validate creation params, added draw modes at create time

Author: keptsecret

examples_tests

@@ -18,13 +18,22 @@ class DrawAABB final : public core::IReferenceCounted
         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
@@ -68,6 +77,7 @@ class DrawAABB final : public core::IReferenceCounted
 	    ~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);

include/nbl/ext/DebugDraw/CDrawAABB.h

@@ -19,17 +19,32 @@ core::smart_refctd_ptr<DrawAABB> DrawAABB::create(SCreationParameters&& params)
 {
 	auto* const logger = params.utilities->getLogger();
 
-	auto singlePipeline = createPipeline(params, params.singlePipelineLayout.get(), "single.vertex.hlsl", "aabb_instances.fragment.hlsl");
-	if (!singlePipeline)
+	if (!validateCreationParameters(params))
 	{
-		logger->log("Failed to create pipeline!", ILogger::ELL_ERROR);
+		logger->log("Failed creation parameters validation!", ILogger::ELL_ERROR);
 		return nullptr;
 	}
-	auto batchPipeline = createPipeline(params, params.batchPipelineLayout.get(), "aabb_instances.vertex.hlsl", "aabb_instances.fragment.hlsl");
-	if (!batchPipeline)
+
+	smart_refctd_ptr<IGPUGraphicsPipeline> singlePipeline = nullptr;
+	if (params.drawMode & ADM_DRAW_SINGLE)
 	{
-		logger->log("Failed to create pipeline!", ILogger::ELL_ERROR);
-		return nullptr;
+		singlePipeline = createPipeline(params, params.singlePipelineLayout.get(), "single.vertex.hlsl", "aabb_instances.fragment.hlsl");
+		if (!singlePipeline)
+		{
+			logger->log("Failed to create pipeline!", ILogger::ELL_ERROR);
+			return nullptr;
+		}
+	}
+
+	smart_refctd_ptr<IGPUGraphicsPipeline> batchPipeline = nullptr;
+	if (params.drawMode & ADM_DRAW_BATCH)
+	{
+		batchPipeline = createPipeline(params, params.batchPipelineLayout.get(), "aabb_instances.vertex.hlsl", "aabb_instances.fragment.hlsl");
+		if (!batchPipeline)
+		{
+			logger->log("Failed to create pipeline!", ILogger::ELL_ERROR);
+			return nullptr;
+		}
 	}
 
 	if (!createStreamingBuffer(params))
@@ -83,6 +98,29 @@ const smart_refctd_ptr<IFileArchive> DrawAABB::mount(smart_refctd_ptr<ILogger> l
 	return smart_refctd_ptr(archive);
 }
 
+bool DrawAABB::validateCreationParameters(SCreationParameters& creationParams)
+{
+	const auto validation = std::to_array
+	({
+		std::make_pair(bool(creationParams.assetManager), "Invalid `creationParams.assetManager` is nullptr!"),
+		std::make_pair(bool(creationParams.assetManager->getSystem()), "Invalid `creationParams.assetManager->getSystem()` is nullptr!"),
+		std::make_pair(bool(creationParams.utilities), "Invalid `creationParams.utilities` is nullptr!"),
+		std::make_pair(bool(creationParams.transfer), "Invalid `creationParams.transfer` is nullptr!"),
+		std::make_pair(bool(creationParams.renderpass), "Invalid `creationParams.renderpass` is nullptr!"),
+		(creationParams.assetManager && creationParams.utilities && creationParams.transfer && creationParams.renderpass) ? std::make_pair(bool(creationParams.utilities->getLogicalDevice()->getPhysicalDevice()->getQueueFamilyProperties()[creationParams.transfer->getFamilyIndex()].queueFlags.hasFlags(IQueue::FAMILY_FLAGS::TRANSFER_BIT)), "Invalid `creationParams.transfer` is not capable of transfer operations!") : std::make_pair(false, "Pass valid required DrawAABB::S_CREATION_PARAMETERS!")
+		});
+
+	system::logger_opt_ptr logger = creationParams.utilities->getLogger();
+	for (const auto& [ok, error] : validation)
+		if (!ok)
+		{
+			logger.log(error, ILogger::ELL_ERROR);
+			return false;
+		}
+
+	return true;
+}
+
 smart_refctd_ptr<IGPUGraphicsPipeline> DrawAABB::createPipeline(SCreationParameters& params, const IGPUPipelineLayout* pipelineLayout, const std::string& vsPath, const std::string& fsPath)
 {
 	auto system = smart_refctd_ptr<ISystem>(params.assetManager->getSystem());
@@ -281,6 +319,12 @@ core::smart_refctd_ptr<video::IGPUPipelineLayout> DrawAABB::createDefaultPipelin
 
 bool DrawAABB::renderSingle(IGPUCommandBuffer* commandBuffer, const hlsl::shapes::AABB<3, float>& aabb, const hlsl::float32_t4& color, const hlsl::float32_t4x4& cameraMat)
 {
+	if (!(m_cachedCreationParams.drawMode & ADM_DRAW_SINGLE))
+	{
+		m_cachedCreationParams.utilities->getLogger()->log("DrawAABB has not been enabled for draw single!", ILogger::ELL_ERROR);
+		return false;
+	}
+
 	commandBuffer->bindGraphicsPipeline(m_singlePipeline.get());
 	commandBuffer->setLineWidth(1.f);
 	asset::SBufferBinding<video::IGPUBuffer> indexBinding = { .offset = 0, .buffer = m_indicesBuffer };
@@ -300,6 +344,12 @@ bool DrawAABB::renderSingle(IGPUCommandBuffer* commandBuffer, const hlsl::shapes
 
 bool DrawAABB::render(IGPUCommandBuffer* commandBuffer, ISemaphore::SWaitInfo waitInfo, std::span<const InstanceData> aabbInstances, const hlsl::float32_t4x4& cameraMat)
 {
+	if (!(m_cachedCreationParams.drawMode & ADM_DRAW_BATCH))
+	{
+		m_cachedCreationParams.utilities->getLogger()->log("DrawAABB has not been enabled for draw batches!", ILogger::ELL_ERROR);
+		return false;
+	}
+
 	using offset_t = SCachedCreationParameters::streaming_buffer_t::size_type;
 	constexpr auto MdiSizes = std::to_array<offset_t>({ sizeof(float32_t3), sizeof(InstanceData) });
 	// shared nPoT alignment needs to be divisible by all smaller ones to satisfy an allocation from all