Switch to HDCamera matrices (WIP, shadows have not yet been fixed)

Assets/ScriptableRenderPipeline/HDRenderPipeline/Debug/DebugDisplayLatlong.shader

             {
                 Varyings output;
                 output.positionCS = GetFullScreenTriangleVertexPosition(input.vertexID);
-                output.texcoord = GetFullScreenTriangleTexcoord(input.vertexID);// *_TextureScaleBias.xy + _TextureScaleBias.zw;
+                output.texcoord = GetFullScreenTriangleTexCoord(input.vertexID);// *_TextureScaleBias.xy + _TextureScaleBias.zw;
 
                 return output;
             }

Assets/ScriptableRenderPipeline/HDRenderPipeline/Debug/DebugDisplayShadowMap.shader

             {
                 Varyings output;
                 output.positionCS = GetFullScreenTriangleVertexPosition(input.vertexID);
-                output.texcoord   = GetFullScreenTriangleTexcoord(input.vertexID) * _TextureScaleBias.xy + _TextureScaleBias.zw;
+                output.texcoord   = GetFullScreenTriangleTexCoord(input.vertexID) * _TextureScaleBias.xy + _TextureScaleBias.zw;
 
                 return output;
             }

Assets/ScriptableRenderPipeline/HDRenderPipeline/HDRenderPipeline.cs

 
     public struct HDCamera
     {
-        public Camera    camera;
+        public Matrix4x4 viewMatrix;
+        public Matrix4x4 projMatrix;
-        public Matrix4x4 viewProjectionMatrix;
-        public Matrix4x4 invViewProjectionMatrix;
-        public Matrix4x4 invProjectionMatrix;
-        public Vector4   invProjectionParam;
+        public Camera    camera;
+
+        public Matrix4x4 viewProjMatrix
+        {
+            get { return projMatrix * viewMatrix; }
+        }
+
+        public Vector4   invProjParam
+        {
+            // Ref: An Efficient Depth Linearization Method for Oblique View Frustums, Eq. 6.
+            get { var p = projMatrix; return new Vector4(p.m20 / (p.m00 * p.m23), p.m21 / (p.m11 * p.m23), -1.0f / p.m23, (-p.m22 + p.m20 * p.m02 / p.m00 + p.m21 * p.m12 / p.m11) / p.m23); }
+        }
     }
 
     public class GBufferManager
         {
             var cmd = new CommandBuffer {name = "Push Global Parameters"};
 
-            cmd.SetGlobalVector("_ScreenSize",        hdCamera.screenSize);
-            cmd.SetGlobalMatrix("_ViewProjMatrix",    hdCamera.viewProjectionMatrix);
-            cmd.SetGlobalMatrix("_InvViewProjMatrix", hdCamera.invViewProjectionMatrix);
-            cmd.SetGlobalMatrix("_InvProjMatrix",     hdCamera.invProjectionMatrix);
-            cmd.SetGlobalVector("_InvProjParam",      hdCamera.invProjectionParam);
+            Utilities.SetupGlobalHDCamera(hdCamera, cmd);
 
             // TODO: cmd.SetGlobalInt() does not exist, so we are forced to use Shader.SetGlobalInt() instead.
 
             renderContext.SetupCameraProperties(camera);
 
             HDCamera hdCamera = Utilities.GetHDCamera(camera);
+            PushGlobalParams(hdCamera, renderContext, m_Asset.sssSettings);
 
             // TODO: Find a correct place to bind these material textures
             // We have to bind the material specific global parameters in this mode
                     renderContext.SetupCameraProperties(camera); // Need to recall SetupCameraProperties after m_ShadowPass.Render
                     m_LightLoop.BuildGPULightLists(camera, renderContext, m_CameraDepthStencilBufferRT);
                 }
