Merge pull request #1028 from Unity-Technologies/hdrp-xr-bigtile

XR support for HDRP Big Tile Pass

ScriptableRenderPipeline/HDRenderPipeline/HDRP/HDStringConstants.cs

         public static readonly int _EnvLightIndexShift = Shader.PropertyToID("_EnvLightIndexShift");
         public static readonly int g_isOrthographic = Shader.PropertyToID("g_isOrthographic");
         public static readonly int g_iNrVisibLights = Shader.PropertyToID("g_iNrVisibLights");
+
+        public static readonly int g_mScrProjectionArr = Shader.PropertyToID("g_mScrProjectionArr");
+        public static readonly int g_mInvScrProjectionArr = Shader.PropertyToID("g_mInvScrProjectionArr");
+
         public static readonly int g_iLog2NumClusters = Shader.PropertyToID("g_iLog2NumClusters");
         public static readonly int g_screenSize = Shader.PropertyToID("g_screenSize");
         public static readonly int g_iNumSamplesMSAA = Shader.PropertyToID("g_iNumSamplesMSAA");

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/LightLoop/LightLoop.cs

         };
         // clustered light list specific buffers and data end
 
-        static int[] s_TempIntArray = new int[2]; // Used to avoid GC stress when calling SetComputeIntParams
+        static int[] s_TempScreenDimArray = new int[2]; // Used to avoid GC stress when calling SetComputeIntParams
 
         FrameSettings m_FrameSettings = null;
         RenderPipelineResources m_Resources = null;
 
             var w = (int)hdCamera.screenSize.x;
             var h = (int)hdCamera.screenSize.y;
-            s_TempIntArray[0] = w;
-            s_TempIntArray[1] = h;
+            s_TempScreenDimArray[0] = w;
+            s_TempScreenDimArray[1] = h;
             var numBigTilesX = (w + 63) / 64;
             var numBigTilesY = (h + 63) / 64;
 
             // enable coarse 2D pass on 64x64 tiles (used for both fptl and clustered).
             if (m_FrameSettings.lightLoopSettings.enableBigTilePrepass)
             {
+                cmd.SetComputeIntParam(buildPerBigTileLightListShader, HDShaderIDs.g_iNrVisibLights, m_lightCount);
-                cmd.SetComputeIntParams(buildPerBigTileLightListShader, HDShaderIDs.g_viDimensions, s_TempIntArray);
+                cmd.SetComputeIntParams(buildPerBigTileLightListShader, HDShaderIDs.g_viDimensions, s_TempScreenDimArray);
+
+                // TODO: These two aren't actually used...
-                cmd.SetComputeIntParam(buildPerBigTileLightListShader, HDShaderIDs.g_iNrVisibLights, m_lightCount);
-                cmd.SetComputeMatrixParam(buildPerBigTileLightListShader, HDShaderIDs.g_mScrProjection, projscrArr[0]);
-                cmd.SetComputeMatrixParam(buildPerBigTileLightListShader, HDShaderIDs.g_mInvScrProjection, invProjscrArr[0]);
+                cmd.SetComputeMatrixArrayParam(buildPerBigTileLightListShader, HDShaderIDs.g_mScrProjectionArr, projscrArr);
+                cmd.SetComputeMatrixArrayParam(buildPerBigTileLightListShader, HDShaderIDs.g_mInvScrProjectionArr, invProjscrArr);
 
                 cmd.SetComputeFloatParam(buildPerBigTileLightListShader, HDShaderIDs.g_fNearPlane, camera.nearClipPlane);
                 cmd.SetComputeFloatParam(buildPerBigTileLightListShader, HDShaderIDs.g_fFarPlane, camera.farClipPlane);
                 cmd.SetComputeBufferParam(buildPerBigTileLightListShader, s_GenListPerBigTileKernel, HDShaderIDs.g_data, s_ConvexBoundsBuffer);
-                cmd.DispatchCompute(buildPerBigTileLightListShader, s_GenListPerBigTileKernel, numBigTilesX, numBigTilesY, 1);
+
+                int tgZ = m_FrameSettings.enableStereo ? 2 : 1;
+                cmd.DispatchCompute(buildPerBigTileLightListShader, s_GenListPerBigTileKernel, numBigTilesX, numBigTilesY, tgZ);
             }
 
             var numTilesX = GetNumTileFtplX(hdCamera);
             if (m_FrameSettings.lightLoopSettings.isFptlEnabled)
             {
                 cmd.SetComputeIntParam(buildPerTileLightListShader, HDShaderIDs.g_isOrthographic, isOrthographic ? 1 : 0);
-                cmd.SetComputeIntParams(buildPerTileLightListShader, HDShaderIDs.g_viDimensions, s_TempIntArray);
+                cmd.SetComputeIntParams(buildPerTileLightListShader, HDShaderIDs.g_viDimensions, s_TempScreenDimArray);
                 cmd.SetComputeIntParam(buildPerTileLightListShader, HDShaderIDs._EnvLightIndexShift, m_lightList.lights.Count);
                 cmd.SetComputeIntParam(buildPerTileLightListShader, HDShaderIDs._DecalIndexShift, m_lightList.lights.Count + m_lightList.envLights.Count);
                 cmd.SetComputeIntParam(buildPerTileLightListShader, HDShaderIDs.g_iNrVisibLights, m_lightCount);
                     }
 
                     cmd.SetComputeIntParam(buildMaterialFlagsShader, HDShaderIDs.g_BaseFeatureFlags, (int)baseFeatureFlags);
