private void Validate()
{
if (nebula == null)
{
nebula = SGT_Helper.CreateGameObject("Nebula", this);
}
if (nebulaMesh == null)
{
nebulaMesh = new SGT_Mesh();
}
if (nebulaMaterial == null)
{
nebulaMaterial = SGT_Helper.CreateMaterial("Hidden/SGT/Nebula/" + nebulaTechnique);
}
SGT_Helper.SetParent(nebula, gameObject);
SGT_Helper.SetLayer(nebula, gameObject.layer);
SGT_Helper.SetTag(nebula, gameObject.tag);
var finalColour = SGT_Helper.Premultiply(particleColour);
nebulaMaterial.SetColor("particleColour", finalColour);
nebulaMaterial.SetTexture("particleTexture", particleTexture);
nebulaMaterial.SetFloat("particleFadeInDistance", particleFadeInDistance);
SGT_Helper.SetRenderQueue(nebulaMaterial, nebulaRenderQueue);
nebulaMesh.GameObject = nebula;
nebulaMesh.HasMeshRenderer = true;
nebulaMesh.MeshRendererEnabled = SGT_Helper.IsBlack(finalColour) == false;
nebulaMesh.SharedMesh = generatedMesh;
nebulaMesh.SharedMaterial = nebulaMaterial;
nebulaMesh.Update();
}
public void Update(int layer, string tag)
{
var surfaceCount = Count;
if (multiMeshes == null || multiMeshes.Length != surfaceCount)
{
multiMeshes = new SGT_MultiMesh[surfaceCount];
}
if (multiMeshGameObjects == null || multiMeshGameObjects.Length != surfaceCount)
{
multiMeshGameObjects = new GameObject[surfaceCount];
}
// Update multi meshes
for (var i = 0; i < multiMeshes.Length; i++)
{
var multiMesh = multiMeshes[i];
var multiMeshGameObject = multiMeshGameObjects[i];
if (multiMesh == null)
{
multiMesh = new SGT_MultiMesh();
multiMeshes[i] = multiMesh;
}
if (multiMeshGameObject == null)
{
multiMeshGameObject = SGT_Helper.CreateGameObject("Multi Mesh " + (i + 1), gameObject);
multiMeshGameObjects[i] = multiMeshGameObject;
}
if (gameObject != null)
{
SGT_Helper.SetParent(multiMeshGameObject, gameObject);
SGT_Helper.SetLayer(multiMeshGameObject, gameObject.layer);
SGT_Helper.SetTag(multiMeshGameObject, gameObject.tag);
}
multiMesh.GameObject = multiMeshGameObject;
multiMesh.HasMeshRenderers = hasMeshRenderers;
multiMesh.MeshRenderersEnabled = meshRenderersEnabled;
multiMesh.HasMeshColliders = hasMeshColliders;
multiMesh.MeshCollidersEnabled = meshCollidersEnabled;
multiMesh.SharedPhysicsMaterial = sharedPhysicsMaterial;
multiMesh.Update();
}
// Check integrity
if (gameObject != null && gameObject.transform.childCount != surfaceCount)
{
SGT_Helper.DestroyGameObjects(multiMeshGameObjects);
SGT_Helper.DestroyChildren(gameObject);
}
}
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);
}
if (dustCamera == null)
{
dustCamera = SGT_Helper.FindCamera();
}
SGT_Helper.SetParent(dust, gameObject);
SGT_Helper.SetLayer(dust, gameObject.layer);
SGT_Helper.SetTag(dust, gameObject.tag);
var finalColour = SGT_Helper.Premultiply(particleColour);
var oldDustCameraRotation = dustCameraRotation;
if (dustCamera != null)
{
dustCameraRotation = dustCamera.transform.rotation;
}
var cameraRotationDelta = Quaternion.Inverse(oldDustCameraRotation) * dustCameraRotation;
particleRoll -= cameraRotationDelta.eulerAngles.z;
var roll = Quaternion.Euler(new Vector3(0.0f, 0.0f, particleRoll));
dustMaterial.SetTexture("dustTexture", particleTexture);
dustMaterial.SetFloat("dustRadius", dustRadius);
dustMaterial.SetColor("particleColour", finalColour);
dustMaterial.SetFloat("particleFadeInDistance", dustRadius / particleFadeInDistance);
dustMaterial.SetFloat("particleFadeOutDistance", dustRadius / particleFadeOutDistance);
dustMaterial.SetMatrix("particleRoll", SGT_MatrixHelper.Rotation(roll));
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();
}
public void LateUpdate()
{
if (starfieldGameObject == null)
{
starfieldGameObject = SGT_Helper.CreateGameObject("Starfield", gameObject);
}
if (starfieldMultiMesh == null)
{
starfieldMultiMesh = new SGT_MultiMesh();
}
if (starfieldObserver == null)
{
starfieldObserver = SGT_Helper.FindCamera();
}
if (packer == null)
{
packer = new SGT_Packer();
}
if (starVariants == null)
{
starVariants = new VariantList();
}
SGT_Helper.SetParent(starfieldGameObject, gameObject);
SGT_Helper.SetLayer(starfieldGameObject, gameObject.layer);
SGT_Helper.SetTag(starfieldGameObject, gameObject.tag);
packer.AtlasFormat = TextureFormat.RGB24;
packer.AtlasMaxSize = SGT_SquareSize.Square2048;
packer.AtlasFilterMode = FilterMode.Trilinear;
packer.AtlasCountMax = 1;
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
}
public void LateUpdate()
{
if (ringGameObject == null)
{
ringGameObject = SGT_Helper.CreateGameObject("Ring", gameObject);
}
if (ringMultiMesh == null)
{
ringMultiMesh = new SGT_MultiMesh();
}
if (ringLightSource == null)
{
ringLightSource = SGT_LightSource.Find();
}
if (ringCamera == null)
{
RingCamera = SGT_Helper.FindCamera(); // NOTE: Assigning property
}
SGT_Helper.SetParent(ringGameObject, gameObject);
SGT_Helper.SetLayer(ringGameObject, gameObject.layer);
SGT_Helper.SetTag(ringGameObject, gameObject.tag);
if (ringAutoRegen == true)
{
Regenerate();
}
if (shadowAutoUpdate == true)
{
var fill = new SGT_FillFloat();
SendMessage("FillShadowRadius", fill, SendMessageOptions.DontRequireReceiver);
shadowRadius = fill.Float;
}
UpdateTechnique();
UpdateShader();
ringMultiMesh.GameObject = ringGameObject;
ringMultiMesh.HasMeshRenderers = true;
ringMultiMesh.MeshRenderersEnabled = true;
ringMultiMesh.SharedMaterial = ringMaterial;
ringMultiMesh.ReplaceAll(generatedMeshes);
ringMultiMesh.Update();
#if UNITY_EDITOR == true
ringMultiMesh.HideInEditor();
#endif
}
private void Validate()
{
if (nebula == null)
{
nebula = SGT_Helper.CreateGameObject("Nebula", this);
}
if (nebulaMesh == null)
{
nebulaMesh = new SGT_Mesh();
}
if (nebulaMaterial == null)
{
nebulaMaterial = SGT_Helper.CreateMaterial("Hidden/SGT/Nebula/" + nebulaTechnique);
}
if (nebulaCamera == null)
{
NebulaCamera = SGT_Helper.FindCamera(); // NOTE: Assigning property
}
SGT_Helper.SetParent(nebula, gameObject);
SGT_Helper.SetLayer(nebula, gameObject.layer);
SGT_Helper.SetTag(nebula, gameObject.tag);
var sideOrTop = Mathf.Abs(Vector3.Dot((SGT_Helper.GetPosition(nebulaCamera) - transform.position).normalized, transform.up));
var finalColour = SGT_Helper.Premultiply(Color.Lerp(particleSideColour, particleTopColour, sideOrTop));
var oldCameraRotation = nebulaCameraRotation; if (nebulaCamera != null)
{
nebulaCameraRotation = nebulaCamera.transform.rotation;
}
var cameraRotationDelta = Quaternion.Inverse(oldCameraRotation) * nebulaCameraRotation;
nebulaCameraRoll = SGT_Helper.Wrap(nebulaCameraRoll - cameraRotationDelta.eulerAngles.z, 0.0f, 360.0f);
var roll = Quaternion.Euler(new Vector3(0.0f, 0.0f, nebulaCameraRoll));
nebulaMaterial.SetColor("particleColour", finalColour);
nebulaMaterial.SetTexture("particleTexture", particleTexture);
nebulaMaterial.SetFloat("particleFadeInDistance", particleFadeInDistance);
nebulaMaterial.SetMatrix("cameraRoll", SGT_MatrixHelper.Rotation(roll));
SGT_Helper.SetRenderQueue(nebulaMaterial, nebulaRenderQueue);
nebulaMesh.GameObject = nebula;
nebulaMesh.HasMeshRenderer = true;
nebulaMesh.MeshRendererEnabled = SGT_Helper.IsBlack(finalColour) == false;
nebulaMesh.SharedMesh = generatedMesh;
nebulaMesh.SharedMaterial = nebulaMaterial;
nebulaMesh.Update();
}
public void LateUpdate()
{
if (ringGameObject == null)
{
ringGameObject = SGT_Helper.CreateGameObject("Ring Slices", gameObject);
}
if (ringMesh == null)
{
ringMesh = new SGT_MultiMesh();
}
if (lightSource == null)
{
lightSource = SGT_LightSource.Find();
}
SGT_Helper.SetParent(ringGameObject, gameObject);
SGT_Helper.SetLayer(ringGameObject, gameObject.layer);
SGT_Helper.SetTag(ringGameObject, gameObject.tag);
if (ringAutoRegen == true)
{
Regenerate();
}
if (shadowAutoUpdate == true)
{
var fill = new SGT_FillFloat();
SendMessage("FillShadowRadius", fill, SendMessageOptions.DontRequireReceiver);
shadowRadius = fill.Float;
}
UpdateMaterial();
UpdateShader();
ringMesh.GameObject = ringGameObject;
ringMesh.HasMeshRenderers = true;
ringMesh.MeshRenderersEnabled = true;
ringMesh.SharedMaterial = ringMaterial;
ringMesh.SharedMesh = generatedMesh;
UpdateRingRotations();
#if UNITY_EDITOR == true
ringMesh.HideInEditor();
#endif
}
public GameObject GetMeshGameObject(int index)
{
if (index >= 0 && meshGameObjects != null && index < meshGameObjects.Count)
{
var meshGameObject = meshGameObjects[index];
if (meshGameObject == null)
{
meshGameObject = SGT_Helper.CreateGameObject("Mesh " + (index + 1), gameObject);
meshGameObjects[index] = meshGameObject;
}
return(meshGameObject);
}
return(null);
}
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 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
}
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 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();
}
public void Update()
{
if (surfaceGameObject == null)
{
var fillSurfaceGameObject = new SGT_FillGameObject();
SendMessage("FillSurfaceGameObject", fillSurfaceGameObject, SendMessageOptions.DontRequireReceiver);
surfaceGameObject = fillSurfaceGameObject.GameObject;
}
if (activeCollider != null)
{
if (activeGameObject == null)
{
activeGameObject = SGT_Helper.CreateGameObject("Collider (Active)", gameObject);
}
activeCollider.GameObject = activeGameObject;
activeCollider.Update();
}
else
{
if (activeGameObject != null)
{
SGT_Helper.DestroyGameObject(activeGameObject);
}
}
if (nextCollider != null)
{
if (nextGameObject == null)
{
nextGameObject = SGT_Helper.CreateGameObject("Collider (Currently Building)", gameObject);
}
nextCollider.GameObject = nextGameObject;
nextCollider.Update();
}
else
{
if (nextGameObject != null)
{
SGT_Helper.DestroyGameObject(nextGameObject);
}
}
if (activeGameObject != null)
{
SGT_Helper.SetLocalScale(activeGameObject.transform, surfaceGameObject.transform.localScale);
}
if (nextGameObject != null)
{
SGT_Helper.SetLocalScale(nextGameObject.transform, surfaceGameObject.transform.localScale);
}
#if UNITY_EDITOR == true
if (Application.isEditor == true)
{
SGT_Helper.HideGameObject(activeGameObject);
SGT_Helper.HideGameObject(nextGameObject);
}
#endif
}
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
}
public void Update()
{
if (meshes == null)
{
meshes = new MeshList();
}
if (meshGameObjects == null)
{
meshGameObjects = new GameObjectList();
}
if (meshGameObjects.Count != meshes.Count)
{
SGT_ArrayHelper.Resize(ref meshGameObjects, meshes.Count, true);
}
// Update meshes
for (var i = meshes.Count - 1; i >= 0; i--)
{
var mesh = meshes[i];
var meshGameObject = meshGameObjects[i];
if (mesh == null)
{
mesh = new SGT_Mesh();
meshes[i] = mesh;
}
if (meshGameObject == null)
{
meshGameObject = SGT_Helper.CreateGameObject("Mesh " + (i + 1), gameObject);
meshGameObjects[i] = meshGameObject;
}
if (gameObject != null)
{
SGT_Helper.SetParent(meshGameObject, gameObject);
SGT_Helper.SetLayer(meshGameObject, gameObject.layer);
SGT_Helper.SetTag(meshGameObject, gameObject.tag);
}
if (sharedMesh != null)
{
mesh.SharedMesh = sharedMesh;
}
if (sharedMaterial != null)
{
mesh.SharedMaterial = sharedMaterial;
}
if (sharedPhysicsMaterial != null)
{
mesh.SharedPhysicsMaterial = sharedPhysicsMaterial;
}
mesh.GameObject = meshGameObject;
mesh.HasMeshRenderer = hasMeshRenderers;
mesh.MeshRendererEnabled = meshRenderersEnabled;
mesh.HasMeshCollider = hasMeshColliders;
mesh.MeshColliderEnabled = meshCollidersEnabled;
mesh.Update();
}
// Check integrity
if (gameObject != null && meshGameObjects.Count != gameObject.transform.childCount)
{
SGT_Helper.DestroyChildren(gameObject);
SGT_Helper.DestroyGameObjects(meshGameObjects);
}
}
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 System.Collections.IEnumerator Update_Coroutine()
{
for (;;)
{
// Swap
currentVertices = nextVertices;
nextVertices = null;
if (currentVertices != null)
{
nextGameObject = SGT_Helper.CreateGameObject("Collider (Currently Building)", gameObject);
nextGameObject.layer = gameObject.layer;
nextGameObject.tag = gameObject.tag;
nextCollider = new SGT_MultiMesh();
nextCollider.GameObject = nextGameObject;
nextCollider.HasMeshColliders = true;
nextCollider.MeshCollidersEnabled = true;
nextCollider.SharedPhysicsMaterial = physicsMaterial;
var vertexCount = currentVertices.Length;
var copyFrom = 0;
while (copyFrom < vertexCount)
{
var copyTo = Mathf.Min(copyFrom + verticesPerMesh, vertexCount);
var copyCount = copyTo - copyFrom;
var vertices = new Vector3[copyCount];
var triangles = new int[copyCount];
for (var i = 0; i < copyCount; i++)
{
vertices[i] = currentVertices[copyFrom + i];
triangles[i] = i;
}
var mesh = new Mesh();
mesh.name = "Tessellator Collider Generated";
mesh.vertices = vertices;
mesh.triangles = triangles;
mesh.RecalculateBounds();
nextCollider.Add(mesh);
nextCollider.Update();
copyFrom += verticesPerMesh;
yield return(new WaitForEndOfFrame());
}
// Remove current ones
if (activeCollider != null)
{
activeCollider.DestroyAllMeshes();
}
SGT_Helper.DestroyGameObject(activeGameObject);
// Swap
activeCollider = nextCollider;
activeGameObject = nextGameObject;
activeGameObject.name = "Collider (Active)";
// Remove old
nextGameObject = null;
nextCollider = null;
}
yield return(new WaitForEndOfFrame());
}
}
public void LateUpdate()
{
if (thrusterObserver == null)
{
thrusterObserver = SGT_Helper.FindCamera();
}
if (thrusterFlameGameObject == null)
{
thrusterFlameGameObject = SGT_Helper.CreateGameObject("Flame", gameObject);
}
if (thrusterFlareGameObject == null)
{
thrusterFlareGameObject = SGT_Helper.CreateGameObject("Flare", gameObject);
}
SGT_Helper.SetParent(thrusterFlameGameObject, gameObject);
SGT_Helper.SetLayer(thrusterFlameGameObject, gameObject.layer);
SGT_Helper.SetTag(thrusterFlameGameObject, gameObject.tag);
SGT_Helper.SetParent(thrusterFlareGameObject, gameObject);
SGT_Helper.SetLayer(thrusterFlareGameObject, gameObject.layer);
SGT_Helper.SetTag(thrusterFlareGameObject, gameObject.tag);
if (thrusterPhysics == true && thrusterPhysicsRigidbody == null)
{
thrusterPhysicsRigidbody = SGT_Helper.GetComponentUpwards <Rigidbody>(gameObject);
}
var observerPosition = SGT_Helper.GetPosition(thrusterObserver);
if (Application.isPlaying == true)
{
currentThrusterThrottle = Mathf.MoveTowards(currentThrusterThrottle, targetThrusterThrottle, thrusterTweenSpeed * Time.deltaTime);
}
else
{
currentThrusterThrottle = targetThrusterThrottle;
}
if (thrusterFlame == true)
{
if (thrusterFlameMesh == null)
{
thrusterFlameMesh = new SGT_Mesh();
}
// Offset flame
SGT_Helper.SetLocalPosition(thrusterFlameGameObject.transform, thrusterFlameOffset);
var finalFlameScale = thrusterFlameScale + thrusterFlameScaleChange * currentThrusterThrottle;
// Hide/show flame
if (finalFlameScale == Vector3.zero)
{
thrusterFlameMesh.MeshRendererEnabled = false;
}
else
{
if (Application.isPlaying == true)
{
finalFlameScale *= Random.Range(1.0f - thrusterFlameScaleFlicker, 1.0f);
}
thrusterFlameMesh.MeshRendererEnabled = true;
SGT_Helper.SetLocalScale(thrusterFlameGameObject.transform, finalFlameScale);
// Roll flame to observer
var pointDir = transform.InverseTransformPoint(observerPosition);
var roll = Mathf.Atan2(pointDir.y, pointDir.x) * Mathf.Rad2Deg;
SGT_Helper.SetRotation(thrusterFlameGameObject.transform, transform.rotation * Quaternion.Euler(0.0f, 0.0f, roll));
}
thrusterFlameMesh.GameObject = thrusterFlameGameObject;
thrusterFlameMesh.HasMeshRenderer = true;
thrusterFlameMesh.Update();
}
else
{
if (thrusterFlameMesh != null)
{
thrusterFlameMesh = thrusterFlameMesh.Clear();
}
}
if (thrusterFlare == true)
{
if (thrusterFlareMesh == null)
{
thrusterFlareMesh = new SGT_Mesh();
}
// Offset flare
SGT_Helper.SetLocalPosition(thrusterFlareGameObject.transform, thrusterFlareOffset);
// Flare visible?
var a = thrusterFlareGameObject.transform.position;
var b = observerPosition;
var direction = (b - a).normalized;
var distance = (b - a).magnitude;
var targetFlareSize = 0.0f;
// If the ray hits something, then hide the flare
if (Physics.Raycast(a, direction, distance, thrusterFlareRaycastMask) == true)
{
targetFlareSize = 0.0f;
}
else
{
targetFlareSize = 1.0f;
}
// Point flare at observer
if (thrusterObserver != null)
{
SGT_Helper.SetRotation(thrusterFlareGameObject.transform, thrusterObserver.transform.rotation);
}
// Fade flare in/out based on raycast
if (Application.isPlaying == true)
{
currentThrusterFlareScale = Mathf.MoveTowards(currentThrusterFlareScale, targetFlareSize, thrusterFlareScaleTweenSpeed * Time.deltaTime);
}
else
{
currentThrusterFlareScale = targetFlareSize;
}
var finalFlareScale = currentThrusterFlareScale * (thrusterFlareScale + thrusterFlareScaleChange * currentThrusterThrottle);
// Hide/show flare
if (finalFlareScale == Vector3.zero)
{
thrusterFlareMesh.MeshRendererEnabled = false;
}
else
{
if (Application.isPlaying == true)
{
finalFlareScale *= Random.Range(1.0f - thrusterFlareScaleFlicker, 1.0f);
}
thrusterFlareMesh.MeshRendererEnabled = true;
SGT_Helper.SetLocalScale(thrusterFlareGameObject.transform, finalFlareScale);
}
thrusterFlareMesh.GameObject = thrusterFlareGameObject;
thrusterFlareMesh.HasMeshRenderer = true;
thrusterFlareMesh.Update();
}
else
{
if (thrusterFlareMesh != null)
{
thrusterFlareMesh = thrusterFlareMesh.Clear();
}
}
#if UNITY_EDITOR == true
if (thrusterFlameMesh != null)
{
thrusterFlameMesh.HideInEditor();
}
if (thrusterFlareMesh != null)
{
thrusterFlareMesh.HideInEditor();
}
SGT_Helper.HideGameObject(thrusterFlameGameObject);
SGT_Helper.HideGameObject(thrusterFlareGameObject);
#endif
}