Ejemplo n.º 1
0
        public override void CalculateShadow(SgtLight light)
        {
            var direction = default(Vector3);
            var position  = default(Vector3);
            var color     = default(Color);

            SgtLight.Calculate(light, transform.position, null, null, ref position, ref direction, ref color);

            var dot      = Vector3.Dot(direction, transform.up);
            var radiusXZ = (transform.lossyScale.x + transform.lossyScale.z) * 0.5f * RadiusMax;
            var radiusY  = transform.lossyScale.y * RadiusMax;
            var radius   = GetRadius(radiusY, radiusXZ, dot * Mathf.PI * 0.5f);
            var rotation = Quaternion.FromToRotation(direction, Vector3.back);
            var vector   = rotation * transform.up;
            var spin     = Quaternion.LookRotation(Vector3.forward, new Vector2(-vector.x, vector.y));             // Orient the shadow ellipse
            var scale    = SgtHelper.Reciprocal3(new Vector3(radiusXZ, radius, 1.0f));
            var shadowT  = Matrix4x4.Translate(-transform.position);
            var shadowR  = Matrix4x4.Rotate(spin * rotation);
            var shadowS  = Matrix4x4.Scale(scale);

            cachedActive  = true;
            cachedMatrix  = shadowS * shadowR * shadowT;
            cachedRatio   = SgtHelper.Divide(RadiusMax, RadiusMax - RadiusMin);
            cachedRadius  = SgtHelper.UniformScale(transform.lossyScale) * RadiusMax;
            cachedTexture = generatedTexture;
        }
Ejemplo n.º 2
0
        public override bool CalculateShadow(ref Matrix4x4 matrix, ref float ratio)
        {
            var light = default(SgtLight);

            if (SgtLight.Find(ref light) == true)
            {
                var direction = default(Vector3);
                var position  = default(Vector3);
                var color     = default(Color);

                SgtLight.Calculate(light.CachedLight, transform.position, null, null, ref position, ref direction, ref color);

                var dot      = Vector3.Dot(direction, transform.up);
                var radiusXZ = (transform.lossyScale.x + transform.lossyScale.z) * 0.5f * RadiusMax;
                var radiusY  = transform.lossyScale.y * RadiusMax;
                var radius   = GetRadius(radiusY, radiusXZ, dot * Mathf.PI * 0.5f);
                var rotation = Quaternion.FromToRotation(direction, Vector3.back);
                var vector   = rotation * transform.up;
                var spin     = Quaternion.LookRotation(Vector3.forward, new Vector2(-vector.x, vector.y));                 // Orient the shadow ellipse
                var scale    = SgtHelper.Reciprocal3(new Vector3(radiusXZ, radius, 1.0f));
                var shadowT  = SgtHelper.Translation(-transform.position);
                var shadowR  = SgtHelper.Rotation(spin * rotation);
                var shadowS  = SgtHelper.Scaling(scale);

                matrix = shadowS * shadowR * shadowT;
                ratio  = SgtHelper.Divide(RadiusMax, RadiusMax - RadiusMin);

                return(true);
            }

            return(false);
        }