-                    cmd.SetComputeIntParams(buildMaterialFlagsShader, HDShaderIDs.g_viDimensions, s_TempIntArray);
+                    cmd.SetComputeIntParams(buildMaterialFlagsShader, HDShaderIDs.g_viDimensions, s_TempScreenDimArray);
                     cmd.SetComputeBufferParam(buildMaterialFlagsShader, buildMaterialFlagsKernel, HDShaderIDs.g_TileFeatureFlags, s_TileFeatureFlags);
 
                     cmd.SetComputeTextureParam(buildMaterialFlagsShader, buildMaterialFlagsKernel, HDShaderIDs._StencilTexture, stencilTextureRT);

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/LightLoop/lightlistbuild-bigtile.compute

 #include "LightLoop.cs.hlsl"
 #include "LightingConvexHullUtils.hlsl"
 #include "SortingComputeUtils.hlsl"
+#include "LightCullUtils.hlsl"
 
 #pragma only_renderers d3d11 ps4 xboxone vulkan metal
 
 
 uniform int g_iNrVisibLights;
 uniform uint2 g_viDimensions;
-uniform float4x4 g_mInvScrProjection;
-uniform float4x4 g_mScrProjection;
+
+uniform float4x4 g_mInvScrProjectionArr[2];
+uniform float4x4 g_mScrProjectionArr[2];
+
+// TODO: These aren't used, we should remove them
 uniform int _EnvLightIndexShift;
 uniform int _DecalIndexShift;
 
 groupshared unsigned int lightsListLDS[MAX_NR_BIG_TILE_LIGHTS_PLUS_ONE];
 groupshared uint lightOffs;
 
+// TODO: Remove this function and g_mInvScrProjectionArr from constants.
+// Only usage of that constant.
+    float4x4 g_mInvScrProjection = g_mInvScrProjectionArr[0];
+
     // for perspective projection m22 is zero and m23 is +1/-1 (depends on left/right hand proj)
 	// however this function must also work for orthographic projection so we keep it like this.
     float m22 = g_mInvScrProjection[2].z, m23 = g_mInvScrProjection[2].w;
     //return v4Pres.z / v4Pres.w;
 }
 
-float3 GetViewPosFromLinDepth(float2 v2ScrPos, float fLinDepth)
+float3 GetViewPosFromLinDepth(float2 v2ScrPos, float fLinDepth, uint eyeIndex)
+    float4x4 g_mScrProjection = g_mScrProjectionArr[eyeIndex];
+
 	bool isOrthographic = g_isOrthographic!=0;
 	float fSx = g_mScrProjection[0].x;
 	float fSy = g_mScrProjection[1].y;
 	return float3(isOrthographic ? p.xy : (fLinDepth*p.xy), fLinDepth);
 }
 
-float GetOnePixDiagWorldDistAtDepthOne()
+float GetOnePixDiagWorldDistAtDepthOne(uint eyeIndex)
+    float4x4 g_mScrProjection = g_mScrProjectionArr[eyeIndex];
+
 	float fSx = g_mScrProjection[0].x;
 	float fSy = g_mScrProjection[1].y;
 
 
 #ifdef PERFORM_SPHERICAL_INTERSECTION_TESTS
