Merge pull request #559 from Unity-Technologies/Unity-2017.3

Unity 2017 3

SampleScenes/HDTest/GraphicTest/Common/CustomTexture/DistortionMap.shader

-Shader "Hidden/HDRenderPipeline/Test/DistortionMap"{
+Shader "Hidden/HDRenderPipeline/Test/DistortionMap"{
     Properties
     {
         _Size("Size", Float) = 1
                 float2 distortion = s.xy * _DistortionAmplitude;
                 float blur = s.z;
 
-                return float4(distortion, blur, 1.0);
+                return float4(distortion * 0.5 + 0.5, blur, 1.0);
             }
             ENDCG
         }
                 
                 float blur = (min(t, 1-t) * 2);
 
-                return float4(distortion, blur, 1.0);
+                return float4(distortion * 0.5 + 0.5, blur, 1.0);
             }
             ENDCG
         }
 
                 float blur = v;
 
-                return float4(distortion, blur, 1.0);
+                return float4(distortion * 0.5 + 0.5, blur, 1.0);
-}
+}

ScriptableRenderPipeline/HDRenderPipeline/Editor/HDRenderPipelineMenuItems.cs

                                 else
                                 {
                                     mat.SetInt("_SubsurfaceProfile" + x, ivalue + 1);
-                                } 
-                                mat.SetInt("_SubsurfaceProfile" + x, ivalue + 1);
+                                }
                             }
                             EditorUtility.SetDirty(mat);
                         }

ScriptableRenderPipeline/HDRenderPipeline/HDRenderPipeline.cs

                 return;
             }
 
+            // The first thing to do is to go through all lights on the CPU side and prepare light for GPU.
+            // This allow us to deal with the flexibility of shadow mask that will do a GBuffer allocation on demand (in case of deferred rendering)
+            m_LightLoop.PrepareLightsForGPU(m_ShadowSettings, m_CullResults, camera);
+
             InitAndClearBuffer(hdCamera, cmd);
 
             RenderDepthPrepass(m_CullResults, camera, renderContext, cmd);
                         }
                     }
 
-                    m_LightLoop.PrepareLightsForGPU(m_ShadowSettings, m_CullResults, camera);
                     m_LightLoop.RenderShadows(renderContext, cmd, m_CullResults);
 
                     cmd.GetTemporaryRT(m_DeferredShadowBuffer, camera.pixelWidth, camera.pixelHeight, 0, FilterMode.Point, RenderTextureFormat.ARGB32, RenderTextureReadWrite.Linear, 1 , true);
                                          bool                    preRefractionQueue = false)
         {
             m_SinglePassName[0] = passName;
-            RenderTransparentRenderList(cull, camera, renderContext, cmd, m_SinglePassName, 
+            RenderTransparentRenderList(cull, camera, renderContext, cmd, m_SinglePassName,
                 rendererConfiguration, stateBlock, overrideMaterial, preRefractionQueue);
         }
 
 
             var filterSettings = new FilterRenderersSettings(true)
             {
-                renderQueueRange = preRefractionQueue 
-                    ? k_RenderQueue_PreRefraction 
+                renderQueueRange = preRefractionQueue
+                    ? k_RenderQueue_PreRefraction
                     : k_RenderQueue_Transparent
             };
 
                 }
                 else
                 {
-                    RenderTransparentRenderList(cullResults, camera, renderContext, cmd, m_ForwardErrorPassNames, 0, 
+                    RenderTransparentRenderList(cullResults, camera, renderContext, cmd, m_ForwardErrorPassNames, 0,
                         null, m_ErrorMaterial, pass == ForwardPass.PreRefraction);
                 }
             }

ScriptableRenderPipeline/HDRenderPipeline/Material/LayeredLit/LayeredLit.shader

             #define SHADERPASS SHADERPASS_LIGHT_TRANSPORT
             #include "../../ShaderVariables.hlsl"
             #include "../../Material/Material.hlsl"
-            #include "../Lit/ShaderPass/LitMetaPass.hlsl"
+            #include "../Lit/ShaderPass/LitSharePass.hlsl"
             #include "LayeredLitData.hlsl"
             #include "../../ShaderPass/ShaderPassLightTransport.hlsl"
 

