private void Despawn(SgtDebris debris, int index)
{
if (debris.OnDespawn != null)
{
debris.OnDespawn();
}
if (debris.Pool == true)
{
SgtComponentPool <SgtDebris> .Add(debris);
}
else
{
SgtHelper.Destroy(debris.gameObject);
}
Debris.RemoveAt(index);
}
private void UpdateLevel(Level level, double distance)
{
if (level != null)
{
if (distance >= level.DistanceMin && distance < level.DistanceMax)
{
if (level.Clone == null)
{
var levelP = level.Prefab;
if (levelP != null)
{
var levelO = levelP.CachedObject;
// Store old values and override
var oldPoint = levelO.Point;
var oldSeed = levelP.Seed;
levelO.Point = cachedObject.Point;
levelP.Seed = CachedSpawnable.Seed;
// Spawn
level.Clone = Instantiate(level.Prefab, SgtFloatingRoot.Root);
// Revert values
levelO.Point = oldPoint;
levelP.Seed = oldSeed;
// Invoke spawn
level.Clone.InvokeOnSpawn();
}
}
}
else
{
if (level.Clone != null)
{
SgtHelper.Destroy(level.Clone.gameObject);
level.Clone = null;
}
}
}
}
protected virtual void OnDestroy()
{
if (models != null)
{
for (var i = models.Count - 1; i >= 0; i--)
{
SgtProminenceModel.MarkForDestruction(models[i]);
}
}
if (mesh != null)
{
mesh.Clear(false);
SgtObjectPool <Mesh> .Add(mesh);
}
SgtHelper.Destroy(material);
}
private void HandleDistance(double distance)
{
if (distance >= distanceMin && distance <= distanceMax)
{
if (spawned == false)
{
spawned = true;
if (prefab != null)
{
clone = Instantiate(prefab, transform, false);
}
}
}
else if (spawned == true)
{
spawned = false;
clone = SgtHelper.Destroy(clone);
}
}
private void ValidateTexture(ref Texture2D texture2D, string createName)
{
// Destroy if invalid
if (texture2D != null)
{
if (texture2D.width != Width || texture2D.height != 1 || texture2D.format != Format)
{
texture2D = SgtHelper.Destroy(texture2D);
}
}
// Create?
if (texture2D == null)
{
texture2D = SgtHelper.CreateTempTexture2D(createName, Width, 1, Format);
texture2D.wrapMode = TextureWrapMode.Clamp;
ApplyTextures();
}
}
public void Rebuild()
{
dirty = false;
generatedMesh = SgtHelper.Destroy(generatedMesh);
if (mesh != null)
{
generatedMesh = Instantiate(mesh);
generatedMesh.GetVertices(generatedPositions);
generatedMesh.GetUVs(0, generatedCoords);
var count = generatedMesh.vertexCount;
#if UNITY_EDITOR
SgtHelper.MakeTextureReadable(heightmap);
#endif
for (var i = 0; i < count; i++)
{
generatedCoords[i] = generatedCoords[i];
var height = radius;
var vector = generatedPositions[i].normalized;
generatedPositions[i] = vector * Sample(vector);
}
generatedMesh.SetVertices(generatedPositions);
generatedMesh.SetUVs(0, generatedCoords);
generatedMesh.RecalculateBounds();
generatedMesh.RecalculateNormals();
generatedMesh.RecalculateTangents();
if (meshCollider != null)
{
meshCollider.sharedMesh = null;
meshCollider.sharedMesh = generatedMesh;
}
}
}
private void UpdateTexture()
{
if (width > 0 && height > 0)
{
// Destroy if invalid
if (generatedTexture != null)
{
if (generatedTexture.width != width || generatedTexture.height != height || generatedTexture.format != format)
{
generatedTexture = SgtHelper.Destroy(generatedTexture);
}
}
// Create?
if (generatedTexture == null)
{
generatedTexture = SgtHelper.CreateTempTexture2D("Scattering (Generated)", width, height, format);
generatedTexture.wrapMode = TextureWrapMode.Clamp;
}
var stepU = 1.0f / (width - 1);
var stepV = 1.0f / (height - 1);
for (var y = 0; y < height; y++)
{
var v = y * stepV;
for (var x = 0; x < width; x++)
{
WritePixel(stepU * x, v, x, y);
}
}
generatedTexture.Apply();
}
ApplyTexture();
}
public void UpdateTexture()
{
if (Width > 0 && Height > 0)
{
// Destroy if invalid
if (generatedTexture != null)
{
if (generatedTexture.width != Width || generatedTexture.height != Height || generatedTexture.format != Format)
{
generatedTexture = SgtHelper.Destroy(generatedTexture);
}
}
// Create?
if (generatedTexture == null)
{
generatedTexture = SgtHelper.CreateTempTexture2D("Scattering (Generated)", Width, Height, Format);
generatedTexture.wrapMode = TextureWrapMode.Clamp;
UpdateApply();
}
var stepU = 1.0f / (Width - 1);
var stepV = 1.0f / (Height - 1);
for (var y = 0; y < Height; y++)
{
var v = y * stepV;
for (var x = 0; x < Width; x++)
{
WritePixel(stepU * x, v, x, y);
}
}
generatedTexture.Apply();
}
}
public void RebuildMesh()
{
displacedMesh = SgtHelper.Destroy(displacedMesh);
if (OriginalMesh != null && Heightmap != null)
{
#if UNITY_EDITOR
SgtHelper.MakeTextureReadable(Heightmap);
#endif
// Duplicate original
displacedMesh = Instantiate(OriginalMesh);
#if UNITY_EDITOR
displacedMesh.hideFlags = HideFlags.DontSave;
#endif
displacedMesh.name = OriginalMesh.name + " (Displaced)";
// Displace vertices
var positions = OriginalMesh.vertices;
for (var i = 0; i < positions.Length; i++)
{
var direction = positions[i].normalized;
positions[i] = direction * GetSurfaceHeightLocal(direction);
}
displacedMesh.vertices = positions;
displacedMesh.RecalculateBounds();
}
// Apply displaced mesh
if (meshFilter == null)
{
meshFilter = GetComponent <MeshFilter>();
}
meshFilter.sharedMesh = displacedMesh;
}
private bool ValidateTexture(ref Texture2D texture2D, string createName)
{
// Destroy if invalid
if (texture2D != null)
{
if (texture2D.width != width || texture2D.height != 1 || texture2D.format != format)
{
texture2D = SgtHelper.Destroy(texture2D);
}
}
// Create?
if (texture2D == null)
{
texture2D = SgtHelper.CreateTempTexture2D(createName, width, 1, format);
texture2D.wrapMode = TextureWrapMode.Clamp;
return(true);
}
return(false);
}
public void UpdateTexture()
{
if (Width > 0)
{
// Destroy if invalid
if (generatedTexture != null)
{
if (generatedTexture.width != Width || generatedTexture.height != 1 || generatedTexture.format != Format)
{
generatedTexture = SgtHelper.Destroy(generatedTexture);
}
}
// Create?
if (generatedTexture == null)
{
generatedTexture = SgtHelper.CreateTempTexture2D("Flare Texture (Generated)", Width, 1, Format);
generatedTexture.wrapMode = TextureWrapMode.Clamp;
if (generatedMaterial != null)
{
generatedMaterial.SetTexture(SgtShader._MainTex, generatedTexture);
}
}
var stepU = 1.0f / (Width - 1);
for (var x = 0; x < Width; x++)
{
WritePixel(stepU * x, x);
}
generatedTexture.Apply();
}
}
private void UpdateTexture()
{
if (width > 0)
{
// Destroy if invalid
if (generatedTexture != null)
{
if (generatedTexture.width != width || generatedTexture.height != 1 || generatedTexture.format != format)
{
generatedTexture = SgtHelper.Destroy(generatedTexture);
}
}
// Create?
if (generatedTexture == null)
{
generatedTexture = SgtHelper.CreateTempTexture2D("Depth (Generated)", width, 1, format);
generatedTexture.wrapMode = TextureWrapMode.Clamp;
ApplyTexture();
}
var color = Color.clear;
var stepU = 1.0f / (width - 1);
for (var x = 0; x < width; x++)
{
WritePixel(stepU * x, x);
}
generatedTexture.Apply();
}
ApplyTexture();
}
protected virtual void OnDestroy()
{
SgtHelper.Destroy(renderTexture);
SgtHelper.Destroy(readTexture);
}
protected virtual void Update()
{
if (prefabs == null)
{
prefabs = new List <Transform>();
}
if (index < 0)
{
index = prefabs.Count - 1;
}
else if (index >= prefabs.Count)
{
index = 0;
}
var prefab = default(Transform);
if (prefabs.Count > 0)
{
prefab = prefabs[index];
}
if (prefab != expectedPrefab)
{
if (clone == null)
{
transition = 0.0f;
}
else
{
transition = Mathf.Clamp01(transition - speed * Time.deltaTime);
}
if (transition == 0.0f)
{
if (clone != null)
{
SgtHelper.Destroy(clone.gameObject);
clone = null;
}
expectedPrefab = prefab;
if (prefab != null)
{
clone = Instantiate(prefab, transform);
scale = clone.localScale;
clone.localScale = new Vector3(0.0f, 0.0f, 0.01f);
if (onTitle != null)
{
onTitle.Invoke(prefab.name);
}
}
}
}
else
{
transition = Mathf.Clamp01(transition + speed * Time.deltaTime);
}
if (clone != null)
{
clone.localScale = scale * Mathf.SmoothStep(0.0f, 1.0f, transition);
}
}
protected virtual void OnDestroy()
{
SgtCloudsphereModel.MarkForDestruction(model);
SgtHelper.Destroy(material);
}
protected virtual void OnDestroy()
{
SgtCoronaModel.MarkForDestruction(model);
SgtHelper.Destroy(outerMaterial);
SgtHelper.Destroy(innerMaterial);
}
protected virtual void OnDestroy()
{
SgtJovianModel.MarkForDestruction(model);
SgtHelper.Destroy(material);
}
protected virtual void OnDestroy()
{
SgtHelper.Destroy(material);
}
protected virtual void OnDestroy()
{
SgtSingularityModel.MarkForDestruction(model);
SgtHelper.Destroy(material);
}
protected virtual void OnDestroy()
{
SgtHelper.Destroy(outerMaterial);
SgtHelper.Destroy(innerMaterial);
}
protected virtual void OnDestroy()
{
SgtHelper.Destroy(generatedInnerTexture);
SgtHelper.Destroy(generatedOuterTexture);
}
public void RebuildMesh()
{
generatedMesh = SgtHelper.Destroy(generatedMesh);
if (OriginalMesh != null)
{
// Duplicate original
generatedMesh = Instantiate(OriginalMesh);
#if UNITY_EDITOR
generatedMesh.hideFlags = HideFlags.DontSave;
#endif
generatedMesh.name = OriginalMesh.name + " (Planet)";
// Displace vertices
var uv = OriginalMesh.uv;
var positions = OriginalMesh.vertices;
var tangents = OriginalMesh.tangents;
var coords = new List <Vector2>();
for (var i = 0; i < uv.Length; i++)
{
var position = positions[i];
var tangent = tangents[i];
var coord = default(Vector2);
if (position.y > 0.0f)
{
coord.x = -position.x;
coord.y = position.z;
}
else
{
coord.x = position.x;
coord.y = position.z;
}
/*
* position.y = 0.0f;
*
* if (position.sqrMagnitude < 0.0001f)
* {
* var pos = position.normalized;
* tangent = new Vector4(pos.x, pos.y, pos.z, -1.0f);
* }
*/
coords.Add(coord * CapScale);
tangents[i] = tangent;
}
generatedMesh.SetUVs(1, coords);
generatedMesh.tangents = tangents;
}
if (meshFilterSet == false)
{
meshFilter = GetComponent <MeshFilter>();
meshFilterSet = true;
}
meshFilter.sharedMesh = generatedMesh;
}
protected virtual void OnDestroy()
{
SgtHelper.Destroy(generatedMesh);
}
protected virtual void OnDestroy()
{
SgtHelper.Destroy(generatedTexture);
}
public void UpdateTexture()
{
if (Source == null)
{
Source = CachedShadowRing.Texture as Texture2D;
}
if (Source != null)
{
var width = Source.width;
#if UNITY_EDITOR
SgtHelper.MakeTextureReadable(Source);
#endif
// Destroy if invalid
if (generatedTexture != null)
{
if (generatedTexture.width != width || generatedTexture.height != 1 || generatedTexture.format != Format)
{
generatedTexture = SgtHelper.Destroy(generatedTexture);
}
}
// Create?
if (generatedTexture == null)
{
generatedTexture = SgtHelper.CreateTempTexture2D("Ring Shadow (Generated)", width, 1, Format);
generatedTexture.wrapMode = TextureWrapMode.Clamp;
ApplyTexture();
}
if (bufferA == null || bufferA.Length != width)
{
bufferA = new Color[width];
bufferB = new Color[width];
}
for (var x = 0; x < width; x++)
{
bufferA[x] = bufferB[x] = Source.GetPixel(x, 0);
}
if (Invert == true)
{
for (var x = 0; x < width; x++)
{
var a = bufferA[x];
bufferA[x] = bufferB[x] = new Color(1.0f - a.r, 1.0f - a.g, 1.0f - a.b, 1.0f - a.a);
}
}
if (ShareRGB == true)
{
for (var x = 0; x < width; x++)
{
var a = bufferA[x].a;
bufferA[x] = bufferB[x] = new Color(a, a, a, a);
}
}
for (var i = 0; i < Iterations; i++)
{
SwapBuffers();
for (var x = width - 2; x >= 1; x--)
{
WritePixel(x);
}
}
for (var x = 0; x < width; x++)
{
generatedTexture.SetPixel(x, 0, bufferB[x]);
}
generatedTexture.SetPixel(0, 0, Color.white);
generatedTexture.SetPixel(width - 1, 0, Color.white);
generatedTexture.Apply();
}
}
protected override float DoCalculate(Vector3 eye, Vector3 target)
{
var coverage = 0.0f;
if (Resolution > 0 && Size > 0.0f)
{
if (renderTexture != null)
{
if (renderTexture.width != Resolution || renderTexture.height != Resolution)
{
renderTexture = SgtHelper.Destroy(renderTexture);
}
}
if (renderTexture == null)
{
renderTexture = new RenderTexture(Resolution, Resolution, 16);
}
if (readTexture != null)
{
if (readTexture.width != Resolution || readTexture.height != Resolution)
{
readTexture = SgtHelper.Destroy(readTexture);
}
}
if (readTexture == null)
{
readTexture = new Texture2D(Resolution, Resolution);
}
var oldPosition = transform.localPosition;
var oldRotation = transform.localRotation;
// Render
UpdateCamera();
cachedCamera.farClipPlane = Vector3.Distance(eye, target);
cachedCamera.transform.position = eye;
cachedCamera.transform.LookAt(target);
cachedCamera.targetTexture = renderTexture;
cachedCamera.Render();
// Copy
RenderTexture.active = renderTexture;
readTexture.ReadPixels(new Rect(0.0f, 0.0f, Resolution, Resolution), 0, 0);
// Clear
RenderTexture.active = null;
cachedCamera.targetTexture = null;
transform.localPosition = oldPosition;
transform.localRotation = oldRotation;
// Calculate
for (var y = 0; y < Resolution; y++)
{
for (var x = 0; x < Resolution; x++)
{
var pixel = readTexture.GetPixel(x, y);
coverage += Mathf.Clamp01(pixel.a);
}
}
// Divide alpha coverage by square of resolution to get 0..1
coverage /= Resolution * Resolution;
}
return(coverage);
}
private void HandlePipelineChanged(bool isScriptable)
{
material = SgtHelper.Destroy(material);
UpdateMaterial();
}