-void SphericalIntersectionTests(uint threadID, int iNrCoarseLights, float2 screenCoordinate);
+void SphericalIntersectionTests(uint threadID, int iNrCoarseLights, float2 screenCoordinate, uint eyeIndex);
-void CullByExactEdgeTests(uint threadID, int iNrCoarseLights, uint2 viTilLL, uint2 viTilUR);
+void CullByExactEdgeTests(uint threadID, int iNrCoarseLights, uint2 viTilLL, uint2 viTilUR, uint eyeIndex);
 #endif
 
 
 void BigTileLightListGen(uint threadID : SV_GroupIndex, uint3 u3GroupID : SV_GroupID)
 {
+    uint eyeIndex = u3GroupID.z;
+
 	uint2 tileIDX = u3GroupID.xy;
 	uint t=threadID;
 
 	GroupMemoryBarrierWithGroupSync();
 #endif
 
-
+    // Raw pixel coordinates of tile
+    // 'Normalized' coordinates of tile
 	float2 vTileLL = float2(viTilLL.x/(float) iWidth, viTilLL.y/(float) iHeight);
 	float2 vTileUR = float2(viTilUR.x/(float) iWidth, viTilUR.y/(float) iHeight);
 
-		const float2 vMi = g_vBoundsBuffer[l].xy;
-		const float2 vMa = g_vBoundsBuffer[l+g_iNrVisibLights].xy;
+        const ScreenSpaceBoundsIndices boundsIndices = GenerateScreenSpaceBoundsIndices(l, g_iNrVisibLights, eyeIndex);
+        const float2 vMi = g_vBoundsBuffer[boundsIndices.min].xy;
+        const float2 vMa = g_vBoundsBuffer[boundsIndices.max].xy;
 
 		if( all(vMa>vTileLL) && all(vMi<vTileUR))
 		{
+
 			if(uIndex<MAX_NR_BIGTILE_LIGHTS) lightsListLDS[uIndex] = l;		// add to light list
 		}
 	}
 	int iNrCoarseLights = min(lightOffs,MAX_NR_BIGTILE_LIGHTS);
 
 #ifdef PERFORM_SPHERICAL_INTERSECTION_TESTS
-	SphericalIntersectionTests( t, iNrCoarseLights, float2(min(viTilLL.xy+uint2(64/2,64/2), uint2(iWidth-1, iHeight-1))) );
+	SphericalIntersectionTests( t, iNrCoarseLights, float2(min(viTilLL.xy+uint2(64/2,64/2), uint2(iWidth-1, iHeight-1))), eyeIndex );
-	CullByExactEdgeTests(t, iNrCoarseLights, viTilLL.xy, viTilUR.xy);
+	CullByExactEdgeTests(t, iNrCoarseLights, viTilLL.xy, viTilUR.xy, eyeIndex);
 #endif
 
 
 	GroupMemoryBarrierWithGroupSync();
 	iNrCoarseLights = lightOffs;
 
-	int offs = tileIDX.y*nrBigTilesX + tileIDX.x;
+    int offs = tileIDX.y*nrBigTilesX + tileIDX.x + (eyeIndex * nrBigTilesX * nrBigTilesY);
 
 	for(i=t; i<(iNrCoarseLights+1); i+=NR_THREADS)
 		g_vLightList[MAX_NR_BIG_TILE_LIGHTS_PLUS_ONE*offs + i] = i==0 ? iNrCoarseLights : lightsListLDS[max(i-1, 0)];
 #ifdef PERFORM_SPHERICAL_INTERSECTION_TESTS
-void SphericalIntersectionTests(uint threadID, int iNrCoarseLights, float2 screenCoordinate)
+void SphericalIntersectionTests(uint threadID, int iNrCoarseLights, float2 screenCoordinate, uint eyeIndex)
-	float3 V = GetViewPosFromLinDepth( screenCoordinate, 1.0);
+	float3 V = GetViewPosFromLinDepth( screenCoordinate, 1.0, eyeIndex);
-	float3 V = GetViewPosFromLinDepth( screenCoordinate, -1.0);
+	float3 V = GetViewPosFromLinDepth( screenCoordinate, -1.0, eyeIndex);
-	float onePixDiagDist = GetOnePixDiagWorldDistAtDepthOne();
+	float onePixDiagDist = GetOnePixDiagWorldDistAtDepthOne(eyeIndex);
-		SFiniteLightBound lgtDat = g_data[lightsListLDS[l]];
+        const int boundIndex = GenerateLightCullDataIndex(lightsListLDS[l], g_iNrVisibLights, eyeIndex);
+        SFiniteLightBound lgtDat = g_data[boundIndex];
 
 		if( !DoesSphereOverlapTile(V, halfTileSizeAtZDistOne, lgtDat.center.xyz, lgtDat.radius, g_isOrthographic!=0) )
 			lightsListLDS[l]=UINT_MAX;
 
 
 #ifdef EXACT_EDGE_TESTS