-
-                PushGlobalParams(hdCamera, renderContext, m_Asset.sssSettings);
 
                 // Caution: We require sun light here as some sky use the sun light to render, mean UpdateSkyEnvironment
                 // must be call after BuildGPULightLists.
                 // Render GBuffer opaque
                 if (!m_Asset.renderingSettings.ShouldUseForwardRenderingOnly())
                 {
-                    Utilities.SetupMaterialHDCamera(hdCamera, m_DebugViewMaterialGBuffer);
-
                     // m_gbufferManager.BindBuffers(m_DebugViewMaterialGBuffer);
                     // TODO: Bind depth textures
                     var cmd = new CommandBuffer { name = "DebugViewMaterialGBuffer" };
             m_FilterAndCombineSubsurfaceScattering.SetFloatArray("_FilterKernelsNearField", sssParameters.filterKernelsNearField);
             m_FilterAndCombineSubsurfaceScattering.SetFloatArray("_FilterKernelsFarField",  sssParameters.filterKernelsFarField);
 
-            Utilities.DrawFullScreen(cmd, m_FilterAndCombineSubsurfaceScattering, hdCamera, m_CameraColorBufferRT, m_CameraDepthStencilBufferRT);
+            Utilities.DrawFullScreen(cmd, m_FilterAndCombineSubsurfaceScattering, m_CameraColorBufferRT, m_CameraDepthStencilBufferRT);
 
             context.ExecuteCommandBuffer(cmd);
             cmd.Dispose();

Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting/AmbientOcclusion/AmbientOcclusion.cs

             // AO estimation.
             cmd.GetTemporaryRT(Uniforms._TempTex1, width / downsize, height / downsize, 0, kFilter, kFormat, kRWMode);
             cmd.SetGlobalTexture(Uniforms._MainTex, depthID);
-            Utilities.DrawFullScreen(cmd, m_Material, hdCamera, Uniforms._TempTex1, null, 0);
+            Utilities.DrawFullScreen(cmd, m_Material, Uniforms._TempTex1, null, 0);
-            Utilities.DrawFullScreen(cmd, m_Material, hdCamera, Uniforms._TempTex2, null, 1);
+            Utilities.DrawFullScreen(cmd, m_Material, Uniforms._TempTex2, null, 1);
-            Utilities.DrawFullScreen(cmd, m_Material, hdCamera, Uniforms._TempTex1, null, 2);
+            Utilities.DrawFullScreen(cmd, m_Material, Uniforms._TempTex1, null, 2);
-            Utilities.DrawFullScreen(cmd, m_Material, hdCamera, Uniforms._AOBuffer, null, 3);
+            Utilities.DrawFullScreen(cmd, m_Material, Uniforms._AOBuffer, null, 3);
             cmd.ReleaseTemporaryRT(Uniforms._TempTex1);
 
             // Setup texture for lighting pass (automagic of unity)

Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting/Deferred.shader

             HLSLPROGRAM
             #pragma target 4.5
             #pragma only_renderers d3d11 ps4 metal // TEMP: until we go further in dev
-            // #pragma enable_d3d11_debug_symbols
+            #pragma enable_d3d11_debug_symbols
 
             #pragma vertex Vert
             #pragma fragment Frag

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

                     if (GetFeatureVariantsEnabled())
                     {
                         // featureVariants
-                        Utilities.SetupMaterialHDCamera(hdCamera, m_DebugViewTilesMaterial);
                         m_DebugViewTilesMaterial.SetInt("_NumTiles", numTiles);
                         m_DebugViewTilesMaterial.SetInt("_ViewTilesFlags", (int)m_TileSettings.tileDebugByCategory);
                         m_DebugViewTilesMaterial.SetVector("_MousePixelCoord", mousePixelCoord);
                 else if (m_TileSettings.tileDebugByCategory != TileSettings.TileDebug.None)
                 {
                     // lightCategories
-                    Utilities.SetupMaterialHDCamera(hdCamera, m_DebugViewTilesMaterial);
                     m_DebugViewTilesMaterial.SetInt("_ViewTilesFlags", (int)m_TileSettings.tileDebugByCategory);
                     m_DebugViewTilesMaterial.SetVector("_MousePixelCoord", mousePixelCoord);
                     m_DebugViewTilesMaterial.EnableKeyword(bUseClusteredForDeferred ? "USE_CLUSTERED_LIGHTLIST" : "USE_FPTL_LIGHTLIST");
                         // This is a debug brute force renderer to debug tile/cluster which render all the lights
                         if (outputSplitLightingForSSS)
                         {
-                            Utilities.DrawFullScreen(cmd, m_SingleDeferredMaterialMRT, hdCamera, colorBuffers, depthStencilBuffer);
+                            Utilities.DrawFullScreen(cmd, m_SingleDeferredMaterialMRT, colorBuffers, depthStencilBuffer);
                         }
                         else
                         {
 
-                            Utilities.DrawFullScreen(cmd, m_SingleDeferredMaterialSRT, hdCamera, colorBuffers[0], depthStencilBuffer);
+                            Utilities.DrawFullScreen(cmd, m_SingleDeferredMaterialSRT, colorBuffers[0], depthStencilBuffer);
                         }
                     }
                     else
                                 cmd.SetComputeTextureParam(shadeOpaqueShader, kernel, "_LtcDisneyDiffuseMatrix", Shader.GetGlobalTexture("_LtcDisneyDiffuseMatrix"));
                                 cmd.SetComputeTextureParam(shadeOpaqueShader, kernel, "_LtcMultiGGXFresnelDisneyDiffuse", Shader.GetGlobalTexture("_LtcMultiGGXFresnelDisneyDiffuse"));
 
-                                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.SetupComputeShaderHDCamera(hdCamera, shadeOpaqueShader, cmd);
-                                Utilities.SetMatrixCS(cmd, shadeOpaqueShader, "_InvViewProjMatrix", invViewProjection);
-                                Utilities.SetMatrixCS(cmd, shadeOpaqueShader, "_ViewProjMatrix", viewProjection);
-                                cmd.SetComputeVectorParam(shadeOpaqueShader, "_ScreenSize", hdCamera.screenSize);
                                 cmd.SetComputeIntParam(shadeOpaqueShader, "_UseTileLightList", Shader.GetGlobalInt("_UseTileLightList"));
 
                                 cmd.SetComputeVectorParam(shadeOpaqueShader, "_Time", Shader.GetGlobalVector("_Time"));
                                 if (outputSplitLightingForSSS)
                                 {
                                     Utilities.SelectKeyword(m_DeferredDirectMaterialMRT, "USE_CLUSTERED_LIGHTLIST", "USE_FPTL_LIGHTLIST", bUseClusteredForDeferred);
-                                    Utilities.DrawFullScreen(cmd, m_DeferredDirectMaterialMRT, hdCamera, colorBuffers, depthStencilBuffer);
+                                    Utilities.DrawFullScreen(cmd, m_DeferredDirectMaterialMRT, colorBuffers, depthStencilBuffer);
-                                    Utilities.DrawFullScreen(cmd, m_DeferredIndirectMaterialMRT, hdCamera, colorBuffers, depthStencilBuffer);
+                                    Utilities.DrawFullScreen(cmd, m_DeferredIndirectMaterialMRT, colorBuffers, depthStencilBuffer);
                                 }
                                 else
                                 {
                                     m_DeferredIndirectMaterialSRT.SetInt("_StencilRef", (int)(debugDisplaySettings.renderingDebugSettings.enableSSS ? StencilBits.SSS : 0));
 
                                     Utilities.SelectKeyword(m_DeferredDirectMaterialSRT, "USE_CLUSTERED_LIGHTLIST", "USE_FPTL_LIGHTLIST", bUseClusteredForDeferred);
-                                    Utilities.DrawFullScreen(cmd, m_DeferredDirectMaterialSRT, hdCamera, colorBuffers[0], depthStencilBuffer);
+                                    Utilities.DrawFullScreen(cmd, m_DeferredDirectMaterialSRT, colorBuffers[0], depthStencilBuffer);
-                                    Utilities.DrawFullScreen(cmd, m_DeferredIndirectMaterialSRT, hdCamera, colorBuffers[0], depthStencilBuffer);
+                                    Utilities.DrawFullScreen(cmd, m_DeferredIndirectMaterialSRT, colorBuffers[0], depthStencilBuffer);
                                 }
                             }
                             else
                                     Utilities.SelectKeyword(m_DeferredAllMaterialMRT, "USE_CLUSTERED_LIGHTLIST", "USE_FPTL_LIGHTLIST", bUseClusteredForDeferred);
-                                    Utilities.DrawFullScreen(cmd, m_DeferredAllMaterialMRT, hdCamera, colorBuffers, depthStencilBuffer);
+                                    Utilities.DrawFullScreen(cmd, m_DeferredAllMaterialMRT, colorBuffers, depthStencilBuffer);
                                 }
                                 else
                                 {
 
                                     Utilities.SelectKeyword(m_DeferredAllMaterialSRT, "USE_CLUSTERED_LIGHTLIST", "USE_FPTL_LIGHTLIST", bUseClusteredForDeferred);
-                                    Utilities.DrawFullScreen(cmd, m_DeferredAllMaterialSRT, hdCamera, colorBuffers[0], depthStencilBuffer);
+                                    Utilities.DrawFullScreen(cmd, m_DeferredAllMaterialSRT, colorBuffers[0], depthStencilBuffer);
                                 }
                             }
                         }

