From 52692f7fba24665c8ce59eba2f27d11fdce690e8 Mon Sep 17 00:00:00 2001 From: Pursche Date: Fri, 28 Nov 2025 00:45:53 +0100 Subject: [PATCH] Refactor to use new ShaderCooker Add loading of ShaderPacks to GameRenderer which now owns shaders Use new way of loading shaders that are already in memory and owned by Game Refactor as much of pipeline creation as possible to happen once upfront rather than every frame Move Present Blit pipeline creation to GameRenderer, providing a callback to get them to the Engine Fix minor issues with CVarEditor Add -f flag to ShaderCookerStandalone to skip shader cache and force rebuild all shaders Add -d flag to ShaderCookerStandalone to output individual .spv files for debugging Clean up shaders Move Shader descriptor set declarations into their own files Add slangdconfig.json for better shader highlighting once we move to .slang extension --- .../Game-Lib/Game-Lib/Editor/CVarEditor.cpp | 52 ++- .../Rendering/Canvas/CanvasRenderer.cpp | 25 +- .../Rendering/Canvas/CanvasRenderer.h | 4 +- .../Game-Lib/Game-Lib/Rendering/CullUtils.cpp | 61 +-- .../Game-Lib/Game-Lib/Rendering/CullUtils.h | 7 +- .../Game-Lib/Rendering/CulledRenderer.cpp | 246 +++++++---- .../Game-Lib/Rendering/CulledRenderer.h | 13 +- .../Game-Lib/Rendering/CullingResources.cpp | 9 + .../Game-Lib/Rendering/CullingResources.h | 2 + .../Rendering/Debug/DebugRenderer.cpp | 165 ++++--- .../Game-Lib/Rendering/Debug/DebugRenderer.h | 13 +- .../Rendering/Debug/JoltDebugRenderer.cpp | 65 +-- .../Rendering/Debug/JoltDebugRenderer.h | 7 +- .../Rendering/Editor/EditorRenderer.cpp | 83 ++-- .../Rendering/Editor/EditorRenderer.h | 8 +- .../Rendering/Effect/EffectRenderer.cpp | 3 +- .../Rendering/Effect/EffectRenderer.h | 6 +- .../Game-Lib/Rendering/GameRenderer.cpp | 201 +++++++-- .../Game-Lib/Rendering/GameRenderer.h | 18 + .../Rendering/Light/LightRenderer.cpp | 29 +- .../Game-Lib/Rendering/Light/LightRenderer.h | 8 +- .../Rendering/Liquid/LiquidRenderer.cpp | 124 +++--- .../Rendering/Liquid/LiquidRenderer.h | 7 +- .../Rendering/Material/MaterialRenderer.cpp | 89 ++-- .../Rendering/Material/MaterialRenderer.h | 12 +- .../Rendering/Model/ModelRenderer.cpp | 412 +++++++++++------- .../Game-Lib/Rendering/Model/ModelRenderer.h | 11 +- .../Game-Lib/Rendering/PixelQuery.cpp | 27 +- .../Game-Lib/Game-Lib/Rendering/PixelQuery.h | 6 +- .../Game-Lib/Rendering/RenderResources.h | 7 + .../Game-Lib/Rendering/RenderUtils.cpp | 162 ++++--- .../Game-Lib/Game-Lib/Rendering/RenderUtils.h | 17 +- .../Rendering/Shadow/ShadowRenderer.cpp | 3 +- .../Rendering/Shadow/ShadowRenderer.h | 6 +- .../Rendering/Skybox/SkyboxRenderer.cpp | 53 +-- .../Rendering/Skybox/SkyboxRenderer.h | 7 +- .../Rendering/Terrain/TerrainRenderer.cpp | 205 ++++++--- .../Rendering/Terrain/TerrainRenderer.h | 11 +- .../Rendering/Texture/TextureRenderer.cpp | 19 +- .../Rendering/Texture/TextureRenderer.h | 5 +- .../Game-Lib/Rendering/UIRenderer.cpp | 6 +- .../ShaderCookerStandalone.lua | 12 +- Source/ShaderCookerStandalone/main.cpp | 32 +- .../Blitting/{blit.ps.hlsl => Blit.ps.hlsl} | 9 +- .../Blitting/{blit.vs.hlsl => Blit.vs.hlsl} | 3 +- .../{blitDepth.cs.hlsl => BlitDepth.cs.hlsl} | 7 +- ...{blitSample.ps.hlsl => BlitSample.ps.hlsl} | 8 +- Source/Shaders/Shaders/Debug/Debug2D.ps.hlsl | 2 + Source/Shaders/Shaders/Debug/Debug2D.vs.hlsl | 3 +- Source/Shaders/Shaders/Debug/Debug3D.ps.hlsl | 2 + Source/Shaders/Shaders/Debug/Debug3D.vs.hlsl | 6 +- .../Shaders/Debug/DebugSolid3D.ps.hlsl | 2 + .../Shaders/Debug/DebugSolid3D.vs.hlsl | 6 +- .../Shaders/DescriptorSet/Debug.inc.hlsl | 9 + .../Global.inc.hlsl} | 6 +- .../Shaders/DescriptorSet/Light.inc.hlsl | 13 + .../Shaders/DescriptorSet/Model.inc.hlsl | 24 + .../Shaders/DescriptorSet/Terrain.inc.hlsl | 16 + .../Shaders/DescriptorSet/Tiles.inc.hlsl | 6 + .../DownSampler/SinglePassDownsampler.cs.hlsl | 1 + .../Shaders/Shaders/Editor/WorldGrid.ps.hlsl | 4 +- .../Shaders/Shaders/Editor/WorldGrid.vs.hlsl | 6 +- .../Common.inc.hlsl} | 4 + .../Shaders/Shaders/Include/Culling.inc.hlsl | 6 +- Source/Shaders/Shaders/Include/Debug.inc.hlsl | 8 +- .../Shaders/Shaders/Include/Editor.inc.hlsl | 1 + Source/Shaders/Shaders/Include/OIT.inc.hlsl | 3 +- .../Shaders/Shaders/Include/Shadows.inc.hlsl | 9 +- .../Include/VisibilityBuffers.inc.hlsl | 9 +- Source/Shaders/Shaders/Jolt/Draw.ps.hlsl | 4 +- Source/Shaders/Shaders/Jolt/Draw.vs.hlsl | 8 +- .../Shaders/Light/Classification.cs.hlsl | 8 +- .../Shaders/Light/LightShared.inc.hlsl | 4 +- Source/Shaders/Shaders/Liquid/Draw.ps.hlsl | 7 +- Source/Shaders/Shaders/Liquid/Draw.vs.hlsl | 9 +- .../{ => Material}/MaterialPass.cs.hlsl | 22 +- .../{ => Material}/PreEffectsPass.cs.hlsl | 6 +- Source/Shaders/Shaders/Model/Draw.ps.hlsl | 8 +- Source/Shaders/Shaders/Model/Draw.vs.hlsl | 10 +- .../Shaders/Shaders/Model/DrawSkybox.ps.hlsl | 8 +- .../Shaders/Shaders/Model/DrawSkybox.vs.hlsl | 11 +- .../Shaders/Model/DrawTransparent.ps.hlsl | 8 +- .../Shaders/Model/DrawTransparent.vs.hlsl | 11 +- .../Shaders/Model/ModelShared.inc.hlsl | 30 +- .../PostProcess/FullscreenTriangle.vs.hlsl | 3 +- .../Shaders/PostProcess/SAO/Blur.cs.hlsl | 1 + .../PostProcess/SAO/DownsampleDepth.cs.hlsl | 1 + .../PostProcess/SAO/LinearizeDepth.cs.hlsl | 1 + .../Shaders/PostProcess/SAO/RawAO.cs.hlsl | 3 +- Source/Shaders/Shaders/Skybox/Skybox.ps.hlsl | 7 +- .../Shaders/Shaders/Sorting/SortCount.cs.hlsl | 1 + .../Shaders/Sorting/SortCountReduce.cs.hlsl | 1 + .../Shaders/Shaders/Sorting/SortScan.cs.hlsl | 1 + .../Shaders/Sorting/SortScanAdd.cs.hlsl | 1 + .../Shaders/Sorting/SortScatter.cs.hlsl | 1 + .../SortSetupIndirectParameters.cs.hlsl | 1 + .../Shaders/Shaders/Terrain/Culling.cs.hlsl | 31 +- Source/Shaders/Shaders/Terrain/Draw.ps.hlsl | 8 +- Source/Shaders/Shaders/Terrain/Draw.vs.hlsl | 8 +- .../Shaders/Terrain/FillDrawCalls.cs.hlsl | 7 +- .../Shaders/Terrain/TerrainShared.inc.hlsl | 25 +- Source/Shaders/Shaders/UI/Panel.ps.hlsl | 3 +- Source/Shaders/Shaders/UI/Panel.vs.hlsl | 7 +- Source/Shaders/Shaders/UI/Text.ps.hlsl | 3 +- Source/Shaders/Shaders/UI/Text.vs.hlsl | 7 +- .../Utils/CreateIndirectAfterCulling.cs.hlsl | 8 +- Source/Shaders/Shaders/Utils/Culling.cs.hlsl | 28 +- .../Shaders/Utils/CullingInstanced.cs.hlsl | 30 +- ...1D.cs.hlsl => DispatchArguments1D.cs.hlsl} | 2 + .../Utils/FillDrawCallsFromBitmask.cs.hlsl | 8 +- .../FillInstancedDrawCallsFromBitmask.cs.hlsl | 6 +- .../Shaders/Shaders/Utils/ObjectQuery.cs.hlsl | 5 +- ...er.cs.hlsl => ResetIndirectBuffer.cs.hlsl} | 2 + .../Shaders/Shaders/globalDataDummy.vs.hlsl | 20 - Source/Shaders/Shaders/slangdconfig.json | 15 + Source/Shaders/Shaders/solidColor.ps.hlsl | 10 - Source/Shaders/Shaders/test.ps.hlsl | 15 - Source/Shaders/Shaders/test.vs.hlsl | 30 -- Submodules/Engine | 2 +- 119 files changed, 1823 insertions(+), 1064 deletions(-) rename Source/Shaders/Shaders/Blitting/{blit.ps.hlsl => Blit.ps.hlsl} (85%) rename Source/Shaders/Shaders/Blitting/{blit.vs.hlsl => Blit.vs.hlsl} (84%) rename Source/Shaders/Shaders/Blitting/{blitDepth.cs.hlsl => BlitDepth.cs.hlsl} (72%) rename Source/Shaders/Shaders/Blitting/{blitSample.ps.hlsl => BlitSample.ps.hlsl} (87%) create mode 100644 Source/Shaders/Shaders/DescriptorSet/Debug.inc.hlsl rename Source/Shaders/Shaders/{globalData.inc.hlsl => DescriptorSet/Global.inc.hlsl} (54%) create mode 100644 Source/Shaders/Shaders/DescriptorSet/Light.inc.hlsl create mode 100644 Source/Shaders/Shaders/DescriptorSet/Model.inc.hlsl create mode 100644 Source/Shaders/Shaders/DescriptorSet/Terrain.inc.hlsl create mode 100644 Source/Shaders/Shaders/DescriptorSet/Tiles.inc.hlsl rename Source/Shaders/Shaders/{common.inc.hlsl => Include/Common.inc.hlsl} (98%) rename Source/Shaders/Shaders/{ => Material}/MaterialPass.cs.hlsl (98%) rename Source/Shaders/Shaders/{ => Material}/PreEffectsPass.cs.hlsl (91%) rename Source/Shaders/Shaders/Utils/{dispatchArguments1D.cs.hlsl => DispatchArguments1D.cs.hlsl} (96%) rename Source/Shaders/Shaders/Utils/{resetIndirectBuffer.cs.hlsl => ResetIndirectBuffer.cs.hlsl} (96%) delete mode 100644 Source/Shaders/Shaders/globalDataDummy.vs.hlsl create mode 100644 Source/Shaders/Shaders/slangdconfig.json delete mode 100644 Source/Shaders/Shaders/solidColor.ps.hlsl delete mode 100644 Source/Shaders/Shaders/test.ps.hlsl delete mode 100644 Source/Shaders/Shaders/test.vs.hlsl diff --git a/Source/Game-Lib/Game-Lib/Editor/CVarEditor.cpp b/Source/Game-Lib/Game-Lib/Editor/CVarEditor.cpp index 7d89e292..af969f63 100644 --- a/Source/Game-Lib/Game-Lib/Editor/CVarEditor.cpp +++ b/Source/Game-Lib/Game-Lib/Editor/CVarEditor.cpp @@ -212,14 +212,17 @@ namespace Editor { bool bCheckbox = cvarSystem->GetCVarArray()->GetCurrent(p->arrayIndex) != 0; if (ImGui::Checkbox("", &bCheckbox)) + { cvarSystem->GetCVarArray()->SetCurrent(bCheckbox ? 1 : 0, p->arrayIndex); - - // intCVars[p->arrayIndex].current = bCheckbox ? 1 : 0; + } } else { - if (ImGui::InputInt("", cvarSystem->GetCVarArray()->GetCurrentPtr(p->arrayIndex))) - cvarSystem->MarkDirty(); + i32 val = cvarSystem->GetCVarArray()->GetCurrent(p->arrayIndex); + if (ImGui::InputInt("", &val)) + { + cvarSystem->GetCVarArray()->SetCurrent(val, p->arrayIndex); + } } } break; @@ -236,13 +239,20 @@ namespace Editor Label(p->name.c_str(), textWidth); if (dragFlag) { - if (ImGui::InputDouble("", cvarSystem->GetCVarArray()->GetCurrentPtr(p->arrayIndex))) - cvarSystem->MarkDirty(); + // TODO: Should this be a different kind of input for dragging? + f64 val = cvarSystem->GetCVarArray()->GetCurrent(p->arrayIndex); + if (ImGui::InputDouble("", &val)) + { + cvarSystem->GetCVarArray()->SetCurrent(val, p->arrayIndex); + } } else { - if (ImGui::InputDouble("", cvarSystem->GetCVarArray()->GetCurrentPtr(p->arrayIndex))) - cvarSystem->MarkDirty(); + f64 val = cvarSystem->GetCVarArray()->GetCurrent(p->arrayIndex); + if (ImGui::InputDouble("", &val)) + { + cvarSystem->GetCVarArray()->SetCurrent(val, p->arrayIndex); + } } } break; @@ -250,16 +260,22 @@ namespace Editor case CVarType::FLOATVEC: { Label(p->name.c_str(), textWidth); - if (ImGui::InputFloat4("", &(*cvarSystem->GetCVarArray()->GetCurrentPtr(p->arrayIndex))[0])) - cvarSystem->MarkDirty(); + vec4 val = cvarSystem->GetCVarArray()->GetCurrent(p->arrayIndex); + if (ImGui::InputFloat4("", &(val)[0])) + { + cvarSystem->GetCVarArray()->SetCurrent(val, p->arrayIndex); + } break; } case CVarType::INTVEC: { Label(p->name.c_str(), textWidth); - if (ImGui::InputInt4("", &(*cvarSystem->GetCVarArray()->GetCurrentPtr(p->arrayIndex))[0])) - cvarSystem->MarkDirty(); + ivec4 val = cvarSystem->GetCVarArray()->GetCurrent(p->arrayIndex); + if (ImGui::InputInt4("", &(val)[0])) + { + cvarSystem->GetCVarArray()->SetCurrent(val, p->arrayIndex); + } break; } @@ -273,20 +289,22 @@ namespace Editor else { Label(p->name.c_str(), textWidth); - if (ImGui::InputText("", cvarSystem->GetCVarArray()->GetCurrentPtr(p->arrayIndex))) - cvarSystem->MarkDirty(); + std::string val = cvarSystem->GetCVarArray()->GetCurrent(p->arrayIndex); + if (ImGui::InputText("", &val)) + { + cvarSystem->GetCVarArray()->SetCurrent(val, p->arrayIndex); + } } break; } case CVarType::SHOWFLAG: { Label(p->name.c_str(), textWidth); - bool enabled = *cvarSystem->GetCVarArray()->GetCurrentPtr(p->arrayIndex) == ShowFlag::ENABLED; + bool enabled = cvarSystem->GetCVarArray()->GetCurrent(p->arrayIndex) == ShowFlag::ENABLED; if (ImGui::Checkbox("", &enabled)) { - *cvarSystem->GetCVarArray()->GetCurrentPtr(p->arrayIndex) = enabled ? ShowFlag::ENABLED : ShowFlag::DISABLED; - cvarSystem->MarkDirty(); + cvarSystem->GetCVarArray()->SetCurrent(enabled ? ShowFlag::ENABLED : ShowFlag::DISABLED, p->arrayIndex); } break; } diff --git a/Source/Game-Lib/Game-Lib/Rendering/Canvas/CanvasRenderer.cpp b/Source/Game-Lib/Game-Lib/Rendering/Canvas/CanvasRenderer.cpp index 39393feb..f2fab1f4 100644 --- a/Source/Game-Lib/Game-Lib/Rendering/Canvas/CanvasRenderer.cpp +++ b/Source/Game-Lib/Game-Lib/Rendering/Canvas/CanvasRenderer.cpp @@ -13,6 +13,7 @@ #include "Game-Lib/ECS/Util/Transform2D.h" #include "Game-Lib/ECS/Util/UIUtil.h" #include "Game-Lib/Rendering/Debug/DebugRenderer.h" +#include "Game-Lib/Rendering/GameRenderer.h" #include "Game-Lib/Rendering/RenderResources.h" #include "Game-Lib/Util/ServiceLocator.h" @@ -39,9 +40,11 @@ void CanvasRenderer::Clear() _renderer->UnloadTexturesInArray(_textures, 2); } -CanvasRenderer::CanvasRenderer(Renderer::Renderer* renderer, DebugRenderer* debugRenderer) +CanvasRenderer::CanvasRenderer(Renderer::Renderer* renderer, GameRenderer* gameRenderer, DebugRenderer* debugRenderer) : _renderer(renderer) + , _gameRenderer(gameRenderer) , _debugRenderer(debugRenderer) + , _descriptorSet(Renderer::DescriptorSetSlot::PER_PASS) { CreatePermanentResources(); } @@ -504,12 +507,13 @@ void CanvasRenderer::CreatePermanentResources() // Shader Renderer::VertexShaderDesc vertexShaderDesc; - vertexShaderDesc.path = "UI/Panel.vs.hlsl"; - - Renderer::PixelShaderDesc pixelShaderDesc; - pixelShaderDesc.path = "UI/Panel.ps.hlsl"; - + vertexShaderDesc.shaderEntry = _gameRenderer->GetShaderEntry("UI/Panel.vs.hlsl"_h); + vertexShaderDesc.shaderEntry.debugName = "UI/Panel.vs.hlsl"; pipelineDesc.states.vertexShader = _renderer->LoadShader(vertexShaderDesc); + + Renderer::PixelShaderDesc pixelShaderDesc; + pixelShaderDesc.shaderEntry = _gameRenderer->GetShaderEntry("UI/Panel.ps.hlsl"_h); + pixelShaderDesc.shaderEntry.debugName = "UI/Panel.ps.hlsl"; pipelineDesc.states.pixelShader = _renderer->LoadShader(pixelShaderDesc); // Blending @@ -533,12 +537,13 @@ void CanvasRenderer::CreatePermanentResources() // Shader Renderer::VertexShaderDesc vertexShaderDesc; - vertexShaderDesc.path = "UI/Text.vs.hlsl"; + vertexShaderDesc.shaderEntry = _gameRenderer->GetShaderEntry("UI/Text.vs.hlsl"_h); + vertexShaderDesc.shaderEntry.debugName = "UI/Text.vs.hlsl"; + pipelineDesc.states.vertexShader = _renderer->LoadShader(vertexShaderDesc); Renderer::PixelShaderDesc pixelShaderDesc; - pixelShaderDesc.path = "UI/Text.ps.hlsl"; - - pipelineDesc.states.vertexShader = _renderer->LoadShader(vertexShaderDesc); + pixelShaderDesc.shaderEntry = _gameRenderer->GetShaderEntry("UI/Text.ps.hlsl"_h); + pixelShaderDesc.shaderEntry.debugName = "UI/Text.ps.hlsl"; pipelineDesc.states.pixelShader = _renderer->LoadShader(pixelShaderDesc); // Blending diff --git a/Source/Game-Lib/Game-Lib/Rendering/Canvas/CanvasRenderer.h b/Source/Game-Lib/Game-Lib/Rendering/Canvas/CanvasRenderer.h index e301b531..1b4a9eb0 100644 --- a/Source/Game-Lib/Game-Lib/Rendering/Canvas/CanvasRenderer.h +++ b/Source/Game-Lib/Game-Lib/Rendering/Canvas/CanvasRenderer.h @@ -36,11 +36,12 @@ namespace ECS struct RenderResources; class Window; class DebugRenderer; +class GameRenderer; class CanvasRenderer { public: - CanvasRenderer(Renderer::Renderer* renderer, DebugRenderer* debugRenderer); + CanvasRenderer(Renderer::Renderer* renderer, GameRenderer* gameRenderer, DebugRenderer* debugRenderer); void Clear(); void Update(f32 deltaTime); @@ -102,6 +103,7 @@ class CanvasRenderer private: Renderer::Renderer* _renderer; + GameRenderer* _gameRenderer; DebugRenderer* _debugRenderer; Renderer::GPUVector _vertices; diff --git a/Source/Game-Lib/Game-Lib/Rendering/CullUtils.cpp b/Source/Game-Lib/Game-Lib/Rendering/CullUtils.cpp index 7f769a8b..c30cfc84 100644 --- a/Source/Game-Lib/Game-Lib/Rendering/CullUtils.cpp +++ b/Source/Game-Lib/Game-Lib/Rendering/CullUtils.cpp @@ -4,6 +4,8 @@ #include "Downsampler/ffx_a.h" #include "Downsampler/ffx_spd.h" +#include "Game-Lib/Rendering/GameRenderer.h" + #include #include #include @@ -13,16 +15,18 @@ Renderer::SamplerID DepthPyramidUtils::_copySampler; Renderer::SamplerID DepthPyramidUtils::_pyramidSampler; -Renderer::DescriptorSet DepthPyramidUtils::_copyDescriptorSet; -Renderer::DescriptorSet DepthPyramidUtils::_pyramidDescriptorSet; +Renderer::DescriptorSet DepthPyramidUtils::_copyDescriptorSet(Renderer::DescriptorSetSlot::PER_PASS); +Renderer::DescriptorSet DepthPyramidUtils::_pyramidDescriptorSet(Renderer::DescriptorSetSlot::PER_PASS); Renderer::BufferID DepthPyramidUtils::_atomicBuffer; +Renderer::ComputePipelineID DepthPyramidUtils::_blitDepthPipeline; +Renderer::ComputePipelineID DepthPyramidUtils::_downsamplePipeline; inline u32 GetGroupCount(u32 threadCount, u32 localSize) { return (threadCount + localSize - 1) / localSize; } -void DepthPyramidUtils::InitBuffers(Renderer::Renderer* renderer) +void DepthPyramidUtils::Init(Renderer::Renderer* renderer, GameRenderer* gameRenderer) { Renderer::BufferDesc desc; desc.name = "DepthPyramidAtomicCounters"; @@ -30,9 +34,9 @@ void DepthPyramidUtils::InitBuffers(Renderer::Renderer* renderer) desc.usage = Renderer::BufferUsage::STORAGE_BUFFER | Renderer::BufferUsage::TRANSFER_DESTINATION; _atomicBuffer = renderer->CreateAndFillBuffer(_atomicBuffer, desc, [](void* mappedMemory, size_t size) - { - memset(mappedMemory, 0, size); - }); + { + memset(mappedMemory, 0, size); + }); _pyramidDescriptorSet.Bind("spdGlobalAtomic", _atomicBuffer); Renderer::SamplerDesc copySamplerDesc; @@ -58,6 +62,29 @@ void DepthPyramidUtils::InitBuffers(Renderer::Renderer* renderer) _pyramidSampler = renderer->CreateSampler(pyramidSamplerDesc); _pyramidDescriptorSet.Bind("srcSampler", _pyramidSampler); + + // Init pipelines + Renderer::ComputePipelineDesc pipelineDesc; + { + pipelineDesc.debugName = "Blit Depthpyramid"; + + Renderer::ComputeShaderDesc shaderDesc; + shaderDesc.shaderEntry = gameRenderer->GetShaderEntry("Blitting/BlitDepth.cs.hlsl"_h); + shaderDesc.shaderEntry.debugName = "Blitting/BlitDepth.cs.hlsl"; + pipelineDesc.computeShader = renderer->LoadShader(shaderDesc); + + _blitDepthPipeline = renderer->CreatePipeline(pipelineDesc); + } + { + pipelineDesc.debugName = "Downsample Depthpyramid"; + + Renderer::ComputeShaderDesc shaderDesc; + shaderDesc.shaderEntry = gameRenderer->GetShaderEntry("DownSampler/SinglePassDownsampler.cs.hlsl"_h); + shaderDesc.shaderEntry.debugName = "DownSampler/SinglePassDownsampler.cs.hlsl"; + pipelineDesc.computeShader = renderer->LoadShader(shaderDesc); + + _downsamplePipeline = renderer->CreatePipeline(pipelineDesc); + } } void DepthPyramidUtils::BuildPyramid(BuildPyramidParams& params) @@ -66,15 +93,7 @@ void DepthPyramidUtils::BuildPyramid(BuildPyramidParams& params) // Copy first mip { - Renderer::ComputePipelineDesc blitPipelineDesc; - blitPipelineDesc.debugName = "Blit Depthpyramid"; - params.graphResources->InitializePipelineDesc(blitPipelineDesc); - - Renderer::ComputeShaderDesc shaderDesc; - shaderDesc.path = "Blitting/blitDepth.cs.hlsl"; - blitPipelineDesc.computeShader = params.renderer->LoadShader(shaderDesc); - - Renderer::ComputePipelineID pipeline = params.renderer->CreatePipeline(blitPipelineDesc); + Renderer::ComputePipelineID pipeline = _blitDepthPipeline; params.commandList->BeginPipeline(pipeline); params.copyDescriptorSet.Bind("_source", params.depth); @@ -93,7 +112,7 @@ void DepthPyramidUtils::BuildPyramid(BuildPyramidParams& params) params.commandList->PushConstant(copyData, 0, sizeof(CopyParams)); - params.commandList->BindDescriptorSet(Renderer::GLOBAL, params.copyDescriptorSet, params.frameIndex); + params.commandList->BindDescriptorSet(Renderer::PER_PASS, params.copyDescriptorSet, params.frameIndex); params.commandList->Dispatch(GetGroupCount(params.pyramidSize.x, 32), GetGroupCount(params.pyramidSize.y, 32), 1); params.commandList->EndPipeline(pipeline); @@ -103,15 +122,7 @@ void DepthPyramidUtils::BuildPyramid(BuildPyramidParams& params) // Downsample { - Renderer::ComputePipelineDesc pipelineDesc; - pipelineDesc.debugName = "Downsample Depthpyramid"; - params.graphResources->InitializePipelineDesc(pipelineDesc); - - Renderer::ComputeShaderDesc shaderDesc; - shaderDesc.path = "DownSampler/SinglePassDownsampler.cs.hlsl"; - pipelineDesc.computeShader = params.renderer->LoadShader(shaderDesc); - - Renderer::ComputePipelineID pipeline = params.renderer->CreatePipeline(pipelineDesc); + Renderer::ComputePipelineID pipeline = _downsamplePipeline; params.commandList->BeginPipeline(pipeline); params.pyramidDescriptorSet.Bind("imgSrc", params.depthPyramid, 0); diff --git a/Source/Game-Lib/Game-Lib/Rendering/CullUtils.h b/Source/Game-Lib/Game-Lib/Rendering/CullUtils.h index 0b1971fa..72041efb 100644 --- a/Source/Game-Lib/Game-Lib/Rendering/CullUtils.h +++ b/Source/Game-Lib/Game-Lib/Rendering/CullUtils.h @@ -14,15 +14,18 @@ namespace Renderer class RenderGraphResources; class CommandList; } +class GameRenderer; + class DepthPyramidUtils { public: - static void InitBuffers(Renderer::Renderer* renderer); + static void Init(Renderer::Renderer* renderer, GameRenderer* gameRenderer); struct BuildPyramidParams { public: Renderer::Renderer* renderer; + GameRenderer* gameRenderer; Renderer::RenderGraphResources* graphResources; Renderer::CommandList* commandList; RenderResources* resources; @@ -42,4 +45,6 @@ class DepthPyramidUtils static Renderer::DescriptorSet _copyDescriptorSet; static Renderer::DescriptorSet _pyramidDescriptorSet; static Renderer::BufferID _atomicBuffer; + static Renderer::ComputePipelineID _blitDepthPipeline; + static Renderer::ComputePipelineID _downsamplePipeline; }; \ No newline at end of file diff --git a/Source/Game-Lib/Game-Lib/Rendering/CulledRenderer.cpp b/Source/Game-Lib/Game-Lib/Rendering/CulledRenderer.cpp index ab5e2247..4285bb71 100644 --- a/Source/Game-Lib/Game-Lib/Rendering/CulledRenderer.cpp +++ b/Source/Game-Lib/Game-Lib/Rendering/CulledRenderer.cpp @@ -1,11 +1,20 @@ #include "CulledRenderer.h" #include "Game-Lib/Rendering/Debug/DebugRenderer.h" +#include "Game-Lib/Rendering/GameRenderer.h" #include "Game-Lib/Rendering/RenderUtils.h" +bool CulledRenderer::_pipelinesCreated = false; +Renderer::ComputePipelineID CulledRenderer::_fillInstancedDrawCallsFromBitmaskPipeline[2]; // [0] = non-indexed, [1] = indexed +Renderer::ComputePipelineID CulledRenderer::_fillDrawCallsFromBitmaskPipeline[2]; // [0] = non-indexed, [1] = indexed +Renderer::ComputePipelineID CulledRenderer::_createIndirectAfterCullingPipeline[2]; // [0] = non-indexed, [1] = indexed +Renderer::ComputePipelineID CulledRenderer::_createIndirectAfterCullingOrderedPipeline[2]; // [0] = non-indexed, [1] = indexed +Renderer::ComputePipelineID CulledRenderer::_cullingInstancedPipeline[2]; // [0] = no bitmasks, [1] = use bitmasks +Renderer::ComputePipelineID CulledRenderer::_cullingPipeline[2]; // [0] = no bitmasks, [1] = use bitmasks -CulledRenderer::CulledRenderer(Renderer::Renderer* renderer, DebugRenderer* debugRenderer) +CulledRenderer::CulledRenderer(Renderer::Renderer* renderer, GameRenderer* gameRenderer, DebugRenderer* debugRenderer) : _renderer(renderer) + , _gameRenderer(gameRenderer) , _debugRenderer(debugRenderer) { CreatePermanentResources(); @@ -64,17 +73,7 @@ void CulledRenderer::OccluderPass(OccluderPassParams& params) std::string debugName = params.passName + " Instanced Occlusion Fill"; params.commandList->PushMarker(debugName, Color::White); - Renderer::ComputePipelineDesc pipelineDesc; - pipelineDesc.debugName = debugName; - params.graphResources->InitializePipelineDesc(pipelineDesc); - - Renderer::ComputeShaderDesc shaderDesc; - shaderDesc.path = "Utils/FillInstancedDrawCallsFromBitmask.cs.hlsl"; - shaderDesc.AddPermutationField("IS_INDEXED", params.isIndexed ? "1" : "0"); - - pipelineDesc.computeShader = _renderer->LoadShader(shaderDesc); - - Renderer::ComputePipelineID pipeline = _renderer->CreatePipeline(pipelineDesc); + Renderer::ComputePipelineID pipeline = _fillInstancedDrawCallsFromBitmaskPipeline[params.isIndexed]; params.commandList->BeginPipeline(pipeline); struct FillDrawCallConstants @@ -118,14 +117,15 @@ void CulledRenderer::OccluderPass(OccluderPassParams& params) cullingPipelineDesc.debugName = debugName; params.graphResources->InitializePipelineDesc(cullingPipelineDesc); - Renderer::ComputeShaderDesc shaderDesc; - shaderDesc.path = "Utils/CreateIndirectAfterCulling.cs.hlsl"; - shaderDesc.AddPermutationField("IS_INDEXED", params.cullingResources->IsIndexed() ? "1" : "0"); - shaderDesc.AddPermutationField("DEBUG_ORDERED", debugOrdered ? "1" : "0"); - - cullingPipelineDesc.computeShader = _renderer->LoadShader(shaderDesc); - - Renderer::ComputePipelineID pipeline = _renderer->CreatePipeline(cullingPipelineDesc); + Renderer::ComputePipelineID pipeline; + if (debugOrdered) + { + pipeline = _createIndirectAfterCullingOrderedPipeline[params.isIndexed]; + } + else + { + pipeline = _createIndirectAfterCullingPipeline[params.isIndexed]; + } params.commandList->BeginPipeline(pipeline); struct CullConstants @@ -239,17 +239,7 @@ void CulledRenderer::OccluderPass(OccluderPassParams& params) std::string debugName = params.passName + " Occlusion Fill"; params.commandList->PushMarker(debugName, Color::White); - Renderer::ComputePipelineDesc pipelineDesc; - pipelineDesc.debugName = debugName; - params.graphResources->InitializePipelineDesc(pipelineDesc); - - Renderer::ComputeShaderDesc shaderDesc; - shaderDesc.path = "Utils/FillDrawCallsFromBitmask.cs.hlsl"; - shaderDesc.AddPermutationField("IS_INDEXED", params.isIndexed ? "1" : "0"); - - pipelineDesc.computeShader = _renderer->LoadShader(shaderDesc); - - Renderer::ComputePipelineID pipeline = _renderer->CreatePipeline(pipelineDesc); + Renderer::ComputePipelineID pipeline = _fillDrawCallsFromBitmaskPipeline[params.isIndexed]; params.commandList->BeginPipeline(pipeline); struct FillDrawCallConstants @@ -358,17 +348,7 @@ void CulledRenderer::CullingPass(CullingPassParams& params) std::string debugName = params.passName + " Instanced Culling"; params.commandList->PushMarker(debugName, Color::Yellow); - Renderer::ComputePipelineDesc cullingPipelineDesc; - cullingPipelineDesc.debugName = debugName; - params.graphResources->InitializePipelineDesc(cullingPipelineDesc); - - Renderer::ComputeShaderDesc shaderDesc; - shaderDesc.path = "Utils/CullingInstanced.cs.hlsl"; - - shaderDesc.AddPermutationField("USE_BITMASKS", params.disableTwoStepCulling ? "0" : "1"); - cullingPipelineDesc.computeShader = _renderer->LoadShader(shaderDesc); - - Renderer::ComputePipelineID pipeline = _renderer->CreatePipeline(cullingPipelineDesc); + Renderer::ComputePipelineID pipeline = _cullingInstancedPipeline[!params.disableTwoStepCulling]; params.commandList->BeginPipeline(pipeline); vec2 viewportSize = _renderer->GetRenderSize(); @@ -431,18 +411,16 @@ void CulledRenderer::CullingPass(CullingPassParams& params) std::string debugName = params.passName + " Create Indirect"; params.commandList->PushMarker(debugName, Color::Yellow); - Renderer::ComputePipelineDesc cullingPipelineDesc; - cullingPipelineDesc.debugName = debugName; - params.graphResources->InitializePipelineDesc(cullingPipelineDesc); - - Renderer::ComputeShaderDesc shaderDesc; - shaderDesc.path = "Utils/CreateIndirectAfterCulling.cs.hlsl"; - shaderDesc.AddPermutationField("IS_INDEXED", params.cullingResources->IsIndexed() ? "1" : "0"); - shaderDesc.AddPermutationField("DEBUG_ORDERED", debugOrdered ? "1" : "0"); - - cullingPipelineDesc.computeShader = _renderer->LoadShader(shaderDesc); - Renderer::ComputePipelineID pipeline = _renderer->CreatePipeline(cullingPipelineDesc); + Renderer::ComputePipelineID pipeline; + if (debugOrdered) + { + pipeline = _createIndirectAfterCullingOrderedPipeline[params.cullingResources->IsIndexed()]; + } + else + { + pipeline = _createIndirectAfterCullingPipeline[params.cullingResources->IsIndexed()]; + } params.commandList->BeginPipeline(pipeline); struct CullConstants @@ -490,18 +468,8 @@ void CulledRenderer::CullingPass(CullingPassParams& params) params.commandList->BufferBarrier(params.drawCountBuffer, Renderer::BufferPassUsage::TRANSFER); params.commandList->BufferBarrier(params.triangleCountBuffer, Renderer::BufferPassUsage::TRANSFER); - Renderer::ComputePipelineDesc cullingPipelineDesc; - cullingPipelineDesc.debugName = debugName; - params.graphResources->InitializePipelineDesc(cullingPipelineDesc); - - Renderer::ComputeShaderDesc shaderDesc; - shaderDesc.path = "Utils/Culling.cs.hlsl"; - - shaderDesc.AddPermutationField("USE_BITMASKS", params.disableTwoStepCulling ? "0" : "1"); - cullingPipelineDesc.computeShader = _renderer->LoadShader(shaderDesc); - // Do culling - Renderer::ComputePipelineID pipeline = _renderer->CreatePipeline(cullingPipelineDesc); + Renderer::ComputePipelineID pipeline = _cullingPipeline[!params.disableTwoStepCulling]; params.commandList->BeginPipeline(pipeline); vec2 viewportSize = _renderer->GetRenderSize(); @@ -609,17 +577,7 @@ void CulledRenderer::GeometryPass(GeometryPassParams& params) std::string debugName = params.passName + " Geometry Fill"; params.commandList->PushMarker(debugName, Color::White); - Renderer::ComputePipelineDesc pipelineDesc; - pipelineDesc.debugName = debugName; - params.graphResources->InitializePipelineDesc(pipelineDesc); - - Renderer::ComputeShaderDesc shaderDesc; - shaderDesc.path = "Utils/FillDrawCallsFromBitmask.cs.hlsl"; - shaderDesc.AddPermutationField("IS_INDEXED", params.isIndexed ? "1" : "0"); - - pipelineDesc.computeShader = _renderer->LoadShader(shaderDesc); - - Renderer::ComputePipelineID pipeline = _renderer->CreatePipeline(pipelineDesc); + Renderer::ComputePipelineID pipeline = _fillDrawCallsFromBitmaskPipeline[params.isIndexed]; params.commandList->BeginPipeline(pipeline); struct FillDrawCallConstants @@ -755,6 +713,144 @@ void CulledRenderer::CreatePermanentResources() _cullingDatas.SetDebugName("CullDataBuffer"); _cullingDatas.SetUsage(Renderer::BufferUsage::STORAGE_BUFFER); + + // Create pipelines + if (!_pipelinesCreated) + { + _pipelinesCreated = true; + CreatePipelines(); + } +} + +void CulledRenderer::CreatePipelines() +{ + // Fill Drawcalls From Bitmask pipelines + Renderer::ComputePipelineDesc pipelineDesc; + { + pipelineDesc.debugName = "FillInstancedDrawcallsFromBitmask"; + + for (u32 i = 0; i < 2; i++) + { + std::vector permutationFields = + { + { "IS_INDEXED", std::to_string(i) } + }; + u32 shaderEntryNameHash = Renderer::GetShaderEntryNameHash("Utils/FillInstancedDrawCallsFromBitmask.cs.hlsl", permutationFields); + + Renderer::ComputeShaderDesc shaderDesc; + shaderDesc.shaderEntry = shaderDesc.shaderEntry = _gameRenderer->GetShaderEntry(shaderEntryNameHash); + shaderDesc.shaderEntry.debugName = "Utils/FillInstancedDrawCallsFromBitmask.cs.hlsl"; + + pipelineDesc.computeShader = _renderer->LoadShader(shaderDesc); + + _fillInstancedDrawCallsFromBitmaskPipeline[i] = _renderer->CreatePipeline(pipelineDesc); + } + } + { + pipelineDesc.debugName = "FillDrawCallsFromBitmask"; + + for (u32 i = 0; i < 2; i++) + { + std::vector permutationFields = + { + { "IS_INDEXED", std::to_string(i) } + }; + u32 shaderEntryNameHash = Renderer::GetShaderEntryNameHash("Utils/FillDrawCallsFromBitmask.cs.hlsl", permutationFields); + + Renderer::ComputeShaderDesc shaderDesc; + shaderDesc.shaderEntry = shaderDesc.shaderEntry = _gameRenderer->GetShaderEntry(shaderEntryNameHash); + shaderDesc.shaderEntry.debugName = "Utils/FillDrawCallsFromBitmask.cs.hlsl"; + + pipelineDesc.computeShader = _renderer->LoadShader(shaderDesc); + + _fillDrawCallsFromBitmaskPipeline[i] = _renderer->CreatePipeline(pipelineDesc); + } + } + // Create Indirect After Culling pipelines + { + pipelineDesc.debugName = "CreateIndirectAfterCulling"; + + for (u32 i = 0; i < 2; i++) + { + std::vector permutationFields = + { + { "IS_INDEXED", std::to_string(i) }, + { "DEBUG_ORDERED", "0" } + }; + u32 shaderEntryNameHash = Renderer::GetShaderEntryNameHash("Utils/CreateIndirectAfterCulling.cs.hlsl", permutationFields); + + Renderer::ComputeShaderDesc shaderDesc; + shaderDesc.shaderEntry = shaderDesc.shaderEntry = _gameRenderer->GetShaderEntry(shaderEntryNameHash); + shaderDesc.shaderEntry.debugName = "Utils/CreateIndirectAfterCulling.cs.hlsl"; + + pipelineDesc.computeShader = _renderer->LoadShader(shaderDesc); + + _createIndirectAfterCullingPipeline[i] = _renderer->CreatePipeline(pipelineDesc); + } + } + { + pipelineDesc.debugName = "CreateIndirectAfterCullingOrdered"; + + for (u32 i = 0; i < 2; i++) + { + std::vector permutationFields = + { + { "IS_INDEXED", std::to_string(i) }, + { "DEBUG_ORDERED", "1" } + }; + u32 shaderEntryNameHash = Renderer::GetShaderEntryNameHash("Utils/CreateIndirectAfterCulling.cs.hlsl", permutationFields); + + Renderer::ComputeShaderDesc shaderDesc; + shaderDesc.shaderEntry = shaderDesc.shaderEntry = _gameRenderer->GetShaderEntry(shaderEntryNameHash); + shaderDesc.shaderEntry.debugName = "Utils/CreateIndirectAfterCulling.cs.hlsl"; + + pipelineDesc.computeShader = _renderer->LoadShader(shaderDesc); + + _createIndirectAfterCullingOrderedPipeline[i] = _renderer->CreatePipeline(pipelineDesc); + } + } + // Culling Instanced Pipelines + { + pipelineDesc.debugName = "CullingInstanced"; + + for (u32 i = 0; i < 2; i++) + { + std::vector permutationFields = + { + { "USE_BITMASKS", std::to_string(i) } + }; + u32 shaderEntryNameHash = Renderer::GetShaderEntryNameHash("Utils/CullingInstanced.cs.hlsl", permutationFields); + + Renderer::ComputeShaderDesc shaderDesc; + shaderDesc.shaderEntry = shaderDesc.shaderEntry = _gameRenderer->GetShaderEntry(shaderEntryNameHash); + shaderDesc.shaderEntry.debugName = "Utils/CullingInstanced.cs.hlsl"; + + pipelineDesc.computeShader = _renderer->LoadShader(shaderDesc); + + _cullingInstancedPipeline[i] = _renderer->CreatePipeline(pipelineDesc); + } + } + // Culling Pipelines + { + pipelineDesc.debugName = "Culling"; + + for (u32 i = 0; i < 2; i++) + { + std::vector permutationFields = + { + { "USE_BITMASKS", std::to_string(i) } + }; + u32 shaderEntryNameHash = Renderer::GetShaderEntryNameHash("Utils/Culling.cs.hlsl", permutationFields); + + Renderer::ComputeShaderDesc shaderDesc; + shaderDesc.shaderEntry = shaderDesc.shaderEntry = _gameRenderer->GetShaderEntry(shaderEntryNameHash); + shaderDesc.shaderEntry.debugName = "Utils/Culling.cs.hlsl"; + + pipelineDesc.computeShader = _renderer->LoadShader(shaderDesc); + + _cullingPipeline[i] = _renderer->CreatePipeline(pipelineDesc); + } + } } void CulledRenderer::SyncToGPU() diff --git a/Source/Game-Lib/Game-Lib/Rendering/CulledRenderer.h b/Source/Game-Lib/Game-Lib/Rendering/CulledRenderer.h index d0efba9c..8719d47b 100644 --- a/Source/Game-Lib/Game-Lib/Rendering/CulledRenderer.h +++ b/Source/Game-Lib/Game-Lib/Rendering/CulledRenderer.h @@ -13,6 +13,7 @@ #include class DebugRenderer; +class GameRenderer; struct RenderResources; namespace Renderer @@ -51,7 +52,7 @@ class CulledRenderer bool isIndexed = true; }; - CulledRenderer(Renderer::Renderer* renderer, DebugRenderer* debugRenderer); + CulledRenderer(Renderer::Renderer* renderer, GameRenderer* gameRenderer, DebugRenderer* debugRenderer); ~CulledRenderer(); void Update(f32 deltaTime); @@ -325,12 +326,22 @@ class CulledRenderer private: void CreatePermanentResources(); + void CreatePipelines(); protected: Renderer::Renderer* _renderer = nullptr; + GameRenderer* _gameRenderer = nullptr; DebugRenderer* _debugRenderer = nullptr; Renderer::GPUVector _cullingDatas; + static bool _pipelinesCreated; + static Renderer::ComputePipelineID _fillInstancedDrawCallsFromBitmaskPipeline[2]; // [0] = non-indexed, [1] = indexed + static Renderer::ComputePipelineID _fillDrawCallsFromBitmaskPipeline[2]; // [0] = non-indexed, [1] = indexed + static Renderer::ComputePipelineID _createIndirectAfterCullingPipeline[2]; // [0] = non-indexed, [1] = indexed + static Renderer::ComputePipelineID _createIndirectAfterCullingOrderedPipeline[2]; // [0] = non-indexed, [1] = indexed + static Renderer::ComputePipelineID _cullingInstancedPipeline[2]; // [0] = no bitmasks, [1] = use bitmasks + static Renderer::ComputePipelineID _cullingPipeline[2]; // [0] = no bitmasks, [1] = use bitmasks + Renderer::SamplerID _occlusionSampler; }; \ No newline at end of file diff --git a/Source/Game-Lib/Game-Lib/Rendering/CullingResources.cpp b/Source/Game-Lib/Game-Lib/Rendering/CullingResources.cpp index d4c399e6..bef6fbbe 100644 --- a/Source/Game-Lib/Game-Lib/Rendering/CullingResources.cpp +++ b/Source/Game-Lib/Game-Lib/Rendering/CullingResources.cpp @@ -3,6 +3,15 @@ #include "Game-Lib/Rendering/RenderUtils.h" +CullingResourcesBase::CullingResourcesBase() + : _occluderFillDescriptorSet(Renderer::DescriptorSetSlot::PER_PASS) + , _cullingDescriptorSet(Renderer::DescriptorSetSlot::PER_PASS) + , _geometryFillDescriptorSet(Renderer::DescriptorSetSlot::PER_PASS) + , _geometryPassDescriptorSet(Renderer::DescriptorSetSlot::PER_PASS) +{ + +} + void CullingResourcesBase::Init(InitParams& params) { NC_ASSERT(params.renderer != nullptr, "CullingResources : params.renderer is nullptr"); diff --git a/Source/Game-Lib/Game-Lib/Rendering/CullingResources.h b/Source/Game-Lib/Game-Lib/Rendering/CullingResources.h index fe234d4e..0c3727bb 100644 --- a/Source/Game-Lib/Game-Lib/Rendering/CullingResources.h +++ b/Source/Game-Lib/Game-Lib/Rendering/CullingResources.h @@ -18,6 +18,8 @@ struct InstanceRef class CullingResourcesBase { public: + CullingResourcesBase(); + struct InitParams { Renderer::Renderer* renderer = nullptr; diff --git a/Source/Game-Lib/Game-Lib/Rendering/Debug/DebugRenderer.cpp b/Source/Game-Lib/Game-Lib/Rendering/Debug/DebugRenderer.cpp index 949ad830..298609ec 100644 --- a/Source/Game-Lib/Game-Lib/Rendering/Debug/DebugRenderer.cpp +++ b/Source/Game-Lib/Game-Lib/Rendering/Debug/DebugRenderer.cpp @@ -1,4 +1,5 @@ #include "DebugRenderer.h" +#include "Game-Lib/Rendering/GameRenderer.h" #include "Game-Lib/Rendering/RenderResources.h" #include @@ -10,10 +11,23 @@ AutoCVar_Int CVAR_DebugRendererNumGPUVertices(CVarCategory::Client | CVarCategory::Rendering, "debugRendererNumGPUVertices", "number of GPU vertices to allocate for", 32000000); AutoCVar_ShowFlag CVAR_DebugRendererAlwaysOnTop(CVarCategory::Client | CVarCategory::Rendering, "debugRendererAlwaysOnTop", "always show debug renderer on top", ShowFlag::DISABLED); -DebugRenderer::DebugRenderer(Renderer::Renderer* renderer) +DebugRenderer::DebugRenderer(Renderer::Renderer* renderer, GameRenderer* gameRenderer) + : _gameRenderer(gameRenderer) + , _debugDescriptorSet(Renderer::DescriptorSetSlot::DEBUG) + , _draw2DDescriptorSet(Renderer::DescriptorSetSlot::PER_PASS) + , _draw2DIndirectDescriptorSet(Renderer::DescriptorSetSlot::PER_PASS) + , _draw3DDescriptorSet(Renderer::DescriptorSetSlot::PER_PASS) + , _draw3DIndirectDescriptorSet(Renderer::DescriptorSetSlot::PER_PASS) + , _drawSolid2DDescriptorSet(Renderer::DescriptorSetSlot::PER_PASS) + , _drawSolid3DDescriptorSet(Renderer::DescriptorSetSlot::PER_PASS) { _renderer = renderer; + CreatePermanentResources(); +} + +void DebugRenderer::CreatePermanentResources() +{ _debugVertices2D.SetDebugName("DebugVertices2D"); _debugVertices2D.SetUsage(Renderer::BufferUsage::TRANSFER_DESTINATION | Renderer::BufferUsage::STORAGE_BUFFER); _debugVertices2D.SyncToGPU(_renderer); @@ -86,6 +100,80 @@ DebugRenderer::DebugRenderer(Renderer::Renderer* renderer) }); _debugDescriptorSet.Bind("_debugVertices3DCount", _gpuDebugVertices3DArgumentBuffer); } + + // Create pipelines + Renderer::GraphicsPipelineDesc pipelineDesc; + // 2D Solid and Wireframe + { + // Rasterizer state + pipelineDesc.states.rasterizerState.cullMode = Renderer::CullMode::NONE; + + // Render targets. + pipelineDesc.states.renderTargetFormats[0] = _renderer->GetSwapChainImageFormat(); + + // Shader + Renderer::VertexShaderDesc vertexShaderDesc; + vertexShaderDesc.shaderEntry = _gameRenderer->GetShaderEntry("Debug/Debug2D.vs.hlsl"_h); + vertexShaderDesc.shaderEntry.debugName = "Debug/Debug2D.vs.hlsl"; + pipelineDesc.states.vertexShader = _renderer->LoadShader(vertexShaderDesc); + + Renderer::PixelShaderDesc pixelShaderDesc; + pixelShaderDesc.shaderEntry = _gameRenderer->GetShaderEntry("Debug/Debug2D.ps.hlsl"_h); + pixelShaderDesc.shaderEntry.debugName = "Debug/Debug2D.ps.hlsl"; + pipelineDesc.states.pixelShader = _renderer->LoadShader(pixelShaderDesc); + + pipelineDesc.states.primitiveTopology = Renderer::PrimitiveTopology::Lines; + _debugLine2DPipeline = _renderer->CreatePipeline(pipelineDesc); + + pipelineDesc.states.primitiveTopology = Renderer::PrimitiveTopology::Triangles; + _debugSolid2DPipeline = _renderer->CreatePipeline(pipelineDesc); + } + // 3D Solid + { + // Shader + Renderer::VertexShaderDesc vertexShaderDesc; + vertexShaderDesc.shaderEntry = _gameRenderer->GetShaderEntry("Debug/DebugSolid3D.vs.hlsl"_h); + vertexShaderDesc.shaderEntry.debugName = "Debug/DebugSolid3D.vs.hlsl"; + pipelineDesc.states.vertexShader = _renderer->LoadShader(vertexShaderDesc); + + Renderer::PixelShaderDesc pixelShaderDesc; + pixelShaderDesc.shaderEntry = _gameRenderer->GetShaderEntry("Debug/DebugSolid3D.ps.hlsl"_h); + pixelShaderDesc.shaderEntry.debugName = "Debug/DebugSolid3D.ps.hlsl"; + pipelineDesc.states.pixelShader = _renderer->LoadShader(pixelShaderDesc); + + // Depth state + pipelineDesc.states.depthStencilState.depthEnable = true; + pipelineDesc.states.depthStencilState.depthWriteEnable = true; + pipelineDesc.states.depthStencilState.depthFunc = Renderer::ComparisonFunc::GREATER; + + // Rasterizer state + pipelineDesc.states.rasterizerState.cullMode = Renderer::CullMode::BACK; + pipelineDesc.states.rasterizerState.frontFaceMode = Renderer::Settings::FRONT_FACE_STATE; + + pipelineDesc.states.renderTargetFormats[0] = _renderer->GetSwapChainImageFormat(); + + pipelineDesc.states.depthStencilFormat = Renderer::DepthImageFormat::D32_FLOAT; + + pipelineDesc.states.primitiveTopology = Renderer::PrimitiveTopology::Triangles; + _debugSolid3DPipeline = _renderer->CreatePipeline(pipelineDesc); + } + // 3D Wireframe + { + Renderer::VertexShaderDesc vertexShaderDesc; + vertexShaderDesc.shaderEntry = _gameRenderer->GetShaderEntry("Debug/Debug3D.vs.hlsl"_h); + vertexShaderDesc.shaderEntry.debugName = "Debug/Debug3D.vs.hlsl"; + pipelineDesc.states.vertexShader = _renderer->LoadShader(vertexShaderDesc); + + Renderer::PixelShaderDesc pixelShaderDesc; + pixelShaderDesc.shaderEntry = _gameRenderer->GetShaderEntry("Debug/Debug3D.ps.hlsl"_h); + pixelShaderDesc.shaderEntry.debugName = "Debug/Debug3D.ps.hlsl"; + pipelineDesc.states.pixelShader = _renderer->LoadShader(pixelShaderDesc); + + pipelineDesc.states.depthStencilState.depthWriteEnable = false; + + pipelineDesc.states.primitiveTopology = Renderer::PrimitiveTopology::Lines; + _debugLine3DPipeline = _renderer->CreatePipeline(pipelineDesc); + } } void DebugRenderer::Update(f32 deltaTime) @@ -174,35 +262,12 @@ void DebugRenderer::Add2DPass(Renderer::RenderGraph* renderGraph, RenderResource Renderer::RenderPassDesc renderPassDesc; graphResources.InitializeRenderPassDesc(renderPassDesc); - - // Render targets renderPassDesc.renderTargets[0] = data.color; commandList.BeginRenderPass(renderPassDesc); - Renderer::GraphicsPipelineDesc pipelineDesc; - - // Rasterizer state - pipelineDesc.states.rasterizerState.cullMode = Renderer::CullMode::NONE; - - // Render targets. - const Renderer::ImageDesc& desc = graphResources.GetImageDesc(data.color); - pipelineDesc.states.renderTargetFormats[0] = desc.format; - - // Shader - Renderer::VertexShaderDesc vertexShaderDesc; - vertexShaderDesc.path = "Debug/Debug2D.vs.hlsl"; - - Renderer::PixelShaderDesc pixelShaderDesc; - pixelShaderDesc.path = "Debug/Debug2D.ps.hlsl"; - - pipelineDesc.states.vertexShader = _renderer->LoadShader(vertexShaderDesc); - pipelineDesc.states.pixelShader = _renderer->LoadShader(pixelShaderDesc); - // Solid { - pipelineDesc.states.primitiveTopology = Renderer::PrimitiveTopology::Triangles; - - Renderer::GraphicsPipelineID pipeline = _renderer->CreatePipeline(pipelineDesc); + Renderer::GraphicsPipelineID pipeline = _debugSolid2DPipeline; // CPU side debug rendering { commandList.BeginPipeline(pipeline); @@ -220,9 +285,7 @@ void DebugRenderer::Add2DPass(Renderer::RenderGraph* renderGraph, RenderResource // Wireframe { - pipelineDesc.states.primitiveTopology = Renderer::PrimitiveTopology::Lines; - - Renderer::GraphicsPipelineID pipeline = _renderer->CreatePipeline(pipelineDesc); + Renderer::GraphicsPipelineID pipeline = _debugLine2DPipeline; // CPU side debug rendering { commandList.BeginPipeline(pipeline); @@ -321,38 +384,9 @@ void DebugRenderer::Add3DPass(Renderer::RenderGraph* renderGraph, RenderResource renderPassDesc.depthStencil = data.depth; commandList.BeginRenderPass(renderPassDesc); - Renderer::GraphicsPipelineDesc pipelineDesc; - - // Shader - Renderer::VertexShaderDesc vertexShaderDesc; - vertexShaderDesc.path = "Debug/DebugSolid3D.vs.hlsl"; - - Renderer::PixelShaderDesc pixelShaderDesc; - pixelShaderDesc.path = "Debug/DebugSolid3D.ps.hlsl"; - - pipelineDesc.states.vertexShader = _renderer->LoadShader(vertexShaderDesc); - pipelineDesc.states.pixelShader = _renderer->LoadShader(pixelShaderDesc); - - // Depth state - pipelineDesc.states.depthStencilState.depthEnable = true; - pipelineDesc.states.depthStencilState.depthWriteEnable = true; - pipelineDesc.states.depthStencilState.depthFunc = Renderer::ComparisonFunc::GREATER; - - // Rasterizer state - pipelineDesc.states.rasterizerState.cullMode = Renderer::CullMode::BACK; - pipelineDesc.states.rasterizerState.frontFaceMode = Renderer::Settings::FRONT_FACE_STATE; - - const Renderer::ImageDesc& desc = graphResources.GetImageDesc(data.color); - pipelineDesc.states.renderTargetFormats[0] = desc.format; - - const Renderer::DepthImageDesc& depthDesc = graphResources.GetImageDesc(data.depth); - pipelineDesc.states.depthStencilFormat = depthDesc.format; - // Solid { - pipelineDesc.states.primitiveTopology = Renderer::PrimitiveTopology::Triangles; - - Renderer::GraphicsPipelineID pipeline = _renderer->CreatePipeline(pipelineDesc); + Renderer::GraphicsPipelineID pipeline = _debugSolid3DPipeline; // CPU side debug rendering { @@ -371,20 +405,7 @@ void DebugRenderer::Add3DPass(Renderer::RenderGraph* renderGraph, RenderResource // Wireframe { - // Shader - Renderer::VertexShaderDesc vertexShaderDesc; - vertexShaderDesc.path = "Debug/Debug3D.vs.hlsl"; - - Renderer::PixelShaderDesc pixelShaderDesc; - pixelShaderDesc.path = "Debug/Debug3D.ps.hlsl"; - - pipelineDesc.states.vertexShader = _renderer->LoadShader(vertexShaderDesc); - pipelineDesc.states.pixelShader = _renderer->LoadShader(pixelShaderDesc); - - pipelineDesc.states.depthStencilState.depthWriteEnable = false; - pipelineDesc.states.primitiveTopology = Renderer::PrimitiveTopology::Lines; - - Renderer::GraphicsPipelineID pipeline = _renderer->CreatePipeline(pipelineDesc); + Renderer::GraphicsPipelineID pipeline = _debugLine3DPipeline; // CPU side debug rendering { diff --git a/Source/Game-Lib/Game-Lib/Rendering/Debug/DebugRenderer.h b/Source/Game-Lib/Game-Lib/Rendering/Debug/DebugRenderer.h index 58ccbff6..aa1afa67 100644 --- a/Source/Game-Lib/Game-Lib/Rendering/Debug/DebugRenderer.h +++ b/Source/Game-Lib/Game-Lib/Rendering/Debug/DebugRenderer.h @@ -5,6 +5,7 @@ #include struct RenderResources; +class GameRenderer; namespace Renderer { @@ -16,7 +17,7 @@ namespace Renderer class DebugRenderer { public: - DebugRenderer(Renderer::Renderer* renderer); + DebugRenderer(Renderer::Renderer* renderer, GameRenderer* gameRenderer); ~DebugRenderer(); void Update(f32 deltaTime); @@ -55,8 +56,12 @@ class DebugRenderer Renderer::DescriptorSet& GetDebugDescriptorSet() { return _debugDescriptorSet; } void RegisterCullingPassBufferUsage(Renderer::RenderGraphBuilder& builder); +private: + void CreatePermanentResources(); + private: Renderer::Renderer* _renderer = nullptr; + GameRenderer* _gameRenderer = nullptr; struct DebugVertex2D { @@ -96,6 +101,9 @@ class DebugRenderer Renderer::DescriptorSet _draw3DDescriptorSet; Renderer::DescriptorSet _draw3DIndirectDescriptorSet; + Renderer::GraphicsPipelineID _debugLine2DPipeline; + Renderer::GraphicsPipelineID _debugLine3DPipeline; + // Solid Renderer::GPUVector _debugVerticesSolid2D; Renderer::GPUVector _debugVerticesSolid3D; @@ -103,4 +111,7 @@ class DebugRenderer Renderer::DescriptorSet _drawSolid2DDescriptorSet; Renderer::DescriptorSet _drawSolid3DDescriptorSet; + Renderer::GraphicsPipelineID _debugSolid2DPipeline; + Renderer::GraphicsPipelineID _debugSolid3DPipeline; + }; diff --git a/Source/Game-Lib/Game-Lib/Rendering/Debug/JoltDebugRenderer.cpp b/Source/Game-Lib/Game-Lib/Rendering/Debug/JoltDebugRenderer.cpp index 8923a1c4..087f84e8 100644 --- a/Source/Game-Lib/Game-Lib/Rendering/Debug/JoltDebugRenderer.cpp +++ b/Source/Game-Lib/Game-Lib/Rendering/Debug/JoltDebugRenderer.cpp @@ -31,8 +31,9 @@ AutoCVar_Int CVAR_JoltDebugDrawAABBs(CVarCategory::Client | CVarCategory::Render AutoCVar_Int CVAR_JoltDebugValidateTransfers(CVarCategory::Client | CVarCategory::Rendering, "joltValidateGPUVectors", "if enabled ON START we will validate GPUVector uploads", 0, CVarFlags::EditCheckbox); -JoltDebugRenderer::JoltDebugRenderer(Renderer::Renderer* renderer, ::DebugRenderer* debugRenderer) - : CulledRenderer(renderer, debugRenderer) +JoltDebugRenderer::JoltDebugRenderer(Renderer::Renderer* renderer, GameRenderer* gameRenderer, ::DebugRenderer* debugRenderer) + : CulledRenderer(renderer, gameRenderer, debugRenderer) + , _gameRenderer(gameRenderer) { #ifdef JPH_DEBUG_RENDERER // Initialize base class @@ -851,34 +852,7 @@ void JoltDebugRenderer::Draw(const RenderResources& resources, u8 frameIndex, Re renderPassDesc.depthStencil = params.depth; commandList.BeginRenderPass(renderPassDesc); - Renderer::GraphicsPipelineDesc pipelineDesc; - - // Shader - Renderer::VertexShaderDesc vertexShaderDesc; - vertexShaderDesc.path = "Jolt/Draw.vs.hlsl"; - - Renderer::PixelShaderDesc pixelShaderDesc; - pixelShaderDesc.path = "Jolt/Draw.ps.hlsl"; - - pipelineDesc.states.vertexShader = _renderer->LoadShader(vertexShaderDesc); - pipelineDesc.states.pixelShader = _renderer->LoadShader(pixelShaderDesc); - - // Depth state - pipelineDesc.states.depthStencilState.depthEnable = true; - pipelineDesc.states.depthStencilState.depthWriteEnable = true; - pipelineDesc.states.depthStencilState.depthFunc = Renderer::ComparisonFunc::GREATER; - - // Rasterizer state - pipelineDesc.states.rasterizerState.cullMode = Renderer::CullMode::BACK; - pipelineDesc.states.rasterizerState.frontFaceMode = Renderer::Settings::FRONT_FACE_STATE; - - const Renderer::ImageDesc& desc = graphResources.GetImageDesc(params.rt0); - pipelineDesc.states.renderTargetFormats[0] = desc.format; - - const Renderer::DepthImageDesc& depthDesc = graphResources.GetImageDesc(params.depth); - pipelineDesc.states.depthStencilFormat = depthDesc.format; - - Renderer::GraphicsPipelineID pipeline = _renderer->CreatePipeline(pipelineDesc); + Renderer::GraphicsPipelineID pipeline = _drawPipeline; commandList.BeginPipeline(pipeline); @@ -942,6 +916,37 @@ void JoltDebugRenderer::CreatePermanentResources() _cullingResources.Init(initParams); SyncToGPU(); + + // Create pipeline + { + Renderer::GraphicsPipelineDesc pipelineDesc; + + // Shader + Renderer::VertexShaderDesc vertexShaderDesc; + vertexShaderDesc.shaderEntry = _gameRenderer->GetShaderEntry("Jolt/Draw.vs.hlsl"_h); + vertexShaderDesc.shaderEntry.debugName = "Jolt/Draw.vs.hlsl"; + pipelineDesc.states.vertexShader = _renderer->LoadShader(vertexShaderDesc); + + Renderer::PixelShaderDesc pixelShaderDesc; + pixelShaderDesc.shaderEntry = _gameRenderer->GetShaderEntry("Jolt/Draw.ps.hlsl"_h); + pixelShaderDesc.shaderEntry.debugName = "Jolt/Draw.ps.hlsl"; + pipelineDesc.states.pixelShader = _renderer->LoadShader(pixelShaderDesc); + + // Depth state + pipelineDesc.states.depthStencilState.depthEnable = true; + pipelineDesc.states.depthStencilState.depthWriteEnable = true; + pipelineDesc.states.depthStencilState.depthFunc = Renderer::ComparisonFunc::GREATER; + + // Rasterizer state + pipelineDesc.states.rasterizerState.cullMode = Renderer::CullMode::BACK; + pipelineDesc.states.rasterizerState.frontFaceMode = Renderer::Settings::FRONT_FACE_STATE; + + pipelineDesc.states.renderTargetFormats[0] = Renderer::ImageFormat::R32G32_UINT; // Visibility buffer + + pipelineDesc.states.depthStencilFormat = Renderer::DepthImageFormat::D32_FLOAT; + + _drawPipeline = _renderer->CreatePipeline(pipelineDesc); + } } void JoltDebugRenderer::SyncToGPU() diff --git a/Source/Game-Lib/Game-Lib/Rendering/Debug/JoltDebugRenderer.h b/Source/Game-Lib/Game-Lib/Rendering/Debug/JoltDebugRenderer.h index 4de0dec6..54b8dd11 100644 --- a/Source/Game-Lib/Game-Lib/Rendering/Debug/JoltDebugRenderer.h +++ b/Source/Game-Lib/Game-Lib/Rendering/Debug/JoltDebugRenderer.h @@ -11,6 +11,7 @@ #endif class DebugRenderer; +class GameRenderer; struct RenderResources; class JoltDebugRenderer : public CulledRenderer @@ -21,7 +22,7 @@ class JoltDebugRenderer : public CulledRenderer public: JPH_OVERRIDE_NEW_DELETE - JoltDebugRenderer(Renderer::Renderer* renderer, ::DebugRenderer* debugRenderer); + JoltDebugRenderer(Renderer::Renderer* renderer, GameRenderer* gameRenderer, ::DebugRenderer* debugRenderer); void Update(f32 deltaTime); void Clear(); @@ -108,6 +109,8 @@ class JoltDebugRenderer : public CulledRenderer }; private: + GameRenderer* _gameRenderer = nullptr; + CullingResourcesIndexed _indexedCullingResources; std::vector _indexedDrawManifests; @@ -118,4 +121,6 @@ class JoltDebugRenderer : public CulledRenderer Renderer::GPUVector _vertices; Renderer::GPUVector _indices; + + Renderer::GraphicsPipelineID _drawPipeline; }; diff --git a/Source/Game-Lib/Game-Lib/Rendering/Editor/EditorRenderer.cpp b/Source/Game-Lib/Game-Lib/Rendering/Editor/EditorRenderer.cpp index 51713a82..3172270f 100644 --- a/Source/Game-Lib/Game-Lib/Rendering/Editor/EditorRenderer.cpp +++ b/Source/Game-Lib/Game-Lib/Rendering/Editor/EditorRenderer.cpp @@ -1,9 +1,10 @@ #include "EditorRenderer.h" -#include -#include -#include -#include +#include "Game-Lib/Rendering/Debug/DebugRenderer.h" +#include "Game-Lib/Rendering/GameRenderer.h" +#include "Game-Lib/Rendering/RenderResources.h" +#include "Game-Lib/Util/ServiceLocator.h" +#include "Game-Lib/Application/EnttRegistries.h" #include #include @@ -16,8 +17,9 @@ AutoCVar_Int CVAR_WorldGridEnabled(CVarCategory::Client | CVarCategory::Renderin AutoCVar_Float CVAR_WorldGridFadeStart(CVarCategory::Client | CVarCategory::Rendering, "worldGridFadeStart", "set the starting value from where the world grid will start fading", 80.0f); AutoCVar_Float CVAR_WorldGridFadeEnd(CVarCategory::Client | CVarCategory::Rendering, "worldGridFadeEnd", "set the starting value from where the world grid will stop fading", 110.0f); -EditorRenderer::EditorRenderer(Renderer::Renderer* renderer, DebugRenderer* debugRenderer) +EditorRenderer::EditorRenderer(Renderer::Renderer* renderer, GameRenderer* gameRenderer, DebugRenderer* debugRenderer) : _renderer(renderer) + , _gameRenderer(gameRenderer) //, _debugRenderer(debugRenderer) { CreatePermanentResources(); @@ -72,43 +74,8 @@ void EditorRenderer::AddWorldGridPass(Renderer::RenderGraph* renderGraph, Render renderPassDesc.depthStencil = data.depth; commandList.BeginRenderPass(renderPassDesc); - Renderer::GraphicsPipelineDesc pipelineDesc; - - // Shaders - Renderer::VertexShaderDesc vertexShaderDesc; - vertexShaderDesc.path = "Editor/WorldGrid.vs.hlsl"; - - pipelineDesc.states.vertexShader = _renderer->LoadShader(vertexShaderDesc); - - Renderer::PixelShaderDesc pixelShaderDesc; - pixelShaderDesc.path = "Editor/WorldGrid.ps.hlsl"; - - pipelineDesc.states.pixelShader = _renderer->LoadShader(pixelShaderDesc); - - // Depth state - pipelineDesc.states.depthStencilState.depthEnable = true; - pipelineDesc.states.depthStencilState.depthFunc = Renderer::ComparisonFunc::GREATER_EQUAL; - - // Rasterizer state - pipelineDesc.states.rasterizerState.cullMode = Renderer::CullMode::NONE; - pipelineDesc.states.rasterizerState.frontFaceMode = Renderer::FrontFaceState::COUNTERCLOCKWISE; - - // Blending - pipelineDesc.states.blendState.renderTargets[0].blendEnable = true; - pipelineDesc.states.blendState.renderTargets[0].srcBlend = Renderer::BlendMode::SRC_ALPHA; - pipelineDesc.states.blendState.renderTargets[0].destBlend = Renderer::BlendMode::INV_SRC_ALPHA; - pipelineDesc.states.blendState.renderTargets[0].srcBlendAlpha = Renderer::BlendMode::ZERO; - pipelineDesc.states.blendState.renderTargets[0].destBlendAlpha = Renderer::BlendMode::ONE; - - // Render targets - const Renderer::ImageDesc& desc = graphResources.GetImageDesc(data.sceneColor); - pipelineDesc.states.renderTargetFormats[0] = desc.format; - - const Renderer::DepthImageDesc& depthDesc = graphResources.GetImageDesc(data.depth); - pipelineDesc.states.depthStencilFormat = depthDesc.format; - // Set pipeline - Renderer::GraphicsPipelineID pipeline = _renderer->CreatePipeline(pipelineDesc); // This will compile the pipeline and return the ID, or just return ID of cached pipeline + Renderer::GraphicsPipelineID pipeline = _worldGridPipeline; commandList.BeginPipeline(pipeline); commandList.BindDescriptorSet(Renderer::DescriptorSetSlot::GLOBAL, data.globalSet, frameIndex); @@ -136,5 +103,37 @@ void EditorRenderer::AddWorldGridPass(Renderer::RenderGraph* renderGraph, Render void EditorRenderer::CreatePermanentResources() { - + Renderer::GraphicsPipelineDesc pipelineDesc; + + // Shaders + Renderer::VertexShaderDesc vertexShaderDesc; + vertexShaderDesc.shaderEntry = _gameRenderer->GetShaderEntry("Editor/WorldGrid.vs.hlsl"_h); + vertexShaderDesc.shaderEntry.debugName = "Editor/WorldGrid.vs.hlsl"; + pipelineDesc.states.vertexShader = _renderer->LoadShader(vertexShaderDesc); + + Renderer::PixelShaderDesc pixelShaderDesc; + pixelShaderDesc.shaderEntry = _gameRenderer->GetShaderEntry("Editor/WorldGrid.ps.hlsl"_h); + pixelShaderDesc.shaderEntry.debugName = "Editor/WorldGrid.ps.hlsl"; + pipelineDesc.states.pixelShader = _renderer->LoadShader(pixelShaderDesc); + + // Depth state + pipelineDesc.states.depthStencilState.depthEnable = true; + pipelineDesc.states.depthStencilState.depthFunc = Renderer::ComparisonFunc::GREATER_EQUAL; + + // Rasterizer state + pipelineDesc.states.rasterizerState.cullMode = Renderer::CullMode::NONE; + pipelineDesc.states.rasterizerState.frontFaceMode = Renderer::FrontFaceState::COUNTERCLOCKWISE; + + // Blending + pipelineDesc.states.blendState.renderTargets[0].blendEnable = true; + pipelineDesc.states.blendState.renderTargets[0].srcBlend = Renderer::BlendMode::SRC_ALPHA; + pipelineDesc.states.blendState.renderTargets[0].destBlend = Renderer::BlendMode::INV_SRC_ALPHA; + pipelineDesc.states.blendState.renderTargets[0].srcBlendAlpha = Renderer::BlendMode::ZERO; + pipelineDesc.states.blendState.renderTargets[0].destBlendAlpha = Renderer::BlendMode::ONE; + + // Render targets + pipelineDesc.states.renderTargetFormats[0] = _renderer->GetSwapChainImageFormat(); + pipelineDesc.states.depthStencilFormat = Renderer::DepthImageFormat::D32_FLOAT; + + _worldGridPipeline = _worldGridPipeline = _renderer->CreatePipeline(pipelineDesc); } \ No newline at end of file diff --git a/Source/Game-Lib/Game-Lib/Rendering/Editor/EditorRenderer.h b/Source/Game-Lib/Game-Lib/Rendering/Editor/EditorRenderer.h index 5a301aac..f18dfba8 100644 --- a/Source/Game-Lib/Game-Lib/Rendering/Editor/EditorRenderer.h +++ b/Source/Game-Lib/Game-Lib/Rendering/Editor/EditorRenderer.h @@ -1,6 +1,8 @@ #pragma once #include +#include + namespace Renderer { class Renderer; @@ -8,12 +10,13 @@ namespace Renderer } class DebugRenderer; +class GameRenderer; struct RenderResources; class EditorRenderer { public: - EditorRenderer(Renderer::Renderer* renderer, DebugRenderer* debugRenderer); + EditorRenderer(Renderer::Renderer* renderer, GameRenderer* gameRenderer, DebugRenderer* debugRenderer); ~EditorRenderer(); void Update(f32 deltaTime); @@ -24,5 +27,8 @@ class EditorRenderer void CreatePermanentResources(); Renderer::Renderer* _renderer; + GameRenderer* _gameRenderer; //DebugRenderer* _debugRenderer; + + Renderer::GraphicsPipelineID _worldGridPipeline; }; diff --git a/Source/Game-Lib/Game-Lib/Rendering/Effect/EffectRenderer.cpp b/Source/Game-Lib/Game-Lib/Rendering/Effect/EffectRenderer.cpp index 17eb9c76..88ebeeea 100644 --- a/Source/Game-Lib/Game-Lib/Rendering/Effect/EffectRenderer.cpp +++ b/Source/Game-Lib/Game-Lib/Rendering/Effect/EffectRenderer.cpp @@ -34,8 +34,9 @@ AutoCVar_Float CVAR_SsaoDetailShadowStrength(CVarCategory::Client | CVarCategory AutoCVar_Float CVAR_SsaoBilateralSigmaSquared(CVarCategory::Client | CVarCategory::Rendering, "ssaoBilateralSigmaSquared", "[0.0, ~ ] Sigma squared value for use in bilateral upsampler giving Gaussian blur term. Should be greater than 0.0", 5.0f, CVarFlags::EditFloatDrag); AutoCVar_Float CVAR_SsaoBilateralSimilarityDistanceSigma(CVarCategory::Client | CVarCategory::Rendering, "ssaoBilateralSimilarityDistanceSigma", "[0.0, ~ ] Sigma squared value for use in bilateral upsampler giving similarity weighting for neighbouring pixels. Should be greater than 0.0", 0.01f, CVarFlags::EditFloatDrag); -EffectRenderer::EffectRenderer(Renderer::Renderer* renderer) +EffectRenderer::EffectRenderer(Renderer::Renderer* renderer, GameRenderer* gameRenderer) : _renderer(renderer) + , _gameRenderer(gameRenderer) { CreatePermanentResources(); } diff --git a/Source/Game-Lib/Game-Lib/Rendering/Effect/EffectRenderer.h b/Source/Game-Lib/Game-Lib/Rendering/Effect/EffectRenderer.h index 09bd7da1..ef0c1dc8 100644 --- a/Source/Game-Lib/Game-Lib/Rendering/Effect/EffectRenderer.h +++ b/Source/Game-Lib/Game-Lib/Rendering/Effect/EffectRenderer.h @@ -12,6 +12,7 @@ namespace Renderer } +class GameRenderer; struct RenderResources; //struct FfxCacaoContext; //struct FfxCacaoSettings; @@ -19,7 +20,7 @@ struct RenderResources; class EffectRenderer { public: - EffectRenderer(Renderer::Renderer* renderer); + EffectRenderer(Renderer::Renderer* renderer, GameRenderer* gameRenderer); ~EffectRenderer(); void Update(f32 deltaTime); @@ -30,7 +31,8 @@ class EffectRenderer void CreatePermanentResources(); private: - Renderer::Renderer* _renderer; + Renderer::Renderer* _renderer = nullptr; + GameRenderer* _gameRenderer = nullptr; //FfxCacaoContext* _cacaoContext = nullptr; //FfxCacaoSettings* _cacaoSettings = nullptr; diff --git a/Source/Game-Lib/Game-Lib/Rendering/GameRenderer.cpp b/Source/Game-Lib/Game-Lib/Rendering/GameRenderer.cpp index 3be5a055..2e784054 100644 --- a/Source/Game-Lib/Game-Lib/Rendering/GameRenderer.cpp +++ b/Source/Game-Lib/Game-Lib/Rendering/GameRenderer.cpp @@ -26,8 +26,13 @@ #include "Game-Lib/Util/ServiceLocator.h" #include +#include +#include + +#include #include + #include #include #include @@ -134,6 +139,14 @@ GameRenderer::GameRenderer(InputManager* inputManager) glfwSetWindowIconifyCallback(_window->GetWindow(), WindowIconifyCallback); _renderer = new Renderer::RendererVK(_window); + _renderer->SetGetShaderEntryCallback([this](u32 shaderNameHash) -> const Renderer::ShaderEntry& + { + return GetShaderEntry(shaderNameHash); + }); + _renderer->SetGetBlitPipelineCallback([this](u32 shaderNameHash) -> Renderer::GraphicsPipelineID + { + return GetBlitPipeline(shaderNameHash); + }); std::string shaderSourcePath = SHADER_SOURCE_DIR; _renderer->SetShaderSourceDirectory(shaderSourcePath); @@ -142,38 +155,38 @@ GameRenderer::GameRenderer(InputManager* inputManager) InitImgui(); _renderer->InitDebug(); - _debugRenderer = new DebugRenderer(_renderer); - _joltDebugRenderer = new JoltDebugRenderer(_renderer, _debugRenderer); + CreatePermanentResources(); + + _debugRenderer = new DebugRenderer(_renderer, this); + _joltDebugRenderer = new JoltDebugRenderer(_renderer, this, _debugRenderer); - _modelRenderer = new ModelRenderer(_renderer, _debugRenderer); - _lightRenderer = new LightRenderer(_renderer, _debugRenderer, _modelRenderer); + _modelRenderer = new ModelRenderer(_renderer, this, _debugRenderer); + _lightRenderer = new LightRenderer(_renderer, this, _debugRenderer, _modelRenderer); _modelLoader = new ModelLoader(_modelRenderer, _lightRenderer); _modelLoader->Init(); - _liquidRenderer = new LiquidRenderer(_renderer, _debugRenderer); + _liquidRenderer = new LiquidRenderer(_renderer, this, _debugRenderer); _liquidLoader = new LiquidLoader(_liquidRenderer); - _terrainRenderer = new TerrainRenderer(_renderer, _debugRenderer); + _terrainRenderer = new TerrainRenderer(_renderer, this, _debugRenderer); _terrainLoader = new TerrainLoader(_terrainRenderer, _modelLoader, _liquidLoader); _terrainManipulator = new TerrainManipulator(*_terrainRenderer, *_debugRenderer); - _textureRenderer = new TextureRenderer(_renderer, _debugRenderer); + _textureRenderer = new TextureRenderer(_renderer, this, _debugRenderer); _modelLoader->SetTerrainLoader(_terrainLoader); _mapLoader = new MapLoader(_terrainLoader, _modelLoader, _liquidLoader); - _materialRenderer = new MaterialRenderer(_renderer, _terrainRenderer, _modelRenderer, _lightRenderer); - _skyboxRenderer = new SkyboxRenderer(_renderer, _debugRenderer); - _editorRenderer = new EditorRenderer(_renderer, _debugRenderer); - _canvasRenderer = new CanvasRenderer(_renderer, _debugRenderer); + _materialRenderer = new MaterialRenderer(_renderer, this, _terrainRenderer, _modelRenderer, _lightRenderer); + _skyboxRenderer = new SkyboxRenderer(_renderer, this, _debugRenderer); + _editorRenderer = new EditorRenderer(_renderer, this, _debugRenderer); + _canvasRenderer = new CanvasRenderer(_renderer, this, _debugRenderer); _uiRenderer = new UIRenderer(_renderer); - _effectRenderer = new EffectRenderer(_renderer); - _shadowRenderer = new ShadowRenderer(_renderer, _debugRenderer, _terrainRenderer, _modelRenderer, _resources); - _pixelQuery = new PixelQuery(_renderer); + _effectRenderer = new EffectRenderer(_renderer, this); + _shadowRenderer = new ShadowRenderer(_renderer, this, _debugRenderer, _terrainRenderer, _modelRenderer, _resources); + _pixelQuery = new PixelQuery(_renderer, this); - CreatePermanentResources(); - - DepthPyramidUtils::InitBuffers(_renderer); + DepthPyramidUtils::Init(_renderer, this); _nameHashToCursor.reserve(128); } @@ -355,6 +368,7 @@ f32 GameRenderer::Render() DepthPyramidUtils::BuildPyramidParams params; params.renderer = _renderer; + params.gameRenderer = this; params.graphResources = &graphResources; params.commandList = &commandList; params.resources = &_resources; @@ -477,6 +491,25 @@ bool GameRenderer::SetCursor(u32 nameHash, u32 imguiMouseCursor /*= 0*/) return true; } +const Renderer::ShaderEntry& GameRenderer::GetShaderEntry(u32 shaderNameHash) +{ + if (_shaderNameHashToShaderEntry.contains(shaderNameHash) == false) + { + NC_LOG_CRITICAL("GameRenderer::GetShaderEntry Tried to get ShaderEntry for unknown shader name hash: {}", shaderNameHash); + } + return _shaderNameHashToShaderEntry[shaderNameHash]; +} + +Renderer::GraphicsPipelineID GameRenderer::GetBlitPipeline(u32 shaderNameHash) +{ + if (_blitPipelines.contains(shaderNameHash) == false) + { + NC_LOG_CRITICAL("GameRenderer::GetBlitPipeline Tried to get Blit Pipeline for unknown shader name hash: {}", shaderNameHash); + } + + return _blitPipelines[shaderNameHash]; +} + bool GameRenderer::SetImguiTheme(u32 themeNameHash) { if (!_themeNameHashToIndex.contains(themeNameHash)) @@ -499,6 +532,34 @@ const std::string& GameRenderer::GetGPUName() } void GameRenderer::CreatePermanentResources() +{ + CreateRenderTargets(); + LoadShaderPacks(); + CreateBlitPipelines(); + + // Frame allocator, this is a fast allocator for data that is only needed this frame + { + const size_t FRAME_ALLOCATOR_SIZE = 16 * 1024 * 1024; // 16 MB + + for (u32 i = 0; i < 2; i++) + { + _frameAllocator[i] = new Memory::StackAllocator(); + _frameAllocator[i]->Init(FRAME_ALLOCATOR_SIZE); + } + } + + _resources.sceneRenderedSemaphore = _renderer->CreateNSemaphore(); + for (u32 i = 0; i < _resources.frameSyncSemaphores.Num; i++) + { + _resources.frameSyncSemaphores.Get(i) = _renderer->CreateNSemaphore(); + } + + _resources.cameras.SetDebugName("Cameras"); + _resources.cameras.SetUsage(Renderer::BufferUsage::STORAGE_BUFFER); + _resources.cameras.Add(Camera()); +} + +void GameRenderer::CreateRenderTargets() { // Visibility Buffer rendertarget Renderer::ImageDesc visibilityBufferDesc; @@ -615,27 +676,111 @@ void GameRenderer::CreatePermanentResources() depthColorCopyDesc.clearColor = Color::Clear; _resources.depthColorCopy = _renderer->CreateImage(depthColorCopyDesc); +} - // Frame allocator, this is a fast allocator for data that is only needed this frame +void GameRenderer::LoadShaderPacks() +{ + // Load all shader packs into memory + std::filesystem::path binPath = std::filesystem::path("Data/Shaders/"); + + // Load all .shaderpack files + for(const auto& entry : std::filesystem::recursive_directory_iterator(binPath)) { - const size_t FRAME_ALLOCATOR_SIZE = 16 * 1024 * 1024; // 16 MB + if (entry.path().extension() != ".shaderpack") + continue; - for (u32 i = 0; i < 2; i++) + FileReader fileReader(entry.path().string()); + if (!fileReader.Open()) { - _frameAllocator[i] = new Memory::StackAllocator(); - _frameAllocator[i]->Init(FRAME_ALLOCATOR_SIZE); + NC_LOG_ERROR("Failed to open shader pack: {}", entry.path().string()); + continue; + } + + u64 bufferSize = fileReader.Length(); + std::shared_ptr buffer = Bytebuffer::BorrowRuntime(bufferSize); + fileReader.Read(buffer.get(), bufferSize); + + FileFormat::ShaderPack shaderPack; + if (!FileFormat::ShaderPack::Read(buffer, shaderPack)) + { + fileReader.Close(); + NC_LOG_ERROR("Failed to read shader pack: {}", entry.path().string()); + continue; } + + LoadShaderPack(buffer, shaderPack); + + std::filesystem::path relativePath = std::filesystem::relative(entry.path(), binPath); + u32 shaderPackNameHash = StringUtils::fnv1a_32(relativePath.string().c_str(), relativePath.string().length()); + _shaderPackBuffers[shaderPackNameHash] = std::move(buffer); } +} - _resources.sceneRenderedSemaphore = _renderer->CreateNSemaphore(); - for (u32 i = 0; i < _resources.frameSyncSemaphores.Num; i++) +void GameRenderer::LoadShaderPack(std::shared_ptr buffer, FileFormat::ShaderPack& shaderPack) +{ + for (u32 i = 0; i < shaderPack.GetNumShaders(); i++) { - _resources.frameSyncSemaphores.Get(i) = _renderer->CreateNSemaphore(); + FileFormat::ShaderRef* shaderRef = shaderPack.GetShaderRef(buffer, i); + + Renderer::ShaderEntry shaderEntry = + { + .permutationNameHash = shaderRef->permutationNameHash, + .shaderData = buffer->GetDataPointer() + shaderRef->dataOffset, + .shaderSize = shaderRef->dataSize, + }; + _shaderNameHashToShaderEntry[shaderRef->permutationNameHash] = shaderEntry; } +} - _resources.cameras.SetDebugName("Cameras"); - _resources.cameras.SetUsage(Renderer::BufferUsage::STORAGE_BUFFER); - _resources.cameras.Add(Camera()); +void GameRenderer::CreateBlitPipelines() +{ + Renderer::VertexShaderDesc vertexShaderDesc; + vertexShaderDesc.shaderEntry = GetShaderEntry("Blitting/Blit.vs.hlsl"_h); + vertexShaderDesc.shaderEntry.debugName = "Blitting/Blit.vs.hlsl"; + Renderer::VertexShaderID vertexShader = _renderer->LoadShader(vertexShaderDesc); + + const char* textureTypes[] = + { + "float", + "int", + "uint" + }; + + Renderer::GraphicsPipelineDesc pipelineDesc; + pipelineDesc.states.vertexShader = vertexShader; + pipelineDesc.states.rasterizerState.cullMode = Renderer::CullMode::BACK; + pipelineDesc.states.rasterizerState.frontFaceMode = Renderer::FrontFaceState::COUNTERCLOCKWISE; + pipelineDesc.states.renderTargetFormats[0] = _renderer->GetSwapChainImageFormat(); + + for (u32 i = 0; i < 3; i++) + { + const char* textureType = textureTypes[i]; + + for (u32 j = 1; j <= 4; j++) + { + std::string componentTypeName = textureType; + if (j > 1) + { + componentTypeName.append(std::to_string(j)); + } + + std::vector permutationFields = + { + { "TEX_TYPE", componentTypeName } + }; + u32 shaderEntryNameHash = Renderer::GetShaderEntryNameHash("Blitting/Blit.ps.hlsl", permutationFields); + + Renderer::PixelShaderDesc pixelShaderDesc; + pixelShaderDesc.shaderEntry = GetShaderEntry(shaderEntryNameHash); + pixelShaderDesc.shaderEntry.debugName = "Blit_" + componentTypeName; + pipelineDesc.debugName = "Blit_" + componentTypeName; + + pipelineDesc.states.pixelShader = _renderer->LoadShader(pixelShaderDesc); + + u32 componentTypeNameHash = StringUtils::fnv1a_32(componentTypeName.c_str(), componentTypeName.length()); + _blitPipelines[componentTypeNameHash] = _renderer->CreatePipeline(pipelineDesc); + } + } } void GameRenderer::CreateImguiThemes() diff --git a/Source/Game-Lib/Game-Lib/Rendering/GameRenderer.h b/Source/Game-Lib/Game-Lib/Rendering/GameRenderer.h index 7f3e63fa..3b00fa56 100644 --- a/Source/Game-Lib/Game-Lib/Rendering/GameRenderer.h +++ b/Source/Game-Lib/Game-Lib/Rendering/GameRenderer.h @@ -16,6 +16,11 @@ namespace Novus class Window; } +namespace FileFormat +{ + struct ShaderPack; +} + struct GLFWwindow; struct GLFWimage; struct GLFWcursor; @@ -86,6 +91,9 @@ class GameRenderer RenderResources& GetRenderResources() { return _resources; } PixelQuery* GetPixelQuery() { return _pixelQuery; } + const Renderer::ShaderEntry& GetShaderEntry(u32 shaderNameHash); + Renderer::GraphicsPipelineID GetBlitPipeline(u32 shaderNameHash); + const std::vector& GetImguiThemes() { return _imguiThemes; } bool IsCurrentTheme(u32 themeNameHash) { return _currentThemeHash == themeNameHash; } bool SetImguiTheme(u32 themeNameHash); @@ -96,6 +104,11 @@ class GameRenderer private: void CreatePermanentResources(); + void CreateRenderTargets(); + void LoadShaderPacks(); + void LoadShaderPack(std::shared_ptr buffer, FileFormat::ShaderPack& shaderPack); + void CreateBlitPipelines(); + void CreateImguiThemes(); void InitImgui(); @@ -148,4 +161,9 @@ class GameRenderer robin_hood::unordered_map _themeNameHashToIndex; robin_hood::unordered_map _nameHashToCursor; + + robin_hood::unordered_map> _shaderPackBuffers; + robin_hood::unordered_map _shaderNameHashToShaderEntry; + + robin_hood::unordered_map _blitPipelines; }; diff --git a/Source/Game-Lib/Game-Lib/Rendering/Light/LightRenderer.cpp b/Source/Game-Lib/Game-Lib/Rendering/Light/LightRenderer.cpp index 0ce813db..c4968257 100644 --- a/Source/Game-Lib/Game-Lib/Rendering/Light/LightRenderer.cpp +++ b/Source/Game-Lib/Game-Lib/Rendering/Light/LightRenderer.cpp @@ -10,6 +10,7 @@ #include "Game-Lib/Editor/EditorHandler.h" #include "Game-Lib/Editor/TerrainTools.h" #include "Game-Lib/Rendering/Debug/DebugRenderer.h" +#include "Game-Lib/Rendering/GameRenderer.h" #include "Game-Lib/Rendering/Model/ModelRenderer.h" #include "Game-Lib/Rendering/RenderResources.h" #include "Game-Lib/Rendering/RenderUtils.h" @@ -26,10 +27,14 @@ AutoCVar_ShowFlag CVAR_DebugLightTiles(CVarCategory::Client | CVarCategory::Rendering, "debugLightTiles", "Debug draw light tiles", ShowFlag::DISABLED); -LightRenderer::LightRenderer(Renderer::Renderer* renderer, DebugRenderer* debugRenderer, ModelRenderer* modelRenderer) +LightRenderer::LightRenderer(Renderer::Renderer* renderer, GameRenderer* gameRenderer, DebugRenderer* debugRenderer, ModelRenderer* modelRenderer) : _renderer(renderer) + , _gameRenderer(gameRenderer) , _debugRenderer(debugRenderer) , _modelRenderer(modelRenderer) + , _classifyPassDescriptorSet(Renderer::DescriptorSetSlot::PER_PASS) + , _debugPassDescriptorSet(Renderer::DescriptorSetSlot::PER_PASS) + , _materialPassDescriptorSet(Renderer::DescriptorSetSlot::LIGHT) { CreatePermanentResources(); } @@ -268,14 +273,7 @@ void LightRenderer::AddClassificationPass(Renderer::RenderGraph* renderGraph, Re { GPU_SCOPED_PROFILER_ZONE(commandList, LightClassificationPass); - Renderer::ComputePipelineDesc pipelineDesc; - graphResources.InitializePipelineDesc(pipelineDesc); - - Renderer::ComputeShaderDesc shaderDesc; - shaderDesc.path = "Light/Classification.cs.hlsl"; - pipelineDesc.computeShader = _renderer->LoadShader(shaderDesc); - - Renderer::ComputePipelineID pipeline = _renderer->CreatePipeline(pipelineDesc); + Renderer::ComputePipelineID pipeline = _classificationPipeline; commandList.BeginPipeline(pipeline); uvec2 outputSize = _renderer->GetImageDimensions(resources.sceneColor, 0); @@ -348,7 +346,7 @@ void LightRenderer::AddDebugPass(Renderer::RenderGraph* renderGraph, RenderResou overlayParams.overlayImage = data.debug; overlayParams.descriptorSet = data.debugSet; - RenderUtils::Overlay(_renderer, graphResources, commandList, frameIndex, overlayParams); + RenderUtils::Overlay(_renderer, _gameRenderer, graphResources, commandList, frameIndex, overlayParams); }); } @@ -389,6 +387,17 @@ void LightRenderer::CreatePermanentResources() _decalAddWork.resize(64); _decalRemoveWork.resize(64); + + // Create pipeline + Renderer::ComputePipelineDesc pipelineDesc; + pipelineDesc.debugName = "LightClassification"; + + Renderer::ComputeShaderDesc shaderDesc; + shaderDesc.shaderEntry = _gameRenderer->GetShaderEntry("Light/Classification.cs.hlsl"_h); + shaderDesc.shaderEntry.debugName = "Light/Classification.cs.hlsl"; + pipelineDesc.computeShader = _renderer->LoadShader(shaderDesc); + + _classificationPipeline = _renderer->CreatePipeline(pipelineDesc); } u32 LightRenderer::CalculateNumTiles(const vec2& size) diff --git a/Source/Game-Lib/Game-Lib/Rendering/Light/LightRenderer.h b/Source/Game-Lib/Game-Lib/Rendering/Light/LightRenderer.h index 3bee256c..1b5cdde1 100644 --- a/Source/Game-Lib/Game-Lib/Rendering/Light/LightRenderer.h +++ b/Source/Game-Lib/Game-Lib/Rendering/Light/LightRenderer.h @@ -18,6 +18,7 @@ namespace Renderer } class DebugRenderer; +class GameRenderer; class ModelRenderer; struct RenderResources; @@ -27,7 +28,7 @@ class LightRenderer static constexpr u32 TILE_SIZE = 16; // in pixels, per axis (16 = 16x16 = 256 pixels per tile) public: - LightRenderer(Renderer::Renderer* renderer, DebugRenderer* debugRenderer, ModelRenderer* modelRenderer); + LightRenderer(Renderer::Renderer* renderer, GameRenderer* gameRenderer, DebugRenderer* debugRenderer, ModelRenderer* modelRenderer); ~LightRenderer(); void Update(f32 deltaTime); @@ -41,7 +42,7 @@ class LightRenderer void RemoveDecal(entt::entity entity); inline u32 CalculateNumTiles(const vec2& size); - inline uvec2 CalculateNumTiles2D(const vec2& size); + uvec2 CalculateNumTiles2D(const vec2& size); Renderer::DescriptorSet& GetTileDescriptorSet() { return _materialPassDescriptorSet; } void RegisterMaterialPassBufferUsage(Renderer::RenderGraphBuilder& builder); @@ -94,7 +95,7 @@ class LightRenderer Renderer::BufferID _entityTilesBuffer; - Renderer::GraphicsPipelineID _debugPipeline; + Renderer::ComputePipelineID _classificationPipeline; moodycamel::ConcurrentQueue _decalAddRequests; std::vector _decalAddWork; @@ -102,6 +103,7 @@ class LightRenderer moodycamel::ConcurrentQueue _decalRemoveRequests; std::vector _decalRemoveWork; + GameRenderer* _gameRenderer = nullptr; DebugRenderer* _debugRenderer = nullptr; ModelRenderer* _modelRenderer = nullptr; }; diff --git a/Source/Game-Lib/Game-Lib/Rendering/Liquid/LiquidRenderer.cpp b/Source/Game-Lib/Game-Lib/Rendering/Liquid/LiquidRenderer.cpp index aa7207bf..bc7fded0 100644 --- a/Source/Game-Lib/Game-Lib/Rendering/Liquid/LiquidRenderer.cpp +++ b/Source/Game-Lib/Game-Lib/Rendering/Liquid/LiquidRenderer.cpp @@ -2,6 +2,7 @@ #include "Game-Lib/ECS/Singletons/Database/ClientDBSingleton.h" #include "Game-Lib/Rendering/Debug/DebugRenderer.h" +#include "Game-Lib/Rendering/GameRenderer.h" #include "Game-Lib/Rendering/RenderUtils.h" #include "Game-Lib/Rendering/RenderResources.h" #include "Game-Lib/Util/ServiceLocator.h" @@ -28,10 +29,12 @@ AutoCVar_Float CVAR_LiquidVisibilityRange(CVarCategory::Client | CVarCategory::R AutoCVar_Int CVAR_LiquidValidateTransfers(CVarCategory::Client | CVarCategory::Rendering, "liquidCalidateGPUVectors", "if enabled ON START we will validate GPUVector uploads", 0, CVarFlags::EditCheckbox); -LiquidRenderer::LiquidRenderer(Renderer::Renderer* renderer, DebugRenderer* debugRenderer) - : CulledRenderer(renderer, debugRenderer) +LiquidRenderer::LiquidRenderer(Renderer::Renderer* renderer, GameRenderer* gameRenderer, DebugRenderer* debugRenderer) + : CulledRenderer(renderer, gameRenderer, debugRenderer) , _renderer(renderer) + , _gameRenderer(gameRenderer) , _debugRenderer(debugRenderer) + , _copyDescriptorSet(Renderer::DescriptorSetSlot::PER_PASS) { if (CVAR_LiquidValidateTransfers.Get()) { @@ -296,6 +299,8 @@ void LiquidRenderer::AddCullingPass(Renderer::RenderGraph* renderGraph, RenderRe builder.Read(_cullingResources.GetDrawCalls().GetBuffer(), BufferUsage::COMPUTE); builder.Read(_cullingResources.GetDrawCallDatas().GetBuffer(), BufferUsage::COMPUTE); + builder.Read(_instanceMatrices.GetBuffer(), BufferUsage::COMPUTE); + data.culledDrawCallsBuffer = builder.Write(_cullingResources.GetCulledDrawsBuffer(), BufferUsage::COMPUTE); data.drawCountBuffer = builder.Write(_cullingResources.GetDrawCountBuffer(), BufferUsage::TRANSFER | BufferUsage::COMPUTE); data.triangleCountBuffer = builder.Write(_cullingResources.GetTriangleCountBuffer(), BufferUsage::TRANSFER | BufferUsage::COMPUTE); @@ -386,7 +391,7 @@ void LiquidRenderer::AddCopyDepthPass(Renderer::RenderGraph* renderGraph, Render copyParams.destinationMip = 0; copyParams.descriptorSet = data.copySet; - RenderUtils::CopyDepthToColor(_renderer, graphResources, commandList, frameIndex, copyParams); + RenderUtils::CopyDepthToColor(_renderer, _gameRenderer, graphResources, commandList, frameIndex, copyParams); }); } @@ -600,8 +605,62 @@ void LiquidRenderer::CreatePermanentResources() .numFramesForTexture = numFramesForBaseTexture }; + _instanceMatrices.SetDebugName("InstanceMatricesLiquid"); + _instanceMatrices.SetUsage(Renderer::BufferUsage::STORAGE_BUFFER); + return true; }); + + // Create pipeline + { + Renderer::GraphicsPipelineDesc pipelineDesc; + + // Shaders + Renderer::VertexShaderDesc vertexShaderDesc; + vertexShaderDesc.shaderEntry = _gameRenderer->GetShaderEntry("Liquid/Draw.vs.hlsl"_h); + vertexShaderDesc.shaderEntry.debugName = "Liquid/Draw.vs.hlsl"; + pipelineDesc.states.vertexShader = _renderer->LoadShader(vertexShaderDesc); + + Renderer::PixelShaderDesc pixelShaderDesc; + pixelShaderDesc.shaderEntry = _gameRenderer->GetShaderEntry("Liquid/Draw.ps.hlsl"_h); + pixelShaderDesc.shaderEntry.debugName = "Liquid/Draw.ps.hlsl"; + pipelineDesc.states.pixelShader = _renderer->LoadShader(pixelShaderDesc); + + // Depth state + pipelineDesc.states.depthStencilState.depthEnable = true; + pipelineDesc.states.depthStencilState.depthFunc = Renderer::ComparisonFunc::GREATER; + + // Rasterizer state + pipelineDesc.states.rasterizerState.cullMode = Renderer::CullMode::BACK; + pipelineDesc.states.rasterizerState.frontFaceMode = Renderer::Settings::FRONT_FACE_STATE; + + // Blend state + pipelineDesc.states.blendState.independentBlendEnable = true; + + pipelineDesc.states.blendState.renderTargets[0].blendEnable = true; + pipelineDesc.states.blendState.renderTargets[0].blendOp = Renderer::BlendOp::ADD; + pipelineDesc.states.blendState.renderTargets[0].srcBlend = Renderer::BlendMode::ONE; + pipelineDesc.states.blendState.renderTargets[0].destBlend = Renderer::BlendMode::ONE; + pipelineDesc.states.blendState.renderTargets[0].srcBlendAlpha = Renderer::BlendMode::ONE; + pipelineDesc.states.blendState.renderTargets[0].destBlendAlpha = Renderer::BlendMode::ONE; + pipelineDesc.states.blendState.renderTargets[0].blendOpAlpha = Renderer::BlendOp::ADD; + + pipelineDesc.states.blendState.renderTargets[1].blendEnable = true; + pipelineDesc.states.blendState.renderTargets[1].blendOp = Renderer::BlendOp::ADD; + pipelineDesc.states.blendState.renderTargets[1].srcBlend = Renderer::BlendMode::ZERO; + pipelineDesc.states.blendState.renderTargets[1].destBlend = Renderer::BlendMode::INV_SRC_ALPHA; + pipelineDesc.states.blendState.renderTargets[1].srcBlendAlpha = Renderer::BlendMode::ZERO; + pipelineDesc.states.blendState.renderTargets[1].destBlendAlpha = Renderer::BlendMode::INV_SRC_ALPHA; + pipelineDesc.states.blendState.renderTargets[1].blendOpAlpha = Renderer::BlendOp::ADD; + + // Render targets + pipelineDesc.states.renderTargetFormats[0] = Renderer::ImageFormat::R16G16B16A16_FLOAT; + pipelineDesc.states.renderTargetFormats[1] = Renderer::ImageFormat::R16_FLOAT; + + pipelineDesc.states.depthStencilFormat = Renderer::DepthImageFormat::D32_FLOAT; + + _liquidPipeline = _renderer->CreatePipeline(pipelineDesc); // This will compile the pipeline and return the ID, or just return ID of cached pipeline + } } void LiquidRenderer::SyncToGPU() @@ -629,6 +688,12 @@ void LiquidRenderer::SyncToGPU() } } + // Really there shouldn't be instanceMatrices, but we need to bind them + if (_instanceMatrices.SyncToGPU(_renderer)) + { + _cullingResources.GetCullingDescriptorSet().Bind("_instanceMatrices", _instanceMatrices.GetBuffer()); + } + _cullingResources.SyncToGPU(_instancesIsDirty); BindCullingResource(_cullingResources); } @@ -647,59 +712,8 @@ void LiquidRenderer::Draw(const RenderResources& resources, u8 frameIndex, Rende renderPassDesc.depthStencil = params.depth; commandList.BeginRenderPass(renderPassDesc); - Renderer::GraphicsPipelineDesc pipelineDesc; - - // Shaders - Renderer::VertexShaderDesc vertexShaderDesc; - vertexShaderDesc.path = "Liquid/Draw.vs.hlsl"; - - pipelineDesc.states.vertexShader = _renderer->LoadShader(vertexShaderDesc); - - Renderer::PixelShaderDesc pixelShaderDesc; - pixelShaderDesc.path = "Liquid/Draw.ps.hlsl"; - pipelineDesc.states.pixelShader = _renderer->LoadShader(pixelShaderDesc); - - // Depth state - pipelineDesc.states.depthStencilState.depthEnable = true; - pipelineDesc.states.depthStencilState.depthFunc = Renderer::ComparisonFunc::GREATER; - - // Rasterizer state - pipelineDesc.states.rasterizerState.cullMode = Renderer::CullMode::BACK; - pipelineDesc.states.rasterizerState.frontFaceMode = Renderer::Settings::FRONT_FACE_STATE; - - // Blend state - pipelineDesc.states.blendState.independentBlendEnable = true; - - pipelineDesc.states.blendState.renderTargets[0].blendEnable = true; - pipelineDesc.states.blendState.renderTargets[0].blendOp = Renderer::BlendOp::ADD; - pipelineDesc.states.blendState.renderTargets[0].srcBlend = Renderer::BlendMode::ONE; - pipelineDesc.states.blendState.renderTargets[0].destBlend = Renderer::BlendMode::ONE; - pipelineDesc.states.blendState.renderTargets[0].srcBlendAlpha = Renderer::BlendMode::ONE; - pipelineDesc.states.blendState.renderTargets[0].destBlendAlpha = Renderer::BlendMode::ONE; - pipelineDesc.states.blendState.renderTargets[0].blendOpAlpha = Renderer::BlendOp::ADD; - - pipelineDesc.states.blendState.renderTargets[1].blendEnable = true; - pipelineDesc.states.blendState.renderTargets[1].blendOp = Renderer::BlendOp::ADD; - pipelineDesc.states.blendState.renderTargets[1].srcBlend = Renderer::BlendMode::ZERO; - pipelineDesc.states.blendState.renderTargets[1].destBlend = Renderer::BlendMode::INV_SRC_ALPHA; - pipelineDesc.states.blendState.renderTargets[1].srcBlendAlpha = Renderer::BlendMode::ZERO; - pipelineDesc.states.blendState.renderTargets[1].destBlendAlpha = Renderer::BlendMode::INV_SRC_ALPHA; - pipelineDesc.states.blendState.renderTargets[1].blendOpAlpha = Renderer::BlendOp::ADD; - - // Render targets - const Renderer::ImageDesc& rt0Desc = graphResources.GetImageDesc(params.rt0); - pipelineDesc.states.renderTargetFormats[0] = rt0Desc.format; - - if (params.rt1 != Renderer::ImageMutableResource::Invalid()) - { - const Renderer::ImageDesc& rt1Desc = graphResources.GetImageDesc(params.rt1); - pipelineDesc.states.renderTargetFormats[1] = rt1Desc.format; - } - const Renderer::DepthImageDesc& depthDesc = graphResources.GetImageDesc(params.depth); - pipelineDesc.states.depthStencilFormat = depthDesc.format; - // Draw - Renderer::GraphicsPipelineID pipeline = _renderer->CreatePipeline(pipelineDesc); // This will compile the pipeline and return the ID, or just return ID of cached pipeline + Renderer::GraphicsPipelineID pipeline = _liquidPipeline; commandList.BeginPipeline(pipeline); commandList.BindDescriptorSet(Renderer::DescriptorSetSlot::GLOBAL, params.globalDescriptorSet, frameIndex); diff --git a/Source/Game-Lib/Game-Lib/Rendering/Liquid/LiquidRenderer.h b/Source/Game-Lib/Game-Lib/Rendering/Liquid/LiquidRenderer.h index 3828e007..b65a677d 100644 --- a/Source/Game-Lib/Game-Lib/Rendering/Liquid/LiquidRenderer.h +++ b/Source/Game-Lib/Game-Lib/Rendering/Liquid/LiquidRenderer.h @@ -9,6 +9,7 @@ namespace Renderer } class DebugRenderer; +class GameRenderer; struct LiquidReserveOffsets { @@ -72,7 +73,7 @@ class LiquidRenderer : CulledRenderer }; public: - LiquidRenderer(Renderer::Renderer* renderer, DebugRenderer* debugRenderer); + LiquidRenderer(Renderer::Renderer* renderer, GameRenderer* gameRenderer, DebugRenderer* debugRenderer); ~LiquidRenderer(); void Update(f32 deltaTime); @@ -128,10 +129,13 @@ class LiquidRenderer : CulledRenderer private: Renderer::Renderer* _renderer = nullptr; + GameRenderer* _gameRenderer = nullptr; DebugRenderer* _debugRenderer = nullptr; Renderer::DescriptorSet _copyDescriptorSet; + Renderer::GraphicsPipelineID _liquidPipeline; + Constants _constants; Renderer::SamplerID _sampler; @@ -141,6 +145,7 @@ class LiquidRenderer : CulledRenderer CullingResourcesIndexed _cullingResources; Renderer::GPUVector _vertices; Renderer::GPUVector _indices; + Renderer::GPUVector _instanceMatrices; robin_hood::unordered_map _liquidTypeIDToLiquidTextureMap; diff --git a/Source/Game-Lib/Game-Lib/Rendering/Material/MaterialRenderer.cpp b/Source/Game-Lib/Game-Lib/Rendering/Material/MaterialRenderer.cpp index cf175291..b03cf167 100644 --- a/Source/Game-Lib/Game-Lib/Rendering/Material/MaterialRenderer.cpp +++ b/Source/Game-Lib/Game-Lib/Rendering/Material/MaterialRenderer.cpp @@ -3,6 +3,7 @@ #include "Game-Lib/Application/EnttRegistries.h" #include "Game-Lib/Editor/EditorHandler.h" #include "Game-Lib/Editor/TerrainTools.h" +#include "Game-Lib/Rendering/GameRenderer.h" #include "Game-Lib/Rendering/Debug/DebugRenderer.h" #include "Game-Lib/Rendering/Light/LightRenderer.h" #include "Game-Lib/Rendering/Model/ModelRenderer.h" @@ -25,11 +26,14 @@ AutoCVar_VecFloat CVAR_FogColor(CVarCategory::Client | CVarCategory::Rendering, AutoCVar_Float CVAR_FogBeginDist(CVarCategory::Client | CVarCategory::Rendering, "fogBlendBegin", "Fog blending start distance", 200.0f, CVarFlags::EditFloatDrag); AutoCVar_Float CVAR_FogEndDist(CVarCategory::Client | CVarCategory::Rendering, "fogBlendEnd", "Fog blending end distance", 600.0f, CVarFlags::EditFloatDrag); -MaterialRenderer::MaterialRenderer(Renderer::Renderer* renderer, TerrainRenderer* terrainRenderer, ModelRenderer* modelRenderer, LightRenderer* lightRenderer) +MaterialRenderer::MaterialRenderer(Renderer::Renderer* renderer, GameRenderer* gameRenderer, TerrainRenderer* terrainRenderer, ModelRenderer* modelRenderer, LightRenderer* lightRenderer) : _renderer(renderer) + , _gameRenderer(gameRenderer) , _terrainRenderer(terrainRenderer) , _modelRenderer(modelRenderer) , _lightRenderer(lightRenderer) + , _preEffectsPassDescriptorSet(Renderer::DescriptorSetSlot::PER_PASS) + , _materialPassDescriptorSet(Renderer::DescriptorSetSlot::PER_PASS) { CreatePermanentResources(); } @@ -84,15 +88,7 @@ void MaterialRenderer::AddPreEffectsPass(Renderer::RenderGraph* renderGraph, Ren { GPU_SCOPED_PROFILER_ZONE(commandList, PreEffectsPass); - Renderer::ComputePipelineDesc pipelineDesc; - graphResources.InitializePipelineDesc(pipelineDesc); - - Renderer::ComputeShaderDesc shaderDesc; - shaderDesc.path = "PreEffectsPass.cs.hlsl"; - pipelineDesc.computeShader = _renderer->LoadShader(shaderDesc); - - Renderer::ComputePipelineID pipeline = _renderer->CreatePipeline(pipelineDesc); - commandList.BeginPipeline(pipeline); + commandList.BeginPipeline(_preEffectsPipeline); data.preEffectsSet.Bind("_visibilityBuffer", data.visibilityBuffer); data.preEffectsSet.BindStorage("_packedNormals", data.packedNormals, 0); @@ -116,7 +112,7 @@ void MaterialRenderer::AddPreEffectsPass(Renderer::RenderGraph* renderGraph, Ren uvec2 dispatchSize = uvec2((outputSize.x + 7) / 8, (outputSize.y + 7) / 8); commandList.Dispatch(dispatchSize.x, dispatchSize.y, 1); - commandList.EndPipeline(pipeline); + commandList.EndPipeline(_preEffectsPipeline); }); } @@ -179,21 +175,7 @@ void MaterialRenderer::AddMaterialPass(Renderer::RenderGraph* renderGraph, Rende { GPU_SCOPED_PROFILER_ZONE(commandList, MaterialPass); - Renderer::ComputePipelineDesc pipelineDesc; - graphResources.InitializePipelineDesc(pipelineDesc); - - const i32 shadowFilterMode = *CVarSystem::Get()->GetIntCVar(CVarCategory::Client | CVarCategory::Rendering, "shadowFilterMode"_h); - - Renderer::ComputeShaderDesc shaderDesc; - shaderDesc.path = "MaterialPass.cs.hlsl"; - shaderDesc.AddPermutationField("DEBUG_ID", std::to_string(visibilityBufferDebugID)); - shaderDesc.AddPermutationField("SHADOW_FILTER_MODE", std::to_string(shadowFilterMode)); - shaderDesc.AddPermutationField("SUPPORTS_EXTENDED_TEXTURES", _renderer->HasExtendedTextureSupport() ? "1" : "0"); - shaderDesc.AddPermutationField("EDITOR_MODE", CVAR_DrawTerrainWireframe.Get() == ShowFlag::ENABLED ? "1" : "0"); - pipelineDesc.computeShader = _renderer->LoadShader(shaderDesc); - - Renderer::ComputePipelineID pipeline = _renderer->CreatePipeline(pipelineDesc); - commandList.BeginPipeline(pipeline); + commandList.BeginPipeline(_materialPipeline); // For some reason, this works when we're binding to modelSet despite the GPU side being bound as PER_PASS??? data.materialSet.Bind("_visibilityBuffer", data.visibilityBuffer); @@ -274,7 +256,7 @@ void MaterialRenderer::AddMaterialPass(Renderer::RenderGraph* renderGraph, Rende uvec2 dispatchSize = uvec2((outputSize.x + 7) / 8, (outputSize.y + 7) / 8); commandList.Dispatch(dispatchSize.x, dispatchSize.y, 1); - commandList.EndPipeline(pipeline); + commandList.EndPipeline(_materialPipeline); }); } @@ -313,6 +295,36 @@ bool MaterialRenderer::SetDirectionalLight(u32 index, const vec3& direction, con void MaterialRenderer::CreatePermanentResources() { + // Create Pre-Effects Pipeline + Renderer::ComputeShaderDesc shaderDesc; + shaderDesc.shaderEntry = _gameRenderer->GetShaderEntry("Material/PreEffectsPass.cs.hlsl"_h); + shaderDesc.shaderEntry.debugName = "Material/PreEffectsPass.cs.hlsl"; + + Renderer::ComputePipelineDesc pipelineDesc; + pipelineDesc.computeShader = _renderer->LoadShader(shaderDesc); + _preEffectsPipeline = _renderer->CreatePipeline(pipelineDesc); + + // Create Material Pipeline + CreateMaterialPipeline(); + + CVAR_VisibilityBufferDebugID.AddOnValueChanged([this](const i32& val) + { + CreateMaterialPipeline(); + }); + CVAR_DrawTerrainWireframe.AddOnValueChanged([this](const ShowFlag& val) + { + CreateMaterialPipeline(); + }); + + CVarSystem::Get()->AddOnIntValueChanged(CVarCategory::Client | CVarCategory::Rendering, "shadowFilterMode"_h, [this](const i32& val) + { + CreateMaterialPipeline(); + }); + + // Register pipelines with descriptor sets + _preEffectsPassDescriptorSet.RegisterPipeline(_renderer, _preEffectsPipeline); + _materialPassDescriptorSet.RegisterPipeline(_renderer, _materialPipeline); + Renderer::SamplerDesc samplerDesc; samplerDesc.enabled = true; samplerDesc.filter = Renderer::SamplerFilter::MIN_MAG_MIP_LINEAR; @@ -343,6 +355,29 @@ void MaterialRenderer::CreatePermanentResources() AddDirectionalLight(direction, color, intensity, groundAmbientColor, groundAmbientIntensity, skyAmbientColor, skyAmbientIntensity, shadowColor); } +void MaterialRenderer::CreateMaterialPipeline() +{ + const i32 shadowFilterMode = *CVarSystem::Get()->GetIntCVar(CVarCategory::Client | CVarCategory::Rendering, "shadowFilterMode"_h); + + std::vector permutationFields = + { + { "DEBUG_ID", std::to_string(CVAR_VisibilityBufferDebugID.Get()) }, + { "SHADOW_FILTER_MODE", std::to_string(shadowFilterMode) }, + { "SUPPORTS_EXTENDED_TEXTURES", _renderer->HasExtendedTextureSupport() ? "1" : "0" }, + { "EDITOR_MODE", CVAR_DrawTerrainWireframe.Get() == ShowFlag::ENABLED ? "1" : "0" } + }; + u32 shaderEntryNameHash = Renderer::GetShaderEntryNameHash("Material/MaterialPass.cs.hlsl", permutationFields); + + Renderer::ComputeShaderDesc shaderDesc; + shaderDesc.shaderEntry = shaderDesc.shaderEntry = _gameRenderer->GetShaderEntry(shaderEntryNameHash); + shaderDesc.shaderEntry.debugName = "Material/MaterialPass.cs.hlsl"; + + Renderer::ComputePipelineDesc pipelineDesc; + pipelineDesc.computeShader = _renderer->LoadShader(shaderDesc); + + _materialPipeline = _renderer->CreatePipeline(pipelineDesc); +} + void MaterialRenderer::SyncToGPU() { if (_directionalLights.SyncToGPU(_renderer)) diff --git a/Source/Game-Lib/Game-Lib/Rendering/Material/MaterialRenderer.h b/Source/Game-Lib/Game-Lib/Rendering/Material/MaterialRenderer.h index 20d5eb6d..1e902004 100644 --- a/Source/Game-Lib/Game-Lib/Rendering/Material/MaterialRenderer.h +++ b/Source/Game-Lib/Game-Lib/Rendering/Material/MaterialRenderer.h @@ -12,15 +12,16 @@ namespace Renderer } -class TerrainRenderer; -class ModelRenderer; +class GameRenderer; class LightRenderer; +class ModelRenderer; +class TerrainRenderer; struct RenderResources; class MaterialRenderer { public: - MaterialRenderer(Renderer::Renderer* renderer, TerrainRenderer* terrainRenderer, ModelRenderer* modelRenderer, LightRenderer* lightRenderer); + MaterialRenderer(Renderer::Renderer* renderer, GameRenderer* gameRenderer, TerrainRenderer* terrainRenderer, ModelRenderer* modelRenderer, LightRenderer* lightRenderer); ~MaterialRenderer(); void Update(f32 deltaTime); @@ -34,6 +35,7 @@ class MaterialRenderer private: void CreatePermanentResources(); + void CreateMaterialPipeline(); void SyncToGPU(); @@ -49,6 +51,10 @@ class MaterialRenderer private: Renderer::Renderer* _renderer; + GameRenderer* _gameRenderer; + + Renderer::ComputePipelineID _preEffectsPipeline; + Renderer::ComputePipelineID _materialPipeline; Renderer::DescriptorSet _preEffectsPassDescriptorSet; Renderer::DescriptorSet _materialPassDescriptorSet; diff --git a/Source/Game-Lib/Game-Lib/Rendering/Model/ModelRenderer.cpp b/Source/Game-Lib/Game-Lib/Rendering/Model/ModelRenderer.cpp index 10fe56af..6c8a7255 100644 --- a/Source/Game-Lib/Game-Lib/Rendering/Model/ModelRenderer.cpp +++ b/Source/Game-Lib/Game-Lib/Rendering/Model/ModelRenderer.cpp @@ -53,10 +53,12 @@ AutoCVar_Int CVAR_ModelValidateTransfers(CVarCategory::Client | CVarCategory::Re AutoCVar_Int CVAR_ModelsCastShadow(CVarCategory::Client | CVarCategory::Rendering, "shadowModelsCastShadow", "should Models cast shadows", 1, CVarFlags::EditCheckbox); -ModelRenderer::ModelRenderer(Renderer::Renderer* renderer, DebugRenderer* debugRenderer) - : CulledRenderer(renderer, debugRenderer) +ModelRenderer::ModelRenderer(Renderer::Renderer* renderer, GameRenderer* gameRenderer, DebugRenderer* debugRenderer) + : CulledRenderer(renderer, gameRenderer, debugRenderer) , _renderer(renderer) + , _gameRenderer(gameRenderer) , _debugRenderer(debugRenderer) + , _materialPassDescriptorSet(Renderer::DescriptorSetSlot::MODEL) { CreatePermanentResources(); @@ -2593,8 +2595,245 @@ void ModelRenderer::CreatePermanentResources() _textureTransformMatrices.SetDebugName("ModelInstanceTextureTransformMatrices"); _textureTransformMatrices.SetUsage(Renderer::BufferUsage::STORAGE_BUFFER); } + + CreateModelPipelines(); } +void ModelRenderer::CreateModelPipelines() +{ + bool supportsExtendedTextures = _renderer->HasExtendedTextureSupport(); + + // Regular Draws + { + Renderer::GraphicsPipelineDesc pipelineDesc; + // Depth state + pipelineDesc.states.depthStencilState.depthEnable = true; + pipelineDesc.states.depthStencilState.depthWriteEnable = true; + pipelineDesc.states.depthStencilState.depthFunc = Renderer::ComparisonFunc::GREATER; + + // Rasterizer state + pipelineDesc.states.rasterizerState.cullMode = Renderer::CullMode::BACK; + pipelineDesc.states.rasterizerState.frontFaceMode = Renderer::Settings::FRONT_FACE_STATE; + + pipelineDesc.states.renderTargetFormats[0] = Renderer::ImageFormat::R32G32_UINT; // Visibility buffer format + pipelineDesc.states.depthStencilFormat = Renderer::DepthImageFormat::D32_FLOAT; + + Renderer::VertexShaderDesc vertexShaderDesc; + std::vector vertexPermutationFields = + { + { "EDITOR_PASS", "0" }, + { "SHADOW_PASS", "0"}, + { "SUPPORTS_EXTENDED_TEXTURES", supportsExtendedTextures ? "1" : "0" } + }; + u32 shaderEntryNameHash = Renderer::GetShaderEntryNameHash("Model/Draw.vs.hlsl", vertexPermutationFields); + vertexShaderDesc.shaderEntry = _gameRenderer->GetShaderEntry(shaderEntryNameHash); + vertexShaderDesc.shaderEntry.debugName = "Model/Draw.vs.hlsl"; + pipelineDesc.states.vertexShader = _renderer->LoadShader(vertexShaderDesc); + + Renderer::PixelShaderDesc pixelShaderDesc; + std::vector pixelPermutationFields = + { + { "SHADOW_PASS", "0" }, + { "SUPPORTS_EXTENDED_TEXTURES", supportsExtendedTextures ? "1" : "0" } + }; + shaderEntryNameHash = Renderer::GetShaderEntryNameHash("Model/Draw.ps.hlsl", pixelPermutationFields); + pixelShaderDesc.shaderEntry = _gameRenderer->GetShaderEntry(shaderEntryNameHash); + pixelShaderDesc.shaderEntry.debugName = "Model/Draw.ps.hlsl"; + pipelineDesc.states.pixelShader = _renderer->LoadShader(pixelShaderDesc); + + _drawPipeline = _renderer->CreatePipeline(pipelineDesc); + } + // Shadows + { + Renderer::GraphicsPipelineDesc pipelineDesc; + // Rasterizer state + pipelineDesc.states.rasterizerState.cullMode = Renderer::CullMode::NONE; + pipelineDesc.states.rasterizerState.depthBiasEnabled = true; + pipelineDesc.states.rasterizerState.depthClampEnabled = true; + + pipelineDesc.states.depthStencilFormat = Renderer::DepthImageFormat::D32_FLOAT; + + Renderer::VertexShaderDesc vertexShaderDesc; + std::vector vertexPermutationFields = + { + { "EDITOR_PASS", "0" }, + { "SHADOW_PASS", "1"}, + { "SUPPORTS_EXTENDED_TEXTURES", supportsExtendedTextures ? "1" : "0" } + }; + u32 shaderEntryNameHash = Renderer::GetShaderEntryNameHash("Model/Draw.vs.hlsl", vertexPermutationFields); + vertexShaderDesc.shaderEntry = _gameRenderer->GetShaderEntry(shaderEntryNameHash); + vertexShaderDesc.shaderEntry.debugName = "Model/Draw.vs.hlsl"; + pipelineDesc.states.vertexShader = _renderer->LoadShader(vertexShaderDesc); + + Renderer::PixelShaderDesc pixelShaderDesc; + std::vector pixelPermutationFields = + { + { "SHADOW_PASS", "1" }, + { "SUPPORTS_EXTENDED_TEXTURES", supportsExtendedTextures ? "1" : "0" } + }; + shaderEntryNameHash = Renderer::GetShaderEntryNameHash("Model/Draw.ps.hlsl", pixelPermutationFields); + pixelShaderDesc.shaderEntry = _gameRenderer->GetShaderEntry(shaderEntryNameHash); + pixelShaderDesc.shaderEntry.debugName = "Model/Draw.ps.hlsl"; + pipelineDesc.states.pixelShader = _renderer->LoadShader(pixelShaderDesc); + + // Draw + _drawShadowPipeline = _renderer->CreatePipeline(pipelineDesc); + } + // Transparencies + { + Renderer::GraphicsPipelineDesc pipelineDesc; + // Depth state + pipelineDesc.states.depthStencilState.depthEnable = true; + pipelineDesc.states.depthStencilState.depthFunc = Renderer::ComparisonFunc::GREATER; + + // Rasterizer state + pipelineDesc.states.rasterizerState.cullMode = Renderer::CullMode::BACK; + pipelineDesc.states.rasterizerState.frontFaceMode = Renderer::Settings::FRONT_FACE_STATE; + + // Blend state + pipelineDesc.states.blendState.independentBlendEnable = true; + + pipelineDesc.states.blendState.renderTargets[0].blendEnable = true; + pipelineDesc.states.blendState.renderTargets[0].blendOp = Renderer::BlendOp::ADD; + pipelineDesc.states.blendState.renderTargets[0].srcBlend = Renderer::BlendMode::ONE; + pipelineDesc.states.blendState.renderTargets[0].destBlend = Renderer::BlendMode::ONE; + pipelineDesc.states.blendState.renderTargets[0].srcBlendAlpha = Renderer::BlendMode::ONE; + pipelineDesc.states.blendState.renderTargets[0].destBlendAlpha = Renderer::BlendMode::ONE; + pipelineDesc.states.blendState.renderTargets[0].blendOpAlpha = Renderer::BlendOp::ADD; + + pipelineDesc.states.blendState.renderTargets[1].blendEnable = true; + pipelineDesc.states.blendState.renderTargets[1].blendOp = Renderer::BlendOp::ADD; + pipelineDesc.states.blendState.renderTargets[1].srcBlend = Renderer::BlendMode::ZERO; + pipelineDesc.states.blendState.renderTargets[1].destBlend = Renderer::BlendMode::INV_SRC_ALPHA; + pipelineDesc.states.blendState.renderTargets[1].srcBlendAlpha = Renderer::BlendMode::ZERO; + pipelineDesc.states.blendState.renderTargets[1].destBlendAlpha = Renderer::BlendMode::INV_SRC_ALPHA; + pipelineDesc.states.blendState.renderTargets[1].blendOpAlpha = Renderer::BlendOp::ADD; + + pipelineDesc.states.renderTargetFormats[0] = Renderer::ImageFormat::R16G16B16A16_FLOAT; // Transparency format + pipelineDesc.states.renderTargetFormats[1] = Renderer::ImageFormat::R16_FLOAT; // Transparency weight format + pipelineDesc.states.depthStencilFormat = Renderer::DepthImageFormat::D32_FLOAT; + + Renderer::VertexShaderDesc vertexShaderDesc; + std::vector permutationFields = + { + { "SUPPORTS_EXTENDED_TEXTURES", supportsExtendedTextures ? "1" : "0" } + }; + u32 shaderEntryNameHash = Renderer::GetShaderEntryNameHash("Model/DrawTransparent.vs.hlsl", permutationFields); + vertexShaderDesc.shaderEntry = _gameRenderer->GetShaderEntry(shaderEntryNameHash); + vertexShaderDesc.shaderEntry.debugName = "Model/DrawTransparent.vs.hlsl"; + pipelineDesc.states.vertexShader = _renderer->LoadShader(vertexShaderDesc); + + + Renderer::PixelShaderDesc pixelShaderDesc; + shaderEntryNameHash = Renderer::GetShaderEntryNameHash("Model/DrawTransparent.ps.hlsl", permutationFields); + pixelShaderDesc.shaderEntry = _gameRenderer->GetShaderEntry(shaderEntryNameHash); + pixelShaderDesc.shaderEntry.debugName = "Model/DrawTransparent.ps.hlsl"; + pipelineDesc.states.pixelShader = _renderer->LoadShader(pixelShaderDesc); + + // Draw + _drawTransparentPipeline = _renderer->CreatePipeline(pipelineDesc); + } + // Skybox Opaque + { + Renderer::GraphicsPipelineDesc pipelineDesc; + // Depth state + pipelineDesc.states.depthStencilState.depthEnable = true; + pipelineDesc.states.depthStencilState.depthWriteEnable = true; + pipelineDesc.states.depthStencilState.depthFunc = Renderer::ComparisonFunc::GREATER; + + // Rasterizer state + pipelineDesc.states.rasterizerState.cullMode = Renderer::CullMode::BACK; + pipelineDesc.states.rasterizerState.frontFaceMode = Renderer::Settings::FRONT_FACE_STATE; + + // Render targets + pipelineDesc.states.renderTargetFormats[0] = _renderer->GetSwapChainImageFormat(); + pipelineDesc.states.depthStencilFormat = Renderer::DepthImageFormat::D32_FLOAT; + + Renderer::VertexShaderDesc vertexShaderDesc; + std::vector vertexPermutationFields = + { + { "SUPPORTS_EXTENDED_TEXTURES", supportsExtendedTextures ? "1" : "0" } + }; + u32 shaderEntryNameHash = Renderer::GetShaderEntryNameHash("Model/DrawSkybox.vs.hlsl", vertexPermutationFields); + vertexShaderDesc.shaderEntry = _gameRenderer->GetShaderEntry(shaderEntryNameHash); + vertexShaderDesc.shaderEntry.debugName = "Model/DrawSkybox.vs.hlsl"; + pipelineDesc.states.vertexShader = _renderer->LoadShader(vertexShaderDesc); + + Renderer::PixelShaderDesc pixelShaderDesc; + std::vector pixelPermutationFields = + { + { "SUPPORTS_EXTENDED_TEXTURES", supportsExtendedTextures ? "1" : "0" }, + { "TRANSPARENCY", "0" } + }; + shaderEntryNameHash = Renderer::GetShaderEntryNameHash("Model/DrawSkybox.ps.hlsl", pixelPermutationFields); + pixelShaderDesc.shaderEntry = _gameRenderer->GetShaderEntry(shaderEntryNameHash); + pixelShaderDesc.shaderEntry.debugName = "Model/DrawSkybox.ps.hlsl"; + pipelineDesc.states.pixelShader = _renderer->LoadShader(pixelShaderDesc); + + // Draw + _drawSkyboxOpaquePipeline = _renderer->CreatePipeline(pipelineDesc); + } + // Skybox Transparent + { + Renderer::GraphicsPipelineDesc pipelineDesc; + // Depth state + pipelineDesc.states.depthStencilState.depthEnable = false; // Is this really correct? + pipelineDesc.states.depthStencilState.depthWriteEnable = false; + pipelineDesc.states.depthStencilState.depthFunc = Renderer::ComparisonFunc::GREATER; + + // Blend state + pipelineDesc.states.blendState.independentBlendEnable = true; + + pipelineDesc.states.blendState.renderTargets[0].blendEnable = true; + pipelineDesc.states.blendState.renderTargets[0].blendOp = Renderer::BlendOp::ADD; + pipelineDesc.states.blendState.renderTargets[0].srcBlend = Renderer::BlendMode::ONE; + pipelineDesc.states.blendState.renderTargets[0].destBlend = Renderer::BlendMode::ONE; + pipelineDesc.states.blendState.renderTargets[0].srcBlendAlpha = Renderer::BlendMode::ONE; + pipelineDesc.states.blendState.renderTargets[0].destBlendAlpha = Renderer::BlendMode::ONE; + pipelineDesc.states.blendState.renderTargets[0].blendOpAlpha = Renderer::BlendOp::ADD; + + pipelineDesc.states.blendState.renderTargets[1].blendEnable = true; + pipelineDesc.states.blendState.renderTargets[1].blendOp = Renderer::BlendOp::ADD; + pipelineDesc.states.blendState.renderTargets[1].srcBlend = Renderer::BlendMode::ZERO; + pipelineDesc.states.blendState.renderTargets[1].destBlend = Renderer::BlendMode::INV_SRC_ALPHA; + pipelineDesc.states.blendState.renderTargets[1].srcBlendAlpha = Renderer::BlendMode::ZERO; + pipelineDesc.states.blendState.renderTargets[1].destBlendAlpha = Renderer::BlendMode::INV_SRC_ALPHA; + pipelineDesc.states.blendState.renderTargets[1].blendOpAlpha = Renderer::BlendOp::ADD; + + // Rasterizer state + pipelineDesc.states.rasterizerState.cullMode = Renderer::CullMode::BACK; + pipelineDesc.states.rasterizerState.frontFaceMode = Renderer::Settings::FRONT_FACE_STATE; + + // Render targets + pipelineDesc.states.renderTargetFormats[0] = Renderer::ImageFormat::R16G16B16A16_FLOAT; // Transparency format + pipelineDesc.states.renderTargetFormats[1] = Renderer::ImageFormat::R16_FLOAT; // Transparency weight format + pipelineDesc.states.depthStencilFormat = Renderer::DepthImageFormat::D32_FLOAT; + + Renderer::VertexShaderDesc vertexShaderDesc; + std::vector vertexPermutationFields = + { + { "SUPPORTS_EXTENDED_TEXTURES", supportsExtendedTextures ? "1" : "0" } + }; + u32 shaderEntryNameHash = Renderer::GetShaderEntryNameHash("Model/DrawSkybox.vs.hlsl", vertexPermutationFields); + vertexShaderDesc.shaderEntry = _gameRenderer->GetShaderEntry(shaderEntryNameHash); + vertexShaderDesc.shaderEntry.debugName = "Model/DrawSkybox.vs.hlsl"; + pipelineDesc.states.vertexShader = _renderer->LoadShader(vertexShaderDesc); + + Renderer::PixelShaderDesc pixelShaderDesc; + std::vector pixelPermutationFields = + { + { "SUPPORTS_EXTENDED_TEXTURES", supportsExtendedTextures ? "1" : "0" }, + { "TRANSPARENCY", "1" } + }; + shaderEntryNameHash = Renderer::GetShaderEntryNameHash("Model/DrawSkybox.ps.hlsl", pixelPermutationFields); + pixelShaderDesc.shaderEntry = _gameRenderer->GetShaderEntry(shaderEntryNameHash); + pixelShaderDesc.shaderEntry.debugName = "Model/DrawSkybox.ps.hlsl"; + pipelineDesc.states.pixelShader = _renderer->LoadShader(pixelShaderDesc); + + // Draw + _drawSkyboxOpaquePipeline = _renderer->CreatePipeline(pipelineDesc); + } +} void ModelRenderer::AllocateModel(const Model::ComplexModel& model, ModelOffsets& offsets) { @@ -3176,51 +3415,7 @@ void ModelRenderer::Draw(const RenderResources& resources, u8 frameIndex, Render renderPassDesc.depthStencil = params.depth; commandList.BeginRenderPass(renderPassDesc); - Renderer::GraphicsPipelineDesc pipelineDesc; - - // Shaders - Renderer::VertexShaderDesc vertexShaderDesc; - vertexShaderDesc.path = "Model/Draw.vs.hlsl"; - vertexShaderDesc.AddPermutationField("EDITOR_PASS", "0"); - vertexShaderDesc.AddPermutationField("SHADOW_PASS", params.shadowPass ? "1" : "0"); - vertexShaderDesc.AddPermutationField("SUPPORTS_EXTENDED_TEXTURES", _renderer->HasExtendedTextureSupport() ? "1" : "0"); - - pipelineDesc.states.vertexShader = _renderer->LoadShader(vertexShaderDesc); - - Renderer::PixelShaderDesc pixelShaderDesc; - pixelShaderDesc.path = "Model/Draw.ps.hlsl"; - pixelShaderDesc.AddPermutationField("SHADOW_PASS", params.shadowPass ? "1" : "0"); - pixelShaderDesc.AddPermutationField("SUPPORTS_EXTENDED_TEXTURES", _renderer->HasExtendedTextureSupport() ? "1" : "0"); - pipelineDesc.states.pixelShader = _renderer->LoadShader(pixelShaderDesc); - - // Depth state - pipelineDesc.states.depthStencilState.depthEnable = true; - pipelineDesc.states.depthStencilState.depthWriteEnable = true; - pipelineDesc.states.depthStencilState.depthFunc = Renderer::ComparisonFunc::GREATER; - - // Rasterizer state - pipelineDesc.states.rasterizerState.cullMode = (params.shadowPass) ? Renderer::CullMode::NONE : Renderer::CullMode::BACK; - pipelineDesc.states.rasterizerState.frontFaceMode = Renderer::Settings::FRONT_FACE_STATE; - pipelineDesc.states.rasterizerState.depthBiasEnabled = params.shadowPass; - pipelineDesc.states.rasterizerState.depthClampEnabled = params.shadowPass; - - // Render targets - if (!params.shadowPass) - { - const Renderer::ImageDesc& rt0Desc = graphResources.GetImageDesc(params.rt0); - pipelineDesc.states.renderTargetFormats[0] = rt0Desc.format; - - if (params.rt1 != Renderer::ImageMutableResource::Invalid()) - { - const Renderer::ImageDesc& desc = graphResources.GetImageDesc(params.rt1); - pipelineDesc.states.renderTargetFormats[1] = desc.format; - } - } - const Renderer::DepthImageDesc& depthDesc = graphResources.GetImageDesc(params.depth); - pipelineDesc.states.depthStencilFormat = depthDesc.format; - - // Draw - Renderer::GraphicsPipelineID pipeline = _renderer->CreatePipeline(pipelineDesc); // This will compile the pipeline and return the ID, or just return ID of cached pipeline + Renderer::GraphicsPipelineID pipeline = params.shadowPass ? _drawShadowPipeline : _drawPipeline; commandList.BeginPipeline(pipeline); struct PushConstants @@ -3260,68 +3455,12 @@ void ModelRenderer::DrawTransparent(const RenderResources& resources, u8 frameIn // Render targets renderPassDesc.renderTargets[0] = params.rt0; - if (params.rt1 != Renderer::ImageMutableResource::Invalid()) - { - renderPassDesc.renderTargets[1] = params.rt1; - } + renderPassDesc.renderTargets[1] = params.rt1; + renderPassDesc.depthStencil = params.depth; commandList.BeginRenderPass(renderPassDesc); - Renderer::GraphicsPipelineDesc pipelineDesc; - - // Shaders - Renderer::VertexShaderDesc vertexShaderDesc; - vertexShaderDesc.path = "Model/DrawTransparent.vs.hlsl"; - vertexShaderDesc.AddPermutationField("SUPPORTS_EXTENDED_TEXTURES", _renderer->HasExtendedTextureSupport() ? "1" : "0"); - - pipelineDesc.states.vertexShader = _renderer->LoadShader(vertexShaderDesc); - - Renderer::PixelShaderDesc pixelShaderDesc; - pixelShaderDesc.path = "Model/DrawTransparent.ps.hlsl"; - pixelShaderDesc.AddPermutationField("SUPPORTS_EXTENDED_TEXTURES", _renderer->HasExtendedTextureSupport() ? "1" : "0"); - - pipelineDesc.states.pixelShader = _renderer->LoadShader(pixelShaderDesc); - - // Depth state - pipelineDesc.states.depthStencilState.depthEnable = true; - pipelineDesc.states.depthStencilState.depthFunc = Renderer::ComparisonFunc::GREATER; - - // Rasterizer state - pipelineDesc.states.rasterizerState.cullMode = Renderer::CullMode::BACK; - pipelineDesc.states.rasterizerState.frontFaceMode = Renderer::Settings::FRONT_FACE_STATE; - - // Blend state - pipelineDesc.states.blendState.independentBlendEnable = true; - - pipelineDesc.states.blendState.renderTargets[0].blendEnable = true; - pipelineDesc.states.blendState.renderTargets[0].blendOp = Renderer::BlendOp::ADD; - pipelineDesc.states.blendState.renderTargets[0].srcBlend = Renderer::BlendMode::ONE; - pipelineDesc.states.blendState.renderTargets[0].destBlend = Renderer::BlendMode::ONE; - pipelineDesc.states.blendState.renderTargets[0].srcBlendAlpha = Renderer::BlendMode::ONE; - pipelineDesc.states.blendState.renderTargets[0].destBlendAlpha = Renderer::BlendMode::ONE; - pipelineDesc.states.blendState.renderTargets[0].blendOpAlpha = Renderer::BlendOp::ADD; - - pipelineDesc.states.blendState.renderTargets[1].blendEnable = true; - pipelineDesc.states.blendState.renderTargets[1].blendOp = Renderer::BlendOp::ADD; - pipelineDesc.states.blendState.renderTargets[1].srcBlend = Renderer::BlendMode::ZERO; - pipelineDesc.states.blendState.renderTargets[1].destBlend = Renderer::BlendMode::INV_SRC_ALPHA; - pipelineDesc.states.blendState.renderTargets[1].srcBlendAlpha = Renderer::BlendMode::ZERO; - pipelineDesc.states.blendState.renderTargets[1].destBlendAlpha = Renderer::BlendMode::INV_SRC_ALPHA; - pipelineDesc.states.blendState.renderTargets[1].blendOpAlpha = Renderer::BlendOp::ADD; - - // Render targets - const Renderer::ImageDesc& rt0Desc = graphResources.GetImageDesc(params.rt0); - pipelineDesc.states.renderTargetFormats[0] = rt0Desc.format; - if (params.rt1 != Renderer::ImageMutableResource::Invalid()) - { - const Renderer::ImageDesc& rt1Desc = graphResources.GetImageDesc(params.rt1); - pipelineDesc.states.renderTargetFormats[1] = rt1Desc.format; - } - const Renderer::DepthImageDesc& depthDesc = graphResources.GetImageDesc(params.depth); - pipelineDesc.states.depthStencilFormat = depthDesc.format; - - // Draw - Renderer::GraphicsPipelineID pipeline = _renderer->CreatePipeline(pipelineDesc); // This will compile the pipeline and return the ID, or just return ID of cached pipeline + Renderer::GraphicsPipelineID pipeline = _drawTransparentPipeline; commandList.BeginPipeline(pipeline); commandList.BindDescriptorSet(Renderer::DescriptorSetSlot::GLOBAL, params.globalDescriptorSet, frameIndex); @@ -3357,66 +3496,7 @@ void ModelRenderer::DrawSkybox(const RenderResources& resources, u8 frameIndex, renderPassDesc.depthStencil = params.depth; commandList.BeginRenderPass(renderPassDesc); - Renderer::GraphicsPipelineDesc pipelineDesc; - - // Shaders - Renderer::VertexShaderDesc vertexShaderDesc; - vertexShaderDesc.path = "Model/DrawSkybox.vs.hlsl"; - vertexShaderDesc.AddPermutationField("SUPPORTS_EXTENDED_TEXTURES", _renderer->HasExtendedTextureSupport() ? "1" : "0"); - - pipelineDesc.states.vertexShader = _renderer->LoadShader(vertexShaderDesc); - - Renderer::PixelShaderDesc pixelShaderDesc; - pixelShaderDesc.path = "Model/DrawSkybox.ps.hlsl"; - pixelShaderDesc.AddPermutationField("SUPPORTS_EXTENDED_TEXTURES", _renderer->HasExtendedTextureSupport() ? "1" : "0"); - pixelShaderDesc.AddPermutationField("TRANSPARENCY", isTransparent ? "1" : "0"); - - pipelineDesc.states.pixelShader = _renderer->LoadShader(pixelShaderDesc); - - // Depth state - pipelineDesc.states.depthStencilState.depthEnable = !isTransparent; - pipelineDesc.states.depthStencilState.depthFunc = Renderer::ComparisonFunc::GREATER; - pipelineDesc.states.depthStencilState.depthWriteEnable = !isTransparent; - - // Blend state - if (isTransparent) - { - pipelineDesc.states.blendState.independentBlendEnable = true; - - pipelineDesc.states.blendState.renderTargets[0].blendEnable = true; - pipelineDesc.states.blendState.renderTargets[0].blendOp = Renderer::BlendOp::ADD; - pipelineDesc.states.blendState.renderTargets[0].srcBlend = Renderer::BlendMode::ONE; - pipelineDesc.states.blendState.renderTargets[0].destBlend = Renderer::BlendMode::ONE; - pipelineDesc.states.blendState.renderTargets[0].srcBlendAlpha = Renderer::BlendMode::ONE; - pipelineDesc.states.blendState.renderTargets[0].destBlendAlpha = Renderer::BlendMode::ONE; - pipelineDesc.states.blendState.renderTargets[0].blendOpAlpha = Renderer::BlendOp::ADD; - - pipelineDesc.states.blendState.renderTargets[1].blendEnable = true; - pipelineDesc.states.blendState.renderTargets[1].blendOp = Renderer::BlendOp::ADD; - pipelineDesc.states.blendState.renderTargets[1].srcBlend = Renderer::BlendMode::ZERO; - pipelineDesc.states.blendState.renderTargets[1].destBlend = Renderer::BlendMode::INV_SRC_ALPHA; - pipelineDesc.states.blendState.renderTargets[1].srcBlendAlpha = Renderer::BlendMode::ZERO; - pipelineDesc.states.blendState.renderTargets[1].destBlendAlpha = Renderer::BlendMode::INV_SRC_ALPHA; - pipelineDesc.states.blendState.renderTargets[1].blendOpAlpha = Renderer::BlendOp::ADD; - } - - // Rasterizer state - pipelineDesc.states.rasterizerState.cullMode = Renderer::CullMode::BACK; - pipelineDesc.states.rasterizerState.frontFaceMode = Renderer::Settings::FRONT_FACE_STATE; - - // Render targets - const Renderer::ImageDesc& rt0Desc = graphResources.GetImageDesc(params.rt0); - pipelineDesc.states.renderTargetFormats[0] = rt0Desc.format; - if (isTransparent) - { - const Renderer::ImageDesc& rt1Desc = graphResources.GetImageDesc(params.rt1); - pipelineDesc.states.renderTargetFormats[1] = rt1Desc.format; - } - const Renderer::DepthImageDesc& depthDesc = graphResources.GetImageDesc(params.depth); - pipelineDesc.states.depthStencilFormat = depthDesc.format; - - // Draw - Renderer::GraphicsPipelineID pipeline = _renderer->CreatePipeline(pipelineDesc); // This will compile the pipeline and return the ID, or just return ID of cached pipeline + Renderer::GraphicsPipelineID pipeline = isTransparent ? _drawSkyboxTransparentPipeline : _drawSkyboxOpaquePipeline; commandList.BeginPipeline(pipeline); commandList.BindDescriptorSet(Renderer::DescriptorSetSlot::GLOBAL, params.globalDescriptorSet, frameIndex); diff --git a/Source/Game-Lib/Game-Lib/Rendering/Model/ModelRenderer.h b/Source/Game-Lib/Game-Lib/Rendering/Model/ModelRenderer.h index 4ca2820d..bf12f5c0 100644 --- a/Source/Game-Lib/Game-Lib/Rendering/Model/ModelRenderer.h +++ b/Source/Game-Lib/Game-Lib/Rendering/Model/ModelRenderer.h @@ -18,6 +18,7 @@ #include class DebugRenderer; +class GameRenderer; struct RenderResources; namespace Renderer @@ -307,7 +308,7 @@ class ModelRenderer : CulledRenderer }; public: - ModelRenderer(Renderer::Renderer* renderer, DebugRenderer* debugRenderer); + ModelRenderer(Renderer::Renderer* renderer, GameRenderer* gameRenderer, DebugRenderer* debugRenderer); ~ModelRenderer(); void Update(f32 deltaTime); @@ -371,6 +372,7 @@ class ModelRenderer : CulledRenderer private: void CreatePermanentResources(); + void CreateModelPipelines(); void AllocateModel(const Model::ComplexModel& model, ModelOffsets& offsets); void AllocateTextureData(u32 numTextureDatas, TextureDataOffsets& offsets); @@ -393,6 +395,7 @@ class ModelRenderer : CulledRenderer private: Renderer::Renderer* _renderer = nullptr; + GameRenderer* _gameRenderer = nullptr; DebugRenderer* _debugRenderer = nullptr; std::mutex _textureLoadMutex; @@ -434,6 +437,12 @@ class ModelRenderer : CulledRenderer CullingResourcesIndexed _opaqueSkyboxCullingResources; CullingResourcesIndexed _transparentSkyboxCullingResources; + Renderer::GraphicsPipelineID _drawPipeline; + Renderer::GraphicsPipelineID _drawShadowPipeline; + Renderer::GraphicsPipelineID _drawTransparentPipeline; + Renderer::GraphicsPipelineID _drawSkyboxOpaquePipeline; + Renderer::GraphicsPipelineID _drawSkyboxTransparentPipeline; + // GPU-only workbuffers Renderer::BufferID _occluderArgumentBuffer; Renderer::BufferID _argumentBuffer; diff --git a/Source/Game-Lib/Game-Lib/Rendering/PixelQuery.cpp b/Source/Game-Lib/Game-Lib/Rendering/PixelQuery.cpp index 072e7440..5128865e 100644 --- a/Source/Game-Lib/Game-Lib/Rendering/PixelQuery.cpp +++ b/Source/Game-Lib/Game-Lib/Rendering/PixelQuery.cpp @@ -9,7 +9,10 @@ #include "RenderResources.h" -PixelQuery::PixelQuery(Renderer::Renderer* renderer) : _renderer(renderer) +PixelQuery::PixelQuery(Renderer::Renderer* renderer, GameRenderer* gameRenderer) + : _renderer(renderer) + , _gameRenderer(gameRenderer) + , _queryDescriptorSet(Renderer::DescriptorSetSlot::PER_PASS) { CreatePermanentResources(); } @@ -26,6 +29,17 @@ void PixelQuery::CreatePermanentResources() } _generator.seed(_randomDevice()); + + { + Renderer::ComputePipelineDesc queryPipelineDesc; + + Renderer::ComputeShaderDesc shaderDesc; + shaderDesc.shaderEntry = _gameRenderer->GetShaderEntry("Utils/ObjectQuery.cs.hlsl"_h); + shaderDesc.shaderEntry.debugName = "Utils/ObjectQuery.cs.hlsl"; + queryPipelineDesc.computeShader = _renderer->LoadShader(shaderDesc); + + _queryPipeline = _renderer->CreatePipeline(queryPipelineDesc); + } } void PixelQuery::Update(f32 deltaTime) @@ -106,17 +120,8 @@ void PixelQuery::AddPixelQueryPass(Renderer::RenderGraph* renderGraph, RenderRes TracyMessage(frameIndexStr.c_str(), frameIndexStr.length()); commandList.PushMarker("Pixel Queries " + std::to_string(numRequests), Color::White); - Renderer::ComputePipelineDesc queryPipelineDesc; - graphResources.InitializePipelineDesc(queryPipelineDesc); - - Renderer::ComputeShaderDesc shaderDesc; - shaderDesc.path = "Utils/ObjectQuery.cs.hlsl"; - shaderDesc.AddPermutationField("SUPPORTS_EXTENDED_TEXTURES", _renderer->HasExtendedTextureSupport() ? "1" : "0"); - - queryPipelineDesc.computeShader = _renderer->LoadShader(shaderDesc); - // Do culling - Renderer::ComputePipelineID pipeline = _renderer->CreatePipeline(queryPipelineDesc); + Renderer::ComputePipelineID pipeline = _queryPipeline; commandList.BeginPipeline(pipeline); // Set Number of Requests we processed diff --git a/Source/Game-Lib/Game-Lib/Rendering/PixelQuery.h b/Source/Game-Lib/Game-Lib/Rendering/PixelQuery.h index 0da62c4d..4c8e2396 100644 --- a/Source/Game-Lib/Game-Lib/Rendering/PixelQuery.h +++ b/Source/Game-Lib/Game-Lib/Rendering/PixelQuery.h @@ -15,6 +15,7 @@ #include #include +class GameRenderer; struct RenderResources; class PixelQuery @@ -28,7 +29,7 @@ class PixelQuery }; public: - PixelQuery(Renderer::Renderer* renderer); + PixelQuery(Renderer::Renderer* renderer, GameRenderer* gameRenderer); void Update(f32 deltaTime); void AddPixelQueryPass(Renderer::RenderGraph* renderGraph, RenderResources& resources, u8 frameIndex); @@ -71,6 +72,9 @@ class PixelQuery private: Renderer::Renderer* _renderer; + GameRenderer* _gameRenderer = nullptr; + + Renderer::ComputePipelineID _queryPipeline; Renderer::DescriptorSet _queryDescriptorSet; Renderer::BufferID _pixelResultBuffer; diff --git a/Source/Game-Lib/Game-Lib/Rendering/RenderResources.h b/Source/Game-Lib/Game-Lib/Rendering/RenderResources.h index 82e5bd05..ceeea811 100644 --- a/Source/Game-Lib/Game-Lib/Rendering/RenderResources.h +++ b/Source/Game-Lib/Game-Lib/Rendering/RenderResources.h @@ -12,6 +12,13 @@ struct RenderResources { public: + RenderResources() + : globalDescriptorSet(Renderer::DescriptorSetSlot::GLOBAL) + , lightDescriptorSet(Renderer::DescriptorSetSlot::LIGHT) + { + + } + // Permanent resources Renderer::GPUVector cameras; diff --git a/Source/Game-Lib/Game-Lib/Rendering/RenderUtils.cpp b/Source/Game-Lib/Game-Lib/Rendering/RenderUtils.cpp index 654e6cae..6882c0c3 100644 --- a/Source/Game-Lib/Game-Lib/Rendering/RenderUtils.cpp +++ b/Source/Game-Lib/Game-Lib/Rendering/RenderUtils.cpp @@ -1,4 +1,5 @@ #include "RenderUtils.h" +#include "Game-Lib/Rendering/GameRenderer.h" #include #include @@ -9,7 +10,7 @@ #include #include -void RenderUtils::Blit(Renderer::Renderer* renderer, Renderer::RenderGraphResources& graphResources, Renderer::CommandList& commandList, u32 frameIndex, const BlitParams& params) +void RenderUtils::Blit(Renderer::Renderer* renderer, GameRenderer* gameRenderer, Renderer::RenderGraphResources& graphResources, Renderer::CommandList& commandList, u32 frameIndex, const BlitParams& params) { commandList.PushMarker("Blit", Color::White); @@ -23,18 +24,22 @@ void RenderUtils::Blit(Renderer::Renderer* renderer, Renderer::RenderGraphResour const Renderer::ImageDesc& imageDesc = graphResources.GetImageDesc(params.input); // Setup pipeline - Renderer::VertexShaderDesc vertexShaderDesc; - vertexShaderDesc.path = "Blitting/blit.vs.hlsl"; - - Renderer::PixelShaderDesc pixelShaderDesc; - pixelShaderDesc.path = "Blitting/blit.ps.hlsl"; - std::string textureTypeName = Renderer::GetTextureTypeName(imageDesc.format); - pixelShaderDesc.AddPermutationField("TEX_TYPE", textureTypeName); - Renderer::GraphicsPipelineDesc pipelineDesc; pipelineDesc.debugName = "Blit"; + Renderer::VertexShaderDesc vertexShaderDesc; + vertexShaderDesc.shaderEntry = gameRenderer->GetShaderEntry("Blitting/Blit.vs.hlsl"_h); pipelineDesc.states.vertexShader = renderer->LoadShader(vertexShaderDesc); + + std::string textureTypeName = Renderer::GetTextureTypeName(imageDesc.format); + std::vector permutationFields = + { + { "TEX_TYPE", textureTypeName } + }; + u32 shaderEntryNameHash = Renderer::GetShaderEntryNameHash("Blitting/Blit.ps.hlsl", permutationFields); + + Renderer::PixelShaderDesc pixelShaderDesc; + pixelShaderDesc.shaderEntry = gameRenderer->GetShaderEntry(shaderEntryNameHash); pipelineDesc.states.pixelShader = renderer->LoadShader(pixelShaderDesc); const Renderer::ImageDesc& outputDesc = graphResources.GetImageDesc(params.output); @@ -53,7 +58,7 @@ void RenderUtils::Blit(Renderer::Renderer* renderer, Renderer::RenderGraphResour } params.descriptorSet.Bind("_texture", params.input, mipLevel); - commandList.BindDescriptorSet(Renderer::DescriptorSetSlot::GLOBAL, params.descriptorSet, frameIndex); + commandList.BindDescriptorSet(Renderer::DescriptorSetSlot::PER_PASS, params.descriptorSet, frameIndex); struct BlitConstant { @@ -84,7 +89,7 @@ void RenderUtils::Blit(Renderer::Renderer* renderer, Renderer::RenderGraphResour commandList.PopMarker(); } -void RenderUtils::DepthBlit(Renderer::Renderer* renderer, Renderer::RenderGraphResources& graphResources, Renderer::CommandList& commandList, u32 frameIndex, const DepthBlitParams& params) +void RenderUtils::DepthBlit(Renderer::Renderer* renderer, GameRenderer* gameRenderer, Renderer::RenderGraphResources& graphResources, Renderer::CommandList& commandList, u32 frameIndex, const DepthBlitParams& params) { commandList.PushMarker("Blit", Color::White); @@ -98,18 +103,22 @@ void RenderUtils::DepthBlit(Renderer::Renderer* renderer, Renderer::RenderGraphR const Renderer::DepthImageDesc& imageDesc = graphResources.GetImageDesc(params.input); // Setup pipeline - Renderer::VertexShaderDesc vertexShaderDesc; - vertexShaderDesc.path = "Blitting/blit.vs.hlsl"; - - Renderer::PixelShaderDesc pixelShaderDesc; - pixelShaderDesc.path = "Blitting/blit.ps.hlsl"; - std::string textureTypeName = Renderer::GetTextureTypeName(imageDesc.format); - pixelShaderDesc.AddPermutationField("TEX_TYPE", textureTypeName); - Renderer::GraphicsPipelineDesc pipelineDesc; pipelineDesc.debugName = "DepthBlit"; + Renderer::VertexShaderDesc vertexShaderDesc; + vertexShaderDesc.shaderEntry = gameRenderer->GetShaderEntry("Blitting/Blit.vs.hlsl"_h); pipelineDesc.states.vertexShader = renderer->LoadShader(vertexShaderDesc); + + std::string textureTypeName = Renderer::GetTextureTypeName(imageDesc.format); + std::vector permutationFields = + { + { "TEX_TYPE", textureTypeName } + }; + u32 shaderEntryNameHash = Renderer::GetShaderEntryNameHash("Blitting/Blit.ps.hlsl", permutationFields); + + Renderer::PixelShaderDesc pixelShaderDesc; + pixelShaderDesc.shaderEntry = gameRenderer->GetShaderEntry(shaderEntryNameHash); pipelineDesc.states.pixelShader = renderer->LoadShader(pixelShaderDesc); const Renderer::ImageDesc& outputDesc = graphResources.GetImageDesc(params.output); @@ -122,7 +131,7 @@ void RenderUtils::DepthBlit(Renderer::Renderer* renderer, Renderer::RenderGraphR commandList.BeginPipeline(pipeline); params.descriptorSet.Bind("_texture", params.input); - commandList.BindDescriptorSet(Renderer::DescriptorSetSlot::GLOBAL, params.descriptorSet, frameIndex); + commandList.BindDescriptorSet(Renderer::DescriptorSetSlot::PER_PASS, params.descriptorSet, frameIndex); struct BlitConstant { @@ -153,7 +162,7 @@ void RenderUtils::DepthBlit(Renderer::Renderer* renderer, Renderer::RenderGraphR commandList.PopMarker(); } -void RenderUtils::Overlay(Renderer::Renderer* renderer, Renderer::RenderGraphResources& graphResources, Renderer::CommandList& commandList, u32 frameIndex, const OverlayParams& params) +void RenderUtils::Overlay(Renderer::Renderer* renderer, GameRenderer* gameRenderer, Renderer::RenderGraphResources& graphResources, Renderer::CommandList& commandList, u32 frameIndex, const OverlayParams& params) { commandList.PushMarker("Overlay", Color::White); @@ -167,18 +176,22 @@ void RenderUtils::Overlay(Renderer::Renderer* renderer, Renderer::RenderGraphRes const Renderer::ImageDesc& imageDesc = graphResources.GetImageDesc(params.overlayImage); // Setup pipeline - Renderer::VertexShaderDesc vertexShaderDesc; - vertexShaderDesc.path = "Blitting/blit.vs.hlsl"; - - Renderer::PixelShaderDesc pixelShaderDesc; - pixelShaderDesc.path = "Blitting/blit.ps.hlsl"; - std::string textureTypeName = Renderer::GetTextureTypeName(imageDesc.format); - pixelShaderDesc.AddPermutationField("TEX_TYPE", textureTypeName); - Renderer::GraphicsPipelineDesc pipelineDesc; pipelineDesc.debugName = "Overlay"; + Renderer::VertexShaderDesc vertexShaderDesc; + vertexShaderDesc.shaderEntry = gameRenderer->GetShaderEntry("Blitting/Blit.vs.hlsl"_h); pipelineDesc.states.vertexShader = renderer->LoadShader(vertexShaderDesc); + + std::string textureTypeName = Renderer::GetTextureTypeName(imageDesc.format); + std::vector permutationFields = + { + { "TEX_TYPE", textureTypeName } + }; + u32 shaderEntryNameHash = Renderer::GetShaderEntryNameHash("Blitting/Blit.ps.hlsl", permutationFields); + + Renderer::PixelShaderDesc pixelShaderDesc; + pixelShaderDesc.shaderEntry = gameRenderer->GetShaderEntry(shaderEntryNameHash); pipelineDesc.states.pixelShader = renderer->LoadShader(pixelShaderDesc); const Renderer::ImageDesc& outputDesc = graphResources.GetImageDesc(params.baseImage); @@ -203,7 +216,7 @@ void RenderUtils::Overlay(Renderer::Renderer* renderer, Renderer::RenderGraphRes } params.descriptorSet.Bind("_texture", params.overlayImage, mipLevel); - commandList.BindDescriptorSet(Renderer::DescriptorSetSlot::GLOBAL, params.descriptorSet, frameIndex); + commandList.BindDescriptorSet(Renderer::DescriptorSetSlot::PER_PASS, params.descriptorSet, frameIndex); struct BlitConstant { @@ -234,7 +247,7 @@ void RenderUtils::Overlay(Renderer::Renderer* renderer, Renderer::RenderGraphRes commandList.PopMarker(); } -void RenderUtils::DepthOverlay(Renderer::Renderer* renderer, Renderer::RenderGraphResources& graphResources, Renderer::CommandList& commandList, u32 frameIndex, const DepthOverlayParams& params) +void RenderUtils::DepthOverlay(Renderer::Renderer* renderer, GameRenderer* gameRenderer, Renderer::RenderGraphResources& graphResources, Renderer::CommandList& commandList, u32 frameIndex, const DepthOverlayParams& params) { commandList.PushMarker("DepthOverlay", Color::White); @@ -245,24 +258,25 @@ void RenderUtils::DepthOverlay(Renderer::Renderer* renderer, Renderer::RenderGra renderPassDesc.renderTargets[0] = params.baseImage; commandList.BeginRenderPass(renderPassDesc); - // Setup pipeline - Renderer::VertexShaderDesc vertexShaderDesc; - vertexShaderDesc.path = "Blitting/blit.vs.hlsl"; - const Renderer::DepthImageDesc& imageDesc = graphResources.GetImageDesc(params.overlayImage); - Renderer::ImageComponentType componentType = Renderer::ToImageComponentType(imageDesc.format); - std::string componentTypeName = ""; - - Renderer::PixelShaderDesc pixelShaderDesc; - pixelShaderDesc.path = "Blitting/blit.ps.hlsl"; - std::string textureTypeName = Renderer::GetTextureTypeName(imageDesc.format); - pixelShaderDesc.AddPermutationField("TEX_TYPE", textureTypeName); - + // Setup pipeline Renderer::GraphicsPipelineDesc pipelineDesc; pipelineDesc.debugName = "DepthOverlay"; + Renderer::VertexShaderDesc vertexShaderDesc; + vertexShaderDesc.shaderEntry = gameRenderer->GetShaderEntry("Blitting/Blit.vs.hlsl"_h); pipelineDesc.states.vertexShader = renderer->LoadShader(vertexShaderDesc); + + std::string textureTypeName = Renderer::GetTextureTypeName(imageDesc.format); + std::vector permutationFields = + { + { "TEX_TYPE", textureTypeName } + }; + u32 shaderEntryNameHash = Renderer::GetShaderEntryNameHash("Blitting/Blit.ps.hlsl", permutationFields); + + Renderer::PixelShaderDesc pixelShaderDesc; + pixelShaderDesc.shaderEntry = gameRenderer->GetShaderEntry(shaderEntryNameHash); pipelineDesc.states.pixelShader = renderer->LoadShader(pixelShaderDesc); const Renderer::ImageDesc& outputDesc = graphResources.GetImageDesc(params.baseImage); @@ -281,7 +295,7 @@ void RenderUtils::DepthOverlay(Renderer::Renderer* renderer, Renderer::RenderGra commandList.BeginPipeline(pipeline); params.descriptorSet.Bind("_texture", params.overlayImage); - commandList.BindDescriptorSet(Renderer::DescriptorSetSlot::GLOBAL, params.descriptorSet, frameIndex); + commandList.BindDescriptorSet(Renderer::DescriptorSetSlot::PER_PASS, params.descriptorSet, frameIndex); struct BlitConstant { @@ -312,7 +326,7 @@ void RenderUtils::DepthOverlay(Renderer::Renderer* renderer, Renderer::RenderGra commandList.PopMarker(); } -void RenderUtils::PictureInPicture(Renderer::Renderer* renderer, Renderer::RenderGraphResources& graphResources, Renderer::CommandList& commandList, u32 frameIndex, const PictureInPictureParams& params) +void RenderUtils::PictureInPicture(Renderer::Renderer* renderer, GameRenderer* gameRenderer, Renderer::RenderGraphResources& graphResources, Renderer::CommandList& commandList, u32 frameIndex, const PictureInPictureParams& params) { commandList.PushMarker("PictureInPicture", Color::White); @@ -333,18 +347,22 @@ void RenderUtils::PictureInPicture(Renderer::Renderer* renderer, Renderer::Rende const Renderer::ImageDesc& imageDesc = graphResources.GetImageDesc(params.pipImage); // Setup pipeline - Renderer::VertexShaderDesc vertexShaderDesc; - vertexShaderDesc.path = "Blitting/blit.vs.hlsl"; - - Renderer::PixelShaderDesc pixelShaderDesc; - pixelShaderDesc.path = "Blitting/blit.ps.hlsl"; - std::string textureTypeName = Renderer::GetTextureTypeName(imageDesc.format); - pixelShaderDesc.AddPermutationField("TEX_TYPE", textureTypeName); - Renderer::GraphicsPipelineDesc pipelineDesc; pipelineDesc.debugName = "PictureInPicture"; + Renderer::VertexShaderDesc vertexShaderDesc; + vertexShaderDesc.shaderEntry = gameRenderer->GetShaderEntry("Blitting/Blit.vs.hlsl"_h); pipelineDesc.states.vertexShader = renderer->LoadShader(vertexShaderDesc); + + std::string textureTypeName = Renderer::GetTextureTypeName(imageDesc.format); + std::vector permutationFields = + { + { "TEX_TYPE", textureTypeName } + }; + u32 shaderEntryNameHash = Renderer::GetShaderEntryNameHash("Blitting/Blit.ps.hlsl", permutationFields); + + Renderer::PixelShaderDesc pixelShaderDesc; + pixelShaderDesc.shaderEntry = gameRenderer->GetShaderEntry(shaderEntryNameHash); pipelineDesc.states.pixelShader = renderer->LoadShader(pixelShaderDesc); const Renderer::ImageDesc& outputDesc = graphResources.GetImageDesc(params.baseImage); @@ -369,7 +387,7 @@ void RenderUtils::PictureInPicture(Renderer::Renderer* renderer, Renderer::Rende } params.descriptorSet.Bind("_texture", params.pipImage, mipLevel); - commandList.BindDescriptorSet(Renderer::DescriptorSetSlot::GLOBAL, params.descriptorSet, frameIndex); + commandList.BindDescriptorSet(Renderer::DescriptorSetSlot::PER_PASS, params.descriptorSet, frameIndex); struct BlitConstant { @@ -406,7 +424,7 @@ void RenderUtils::PictureInPicture(Renderer::Renderer* renderer, Renderer::Rende commandList.PopMarker(); } -void RenderUtils::DepthPictureInPicture(Renderer::Renderer* renderer, Renderer::RenderGraphResources& graphResources, Renderer::CommandList& commandList, u32 frameIndex, const DepthPictureInPictureParams& params) +void RenderUtils::DepthPictureInPicture(Renderer::Renderer* renderer, GameRenderer* gameRenderer, Renderer::RenderGraphResources& graphResources, Renderer::CommandList& commandList, u32 frameIndex, const DepthPictureInPictureParams& params) { commandList.PushMarker("DepthPictureInPicture", Color::White); @@ -424,24 +442,25 @@ void RenderUtils::DepthPictureInPicture(Renderer::Renderer* renderer, Renderer:: commandList.SetViewport(static_cast(params.targetRegion.left), static_cast(params.targetRegion.top), width, height, 0.0f, 1.0f); commandList.SetScissorRect(params.targetRegion.left, params.targetRegion.right, params.targetRegion.top, params.targetRegion.bottom); - // Setup pipeline - Renderer::VertexShaderDesc vertexShaderDesc; - vertexShaderDesc.path = "Blitting/blit.vs.hlsl"; - const Renderer::DepthImageDesc& imageDesc = graphResources.GetImageDesc(params.pipImage); - Renderer::ImageComponentType componentType = Renderer::ToImageComponentType(imageDesc.format); - std::string componentTypeName = ""; - - Renderer::PixelShaderDesc pixelShaderDesc; - pixelShaderDesc.path = "Blitting/blit.ps.hlsl"; - std::string textureTypeName = Renderer::GetTextureTypeName(imageDesc.format); - pixelShaderDesc.AddPermutationField("TEX_TYPE", textureTypeName); - + // Setup pipeline Renderer::GraphicsPipelineDesc pipelineDesc; pipelineDesc.debugName = "DepthPictureInPicture"; + Renderer::VertexShaderDesc vertexShaderDesc; + vertexShaderDesc.shaderEntry = gameRenderer->GetShaderEntry("Blitting/Blit.vs.hlsl"_h); pipelineDesc.states.vertexShader = renderer->LoadShader(vertexShaderDesc); + + std::string textureTypeName = Renderer::GetTextureTypeName(imageDesc.format); + std::vector permutationFields = + { + { "TEX_TYPE", textureTypeName } + }; + u32 shaderEntryNameHash = Renderer::GetShaderEntryNameHash("Blitting/Blit.ps.hlsl", permutationFields); + + Renderer::PixelShaderDesc pixelShaderDesc; + pixelShaderDesc.shaderEntry = gameRenderer->GetShaderEntry(shaderEntryNameHash); pipelineDesc.states.pixelShader = renderer->LoadShader(pixelShaderDesc); const Renderer::ImageDesc& outputDesc = graphResources.GetImageDesc(params.baseImage); @@ -460,7 +479,7 @@ void RenderUtils::DepthPictureInPicture(Renderer::Renderer* renderer, Renderer:: commandList.BeginPipeline(pipeline); params.descriptorSet.Bind("_texture", params.pipImage); - commandList.BindDescriptorSet(Renderer::DescriptorSetSlot::GLOBAL, params.descriptorSet, frameIndex); + commandList.BindDescriptorSet(Renderer::DescriptorSetSlot::PER_PASS, params.descriptorSet, frameIndex); struct BlitConstant { @@ -497,14 +516,15 @@ void RenderUtils::DepthPictureInPicture(Renderer::Renderer* renderer, Renderer:: commandList.PopMarker(); } -void RenderUtils::CopyDepthToColor(Renderer::Renderer* renderer, Renderer::RenderGraphResources& graphResources, Renderer::CommandList& commandList, u32 frameIndex, const CopyDepthToColorParams& params) +void RenderUtils::CopyDepthToColor(Renderer::Renderer* renderer, GameRenderer* gameRenderer, Renderer::RenderGraphResources& graphResources, Renderer::CommandList& commandList, u32 frameIndex, const CopyDepthToColorParams& params) { Renderer::ComputePipelineDesc pipelineDesc; pipelineDesc.debugName = "CopyDepthToColor"; graphResources.InitializePipelineDesc(pipelineDesc); Renderer::ComputeShaderDesc shaderDesc; - shaderDesc.path = "Blitting/blitDepth.cs.hlsl"; + shaderDesc.shaderEntry = gameRenderer->GetShaderEntry("Blitting/BlitDepth.cs.hlsl"_h); + shaderDesc.shaderEntry.debugName = "Blitting/BlitDepth.cs.hlsl"; pipelineDesc.computeShader = renderer->LoadShader(shaderDesc); // Do culling @@ -534,7 +554,7 @@ void RenderUtils::CopyDepthToColor(Renderer::Renderer* renderer, Renderer::Rende commandList.PushConstant(copyParams, 0, sizeof(CopyParams)); - commandList.BindDescriptorSet(Renderer::GLOBAL, params.descriptorSet, frameIndex); + commandList.BindDescriptorSet(Renderer::PER_PASS, params.descriptorSet, frameIndex); commandList.Dispatch(GetGroupCount(destinationSize.x, 32), GetGroupCount(destinationSize.y, 32), 1); commandList.EndPipeline(pipeline); diff --git a/Source/Game-Lib/Game-Lib/Rendering/RenderUtils.h b/Source/Game-Lib/Game-Lib/Rendering/RenderUtils.h index 4c701df9..9f597242 100644 --- a/Source/Game-Lib/Game-Lib/Rendering/RenderUtils.h +++ b/Source/Game-Lib/Game-Lib/Rendering/RenderUtils.h @@ -13,10 +13,13 @@ namespace Renderer class RenderGraphResources; class CommandList; } +class GameRenderer; class RenderUtils { public: + static void Init(Renderer::Renderer* renderer, GameRenderer* gameRenderer); + struct BlitParams { public: @@ -30,7 +33,7 @@ class RenderUtils Renderer::DescriptorSetResource descriptorSet; }; - static void Blit(Renderer::Renderer* renderer, Renderer::RenderGraphResources& graphResources, Renderer::CommandList& commandList, u32 frameIndex, const BlitParams& params); + static void Blit(Renderer::Renderer* renderer, GameRenderer* gameRenderer, Renderer::RenderGraphResources& graphResources, Renderer::CommandList& commandList, u32 frameIndex, const BlitParams& params); struct DepthBlitParams { @@ -44,7 +47,7 @@ class RenderUtils Renderer::DescriptorSetResource descriptorSet; }; - static void DepthBlit(Renderer::Renderer* renderer, Renderer::RenderGraphResources& graphResources, Renderer::CommandList& commandList, u32 frameIndex, const DepthBlitParams& params); + static void DepthBlit(Renderer::Renderer* renderer, GameRenderer* gameRenderer, Renderer::RenderGraphResources& graphResources, Renderer::CommandList& commandList, u32 frameIndex, const DepthBlitParams& params); struct OverlayParams { @@ -59,7 +62,7 @@ class RenderUtils Renderer::DescriptorSetResource descriptorSet; }; - static void Overlay(Renderer::Renderer* renderer, Renderer::RenderGraphResources& graphResources, Renderer::CommandList& commandList, u32 frameIndex, const OverlayParams& params); + static void Overlay(Renderer::Renderer* renderer, GameRenderer* gameRenderer, Renderer::RenderGraphResources& graphResources, Renderer::CommandList& commandList, u32 frameIndex, const OverlayParams& params); struct DepthOverlayParams { @@ -73,7 +76,7 @@ class RenderUtils Renderer::DescriptorSetResource descriptorSet; }; - static void DepthOverlay(Renderer::Renderer* renderer, Renderer::RenderGraphResources& graphResources, Renderer::CommandList& commandList, u32 frameIndex, const DepthOverlayParams& params); + static void DepthOverlay(Renderer::Renderer* renderer, GameRenderer* gameRenderer, Renderer::RenderGraphResources& graphResources, Renderer::CommandList& commandList, u32 frameIndex, const DepthOverlayParams& params); struct PictureInPictureParams { @@ -89,7 +92,7 @@ class RenderUtils Renderer::DescriptorSetResource descriptorSet; }; - static void PictureInPicture(Renderer::Renderer* renderer, Renderer::RenderGraphResources& graphResources, Renderer::CommandList& commandList, u32 frameIndex, const PictureInPictureParams& params); + static void PictureInPicture(Renderer::Renderer* renderer, GameRenderer* gameRenderer, Renderer::RenderGraphResources& graphResources, Renderer::CommandList& commandList, u32 frameIndex, const PictureInPictureParams& params); struct DepthPictureInPictureParams { @@ -104,7 +107,7 @@ class RenderUtils Renderer::DescriptorSetResource descriptorSet; }; - static void DepthPictureInPicture(Renderer::Renderer* renderer, Renderer::RenderGraphResources& graphResources, Renderer::CommandList& commandList, u32 frameIndex, const DepthPictureInPictureParams& params); + static void DepthPictureInPicture(Renderer::Renderer* renderer, GameRenderer* gameRenderer, Renderer::RenderGraphResources& graphResources, Renderer::CommandList& commandList, u32 frameIndex, const DepthPictureInPictureParams& params); static u32 CalcCullingBitmaskSize(size_t numObjects) { @@ -137,6 +140,6 @@ class RenderUtils Renderer::DescriptorSetResource descriptorSet; }; - static void CopyDepthToColor(Renderer::Renderer* renderer, Renderer::RenderGraphResources& graphResources, Renderer::CommandList& commandList, u32 frameIndex, const CopyDepthToColorParams& params); + static void CopyDepthToColor(Renderer::Renderer* renderer, GameRenderer* gameRenderer, Renderer::RenderGraphResources& graphResources, Renderer::CommandList& commandList, u32 frameIndex, const CopyDepthToColorParams& params); private: }; \ No newline at end of file diff --git a/Source/Game-Lib/Game-Lib/Rendering/Shadow/ShadowRenderer.cpp b/Source/Game-Lib/Game-Lib/Rendering/Shadow/ShadowRenderer.cpp index 20e7eba1..5258028a 100644 --- a/Source/Game-Lib/Game-Lib/Rendering/Shadow/ShadowRenderer.cpp +++ b/Source/Game-Lib/Game-Lib/Rendering/Shadow/ShadowRenderer.cpp @@ -32,8 +32,9 @@ AutoCVar_Float CVAR_ShadowDepthBiasSlopeFactor(CVarCategory::Client | CVarCatego #define TIMESLICED_CASCADES 0 -ShadowRenderer::ShadowRenderer(Renderer::Renderer* renderer, DebugRenderer* debugRenderer, TerrainRenderer* terrainRenderer, ModelRenderer* modelRenderer, RenderResources& resources) +ShadowRenderer::ShadowRenderer(Renderer::Renderer* renderer, GameRenderer* gameRenderer, DebugRenderer* debugRenderer, TerrainRenderer* terrainRenderer, ModelRenderer* modelRenderer, RenderResources& resources) : _renderer(renderer) + , _gameRenderer(gameRenderer) , _debugRenderer(debugRenderer) , _terrainRenderer(terrainRenderer) , _modelRenderer(modelRenderer) diff --git a/Source/Game-Lib/Game-Lib/Rendering/Shadow/ShadowRenderer.h b/Source/Game-Lib/Game-Lib/Rendering/Shadow/ShadowRenderer.h index 065463b2..76fb006b 100644 --- a/Source/Game-Lib/Game-Lib/Rendering/Shadow/ShadowRenderer.h +++ b/Source/Game-Lib/Game-Lib/Rendering/Shadow/ShadowRenderer.h @@ -15,13 +15,14 @@ namespace Renderer struct RenderResources; class DebugRenderer; -class TerrainRenderer; +class GameRenderer; class ModelRenderer; +class TerrainRenderer; class ShadowRenderer { public: - ShadowRenderer(Renderer::Renderer* renderer, DebugRenderer* debugRenderer, TerrainRenderer* terrainRenderer, ModelRenderer* modelRenderer, RenderResources& resources); + ShadowRenderer(Renderer::Renderer* renderer, GameRenderer* gameRenderer, DebugRenderer* debugRenderer, TerrainRenderer* terrainRenderer, ModelRenderer* modelRenderer, RenderResources& resources); ~ShadowRenderer(); void Update(f32 deltaTime, RenderResources& resources); @@ -42,6 +43,7 @@ class ShadowRenderer private: Renderer::Renderer* _renderer = nullptr; + GameRenderer* _gameRenderer = nullptr; DebugRenderer* _debugRenderer = nullptr; TerrainRenderer* _terrainRenderer = nullptr; ModelRenderer* _modelRenderer = nullptr; diff --git a/Source/Game-Lib/Game-Lib/Rendering/Skybox/SkyboxRenderer.cpp b/Source/Game-Lib/Game-Lib/Rendering/Skybox/SkyboxRenderer.cpp index 05640fc9..fdecd4c0 100644 --- a/Source/Game-Lib/Game-Lib/Rendering/Skybox/SkyboxRenderer.cpp +++ b/Source/Game-Lib/Game-Lib/Rendering/Skybox/SkyboxRenderer.cpp @@ -1,6 +1,7 @@ #include "SkyboxRenderer.h" #include "Game-Lib/Rendering/Debug/DebugRenderer.h" +#include "Game-Lib/Rendering/GameRenderer.h" #include "Game-Lib/Rendering/RenderResources.h" #include "Game-Lib/Util/ServiceLocator.h" #include "Game-Lib/Application/EnttRegistries.h" @@ -10,8 +11,9 @@ #include -SkyboxRenderer::SkyboxRenderer(Renderer::Renderer* renderer, DebugRenderer* debugRenderer) +SkyboxRenderer::SkyboxRenderer(Renderer::Renderer* renderer, GameRenderer* gameRenderer, DebugRenderer* debugRenderer) : _renderer(renderer) + , _gameRenderer(gameRenderer) //, _debugRenderer(debugRenderer) { CreatePermanentResources(); @@ -64,32 +66,8 @@ void SkyboxRenderer::AddSkyboxPass(Renderer::RenderGraph* renderGraph, RenderRes renderPassDesc.renderTargets[0] = data.skyboxColor; commandList.BeginRenderPass(renderPassDesc); - Renderer::GraphicsPipelineDesc pipelineDesc; - - // Shaders - Renderer::VertexShaderDesc vertexShaderDesc; - vertexShaderDesc.path = "PostProcess/FullscreenTriangle.vs.hlsl"; - - pipelineDesc.states.vertexShader = _renderer->LoadShader(vertexShaderDesc); - - Renderer::PixelShaderDesc pixelShaderDesc; - pixelShaderDesc.path = "Skybox/Skybox.ps.hlsl"; - - pipelineDesc.states.pixelShader = _renderer->LoadShader(pixelShaderDesc); - - // Depth state - pipelineDesc.states.depthStencilState.depthEnable = false; - - // Rasterizer state - pipelineDesc.states.rasterizerState.cullMode = Renderer::CullMode::NONE; - pipelineDesc.states.rasterizerState.frontFaceMode = Renderer::FrontFaceState::COUNTERCLOCKWISE; - - // Render targets - const Renderer::ImageDesc& desc = graphResources.GetImageDesc(data.skyboxColor); - pipelineDesc.states.renderTargetFormats[0] = desc.format; - // Set pipeline - Renderer::GraphicsPipelineID pipeline = _renderer->CreatePipeline(pipelineDesc); // This will compile the pipeline and return the ID, or just return ID of cached pipeline + Renderer::GraphicsPipelineID pipeline = _skyboxPipeline; commandList.BeginPipeline(pipeline); commandList.BindDescriptorSet(Renderer::DescriptorSetSlot::GLOBAL, data.globalSet, frameIndex); @@ -116,5 +94,28 @@ void SkyboxRenderer::SetSkybandColors(const vec3& skyTopColor, const vec3& skyMi void SkyboxRenderer::CreatePermanentResources() { + Renderer::GraphicsPipelineDesc pipelineDesc; + + // Shaders + Renderer::VertexShaderDesc vertexShaderDesc; + vertexShaderDesc.shaderEntry = _gameRenderer->GetShaderEntry("PostProcess/FullscreenTriangle.vs.hlsl"_h); + vertexShaderDesc.shaderEntry.debugName = "PostProcess/FullscreenTriangle.vs.hlsl"; + pipelineDesc.states.vertexShader = _renderer->LoadShader(vertexShaderDesc); + + Renderer::PixelShaderDesc pixelShaderDesc; + pixelShaderDesc.shaderEntry = _gameRenderer->GetShaderEntry("Skybox/Skybox.ps.hlsl"_h); + pixelShaderDesc.shaderEntry.debugName = "Skybox/Skybox.ps.hlsl"; + pipelineDesc.states.pixelShader = _renderer->LoadShader(pixelShaderDesc); + + // Depth state + pipelineDesc.states.depthStencilState.depthEnable = false; + + // Rasterizer state + pipelineDesc.states.rasterizerState.cullMode = Renderer::CullMode::NONE; + pipelineDesc.states.rasterizerState.frontFaceMode = Renderer::FrontFaceState::COUNTERCLOCKWISE; + + // Render targets + pipelineDesc.states.renderTargetFormats[0] = _renderer->GetSwapChainImageFormat(); + _skyboxPipeline = _renderer->CreatePipeline(pipelineDesc); } \ No newline at end of file diff --git a/Source/Game-Lib/Game-Lib/Rendering/Skybox/SkyboxRenderer.h b/Source/Game-Lib/Game-Lib/Rendering/Skybox/SkyboxRenderer.h index 69f0216f..453a81ab 100644 --- a/Source/Game-Lib/Game-Lib/Rendering/Skybox/SkyboxRenderer.h +++ b/Source/Game-Lib/Game-Lib/Rendering/Skybox/SkyboxRenderer.h @@ -1,6 +1,8 @@ #pragma once #include +#include + namespace Renderer { class Renderer; @@ -8,6 +10,7 @@ namespace Renderer } class DebugRenderer; +class GameRenderer; struct RenderResources; class SkyboxRenderer @@ -24,7 +27,7 @@ class SkyboxRenderer }; public: - SkyboxRenderer(Renderer::Renderer* renderer, DebugRenderer* debugRenderer); + SkyboxRenderer(Renderer::Renderer* renderer, GameRenderer* gameRenderer, DebugRenderer* debugRenderer); ~SkyboxRenderer(); void Update(f32 deltaTime); @@ -37,7 +40,9 @@ class SkyboxRenderer void CreatePermanentResources(); Renderer::Renderer* _renderer; + GameRenderer* _gameRenderer = nullptr; //DebugRenderer* _debugRenderer; + Renderer::GraphicsPipelineID _skyboxPipeline; SkybandColors _skybandColors; }; diff --git a/Source/Game-Lib/Game-Lib/Rendering/Terrain/TerrainRenderer.cpp b/Source/Game-Lib/Game-Lib/Rendering/Terrain/TerrainRenderer.cpp index 02e421fc..1d27560f 100644 --- a/Source/Game-Lib/Game-Lib/Rendering/Terrain/TerrainRenderer.cpp +++ b/Source/Game-Lib/Game-Lib/Rendering/Terrain/TerrainRenderer.cpp @@ -33,9 +33,14 @@ AutoCVar_Int CVAR_TerrainValidateTransfers(CVarCategory::Client | CVarCategory:: AutoCVar_Int CVAR_TerrainCastShadow(CVarCategory::Client | CVarCategory::Rendering, "shadowTerrainCastShadow", "should Terrain cast shadows", 1, CVarFlags::EditCheckbox); -TerrainRenderer::TerrainRenderer(Renderer::Renderer* renderer, DebugRenderer* debugRenderer) +TerrainRenderer::TerrainRenderer(Renderer::Renderer* renderer, GameRenderer* gameRenderer, DebugRenderer* debugRenderer) : _renderer(renderer) + , _gameRenderer(gameRenderer) , _debugRenderer(debugRenderer) + , _geometryPassDescriptorSet(Renderer::DescriptorSetSlot::TERRAIN) + , _materialPassDescriptorSet(Renderer::DescriptorSetSlot::TERRAIN) + , _cullingPassDescriptorSet(Renderer::DescriptorSetSlot::PER_PASS) + , _fillPassDescriptorSet(Renderer::DescriptorSetSlot::PER_PASS) { if (CVAR_TerrainValidateTransfers.Get()) { @@ -326,15 +331,7 @@ void TerrainRenderer::AddCullingPass(Renderer::RenderGraph* renderGraph, RenderR { commandList.PushMarker("Reset indirect", Color::White); - Renderer::ComputePipelineDesc pipelineDesc; - pipelineDesc.debugName = "Terrain Reset indirect"; - graphResources.InitializePipelineDesc(pipelineDesc); - - Renderer::ComputeShaderDesc shaderDesc; - shaderDesc.path = "Utils/resetIndirectBuffer.cs.hlsl"; - pipelineDesc.computeShader = _renderer->LoadShader(shaderDesc); - - Renderer::ComputePipelineID pipeline = _renderer->CreatePipeline(pipelineDesc); + Renderer::ComputePipelineID pipeline = _resetIndirectBufferPipeline; commandList.BeginPipeline(pipeline); struct ResetIndirectBufferConstants @@ -363,15 +360,7 @@ void TerrainRenderer::AddCullingPass(Renderer::RenderGraph* renderGraph, RenderR commandList.BufferBarrier(data.argumentBuffer, Renderer::BufferPassUsage::COMPUTE); // Cull instances on GPU - Renderer::ComputePipelineDesc pipelineDesc; - pipelineDesc.debugName = "Terrain Culling"; - graphResources.InitializePipelineDesc(pipelineDesc); - - Renderer::ComputeShaderDesc shaderDesc; - shaderDesc.path = "Terrain/Culling.cs.hlsl"; - pipelineDesc.computeShader = _renderer->LoadShader(shaderDesc); - - Renderer::ComputePipelineID pipeline = _renderer->CreatePipeline(pipelineDesc); + Renderer::ComputePipelineID pipeline = _cullingPipeline; commandList.BeginPipeline(pipeline); struct CullConstants @@ -999,6 +988,133 @@ void TerrainRenderer::CreatePermanentResources() _chunkDatas.SetDebugName("TerrainChunkData"); _chunkDatas.SetUsage(Renderer::BufferUsage::STORAGE_BUFFER); + + CreateTerrainPipelines(); +} + +void TerrainRenderer::CreateTerrainPipelines() +{ + bool supportsExtendedTextures = _renderer->HasExtendedTextureSupport(); + + // Reset Indirect Buffer + { + Renderer::ComputePipelineDesc pipelineDesc; + pipelineDesc.debugName = "Terrain Reset indirect"; + + Renderer::ComputeShaderDesc shaderDesc; + shaderDesc.shaderEntry = _gameRenderer->GetShaderEntry("Utils/ResetIndirectBuffer.cs.hlsl"_h); + shaderDesc.shaderEntry.debugName = "Utils/ResetIndirectBuffer.cs.hlsl"; + pipelineDesc.computeShader = _renderer->LoadShader(shaderDesc); + + _resetIndirectBufferPipeline = _renderer->CreatePipeline(pipelineDesc); + } + // Fill Draw Calls + { + Renderer::ComputePipelineDesc pipelineDesc; + pipelineDesc.debugName = "Terrain Fill Draw Calls"; + + Renderer::ComputeShaderDesc shaderDesc; + shaderDesc.shaderEntry = _gameRenderer->GetShaderEntry("Terrain/FillDrawCalls.cs.hlsl"_h); + shaderDesc.shaderEntry.debugName = "Terrain/FillDrawCalls.cs.hlsl"; + pipelineDesc.computeShader = _renderer->LoadShader(shaderDesc); + + _fillDrawCallsPipeline = _renderer->CreatePipeline(pipelineDesc); + } + // Culling + { + Renderer::ComputePipelineDesc pipelineDesc; + pipelineDesc.debugName = "Terrain Culling"; + + Renderer::ComputeShaderDesc shaderDesc; + shaderDesc.shaderEntry = _gameRenderer->GetShaderEntry("Terrain/Culling.cs.hlsl"_h); + shaderDesc.shaderEntry.debugName = "Terrain/Culling.cs.hlsl"; + pipelineDesc.computeShader = _renderer->LoadShader(shaderDesc); + + _cullingPipeline = _renderer->CreatePipeline(pipelineDesc); + } + // Draw regular + { + Renderer::GraphicsPipelineDesc pipelineDesc; + pipelineDesc.debugName = "Terrain Draw"; + + // Shaders + Renderer::VertexShaderDesc vertexShaderDesc; + { + std::vector permutationFields = + { + { "EDITOR_PASS", "0" }, + { "SHADOW_PASS", "0" }, + { "SUPPORTS_EXTENDED_TEXTURES", supportsExtendedTextures ? "1" : "0" } + }; + u32 shaderEntryNameHash = Renderer::GetShaderEntryNameHash("Terrain/Draw.vs.hlsl", permutationFields); + vertexShaderDesc.shaderEntry = _gameRenderer->GetShaderEntry(shaderEntryNameHash); + vertexShaderDesc.shaderEntry.debugName = "Terrain/Draw.vs.hlsl"; + pipelineDesc.states.vertexShader = _renderer->LoadShader(vertexShaderDesc); + } + + Renderer::PixelShaderDesc pixelShaderDesc; + { + std::vector permutationFields = + { + { "SUPPORTS_EXTENDED_TEXTURES", supportsExtendedTextures ? "1" : "0" } + }; + u32 shaderEntryNameHash = Renderer::GetShaderEntryNameHash("Terrain/Draw.ps.hlsl", permutationFields); + pixelShaderDesc.shaderEntry = _gameRenderer->GetShaderEntry(shaderEntryNameHash); + pixelShaderDesc.shaderEntry.debugName = "Terrain/Draw.ps.hlsl"; + pipelineDesc.states.pixelShader = _renderer->LoadShader(pixelShaderDesc); + } + + // Depth state + pipelineDesc.states.depthStencilState.depthEnable = true; + pipelineDesc.states.depthStencilState.depthWriteEnable = true; + pipelineDesc.states.depthStencilState.depthFunc = Renderer::ComparisonFunc::GREATER; + + // Rasterizer state + pipelineDesc.states.rasterizerState.cullMode = Renderer::CullMode::BACK; + pipelineDesc.states.rasterizerState.frontFaceMode = Renderer::Settings::FRONT_FACE_STATE; + + // Render targets + pipelineDesc.states.renderTargetFormats[0] = Renderer::ImageFormat::R32G32_UINT; // Visibility buffer format + pipelineDesc.states.depthStencilFormat = Renderer::DepthImageFormat::D32_FLOAT; + + _drawPipeline = _renderer->CreatePipeline(pipelineDesc); + } + // Draw shadow + { + Renderer::GraphicsPipelineDesc pipelineDesc; + pipelineDesc.debugName = "Terrain Draw Shadow"; + + // Shaders + Renderer::VertexShaderDesc vertexShaderDesc; + { + std::vector permutationFields = + { + { "EDITOR_PASS", "0" }, + { "SHADOW_PASS", "1" }, + { "SUPPORTS_EXTENDED_TEXTURES", supportsExtendedTextures ? "1" : "0" } + }; + u32 shaderEntryNameHash = Renderer::GetShaderEntryNameHash("Terrain/Draw.vs.hlsl", permutationFields); + vertexShaderDesc.shaderEntry = _gameRenderer->GetShaderEntry(shaderEntryNameHash); + vertexShaderDesc.shaderEntry.debugName = "Terrain/Draw.vs.hlsl"; + pipelineDesc.states.vertexShader = _renderer->LoadShader(vertexShaderDesc); + } + + // Depth state + pipelineDesc.states.depthStencilState.depthEnable = true; + pipelineDesc.states.depthStencilState.depthWriteEnable = true; + pipelineDesc.states.depthStencilState.depthFunc = Renderer::ComparisonFunc::GREATER; + + // Rasterizer state + pipelineDesc.states.rasterizerState.cullMode = Renderer::CullMode::NONE; + pipelineDesc.states.rasterizerState.frontFaceMode = Renderer::Settings::FRONT_FACE_STATE; + pipelineDesc.states.rasterizerState.depthBiasEnabled = true; + pipelineDesc.states.rasterizerState.depthClampEnabled = true; + + // Render targets + pipelineDesc.states.depthStencilFormat = Renderer::DepthImageFormat::D32_FLOAT; + + _drawShadowPipeline = _renderer->CreatePipeline(pipelineDesc); + } } void TerrainRenderer::SyncToGPU() @@ -1082,48 +1198,8 @@ void TerrainRenderer::Draw(const RenderResources& resources, u8 frameIndex, Rend renderPassDesc.depthStencil = params.depth; commandList.BeginRenderPass(renderPassDesc); - Renderer::GraphicsPipelineDesc pipelineDesc; - - // Shaders - Renderer::VertexShaderDesc vertexShaderDesc; - vertexShaderDesc.path = "Terrain/Draw.vs.hlsl"; - vertexShaderDesc.AddPermutationField("EDITOR_PASS", "0"); - vertexShaderDesc.AddPermutationField("SHADOW_PASS", params.shadowPass ? "1" : "0"); - vertexShaderDesc.AddPermutationField("SUPPORTS_EXTENDED_TEXTURES", _renderer->HasExtendedTextureSupport() ? "1" : "0"); - - pipelineDesc.states.vertexShader = _renderer->LoadShader(vertexShaderDesc); - - if (!params.shadowPass) - { - Renderer::PixelShaderDesc pixelShaderDesc; - pixelShaderDesc.path = "Terrain/Draw.ps.hlsl"; - pixelShaderDesc.AddPermutationField("SUPPORTS_EXTENDED_TEXTURES", _renderer->HasExtendedTextureSupport() ? "1" : "0"); - - pipelineDesc.states.pixelShader = _renderer->LoadShader(pixelShaderDesc); - } - - // Depth state - pipelineDesc.states.depthStencilState.depthEnable = true; - pipelineDesc.states.depthStencilState.depthWriteEnable = true; - pipelineDesc.states.depthStencilState.depthFunc = Renderer::ComparisonFunc::GREATER; - - // Rasterizer state - pipelineDesc.states.rasterizerState.cullMode = params.shadowPass ? Renderer::CullMode::NONE : Renderer::CullMode::BACK; - pipelineDesc.states.rasterizerState.frontFaceMode = Renderer::Settings::FRONT_FACE_STATE; - pipelineDesc.states.rasterizerState.depthBiasEnabled = params.shadowPass; - pipelineDesc.states.rasterizerState.depthClampEnabled = params.shadowPass; - - // Render targets - if (!params.shadowPass) - { - const Renderer::ImageDesc& desc = graphResources.GetImageDesc(params.visibilityBuffer); - pipelineDesc.states.renderTargetFormats[0] = desc.format; - } - const Renderer::DepthImageDesc& depthDesc = graphResources.GetImageDesc(params.depth); - pipelineDesc.states.depthStencilFormat = depthDesc.format; - // Set pipeline - Renderer::GraphicsPipelineID pipeline = _renderer->CreatePipeline(pipelineDesc); // This will compile the pipeline and return the ID, or just return ID of cached pipeline + Renderer::GraphicsPipelineID pipeline = _drawPipeline; commandList.BeginPipeline(pipeline); // Set index buffer @@ -1165,14 +1241,7 @@ void TerrainRenderer::FillDrawCalls(u8 frameIndex, Renderer::RenderGraphResource { commandList.PushMarker(params.passName + " Fill", Color::White); - Renderer::ComputePipelineDesc pipelineDesc; - graphResources.InitializePipelineDesc(pipelineDesc); - - Renderer::ComputeShaderDesc shaderDesc; - shaderDesc.path = "Terrain/FillDrawCalls.cs.hlsl"; - pipelineDesc.computeShader = _renderer->LoadShader(shaderDesc); - - Renderer::ComputePipelineID pipeline = _renderer->CreatePipeline(pipelineDesc); + Renderer::ComputePipelineID pipeline = _fillDrawCallsPipeline; commandList.BeginPipeline(pipeline); struct FillDrawCallConstants diff --git a/Source/Game-Lib/Game-Lib/Rendering/Terrain/TerrainRenderer.h b/Source/Game-Lib/Game-Lib/Rendering/Terrain/TerrainRenderer.h index 66fdb1c1..db83993d 100644 --- a/Source/Game-Lib/Game-Lib/Rendering/Terrain/TerrainRenderer.h +++ b/Source/Game-Lib/Game-Lib/Rendering/Terrain/TerrainRenderer.h @@ -12,6 +12,7 @@ #include class DebugRenderer; +class GameRenderer; struct RenderResources; namespace Renderer @@ -39,7 +40,7 @@ struct TerrainReserveOffsets class TerrainRenderer { public: - TerrainRenderer(Renderer::Renderer* renderer, DebugRenderer* debugRenderer); + TerrainRenderer(Renderer::Renderer* renderer, GameRenderer* gameRenderer, DebugRenderer* debugRenderer); ~TerrainRenderer(); void Update(f32 deltaTime); @@ -70,6 +71,7 @@ class TerrainRenderer private: void CreatePermanentResources(); + void CreateTerrainPipelines(); void SyncToGPU(); @@ -148,8 +150,15 @@ class TerrainRenderer private: Renderer::Renderer* _renderer = nullptr; + GameRenderer* _gameRenderer = nullptr; DebugRenderer* _debugRenderer = nullptr; + Renderer::ComputePipelineID _resetIndirectBufferPipeline; + Renderer::ComputePipelineID _fillDrawCallsPipeline; + Renderer::ComputePipelineID _cullingPipeline; + Renderer::GraphicsPipelineID _drawPipeline; + Renderer::GraphicsPipelineID _drawShadowPipeline; + Renderer::GPUVector _cellIndices; Renderer::GPUVector _vertices; Renderer::GPUVector _instanceDatas; diff --git a/Source/Game-Lib/Game-Lib/Rendering/Texture/TextureRenderer.cpp b/Source/Game-Lib/Game-Lib/Rendering/Texture/TextureRenderer.cpp index ebf2ac92..60231d9b 100644 --- a/Source/Game-Lib/Game-Lib/Rendering/Texture/TextureRenderer.cpp +++ b/Source/Game-Lib/Game-Lib/Rendering/Texture/TextureRenderer.cpp @@ -30,9 +30,12 @@ void TextureRenderer::Clear() } -TextureRenderer::TextureRenderer(Renderer::Renderer* renderer, DebugRenderer* debugRenderer) +TextureRenderer::TextureRenderer(Renderer::Renderer* renderer, GameRenderer* gameRenderer, DebugRenderer* debugRenderer) : _renderer(renderer) + , _gameRenderer(gameRenderer) , _debugRenderer(debugRenderer) + , _descriptorSet(Renderer::DescriptorSetSlot::PER_PASS) + , _mipResolveDescriptorSet(Renderer::DescriptorSetSlot::PER_PASS) { CreatePermanentResources(); } @@ -242,7 +245,8 @@ void TextureRenderer::CreatePermanentResources() pipelineDesc.debugName = "Downsample Mips"; Renderer::ComputeShaderDesc shaderDesc; - shaderDesc.path = "DownSampler/SinglePassDownsampler.cs.hlsl"; + shaderDesc.shaderEntry = _gameRenderer->GetShaderEntry("DownSampler/SinglePassDownsampler.cs.hlsl"_h); + shaderDesc.shaderEntry.debugName = "DownSampler/SinglePassDownsampler.cs.hlsl"; pipelineDesc.computeShader = _renderer->LoadShader(shaderDesc); _mipDownsamplerPipeline = _renderer->CreatePipeline(pipelineDesc); @@ -280,7 +284,7 @@ void TextureRenderer::RenderTextureToTexture(Renderer::RenderGraphResources& gra commandList.BeginPipeline(pipeline); descriptorSet.BindRead("_texture", src); - commandList.BindDescriptorSet(Renderer::DescriptorSetSlot::GLOBAL, descriptorSet, frameIndex); + commandList.BindDescriptorSet(Renderer::DescriptorSetSlot::PER_PASS, descriptorSet, frameIndex); struct BlitConstant { @@ -372,13 +376,13 @@ Renderer::GraphicsPipelineID TextureRenderer::CreatePipeline(Renderer::ImageForm // Shaders Renderer::VertexShaderDesc vertexShaderDesc; - vertexShaderDesc.path = "Blitting/blit.vs.hlsl"; - + vertexShaderDesc.shaderEntry = _gameRenderer->GetShaderEntry("Blitting/Blit.vs.hlsl"_h); + vertexShaderDesc.shaderEntry.debugName = "Blitting/Blit.vs.hlsl"; pipelineDesc.states.vertexShader = _renderer->LoadShader(vertexShaderDesc); Renderer::PixelShaderDesc pixelShaderDesc; - pixelShaderDesc.path = "Blitting/blitSample.ps.hlsl"; - + pixelShaderDesc.shaderEntry = _gameRenderer->GetShaderEntry("Blitting/BlitSample.ps.hlsl"_h); + pixelShaderDesc.shaderEntry.debugName = "Blitting/BlitSample.ps.hlsl"; pipelineDesc.states.pixelShader = _renderer->LoadShader(pixelShaderDesc); // Depth state @@ -399,6 +403,5 @@ Renderer::GraphicsPipelineID TextureRenderer::CreatePipeline(Renderer::ImageForm pipelineDesc.states.blendState.renderTargets[0].destBlendAlpha = Renderer::BlendMode::ONE; pipelineDesc.states.blendState.renderTargets[0].blendOpAlpha = Renderer::BlendOp::MAX; - // Set pipeline return _renderer->CreatePipeline(pipelineDesc); // This will compile the pipeline and return the ID, or just return ID of cached pipeline } diff --git a/Source/Game-Lib/Game-Lib/Rendering/Texture/TextureRenderer.h b/Source/Game-Lib/Game-Lib/Rendering/Texture/TextureRenderer.h index 2b75e42a..e3710a6a 100644 --- a/Source/Game-Lib/Game-Lib/Rendering/Texture/TextureRenderer.h +++ b/Source/Game-Lib/Game-Lib/Rendering/Texture/TextureRenderer.h @@ -1,5 +1,6 @@ #pragma once #include "Game-Lib/ECS/Components/UI/Widget.h" +#include "Game-Lib/Rendering/GameRenderer.h" #include #include @@ -19,11 +20,12 @@ namespace Renderer struct RenderResources; class Window; class DebugRenderer; +class GameRenderer; class TextureRenderer { public: - TextureRenderer(Renderer::Renderer* renderer, DebugRenderer* debugRenderer); + TextureRenderer(Renderer::Renderer* renderer, GameRenderer* gameRenderer, DebugRenderer* debugRenderer); void Clear(); void Update(f32 deltaTime); @@ -66,6 +68,7 @@ class TextureRenderer private: Renderer::Renderer* _renderer; + GameRenderer* _gameRenderer = nullptr; DebugRenderer* _debugRenderer; robin_hood::unordered_map _pipelines; diff --git a/Source/Game-Lib/Game-Lib/Rendering/UIRenderer.cpp b/Source/Game-Lib/Game-Lib/Rendering/UIRenderer.cpp index 0568be48..a1b2b1df 100644 --- a/Source/Game-Lib/Game-Lib/Rendering/UIRenderer.cpp +++ b/Source/Game-Lib/Game-Lib/Rendering/UIRenderer.cpp @@ -13,7 +13,11 @@ #include //#include -UIRenderer::UIRenderer(Renderer::Renderer* renderer) : _renderer(renderer) +UIRenderer::UIRenderer(Renderer::Renderer* renderer) + : _renderer(renderer) + , _passDescriptorSet(Renderer::DescriptorSetSlot::PER_PASS) + , _drawImageDescriptorSet(Renderer::DescriptorSetSlot::PER_PASS) + , _drawTextDescriptorSet(Renderer::DescriptorSetSlot::PER_PASS) { CreatePermanentResources(); } diff --git a/Source/ShaderCookerStandalone/ShaderCookerStandalone.lua b/Source/ShaderCookerStandalone/ShaderCookerStandalone.lua index 63491fa6..2ed50d68 100644 --- a/Source/ShaderCookerStandalone/ShaderCookerStandalone.lua +++ b/Source/ShaderCookerStandalone/ShaderCookerStandalone.lua @@ -1,7 +1,7 @@ local mod = Solution.Util.CreateModuleTable("ShaderCookerStandalone", { "shadercooker", "base" }) Solution.Util.CreateConsoleApp(mod.Name, Solution.Projects.Current.BinDir, mod.Dependencies, function() - local defines = { "_SILENCE_ALL_CXX17_DEPRECATION_WARNINGS", "_SILENCE_ALL_MS_EXT_DEPRECATION_WARNINGS" } + local defines = { "_SILENCE_ALL_CXX17_DEPRECATION_WARNINGS", "_SILENCE_ALL_MS_EXT_DEPRECATION_WARNINGS", "SLANG_STATIC" } Solution.Util.SetLanguage("C++") Solution.Util.SetCppDialect(20) @@ -10,14 +10,4 @@ Solution.Util.CreateConsoleApp(mod.Name, Solution.Projects.Current.BinDir, mod.D Solution.Util.SetFiles(files) Solution.Util.SetIncludes(mod.Path) Solution.Util.SetDefines(defines) - - if os.target() == "windows" then - -- fetch the dxcompiler dependency table - local dxcDepCache = Solution.Util.GetDepCache("dxcompiler", "cache") - if not dxcDepCache.libPaths then - Solution.Util.PrintError("Failed to find DXCompiler Dynamic Lib Path, this setting is supposed to be set during the setup of dxcompiler in premake") - end - - postbuildcommands { "{COPYFILE} " .. dxcDepCache.libPaths .. "/dxcompiler.%{systemToDynamicLibExtensionMap[cfg.system]} " .. Solution.Projects.Current.BinDir .. "/%{cfg.buildcfg}/dxcompiler.%{systemToDynamicLibExtensionMap[cfg.system]}" } - end end) diff --git a/Source/ShaderCookerStandalone/main.cpp b/Source/ShaderCookerStandalone/main.cpp index 4eccb731..cbc3e475 100644 --- a/Source/ShaderCookerStandalone/main.cpp +++ b/Source/ShaderCookerStandalone/main.cpp @@ -20,14 +20,32 @@ i32 main(int argc, char* argv[]) auto console_sink = quill::Frontend::create_or_get_sink("console_sink_1", colors, "stderr"); quill::Logger* logger = quill::Frontend::create_or_get_logger("root", std::move(console_sink), "%(time:<16) LOG_%(log_level:<11) %(message)", "%H:%M:%S.%Qms", quill::Timezone::LocalTime, quill::ClockSourceType::System); - if (argc != 3) + int argIndex = 1; + + // Handle force flag + bool debugSkipCache = false; + if (argc > 1 && std::string(argv[1]) == "-f") + { + debugSkipCache = true; + argIndex++; + } + + // Handle debug SPV output flag + bool debugOutputSpv = false; + if (argc > argIndex && std::string(argv[argIndex]) == "-d") + { + debugOutputSpv = true; + argIndex++; + } + + if (argc - argIndex != 2) { - NC_LOG_ERROR("Expected two parameters, got {0}. Usage: ", argc); + NC_LOG_ERROR("Expected two parameters, got {}. Usage: [-f] [-d] ", argc - 1); return -1; } - std::string sourceDir = argv[1]; - std::string binDir = argv[2]; + std::string sourceDir = argv[argIndex]; + std::string binDir = argv[argIndex + 1]; std::chrono::system_clock::time_point startTime = std::chrono::system_clock::now(); std::filesystem::path shaderCachePath = std::filesystem::path(binDir) / "_shaders.cache"; @@ -35,7 +53,6 @@ i32 main(int argc, char* argv[]) ShaderCooker::ShaderCache shaderCache; - const bool debugSkipCache = false; if (!debugSkipCache) { std::string shaderCachePathStr = shaderCachePath.string(); @@ -51,10 +68,11 @@ i32 main(int argc, char* argv[]) } else { - NC_LOG_INFO("Skipped loading shadercache due to debugSkipCache being true"); + NC_LOG_INFO("Skipped loading shadercache due to being ran with -f flag"); } ShaderCooker::ShaderCompiler compiler; + compiler.SetDebugOutputSPV(debugOutputSpv); // Find all shader files in the source directory std::vector shadersToCompile; @@ -107,7 +125,7 @@ i32 main(int argc, char* argv[]) std::chrono::duration duration = endTime - startTime; u32 numCompiledShaders = compiler.GetNumCompiledShaders(); - u32 numSkippedShaders = numNonIncludeShaders - numCompiledShaders; + u32 numSkippedShaders = numNonIncludeShaders - numCompiledShaders - numFailedShaders; NC_LOG_INFO("Compiled {0} shaders ({1} up to date) in {2}s", numCompiledShaders, numSkippedShaders, duration.count()); return 0; } \ No newline at end of file diff --git a/Source/Shaders/Shaders/Blitting/blit.ps.hlsl b/Source/Shaders/Shaders/Blitting/Blit.ps.hlsl similarity index 85% rename from Source/Shaders/Shaders/Blitting/blit.ps.hlsl rename to Source/Shaders/Shaders/Blitting/Blit.ps.hlsl index 024d9fc5..6f8b963f 100644 --- a/Source/Shaders/Shaders/Blitting/blit.ps.hlsl +++ b/Source/Shaders/Shaders/Blitting/Blit.ps.hlsl @@ -1,9 +1,9 @@ permutation TEX_TYPE = [float, float2, float3, float4, int, int2, int3, int4, uint, uint2, uint3, uint4]; -#include "common.inc.hlsl" +#include "Include/Common.inc.hlsl" -[[vk::binding(0, GLOBAL)]] SamplerState _sampler; -[[vk::binding(1, GLOBAL)]] Texture2D _texture; +[[vk::binding(0, PER_PASS)]] SamplerState _sampler; +[[vk::binding(1, PER_PASS)]] Texture2D _texture; struct Constants { @@ -20,6 +20,7 @@ struct VSOutput float2 uv : TEXCOORD0; }; +[shader("fragment")] float4 main(VSOutput input) : SV_Target { float2 dimensions; @@ -28,7 +29,7 @@ float4 main(VSOutput input) : SV_Target float2 uv = float2(input.uv.x, 1.0 - input.uv.y); uv = uv * _constants.uvOffsetAndExtent.zw + _constants.uvOffsetAndExtent.xy; - int3 location = int3(uv * dimensions, 0); + int3 location = int3((int2)(uv * dimensions), 0); float4 color = ToFloat4(_texture.Load(location), 1.0f); diff --git a/Source/Shaders/Shaders/Blitting/blit.vs.hlsl b/Source/Shaders/Shaders/Blitting/Blit.vs.hlsl similarity index 84% rename from Source/Shaders/Shaders/Blitting/blit.vs.hlsl rename to Source/Shaders/Shaders/Blitting/Blit.vs.hlsl index 5a3ff43e..e93d2642 100644 --- a/Source/Shaders/Shaders/Blitting/blit.vs.hlsl +++ b/Source/Shaders/Shaders/Blitting/Blit.vs.hlsl @@ -1,7 +1,7 @@ struct VSInput { - uint vertexID : SV_VertexID; + uint vertexID : SV_VulkanVertexID; }; struct VSOutput @@ -10,6 +10,7 @@ struct VSOutput float4 position : SV_POSITION; }; +[shader("vertex")] VSOutput main(VSInput input) { VSOutput output; diff --git a/Source/Shaders/Shaders/Blitting/blitDepth.cs.hlsl b/Source/Shaders/Shaders/Blitting/BlitDepth.cs.hlsl similarity index 72% rename from Source/Shaders/Shaders/Blitting/blitDepth.cs.hlsl rename to Source/Shaders/Shaders/Blitting/BlitDepth.cs.hlsl index 37ddb141..4ee74ee6 100644 --- a/Source/Shaders/Shaders/Blitting/blitDepth.cs.hlsl +++ b/Source/Shaders/Shaders/Blitting/BlitDepth.cs.hlsl @@ -1,7 +1,7 @@ -[[vk::binding(0, GLOBAL)]] SamplerState _sampler; -[[vk::binding(1, GLOBAL)]] Texture2D _source; -[[vk::binding(2, GLOBAL)]] RWTexture2D _target; +[[vk::binding(0, PER_PASS)]] SamplerState _sampler; +[[vk::binding(1, PER_PASS)]] Texture2D _source; +[[vk::binding(2, PER_PASS)]] RWTexture2D _target; struct Constants { @@ -12,6 +12,7 @@ struct Constants [[vk::push_constant]] Constants _constants; +[shader("compute")] [numthreads(32, 32, 1)] void main(uint3 DTid : SV_DispatchThreadID) { diff --git a/Source/Shaders/Shaders/Blitting/blitSample.ps.hlsl b/Source/Shaders/Shaders/Blitting/BlitSample.ps.hlsl similarity index 87% rename from Source/Shaders/Shaders/Blitting/blitSample.ps.hlsl rename to Source/Shaders/Shaders/Blitting/BlitSample.ps.hlsl index 94fd79d4..a565ef62 100644 --- a/Source/Shaders/Shaders/Blitting/blitSample.ps.hlsl +++ b/Source/Shaders/Shaders/Blitting/BlitSample.ps.hlsl @@ -1,7 +1,8 @@ -#include "common.inc.hlsl" -[[vk::binding(0, GLOBAL)]] SamplerState _sampler; -[[vk::binding(1, GLOBAL)]] Texture2D _texture; +#include "Include/Common.inc.hlsl" + +[[vk::binding(0, PER_PASS)]] SamplerState _sampler; +[[vk::binding(1, PER_PASS)]] Texture2D _texture; struct Constants { @@ -18,6 +19,7 @@ struct VSOutput float2 uv : TEXCOORD0; }; +[shader("fragment")] float4 main(VSOutput input) : SV_Target { float2 dimensions; diff --git a/Source/Shaders/Shaders/Debug/Debug2D.ps.hlsl b/Source/Shaders/Shaders/Debug/Debug2D.ps.hlsl index e0106325..58668789 100644 --- a/Source/Shaders/Shaders/Debug/Debug2D.ps.hlsl +++ b/Source/Shaders/Shaders/Debug/Debug2D.ps.hlsl @@ -1,8 +1,10 @@ + struct PSInput { float4 color : Color; }; +[shader("fragment")] float4 main(PSInput input) : SV_Target0 { return input.color; diff --git a/Source/Shaders/Shaders/Debug/Debug2D.vs.hlsl b/Source/Shaders/Shaders/Debug/Debug2D.vs.hlsl index f478e1c6..e01e53d7 100644 --- a/Source/Shaders/Shaders/Debug/Debug2D.vs.hlsl +++ b/Source/Shaders/Shaders/Debug/Debug2D.vs.hlsl @@ -10,7 +10,7 @@ struct Vertex2D struct VSInput { - uint vertexID : SV_VertexID; + uint vertexID : SV_VulkanVertexID; }; struct VSOutput @@ -31,6 +31,7 @@ float4 GetVertexColor(uint inColor) return color; } +[shader("vertex")] VSOutput main(VSInput input) { Vertex2D vertex = _vertices[input.vertexID]; diff --git a/Source/Shaders/Shaders/Debug/Debug3D.ps.hlsl b/Source/Shaders/Shaders/Debug/Debug3D.ps.hlsl index e0106325..58668789 100644 --- a/Source/Shaders/Shaders/Debug/Debug3D.ps.hlsl +++ b/Source/Shaders/Shaders/Debug/Debug3D.ps.hlsl @@ -1,8 +1,10 @@ + struct PSInput { float4 color : Color; }; +[shader("fragment")] float4 main(PSInput input) : SV_Target0 { return input.color; diff --git a/Source/Shaders/Shaders/Debug/Debug3D.vs.hlsl b/Source/Shaders/Shaders/Debug/Debug3D.vs.hlsl index f3d045a2..ebff0325 100644 --- a/Source/Shaders/Shaders/Debug/Debug3D.vs.hlsl +++ b/Source/Shaders/Shaders/Debug/Debug3D.vs.hlsl @@ -1,4 +1,5 @@ -#include "globalData.inc.hlsl" + +#include "DescriptorSet/Global.inc.hlsl" struct Vertex3D { @@ -10,7 +11,7 @@ struct Vertex3D struct VSInput { - uint vertexID : SV_VertexID; + uint vertexID : SV_VulkanVertexID; }; struct VSOutput @@ -31,6 +32,7 @@ float4 GetVertexColor(uint inColor) return color; } +[shader("vertex")] VSOutput main(VSInput input) { Vertex3D vertex = _vertices[input.vertexID]; diff --git a/Source/Shaders/Shaders/Debug/DebugSolid3D.ps.hlsl b/Source/Shaders/Shaders/Debug/DebugSolid3D.ps.hlsl index bd35eb88..fc4c6600 100644 --- a/Source/Shaders/Shaders/Debug/DebugSolid3D.ps.hlsl +++ b/Source/Shaders/Shaders/Debug/DebugSolid3D.ps.hlsl @@ -1,9 +1,11 @@ + struct PSInput { float3 normal : TEXCOORD0; float4 color : Color; }; +[shader("fragment")] float4 main(PSInput input) : SV_Target0 { float4 color = input.color; diff --git a/Source/Shaders/Shaders/Debug/DebugSolid3D.vs.hlsl b/Source/Shaders/Shaders/Debug/DebugSolid3D.vs.hlsl index 6eab51e2..23b04a9b 100644 --- a/Source/Shaders/Shaders/Debug/DebugSolid3D.vs.hlsl +++ b/Source/Shaders/Shaders/Debug/DebugSolid3D.vs.hlsl @@ -1,4 +1,5 @@ -#include "globalData.inc.hlsl" + +#include "DescriptorSet/Global.inc.hlsl" struct Vertex3D { @@ -10,7 +11,7 @@ struct Vertex3D struct VSInput { - uint vertexID : SV_VertexID; + uint vertexID : SV_VulkanVertexID; }; struct VSOutput @@ -32,6 +33,7 @@ float4 GetVertexColor(uint inColor) return color; } +[shader("vertex")] VSOutput main(VSInput input) { Vertex3D vertex = _vertices[input.vertexID]; diff --git a/Source/Shaders/Shaders/DescriptorSet/Debug.inc.hlsl b/Source/Shaders/Shaders/DescriptorSet/Debug.inc.hlsl new file mode 100644 index 00000000..fc250f98 --- /dev/null +++ b/Source/Shaders/Shaders/DescriptorSet/Debug.inc.hlsl @@ -0,0 +1,9 @@ +#ifndef DEBUG_SET_INCLUDED +#define DEBUG_SET_INCLUDED + +[[vk::binding(0, DEBUG)]] RWStructuredBuffer _debugVertices2D; +[[vk::binding(1, DEBUG)]] RWByteAddressBuffer _debugVertices2DCount; +[[vk::binding(2, DEBUG)]] RWStructuredBuffer _debugVertices3D; +[[vk::binding(3, DEBUG)]] RWByteAddressBuffer _debugVertices3DCount; + +#endif // DEBUG_SET_INCLUDED \ No newline at end of file diff --git a/Source/Shaders/Shaders/globalData.inc.hlsl b/Source/Shaders/Shaders/DescriptorSet/Global.inc.hlsl similarity index 54% rename from Source/Shaders/Shaders/globalData.inc.hlsl rename to Source/Shaders/Shaders/DescriptorSet/Global.inc.hlsl index 314eeb35..267281a5 100644 --- a/Source/Shaders/Shaders/globalData.inc.hlsl +++ b/Source/Shaders/Shaders/DescriptorSet/Global.inc.hlsl @@ -1,8 +1,8 @@ -#ifndef GLOBALDATA_INCLUDED -#define GLOBALDATA_INCLUDED +#ifndef GLOBAL_SET_INCLUDED +#define GLOBAL_SET_INCLUDED #include "Include/Camera.inc.hlsl" [[vk::binding(0, GLOBAL)]] StructuredBuffer _cameras; -#endif // GLOBALDATA_INCLUDED \ No newline at end of file +#endif // GLOBAL_SET_INCLUDED \ No newline at end of file diff --git a/Source/Shaders/Shaders/DescriptorSet/Light.inc.hlsl b/Source/Shaders/Shaders/DescriptorSet/Light.inc.hlsl new file mode 100644 index 00000000..13ca73f0 --- /dev/null +++ b/Source/Shaders/Shaders/DescriptorSet/Light.inc.hlsl @@ -0,0 +1,13 @@ +#ifndef LIGHT_SET_INCLUDED +#define LIGHT_SET_INCLUDED + +#ifndef MAX_SHADOW_CASCADES +#define MAX_SHADOW_CASCADES 8 // Has to be kept in sync with the one in RenderSettings.h +#endif + +[[vk::binding(0, LIGHT)]] SamplerComparisonState _shadowCmpSampler; +[[vk::binding(1, LIGHT)]] SamplerState _shadowPointClampSampler; +[[vk::binding(2, LIGHT)]] Texture2D _shadowCascadeRTs[MAX_SHADOW_CASCADES]; +[[vk::binding(3, LIGHT)]] StructuredBuffer _packedDecals; // All decals in the world + +#endif // LIGHT_SET_INCLUDED \ No newline at end of file diff --git a/Source/Shaders/Shaders/DescriptorSet/Model.inc.hlsl b/Source/Shaders/Shaders/DescriptorSet/Model.inc.hlsl new file mode 100644 index 00000000..bac0b78f --- /dev/null +++ b/Source/Shaders/Shaders/DescriptorSet/Model.inc.hlsl @@ -0,0 +1,24 @@ +#ifndef MODEL_SET_INCLUDED +#define MODEL_SET_INCLUDED + +#include "Include/Common.inc.hlsl" + +#define MAX_MODEL_SAMPLERS 4 + +[[vk::binding(0, MODEL)]] StructuredBuffer _culledInstanceLookupTable; // One uint per instance, contains instanceRefID of what survives culling, and thus can get reordered +[[vk::binding(1, MODEL)]] StructuredBuffer _instanceRefTable; +[[vk::binding(2, MODEL)]] StructuredBuffer _modelDrawCallDatas; +[[vk::binding(3, MODEL)]] StructuredBuffer _packedModelTextureDatas; +[[vk::binding(4, MODEL)]] StructuredBuffer _packedModelVertices; +[[vk::binding(5, MODEL)]] StructuredBuffer _modelInstanceDatas; +[[vk::binding(6, MODEL)]] StructuredBuffer _modelInstanceMatrices; +[[vk::binding(7, MODEL)]] StructuredBuffer _instanceBoneMatrices; +[[vk::binding(8, MODEL)]] StructuredBuffer _instanceTextureTransformMatrices; +[[vk::binding(9, MODEL)]] RWStructuredBuffer _animatedModelVertexPositions; +[[vk::binding(10, MODEL)]] StructuredBuffer _modelDraws; +[[vk::binding(11, MODEL)]] StructuredBuffer _modelIndices; +[[vk::binding(12, MODEL)]] StructuredBuffer _modelTextureUnits; +[[vk::binding(13, MODEL)]] SamplerState _samplers[MAX_MODEL_SAMPLERS]; +[[vk::binding(20, MODEL)]] Texture2D _modelTextures[MAX_TEXTURES]; // We give this index 20 because it always needs to be last in this descriptor set + +#endif // MODEL_SET_INCLUDED \ No newline at end of file diff --git a/Source/Shaders/Shaders/DescriptorSet/Terrain.inc.hlsl b/Source/Shaders/Shaders/DescriptorSet/Terrain.inc.hlsl new file mode 100644 index 00000000..0cfbb631 --- /dev/null +++ b/Source/Shaders/Shaders/DescriptorSet/Terrain.inc.hlsl @@ -0,0 +1,16 @@ +#ifndef TERRAIN_SET_INCLUDED +#define TERRAIN_SET_INCLUDED + +#include "Include/Common.inc.hlsl" + +#define NUM_CHUNKS_PER_MAP_SIDE (64) + +[[vk::binding(0, TERRAIN)]] StructuredBuffer _packedCellData; +[[vk::binding(1, TERRAIN)]] StructuredBuffer _packedTerrainVertices; +[[vk::binding(2, TERRAIN)]] StructuredBuffer _instanceDatas; +[[vk::binding(3, TERRAIN)]] StructuredBuffer _chunkData; +[[vk::binding(4, TERRAIN)]] SamplerState _alphaSampler; +[[vk::binding(7, TERRAIN)]] Texture2D _terrainColorTextures[MAX_TEXTURES]; +[[vk::binding(8, TERRAIN)]] Texture2DArray _terrainAlphaTextures[NUM_CHUNKS_PER_MAP_SIDE * NUM_CHUNKS_PER_MAP_SIDE]; + +#endif // TERRAIN_SET_INCLUDED \ No newline at end of file diff --git a/Source/Shaders/Shaders/DescriptorSet/Tiles.inc.hlsl b/Source/Shaders/Shaders/DescriptorSet/Tiles.inc.hlsl new file mode 100644 index 00000000..7f329cbc --- /dev/null +++ b/Source/Shaders/Shaders/DescriptorSet/Tiles.inc.hlsl @@ -0,0 +1,6 @@ +#ifndef TILES_SET_INCLUDED +#define TILES_SET_INCLUDED + +[[vk::binding(0, TILES)]] StructuredBuffer _entityTiles; + +#endif // TILES_SET_INCLUDED \ No newline at end of file diff --git a/Source/Shaders/Shaders/DownSampler/SinglePassDownsampler.cs.hlsl b/Source/Shaders/Shaders/DownSampler/SinglePassDownsampler.cs.hlsl index 5988cdfc..4b29ea2e 100644 --- a/Source/Shaders/Shaders/DownSampler/SinglePassDownsampler.cs.hlsl +++ b/Source/Shaders/Shaders/DownSampler/SinglePassDownsampler.cs.hlsl @@ -176,6 +176,7 @@ AH4 SpdReduce4H(AH4 v0, AH4 v1, AH4 v2, AH4 v3) // Main function //-------------------------------------------------------------------------------------- //-------------------------------------------------------------------------------------- +[shader("compute")] [numthreads(256, 1, 1)] void main(uint3 WorkGroupId : SV_GroupID, uint LocalThreadIndex : SV_GroupIndex) { diff --git a/Source/Shaders/Shaders/Editor/WorldGrid.ps.hlsl b/Source/Shaders/Shaders/Editor/WorldGrid.ps.hlsl index 7f51a077..03656113 100644 --- a/Source/Shaders/Shaders/Editor/WorldGrid.ps.hlsl +++ b/Source/Shaders/Shaders/Editor/WorldGrid.ps.hlsl @@ -1,4 +1,5 @@ -#include "globalData.inc.hlsl" + +#include "DescriptorSet/Global.inc.hlsl" struct Constants { @@ -47,6 +48,7 @@ float4 Grid(float3 pos, float scale, bool drawAxis) return color; } +[shader("fragment")] PSOutput main(VertexOutput input) : SV_Target { float t = -input.nearPoint.y / (input.farPoint.y - input.nearPoint.y); diff --git a/Source/Shaders/Shaders/Editor/WorldGrid.vs.hlsl b/Source/Shaders/Shaders/Editor/WorldGrid.vs.hlsl index 3d8267c6..4f19e1e1 100644 --- a/Source/Shaders/Shaders/Editor/WorldGrid.vs.hlsl +++ b/Source/Shaders/Shaders/Editor/WorldGrid.vs.hlsl @@ -1,8 +1,9 @@ -#include "globalData.inc.hlsl" + +#include "DescriptorSet/Global.inc.hlsl" struct VertexInput { - uint vertexID : SV_VertexID; + uint vertexID : SV_VulkanVertexID; }; struct VertexOutput @@ -18,6 +19,7 @@ float3 UnprojectPoint(float2 xy, float z, Camera camera) return unprojectedPoint.xyz / unprojectedPoint.w; } +[shader("vertex")] VertexOutput main(VertexInput input) { const float3 GRID_PLANE[6] = { diff --git a/Source/Shaders/Shaders/common.inc.hlsl b/Source/Shaders/Shaders/Include/Common.inc.hlsl similarity index 98% rename from Source/Shaders/Shaders/common.inc.hlsl rename to Source/Shaders/Shaders/Include/Common.inc.hlsl index 8b670c17..b6a472e4 100644 --- a/Source/Shaders/Shaders/common.inc.hlsl +++ b/Source/Shaders/Shaders/Include/Common.inc.hlsl @@ -10,6 +10,10 @@ #define MAX_TEXTURES_NORMAL 4096 // Don't increase this or we get issues with certain graphics cards not supporting enough textures #define MAX_TEXTURES_EXTENDED 8192 // Keep this synced with RenderSettings.h +#ifndef SUPPORTS_EXTENDED_TEXTURES +#define SUPPORTS_EXTENDED_TEXTURES 0 +#endif + #if SUPPORTS_EXTENDED_TEXTURES #define MAX_TEXTURES MAX_TEXTURES_EXTENDED #else diff --git a/Source/Shaders/Shaders/Include/Culling.inc.hlsl b/Source/Shaders/Shaders/Include/Culling.inc.hlsl index c54a1373..335557de 100644 --- a/Source/Shaders/Shaders/Include/Culling.inc.hlsl +++ b/Source/Shaders/Shaders/Include/Culling.inc.hlsl @@ -1,7 +1,8 @@ #ifndef CULLING_INCLUDED #define CULLING_INCLUDED -#include "globalData.inc.hlsl" -#include "common.inc.hlsl" + +#include "DescriptorSet/Global.inc.hlsl" +#include "Include/Common.inc.hlsl" struct AABBMinMax { @@ -9,7 +10,6 @@ struct AABBMinMax float3 max; }; -#define MAX_SHADOW_CASCADES 8 #define NUM_CULL_VIEWS 1 + MAX_SHADOW_CASCADES // Main view plus max number of cascades // Based on the work of WickedEngine, thank you! https://github.com/turanszkij/WickedEngine/ diff --git a/Source/Shaders/Shaders/Include/Debug.inc.hlsl b/Source/Shaders/Shaders/Include/Debug.inc.hlsl index 130cb73c..498b167d 100644 --- a/Source/Shaders/Shaders/Include/Debug.inc.hlsl +++ b/Source/Shaders/Shaders/Include/Debug.inc.hlsl @@ -1,5 +1,7 @@ #ifndef DEBUG_INCLUDED #define DEBUG_INCLUDED + +#include "DescriptorSet/Debug.inc.hlsl" #include "Include/Culling.inc.hlsl" static const float PI = 3.14159265f; @@ -40,9 +42,6 @@ struct DebugVertex2D uint color; }; -[[vk::binding(0, DEBUG)]] RWStructuredBuffer _debugVertices2D; -[[vk::binding(1, DEBUG)]] RWByteAddressBuffer _debugVertices2DCount; - // The debug vertices need to be continuous in memory, so we have to allocate them upfront DebugDrawContext2D StartDraw2D(uint numVertices) { @@ -99,9 +98,6 @@ struct DebugVertex3D uint color; }; -[[vk::binding(2, DEBUG)]] RWStructuredBuffer _debugVertices3D; -[[vk::binding(3, DEBUG)]] RWByteAddressBuffer _debugVertices3DCount; - // The debug vertices need to be continuous in memory, so we have to allocate them upfront DebugDrawContext3D StartDraw3D(uint numVertices) { diff --git a/Source/Shaders/Shaders/Include/Editor.inc.hlsl b/Source/Shaders/Shaders/Include/Editor.inc.hlsl index d9da1742..28e090aa 100644 --- a/Source/Shaders/Shaders/Include/Editor.inc.hlsl +++ b/Source/Shaders/Shaders/Include/Editor.inc.hlsl @@ -1,5 +1,6 @@ #ifndef EDITOR_INCLUDED #define EDITOR_INCLUDED + #include "Include/VisibilityBuffers.inc.hlsl" float sdCapsule(float3 p, float3 a, float3 b) diff --git a/Source/Shaders/Shaders/Include/OIT.inc.hlsl b/Source/Shaders/Shaders/Include/OIT.inc.hlsl index fb9af051..4c62f9d0 100644 --- a/Source/Shaders/Shaders/Include/OIT.inc.hlsl +++ b/Source/Shaders/Shaders/Include/OIT.inc.hlsl @@ -1,6 +1,7 @@ #ifndef OIT_INC_INCLUDED #define OIT_INC_INCLUDED -#include "common.inc.hlsl" + +#include "Include/Common.inc.hlsl" #define MODE 0 diff --git a/Source/Shaders/Shaders/Include/Shadows.inc.hlsl b/Source/Shaders/Shaders/Include/Shadows.inc.hlsl index a3295cb0..020218c1 100644 --- a/Source/Shaders/Shaders/Include/Shadows.inc.hlsl +++ b/Source/Shaders/Shaders/Include/Shadows.inc.hlsl @@ -1,13 +1,8 @@ #ifndef SHADOWS_INCLUDED #define SHADOWS_INCLUDED -#include "globalData.inc.hlsl" - -#define MAX_SHADOW_CASCADES 8 // Has to be kept in sync with the one in RenderSettings.h - -[[vk::binding(0, LIGHT)]] SamplerComparisonState _shadowCmpSampler; -[[vk::binding(1, LIGHT)]] SamplerState _shadowPointClampSampler; -[[vk::binding(2, LIGHT)]] Texture2D _shadowCascadeRTs[MAX_SHADOW_CASCADES]; +#include "DescriptorSet/Global.inc.hlsl" +#include "DescriptorSet/Light.inc.hlsl" struct ShadowSettings { diff --git a/Source/Shaders/Shaders/Include/VisibilityBuffers.inc.hlsl b/Source/Shaders/Shaders/Include/VisibilityBuffers.inc.hlsl index cfd86527..8b5cda4d 100644 --- a/Source/Shaders/Shaders/Include/VisibilityBuffers.inc.hlsl +++ b/Source/Shaders/Shaders/Include/VisibilityBuffers.inc.hlsl @@ -1,9 +1,10 @@ #ifndef VISIBILITYBUFFERS_INCLUDED #define VISIBILITYBUFFERS_INCLUDED -#include "Terrain/TerrainShared.inc.hlsl" +#include "DescriptorSet/Global.inc.hlsl" + #include "Model/ModelShared.inc.hlsl" -#include "globalData.inc.hlsl" +#include "Terrain/TerrainShared.inc.hlsl" // Choose barycentric reconstruction method method (default = plane). For ray, define RECONSTRUCT_BARY_RAY. //#define RECONSTRUCT_BARY_RAY @@ -435,7 +436,7 @@ PixelVertexData GetPixelVertexDataModel(const uint2 pixelPos, const VisibilityBu for (uint i = 0; i < 3; i++) { vertices[i] = LoadModelVertex(vertexIDs[i]); - if (instanceData.boneMatrixOffset != 4294967295) + if (instanceData.boneMatrixOffset != 4294967295) { float4x4 boneTransformMatrix = CalcBoneTransformMatrix(instanceData, vertices[i]); vertices[i].position = mul(float4(vertices[i].position, 1.0f), boneTransformMatrix).xyz; @@ -459,6 +460,8 @@ PixelVertexData GetPixelVertexDataModel(const uint2 pixelPos, const VisibilityBu result.uv1 = CalcFullBary2(bary, vertices[0].uv01.zw, vertices[1].uv01.zw, vertices[2].uv01.zw); result.color = float3(1, 1, 1); + //result.uv0.value = (vertices[0].uv01.xy + vertices[1].uv01.xy + vertices[2].uv01.xy) / 3.0f; + float3 vertexNormal = normalize(InterpolateVertexAttribute(bary, vertices[0].normal, vertices[1].normal, vertices[2].normal)); result.worldNormal = normalize(mul(vertexNormal, (float3x3)instanceMatrix)); diff --git a/Source/Shaders/Shaders/Jolt/Draw.ps.hlsl b/Source/Shaders/Shaders/Jolt/Draw.ps.hlsl index 038b5093..ffbdd6d1 100644 --- a/Source/Shaders/Shaders/Jolt/Draw.ps.hlsl +++ b/Source/Shaders/Shaders/Jolt/Draw.ps.hlsl @@ -1,4 +1,5 @@ -#include "common.inc.hlsl" + +#include "Include/Common.inc.hlsl" struct PSInput { @@ -11,6 +12,7 @@ struct PSOutput uint4 vBuffer : SV_Target0; }; +[shader("fragment")] PSOutput main(PSInput input) : SV_Target0 { float4 color = input.color; diff --git a/Source/Shaders/Shaders/Jolt/Draw.vs.hlsl b/Source/Shaders/Shaders/Jolt/Draw.vs.hlsl index 9bdd2bfa..f60cb451 100644 --- a/Source/Shaders/Shaders/Jolt/Draw.vs.hlsl +++ b/Source/Shaders/Shaders/Jolt/Draw.vs.hlsl @@ -1,4 +1,5 @@ -#include "globalData.inc.hlsl" + +#include "DescriptorSet/Global.inc.hlsl" struct PackedVertex { @@ -30,8 +31,8 @@ struct InstanceRef struct VSInput { - uint vertexID : SV_VertexID; - uint culledInstanceID : SV_InstanceID; + uint vertexID : SV_VulkanVertexID; + uint culledInstanceID : SV_VulkanInstanceID; }; struct VSOutput @@ -54,6 +55,7 @@ Vertex LoadVertex(uint vertexID) return vertex; } +[shader("vertex")] VSOutput main(VSInput input) { uint instanceRefID = _culledInstanceLookupTable[input.culledInstanceID]; diff --git a/Source/Shaders/Shaders/Light/Classification.cs.hlsl b/Source/Shaders/Shaders/Light/Classification.cs.hlsl index 8eedb506..1d530afc 100644 --- a/Source/Shaders/Shaders/Light/Classification.cs.hlsl +++ b/Source/Shaders/Shaders/Light/Classification.cs.hlsl @@ -1,13 +1,14 @@ // Based on the work of WickedEngine, thank you! https://github.com/turanszkij/WickedEngine/ // https://github.com/turanszkij/WickedEngine/blob/master/WickedEngine/shaders/lightCullingCS.hlsl -#include "common.inc.hlsl" -#include "globalData.inc.hlsl" +#include "DescriptorSet/Global.inc.hlsl" + +#include "Include/Common.inc.hlsl" #include "Include/Culling.inc.hlsl" #include "Include/Debug.inc.hlsl" #include "Light/LightShared.inc.hlsl" -#define DEBUG_TILEDLIGHTCULLING +//#define DEBUG_TILEDLIGHTCULLING #define ADVANCED_CULLING struct Constants @@ -108,6 +109,7 @@ inline AABB WorldAABB_To_DecalSpace(AABB worldBox, float3 decalCenter, float4 de return outB; } +[shader("compute")] [numthreads(TILED_CULLING_THREADSIZE, TILED_CULLING_THREADSIZE, 1)] void main(uint3 Gid : SV_GroupID, uint3 DTid : SV_DispatchThreadID, uint3 GTid : SV_GroupThreadID, uint groupIndex : SV_GroupIndex) { diff --git a/Source/Shaders/Shaders/Light/LightShared.inc.hlsl b/Source/Shaders/Shaders/Light/LightShared.inc.hlsl index 1063eb03..a9745248 100644 --- a/Source/Shaders/Shaders/Light/LightShared.inc.hlsl +++ b/Source/Shaders/Shaders/Light/LightShared.inc.hlsl @@ -1,6 +1,6 @@ #ifndef LIGHT_SHARED_INCLUDED #define LIGHT_SHARED_INCLUDED -#include "common.inc.hlsl" +#include "Include/Common.inc.hlsl" static const uint TILED_CULLING_BLOCKSIZE = 16; static const uint TILED_CULLING_THREADSIZE = 8; @@ -33,7 +33,7 @@ struct Decal uint textureID; uint flags; - bool IsTwoSided() { return (flags & DECAL_FLAG_TWOSIDED) != 0; } + bool IsTwoSided() { return (flags & DecalFlags::DECAL_FLAG_TWOSIDED) != 0; } }; float3 ApplyDecal(float3 pixelWS, float3 normalWS, Decal d, Texture2D decalTexture, SamplerState sampler) diff --git a/Source/Shaders/Shaders/Liquid/Draw.ps.hlsl b/Source/Shaders/Shaders/Liquid/Draw.ps.hlsl index 91ae7912..2a6ce1c0 100644 --- a/Source/Shaders/Shaders/Liquid/Draw.ps.hlsl +++ b/Source/Shaders/Shaders/Liquid/Draw.ps.hlsl @@ -1,5 +1,7 @@ -#include "common.inc.hlsl" -#include "globalData.inc.hlsl" + +#include "DescriptorSet/Global.inc.hlsl" + +#include "Include/Common.inc.hlsl" #include "Include/OIT.inc.hlsl" struct Constants @@ -76,6 +78,7 @@ float2 Rot2(float2 p, float degree) return mul(p, float2x2(cos(a), -sin(a), sin(a), cos(a))); } +[shader("fragment")] PSOutput main(PSInput input) { DrawCallData drawCallData = LoadDrawCallData(input.drawCallID); diff --git a/Source/Shaders/Shaders/Liquid/Draw.vs.hlsl b/Source/Shaders/Shaders/Liquid/Draw.vs.hlsl index 851f0064..398c116a 100644 --- a/Source/Shaders/Shaders/Liquid/Draw.vs.hlsl +++ b/Source/Shaders/Shaders/Liquid/Draw.vs.hlsl @@ -1,4 +1,6 @@ -#include "globalData.inc.hlsl" + +#include "DescriptorSet/Global.inc.hlsl" + #include "Terrain/TerrainShared.inc.hlsl" struct PackedDrawCallData @@ -74,8 +76,8 @@ Vertex LoadVertex(DrawCallData drawCallData, uint vertexID) struct VSInput { - uint vertexID : SV_VertexID; - uint instanceID : SV_InstanceID; + uint vertexID : SV_VulkanVertexID; + uint instanceID : SV_VulkanInstanceID; }; struct VSOutput @@ -86,6 +88,7 @@ struct VSOutput float3 posViewSpace : TEXCOORD2; }; +[shader("vertex")] VSOutput main(VSInput input) { VSOutput output; diff --git a/Source/Shaders/Shaders/MaterialPass.cs.hlsl b/Source/Shaders/Shaders/Material/MaterialPass.cs.hlsl similarity index 98% rename from Source/Shaders/Shaders/MaterialPass.cs.hlsl rename to Source/Shaders/Shaders/Material/MaterialPass.cs.hlsl index 5dae35ac..ac47c863 100644 --- a/Source/Shaders/Shaders/MaterialPass.cs.hlsl +++ b/Source/Shaders/Shaders/Material/MaterialPass.cs.hlsl @@ -3,14 +3,17 @@ permutation SHADOW_FILTER_MODE = [0, 1, 2]; // Off, PCF, PCSS permutation SUPPORTS_EXTENDED_TEXTURES = [0, 1]; permutation EDITOR_MODE = [0, 1]; // Off, Terrain -#include "common.inc.hlsl" -#include "globalData.inc.hlsl" -#include "Include/VisibilityBuffers.inc.hlsl" +#include "DescriptorSet/Global.inc.hlsl" +#include "DescriptorSet/Light.inc.hlsl" +#include "DescriptorSet/Tiles.inc.hlsl" + +#include "Include/Common.inc.hlsl" #include "Include/Editor.inc.hlsl" #include "Include/Lighting.inc.hlsl" -#include "Terrain/TerrainShared.inc.hlsl" -#include "Model/ModelShared.inc.hlsl" +#include "Include/VisibilityBuffers.inc.hlsl" #include "Light/LightShared.inc.hlsl" +#include "Model/ModelShared.inc.hlsl" +#include "Terrain/TerrainShared.inc.hlsl" struct Constants { @@ -30,12 +33,6 @@ struct Constants [[vk::push_constant]] Constants _constants; -// Tiled culling -[[vk::binding(0, TILES)]] StructuredBuffer _entityTiles; - -// Lighting -[[vk::binding(0, LIGHT)]] StructuredBuffer _packedDecals; // All decals in the world - [[vk::binding(0, PER_PASS)]] SamplerState _sampler; [[vk::binding(3, PER_PASS)]] Texture2D _skyboxColor; [[vk::binding(4, PER_PASS)]] Texture2D _transparency; @@ -240,7 +237,7 @@ float4 ShadeModel(const uint2 pixelPos, const float2 screenUV, const VisibilityB { // Get the interpolated vertex data from the visibility buffer PixelVertexData pixelVertexData = GetPixelVertexDataModel(pixelPos, vBuffer, 0, _constants.renderInfo.xy); - + TextureData textureData = LoadModelTextureData(pixelVertexData.extraID); // Shade @@ -305,6 +302,7 @@ float4 ShadeModel(const uint2 pixelPos, const float2 screenUV, const VisibilityB return saturate(color); } +[shader("compute")] [numthreads(8, 8, 1)] void main(uint3 dispatchThreadId : SV_DispatchThreadID) { diff --git a/Source/Shaders/Shaders/PreEffectsPass.cs.hlsl b/Source/Shaders/Shaders/Material/PreEffectsPass.cs.hlsl similarity index 91% rename from Source/Shaders/Shaders/PreEffectsPass.cs.hlsl rename to Source/Shaders/Shaders/Material/PreEffectsPass.cs.hlsl index a94a57b4..72a216eb 100644 --- a/Source/Shaders/Shaders/PreEffectsPass.cs.hlsl +++ b/Source/Shaders/Shaders/Material/PreEffectsPass.cs.hlsl @@ -1,6 +1,7 @@ -#include "common.inc.hlsl" -#include "globalData.inc.hlsl" +#include "DescriptorSet/Global.inc.hlsl" + +#include "Include/Common.inc.hlsl" #include "Include/VisibilityBuffers.inc.hlsl" struct Constants @@ -13,6 +14,7 @@ struct Constants [[vk::binding(0, PER_PASS)]] SamplerState _sampler; [[vk::binding(3, PER_PASS)]] RWTexture2D _packedNormals; +[shader("compute")] [numthreads(8, 8, 1)] void main(uint3 dispatchThreadId : SV_DispatchThreadID) { diff --git a/Source/Shaders/Shaders/Model/Draw.ps.hlsl b/Source/Shaders/Shaders/Model/Draw.ps.hlsl index b04a07f5..2c773e03 100644 --- a/Source/Shaders/Shaders/Model/Draw.ps.hlsl +++ b/Source/Shaders/Shaders/Model/Draw.ps.hlsl @@ -2,10 +2,11 @@ permutation SHADOW_PASS = [0, 1]; permutation SUPPORTS_EXTENDED_TEXTURES = [0, 1]; #define GEOMETRY_PASS 1 -#include "common.inc.hlsl" -#include "globalData.inc.hlsl" -#include "Model/ModelShared.inc.hlsl" +#include "DescriptorSet/Global.inc.hlsl" + +#include "Include/Common.inc.hlsl" #include "Include/VisibilityBuffers.inc.hlsl" +#include "Model/ModelShared.inc.hlsl" struct PSInput { @@ -26,6 +27,7 @@ struct PSOutput #define PSOutput void #endif +[shader("fragment")] PSOutput main(PSInput input) { uint drawCallID = input.drawIDInstanceIDTextureDataIDInstanceRefID.x; diff --git a/Source/Shaders/Shaders/Model/Draw.vs.hlsl b/Source/Shaders/Shaders/Model/Draw.vs.hlsl index 0836ebc6..e0f36169 100644 --- a/Source/Shaders/Shaders/Model/Draw.vs.hlsl +++ b/Source/Shaders/Shaders/Model/Draw.vs.hlsl @@ -3,8 +3,9 @@ permutation SHADOW_PASS = [0, 1]; permutation SUPPORTS_EXTENDED_TEXTURES = [0, 1]; #define GEOMETRY_PASS 1 -#include "common.inc.hlsl" -#include "globalData.inc.hlsl" +#include "DescriptorSet/Global.inc.hlsl" + +#include "Include/Common.inc.hlsl" #include "Model/ModelShared.inc.hlsl" struct Constants @@ -16,8 +17,8 @@ struct Constants struct VSInput { - uint vertexID : SV_VertexID; - uint culledInstanceID : SV_InstanceID; + uint vertexID : SV_VulkanVertexID; + uint culledInstanceID : SV_VulkanInstanceID; }; struct VSOutput @@ -29,6 +30,7 @@ struct VSOutput #endif }; +[shader("vertex")] VSOutput main(VSInput input) { uint instanceRefID = GetInstanceRefID(input.culledInstanceID); diff --git a/Source/Shaders/Shaders/Model/DrawSkybox.ps.hlsl b/Source/Shaders/Shaders/Model/DrawSkybox.ps.hlsl index b3f676cf..d2f46a4e 100644 --- a/Source/Shaders/Shaders/Model/DrawSkybox.ps.hlsl +++ b/Source/Shaders/Shaders/Model/DrawSkybox.ps.hlsl @@ -2,10 +2,11 @@ permutation SUPPORTS_EXTENDED_TEXTURES = [0, 1]; permutation TRANSPARENCY = [0, 1]; #define GEOMETRY_PASS 1 -#include "common.inc.hlsl" -#include "globalData.inc.hlsl" -#include "Model/ModelShared.inc.hlsl" +#include "DescriptorSet/Global.inc.hlsl" + +#include "Include/Common.inc.hlsl" #include "Include/OIT.inc.hlsl" +#include "Model/ModelShared.inc.hlsl" struct PSInput { @@ -25,6 +26,7 @@ struct PSOutput #endif }; +[shader("fragment")] PSOutput main(PSInput input) { TextureData textureData = LoadModelTextureData(input.textureDataID); diff --git a/Source/Shaders/Shaders/Model/DrawSkybox.vs.hlsl b/Source/Shaders/Shaders/Model/DrawSkybox.vs.hlsl index 9d21d706..c553de61 100644 --- a/Source/Shaders/Shaders/Model/DrawSkybox.vs.hlsl +++ b/Source/Shaders/Shaders/Model/DrawSkybox.vs.hlsl @@ -1,12 +1,14 @@ permutation SUPPORTS_EXTENDED_TEXTURES = [0, 1]; -#include "common.inc.hlsl" -#include "globalData.inc.hlsl" + +#include "DescriptorSet/Global.inc.hlsl" + +#include "Include/Common.inc.hlsl" #include "Model/ModelShared.inc.hlsl" struct VSInput { - uint vertexID : SV_VertexID; - uint instanceRefIndex : SV_InstanceID; + uint vertexID : SV_VulkanVertexID; + uint instanceRefIndex : SV_VulkanInstanceID; }; struct VSOutput @@ -18,6 +20,7 @@ struct VSOutput float3 posViewSpace : TEXCOORD2; }; +[shader("vertex")] VSOutput main(VSInput input) { InstanceRef instanceRef = GetModelInstanceID(input.instanceRefIndex); diff --git a/Source/Shaders/Shaders/Model/DrawTransparent.ps.hlsl b/Source/Shaders/Shaders/Model/DrawTransparent.ps.hlsl index c57a9540..fb30bd6f 100644 --- a/Source/Shaders/Shaders/Model/DrawTransparent.ps.hlsl +++ b/Source/Shaders/Shaders/Model/DrawTransparent.ps.hlsl @@ -1,10 +1,11 @@ permutation SUPPORTS_EXTENDED_TEXTURES = [0, 1]; #define GEOMETRY_PASS 1 -#include "common.inc.hlsl" -#include "globalData.inc.hlsl" -#include "Model/ModelShared.inc.hlsl" +#include "DescriptorSet/Global.inc.hlsl" + +#include "Include/Common.inc.hlsl" #include "Include/OIT.inc.hlsl" +#include "Model/ModelShared.inc.hlsl" struct PSInput { @@ -21,6 +22,7 @@ struct PSOutput float4 transparencyWeight : SV_Target1; }; +[shader("fragment")] PSOutput main(PSInput input) { TextureData textureData = LoadModelTextureData(input.textureDataID); diff --git a/Source/Shaders/Shaders/Model/DrawTransparent.vs.hlsl b/Source/Shaders/Shaders/Model/DrawTransparent.vs.hlsl index cd086a8b..2f39608a 100644 --- a/Source/Shaders/Shaders/Model/DrawTransparent.vs.hlsl +++ b/Source/Shaders/Shaders/Model/DrawTransparent.vs.hlsl @@ -1,12 +1,14 @@ permutation SUPPORTS_EXTENDED_TEXTURES = [0, 1]; -#include "common.inc.hlsl" -#include "globalData.inc.hlsl" + +#include "DescriptorSet/Global.inc.hlsl" + +#include "Include/Common.inc.hlsl" #include "Model/ModelShared.inc.hlsl" struct VSInput { - uint vertexID : SV_VertexID; - uint culledInstanceID : SV_InstanceID; + uint vertexID : SV_VulkanVertexID; + uint culledInstanceID : SV_VulkanInstanceID; }; struct VSOutput @@ -18,6 +20,7 @@ struct VSOutput float4 posViewSpaceAndOpacity : TEXCOORD2; }; +[shader("vertex")] VSOutput main(VSInput input) { uint instanceRefID = GetInstanceRefID(input.culledInstanceID); diff --git a/Source/Shaders/Shaders/Model/ModelShared.inc.hlsl b/Source/Shaders/Shaders/Model/ModelShared.inc.hlsl index 94ed8687..3a1f2698 100644 --- a/Source/Shaders/Shaders/Model/ModelShared.inc.hlsl +++ b/Source/Shaders/Shaders/Model/ModelShared.inc.hlsl @@ -1,8 +1,13 @@ #ifndef MODEL_SHARED_INCLUDED #define MODEL_SHARED_INCLUDED -#include "common.inc.hlsl" -#define MAX_MODEL_SAMPLERS 4 +#include "DescriptorSet/Model.inc.hlsl" + +#include "Include/Common.inc.hlsl" + +#ifndef GEOMETRY_PASS +#define GEOMETRY_PASS 0 +#endif struct ModelInstanceData { @@ -43,25 +48,21 @@ struct InstanceRef uint padding; }; -[[vk::binding(0, MODEL)]] StructuredBuffer _culledInstanceLookupTable; // One uint per instance, contains instanceRefID of what survives culling, and thus can get reordered uint GetInstanceRefID(uint culledInstanceID) { return _culledInstanceLookupTable[culledInstanceID]; } -[[vk::binding(1, MODEL)]] StructuredBuffer _instanceRefTable; InstanceRef GetModelInstanceID(uint instanceRefID) { return _instanceRefTable[instanceRefID]; } -[[vk::binding(2, MODEL)]] StructuredBuffer _modelDrawCallDatas; ModelDrawCallData LoadModelDrawCallData(uint drawCallID) { return _modelDrawCallDatas[drawCallID]; } -[[vk::binding(3, MODEL)]] StructuredBuffer _packedModelTextureDatas; TextureData LoadModelTextureData(uint textureDataID) { PackedTextureData packedTextureData = _packedModelTextureDatas[textureDataID]; @@ -153,7 +154,6 @@ float4 UnpackModelBoneWeights(PackedModelVertex packedVertex) return boneWeights; } -[[vk::binding(4, MODEL)]] StructuredBuffer _packedModelVertices; ModelVertex LoadModelVertex(uint vertexID) { PackedModelVertex packedVertex = _packedModelVertices[vertexID]; @@ -174,17 +174,11 @@ ModelVertex LoadModelVertex(uint vertexID) return vertex; } -[[vk::binding(5, MODEL)]] StructuredBuffer _modelInstanceDatas; -[[vk::binding(6, MODEL)]] StructuredBuffer _modelInstanceMatrices; -[[vk::binding(7, MODEL)]] StructuredBuffer _instanceBoneMatrices; -[[vk::binding(8, MODEL)]] StructuredBuffer _instanceTextureTransformMatrices; - struct PackedAnimatedVertexPosition { uint packed0; // half2 position.xy uint packed1; // half position.z, padding }; -[[vk::binding(9, MODEL)]] RWStructuredBuffer _animatedModelVertexPositions; void StoreAnimatedVertexPosition(uint animatedVertexID, float3 position) { @@ -218,16 +212,14 @@ float4x4 CalcBoneTransformMatrix(const ModelInstanceData instanceData, ModelVert [unroll] for (int j = 0; j < 4; j++) { - boneTransformMatrix += mul(vertex.boneWeights[j], _instanceBoneMatrices[instanceData.boneMatrixOffset + vertex.boneIndices[j]]); + //boneTransformMatrix += mul(vertex.boneWeights[j], _instanceBoneMatrices[instanceData.boneMatrixOffset + vertex.boneIndices[j]]); // Previous line, Slang did not like this + boneTransformMatrix += _instanceBoneMatrices[instanceData.boneMatrixOffset + vertex.boneIndices[j]] * vertex.boneWeights[j]; } } return boneTransformMatrix; } -[[vk::binding(10, MODEL)]] StructuredBuffer _modelDraws; -[[vk::binding(11, MODEL)]] StructuredBuffer _modelIndices; - struct ModelTextureUnit { uint data1; // (Is Projected Texture (1 bit) + Material Flag (10 bit) + Material Blending Mode (3 bit) + Unused Padding (2 bits)) + Material Type (16 bit) @@ -239,10 +231,6 @@ struct ModelTextureUnit uint padding2; }; -[[vk::binding(12, MODEL)]] StructuredBuffer _modelTextureUnits; -[[vk::binding(13, MODEL)]] SamplerState _samplers[MAX_MODEL_SAMPLERS]; -[[vk::binding(20, MODEL)]] Texture2D _modelTextures[MAX_TEXTURES]; // We give this index 20 because it always needs to be last in this descriptor set - enum ModelPixelShaderID { Opaque = 0, diff --git a/Source/Shaders/Shaders/PostProcess/FullscreenTriangle.vs.hlsl b/Source/Shaders/Shaders/PostProcess/FullscreenTriangle.vs.hlsl index e465d928..467ccfb3 100644 --- a/Source/Shaders/Shaders/PostProcess/FullscreenTriangle.vs.hlsl +++ b/Source/Shaders/Shaders/PostProcess/FullscreenTriangle.vs.hlsl @@ -1,6 +1,6 @@ struct VertexInput { - uint vertexID : SV_VertexID; + uint vertexID : SV_VulkanVertexID; }; struct VertexOutput @@ -9,6 +9,7 @@ struct VertexOutput float2 uv : TEXCOORD0; }; +[shader("vertex")] VertexOutput main(VertexInput input) { /* diff --git a/Source/Shaders/Shaders/PostProcess/SAO/Blur.cs.hlsl b/Source/Shaders/Shaders/PostProcess/SAO/Blur.cs.hlsl index c8bf5500..b842b698 100644 --- a/Source/Shaders/Shaders/PostProcess/SAO/Blur.cs.hlsl +++ b/Source/Shaders/Shaders/PostProcess/SAO/Blur.cs.hlsl @@ -74,6 +74,7 @@ float unpackKey(float2 p) return p.x * (256.0 / 257.0) + p.y * (1.0 / 257.0); } +[shader("compute")] [numthreads(32, 32, 1)] void main(uint3 dispatchThreadID : SV_DispatchThreadID) { diff --git a/Source/Shaders/Shaders/PostProcess/SAO/DownsampleDepth.cs.hlsl b/Source/Shaders/Shaders/PostProcess/SAO/DownsampleDepth.cs.hlsl index 97033844..84765220 100644 --- a/Source/Shaders/Shaders/PostProcess/SAO/DownsampleDepth.cs.hlsl +++ b/Source/Shaders/Shaders/PostProcess/SAO/DownsampleDepth.cs.hlsl @@ -20,6 +20,7 @@ [[vk::binding(0, PER_PASS)]] Texture2D _source; [[vk::binding(1, PER_PASS)]] RWTexture2D _destination; +[shader("compute")] [numthreads(32, 32, 1)] void main(uint3 dispatchThreadID : SV_DispatchThreadID) { diff --git a/Source/Shaders/Shaders/PostProcess/SAO/LinearizeDepth.cs.hlsl b/Source/Shaders/Shaders/PostProcess/SAO/LinearizeDepth.cs.hlsl index e1316426..184e2e98 100644 --- a/Source/Shaders/Shaders/PostProcess/SAO/LinearizeDepth.cs.hlsl +++ b/Source/Shaders/Shaders/PostProcess/SAO/LinearizeDepth.cs.hlsl @@ -19,6 +19,7 @@ return near * far / (far + depth * (near - far)); }*/ +[shader("compute")] [numthreads(32, 32, 1)] void main(uint3 dispatchThreadID : SV_DispatchThreadID) { diff --git a/Source/Shaders/Shaders/PostProcess/SAO/RawAO.cs.hlsl b/Source/Shaders/Shaders/PostProcess/SAO/RawAO.cs.hlsl index 5ade2bed..d7675950 100644 --- a/Source/Shaders/Shaders/PostProcess/SAO/RawAO.cs.hlsl +++ b/Source/Shaders/Shaders/PostProcess/SAO/RawAO.cs.hlsl @@ -28,7 +28,7 @@ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -#include "common.inc.hlsl" +#include "Include/Common.inc.hlsl" // Total number of direct samples to take at each pixel #define NUM_SAMPLES (11) @@ -183,6 +183,7 @@ float nrand(uint2 uv) return frac(cos(dot(uv, K1)) * 12345.6789); } +[shader("compute")] [numthreads(32, 32, 1)] void main(uint3 dispatchThreadID : SV_DispatchThreadID) { diff --git a/Source/Shaders/Shaders/Skybox/Skybox.ps.hlsl b/Source/Shaders/Shaders/Skybox/Skybox.ps.hlsl index 46a878d1..9dc0afff 100644 --- a/Source/Shaders/Shaders/Skybox/Skybox.ps.hlsl +++ b/Source/Shaders/Shaders/Skybox/Skybox.ps.hlsl @@ -1,5 +1,7 @@ -#include "globalData.inc.hlsl" -#include "common.inc.hlsl" + +#include "DescriptorSet/Global.inc.hlsl" + +#include "Include/Common.inc.hlsl" struct SkybandColors { @@ -22,6 +24,7 @@ struct PSOutput float4 color : SV_Target0; }; +[shader("fragment")] PSOutput main(VertexOutput input) : SV_Target { float3 rotation = _cameras[0].eyeRotation.xyz; diff --git a/Source/Shaders/Shaders/Sorting/SortCount.cs.hlsl b/Source/Shaders/Shaders/Sorting/SortCount.cs.hlsl index f88c571d..04b2470e 100644 --- a/Source/Shaders/Shaders/Sorting/SortCount.cs.hlsl +++ b/Source/Shaders/Shaders/Sorting/SortCount.cs.hlsl @@ -31,6 +31,7 @@ struct CountCB [[vk::binding(1, PER_PASS)]] RWStructuredBuffer _keys; // The unsorted keys or scan data [[vk::binding(2, PER_PASS)]] RWStructuredBuffer _sumTable; // The sum table we will write sums to +[shader("compute")] [numthreads(FFX_PARALLELSORT_THREADGROUP_SIZE, 1, 1)] void main(uint localID : SV_GroupThreadID, uint groupID : SV_GroupID) { diff --git a/Source/Shaders/Shaders/Sorting/SortCountReduce.cs.hlsl b/Source/Shaders/Shaders/Sorting/SortCountReduce.cs.hlsl index 74a05b49..01489a7e 100644 --- a/Source/Shaders/Shaders/Sorting/SortCountReduce.cs.hlsl +++ b/Source/Shaders/Shaders/Sorting/SortCountReduce.cs.hlsl @@ -24,6 +24,7 @@ [[vk::binding(1, PER_PASS)]] RWStructuredBuffer _sumTable; // The sum table we will write sums to [[vk::binding(2, PER_PASS)]] RWStructuredBuffer _reducedSumTable; // The reduced sum table we will write sums to +[shader("compute")] [numthreads(FFX_PARALLELSORT_THREADGROUP_SIZE, 1, 1)] void main(uint localID : SV_GroupThreadID, uint groupID : SV_GroupID) { diff --git a/Source/Shaders/Shaders/Sorting/SortScan.cs.hlsl b/Source/Shaders/Shaders/Sorting/SortScan.cs.hlsl index cf49b8fc..3da44d22 100644 --- a/Source/Shaders/Shaders/Sorting/SortScan.cs.hlsl +++ b/Source/Shaders/Shaders/Sorting/SortScan.cs.hlsl @@ -25,6 +25,7 @@ [[vk::binding(2, PER_PASS)]] RWStructuredBuffer _scanDst; // Destination for Scan Data [[vk::binding(3, PER_PASS)]] RWStructuredBuffer _scanScratch; // Scratch data for Scan +[shader("compute")] [numthreads(FFX_PARALLELSORT_THREADGROUP_SIZE, 1, 1)] void main(uint localID : SV_GroupThreadID, uint groupID : SV_GroupID) { diff --git a/Source/Shaders/Shaders/Sorting/SortScanAdd.cs.hlsl b/Source/Shaders/Shaders/Sorting/SortScanAdd.cs.hlsl index 16a12c9e..2861d1e1 100644 --- a/Source/Shaders/Shaders/Sorting/SortScanAdd.cs.hlsl +++ b/Source/Shaders/Shaders/Sorting/SortScanAdd.cs.hlsl @@ -25,6 +25,7 @@ [[vk::binding(2, PER_PASS)]] RWStructuredBuffer _scanDst; // Destination for Scan Data [[vk::binding(3, PER_PASS)]] RWStructuredBuffer _scanScratch; // Scratch data for Scan +[shader("compute")] [numthreads(FFX_PARALLELSORT_THREADGROUP_SIZE, 1, 1)] void main(uint localID : SV_GroupThreadID, uint groupID : SV_GroupID) { diff --git a/Source/Shaders/Shaders/Sorting/SortScatter.cs.hlsl b/Source/Shaders/Shaders/Sorting/SortScatter.cs.hlsl index 95deb234..5a36256c 100644 --- a/Source/Shaders/Shaders/Sorting/SortScatter.cs.hlsl +++ b/Source/Shaders/Shaders/Sorting/SortScatter.cs.hlsl @@ -34,6 +34,7 @@ struct ScatterCB [[vk::binding(5, PER_PASS)]] RWStructuredBuffer _writeKeys; // The sorted keys or prefixed data [[vk::binding(6, PER_PASS)]] RWStructuredBuffer _writeValues; // the sorted payload data +[shader("compute")] [numthreads(FFX_PARALLELSORT_THREADGROUP_SIZE, 1, 1)] void main(uint localID : SV_GroupThreadID, uint groupID : SV_GroupID) { diff --git a/Source/Shaders/Shaders/Sorting/SortSetupIndirectParameters.cs.hlsl b/Source/Shaders/Shaders/Sorting/SortSetupIndirectParameters.cs.hlsl index 2115ed3f..b4e78de0 100644 --- a/Source/Shaders/Shaders/Sorting/SortSetupIndirectParameters.cs.hlsl +++ b/Source/Shaders/Shaders/Sorting/SortSetupIndirectParameters.cs.hlsl @@ -37,6 +37,7 @@ struct NumKeys [[vk::binding(2, PER_PASS)]] RWStructuredBuffer _countScatterArgs; // Count and Scatter Args for indirect execution [[vk::binding(3, PER_PASS)]] RWStructuredBuffer _reduceScanArgs; // Reduce and Scan Args for indirect execution +[shader("compute")] [numthreads(1, 1, 1)] void main(uint localID : SV_GroupThreadID) { diff --git a/Source/Shaders/Shaders/Terrain/Culling.cs.hlsl b/Source/Shaders/Shaders/Terrain/Culling.cs.hlsl index 5620bfa0..31694a82 100644 --- a/Source/Shaders/Shaders/Terrain/Culling.cs.hlsl +++ b/Source/Shaders/Shaders/Terrain/Culling.cs.hlsl @@ -1,8 +1,10 @@ -#include "common.inc.hlsl" + +#include "DescriptorSet/Global.inc.hlsl" + +#include "Include/Common.inc.hlsl" #include "Include/Culling.inc.hlsl" -#include "Include/PyramidCulling.inc.hlsl" #include "Include/Debug.inc.hlsl" -#include "globalData.inc.hlsl" +#include "Include/PyramidCulling.inc.hlsl" #include "Terrain/TerrainShared.inc.hlsl" struct Constants @@ -45,18 +47,16 @@ bool SphereIsForwardPlane(float4 plane, float4 sphere) return (dot(plane.xyz, sphere.xyz) - plane.w) > -sphere.w; } -bool IsSphereInsideFrustum(float4 frustum[6], float4 sphere) +bool IsSphereInsideFrustum(Camera camera, float4 sphere) { - for (int i = 0; i < 6; ++i) - { - const float4 plane = frustum[i]; - - if (!SphereIsForwardPlane(plane, sphere)) - { - return false; - } - } - + // Due to a Slang compiler bug we cannot use loops with unroll here + if (!SphereIsForwardPlane(camera.frustum[0], sphere)) return false; + if (!SphereIsForwardPlane(camera.frustum[1], sphere)) return false; + if (!SphereIsForwardPlane(camera.frustum[2], sphere)) return false; + if (!SphereIsForwardPlane(camera.frustum[3], sphere)) return false; + if (!SphereIsForwardPlane(camera.frustum[4], sphere)) return false; + if (!SphereIsForwardPlane(camera.frustum[5], sphere)) return false; + return true; } @@ -91,7 +91,7 @@ void CullForCamera(DrawInput drawInput, { bool isVisible = true; - if (!IsSphereInsideFrustum(camera.frustum, drawInput.sphere)) + if (!IsSphereInsideFrustum(camera, drawInput.sphere)) { isVisible = false; } @@ -133,6 +133,7 @@ void CullForCamera(DrawInput drawInput, }*/ } +[shader("compute")] [numthreads(32, 1, 1)] void main(CSInput input) { diff --git a/Source/Shaders/Shaders/Terrain/Draw.ps.hlsl b/Source/Shaders/Shaders/Terrain/Draw.ps.hlsl index 5e695571..d42ab7a3 100644 --- a/Source/Shaders/Shaders/Terrain/Draw.ps.hlsl +++ b/Source/Shaders/Shaders/Terrain/Draw.ps.hlsl @@ -1,10 +1,11 @@ permutation SUPPORTS_EXTENDED_TEXTURES = [0, 1]; #define GEOMETRY_PASS 1 -#include "common.inc.hlsl" -#include "globalData.inc.hlsl" -#include "Terrain/TerrainShared.inc.hlsl" +#include "DescriptorSet/Global.inc.hlsl" + +#include "Include/Common.inc.hlsl" #include "Include/VisibilityBuffers.inc.hlsl" +#include "Terrain/TerrainShared.inc.hlsl" struct PSInput { @@ -17,6 +18,7 @@ struct PSOutput uint2 visibilityBuffer : SV_Target0; }; +[shader("fragment")] PSOutput main(PSInput input) { PSOutput output; diff --git a/Source/Shaders/Shaders/Terrain/Draw.vs.hlsl b/Source/Shaders/Shaders/Terrain/Draw.vs.hlsl index d95c8e10..37f3fadb 100644 --- a/Source/Shaders/Shaders/Terrain/Draw.vs.hlsl +++ b/Source/Shaders/Shaders/Terrain/Draw.vs.hlsl @@ -3,7 +3,8 @@ permutation SHADOW_PASS = [0, 1]; permutation SUPPORTS_EXTENDED_TEXTURES = [0, 1]; #define GEOMETRY_PASS 1 -#include "globalData.inc.hlsl" +#include "DescriptorSet/Global.inc.hlsl" + #include "Terrain/TerrainShared.inc.hlsl" struct Constants @@ -15,8 +16,8 @@ struct Constants struct VSInput { - uint vertexID : SV_VertexID; - uint culledInstanceID : SV_InstanceID; + uint vertexID : SV_VulkanVertexID; + uint culledInstanceID : SV_VulkanInstanceID; }; struct VSOutput @@ -27,6 +28,7 @@ struct VSOutput #endif }; +[shader("vertex")] VSOutput main(VSInput input) { InstanceData instanceData = _instanceDatas[input.culledInstanceID]; diff --git a/Source/Shaders/Shaders/Terrain/FillDrawCalls.cs.hlsl b/Source/Shaders/Shaders/Terrain/FillDrawCalls.cs.hlsl index 35fe2ce8..23338fef 100644 --- a/Source/Shaders/Shaders/Terrain/FillDrawCalls.cs.hlsl +++ b/Source/Shaders/Shaders/Terrain/FillDrawCalls.cs.hlsl @@ -1,7 +1,9 @@ -#include "common.inc.hlsl" + +#include "DescriptorSet/Global.inc.hlsl" + +#include "Include/Common.inc.hlsl" #include "Include/Culling.inc.hlsl" #include "Include/PyramidCulling.inc.hlsl" -#include "globalData.inc.hlsl" #include "Terrain/TerrainShared.inc.hlsl" struct Constants @@ -27,6 +29,7 @@ struct CSInput uint3 groupThreadID : SV_GroupThreadID; }; +[shader("compute")] [numthreads(32, 1, 1)] void main(CSInput input) { diff --git a/Source/Shaders/Shaders/Terrain/TerrainShared.inc.hlsl b/Source/Shaders/Shaders/Terrain/TerrainShared.inc.hlsl index f7990dd0..5d7812bc 100644 --- a/Source/Shaders/Shaders/Terrain/TerrainShared.inc.hlsl +++ b/Source/Shaders/Shaders/Terrain/TerrainShared.inc.hlsl @@ -1,10 +1,16 @@ #ifndef TERRAIN_SHARED_INCLUDED #define TERRAIN_SHARED_INCLUDED -#include "common.inc.hlsl" +#include "DescriptorSet/Terrain.inc.hlsl" + +#include "Include/Common.inc.hlsl" #include "Include/Culling.inc.hlsl" -#define NUM_CHUNKS_PER_MAP_SIDE (64) +#ifndef GEOMETRY_PASS +#define GEOMETRY_PASS 0 +#endif + + #define NUM_CELLS_PER_CHUNK_SIDE (16) #define NUM_CELLS_PER_CHUNK (NUM_CELLS_PER_CHUNK_SIDE * NUM_CELLS_PER_CHUNK_SIDE) @@ -150,7 +156,6 @@ bool IsHoleVertex(uint vertexId, uint2 holes) return isVertexAHole; } -[[vk::binding(0, TERRAIN)]] StructuredBuffer _packedCellData; CellData LoadCellData(uint globalCellID) { const PackedCellData rawCellData = _packedCellData[globalCellID]; @@ -222,8 +227,6 @@ struct TerrainVertex #endif }; -[[vk::binding(1, TERRAIN)]] StructuredBuffer _packedTerrainVertices; - float3 UnpackTerrainNormal(uint encoded) { uint x = encoded & 0x000000FFu; @@ -298,16 +301,4 @@ TerrainVertex LoadTerrainVertex(uint chunkID, uint cellID, uint vertexBaseOffset return vertex; } -[[vk::binding(2, TERRAIN)]] StructuredBuffer _instanceDatas; -[[vk::binding(3, TERRAIN)]] StructuredBuffer _chunkData; - -[[vk::binding(4, TERRAIN)]] SamplerState _alphaSampler; - -//[[vk::binding(5, TERRAIN)]] Texture2D _ambientOcclusion; - -//[[vk::binding(6, TERRAIN)]] RWTexture2D _resolvedColor; - -[[vk::binding(7, TERRAIN)]] Texture2D _terrainColorTextures[MAX_TEXTURES]; -[[vk::binding(8, TERRAIN)]] Texture2DArray _terrainAlphaTextures[NUM_CHUNKS_PER_MAP_SIDE * NUM_CHUNKS_PER_MAP_SIDE]; - #endif // TERRAIN_SHARED_INCLUDED \ No newline at end of file diff --git a/Source/Shaders/Shaders/UI/Panel.ps.hlsl b/Source/Shaders/Shaders/UI/Panel.ps.hlsl index e461241b..137ada8c 100644 --- a/Source/Shaders/Shaders/UI/Panel.ps.hlsl +++ b/Source/Shaders/Shaders/UI/Panel.ps.hlsl @@ -1,5 +1,5 @@ -#include "common.inc.hlsl" +#include "Include/Common.inc.hlsl" struct PanelDrawData { @@ -58,6 +58,7 @@ struct VertexOutput nointerpolation uint drawDataID : TEXCOORD1; }; +[shader("fragment")] float4 main(VertexOutput input) : SV_Target { PanelDrawData drawData = _panelDrawDatas[input.drawDataID]; diff --git a/Source/Shaders/Shaders/UI/Panel.vs.hlsl b/Source/Shaders/Shaders/UI/Panel.vs.hlsl index 4daa79bd..f0fef045 100644 --- a/Source/Shaders/Shaders/UI/Panel.vs.hlsl +++ b/Source/Shaders/Shaders/UI/Panel.vs.hlsl @@ -1,5 +1,5 @@ -#include "globalData.inc.hlsl" +#include "DescriptorSet/Global.inc.hlsl" [[vk::binding(0, PER_PASS)]] StructuredBuffer _vertices; [[vk::binding(1, PER_PASS)]] StructuredBuffer _widgetWorldPositions; @@ -17,8 +17,8 @@ struct PanelDrawData struct VertexInput { - uint vertexID : SV_VertexID; - uint drawDataID : SV_InstanceID; + uint vertexID : SV_VulkanVertexID; + uint drawDataID : SV_VulkanInstanceID; }; struct VertexOutput @@ -28,6 +28,7 @@ struct VertexOutput uint drawDataID : TEXCOORD1; }; +[shader("vertex")] VertexOutput main(VertexInput input) { float4 vertex = _vertices[input.vertexID]; diff --git a/Source/Shaders/Shaders/UI/Text.ps.hlsl b/Source/Shaders/Shaders/UI/Text.ps.hlsl index 64e3b7cd..1d114711 100644 --- a/Source/Shaders/Shaders/UI/Text.ps.hlsl +++ b/Source/Shaders/Shaders/UI/Text.ps.hlsl @@ -1,5 +1,5 @@ -#include "common.inc.hlsl" +#include "Include/Common.inc.hlsl" struct CharDrawData { @@ -38,6 +38,7 @@ bool ShouldDiscard(float2 pos, float2 clipMin, float2 clipMax) return pos.x < clipMin.x || pos.x > clipMax.x || pos.y < clipMin.y || pos.y > clipMax.y; } +[shader("fragment")] float4 main(VertexOutput input) : SV_Target { //return float4(1.0f, 0.0f, 0.0f, 0.3f); diff --git a/Source/Shaders/Shaders/UI/Text.vs.hlsl b/Source/Shaders/Shaders/UI/Text.vs.hlsl index 79096618..ccba843a 100644 --- a/Source/Shaders/Shaders/UI/Text.vs.hlsl +++ b/Source/Shaders/Shaders/UI/Text.vs.hlsl @@ -1,5 +1,5 @@ -#include "globalData.inc.hlsl" +#include "DescriptorSet/Global.inc.hlsl" [[vk::binding(0, PER_PASS)]] StructuredBuffer _vertices; [[vk::binding(1, PER_PASS)]] StructuredBuffer _widgetWorldPositions; @@ -15,8 +15,8 @@ struct CharDrawData struct VertexInput { - uint vertexID : SV_VertexID; - uint charDrawDataID : SV_InstanceID; + uint vertexID : SV_VulkanVertexID; + uint charDrawDataID : SV_VulkanInstanceID; }; struct VertexOutput @@ -26,6 +26,7 @@ struct VertexOutput uint charDrawDataID : TEXCOORD1; }; +[shader("vertex")] VertexOutput main(VertexInput input) { CharDrawData charDrawData = _charDrawDatas[input.charDrawDataID]; diff --git a/Source/Shaders/Shaders/Utils/CreateIndirectAfterCulling.cs.hlsl b/Source/Shaders/Shaders/Utils/CreateIndirectAfterCulling.cs.hlsl index b7011f77..2e0c94a0 100644 --- a/Source/Shaders/Shaders/Utils/CreateIndirectAfterCulling.cs.hlsl +++ b/Source/Shaders/Shaders/Utils/CreateIndirectAfterCulling.cs.hlsl @@ -1,11 +1,12 @@ permutation IS_INDEXED = [0, 1]; permutation DEBUG_ORDERED = [0, 1]; -#include "common.inc.hlsl" -#include "globalData.inc.hlsl" +#include "DescriptorSet/Global.inc.hlsl" + +#include "Include/Common.inc.hlsl" #include "Include/Culling.inc.hlsl" -#include "Include/PyramidCulling.inc.hlsl" #include "Include/Debug.inc.hlsl" +#include "Include/PyramidCulling.inc.hlsl" struct Constants { @@ -52,6 +53,7 @@ struct CSInput }; // One thread per drawcall +[shader("compute")] #if DEBUG_ORDERED [numthreads(1, 1, 1)] #else diff --git a/Source/Shaders/Shaders/Utils/Culling.cs.hlsl b/Source/Shaders/Shaders/Utils/Culling.cs.hlsl index a83044ab..e716e02d 100644 --- a/Source/Shaders/Shaders/Utils/Culling.cs.hlsl +++ b/Source/Shaders/Shaders/Utils/Culling.cs.hlsl @@ -1,10 +1,11 @@ permutation USE_BITMASKS = [0, 1]; -#include "common.inc.hlsl" -#include "globalData.inc.hlsl" +#include "DescriptorSet/Global.inc.hlsl" + +#include "Include/Common.inc.hlsl" #include "Include/Culling.inc.hlsl" -#include "Include/PyramidCulling.inc.hlsl" #include "Include/Debug.inc.hlsl" +#include "Include/PyramidCulling.inc.hlsl" struct Constants { @@ -94,17 +95,15 @@ bool SphereIsForwardPlane(float4 plane, float4 sphere) return (dot(plane.xyz, sphere.xyz) - plane.w) > -sphere.w; } -bool IsSphereInsideFrustum(float4 frustum[6], float4 sphere) +bool IsSphereInsideFrustum(Camera camera, float4 sphere) { - for (int i = 0; i < 6; ++i) - { - const float4 plane = frustum[i]; - - if (!SphereIsForwardPlane(plane, sphere)) - { - return false; - } - } + // Due to a Slang compiler bug we cannot use loops with unroll here + if (!SphereIsForwardPlane(camera.frustum[0], sphere)) return false; + if (!SphereIsForwardPlane(camera.frustum[1], sphere)) return false; + if (!SphereIsForwardPlane(camera.frustum[2], sphere)) return false; + if (!SphereIsForwardPlane(camera.frustum[3], sphere)) return false; + if (!SphereIsForwardPlane(camera.frustum[4], sphere)) return false; + if (!SphereIsForwardPlane(camera.frustum[5], sphere)) return false; return true; } @@ -155,7 +154,7 @@ void CullForCamera(DrawInput drawInput, ) { bool isVisible = drawInput.drawCall.instanceCount > 0; - if (!IsSphereInsideFrustum(camera.frustum, drawInput.sphere)) + if (!IsSphereInsideFrustum(camera, drawInput.sphere)) { isVisible = false; } @@ -222,6 +221,7 @@ void CullForCamera(DrawInput drawInput, } } +[shader("compute")] [numthreads(32, 1, 1)] void main(CSInput input) { diff --git a/Source/Shaders/Shaders/Utils/CullingInstanced.cs.hlsl b/Source/Shaders/Shaders/Utils/CullingInstanced.cs.hlsl index 4df9f31d..64c98c1d 100644 --- a/Source/Shaders/Shaders/Utils/CullingInstanced.cs.hlsl +++ b/Source/Shaders/Shaders/Utils/CullingInstanced.cs.hlsl @@ -1,10 +1,11 @@ permutation USE_BITMASKS = [0, 1]; -#include "common.inc.hlsl" -#include "globalData.inc.hlsl" +#include "DescriptorSet/Global.inc.hlsl" + +#include "Include/Common.inc.hlsl" #include "Include/Culling.inc.hlsl" -#include "Include/PyramidCulling.inc.hlsl" #include "Include/Debug.inc.hlsl" +#include "Include/PyramidCulling.inc.hlsl" struct Constants { @@ -108,18 +109,30 @@ bool SphereIsForwardPlane(float4 plane, float4 sphere) return (dot(plane.xyz, sphere.xyz) - plane.w) > -sphere.w; } -bool IsSphereInsideFrustum(float4 frustum[6], float4 sphere) +/*bool IsSphereInsideFrustum(Camera camera, float4 sphere) { + [unroll] for (int i = 0; i < 6; ++i) { - const float4 plane = frustum[i]; - - if (!SphereIsForwardPlane(plane, sphere)) + if (!SphereIsForwardPlane(camera.frustum[i], sphere)) { return false; } } + return true; +}*/ + +bool IsSphereInsideFrustum(Camera camera, float4 sphere) +{ + // Due to a Slang compiler bug we cannot use loops with unroll here + if (!SphereIsForwardPlane(camera.frustum[0], sphere)) return false; + if (!SphereIsForwardPlane(camera.frustum[1], sphere)) return false; + if (!SphereIsForwardPlane(camera.frustum[2], sphere)) return false; + if (!SphereIsForwardPlane(camera.frustum[3], sphere)) return false; + if (!SphereIsForwardPlane(camera.frustum[4], sphere)) return false; + if (!SphereIsForwardPlane(camera.frustum[5], sphere)) return false; + return true; } @@ -166,7 +179,7 @@ void CullForCamera(DrawInput drawInput, CullOutput cullOutput) { bool isVisible = drawInput.instanceCount > 0; - if (!IsSphereInsideFrustum(camera.frustum, drawInput.sphere)) + if (!IsSphereInsideFrustum(camera, drawInput.sphere)) { isVisible = false; } @@ -247,6 +260,7 @@ void CullForCamera(DrawInput drawInput, } } +[shader("compute")] [numthreads(32, 1, 1)] void main(CSInput input) { diff --git a/Source/Shaders/Shaders/Utils/dispatchArguments1D.cs.hlsl b/Source/Shaders/Shaders/Utils/DispatchArguments1D.cs.hlsl similarity index 96% rename from Source/Shaders/Shaders/Utils/dispatchArguments1D.cs.hlsl rename to Source/Shaders/Shaders/Utils/DispatchArguments1D.cs.hlsl index 9cbc9817..27bbc9ac 100644 --- a/Source/Shaders/Shaders/Utils/dispatchArguments1D.cs.hlsl +++ b/Source/Shaders/Shaders/Utils/DispatchArguments1D.cs.hlsl @@ -1,3 +1,4 @@ + struct Constants { uint sourceByteOffset; @@ -10,6 +11,7 @@ struct Constants [[vk::push_constant]] Constants _constants; +[shader("compute")] [numthreads(1, 1, 1)] void main() { diff --git a/Source/Shaders/Shaders/Utils/FillDrawCallsFromBitmask.cs.hlsl b/Source/Shaders/Shaders/Utils/FillDrawCallsFromBitmask.cs.hlsl index a3efd556..38c07f42 100644 --- a/Source/Shaders/Shaders/Utils/FillDrawCallsFromBitmask.cs.hlsl +++ b/Source/Shaders/Shaders/Utils/FillDrawCallsFromBitmask.cs.hlsl @@ -1,7 +1,8 @@ permutation IS_INDEXED = [0, 1]; -#include "common.inc.hlsl" -#include "globalData.inc.hlsl" +#include "DescriptorSet/Global.inc.hlsl" + +#include "Include/Common.inc.hlsl" #include "Include/Culling.inc.hlsl" #include "Include/PyramidCulling.inc.hlsl" @@ -35,8 +36,7 @@ struct CSInput uint3 groupThreadID : SV_GroupThreadID; }; -// TODO: Rewrite this for instanced rendering - +[shader("compute")] [numthreads(32, 1, 1)] void main(CSInput input) { diff --git a/Source/Shaders/Shaders/Utils/FillInstancedDrawCallsFromBitmask.cs.hlsl b/Source/Shaders/Shaders/Utils/FillInstancedDrawCallsFromBitmask.cs.hlsl index 14191f2a..50a6a58f 100644 --- a/Source/Shaders/Shaders/Utils/FillInstancedDrawCallsFromBitmask.cs.hlsl +++ b/Source/Shaders/Shaders/Utils/FillInstancedDrawCallsFromBitmask.cs.hlsl @@ -1,7 +1,8 @@ permutation IS_INDEXED = [0, 1]; -#include "common.inc.hlsl" -#include "globalData.inc.hlsl" +#include "DescriptorSet/Global.inc.hlsl" + +#include "Include/Common.inc.hlsl" #include "Include/Culling.inc.hlsl" #include "Include/PyramidCulling.inc.hlsl" @@ -49,6 +50,7 @@ uint GetBaseInstanceLookup(uint drawCallID) return baseInstanceLookup; } +[shader("compute")] [numthreads(32, 1, 1)] void main(CSInput input) { diff --git a/Source/Shaders/Shaders/Utils/ObjectQuery.cs.hlsl b/Source/Shaders/Shaders/Utils/ObjectQuery.cs.hlsl index dee3837f..2dd35836 100644 --- a/Source/Shaders/Shaders/Utils/ObjectQuery.cs.hlsl +++ b/Source/Shaders/Shaders/Utils/ObjectQuery.cs.hlsl @@ -1,7 +1,7 @@ -permutation SUPPORTS_EXTENDED_TEXTURES = [0, 1]; + #include "Include/VisibilityBuffers.inc.hlsl" -#include "Terrain/TerrainShared.inc.hlsl" #include "Model/ModelShared.inc.hlsl" +#include "Terrain/TerrainShared.inc.hlsl" struct Constants { @@ -18,6 +18,7 @@ struct ObjectData [[vk::push_constant]] Constants _constants; [[vk::binding(0, PER_PASS)]] RWStructuredBuffer _result; +[shader("compute")] [numthreads(1, 1, 1)] void main(uint3 dispatchThreadId : SV_DispatchThreadID) { diff --git a/Source/Shaders/Shaders/Utils/resetIndirectBuffer.cs.hlsl b/Source/Shaders/Shaders/Utils/ResetIndirectBuffer.cs.hlsl similarity index 96% rename from Source/Shaders/Shaders/Utils/resetIndirectBuffer.cs.hlsl rename to Source/Shaders/Shaders/Utils/ResetIndirectBuffer.cs.hlsl index 31670b75..e4d671dd 100644 --- a/Source/Shaders/Shaders/Utils/resetIndirectBuffer.cs.hlsl +++ b/Source/Shaders/Shaders/Utils/ResetIndirectBuffer.cs.hlsl @@ -1,3 +1,4 @@ + struct IndirectArguments { uint indexCount; @@ -16,6 +17,7 @@ struct Constants [[vk::binding(0, PER_PASS)]] RWStructuredBuffer _arguments; +[shader("compute")] [numthreads(1, 1, 1)] void main() { diff --git a/Source/Shaders/Shaders/globalDataDummy.vs.hlsl b/Source/Shaders/Shaders/globalDataDummy.vs.hlsl deleted file mode 100644 index 2219003b..00000000 --- a/Source/Shaders/Shaders/globalDataDummy.vs.hlsl +++ /dev/null @@ -1,20 +0,0 @@ -#include "globalData.inc.hlsl" - -// This file is a dummy shader, we don't use it for rendering but we want to load it to reflect descriptorsets from globalData.inc.hlsl - -struct VSInput -{ - -}; - -struct VSOutput -{ - float4 pos : SV_Position; -}; - -VSOutput main(VSInput input) -{ - VSOutput output; - output.pos = float4(1, 1, 1, 1); - return output; -} diff --git a/Source/Shaders/Shaders/slangdconfig.json b/Source/Shaders/Shaders/slangdconfig.json new file mode 100644 index 00000000..838fc6ac --- /dev/null +++ b/Source/Shaders/Shaders/slangdconfig.json @@ -0,0 +1,15 @@ +{ + "slang.predefinedMacros": [ + "DEBUG=0", + "GLOBAL=1", + "TILES=2", + "LIGHT=3", + "TERRAIN=4", + "MODEL=5", + "PER_PASS=6", + "PER_DRAW=7" + ], + "slang.additionalSearchPaths": [ + "/" + ] +} \ No newline at end of file diff --git a/Source/Shaders/Shaders/solidColor.ps.hlsl b/Source/Shaders/Shaders/solidColor.ps.hlsl deleted file mode 100644 index 3987e6dc..00000000 --- a/Source/Shaders/Shaders/solidColor.ps.hlsl +++ /dev/null @@ -1,10 +0,0 @@ -struct Color -{ - float4 value; -}; -[[vk::push_constant]] Color _color; - -float4 main() : SV_Target -{ - return _color.value; -} \ No newline at end of file diff --git a/Source/Shaders/Shaders/test.ps.hlsl b/Source/Shaders/Shaders/test.ps.hlsl deleted file mode 100644 index e9df33f1..00000000 --- a/Source/Shaders/Shaders/test.ps.hlsl +++ /dev/null @@ -1,15 +0,0 @@ - -[[vk::binding(0, PER_PASS)]] SamplerState _sampler; - -[[vk::binding(1, PER_DRAW)]] Texture2D _texture; - -struct VertexOutput -{ - float4 position : SV_POSITION; - float2 uv : TEXCOORD0; -}; - -float4 main(VertexOutput input) : SV_Target -{ - return _texture.Sample(_sampler, input.uv); -} \ No newline at end of file diff --git a/Source/Shaders/Shaders/test.vs.hlsl b/Source/Shaders/Shaders/test.vs.hlsl deleted file mode 100644 index 6b517fac..00000000 --- a/Source/Shaders/Shaders/test.vs.hlsl +++ /dev/null @@ -1,30 +0,0 @@ -#include "globalData.inc.hlsl" - -struct ModelData -{ - float4 colorMultiplier; - float4x4 modelMatrix; -}; - -[[vk::binding(0, PER_DRAW)]] ConstantBuffer _modelData; - -struct VertexInput -{ - float4 position : POSITION; - float3 normal : TEXCOORD0; - float2 uv : TEXCOORD1; -}; - -struct VertexOutput -{ - float4 position : SV_POSITION; - float2 uv : TEXCOORD0; -}; - -VertexOutput main(VertexInput input) -{ - VertexOutput output; - output.position = mul(_cameras[0].worldToClip, mul(_modelData.modelMatrix, input.position)); - output.uv = input.uv; - return output; -} \ No newline at end of file diff --git a/Submodules/Engine b/Submodules/Engine index 0ebcdcb2..db1cf18e 160000 --- a/Submodules/Engine +++ b/Submodules/Engine @@ -1 +1 @@ -Subproject commit 0ebcdcb24068a8c2d6904ea8f756973eb661b42e +Subproject commit db1cf18ee337cb5f7e09cf668626a204fec4bb73