-float3 GetTileVertex(uint2 viTilLL, uint2 viTilUR, int i, float fTileFarPlane)
+float3 GetTileVertex(uint2 viTilLL, uint2 viTilUR, int i, float fTileFarPlane, uint eyeIndex)
 {
 	float x = (i&1)==0 ? viTilLL.x : viTilUR.x;
 	float y = (i&2)==0 ? viTilLL.y : viTilUR.y;
 #endif
-	return GetViewPosFromLinDepth( float2(x, y), z);
+	return GetViewPosFromLinDepth( float2(x, y), z, eyeIndex);
-void GetFrustEdge(out float3 vP0, out float3 vE0, const int e0, uint2 viTilLL, uint2 viTilUR, float fTileFarPlane)
+void GetFrustEdge(out float3 vP0, out float3 vE0, const int e0, uint2 viTilLL, uint2 viTilUR, float fTileFarPlane, uint eyeIndex)
-	vP0 = GetTileVertex(uint2(viTilLL.x, viTilUR.y), uint2(viTilUR.x, viTilLL.y), i, fTileFarPlane);
+	vP0 = GetTileVertex(uint2(viTilLL.x, viTilUR.y), uint2(viTilUR.x, viTilLL.y), i, fTileFarPlane, eyeIndex);
 
 #if USE_LEFT_HAND_CAMERA_SPACE
 	float3 edgeSectionZero = g_isOrthographic==0 ? vP0 : float3(0.0,0.0,1.0);
 	vE0 = iSection == 0 ? edgeSectionZero : (((iSwizzle & 0x2) == 0 ? 1.0f : (-1.0f)) * ((int)(iSwizzle & 0x1) == (iSwizzle >> 1) ? float3(1, 0, 0) : float3(0, 1, 0)));
 }
 
