Mesh Pipelines

3rdparty/CMakeLists.txt

@@ -95,7 +95,9 @@ if(CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
 endif()
 
 # boost
+set(CMAKE_BUILD_TYPE Release CACHE STRING "" FORCE) #forcing boost to be in release
 add_subdirectory(boost boost EXCLUDE_FROM_ALL)
+set(CMAKE_BUILD_TYPE ${CMAKE_BUILD_TYPE} CACHE STRING "" FORCE) #restoring config from boost
 
 set(SPIRV_HEADERS_SKIP_INSTALL ON CACHE INTERNAL "Skip SPIRV-Headers install")
 set(SPIRV_HEADERS_SKIP_EXAMPLES ON CACHE INTERNAL "Skip SPIRV-Headers examples")

CMakeLists.txt

@@ -175,6 +175,7 @@ option(NBL_FAST_MATH "Enable fast low-precision math" OFF) # the reason OFF is b
 option(NBL_BUILD_EXAMPLES "Enable building examples" ON)
 option(NBL_BUILD_MITSUBA_LOADER "Enable nbl::ext::MitsubaLoader?" OFF) # TODO: once it compies turn this ON by default!
 option(NBL_BUILD_IMGUI "Enable nbl::ext::ImGui?" ON)
+option(NBL_BUILD_DEBUG_DRAW "Enable Nabla Debug Draw extension?" ON)
 
 option(NBL_BUILD_OPTIX "Enable nbl::ext::OptiX?" OFF)
 if(NBL_COMPILE_WITH_CUDA)

include/nbl/asset/IAsset.h

@@ -95,6 +95,7 @@ class IAsset : virtual public core::IReferenceCounted
 			ET_PIPELINE_CACHE = 1ull<<21,						//!< asset::ICPUPipelineCache
 			ET_SCENE = 1ull<<22,								//!< reserved, to implement later
 			ET_RAYTRACING_PIPELINE = 1ull << 23, //!< asset::ICPURayTracingPipeline
+			ET_MESH_PIPELINE = 1ull << 24,
 			ET_IMPLEMENTATION_SPECIFIC_METADATA = 1ull<<31u,    //!< lights, etc.
 			//! Reserved special value used for things like terminating lists of this enum
 

include/nbl/asset/ICPUMeshPipeline.h

@@ -0,0 +1,145 @@
+#ifndef _NBL_I_CPU_MESH_PIPELINE_H_INCLUDED_
+#define _NBL_I_CPU_MESH_PIPELINE_H_INCLUDED_
+
+
+#include "nbl/asset/IMeshPipeline.h"
+#include "nbl/asset/ICPURenderpass.h"
+#include "nbl/asset/ICPUPipeline.h"
+
+
+namespace nbl::asset
+{
+
+class ICPUMeshPipeline final : public ICPUPipeline<IMeshPipeline<ICPUPipelineLayout,ICPURenderpass>>
+{
+        using pipeline_base_t = IMeshPipeline<ICPUPipelineLayout, ICPURenderpass>;
+        using base_t = ICPUPipeline<pipeline_base_t>;
+
+    public:
+
+        static core::smart_refctd_ptr<ICPUMeshPipeline> create(ICPUPipelineLayout* layout, ICPURenderpass* renderpass = nullptr)
+        {
+            auto retval = new ICPUMeshPipeline(layout, renderpass);
+            return core::smart_refctd_ptr<ICPUMeshPipeline>(retval,core::dont_grab);
+        }
+
+        constexpr static inline auto AssetType = ET_MESH_PIPELINE;
+        inline E_TYPE getAssetType() const override { return AssetType; }
+
+        inline const SCachedCreationParams& getCachedCreationParams() const
+        {
+            return pipeline_base_t::getCachedCreationParams();
+        }
+
+        inline SCachedCreationParams& getCachedCreationParams()
+        {
+            assert(isMutable());
+            return m_params;
+        }
+
+        inline std::span<const SShaderSpecInfo> getSpecInfos(const hlsl::ShaderStage stage) const override final
+        {
+            switch (stage) {
+                case hlsl::ShaderStage::ESS_TASK:       return { &m_specInfos[0], 1 };
+                case hlsl::ShaderStage::ESS_MESH:       return { &m_specInfos[1], 1 };
+                case hlsl::ShaderStage::ESS_FRAGMENT:   return { &m_specInfos[2], 1 };
+            }
+            return {};
+        }
+
+        inline std::span<SShaderSpecInfo> getSpecInfos(const hlsl::ShaderStage stage)
+        {
+            return base_t::getSpecInfos(stage);
+        }
+
+        SShaderSpecInfo* getSpecInfo(const hlsl::ShaderStage stage)
+        {
+            if (!isMutable()) return nullptr;
+            switch (stage) {
+                case hlsl::ShaderStage::ESS_TASK:       return &m_specInfos[0];
+                case hlsl::ShaderStage::ESS_MESH:       return &m_specInfos[1];
+                case hlsl::ShaderStage::ESS_FRAGMENT:   return &m_specInfos[2];
+            }
+            return nullptr;
+        }
+
+        const SShaderSpecInfo* getSpecInfo(const hlsl::ShaderStage stage) const
+        {
+            const auto stageIndex = stageToIndex(stage);
+            if (stageIndex != -1)
+                return &m_specInfos[stageIndex];
+            return nullptr;
+        }
+
+        inline bool valid() const override
+        {
+            if (!m_layout) return false;
+            if (!m_layout->valid())return false;
+
+            // https://registry.khronos.org/vulkan/specs/1.3-extensions/man/html/VkGraphicsPipelineCreateInfo.html#VUID-VkGraphicsPipelineCreateInfo-dynamicRendering-06576
+            if (!m_renderpass || m_params.subpassIx >= m_renderpass->getSubpassCount()) return false;
+
+            core::bitflag<hlsl::ShaderStage> stagePresence = {};
+            for (auto shader_i = 0u; shader_i < m_specInfos.size(); shader_i++)
+            {
+                const auto& info = m_specInfos[shader_i];
+                if (info.shader)
+                    stagePresence |= indexToStage(shader_i);
+            }
+            return hasRequiredStages(stagePresence);
+        }
+
+    protected:
+        using base_t::base_t;
+        virtual ~ICPUMeshPipeline() override = default;
+
+        std::array<SShaderSpecInfo, MESH_SHADER_STAGE_COUNT> m_specInfos;
+
+    private:
+        explicit ICPUMeshPipeline(ICPUPipelineLayout* layout, ICPURenderpass* renderpass)
+            : base_t(layout, {}, renderpass)
+            {}
+
+        static inline int8_t stageToIndex(const hlsl::ShaderStage stage)
+        {
+            const auto stageIx = hlsl::findLSB(stage);
+            if (stageIx < 0 || stageIx >= MESH_SHADER_STAGE_COUNT || hlsl::bitCount(stage)!=1)
+              return -1;
+            return stageIx;
+        }
+
+        static inline hlsl::ShaderStage indexToStage(const int8_t index)
+        {
+            switch (index) {
+                case 0: return hlsl::ShaderStage::ESS_TASK;
+                case 1: return hlsl::ShaderStage::ESS_MESH;
+                case 2: return hlsl::ShaderStage::ESS_FRAGMENT;
+            }
+            return hlsl::ShaderStage::ESS_UNKNOWN;
+        }
+
+        inline core::smart_refctd_ptr<base_t> clone_impl(core::smart_refctd_ptr<ICPUPipelineLayout>&& layout, uint32_t depth) const override final
+        {
+            auto* newPipeline = new ICPUMeshPipeline(layout.get(), m_renderpass.get());
+            newPipeline->m_params = m_params;
+
+            for (auto specInfo_i = 0u; specInfo_i < m_specInfos.size(); specInfo_i++)
+            {
+                newPipeline->m_specInfos[specInfo_i] = m_specInfos[specInfo_i].clone(depth);
+            }
+
+            return core::smart_refctd_ptr<base_t>(newPipeline, core::dont_grab);
+        }
+
+        inline void visitDependents_impl(std::function<bool(const IAsset*)> visit) const override
+        {
+            if (!visit(m_layout.get())) return;
+            if (!visit(m_renderpass.get())) return;
+            for (const auto& info : m_specInfos)
+              if (!visit(info.shader.get())) return;
+        }
+};
+
+}
+
+#endif

include/nbl/asset/ICPUScene.h

@@ -0,0 +1,54 @@
+// Copyright (C) 2025-2025 - DevSH Graphics Programming Sp. z O.O.
+// This file is part of the "Nabla Engine".
+// For conditions of distribution and use, see copyright notice in nabla.h
+#ifndef _NBL_ASSET_I_CPU_SCENE_H_INCLUDED_
+#define _NBL_ASSET_I_CPU_SCENE_H_INCLUDED_
+
+
+#include "nbl/asset/IScene.h"
+// TODO: change to true IR later
+#include "nbl/asset/material_compiler3/CFrontendIR.h"
+
+
+namespace nbl::asset
+{
+// 
+class NBL_API2 ICPUScene : public IAsset, public IScene
+{
+        using base_t = IScene;
+
+    public:
+        inline ICPUScene() = default;
+
+        constexpr static inline auto AssetType = ET_SCENE;
+        inline E_TYPE getAssetType() const override { return AssetType; }
+
+        inline bool valid() const override
+        {
+            return true;
+        }
+
+        inline core::smart_refctd_ptr<IAsset> clone(uint32_t _depth=~0u) const
+        {
+            const auto nextDepth = _depth ? (_depth-1):0;
+            auto retval = core::smart_refctd_ptr<ICPUScene>();
+            return retval;
+        }
+
+    protected:
+        //
+        inline void visitDependents_impl(std::function<bool(const IAsset*)> visit) const override
+        {
+        }
+
+
+        // suggested contents:
+        // - morph target list
+        // - material table
+        // - instance list (morph target, keyframed transforms, material table indexings, FUTURE: reference skeleton)
+        // - area light list (OBB decompositions, material table indexings)
+        // - envlight data
+};
+}
+
+#endif

include/nbl/asset/IMeshPipeline.h

@@ -0,0 +1,59 @@
+#ifndef _NBL_ASSET_I_MESH_PIPELINE_H_INCLUDED_
+#define _NBL_ASSET_I_MESH_PIPELINE_H_INCLUDED_
+
+#include "nbl/asset/IShader.h"
+#include "nbl/asset/RasterizationStates.h"
+#include "nbl/asset/IPipeline.h"
+
+
+namespace nbl::asset {
+    class IMeshPipelineBase : public virtual core::IReferenceCounted {
+    public:
+        constexpr static inline uint8_t MESH_SHADER_STAGE_COUNT = 3u; //i dont know what this is going to be used for yet, might be redundant
+        struct SCachedCreationParams final {
+            SRasterizationParams rasterization = {};
+            SBlendParams blend = {};
+            uint32_t subpassIx = 0u; //this subpass stuff is eluding me rn. i might just need to crack open the vulkan documentation
+            uint8_t requireFullSubgroups = false;
+        };
+
+    };
+
+    template<typename PipelineLayoutType, typename RenderpassType>
+    class IMeshPipeline : public IPipeline<PipelineLayoutType>, public IMeshPipelineBase {
+    protected:
+        using renderpass_t = RenderpassType;
+        //using base_creation_params_t = IPipeline<PipelineLayoutType>;//compute uses this, idk if its necessary yet
+    public:
+
+        static inline bool hasRequiredStages(const core::bitflag<hlsl::ShaderStage>& stagePresence)
+        {
+            // https://registry.khronos.org/vulkan/specs/1.3-extensions/man/html/VkGraphicsPipelineCreateInfo.html#VUID-VkGraphicsPipelineCreateInfo-stage-02096
+            if (!stagePresence.hasFlags(hlsl::ShaderStage::ESS_MESH)) {
+                return false;
+            }
+            //i dont quite understand why igraphicspipeline doesnt require a fragment shader. is it not required by vulkan?
+            if (!stagePresence.hasFlags(hlsl::ShaderStage::ESS_FRAGMENT)) {
+                return false;
+            }
+
+            return true;
+        }
+
+        inline const SCachedCreationParams& getCachedCreationParams() const { return m_params; }
+
+    protected:
+        explicit IMeshPipeline(PipelineLayoutType* layout, const SCachedCreationParams& cachedParams, renderpass_t* renderpass) :
+            IPipeline<PipelineLayoutType>(core::smart_refctd_ptr<PipelineLayoutType>(layout)),
+            m_params(cachedParams), m_renderpass(core::smart_refctd_ptr<renderpass_t>(renderpass))
+        {
+        }
+
+        SCachedCreationParams m_params = {};
+        core::smart_refctd_ptr<renderpass_t> m_renderpass = nullptr;
+    };
+
+}
+
+
+#endif

include/nbl/builtin/glsl/utils/morton.glsl

@@ -22,6 +22,18 @@ uint nbl_glsl_morton_decode2d8bComponent(in uint x)
     return x;
 }
 
+uint nbl_glsl_morton_decode2d32bComponent(in uint x) 
+{
+    x &= 0x55555555u;
+    x = (x ^ (x >>  1u)) & 0x33333333u;
+    x = (x ^ (x >>  2u)) & 0x0f0f0f0fu;
+    x = (x ^ (x >>  4u)) & 0x00ff00ffu;
+    x = (x ^ (x >>  8u)) & 0x0000ffffu;
+    x = (x ^ (x >>  16u));
+    return x;
+}
+
+
 uvec2 nbl_glsl_morton_decode2d4b(in uint x)
 {
     return uvec2(nbl_glsl_morton_decode2d4bComponent(x), nbl_glsl_morton_decode2d4bComponent(x >> 1u));
@@ -32,4 +44,9 @@ uvec2 nbl_glsl_morton_decode2d8b(in uint x)
     return uvec2(nbl_glsl_morton_decode2d8bComponent(x), nbl_glsl_morton_decode2d8bComponent(x >> 1u));
 }
 
+uvec2 nbl_glsl_morton_decode2d32b(in uint x)
+{
+    return uvec2(nbl_glsl_morton_decode2d32bComponent(x), nbl_glsl_morton_decode2d32bComponent(x >> 1u));
+}
+
 #endif