Created cull shader

Przemog1 · Przemog1 · commit 5a03c287e383 · 2021-06-22T17:40:49.000+02:00
diff --git a/examples_tests/41.VisibilityBuffer/CMakeLists.txt b/examples_tests/41.VisibilityBuffer/CMakeLists.txt
@@ -4,4 +4,4 @@ if(NOT RES)
 	message(FATAL_ERROR "common.cmake not found. Should be in {repo_root}/cmake directory")
 endif()
 
-nbl_create_executable_project("" "" "" "")
+nbl_create_executable_project(../../src/nbl/ext/DebugDraw/CDraw3DLine.cpp "" "" "")
diff --git a/examples_tests/41.VisibilityBuffer/cull.comp b/examples_tests/41.VisibilityBuffer/cull.comp
@@ -0,0 +1,41 @@
+#version 430 core
+
+#include "rasterizationCommon.h"
+layout(local_size_x = WORKGROUP_SIZE) in;
+
+#include <nbl/builtin/glsl/utils/indirect_commands.glsl>
+
+layout(set=0, binding=0, std430, row_major) restrict readonly buffer PerInstanceCull
+{
+    CullData_t cullData[];
+};
+layout(set=0, binding=1, std430) restrict coherent buffer IndirectDraws
+{
+    nbl_glsl_DrawElementsIndirectCommand_t draws[];
+} commandBuff;
+
+
+
+layout(push_constant, row_major) uniform PushConstants
+{
+    CullShaderData_t data;
+} pc;
+
+
+
+#include <nbl/builtin/glsl/utils/culling.glsl>
+#include <nbl/builtin/glsl/utils/transform.glsl>
+
+
+void main()
+{
+    if (gl_GlobalInvocationID.x >= pc.data.maxBatchCount)
+        return;
+
+    const CullData_t batchCullData = cullData[gl_GlobalInvocationID.x];
+
+    const mat2x3 bbox = mat2x3(batchCullData.aabbMinEdge,batchCullData.aabbMaxEdge);
+    bool couldBeVisible = nbl_glsl_couldBeVisible(pc.data.viewProjMatrix,bbox);
+
+    commandBuff.draws[batchCullData.drawCommandGUID].instanceCount = couldBeVisible == true ? 1 : 0;
+}
diff --git a/examples_tests/41.VisibilityBuffer/cullShaderCommon.h b/examples_tests/41.VisibilityBuffer/cullShaderCommon.h
@@ -0,0 +1,32 @@
+#ifndef _COMMON_INCLUDED_
+#define _COMMON_INCLUDED_
+
+
+#define MAX_TRIANGLES_IN_BATCH 512
+#define MAX_ACCUMULATED_SAMPLES 0x10000
+
+
+#define WORKGROUP_SIZE 256
+
+
+#ifdef __cplusplus
+	#define uint uint32_t
+	struct uvec2
+	{
+		uint x,y;
+	};
+	struct vec2
+	{
+		float x,y;
+	};
+	struct vec3
+	{
+		float x,y,z;
+	};
+	#define vec4 nbl::core::vectorSIMDf
+	#define mat4 nbl::core::matrix4SIMD
+	#define mat4x3 nbl::core::matrix3x4SIMD
+#endif
+
+
+#endif
diff --git a/examples_tests/41.VisibilityBuffer/main.cpp b/examples_tests/41.VisibilityBuffer/main.cpp
@@ -10,12 +10,15 @@
 //! I advise to check out this file, its a basic input handler
 #include "../common/QToQuitEventReceiver.h"
 
+#include "nbl/ext/DebugDraw/CDraw3DLine.h"
+
 using namespace nbl;
 using namespace nbl::core;
 using namespace nbl::asset;
 using namespace nbl::video;
 
 #include "common.h"
+#include "rasterizationCommon.h"
 
 //vt stuff
 using STextureData = asset::ICPUVirtualTexture::SMasterTextureData;
@@ -31,6 +34,8 @@ struct commit_t
     asset::ICPUSampler::E_TEXTURE_CLAMP uwrap;
     asset::ICPUSampler::E_TEXTURE_CLAMP vwrap;
     asset::ICPUSampler::E_TEXTURE_BORDER_COLOR border;
+
+    core::vector<CullData_t> cullData;
 };
 
 constexpr uint32_t TEX_OF_INTEREST_CNT = 6u;
