public void UpdateFlare(Sprite sprite, Vector3 targetScale, float flicker, float dampening)
{
// Get or add SpriteRenderer?
if (spriteRenderer == null)
{
spriteRenderer = SgtHelper.GetOrAddComponent <SpriteRenderer>(gameObject);
spriteRenderer.sharedMaterial = FlareMaterial;
}
// Assign the default material?
if (spriteRenderer.sharedMaterial == null)
{
SgtHelper.BeginStealthSet(spriteRenderer);
{
spriteRenderer.sharedMaterial = FlareMaterial;
}
SgtHelper.EndStealthSet();
}
// Assign the current sprite?
if (spriteRenderer.sprite != sprite)
{
spriteRenderer.sprite = sprite;
}
// Transition scale
CurrentScale = SgtHelper.Dampen3(CurrentScale, targetScale, dampening, Time.deltaTime, 0.1f);
finalScale = CurrentScale * (1.0f - flicker);
}
public void ManualUpdate(Mesh mesh, Material material)
{
if (Jovian != null)
{
if (MeshFilter == null)
{
MeshFilter = gameObject.AddComponent <MeshFilter>();
}
if (MeshRenderer == null)
{
MeshRenderer = gameObject.AddComponent <MeshRenderer>();
}
if (MeshFilter.sharedMesh != mesh)
{
SgtHelper.BeginStealthSet(MeshFilter);
{
MeshFilter.sharedMesh = mesh;
}
SgtHelper.EndStealthSet();
}
if (MeshRenderer.sharedMaterial != material)
{
SgtHelper.BeginStealthSet(MeshRenderer);
{
MeshRenderer.sharedMaterial = material;
}
SgtHelper.EndStealthSet();
}
}
}
public void ObserverPreCull(SgtObserver observer)
{
if (ObserverOffset != 0.0f)
{
for (var i = models.Count - 1; i >= 0; i--)
{
var model = models[i];
if (model != null)
{
var modelTransform = model.transform;
var oldPosition = modelTransform.position;
var observerDir = (oldPosition - observer.transform.position).normalized;
model.TempPosition = oldPosition;
SgtHelper.BeginStealthSet(modelTransform);
{
modelTransform.position += observerDir * ObserverOffset;
}
SgtHelper.EndStealthSet();
}
}
}
}
public void ObserverPreCull(SgtObserver observer)
{
if (ObserverOffset != 0.0f)
{
for (var i = planes.Count - 1; i >= 0; i--)
{
var plane = planes[i];
if (plane != null)
{
var planeTransform = plane.transform;
var oldPosition = planeTransform.position;
var observerDir = (oldPosition - observer.transform.position).normalized;
plane.TempPosition = oldPosition;
SgtHelper.BeginStealthSet(planeTransform);
{
planeTransform.position += observerDir * ObserverOffset;
}
SgtHelper.EndStealthSet();
}
}
}
}
public void ManualUpdate(Mesh mesh, Material material, Quaternion rotation)
{
if (Ring != null)
{
if (MeshFilter == null)
{
MeshFilter = gameObject.AddComponent <MeshFilter>();
}
if (MeshRenderer == null)
{
MeshRenderer = gameObject.AddComponent <MeshRenderer>();
}
if (MeshFilter.sharedMesh != mesh)
{
SgtHelper.BeginStealthSet(MeshFilter);
{
MeshFilter.sharedMesh = mesh;
}
SgtHelper.EndStealthSet();
}
if (MeshRenderer.sharedMaterial != material)
{
SgtHelper.BeginStealthSet(MeshRenderer);
{
MeshRenderer.sharedMaterial = material;
}
SgtHelper.EndStealthSet();
}
SgtHelper.SetLocalRotation(transform, rotation);
}
}
public void ManualUpdate(Mesh mesh, Material material, float scale)
{
if (Cloudsphere != null)
{
if (MeshFilter == null)
{
MeshFilter = gameObject.AddComponent <MeshFilter>();
}
if (MeshRenderer == null)
{
MeshRenderer = gameObject.AddComponent <MeshRenderer>();
}
if (MeshFilter.sharedMesh != mesh)
{
SgtHelper.BeginStealthSet(MeshFilter);
{
MeshFilter.sharedMesh = mesh;
}
SgtHelper.EndStealthSet();
}
if (MeshRenderer.sharedMaterial != material)
{
SgtHelper.BeginStealthSet(MeshRenderer);
{
MeshRenderer.sharedMaterial = material;
}
SgtHelper.EndStealthSet();
}
SgtHelper.SetLocalScale(transform, scale);
}
}
private void UpdateMaterials()
{
var coronaMaterial = Terrain.CoronaMaterial;
var sharedMaterials = meshRenderer.sharedMaterials;
if (coronaMaterial != null)
{
if (sharedMaterials.Length != 2 || sharedMaterials[0] != FinalMaterial || sharedMaterials[1] != coronaMaterial)
{
sharedMaterials2[0] = FinalMaterial;
sharedMaterials2[1] = coronaMaterial;
SgtHelper.BeginStealthSet(meshRenderer);
{
meshRenderer.sharedMaterials = sharedMaterials2;
}
SgtHelper.EndStealthSet();
}
}
else
{
if (sharedMaterials.Length != 1 || sharedMaterials[0] != FinalMaterial)
{
sharedMaterials1[0] = FinalMaterial;
SgtHelper.BeginStealthSet(meshRenderer);
{
meshRenderer.sharedMaterials = sharedMaterials1;
}
SgtHelper.EndStealthSet();
}
}
}
public virtual void ObserverPreCull(SgtObserver observer)
{
for (var i = groups.Count - 1; i >= 0; i--)
{
var group = groups[i];
if (group != null)
{
if (group.Material != null)
{
group.Material.SetFloat("_CameraRollAngle", observer.RollAngle * Mathf.Deg2Rad);
if (StretchToObservers == true)
{
var velocity = (StretchOverride == true ? StretchVector : observer.Velocity) * StretchScale;
group.Material.SetVector("_StretchVector", velocity);
group.Material.SetVector("_StretchDirection", velocity.normalized);
group.Material.SetFloat("_StretchLength", velocity.magnitude);
}
}
if (FollowObservers == true)
{
group.TempPosition = group.transform.position;
SgtHelper.BeginStealthSet(group.transform);
{
group.transform.position = observer.transform.position;
}
SgtHelper.EndStealthSet();
}
}
}
}
public void ManualUpdate()
{
if (Group != null)
{
if (MeshFilter == null)
{
MeshFilter = gameObject.AddComponent <MeshFilter>();
}
if (MeshRenderer == null)
{
MeshRenderer = gameObject.AddComponent <MeshRenderer>();
}
if (MeshFilter.sharedMesh != Mesh)
{
SgtHelper.BeginStealthSet(MeshFilter);
{
MeshFilter.sharedMesh = Mesh;
}
SgtHelper.EndStealthSet();
}
if (MeshRenderer.sharedMaterial != Group.Material)
{
SgtHelper.BeginStealthSet(MeshRenderer);
{
MeshRenderer.sharedMaterial = Group.Material;
}
SgtHelper.EndStealthSet();
}
}
}
private void UpdateCollider(bool enableColliders)
{
if (enableColliders == true)
{
if (Mesh == null)
{
SgtPatchBuilder.GenerateMesh(this);
}
if (meshCollider == null)
{
meshCollider = SgtHelper.GetOrAddComponent <MeshCollider>(gameObject);
}
if (meshCollider.sharedMesh != Mesh)
{
SgtHelper.BeginStealthSet(meshCollider);
{
meshCollider.sharedMesh = Mesh;
}
SgtHelper.EndStealthSet();
}
SgtHelper.SetEnabled(meshCollider, true);
}
else
{
SgtHelper.SetEnabled(meshCollider, false);
}
}
private void RemoveMaterial()
{
for (var i = Renderers.Count - 1; i >= 0; i--)
{
var renderer = Renderers[i];
SgtHelper.BeginStealthSet(renderer);
{
SgtHelper.RemoveMaterial(renderer, depthMaterial);
}
SgtHelper.EndStealthSet();
}
}
protected virtual void LateUpdate()
{
UpdateMaterial();
for (var i = Renderers.Count - 1; i >= 0; i--)
{
var renderer = Renderers[i];
SgtHelper.BeginStealthSet(renderer);
{
SgtHelper.AddMaterial(renderer, depthMaterial);
}
SgtHelper.EndStealthSet();
}
}
private void UpdateInnerRenderers()
{
for (var i = InnerRenderers.Count - 1; i >= 0; i--)
{
var innerRenderer = InnerRenderers[i];
if (innerRenderer != null)
{
SgtHelper.BeginStealthSet(innerRenderer);
{
SgtHelper.ReplaceMaterial(innerRenderer, innerMaterial);
}
SgtHelper.EndStealthSet();
}
}
}
private void UpdateRenderers()
{
for (var i = Renderers.Count - 1; i >= 0; i--)
{
var renderer = Renderers[i];
if (renderer != null && renderer.sharedMaterial != material)
{
SgtHelper.BeginStealthSet(renderer);
{
renderer.sharedMaterial = material;
}
SgtHelper.EndStealthSet();
}
}
}
public void ObserverPostRender(SgtObserver observer)
{
if (ObserverOffset != 0.0f)
{
for (var i = models.Count - 1; i >= 0; i--)
{
var model = models[i];
if (model != null)
{
var modelTransform = model.transform;
SgtHelper.BeginStealthSet(modelTransform);
{
modelTransform.position = model.TempPosition;
}
SgtHelper.EndStealthSet();
}
}
}
}
public void ObserverPostRender(SgtObserver observer)
{
if (ObserverOffset != 0.0f)
{
for (var i = planes.Count - 1; i >= 0; i--)
{
var plane = planes[i];
if (plane != null)
{
var planeTransform = plane.transform;
SgtHelper.BeginStealthSet(planeTransform);
{
planeTransform.position = plane.TempPosition;
}
SgtHelper.EndStealthSet();
}
}
}
}
public void ObserverPostRender(SgtObserver observer)
{
for (var i = groups.Count - 1; i >= 0; i--)
{
var group = groups[i];
if (group != null)
{
if (group.Material != null)
{
group.Material.SetFloat("_CameraRollAngle", 0.0f);
}
if (FollowObservers == true)
{
SgtHelper.BeginStealthSet(group.transform);
{
group.transform.position = group.TempPosition;
}
SgtHelper.EndStealthSet();
}
}
}
}
public void UpdateState()
{
if (Material != null)
{
FinalMaterial = Material;
}
else
{
if (Parent != null)
{
FinalMaterial = Parent.FinalMaterial;
}
else
{
FinalMaterial = Terrain.Material;
}
}
if (ChildrenExist == true)
{
if (meshRenderer != null)
{
SgtHelper.SetEnabled(meshRenderer, false);
}
// Has colliders if it's the last depth
UpdateCollider(Depth + 1 == Terrain.MaxColliderDepth);
}
else
{
if (Mesh == null)
{
SgtPatchBuilder.GenerateMesh(this);
}
if (meshRenderer == null)
{
meshRenderer = SgtHelper.GetOrAddComponent <MeshRenderer>(gameObject);
}
if (meshFilter == null)
{
meshFilter = SgtHelper.GetOrAddComponent <MeshFilter>(gameObject);
}
SgtHelper.SetEnabled(meshRenderer, true);
if (meshFilter.sharedMesh != Mesh)
{
SgtHelper.BeginStealthSet(meshFilter);
{
meshFilter.sharedMesh = Mesh;
}
SgtHelper.EndStealthSet();
}
UpdateMaterials();
// Has colliders if it's under max depth
UpdateCollider(Depth < Terrain.MaxColliderDepth);
}
}
