Hlsl path tracer

01_HelloCoreSystemAsset/main.cpp

@@ -2,8 +2,8 @@
 // This file is part of the "Nabla Engine".
 // For conditions of distribution and use, see copyright notice in nabla.h
 
-// always include nabla first before std:: headers
-#include "nabla.h"
+// <nabla.h> public interface and common examples API, always include first before std:: headers
+#include "nbl/examples/examples.hpp"
 
 #include "nbl/system/IApplicationFramework.h"
 

02_HelloCompute/main.cpp

@@ -94,9 +94,9 @@ class HelloComputeApp final : public nbl::application_templates::MonoSystemMonoL
 				// The convention is that an `ICPU` object represents a potentially Mutable (and in the past, Serializable) recipe for creating an `IGPU` object, and later examples will show automated systems for doing that.
 				// The Assets always form a Directed Acyclic Graph and our type system enforces that property at compile time (i.e. an `IBuffer` cannot reference an `IImageView` even indirectly).
 				// Another reason for the 1:1 pairing of types is that one can use a CPU-to-GPU associative cache (asset manager has a default one) and use the pointers to the CPU objects as UUIDs.
-				// The ICPUShader is just a mutable container for source code (can be high level like HLSL needing compilation to SPIR-V or SPIR-V itself) held in an `nbl::asset::ICPUBuffer`.
+				// The IShader is just a mutable container for source code (can be high level like HLSL needing compilation to SPIR-V or SPIR-V itself) held in an `nbl::asset::ICPUBuffer`.
 				// They can be created: from buffers of code, by compilation from some other source code, or loaded from files (next example will do that).
-				smart_refctd_ptr<nbl::asset::ICPUShader> cpuShader;
+				smart_refctd_ptr<nbl::asset::IShader> cpuShader;
 				{
 					// Normally we'd use the ISystem and the IAssetManager to load shaders flexibly from (virtual) files for ease of development (syntax highlighting and Intellisense),
 					// but I want to show the full process of assembling a shader from raw source code at least once.
@@ -138,7 +138,7 @@ class HelloComputeApp final : public nbl::application_templates::MonoSystemMonoL
 				}
 
 				// Note how each ILogicalDevice method takes a smart-pointer r-value, so that the GPU objects refcount their dependencies
-				smart_refctd_ptr<nbl::video::IGPUShader> shader = device->createShader(cpuShader.get());
+				smart_refctd_ptr<IShader> shader = device->compileShader({.source = cpuShader.get()});
 				if (!shader)
 					return logFail("Failed to create a GPU Shader, seems the Driver doesn't like the SPIR-V we're feeding it!\n");
 

03_DeviceSelectionAndSharedSources/Testers.h

@@ -4,8 +4,7 @@
 #ifndef _NBL_TESTERS_H_INCLUDED_
 #define _NBL_TESTERS_H_INCLUDED_
 
-#include "nbl/application_templates/MonoDeviceApplication.hpp"
-#include "nbl/application_templates/MonoAssetManagerAndBuiltinResourceApplication.hpp"
+#include "nbl/examples/examples.hpp"
 
 using namespace nbl;
 
@@ -24,7 +23,7 @@ class IntrospectionTesterBase
 	const std::string m_functionToTestName = "";
 
 protected:
