Merge branch 'master' into metal

Assets/ScriptableRenderPipeline/HDRenderPipeline/HDRenderPipeline.cs

             m_FilterSubsurfaceScattering.SetFloat("_DstBlend", (float)BlendMode.Zero);
 
             m_FilterAndCombineSubsurfaceScattering = Utilities.CreateEngineMaterial("Hidden/HDRenderPipeline/CombineSubsurfaceScattering");
-            m_FilterSubsurfaceScattering.EnableKeyword("FILTER_HORIZONTAL_AND_COMBINE");
+            m_FilterAndCombineSubsurfaceScattering.EnableKeyword("FILTER_HORIZONTAL_AND_COMBINE");
             m_FilterAndCombineSubsurfaceScattering.SetFloat("_DstBlend", (float)BlendMode.One);
 
             InitializeDebugMaterials();

Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting/TilePass/Resources/shadeopaque.compute

 #pragma kernel ShadeOpaque_Clustered		            SHADE_OPAQUE_ENTRY=ShadeOpaque_Clustered		        USE_CLUSTERED_LIGHTLIST
 #pragma kernel ShadeOpaque_Clustered_DebugLighting		SHADE_OPAQUE_ENTRY=ShadeOpaque_Clustered_DebugLighting	USE_CLUSTERED_LIGHTLIST   LIGHTING_DEBUG
 
+#pragma #pragma enable_d3d11_debug_symbols
+
 // Split lighting is required for the SSS pass.
 // Not currently possible since we need to access the stencil buffer from the compute shader.
 // #pragma multi_compile _ OUTPUT_SPLIT_LIGHTING

Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting/TilePass/TilePass.cs

                             // TODO: get rid of this by making global parameters visible to compute shaders
                             BindGlobalParams(cmd, shadeOpaqueShader, kernel, camera, renderContext);
 
+                            cmd.SetComputeBufferParam(shadeOpaqueShader, kernel, "g_vLightListGlobal", bUseClusteredForDeferred ? s_PerVoxelLightLists : s_LightList);
+
                             cmd.SetComputeTextureParam(shadeOpaqueShader, kernel, "_MainDepthTexture", depthStencilTexture);
                             cmd.SetComputeTextureParam(shadeOpaqueShader, kernel, "_GBufferTexture0", Shader.PropertyToID("_GBufferTexture0"));
                             cmd.SetComputeTextureParam(shadeOpaqueShader, kernel, "_GBufferTexture1", Shader.PropertyToID("_GBufferTexture1"));
                             cmd.SetComputeTextureParam(shadeOpaqueShader, kernel, "g_tShadowBuffer", Shader.PropertyToID("g_tShadowBuffer"));
 
-
+                            cmd.SetComputeTextureParam(shadeOpaqueShader, kernel, "_LtcData", Shader.GetGlobalTexture(Shader.PropertyToID("_LtcData")));
-                            Utilities.SetMatrixCS(cmd, shadeOpaqueShader, "_InvViewProjMatrix", Shader.GetGlobalMatrix("_InvViewProjMatrix"));
-                            Utilities.SetMatrixCS(cmd, shadeOpaqueShader, "_ViewProjMatrix", Shader.GetGlobalMatrix("_ViewProjMatrix"));
+                            Matrix4x4 viewToWorld = camera.cameraToWorldMatrix;
+                            Matrix4x4 worldToView = camera.worldToCameraMatrix;
+                            Matrix4x4 viewProjection = hdCamera.viewProjectionMatrix;
+                            Matrix4x4 invViewProjection = hdCamera.invViewProjectionMatrix;
+
+                            Utilities.SetMatrixCS(cmd, shadeOpaqueShader, "unity_MatrixV", worldToView);
+                            Utilities.SetMatrixCS(cmd, shadeOpaqueShader, "unity_MatrixInvV", viewToWorld);
+                            Utilities.SetMatrixCS(cmd, shadeOpaqueShader, "unity_MatrixVP", viewProjection);
+
+                            Utilities.SetMatrixCS(cmd, shadeOpaqueShader, "_InvViewProjMatrix", invViewProjection);
+                            Utilities.SetMatrixCS(cmd, shadeOpaqueShader, "_ViewProjMatrix", viewProjection);
                             Utilities.SetMatrixCS(cmd, shadeOpaqueShader, "g_mInvScrProjection", Shader.GetGlobalMatrix("g_mInvScrProjection"));
                             cmd.SetComputeVectorParam(shadeOpaqueShader, "_ScreenSize", Shader.GetGlobalVector("_ScreenSize"));
                             cmd.SetComputeIntParam(shadeOpaqueShader, "_UseTileLightList", Shader.GetGlobalInt("_UseTileLightList"));

