Lucas de Vries
347 lines
8.7 KiB
ActionScript
347 lines
8.7 KiB
ActionScript
import planet_types;
|
|
|
|
from planets.PlanetSurface import preparePlanetShader;
|
|
|
|
const double PLANET_DIST_MAX = 4000;
|
|
|
|
enum PlanetSpecial {
|
|
PS_None,
|
|
PS_Asteroids,
|
|
PS_Ring
|
|
};
|
|
|
|
//Draws the physical star, its corona, and a distant star sprite
|
|
final class MoonData {
|
|
uint style = 0;
|
|
float size = 0.f;
|
|
};
|
|
|
|
final class PlanetNodeScript {
|
|
bool Colonized = false;
|
|
const Material@ emptyMat = material::ProceduralPlanet;
|
|
const Material@ colonyMat = material::ProceduralPlanet;
|
|
const Material@ atmosMat;
|
|
const Model@ planetModel;
|
|
PlanetSpecial special = PS_None;
|
|
double ringScale = 1.0, ringAngle = 0.0;
|
|
float ringMin = 0.f, ringMax = 1.f;
|
|
const Material@ ringMat;
|
|
array<MoonData@>@ moons;
|
|
uint gfxFlags = 0;
|
|
Planet@ obj;
|
|
|
|
PlanetNodeScript(Node& node) {
|
|
node.memorable = true;
|
|
node.animInvis = false;
|
|
node.autoCull = false;
|
|
}
|
|
|
|
void set_planetType(Node& node, int planetTypeID) {
|
|
//Cache values for performance
|
|
const PlanetType@ type = getPlanetType(planetTypeID);
|
|
@emptyMat = type.emptyMat;
|
|
@colonyMat = type.colonyMat;
|
|
@planetModel = type.model;
|
|
//@dyingMat = type.dyingMat;
|
|
@atmosMat = type.atmosMat;
|
|
node.transparent = atmosMat !is null;
|
|
}
|
|
|
|
void set_colonized(bool isColonized) {
|
|
Colonized = isColonized;
|
|
}
|
|
|
|
void set_flags(uint newFlags) {
|
|
gfxFlags = newFlags;
|
|
}
|
|
|
|
void establish(Planet@ obj) {
|
|
@this.obj = obj;
|
|
}
|
|
|
|
void addRing(Node& node, uint rnd) {
|
|
node.autoCull = false;
|
|
special = PS_Ring;
|
|
|
|
uint matIndex = rnd % 7;
|
|
rnd /= 7;
|
|
|
|
uint scale = rnd % 256;
|
|
rnd /= 256;
|
|
|
|
uint inner = rnd % 128;
|
|
rnd /= 128;
|
|
|
|
uint outer = rnd % 64;
|
|
rnd /= 64;
|
|
|
|
uint angle = rnd % 64;
|
|
rnd /= 64;
|
|
|
|
ringScale = 1.2 + 2.0 * double(scale) / 1024.0;
|
|
ringMin = double(inner) * 0.9 / 1024.0;
|
|
ringMax = max(1.0 - ((1.0 - ringMin) * double(outer)/1024.0), ringMin + 0.1);
|
|
ringAngle = pi * (-0.07 + (0.14 * double(angle)/64.0));
|
|
|
|
@ringMat = getMaterial("PlanetRing" + (1 + matIndex));
|
|
}
|
|
|
|
void addMoon(Node& node, float size, uint style = 0) {
|
|
if(moons is null)
|
|
@moons = array<MoonData@>();
|
|
MoonData dat;
|
|
dat.size = size;
|
|
dat.style = style;
|
|
moons.insertLast(dat);
|
|
}
|
|
|
|
void giveAsteroids(Node& node) {
|
|
node.autoCull = true;
|
|
special = PS_Asteroids;
|
|
}
|
|
|
|
bool preRender(Node& node) {
|
|
double visScale = node.abs_scale;
|
|
double distScale = 1.0;
|
|
|
|
if(special == PS_Ring) {
|
|
visScale *= ringScale * 1.5;
|
|
}
|
|
if(moons !is null) {
|
|
if(node.sortDistance < 800.0 * node.abs_scale)
|
|
visScale = max(visScale, 100.0 + node.abs_scale);
|
|
}
|
|
if(gfxFlags & PGA_Ringworld != 0)
|
|
distScale = node.abs_scale / 10.0;
|
|
|
|
return node.sortDistance * config::GFX_DISTANCE_MOD < PLANET_DIST_MAX * distScale && isSphereVisible(node.abs_position, visScale);
|
|
}
|
|
|
|
void render(Node& node) {
|
|
if(gfxFlags & PGA_Ringworld != 0) {
|
|
double lodDist = node.sortDistance / (node.abs_scale * pixelSizeRatio);
|
|
node.applyTransform();
|
|
|
|
material::GenericPBR_RingworldOuter.switchTo();
|
|
model::RingworldOuter.draw(lodDist);
|
|
|
|
//Poor man's opposite direction rotation
|
|
applyAbsTransform(vec3d(), vec3d(1.0), node.rotation.inverted());
|
|
applyAbsTransform(vec3d(), vec3d(1.0), node.rotation.inverted());
|
|
material::GenericPBR_RingworldInner.switchTo();
|
|
model::RingworldInner.draw(lodDist);
|
|
undoTransform();
|
|
undoTransform();
|
|
|
|
preparePlanetShader(obj);
|
|
getPlanetMaterial(obj, material::RingworldSurface).switchTo();
|
|
|
|
model::RingworldLiving.draw(lodDist);
|
|
|
|
// material::RingworldAtmo.switchTo();
|
|
// model::RingworldAtmosphere.draw(lodDist);
|
|
|
|
undoTransform();
|
|
return;
|
|
}
|
|
|
|
bool hasAtmos = atmosMat !is null;
|
|
if(hasAtmos && node.sortDistance * config::GFX_DISTANCE_MOD < PLANET_DIST_MAX * pixelSizeRatio * node.abs_scale * 0.25)
|
|
drawBuffers();
|
|
|
|
node.applyTransform();
|
|
|
|
const Material@ baseMat;
|
|
if(Colonized)
|
|
@baseMat = colonyMat;
|
|
else
|
|
@baseMat = emptyMat;
|
|
|
|
preparePlanetShader(obj);
|
|
getPlanetMaterial(obj, baseMat).switchTo();
|
|
planetModel.draw(node.sortDistance / (node.abs_scale * pixelSizeRatio));
|
|
|
|
if(hasAtmos) {
|
|
applyAbsTransform(vec3d(), vec3d(1.015), quaterniond_fromAxisAngle(vec3d_up(), fraction(gameTime / 240.0) * twopi));
|
|
|
|
atmosMat.switchTo();
|
|
//Use the same lod as the planet to avoid weirdness
|
|
model::Sphere_max.draw(node.sortDistance / (node.abs_scale * pixelSizeRatio));
|
|
undoTransform();
|
|
}
|
|
|
|
if(special == PS_Asteroids) {
|
|
material::AsteroidPegmatite.switchTo();
|
|
applyAbsTransform(vec3d(2.0,2.0,2.0), vec3d(0.01), quaterniond());
|
|
model::Asteroid1.draw();
|
|
undoTransform();
|
|
|
|
material::AsteroidMagnetite.switchTo();
|
|
applyAbsTransform(vec3d(2.3,1.5,1.95), vec3d(0.0125), quaterniond_fromAxisAngle(vec3d(0,0.32,-0.1).normalize(), 1.3));
|
|
model::Asteroid2.draw();
|
|
undoTransform();
|
|
|
|
material::AsteroidTonalite.switchTo();
|
|
applyAbsTransform(vec3d(2.4,2.8,2.1), vec3d(0.008), quaterniond_fromAxisAngle(vec3d(1).normalize(), 0.782));
|
|
model::Asteroid3.draw();
|
|
undoTransform();
|
|
}
|
|
else if(special == PS_Ring) {
|
|
auto ringRot = node.abs_rotation.inverted() *
|
|
quaterniond_fromAxisAngle(vec3d_front(), ringAngle) *
|
|
quaterniond_fromAxisAngle(vec3d_up(), ((gameTime / 30.0) % (2.0 * pi)));
|
|
|
|
vec3d starDir = node.parent.abs_position - node.abs_position;
|
|
starDir = (node.abs_rotation * ringRot).inverted() * starDir;
|
|
|
|
shader::STAR_DIRECTION = vec2f(starDir.x, starDir.z);
|
|
shader::PLANET_RING_RATIO = 1.0 / ringScale;
|
|
shader::RING_MIN = ringMin;
|
|
shader::RING_MAX = ringMax;
|
|
|
|
applyAbsTransform(vec3d(), vec3d(ringScale), ringRot);
|
|
ringMat.switchTo();
|
|
model::PlanetRing.draw();
|
|
undoTransform();
|
|
}
|
|
|
|
//if(gfxFlags & PGA_SpaceElevator != 0) {
|
|
//TODO
|
|
//}
|
|
|
|
undoTransform();
|
|
|
|
if(moons !is null && node.sortDistance < 800.0 * node.abs_scale) {
|
|
for(uint i = 0, cnt = moons.length; i < cnt; ++i) {
|
|
auto@ dat = moons[i];
|
|
|
|
uint st = dat.style;
|
|
double rot = fraction(gameTime / (1.0 + 12.0 * double(st % 256) / 255.0)) * twopi;
|
|
st >>= 8;
|
|
double angle = fraction(gameTime / (10.0 + 40.0 * double(st % 256) / 255.0)) * twopi;
|
|
st >>= 8;
|
|
double distance = double(st % 256) / 255.0 * 7.0 + 2.0;
|
|
st >>= 8;
|
|
vec3d offset = quaterniond_fromAxisAngle(vec3d_up(), angle) * vec3d_front(distance * node.abs_scale);
|
|
|
|
applyTransform(node.abs_position + offset, vec3d(dat.size), quaterniond_fromAxisAngle(vec3d_up(), rot));
|
|
material::ProceduralMoon.switchTo();
|
|
model::Moon_Sphere_max.draw(node.sortDistance / (dat.size * pixelSizeRatio));
|
|
undoTransform();
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
class DynTex {
|
|
DynamicTexture@ tex;
|
|
Object@ obj;
|
|
double lastRender = 0.0;
|
|
uint modId = uint(-1);
|
|
const Material@ baseMat;
|
|
double delay = 0;
|
|
|
|
DynTex() {
|
|
@tex = DynamicTexture();
|
|
}
|
|
|
|
void cache(Object& obj, const Material@ baseMat) {
|
|
if(!obj.valid)
|
|
return;
|
|
if(this.obj is obj && modId == obj.surfaceModId && baseMat is this.baseMat)
|
|
return;
|
|
if(modId != uint(-1) && frameTime < delay && this.obj is obj && baseMat is this.baseMat)
|
|
return;
|
|
|
|
@this.obj = obj;
|
|
@this.baseMat = baseMat;
|
|
|
|
vec2u size = vec2u(obj.originalGridSize);
|
|
if(size.x == 0 || size.y == 0) {
|
|
@this.obj = null;
|
|
return;
|
|
}
|
|
|
|
Image img(size, 4);
|
|
|
|
uint shown = obj.getSurfaceData(img);
|
|
modId = shown;
|
|
if(shown == uint(-1)) {
|
|
@this.obj = null;
|
|
return;
|
|
}
|
|
|
|
const Texture@ prevTex = tex.material.texture7;
|
|
tex.material = baseMat;
|
|
@tex.material.texture7 = prevTex;
|
|
@tex.image[7] = img;
|
|
delay = frameTime + 1.0;
|
|
}
|
|
|
|
const Material@ get_material() {
|
|
if(obj is null)
|
|
return null;
|
|
tex.stream();
|
|
lastRender = frameTime;
|
|
return tex.material;
|
|
}
|
|
|
|
void switchTo() {
|
|
if(obj is null)
|
|
return;
|
|
tex.stream();
|
|
tex.material.switchTo();
|
|
lastRender = frameTime;
|
|
}
|
|
};
|
|
|
|
const uint MIN_CACHED = 8;
|
|
const uint MAX_CACHED = 32;
|
|
const double DISCARD_TIME = 2.0;
|
|
array<DynTex@> cachedTextures;
|
|
|
|
DynTex@ getPlanetMaterial(Object& obj, const Material@ baseMat) {
|
|
DynTex@ tex;
|
|
|
|
//Check if we already have this planet in our cache
|
|
for(uint i = 0, cnt = cachedTextures.length; i < cnt; ++i) {
|
|
if(cachedTextures[i].obj is obj) {
|
|
@tex = cachedTextures[i];
|
|
break;
|
|
}
|
|
}
|
|
|
|
//Check if there's any old caches we can override
|
|
if(tex is null && cachedTextures.length > MIN_CACHED) {
|
|
for(uint i = 0, cnt = cachedTextures.length; i < cnt; ++i) {
|
|
if(frameTime - cachedTextures[i].lastRender > DISCARD_TIME) {
|
|
@tex = cachedTextures[i];
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
//Check if we can create a new cache
|
|
if(tex is null && cachedTextures.length < MAX_CACHED) {
|
|
@tex = DynTex();
|
|
cachedTextures.insertLast(tex);
|
|
}
|
|
|
|
//Forcefully override the least recently used cache
|
|
if(tex is null) {
|
|
double bestTime = INFINITY;
|
|
for(uint i = 0, cnt = cachedTextures.length; i < cnt; ++i) {
|
|
double rt = cachedTextures[i].lastRender;
|
|
if(rt < bestTime) {
|
|
@tex = cachedTextures[i];
|
|
bestTime = rt;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
tex.cache(obj, baseMat);
|
|
return tex;
|
|
}
|
|
|