+16

Shaders that use vertex colors and fog break with Single Pass Stereo Rendering enabled (Gear Vr)

Christoph 12 months ago 0

With Single Pass Stereo Rendering enabled, in VR, Shaders that use vertex colors show up with graphical artifacts, when fog (in Lighting Window) is enabled.

Lighting is set to Baked Global Illumination.


Unity Version: 5.6.2.f1

Device: Samsung Galaxy S7 (with Gear Vr)


top image is taken in vr
bottom image is taken in editor


The shader code:
-------------------------------------------------------------------------------


// Shader created with Shader Forge v1.37 

// Shader Forge (c) Neat Corporation / Joachim Holmer - http://www.acegikmo.com/shaderforge/

// Note: Manually altering this data may prevent you from opening it in Shader Forge

/*SF_DATA;ver:1.37;sub:START;pass:START;ps:flbk:,iptp:0,cusa:False,bamd:0,cgin:,lico:1,lgpr:1,limd:1,spmd:1,trmd:0,grmd:0,uamb:True,mssp:True,bkdf:True,hqlp:False,rprd:True,enco:True,rmgx:True,imps:True,rpth:0,vtps:0,hqsc:True,nrmq:1,nrsp:0,vomd:0,spxs:False,tesm:0,olmd:1,culm:0,bsrc:0,bdst:1,dpts:2,wrdp:True,dith:0,atcv:False,rfrpo:True,rfrpn:Refraction,coma:15,ufog:True,aust:True,igpj:False,qofs:0,qpre:1,rntp:1,fgom:False,fgoc:False,fgod:False,fgor:False,fgmd:0,fgcr:0.5,fgcg:0.5,fgcb:0.5,fgca:1,fgde:0.01,fgrn:0,fgrf:300,stcl:False,stva:128,stmr:255,stmw:255,stcp:6,stps:0,stfa:0,stfz:0,ofsf:0,ofsu:0,f2p0:False,fnsp:False,fnfb:False,fsmp:False;n:type:ShaderForge.SFN_Final,id:4013,x:33078,y:32801,varname:node_4013,prsc:2|diff-3076-RGB,spec-3039-RGB,gloss-3039-A,normal-9069-RGB,amdfl-714-RGB;n:type:ShaderForge.SFN_Tex2d,id:3076,x:32418,y:32587,ptovrint:False,ptlb:diffuse,ptin:_diffuse,varname:_diffuse,prsc:2,glob:False,taghide:False,taghdr:False,tagprd:False,tagnsco:False,tagnrm:False,ntxv:0,isnm:False;n:type:ShaderForge.SFN_Tex2d,id:3039,x:32418,y:32821,ptovrint:False,ptlb:spec,ptin:_spec,varname:_spec,prsc:2,glob:False,taghide:False,taghdr:False,tagprd:False,tagnsco:False,tagnrm:False,ntxv:0,isnm:False;n:type:ShaderForge.SFN_Tex2d,id:9069,x:32418,y:33050,ptovrint:False,ptlb:normal,ptin:_normal,varname:_normal,prsc:2,glob:False,taghide:False,taghdr:False,tagprd:False,tagnsco:False,tagnrm:False,ntxv:3,isnm:True;n:type:ShaderForge.SFN_VertexColor,id:714,x:32418,y:33263,varname:node_714,prsc:2;proporder:3076-3039-9069;pass:END;sub:END;*/

