New vertex fetching method

Author: Przemog1

examples_tests/41.VisibilityBuffer/main.cpp

@@ -17,15 +17,11 @@ using namespace core;
 using namespace asset;
 using namespace video;
 
-constexpr const char* SHADER_OVERRIDES[2] =
-{
+constexpr const char* SHADER_OVERRIDES =
 R"(
 #define _NBL_VERT_INPUTS_DEFINED_
-#define _NBL_VERT_MAIN_DEFINED_
-#define _NBL_VERT_OUTPUTS_DEFINED_
-#define _NBL_VERT_SET1_BINDINGS_DEFINED_
 
-#define VirtualAttribute_t uvec2
+//#define nbl_glsl_VirtualAttribute_t uint
 
 vec4 nbl_glsl_decodeRGB10A2_UNORM(in uint x)
 {
@@ -66,34 +62,36 @@ layout(set = 0, binding = 5) readonly buffer VertexNormalOffsetTable
     int dataOffsetTable[];
 } vertexNormal;
 
-layout(push_constant, row_major) uniform PushConstants
-{
-	mat4 vp;
-} pc;
-
-//outputs
-layout(location = 0) out vec3 normal;
-layout(location = 1) out vec2 uv;
+#define _NBL_BASIC_VTX_ATTRIB_FETCH_FUCTIONS_DEFINED_
+#define _NBL_POS_FETCH_FUNCTION_DEFINED
+#define _NBL_UV_FETCH_FUNCTION_DEFINED
+#define _NBL_NORMAL_FETCH_FUNCTION_DEFINED
 
-)",
+//vec4 nbl_glsl_readAttrib(uint offset)
+//ivec4 nbl_glsl_readAttrib(uint offset)
+//uvec4 nbl_glsl_readAttrib(uint offset)
+//vec3 nbl_glsl_readAttrib(uint offset) 
+//..
 
-R"(
-void main()
+vec3 nbl_glsl_fetchVtxPos()
 {
     int vtxPosOffset = int(gl_VertexIndex) + vertexPosition.dataOffsetTable[gl_DrawID];
-    vec3 pos = texelFetch(MeshPackedData_R32G32B32_SFLOAT, vtxPosOffset).xyz;
-    gl_Position = nbl_glsl_pseudoMul4x4with3x1(pc.vp, pos);
-    
+    return texelFetch(MeshPackedData_R32G32B32_SFLOAT, vtxPosOffset).xyz;
+}
+
+vec2 nbl_glsl_fetchVtxUV()
+{
     int vtxUVOffset = int(gl_VertexIndex) + vertexUV.dataOffsetTable[gl_DrawID];
-    uv = texelFetch(MeshPackedData_R32G32_SFLOAT, vtxUVOffset).xy;
+    return texelFetch(MeshPackedData_R32G32_SFLOAT, vtxUVOffset).xy;
+}
 
+vec3 nbl_glsl_fetchVtxNormal()
+{
     int vtxNormOffset = int(gl_VertexIndex) + vertexNormal.dataOffsetTable[gl_DrawID];
-    normal = normalize(nbl_glsl_decodeRGB10A2_SNORM(texelFetch(MeshPackedData_A2B10G10R10_SNORM_PACK32, vtxNormOffset).x).xyz);
+    return normalize(nbl_glsl_decodeRGB10A2_SNORM(texelFetch(MeshPackedData_A2B10G10R10_SNORM_PACK32, vtxNormOffset).x).xyz);
 }
-)"
 
