New debug draw extension for AABBs

CMakeLists.txt

@@ -182,6 +182,7 @@ option(NBL_FAST_MATH "Enable fast low-precision math" ON)
 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?" OFF)
 
 option(NBL_BUILD_OPTIX "Enable nbl::ext::OptiX?" OFF)
 if(NBL_COMPILE_WITH_CUDA)

include/nbl/config/BuildConfigOptions.h.in

@@ -65,6 +65,8 @@
 
 #cmakedefine _NBL_BUILD_DPL_
 
+#cmakedefine NBL_BUILD_DEBUG_DRAW
+
 // TODO: This has to disapppear from the main header and go to the OptiX extension header + config
 #cmakedefine OPTIX_INCLUDE_DIR "@OPTIX_INCLUDE_DIR@"
 

include/nbl/ext/DebugDraw/CDrawAABB.h

@@ -0,0 +1,94 @@
+// Copyright (C) 2018-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_EXT_DRAW_AABB_H_
+#define _NBL_EXT_DRAW_AABB_H_
+
+#include "nbl/video/declarations.h"
+#include "nbl/builtin/hlsl/cpp_compat.hlsl"
+#include "nbl/builtin/hlsl/shapes/aabb.hlsl"
+#include "nbl/ext/DebugDraw/builtin/hlsl/common.hlsl"
+
+namespace nbl::ext::debug_draw
+{
+class DrawAABB final : public core::IReferenceCounted
+{
+    public:
+        static constexpr inline uint32_t IndicesCount = 24u;
+        static constexpr inline uint32_t VerticesCount = 8u;
+
+        enum DrawMode : uint16_t
+        {
+            ADM_DRAW_SINGLE = 0b01,
+            ADM_DRAW_BATCH = 0b10,
+            ADM_DRAW_BOTH = 0b11
+        };
+
+        struct SCachedCreationParameters
+        {
+            using streaming_buffer_t = video::StreamingTransientDataBufferST<core::allocator<uint8_t>>;
+
+            static constexpr inline auto RequiredAllocateFlags = core::bitflag<video::IDeviceMemoryAllocation::E_MEMORY_ALLOCATE_FLAGS>(video::IDeviceMemoryAllocation::EMAF_DEVICE_ADDRESS_BIT);
+            static constexpr inline auto RequiredUsageFlags = core::bitflag(asset::IBuffer::EUF_STORAGE_BUFFER_BIT) | asset::IBuffer::EUF_SHADER_DEVICE_ADDRESS_BIT;
+
+            DrawMode drawMode = ADM_DRAW_BOTH;
+
+            core::smart_refctd_ptr<video::IUtilities> utilities;
+
+            //! optional, default MDI buffer allocated if not provided
+            core::smart_refctd_ptr<streaming_buffer_t> streamingBuffer = nullptr;
+        };
+
+        struct SCreationParameters : SCachedCreationParameters
+        {
+            video::IQueue* transfer = nullptr;
+            core::smart_refctd_ptr<asset::IAssetManager> assetManager = nullptr;
+
+            core::smart_refctd_ptr<video::IGPUPipelineLayout> singlePipelineLayout;
+            core::smart_refctd_ptr<video::IGPUPipelineLayout> batchPipelineLayout;
+            core::smart_refctd_ptr<video::IGPURenderpass> renderpass = nullptr;
+        };
+
+        // creates an instance that can draw one AABB via push constant or multiple using streaming buffer
+        static core::smart_refctd_ptr<DrawAABB> create(SCreationParameters&& params);
+
+        // creates pipeline layout from push constant range
+        static core::smart_refctd_ptr<video::IGPUPipelineLayout> createPipelineLayoutFromPCRange(video::ILogicalDevice* device, const asset::SPushConstantRange& pcRange);
+
+        // creates default pipeline layout for streaming version
+        static core::smart_refctd_ptr<video::IGPUPipelineLayout> createDefaultPipelineLayout(video::ILogicalDevice* device);
+
+        //! mounts the extension's archive to given system - useful if you want to create your own shaders with common header included
+        static const core::smart_refctd_ptr<system::IFileArchive> mount(core::smart_refctd_ptr<system::ILogger> logger, system::ISystem* system, const std::string_view archiveAlias = "");
+
+        inline const SCachedCreationParameters& getCreationParameters() const { return m_cachedCreationParams; }
+
+        // records draw command for single AABB, user has to set pipeline outside
+        bool renderSingle(video::IGPUCommandBuffer* commandBuffer, const hlsl::shapes::AABB<3, float>& aabb, const hlsl::float32_t4& color, const hlsl::float32_t4x4& cameraMat);
+
+        bool render(video::IGPUCommandBuffer* commandBuffer, video::ISemaphore::SWaitInfo waitInfo, std::span<const InstanceData> aabbInstances, const hlsl::float32_t4x4& cameraMat);
+
+        static hlsl::float32_t4x4 getTransformFromAABB(const hlsl::shapes::AABB<3, float>& aabb);
+
+    protected:
+	    DrawAABB(SCreationParameters&& _params, core::smart_refctd_ptr<video::IGPUGraphicsPipeline> singlePipeline, core::smart_refctd_ptr<video::IGPUGraphicsPipeline> batchPipeline,
+            core::smart_refctd_ptr<video::IGPUBuffer> indicesBuffer);
+	    ~DrawAABB() override;
+
+    private:
+        static bool validateCreationParameters(SCreationParameters& params);
+        static core::smart_refctd_ptr<video::IGPUGraphicsPipeline> createPipeline(SCreationParameters& params, const video::IGPUPipelineLayout* pipelineLayout, const std::string& vsPath, const std::string& fsPath);
+        static bool createStreamingBuffer(SCreationParameters& params);
+        static core::smart_refctd_ptr<video::IGPUBuffer> createIndicesBuffer(SCreationParameters& params);
+
+        core::smart_refctd_ptr<video::IGPUBuffer> m_indicesBuffer;
+
+        SCachedCreationParameters m_cachedCreationParams;
+
+        core::smart_refctd_ptr<video::IGPUGraphicsPipeline> m_singlePipeline;
+        core::smart_refctd_ptr<video::IGPUGraphicsPipeline> m_batchPipeline;
+};
+}
+
+#endif

