Lot of synchronization changes

res/shaders/DepthCullingMesh.slang

@@ -0,0 +1,60 @@
+import Common;
+import Scene;
+import VertexData;
+import MaterialParameter;
+
+struct PrimitiveAttributes
+{
+#ifdef VISIBILITY
+    uint32_t prim : SV_PrimitiveID;
+#endif
+	bool cull: SV_CullPrimitive;
+};
+
+[numthreads(MESH_GROUP_SIZE, 1, 1)]
+[outputtopology("triangle")]
+[shader("mesh")]
+void meshMain(
+    in uint threadID: SV_GroupThreadID,
+    in uint groupID: SV_GroupID,
+    in payload MeshPayload meshPayload,
+    out vertices FragmentParameter vertices[MAX_VERTICES],
+    out indices uint3 indices[MAX_PRIMITIVES],
+    out primitives PrimitiveAttributes prim[MAX_PRIMITIVES]
+) {
+    // meshlet number relative to start for this instance
+    uint meshletNumber = meshPayload.culledMeshlets[groupID];
+    uint meshletId = meshPayload.cullingOffset + meshletNumber;
+    InstanceData inst = pScene.instances[meshPayload.instanceId];
+    MeshletDescription m = pScene.meshletInfos[meshPayload.meshletOffset + meshletNumber];
+    MeshletCullingInfo cull = pScene.cullingInfos[meshletId];
+	SetMeshOutputCounts(m.vertexCount, m.primitiveCount);
+	
+	for(uint i = threadID; i < MAX_PRIMITIVES; i += MESH_GROUP_SIZE)
+	{
+		uint p = min(i, m.primitiveCount - 1);
+		{
+			uint local_idx0 = pScene.primitiveIndices[m.primitiveOffset + (p * 3) + 0];
+			uint local_idx1 = pScene.primitiveIndices[m.primitiveOffset + (p * 3) + 1];
+			uint local_idx2 = pScene.primitiveIndices[m.primitiveOffset + (p * 3) + 2];
+            indices[p] = uint3(local_idx0, local_idx1, local_idx2);
+            prim[p].cull = false;//!cull.triangleCulled(p);
+#ifdef VISIBILITY
+            prim[p].prim = encodePrimitive(p, meshletId);
+#endif
+		}
+	}
+	for(uint i = threadID; i < MAX_VERTICES; i += MESH_GROUP_SIZE)
+	{
+		uint v = min(i, m.vertexCount - 1);
+		{
+			uint vertexIndex = pScene.vertexIndices[m.vertexOffset + v];
+#ifdef POS_ONLY
+            VertexAttributes attr = pVertexData.getPosition(m.indicesOffset + vertexIndex);
+#else
+			VertexAttributes attr = pVertexData.getAttributes(m.indicesOffset + vertexIndex);
+#endif
+			vertices[v] = attr.getParameter(inst.transformMatrix);
+		}
+	}
+}

res/shaders/VisibilityCompute.slang

@@ -8,15 +8,22 @@ struct VisibilityCullingData
 };
 ParameterBlock<VisibilityCullingData> pVisibilityParams;
 
-[numthreads(BLOCK_SIZE, BLOCK_SIZE, 1)]
+[numthreads(BLOCK_SIZE, 1, 1)]
 [shader("compute")]
 void computeMain(
     uint3 dispatchThreadID: SV_DispatchThreadID,
 ){
-    int3 texCoords = int3(dispatchThreadID.xy, 0);
-    uint encoded = pVisibilityParams.visibilityTexture.Load(texCoords).r;
-    uint2 decoded = decodePrimitive(encoded);
-    uint arrIdx = decoded.x / 32;
-    uint bit = decoded.x % 32;
-    pVisibilityParams.cullingInfos[decoded.y].visible[arrIdx] |= (1 << bit);
+    //int3 texCoords = int3(dispatchThreadID.xy, 0);
+    //uint encoded = pVisibilityParams.visibilityTexture.Load(texCoords).r;
+    //uint2 decoded = decodePrimitive(encoded);
+    //uint arrIdx = decoded.x / 32;
+    //uint bit = decoded.x % 32;
+    pVisibilityParams.cullingInfos[dispatchThreadID.x].visible[0] = 0x0;
+    pVisibilityParams.cullingInfos[dispatchThreadID.x].visible[1] = 0x0;
+    pVisibilityParams.cullingInfos[dispatchThreadID.x].visible[2] = 0x0;
+    pVisibilityParams.cullingInfos[dispatchThreadID.x].visible[3] = 0x0;
+    pVisibilityParams.cullingInfos[dispatchThreadID.x].visible[4] = 0x0;
+    pVisibilityParams.cullingInfos[dispatchThreadID.x].visible[5] = 0x0;
+    pVisibilityParams.cullingInfos[dispatchThreadID.x].visible[6] = 0x0;
+    pVisibilityParams.cullingInfos[dispatchThreadID.x].visible[7] = 0x0;
 }

res/shaders/lib/Scene.slang

@@ -48,7 +48,12 @@ struct MeshletCullingInfo
     }
     bool anyVisible()
     {
-        return (visible[0] + visible[1] + visible[2] + visible[3]) != 0;
+        uint result = 0;
+        for(uint i = 0; i < MAX_PRIMITIVES / 32; ++i)
+        {
+            result |= visible[i];
+        }
+        return result != 0;
     }
 };