Merge pull request #1111 from Unity-Technologies/lw/shader-optimization

Lw/shader optimization

ScriptableRenderPipeline/Core/CoreRP/ShaderLibrary/Common.hlsl

 #define real3x3 half3x3
 #define real3x4 half3x4
 #define real4x3 half4x3
-#define real4x4 half4x4
+#define real4x4 half4x4
+
+#define half min16float
+#define half2 min16float2
+#define half3 min16float3
+#define half4 min16float4
+
+#define half2x2 min16float2x2
+#define half2x3 min16float2x3
+#define half3x2 min16float3x2
+#define half3x3 min16float3x3
+#define half3x4 min16float3x4
+#define half4x3 min16float4x3
+#define half4x4 min16float4x4
 
 #define REAL_MIN HALF_MIN
 #define REAL_MAX HALF_MAX

ScriptableRenderPipeline/LightweightPipeline/LWRP/LightweightPipeline.cs

                 if (shadows && m_ShadowSettings.screenSpace)
                     ShadowCollectPass(visibleLights, ref context, ref lightData, frameRenderingConfiguration);
 
-                if (!shadows)
-                {
-                    var setRT = CommandBufferPool.Get("Generate Small Shadow Buffer");
-                    if (m_ShadowSettings.screenSpace)
-                        setRT.GetTemporaryRT(m_ScreenSpaceShadowMapRTID, 4, 4, 0, FilterMode.Bilinear, m_ShadowSettings.screenspaceShadowmapTextureFormat);
-                    else
-                        setRT.GetTemporaryRT(m_ShadowMapRTID, 4, 4, 0, FilterMode.Bilinear, m_ShadowSettings.shadowmapTextureFormat);
-                    setRT.Blit(Texture2D.whiteTexture, m_ScreenSpaceShadowMapRT);
-                    context.ExecuteCommandBuffer(setRT);
-                }
-
                 ForwardPass(visibleLights, frameRenderingConfiguration, ref context, ref lightData, stereoEnabled);
 
 

ScriptableRenderPipeline/LightweightPipeline/LWRP/ShaderLibrary/Core.hlsl

 #endif
 #endif
 
+#ifndef BUMP_SCALE_NOT_SUPPORTED
+#define BUMP_SCALE_NOT_SUPPORTED !SHADER_HINT_NICE_QUALITY
+#endif
+
 ///////////////////////////////////////////////////////////////////////////////
 #ifdef _NORMALMAP
     #define OUTPUT_NORMAL(IN, OUT) OutputTangentToWorld(IN.tangent, IN.normal, OUT.tangent.xyz, OUT.binormal.xyz, OUT.normal.xyz)
 
 void OutputTangentToWorld(half4 vertexTangent, half3 vertexNormal, out half3 tangentWS, out half3 binormalWS, out half3 normalWS)
 {
+    // mikkts space compliant. only normalize when extracting normal at frag.
-    tangentWS = normalize(mul((half3x3)UNITY_MATRIX_M, vertexTangent.xyz));
+    tangentWS = TransformObjectToWorldDir(vertexTangent.xyz);
     binormalWS = cross(normalWS, tangentWS) * sign;
 }
 

ScriptableRenderPipeline/LightweightPipeline/LWRP/ShaderLibrary/InputBuiltin.hlsl

 
 float4x4 unity_ObjectToWorld;
 float4x4 unity_WorldToObject;