include/nbl/ext/DebugDraw/builtin/hlsl/aabb_instances.fragment.hlsl

@@ -0,0 +1,13 @@
+#pragma shader_stage(fragment)
+
+#include "common.hlsl"
+
+using namespace nbl::ext::debug_draw;
+
+[shader("pixel")]
+float32_t4 main(PSInput input) : SV_TARGET
+{
+    float32_t4 outColor = input.color;
+
+    return outColor;
+}

include/nbl/ext/DebugDraw/builtin/hlsl/aabb_instances.vertex.hlsl

@@ -0,0 +1,35 @@
+#pragma shader_stage(vertex)
+
+#include "nbl/builtin/hlsl/math/linalg/fast_affine.hlsl"
+#include "nbl/builtin/hlsl/glsl_compat/core.hlsl"
+#include "nbl/builtin/hlsl/bda/__ptr.hlsl"
+#include "common.hlsl"
+
+using namespace nbl::hlsl;
+using namespace nbl::ext::debug_draw;
+
+[[vk::push_constant]] SPushConstants pc;
+
+[shader("vertex")]
+PSInput main()
+{
+    const float32_t3 unitAABBVertices[8] = {
+        float32_t3(0.0, 0.0, 0.0),
+        float32_t3(1.0, 0.0, 0.0),
+        float32_t3(0.0, 0.0, 1.0),
+        float32_t3(1.0, 0.0, 1.0),
+        float32_t3(0.0, 1.0, 0.0),
+        float32_t3(1.0, 1.0, 0.0),
+        float32_t3(0.0, 1.0, 1.0),
+        float32_t3(1.0, 1.0, 1.0)
+    };
+
+    PSInput output;
+    float32_t3 vertex = unitAABBVertices[glsl::gl_VertexIndex()];
+    InstanceData instance = vk::BufferPointer<InstanceData>(pc.pInstanceBuffer + sizeof(InstanceData) * glsl::gl_InstanceIndex()).Get();
+
+    output.position = math::linalg::promoted_mul(instance.transform, vertex);
+    output.color = instance.color;
+
+    return output;
+}

