Base impl for DXC HLSL compiler

Author: deprilula28

include/nbl/asset/utils/CHLSLCompiler.h

@@ -8,6 +8,9 @@
 #include "nbl/asset/utils/ISPIRVOptimizer.h"
 #include "nbl/asset/utils/IShaderCompiler.h"
 
+#include <dxc/dxcapi.h>
+#include <combaseapi.h>
+
 namespace nbl::asset
 {
 
@@ -42,6 +45,10 @@ class NBL_API2 CHLSLCompiler final : public IShaderCompiler
 
 		void insertExtraDefines(std::string& str, const core::SRange<const char* const>& defines) const override;
 
+		// TODO do we want to use ComPtr? 
+		std::unique_ptr<IDxcUtils> m_dxcUtils;
+		std::unique_ptr<IDxcCompiler3> m_dxcCompiler;
+
 		static CHLSLCompiler::SOptions option_cast(const IShaderCompiler::SCompilerOptions& options)
 		{
 			CHLSLCompiler::SOptions ret = {};
@@ -51,8 +58,23 @@ class NBL_API2 CHLSLCompiler final : public IShaderCompiler
 				ret.setCommonData(options);
 			return ret;
 		}
+
+		class DxcCompilationResult
+		{
+			public:
+			std::unique_ptr<IDxcBlobEncoding> errorMessages;
+			std::unique_ptr<IDxcBlob> objectBlob;
+			std::unique_ptr<IDxcResult> compileResult;
+			
+			char* GetErrorMessagesString()
+			{
+				return reinterpret_cast<char*>(errorMessages->GetBufferPointer());
+			}
+		};
+
+		DxcCompilationResult dxcCompile(asset::ICPUShader* source, LPCWSTR* args, uint32_t argCount, const SOptions& options);
 };
 
 }
 
-#endif
+#endif

src/nbl/asset/utils/CHLSLCompiler.cpp

@@ -8,6 +8,8 @@
 #include <regex>
 #include <iterator>
 
+#include <dxc/dxcapi.h>
+#include <combaseapi.h>
 
 using namespace nbl;
 using namespace nbl::asset;
@@ -16,6 +18,56 @@ using namespace nbl::asset;
 CHLSLCompiler::CHLSLCompiler(core::smart_refctd_ptr<system::ISystem>&& system)
     : IShaderCompiler(std::move(system))
 {
+    IDxcUtils* utils;
+    auto res = DxcCreateInstance(CLSID_DxcUtils, IID_PPV_ARGS(&utils));
+    assert(SUCCEEDED(res));
+
+    IDxcCompiler3* compiler;
+    res = DxcCreateInstance(CLSID_DxcCompiler, IID_PPV_ARGS(&compiler));
+    assert(SUCCEEDED(res));
+
+    m_dxcUtils = std::unique_ptr<IDxcUtils>(utils);
+    m_dxcCompiler = std::unique_ptr<IDxcCompiler3>(compiler);
+}
+
+CHLSLCompiler::DxcCompilationResult CHLSLCompiler::dxcCompile(asset::ICPUShader* source, LPCWSTR* args, uint32_t argCount, const SOptions& options)
+{
+    DxcBuffer sourceBuffer;
+    sourceBuffer.Ptr = source->getContent()->getPointer();
+    sourceBuffer.Size = source->getContent()->getSize();
+    sourceBuffer.Encoding = 0;
+
+    IDxcResult* compileResult;
+    auto res = m_dxcCompiler->Compile(&sourceBuffer, args, argCount, nullptr, IID_PPV_ARGS(&compileResult));
+    // If the compilation failed, this should still be a successful result
+    assert(SUCCEEDED(res));
+
+    HRESULT compilationStatus = 0;
+    res = compileResult->GetStatus(&compilationStatus);
+    assert(SUCCEEDED(res));
+
+    IDxcBlobEncoding* errorBuffer;
+    res = compileResult->GetErrorBuffer(&errorBuffer);
+    assert(SUCCEEDED(res));
+
+    DxcCompilationResult result;
+    result.errorMessages = std::unique_ptr<IDxcBlobEncoding>(errorBuffer);
+    result.compileResult = std::unique_ptr<IDxcResult>(compileResult);
+    result.objectBlob = nullptr;
+
+    if (!SUCCEEDED(compilationStatus))
+    {
+        options.logger.log(result.GetErrorMessagesString(), system::ILogger::ELL_ERROR);
+        return result;
+    }
+
+    IDxcBlob* resultingBlob;
+    res = compileResult->GetResult(&resultingBlob);
+    assert(SUCCEEDED(res));
+
+    result.objectBlob = std::unique_ptr<IDxcBlob>(resultingBlob);
+
+    return result;
 }
 
 core::smart_refctd_ptr<ICPUShader> CHLSLCompiler::compileToSPIRV(const char* code, const IShaderCompiler::SCompilerOptions& options) const
@@ -28,9 +80,38 @@ core::smart_refctd_ptr<ICPUShader> CHLSLCompiler::compileToSPIRV(const char* cod
         return nullptr;
     }
 
-    core::smart_refctd_ptr<ICPUBuffer> spirv = nullptr;
-    // TODO: Use DXC
-    return core::make_smart_refctd_ptr<asset::ICPUShader>(std::move(spirv), options.stage, IShader::E_CONTENT_TYPE::ECT_SPIRV, options.preprocessorOptions.sourceIdentifier.data());
+    core::smart_refctd_ptr<asset::ICPUShader> includesResolved;
+    if (hlslOptions.includeFinder != nullptr)
+    {
+        includesResolved = resolveIncludeDirectives(code, hlslOptions.stage, hlslOptions.sourceIdentifier.data(), hlslOptions.maxSelfInclusionCount, hlslOptions.logger);
+        if (includesResolved)
+        {
+            code = reinterpret_cast<const char*>(includesResolved->getContent()->getPointer());
+        }
+    }
+
+    LPCWSTR arguments[] = {
+        // These will always be present
+        L"-spirv",
+
+        // These are debug only
+        L"-DPARTI",
+        L"-DBOY"
+    };
+    const uint32_t allArgs = 3;
+    const uint32_t nonDebugArgs = 1;
+
+    DxcCompilationResult compileResult = dxcCompile(includesResolved.get(), &arguments[0], hlslOptions.genDebugInfo ? allArgs : nonDebugArgs, hlslOptions);
+
+    if (!compileResult.objectBlob)
+    {
+        return nullptr;
+    }
+
+    auto outSpirv = core::make_smart_refctd_ptr<ICPUBuffer>(compileResult.objectBlob->GetBufferSize());
+    memcpy(outSpirv->getPointer(), compileResult.objectBlob->GetBufferPointer(), compileResult.objectBlob->GetBufferSize());
+
+    return core::make_smart_refctd_ptr<asset::ICPUShader>(std::move(outSpirv), hlslOptions.stage, IShader::E_CONTENT_TYPE::ECT_SPIRV, hlslOptions.sourceIdentifier.data());
 }
 
 void CHLSLCompiler::insertExtraDefines(std::string& code, const core::SRange<const char* const>& defines) const