ScriptableRenderPipeline/HDRenderPipeline/Material/LayeredLit/LayeredLitTessellation.shader

             #define SHADERPASS SHADERPASS_LIGHT_TRANSPORT
             #include "../../ShaderVariables.hlsl"
             #include "../../Material/Material.hlsl"
-            #include "../Lit/ShaderPass/LitMetaPass.hlsl"
+            #include "../Lit/ShaderPass/LitSharePass.hlsl"
             #include "LayeredLitData.hlsl"
             #include "../../ShaderPass/ShaderPassLightTransport.hlsl"
 

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/Lit.shader

             #define SHADERPASS SHADERPASS_LIGHT_TRANSPORT
             #include "../../ShaderVariables.hlsl"
             #include "../../Material/Material.hlsl"
-            #include "ShaderPass/LitMetaPass.hlsl"
+            #include "ShaderPass/LitSharePass.hlsl"
             #include "LitData.hlsl"
             #include "../../ShaderPass/ShaderPassLightTransport.hlsl"
 

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/LitData.hlsl

     builtinData.velocity = float2(0.0, 0.0);
 
 #if (SHADERPASS == SHADERPASS_DISTORTION) || defined(DEBUG_DISPLAY)
-    float3 distortion = SAMPLE_TEXTURE2D(_DistortionVectorMap, sampler_DistortionVectorMap, input.texCoord0).rgb;
+    float3 distortion = SAMPLE_TEXTURE2D(_DistortionVectorMap, sampler_DistortionVectorMap, input.texCoord0).rgb * 2.0 - 1.0;
     builtinData.distortion = distortion.rg * _DistortionScale;
     builtinData.distortionBlur = clamp(distortion.b * _DistortionBlurScale, 0.0, 1.0) * (_DistortionBlurRemapMax - _DistortionBlurRemapMin) + _DistortionBlurRemapMin;
 #else

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/LitTessellation.shader

             #define SHADERPASS SHADERPASS_LIGHT_TRANSPORT
             #include "../../ShaderVariables.hlsl"
             #include "../../Material/Material.hlsl"
-            #include "ShaderPass/LitMetaPass.hlsl"
+            #include "ShaderPass/LitSharePass.hlsl"
             #include "LitData.hlsl"
             #include "../../ShaderPass/ShaderPassLightTransport.hlsl"
 

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/Resources/SubsurfaceScattering.compute

     }
 }
 
-// Computes the value of the integrand over a disk: (2 * PI * r) * KernelVal().
-// N.b.: the returned value is multiplied by 4. It is irrelevant due to weight renormalization.
-float3 KernelValCircle(float r, float3 S)
+// Computes the value of the integrand in polar coordinates: f(r, s) = r * R(r, s).
+// f(r, s) = (Exp[-r * s] + Exp[-r * s / 3]) * (s / (8 * Pi))
+// We can drop the constant (s / (8 * Pi)) due to the subsequent weight renormalization.
+float3 DisneyProfilePolar(float r, float3 S)
-    return /* 0.25 * */ S * (expOneThird + expOneThird * expOneThird * expOneThird);
+    return expOneThird + expOneThird * expOneThird * expOneThird;
-// Computes F(r)/P(r), s.t. r = sqrt(xy^2 + z^2).
+// Computes f(r, s)/p(r, s), s.t. r = sqrt(xy^2 + z^2).
 // Rescaling of the PDF is handled by 'totalWeight'.
 float3 ComputeBilateralWeight(float xy2, float z, float mmPerUnit, float3 S, float rcpPdf)
 {
 #endif
 
 #if SSS_CLAMP_ARTIFACT
-    return saturate(KernelValCircle(r, S) * rcpPdf);
+    return saturate(DisneyProfilePolar(r, S) * rcpPdf);
-    return KernelValCircle(r, S) * rcpPdf;
+    return DisneyProfilePolar(r, S) * rcpPdf;
 #endif
 }
 
 
     float  centerRadius = _FilterKernels[profileID][0][iR];
     float  centerRcpPdf = _FilterKernels[profileID][0][iP];