Ejemplo n.º 3
0
        public override bool CalculateShadow(ref Matrix4x4 matrix, ref float ratio)
        {
            var light = default(SgtLight);

            if (Texture != null && SgtLight.Find(ref light) == true)
            {
                var direction = default(Vector3);
                var position  = default(Vector3);
                var color     = default(Color);

                SgtLight.Calculate(light.CachedLight, 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);
        }
Ejemplo n.º 4
0
        private void HandleCameraDraw(Camera camera)
        {
            if (SgtHelper.CanDraw(gameObject, camera) == false)
            {
                return;
            }

            if (depthTex != null)
            {
#if UNITY_EDITOR
                SgtHelper.MakeTextureReadable(depthTex);
#endif
                material.SetFloat(SgtShader._Sky, GetSky(camera.transform.position));
            }

            var scale  = SgtHelper.Divide(radius, meshRadius);
            var matrix = transform.localToWorldMatrix * Matrix4x4.Scale(Vector3.one * scale);

            if (cameraOffset != 0.0f)
            {
                var direction = Vector3.Normalize(camera.transform.position - transform.position);

                matrix = Matrix4x4.Translate(direction * cameraOffset) * matrix;
            }

            Graphics.DrawMesh(mesh, matrix, material, gameObject.layer, camera);
        }
Ejemplo n.º 5
0
        private void CalculateOcclusion(int layers, Vector4 worldEye, Vector4 worldTgt, ref float occlusion)
        {
            if (SgtOcclusion.IsValid(occlusion, layers, gameObject) == true && OuterRadius > 0.0f && outerDepthTex != null)
            {
                var eye = cachedTransform.InverseTransformPoint(worldEye) / OuterRadius;
                var tgt = cachedTransform.InverseTransformPoint(worldTgt) / OuterRadius;

                var dir    = Vector3.Normalize(tgt - eye);
                var len    = Vector3.Magnitude(tgt - eye);
                var length = default(float);

                if (GetLength(eye, dir, len, ref length) == true)
                {
                    var localPosition  = cachedTransform.InverseTransformPoint(worldEye);
                    var localDistance  = localPosition.magnitude;
                    var innerThickness = default(float);
                    var outerThickness = default(float);
                    var innerRatio     = SgtHelper.Divide(innerMeshRadius, OuterRadius);
                    var middleRatio    = Mathf.Lerp(innerRatio, 1.0f, middle);
                    var distance       = SgtHelper.Divide(localDistance, OuterRadius);
                    var outerDensity   = 1.0f - outerFog;

                    SgtHelper.CalculateHorizonThickness(innerRatio, middleRatio, distance, out innerThickness, out outerThickness);

                    length *= SgtHelper.Reciprocal(outerThickness * outerDensity);

                    var depth = outerDepthTex.GetPixelBilinear(length, length).a;

                    depth = Mathf.Clamp01(depth + (1.0f - depth) * GetSky(worldEye, localDistance));

                    occlusion += (1.0f - occlusion) * depth;
                }
            }
        }
        public override void CalculateShadow(SgtLight light)
        {
            if (Texture != null)
            {
                var direction = default(Vector3);
                var position  = default(Vector3);
                var color     = default(Color);

                SgtLight.Calculate(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 = Matrix4x4.Translate(-transform.position);
                var shadowR = Matrix4x4.Rotate(spin * rotation);            // Spin the shadow so lines up with its tilt
                var shadowS = Matrix4x4.Scale(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

                cachedActive  = true;
                cachedMatrix  = shadowS * shadowK * shadowR * shadowT;
                cachedRatio   = SgtHelper.Divide(RadiusMax, RadiusMax - RadiusMin);
                cachedRadius  = SgtHelper.UniformScale(transform.lossyScale) * RadiusMax;
                cachedTexture = Texture;
            }
            else
            {
                cachedActive = false;
            }
        }
Ejemplo n.º 7
0
        public void UpdateModels()
        {
            var angleStep = SgtHelper.Divide(360.0f, Segments);

            for (var i = 0; i < Segments; i++)
            {
                var model    = GetOrAddModel(i);
                var angle    = angleStep * i;
                var rotation = Quaternion.Euler(0.0f, angle, 0.0f);

                model.SetMesh(Mesh);
                model.SetMaterial(material);
                model.SetRotation(rotation);
            }

            // Remove any excess
            if (models != null)
            {
                var min = Mathf.Max(0, Segments);

                for (var i = models.Count - 1; i >= min; i--)
                {
                    SgtRingModel.Pool(models[i]);

                    models.RemoveAt(i);
                }
            }
        }
Ejemplo n.º 8
0
        private float GetSky(Vector3 eye)
        {
            var localCameraPosition = transform.InverseTransformPoint(eye);
            var localDistance       = localCameraPosition.magnitude;
            var scaleDistance       = SgtHelper.Divide(localDistance, radius);

            return(sky * depthTex.GetPixelBilinear(1.0f - scaleDistance, 0.0f).a);
        }
Ejemplo n.º 9
0
        private void UpdateMaterialNonSerialized()
        {
            var scale        = SgtHelper.Divide(OuterMeshRadius, OuterRadius);
            var worldToLocal = SgtHelper.Scaling(scale) * transform.worldToLocalMatrix;

            innerMaterial.SetMatrix("_WorldToLocal", worldToLocal);
            outerMaterial.SetMatrix("_WorldToLocal", worldToLocal);
        }
Ejemplo n.º 10
0
        private void UpdateMaterialNonSerialized()
        {
            var scale        = SgtHelper.Divide(OuterMeshRadius, OuterRadius);
            var worldToLocal = Matrix4x4.Scale(new Vector3(scale, scale, scale)) * cachedTransform.worldToLocalMatrix;

            innerMaterial.SetMatrix(SgtShader._WorldToLocal, worldToLocal);
            outerMaterial.SetMatrix(SgtShader._WorldToLocal, worldToLocal);
        }
Ejemplo n.º 11
0
        public static void CalculateAtmosphereThicknessAtHorizon(float groundRadius, float skyRadius, float distance, out float groundThickness, out float skyThickness)
        {
            var horizonDistance    = DistanceToHorizon(groundRadius, distance);
            var maxSkyThickness    = Mathf.Sin(Mathf.Acos(SgtHelper.Divide(groundRadius, skyRadius))) * skyRadius;
            var maxGroundThickness = Mathf.Min(horizonDistance, maxSkyThickness);

            groundThickness = Mathf.Max(maxGroundThickness, skyRadius - groundRadius);
            skyThickness    = maxSkyThickness + maxGroundThickness;
        }
Ejemplo n.º 12
0
        private void CameraPreRender(Camera camera)
        {
            if (model != null)
            {
                model.Restore(camera);
            }

            // Write camera-dependant shader values
            if (innerMaterial != null && outerMaterial != null)
            {
                var localPosition  = cachedTransform.InverseTransformPoint(camera.transform.position);
                var localDistance  = localPosition.magnitude;
                var height01       = Mathf.InverseLerp(OuterRadius, InnerMeshRadius, localDistance);
                var innerThickness = default(float);
                var outerThickness = default(float);
                var innerRatio     = SgtHelper.Divide(InnerMeshRadius, OuterRadius);
                var middleRatio    = Mathf.Lerp(innerRatio, 1.0f, Middle);
                var distance       = SgtHelper.Divide(localDistance, OuterRadius);
                var innerDensity   = 1.0f - InnerFog;
                var outerDensity   = 1.0f - OuterFog;

                SgtHelper.CalculateHorizonThickness(innerRatio, middleRatio, distance, out innerThickness, out outerThickness);

                innerMaterial.SetFloat(SgtShader._HorizonLengthRecip, SgtHelper.Reciprocal(innerThickness * innerDensity));
                outerMaterial.SetFloat(SgtShader._HorizonLengthRecip, SgtHelper.Reciprocal(outerThickness * outerDensity));

                if (OuterDepthTex != null)
                {
#if UNITY_EDITOR
                    SgtHelper.MakeTextureReadable(OuterDepthTex);
#endif
                    outerMaterial.SetFloat(SgtShader._Sky, GetSky(camera) * OuterDepthTex.GetPixelBilinear(height01 / outerDensity, 0.0f).a);
                }

                var scale        = SgtHelper.Divide(OuterMeshRadius, OuterRadius);
                var worldToLocal = Matrix4x4.Scale(new Vector3(scale, scale, scale)) * cachedTransform.worldToLocalMatrix;                 // cachedTransform might not be set here, so use the property

                innerMaterial.SetMatrix(SgtShader._WorldToLocal, worldToLocal);
                outerMaterial.SetMatrix(SgtShader._WorldToLocal, worldToLocal);

                // Write lights and shadows
                SgtHelper.SetTempMaterial(innerMaterial, outerMaterial);

                var mask   = 1 << gameObject.layer;
                var lights = SgtLight.Find(Lit, mask);

                SgtShadow.Find(Lit, mask, lights);
                SgtShadow.FilterOutSphere(transform.position);
                SgtShadow.Write(Lit, 2);

                SgtLight.FilterOut(transform.position);
                SgtLight.Write(Lit, transform.position, cachedTransform, null, ScatteringStrength, 2);
            }
        }
Ejemplo n.º 13
0
        public void UpdateModel()
        {
            if (model == null)
            {
                model = SgtCloudsphereModel.Create(this);
            }

            var scale = SgtHelper.Divide(Radius, MeshRadius);

            model.SetMesh(Mesh);
            model.SetMaterial(material);
            model.SetScale(scale);
        }
Ejemplo n.º 14
0
        public void UpdateModel()
        {
            if (model == null)
            {
                model = SgtAtmosphereModel.Create(this);
            }

            var scale = SgtHelper.Divide(OuterRadius, OuterMeshRadius);

            model.SetMesh(OuterMesh);
            model.SetMaterial(outerMaterial);
            model.SetScale(scale);
        }
Ejemplo n.º 15
0
        private void HandleCameraDraw(Camera camera)
        {
            if (SgtHelper.CanDraw(gameObject, camera) == false)
            {
                return;
            }

            // Write camera-dependent shader values
            if (innerMaterial != null && outerMaterial != null)
            {
                var localPosition  = CachedTransform.InverseTransformPoint(camera.transform.position);
                var localDistance  = localPosition.magnitude;
                var innerThickness = default(float);
                var outerThickness = default(float);
                var innerRatio     = SgtHelper.Divide(innerMeshRadius, OuterRadius);
                var middleRatio    = Mathf.Lerp(innerRatio, 1.0f, middle);
                var distance       = SgtHelper.Divide(localDistance, OuterRadius);
                var innerDensity   = 1.0f - innerFog;
                var outerDensity   = 1.0f - outerFog;

                SgtHelper.CalculateHorizonThickness(innerRatio, middleRatio, distance, out innerThickness, out outerThickness);

                innerMaterial.SetFloat(SgtShader._HorizonLengthRecip, SgtHelper.Reciprocal(innerThickness * innerDensity));
                outerMaterial.SetFloat(SgtShader._HorizonLengthRecip, SgtHelper.Reciprocal(outerThickness * outerDensity));

                if (outerDepthTex != null)
                {
#if UNITY_EDITOR
                    SgtHelper.MakeTextureReadable(outerDepthTex);
#endif
                    outerMaterial.SetFloat(SgtShader._Sky, GetSky(localDistance));
                }

                UpdateMaterialNonSerialized();
            }

            var scale  = SgtHelper.Divide(OuterRadius, outerMeshRadius);
            var matrix = CachedTransform.localToWorldMatrix * Matrix4x4.Scale(Vector3.one * scale);

            if (cameraOffset != 0.0f)
            {
                var direction = Vector3.Normalize(camera.transform.position - cachedTransform.position);

                matrix = Matrix4x4.Translate(direction * cameraOffset) * matrix;
            }

            Graphics.DrawMesh(outerMesh, matrix, outerMaterial, gameObject.layer, camera);
        }
Ejemplo n.º 16
0
        private void CameraPreRender(Camera camera)
        {
            if (model != null)
            {
                model.Restore(camera);
            }

            // Write camera-dependant shader values
            if (innerMaterial != null && outerMaterial != null)
            {
                var cameraPosition       = camera.transform.position;
                var localCameraPosition  = transform.InverseTransformPoint(cameraPosition);
                var localDistance        = localCameraPosition.magnitude;
                var clampedSky           = Mathf.InverseLerp(OuterRadius, InnerMeshRadius, localDistance);
                var innerAtmosphereDepth = default(float);
                var outerAtmosphereDepth = default(float);
                var radiusRatio          = SgtHelper.Divide(InnerMeshRadius, OuterRadius);
                var scaleDistance        = SgtHelper.Divide(localDistance, OuterRadius);
                var innerDensity         = 1.0f - InnerFog;
                var outerDensity         = 1.0f - OuterFog;

                SgtHelper.CalculateAtmosphereThicknessAtHorizon(radiusRatio, 1.0f, scaleDistance, out innerAtmosphereDepth, out outerAtmosphereDepth);

                SgtHelper.SetTempMaterial(innerMaterial, outerMaterial);

                if (scaleDistance > 1.0f)
                {
                    SgtHelper.EnableKeyword("SGT_A");                     // Outside
                }
                else
                {
                    SgtHelper.DisableKeyword("SGT_A");                     // Outside
                }

                innerMaterial.SetFloat("_HorizonLengthRecip", SgtHelper.Reciprocal(innerAtmosphereDepth * innerDensity));
                outerMaterial.SetFloat("_HorizonLengthRecip", SgtHelper.Reciprocal(outerAtmosphereDepth * outerDensity));

                if (OuterDepthTex != null)
                {
#if UNITY_EDITOR
                    SgtHelper.MakeTextureReadable(OuterDepthTex);
#endif
                    outerMaterial.SetFloat("_Sky", GetSky(camera) * OuterDepthTex.GetPixelBilinear(clampedSky / outerDensity, 0.0f).a);
                }

                UpdateMaterialNonSerialized();
            }
        }
Ejemplo n.º 17
0
        private void CameraPreRender(Camera camera)
        {
            if (material != null)
            {
                var cameraPosition      = camera.transform.position;
                var localCameraPosition = transform.InverseTransformPoint(cameraPosition);
                var localDistance       = localCameraPosition.magnitude;
                var scaleDistance       = SgtHelper.Divide(localDistance, Radius);

                if (scaleDistance > 1.0f)
                {
                    SgtHelper.EnableKeyword("SGT_A", material);                     // Outside
                }
                else
                {
                    SgtHelper.DisableKeyword("SGT_A", material);                     // Outside

                    if (DepthTex != null)
                    {
#if UNITY_EDITOR
                        SgtHelper.MakeTextureReadable(DepthTex);
#endif
                        material.SetFloat("_Sky", Sky * DepthTex.GetPixelBilinear(1.0f - scaleDistance, 0.0f).a);
                    }
                }

                // Write these once to save CPU
                if (renderedThisFrame == false)
                {
                    renderedThisFrame = true;

                    // Write lights and shadows
                    SgtHelper.SetTempMaterial(material);

                    SgtLight.Write(Lit, transform.position, transform, null, ScatteringStrength, 2);
                    SgtShadow.Write(Lit, gameObject, 2);

                    // Write matrices
                    var localToWorld = transform.localToWorldMatrix * SgtHelper.Scaling(Radius * 2.0f);                     // Double mesh radius so the max thickness caps at 1.0

                    material.SetMatrix("_WorldToLocal", localToWorld.inverse);

                    material.SetMatrix("_LocalToWorld", localToWorld);
                }
            }
        }
Ejemplo n.º 18
0
        public static Vector4 CalculateSpriteUV(Sprite s)
        {
            var uv = default(Vector4);

            if (s != null)
            {
                var r = s.textureRect;
                var t = s.texture;

                uv.x = SgtHelper.Divide(r.xMin, t.width);
                uv.y = SgtHelper.Divide(r.yMin, t.height);
                uv.z = SgtHelper.Divide(r.xMax, t.width);
                uv.w = SgtHelper.Divide(r.yMax, t.height);
            }

            return(uv);
        }
Ejemplo n.º 19
0
        public void UpdateMaterials()
        {
            if (innerMaterial == null)
            {
                innerMaterial = SgtHelper.CreateTempMaterial("Corona Inner (Generated)", SgtHelper.ShaderNamePrefix + "CoronaInner");

                CachedSharedMaterial.Material = innerMaterial;
            }

            if (outerMaterial == null)
            {
                outerMaterial = SgtHelper.CreateTempMaterial("Corona Outer (Generated)", SgtHelper.ShaderNamePrefix + "CoronaOuter");

                if (model != null)
                {
                    model.SetMaterial(outerMaterial);
                }
            }

            var color      = SgtHelper.Brighten(Color, Brightness);
            var innerRatio = SgtHelper.Divide(InnerMeshRadius, OuterRadius);

            innerMaterial.renderQueue = outerMaterial.renderQueue = RenderQueue;

            innerMaterial.SetColor(SgtShader._Color, color);
            outerMaterial.SetColor(SgtShader._Color, color);

            innerMaterial.SetTexture(SgtShader._DepthTex, InnerDepthTex);
            outerMaterial.SetTexture(SgtShader._DepthTex, OuterDepthTex);

            innerMaterial.SetFloat(SgtShader._InnerRatio, innerRatio);
            innerMaterial.SetFloat(SgtShader._InnerScale, 1.0f / (1.0f - innerRatio));

            if (OuterSoftness > 0.0f)
            {
                SgtHelper.EnableKeyword("SGT_A", outerMaterial);                 // Softness

                outerMaterial.SetFloat(SgtShader._SoftParticlesFactor, SgtHelper.Reciprocal(OuterSoftness));
            }
            else
            {
                SgtHelper.DisableKeyword("SGT_A", outerMaterial);                 // Softness
            }

            UpdateMaterialNonSerialized();
        }
Ejemplo n.º 20
0
        private void CameraPreRender(Camera camera)
        {
            if (material != null)
            {
                var cameraPosition      = camera.transform.position;
                var localCameraPosition = transform.InverseTransformPoint(cameraPosition);
                var localDistance       = localCameraPosition.magnitude;
                var scaleDistance       = SgtHelper.Divide(localDistance, Radius);

                if (DepthTex != null)
                {
#if UNITY_EDITOR
                    SgtHelper.MakeTextureReadable(DepthTex);
#endif
                    material.SetFloat(SgtShader._Sky, Sky * DepthTex.GetPixelBilinear(1.0f - scaleDistance, 0.0f).a);
                }

                // Write these once to save CPU
                if (renderedThisFrame == false)
                {
                    renderedThisFrame = true;

                    // Write lights and shadows
                    SgtHelper.SetTempMaterial(material);

                    var mask   = 1 << gameObject.layer;
                    var lights = SgtLight.Find(Lit, mask, transform.position);

                    SgtLight.FilterOut(transform.position);

                    SgtShadow.Find(Lit, mask, lights);
                    SgtShadow.FilterOutSphere(transform.position);
                    SgtShadow.Write(Lit, 2);

                    SgtLight.Write(Lit, transform.position, transform, null, ScatteringStrength, 2);

                    // Write matrices
                    var scale        = Radius;
                    var localToWorld = transform.localToWorldMatrix * Matrix4x4.Scale(new Vector3(scale, scale, scale));                     // Double mesh radius so the max thickness caps at 1.0

                    material.SetMatrix(SgtShader._WorldToLocal, localToWorld.inverse);
                    material.SetMatrix(SgtShader._LocalToWorld, localToWorld);
                }
            }
        }
        protected virtual void OnDrawGizmosSelected()
        {
            var mask   = 1 << gameObject.layer;
            var lights = SgtLight.Find(true, mask);

            if (SgtHelper.Enabled(this) == true && lights.Count > 0)
            {
                CalculateShadow(lights[0]);

                if (cachedActive == true)
                {
                    Gizmos.matrix = cachedMatrix.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;
                    }
                }
            }
        }
Ejemplo n.º 22
0
        private void HandleCameraDraw(Camera camera)
        {
            if (SgtHelper.CanDraw(gameObject, camera) == false)
            {
                return;
            }

            var scale  = SgtHelper.Divide(radius, meshRadius);
            var matrix = cachedTransform.localToWorldMatrix * Matrix4x4.Scale(Vector3.one * scale);

            if (cameraOffset != 0.0f)
            {
                var direction = Vector3.Normalize(camera.transform.position - cachedTransform.position);

                matrix = Matrix4x4.Translate(direction * cameraOffset) * matrix;
            }

            Graphics.DrawMesh(mesh, matrix, generatedMaterial, gameObject.layer, camera);
        }
Ejemplo n.º 23
0
        protected virtual void Update()
        {
            if (Point != null && Title != null)
            {
                var currentPosition = Point.Position;

                if (expectedPositionSet == false)
                {
                    expectedPositionSet = true;
                    expectedPosition    = currentPosition;
                }

                var delta = SgtHelper.Divide(SgtPosition.Distance(ref expectedPosition, ref currentPosition), Time.deltaTime);

                Title.text = "Speed = " + System.Math.Round(delta).ToString("0") + "m/s";

                expectedPosition = currentPosition;
            }
        }
Ejemplo n.º 24
0
        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;
                    }
                }
            }
        }
