Initial RenderTextureDescriptor management

Placed in HDCamera for now

Also, plumb the GBuffer code

ScriptableRenderPipeline/HDRenderPipeline/Camera/HDCamera.cs

 using System.Collections.Generic;
 using UnityEngine.Rendering;
 using UnityEngine.Rendering.PostProcessing;
+using UnityEngine.XR;
 
 namespace UnityEngine.Experimental.Rendering.HDPipeline
 {
         {
             get { return nonJitteredProjMatrix * viewMatrix; }
         }
+
+        public RenderTextureDescriptor renderTextureDesc { get; private set; }
 
         // Always true for cameras that just got added to the pool - needed for previous matrices to
         // avoid one-frame jumps/hiccups with temporal effects (motion blur, TAA...)
             projMatrix = gpuProj;
             nonJitteredProjMatrix = gpuNonJitteredProj;
             cameraPos = pos;
-            screenSize = new Vector4(camera.pixelWidth, camera.pixelHeight, 1.0f / camera.pixelWidth, 1.0f / camera.pixelHeight);
 
             // Warning: near and far planes appear to be broken.
             GeometryUtility.CalculateFrustumPlanes(viewProjMatrix, frustumPlanes);
 
             stereoEnabled = stereoActive && (camera.stereoTargetEye == StereoTargetEyeMask.Both);
             useForwardOnly = globalRenderingSettings.ShouldUseForwardRenderingOnly() || stereoEnabled;
+
+            RenderTextureDescriptor tempDesc;
+            if (stereoEnabled)
+            {
+                screenSize = new Vector4(XRSettings.eyeTextureWidth, XRSettings.eyeTextureHeight, 1.0f / XRSettings.eyeTextureWidth, 1.0f / XRSettings.eyeTextureHeight);
+                tempDesc = XRSettings.eyeTextureDesc;
+            }
+            else
+            {
+                screenSize = new Vector4(camera.pixelWidth, camera.pixelHeight, 1.0f / camera.pixelWidth, 1.0f / camera.pixelHeight);
+                tempDesc = new RenderTextureDescriptor(camera.pixelWidth, camera.pixelHeight);
+            }
+
+            tempDesc.msaaSamples = 1; // will be updated later, deferred will always set to 1
+            tempDesc.depthBufferBits = 0;
+            tempDesc.autoGenerateMips = false;
+            tempDesc.useMipMap = false;
+            tempDesc.memoryless = RenderTextureMemoryless.None;
+
+            renderTextureDesc = tempDesc;
         }
 
         public void Reset()

ScriptableRenderPipeline/HDRenderPipeline/HDRenderPipeline.cs

 
 namespace UnityEngine.Experimental.Rendering.HDPipeline
 {
+    //static void GetScreenSpaceTemporaryRT(CommandBuffer cmd, int nameID,
+    //                                        int depthBufferBits = 0, RenderTextureFormat colorFormat = RenderTextureFormat.Default, RenderTextureReadWrite readWrite = RenderTextureReadWrite.Default,
+    //                                        FilterMode filter = FilterMode.Bilinear, int widthOverride = 0, int heightOverride = 0)
+    //{
+
+    //}
+
     public class GBufferManager
     {
         public const int k_MaxGbuffer = 8;
         RenderTargetIdentifier[] m_ColorMRTs;
         RenderTargetIdentifier[] m_RTIDs = new RenderTargetIdentifier[k_MaxGbuffer];
 
-        public void InitGBuffers(int width, int height, RenderPipelineMaterial deferredMaterial, bool enableBakeShadowMask, CommandBuffer cmd)
+        //public void InitGBuffers(int width, int height, RenderPipelineMaterial deferredMaterial, bool enableBakeShadowMask, CommandBuffer cmd)
+        public void InitGBuffers(RenderTextureDescriptor rtDesc, RenderPipelineMaterial deferredMaterial, bool enableBakeShadowMask, CommandBuffer cmd)
         {
             // Init Gbuffer description
             gbufferCount = deferredMaterial.GetMaterialGBufferCount();
+
+            rtDesc.depthBufferBits = 0;
-                cmd.GetTemporaryRT(HDShaderIDs._GBufferTexture[gbufferIndex], width, height, 0, FilterMode.Point, rtFormat[gbufferIndex], rtReadWrite[gbufferIndex]);
+
+                rtDesc.colorFormat = rtFormat[gbufferIndex];
+                rtDesc.sRGB = (rtReadWrite[gbufferIndex] != RenderTextureReadWrite.Linear);
+
+                cmd.GetTemporaryRT(HDShaderIDs._GBufferTexture[gbufferIndex], rtDesc, FilterMode.Point);
                 m_RTIDs[gbufferIndex] = new RenderTargetIdentifier(HDShaderIDs._GBufferTexture[gbufferIndex]);
             }
 
-                cmd.GetTemporaryRT(HDShaderIDs._ShadowMaskTexture, width, height, 0, FilterMode.Point, Builtin.GetShadowMaskBufferFormat(), Builtin.GetShadowMaskBufferReadWrite());
+
+                rtDesc.colorFormat = Builtin.GetShadowMaskBufferFormat();
+                rtDesc.sRGB = (Builtin.GetShadowMaskBufferReadWrite() != RenderTextureReadWrite.Linear);
+
+                cmd.GetTemporaryRT(HDShaderIDs._ShadowMaskTexture, rtDesc, FilterMode.Point);
                 m_RTIDs[gbufferCount++] = new RenderTargetIdentifier(HDShaderIDs._ShadowMaskTexture);
             }
 
                 cmd.ReleaseTemporaryRT(HDShaderIDs._VelocityTexture);
-                cmd.GetTemporaryRT(HDShaderIDs._VelocityTexture, width, height, 0, FilterMode.Point, Builtin.GetVelocityBufferFormat(), Builtin.GetVelocityBufferReadWrite());
+
+                rtDesc.colorFormat = Builtin.GetVelocityBufferFormat();
+                rtDesc.sRGB = (Builtin.GetVelocityBufferReadWrite() != RenderTextureReadWrite.Linear);
+
+                cmd.GetTemporaryRT(HDShaderIDs._VelocityTexture, rtDesc, FilterMode.Point);
                 m_RTIDs[gbufferCount++] = new RenderTargetIdentifier(HDShaderIDs._VelocityTexture);
             }
         }
 
                     if (!camera.useForwardOnly)
                     {
-                        m_GbufferManager.InitGBuffers(w, h, m_DeferredMaterial, enableBakeShadowMask, cmd);
+                        //m_GbufferManager.InitGBuffers(w, h, m_DeferredMaterial, enableBakeShadowMask, cmd);
+                        m_GbufferManager.InitGBuffers(camera.renderTextureDesc, m_DeferredMaterial, enableBakeShadowMask, cmd);
                         m_SSSBufferManager.InitGBuffers(w, h, m_GbufferManager, cmd);
                     }
                     else