Assets/ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/Resources/CombineSubsurfaceScattering.shader

             //-------------------------------------------------------------------------------------
 
             #define N_PROFILES 8
-            #define N_SAMPLES  7
+            #define N_SAMPLES  11
 
             float4 _FilterKernels[N_PROFILES][N_SAMPLES]; // RGB = weights, A = radial distance
             float4 _HalfRcpWeightedVariances[N_PROFILES]; // RGB for chromatic, A for achromatic
                 float  stepSize      = stepSizeY;
                 float2 unitDirection = float2(0, 1);
             #endif
-                float2 scaledDirection = distScale * stepSize * unitDirection;
+
+                float2   scaledDirection  = distScale * stepSize * unitDirection;
+                float    phi              = 0; // Random rotation; unused for now
+                float2x2 rotationMatrix   = float2x2(cos(phi), -sin(phi), sin(phi), cos(phi));
+                float2   rotatedDirection = mul(rotationMatrix, scaledDirection);
 
                 // Load (1 / (2 * WeightedVariance)) for bilateral weighting.
             #ifdef RBG_BILATERAL_WEIGHTS
                 [unroll]
                 for (int i = 1; i < N_SAMPLES; i++)
                 {
-                    samplePosition = posInput.unPositionSS + scaledDirection * _FilterKernels[profileID][i].a;
+                    samplePosition = posInput.unPositionSS + rotatedDirection * _FilterKernels[profileID][i].a;
                     sampleWeight   = _FilterKernels[profileID][i].rgb;
 
                     rawDepth         = LOAD_TEXTURE2D(_MainDepthTexture, samplePosition).r;

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

     [Serializable]
     public class SubsurfaceScatteringProfile
     {
-        public const int numSamples = 7; // Must be an odd number
+        public const int numSamples = 11; // Must be an odd number
 
         [SerializeField, ColorUsage(false, true, 0.05f, 2.0f, 1.0f, 1.0f)]
         public Color   stdDev1;
 
         public void UpdateKernelAndVarianceData()
         {
-            if (m_FilterKernel == null)
+            if (m_FilterKernel == null || m_FilterKernel.Length != numSamples)
             {
                 m_FilterKernel = new Vector4[numSamples];
             }
             // as a product of a linear combination of two normalized 1D Gaussians
             // as suggested by Jimenez et al. in "Separable Subsurface Scattering".
             // A normalized (i.e. energy-preserving) 1D Gaussian with the mean of 0
-            // is defined as follows: G1(x, v) = exp(-x� / (2 * v)) / sqrt(2 * Pi * v),
+            // is defined as follows: G1(x, v) = exp(-x * x / (2 * v)) / sqrt(2 * Pi * v),
             // where 'v' is variance and 'x' is the radial distance from the origin.
             // Using the weight 'w', our 1D and the resulting 2D filters are given as:
             // A1(v1, v2, w, x)    = G1(x, v1) * (1 - w) + G1(r, v2) * w,
                 halfRcpWeightedVariances = new Vector4[maxNumProfiles];
             }
 
-            if (filterKernels == null)
+            if (filterKernels == null || filterKernels.Length != (maxNumProfiles * SubsurfaceScatteringProfile.numSamples))
             {
                 filterKernels = new Vector4[maxNumProfiles * SubsurfaceScatteringProfile.numSamples];
             }

Assets/ScriptableRenderPipeline/HDRenderPipeline/ShaderVariables.hlsl

     // to represent the position of the primary (scene view) camera in order to
     // have identical tessellation levels for both the scene view and shadow views.
     // Otherwise, depth comparisons become meaningless!
-    float4x4 viewMat   = transpose(GetWorldToViewMatrix());
-    float3   rotCamPos = viewMat[3].xyz;
-   return mul((float3x3)viewMat, -rotCamPos);
+    float4x4 trViewMat = transpose(GetWorldToViewMatrix());
+    float3   rotCamPos = trViewMat[3].xyz;
+   return mul((float3x3)trViewMat, -rotCamPos);
 #endif
 }