Ejemplo n.º 1
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);

            innerMaterial.renderQueue = outerMaterial.renderQueue = RenderQueue;

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

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

            UpdateMaterialNonSerialized();
        }
Ejemplo n.º 2
0
        public void UpdateMaterial()
        {
            if (material == null)
            {
                material = SgtHelper.CreateTempMaterial("Cloudsphere (Generated)", SgtHelper.ShaderNamePrefix + "Cloudsphere");

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

            var color = SgtHelper.Brighten(Color, Brightness);

            material.renderQueue = RenderQueue;

            material.SetColor("_Color", color);
            material.SetTexture("_MainTex", MainTex);
            material.SetTexture("_DepthTex", DepthTex);
            material.SetTexture("_LightingTex", LightingTex);

            if (Near == true)
            {
                SgtHelper.EnableKeyword("SGT_A", material);                 // Near

                material.SetTexture("_NearTex", NearTex);
                material.SetFloat("_NearScale", SgtHelper.Reciprocal(NearDistance));
            }
            else
            {
                SgtHelper.DisableKeyword("SGT_A", material);                 // Near
            }
        }
Ejemplo n.º 3
0
        public static void Calculate(Light light, Vector3 center, Transform directionTransform, Transform positionTransform, ref Vector3 position, ref Vector3 direction, ref Color color)
        {
            if (light != null)
            {
                direction = -light.transform.forward;
                position  = light.transform.position;
                color     = SgtHelper.Brighten(light.color, light.intensity);

                switch (light.type)
                {
                case LightType.Point: direction = Vector3.Normalize(position - center); break;

                case LightType.Directional: position = center + direction * 10000000.0f; break;
                }

                // Transform into local space?
                if (directionTransform != null)
                {
                    direction = directionTransform.InverseTransformDirection(direction);
                }

                if (positionTransform != null)
                {
                    position = positionTransform.InverseTransformPoint(position);
                }
            }
        }
Ejemplo n.º 4
0
        public void UpdateMaterial()
        {
            renderedThisFrame = false;

            if (material == null)
            {
                material = SgtHelper.CreateTempMaterial("Cloudsphere (Generated)", SgtHelper.ShaderNamePrefix + "Cloudsphere");

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

            var color = SgtHelper.Brighten(Color, Brightness);

            material.renderQueue = RenderQueue;

            material.SetColor(SgtShader._Color, color);
            material.SetTexture(SgtShader._CubeTex, MainTex);
            material.SetTexture(SgtShader._DepthTex, DepthTex);
            material.SetTexture(SgtShader._LightingTex, LightingTex);

            if (Near == true)
            {
                SgtHelper.EnableKeyword("SGT_A", material);                 // Near

                material.SetTexture(SgtShader._NearTex, NearTex);
                material.SetFloat(SgtShader._NearScale, SgtHelper.Reciprocal(NearDistance));
            }
            else
            {
                SgtHelper.DisableKeyword("SGT_A", material);                 // Near
            }

            if (Detail == true)
            {
                SgtHelper.EnableKeyword("SGT_B", material);                 // Detail

                material.SetTexture(SgtShader._DetailTex, DetailTex);
                material.SetFloat(SgtShader._DetailScale, DetailScale);
                material.SetFloat(SgtShader._DetailTiling, DetailTiling);
            }
            else
            {
                SgtHelper.DisableKeyword("SGT_B", material);                 // Detail
            }

            if (Softness > 0.0f)
            {
                SgtHelper.EnableKeyword("SGT_C", material);                 // Softness

                material.SetFloat(SgtShader._SoftParticlesFactor, SgtHelper.Reciprocal(Softness));
            }
            else
            {
                SgtHelper.DisableKeyword("SGT_C", material);                 // Softness
            }
        }
Ejemplo n.º 5
0
        public virtual void UpdateMaterial()
        {
            if (material == null)
            {
                material = SgtHelper.CreateTempMaterial("Ring (Generated)", SgtHelper.ShaderNamePrefix + "Ring");
            }

            var color = SgtHelper.Brighten(this.color, brightness);

            material.renderQueue = renderQueue;

            material.SetColor(SgtShader._Color, color);
            material.SetTexture(SgtShader._MainTex, mainTex);

            if (detail == true)
            {
                SgtHelper.EnableKeyword("SGT_B", material);                 // Detail

                material.SetTexture(SgtShader._DetailTex, detailTex);
                material.SetVector(SgtShader._DetailOffset, detailOffset);
                material.SetVector(SgtShader._DetailScale, new Vector2(detailScaleX, detailScaleY));
                material.SetFloat(SgtShader._DetailTwist, detailTwist);
                material.SetFloat(SgtShader._DetailTwistBias, detailTwistBias);
            }
            else
            {
                SgtHelper.DisableKeyword("SGT_B", material);                 // Detail
            }

            if (near == true)
            {
                SgtHelper.EnableKeyword("SGT_C", material);                 // Near

                material.SetTexture(SgtShader._NearTex, nearTex);
                material.SetFloat(SgtShader._NearScale, SgtHelper.Reciprocal(nearDistance));
            }
            else
            {
                SgtHelper.DisableKeyword("SGT_C", material);                 // Near
            }

            if (lit == true)
            {
                material.SetTexture(SgtShader._LightingTex, lightingTex);
                material.SetColor(SgtShader._AmbientColor, ambientColor);
            }

            if (scattering == true)
            {
                SgtHelper.EnableKeyword("SGT_A", material);                 // Scattering

                material.SetFloat(SgtShader._ScatteringMie, scatteringMie * scatteringMie);
            }
            else
            {
                SgtHelper.DisableKeyword("SGT_A", material);                 // Scattering
            }
        }
Ejemplo n.º 6
0
        private void UpdateMaterial()
        {
            if (generatedMaterial == null)
            {
                generatedMaterial = SgtHelper.CreateTempMaterial("Cloudsphere (Generated)", SgtHelper.ShaderNamePrefix + "Cloudsphere");
            }

            var color = SgtHelper.Brighten(this.color, brightness);

            generatedMaterial.renderQueue = renderQueue;

            generatedMaterial.SetColor(SgtShader._Color, color);
            generatedMaterial.SetTexture(SgtShader._CubeTex, mainTex);
            generatedMaterial.SetTexture(SgtShader._DepthTex, depthTex);

            if (lit == true)
            {
                generatedMaterial.SetTexture(SgtShader._LightingTex, lightingTex);
                generatedMaterial.SetColor(SgtShader._AmbientColor, ambientColor);
            }

            if (near == true)
            {
                SgtHelper.EnableKeyword("SGT_A", generatedMaterial);                 // Near

                generatedMaterial.SetTexture(SgtShader._NearTex, nearTex);
                generatedMaterial.SetFloat(SgtShader._NearScale, SgtHelper.Reciprocal(nearDistance));
            }
            else
            {
                SgtHelper.DisableKeyword("SGT_A", generatedMaterial);                 // Near
            }

            if (detail == true)
            {
                SgtHelper.EnableKeyword("SGT_B", generatedMaterial);                 // Detail

                generatedMaterial.SetTexture(SgtShader._DetailTex, detailTex);
                generatedMaterial.SetFloat(SgtShader._DetailScale, detailScale);
                generatedMaterial.SetFloat(SgtShader._DetailTiling, detailTiling);
            }
            else
            {
                SgtHelper.DisableKeyword("SGT_B", generatedMaterial);                 // Detail
            }

            if (softness > 0.0f)
            {
                SgtHelper.EnableKeyword("SGT_C", generatedMaterial);                 // Softness

                generatedMaterial.SetFloat(SgtShader._SoftParticlesFactor, SgtHelper.Reciprocal(softness));
            }
            else
            {
                SgtHelper.DisableKeyword("SGT_C", generatedMaterial);                 // Softness
            }
        }
Ejemplo n.º 7
0
        public void UpdateMaterial()
        {
            if (material == null)
            {
                material = SgtHelper.CreateTempMaterial("Aurora (Generated)", SgtHelper.ShaderNamePrefix + "Aurora");

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

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

            var color = SgtHelper.Premultiply(SgtHelper.Brighten(Color, Brightness));

            material.renderQueue = RenderQueue;

            material.SetColor(SgtShader._Color, color);
            material.SetTexture(SgtShader._MainTex, MainTex);
            material.SetFloat(SgtShader._RadiusMin, RadiusMin);
            material.SetFloat(SgtShader._RadiusSize, RadiusMax - RadiusMin);

            SgtHelper.SetTempMaterial(material);

            if (Near == true)
            {
                SgtHelper.EnableKeyword("SGT_A");                 // Near

                material.SetTexture(SgtShader._NearTex, NearTex);
                material.SetFloat(SgtShader._NearScale, SgtHelper.Reciprocal(NearDistance));
            }
            else
            {
                SgtHelper.DisableKeyword("SGT_A");                 // Near
            }

            if (Anim == true)
            {
                SgtHelper.EnableKeyword("SGT_B");                 // Anim

                material.SetFloat(SgtShader._AnimOffset, AnimOffset);
            }
            else
            {
                SgtHelper.DisableKeyword("SGT_B");                 // Anim
            }
        }
Ejemplo n.º 8
0
        public void UpdateMaterial()
        {
            if (material == null)
            {
                material = SgtHelper.CreateTempMaterial("Prominence (Generated)", SgtHelper.ShaderNamePrefix + "Prominence");

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

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

            var color = SgtHelper.Premultiply(SgtHelper.Brighten(Color, Brightness));

            material.renderQueue = RenderQueue;

            material.SetTexture("_MainTex", MainTex);
            material.SetColor("_Color", color);
            material.SetVector("_WorldPosition", transform.position);

            SgtHelper.SetTempMaterial(material);

            if (FadeEdge == true)
            {
                SgtHelper.EnableKeyword("SGT_A");

                material.SetFloat("_FadePower", FadePower);
            }
            else
            {
                SgtHelper.DisableKeyword("SGT_A");
            }

            if (ClipNear == true)
            {
                SgtHelper.EnableKeyword("SGT_B");

                material.SetFloat("_ClipPower", ClipPower);
            }
            else
            {
                SgtHelper.DisableKeyword("SGT_B");
            }
        }
Ejemplo n.º 9
0
        public virtual void UpdateMaterial()
        {
            if (material == null)
            {
                material = SgtHelper.CreateTempMaterial("Accretion (Generated)", SgtHelper.ShaderNamePrefix + "Accretion");

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

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

            material.renderQueue = RenderQueue;

            material.SetColor("_Color", SgtHelper.Brighten(Color, Brightness));
            material.SetTexture("_MainTex", MainTex);

            if (Detail == true)
            {
                SgtHelper.EnableKeyword("SGT_B", material);                 // Detail

                material.SetTexture("_DetailTex", DetailTex);
                material.SetVector("_DetailScale", new Vector2(DetailScaleX, DetailScaleY));
                material.SetFloat("_DetailTwist", DetailTwist);
                material.SetFloat("_DetailTwistBias", DetailTwistBias);
            }
            else
            {
                SgtHelper.DisableKeyword("SGT_B", material);                 // Detail
            }

            if (Near == true)
            {
                SgtHelper.EnableKeyword("SGT_C", material);                 // Near

                material.SetTexture("_NearTex", NearTex);
                material.SetFloat("_NearScale", SgtHelper.Reciprocal(NearDistance));
            }
            else
            {
                SgtHelper.DisableKeyword("SGT_C", material);                 // Near
            }
        }
Ejemplo n.º 10
0
        public void UpdateMaterial()
        {
            if (material == null)
            {
                material = SgtHelper.CreateTempMaterial("Spacetime (Generated)", SgtHelper.ShaderNamePrefix + "Spacetime");

                CachedSharedMaterial.Material = material;
            }

            var ambientColor      = SgtHelper.Brighten(AmbientColor, AmbientBrightness);
            var displacementColor = SgtHelper.Brighten(DisplacementColor, DisplacementBrightness);
            var higlightColor     = SgtHelper.Brighten(HighlightColor, HighlightBrightness);

            material.renderQueue = RenderQueue;

            material.SetTexture("_MainTex", MainTex);
            material.SetColor("_Color", SgtHelper.Brighten(Color, Brightness));
            material.SetColor("_AmbientColor", ambientColor);
            material.SetColor("_DisplacementColor", displacementColor);
            material.SetColor("_HighlightColor", higlightColor);
            material.SetFloat("_HighlightPower", HighlightPower);
            material.SetFloat("_HighlightScale", HighlightScale);
            material.SetFloat("_Tile", Tile);

            if (Displacement == DisplacementType.Pinch)
            {
                material.SetFloat("_Power", Power);
            }

            if (Displacement == DisplacementType.Offset)
            {
                SgtHelper.EnableKeyword("SGT_A", material);

                material.SetVector("_Offset", Offset);
            }
            else
            {
                SgtHelper.DisableKeyword("SGT_A", material);
            }

            if (Accumulate == true)
            {
                SgtHelper.EnableKeyword("SGT_B", material);
            }
            else
            {
                SgtHelper.DisableKeyword("SGT_B", material);
            }
        }
Ejemplo n.º 11
0
        protected override void CameraPreCull(Camera camera)
        {
            base.CameraPreCull(camera);

            // Change brightness based on viewing angle?
            if (material != null)
            {
                var dir    = (transform.position - camera.transform.position).normalized;
                var theta  = Mathf.Abs(Vector3.Dot(transform.up, dir));
                var bright = Mathf.Lerp(HorizontalBrightness, Brightness, Mathf.Pow(theta, HorizontalPower));
                var color  = SgtHelper.Brighten(Color, Color.a * bright);

                material.SetColor("_Color", color);
            }
        }
Ejemplo n.º 12
0
        private void UpdateMaterial()
        {
            if (material == null)
            {
                material = SgtHelper.CreateTempMaterial("Spacetime (Generated)", SgtHelper.ShaderNamePrefix + "Spacetime");
            }

            var ambientColor      = SgtHelper.Brighten(this.ambientColor, ambientBrightness);
            var displacementColor = SgtHelper.Brighten(this.displacementColor, displacementBrightness);
            var higlightColor     = SgtHelper.Brighten(highlightColor, highlightBrightness);

            material.renderQueue = renderQueue;

            material.SetTexture(SgtShader._MainTex, mainTex);
            material.SetColor(SgtShader._Color, SgtHelper.Brighten(color, brightness));
            material.SetColor(SgtShader._AmbientColor, ambientColor);
            material.SetColor(SgtShader._DisplacementColor, displacementColor);
            material.SetColor(SgtShader._HighlightColor, higlightColor);
            material.SetFloat(SgtShader._HighlightPower, highlightPower);
            material.SetFloat(SgtShader._HighlightScale, highlightScale);
            material.SetFloat(SgtShader._Tile, tile);

            if (displacement == DisplacementType.Pinch)
            {
                material.SetFloat(SgtShader._Power, power);
            }

            if (displacement == DisplacementType.Offset)
            {
                SgtHelper.EnableKeyword("SGT_A", material);

                material.SetVector(SgtShader._Offset, offset);
            }
            else
            {
                SgtHelper.DisableKeyword("SGT_A", material);
            }

            if (accumulate == true)
            {
                SgtHelper.EnableKeyword("SGT_B", material);
            }
            else
            {
                SgtHelper.DisableKeyword("SGT_B", material);
            }
        }
Ejemplo n.º 13
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.º 14
0
        protected virtual void BuildMaterial()
        {
            material.renderQueue = RenderQueue;

            switch (BlendMode)
            {
            case BlendModeType.Additive: BuildAdditive(); break;

            case BlendModeType.AlphaTest: BuildAlphaTest(); break;

            case BlendModeType.AdditiveSmooth: BuildAdditiveSmooth(); break;
            }

            material.SetTexture(SgtShader._MainTex, MainTex);
            material.SetColor(SgtShader._Color, SgtHelper.Brighten(Color, Color.a * Brightness));
            material.SetFloat(SgtShader._Scale, transform.lossyScale.x);
            material.SetFloat(SgtShader._ScaleRecip, SgtHelper.Reciprocal(transform.lossyScale.x));
        }
Ejemplo n.º 15
0
        protected virtual void UpdateMaterial()
        {
            dirtyMaterial = false;

            material.renderQueue = renderQueue;

            switch (blendMode)
            {
            case BlendModeType.Additive: BuildAdditive(); break;

            case BlendModeType.AlphaTest: BuildAlphaTest(); break;

            case BlendModeType.AdditiveSmooth: BuildAdditiveSmooth(); break;
            }

            material.SetTexture(SgtShader._MainTex, mainTex);
            material.SetColor(SgtShader._Color, SgtHelper.Brighten(Color, Color.a * Brightness, false));
        }
Ejemplo n.º 16
0
        public static void Calculate(SgtLight light, Vector3 center, Transform directionTransform, Transform positionTransform, ref Vector3 position, ref Vector3 direction, ref Color color)
        {
            if (light != null)
            {
                var cachedLight = light.CachedLight;

                direction = -light.transform.forward;
                position  = light.transform.position;
                color     = SgtHelper.Brighten(cachedLight.color, light.intensityInSGT * light.multiplier, false);

                switch (cachedLight.type)
                {
                case LightType.Point:
                {
                    direction = Vector3.Normalize(position - center);
                }
                break;

                case LightType.Directional:
                {
                    if (light.treatAsPoint == true)
                    {
                        direction = Vector3.Normalize(position - center);
                    }
                    else
                    {
                        position = center + direction * 10000000.0f;
                    }
                }
                break;
                }

                // Transform into local space?
                if (directionTransform != null)
                {
                    direction = directionTransform.InverseTransformDirection(direction);
                }

                if (positionTransform != null)
                {
                    position = positionTransform.InverseTransformPoint(position);
                }
            }
        }
Ejemplo n.º 17
0
        protected override void HandleCameraDraw(Camera camera)
        {
            if (SgtHelper.CanDraw(gameObject, camera) == false)
            {
                return;
            }

            var properties = shaderProperties.GetProperties(material, camera);

            // Change brightness based on viewing angle?
            var dir    = (transform.position - camera.transform.position).normalized;
            var theta  = Mathf.Abs(Vector3.Dot(transform.up, dir));
            var bright = Mathf.Lerp(horizontalBrightness, Brightness, Mathf.Pow(theta, horizontalPower));
            var color  = SgtHelper.Brighten(Color, Color.a * bright);

            properties.SetColor(SgtShader._Color, color);

            Graphics.DrawMesh(mesh, transform.localToWorldMatrix, material, gameObject.layer, camera, 0, properties);
        }
Ejemplo n.º 18
0
        private void UpdateMaterial()
        {
            if (material == null)
            {
                material = SgtHelper.CreateTempMaterial("Aurora (Generated)", SgtHelper.ShaderNamePrefix + "Aurora");
            }

            var color = SgtHelper.Premultiply(SgtHelper.Brighten(this.color, brightness));

            material.renderQueue = renderQueue;

            material.SetColor(SgtShader._Color, color);
            material.SetTexture(SgtShader._MainTex, mainTex);
            material.SetFloat(SgtShader._RadiusMin, radiusMin);
            material.SetFloat(SgtShader._RadiusSize, radiusMax - radiusMin);

            SgtHelper.SetTempMaterial(material);

            if (near == true)
            {
                SgtHelper.EnableKeyword("SGT_A");                 // Near

                material.SetTexture(SgtShader._NearTex, nearTex);
                material.SetFloat(SgtShader._NearScale, SgtHelper.Reciprocal(nearDistance));
            }
            else
            {
                SgtHelper.DisableKeyword("SGT_A");                 // Near
            }

            if (anim == true)
            {
                SgtHelper.EnableKeyword("SGT_B");                 // Anim

                material.SetFloat(SgtShader._AnimOffset, animOffset);
            }
            else
            {
                SgtHelper.DisableKeyword("SGT_B");                 // Anim
            }
        }
Ejemplo n.º 19
0
        private void UpdateMaterial()
        {
            if (material == null)
            {
                material = SgtHelper.CreateTempMaterial("Accretion (Generated)", SgtHelper.ShaderNamePrefix + "Accretion");
            }

            material.renderQueue = renderQueue;

            material.SetColor(SgtShader._Color, SgtHelper.Brighten(color, brightness));
            material.SetTexture(SgtShader._MainTex, mainTex);

            if (detail == true)
            {
                SgtHelper.EnableKeyword("SGT_B", material);                 // Detail

                material.SetTexture(SgtShader._DetailTex, detailTex);
                material.SetVector(SgtShader._DetailScale, new Vector2(detailScaleX, detailScaleY));
                material.SetFloat(SgtShader._DetailTwist, detailTwist);
                material.SetFloat(SgtShader._DetailTwistBias, detailTwistBias);
            }
            else
            {
                SgtHelper.DisableKeyword("SGT_B", material);                 // Detail
            }

            if (near == true)
            {
                SgtHelper.EnableKeyword("SGT_C", material);                 // Near

                material.SetTexture(SgtShader._NearTex, nearTex);
                material.SetFloat(SgtShader._NearScale, SgtHelper.Reciprocal(nearDistance));
            }
            else
            {
                SgtHelper.DisableKeyword("SGT_C", material);                 // Near
            }
        }
        public SgtLightning Spawn()
        {
            if (mesh != null && LifeMin > 0.0f && LifeMax > 0.0f)
            {
                var sprite = RandomSprite;

                if (sprite != null)
                {
                    var lightning = SgtLightning.Create(this);
                    var material  = lightning.Material;
                    var uv        = SgtHelper.CalculateSpriteUV(sprite);

                    if (material == null)
                    {
                        material = SgtHelper.CreateTempMaterial("Lightning (Generated)", SgtHelper.ShaderNamePrefix + "Lightning");

                        lightning.SetMaterial(material);
                    }

                    lightning.Life = Random.Range(LifeMin, LifeMax);
                    lightning.Age  = 0.0f;

                    lightning.SetMesh(mesh);

                    material.SetTexture(SgtShader._MainTex, sprite.texture);
                    material.SetColor(SgtShader._Color, SgtHelper.Brighten(RandomColor, Brightness));
                    material.SetFloat(SgtShader._Age, 0.0f);
                    material.SetVector(SgtShader._Offset, new Vector2(uv.x, uv.y));
                    material.SetVector(SgtShader._Scale, new Vector2(uv.z - uv.x, uv.w - uv.y));

                    lightning.transform.localRotation = Random.rotation;

                    return(lightning);
                }
            }

            return(null);
        }
Ejemplo n.º 21
0
        public void UpdateMaterial()
        {
            if (material == null)
            {
                material = SgtHelper.CreateTempMaterial("Jovian Material (Generated)", SgtHelper.ShaderNamePrefix + "Jovian");

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

            material.renderQueue = RenderQueue;

            material.SetTexture(SgtShader._CubeTex, MainTex);
            material.SetTexture(SgtShader._DepthTex, DepthTex);
            material.SetColor(SgtShader._Color, SgtHelper.Brighten(Color, Brightness));

            if (Lit == true)
            {
                material.SetTexture(SgtShader._LightingTex, LightingTex);
                material.SetColor(SgtShader._AmbientColor, AmbientColor);
            }

            SgtHelper.SetTempMaterial(material);

            if (Scattering == true)
            {
                material.SetTexture(SgtShader._ScatteringTex, ScatteringTex);

                SgtHelper.EnableKeyword("SGT_B");                 // Scattering
            }
            else
            {
                SgtHelper.DisableKeyword("SGT_B");                 // Scattering
            }
        }
Ejemplo n.º 22
0
        private void UpdateMaterial()
        {
            if (material == null)
            {
                material = SgtHelper.CreateTempMaterial("Jovian Material (Generated)", SgtHelper.ShaderNamePrefix + "Jovian");
            }

            material.renderQueue = renderQueue;

            material.SetTexture(SgtShader._CubeTex, mainTex);
            material.SetTexture("_FlowTex", flowTex);
            material.SetFloat("_FlowSpeed", flowSpeed);
            material.SetFloat("_FlowStrength", flowStrength);
            material.SetFloat("_FlowNoiseTiling", flowNoiseTiling);
            material.SetTexture(SgtShader._DepthTex, depthTex);
            material.SetColor(SgtShader._Color, SgtHelper.Brighten(color, brightness));

            if (lit == true)
            {
                material.SetTexture(SgtShader._LightingTex, lightingTex);
                material.SetColor(SgtShader._AmbientColor, ambientColor);
            }

            SgtHelper.SetTempMaterial(material);

            if (scattering == true)
            {
                material.SetTexture(SgtShader._ScatteringTex, scatteringTex);

                SgtHelper.EnableKeyword("SGT_B");                 // Scattering
            }
            else
            {
                SgtHelper.DisableKeyword("SGT_B");                 // Scattering
            }
        }
Ejemplo n.º 23
0
        public void UpdateMaterials()
        {
            if (innerMaterial == null)
            {
                innerMaterial = SgtHelper.CreateTempMaterial("Atmosphere Inner (Generated)", SgtHelper.ShaderNamePrefix + "AtmosphereInner");

                CachedSharedMaterial.Material = innerMaterial;
            }

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

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

            var color = SgtHelper.Brighten(Color, Brightness);

            innerMaterial.renderQueue = outerMaterial.renderQueue = RenderQueue;

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

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

            if (Lit == true)
            {
                innerMaterial.SetTexture("_LightingTex", LightingTex);
                outerMaterial.SetTexture("_LightingTex", LightingTex);

                if (Scattering == true)
                {
                    outerMaterial.SetTexture("_ScatteringTex", ScatteringTex);
                    outerMaterial.SetFloat("_ScatteringMie", ScatteringMie);
                    outerMaterial.SetFloat("_ScatteringRayleigh", ScatteringRayleigh);

                    SgtHelper.EnableKeyword("SGT_B", outerMaterial);                     // Scattering

                    if (GroundScattering == true)
                    {
                        innerMaterial.SetTexture("_ScatteringTex", ScatteringTex);
                        innerMaterial.SetFloat("_ScatteringMie", ScatteringMie);
                        innerMaterial.SetFloat("_ScatteringRayleigh", ScatteringRayleigh);

                        SgtHelper.EnableKeyword("SGT_B", innerMaterial);                         // Scattering
                    }
                    else
                    {
                        SgtHelper.DisableKeyword("SGT_B", innerMaterial);                         // Scattering
                    }
                }
                else
                {
                    SgtHelper.DisableKeyword("SGT_B", innerMaterial);                     // Scattering
                    SgtHelper.DisableKeyword("SGT_B", outerMaterial);                     // Scattering
                }
            }

            UpdateMaterialNonSerialized();
        }
Ejemplo n.º 24
0
        public void UpdateMaterial()
        {
            if (material == null)
            {
                material = SgtHelper.CreateTempMaterial("Prominence (Generated)", SgtHelper.ShaderNamePrefix + "Prominence");

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

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

            var color = SgtHelper.Premultiply(SgtHelper.Brighten(Color, Brightness));

            material.renderQueue = RenderQueue;

            material.SetTexture(SgtShader._MainTex, MainTex);
            material.SetColor(SgtShader._Color, color);
            material.SetVector(SgtShader._WorldPosition, transform.position);

            SgtHelper.SetTempMaterial(material);

            if (FadeEdge == true)
            {
                SgtHelper.EnableKeyword("SGT_A");

                material.SetFloat(SgtShader._FadePower, FadePower);
            }
            else
            {
                SgtHelper.DisableKeyword("SGT_A");
            }

            if (ClipNear == true)
            {
                SgtHelper.EnableKeyword("SGT_B");

                material.SetFloat(SgtShader._ClipPower, ClipPower);
            }
            else
            {
                SgtHelper.DisableKeyword("SGT_B");
            }

            if (Distort == true)
            {
                SgtHelper.EnableKeyword("SGT_C", material);                 // Distort

                material.SetTexture(SgtShader._DistortTex, DistortTex);
                material.SetVector(SgtShader._DistortScale, new Vector2(DistortScaleX, DistortScaleY));
                material.SetFloat(SgtShader._DistortStrength, DistortStrength);
            }
            else
            {
                SgtHelper.DisableKeyword("SGT_C", material);                 // Distort
            }

            if (Detail == true)
            {
                SgtHelper.EnableKeyword("SGT_D", material);                 // Detail

                material.SetTexture(SgtShader._DetailTex, DetailTex);
                material.SetVector(SgtShader._DetailScale, new Vector2(DetailScaleX, DetailScaleY));
                material.SetFloat(SgtShader._DetailStrength, DetailStrength);
            }
            else
            {
                SgtHelper.DisableKeyword("SGT_D", material);                 // Detail
            }
        }
Ejemplo n.º 25
0
        public void UpdateMaterial()
        {
            if (material == null)
            {
                material = SgtHelper.CreateTempMaterial("Prominence (Generated)", SgtHelper.ShaderNamePrefix + "Prominence");
            }

            material.renderQueue = renderQueue;

            material.SetTexture(SgtShader._MainTex, mainTex);
            material.SetColor(SgtShader._Color, SgtHelper.Premultiply(SgtHelper.Brighten(this.color, brightness)));
            material.SetVector(SgtShader._WorldPosition, transform.position);

            SgtHelper.SetTempMaterial(material);

            if (fadeEdge == true)
            {
                SgtHelper.EnableKeyword("SGT_A");

                material.SetFloat(SgtShader._FadePower, fadePower);
            }
            else
            {
                SgtHelper.DisableKeyword("SGT_A");
            }

            if (clipNear == true)
            {
                SgtHelper.EnableKeyword("SGT_B");

                material.SetFloat(SgtShader._ClipPower, clipPower);
            }
            else
            {
                SgtHelper.DisableKeyword("SGT_B");
            }

            if (distort == true)
            {
                SgtHelper.EnableKeyword("SGT_C", material);                 // Distort

                material.SetTexture(SgtShader._DistortTex, distortTex);
                material.SetVector(SgtShader._DistortScale, new Vector2(distortScaleX, distortScaleY));
                material.SetFloat(SgtShader._DistortStrength, distortStrength);
            }
            else
            {
                SgtHelper.DisableKeyword("SGT_C", material);                 // Distort
            }

            if (detail == true)
            {
                SgtHelper.EnableKeyword("SGT_D", material);                 // Detail

                material.SetTexture(SgtShader._DetailTex, detailTex);
                material.SetVector(SgtShader._DetailScale, new Vector2(detailScaleX, detailScaleY));
                material.SetFloat(SgtShader._DetailStrength, detailStrength);
            }
            else
            {
                SgtHelper.DisableKeyword("SGT_D", material);                 // Detail
            }
        }
Ejemplo n.º 26
0
        public void UpdateMaterials()
        {
            CacheTransform();

            if (innerMaterial == null)
            {
                innerMaterial = SgtHelper.CreateTempMaterial("Atmosphere Inner (Generated)", SgtHelper.ShaderNamePrefix + "AtmosphereInner");

                CachedSharedMaterial.Material = innerMaterial;
            }

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

                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
            }

            if (Lit == true)
            {
                innerMaterial.SetColor(SgtShader._AmbientColor, AmbientColor);
                outerMaterial.SetColor(SgtShader._AmbientColor, AmbientColor);

                innerMaterial.SetTexture(SgtShader._LightingTex, LightingTex);
                outerMaterial.SetTexture(SgtShader._LightingTex, LightingTex);

                if (Scattering == true)
                {
                    outerMaterial.SetTexture(SgtShader._ScatteringTex, ScatteringTex);
                    outerMaterial.SetFloat(SgtShader._ScatteringMie, ScatteringMie);
                    outerMaterial.SetFloat(SgtShader._ScatteringRayleigh, ScatteringRayleigh);

                    SgtHelper.EnableKeyword("SGT_B", outerMaterial);                     // Scattering

                    if (GroundScattering == true)
                    {
                        innerMaterial.SetTexture(SgtShader._ScatteringTex, ScatteringTex);
                        innerMaterial.SetFloat(SgtShader._ScatteringMie, ScatteringMie);
                        innerMaterial.SetFloat(SgtShader._ScatteringRayleigh, ScatteringRayleigh);

                        SgtHelper.EnableKeyword("SGT_B", innerMaterial);                         // Scattering
                    }
                    else
                    {
                        SgtHelper.DisableKeyword("SGT_B", innerMaterial);                         // Scattering
                    }
                }
                else
                {
                    SgtHelper.DisableKeyword("SGT_B", innerMaterial);                     // Scattering
                    SgtHelper.DisableKeyword("SGT_B", outerMaterial);                     // Scattering
                }
            }
        }
Ejemplo n.º 27
0
        public virtual void UpdateMaterial()
        {
            if (material == null)
            {
                material = SgtHelper.CreateTempMaterial("Ring (Generated)", SgtHelper.ShaderNamePrefix + "Ring");

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

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

            var color = SgtHelper.Brighten(Color, Brightness);

            material.renderQueue = RenderQueue;

            material.SetColor(SgtShader._Color, color);
            material.SetTexture(SgtShader._MainTex, MainTex);

            if (Detail == true)
            {
                SgtHelper.EnableKeyword("SGT_B", material);                 // Detail

                material.SetTexture(SgtShader._DetailTex, DetailTex);
                material.SetVector(SgtShader._DetailOffset, DetailOffset);
                material.SetVector(SgtShader._DetailScale, new Vector2(DetailScaleX, DetailScaleY));
                material.SetFloat(SgtShader._DetailTwist, DetailTwist);
                material.SetFloat(SgtShader._DetailTwistBias, DetailTwistBias);
            }
            else
            {
                SgtHelper.DisableKeyword("SGT_B", material);                 // Detail
            }

            if (Near == true)
            {
                SgtHelper.EnableKeyword("SGT_C", material);                 // Near

                material.SetTexture(SgtShader._NearTex, NearTex);
                material.SetFloat(SgtShader._NearScale, SgtHelper.Reciprocal(NearDistance));
            }
            else
            {
                SgtHelper.DisableKeyword("SGT_C", material);                 // Near
            }

            if (Lit == true)
            {
                material.SetTexture(SgtShader._LightingTex, LightingTex);
            }

            if (Scattering == true)
            {
                SgtHelper.EnableKeyword("SGT_A", material);                 // Scattering

                material.SetFloat(SgtShader._ScatteringMie, ScatteringMie * ScatteringMie);
            }
            else
            {
                SgtHelper.DisableKeyword("SGT_A", material);                 // Scattering
            }
        }
Ejemplo n.º 28
0
        protected virtual void UpdateMaterials()
        {
            if (innerMaterial == null)
            {
                innerMaterial = SgtHelper.CreateTempMaterial("Atmosphere Inner (Generated)", SgtHelper.ShaderNamePrefix + "AtmosphereInner");
            }

            if (outerMaterial == null)
            {
                outerMaterial = SgtHelper.CreateTempMaterial("Atmosphere Outer (Generated)", SgtHelper.ShaderNamePrefix + "AtmosphereOuter");
            }

            var color      = SgtHelper.Brighten(this.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 (SgtShaderBundle.IsHDRP(SgtShaderBundle.DetectProjectPipeline()) == true)
            {
                innerMaterial.SetFloat(SgtShader._Offset, -1.0f);
            }
            else
            {
                innerMaterial.SetFloat(SgtShader._Offset, -0.001f);
            }

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

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

            if (lit == true)
            {
                innerMaterial.SetColor(SgtShader._AmbientColor, ambientColor);
                outerMaterial.SetColor(SgtShader._AmbientColor, ambientColor);

                innerMaterial.SetTexture(SgtShader._LightingTex, lightingTex);
                outerMaterial.SetTexture(SgtShader._LightingTex, lightingTex);

                if (scattering == true)
                {
                    outerMaterial.SetTexture(SgtShader._ScatteringTex, scatteringTex);
                    outerMaterial.SetFloat(SgtShader._ScatteringMie, scatteringMie);
                    outerMaterial.SetFloat(SgtShader._ScatteringRayleigh, scatteringRayleigh);

                    SgtHelper.EnableKeyword("SGT_B", outerMaterial);                     // Scattering

                    if (groundScattering == true)
                    {
                        innerMaterial.SetTexture(SgtShader._ScatteringTex, scatteringTex);
                        innerMaterial.SetFloat(SgtShader._ScatteringMie, scatteringMie);
                        innerMaterial.SetFloat(SgtShader._ScatteringRayleigh, scatteringRayleigh);

                        SgtHelper.EnableKeyword("SGT_B", innerMaterial);                         // Scattering
                    }
                    else
                    {
                        SgtHelper.DisableKeyword("SGT_B", innerMaterial);                         // Scattering
                    }
                }
                else
                {
                    SgtHelper.DisableKeyword("SGT_B", innerMaterial);                     // Scattering
                    SgtHelper.DisableKeyword("SGT_B", outerMaterial);                     // Scattering
                }
            }

            CachedSharedMaterial.Material = innerMaterial;
        }