@@ -155,6 +160,18 @@ struct SceneData
     smart_refctd_ptr<IGPUBuffer> ubo;
 };
 
+struct CullShaderData
+{
+    core::smart_refctd_ptr<IGPUBuffer> perBatchCull;
+    core::smart_refctd_ptr<IGPUBuffer> commandBuffer;
+
+    core::smart_refctd_ptr<IGPUComputePipeline> cullPipeline;
+    core::smart_refctd_ptr<IGPUDescriptorSetLayout> cullDSLayout;
+    core::smart_refctd_ptr<IGPUDescriptorSet> cullDS;
+
+    uint32_t maxBatchCount;
+};
+
 using MeshPacker = CCPUMeshPackerV2<DrawElementsIndirectCommand_t>;
 using GPUMeshPacker = CGPUMeshPackerV2<DrawElementsIndirectCommand_t>;
 
@@ -212,6 +229,8 @@ int main()
     auto* am = device->getAssetManager();
     auto* fs = am->getFileSystem();
 
+    auto draw3DLine = ext::DebugDraw::CDraw3DLine::create(driver);
+
     //
     auto createScreenSizedImage = [driver,&params](const E_FORMAT format) -> auto
     {
@@ -250,6 +269,8 @@ int main()
 
     //
     SceneData sceneData;
+    CullShaderData cullShaderData;
+    core::vector<std::pair<ext::DebugDraw::S3DLineVertex, ext::DebugDraw::S3DLineVertex>> dbgLines;
     {
         //
         smart_refctd_ptr<IGPUDescriptorSetLayout> perFrameDSLayout,shadingDSLayout;
@@ -507,6 +528,9 @@ int main()
             core::vector<BatchInstanceData> batchData;
             batchData.reserve(mdiCntBound);
 
+            core::vector<CullData_t> batchCullData(mdiCntBound);
+            auto batchCullDataEnd = batchCullData.begin();
+
             allocDataIt = allocData->begin();
             uint32_t mdiListOffset = 0u;
             for (auto it=pipelineMeshBufferRanges.begin(); it!=pipelineMeshBufferRanges.end()-1u; )
@@ -517,7 +541,8 @@ int main()
                 const uint32_t meshMdiBound = mp->calcMDIStructMaxCount(mbRangeBegin,mbRangeEnd);
                 core::vector<IMeshPackerBase::PackedMeshBufferData> pmbd(std::distance(mbRangeBegin,mbRangeEnd));
                 core::vector<MeshPacker::CombinedDataOffsetTable> cdot(meshMdiBound);
-                uint32_t actualMdiCnt = mp->commit(pmbd.data(),cdot.data(),nullptr,&*allocDataIt,mbRangeBegin,mbRangeEnd);
+                core::vector<aabbox3df> aabbs(meshMdiBound);
+                uint32_t actualMdiCnt = mp->commit(pmbd.data(),cdot.data(),aabbs.data(),&*allocDataIt,mbRangeBegin,mbRangeEnd);
                 allocDataIt += meshMdiBound;
 
                 if (actualMdiCnt==0u)
@@ -526,6 +551,24 @@ int main()
                     _NBL_DEBUG_BREAK_IF(true);
                 }
 
+                for (uint32_t i = 0u; i < actualMdiCnt; i++)
+                {
+                    batchCullDataEnd->aabbMinEdge.x = aabbs[i].MinEdge.X;
+                    batchCullDataEnd->aabbMinEdge.y = aabbs[i].MinEdge.Y;
+                    batchCullDataEnd->aabbMinEdge.z = aabbs[i].MinEdge.Z;
+
+                    batchCullDataEnd->aabbMaxEdge.x = aabbs[i].MaxEdge.X;
+                    batchCullDataEnd->aabbMaxEdge.y = aabbs[i].MaxEdge.Y;
+                    batchCullDataEnd->aabbMaxEdge.z = aabbs[i].MaxEdge.Z;
+
+                    batchCullDataEnd->drawCommandGUID = pmbd[i].mdiParameterOffset + i;
+                    assert(pmbd[i].mdiParameterOffset + i <= pmbd[i].mdiParameterCount);
+
+                    draw3DLine->enqueueBox(dbgLines, aabbs[i], 1.0f, 0.0f, 0.0f, 1.0f, core::matrix3x4SIMD());
+
+                    batchCullDataEnd++;
+                }
+
                 sceneData.pushConstantsData.push_back(mdiListOffset);
                 mdiListOffset += actualMdiCnt;
 
@@ -558,6 +601,10 @@ int main()
             gpump = core::make_smart_refctd_ptr<CGPUMeshPackerV2<>>(driver,mp.get());
             sceneData.mdiBuffer = gpump->getPackerDataStore().MDIDataBuffer;
             sceneData.idxBuffer = gpump->getPackerDataStore().indexBuffer;
+
+            cullShaderData.commandBuffer = gpump->getPackerDataStore().MDIDataBuffer;
+            cullShaderData.maxBatchCount = std::distance(batchCullData.begin(), batchCullDataEnd);
+            cullShaderData.perBatchCull = driver->createFilledDeviceLocalGPUBufferOnDedMem(cullShaderData.maxBatchCount, batchCullData.data());
         }
         mesh_raw->convertToDummyObject(~0u);
 
