Оптимизация шейдеров

[Kaito]

Честно говоря , совсем немного разбираюсь в работе шейдеров , пишу игру на андроид , производительность играет большую роль , однако при использовании данного шейдера (висит только на одном объекте (планете)) падает довольно таки сильно .
Возможно ли оптимизировать данный шейдер ?

Синтаксис:

Синтаксис: [ Показать ]

Используется csharp

Shader "NanoRav/Planet-Lit" {
        Properties {

        _BumpMap("BumpMap", 2D) = "bump"{}
        [HideInInspector] _NormMap("NormMap", 2D) = "bump"{}

                _PeakColor("PeakColor", Color) = (0, 0, 0, 1)
        _Level3Color("Level3Color", Color) = (0, 0, 0, 1)
        _Level2Color("Level2Color", Color) = (0, 0, 0, 1)
        _Level1Color("Level1Color", Color) = (0, 0, 0, 1)
        _ShoreColor("ShoreColor", Color) = (0, 0, 0, 1)
        _WaterColor("WaterColor", Color) = (0, 0, 0, 1)

        _PeakLevel("PeakLevel", Float) = 0.5
        _Level3("Level3", Float) = 0.5
        _Level2("Level2", Float) = 0.5
        _Level1("Level1", Float) = 0.5
        _ShoreLevel("ShoreLevel", Float) = 0.5
        _WaterLevel("WaterLevel", Float) = 0.5

        _IceLevel("IceLevel",Float) = 0.4
        _IceStrength("IceStrength",Float) = 2.0
        _IceColor("IceColor", Color) = (0.95, 0.95, 0.95, 1)

        _Frequency("Frequency", Float) = 2.0
        _Lacunarity("Lacunarity", Float) = 3.0
        _Gain("Gain", Float) = 0.5

        _PlanetStretch("PlanetStretch",Float) = 0.4

            _AtmosNear("AtmosNear", Color) = (1,1,1,1)
            _AtmosFar("AtmosFar", Color) = (1,1,1,1)
            _AtmosFalloff("AtmosFalloff", Float) = 3

                [HideInInspector] _CityFrequency("CityFrequency", Float) = 250.0

        _CityColor("CityColor", Color) = (1.0, 1.0, 1.0, 1.0)
                [HideInInspector] _CityLevel("CityLevel",Float) = 0.7
                [HideInInspector] _isCities("isCities",Float) = 1.0

        _CloudFrequency("CloudFrequency", Float) = 2.0
        _CloudLacunarity("CloudLacunarity", Float) = 3.0
        _CloudGain("CloudGain", Float) = 0.5

        _CloudColor("CloudColor", Color) = (1.0, 1.0, 1.0, 1.0)
        _CloudLevel("CloudLevel",Float) = 0.05
        _CloudRotation("CloudRotation",Float) = 0.01
                [HideInInspector] _isClouds("isClouds",Float) = 1.0

                _CityTOP ("City Top",Float) = 0.8
                _CityBOT ("City Bot", Float) = 0.2
        }
        SubShader {

                Tags {
                        "Queue"="Geometry"
                        "RenderType"="Opaque"
                }

                Cull Back
            ZWrite On
            ZTest LEqual
            ColorMask RGBA
                Fog { Mode Off }

                CGPROGRAM
                #pragma surface surf BlinnPhongEditor vertex:vert
                #pragma target 3.0
       
                #include "UnityCG.cginc"

                uniform sampler2D _PermTable2D, _Gradient3D, _BumpMap, _NormMap;
        uniform float _PlanetStretch, _SpecPower, _PlanetType, _Frequency, _Lacunarity, _Gain, _IceStrength, _IceLevel, _Level3, _Level2, _Level1, _ShoreLevel, _WaterLevel, _PeakLevel;
        uniform float4 _ChosenColor, _IceColor, _PeakColor, _Level3Color, _Level2Color, _Level1Color, _ShoreColor, _WaterColor;

            float4 _AtmosNear;
            float4 _AtmosFar;
            float _AtmosFalloff;

        struct EditorSurfaceOutput {
            half3 Albedo;
            half3 Normal;
            half3 Emission;
            half3 Gloss;
            half Specular;
            half Alpha;
            half Custom;
          };

                inline half4 LightingBlinnPhongEditor_PrePass (EditorSurfaceOutput s, half4 light){
                        half3 spec = light.a * s.Gloss;
                        half4 c;
                        c.rgb = (s.Albedo.rgb * light.rgb + light.rgb * spec);
                        c.g -= .01 * s.Alpha;
                        c.r -= .03 * s.Alpha;
                        c.rg += min(s.Custom, s.Alpha);
                        c.b += 5.75 * min(s.Custom, s.Alpha);
                        c.b = saturate(c.b + s.Alpha * 0.02);
                        c.a = 1.0;
                        return c;
                }

                inline half4 LightingBlinnPhongEditor (EditorSurfaceOutput s, half3 lightDir, half3 viewDir, half atten){

                        half3 h = normalize (lightDir + viewDir);
                        half diff = max (0, dot ( lightDir, s.Normal ));

                        float nh = max (0, dot (s.Normal, h));
                        float spec = pow (nh, s.Specular*128.0);

                        half4 res;
                        res.rgb = _LightColor0.rgb * diff;
                        res.w = spec * Luminance (_LightColor0.rgb);
                        res *= atten * 1.0; //CHANGED TO 1.0 FOR 5.0

                        return LightingBlinnPhongEditor_PrePass( s, res );
                }


                struct Input {
                        float4 vertPos;
            float3 viewDir;
            float2 uv_BumpMap;
            float2 uv_NormMap;
                };

                float3 fade(float3 t){
            return t * t * t * (t * (t * 6 - 15) + 10);
        }

        float4 perm2d(float2 uv){
            return tex2D(_PermTable2D, uv);
        }

        float gradperm(float x, float3 p){
            float3 g = tex2D(_Gradient3D, float2(x, 0) ).rgb *2.0 - 1.0;
            return dot(g, p);
        }

        float inoise(float3 p){
            float3 P = fmod(floor(p), 256.0);   // FIND UNIT CUBE THAT CONTAINS POINT
            p -= floor(p);                      // FIND RELATIVE X,Y,Z OF POINT IN CUBE.
            float3 f = fade(p);                 // COMPUTE FADE CURVES FOR EACH OF X,Y,Z.

            P = P / 256.0;
            const float one = 1.0 / 256.0;

            // HASH COORDINATES OF THE 8 CUBE CORNERS
            float4 AA = perm2d(P.xy) + P.z;

            // AND ADD BLENDED RESULTS FROM 8 CORNERS OF CUBE
            return lerp( lerp( lerp( gradperm(AA.x, p ),
                                     gradperm(AA.z, p + float3(-1, 0, 0) ), f.x),
                               lerp( gradperm(AA.y, p + float3(0, -1, 0) ),
                                     gradperm(AA.w, p + float3(-1, -1, 0) ), f.x), f.y),

                         lerp( lerp( gradperm(AA.x+one, p + float3(0, 0, -1) ),
                                     gradperm(AA.z+one, p + float3(-1, 0, -1) ), f.x),
                               lerp( gradperm(AA.y+one, p + float3(0, -1, -1) ),
                                     gradperm(AA.w+one, p + float3(-1, -1, -1) ), f.x), f.y), f.z);
        }

        float fBm(float3 p, int octaves){
            float freq = _Frequency, amp = 0.5;
            float sum = 0;
            for(int i = 0; i < octaves; i++)
            {
                sum += inoise(p * freq) * amp;
                freq *= _Lacunarity;
                amp *= _Gain;
            }
            return sum;
        }

                void vert (inout appdata_full v, out Input o) {
                        UNITY_INITIALIZE_OUTPUT(Input,o);
                o.vertPos = v.vertex;
        }

                void surf (Input IN, inout EditorSurfaceOutput  o) {

            if(_PlanetType == 6){
                IN.vertPos.xyz = IN.vertPos.xyz/float3(4,_PlanetStretch,1);
            }

                        float n = fBm(IN.vertPos.xyz, 4);

                if(_Level1 < _ShoreLevel)
                    _Level1 = _ShoreLevel+0.02;

                if(_ShoreLevel < _WaterLevel)
                    _WaterLevel = _ShoreLevel-0.02;

                if(n >= _PeakLevel){
                    _ChosenColor = _PeakColor;
                }
                if(n <= _PeakLevel){
                    _ChosenColor = lerp(_Level3Color,_PeakColor, (n - _Level3)/(_PeakLevel - _Level3));
                }
                if(n <= _Level3){
                    _ChosenColor = lerp(_Level2Color,_Level3Color, (n - _Level2)/(_Level3 - _Level2));
                }
                if(n <= _Level2){
                    _ChosenColor = lerp(_Level1Color,_Level2Color, (n - _Level1)/(_Level2 - _Level1));
                }
                if(n <= _Level1){
                    _ChosenColor = lerp(_ShoreColor,_Level1Color, (n - _ShoreLevel)/(_Level1 - _ShoreLevel));
                }
                if(n <= _ShoreLevel){
                    _ChosenColor = lerp(_WaterColor,_ShoreColor, (n - _WaterLevel)/(_ShoreLevel - _WaterLevel));
                }
                if (n <= _WaterLevel){
                    _ChosenColor = _WaterColor;
                }


                if (_PlanetType == 0 && n >= _Level1 && IN.vertPos.y >= _IceLevel)
                    _ChosenColor = lerp(_ChosenColor,_ChosenColor*_IceStrength, (IN.vertPos.y - _IceLevel)/(_IceLevel));

                if (_PlanetType == 0 && n >= _Level1 && IN.vertPos.y <= -_IceLevel)
                    _ChosenColor = lerp(_ChosenColor,_ChosenColor*_IceStrength, (IN.vertPos.y + _IceLevel)/(-_IceLevel));

                if (_PlanetType == 2 && IN.vertPos.y >= _IceLevel)
                    _ChosenColor = lerp(_ChosenColor,_ChosenColor*_IceStrength, (IN.vertPos.y - _IceLevel)/(_IceLevel));

                if (_PlanetType == 2 && IN.vertPos.y <= -_IceLevel)
                    _ChosenColor = lerp(_ChosenColor,_ChosenColor*_IceStrength, (IN.vertPos.y + _IceLevel)/(-_IceLevel));

                if (_PlanetType == 3 && n >= _Level1 && IN.vertPos.y >= _IceLevel)
                    _ChosenColor = lerp(_ChosenColor,_IceColor, (IN.vertPos.y - _IceLevel)/(_IceLevel));

                if (_PlanetType == 3 && n >= _Level1 && IN.vertPos.y <= -_IceLevel)
                    _ChosenColor = lerp(_ChosenColor,_IceColor, (IN.vertPos.y + _IceLevel)/(-_IceLevel));

            o.Custom = 0.0;

            float4 Fresnel0_1_NoInput = float4(0,0,1,1);
                float4 Fresnel0=(1.0 - dot( normalize( float4( IN.viewDir.x, IN.viewDir.y,IN.viewDir.z,1.0 ).xyz), normalize( Fresnel0_1_NoInput.xyz ) )).xxxx;
                float4 Pow0=pow(Fresnel0,_AtmosFalloff.xxxx);
                float4 Saturate0=saturate(Pow0);
                float4 Lerp0=lerp(_AtmosNear,_AtmosFar,Saturate0);
                float4 Multiply1=Lerp0 * Saturate0;
                float4 Add0=Multiply1 + _ChosenColor;

                o.Albedo = Add0.xyz;
            o.Specular = 1.0;

            o.Gloss = 0.5;
            o.Normal = UnpackNormal(tex2D (_NormMap, IN.uv_NormMap));

            if(n > _ShoreLevel){
                o.Gloss = 0.1;
                o.Normal = UnpackNormal(tex2D (_BumpMap, IN.uv_BumpMap));
            }else if(_PlanetType == 2){
                o.Gloss = 0.1;
                o.Normal = UnpackNormal(tex2D (_BumpMap, IN.uv_BumpMap));
            }else if(_PlanetType == 5){
                o.Gloss = 0.1;
                o.Normal = UnpackNormal(tex2D (_BumpMap, IN.uv_BumpMap));
            }

            if(_PlanetType == 6){
                o.Gloss = 0.1;
                o.Normal = UnpackNormal(tex2D (_NormMap, IN.uv_NormMap));
            }

            if(_PlanetType == 0){
                if(n > _ShoreLevel){
                    o.Gloss = 0.01;
                }
                o.Gloss = 0.05;
            }

                }
                ENDCG


                //CITIES
        Blend SrcAlpha OneMinusSrcAlpha

                Tags{
            "Queue"="Transparent"
            "IgnoreProjector"="True"
            "RenderType"="Transparent"
        }

        Cull Off
        ZWrite Off
                Fog { Mode Off }
                Blend SrcAlpha OneMinusSrcAlpha

        CGPROGRAM
        #pragma surface surf BlinnPhongEditor vertex:vert alpha:blend
        #pragma target 3.0

        #include "UnityCG.cginc"

        uniform sampler2D _PermTable2D, _Gradient3D, _BumpMap, _NormMap;
        uniform float _CityTOP, _CityBOT, _isCities, _CityFrequency, _Frequency, _Lacunarity, _Gain, _CityLevel, _Level1, _Level2;
        uniform float4 _CityColor;

        float4 _AtmosNear;
        float4 _AtmosFar;
        float _AtmosFalloff;

        struct EditorSurfaceOutput {
            half3 Albedo;
            half3 Normal;
            half3 Emission;
            half3 Gloss;
            half Specular;
            half Alpha;
            half Custom;
          };

        inline half4 LightingBlinnPhongEditor_PrePass (EditorSurfaceOutput s, half4 light){
                half3 spec = light.a * s.Gloss;
                half4 c;
                c.rgb = (s.Albedo.rgb * light.rgb + light.rgb * spec);
                c.g -= .01 * s.Alpha;
                c.r -= .03 * s.Alpha;
                c.rg += min(s.Custom, s.Alpha);
                c.b += 5.75 * min(s.Custom, s.Alpha);
                c.b = saturate(c.b + s.Alpha * 0.02);
                c.a = s.Alpha;
                return c;
        }

        inline half4 LightingBlinnPhongEditor (EditorSurfaceOutput s, half3 lightDir, half3 viewDir, half atten){
                half3 h = normalize (lightDir + viewDir);
                half diff = max (0, dot ( lightDir, s.Normal ));

                float nh = max (0, dot (s.Normal, h));
                float spec = pow (nh, s.Specular*128.0);

                half4 res;
                res.rgb = _LightColor0.rgb * diff;
                res.w = spec * Luminance (_LightColor0.rgb);
                res *= atten * 2.0;

                half invdiff = 1 - saturate(16 * diff);
                s.Alpha = s.Custom*invdiff;

                return LightingBlinnPhongEditor_PrePass( s, res );
        }

        struct Input {
            float4 vertPos;
            float3 viewDir;
                        float2 uv_BumpMap;
            float2 uv_NormMap;
        };

        float3 fade(float3 t){
            return t * t * t * (t * (t * 6 - 15) + 10);
        }

        float4 perm2d(float2 uv){
            return tex2D(_PermTable2D, uv);
        }

        float gradperm(float x, float3 p){
            float3 g = tex2D(_Gradient3D, float2(x, 0) ).rgb *2.0 - 1.0;
            return dot(g, p);
        }

        float inoise(float3 p){
            float3 P = fmod(floor(p), 256.0);   // FIND UNIT CUBE THAT CONTAINS POINT
            p -= floor(p);                      // FIND RELATIVE X,Y,Z OF POINT IN CUBE.
            float3 f = fade(p);                 // COMPUTE FADE CURVES FOR EACH OF X,Y,Z.

            P = P / 256.0;
            const float one = 1.0 / 256.0;

            // HASH COORDINATES OF THE 8 CUBE CORNERS
            float4 AA = perm2d(P.xy) + P.z;

            // AND ADD BLENDED RESULTS FROM 8 CORNERS OF CUBE
            return lerp( lerp( lerp( gradperm(AA.x, p ),
                                     gradperm(AA.z, p + float3(-1, 0, 0) ), f.x),
                               lerp( gradperm(AA.y, p + float3(0, -1, 0) ),
                                     gradperm(AA.w, p + float3(-1, -1, 0) ), f.x), f.y),

                         lerp( lerp( gradperm(AA.x+one, p + float3(0, 0, -1) ),
                                     gradperm(AA.z+one, p + float3(-1, 0, -1) ), f.x),
                               lerp( gradperm(AA.y+one, p + float3(0, -1, -1) ),
                                     gradperm(AA.w+one, p + float3(-1, -1, -1) ), f.x), f.y), f.z);
        }

        float fBm(float3 p, int octaves){
            float freq = _CityFrequency, amp = 0.5;
            float sum = 0;
            for(int i = 0; i < octaves; i++)
            {
                sum += inoise(p * freq) * amp;
                freq *= _Lacunarity;
                amp *= _Gain;
            }
            return sum;
        }


        void vert (inout appdata_full v, out Input o) {
                UNITY_INITIALIZE_OUTPUT(Input,o);
                o.vertPos = v.vertex;
        }

        void surf (Input IN, inout EditorSurfaceOutput o) {

                float n = fBm(IN.vertPos.xyz, 1);

                _CityFrequency = _Frequency;

                float k = fBm(IN.vertPos.xyz, 4);

                if(IN.vertPos.y > 0.0){
                    _CityLevel *= IN.vertPos.y;
                }else{
                    _CityLevel *= -IN.vertPos.y;
                }
                _CityColor.a = n*2;

                if(n <= _CityLevel){
                    _CityColor.a = 0;
                }

                float4 Fresnel0_1_NoInput = float4(0,0,1,1);
                float4 Fresnel0=(1.0 - dot( normalize( float4( IN.viewDir.x, IN.viewDir.y,IN.viewDir.z,1.0 ).xyz), normalize( Fresnel0_1_NoInput.xyz ) )).xxxx;
                float4 Pow0=pow(Fresnel0,_AtmosFalloff.xxxx);
                float4 Saturate0=saturate(Pow0);
                float4 Lerp0=lerp(_AtmosNear,_AtmosFar,Saturate0);
                float4 Multiply1=Lerp0 * Saturate0;
                float4 Add0 = Multiply1 + _CityColor;

                if(_isCities <0.5){
                        Add0 = float4(0,0,0,0);
                        _CityColor.a = 0.0;
                }

                if(k > _Level1+0.05 && k < _Level2-0.05){
                                        o.Custom = _CityColor.a;
                }else{
                    Add0 = float4(0,0,0,0);
                    _CityColor.a = 0.0;
                                        o.Custom = 0.0;
                }

                                o.Specular = 1.0;
                                o.Gloss = 1.0;

                o.Albedo = Add0.xyz;
                o.Alpha = _CityColor.a;
                                o.Normal = UnpackNormal(tex2D (_NormMap, IN.uv_NormMap));

        }
        ENDCG

                //CLOUDS
        Tags{
            "Queue"="Transparent"
            "IgnoreProjector"="True"
            "RenderType"="Transparent"
        }

        Cull Off
        ZWrite Off
                Fog { Mode Off }
                Blend SrcAlpha OneMinusSrcAlpha

        CGPROGRAM
        #pragma surface surf BlinnPhongEditor vertex:vert alpha:blend
        #pragma target 3.0

                #pragma shader_feature _ _ALPHATEST_ON _ALPHABLEND_ON
        #include "UnityCG.cginc"

        uniform sampler2D _CloudPermTable2D, _CloudGradient3D, _BumpMap, _NormMap;
        uniform float _isClouds, _CloudRotation, _CloudFrequency, _CloudLacunarity, _CloudGain, _CloudLevel;
        uniform float4 _CloudColor;

        float4 _AtmosNear;
        float4 _AtmosFar;
        float _AtmosFalloff;

        struct EditorSurfaceOutput {
            half3 Albedo;
            half3 Normal;
            half3 Emission;
            half3 Gloss;
            half Specular;
            half Alpha;
            half Custom;
          };

        inline half4 LightingBlinnPhongEditor_PrePass (EditorSurfaceOutput s, half4 light){
                half3 spec = light.a * s.Gloss;
                half4 c;
                c.rgb = (s.Albedo.rgb * light.rgb + light.rgb * spec);
                c.g -= .01 * s.Alpha;
                c.r -= .03 * s.Alpha;
                c.rg += min(s.Custom, s.Alpha);
                c.b += 5.75 * min(s.Custom, s.Alpha);
                c.b = saturate(c.b + s.Alpha * 0.02);
                c.a = s.Alpha;
                return c;
        }

        inline half4 LightingBlinnPhongEditor (EditorSurfaceOutput s, half3 lightDir, half3 viewDir, half atten){
                half3 h = normalize (lightDir + viewDir);
                half diff = max (0, dot ( lightDir, s.Normal ));

                float nh = max (0, dot (s.Normal, h));
                float spec = pow (nh, s.Specular*128.0);

                half4 res;
                res.rgb = _LightColor0.rgb * diff;
                res.w = spec * Luminance (_LightColor0.rgb);
                res *= atten * 1.0;

                return LightingBlinnPhongEditor_PrePass( s, res );
        }

        struct Input {
            float4 vertPos;
            float3 viewDir;
                        float2 uv_BumpMap;
            float2 uv_NormMap;
        };

        float3 fade(float3 t){
            return t * t * t * (t * (t * 6 - 15) + 10);
        }

        float4 perm2d(float2 uv){
            return tex2D(_CloudPermTable2D, uv);
        }

        float gradperm(float x, float3 p){
            float3 g = tex2D(_CloudGradient3D, float2(x, 0) ).rgb *2.0 - 1.0;
            return dot(g, p);
        }

        float inoise(float3 p){
            float3 P = fmod(floor(p), 256.0);   // FIND UNIT CUBE THAT CONTAINS POINT
            p -= floor(p);                      // FIND RELATIVE X,Y,Z OF POINT IN CUBE.
            float3 f = fade(p);                 // COMPUTE FADE CURVES FOR EACH OF X,Y,Z.

            P = P / 256.0;
            const float one = 1.0 / 256.0;

            // HASH COORDINATES OF THE 8 CUBE CORNERS
            float4 AA = perm2d(P.xy) + P.z;

            // AND ADD BLENDED RESULTS FROM 8 CORNERS OF CUBE
            return lerp( lerp( lerp( gradperm(AA.x, p ),
                                     gradperm(AA.z, p + float3(-1, 0, 0) ), f.x),
                               lerp( gradperm(AA.y, p + float3(0, -1, 0) ),
                                     gradperm(AA.w, p + float3(-1, -1, 0) ), f.x), f.y),

                         lerp( lerp( gradperm(AA.x+one, p + float3(0, 0, -1) ),
                                     gradperm(AA.z+one, p + float3(-1, 0, -1) ), f.x),
                               lerp( gradperm(AA.y+one, p + float3(0, -1, -1) ),
                                     gradperm(AA.w+one, p + float3(-1, -1, -1) ), f.x), f.y), f.z);
        }

        float fBm(float3 p, int octaves){
            float freq = _CloudFrequency, amp = 0.5;
            float sum = 0;
            for(int i = 0; i < octaves; i++)
            {
                sum += inoise(p * freq) * amp;
                freq *= _CloudLacunarity;
                amp *= _CloudGain;
            }
            return sum;
        }


        void vert (inout appdata_full v, out Input o) {
                UNITY_INITIALIZE_OUTPUT(Input,o);
                o.vertPos = v.vertex;
                o.vertPos.x += _CloudRotation;
        }

        void surf (Input IN, inout EditorSurfaceOutput o) {

                float n = fBm(IN.vertPos.xyz, 4);

                _CloudColor.a = n*2;

                if(n <= _CloudLevel){
                    _CloudColor.a = 0;
                }

                float4 Fresnel0_1_NoInput = float4(0,0,1,1);
                float4 Fresnel0=(1.0 - dot( normalize( float4( IN.viewDir.x, IN.viewDir.y,IN.viewDir.z,1.0 ).xyz), normalize( Fresnel0_1_NoInput.xyz ) )).xxxx;
                float4 Pow0=pow(Fresnel0,_AtmosFalloff.xxxx);
                float4 Saturate0=saturate(Pow0);
                float4 Lerp0=lerp(_AtmosNear,_AtmosFar,Saturate0);
                float4 Multiply1=Lerp0 * Saturate0;
                float4 Add0 = Multiply1 + _CloudColor;

                if(_isClouds <0.5){
                    Add0 = float4(0,0,0,0);
                    _CloudColor.a = 0.0;
                }

                    o.Albedo = Add0.xyz;
                    o.Alpha = _CloudColor.a;

                                o.Gloss = 0.0;
                                o.Specular = 0.0;
                                o.Custom = 0.0;
                                o.Normal = UnpackNormal(tex2D (_NormMap, IN.uv_NormMap));

        }
        ENDCG

        }
}
 

[jetyb]

ЭЭЭ.. в этом без бутылки сложно разбираться... гоните пузырь

по делу сами потрахайтесь:
- уберите лишние операции, их тут до хренища
- избавьтесь от if - ов , условные операторы тут фатально тормозные, особенно во фрагментном шейдере, у вас их до хрена
- используйте half и fixed вместо float, они более быстрые

такой тяжелый шейдер не то что на андроиде, на ПК будет тормозить

[alt3d]

Маловат шейдер!
Надо было всю игру в один шейдер запихать. И вообще все расчеты в нем вести - логику, ИИ, типы планет и звезд, дороги, небо, аллаха - все в шейдер!
И каждый кадр, для каждого пикселя все это считать!

[kripto289]

- используйте half и fixed вместо float, они более быстрые

Хочу заметить, PC видеокарты игнорируют half/fixed (всё по дефолту считают как float), поэтому на дектопе изменений не будет видно и надо тестить на ведроиде