Ejemplo n.º 25
0
        protected virtual void LateUpdate()
        {
            var scale        = SgtHelper.Divide(outerMeshRadius, OuterRadius);
            var worldToLocal = Matrix4x4.Scale(new Vector3(scale, scale, scale)) * cachedTransform.worldToLocalMatrix;

            innerMaterial.SetMatrix(SgtShader._WorldToLocal, worldToLocal);
            outerMaterial.SetMatrix(SgtShader._WorldToLocal, worldToLocal);

            // Write lights and shadows
            SgtHelper.SetTempMaterial(innerMaterial, outerMaterial);

            var mask   = 1 << gameObject.layer;
            var lights = SgtLight.Find(lit, mask, cachedTransform.position);

            SgtShadow.Find(lit, mask, lights);
            SgtShadow.FilterOutSphere(cachedTransform.position);
            SgtShadow.Write(lit, 2);

            SgtLight.FilterOut(cachedTransform.position);
            SgtLight.Write(lit, cachedTransform.position, cachedTransform, null, scatteringStrength, 2);
        }
Ejemplo n.º 26
0
        protected virtual void Update()
        {
            if (LightningSpawner == null)
            {
                Pool(this);
            }
            else
            {
                if (Application.isPlaying == true)
                {
                    Age += Time.deltaTime;
                }

                if (Age >= Life)
                {
                    SgtComponentPool <SgtLightning> .Add(this);
                }
                else if (material != null)
                {
                    material.SetFloat(SgtShader._Age, SgtHelper.Divide(Age, Life));
                }
            }
        }