-void CullByExactEdgeTests(uint threadID, int iNrCoarseLights, uint2 viTilLL, uint2 viTilUR)
+void CullByExactEdgeTests(uint threadID, int iNrCoarseLights, uint2 viTilLL, uint2 viTilUR, uint eyeIndex)
 {
 	const bool bOnlyNeedFrustumSideEdges = true;
 	const int nrFrustEdges = bOnlyNeedFrustumSideEdges ? 4 : 8;	// max 8 since we never need to test 4 far edges of frustum since they are identical vectors to near edges and plane is placed at vP0 on light hull.
 	{
 		const uint idxCoarse = lightsListLDS[l];
+        const int bufIdxCoarse = GenerateLightCullDataIndex(idxCoarse, g_iNrVisibLights, eyeIndex);
-		if(canEnter) canEnter = _LightVolumeData[idxCoarse].lightVolume != LIGHTVOLUMETYPE_SPHERE;		// don't bother doing edge tests for sphere lights since these have camera aligned bboxes.
+
+        if(canEnter) canEnter = _LightVolumeData[bufIdxCoarse].lightVolume != LIGHTVOLUMETYPE_SPHERE;		// don't bother doing edge tests for sphere lights since these have camera aligned bboxes.
-			SFiniteLightBound lgtDat = g_data[idxCoarse];
+            SFiniteLightBound lgtDat = g_data[bufIdxCoarse];
 
 			const float3 boxX = lgtDat.boxAxisX.xyz;
 			const float3 boxY = lgtDat.boxAxisY.xyz;
 
 
 				float3 vP1, vE1;
-				GetFrustEdge(vP1, vE1, e1, viTilLL, viTilUR, g_fFarPlane);
+				GetFrustEdge(vP1, vE1, e1, viTilLL, viTilUR, g_fFarPlane, eyeIndex);
 
 				// potential separation plane
 				float3 vN = cross(vE0, vE1);
 				positive=0; negative=0;
 				for(int j=0; j<8; j++)
 				{
-					float3 vPf = GetTileVertex(viTilLL, viTilUR, j, g_fFarPlane);
+					float3 vPf = GetTileVertex(viTilLL, viTilUR, j, g_fFarPlane, eyeIndex);
 					float fSignDist = dot(vN, vPf-vP0);
 					if(fSignDist>0) ++positive; else if(fSignDist<0) ++negative;
 				}

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/LightLoop/scrbound.compute

 
 #include "CoreRP/ShaderLibrary/common.hlsl"
 #include "LightLoop.cs.hlsl"
+#include "LightCullUtils.hlsl"
 
 #pragma only_renderers d3d11 ps4 xboxone vulkan metal
 
 	const int lgtIndex = subLigt+(int) g*8;
 	const int sideIndex = (int) (t%8);
 
-    const int eyeAdjustedLgtIndex = lgtIndex + (eyeIndex * g_iNrVisibLights);
+    const int eyeAdjustedLgtIndex = GenerateLightCullDataIndex(lgtIndex, g_iNrVisibLights, eyeIndex);
     SFiniteLightBound lgtDat = g_data[eyeAdjustedLgtIndex];
 
 	const float3 boxX = lgtDat.boxAxisX.xyz;
             // Each light's AABB is represented by two float3s, the min and max of the box.
             // And for stereo, we have two sets of lights.  Therefore, each eye has a set of mins, followed by
             // a set of maxs, and each set is equal to g_iNrVisibLights.
-            const int eyeBaseIndex = eyeIndex * g_iNrVisibLights * 2;
-            const int minIndex = eyeBaseIndex + lgtIndex + 0;
-            const int maxIndex = eyeBaseIndex + lgtIndex + (int)g_iNrVisibLights;
-            g_vBoundsBuffer[minIndex] = float3(0.5*vMin.x + 0.5, 0.5*vMin.y + 0.5, vMin.z*VIEWPORT_SCALE_Z);
-            g_vBoundsBuffer[maxIndex] = float3(0.5*vMax.x + 0.5, 0.5*vMax.y + 0.5, vMax.z*VIEWPORT_SCALE_Z);
+            const ScreenSpaceBoundsIndices boundsIndices = GenerateScreenSpaceBoundsIndices(lgtIndex, g_iNrVisibLights, eyeIndex);
+
+            g_vBoundsBuffer[boundsIndices.min] = float3(0.5*vMin.x + 0.5, 0.5*vMin.y + 0.5, vMin.z*VIEWPORT_SCALE_Z);
+            g_vBoundsBuffer[boundsIndices.max] = float3(0.5*vMax.x + 0.5, 0.5*vMax.y + 0.5, vMax.z*VIEWPORT_SCALE_Z);
 		}
 	}
 }

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/LightLoop/LightCullUtils.hlsl

+#ifndef __LIGHTCULLUTILS_H__
+#define __LIGHTCULLUTILS_H__
+
+// Used to index into our SFiniteLightBound (g_data) and 
+// LightVolumeData (_LightVolumeData) buffers.
+int GenerateLightCullDataIndex(int lightIndex, uint numVisibleLights, uint eyeIndex)
+{
+    // For monoscopic, there is just one set of light cull data structs.
+    // In stereo, all of the left eye structs are first, followed by the right eye structs.
+    const int perEyeBaseIndex = (int)eyeIndex * (int)numVisibleLights;
+    return (perEyeBaseIndex + lightIndex);
+}
+
+struct ScreenSpaceBoundsIndices
+{
+    int min;
+    int max;
+};
+
+// The returned values are used to index into our AABB screen space bounding box buffer
+// Usually named g_vBoundsBuffer.  The two values represent the min/max indices.
+ScreenSpaceBoundsIndices GenerateScreenSpaceBoundsIndices(int lightIndex, uint numVisibleLights, uint eyeIndex)
+{
+    // In the monoscopic mode, there is one set of bounds (min,max -> 2 * g_iNrVisibLights)
+    // In stereo, there are two sets of bounds (leftMin, leftMax, rightMin, rightMax -> 4 * g_iNrVisibLights)
+    const int eyeRelativeBase = (int)eyeIndex * 2 * (int)numVisibleLights;
+
+    ScreenSpaceBoundsIndices indices;
+    indices.min = eyeRelativeBase + lightIndex;
+    indices.max = eyeRelativeBase + lightIndex + (int)numVisibleLights;
+
+    return indices;
+}
+
+#endif //__LIGHTCULLUTILS_H__

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/LightLoop/LightCullUtils.hlsl.meta

+fileFormatVersion: 2
+guid: 1c2274cd4aa7374419016ddf7360a620
+ShaderImporter:
+  externalObjects: {}
+  defaultTextures: []
+  nonModifiableTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: