Improve cluster building performance

Author: pezcode

src/Renderer/ClusteredRenderer.cpp

@@ -5,9 +5,11 @@
 #include <bx/string.h>
 #include <glm/matrix.hpp>
 #include <glm/gtc/type_ptr.hpp>
+#include <glm/ext/matrix_relational.hpp>
 
 ClusteredRenderer::ClusteredRenderer(const Scene* scene) :
     Renderer(scene),
+    oldProjMat(glm::zero<glm::mat4>()),
     clusterBuildingComputeProgram(BGFX_INVALID_HANDLE),
     lightCullingComputeProgram(BGFX_INVALID_HANDLE),
     lightingProgram(BGFX_INVALID_HANDLE),
@@ -54,20 +56,18 @@ void ClusteredRenderer::onRender(float dt)
         vLightCulling,
         vLighting
     };
-        
+
     bgfx::setViewName(vClusterBuilding, "Cluster building pass (compute)");
-    //bgfx::setViewClear(vClusterBuilding, BGFX_CLEAR_NONE);
+    bgfx::setViewClear(vClusterBuilding, BGFX_CLEAR_NONE);
     // set u_viewRect for screen2Eye to work correctly
     bgfx::setViewRect(vClusterBuilding, 0, 0, width, height);
     // this could be set by a different renderer, reset it (D3D12 cares and crashes)
     bgfx::setViewFrameBuffer(vClusterBuilding, BGFX_INVALID_HANDLE);
-    //bgfx::touch(vClusterBuilding);
 
     bgfx::setViewName(vLightCulling, "Clustered light culling pass (compute)");
-    //bgfx::setViewClear(vLightCulling, BGFX_CLEAR_NONE);
+    bgfx::setViewClear(vLightCulling, BGFX_CLEAR_NONE);
     bgfx::setViewRect(vLightCulling, 0, 0, width, height);
     bgfx::setViewFrameBuffer(vLightCulling, BGFX_INVALID_HANDLE);
-    //bgfx::touch(vLightCulling);
 
     bgfx::setViewName(vLighting, "Clustered lighting pass");
     bgfx::setViewClear(vLighting, BGFX_CLEAR_COLOR | BGFX_CLEAR_DEPTH, clearColor, 1.0f, 0);
@@ -88,24 +88,37 @@ void ClusteredRenderer::onRender(float dt)
 
     // cluster building
 
-    clusters.bindBuffers(false); // write access, all buffers
+    // only run this step if the camera parameters changed (aspect ratio, fov, near/far plane)
+    // cluster bounds are saved in camera coordinates so they don't change with camera movement
+
+    // ideally we'd compare the relative error here but a correct implementation would involve
+    // a bunch of costly matrix operations: https://floating-point-gui.de/errors/comparison/
+    // comparing the absolute error against a rather small epsilon here works as long as the values
+    // in the projection matrix aren't getting too large
+    bool buildClusters = glm::any(glm::notEqual(projMat, oldProjMat, 0.00001f));
+    if(buildClusters)
+    {
+        oldProjMat = projMat;
+
+        clusters.bindBuffers(false); // write access, all buffers
 
-    bgfx::dispatch(vClusterBuilding,
-                    clusterBuildingComputeProgram,
-                    ClusterShader::CLUSTERS_X,
-                    ClusterShader::CLUSTERS_Y,
-                    ClusterShader::CLUSTERS_Z);
+        bgfx::dispatch(vClusterBuilding,
+                       clusterBuildingComputeProgram,
+                       ClusterShader::CLUSTERS_X / ClusterShader::CLUSTERS_X_THREADS,
+                       ClusterShader::CLUSTERS_Y / ClusterShader::CLUSTERS_Y_THREADS,
+                       ClusterShader::CLUSTERS_Z / ClusterShader::CLUSTERS_Z_THREADS);
+    }
 
     // light culling
 
     lights.bindLights(scene);
     clusters.bindBuffers(false); // write access, all buffers
 
     bgfx::dispatch(vLightCulling,
-                    lightCullingComputeProgram,
-                    ClusterShader::CLUSTERS_X / ClusterShader::CLUSTERS_X_THREADS,
-                    ClusterShader::CLUSTERS_Y / ClusterShader::CLUSTERS_Y_THREADS,
-                    ClusterShader::CLUSTERS_Z / ClusterShader::CLUSTERS_Z_THREADS);
+                   lightCullingComputeProgram,
+                   ClusterShader::CLUSTERS_X / ClusterShader::CLUSTERS_X_THREADS,
+                   ClusterShader::CLUSTERS_Y / ClusterShader::CLUSTERS_Y_THREADS,
+                   ClusterShader::CLUSTERS_Z / ClusterShader::CLUSTERS_Z_THREADS);
     // lighting
 
     bool debugVis = variables["DEBUG_VIS"] == "true";

src/Renderer/ClusteredRenderer.h

@@ -15,6 +15,8 @@ class ClusteredRenderer : public Renderer
     virtual void onShutdown() override;
 
 private:
+    glm::mat4 oldProjMat;
+
     bgfx::ProgramHandle clusterBuildingComputeProgram;
     bgfx::ProgramHandle lightCullingComputeProgram;
     bgfx::ProgramHandle lightingProgram;

src/Renderer/Shaders/clusters.sh

@@ -14,6 +14,7 @@
 #define CLUSTERS_Z 24
 
 // workgroup size of the culling compute shader
+// D3D compute shaders only allow up to 1024 threads per workgroup
 #define CLUSTERS_X_THREADS 16
 #define CLUSTERS_Y_THREADS 8
 #define CLUSTERS_Z_THREADS 4
@@ -37,13 +38,12 @@ uniform vec4 u_zNearFarVec;
 // light indices belonging to clusters
 CLUSTER_BUFFER(b_clusterLightIndices, uint, SAMPLER_CLUSTERS_LIGHTINDICES);
 // for each cluster: (start index in b_clusterLightIndices, number of point lights, empty, empty)
+// uint because uvec4 doesn't seem to work with D3D11
 CLUSTER_BUFFER(b_clusterLightGrid, uint, SAMPLER_CLUSTERS_LIGHTGRID);
-// uvec4 doesn't seem to work with DX11
-//CLUSTER_BUFFER(b_clusterLightGrid, uvec4, SAMPLER_CLUSTERS_LIGHTGRID);
 
 // these are only needed for building clusters and light culling, not in the fragment shader
 #ifdef WRITE_CLUSTERS
-// list of clusters (2 vec4's each, min + max pos)
+// list of clusters (2 vec4's each, min + max pos for AABB)
 CLUSTER_BUFFER(b_clusters, vec4, SAMPLER_CLUSTERS_CLUSTERS);
 // atomic counter for building the light grid
 // must be reset to 0 every frame
@@ -60,6 +60,8 @@ struct LightGrid
 {
     uint offset;
     uint pointLights;
+    // TODO
+    //uint spotLights;
 };
 
 #ifdef WRITE_CLUSTERS
@@ -74,7 +76,6 @@ Cluster getCluster(uint index)
 
 LightGrid getLightGrid(uint cluster)
 {
-    //uvec4 gridvec = b_clusterLightGrid[cluster];
     uvec4 gridvec = uvec4(b_clusterLightGrid[4 * cluster + 0], b_clusterLightGrid[4 * cluster + 1], 0, 0);
     LightGrid grid;
     grid.offset = gridvec.x;
@@ -90,6 +91,8 @@ uint getGridLightIndex(uint start, uint offset)
 // cluster depth index from depth in screen coordinates (gl_FragCoord.z)
 uint getClusterZIndex(float screenDepth)
 {
+    // this can be calculated on the CPU and passed as a uniform
+    // only leaving it here to keep most of the relevant code in the shaders for learning purposes
     float scale = float(CLUSTERS_Z) / log(u_zFar / u_zNear);
     float bias = -(float(CLUSTERS_Z) * log(u_zNear) / log(u_zFar / u_zNear));
 

src/Renderer/Shaders/cs_clustered_clusterbuilding.sc

@@ -10,30 +10,29 @@
 // z-subdivision concept from http://advances.realtimerendering.com/s2016/Siggraph2016_idTech6.pdf
 
 // bgfx doesn't define this in shaders
-#define gl_WorkGroupSize uvec3(1, 1, 1)
-#define gl_NumWorkGroups uvec3(CLUSTERS_X, CLUSTERS_Y, CLUSTERS_Z)
+#define gl_WorkGroupSize uvec3(CLUSTERS_X_THREADS, CLUSTERS_Y_THREADS, CLUSTERS_Z_THREADS)
 
 // each thread handles one cluster
-// TODO use workgroups that fill GPU wavefronts (32 on Nvidia, 64 on AMD)
-NUM_THREADS(1, 1, 1)
+NUM_THREADS(CLUSTERS_X_THREADS, CLUSTERS_Y_THREADS, CLUSTERS_Z_THREADS)
 void main()
 {
-    const uint clusterIndex = gl_WorkGroupID.z * gl_NumWorkGroups.x * gl_NumWorkGroups.y +
-                              gl_WorkGroupID.y * gl_NumWorkGroups.x +
-                              gl_WorkGroupID.x;
+    // index calculation must match the inverse operation in the fragment shader (see getClusterIndex)
+    uint clusterIndex = gl_GlobalInvocationID.z * gl_WorkGroupSize.x * gl_WorkGroupSize.y +
+                        gl_GlobalInvocationID.y * gl_WorkGroupSize.x +
+                        gl_GlobalInvocationID.x;
 
     // calculate min (bottom left) and max (top right) xy in screen coordinates
-    vec4 minScreen = vec4(gl_WorkGroupID.xy * u_clusterSizes.xy, 1.0, 1.0);
-    vec4 maxScreen = vec4(vec2(gl_WorkGroupID.x + 1, gl_WorkGroupID.y + 1) * u_clusterSizes.xy, 1.0, 1.0);
+    vec4 minScreen = vec4( gl_GlobalInvocationID.xy               * u_clusterSizes.xy, 1.0, 1.0);
+    vec4 maxScreen = vec4((gl_GlobalInvocationID.xy + vec2(1, 1)) * u_clusterSizes.xy, 1.0, 1.0);
 
     // -> eye coordinates
     // z is the camera far plane (1 in screen coordinates)
     vec3 minEye = screen2Eye(minScreen).xyz;
     vec3 maxEye = screen2Eye(maxScreen).xyz;
 
     // calculate near and far depth edges of the cluster
-    float clusterNear = u_zNear * pow(u_zFar / u_zNear,  gl_WorkGroupID.z      / float(gl_NumWorkGroups.z));
-    float clusterFar  = u_zNear * pow(u_zFar / u_zNear, (gl_WorkGroupID.z + 1) / float(gl_NumWorkGroups.z));
+    float clusterNear = u_zNear * pow(u_zFar / u_zNear,  gl_GlobalInvocationID.z      / float(CLUSTERS_Z));
+    float clusterFar  = u_zNear * pow(u_zFar / u_zNear, (gl_GlobalInvocationID.z + 1) / float(CLUSTERS_Z));
 
     // this calculates the intersection between:
     // - a line from the camera (origin) to the eye point (at the camera's far plane)
@@ -44,17 +43,11 @@ void main()
     vec3 maxNear = maxEye * clusterNear / maxEye.z;
     vec3 maxFar  = maxEye * clusterFar  / maxEye.z;
 
-    // get max extent of the cluster in all dimensions (axis-aligned bounding box)
+    // get extent of the cluster in all dimensions (axis-aligned bounding box)
+    // there is some overlap here but it's easier to calculate intersections with AABB
     vec3 minBounds = min(min(minNear, minFar), min(maxNear, maxFar));
     vec3 maxBounds = max(max(minNear, minFar), max(maxNear, maxFar));
 
     b_clusters[2 * clusterIndex + 0] = vec4(minBounds, 1.0);
     b_clusters[2 * clusterIndex + 1] = vec4(maxBounds, 1.0);
-
-    // reset the atomic counter for the light culling shader
-    // writable compute buffers can't be updated by CPU so do it here
-    if(clusterIndex == 0)
-    {
-        b_globalIndex[0] = 0;
-    }
 }

src/Renderer/Shaders/cs_clustered_lightculling.sc

@@ -10,20 +10,15 @@
 // largely inspired by http://www.aortiz.me/2018/12/21/CG.html
 
 // point lights only for now
+bool pointLightIntersectsCluster(PointLight light, Cluster cluster);
 
-bool pointLightAffectsCluster(PointLight light, Cluster cluster);
-float distsqToCluster(vec3 pos, Cluster cluster);
-
-// bgfx doesn't define this in shaders
 #define gl_WorkGroupSize uvec3(CLUSTERS_X_THREADS, CLUSTERS_Y_THREADS, CLUSTERS_Z_THREADS)
 #define GROUP_SIZE (CLUSTERS_X_THREADS * CLUSTERS_Y_THREADS * CLUSTERS_Z_THREADS)
 
 // light cache for the current work group
 SHARED PointLight lights[GROUP_SIZE];
 
-// work group size
 // each thread handles one cluster
-// D3D compute shaders only seem to allow 1024 threads
 NUM_THREADS(CLUSTERS_X_THREADS, CLUSTERS_Y_THREADS, CLUSTERS_Z_THREADS)
 void main()
 {
@@ -32,11 +27,19 @@ void main()
     uint visibleLights[MAX_LIGHTS_PER_CLUSTER];
     uint visibleCount = 0;
 
-    // the way we calculate the index doesn't really matter here since we write to the same index as we read from the cluster buffer
-    // it only matters that the cluster buildung and fragment shader calculate the cluster index the same way
+    // the way we calculate the index doesn't really matter here since we write to the same index in the light grid as we read from the cluster buffer
     uint clusterIndex = gl_GlobalInvocationID.z * gl_WorkGroupSize.x * gl_WorkGroupSize.y +
                         gl_GlobalInvocationID.y * gl_WorkGroupSize.x +
                         gl_GlobalInvocationID.x;
+
+    // reset the atomic counter
+    // writable compute buffers can't be updated by CPU so do it here
+    if(clusterIndex == 0)
+    {
+        b_globalIndex[0] = 0;
+    }
+
+    Cluster cluster = getCluster(clusterIndex);
 
     // we have a cache of GROUP_SIZE lights
     // have to run this loop several times if we have more than GROUP_SIZE lights
@@ -89,34 +92,30 @@ void main()
     }
 
     // write light grid for this cluster
-    //b_clusterLightGrid[clusterIndex] = uvec4(offset, visibleCount, 0, 0);
     b_clusterLightGrid[4 * clusterIndex + 0] = offset;
     b_clusterLightGrid[4 * clusterIndex + 1] = visibleCount;
-    //b_clusterLightGrid[4 * clusterIndex + 2] = 0; // unused, spot lights etc.
+    // unused, spot lights etc.
+    //b_clusterLightGrid[4 * clusterIndex + 2] = 0;
     //b_clusterLightGrid[4 * clusterIndex + 3] = 0;
 }
 
 // check if light radius extends into the cluster
-bool pointLightAffectsCluster(PointLight light, Cluster cluster)
+bool pointLightIntersectsCluster(PointLight light, Cluster cluster)
 {
     // NOTE: expects light.position to be in view space like the cluster bounds
     // global light list has world space coordinates, but we transform the
     // coordinates in the shared array of lights after copying
-    return distsqToCluster(light.position, cluster) <= (light.radius * light.radius);
-}
 
-// squared distance of the point to planes of the bounding box
-float distsqToCluster(vec3 pos, Cluster cluster)
-{
     // only add distance in either dimension if it's outside the bounding box
 
-    vec3 belowDist = cluster.minBounds - pos;
-    vec3 aboveDist = pos - cluster.maxBounds;
+    vec3 belowDist = cluster.minBounds - light.position;
+    vec3 aboveDist = light.position - cluster.maxBounds;
 
     vec3 isBelow = vec3(greaterThan(belowDist, vec3_splat(0.0)));
     vec3 isAbove = vec3(greaterThan(aboveDist, vec3_splat(0.0)));
 
     vec3 distSqVec = (isBelow * belowDist) + (isAbove * aboveDist);
     float distsq = dot(distSqVec, distSqVec);
-    return distsq;
+
+    return distsq <= (light.radius * light.radius);
 }