-    float3 centerWeight = KernelValCircle(centerRadius, shapeParam) * centerRcpPdf;
+    float3 centerWeight = DisneyProfilePolar(centerRadius, shapeParam) * centerRcpPdf;
 
     // Accumulate filtered irradiance and bilateral weights (for renormalization).
     float3 totalIrradiance = centerWeight * centerIrradiance;

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/ShaderPass/LitSharePass.hlsl

 #define ATTRIBUTES_NEED_TEXCOORD1
 #define ATTRIBUTES_NEED_COLOR
 
-#if defined(_REQUIRE_UV2) || defined(_REQUIRE_UV3) || defined(DYNAMICLIGHTMAP_ON) || defined(DEBUG_DISPLAY)
+#if defined(_REQUIRE_UV2) || defined(_REQUIRE_UV3) || defined(DYNAMICLIGHTMAP_ON) || defined(DEBUG_DISPLAY) || (SHADERPASS == SHADERPASS_LIGHT_TRANSPORT)
 #define ATTRIBUTES_NEED_TEXCOORD2
 #endif
 #if defined(_REQUIRE_UV3) || defined(DEBUG_DISPLAY)

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/SubsurfaceScatteringSettings.cs

             // We importance sample the color channel with the widest scattering distance.
             float s = Mathf.Min(shapeParam.x, shapeParam.y, shapeParam.z);
 
-            // Importance sample the normalized diffusion profile for the computed value of 's'.
+            // Importance sample the normalized diffuse reflectance profile for the computed value of 's'.
-            // R(r, s)   = s * (Exp[-r * s] + Exp[-r * s / 3]) / (8 * Pi * r)
-            // PDF(r, s) = s * (Exp[-r * s] + Exp[-r * s / 3]) / 4
-            // CDF(r, s) = 1 - 1/4 * Exp[-r * s] - 3/4 * Exp[-r * s / 3]
+            // R[r, phi, s]   = s * (Exp[-r * s] + Exp[-r * s / 3]) / (8 * Pi * r)
+            // PDF[r, phi, s] = r * R[r, phi, s]
+            // CDF[r, s]      = 1 - 1/4 * Exp[-r * s] - 3/4 * Exp[-r * s / 3]
             // ------------------------------------------------------------------------------------
 
             // Importance sample the near field kernel.
-                float r = KernelCdfInverse(p, s);
+                float r = DisneyProfileCdfInverse(p, s);
-                filterKernelNearField[i].y = 1f / KernelPdf(r, s);
+                filterKernelNearField[i].y = 1f / DisneyProfilePdf(r, s);
             }
 
             // Importance sample the far field kernel.
-                float r = KernelCdfInverse(p, s);
+                float r = DisneyProfileCdfInverse(p, s);
-                filterKernelFarField[i].y = 1f / KernelPdf(r, s);
+                filterKernelFarField[i].y = 1f / DisneyProfilePdf(r, s);
             }
 
             maxRadius = filterKernelFarField[SssConstants.SSS_N_SAMPLES_FAR_FIELD - 1].x;
         }
         // <<< Old SSS Model
 
-        static float KernelVal(float r, float s)
+        static float DisneyProfile(float r, float s)
-        // Computes the value of the integrand over a disk: (2 * PI * r) * KernelVal().
-        static float KernelValCircle(float r, float s)
+        static float DisneyProfilePdf(float r, float s)
-            return 0.25f * s * (Mathf.Exp(-r * s) + Mathf.Exp(-r * s * (1.0f / 3.0f)));
+            return r * DisneyProfile(r, s);
-        static float KernelPdf(float r, float s)
-        {
-            return KernelValCircle(r, s);
-        }
-
-        static float KernelCdf(float r, float s)
+        static float DisneyProfileCdf(float r, float s)
-        static float KernelCdfDerivative1(float r, float s)
+        static float DisneyProfileCdfDerivative1(float r, float s)
-        static float KernelCdfDerivative2(float r, float s)
+        static float DisneyProfileCdfDerivative2(float r, float s)
         {
             return (-1.0f / 12.0f) * s * s * Mathf.Exp(-r * s) * (3.0f + Mathf.Exp(r * s * (2.0f / 3.0f)));
         }
