private void CameraPreCull(Camera camera)
{
if (busy == true)
{
return;
}
if (Model != null)
{
Model.Revert();
{
if (FollowCameras == true)
{
Model.transform.position = camera.transform.position - Model.transform.forward * FollowDistance;
}
if (SgtHelper.Enabled(Depth) == true)
{
busy = true;
{
Model.transform.localScale *= 1.0f - Depth.Calculate(camera.transform.position, Model.transform.position);
}
busy = false;
}
// Face camera with offset
var cameraDir = (Model.transform.position - camera.transform.position).normalized;
Model.transform.rotation = camera.transform.rotation;
Model.transform.position += cameraDir * CameraOffset;
}
Model.Save(camera);
}
}
public static int WriteShadows(List <SgtShadow> shadows, int maxShadows, params Material[] materials)
{
var shadowCount = 0;
if (shadows != null)
{
for (var i = shadows.Count - 1; i >= 0; i--)
{
var shadow = shadows[i];
if (SgtHelper.Enabled(shadow) == true && shadow.CalculateShadow() == true && shadowCount < maxShadows)
{
var prefix = "_Shadow" + (++shadowCount);
for (var j = materials.Length - 1; j >= 0; j--)
{
var material = materials[j];
if (material != null)
{
material.SetTexture(prefix + "Texture", shadow.GetTexture());
material.SetMatrix(prefix + "Matrix", shadow.Matrix);
material.SetFloat(prefix + "Ratio", shadow.Ratio);
}
}
}
}
}
return(shadowCount);
}
protected override void OnInspector()
{
BeginError(Any(t => t.Light == null));
{
DrawDefault("Light");
}
EndError();
BeginError(Any(t => t.Texture == null));
{
DrawDefault("Texture");
}
EndError();
DrawDefault("Ring");
EditorGUI.BeginDisabledGroup(Any(t => SgtHelper.Enabled(t.Ring)));
{
BeginError(Any(t => t.InnerRadius < 0.0f || t.InnerRadius >= t.OuterRadius));
{
DrawDefault("InnerRadius");
}
EndError();
BeginError(Any(t => t.OuterRadius < 0.0f || t.InnerRadius >= t.OuterRadius));
{
DrawDefault("OuterRadius");
}
EndError();
}
EditorGUI.EndDisabledGroup();
}
protected override float CalculateOuterPower(Vector3 cameraPosition, float clampedAltitude)
{
var cameraDir = (cameraPosition - transform.position).normalized;
var lightCount = 0;
var maxLights = 2;
var strength = 1.0f - clampedAltitude;
for (var i = Lights.Count - 1; i >= 0; i--)
{
var light = Lights[i];
if (SgtHelper.Enabled(light) == true && light.intensity > 0.0f && lightCount < maxLights)
{
var direction = default(Vector3);
var position = default(Vector3);
var color = default(Color);
SgtHelper.CalculateLight(light, transform.position, null, null, ref position, ref direction, ref color);
var dot = Vector3.Dot(direction, cameraDir);
var lighting = LightingBrightness.Evaluate(dot * 0.5f + 0.5f);
clampedAltitude += (1.0f - lighting.a) * strength;
}
}
return(base.CalculateOuterPower(cameraPosition, clampedAltitude));
}
public virtual bool CalculateShadow()
{
if (SgtHelper.Enabled(Light) == true && Light.intensity > 0.0f)
{
return(true);
}
return(false);
}
public virtual bool CalculateShadow(ref Matrix4x4 matrix, ref float ratio)
{
if (SgtHelper.Enabled(Light) == true && Light.intensity > 0.0f)
{
return(true);
}
return(false);
}
protected virtual void OnDrawGizmosSelected()
{
if (SgtHelper.Enabled(this) == true)
{
var r0 = transform.lossyScale;
SgtHelper.DrawSphere(transform.position, transform.right * r0.x, transform.up * r0.y, transform.forward * r0.z);
}
}
protected virtual void OnDrawGizmosSelected()
{
if (SgtHelper.Enabled(this) == true)
{
var r1 = InnerMeshRadius;
var r2 = OuterRadius;
SgtHelper.DrawSphere(transform.position, transform.right * transform.lossyScale.x * r1, transform.up * transform.lossyScale.y * r1, transform.forward * transform.lossyScale.z * r1);
SgtHelper.DrawSphere(transform.position, transform.right * transform.lossyScale.x * r2, transform.up * transform.lossyScale.y * r2, transform.forward * transform.lossyScale.z * r2);
}
}
// Writes light data to tempMaterials
public static void WriteLights(bool lit, List <Light> lights, int maxLights, Vector3 center, Transform directionTransform, Transform positionTransform, Color tint, float scatterStrength)
{
var lightCount = 0;
if (lit == true && lights != null)
{
for (var i = 0; i < lights.Count && lightCount < maxLights; i++)
{
var light = lights[i];
if (SgtHelper.Enabled(light) == true && light.intensity > 0.0f)
{
var prefix = "_Light" + (++lightCount);
var direction = default(Vector3);
var position = default(Vector3);
var color = default(Color);
CalculateLight(light, center, directionTransform, positionTransform, ref position, ref direction, ref color);
var position4 = SgtHelper.NewVector4(position, 1.0f);
for (var j = tempMaterials.Count - 1; j >= 0; j--)
{
var tempMaterial = tempMaterials[j];
if (tempMaterial != null)
{
tempMaterial.SetVector(prefix + "Direction", direction);
tempMaterial.SetVector(prefix + "Position", position4);
tempMaterial.SetColor(prefix + "Color", color * tint);
tempMaterial.SetColor(prefix + "Scatter", color * tint * scatterStrength);
}
}
}
}
}
for (var i = 0; i <= maxLights; i++)
{
if (lit == true && i == lightCount)
{
EnableKeyword("LIGHT_" + i);
}
else
{
DisableKeyword("LIGHT_" + i);
}
}
}
protected virtual void OnDrawGizmosSelected()
{
if (SgtHelper.Enabled(this) == true)
{
Gizmos.matrix = transform.localToWorldMatrix;
Gizmos.DrawWireSphere(Vector3.zero, InnerRadius);
Gizmos.DrawWireSphere(Vector3.zero, OuterRadius);
if (CalculateShadow() == true)
{
Gizmos.matrix = Matrix.inverse;
Gizmos.DrawWireCube(new Vector3(0, 0, 5), new Vector3(2, 2, 10));
}
}
}
protected virtual void OnDrawGizmosSelected()
{
if (SgtHelper.Enabled(this) == true)
{
if (transform.parent != null)
{
Gizmos.matrix = transform.parent.localToWorldMatrix;
}
var r1 = Radius;
var r2 = Radius * (1.0f - Oblateness);
SgtHelper.DrawCircle(Center, Vector3.right * r1, Vector3.forward * r2);
Gizmos.DrawLine(Vector3.zero, transform.localPosition);
}
}
public static void WriteShadows(List <SgtShadow> shadows, int maxShadows)
{
var shadowCount = 0;
if (shadows != null)
{
var shadowsCount = shadows.Count;
for (var i = 0; i < shadowsCount && shadowCount < maxShadows; i++)
{
var shadow = shadows[i];
var matrix = default(Matrix4x4);
var ratio = default(float);
if (SgtHelper.Enabled(shadow) == true && shadow.CalculateShadow(ref matrix, ref ratio) == true)
{
var prefix = "_Shadow" + (++shadowCount);
for (var j = tempMaterials.Count - 1; j >= 0; j--)
{
var tempMaterial = tempMaterials[j];
if (tempMaterial != null)
{
tempMaterial.SetTexture(prefix + "Texture", shadow.GetTexture());
tempMaterial.SetMatrix(prefix + "Matrix", matrix);
tempMaterial.SetFloat(prefix + "Ratio", ratio);
}
}
}
}
}
for (var i = 1; i <= maxShadows; i++)
{
if (i == shadowCount)
{
EnableKeyword("SHADOW_" + i);
}
else
{
DisableKeyword("SHADOW_" + i);
}
}
}
protected override void OnInspector()
{
BeginError(Any(t => t.Light == null));
DrawDefault("Light");
EndError();
BeginError(Any(t => t.Texture == null));
DrawDefault("Texture");
EndError();
DrawDefault("RingMesh");
BeginDisabled(Any(t => SgtHelper.Enabled(t.RingMesh)));
BeginError(Any(t => t.RadiusMin < 0.0f || t.RadiusMin >= t.RadiusMax));
DrawDefault("RadiusMin");
EndError();
BeginError(Any(t => t.RadiusMax < 0.0f || t.RadiusMin >= t.RadiusMax));
DrawDefault("RadiusMax");
EndError();
EndDisabled();
}
public Material[] GetMaterials(SgtTerrainLevel level)
{
var finalMaterial = GetMaterial(level);
if (SgtHelper.Enabled(Atmosphere) == true)
{
materials2[0] = finalMaterial;
materials2[1] = Atmosphere.InnerMaterial;
return(materials2);
}
else
{
materials1[0] = finalMaterial;
return(materials1);
}
}
private int WriteWells(int maxWells)
{
var wellCount = 0;
var wells = UseAllWells == true ? SgtSpacetimeWell.AllWells : Wells;
for (var i = wells.Count - 1; i >= 0; i--)
{
var well = wells[i];
if (SgtHelper.Enabled(well) == true && well.Radius > 0.0f)
{
// If the well list is atuo generated, allow well filtering
if (UseAllWells == true)
{
if (RequireSameLayer == true && gameObject.layer != well.gameObject.layer)
{
continue;
}
if (RequireSameTag == true && tag != well.tag)
{
continue;
}
if (string.IsNullOrEmpty(RequireNameContains) == false && well.name.Contains(RequireNameContains) == false)
{
continue;
}
}
var prefix = "_Well" + (++wellCount);
material.SetVector(prefix + "_Pos", well.transform.position);
material.SetVector(prefix + "_Dat", new Vector4(well.Radius, well.Age, well.Strength, 0.0f));
}
if (wellCount >= maxWells)
{
break;
}
}
return(wellCount);
}
protected virtual void OnDrawGizmosSelected()
{
if (SgtHelper.Enabled(this) == true)
{
var matrix = default(Matrix4x4);
var ratio = default(float);
if (CalculateShadow(ref matrix, ref ratio) == true)
{
Gizmos.matrix = matrix.inverse;
var distA = 0.0f;
var distB = 1.0f;
var scale = 1.0f * Mathf.Deg2Rad;
var inner = SgtHelper.Divide(RadiusMin, RadiusMax);
for (var i = 1; i < 10; i++)
{
var posA = new Vector3(0.0f, 0.0f, distA);
var posB = new Vector3(0.0f, 0.0f, distB);
Gizmos.color = new Color(1.0f, 1.0f, 1.0f, Mathf.Pow(0.75f, i) * 0.125f);
for (var a = 1; a <= 360; a++)
{
posA.x = posB.x = Mathf.Sin(a * scale);
posA.y = posB.y = Mathf.Cos(a * scale);
Gizmos.DrawLine(posA, posB);
posA.x = posB.x = posA.x * inner;
posA.y = posB.y = posA.y * inner;
Gizmos.DrawLine(posA, posB);
}
distA = distB;
distB = distB * 2.0f;
}
}
}
}
public override bool CalculateShadow(ref Matrix4x4 matrix, ref float ratio)
{
if (base.CalculateShadow(ref matrix, ref ratio) == true)
{
if (Texture != null)
{
if (SgtHelper.Enabled(RingMesh) == true)
{
RadiusMin = RingMesh.RadiusMin;
RadiusMax = RingMesh.RadiusMax;
}
var direction = default(Vector3);
var position = default(Vector3);
var color = default(Color);
SgtHelper.CalculateLight(Light, transform.position, null, null, ref position, ref direction, ref color);
var rotation = Quaternion.FromToRotation(direction, Vector3.back);
var squash = Vector3.Dot(direction, transform.up); // Find how squashed the ellipse is based on light direction
var width = transform.lossyScale.x * RadiusMax;
var length = transform.lossyScale.z * RadiusMax;
var axis = rotation * transform.up; // Find the transformed up axis
var spin = Quaternion.LookRotation(Vector3.forward, new Vector2(-axis.x, axis.y)); // Orient the shadow ellipse
var scale = SgtHelper.Reciprocal3(new Vector3(width, length * Mathf.Abs(squash), 1.0f));
var skew = Mathf.Tan(SgtHelper.Acos(-squash));
var shadowT = SgtHelper.Translation(-transform.position);
var shadowR = SgtHelper.Rotation(spin * rotation); // Spin the shadow so lines up with its tilt
var shadowS = SgtHelper.Scaling(scale); // Scale the ring into an oval
var shadowK = SgtHelper.ShearingZ(new Vector2(0.0f, skew)); // Skew the shadow so it aligns with the ring plane
matrix = shadowS * shadowK * shadowR * shadowT;
ratio = SgtHelper.Divide(RadiusMax, RadiusMax - RadiusMin);
return(true);
}
}
return(false);
}
public static void WriteShadowsNonSerialized(List <SgtShadow> shadows, int maxShadows)
{
if (shadows != null)
{
var shadowCount = 0;
for (var i = 0; i < shadows.Count && shadowCount < maxShadows; i++)
{
var shadow = shadows[i];
var matrix = default(Matrix4x4);
var ratio = default(float);
if (SgtHelper.Enabled(shadow) == true && shadow.CalculateShadow(ref matrix, ref ratio) == true)
{
var prefix = "_Shadow" + (++shadowCount);
SetMatrix(prefix + "Matrix", matrix);
}
}
}
}
public static int WriteLights(List <Light> lights, int maxLights, Vector3 center, Transform directionTransform, Transform positionTransform, params Material[] materials)
{
var lightCount = 0;
if (lights != null)
{
for (var i = lights.Count - 1; i >= 0; i--)
{
var light = lights[i];
if (SgtHelper.Enabled(light) == true && light.intensity > 0.0f && lightCount < maxLights)
{
var prefix = "_Light" + (++lightCount);
var direction = default(Vector3);
var position = default(Vector3);
var color = default(Color);
CalculateLight(light, center, directionTransform, positionTransform, ref position, ref direction, ref color);
for (var j = materials.Length - 1; j >= 0; j--)
{
var material = materials[j];
if (material != null)
{
material.SetVector(prefix + "Direction", direction);
material.SetVector(prefix + "Position", SgtHelper.NewVector4(position, 1.0f));
material.SetColor(prefix + "Color", color);
}
}
}
}
}
return(lightCount);
}
private void WriteWells(ref int gaussianCount, ref int rippleCount, ref int twistCount)
{
var wells = UseAllWells == true ? SgtSpacetimeWell.AllWells : Wells;
if (wells != null)
{
for (var i = wells.Count - 1; i >= 0; i--)
{
var well = wells[i];
if (SgtHelper.Enabled(well) == true && well.Radius > 0.0f)
{
if (well.Distribution == SgtSpacetimeWell.DistributionType.Gaussian && gaussianCount >= gauPos.Length)
{
continue;
}
if (well.Distribution == SgtSpacetimeWell.DistributionType.Ripple && rippleCount >= ripPos.Length)
{
continue;
}
if (well.Distribution == SgtSpacetimeWell.DistributionType.Twist && twistCount >= twiPos.Length)
{
continue;
}
// If the well list is atuo generated, allow well filtering
if (UseAllWells == true)
{
if (RequireSameLayer == true && gameObject.layer != well.gameObject.layer)
{
continue;
}
if (RequireSameTag == true && tag != well.tag)
{
continue;
}
if (string.IsNullOrEmpty(RequireNameContains) == false && well.name.Contains(RequireNameContains) == false)
{
continue;
}
}
var wellPos = well.transform.position;
switch (well.Distribution)
{
case SgtSpacetimeWell.DistributionType.Gaussian:
{
var index = gaussianCount++;
gauPos[index] = new Vector4(wellPos.x, wellPos.y, wellPos.z, well.Radius);
gauDat[index] = new Vector4(well.Strength, 0.0f, 0.0f, 0.0f);
}
break;
case SgtSpacetimeWell.DistributionType.Ripple:
{
var index = rippleCount++;
ripPos[index] = new Vector4(wellPos.x, wellPos.y, wellPos.z, well.Radius);
ripDat[index] = new Vector4(well.Strength, well.Frequency, well.Offset, 0.0f);
}
break;
case SgtSpacetimeWell.DistributionType.Twist:
{
var index = twistCount++;
twiPos[index] = new Vector4(wellPos.x, wellPos.y, wellPos.z, well.Radius);
twiDat[index] = new Vector4(well.Strength, well.Frequency, well.HoleSize, well.HolePower);
twiMat[index] = well.transform.worldToLocalMatrix;
}
break;
}
}
}
Material.SetVectorArray("_GauPos", gauPos);
Material.SetVectorArray("_GauDat", gauDat);
Material.SetVectorArray("_RipPos", ripPos);
Material.SetVectorArray("_RipDat", ripDat);
Material.SetVectorArray("_TwiPos", twiPos);
Material.SetVectorArray("_TwiDat", twiDat);
Material.SetMatrixArray("_TwiMat", twiMat);
}
}
protected void DrawPointMaterial(ref bool updateMaterial)
{
DrawDefault("Softness", ref updateMaterial);
if (Any(t => t.Softness > 0.0f))
{
foreach (var camera in Camera.allCameras)
{
if (SgtHelper.Enabled(camera) == true && camera.depthTextureMode == DepthTextureMode.None)
{
if ((camera.cullingMask & (1 << Target.gameObject.layer)) != 0)
{
if (HelpButton("You have enabled soft particles, but the '" + camera.name + "' camera does not write depth textures.", MessageType.Error, "Fix", 50.0f) == true)
{
var dtm = SgtHelper.GetOrAddComponent <SgtDepthTextureMode>(camera.gameObject);
dtm.DepthMode = DepthTextureMode.Depth;
dtm.UpdateDepthMode();
Selection.activeObject = dtm;
}
}
}
}
}
Separator();
DrawDefault("FollowCameras", ref updateMaterial);
if (Any(t => t.FollowCameras == true && t.Wrap == true))
{
EditorGUILayout.HelpBox("This setting shouldn't be used with 'Wrap'", MessageType.Warning);
}
DrawDefault("Wrap", ref updateMaterial);
if (Any(t => t.Wrap == true))
{
BeginIndent();
BeginError(Any(t => t.WrapSize.x == 0.0f || t.WrapSize.y == 0.0f || t.WrapSize.z == 0.0f));
DrawDefault("WrapSize", ref updateMaterial);
EndError();
EndIndent();
}
DrawDefault("FadeNear", ref updateMaterial);
if (Any(t => t.FadeNear == true))
{
BeginIndent();
BeginError(Any(t => t.FadeNearTex == null));
DrawDefault("FadeNearTex", ref updateMaterial);
EndError();
BeginError(Any(t => t.FadeNearRadius < 0.0f));
DrawDefault("FadeNearRadius", ref updateMaterial);
EndError();
BeginError(Any(t => t.FadeNearThickness <= 0.0f));
DrawDefault("FadeNearThickness", ref updateMaterial);
EndError();
EndIndent();
}
DrawDefault("FadeFar", ref updateMaterial);
if (Any(t => t.FadeFar == true))
{
BeginIndent();
BeginError(Any(t => t.FadeFarTex == null));
DrawDefault("FadeFarTex", ref updateMaterial);
EndError();
BeginError(Any(t => t.FadeFarRadius < 0.0f));
DrawDefault("FadeFarRadius", ref updateMaterial);
EndError();
BeginError(Any(t => t.FadeFarThickness <= 0.0f));
DrawDefault("FadeFarThickness", ref updateMaterial);
EndError();
EndIndent();
}
DrawDefault("Stretch", ref updateMaterial);
if (Any(t => t.Stretch == true))
{
BeginIndent();
DrawDefault("StretchVector", ref updateMaterial);
BeginError(Any(t => t.StretchScale < 0.0f));
DrawDefault("StretchScale", ref updateMaterial);
EndError();
EndIndent();
}
DrawDefault("Pulse", ref updateMaterial);
if (Any(t => t.Pulse == true))
{
BeginIndent();
DrawDefault("PulseOffset");
BeginError(Any(t => t.PulseSpeed == 0.0f));
DrawDefault("PulseSpeed");
EndError();
EndIndent();
}
if (Any(t => t.FadeNear == true && t.FadeNearTex == null && t.GetComponent <SgtStarfieldFadeNear>() == null))
{
Separator();
if (Button("Add Fade Near") == true)
{
Each(t => SgtHelper.GetOrAddComponent <SgtStarfieldFadeNear>(t.gameObject));
}
}
if (Any(t => t.FadeFar == true && t.FadeFarTex == null && t.GetComponent <SgtStarfieldFadeFar>() == null))
{
Separator();
if (Button("Add Fade Far") == true)
{
Each(t => SgtHelper.GetOrAddComponent <SgtStarfieldFadeFar>(t.gameObject));
}
}
}
