diff options
47 files changed, 2221 insertions, 1660 deletions
diff --git a/.gitignore b/.gitignore index 9d3adf5e3..e941540c1 100644 --- a/.gitignore +++ b/.gitignore @@ -8,6 +8,7 @@ *.ilk *.obj *.slang-module +*.zip .clang-format bin/ intermediate/ diff --git a/build/visual-studio/gfx/gfx.vcxproj b/build/visual-studio/gfx/gfx.vcxproj index e80387bfa..789440fb7 100644 --- a/build/visual-studio/gfx/gfx.vcxproj +++ b/build/visual-studio/gfx/gfx.vcxproj @@ -184,7 +184,9 @@ <ClInclude Include="..\..\..\tools\gfx\open-gl\render-gl.h" /> <ClInclude Include="..\..\..\tools\gfx\render-graphics-common.h" /> <ClInclude Include="..\..\..\tools\gfx\render.h" /> + <ClInclude Include="..\..\..\tools\gfx\renderer-shared.h" /> <ClInclude Include="..\..\..\tools\gfx\shader-cursor.h" /> + <ClInclude Include="..\..\..\tools\gfx\slang-gfx-helper.h" /> <ClInclude Include="..\..\..\tools\gfx\surface.h" /> <ClInclude Include="..\..\..\tools\gfx\vulkan\render-vk.h" /> <ClInclude Include="..\..\..\tools\gfx\vulkan\vk-api.h" /> @@ -206,7 +208,9 @@ <ClCompile Include="..\..\..\tools\gfx\open-gl\render-gl.cpp" /> <ClCompile Include="..\..\..\tools\gfx\render-graphics-common.cpp" /> <ClCompile Include="..\..\..\tools\gfx\render.cpp" /> + <ClCompile Include="..\..\..\tools\gfx\renderer-shared.cpp" /> <ClCompile Include="..\..\..\tools\gfx\shader-cursor.cpp" /> + <ClCompile Include="..\..\..\tools\gfx\slang-gfx-helper.cpp" /> <ClCompile Include="..\..\..\tools\gfx\surface.cpp" /> <ClCompile Include="..\..\..\tools\gfx\vulkan\render-vk.cpp" /> <ClCompile Include="..\..\..\tools\gfx\vulkan\vk-api.cpp" /> diff --git a/build/visual-studio/gfx/gfx.vcxproj.filters b/build/visual-studio/gfx/gfx.vcxproj.filters index bfb99449b..90caef2f9 100644 --- a/build/visual-studio/gfx/gfx.vcxproj.filters +++ b/build/visual-studio/gfx/gfx.vcxproj.filters @@ -48,9 +48,15 @@ <ClInclude Include="..\..\..\tools\gfx\render.h"> <Filter>Header Files</Filter> </ClInclude> + <ClInclude Include="..\..\..\tools\gfx\renderer-shared.h"> + <Filter>Header Files</Filter> + </ClInclude> <ClInclude Include="..\..\..\tools\gfx\shader-cursor.h"> <Filter>Header Files</Filter> </ClInclude> + <ClInclude Include="..\..\..\tools\gfx\slang-gfx-helper.h"> + <Filter>Header Files</Filter> + </ClInclude> <ClInclude Include="..\..\..\tools\gfx\surface.h"> <Filter>Header Files</Filter> </ClInclude> @@ -110,9 +116,15 @@ <ClCompile Include="..\..\..\tools\gfx\render.cpp"> <Filter>Source Files</Filter> </ClCompile> + <ClCompile Include="..\..\..\tools\gfx\renderer-shared.cpp"> + <Filter>Source Files</Filter> + </ClCompile> <ClCompile Include="..\..\..\tools\gfx\shader-cursor.cpp"> <Filter>Source Files</Filter> </ClCompile> + <ClCompile Include="..\..\..\tools\gfx\slang-gfx-helper.cpp"> + <Filter>Source Files</Filter> + </ClCompile> <ClCompile Include="..\..\..\tools\gfx\surface.cpp"> <Filter>Source Files</Filter> </ClCompile> diff --git a/examples/gpu-printing/main.cpp b/examples/gpu-printing/main.cpp index 75c083a33..03b20b969 100644 --- a/examples/gpu-printing/main.cpp +++ b/examples/gpu-printing/main.cpp @@ -8,6 +8,7 @@ using Slang::ComPtr; #include "gfx/render.h" #include "gfx/d3d11/render-d3d11.h" #include "tools/graphics-app-framework/window.h" +#include "source/core/slang-basic.h" using namespace gfx; #include <string> @@ -69,17 +70,17 @@ ComPtr<gfx::IRenderer> gRenderer; ComPtr<slang::ISession> gSlangSession; ComPtr<slang::IModule> gSlangModule; -RefPtr<gfx::ShaderProgram> gProgram; +ComPtr<gfx::IShaderProgram> gProgram; -RefPtr<gfx::PipelineLayout> gPipelineLayout; -RefPtr<gfx::PipelineState> gPipelineState; -RefPtr<gfx::DescriptorSet> gDescriptorSet; +ComPtr<gfx::IPipelineLayout> gPipelineLayout; +ComPtr<gfx::IPipelineState> gPipelineState; +ComPtr<gfx::IDescriptorSet> gDescriptorSet; -Dictionary<int, std::string> gHashedStrings; +Slang::Dictionary<int, std::string> gHashedStrings; GPUPrinting gGPUPrinting; -RefPtr<gfx::ShaderProgram> loadComputeProgram(slang::IModule* slangModule, char const* entryPointName) +ComPtr<gfx::IShaderProgram> loadComputeProgram(slang::IModule* slangModule, char const* entryPointName) { ComPtr<slang::IEntryPoint> entryPoint; slangModule->findEntryPointByName(entryPointName, entryPoint.writeRef()); @@ -95,12 +96,12 @@ RefPtr<gfx::ShaderProgram> loadComputeProgram(slang::IModule* slangModule, char char const* code = (char const*) codeBlob->getBufferPointer(); char const* codeEnd = code + codeBlob->getBufferSize(); - gfx::ShaderProgram::KernelDesc kernelDescs[] = + gfx::IShaderProgram::KernelDesc kernelDescs[] = { { gfx::StageType::Compute, code, codeEnd }, }; - gfx::ShaderProgram::Desc programDesc; + gfx::IShaderProgram::Desc programDesc; programDesc.pipelineType = gfx::PipelineType::Compute; programDesc.kernels = &kernelDescs[0]; programDesc.kernelCount = 2; @@ -133,21 +134,21 @@ Result execute() gProgram = loadComputeProgram(gSlangModule, "computeMain"); if(!gProgram) return SLANG_FAIL; - DescriptorSetLayout::SlotRangeDesc slotRanges[] = + IDescriptorSetLayout::SlotRangeDesc slotRanges[] = { - DescriptorSetLayout::SlotRangeDesc(DescriptorSlotType::StorageBuffer), + IDescriptorSetLayout::SlotRangeDesc(DescriptorSlotType::StorageBuffer), }; - DescriptorSetLayout::Desc descriptorSetLayoutDesc; + IDescriptorSetLayout::Desc descriptorSetLayoutDesc; descriptorSetLayoutDesc.slotRangeCount = 1; descriptorSetLayoutDesc.slotRanges = &slotRanges[0]; auto descriptorSetLayout = gRenderer->createDescriptorSetLayout(descriptorSetLayoutDesc); if(!descriptorSetLayout) return SLANG_FAIL; - PipelineLayout::DescriptorSetDesc descriptorSets[] = + IPipelineLayout::DescriptorSetDesc descriptorSets[] = { - PipelineLayout::DescriptorSetDesc( descriptorSetLayout ), + IPipelineLayout::DescriptorSetDesc( descriptorSetLayout ), }; - PipelineLayout::Desc pipelineLayoutDesc; + IPipelineLayout::Desc pipelineLayoutDesc; pipelineLayoutDesc.renderTargetCount = 1; pipelineLayoutDesc.descriptorSetCount = 1; pipelineLayoutDesc.descriptorSets = &descriptorSets[0]; @@ -176,14 +177,14 @@ Result execute() size_t printBufferSize = 4 * 1024; // use a small-ish (4KB) buffer for print output - BufferResource::Desc printBufferDesc; + IBufferResource::Desc printBufferDesc; printBufferDesc.init(printBufferSize); printBufferDesc.elementSize = sizeof(uint32_t); - printBufferDesc.cpuAccessFlags = Resource::AccessFlag::Read; // | Resource::AccessFlag::Write; - auto printBuffer = gRenderer->createBufferResource(Resource::Usage::UnorderedAccess, printBufferDesc); + printBufferDesc.cpuAccessFlags = IResource::AccessFlag::Read; // | Resource::AccessFlag::Write; + auto printBuffer = gRenderer->createBufferResource(IResource::Usage::UnorderedAccess, printBufferDesc); - ResourceView::Desc printBufferViewDesc; - printBufferViewDesc.type = ResourceView::Type::UnorderedAccess; + IResourceView::Desc printBufferViewDesc; + printBufferViewDesc.type = IResourceView::Type::UnorderedAccess; auto printBufferView = gRenderer->createBufferView(printBuffer, printBufferViewDesc); // TODO: need to copy a zero into the start of the print buffer! diff --git a/examples/hello-world/main.cpp b/examples/hello-world/main.cpp index da35f3f0a..77ca8a978 100644 --- a/examples/hello-world/main.cpp +++ b/examples/hello-world/main.cpp @@ -36,8 +36,10 @@ #include "gfx/d3d11/render-d3d11.h" #include "tools/graphics-app-framework/window.h" #include "slang-com-ptr.h" +#include "source/core/slang-basic.h" using namespace gfx; +using namespace Slang; // For the purposes of a small example, we will define the vertex data for a // single triangle directly in the source file. It should be easy to extend @@ -72,7 +74,7 @@ struct HelloWorld // Slang API. This function is representative of code that a user // might write to integrate Slang into their renderer/engine. // -RefPtr<gfx::ShaderProgram> loadShaderProgram(gfx::IRenderer* renderer) +ComPtr<gfx::IShaderProgram> loadShaderProgram(gfx::IRenderer* renderer) { // First, we need to create a "session" for interacting with the Slang // compiler. This scopes all of our application's interactions @@ -183,13 +185,13 @@ RefPtr<gfx::ShaderProgram> loadShaderProgram(gfx::IRenderer* renderer) // Reminder: this section does not involve the Slang API at all. // - gfx::ShaderProgram::KernelDesc kernelDescs[] = + gfx::IShaderProgram::KernelDesc kernelDescs[] = { { gfx::StageType::Vertex, vertexCode, vertexCodeEnd }, { gfx::StageType::Fragment, fragmentCode, fragmentCodeEnd }, }; - gfx::ShaderProgram::Desc programDesc; + gfx::IShaderProgram::Desc programDesc; programDesc.pipelineType = gfx::PipelineType::Graphics; programDesc.kernels = &kernelDescs[0]; programDesc.kernelCount = 2; @@ -230,19 +232,19 @@ int gWindowHeight = 768; gfx::ApplicationContext* gAppContext; gfx::Window* gWindow; Slang::ComPtr<gfx::IRenderer> gRenderer; -RefPtr<gfx::BufferResource> gConstantBuffer; +ComPtr<gfx::IBufferResource> gConstantBuffer; -RefPtr<gfx::PipelineLayout> gPipelineLayout; -RefPtr<gfx::PipelineState> gPipelineState; -RefPtr<gfx::DescriptorSet> gDescriptorSet; +ComPtr<gfx::IPipelineLayout> gPipelineLayout; +ComPtr<gfx::IPipelineState> gPipelineState; +ComPtr<gfx::IDescriptorSet> gDescriptorSet; -RefPtr<gfx::BufferResource> gVertexBuffer; +ComPtr<gfx::IBufferResource> gVertexBuffer; // Now that we've covered the function that actually loads and // compiles our Slang shade code, we can go through the rest // of the application code without as much commentary. // -Result initialize() +Slang::Result initialize() { // Create a window for our application to render into. // @@ -264,7 +266,7 @@ Result initialize() rendererDesc.width = gWindowWidth; rendererDesc.height = gWindowHeight; { - Result res = gRenderer->initialize(rendererDesc, getPlatformWindowHandle(gWindow)); + gfx::Result res = gRenderer->initialize(rendererDesc, getPlatformWindowHandle(gWindow)); if(SLANG_FAILED(res)) return res; } @@ -278,13 +280,13 @@ Result initialize() // int constantBufferSize = 16 * sizeof(float); - BufferResource::Desc constantBufferDesc; + IBufferResource::Desc constantBufferDesc; constantBufferDesc.init(constantBufferSize); - constantBufferDesc.setDefaults(Resource::Usage::ConstantBuffer); - constantBufferDesc.cpuAccessFlags = Resource::AccessFlag::Write; + constantBufferDesc.setDefaults(IResource::Usage::ConstantBuffer); + constantBufferDesc.cpuAccessFlags = IResource::AccessFlag::Write; gConstantBuffer = gRenderer->createBufferResource( - Resource::Usage::ConstantBuffer, + IResource::Usage::ConstantBuffer, constantBufferDesc); if(!gConstantBuffer) return SLANG_FAIL; @@ -305,11 +307,11 @@ Result initialize() // Next we allocate a vertex buffer for our pre-initialized // vertex data. // - BufferResource::Desc vertexBufferDesc; + IBufferResource::Desc vertexBufferDesc; vertexBufferDesc.init(kVertexCount * sizeof(Vertex)); - vertexBufferDesc.setDefaults(Resource::Usage::VertexBuffer); + vertexBufferDesc.setDefaults(IResource::Usage::VertexBuffer); gVertexBuffer = gRenderer->createBufferResource( - Resource::Usage::VertexBuffer, + IResource::Usage::VertexBuffer, vertexBufferDesc, &kVertexData[0]); if(!gVertexBuffer) return SLANG_FAIL; @@ -317,7 +319,7 @@ Result initialize() // Now we will use our `loadShaderProgram` function to load // the code from `shaders.slang` into the graphics API. // - RefPtr<ShaderProgram> shaderProgram = loadShaderProgram(gRenderer); + ComPtr<IShaderProgram> shaderProgram = loadShaderProgram(gRenderer); if(!shaderProgram) return SLANG_FAIL; // Our example graphics API usess a "modern" D3D12/Vulkan style @@ -326,11 +328,11 @@ Result initialize() // // First, we need to construct a descriptor set *layout*. // - DescriptorSetLayout::SlotRangeDesc slotRanges[] = + IDescriptorSetLayout::SlotRangeDesc slotRanges[] = { - DescriptorSetLayout::SlotRangeDesc(DescriptorSlotType::UniformBuffer), + IDescriptorSetLayout::SlotRangeDesc(DescriptorSlotType::UniformBuffer), }; - DescriptorSetLayout::Desc descriptorSetLayoutDesc; + IDescriptorSetLayout::Desc descriptorSetLayoutDesc; descriptorSetLayoutDesc.slotRangeCount = 1; descriptorSetLayoutDesc.slotRanges = &slotRanges[0]; auto descriptorSetLayout = gRenderer->createDescriptorSetLayout(descriptorSetLayoutDesc); @@ -340,11 +342,11 @@ Result initialize() // that we will render with only a single descriptor set bound. // - PipelineLayout::DescriptorSetDesc descriptorSets[] = + IPipelineLayout::DescriptorSetDesc descriptorSets[] = { - PipelineLayout::DescriptorSetDesc( descriptorSetLayout ), + IPipelineLayout::DescriptorSetDesc( descriptorSetLayout ), }; - PipelineLayout::Desc pipelineLayoutDesc; + IPipelineLayout::Desc pipelineLayoutDesc; pipelineLayoutDesc.renderTargetCount = 1; pipelineLayoutDesc.descriptorSetCount = 1; pipelineLayoutDesc.descriptorSets = &descriptorSets[0]; diff --git a/examples/heterogeneous-hello-world/main.cpp b/examples/heterogeneous-hello-world/main.cpp index 51aff0a17..0446ea1a7 100644 --- a/examples/heterogeneous-hello-world/main.cpp +++ b/examples/heterogeneous-hello-world/main.cpp @@ -37,20 +37,22 @@ #include "gfx/d3d11/render-d3d11.h" #include "tools/graphics-app-framework/window.h" #include "../../prelude/slang-cpp-types.h" +#include "source/core/slang-basic.h" + using namespace gfx; // We create global ref pointers to avoid dereferencing values // -RefPtr<gfx::ShaderProgram> gShaderProgram; -RefPtr<gfx::ApplicationContext> gAppContext; +ComPtr<gfx::IShaderProgram> gShaderProgram; +Slang::RefPtr<gfx::ApplicationContext> gAppContext; Slang::ComPtr<gfx::IRenderer> gRenderer; -RefPtr<gfx::BufferResource> gStructuredBuffer; +ComPtr<gfx::IBufferResource> gStructuredBuffer; -RefPtr<gfx::PipelineLayout> gPipelineLayout; -RefPtr<gfx::PipelineState> gPipelineState; -RefPtr<gfx::DescriptorSetLayout> gDescriptorSetLayout; -RefPtr<gfx::DescriptorSet> gDescriptorSet; +ComPtr<gfx::IPipelineLayout> gPipelineLayout; +ComPtr<gfx::IPipelineState> gPipelineState; +ComPtr<gfx::IDescriptorSetLayout> gDescriptorSetLayout; +ComPtr<gfx::IDescriptorSet> gDescriptorSet; // Boilerplate types to help the slan-generated file // @@ -67,7 +69,7 @@ bool executeComputation_0(); extern unsigned char __computeMain[]; extern size_t __computeMainSize; -gfx::ShaderProgram* loadShaderProgram(gfx::IRenderer* renderer, unsigned char computeCode[], size_t computeCodeSize) +gfx::IShaderProgram* loadShaderProgram(gfx::IRenderer* renderer, unsigned char computeCode[], size_t computeCodeSize) { // We extract the begin/end pointers to the output code buffers directly // @@ -79,12 +81,12 @@ gfx::ShaderProgram* loadShaderProgram(gfx::IRenderer* renderer, unsigned char co // Reminder: this section does not involve the Slang API at all. // - gfx::ShaderProgram::KernelDesc kernelDescs[] = + gfx::IShaderProgram::KernelDesc kernelDescs[] = { { gfx::StageType::Compute, computeCode, computeCodeEnd }, }; - gfx::ShaderProgram::Desc programDesc; + gfx::IShaderProgram::Desc programDesc; programDesc.pipelineType = gfx::PipelineType::Compute; programDesc.kernels = &kernelDescs[0]; programDesc.kernelCount = 1; @@ -133,26 +135,26 @@ gfx::IRenderer* createRenderer( return gRenderer; } -gfx::BufferResource* createStructuredBuffer(gfx::IRenderer* renderer, float* initialArray) +gfx::IBufferResource* createStructuredBuffer(gfx::IRenderer* renderer, float* initialArray) { // Create a structured buffer for storing the data for computation // int structuredBufferSize = 4 * sizeof(float); - BufferResource::Desc structuredBufferDesc; + IBufferResource::Desc structuredBufferDesc; structuredBufferDesc.init(structuredBufferSize); - structuredBufferDesc.setDefaults(Resource::Usage::UnorderedAccess); + structuredBufferDesc.setDefaults(IResource::Usage::UnorderedAccess); structuredBufferDesc.elementSize = 4; - structuredBufferDesc.cpuAccessFlags = Resource::AccessFlag::Read; + structuredBufferDesc.cpuAccessFlags = IResource::AccessFlag::Read; gStructuredBuffer = renderer->createBufferResource( - Resource::Usage::UnorderedAccess, + IResource::Usage::UnorderedAccess, structuredBufferDesc, initialArray); return gStructuredBuffer; } -gfx::DescriptorSetLayout* buildDescriptorSetLayout(gfx::IRenderer* renderer) +gfx::IDescriptorSetLayout* buildDescriptorSetLayout(gfx::IRenderer* renderer) { // Our example graphics API usess a "modern" D3D12/Vulkan style // of resource binding, so now we will dive into describing and @@ -160,28 +162,28 @@ gfx::DescriptorSetLayout* buildDescriptorSetLayout(gfx::IRenderer* renderer) // // First, we need to construct a descriptor set *layout*. // - DescriptorSetLayout::SlotRangeDesc slotRanges[] = + IDescriptorSetLayout::SlotRangeDesc slotRanges[] = { - DescriptorSetLayout::SlotRangeDesc(DescriptorSlotType::StorageBuffer), + IDescriptorSetLayout::SlotRangeDesc(DescriptorSlotType::StorageBuffer), }; - DescriptorSetLayout::Desc descriptorSetLayoutDesc; + IDescriptorSetLayout::Desc descriptorSetLayoutDesc; descriptorSetLayoutDesc.slotRangeCount = 1; descriptorSetLayoutDesc.slotRanges = &slotRanges[0]; gDescriptorSetLayout = renderer->createDescriptorSetLayout(descriptorSetLayoutDesc); return gDescriptorSetLayout; } -gfx::PipelineLayout* buildPipeline(gfx::IRenderer* renderer, gfx::DescriptorSetLayout* descriptorSetLayout) +gfx::IPipelineLayout* buildPipeline(gfx::IRenderer* renderer, gfx::IDescriptorSetLayout* descriptorSetLayout) { // Next we will allocate a pipeline layout, which specifies // that we will render with only a single descriptor set bound. // - PipelineLayout::DescriptorSetDesc descriptorSets[] = + IPipelineLayout::DescriptorSetDesc descriptorSets[] = { - PipelineLayout::DescriptorSetDesc(descriptorSetLayout), + IPipelineLayout::DescriptorSetDesc(descriptorSetLayout), }; - PipelineLayout::Desc pipelineLayoutDesc; + IPipelineLayout::Desc pipelineLayoutDesc; pipelineLayoutDesc.renderTargetCount = 1; pipelineLayoutDesc.descriptorSetCount = 1; pipelineLayoutDesc.descriptorSets = &descriptorSets[0]; @@ -190,10 +192,10 @@ gfx::PipelineLayout* buildPipeline(gfx::IRenderer* renderer, gfx::DescriptorSetL return gPipelineLayout; } -gfx::DescriptorSet* buildDescriptorSet( +gfx::IDescriptorSet* buildDescriptorSet( gfx::IRenderer* renderer, - gfx::DescriptorSetLayout* descriptorSetLayout, - gfx::BufferResource* structuredBuffer) + gfx::IDescriptorSetLayout* descriptorSetLayout, + gfx::IBufferResource* structuredBuffer) { // Once we have the descriptor set layout, we can allocate // and fill in a descriptor set to hold our parameters. @@ -204,18 +206,18 @@ gfx::DescriptorSet* buildDescriptorSet( // Once we have the bufferResource created, we can fill in // a descriptor set for creating a structured buffer // - ResourceView::Desc resourceViewDesc; - resourceViewDesc.type = ResourceView::Type::UnorderedAccess; + IResourceView::Desc resourceViewDesc; + resourceViewDesc.type = IResourceView::Type::UnorderedAccess; auto resourceView = renderer->createBufferView(structuredBuffer, resourceViewDesc); gDescriptorSet->setResource(0, 0, resourceView); return gDescriptorSet; } -gfx::PipelineState* buildPipelineState( - gfx::ShaderProgram* shaderProgram, +gfx::IPipelineState* buildPipelineState( + gfx::IShaderProgram* shaderProgram, gfx::IRenderer* renderer, - gfx::PipelineLayout* pipelineLayout) + gfx::IPipelineLayout* pipelineLayout) { // Following the D3D12/Vulkan style of API, we need a pipeline state object // (PSO) to encapsulate the configuration of the overall graphics pipeline. @@ -240,9 +242,9 @@ void printInitialValues(float* initialArray, int length) void dispatchComputation( gfx::IRenderer* gRenderer, - gfx::PipelineState* gPipelineState, - gfx::PipelineLayout* gPipelineLayout, - gfx::DescriptorSet* gDescriptorSet, + gfx::IPipelineState* gPipelineState, + gfx::IPipelineLayout* gPipelineLayout, + gfx::IDescriptorSet* gDescriptorSet, unsigned int gridDimsX, unsigned int gridDimsY, unsigned int gridDimsZ) @@ -256,7 +258,7 @@ void dispatchComputation( void print_output( gfx::IRenderer* renderer, - gfx::BufferResource* structuredBuffer, + gfx::IBufferResource* structuredBuffer, int length) { if (float* outputData = (float*)renderer->map(structuredBuffer, MapFlavor::HostRead)) @@ -301,22 +303,22 @@ gfx_DescriptorSetLayout_0* buildDescriptorSetLayout_0(gfx_Renderer_0* _0) gfx_PipelineLayout_0* buildPipeline_0(gfx_Renderer_0* _0, gfx_DescriptorSetLayout_0* _1) { - return (gfx_PipelineLayout_0*)buildPipeline((gfx::IRenderer*)_0, (gfx::DescriptorSetLayout*)_1); + return (gfx_PipelineLayout_0*)buildPipeline((gfx::IRenderer*)_0, (gfx::IDescriptorSetLayout*)_1); } gfx_DescriptorSet_0* buildDescriptorSet_0(gfx_Renderer_0* _0, gfx_DescriptorSetLayout_0* _1, gfx_BufferResource_0* _2) { return (gfx_DescriptorSet_0*)buildDescriptorSet( (gfx::IRenderer*)_0, - (gfx::DescriptorSetLayout*)_1, - (gfx::BufferResource*)_2); + (gfx::IDescriptorSetLayout*)_1, + (gfx::IBufferResource*)_2); } gfx_PipelineState_0* buildPipelineState_0(gfx_ShaderProgram_0* _0, gfx_Renderer_0* _1, gfx_PipelineLayout_0* _2) { return (gfx_PipelineState_0*)buildPipelineState( - (gfx::ShaderProgram*)_0, (gfx::IRenderer*)_1, - (gfx::PipelineLayout*)_2); + (gfx::IShaderProgram*)_0, (gfx::IRenderer*)_1, + (gfx::IPipelineLayout*)_2); } void printInitialValues_0(FixedArray<float, 4> _0, int32_t _1) @@ -328,9 +330,9 @@ void dispatchComputation_0(gfx_Renderer_0* _0, gfx_PipelineState_0* _1, gfx_Pipe { dispatchComputation( (gfx::IRenderer*)_0, - (gfx::PipelineState*)_1, - (gfx::PipelineLayout*)_2, - (gfx::DescriptorSet*)_3, + (gfx::IPipelineState*)_1, + (gfx::IPipelineLayout*)_2, + (gfx::IDescriptorSet*)_3, gridDimsX, gridDimsY, gridDimsZ); @@ -348,7 +350,7 @@ gfx_BufferResource_0* unconvertBuffer_0(RWStructuredBuffer<float> _0) { void print_output_0(gfx_Renderer_0* _0, gfx_BufferResource_0* _1, int32_t _2) { - print_output((gfx::IRenderer*)_0, (gfx::BufferResource*)_1, _2); + print_output((gfx::IRenderer*)_0, (gfx::IBufferResource*)_1, _2); } // This "inner" main function is used by the platform abstraction diff --git a/examples/model-viewer/main.cpp b/examples/model-viewer/main.cpp index 2dc7df3b5..387ec7293 100644 --- a/examples/model-viewer/main.cpp +++ b/examples/model-viewer/main.cpp @@ -23,7 +23,8 @@ #include "graphics-app-framework/window.h" #include "graphics-app-framework/gui.h" using namespace gfx; - +using Slang::RefObject; +using Slang::RefPtr; // We will use a few utilities from the C++ standard library, // just to keep the code short. Note that the Slang API does // not use or require any C++ standard library features. @@ -382,7 +383,7 @@ struct ParameterBlockLayout : RefObject // API-specific layout information computes from `slangTypelayout`. // - RefPtr<gfx::DescriptorSetLayout> descriptorSetLayout; + ComPtr<gfx::IDescriptorSetLayout> descriptorSetLayout; }; // // A parameter block layout can be computed for any `struct` type @@ -423,7 +424,7 @@ RefPtr<ParameterBlockLayout> getParameterBlockLayout( // create a graphics-API-level descriptor-set layout that // is compatible with the original declaration. // - std::vector<gfx::DescriptorSetLayout::SlotRangeDesc> slotRanges; + std::vector<gfx::IDescriptorSetLayout::SlotRangeDesc> slotRanges; // If the type has any ordinary data, then the descriptor set // will need a constant buffer to be the first thing it stores. @@ -438,7 +439,7 @@ RefPtr<ParameterBlockLayout> getParameterBlockLayout( if(primaryConstantBufferSize) { slotRanges.push_back( - gfx::DescriptorSetLayout::SlotRangeDesc( + gfx::IDescriptorSetLayout::SlotRangeDesc( gfx::DescriptorSlotType::UniformBuffer)); } @@ -453,7 +454,7 @@ RefPtr<ParameterBlockLayout> getParameterBlockLayout( // Now that we've collected the graphics-API level binding // information, we can construct a graphics API descriptor set // layout. - gfx::DescriptorSetLayout::Desc descriptorSetLayoutDesc; + gfx::IDescriptorSetLayout::Desc descriptorSetLayoutDesc; descriptorSetLayoutDesc.slotRangeCount = slotRanges.size(); descriptorSetLayoutDesc.slotRanges = slotRanges.data(); auto descriptorSetLayout = renderer->createDescriptorSetLayout(descriptorSetLayoutDesc); @@ -552,7 +553,7 @@ struct ParameterBlockEncoder // The underlying descriptor set being filled in. // - gfx::DescriptorSet* descriptorSet = nullptr; + gfx::IDescriptorSet* descriptorSet = nullptr; // The Slang type information for the part of the // block that we are filling in. This might be the @@ -648,11 +649,11 @@ struct ParameterBlock : RefObject // The (optional) constant buffer that holds the values // for any ordinay fields. This will be null if // `layout->primaryConstantBufferSize` is zero. - RefPtr<BufferResource> primaryConstantBuffer; + ComPtr<IBufferResource> primaryConstantBuffer; // The graphics-API descriptor set that provides storage // for any resource fields. - RefPtr<gfx::DescriptorSet> descriptorSet; + ComPtr<gfx::IDescriptorSet> descriptorSet; ParameterBlockEncoder beginEncoding(); }; @@ -674,15 +675,15 @@ RefPtr<ParameterBlock> allocateParameterBlockImpl( // If the parameter block has any ordinary data, then it requires // a "primary" constant buffer to hold that data. // - RefPtr<gfx::BufferResource> primaryConstantBuffer = nullptr; + ComPtr<gfx::IBufferResource> primaryConstantBuffer = nullptr; if(auto primaryConstantBufferSize = layout->primaryConstantBufferSize) { - gfx::BufferResource::Desc bufferDesc; + gfx::IBufferResource::Desc bufferDesc; bufferDesc.init(primaryConstantBufferSize); - bufferDesc.setDefaults(gfx::Resource::Usage::ConstantBuffer); - bufferDesc.cpuAccessFlags = gfx::Resource::AccessFlag::Write; + bufferDesc.setDefaults(gfx::IResource::Usage::ConstantBuffer); + bufferDesc.cpuAccessFlags = gfx::IResource::AccessFlag::Write; primaryConstantBuffer = renderer->createBufferResource( - gfx::Resource::Usage::ConstantBuffer, + gfx::IResource::Usage::ConstantBuffer, bufferDesc); // The primary constant buffer will always be the first thing @@ -774,7 +775,7 @@ struct Effect : RefObject // Additional state corresponding to the data needed // to create a graphics-API pipeline state object. - RefPtr<gfx::InputLayout> inputLayout; + ComPtr<gfx::IInputLayout> inputLayout; Int renderTargetCount; }; @@ -791,8 +792,8 @@ struct EffectVariant : RefObject // that need to be bound in order to use this // effect. // - RefPtr<gfx::PipelineLayout> pipelineLayout; - RefPtr<gfx::PipelineState> pipelineState; + ComPtr<gfx::IPipelineLayout> pipelineLayout; + ComPtr<gfx::IPipelineState> pipelineState; }; // // A specialized variant is created based on a base effect @@ -839,13 +840,13 @@ RefPtr<EffectVariant> createEffectVaraint( // be determined based on the descriptor-set layouts // already cached in the given parameter block layouts. // - std::vector<PipelineLayout::DescriptorSetDesc> descriptorSets; + std::vector<IPipelineLayout::DescriptorSetDesc> descriptorSets; for(UInt pp = 0; pp < parameterBlockCount; ++pp) { descriptorSets.emplace_back( parameterBlockLayouts[pp]->descriptorSetLayout); } - PipelineLayout::Desc pipelineLayoutDesc; + IPipelineLayout::Desc pipelineLayoutDesc; pipelineLayoutDesc.renderTargetCount = 1; pipelineLayoutDesc.descriptorSetCount = descriptorSets.size(); pipelineLayoutDesc.descriptorSets = descriptorSets.data(); @@ -927,7 +928,7 @@ RefPtr<EffectVariant> createEffectVaraint( // to the graphics APIs loading logic. // std::vector<ISlangBlob*> kernelBlobs; - std::vector<gfx::ShaderProgram::KernelDesc> kernelDescs; + std::vector<gfx::IShaderProgram::KernelDesc> kernelDescs; for(int ii = 0; ii < entryPointCount; ++ii) { auto entryPoint = program->entryPoints[ii]; @@ -937,7 +938,7 @@ RefPtr<EffectVariant> createEffectVaraint( kernelBlobs.push_back(blob); - ShaderProgram::KernelDesc kernelDesc; + IShaderProgram::KernelDesc kernelDesc; char const* codeBegin = (char const*) blob->getBufferPointer(); char const* codeEnd = codeBegin + blob->getBufferSize(); @@ -960,7 +961,7 @@ RefPtr<EffectVariant> createEffectVaraint( spDestroyCompileRequest(slangRequest); // We use the graphics API to load a program into the GPU - gfx::ShaderProgram::Desc programDesc; + gfx::IShaderProgram::Desc programDesc; programDesc.pipelineType = gfx::PipelineType::Graphics; programDesc.kernels = kernelDescs.data(); programDesc.kernelCount = kernelDescs.size(); @@ -1020,11 +1021,11 @@ struct ShaderCache : RefObject Slang::HashCode getHashCode() const { - auto hash = ::getHashCode(effect); - hash = combineHash(hash, ::getHashCode(parameterBlockCount)); + auto hash = Slang::getHashCode(effect); + hash = Slang::combineHash(hash, Slang::getHashCode(parameterBlockCount)); for( UInt ii = 0; ii < parameterBlockCount; ++ii ) { - hash = combineHash(hash, ::getHashCode(parameterBlockLayouts[ii])); + hash = Slang::combineHash(hash, Slang::getHashCode(parameterBlockLayouts[ii])); } return hash; } @@ -1033,7 +1034,7 @@ struct ShaderCache : RefObject // The shader cache is mostly just a dictionary mapping // variant keys to the associated variant, generated on-demand. // - Dictionary<VariantKey, RefPtr<EffectVariant> > variants; + Slang::Dictionary<VariantKey, RefPtr<EffectVariant> > variants; // Getting a variant is just a matter of looking for an // existing entry in the dictionary, and creating one @@ -1372,8 +1373,8 @@ struct Model : RefObject { typedef ModelLoader::Vertex Vertex; - RefPtr<BufferResource> vertexBuffer; - RefPtr<BufferResource> indexBuffer; + ComPtr<IBufferResource> vertexBuffer; + ComPtr<IBufferResource> indexBuffer; PrimitiveTopology primitiveTopology; int vertexCount; int indexCount; @@ -1911,7 +1912,7 @@ struct ModelViewer { Window* gWindow; Slang::ComPtr<gfx::IRenderer> gRenderer; -RefPtr<gfx::ResourceView> gDepthTarget; +ComPtr<gfx::IResourceView> gDepthTarget; // We keep a pointer to the one effect we are using (for a forward // rendering pass), plus the parameter-block layouts for our `PerView` @@ -2069,16 +2070,16 @@ Result initialize() // Because we are rendering more than a single triangle this time, we // require a depth buffer to resolve visibility. // - TextureResource::Desc depthBufferDesc = gRenderer->getSwapChainTextureDesc(); + ITextureResource::Desc depthBufferDesc = gRenderer->getSwapChainTextureDesc(); depthBufferDesc.format = Format::D_Float32; - depthBufferDesc.setDefaults(Resource::Usage::DepthWrite); + depthBufferDesc.setDefaults(IResource::Usage::DepthWrite); auto depthTexture = gRenderer->createTextureResource( - Resource::Usage::DepthWrite, + IResource::Usage::DepthWrite, depthBufferDesc); if(!depthTexture) return SLANG_FAIL; - ResourceView::Desc textureViewDesc; - textureViewDesc.type = ResourceView::Type::DepthStencil; + IResourceView::Desc textureViewDesc; + textureViewDesc.type = IResourceView::Type::DepthStencil; auto depthTarget = gRenderer->createTextureView(depthTexture, textureViewDesc); if (!depthTarget) return SLANG_FAIL; diff --git a/examples/shader-toy/main.cpp b/examples/shader-toy/main.cpp index 89a40b794..e2efc325c 100644 --- a/examples/shader-toy/main.cpp +++ b/examples/shader-toy/main.cpp @@ -22,6 +22,8 @@ using Slang::ComPtr; #include "gfx/render.h" #include "gfx/d3d11/render-d3d11.h" #include "tools/graphics-app-framework/window.h" +#include "source/core/slang-basic.h" + using namespace gfx; // In order to display a shader toy effect using rasterization-based shader @@ -88,7 +90,7 @@ void diagnoseIfNeeded(slang::IBlob* diagnosticsBlob) // The main interesting part of the host application code is where we // load, compile, inspect, and compose the Slang shader code. // -Result loadShaderProgram(gfx::IRenderer* renderer, RefPtr<gfx::ShaderProgram>& outShaderProgram) +Result loadShaderProgram(gfx::IRenderer* renderer, ComPtr<gfx::IShaderProgram>& outShaderProgram) { // The first step in interacting with the Slang API is to create a "global session," // which represents an instance of the Slang API loaded from the library. @@ -192,7 +194,7 @@ Result loadShaderProgram(gfx::IRenderer* renderer, RefPtr<gfx::ShaderProgram>& o // other pieces, and that is what we are going to do with our module // and entry points. // - List<slang::IComponentType*> componentTypes; + Slang::List<slang::IComponentType*> componentTypes; componentTypes.add(module); // Later on when we go to extract compiled kernel code for our vertex @@ -266,7 +268,7 @@ Result loadShaderProgram(gfx::IRenderer* renderer, RefPtr<gfx::ShaderProgram>& o // Because a shader program could have zero or more specialization parameters, // we need to build up an array of specialization arguments. // - List<slang::SpecializationArg> specializationArgs; + Slang::List<slang::SpecializationArg> specializationArgs; { // In our case, we only have a single specialization argument we plan @@ -344,13 +346,13 @@ Result loadShaderProgram(gfx::IRenderer* renderer, RefPtr<gfx::ShaderProgram>& o char const* fragmentCode = (char const*) fragmentShaderBlob->getBufferPointer(); char const* fragmentCodeEnd = fragmentCode + fragmentShaderBlob->getBufferSize(); - gfx::ShaderProgram::KernelDesc kernelDescs[] = + gfx::IShaderProgram::KernelDesc kernelDescs[] = { { gfx::StageType::Vertex, vertexCode, vertexCodeEnd }, { gfx::StageType::Fragment, fragmentCode, fragmentCodeEnd }, }; - gfx::ShaderProgram::Desc programDesc; + gfx::IShaderProgram::Desc programDesc; programDesc.pipelineType = gfx::PipelineType::Graphics; programDesc.kernels = &kernelDescs[0]; programDesc.kernelCount = 2; @@ -367,13 +369,11 @@ int gWindowHeight = 768; gfx::ApplicationContext* gAppContext; gfx::Window* gWindow; Slang::ComPtr<gfx::IRenderer> gRenderer; -RefPtr<gfx::BufferResource> gConstantBuffer; - -RefPtr<gfx::PipelineLayout> gPipelineLayout; -RefPtr<gfx::PipelineState> gPipelineState; -RefPtr<gfx::DescriptorSet> gDescriptorSet; - -RefPtr<gfx::BufferResource> gVertexBuffer; +ComPtr<gfx::IBufferResource> gConstantBuffer; +ComPtr<gfx::IPipelineLayout> gPipelineLayout; +ComPtr<gfx::IPipelineState> gPipelineState; +ComPtr<gfx::IDescriptorSet> gDescriptorSet; +ComPtr<gfx::IBufferResource> gVertexBuffer; Result initialize() { @@ -396,13 +396,13 @@ Result initialize() int constantBufferSize = sizeof(Uniforms); - BufferResource::Desc constantBufferDesc; + IBufferResource::Desc constantBufferDesc; constantBufferDesc.init(constantBufferSize); - constantBufferDesc.setDefaults(Resource::Usage::ConstantBuffer); - constantBufferDesc.cpuAccessFlags = Resource::AccessFlag::Write; + constantBufferDesc.setDefaults(IResource::Usage::ConstantBuffer); + constantBufferDesc.cpuAccessFlags = IResource::AccessFlag::Write; gConstantBuffer = gRenderer->createBufferResource( - Resource::Usage::ConstantBuffer, + IResource::Usage::ConstantBuffer, constantBufferDesc); if(!gConstantBuffer) return SLANG_FAIL; @@ -414,33 +414,33 @@ Result initialize() SLANG_COUNT_OF(inputElements)); if(!inputLayout) return SLANG_FAIL; - BufferResource::Desc vertexBufferDesc; + IBufferResource::Desc vertexBufferDesc; vertexBufferDesc.init(FullScreenTriangle::kVertexCount * sizeof(FullScreenTriangle::Vertex)); - vertexBufferDesc.setDefaults(Resource::Usage::VertexBuffer); + vertexBufferDesc.setDefaults(IResource::Usage::VertexBuffer); gVertexBuffer = gRenderer->createBufferResource( - Resource::Usage::VertexBuffer, + IResource::Usage::VertexBuffer, vertexBufferDesc, &FullScreenTriangle::kVertices[0]); if(!gVertexBuffer) return SLANG_FAIL; - RefPtr<ShaderProgram> shaderProgram; + ComPtr<IShaderProgram> shaderProgram; SLANG_RETURN_ON_FAIL(loadShaderProgram(gRenderer, shaderProgram)); - DescriptorSetLayout::SlotRangeDesc slotRanges[] = + IDescriptorSetLayout::SlotRangeDesc slotRanges[] = { - DescriptorSetLayout::SlotRangeDesc(DescriptorSlotType::UniformBuffer), + IDescriptorSetLayout::SlotRangeDesc(DescriptorSlotType::UniformBuffer), }; - DescriptorSetLayout::Desc descriptorSetLayoutDesc; + IDescriptorSetLayout::Desc descriptorSetLayoutDesc; descriptorSetLayoutDesc.slotRangeCount = 1; descriptorSetLayoutDesc.slotRanges = &slotRanges[0]; auto descriptorSetLayout = gRenderer->createDescriptorSetLayout(descriptorSetLayoutDesc); if(!descriptorSetLayout) return SLANG_FAIL; - PipelineLayout::DescriptorSetDesc descriptorSets[] = + IPipelineLayout::DescriptorSetDesc descriptorSets[] = { - PipelineLayout::DescriptorSetDesc( descriptorSetLayout ), + IPipelineLayout::DescriptorSetDesc( descriptorSetLayout ), }; - PipelineLayout::Desc pipelineLayoutDesc; + IPipelineLayout::Desc pipelineLayoutDesc; pipelineLayoutDesc.renderTargetCount = 1; pipelineLayoutDesc.descriptorSetCount = 1; pipelineLayoutDesc.descriptorSets = &descriptorSets[0]; @@ -526,9 +526,7 @@ void renderFrame() gRenderer->presentFrame(); } -void finalize() -{ -} +void finalize() { destroyWindow(gWindow); } void handleEvent(Event const& event) { diff --git a/slang-com-ptr.h b/slang-com-ptr.h index 7860256cc..ced36d178 100644 --- a/slang-com-ptr.h +++ b/slang-com-ptr.h @@ -1,9 +1,10 @@ -#ifndef SLANG_COM_PTR_H +#ifndef SLANG_COM_PTR_H #define SLANG_COM_PTR_H #include "slang-com-helper.h" #include <assert.h> +#include <cstddef> namespace Slang { @@ -54,6 +55,7 @@ public: /// Constructors /// Default Ctor. Sets to nullptr SLANG_FORCE_INLINE ComPtr() :m_ptr(nullptr) {} + SLANG_FORCE_INLINE ComPtr(std::nullptr_t) : m_ptr(nullptr) {} /// Sets, and ref counts. SLANG_FORCE_INLINE explicit ComPtr(T* ptr) :m_ptr(ptr) { if (ptr) ((Ptr)ptr)->addRef(); } /// The copy ctor diff --git a/source/core/slang-math.h b/source/core/slang-math.h index 2378b73a0..3d229ded8 100644 --- a/source/core/slang-math.h +++ b/source/core/slang-math.h @@ -1,7 +1,7 @@ #ifndef SLANG_CORE_MATH_H #define SLANG_CORE_MATH_H -#include <math.h> +#include <cmath> namespace Slang { @@ -82,16 +82,12 @@ namespace Slang static inline int IsNaN(float x) { -#ifdef _M_X64 - return _isnanf(x); -#else - return isnan(x); -#endif + return std::isnan(x); } static inline int IsInf(float x) { - return isinf(x); + return std::isinf(x); } static inline unsigned int Ones32(unsigned int x) diff --git a/tools/gfx/cuda/render-cuda.cpp b/tools/gfx/cuda/render-cuda.cpp index 03bf41d38..69166c6b6 100644 --- a/tools/gfx/cuda/render-cuda.cpp +++ b/tools/gfx/cuda/render-cuda.cpp @@ -1,11 +1,17 @@ #include "render-cuda.h" #include "slang.h" +#include "slang-com-ptr.h" +#include "slang-com-helper.h" +#include "core/slang-basic.h" + +#include "../renderer-shared.h" +#include "../render-graphics-common.h" #ifdef GFX_ENABLE_CUDA -#include "../render.h" #include <cuda.h> #include <cuda_runtime_api.h> #include "core/slang-std-writers.h" + #endif namespace gfx @@ -13,9 +19,6 @@ namespace gfx #ifdef GFX_ENABLE_CUDA using namespace Slang; -static const Guid IID_ISlangUnknown = SLANG_UUID_ISlangUnknown; -static const Guid IID_IRenderer = SLANG_UUID_IRenderer; - SLANG_FORCE_INLINE static bool _isError(CUresult result) { return result != 0; } SLANG_FORCE_INLINE static bool _isError(cudaError_t result) { return result != 0; } @@ -222,17 +225,33 @@ public: CUmipmappedArray m_cudaMipMappedArray = CUmipmappedArray(); }; -class CUDAResourceView : public ResourceView +class CUDAResourceView : public IResourceView, public RefObject { public: + SLANG_REF_OBJECT_IUNKNOWN_ALL + IResourceView* getInterface(const Guid& guid) + { + if (guid == GfxGUID::IID_ISlangUnknown || guid == GfxGUID::IID_IResourceView) + return static_cast<IResourceView*>(this); + return nullptr; + } +public: Desc desc; RefPtr<MemoryCUDAResource> memoryResource = nullptr; RefPtr<TextureCUDAResource> textureResource = nullptr; }; -class CUDAShaderProgram : public ShaderProgram +class CUDAShaderProgram : public IShaderProgram, public RefObject { public: + SLANG_REF_OBJECT_IUNKNOWN_ALL + IShaderProgram* getInterface(const Guid& guid) + { + if (guid == GfxGUID::IID_ISlangUnknown || guid == GfxGUID::IID_IShaderProgram) + return static_cast<IShaderProgram*>(this); + return nullptr; + } +public: CUmodule cudaModule = nullptr; CUfunction cudaKernel; String kernelName; @@ -243,15 +262,31 @@ public: } }; -class CUDAPipelineState : public PipelineState +class CUDAPipelineState : public IPipelineState, public RefObject { public: + SLANG_REF_OBJECT_IUNKNOWN_ALL + IPipelineState* getInterface(const Guid& guid) + { + if (guid == GfxGUID::IID_ISlangUnknown || guid == GfxGUID::IID_IPipelineState) + return static_cast<IPipelineState*>(this); + return nullptr; + } +public: RefPtr<CUDAShaderProgram> shaderProgram; }; -class CUDAShaderObjectLayout : public ShaderObjectLayout +class CUDAShaderObjectLayout : public IShaderObjectLayout, public RefObject { public: + SLANG_REF_OBJECT_IUNKNOWN_ALL + IShaderObjectLayout* getInterface(const Guid& guid) + { + if (guid == GfxGUID::IID_ISlangUnknown || guid == GfxGUID::IID_IShaderObjectLayout) + return static_cast<IShaderObjectLayout*>(this); + return nullptr; + } +public: slang::TypeLayoutReflection* typeLayout = nullptr; struct BindingRangeInfo @@ -409,48 +444,64 @@ public: } }; -class CUDAShaderObject : public ShaderObject +class CUDAShaderObject : public IShaderObject, public RefObject { public: + SLANG_REF_OBJECT_IUNKNOWN_ALL + IShaderObject* getInterface(const Guid& guid) + { + if (guid == GfxGUID::IID_ISlangUnknown || guid == GfxGUID::IID_IShaderObject) + return static_cast<IShaderObject*>(this); + return nullptr; + } + +public: RefPtr<MemoryCUDAResource> bufferResource; RefPtr<CUDAShaderObjectLayout> layout; List<RefPtr<CUDAShaderObject>> objects; List<RefPtr<CUDAResourceView>> resources; - virtual SlangResult init(IRenderer* renderer, CUDAShaderObjectLayout* typeLayout); + virtual SLANG_NO_THROW Result SLANG_MCALL + init(IRenderer* renderer, CUDAShaderObjectLayout* typeLayout); - virtual SlangResult initBuffer(IRenderer* renderer, size_t bufferSize) + virtual SLANG_NO_THROW Result SLANG_MCALL initBuffer(IRenderer* renderer, size_t bufferSize) { BufferResource::Desc bufferDesc; bufferDesc.init(bufferSize); - bufferDesc.cpuAccessFlags |= Resource::AccessFlag::Write; - RefPtr<BufferResource> constantBuffer; + bufferDesc.cpuAccessFlags |= IResource::AccessFlag::Write; + ComPtr<IBufferResource> constantBuffer; SLANG_RETURN_ON_FAIL(renderer->createBufferResource( - Resource::Usage::ConstantBuffer, bufferDesc, nullptr, constantBuffer.writeRef())); - bufferResource = dynamic_cast<MemoryCUDAResource*>(constantBuffer.Ptr()); + IResource::Usage::ConstantBuffer, bufferDesc, nullptr, constantBuffer.writeRef())); + bufferResource = dynamic_cast<MemoryCUDAResource*>(constantBuffer.get()); return SLANG_OK; } - virtual void* getBuffer() + virtual SLANG_NO_THROW void* SLANG_MCALL getBuffer() { return bufferResource ? bufferResource->m_cudaMemory : nullptr; } - virtual size_t getBufferSize() + virtual SLANG_NO_THROW size_t SLANG_MCALL getBufferSize() { - return bufferResource ? bufferResource->getDesc().sizeInBytes : 0; + return bufferResource ? bufferResource->getDesc()->sizeInBytes : 0; } - virtual slang::TypeLayoutReflection* getElementTypeLayout() override + virtual SLANG_NO_THROW slang::TypeLayoutReflection* SLANG_MCALL getElementTypeLayout() override { return layout->typeLayout; } - virtual Slang::Index getEntryPointCount() override { return 0; } - virtual ShaderObject* getEntryPoint(Slang::Index index) override { return nullptr; } - virtual SlangResult setData(ShaderOffset const& offset, void const* data, size_t size) + virtual SLANG_NO_THROW UInt SLANG_MCALL getEntryPointCount() override { return 0; } + virtual SLANG_NO_THROW Result SLANG_MCALL + getEntryPoint(UInt index, IShaderObject** outEntryPoint) override { - size = Math::Min(size, bufferResource->getDesc().sizeInBytes - offset.uniformOffset); + *outEntryPoint = nullptr; + return SLANG_OK; + } + virtual SLANG_NO_THROW Result SLANG_MCALL + setData(ShaderOffset const& offset, void const* data, size_t size) + { + size = Math::Min(size, bufferResource->getDesc()->sizeInBytes - offset.uniformOffset); SLANG_CUDA_RETURN_ON_FAIL(cudaMemcpy( (uint8_t*)bufferResource->m_cudaMemory + offset.uniformOffset, data, @@ -458,7 +509,8 @@ public: cudaMemcpyHostToDevice)); return SLANG_OK; } - virtual SlangResult getObject(ShaderOffset const& offset, ShaderObject** object) + virtual SLANG_NO_THROW Result SLANG_MCALL + getObject(ShaderOffset const& offset, IShaderObject** object) { auto subObjectIndex = layout->m_bindingRanges[offset.bindingRangeIndex].baseIndex + offset.bindingArrayIndex; @@ -467,10 +519,12 @@ public: *object = nullptr; return SLANG_OK; } + objects[subObjectIndex]->addRef(); *object = objects[subObjectIndex].Ptr(); return SLANG_OK; } - virtual SlangResult setObject(ShaderOffset const& offset, ShaderObject* object) + virtual SLANG_NO_THROW Result SLANG_MCALL + setObject(ShaderOffset const& offset, IShaderObject* object) { auto subObjectIndex = layout->m_bindingRanges[offset.bindingRangeIndex].baseIndex + offset.bindingArrayIndex; @@ -484,7 +538,8 @@ public: objects[subObjectIndex] = cudaObject; return setData(offset, &cudaObject->bufferResource->m_cudaMemory, sizeof(void*)); } - virtual SlangResult setResource(ShaderOffset const& offset, ResourceView* resourceView) + virtual SLANG_NO_THROW Result SLANG_MCALL + setResource(ShaderOffset const& offset, IResourceView* resourceView) { auto cudaView = dynamic_cast<CUDAResourceView*>(resourceView); if (offset.bindingRangeIndex >= resources.getCount()) @@ -492,7 +547,7 @@ public: resources[offset.bindingRangeIndex] = cudaView; if (cudaView->textureResource) { - if (cudaView->desc.type == ResourceView::Type::UnorderedAccess) + if (cudaView->desc.type == IResourceView::Type::UnorderedAccess) { auto handle = cudaView->textureResource->getBindlessHandle(); setData(offset, &handle, sizeof(uint64_t)); @@ -509,7 +564,7 @@ public: setData(offset, &handle, sizeof(handle)); auto sizeOffset = offset; sizeOffset.uniformOffset += sizeof(handle); - auto& desc = cudaView->memoryResource->getDesc(); + auto& desc = *cudaView->memoryResource->getDesc(); size_t size = desc.sizeInBytes; if (desc.elementSize > 1) size /= desc.elementSize; @@ -518,14 +573,15 @@ public: } return SLANG_OK; } - virtual SlangResult setSampler(ShaderOffset const& offset, SamplerState* sampler) + virtual SLANG_NO_THROW Result SLANG_MCALL + setSampler(ShaderOffset const& offset, ISamplerState* sampler) { SLANG_UNUSED(sampler); SLANG_UNUSED(offset); return SLANG_OK; } - virtual SlangResult setCombinedTextureSampler( - ShaderOffset const& offset, ResourceView* textureView, SamplerState* sampler) + virtual SLANG_NO_THROW Result SLANG_MCALL setCombinedTextureSampler( + ShaderOffset const& offset, IResourceView* textureView, ISamplerState* sampler) { SLANG_UNUSED(sampler); setResource(offset, textureView); @@ -539,14 +595,15 @@ public: void* hostBuffer = nullptr; size_t uniformBufferSize = 0; // Override buffer allocation so we store all uniform data on host memory instead of device memory. - virtual SlangResult initBuffer(IRenderer* renderer, size_t bufferSize) override + virtual SLANG_NO_THROW Result SLANG_MCALL initBuffer(IRenderer* renderer, size_t bufferSize) override { uniformBufferSize = bufferSize; hostBuffer = malloc(bufferSize); return SLANG_OK; } - virtual SlangResult setData(ShaderOffset const& offset, void const* data, size_t size) override + virtual SLANG_NO_THROW Result SLANG_MCALL + setData(ShaderOffset const& offset, void const* data, size_t size) override { size = Math::Min(size, uniformBufferSize - offset.uniformOffset); memcpy( @@ -556,12 +613,12 @@ public: return SLANG_OK; } - virtual void* getBuffer() override + virtual SLANG_NO_THROW void* SLANG_MCALL getBuffer() override { return hostBuffer; } - virtual size_t getBufferSize() override + virtual SLANG_NO_THROW size_t SLANG_MCALL getBufferSize() override { return uniformBufferSize; } @@ -576,9 +633,16 @@ class CUDARootShaderObject : public CUDAShaderObject { public: List<RefPtr<CUDAEntryPointShaderObject>> entryPointObjects; - virtual SlangResult init(IRenderer* renderer, CUDAShaderObjectLayout* typeLayout) override; - virtual Slang::Index getEntryPointCount() override { return entryPointObjects.getCount(); } - virtual ShaderObject* getEntryPoint(Slang::Index index) override { return entryPointObjects[index].Ptr(); } + virtual SLANG_NO_THROW Result SLANG_MCALL + init(IRenderer* renderer, CUDAShaderObjectLayout* typeLayout) override; + virtual SLANG_NO_THROW UInt SLANG_MCALL getEntryPointCount() override { return entryPointObjects.getCount(); } + virtual SLANG_NO_THROW Result SLANG_MCALL + getEntryPoint(UInt index, IShaderObject** outEntryPoint) override + { + *outEntryPoint = entryPointObjects[index].Ptr(); + entryPointObjects[index]->addRef(); + return SLANG_OK; + } }; @@ -588,8 +652,9 @@ public: SLANG_REF_OBJECT_IUNKNOWN_ALL IRenderer* getInterface(const Guid& guid) { - return (guid == IID_ISlangUnknown || guid == IID_IRenderer) ? static_cast<IRenderer*>(this) - : nullptr; + return (guid == GfxGUID::IID_ISlangUnknown || guid == GfxGUID::IID_IRenderer) + ? static_cast<IRenderer*>(this) + : nullptr; } private: @@ -740,10 +805,10 @@ private: } virtual SLANG_NO_THROW Result SLANG_MCALL createTextureResource( - Resource::Usage initialUsage, - const TextureResource::Desc& desc, - const TextureResource::Data* initData, - TextureResource** outResource) override + IResource::Usage initialUsage, + const ITextureResource::Desc& desc, + const ITextureResource::Data* initData, + ITextureResource** outResource) override { RefPtr<TextureCUDAResource> tex = new TextureCUDAResource(desc); CUresourcetype resourceType; @@ -792,9 +857,9 @@ private: if (desc.arraySize > 1) { - if (desc.type == Resource::Type::Texture1D || - desc.type == Resource::Type::Texture2D || - desc.type == Resource::Type::TextureCube) + if (desc.type == IResource::Type::Texture1D || + desc.type == IResource::Type::Texture2D || + desc.type == IResource::Type::TextureCube) { arrayDesc.Flags |= CUDA_ARRAY3D_LAYERED; arrayDesc.Depth = desc.arraySize; @@ -806,7 +871,7 @@ private: } } - if (desc.type == Resource::Type::TextureCube) + if (desc.type == IResource::Type::TextureCube) { arrayDesc.Flags |= CUDA_ARRAY3D_CUBEMAP; arrayDesc.Depth *= 6; @@ -821,9 +886,9 @@ private: if (desc.arraySize > 1) { - if (desc.type == Resource::Type::Texture1D || - desc.type == Resource::Type::Texture2D || - desc.type == Resource::Type::TextureCube) + if (desc.type == IResource::Type::Texture1D || + desc.type == IResource::Type::Texture2D || + desc.type == IResource::Type::TextureCube) { SLANG_ASSERT(!"Only 1D, 2D and Cube arrays supported"); return SLANG_FAIL; @@ -834,7 +899,7 @@ private: // Set the depth as the array length arrayDesc.Depth = desc.arraySize; - if (desc.type == Resource::Type::TextureCube) + if (desc.type == IResource::Type::TextureCube) { arrayDesc.Depth *= 6; } @@ -844,15 +909,15 @@ private: arrayDesc.Format = format; arrayDesc.NumChannels = numChannels; - if (desc.type == Resource::Type::TextureCube) + if (desc.type == IResource::Type::TextureCube) { arrayDesc.Flags |= CUDA_ARRAY3D_CUBEMAP; } SLANG_CUDA_RETURN_ON_FAIL(cuArray3DCreate(&tex->m_cudaArray, &arrayDesc)); } - else if (desc.type == Resource::Type::Texture3D || - desc.type == Resource::Type::TextureCube) + else if (desc.type == IResource::Type::Texture3D || + desc.type == IResource::Type::TextureCube) { CUDA_ARRAY3D_DESCRIPTOR arrayDesc; memset(&arrayDesc, 0, sizeof(arrayDesc)); @@ -866,7 +931,7 @@ private: arrayDesc.Flags = 0; // Handle cube texture - if (desc.type == Resource::Type::TextureCube) + if (desc.type == IResource::Type::TextureCube) { arrayDesc.Depth = 6; arrayDesc.Flags |= CUDA_ARRAY3D_CUBEMAP; @@ -906,7 +971,7 @@ private: mipDepth = (mipDepth == 0) ? 1 : mipDepth; // If it's a cubemap then the depth is always 6 - if (desc.type == Resource::Type::TextureCube) + if (desc.type == IResource::Type::TextureCube) { mipDepth = 6; } @@ -935,16 +1000,16 @@ private: if (desc.arraySize > 1) { SLANG_ASSERT( - desc.type == Resource::Type::Texture1D || - desc.type == Resource::Type::Texture2D || - desc.type == Resource::Type::TextureCube); + desc.type == IResource::Type::Texture1D || + desc.type == IResource::Type::Texture2D || + desc.type == IResource::Type::TextureCube); // TODO(JS): Here I assume that arrays are just held contiguously within a 'face' // This seems reasonable and works with the Copy3D. const size_t faceSizeInBytes = elementSize * mipWidth * mipHeight; Index faceCount = desc.arraySize; - if (desc.type == Resource::Type::TextureCube) + if (desc.type == IResource::Type::TextureCube) { faceCount *= 6; } @@ -970,7 +1035,7 @@ private: } else { - if (desc.type == Resource::Type::TextureCube) + if (desc.type == IResource::Type::TextureCube) { size_t faceSizeInBytes = elementSize * mipWidth * mipHeight; @@ -998,9 +1063,9 @@ private: if (desc.arraySize > 1) { SLANG_ASSERT( - desc.type == Resource::Type::Texture1D || - desc.type == Resource::Type::Texture2D || - desc.type == Resource::Type::TextureCube); + desc.type == IResource::Type::Texture1D || + desc.type == IResource::Type::Texture2D || + desc.type == IResource::Type::TextureCube); CUDA_MEMCPY3D copyParam; memset(©Param, 0, sizeof(copyParam)); @@ -1016,7 +1081,7 @@ private: // Set the depth to the array length copyParam.Depth = desc.arraySize; - if (desc.type == Resource::Type::TextureCube) + if (desc.type == IResource::Type::TextureCube) { copyParam.Depth *= 6; } @@ -1027,8 +1092,8 @@ private: { switch (desc.type) { - case Resource::Type::Texture1D: - case Resource::Type::Texture2D: + case IResource::Type::Texture1D: + case IResource::Type::Texture2D: { CUDA_MEMCPY2D copyParam; memset(©Param, 0, sizeof(copyParam)); @@ -1042,8 +1107,8 @@ private: SLANG_CUDA_RETURN_ON_FAIL(cuMemcpy2D(©Param)); break; } - case Resource::Type::Texture3D: - case Resource::Type::TextureCube: + case IResource::Type::Texture3D: + case IResource::Type::TextureCube: { CUDA_MEMCPY3D copyParam; memset(©Param, 0, sizeof(copyParam)); @@ -1108,10 +1173,10 @@ private: } virtual SLANG_NO_THROW Result SLANG_MCALL createBufferResource( - Resource::Usage initialUsage, - const BufferResource::Desc& desc, + IResource::Usage initialUsage, + const IBufferResource::Desc& desc, const void* initData, - BufferResource** outResource) override + IBufferResource** outResource) override { RefPtr<MemoryCUDAResource> resource = new MemoryCUDAResource(desc); SLANG_CUDA_RETURN_ON_FAIL(cudaMallocManaged(&resource->m_cudaMemory, desc.sizeInBytes)); @@ -1124,7 +1189,7 @@ private: } virtual SLANG_NO_THROW Result SLANG_MCALL createTextureView( - TextureResource* texture, ResourceView::Desc const& desc, ResourceView** outView) override + ITextureResource* texture, IResourceView::Desc const& desc, IResourceView** outView) override { RefPtr<CUDAResourceView> view = new CUDAResourceView(); view->desc = desc; @@ -1134,7 +1199,7 @@ private: } virtual SLANG_NO_THROW Result SLANG_MCALL createBufferView( - BufferResource* buffer, ResourceView::Desc const& desc, ResourceView** outView) override + IBufferResource* buffer, IResourceView::Desc const& desc, IResourceView** outView) override { RefPtr<CUDAResourceView> view = new CUDAResourceView(); view->desc = desc; @@ -1144,7 +1209,7 @@ private: } virtual SLANG_NO_THROW Result SLANG_MCALL createShaderObjectLayout( - slang::TypeLayoutReflection* typeLayout, ShaderObjectLayout** outLayout) override + slang::TypeLayoutReflection* typeLayout, IShaderObjectLayout** outLayout) override { RefPtr<CUDAShaderObjectLayout> cudaLayout; cudaLayout = new CUDAShaderObjectLayout(typeLayout); @@ -1153,7 +1218,7 @@ private: } virtual SLANG_NO_THROW Result SLANG_MCALL createRootShaderObjectLayout( - slang::ProgramLayout* layout, ShaderObjectLayout** outLayout) override + slang::ProgramLayout* layout, IShaderObjectLayout** outLayout) override { RefPtr<CUDAProgramLayout> cudaLayout; cudaLayout = new CUDAProgramLayout(layout); @@ -1163,7 +1228,7 @@ private: } virtual SLANG_NO_THROW Result SLANG_MCALL - createShaderObject(ShaderObjectLayout* layout, ShaderObject** outObject) override + createShaderObject(IShaderObjectLayout* layout, IShaderObject** outObject) override { RefPtr<CUDAShaderObject> result = new CUDAShaderObject(); SLANG_RETURN_ON_FAIL(result->init(this, dynamic_cast<CUDAShaderObjectLayout*>(layout))); @@ -1172,7 +1237,7 @@ private: } virtual SLANG_NO_THROW Result SLANG_MCALL - createRootShaderObject(ShaderObjectLayout* layout, ShaderObject** outObject) override + createRootShaderObject(IShaderObjectLayout* layout, IShaderObject** outObject) override { RefPtr<CUDARootShaderObject> result = new CUDARootShaderObject(); SLANG_RETURN_ON_FAIL(result->init(this, dynamic_cast<CUDAShaderObjectLayout*>(layout))); @@ -1181,7 +1246,7 @@ private: } virtual SLANG_NO_THROW Result SLANG_MCALL - bindRootShaderObject(PipelineType pipelineType, ShaderObject* object) override + bindRootShaderObject(PipelineType pipelineType, IShaderObject* object) override { currentRootObject = dynamic_cast<CUDARootShaderObject*>(object); if (currentRootObject) @@ -1190,7 +1255,7 @@ private: } virtual SLANG_NO_THROW Result SLANG_MCALL - createProgram(const ShaderProgram::Desc& desc, ShaderProgram** outProgram) override + createProgram(const IShaderProgram::Desc& desc, IShaderProgram** outProgram) override { if (desc.kernelCount != 1) return SLANG_E_INVALID_ARG; @@ -1204,7 +1269,7 @@ private: } virtual SLANG_NO_THROW Result SLANG_MCALL createComputePipelineState( - const ComputePipelineStateDesc& desc, PipelineState** outState) override + const ComputePipelineStateDesc& desc, IPipelineState** outState) override { RefPtr<CUDAPipelineState> state = new CUDAPipelineState(); state->shaderProgram = dynamic_cast<CUDAShaderProgram*>(desc.program); @@ -1212,18 +1277,18 @@ private: return Result(); } - virtual SLANG_NO_THROW void* SLANG_MCALL map(BufferResource* buffer, MapFlavor flavor) override + virtual SLANG_NO_THROW void* SLANG_MCALL map(IBufferResource* buffer, MapFlavor flavor) override { return dynamic_cast<MemoryCUDAResource*>(buffer)->m_cudaMemory; } - virtual SLANG_NO_THROW void SLANG_MCALL unmap(BufferResource* buffer) override + virtual SLANG_NO_THROW void SLANG_MCALL unmap(IBufferResource* buffer) override { SLANG_UNUSED(buffer); } virtual SLANG_NO_THROW void SLANG_MCALL - setPipelineState(PipelineType pipelineType, PipelineState* state) override + setPipelineState(PipelineType pipelineType, IPipelineState* state) override { SLANG_ASSERT(pipelineType == PipelineType::Compute); currentPipeline = dynamic_cast<CUDAPipelineState*>(state); @@ -1315,11 +1380,19 @@ private: public: // Unused public interfaces. These functions are not supported on CUDA. - virtual SLANG_NO_THROW const Slang::List<Slang::String>& SLANG_MCALL getFeatures() override + SLANG_NO_THROW Result SLANG_MCALL getFeatures( + const char** outFeatures, UInt bufferSize, UInt* outFeatureCount) { - static Slang::List<Slang::String> featureSet; - return featureSet; + if (outFeatureCount) + *outFeatureCount = 0; + return SLANG_OK; } + + SLANG_NO_THROW bool SLANG_MCALL hasFeature(const char* featureName) + { + return false; + } + virtual SLANG_NO_THROW void SLANG_MCALL setClearColor(const float color[4]) override { SLANG_UNUSED(color); @@ -1332,7 +1405,7 @@ public: } virtual SLANG_NO_THROW Result SLANG_MCALL - createSamplerState(SamplerState::Desc const& desc, SamplerState** outSampler) override + createSamplerState(ISamplerState::Desc const& desc, ISamplerState** outSampler) override { SLANG_UNUSED(desc); *outSampler = nullptr; @@ -1342,7 +1415,7 @@ public: virtual SLANG_NO_THROW Result SLANG_MCALL createInputLayout( const InputElementDesc* inputElements, UInt inputElementCount, - InputLayout** outLayout) override + IInputLayout** outLayout) override { SLANG_UNUSED(inputElements); SLANG_UNUSED(inputElementCount); @@ -1350,28 +1423,28 @@ public: return SLANG_E_NOT_AVAILABLE; } virtual SLANG_NO_THROW Result SLANG_MCALL createDescriptorSetLayout( - const DescriptorSetLayout::Desc& desc, DescriptorSetLayout** outLayout) override + const IDescriptorSetLayout::Desc& desc, IDescriptorSetLayout** outLayout) override { SLANG_UNUSED(desc); SLANG_UNUSED(outLayout); return SLANG_E_NOT_AVAILABLE; } virtual SLANG_NO_THROW Result SLANG_MCALL - createPipelineLayout(const PipelineLayout::Desc& desc, PipelineLayout** outLayout) override + createPipelineLayout(const IPipelineLayout::Desc& desc, IPipelineLayout** outLayout) override { SLANG_UNUSED(desc); SLANG_UNUSED(outLayout); return SLANG_E_NOT_AVAILABLE; } virtual SLANG_NO_THROW Result SLANG_MCALL - createDescriptorSet(DescriptorSetLayout* layout, DescriptorSet** outDescriptorSet) override + createDescriptorSet(IDescriptorSetLayout* layout, IDescriptorSet** outDescriptorSet) override { SLANG_UNUSED(layout); SLANG_UNUSED(outDescriptorSet); return SLANG_E_NOT_AVAILABLE; } virtual SLANG_NO_THROW Result SLANG_MCALL createGraphicsPipelineState( - const GraphicsPipelineStateDesc& desc, PipelineState** outState) override + const GraphicsPipelineStateDesc& desc, IPipelineState** outState) override { SLANG_UNUSED(desc); SLANG_UNUSED(outState); @@ -1390,9 +1463,9 @@ public: } virtual SLANG_NO_THROW void SLANG_MCALL setDescriptorSet( PipelineType pipelineType, - PipelineLayout* layout, + IPipelineLayout* layout, UInt index, - DescriptorSet* descriptorSet) override + IDescriptorSet* descriptorSet) override { SLANG_UNUSED(pipelineType); SLANG_UNUSED(layout); @@ -1402,7 +1475,7 @@ public: virtual SLANG_NO_THROW void SLANG_MCALL setVertexBuffers( UInt startSlot, UInt slotCount, - BufferResource* const* buffers, + IBufferResource* const* buffers, const UInt* strides, const UInt* offsets) override { @@ -1413,14 +1486,14 @@ public: SLANG_UNUSED(offsets); } virtual SLANG_NO_THROW void SLANG_MCALL - setIndexBuffer(BufferResource* buffer, Format indexFormat, UInt offset = 0) override + setIndexBuffer(IBufferResource* buffer, Format indexFormat, UInt offset = 0) override { SLANG_UNUSED(buffer); SLANG_UNUSED(indexFormat); SLANG_UNUSED(offset); } virtual SLANG_NO_THROW void SLANG_MCALL - setDepthStencilTarget(ResourceView* depthStencilView) override + setDepthStencilTarget(IResourceView* depthStencilView) override { SLANG_UNUSED(depthStencilView); } @@ -1521,14 +1594,14 @@ SlangResult CUDARootShaderObject::init(IRenderer* renderer, CUDAShaderObjectLayo return SLANG_OK; } -SlangResult createCUDARenderer(IRenderer** outRenderer) +SlangResult SLANG_MCALL createCUDARenderer(IRenderer** outRenderer) { *outRenderer = new CUDARenderer(); (*outRenderer)->addRef(); return SLANG_OK; } #else -SlangResult createCUDARenderer(IRenderer** outRenderer) +SlangResult SLANG_MCALL createCUDARenderer(IRenderer** outRenderer) { *outRenderer = nullptr; return SLANG_OK; diff --git a/tools/gfx/cuda/render-cuda.h b/tools/gfx/cuda/render-cuda.h index 3b403287a..e209af02c 100644 --- a/tools/gfx/cuda/render-cuda.h +++ b/tools/gfx/cuda/render-cuda.h @@ -1,10 +1,11 @@ #pragma once #include <cstdint> +#include "slang.h" namespace gfx { class IRenderer; -int32_t createCUDARenderer(IRenderer** outRenderer); +SlangResult SLANG_MCALL createCUDARenderer(IRenderer** outRenderer); } diff --git a/tools/gfx/d3d/d3d-util.cpp b/tools/gfx/d3d/d3d-util.cpp index c746655c7..f60bd9d3f 100644 --- a/tools/gfx/d3d/d3d-util.cpp +++ b/tools/gfx/d3d/d3d-util.cpp @@ -8,6 +8,8 @@ // We will use the C standard library just for printing error messages. #include <stdio.h> +#include "core/slang-basic.h" + namespace gfx { using namespace Slang; @@ -397,7 +399,7 @@ static bool _isMatch(IDXGIAdapter* adapter, const Slang::UnownedStringSlice& low /* static */SlangResult D3DUtil::findAdapters(DeviceCheckFlags flags, const UnownedStringSlice& adapterName, IDXGIFactory* dxgiFactory, List<ComPtr<IDXGIAdapter>>& outDxgiAdapters) { - String lowerAdapterName = String(adapterName).toLower(); + Slang::String lowerAdapterName = Slang::String(adapterName).toLower(); outDxgiAdapters.clear(); diff --git a/tools/gfx/d3d/d3d-util.h b/tools/gfx/d3d/d3d-util.h index 37c277832..69d42418e 100644 --- a/tools/gfx/d3d/d3d-util.h +++ b/tools/gfx/d3d/d3d-util.h @@ -6,7 +6,7 @@ #include "slang-com-helper.h" #include "slang-com-ptr.h" -#include "core/slang-list.h" +#include "core/slang-basic.h" #include "../flag-combiner.h" diff --git a/tools/gfx/d3d11/render-d3d11.cpp b/tools/gfx/d3d11/render-d3d11.cpp index 97d294e5d..8bf11c39d 100644 --- a/tools/gfx/d3d11/render-d3d11.cpp +++ b/tools/gfx/d3d11/render-d3d11.cpp @@ -3,9 +3,10 @@ #define _CRT_SECURE_NO_WARNINGS #include "render-d3d11.h" +#include "core/slang-basic.h" //WORKING: #include "options.h" -#include "../render.h" +#include "../renderer-shared.h" #include "../render-graphics-common.h" #include "../d3d/d3d-util.h" #include "../nvapi/nvapi-util.h" @@ -60,86 +61,81 @@ public: kMaxUAVs = 64, kMaxRTVs = 8, }; - // Renderer implementation virtual SLANG_NO_THROW SlangResult SLANG_MCALL initialize(const Desc& desc, void* inWindowHandle) override; - virtual SLANG_NO_THROW const List<String>& SLANG_MCALL getFeatures() override - { - return m_features; - } virtual SLANG_NO_THROW void SLANG_MCALL setClearColor(const float color[4]) override; virtual SLANG_NO_THROW void SLANG_MCALL clearFrame() override; virtual SLANG_NO_THROW void SLANG_MCALL presentFrame() override; virtual SLANG_NO_THROW TextureResource::Desc SLANG_MCALL getSwapChainTextureDesc() override; virtual SLANG_NO_THROW Result SLANG_MCALL createTextureResource( - Resource::Usage initialUsage, - const TextureResource::Desc& desc, - const TextureResource::Data* initData, - TextureResource** outResource) override; + IResource::Usage initialUsage, + const ITextureResource::Desc& desc, + const ITextureResource::Data* initData, + ITextureResource** outResource) override; virtual SLANG_NO_THROW Result SLANG_MCALL createBufferResource( - Resource::Usage initialUsage, - const BufferResource::Desc& desc, + IResource::Usage initialUsage, + const IBufferResource::Desc& desc, const void* initData, - BufferResource** outResource) override; + IBufferResource** outResource) override; virtual SLANG_NO_THROW Result SLANG_MCALL - createSamplerState(SamplerState::Desc const& desc, SamplerState** outSampler) override; + createSamplerState(ISamplerState::Desc const& desc, ISamplerState** outSampler) override; virtual SLANG_NO_THROW Result SLANG_MCALL createTextureView( - TextureResource* texture, ResourceView::Desc const& desc, ResourceView** outView) override; + ITextureResource* texture, IResourceView::Desc const& desc, IResourceView** outView) override; virtual SLANG_NO_THROW Result SLANG_MCALL createBufferView( - BufferResource* buffer, ResourceView::Desc const& desc, ResourceView** outView) override; + IBufferResource* buffer, IResourceView::Desc const& desc, IResourceView** outView) override; virtual SLANG_NO_THROW Result SLANG_MCALL createInputLayout( const InputElementDesc* inputElements, UInt inputElementCount, - InputLayout** outLayout) override; + IInputLayout** outLayout) override; virtual SLANG_NO_THROW Result SLANG_MCALL createDescriptorSetLayout( - const DescriptorSetLayout::Desc& desc, DescriptorSetLayout** outLayout) override; + const IDescriptorSetLayout::Desc& desc, IDescriptorSetLayout** outLayout) override; virtual SLANG_NO_THROW Result SLANG_MCALL - createPipelineLayout(const PipelineLayout::Desc& desc, PipelineLayout** outLayout) override; + createPipelineLayout(const IPipelineLayout::Desc& desc, IPipelineLayout** outLayout) override; virtual SLANG_NO_THROW Result SLANG_MCALL - createDescriptorSet(DescriptorSetLayout* layout, DescriptorSet** outDescriptorSet) override; + createDescriptorSet(IDescriptorSetLayout* layout, IDescriptorSet** outDescriptorSet) override; virtual SLANG_NO_THROW Result SLANG_MCALL - createProgram(const ShaderProgram::Desc& desc, ShaderProgram** outProgram) override; + createProgram(const IShaderProgram::Desc& desc, IShaderProgram** outProgram) override; virtual SLANG_NO_THROW Result SLANG_MCALL createGraphicsPipelineState( - const GraphicsPipelineStateDesc& desc, PipelineState** outState) override; + const GraphicsPipelineStateDesc& desc, IPipelineState** outState) override; virtual SLANG_NO_THROW Result SLANG_MCALL createComputePipelineState( - const ComputePipelineStateDesc& desc, PipelineState** outState) override; + const ComputePipelineStateDesc& desc, IPipelineState** outState) override; virtual SLANG_NO_THROW SlangResult SLANG_MCALL captureScreenSurface(Surface& surfaceOut) override; - virtual SLANG_NO_THROW void* SLANG_MCALL map(BufferResource* buffer, MapFlavor flavor) override; - virtual SLANG_NO_THROW void SLANG_MCALL unmap(BufferResource* buffer) override; + virtual SLANG_NO_THROW void* SLANG_MCALL map(IBufferResource* buffer, MapFlavor flavor) override; + virtual SLANG_NO_THROW void SLANG_MCALL unmap(IBufferResource* buffer) override; virtual SLANG_NO_THROW void SLANG_MCALL setPrimitiveTopology(PrimitiveTopology topology) override; virtual SLANG_NO_THROW void SLANG_MCALL setDescriptorSet( PipelineType pipelineType, - PipelineLayout* layout, + IPipelineLayout* layout, UInt index, - DescriptorSet* descriptorSet) override; + IDescriptorSet* descriptorSet) override; virtual SLANG_NO_THROW void SLANG_MCALL setVertexBuffers( UInt startSlot, UInt slotCount, - BufferResource* const* buffers, + IBufferResource* const* buffers, const UInt* strides, const UInt* offsets) override; virtual SLANG_NO_THROW void SLANG_MCALL - setIndexBuffer(BufferResource* buffer, Format indexFormat, UInt offset) override; + setIndexBuffer(IBufferResource* buffer, Format indexFormat, UInt offset) override; virtual SLANG_NO_THROW void SLANG_MCALL - setDepthStencilTarget(ResourceView* depthStencilView) override; + setDepthStencilTarget(IResourceView* depthStencilView) override; virtual SLANG_NO_THROW void SLANG_MCALL setViewports(UInt count, Viewport const* viewports) override; virtual SLANG_NO_THROW void SLANG_MCALL setScissorRects(UInt count, ScissorRect const* rects) override; virtual SLANG_NO_THROW void SLANG_MCALL - setPipelineState(PipelineType pipelineType, PipelineState* state) override; + setPipelineState(PipelineType pipelineType, IPipelineState* state) override; virtual SLANG_NO_THROW void SLANG_MCALL draw(UInt vertexCount, UInt startVertex) override; virtual SLANG_NO_THROW void SLANG_MCALL drawIndexed(UInt indexCount, UInt startIndex, UInt baseVertex) override; @@ -201,9 +197,17 @@ public: CountOf, }; - class DescriptorSetLayoutImpl : public DescriptorSetLayout + class DescriptorSetLayoutImpl : public IDescriptorSetLayout, public RefObject { public: + SLANG_REF_OBJECT_IUNKNOWN_ALL + IDescriptorSetLayout* getInterface(const Guid& guid) + { + if (guid == GfxGUID::IID_ISlangUnknown || guid == GfxGUID::IID_IDescriptorSetLayout) + return static_cast<IDescriptorSetLayout*>(this); + return nullptr; + } + public: // Each descriptor set for the D3D11 renderer stores distinct // arrays for each kind of shader-visible entity D3D11 understands: // shader resource views (SRVs), unordered access views (UAVs), @@ -267,9 +271,19 @@ public: UInt m_counts[int(D3D11DescriptorSlotType::CountOf)]; }; - class PipelineLayoutImpl : public PipelineLayout + class PipelineLayoutImpl : public IPipelineLayout, public RefObject { public: + SLANG_REF_OBJECT_IUNKNOWN_ALL + IPipelineLayout* getInterface(const Guid& guid) + { + if (guid == GfxGUID::IID_ISlangUnknown || guid == GfxGUID::IID_IPipelineLayout) + { + return static_cast<IPipelineLayout*>(this); + } + return nullptr; + } + public: struct DescriptorSetInfo { RefPtr<DescriptorSetLayoutImpl> layout; @@ -280,18 +294,30 @@ public: UINT m_uavCount; }; - class DescriptorSetImpl : public DescriptorSet + class DescriptorSetImpl : public IDescriptorSet, public RefObject { public: - virtual void setConstantBuffer(UInt range, UInt index, BufferResource* buffer) override; - virtual void setResource(UInt range, UInt index, ResourceView* view) override; - virtual void setSampler(UInt range, UInt index, SamplerState* sampler) override; - virtual void setCombinedTextureSampler( + SLANG_REF_OBJECT_IUNKNOWN_ALL + IDescriptorSet* getInterface(const Guid& guid) + { + if (guid == GfxGUID::IID_ISlangUnknown || guid == GfxGUID::IID_IDescriptorSet) + return static_cast<IDescriptorSet*>(this); + return nullptr; + } + public: + virtual SLANG_NO_THROW void SLANG_MCALL + setConstantBuffer(UInt range, UInt index, IBufferResource* buffer) override; + virtual SLANG_NO_THROW void SLANG_MCALL + setResource(UInt range, UInt index, IResourceView* view) override; + virtual SLANG_NO_THROW void SLANG_MCALL + setSampler(UInt range, UInt index, ISamplerState* sampler) override; + virtual SLANG_NO_THROW void SLANG_MCALL setCombinedTextureSampler( UInt range, UInt index, - ResourceView* textureView, - SamplerState* sampler) override; - virtual void setRootConstants( + IResourceView* textureView, + ISamplerState* sampler) override; + virtual SLANG_NO_THROW void SLANG_MCALL + setRootConstants( UInt range, UInt offset, UInt size, @@ -307,9 +333,17 @@ public: List<ComPtr<ID3D11SamplerState>> m_samplers; }; - class ShaderProgramImpl: public ShaderProgram + class ShaderProgramImpl : public IShaderProgram, public RefObject { public: + SLANG_REF_OBJECT_IUNKNOWN_ALL + IShaderProgram* getInterface(const Guid& guid) + { + if (guid == GfxGUID::IID_ISlangUnknown || guid == GfxGUID::IID_IShaderProgram) + return static_cast<IShaderProgram*>(this); + return nullptr; + } + public: ComPtr<ID3D11VertexShader> m_vertexShader; ComPtr<ID3D11PixelShader> m_pixelShader; ComPtr<ID3D11ComputeShader> m_computeShader; @@ -317,10 +351,10 @@ public: class BufferResourceImpl: public BufferResource { - public: + public: typedef BufferResource Parent; - BufferResourceImpl(const Desc& desc, Usage initialUsage): + BufferResourceImpl(const IBufferResource::Desc& desc, IResource::Usage initialUsage): Parent(desc), m_initialUsage(initialUsage) { @@ -346,16 +380,32 @@ public: }; - class SamplerStateImpl : public SamplerState + class SamplerStateImpl : public ISamplerState, public RefObject { public: + SLANG_REF_OBJECT_IUNKNOWN_ALL + ISamplerState* getInterface(const Guid& guid) + { + if (guid == GfxGUID::IID_ISlangUnknown || guid == GfxGUID::IID_ISamplerState) + return static_cast<ISamplerState*>(this); + return nullptr; + } + public: ComPtr<ID3D11SamplerState> m_sampler; }; - class ResourceViewImpl : public ResourceView + class ResourceViewImpl : public IResourceView, public RefObject { public: + SLANG_REF_OBJECT_IUNKNOWN_ALL + IResourceView* getInterface(const Guid& guid) + { + if (guid == GfxGUID::IID_ISlangUnknown || guid == GfxGUID::IID_IResourceView) + return static_cast<IResourceView*>(this); + return nullptr; + } + public: enum class Type { SRV, @@ -390,15 +440,31 @@ public: ComPtr<ID3D11RenderTargetView> m_rtv; }; - class InputLayoutImpl: public InputLayout + class InputLayoutImpl: public IInputLayout, public RefObject { - public: + public: + SLANG_REF_OBJECT_IUNKNOWN_ALL + IInputLayout* getInterface(const Guid& guid) + { + if (guid == GfxGUID::IID_ISlangUnknown || guid == GfxGUID::IID_IInputLayout) + return static_cast<IInputLayout*>(this); + return nullptr; + } + public: ComPtr<ID3D11InputLayout> m_layout; }; - class PipelineStateImpl : public PipelineState + class PipelineStateImpl : public IPipelineState, public RefObject { public: + SLANG_REF_OBJECT_IUNKNOWN_ALL + IPipelineState* getInterface(const Guid& guid) + { + if (guid == GfxGUID::IID_ISlangUnknown || guid == GfxGUID::IID_IPipelineState) + return static_cast<IPipelineState*>(this); + return nullptr; + } + public: RefPtr<ShaderProgramImpl> m_program; RefPtr<PipelineLayoutImpl> m_pipelineLayout; }; @@ -436,15 +502,15 @@ public: ComPtr<ID3D11Texture2D> m_backBufferTexture; RefPtr<TextureResourceImpl> m_primaryRenderTargetTexture; - RefPtr<RenderTargetViewImpl> m_primaryRenderTargetView; + RefPtr<RenderTargetViewImpl> m_primaryRenderTargetView; // List<ComPtr<ID3D11RenderTargetView> > m_renderTargetViews; // List<ComPtr<ID3D11Texture2D> > m_renderTargetTextures; bool m_renderTargetBindingsDirty = false; - RefPtr<GraphicsPipelineStateImpl> m_currentGraphicsState; - RefPtr<ComputePipelineStateImpl> m_currentComputeState; + ComPtr<GraphicsPipelineStateImpl> m_currentGraphicsState; + ComPtr<ComputePipelineStateImpl> m_currentComputeState; ComPtr<ID3D11RenderTargetView> m_rtvBindings[kMaxRTVs]; ComPtr<ID3D11DepthStencilView> m_dsvBinding; @@ -455,12 +521,10 @@ public: float m_clearColor[4] = { 0, 0, 0, 0 }; - List<String> m_features; - bool m_nvapi = false; }; -SlangResult createD3D11Renderer(IRenderer** outRenderer) +SlangResult SLANG_MCALL createD3D11Renderer(IRenderer** outRenderer) { *outRenderer = new D3D11Renderer(); (*outRenderer)->addRef(); @@ -654,10 +718,10 @@ SlangResult D3D11Renderer::initialize(const Desc& desc, void* inWindowHandle) // If we have an adapter set on the desc, look it up. We only need to do so for hardware ComPtr<IDXGIAdapter> adapter; - if (desc.adapter.getLength() && (deviceCheckFlags & DeviceCheckFlag::UseHardwareDevice)) + if (desc.adapter && (deviceCheckFlags & DeviceCheckFlag::UseHardwareDevice)) { List<ComPtr<IDXGIAdapter>> dxgiAdapters; - D3DUtil::findAdapters(deviceCheckFlags, desc.adapter.getUnownedSlice(), dxgiAdapters); + D3DUtil::findAdapters(deviceCheckFlags, Slang::UnownedStringSlice(desc.adapter), dxgiAdapters); if (dxgiAdapters.getCount() == 0) { continue; @@ -762,19 +826,19 @@ SlangResult D3D11Renderer::initialize(const Desc& desc, void* inWindowHandle) SLANG_RETURN_ON_FAIL(m_device->CreateRenderTargetView(texture, &rtvDesc, rtv.writeRef())); TextureResource::Desc resourceDesc; - resourceDesc.init2D(Resource::Type::Texture2D, Format::RGBA_Unorm_UInt8, textureDesc.Width, textureDesc.Height, 1); + resourceDesc.init2D(IResource::Type::Texture2D, Format::RGBA_Unorm_UInt8, textureDesc.Width, textureDesc.Height, 1); - RefPtr<TextureResource> primaryRenderTargetTexture; - SLANG_RETURN_ON_FAIL(createTextureResource(Resource::Usage::RenderTarget, resourceDesc, nullptr, primaryRenderTargetTexture.writeRef())); + ComPtr<ITextureResource> primaryRenderTargetTexture; + SLANG_RETURN_ON_FAIL(createTextureResource(IResource::Usage::RenderTarget, resourceDesc, nullptr, primaryRenderTargetTexture.writeRef())); - ResourceView::Desc viewDesc; + IResourceView::Desc viewDesc; viewDesc.format = resourceDesc.format; - viewDesc.type = ResourceView::Type::RenderTarget; - RefPtr<ResourceView> primaryRenderTargetView; + viewDesc.type = IResourceView::Type::RenderTarget; + ComPtr<IResourceView> primaryRenderTargetView; SLANG_RETURN_ON_FAIL(createTextureView(primaryRenderTargetTexture, viewDesc, primaryRenderTargetView.writeRef())); - m_primaryRenderTargetTexture = (TextureResourceImpl*) primaryRenderTargetTexture.Ptr(); - m_primaryRenderTargetView = (RenderTargetViewImpl*) primaryRenderTargetView.Ptr(); + m_primaryRenderTargetTexture = dynamic_cast<TextureResourceImpl*>(primaryRenderTargetTexture.get()); + m_primaryRenderTargetView = dynamic_cast<RenderTargetViewImpl*>(primaryRenderTargetView.get()); } // m_immediateContext->OMSetRenderTargets(1, m_primaryRenderTargetView->m_rtv.readRef(), nullptr); @@ -822,7 +886,7 @@ TextureResource::Desc D3D11Renderer::getSwapChainTextureDesc() ((ID3D11Texture2D*)m_primaryRenderTargetTexture->m_resource.get())->GetDesc(&dxDesc); TextureResource::Desc desc; - desc.init2D(Resource::Type::Texture2D, Format::Unknown, dxDesc.Width, dxDesc.Height, 1); + desc.init2D(IResource::Type::Texture2D, Format::Unknown, dxDesc.Width, dxDesc.Height, 1); return desc; } @@ -832,9 +896,9 @@ SlangResult D3D11Renderer::captureScreenSurface(Surface& surfaceOut) return captureTextureToSurface(m_device, m_immediateContext, (ID3D11Texture2D*) m_primaryRenderTargetTexture->m_resource.get(), surfaceOut); } -static D3D11_BIND_FLAG _calcResourceFlag(Resource::BindFlag::Enum bindFlag) +static D3D11_BIND_FLAG _calcResourceFlag(IResource::BindFlag::Enum bindFlag) { - typedef Resource::BindFlag BindFlag; + typedef IResource::BindFlag BindFlag; switch (bindFlag) { case BindFlag::VertexBuffer: return D3D11_BIND_VERTEX_BUFFER; @@ -857,7 +921,7 @@ static int _calcResourceBindFlags(int bindFlags) { int lsb = bindFlags & -bindFlags; - dstFlags |= _calcResourceFlag(Resource::BindFlag::Enum(lsb)); + dstFlags |= _calcResourceFlag(IResource::BindFlag::Enum(lsb)); bindFlags &= ~lsb; } return dstFlags; @@ -868,15 +932,15 @@ static int _calcResourceAccessFlags(int accessFlags) switch (accessFlags) { case 0: return 0; - case Resource::AccessFlag::Read: return D3D11_CPU_ACCESS_READ; - case Resource::AccessFlag::Write: return D3D11_CPU_ACCESS_WRITE; - case Resource::AccessFlag::Read | - Resource::AccessFlag::Write: return D3D11_CPU_ACCESS_READ | D3D11_CPU_ACCESS_WRITE; + case IResource::AccessFlag::Read: return D3D11_CPU_ACCESS_READ; + case IResource::AccessFlag::Write: return D3D11_CPU_ACCESS_WRITE; + case IResource::AccessFlag::Read | + IResource::AccessFlag::Write: return D3D11_CPU_ACCESS_READ | D3D11_CPU_ACCESS_WRITE; default: assert(!"Invalid flags"); return 0; } } -Result D3D11Renderer::createTextureResource(Resource::Usage initialUsage, const TextureResource::Desc& descIn, const TextureResource::Data* initData, TextureResource** outResource) +Result D3D11Renderer::createTextureResource(IResource::Usage initialUsage, const ITextureResource::Desc& descIn, const ITextureResource::Data* initData, ITextureResource** outResource) { TextureResource::Desc srcDesc(descIn); srcDesc.setDefaults(initialUsage); @@ -908,7 +972,7 @@ Result D3D11Renderer::createTextureResource(Resource::Usage initialUsage, const { for (int j = 0; j < srcDesc.numMipLevels; j++) { - const int mipHeight = TextureResource::calcMipSize(srcDesc.size.height, j); + const int mipHeight = ITextureResource::Size::calcMipSize(srcDesc.size.height, j); D3D11_SUBRESOURCE_DATA& data = subRes[subResourceIndex]; @@ -927,10 +991,10 @@ Result D3D11Renderer::createTextureResource(Resource::Usage initialUsage, const const int accessFlags = _calcResourceAccessFlags(srcDesc.cpuAccessFlags); RefPtr<TextureResourceImpl> texture(new TextureResourceImpl(srcDesc, initialUsage)); - + switch (srcDesc.type) { - case Resource::Type::Texture1D: + case IResource::Type::Texture1D: { D3D11_TEXTURE1D_DESC desc = { 0 }; desc.BindFlags = bindFlags; @@ -948,8 +1012,8 @@ Result D3D11Renderer::createTextureResource(Resource::Usage initialUsage, const texture->m_resource = texture1D; break; } - case Resource::Type::TextureCube: - case Resource::Type::Texture2D: + case IResource::Type::TextureCube: + case IResource::Type::Texture2D: { D3D11_TEXTURE2D_DESC desc = { 0 }; desc.BindFlags = bindFlags; @@ -965,7 +1029,7 @@ Result D3D11Renderer::createTextureResource(Resource::Usage initialUsage, const desc.SampleDesc.Count = srcDesc.sampleDesc.numSamples; desc.SampleDesc.Quality = srcDesc.sampleDesc.quality; - if (srcDesc.type == Resource::Type::TextureCube) + if (srcDesc.type == IResource::Type::TextureCube) { desc.MiscFlags |= D3D11_RESOURCE_MISC_TEXTURECUBE; } @@ -976,7 +1040,7 @@ Result D3D11Renderer::createTextureResource(Resource::Usage initialUsage, const texture->m_resource = texture2D; break; } - case Resource::Type::Texture3D: + case IResource::Type::Texture3D: { D3D11_TEXTURE3D_DESC desc = { 0 }; desc.BindFlags = bindFlags; @@ -1003,9 +1067,9 @@ Result D3D11Renderer::createTextureResource(Resource::Usage initialUsage, const return SLANG_OK; } -Result D3D11Renderer::createBufferResource(Resource::Usage initialUsage, const BufferResource::Desc& descIn, const void* initData, BufferResource** outResource) +Result D3D11Renderer::createBufferResource(IResource::Usage initialUsage, const IBufferResource::Desc& descIn, const void* initData, IBufferResource** outResource) { - BufferResource::Desc srcDesc(descIn); + IBufferResource::Desc srcDesc(descIn); srcDesc.setDefaults(initialUsage); auto d3dBindFlags = _calcResourceBindFlags(srcDesc.bindFlags); @@ -1031,18 +1095,19 @@ Result D3D11Renderer::createBufferResource(Resource::Usage initialUsage, const B bufferDesc.ByteWidth = UINT(alignedSizeInBytes); bufferDesc.BindFlags = d3dBindFlags; // For read we'll need to do some staging - bufferDesc.CPUAccessFlags = _calcResourceAccessFlags(descIn.cpuAccessFlags & Resource::AccessFlag::Write); + bufferDesc.CPUAccessFlags = + _calcResourceAccessFlags(descIn.cpuAccessFlags & IResource::AccessFlag::Write); bufferDesc.Usage = D3D11_USAGE_DEFAULT; // If written by CPU, make it dynamic - if (descIn.cpuAccessFlags & Resource::AccessFlag::Write) + if (descIn.cpuAccessFlags & IResource::AccessFlag::Write) { bufferDesc.Usage = D3D11_USAGE_DYNAMIC; } switch (initialUsage) { - case Resource::Usage::ConstantBuffer: + case IResource::Usage::ConstantBuffer: { // We'll just assume ConstantBuffers are dynamic for now bufferDesc.Usage = D3D11_USAGE_DYNAMIC; @@ -1077,7 +1142,7 @@ Result D3D11Renderer::createBufferResource(Resource::Usage initialUsage, const B SLANG_RETURN_ON_FAIL(m_device->CreateBuffer(&bufferDesc, initData ? &subResourceData : nullptr, buffer->m_buffer.writeRef())); - if (srcDesc.cpuAccessFlags & Resource::AccessFlag::Read) + if (srcDesc.cpuAccessFlags & IResource::AccessFlag::Read) { D3D11_BUFFER_DESC bufDesc = {}; bufDesc.BindFlags = 0; @@ -1171,7 +1236,7 @@ static D3D11_COMPARISON_FUNC translateComparisonFunc(ComparisonFunc func) } } -Result D3D11Renderer::createSamplerState(SamplerState::Desc const& desc, SamplerState** outSampler) +Result D3D11Renderer::createSamplerState(ISamplerState::Desc const& desc, ISamplerState** outSampler) { D3D11_FILTER_REDUCTION_TYPE dxReduction = translateFilterReduction(desc.reductionOp); D3D11_FILTER dxFilter; @@ -1212,7 +1277,7 @@ Result D3D11Renderer::createSamplerState(SamplerState::Desc const& desc, Sampler return SLANG_OK; } -Result D3D11Renderer::createTextureView(TextureResource* texture, ResourceView::Desc const& desc, ResourceView** outView) +Result D3D11Renderer::createTextureView(ITextureResource* texture, IResourceView::Desc const& desc, IResourceView** outView) { auto resourceImpl = (TextureResourceImpl*) texture; @@ -1221,7 +1286,7 @@ Result D3D11Renderer::createTextureView(TextureResource* texture, ResourceView:: default: return SLANG_FAIL; - case ResourceView::Type::RenderTarget: + case IResourceView::Type::RenderTarget: { ComPtr<ID3D11RenderTargetView> rtv; SLANG_RETURN_ON_FAIL(m_device->CreateRenderTargetView(resourceImpl->m_resource, nullptr, rtv.writeRef())); @@ -1234,7 +1299,7 @@ Result D3D11Renderer::createTextureView(TextureResource* texture, ResourceView:: } break; - case ResourceView::Type::DepthStencil: + case IResourceView::Type::DepthStencil: { ComPtr<ID3D11DepthStencilView> dsv; SLANG_RETURN_ON_FAIL(m_device->CreateDepthStencilView(resourceImpl->m_resource, nullptr, dsv.writeRef())); @@ -1247,7 +1312,7 @@ Result D3D11Renderer::createTextureView(TextureResource* texture, ResourceView:: } break; - case ResourceView::Type::UnorderedAccess: + case IResourceView::Type::UnorderedAccess: { ComPtr<ID3D11UnorderedAccessView> uav; SLANG_RETURN_ON_FAIL(m_device->CreateUnorderedAccessView(resourceImpl->m_resource, nullptr, uav.writeRef())); @@ -1260,7 +1325,7 @@ Result D3D11Renderer::createTextureView(TextureResource* texture, ResourceView:: } break; - case ResourceView::Type::ShaderResource: + case IResourceView::Type::ShaderResource: { ComPtr<ID3D11ShaderResourceView> srv; SLANG_RETURN_ON_FAIL(m_device->CreateShaderResourceView(resourceImpl->m_resource, nullptr, srv.writeRef())); @@ -1275,17 +1340,17 @@ Result D3D11Renderer::createTextureView(TextureResource* texture, ResourceView:: } } -Result D3D11Renderer::createBufferView(BufferResource* buffer, ResourceView::Desc const& desc, ResourceView** outView) +Result D3D11Renderer::createBufferView(IBufferResource* buffer, IResourceView::Desc const& desc, IResourceView** outView) { auto resourceImpl = (BufferResourceImpl*) buffer; - auto resourceDesc = resourceImpl->getDesc(); + auto resourceDesc = *resourceImpl->getDesc(); switch (desc.type) { default: return SLANG_FAIL; - case ResourceView::Type::UnorderedAccess: + case IResourceView::Type::UnorderedAccess: { D3D11_UNORDERED_ACCESS_VIEW_DESC uavDesc = {}; uavDesc.ViewDimension = D3D11_UAV_DIMENSION_BUFFER; @@ -1304,7 +1369,7 @@ Result D3D11Renderer::createBufferView(BufferResource* buffer, ResourceView::Des } else { - uavDesc.Buffer.NumElements = UINT(resourceDesc.sizeInBytes / RendererUtil::getFormatSize(desc.format)); + uavDesc.Buffer.NumElements = UINT(resourceDesc.sizeInBytes / gfxGetFormatSize(desc.format)); } ComPtr<ID3D11UnorderedAccessView> uav; @@ -1318,7 +1383,7 @@ Result D3D11Renderer::createBufferView(BufferResource* buffer, ResourceView::Des } break; - case ResourceView::Type::ShaderResource: + case IResourceView::Type::ShaderResource: { D3D11_SHADER_RESOURCE_VIEW_DESC srvDesc = {}; srvDesc.ViewDimension = D3D11_SRV_DIMENSION_BUFFER; @@ -1349,7 +1414,7 @@ Result D3D11Renderer::createBufferView(BufferResource* buffer, ResourceView::Des } else { - srvDesc.Buffer.NumElements = UINT(resourceDesc.sizeInBytes / RendererUtil::getFormatSize(desc.format)); + srvDesc.Buffer.NumElements = UINT(resourceDesc.sizeInBytes / gfxGetFormatSize(desc.format)); } ComPtr<ID3D11ShaderResourceView> srv; @@ -1365,7 +1430,7 @@ Result D3D11Renderer::createBufferView(BufferResource* buffer, ResourceView::Des } } -Result D3D11Renderer::createInputLayout(const InputElementDesc* inputElementsIn, UInt inputElementCount, InputLayout** outLayout) +Result D3D11Renderer::createInputLayout(const InputElementDesc* inputElementsIn, UInt inputElementCount, IInputLayout** outLayout) { D3D11_INPUT_ELEMENT_DESC inputElements[16] = {}; @@ -1432,7 +1497,7 @@ Result D3D11Renderer::createInputLayout(const InputElementDesc* inputElementsIn, return SLANG_OK; } -void* D3D11Renderer::map(BufferResource* bufferIn, MapFlavor flavor) +void* D3D11Renderer::map(IBufferResource* bufferIn, MapFlavor flavor) { BufferResourceImpl* bufferResource = static_cast<BufferResourceImpl*>(bufferIn); @@ -1475,7 +1540,7 @@ void* D3D11Renderer::map(BufferResource* bufferIn, MapFlavor flavor) return mappedSub.pData; } -void D3D11Renderer::unmap(BufferResource* bufferIn) +void D3D11Renderer::unmap(IBufferResource* bufferIn) { BufferResourceImpl* bufferResource = static_cast<BufferResourceImpl*>(bufferIn); ID3D11Buffer* buffer = (bufferResource->m_mapFlavor == MapFlavor::HostRead) ? bufferResource->m_staging : bufferResource->m_buffer; @@ -1495,7 +1560,7 @@ void D3D11Renderer::setPrimitiveTopology(PrimitiveTopology topology) m_immediateContext->IASetPrimitiveTopology(D3DUtil::getPrimitiveTopology(topology)); } -void D3D11Renderer::setVertexBuffers(UInt startSlot, UInt slotCount, BufferResource*const* buffersIn, const UInt* stridesIn, const UInt* offsetsIn) +void D3D11Renderer::setVertexBuffers(UInt startSlot, UInt slotCount, IBufferResource*const* buffersIn, const UInt* stridesIn, const UInt* offsetsIn) { static const int kMaxVertexBuffers = 16; assert(slotCount <= kMaxVertexBuffers); @@ -1516,13 +1581,13 @@ void D3D11Renderer::setVertexBuffers(UInt startSlot, UInt slotCount, BufferResou m_immediateContext->IASetVertexBuffers((UINT)startSlot, (UINT)slotCount, dxBuffers, &vertexStrides[0], &vertexOffsets[0]); } -void D3D11Renderer::setIndexBuffer(BufferResource* buffer, Format indexFormat, UInt offset) +void D3D11Renderer::setIndexBuffer(IBufferResource* buffer, Format indexFormat, UInt offset) { DXGI_FORMAT dxFormat = D3DUtil::getMapFormat(indexFormat); m_immediateContext->IASetIndexBuffer(((BufferResourceImpl*)buffer)->m_buffer, dxFormat, UINT(offset)); } -void D3D11Renderer::setDepthStencilTarget(ResourceView* depthStencilView) +void D3D11Renderer::setDepthStencilTarget(IResourceView* depthStencilView) { m_dsvBinding = ((DepthStencilViewImpl*) depthStencilView)->m_dsv; m_targetBindingsDirty[int(PipelineType::Graphics)] = true; @@ -1571,7 +1636,7 @@ void D3D11Renderer::setScissorRects(UInt count, ScissorRect const* rects) } -void D3D11Renderer::setPipelineState(PipelineType pipelineType, PipelineState* state) +void D3D11Renderer::setPipelineState(PipelineType pipelineType, IPipelineState* state) { switch(pipelineType) { @@ -1650,7 +1715,7 @@ void D3D11Renderer::drawIndexed(UInt indexCount, UInt startIndex, UInt baseVerte m_immediateContext->DrawIndexed((UINT)indexCount, (UINT)startIndex, (INT)baseVertex); } -Result D3D11Renderer::createProgram(const ShaderProgram::Desc& desc, ShaderProgram** outProgram) +Result D3D11Renderer::createProgram(const IShaderProgram::Desc& desc, IShaderProgram** outProgram) { if (desc.pipelineType == PipelineType::Compute) { @@ -1822,7 +1887,7 @@ D3D11_COLOR_WRITE_ENABLE translateRenderTargetWriteMask(RenderTargetWriteMaskT m return D3D11_COLOR_WRITE_ENABLE(result); } -Result D3D11Renderer::createGraphicsPipelineState(const GraphicsPipelineStateDesc& inDesc, PipelineState** outState) +Result D3D11Renderer::createGraphicsPipelineState(const GraphicsPipelineStateDesc& inDesc, IPipelineState** outState) { GraphicsPipelineStateDesc desc = inDesc; preparePipelineDesc(desc); @@ -1954,7 +2019,7 @@ Result D3D11Renderer::createGraphicsPipelineState(const GraphicsPipelineStateDes return SLANG_OK; } -Result D3D11Renderer::createComputePipelineState(const ComputePipelineStateDesc& inDesc, PipelineState** outState) +Result D3D11Renderer::createComputePipelineState(const ComputePipelineStateDesc& inDesc, IPipelineState** outState) { ComputePipelineStateDesc desc = inDesc; preparePipelineDesc(desc); @@ -1976,7 +2041,7 @@ void D3D11Renderer::dispatchCompute(int x, int y, int z) m_immediateContext->Dispatch(x, y, z); } -Result D3D11Renderer::createDescriptorSetLayout(const DescriptorSetLayout::Desc& desc, DescriptorSetLayout** outLayout) +Result D3D11Renderer::createDescriptorSetLayout(const IDescriptorSetLayout::Desc& desc, IDescriptorSetLayout** outLayout) { RefPtr<DescriptorSetLayoutImpl> descriptorSetLayoutImpl = new DescriptorSetLayoutImpl(); @@ -2072,7 +2137,7 @@ Result D3D11Renderer::createDescriptorSetLayout(const DescriptorSetLayout::Desc& return SLANG_OK; } -Result D3D11Renderer::createPipelineLayout(const PipelineLayout::Desc& desc, PipelineLayout** outLayout) +Result D3D11Renderer::createPipelineLayout(const IPipelineLayout::Desc& desc, IPipelineLayout** outLayout) { RefPtr<PipelineLayoutImpl> pipelineLayoutImpl = new PipelineLayoutImpl(); @@ -2101,7 +2166,7 @@ Result D3D11Renderer::createPipelineLayout(const PipelineLayout::Desc& desc, Pip return SLANG_OK; } -Result D3D11Renderer::createDescriptorSet(DescriptorSetLayout* layout, DescriptorSet** outDescriptorSet) +Result D3D11Renderer::createDescriptorSet(IDescriptorSetLayout* layout, IDescriptorSet** outDescriptorSet) { auto layoutImpl = (DescriptorSetLayoutImpl*)layout; @@ -2168,7 +2233,7 @@ void D3D11Renderer::_flushGraphicsState() { m_targetBindingsDirty[pipelineType] = false; - auto pipelineState = m_currentGraphicsState.Ptr(); + auto pipelineState = m_currentGraphicsState.get(); auto rtvCount = pipelineState->m_rtvCount; auto uavCount = pipelineState->m_pipelineLayout->m_uavCount; @@ -2191,7 +2256,7 @@ void D3D11Renderer::_flushComputeState() { m_targetBindingsDirty[pipelineType] = false; - auto pipelineState = m_currentComputeState.Ptr(); + auto pipelineState = m_currentComputeState.get(); auto uavCount = pipelineState->m_pipelineLayout->m_uavCount; @@ -2203,7 +2268,7 @@ void D3D11Renderer::_flushComputeState() } } -void D3D11Renderer::DescriptorSetImpl::setConstantBuffer(UInt range, UInt index, BufferResource* buffer) +void D3D11Renderer::DescriptorSetImpl::setConstantBuffer(UInt range, UInt index, IBufferResource* buffer) { auto bufferImpl = (BufferResourceImpl*) buffer; auto& rangeInfo = m_layout->m_ranges[range]; @@ -2213,7 +2278,7 @@ void D3D11Renderer::DescriptorSetImpl::setConstantBuffer(UInt range, UInt index, m_cbs[rangeInfo.arrayIndex + index] = bufferImpl->m_buffer; } -void D3D11Renderer::DescriptorSetImpl::setResource(UInt range, UInt index, ResourceView* view) +void D3D11Renderer::DescriptorSetImpl::setResource(UInt range, UInt index, IResourceView* view) { auto viewImpl = (ResourceViewImpl*)view; auto& rangeInfo = m_layout->m_ranges[range]; @@ -2257,7 +2322,7 @@ void D3D11Renderer::DescriptorSetImpl::setResource(UInt range, UInt index, Resou } } -void D3D11Renderer::DescriptorSetImpl::setSampler(UInt range, UInt index, SamplerState* sampler) +void D3D11Renderer::DescriptorSetImpl::setSampler(UInt range, UInt index, ISamplerState* sampler) { auto samplerImpl = (SamplerStateImpl*) sampler; auto& rangeInfo = m_layout->m_ranges[range]; @@ -2270,8 +2335,8 @@ void D3D11Renderer::DescriptorSetImpl::setSampler(UInt range, UInt index, Sample void D3D11Renderer::DescriptorSetImpl::setCombinedTextureSampler( UInt range, UInt index, - ResourceView* textureView, - SamplerState* sampler) + IResourceView* textureView, + ISamplerState* sampler) { auto viewImpl = (ResourceViewImpl*) textureView; auto samplerImpl = (SamplerStateImpl*)sampler; @@ -2327,7 +2392,7 @@ void D3D11Renderer::DescriptorSetImpl::setRootConstants( dxContext->Unmap(dxBuffer, 0); } -void D3D11Renderer::setDescriptorSet(PipelineType pipelineType, PipelineLayout* layout, UInt index, DescriptorSet* descriptorSet) +void D3D11Renderer::setDescriptorSet(PipelineType pipelineType, IPipelineLayout* layout, UInt index, IDescriptorSet* descriptorSet) { auto pipelineLayoutImpl = (PipelineLayoutImpl*)layout; auto descriptorSetImpl = (DescriptorSetImpl*) descriptorSet; @@ -2414,8 +2479,6 @@ void D3D11Renderer::setDescriptorSet(PipelineType pipelineType, PipelineLayout* m_targetBindingsDirty[int(pipelineType)] = true; } } - - } } // renderer_test diff --git a/tools/gfx/d3d11/render-d3d11.h b/tools/gfx/d3d11/render-d3d11.h index 63b4818ce..96a6a981c 100644 --- a/tools/gfx/d3d11/render-d3d11.h +++ b/tools/gfx/d3d11/render-d3d11.h @@ -2,11 +2,12 @@ #pragma once #include <cstdint> +#include "slang.h" namespace gfx { class IRenderer; -int32_t createD3D11Renderer(IRenderer** outRenderer); +SlangResult SLANG_MCALL createD3D11Renderer(IRenderer** outRenderer); } // gfx diff --git a/tools/gfx/d3d12/render-d3d12.cpp b/tools/gfx/d3d12/render-d3d12.cpp index c533fe1fd..6b66c5403 100644 --- a/tools/gfx/d3d12/render-d3d12.cpp +++ b/tools/gfx/d3d12/render-d3d12.cpp @@ -4,10 +4,11 @@ #include "render-d3d12.h" //WORKING:#include "options.h" -#include "../render.h" +#include "../renderer-shared.h" #include "../render-graphics-common.h" #include "../surface.h" +#include "core/slang-basic.h" // In order to use the Slang API, we need to include its header @@ -67,82 +68,81 @@ class D3D12Renderer : public GraphicsAPIRenderer public: // Renderer implementation virtual SLANG_NO_THROW SlangResult SLANG_MCALL initialize(const Desc& desc, void* inWindowHandle) override; - virtual SLANG_NO_THROW const List<String>& SLANG_MCALL getFeatures() override - { - return m_features; - } virtual SLANG_NO_THROW void SLANG_MCALL setClearColor(const float color[4]) override; virtual SLANG_NO_THROW void SLANG_MCALL clearFrame() override; virtual SLANG_NO_THROW void SLANG_MCALL presentFrame() override; - virtual SLANG_NO_THROW TextureResource::Desc SLANG_MCALL getSwapChainTextureDesc() override; + virtual SLANG_NO_THROW ITextureResource::Desc SLANG_MCALL getSwapChainTextureDesc() override; virtual SLANG_NO_THROW Result SLANG_MCALL createTextureResource( - Resource::Usage initialUsage, - const TextureResource::Desc& desc, - const TextureResource::Data* initData, - TextureResource** outResource) override; + IResource::Usage initialUsage, + const ITextureResource::Desc& desc, + const ITextureResource::Data* initData, + ITextureResource** outResource) override; virtual SLANG_NO_THROW Result SLANG_MCALL createBufferResource( - Resource::Usage initialUsage, - const BufferResource::Desc& desc, + IResource::Usage initialUsage, + const IBufferResource::Desc& desc, const void* initData, - BufferResource** outResource) override; + IBufferResource** outResource) override; virtual SLANG_NO_THROW Result SLANG_MCALL - createSamplerState(SamplerState::Desc const& desc, SamplerState** outSampler) override; + createSamplerState(ISamplerState::Desc const& desc, ISamplerState** outSampler) override; virtual SLANG_NO_THROW Result SLANG_MCALL createTextureView( - TextureResource* texture, ResourceView::Desc const& desc, ResourceView** outView) override; + ITextureResource* texture, + IResourceView::Desc const& desc, + IResourceView** outView) override; virtual SLANG_NO_THROW Result SLANG_MCALL createBufferView( - BufferResource* buffer, ResourceView::Desc const& desc, ResourceView** outView) override; + IBufferResource* buffer, IResourceView::Desc const& desc, IResourceView** outView) override; virtual SLANG_NO_THROW Result SLANG_MCALL createInputLayout( const InputElementDesc* inputElements, UInt inputElementCount, - InputLayout** outLayout) override; + IInputLayout** outLayout) override; virtual SLANG_NO_THROW Result SLANG_MCALL createDescriptorSetLayout( - const DescriptorSetLayout::Desc& desc, DescriptorSetLayout** outLayout) override; - virtual SLANG_NO_THROW Result SLANG_MCALL - createPipelineLayout(const PipelineLayout::Desc& desc, PipelineLayout** outLayout) override; - virtual SLANG_NO_THROW Result SLANG_MCALL - createDescriptorSet(DescriptorSetLayout* layout, DescriptorSet** outDescriptorSet) override; + const IDescriptorSetLayout::Desc& desc, IDescriptorSetLayout** outLayout) override; + virtual SLANG_NO_THROW Result SLANG_MCALL createPipelineLayout( + const IPipelineLayout::Desc& desc, IPipelineLayout** outLayout) override; + virtual SLANG_NO_THROW Result SLANG_MCALL createDescriptorSet( + IDescriptorSetLayout* layout, IDescriptorSet** outDescriptorSet) override; virtual SLANG_NO_THROW Result SLANG_MCALL - createProgram(const ShaderProgram::Desc& desc, ShaderProgram** outProgram) override; + createProgram(const IShaderProgram::Desc& desc, IShaderProgram** outProgram) override; virtual SLANG_NO_THROW Result SLANG_MCALL createGraphicsPipelineState( - const GraphicsPipelineStateDesc& desc, PipelineState** outState) override; + const GraphicsPipelineStateDesc& desc, IPipelineState** outState) override; virtual SLANG_NO_THROW Result SLANG_MCALL createComputePipelineState( - const ComputePipelineStateDesc& desc, PipelineState** outState) override; + const ComputePipelineStateDesc& desc, IPipelineState** outState) override; virtual SLANG_NO_THROW SlangResult SLANG_MCALL captureScreenSurface(Surface& surfaceOut) override; - virtual SLANG_NO_THROW void* SLANG_MCALL map(BufferResource* buffer, MapFlavor flavor) override; - virtual SLANG_NO_THROW void SLANG_MCALL unmap(BufferResource* buffer) override; + virtual SLANG_NO_THROW void* SLANG_MCALL + map(IBufferResource* buffer, MapFlavor flavor) override; + virtual SLANG_NO_THROW void SLANG_MCALL unmap(IBufferResource* buffer) override; // virtual void setInputLayout(InputLayout* inputLayout) override; virtual SLANG_NO_THROW void SLANG_MCALL setPrimitiveTopology(PrimitiveTopology topology) override; virtual SLANG_NO_THROW void SLANG_MCALL setDescriptorSet( PipelineType pipelineType, - PipelineLayout* layout, + IPipelineLayout* layout, UInt index, - DescriptorSet* descriptorSet) override; + IDescriptorSet* descriptorSet) override; virtual SLANG_NO_THROW void SLANG_MCALL setVertexBuffers( UInt startSlot, UInt slotCount, - BufferResource* const* buffers, + IBufferResource* const* buffers, const UInt* strides, const UInt* offsets) override; - virtual SLANG_NO_THROW void - SLANG_MCALL setIndexBuffer(BufferResource* buffer, Format indexFormat, UInt offset) override; - virtual void SLANG_MCALL setDepthStencilTarget(ResourceView* depthStencilView) override; + virtual SLANG_NO_THROW void SLANG_MCALL + setIndexBuffer(IBufferResource* buffer, Format indexFormat, UInt offset) override; + virtual void SLANG_MCALL setDepthStencilTarget(IResourceView* depthStencilView) override; virtual SLANG_NO_THROW void SLANG_MCALL setViewports(UInt count, Viewport const* viewports) override; virtual SLANG_NO_THROW void SLANG_MCALL setScissorRects(UInt count, ScissorRect const* rects) override; virtual SLANG_NO_THROW void SLANG_MCALL - setPipelineState(PipelineType pipelineType, PipelineState* state) override; + setPipelineState(PipelineType pipelineType, IPipelineState* state) override; virtual SLANG_NO_THROW void SLANG_MCALL draw(UInt vertexCount, UInt startVertex) override; virtual SLANG_NO_THROW void SLANG_MCALL drawIndexed(UInt indexCount, UInt startIndex, UInt baseVertex) override; @@ -203,18 +203,26 @@ protected: UINT64 m_fenceValue; ///< The fence value when rendering this Frame is complete }; - class ShaderProgramImpl: public ShaderProgram + class ShaderProgramImpl : public IShaderProgram, public RefObject { - public: + public: + SLANG_REF_OBJECT_IUNKNOWN_ALL + IShaderProgram* getInterface(const Guid& guid) + { + if (guid == GfxGUID::IID_ISlangUnknown || guid == GfxGUID::IID_IShaderProgram) + return static_cast<IShaderProgram*>(this); + return nullptr; + } + public: PipelineType m_pipelineType; List<uint8_t> m_vertexShader; List<uint8_t> m_pixelShader; List<uint8_t> m_computeShader; }; - class BufferResourceImpl: public BufferResource + class BufferResourceImpl: public gfx::BufferResource { - public: + public: typedef BufferResource Parent; enum class BackingStyle @@ -247,7 +255,7 @@ protected: } } - BufferResourceImpl(Resource::Usage initialUsage, const Desc& desc): + BufferResourceImpl(IResource::Usage initialUsage, const Desc& desc): Parent(desc), m_mapFlavor(MapFlavor::HostRead), m_initialUsage(initialUsage) @@ -292,7 +300,7 @@ protected: class TextureResourceImpl: public TextureResource { - public: + public: typedef TextureResource Parent; TextureResourceImpl(const Desc& desc): @@ -303,58 +311,60 @@ protected: D3D12Resource m_resource; }; - class SamplerStateImpl : public SamplerState + class SamplerStateImpl : public ISamplerState, public RefObject { public: + SLANG_REF_OBJECT_IUNKNOWN_ALL + ISamplerState* getInterface(const Guid& guid) + { + if (guid == GfxGUID::IID_ISlangUnknown || guid == GfxGUID::IID_ISamplerState) + return static_cast<ISamplerState*>(this); + return nullptr; + } + public: D3D12_CPU_DESCRIPTOR_HANDLE m_cpuHandle; }; - class ResourceViewImpl : public ResourceView + class ResourceViewImpl : public IResourceView, public RefObject { public: + SLANG_REF_OBJECT_IUNKNOWN_ALL + IResourceView* getInterface(const Guid& guid) + { + if (guid == GfxGUID::IID_ISlangUnknown || guid == GfxGUID::IID_IResourceView) + return static_cast<IResourceView*>(this); + return nullptr; + } + public: RefPtr<Resource> m_resource; D3D12HostVisibleDescriptor m_descriptor; }; - class InputLayoutImpl: public InputLayout - { - public: + class InputLayoutImpl: public IInputLayout, public RefObject + { + public: + SLANG_REF_OBJECT_IUNKNOWN_ALL + IInputLayout* getInterface(const Guid& guid) + { + if (guid == GfxGUID::IID_ISlangUnknown || guid == GfxGUID::IID_IInputLayout) + return static_cast<IInputLayout*>(this); + return nullptr; + } + public: List<D3D12_INPUT_ELEMENT_DESC> m_elements; List<char> m_text; ///< Holds all strings to keep in scope }; -#if 0 - struct BindingDetail - { - int m_srvIndex = -1; - int m_uavIndex = -1; - int m_samplerIndex = -1; - }; - - class BindingStateImpl: public BindingState + class DescriptorSetLayoutImpl : public IDescriptorSetLayout, public RefObject { - public: - typedef BindingState Parent; - - Result init(ID3D12Device* device) + public: + SLANG_REF_OBJECT_IUNKNOWN_ALL + IDescriptorSetLayout* getInterface(const Guid& guid) { - // Set up descriptor heaps - SLANG_RETURN_ON_FAIL(m_viewHeap.init(device, 256, D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV, D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE)); - SLANG_RETURN_ON_FAIL(m_samplerHeap.init(device, 16, D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER, D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE)); - return SLANG_OK; + if (guid == GfxGUID::IID_ISlangUnknown || guid == GfxGUID::IID_IDescriptorSetLayout) + return static_cast<IDescriptorSetLayout*>(this); + return nullptr; } - - /// Ctor - BindingStateImpl(const Desc& desc) : - Parent(desc) - {} - - List<BindingDetail> m_bindingDetails; ///< These match 1-1 to the bindings in the m_desc - }; -#endif - - class DescriptorSetLayoutImpl : public DescriptorSetLayout - { public: // A "descriptor set" at the level of the `Renderer` API // is similar to a D3D12 "descriptor table," but the match @@ -443,25 +453,47 @@ protected: Int m_samplerCount; }; - class PipelineLayoutImpl : public PipelineLayout + class PipelineLayoutImpl : public IPipelineLayout, public RefObject { public: + SLANG_REF_OBJECT_IUNKNOWN_ALL + IPipelineLayout* getInterface(const Guid& guid) + { + if (guid == GfxGUID::IID_ISlangUnknown || guid == GfxGUID::IID_IPipelineLayout) + { + return static_cast<IPipelineLayout*>(this); + } + return nullptr; + } + public: ComPtr<ID3D12RootSignature> m_rootSignature; UInt m_descriptorSetCount; }; - class DescriptorSetImpl : public DescriptorSet + class DescriptorSetImpl : public IDescriptorSet, public RefObject { public: - virtual void setConstantBuffer(UInt range, UInt index, BufferResource* buffer) override; - virtual void setResource(UInt range, UInt index, ResourceView* view) override; - virtual void setSampler(UInt range, UInt index, SamplerState* sampler) override; - virtual void setCombinedTextureSampler( + SLANG_REF_OBJECT_IUNKNOWN_ALL + IDescriptorSet* getInterface(const Guid& guid) + { + if (guid == GfxGUID::IID_ISlangUnknown || guid == GfxGUID::IID_IDescriptorSet) + return static_cast<IDescriptorSet*>(this); + return nullptr; + } + public: + virtual SLANG_NO_THROW void SLANG_MCALL + setConstantBuffer(UInt range, UInt index, IBufferResource* buffer) override; + virtual SLANG_NO_THROW void SLANG_MCALL + setResource(UInt range, UInt index, IResourceView* view) override; + virtual SLANG_NO_THROW void SLANG_MCALL + setSampler(UInt range, UInt index, ISamplerState* sampler) override; + virtual SLANG_NO_THROW void SLANG_MCALL setCombinedTextureSampler( UInt range, UInt index, - ResourceView* textureView, - SamplerState* sampler) override; - virtual void setRootConstants( + IResourceView* textureView, + ISamplerState* sampler) override; + virtual SLANG_NO_THROW void SLANG_MCALL + setRootConstants( UInt range, UInt offset, UInt size, @@ -517,9 +549,17 @@ protected: D3D12DescriptorHeap m_cpuViewHeap; ///< Cbv, Srv, Uav D3D12DescriptorHeap m_cpuSamplerHeap; ///< Heap for samplers - class PipelineStateImpl : public PipelineState + class PipelineStateImpl : public IPipelineState, public RefObject { public: + SLANG_REF_OBJECT_IUNKNOWN_ALL + IPipelineState* getInterface(const Guid& guid) + { + if (guid == GfxGUID::IID_ISlangUnknown || guid == GfxGUID::IID_IPipelineState) + return static_cast<IPipelineState*>(this); + return nullptr; + } + public: PipelineType m_pipelineType; RefPtr<PipelineLayoutImpl> m_pipelineLayout; ComPtr<ID3D12PipelineState> m_pipelineState; @@ -532,30 +572,6 @@ protected: int m_offset; }; -#if 0 - struct BindParameters - { - enum - { - kMaxRanges = 16, - kMaxParameters = 32 - }; - - D3D12_DESCRIPTOR_RANGE& nextRange() { return m_ranges[m_rangeIndex++]; } - D3D12_ROOT_PARAMETER& nextParameter() { return m_parameters[m_paramIndex++]; } - - BindParameters(): - m_rangeIndex(0), - m_paramIndex(0) - {} - - D3D12_DESCRIPTOR_RANGE m_ranges[kMaxRanges]; - int m_rangeIndex; - D3D12_ROOT_PARAMETER m_parameters[kMaxParameters]; - int m_paramIndex; - }; -#endif - struct GraphicsSubmitter : public Submitter { virtual void setRootConstantBufferView(int index, D3D12_GPU_VIRTUAL_ADDRESS gpuBufferLocation) override @@ -748,7 +764,7 @@ protected: bool m_nvapi = false; }; -SlangResult createD3D12Renderer(IRenderer** outRenderer) +SlangResult SLANG_MCALL createD3D12Renderer(IRenderer** outRenderer) { *outRenderer = new D3D12Renderer(); (*outRenderer)->addRef(); @@ -801,7 +817,7 @@ D3D12Renderer::~D3D12Renderer() } } -static void _initSrvDesc(Resource::Type resourceType, const TextureResource::Desc& textureDesc, const D3D12_RESOURCE_DESC& desc, DXGI_FORMAT pixelFormat, D3D12_SHADER_RESOURCE_VIEW_DESC& descOut) +static void _initSrvDesc(IResource::Type resourceType, const ITextureResource::Desc& textureDesc, const D3D12_RESOURCE_DESC& desc, DXGI_FORMAT pixelFormat, D3D12_SHADER_RESOURCE_VIEW_DESC& descOut) { // create SRV descOut = D3D12_SHADER_RESOURCE_VIEW_DESC(); @@ -823,7 +839,7 @@ static void _initSrvDesc(Resource::Type resourceType, const TextureResource::Des descOut.Texture2D.PlaneSlice = 0; descOut.Texture2D.ResourceMinLODClamp = 0.0f; } - else if (resourceType == Resource::Type::TextureCube) + else if (resourceType == IResource::Type::TextureCube) { if (textureDesc.arraySize > 1) { @@ -1384,7 +1400,7 @@ Result D3D12Renderer::initialize(const Desc& desc, void* inWindowHandle) const int numCombinations = combiner.getNumCombinations(); for (int i = 0; i < numCombinations; ++i) { - if (SLANG_SUCCEEDED(_createDevice(combiner.getCombination(i), desc.adapter.getUnownedSlice(), featureLevel, m_deviceInfo))) + if (SLANG_SUCCEEDED(_createDevice(combiner.getCombination(i), UnownedStringSlice(desc.adapter), featureLevel, m_deviceInfo))) { break; } @@ -1779,7 +1795,7 @@ void D3D12Renderer::presentFrame() TextureResource::Desc D3D12Renderer::getSwapChainTextureDesc() { TextureResource::Desc desc; - desc.init2D(Resource::Type::Texture2D, Format::Unknown, m_desc.width, m_desc.height, 1); + desc.init2D(IResource::Type::Texture2D, Format::Unknown, m_desc.width, m_desc.height, 1); return desc; } @@ -1789,9 +1805,9 @@ SlangResult D3D12Renderer::captureScreenSurface(Surface& surfaceOut) return captureTextureToSurface(*m_renderTargets[m_renderTargetIndex], surfaceOut); } -static D3D12_RESOURCE_STATES _calcResourceState(Resource::Usage usage) +static D3D12_RESOURCE_STATES _calcResourceState(IResource::Usage usage) { - typedef Resource::Usage Usage; + typedef IResource::Usage Usage; switch (usage) { case Usage::VertexBuffer: return D3D12_RESOURCE_STATE_VERTEX_AND_CONSTANT_BUFFER; @@ -1809,9 +1825,9 @@ static D3D12_RESOURCE_STATES _calcResourceState(Resource::Usage usage) } } -static D3D12_RESOURCE_FLAGS _calcResourceFlag(Resource::BindFlag::Enum bindFlag) +static D3D12_RESOURCE_FLAGS _calcResourceFlag(IResource::BindFlag::Enum bindFlag) { - typedef Resource::BindFlag BindFlag; + typedef IResource::BindFlag BindFlag; switch (bindFlag) { case BindFlag::RenderTarget: return D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET; @@ -1821,36 +1837,36 @@ static D3D12_RESOURCE_FLAGS _calcResourceFlag(Resource::BindFlag::Enum bindFlag) } } -static D3D12_RESOURCE_FLAGS _calcResourceBindFlags(Resource::Usage initialUsage, int bindFlags) +static D3D12_RESOURCE_FLAGS _calcResourceBindFlags(IResource::Usage initialUsage, int bindFlags) { int dstFlags = 0; while (bindFlags) { int lsb = bindFlags & -bindFlags; - dstFlags |= _calcResourceFlag(Resource::BindFlag::Enum(lsb)); + dstFlags |= _calcResourceFlag(IResource::BindFlag::Enum(lsb)); bindFlags &= ~lsb; } return D3D12_RESOURCE_FLAGS(dstFlags); } -static D3D12_RESOURCE_DIMENSION _calcResourceDimension(Resource::Type type) +static D3D12_RESOURCE_DIMENSION _calcResourceDimension(IResource::Type type) { switch (type) { - case Resource::Type::Buffer: return D3D12_RESOURCE_DIMENSION_BUFFER; - case Resource::Type::Texture1D: return D3D12_RESOURCE_DIMENSION_TEXTURE1D; - case Resource::Type::TextureCube: - case Resource::Type::Texture2D: + case IResource::Type::Buffer: return D3D12_RESOURCE_DIMENSION_BUFFER; + case IResource::Type::Texture1D: return D3D12_RESOURCE_DIMENSION_TEXTURE1D; + case IResource::Type::TextureCube: + case IResource::Type::Texture2D: { return D3D12_RESOURCE_DIMENSION_TEXTURE2D; } - case Resource::Type::Texture3D: return D3D12_RESOURCE_DIMENSION_TEXTURE3D; + case IResource::Type::Texture3D: return D3D12_RESOURCE_DIMENSION_TEXTURE3D; default: return D3D12_RESOURCE_DIMENSION_UNKNOWN; } } -Result D3D12Renderer::createTextureResource(Resource::Usage initialUsage, const TextureResource::Desc& descIn, const TextureResource::Data* initData, TextureResource** outResource) +Result D3D12Renderer::createTextureResource(IResource::Usage initialUsage, const ITextureResource::Desc& descIn, const ITextureResource::Data* initData, ITextureResource** outResource) { // Description of uploading on Dx12 // https://msdn.microsoft.com/en-us/library/windows/desktop/dn899215%28v=vs.85%29.aspx @@ -2035,7 +2051,7 @@ Result D3D12Renderer::createTextureResource(Resource::Usage initialUsage, const return SLANG_OK; } -Result D3D12Renderer::createBufferResource(Resource::Usage initialUsage, const BufferResource::Desc& descIn, const void* initData, BufferResource** outResource) +Result D3D12Renderer::createBufferResource(IResource::Usage initialUsage, const IBufferResource::Desc& descIn, const void* initData, IBufferResource** outResource) { typedef BufferResourceImpl::BackingStyle Style; @@ -2165,7 +2181,7 @@ static D3D12_COMPARISON_FUNC translateComparisonFunc(ComparisonFunc func) } } -Result D3D12Renderer::createSamplerState(SamplerState::Desc const& desc, SamplerState** outSampler) +Result D3D12Renderer::createSamplerState(ISamplerState::Desc const& desc, ISamplerState** outSampler) { D3D12_FILTER_REDUCTION_TYPE dxReduction = translateFilterReduction(desc.reductionOp); D3D12_FILTER dxFilter; @@ -2222,7 +2238,7 @@ Result D3D12Renderer::createSamplerState(SamplerState::Desc const& desc, Sampler return SLANG_OK; } -Result D3D12Renderer::createTextureView(TextureResource* texture, ResourceView::Desc const& desc, ResourceView** outView) +Result D3D12Renderer::createTextureView(ITextureResource* texture, IResourceView::Desc const& desc, IResourceView** outView) { auto resourceImpl = (TextureResourceImpl*) texture; @@ -2234,21 +2250,21 @@ Result D3D12Renderer::createTextureView(TextureResource* texture, ResourceView:: default: return SLANG_FAIL; - case ResourceView::Type::RenderTarget: + case IResourceView::Type::RenderTarget: { SLANG_RETURN_ON_FAIL(m_rtvAllocator.allocate(&viewImpl->m_descriptor)); m_device->CreateRenderTargetView(resourceImpl->m_resource, nullptr, viewImpl->m_descriptor.cpuHandle); } break; - case ResourceView::Type::DepthStencil: + case IResourceView::Type::DepthStencil: { SLANG_RETURN_ON_FAIL(m_dsvAllocator.allocate(&viewImpl->m_descriptor)); m_device->CreateDepthStencilView(resourceImpl->m_resource, nullptr, viewImpl->m_descriptor.cpuHandle); } break; - case ResourceView::Type::UnorderedAccess: + case IResourceView::Type::UnorderedAccess: { // TODO: need to support the separate "counter resource" for the case // of append/consume buffers with attached counters. @@ -2258,7 +2274,7 @@ Result D3D12Renderer::createTextureView(TextureResource* texture, ResourceView:: } break; - case ResourceView::Type::ShaderResource: + case IResourceView::Type::ShaderResource: { SLANG_RETURN_ON_FAIL(m_viewAllocator.allocate(&viewImpl->m_descriptor)); @@ -2268,7 +2284,7 @@ Result D3D12Renderer::createTextureView(TextureResource* texture, ResourceView:: const DXGI_FORMAT pixelFormat = resourceDesc.Format; D3D12_SHADER_RESOURCE_VIEW_DESC srvDesc; - _initSrvDesc(resourceImpl->getType(), resourceImpl->getDesc(), resourceDesc, pixelFormat, srvDesc); + _initSrvDesc(resourceImpl->getType(), *resourceImpl->getDesc(), resourceDesc, pixelFormat, srvDesc); m_device->CreateShaderResourceView(resourceImpl->m_resource, &srvDesc, viewImpl->m_descriptor.cpuHandle); } @@ -2279,10 +2295,10 @@ Result D3D12Renderer::createTextureView(TextureResource* texture, ResourceView:: return SLANG_OK; } -Result D3D12Renderer::createBufferView(BufferResource* buffer, ResourceView::Desc const& desc, ResourceView** outView) +Result D3D12Renderer::createBufferView(IBufferResource* buffer, IResourceView::Desc const& desc, IResourceView** outView) { auto resourceImpl = (BufferResourceImpl*) buffer; - auto resourceDesc = resourceImpl->getDesc(); + auto resourceDesc = *resourceImpl->getDesc(); RefPtr<ResourceViewImpl> viewImpl = new ResourceViewImpl(); viewImpl->m_resource = resourceImpl; @@ -2292,7 +2308,7 @@ Result D3D12Renderer::createBufferView(BufferResource* buffer, ResourceView::Des default: return SLANG_FAIL; - case ResourceView::Type::UnorderedAccess: + case IResourceView::Type::UnorderedAccess: { D3D12_UNORDERED_ACCESS_VIEW_DESC uavDesc = {}; uavDesc.ViewDimension = D3D12_UAV_DIMENSION_BUFFER; @@ -2312,7 +2328,7 @@ Result D3D12Renderer::createBufferView(BufferResource* buffer, ResourceView::Des } else { - uavDesc.Buffer.NumElements = UINT(resourceDesc.sizeInBytes / RendererUtil::getFormatSize(desc.format)); + uavDesc.Buffer.NumElements = UINT(resourceDesc.sizeInBytes / gfxGetFormatSize(desc.format)); } @@ -2324,7 +2340,7 @@ Result D3D12Renderer::createBufferView(BufferResource* buffer, ResourceView::Des } break; - case ResourceView::Type::ShaderResource: + case IResourceView::Type::ShaderResource: { D3D12_SHADER_RESOURCE_VIEW_DESC srvDesc = {}; srvDesc.ViewDimension = D3D12_SRV_DIMENSION_BUFFER; @@ -2345,7 +2361,7 @@ Result D3D12Renderer::createBufferView(BufferResource* buffer, ResourceView::Des } else { - srvDesc.Buffer.NumElements = UINT(resourceDesc.sizeInBytes / RendererUtil::getFormatSize(desc.format)); + srvDesc.Buffer.NumElements = UINT(resourceDesc.sizeInBytes / gfxGetFormatSize(desc.format)); } SLANG_RETURN_ON_FAIL(m_viewAllocator.allocate(&viewImpl->m_descriptor)); @@ -2358,7 +2374,7 @@ Result D3D12Renderer::createBufferView(BufferResource* buffer, ResourceView::Des return SLANG_OK; } -Result D3D12Renderer::createInputLayout(const InputElementDesc* inputElements, UInt inputElementCount, InputLayout** outLayout) +Result D3D12Renderer::createInputLayout(const InputElementDesc* inputElements, UInt inputElementCount, IInputLayout** outLayout) { RefPtr<InputLayoutImpl> layout(new InputLayoutImpl); @@ -2405,14 +2421,14 @@ Result D3D12Renderer::createInputLayout(const InputElementDesc* inputElements, U return SLANG_OK; } -void* D3D12Renderer::map(BufferResource* bufferIn, MapFlavor flavor) +void* D3D12Renderer::map(IBufferResource* bufferIn, MapFlavor flavor) { typedef BufferResourceImpl::BackingStyle Style; BufferResourceImpl* buffer = static_cast<BufferResourceImpl*>(bufferIn); buffer->m_mapFlavor = flavor; - const size_t bufferSize = buffer->getDesc().sizeInBytes; + const size_t bufferSize = buffer->getDesc()->sizeInBytes; switch (buffer->m_backingStyle) { @@ -2503,7 +2519,7 @@ void* D3D12Renderer::map(BufferResource* bufferIn, MapFlavor flavor) return nullptr; } -void D3D12Renderer::unmap(BufferResource* bufferIn) +void D3D12Renderer::unmap(IBufferResource* bufferIn) { typedef BufferResourceImpl::BackingStyle Style; BufferResourceImpl* buffer = static_cast<BufferResourceImpl*>(bufferIn); @@ -2537,7 +2553,7 @@ void D3D12Renderer::unmap(BufferResource* bufferIn) buffer->m_resource.transition(D3D12_RESOURCE_STATE_COPY_DEST, submitter); } - m_commandList->CopyBufferRegion(resource, 0, uploadResource, 0, buffer->getDesc().sizeInBytes); + m_commandList->CopyBufferRegion(resource, 0, uploadResource, 0, buffer->getDesc()->sizeInBytes); { D3D12BarrierSubmitter submitter(m_commandList); @@ -2578,7 +2594,7 @@ void D3D12Renderer::setPrimitiveTopology(PrimitiveTopology topology) } } -void D3D12Renderer::setVertexBuffers(UInt startSlot, UInt slotCount, BufferResource*const* buffers, const UInt* strides, const UInt* offsets) +void D3D12Renderer::setVertexBuffers(UInt startSlot, UInt slotCount, IBufferResource*const* buffers, const UInt* strides, const UInt* offsets) { { const Index num = startSlot + slotCount; @@ -2593,7 +2609,7 @@ void D3D12Renderer::setVertexBuffers(UInt startSlot, UInt slotCount, BufferResou BufferResourceImpl* buffer = static_cast<BufferResourceImpl*>(buffers[i]); if (buffer) { - assert(buffer->m_initialUsage == Resource::Usage::VertexBuffer); + assert(buffer->m_initialUsage == IResource::Usage::VertexBuffer); } BoundVertexBuffer& boundBuffer = m_boundVertexBuffers[startSlot + i]; @@ -2603,14 +2619,14 @@ void D3D12Renderer::setVertexBuffers(UInt startSlot, UInt slotCount, BufferResou } } -void D3D12Renderer::setIndexBuffer(BufferResource* buffer, Format indexFormat, UInt offset) +void D3D12Renderer::setIndexBuffer(IBufferResource* buffer, Format indexFormat, UInt offset) { m_boundIndexBuffer = (BufferResourceImpl*) buffer; m_boundIndexFormat = D3DUtil::getMapFormat(indexFormat); m_boundIndexOffset = UINT(offset); } -void D3D12Renderer::setDepthStencilTarget(ResourceView* depthStencilView) +void D3D12Renderer::setDepthStencilTarget(IResourceView* depthStencilView) { } @@ -2656,7 +2672,7 @@ void D3D12Renderer::setScissorRects(UInt count, ScissorRect const* rects) m_commandList->RSSetScissorRects(UINT(count), dxRects); } -void D3D12Renderer::setPipelineState(PipelineType pipelineType, PipelineState* state) +void D3D12Renderer::setPipelineState(PipelineType pipelineType, IPipelineState* state) { m_currentPipelineState = (PipelineStateImpl*)state; } @@ -2693,7 +2709,7 @@ void D3D12Renderer::draw(UInt vertexCount, UInt startVertex) D3D12_VERTEX_BUFFER_VIEW& vertexView = vertexViews[numVertexViews++]; vertexView.BufferLocation = buffer->m_resource.getResource()->GetGPUVirtualAddress() + boundVertexBuffer.m_offset; - vertexView.SizeInBytes = UINT(buffer->getDesc().sizeInBytes - boundVertexBuffer.m_offset); + vertexView.SizeInBytes = UINT(buffer->getDesc()->sizeInBytes - boundVertexBuffer.m_offset); vertexView.StrideInBytes = UINT(boundVertexBuffer.m_stride); } } @@ -2706,7 +2722,7 @@ void D3D12Renderer::draw(UInt vertexCount, UInt startVertex) D3D12_INDEX_BUFFER_VIEW indexBufferView; indexBufferView.BufferLocation = m_boundIndexBuffer->m_resource.getResource()->GetGPUVirtualAddress() + m_boundIndexOffset; - indexBufferView.SizeInBytes = UINT(m_boundIndexBuffer->getDesc().sizeInBytes - m_boundIndexOffset); + indexBufferView.SizeInBytes = UINT(m_boundIndexBuffer->getDesc()->sizeInBytes - m_boundIndexOffset); indexBufferView.Format = m_boundIndexFormat; commandList->IASetIndexBuffer(&indexBufferView); @@ -2733,7 +2749,7 @@ void D3D12Renderer::dispatchCompute(int x, int y, int z) commandList->Dispatch(x, y, z); } -void D3D12Renderer::DescriptorSetImpl::setConstantBuffer(UInt range, UInt index, BufferResource* buffer) +void D3D12Renderer::DescriptorSetImpl::setConstantBuffer(UInt range, UInt index, IBufferResource* buffer) { auto dxDevice = m_renderer->m_device; @@ -2741,7 +2757,7 @@ void D3D12Renderer::DescriptorSetImpl::setConstantBuffer(UInt range, UInt index, auto resourceDesc = resourceImpl->getDesc(); // Constant buffer view size must be a multiple of 256 bytes, so we round it up here. - const size_t alignedSizeInBytes = D3DUtil::calcAligned(resourceDesc.sizeInBytes, 256); + const size_t alignedSizeInBytes = D3DUtil::calcAligned(resourceDesc->sizeInBytes, 256); D3D12_CONSTANT_BUFFER_VIEW_DESC cbvDesc = {}; cbvDesc.BufferLocation = resourceImpl->m_resource.getResource()->GetGPUVirtualAddress(); @@ -2771,7 +2787,7 @@ void D3D12Renderer::DescriptorSetImpl::setConstantBuffer(UInt range, UInt index, m_resourceHeap->getCpuHandle(int(descriptorIndex))); } -void D3D12Renderer::DescriptorSetImpl::setResource(UInt range, UInt index, ResourceView* view) +void D3D12Renderer::DescriptorSetImpl::setResource(UInt range, UInt index, IResourceView* view) { auto dxDevice = m_renderer->m_device; @@ -2792,7 +2808,7 @@ void D3D12Renderer::DescriptorSetImpl::setResource(UInt range, UInt index, Resou D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV); } -void D3D12Renderer::DescriptorSetImpl::setSampler(UInt range, UInt index, SamplerState* sampler) +void D3D12Renderer::DescriptorSetImpl::setSampler(UInt range, UInt index, ISamplerState* sampler) { auto dxDevice = m_renderer->m_device; @@ -2826,8 +2842,8 @@ void D3D12Renderer::DescriptorSetImpl::setSampler(UInt range, UInt index, Sample void D3D12Renderer::DescriptorSetImpl::setCombinedTextureSampler( UInt range, UInt index, - ResourceView* textureView, - SamplerState* sampler) + IResourceView* textureView, + ISamplerState* sampler) { auto dxDevice = m_renderer->m_device; @@ -2896,7 +2912,7 @@ void D3D12Renderer::DescriptorSetImpl::setRootConstants( memcpy((char*)m_rootConstantData.getBuffer() + rootConstantRangeInfo.offset + offset, data, size); } -void D3D12Renderer::setDescriptorSet(PipelineType pipelineType, PipelineLayout* layout, UInt index, DescriptorSet* descriptorSet) +void D3D12Renderer::setDescriptorSet(PipelineType pipelineType, IPipelineLayout* layout, UInt index, IDescriptorSet* descriptorSet) { // In D3D12, unlike Vulkan, binding a root signature invalidates *all* descriptor table // bindings (rather than preserving those that are part of the longest common prefix @@ -2912,7 +2928,7 @@ void D3D12Renderer::setDescriptorSet(PipelineType pipelineType, PipelineLayout* m_boundDescriptorSets[int(pipelineType)][index] = descriptorSetImpl; } -Result D3D12Renderer::createProgram(const ShaderProgram::Desc& desc, ShaderProgram** outProgram) +Result D3D12Renderer::createProgram(const IShaderProgram::Desc& desc, IShaderProgram** outProgram) { RefPtr<ShaderProgramImpl> program(new ShaderProgramImpl()); program->m_pipelineType = desc.pipelineType; @@ -2935,7 +2951,7 @@ Result D3D12Renderer::createProgram(const ShaderProgram::Desc& desc, ShaderProgr return SLANG_OK; } -Result D3D12Renderer::createDescriptorSetLayout(const DescriptorSetLayout::Desc& desc, DescriptorSetLayout** outLayout) +Result D3D12Renderer::createDescriptorSetLayout(const IDescriptorSetLayout::Desc& desc, IDescriptorSetLayout** outLayout) { Int rangeCount = desc.slotRangeCount; @@ -3367,7 +3383,7 @@ Result D3D12Renderer::createDescriptorSetLayout(const DescriptorSetLayout::Desc& return SLANG_OK; } -Result D3D12Renderer::createPipelineLayout(const PipelineLayout::Desc& desc, PipelineLayout** outLayout) +Result D3D12Renderer::createPipelineLayout(const IPipelineLayout::Desc& desc, IPipelineLayout** outLayout) { static const UInt kMaxRanges = 16; static const UInt kMaxRootParameters = 32; @@ -3527,7 +3543,7 @@ Result D3D12Renderer::createPipelineLayout(const PipelineLayout::Desc& desc, Pip return SLANG_OK; } -Result D3D12Renderer::createDescriptorSet(DescriptorSetLayout* layout, DescriptorSet** outDescriptorSet) +Result D3D12Renderer::createDescriptorSet(IDescriptorSetLayout* layout, IDescriptorSet** outDescriptorSet) { auto layoutImpl = (DescriptorSetLayoutImpl*) layout; @@ -3565,7 +3581,7 @@ Result D3D12Renderer::createDescriptorSet(DescriptorSetLayout* layout, Descripto return SLANG_OK; } -Result D3D12Renderer::createGraphicsPipelineState(const GraphicsPipelineStateDesc& inDesc, PipelineState** outState) +Result D3D12Renderer::createGraphicsPipelineState(const GraphicsPipelineStateDesc& inDesc, IPipelineState** outState) { GraphicsPipelineStateDesc desc = inDesc; preparePipelineDesc(desc); @@ -3666,7 +3682,7 @@ Result D3D12Renderer::createGraphicsPipelineState(const GraphicsPipelineStateDes return SLANG_OK; } -Result D3D12Renderer::createComputePipelineState(const ComputePipelineStateDesc& inDesc, PipelineState** outState) +Result D3D12Renderer::createComputePipelineState(const ComputePipelineStateDesc& inDesc, IPipelineState** outState) { ComputePipelineStateDesc desc = inDesc; preparePipelineDesc(desc); diff --git a/tools/gfx/d3d12/render-d3d12.h b/tools/gfx/d3d12/render-d3d12.h index cdbbc3996..bc28e276b 100644 --- a/tools/gfx/d3d12/render-d3d12.h +++ b/tools/gfx/d3d12/render-d3d12.h @@ -2,11 +2,12 @@ #pragma once #include <cstdint> +#include "slang.h" namespace gfx { class IRenderer; -int32_t createD3D12Renderer(IRenderer** outRenderer); +SlangResult SLANG_MCALL createD3D12Renderer(IRenderer** outRenderer); } // gfx diff --git a/tools/gfx/open-gl/render-gl.cpp b/tools/gfx/open-gl/render-gl.cpp index 4874c4c69..826192e8d 100644 --- a/tools/gfx/open-gl/render-gl.cpp +++ b/tools/gfx/open-gl/render-gl.cpp @@ -4,7 +4,7 @@ #include "../nvapi/nvapi-util.h" //WORKING:#include "options.h" -#include "../render.h" +#include "../renderer-shared.h" #include "../render-graphics-common.h" #include <stdio.h> @@ -83,82 +83,78 @@ public: // Renderer implementation virtual SLANG_NO_THROW SlangResult SLANG_MCALL initialize(const Desc& desc, void* inWindowHandle) override; - virtual SLANG_NO_THROW const List<String>& SLANG_MCALL getFeatures() override - { - return m_features; - } virtual SLANG_NO_THROW void SLANG_MCALL setClearColor(const float color[4]) override; virtual SLANG_NO_THROW void SLANG_MCALL clearFrame() override; virtual SLANG_NO_THROW void SLANG_MCALL presentFrame() override; - virtual SLANG_NO_THROW TextureResource::Desc SLANG_MCALL getSwapChainTextureDesc() override; + virtual SLANG_NO_THROW ITextureResource::Desc SLANG_MCALL getSwapChainTextureDesc() override; virtual SLANG_NO_THROW Result SLANG_MCALL createTextureResource( - Resource::Usage initialUsage, - const TextureResource::Desc& desc, - const TextureResource::Data* initData, - TextureResource** outResource) override; + IResource::Usage initialUsage, + const ITextureResource::Desc& desc, + const ITextureResource::Data* initData, + ITextureResource** outResource) override; virtual SLANG_NO_THROW Result SLANG_MCALL createBufferResource( - Resource::Usage initialUsage, - const BufferResource::Desc& desc, + IResource::Usage initialUsage, + const IBufferResource::Desc& desc, const void* initData, - BufferResource** outResource) override; + IBufferResource** outResource) override; virtual SLANG_NO_THROW Result SLANG_MCALL - createSamplerState(SamplerState::Desc const& desc, SamplerState** outSampler) override; + createSamplerState(ISamplerState::Desc const& desc, ISamplerState** outSampler) override; virtual SLANG_NO_THROW Result SLANG_MCALL createTextureView( - TextureResource* texture, ResourceView::Desc const& desc, ResourceView** outView) override; + ITextureResource* texture, IResourceView::Desc const& desc, IResourceView** outView) override; virtual SLANG_NO_THROW Result SLANG_MCALL createBufferView( - BufferResource* buffer, ResourceView::Desc const& desc, ResourceView** outView) override; + IBufferResource* buffer, IResourceView::Desc const& desc, IResourceView** outView) override; virtual SLANG_NO_THROW Result SLANG_MCALL createInputLayout( const InputElementDesc* inputElements, UInt inputElementCount, - InputLayout** outLayout) override; + IInputLayout** outLayout) override; virtual SLANG_NO_THROW Result SLANG_MCALL createDescriptorSetLayout( - const DescriptorSetLayout::Desc& desc, DescriptorSetLayout** outLayout) override; + const IDescriptorSetLayout::Desc& desc, IDescriptorSetLayout** outLayout) override; virtual SLANG_NO_THROW Result SLANG_MCALL - createPipelineLayout(const PipelineLayout::Desc& desc, PipelineLayout** outLayout) override; + createPipelineLayout(const IPipelineLayout::Desc& desc, IPipelineLayout** outLayout) override; virtual SLANG_NO_THROW Result SLANG_MCALL - createDescriptorSet(DescriptorSetLayout* layout, DescriptorSet** outDescriptorSet) override; + createDescriptorSet(IDescriptorSetLayout* layout, IDescriptorSet** outDescriptorSet) override; virtual SLANG_NO_THROW Result SLANG_MCALL - createProgram(const ShaderProgram::Desc& desc, ShaderProgram** outProgram) override; + createProgram(const IShaderProgram::Desc& desc, IShaderProgram** outProgram) override; virtual SLANG_NO_THROW Result SLANG_MCALL createGraphicsPipelineState( - const GraphicsPipelineStateDesc& desc, PipelineState** outState) override; + const GraphicsPipelineStateDesc& desc, IPipelineState** outState) override; virtual SLANG_NO_THROW Result SLANG_MCALL createComputePipelineState( - const ComputePipelineStateDesc& desc, PipelineState** outState) override; + const ComputePipelineStateDesc& desc, IPipelineState** outState) override; virtual SLANG_NO_THROW SlangResult SLANG_MCALL captureScreenSurface(Surface& surfaceOut) override; - virtual SLANG_NO_THROW void* SLANG_MCALL map(BufferResource* buffer, MapFlavor flavor) override; - virtual SLANG_NO_THROW void SLANG_MCALL unmap(BufferResource* buffer) override; + virtual SLANG_NO_THROW void* SLANG_MCALL map(IBufferResource* buffer, MapFlavor flavor) override; + virtual SLANG_NO_THROW void SLANG_MCALL unmap(IBufferResource* buffer) override; virtual SLANG_NO_THROW void SLANG_MCALL setPrimitiveTopology(PrimitiveTopology topology) override; virtual SLANG_NO_THROW void SLANG_MCALL setDescriptorSet( PipelineType pipelineType, - PipelineLayout* layout, + IPipelineLayout* layout, UInt index, - DescriptorSet* descriptorSet) override; + IDescriptorSet* descriptorSet) override; virtual SLANG_NO_THROW void SLANG_MCALL setVertexBuffers( UInt startSlot, UInt slotCount, - BufferResource* const* buffers, + IBufferResource* const* buffers, const UInt* strides, const UInt* offsets) override; virtual SLANG_NO_THROW void SLANG_MCALL - setIndexBuffer(BufferResource* buffer, Format indexFormat, UInt offset) override; + setIndexBuffer(IBufferResource* buffer, Format indexFormat, UInt offset) override; virtual SLANG_NO_THROW void SLANG_MCALL - setDepthStencilTarget(ResourceView* depthStencilView) override; + setDepthStencilTarget(IResourceView* depthStencilView) override; virtual SLANG_NO_THROW void SLANG_MCALL setViewports(UInt count, Viewport const* viewports) override; virtual SLANG_NO_THROW void SLANG_MCALL setScissorRects(UInt count, ScissorRect const* rects) override; virtual SLANG_NO_THROW void SLANG_MCALL - setPipelineState(PipelineType pipelineType, PipelineState* state) override; + setPipelineState(PipelineType pipelineType, IPipelineState* state) override; virtual SLANG_NO_THROW void SLANG_MCALL draw(UInt vertexCount, UInt startVertex) override; virtual void SLANG_MCALL drawIndexed(UInt indexCount, UInt startIndex, UInt baseVertex) override; @@ -193,8 +189,16 @@ public: GLsizei offset; }; - class InputLayoutImpl: public InputLayout - { + class InputLayoutImpl: public IInputLayout, public RefObject + { + public: + SLANG_REF_OBJECT_IUNKNOWN_ALL + IInputLayout* getInterface(const Guid& guid) + { + if (guid == GfxGUID::IID_ISlangUnknown || guid == GfxGUID::IID_IInputLayout) + return static_cast<IInputLayout*>(this); + return nullptr; + } public: VertexAttributeDesc m_attributes[kMaxVertexStreams]; UInt m_attributeCount = 0; @@ -254,14 +258,30 @@ public: GLuint m_handle; }; - class SamplerStateImpl : public SamplerState + class SamplerStateImpl : public ISamplerState, public RefObject { public: + SLANG_REF_OBJECT_IUNKNOWN_ALL + ISamplerState* getInterface(const Guid& guid) + { + if (guid == GfxGUID::IID_ISlangUnknown || guid == GfxGUID::IID_ISamplerState) + return static_cast<ISamplerState*>(this); + return nullptr; + } + public: GLuint m_samplerID; }; - class ResourceViewImpl : public ResourceView + class ResourceViewImpl : public IResourceView, public RefObject { + public: + SLANG_REF_OBJECT_IUNKNOWN_ALL + IResourceView* getInterface(const Guid& guid) + { + if (guid == GfxGUID::IID_ISlangUnknown || guid == GfxGUID::IID_IResourceView) + return static_cast<IResourceView*>(this); + return nullptr; + } }; class TextureViewImpl : public ResourceViewImpl @@ -286,9 +306,17 @@ public: CountOf, }; - class DescriptorSetLayoutImpl : public DescriptorSetLayout + class DescriptorSetLayoutImpl : public IDescriptorSetLayout, public RefObject { public: + SLANG_REF_OBJECT_IUNKNOWN_ALL + IDescriptorSetLayout* getInterface(const Guid& guid) + { + if (guid == GfxGUID::IID_ISlangUnknown || guid == GfxGUID::IID_IDescriptorSetLayout) + return static_cast<IDescriptorSetLayout*>(this); + return nullptr; + } + public: struct RangeInfo { GLDescriptorSlotType type; @@ -298,9 +326,19 @@ public: Int m_counts[int(GLDescriptorSlotType::CountOf)]; }; - class PipelineLayoutImpl : public PipelineLayout + class PipelineLayoutImpl : public IPipelineLayout, public RefObject { public: + SLANG_REF_OBJECT_IUNKNOWN_ALL + IPipelineLayout* getInterface(const Guid& guid) + { + if (guid == GfxGUID::IID_ISlangUnknown || guid == GfxGUID::IID_IPipelineLayout) + { + return static_cast<IPipelineLayout*>(this); + } + return nullptr; + } + public: struct DescriptorSetInfo { RefPtr<DescriptorSetLayoutImpl> layout; @@ -310,18 +348,30 @@ public: List<DescriptorSetInfo> m_sets; }; - class DescriptorSetImpl : public DescriptorSet + class DescriptorSetImpl : public IDescriptorSet, public RefObject { public: - virtual void setConstantBuffer(UInt range, UInt index, BufferResource* buffer) override; - virtual void setResource(UInt range, UInt index, ResourceView* view) override; - virtual void setSampler(UInt range, UInt index, SamplerState* sampler) override; - virtual void setCombinedTextureSampler( + SLANG_REF_OBJECT_IUNKNOWN_ALL + IDescriptorSet* getInterface(const Guid& guid) + { + if (guid == GfxGUID::IID_ISlangUnknown || guid == GfxGUID::IID_IDescriptorSet) + return static_cast<IDescriptorSet*>(this); + return nullptr; + } + public: + virtual SLANG_NO_THROW void SLANG_MCALL + setConstantBuffer(UInt range, UInt index, IBufferResource* buffer) override; + virtual SLANG_NO_THROW void SLANG_MCALL + setResource(UInt range, UInt index, IResourceView* view) override; + virtual SLANG_NO_THROW void SLANG_MCALL + setSampler(UInt range, UInt index, ISamplerState* sampler) override; + virtual SLANG_NO_THROW void SLANG_MCALL setCombinedTextureSampler( UInt range, UInt index, - ResourceView* textureView, - SamplerState* sampler) override; - virtual void setRootConstants( + IResourceView* textureView, + ISamplerState* sampler) override; + virtual SLANG_NO_THROW void SLANG_MCALL + setRootConstants( UInt range, UInt offset, UInt size, @@ -333,8 +383,16 @@ public: List<RefPtr<SamplerStateImpl>> m_samplers; }; - class ShaderProgramImpl : public ShaderProgram - { + class ShaderProgramImpl : public IShaderProgram, public RefObject + { + public: + SLANG_REF_OBJECT_IUNKNOWN_ALL + IShaderProgram* getInterface(const Guid& guid) + { + if (guid == GfxGUID::IID_ISlangUnknown || guid == GfxGUID::IID_IShaderProgram) + return static_cast<IShaderProgram*>(this); + return nullptr; + } public: ShaderProgramImpl(WeakSink<GLRenderer>* renderer, GLuint id): m_renderer(renderer), @@ -353,9 +411,17 @@ public: RefPtr<WeakSink<GLRenderer> > m_renderer; }; - class PipelineStateImpl : public PipelineState + class PipelineStateImpl : public IPipelineState, public RefObject { public: + SLANG_REF_OBJECT_IUNKNOWN_ALL + IPipelineState* getInterface(const Guid& guid) + { + if (guid == GfxGUID::IID_ISlangUnknown || guid == GfxGUID::IID_IPipelineState) + return static_cast<IPipelineState*>(this); + return nullptr; + } + public: RefPtr<ShaderProgramImpl> m_program; RefPtr<PipelineLayoutImpl> m_pipelineLayout; RefPtr<InputLayoutImpl> m_inputLayout; @@ -438,7 +504,7 @@ public: SLANG_COMPILE_TIME_ASSERT(SLANG_COUNT_OF(s_pixelFormatInfos) == int(GlPixelFormat::CountOf)); } -SlangResult createGLRenderer(IRenderer** outRenderer) +SlangResult SLANG_MCALL createGLRenderer(IRenderer** outRenderer) { *outRenderer = new GLRenderer(); (*outRenderer)->addRef(); @@ -727,7 +793,7 @@ void GLRenderer::destroyBindingEntries(const BindingState::Desc& desc, const Bin // !!!!!!!!!!!!!!!!!!!!!!!!!!!! Renderer interface !!!!!!!!!!!!!!!!!!!!!!!!!! -SlangResult GLRenderer::initialize(const Desc& desc, void* inWindowHandle) +SLANG_NO_THROW Result SLANG_MCALL GLRenderer::initialize(const Desc& desc, void* inWindowHandle) { auto windowHandle = (HWND)inWindowHandle; m_desc = desc; @@ -751,9 +817,9 @@ SlangResult GLRenderer::initialize(const Desc& desc, void* inWindowHandle) auto renderer = glGetString(GL_RENDERER); - if (renderer && desc.adapter.getLength() > 0) + if (renderer && desc.adapter) { - String lowerAdapter = desc.adapter.toLower(); + String lowerAdapter = String(desc.adapter).toLower(); String lowerRenderer = String((const char*)renderer).toLower(); // The adapter is not available @@ -793,30 +859,30 @@ SlangResult GLRenderer::initialize(const Desc& desc, void* inWindowHandle) return SLANG_OK; } -void GLRenderer::setClearColor(const float color[4]) +SLANG_NO_THROW void SLANG_MCALL GLRenderer::setClearColor(const float color[4]) { glClearColor(color[0], color[1], color[2], color[3]); } -void GLRenderer::clearFrame() +SLANG_NO_THROW void SLANG_MCALL GLRenderer::clearFrame() { glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT); } -void GLRenderer::presentFrame() +SLANG_NO_THROW void SLANG_MCALL GLRenderer::presentFrame() { glFlush(); ::SwapBuffers(m_hdc); } -TextureResource::Desc GLRenderer::getSwapChainTextureDesc() +SLANG_NO_THROW TextureResource::Desc SLANG_MCALL GLRenderer::getSwapChainTextureDesc() { TextureResource::Desc desc; - desc.init2D(Resource::Type::Texture2D, Format::Unknown, m_desc.width, m_desc.height, 1); + desc.init2D(IResource::Type::Texture2D, Format::Unknown, m_desc.width, m_desc.height, 1); return desc; } -SlangResult GLRenderer::captureScreenSurface(Surface& surfaceOut) +SLANG_NO_THROW Result SLANG_MCALL GLRenderer::captureScreenSurface(Surface& surfaceOut) { SLANG_RETURN_ON_FAIL(surfaceOut.allocate(m_desc.width, m_desc.height, Format::RGBA_Unorm_UInt8, 1, SurfaceAllocator::getMallocAllocator())); glReadPixels(0, 0, m_desc.width, m_desc.height, GL_RGBA, GL_UNSIGNED_BYTE, surfaceOut.m_data); @@ -824,7 +890,11 @@ SlangResult GLRenderer::captureScreenSurface(Surface& surfaceOut) return SLANG_OK; } -Result GLRenderer::createTextureResource(Resource::Usage initialUsage, const TextureResource::Desc& descIn, const TextureResource::Data* initData, TextureResource** outResource) +SLANG_NO_THROW Result SLANG_MCALL GLRenderer::createTextureResource( + IResource::Usage initialUsage, + const ITextureResource::Desc& descIn, + const ITextureResource::Data* initData, + ITextureResource** outResource) { TextureResource::Desc srcDesc(descIn); srcDesc.setDefaults(initialUsage); @@ -858,7 +928,7 @@ Result GLRenderer::createTextureResource(Resource::Usage initialUsage, const Tex switch (srcDesc.type) { - case Resource::Type::Texture1D: + case IResource::Type::Texture1D: { if (srcDesc.arraySize > 0) { @@ -885,12 +955,12 @@ Result GLRenderer::createTextureResource(Resource::Usage initialUsage, const Tex } break; } - case Resource::Type::TextureCube: - case Resource::Type::Texture2D: + case IResource::Type::TextureCube: + case IResource::Type::Texture2D: { if (srcDesc.arraySize > 0) { - if (srcDesc.type == Resource::Type::TextureCube) + if (srcDesc.type == IResource::Type::TextureCube) { target = GL_TEXTURE_CUBE_MAP_ARRAY; } @@ -912,7 +982,7 @@ Result GLRenderer::createTextureResource(Resource::Usage initialUsage, const Tex } else { - if (srcDesc.type == Resource::Type::TextureCube) + if (srcDesc.type == IResource::Type::TextureCube) { target = GL_TEXTURE_CUBE_MAP; glBindTexture(target, handle); @@ -938,7 +1008,7 @@ Result GLRenderer::createTextureResource(Resource::Usage initialUsage, const Tex } break; } - case Resource::Type::Texture3D: + case IResource::Type::Texture3D: { target = GL_TEXTURE_3D; glBindTexture(target, handle); @@ -967,9 +1037,9 @@ Result GLRenderer::createTextureResource(Resource::Usage initialUsage, const Tex return SLANG_OK; } -static GLenum _calcUsage(Resource::Usage usage) +static GLenum _calcUsage(IResource::Usage usage) { - typedef Resource::Usage Usage; + typedef IResource::Usage Usage; switch (usage) { case Usage::ConstantBuffer: return GL_DYNAMIC_DRAW; @@ -977,9 +1047,9 @@ static GLenum _calcUsage(Resource::Usage usage) } } -static GLenum _calcTarget(Resource::Usage usage) +static GLenum _calcTarget(IResource::Usage usage) { - typedef Resource::Usage Usage; + typedef IResource::Usage Usage; switch (usage) { case Usage::ConstantBuffer: return GL_UNIFORM_BUFFER; @@ -987,7 +1057,11 @@ static GLenum _calcTarget(Resource::Usage usage) } } -Result GLRenderer::createBufferResource(Resource::Usage initialUsage, const BufferResource::Desc& descIn, const void* initData, BufferResource** outResource) +SLANG_NO_THROW Result SLANG_MCALL GLRenderer::createBufferResource( + IResource::Usage initialUsage, + const IBufferResource::Desc& descIn, + const void* initData, + IBufferResource** outResource) { BufferResource::Desc desc(descIn); desc.setDefaults(initialUsage); @@ -1007,7 +1081,8 @@ Result GLRenderer::createBufferResource(Resource::Usage initialUsage, const Buff return SLANG_OK; } -Result GLRenderer::createSamplerState(SamplerState::Desc const& desc, SamplerState** outSampler) +SLANG_NO_THROW Result SLANG_MCALL + GLRenderer::createSamplerState(ISamplerState::Desc const& desc, ISamplerState** outSampler) { GLuint samplerID; glCreateSamplers(1, &samplerID); @@ -1018,7 +1093,8 @@ Result GLRenderer::createSamplerState(SamplerState::Desc const& desc, SamplerSta return SLANG_OK; } -Result GLRenderer::createTextureView(TextureResource* texture, ResourceView::Desc const& desc, ResourceView** outView) +SLANG_NO_THROW Result SLANG_MCALL GLRenderer::createTextureView( + ITextureResource* texture, IResourceView::Desc const& desc, IResourceView** outView) { auto resourceImpl = (TextureResourceImpl*) texture; @@ -1031,7 +1107,8 @@ Result GLRenderer::createTextureView(TextureResource* texture, ResourceView::Des return SLANG_OK; } -Result GLRenderer::createBufferView(BufferResource* buffer, ResourceView::Desc const& desc, ResourceView** outView) +SLANG_NO_THROW Result SLANG_MCALL GLRenderer::createBufferView( + IBufferResource* buffer, IResourceView::Desc const& desc, IResourceView** outView) { auto resourceImpl = (BufferResourceImpl*) buffer; @@ -1044,7 +1121,8 @@ Result GLRenderer::createBufferView(BufferResource* buffer, ResourceView::Desc c return SLANG_OK; } -Result GLRenderer::createInputLayout(const InputElementDesc* inputElements, UInt inputElementCount, InputLayout** outLayout) +SLANG_NO_THROW Result SLANG_MCALL GLRenderer::createInputLayout( + const InputElementDesc* inputElements, UInt inputElementCount, IInputLayout** outLayout) { RefPtr<InputLayoutImpl> inputLayout = new InputLayoutImpl; @@ -1063,7 +1141,7 @@ Result GLRenderer::createInputLayout(const InputElementDesc* inputElements, UInt return SLANG_OK; } -void* GLRenderer::map(BufferResource* bufferIn, MapFlavor flavor) +SLANG_NO_THROW void* SLANG_MCALL GLRenderer::map(IBufferResource* bufferIn, MapFlavor flavor) { BufferResourceImpl* buffer = static_cast<BufferResourceImpl*>(bufferIn); @@ -1086,13 +1164,13 @@ void* GLRenderer::map(BufferResource* bufferIn, MapFlavor flavor) return glMapBuffer(buffer->m_target, access); } -void GLRenderer::unmap(BufferResource* bufferIn) +SLANG_NO_THROW void SLANG_MCALL GLRenderer::unmap(IBufferResource* bufferIn) { BufferResourceImpl* buffer = static_cast<BufferResourceImpl*>(bufferIn); glUnmapBuffer(buffer->m_target); } -void GLRenderer::setPrimitiveTopology(PrimitiveTopology topology) +SLANG_NO_THROW void SLANG_MCALL GLRenderer::setPrimitiveTopology(PrimitiveTopology topology) { GLenum glTopology = 0; switch (topology) @@ -1106,7 +1184,12 @@ void GLRenderer::setPrimitiveTopology(PrimitiveTopology topology) m_boundPrimitiveTopology = glTopology; } -void GLRenderer::setVertexBuffers(UInt startSlot, UInt slotCount, BufferResource*const* buffers, const UInt* strides, const UInt* offsets) +SLANG_NO_THROW void SLANG_MCALL GLRenderer::setVertexBuffers( + UInt startSlot, + UInt slotCount, + IBufferResource* const* buffers, + const UInt* strides, + const UInt* offsets) { for (UInt ii = 0; ii < slotCount; ++ii) { @@ -1121,15 +1204,16 @@ void GLRenderer::setVertexBuffers(UInt startSlot, UInt slotCount, BufferResource } } -void GLRenderer::setIndexBuffer(BufferResource* buffer, Format indexFormat, UInt offset) +SLANG_NO_THROW void SLANG_MCALL + GLRenderer::setIndexBuffer(IBufferResource* buffer, Format indexFormat, UInt offset) { } -void GLRenderer::setDepthStencilTarget(ResourceView* depthStencilView) +SLANG_NO_THROW void SLANG_MCALL GLRenderer::setDepthStencilTarget(IResourceView* depthStencilView) { } -void GLRenderer::setViewports(UInt count, Viewport const* viewports) +SLANG_NO_THROW void SLANG_MCALL GLRenderer::setViewports(UInt count, Viewport const* viewports) { assert(count == 1); auto viewport = viewports[0]; @@ -1141,7 +1225,7 @@ void GLRenderer::setViewports(UInt count, Viewport const* viewports) glDepthRange(viewport.minZ, viewport.maxZ); } -void GLRenderer::setScissorRects(UInt count, ScissorRect const* rects) +SLANG_NO_THROW void SLANG_MCALL GLRenderer::setScissorRects(UInt count, ScissorRect const* rects) { assert(count <= 1); if( count ) @@ -1169,7 +1253,8 @@ void GLRenderer::setScissorRects(UInt count, ScissorRect const* rects) } } -void GLRenderer::setPipelineState(PipelineType pipelineType, PipelineState* state) +SLANG_NO_THROW void SLANG_MCALL + GLRenderer::setPipelineState(PipelineType pipelineType, IPipelineState* state) { auto pipelineStateImpl = (PipelineStateImpl*) state; @@ -1180,24 +1265,26 @@ void GLRenderer::setPipelineState(PipelineType pipelineType, PipelineState* stat glUseProgram(programID); } -void GLRenderer::draw(UInt vertexCount, UInt startVertex = 0) +SLANG_NO_THROW void SLANG_MCALL GLRenderer::draw(UInt vertexCount, UInt startVertex = 0) { flushStateForDraw(); glDrawArrays(m_boundPrimitiveTopology, (GLint)startVertex, (GLsizei)vertexCount); } -void GLRenderer::drawIndexed(UInt indexCount, UInt startIndex, UInt baseVertex) +SLANG_NO_THROW void SLANG_MCALL + GLRenderer::drawIndexed(UInt indexCount, UInt startIndex, UInt baseVertex) { assert(!"unimplemented"); } -void GLRenderer::dispatchCompute(int x, int y, int z) +SLANG_NO_THROW void SLANG_MCALL GLRenderer::dispatchCompute(int x, int y, int z) { glDispatchCompute(x, y, z); } -void GLRenderer::DescriptorSetImpl::setConstantBuffer(UInt range, UInt index, BufferResource* buffer) +SLANG_NO_THROW void SLANG_MCALL GLRenderer::DescriptorSetImpl::setConstantBuffer( + UInt range, UInt index, IBufferResource* buffer) { auto resourceImpl = (BufferResourceImpl*) buffer; @@ -1208,7 +1295,8 @@ void GLRenderer::DescriptorSetImpl::setConstantBuffer(UInt range, UInt index, Bu m_constantBuffers[arrayIndex] = resourceImpl; } -void GLRenderer::DescriptorSetImpl::setResource(UInt range, UInt index, ResourceView* view) +SLANG_NO_THROW void SLANG_MCALL + GLRenderer::DescriptorSetImpl::setResource(UInt range, UInt index, IResourceView* view) { auto viewImpl = (ResourceViewImpl*) view; @@ -1219,16 +1307,17 @@ void GLRenderer::DescriptorSetImpl::setResource(UInt range, UInt index, Resource assert(!"unimplemented"); } -void GLRenderer::DescriptorSetImpl::setSampler(UInt range, UInt index, SamplerState* sampler) +SLANG_NO_THROW void SLANG_MCALL + GLRenderer::DescriptorSetImpl::setSampler(UInt range, UInt index, ISamplerState* sampler) { assert(!"unsupported"); } -void GLRenderer::DescriptorSetImpl::setCombinedTextureSampler( +SLANG_NO_THROW void SLANG_MCALL GLRenderer::DescriptorSetImpl::setCombinedTextureSampler( UInt range, UInt index, - ResourceView* textureView, - SamplerState* sampler) + IResourceView* textureView, + ISamplerState* sampler) { auto viewImpl = (TextureViewImpl*) textureView; auto samplerImpl = (SamplerStateImpl*) sampler; @@ -1241,7 +1330,7 @@ void GLRenderer::DescriptorSetImpl::setCombinedTextureSampler( m_samplers[arrayIndex] = samplerImpl; } -void GLRenderer::DescriptorSetImpl::setRootConstants( +SLANG_NO_THROW void SLANG_MCALL GLRenderer::DescriptorSetImpl::setRootConstants( UInt range, UInt offset, UInt size, @@ -1250,7 +1339,8 @@ void GLRenderer::DescriptorSetImpl::setRootConstants( SLANG_UNEXPECTED("unimplemented: setRootConstants for GlRenderer"); } -void GLRenderer::setDescriptorSet(PipelineType pipelineType, PipelineLayout* layout, UInt index, DescriptorSet* descriptorSet) +SLANG_NO_THROW void SLANG_MCALL GLRenderer::setDescriptorSet( + PipelineType pipelineType, IPipelineLayout* layout, UInt index, IDescriptorSet* descriptorSet) { auto descriptorSetImpl = (DescriptorSetImpl*)descriptorSet; @@ -1259,7 +1349,8 @@ void GLRenderer::setDescriptorSet(PipelineType pipelineType, PipelineLayout* lay m_boundDescriptorSets[index] = descriptorSetImpl; } -Result GLRenderer::createDescriptorSetLayout(const DescriptorSetLayout::Desc& desc, DescriptorSetLayout** outLayout) +SLANG_NO_THROW Result SLANG_MCALL GLRenderer::createDescriptorSetLayout( + const IDescriptorSetLayout::Desc& desc, IDescriptorSetLayout** outLayout) { RefPtr<DescriptorSetLayoutImpl> layoutImpl = new DescriptorSetLayoutImpl(); @@ -1309,7 +1400,8 @@ Result GLRenderer::createDescriptorSetLayout(const DescriptorSetLayout::Desc& de return SLANG_OK; } -Result GLRenderer::createPipelineLayout(const PipelineLayout::Desc& desc, PipelineLayout** outLayout) +SLANG_NO_THROW Result SLANG_MCALL + GLRenderer::createPipelineLayout(const IPipelineLayout::Desc& desc, IPipelineLayout** outLayout) { RefPtr<PipelineLayoutImpl> layoutImpl = new PipelineLayoutImpl(); @@ -1337,7 +1429,8 @@ Result GLRenderer::createPipelineLayout(const PipelineLayout::Desc& desc, Pipeli return SLANG_OK; } -Result GLRenderer::createDescriptorSet(DescriptorSetLayout* layout, DescriptorSet** outDescriptorSet) +SLANG_NO_THROW Result SLANG_MCALL + GLRenderer::createDescriptorSet(IDescriptorSetLayout* layout, IDescriptorSet** outDescriptorSet) { auto layoutImpl = (DescriptorSetLayoutImpl*) layout; @@ -1367,7 +1460,7 @@ Result GLRenderer::createDescriptorSet(DescriptorSetLayout* layout, DescriptorSe return SLANG_OK; } -Result GLRenderer::createProgram(const ShaderProgram::Desc& desc, ShaderProgram** outProgram) +Result GLRenderer::createProgram(const IShaderProgram::Desc& desc, IShaderProgram** outProgram) { auto programID = glCreateProgram(); if(desc.pipelineType == PipelineType::Compute ) @@ -1422,7 +1515,7 @@ Result GLRenderer::createProgram(const ShaderProgram::Desc& desc, ShaderProgram* return SLANG_OK; } -Result GLRenderer::createGraphicsPipelineState(const GraphicsPipelineStateDesc& inDesc, PipelineState** outState) +Result GLRenderer::createGraphicsPipelineState(const GraphicsPipelineStateDesc& inDesc, IPipelineState** outState) { GraphicsPipelineStateDesc desc = inDesc; preparePipelineDesc(desc); @@ -1439,7 +1532,7 @@ Result GLRenderer::createGraphicsPipelineState(const GraphicsPipelineStateDesc& return SLANG_OK; } -Result GLRenderer::createComputePipelineState(const ComputePipelineStateDesc& inDesc, PipelineState** outState) +Result GLRenderer::createComputePipelineState(const ComputePipelineStateDesc& inDesc, IPipelineState** outState) { ComputePipelineStateDesc desc = inDesc; preparePipelineDesc(desc); diff --git a/tools/gfx/open-gl/render-gl.h b/tools/gfx/open-gl/render-gl.h index 04a6eaa9f..79ff2d124 100644 --- a/tools/gfx/open-gl/render-gl.h +++ b/tools/gfx/open-gl/render-gl.h @@ -2,11 +2,12 @@ #pragma once #include <cstdint> +#include "slang.h" namespace gfx { class IRenderer; -int32_t createGLRenderer(IRenderer** outRenderer); +SlangResult SLANG_MCALL createGLRenderer(IRenderer** outRenderer); } // gfx diff --git a/tools/gfx/render-graphics-common.cpp b/tools/gfx/render-graphics-common.cpp index beaa6a55c..811602ffc 100644 --- a/tools/gfx/render-graphics-common.cpp +++ b/tools/gfx/render-graphics-common.cpp @@ -1,11 +1,26 @@ #include "render-graphics-common.h" +#include "core/slang-basic.h" + using namespace Slang; namespace gfx { -static const Slang::Guid IID_ISlangUnknown = SLANG_UUID_ISlangUnknown; -static const Slang::Guid IID_IRenderer = SLANG_UUID_IRenderer; +const Slang::Guid GfxGUID::IID_ISlangUnknown = SLANG_UUID_ISlangUnknown; +const Slang::Guid GfxGUID::IID_IDescriptorSetLayout = SLANG_UUID_IDescriptorSetLayout; +const Slang::Guid GfxGUID::IID_IDescriptorSet = SLANG_UUID_IDescriptorSet; +const Slang::Guid GfxGUID::IID_IShaderProgram = SLANG_UUID_IShaderProgram; +const Slang::Guid GfxGUID::IID_IPipelineLayout = SLANG_UUID_IPipelineLayout; +const Slang::Guid GfxGUID::IID_IInputLayout = SLANG_UUID_IInputLayout; +const Slang::Guid GfxGUID::IID_IPipelineState = SLANG_UUID_IPipelineState; +const Slang::Guid GfxGUID::IID_IResourceView = SLANG_UUID_IResourceView; +const Slang::Guid GfxGUID::IID_ISamplerState = SLANG_UUID_ISamplerState; +const Slang::Guid GfxGUID::IID_IResource = SLANG_UUID_IResource; +const Slang::Guid GfxGUID::IID_IBufferResource = SLANG_UUID_IBufferResource; +const Slang::Guid GfxGUID::IID_ITextureResource = SLANG_UUID_ITextureResource; +const Slang::Guid GfxGUID::IID_IRenderer = SLANG_UUID_IRenderer; +const Slang::Guid GfxGUID::IID_IShaderObjectLayout = SLANG_UUID_IShaderObjectLayout; +const Slang::Guid GfxGUID::IID_IShaderObject = SLANG_UUID_IShaderObject; gfx::StageType translateStage(SlangStage slangStage) { @@ -38,9 +53,17 @@ gfx::StageType translateStage(SlangStage slangStage) } } -class GraphicsCommonShaderObjectLayout : public ShaderObjectLayout +class GraphicsCommonShaderObjectLayout : public IShaderObjectLayout, public RefObject { public: + SLANG_REF_OBJECT_IUNKNOWN_ALL + IShaderObjectLayout* getInterface(const Guid& guid) + { + if (guid == GfxGUID::IID_ISlangUnknown || guid == GfxGUID::IID_IShaderObjectLayout) + return static_cast<IShaderObjectLayout*>(this); + return nullptr; + } +public: struct BindingRangeInfo { slang::BindingType bindingType; @@ -53,7 +76,7 @@ public: struct SubObjectRangeInfo { - RefPtr<GraphicsCommonShaderObjectLayout> layout; + ComPtr<GraphicsCommonShaderObjectLayout> layout; // Index baseIndex; // Index count; Index bindingRangeIndex; @@ -61,7 +84,7 @@ public: struct DescriptorSetInfo : public RefObject { - RefPtr<DescriptorSetLayout> layout; + ComPtr<IDescriptorSetLayout> layout; Slang::Int space = -1; }; @@ -84,7 +107,7 @@ public: struct DescriptorSetBuildInfo : public RefObject { - List<DescriptorSetLayout::SlotRangeDesc> slotRangeDescs; + List<IDescriptorSetLayout::SlotRangeDesc> slotRangeDescs; Index space; }; List<RefPtr<DescriptorSetBuildInfo>> m_descriptorSetBuildInfos; @@ -175,7 +198,7 @@ public: auto slangBindingType = typeLayout->getDescriptorSetDescriptorRangeType(s, r); auto gfxDescriptorType = _mapDescriptorType(slangBindingType); - DescriptorSetLayout::SlotRangeDesc descriptorRangeDesc; + IDescriptorSetLayout::SlotRangeDesc descriptorRangeDesc; descriptorRangeDesc.binding = typeLayout->getDescriptorSetDescriptorRangeIndexOffset(s, r); descriptorRangeDesc.count = @@ -334,8 +357,8 @@ public: SlangResult build(GraphicsCommonShaderObjectLayout** outLayout) { - RefPtr<GraphicsCommonShaderObjectLayout> layout = - new GraphicsCommonShaderObjectLayout(); + auto layout = + ComPtr<GraphicsCommonShaderObjectLayout>(new GraphicsCommonShaderObjectLayout()); SLANG_RETURN_ON_FAIL(layout->_init(this)); *outLayout = layout.detach(); @@ -388,11 +411,11 @@ protected: for (auto descriptorSetBuildInfo : builder->m_descriptorSetBuildInfos) { auto& slotRangeDescs = descriptorSetBuildInfo->slotRangeDescs; - DescriptorSetLayout::Desc desc; + IDescriptorSetLayout::Desc desc; desc.slotRangeCount = slotRangeDescs.getCount(); desc.slotRanges = slotRangeDescs.getBuffer(); - RefPtr<DescriptorSetLayout> descriptorSetLayout; + ComPtr<IDescriptorSetLayout> descriptorSetLayout; SLANG_RETURN_ON_FAIL( m_renderer->createDescriptorSetLayout(desc, descriptorSetLayout.writeRef())); @@ -582,7 +605,7 @@ public: Slang::Int getRenderTargetCount() { return m_renderTargetCount; } - PipelineLayout* getPipelineLayout() { return m_pipelineLayout; } + IPipelineLayout* getPipelineLayout() { return m_pipelineLayout; } Index findEntryPointIndex(gfx::StageType stage) { @@ -609,7 +632,7 @@ protected: m_entryPoints = builder->m_entryPoints; - List<PipelineLayout::DescriptorSetDesc> pipelineDescriptorSets; + List<IPipelineLayout::DescriptorSetDesc> pipelineDescriptorSets; _addDescriptorSetsRec(this, pipelineDescriptorSets); #if 0 @@ -623,7 +646,7 @@ protected: m_renderTargetCount = fragmentEntryPoint.layout->getVaryingOutputs().getCount(); } - PipelineLayout::Desc pipelineLayoutDesc; + IPipelineLayout::Desc pipelineLayoutDesc; pipelineLayoutDesc.renderTargetCount = m_renderTargetCount; pipelineLayoutDesc.descriptorSetCount = pipelineDescriptorSets.getCount(); pipelineLayoutDesc.descriptorSets = pipelineDescriptorSets.getBuffer(); @@ -636,11 +659,11 @@ protected: static void _addDescriptorSetsRec( GraphicsCommonShaderObjectLayout* layout, - List<PipelineLayout::DescriptorSetDesc>& ioPipelineDescriptorSets) + List<IPipelineLayout::DescriptorSetDesc>& ioPipelineDescriptorSets) { for (auto descriptorSetInfo : layout->getDescriptorSets()) { - PipelineLayout::DescriptorSetDesc pipelineDescriptorSet; + IPipelineLayout::DescriptorSetDesc pipelineDescriptorSet; pipelineDescriptorSet.layout = descriptorSetInfo->layout; pipelineDescriptorSet.space = descriptorSetInfo->space; @@ -666,18 +689,27 @@ protected: List<EntryPointInfo> m_entryPoints; gfx::UInt m_renderTargetCount = 0; - RefPtr<PipelineLayout> m_pipelineLayout; + ComPtr<IPipelineLayout> m_pipelineLayout; }; -class GraphicsCommonShaderObject : public ShaderObject +class GraphicsCommonShaderObject : public IShaderObject, public RefObject { public: + SLANG_REF_OBJECT_IUNKNOWN_ALL + IShaderObject* getInterface(const Guid& guid) + { + if (guid == GfxGUID::IID_ISlangUnknown || guid == GfxGUID::IID_IShaderObject) + return static_cast<IShaderObject*>(this); + return nullptr; + } + +public: static Result create( IRenderer* renderer, GraphicsCommonShaderObjectLayout* layout, GraphicsCommonShaderObject** outShaderObject) { - RefPtr<GraphicsCommonShaderObject> object = new GraphicsCommonShaderObject(); + auto object = ComPtr<GraphicsCommonShaderObject>(new GraphicsCommonShaderObject()); SLANG_RETURN_ON_FAIL(object->init(renderer, layout)); *outShaderObject = object.detach(); @@ -686,15 +718,27 @@ public: IRenderer* getRenderer() { return m_layout->getRenderer(); } - Index getEntryPointCount() { return 0; } + SLANG_NO_THROW UInt SLANG_MCALL getEntryPointCount() SLANG_OVERRIDE { return 0; } - ShaderObject* getEntryPoint(Index index) { return nullptr; } + SLANG_NO_THROW Result SLANG_MCALL getEntryPoint(UInt index, IShaderObject** outEntryPoint) + SLANG_OVERRIDE + { + *outEntryPoint = nullptr; + return SLANG_OK; + } - GraphicsCommonShaderObjectLayout* getLayout() { return m_layout; } + GraphicsCommonShaderObjectLayout* getLayout() + { + return m_layout; + } - slang::TypeLayoutReflection* getElementTypeLayout() { return m_layout->getElementTypeLayout(); } + SLANG_NO_THROW slang::TypeLayoutReflection* SLANG_MCALL getElementTypeLayout() SLANG_OVERRIDE + { + return m_layout->getElementTypeLayout(); + } - SlangResult setData(ShaderOffset const& offset, void const* data, size_t size) + SLANG_NO_THROW Result SLANG_MCALL + setData(ShaderOffset const& offset, void const* data, size_t size) SLANG_OVERRIDE { IRenderer* renderer = getRenderer(); @@ -705,7 +749,9 @@ public: return SLANG_OK; } - virtual SlangResult setObject(ShaderOffset const& offset, ShaderObject* object) SLANG_OVERRIDE + virtual SLANG_NO_THROW Result SLANG_MCALL + setObject(ShaderOffset const& offset, IShaderObject* object) + SLANG_OVERRIDE { if (offset.bindingRangeIndex < 0) return SLANG_E_INVALID_ARG; @@ -734,7 +780,9 @@ public: #endif } - virtual SlangResult getObject(ShaderOffset const& offset, ShaderObject** outObject) SLANG_OVERRIDE + virtual SLANG_NO_THROW Result SLANG_MCALL + getObject(ShaderOffset const& offset, IShaderObject** outObject) + SLANG_OVERRIDE { SLANG_ASSERT(outObject); if (offset.bindingRangeIndex < 0) @@ -743,7 +791,9 @@ public: return SLANG_E_INVALID_ARG; auto& bindingRange = m_layout->getBindingRange(offset.bindingRangeIndex); - *outObject = m_objects[bindingRange.baseIndex + offset.bindingArrayIndex]; + auto object = m_objects[bindingRange.baseIndex + offset.bindingArrayIndex].Ptr(); + object->addRef(); + *outObject = object; // auto& subObjectRange = // m_layout->getSubObjectRange(bindingRange.subObjectRangeIndex); *outObject = @@ -761,14 +811,8 @@ public: #endif } - ShaderObject* getObject(ShaderOffset const& offset) - { - ShaderObject* object = nullptr; - SLANG_RETURN_NULL_ON_FAIL(getObject(offset, &object)); - return object; - } - - SlangResult setResource(ShaderOffset const& offset, ResourceView* resourceView) + SLANG_NO_THROW Result SLANG_MCALL + setResource(ShaderOffset const& offset, IResourceView* resourceView) SLANG_OVERRIDE { if (offset.bindingRangeIndex < 0) return SLANG_E_INVALID_ARG; @@ -780,7 +824,8 @@ public: return SLANG_OK; } - SlangResult setSampler(ShaderOffset const& offset, SamplerState* sampler) + SLANG_NO_THROW Result SLANG_MCALL setSampler(ShaderOffset const& offset, ISamplerState* sampler) + SLANG_OVERRIDE { if (offset.bindingRangeIndex < 0) return SLANG_E_INVALID_ARG; @@ -792,8 +837,8 @@ public: return SLANG_OK; } - SlangResult setCombinedTextureSampler( - ShaderOffset const& offset, ResourceView* textureView, SamplerState* sampler) + SLANG_NO_THROW Result SLANG_MCALL setCombinedTextureSampler( + ShaderOffset const& offset, IResourceView* textureView, ISamplerState* sampler) SLANG_OVERRIDE { if (offset.bindingRangeIndex < 0) return SLANG_E_INVALID_ARG; @@ -826,11 +871,11 @@ protected: size_t uniformSize = layout->getElementTypeLayout()->getSize(); if (uniformSize) { - BufferResource::Desc bufferDesc; + IBufferResource::Desc bufferDesc; bufferDesc.init(uniformSize); - bufferDesc.cpuAccessFlags |= Resource::AccessFlag::Write; + bufferDesc.cpuAccessFlags |= IResource::AccessFlag::Write; SLANG_RETURN_ON_FAIL(renderer->createBufferResource( - Resource::Usage::ConstantBuffer, bufferDesc, nullptr, m_buffer.writeRef())); + IResource::Usage::ConstantBuffer, bufferDesc, nullptr, m_buffer.writeRef())); } #if 0 @@ -857,7 +902,7 @@ protected: for (auto subObjectRangeInfo : layout->getSubObjectRanges()) { - RefPtr<GraphicsCommonShaderObjectLayout> subObjectLayout = subObjectRangeInfo.layout; + auto subObjectLayout = subObjectRangeInfo.layout; // In the case where the sub-object range represents an // existential-type leaf field (e.g., an `IBar`), we @@ -888,17 +933,17 @@ protected: Result apply( IRenderer* renderer, PipelineType pipelineType, - PipelineLayout* pipelineLayout, + IPipelineLayout* pipelineLayout, Index& ioRootIndex) { GraphicsCommonShaderObjectLayout* layout = m_layout; // Create the descritpor sets required by the layout... // - List<RefPtr<DescriptorSet>> descriptorSets; + List<ComPtr<IDescriptorSet>> descriptorSets; for (auto descriptorSetInfo : layout->getDescriptorSets()) { - RefPtr<DescriptorSet> descriptorSet; + ComPtr<IDescriptorSet> descriptorSet; SLANG_RETURN_ON_FAIL( renderer->createDescriptorSet(descriptorSetInfo->layout, descriptorSet.writeRef())); descriptorSets.add(descriptorSet); @@ -915,7 +960,7 @@ protected: } Result _bindIntoDescriptorSet( - DescriptorSet* descriptorSet, Index baseRangeIndex, Index subObjectRangeArrayIndex) + IDescriptorSet* descriptorSet, Index baseRangeIndex, Index subObjectRangeArrayIndex) { GraphicsCommonShaderObjectLayout* layout = m_layout; @@ -999,7 +1044,7 @@ protected: } public: - virtual Result _bindIntoDescriptorSets(RefPtr<DescriptorSet>* descriptorSets) + virtual Result _bindIntoDescriptorSets(ComPtr<IDescriptorSet>* descriptorSets) { GraphicsCommonShaderObjectLayout* layout = m_layout; @@ -1013,7 +1058,7 @@ public: // for (auto bindingRangeInfo : layout->getBindingRanges()) { - DescriptorSet* descriptorSet = descriptorSets[bindingRangeInfo.descriptorSetIndex]; + auto descriptorSet = descriptorSets[bindingRangeInfo.descriptorSetIndex]; auto rangeIndex = bindingRangeInfo.rangeIndexInDescriptorSet; auto baseIndex = bindingRangeInfo.baseIndex; auto count = bindingRangeInfo.count; @@ -1073,16 +1118,16 @@ public: } RefPtr<GraphicsCommonShaderObjectLayout> m_layout = nullptr; - RefPtr<BufferResource> m_buffer; + ComPtr<IBufferResource> m_buffer; - List<RefPtr<ResourceView>> m_resourceViews; + List<ComPtr<IResourceView>> m_resourceViews; - List<RefPtr<SamplerState>> m_samplers; + List<ComPtr<ISamplerState>> m_samplers; struct CombinedTextureSamplerSlot { - RefPtr<ResourceView> textureView; - RefPtr<SamplerState> sampler; + ComPtr<IResourceView> textureView; + ComPtr<ISamplerState> sampler; }; List<CombinedTextureSamplerSlot> m_combinedTextureSamplers; @@ -1158,12 +1203,17 @@ public: List<RefPtr<EntryPointVars>> const& getEntryPoints() const { return m_entryPoints; } - Index getEntryPointCount() { return m_entryPoints.getCount(); } - ShaderObject* getEntryPoint(Index index) { return m_entryPoints[index]; } + UInt SLANG_MCALL getEntryPointCount() SLANG_OVERRIDE { return (UInt)m_entryPoints.getCount(); } + SlangResult SLANG_MCALL getEntryPoint(UInt index, IShaderObject** outEntryPoint) SLANG_OVERRIDE + { + *outEntryPoint = m_entryPoints[index]; + m_entryPoints[index]->addRef(); + return SLANG_OK; + } protected: - virtual Result _bindIntoDescriptorSets(RefPtr<DescriptorSet>* descriptorSets) + virtual Result _bindIntoDescriptorSets(ComPtr<IDescriptorSet>* descriptorSets) override { SLANG_RETURN_ON_FAIL(Super::_bindIntoDescriptorSets(descriptorSets)); @@ -1199,8 +1249,8 @@ protected: }; -Result GraphicsAPIRenderer::createShaderObjectLayout( - slang::TypeLayoutReflection* typeLayout, ShaderObjectLayout** outLayout) +Result SLANG_MCALL GraphicsAPIRenderer::createShaderObjectLayout( + slang::TypeLayoutReflection* typeLayout, IShaderObjectLayout** outLayout) { RefPtr<GraphicsCommonShaderObjectLayout> layout; SLANG_RETURN_ON_FAIL(GraphicsCommonShaderObjectLayout::createForElementType( @@ -1209,7 +1259,8 @@ Result GraphicsAPIRenderer::createShaderObjectLayout( return SLANG_OK; } -Result GraphicsAPIRenderer::createShaderObject(ShaderObjectLayout* layout, ShaderObject** outObject) +Result SLANG_MCALL + GraphicsAPIRenderer::createShaderObject(IShaderObjectLayout* layout, IShaderObject** outObject) { RefPtr<GraphicsCommonShaderObject> shaderObject; SLANG_RETURN_ON_FAIL(GraphicsCommonShaderObject::create(this, @@ -1218,8 +1269,8 @@ Result GraphicsAPIRenderer::createShaderObject(ShaderObjectLayout* layout, Shade return SLANG_OK; } -Result GraphicsAPIRenderer::createRootShaderObject( - ShaderObjectLayout* rootLayout, ShaderObject** outObject) +Result SLANG_MCALL GraphicsAPIRenderer::createRootShaderObject( + IShaderObjectLayout* rootLayout, IShaderObject** outObject) { RefPtr<ProgramVars> shaderObject; SLANG_RETURN_ON_FAIL(ProgramVars::create(this, @@ -1229,8 +1280,8 @@ Result GraphicsAPIRenderer::createRootShaderObject( return SLANG_OK; } -Result GraphicsAPIRenderer::createRootShaderObjectLayout( - slang::ProgramLayout* layout, ShaderObjectLayout** outLayout) +Result SLANG_MCALL GraphicsAPIRenderer::createRootShaderObjectLayout( + slang::ProgramLayout* layout, IShaderObjectLayout** outLayout) { RefPtr<GraphicsCommonProgramLayout> programLayout; auto slangReflection = layout; @@ -1260,7 +1311,8 @@ Result GraphicsAPIRenderer::createRootShaderObjectLayout( return SLANG_OK; } -Result GraphicsAPIRenderer::bindRootShaderObject(PipelineType pipelineType, ShaderObject* object) +Result SLANG_MCALL + GraphicsAPIRenderer::bindRootShaderObject(PipelineType pipelineType, IShaderObject* object) { auto programVars = dynamic_cast<ProgramVars*>(object); if (!programVars) @@ -1270,6 +1322,27 @@ Result GraphicsAPIRenderer::bindRootShaderObject(PipelineType pipelineType, Shad return SLANG_OK; } +SLANG_NO_THROW Result SLANG_MCALL + gfx::GraphicsAPIRenderer::getFeatures( + const char** outFeatures, UInt bufferSize, UInt* outFeatureCount) +{ + if (bufferSize >= (UInt)m_features.getCount()) + { + for (Index i = 0; i < m_features.getCount(); i++) + { + outFeatures[i] = m_features[i].getUnownedSlice().begin(); + } + } + if (outFeatureCount) + *outFeatureCount = (UInt)m_features.getCount(); + return SLANG_OK; +} + +SLANG_NO_THROW bool SLANG_MCALL gfx::GraphicsAPIRenderer::hasFeature(const char* featureName) +{ + return m_features.findFirstIndex([&](Slang::String x) { return x == featureName; }) != -1; +} + void GraphicsAPIRenderer::preparePipelineDesc(GraphicsPipelineStateDesc& desc) { if (desc.rootShaderObjectLayout) @@ -1291,7 +1364,7 @@ void GraphicsAPIRenderer::preparePipelineDesc(ComputePipelineStateDesc& desc) IRenderer* gfx::GraphicsAPIRenderer::getInterface(const Guid& guid) { - return (guid == IID_ISlangUnknown || guid == IID_IRenderer) + return (guid == GfxGUID::IID_ISlangUnknown || guid == GfxGUID::IID_IRenderer) ? static_cast<IRenderer*>(this) : nullptr; } diff --git a/tools/gfx/render-graphics-common.h b/tools/gfx/render-graphics-common.h index af2677905..1c04302ce 100644 --- a/tools/gfx/render-graphics-common.h +++ b/tools/gfx/render-graphics-common.h @@ -1,6 +1,7 @@ #pragma once #include "tools/gfx/render.h" +#include "core/slang-basic.h" namespace gfx { @@ -9,16 +10,44 @@ class GraphicsAPIRenderer : public IRenderer, public Slang::RefObject { public: SLANG_REF_OBJECT_IUNKNOWN_ALL + virtual SLANG_NO_THROW Result SLANG_MCALL getFeatures( + const char** outFeatures, UInt bufferSize, UInt* outFeatureCount) SLANG_OVERRIDE; + virtual SLANG_NO_THROW bool SLANG_MCALL hasFeature(const char* featureName) SLANG_OVERRIDE; virtual SLANG_NO_THROW Result SLANG_MCALL createShaderObjectLayout( - slang::TypeLayoutReflection* typeLayout, ShaderObjectLayout** outLayout) SLANG_OVERRIDE; + slang::TypeLayoutReflection* typeLayout, IShaderObjectLayout** outLayout) SLANG_OVERRIDE; virtual SLANG_NO_THROW Result SLANG_MCALL createRootShaderObjectLayout( - slang::ProgramLayout* programLayout, ShaderObjectLayout** outLayout) SLANG_OVERRIDE; - virtual SLANG_NO_THROW Result SLANG_MCALL createShaderObject(ShaderObjectLayout* layout, ShaderObject** outObject) SLANG_OVERRIDE; - virtual SLANG_NO_THROW Result SLANG_MCALL createRootShaderObject(ShaderObjectLayout* rootLayout, ShaderObject** outObject) SLANG_OVERRIDE; - virtual SLANG_NO_THROW Result SLANG_MCALL bindRootShaderObject(PipelineType pipelineType, ShaderObject* object) SLANG_OVERRIDE; + slang::ProgramLayout* programLayout, IShaderObjectLayout** outLayout) SLANG_OVERRIDE; + virtual SLANG_NO_THROW Result SLANG_MCALL + createShaderObject(IShaderObjectLayout* layout, IShaderObject** outObject) SLANG_OVERRIDE; + virtual SLANG_NO_THROW Result SLANG_MCALL createRootShaderObject( + IShaderObjectLayout* rootLayout, IShaderObject** outObject) SLANG_OVERRIDE; + virtual SLANG_NO_THROW Result SLANG_MCALL + bindRootShaderObject(PipelineType pipelineType, IShaderObject* object) SLANG_OVERRIDE; void preparePipelineDesc(GraphicsPipelineStateDesc& desc); void preparePipelineDesc(ComputePipelineStateDesc& desc); IRenderer* getInterface(const Slang::Guid& guid); + +protected: + Slang::List<Slang::String> m_features; +}; + +struct GfxGUID +{ + static const Slang::Guid IID_ISlangUnknown; + static const Slang::Guid IID_IDescriptorSetLayout; + static const Slang::Guid IID_IDescriptorSet; + static const Slang::Guid IID_IShaderProgram; + static const Slang::Guid IID_IPipelineLayout; + static const Slang::Guid IID_IPipelineState; + static const Slang::Guid IID_IResourceView; + static const Slang::Guid IID_ISamplerState; + static const Slang::Guid IID_IResource; + static const Slang::Guid IID_IBufferResource; + static const Slang::Guid IID_ITextureResource; + static const Slang::Guid IID_IInputLayout; + static const Slang::Guid IID_IRenderer; + static const Slang::Guid IID_IShaderObjectLayout; + static const Slang::Guid IID_IShaderObject; }; } diff --git a/tools/gfx/render.cpp b/tools/gfx/render.cpp index cf3a0576c..a25393714 100644 --- a/tools/gfx/render.cpp +++ b/tools/gfx/render.cpp @@ -1,6 +1,5 @@ // render.cpp -#include "render.h" - +#include "renderer-shared.h" #include "../../source/core/slang-math.h" #include "d3d11/render-d3d11.h" @@ -8,438 +7,161 @@ #include "open-gl/render-gl.h" #include "vulkan/render-vk.h" #include "cuda/render-cuda.h" +#include <cstring> namespace gfx { using namespace Slang; -/* static */const Resource::BindFlag::Enum Resource::s_requiredBinding[] = -{ - BindFlag::VertexBuffer, // VertexBuffer - BindFlag::IndexBuffer, // IndexBuffer - BindFlag::ConstantBuffer, // ConstantBuffer - BindFlag::StreamOutput, // StreamOut - BindFlag::RenderTarget, // RenderTager - BindFlag::DepthStencil, // DepthRead - BindFlag::DepthStencil, // DepthWrite - BindFlag::UnorderedAccess, // UnorderedAccess - BindFlag::PixelShaderResource, // PixelShaderResource - BindFlag::NonPixelShaderResource, // NonPixelShaderResource - BindFlag::Enum(BindFlag::PixelShaderResource | BindFlag::NonPixelShaderResource), // GenericRead -}; - - -/* static */void Resource::compileTimeAsserts() -{ - SLANG_COMPILE_TIME_ASSERT(SLANG_COUNT_OF(s_requiredBinding) == int(Usage::CountOf)); -} - -static const Resource::DescBase s_emptyDescBase = {}; - -const Resource::DescBase& Resource::getDescBase() const -{ - if (isBuffer()) - { - return static_cast<const BufferResource *>(this)->getDesc(); - } - else if (isTexture()) - { - return static_cast<const TextureResource *>(this)->getDesc(); - } - return s_emptyDescBase; -} +static const IResource::DescBase s_emptyDescBase = {}; -/* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! RendererUtil !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! */ +/* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!! Global Renderer Functions !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! */ -/* static */const uint8_t RendererUtil::s_formatSize[] = -{ - 0, // Unknown, +static const uint8_t s_formatSize[] = { + 0, // Unknown, - uint8_t(sizeof(float) * 4), // RGBA_Float32, - uint8_t(sizeof(float) * 3), // RGB_Float32, - uint8_t(sizeof(float) * 2), // RG_Float32, - uint8_t(sizeof(float) * 1), // R_Float32, + uint8_t(sizeof(float) * 4), // RGBA_Float32, + uint8_t(sizeof(float) * 3), // RGB_Float32, + uint8_t(sizeof(float) * 2), // RG_Float32, + uint8_t(sizeof(float) * 1), // R_Float32, - uint8_t(sizeof(uint32_t)), // RGBA_Unorm_UInt8, + uint8_t(sizeof(uint32_t)), // RGBA_Unorm_UInt8, - uint8_t(sizeof(uint16_t)), // R_UInt16, - uint8_t(sizeof(uint32_t)), // R_UInt32, + uint8_t(sizeof(uint16_t)), // R_UInt16, + uint8_t(sizeof(uint32_t)), // R_UInt32, - uint8_t(sizeof(float)), // D_Float32, - uint8_t(sizeof(uint32_t)), // D_Unorm24_S8, + uint8_t(sizeof(float)), // D_Float32, + uint8_t(sizeof(uint32_t)), // D_Unorm24_S8, }; -/* static */const BindingStyle RendererUtil::s_rendererTypeToBindingStyle[] = -{ - BindingStyle::Unknown, // Unknown, - BindingStyle::DirectX, // DirectX11, - BindingStyle::DirectX, // DirectX12, - BindingStyle::OpenGl, // OpenGl, - BindingStyle::Vulkan, // Vulkan - BindingStyle::CPU, // CPU - BindingStyle::CUDA, // CUDA +static const BindingStyle s_rendererTypeToBindingStyle[] = { + BindingStyle::Unknown, // Unknown, + BindingStyle::DirectX, // DirectX11, + BindingStyle::DirectX, // DirectX12, + BindingStyle::OpenGl, // OpenGl, + BindingStyle::Vulkan, // Vulkan + BindingStyle::CPU, // CPU + BindingStyle::CUDA, // CUDA }; -/* static */void RendererUtil::compileTimeAsserts() +static void _compileTimeAsserts() { SLANG_COMPILE_TIME_ASSERT(SLANG_COUNT_OF(s_formatSize) == int(Format::CountOf)); - SLANG_COMPILE_TIME_ASSERT(SLANG_COUNT_OF(s_rendererTypeToBindingStyle) == int(RendererType::CountOf)); -} - -/* !!!!!!!!!!!!!!!!!!!!!!!!!!! BindingState::Desc !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! */ -#if 0 -void BindingState::Desc::addSampler(const SamplerDesc& desc, const RegisterRange& registerRange) -{ - int descIndex = int(m_samplerDescs.Count()); - m_samplerDescs.Add(desc); - - Binding binding; - binding.bindingType = BindingType::Sampler; - binding.resource = nullptr; - binding.registerRange = registerRange; - binding.descIndex = descIndex; - - m_bindings.Add(binding); + SLANG_COMPILE_TIME_ASSERT( + SLANG_COUNT_OF(s_rendererTypeToBindingStyle) == int(RendererType::CountOf)); } -void BindingState::Desc::addResource(BindingType bindingType, Resource* resource, const RegisterRange& registerRange) +extern "C" { - assert(resource); - - Binding binding; - binding.bindingType = bindingType; - binding.resource = resource; - binding.descIndex = -1; - binding.registerRange = registerRange; - m_bindings.Add(binding); -} - -void BindingState::Desc::addCombinedTextureSampler(TextureResource* resource, const SamplerDesc& samplerDesc, const RegisterRange& registerRange) -{ - assert(resource); - - int samplerDescIndex = int(m_samplerDescs.Count()); - m_samplerDescs.Add(samplerDesc); - - Binding binding; - binding.bindingType = BindingType::CombinedTextureSampler; - binding.resource = resource; - binding.descIndex = samplerDescIndex; - binding.registerRange = registerRange; - m_bindings.Add(binding); -} - -void BindingState::Desc::clear() -{ - m_bindings.Clear(); - m_samplerDescs.Clear(); - m_numRenderTargets = 1; -} - -int BindingState::Desc::findBindingIndex(Resource::BindFlag::Enum bindFlag, int registerIndex) const -{ - const int numBindings = int(m_bindings.Count()); - for (int i = 0; i < numBindings; ++i) + size_t SLANG_MCALL gfxGetFormatSize(Format format) { - const Binding& binding = m_bindings[i]; - if (binding.resource && (binding.resource->getDescBase().bindFlags & bindFlag) != 0) - { - if (binding.registerRange.hasRegister(registerIndex)) - { - return i; - } - } + return s_formatSize[int(format)]; } - return -1; -} -#endif - -/* !!!!!!!!!!!!!!!!!!!!!!!!!!! TextureResource::Size !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! */ - -int TextureResource::Size::calcMaxDimension(Type type) const -{ - switch (type) + BindingStyle SLANG_MCALL gfxGetBindingStyle(RendererType type) { - case Resource::Type::Texture1D: return this->width; - case Resource::Type::Texture3D: return std::max(std::max(this->width, this->height), this->depth); - case Resource::Type::TextureCube: // fallthru - case Resource::Type::Texture2D: - { - return std::max(this->width, this->height); - } - default: return 0; + return s_rendererTypeToBindingStyle[int(type)]; } -} -TextureResource::Size TextureResource::Size::calcMipSize(int mipLevel) const -{ - Size size; - size.width = TextureResource::calcMipSize(this->width, mipLevel); - size.height = TextureResource::calcMipSize(this->height, mipLevel); - size.depth = TextureResource::calcMipSize(this->depth, mipLevel); - return size; -} - -/* !!!!!!!!!!!!!!!!!!!!!!!!! BufferResource::Desc !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! */ - -void BufferResource::Desc::setDefaults(Usage initialUsage) -{ - if (this->bindFlags == 0) + const char* SLANG_MCALL gfxGetRendererName(RendererType type) { - this->bindFlags = Resource::s_requiredBinding[int(initialUsage)]; - } -} - -/* !!!!!!!!!!!!!!!!!!!!!!!!! TextureResource::Desc !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! */ - -int TextureResource::Desc::calcNumMipLevels() const -{ - const int maxDimensionSize = this->size.calcMaxDimension(type); - return (maxDimensionSize > 0) ? (Math::Log2Floor(maxDimensionSize) + 1) : 0; -} - -int TextureResource::Desc::calcNumSubResources() const -{ - const int numMipMaps = (this->numMipLevels > 0) ? this->numMipLevels : calcNumMipLevels(); - const int arrSize = (this->arraySize > 0) ? this->arraySize : 1; - - switch (type) - { - case Resource::Type::Texture1D: - case Resource::Type::Texture2D: - { - return numMipMaps * arrSize; - } - case Resource::Type::Texture3D: - { - // can't have arrays of 3d textures - assert(this->arraySize <= 1); - return numMipMaps * this->size.depth; - } - case Resource::Type::TextureCube: + switch (type) { - // There are 6 faces to a cubemap - return numMipMaps * arrSize * 6; + case RendererType::DirectX11: + return "DirectX11"; + case RendererType::DirectX12: + return "DirectX11"; + case RendererType::OpenGl: + return "OpenGL"; + case RendererType::Vulkan: + return "Vulkan"; + case RendererType::Unknown: + return "Unknown"; + case RendererType::CPU: + return "CPU"; + case RendererType::CUDA: + return "CUDA"; + default: + return "?!?"; } - default: return 0; } -} -void TextureResource::Desc::fixSize() -{ - switch (type) + SGRendererCreateFunc SLANG_MCALL gfxGetCreateFunc(RendererType type) { - case Resource::Type::Texture1D: - { - this->size.height = 1; - this->size.depth = 1; - break; - } - case Resource::Type::TextureCube: - case Resource::Type::Texture2D: - { - this->size.depth = 1; - break; - } - case Resource::Type::Texture3D: + switch (type) { - // Can't have an array - this->arraySize = 0; - break; - } - default: break; - } -} - -void TextureResource::Desc::setDefaults(Usage initialUsage) -{ - fixSize(); - if (this->bindFlags == 0) - { - this->bindFlags = Resource::s_requiredBinding[int(initialUsage)]; - } - if (this->numMipLevels <= 0) - { - this->numMipLevels = calcNumMipLevels(); - } -} - -int TextureResource::Desc::calcEffectiveArraySize() const -{ - const int arrSize = (this->arraySize > 0) ? this->arraySize : 1; +#if SLANG_WINDOWS_FAMILY + case RendererType::DirectX11: + { + return &createD3D11Renderer; + } + case RendererType::DirectX12: + { + return &createD3D12Renderer; + } + case RendererType::OpenGl: + { + return &createGLRenderer; + } + case RendererType::Vulkan: + { + return &createVKRenderer; + } + case RendererType::CUDA: + { + return &createCUDARenderer; + } +#endif - switch (type) - { - case Resource::Type::Texture1D: // fallthru - case Resource::Type::Texture2D: - { - return arrSize; + default: + return nullptr; } - case Resource::Type::TextureCube: return arrSize * 6; - case Resource::Type::Texture3D: return 1; - default: return 0; } -} - -void TextureResource::Desc::init(Type typeIn) -{ - this->type = typeIn; - this->size.init(); - - this->format = Format::Unknown; - this->arraySize = 0; - this->numMipLevels = 0; - this->sampleDesc.init(); - - this->bindFlags = 0; - this->cpuAccessFlags = 0; -} - -void TextureResource::Desc::init1D(Format formatIn, int widthIn, int numMipMapsIn) -{ - this->type = Type::Texture1D; - this->size.init(widthIn); - - this->format = formatIn; - this->arraySize = 0; - this->numMipLevels = numMipMapsIn; - this->sampleDesc.init(); - - this->bindFlags = 0; - this->cpuAccessFlags = 0; -} - -void TextureResource::Desc::init2D(Type typeIn, Format formatIn, int widthIn, int heightIn, int numMipMapsIn) -{ - assert(typeIn == Type::Texture2D || typeIn == Type::TextureCube); - - this->type = typeIn; - this->size.init(widthIn, heightIn); - - this->format = formatIn; - this->arraySize = 0; - this->numMipLevels = numMipMapsIn; - this->sampleDesc.init(); - - this->bindFlags = 0; - this->cpuAccessFlags = 0; -} - -void TextureResource::Desc::init3D(Format formatIn, int widthIn, int heightIn, int depthIn, int numMipMapsIn) -{ - this->type = Type::Texture3D; - this->size.init(widthIn, heightIn, depthIn); - this->format = formatIn; - this->arraySize = 0; - this->numMipLevels = numMipMapsIn; - this->sampleDesc.init(); - - this->bindFlags = 0; - this->cpuAccessFlags = 0; -} - -/* !!!!!!!!!!!!!!!!!!!!!!!!! RennderUtil !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! */ - -ProjectionStyle RendererUtil::getProjectionStyle(RendererType type) -{ - switch (type) + ProjectionStyle SLANG_MCALL gfxGetProjectionStyle(RendererType type) { + switch (type) + { case RendererType::DirectX11: case RendererType::DirectX12: - { - return ProjectionStyle::DirectX; - } - case RendererType::OpenGl: return ProjectionStyle::OpenGl; - case RendererType::Vulkan: return ProjectionStyle::Vulkan; - case RendererType::Unknown: return ProjectionStyle::Unknown; - default: - { - assert(!"Unhandled type"); + { + return ProjectionStyle::DirectX; + } + case RendererType::OpenGl: + return ProjectionStyle::OpenGl; + case RendererType::Vulkan: + return ProjectionStyle::Vulkan; + case RendererType::Unknown: return ProjectionStyle::Unknown; + default: + { + assert(!"Unhandled type"); + return ProjectionStyle::Unknown; + } } } -} -/* static */void RendererUtil::getIdentityProjection(ProjectionStyle style, float projMatrix[16]) -{ - switch (style) + void SLANG_MCALL gfxGetIdentityProjection(ProjectionStyle style, float projMatrix[16]) { + switch (style) + { case ProjectionStyle::DirectX: case ProjectionStyle::OpenGl: - { - static const float kIdentity[] = { - 1, 0, 0, 0, - 0, 1, 0, 0, - 0, 0, 1, 0, - 0, 0, 0, 1 - }; - ::memcpy(projMatrix, kIdentity, sizeof(kIdentity)); - break; - } + static const float kIdentity[] = {1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1}; + ::memcpy(projMatrix, kIdentity, sizeof(kIdentity)); + break; + } case ProjectionStyle::Vulkan: - { - static const float kIdentity[] = { - 1, 0, 0, 0, - 0, -1, 0, 0, - 0, 0, 1, 0, - 0, 0, 0, 1 - }; - ::memcpy(projMatrix, kIdentity, sizeof(kIdentity)); - break; - } + static const float kIdentity[] = {1, 0, 0, 0, 0, -1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1}; + ::memcpy(projMatrix, kIdentity, sizeof(kIdentity)); + break; + } default: - { - assert(!"Not handled"); - } - } -} - -/* static */UnownedStringSlice RendererUtil::toText(RendererType type) -{ - switch (type) - { - case RendererType::DirectX11: return UnownedStringSlice::fromLiteral("DirectX11"); - case RendererType::DirectX12: return UnownedStringSlice::fromLiteral("DirectX11"); - case RendererType::OpenGl: return UnownedStringSlice::fromLiteral("OpenGL"); - case RendererType::Vulkan: return UnownedStringSlice::fromLiteral("Vulkan"); - case RendererType::Unknown: return UnownedStringSlice::fromLiteral("Unknown"); - case RendererType::CPU: return UnownedStringSlice::fromLiteral("CPU"); - case RendererType::CUDA: return UnownedStringSlice::fromLiteral("CUDA"); - default: return UnownedStringSlice::fromLiteral("?!?"); - } -} - -/* static */ RendererUtil::CreateFunc RendererUtil::getCreateFunc(RendererType type) -{ - switch (type) - { -#if SLANG_WINDOWS_FAMILY - case RendererType::DirectX11: - { - return &createD3D11Renderer; - } - case RendererType::DirectX12: - { - return &createD3D12Renderer; - } - case RendererType::OpenGl: - { - return &createGLRenderer; - } - case RendererType::Vulkan: - { - return &createVKRenderer; - } - case RendererType::CUDA: - { - return &createCUDARenderer; + { + assert(!"Not handled"); + } } -#endif - - default: return nullptr; } } diff --git a/tools/gfx/render.h b/tools/gfx/render.h index bcba27dc5..0bc8692eb 100644 --- a/tools/gfx/render.h +++ b/tools/gfx/render.h @@ -1,28 +1,36 @@ // render.h #pragma once -//#include "shader-input-layout.h" - #include <float.h> - -#include "../../slang-com-helper.h" - -#include "../../source/core/slang-smart-pointer.h" -#include "../../source/core/slang-list.h" -#include "../../source/core/slang-dictionary.h" -#include "../../source/core/slang-process-util.h" - -#include "../../slang.h" +#include <assert.h> + +#include "slang.h" +#include "slang-com-ptr.h" +#include "slang-com-helper.h" + + +#if defined(SLANG_GFX_DYNAMIC) +# if defined(_MSC_VER) +# ifdef SLANG_GFX_DYNAMIC_EXPORT +# define SLANG_GFX_API SLANG_DLL_EXPORT +# else +# define SLANG_GFX_API __declspec(dllimport) +# endif +# else +// TODO: need to consider compiler capabilities +//# ifdef SLANG_DYNAMIC_EXPORT +# define SLANG_GFX_API SLANG_DLL_EXPORT +//# endif +# endif +#endif + +#ifndef SLANG_GFX_API +# define SLANG_GFX_API +#endif namespace gfx { -using Slang::RefObject; -using Slang::RefPtr; -using Slang::Dictionary; -using Slang::List; - -using Slang::getHashCode; -using Slang::combineHash; +using Slang::ComPtr; typedef SlangResult Result; @@ -34,10 +42,13 @@ typedef SlangUInt UInt; class Surface; // Declare opaque type -class InputLayout: public Slang::RefObject +class IInputLayout: public ISlangUnknown { - public: }; +#define SLANG_UUID_IInputLayout \ + { \ + 0x45223711, 0xa84b, 0x455c, { 0xbe, 0xfa, 0x49, 0x37, 0x42, 0x1e, 0x8e, 0x2e } \ + } enum class PipelineType { @@ -99,7 +110,7 @@ enum class BindingStyle CountOf, }; -class ShaderProgram: public Slang::RefObject +class IShaderProgram: public ISlangUnknown { public: @@ -129,36 +140,10 @@ public: } }; }; - -struct ShaderCompileRequest -{ - struct SourceInfo - { - char const* path; - - // The data may either be source text (in which - // case it can be assumed to be nul-terminated with - // `dataEnd` pointing at the terminator), or - // raw binary data (in which case `dataEnd` points - // at the end of the buffer). - char const* dataBegin; - char const* dataEnd; - }; - - struct EntryPoint - { - char const* name = nullptr; - SlangStage slangStage; - }; - - SourceInfo source; - Slang::List<EntryPoint> entryPoints; - - Slang::List<Slang::String> globalSpecializationArgs; - Slang::List<Slang::String> entryPointSpecializationArgs; - - Slang::List<Slang::CommandLine::Arg> compileArgs; -}; +#define SLANG_UUID_IShaderProgram \ + { \ + 0x9d32d0ad, 0x915c, 0x4ffd, { 0x91, 0xe2, 0x50, 0x85, 0x54, 0xa0, 0x4a, 0x76 } \ + } /// Different formats of things like pixels or elements of vertices /// NOTE! Any change to this type (adding, removing, changing order) - must also be reflected in changes to RendererUtil @@ -203,10 +188,9 @@ enum class PrimitiveTopology TriangleList, }; -class Resource: public Slang::RefObject +class IResource: public ISlangUnknown { - public: - +public: /// The type of resource. /// NOTE! The order needs to be such that all texture types are at or after Texture1D (otherwise isTexture won't work correctly) enum class Type @@ -277,36 +261,48 @@ class Resource: public Slang::RefObject int cpuAccessFlags = 0; ///< Combination of Resource::AccessFlag }; - /// Get the type - SLANG_FORCE_INLINE Type getType() const { return m_type; } - /// True if it's a texture derived type - SLANG_FORCE_INLINE bool isTexture() const { return int(m_type) >= int(Type::Texture1D); } - /// True if it's a buffer derived type - SLANG_FORCE_INLINE bool isBuffer() const { return m_type == Type::Buffer; } - - /// Get the descBase - const DescBase& getDescBase() const; - /// Returns true if can bind with flag - bool canBind(BindFlag::Enum bindFlag) const { return getDescBase().canBind(bindFlag); } - - /// For a usage gives the required binding flags - static const BindFlag::Enum s_requiredBinding[]; /// Maps Usage to bind flags required - - protected: - Resource(Type type): - m_type(type) - {} - - static void compileTimeAsserts(); + inline static BindFlag::Enum getDefaultBindFlagsFromUsage(IResource::Usage usage) + { + switch (usage) + { + case Usage::VertexBuffer: + return BindFlag::VertexBuffer; + case Usage::IndexBuffer: + return BindFlag::IndexBuffer; + case Usage::ConstantBuffer: + return BindFlag::ConstantBuffer; + case Usage::StreamOutput: + return BindFlag::StreamOutput; + case Usage::RenderTarget: + return BindFlag::RenderTarget; + case Usage::DepthRead: + case Usage::DepthWrite: + return BindFlag::DepthStencil; + case Usage::UnorderedAccess: + return BindFlag::UnorderedAccess; + case Usage::PixelShaderResource: + return BindFlag::PixelShaderResource; + case Usage::NonPixelShaderResource: + return BindFlag::NonPixelShaderResource; + case Usage::GenericRead: + return BindFlag::Enum( + BindFlag::PixelShaderResource | + BindFlag::NonPixelShaderResource); + default: + return BindFlag::Enum(-1); + } + } - Type m_type; + virtual SLANG_NO_THROW Type SLANG_MCALL getType() = 0; }; +#define SLANG_UUID_IResource \ + { \ + 0xa0e39f34, 0x8398, 0x4522, { 0x95, 0xc2, 0xeb, 0xc0, 0xf9, 0x84, 0xef, 0x3f } \ + } -class BufferResource: public Resource +class IBufferResource: public IResource { - public: - typedef Resource Parent; - +public: struct Desc: public DescBase { void init(size_t sizeInBytesIn) @@ -315,33 +311,53 @@ class BufferResource: public Resource elementSize = 0; format = Format::Unknown; } - /// Set up default parameters based on usage - void setDefaults(Usage initialUsage); - + void setDefaults(Usage initialUsage) + { + if (bindFlags == 0) + { + bindFlags = getDefaultBindFlagsFromUsage(initialUsage); + } + } size_t sizeInBytes; ///< Total size in bytes int elementSize; ///< Get the element stride. If > 0, this is a structured buffer Format format; }; - - /// Get the buffer description - SLANG_FORCE_INLINE const Desc& getDesc() const { return m_desc; } - - /// Ctor - BufferResource(const Desc& desc): - Parent(Type::Buffer), - m_desc(desc) - { + virtual SLANG_NO_THROW Desc* SLANG_MCALL getDesc() = 0; +}; +#define SLANG_UUID_IBufferResource \ + { \ + 0x1b274efe, 0x5e37, 0x492b, { 0x82, 0x6e, 0x7e, 0xe7, 0xe8, 0xf5, 0xa4, 0x9b } \ } - protected: - Desc m_desc; -}; +template <typename T> T _slang_gfx_max(T v0, T v1) { return v0 > v1 ? v0 : v1; } + +static inline unsigned int _slang_gfx_ones32(unsigned int x) +{ + /* 32-bit recursive reduction using SWAR... + but first step is mapping 2-bit values + into sum of 2 1-bit values in sneaky way + */ + x -= ((x >> 1) & 0x55555555); + x = (((x >> 2) & 0x33333333) + (x & 0x33333333)); + x = (((x >> 4) + x) & 0x0f0f0f0f); + x += (x >> 8); + x += (x >> 16); + return (x & 0x0000003f); +} -class TextureResource: public Resource +static inline unsigned int _slang_gfx_log2Floor(unsigned int x) { - public: - typedef Resource Parent; + x |= (x >> 1); + x |= (x >> 2); + x |= (x >> 4); + x |= (x >> 8); + x |= (x >> 16); + return (_slang_gfx_ones32(x >> 1)); +} +class ITextureResource: public IResource +{ +public: struct SampleDesc { void init() @@ -366,9 +382,38 @@ class TextureResource: public Resource depth = depthIn; } /// Given the type works out the maximum dimension size - int calcMaxDimension(Type type) const; + int calcMaxDimension(Type type) const + { + switch (type) + { + case IResource::Type::Texture1D: + return this->width; + case IResource::Type::Texture3D: + return _slang_gfx_max(_slang_gfx_max(this->width, this->height), this->depth); + case IResource::Type::TextureCube: // fallthru + case IResource::Type::Texture2D: + { + return _slang_gfx_max(this->width, this->height); + } + default: + return 0; + } + } + + SLANG_FORCE_INLINE static int calcMipSize(int width, int mipLevel) + { + width = width >> mipLevel; + return width > 0 ? width : 1; + } /// Given a size, calculates the size at a mip level - Size calcMipSize(int mipLevel) const; + Size calcMipSize(int mipLevel) const + { + Size size; + size.width = calcMipSize(this->width, mipLevel); + size.height = calcMipSize(this->height, mipLevel); + size.depth = calcMipSize(this->depth, mipLevel); + return size; + } int width; ///< Width in pixels int height; ///< Height in pixels (if 2d or 3d) @@ -378,28 +423,165 @@ class TextureResource: public Resource struct Desc: public DescBase { /// Initialize with default values - void init(Type typeIn); + void init(Type typeIn) + { + this->type = typeIn; + this->size.init(); + + this->format = Format::Unknown; + this->arraySize = 0; + this->numMipLevels = 0; + this->sampleDesc.init(); + + this->bindFlags = 0; + this->cpuAccessFlags = 0; + } /// Initialize different dimensions. For cubemap, use init2D - void init1D(Format format, int width, int numMipMaps = 0); - void init2D(Type typeIn, Format format, int width, int height, int numMipMaps = 0); - void init3D(Format format, int width, int height, int depth, int numMipMaps = 0); + void init1D(Format formatIn, int widthIn, int numMipMapsIn = 0) + { + this->type = Type::Texture1D; + this->size.init(widthIn); + + this->format = formatIn; + this->arraySize = 0; + this->numMipLevels = numMipMapsIn; + this->sampleDesc.init(); + + this->bindFlags = 0; + this->cpuAccessFlags = 0; + } + + void init2D(Type typeIn, Format formatIn, int widthIn, int heightIn, int numMipMapsIn = 0) + { + assert(typeIn == Type::Texture2D || typeIn == Type::TextureCube); + + this->type = typeIn; + this->size.init(widthIn, heightIn); + + this->format = formatIn; + this->arraySize = 0; + this->numMipLevels = numMipMapsIn; + this->sampleDesc.init(); + + this->bindFlags = 0; + this->cpuAccessFlags = 0; + } + + void init3D(Format formatIn, int widthIn, int heightIn, int depthIn, int numMipMapsIn = 0) + { + this->type = Type::Texture3D; + this->size.init(widthIn, heightIn, depthIn); + + this->format = formatIn; + this->arraySize = 0; + this->numMipLevels = numMipMapsIn; + this->sampleDesc.init(); + + this->bindFlags = 0; + this->cpuAccessFlags = 0; + } /// Given the type, calculates the number of mip maps. 0 on error - int calcNumMipLevels() const; + int calcNumMipLevels() const + { + const int maxDimensionSize = this->size.calcMaxDimension(type); + return (maxDimensionSize > 0) ? (_slang_gfx_log2Floor(maxDimensionSize) + 1) : 0; + } /// Calculate the total number of sub resources. 0 on error. - int calcNumSubResources() const; + int calcNumSubResources() const + { + const int numMipMaps = + (this->numMipLevels > 0) ? this->numMipLevels : calcNumMipLevels(); + const int arrSize = (this->arraySize > 0) ? this->arraySize : 1; + + switch (type) + { + case IResource::Type::Texture1D: + case IResource::Type::Texture2D: + { + return numMipMaps * arrSize; + } + case IResource::Type::Texture3D: + { + // can't have arrays of 3d textures + assert(this->arraySize <= 1); + return numMipMaps * this->size.depth; + } + case IResource::Type::TextureCube: + { + // There are 6 faces to a cubemap + return numMipMaps * arrSize * 6; + } + default: + return 0; + } + } /// Calculate the effective array size - in essence the amount if mip map sets needed. /// In practice takes into account if the arraySize is 0 (it's not an array, but it will still have at least one mip set) /// and if the type is a cubemap (multiplies the amount of mip sets by 6) - int calcEffectiveArraySize() const; + int calcEffectiveArraySize() const + { + const int arrSize = (this->arraySize > 0) ? this->arraySize : 1; + + switch (type) + { + case IResource::Type::Texture1D: // fallthru + case IResource::Type::Texture2D: + { + return arrSize; + } + case IResource::Type::TextureCube: + return arrSize * 6; + case IResource::Type::Texture3D: + return 1; + default: + return 0; + } + } /// Use type to fix the size values (and array size). /// For example a 1d texture, should have height and depth set to 1. - void fixSize(); + void fixSize() + { + switch (type) + { + case IResource::Type::Texture1D: + { + this->size.height = 1; + this->size.depth = 1; + break; + } + case IResource::Type::TextureCube: + case IResource::Type::Texture2D: + { + this->size.depth = 1; + break; + } + case IResource::Type::Texture3D: + { + // Can't have an array + this->arraySize = 0; + break; + } + default: + break; + } + } /// Set up default parameters based on type and usage - void setDefaults(Usage initialUsage); + void setDefaults(Usage initialUsage) + { + fixSize(); + if (this->bindFlags == 0) + { + this->bindFlags = getDefaultBindFlagsFromUsage(initialUsage); + } + if (this->numMipLevels <= 0) + { + this->numMipLevels = calcNumMipLevels(); + } + } Size size; @@ -422,25 +604,12 @@ class TextureResource: public Resource int numSubResources; ///< The total amount of subResources. Typically = numMips * depth * arraySize }; - /// Get the description of the texture - SLANG_FORCE_INLINE const Desc& getDesc() const { return m_desc; } - - /// Ctor - TextureResource(const Desc& desc): - Parent(desc.type), - m_desc(desc) - { - } - - SLANG_FORCE_INLINE static int calcMipSize(int width, int mipLevel) - { - width = width >> mipLevel; - return width > 0 ? width : 1; - } - - protected: - Desc m_desc; + virtual SLANG_NO_THROW Desc* SLANG_MCALL getDesc() = 0; }; +#define SLANG_UUID_ITextureResource \ + { \ + 0xcf88a31c, 0x6187, 0x46c5, { 0xa4, 0xb7, 0xeb, 0x58, 0xc7, 0x33, 0x40, 0x17 } \ + } // Needed for building on cygwin with gcc #undef Always @@ -481,7 +650,7 @@ enum class TextureReductionOp Maximum, }; -class SamplerState : public Slang::RefObject +class ISamplerState : public ISlangUnknown { public: struct Desc @@ -501,6 +670,11 @@ public: float maxLOD = FLT_MAX; }; }; +#define SLANG_UUID_ISamplerState \ + { \ + 0x8b8055df, 0x9377, 0x401d, { 0x91, 0xff, 0x3f, 0xa3, 0xbf, 0x66, 0x64, 0xf4 } \ + } + enum class DescriptorSlotType { @@ -522,7 +696,7 @@ enum class DescriptorSlotType RayTracingAccelerationStructure, }; -class DescriptorSetLayout : public Slang::RefObject +class IDescriptorSetLayout : public ISlangUnknown { public: struct SlotRangeDesc @@ -558,13 +732,18 @@ public: SlotRangeDesc const* slotRanges = nullptr; }; }; +#define SLANG_UUID_IDescriptorSetLayout \ + { \ + 0x9fe39a2f, 0xdf8b, 0x4690, { 0x90, 0x6a, 0x10, 0x1e, 0xed, 0xf9, 0xbe, 0xc0 } \ + } -class PipelineLayout : public Slang::RefObject + +class IPipelineLayout : public ISlangUnknown { public: struct DescriptorSetDesc { - DescriptorSetLayout* layout = nullptr; + IDescriptorSetLayout* layout = nullptr; /// The underlying API-specific space/set number to use for this set. /// @@ -581,7 +760,7 @@ public: {} DescriptorSetDesc( - DescriptorSetLayout* layout) + IDescriptorSetLayout* layout) : layout(layout) {} }; @@ -593,8 +772,12 @@ public: DescriptorSetDesc const* descriptorSets = nullptr; }; }; +#define SLANG_UUID_IPipelineLayout \ + { \ + 0x9d644a9a, 0x3e6f, 0x4350, { 0xa3, 0x5a, 0xe8, 0xe3, 0xbc, 0xef, 0xb9, 0xcf } \ + } -class ResourceView : public Slang::RefObject +class IResourceView : public ISlangUnknown { public: enum class Type @@ -613,24 +796,37 @@ public: Format format; }; }; +#define SLANG_UUID_IResourceView \ + { \ + 0x7b6c4926, 0x884, 0x408c, { 0xad, 0x8a, 0x50, 0x3a, 0x8e, 0x23, 0x98, 0xa4 } \ + } + -class DescriptorSet : public Slang::RefObject +class IDescriptorSet : public ISlangUnknown { public: - virtual void setConstantBuffer(UInt range, UInt index, BufferResource* buffer) = 0; - virtual void setResource(UInt range, UInt index, ResourceView* view) = 0; - virtual void setSampler(UInt range, UInt index, SamplerState* sampler) = 0; - virtual void setCombinedTextureSampler( + virtual SLANG_NO_THROW void SLANG_MCALL setConstantBuffer(UInt range, UInt index, IBufferResource* buffer) = 0; + virtual SLANG_NO_THROW void SLANG_MCALL + setResource(UInt range, UInt index, IResourceView* view) = 0; + virtual SLANG_NO_THROW void SLANG_MCALL + setSampler(UInt range, UInt index, ISamplerState* sampler) = 0; + virtual SLANG_NO_THROW void SLANG_MCALL setCombinedTextureSampler( UInt range, UInt index, - ResourceView* textureView, - SamplerState* sampler) = 0; - virtual void setRootConstants( + IResourceView* textureView, + ISamplerState* sampler) = 0; + virtual SLANG_NO_THROW void SLANG_MCALL + setRootConstants( UInt range, UInt offset, UInt size, void const* data) = 0; }; +#define SLANG_UUID_IDescriptorSet \ + { \ + 0x29a881ea, 0xd7, 0x41d4, { 0xa3, 0x2d, 0x6c, 0x78, 0x4b, 0x79, 0xda, 0x2e } \ + } + struct ShaderOffset { @@ -639,30 +835,53 @@ struct ShaderOffset SlangInt bindingArrayIndex = 0; }; -class ShaderObjectLayout : public Slang::RefObject +class IShaderObjectLayout : public ISlangUnknown {}; +#define SLANG_UUID_IShaderObjectLayout \ + { \ + 0x27f3f67e, 0xa49d, 0x4aae, { 0xa6, 0xd, 0xfa, 0xc2, 0x6b, 0x1c, 0x10, 0x7c } \ + } -class ShaderObject : public Slang::RefObject + +class IShaderObject : public ISlangUnknown { public: - ShaderObject* getObject(ShaderOffset const& offset) + SLANG_NO_THROW ComPtr<IShaderObject> SLANG_MCALL getObject(ShaderOffset const& offset) { - ShaderObject* object = nullptr; - SLANG_RETURN_NULL_ON_FAIL(getObject(offset, &object)); + ComPtr<IShaderObject> object = nullptr; + SLANG_RETURN_NULL_ON_FAIL(getObject(offset, object.writeRef())); return object; } - virtual slang::TypeLayoutReflection* getElementTypeLayout() = 0; - virtual Slang::Index getEntryPointCount() = 0; - virtual ShaderObject* getEntryPoint(Slang::Index index) = 0; - virtual SlangResult setData(ShaderOffset const& offset, void const* data, size_t size) = 0; - virtual SlangResult getObject(ShaderOffset const& offset, ShaderObject** object) = 0; - virtual SlangResult setObject(ShaderOffset const& offset, ShaderObject* object) = 0; - virtual SlangResult setResource(ShaderOffset const& offset, ResourceView* resourceView) = 0; - virtual SlangResult setSampler(ShaderOffset const& offset, SamplerState* sampler) = 0; - virtual SlangResult setCombinedTextureSampler( - ShaderOffset const& offset, ResourceView* textureView, SamplerState* sampler) = 0; + virtual SLANG_NO_THROW slang::TypeLayoutReflection* SLANG_MCALL getElementTypeLayout() = 0; + virtual SLANG_NO_THROW UInt SLANG_MCALL getEntryPointCount() = 0; + + ComPtr<IShaderObject> getEntryPoint(UInt index) + { + ComPtr<IShaderObject> entryPoint = nullptr; + SLANG_RETURN_NULL_ON_FAIL(getEntryPoint(index, entryPoint.writeRef())); + return entryPoint; + } + virtual SLANG_NO_THROW Result SLANG_MCALL + getEntryPoint(UInt index, IShaderObject** entryPoint) = 0; + virtual SLANG_NO_THROW Result SLANG_MCALL + setData(ShaderOffset const& offset, void const* data, size_t size) = 0; + virtual SLANG_NO_THROW Result SLANG_MCALL + getObject(ShaderOffset const& offset, IShaderObject** object) = 0; + virtual SLANG_NO_THROW Result SLANG_MCALL + setObject(ShaderOffset const& offset, IShaderObject* object) = 0; + virtual SLANG_NO_THROW Result SLANG_MCALL + setResource(ShaderOffset const& offset, IResourceView* resourceView) = 0; + virtual SLANG_NO_THROW Result SLANG_MCALL + setSampler(ShaderOffset const& offset, ISamplerState* sampler) = 0; + virtual SLANG_NO_THROW Result SLANG_MCALL setCombinedTextureSampler( + ShaderOffset const& offset, IResourceView* textureView, ISamplerState* sampler) = 0; }; +#define SLANG_UUID_IShaderObject \ + { \ + 0xc1fa997e, 0x5ca2, 0x45ae, { 0x9b, 0xcb, 0xc4, 0x35, 0x9e, 0x85, 0x5, 0x85 } \ + } + enum class StencilOp : uint8_t { @@ -808,12 +1027,12 @@ struct BlendDesc struct GraphicsPipelineStateDesc { - ShaderProgram* program; + IShaderProgram* program; // Application should set either pipelineLayout or rootShaderObjectLayout, but not both. - PipelineLayout* pipelineLayout = nullptr; + IPipelineLayout* pipelineLayout = nullptr; // Application should set either pipelineLayout or rootShaderObjectLayout, but not both. - ShaderObjectLayout* rootShaderObjectLayout = nullptr; - InputLayout* inputLayout; + IShaderObjectLayout* rootShaderObjectLayout = nullptr; + IInputLayout* inputLayout; UInt framebufferWidth; UInt framebufferHeight; UInt renderTargetCount = 0; // Not used if rootShaderObjectLayout is set. @@ -824,15 +1043,19 @@ struct GraphicsPipelineStateDesc struct ComputePipelineStateDesc { - ShaderProgram* program; - PipelineLayout* pipelineLayout = nullptr; - ShaderObjectLayout* rootShaderObjectLayout = nullptr; + IShaderProgram* program; + IPipelineLayout* pipelineLayout = nullptr; + IShaderObjectLayout* rootShaderObjectLayout = nullptr; }; -class PipelineState : public Slang::RefObject +class IPipelineState : public ISlangUnknown { -public: }; +#define SLANG_UUID_IPipelineState \ + { \ + 0xca7e57d, 0x8a90, 0x44f3, { 0xbd, 0xb1, 0xfe, 0x9b, 0x35, 0x3f, 0x5a, 0x72 } \ + } + struct ScissorRect { @@ -860,194 +1083,199 @@ public: { int width = 0; ///< Width in pixels int height = 0; ///< height in pixels - Slang::String adapter; ///< Name to identify the adapter to use - Slang::List<Slang::String> requiredFeatures; ///< List of required feature names. + const char* adapter = nullptr; ///< Name to identify the adapter to use + int requiredFeatureCount = 0; ///< Number of required features. + const char** requiredFeatures = nullptr; ///< Array of required feature names, whose size is `requiredFeatureCount`. int nvapiExtnSlot = -1; ///< The slot (typically UAV) used to identify NVAPI intrinsics. If >=0 NVAPI is required. }; // Will return with SLANG_E_NOT_AVAILABLE if NVAPI can't be initialized and nvapiExtnSlot >= 0 - virtual SLANG_NO_THROW SlangResult SLANG_MCALL initialize(const Desc& desc, void* inWindowHandle) = 0; + virtual SLANG_NO_THROW Result SLANG_MCALL initialize(const Desc& desc, void* inWindowHandle) = 0; + + virtual SLANG_NO_THROW bool SLANG_MCALL hasFeature(const char* feature) = 0; - bool hasFeature(const Slang::UnownedStringSlice& feature) { return getFeatures().indexOf(Slang::String(feature)) != Slang::Index(-1); } - virtual SLANG_NO_THROW const Slang::List<Slang::String>& SLANG_MCALL getFeatures() = 0; + /// Returns a list of features supported by the renderer. + virtual SLANG_NO_THROW Result SLANG_MCALL getFeatures(const char** outFeatures, UInt bufferSize, UInt* outFeatureCount) = 0; virtual SLANG_NO_THROW void SLANG_MCALL setClearColor(const float color[4]) = 0; virtual SLANG_NO_THROW void SLANG_MCALL clearFrame() = 0; virtual SLANG_NO_THROW void SLANG_MCALL presentFrame() = 0; - virtual SLANG_NO_THROW TextureResource::Desc SLANG_MCALL getSwapChainTextureDesc() = 0; + virtual SLANG_NO_THROW ITextureResource::Desc SLANG_MCALL getSwapChainTextureDesc() = 0; /// Create a texture resource. initData holds the initialize data to set the contents of the texture when constructed. virtual SLANG_NO_THROW Result SLANG_MCALL createTextureResource( - Resource::Usage initialUsage, - const TextureResource::Desc& desc, - const TextureResource::Data* initData, - TextureResource** outResource) = 0; + IResource::Usage initialUsage, + const ITextureResource::Desc& desc, + const ITextureResource::Data* initData, + ITextureResource** outResource) = 0; /// Create a texture resource. initData holds the initialize data to set the contents of the texture when constructed. - inline SLANG_NO_THROW RefPtr<TextureResource> SLANG_MCALL createTextureResource( - Resource::Usage initialUsage, - const TextureResource::Desc& desc, - const TextureResource::Data* initData = nullptr) + inline SLANG_NO_THROW ComPtr<ITextureResource> createTextureResource( + IResource::Usage initialUsage, + const ITextureResource::Desc& desc, + const ITextureResource::Data* initData = nullptr) { - RefPtr<TextureResource> resource; + ComPtr<ITextureResource> resource; SLANG_RETURN_NULL_ON_FAIL(createTextureResource(initialUsage, desc, initData, resource.writeRef())); return resource; } /// Create a buffer resource virtual SLANG_NO_THROW Result SLANG_MCALL createBufferResource( - Resource::Usage initialUsage, - const BufferResource::Desc& desc, + IResource::Usage initialUsage, + const IBufferResource::Desc& desc, const void* initData, - BufferResource** outResource) = 0; + IBufferResource** outResource) = 0; - inline SLANG_NO_THROW RefPtr<BufferResource> SLANG_MCALL createBufferResource( - Resource::Usage initialUsage, - const BufferResource::Desc& desc, + inline SLANG_NO_THROW ComPtr<IBufferResource> createBufferResource( + IResource::Usage initialUsage, + const IBufferResource::Desc& desc, const void* initData = nullptr) { - RefPtr<BufferResource> resource; + ComPtr<IBufferResource> resource; SLANG_RETURN_NULL_ON_FAIL(createBufferResource(initialUsage, desc, initData, resource.writeRef())); return resource; } - virtual SLANG_NO_THROW Result SLANG_MCALL createSamplerState(SamplerState::Desc const& desc, SamplerState** outSampler) = 0; + virtual SLANG_NO_THROW Result SLANG_MCALL + createSamplerState(ISamplerState::Desc const& desc, ISamplerState** outSampler) = 0; - inline RefPtr<SamplerState> createSamplerState(SamplerState::Desc const& desc) + inline ComPtr<ISamplerState> createSamplerState(ISamplerState::Desc const& desc) { - RefPtr<SamplerState> sampler; + ComPtr<ISamplerState> sampler; SLANG_RETURN_NULL_ON_FAIL(createSamplerState(desc, sampler.writeRef())); return sampler; } virtual SLANG_NO_THROW Result SLANG_MCALL createTextureView( - TextureResource* texture, ResourceView::Desc const& desc, ResourceView** outView) = 0; + ITextureResource* texture, IResourceView::Desc const& desc, IResourceView** outView) = 0; - inline RefPtr<ResourceView> createTextureView(TextureResource* texture, ResourceView::Desc const& desc) + inline ComPtr<IResourceView> createTextureView(ITextureResource* texture, IResourceView::Desc const& desc) { - RefPtr<ResourceView> view; + ComPtr<IResourceView> view; SLANG_RETURN_NULL_ON_FAIL(createTextureView(texture, desc, view.writeRef())); return view; } virtual SLANG_NO_THROW Result SLANG_MCALL createBufferView( - BufferResource* buffer, ResourceView::Desc const& desc, ResourceView** outView) = 0; + IBufferResource* buffer, IResourceView::Desc const& desc, IResourceView** outView) = 0; - inline RefPtr<ResourceView> createBufferView(BufferResource* buffer, ResourceView::Desc const& desc) + inline ComPtr<IResourceView> createBufferView(IBufferResource* buffer, IResourceView::Desc const& desc) { - RefPtr<ResourceView> view; + ComPtr<IResourceView> view; SLANG_RETURN_NULL_ON_FAIL(createBufferView(buffer, desc, view.writeRef())); return view; } virtual SLANG_NO_THROW Result SLANG_MCALL createInputLayout( - const InputElementDesc* inputElements, UInt inputElementCount, InputLayout** outLayout) = 0; + const InputElementDesc* inputElements, UInt inputElementCount, IInputLayout** outLayout) = 0; - inline RefPtr<InputLayout> createInputLayout(const InputElementDesc* inputElements, UInt inputElementCount) + inline ComPtr<IInputLayout> createInputLayout(const InputElementDesc* inputElements, UInt inputElementCount) { - RefPtr<InputLayout> layout; + ComPtr<IInputLayout> layout; SLANG_RETURN_NULL_ON_FAIL(createInputLayout(inputElements, inputElementCount, layout.writeRef())); return layout; } virtual SLANG_NO_THROW Result SLANG_MCALL createDescriptorSetLayout( - const DescriptorSetLayout::Desc& desc, DescriptorSetLayout** outLayout) = 0; + const IDescriptorSetLayout::Desc& desc, IDescriptorSetLayout** outLayout) = 0; - inline RefPtr<DescriptorSetLayout> createDescriptorSetLayout(const DescriptorSetLayout::Desc& desc) + inline ComPtr<IDescriptorSetLayout> createDescriptorSetLayout(const IDescriptorSetLayout::Desc& desc) { - RefPtr<DescriptorSetLayout> layout; + ComPtr<IDescriptorSetLayout> layout; SLANG_RETURN_NULL_ON_FAIL(createDescriptorSetLayout(desc, layout.writeRef())); return layout; } virtual SLANG_NO_THROW Result SLANG_MCALL createShaderObjectLayout( - slang::TypeLayoutReflection* typeLayout, ShaderObjectLayout** outLayout) = 0; + slang::TypeLayoutReflection* typeLayout, IShaderObjectLayout** outLayout) = 0; - inline RefPtr<ShaderObjectLayout> createShaderObjectLayout(slang::TypeLayoutReflection* typeLayout) + inline ComPtr<IShaderObjectLayout> createShaderObjectLayout(slang::TypeLayoutReflection* typeLayout) { - RefPtr<ShaderObjectLayout> layout; + ComPtr<IShaderObjectLayout> layout; SLANG_RETURN_NULL_ON_FAIL(createShaderObjectLayout(typeLayout, layout.writeRef())); return layout; } - virtual SLANG_NO_THROW Result SLANG_MCALL createRootShaderObjectLayout(slang::ProgramLayout* layout, ShaderObjectLayout** outLayout) = 0; + virtual SLANG_NO_THROW Result SLANG_MCALL createRootShaderObjectLayout( + slang::ProgramLayout* layout, IShaderObjectLayout** outLayout) = 0; - inline RefPtr<ShaderObjectLayout> createRootShaderObjectLayout(slang::ProgramLayout* layout) + inline ComPtr<IShaderObjectLayout> createRootShaderObjectLayout(slang::ProgramLayout* layout) { - RefPtr<ShaderObjectLayout> result; + ComPtr<IShaderObjectLayout> result; SLANG_RETURN_NULL_ON_FAIL(createRootShaderObjectLayout(layout, result.writeRef())); return result; } - virtual SLANG_NO_THROW Result SLANG_MCALL createShaderObject(ShaderObjectLayout* layout, ShaderObject** outObject) = 0; + virtual SLANG_NO_THROW Result SLANG_MCALL createShaderObject(IShaderObjectLayout* layout, IShaderObject** outObject) = 0; - inline RefPtr<ShaderObject> createShaderObject(ShaderObjectLayout* layout) + inline ComPtr<IShaderObject> createShaderObject(IShaderObjectLayout* layout) { - RefPtr<ShaderObject> object; + ComPtr<IShaderObject> object; SLANG_RETURN_NULL_ON_FAIL(createShaderObject(layout, object.writeRef())); return object; } - virtual SLANG_NO_THROW Result SLANG_MCALL createRootShaderObject(ShaderObjectLayout* layout, ShaderObject** outObject) = 0; + virtual SLANG_NO_THROW Result SLANG_MCALL createRootShaderObject(IShaderObjectLayout* layout, IShaderObject** outObject) = 0; - inline RefPtr<ShaderObject> createRootShaderObject(ShaderObjectLayout* layout) + inline ComPtr<IShaderObject> createRootShaderObject(IShaderObjectLayout* layout) { - RefPtr<ShaderObject> object; + ComPtr<IShaderObject> object; SLANG_RETURN_NULL_ON_FAIL(createRootShaderObject(layout, object.writeRef())); return object; } - virtual SLANG_NO_THROW Result SLANG_MCALL bindRootShaderObject(PipelineType pipelineType, ShaderObject* object) = 0; + virtual SLANG_NO_THROW Result SLANG_MCALL bindRootShaderObject(PipelineType pipelineType, IShaderObject* object) = 0; - virtual SLANG_NO_THROW Result SLANG_MCALL createPipelineLayout(const PipelineLayout::Desc& desc, PipelineLayout** outLayout) = 0; + virtual SLANG_NO_THROW Result SLANG_MCALL createPipelineLayout(const IPipelineLayout::Desc& desc, IPipelineLayout** outLayout) = 0; - inline RefPtr<PipelineLayout> createPipelineLayout(const PipelineLayout::Desc& desc) + inline ComPtr<IPipelineLayout> createPipelineLayout(const IPipelineLayout::Desc& desc) { - RefPtr<PipelineLayout> layout; + ComPtr<IPipelineLayout> layout; SLANG_RETURN_NULL_ON_FAIL(createPipelineLayout(desc, layout.writeRef())); return layout; } - virtual SLANG_NO_THROW Result SLANG_MCALL createDescriptorSet(DescriptorSetLayout* layout, DescriptorSet** outDescriptorSet) = 0; + virtual SLANG_NO_THROW Result SLANG_MCALL createDescriptorSet(IDescriptorSetLayout* layout, IDescriptorSet** outDescriptorSet) = 0; - inline RefPtr<DescriptorSet> createDescriptorSet(DescriptorSetLayout* layout) + inline ComPtr<IDescriptorSet> createDescriptorSet(IDescriptorSetLayout* layout) { - RefPtr<DescriptorSet> descriptorSet; + ComPtr<IDescriptorSet> descriptorSet; SLANG_RETURN_NULL_ON_FAIL(createDescriptorSet(layout, descriptorSet.writeRef())); return descriptorSet; } - virtual SLANG_NO_THROW Result SLANG_MCALL createProgram(const ShaderProgram::Desc& desc, ShaderProgram** outProgram) = 0; + virtual SLANG_NO_THROW Result SLANG_MCALL createProgram(const IShaderProgram::Desc& desc, IShaderProgram** outProgram) = 0; - inline RefPtr<ShaderProgram> createProgram(const ShaderProgram::Desc& desc) + inline ComPtr<IShaderProgram> createProgram(const IShaderProgram::Desc& desc) { - RefPtr<ShaderProgram> program; + ComPtr<IShaderProgram> program; SLANG_RETURN_NULL_ON_FAIL(createProgram(desc, program.writeRef())); return program; } virtual SLANG_NO_THROW Result SLANG_MCALL createGraphicsPipelineState( const GraphicsPipelineStateDesc& desc, - PipelineState** outState) = 0; + IPipelineState** outState) = 0; - inline RefPtr<PipelineState> createGraphicsPipelineState( + inline ComPtr<IPipelineState> createGraphicsPipelineState( const GraphicsPipelineStateDesc& desc) { - RefPtr<PipelineState> state; + ComPtr<IPipelineState> state; SLANG_RETURN_NULL_ON_FAIL(createGraphicsPipelineState(desc, state.writeRef())); return state; } virtual SLANG_NO_THROW Result SLANG_MCALL createComputePipelineState( const ComputePipelineStateDesc& desc, - PipelineState** outState) = 0; + IPipelineState** outState) = 0; - inline RefPtr<PipelineState> createComputePipelineState( + inline ComPtr<IPipelineState> createComputePipelineState( const ComputePipelineStateDesc& desc) { - RefPtr<PipelineState> state; + ComPtr<IPipelineState> state; SLANG_RETURN_NULL_ON_FAIL(createComputePipelineState(desc, state.writeRef())); return state; } @@ -1055,28 +1283,29 @@ public: /// Captures the back buffer and stores the result in surfaceOut. If the surface contains data - it will either be overwritten (if same size and format), or freed and a re-allocated. virtual SLANG_NO_THROW SlangResult SLANG_MCALL captureScreenSurface(Surface& surfaceOut) = 0; - virtual SLANG_NO_THROW void* SLANG_MCALL map(BufferResource* buffer, MapFlavor flavor) = 0; - virtual SLANG_NO_THROW void SLANG_MCALL unmap(BufferResource* buffer) = 0; + virtual SLANG_NO_THROW void* SLANG_MCALL map(IBufferResource* buffer, MapFlavor flavor) = 0; + virtual SLANG_NO_THROW void SLANG_MCALL unmap(IBufferResource* buffer) = 0; virtual SLANG_NO_THROW void SLANG_MCALL setPrimitiveTopology(PrimitiveTopology topology) = 0; virtual SLANG_NO_THROW void SLANG_MCALL setDescriptorSet( PipelineType pipelineType, - PipelineLayout* layout, + IPipelineLayout* layout, UInt index, - DescriptorSet* descriptorSet) = 0; + IDescriptorSet* descriptorSet) = 0; virtual SLANG_NO_THROW void SLANG_MCALL setVertexBuffers( UInt startSlot, UInt slotCount, - BufferResource* const* buffers, + IBufferResource* const* buffers, const UInt* strides, const UInt* offsets) = 0; - inline void setVertexBuffer(UInt slot, BufferResource* buffer, UInt stride, UInt offset = 0); + inline void setVertexBuffer(UInt slot, IBufferResource* buffer, UInt stride, UInt offset = 0); - virtual SLANG_NO_THROW void SLANG_MCALL setIndexBuffer(BufferResource* buffer, Format indexFormat, UInt offset = 0) = 0; + virtual SLANG_NO_THROW void SLANG_MCALL + setIndexBuffer(IBufferResource* buffer, Format indexFormat, UInt offset = 0) = 0; - virtual SLANG_NO_THROW void SLANG_MCALL setDepthStencilTarget(ResourceView* depthStencilView) = 0; + virtual SLANG_NO_THROW void SLANG_MCALL setDepthStencilTarget(IResourceView* depthStencilView) = 0; virtual SLANG_NO_THROW void SLANG_MCALL setViewports(UInt count, Viewport const* viewports) = 0; inline void setViewport(Viewport const& viewport) @@ -1090,7 +1319,7 @@ public: setScissorRects(1, &rect); } - virtual SLANG_NO_THROW void SLANG_MCALL setPipelineState(PipelineType pipelineType, PipelineState* state) = 0; + virtual SLANG_NO_THROW void SLANG_MCALL setPipelineState(PipelineType pipelineType, IPipelineState* state) = 0; virtual SLANG_NO_THROW void SLANG_MCALL draw(UInt vertexCount, UInt startVertex = 0) = 0; virtual SLANG_NO_THROW void SLANG_MCALL drawIndexed(UInt indexCount, UInt startIndex = 0, UInt baseVertex = 0) = 0; @@ -1113,37 +1342,36 @@ public: } // ---------------------------------------------------------------------------------------- -inline void IRenderer::setVertexBuffer(UInt slot, BufferResource* buffer, UInt stride, UInt offset) +inline void IRenderer::setVertexBuffer(UInt slot, IBufferResource* buffer, UInt stride, UInt offset) { setVertexBuffers(slot, 1, &buffer, &stride, &offset); } -/// Functions that are around Renderer and it's types -struct RendererUtil +// Global public functions + +extern "C" { - typedef SlangResult (*CreateFunc)(IRenderer** outRenderer); + typedef SlangResult(SLANG_MCALL * SGRendererCreateFunc)(IRenderer** outRenderer); - /// Gets the size in bytes of a Format type. Returns 0 if a size is not defined/invalid - SLANG_FORCE_INLINE static size_t getFormatSize(Format format) { return s_formatSize[int(format)]; } - /// Given a renderer type, gets a projection style - static ProjectionStyle getProjectionStyle(RendererType type); + /// Gets the size in bytes of a Format type. Returns 0 if a size is not defined/invalid + SLANG_GFX_API size_t SLANG_MCALL gfxGetFormatSize(Format format); - /// Given the projection style returns an 'identity' matrix, which ensures x,y mapping to pixels is the same on all targets - static void getIdentityProjection(ProjectionStyle style, float projMatrix[16]); + /// Gets the binding style from the type + SLANG_GFX_API BindingStyle SLANG_MCALL gfxGetBindingStyle(RendererType type); - /// Get the binding style from the type - static BindingStyle getBindingStyle(RendererType type) { return s_rendererTypeToBindingStyle[int(type)]; } + /// Given a renderer type, gets a projection style + SLANG_GFX_API ProjectionStyle SLANG_MCALL gfxGetProjectionStyle(RendererType type); - /// Get as text - static Slang::UnownedStringSlice toText(RendererType type); + /// Given the projection style returns an 'identity' matrix, which ensures x,y mapping to pixels + /// is the same on all targets + SLANG_GFX_API void SLANG_MCALL + gfxGetIdentityProjection(ProjectionStyle style, float projMatrix[16]); - /// Given a type returns a function that can construct it, or nullptr if there isn't one - static CreateFunc getCreateFunc(RendererType type); + /// Get the name of the renderer + SLANG_GFX_API const char* SLANG_MCALL gfxGetRendererName(RendererType type); - private: - static void compileTimeAsserts(); - static const uint8_t s_formatSize[]; // Maps Format::XXX to a size in bytes; - static const BindingStyle s_rendererTypeToBindingStyle[]; ///< Maps a RendererType to a BindingStyle -}; + /// Given a type returns a function that can construct it, or nullptr if there isn't one + SLANG_GFX_API SGRendererCreateFunc SLANG_MCALL gfxGetCreateFunc(RendererType type); +} -} // renderer_test +}// renderer_test diff --git a/tools/gfx/renderer-shared.cpp b/tools/gfx/renderer-shared.cpp new file mode 100644 index 000000000..94154bc42 --- /dev/null +++ b/tools/gfx/renderer-shared.cpp @@ -0,0 +1,31 @@ +#include "renderer-shared.h" +#include "render-graphics-common.h" + +namespace gfx +{ + +IResource* BufferResource::getInterface(const Slang::Guid& guid) +{ + if (guid == GfxGUID::IID_ISlangUnknown || guid == GfxGUID::IID_IResource || + guid == GfxGUID::IID_IBufferResource) + return static_cast<IBufferResource*>(this); + return nullptr; +} + +SLANG_NO_THROW IResource::Type SLANG_MCALL BufferResource::getType() { return m_type; } +SLANG_NO_THROW IBufferResource::Desc* SLANG_MCALL BufferResource::getDesc() { return &m_desc; } + + +IResource* TextureResource::getInterface(const Slang::Guid& guid) +{ + if (guid == GfxGUID::IID_ISlangUnknown || guid == GfxGUID::IID_IResource || + guid == GfxGUID::IID_ITextureResource) + return static_cast<ITextureResource*>(this); + return nullptr; +} + +SLANG_NO_THROW IResource::Type SLANG_MCALL TextureResource::getType() { return m_type; } +SLANG_NO_THROW ITextureResource::Desc* SLANG_MCALL TextureResource::getDesc() { return &m_desc; } + + +} // namespace gfx diff --git a/tools/gfx/renderer-shared.h b/tools/gfx/renderer-shared.h new file mode 100644 index 000000000..47cc9328d --- /dev/null +++ b/tools/gfx/renderer-shared.h @@ -0,0 +1,70 @@ +#pragma once + +#include "tools/gfx/render.h" + +#include "core/slang-smart-pointer.h" + +namespace gfx +{ + +class Resource : public Slang::RefObject +{ +public: + /// Get the type + SLANG_FORCE_INLINE IResource::Type getType() const { return m_type; } + /// True if it's a texture derived type + SLANG_FORCE_INLINE bool isTexture() const { return int(m_type) >= int(IResource::Type::Texture1D); } + /// True if it's a buffer derived type + SLANG_FORCE_INLINE bool isBuffer() const { return m_type == IResource::Type::Buffer; } +protected: + Resource(IResource::Type type) + : m_type(type) + {} + + IResource::Type m_type; +}; + +class BufferResource : public IBufferResource, public Resource +{ +public: + SLANG_REF_OBJECT_IUNKNOWN_ALL + IResource* getInterface(const Slang::Guid& guid); + +public: + typedef Resource Parent; + + /// Ctor + BufferResource(const Desc& desc) + : Parent(Type::Buffer) + , m_desc(desc) + {} + + virtual SLANG_NO_THROW IResource::Type SLANG_MCALL getType() SLANG_OVERRIDE; + virtual SLANG_NO_THROW IBufferResource::Desc* SLANG_MCALL getDesc() SLANG_OVERRIDE; + +protected: + Desc m_desc; +}; + +class TextureResource : public ITextureResource, public Resource +{ +public: + SLANG_REF_OBJECT_IUNKNOWN_ALL + IResource* getInterface(const Slang::Guid& guid); + +public: + typedef Resource Parent; + + /// Ctor + TextureResource(const Desc& desc) + : Parent(desc.type) + , m_desc(desc) + {} + + virtual SLANG_NO_THROW IResource::Type SLANG_MCALL getType() SLANG_OVERRIDE; + virtual SLANG_NO_THROW ITextureResource::Desc* SLANG_MCALL getDesc() SLANG_OVERRIDE; + +protected: + Desc m_desc; +}; +} diff --git a/tools/gfx/shader-cursor.cpp b/tools/gfx/shader-cursor.cpp index c4a9ac607..65cf2f8ac 100644 --- a/tools/gfx/shader-cursor.cpp +++ b/tools/gfx/shader-cursor.cpp @@ -13,7 +13,7 @@ Result gfx::ShaderCursor::getDereferenced(ShaderCursor& outCursor) const case slang::TypeReflection::Kind::ConstantBuffer: case slang::TypeReflection::Kind::ParameterBlock: { - ShaderObject* subObject = m_baseObject->getObject(m_offset); + auto subObject = m_baseObject->getObject(m_offset); outCursor = ShaderCursor(subObject); return SLANG_OK; } diff --git a/tools/gfx/shader-cursor.h b/tools/gfx/shader-cursor.h index 8f48f3581..82794be9a 100644 --- a/tools/gfx/shader-cursor.h +++ b/tools/gfx/shader-cursor.h @@ -25,7 +25,7 @@ namespace gfx /// struct ShaderCursor { - ShaderObject* m_baseObject = nullptr; + IShaderObject* m_baseObject = nullptr; slang::TypeLayoutReflection* m_typeLayout = nullptr; ShaderOffset m_offset; @@ -90,7 +90,7 @@ struct ShaderCursor ShaderCursor() {} - ShaderCursor(ShaderObject* object) + ShaderCursor(IShaderObject* object) : m_baseObject(object) , m_typeLayout(object->getElementTypeLayout()) {} @@ -100,22 +100,22 @@ struct ShaderCursor return m_baseObject->setData(m_offset, data, size); } - SlangResult setObject(ShaderObject* object) + SlangResult setObject(IShaderObject* object) { return m_baseObject->setObject(m_offset, object); } - SlangResult setResource(ResourceView* resourceView) + SlangResult setResource(IResourceView* resourceView) { return m_baseObject->setResource(m_offset, resourceView); } - SlangResult setSampler(SamplerState* sampler) + SlangResult setSampler(ISamplerState* sampler) { return m_baseObject->setSampler(m_offset, sampler); } - SlangResult setCombinedTextureSampler(ResourceView* textureView, SamplerState* sampler) + SlangResult setCombinedTextureSampler(IResourceView* textureView, ISamplerState* sampler) { return m_baseObject->setCombinedTextureSampler(m_offset, textureView, sampler); } diff --git a/tools/gfx/slang-gfx-helper.cpp b/tools/gfx/slang-gfx-helper.cpp new file mode 100644 index 000000000..499e462b0 --- /dev/null +++ b/tools/gfx/slang-gfx-helper.cpp @@ -0,0 +1,6 @@ +#include "slang-gfx-helper.h" +#include "renderer-shared.h" + +namespace gfx +{ +} // namespace gfx diff --git a/tools/gfx/slang-gfx-helper.h b/tools/gfx/slang-gfx-helper.h new file mode 100644 index 000000000..1cd3fe64c --- /dev/null +++ b/tools/gfx/slang-gfx-helper.h @@ -0,0 +1,9 @@ +#pragma once + +#include "render.h" + +namespace gfx +{ + + +} diff --git a/tools/gfx/surface.cpp b/tools/gfx/surface.cpp index 28fe744de..636881fca 100644 --- a/tools/gfx/surface.cpp +++ b/tools/gfx/surface.cpp @@ -3,6 +3,7 @@ #include <stdlib.h> #include <stdio.h> +#include <string.h> #include "../../source/core/slang-list.h" @@ -72,7 +73,7 @@ void MallocSurfaceAllocator::deallocate(Surface& surface) /* static */int Surface::calcRowSize(Format format, int width) { - size_t pixelSize = RendererUtil::getFormatSize(format); + size_t pixelSize = gfxGetFormatSize(format); if (pixelSize == 0) { return 0; diff --git a/tools/gfx/vulkan/render-vk.cpp b/tools/gfx/vulkan/render-vk.cpp index 3cd10902b..c2a1e36bf 100644 --- a/tools/gfx/vulkan/render-vk.cpp +++ b/tools/gfx/vulkan/render-vk.cpp @@ -2,10 +2,10 @@ #include "render-vk.h" //WORKING:#include "options.h" -#include "../render.h" +#include "../renderer-shared.h" #include "../render-graphics-common.h" -#include "core/slang-smart-pointer.h" +#include "core/slang-basic.h" #include "vk-api.h" #include "vk-util.h" @@ -43,84 +43,80 @@ public: // Renderer implementation virtual SLANG_NO_THROW SlangResult SLANG_MCALL initialize(const Desc& desc, void* inWindowHandle) override; - virtual SLANG_NO_THROW const List<String>& SLANG_MCALL getFeatures() override - { - return m_features; - } virtual SLANG_NO_THROW void SLANG_MCALL setClearColor(const float color[4]) override; virtual SLANG_NO_THROW void SLANG_MCALL clearFrame() override; virtual SLANG_NO_THROW void SLANG_MCALL presentFrame() override; virtual SLANG_NO_THROW TextureResource::Desc SLANG_MCALL getSwapChainTextureDesc() override; virtual SLANG_NO_THROW Result SLANG_MCALL createTextureResource( - Resource::Usage initialUsage, - const TextureResource::Desc& desc, - const TextureResource::Data* initData, - TextureResource** outResource) override; + IResource::Usage initialUsage, + const ITextureResource::Desc& desc, + const ITextureResource::Data* initData, + ITextureResource** outResource) override; virtual SLANG_NO_THROW Result SLANG_MCALL createBufferResource( - Resource::Usage initialUsage, - const BufferResource::Desc& desc, + IResource::Usage initialUsage, + const IBufferResource::Desc& desc, const void* initData, - BufferResource** outResource) override; + IBufferResource** outResource) override; virtual SLANG_NO_THROW Result SLANG_MCALL - createSamplerState(SamplerState::Desc const& desc, SamplerState** outSampler) override; + createSamplerState(ISamplerState::Desc const& desc, ISamplerState** outSampler) override; virtual SLANG_NO_THROW Result SLANG_MCALL createTextureView( - TextureResource* texture, ResourceView::Desc const& desc, ResourceView** outView) override; + ITextureResource* texture, IResourceView::Desc const& desc, IResourceView** outView) override; virtual SLANG_NO_THROW Result SLANG_MCALL createBufferView( - BufferResource* buffer, ResourceView::Desc const& desc, ResourceView** outView) override; + IBufferResource* buffer, IResourceView::Desc const& desc, IResourceView** outView) override; virtual SLANG_NO_THROW Result SLANG_MCALL createInputLayout( const InputElementDesc* inputElements, UInt inputElementCount, - InputLayout** outLayout) override; + IInputLayout** outLayout) override; virtual SLANG_NO_THROW Result SLANG_MCALL createDescriptorSetLayout( - const DescriptorSetLayout::Desc& desc, - DescriptorSetLayout** outLayout) override; + const IDescriptorSetLayout::Desc& desc, + IDescriptorSetLayout** outLayout) override; virtual SLANG_NO_THROW Result SLANG_MCALL - createPipelineLayout(const PipelineLayout::Desc& desc, PipelineLayout** outLayout) override; + createPipelineLayout(const IPipelineLayout::Desc& desc, IPipelineLayout** outLayout) override; virtual SLANG_NO_THROW Result SLANG_MCALL - createDescriptorSet(DescriptorSetLayout* layout, DescriptorSet** outDescriptorSet) override; + createDescriptorSet(IDescriptorSetLayout* layout, IDescriptorSet** outDescriptorSet) override; virtual SLANG_NO_THROW Result SLANG_MCALL - createProgram(const ShaderProgram::Desc& desc, ShaderProgram** outProgram) override; + createProgram(const IShaderProgram::Desc& desc, IShaderProgram** outProgram) override; virtual SLANG_NO_THROW Result SLANG_MCALL createGraphicsPipelineState( const GraphicsPipelineStateDesc& desc, - PipelineState** outState) override; + IPipelineState** outState) override; virtual SLANG_NO_THROW Result SLANG_MCALL createComputePipelineState( const ComputePipelineStateDesc& desc, - PipelineState** outState) override; + IPipelineState** outState) override; virtual SLANG_NO_THROW SlangResult SLANG_MCALL captureScreenSurface(Surface& surface) override; - virtual SLANG_NO_THROW void* SLANG_MCALL map(BufferResource* buffer, MapFlavor flavor) override; - virtual SLANG_NO_THROW void SLANG_MCALL unmap(BufferResource* buffer) override; + virtual SLANG_NO_THROW void* SLANG_MCALL map(IBufferResource* buffer, MapFlavor flavor) override; + virtual SLANG_NO_THROW void SLANG_MCALL unmap(IBufferResource* buffer) override; virtual SLANG_NO_THROW void SLANG_MCALL setPrimitiveTopology(PrimitiveTopology topology) override; virtual SLANG_NO_THROW void SLANG_MCALL setDescriptorSet( PipelineType pipelineType, - PipelineLayout* layout, + IPipelineLayout* layout, UInt index, - DescriptorSet* descriptorSet) override; + IDescriptorSet* descriptorSet) override; virtual SLANG_NO_THROW void SLANG_MCALL setVertexBuffers( UInt startSlot, UInt slotCount, - BufferResource* const* buffers, + IBufferResource* const* buffers, const UInt* strides, const UInt* offsets) override; virtual SLANG_NO_THROW void SLANG_MCALL - setIndexBuffer(BufferResource* buffer, Format indexFormat, UInt offset) override; + setIndexBuffer(IBufferResource* buffer, Format indexFormat, UInt offset) override; virtual SLANG_NO_THROW void SLANG_MCALL - setDepthStencilTarget(ResourceView* depthStencilView) override; + setDepthStencilTarget(IResourceView* depthStencilView) override; virtual SLANG_NO_THROW void SLANG_MCALL setViewports(UInt count, Viewport const* viewports) override; virtual SLANG_NO_THROW void SLANG_MCALL setScissorRects(UInt count, ScissorRect const* rects) override; virtual SLANG_NO_THROW void SLANG_MCALL - setPipelineState(PipelineType pipelineType, PipelineState* state) override; + setPipelineState(PipelineType pipelineType, IPipelineState* state) override; virtual SLANG_NO_THROW void SLANG_MCALL draw(UInt vertexCount, UInt startVertex) override; virtual SLANG_NO_THROW void SLANG_MCALL drawIndexed(UInt indexCount, UInt startIndex, UInt baseVertex) override; @@ -169,8 +165,16 @@ public: const VulkanApi* m_api; }; - class InputLayoutImpl : public InputLayout - { + class InputLayoutImpl : public IInputLayout, public RefObject + { + public: + SLANG_REF_OBJECT_IUNKNOWN_ALL + IInputLayout* getInterface(const Guid& guid) + { + if (guid == GfxGUID::IID_ISlangUnknown || guid == GfxGUID::IID_IInputLayout) + return static_cast<IInputLayout*>(this); + return nullptr; + } public: List<VkVertexInputAttributeDescription> m_vertexDescs; int m_vertexSize; @@ -181,7 +185,7 @@ public: public: typedef BufferResource Parent; - BufferResourceImpl(Resource::Usage initialUsage, const BufferResource::Desc& desc, VKRenderer* renderer): + BufferResourceImpl(IResource::Usage initialUsage, const IBufferResource::Desc& desc, VKRenderer* renderer): Parent(desc), m_renderer(renderer), m_initialUsage(initialUsage) @@ -189,7 +193,7 @@ public: assert(renderer); } - Resource::Usage m_initialUsage; + IResource::Usage m_initialUsage; VKRenderer* m_renderer; Buffer m_buffer; Buffer m_uploadBuffer; @@ -232,15 +236,31 @@ public: const VulkanApi* m_api; }; - class SamplerStateImpl : public SamplerState + class SamplerStateImpl : public ISamplerState, public RefObject { public: + SLANG_REF_OBJECT_IUNKNOWN_ALL + ISamplerState* getInterface(const Guid& guid) + { + if (guid == GfxGUID::IID_ISlangUnknown || guid == GfxGUID::IID_ISamplerState) + return static_cast<ISamplerState*>(this); + return nullptr; + } + public: VkSampler m_sampler; }; - class ResourceViewImpl : public ResourceView + class ResourceViewImpl : public IResourceView, public RefObject { public: + SLANG_REF_OBJECT_IUNKNOWN_ALL + IResourceView* getInterface(const Guid& guid) + { + if (guid == GfxGUID::IID_ISlangUnknown || guid == GfxGUID::IID_IResourceView) + return static_cast<IResourceView*>(this); + return nullptr; + } + public: enum class ViewType { Texture, @@ -288,9 +308,17 @@ public: VkDeviceSize size; }; - class ShaderProgramImpl: public ShaderProgram + class ShaderProgramImpl: public IShaderProgram, public RefObject { - public: + public: + SLANG_REF_OBJECT_IUNKNOWN_ALL + IShaderProgram* getInterface(const Guid& guid) + { + if (guid == GfxGUID::IID_ISlangUnknown || guid == GfxGUID::IID_IShaderProgram) + return static_cast<IShaderProgram*>(this); + return nullptr; + } + public: ShaderProgramImpl(const VulkanApi& api, PipelineType pipelineType): m_api(&api), @@ -322,9 +350,17 @@ public: VkShaderModule m_modules[2]; }; - class DescriptorSetLayoutImpl : public DescriptorSetLayout + class DescriptorSetLayoutImpl : public IDescriptorSetLayout, public RefObject { public: + SLANG_REF_OBJECT_IUNKNOWN_ALL + IDescriptorSetLayout* getInterface(const Guid& guid) + { + if (guid == GfxGUID::IID_ISlangUnknown || guid == GfxGUID::IID_IDescriptorSetLayout) + return static_cast<IDescriptorSetLayout*>(this); + return nullptr; + } + public: DescriptorSetLayoutImpl(const VulkanApi& api) : m_api(&api) { @@ -399,9 +435,19 @@ public: Index m_totalBoundObjectCount = 0; }; - class PipelineLayoutImpl : public PipelineLayout + class PipelineLayoutImpl : public IPipelineLayout, public RefObject { public: + SLANG_REF_OBJECT_IUNKNOWN_ALL + IPipelineLayout* getInterface(const Guid& guid) + { + if (guid == GfxGUID::IID_ISlangUnknown || guid == GfxGUID::IID_IPipelineLayout) + { + return static_cast<IPipelineLayout*>(this); + } + return nullptr; + } + public: PipelineLayoutImpl(const VulkanApi& api) : m_api(&api) { @@ -423,9 +469,17 @@ public: List<uint32_t> m_descriptorSetRootConstantOffsets; }; - class DescriptorSetImpl : public DescriptorSet + class DescriptorSetImpl : public IDescriptorSet, public RefObject { public: + SLANG_REF_OBJECT_IUNKNOWN_ALL + IDescriptorSet* getInterface(const Guid& guid) + { + if (guid == GfxGUID::IID_ISlangUnknown || guid == GfxGUID::IID_IDescriptorSet) + return static_cast<IDescriptorSet*>(this); + return nullptr; + } + public: DescriptorSetImpl(VKRenderer* renderer) : m_renderer(renderer) { @@ -435,15 +489,18 @@ public: { } - virtual void setConstantBuffer(UInt range, UInt index, BufferResource* buffer) override; - virtual void setResource(UInt range, UInt index, ResourceView* view) override; - virtual void setSampler(UInt range, UInt index, SamplerState* sampler) override; - virtual void setCombinedTextureSampler( + virtual SLANG_NO_THROW void SLANG_MCALL setConstantBuffer(UInt range, UInt index, IBufferResource* buffer) override; + virtual SLANG_NO_THROW void SLANG_MCALL + setResource(UInt range, UInt index, IResourceView* view) override; + virtual SLANG_NO_THROW void SLANG_MCALL + setSampler(UInt range, UInt index, ISamplerState* sampler) override; + virtual SLANG_NO_THROW void SLANG_MCALL setCombinedTextureSampler( UInt range, UInt index, - ResourceView* textureView, - SamplerState* sampler) override; - virtual void setRootConstants( + IResourceView* textureView, + ISamplerState* sampler) override; + virtual SLANG_NO_THROW void SLANG_MCALL + setRootConstants( UInt range, UInt offset, UInt size, @@ -467,9 +524,17 @@ public: int m_offset; }; - class PipelineStateImpl : public PipelineState + class PipelineStateImpl : public IPipelineState, public RefObject { public: + SLANG_REF_OBJECT_IUNKNOWN_ALL + IPipelineState* getInterface(const Guid& guid) + { + if (guid == GfxGUID::IID_ISlangUnknown || guid == GfxGUID::IID_IPipelineState) + return static_cast<IPipelineState*>(this); + return nullptr; + } + public: PipelineStateImpl(const VulkanApi& api): m_api(&api) { @@ -497,7 +562,7 @@ public: /// Note that the outShaderModule value should be cleaned up when no longer needed by caller /// via vkShaderModuleDestroy() VkPipelineShaderStageCreateInfo compileEntryPoint( - ShaderProgram::KernelDesc const& kernelDesc, + IShaderProgram::KernelDesc const& kernelDesc, VkShaderStageFlagBits stage, List<char>& outBuffer, VkShaderModule& outShaderModule); @@ -550,7 +615,6 @@ public: float m_clearColor[4] = { 0, 0, 0, 0 }; Desc m_desc; - List<String> m_features; }; /* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! VkRenderer::Buffer !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! */ @@ -858,7 +922,7 @@ void VKRenderer::_endRender() m_deviceQueue.flush(); } -SlangResult createVKRenderer(IRenderer** outRenderer) +Result SLANG_MCALL createVKRenderer(IRenderer** outRenderer) { *outRenderer = new VKRenderer(); (*outRenderer)->addRef(); @@ -941,7 +1005,7 @@ VkBool32 VKRenderer::handleDebugMessage(VkDebugReportFlagsEXT flags, VkDebugRepo } VkPipelineShaderStageCreateInfo VKRenderer::compileEntryPoint( - ShaderProgram::KernelDesc const& kernelDesc, + IShaderProgram::KernelDesc const& kernelDesc, VkShaderStageFlagBits stage, List<char>& outBuffer, VkShaderModule& outShaderModule) @@ -1085,11 +1149,11 @@ SlangResult VKRenderer::initialize(const Desc& desc, void* inWindowHandle) Index selectedDeviceIndex = 0; - if (desc.adapter.getLength()) + if (desc.adapter) { selectedDeviceIndex = -1; - String lowerAdapter = desc.adapter.toLower(); + String lowerAdapter = String(desc.adapter).toLower(); for (Index i = 0; i < physicalDevices.getCount(); ++i) { @@ -1371,7 +1435,7 @@ void VKRenderer::presentFrame() TextureResource::Desc VKRenderer::getSwapChainTextureDesc() { TextureResource::Desc desc; - desc.init2D(Resource::Type::Texture2D, Format::Unknown, m_desc.width, m_desc.height, 1); + desc.init2D(IResource::Type::Texture2D, Format::Unknown, m_desc.width, m_desc.height, 1); return desc; } @@ -1380,9 +1444,9 @@ SlangResult VKRenderer::captureScreenSurface(Surface& surfaceOut) return SLANG_FAIL; } -static VkBufferUsageFlagBits _calcBufferUsageFlags(Resource::BindFlag::Enum bind) +static VkBufferUsageFlagBits _calcBufferUsageFlags(IResource::BindFlag::Enum bind) { - typedef Resource::BindFlag BindFlag; + typedef IResource::BindFlag BindFlag; switch (bind) { @@ -1409,7 +1473,7 @@ static VkBufferUsageFlagBits _calcBufferUsageFlags(int bindFlags) while (bindFlags) { int lsb = bindFlags & -bindFlags; - dstFlags |= _calcBufferUsageFlags(Resource::BindFlag::Enum(lsb)); + dstFlags |= _calcBufferUsageFlags(IResource::BindFlag::Enum(lsb)); bindFlags &= ~lsb; } return VkBufferUsageFlagBits(dstFlags); @@ -1419,12 +1483,12 @@ static VkBufferUsageFlags _calcBufferUsageFlags(int bindFlags, int cpuAccessFlag { VkBufferUsageFlags usage = _calcBufferUsageFlags(bindFlags); - if (cpuAccessFlags & Resource::AccessFlag::Read) + if (cpuAccessFlags & IResource::AccessFlag::Read) { // If it can be read from, set this usage |= VK_BUFFER_USAGE_TRANSFER_SRC_BIT; } - if ((cpuAccessFlags & Resource::AccessFlag::Write) || initData) + if ((cpuAccessFlags & IResource::AccessFlag::Write) || initData) { usage |= VK_BUFFER_USAGE_TRANSFER_DST_BIT; } @@ -1432,9 +1496,9 @@ static VkBufferUsageFlags _calcBufferUsageFlags(int bindFlags, int cpuAccessFlag return usage; } -static VkImageUsageFlagBits _calcImageUsageFlags(Resource::BindFlag::Enum bind) +static VkImageUsageFlagBits _calcImageUsageFlags(IResource::BindFlag::Enum bind) { - typedef Resource::BindFlag BindFlag; + typedef IResource::BindFlag BindFlag; switch (bind) { @@ -1460,7 +1524,7 @@ static VkImageUsageFlagBits _calcImageUsageFlags(int bindFlags) while (bindFlags) { int lsb = bindFlags & -bindFlags; - dstFlags |= _calcImageUsageFlags(Resource::BindFlag::Enum(lsb)); + dstFlags |= _calcImageUsageFlags(IResource::BindFlag::Enum(lsb)); bindFlags &= ~lsb; } return VkImageUsageFlagBits(dstFlags); @@ -1472,12 +1536,12 @@ static VkImageUsageFlags _calcImageUsageFlags(int bindFlags, int cpuAccessFlags, usage |= VK_IMAGE_USAGE_SAMPLED_BIT; - if (cpuAccessFlags & Resource::AccessFlag::Read) + if (cpuAccessFlags & IResource::AccessFlag::Read) { // If it can be read from, set this usage |= VK_IMAGE_USAGE_TRANSFER_SRC_BIT; } - if ((cpuAccessFlags & Resource::AccessFlag::Write) || initData) + if ((cpuAccessFlags & IResource::AccessFlag::Write) || initData) { usage |= VK_IMAGE_USAGE_TRANSFER_DST_BIT; } @@ -1530,7 +1594,7 @@ void VKRenderer::_transitionImageLayout(VkImage image, VkFormat format, const Te m_api.vkCmdPipelineBarrier(commandBuffer, sourceStage, destinationStage, 0, 0, nullptr, 0, nullptr, 1, &barrier); } -Result VKRenderer::createTextureResource(Resource::Usage initialUsage, const TextureResource::Desc& descIn, const TextureResource::Data* initData, TextureResource** outResource) +Result VKRenderer::createTextureResource(IResource::Usage initialUsage, const ITextureResource::Desc& descIn, const ITextureResource::Data* initData, ITextureResource** outResource) { TextureResource::Desc desc(descIn); desc.setDefaults(initialUsage); @@ -1552,25 +1616,25 @@ Result VKRenderer::createTextureResource(Resource::Usage initialUsage, const Tex switch (desc.type) { - case Resource::Type::Texture1D: + case IResource::Type::Texture1D: { imageInfo.imageType = VK_IMAGE_TYPE_1D; imageInfo.extent = VkExtent3D{ uint32_t(descIn.size.width), 1, 1 }; break; } - case Resource::Type::Texture2D: + case IResource::Type::Texture2D: { imageInfo.imageType = VK_IMAGE_TYPE_2D; imageInfo.extent = VkExtent3D{ uint32_t(descIn.size.width), uint32_t(descIn.size.height), 1 }; break; } - case Resource::Type::TextureCube: + case IResource::Type::TextureCube: { imageInfo.imageType = VK_IMAGE_TYPE_2D; imageInfo.extent = VkExtent3D{ uint32_t(descIn.size.width), uint32_t(descIn.size.height), 1 }; break; } - case Resource::Type::Texture3D: + case IResource::Type::Texture3D: { // Can't have an array and 3d texture assert(desc.arraySize <= 1); @@ -1694,7 +1758,7 @@ Result VKRenderer::createTextureResource(Resource::Usage initialUsage, const Tex m_api.vkUnmapMemory(m_device, uploadBuffer.m_memory); } - _transitionImageLayout(texture->m_image, format, texture->getDesc(), VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL); + _transitionImageLayout(texture->m_image, format, *texture->getDesc(), VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL); { size_t srcOffset = 0; @@ -1734,7 +1798,7 @@ Result VKRenderer::createTextureResource(Resource::Usage initialUsage, const Tex } } - _transitionImageLayout(texture->m_image, format, texture->getDesc(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL); + _transitionImageLayout(texture->m_image, format, *texture->getDesc(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL); m_deviceQueue.flushAndWait(); } @@ -1743,7 +1807,7 @@ Result VKRenderer::createTextureResource(Resource::Usage initialUsage, const Tex return SLANG_OK; } -Result VKRenderer::createBufferResource(Resource::Usage initialUsage, const BufferResource::Desc& descIn, const void* initData, BufferResource** outResource) +Result VKRenderer::createBufferResource(IResource::Usage initialUsage, const IBufferResource::Desc& descIn, const void* initData, IBufferResource** outResource) { BufferResource::Desc desc(descIn); desc.setDefaults(initialUsage); @@ -1756,7 +1820,7 @@ Result VKRenderer::createBufferResource(Resource::Usage initialUsage, const Buff switch (initialUsage) { - case Resource::Usage::ConstantBuffer: + case IResource::Usage::ConstantBuffer: { reqMemoryProperties = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT; break; @@ -1767,7 +1831,7 @@ Result VKRenderer::createBufferResource(Resource::Usage initialUsage, const Buff RefPtr<BufferResourceImpl> buffer(new BufferResourceImpl(initialUsage, desc, this)); SLANG_RETURN_ON_FAIL(buffer->m_buffer.init(m_api, desc.sizeInBytes, usage, reqMemoryProperties)); - if ((desc.cpuAccessFlags & Resource::AccessFlag::Write) || initData) + if ((desc.cpuAccessFlags & IResource::AccessFlag::Write) || initData) { SLANG_RETURN_ON_FAIL(buffer->m_uploadBuffer.init(m_api, bufferSize, VK_BUFFER_USAGE_TRANSFER_SRC_BIT, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT)); } @@ -1875,7 +1939,7 @@ static VkCompareOp translateComparisonFunc(ComparisonFunc func) } } -Result VKRenderer::createSamplerState(SamplerState::Desc const& desc, SamplerState** outSampler) +Result VKRenderer::createSamplerState(ISamplerState::Desc const& desc, ISamplerState** outSampler) { VkSamplerCreateInfo samplerInfo = { VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO }; @@ -1906,19 +1970,19 @@ Result VKRenderer::createSamplerState(SamplerState::Desc const& desc, SamplerSta return SLANG_OK; } -Result VKRenderer::createTextureView(TextureResource* texture, ResourceView::Desc const& desc, ResourceView** outView) +Result VKRenderer::createTextureView(ITextureResource* texture, IResourceView::Desc const& desc, IResourceView** outView) { assert(!"unimplemented"); return SLANG_FAIL; } -Result VKRenderer::createBufferView(BufferResource* buffer, ResourceView::Desc const& desc, ResourceView** outView) +Result VKRenderer::createBufferView(IBufferResource* buffer, IResourceView::Desc const& desc, IResourceView** outView) { auto resourceImpl = (BufferResourceImpl*) buffer; // TODO: These should come from the `ResourceView::Desc` VkDeviceSize offset = 0; - VkDeviceSize size = resourceImpl->getDesc().sizeInBytes; + VkDeviceSize size = resourceImpl->getDesc()->sizeInBytes; // There are two different cases we need to think about for buffers. // @@ -1945,7 +2009,7 @@ Result VKRenderer::createBufferView(BufferResource* buffer, ResourceView::Desc c assert(!"unhandled"); return SLANG_FAIL; - case ResourceView::Type::UnorderedAccess: + case IResourceView::Type::UnorderedAccess: // Is this a formatted view? // if(desc.format == Format::Unknown) @@ -1964,7 +2028,7 @@ Result VKRenderer::createBufferView(BufferResource* buffer, ResourceView::Desc c // it just like we would for a "sampled" buffer: // // FALLTHROUGH - case ResourceView::Type::ShaderResource: + case IResourceView::Type::ShaderResource: { VkBufferViewCreateInfo info = { VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO }; @@ -1986,7 +2050,7 @@ Result VKRenderer::createBufferView(BufferResource* buffer, ResourceView::Desc c } } -Result VKRenderer::createInputLayout(const InputElementDesc* elements, UInt numElements, InputLayout** outLayout) +Result VKRenderer::createInputLayout(const InputElementDesc* elements, UInt numElements, IInputLayout** outLayout) { RefPtr<InputLayoutImpl> layout(new InputLayoutImpl); @@ -2010,7 +2074,7 @@ Result VKRenderer::createInputLayout(const InputElementDesc* elements, UInt numE dstDesc.offset = uint32_t(srcDesc.offset); - const size_t elementSize = RendererUtil::getFormatSize(srcDesc.format); + const size_t elementSize = gfxGetFormatSize(srcDesc.format); assert(elementSize > 0); const size_t endElement = srcDesc.offset + elementSize; @@ -2023,7 +2087,7 @@ Result VKRenderer::createInputLayout(const InputElementDesc* elements, UInt numE return SLANG_OK; } -void* VKRenderer::map(BufferResource* bufferIn, MapFlavor flavor) +void* VKRenderer::map(IBufferResource* bufferIn, MapFlavor flavor) { BufferResourceImpl* buffer = static_cast<BufferResourceImpl*>(bufferIn); assert(buffer->m_mapFlavor == MapFlavor::Unknown); @@ -2031,7 +2095,7 @@ void* VKRenderer::map(BufferResource* bufferIn, MapFlavor flavor) // Make sure everything has completed before reading... m_deviceQueue.flushAndWait(); - const size_t bufferSize = buffer->getDesc().sizeInBytes; + const size_t bufferSize = buffer->getDesc()->sizeInBytes; switch (flavor) { @@ -2083,12 +2147,12 @@ void* VKRenderer::map(BufferResource* bufferIn, MapFlavor flavor) } } -void VKRenderer::unmap(BufferResource* bufferIn) +void VKRenderer::unmap(IBufferResource* bufferIn) { BufferResourceImpl* buffer = static_cast<BufferResourceImpl*>(bufferIn); assert(buffer->m_mapFlavor != MapFlavor::Unknown); - const size_t bufferSize = buffer->getDesc().sizeInBytes; + const size_t bufferSize = buffer->getDesc()->sizeInBytes; switch (buffer->m_mapFlavor) { @@ -2120,7 +2184,7 @@ void VKRenderer::setPrimitiveTopology(PrimitiveTopology topology) m_primitiveTopology = VulkanUtil::getVkPrimitiveTopology(topology); } -void VKRenderer::setVertexBuffers(UInt startSlot, UInt slotCount, BufferResource*const* buffers, const UInt* strides, const UInt* offsets) +void VKRenderer::setVertexBuffers(UInt startSlot, UInt slotCount, IBufferResource*const* buffers, const UInt* strides, const UInt* offsets) { { const Index num = Index(startSlot + slotCount); @@ -2135,7 +2199,7 @@ void VKRenderer::setVertexBuffers(UInt startSlot, UInt slotCount, BufferResource BufferResourceImpl* buffer = static_cast<BufferResourceImpl*>(buffers[i]); if (buffer) { - assert(buffer->m_initialUsage == Resource::Usage::VertexBuffer); + assert(buffer->m_initialUsage == IResource::Usage::VertexBuffer); } BoundVertexBuffer& boundBuffer = m_boundVertexBuffers[startSlot + i]; @@ -2145,11 +2209,11 @@ void VKRenderer::setVertexBuffers(UInt startSlot, UInt slotCount, BufferResource } } -void VKRenderer::setIndexBuffer(BufferResource* buffer, Format indexFormat, UInt offset) +void VKRenderer::setIndexBuffer(IBufferResource* buffer, Format indexFormat, UInt offset) { } -void VKRenderer::setDepthStencilTarget(ResourceView* depthStencilView) +void VKRenderer::setDepthStencilTarget(IResourceView* depthStencilView) { } @@ -2197,7 +2261,7 @@ void VKRenderer::setScissorRects(UInt count, ScissorRect const* rects) m_api.vkCmdSetScissor(commandBuffer, 0, uint32_t(count), vkRects); } -void VKRenderer::setPipelineState(PipelineType pipelineType, PipelineState* state) +void VKRenderer::setPipelineState(PipelineType pipelineType, IPipelineState* state) { m_currentPipeline = (PipelineStateImpl*)state; } @@ -2295,14 +2359,14 @@ void VKRenderer::dispatchCompute(int x, int y, int z) m_api.vkCmdDispatch(commandBuffer, x, y, z); } -static VkImageViewType _calcImageViewType(TextureResource::Type type, const TextureResource::Desc& desc) +static VkImageViewType _calcImageViewType(ITextureResource::Type type, const ITextureResource::Desc& desc) { switch (type) { - case Resource::Type::Texture1D: return desc.arraySize > 1 ? VK_IMAGE_VIEW_TYPE_1D_ARRAY : VK_IMAGE_VIEW_TYPE_1D; - case Resource::Type::Texture2D: return desc.arraySize > 1 ? VK_IMAGE_VIEW_TYPE_2D_ARRAY : VK_IMAGE_VIEW_TYPE_2D; - case Resource::Type::TextureCube: return desc.arraySize > 1 ? VK_IMAGE_VIEW_TYPE_CUBE_ARRAY : VK_IMAGE_VIEW_TYPE_CUBE; - case Resource::Type::Texture3D: + case IResource::Type::Texture1D: return desc.arraySize > 1 ? VK_IMAGE_VIEW_TYPE_1D_ARRAY : VK_IMAGE_VIEW_TYPE_1D; + case IResource::Type::Texture2D: return desc.arraySize > 1 ? VK_IMAGE_VIEW_TYPE_2D_ARRAY : VK_IMAGE_VIEW_TYPE_2D; + case IResource::Type::TextureCube: return desc.arraySize > 1 ? VK_IMAGE_VIEW_TYPE_CUBE_ARRAY : VK_IMAGE_VIEW_TYPE_CUBE; + case IResource::Type::Texture3D: { // Can't have an array and 3d texture assert(desc.arraySize <= 1); @@ -2344,7 +2408,7 @@ static VkDescriptorType translateDescriptorType(DescriptorSlotType type) } } -Result VKRenderer::createDescriptorSetLayout(const DescriptorSetLayout::Desc& desc, DescriptorSetLayout** outLayout) +Result VKRenderer::createDescriptorSetLayout(const IDescriptorSetLayout::Desc& desc, IDescriptorSetLayout** outLayout) { RefPtr<DescriptorSetLayoutImpl> descriptorSetLayoutImpl = new DescriptorSetLayoutImpl(m_api); @@ -2479,7 +2543,7 @@ Result VKRenderer::createDescriptorSetLayout(const DescriptorSetLayout::Desc& de return SLANG_OK; } -Result VKRenderer::createPipelineLayout(const PipelineLayout::Desc& desc, PipelineLayout** outLayout) +Result VKRenderer::createPipelineLayout(const IPipelineLayout::Desc& desc, IPipelineLayout** outLayout) { UInt descriptorSetCount = desc.descriptorSetCount; @@ -2542,7 +2606,7 @@ Result VKRenderer::createPipelineLayout(const PipelineLayout::Desc& desc, Pipeli return SLANG_OK; } -Result VKRenderer::createDescriptorSet(DescriptorSetLayout* layout, DescriptorSet** outDescriptorSet) +Result VKRenderer::createDescriptorSet(IDescriptorSetLayout* layout, IDescriptorSet** outDescriptorSet) { auto layoutImpl = (DescriptorSetLayoutImpl*)layout; @@ -2565,7 +2629,7 @@ Result VKRenderer::createDescriptorSet(DescriptorSetLayout* layout, DescriptorSe return SLANG_OK; } -void VKRenderer::DescriptorSetImpl::setConstantBuffer(UInt range, UInt index, BufferResource* buffer) +void VKRenderer::DescriptorSetImpl::setConstantBuffer(UInt range, UInt index, IBufferResource* buffer) { auto bufferImpl = (BufferResourceImpl*)buffer; @@ -2577,7 +2641,7 @@ void VKRenderer::DescriptorSetImpl::setConstantBuffer(UInt range, UInt index, Bu VkDescriptorBufferInfo bufferInfo = {}; bufferInfo.buffer = bufferImpl->m_buffer.m_buffer; bufferInfo.offset = 0; - bufferInfo.range = bufferImpl->getDesc().sizeInBytes; + bufferInfo.range = bufferImpl->getDesc()->sizeInBytes; VkWriteDescriptorSet writeInfo = { VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET }; writeInfo.dstSet = m_descriptorSet; @@ -2588,10 +2652,10 @@ void VKRenderer::DescriptorSetImpl::setConstantBuffer(UInt range, UInt index, Bu writeInfo.pBufferInfo = &bufferInfo; m_renderer->m_api.vkUpdateDescriptorSets(m_renderer->m_device, 1, &writeInfo, 0, nullptr); - m_boundObjects[boundObjectIndex] = buffer; + m_boundObjects[boundObjectIndex] = dynamic_cast<RefObject*>(buffer); } -void VKRenderer::DescriptorSetImpl::setResource(UInt range, UInt index, ResourceView* view) +void VKRenderer::DescriptorSetImpl::setResource(UInt range, UInt index, IResourceView* view) { SLANG_ASSERT(range < UInt(m_layout->m_ranges.getCount())); auto& rangeInfo = m_layout->m_ranges[range]; @@ -2660,10 +2724,10 @@ void VKRenderer::DescriptorSetImpl::setResource(UInt range, UInt index, Resource break; } - m_boundObjects[boundObjectIndex] = view; + m_boundObjects[boundObjectIndex] = dynamic_cast<RefObject*>(view); } -void VKRenderer::DescriptorSetImpl::setSampler(UInt range, UInt index, SamplerState* sampler) +void VKRenderer::DescriptorSetImpl::setSampler(UInt range, UInt index, ISamplerState* sampler) { SLANG_ASSERT(range < UInt(m_layout->m_ranges.getCount())); auto& rangeInfo = m_layout->m_ranges[range]; @@ -2674,14 +2738,14 @@ void VKRenderer::DescriptorSetImpl::setSampler(UInt range, UInt index, SamplerSt // TODO: Actually bind it! - m_boundObjects[boundObjectIndex] = sampler; + m_boundObjects[boundObjectIndex] = dynamic_cast<RefObject*>(sampler); } void VKRenderer::DescriptorSetImpl::setCombinedTextureSampler( UInt range, UInt index, - ResourceView* textureView, - SamplerState* sampler) + IResourceView* textureView, + ISamplerState* sampler) { SLANG_ASSERT(range < UInt(m_layout->m_ranges.getCount())); auto& rangeInfo = m_layout->m_ranges[range]; @@ -2696,8 +2760,8 @@ void VKRenderer::DescriptorSetImpl::setCombinedTextureSampler( // to keep both the texture view and the sampler object live. // auto boundObjectIndex = rangeInfo.arrayIndex + 2 * index; - m_boundObjects[boundObjectIndex + 0] = textureView; - m_boundObjects[boundObjectIndex + 1] = sampler; + m_boundObjects[boundObjectIndex + 0] = dynamic_cast<RefObject*>(textureView); + m_boundObjects[boundObjectIndex + 1] = dynamic_cast<RefObject*>(sampler); } void VKRenderer::DescriptorSetImpl::setRootConstants( @@ -2725,7 +2789,7 @@ void VKRenderer::DescriptorSetImpl::setRootConstants( memcpy(m_rootConstantData.getBuffer() + rootConstantRangeInfo.offset + offset, data, size); } -void VKRenderer::setDescriptorSet(PipelineType pipelineType, PipelineLayout* layout, UInt index, DescriptorSet* descriptorSet) +void VKRenderer::setDescriptorSet(PipelineType pipelineType, IPipelineLayout* layout, UInt index, IDescriptorSet* descriptorSet) { // Ideally this should eventually be as simple as: // @@ -2749,7 +2813,7 @@ void VKRenderer::setDescriptorSet(PipelineType pipelineType, PipelineLayout* lay m_currentDescriptorSets[index] = descriptorSetImpl->m_descriptorSet; } -Result VKRenderer::createProgram(const ShaderProgram::Desc& desc, ShaderProgram** outProgram) +Result VKRenderer::createProgram(const IShaderProgram::Desc& desc, IShaderProgram** outProgram) { RefPtr<ShaderProgramImpl> impl = new ShaderProgramImpl(m_api, desc.pipelineType); if( desc.pipelineType == PipelineType::Compute) @@ -2769,7 +2833,7 @@ Result VKRenderer::createProgram(const ShaderProgram::Desc& desc, ShaderProgram* return SLANG_OK; } -Result VKRenderer::createGraphicsPipelineState(const GraphicsPipelineStateDesc& inDesc, PipelineState** outState) +Result VKRenderer::createGraphicsPipelineState(const GraphicsPipelineStateDesc& inDesc, IPipelineState** outState) { GraphicsPipelineStateDesc desc = inDesc; preparePipelineDesc(desc); @@ -2900,7 +2964,7 @@ Result VKRenderer::createGraphicsPipelineState(const GraphicsPipelineStateDesc& return SLANG_OK; } -Result VKRenderer::createComputePipelineState(const ComputePipelineStateDesc& inDesc, PipelineState** outState) +Result VKRenderer::createComputePipelineState(const ComputePipelineStateDesc& inDesc, IPipelineState** outState) { ComputePipelineStateDesc desc = inDesc; preparePipelineDesc(desc); diff --git a/tools/gfx/vulkan/render-vk.h b/tools/gfx/vulkan/render-vk.h index 2e101c999..7e086f6c0 100644 --- a/tools/gfx/vulkan/render-vk.h +++ b/tools/gfx/vulkan/render-vk.h @@ -2,11 +2,12 @@ #pragma once #include <cstdint> +#include "slang.h" namespace gfx { class IRenderer; -int32_t createVKRenderer(IRenderer** outRenderer); +SlangResult SLANG_MCALL createVKRenderer(IRenderer** outRenderer); } // gfx diff --git a/tools/graphics-app-framework/gui.cpp b/tools/graphics-app-framework/gui.cpp index 3d6039f27..777614d58 100644 --- a/tools/graphics-app-framework/gui.cpp +++ b/tools/graphics-app-framework/gui.cpp @@ -133,13 +133,13 @@ GUI::GUI(Window* window, IRenderer* inRenderer) spDestroyCompileRequest(slangRequest); spDestroySession(slangSession); - gfx::ShaderProgram::KernelDesc kernelDescs[] = + gfx::IShaderProgram::KernelDesc kernelDescs[] = { { gfx::StageType::Vertex, vertexCode, vertexCodeEnd }, { gfx::StageType::Fragment, fragmentCode, fragmentCodeEnd }, }; - gfx::ShaderProgram::Desc programDesc; + gfx::IShaderProgram::Desc programDesc; programDesc.pipelineType = gfx::PipelineType::Graphics; programDesc.kernels = &kernelDescs[0]; programDesc.kernelCount = 2; @@ -160,21 +160,21 @@ GUI::GUI(Window* window, IRenderer* inRenderer) // - List<DescriptorSetLayout::SlotRangeDesc> descriptorSetRanges; - descriptorSetRanges.add(DescriptorSetLayout::SlotRangeDesc(DescriptorSlotType::UniformBuffer)); - descriptorSetRanges.add(DescriptorSetLayout::SlotRangeDesc(DescriptorSlotType::SampledImage)); - descriptorSetRanges.add(DescriptorSetLayout::SlotRangeDesc(DescriptorSlotType::Sampler)); + Slang::List<IDescriptorSetLayout::SlotRangeDesc> descriptorSetRanges; + descriptorSetRanges.add(IDescriptorSetLayout::SlotRangeDesc(DescriptorSlotType::UniformBuffer)); + descriptorSetRanges.add(IDescriptorSetLayout::SlotRangeDesc(DescriptorSlotType::SampledImage)); + descriptorSetRanges.add(IDescriptorSetLayout::SlotRangeDesc(DescriptorSlotType::Sampler)); - DescriptorSetLayout::Desc descriptorSetLayoutDesc; + IDescriptorSetLayout::Desc descriptorSetLayoutDesc; descriptorSetLayoutDesc.slotRangeCount = descriptorSetRanges.getCount(); descriptorSetLayoutDesc.slotRanges = descriptorSetRanges.getBuffer(); descriptorSetLayout = renderer->createDescriptorSetLayout(descriptorSetLayoutDesc); - List<PipelineLayout::DescriptorSetDesc> pipelineDescriptorSets; - pipelineDescriptorSets.add(PipelineLayout::DescriptorSetDesc(descriptorSetLayout)); + Slang::List<IPipelineLayout::DescriptorSetDesc> pipelineDescriptorSets; + pipelineDescriptorSets.add(IPipelineLayout::DescriptorSetDesc(descriptorSetLayout)); - PipelineLayout::Desc pipelineLayoutDesc; + IPipelineLayout::Desc pipelineLayoutDesc; pipelineLayoutDesc.descriptorSetCount = pipelineDescriptorSets.getCount(); pipelineLayoutDesc.descriptorSets = pipelineDescriptorSets.getBuffer(); pipelineLayoutDesc.renderTargetCount = 1; @@ -209,31 +209,31 @@ GUI::GUI(Window* window, IRenderer* inRenderer) io.Fonts->GetTexDataAsRGBA32(&pixels, &width, &height); { - gfx::TextureResource::Desc desc; - desc.init2D(Resource::Type::Texture2D, Format::RGBA_Unorm_UInt8, width, height, 1); - desc.setDefaults(Resource::Usage::PixelShaderResource); + gfx::ITextureResource::Desc desc; + desc.init2D(IResource::Type::Texture2D, Format::RGBA_Unorm_UInt8, width, height, 1); + desc.setDefaults(IResource::Usage::PixelShaderResource); ptrdiff_t mipRowStrides[] = { ptrdiff_t(width * 4 * sizeof(unsigned char)) }; void* subResourceData[] = { pixels }; - TextureResource::Data initData; + ITextureResource::Data initData; initData.mipRowStrides = mipRowStrides; initData.numMips = 1; initData.numSubResources = 1; initData.subResources = subResourceData; - auto texture = renderer->createTextureResource(Resource::Usage::PixelShaderResource, desc, &initData); + auto texture = renderer->createTextureResource(IResource::Usage::PixelShaderResource, desc, &initData); - gfx::ResourceView::Desc viewDesc; + gfx::IResourceView::Desc viewDesc; viewDesc.format = desc.format; - viewDesc.type = ResourceView::Type::ShaderResource; + viewDesc.type = IResourceView::Type::ShaderResource; auto textureView = renderer->createTextureView(texture, viewDesc); io.Fonts->TexID = (void*) textureView.detach(); } { - SamplerState::Desc desc; + ISamplerState::Desc desc; samplerState = renderer->createSamplerState(desc); } } @@ -263,20 +263,20 @@ void GUI::endFrame() // Allocate transient vertex/index buffers to hold the data for this frame. - gfx::BufferResource::Desc vertexBufferDesc; + gfx::IBufferResource::Desc vertexBufferDesc; vertexBufferDesc.init(vertexCount * sizeof(ImDrawVert)); - vertexBufferDesc.setDefaults(Resource::Usage::VertexBuffer); - vertexBufferDesc.cpuAccessFlags = Resource::AccessFlag::Write; + vertexBufferDesc.setDefaults(IResource::Usage::VertexBuffer); + vertexBufferDesc.cpuAccessFlags = IResource::AccessFlag::Write; auto vertexBuffer = renderer->createBufferResource( - Resource::Usage::VertexBuffer, + IResource::Usage::VertexBuffer, vertexBufferDesc); - gfx::BufferResource::Desc indexBufferDesc; + gfx::IBufferResource::Desc indexBufferDesc; indexBufferDesc.init(indexCount * sizeof(ImDrawIdx)); - indexBufferDesc.setDefaults(Resource::Usage::IndexBuffer); - indexBufferDesc.cpuAccessFlags = Resource::AccessFlag::Write; + indexBufferDesc.setDefaults(IResource::Usage::IndexBuffer); + indexBufferDesc.cpuAccessFlags = IResource::AccessFlag::Write; auto indexBuffer = renderer->createBufferResource( - Resource::Usage::IndexBuffer, + IResource::Usage::IndexBuffer, indexBufferDesc); { @@ -297,12 +297,12 @@ void GUI::endFrame() } // Allocate a transient constant buffer for projection matrix - gfx::BufferResource::Desc constantBufferDesc; + gfx::IBufferResource::Desc constantBufferDesc; constantBufferDesc.init(sizeof(glm::mat4x4)); - constantBufferDesc.setDefaults(Resource::Usage::ConstantBuffer); - constantBufferDesc.cpuAccessFlags = Resource::AccessFlag::Write; + constantBufferDesc.setDefaults(IResource::Usage::ConstantBuffer); + constantBufferDesc.cpuAccessFlags = IResource::AccessFlag::Write; auto constantBuffer = renderer->createBufferResource( - Resource::Usage::ConstantBuffer, + IResource::Usage::ConstantBuffer, constantBufferDesc); { @@ -371,7 +371,7 @@ void GUI::endFrame() auto descriptorSet = renderer->createDescriptorSet(descriptorSetLayout); descriptorSet->setConstantBuffer(0, 0, constantBuffer); descriptorSet->setResource(1, 0, - (gfx::ResourceView*) command->TextureId); + (gfx::IResourceView*) command->TextureId); descriptorSet->setSampler(2, 0, samplerState); @@ -394,8 +394,8 @@ GUI::~GUI() auto& io = ImGui::GetIO(); { - RefPtr<ResourceView> textureView; - textureView.attach((ResourceView*) io.Fonts->TexID); + ComPtr<IResourceView> textureView; + textureView.attach((IResourceView*) io.Fonts->TexID); textureView = nullptr; } diff --git a/tools/graphics-app-framework/gui.h b/tools/graphics-app-framework/gui.h index fa6fda1d1..4fd1ca150 100644 --- a/tools/graphics-app-framework/gui.h +++ b/tools/graphics-app-framework/gui.h @@ -6,10 +6,11 @@ #include "window.h" #include "slang-com-ptr.h" #include "external/imgui/imgui.h" +#include "source/core/slang-basic.h" namespace gfx { -struct GUI : RefObject +struct GUI : Slang::RefObject { GUI(Window* window, IRenderer* renderer); ~GUI(); @@ -19,10 +20,10 @@ struct GUI : RefObject private: Slang::ComPtr<IRenderer> renderer; - RefPtr<PipelineState> pipelineState; - RefPtr<DescriptorSetLayout> descriptorSetLayout; - RefPtr<PipelineLayout> pipelineLayout; - RefPtr<SamplerState> samplerState; + Slang::ComPtr<IPipelineState> pipelineState; + Slang::ComPtr<IDescriptorSetLayout> descriptorSetLayout; + Slang::ComPtr<IPipelineLayout> pipelineLayout; + Slang::ComPtr<ISamplerState> samplerState; }; } // gfx diff --git a/tools/graphics-app-framework/model.cpp b/tools/graphics-app-framework/model.cpp index 6a61c64e5..6984a6818 100644 --- a/tools/graphics-app-framework/model.cpp +++ b/tools/graphics-app-framework/model.cpp @@ -97,7 +97,7 @@ namespace std namespace gfx { -RefPtr<TextureResource> loadTextureImage( +ComPtr<ITextureResource> loadTextureImage( IRenderer* renderer, char const* path) { @@ -178,17 +178,17 @@ RefPtr<TextureResource> loadTextureImage( int mipCount = (int) mipRowStrides.size(); - TextureResource::Desc desc; - desc.init2D(Resource::Type::Texture2D, format, extentX, extentY, mipCount); + ITextureResource::Desc desc; + desc.init2D(IResource::Type::Texture2D, format, extentX, extentY, mipCount); - TextureResource::Data initData; + ITextureResource::Data initData; initData.numSubResources = mipCount; initData.numMips = mipCount; initData.subResources = &subresourceInitData[0]; initData.mipRowStrides = &mipRowStrides[0]; auto texture = renderer->createTextureResource( - Resource::Usage::PixelShaderResource, + IResource::Usage::PixelShaderResource, desc, &initData); @@ -538,22 +538,22 @@ Result ModelLoader::load( modelData.meshCount = int(meshes.size()); modelData.meshes = meshes.data(); - BufferResource::Desc vertexBufferDesc; + IBufferResource::Desc vertexBufferDesc; vertexBufferDesc.init(modelData.vertexCount * sizeof(Vertex)); - vertexBufferDesc.setDefaults(Resource::Usage::VertexBuffer); + vertexBufferDesc.setDefaults(IResource::Usage::VertexBuffer); modelData.vertexBuffer = renderer->createBufferResource( - Resource::Usage::VertexBuffer, + IResource::Usage::VertexBuffer, vertexBufferDesc, flatVertices.data()); if(!modelData.vertexBuffer) return SLANG_FAIL; - BufferResource::Desc indexBufferDesc; + IBufferResource::Desc indexBufferDesc; indexBufferDesc.init(modelData.indexCount * sizeof(Index)); - vertexBufferDesc.setDefaults(Resource::Usage::IndexBuffer); + vertexBufferDesc.setDefaults(IResource::Usage::IndexBuffer); modelData.indexBuffer = renderer->createBufferResource( - Resource::Usage::IndexBuffer, + IResource::Usage::IndexBuffer, indexBufferDesc, flatIndices.data()); if(!modelData.indexBuffer) return SLANG_FAIL; diff --git a/tools/graphics-app-framework/model.h b/tools/graphics-app-framework/model.h index 446f57943..44c8f0aab 100644 --- a/tools/graphics-app-framework/model.h +++ b/tools/graphics-app-framework/model.h @@ -17,7 +17,7 @@ struct ModelLoader glm::vec3 specularColor; float specularity; - RefPtr<TextureResource> diffuseMap; + ComPtr<ITextureResource> diffuseMap; }; struct Vertex @@ -39,8 +39,8 @@ struct ModelLoader struct ModelData { - RefPtr<BufferResource> vertexBuffer; - RefPtr<BufferResource> indexBuffer; + ComPtr<IBufferResource> vertexBuffer; + ComPtr<IBufferResource> indexBuffer; PrimitiveTopology primitiveTopology; int vertexCount; int indexCount; diff --git a/tools/graphics-app-framework/window.h b/tools/graphics-app-framework/window.h index e6f886f42..2e216aacf 100644 --- a/tools/graphics-app-framework/window.h +++ b/tools/graphics-app-framework/window.h @@ -57,6 +57,7 @@ struct WindowDesc }; Window* createWindow(WindowDesc const& desc); +void destroyWindow(Window* window); void showWindow(Window* window); void* getPlatformWindowHandle(Window* window); @@ -104,13 +105,23 @@ int runWindowsApplication( void* instance, int showCommand); +#ifdef _MSC_VER +#ifdef _DEBUG +# define GFX_DUMP_LEAK _CrtDumpMemoryLeaks(); +#endif +#endif +#ifndef GFX_DUMP_LEAK +#define GFX_DUMP_LEAK +#endif #define GFX_UI_MAIN(APPLICATION_ENTRY) \ int __stdcall WinMain( \ void* instance, \ void* /* prevInstance */, \ void* /* commandLine */, \ int showCommand) { \ - return gfx::runWindowsApplication(&(APPLICATION_ENTRY), instance, showCommand); \ + auto result = gfx::runWindowsApplication(&(APPLICATION_ENTRY), instance, showCommand); \ + GFX_DUMP_LEAK \ + return result; \ } #else diff --git a/tools/graphics-app-framework/windows/win-window.cpp b/tools/graphics-app-framework/windows/win-window.cpp index 45315a27a..7433603cb 100644 --- a/tools/graphics-app-framework/windows/win-window.cpp +++ b/tools/graphics-app-framework/windows/win-window.cpp @@ -293,6 +293,12 @@ Window* createWindow(WindowDesc const& desc) return window; } +void destroyWindow(Window* window) +{ + DestroyWindow(window->handle); + delete window; +} + void showWindow(Window* window) { ShowWindow(window->handle, SW_SHOW); diff --git a/tools/render-test/cpu-compute-util.h b/tools/render-test/cpu-compute-util.h index 56d510818..b1de6ce85 100644 --- a/tools/render-test/cpu-compute-util.h +++ b/tools/render-test/cpu-compute-util.h @@ -20,7 +20,7 @@ struct CPUComputeUtil GroupRange, }; - struct Resource : public RefObject + struct Resource : public Slang::RefObject { void* getInterface() const { return m_interface; } void* m_interface; @@ -33,10 +33,10 @@ struct CPUComputeUtil CPULikeBindRoot m_bindRoot; /// Buffers are held in same order as entries in layout (useful for dumping out bindings) - List<BindSet::Value*> m_buffers; + Slang::List<BindSet::Value*> m_buffers; /// Bindless resource objects - Slang::OrderedDictionary<Slang::String, RefPtr<Resource>> m_bindlessResources; + Slang::OrderedDictionary<Slang::String, Slang::RefPtr<Resource>> m_bindlessResources; }; struct ExecuteInfo diff --git a/tools/render-test/cuda/cuda-compute-util.h b/tools/render-test/cuda/cuda-compute-util.h index 8bc7bd8d6..ac0c6bba3 100644 --- a/tools/render-test/cuda/cuda-compute-util.h +++ b/tools/render-test/cuda/cuda-compute-util.h @@ -10,7 +10,7 @@ namespace renderer_test { // Base class for CUDA resources. This includes textures but also // memory allocations -class CUDAResource : public RefObject +class CUDAResource : public Slang::RefObject { public: virtual uint64_t getBindlessHandle() = 0; @@ -44,8 +44,8 @@ struct CUDAComputeUtil BindSet m_bindSet; CPULikeBindRoot m_bindRoot; /// Buffers are held in same order as entries in layout (useful for dumping out bindings) - List<BindSet::Value*> m_buffers; - Slang::OrderedDictionary<Slang::String, RefPtr<CUDAResource>> m_bindlessResources; + Slang::List<BindSet::Value*> m_buffers; + Slang::OrderedDictionary<Slang::String, Slang::RefPtr<CUDAResource>> m_bindlessResources; void releaseBindlessResources(); }; @@ -53,7 +53,10 @@ struct CUDAComputeUtil static bool hasFeature(const Slang::UnownedStringSlice& feature); - static SlangResult createTextureResource(const ShaderInputLayoutEntry& srcEntry, slang::TypeLayoutReflection* typeLayout, RefPtr<CUDAResource>& outResource); + static SlangResult createTextureResource( + const ShaderInputLayoutEntry& srcEntry, + slang::TypeLayoutReflection* typeLayout, + Slang::RefPtr<CUDAResource>& outResource); static SlangResult execute(const ShaderCompilerUtil::OutputAndLayout& outputAndLayout, const uint32_t dispatchSize[3], Context& outContext); diff --git a/tools/render-test/render-test-main.cpp b/tools/render-test/render-test-main.cpp index 533932eab..4c05422ee 100644 --- a/tools/render-test/render-test-main.cpp +++ b/tools/render-test/render-test-main.cpp @@ -74,7 +74,7 @@ struct ShaderOutputPlan struct Item { Index inputLayoutEntryIndex; - RefPtr<Resource> resource; + ComPtr<IResource> resource; }; List<Item> items; @@ -118,10 +118,10 @@ protected: ComPtr<IRenderer> m_renderer; - RefPtr<InputLayout> m_inputLayout; - RefPtr<BufferResource> m_vertexBuffer; - RefPtr<ShaderProgram> m_shaderProgram; - RefPtr<PipelineState> m_pipelineState; + ComPtr<IInputLayout> m_inputLayout; + ComPtr<IBufferResource> m_vertexBuffer; + ComPtr<IShaderProgram> m_shaderProgram; + ComPtr<IPipelineState> m_pipelineState; ShaderCompilerUtil::OutputAndLayout m_compilationOutput; @@ -147,7 +147,7 @@ public: protected: uintptr_t m_constantBufferSize; - RefPtr<BufferResource> m_constantBuffer; + ComPtr<IBufferResource> m_constantBuffer; RefPtr<BindingStateImpl> m_bindingState; int m_numAddedConstantBuffers; ///< Constant buffers can be added to the binding directly. Will be added at the end. }; @@ -165,20 +165,20 @@ public: virtual Result writeBindingOutput(BindRoot* bindRoot, const char* fileName) override; protected: - RefPtr<ShaderObject> m_programVars; + ComPtr<IShaderObject> m_programVars; ShaderOutputPlan m_outputPlan; }; SlangResult _assignVarsFromLayout( IRenderer* renderer, - ShaderObject* shaderObject, + IShaderObject* shaderObject, ShaderInputLayout const& layout, ShaderOutputPlan& ioOutputPlan, slang::ProgramLayout* slangReflection) { ShaderCursor rootCursor = ShaderCursor(shaderObject); - const int textureBindFlags = Resource::BindFlag::NonPixelShaderResource | Resource::BindFlag::PixelShaderResource; + const int textureBindFlags = IResource::BindFlag::NonPixelShaderResource | IResource::BindFlag::PixelShaderResource; Index entryCount = layout.entries.getCount(); for(Index entryIndex = 0; entryIndex < entryCount; ++entryIndex) @@ -194,7 +194,7 @@ SlangResult _assignVarsFromLayout( if(!entryCursor.isValid()) { - for(Index i = 0; i < shaderObject->getEntryPointCount(); i++) + for(gfx::UInt i = 0; i < shaderObject->getEntryPointCount(); i++) { entryCursor = ShaderCursor(shaderObject->getEntryPoint(i)).getPath(entry.name); if(entryCursor.isValid()) @@ -209,7 +209,7 @@ SlangResult _assignVarsFromLayout( return SLANG_E_INVALID_ARG; } - RefPtr<Resource> resource; + ComPtr<IResource> resource; switch(entry.type) { case ShaderInputType::Uniform: @@ -267,12 +267,12 @@ SlangResult _assignVarsFromLayout( default: { - RefPtr<BufferResource> bufferResource; + ComPtr<IBufferResource> bufferResource; SLANG_RETURN_ON_FAIL(ShaderRendererUtil::createBufferResource(entry.bufferDesc, entry.isOutput, bufferSize, entry.bufferData.getBuffer(), renderer, bufferResource)); resource = bufferResource; - ResourceView::Desc viewDesc; - viewDesc.type = ResourceView::Type::UnorderedAccess; + IResourceView::Desc viewDesc; + viewDesc.type = IResourceView::Type::UnorderedAccess; viewDesc.format = srcBuffer.format; auto bufferView = renderer->createBufferView( bufferResource, @@ -315,14 +315,14 @@ SlangResult _assignVarsFromLayout( case ShaderInputType::CombinedTextureSampler: { - RefPtr<TextureResource> texture; + ComPtr<ITextureResource> texture; SLANG_RETURN_ON_FAIL(ShaderRendererUtil::generateTextureResource(entry.textureDesc, textureBindFlags, renderer, texture)); resource = texture; auto sampler = _createSamplerState(renderer, entry.samplerDesc); - ResourceView::Desc viewDesc; - viewDesc.type = ResourceView::Type::ShaderResource; + IResourceView::Desc viewDesc; + viewDesc.type = IResourceView::Type::ShaderResource; auto textureView = renderer->createTextureView( texture, viewDesc); @@ -345,14 +345,14 @@ SlangResult _assignVarsFromLayout( case ShaderInputType::Texture: { - RefPtr<TextureResource> texture; + ComPtr<ITextureResource> texture; SLANG_RETURN_ON_FAIL(ShaderRendererUtil::generateTextureResource(entry.textureDesc, textureBindFlags, renderer, texture)); resource = texture; // TODO: support UAV textures... - ResourceView::Desc viewDesc; - viewDesc.type = ResourceView::Type::ShaderResource; + IResourceView::Desc viewDesc; + viewDesc.type = IResourceView::Type::ShaderResource; auto textureView = renderer->createTextureView( texture, viewDesc); @@ -395,8 +395,9 @@ SlangResult _assignVarsFromLayout( auto slangType = slangReflection->findTypeByName(typeName.getBuffer()); auto slangTypeLayout = slangReflection->getTypeLayout(slangType); - RefPtr<ShaderObjectLayout> shaderObjectLayout = renderer->createShaderObjectLayout(slangTypeLayout); - RefPtr<ShaderObject> shaderObject = renderer->createShaderObject(shaderObjectLayout); + ComPtr<IShaderObjectLayout> shaderObjectLayout = renderer->createShaderObjectLayout(slangTypeLayout); + ComPtr<IShaderObject> shaderObject = + renderer->createShaderObject(shaderObjectLayout); entryCursor.setObject(shaderObject); } @@ -445,12 +446,12 @@ SlangResult LegacyRenderTestApp::initialize( // TODO(tfoley): use each API's reflection interface to query the constant-buffer size needed m_constantBufferSize = 16 * sizeof(float); - BufferResource::Desc constantBufferDesc; + IBufferResource::Desc constantBufferDesc; constantBufferDesc.init(m_constantBufferSize); - constantBufferDesc.cpuAccessFlags = Resource::AccessFlag::Write; + constantBufferDesc.cpuAccessFlags = IResource::AccessFlag::Write; m_constantBuffer = - renderer->createBufferResource(Resource::Usage::ConstantBuffer, constantBufferDesc); + renderer->createBufferResource(IResource::Usage::ConstantBuffer, constantBufferDesc); if (!m_constantBuffer) return SLANG_FAIL; @@ -458,7 +459,7 @@ SlangResult LegacyRenderTestApp::initialize( // // TODO: Should probably be more sophisticated than this - with 'dynamic' constant buffer/s // binding always being specified in the test file - RefPtr<BufferResource> addedConstantBuffer; + ComPtr<IBufferResource> addedConstantBuffer; switch (m_options.shaderType) { default: @@ -490,11 +491,11 @@ SlangResult LegacyRenderTestApp::initialize( if (!m_inputLayout) return SLANG_FAIL; - BufferResource::Desc vertexBufferDesc; + IBufferResource::Desc vertexBufferDesc; vertexBufferDesc.init(kVertexCount * sizeof(Vertex)); m_vertexBuffer = renderer->createBufferResource( - Resource::Usage::VertexBuffer, vertexBufferDesc, kVertexData); + IResource::Usage::VertexBuffer, vertexBufferDesc, kVertexData); if (!m_vertexBuffer) return SLANG_FAIL; @@ -555,7 +556,7 @@ SlangResult ShaderObjectRenderTestApp::initialize( // Slang's reflection API to tell us what the parameters of the program are. // auto slangReflection = (slang::ProgramLayout*) spGetReflection(m_compilationOutput.output.getRequestForReflection()); - RefPtr<ShaderObjectLayout> programLayout = renderer->createRootShaderObjectLayout(slangReflection); + ComPtr<IShaderObjectLayout> programLayout = renderer->createRootShaderObjectLayout(slangReflection); // Once we have determined the layout of all the parameters we need to bind, // we will create a shader object to use for storing and binding those parameters. @@ -583,7 +584,7 @@ SlangResult ShaderObjectRenderTestApp::initialize( case Options::ShaderProgramType::Compute: { ComputePipelineStateDesc desc; - desc.rootShaderObjectLayout = programLayout.Ptr(); + desc.rootShaderObjectLayout = programLayout.get(); desc.program = m_shaderProgram; m_pipelineState = renderer->createComputePipelineState(desc); @@ -608,16 +609,16 @@ SlangResult ShaderObjectRenderTestApp::initialize( { "A", 2, Format::RG_Float32, offsetof(Vertex, uv) }, }; - RefPtr<InputLayout> inputLayout; + ComPtr<IInputLayout> inputLayout; SLANG_RETURN_ON_FAIL(renderer->createInputLayout(inputElements, SLANG_COUNT_OF(inputElements), inputLayout.writeRef())); - BufferResource::Desc vertexBufferDesc; + IBufferResource::Desc vertexBufferDesc; vertexBufferDesc.init(kVertexCount * sizeof(Vertex)); - SLANG_RETURN_ON_FAIL(renderer->createBufferResource(Resource::Usage::VertexBuffer, vertexBufferDesc, kVertexData, m_vertexBuffer.writeRef())); + SLANG_RETURN_ON_FAIL(renderer->createBufferResource(IResource::Usage::VertexBuffer, vertexBufferDesc, kVertexData, m_vertexBuffer.writeRef())); GraphicsPipelineStateDesc desc; - desc.rootShaderObjectLayout = programLayout.Ptr(); + desc.rootShaderObjectLayout = programLayout.get(); desc.program = m_shaderProgram; desc.inputLayout = inputLayout; @@ -650,8 +651,8 @@ void LegacyRenderTestApp::setProjectionMatrix() if (mappedData) { const ProjectionStyle projectionStyle = - RendererUtil::getProjectionStyle(m_renderer->getRendererType()); - RendererUtil::getIdentityProjection(projectionStyle, (float*)mappedData); + gfxGetProjectionStyle(m_renderer->getRendererType()); + gfxGetIdentityProjection(projectionStyle, (float*)mappedData); m_renderer->unmap(m_constantBuffer); } @@ -660,10 +661,10 @@ void LegacyRenderTestApp::setProjectionMatrix() void ShaderObjectRenderTestApp::setProjectionMatrix() { const ProjectionStyle projectionStyle = - RendererUtil::getProjectionStyle(m_renderer->getRendererType()); + gfxGetProjectionStyle(m_renderer->getRendererType()); float projectionMatrix[16]; - RendererUtil::getIdentityProjection(projectionStyle, projectionMatrix); + gfxGetIdentityProjection(projectionStyle, projectionMatrix); ShaderCursor(m_programVars) .getField("Uniforms") .getDereferenced() @@ -722,10 +723,10 @@ Result LegacyRenderTestApp::writeBindingOutput(BindRoot* bindRoot, const char* f assert(layoutBinding.isOutput); - if (binding.resource && binding.resource->isBuffer()) + if (binding.resource && binding.resource->getType() == IResource::Type::Buffer) { - BufferResource* bufferResource = static_cast<BufferResource*>(binding.resource.Ptr()); - const size_t bufferSize = bufferResource->getDesc().sizeInBytes; + IBufferResource* bufferResource = static_cast<IBufferResource*>(binding.resource.get()); + const size_t bufferSize = bufferResource->getDesc()->sizeInBytes; unsigned int* ptr = (unsigned int*)m_renderer->map(bufferResource, MapFlavor::HostRead); if (!ptr) @@ -768,10 +769,10 @@ Result ShaderObjectRenderTestApp::writeBindingOutput(BindRoot* bindRoot, const c assert(inputEntry.isOutput); auto resource = outputItem.resource; - if (resource && resource->isBuffer()) + if (resource && resource->getType() == IResource::Type::Buffer) { - BufferResource* bufferResource = static_cast<BufferResource*>(resource.Ptr()); - const size_t bufferSize = bufferResource->getDesc().sizeInBytes; + IBufferResource* bufferResource = static_cast<IBufferResource*>(resource.get()); + const size_t bufferSize = bufferResource->getDesc()->sizeInBytes; unsigned int* ptr = (unsigned int*)m_renderer->map(bufferResource, MapFlavor::HostRead); if (!ptr) @@ -1054,7 +1055,7 @@ static SlangResult _innerMain(Slang::StdWriters* stdWriters, SlangSession* sessi input.profile = options.profileName ? options.profileName : input.profile; StringBuilder rendererName; - rendererName << "[" << RendererUtil::toText(options.rendererType) << "] "; + rendererName << "[" << gfxGetRendererName(options.rendererType) << "] "; if (options.adapter.getLength()) { rendererName << "'" << options.adapter << "'"; @@ -1217,7 +1218,7 @@ static SlangResult _innerMain(Slang::StdWriters* stdWriters, SlangSession* sessi Slang::ComPtr<IRenderer> renderer; { - RendererUtil::CreateFunc createFunc = RendererUtil::getCreateFunc(options.rendererType); + SGRendererCreateFunc createFunc = gfxGetCreateFunc(options.rendererType); if (createFunc) { createFunc(renderer.writeRef()); @@ -1235,8 +1236,12 @@ static SlangResult _innerMain(Slang::StdWriters* stdWriters, SlangSession* sessi IRenderer::Desc desc; desc.width = gWindowWidth; desc.height = gWindowHeight; - desc.adapter = options.adapter; - desc.requiredFeatures = options.renderFeatures; + desc.adapter = options.adapter.getBuffer(); + List<const char*> requiredFeatureList; + for (auto & name : options.renderFeatures) + requiredFeatureList.add(name.getBuffer()); + desc.requiredFeatures = requiredFeatureList.getBuffer(); + desc.requiredFeatureCount = requiredFeatureList.getCount(); desc.nvapiExtnSlot = int(nvapiExtnSlot); window = renderer_test::Window::create(); @@ -1254,10 +1259,10 @@ static SlangResult _innerMain(Slang::StdWriters* stdWriters, SlangSession* sessi return res; } - for (const auto& feature : options.renderFeatures) + for (const auto& feature : requiredFeatureList) { // If doesn't have required feature... we have to give up - if (!renderer->hasFeature(feature.getUnownedSlice())) + if (!renderer->hasFeature(feature)) { return SLANG_E_NOT_AVAILABLE; } diff --git a/tools/render-test/shader-input-layout.h b/tools/render-test/shader-input-layout.h index 437da820b..51463eca6 100644 --- a/tools/render-test/shader-input-layout.h +++ b/tools/render-test/shader-input-layout.h @@ -140,7 +140,7 @@ public: static SlangResult writeBinding(BindRoot* bindRoot, const ShaderInputLayoutEntry& entry, const void* data, size_t sizeInBytes, Slang::WriterHelper writer); /// Write all bindings, using data from buffers - static SlangResult writeBindings(BindRoot* bindRoot, const ShaderInputLayout& layout, const List<BindSet::Value*>& buffers, Slang::WriterHelper writer); + static SlangResult writeBindings(BindRoot* bindRoot, const ShaderInputLayout& layout, const Slang::List<BindSet::Value*>& buffers, Slang::WriterHelper writer); /// Write bindings from values in memory from buffers static SlangResult writeBindings(BindRoot* bindRoot, const ShaderInputLayout& layout, const Slang::List<BindSet::Value*>& buffers, const Slang::String& fileName); diff --git a/tools/render-test/shader-renderer-util.cpp b/tools/render-test/shader-renderer-util.cpp index d24909bca..c90d197f4 100644 --- a/tools/render-test/shader-renderer-util.cpp +++ b/tools/render-test/shader-renderer-util.cpp @@ -20,7 +20,7 @@ void BindingStateImpl::apply(IRenderer* renderer, PipelineType pipelineType) const InputTextureDesc& inputDesc, int bindFlags, IRenderer* renderer, - RefPtr<TextureResource>& textureOut) + ComPtr<ITextureResource>& textureOut) { TextureData texData; generateTextureData(texData, inputDesc); @@ -32,10 +32,10 @@ void BindingStateImpl::apply(IRenderer* renderer, PipelineType pipelineType) const TextureData& texData, int bindFlags, IRenderer* renderer, - RefPtr<TextureResource>& textureOut) + ComPtr<ITextureResource>& textureOut) { - TextureResource::Desc textureResourceDesc; - textureResourceDesc.init(Resource::Type::Unknown); + ITextureResource::Desc textureResourceDesc; + textureResourceDesc.init(IResource::Type::Unknown); // Default to RGBA_Unorm_UInt8 const Format format = (inputDesc.format == Format::Unknown) ? Format::RGBA_Unorm_UInt8 : inputDesc.format; @@ -50,19 +50,19 @@ void BindingStateImpl::apply(IRenderer* renderer, PipelineType pipelineType) { case 1: { - textureResourceDesc.type = Resource::Type::Texture1D; + textureResourceDesc.type = IResource::Type::Texture1D; textureResourceDesc.size.init(inputDesc.size); break; } case 2: { - textureResourceDesc.type = inputDesc.isCube ? Resource::Type::TextureCube : Resource::Type::Texture2D; + textureResourceDesc.type = inputDesc.isCube ? IResource::Type::TextureCube : IResource::Type::Texture2D; textureResourceDesc.size.init(inputDesc.size, inputDesc.size); break; } case 3: { - textureResourceDesc.type = Resource::Type::Texture3D; + textureResourceDesc.type = IResource::Type::Texture3D; textureResourceDesc.size.init(inputDesc.size, inputDesc.size, inputDesc.size); break; } @@ -71,8 +71,8 @@ void BindingStateImpl::apply(IRenderer* renderer, PipelineType pipelineType) const int effectiveArraySize = textureResourceDesc.calcEffectiveArraySize(); const int numSubResources = textureResourceDesc.calcNumSubResources(); - Resource::Usage initialUsage = Resource::Usage::GenericRead; - TextureResource::Data initData; + IResource::Usage initialUsage = IResource::Usage::GenericRead; + ITextureResource::Data initData; List<ptrdiff_t> mipRowStrides; mipRowStrides.setCount(textureResourceDesc.numMipLevels); @@ -82,7 +82,7 @@ void BindingStateImpl::apply(IRenderer* renderer, PipelineType pipelineType) // Set up the src row strides for (int i = 0; i < textureResourceDesc.numMipLevels; i++) { - const int mipWidth = TextureResource::calcMipSize(textureResourceDesc.size.width, i); + const int mipWidth = ITextureResource::Size::calcMipSize(textureResourceDesc.size.width, i); mipRowStrides[i] = mipWidth * sizeof(uint32_t); } @@ -103,7 +103,7 @@ void BindingStateImpl::apply(IRenderer* renderer, PipelineType pipelineType) initData.numSubResources = numSubResources; initData.subResources = subResources.getBuffer(); - textureOut = renderer->createTextureResource(Resource::Usage::GenericRead, textureResourceDesc, &initData); + textureOut = renderer->createTextureResource(IResource::Usage::GenericRead, textureResourceDesc, &initData); return textureOut ? SLANG_OK : SLANG_FAIL; } @@ -114,36 +114,36 @@ void BindingStateImpl::apply(IRenderer* renderer, PipelineType pipelineType) size_t bufferSize, const void* initData, IRenderer* renderer, - Slang::RefPtr<BufferResource>& bufferOut) + Slang::ComPtr<IBufferResource>& bufferOut) { - Resource::Usage initialUsage = Resource::Usage::GenericRead; + IResource::Usage initialUsage = IResource::Usage::GenericRead; - BufferResource::Desc srcDesc; + IBufferResource::Desc srcDesc; srcDesc.init(bufferSize); srcDesc.format = inputDesc.format; int bindFlags = 0; if (inputDesc.type == InputBufferType::ConstantBuffer) { - bindFlags |= Resource::BindFlag::ConstantBuffer; - srcDesc.cpuAccessFlags |= Resource::AccessFlag::Write; - initialUsage = Resource::Usage::ConstantBuffer; + bindFlags |= IResource::BindFlag::ConstantBuffer; + srcDesc.cpuAccessFlags |= IResource::AccessFlag::Write; + initialUsage = IResource::Usage::ConstantBuffer; } else { - bindFlags |= Resource::BindFlag::UnorderedAccess | Resource::BindFlag::PixelShaderResource | Resource::BindFlag::NonPixelShaderResource; + bindFlags |= IResource::BindFlag::UnorderedAccess | IResource::BindFlag::PixelShaderResource | IResource::BindFlag::NonPixelShaderResource; srcDesc.elementSize = inputDesc.stride; - initialUsage = Resource::Usage::UnorderedAccess; + initialUsage = IResource::Usage::UnorderedAccess; } if (isOutput) { - srcDesc.cpuAccessFlags |= Resource::AccessFlag::Read; + srcDesc.cpuAccessFlags |= IResource::AccessFlag::Read; } srcDesc.bindFlags = bindFlags; - RefPtr<BufferResource> bufferResource = renderer->createBufferResource(initialUsage, srcDesc, initData); + ComPtr<IBufferResource> bufferResource = renderer->createBufferResource(initialUsage, srcDesc, initData); if (!bufferResource) { return SLANG_FAIL; @@ -153,9 +153,9 @@ void BindingStateImpl::apply(IRenderer* renderer, PipelineType pipelineType) return SLANG_OK; } -static SamplerState::Desc _calcSamplerDesc(const InputSamplerDesc& srcDesc) +static ISamplerState::Desc _calcSamplerDesc(const InputSamplerDesc& srcDesc) { - SamplerState::Desc dstDesc; + ISamplerState::Desc dstDesc; if (srcDesc.isCompareSampler) { dstDesc.reductionOp = TextureReductionOp::Comparison; @@ -164,7 +164,7 @@ static SamplerState::Desc _calcSamplerDesc(const InputSamplerDesc& srcDesc) return dstDesc; } -RefPtr<SamplerState> _createSamplerState(IRenderer* renderer, +ComPtr<ISamplerState> _createSamplerState(IRenderer* renderer, const InputSamplerDesc& srcDesc) { return renderer->createSamplerState(_calcSamplerDesc(srcDesc)); @@ -173,19 +173,19 @@ RefPtr<SamplerState> _createSamplerState(IRenderer* renderer, /* static */ Result ShaderRendererUtil::createBindingState( const ShaderInputLayout& layout, IRenderer* renderer, - BufferResource* addedConstantBuffer, + IBufferResource* addedConstantBuffer, BindingStateImpl** outBindingState) { auto srcEntries = layout.entries.getBuffer(); auto numEntries = layout.entries.getCount(); - const int textureBindFlags = Resource::BindFlag::NonPixelShaderResource | Resource::BindFlag::PixelShaderResource; + const int textureBindFlags = IResource::BindFlag::NonPixelShaderResource | IResource::BindFlag::PixelShaderResource; - List<DescriptorSetLayout::SlotRangeDesc> slotRangeDescs; + List<IDescriptorSetLayout::SlotRangeDesc> slotRangeDescs; if(addedConstantBuffer) { - DescriptorSetLayout::SlotRangeDesc slotRangeDesc; + IDescriptorSetLayout::SlotRangeDesc slotRangeDesc; slotRangeDesc.type = DescriptorSlotType::UniformBuffer; slotRangeDescs.add(slotRangeDesc); @@ -196,7 +196,7 @@ RefPtr<SamplerState> _createSamplerState(IRenderer* renderer, const ShaderInputLayoutEntry& srcEntry = srcEntries[i]; SLANG_ASSERT(srcEntry.onlyCPULikeBinding == false); - DescriptorSetLayout::SlotRangeDesc slotRangeDesc; + IDescriptorSetLayout::SlotRangeDesc slotRangeDesc; switch (srcEntry.type) { @@ -259,17 +259,17 @@ RefPtr<SamplerState> _createSamplerState(IRenderer* renderer, slotRangeDescs.add(slotRangeDesc); } - DescriptorSetLayout::Desc descriptorSetLayoutDesc; + IDescriptorSetLayout::Desc descriptorSetLayoutDesc; descriptorSetLayoutDesc.slotRangeCount = slotRangeDescs.getCount(); descriptorSetLayoutDesc.slotRanges = slotRangeDescs.getBuffer(); auto descriptorSetLayout = renderer->createDescriptorSetLayout(descriptorSetLayoutDesc); if(!descriptorSetLayout) return SLANG_FAIL; - List<PipelineLayout::DescriptorSetDesc> pipelineDescriptorSets; - pipelineDescriptorSets.add(PipelineLayout::DescriptorSetDesc(descriptorSetLayout)); + List<IPipelineLayout::DescriptorSetDesc> pipelineDescriptorSets; + pipelineDescriptorSets.add(IPipelineLayout::DescriptorSetDesc(descriptorSetLayout)); - PipelineLayout::Desc pipelineLayoutDesc; + IPipelineLayout::Desc pipelineLayoutDesc; pipelineLayoutDesc.renderTargetCount = layout.numRenderTargets; pipelineLayoutDesc.descriptorSetCount = pipelineDescriptorSets.getCount(); pipelineLayoutDesc.descriptorSets = pipelineDescriptorSets.getBuffer(); @@ -313,7 +313,7 @@ RefPtr<SamplerState> _createSamplerState(IRenderer* renderer, break; } - RefPtr<BufferResource> bufferResource; + ComPtr<IBufferResource> bufferResource; SLANG_RETURN_ON_FAIL(createBufferResource(srcEntry.bufferDesc, srcEntry.isOutput, bufferSize, srcEntry.bufferData.getBuffer(), renderer, bufferResource)); switch(srcBuffer.type) @@ -324,8 +324,8 @@ RefPtr<SamplerState> _createSamplerState(IRenderer* renderer, case InputBufferType::StorageBuffer: { - ResourceView::Desc viewDesc; - viewDesc.type = ResourceView::Type::UnorderedAccess; + IResourceView::Desc viewDesc; + viewDesc.type = IResourceView::Type::UnorderedAccess; viewDesc.format = srcBuffer.format; auto bufferView = renderer->createBufferView( bufferResource, @@ -347,13 +347,13 @@ RefPtr<SamplerState> _createSamplerState(IRenderer* renderer, case ShaderInputType::CombinedTextureSampler: { - RefPtr<TextureResource> texture; + ComPtr<ITextureResource> texture; SLANG_RETURN_ON_FAIL(generateTextureResource(srcEntry.textureDesc, textureBindFlags, renderer, texture)); auto sampler = _createSamplerState(renderer, srcEntry.samplerDesc); - ResourceView::Desc viewDesc; - viewDesc.type = ResourceView::Type::ShaderResource; + IResourceView::Desc viewDesc; + viewDesc.type = IResourceView::Type::ShaderResource; auto textureView = renderer->createTextureView( texture, viewDesc); @@ -372,13 +372,13 @@ RefPtr<SamplerState> _createSamplerState(IRenderer* renderer, case ShaderInputType::Texture: { - RefPtr<TextureResource> texture; + ComPtr<ITextureResource> texture; SLANG_RETURN_ON_FAIL(generateTextureResource(srcEntry.textureDesc, textureBindFlags, renderer, texture)); // TODO: support UAV textures... - ResourceView::Desc viewDesc; - viewDesc.type = ResourceView::Type::ShaderResource; + IResourceView::Desc viewDesc; + viewDesc.type = IResourceView::Type::ShaderResource; auto textureView = renderer->createTextureView( texture, viewDesc); diff --git a/tools/render-test/shader-renderer-util.h b/tools/render-test/shader-renderer-util.h index 5bb2d342e..045f501c3 100644 --- a/tools/render-test/shader-renderer-util.h +++ b/tools/render-test/shader-renderer-util.h @@ -37,17 +37,17 @@ struct BindingStateImpl : public Slang::RefObject struct OutputBinding { - RefPtr<Resource> resource; + ComPtr<IResource> resource; Slang::UInt entryIndex; }; List<OutputBinding> outputBindings; - RefPtr<PipelineLayout> pipelineLayout; - RefPtr<DescriptorSet> descriptorSet; + ComPtr<IPipelineLayout> pipelineLayout; + ComPtr<IDescriptorSet> descriptorSet; int m_numRenderTargets = 1; }; -RefPtr<SamplerState> _createSamplerState( +ComPtr<ISamplerState> _createSamplerState( IRenderer* renderer, const InputSamplerDesc& srcDesc); @@ -55,7 +55,7 @@ RefPtr<SamplerState> _createSamplerState( struct ShaderRendererUtil { /// Generate a texture using the InputTextureDesc and construct a TextureResource using the Renderer with the contents - static Slang::Result generateTextureResource(const InputTextureDesc& inputDesc, int bindFlags, IRenderer* renderer, Slang::RefPtr<TextureResource>& textureOut); + static Slang::Result generateTextureResource(const InputTextureDesc& inputDesc, int bindFlags, IRenderer* renderer, ComPtr<ITextureResource>& textureOut); /// Create texture resource using inputDesc, and texData to describe format, and contents static Slang::Result createTextureResource( @@ -63,7 +63,7 @@ struct ShaderRendererUtil const TextureData& texData, int bindFlags, IRenderer* renderer, - Slang::RefPtr<TextureResource>& textureOut); + ComPtr<ITextureResource>& textureOut); /// Create the BufferResource using the renderer from the contents of inputDesc static Slang::Result createBufferResource( @@ -72,13 +72,13 @@ struct ShaderRendererUtil size_t bufferSize, const void* initData, IRenderer* renderer, - Slang::RefPtr<BufferResource>& bufferOut); + ComPtr<IBufferResource>& bufferOut); /// Create BindingState::Desc from the contents of layout static Slang::Result createBindingState( const ShaderInputLayout& layout, IRenderer* renderer, - BufferResource* addedConstantBuffer, + IBufferResource* addedConstantBuffer, BindingStateImpl** outBindingState); private: @@ -87,7 +87,7 @@ private: ShaderInputLayoutEntry* srcEntries, int numEntries, IRenderer* renderer, - BufferResource* addedConstantBuffer, + IBufferResource* addedConstantBuffer, BindingStateImpl** outBindingState); }; diff --git a/tools/render-test/slang-support.cpp b/tools/render-test/slang-support.cpp index baa745b14..300cab4d7 100644 --- a/tools/render-test/slang-support.cpp +++ b/tools/render-test/slang-support.cpp @@ -205,7 +205,7 @@ gfx::StageType translateStage(SlangStage slangStage) actualEntryPoints = request.entryPoints; } - List<ShaderProgram::KernelDesc> kernelDescs; + Slang::List<IShaderProgram::KernelDesc> kernelDescs; Index actualEntryPointCount = actualEntryPoints.getCount(); for(Index ee = 0; ee < actualEntryPointCount; ++ee) @@ -217,7 +217,7 @@ gfx::StageType translateStage(SlangStage slangStage) auto gfxStage = translateStage(actualEntryPoint.slangStage); - ShaderProgram::KernelDesc kernelDesc; + IShaderProgram::KernelDesc kernelDesc; kernelDesc.stage = gfxStage; kernelDesc.codeBegin = code; kernelDesc.codeEnd = code + codeSize; diff --git a/tools/render-test/slang-support.h b/tools/render-test/slang-support.h index a0a7ef276..06651ec73 100644 --- a/tools/render-test/slang-support.h +++ b/tools/render-test/slang-support.h @@ -12,6 +12,37 @@ namespace renderer_test { gfx::StageType translateStage(SlangStage slangStage); +struct ShaderCompileRequest +{ + struct SourceInfo + { + char const* path; + + // The data may either be source text (in which + // case it can be assumed to be nul-terminated with + // `dataEnd` pointing at the terminator), or + // raw binary data (in which case `dataEnd` points + // at the end of the buffer). + char const* dataBegin; + char const* dataEnd; + }; + + struct EntryPoint + { + char const* name = nullptr; + SlangStage slangStage; + }; + + SourceInfo source; + Slang::List<EntryPoint> entryPoints; + + Slang::List<Slang::String> globalSpecializationArgs; + Slang::List<Slang::String> entryPointSpecializationArgs; + + Slang::List<Slang::CommandLine::Arg> compileArgs; +}; + + struct ShaderCompilerUtil { struct Input @@ -27,7 +58,7 @@ struct ShaderCompilerUtil struct Output { - void set(PipelineType pipelineType, const ShaderProgram::KernelDesc* inKernelDescs, Slang::Index kernelDescCount) + void set(PipelineType pipelineType, const IShaderProgram::KernelDesc* inKernelDescs, Slang::Index kernelDescCount) { kernelDescs.clear(); kernelDescs.addRange(inKernelDescs, kernelDescCount); @@ -73,8 +104,8 @@ struct ShaderCompilerUtil return -1; } - List<ShaderProgram::KernelDesc> kernelDescs; - ShaderProgram::Desc desc; + Slang::List<IShaderProgram::KernelDesc> kernelDescs; + IShaderProgram::Desc desc; /// Compile request that owns the lifetime of compiled kernel code. SlangCompileRequest* m_requestForKernels = nullptr; @@ -98,7 +129,7 @@ struct ShaderCompilerUtil static SlangResult compileWithLayout(SlangSession* session, const Options& options, const ShaderCompilerUtil::Input& input, OutputAndLayout& output); - static SlangResult readSource(const Slang::String& inSourcePath, List<char>& outSourceText); + static SlangResult readSource(const Slang::String& inSourcePath, Slang::List<char>& outSourceText); static SlangResult _compileProgramImpl(SlangSession* session, const Options& options, const Input& input, const ShaderCompileRequest& request, Output& out); static SlangResult compileProgram(SlangSession* session, const Options& options, const Input& input, const ShaderCompileRequest& request, Output& out); |