-        static float KernelCdfInverse(float p, float s)
+        static float DisneyProfileCdfInverse(float p, float s)
         {
             // Supply the initial guess.
             float r = (Mathf.Pow(10f, p) - 1f) / s;
             {
-                float f0 = KernelCdf(r, s) - p;
-                float f1 = KernelCdfDerivative1(r, s);
-                float f2 = KernelCdfDerivative2(r, s);
+                float f0 = DisneyProfileCdf(r, s) - p;
+                float f1 = DisneyProfileCdfDerivative1(r, s);
+                float f2 = DisneyProfileCdfDerivative2(r, s);
                 float dr = f0 / (f1 * (1f - f0 * f2 / (2f * f1 * f1)));
 
                 if (Mathf.Abs(dr) < t)

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/SubsurfaceScatteringSettings.cs.hlsl

 // UnityEngine.Experimental.Rendering.HDPipeline.SssConstants:  static fields
 //
 #define SSS_N_PROFILES (16)
-#define SSS_NEUTRAL_PROFILE_ID (15)
+#define SSS_NEUTRAL_PROFILE_ID (0)
 #define SSS_N_SAMPLES_NEAR_FIELD (55)
 #define SSS_N_SAMPLES_FAR_FIELD (21)
 #define SSS_LOD_THRESHOLD (4)

ScriptableRenderPipeline/HDRenderPipeline/Material/Unlit/Editor/BaseUnlitUI.cs

         // Since we don't have those parameters in our shaders we need to provide a "fake" useless version of them with the right values for the GI to work.
         protected static void SetupMainTexForAlphaTestGI(string colorMapPropertyName, string colorPropertyName, Material material)
         {
-            if(material.HasProperty(colorMapPropertyName))
+            if (material.HasProperty(colorMapPropertyName))
-            if(material.HasProperty(colorPropertyName))
+            if (material.HasProperty(colorPropertyName))
-            if(material.HasProperty("_AlphaCutoff")) // Same for all our materials
+            if (material.HasProperty("_AlphaCutoff")) // Same for all our materials
             {
                 var cutoff = material.GetFloat("_AlphaCutoff");
                 material.SetFloat("_Cutoff", cutoff);

ScriptableRenderPipeline/HDRenderPipeline/Material/Unlit/ShaderPass/UnlitSharePass.hlsl

 
 #define ATTRIBUTES_NEED_TEXCOORD0
 
+#if defined(DEBUG_DISPLAY) || (SHADERPASS == SHADERPASS_LIGHT_TRANSPORT)
+// For the meta pass with emissive we require UV1 and/or UV2
+#define ATTRIBUTES_NEED_TEXCOORD1
+#define ATTRIBUTES_NEED_TEXCOORD2
+#endif
+
 #if defined(_ENABLE_FOG_ON_TRANSPARENT)
 #define VARYINGS_NEED_POSITION_WS
 #endif

ScriptableRenderPipeline/HDRenderPipeline/Material/Unlit/Unlit.shader

 
             #define SHADERPASS SHADERPASS_LIGHT_TRANSPORT
             #include "../../Material/Material.hlsl"
-            #include "ShaderPass/UnlitMetaPass.hlsl"
+            #include "ShaderPass/UnlitSharePass.hlsl"
             #include "UnlitData.hlsl"
             #include "../../ShaderPass/ShaderPassLightTransport.hlsl"
 

ScriptableRenderPipeline/HDRenderPipeline/Material/Unlit/UnlitData.hlsl

     builtinData.velocity = float2(0.0, 0.0);
 
 #if (SHADERPASS == SHADERPASS_DISTORTION) || defined(DEBUG_DISPLAY)
-    float3 distortion = SAMPLE_TEXTURE2D(_DistortionVectorMap, sampler_DistortionVectorMap, input.texCoord0).rgb;
+    float3 distortion = SAMPLE_TEXTURE2D(_DistortionVectorMap, sampler_DistortionVectorMap, input.texCoord0).rgb * 2.0 - 1.0;
     builtinData.distortion = distortion.rg * _DistortionScale;
     builtinData.distortionBlur = clamp(distortion.b * _DistortionBlurScale, 0.0, 1.0) * (_DistortionBlurRemapMax - _DistortionBlurRemapMin) + _DistortionBlurRemapMin;
 #else

ScriptableRenderPipeline/HDRenderPipeline/ShaderPass/ShaderPassLightTransport.hlsl

     // OpenGL right now needs to actually use the incoming vertex position
     // so we create a fake dependency on it here that haven't any impact.
     output.vmesh.positionCS = float4(uv * 2.0 - 1.0, inputMesh.positionOS.z > 0 ? 1.0e-4 : 0.0, 1.0);
-    output.vmesh.texCoord0  = inputMesh.uv0;
-    output.vmesh.texCoord1  = inputMesh.uv1;
-    output.vmesh.texCoord2  = inputMesh.uv2;
-    output.vmesh.texCoord3  = inputMesh.uv3;
+#ifdef VARYINGS_NEED_POSITION_WS
+#endif
-#if defined(VARYINGS_NEED_COLOR)
+#ifdef VARYINGS_NEED_TEXCOORD0
+    output.vmesh.texCoord0 = inputMesh.uv0;
+#endif
+#ifdef VARYINGS_NEED_TEXCOORD1
+    output.vmesh.texCoord1 = inputMesh.uv1;
+#endif
+#ifdef VARYINGS_NEED_TEXCOORD2
+    output.vmesh.texCoord2 = inputMesh.uv2;
+#endif
+#ifdef VARYINGS_NEED_TEXCOORD3
+    output.vmesh.texCoord3 = inputMesh.uv3;
+#endif
+#ifdef VARYINGS_NEED_COLOR
     output.vmesh.color = inputMesh.color;
 #endif
 

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/ShaderPass/LitMetaPass.hlsl.meta

-fileFormatVersion: 2
-guid: a55741149134f0a4280500a1842a7460
-timeCreated: 1478601047
-licenseType: Pro
-ShaderImporter:
-  defaultTextures: []
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/ShaderPass/LitMetaPass.hlsl

-#ifndef SHADERPASS
-#error Undefine_SHADERPASS
-#endif
-
-#define ATTRIBUTES_NEED_TEXCOORD0
-#define ATTRIBUTES_NEED_TEXCOORD1
-#define ATTRIBUTES_NEED_TEXCOORD2
-#define ATTRIBUTES_NEED_TEXCOORD3
-
-#ifdef _VERTEX_WIND
-#define ATTRIBUTES_NEED_COLOR
-#define ATTRIBUTES_NEED_NORMAL
-#endif
-
-#define REQUIRE_VERTEX_COLOR defined(LAYERED_LIT_SHADER) && (defined(_LAYER_MASK_VERTEX_COLOR_MUL) || defined(_LAYER_MASK_VERTEX_COLOR_ADD))
-
-#if REQUIRE_VERTEX_COLOR
-#define ATTRIBUTES_NEED_COLOR
-#endif
-
-#define VARYINGS_NEED_TEXCOORD0
-#define VARYINGS_NEED_TEXCOORD1
-#define VARYINGS_NEED_TEXCOORD2
-#define VARYINGS_NEED_TEXCOORD3
-
-#define VARYINGS_NEED_POSITION_WS
-
-#if REQUIRE_VERTEX_COLOR
-#define VARYINGS_NEED_COLOR
-#endif
-
-// This include will define the various Attributes/Varyings structure
-#include "../../ShaderPass/VaryingMesh.hlsl"

ScriptableRenderPipeline/HDRenderPipeline/Material/Unlit/ShaderPass/UnlitMetaPass.hlsl.meta

-fileFormatVersion: 2
-guid: 34b6e92ecac8a054085e28dc783b1a80
-timeCreated: 1484323639
-licenseType: Pro
-ShaderImporter:
-  defaultTextures: []
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

ScriptableRenderPipeline/HDRenderPipeline/Material/Unlit/ShaderPass/UnlitMetaPass.hlsl

-#ifndef SHADERPASS
-#error Undefine_SHADERPASS
-#endif
-
-#define ATTRIBUTES_NEED_TEXCOORD0
-#define ATTRIBUTES_NEED_TEXCOORD1
-#define ATTRIBUTES_NEED_TEXCOORD2
-#define ATTRIBUTES_NEED_TEXCOORD3
-
-#define VARYINGS_NEED_TEXCOORD0
-#define VARYINGS_NEED_TEXCOORD1
-#define VARYINGS_NEED_TEXCOORD2
-#define VARYINGS_NEED_TEXCOORD3
-
-#define VARYINGS_NEED_POSITION_WS
-
-// This include will define the various Attributes/Varyings structure
-#include "../../ShaderPass/VaryingMesh.hlsl"