Assets/ScriptableRenderPipeline/HDRenderPipeline/Material/LayeredLit/LayeredLit.shader

 
     #pragma target 4.5
     #pragma only_renderers d3d11 ps4 metal // TEMP: until we go further in dev
+    #pragma enable_d3d11_debug_symbols
 
     #pragma shader_feature _ALPHATEST_ON
     #pragma shader_feature _DISTORTION_ON

Assets/ScriptableRenderPipeline/HDRenderPipeline/Material/LayeredLit/LayeredLitTessellation.shader

 
     #pragma target 5.0
     #pragma only_renderers d3d11 ps4 // TEMP: until we go further in dev
+    #pragma enable_d3d11_debug_symbols
 
     #pragma shader_feature _ALPHATEST_ON
     #pragma shader_feature _DISTORTION_ON

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

             {
                 var cmd = new CommandBuffer();
                 cmd.name = "Init PreFGD";
-                cmd.Blit(null, new RenderTargetIdentifier(m_PreIntegratedFGD), m_InitPreFGD, 0);
+                Utilities.DrawFullScreen(cmd, m_InitPreFGD, new RenderTargetIdentifier(m_PreIntegratedFGD));
                 renderContext.ExecuteCommandBuffer(cmd);
                 cmd.Dispose();
 

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

 
     #pragma target 4.5
     #pragma only_renderers d3d11 ps4 metal // TEMP: until we go futher in dev
-    // #pragma enable_d3d11_debug_symbols
+    #pragma enable_d3d11_debug_symbols
 
     //-------------------------------------------------------------------------------------
     // Variant

Assets/ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/LitTessellation.shader

 
     #pragma target 5.0
     #pragma only_renderers d3d11 ps4// TEMP: until we go futher in dev
-    // #pragma enable_d3d11_debug_symbols
+    #pragma enable_d3d11_debug_symbols
 
     //-------------------------------------------------------------------------------------
     // Variant

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

             #include "../../../../ShaderLibrary/ImageBasedLighting.hlsl"
             #include "../../../ShaderVariables.hlsl"
 
-
-                float3 vertex : POSITION;
-                float2 texcoord : TEXCOORD0;
+                uint vertexID : SV_VertexID;
-                float4 vertex : SV_POSITION;
-                float2 texcoord : TEXCOORD0;
+                float4 positionCS : SV_POSITION;
+                float2 texCoord   : TEXCOORD0;
-                output.vertex = TransformWorldToHClip(input.vertex);
-                output.texcoord = input.texcoord.xy;
+
+                output.positionCS = GetFullScreenTriangleVertexPosition(input.vertexID);
+                output.texCoord   = GetFullScreenTriangleTexCoord(input.vertexID);
+
                 return output;
             }
 
