private void UpdateMaterial()
{
var targetStarfieldTechnique = "Variant";
if (starfieldMaterial != null && starfieldTechnique != targetStarfieldTechnique)
{
starfieldMaterial = SGT_Helper.DestroyObject(starfieldMaterial);
}
// New material?
if (starfieldMaterial == null)
{
starfieldTechnique = targetStarfieldTechnique;
starfieldMaterial = SGT_Helper.CreateMaterial("Hidden/SGT/Starfield/" + starfieldTechnique, starfieldRenderQueue);
}
else
{
SGT_Helper.SetRenderQueue(starfieldMaterial, starfieldRenderQueue);
}
}
public void LateUpdate() // TODO: Check mesh size
{
if (skysphereGameObject == null)
{
skysphereGameObject = SGT_Helper.CreateGameObject("Skysphere", gameObject);
}
if (skysphereMesh == null)
{
skysphereMesh = new SGT_Mesh();
}
if (skysphereObserver == null)
{
skysphereObserver = SGT_Helper.FindCamera();
}
SGT_Helper.SetParent(skysphereGameObject, gameObject);
SGT_Helper.SetLayer(skysphereGameObject, gameObject.layer);
SGT_Helper.SetTag(skysphereGameObject, gameObject.tag);
UpdateMaterial();
UpdateShader();
if (skysphereObserver != null)
{
// Stretch to camera's far view frustum
SGT_Helper.SetLocalScale(skysphereGameObject.transform, skysphereObserver.far * 0.9f);
// Centre to main camera
SGT_Helper.SetPosition(skysphereGameObject.transform, skysphereObserver.transform.position);
}
skysphereMesh.GameObject = skysphereGameObject;
skysphereMesh.HasMeshRenderer = true;
skysphereMesh.MeshRendererEnabled = true;
skysphereMesh.SharedMaterial = skysphereMaterial;
skysphereMesh.Update();
#if UNITY_EDITOR == true
skysphereMesh.HideInEditor();
#endif
}
public void Awake()
{
var instances = SGT_Helper.FindAll <T>();
if (instances.Length > 1)
{
Debug.LogWarning("An instance of " + typeof(T).Name + " already exists!");
Debug.Log("Removing other " + (instances.Length - 1) + " instance(s) of " + typeof(T).Name);
// Destroy other instances
foreach (var i in instances)
{
if (i != this)
{
SGT_Helper.DestroyObject(i);
}
}
}
instance = (T)this;
}
private void UpdateGradient()
{
if (atmosphereLightingColour.Modified == true || atmosphereTwilightColour.Modified == true || atmosphereLimbColour.Modified == true)
{
lightingTexture = SGT_Helper.DestroyObject(lightingTexture);
}
atmosphereLightingColour.Modified = false;
atmosphereTwilightColour.Modified = false;
atmosphereLimbColour.Modified = false;
if (lightingTexture == null)
{
var lightingColours = atmosphereLightingColour.CalculateColours(0.0f, 1.0f, (int)lutSize);
var twilightColours = atmosphereTwilightColour.CalculateColours(0.0f, 1.0f, (int)lutSize);
var limbColours = atmosphereLimbColour.CalculateColours(0.0f, 1.0f, (int)lutSize);
lightingTexture = SGT_ColourGradient.AllocateTexture((int)lutSize, (int)lutSize);
for (var y = 0; y < (int)lutSize; y++)
{
var limbPixel = limbColours[y];
for (var x = 0; x < (int)lutSize; x++)
{
var lightingPixel = lightingColours[x];
var twilightPixel = twilightColours[x];
var colour = Color.white;
colour = SGT_Helper.AlphaBlend(colour, twilightPixel);
colour = SGT_Helper.AlphaBlend(colour, limbPixel);
colour = colour * lightingPixel;
lightingTexture.SetPixel(x, y, colour);
}
}
lightingTexture.Apply();
}
}
public void Regenerate()
{
if (modified == true)
{
DestroyGeneratedMeshes();
if (starVariants.Count > 0)
{
SGT_Helper.BeginRandomSeed(starfieldSeed);
{
RecalculateCoords();
RecalculateWeights();
var remainingStars = starfieldStarCount;
var starsPerMesh = SGT_Helper.MeshVertexLimit / 4;
var newMeshes = new MeshList();
while (remainingStars > 0)
{
var starsInMesh = Mathf.Min(remainingStars, starsPerMesh);
newMeshes.Add(GenerateStarMesh(starfieldStarCount - remainingStars, starsInMesh));
remainingStars -= starsInMesh;
}
meshes = newMeshes.ToArray();
if (starfieldMultiMesh != null)
{
starfieldMultiMesh.ReplaceAll(meshes);
starfieldMultiMesh.Update();
}
}
SGT_Helper.EndRandomSeed();
}
modified = false;
}
}
public void LateUpdate()
{
if (coronaGameObject == null)
{
coronaGameObject = SGT_Helper.CreateGameObject("Corona", gameObject);
}
if (coronaMesh == null)
{
coronaMesh = new SGT_Mesh();
}
if (coronaObserver == null)
{
coronaObserver = SGT_Helper.FindCamera();
}
SGT_Helper.SetParent(coronaGameObject, gameObject);
SGT_Helper.SetLayer(coronaGameObject, gameObject.layer);
SGT_Helper.SetTag(coronaGameObject, gameObject.tag);
if (coronaAutoRegen == true)
{
Regenerate();
}
UpdateMaterial();
UpdateShader();
UpdateCoronaOffset();
coronaMesh.GameObject = coronaGameObject;
coronaMesh.HasMeshRenderer = true;
coronaMesh.MeshRendererEnabled = true;
coronaMesh.SharedMaterial = coronaMaterial;
coronaMesh.SharedMesh = generatedMesh;
coronaMesh.Update();
#if UNITY_EDITOR == true
coronaMesh.HideInEditor();
#endif
}
private void UpdateRenderQueues()
{
if (materials == null)
{
materials = new MaterialList();
}
if (renderQueues == null)
{
renderQueues = new IntList();
}
if (materials.Count != renderQueues.Count)
{
materials.Clear();
renderQueues.Clear();
}
for (var i = 0; i < materials.Count; i++)
{
SGT_Helper.SetRenderQueue(materials[i], renderQueues[i]);
}
}
public void Update()
{
if (orbit == true)
{
if (Application.isPlaying == true)
{
orbitAngle += SGT_Helper.RadiansPerSecond(orbitPeriod) * Time.deltaTime;
}
var targetPosition = SGT_Helper.PolarToCartesian(new Vector2(orbitAngle, 0.0f)) * orbitDistance; targetPosition.x *= (1.0f - orbitOblateness);
SGT_Helper.SetLocalPosition(transform, targetPosition);
}
if (rotation == true)
{
if (Application.isPlaying == true)
{
transform.Rotate(rotationAxis, SGT_Helper.DegreesPerSecond(rotationPeriod) * Time.deltaTime, Space.Self);
}
}
}
public void Regenerate()
{
if (modified == false)
{
CheckForModifications();
}
if (modified == true)
{
modified = false;
SGT_Helper.DestroyObjects(generatedMeshes);
SGT_Helper.BeginRandomSeed(ringSeed);
{
var remainingAsteroids = ringAsteroidCount;
var asteroidsPerMesh = SGT_Helper.MeshVertexLimit / 4;
var newMeshes = new MeshList();
while (remainingAsteroids > 0)
{
var asteroidsInMesh = Mathf.Min(remainingAsteroids, asteroidsPerMesh);
newMeshes.Add(GenerateAsteroidMesh(asteroidsInMesh));
remainingAsteroids -= asteroidsInMesh;
}
generatedMeshes = newMeshes.ToArray();
if (ringMultiMesh != null)
{
ringMultiMesh.ReplaceAll(generatedMeshes);
ringMultiMesh.Update();
}
}
SGT_Helper.EndRandomSeed();
}
}
private void UpdateShader()
{
var uniformScale = UniformScale;
// Update shader variables
coronaMaterial.SetTexture("coronaTexture", coronaTexture);
coronaMaterial.SetVector("coronaPosition", transform.position);
coronaMaterial.SetColor("coronaColour", SGT_Helper.Premultiply(coronaColour));
coronaMaterial.SetFloat("coronaFalloff", coronaFalloff * coronaFalloff);
if (cullNear == true)
{
coronaMaterial.SetFloat("cullNearOffset", cullNearOffset * uniformScale);
coronaMaterial.SetFloat("invCullNearLength", SGT_Helper.Reciprocal(cullNearLength * uniformScale));
}
if (meshType == Type.Ring)
{
coronaMaterial.SetFloat("coronaRadius", meshRadius * uniformScale);
coronaMaterial.SetFloat("coronaHeight", meshHeight * uniformScale);
}
}
private void UpdateMaterial()
{
var targetTechnique = "Variant";
if (tiled == false)
{
targetTechnique += "Stretched";
}
if (shadow == true)
{
targetTechnique += "Shadow";
}
if (lit == true)
{
targetTechnique += "Lit";
}
if (scattering == true)
{
targetTechnique += "Scattering";
}
if (ringMaterial == null || technique != targetTechnique)
{
SGT_Helper.DestroyObject(ringMaterial);
technique = targetTechnique;
ringMaterial = SGT_Helper.CreateMaterial("Hidden/SGT/Ring/" + technique, renderQueue);
ringMesh.SharedMaterial = ringMaterial;
}
else
{
SGT_Helper.SetRenderQueue(ringMaterial, renderQueue);
}
}
public void LateUpdate()
{
if (starfieldGameObject == null)
{
starfieldGameObject = SGT_Helper.CreateGameObject("Starfield", gameObject);
}
if (starfieldMultiMesh == null)
{
starfieldMultiMesh = new SGT_MultiMesh();
}
if (starfieldCamera == null)
{
StarfieldCamera = SGT_Helper.FindCamera(); // NOTE: Assigning property
}
SGT_Helper.SetParent(starfieldGameObject, gameObject);
SGT_Helper.SetLayer(starfieldGameObject, gameObject.layer);
SGT_Helper.SetTag(starfieldGameObject, gameObject.tag);
if (starfieldAutoRegen == true)
{
Regenerate();
}
UpdateMaterial();
UpdateShader();
UpdateBackground();
starfieldMultiMesh.GameObject = starfieldGameObject;
starfieldMultiMesh.HasMeshRenderers = true;
starfieldMultiMesh.MeshRenderersEnabled = true;
starfieldMultiMesh.SharedMaterial = starfieldMaterial;
starfieldMultiMesh.ReplaceAll(meshes);
starfieldMultiMesh.Update();
#if UNITY_EDITOR == true
starfieldMultiMesh.HideInEditor();
#endif
}
private void UpdateRingRotations()
{
if (generatedRotations != null && generatedRotations.Length > 0)
{
ringMesh.Resize(generatedRotations.Length);
ringMesh.Update();
for (var i = 0; i < generatedRotations.Length; i++)
{
var meshRoot = ringMesh.GetMeshGameObject(i);
if (meshRoot != null)
{
SGT_Helper.SetLocalRotation(meshRoot.transform, generatedRotations[i]);
}
}
}
else
{
ringMesh.Resize(1);
ringMesh.Update();
}
}
public void Regenerate()
{
if (dustModified == false)
{
CheckForModifications();
}
if (dustModified == true)
{
Validate();
dustModified = false;
var particles = new ParticleList();
SGT_Helper.BeginRandomSeed(dustSeed);
{
for (var y = 0; y < dustCount; y++)
{
var p = new Particle();
var posX = Random.Range(0.0f, 1.0f);
var posY = Random.Range(0.0f, 1.0f);
var posZ = Random.Range(0.0f, 1.0f);
p.Position = new Vector3(posX, posY, posZ);
p.Size = particleScale;
p.Colour = Color.white * particleColour;
p.Angle = Random.value * 360.0f;
particles.Add(p);
}
}
SGT_Helper.EndRandomSeed();
CreateMesh(particles);
}
}
public Vector3 ForceAtPoint(Vector3 xyz)
{
var newForce = transform.position - xyz;
if (newForce.sqrMagnitude > 0.0f)
{
switch (gravitySourceType)
{
case GravityType.Linear:
{
newForce = newForce.normalized * SGT_Helper.RemapClamped(gravitySourceRadius, gravitySourceRadius + gravitySourceHeight, newForce.magnitude, 0.0f, gravitySourceForce);
}
break;
case GravityType.Exponential:
{
newForce = (newForce / newForce.sqrMagnitude) * gravitySourceForce;
}
break;
}
}
return(newForce);
}
private void MoveShaders(bool sync)
{
var dummyMaterial = new Material(Shader.Find("Diffuse"));
UnityEditorInternal.InternalEditorUtility.SetupShaderMenu(dummyMaterial);
var shaders = (Shader[])Resources.FindObjectsOfTypeAll(typeof(Shader));
dummyMaterial = SGT_Helper.DestroyObject(dummyMaterial);
var includedShaders = sync ? IncludedShaders() : null;
foreach (var shader in shaders)
{
if (shader.name.Contains("Hidden/SGT/") == true)
{
var include = true;
if (sync == true)
{
var index = includedShaders.IndexOf(shader);
if (index != -1)
{
includedShaders.RemoveAt(index);
}
else
{
include = false;
}
}
MoveShader(shader, include);
}
}
}
public void FixedUpdate()
{
if (thrusterPhysics == true)
{
if (thrusterPhysicsRigidbody == null)
{
thrusterPhysicsRigidbody = SGT_Helper.GetComponentUpwards <Rigidbody>(gameObject);
}
if (thrusterPhysicsRigidbody != null && targetThrusterThrottle != 0.0f)
{
var force = -transform.forward * thrusterPhysicsForce * targetThrusterThrottle * Time.fixedDeltaTime;
switch (thrusterPhysicsForceType)
{
case ForceType.AddForce: thrusterPhysicsRigidbody.AddForce(force, thrusterPhysicsForceMode); break;
case ForceType.AddForceAtPosition: thrusterPhysicsRigidbody.AddForceAtPosition(force, transform.position, thrusterPhysicsForceMode); break;
case ForceType.AddRelativeForce: thrusterPhysicsRigidbody.AddRelativeForce(force, thrusterPhysicsForceMode); break;
}
}
}
}
private void UpdateGradient()
{
if (atmosphereDensityColour.Modified == true)
{
atmosphereTexture = SGT_Helper.DestroyObject(atmosphereTexture);
}
atmosphereDensityColour.Modified = false;
if (atmosphereTexture == null)
{
atmosphereDensityColour.Modified = false;
SGT_Helper.DestroyObject(atmosphereTexture);
SGT_Helper.DestroyObject(atmosphereSurfaceTexture);
var density = atmosphereDensityColour.CalculateColours(1.0f, 0.5f, (int)lutSize);
var surfaceDensity = atmosphereDensityColour.CalculateColours(0.0f, 0.5f, (int)lutSize);
atmosphereTexture = SGT_ColourGradient.AllocateTexture((int)lutSize);
atmosphereSurfaceTexture = SGT_ColourGradient.AllocateTexture((int)lutSize);
for (var x = 0; x < (int)lutSize; x++)
{
atmosphereTexture.SetPixel(x, 0, density[x]);
}
for (var x = 0; x < (int)lutSize; x++)
{
atmosphereSurfaceTexture.SetPixel(x, 0, surfaceDensity[x]);
}
atmosphereTexture.Apply();
atmosphereSurfaceTexture.Apply();
}
}
private void Validate()
{
if (dust == null)
{
dust = SGT_Helper.CreateGameObject("Dust", this);
}
if (dustMesh == null)
{
dustMesh = new SGT_Mesh();
}
if (dustMaterial == null)
{
dustMaterial = SGT_Helper.CreateMaterial("Hidden/SGT/Dust/" + dustTechnique);
}
SGT_Helper.SetParent(dust, gameObject);
SGT_Helper.SetLayer(dust, gameObject.layer);
SGT_Helper.SetTag(dust, gameObject.tag);
var finalColour = SGT_Helper.Premultiply(particleColour);
dustMaterial.SetTexture("dustTexture", particleTexture);
dustMaterial.SetFloat("dustRadius", dustRadius);
dustMaterial.SetColor("particleColour", finalColour);
dustMaterial.SetFloat("particleFadeInDistance", dustRadius / particleFadeInDistance);
dustMaterial.SetFloat("particleFadeOutDistance", dustRadius / particleFadeOutDistance);
SGT_Helper.SetRenderQueue(dustMaterial, dustRenderQueue);
dustMesh.GameObject = dust;
dustMesh.HasMeshRenderer = true;
dustMesh.MeshRendererEnabled = SGT_Helper.IsBlack(finalColour) == false;
dustMesh.SharedMesh = generatedMesh;
dustMesh.SharedMaterial = dustMaterial;
dustMesh.Update();
}
private void UpdateGradient()
{
// See if any gradient has been modified
if (planetLighting.Modified == true)
{
planetLighting.Modified = false;
surfaceLightingTexture = SGT_Helper.DestroyObject(surfaceLightingTexture);
atmosphereTexture = SGT_Helper.DestroyObject(atmosphereTexture);
atmosphereSurfaceTexture = SGT_Helper.DestroyObject(atmosphereSurfaceTexture);
cloudsLightingTexture = SGT_Helper.DestroyObject(cloudsLightingTexture);
}
if (atmosphereTwilightColour.Modified == true)
{
atmosphereTwilightColour.Modified = false;
atmosphereTexture = SGT_Helper.DestroyObject(atmosphereTexture);
atmosphereSurfaceTexture = SGT_Helper.DestroyObject(atmosphereSurfaceTexture);
cloudsLightingTexture = SGT_Helper.DestroyObject(cloudsLightingTexture);
}
if (atmosphereDensityColour.Modified == true)
{
atmosphereDensityColour.Modified = false;
atmosphereTexture = SGT_Helper.DestroyObject(atmosphereTexture);
atmosphereSurfaceTexture = SGT_Helper.DestroyObject(atmosphereSurfaceTexture);
}
if (cloudsLimbColour.Modified == true)
{
cloudsLimbColour.Modified = false;
cloudsLightingTexture = SGT_Helper.DestroyObject(cloudsLightingTexture);
}
// Build colour arrays
var lighting = surfaceLightingTexture == null || atmosphereTexture == null || atmosphereSurfaceTexture == null || cloudsLightingTexture == null?planetLighting.CalculateColours(0.0f, 1.0f, (int)planetLutSize) : null;
var twilight = atmosphereTexture == null || atmosphereSurfaceTexture == null?atmosphereTwilightColour.CalculateColours(0.0f, 1.0f, (int)planetLutSize) : null;
var cloudsTwilight = cloudsLightingTexture == null?atmosphereTwilightColour.CalculateColours(cloudsTwilightOffset, cloudsTwilightOffset + 1.0f, (int)planetLutSize) : null;
var density = atmosphereTexture == null?atmosphereDensityColour.CalculateColours(1.0f, 0.5f, (int)planetLutSize) : null;
var surfaceDensity = atmosphereSurfaceTexture == null?atmosphereDensityColour.CalculateColours(0.0f, 0.5f, (int)planetLutSize) : null;
var cloudsLimb = cloudsLightingTexture == null?cloudsLimbColour.CalculateColours(0.0f, 1.0f, (int)planetLutSize) : null;
// Rebuild textures
if (surfaceLightingTexture == null)
{
updateShader |= ShaderFlags.SurfaceTextureLighting;
surfaceLightingTexture = SGT_ColourGradient.AllocateTexture((int)planetLutSize);
for (var x = 0; x < (int)planetLutSize; x++)
{
surfaceLightingTexture.SetPixel(x, 0, lighting[x]);
}
surfaceLightingTexture.anisoLevel = 8;
surfaceLightingTexture.filterMode = FilterMode.Trilinear;
surfaceLightingTexture.Apply();
}
if (atmosphereTexture == null)
{
updateShader |= ShaderFlags.AtmosphereTexture;
atmosphereTexture = SGT_ColourGradient.AllocateTexture((int)planetLutSize, (int)planetLutSize);
for (var y = 0; y < (int)planetLutSize; y++)
{
var densityColour = density[y];
for (var x = 0; x < (int)planetLutSize; x++)
{
var lightingColour = lighting[x];
//var twilightColour = twilight[x];
lightingColour.a = Mathf.Lerp(atmosphereNightOpacity, 1.0f, lightingColour.grayscale);
//var colour = SGT_Helper.AlphaBlend(densityColour, twilightColour) * lightingColour;
var twilightColour = SGT_Helper.AlphaBlend(Color.white, twilight[x]);
var colour = SGT_Helper.BlendRGB(densityColour * lightingColour, twilightColour, SGT_Helper.ChannelBlendMode.Multiply);
atmosphereTexture.SetPixel(x, y, SGT_Helper.PreventZeroRGB(colour));
atmosphereTexture.filterMode = FilterMode.Trilinear;
}
}
atmosphereTexture.Apply();
}
if (atmosphereSurfaceTexture == null)
{
updateShader |= ShaderFlags.SurfaceTextureAtmosphere;
atmosphereSurfaceTexture = SGT_ColourGradient.AllocateTexture((int)planetLutSize, (int)planetLutSize);
for (var y = 0; y < (int)planetLutSize; y++)
{
var densityColour = surfaceDensity[y];
for (var x = 0; x < (int)planetLutSize; x++)
{
var lightingColour = lighting[x];
var twilightColour = twilight[x];
lightingColour.a = Mathf.Lerp(atmosphereNightOpacity, 1.0f, lightingColour.grayscale);
var colour = SGT_Helper.AlphaBlend(densityColour, twilightColour) * lightingColour;
atmosphereSurfaceTexture.SetPixel(x, y, SGT_Helper.PreventZeroRGB(colour));
atmosphereSurfaceTexture.filterMode = FilterMode.Trilinear;
}
}
atmosphereSurfaceTexture.Apply();
}
if (cloudsLightingTexture == null)
{
updateShader |= ShaderFlags.CloudsTextureLighting;
cloudsLightingTexture = SGT_ColourGradient.AllocateTexture((int)planetLutSize, (int)planetLutSize);
for (var y = 0; y < (int)planetLutSize; y++)
{
var limb = cloudsLimb[y];
for (var x = 0; x < (int)planetLutSize; x++)
{
var colour = lighting[x];
if (atmosphere == true)
{
colour *= SGT_Helper.AlphaBlend(limb, cloudsTwilight[x]);
}
else
{
colour *= limb;
}
cloudsLightingTexture.SetPixel(x, y, colour);
cloudsLightingTexture.filterMode = FilterMode.Trilinear;
}
}
cloudsLightingTexture.Apply();
}
}
private void UpdateShader()
{
var starDirection = planetLightSource != null ? (planetLightSource.transform.position - transform.position).normalized : Vector3.up;
var lightSourcePosition = planetLightSource != null ? planetLightSource.transform.position : Vector3.zero;
var transformPosition = transform.position;
var uniformScale = UniformScale;
var observerPosition = planetObserver != null ? planetObserver.transform.position : Vector3.zero;
var distance = (observerPosition - transformPosition).magnitude;
float maxSurfaceDepth, maxAtmosphereDepth;
SGT_Helper.CalculateHorizonAtmosphereDepth(surfaceRadius * uniformScale, AtmosphereRadius * uniformScale, distance, out maxSurfaceDepth, out maxAtmosphereDepth);
// Common shader variables
SGT_ShaderHelper.SetVector(surfaceMaterials, "centrePosition", transformPosition);
SGT_ShaderHelper.SetVector(surfaceMaterials, "starDirection", starDirection);
if (surfaceTextureNormal != null)
{
var starDirectionM = surfaceGameObject.transform.worldToLocalMatrix.MultiplyVector(starDirection).normalized;
SGT_ShaderHelper.SetVector(surfaceMaterials, "starDirectionM", starDirectionM);
}
if (atmosphereMaterial != null)
{
var altitudeUnclamped = distance - surfaceRadius * uniformScale;
var altitude = Mathf.Clamp(altitudeUnclamped, 0.0f, atmosphereHeight * uniformScale);
var atmoAlt = SGT_Helper.RemapClamped(atmosphereHeight * uniformScale * atmosphereSkyAltitude, atmosphereHeight * uniformScale, altitude, 0.0f, 1.0f);
SGT_ShaderHelper.SetFloat(surfaceMaterials, "maxDepth", maxSurfaceDepth * (1.0f - atmosphereFog)); // FOG
atmosphereMaterial.SetFloat("maxDepth", maxAtmosphereDepth);
atmosphereMaterial.SetVector("centrePosition", transformPosition);
atmosphereMaterial.SetVector("starDirection", starDirection);
atmosphereMaterial.SetFloat("atmosphereFalloff", Mathf.SmoothStep(atmosphereFalloffInside, atmosphereFalloffOutside, atmoAlt));
if (atmosphereScattering == true)
{
SGT_ShaderHelper.SetVector(surfaceMaterials, "starPosition", lightSourcePosition);
atmosphereMaterial.SetVector("starPosition", lightSourcePosition);
}
}
if (cloudsMaterials != null)
{
SGT_ShaderHelper.SetVector(cloudsMaterials, "centrePosition", transformPosition);
SGT_ShaderHelper.SetVector(cloudsMaterials, "starDirection", starDirection);
}
if (shadow == true)
{
var shadowMatrix = Matrix4x4.identity;
switch (shadowCasterType)
{
case SGT_ShadowOccluder.Planet:
{
if (shadowCasterGameObject != null)
{
shadowMatrix = SGT_Helper.CalculateSphereShadowMatrix(ShadowCasterRadiusOuter, shadowCasterGameObject.transform.position, lightSourcePosition, transformPosition, uniformScale);
}
}
break;
case SGT_ShadowOccluder.Ring:
{
shadowMatrix = SGT_Helper.CalculateCircleShadowMatrix(ShadowCasterRadiusOuter, transform.position, transform.up, lightSourcePosition, transformPosition, uniformScale);
}
break;
}
SGT_ShaderHelper.SetMatrix(surfaceMaterials, "shadowMatrix", shadowMatrix);
if (atmosphereMaterial != null)
{
atmosphereMaterial.SetMatrix("shadowMatrix", shadowMatrix);
}
if (cloudsMaterials != null)
{
SGT_ShaderHelper.SetMatrix(cloudsMaterials, "shadowMatrix", shadowMatrix);
}
}
// Uncommon shader variables
if (SGT_Helper.FlagIsSet(updateShader, ShaderFlags.ShadowSettings) == true)
{
var cutoff = ShadowCasterRadiusInner / ShadowCasterRadiusOuter;
var invCutoff = SGT_Helper.Reciprocal(1.0f - cutoff);
var shadowValues = new Vector3(cutoff, invCutoff, 1.0f + ShadowCasterRadiusOuter);
SGT_ShaderHelper.SetVector(surfaceMaterials, "shadowValues", shadowValues);
if (atmosphereMaterial != null)
{
atmosphereMaterial.SetVector("shadowValues", shadowValues);
}
if (cloudsMaterials != null)
{
SGT_ShaderHelper.SetVector(cloudsMaterials, "shadowValues", shadowValues);
}
}
if (SGT_Helper.FlagIsSet(updateShader, ShaderFlags.SurfaceTextureDay) == true)
{
for (var i = 0; i < surfaceMaterials.Length; i++)
{
surfaceMaterials[i].SetTexture("dayTexture", surfaceTextureDay.GetTexture((CubemapFace)i));
}
}
if (SGT_Helper.FlagIsSet(updateShader, ShaderFlags.SurfaceTextureNight) == true)
{
for (var i = 0; i < surfaceMaterials.Length; i++)
{
surfaceMaterials[i].SetTexture("nightTexture", surfaceTextureNight.GetTexture((CubemapFace)i));
}
}
if (SGT_Helper.FlagIsSet(updateShader, ShaderFlags.SurfaceTextureNormal) == true)
{
for (var i = 0; i < surfaceMaterials.Length; i++)
{
surfaceMaterials[i].SetTexture("normalTexture", surfaceTextureNormal.GetTexture((CubemapFace)i));
}
}
if (SGT_Helper.FlagIsSet(updateShader, ShaderFlags.SurfaceTextureSpecular) == true)
{
for (var i = 0; i < surfaceMaterials.Length; i++)
{
surfaceMaterials[i].SetTexture("specularTexture", surfaceTextureSpecular.GetTexture((CubemapFace)i));
}
}
if (SGT_Helper.FlagIsSet(updateShader, ShaderFlags.SurfaceSpecularSettings) == true)
{
SGT_ShaderHelper.SetFloat(surfaceMaterials, "specularPower", surfaceSpecularPower * surfaceSpecularPower);
}
if (SGT_Helper.FlagIsSet(updateShader, ShaderFlags.SurfaceTextureDetail) == true)
{
SGT_ShaderHelper.SetTexture(surfaceMaterials, "detailTexture", surfaceTextureDetail);
SGT_ShaderHelper.SetFloat(surfaceMaterials, "detailRepeat", surfaceDetailRepeat);
}
if (SGT_Helper.FlagIsSet(updateShader, ShaderFlags.SurfaceTextureLighting) == true)
{
SGT_ShaderHelper.SetTexture(surfaceMaterials, "lightingTexture", surfaceLightingTexture);
}
if (SGT_Helper.FlagIsSet(updateShader, ShaderFlags.SurfaceTextureShadow) == true)
{
SGT_ShaderHelper.SetTexture(surfaceMaterials, "shadowTexture", shadowTextureSurface);
}
if (atmosphereMaterial != null)
{
SGT_ShaderHelper.SetFloat(surfaceMaterials, "atmosphereRadius", AtmosphereRadius * uniformScale);
SGT_ShaderHelper.SetFloat(surfaceMaterials, "atmosphereFalloff", atmosphereFalloffSurface);
SGT_ShaderHelper.SetFloat(surfaceMaterials, "surfaceRadius", surfaceRadius * uniformScale);
SGT_ShaderHelper.SetFloat(surfaceMaterials, "atmosphereHeight", atmosphereHeight * uniformScale);
if (SGT_Helper.FlagIsSet(updateShader, ShaderFlags.SurfaceTextureAtmosphere) == true)
{
SGT_ShaderHelper.SetTexture(surfaceMaterials, "atmosphereTexture", atmosphereSurfaceTexture);
}
if (SGT_Helper.FlagIsSet(updateShader, ShaderFlags.AtmosphereTexture) == true)
{
atmosphereMaterial.SetTexture("atmosphereTexture", atmosphereTexture);
}
if (SGT_Helper.FlagIsSet(updateShader, ShaderFlags.AtmosphereTextureShadow) == true)
{
atmosphereMaterial.SetTexture("shadowTexture", shadowTextureAtmosphere);
}
if (SGT_Helper.FlagIsSet(updateShader, ShaderFlags.ScatteringSettings) == true)
{
var mie = -(1.0f - 1.0f / Mathf.Pow(10.0f, atmosphereScatteringMie * 5.0f));
var mie4 = new Vector4(mie * 2.0f, 1.0f - mie * mie, 1.0f + mie * mie, 1.5f);
var ray2 = new Vector2(0.0f, atmosphereScatteringRayleigh);
SGT_ShaderHelper.SetVector(surfaceMaterials, "rayleighValues", ray2);
atmosphereMaterial.SetVector("mieValues", mie4);
atmosphereMaterial.SetVector("rayleighValues", ray2);
}
}
if (cloudsMaterials != null)
{
if (SGT_Helper.FlagIsSet(updateShader, ShaderFlags.CloudsTextureShadow) == true)
{
SGT_ShaderHelper.SetTexture(cloudsMaterials, "shadowTexture", shadowTextureClouds);
}
if (SGT_Helper.FlagIsSet(updateShader, ShaderFlags.CloudsTexture) == true)
{
for (var i = 0; i < cloudsMaterials.Length; i++)
{
cloudsMaterials[i].SetTexture("cloudsTexture", cloudsTexture.GetTexture((CubemapFace)i));
}
}
if (SGT_Helper.FlagIsSet(updateShader, ShaderFlags.CloudsTextureLighting) == true)
{
SGT_ShaderHelper.SetTexture(cloudsMaterials, "lightingTexture", cloudsLightingTexture);
}
if (SGT_Helper.FlagIsSet(updateShader, ShaderFlags.CloudsFalloffSettings) == true)
{
SGT_ShaderHelper.SetFloat(cloudsMaterials, "falloff", cloudsFalloff * cloudsFalloff);
}
}
updateShader = 0;
}
public void LateUpdate()
{
if (oblatenessGameObject == null)
{
oblatenessGameObject = SGT_Helper.CreateGameObject("Oblateness", gameObject);
}
if (atmosphereGameObject == null)
{
atmosphereGameObject = SGT_Helper.CreateGameObject("Atmosphere", oblatenessGameObject);
}
if (atmosphereMesh == null)
{
atmosphereMesh = new SGT_Mesh();
}
if (gasGiantLightSource == null)
{
gasGiantLightSource = SGT_LightSource.Find();
}
if (gasGiantObserver == null)
{
gasGiantObserver = SGT_Helper.FindCamera();
}
SGT_Helper.SetParent(oblatenessGameObject, gameObject);
SGT_Helper.SetLayer(oblatenessGameObject, gameObject.layer);
SGT_Helper.SetTag(oblatenessGameObject, gameObject.tag);
SGT_Helper.SetParent(atmosphereGameObject, oblatenessGameObject);
SGT_Helper.SetLayer(atmosphereGameObject, oblatenessGameObject.layer);
SGT_Helper.SetTag(atmosphereGameObject, oblatenessGameObject.tag);
if (atmosphereLightingColour == null)
{
atmosphereLightingColour = new SGT_ColourGradient(false, false);
atmosphereLightingColour.AddColourNode(Color.black, 0.4f);
atmosphereLightingColour.AddColourNode(Color.white, 0.7f);
}
if (atmosphereTwilightColour == null)
{
atmosphereTwilightColour = new SGT_ColourGradient(false, true);
atmosphereTwilightColour.AddAlphaNode(1.0f, 0.4f);
atmosphereTwilightColour.AddAlphaNode(0.0f, 0.5f);
atmosphereTwilightColour.AddColourNode(Color.red, 0.5f);
}
if (atmosphereLimbColour == null)
{
atmosphereLimbColour = new SGT_ColourGradient(false, true);
atmosphereLimbColour.AddAlphaNode(0.0f, 0.75f);
atmosphereLimbColour.AddAlphaNode(1.0f, 1.0f);
atmosphereLimbColour.AddColourNode(Color.blue, 0.4f);
}
if (shadowAutoUpdate == true)
{
switch (shadowType)
{
case SGT_ShadowOccluder.Ring:
{
var fill = new SGT_FillRingDimensions();
SendMessage("FillRingDimensions", fill, SendMessageOptions.DontRequireReceiver);
shadowRadius = fill.Radius;
shadowWidth = fill.Width;
}
break;
case SGT_ShadowOccluder.Planet:
{
if (shadowGameObject != null)
{
var fill = new SGT_FillFloat();
shadowGameObject.SendMessage("FillShadowRadius", fill, SendMessageOptions.DontRequireReceiver);
shadowRadius = fill.Float;
}
}
break;
}
}
UpdateTransform();
UpdateGradient();
UpdateMaterial();
UpdateShader();
// Update mesh
atmosphereMesh.GameObject = atmosphereGameObject;
atmosphereMesh.HasMeshRenderer = true;
atmosphereMesh.MeshRendererEnabled = true;
atmosphereMesh.SharedMaterial = atmosphereMaterial;
atmosphereMesh.Update();
#if UNITY_EDITOR == true
SGT_Helper.HideGameObject(oblatenessGameObject);
atmosphereMesh.HideInEditor();
#endif
}
private void CreateMesh(ParticleList particles)
{
SGT_Helper.DestroyObject(generatedMesh);
particleCount = particles.Count;
generatedMesh = new Mesh();
var positions = new Vector3[particleCount * 4];
var indices = new int[particleCount * 6];
var uv0s = new Vector2[particleCount * 4];
var uv1s = new Vector2[particleCount * 4];
var normals = new Vector3[particleCount * 4];
var colours = new Color[particleCount * 4];
for (var i = 0; i < particleCount; i++)
{
var particle = particles[i];
var i0 = i * 6;
var i1 = i0 + 1;
var i2 = i1 + 1;
var i3 = i2 + 1;
var i4 = i3 + 1;
var i5 = i4 + 1;
var v0 = i * 4;
var v1 = v0 + 1;
var v2 = v1 + 1;
var v3 = v2 + 1;
// Index data
indices[i0] = v0;
indices[i1] = v1;
indices[i2] = v2;
indices[i3] = v3;
indices[i4] = v2;
indices[i5] = v1;
var right = SGT_Helper.Rotate(Vector2.right * SGT_Helper.InscribedBox, particle.Angle);
var up = SGT_Helper.Rotate(Vector2.up * SGT_Helper.InscribedBox, particle.Angle);
var uv1 = new Vector2(particle.Size * 0.5f, 0.0f);
// Write star values into vertex data
positions[v0] = particle.Position;
positions[v1] = particle.Position;
positions[v2] = particle.Position;
positions[v3] = particle.Position;
normals[v0] = SGT_Helper.NewVector3(-right + up, 0.0f);
normals[v1] = SGT_Helper.NewVector3(right + up, 0.0f);
normals[v2] = SGT_Helper.NewVector3(-right - up, 0.0f);
normals[v3] = SGT_Helper.NewVector3(right - up, 0.0f);
colours[v0] = particle.Colour;
colours[v1] = particle.Colour;
colours[v2] = particle.Colour;
colours[v3] = particle.Colour;
uv0s[v0] = new Vector2(0.0f, 1.0f);
uv0s[v1] = new Vector2(1.0f, 1.0f);
uv0s[v2] = new Vector2(0.0f, 0.0f);
uv0s[v3] = new Vector2(1.0f, 0.0f);
uv1s[v0] = uv1;
uv1s[v1] = uv1;
uv1s[v2] = uv1;
uv1s[v3] = uv1;
}
generatedMesh.name = "Dust";
generatedMesh.vertices = positions;
generatedMesh.normals = normals;
generatedMesh.colors = colours;
generatedMesh.uv = uv0s;
generatedMesh.uv2 = uv1s;
generatedMesh.triangles = indices;
generatedMesh.bounds = new Bounds(Vector3.zero, new Vector3(100000000.0f, 100000000.0f, 100000000.0f)); // NOTE: using infinity here causes an error
dustMesh.SharedMesh = generatedMesh;
dustMesh.Update();
}
public override void OnInspector()
{
var mbs = (SGT_MonoBehaviour[])Object.FindObjectsOfType(typeof(SGT_MonoBehaviour));
SGT_EditorGUI.HelpBox("This tool allows you to cleanup any hidden game objects that have been orphaned by SGT.", MessageType.Info);
SGT_EditorGUI.HelpBox("If a game object is still visible after showing it, then it's still in use by SGT.", MessageType.Info);
SGT_EditorGUI.Separator();
if (SGT_EditorGUI.Button("Show All Hidden Game Objects") == true)
{
foreach (var mb in mbs)
{
if (mb != null)
{
foreach (Transform t in mb.transform)
{
if (Check(t) == true)
{
t.hideFlags = 0;
}
}
}
}
Repaint();
}
SGT_EditorGUI.Separator();
if (SGT_EditorGUI.Button("Delete All Hidden Game Objects") == true)
{
foreach (var mb in mbs)
{
if (mb != null)
{
foreach (Transform t in mb.transform)
{
if (Check(t) == true)
{
SGT_Helper.DestroyGameObject(t);
}
}
}
}
Repaint();
}
SGT_EditorGUI.Separator();
var totalHiddenCount = 0;
for (var i = 0; i < mbs.Length; i++)
{
var mb = mbs[i];
if (mb != null)
{
var hiddenCount = 0;
foreach (Transform t in mb.transform)
{
if (Check(t) == true)
{
hiddenCount += 1;
totalHiddenCount += 1;
}
}
if (hiddenCount > 0)
{
SGT_EditorGUI.BeginGroup("SGT Component (" + mb.name + ")");
{
for (var j = 0; j < mb.transform.childCount; j++)
{
var t = mb.transform.GetChild(j);
if (Check(t) == true)
{
if (SGT_EditorGUI.TextWithButton("Hidden GameObject (" + t.name + ")", "Show", 50.0f) == true)
{
t.hideFlags = 0;
GUI.changed = true;
EditorUtility.SetDirty(mb);
EditorApplication.RepaintHierarchyWindow();
Repaint();
}
}
}
}
SGT_EditorGUI.EndGroup();
SGT_EditorGUI.Separator();
}
}
}
if (totalHiddenCount == 0)
{
SGT_EditorGUI.HelpBox("This scene contains no hidden children of SGT components.", MessageType.Info);
}
}
public void Regenerate()
{
if (modified == false)
{
CheckForModifications();
}
if (modified == true)
{
if (displacementTexture != null && sourceSurfaceMesh != null)
{
if (generatedSurfaceMesh == null)
{
generatedSurfaceMesh = new SGT_SurfaceMultiMesh();
}
// Destroy old meshes
generatedSurfaceMesh.DestroyAllMeshes();
sourceSurfaceMesh.CopyMeshesInto(generatedSurfaceMesh);
var surfaceCount = generatedSurfaceMesh.Count;
for (var i = 0; i < surfaceCount; i++)
{
var multiMesh = generatedSurfaceMesh.GetMultiMesh(i);
if (multiMesh != null)
{
for (var j = 0; j < multiMesh.Count; j++)
{
var mesh = multiMesh.GetSharedMesh(j);
if (mesh != null)
{
mesh = SGT_Helper.CloneObject(mesh);
mesh.hideFlags = HideFlags.DontSave;
var positions = mesh.vertices;
var uv0s = mesh.uv;
var newPositions = new Vector3[positions.Length];
var displacementUV = Vector2.zero;
for (var k = 0; k < positions.Length; k++)
{
var texture = (Texture2D)null;
var position = positions[k];
switch (displacementTexture.Configuration)
{
case SGT_SurfaceConfiguration.Sphere:
{
texture = displacementTexture.GetTexture2D(0);
if (texture != null)
{
displacementUV = useUV == true ? uv0s[k] : SGT_Helper.CartesianToPolarUV(position);
if (clamp == true)
{
displacementUV = SGT_Helper.ClampCollapseV(displacementUV, SGT_Helper.PixelUV(texture));
}
}
}
break;
case SGT_SurfaceConfiguration.Cube:
{
texture = displacementTexture.GetTexture2D(position);
if (texture != null)
{
displacementUV = useUV == true ? uv0s[k] : SGT_Helper.CubeUV(position, true);
if (clamp == true)
{
displacementUV = SGT_Helper.ClampUV(displacementUV, SGT_Helper.PixelUV(texture));
}
}
}
break;
}
var displacement = texture != null?texture.GetPixelBilinear(displacementUV.x, displacementUV.y).r : 0.0f;
newPositions[k] = position * Mathf.Lerp(scaleMin, scaleMax, displacement);
}
mesh.name += "(Displaced)";
mesh.vertices = newPositions;
mesh.bounds = new Bounds(mesh.bounds.center, mesh.bounds.size * scaleMax);
mesh.RecalculateNormals();
multiMesh.SetSharedMesh(mesh, j);
}
}
}
}
MarkAsUnmodified();
SendMessage("SetSurfaceMultiMesh", generatedSurfaceMesh, SendMessageOptions.DontRequireReceiver);
}
}
}
public void Regenerate()
{
if (modified == false)
{
CheckForModifications();
}
if (modified == true)
{
modified = false;
SGT_Helper.BeginRandomSeed(meshSeed);
{
Quaternion[] rotations = null;
switch (meshAlignment)
{
case Alignment.Billboard:
{
rotations = new Quaternion[1];
rotations[0] = Quaternion.identity;
}
break;
case Alignment.AxisAlined:
{
coronaGameObject.transform.localRotation = Quaternion.identity;
rotations = new Quaternion[3];
rotations[0] = Quaternion.LookRotation(Vector3.right);
rotations[1] = Quaternion.LookRotation(Vector3.up);
rotations[2] = Quaternion.LookRotation(Vector3.forward);
}
break;
case Alignment.Random:
{
coronaGameObject.transform.localRotation = Quaternion.identity;
rotations = new Quaternion[meshPlaneCount];
for (var i = 0; i < rotations.Length; i++)
{
rotations[i] = Random.rotation;
}
}
break;
}
// Replace mesh
SGT_Helper.DestroyObject(generatedMesh);
switch (meshType)
{
case Type.Plane:
{
GeneratePlane(rotations);
}
break;
case Type.Ring:
{
GenerateRing(rotations);
}
break;
}
if (coronaMesh != null)
{
coronaMesh.SharedMesh = generatedMesh;
}
}
SGT_Helper.EndRandomSeed();
UpdateCoronaOffset();
}
}
private void GenerateRing(Quaternion[] rotations)
{
var positions = new Vector3[rotations.Length * (meshSegments * 2 + 2)];
var indices = new int[rotations.Length * meshSegments * 6];
var uv0 = new Vector2[rotations.Length * (meshSegments * 2 + 2)];
var vStep = 1.0f / meshSegments;
var angleStep = (Mathf.PI * 2.0f) / meshSegments;
var meshRadiusOuter = (meshRadius + meshHeight) * SGT_Helper.PolygonOuterBoundScale(angleStep);
// Write index data
{
var indicesIndex = 0;
var vertexIndex = 0;
for (var r = 0; r < rotations.Length; r++)
{
for (var i = 0; i < meshSegments; i++)
{
var vertexIndexNext = vertexIndex + 2;
// Index data
indices[indicesIndex + 0] = vertexIndex + 0;
indices[indicesIndex + 1] = vertexIndex + 1;
indices[indicesIndex + 2] = vertexIndexNext + 1;
indices[indicesIndex + 3] = vertexIndex + 0;
indices[indicesIndex + 4] = vertexIndexNext + 1;
indices[indicesIndex + 5] = vertexIndexNext + 0;
indicesIndex += 6;
vertexIndex += 2;
}
vertexIndex += 2;
}
}
// Write vertex data
{
var vertexIndex = 0;
for (var r = 0; r < rotations.Length; r++)
{
var rot = rotations[r];
for (var i = 0; i < meshSegments + 1; i++)
{
// Calculate stuff
var angle = angleStep * i;
var direction = new Vector3(Mathf.Sin(angle), Mathf.Cos(angle), 0.0f);
// Write vertex data
positions[vertexIndex + 0] = rot * (direction * meshRadius);
positions[vertexIndex + 1] = rot * (direction * meshRadiusOuter);
uv0[vertexIndex + 0] = new Vector2(vStep * i, 0.0f);
uv0[vertexIndex + 1] = new Vector2(vStep * i, 1.0f);
vertexIndex += 2;
}
}
}
generatedMesh = new Mesh();
generatedMesh.vertices = positions;
generatedMesh.triangles = indices;
generatedMesh.uv = uv0;
generatedMesh.RecalculateBounds();
generatedMesh.RecalculateNormals();
}
public void LateUpdate()
{
if (surfaceGameObject == null)
{
surfaceGameObject = SGT_Helper.CreateGameObject("Surface", gameObject);
}
if (atmosphereGameObject == null)
{
atmosphereGameObject = SGT_Helper.CreateGameObject("Atmosphere", gameObject);
}
if (cloudsGameObject == null)
{
cloudsGameObject = SGT_Helper.CreateGameObject("Clouds", gameObject);
}
if (surfaceMesh == null)
{
surfaceMesh = new SGT_SurfaceMultiMesh();
}
if (surfaceTextureDay == null)
{
surfaceTextureDay = new SGT_SurfaceTexture();
}
if (surfaceTextureNight == null)
{
surfaceTextureNight = new SGT_SurfaceTexture();
}
if (surfaceTextureNormal == null)
{
surfaceTextureNormal = new SGT_SurfaceTexture();
}
if (surfaceTextureSpecular == null)
{
surfaceTextureSpecular = new SGT_SurfaceTexture();
}
if (planetObserver == null)
{
planetObserver = SGT_Helper.FindCamera();
}
if (planetLightSource == null)
{
planetLightSource = SGT_LightSource.Find();
}
SGT_Helper.SetParent(surfaceGameObject, gameObject);
SGT_Helper.SetLayer(surfaceGameObject, gameObject.layer);
SGT_Helper.SetTag(surfaceGameObject, gameObject.tag);
SGT_Helper.SetParent(atmosphereGameObject, gameObject);
SGT_Helper.SetLayer(atmosphereGameObject, gameObject.layer);
SGT_Helper.SetTag(atmosphereGameObject, gameObject.tag);
SGT_Helper.SetParent(cloudsGameObject, gameObject);
SGT_Helper.SetLayer(cloudsGameObject, gameObject.layer);
SGT_Helper.SetTag(cloudsGameObject, gameObject.tag);
surfaceTextureDay.Configuration = surfaceMesh.Configuration;
surfaceTextureNight.Configuration = surfaceMesh.Configuration;
surfaceTextureNormal.Configuration = surfaceMesh.Configuration;
surfaceTextureSpecular.Configuration = surfaceMesh.Configuration;
if (surfaceTextureDay.Modified == true)
{
updateShader |= ShaderFlags.SurfaceTextureDay; surfaceTextureDay.Modified = false;
}
if (surfaceTextureNight.Modified == true)
{
updateShader |= ShaderFlags.SurfaceTextureNight; surfaceTextureNight.Modified = false;
}
if (surfaceTextureNormal.Modified == true)
{
updateShader |= ShaderFlags.SurfaceTextureNormal; surfaceTextureNormal.Modified = false;
}
if (surfaceTextureSpecular.Modified == true)
{
updateShader |= ShaderFlags.SurfaceTextureSpecular; surfaceTextureSpecular.Modified = false;
}
if (atmosphere == true)
{
if (atmosphereMesh == null)
{
atmosphereMesh = new SGT_Mesh();
}
}
else
{
if (atmosphereMesh != null)
{
atmosphereMesh.Clear();
}
}
if (clouds == true)
{
if (cloudsMesh == null)
{
cloudsMesh = new SGT_SurfaceMultiMesh();
}
if (cloudsTexture == null)
{
cloudsTexture = new SGT_SurfaceTexture();
}
if (cloudsTexture.Modified == true)
{
updateShader |= ShaderFlags.CloudsTexture; cloudsTexture.Modified = false;
}
}
else
{
if (cloudsTexture != null)
{
cloudsTexture = null;
}
if (cloudsMesh != null)
{
cloudsMesh.Clear();
}
}
if (planetLighting == null)
{
planetLighting = new SGT_ColourGradient(false, false);
planetLighting.AddColourNode(Color.black, 0.45f);
planetLighting.AddColourNode(Color.white, 0.55f);
}
if (atmosphereTwilightColour == null)
{
atmosphereTwilightColour = new SGT_ColourGradient(false, true);
atmosphereTwilightColour.AddAlphaNode(1.0f, 0.45f);
atmosphereTwilightColour.AddAlphaNode(0.0f, 0.65f);
atmosphereTwilightColour.AddColourNode(new Color(1.0f, 0.19f, 0.0f, 1.0f), 0.5f);
}
if (atmosphereDensityColour == null)
{
atmosphereDensityColour = new SGT_ColourGradient(false, true);
atmosphereDensityColour.AddColourNode(new Color(0.17f, 0.53f, 0.85f), 0.2f);
atmosphereDensityColour.AddColourNode(Color.white, 0.5f).Locked = true;
atmosphereDensityColour.AddColourNode(new Color(0.17f, 0.51f, 1.0f), 1.0f);
}
if (cloudsLimbColour == null)
{
cloudsLimbColour = new SGT_ColourGradient(false, true);
cloudsLimbColour.AddColourNode(Color.white, 0.5f);
}
// Rotate?
if (Application.isPlaying == true)
{
if (cloudsRotationPeriod != 0.0f)
{
cloudsGameObject.transform.Rotate(0.0f, SGT_Helper.DegreesPerSecond(cloudsRotationPeriod) * Time.smoothDeltaTime, 0.0f);
}
}
// Update scales
SGT_Helper.SetLocalScale(surfaceGameObject.transform, surfaceRadius);
if (atmosphere == true)
{
SGT_Helper.SetLocalScale(atmosphereGameObject.transform, AtmosphereRadius);
// Point atmosphere at camera
if (planetObserver != null)
{
var observerPosition = planetObserver.transform.position;
var observerDirection = (observerPosition - gameObject.transform.position).normalized;
SGT_Helper.SetUp(atmosphereGameObject.transform, observerDirection);
}
}
if (clouds == true)
{
SGT_Helper.SetLocalScale(cloudsGameObject.transform, CloudsRadius);
UpdateCloudsOffset();
}
UpdateGradient();
UpdateTechnique();
UpdateShader();
surfaceMesh.GameObject = surfaceGameObject;
surfaceMesh.HasMeshRenderers = true;
surfaceMesh.MeshRenderersEnabled = true;
surfaceMesh.MeshCollidersEnabled = true;
surfaceMesh.SetSharedMaterials(surfaceMaterials);
surfaceMesh.Update(gameObject.layer, gameObject.tag);
if (atmosphere == true)
{
atmosphereMesh.GameObject = atmosphereGameObject;
atmosphereMesh.HasMeshRenderer = true;
atmosphereMesh.MeshRendererEnabled = true;
atmosphereMesh.SharedMaterial = atmosphereMaterial;
atmosphereMesh.Update();
}
if (clouds == true)
{
cloudsMesh.GameObject = cloudsGameObject;
cloudsMesh.HasMeshRenderers = true;
cloudsMesh.MeshRenderersEnabled = true;
cloudsMesh.SetSharedMaterials(cloudsMaterials);
cloudsMesh.Update(gameObject.layer, gameObject.tag);
}
#if UNITY_EDITOR == true
surfaceMesh.HideInEditor();
if (atmosphereMesh != null)
{
atmosphereMesh.HideInEditor();
}
if (cloudsMesh != null)
{
cloudsMesh.HideInEditor();
}
SGT_Helper.HideGameObject(atmosphereGameObject);
SGT_Helper.HideGameObject(cloudsGameObject);
#endif
}
public void LateUpdate()
{
if (oblatenessGameObject == null)
{
oblatenessGameObject = SGT_Helper.CreateGameObject("Oblateness", gameObject);
}
if (surfaceGameObject == null)
{
surfaceGameObject = SGT_Helper.CreateGameObject("Surface", oblatenessGameObject);
}
if (atmosphereGameObject == null)
{
atmosphereGameObject = SGT_Helper.CreateGameObject("Atmosphere", oblatenessGameObject);
}
if (atmosphereMesh == null)
{
atmosphereMesh = new SGT_Mesh();
}
if (starObserver == null)
{
starObserver = SGT_Helper.FindCamera();
}
if (surfaceTexture == null)
{
surfaceTexture = new SGT_SurfaceTexture();
}
if (surfaceMultiMesh == null)
{
surfaceMultiMesh = new SGT_SurfaceMultiMesh();
}
SGT_Helper.SetParent(oblatenessGameObject, gameObject);
SGT_Helper.SetLayer(oblatenessGameObject, gameObject.layer);
SGT_Helper.SetTag(oblatenessGameObject, gameObject.tag);
SGT_Helper.SetParent(surfaceGameObject, oblatenessGameObject);
SGT_Helper.SetLayer(surfaceGameObject, oblatenessGameObject.layer);
SGT_Helper.SetTag(surfaceGameObject, oblatenessGameObject.tag);
SGT_Helper.SetParent(atmosphereGameObject, oblatenessGameObject);
SGT_Helper.SetLayer(atmosphereGameObject, oblatenessGameObject.layer);
SGT_Helper.SetTag(atmosphereGameObject, oblatenessGameObject.tag);
if (atmosphereDensityColour == null)
{
atmosphereDensityColour = new SGT_ColourGradient(false, true);
atmosphereDensityColour.AddColourNode(new Color(1.0f, 1.0f, 0.0f, 1.0f), 0.0f);
atmosphereDensityColour.AddColourNode(new Color(1.0f, 0.5f, 0.0f, 1.0f), 0.5f).Locked = true;
atmosphereDensityColour.AddColourNode(new Color(1.0f, 0.0f, 0.0f, 1.0f), 1.0f);
}
UpdateTransform();
UpdateGradient();
UpdateMaterial();
UpdateShader();
surfaceMultiMesh.GameObject = surfaceGameObject;
surfaceMultiMesh.HasMeshRenderers = true;
surfaceMultiMesh.MeshRenderersEnabled = true;
surfaceMultiMesh.MeshCollidersEnabled = true;
surfaceMultiMesh.SetSharedMaterials(surfaceMaterials);
surfaceMultiMesh.Update(gameObject.layer, gameObject.tag);
atmosphereMesh.GameObject = atmosphereGameObject;
atmosphereMesh.HasMeshRenderer = true;
atmosphereMesh.MeshRendererEnabled = true;
atmosphereMesh.SharedMaterial = atmosphereMaterial;
atmosphereMesh.Update();
#if UNITY_EDITOR == true
SGT_Helper.HideGameObject(oblatenessGameObject);
atmosphereMesh.HideInEditor();
surfaceMultiMesh.HideInEditor();
#endif
}
private void UpdateShader()
{
var position = transform.position;
var lightSourcePosition = SGT_Helper.GetPosition(ringLightSource);
var uniformScale = UniformScale;
var starPositionRaw = ringGameObject.transform.worldToLocalMatrix.MultiplyPoint(lightSourcePosition);
var oldCameraRotation = ringCameraRotation; if (ringCamera != null)
{
ringCameraRotation = ringCamera.transform.rotation;
}
var cameraRotationDelta = Quaternion.Inverse(oldCameraRotation) * ringCameraRotation;
ringCameraRoll = SGT_Helper.Wrap(ringCameraRoll - cameraRotationDelta.eulerAngles.z, 0.0f, 360.0f);
var roll = Quaternion.Euler(new Vector3(0.0f, 0.0f, ringCameraRoll));
ringMaterial.SetTexture("dayTexture", asteroidTextureDay);
ringMaterial.SetTexture("nightTexture", asteroidTextureNight);
ringMaterial.SetTexture("bumpTexture", asteroidTextureHeight);
ringMaterial.SetVector("starPositionRaw", SGT_Helper.NewVector4(starPositionRaw, 1.0f));
ringMaterial.SetVector("centrePosition", position);
ringMaterial.SetFloat("ringHeight", ringHeight);
ringMaterial.SetMatrix("cameraRoll", SGT_MatrixHelper.Rotation(roll));
if (shadow == true)
{
var shadowRatio = 0.0f;
var shadowScale = 0.0f;
if (shadowWidth > 0.0f)
{
shadowRatio = ShadowInnerRadius / ShadowOuterRadius;
shadowScale = 1.0f / (1.0f - shadowRatio);
}
ringMaterial.SetColor("umbraColour", shadowUmbraColour);
ringMaterial.SetColor("penumbraColour", shadowPenumbraColour);
ringMaterial.SetFloat("shadowRatio", shadowRatio);
ringMaterial.SetFloat("shadowScale", shadowScale);
if (ShadowInnerRadius > 0.0f)
{
var direction = (position - lightSourcePosition).normalized;
var r = Quaternion.FromToRotation(direction, Vector3.forward);
var s = SGT_Helper.NewVector3(1.0f / (ShadowOuterRadius * uniformScale));
var shadowT = SGT_MatrixHelper.Translation(-position);
var shadowR = SGT_MatrixHelper.Rotation(r);
var shadowS = SGT_MatrixHelper.Scaling(s);
var shadowMatrix = shadowS * shadowR * shadowT;
ringMaterial.SetMatrix("shadowMatrix", shadowMatrix);
}
}
if (spin == true)
{
ringMaterial.SetFloat("spinRateMax", spinRateMax);
}
}