include/nbl/ext/DebugDraw/builtin/hlsl/common.hlsl

@@ -0,0 +1,40 @@
+#ifndef _NBL_DEBUG_DRAW_EXT_COMMON_HLSL
+#define _NBL_DEBUG_DRAW_EXT_COMMON_HLSL
+
+#include "nbl/builtin/hlsl/cpp_compat.hlsl"
+
+namespace nbl
+{
+namespace ext
+{
+namespace debug_draw
+{
+
+struct InstanceData
+{
+    hlsl::float32_t4x4 transform;
+    hlsl::float32_t4 color;
+};
+
+struct SSinglePushConstants
+{
+    InstanceData instance;
+};
+
+struct SPushConstants
+{
+    uint64_t pInstanceBuffer;
+};
+
+#ifdef __HLSL_VERSION
+struct PSInput
+{
+    float32_t4 position : SV_Position;
+    float32_t4 color : TEXCOORD0;
+};
+#endif
+
+}
+}
+}
+#endif

include/nbl/ext/DebugDraw/builtin/hlsl/single.vertex.hlsl

@@ -0,0 +1,34 @@
+#pragma shader_stage(vertex)
+
+#include "nbl/builtin/hlsl/math/linalg/fast_affine.hlsl"
+#include "nbl/builtin/hlsl/glsl_compat/core.hlsl"
+#include "nbl/builtin/hlsl/bda/__ptr.hlsl"
+#include "common.hlsl"
+
+using namespace nbl::hlsl;
+using namespace nbl::ext::debug_draw;
+
+[[vk::push_constant]] SSinglePushConstants pc;
+
+[shader("vertex")]
+PSInput main()
+{
+    const float32_t3 unitAABBVertices[8] = {
+        float32_t3(0.0, 0.0, 0.0),
+        float32_t3(1.0, 0.0, 0.0),
+        float32_t3(0.0, 0.0, 1.0),
+        float32_t3(1.0, 0.0, 1.0),
+        float32_t3(0.0, 1.0, 0.0),
+        float32_t3(1.0, 1.0, 0.0),
+        float32_t3(0.0, 1.0, 1.0),
+        float32_t3(1.0, 1.0, 1.0)
+    };
+
+    PSInput output;
+    float32_t3 vertex = unitAABBVertices[glsl::gl_VertexIndex()];
+
+    output.position = math::linalg::promoted_mul(pc.instance.transform, vertex);
+    output.color = pc.instance.color;
+
+    return output;
+}

src/nbl/ext/CMakeLists.txt

@@ -54,6 +54,18 @@ if(NBL_BUILD_TEXT_RENDERING)
 	add_subdirectory(TextRendering)
 endif()
 
+if(NBL_BUILD_DEBUG_DRAW)
+    add_subdirectory(DebugDraw)
+    set(NBL_EXT_DEBUG_DRAW_INCLUDE_DIRS
+        ${NBL_EXT_DEBUG_DRAW_INCLUDE_DIRS}
+        PARENT_SCOPE
+    )
+    set(NBL_EXT_DEBUG_DRAW_LIB
+        ${NBL_EXT_DEBUG_DRAW_LIB}
+        PARENT_SCOPE
+    )
+endif()
+
 propagate_changed_variables_to_parent_scope()
 
 NBL_ADJUST_FOLDERS(ext)