Shader "Shader Forge/broken_single_pass_shader" {

    Properties {

        _diffuse ("diffuse", 2D) = "white" {}

        _spec ("spec", 2D) = "white" {}

        _normal ("normal", 2D) = "bump" {}

    }

    SubShader {

        Tags {

            "RenderType"="Opaque"

        }

        Pass {

            Name "FORWARD"

            Tags {

                "LightMode"="ForwardBase"

            }

            

            

            CGPROGRAM

            #pragma vertex vert

            #pragma fragment frag

            #define UNITY_PASS_FORWARDBASE

            #define SHOULD_SAMPLE_SH ( defined (LIGHTMAP_OFF) && defined(DYNAMICLIGHTMAP_OFF) )

            #define _GLOSSYENV 1

            #include "UnityCG.cginc"

            #include "AutoLight.cginc"

            #include "Lighting.cginc"

            #include "UnityPBSLighting.cginc"

            #include "UnityStandardBRDF.cginc"

            #pragma multi_compile_fwdbase_fullshadows

            #pragma multi_compile LIGHTMAP_OFF LIGHTMAP_ON

            #pragma multi_compile DIRLIGHTMAP_OFF DIRLIGHTMAP_COMBINED DIRLIGHTMAP_SEPARATE

            #pragma multi_compile DYNAMICLIGHTMAP_OFF DYNAMICLIGHTMAP_ON

            #pragma multi_compile_fog

            #pragma only_renderers d3d11 gles gles3 

            #pragma target 3.0

            uniform sampler2D _diffuse; uniform float4 _diffuse_ST;

            uniform sampler2D _spec; uniform float4 _spec_ST;

            uniform sampler2D _normal; uniform float4 _normal_ST;

            struct VertexInput {

                float4 vertex : POSITION;

                float3 normal : NORMAL;

                float4 tangent : TANGENT;

                float2 texcoord0 : TEXCOORD0;

                float2 texcoord1 : TEXCOORD1;

                float2 texcoord2 : TEXCOORD2;

                float4 vertexColor : COLOR;

            };

            struct VertexOutput {

                float4 pos : SV_POSITION;

                float2 uv0 : TEXCOORD0;

                float2 uv1 : TEXCOORD1;

                float2 uv2 : TEXCOORD2;

                float4 posWorld : TEXCOORD3;

                float3 normalDir : TEXCOORD4;

                float3 tangentDir : TEXCOORD5;

                float3 bitangentDir : TEXCOORD6;

                float4 vertexColor : COLOR;

                LIGHTING_COORDS(7,8)

                UNITY_FOG_COORDS(9)

                #if defined(LIGHTMAP_ON) || defined(UNITY_SHOULD_SAMPLE_SH)

                    float4 ambientOrLightmapUV : TEXCOORD10;

                #endif

            };

            VertexOutput vert (VertexInput v) {

                VertexOutput o = (VertexOutput)0;

                o.uv0 = v.texcoord0;

                o.uv1 = v.texcoord1;

                o.uv2 = v.texcoord2;

                o.vertexColor = v.vertexColor;

                #ifdef LIGHTMAP_ON

                    o.ambientOrLightmapUV.xy = v.texcoord1.xy * unity_LightmapST.xy + unity_LightmapST.zw;

                    o.ambientOrLightmapUV.zw = 0;

                #elif UNITY_SHOULD_SAMPLE_SH

                #endif

                #ifdef DYNAMICLIGHTMAP_ON

                    o.ambientOrLightmapUV.zw = v.texcoord2.xy * unity_DynamicLightmapST.xy + unity_DynamicLightmapST.zw;

                #endif

                o.normalDir = UnityObjectToWorldNormal(v.normal);

                o.tangentDir = normalize( mul( unity_ObjectToWorld, float4( v.tangent.xyz, 0.0 ) ).xyz );

                o.bitangentDir = normalize(cross(o.normalDir, o.tangentDir) * v.tangent.w);

                o.posWorld = mul(unity_ObjectToWorld, v.vertex);

                float3 lightColor = _LightColor0.rgb;

                o.pos = UnityObjectToClipPos( v.vertex );

                UNITY_TRANSFER_FOG(o,o.pos);

                TRANSFER_VERTEX_TO_FRAGMENT(o)

                return o;

            }

            float4 frag(VertexOutput i) : COLOR {

                i.normalDir = normalize(i.normalDir);

                float3x3 tangentTransform = float3x3( i.tangentDir, i.bitangentDir, i.normalDir);

                float3 viewDirection = normalize(_WorldSpaceCameraPos.xyz - i.posWorld.xyz);

                float3 _normal_var = UnpackNormal(tex2D(_normal,TRANSFORM_TEX(i.uv0, _normal)));

                float3 normalLocal = _normal_var.rgb;

                float3 normalDirection = normalize(mul( normalLocal, tangentTransform )); // Perturbed normals

                float3 viewReflectDirection = reflect( -viewDirection, normalDirection );

                float3 lightDirection = normalize(_WorldSpaceLightPos0.xyz);

                float3 lightColor = _LightColor0.rgb;

                float3 halfDirection = normalize(viewDirection+lightDirection);

////// Lighting:

                float attenuation = LIGHT_ATTENUATION(i);

                float3 attenColor = attenuation * _LightColor0.xyz;

                float Pi = 3.141592654;

                float InvPi = 0.31830988618;

///////// Gloss:

                float4 _spec_var = tex2D(_spec,TRANSFORM_TEX(i.uv0, _spec));

                float gloss = _spec_var.a;

                float specPow = exp2( gloss * 10.0 + 1.0 );

/////// GI Data:

                UnityLight light;

                #ifdef LIGHTMAP_OFF

                    light.color = lightColor;

                    light.dir = lightDirection;

                    light.ndotl = LambertTerm (normalDirection, light.dir);

                #else

                    light.color = half3(0.f, 0.f, 0.f);

                    light.ndotl = 0.0f;

                    light.dir = half3(0.f, 0.f, 0.f);

                #endif

                UnityGIInput d;

                d.light = light;

                d.worldPos = i.posWorld.xyz;

                d.worldViewDir = viewDirection;

                d.atten = attenuation;

                #if defined(LIGHTMAP_ON) || defined(DYNAMICLIGHTMAP_ON)

                    d.ambient = 0;

                    d.lightmapUV = i.ambientOrLightmapUV;

                #else

                    d.ambient = i.ambientOrLightmapUV;

                #endif

                #if UNITY_SPECCUBE_BLENDING || UNITY_SPECCUBE_BOX_PROJECTION

                    d.boxMin[0] = unity_SpecCube0_BoxMin;

                    d.boxMin[1] = unity_SpecCube1_BoxMin;

                #endif

                #if UNITY_SPECCUBE_BOX_PROJECTION

                    d.boxMax[0] = unity_SpecCube0_BoxMax;

                    d.boxMax[1] = unity_SpecCube1_BoxMax;

                    d.probePosition[0] = unity_SpecCube0_ProbePosition;

                    d.probePosition[1] = unity_SpecCube1_ProbePosition;

                #endif

                d.probeHDR[0] = unity_SpecCube0_HDR;

                d.probeHDR[1] = unity_SpecCube1_HDR;

                Unity_GlossyEnvironmentData ugls_en_data;

                ugls_en_data.roughness = 1.0 - gloss;

                ugls_en_data.reflUVW = viewReflectDirection;

                UnityGI gi = UnityGlobalIllumination(d, 1, normalDirection, ugls_en_data );

                lightDirection = gi.light.dir;

                lightColor = gi.light.color;

////// Specular:

                float NdotL = saturate(dot( normalDirection, lightDirection ));

                float3 specularColor = _spec_var.rgb;

                float specularMonochrome = max( max(specularColor.r, specularColor.g), specularColor.b);

                float normTerm = (specPow + 8.0 ) / (8.0 * Pi);

                float3 directSpecular = attenColor * pow(max(0,dot(halfDirection,normalDirection)),specPow)*normTerm*specularColor;

                float3 indirectSpecular = (gi.indirect.specular)*specularColor;

                float3 specular = (directSpecular + indirectSpecular);

/////// Diffuse:

                NdotL = max(0.0,dot( normalDirection, lightDirection ));

                float3 directDiffuse = max( 0.0, NdotL) * attenColor;

                float3 indirectDiffuse = float3(0,0,0);

                indirectDiffuse += i.vertexColor.rgb; // Diffuse Ambient Light

                indirectDiffuse += gi.indirect.diffuse;

                float4 _diffuse_var = tex2D(_diffuse,TRANSFORM_TEX(i.uv0, _diffuse));

                float3 diffuseColor = _diffuse_var.rgb;

                diffuseColor *= 1-specularMonochrome;

                float3 diffuse = (directDiffuse + indirectDiffuse) * diffuseColor;

/// Final Color:

                float3 finalColor = diffuse + specular;

                fixed4 finalRGBA = fixed4(finalColor,1);

                UNITY_APPLY_FOG(i.fogCoord, finalRGBA);

                return finalRGBA;

            }

            ENDCG

        }

        Pass {

            Name "FORWARD_DELTA"

            Tags {

                "LightMode"="ForwardAdd"

            }

            Blend One One

            

            

            CGPROGRAM

            #pragma vertex vert

            #pragma fragment frag

            #define UNITY_PASS_FORWARDADD

            #define SHOULD_SAMPLE_SH ( defined (LIGHTMAP_OFF) && defined(DYNAMICLIGHTMAP_OFF) )

            #define _GLOSSYENV 1

            #include "UnityCG.cginc"

            #include "AutoLight.cginc"

            #include "Lighting.cginc"

            #include "UnityPBSLighting.cginc"

            #include "UnityStandardBRDF.cginc"

            #pragma multi_compile_fwdadd_fullshadows

            #pragma multi_compile LIGHTMAP_OFF LIGHTMAP_ON

            #pragma multi_compile DIRLIGHTMAP_OFF DIRLIGHTMAP_COMBINED DIRLIGHTMAP_SEPARATE

            #pragma multi_compile DYNAMICLIGHTMAP_OFF DYNAMICLIGHTMAP_ON

            #pragma multi_compile_fog

            #pragma only_renderers d3d11 gles gles3 

            #pragma target 3.0

            uniform sampler2D _diffuse; uniform float4 _diffuse_ST;

            uniform sampler2D _spec; uniform float4 _spec_ST;

            uniform sampler2D _normal; uniform float4 _normal_ST;

            struct VertexInput {

                float4 vertex : POSITION;

                float3 normal : NORMAL;

                float4 tangent : TANGENT;

                float2 texcoord0 : TEXCOORD0;

                float2 texcoord1 : TEXCOORD1;

                float2 texcoord2 : TEXCOORD2;

            };

            struct VertexOutput {

                float4 pos : SV_POSITION;

                float2 uv0 : TEXCOORD0;

                float2 uv1 : TEXCOORD1;

                float2 uv2 : TEXCOORD2;

                float4 posWorld : TEXCOORD3;

                float3 normalDir : TEXCOORD4;

                float3 tangentDir : TEXCOORD5;

                float3 bitangentDir : TEXCOORD6;

                LIGHTING_COORDS(7,8)

                UNITY_FOG_COORDS(9)

            };

            VertexOutput vert (VertexInput v) {

                VertexOutput o = (VertexOutput)0;

                o.uv0 = v.texcoord0;

                o.uv1 = v.texcoord1;

                o.uv2 = v.texcoord2;

                o.normalDir = UnityObjectToWorldNormal(v.normal);

                o.tangentDir = normalize( mul( unity_ObjectToWorld, float4( v.tangent.xyz, 0.0 ) ).xyz );

                o.bitangentDir = normalize(cross(o.normalDir, o.tangentDir) * v.tangent.w);

                o.posWorld = mul(unity_ObjectToWorld, v.vertex);

                float3 lightColor = _LightColor0.rgb;

                o.pos = UnityObjectToClipPos( v.vertex );

                UNITY_TRANSFER_FOG(o,o.pos);

                TRANSFER_VERTEX_TO_FRAGMENT(o)

                return o;

            }

            float4 frag(VertexOutput i) : COLOR {

                i.normalDir = normalize(i.normalDir);

                float3x3 tangentTransform = float3x3( i.tangentDir, i.bitangentDir, i.normalDir);

                float3 viewDirection = normalize(_WorldSpaceCameraPos.xyz - i.posWorld.xyz);

                float3 _normal_var = UnpackNormal(tex2D(_normal,TRANSFORM_TEX(i.uv0, _normal)));

                float3 normalLocal = _normal_var.rgb;

                float3 normalDirection = normalize(mul( normalLocal, tangentTransform )); // Perturbed normals

                float3 lightDirection = normalize(lerp(_WorldSpaceLightPos0.xyz, _WorldSpaceLightPos0.xyz - i.posWorld.xyz,_WorldSpaceLightPos0.w));

                float3 lightColor = _LightColor0.rgb;

                float3 halfDirection = normalize(viewDirection+lightDirection);

////// Lighting:

                float attenuation = LIGHT_ATTENUATION(i);

                float3 attenColor = attenuation * _LightColor0.xyz;

                float Pi = 3.141592654;

                float InvPi = 0.31830988618;

///////// Gloss:

                float4 _spec_var = tex2D(_spec,TRANSFORM_TEX(i.uv0, _spec));

                float gloss = _spec_var.a;

                float specPow = exp2( gloss * 10.0 + 1.0 );

////// Specular:

                float NdotL = saturate(dot( normalDirection, lightDirection ));

                float3 specularColor = _spec_var.rgb;

                float specularMonochrome = max( max(specularColor.r, specularColor.g), specularColor.b);

                float normTerm = (specPow + 8.0 ) / (8.0 * Pi);

                float3 directSpecular = attenColor * pow(max(0,dot(halfDirection,normalDirection)),specPow)*normTerm*specularColor;

                float3 specular = directSpecular;

/////// Diffuse:

                NdotL = max(0.0,dot( normalDirection, lightDirection ));

                float3 directDiffuse = max( 0.0, NdotL) * attenColor;

                float4 _diffuse_var = tex2D(_diffuse,TRANSFORM_TEX(i.uv0, _diffuse));

                float3 diffuseColor = _diffuse_var.rgb;

                diffuseColor *= 1-specularMonochrome;

                float3 diffuse = directDiffuse * diffuseColor;

/// Final Color:

                float3 finalColor = diffuse + specular;

                fixed4 finalRGBA = fixed4(finalColor * 1,0);

                UNITY_APPLY_FOG(i.fogCoord, finalRGBA);

                return finalRGBA;

            }

            ENDCG

        }

        Pass {

            Name "Meta"

            Tags {

                "LightMode"="Meta"

            }

            Cull Off

            

            CGPROGRAM

            #pragma vertex vert

            #pragma fragment frag

            #define UNITY_PASS_META 1

            #define SHOULD_SAMPLE_SH ( defined (LIGHTMAP_OFF) && defined(DYNAMICLIGHTMAP_OFF) )

            #define _GLOSSYENV 1

            #include "UnityCG.cginc"

            #include "Lighting.cginc"

            #include "UnityPBSLighting.cginc"

            #include "UnityStandardBRDF.cginc"

            #include "UnityMetaPass.cginc"

            #pragma fragmentoption ARB_precision_hint_fastest

            #pragma multi_compile_shadowcaster

            #pragma multi_compile LIGHTMAP_OFF LIGHTMAP_ON

            #pragma multi_compile DIRLIGHTMAP_OFF DIRLIGHTMAP_COMBINED DIRLIGHTMAP_SEPARATE

            #pragma multi_compile DYNAMICLIGHTMAP_OFF DYNAMICLIGHTMAP_ON

            #pragma multi_compile_fog

            #pragma only_renderers d3d11 gles gles3 

            #pragma target 3.0

            uniform sampler2D _diffuse; uniform float4 _diffuse_ST;

            uniform sampler2D _spec; uniform float4 _spec_ST;

            struct VertexInput {

                float4 vertex : POSITION;

                float2 texcoord0 : TEXCOORD0;

                float2 texcoord1 : TEXCOORD1;

                float2 texcoord2 : TEXCOORD2;

            };

            struct VertexOutput {

                float4 pos : SV_POSITION;

                float2 uv0 : TEXCOORD0;

                float2 uv1 : TEXCOORD1;

                float2 uv2 : TEXCOORD2;

                float4 posWorld : TEXCOORD3;

            };

            VertexOutput vert (VertexInput v) {

                VertexOutput o = (VertexOutput)0;

                o.uv0 = v.texcoord0;

                o.uv1 = v.texcoord1;

                o.uv2 = v.texcoord2;

                o.posWorld = mul(unity_ObjectToWorld, v.vertex);

                o.pos = UnityMetaVertexPosition(v.vertex, v.texcoord1.xy, v.texcoord2.xy, unity_LightmapST, unity_DynamicLightmapST );

                return o;

            }

            float4 frag(VertexOutput i) : SV_Target {

                float3 viewDirection = normalize(_WorldSpaceCameraPos.xyz - i.posWorld.xyz);

                UnityMetaInput o;

                UNITY_INITIALIZE_OUTPUT( UnityMetaInput, o );

                

                o.Emission = 0;

                

                float4 _diffuse_var = tex2D(_diffuse,TRANSFORM_TEX(i.uv0, _diffuse));

                float3 diffColor = _diffuse_var.rgb;

                float4 _spec_var = tex2D(_spec,TRANSFORM_TEX(i.uv0, _spec));

                float3 specColor = _spec_var.rgb;

                float roughness = 1.0 - _spec_var.a;

                o.Albedo = diffColor + specColor * roughness * roughness * 0.5;

                

                return UnityMetaFragment( o );

            }

            ENDCG

        }

    }

    FallBack "Diffuse"

    CustomEditor "ShaderForgeMaterialInspector"

}


---------------------------------------------------------------

With kind regards,
Christoph