Visibility reset doesnt work anymore for some reason

.vscode/launch.json

@@ -6,24 +6,13 @@
     "configurations": [
         {
             "name": "Editor",
-            "type": "cppvsdbg",
+            "type": "lldb",
             "request": "launch",
             "program": "${workspaceRoot}/build/Editor.exe",
             "args": [],
             "cwd": "${workspaceRoot}/build",
-            "console": "internalConsole",
+            "console": "integratedTerminal",
-            "setupCommands": [
+            "breakpointMode": "path",
-                {
-                    "description": "Enable pretty-printing for gdb",
-                    "text": "-enable-pretty-printing",
-                    "ignoreFailures": true
-                },
-                {
-                    "description":  "Set Disassembly Flavor to Intel",
-                    "text": "-gdb-set disassembly-flavor intel",
-                    "ignoreFailures": true
-                }
-            ]
         },
         {
             "name": "Editor (Mac)",

res/shaders/DepthCullingTask.slang

@@ -4,6 +4,10 @@ import Scene;
 groupshared MeshPayload p;
 groupshared uint head;
 groupshared MeshData mesh;
+groupshared InstanceData instance;
+groupshared Frustum viewFrustum;
+
+ParameterBlock<Texture2D> pDepthAttachment;
 
 [numthreads(TASK_GROUP_SIZE, 1, 1)]
 [shader("amplification")]
@@ -14,10 +18,23 @@ void taskMain(
     if (threadID == 0)
     {
         head = 0;
+	    instance = pScene.instances[pOffsets.instanceOffset + groupID];
         mesh = pScene.meshData[pOffsets.instanceOffset + groupID];
         p.instanceId = pOffsets.instanceOffset + groupID;
         p.meshletOffset = mesh.meshletOffset;
         p.cullingOffset = pScene.cullingOffsets[p.instanceId];
+		float3 origin = viewToModel(instance.inverseTransformMatrix, float4(0, 0, 0, 1)).xyz;
+		const float offset = 0.0f;
+		float3 corners[4] = {
+			screenToModel(instance.inverseTransformMatrix, float4(offset, offset, -1.0f, 1.0f)).xyz,
+			screenToModel(instance.inverseTransformMatrix, float4(pViewParams.screenDimensions.x - offset, offset, -1.0f, 1.0f)).xyz,
+			screenToModel(instance.inverseTransformMatrix, float4(offset, pViewParams.screenDimensions.y - offset, -1.0f, 1.0f)).xyz,
+			screenToModel(instance.inverseTransformMatrix, float4(pViewParams.screenDimensions - float2(offset, offset), -1.0f, 1.0f)).xyz
+		};
+		viewFrustum.sides[0] = computePlane(origin, corners[2], corners[0]);
+		viewFrustum.sides[1] = computePlane(origin, corners[1], corners[3]);
+		viewFrustum.sides[2] = computePlane(origin, corners[0], corners[1]);
+		viewFrustum.sides[3] = computePlane(origin, corners[3], corners[2]);
     }
     GroupMemoryBarrierWithGroupSync();
     for (uint i = threadID; i < mesh.numMeshlets; i += TASK_GROUP_SIZE)
@@ -26,11 +43,17 @@ void taskMain(
         uint cull = p.cullingOffset + i;
         MeshletDescription meshlet = pScene.meshletInfos[m];
         MeshletCullingInfo culling = pScene.cullingInfos[cull];
-        if(false)//if(!culling.anyVisible())
+        // if any triangle was visible last frame, it was drawn by the cached pass already
+        if(!culling.anyVisible())
         {
-            uint index;
+#ifdef VIEW_CULLING
-            InterlockedAdd(head, 1, index);
+		    if(meshlet.bounding.insideFrustum(viewFrustum))
-            p.culledMeshlets[index] = i;
+#endif
+            {
+                uint index;
+                InterlockedAdd(head, 1, index);
+                p.culledMeshlets[index] = i;
+            }
         }
     }
     GroupMemoryBarrierWithGroupSync();

res/shaders/DrawListMesh.slang

@@ -38,7 +38,7 @@ void meshMain(
 			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 = cull.triangleCulled(p);
+            prim[p].cull = false;//cull.triangleCulled(p);
 #ifdef VISIBILITY
             prim[p].prim = encodePrimitive(p, meshletId);
 #endif

src/Editor/Asset/MeshLoader.cpp

@@ -151,7 +151,6 @@ void MeshLoader::loadMaterials(const aiScene* scene, const Array<PTextureAsset>&
             if (material->GetTexture(type, index, &texPath, &mapping, &uvIndex, nullptr, nullptr, nullptr) != AI_SUCCESS) {
                 std::cout << "fuck" << std::endl;
             }
-
             std::string textureKey = fmt::format("{0}Texture{1}", paramKey, index);
             auto texFilename = std::filesystem::path(texPath.C_Str());
             PTextureAsset texture;

src/Engine/Graphics/RenderPass/VisibilityPass.cpp

@@ -12,31 +12,15 @@ VisibilityPass::~VisibilityPass() {}
 void VisibilityPass::beginFrame(const Component::Camera& cam) {
     RenderPass::beginFrame(cam);
     cullingBuffer->rotateBuffer(VertexData::getMeshletCount() * sizeof(VertexData::MeshletCullingInfo), true);
-    if (resetVisibility) {
-        Array<VertexData::MeshletCullingInfo> cullingData(VertexData::getMeshletCount());
-        std::memset(cullingData.data(), 0xffff, cullingData.size() * sizeof(VertexData::MeshletCullingInfo));
-
-        cullingBuffer->updateContents(
-            ShaderBufferCreateInfo{.sourceData =
-                                       {
-                                           .size = VertexData::getMeshletCount() * sizeof(VertexData::MeshletCullingInfo),
-                                           .data = (uint8*)cullingData.data(),
-                                       },
-                                   .numElements = VertexData::getMeshletCount()});
-        cullingBuffer->pipelineBarrier(Gfx::SE_ACCESS_TRANSFER_WRITE_BIT, Gfx::SE_PIPELINE_STAGE_TRANSFER_BIT,
-                                       Gfx::SE_ACCESS_MEMORY_WRITE_BIT, Gfx::SE_PIPELINE_STAGE_TOP_OF_PIPE_BIT);
-
-        resetVisibility = false;
-    }
 }
 
 void VisibilityPass::render() {
     cullingBuffer->pipelineBarrier(Gfx::SE_ACCESS_SHADER_READ_BIT, Gfx::SE_PIPELINE_STAGE_MESH_SHADER_BIT_EXT,
                                    Gfx::SE_ACCESS_TRANSFER_WRITE_BIT, Gfx::SE_PIPELINE_STAGE_TRANSFER_BIT);
     cullingBuffer->clear();
+
     cullingBuffer->pipelineBarrier(Gfx::SE_ACCESS_TRANSFER_WRITE_BIT, Gfx::SE_PIPELINE_STAGE_TRANSFER_BIT, Gfx::SE_ACCESS_SHADER_READ_BIT,
                                    Gfx::SE_PIPELINE_STAGE_COMPUTE_SHADER_BIT);
-
     visibilityDescriptor->reset();
     visibilitySet = visibilityDescriptor->allocateDescriptorSet();
     visibilitySet->updateTexture(0, visibilityAttachment.getTexture());

src/Engine/Graphics/Vulkan/Buffer.cpp

@@ -25,7 +25,7 @@ static Map<Vulkan::Buffer*, PendingBuffer> pendingBuffers;
 
 Buffer::Buffer(PGraphics graphics, uint64 size, VkBufferUsageFlags usage, Gfx::QueueType& queueType, bool dynamic, std::string name)
     : graphics(graphics), currentBuffer(0), owner(queueType),
-      usage(usage | VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_TRANSFER_SRC_BIT), dynamic(dynamic), name(name) {
+      usage(usage | VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT), dynamic(dynamic), name(name) {
     createBuffer(size);
 }
 

src/Engine/Graphics/Vulkan/Descriptor.cpp

@@ -170,7 +170,7 @@ DescriptorSet::DescriptorSet(PGraphics graphics, PDescriptorPool owner)
     boundResources.resize(owner->getLayout()->getBindings().size());
 }
 
-DescriptorSet::~DescriptorSet() { vkFreeDescriptorSets(graphics->getDevice(), owner->getHandle(), 1, &setHandle); }
+DescriptorSet::~DescriptorSet() {}
 
 void DescriptorSet::updateBuffer(uint32_t binding, Gfx::PUniformBuffer uniformBuffer) {
     PUniformBuffer vulkanBuffer = uniformBuffer.cast<UniformBuffer>();

src/Engine/Graphics/Vulkan/Graphics.cpp

@@ -51,6 +51,7 @@ void Graphics::init(GraphicsInitializer initInfo) {
     pickPhysicalDevice();
     createDevice(initInfo);
     VmaAllocatorCreateInfo createInfo = {
+        .flags = VMA_ALLOCATOR_CREATE_BUFFER_DEVICE_ADDRESS_BIT,
         .physicalDevice = physicalDevice,
         .device = handle,
         .preferredLargeHeapBlockSize = 0,
@@ -498,6 +499,8 @@ void Graphics::createDevice(GraphicsInitializer initializer) {
 #ifdef __APPLE__
     initializer.deviceExtensions.add("VK_KHR_portability_subset");
 #endif
+    initializer.deviceExtensions.add(VK_KHR_DEFERRED_HOST_OPERATIONS_EXTENSION_NAME);
+    initializer.deviceExtensions.add(VK_KHR_ACCELERATION_STRUCTURE_EXTENSION_NAME);
     VkDeviceCreateInfo deviceInfo = {
         .sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO,
         .pNext = &features11,