Ejemplo n.º 27
0
        private void CameraPreRender(Camera camera)
        {
            if (model != null)
            {
                model.Restore(camera);
            }

            // Write camera-dependant shader values
            if (innerMaterial != null && outerMaterial != null)
            {
                var localPosition  = cachedTransform.InverseTransformPoint(camera.transform.position);
                var localDistance  = localPosition.magnitude;
                var height01       = Mathf.InverseLerp(OuterRadius, InnerMeshRadius, localDistance);
                var innerThickness = default(float);
                var outerThickness = default(float);
                var innerRatio     = SgtHelper.Divide(InnerMeshRadius, OuterRadius);
                var middleRatio    = Mathf.Lerp(innerRatio, 1.0f, Middle);
                var distance       = SgtHelper.Divide(localDistance, OuterRadius);
                var innerDensity   = 1.0f - InnerFog;
                var outerDensity   = 1.0f - OuterFog;

                SgtHelper.CalculateHorizonThickness(innerRatio, middleRatio, distance, out innerThickness, out outerThickness);

                innerMaterial.SetFloat(SgtShader._HorizonLengthRecip, SgtHelper.Reciprocal(innerThickness * innerDensity));
                outerMaterial.SetFloat(SgtShader._HorizonLengthRecip, SgtHelper.Reciprocal(outerThickness * outerDensity));

                if (OuterDepthTex != null)
                {
#if UNITY_EDITOR
                    SgtHelper.MakeTextureReadable(OuterDepthTex);
#endif
                    outerMaterial.SetFloat(SgtShader._Sky, Sky * OuterDepthTex.GetPixelBilinear(height01 / outerDensity, 0.0f).a);
                }

                UpdateMaterialNonSerialized();
            }
        }
        private void TryUpdate()
        {
            if (point != null)
            {
                var currentPosition = point.Position;

                if (expectedPositionSet == false)
                {
                    expectedPosition    = currentPosition;
                    expectedPositionSet = true;
                }

                var distance = SgtPosition.Distance(ref expectedPosition, ref currentPosition);
                var delta    = SgtHelper.Divide(distance, Time.deltaTime);
                var text     = string.Format(format, System.Math.Round(delta));

                if (onString != null)
                {
                    onString.Invoke(text);
                }

                expectedPosition = currentPosition;
            }
        }