-float4 unity_LODFade; // x is the fade value ranging within [0,1]. y is x quantized into 16 levels
+real4 unity_LODFade; // x is the fade value ranging within [0,1]. y is x quantized into 16 levels
-float4 unity_DynamicLightmapST;
-float4 unity_SHAr;
-float4 unity_SHAg;
-float4 unity_SHAb;
-float4 unity_SHBr;
-float4 unity_SHBg;
-float4 unity_SHBb;
-float4 unity_SHC;
-
-// x = Disabled(0)/Enabled(1)
-// y = Computation are done in global space(0) or local space(1)
-// z = Texel size on U texture coordinate
-float4 unity_ProbeVolumeParams;
-float4x4 unity_ProbeVolumeWorldToObject;
-float3 unity_ProbeVolumeSizeInv;
-float3 unity_ProbeVolumeMin;
+real4 unity_SHAr;
+real4 unity_SHAg;
+real4 unity_SHAb;
+real4 unity_SHBr;
+real4 unity_SHBg;
+real4 unity_SHBb;
+real4 unity_SHC;
-float4 unity_ProbesOcclusion;
+real4 unity_ProbesOcclusion;
-half4 unity_SpecCube0_HDR;
+real4 unity_SpecCube0_HDR;
-half4 unity_Lightmap_HDR;
+real4 unity_Lightmap_HDR;
-half4 unity_LightIndicesOffsetAndCount;
-half4 unity_4LightIndices0;
-half4 unity_4LightIndices1;
+real4 unity_LightIndicesOffsetAndCount;
+real4 unity_4LightIndices0;
+real4 unity_4LightIndices1;
 
 CBUFFER_END
 
 
 #if defined(USING_STEREO_MATRICES) && defined(UNITY_STEREO_MULTIVIEW_ENABLED)
 CBUFFER_START(UnityStereoEyeIndices)
-float4 unity_StereoEyeIndices[2];
+real4 unity_StereoEyeIndices[2];
 CBUFFER_END
 #endif
 
 // ----------------------------------------------------------------------------
 
 CBUFFER_START(UnityPerFrame)
-float4 glstate_lightmodel_ambient;
-float4 unity_AmbientSky;
-float4 unity_AmbientEquator;
-float4 unity_AmbientGround;
-float4 unity_IndirectSpecColor;
+real4 glstate_lightmodel_ambient;
+real4 unity_AmbientSky;
+real4 unity_AmbientEquator;
+real4 unity_AmbientGround;
+real4 unity_IndirectSpecColor;
-half4  unity_FogColor;
+real4  unity_FogColor;
 
 #if !defined(USING_STEREO_MATRICES)
 float4x4 glstate_matrix_projection;
 int unity_StereoEyeIndex;
 #endif
 
-float4 unity_ShadowColor;
+real4 unity_ShadowColor;
 CBUFFER_END
 
 // ----------------------------------------------------------------------------

ScriptableRenderPipeline/LightweightPipeline/LWRP/ShaderLibrary/InputSurface.hlsl

 #endif
 
 CBUFFER_START(UnityPerMaterial)
-half4 _MainTex_ST;
+float4 _MainTex_ST;
+half4 _SpecColor;
+half4 _EmissionColor;
-half _SmoothnessTextureChannel;
-half4 _SpecColor;
-half4 _EmissionColor;
-TEXTURE2D(_MainTex); SAMPLER(sampler_MainTex);
-TEXTURE2D(_MetallicGlossMap); SAMPLER(sampler_MetallicGlossMap);
-TEXTURE2D(_SpecGlossMap); SAMPLER(sampler_SpecGlossMap);
-TEXTURE2D(_BumpMap); SAMPLER(sampler_BumpMap);
-TEXTURE2D(_OcclusionMap); SAMPLER(sampler_OcclusionMap);
-TEXTURE2D(_EmissionMap); SAMPLER(sampler_EmissionMap);
+TEXTURE2D(_MainTex);            SAMPLER(sampler_MainTex);
+TEXTURE2D(_MetallicGlossMap);   SAMPLER(sampler_MetallicGlossMap);
+TEXTURE2D(_SpecGlossMap);       SAMPLER(sampler_SpecGlossMap);
+TEXTURE2D(_BumpMap);            SAMPLER(sampler_BumpMap);
+TEXTURE2D(_OcclusionMap);       SAMPLER(sampler_OcclusionMap);
+TEXTURE2D(_EmissionMap);        SAMPLER(sampler_EmissionMap);
 
 // Must match Lightweigth ShaderGraph master node
 struct SurfaceData