@@ -738,6 +785,83 @@ int main()
         }
     }
 
+    {
+        SPushConstantRange range{ ISpecializedShader::ESS_COMPUTE,0u,sizeof(CullShaderData_t) };
+        
+        {
+            IGPUDescriptorSetLayout::SBinding bindings[2];
+            bindings[0].binding = 0u;
+            bindings[0].count = 1u;
+            bindings[0].samplers = nullptr;
+            bindings[0].stageFlags = ISpecializedShader::ESS_COMPUTE;
+            bindings[0].type = EDT_STORAGE_BUFFER;
+        
+            bindings[1].binding = 1u;
+            bindings[1].count = 1u;
+            bindings[1].samplers = nullptr;
+            bindings[1].stageFlags = ISpecializedShader::ESS_COMPUTE;
+            bindings[1].type = EDT_STORAGE_BUFFER;
+        
+            cullShaderData.cullDSLayout = driver->createGPUDescriptorSetLayout(bindings, bindings + sizeof(bindings) / sizeof(IGPUDescriptorSetLayout::SBinding));
+        }
+        
+        {
+            IGPUDescriptorSet::SDescriptorInfo infos[2];
+        
+            infos[0].desc = core::smart_refctd_ptr(cullShaderData.perBatchCull);
+            infos[0].buffer.offset = 0u;
+            infos[0].buffer.size = cullShaderData.perBatchCull->getSize();
+        
+            infos[1].desc = core::smart_refctd_ptr(cullShaderData.commandBuffer);
+            infos[1].buffer.offset = 0u;
+            infos[1].buffer.size = cullShaderData.commandBuffer->getSize();
+        
+            cullShaderData.cullDS = driver->createGPUDescriptorSet(smart_refctd_ptr(cullShaderData.cullDSLayout));
+        
+            IGPUDescriptorSet::SWriteDescriptorSet writes[2];
+        
+            for (uint32_t i = 0u; i < 2; i++)
+            {
+                writes[i].dstSet = cullShaderData.cullDS.get();
+                writes[i].binding = i;
+                writes[i].arrayElement = 0u;
+                writes[i].count = 1u;
+                writes[i].descriptorType = EDT_STORAGE_BUFFER;
+                writes[i].info = infos + i;
+            }
+        
+            driver->updateDescriptorSets(sizeof(writes) / sizeof(IGPUDescriptorSet::SWriteDescriptorSet), writes, 0u, nullptr);
+        }
+        
+        asset::IAssetLoader::SAssetLoadParams lp;
+        auto cullShader = IAsset::castDown<ICPUSpecializedShader>(*am->getAsset("../cull.comp", lp).getContents().begin());
+        assert(cullShader);
+        const asset::ICPUShader* unspec = cullShader->getUnspecialized();
+        assert(unspec->containsGLSL());
+        
+        auto gpuCullShader = driver->getGPUObjectsFromAssets(&cullShader, &cullShader + 1u)->begin()[0];
+        
+        auto cullPipelineLayout = driver->createGPUPipelineLayout(&range, &range + 1u, core::smart_refctd_ptr(cullShaderData.cullDSLayout));
+        cullShaderData.cullPipeline = driver->createGPUComputePipeline(nullptr, std::move(cullPipelineLayout), std::move(gpuCullShader));
+    }
+
+    auto cullBatches = [&driver, &cullShaderData](const core::matrix4SIMD& vp)
+    {
+        driver->bindDescriptorSets(EPBP_COMPUTE, cullShaderData.cullPipeline->getLayout(), 0u, 1u, &cullShaderData.cullDS.get(), nullptr);
+        driver->bindComputePipeline(cullShaderData.cullPipeline.get());
+
+        CullShaderData_t cullPushConstants;
+        cullPushConstants.viewProjMatrix = vp;
+        cullPushConstants.viewProjDeterminant = core::determinant(vp);
+        cullPushConstants.maxBatchCount = cullShaderData.maxBatchCount; //TODO: this should be uniform, and set only once
+
+        driver->pushConstants(cullShaderData.cullPipeline->getLayout(), ISpecializedShader::ESS_COMPUTE, 0u, sizeof(CullShaderData_t), &cullPushConstants);
+
+        const uint32_t cullWorkGroups = (cullPushConstants.maxBatchCount - 1u) / WORKGROUP_SIZE + 1u;
+
+        driver->dispatch(cullWorkGroups, 1u, 1u);
+    };
+
     //! we want to move around the scene and view it from different angles
     scene::ICameraSceneNode* camera = smgr->addCameraSceneNodeFPS(0, 100.0f, 0.5f);
 
