Double sided custom shader looks strange - Need Help.

I'm very new to Shaders programming, I was trying to create a shader which:

• Allows to change 2 textures with 2 corresponding normal maps (fade in/fade out)
• Doublesided (show mesh from both sides of the surface)

Here is what I end up with:

Code (CSharp):

1.      Shader "Custom/TextureBlend" {
2.          Properties {
3.              _Color ("Color", Color) = (1,1,1,1)
4.              _Blend ("Texture Blend", Range(0,1)) = 0.0
5.              _MainTex ("Albedo (RGB)", 2D) = "white" {}
6.              _MainTex2 ("Albedo 2 (RGB)", 2D) = "white" {}
7.              _Glossiness ("Smoothness", Range(0,1)) = 0.5
8.              _Metallic ("Metallic", Range(0,1)) = 0.0
9.              _BumpMap ("Bumpmap", 2D) = "bump" {}
10.              _BumpMap2 ("Bumpmap", 2D) = "bump" {}
11.          }
12.          SubShader {
13.              Tags { "RenderType"="Opaque" }
14.              LOD 200
15.               Cull Off
16.               ZTest LEqual
17.  
18.              CGPROGRAM
19.              // Physically based Standard lighting model, and enable shadows on all light types
20.              #pragma surface surf Standard fullforwardshadows
21.      
22.              // Use shader model 3.0 target, to get nicer looking lighting
23.              #pragma target 3.0
24.      
25.              sampler2D _MainTex;
26.              sampler2D _MainTex2;
27.              sampler2D _BumpMap;
28.              sampler2D _BumpMap2;
29.      
30.              struct Input {
31.                  float2 uv_MainTex;
32.                  float2 uv_MainTex2;
33.                  float2 uv_BumpMap;
34.                  float2 uv_BumpMap2;
35.              };
36.      
37.              half _Blend;
38.              half _Glossiness;
39.              half _Metallic;
40.              fixed4 _Color;
41.    
42.              void surf (Input IN, inout SurfaceOutputStandard o) {
43.                  // Albedo comes from a texture tinted by color
44.                  fixed4 c = lerp (tex2D (_MainTex, IN.uv_MainTex), tex2D (_MainTex2, IN.uv_MainTex2), _Blend) * _Color;
45.                  o.Albedo = c.rgb;
46.                  // Metallic and smoothness come from slider variables
47.                  o.Metallic = _Metallic;
48.                  o.Smoothness = _Glossiness;
49.                  o.Alpha = c.a;
50.                  fixed4 n = lerp (tex2D (_BumpMap, IN.uv_BumpMap), tex2D (_BumpMap2, IN.uv_BumpMap2), _Blend) * _Color;
51.                  o.Normal = n.rgb;
52.              }
53.              ENDCG
54.          }
55.          FallBack "Diffuse"
56.      }

It works but for some reason the texture on the surface looks dim (on the other side of the mesh which usually invisible it's even darker), and normal map reflections barely visible.

Here, on the left you can see the plane with my shader, on the right - standard shader:



Also the reflection looks really strange, if I will move Metallic slider to the right you will see it:




I would be super grateful for any help.
Thank you very much in advance!

 

I am not sure of the answer my self, but I think it has got something to do with the normals. There should be something more that you need to add to the shader to make it work in both sides as a plane will always have normals in one direction.

 

@iamvideep is correct. The problem for lit double sided materials is the vertex normals are aligned to the front face of the tri, so when you turn off culling it's rendering with the normals pointed away from you. The math for lighting and reflections breaks down as there are assumptions made that there will never be more than 90 degrees difference between the view direction and the surface normal.

The trick is to use VFACE, which is a variable that is passed to fragment shaders (which the surface function is called inside of) to say which side of a tri you're rendering.

Code (csharp):

1. struct Input
2. {
3.     // usual UV stuff
4.     fixed facing : VFACE;
5. }
6.  
7. // in surf function
8. o.Normal = UnpackNormal(tex2D(_BumpMap, IN.uv_BumpMap));
9. o.Normal.z *= IN.facing;

One extra note, you really should be using the UnpackNormal() function if you're using Unity's Normal Map texture import type. On mobile it doesn't really matter, but on desktop and consoles it will make a difference. If you are importing normal maps as regular textures, do make sure to set Bypass sRGB on the texture.