-                float NdotV                 = input.texcoord.x;
-                float perceptualRoughness   = input.texcoord.y;
+                float NdotV                 = input.texCoord.x;
+                float perceptualRoughness   = input.texCoord.y;
                 float3 V                    = float3(sqrt(1 - NdotV * NdotV), 0, NdotV);
                 float3 N                    = float3(0.0, 0.0, 1.0);
 

Assets/ScriptableRenderPipeline/HDRenderPipeline/Material/Unlit/Unlit.shader

 
     #pragma target 4.5
     #pragma only_renderers d3d11 ps4 metal  // TEMP: until we go further in dev
+    #pragma enable_d3d11_debug_symbols
 
     //-------------------------------------------------------------------------------------
     // Variant

Assets/ScriptableRenderPipeline/HDRenderPipeline/SceneSettings/Resources/DrawSssProfile.shader

             Varyings Vert(Attributes input)
             {
                 Varyings output;
-                output.vertex   = TransformWorldToHClip(input.vertex);
+                // GUI code set up by Unity - do not modify.
+                output.vertex   = mul(unity_MatrixVP, float4(input.vertex, 1));
                 output.texcoord = input.texcoord.xy;
                 return output;
             }

Assets/ScriptableRenderPipeline/HDRenderPipeline/SceneSettings/Resources/DrawTransmittanceGraph.shader

             Varyings Vert(Attributes input)
             {
                 Varyings output;
-                output.vertex   = TransformWorldToHClip(input.vertex);
+                // GUI code set up by Unity - do not modify.
+                output.vertex   = mul(unity_MatrixVP, float4(input.vertex, 1));
                 output.texcoord = input.texcoord.xy;
                 return output;
             }

Assets/ScriptableRenderPipeline/HDRenderPipeline/ShaderVariables.hlsl

     float _MotionVectorDepthBias;
 CBUFFER_END
 