-	static std::pair<smart_refctd_ptr<ICPUShader>, smart_refctd_ptr<const CSPIRVIntrospector::CStageIntrospectionData>> compileHLSLShaderAndTestIntrospection(
+	static std::pair<smart_refctd_ptr<IShader>, smart_refctd_ptr<const CSPIRVIntrospector::CStageIntrospectionData>> compileHLSLShaderAndTestIntrospection(
 		video::IPhysicalDevice* physicalDevice, video::ILogicalDevice* device, system::ILogger* logger, asset::IAssetManager* assetMgr, const std::string& shaderPath, CSPIRVIntrospector& introspector)
 	{
 		IAssetLoader::SAssetLoadParams lp = {};
@@ -33,15 +32,18 @@ class IntrospectionTesterBase
 		// this time we load a shader directly from a file
 		auto assetBundle = assetMgr->getAsset(shaderPath, lp);
 		const auto assets = assetBundle.getContents();
-		if (assets.empty())
+		const auto* metadata = assetBundle.getMetadata();
+		if (assets.empty() || assetBundle.getAssetType() != IAsset::ET_SHADER)
 		{
 			logFail(logger, "Could not load shader!");
 			assert(0);
 		}
+		const auto hlslMetadata = static_cast<const CHLSLMetadata*>(metadata);
+		const auto shaderStage = hlslMetadata->shaderStages->front();
 
 		// It would be super weird if loading a shader from a file produced more than 1 asset
 		assert(assets.size() == 1);
-		smart_refctd_ptr<ICPUShader> source = IAsset::castDown<ICPUShader>(assets[0]);
+		smart_refctd_ptr<IShader> source = IAsset::castDown<IShader>(assets[0]);
 
 		smart_refctd_ptr<const CSPIRVIntrospector::CStageIntrospectionData> introspection;
 		{
@@ -53,8 +55,8 @@ class IntrospectionTesterBase
 			// The Shader Asset Loaders deduce the stage from the file extension,
 			// if the extension is generic (.glsl or .hlsl) the stage is unknown.
 			// But it can still be overriden from within the source with a `#pragma shader_stage` 
-			options.stage = source->getStage() == IShader::E_SHADER_STAGE::ESS_COMPUTE ? source->getStage() : IShader::E_SHADER_STAGE::ESS_VERTEX; // TODO: do smth with it
-			options.targetSpirvVersion = device->getPhysicalDevice()->getLimits().spirvVersion;
+			options.stage = shaderStage == IShader::E_SHADER_STAGE::ESS_COMPUTE ? shaderStage : IShader::E_SHADER_STAGE::ESS_VERTEX; // TODO: do smth with it
+			options.preprocessorOptions.targetSpirvVersion = device->getPhysicalDevice()->getLimits().spirvVersion;
 			// we need to perform an unoptimized compilation with source debug info or we'll lose names of variable sin the introspection
 			options.spirvOptimizer = nullptr;
 			options.debugInfoFlags |= IShaderCompiler::E_DEBUG_INFO_FLAGS::EDIF_SOURCE_BIT;
@@ -186,7 +188,7 @@ class PredefinedLayoutTester final : public IntrospectionTesterBase
 		constexpr uint32_t MERGE_TEST_SHADERS_CNT = mergeTestShadersPaths.size();
 
 		CSPIRVIntrospector introspector[MERGE_TEST_SHADERS_CNT];
-		smart_refctd_ptr<ICPUShader> sources[MERGE_TEST_SHADERS_CNT];
+		smart_refctd_ptr<IShader> sources[MERGE_TEST_SHADERS_CNT];
 
 		for (uint32_t i = 0u; i < MERGE_TEST_SHADERS_CNT; ++i)
 		{
@@ -201,7 +203,7 @@ class PredefinedLayoutTester final : public IntrospectionTesterBase
 				.binding = 0,
 				.type = nbl::asset::IDescriptor::E_TYPE::ET_STORAGE_BUFFER,
 				.createFlags = ICPUDescriptorSetLayout::SBinding::E_CREATE_FLAGS::ECF_NONE,
-				.stageFlags = ICPUShader::E_SHADER_STAGE::ESS_COMPUTE,
+				.stageFlags = IShader::E_SHADER_STAGE::ESS_COMPUTE,
 				.count = 1,
 				.immutableSamplers = nullptr
 			}
@@ -213,15 +215,15 @@ class PredefinedLayoutTester final : public IntrospectionTesterBase
 					.binding = 0,
 					.type = nbl::asset::IDescriptor::E_TYPE::ET_STORAGE_BUFFER,
 					.createFlags = ICPUDescriptorSetLayout::SBinding::E_CREATE_FLAGS::ECF_NONE,
-					.stageFlags = ICPUShader::E_SHADER_STAGE::ESS_COMPUTE,
+					.stageFlags = IShader::E_SHADER_STAGE::ESS_COMPUTE,
 					.count = 1,
 					.immutableSamplers = nullptr
 				},
 				{
 					.binding = 1,
 					.type = nbl::asset::IDescriptor::E_TYPE::ET_STORAGE_BUFFER,
 					.createFlags = ICPUDescriptorSetLayout::SBinding::E_CREATE_FLAGS::ECF_NONE,
-					.stageFlags = ICPUShader::E_SHADER_STAGE::ESS_COMPUTE,
+					.stageFlags = IShader::E_SHADER_STAGE::ESS_COMPUTE,
 					.count = 2,
 					.immutableSamplers = nullptr
 				}
@@ -251,9 +253,9 @@ class PredefinedLayoutTester final : public IntrospectionTesterBase
 		bool pplnCreationSuccess[MERGE_TEST_SHADERS_CNT];
 		for (uint32_t i = 0u; i < MERGE_TEST_SHADERS_CNT; ++i)
 		{
-			ICPUShader::SSpecInfo specInfo;
+			ICPUPipelineBase::SShaderSpecInfo specInfo;
 			specInfo.entryPoint = "main";
-			specInfo.shader = sources[i].get();
+			specInfo.shader = sources[i];
 			pplnCreationSuccess[i] = static_cast<bool>(introspector[i].createApproximateComputePipelineFromIntrospection(specInfo, core::smart_refctd_ptr<ICPUPipelineLayout>(predefinedPplnLayout)));
 		}
 

03_DeviceSelectionAndSharedSources/main.cpp

@@ -2,15 +2,20 @@
 // This file is part of the "Nabla Engine".
 // For conditions of distribution and use, see copyright notice in nabla.h
 
-#include "nbl/application_templates/MonoDeviceApplication.hpp"
-#include "nbl/application_templates/MonoAssetManagerAndBuiltinResourceApplication.hpp"
-#include "CommonPCH/PCH.hpp"
+
+#include "nbl/examples/examples.hpp"
+// TODO: why isn't this in `nabla.h` ?
+#include "nbl/asset/metadata/CHLSLMetadata.h"
+
 
 using namespace nbl;
-using namespace core;
-using namespace system;
-using namespace asset;
-using namespace video;
+using namespace nbl::core;
+using namespace nbl::hlsl;
+using namespace nbl::system;
+using namespace nbl::asset;
+using namespace nbl::ui;
+using namespace nbl::video;
+using namespace nbl::examples;
 
 // TODO[Przemek]: update comments
 
@@ -21,10 +26,10 @@ using namespace video;
 constexpr bool ENABLE_TESTS = false;
 
 // This time we create the device in the base class and also use a base class to give us an Asset Manager and an already mounted built-in resource archive
-class DeviceSelectionAndSharedSourcesApp final : public application_templates::MonoDeviceApplication, public application_templates::MonoAssetManagerAndBuiltinResourceApplication
+class DeviceSelectionAndSharedSourcesApp final : public application_templates::MonoDeviceApplication, public BuiltinResourcesApplication
 {
 	using device_base_t = application_templates::MonoDeviceApplication;
-	using asset_base_t = application_templates::MonoAssetManagerAndBuiltinResourceApplication;
+	using asset_base_t = BuiltinResourcesApplication;
 public:
 	// Yay thanks to multiple inheritance we cannot forward ctors anymore
 	DeviceSelectionAndSharedSourcesApp(const path& _localInputCWD, const path& _localOutputCWD, const path& _sharedInputCWD, const path& _sharedOutputCWD) :
@@ -60,9 +65,9 @@ class DeviceSelectionAndSharedSourcesApp final : public application_templates::M
 		//shaderIntrospection->debugPrint(m_logger.get());
 
 		// We've now skipped the manual creation of a descriptor set layout, pipeline layout
-		ICPUShader::SSpecInfo specInfo;
+		ICPUPipelineBase::SShaderSpecInfo specInfo;
 		specInfo.entryPoint = "main";
-		specInfo.shader = source.get();
+		specInfo.shader = source;
 
 		smart_refctd_ptr<nbl::asset::ICPUComputePipeline> cpuPipeline = introspector.createApproximateComputePipelineFromIntrospection(specInfo);
 
@@ -236,7 +241,7 @@ class DeviceSelectionAndSharedSourcesApp final : public application_templates::M
 	// Whether to keep invoking the above. In this example because its headless GPU compute, we do all the work in the app initialization.
 	bool keepRunning() override { return false; }
 
-	std::pair<smart_refctd_ptr<ICPUShader>, smart_refctd_ptr<const CSPIRVIntrospector::CStageIntrospectionData>> compileShaderAndTestIntrospection(
+	std::pair<smart_refctd_ptr<IShader>, smart_refctd_ptr<const CSPIRVIntrospector::CStageIntrospectionData>> compileShaderAndTestIntrospection(
 		const std::string& shaderPath, CSPIRVIntrospector& introspector)
 	{
 		IAssetLoader::SAssetLoadParams lp = {};
@@ -245,15 +250,19 @@ class DeviceSelectionAndSharedSourcesApp final : public application_templates::M
 		// this time we load a shader directly from a file
 		auto assetBundle = m_assetMgr->getAsset(shaderPath, lp);
 		const auto assets = assetBundle.getContents();
-		if (assets.empty())
+		if (assets.empty() || assetBundle.getAssetType() != IAsset::ET_SHADER)
 		{
 			logFail("Could not load shader!");
 			assert(0);
 		}
 
+		const auto* metadata = assetBundle.getMetadata();
+    const auto hlslMetadata = static_cast<const CHLSLMetadata*>(metadata);
+		const auto shaderStage = hlslMetadata->shaderStages->front();
+
 		// It would be super weird if loading a shader from a file produced more than 1 asset
 		assert(assets.size() == 1);
-		smart_refctd_ptr<ICPUShader> source = IAsset::castDown<ICPUShader>(assets[0]);
+		smart_refctd_ptr<IShader> source = IAsset::castDown<IShader>(assets[0]);
 
 		smart_refctd_ptr<const CSPIRVIntrospector::CStageIntrospectionData> introspection;
 		{
@@ -265,8 +274,8 @@ class DeviceSelectionAndSharedSourcesApp final : public application_templates::M
 			// The Shader Asset Loaders deduce the stage from the file extension,
 			// if the extension is generic (.glsl or .hlsl) the stage is unknown.
 			// But it can still be overriden from within the source with a `#pragma shader_stage` 
-			options.stage = source->getStage() == IShader::E_SHADER_STAGE::ESS_COMPUTE ? source->getStage() : IShader::E_SHADER_STAGE::ESS_VERTEX; // TODO: do smth with it
-			options.targetSpirvVersion = m_device->getPhysicalDevice()->getLimits().spirvVersion;
+			options.stage = shaderStage == IShader::E_SHADER_STAGE::ESS_COMPUTE ? shaderStage : IShader::E_SHADER_STAGE::ESS_VERTEX; // TODO: do smth with it
+			options.preprocessorOptions.targetSpirvVersion = m_device->getPhysicalDevice()->getLimits().spirvVersion;
 			// we need to perform an unoptimized compilation with source debug info or we'll lose names of variable sin the introspection
 			options.spirvOptimizer = nullptr;
 			options.debugInfoFlags |= IShaderCompiler::E_DEBUG_INFO_FLAGS::EDIF_SOURCE_BIT;
@@ -277,7 +286,7 @@ class DeviceSelectionAndSharedSourcesApp final : public application_templates::M
 			options.preprocessorOptions.includeFinder = compilerSet->getShaderCompiler(source->getContentType())->getDefaultIncludeFinder();
 
 			auto spirvUnspecialized = compilerSet->compileToSPIRV(source.get(), options);
-			const CSPIRVIntrospector::CStageIntrospectionData::SParams inspctParams = { .entryPoint = "main", .shader = spirvUnspecialized };
+			const CSPIRVIntrospector::CStageIntrospectionData::SParams inspctParams = { .entryPoint = "main", .shader = spirvUnspecialized, .stage = shaderStage };
 
 			introspection = introspector.introspect(inspctParams);
 			introspection->debugPrint(m_logger.get());

05_StreamingAndBufferDeviceAddressApp/app_resources/shader.comp.hlsl

@@ -10,6 +10,7 @@ template<typename capability_traits=nbl::hlsl::jit::device_capabilities_traits>
 void dummyTraitTest() {}
 
 [numthreads(WorkgroupSize,1,1)]
+[shader("compute")]
 void main(uint32_t3 ID : SV_DispatchThreadID)
 {
 	dummyTraitTest();

05_StreamingAndBufferDeviceAddressApp/main.cpp

@@ -5,7 +5,7 @@
 
 // I've moved out a tiny part of this example into a shared header for reuse, please open and read it.
 #include "nbl/application_templates/MonoDeviceApplication.hpp"
-#include "nbl/application_templates/MonoAssetManagerAndBuiltinResourceApplication.hpp"
+#include "nbl/examples/common/BuiltinResourcesApplication.hpp"
 
 
 using namespace nbl;
@@ -20,10 +20,10 @@ using namespace video;
 
 
 // In this application we'll cover buffer streaming, Buffer Device Address (BDA) and push constants 
-class StreamingAndBufferDeviceAddressApp final : public application_templates::MonoDeviceApplication, public application_templates::MonoAssetManagerAndBuiltinResourceApplication
+class StreamingAndBufferDeviceAddressApp final : public application_templates::MonoDeviceApplication, public examples::BuiltinResourcesApplication
 {
 		using device_base_t = application_templates::MonoDeviceApplication;
-		using asset_base_t = application_templates::MonoAssetManagerAndBuiltinResourceApplication;
+		using asset_base_t = examples::BuiltinResourcesApplication;
 
 		// This is the first example that submits multiple workloads in-flight. 
 		// What the shader does is it computes the minimum distance of each point against K other random input points.
@@ -91,7 +91,7 @@ class StreamingAndBufferDeviceAddressApp final : public application_templates::M
 				return false;
 
 			// this time we load a shader directly from a file
-			smart_refctd_ptr<IGPUShader> shader;
+			smart_refctd_ptr<IShader> shader;
 			{
 				IAssetLoader::SAssetLoadParams lp = {};
 				lp.logger = m_logger.get();
@@ -102,23 +102,19 @@ class StreamingAndBufferDeviceAddressApp final : public application_templates::M
 					return logFail("Could not load shader!");
 
 				// lets go straight from ICPUSpecializedShader to IGPUSpecializedShader
-				auto source = IAsset::castDown<ICPUShader>(assets[0]);
+				const auto shaderSource = IAsset::castDown<IShader>(assets[0]);
+				shader = m_device->compileShader({shaderSource.get()});
 				// The down-cast should not fail!
-				assert(source);
-
-				// this time we skip the use of the asset converter since the ICPUShader->IGPUShader path is quick and simple
-				shader = m_device->createShader(source.get());
-				if (!shader)
-					return logFail("Creation of a GPU Shader to from CPU Shader source failed!");
+				assert(shader);
 			}
 
 			// The StreamingTransientDataBuffers are actually composed on top of another useful utility called `CAsyncSingleBufferSubAllocator`
 			// The difference is that the streaming ones are made on top of ranges of `IGPUBuffer`s backed by mappable memory, whereas the
 			// `CAsyncSingleBufferSubAllocator` just allows you suballocate subranges of any `IGPUBuffer` range with deferred/latched frees.
 			constexpr uint32_t DownstreamBufferSize = sizeof(output_t)<<23;
 			constexpr uint32_t UpstreamBufferSize = sizeof(input_t)<<23;
-
-			m_utils = make_smart_refctd_ptr<IUtilities>(smart_refctd_ptr(m_device),smart_refctd_ptr(m_logger),DownstreamBufferSize,UpstreamBufferSize);
+			
+			m_utils = IUtilities::create(smart_refctd_ptr(m_device),smart_refctd_ptr(m_logger),DownstreamBufferSize,UpstreamBufferSize);
 			if (!m_utils)
 				return logFail("Failed to create Utilities!");
 			m_upStreamingBuffer = m_utils->getDefaultUpStreamingBuffer();
@@ -139,6 +135,7 @@ class StreamingAndBufferDeviceAddressApp final : public application_templates::M
 				IGPUComputePipeline::SCreationParams params = {};
 				params.layout = layout.get();
 				params.shader.shader = shader.get();
+				params.shader.entryPoint = "main";
 				if (!m_device->createComputePipelines(nullptr,{&params,1},&m_pipeline))
 					return logFail("Failed to create compute pipeline!\n");
 			}

06_HelloGraphicsQueue/main.cpp

@@ -3,18 +3,20 @@
 // For conditions of distribution and use, see copyright notice in nabla.h
 
 
-// I've moved out a tiny part of this example into a shared header for reuse, please open and read it.
-#include "nbl/application_templates/MonoDeviceApplication.hpp"
-#include "nbl/application_templates/MonoAssetManagerAndBuiltinResourceApplication.hpp"
+#include "nbl/examples/examples.hpp"
 
 #include "nbl/ext/ScreenShot/ScreenShot.h"
 
 
 using namespace nbl;
-using namespace core;
-using namespace system;
-using namespace asset;
-using namespace video;
+using namespace nbl::core;
+using namespace nbl::hlsl;
+using namespace nbl::system;
+using namespace nbl::asset;
+using namespace nbl::ui;
+using namespace nbl::video;
+using namespace nbl::examples;
+
 
 // Here we showcase the use of Graphics Queue only 
 // Steps we take in this example:
@@ -26,10 +28,10 @@ using namespace video;
 // - save the smallImg to disk
 // 
 // all without using IUtilities.
-class HelloGraphicsQueueApp final : public application_templates::MonoDeviceApplication, public application_templates::MonoAssetManagerAndBuiltinResourceApplication
+class HelloGraphicsQueueApp final : public application_templates::MonoDeviceApplication, public BuiltinResourcesApplication
 {
 		using device_base_t = application_templates::MonoDeviceApplication;
-		using asset_base_t = application_templates::MonoAssetManagerAndBuiltinResourceApplication;
+		using asset_base_t = BuiltinResourcesApplication;
 
 	public:
 		// Yay thanks to multiple inheritance we cannot forward ctors anymore.