ScriptableRenderPipeline/LightweightPipeline/LWRP/ShaderLibrary/Lighting.hlsl

     half roughness;
     half roughness2;
     half grazingTerm;
+
+    // We save some light invariant BRDF terms so we don't have to recompute
+    // them in the light loop. Take a look at DirectBRDF function for detailed explaination.
+    half normalizationTerm;     // roughness * 4.0 + 2.0
+    half roughness2MinusOne;    // roughness² - 1.0
 };
 
 half ReflectivitySpecular(half3 specular)
     outBRDFData.roughness = PerceptualRoughnessToRoughness(outBRDFData.perceptualRoughness);
     outBRDFData.roughness2 = outBRDFData.roughness * outBRDFData.roughness;
 
+    outBRDFData.normalizationTerm = outBRDFData.roughness * 4.0h + 2.0h;
+    outBRDFData.roughness2MinusOne = outBRDFData.roughness2 - 1.0h;
+
 #ifdef _ALPHAPREMULTIPLY_ON
     outBRDFData.diffuse *= alpha;
     alpha = alpha * oneMinusReflectivity + reflectivity;
     half LoH = saturate(dot(lightDirectionWS, halfDir));
 
     // GGX Distribution multiplied by combined approximation of Visibility and Fresnel
+    // BRDFspec = (D * V * F) / 4.0
+    // D = roughness² / ( NoH² * (roughness² - 1) + 1 )²
+    // V * F = 1.0 / ( LoH² * (roughness + 0.5) )
-    half d = NoH * NoH * (brdfData.roughness2 - 1.h) + 1.00001h;
+
+    // Final BRDFspec = roughness² / ( NoH² * (roughness² - 1) + 1 )² * (LoH² * (roughness + 0.5) * 4.0)
+    // We further optimize a few light invariant terms
+    // brdfData.normalizationTerm = (roughness + 0.5) * 4.0 rewritten as roughness * 4.0 + 2.0 to a fit a MAD.
+    half d = NoH * NoH * brdfData.roughness2MinusOne + 1.00001h;
-    half specularTerm = brdfData.roughness2 / ((d * d) * max(0.1h, LoH2) * (brdfData.roughness + 0.5h) * 4);
+    half specularTerm = brdfData.roughness2 / ((d * d) * max(0.1h, LoH2) * brdfData.normalizationTerm);
 
     // on mobiles (where half actually means something) denominator have risk of overflow
     // clamp below was added specifically to "fix" that, but dx compiler (we convert bytecode to metal/gles)

ScriptableRenderPipeline/LightweightPipeline/LWRP/ShaderLibrary/LightweightPassLit.hlsl

 
     half4 fogFactorAndVertexLight   : TEXCOORD6; // x: fogFactor, yzw: vertex light
 
+#ifdef _SHADOWS_ENABLED
+#endif
 
     float4 clipPos                  : SV_POSITION;
     UNITY_VERTEX_INPUT_INSTANCE_ID
 #endif
 
     inputData.viewDirectionWS = FragmentViewDirWS(viewDir);
+#ifdef _SHADOWS_ENABLED
+#else
+    inputData.shadowCoord = float4(0, 0, 0, 0);
+#endif
     inputData.fogCoord = IN.fogFactorAndVertexLight.x;
     inputData.vertexLighting = IN.fogFactorAndVertexLight.yzw;
     inputData.bakedGI = SAMPLE_GI(IN.lightmapUV, IN.vertexSH, inputData.normalWS);
 //                  Vertex and Fragment functions                            //
 ///////////////////////////////////////////////////////////////////////////////
 