Ejemplo n.º 29
0
        public void UpdateMesh()
        {
            if (mesh == null)
            {
                mesh = SgtHelper.CreateTempMesh("Plane");

                if (models != null)
                {
                    for (var i = models.Count - 1; i >= 0; i--)
                    {
                        var model = models[i];

                        if (model != null)
                        {
                            model.SetMesh(mesh);
                        }
                    }
                }
            }
            else
            {
                mesh.Clear(false);
            }

            if (PlaneDetail >= 2)
            {
                var detail    = Mathf.Min(PlaneDetail, SgtHelper.QuadsPerMesh / 2);                 // Limit the amount of vertices that get made
                var positions = new Vector3[detail * 2 + 2];
                var normals   = new Vector3[detail * 2 + 2];
                var coords1   = new Vector2[detail * 2 + 2];
                var coords2   = new Vector2[detail * 2 + 2];
                var indices   = new int[detail * 6];
                var angleStep = SgtHelper.Divide(Mathf.PI * 2.0f, detail);
                var coordStep = SgtHelper.Reciprocal(detail);

                for (var i = 0; i <= detail; i++)
                {
                    var coord = coordStep * i;
                    var angle = angleStep * i;
                    var sin   = Mathf.Sin(angle);
                    var cos   = Mathf.Cos(angle);
                    var offV  = i * 2;

                    positions[offV + 0] = new Vector3(sin * RadiusMin, 0.0f, cos * RadiusMin);
                    positions[offV + 1] = new Vector3(sin * RadiusMax, 0.0f, cos * RadiusMax);

                    normals[offV + 0] = Vector3.up;
                    normals[offV + 1] = Vector3.up;

                    coords1[offV + 0] = new Vector2(0.0f, coord * RadiusMin);
                    coords1[offV + 1] = new Vector2(1.0f, coord * RadiusMax);

                    coords2[offV + 0] = new Vector2(RadiusMin, 0.0f);
                    coords2[offV + 1] = new Vector2(RadiusMax, 0.0f);
                }

                for (var i = 0; i < detail; i++)
                {
                    var offV = i * 2;
                    var offI = i * 6;

                    indices[offI + 0] = offV + 0;
                    indices[offI + 1] = offV + 1;
                    indices[offI + 2] = offV + 2;
                    indices[offI + 3] = offV + 3;
                    indices[offI + 4] = offV + 2;
                    indices[offI + 5] = offV + 1;
                }

                mesh.vertices  = positions;
                mesh.normals   = normals;
                mesh.uv        = coords1;
                mesh.uv2       = coords2;
                mesh.triangles = indices;
            }
        }
