WavySphere shader

Shader "Erika/WavyModified" {

// Shader made by Erika Moya. With @MatthewDBell 's help
// Goes with this script: https://pastebin.com/jTYuRsSn

        Properties {
            _Tess ("Tessellation", Range(1,32)) = 4
            _MainTex ("Base (RGB)", 2D) = "white" {}
            _Color ("Main color", Color) = (1, 1, 1, 0)
            _Glossiness ("Smoothness", Range(0,1)) = 0.5
            _Metallic ("Metallic", Range(0,1)) = 0.0

            _DispTex1 ("Disp Texture 1", 2D) = "gray" {}
            _NormalMap1 ("Normalmap1", 2D) = "bump" {}
            _ScrollX1 ("Scroll X1", Range(-5, 5)) = 1
            _ScrollY1 ("Scroll Y1", Range(-5, 5)) = 1

            _DispTex2 ("Disp Texture 2", 2D) = "gray" {}
            _NormalMap2 ("Normalmap2", 2D) = "bump" {}
            _ScrollX2 ("Scroll X2", Range(-5, 5)) = 1
            _ScrollY2 ("Scroll Y2", Range(-5, 5)) = 1

			_DispPatch ("Disp Patch", 2D) = "gray" {} // For the poles of the sphere
            _NormalMapPatch ("Normalmap patch", 2D) = "bump" {}

			_DispLogo ("Logo displacement", 2D) = "gray" {}
			_LogoNM ("Logo normal map", 2D) = "gray" {}

            _NormalStrength ("Normal strength", Range (0, 5.0)) = 1.0
            _Displacement ("Displacement", Range(0, 1.0)) = 0.3

            _DispBuildings ("Displacement for buildings", CUBE) = ""{}
			_Brightness ("Brightness of cubemap", float) = 1

			_Blend ("Blend", Range(0,1)) = 0.0

        }
        SubShader {
            Tags { "RenderType"="Opaque" }
            LOD 300

            CGPROGRAM
            #pragma surface surf Standard addshadow fullforwardshadows vertex:disp tessellate:tessFixed nolightmap
            #pragma target 4.6
            #include "UnityCG.cginc"

            struct appdata {
                float4 vertex : POSITION;
                float4 tangent : TANGENT;
                float3 normal : NORMAL;
                float2 texcoord : TEXCOORD0;

                float4 color : COLOR;
            };

            float _Tess;

            float4 tessFixed()
            {
                return _Tess;
            }

            // Displacement
            sampler2D _DispTex1;
            sampler2D _DispTex2;
            sampler2D _DispPatch;
			sampler2D _DispLogo;
			sampler2D _LogoNM;
            sampler2D _NormalMap1;
            sampler2D _NormalMap2;
            sampler2D _NormalMapPatch;
            float _Displacement;

            // Scrolling texture effect
            float _ScrollX1;
            float _ScrollY1;
            float _ScrollX2;
            float _ScrollY2;

            samplerCUBE _DispBuildings;
            uniform float4 _DispBuildings_TexelSize;
            half4 _DispBuildings_HDR;
			float _Brightness;
            half4 tex;

			half _Blend;

            void disp (inout appdata v)
            {
                _ScrollX1 *= _Time.x;
                _ScrollY1 *= _Time.x;
                _ScrollX2 *= _Time.x;
                _ScrollY2 *= _Time.x;

				// Waves
				float d = ((tex2Dlod(_DispTex1, float4(v.texcoord.xy, 0, 0) + float4(_ScrollX1, _ScrollY1, 0, 0)).r
                + tex2Dlod(_DispTex2, float4(v.texcoord.xy, 0, 0) + float4(_ScrollX2, _ScrollY2, 0, 0)).r))
                * (-1 * _Displacement);

				// Poles patch
                d *= tex2Dlod(_DispPatch, float4(v.texcoord.xy,0,0)).r;
                v.color = mul(unity_ObjectToWorld, v.vertex);

				// Buildings
                d *= 1.0f - texCUBElod(_DispBuildings, float4(v.color.xyz, 0)).r * _Brightness;
                tex = texCUBElod(_DispBuildings, float4(v.color.xyz, 0)).r * _Brightness;

				// Logo
				float dL = - tex2Dlod(_DispLogo, float4(v.texcoord.xy,0,0)) * _Displacement / 2;


                v.vertex.xyz += v.normal * lerp(d, dL, _Blend);

            }

            struct Input {
                float2 uv_MainTex;
				float2 uv_LogoNM;
                float2 uv_NormalMap1;
                float2 uv_NormalMap2;
                float3 worldRefl;
                float4 color : COLOR;
                INTERNAL_DATA

            };

            sampler2D _MainTex;
            sampler2D _NormalMap;
            float _NormalStrength;
            fixed4 _Color;
            half _Glossiness;
            half _Metallic;


            void surf (Input IN, inout SurfaceOutputStandard o) {
                o.Albedo = lerp (_Color, tex2D(_MainTex, IN.uv_MainTex).rgb, _Blend);
                o.Metallic = _Metallic;
                o.Smoothness = lerp (_Glossiness, 0, _Blend);

                _ScrollX1 *= _Time.x;
                _ScrollY1 *= _Time.x;
                _ScrollX2 *= _Time.x;
                _ScrollY2 *= _Time.x;

                // Cubemap normal map
                float3 cubemapNormal = float3(0,0,1);

				float heightSampleCenter = texCUBE(_DispBuildings, IN.color.xyz).r;
				float heightSampleRight = texCUBE(_DispBuildings, IN.color.xyz + float3(_DispBuildings_TexelSize.x,0,0)).r;
				float heightSampleUp = texCUBE(_DispBuildings, IN.color.xyz + float3(0,_DispBuildings_TexelSize.y,0)).r;

                float sampleDeltaRight = heightSampleRight - heightSampleCenter;
                float sampleDeltaUp = heightSampleUp - heightSampleCenter;

                float _BumpStrength = 15.0f;

                cubemapNormal = cross (float3(1, 0, sampleDeltaRight * _BumpStrength), float3(0,1, sampleDeltaUp * _BumpStrength));

                // Normalmap

                IN.uv_NormalMap1 += fixed2(_ScrollX1, _ScrollY1);
                IN.uv_NormalMap2 += fixed2(_ScrollX2, _ScrollY2);


				/* // Normal maps including waves and buildings
                float3 normal = (UnpackNormal(tex2D(_NormalMap1, IN.uv_NormalMap1))
                + UnpackNormal(tex2D(_NormalMap2, IN.uv_NormalMap2))
                + cubemapNormal)
                * UnpackNormal(tex2D(_NormalMapPatch, IN.uv_MainTex));
                normal.xy *= _NormalStrength;
                o.Normal = normalize(normal);
				*/
				// Normal map for just the sphere
				float3 normalWaves = UnpackNormal(tex2D(_NormalMap1, IN.uv_NormalMap1)) + UnpackNormal(tex2D(_NormalMap2, IN.uv_NormalMap2));
				float3 normalLogo = UnpackNormal(tex2D(_LogoNM, IN.uv_LogoNM));
				float3 normal = lerp (normalWaves, normalLogo, _Blend);

				normal.xy *= _NormalStrength;
				o.Normal = normalize (normal);

            }
            ENDCG
        }
        FallBack "Diffuse"
    }