-// Vertex: Used for Standard and StandardSimpleLighting shaders
+// Used in Standard (Physically Based) shader
 LightweightVertexOutput LitPassVertex(LightweightVertexInput v)
 {
     LightweightVertexOutput o = (LightweightVertexOutput)0;
     o.uv = TransformMainTextureCoord(v.texcoord);
 
     o.posWSShininess.xyz = TransformObjectToWorld(v.vertex.xyz);
-    o.posWSShininess.w = _Shininess * 128.0;
     o.clipPos = TransformWorldToHClip(o.posWSShininess.xyz);
 
     half3 viewDir = VertexViewDirWS(GetCameraPositionWS() - o.posWSShininess.xyz);
     half fogFactor = ComputeFogFactor(o.clipPos.z);
     o.fogFactorAndVertexLight = half4(fogFactor, vertexLight);
 
+#ifdef _SHADOWS_ENABLED
+#endif
-// Used for Standard shader
+// Used in Standard (Physically Based) shader
 half4 LitPassFragment(LightweightVertexOutput IN) : SV_Target
 {
     UNITY_SETUP_INSTANCE_ID(IN);
 
     ApplyFog(color.rgb, inputData.fogCoord);
     return color;
+}
+
+// Used in Standard (Simple Lighting) shader
+// TODO: we only need to specialise this because of _Shininess prop
+// Once we refactor SimpleLighting shader we will be able to share vertex
+// between PBS and Simple
+LightweightVertexOutput LitPassVertexSimple(LightweightVertexInput v)
+{
+    LightweightVertexOutput o = (LightweightVertexOutput)0;
+
+    UNITY_SETUP_INSTANCE_ID(v);
+    UNITY_TRANSFER_INSTANCE_ID(v, o);
+    UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o);
+
+    o.uv = TransformMainTextureCoord(v.texcoord);
+
+    o.posWSShininess.xyz = TransformObjectToWorld(v.vertex.xyz);
+    o.posWSShininess.w = _Shininess * 128.0;
+    o.clipPos = TransformWorldToHClip(o.posWSShininess.xyz);
+
+    half3 viewDir = VertexViewDirWS(GetCameraPositionWS() - o.posWSShininess.xyz);
+
+#ifdef _NORMALMAP
+    o.normal.w = viewDir.x;
+    o.tangent.w = viewDir.y;
+    o.binormal.w = viewDir.z;
+#else
+    o.viewDir = viewDir;
+#endif
+
+    // initializes o.normal and if _NORMALMAP also o.tangent and o.binormal
+    OUTPUT_NORMAL(v, o);
+
+    // We either sample GI from lightmap or SH.
+    // Lightmap UV and vertex SH coefficients use the same interpolator ("float2 lightmapUV" for lightmap or "half3 vertexSH" for SH)
+    // see DECLARE_LIGHTMAP_OR_SH macro.
+    // The following funcions initialize the correct variable with correct data
+    OUTPUT_LIGHTMAP_UV(v.lightmapUV, unity_LightmapST, o.lightmapUV);
+    OUTPUT_SH(o.normal.xyz, o.vertexSH);
+
+    half3 vertexLight = VertexLighting(o.posWSShininess.xyz, o.normal.xyz);
+    half fogFactor = ComputeFogFactor(o.clipPos.z);
+    o.fogFactorAndVertexLight = half4(fogFactor, vertexLight);
+
+#ifdef _SHADOWS_ENABLED
+#if SHADOWS_SCREEN
+    o.shadowCoord = ComputeShadowCoord(o.clipPos);
+#else
+    o.shadowCoord = TransformWorldToShadowCoord(o.posWSShininess.xyz);
+#endif
+#endif
+
+    return o;
 }
 
 // Used for StandardSimpleLighting shader

ScriptableRenderPipeline/LightweightPipeline/LWRP/ShaderLibrary/LightweightPassMeta.hlsl

     float2 uv       : TEXCOORD0;
 };
 