Ejemplo n.º 30
0
        protected virtual void Update()
        {
            if (Target == null)
            {
                ClearDebris(); return;
            }

            var followerPosition = Target.position;
            var followerDensity  = GetDensity(followerPosition);

            if (followerDensity > 0.0f)
            {
                var debrisCount = Debris != null ? Debris.Count : 0;

                if (debrisCount < SpawnLimit)
                {
                    spawnCooldown -= Time.deltaTime;

                    while (spawnCooldown <= 0.0f)
                    {
                        spawnCooldown += Random.Range(SpawnRateMin, SpawnRateMax);

                        SpawnDebris(false);

                        debrisCount += 1;

                        if (debrisCount >= SpawnLimit)
                        {
                            break;
                        }
                    }
                }
            }

            if (Debris != null)
            {
                var distanceRange = HideDistance - ShowDistance;

                for (var i = Debris.Count - 1; i >= 0; i--)
                {
                    var debris = Debris[i];

                    if (debris != null)
                    {
                        var targetScale = default(float);
                        var distance    = Vector3.Distance(followerPosition, debris.transform.position);

                        // Fade its size in
                        debris.Show = SgtHelper.Dampen(debris.Show, 1.0f, ShowSpeed, Time.deltaTime, 0.1f);

                        if (distance < ShowDistance)
                        {
                            targetScale = 1.0f;
                        }
                        else if (distance > HideDistance)
                        {
                            targetScale = 0.0f;
                        }
                        else
                        {
                            targetScale = 1.0f - SgtHelper.Divide(distance - ShowDistance, distanceRange);
                        }

                        debris.transform.localScale = debris.Scale * debris.Show * Mathf.Max(minScale, targetScale);

                        if (targetScale <= 0.0f)
                        {
                            Despawn(debris, i);
                        }
                    }
                    else
                    {
                        Debris.RemoveAt(i);
                    }
                }
            }
        }