-}
-;
+)";
 
 struct DataOffsetTable
 {
@@ -112,11 +110,9 @@ core::smart_refctd_ptr<asset::ICPUSpecializedShader> createModifiedVertexShader(
 
     size_t firstNewlineAfterVersion = resultShaderSrc.find("\n", resultShaderSrc.find("#version "));
 
-    const std::string buffersDef = SHADER_OVERRIDES[0];
-    const std::string mainDef = SHADER_OVERRIDES[1];
+    const std::string customSrcCode = SHADER_OVERRIDES;
 
-    resultShaderSrc.insert(firstNewlineAfterVersion, buffersDef);
-    resultShaderSrc += mainDef;
+    resultShaderSrc.insert(firstNewlineAfterVersion, customSrcCode);
     resultShaderSrc.replace(resultShaderSrc.find("#version 430 core"), sizeof("#version 430 core"), "#version 460 core\n");
 
     auto unspecNew = core::make_smart_refctd_ptr<asset::ICPUShader>(resultShaderSrc.c_str());
@@ -141,7 +137,7 @@ struct DrawIndexedIndirectInput
 };
 
 
-void packMeshBuffersV2(video::IVideoDriver* driver, core::vector<ICPUMeshBuffer*>& meshBuffers, DrawIndexedIndirectInput& output, std::array<DataOffsetTable, 3>& offsetTable)
+void packMeshBuffers(video::IVideoDriver* driver, core::vector<ICPUMeshBuffer*>& meshBuffers, DrawIndexedIndirectInput& output, std::array<DataOffsetTable, 3>& offsetTable)
 {
     using MeshPacker = CCPUMeshPackerV2<DrawElementsIndirectCommand_t>;
 
@@ -178,7 +174,7 @@ void packMeshBuffersV2(video::IVideoDriver* driver, core::vector<ICPUMeshBuffer*
     output.maxCount = offsetTableSz;
     output.stride = sizeof(DrawElementsIndirectCommand_t);
 
-    mp.generateGLSLBufferDefinitions(0u);
+    auto glsl = mp.generateGLSLBufferDefinitions(0u);
 
     /*DrawElementsIndirectCommand_t* mdiPtr = static_cast<DrawElementsIndirectCommand_t*>(packerDataStore.MDIDataBuffer->getPointer());
     uint16_t* idxBuffPtr = static_cast<uint16_t*>(packerDataStore.indexBuffer->getPointer());
@@ -202,49 +198,59 @@ void packMeshBuffersV2(video::IVideoDriver* driver, core::vector<ICPUMeshBuffer*
     offsetTable[0].offsetBuffer.buffer = driver->createFilledDeviceLocalGPUBufferOnDedMem(sizeof(uint32_t) * offsetTableLocal.size(), static_cast<void*>(offsetTableLocal.data()));
 
     for (uint32_t i = 0u; i < offsetTableLocal.size(); i++)
-        offsetTableLocal[i] = cdot[i].attribOffset[2];
+        offsetTableLocal[i] = cdot[i].attribOffset[1];
 
     offsetTable[1].offsetBuffer.offset = 0u;
     offsetTable[1].offsetBuffer.buffer = driver->createFilledDeviceLocalGPUBufferOnDedMem(sizeof(uint32_t) * offsetTableLocal.size(), static_cast<void*>(offsetTableLocal.data()));
 
     for (uint32_t i = 0u; i < offsetTableLocal.size(); i++)
-        offsetTableLocal[i] = cdot[i].attribOffset[3];
+        offsetTableLocal[i] = cdot[i].attribOffset[2];
 
     offsetTable[2].offsetBuffer.offset = 0u;
     offsetTable[2].offsetBuffer.buffer = driver->createFilledDeviceLocalGPUBufferOnDedMem(sizeof(uint32_t) * offsetTableLocal.size(), static_cast<void*>(offsetTableLocal.data()));
 }
 
 void setPipeline(IVideoDriver* driver, ICPUSpecializedShader* vs, ICPUSpecializedShader* fs,
-    core::smart_refctd_ptr<IGPUBuffer>& vtxBuffer, std::array<DataOffsetTable, 3>& dataOffsetBuffers,
-    core::smart_refctd_ptr<IGPUDescriptorSet>& outputGPUDescriptorSet,
+    core::smart_refctd_ptr<IGPUBuffer>& vtxBuffer, core::smart_refctd_ptr<IGPUBuffer>& outputUBO, std::array<DataOffsetTable, 3>& dataOffsetBuffers,
+    core::smart_refctd_ptr<IGPUDescriptorSet>& outputGPUDescriptorSet0,
+    core::smart_refctd_ptr<IGPUDescriptorSet>& outputGPUDescriptorSet1,
     core::smart_refctd_ptr<IGPURenderpassIndependentPipeline>& outputGpuPipeline)
 {
     ICPUSpecializedShader* cpuShaders[2] = { vs, fs };
     auto gpuShaders = driver->getGPUObjectsFromAssets(cpuShaders, cpuShaders + 2);
 
-    core::smart_refctd_ptr<IGPUDescriptorSetLayout> dsLayout;
+    core::smart_refctd_ptr<IGPUDescriptorSetLayout> ds0Layout;
+    core::smart_refctd_ptr<IGPUDescriptorSetLayout> ds1Layout;
     {
         IGPUDescriptorSetLayout::SBinding b[6];
         b[0].binding = 0u; b[1].binding = 1u; b[2].binding = 2u; b[3].binding = 3u; b[4].binding = 4u; b[5].binding = 5u;
         b[0].type = b[1].type = b[2].type = EDT_UNIFORM_TEXEL_BUFFER;
         b[3].type = b[4].type = b[5].type = EDT_STORAGE_BUFFER;
         b[0].stageFlags = b[1].stageFlags = b[2].stageFlags = b[3].stageFlags = b[4].stageFlags = b[5].stageFlags = ISpecializedShader::ESS_VERTEX;
         b[0].count = b[1].count = b[2].count = b[3].count = b[4].count = b[5].count = 1u;
-        dsLayout = driver->createGPUDescriptorSetLayout(b, b + 6u);
+        ds0Layout = driver->createGPUDescriptorSetLayout(b, b + 6u);
+
+        IGPUDescriptorSetLayout::SBinding b2;
+        b2.binding = 0;
+        b2.type = EDT_UNIFORM_BUFFER;
+        b2.stageFlags = ISpecializedShader::ESS_VERTEX;
+        b2.count = 1u;
+        ds1Layout = driver->createGPUDescriptorSetLayout(&b2, &b2 + 1);
     }
 
     asset::SPushConstantRange pcRange = { asset::ISpecializedShader::ESS_VERTEX, 0u, sizeof(core::matrix4SIMD) };
-    auto pipelineLayout = driver->createGPUPipelineLayout(&pcRange, &pcRange + 1, core::smart_refctd_ptr(dsLayout));
+    auto pipelineLayout = driver->createGPUPipelineLayout(nullptr, nullptr, core::smart_refctd_ptr(ds0Layout), core::smart_refctd_ptr(ds1Layout));
 
-    outputGPUDescriptorSet = driver->createGPUDescriptorSet(std::move(dsLayout));
+    outputGPUDescriptorSet0 = driver->createGPUDescriptorSet(std::move(ds0Layout));
+    outputGPUDescriptorSet1 = driver->createGPUDescriptorSet(std::move(ds1Layout));
     {
         IGPUDescriptorSet::SWriteDescriptorSet w[6];
         w[0].arrayElement = w[1].arrayElement = w[2].arrayElement = w[3].arrayElement = w[4].arrayElement = w[5].arrayElement = 0u;
         w[0].count = w[1].count = w[2].count = w[3].count = w[4].count = w[5].count = 1u;
         w[0].binding = 0u; w[1].binding = 1u; w[2].binding = 2u; w[3].binding = 3u; w[4].binding = 4u; w[5].binding = 4u;
         w[0].descriptorType = w[1].descriptorType = w[2].descriptorType = EDT_UNIFORM_TEXEL_BUFFER;
         w[3].descriptorType = w[4].descriptorType = w[5].descriptorType = EDT_STORAGE_BUFFER;
-        w[0].dstSet = w[1].dstSet = w[2].dstSet = w[3].dstSet = w[4].dstSet = w[5].dstSet = outputGPUDescriptorSet.get();
+        w[0].dstSet = w[1].dstSet = w[2].dstSet = w[3].dstSet = w[4].dstSet = w[5].dstSet = outputGPUDescriptorSet0.get();
 
         IGPUDescriptorSet::SDescriptorInfo info[6];
 
@@ -280,8 +286,27 @@ void setPipeline(IVideoDriver* driver, ICPUSpecializedShader* vs, ICPUSpecialize
         w[5].info = &info[5];
 
         driver->updateDescriptorSets(6u, w, 0u, nullptr);
+
+        IGPUDescriptorSet::SWriteDescriptorSet w2;
+        w2.arrayElement = 0u;
+        w2.count = 1u;
+        w2.binding = 0u;
+        w2.descriptorType = EDT_UNIFORM_BUFFER;
+        w2.dstSet = outputGPUDescriptorSet1.get();
+
+        outputUBO = driver->createDeviceLocalGPUBufferOnDedMem(sizeof(SBasicViewParameters));
+
+        IGPUDescriptorSet::SDescriptorInfo info2;
+        info2.buffer.offset = 0u;
+        info2.buffer.size = outputUBO->getSize();
+        info2.desc = core::smart_refctd_ptr(outputUBO);
+        w2.info = &info2;
+
+        driver->updateDescriptorSets(1u, &w2, 0u, nullptr);
     }
 
+
+
     IGPUSpecializedShader* shaders[2] = { gpuShaders->operator[](0).get(), gpuShaders->operator[](1).get() };
 
     outputGpuPipeline = driver->createGPURenderpassIndependentPipeline(
@@ -346,7 +371,9 @@ int main()
         meshBuffers.push_back(mesh_raw->getMeshBufferVector()[i].get());
 
     core::smart_refctd_ptr<IGPURenderpassIndependentPipeline> gpuPipeline;
-    core::smart_refctd_ptr<IGPUDescriptorSet> ds;
+    core::smart_refctd_ptr<IGPUDescriptorSet> ds0;
+    core::smart_refctd_ptr<IGPUDescriptorSet> ds1;
+    core::smart_refctd_ptr<IGPUBuffer> ubo;
     DrawIndexedIndirectInput mdiCallParams;
     {
         auto* pipeline = meshBuffers[0]->getPipeline();
@@ -356,9 +383,9 @@ int main()
         ICPUSpecializedShader* fs = IAsset::castDown<ICPUSpecializedShader>(am->getAsset("../shader.frag", lp).getContents().begin()->get());
         std::array<DataOffsetTable, 3> offsetTable;
 
-        packMeshBuffersV2(driver, meshBuffers, mdiCallParams, offsetTable);
+        packMeshBuffers(driver, meshBuffers, mdiCallParams, offsetTable);
 
-        setPipeline(driver, vs.get(), fs, mdiCallParams.vtxBuffer.buffer, offsetTable, ds, gpuPipeline);
+        setPipeline(driver, vs.get(), fs, mdiCallParams.vtxBuffer.buffer, ubo, offsetTable, ds0, ds1, gpuPipeline);
     }
 
     //! we want to move around the scene and view it from different angles
@@ -374,16 +401,24 @@ int main()
     uint64_t lastFPSTime = 0;
     while (device->run() && receiver.keepOpen())
     {
+        video::IGPUDescriptorSet* ds[]{ ds0.get(), ds1.get() };
         driver->bindGraphicsPipeline(gpuPipeline.get());
-        driver->bindDescriptorSets(video::EPBP_GRAPHICS, gpuPipeline->getLayout(), 0u, 1u, &ds.get(), nullptr);
+        driver->bindDescriptorSets(video::EPBP_GRAPHICS, gpuPipeline->getLayout(), 0u, 2u, ds, nullptr);
 
         driver->beginScene(true, true, video::SColor(255, 0, 0, 255));
 
         //! This animates (moves) the camera and sets the transforms
         camera->OnAnimate(std::chrono::duration_cast<std::chrono::milliseconds>(device->getTimer()->getTime()).count());
         camera->render();
 
-        driver->pushConstants(gpuPipeline->getLayout(), asset::ISpecializedShader::ESS_VERTEX, 0u, sizeof(core::matrix4SIMD), camera->getConcatenatedMatrix().pointer());
+        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(ubo.get(), 0u, sizeof(SBasicViewParameters), &uboData);
+
         SBufferBinding<IGPUBuffer> vtxBufferBindings[IGPUMeshBuffer::MAX_ATTR_BUF_BINDING_COUNT];
         vtxBufferBindings[0] = mdiCallParams.vtxBuffer;
         driver->drawIndexedIndirect(vtxBufferBindings, mdiCallParams.mode, mdiCallParams.indexType, mdiCallParams.idxBuff.get(), mdiCallParams.indirectDrawBuff.get(), mdiCallParams.offset, mdiCallParams.maxCount, mdiCallParams.stride);

examples_tests/41.VisibilityBuffer/shader.frag

@@ -1,13 +1,15 @@
 #version 460 core
 
-layout(location = 0) in vec3 normal;
-layout(location = 1) in vec2 uv;
+layout (location = 0) in vec3 LocalPos;
+layout (location = 1) in vec3 ViewPos;
+layout (location = 2) in vec3 Normal;
+layout (location = 3) in vec2 UV;
 
 layout(location = 0) out vec4 color;
 
 void main()
 {
-    vec3 colorTmp = clamp(dot(vec3(0.0, 1.0, 0.0), normal), 0, 1) * vec3(1.0) + vec3(0.2);
+    vec3 colorTmp = clamp(dot(vec3(0.0, 1.0, 0.0), Normal), 0, 1) * vec3(1.0) + vec3(0.2);
     color = vec4(colorTmp, 1.0);
 
     //color = vec4(1.0);

include/nbl/builtin/shader/loader/mtl/vertex_impl.glsl

@@ -24,6 +24,18 @@ layout (location = 3) out vec2 UV;
 #include <nbl/builtin/glsl/utils/common.glsl>
 #include <nbl/builtin/glsl/utils/transform.glsl>
 
+#ifndef _NBL_BASIC_VTX_ATTRIB_FETCH_FUCTIONS_DEFINED_
+#ifndef _NBL_POS_FETCH_FUNCTION_DEFINED
+vec3 nbl_glsl_fetchVtxPos()    { return vPos; }
+#endif
+#if !defined(_NBL_UV_FETCH_FUNCTION_DEFINED) && !defined(_NO_UV)
+vec2 nbl_glsl_fetchVtxUV()     { return vUV; }
+#endif
+#ifndef _NBL_NORMAL_FETCH_FUNCTION_DEFINED
+vec3 nbl_glsl_fetchVtxNormal() { return vNormal; }
+#endif
+#endif
+
 #ifndef _NBL_VERT_SET1_BINDINGS_DEFINED_
 #define _NBL_VERT_SET1_BINDINGS_DEFINED_
 layout (set = 1, binding = 0, row_major, std140) uniform UBO
@@ -36,13 +48,13 @@ layout (set = 1, binding = 0, row_major, std140) uniform UBO
 #define _NBL_VERT_MAIN_DEFINED_
 void main()
 {
-    LocalPos = vPos;
-    gl_Position = nbl_glsl_pseudoMul4x4with3x1(CamData.params.MVP, vPos);
-    ViewPos = nbl_glsl_pseudoMul3x4with3x1(CamData.params.MV, vPos);
+    LocalPos = nbl_glsl_fetchVtxPos();
+    gl_Position = nbl_glsl_pseudoMul4x4with3x1(CamData.params.MVP, LocalPos);
+    ViewPos = nbl_glsl_pseudoMul3x4with3x1(CamData.params.MV, LocalPos);
     mat3 normalMat = nbl_glsl_SBasicViewParameters_GetNormalMat(CamData.params.NormalMatAndEyePos);
-    Normal = normalMat*normalize(vNormal);
+    Normal = normalMat*normalize(nbl_glsl_fetchVtxNormal());
 #ifndef _NO_UV
-    UV = vUV;
+    UV = nbl_glsl_fetchVtxUV();
 #endif
 }
 #endif //_NBL_VERT_MAIN_DEFINED_