-// ----------------------------------------------------------------------------
-
-float4   _ScreenSize;
-float4x4 _ViewProjMatrix; // Looks like using UNITY_MATRIX_VP in pixel shader doesn't work ??? need to setup my own...
-float4x4 _InvViewProjMatrix;
+float4x4 _ViewMatrix;
+float4x4 _InvViewMatrix;
+float4x4 _ProjMatrix;
+float4x4 _ViewProjMatrix;
+float4x4 _InvViewProjMatrix;
+float4   _ScreenSize;
+
+/****************************************************************************/
+/*                            HDCAMERA OVERRIDES                            */
+/****************************************************************************/
+
+#define UNITY_MATRIX_M     unity_ObjectToWorld
+#define UNITY_MATRIX_I_M   unity_WorldToObject
+#define UNITY_MATRIX_V     _ViewMatrix
+#define UNITY_MATRIX_I_V   _InvViewMatrix
+#define UNITY_MATRIX_P     _ProjMatrix
+#define UNITY_MATRIX_I_P   _InvProjMatrix
+#define UNITY_MATRIX_VP    _ViewProjMatrix
+#define UNITY_MATRIX_MVP   mul(UNITY_MATRIX_VP, UNITY_MATRIX_M)
+#define UNITY_MATRIX_MV    mul(UNITY_MATRIX_V, UNITY_MATRIX_M)
+#define UNITY_MATRIX_T_MV  transpose(UNITY_MATRIX_MV)
+#define UNITY_MATRIX_IT_MV transpose(mul(UNITY_MATRIX_I_M, UNITY_MATRIX_I_V))
 
 float4x4 GetWorldToViewMatrix()
 {
 float4x4 GetObjectToWorldMatrix()
 {
-    return unity_ObjectToWorld;
+    return UNITY_MATRIX_M;
-    return unity_WorldToObject;
+    return UNITY_MATRIX_I_M;
 }
 
 // Transform to homogenous clip space
 {
     // Use transpose transformation to go from tangent to world as the matrix is orthogonal
     float3 normalWS = mul(dirTS, worldToTangent);
-    return mul((float3x3)unity_WorldToObject, normalWS);
+    return mul((float3x3)GetWorldToObjectMatrix(), normalWS);
 }
 
 float3 TransformObjectToTangent(float3 dirOS, float3x3 worldToTangent)

Assets/ScriptableRenderPipeline/HDRenderPipeline/Sky/BlitCubemap.shader

                 v2f o;
 
                 o.vertex = GetFullScreenTriangleVertexPosition(v.vertexID);
-                float2 uv = GetFullScreenTriangleTexcoord(v.vertexID) * 2.0 - 1.0;
+                float2 uv = GetFullScreenTriangleTexCoord(v.vertexID) * 2.0 - 1.0;
 
                 int idx = (int)_faceIndex;
                 float3 transformU = faceU[idx];

Assets/ScriptableRenderPipeline/HDRenderPipeline/Sky/GGXConvolve.shader

             ZWrite Off
             ZTest Always
             Blend One Zero
+            Cull Off
 
             HLSLPROGRAM
             #pragma target 4.5
             Varyings Vert(Attributes input)
             {
                 Varyings output;
-                output.positionCS = float4(input.positionCS.xy, UNITY_RAW_FAR_CLIP_VALUE, 1.0);
+                output.positionCS = float4(input.positionCS.x, -input.positionCS.y, UNITY_RAW_FAR_CLIP_VALUE, 1.0);
                 output.eyeVector = input.eyeVector;
                 return output;
             }
             float _LastLevel;
             float _InvOmegaP;
 
-            half4 Frag(Varyings input) : SV_Target
+            float4 Frag(Varyings input) : SV_Target
             {
                 // Vector interpolation is not magnitude-preserving.
                 float3 N = normalize(input.eyeVector);

Assets/ScriptableRenderPipeline/HDRenderPipeline/Sky/HDRISky/Resources/SkyHDRI.shader

     {
         // TODO: implement SV_vertexID full screen quad
         Varyings output;
-        output.positionCS = float4(input.positionCS.xy, UNITY_RAW_FAR_CLIP_VALUE, 1.0);
+        output.positionCS = float4(input.positionCS.x, -input.positionCS.y, UNITY_RAW_FAR_CLIP_VALUE, 1.0);
         output.eyeVector = input.eyeVector;
 
         return output;

Assets/ScriptableRenderPipeline/HDRenderPipeline/Sky/ProceduralSky/ProceduralSkyRenderer.cs

             // Since we use the material for rendering the sky both into the cubemap, and
             // during the fullscreen pass, setting the 'PERFORM_SKY_OCCLUSION_TEST' keyword has no effect.
             properties.SetFloat("_DisableSkyOcclusionTest", renderForCubemap ? 1.0f : 0.0f);
-            // We flip the screens-space Y axis in case we follow the D3D convention.
-            properties.SetFloat("_FlipY",                   renderForCubemap ? 1.0f : 0.0f);
             // We do not render the height fog into the sky IBL cubemap.
             properties.SetFloat("_HeightRayleighDensity",   renderForCubemap ? -0.0f : -param.heightRayleighDensity / 100000f);
             properties.SetFloat("_HeightMieDensity",        renderForCubemap ? -0.0f : -param.heightMieDensity / 100000f);

Assets/ScriptableRenderPipeline/HDRenderPipeline/Sky/ProceduralSky/Resources/SkyProcedural.shader

 
             float _DisableSkyOcclusionTest;
 
-            float _FlipY;
-
             #define IS_RENDERING_SKY
             #include "AtmosphericScattering.hlsl"
 
             {
                 // TODO: implement SV_vertexID full screen quad
                 Varyings output;
-                output.positionCS = float4(input.positionCS.xy, UNITY_RAW_FAR_CLIP_VALUE, 1.0);
+                output.positionCS = float4(input.positionCS.x, -input.positionCS.y, UNITY_RAW_FAR_CLIP_VALUE, 1.0);
                 output.eyeVector  = input.eyeVector;
 
                 return output;
                 }
 
                 // Since we only need the world space position, so we don't pass the view-projection matrix.
-                UpdatePositionInput(depthRaw, _InvViewProjMatrix, k_identity4x4, posInput, _FlipY != 0);
+                UpdatePositionInput(depthRaw, _InvViewProjMatrix, k_identity4x4, posInput);
 
                 float4 c1, c2, c3;
                 VolundTransferScatter(posInput.positionWS, c1, c2, c3);

Assets/ScriptableRenderPipeline/HDRenderPipeline/Sky/SkyManager.cs

 
         public Texture skyReflection { get { return m_SkyboxGGXCubemapRT; } }
 
-        protected Mesh BuildSkyMesh(Vector3 cameraPosition, Matrix4x4 cameraInvViewProjectionMatrix, bool forceUVBottom)
+        protected Mesh BuildSkyMesh(Vector3 cameraPosition, Matrix4x4 cameraInvViewProjectionMatrix)
-            Vector4 vertData0 = new Vector4(-1.0f, -1.0f, 1.0f, 1.0f);
-            Vector4 vertData1 = new Vector4(1.0f, -1.0f, 1.0f, 1.0f);
-            Vector4 vertData2 = new Vector4(1.0f, 1.0f, 1.0f, 1.0f);
-            Vector4 vertData3 = new Vector4(-1.0f, 1.0f, 1.0f, 1.0f);
+            Vector4 vertData0 = new Vector4(-1.0f, -1.0f, 0.0f, 1.0f);
+            Vector4 vertData1 = new Vector4( 1.0f, -1.0f, 0.0f, 1.0f);
+            Vector4 vertData2 = new Vector4( 1.0f,  1.0f, 0.0f, 1.0f);
+            Vector4 vertData3 = new Vector4(-1.0f,  1.0f, 0.0f, 1.0f);
 
             Vector3[] vertData = new Vector3[4];
             vertData[0] = new Vector3(vertData0.x, vertData0.y, vertData0.z);
             Vector4 direction2 = (posWorldSpace2 / posWorldSpace2.w - cameraPos);
             Vector4 direction3 = (posWorldSpace3 / posWorldSpace3.w - cameraPos);
 
-            if (SystemInfo.graphicsUVStartsAtTop && !forceUVBottom)
+            if (SystemInfo.graphicsUVStartsAtTop)
             {
                 eyeVectorData[3] = new Vector3(direction0.x, direction0.y, direction0.z).normalized;
                 eyeVectorData[2] = new Vector3(direction1.x, direction1.y, direction1.z).normalized;
                     m_faceCameraViewProjectionMatrix[i] = Utilities.GetViewProjectionMatrix(lookAt, cubeProj);
                     m_faceCameraInvViewProjectionMatrix[i] = m_faceCameraViewProjectionMatrix[i].inverse;
 
-                    m_CubemapFaceMesh[i] = BuildSkyMesh(Vector3.zero, m_faceCameraInvViewProjectionMatrix[i], true);
+                    m_CubemapFaceMesh[i] = BuildSkyMesh(Vector3.zero, m_faceCameraInvViewProjectionMatrix[i]);
                 }
             }
         }
                 {
                     m_BuiltinParameters.renderContext = renderContext;
                     m_BuiltinParameters.sunLight = sunLight;
-                    m_BuiltinParameters.invViewProjMatrix = camera.invViewProjectionMatrix;
+                    m_BuiltinParameters.invViewProjMatrix = camera.viewProjMatrix.inverse;
-                    m_BuiltinParameters.skyMesh = BuildSkyMesh(camera.camera.GetComponent<Transform>().position, m_BuiltinParameters.invViewProjMatrix, false);
+                    m_BuiltinParameters.skyMesh = BuildSkyMesh(camera.camera.GetComponent<Transform>().position, m_BuiltinParameters.invViewProjMatrix);
                     m_BuiltinParameters.colorBuffer = colorBuffer;
                     m_BuiltinParameters.depthBuffer = depthBuffer;
 

Assets/ScriptableRenderPipeline/HDRenderPipeline/Utilities.cs

 
         public static HDCamera GetHDCamera(Camera camera)
         {
-            HDCamera hdCamera = new HDCamera();
-            hdCamera.camera = camera;
-            hdCamera.screenSize = new Vector4(camera.pixelWidth, camera.pixelHeight, 1.0f / camera.pixelWidth, 1.0f / camera.pixelHeight);
+            // The actual projection matrix used in shaders is actually massaged a bit to work across all platforms (different Z value ranges etc.)
+            Matrix4x4 projMatrix = GL.GetGPUProjectionMatrix(camera.projectionMatrix, true);
-            // The actual projection matrix used in shaders is actually massaged a bit to work across all platforms
-            // (different Z value ranges etc.)
-            var gpuProj = GL.GetGPUProjectionMatrix(camera.projectionMatrix, false);
-            var gpuVP = gpuProj * camera.worldToCameraMatrix;
+            HDCamera hdCamera = new HDCamera();
-            // Ref: An Efficient Depth Linearization Method for Oblique View Frustums, Eq. 6.
-            Vector4 invProjectionParam = new Vector4(gpuProj.m20 / (gpuProj.m00 * gpuProj.m23),
-                    gpuProj.m21 / (gpuProj.m11 * gpuProj.m23),
-                    -1.0f / gpuProj.m23,
-                    (-gpuProj.m22
-                     + gpuProj.m20 * gpuProj.m02 / gpuProj.m00
-                     + gpuProj.m21 * gpuProj.m12 / gpuProj.m11) / gpuProj.m23);
-
-            hdCamera.viewProjectionMatrix    = gpuVP;
-            hdCamera.invViewProjectionMatrix = gpuVP.inverse;
-            hdCamera.invProjectionMatrix     = gpuProj.inverse;
-            hdCamera.invProjectionParam      = invProjectionParam;
+            hdCamera.viewMatrix = camera.worldToCameraMatrix;
+            hdCamera.projMatrix = projMatrix;
+            hdCamera.screenSize = new Vector4(camera.pixelWidth, camera.pixelHeight, 1.0f / camera.pixelWidth, 1.0f / camera.pixelHeight);;
+            hdCamera.camera     = camera;
+        public static void SetupGlobalHDCamera(HDCamera hdCamera, CommandBuffer cmd)
+        {
+            cmd.SetGlobalMatrix("_ViewMatrix",        hdCamera.viewMatrix);
+            cmd.SetGlobalMatrix("_InvViewMatrix",     hdCamera.viewMatrix.inverse);
+            cmd.SetGlobalMatrix("_ProjMatrix",        hdCamera.projMatrix);
+            cmd.SetGlobalMatrix("_InvProjMatrix",     hdCamera.projMatrix.inverse);
+            cmd.SetGlobalMatrix("_ViewProjMatrix",    hdCamera.viewProjMatrix);
+            cmd.SetGlobalMatrix("_InvViewProjMatrix", hdCamera.viewProjMatrix.inverse);
+            cmd.SetGlobalVector("_InvProjParam",      hdCamera.invProjParam);
+            cmd.SetGlobalVector("_ScreenSize",        hdCamera.screenSize);
+        }
-        public static void SetupMaterialHDCamera(HDCamera hdCamera, Material material)
+        // Does not modify global settings. Used for shadows, low res. rendering, etc.
+        public static void OverrideGlobalHDCamera(HDCamera hdCamera, Material material)
+            material.SetMatrix("_ViewMatrix",        hdCamera.viewMatrix);
+            material.SetMatrix("_InvViewMatrix",     hdCamera.viewMatrix.inverse);
+            material.SetMatrix("_ProjMatrix",        hdCamera.projMatrix);
+            material.SetMatrix("_InvProjMatrix",     hdCamera.projMatrix.inverse);
+            material.SetMatrix("_ViewProjMatrix",    hdCamera.viewProjMatrix);
+            material.SetMatrix("_InvViewProjMatrix", hdCamera.viewProjMatrix.inverse);
+            material.SetVector("_InvProjParam",      hdCamera.invProjParam);
-            material.SetMatrix("_ViewProjMatrix",    hdCamera.viewProjectionMatrix);
-            material.SetMatrix("_InvViewProjMatrix", hdCamera.invViewProjectionMatrix);
-            material.SetMatrix("_InvProjMatrix",     hdCamera.invProjectionMatrix);
-            material.SetVector("_InvProjParam",      hdCamera.invProjectionParam);
+        }
+
+        public static void SetupComputeShaderHDCamera(HDCamera hdCamera, ComputeShader cs, CommandBuffer cmd)
+        {
+            SetMatrixCS(cmd,          cs, "_ViewMatrix",        hdCamera.viewMatrix);
+            SetMatrixCS(cmd,          cs, "_InvViewMatrix",     hdCamera.viewMatrix.inverse);
+            SetMatrixCS(cmd,          cs, "_ProjMatrix",        hdCamera.projMatrix);
+            SetMatrixCS(cmd,          cs, "_InvProjMatrix",     hdCamera.projMatrix.inverse);
+            SetMatrixCS(cmd,          cs, "_ViewProjMatrix",    hdCamera.viewProjMatrix);
+            SetMatrixCS(cmd,          cs, "_InvViewProjMatrix", hdCamera.viewProjMatrix.inverse);
+            cmd.SetComputeVectorParam(cs, "_InvProjParam",      hdCamera.invProjParam);
+            cmd.SetComputeVectorParam(cs, "_ScreenSize",        hdCamera.screenSize);
         }
 
         // TEMP: These functions should be implemented C++ side, for now do it in C#
         }
 
         // Draws a full screen triangle as a faster alternative to drawing a full screen quad.
-        public static void DrawFullScreen(CommandBuffer commandBuffer, Material material, HDCamera camera,
+        public static void DrawFullScreen(CommandBuffer commandBuffer, Material material,
-            SetupMaterialHDCamera(camera, material);
-        public static void DrawFullScreen(CommandBuffer commandBuffer, Material material, HDCamera camera,
+        public static void DrawFullScreen(CommandBuffer commandBuffer, Material material,
-            SetupMaterialHDCamera(camera, material);
-        public static void DrawFullScreen(CommandBuffer commandBuffer, Material material, HDCamera camera,
+        public static void DrawFullScreen(CommandBuffer commandBuffer, Material material,
-            SetupMaterialHDCamera(camera, material);
             commandBuffer.SetRenderTarget(colorBuffers, depthStencilBuffer);
             commandBuffer.DrawProcedural(Matrix4x4.identity, material, shaderPassID, MeshTopology.Triangles, 3, 1, properties);
         }
-        public static void DrawFullScreen(CommandBuffer commandBuffer, Material material, HDCamera camera,
+        public static void DrawFullScreen(CommandBuffer commandBuffer, Material material,
             RenderTargetIdentifier[] colorBuffers,
             MaterialPropertyBlock properties = null, int shaderPassID = 0)
         {
             // no depth target ends up being bound.
-            DrawFullScreen(commandBuffer, material, camera, colorBuffers, colorBuffers[0], properties, shaderPassID);
+            DrawFullScreen(commandBuffer, material, colorBuffers, colorBuffers[0], properties, shaderPassID);
         }
 
         // Helper to help to display debug info on screen

Assets/ScriptableRenderPipeline/ShaderLibrary/Common.hlsl

 // For information. In Unity Depth is always in range 0..1 (even on OpenGL) but can be reversed.
 // It may be necessary to flip the Y axis as the origin of the screen-space coordinate system
 // of Direct3D is at the top left corner of the screen, with the Y axis pointing downwards.
-void UpdatePositionInput(float depthRaw, float4x4 invViewProjMatrix, float4x4 viewProjMatrix,
-                         inout PositionInputs posInput, bool flipY = false)
+void UpdatePositionInput(float depthRaw, float4x4 invViewProjMatrix, float4x4 viewProjMatrix, inout PositionInputs posInput)
-    screenSpacePos.x = posInput.positionSS.x;
-    screenSpacePos.y = flipY ? 1.0 - posInput.positionSS.y : posInput.positionSS.y;
-
+    screenSpacePos = posInput.positionSS;
+#if UNITY_UV_STARTS_AT_TOP
+    screenSpacePos.y = 1.0 - screenSpacePos.y;
+#endif
     float4 positionCS   = float4(screenSpacePos * 2.0 - 1.0, depthRaw, 1.0);
     float4 hpositionWS  = mul(invViewProjMatrix, positionCS);
     posInput.positionWS = hpositionWS.xyz / hpositionWS.w;
 
 // It may be necessary to flip the Y axis as the origin of the screen-space coordinate system
 // of Direct3D is at the top left corner of the screen, with the Y axis pointing downwards.
-float3 ComputeViewSpacePosition(float2 positionSS, float depthRaw, float4x4 invProjMatrix, bool flipY = false)
+float3 ComputeViewSpacePosition(float2 positionSS, float depthRaw, float4x4 invProjMatrix)
-    screenSpacePos.x = positionSS.x;
-    screenSpacePos.y = flipY ? 1.0 - positionSS.y : positionSS.y;
-
+    screenSpacePos = positionSS;
+#if UNITY_UV_STARTS_AT_TOP
+    screenSpacePos.y = 1.0 - screenSpacePos.y;
+#endif
     float4 positionCS = float4(screenSpacePos * 2.0 - 1.0, depthRaw, 1.0);
     float4 positionVS = mul(invProjMatrix, positionCS);
     // The view space uses a right-handed coordinate system.
 
 // Generates a triangle in homogeneous clip space, s.t.
 // v0 = (-1, -1, 1), v1 = (3, -1, 1), v2 = (-1, 3, 1).
-float2 GetFullScreenTriangleTexcoord(uint vertexID)
+float2 GetFullScreenTriangleTexCoord(uint vertexID)
 {
 #if UNITY_UV_STARTS_AT_TOP
     return float2((vertexID << 1) & 2, 1.0 - (vertexID & 2));