@@ -748,6 +872,8 @@ int main()
 
     smgr->setActiveCamera(camera);
     
+    //tmp shit
+    core::matrix4SIMD vpFromFirstFrame;
 
     uint64_t lastFPSTime = 0;
     while (device->run() && receiver.keepOpen())
@@ -758,13 +884,17 @@ int main()
         camera->OnAnimate(std::chrono::duration_cast<std::chrono::milliseconds>(device->getTimer()->getTime()).count());
         camera->render();
 
+        if (lastFPSTime == 0)
+            vpFromFirstFrame = camera->getConcatenatedMatrix();
+
         SBasicViewParameters uboData;
         memcpy(uboData.MVP, camera->getConcatenatedMatrix().pointer(), sizeof(core::matrix4SIMD));
         memcpy(uboData.MV, camera->getViewMatrix().pointer(), sizeof(core::matrix3x4SIMD));
         memcpy(uboData.NormalMat, camera->getViewMatrix().pointer(), sizeof(core::matrix3x4SIMD));
         driver->updateBufferRangeViaStagingBuffer(sceneData.ubo.get(), 0u, sizeof(SBasicViewParameters), &uboData);
 
         // TODO: Cull MDIs
+        cullBatches(vpFromFirstFrame);
 
         driver->setRenderTarget(visBuffer);
         driver->clearZBuffer();
@@ -788,6 +918,9 @@ int main()
             );
         }
 
+        //draw aabbs
+        draw3DLine->draw(camera->getConcatenatedMatrix(), dbgLines);
+
         // shade
         driver->bindDescriptorSets(video::EPBP_COMPUTE,sceneData.shadeVBufferPpln->getLayout(),0u,4u,ds,nullptr);
         driver->bindComputePipeline(sceneData.shadeVBufferPpln.get());
@@ -800,6 +933,7 @@ int main()
 
         // blit
         driver->blitRenderTargets(fb,0);
+
         driver->endScene();
 
         // display frames per second in window title
diff --git a/examples_tests/41.VisibilityBuffer/rasterizationCommon.h b/examples_tests/41.VisibilityBuffer/rasterizationCommon.h
@@ -0,0 +1,29 @@
+#ifndef _RASTERIZATION_COMMON_H_INCLUDED_
+#define _RASTERIZATION_COMMON_H_INCLUDED_
+
+#include "cullShaderCommon.h"
+
+struct CullShaderData_t
+{
+    mat4    viewProjMatrix;
+    float   viewProjDeterminant;
+    uint    maxBatchCount;
+};
+
+struct CullData_t
+{
+    vec3    aabbMinEdge;
+    vec3    aabbMaxEdge;
+    uint    drawCommandGUID;
+};
+
+struct DrawData_t
+{
+    mat4 MVP;
+    uint backfacingBit_batchInstanceGUID;
+    uint firstIndex;
+    uint padding1;
+    uint padding2;
+};
+
+#endif