-float4 MetaVertexPosition(float4 vertex, float2 uv1, float2 uv2, float4 lightmapST, float4 dynlightmapST)
+float4 MetaVertexPosition(float4 vertex, float2 uv1, float2 uv2, float4 lightmapST)
 {
     if (unity_MetaVertexControl.x)
     {
-        vertex.z = vertex.z > 0 ? 1.0e-4f : 0.0f;
-    }
-    if (unity_MetaVertexControl.y)
-    {
-        vertex.xy = uv2 * dynlightmapST.xy + dynlightmapST.zw;
-        // OpenGL right now needs to actually use incoming vertex position,
-        // so use it in a very dummy way
-        vertex.z = vertex.z > 0 ? 1.0e-4f : 0.0f;
+        vertex.z = vertex.z > 0 ? REAL_MIN : 0.0f;
     }
     return TransformWorldToHClip(vertex.xyz); // Need to transfer from world to clip compared to legacy
 }
 MetaVertexOuput LightweightVertexMeta(MetaVertexInput v)
 {
     MetaVertexOuput o;
-    o.pos = MetaVertexPosition(v.vertex, v.uv1.xy, v.uv2.xy, unity_LightmapST, unity_DynamicLightmapST);
-    o.uv = TRANSFORM_TEX(v.uv0, _MainTex);
+    o.pos = MetaVertexPosition(v.vertex, v.uv1.xy, v.uv2.xy, unity_LightmapST);
+    o.uv = TransformMainTextureCoord(v.uv0);
     return o;
 }
 

ScriptableRenderPipeline/LightweightPipeline/LWRP/ShaderLibrary/Shadows.hlsl

 
 half RealtimeShadowAttenuation(float4 shadowCoord)
 {
-#if NO_SHADOWS
+#ifndef _SHADOWS_ENABLED
+    return 1.0h;
+#endif
+
+#if defined(NO_SHADOWS)
     return 1.0h;
 #elif SHADOWS_SCREEN
     return SampleScreenSpaceShadowMap(shadowCoord);

ScriptableRenderPipeline/LightweightPipeline/LWRP/Shaders/LightweightStandard.shader

             #pragma multi_compile _ _ADDITIONAL_LIGHTS
             #pragma multi_compile _ _VERTEX_LIGHTS
             #pragma multi_compile _ _MIXED_LIGHTING_SUBTRACTIVE
-            #pragma multi_compile_fog
+            #pragma multi_compile _ _SHADOWS_ENABLED
+            #pragma multi_compile_fog
 
             //--------------------------------------
             // GPU Instancing

ScriptableRenderPipeline/LightweightPipeline/LWRP/Shaders/LightweightStandardSimpleLighting.shader

             #pragma multi_compile _ _ADDITIONAL_LIGHTS
             #pragma multi_compile _ _VERTEX_LIGHTS
             #pragma multi_compile _ _MIXED_LIGHTING_SUBTRACTIVE
-            #pragma multi_compile_fog
+            #pragma multi_compile _ _SHADOWS_ENABLED
+            #pragma multi_compile_fog
-            #pragma vertex LitPassVertex
+            #pragma vertex LitPassVertexSimple
             #pragma fragment LitPassFragmentSimple
             #define BUMP_SCALE_NOT_SUPPORTED 1
             #include "LWRP/ShaderLibrary/LightweightPassLit.hlsl"

ScriptableRenderPipeline/LightweightPipeline/LWRP/Shaders/LightweightStandardTerrain.shader

             #pragma multi_compile _ _ADDITIONAL_LIGHTS
             #pragma multi_compile _ _VERTEX_LIGHTS
             #pragma multi_compile _ _MIXED_LIGHTING_SUBTRACTIVE
-            #pragma multi_compile_fog
+            #pragma multi_compile _ _SHADOWS_ENABLED
+            #pragma multi_compile_fog
 
             #pragma multi_compile __ _TERRAIN_NORMAL_MAP