diff --git a/.github/workflows/build-nightly.yml b/.github/workflows/build-nightly.yml index c4ddcd18c..01661b827 100644 --- a/.github/workflows/build-nightly.yml +++ b/.github/workflows/build-nightly.yml @@ -18,7 +18,7 @@ jobs: run: | "C:/Program Files (x86)/Microsoft Visual Studio/2019/Enterprise/MSBuild/Current/Bin/MSBuild.exe" WickedEngine.sln /t:OfflineShaderCompiler /m /p:Configuration=Release /p:Platform=x64 cd "WickedEngine" - "../BUILD/x64/Release/OfflineShaderCompiler/OfflineShaderCompiler.exe" hlsl5 hlsl6 spirv shaderdump + "../BUILD/x64/Release/OfflineShaderCompiler/OfflineShaderCompiler.exe" hlsl6 spirv shaderdump cd .. "C:/Program Files (x86)/Microsoft Visual Studio/2019/Enterprise/MSBuild/Current/Bin/MSBuild.exe" WickedEngine.sln /t:rebuild /m /p:Configuration=Release /p:Platform=x64 diff --git a/.github/workflows/build-pr.yml b/.github/workflows/build-pr.yml index 16321ecf0..351dca698 100644 --- a/.github/workflows/build-pr.yml +++ b/.github/workflows/build-pr.yml @@ -17,7 +17,7 @@ jobs: run: | "C:/Program Files (x86)/Microsoft Visual Studio/2019/Enterprise/MSBuild/Current/Bin/MSBuild.exe" WickedEngine.sln /t:OfflineShaderCompiler /m /p:Configuration=Release /p:Platform=x64 cd "WickedEngine" - "../BUILD/x64/Release/OfflineShaderCompiler/OfflineShaderCompiler.exe" hlsl5 hlsl6 spirv shaderdump + "../BUILD/x64/Release/OfflineShaderCompiler/OfflineShaderCompiler.exe" hlsl6 spirv shaderdump cd .. "C:/Program Files (x86)/Microsoft Visual Studio/2019/Enterprise/MSBuild/Current/Bin/MSBuild.exe" WickedEngine.sln /t:rebuild /m /p:Configuration=Release /p:Platform=x64 diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index daa6516a4..9cb4b69ed 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -18,7 +18,7 @@ jobs: run: | "C:/Program Files (x86)/Microsoft Visual Studio/2019/Enterprise/MSBuild/Current/Bin/MSBuild.exe" WickedEngine.sln /t:OfflineShaderCompiler /m /p:Configuration=Release /p:Platform=x64 cd "WickedEngine" - "../BUILD/x64/Release/OfflineShaderCompiler/OfflineShaderCompiler.exe" hlsl5 hlsl6 spirv shaderdump + "../BUILD/x64/Release/OfflineShaderCompiler/OfflineShaderCompiler.exe" hlsl6 spirv shaderdump cd .. "C:/Program Files (x86)/Microsoft Visual Studio/2019/Enterprise/MSBuild/Current/Bin/MSBuild.exe" WickedEngine.sln /t:rebuild /m /p:Configuration=Release /p:Platform=x64 diff --git a/Content/Documentation/WickedEngine-Documentation.md b/Content/Documentation/WickedEngine-Documentation.md index 6298799bc..8b1d8dabc 100644 --- a/Content/Documentation/WickedEngine-Documentation.md +++ b/Content/Documentation/WickedEngine-Documentation.md @@ -480,7 +480,7 @@ device->SubmitCommandLists(); // execute all of the above The `WaitCommandList()` function is a GPU wait operation, so it will not block CPU execution. Furthermore, it is not required to use this between two `CommandList`s that are on the same queue, because the synchronization between those is implicit. -Important: The `IMAGE_LAYOUT_SHADER_RESOURCE` and `BUFFER_STATE_SHADER_RESOURCE` states cannot be used on the compute queue. The device could convert these to `IMAGE_LAYOUT_SHADER_RESOURCE_COMPUTE` and `BUFFER_STATE_SHADER_RESOURCE_COMPUTE` respectively while issuing `Barrier()` commands. However, the starting resource state must be correctly specified, because those cannot be converted. Consider always choosing a `_SHADER_RESOURCE_COMPUTE` starting resource state if the resource is goig to be used in a compute queue, and transition them to regular `SHADER_RESOURCE` only before the resource is going to be used in a pixel shader. The graphics queue with compute commands doesn't have this limitation however. +Important: The `RESOURCE_STATE_SHADER_RESOURCE` state cannot be used on the compute queue. The device could convert these to `RESOURCE_STATE_SHADER_RESOURCE_COMPUTE` while issuing `Barrier()` commands. However, the starting resource state must be correctly specified, because those cannot be converted. Consider always choosing a `_SHADER_RESOURCE_COMPUTE` starting resource state if the resource is goig to be used in a compute queue, and transition them to regular `SHADER_RESOURCE` only before the resource is going to be used in a pixel shader. The graphics queue with compute commands doesn't have this limitation however. ##### Presenting to the screen To present to the screen (an operating system window), first create a SwapChain with the `CreateSwapChain()` function that will be associated with a window. The SwapChain acts as a special kind of [RenderPass](#render-passes), so there is a `BeginRenderPass()` function with an overload that accepts a SwapChain parameter instead of a RenderPass. Simply use this `BeginRenderPass()` and `EndRenderPass()` to draw to the SwapChain. The final presentation will happen when calling `SubmitCommandLists()`. @@ -505,14 +505,14 @@ After this, the user can bind the texture resource from the CPU side: ```cpp Texture myTexture; // after texture was created, etc: -device->BindResource(PS, myTexture, my_texture_bind_slot, cmd); +device->BindResource(myTexture, my_texture_bind_slot, cmd); ``` Other than this, resources like `Texture` can have different subresources, so an extra parameter can be specified to the `BindResources()` function called `subresource`: ```cpp Texture myTexture; // after texture was created, etc: -device->BindResource(PS, myTexture, my_texture_bind_slot, cmd, 42); +device->BindResource(myTexture, my_texture_bind_slot, cmd, 42); ``` By default, the `subresource` parameter is `-1`, which means that the entire resource will be bound. For more information about subresources, see the [Subresources](#subresources) section. @@ -536,7 +536,7 @@ Remarks: ##### Bindless resources -Some graphics API supports bindless resource management, this can greatly improve performance and removes resource binding constraints to allow great flexibility. This can be queried by `GraphicsDevice::CheckCapability()` and providing the `GRAPHICSDEVICE_CAPABILITY_BINDLESS_DESCRIPTORS` flag. If the device supports this feature, the function will return true. +Wicked Engine supports bindless resource management, this can greatly improve performance and removes resource binding constraints to allow great flexibility. Related functions to this feature: - `GetDescriptorIndex()` : returns an `int` that identifies the resource in bindless space. The queried resource can be a `Sampler` or a `GPUResource`. If the resource is not usable (for example if it was not created), then the function returns `-1`. **In this case, the shaders must not use the resource, but instead rely on dynamic branching to avoid it, because this would be undefined behaviour and could result in a GPU hang**. Otherwise, the index can be used by shaders to index into a descriptor heap. @@ -565,7 +565,7 @@ struct PushConstants int textureindex; }; PushConstants push; -push.materialIndex = device->GetDescriptorIndex(materialCB, CBV); +push.materialIndex = device->GetDescriptorIndex(materialCB, SRV); push.textureindex = device->GetDescriptorIndex(texture, SRV); device->PushConstants(&push, sizeof(push), cmd); ``` @@ -620,13 +620,13 @@ Defines how the texture contents are initialized at the start of the render pass - Store operation:
Defines how the texture contents are handled after the render pass ends. `STOREOP_STORE` means that the contents will be preserved. `STOREOP_DONTCARE` means that the contents won't be necessarily preserved, they are only temporarily valid within the duration of the render pass, which can save some memory bandwidth on some platforms (specifically tile based rendering architectures, like mobile GPUs). - Layout transition:
-Define the `intial_layout`, `subpass_layout` (only for `RENDERTARGET` or `DEPTH_STENCIL`) and `final_layout` members to have an implicit transition performed as part of the render pass, that works like an [IMAGE_BARRIER](#gpu-barriers), but can be more optimal. The `initial_layout` states the starting state of the resource. The resource will be transitioned from `initial_layout` to `subpass_layout` within the render pass. The `subpass_layout` states how the resource is accessed within the render pass. For `RENDERTARGET`, this must be `IMAGE_LAYOUT_RENDERTARGET`, for `DEPTH_STENCIL` type, it must be either `IMAGE_LAYOUT_DEPTHSTENCIL` or `IMAGE_LAYOUT_DEPTHSTENCIL_READONLY`. For `RESOLVE` type, the subpass_layout have no meaning, it is implicitly defined. At the end of the render pass, the resources will be transitioned from `subpass_layout` to `final_layout`. +Define the `intial_layout`, `subpass_layout` (only for `RENDERTARGET` or `DEPTH_STENCIL`) and `final_layout` members to have an implicit transition performed as part of the render pass, that works like an [IMAGE_BARRIER](#gpu-barriers), but can be more optimal. The `initial_layout` states the starting state of the resource. The resource will be transitioned from `initial_layout` to `subpass_layout` within the render pass. The `subpass_layout` states how the resource is accessed within the render pass. For `RENDERTARGET`, this must be `RESOURCE_STATE_RENDERTARGET`, for `DEPTH_STENCIL` type, it must be either `RESOURCE_STATE_DEPTHSTENCIL` or `RESOURCE_STATE_DEPTHSTENCIL_READONLY`. For `RESOLVE` type, the subpass_layout have no meaning, it is implicitly defined. At the end of the render pass, the resources will be transitioned from `subpass_layout` to `final_layout`. Notes: - When `RenderPassBegin()` is called, `RenderPassEnd()` must be called after on the same command list before the command list gets [submitted](#work-submission). - It is not allowed to call `CopyResource()`, `CopyTexture2D()`, etc. inside a render pass. - It is not allowed to call `Dispatch()` and `DispatchIndirect()` inside a render pass. -- It is not allowed to call `UpdateBuffer()` inside the render pass unless the buffer is `USAGE_DYNAMIC` and is a `BIND_CONSTANT_BUFFER`. +- It is not allowed to call `UpdateBuffer()` inside the render pass. ##### GPU Barriers `GPUBarrier`s can be used to state dependencies between GPU workloads. There are different kinds of barriers: @@ -634,7 +634,7 @@ Notes: - MEMORY_BARRIER
Memory barriers are used to wait for UAV writes to finish, or in other words to wait for shaders to finish that are writing to a BIND_UNORDERED_ACCESS resource. The `GPUBarrier::memory.resource` member is a pointer to the GPUResource to wait on. If it is nullptr, than the barrier means "wait for every UAV write that is in flight to finish". - IMAGE_BARRIER
-Image barriers are stating resource state transition for [textures](#textures). The most common use case for example is to transition from `IMAGE_LAYOUT_RENDERTARGET` to `IMAGE_LAYOUT_SHADER_RESOURCE`, which means that the [RenderPass](#render-passes) that writes to the texture as render target must finish before the barrier, and the texture can be used as a read only shader resource after the barrier. There are other cases that can be indicated using the `GPUBarrier::image.layout_before` and `GPUBarrier::image.layout_after` states. The `GPUBarrier::image.resource` is a pointer to the resource which will have its state changed. If the texture's `layout` (as part of the TextureDesc) is not `IMAGE_LAYOUT_SHADER_RESOURCE`, the layout must be transitioned to `IMAGE_LAYOUT_SHADER_RESOURCE` before binding as shader resource. The image layout can also be transitioned using a [RenderPass](#render-passes), which should be preferred to `GPUBarrier`s. +Image barriers are stating resource state transition for [textures](#textures). The most common use case for example is to transition from `RESOURCE_STATE_RENDERTARGET` to `RESOURCE_STATE_SHADER_RESOURCE`, which means that the [RenderPass](#render-passes) that writes to the texture as render target must finish before the barrier, and the texture can be used as a read only shader resource after the barrier. There are other cases that can be indicated using the `GPUBarrier::image.layout_before` and `GPUBarrier::image.layout_after` states. The `GPUBarrier::image.resource` is a pointer to the resource which will have its state changed. If the texture's `layout` (as part of the TextureDesc) is not `RESOURCE_STATE_SHADER_RESOURCE`, the layout must be transitioned to `RESOURCE_STATE_SHADER_RESOURCE` before binding as shader resource. The image layout can also be transitioned using a [RenderPass](#render-passes), which should be preferred to `GPUBarrier`s. - BUFFER_BARRIER
Similar to `IMAGE_BARRIER`, but for [GPU Buffer](#gpu-buffers) state transitions. @@ -663,11 +663,10 @@ Related topics: [Creating Resources](#creating-resources), [Destroying Resources Related topics: [Creating Resources](#creating-resources), [Destroying Resources](#destroying-resources), [Binding resources](#resource-binding), [Subresources](#subresources), [Updating GPU Buffers](#updating-gpu-buffers) ##### Updating GPU buffers -A common scenario is updating buffers, when the developer wants to make data visible from the CPU to the GPU. The simplest way is to use the `GraphicsDevice::UpdateBuffer()` function. To use this successfully, the buffer must have been created with a `Usage` that is either `USAGE_DEFAULT` or `USAGE_DYNAMIC`. The `USAGE_IMMUTABLE` buffers cannot be updated after having been created. If the `USAGE_DEFAULT` is in effect, the buffer updating can be heavier on the CPU, and introduce additional [GPUBarriers](#gpu-barriers), but they can have superior GPU read performance, or can be writable by the GPU. On the other hand, `USAGE_DYNAMIC` type buffers will be lighter weight on the CPU side, but they could have worse GPU performance. If `USAGE_DYNAMIC` was specified, the buffer must also have been created with `CPUAccessFlags` member of the `GPUBufferDesc` that contains the value `CPU_ACCESS_WRITE` in order to be successfully updated. - -`GraphicsDevice::UpdateBuffer()` function can either take the dataSize parameter, or if it is left as default, the `GPUBufferDesc::ByteWidth` (that was specified at buffer creation time) number of bytes will be read from the `data` parameter and uploaded to the buffer. - -An other case is to dynamically allocate a temporary buffer using the `GraphicsDevice::AllocateGPU()` function. The developer has to specify the amount of space that needs to be allocated, and the function will return a `GPUAllocation` struct that has a `buffer` member that can be used for [resource binding](#resource-binding), a `data` pointer member that the application can write into, and an offset value, that indicates an offset that the new data will start from in the temporary buffer. Buffers that were allocated like this can be only used as index buffers, vertex buffers, instance buffers, or raw buffers. Attempting to use these as constant buffers, structured buffers, or typed buffers is not supported. +A `GPUBuffer`'s `Usage` parameter specifies how the buffer memory is accessed. +- `USAGE_DEFAULT`: The buffer memory is visible to the GPU but not the CPU. This means that it will observe maximum GPU performance, but special care needs to be taken to write the buffer contents. The GPU could write the memory from a shader or copy operation for example. You can also use the `UpdateBuffer()` function to update such a buffer from CPU (which uses a GPU copy). +- `USAGE_UPLOAD`: The buffer can be written by the CPU and read by the GPU. Once such a `GPUBuffer` was created, it's memory is persistently mapped for CPU access, and can be accessed through the `GPUResource::mapped_data` pointer. It's perfect to update a `USAGE_DEFAULT` buffer from this by first filling the `USAGE_UPLOAD` buffer from the CPU, then let the GPU copy its contents to the `USAGE_DEFAULT` buffer with a shader or copy operation. +- `USAGE_READBACK`: The buffer can be written by the GPU and the contents read by the CPU. The buffer memory is persistently mapped after creation, and accessible through the `GPUResource::mapped_data` pointer. ##### GPU Queries The `GPUQueryHeap` can be used to retrieve information from GPU to CPU. There are different query types: @@ -687,7 +686,7 @@ Binding a ray tracing pipeline state is required to dispatch ray tracing shaders Variable Rate Shading can be used to decrease shading quality while retaining depth testing accuracy. The shading rate can be set up in different ways: - `BindShadingRate()`: Set the shading rate for the following draw calls. The first parameter is the shading rate, which is by default `SHADING_RATE_1X1` (the best quality). The increasing enum values are standing for decreasing shading rates. -- Shading rate image: Set the shading rate for the screen via a tiled texture. The texture must be set as a RenderPassAttachment of `SHADING_RATE_SOURCE` type. The texture must be using the `FORMAT_R8_UINT` format. In each pixel, the texture contains the shading rate value for a tile of pixels (8x8, 16x16 or 32x32). The tile size can be queried via `GetVariableRateShadingTileSize()`. The shading rate values that the texture contains are not the raw values from `SHADING_RATE` enum, but they must be converted to values that are native to the graphics API used using the `WriteShadingRateValue()` function. The shading rate texture must be written with a compute shader and transitioned to `IMAGE_LAYOUT_SHADING_RATE_SOURCE` with a [GPUBarrier](#gpu-barriers) before setting it with `BindShadingRateImage()`. It is valid to set a `nullptr` instead of the texture, indicating that the shading rate is not specified by a texture. +- Shading rate image: Set the shading rate for the screen via a tiled texture. The texture must be set as a RenderPassAttachment of `SHADING_RATE_SOURCE` type. The texture must be using the `FORMAT_R8_UINT` format. In each pixel, the texture contains the shading rate value for a tile of pixels (8x8, 16x16 or 32x32). The tile size can be queried via `GetVariableRateShadingTileSize()`. The shading rate values that the texture contains are not the raw values from `SHADING_RATE` enum, but they must be converted to values that are native to the graphics API used using the `WriteShadingRateValue()` function. The shading rate texture must be written with a compute shader and transitioned to `RESOURCE_STATE_SHADING_RATE_SOURCE` with a [GPUBarrier](#gpu-barriers) before setting it with `BindShadingRateImage()`. It is valid to set a `nullptr` instead of the texture, indicating that the shading rate is not specified by a texture. - Or setting the shading rate from a vertex or geometry shader with the `SV_ShadingRate` system value semantic. The final shading rate will be determined from the above methods using the maximum shading rate (least detailed) which is applicable to the screen tile. In the future it might be considered to expose the operator to define this. @@ -696,8 +695,7 @@ To read more about variable rate shading, refer to the [DirectX specifications.] #### GraphicsDevice_DX11 -[[Header]](../../WickedEngine/wiGraphicsDevice_DX11.h) [[Cpp]](../../WickedEngine/wiGraphicsDevice_DX11.cpp) -DirectX11 implementation for rendering interface +The DirectX11 interface has been removed after version 0.56 #### GraphicsDevice_DX12 [[Header]](../../WickedEngine/wiGraphicsDevice_DX12.h) [[Cpp]](../../WickedEngine/wiGraphicsDevice_DX12.cpp) @@ -844,7 +842,7 @@ enum CBTYPE }; GPUBuffer buffers[CBTYPE_COUNT]; // this example array contains 3 elements //... -device->BindConstantBuffer(PS, &buffers[CBTYPE_MESH], 0, cmd); // makes it easy to reference an element +device->BindConstantBuffer(&buffers[CBTYPE_MESH], 0, cmd); // makes it easy to reference an element ``` This is widely used to make code straight forward and easy to add new objects, without needing to create additional declarations, except for the enum values. @@ -1544,8 +1542,6 @@ Shader Interop is used for declaring shared structures or values between C++ Eng [ShaderInterop_Raytracing.h](../WickedEngine/ShaderInterop_Raytracing.h)
[ShaderInterop_Renderer.h](../WickedEngine/ShaderInterop_Renderer.h)
[ShaderInterop_Skinning.h](../WickedEngine/ShaderInterop_Skinning.h)
-[ShaderInterop_Utility.h](../WickedEngine/ShaderInterop_Utility.h)
-[ShaderInterop_Vulkan.h](../WickedEngine/ShaderInterop_Vulkan.h)
The ShaderInterop also contains the resource macros to help share code between C++ and HLSL, and portability between shader compilers. Read more about macros in the [Shaders section](#shaders) ### Shader Compiler diff --git a/Content/models/hairparticle_torus.wiscene b/Content/models/hairparticle_torus.wiscene index 2f55f67af..2ede667ed 100644 Binary files a/Content/models/hairparticle_torus.wiscene and b/Content/models/hairparticle_torus.wiscene differ diff --git a/Content/models/playground.wiscene b/Content/models/playground.wiscene index 1c328233a..d7eab42e2 100644 Binary files a/Content/models/playground.wiscene and b/Content/models/playground.wiscene differ diff --git a/Editor/Editor.cpp b/Editor/Editor.cpp index 5a3ddce8e..a8666ee43 100644 --- a/Editor/Editor.cpp +++ b/Editor/Editor.cpp @@ -238,9 +238,9 @@ void EditorComponent::ResizeBuffers() renderPath->GetDepthStencil(), RenderPassAttachment::LOADOP_LOAD, RenderPassAttachment::STOREOP_STORE, - IMAGE_LAYOUT_DEPTHSTENCIL_READONLY, - IMAGE_LAYOUT_DEPTHSTENCIL_READONLY, - IMAGE_LAYOUT_DEPTHSTENCIL_READONLY + RESOURCE_STATE_DEPTHSTENCIL_READONLY, + RESOURCE_STATE_DEPTHSTENCIL_READONLY, + RESOURCE_STATE_DEPTHSTENCIL_READONLY ) ); hr = device->CreateRenderPass(&desc, &renderpass_selectionOutline[0]); @@ -771,8 +771,8 @@ void EditorComponent::Load() { wiScene::GetCamera() = *cam; // camera aspect should be always for the current screen - wiScene::GetCamera().width = renderPath->GetInternalResolution().x; - wiScene::GetCamera().height = renderPath->GetInternalResolution().y; + wiScene::GetCamera().width = (float)renderPath->GetInternalResolution().x; + wiScene::GetCamera().height = (float)renderPath->GetInternalResolution().y; } } } @@ -1947,7 +1947,6 @@ void EditorComponent::Render() const // Objects outline: { - device->UnbindResources(TEXSLOT_ONDEMAND0, 1, cmd); device->RenderPassBegin(&renderpass_selectionOutline[1], cmd); // Draw solid blocks of selected objects diff --git a/Editor/Editor_SOURCE.vcxitems b/Editor/Editor_SOURCE.vcxitems index 341406eaa..cf9f74db1 100644 --- a/Editor/Editor_SOURCE.vcxitems +++ b/Editor/Editor_SOURCE.vcxitems @@ -153,11 +153,6 @@ - - true - true - Document - true true diff --git a/Editor/Editor_SOURCE.vcxitems.filters b/Editor/Editor_SOURCE.vcxitems.filters index bc4de9f67..00dc20113 100644 --- a/Editor/Editor_SOURCE.vcxitems.filters +++ b/Editor/Editor_SOURCE.vcxitems.filters @@ -167,7 +167,6 @@ - diff --git a/Editor/PaintToolWindow.cpp b/Editor/PaintToolWindow.cpp index c4f110631..f2cfbe094 100644 --- a/Editor/PaintToolWindow.cpp +++ b/Editor/PaintToolWindow.cpp @@ -1,7 +1,7 @@ #include "stdafx.h" #include "Editor.h" #include "PaintToolWindow.h" -#include "shaders/ShaderInterop_Paint.h" +#include "shaders/ShaderInterop_Renderer.h" #include #include @@ -305,22 +305,11 @@ void PaintToolWindow::Update(float dt) // Need to requery this because RecordHistory might swap textures on material: editTexture = GetEditTextureSlot(*material, &uvset); - static GPUBuffer cbuf; - if (!cbuf.IsValid()) - { - GPUBufferDesc desc; - desc.BindFlags = BIND_CONSTANT_BUFFER; - desc.Usage = USAGE_DYNAMIC; - desc.CPUAccessFlags = CPU_ACCESS_WRITE; - desc.ByteWidth = sizeof(PaintTextureCB); - device->CreateBuffer(&desc, nullptr, &cbuf); - } - device->BindComputeShader(wiRenderer::GetShader(CSTYPE_PAINT_TEXTURE), cmd); wiRenderer::BindCommonResources(cmd); - device->BindResource(CS, wiTextureHelper::getWhite(), TEXSLOT_ONDEMAND0, cmd); - device->BindUAV(CS, &editTexture, 0, cmd); + device->BindResource(wiTextureHelper::getWhite(), TEXSLOT_ONDEMAND0, cmd); + device->BindUAV(&editTexture, 0, cmd); PaintTextureCB cb; cb.xPaintBrushCenter = center; @@ -328,8 +317,7 @@ void PaintToolWindow::Update(float dt) cb.xPaintBrushAmount = amount; cb.xPaintBrushFalloff = falloff; cb.xPaintBrushColor = color.rgba; - device->UpdateBuffer(&cbuf, &cb, cmd); - device->BindConstantBuffer(CS, &cbuf, CB_GETBINDSLOT(PaintTextureCB), cmd); + device->PushConstants(&cb, sizeof(cb), cmd); const uint diameter = cb.xPaintBrushRadius * 2; const uint dispatch_dim = (diameter + PAINT_TEXTURE_BLOCKSIZE - 1) / PAINT_TEXTURE_BLOCKSIZE; @@ -340,7 +328,6 @@ void PaintToolWindow::Update(float dt) }; device->Barrier(barriers, arraysize(barriers), cmd); - device->UnbindUAVs(0, 1, cmd); wiRenderer::GenerateMipChain(editTexture, wiRenderer::MIPGENFILTER::MIPGENFILTER_LINEAR, cmd); } diff --git a/Editor/PostprocessWindow.cpp b/Editor/PostprocessWindow.cpp index bb1e728fc..9abc14ef6 100644 --- a/Editor/PostprocessWindow.cpp +++ b/Editor/PostprocessWindow.cpp @@ -59,7 +59,7 @@ void PostprocessWindow::Create(EditorComponent* editor) aoComboBox.AddItem("SSAO"); aoComboBox.AddItem("HBAO"); aoComboBox.AddItem("MSAO"); - if (wiRenderer::GetDevice()->CheckCapability(GRAPHICSDEVICE_CAPABILITY_RAYTRACING_INLINE)) + if (wiRenderer::GetDevice()->CheckCapability(GRAPHICSDEVICE_CAPABILITY_RAYTRACING)) { aoComboBox.AddItem("RTAO"); } @@ -142,7 +142,7 @@ void PostprocessWindow::Create(EditorComponent* editor) editor->renderPath->setRaytracedReflectionsEnabled(args.bValue); }); AddWidget(&raytracedReflectionsCheckBox); - raytracedReflectionsCheckBox.SetEnabled(wiRenderer::GetDevice()->CheckCapability(GRAPHICSDEVICE_CAPABILITY_RAYTRACING_PIPELINE) && wiRenderer::GetDevice()->CheckCapability(GRAPHICSDEVICE_CAPABILITY_RAYTRACING_GEOMETRYINDEX)); + raytracedReflectionsCheckBox.SetEnabled(wiRenderer::GetDevice()->CheckCapability(GRAPHICSDEVICE_CAPABILITY_RAYTRACING)); screenSpaceShadowsCheckBox.Create("SS Shadows: "); screenSpaceShadowsCheckBox.SetTooltip("Enable screen space contact shadows. This can add small shadows details to shadow maps in screen space."); diff --git a/Editor/RendererWindow.cpp b/Editor/RendererWindow.cpp index 69f8f7efc..0044729c4 100644 --- a/Editor/RendererWindow.cpp +++ b/Editor/RendererWindow.cpp @@ -64,6 +64,26 @@ void RendererWindow::Create(EditorComponent* editor) }); AddWidget(&gammaSlider); + surfelGICheckBox.Create("Surfel GI: "); + surfelGICheckBox.SetTooltip("Surfel GI is a raytraced diffuse GI using raytracing and surface cache."); + surfelGICheckBox.SetPos(XMFLOAT2(x, y += step)); + surfelGICheckBox.SetSize(XMFLOAT2(itemheight, itemheight)); + surfelGICheckBox.OnClick([](wiEventArgs args) { + wiRenderer::SetSurfelGIEnabled(args.bValue); + }); + surfelGICheckBox.SetCheck(wiRenderer::GetSurfelGIEnabled()); + AddWidget(&surfelGICheckBox); + + surfelGIDebugCheckBox.Create("DEBUG: "); + surfelGIDebugCheckBox.SetTooltip("Toggle Surfel GI visualization."); + surfelGIDebugCheckBox.SetPos(XMFLOAT2(x + 122, y)); + surfelGIDebugCheckBox.SetSize(XMFLOAT2(itemheight, itemheight)); + surfelGIDebugCheckBox.OnClick([](wiEventArgs args) { + wiRenderer::SetSurfelGIDebugEnabled(args.bValue); + }); + surfelGIDebugCheckBox.SetCheck(wiRenderer::GetSurfelGIDebugEnabled()); + AddWidget(&surfelGIDebugCheckBox); + voxelRadianceCheckBox.Create("Voxel GI: "); voxelRadianceCheckBox.SetTooltip("Toggle voxel Global Illumination computation."); voxelRadianceCheckBox.SetPos(XMFLOAT2(x, y += step)); @@ -231,7 +251,7 @@ void RendererWindow::Create(EditorComponent* editor) shadowTypeComboBox.SetSize(XMFLOAT2(100, itemheight)); shadowTypeComboBox.SetPos(XMFLOAT2(x, y += step)); shadowTypeComboBox.AddItem("Shadowmaps"); - if (wiRenderer::GetDevice()->CheckCapability(wiGraphics::GRAPHICSDEVICE_CAPABILITY_RAYTRACING_INLINE)) + if (wiRenderer::GetDevice()->CheckCapability(wiGraphics::GRAPHICSDEVICE_CAPABILITY_RAYTRACING)) { shadowTypeComboBox.AddItem("Ray traced"); } @@ -631,7 +651,7 @@ void RendererWindow::Create(EditorComponent* editor) - disableAlbedoMapsCheckBox.Create("Disable Albedo maps: "); + disableAlbedoMapsCheckBox.Create("Disable albedo maps: "); disableAlbedoMapsCheckBox.SetTooltip("Disables albedo maps on objects for easier lighting debugging"); disableAlbedoMapsCheckBox.SetPos(XMFLOAT2(x, y += step)); disableAlbedoMapsCheckBox.SetSize(XMFLOAT2(itemheight, itemheight)); @@ -642,6 +662,17 @@ void RendererWindow::Create(EditorComponent* editor) AddWidget(&disableAlbedoMapsCheckBox); + forceDiffuseLightingCheckBox.Create("Force diffuse lighting: "); + forceDiffuseLightingCheckBox.SetTooltip("Sets every surface fully diffuse, with zero specularity"); + forceDiffuseLightingCheckBox.SetPos(XMFLOAT2(x, y += step)); + forceDiffuseLightingCheckBox.SetSize(XMFLOAT2(itemheight, itemheight)); + forceDiffuseLightingCheckBox.OnClick([](wiEventArgs args) { + wiRenderer::SetForceDiffuseLighting(args.bValue); + }); + forceDiffuseLightingCheckBox.SetCheck(wiRenderer::IsForceDiffuseLighting()); + AddWidget(&forceDiffuseLightingCheckBox); + + Translate(XMFLOAT3(100, 50, 0)); SetVisible(false); diff --git a/Editor/RendererWindow.h b/Editor/RendererWindow.h index fff3ac1eb..8548b94a2 100644 --- a/Editor/RendererWindow.h +++ b/Editor/RendererWindow.h @@ -27,6 +27,8 @@ public: wiCheckBox occlusionCullingCheckBox; wiSlider resolutionScaleSlider; wiSlider gammaSlider; + wiCheckBox surfelGICheckBox; + wiCheckBox surfelGIDebugCheckBox; wiCheckBox voxelRadianceCheckBox; wiCheckBox voxelRadianceDebugCheckBox; wiCheckBox voxelRadianceSecondaryBounceCheckBox; @@ -74,6 +76,7 @@ public: wiCheckBox freezeCullingCameraCheckBox; wiCheckBox disableAlbedoMapsCheckBox; + wiCheckBox forceDiffuseLightingCheckBox; uint32_t GetPickType() const; }; diff --git a/Editor/Translator.cpp b/Editor/Translator.cpp index 3295086e5..663b06edb 100644 --- a/Editor/Translator.cpp +++ b/Editor/Translator.cpp @@ -73,7 +73,6 @@ void Translator::Create() bd.Usage = USAGE_DEFAULT; bd.ByteWidth = sizeof(verts); bd.BindFlags = BIND_VERTEX_BUFFER; - bd.CPUAccessFlags = 0; SubresourceData InitData; InitData.pSysMem = verts; @@ -100,7 +99,6 @@ void Translator::Create() bd.Usage = USAGE_DEFAULT; bd.ByteWidth = sizeof(verts); bd.BindFlags = BIND_VERTEX_BUFFER; - bd.CPUAccessFlags = 0; SubresourceData InitData; InitData.pSysMem = verts; @@ -156,7 +154,6 @@ void Translator::Create() bd.Usage = USAGE_DEFAULT; bd.ByteWidth = sizeof(verts); bd.BindFlags = BIND_VERTEX_BUFFER; - bd.CPUAccessFlags = 0; SubresourceData InitData; InitData.pSysMem = verts; @@ -467,25 +464,19 @@ void Translator::Draw(const CameraComponent& camera, CommandList cmd) const // xy XMStoreFloat4x4(&sb.g_xTransform, matX); sb.g_xColor = state == TRANSLATOR_XY ? XMFLOAT4(1, 1, 1, 1) : XMFLOAT4(0.4f, 0.4f, 0, 0.4f); - device->UpdateBuffer(wiRenderer::GetConstantBuffer(CBTYPE_MISC), &sb, cmd); - device->BindConstantBuffer(VS, wiRenderer::GetConstantBuffer(CBTYPE_MISC), CB_GETBINDSLOT(MiscCB), cmd); - device->BindConstantBuffer(PS, wiRenderer::GetConstantBuffer(CBTYPE_MISC), CB_GETBINDSLOT(MiscCB), cmd); + device->BindDynamicConstantBuffer(sb, CBSLOT_RENDERER_MISC, cmd); device->Draw(vertexCount_Plane, 0, cmd); // xz XMStoreFloat4x4(&sb.g_xTransform, matZ); sb.g_xColor = state == TRANSLATOR_XZ ? XMFLOAT4(1, 1, 1, 1) : XMFLOAT4(0.4f, 0.4f, 0, 0.4f); - device->UpdateBuffer(wiRenderer::GetConstantBuffer(CBTYPE_MISC), &sb, cmd); - device->BindConstantBuffer(VS, wiRenderer::GetConstantBuffer(CBTYPE_MISC), CB_GETBINDSLOT(MiscCB), cmd); - device->BindConstantBuffer(PS, wiRenderer::GetConstantBuffer(CBTYPE_MISC), CB_GETBINDSLOT(MiscCB), cmd); + device->BindDynamicConstantBuffer(sb, CBSLOT_RENDERER_MISC, cmd); device->Draw(vertexCount_Plane, 0, cmd); // yz XMStoreFloat4x4(&sb.g_xTransform, matY); sb.g_xColor = state == TRANSLATOR_YZ ? XMFLOAT4(1, 1, 1, 1) : XMFLOAT4(0.4f, 0.4f, 0, 0.4f); - device->UpdateBuffer(wiRenderer::GetConstantBuffer(CBTYPE_MISC), &sb, cmd); - device->BindConstantBuffer(VS, wiRenderer::GetConstantBuffer(CBTYPE_MISC), CB_GETBINDSLOT(MiscCB), cmd); - device->BindConstantBuffer(PS, wiRenderer::GetConstantBuffer(CBTYPE_MISC), CB_GETBINDSLOT(MiscCB), cmd); + device->BindDynamicConstantBuffer(sb, CBSLOT_RENDERER_MISC, cmd); device->Draw(vertexCount_Plane, 0, cmd); // Lines: @@ -503,25 +494,19 @@ void Translator::Draw(const CameraComponent& camera, CommandList cmd) const // x XMStoreFloat4x4(&sb.g_xTransform, matX); sb.g_xColor = state == TRANSLATOR_X ? XMFLOAT4(1, 1, 1, 1) : XMFLOAT4(1, 0, 0, 1); - device->UpdateBuffer(wiRenderer::GetConstantBuffer(CBTYPE_MISC), &sb, cmd); - device->BindConstantBuffer(VS, wiRenderer::GetConstantBuffer(CBTYPE_MISC), CB_GETBINDSLOT(MiscCB), cmd); - device->BindConstantBuffer(PS, wiRenderer::GetConstantBuffer(CBTYPE_MISC), CB_GETBINDSLOT(MiscCB), cmd); + device->BindDynamicConstantBuffer(sb, CBSLOT_RENDERER_MISC, cmd); device->Draw(vertexCount_Axis, 0, cmd); // y XMStoreFloat4x4(&sb.g_xTransform, matY); sb.g_xColor = state == TRANSLATOR_Y ? XMFLOAT4(1, 1, 1, 1) : XMFLOAT4(0, 1, 0, 1); - device->UpdateBuffer(wiRenderer::GetConstantBuffer(CBTYPE_MISC), &sb, cmd); - device->BindConstantBuffer(VS, wiRenderer::GetConstantBuffer(CBTYPE_MISC), CB_GETBINDSLOT(MiscCB), cmd); - device->BindConstantBuffer(PS, wiRenderer::GetConstantBuffer(CBTYPE_MISC), CB_GETBINDSLOT(MiscCB), cmd); + device->BindDynamicConstantBuffer(sb, CBSLOT_RENDERER_MISC, cmd); device->Draw(vertexCount_Axis, 0, cmd); // z XMStoreFloat4x4(&sb.g_xTransform, matZ); sb.g_xColor = state == TRANSLATOR_Z ? XMFLOAT4(1, 1, 1, 1) : XMFLOAT4(0, 0, 1, 1); - device->UpdateBuffer(wiRenderer::GetConstantBuffer(CBTYPE_MISC), &sb, cmd); - device->BindConstantBuffer(VS, wiRenderer::GetConstantBuffer(CBTYPE_MISC), CB_GETBINDSLOT(MiscCB), cmd); - device->BindConstantBuffer(PS, wiRenderer::GetConstantBuffer(CBTYPE_MISC), CB_GETBINDSLOT(MiscCB), cmd); + device->BindDynamicConstantBuffer(sb, CBSLOT_RENDERER_MISC, cmd); device->Draw(vertexCount_Axis, 0, cmd); // Origin: @@ -536,9 +521,7 @@ void Translator::Draw(const CameraComponent& camera, CommandList cmd) const device->BindVertexBuffers(vbs, 0, arraysize(vbs), strides, nullptr, cmd); XMStoreFloat4x4(&sb.g_xTransform, mat); sb.g_xColor = state == TRANSLATOR_XYZ ? XMFLOAT4(1, 1, 1, 1) : XMFLOAT4(0.25f, 0.25f, 0.25f, 1); - device->UpdateBuffer(wiRenderer::GetConstantBuffer(CBTYPE_MISC), &sb, cmd); - device->BindConstantBuffer(VS, wiRenderer::GetConstantBuffer(CBTYPE_MISC), CB_GETBINDSLOT(MiscCB), cmd); - device->BindConstantBuffer(PS, wiRenderer::GetConstantBuffer(CBTYPE_MISC), CB_GETBINDSLOT(MiscCB), cmd); + device->BindDynamicConstantBuffer(sb, CBSLOT_RENDERER_MISC, cmd); device->Draw(vertexCount_Origin, 0, cmd); } diff --git a/README.md b/README.md index 28f495007..1b3917363 100644 --- a/README.md +++ b/README.md @@ -203,7 +203,7 @@ The preferred workflow is to import models into the Editor, and save them as ### Graphics API: -The default renderer is `DirectX 11` on Windows and `Vulkan` on Linux. There is also an optional `DirectX 12` renderer for Windows. +The default renderer is `DirectX 12` on Windows and `Vulkan` on Linux. The `DirectX 11` renderer is no longer available starting from version 0.57.0, but it can be found on the dx11-backup branch. You can specify command line arguments (without any prefix) to switch between render devices or other settings. Currently the list of options: diff --git a/Template_UWP/Template_UWP.vcxproj b/Template_UWP/Template_UWP.vcxproj index ac729d56f..c41a87a29 100644 --- a/Template_UWP/Template_UWP.vcxproj +++ b/Template_UWP/Template_UWP.vcxproj @@ -159,11 +159,6 @@ - - true - Document - true - true Document diff --git a/Template_UWP/Template_UWP.vcxproj.filters b/Template_UWP/Template_UWP.vcxproj.filters index 904359c08..724c704f0 100644 --- a/Template_UWP/Template_UWP.vcxproj.filters +++ b/Template_UWP/Template_UWP.vcxproj.filters @@ -44,7 +44,6 @@ - diff --git a/Template_Windows/Template_Windows.vcxproj b/Template_Windows/Template_Windows.vcxproj index 2fd04a674..9daa99cad 100644 --- a/Template_Windows/Template_Windows.vcxproj +++ b/Template_Windows/Template_Windows.vcxproj @@ -75,9 +75,8 @@ $(SolutionDir)BUILD\$(Platform)\$(Configuration);%(AdditionalLibraryDirectories) - xcopy "$(SolutionDir)WickedEngine\dxcompiler.dll" "$(OutDir)" /c /y -xcopy "$(SolutionDir)WickedEngine\dxil.dll" "$(OutDir)" /c /y -xcopy "$(SolutionDir)WickedEngine\d3dcompiler_47.dll" "$(OutDir)" /c /y + + @@ -97,9 +96,8 @@ xcopy "$(SolutionDir)WickedEngine\d3dcompiler_47.dll" "$(OutDir)" /c /y$(SolutionDir)BUILD\$(Platform)\$(Configuration);%(AdditionalLibraryDirectories) - xcopy "$(SolutionDir)WickedEngine\dxcompiler.dll" "$(OutDir)" /c /y -xcopy "$(SolutionDir)WickedEngine\dxil.dll" "$(OutDir)" /c /y -xcopy "$(SolutionDir)WickedEngine\d3dcompiler_47.dll" "$(OutDir)" /c /y + + @@ -131,11 +129,6 @@ xcopy "$(SolutionDir)WickedEngine\d3dcompiler_47.dll" "$(OutDir)" /c /y - - true - Document - true - true Document diff --git a/Template_Windows/Template_Windows.vcxproj.filters b/Template_Windows/Template_Windows.vcxproj.filters index e5bb75190..87ab8dae9 100644 --- a/Template_Windows/Template_Windows.vcxproj.filters +++ b/Template_Windows/Template_Windows.vcxproj.filters @@ -49,7 +49,6 @@ - \ No newline at end of file diff --git a/Tests/Tests.vcxproj b/Tests/Tests.vcxproj index 3955b2d27..c34ba14c0 100644 --- a/Tests/Tests.vcxproj +++ b/Tests/Tests.vcxproj @@ -78,9 +78,8 @@ $(SolutionDir)BUILD\$(Platform)\$(Configuration);%(AdditionalLibraryDirectories) - xcopy "$(SolutionDir)WickedEngine\dxcompiler.dll" "$(OutDir)" /c /y -xcopy "$(SolutionDir)WickedEngine\dxil.dll" "$(OutDir)" /c /y -xcopy "$(SolutionDir)WickedEngine\d3dcompiler_47.dll" "$(OutDir)" /c /y + + @@ -101,9 +100,8 @@ xcopy "$(SolutionDir)WickedEngine\d3dcompiler_47.dll" "$(OutDir)" /c /y$(SolutionDir)BUILD\$(Platform)\$(Configuration);%(AdditionalLibraryDirectories) - xcopy "$(SolutionDir)WickedEngine\dxcompiler.dll" "$(OutDir)" /c /y -xcopy "$(SolutionDir)WickedEngine\dxil.dll" "$(OutDir)" /c /y -xcopy "$(SolutionDir)WickedEngine\d3dcompiler_47.dll" "$(OutDir)" /c /y + + @@ -135,11 +133,6 @@ xcopy "$(SolutionDir)WickedEngine\d3dcompiler_47.dll" "$(OutDir)" /c /y - - true - Document - true - true Document diff --git a/Tests/Tests.vcxproj.filters b/Tests/Tests.vcxproj.filters index 99ffd102b..2f38cb886 100644 --- a/Tests/Tests.vcxproj.filters +++ b/Tests/Tests.vcxproj.filters @@ -68,7 +68,6 @@ - diff --git a/WickedEngine/CMakeLists.txt b/WickedEngine/CMakeLists.txt index 8676756d3..e5c295e89 100644 --- a/WickedEngine/CMakeLists.txt +++ b/WickedEngine/CMakeLists.txt @@ -61,7 +61,6 @@ add_library(${TARGET_NAME} STATIC wiGPUBVH.cpp wiGPUSortLib.cpp wiGraphicsDevice.cpp - wiGraphicsDevice_DX11.cpp wiGraphicsDevice_DX12.cpp wiGraphicsDevice_Vulkan.cpp wiGUI.cpp diff --git a/WickedEngine/MainComponent.cpp b/WickedEngine/MainComponent.cpp index 0e5c9422e..258e6053f 100644 --- a/WickedEngine/MainComponent.cpp +++ b/WickedEngine/MainComponent.cpp @@ -16,7 +16,6 @@ #include "wiImage.h" #include "wiEvent.h" -#include "wiGraphicsDevice_DX11.h" #include "wiGraphicsDevice_DX12.h" #include "wiGraphicsDevice_Vulkan.h" @@ -107,64 +106,61 @@ void MainComponent::Run() wiLua::RunFile("startup.lua"); } + if (!is_window_active) + { + // If the application is not active, disable Update loops: + deltaTimeAccumulator = 0; + return; + } + wiProfiler::BeginFrame(); deltaTime = float(std::max(0.0, timer.elapsed() / 1000.0)); timer.record(); - if (is_window_active) + // Wake up the events that need to be executed on the main thread, in thread safe manner: + wiEvent::FireEvent(SYSTEM_EVENT_THREAD_SAFE_POINT, 0); + + const float dt = framerate_lock ? (1.0f / targetFrameRate) : deltaTime; + + fadeManager.Update(dt); + + if (GetActivePath() != nullptr) { - // If the application is active, run Update loops: + GetActivePath()->init(canvas); + GetActivePath()->PreUpdate(); + } - // Wake up the events that need to be executed on the main thread, in thread safe manner: - wiEvent::FireEvent(SYSTEM_EVENT_THREAD_SAFE_POINT, 0); - - const float dt = framerate_lock ? (1.0f / targetFrameRate) : deltaTime; - - fadeManager.Update(dt); - - if (GetActivePath() != nullptr) + // Fixed time update: + auto range = wiProfiler::BeginRangeCPU("Fixed Update"); + { + if (frameskip) { - GetActivePath()->init(canvas); - GetActivePath()->PreUpdate(); - } - - // Fixed time update: - auto range = wiProfiler::BeginRangeCPU("Fixed Update"); - { - if (frameskip) + deltaTimeAccumulator += dt; + if (deltaTimeAccumulator > 10) { - deltaTimeAccumulator += dt; - if (deltaTimeAccumulator > 10) - { - // application probably lost control, fixed update would take too long - deltaTimeAccumulator = 0; - } - - const float targetFrameRateInv = 1.0f / targetFrameRate; - while (deltaTimeAccumulator >= targetFrameRateInv) - { - FixedUpdate(); - deltaTimeAccumulator -= targetFrameRateInv; - } + // application probably lost control, fixed update would take too long + deltaTimeAccumulator = 0; } - else + + const float targetFrameRateInv = 1.0f / targetFrameRate; + while (deltaTimeAccumulator >= targetFrameRateInv) { FixedUpdate(); + deltaTimeAccumulator -= targetFrameRateInv; } } - wiProfiler::EndRange(range); // Fixed Update - - // Variable-timed update: - Update(dt); - - Render(); - } - else - { - // If the application is not active, disable Update loops: - deltaTimeAccumulator = 0; + else + { + FixedUpdate(); + } } + wiProfiler::EndRange(range); // Fixed Update + + // Variable-timed update: + Update(dt); + + Render(); wiInput::Update(window); @@ -267,12 +263,6 @@ void MainComponent::Compose(CommandList cmd) ss << "[UWP]"; #endif -#ifdef WICKEDENGINE_BUILD_DX11 - if (dynamic_cast(device)) - { - ss << "[DX11]"; - } -#endif #ifdef WICKEDENGINE_BUILD_DX12 if (dynamic_cast(device)) { @@ -356,16 +346,9 @@ void MainComponent::SetWindow(wiPlatform::window_type window, bool fullscreen) bool debugdevice = wiStartupArguments::HasArgument("debugdevice"); bool gpuvalidation = wiStartupArguments::HasArgument("gpuvalidation"); - bool use_dx11 = wiStartupArguments::HasArgument("dx11"); bool use_dx12 = wiStartupArguments::HasArgument("dx12"); bool use_vulkan = wiStartupArguments::HasArgument("vulkan"); -#ifndef WICKEDENGINE_BUILD_DX11 - if (use_dx11) { - wiHelper::messageBox("The engine was built without DX11 support!", "Error"); - use_dx11 = false; - } -#endif #ifndef WICKEDENGINE_BUILD_DX12 if (use_dx12) { wiHelper::messageBox("The engine was built without DX12 support!", "Error"); @@ -379,11 +362,9 @@ void MainComponent::SetWindow(wiPlatform::window_type window, bool fullscreen) } #endif - if (!use_dx11 && !use_dx12 && !use_vulkan) + if (!use_dx12 && !use_vulkan) { -#if defined(WICKEDENGINE_BUILD_DX11) - use_dx11 = true; -#elif defined(WICKEDENGINE_BUILD_DX12) +#if defined(WICKEDENGINE_BUILD_DX12) use_dx12 = true; #elif defined(WICKEDENGINE_BUILD_VULKAN) use_vulkan = true; @@ -392,7 +373,7 @@ void MainComponent::SetWindow(wiPlatform::window_type window, bool fullscreen) assert(false); #endif } - assert(use_dx11 || use_dx12 || use_vulkan); + assert(use_dx12 || use_vulkan); if (use_vulkan) { @@ -406,13 +387,6 @@ void MainComponent::SetWindow(wiPlatform::window_type window, bool fullscreen) #ifdef WICKEDENGINE_BUILD_DX12 wiRenderer::SetShaderPath(wiRenderer::GetShaderPath() + "hlsl6/"); wiRenderer::SetDevice(std::make_shared(debugdevice, gpuvalidation)); -#endif - } - else if (use_dx11) - { -#ifdef WICKEDENGINE_BUILD_DX11 - wiRenderer::SetShaderPath(wiRenderer::GetShaderPath() + "hlsl5/"); - wiRenderer::SetDevice(std::make_shared(debugdevice)); #endif } } diff --git a/WickedEngine/OfflineShaderCompiler.vcxproj b/WickedEngine/OfflineShaderCompiler.vcxproj index bb5ff4e93..95dfe384b 100644 --- a/WickedEngine/OfflineShaderCompiler.vcxproj +++ b/WickedEngine/OfflineShaderCompiler.vcxproj @@ -97,11 +97,6 @@ - - true - Document - true - true true diff --git a/WickedEngine/RenderPath2D.cpp b/WickedEngine/RenderPath2D.cpp index 3ec663d23..0e6043197 100644 --- a/WickedEngine/RenderPath2D.cpp +++ b/WickedEngine/RenderPath2D.cpp @@ -18,7 +18,7 @@ void RenderPath2D::ResizeBuffers() if(dsv != nullptr && (resolutionScale != 1.0f || dsv->GetDesc().SampleCount > 1)) { TextureDesc desc = GetDepthStencil()->GetDesc(); - desc.layout = IMAGE_LAYOUT_SHADER_RESOURCE; + desc.layout = RESOURCE_STATE_SHADER_RESOURCE; desc.BindFlags = BIND_RENDER_TARGET | BIND_SHADER_RESOURCE; desc.Format = FORMAT_R8G8B8A8_UNORM; device->CreateTexture(&desc, nullptr, &rtStenciled); @@ -55,9 +55,9 @@ void RenderPath2D::ResizeBuffers() dsv, RenderPassAttachment::LOADOP_LOAD, RenderPassAttachment::STOREOP_STORE, - IMAGE_LAYOUT_DEPTHSTENCIL_READONLY, - IMAGE_LAYOUT_DEPTHSTENCIL_READONLY, - IMAGE_LAYOUT_DEPTHSTENCIL_READONLY + RESOURCE_STATE_DEPTHSTENCIL_READONLY, + RESOURCE_STATE_DEPTHSTENCIL_READONLY, + RESOURCE_STATE_DEPTHSTENCIL_READONLY ) ); @@ -81,9 +81,9 @@ void RenderPath2D::ResizeBuffers() dsv, RenderPassAttachment::LOADOP_LOAD, RenderPassAttachment::STOREOP_STORE, - IMAGE_LAYOUT_DEPTHSTENCIL_READONLY, - IMAGE_LAYOUT_DEPTHSTENCIL_READONLY, - IMAGE_LAYOUT_DEPTHSTENCIL_READONLY + RESOURCE_STATE_DEPTHSTENCIL_READONLY, + RESOURCE_STATE_DEPTHSTENCIL_READONLY, + RESOURCE_STATE_DEPTHSTENCIL_READONLY ) ); } diff --git a/WickedEngine/RenderPath3D.cpp b/WickedEngine/RenderPath3D.cpp index decb83b3e..cef7968a2 100644 --- a/WickedEngine/RenderPath3D.cpp +++ b/WickedEngine/RenderPath3D.cpp @@ -20,51 +20,63 @@ void RenderPath3D::ResizeBuffers() { TextureDesc desc; - desc.BindFlags = BIND_RENDER_TARGET | BIND_SHADER_RESOURCE; - if (getMSAASampleCount() == 1) - { - desc.BindFlags |= BIND_UNORDERED_ACCESS; - } + desc.Format = FORMAT_R11G11B10_FLOAT; + desc.BindFlags = BIND_RENDER_TARGET | BIND_SHADER_RESOURCE | BIND_UNORDERED_ACCESS; desc.Width = internalResolution.x; desc.Height = internalResolution.y; - desc.SampleCount = getMSAASampleCount(); + desc.SampleCount = 1; - desc.Format = FORMAT_R11G11B10_FLOAT; - device->CreateTexture(&desc, nullptr, &rtGbuffer[GBUFFER_COLOR]); - device->SetName(&rtGbuffer[GBUFFER_COLOR], "rtGbuffer[GBUFFER_COLOR]"); + device->CreateTexture(&desc, nullptr, &rtMain); + device->SetName(&rtMain, "rtMain"); - desc.BindFlags = BIND_RENDER_TARGET | BIND_SHADER_RESOURCE; - desc.Format = FORMAT_R8G8B8A8_UNORM; - device->CreateTexture(&desc, nullptr, &rtGbuffer[GBUFFER_NORMAL_ROUGHNESS]); - device->SetName(&rtGbuffer[GBUFFER_NORMAL_ROUGHNESS], "rtGbuffer[GBUFFER_NORMAL_ROUGHNESS]"); + if (getMSAASampleCount() > 1) + { + desc.SampleCount = getMSAASampleCount(); + desc.BindFlags = BIND_RENDER_TARGET; + device->CreateTexture(&desc, nullptr, &rtMain_render); + device->SetName(&rtMain_render, "rtMain_render"); + } + else + { + rtMain_render = rtMain; + } + } + { + TextureDesc desc; + desc.Width = internalResolution.x; + desc.Height = internalResolution.y; + desc.layout = RESOURCE_STATE_SHADER_RESOURCE_COMPUTE; + desc.SampleCount = 1; + + desc.BindFlags = BIND_RENDER_TARGET | BIND_SHADER_RESOURCE | BIND_UNORDERED_ACCESS; + desc.Format = FORMAT_R32G32_UINT; + device->CreateTexture(&desc, nullptr, &rtGbuffer[GBUFFER_PRIMITIVEID]); + device->SetName(&rtGbuffer[GBUFFER_PRIMITIVEID], "rtGbuffer[GBUFFER_PRIMITIVEID]"); + + desc.BindFlags = BIND_SHADER_RESOURCE | BIND_UNORDERED_ACCESS; desc.Format = FORMAT_R16G16_FLOAT; device->CreateTexture(&desc, nullptr, &rtGbuffer[GBUFFER_VELOCITY]); device->SetName(&rtGbuffer[GBUFFER_VELOCITY], "rtGbuffer[GBUFFER_VELOCITY]"); if (getMSAASampleCount() > 1) { - desc.SampleCount = 1; - desc.BindFlags = BIND_RENDER_TARGET | BIND_SHADER_RESOURCE | BIND_UNORDERED_ACCESS; - - desc.Format = FORMAT_R11G11B10_FLOAT; - device->CreateTexture(&desc, nullptr, &rtGbuffer_resolved[GBUFFER_COLOR]); - device->SetName(&rtGbuffer_resolved[GBUFFER_COLOR], "rtGbuffer_resolved[GBUFFER_COLOR]"); - - desc.Format = FORMAT_R8G8B8A8_UNORM; - device->CreateTexture(&desc, nullptr, &rtGbuffer_resolved[GBUFFER_NORMAL_ROUGHNESS]); - device->SetName(&rtGbuffer_resolved[GBUFFER_NORMAL_ROUGHNESS], "rtGbuffer_resolved[GBUFFER_NORMAL_ROUGHNESS]"); - - desc.Format = FORMAT_R16G16_FLOAT; - device->CreateTexture(&desc, nullptr, &rtGbuffer_resolved[GBUFFER_VELOCITY]); - device->SetName(&rtGbuffer_resolved[GBUFFER_VELOCITY], "rtGbuffer_resolved[GBUFFER_VELOCITY]"); + desc = rtGbuffer[GBUFFER_PRIMITIVEID].desc; + desc.SampleCount = getMSAASampleCount(); + desc.BindFlags = BIND_RENDER_TARGET | BIND_SHADER_RESOURCE; + device->CreateTexture(&desc, nullptr, &rtPrimitiveID_render); + device->SetName(&rtPrimitiveID_render, "rtPrimitiveID_render"); + } + else + { + rtPrimitiveID_render = rtGbuffer[GBUFFER_PRIMITIVEID]; } } { TextureDesc desc; desc.BindFlags = BIND_RENDER_TARGET | BIND_SHADER_RESOURCE; - desc.Format = FORMAT_R16G16B16A16_FLOAT; + desc.Format = FORMAT_R16G16_FLOAT; desc.Width = internalResolution.x; desc.Height = internalResolution.y; desc.SampleCount = getMSAASampleCount(); @@ -91,7 +103,7 @@ void RenderPath3D::ResizeBuffers() { TextureDesc desc; desc.BindFlags = BIND_RENDER_TARGET | BIND_SHADER_RESOURCE; - desc.Format = FORMAT_R8G8_SNORM; + desc.Format = FORMAT_R16G16_FLOAT; desc.Width = internalResolution.x; desc.Height = internalResolution.y; device->CreateTexture(&desc, nullptr, &rtWaterRipple); @@ -138,7 +150,7 @@ void RenderPath3D::ResizeBuffers() desc.Format = FORMAT_R32G32B32A32_UINT; desc.Width = internalResolution.x / 2; desc.Height = internalResolution.y / 2; - desc.layout = IMAGE_LAYOUT_SHADER_RESOURCE_COMPUTE; + desc.layout = RESOURCE_STATE_SHADER_RESOURCE_COMPUTE; device->CreateTexture(&desc, nullptr, &rtShadow); device->SetName(&rtShadow, "rtShadow"); } @@ -218,7 +230,7 @@ void RenderPath3D::ResizeBuffers() uint32_t tileSize = device->GetVariableRateShadingTileSize(); TextureDesc desc; - desc.layout = IMAGE_LAYOUT_UNORDERED_ACCESS; + desc.layout = RESOURCE_STATE_UNORDERED_ACCESS; desc.BindFlags = BIND_UNORDERED_ACCESS | BIND_SHADING_RATE; desc.Format = FORMAT_R8_UINT; desc.Width = (internalResolution.x + tileSize - 1) / tileSize; @@ -235,17 +247,17 @@ void RenderPath3D::ResizeBuffers() desc.Height = internalResolution.y; desc.SampleCount = getMSAASampleCount(); - desc.layout = IMAGE_LAYOUT_DEPTHSTENCIL_READONLY; + desc.layout = RESOURCE_STATE_DEPTHSTENCIL_READONLY; desc.Format = FORMAT_R32G8X24_TYPELESS; desc.BindFlags = BIND_DEPTH_STENCIL | BIND_SHADER_RESOURCE; device->CreateTexture(&desc, nullptr, &depthBuffer_Main); device->SetName(&depthBuffer_Main, "depthBuffer_Main"); - desc.layout = IMAGE_LAYOUT_SHADER_RESOURCE_COMPUTE; + desc.layout = RESOURCE_STATE_SHADER_RESOURCE_COMPUTE; desc.Format = FORMAT_R32_FLOAT; desc.BindFlags = BIND_SHADER_RESOURCE | BIND_UNORDERED_ACCESS; desc.SampleCount = 1; - desc.MipLevels = 3; + desc.MipLevels = 5; device->CreateTexture(&desc, nullptr, &depthBuffer_Copy); device->SetName(&depthBuffer_Copy, "depthBuffer_Copy"); device->CreateTexture(&desc, nullptr, &depthBuffer_Copy1); @@ -270,7 +282,7 @@ void RenderPath3D::ResizeBuffers() desc.Format = FORMAT_R32_TYPELESS; desc.Width = internalResolution.x / 4; desc.Height = internalResolution.y / 4; - desc.layout = IMAGE_LAYOUT_DEPTHSTENCIL_READONLY; + desc.layout = RESOURCE_STATE_DEPTHSTENCIL_READONLY; device->CreateTexture(&desc, nullptr, &depthBuffer_Reflection); device->SetName(&depthBuffer_Reflection, "depthBuffer_Reflection"); } @@ -280,8 +292,8 @@ void RenderPath3D::ResizeBuffers() desc.Format = FORMAT_R32_FLOAT; desc.Width = internalResolution.x; desc.Height = internalResolution.y; - desc.MipLevels = 6; - desc.layout = IMAGE_LAYOUT_SHADER_RESOURCE_COMPUTE; + desc.MipLevels = 5; + desc.layout = RESOURCE_STATE_SHADER_RESOURCE_COMPUTE; device->CreateTexture(&desc, nullptr, &rtLinearDepth); device->SetName(&rtLinearDepth, "rtLinearDepth"); @@ -303,60 +315,63 @@ void RenderPath3D::ResizeBuffers() &depthBuffer_Main, RenderPassAttachment::LOADOP_CLEAR, RenderPassAttachment::STOREOP_STORE, - IMAGE_LAYOUT_DEPTHSTENCIL_READONLY, - IMAGE_LAYOUT_DEPTHSTENCIL, - IMAGE_LAYOUT_SHADER_RESOURCE + RESOURCE_STATE_DEPTHSTENCIL_READONLY, + RESOURCE_STATE_DEPTHSTENCIL, + RESOURCE_STATE_SHADER_RESOURCE + ) + ); + desc.attachments.push_back( + RenderPassAttachment::RenderTarget( + &rtPrimitiveID_render, + RenderPassAttachment::LOADOP_DONTCARE, + RenderPassAttachment::STOREOP_STORE, + RESOURCE_STATE_SHADER_RESOURCE_COMPUTE, + RESOURCE_STATE_RENDERTARGET, + RESOURCE_STATE_SHADER_RESOURCE_COMPUTE ) ); - desc.attachments.push_back(RenderPassAttachment::RenderTarget(&rtGbuffer[GBUFFER_VELOCITY], RenderPassAttachment::LOADOP_DONTCARE)); - if (getMSAASampleCount() > 1) - { - desc.attachments.push_back(RenderPassAttachment::Resolve(GetGbuffer_Read(GBUFFER_VELOCITY))); - } device->CreateRenderPass(&desc, &renderpass_depthprepass); desc.attachments.clear(); - desc.attachments.push_back(RenderPassAttachment::RenderTarget(&rtGbuffer[GBUFFER_COLOR], RenderPassAttachment::LOADOP_DONTCARE)); - desc.attachments.push_back(RenderPassAttachment::RenderTarget(&rtGbuffer[GBUFFER_NORMAL_ROUGHNESS], RenderPassAttachment::LOADOP_DONTCARE)); + desc.attachments.push_back(RenderPassAttachment::RenderTarget(&rtMain_render, RenderPassAttachment::LOADOP_DONTCARE)); desc.attachments.push_back( RenderPassAttachment::DepthStencil( &depthBuffer_Main, RenderPassAttachment::LOADOP_LOAD, RenderPassAttachment::STOREOP_STORE, - IMAGE_LAYOUT_SHADER_RESOURCE, - IMAGE_LAYOUT_DEPTHSTENCIL_READONLY, - IMAGE_LAYOUT_DEPTHSTENCIL_READONLY + RESOURCE_STATE_SHADER_RESOURCE, + RESOURCE_STATE_DEPTHSTENCIL_READONLY, + RESOURCE_STATE_DEPTHSTENCIL_READONLY ) ); if (getMSAASampleCount() > 1) { - desc.attachments.push_back(RenderPassAttachment::Resolve(GetGbuffer_Read(GBUFFER_COLOR))); - desc.attachments.push_back(RenderPassAttachment::Resolve(GetGbuffer_Read(GBUFFER_NORMAL_ROUGHNESS))); + desc.attachments.push_back(RenderPassAttachment::Resolve(&rtMain)); } if (device->CheckCapability(GRAPHICSDEVICE_CAPABILITY_VARIABLE_RATE_SHADING_TIER2)) { - desc.attachments.push_back(RenderPassAttachment::ShadingRateSource(&rtShadingRate, IMAGE_LAYOUT_UNORDERED_ACCESS, IMAGE_LAYOUT_UNORDERED_ACCESS)); + desc.attachments.push_back(RenderPassAttachment::ShadingRateSource(&rtShadingRate, RESOURCE_STATE_UNORDERED_ACCESS, RESOURCE_STATE_UNORDERED_ACCESS)); } device->CreateRenderPass(&desc, &renderpass_main); } { RenderPassDesc desc; - desc.attachments.push_back(RenderPassAttachment::RenderTarget(&rtGbuffer[GBUFFER_COLOR], RenderPassAttachment::LOADOP_LOAD)); + desc.attachments.push_back(RenderPassAttachment::RenderTarget(&rtMain_render, RenderPassAttachment::LOADOP_LOAD)); desc.attachments.push_back( RenderPassAttachment::DepthStencil( &depthBuffer_Main, RenderPassAttachment::LOADOP_LOAD, RenderPassAttachment::STOREOP_STORE, - IMAGE_LAYOUT_DEPTHSTENCIL_READONLY, - IMAGE_LAYOUT_DEPTHSTENCIL, - IMAGE_LAYOUT_DEPTHSTENCIL_READONLY + RESOURCE_STATE_DEPTHSTENCIL_READONLY, + RESOURCE_STATE_DEPTHSTENCIL, + RESOURCE_STATE_DEPTHSTENCIL_READONLY ) ); if (getMSAASampleCount() > 1) { - desc.attachments.push_back(RenderPassAttachment::Resolve(&rtGbuffer_resolved[GBUFFER_COLOR])); + desc.attachments.push_back(RenderPassAttachment::Resolve(&rtMain)); } device->CreateRenderPass(&desc, &renderpass_transparent); } @@ -367,9 +382,9 @@ void RenderPath3D::ResizeBuffers() &depthBuffer_Reflection, RenderPassAttachment::LOADOP_CLEAR, RenderPassAttachment::STOREOP_STORE, - IMAGE_LAYOUT_DEPTHSTENCIL_READONLY, - IMAGE_LAYOUT_DEPTHSTENCIL, - IMAGE_LAYOUT_SHADER_RESOURCE + RESOURCE_STATE_DEPTHSTENCIL_READONLY, + RESOURCE_STATE_DEPTHSTENCIL, + RESOURCE_STATE_SHADER_RESOURCE ) ); @@ -382,9 +397,9 @@ void RenderPath3D::ResizeBuffers() &rtReflection, RenderPassAttachment::LOADOP_DONTCARE, RenderPassAttachment::STOREOP_STORE, - IMAGE_LAYOUT_SHADER_RESOURCE, - IMAGE_LAYOUT_RENDERTARGET, - IMAGE_LAYOUT_SHADER_RESOURCE + RESOURCE_STATE_SHADER_RESOURCE, + RESOURCE_STATE_RENDERTARGET, + RESOURCE_STATE_SHADER_RESOURCE ) ); desc.attachments.push_back( @@ -392,9 +407,9 @@ void RenderPath3D::ResizeBuffers() &depthBuffer_Reflection, RenderPassAttachment::LOADOP_LOAD, RenderPassAttachment::STOREOP_DONTCARE, - IMAGE_LAYOUT_SHADER_RESOURCE, - IMAGE_LAYOUT_DEPTHSTENCIL_READONLY, - IMAGE_LAYOUT_DEPTHSTENCIL_READONLY + RESOURCE_STATE_SHADER_RESOURCE, + RESOURCE_STATE_DEPTHSTENCIL_READONLY, + RESOURCE_STATE_DEPTHSTENCIL_READONLY ) ); @@ -413,9 +428,9 @@ void RenderPath3D::ResizeBuffers() &depthBuffer_Main, RenderPassAttachment::LOADOP_LOAD, RenderPassAttachment::STOREOP_STORE, - IMAGE_LAYOUT_DEPTHSTENCIL_READONLY, - IMAGE_LAYOUT_DEPTHSTENCIL_READONLY, - IMAGE_LAYOUT_DEPTHSTENCIL_READONLY + RESOURCE_STATE_DEPTHSTENCIL_READONLY, + RESOURCE_STATE_DEPTHSTENCIL_READONLY, + RESOURCE_STATE_DEPTHSTENCIL_READONLY ) ); desc.attachments.push_back(RenderPassAttachment::RenderTarget(&rtSun[0], RenderPassAttachment::LOADOP_CLEAR)); @@ -441,9 +456,9 @@ void RenderPath3D::ResizeBuffers() &depthBuffer_Main, RenderPassAttachment::LOADOP_LOAD, RenderPassAttachment::STOREOP_STORE, - IMAGE_LAYOUT_DEPTHSTENCIL_READONLY, - IMAGE_LAYOUT_DEPTHSTENCIL_READONLY, - IMAGE_LAYOUT_DEPTHSTENCIL_READONLY + RESOURCE_STATE_DEPTHSTENCIL_READONLY, + RESOURCE_STATE_DEPTHSTENCIL_READONLY, + RESOURCE_STATE_DEPTHSTENCIL_READONLY ) ); @@ -473,8 +488,6 @@ void RenderPath3D::ResizeBuffers() desc.SampleCount = 1; desc.Usage = USAGE_DEFAULT; desc.BindFlags = BIND_SHADER_RESOURCE | BIND_UNORDERED_ACCESS; - desc.CPUAccessFlags = 0; - desc.MiscFlags = 0; device->CreateTexture(&desc, nullptr, &debugUAV); device->SetName(&debugUAV, "debugUAV"); @@ -488,8 +501,9 @@ void RenderPath3D::ResizeBuffers() wiRenderer::CreateVolumetricCloudResources(volumetriccloudResources, internalResolution); wiRenderer::CreateVolumetricCloudResources(volumetriccloudResources_reflection, XMUINT2(depthBuffer_Reflection.desc.Width, depthBuffer_Reflection.desc.Height)); wiRenderer::CreateBloomResources(bloomResources, internalResolution); + wiRenderer::CreateSurfelGIResources(surfelGIResources, internalResolution); - if (device->CheckCapability(GRAPHICSDEVICE_CAPABILITY_RAYTRACING_INLINE)) + if (device->CheckCapability(GRAPHICSDEVICE_CAPABILITY_RAYTRACING)) { wiRenderer::CreateRTShadowResources(rtshadowResources, internalResolution); } @@ -510,7 +524,7 @@ void RenderPath3D::PreUpdate() void RenderPath3D::Update(float dt) { - if (rtGbuffer[GBUFFER_COLOR].desc.SampleCount != msaaSampleCount) + if (rtMain_render.desc.SampleCount != msaaSampleCount) { ResizeBuffers(); } @@ -519,14 +533,15 @@ void RenderPath3D::Update(float dt) if (getSceneUpdateEnabled()) { - scene->Update(dt * wiRenderer::GetGameSpeed()); - - if (wiRenderer::GetRaytracedShadowsEnabled() || + if (wiRenderer::GetSurfelGIEnabled() || + wiRenderer::GetRaytracedShadowsEnabled() || getAO() == AO_RTAO || getRaytracedReflectionEnabled()) { scene->SetAccelerationStructureUpdateRequested(true); } + + scene->Update(dt * wiRenderer::GetGameSpeed()); } // Frustum culling for main camera: @@ -607,6 +622,21 @@ void RenderPath3D::Render() const wiRenderer::UpdateRaytracingAccelerationStructures(*scene, cmd); + if (wiRenderer::GetSurfelGIEnabled()) + { + wiRenderer::UpdateCameraCB( + *camera, + camera_previous, + camera_reflection, + cmd + ); + wiRenderer::SurfelGI( + surfelGIResources, + *scene, + cmd + ); + } + }); } @@ -634,6 +664,8 @@ void RenderPath3D::Render() const cmd ); + wiRenderer::OcclusionCulling_Reset(visibility_main, cmd); // must be outside renderpass! + device->RenderPassBegin(&renderpass_depthprepass, cmd); device->EventBegin("Opaque Z-prepass", cmd); @@ -644,7 +676,6 @@ void RenderPath3D::Render() const vp.Height = (float)depthBuffer_Main.GetDesc().Height; device->BindViewports(1, &vp, cmd); wiRenderer::DrawScene(visibility_main, RENDERPASS_PREPASS, cmd, drawscene_flags); - wiRenderer::DrawSkyVelocity(cmd); wiProfiler::EndRange(range); device->EventEnd(cmd); @@ -656,6 +687,8 @@ void RenderPath3D::Render() const device->RenderPassEnd(cmd); + wiRenderer::OcclusionCulling_Resolve(visibility_main, cmd); // must be outside renderpass! + }); // Main camera compute effects: @@ -675,24 +708,33 @@ void RenderPath3D::Render() const cmd ); - // Create the top mip of depth pyramid from main depth buffer: - if (getMSAASampleCount() > 1) - { - wiRenderer::ResolveMSAADepthBuffer(depthBuffer_Copy, depthBuffer_Main, cmd); - } - else - { - wiRenderer::CopyTexture2D(depthBuffer_Copy, 0, 0, 0, depthBuffer_Main, 0, cmd); - } + wiRenderer::VisibilityResolve( + depthBuffer_Main, + rtPrimitiveID_render, + rtGbuffer, + depthBuffer_Copy, + rtLinearDepth, + cmd + ); - wiRenderer::Postprocess_DepthPyramid(depthBuffer_Copy, rtLinearDepth, cmd); + if (wiRenderer::GetSurfelGIEnabled()) + { + wiRenderer::SurfelGI_Coverage( + surfelGIResources, + *scene, + depthBuffer_Copy, + rtGbuffer, + debugUAV, + cmd + ); + } RenderAO(cmd); if (wiRenderer::GetVariableRateShadingClassification() && device->CheckCapability(GRAPHICSDEVICE_CAPABILITY_VARIABLE_RATE_SHADING_TIER2)) { wiRenderer::ComputeShadingRateClassification( - GetGbuffer_Read(), + rtGbuffer, rtLinearDepth, rtShadingRate, debugUAV, @@ -729,6 +771,7 @@ void RenderPath3D::Render() const depthBuffer_Copy, rtLinearDepth, tiledLightResources.entityTiles_Opaque, + rtGbuffer, rtShadow, cmd, getScreenSpaceShadowRange(), @@ -745,7 +788,7 @@ void RenderPath3D::Render() const rtLinearDepth, depthBuffer_Copy1, tiledLightResources.entityTiles_Opaque, - GetGbuffer_Read(), + rtGbuffer, rtShadow, cmd ); @@ -766,8 +809,13 @@ void RenderPath3D::Render() const cmd = device->BeginCommandList(); wiJobSystem::Execute(ctx, [cmd, this](wiJobArgs args) { wiRenderer::BindCommonResources(cmd); - wiRenderer::RefreshDecalAtlas(*scene, cmd); - wiRenderer::RefreshLightmapAtlas(*scene, cmd); + wiRenderer::UpdateCameraCB( + *camera, + camera_previous, + camera_reflection, + cmd + ); + wiRenderer::RefreshLightmaps(*scene, cmd); wiRenderer::RefreshEnvProbes(visibility_main, cmd); wiRenderer::RefreshImpostors(*scene, cmd); }); @@ -852,15 +900,14 @@ void RenderPath3D::Render() const vp.Height = (float)depthBuffer_Reflection.GetDesc().Height; device->BindViewports(1, &vp, cmd); - device->UnbindResources(TEXSLOT_DEPTH, 1, cmd); device->RenderPassBegin(&renderpass_reflection, cmd); - device->BindResource(PS, &tiledLightResources_planarReflection.entityTiles_Opaque, TEXSLOT_RENDERPATH_ENTITYTILES, cmd); - device->BindResource(PS, wiTextureHelper::getTransparent(), TEXSLOT_RENDERPATH_REFLECTION, cmd); - device->BindResource(PS, wiTextureHelper::getWhite(), TEXSLOT_RENDERPATH_AO, cmd); - device->BindResource(PS, wiTextureHelper::getTransparent(), TEXSLOT_RENDERPATH_SSR, cmd); - device->BindResource(PS, wiTextureHelper::getUINT4(), TEXSLOT_RENDERPATH_RTSHADOW, cmd); + device->BindResource(&tiledLightResources_planarReflection.entityTiles_Opaque, TEXSLOT_RENDERPATH_ENTITYTILES, cmd); + device->BindResource(wiTextureHelper::getTransparent(), TEXSLOT_RENDERPATH_REFLECTION, cmd); + device->BindResource(wiTextureHelper::getWhite(), TEXSLOT_RENDERPATH_AO, cmd); + device->BindResource(wiTextureHelper::getTransparent(), TEXSLOT_RENDERPATH_SSR, cmd); + device->BindResource(wiTextureHelper::getUINT4(), TEXSLOT_RENDERPATH_RTSHADOW, cmd); wiRenderer::DrawScene(visibility_reflection, RENDERPASS_MAIN, cmd, drawscene_flags_reflections); wiRenderer::DrawSky(*scene, cmd); @@ -905,7 +952,7 @@ void RenderPath3D::Render() const *scene, depthBuffer_Copy, depthBuffer_Copy1, - GetGbuffer_Read(), + rtGbuffer, rtSSR, cmd ); @@ -922,19 +969,20 @@ void RenderPath3D::Render() const if (wiRenderer::GetRaytracedShadowsEnabled() || wiRenderer::GetScreenSpaceShadowsEnabled()) { - GPUBarrier barrier = GPUBarrier::Image(&rtShadow, rtShadow.desc.layout, IMAGE_LAYOUT_SHADER_RESOURCE); + GPUBarrier barrier = GPUBarrier::Image(&rtShadow, rtShadow.desc.layout, RESOURCE_STATE_SHADER_RESOURCE); device->Barrier(&barrier, 1, cmd); - device->BindResource(PS, &rtShadow, TEXSLOT_RENDERPATH_RTSHADOW, cmd); + device->BindResource(&rtShadow, TEXSLOT_RENDERPATH_RTSHADOW, cmd); } else { - device->BindResource(PS, wiTextureHelper::getUINT4(), TEXSLOT_RENDERPATH_RTSHADOW, cmd); + device->BindResource(wiTextureHelper::getUINT4(), TEXSLOT_RENDERPATH_RTSHADOW, cmd); } - device->BindResource(PS, &tiledLightResources.entityTiles_Opaque, TEXSLOT_RENDERPATH_ENTITYTILES, cmd); - device->BindResource(PS, getReflectionsEnabled() ? &rtReflection : wiTextureHelper::getTransparent(), TEXSLOT_RENDERPATH_REFLECTION, cmd); - device->BindResource(PS, getAOEnabled() ? &rtAO : wiTextureHelper::getWhite(), TEXSLOT_RENDERPATH_AO, cmd); - device->BindResource(PS, getSSREnabled() || getRaytracedReflectionEnabled() ? &rtSSR : wiTextureHelper::getTransparent(), TEXSLOT_RENDERPATH_SSR, cmd); + device->BindResource(&tiledLightResources.entityTiles_Opaque, TEXSLOT_RENDERPATH_ENTITYTILES, cmd); + device->BindResource(getReflectionsEnabled() ? &rtReflection : wiTextureHelper::getTransparent(), TEXSLOT_RENDERPATH_REFLECTION, cmd); + device->BindResource(getAOEnabled() ? &rtAO : wiTextureHelper::getWhite(), TEXSLOT_RENDERPATH_AO, cmd); + device->BindResource(getSSREnabled() || getRaytracedReflectionEnabled() ? &rtSSR : wiTextureHelper::getTransparent(), TEXSLOT_RENDERPATH_SSR, cmd); + device->BindResource(&surfelGIResources.result, TEXSLOT_RENDERPATH_SURFELGI, cmd); wiRenderer::DrawScene(visibility_main, RENDERPASS_MAIN, cmd, drawscene_flags); wiRenderer::DrawSky(*scene, cmd); @@ -949,7 +997,7 @@ void RenderPath3D::Render() const wiRenderer::Postprocess_Upsample_Bilateral( volumetriccloudResources.texture_temporal[device->GetFrameCount() % 2], rtLinearDepth, - *GetGbuffer_Read(GBUFFER_COLOR), // only desc is taken if pixel shader upsampling is used + rtMain_render, // only desc is taken if pixel shader upsampling is used cmd, true // pixel shader upsampling ); @@ -960,7 +1008,7 @@ void RenderPath3D::Render() const if (wiRenderer::GetRaytracedShadowsEnabled() || wiRenderer::GetScreenSpaceShadowsEnabled()) { - GPUBarrier barrier = GPUBarrier::Image(&rtShadow, IMAGE_LAYOUT_SHADER_RESOURCE, rtShadow.desc.layout); + GPUBarrier barrier = GPUBarrier::Image(&rtShadow, RESOURCE_STATE_SHADER_RESOURCE, rtShadow.desc.layout); device->Barrier(&barrier, 1, cmd); } @@ -990,6 +1038,7 @@ void RenderPath3D::Render() const RenderTransparents(cmd); RenderPostprocessChain(cmd); + }); RenderPath2D::Render(); @@ -1010,7 +1059,11 @@ void RenderPath3D::Compose(CommandList cmd) const wiImage::Draw(GetLastPostprocessRT(), fx, cmd); device->EventEnd(cmd); - if (wiRenderer::GetDebugLightCulling() || wiRenderer::GetVariableRateShadingClassificationDebug()) + if ( + wiRenderer::GetDebugLightCulling() || + wiRenderer::GetVariableRateShadingClassificationDebug() || + wiRenderer::GetSurfelGIDebugEnabled() + ) { fx.enableFullScreen(); fx.blendFlag = BLENDMODE_PREMULTIPLIED; @@ -1024,13 +1077,12 @@ void RenderPath3D::RenderFrameSetUp(CommandList cmd) const { GraphicsDevice* device = wiRenderer::GetDevice(); - device->BindResource(CS, &depthBuffer_Copy1, TEXSLOT_DEPTH, cmd); + device->BindResource(&depthBuffer_Copy1, TEXSLOT_DEPTH, cmd); wiRenderer::UpdateRenderData(visibility_main, frameCB, cmd); } void RenderPath3D::RenderAO(CommandList cmd) const { - wiRenderer::GetDevice()->UnbindResources(TEXSLOT_RENDERPATH_AO, 1, cmd); if (getAOEnabled()) { @@ -1075,7 +1127,7 @@ void RenderPath3D::RenderAO(CommandList cmd) const depthBuffer_Copy, rtLinearDepth, depthBuffer_Copy1, - GetGbuffer_Read(), + rtGbuffer, rtAO, cmd, getAORange(), @@ -1095,7 +1147,7 @@ void RenderPath3D::RenderSSR(CommandList cmd) const depthBuffer_Copy, rtLinearDepth, depthBuffer_Copy1, - GetGbuffer_Read(), + rtGbuffer, rtSSR, cmd ); @@ -1116,7 +1168,6 @@ void RenderPath3D::RenderLightShafts(CommandList cmd) const GraphicsDevice* device = wiRenderer::GetDevice(); device->EventBegin("Light Shafts", cmd); - device->UnbindResources(TEXSLOT_ONDEMAND0, TEXSLOT_ONDEMAND_COUNT, cmd); // Render sun stencil cutout: { @@ -1205,7 +1256,7 @@ void RenderPath3D::RenderSceneMIPChain(CommandList cmd) const fx.sampleFlag = SAMPLEMODE_CLAMP; fx.quality = QUALITY_LINEAR; fx.blendFlag = BLENDMODE_OPAQUE; - wiImage::Draw(GetGbuffer_Read(GBUFFER_COLOR), fx, cmd); + wiImage::Draw(&rtMain, fx, cmd); device->RenderPassEnd(cmd); @@ -1235,8 +1286,6 @@ void RenderPath3D::RenderTransparents(CommandList cmd) const device->RenderPassEnd(cmd); } - device->UnbindResources(TEXSLOT_GBUFFER0, 1, cmd); - device->UnbindResources(TEXSLOT_ONDEMAND0, TEXSLOT_ONDEMAND_COUNT, cmd); device->RenderPassBegin(&renderpass_transparent, cmd); @@ -1250,11 +1299,11 @@ void RenderPath3D::RenderTransparents(CommandList cmd) const auto range = wiProfiler::BeginRangeGPU("Transparent Scene", cmd); device->EventBegin("Transparent Scene", cmd); - device->BindResource(PS, &tiledLightResources.entityTiles_Transparent, TEXSLOT_RENDERPATH_ENTITYTILES, cmd); - device->BindResource(PS, &rtLinearDepth, TEXSLOT_LINEARDEPTH, cmd); - device->BindResource(PS, getReflectionsEnabled() ? &rtReflection : wiTextureHelper::getTransparent(), TEXSLOT_RENDERPATH_REFLECTION, cmd); - device->BindResource(PS, &rtSceneCopy, TEXSLOT_RENDERPATH_REFRACTION, cmd); - device->BindResource(PS, &rtWaterRipple, TEXSLOT_RENDERPATH_WATERRIPPLES, cmd); + device->BindResource(&tiledLightResources.entityTiles_Transparent, TEXSLOT_RENDERPATH_ENTITYTILES, cmd); + device->BindResource(&rtLinearDepth, TEXSLOT_LINEARDEPTH, cmd); + device->BindResource(getReflectionsEnabled() ? &rtReflection : wiTextureHelper::getTransparent(), TEXSLOT_RENDERPATH_REFLECTION, cmd); + device->BindResource(&rtSceneCopy, TEXSLOT_RENDERPATH_REFRACTION, cmd); + device->BindResource(&rtWaterRipple, TEXSLOT_RENDERPATH_WATERRIPPLES, cmd); uint32_t drawscene_flags = 0; drawscene_flags |= wiRenderer::DRAWSCENE_TRANSPARENT; @@ -1323,7 +1372,7 @@ void RenderPath3D::RenderPostprocessChain(CommandList cmd) const GraphicsDevice* device = wiRenderer::GetDevice(); const Texture* rt_first = nullptr; // not ping-ponged with read / write - const Texture* rt_read = GetGbuffer_Read(GBUFFER_COLOR); + const Texture* rt_read = &rtMain; const Texture* rt_write = &rtPostprocess_HDR; // 1.) HDR post process chain @@ -1338,7 +1387,7 @@ void RenderPath3D::RenderPostprocessChain(CommandList cmd) const *rt_read, rtTemporalAA[history], rtLinearDepth, depthBuffer_Copy1, - GetGbuffer_Read(), + rtGbuffer, rtTemporalAA[output], cmd ); @@ -1358,7 +1407,6 @@ void RenderPath3D::RenderPostprocessChain(CommandList cmd) const rt_first = nullptr; std::swap(rt_read, rt_write); - device->UnbindResources(TEXSLOT_ONDEMAND0, 1, cmd); } if (getMotionBlurEnabled() && getMotionBlurStrength() > 0) @@ -1367,7 +1415,7 @@ void RenderPath3D::RenderPostprocessChain(CommandList cmd) const motionblurResources, rt_first == nullptr ? *rt_read : *rt_first, rtLinearDepth, - GetGbuffer_Read(), + rtGbuffer, *rt_write, cmd, getMotionBlurStrength() @@ -1375,7 +1423,6 @@ void RenderPath3D::RenderPostprocessChain(CommandList cmd) const rt_first = nullptr; std::swap(rt_read, rt_write); - device->UnbindResources(TEXSLOT_ONDEMAND0, 1, cmd); } if (getBloomEnabled()) @@ -1390,7 +1437,6 @@ void RenderPath3D::RenderPostprocessChain(CommandList cmd) const rt_first = nullptr; std::swap(rt_read, rt_write); - device->UnbindResources(TEXSLOT_ONDEMAND0, 1, cmd); } } @@ -1406,14 +1452,13 @@ void RenderPath3D::RenderPostprocessChain(CommandList cmd) const getDitherEnabled(), getColorGradingEnabled() ? (scene->weather.colorGradingMap == nullptr ? nullptr : &scene->weather.colorGradingMap->texture) : nullptr, getMSAASampleCount() > 1 ? &rtParticleDistortion_Resolved : &rtParticleDistortion, - getEyeAdaptionEnabled() ? wiRenderer::ComputeLuminance(luminanceResources, *GetGbuffer_Read(GBUFFER_COLOR), cmd, getEyeAdaptionRate()) : nullptr, + getEyeAdaptionEnabled() ? wiRenderer::ComputeLuminance(luminanceResources, rtMain, cmd, getEyeAdaptionRate()) : nullptr, getEyeAdaptionKey() ); rt_first = nullptr; rt_read = rt_write; rt_write = &rtPostprocess_LDR[1]; - device->UnbindResources(TEXSLOT_ONDEMAND0, 1, cmd); } // 3.) LDR post process chain @@ -1423,7 +1468,6 @@ void RenderPath3D::RenderPostprocessChain(CommandList cmd) const wiRenderer::Postprocess_Sharpen(*rt_read, *rt_write, cmd, getSharpenFilterAmount()); std::swap(rt_read, rt_write); - device->UnbindResources(TEXSLOT_ONDEMAND0, 1, cmd); } if (getFXAAEnabled()) @@ -1431,7 +1475,6 @@ void RenderPath3D::RenderPostprocessChain(CommandList cmd) const wiRenderer::Postprocess_FXAA(*rt_read, *rt_write, cmd); std::swap(rt_read, rt_write); - device->UnbindResources(TEXSLOT_ONDEMAND0, 1, cmd); } if (getChromaticAberrationEnabled()) @@ -1439,7 +1482,6 @@ void RenderPath3D::RenderPostprocessChain(CommandList cmd) const wiRenderer::Postprocess_Chromatic_Aberration(*rt_read, *rt_write, cmd, getChromaticAberrationAmount()); std::swap(rt_read, rt_write); - device->UnbindResources(TEXSLOT_ONDEMAND0, 1, cmd); } // GUI Background blurring: @@ -1457,7 +1499,6 @@ void RenderPath3D::RenderPostprocessChain(CommandList cmd) const { wiRenderer::Postprocess_FSR(*rt_read, rtFSR[1], rtFSR[0], cmd, getFSRSharpness()); - device->UnbindResources(TEXSLOT_ONDEMAND0, 1, cmd); } } } @@ -1481,7 +1522,7 @@ void RenderPath3D::setAO(AO value) TextureDesc desc; desc.BindFlags = BIND_SHADER_RESOURCE | BIND_UNORDERED_ACCESS; desc.Format = FORMAT_R8_UNORM; - desc.layout = IMAGE_LAYOUT_SHADER_RESOURCE_COMPUTE; + desc.layout = RESOURCE_STATE_SHADER_RESOURCE_COMPUTE; switch (ao) { diff --git a/WickedEngine/RenderPath3D.h b/WickedEngine/RenderPath3D.h index 2d5902fc7..f774a0663 100644 --- a/WickedEngine/RenderPath3D.h +++ b/WickedEngine/RenderPath3D.h @@ -64,8 +64,10 @@ private: uint32_t msaaSampleCount = 1; public: + wiGraphics::Texture rtMain; + wiGraphics::Texture rtMain_render; // can be MSAA wiGraphics::Texture rtGbuffer[GBUFFER_COUNT]; - wiGraphics::Texture rtGbuffer_resolved[GBUFFER_COUNT]; + wiGraphics::Texture rtPrimitiveID_render; // can be MSAA wiGraphics::Texture rtReflection; // contains the scene rendered for planar reflections wiGraphics::Texture rtSSR; // standard screen-space reflection results wiGraphics::Texture rtSceneCopy; // contains the rendered scene that can be fed into transparent pass for distortion effect @@ -121,29 +123,7 @@ public: wiRenderer::VolumetricCloudResources volumetriccloudResources; wiRenderer::VolumetricCloudResources volumetriccloudResources_reflection; wiRenderer::BloomResources bloomResources; - - const constexpr wiGraphics::Texture* GetGbuffer_Read() const - { - if (getMSAASampleCount() > 1) - { - return rtGbuffer_resolved; - } - else - { - return rtGbuffer; - } - } - const constexpr wiGraphics::Texture* GetGbuffer_Read(GBUFFER i) const - { - if (getMSAASampleCount() > 1) - { - return &rtGbuffer_resolved[i]; - } - else - { - return &rtGbuffer[i]; - } - } + wiRenderer::SurfelGIResources surfelGIResources; // Post-processes are ping-ponged, this function helps to obtain the last postprocess render target that was written const wiGraphics::Texture* GetLastPostprocessRT() const diff --git a/WickedEngine/RenderPath3D_PathTracing.cpp b/WickedEngine/RenderPath3D_PathTracing.cpp index 788c481a3..260555534 100644 --- a/WickedEngine/RenderPath3D_PathTracing.cpp +++ b/WickedEngine/RenderPath3D_PathTracing.cpp @@ -55,7 +55,7 @@ void RenderPath3D_PathTracing::ResizeBuffers() #ifdef OPEN_IMAGE_DENOISE desc.BindFlags = BIND_UNORDERED_ACCESS; - desc.layout = IMAGE_LAYOUT_UNORDERED_ACCESS; + desc.layout = RESOURCE_STATE_UNORDERED_ACCESS; device->CreateTexture(&desc, nullptr, &denoiserAlbedo); device->SetName(&denoiserAlbedo, "denoiserAlbedo"); device->CreateTexture(&desc, nullptr, &denoiserNormal); @@ -93,6 +93,8 @@ void RenderPath3D_PathTracing::ResizeBuffers() device->CreateRenderPass(&desc, &renderpass_debugbvh); } + wiRenderer::CreateLuminanceResources(luminanceResources, internalResolution); + // also reset accumulation buffer state: sam = -1; } @@ -306,25 +308,6 @@ void RenderPath3D_PathTracing::Render() const wiProfiler::EndRange(range); // Traced Scene } - wiRenderer::Postprocess_Tonemap( - denoiserResult.IsValid() ? denoiserResult : traceResult, - rtPostprocess_LDR[0], - cmd, - getExposure(), - getDitherEnabled(), - getColorGradingEnabled() ? (scene->weather.colorGradingMap == nullptr ? nullptr : &scene->weather.colorGradingMap->texture) : nullptr - ); - - // GUI Background blurring: - { - auto range = wiProfiler::BeginRangeGPU("GUI Background Blur", cmd); - device->EventBegin("GUI Background Blur", cmd); - wiRenderer::Postprocess_Downsample4x(rtPostprocess_LDR[0], rtGUIBlurredBackground[0], cmd); - wiRenderer::Postprocess_Downsample4x(rtGUIBlurredBackground[0], rtGUIBlurredBackground[2], cmd); - wiRenderer::Postprocess_Blur_Gaussian(rtGUIBlurredBackground[2], rtGUIBlurredBackground[1], rtGUIBlurredBackground[2], cmd, -1, -1, true); - device->EventEnd(cmd); - wiProfiler::EndRange(range); - } }); } @@ -342,13 +325,18 @@ void RenderPath3D_PathTracing::Render() const ); wiRenderer::BindCommonResources(cmd); + Texture srcTex = denoiserResult.IsValid() && !wiJobSystem::IsBusy(denoiserContext) ? denoiserResult : traceResult; + wiRenderer::Postprocess_Tonemap( - denoiserResult.IsValid() && !wiJobSystem::IsBusy(denoiserContext) ? denoiserResult : traceResult, + srcTex, rtPostprocess_LDR[0], cmd, getExposure(), getDitherEnabled(), - getColorGradingEnabled() ? (scene->weather.colorGradingMap == nullptr ? nullptr : &scene->weather.colorGradingMap->texture) : nullptr + getColorGradingEnabled() ? (scene->weather.colorGradingMap == nullptr ? nullptr : &scene->weather.colorGradingMap->texture) : nullptr, + nullptr, + getEyeAdaptionEnabled() ? wiRenderer::ComputeLuminance(luminanceResources, srcTex, cmd, getEyeAdaptionRate()) : nullptr, + getEyeAdaptionKey() ); // GUI Background blurring: diff --git a/WickedEngine/WickedEngine_SOURCE.vcxitems b/WickedEngine/WickedEngine_SOURCE.vcxitems index b00f37774..16322f20e 100644 --- a/WickedEngine/WickedEngine_SOURCE.vcxitems +++ b/WickedEngine/WickedEngine_SOURCE.vcxitems @@ -262,7 +262,6 @@ - @@ -319,7 +318,6 @@ - @@ -658,7 +656,6 @@ - diff --git a/WickedEngine/WickedEngine_SOURCE.vcxitems.filters b/WickedEngine/WickedEngine_SOURCE.vcxitems.filters index 585df0619..35bc2a001 100644 --- a/WickedEngine/WickedEngine_SOURCE.vcxitems.filters +++ b/WickedEngine/WickedEngine_SOURCE.vcxitems.filters @@ -894,9 +894,6 @@ ENGINE\Graphics\API - - ENGINE\Graphics\API - ENGINE\Graphics @@ -912,9 +909,6 @@ ENGINE\Graphics\API - - ENGINE\Graphics\API - UTILITY @@ -960,9 +954,6 @@ ENGINE\High level interface - - ENGINE\High level interface - ENGINE\High level interface @@ -1086,6 +1077,9 @@ ENGINE\System + + ENGINE\High level interface + @@ -1706,9 +1700,6 @@ ENGINE\Graphics\API - - ENGINE\Graphics\API - ENGINE\Graphics diff --git a/WickedEngine/WickedEngine_Windows.vcxproj b/WickedEngine/WickedEngine_Windows.vcxproj index 2e54b27ba..3c82cb514 100644 --- a/WickedEngine/WickedEngine_Windows.vcxproj +++ b/WickedEngine/WickedEngine_Windows.vcxproj @@ -87,7 +87,8 @@ %(AdditionalLibraryDirectories) - IF NOT EXIST "$(ProjectDir)shaders\" mkdir "$(ProjectDir)shaders\" + + @@ -121,7 +122,8 @@ true - IF NOT EXIST "$(ProjectDir)shaders\" mkdir "$(ProjectDir)shaders\" + + diff --git a/WickedEngine/d3dcompiler_47.dll b/WickedEngine/d3dcompiler_47.dll deleted file mode 100644 index 669763121..000000000 Binary files a/WickedEngine/d3dcompiler_47.dll and /dev/null differ diff --git a/WickedEngine/offlineshadercompiler.cpp b/WickedEngine/offlineshadercompiler.cpp index 79fd87148..261f00758 100644 --- a/WickedEngine/offlineshadercompiler.cpp +++ b/WickedEngine/offlineshadercompiler.cpp @@ -67,7 +67,7 @@ int main(int argc, char* argv[]) if (targets.empty()) { targets = { - { wiGraphics::SHADERFORMAT_HLSL5, "shaders/hlsl5/" }, + //{ wiGraphics::SHADERFORMAT_HLSL5, "shaders/hlsl5/" }, { wiGraphics::SHADERFORMAT_HLSL6, "shaders/hlsl6/" }, { wiGraphics::SHADERFORMAT_SPIRV, "shaders/spirv/" }, }; @@ -113,7 +113,6 @@ int main(int argc, char* argv[]) "ssr_raytraceCS.hlsl" , "sharpenCS.hlsl" , "skinningCS.hlsl" , - "skinningCS_LDS.hlsl" , "resolveMSAADepthStencilCS.hlsl" , "raytraceCS.hlsl" , "raytraceCS_rtapi.hlsl" , @@ -137,7 +136,6 @@ int main(int argc, char* argv[]) "motionblurCS.hlsl" , "motionblurCS_cheap.hlsl" , "motionblurCS_earlyexit.hlsl" , - "lineardepthCS.hlsl" , "luminancePass1CS.hlsl" , "lightShaftsCS.hlsl" , "lightCullingCS_ADVANCED_DEBUG.hlsl" , @@ -224,16 +222,22 @@ int main(int argc, char* argv[]) "rtaoCS.hlsl" , "rtao_denoise_tileclassificationCS.hlsl", "rtao_denoise_filterCS.hlsl", + "visibility_resolveCS.hlsl", + "visibility_resolveCS_MSAA.hlsl", + "surfel_coverageCS.hlsl", + "surfel_indirectprepareCS.hlsl", + "surfel_updateCS.hlsl", + "surfel_gridresetCS.hlsl", + "surfel_gridoffsetsCS.hlsl", + "surfel_binningCS.hlsl", + "surfel_shadeCS.hlsl", + "surfel_raytraceCS_rtapi.hlsl", + "surfel_raytraceCS.hlsl", }; shaders[wiGraphics::PS] = { "emittedparticlePS_soft.hlsl" , "screenPS.hlsl" , - "imagePS_separatenormalmap.hlsl" , - "imagePS_separatenormalmap_bicubic.hlsl" , - "imagePS_backgroundblur_masked.hlsl" , - "imagePS_masked.hlsl" , - "imagePS_backgroundblur.hlsl" , "imagePS.hlsl" , "emittedparticlePS_soft_lighting.hlsl" , "oceanSurfacePS.hlsl" , @@ -248,7 +252,6 @@ int main(int argc, char* argv[]) "sunPS.hlsl" , "skyPS_dynamic.hlsl" , "skyPS_static.hlsl" , - "skyPS_velocity.hlsl" , "shadowPS_transparent.hlsl" , "shadowPS_water.hlsl" , "shadowPS_alphatest.hlsl" , @@ -395,12 +398,8 @@ int main(int argc, char* argv[]) minshadermodels["renderlightmapPS_rtapi.hlsl"] = wiGraphics::SHADERMODEL_6_5; minshadermodels["raytraceCS_rtapi.hlsl"] = wiGraphics::SHADERMODEL_6_5; minshadermodels["rtshadowCS.hlsl"] = wiGraphics::SHADERMODEL_6_5; - minshadermodels["rtshadow_denoise_tileclassificationCS.hlsl"] = wiGraphics::SHADERMODEL_6_0; - minshadermodels["rtshadow_denoise_filterCS.hlsl"] = wiGraphics::SHADERMODEL_6_0; - minshadermodels["rtshadow_denoise_temporalCS.hlsl"] = wiGraphics::SHADERMODEL_6_0; minshadermodels["rtaoCS.hlsl"] = wiGraphics::SHADERMODEL_6_5; - minshadermodels["rtao_denoise_tileclassificationCS.hlsl"] = wiGraphics::SHADERMODEL_6_0; - minshadermodels["rtao_denoise_filterCS.hlsl"] = wiGraphics::SHADERMODEL_6_0; + minshadermodels["surfel_raytraceCS_rtapi.hlsl"] = wiGraphics::SHADERMODEL_6_5; wiShaderCompiler::Initialize(); wiJobSystem::Initialize(); diff --git a/WickedEngine/shaders/CMakeLists.txt b/WickedEngine/shaders/CMakeLists.txt index 105e89d66..7a08ab170 100644 --- a/WickedEngine/shaders/CMakeLists.txt +++ b/WickedEngine/shaders/CMakeLists.txt @@ -39,7 +39,6 @@ set(SHADERS_CS "ssr_raytraceCS.hlsl" "sharpenCS.hlsl" "skinningCS.hlsl" - "skinningCS_LDS.hlsl" "resolveMSAADepthStencilCS.hlsl" "paint_textureCS.hlsl" "raytraceCS.hlsl" @@ -63,7 +62,6 @@ set(SHADERS_CS "motionblurCS.hlsl" "motionblurCS_cheap.hlsl" "motionblurCS_earlyexit.hlsl" - "lineardepthCS.hlsl" "luminancePass1CS.hlsl" "lightShaftsCS.hlsl" "lightCullingCS_ADVANCED_DEBUG.hlsl" @@ -150,16 +148,22 @@ set(SHADERS_CS "rtaoCS.hlsl" "rtao_denoise_tileclassificationCS.hlsl" "rtao_denoise_filterCS.hlsl" + "visibility_resolveCS.hlsl" + "visibility_resolveCS_MSAA.hlsl" + "surfel_coverageCS.hlsl" + "surfel_indirectprepareCS.hlsl" + "surfel_updateCS.hlsl" + "surfel_gridresetCS.hlsl" + "surfel_gridoffsetsCS.hlsl" + "surfel_binningCS.hlsl" + "surfel_shadeCS.hlsl" + "surfel_raytraceCS_rtapi.hlsl" + "surfel_raytraceCS.hlsl" ) set(SHADERS_PS "emittedparticlePS_soft.hlsl" "screenPS.hlsl" - "imagePS_separatenormalmap.hlsl" - "imagePS_separatenormalmap_bicubic.hlsl" - "imagePS_backgroundblur_masked.hlsl" - "imagePS_masked.hlsl" - "imagePS_backgroundblur.hlsl" "imagePS.hlsl" "emittedparticlePS_soft_lighting.hlsl" "oceanSurfacePS.hlsl" @@ -174,7 +178,6 @@ set(SHADERS_PS "sunPS.hlsl" "skyPS_dynamic.hlsl" "skyPS_static.hlsl" - "skyPS_velocity.hlsl" "shadowPS_transparent.hlsl" "shadowPS_water.hlsl" "shadowPS_alphatest.hlsl" diff --git a/WickedEngine/shaders/ConstantBufferMapping.h b/WickedEngine/shaders/ConstantBufferMapping.h index 7225df18c..7ba8bc483 100644 --- a/WickedEngine/shaders/ConstantBufferMapping.h +++ b/WickedEngine/shaders/ConstantBufferMapping.h @@ -13,21 +13,13 @@ // On demand buffers: // These are bound on demand and alive until another is bound at the same slot -#define CBSLOT_IMAGE 3 -#define CBSLOT_FONT 4 #define CBSLOT_RENDERER_MISC 5 -#define CBSLOT_RENDERER_MATERIAL 6 #define CBSLOT_RENDERER_FORWARD_LIGHTMASK 7 #define CBSLOT_RENDERER_VOLUMELIGHT 7 -#define CBSLOT_RENDERER_LENSFLARE 7 -#define CBSLOT_RENDERER_DECAL 7 -#define CBSLOT_RENDERER_TESSELLATION 7 -#define CBSLOT_RENDERER_DISPATCHPARAMS 7 #define CBSLOT_RENDERER_VOXELIZER 7 #define CBSLOT_RENDERER_TRACED 7 #define CBSLOT_RENDERER_BVH 7 -#define CBSLOT_RENDERER_UTILITY 7 #define CBSLOT_RENDERER_POSTPROCESS 7 #define CBSLOT_RENDERER_CUBEMAPRENDER 8 @@ -39,9 +31,6 @@ #define CBSLOT_OTHER_OCEAN_RENDER 7 #define CBSLOT_OTHER_CLOUDGENERATOR 7 #define CBSLOT_OTHER_GPUSORTLIB 8 -#define CBSLOT_RENDERER_MATERIAL_BLEND1 8 -#define CBSLOT_RENDERER_MATERIAL_BLEND2 9 -#define CBSLOT_RENDERER_MATERIAL_BLEND3 10 diff --git a/WickedEngine/shaders/ResourceMapping.h b/WickedEngine/shaders/ResourceMapping.h index 4dae4baf7..6a3e1e66c 100644 --- a/WickedEngine/shaders/ResourceMapping.h +++ b/WickedEngine/shaders/ResourceMapping.h @@ -13,34 +13,35 @@ #define TEXSLOT_GBUFFER0 2 #define TEXSLOT_GBUFFER1 3 -#define TEXSLOT_GBUFFER2 4 -#define TEXSLOT_ACCELERATION_STRUCTURE 5 -#define TEXSLOT_GLOBALENVMAP 6 -#define TEXSLOT_GLOBALLIGHTMAP 7 -#define TEXSLOT_ENVMAPARRAY 8 -#define TEXSLOT_DECALATLAS 9 -#define TEXSLOT_SKYVIEWLUT 10 -#define TEXSLOT_TRANSMITTANCELUT 11 -#define TEXSLOT_MULTISCATTERINGLUT 12 -#define TEXSLOT_SKYLUMINANCELUT 13 +#define TEXSLOT_ACCELERATION_STRUCTURE 4 +#define TEXSLOT_BVH_COUNTER 4 +#define TEXSLOT_BVH_PRIMITIVES 5 +#define TEXSLOT_BVH_NODES 6 -#define TEXSLOT_SHADOWARRAY_2D 14 -#define TEXSLOT_SHADOWARRAY_CUBE 15 -#define TEXSLOT_SHADOWARRAY_TRANSPARENT_2D 16 -#define TEXSLOT_SHADOWARRAY_TRANSPARENT_CUBE 17 +#define SBSLOT_ENTITYARRAY 7 +#define SBSLOT_MATRIXARRAY 8 -#define TEXSLOT_VOXELRADIANCE 18 +#define TEXSLOT_SHADOWARRAY_2D 12 +#define TEXSLOT_SHADOWARRAY_CUBE 13 +#define TEXSLOT_SHADOWARRAY_TRANSPARENT_2D 14 +#define TEXSLOT_SHADOWARRAY_TRANSPARENT_CUBE 15 -#define TEXSLOT_SHEENLUT 19 +#define TEXSLOT_SKYVIEWLUT 16 +#define TEXSLOT_TRANSMITTANCELUT 17 +#define TEXSLOT_MULTISCATTERINGLUT 18 +#define TEXSLOT_SKYLUMINANCELUT 19 + +#define TEXSLOT_SHEENLUT 20 +#define TEXSLOT_BLUENOISE 21 +#define TEXSLOT_RANDOM64X64 22 + +#define TEXSLOT_VOXELGI 23 + +#define TEXSLOT_FONTATLAS 29 -#define SBSLOT_ENTITYARRAY 20 -#define SBSLOT_MATRIXARRAY 21 -#define TEXSLOT_FONTATLAS 22 -#define TEXSLOT_BLUENOISE 23 -#define TEXSLOT_RANDOM64X64 24 // Ondemand textures are 2d textures and declared in shader globals, these can be used independently in any shader: #define TEXSLOT_ONDEMAND0 30 @@ -87,37 +88,6 @@ #define SKINNINGSLOT_IN_VERTEX_BON TEXSLOT_ONDEMAND2 #define SKINNINGSLOT_IN_BONEBUFFER TEXSLOT_ONDEMAND3 - -// wiRenderer object shader resources: -#define TEXSLOT_RENDERER_BASECOLORMAP TEXSLOT_ONDEMAND0 -#define TEXSLOT_RENDERER_NORMALMAP TEXSLOT_ONDEMAND1 -#define TEXSLOT_RENDERER_SURFACEMAP TEXSLOT_ONDEMAND2 -#define TEXSLOT_RENDERER_EMISSIVEMAP TEXSLOT_ONDEMAND3 -#define TEXSLOT_RENDERER_DISPLACEMENTMAP TEXSLOT_ONDEMAND4 -#define TEXSLOT_RENDERER_OCCLUSIONMAP TEXSLOT_ONDEMAND5 -#define TEXSLOT_RENDERER_TRANSMISSIONMAP TEXSLOT_ONDEMAND6 -#define TEXSLOT_RENDERER_SHEENCOLORMAP TEXSLOT_ONDEMAND7 -#define TEXSLOT_RENDERER_SHEENROUGHNESSMAP TEXSLOT_ONDEMAND8 -#define TEXSLOT_RENDERER_CLEARCOATMAP TEXSLOT_ONDEMAND9 -#define TEXSLOT_RENDERER_CLEARCOATROUGHNESSMAP TEXSLOT_ONDEMAND10 -#define TEXSLOT_RENDERER_CLEARCOATNORMALMAP TEXSLOT_ONDEMAND11 -#define TEXSLOT_RENDERER_SPECULARMAP TEXSLOT_ONDEMAND12 - -#define TEXSLOT_RENDERER_BLEND1_BASECOLORMAP TEXSLOT_ONDEMAND20 -#define TEXSLOT_RENDERER_BLEND1_NORMALMAP TEXSLOT_ONDEMAND21 -#define TEXSLOT_RENDERER_BLEND1_SURFACEMAP TEXSLOT_ONDEMAND22 -#define TEXSLOT_RENDERER_BLEND1_EMISSIVEMAP TEXSLOT_ONDEMAND23 - -#define TEXSLOT_RENDERER_BLEND2_BASECOLORMAP TEXSLOT_ONDEMAND24 -#define TEXSLOT_RENDERER_BLEND2_NORMALMAP TEXSLOT_ONDEMAND25 -#define TEXSLOT_RENDERER_BLEND2_SURFACEMAP TEXSLOT_ONDEMAND26 -#define TEXSLOT_RENDERER_BLEND2_EMISSIVEMAP TEXSLOT_ONDEMAND27 - -#define TEXSLOT_RENDERER_BLEND3_BASECOLORMAP TEXSLOT_ONDEMAND28 -#define TEXSLOT_RENDERER_BLEND3_NORMALMAP TEXSLOT_ONDEMAND29 -#define TEXSLOT_RENDERER_BLEND3_SURFACEMAP TEXSLOT_ONDEMAND30 -#define TEXSLOT_RENDERER_BLEND3_EMISSIVEMAP TEXSLOT_ONDEMAND31 - // RenderPath texture mappings: #define TEXSLOT_RENDERPATH_ENTITYTILES TEXSLOT_ONDEMAND13 #define TEXSLOT_RENDERPATH_REFLECTION TEXSLOT_ONDEMAND14 @@ -126,6 +96,7 @@ #define TEXSLOT_RENDERPATH_AO TEXSLOT_ONDEMAND17 #define TEXSLOT_RENDERPATH_SSR TEXSLOT_ONDEMAND18 #define TEXSLOT_RENDERPATH_RTSHADOW TEXSLOT_ONDEMAND19 +#define TEXSLOT_RENDERPATH_SURFELGI TEXSLOT_ONDEMAND20 // wiImage: #define TEXSLOT_IMAGE_BASE TEXSLOT_ONDEMAND0 diff --git a/WickedEngine/shaders/ShaderInterop.h b/WickedEngine/shaders/ShaderInterop.h index a1e2b8f75..ce8556fb5 100644 --- a/WickedEngine/shaders/ShaderInterop.h +++ b/WickedEngine/shaders/ShaderInterop.h @@ -11,6 +11,7 @@ // Application-side types: typedef XMMATRIX matrix; +typedef XMFLOAT3X4 float3x4; typedef XMFLOAT4X4 float4x4; typedef XMFLOAT2 float2; typedef XMFLOAT3 float3; @@ -23,10 +24,13 @@ typedef XMINT2 int2; typedef XMINT3 int3; typedef XMINT4 int4; +#define column_major +#define row_major + #define CB_GETBINDSLOT(name) __CBUFFERBINDSLOT__##name##__ #define CBUFFER(name, slot) static const int CB_GETBINDSLOT(name) = slot; struct alignas(16) name -#define CONSTANTBUFFER(name, type, slot) CBUFFER(name, slot) -#define ROOTCONSTANTS(name, type, slot) CBUFFER(name, slot) +#define CONSTANTBUFFER(name, type, slot) +#define PUSHCONSTANT(name, type) #else diff --git a/WickedEngine/shaders/ShaderInterop_BVH.h b/WickedEngine/shaders/ShaderInterop_BVH.h index 9e5c670f1..02055e422 100644 --- a/WickedEngine/shaders/ShaderInterop_BVH.h +++ b/WickedEngine/shaders/ShaderInterop_BVH.h @@ -1,55 +1,45 @@ #ifndef WI_SHADERINTEROP_BVH_H #define WI_SHADERINTEROP_BVH_H -#include "ShaderInterop.h" +#include "ShaderInterop_Renderer.h" + +struct BVHPushConstants +{ + uint instanceIndex; + uint subsetIndex; + uint primitiveCount; + uint primitiveOffset; +}; static const uint BVH_BUILDER_GROUPSIZE = 64; -CBUFFER(BVHCB, CBSLOT_RENDERER_BVH) -{ - float4x4 xBVHWorld; - float4 xBVHInstanceColor; - uint xBVHMaterialOffset; - uint xBVHMeshTriangleOffset; - uint xBVHMeshTriangleCount; - uint xBVHMeshVertexPOSStride; -}; - +static const uint BVH_PRIMITIVE_FLAG_DOUBLE_SIDED = 1 << 0; +static const uint BVH_PRIMITIVE_FLAG_TRANSPARENT = 1 << 1; struct BVHPrimitive { + uint2 packed_prim; + uint flags; float x0; + float y0; float z0; float x1; - float y1; + float z1; float x2; float y2; - - // This layout is good because if we only want to load normals, then the first 8 floats can be skipped float z2; - uint n0; - uint n1; - uint n2; float3 v0() { return float3(x0, y0, z0); } float3 v1() { return float3(x1, y1, z1); } float3 v2() { return float3(x2, y2, z2); } -}; -struct BVHPrimitiveData -{ - uint2 u0; - uint2 u1; - - uint2 u2; - uint c0; - uint c1; - - uint c2; - uint tangent; - uint binormal; - uint materialIndex; + PrimitiveID primitiveID() + { + PrimitiveID prim; + prim.unpack(packed_prim); + return prim; + } }; struct BVHNode diff --git a/WickedEngine/shaders/ShaderInterop_EmittedParticle.h b/WickedEngine/shaders/ShaderInterop_EmittedParticle.h index b000784a0..d847236b5 100644 --- a/WickedEngine/shaders/ShaderInterop_EmittedParticle.h +++ b/WickedEngine/shaders/ShaderInterop_EmittedParticle.h @@ -44,17 +44,17 @@ CBUFFER(EmittedParticleCB, CBSLOT_OTHER_EMITTEDPARTICLE) float xParticleSize; float xParticleScaling; float xParticleRotation; - uint xParticleColor; - float xParticleRandomFactor; + float xParticleNormalFactor; float xParticleLifeSpan; float xParticleLifeSpanRandomness; - float xParticleMass; + float xParticleMotionBlurAmount; - float xEmitterOpacity; uint xEmitterMaxParticleCount; + uint xEmitterMaterialIndex; + uint xEmitter_padding1; uint2 xEmitterFramesXY; uint xEmitterFrameCount; @@ -77,7 +77,7 @@ CBUFFER(EmittedParticleCB, CBSLOT_OTHER_EMITTEDPARTICLE) float xSPH_e; // viscosity constant uint xEmitterOptions; float xEmitterFixedTimestep; // we can force a fixed timestep (>0) onto the simulation to avoid blowing up - float xParticleEmissive; + float xEmitter_padding2; float3 xParticleGravity; float xParticleDrag; diff --git a/WickedEngine/shaders/ShaderInterop_Font.h b/WickedEngine/shaders/ShaderInterop_Font.h index ab9e3477e..5f6c94a49 100644 --- a/WickedEngine/shaders/ShaderInterop_Font.h +++ b/WickedEngine/shaders/ShaderInterop_Font.h @@ -1,17 +1,16 @@ #ifndef WI_SHADERINTEROP_FONT_H #define WI_SHADERINTEROP_FONT_H - #include "ShaderInterop.h" -CBUFFER(FontCB, CBSLOT_FONT) +struct PushConstantsFont { - float4x4 g_xFont_Transform; - float4 g_xFont_Color; - uint g_xFont_BufferOffset; - int g_xFont_TextureIndex; - float g_xFont_padding0; - float g_xFont_padding1; + float4x4 transform; + uint color; + int buffer_index; + uint buffer_offset; + int texture_index; }; +PUSHCONSTANT(push, PushConstantsFont); #endif // WI_SHADERINTEROP_FONT_H diff --git a/WickedEngine/shaders/ShaderInterop_HairParticle.h b/WickedEngine/shaders/ShaderInterop_HairParticle.h index 1f644e566..c0400913d 100644 --- a/WickedEngine/shaders/ShaderInterop_HairParticle.h +++ b/WickedEngine/shaders/ShaderInterop_HairParticle.h @@ -5,24 +5,19 @@ #define THREADCOUNT_SIMULATEHAIR 256 -struct Patch +struct PatchSimulationData { float3 position; uint tangent_random; float3 normal; // need high precision for the simulation! uint binormal_length; -}; - -struct PatchSimulationData -{ float3 velocity; uint padding; }; CBUFFER(HairParticleCB, CBSLOT_OTHER_HAIRPARTICLE) { - float4x4 xWorld; - float4 xColor; + float4x4 xHairWorld; uint xHairRegenerate; float xLength; @@ -46,6 +41,11 @@ CBUFFER(HairParticleCB, CBSLOT_OTHER_HAIRPARTICLE) float2 xHairTexMul; float xHairAspect; uint xHairLayerMask; + + uint xHairInstanceIndex; + uint padding0; + uint padding1; + uint padding2; }; #endif // WI_SHADERINTEROP_HAIRPARTICLE_H diff --git a/WickedEngine/shaders/ShaderInterop_Image.h b/WickedEngine/shaders/ShaderInterop_Image.h index 49502dce7..7c5057b83 100644 --- a/WickedEngine/shaders/ShaderInterop_Image.h +++ b/WickedEngine/shaders/ShaderInterop_Image.h @@ -2,21 +2,23 @@ #define WI_SHADERINTEROP_IMAGE_H #include "ShaderInterop.h" -CBUFFER(ImageCB, CBSLOT_IMAGE) -{ - float4 xCorners[4]; - float4 xTexMulAdd; - float4 xTexMulAdd2; - float4 xColor; -}; +static const uint IMAGE_FLAG_EXTRACT_NORMALMAP = 1 << 0; struct PushConstantsImage { - int texture_base_index; - int texture_mask_index; - int texture_background_index; - int sampler_index; + float4 corners[4]; + float4 texMulAdd; + float4 texMulAdd2; + + uint2 packed_color; // packed half4 + uint flags; + int sampler_index; + + int texture_base_index; + int texture_mask_index; + int texture_background_index; }; +PUSHCONSTANT(push, PushConstantsImage); #endif // WI_SHADERINTEROP_IMAGE_H diff --git a/WickedEngine/shaders/ShaderInterop_Paint.h b/WickedEngine/shaders/ShaderInterop_Paint.h deleted file mode 100644 index 83e5d4761..000000000 --- a/WickedEngine/shaders/ShaderInterop_Paint.h +++ /dev/null @@ -1,27 +0,0 @@ -#ifndef WI_SHADERINTEROP_PAINT_H -#define WI_SHADERINTEROP_PAINT_H -#include "ShaderInterop.h" - -static const uint PAINT_TEXTURE_BLOCKSIZE = 8; - -CBUFFER(PaintTextureCB, CBSLOT_RENDERER_UTILITY) -{ - uint2 xPaintBrushCenter; - uint xPaintBrushRadius; - float xPaintBrushAmount; - - float xPaintBrushFalloff; - uint xPaintBrushColor; - uint2 padding0; -}; - -CBUFFER(PaintRadiusCB, CBSLOT_RENDERER_UTILITY) -{ - uint2 xPaintRadResolution; - uint2 xPaintRadCenter; - uint xPaintRadUVSET; - float xPaintRadRadius; - uint2 pad; -}; - -#endif // WI_SHADERINTEROP_PAINT_H diff --git a/WickedEngine/shaders/ShaderInterop_Renderer.h b/WickedEngine/shaders/ShaderInterop_Renderer.h index c4e892227..d8d1108b9 100644 --- a/WickedEngine/shaders/ShaderInterop_Renderer.h +++ b/WickedEngine/shaders/ShaderInterop_Renderer.h @@ -2,6 +2,18 @@ #define WI_SHADERINTEROP_RENDERER_H #include "ShaderInterop.h" +struct ShaderScene +{ + int instancebuffer; + int meshbuffer; + int materialbuffer; + int TLAS; + + int envmaparray; + int globalenvmap; + int padding1; + int padding2; +}; static const uint SHADERMATERIAL_OPTION_BIT_USE_VERTEXCOLORS = 1 << 0; static const uint SHADERMATERIAL_OPTION_BIT_SPECULARGLOSSINESS_WORKFLOW = 1 << 1; @@ -10,6 +22,8 @@ static const uint SHADERMATERIAL_OPTION_BIT_OCCLUSION_SECONDARY = 1 << 3; static const uint SHADERMATERIAL_OPTION_BIT_USE_WIND = 1 << 4; static const uint SHADERMATERIAL_OPTION_BIT_RECEIVE_SHADOW = 1 << 5; static const uint SHADERMATERIAL_OPTION_BIT_CAST_SHADOW = 1 << 6; +static const uint SHADERMATERIAL_OPTION_BIT_DOUBLE_SIDED = 1 << 7; +static const uint SHADERMATERIAL_OPTION_BIT_TRANSPARENT = 1 << 8; struct ShaderMaterial { @@ -96,6 +110,8 @@ struct ShaderMaterial inline bool IsCastingShadow() { return options & SHADERMATERIAL_OPTION_BIT_CAST_SHADOW; } }; +static const uint SHADERMESH_FLAG_DOUBLE_SIDED = 1 << 0; + struct ShaderMesh { int ib; @@ -109,25 +125,193 @@ struct ShaderMesh int vb_pre; int subsetbuffer; - int blendmaterial1; - int blendmaterial2; - int blendmaterial3; + uint blendmaterial1; + uint blendmaterial2; + uint blendmaterial3; + + float3 aabb_min; + uint flags; + float3 aabb_max; + float tessellation_factor; + + void init() + { + ib = -1; + vb_pos_nor_wind = -1; + vb_tan = -1; + vb_col = -1; + + vb_uv0 = -1; + vb_uv1 = -1; + vb_atl = -1; + vb_pre = -1; + + subsetbuffer = -1; + blendmaterial1 = 0; + blendmaterial2 = 0; + blendmaterial3 = 0; + + aabb_min = float3(0, 0, 0); + aabb_max = float3(0, 0, 0); + + flags = 0; + } }; struct ShaderMeshSubset { uint indexOffset; - uint indexCount; - int mesh; - int material; + uint materialIndex; + + void init() + { + indexOffset = 0; + materialIndex = 0; + } +}; + +struct ShaderTransform +{ + float4 mat0; + float4 mat1; + float4 mat2; + + void init() + { + mat0 = float4(1, 0, 0, 0); + mat1 = float4(0, 1, 0, 0); + mat2 = float4(0, 0, 1, 0); + } + void Create(float4x4 mat) + { + mat0 = float4(mat._11, mat._21, mat._31, mat._41); + mat1 = float4(mat._12, mat._22, mat._32, mat._42); + mat2 = float4(mat._13, mat._23, mat._33, mat._43); + } + float4x4 GetMatrix() +#ifdef __cplusplus + const +#endif // __cplusplus + { + return float4x4( + mat0.x, mat0.y, mat0.z, mat0.w, + mat1.x, mat1.y, mat1.z, mat1.w, + mat2.x, mat2.y, mat2.z, mat2.w, + 0, 0, 0, 1 + ); + } +}; + +struct ShaderMeshInstance +{ + uint uid; + uint flags; + uint meshIndex; + uint color; + uint emissive; + int lightmap; + int padding0; + int padding1; + ShaderTransform transform; + ShaderTransform transformInverseTranspose; // This correctly handles non uniform scaling for normals + ShaderTransform transformPrev; + + void init() + { + uid = 0; + flags = 0; + meshIndex = ~0; + color = ~0u; + emissive = ~0u; + lightmap = -1; + transform.init(); + transformInverseTranspose.init(); + transformPrev.init(); + } + +}; +struct ShaderMeshInstancePointer +{ + uint instanceID; + uint userdata; + + void init() + { + instanceID = ~0; + userdata = 0; + } + void Create(uint _instanceID, uint frustum_index, float dither) + { + instanceID = _instanceID; + userdata = 0; + userdata |= frustum_index & 0xF; + userdata |= (uint(dither * 255.0f) & 0xFF) << 4u; + } + uint GetFrustumIndex() + { + return userdata & 0xF; + } + float GetDither() + { + return ((userdata >> 4u) & 0xFF) / 255.0f; + } }; struct ObjectPushConstants { - int mesh; - int material; + uint meshIndex_subsetIndex; // 24-bit mesh, 8-bit subset + uint materialIndex; int instances; uint instance_offset; + + void init( + uint _meshIndex, + uint _subsetIndex, + uint _materialIndex, + int _instances, + uint _instance_offset + ) + { + meshIndex_subsetIndex = 0; + meshIndex_subsetIndex |= _meshIndex & 0xFFFFFF; + meshIndex_subsetIndex |= (_subsetIndex & 0xFF) << 24u; + materialIndex = _materialIndex; + instances = _instances; + instance_offset = _instance_offset; + } + uint GetMeshIndex() + { + return meshIndex_subsetIndex & 0xFFFFFF; + } + uint GetSubsetIndex() + { + return (meshIndex_subsetIndex >> 24u) & 0xFF; + } + uint GetMaterialIndex() + { + return materialIndex; + } +}; + +struct PrimitiveID +{ + uint primitiveIndex; + uint instanceIndex; + uint subsetIndex; + + uint2 pack() + { + // 32 bit primitiveID + // 24 bit instanceID + // 8 bit subsetID + return uint2(primitiveIndex, (instanceIndex & 0xFFFFFF) | ((subsetIndex & 0xFF) << 24u)); + } + void unpack(uint2 value) + { + primitiveIndex = value.x; + instanceIndex = value.y & 0xFFFFFF; + subsetIndex = (value.y >> 24u) & 0xFF; + } }; // Warning: the size of this structure directly affects shader performance. @@ -525,7 +709,7 @@ struct VolumetricCloudParameters }; -// These option bits can be read from g_xFrame_Options constant buffer value: +// These option bits can be read from Options constant buffer value: static const uint OPTION_BIT_TEMPORALAA_ENABLED = 1 << 0; static const uint OPTION_BIT_TRANSPARENTSHADOWS_ENABLED = 1 << 1; static const uint OPTION_BIT_VOXELGI_ENABLED = 1 << 2; @@ -535,126 +719,130 @@ static const uint OPTION_BIT_SIMPLE_SKY = 1 << 5; static const uint OPTION_BIT_REALISTIC_SKY = 1 << 6; static const uint OPTION_BIT_HEIGHT_FOG = 1 << 7; static const uint OPTION_BIT_RAYTRACED_SHADOWS = 1 << 8; -static const uint OPTION_BIT_DISABLE_ALBEDO_MAPS = 1 << 9; -static const uint OPTION_BIT_SHADOW_MASK = 1 << 10; +static const uint OPTION_BIT_SHADOW_MASK = 1 << 9; +static const uint OPTION_BIT_SURFELGI_ENABLED = 1 << 10; +static const uint OPTION_BIT_DISABLE_ALBEDO_MAPS = 1 << 11; +static const uint OPTION_BIT_FORCE_DIFFUSE_LIGHTING = 1 << 12; // ---------- Common Constant buffers: ----------------- -CBUFFER(FrameCB, CBSLOT_RENDERER_FRAME) +struct FrameCB { - float2 g_xFrame_CanvasSize; - float2 g_xFrame_CanvasSize_rcp; + float2 CanvasSize; + float2 CanvasSize_rcp; - float2 g_xFrame_InternalResolution; - float2 g_xFrame_InternalResolution_rcp; + float2 InternalResolution; + float2 InternalResolution_rcp; - float3 g_xFrame_SunColor; - float g_xFrame_Gamma; + float3 SunColor; + float Gamma; - float3 g_xFrame_SunDirection; - uint g_xFrame_ShadowCascadeCount; + float3 SunDirection; + uint ShadowCascadeCount; - float3 g_xFrame_Horizon; - uint g_xFrame_ConstantOne; // Just a constant 1 value as uint (can be used to force disable loop unrolling) + float3 Horizon; + uint ConstantOne; // Just a constant 1 value as uint (can be used to force disable loop unrolling) - float3 g_xFrame_Zenith; - float g_xFrame_CloudScale; + float3 Zenith; + float CloudScale; - float3 g_xFrame_Ambient; - float g_xFrame_Cloudiness; + float3 Ambient; + float Cloudiness; - float4 g_xFrame_Fog; // Fog Start,End,Height Start,Height End + float4 Fog; // Fog Start,End,Height Start,Height End - float g_xFrame_padding0; - float g_xFrame_FogHeightSky; - float g_xFrame_SkyExposure; - float g_xFrame_VoxelRadianceMaxDistance; // maximum raymarch distance for voxel GI in world-space + float padding0; + float FogHeightSky; + float SkyExposure; + float VoxelRadianceMaxDistance; // maximum raymarch distance for voxel GI in world-space - float g_xFrame_VoxelRadianceDataSize; // voxel half-extent in world space units - float g_xFrame_VoxelRadianceDataSize_rcp; // 1.0 / voxel-half extent - uint g_xFrame_VoxelRadianceDataRes; // voxel grid resolution - float g_xFrame_VoxelRadianceDataRes_rcp; // 1.0 / voxel grid resolution + float VoxelRadianceDataSize; // voxel half-extent in world space units + float VoxelRadianceDataSize_rcp; // 1.0 / voxel-half extent + uint VoxelRadianceDataRes; // voxel grid resolution + float VoxelRadianceDataRes_rcp; // 1.0 / voxel grid resolution - uint g_xFrame_VoxelRadianceDataMIPs; // voxel grid mipmap count - uint g_xFrame_VoxelRadianceNumCones; // number of diffuse cones to trace - float g_xFrame_VoxelRadianceNumCones_rcp; // 1.0 / number of diffuse cones to trace - float g_xFrame_VoxelRadianceRayStepSize; // raymarch step size in voxel space units + uint VoxelRadianceDataMIPs; // voxel grid mipmap count + uint VoxelRadianceNumCones; // number of diffuse cones to trace + float VoxelRadianceNumCones_rcp; // 1.0 / number of diffuse cones to trace + float VoxelRadianceRayStepSize; // raymarch step size in voxel space units - float3 g_xFrame_VoxelRadianceDataCenter; // center of the voxel grid in world space units - uint g_xFrame_Options; // wiRenderer bool options packed into bitmask + float3 VoxelRadianceDataCenter; // center of the voxel grid in world space units + uint Options; // wiRenderer bool options packed into bitmask - uint3 g_xFrame_EntityCullingTileCount; - int g_xFrame_GlobalEnvProbeIndex; + uint3 EntityCullingTileCount; + int GlobalEnvProbeIndex; - uint g_xFrame_EnvProbeMipCount; - float g_xFrame_EnvProbeMipCount_rcp; - float g_xFrame_Time; - float g_xFrame_TimePrev; + uint EnvProbeMipCount; + float EnvProbeMipCount_rcp; + float Time; + float TimePrev; - float g_xFrame_SunEnergy; - float g_xFrame_WindSpeed; - float g_xFrame_DeltaTime; - uint g_xFrame_FrameCount; + float SunEnergy; + float WindSpeed; + float DeltaTime; + uint FrameCount; - uint g_xFrame_LightArrayOffset; // indexing into entity array - uint g_xFrame_LightArrayCount; // indexing into entity array - uint g_xFrame_DecalArrayOffset; // indexing into entity array - uint g_xFrame_DecalArrayCount; // indexing into entity array + uint LightArrayOffset; // indexing into entity array + uint LightArrayCount; // indexing into entity array + uint DecalArrayOffset; // indexing into entity array + uint DecalArrayCount; // indexing into entity array - uint g_xFrame_ForceFieldArrayOffset; // indexing into entity array - uint g_xFrame_ForceFieldArrayCount; // indexing into entity array - uint g_xFrame_EnvProbeArrayOffset; // indexing into entity array - uint g_xFrame_EnvProbeArrayCount; // indexing into entity array + uint ForceFieldArrayOffset; // indexing into entity array + uint ForceFieldArrayCount; // indexing into entity array + uint EnvProbeArrayOffset; // indexing into entity array + uint EnvProbeArrayCount; // indexing into entity array - float3 g_xFrame_WindDirection; - float g_xFrame_WindWaveSize; + float3 WindDirection; + float WindWaveSize; - float3 g_xFrame_WorldBoundsMin; // world enclosing AABB min - float g_xFrame_CloudSpeed; + float3 WorldBoundsMin; // world enclosing AABB min + float CloudSpeed; - float3 g_xFrame_WorldBoundsMax; // world enclosing AABB max - float g_xFrame_WindRandomness; + float3 WorldBoundsMax; // world enclosing AABB max + float WindRandomness; - float3 g_xFrame_WorldBoundsExtents; // world enclosing AABB abs(max - min) - float g_xFrame_StaticSkyGamma; // possible values (0: no static sky; 1: hdr static sky; other: actual gamma when ldr) + float3 WorldBoundsExtents; // world enclosing AABB abs(max - min) + float StaticSkyGamma; // possible values (0: no static sky; 1: hdr static sky; other: actual gamma when ldr) - float3 g_xFrame_WorldBoundsExtents_rcp; // world enclosing AABB 1.0f / abs(max - min) - uint g_xFrame_TemporalAASampleRotation; + float3 WorldBoundsExtents_rcp; // world enclosing AABB 1.0f / abs(max - min) + uint TemporalAASampleRotation; - float g_xFrame_ShadowKernel2D; - float g_xFrame_ShadowKernelCube; - int g_xFrame_ObjectShaderSamplerIndex; - float g_xFrame_BlueNoisePhase; + float ShadowKernel2D; + float ShadowKernelCube; + int ObjectShaderSamplerIndex; + float BlueNoisePhase; - AtmosphereParameters g_xFrame_Atmosphere; - VolumetricCloudParameters g_xFrame_VolumetricClouds; + AtmosphereParameters Atmosphere; + VolumetricCloudParameters VolumetricClouds; + + ShaderScene scene; }; -CBUFFER(CameraCB, CBSLOT_RENDERER_CAMERA) +struct CameraCB { - float4x4 g_xCamera_VP; // View*Projection + float4x4 VP; // View*Projection - float4 g_xCamera_ClipPlane; + float4 ClipPlane; - float3 g_xCamera_CamPos; - float g_xCamera_DistanceFromOrigin; + float3 CamPos; + float DistanceFromOrigin; - float3 g_xCamera_At; - float g_xCamera_ZNearP; + float3 At; + float ZNearP; - float3 g_xCamera_Up; - float g_xCamera_ZFarP; + float3 Up; + float ZFarP; - float g_xCamera_ZNearP_rcp; - float g_xCamera_ZFarP_rcp; - float g_xCamera_ZRange; - float g_xCamera_ZRange_rcp; + float ZNearP_rcp; + float ZFarP_rcp; + float ZRange; + float ZRange_rcp; - float4x4 g_xCamera_View; - float4x4 g_xCamera_Proj; - float4x4 g_xCamera_InvV; // Inverse View - float4x4 g_xCamera_InvP; // Inverse Projection - float4x4 g_xCamera_InvVP; // Inverse View-Projection + float4x4 View; + float4x4 Proj; + float4x4 InvV; // Inverse View + float4x4 InvP; // Inverse Projection + float4x4 InvVP; // Inverse View-Projection // Frustum planes: // 0 : near @@ -663,45 +851,30 @@ CBUFFER(CameraCB, CBSLOT_RENDERER_CAMERA) // 3 : right // 4 : top // 5 : bottom - float4 g_xCamera_FrustumPlanes[6]; + float4 FrustumPlanes[6]; - float2 g_xFrame_TemporalAAJitter; - float2 g_xFrame_TemporalAAJitterPrev; + float2 TemporalAAJitter; + float2 TemporalAAJitterPrev; - float4x4 g_xCamera_PrevV; - float4x4 g_xCamera_PrevP; - float4x4 g_xCamera_PrevVP; // PrevView*PrevProjection - float4x4 g_xCamera_PrevInvVP; // Inverse(PrevView*PrevProjection) - float4x4 g_xCamera_ReflVP; // ReflectionView*ReflectionProjection - float4x4 g_xCamera_Reprojection; // view_projection_inverse_matrix * previous_view_projection_matrix + float4x4 PrevV; + float4x4 PrevP; + float4x4 PrevVP; // PrevView*PrevProjection + float4x4 PrevInvVP; // Inverse(PrevView*PrevProjection) + float4x4 ReflVP; // ReflectionView*ReflectionProjection + float4x4 Reprojection; // view_projection_inverse_matrix * previous_view_projection_matrix - float2 g_xCamera_ApertureShape; - float g_xCamera_ApertureSize; - float g_xCamera_FocalLength; + float2 ApertureShape; + float ApertureSize; + float FocalLength; }; +CONSTANTBUFFER(g_xFrame, FrameCB, CBSLOT_RENDERER_FRAME); +CONSTANTBUFFER(g_xCamera, CameraCB, CBSLOT_RENDERER_CAMERA); // ------- On demand Constant buffers: ---------- -CBUFFER(MaterialCB, CBSLOT_RENDERER_MATERIAL) -{ - ShaderMaterial g_xMaterial; -}; -CBUFFER(MaterialCB_Blend1, CBSLOT_RENDERER_MATERIAL_BLEND1) -{ - ShaderMaterial g_xMaterial_blend1; -}; -CBUFFER(MaterialCB_Blend2, CBSLOT_RENDERER_MATERIAL_BLEND2) -{ - ShaderMaterial g_xMaterial_blend2; -}; -CBUFFER(MaterialCB_Blend3, CBSLOT_RENDERER_MATERIAL_BLEND3) -{ - ShaderMaterial g_xMaterial_blend3; -}; - CBUFFER(MiscCB, CBSLOT_RENDERER_MISC) { float4x4 g_xTransform; @@ -715,15 +888,6 @@ CBUFFER(ForwardEntityMaskCB, CBSLOT_RENDERER_FORWARD_LIGHTMASK) uint xForwardEnvProbeMask; // supports indexing 32 environment probes }; -CBUFFER(DecalCB, CBSLOT_RENDERER_DECAL) -{ - float4x4 xDecalVP; - float3 eye; - int hasTexNor; - float3 front; - float opacity; -}; - CBUFFER(VolumeLightCB, CBSLOT_RENDERER_VOLUMELIGHT) { float4x4 lightWorld; @@ -731,7 +895,7 @@ CBUFFER(VolumeLightCB, CBSLOT_RENDERER_VOLUMELIGHT) float4 lightEnerdis; }; -CBUFFER(LensFlareCB, CBSLOT_RENDERER_LENSFLARE) +struct LensFlarePush { float3 xLensFlarePos; float xLensFlareOffset; @@ -749,9 +913,61 @@ CBUFFER(CubemapRenderCB, CBSLOT_RENDERER_CUBEMAPRENDER) CubemapRenderCam xCubemapRenderCams[6]; }; -CBUFFER(TessellationCB, CBSLOT_RENDERER_TESSELLATION) +// MIP Generator params: +#define GENERATEMIPCHAIN_1D_BLOCK_SIZE 64 +#define GENERATEMIPCHAIN_2D_BLOCK_SIZE 8 +#define GENERATEMIPCHAIN_3D_BLOCK_SIZE 4 + +struct GenerateMIPChainCB { - float4 xTessellationFactors; + uint3 outputResolution; + uint arrayIndex; + float3 outputResolution_rcp; + uint mipgen_options; +}; +static const uint MIPGEN_OPTION_BIT_PRESERVE_COVERAGE = 1 << 0; + +struct FilterEnvmapCB +{ + uint2 filterResolution; + float2 filterResolution_rcp; + uint filterArrayIndex; + float filterRoughness; + uint filterRayCount; + uint padding_filterCB; +}; + +// CopyTexture2D params: +struct CopyTextureCB +{ + int2 xCopyDest; + int2 xCopySrcSize; + int2 padding0; + int xCopySrcMIP; + int xCopyBorderExpandStyle; +}; + + +static const uint PAINT_TEXTURE_BLOCKSIZE = 8; + +struct PaintTextureCB +{ + uint2 xPaintBrushCenter; + uint xPaintBrushRadius; + float xPaintBrushAmount; + + float xPaintBrushFalloff; + uint xPaintBrushColor; + uint2 padding0; +}; + +CBUFFER(PaintRadiusCB, CBSLOT_RENDERER_MISC) +{ + uint2 xPaintRadResolution; + uint2 xPaintRadCenter; + uint xPaintRadUVSET; + float xPaintRadRadius; + uint2 pad; }; diff --git a/WickedEngine/shaders/ShaderInterop_Skinning.h b/WickedEngine/shaders/ShaderInterop_Skinning.h deleted file mode 100644 index 84c069b46..000000000 --- a/WickedEngine/shaders/ShaderInterop_Skinning.h +++ /dev/null @@ -1,10 +0,0 @@ -#ifndef WI_SHADERINTEROP_SKINNING_H -#define WI_SHADERINTEROP_SKINNING_H -#include "ShaderInterop.h" - - -// Skinning compute params: -#define SKINNING_COMPUTE_THREADCOUNT 128 - - -#endif // WI_SHADERINTEROP_SKINNING_H diff --git a/WickedEngine/shaders/ShaderInterop_SurfelGI.h b/WickedEngine/shaders/ShaderInterop_SurfelGI.h new file mode 100644 index 000000000..b5772ab29 --- /dev/null +++ b/WickedEngine/shaders/ShaderInterop_SurfelGI.h @@ -0,0 +1,189 @@ +#ifndef WI_SHADERINTEROP_SURFEL_GI_H +#define WI_SHADERINTEROP_SURFEL_GI_H +#include "ShaderInterop.h" +#include "ShaderInterop_Renderer.h" + +struct Surfel +{ + float3 position; + uint normal; + float3 color; + float radius; +}; +struct SurfelData +{ + uint2 primitiveID; + uint bary; + uint uid; + + float3 mean; + uint life; + + float3 shortMean; + float vbbr; + + float3 variance; + float inconsistency; + + float3 hitpos; + uint hitnormal; + + float3 hitenergy; + float padding0; + + float3 traceresult; + float padding1; +}; +static const uint SURFEL_CAPACITY = 250000; +static const uint SQRT_SURFEL_CAPACITY = (uint)ceil(sqrt((float)SURFEL_CAPACITY)); +static const uint SURFEL_MOMENT_TEXELS = 4 + 2; +static const uint SURFEL_MOMENT_ATLAS_TEXELS = SQRT_SURFEL_CAPACITY * SURFEL_MOMENT_TEXELS; +static const uint3 SURFEL_GRID_DIMENSIONS = uint3(128, 64, 128); +static const uint SURFEL_TABLE_SIZE = SURFEL_GRID_DIMENSIONS.x * SURFEL_GRID_DIMENSIONS.y * SURFEL_GRID_DIMENSIONS.z; +static const float SURFEL_MAX_RADIUS = 1; +struct SurfelGridCell +{ + uint count; + uint offset; +}; +static const uint SURFEL_STATS_OFFSET_COUNT = 0; +static const uint SURFEL_STATS_OFFSET_CELLALLOCATOR = 4; +static const uint SURFEL_STATS_OFFSET_INDIRECT = 8; +static const uint SURFEL_INDIRECT_NUMTHREADS = 32; +static const float SURFEL_TARGET_COVERAGE = 0.5; // how many surfels should affect a pixel fully, higher values will increase quality and cost +static const uint SURFEL_CELL_LIMIT = ~0; // limit the amount of allocated surfels in a cell +#define SURFEL_COVERAGE_HALFRES // runs the coverage shader in half resolution for improved performance +#define SURFEL_GRID_CULLING // if defined, surfels will not be added to grid cells that they do not intersect +#define SURFEL_USE_HASHING // if defined, hashing will be used to retrieve surfels, hashing is good because it supports infinite world trivially, but slower due to hash collisions + +#ifndef __cplusplus +inline int3 surfel_cell(float3 position) +{ +#ifdef SURFEL_USE_HASHING + return floor(position / SURFEL_MAX_RADIUS); +#else + return floor((position - floor(g_xCamera.CamPos)) / SURFEL_MAX_RADIUS) + SURFEL_GRID_DIMENSIONS / 2; +#endif // SURFEL_USE_HASHING +} +float3 surfel_griduv(float3 position) +{ +#ifdef SURFEL_USE_HASHING + return 0; // hashed grid can't be sampled for colors, it doesn't make sense +#else + return (((position - floor(g_xCamera.CamPos)) / SURFEL_MAX_RADIUS) + SURFEL_GRID_DIMENSIONS / 2) / SURFEL_GRID_DIMENSIONS; +#endif // SURFEL_USE_HASHING +} +inline uint surfel_cellindex(int3 cell) +{ +#ifdef SURFEL_USE_HASHING + const uint p1 = 73856093; // some large primes + const uint p2 = 19349663; + const uint p3 = 83492791; + int n = p1 * cell.x ^ p2 * cell.y ^ p3 * cell.z; + n %= SURFEL_TABLE_SIZE; + return n; +#else + return flatten3D(cell, SURFEL_GRID_DIMENSIONS); +#endif // SURFEL_USE_HASHING +} +inline bool surfel_cellvalid(int3 cell) +{ +#ifdef SURFEL_USE_HASHING + return true; +#else + if (cell.x < 0 || cell.x >= SURFEL_GRID_DIMENSIONS.x) + return false; + if (cell.y < 0 || cell.y >= SURFEL_GRID_DIMENSIONS.y) + return false; + if (cell.z < 0 || cell.z >= SURFEL_GRID_DIMENSIONS.z) + return false; + return true; +#endif // SURFEL_USE_HASHING +} +inline bool surfel_cellintersects(Surfel surfel, int3 cell) +{ + if (!surfel_cellvalid(cell)) + return false; + +#ifdef SURFEL_GRID_CULLING +#ifdef SURFEL_USE_HASHING + float3 gridmin = cell * SURFEL_MAX_RADIUS; + float3 gridmax = (cell + 1) * SURFEL_MAX_RADIUS; +#else + float3 gridmin = cell - SURFEL_GRID_DIMENSIONS / 2 * SURFEL_MAX_RADIUS + floor(g_xCamera.CamPos); + float3 gridmax = (cell + 1) - SURFEL_GRID_DIMENSIONS / 2 * SURFEL_MAX_RADIUS + floor(g_xCamera.CamPos); +#endif // SURFEL_USE_HASHING + + float3 closestPointInAabb = min(max(surfel.position, gridmin), gridmax); + float dist = distance(closestPointInAabb, surfel.position); + if (dist < surfel.radius) + return true; + return false; +#else + return true; +#endif // SURFEL_GRID_CULLING +} +// 27 neighbor offsets in a 3D grid, including center cell: +static const int3 surfel_neighbor_offsets[27] = { + int3(-1, -1, -1), + int3(-1, -1, 0), + int3(-1, -1, 1), + int3(-1, 0, -1), + int3(-1, 0, 0), + int3(-1, 0, 1), + int3(-1, 1, -1), + int3(-1, 1, 0), + int3(-1, 1, 1), + int3(0, -1, -1), + int3(0, -1, 0), + int3(0, -1, 1), + int3(0, 0, -1), + int3(0, 0, 0), + int3(0, 0, 1), + int3(0, 1, -1), + int3(0, 1, 0), + int3(0, 1, 1), + int3(1, -1, -1), + int3(1, -1, 0), + int3(1, -1, 1), + int3(1, 0, -1), + int3(1, 0, 0), + int3(1, 0, 1), + int3(1, 1, -1), + int3(1, 1, 0), + int3(1, 1, 1), +}; + +inline float2 encode(in float3 N) +{ + return float2(atan2(N.y, N.x) / PI, N.z) * 0.5 + 0.5; +} +float2 surfel_moment_pixel(uint surfel_index, float3 normal, float3 direction) +{ + uint2 moments_pixel = unflatten2D(surfel_index, SQRT_SURFEL_CAPACITY) * SURFEL_MOMENT_TEXELS; + float3 hemi = mul(direction, transpose(GetTangentSpace(normal))); + hemi.z = abs(hemi.z); + hemi = normalize(hemi); + float2 moments_uv = encode_hemioct(hemi) * 0.5 + 0.5; + //float2 moments_uv = hemi.xy * 0.5 + 0.5; + return moments_pixel + 1 + moments_uv * (SURFEL_MOMENT_TEXELS - 2); +} +float2 surfel_moment_uv(uint surfel_index, float3 normal, float3 direction) +{ + return surfel_moment_pixel(surfel_index, normal, direction) / SURFEL_MOMENT_ATLAS_TEXELS; +} +float surfel_moment_weight(float2 moments, float dist) +{ + float mean = moments.x; + float mean2 = moments.y; + if (dist > mean) + { + // Chebishev weight + float variance = abs(sqr(mean) - mean2); + return variance / (variance + sqr(dist - mean)); + } + return 1; +} +#endif // __cplusplus + +#endif // WI_SHADERINTEROP_SURFEL_GI_H diff --git a/WickedEngine/shaders/ShaderInterop_Utility.h b/WickedEngine/shaders/ShaderInterop_Utility.h deleted file mode 100644 index 2b86bc521..000000000 --- a/WickedEngine/shaders/ShaderInterop_Utility.h +++ /dev/null @@ -1,41 +0,0 @@ -#ifndef WI_SHADERINTEROP_UTILITY_H -#define WI_SHADERINTEROP_UTILITY_H -#include "ShaderInterop.h" - -// MIP Generator params: -#define GENERATEMIPCHAIN_1D_BLOCK_SIZE 64 -#define GENERATEMIPCHAIN_2D_BLOCK_SIZE 8 -#define GENERATEMIPCHAIN_3D_BLOCK_SIZE 4 - -CBUFFER(GenerateMIPChainCB, CBSLOT_RENDERER_UTILITY) -{ - uint3 outputResolution; - uint arrayIndex; - float3 outputResolution_rcp; - uint mipgen_options; -}; -static const uint MIPGEN_OPTION_BIT_PRESERVE_COVERAGE = 1 << 0; - -CBUFFER(FilterEnvmapCB, CBSLOT_RENDERER_UTILITY) -{ - uint2 filterResolution; - float2 filterResolution_rcp; - uint filterArrayIndex; - float filterRoughness; - uint filterRayCount; - uint padding_filterCB; -}; - - - -// CopyTexture2D params: -CBUFFER(CopyTextureCB, CBSLOT_RENDERER_UTILITY) -{ - int2 xCopyDest; - int2 xCopySrcSize; - int2 padding0; - int xCopySrcMIP; - int xCopyBorderExpandStyle; -}; - -#endif // WI_SHADERINTEROP_UTILITY_H diff --git a/WickedEngine/shaders/Shaders_SOURCE.vcxitems b/WickedEngine/shaders/Shaders_SOURCE.vcxitems index 65d1836da..49350c6c1 100644 --- a/WickedEngine/shaders/Shaders_SOURCE.vcxitems +++ b/WickedEngine/shaders/Shaders_SOURCE.vcxitems @@ -977,15 +977,41 @@ Compute Compute - - Pixel - Pixel - Pixel - Pixel - Pixel - Pixel - Pixel - Pixel + + Compute + 4.0 + + + Compute + 4.0 + + + Compute + 4.0 + + + Compute + 4.0 + + + Compute + 4.0 + + + Compute + 4.0 + + + Compute + 4.0 + + + Compute + 4.0 + + + Compute + 4.0 Compute @@ -1028,6 +1054,14 @@ Compute Compute + + Compute + 4.0 + + + Compute + 4.0 + Vertex @@ -1684,56 +1718,6 @@ Pixel Pixel - - Pixel - Pixel - Pixel - Pixel - Pixel - Pixel - Pixel - Pixel - - - Pixel - Pixel - Pixel - Pixel - Pixel - Pixel - Pixel - Pixel - - - Pixel - Pixel - Pixel - Pixel - Pixel - Pixel - Pixel - Pixel - - - Pixel - Pixel - Pixel - Pixel - Pixel - Pixel - Pixel - Pixel - - - Pixel - Pixel - Pixel - Pixel - Pixel - Pixel - Pixel - Pixel - Vertex Vertex @@ -1876,16 +1860,6 @@ Pixel Pixel - - Compute - Compute - Compute - Compute - Compute - Compute - Compute - Compute - Compute Compute @@ -2536,16 +2510,6 @@ Compute Compute - - Compute - Compute - Compute - Compute - Compute - Compute - Compute - Compute - Pixel Pixel @@ -2880,11 +2844,9 @@ - - - + \ No newline at end of file diff --git a/WickedEngine/shaders/Shaders_SOURCE.vcxitems.filters b/WickedEngine/shaders/Shaders_SOURCE.vcxitems.filters index 694147d47..48b7188d4 100644 --- a/WickedEngine/shaders/Shaders_SOURCE.vcxitems.filters +++ b/WickedEngine/shaders/Shaders_SOURCE.vcxitems.filters @@ -236,9 +236,6 @@ CS - - CS - CS @@ -302,9 +299,6 @@ CS - - CS - CS @@ -500,21 +494,6 @@ PS - - PS - - - PS - - - PS - - - PS - - - PS - PS @@ -896,9 +875,6 @@ PS - - PS - VS @@ -995,6 +971,39 @@ CS + + CS + + + CS + + + CS + + + CS + + + CS + + + CS + + + CS + + + CS + + + CS + + + CS + + + CS + @@ -1033,9 +1042,6 @@ interop - - interop - interop @@ -1045,10 +1051,7 @@ interop - - interop - - + interop diff --git a/WickedEngine/shaders/blur_gaussian_float4CS.hlsl b/WickedEngine/shaders/blur_gaussian_float4CS.hlsl index 407d50da8..8a820ecff 100644 --- a/WickedEngine/shaders/blur_gaussian_float4CS.hlsl +++ b/WickedEngine/shaders/blur_gaussian_float4CS.hlsl @@ -165,7 +165,7 @@ void main(uint3 Gid : SV_GroupID, uint groupIndex : SV_GroupIndex) const BLUR_FORMAT color2 = color_cache[sam]; #ifdef BILATERAL const float depth = depth_cache[sam]; - const float weight = saturate(abs(depth - center_depth) * g_xCamera_ZFarP * depth_threshold); + const float weight = saturate(abs(depth - center_depth) * g_xCamera.ZFarP * depth_threshold); color += lerp(color2, center_color, weight) * gaussianWeightsNormalized[i]; #else color += color2 * gaussianWeightsNormalized[i]; diff --git a/WickedEngine/shaders/brdf.hlsli b/WickedEngine/shaders/brdf.hlsli index 9f0c69052..dbd024997 100644 --- a/WickedEngine/shaders/brdf.hlsli +++ b/WickedEngine/shaders/brdf.hlsli @@ -202,10 +202,22 @@ struct Surface { init(); - opacity = baseColor.a; + if (material.options & SHADERMATERIAL_OPTION_BIT_TRANSPARENT || material.alphaTest > 0) + { + opacity = baseColor.a; + } + else + { + opacity = 1; + } roughness = material.roughness; f0 = material.specularColor.rgb * specularMap.rgb * specularMap.a * material.specularColor.a; + if (g_xFrame.Options & OPTION_BIT_FORCE_DIFFUSE_LIGHTING) + { + f0 = material.metalness = material.reflectance = 0; + } + [branch] if (material.IsUsingSpecularGlossinessWorkflow()) { @@ -267,6 +279,217 @@ struct Surface } inline bool IsReceiveShadow() { return receiveshadow; } + + + ShaderMeshInstance inst; + ShaderMesh mesh; + ShaderMeshSubset subset; + ShaderMaterial material; + float2 bary; + float3 pre; + + bool load(in PrimitiveID prim, in float2 barycentrics, in uint uid = 0) + { + inst = load_instance(prim.instanceIndex); + if (uid != 0 && inst.uid != uid) + return false; + + mesh = load_mesh(inst.meshIndex); + if (mesh.vb_pos_nor_wind < 0) + return false; + + subset = load_subset(mesh, prim.subsetIndex); + material = load_material(subset.materialIndex); + bary = barycentrics; + + uint startIndex = prim.primitiveIndex * 3 + subset.indexOffset; + uint i0 = bindless_ib[NonUniformResourceIndex(mesh.ib)][startIndex + 0]; + uint i1 = bindless_ib[NonUniformResourceIndex(mesh.ib)][startIndex + 1]; + uint i2 = bindless_ib[NonUniformResourceIndex(mesh.ib)][startIndex + 2]; + + uint4 data0 = bindless_buffers[NonUniformResourceIndex(mesh.vb_pos_nor_wind)].Load4(i0 * 16); + uint4 data1 = bindless_buffers[NonUniformResourceIndex(mesh.vb_pos_nor_wind)].Load4(i1 * 16); + uint4 data2 = bindless_buffers[NonUniformResourceIndex(mesh.vb_pos_nor_wind)].Load4(i2 * 16); + float3 p0 = asfloat(data0.xyz); + float3 p1 = asfloat(data1.xyz); + float3 p2 = asfloat(data2.xyz); + float3 n0 = unpack_unitvector(data0.w); + float3 n1 = unpack_unitvector(data1.w); + float3 n2 = unpack_unitvector(data2.w); + + float u = barycentrics.x; + float v = barycentrics.y; + float w = 1 - u - v; + + P = p0 * w + p1 * u + p2 * v; + P = mul(inst.transform.GetMatrix(), float4(P, 1)).xyz; + V = normalize(g_xCamera.CamPos - P); + + float4 uv0 = 0, uv1 = 0, uv2 = 0; + [branch] + if (mesh.vb_uv0 >= 0) + { + uv0.xy = unpack_half2(bindless_buffers[NonUniformResourceIndex(mesh.vb_uv0)].Load(i0 * 4)); + uv1.xy = unpack_half2(bindless_buffers[NonUniformResourceIndex(mesh.vb_uv0)].Load(i1 * 4)); + uv2.xy = unpack_half2(bindless_buffers[NonUniformResourceIndex(mesh.vb_uv0)].Load(i2 * 4)); + } + [branch] + if (mesh.vb_uv1 >= 0) + { + uv0.zw = unpack_half2(bindless_buffers[NonUniformResourceIndex(mesh.vb_uv1)].Load(i0 * 4)); + uv1.zw = unpack_half2(bindless_buffers[NonUniformResourceIndex(mesh.vb_uv1)].Load(i1 * 4)); + uv2.zw = unpack_half2(bindless_buffers[NonUniformResourceIndex(mesh.vb_uv1)].Load(i2 * 4)); + } + float4 uvsets = uv0 * w + uv1 * u + uv2 * v; + uvsets.xy = uvsets.xy * material.texMulAdd.xy + material.texMulAdd.zw; + + float4 baseColor = material.baseColor; + [branch] + if (material.texture_basecolormap_index >= 0) + { + const float2 UV_baseColorMap = material.uvset_baseColorMap == 0 ? uvsets.xy : uvsets.zw; + float4 baseColorMap = bindless_textures[NonUniformResourceIndex(material.texture_basecolormap_index)].SampleLevel(sampler_linear_wrap, UV_baseColorMap, 0); + if ((g_xFrame.Options & OPTION_BIT_DISABLE_ALBEDO_MAPS) == 0) + { + baseColorMap.rgb *= DEGAMMA(baseColorMap.rgb); + baseColor *= baseColorMap; + } + else + { + baseColor.a *= baseColorMap.a; + } + } + + [branch] + if (mesh.vb_col >= 0 && material.IsUsingVertexColors()) + { + float4 c0, c1, c2; + const uint stride_COL = 4; + c0 = unpack_rgba(bindless_buffers[NonUniformResourceIndex(mesh.vb_col)].Load(i0 * stride_COL)); + c1 = unpack_rgba(bindless_buffers[NonUniformResourceIndex(mesh.vb_col)].Load(i1 * stride_COL)); + c2 = unpack_rgba(bindless_buffers[NonUniformResourceIndex(mesh.vb_col)].Load(i2 * stride_COL)); + float4 vertexColor = c0 * w + c1 * u + c2 * v; + baseColor *= vertexColor; + } + + float4 surfaceMap = 1; + [branch] + if (material.texture_surfacemap_index >= 0) + { + const float2 UV_surfaceMap = material.uvset_surfaceMap == 0 ? uvsets.xy : uvsets.zw; + surfaceMap = bindless_textures[NonUniformResourceIndex(material.texture_surfacemap_index)].SampleLevel(sampler_linear_wrap, UV_surfaceMap, 0); + } + + float4 specularMap = 1; + [branch] + if (material.texture_specularmap_index >= 0) + { + const float2 UV_specularMap = material.uvset_specularMap == 0 ? uvsets.xy : uvsets.zw; + specularMap = bindless_textures[NonUniformResourceIndex(material.texture_specularmap_index)].SampleLevel(sampler_linear_wrap, UV_specularMap, 0); + specularMap.rgb = DEGAMMA(specularMap.rgb); + } + + create(material, baseColor, surfaceMap, specularMap); + + emissiveColor = material.emissiveColor; + [branch] + if (material.texture_emissivemap_index >= 0) + { + const float2 UV_emissiveMap = material.uvset_emissiveMap == 0 ? uvsets.xy : uvsets.zw; + float4 emissiveMap = bindless_textures[NonUniformResourceIndex(material.texture_emissivemap_index)].SampleLevel(sampler_linear_wrap, UV_emissiveMap, 0); + emissiveMap.rgb = DEGAMMA(emissiveMap.rgb); + emissiveColor *= emissiveMap; + } + + transmission = material.transmission; + if (material.texture_transmissionmap_index >= 0) + { + const float2 UV_transmissionMap = material.uvset_transmissionMap == 0 ? uvsets.xy : uvsets.zw; + float transmissionMap = bindless_textures[NonUniformResourceIndex(material.texture_transmissionmap_index)].SampleLevel(sampler_linear_wrap, UV_transmissionMap, 0).r; + transmission *= transmissionMap; + } + + [branch] + if (material.IsOcclusionEnabled_Secondary() && material.texture_occlusionmap_index >= 0) + { + const float2 UV_occlusionMap = material.uvset_occlusionMap == 0 ? uvsets.xy : uvsets.zw; + occlusion *= bindless_textures[NonUniformResourceIndex(material.texture_occlusionmap_index)].SampleLevel(sampler_linear_wrap, UV_occlusionMap, 0).r; + } + + N = n0 * w + n1 * u + n2 * v; + N = mul((float3x3)inst.transformInverseTranspose.GetMatrix(), N); + N = normalize(N); + facenormal = N; + + [branch] + if (mesh.vb_tan >= 0 && material.texture_normalmap_index >= 0 && material.normalMapStrength > 0) + { + float4 t0, t1, t2; + const uint stride_TAN = 4; + t0 = unpack_utangent(bindless_buffers[NonUniformResourceIndex(mesh.vb_tan)].Load(i0 * stride_TAN)); + t1 = unpack_utangent(bindless_buffers[NonUniformResourceIndex(mesh.vb_tan)].Load(i1 * stride_TAN)); + t2 = unpack_utangent(bindless_buffers[NonUniformResourceIndex(mesh.vb_tan)].Load(i2 * stride_TAN)); + float4 T = t0 * w + t1 * u + t2 * v; + T = T * 2 - 1; + T.xyz = mul((float3x3)inst.transformInverseTranspose.GetMatrix(), T.xyz); + T.xyz = normalize(T.xyz); + float3 B = normalize(cross(T.xyz, N) * T.w); + float3x3 TBN = float3x3(T.xyz, B, N); + + const float2 UV_normalMap = material.uvset_normalMap == 0 ? uvsets.xy : uvsets.zw; + float3 normalMap = bindless_textures[NonUniformResourceIndex(material.texture_normalmap_index)].SampleLevel(sampler_linear_wrap, UV_normalMap, 0).rgb; + normalMap.b = normalMap.b == 0 ? 1 : normalMap.b; // fix for missing blue channel + normalMap = normalMap * 2 - 1; + N = normalize(lerp(N, mul(normalMap, TBN), material.normalMapStrength)); + } + + [branch] + if (mesh.vb_pre >= 0) + { + p0 = asfloat(bindless_buffers[mesh.vb_pre].Load3(i0 * 16)); + p1 = asfloat(bindless_buffers[mesh.vb_pre].Load3(i1 * 16)); + p2 = asfloat(bindless_buffers[mesh.vb_pre].Load3(i2 * 16)); + } + pre = p0 * w + p1 * u + p2 * v; + pre = mul(inst.transformPrev.GetMatrix(), float4(pre, 1)).xyz; + + update(); + + return true; + } + + bool load(in PrimitiveID prim, in float3 P, in uint uid = 0) + { + inst = load_instance(prim.instanceIndex); + if (uid != 0 && inst.uid != uid) + return false; + + mesh = load_mesh(inst.meshIndex); + if (mesh.vb_pos_nor_wind < 0) + return false; + + subset = load_subset(mesh, prim.subsetIndex); + material = load_material(subset.materialIndex); + + uint startIndex = prim.primitiveIndex * 3 + subset.indexOffset; + uint i0 = bindless_ib[NonUniformResourceIndex(mesh.ib)][startIndex + 0]; + uint i1 = bindless_ib[NonUniformResourceIndex(mesh.ib)][startIndex + 1]; + uint i2 = bindless_ib[NonUniformResourceIndex(mesh.ib)][startIndex + 2]; + + uint4 data0 = bindless_buffers[NonUniformResourceIndex(mesh.vb_pos_nor_wind)].Load4(i0 * 16); + uint4 data1 = bindless_buffers[NonUniformResourceIndex(mesh.vb_pos_nor_wind)].Load4(i1 * 16); + uint4 data2 = bindless_buffers[NonUniformResourceIndex(mesh.vb_pos_nor_wind)].Load4(i2 * 16); + float3 p0 = asfloat(data0.xyz); + float3 p1 = asfloat(data1.xyz); + float3 p2 = asfloat(data2.xyz); + float3 P0 = mul(inst.transform.GetMatrix(), float4(p0, 1)).xyz; + float3 P1 = mul(inst.transform.GetMatrix(), float4(p1, 1)).xyz; + float3 P2 = mul(inst.transform.GetMatrix(), float4(p2, 1)).xyz; + + float2 barycentrics = compute_barycentrics(P, P0, P1, P2); + + return load(prim, barycentrics, uid); + } }; struct SurfaceToLight diff --git a/WickedEngine/shaders/bvh_primitivesCS.hlsl b/WickedEngine/shaders/bvh_primitivesCS.hlsl index e7f103e48..09571aec1 100644 --- a/WickedEngine/shaders/bvh_primitivesCS.hlsl +++ b/WickedEngine/shaders/bvh_primitivesCS.hlsl @@ -2,150 +2,81 @@ #include "ShaderInterop_BVH.h" // This shader builds scene triangle data and performs BVH classification: -// - This shader is run per object. +// - This shader is run per object subset. // - Each thread processes a triangle // - Computes triangle bounding box, morton code and other properties and stores into global primitive buffer -STRUCTUREDBUFFER(materialBuffer, ShaderMaterial, TEXSLOT_ONDEMAND0); -TYPEDBUFFER(meshIndexBuffer, uint, TEXSLOT_ONDEMAND1); -RAWBUFFER(meshVertexBuffer_POS, TEXSLOT_ONDEMAND2); -RAWBUFFER(meshVertexBuffer_UV0, TEXSLOT_ONDEMAND3); -RAWBUFFER(meshVertexBuffer_UV1, TEXSLOT_ONDEMAND4); -RAWBUFFER(meshVertexBuffer_COL, TEXSLOT_ONDEMAND5); -TYPEDBUFFER(meshVertexBuffer_SUB, uint, TEXSLOT_ONDEMAND6); +PUSHCONSTANT(push, BVHPushConstants); RWSTRUCTUREDBUFFER(primitiveIDBuffer, uint, 0); RWSTRUCTUREDBUFFER(primitiveBuffer, BVHPrimitive, 1); -RWSTRUCTUREDBUFFER(primitiveDataBuffer, BVHPrimitiveData, 2); -RWSTRUCTUREDBUFFER(primitiveMortonBuffer, float, 3); // morton buffer is float because sorting is written for floats! - +RWSTRUCTUREDBUFFER(primitiveMortonBuffer, float, 2); // morton buffer is float because sorting is written for floats! [numthreads(BVH_BUILDER_GROUPSIZE, 1, 1)] void main(uint3 DTid : SV_DispatchThreadID, uint groupIndex : SV_GroupIndex) { - const uint tri = DTid.x; - const uint primitiveID = xBVHMeshTriangleOffset + tri; - const bool activeThread = tri < xBVHMeshTriangleCount; + if (DTid.x >= push.primitiveCount) + return; - if (activeThread) + PrimitiveID prim; + prim.primitiveIndex = DTid.x; + prim.instanceIndex = push.instanceIndex; + prim.subsetIndex = push.subsetIndex; + + ShaderMeshInstance inst = load_instance(prim.instanceIndex); + ShaderMesh mesh = load_mesh(inst.meshIndex); + ShaderMeshSubset subset = load_subset(mesh, prim.subsetIndex); + ShaderMaterial material = load_material(subset.materialIndex); + + uint startIndex = prim.primitiveIndex * 3 + subset.indexOffset; + uint i0 = bindless_ib[mesh.ib][startIndex + 0]; + uint i1 = bindless_ib[mesh.ib][startIndex + 1]; + uint i2 = bindless_ib[mesh.ib][startIndex + 2]; + + uint4 data0 = bindless_buffers[mesh.vb_pos_nor_wind].Load4(i0 * 16); + uint4 data1 = bindless_buffers[mesh.vb_pos_nor_wind].Load4(i1 * 16); + uint4 data2 = bindless_buffers[mesh.vb_pos_nor_wind].Load4(i2 * 16); + float3 p0 = asfloat(data0.xyz); + float3 p1 = asfloat(data1.xyz); + float3 p2 = asfloat(data2.xyz); + float3 P0 = mul(inst.transform.GetMatrix(), float4(p0, 1)).xyz; + float3 P1 = mul(inst.transform.GetMatrix(), float4(p1, 1)).xyz; + float3 P2 = mul(inst.transform.GetMatrix(), float4(p2, 1)).xyz; + + BVHPrimitive bvhprim; + bvhprim.packed_prim = prim.pack(); + bvhprim.flags = 0; + if (mesh.flags & SHADERMESH_FLAG_DOUBLE_SIDED) { - // load indices of triangle from index buffer - uint i0 = meshIndexBuffer[tri * 3 + 0]; - uint i1 = meshIndexBuffer[tri * 3 + 2]; - uint i2 = meshIndexBuffer[tri * 3 + 1]; - - // load vertices of triangle from vertex buffer: - float4 pos_nor0 = asfloat(meshVertexBuffer_POS.Load4(i0 * xBVHMeshVertexPOSStride)); - float4 pos_nor1 = asfloat(meshVertexBuffer_POS.Load4(i1 * xBVHMeshVertexPOSStride)); - float4 pos_nor2 = asfloat(meshVertexBuffer_POS.Load4(i2 * xBVHMeshVertexPOSStride)); - - uint nor_u = asuint(pos_nor0.w); - float3 nor0 = unpack_unitvector(nor_u); - uint subsetIndex = meshVertexBuffer_SUB[i0]; - - nor_u = asuint(pos_nor1.w); - float3 nor1 = unpack_unitvector(nor_u); - - nor_u = asuint(pos_nor2.w); - float3 nor2 = unpack_unitvector(nor_u); - - - // Compute triangle parameters: - float4x4 WORLD = xBVHWorld; - const uint materialIndex = xBVHMaterialOffset + subsetIndex; - ShaderMaterial material = materialBuffer[materialIndex]; - - float3 v0 = mul(WORLD, float4(pos_nor0.xyz, 1)).xyz; - float3 v1 = mul(WORLD, float4(pos_nor1.xyz, 1)).xyz; - float3 v2 = mul(WORLD, float4(pos_nor2.xyz, 1)).xyz; - nor0 = normalize(mul((float3x3)WORLD, nor0)); - nor1 = normalize(mul((float3x3)WORLD, nor1)); - nor2 = normalize(mul((float3x3)WORLD, nor2)); - float4 u0 = float4(unpack_half2(meshVertexBuffer_UV0.Load(i0 * 4)) * material.texMulAdd.xy + material.texMulAdd.zw, unpack_half2(meshVertexBuffer_UV1.Load(i0 * 4))); - float4 u1 = float4(unpack_half2(meshVertexBuffer_UV0.Load(i1 * 4)) * material.texMulAdd.xy + material.texMulAdd.zw, unpack_half2(meshVertexBuffer_UV1.Load(i1 * 4))); - float4 u2 = float4(unpack_half2(meshVertexBuffer_UV0.Load(i2 * 4)) * material.texMulAdd.xy + material.texMulAdd.zw, unpack_half2(meshVertexBuffer_UV1.Load(i2 * 4))); - - const float4 color = xBVHInstanceColor * material.baseColor; - float4 c0 = color; - float4 c1 = color; - float4 c2 = color; - - [branch] - if (material.IsUsingVertexColors()) - { - c0 *= unpack_rgba(meshVertexBuffer_COL.Load(i0 * 4)); - c1 *= unpack_rgba(meshVertexBuffer_COL.Load(i1 * 4)); - c2 *= unpack_rgba(meshVertexBuffer_COL.Load(i2 * 4)); - } - - // Compute tangent vectors: - float4 tangent; - float3 binormal; - { - const float3 facenormal = normalize(nor0 + nor1 + nor2); - - const float x1 = v1.x - v0.x; - const float x2 = v2.x - v0.x; - const float y1 = v1.y - v0.y; - const float y2 = v2.y - v0.y; - const float z1 = v1.z - v0.z; - const float z2 = v2.z - v0.z; - - const float s1 = u1.x - u0.x; - const float s2 = u2.x - u0.x; - const float t1 = u1.y - u0.y; - const float t2 = u2.y - u0.y; - - const float r = 1.0f / (s1 * t2 - s2 * t1); - const float3 sdir = float3((t2 * x1 - t1 * x2) * r, (t2 * y1 - t1 * y2) * r, - (t2 * z1 - t1 * z2) * r); - const float3 tdir = float3((s1 * x2 - s2 * x1) * r, (s1 * y2 - s2 * y1) * r, - (s1 * z2 - s2 * z1) * r); - - tangent.xyz = normalize(sdir - facenormal * dot(facenormal, sdir)); - tangent.w = (dot(cross(tangent.xyz, facenormal), tdir) < 0.0f) ? -1.0f : 1.0f; - - binormal = normalize(cross(tangent.xyz, facenormal) * tangent.w); - } - - // Pack primitive: - BVHPrimitive prim; - prim.x0 = v0.x; - prim.y0 = v0.y; - prim.z0 = v0.z; - prim.x1 = v1.x; - prim.y1 = v1.y; - prim.z1 = v1.z; - prim.x2 = v2.x; - prim.y2 = v2.y; - prim.z2 = v2.z; - prim.n0 = pack_unitvector(nor0); - prim.n1 = pack_unitvector(nor1); - prim.n2 = pack_unitvector(nor2); - - BVHPrimitiveData primdata; - primdata.u0 = pack_half4(u0); - primdata.u1 = pack_half4(u1); - primdata.u2 = pack_half4(u2); - primdata.c0 = pack_rgba(c0); - primdata.c1 = pack_rgba(c1); - primdata.c2 = pack_rgba(c2); - primdata.tangent = pack_unitvector(tangent.xyz); - primdata.binormal = pack_unitvector(binormal); - primdata.materialIndex = materialIndex; - - // Store primitive: - primitiveBuffer[primitiveID] = prim; - primitiveDataBuffer[primitiveID] = primdata; - - primitiveIDBuffer[primitiveID] = primitiveID; // will be sorted by morton so we need this! - - - // Compute triangle morton code: - float3 minAABB = min(v0, min(v1, v2)); - float3 maxAABB = max(v0, max(v1, v2)); - float3 centerAABB = (minAABB + maxAABB) * 0.5f; - const uint mortoncode = morton3D((centerAABB - g_xFrame_WorldBoundsMin) * g_xFrame_WorldBoundsExtents_rcp); - primitiveMortonBuffer[primitiveID] = (float)mortoncode; // convert to float before sorting + bvhprim.flags |= BVH_PRIMITIVE_FLAG_DOUBLE_SIDED; } + if (material.options & SHADERMATERIAL_OPTION_BIT_DOUBLE_SIDED) + { + bvhprim.flags |= BVH_PRIMITIVE_FLAG_DOUBLE_SIDED; + } + if (material.options & SHADERMATERIAL_OPTION_BIT_TRANSPARENT || material.alphaTest > 0) + { + bvhprim.flags |= BVH_PRIMITIVE_FLAG_TRANSPARENT; + } + bvhprim.x0 = P0.x; + bvhprim.y0 = P0.y; + bvhprim.z0 = P0.z; + bvhprim.x1 = P1.x; + bvhprim.y1 = P1.y; + bvhprim.z1 = P1.z; + bvhprim.x2 = P2.x; + bvhprim.y2 = P2.y; + bvhprim.z2 = P2.z; + + uint primitiveID = push.primitiveOffset + prim.primitiveIndex; + primitiveBuffer[primitiveID] = bvhprim; + primitiveIDBuffer[primitiveID] = primitiveID; // will be sorted by morton so we need this! + + // Compute triangle morton code: + float3 minAABB = min(P0, min(P1, P2)); + float3 maxAABB = max(P0, max(P1, P2)); + float3 centerAABB = (minAABB + maxAABB) * 0.5f; + const uint mortoncode = morton3D((centerAABB - g_xFrame.WorldBoundsMin) * g_xFrame.WorldBoundsExtents_rcp); + primitiveMortonBuffer[primitiveID] = (float)mortoncode; // convert to float before sorting + } diff --git a/WickedEngine/shaders/copytexture2D_float4CS.hlsl b/WickedEngine/shaders/copytexture2D_float4CS.hlsl index 282c01d0d..5f54aa08a 100644 --- a/WickedEngine/shaders/copytexture2D_float4CS.hlsl +++ b/WickedEngine/shaders/copytexture2D_float4CS.hlsl @@ -1,10 +1,12 @@ #include "globals.hlsli" -#include "ShaderInterop_Utility.h" +#include "ShaderInterop_Renderer.h" #ifndef COPY_OUTPUT_FORMAT #define COPY_OUTPUT_FORMAT float4 #endif // COPY_OUTPUT_FORMAT +PUSHCONSTANT(push, CopyTextureCB); + TEXTURE2D(input, float4, TEXSLOT_ONDEMAND0); RWTEXTURE2D(output, COPY_OUTPUT_FORMAT, 0); @@ -12,13 +14,13 @@ RWTEXTURE2D(output, COPY_OUTPUT_FORMAT, 0); [numthreads(8, 8, 1)] void main(int3 DTid : SV_DispatchThreadID) { - if (DTid.x >= xCopySrcSize.x || DTid.y >= xCopySrcSize.y) + if (DTid.x >= push.xCopySrcSize.x || DTid.y >= push.xCopySrcSize.y) { return; } const int2 readcoord = DTid.xy; - const int2 writecoord = DTid.xy + xCopyDest; + const int2 writecoord = DTid.xy + push.xCopyDest; - output[writecoord] = input.Load(int3(readcoord, xCopySrcMIP)); + output[writecoord] = input.Load(int3(readcoord, push.xCopySrcMIP)); } diff --git a/WickedEngine/shaders/copytexture2D_float4_borderexpandCS.hlsl b/WickedEngine/shaders/copytexture2D_float4_borderexpandCS.hlsl index 6650a3c54..850ee8663 100644 --- a/WickedEngine/shaders/copytexture2D_float4_borderexpandCS.hlsl +++ b/WickedEngine/shaders/copytexture2D_float4_borderexpandCS.hlsl @@ -1,10 +1,12 @@ #include "globals.hlsli" -#include "ShaderInterop_Utility.h" +#include "ShaderInterop_Renderer.h" #ifndef COPY_OUTPUT_FORMAT #define COPY_OUTPUT_FORMAT float4 #endif // COPY_OUTPUT_FORMAT +PUSHCONSTANT(push, CopyTextureCB); + TEXTURE2D(input, float4, TEXSLOT_ONDEMAND0); RWTEXTURE2D(output, COPY_OUTPUT_FORMAT, 0); @@ -12,79 +14,79 @@ RWTEXTURE2D(output, COPY_OUTPUT_FORMAT, 0); [numthreads(8, 8, 1)] void main(int3 DTid : SV_DispatchThreadID) { - if (DTid.x >= xCopySrcSize.x || DTid.y >= xCopySrcSize.y) + if (DTid.x >= push.xCopySrcSize.x || DTid.y >= push.xCopySrcSize.y) { return; } const int2 readcoord = DTid.xy; - const int2 writecoord = DTid.xy + xCopyDest; + const int2 writecoord = DTid.xy + push.xCopyDest; - output[writecoord] = input.Load(int3(readcoord, xCopySrcMIP)); + output[writecoord] = input.Load(int3(readcoord, push.xCopySrcMIP)); // border expansion: - const bool wrap = xCopyBorderExpandStyle == 1; + const bool wrap = push.xCopyBorderExpandStyle == 1; int2 readoffset; // left if (readcoord.x == 0) { - readoffset = wrap ? int2(xCopySrcSize.x - 1, 0) : 0; + readoffset = wrap ? int2(push.xCopySrcSize.x - 1, 0) : 0; - output[writecoord + int2(-1, 0)] = input.Load(int3(readcoord + readoffset, xCopySrcMIP)); + output[writecoord + int2(-1, 0)] = input.Load(int3(readcoord + readoffset, push.xCopySrcMIP)); // top left if (readcoord.y == 0) { - readoffset = wrap ? int2(xCopySrcSize.x - 1, xCopySrcSize.x - 1) : 0; + readoffset = wrap ? int2(push.xCopySrcSize.x - 1, push.xCopySrcSize.x - 1) : 0; - output[writecoord + int2(-1, -1)] = input.Load(int3(readcoord + readoffset, xCopySrcMIP)); + output[writecoord + int2(-1, -1)] = input.Load(int3(readcoord + readoffset, push.xCopySrcMIP)); } } // right - if (readcoord.x == xCopySrcSize.x - 1) + if (readcoord.x == push.xCopySrcSize.x - 1) { - readoffset = wrap ? int2(-xCopySrcSize.x + 1, 0) : 0; + readoffset = wrap ? int2(-push.xCopySrcSize.x + 1, 0) : 0; - output[writecoord + int2(1, 0)] = input.Load(int3(readcoord + readoffset, xCopySrcMIP)); + output[writecoord + int2(1, 0)] = input.Load(int3(readcoord + readoffset, push.xCopySrcMIP)); // bottom right - if (readcoord.y == xCopySrcSize.y - 1) + if (readcoord.y == push.xCopySrcSize.y - 1) { - readoffset = wrap ? int2(-xCopySrcSize.x + 1, -xCopySrcSize.x + 1) : 0; + readoffset = wrap ? int2(-push.xCopySrcSize.x + 1, -push.xCopySrcSize.x + 1) : 0; - output[writecoord + int2(1, 1)] = input.Load(int3(readcoord + readoffset, xCopySrcMIP)); + output[writecoord + int2(1, 1)] = input.Load(int3(readcoord + readoffset, push.xCopySrcMIP)); } } // top if (readcoord.y == 0) { - readoffset = wrap ? int2(0, xCopySrcSize.x - 1) : 0; + readoffset = wrap ? int2(0, push.xCopySrcSize.x - 1) : 0; - output[writecoord + int2(0, -1)] = input.Load(int3(readcoord + readoffset, xCopySrcMIP)); + output[writecoord + int2(0, -1)] = input.Load(int3(readcoord + readoffset, push.xCopySrcMIP)); // top right - if (readcoord.x == xCopySrcSize.x - 1) + if (readcoord.x == push.xCopySrcSize.x - 1) { - readoffset = wrap ? int2(-xCopySrcSize.x + 1, xCopySrcSize.x - 1) : 0; + readoffset = wrap ? int2(-push.xCopySrcSize.x + 1, push.xCopySrcSize.x - 1) : 0; - output[writecoord + int2(1, -1)] = input.Load(int3(readcoord + readoffset, xCopySrcMIP)); + output[writecoord + int2(1, -1)] = input.Load(int3(readcoord + readoffset, push.xCopySrcMIP)); } } // bottom - if (readcoord.y == xCopySrcSize.y - 1) + if (readcoord.y == push.xCopySrcSize.y - 1) { - readoffset = wrap ? int2(0, -xCopySrcSize.x + 1) : 0; + readoffset = wrap ? int2(0, -push.xCopySrcSize.x + 1) : 0; - output[writecoord + int2(0, 1)] = input.Load(int3(readcoord + readoffset, xCopySrcMIP)); + output[writecoord + int2(0, 1)] = input.Load(int3(readcoord + readoffset, push.xCopySrcMIP)); // bottom left if (readcoord.x == 0) { - readoffset = wrap ? int2(xCopySrcSize.x - 1, -xCopySrcSize.x + 1) : 0; + readoffset = wrap ? int2(push.xCopySrcSize.x - 1, -push.xCopySrcSize.x + 1) : 0; - output[writecoord + int2(-1, 1)] = input.Load(int3(readcoord + readoffset, xCopySrcMIP)); + output[writecoord + int2(-1, 1)] = input.Load(int3(readcoord + readoffset, push.xCopySrcMIP)); } } } diff --git a/WickedEngine/shaders/cubeMapPS.hlsl b/WickedEngine/shaders/cubeMapPS.hlsl index 1494d41c4..84b13fa5d 100644 --- a/WickedEngine/shaders/cubeMapPS.hlsl +++ b/WickedEngine/shaders/cubeMapPS.hlsl @@ -13,6 +13,6 @@ float4 main(VSOut_Sphere input) : SV_TARGET { float3 P = input.pos3D; float3 N = normalize(input.nor); - float3 V = normalize(g_xCamera_CamPos - P); + float3 V = normalize(g_xCamera.CamPos - P); return float4(cubeMap.Sample(sampler_linear_clamp, -reflect(V, N)).rgb, 1); } \ No newline at end of file diff --git a/WickedEngine/shaders/cubeShadowVS.hlsl b/WickedEngine/shaders/cubeShadowVS.hlsl index 1041baf5f..93bb701d9 100644 --- a/WickedEngine/shaders/cubeShadowVS.hlsl +++ b/WickedEngine/shaders/cubeShadowVS.hlsl @@ -1,4 +1,4 @@ #define OBJECTSHADER_COMPILE_VS -#define OBJECTSHADER_LAYOUT_POS +#define OBJECTSHADER_LAYOUT_SHADOW #define OBJECTSHADER_USE_RENDERTARGETARRAYINDEX #include "objectHF.hlsli" diff --git a/WickedEngine/shaders/cubeShadowVS_alphatest.hlsl b/WickedEngine/shaders/cubeShadowVS_alphatest.hlsl index df4fcd731..aea4bcb00 100644 --- a/WickedEngine/shaders/cubeShadowVS_alphatest.hlsl +++ b/WickedEngine/shaders/cubeShadowVS_alphatest.hlsl @@ -1,5 +1,5 @@ #define OBJECTSHADER_COMPILE_VS -#define OBJECTSHADER_LAYOUT_POS_TEX +#define OBJECTSHADER_LAYOUT_SHADOW_TEX #define OBJECTSHADER_USE_RENDERTARGETARRAYINDEX #include "objectHF.hlsli" diff --git a/WickedEngine/shaders/cubeShadowVS_transparent.hlsl b/WickedEngine/shaders/cubeShadowVS_transparent.hlsl index 6f3a7fac9..d988de5f1 100644 --- a/WickedEngine/shaders/cubeShadowVS_transparent.hlsl +++ b/WickedEngine/shaders/cubeShadowVS_transparent.hlsl @@ -1,5 +1,5 @@ #define OBJECTSHADER_COMPILE_VS -#define OBJECTSHADER_LAYOUT_POS_TEX +#define OBJECTSHADER_LAYOUT_SHADOW_TEX #define OBJECTSHADER_USE_COLOR #define OBJECTSHADER_USE_RENDERTARGETARRAYINDEX #include "objectHF.hlsli" diff --git a/WickedEngine/shaders/cubeVS.hlsl b/WickedEngine/shaders/cubeVS.hlsl index cc5c39e25..043f6b51e 100644 --- a/WickedEngine/shaders/cubeVS.hlsl +++ b/WickedEngine/shaders/cubeVS.hlsl @@ -1,13 +1,11 @@ #include "globals.hlsli" #include "cube.hlsli" -#ifdef BINDLESS struct CubePushConstants { float4x4 transform; }; PUSHCONSTANT(push, CubePushConstants); -#endif // BINDLESS float4 main(uint vID : SV_VERTEXID) : SV_Position { @@ -15,9 +13,5 @@ float4 main(uint vID : SV_VERTEXID) : SV_Position //return mul(g_xTransform, CUBE[vID]); // This is a 14 vertex count trianglestrip variant: -#ifdef BINDLESS return mul(push.transform, float4(CreateCube(vID) * 2 - 1,1)); -#else - return mul(g_xTransform, float4(CreateCube(vID) * 2 - 1,1)); -#endif // BINDLESS } diff --git a/WickedEngine/shaders/cullingShaderHF.hlsli b/WickedEngine/shaders/cullingShaderHF.hlsli index ea1b35c82..785339153 100644 --- a/WickedEngine/shaders/cullingShaderHF.hlsli +++ b/WickedEngine/shaders/cullingShaderHF.hlsli @@ -40,7 +40,7 @@ struct Frustum float4 ClipToView(float4 clip) { // View space position. - float4 view = mul(g_xCamera_InvP, clip); + float4 view = mul(g_xCamera.InvP, clip); // Perspective projection. view = view / view.w; diff --git a/WickedEngine/shaders/depthOfFieldHF.hlsli b/WickedEngine/shaders/depthOfFieldHF.hlsli index 24fd6bb56..c02fe5e0b 100644 --- a/WickedEngine/shaders/depthOfFieldHF.hlsli +++ b/WickedEngine/shaders/depthOfFieldHF.hlsli @@ -3,10 +3,10 @@ inline float get_coc(in float linear_depth) { - return min(dof_maxcoc, dof_cocscale * g_xCamera_ApertureSize * pow(abs(1 - g_xCamera_FocalLength / (linear_depth * g_xCamera_ZFarP)), 2.0f)); + return min(dof_maxcoc, dof_cocscale * g_xCamera.ApertureSize * pow(abs(1 - g_xCamera.FocalLength / (linear_depth * g_xCamera.ZFarP)), 2.0f)); } -#define DOF_DEPTH_SCALE_FOREGROUND (g_xCamera_ZFarP * 1.5) +#define DOF_DEPTH_SCALE_FOREGROUND (g_xCamera.ZFarP * 1.5) float2 DepthCmp2(float depth, float closestTileDepth) { float d = DOF_DEPTH_SCALE_FOREGROUND * (depth - closestTileDepth); diff --git a/WickedEngine/shaders/depthoffield_mainCS.hlsl b/WickedEngine/shaders/depthoffield_mainCS.hlsl index 611f01aec..b865c1406 100644 --- a/WickedEngine/shaders/depthoffield_mainCS.hlsl +++ b/WickedEngine/shaders/depthoffield_mainCS.hlsl @@ -46,7 +46,7 @@ void main(uint3 Gid : SV_GroupID, uint3 GTid : SV_GroupThreadID) const uint ringCount = clamp(ceil(pow(maxcoc, 0.5f) * DOF_RING_COUNT), 1, DOF_RING_COUNT); const float spreadScale = ringCount / maxcoc; - const float2 ringScale = float(ringCount) / float(DOF_RING_COUNT) * maxcoc * g_xCamera_ApertureShape * xPPResolution_rcp; + const float2 ringScale = float(ringCount) / float(DOF_RING_COUNT) * maxcoc * g_xCamera.ApertureShape * xPPResolution_rcp; const float3 center_color = texture_prefilter[pixel]; const float3 center_presort = texture_presort[pixel]; diff --git a/WickedEngine/shaders/depthoffield_prepassCS.hlsl b/WickedEngine/shaders/depthoffield_prepassCS.hlsl index eb4ce921a..a10f0ec7d 100644 --- a/WickedEngine/shaders/depthoffield_prepassCS.hlsl +++ b/WickedEngine/shaders/depthoffield_prepassCS.hlsl @@ -47,14 +47,14 @@ void main(uint3 Gid : SV_GroupID, uint3 GTid : SV_GroupThreadID) [branch] if (backgroundFactor < 1.0f) { - const float2 ringScale = 0.5f * coc * g_xCamera_ApertureShape * xPPResolution_rcp; + const float2 ringScale = 0.5f * coc * g_xCamera.ApertureShape * xPPResolution_rcp; [unroll] for (uint i = ringSampleCount[0]; i < ringSampleCount[1]; ++i) { const float2 uv2 = uv + ringScale * disc[i].xy; const float depth = texture_lineardepth.SampleLevel(sampler_point_clamp, uv2, 1); const float3 color = max(0, input.SampleLevel(sampler_linear_clamp, uv2, 0).rgb); - const float weight = saturate(abs(depth - center_depth) * g_xCamera_ZFarP * 2); + const float weight = saturate(abs(depth - center_depth) * g_xCamera.ZFarP * 2); prefilter += lerp(color, center_color, weight); } prefilter *= ringNormFactor[1]; diff --git a/WickedEngine/shaders/depthoffield_upsampleCS.hlsl b/WickedEngine/shaders/depthoffield_upsampleCS.hlsl index 782425461..233474d99 100644 --- a/WickedEngine/shaders/depthoffield_upsampleCS.hlsl +++ b/WickedEngine/shaders/depthoffield_upsampleCS.hlsl @@ -24,7 +24,7 @@ void main(uint3 DTid : SV_DispatchThreadID) const float coc = get_coc(center_depth); - float depthDelta = saturate(1.0 - g_xCamera_ZFarP * (center_depth - mindepth)); + float depthDelta = saturate(1.0 - g_xCamera.ZFarP * (center_depth - mindepth)); const float backgroundFactor = coc; const float foregroundFactor = lerp(maxcoc, coc, depthDelta); diff --git a/WickedEngine/shaders/emittedparticleHF.hlsli b/WickedEngine/shaders/emittedparticleHF.hlsli index 0bd0f5e4f..4e079f450 100644 --- a/WickedEngine/shaders/emittedparticleHF.hlsli +++ b/WickedEngine/shaders/emittedparticleHF.hlsli @@ -1,5 +1,12 @@ #ifndef WI_EMITTEDPARTICLE_HF #define WI_EMITTEDPARTICLE_HF +#include "globals.hlsli" +#include "ShaderInterop_EmittedParticle.h" + +ShaderMaterial EmitterGetMaterial() +{ + return load_material(xEmitterMaterialIndex); +} struct VertextoPixel { diff --git a/WickedEngine/shaders/emittedparticleMS.hlsl b/WickedEngine/shaders/emittedparticleMS.hlsl index 41b812d51..1a9646835 100644 --- a/WickedEngine/shaders/emittedparticleMS.hlsl +++ b/WickedEngine/shaders/emittedparticleMS.hlsl @@ -43,7 +43,7 @@ void main( // calculate render properties from life: float lifeLerp = 1 - particle.life / particle.maxLife; float size = lerp(particle.sizeBeginEnd.x, particle.sizeBeginEnd.y, lifeLerp); - float opacity = saturate(lerp(1, 0, lifeLerp) * xEmitterOpacity); + float opacity = saturate(lerp(1, 0, lifeLerp) * EmitterGetMaterial().baseColor.a); float rotation = lifeLerp * particle.rotationalVelocity; const float spriteframe = xEmitterFrameRate == 0 ? @@ -60,7 +60,7 @@ void main( sin(rotation), cos(rotation) ); - float3 velocity = mul((float3x3)g_xCamera_View, particle.velocity); + float3 velocity = mul((float3x3)g_xCamera.View, particle.velocity); // Transform the vertices and write them for (uint i = 0; i < BILLBOARD_VERTEXCOUNT; ++i) @@ -93,10 +93,10 @@ void main( // copy to output: Out.pos = float4(particle.position, 1); - Out.pos = mul(g_xCamera_View, Out.pos); + Out.pos = mul(g_xCamera.View, Out.pos); Out.pos.xyz += quadPos.xyz; - Out.P = mul(g_xCamera_InvV, float4(Out.pos.xyz, 1)).xyz; - Out.pos = mul(g_xCamera_Proj, Out.pos); + Out.P = mul(g_xCamera.InvV, float4(Out.pos.xyz, 1)).xyz; + Out.pos = mul(g_xCamera.Proj, Out.pos); Out.tex = float4(uv, uv2); Out.size = size; diff --git a/WickedEngine/shaders/emittedparticlePS_soft.hlsl b/WickedEngine/shaders/emittedparticlePS_soft.hlsl index a28aa3e1b..9b598762d 100644 --- a/WickedEngine/shaders/emittedparticlePS_soft.hlsl +++ b/WickedEngine/shaders/emittedparticlePS_soft.hlsl @@ -3,23 +3,29 @@ #include "ShaderInterop_EmittedParticle.h" #include "objectHF.hlsli" -TEXTURE2D(texture_color, float4, TEXSLOT_ONDEMAND0); - [earlydepthstencil] float4 main(VertextoPixel input) : SV_TARGET { - float4 color = texture_color.Sample(sampler_linear_clamp, input.tex.xy); + ShaderMaterial material = EmitterGetMaterial(); + + float4 color = 1; [branch] - if (xEmitterOptions & EMITTER_OPTION_BIT_FRAME_BLENDING_ENABLED) + if (material.texture_basecolormap_index >= 0) { - float4 color2 = texture_color.Sample(sampler_linear_clamp, input.tex.zw); - color = lerp(color, color2, input.frameBlend); + color = bindless_textures[material.texture_basecolormap_index].Sample(sampler_linear_clamp, input.tex.xy); + + [branch] + if (xEmitterOptions & EMITTER_OPTION_BIT_FRAME_BLENDING_ENABLED) + { + float4 color2 = bindless_textures[material.texture_basecolormap_index].Sample(sampler_linear_clamp, input.tex.zw); + color = lerp(color, color2, input.frameBlend); + } } float2 pixel = input.pos.xy; - float2 ScreenCoord = pixel * g_xFrame_InternalResolution_rcp; - float4 depthScene = texture_lineardepth.GatherRed(sampler_linear_clamp, ScreenCoord) * g_xCamera_ZFarP; + float2 ScreenCoord = pixel * g_xFrame.InternalResolution_rcp; + float4 depthScene = texture_lineardepth.GatherRed(sampler_linear_clamp, ScreenCoord) * g_xCamera.ZFarP; float depthFragment = input.pos.w; float fade = saturate(1.0 / input.size*(max(max(depthScene.x, depthScene.y), max(depthScene.z, depthScene.w)) - depthFragment)); @@ -31,7 +37,7 @@ float4 main(VertextoPixel input) : SV_TARGET float opacity = saturate(color.a * inputColor.a * fade); - color.rgb *= inputColor.rgb * (1 + xParticleEmissive); + color.rgb *= inputColor.rgb * (1 + material.emissiveColor.rgb * material.emissiveColor.a); color.a = opacity; #ifdef EMITTEDPARTICLE_DISTORTION @@ -49,20 +55,20 @@ float4 main(VertextoPixel input) : SV_TARGET N.x = -cos(PI * input.unrotated_uv.x); N.y = cos(PI * input.unrotated_uv.y); N.z = -sin(PI * length(input.unrotated_uv)); - N = mul((float3x3)g_xCamera_InvV, N); + N = mul((float3x3)g_xCamera.InvV, N); N = normalize(N); Lighting lighting; lighting.create(0, 0, GetAmbient(N), 0); Surface surface; - surface.create(g_xMaterial, color, 0); + surface.create(material, color, 0); surface.P = input.P; surface.N = N; surface.V = 0; surface.pixel = pixel; - surface.sss = g_xMaterial.subsurfaceScattering; - surface.sss_inv = g_xMaterial.subsurfaceScattering_inv; + surface.sss = material.subsurfaceScattering; + surface.sss_inv = material.subsurfaceScattering_inv; surface.update(); TiledLighting(surface, lighting); @@ -72,9 +78,10 @@ float4 main(VertextoPixel input) : SV_TARGET //color.rgb = float3(unrotated_uv, 0); //color.rgb = float3(input.tex, 0); + color = max(0, color); } #endif // EMITTEDPARTICLE_LIGHTING - return max(color, 0); + return color; } diff --git a/WickedEngine/shaders/emittedparticleVS.hlsl b/WickedEngine/shaders/emittedparticleVS.hlsl index bf67d001d..0e21cbb22 100644 --- a/WickedEngine/shaders/emittedparticleVS.hlsl +++ b/WickedEngine/shaders/emittedparticleVS.hlsl @@ -22,7 +22,7 @@ VertextoPixel main(uint vertexID : SV_VERTEXID, uint instanceID : SV_INSTANCEID) // calculate render properties from life: float lifeLerp = 1 - particle.life / particle.maxLife; float size = lerp(particle.sizeBeginEnd.x, particle.sizeBeginEnd.y, lifeLerp); - float opacity = saturate(lerp(1, 0, lifeLerp) * xEmitterOpacity); + float opacity = saturate(lerp(1, 0, lifeLerp) * EmitterGetMaterial().baseColor.a); float rotation = lifeLerp * particle.rotationalVelocity; // expand the point into a billboard in view space: @@ -57,16 +57,16 @@ VertextoPixel main(uint vertexID : SV_VERTEXID, uint instanceID : SV_INSTANCEID) quadPos *= size; // scale the billboard along view space motion vector: - float3 velocity = mul((float3x3)g_xCamera_View, particle.velocity); + float3 velocity = mul((float3x3)g_xCamera.View, particle.velocity); quadPos += dot(quadPos, velocity) * velocity * xParticleMotionBlurAmount; // copy to output: Out.pos = float4(particle.position, 1); - Out.pos = mul(g_xCamera_View, Out.pos); + Out.pos = mul(g_xCamera.View, Out.pos); Out.pos.xyz += quadPos.xyz; - Out.P = mul(g_xCamera_InvV, float4(Out.pos.xyz, 1)).xyz; - Out.pos = mul(g_xCamera_Proj, Out.pos); + Out.P = mul(g_xCamera.InvV, float4(Out.pos.xyz, 1)).xyz; + Out.pos = mul(g_xCamera.Proj, Out.pos); Out.tex = float4(uv, uv2); Out.size = size; @@ -75,4 +75,4 @@ VertextoPixel main(uint vertexID : SV_VERTEXID, uint instanceID : SV_INSTANCEID) Out.frameBlend = frameBlend; return Out; -} \ No newline at end of file +} diff --git a/WickedEngine/shaders/emittedparticle_emitCS.hlsl b/WickedEngine/shaders/emittedparticle_emitCS.hlsl index adb7b8bf2..66cfa4b0c 100644 --- a/WickedEngine/shaders/emittedparticle_emitCS.hlsl +++ b/WickedEngine/shaders/emittedparticle_emitCS.hlsl @@ -1,4 +1,5 @@ #include "globals.hlsli" +#include "emittedparticleHF.hlsli" #include "ShaderInterop_EmittedParticle.h" RWSTRUCTUREDBUFFER(particleBuffer, Particle, 0); @@ -22,7 +23,7 @@ void main(uint3 DTid : SV_DispatchThreadID) { // we can emit: - float2 uv = float2(g_xFrame_Time + xEmitterRandomness, (float)DTid.x / (float)THREADCOUNT_EMIT); + float2 uv = float2(g_xFrame.Time + xEmitterRandomness, (float)DTid.x / (float)THREADCOUNT_EMIT); float seed = 0.12345; #ifdef EMIT_FROM_MESH @@ -112,7 +113,7 @@ void main(uint3 DTid : SV_DispatchThreadID) color_modifier |= (uint)(255.0 * lerp(1, rand(seed, uv), xParticleRandomColorFactor)) << 0; color_modifier |= (uint)(255.0 * lerp(1, rand(seed, uv), xParticleRandomColorFactor)) << 8; color_modifier |= (uint)(255.0 * lerp(1, rand(seed, uv), xParticleRandomColorFactor)) << 16; - particle.color_mirror |= xParticleColor & color_modifier; + particle.color_mirror |= pack_rgba(float4(EmitterGetMaterial().baseColor.rgb, 1)) & color_modifier; // new particle index retrieved from dead list (pop): diff --git a/WickedEngine/shaders/emittedparticle_simulateCS.hlsl b/WickedEngine/shaders/emittedparticle_simulateCS.hlsl index e3a45bd33..dd840f32e 100644 --- a/WickedEngine/shaders/emittedparticle_simulateCS.hlsl +++ b/WickedEngine/shaders/emittedparticle_simulateCS.hlsl @@ -21,7 +21,7 @@ void main(uint3 DTid : SV_DispatchThreadID, uint Gid : SV_GroupIndex) if (DTid.x < aliveCount) { // simulation can be either fixed or variable timestep: - const float dt = xEmitterFixedTimestep >= 0 ? xEmitterFixedTimestep : g_xFrame_DeltaTime; + const float dt = xEmitterFixedTimestep >= 0 ? xEmitterFixedTimestep : g_xFrame.DeltaTime; uint particleIndex = aliveBuffer_CURRENT[DTid.x]; Particle particle = particleBuffer[particleIndex]; @@ -29,9 +29,9 @@ void main(uint3 DTid : SV_DispatchThreadID, uint Gid : SV_GroupIndex) if (particle.life > 0) { // simulate: - for (uint i = 0; i < g_xFrame_ForceFieldArrayCount; ++i) + for (uint i = 0; i < g_xFrame.ForceFieldArrayCount; ++i) { - ShaderEntity forceField = EntityArray[g_xFrame_ForceFieldArrayOffset + i]; + ShaderEntity forceField = EntityArray[g_xFrame.ForceFieldArrayOffset + i]; [branch] if (forceField.layerMask & xEmitterLayerMask) @@ -57,13 +57,13 @@ void main(uint3 DTid : SV_DispatchThreadID, uint Gid : SV_GroupIndex) // NOTE: We are using the textures from previous frame, so reproject against those! (PrevVP) - float4 pos2D = mul(g_xCamera_PrevVP, float4(particle.position, 1)); + float4 pos2D = mul(g_xCamera.PrevVP, float4(particle.position, 1)); pos2D.xyz /= pos2D.w; if (pos2D.x > -1 && pos2D.x < 1 && pos2D.y > -1 && pos2D.y < 1) { float2 uv = pos2D.xy * float2(0.5f, -0.5f) + 0.5f; - uint2 pixel = uv * g_xFrame_InternalResolution; + uint2 pixel = uv * g_xFrame.InternalResolution; float depth0 = texture_depth[pixel]; float surfaceLinearDepth = getLinearDepth(depth0); @@ -79,9 +79,9 @@ void main(uint3 DTid : SV_DispatchThreadID, uint Gid : SV_GroupIndex) float depth1 = texture_depth[pixel + uint2(1, 0)]; float depth2 = texture_depth[pixel + uint2(0, -1)]; - float3 p0 = reconstructPosition(uv, depth0, g_xCamera_PrevInvVP); - float3 p1 = reconstructPosition(uv + float2(1, 0) * g_xFrame_InternalResolution_rcp, depth1, g_xCamera_PrevInvVP); - float3 p2 = reconstructPosition(uv + float2(0, -1) * g_xFrame_InternalResolution_rcp, depth2, g_xCamera_PrevInvVP); + float3 p0 = reconstructPosition(uv, depth0, g_xCamera.PrevInvVP); + float3 p1 = reconstructPosition(uv + float2(1, 0) * g_xFrame.InternalResolution_rcp, depth1, g_xCamera.PrevInvVP); + float3 p2 = reconstructPosition(uv + float2(0, -1) * g_xFrame.InternalResolution_rcp, depth2, g_xCamera.PrevInvVP); float3 surfaceNormal = normalize(cross(p2 - p0, p1 - p0)); @@ -165,7 +165,7 @@ void main(uint3 DTid : SV_DispatchThreadID, uint Gid : SV_GroupIndex) #ifdef SORTING // store squared distance to main camera: - float3 eyeVector = particle.position - g_xCamera_CamPos; + float3 eyeVector = particle.position - g_xCamera.CamPos; float distSQ = dot(eyeVector, eyeVector); distanceBuffer[particleIndex] = -distSQ; // this can be negated to modify sorting order here instead of rewriting sorting shaders... #endif // SORTING diff --git a/WickedEngine/shaders/envMapPS.hlsl b/WickedEngine/shaders/envMapPS.hlsl index 6f884b590..db35d28ba 100644 --- a/WickedEngine/shaders/envMapPS.hlsl +++ b/WickedEngine/shaders/envMapPS.hlsl @@ -12,6 +12,7 @@ #define OBJECTSHADER_USE_TANGENT #define OBJECTSHADER_USE_POSITION3D #define OBJECTSHADER_USE_EMISSIVE +#define OBJECTSHADER_USE_INSTANCEID #define OBJECTSHADER_USE_RENDERTARGETARRAYINDEX #define ENVMAPRENDERING #define FORWARD diff --git a/WickedEngine/shaders/envMapVS.hlsl b/WickedEngine/shaders/envMapVS.hlsl index 8a0862434..5cb191a47 100644 --- a/WickedEngine/shaders/envMapVS.hlsl +++ b/WickedEngine/shaders/envMapVS.hlsl @@ -12,6 +12,7 @@ #define OBJECTSHADER_USE_TANGENT #define OBJECTSHADER_USE_POSITION3D #define OBJECTSHADER_USE_EMISSIVE +#define OBJECTSHADER_USE_INSTANCEID #define OBJECTSHADER_USE_RENDERTARGETARRAYINDEX #define ENVMAPRENDERING #include "objectHF.hlsli" diff --git a/WickedEngine/shaders/filterEnvMapCS.hlsl b/WickedEngine/shaders/filterEnvMapCS.hlsl index 1127c7eab..7eff40439 100644 --- a/WickedEngine/shaders/filterEnvMapCS.hlsl +++ b/WickedEngine/shaders/filterEnvMapCS.hlsl @@ -1,5 +1,7 @@ #include "globals.hlsli" -#include "ShaderInterop_Utility.h" +#include "ShaderInterop_Renderer.h" + +PUSHCONSTANT(push, FilterEnvmapCB); TEXTURECUBEARRAY(input, float4, TEXSLOT_ONDEMAND0); RWTEXTURE2DARRAY(output, float4, 0); @@ -21,25 +23,25 @@ float3 ImportanceSampleGGX(float2 Xi, float Roughness, float3 N) [numthreads(GENERATEMIPCHAIN_2D_BLOCK_SIZE, GENERATEMIPCHAIN_2D_BLOCK_SIZE, 1)] void main(uint3 DTid : SV_DispatchThreadID) { - if (DTid.x < filterResolution.x && DTid.y < filterResolution.y) + if (DTid.x < push.filterResolution.x && DTid.y < push.filterResolution.y) { - float2 uv = (DTid.xy + 0.5f) * filterResolution_rcp.xy; + float2 uv = (DTid.xy + 0.5f) * push.filterResolution_rcp.xy; float3 N = UV_to_CubeMap(uv, DTid.z); float3x3 tangentSpace = GetTangentSpace(N); float4 col = 0; - for (uint i = 0; i < filterRayCount; ++i) + for (uint i = 0; i < push.filterRayCount; ++i) { - float2 hamm = hammersley2d(i, filterRayCount); - float3 hemisphere = ImportanceSampleGGX(hamm, filterRoughness, N); + float2 hamm = hammersley2d(i, push.filterRayCount); + float3 hemisphere = ImportanceSampleGGX(hamm, push.filterRoughness, N); float3 cone = mul(hemisphere, tangentSpace); - col += input.SampleLevel(sampler_linear_clamp, float4(cone, filterArrayIndex), 0); + col += input.SampleLevel(sampler_linear_clamp, float4(cone, push.filterArrayIndex), 0); } - col /= (float)filterRayCount; + col /= (float)push.filterRayCount; - output[uint3(DTid.xy, DTid.z + filterArrayIndex * 6)] = col; + output[uint3(DTid.xy, DTid.z + push.filterArrayIndex * 6)] = col; } } diff --git a/WickedEngine/shaders/fontPS.hlsl b/WickedEngine/shaders/fontPS.hlsl index 9665b0ae6..8108f75d0 100644 --- a/WickedEngine/shaders/fontPS.hlsl +++ b/WickedEngine/shaders/fontPS.hlsl @@ -1,13 +1,6 @@ #include "globals.hlsli" #include "ShaderInterop_Font.h" -#ifdef BINDLESS -Texture2D bindless_textures[] : register(space1); -#define texture_font bindless_textures[g_xFont_TextureIndex] -#else -TEXTURE2D(texture_font, float, TEXSLOT_FONTATLAS); -#endif // BINDLESS - SAMPLERSTATE(sampler_font, SSLOT_ONDEMAND1); struct VertextoPixel @@ -18,5 +11,5 @@ struct VertextoPixel float4 main(VertextoPixel PSIn) : SV_TARGET { - return texture_font.SampleLevel(sampler_font, PSIn.tex, 0).rrrr * g_xFont_Color; + return bindless_textures[push.texture_index].SampleLevel(sampler_font, PSIn.tex, 0).rrrr * unpack_rgba(push.color); } diff --git a/WickedEngine/shaders/fontVS.hlsl b/WickedEngine/shaders/fontVS.hlsl index ecc2eabe6..65ca56a1e 100644 --- a/WickedEngine/shaders/fontVS.hlsl +++ b/WickedEngine/shaders/fontVS.hlsl @@ -7,15 +7,13 @@ struct VertextoPixel float2 tex : TEXCOORD0; }; -RAWBUFFER(vertexBuffer, 0); - VertextoPixel main(uint vertexID : SV_VERTEXID, uint instanceID : SV_InstanceID) { VertextoPixel Out; uint vID = instanceID * 4 + vertexID; - uint3 raw = vertexBuffer.Load3(g_xFont_BufferOffset + vID * 12); - Out.pos = mul(g_xFont_Transform, float4(asfloat(raw.xy), 0, 1)); + uint3 raw = bindless_buffers[push.buffer_index].Load3(push.buffer_offset + vID * 12); + Out.pos = mul(push.transform, float4(asfloat(raw.xy), 0, 1)); Out.tex = unpack_half2(raw.z); return Out; diff --git a/WickedEngine/shaders/forceFieldPlaneVisualizerVS.hlsl b/WickedEngine/shaders/forceFieldPlaneVisualizerVS.hlsl index b9c77aa9e..20695213a 100644 --- a/WickedEngine/shaders/forceFieldPlaneVisualizerVS.hlsl +++ b/WickedEngine/shaders/forceFieldPlaneVisualizerVS.hlsl @@ -13,7 +13,7 @@ PSIn main(uint vID : SV_VERTEXID) Out.pos = float4(CreateCube(vID) * 2 - 1, 1); - uint forceFieldID = g_xFrame_ForceFieldArrayOffset + (uint)g_xColor.w; + uint forceFieldID = g_xFrame.ForceFieldArrayOffset + (uint)g_xColor.w; ShaderEntity forceField = EntityArray[forceFieldID]; Out.pos.xyz *= forceField.GetConeAngleCos(); // range... diff --git a/WickedEngine/shaders/forceFieldPointVisualizerVS.hlsl b/WickedEngine/shaders/forceFieldPointVisualizerVS.hlsl index 6914e581e..25d8f8e75 100644 --- a/WickedEngine/shaders/forceFieldPointVisualizerVS.hlsl +++ b/WickedEngine/shaders/forceFieldPointVisualizerVS.hlsl @@ -15,7 +15,7 @@ PSIn main(uint vID : SV_VERTEXID) Out.pos = UVSPHERE[vID]; - uint forceFieldID = g_xFrame_ForceFieldArrayOffset + (uint)g_xColor.w; + uint forceFieldID = g_xFrame.ForceFieldArrayOffset + (uint)g_xColor.w; ShaderEntity forceField = EntityArray[forceFieldID]; Out.pos.xyz *= forceField.GetConeAngleCos(); // range... diff --git a/WickedEngine/shaders/forceFieldVisualizerPS.hlsl b/WickedEngine/shaders/forceFieldVisualizerPS.hlsl index f343319ea..89ab0b8c6 100644 --- a/WickedEngine/shaders/forceFieldVisualizerPS.hlsl +++ b/WickedEngine/shaders/forceFieldVisualizerPS.hlsl @@ -9,7 +9,7 @@ struct PSIn float4 main(PSIn input) : SV_TARGET { - uint forceFieldID = g_xFrame_ForceFieldArrayOffset + (uint)g_xColor.w; + uint forceFieldID = g_xFrame.ForceFieldArrayOffset + (uint)g_xColor.w; ShaderEntity forceField = EntityArray[forceFieldID]; float4 color = forceField.GetEnergy() < 0 ? float4(0, 0, 1, 1) : float4(1, 0, 0, 1); @@ -30,7 +30,7 @@ float4 main(PSIn input) : SV_TARGET } float2 pTex = input.pos2D.xy / input.pos2D.w * float2(0.5f, -0.5f) + 0.5f; - float4 depthScene = texture_lineardepth.GatherRed(sampler_linear_clamp, pTex) * g_xCamera_ZFarP; + float4 depthScene = texture_lineardepth.GatherRed(sampler_linear_clamp, pTex) * g_xCamera.ZFarP; float depthFragment = input.pos2D.w; float fade = saturate(1.0 / forceField.GetConeAngleCos() * abs(forceField.GetEnergy()) * (max(max(depthScene.x, depthScene.y), max(depthScene.z, depthScene.w)) - depthFragment)); color.a *= fade; diff --git a/WickedEngine/shaders/generateMIPChain2DCS_float4.hlsl b/WickedEngine/shaders/generateMIPChain2DCS_float4.hlsl index 8ee94a17a..7d4e4ccfe 100644 --- a/WickedEngine/shaders/generateMIPChain2DCS_float4.hlsl +++ b/WickedEngine/shaders/generateMIPChain2DCS_float4.hlsl @@ -1,10 +1,12 @@ #include "globals.hlsli" -#include "ShaderInterop_Utility.h" +#include "ShaderInterop_Renderer.h" #ifndef MIP_OUTPUT_FORMAT #define MIP_OUTPUT_FORMAT float4 #endif +PUSHCONSTANT(push, GenerateMIPChainCB); + TEXTURE2D(input, float4, TEXSLOT_ONDEMAND0); RWTEXTURE2D(output, MIP_OUTPUT_FORMAT, 0); @@ -13,13 +15,13 @@ SAMPLERSTATE(customsampler, SSLOT_ONDEMAND0); [numthreads(GENERATEMIPCHAIN_2D_BLOCK_SIZE, GENERATEMIPCHAIN_2D_BLOCK_SIZE, 1)] void main(uint3 DTid : SV_DispatchThreadID) { - if (DTid.x < outputResolution.x && DTid.y < outputResolution.y) + if (DTid.x < push.outputResolution.x && DTid.y < push.outputResolution.y) { - float2 uv = ((float2)DTid.xy + 0.5f) * (float2)outputResolution_rcp.xy; + float2 uv = ((float2)DTid.xy + 0.5f) * (float2)push.outputResolution_rcp.xy; float4 color = input.SampleLevel(customsampler, uv, 0); [branch] - if (mipgen_options & MIPGEN_OPTION_BIT_PRESERVE_COVERAGE) + if (push.mipgen_options & MIPGEN_OPTION_BIT_PRESERVE_COVERAGE) { float4 alphas = input.GatherAlpha(customsampler, uv, 0); alphas = pow(saturate(alphas), 2.2f); diff --git a/WickedEngine/shaders/generateMIPChain3DCS_float4.hlsl b/WickedEngine/shaders/generateMIPChain3DCS_float4.hlsl index d95b064c9..029ab46a2 100644 --- a/WickedEngine/shaders/generateMIPChain3DCS_float4.hlsl +++ b/WickedEngine/shaders/generateMIPChain3DCS_float4.hlsl @@ -1,10 +1,12 @@ #include "globals.hlsli" -#include "ShaderInterop_Utility.h" +#include "ShaderInterop_Renderer.h" #ifndef MIP_OUTPUT_FORMAT #define MIP_OUTPUT_FORMAT float4 #endif +PUSHCONSTANT(push, GenerateMIPChainCB); + TEXTURE3D(input, float4, TEXSLOT_ONDEMAND0); RWTEXTURE3D(output, MIP_OUTPUT_FORMAT, 0); @@ -13,8 +15,8 @@ SAMPLERSTATE(customsampler, SSLOT_ONDEMAND0); [numthreads(GENERATEMIPCHAIN_3D_BLOCK_SIZE, GENERATEMIPCHAIN_3D_BLOCK_SIZE, GENERATEMIPCHAIN_3D_BLOCK_SIZE)] void main( uint3 DTid : SV_DispatchThreadID ) { - if (DTid.x < outputResolution.x && DTid.y < outputResolution.y && DTid.z < outputResolution.z) + if (DTid.x < push.outputResolution.x && DTid.y < push.outputResolution.y && DTid.z < push.outputResolution.z) { - output[DTid] = input.SampleLevel(customsampler, ((float3)DTid + 0.5f) * (float3)outputResolution_rcp, 0); + output[DTid] = input.SampleLevel(customsampler, ((float3)DTid + 0.5f) * (float3)push.outputResolution_rcp, 0); } } diff --git a/WickedEngine/shaders/generateMIPChainCubeArrayCS_float4.hlsl b/WickedEngine/shaders/generateMIPChainCubeArrayCS_float4.hlsl index 708889698..51f3f9082 100644 --- a/WickedEngine/shaders/generateMIPChainCubeArrayCS_float4.hlsl +++ b/WickedEngine/shaders/generateMIPChainCubeArrayCS_float4.hlsl @@ -1,10 +1,12 @@ #include "globals.hlsli" -#include "ShaderInterop_Utility.h" +#include "ShaderInterop_Renderer.h" #ifndef MIP_OUTPUT_FORMAT #define MIP_OUTPUT_FORMAT float4 #endif +PUSHCONSTANT(push, GenerateMIPChainCB); + TEXTURECUBEARRAY(input, float4, TEXSLOT_ONDEMAND0); RWTEXTURE2DARRAY(output, MIP_OUTPUT_FORMAT, 0); @@ -13,11 +15,11 @@ SAMPLERSTATE(customsampler, SSLOT_ONDEMAND0); [numthreads(GENERATEMIPCHAIN_2D_BLOCK_SIZE, GENERATEMIPCHAIN_2D_BLOCK_SIZE, 1)] void main(uint3 DTid : SV_DispatchThreadID) { - if (DTid.x < outputResolution.x && DTid.y < outputResolution.y) + if (DTid.x < push.outputResolution.x && DTid.y < push.outputResolution.y) { - float2 uv = ((float2)DTid.xy + 0.5f) * outputResolution_rcp.xy; + float2 uv = ((float2)DTid.xy + 0.5f) * push.outputResolution_rcp.xy; float3 N = UV_to_CubeMap(uv, DTid.z); - output[uint3(DTid.xy, DTid.z + arrayIndex * 6)] = input.SampleLevel(customsampler, float4(N, arrayIndex), 0); + output[uint3(DTid.xy, DTid.z + push.arrayIndex * 6)] = input.SampleLevel(customsampler, float4(N, push.arrayIndex), 0); } } diff --git a/WickedEngine/shaders/generateMIPChainCubeCS_float4.hlsl b/WickedEngine/shaders/generateMIPChainCubeCS_float4.hlsl index ccdb3a217..17584c46a 100644 --- a/WickedEngine/shaders/generateMIPChainCubeCS_float4.hlsl +++ b/WickedEngine/shaders/generateMIPChainCubeCS_float4.hlsl @@ -1,10 +1,12 @@ #include "globals.hlsli" -#include "ShaderInterop_Utility.h" +#include "ShaderInterop_Renderer.h" #ifndef MIP_OUTPUT_FORMAT #define MIP_OUTPUT_FORMAT float4 #endif +PUSHCONSTANT(push, GenerateMIPChainCB); + TEXTURECUBE(input, float4, TEXSLOT_ONDEMAND0); RWTEXTURE2DARRAY(output, MIP_OUTPUT_FORMAT, 0); @@ -13,9 +15,9 @@ SAMPLERSTATE(customsampler, SSLOT_ONDEMAND0); [numthreads(GENERATEMIPCHAIN_2D_BLOCK_SIZE, GENERATEMIPCHAIN_2D_BLOCK_SIZE, 1)] void main(uint3 DTid : SV_DispatchThreadID) { - if (DTid.x < outputResolution.x && DTid.y < outputResolution.y) + if (DTid.x < push.outputResolution.x && DTid.y < push.outputResolution.y) { - float2 uv = ((float2)DTid.xy + 0.5f) * outputResolution_rcp.xy; + float2 uv = ((float2)DTid.xy + 0.5f) * push.outputResolution_rcp.xy; float3 N = UV_to_CubeMap(uv, DTid.z); output[DTid.xyz] = input.SampleLevel(customsampler, N, 0); diff --git a/WickedEngine/shaders/globals.hlsli b/WickedEngine/shaders/globals.hlsli index 18e60ec55..9be56feda 100644 --- a/WickedEngine/shaders/globals.hlsli +++ b/WickedEngine/shaders/globals.hlsli @@ -3,15 +3,40 @@ #include "ShaderInterop.h" #include "ShaderInterop_Renderer.h" +Texture2D bindless_textures[] : register(space1); +ByteAddressBuffer bindless_buffers[] : register(space2); +SamplerState bindless_samplers[] : register(space3); +Buffer bindless_ib[] : register(space4); + +TextureCube bindless_cubemaps[] : register(space5); +TextureCubeArray bindless_cubearrays[] : register(space6); +Texture3D bindless_textures3D[] : register(space7); +RWTexture2D bindless_rwtextures[] : register(space8); + +ShaderMeshInstance load_instance(uint instanceIndex) +{ + return bindless_buffers[g_xFrame.scene.instancebuffer].Load(instanceIndex * sizeof(ShaderMeshInstance)); +} +ShaderMesh load_mesh(uint meshIndex) +{ + return bindless_buffers[g_xFrame.scene.meshbuffer].Load(meshIndex * sizeof(ShaderMesh)); +} +ShaderMeshSubset load_subset(ShaderMesh mesh, uint subsetIndex) +{ + return bindless_buffers[NonUniformResourceIndex(mesh.subsetbuffer)].Load(subsetIndex * sizeof(ShaderMeshSubset)); +} +ShaderMaterial load_material(uint materialIndex) +{ + return bindless_buffers[g_xFrame.scene.materialbuffer].Load(materialIndex * sizeof(ShaderMaterial)); +} + +#define texture_globalenvmap bindless_cubemaps[g_xFrame.scene.globalenvmap] +#define texture_envmaparray bindless_cubearrays[g_xFrame.scene.envmaparray] + TEXTURE2D(texture_depth, float, TEXSLOT_DEPTH); TEXTURE2D(texture_lineardepth, float, TEXSLOT_LINEARDEPTH); -TEXTURE2D(texture_gbuffer0, float3, TEXSLOT_GBUFFER0); -TEXTURE2D(texture_gbuffer1, float4, TEXSLOT_GBUFFER1); -TEXTURE2D(texture_gbuffer2, float2, TEXSLOT_GBUFFER2); -TEXTURECUBE(texture_globalenvmap, float4, TEXSLOT_GLOBALENVMAP); -TEXTURE2D(texture_globallightmap, float4, TEXSLOT_GLOBALLIGHTMAP); -TEXTURECUBEARRAY(texture_envmaparray, float4, TEXSLOT_ENVMAPARRAY); -TEXTURE2D(texture_decalatlas, float4, TEXSLOT_DECALATLAS); +TEXTURE2D(texture_gbuffer0, uint2, TEXSLOT_GBUFFER0); +TEXTURE2D(texture_gbuffer1, float2, TEXSLOT_GBUFFER1); TEXTURE2D(texture_skyviewlut, float4, TEXSLOT_SKYVIEWLUT); TEXTURE2D(texture_transmittancelut, float4, TEXSLOT_TRANSMITTANCELUT); TEXTURE2D(texture_multiscatteringlut, float4, TEXSLOT_MULTISCATTERINGLUT); @@ -20,7 +45,7 @@ TEXTURE2DARRAY(texture_shadowarray_2d, float, TEXSLOT_SHADOWARRAY_2D); TEXTURECUBEARRAY(texture_shadowarray_cube, float, TEXSLOT_SHADOWARRAY_CUBE); TEXTURE2DARRAY(texture_shadowarray_transparent_2d, float4, TEXSLOT_SHADOWARRAY_TRANSPARENT_2D); TEXTURECUBEARRAY(texture_shadowarray_transparent_cube, float4, TEXSLOT_SHADOWARRAY_TRANSPARENT_CUBE); -TEXTURE3D(texture_voxelradiance, float4, TEXSLOT_VOXELRADIANCE); +TEXTURE3D(texture_voxelgi, float4, TEXSLOT_VOXELGI); TEXTURE2D(texture_sheenlut, float, TEXSLOT_SHEENLUT); TEXTURE2D(texture_bluenoise, float4, TEXSLOT_BLUENOISE); TEXTURE2D(texture_random64x64, float4, TEXSLOT_RANDOM64X64); @@ -37,7 +62,6 @@ SAMPLERSTATE( sampler_aniso_clamp, SSLOT_ANISO_CLAMP ); SAMPLERSTATE( sampler_aniso_wrap, SSLOT_ANISO_WRAP ); SAMPLERSTATE( sampler_aniso_mirror, SSLOT_ANISO_MIRROR ); SAMPLERCOMPARISONSTATE( sampler_cmp_depth, SSLOT_CMP_DEPTH ); -SAMPLERSTATE( sampler_objectshader, SSLOT_OBJECTSHADER ); #define PI 3.14159265358979323846 #define SQRT2 1.41421356237309504880 @@ -52,20 +76,20 @@ inline bool is_saturated(float2 a) { return is_saturated(a.x) && is_saturated(a. inline bool is_saturated(float3 a) { return is_saturated(a.x) && is_saturated(a.y) && is_saturated(a.z); } inline bool is_saturated(float4 a) { return is_saturated(a.x) && is_saturated(a.y) && is_saturated(a.z) && is_saturated(a.w); } -#define DEGAMMA_SKY(x) pow(abs(x),g_xFrame_StaticSkyGamma) -#define DEGAMMA(x) pow(abs(x),g_xFrame_Gamma) -#define GAMMA(x) pow(abs(x),1.0/g_xFrame_Gamma) +#define DEGAMMA_SKY(x) pow(abs(x),g_xFrame.StaticSkyGamma) +#define DEGAMMA(x) pow(abs(x),g_xFrame.Gamma) +#define GAMMA(x) pow(abs(x),1.0/g_xFrame.Gamma) -inline float3 GetSunColor() { return g_xFrame_SunColor; } -inline float3 GetSunDirection() { return g_xFrame_SunDirection; } -inline float GetSunEnergy() { return g_xFrame_SunEnergy; } -inline float3 GetHorizonColor() { return g_xFrame_Horizon.rgb; } -inline float3 GetZenithColor() { return g_xFrame_Zenith.rgb; } -inline float3 GetAmbientColor() { return g_xFrame_Ambient.rgb; } -inline float2 GetInternalResolution() { return g_xFrame_InternalResolution; } -inline float GetTime() { return g_xFrame_Time; } -inline uint2 GetTemporalAASampleRotation() { return uint2((g_xFrame_TemporalAASampleRotation >> 0u) & 0x000000FF, (g_xFrame_TemporalAASampleRotation >> 8) & 0x000000FF); } -inline bool IsStaticSky() { return g_xFrame_StaticSkyGamma > 0.0; } +inline float3 GetSunColor() { return g_xFrame.SunColor; } +inline float3 GetSunDirection() { return g_xFrame.SunDirection; } +inline float GetSunEnergy() { return g_xFrame.SunEnergy; } +inline float3 GetHorizonColor() { return g_xFrame.Horizon.rgb; } +inline float3 GetZenithColor() { return g_xFrame.Zenith.rgb; } +inline float3 GetAmbientColor() { return g_xFrame.Ambient.rgb; } +inline float2 GetInternalResolution() { return g_xFrame.InternalResolution; } +inline float GetTime() { return g_xFrame.Time; } +inline uint2 GetTemporalAASampleRotation() { return uint2((g_xFrame.TemporalAASampleRotation >> 0u) & 0x000000FF, (g_xFrame.TemporalAASampleRotation >> 8) & 0x000000FF); } +inline bool IsStaticSky() { return g_xFrame.scene.globalenvmap >= 0; } // Exponential height fog based on: https://www.iquilezles.org/www/articles/fog/fog.htm // Non constant density function @@ -74,12 +98,12 @@ inline bool IsStaticSky() { return g_xFrame_StaticSkyGamma > 0.0; } // V : sample to point vector inline float GetFogAmount(float distance, float3 O, float3 V) { - float fogDensity = saturate((distance - g_xFrame_Fog.x) / (g_xFrame_Fog.y - g_xFrame_Fog.x)); + float fogDensity = saturate((distance - g_xFrame.Fog.x) / (g_xFrame.Fog.y - g_xFrame.Fog.x)); - if (g_xFrame_Options & OPTION_BIT_HEIGHT_FOG) + if (g_xFrame.Options & OPTION_BIT_HEIGHT_FOG) { - float fogHeightStart = g_xFrame_Fog.z; - float fogHeightEnd = g_xFrame_Fog.w; + float fogHeightStart = g_xFrame.Fog.z; + float fogHeightEnd = g_xFrame.Fog.w; float fogFalloffScale = 1.0 / max(0.01, fogHeightEnd - fogHeightStart); // solve for x, e^(-h * x) = 0.001 @@ -121,11 +145,11 @@ float3 inverseTonemap(float3 x) inline float4 blue_noise(uint2 pixel) { - return frac(texture_bluenoise[pixel % 128].rgba + g_xFrame_BlueNoisePhase); + return frac(texture_bluenoise[pixel % 128].rgba + g_xFrame.BlueNoisePhase); } inline float4 blue_noise(uint2 pixel, float depth) { - return frac(texture_bluenoise[pixel % 128].rgba + g_xFrame_BlueNoisePhase + depth); + return frac(texture_bluenoise[pixel % 128].rgba + g_xFrame.BlueNoisePhase + depth); } // Helpers: @@ -267,7 +291,7 @@ inline float getLinearDepth(in float z, in float near, in float far) } inline float getLinearDepth(in float z) { - return getLinearDepth(z, g_xCamera_ZNearP, g_xCamera_ZFarP); + return getLinearDepth(z, g_xCamera.ZNearP, g_xCamera.ZFarP); } inline float3x3 GetTangentSpace(in float3 normal) @@ -322,7 +346,7 @@ inline float3 reconstructPosition(in float2 uv, in float z, in float4x4 InvVP) } inline float3 reconstructPosition(in float2 uv, in float z) { - return reconstructPosition(uv, z, g_xCamera_InvVP); + return reconstructPosition(uv, z, g_xCamera.InvVP); } #if 0 @@ -578,6 +602,49 @@ inline uint morton3D(in float3 pos) } +// Octahedral encodings: +// Journal of Computer Graphics Techniques Vol. 3, No. 2, 2014 http://jcgt.org + +// Returns +/-1 +float2 signNotZero(float2 v) +{ + return float2((v.x >= 0.0) ? +1.0 : -1.0, (v.y >= 0.0) ? +1.0 : -1.0); +} +// Assume normalized input. Output is on [-1, 1] for each component. +float2 encode_oct(in float3 v) +{ + // Project the sphere onto the octahedron, and then onto the xy plane + float2 p = v.xy * (1.0 / (abs(v.x) + abs(v.y) + abs(v.z))); + // Reflect the folds of the lower hemisphere over the diagonals + return (v.z <= 0.0) ? ((1.0 - abs(p.yx)) * signNotZero(p)) : p; +} +float3 decode_oct(float2 e) +{ + float3 v = float3(e.xy, 1.0 - abs(e.x) - abs(e.y)); + if (v.z < 0) v.xy = (1.0 - abs(v.yx)) * signNotZero(v.xy); + return normalize(v); +} + +// Assume normalized input on +Z hemisphere. +// Output is on [-1, 1]. +float2 encode_hemioct(in float3 v) +{ + // Project the hemisphere onto the hemi-octahedron, + // and then into the xy plane + float2 p = v.xy * (1.0 / (abs(v.x) + abs(v.y) + v.z)); + // Rotate and scale the center diamond to the unit square + return float2(p.x + p.y, p.x - p.y); +} +float3 decode_hemioct(float2 e) +{ + // Rotate and scale the unit square back to the center diamond + float2 temp = float2(e.x + e.y, e.x - e.y) * 0.5; + float3 v = float3(temp, 1.0 - abs(temp.x) - abs(temp.y)); + return normalize(v); +} + + + static const float2x2 BayerMatrix2 = { @@ -715,6 +782,21 @@ float3 ClosestPointOnSegment(float3 a, float3 b, float3 c) return a + saturate(t) * ab; } +// Compute barycentric coordinates on triangle from a point p +float2 compute_barycentrics(float3 p, float3 a, float3 b, float3 c) +{ + float3 v0 = b - a, v1 = c - a, v2 = p - a; + float d00 = dot(v0, v0); + float d01 = dot(v0, v1); + float d11 = dot(v1, v1); + float d20 = dot(v2, v0); + float d21 = dot(v2, v1); + float denom_rcp = rcp(d00 * d11 - d01 * d01); + float u = (d11 * d20 - d01 * d21) * denom_rcp; + float v = (d00 * d21 - d01 * d20) * denom_rcp; + return float2(u, v); +} + static const float4 halton64[] = { float4(0.5000000000f, 0.3333333333f, 0.2000000000f, 0.1428571429f), float4(0.2500000000f, 0.6666666667f, 0.4000000000f, 0.2857142857f), diff --git a/WickedEngine/shaders/hairparticleHF.hlsli b/WickedEngine/shaders/hairparticleHF.hlsli index 9b199d282..b998434e0 100644 --- a/WickedEngine/shaders/hairparticleHF.hlsli +++ b/WickedEngine/shaders/hairparticleHF.hlsli @@ -1,15 +1,29 @@ #ifndef WI_HAIRPARTICLE_HF #define WI_HAIRPARTICLE_HF +#include "globals.hlsli" +#include "ShaderInterop_HairParticle.h" + +ShaderMeshInstance HairGetInstance() +{ + return load_instance(xHairInstanceIndex); +} +ShaderMesh HairGetMesh() +{ + return load_mesh(HairGetInstance().meshIndex); +} +ShaderMaterial HairGetMaterial() +{ + return load_material(load_subset(HairGetMesh(), 0).materialIndex); +} struct VertexToPixel { float4 pos : SV_POSITION; + float2 tex : TEXCOORD; + nointerpolation float fade : DITHERFADE; + uint primitiveID : PRIMITIVEID; float3 pos3D : POSITION3D; float3 nor : NORMAL; - float2 tex : TEXCOORD; - float fade : DITHERFADE; - float4 pos2DPrev : SCREENPOSITIONPREV; - float3 color : COLOR; }; #endif // WI_HAIRPARTICLE_HF diff --git a/WickedEngine/shaders/hairparticlePS.hlsl b/WickedEngine/shaders/hairparticlePS.hlsl index 16f0392c8..2f8b21fe1 100644 --- a/WickedEngine/shaders/hairparticlePS.hlsl +++ b/WickedEngine/shaders/hairparticlePS.hlsl @@ -5,25 +5,32 @@ #include "objectHF.hlsli" #include "hairparticleHF.hlsli" -TEXTURE2D(texture_color, float4, TEXSLOT_ONDEMAND0); - [earlydepthstencil] -GBuffer main(VertexToPixel input) +float4 main(VertexToPixel input) : SV_Target { - float4 color = texture_color.Sample(sampler_linear_wrap, input.tex); - color.rgb = DEGAMMA(color.rgb); - color.rgb *= input.color; + ShaderMaterial material = HairGetMaterial(); + + float4 color = 1; + + [branch] + if (material.texture_basecolormap_index >= 0 && (g_xFrame.Options & OPTION_BIT_DISABLE_ALBEDO_MAPS) == 0) + { + color = bindless_textures[material.texture_basecolormap_index].Sample(sampler_linear_wrap, input.tex); + color.rgb = DEGAMMA(color.rgb); + } + color *= material.baseColor; + float opacity = 1; - float3 V = g_xCamera_CamPos - input.pos3D; + float3 V = g_xCamera.CamPos - input.pos3D; float dist = length(V); V /= dist; float emissive = 0; const uint2 pixel = input.pos.xy; - const float2 ScreenCoord = pixel * g_xFrame_InternalResolution_rcp; + const float2 ScreenCoord = pixel * g_xFrame.InternalResolution_rcp; Surface surface; - surface.create(g_xMaterial, color, 0); + surface.create(material, color, 0); surface.P = input.pos3D; surface.N = input.nor; surface.V = V; @@ -47,9 +54,10 @@ GBuffer main(VertexToPixel input) TiledLighting(surface, lighting); + ApplyLighting(surface, lighting, color); - ApplyFog(dist, g_xCamera_CamPos, V, color); + ApplyFog(dist, g_xCamera.CamPos, V, color); - return CreateGBuffer(color, surface); + return color; } diff --git a/WickedEngine/shaders/hairparticlePS_prepass.hlsl b/WickedEngine/shaders/hairparticlePS_prepass.hlsl index 8d2838f4d..c31f270bc 100644 --- a/WickedEngine/shaders/hairparticlePS_prepass.hlsl +++ b/WickedEngine/shaders/hairparticlePS_prepass.hlsl @@ -1,26 +1,34 @@ #include "globals.hlsli" +#include "objectHF.hlsli" #include "hairparticleHF.hlsli" +#include "ShaderInterop_HairParticle.h" -TEXTURE2D(texture_color, float4, TEXSLOT_ONDEMAND0); - -float2 main(VertexToPixel input) : SV_TARGET +uint2 main(VertexToPixel input) : SV_TARGET { + ShaderMaterial material = HairGetMaterial(); + const float lineardepth = input.pos.w; clip(dither(input.pos.xy + GetTemporalAASampleRotation()) - input.fade); - float4 color = texture_color.Sample(sampler_linear_clamp,input.tex); + float4 color = 1; - float alphatest = g_xMaterial.alphaTest; - if (g_xFrame_Options & OPTION_BIT_TEMPORALAA_ENABLED) + [branch] + if (material.texture_basecolormap_index >= 0) + { + color = bindless_textures[material.texture_basecolormap_index].Sample(sampler_linear_clamp, input.tex); + } + + float alphatest = material.alphaTest; + if (g_xFrame.Options & OPTION_BIT_TEMPORALAA_ENABLED) { alphatest = clamp(blue_noise(input.pos.xy, lineardepth).r, 0, 0.99); } clip(color.a - alphatest); - float2 ScreenCoord = input.pos.xy * g_xFrame_InternalResolution_rcp; - float2 pos2D = ScreenCoord * 2 - 1; - pos2D.y *= -1; - float2 velocity = ((input.pos2DPrev.xy / input.pos2DPrev.w - g_xFrame_TemporalAAJitterPrev) - (pos2D.xy - g_xFrame_TemporalAAJitter)) * float2(0.5f, -0.5f); - return velocity; + PrimitiveID prim; + prim.primitiveIndex = input.primitiveID; + prim.instanceIndex = xHairInstanceIndex; + prim.subsetIndex = 0; + return prim.pack(); } diff --git a/WickedEngine/shaders/hairparticlePS_simple.hlsl b/WickedEngine/shaders/hairparticlePS_simple.hlsl index a20d54300..85d2f4dd7 100644 --- a/WickedEngine/shaders/hairparticlePS_simple.hlsl +++ b/WickedEngine/shaders/hairparticlePS_simple.hlsl @@ -3,5 +3,7 @@ float4 main(VertexToPixel input) : SV_TARGET { - return float4(input.color, 1.0f); -} \ No newline at end of file + ShaderMaterial material = HairGetMaterial(); + + return material.baseColor; +} diff --git a/WickedEngine/shaders/hairparticleVS.hlsl b/WickedEngine/shaders/hairparticleVS.hlsl index bbe86317f..9c364f802 100644 --- a/WickedEngine/shaders/hairparticleVS.hlsl +++ b/WickedEngine/shaders/hairparticleVS.hlsl @@ -2,105 +2,30 @@ #include "hairparticleHF.hlsli" #include "ShaderInterop_HairParticle.h" -static const float3 HAIRPATCH[] = { - float3(-1, -1, 0), - float3(1, -1, 0), - float3(-1, 1, 0), - float3(1, 1, 0), -}; +TYPEDBUFFER(primitiveBuffer, uint, 0); -STRUCTUREDBUFFER(particleBuffer, Patch, 0); -STRUCTUREDBUFFER(culledIndexBuffer, uint, 1); - -VertexToPixel main(uint vertexID : SV_VERTEXID, uint instanceID : SV_INSTANCEID) +VertexToPixel main(uint vid : SV_VERTEXID) { + ShaderMesh mesh = HairGetMesh(); + VertexToPixel Out; + Out.primitiveID = vid / 3; - const uint particleID = culledIndexBuffer[instanceID]; - const uint segmentID = particleID % xHairSegmentCount; + uint vertexID = primitiveBuffer[vid]; + uint4 data = bindless_buffers[mesh.vb_pos_nor_wind].Load4(vertexID * 16); + float3 position = asfloat(data.xyz); + float3 normal = normalize(unpack_unitvector(data.w)); + float2 uv = unpack_half2(bindless_buffers[mesh.vb_uv0].Load(vertexID * 4)); - float3 rootposition = particleBuffer[particleID - segmentID].position; - Out.fade = saturate(distance(rootposition.xyz, g_xCamera_CamPos.xyz) / xHairViewDistance); + Out.fade = saturate(distance(position.xyz, g_xCamera.CamPos.xyz) / xHairViewDistance); Out.fade = saturate(Out.fade - 0.8f) * 5.0f; // fade will be on edge and inwards 20% - [branch] - if (Out.fade < 1.0 - 1.0f / 255.0f) - { - uint tangent_random = particleBuffer[particleID].tangent_random; - float3 normal = particleBuffer[particleID].normal; - uint binormal_length = particleBuffer[particleID].binormal_length; + Out.pos = float4(position, 1); + Out.pos3D = Out.pos.xyz; + Out.pos = mul(g_xCamera.VP, Out.pos); - float3 tangent; - tangent.x = (tangent_random >> 0) & 0x000000FF; - tangent.y = (tangent_random >> 8) & 0x000000FF; - tangent.z = (tangent_random >> 16) & 0x000000FF; - tangent = tangent / 255.0f * 2 - 1; - - uint rand = (tangent_random >> 24) & 0x000000FF; - - float3 binormal; - binormal.x = (binormal_length >> 0) & 0x000000FF; - binormal.y = (binormal_length >> 8) & 0x000000FF; - binormal.z = (binormal_length >> 16) & 0x000000FF; - binormal = binormal / 255.0f * 2 - 1; - - float len = (binormal_length >> 24) & 0x000000FF; - len /= 255.0f; - len *= xLength; - - // expand the particle into a billboard cross section, the patch: - float3 patchPos = HAIRPATCH[vertexID]; - float2 uv = vertexID < 6 ? patchPos.xy : patchPos.zy; - uv = uv * float2(0.5f, 0.5f) + 0.5f; - uv.y = lerp((float)segmentID / (float)xHairSegmentCount, ((float)segmentID + 1) / (float)xHairSegmentCount, uv.y); - uv.y = 1 - uv.y; - patchPos.y += 1; - - // Sprite sheet UV transform: - const uint currentFrame = (xHairFrameStart + rand) % xHairFrameCount; - uint2 offset = uint2(currentFrame % xHairFramesXY.x, currentFrame / xHairFramesXY.x); - uv.xy += offset; - uv.xy *= xHairTexMul; - - // scale the billboard by the texture aspect: - float2 frame = float2(xHairAspect, 1); - frame.xy *= len; - patchPos.xyz *= frame.xyx * 0.5f; - - // simplistic wind effect only affects the top, but leaves the base as is: - const float waveoffset = dot(rootposition, g_xFrame_WindDirection) * g_xFrame_WindWaveSize + rand / 255.0f * g_xFrame_WindRandomness; - const float3 wavedir = g_xFrame_WindDirection * (segmentID + patchPos.y); - const float3 wind = sin(g_xFrame_Time * g_xFrame_WindSpeed + waveoffset) * wavedir; - const float3 windPrev = sin(g_xFrame_TimePrev * g_xFrame_WindSpeed + waveoffset) * wavedir; - - // rotate the patch into the tangent space of the emitting triangle: - float3x3 TBN = float3x3(tangent, normal, binormal); // don't derive binormal, because we want the shear! - patchPos = mul(patchPos, TBN); - - // inset to the emitter a bit, to avoid disconnect: - float3 position = particleBuffer[particleID].position; - position.xyz -= normal * 0.1 * len; - - - // copy to output: - Out.pos = float4(position, 1); - Out.pos.xyz += patchPos; - float3 savedPos = Out.pos.xyz; - Out.pos.xyz += wind; - Out.pos3D = Out.pos.xyz; - Out.pos = mul(g_xCamera_VP, Out.pos); - - Out.nor = normalize(normal + wind); - Out.tex = uv; - - Out.pos2DPrev = mul(g_xCamera_PrevVP, float4(savedPos + windPrev, 1)); - - Out.color = xColor.rgb; - } - else - { - Out = (VertexToPixel)0; - } + Out.nor = normalize(normal); + Out.tex = uv; return Out; } diff --git a/WickedEngine/shaders/hairparticle_finishUpdateCS.hlsl b/WickedEngine/shaders/hairparticle_finishUpdateCS.hlsl index 7ccbabf1a..892d6b55f 100644 --- a/WickedEngine/shaders/hairparticle_finishUpdateCS.hlsl +++ b/WickedEngine/shaders/hairparticle_finishUpdateCS.hlsl @@ -13,6 +13,6 @@ void main( uint3 DTid : SV_DispatchThreadID ) // Reset counter for next frame: counterBuffer.Store(0, 0); - // Create draw argument buffer (VertexCountPerInstance, InstanceCount, StartVertexLocation, StartInstanceLocation): - counterBuffer.Store4(4, uint4(4, particleCount, 0, 0)); + // Create draw argument buffer (IndexCountPerInstance, InstanceCount, StartIndexLocation, BaseVertexLocation, StartInstanceLocation): + counterBuffer.Store4(4, uint4(particleCount * 6, 1, 0, 0)); } diff --git a/WickedEngine/shaders/hairparticle_simulateCS.hlsl b/WickedEngine/shaders/hairparticle_simulateCS.hlsl index bcdda002c..09d844526 100644 --- a/WickedEngine/shaders/hairparticle_simulateCS.hlsl +++ b/WickedEngine/shaders/hairparticle_simulateCS.hlsl @@ -1,10 +1,20 @@ #include "globals.hlsli" +#include "hairparticleHF.hlsli" #include "ShaderInterop_HairParticle.h" -RWSTRUCTUREDBUFFER(particleBuffer, Patch, 0); -RWSTRUCTUREDBUFFER(simulationBuffer, PatchSimulationData, 1); -RWSTRUCTUREDBUFFER(indexBuffer, uint, 2); -RWRAWBUFFER(counterBuffer, 3); +static const float3 HAIRPATCH[] = { + float3(-1, -1, 0), + float3(1, -1, 0), + float3(-1, 1, 0), + float3(1, 1, 0), +}; + +RWSTRUCTUREDBUFFER(simulationBuffer, PatchSimulationData, 0); +RWRAWBUFFER(vertexBuffer_POS, 1); +RWRAWBUFFER(vertexBuffer_TEX, 2); +RWTYPEDBUFFER(primitiveBuffer, uint, 3); +RWTYPEDBUFFER(culledIndexBuffer, uint, 4); +RWRAWBUFFER(counterBuffer, 5); TYPEDBUFFER(meshIndexBuffer, uint, TEXSLOT_ONDEMAND0); RAWBUFFER(meshVertexBuffer_POS, TEXSLOT_ONDEMAND1); @@ -73,8 +83,8 @@ void main(uint3 DTid : SV_DispatchThreadID, uint3 Gid : SV_GroupID, uint groupIn const uint strandID = DTid.x * xHairSegmentCount; // Transform particle by the emitter object matrix: - float3 base = mul(xWorld, float4(position.xyz, 1)).xyz; - target = normalize(mul((float3x3)xWorld, target)); + float3 base = mul(xHairWorld, float4(position.xyz, 1)).xyz; + target = normalize(mul((float3x3)xHairWorld, target)); const float3 root = base; float3 normal = 0; @@ -83,17 +93,17 @@ void main(uint3 DTid : SV_DispatchThreadID, uint3 Gid : SV_GroupID, uint groupIn { // Identifies the hair strand segment particle: const uint particleID = strandID + segmentID; - particleBuffer[particleID].tangent_random = tangent_random; - particleBuffer[particleID].binormal_length = binormal_length; + simulationBuffer[particleID].tangent_random = tangent_random; + simulationBuffer[particleID].binormal_length = binormal_length; if (xHairRegenerate) { - particleBuffer[particleID].position = base; - particleBuffer[particleID].normal = target; + simulationBuffer[particleID].position = base; + simulationBuffer[particleID].normal = target; simulationBuffer[particleID].velocity = 0; } - normal += particleBuffer[particleID].normal; + normal += simulationBuffer[particleID].normal; normal = normalize(normal); float len = (binormal_length >> 24) & 0x000000FF; @@ -104,9 +114,9 @@ void main(uint3 DTid : SV_DispatchThreadID, uint3 Gid : SV_GroupID, uint groupIn // Accumulate forces: float3 force = 0; - for (uint i = 0; i < g_xFrame_ForceFieldArrayCount; ++i) + for (uint i = 0; i < g_xFrame.ForceFieldArrayCount; ++i) { - ShaderEntity forceField = EntityArray[g_xFrame_ForceFieldArrayOffset + i]; + ShaderEntity forceField = EntityArray[g_xFrame.ForceFieldArrayOffset + i]; [branch] if (forceField.layerMask & xHairLayerMask) @@ -132,50 +142,110 @@ void main(uint3 DTid : SV_DispatchThreadID, uint3 Gid : SV_GroupID, uint groupIn // Pull back to rest position: force += (target - normal) * xStiffness; - force *= g_xFrame_DeltaTime; + force *= g_xFrame.DeltaTime; // Simulation buffer load: float3 velocity = simulationBuffer[particleID].velocity; // Apply surface-movement-based velocity: - const float3 old_base = particleBuffer[particleID].position; - const float3 old_normal = particleBuffer[particleID].normal; + const float3 old_base = simulationBuffer[particleID].position; + const float3 old_normal = simulationBuffer[particleID].normal; const float3 old_tip = old_base + old_normal * len; const float3 surface_velocity = old_tip - tip; velocity += surface_velocity; // Apply forces: velocity += force; - normal += velocity * g_xFrame_DeltaTime; + normal += velocity * g_xFrame.DeltaTime; // Drag: velocity *= 0.98f; // Store particle: - particleBuffer[particleID].position = base; - particleBuffer[particleID].normal = normalize(normal); + simulationBuffer[particleID].position = base; + simulationBuffer[particleID].normal = normalize(normal); // Store simulation data: simulationBuffer[particleID].velocity = velocity; - // Offset next segment root to current tip: - base = tip; + // Write out render buffers: + // These must be persistent, not culled (raytracing, surfels...) + uint v0 = particleID * 4; + uint i0 = particleID * 6; + primitiveBuffer[i0 + 0] = v0 + 0; + primitiveBuffer[i0 + 1] = v0 + 1; + primitiveBuffer[i0 + 2] = v0 + 2; + primitiveBuffer[i0 + 3] = v0 + 2; + primitiveBuffer[i0 + 4] = v0 + 1; + primitiveBuffer[i0 + 5] = v0 + 3; + + uint rand = (tangent_random >> 24) & 0x000000FF; + float3x3 TBN = float3x3(tangent, normal, binormal); // don't derive binormal, because we want the shear! + float3 rootposition = base - normal * 0.1 * len; // inset to the emitter a bit, to avoid disconnect: + float2 frame = float2(xHairAspect, 1) * len * 0.5; + const uint currentFrame = (xHairFrameStart + rand) % xHairFrameCount; + uint2 offset = uint2(currentFrame % xHairFramesXY.x, currentFrame / xHairFramesXY.x); + + for (uint vertexID = 0; vertexID < 4; ++vertexID) + { + // expand the particle into a billboard cross section, the patch: + float3 patchPos = HAIRPATCH[vertexID]; + float2 uv = vertexID < 6 ? patchPos.xy : patchPos.zy; + uv = uv * float2(0.5f, 0.5f) + 0.5f; + uv.y = lerp((float)segmentID / (float)xHairSegmentCount, ((float)segmentID + 1) / (float)xHairSegmentCount, uv.y); + uv.y = 1 - uv.y; + patchPos.y += 1; + + // Sprite sheet UV transform: + uv.xy += offset; + uv.xy *= xHairTexMul; + + // scale the billboard by the texture aspect: + patchPos.xyz *= frame.xyx; + + // rotate the patch into the tangent space of the emitting triangle: + patchPos = mul(patchPos, TBN); + + // simplistic wind effect only affects the top, but leaves the base as is: + const float waveoffset = dot(rootposition, g_xFrame.WindDirection) * g_xFrame.WindWaveSize + rand / 255.0f * g_xFrame.WindRandomness; + const float3 wavedir = g_xFrame.WindDirection * (segmentID + patchPos.y); + const float3 wind = sin(g_xFrame.Time * g_xFrame.WindSpeed + waveoffset) * wavedir; + + float3 position = rootposition + patchPos + wind; + + uint4 data; + data.xyz = asuint(position); + data.w = pack_unitvector(normalize(normal + wind)); + vertexBuffer_POS.Store4((v0 + vertexID) * 16, data); + vertexBuffer_TEX.Store((v0 + vertexID) * 4, pack_half2(uv)); + } // Frustum culling: uint infrustum = 1; - infrustum &= distance(base, g_xCamera_CamPos.xyz) < xHairViewDistance; - infrustum &= dot(g_xCamera_FrustumPlanes[0], float4(base, 1)) > -len; - infrustum &= dot(g_xCamera_FrustumPlanes[2], float4(base, 1)) > -len; - infrustum &= dot(g_xCamera_FrustumPlanes[3], float4(base, 1)) > -len; - infrustum &= dot(g_xCamera_FrustumPlanes[4], float4(base, 1)) > -len; - infrustum &= dot(g_xCamera_FrustumPlanes[5], float4(base, 1)) > -len; + float3 center = (base + tip) * 0.5; + float radius = -len; + infrustum &= distance(base, g_xCamera.CamPos.xyz) < xHairViewDistance; + infrustum &= dot(g_xCamera.FrustumPlanes[0], float4(center, 1)) > radius; + infrustum &= dot(g_xCamera.FrustumPlanes[2], float4(center, 1)) > radius; + infrustum &= dot(g_xCamera.FrustumPlanes[3], float4(center, 1)) > radius; + infrustum &= dot(g_xCamera.FrustumPlanes[4], float4(center, 1)) > radius; + infrustum &= dot(g_xCamera.FrustumPlanes[5], float4(center, 1)) > radius; if (infrustum) { uint prevCount; counterBuffer.InterlockedAdd(0, 1, prevCount); - indexBuffer[prevCount] = particleID; + uint ii0 = prevCount * 6; + culledIndexBuffer[ii0 + 0] = i0 + 0; + culledIndexBuffer[ii0 + 1] = i0 + 1; + culledIndexBuffer[ii0 + 2] = i0 + 2; + culledIndexBuffer[ii0 + 3] = i0 + 3; + culledIndexBuffer[ii0 + 4] = i0 + 4; + culledIndexBuffer[ii0 + 5] = i0 + 5; } + + // Offset next segment root to current tip: + base = tip; } } diff --git a/WickedEngine/shaders/hbaoCS.hlsl b/WickedEngine/shaders/hbaoCS.hlsl index e040ad963..f1b36ad0f 100644 --- a/WickedEngine/shaders/hbaoCS.hlsl +++ b/WickedEngine/shaders/hbaoCS.hlsl @@ -89,7 +89,7 @@ void main(uint3 Gid : SV_GroupID, uint groupIndex : SV_GroupIndex) { const uint2 pixel = tile_start + hbao_direction * (i - TILE_BORDER); const float2 uv = (pixel + 0.5f) * xPPResolution_rcp; - const float z = texture_lineardepth.Load(uint3(tile_start + hbao_direction * (i - TILE_BORDER), 1)) * g_xCamera_ZFarP; + const float z = texture_lineardepth.Load(uint3(tile_start + hbao_direction * (i - TILE_BORDER), 1)) * g_xCamera.ZFarP; const float2 xy = (hbao_uv_to_view_A * uv + hbao_uv_to_view_B) * z; cache[i] = float2(horizontal ? xy.x : xy.y, z); } @@ -97,7 +97,7 @@ void main(uint3 Gid : SV_GroupID, uint groupIndex : SV_GroupIndex) const uint2 pixel = tile_start + groupIndex * hbao_direction; const int center = TILE_BORDER + groupIndex; - if (pixel.x >= xPPResolution.x || pixel.y >= xPPResolution.y || cache[center].y >= g_xCamera_ZFarP - 0.99) + if (pixel.x >= xPPResolution.x || pixel.y >= xPPResolution.y || cache[center].y >= g_xCamera.ZFarP - 0.99) { return; } diff --git a/WickedEngine/shaders/imageHF.hlsli b/WickedEngine/shaders/imageHF.hlsli index 59cda07af..07c72c771 100644 --- a/WickedEngine/shaders/imageHF.hlsli +++ b/WickedEngine/shaders/imageHF.hlsli @@ -3,21 +3,6 @@ #include "globals.hlsli" #include "ShaderInterop_Image.h" -#ifdef BINDLESS -PUSHCONSTANT(push, PushConstantsImage); -Texture2D bindless_textures[] : register(space1); -SamplerState bindless_samplers[] : register(space2); -#define texture_base bindless_textures[push.texture_base_index] -#define texture_mask bindless_textures[push.texture_mask_index] -#define texture_background bindless_textures[push.texture_background_index] -#define Sampler bindless_samplers[push.sampler_index] -#else -TEXTURE2D(texture_base, float4, TEXSLOT_IMAGE_BASE); -TEXTURE2D(texture_mask, float4, TEXSLOT_IMAGE_MASK); -TEXTURE2D(texture_background, float4, TEXSLOT_IMAGE_BACKGROUND); -SAMPLERSTATE(Sampler, SSLOT_ONDEMAND0); -#endif // BINDLESS - float Wedge2D(float2 v, float2 w) { return v.x * w.y - v.y * w.x; @@ -62,8 +47,8 @@ struct VertextoPixel else uv.x = (q.y - b2.y * uv.y) / denom.y; - float2 uv0 = uv * xTexMulAdd.xy + xTexMulAdd.zw; - float2 uv1 = uv * xTexMulAdd2.xy + xTexMulAdd2.zw; + float2 uv0 = uv * push.texMulAdd.xy + push.texMulAdd.zw; + float2 uv1 = uv * push.texMulAdd2.xy + push.texMulAdd2.zw; return float4(uv0, uv1); } }; diff --git a/WickedEngine/shaders/imagePS.hlsl b/WickedEngine/shaders/imagePS.hlsl index b09a18f59..fbe4b8770 100644 --- a/WickedEngine/shaders/imagePS.hlsl +++ b/WickedEngine/shaders/imagePS.hlsl @@ -2,8 +2,38 @@ float4 main(VertextoPixel input) : SV_TARGET { + SamplerState sam = bindless_samplers[push.sampler_index]; + float4 uvsets = input.compute_uvs(); - float4 color = texture_base.Sample(Sampler, uvsets.xy) * xColor; + + float4 color = unpack_half4(push.packed_color); + [branch] + if (push.texture_base_index >= 0) + { + float4 tex = bindless_textures[push.texture_base_index].Sample(sam, uvsets.xy); + + if (push.flags & IMAGE_FLAG_EXTRACT_NORMALMAP) + { + tex.rgb = tex.rgb * 2 - 1; + } + + color *= tex; + } + + float4 mask = 1; + [branch] + if (push.texture_mask_index >= 0) + { + mask = bindless_textures[push.texture_mask_index].Sample(sam, uvsets.zw); + } + color *= mask; + + [branch] + if (push.texture_background_index >= 0) + { + float3 background = bindless_textures[push.texture_background_index].Sample(sam, (input.uv_screen.xy * float2(0.5f, -0.5f) + 0.5f) / input.uv_screen.w).rgb; + color = float4(lerp(background, color.rgb, color.a), mask.a); + } return color; } diff --git a/WickedEngine/shaders/imagePS_backgroundblur.hlsl b/WickedEngine/shaders/imagePS_backgroundblur.hlsl deleted file mode 100644 index 7515cb885..000000000 --- a/WickedEngine/shaders/imagePS_backgroundblur.hlsl +++ /dev/null @@ -1,10 +0,0 @@ -#include "imageHF.hlsli" - -float4 main(VertextoPixel input) : SV_TARGET -{ - float4 uvsets = input.compute_uvs(); - float4 color = texture_base.Sample(Sampler, uvsets.xy) * xColor; - float3 background = texture_background.Sample(Sampler, (input.uv_screen.xy * float2(0.5f, -0.5f) + 0.5f) / input.uv_screen.w).rgb; - - return float4(lerp(background, color.rgb, color.a), 1); -} diff --git a/WickedEngine/shaders/imagePS_backgroundblur_masked.hlsl b/WickedEngine/shaders/imagePS_backgroundblur_masked.hlsl deleted file mode 100644 index f7855fa9b..000000000 --- a/WickedEngine/shaders/imagePS_backgroundblur_masked.hlsl +++ /dev/null @@ -1,12 +0,0 @@ -#include "imageHF.hlsli" - -float4 main(VertextoPixel input) : SV_TARGET -{ - float4 uvsets = input.compute_uvs(); - float4 color = texture_base.Sample(Sampler, uvsets.xy) * xColor; - float3 background = texture_background.Sample(Sampler, (input.uv_screen.xy * float2(0.5f, -0.5f) + 0.5f) / input.uv_screen.w).rgb; - float4 mask = texture_mask.Sample(Sampler, uvsets.zw); - color *= mask; - - return float4(lerp(background, color.rgb, color.a), mask.a); -} diff --git a/WickedEngine/shaders/imagePS_masked.hlsl b/WickedEngine/shaders/imagePS_masked.hlsl deleted file mode 100644 index b4bce5f13..000000000 --- a/WickedEngine/shaders/imagePS_masked.hlsl +++ /dev/null @@ -1,11 +0,0 @@ -#include "imageHF.hlsli" - -float4 main(VertextoPixel input) : SV_TARGET -{ - float4 uvsets = input.compute_uvs(); - float4 color = texture_base.Sample(Sampler, uvsets.xy) * xColor; - - color *= texture_mask.Sample(Sampler, uvsets.zw); - - return color; -} diff --git a/WickedEngine/shaders/imagePS_separatenormalmap.hlsl b/WickedEngine/shaders/imagePS_separatenormalmap.hlsl deleted file mode 100644 index db9ca2072..000000000 --- a/WickedEngine/shaders/imagePS_separatenormalmap.hlsl +++ /dev/null @@ -1,13 +0,0 @@ -#include "imageHF.hlsli" - -float4 main(VertextoPixel input) : SV_TARGET -{ - float4 uvsets = input.compute_uvs(); - float4 color = texture_base.Sample(Sampler, uvsets.xy); - - color = 2 * color - 1; - - color *= xColor; - - return color; -} diff --git a/WickedEngine/shaders/imagePS_separatenormalmap_bicubic.hlsl b/WickedEngine/shaders/imagePS_separatenormalmap_bicubic.hlsl deleted file mode 100644 index b2dc5b79f..000000000 --- a/WickedEngine/shaders/imagePS_separatenormalmap_bicubic.hlsl +++ /dev/null @@ -1,13 +0,0 @@ -#include "imageHF.hlsli" - -float4 main(VertextoPixel input) : SV_TARGET -{ - float4 uvsets = input.compute_uvs(); - float4 color = SampleTextureCatmullRom(texture_base, Sampler, uvsets.xy); - - color = 2 * color - 1; - - color *= xColor; - - return color; -} diff --git a/WickedEngine/shaders/imageVS.hlsl b/WickedEngine/shaders/imageVS.hlsl index 4501da5ac..47440ee4a 100644 --- a/WickedEngine/shaders/imageVS.hlsl +++ b/WickedEngine/shaders/imageVS.hlsl @@ -11,14 +11,14 @@ VertextoPixel main(uint vI : SV_VERTEXID) // / // 3--4 - Out.pos = xCorners[vI]; + Out.pos = push.corners[vI]; Out.uv_screen = Out.pos; // Set up inverse bilinear interpolation - Out.q = Out.pos.xy - xCorners[0].xy; - Out.b1 = xCorners[1].xy - xCorners[0].xy; - Out.b2 = xCorners[2].xy - xCorners[0].xy; - Out.b3 = xCorners[0].xy - xCorners[1].xy - xCorners[2].xy + xCorners[3].xy; + Out.q = Out.pos.xy - push.corners[0].xy; + Out.b1 = push.corners[1].xy - push.corners[0].xy; + Out.b2 = push.corners[2].xy - push.corners[0].xy; + Out.b3 = push.corners[0].xy - push.corners[1].xy - push.corners[2].xy + push.corners[3].xy; return Out; } diff --git a/WickedEngine/shaders/impostorHF.hlsli b/WickedEngine/shaders/impostorHF.hlsli index abf19fd63..52a3d4a92 100644 --- a/WickedEngine/shaders/impostorHF.hlsli +++ b/WickedEngine/shaders/impostorHF.hlsli @@ -4,11 +4,11 @@ struct VSOut { float4 pos : SV_POSITION; - float3 tex : TEXCOORD; + float2 uv : TEXCOORD; + uint slice : SLICE; nointerpolation float dither : DITHER; float3 pos3D : WORLDPOSITION; - uint instanceColor : INSTANCECOLOR; - float4 pos2DPrev : SCREENPOSITIONPREV; + uint instanceID : INSTANCEID; }; TEXTURE2DARRAY(impostorTex, float4, TEXSLOT_ONDEMAND0); diff --git a/WickedEngine/shaders/impostorPS.hlsl b/WickedEngine/shaders/impostorPS.hlsl index bb194fdf2..e37db430a 100644 --- a/WickedEngine/shaders/impostorPS.hlsl +++ b/WickedEngine/shaders/impostorPS.hlsl @@ -3,15 +3,17 @@ #include "objectHF.hlsli" [earlydepthstencil] -GBuffer main(VSOut input) +float4 main(VSOut input) : SV_Target { - float3 uv_col = input.tex; + float3 uv_col = float3(input.uv, input.slice); float3 uv_nor = uv_col; uv_nor.z += impostorCaptureAngles; float3 uv_sur = uv_nor; uv_sur.z += impostorCaptureAngles; - float4 color = impostorTex.Sample(sampler_linear_clamp, uv_col) * unpack_rgba(input.instanceColor); + ShaderMeshInstance instance = load_instance(input.instanceID); + + float4 color = impostorTex.Sample(sampler_linear_clamp, uv_col) * unpack_rgba(instance.color); float3 N = impostorTex.Sample(sampler_linear_clamp, uv_nor).rgb * 2 - 1; float4 surfaceparams = impostorTex.Sample(sampler_linear_clamp, uv_sur); @@ -20,7 +22,7 @@ GBuffer main(VSOut input) float metalness = surfaceparams.b; float reflectance = surfaceparams.a; - float3 V = g_xCamera_CamPos - input.pos3D; + float3 V = g_xCamera.CamPos - input.pos3D; float dist = length(V); V /= dist; @@ -38,16 +40,11 @@ GBuffer main(VSOut input) Lighting lighting; lighting.create(0, 0, GetAmbient(surface.N), 0); - float2 ScreenCoord = surface.pixel * g_xFrame_InternalResolution_rcp; - float2 pos2D = ScreenCoord * 2 - 1; - pos2D.y *= -1; - float2 velocity = ((input.pos2DPrev.xy / input.pos2DPrev.w - g_xFrame_TemporalAAJitterPrev) - (pos2D.xy - g_xFrame_TemporalAAJitter)) * float2(0.5f, -0.5f); - TiledLighting(surface, lighting); ApplyLighting(surface, lighting, color); - ApplyFog(dist, g_xCamera_CamPos, V, color); + ApplyFog(dist, g_xCamera.CamPos, V, color); - return CreateGBuffer(color, surface); + return color; } diff --git a/WickedEngine/shaders/impostorPS_prepass.hlsl b/WickedEngine/shaders/impostorPS_prepass.hlsl index 56f6e45df..a7c796ea3 100644 --- a/WickedEngine/shaders/impostorPS_prepass.hlsl +++ b/WickedEngine/shaders/impostorPS_prepass.hlsl @@ -1,19 +1,15 @@ #include "globals.hlsli" #include "impostorHF.hlsli" -float4 main(VSOut input) : SV_TARGET +uint2 main(VSOut input) : SV_Target { clip(dither(input.pos.xy + GetTemporalAASampleRotation()) - input.dither); - float3 uv_col = input.tex; + float3 uv_col = float3(input.uv, input.slice); clip(impostorTex.Sample(sampler_linear_clamp, uv_col).a - 0.5f); - const float2 pixel = input.pos.xy; - const float2 ScreenCoord = pixel * g_xFrame_InternalResolution_rcp; - - float2 pos2D = ScreenCoord * 2 - 1; - pos2D.y *= -1; - input.pos2DPrev.xy /= input.pos2DPrev.w; - const float2 velocity = ((input.pos2DPrev.xy - g_xFrame_TemporalAAJitterPrev) - (pos2D.xy - g_xFrame_TemporalAAJitter)) * float2(0.5, -0.5); - - return float4(velocity, 0, 0); + PrimitiveID prim; + prim.primitiveIndex = ~0u; + prim.instanceIndex = input.instanceID; + prim.subsetIndex = 0; + return prim.pack(); } diff --git a/WickedEngine/shaders/impostorPS_simple.hlsl b/WickedEngine/shaders/impostorPS_simple.hlsl index a7fd97970..8701fd5f5 100644 --- a/WickedEngine/shaders/impostorPS_simple.hlsl +++ b/WickedEngine/shaders/impostorPS_simple.hlsl @@ -5,10 +5,10 @@ float4 main(VSOut input) : SV_TARGET { clip(dither(input.pos.xy + GetTemporalAASampleRotation()) - input.dither); - float3 uv_col = input.tex; + float3 uv_col = float3(input.uv, input.slice); - float4 color = impostorTex.Sample(sampler_linear_clamp, uv_col) * unpack_rgba(input.instanceColor); - clip(color.a - 0.5f); + ShaderMeshInstance instance = load_instance(input.instanceID); + float4 color = unpack_rgba(instance.color); return color; } diff --git a/WickedEngine/shaders/impostorVS.hlsl b/WickedEngine/shaders/impostorVS.hlsl index ee8830f76..8138ba739 100644 --- a/WickedEngine/shaders/impostorVS.hlsl +++ b/WickedEngine/shaders/impostorVS.hlsl @@ -1,6 +1,12 @@ #include "globals.hlsli" #include "impostorHF.hlsli" +struct ImpostorPush +{ + uint instanceOffset; +}; +PUSHCONSTANT(push, ImpostorPush); + static const float3 BILLBOARD[] = { float3(-1, -1, 0), float3(1, -1, 0), @@ -10,36 +16,30 @@ static const float3 BILLBOARD[] = { float3(1, 1, 0), }; -RAWBUFFER(instanceBuffer, TEXSLOT_ONDEMAND21); +RAWBUFFER(impostorBuffer, TEXSLOT_ONDEMAND21); VSOut main(uint fakeIndex : SV_VERTEXID) { const uint vertexID = fakeIndex % 6; const uint instanceID = fakeIndex / 6; - uint byteOffset = (uint)g_xColor.x + instanceID * 64; - - float4 mat0 = asfloat(instanceBuffer.Load4(byteOffset + 0)); - float4 mat1 = asfloat(instanceBuffer.Load4(byteOffset + 16)); - float4 mat2 = asfloat(instanceBuffer.Load4(byteOffset + 32)); - uint4 userdata = instanceBuffer.Load4(byteOffset + 48); - - float4x4 WORLD = WORLD = float4x4( - mat0, - mat1, - mat2, - float4(0, 0, 0, 1) - ); + ShaderMeshInstancePointer poi = impostorBuffer.Load(push.instanceOffset + instanceID * 8); + ShaderMeshInstance instance = load_instance(poi.instanceID); + ShaderMesh mesh = load_mesh(instance.meshIndex); + float3 extents = mesh.aabb_max - mesh.aabb_min; + float radius = max(extents.x, max(extents.y, extents.z)) * 0.5; float3 pos = BILLBOARD[vertexID]; - float3 tex = float3(pos.xy * float2(0.5f, -0.5f) + 0.5f, userdata.y); + float2 uv = float2(pos.xy * float2(0.5f, -0.5f) + 0.5f); + uint slice = poi.GetFrustumIndex(); + pos *= radius; // We rotate the billboard to face camera, but unlike emitted particles, // they don't rotate according to camera rotation, but the camera position relative // to the impostor (at least for now) - float3 origin = mul(WORLD, float4(0, 0, 0, 1)).xyz; - float3 up = normalize(mul((float3x3)WORLD, float3(0, 1, 0))); - float3 face = mul((float3x3)WORLD, g_xCamera_CamPos - origin); + float3 origin = mul(instance.transform.GetMatrix(), float4(0, 0, 0, 1)).xyz; + float3 up = normalize(mul((float3x3)instance.transform.GetMatrix(), float3(0, 1, 0))); + float3 face = mul((float3x3)instance.transform.GetMatrix(), g_xCamera.CamPos - origin); face.y = 0; // only rotate around Y axis! face = normalize(face); float3 right = normalize(cross(face, up)); @@ -52,17 +52,16 @@ VSOut main(uint fakeIndex : SV_VERTEXID) angle = 2 - angle; } angle *= 0.5f; - tex.z += floor(angle * impostorCaptureAngles); - - float4 color_dither = unpack_rgba(userdata.x); + angle = saturate(angle - 0.0001); + slice += uint(angle * impostorCaptureAngles); VSOut Out; - Out.pos3D = mul(WORLD, float4(pos, 1)).xyz; - Out.pos = mul(g_xCamera_VP, float4(Out.pos3D, 1)); - Out.tex = tex; - Out.dither = 1 - color_dither.a; - Out.instanceColor = pack_rgba(float4(color_dither.rgb, 1)); - Out.pos2DPrev = mul(g_xCamera_PrevVP, float4(Out.pos3D, 1)); + Out.pos3D = mul(instance.transform.GetMatrix(), float4(pos, 1)).xyz; + Out.pos = mul(g_xCamera.VP, float4(Out.pos3D, 1)); + Out.uv = uv; + Out.slice = slice; + Out.dither = poi.GetDither(); + Out.instanceID = poi.instanceID; return Out; } diff --git a/WickedEngine/shaders/lensFlareVS.hlsl b/WickedEngine/shaders/lensFlareVS.hlsl index 12de86765..c2a76cd28 100644 --- a/WickedEngine/shaders/lensFlareVS.hlsl +++ b/WickedEngine/shaders/lensFlareVS.hlsl @@ -1,5 +1,7 @@ #include "globals.hlsli" +PUSHCONSTANT(push, LensFlarePush); + TEXTURE2D(texture_occlusion, float4, TEXSLOT_ONDEMAND0); static const float2 BILLBOARD[] = { @@ -22,8 +24,8 @@ VertexOut main(uint vertexID : SV_VertexID) Out.uv = BILLBOARD[vertexID] * 0.5f + 0.5f; // determine the flare opacity based on depth buffer occlusion and occlusion mask: - float referenceDepth = saturate(1 - xLensFlarePos.z); - const float2 step = 1.0 / (GetInternalResolution() * xLensFlarePos.z); + float referenceDepth = saturate(1 - push.xLensFlarePos.z); + const float2 step = 1.0 / (GetInternalResolution() * push.xLensFlarePos.z); const float2 range = 10.5 * step; float samples = 0; float visibility = 0; @@ -32,8 +34,8 @@ VertexOut main(uint vertexID : SV_VertexID) for (float x = -range.x; x <= range.x; x += step.x) { samples++; - float vis = texture_occlusion.SampleLevel(sampler_linear_clamp, xLensFlarePos.xy + float2(x, y), 0).r; - vis *= texture_depth.SampleLevel(sampler_point_clamp, xLensFlarePos.xy + float2(x, y), 0).r <= referenceDepth ? 1 : 0; + float vis = texture_occlusion.SampleLevel(sampler_linear_clamp, push.xLensFlarePos.xy + float2(x, y), 0).r; + vis *= texture_depth.SampleLevel(sampler_point_clamp, push.xLensFlarePos.xy + float2(x, y), 0).r <= referenceDepth ? 1 : 0; visibility += vis; } } @@ -41,11 +43,11 @@ VertexOut main(uint vertexID : SV_VertexID) Out.opacity = visibility; - float2 pos = (xLensFlarePos.xy - 0.5) * float2(2, -2); - float2 moddedpos = pos * xLensFlareOffset; + float2 pos = (push.xLensFlarePos.xy - 0.5) * float2(2, -2); + float2 moddedpos = pos * push.xLensFlareOffset; Out.opacity *= saturate(1 - length(pos - moddedpos)); - Out.pos = float4(moddedpos + BILLBOARD[vertexID] * xLensFlareSize * g_xFrame_CanvasSize_rcp, 0, 1); + Out.pos = float4(moddedpos + BILLBOARD[vertexID] * push.xLensFlareSize * g_xFrame.CanvasSize_rcp, 0, 1); return Out; } diff --git a/WickedEngine/shaders/lightCullingCS.hlsl b/WickedEngine/shaders/lightCullingCS.hlsl index b45b8563b..582f05523 100644 --- a/WickedEngine/shaders/lightCullingCS.hlsl +++ b/WickedEngine/shaders/lightCullingCS.hlsl @@ -2,7 +2,7 @@ #include "cullingShaderHF.hlsli" #include "lightingHF.hlsli" -#define entityCount (g_xFrame_LightArrayCount + g_xFrame_DecalArrayCount + g_xFrame_EnvProbeArrayCount) +#define entityCount (g_xFrame.LightArrayCount + g_xFrame.DecalArrayCount + g_xFrame.EnvProbeArrayCount) STRUCTUREDBUFFER(in_Frustums, Frustum, TEXSLOT_ONDEMAND0); @@ -94,7 +94,7 @@ void main(uint3 Gid : SV_GroupID, uint3 DTid : SV_DispatchThreadID, uint3 GTid : uint i = 0; // Compute addresses and load frustum: - const uint flatTileIndex = flatten2D(Gid.xy, g_xFrame_EntityCullingTileCount.xy); + const uint flatTileIndex = flatten2D(Gid.xy, g_xFrame.EntityCullingTileCount.xy); const uint tileBucketsAddress = flatTileIndex * SHADER_ENTITY_TILE_BUCKET_COUNT; const uint bucketIndex = groupIndex; Frustum GroupFrustum = in_Frustums[flatTileIndex]; @@ -182,7 +182,7 @@ void main(uint3 Gid : SV_GroupID, uint3 DTid : SV_DispatchThreadID, uint3 GTid : // We can perform coarse AABB intersection tests with this: GroupAABB_WS = GroupAABB; - AABBtransform(GroupAABB_WS, g_xCamera_InvV); + AABBtransform(GroupAABB_WS, g_xCamera.InvV); } // Convert depth values to view space. @@ -223,7 +223,7 @@ void main(uint3 Gid : SV_GroupID, uint3 DTid : SV_DispatchThreadID, uint3 GTid : { case ENTITY_TYPE_POINTLIGHT: { - float3 positionVS = mul(g_xCamera_View, float4(entity.position, 1)).xyz; + float3 positionVS = mul(g_xCamera.View, float4(entity.position, 1)).xyz; Sphere sphere = { positionVS.xyz, entity.GetRange() }; if (SphereInsideFrustum(sphere, GroupFrustum, nearClipVS, maxDepthVS)) { @@ -243,8 +243,8 @@ void main(uint3 Gid : SV_GroupID, uint3 DTid : SV_DispatchThreadID, uint3 GTid : break; case ENTITY_TYPE_SPOTLIGHT: { - float3 positionVS = mul(g_xCamera_View, float4(entity.position, 1)).xyz; - float3 directionVS = mul((float3x3)g_xCamera_View, entity.GetDirection()); + float3 positionVS = mul(g_xCamera.View, float4(entity.position, 1)).xyz; + float3 directionVS = mul((float3x3)g_xCamera.View, entity.GetDirection()); // Construct a tight fitting sphere around the spotlight cone: const float r = entity.GetRange() * 0.5f / (entity.GetConeAngleCos() * entity.GetConeAngleCos()); Sphere sphere = { positionVS - directionVS * r, r }; @@ -274,7 +274,7 @@ void main(uint3 Gid : SV_GroupID, uint3 DTid : SV_DispatchThreadID, uint3 GTid : case ENTITY_TYPE_DECAL: case ENTITY_TYPE_ENVMAP: { - float3 positionVS = mul(g_xCamera_View, float4(entity.position, 1)).xyz; + float3 positionVS = mul(g_xCamera.View, float4(entity.position, 1)).xyz; Sphere sphere = { positionVS.xyz, entity.GetRange() }; if (SphereInsideFrustum(sphere, GroupFrustum, nearClipVS, maxDepthVS)) { diff --git a/WickedEngine/shaders/lightingHF.hlsli b/WickedEngine/shaders/lightingHF.hlsli index ca9d08e65..cf1fa7e1b 100644 --- a/WickedEngine/shaders/lightingHF.hlsli +++ b/WickedEngine/shaders/lightingHF.hlsli @@ -50,22 +50,22 @@ inline float3 shadowCascade(in ShaderEntity light, in float3 shadowPos, in float float3 shadow = 0; #ifndef DISABLE_SOFT_SHADOWMAP // sample along a rectangle pattern around center: - shadow.x += texture_shadowarray_2d.SampleCmpLevelZero(sampler_cmp_depth, float3(shadowUV + float2(-1, -1) * g_xFrame_ShadowKernel2D, slice), realDistance); - shadow.x += texture_shadowarray_2d.SampleCmpLevelZero(sampler_cmp_depth, float3(shadowUV + float2(-1, 0) * g_xFrame_ShadowKernel2D, slice), realDistance); - shadow.x += texture_shadowarray_2d.SampleCmpLevelZero(sampler_cmp_depth, float3(shadowUV + float2(-1, 1) * g_xFrame_ShadowKernel2D, slice), realDistance); - shadow.x += texture_shadowarray_2d.SampleCmpLevelZero(sampler_cmp_depth, float3(shadowUV + float2(0, -1) * g_xFrame_ShadowKernel2D, slice), realDistance); + shadow.x += texture_shadowarray_2d.SampleCmpLevelZero(sampler_cmp_depth, float3(shadowUV + float2(-1, -1) * g_xFrame.ShadowKernel2D, slice), realDistance); + shadow.x += texture_shadowarray_2d.SampleCmpLevelZero(sampler_cmp_depth, float3(shadowUV + float2(-1, 0) * g_xFrame.ShadowKernel2D, slice), realDistance); + shadow.x += texture_shadowarray_2d.SampleCmpLevelZero(sampler_cmp_depth, float3(shadowUV + float2(-1, 1) * g_xFrame.ShadowKernel2D, slice), realDistance); + shadow.x += texture_shadowarray_2d.SampleCmpLevelZero(sampler_cmp_depth, float3(shadowUV + float2(0, -1) * g_xFrame.ShadowKernel2D, slice), realDistance); shadow.x += texture_shadowarray_2d.SampleCmpLevelZero(sampler_cmp_depth, float3(shadowUV, slice), realDistance); - shadow.x += texture_shadowarray_2d.SampleCmpLevelZero(sampler_cmp_depth, float3(shadowUV + float2(0, 1) * g_xFrame_ShadowKernel2D, slice), realDistance); - shadow.x += texture_shadowarray_2d.SampleCmpLevelZero(sampler_cmp_depth, float3(shadowUV + float2(1, -1) * g_xFrame_ShadowKernel2D, slice), realDistance); - shadow.x += texture_shadowarray_2d.SampleCmpLevelZero(sampler_cmp_depth, float3(shadowUV + float2(1, 0) * g_xFrame_ShadowKernel2D, slice), realDistance); - shadow.x += texture_shadowarray_2d.SampleCmpLevelZero(sampler_cmp_depth, float3(shadowUV + float2(1, 1) * g_xFrame_ShadowKernel2D, slice), realDistance); + shadow.x += texture_shadowarray_2d.SampleCmpLevelZero(sampler_cmp_depth, float3(shadowUV + float2(0, 1) * g_xFrame.ShadowKernel2D, slice), realDistance); + shadow.x += texture_shadowarray_2d.SampleCmpLevelZero(sampler_cmp_depth, float3(shadowUV + float2(1, -1) * g_xFrame.ShadowKernel2D, slice), realDistance); + shadow.x += texture_shadowarray_2d.SampleCmpLevelZero(sampler_cmp_depth, float3(shadowUV + float2(1, 0) * g_xFrame.ShadowKernel2D, slice), realDistance); + shadow.x += texture_shadowarray_2d.SampleCmpLevelZero(sampler_cmp_depth, float3(shadowUV + float2(1, 1) * g_xFrame.ShadowKernel2D, slice), realDistance); shadow = shadow.xxx / 9.0; #else shadow = texture_shadowarray_2d.SampleCmpLevelZero(sampler_cmp_depth, float3(shadowUV, slice), realDistance); #endif // DISABLE_SOFT_SHADOWMAP #ifndef DISABLE_TRANSPARENT_SHADOWMAP - if (g_xFrame_Options & OPTION_BIT_TRANSPARENTSHADOWS_ENABLED) + if (g_xFrame.Options & OPTION_BIT_TRANSPARENTSHADOWS_ENABLED) { float4 transparent_shadow = texture_shadowarray_transparent_2d.SampleLevel(sampler_linear_clamp, float3(shadowUV, slice), 0); #ifdef TRANSPARENT_SHADOWMAP_SECONDARY_DEPTH_CHECK @@ -89,22 +89,22 @@ inline float3 shadowCube(in ShaderEntity light, in float3 L, in float3 Lunnormal #ifndef DISABLE_SOFT_SHADOWMAP // sample along a cube pattern around center: L = -L; - shadow += texture_shadowarray_cube.SampleCmpLevelZero(sampler_cmp_depth, float4(L + float3(-1, -1, -1) * g_xFrame_ShadowKernelCube, slice), remappedDistance); - shadow += texture_shadowarray_cube.SampleCmpLevelZero(sampler_cmp_depth, float4(L + float3(1, -1, -1) * g_xFrame_ShadowKernelCube, slice), remappedDistance); - shadow += texture_shadowarray_cube.SampleCmpLevelZero(sampler_cmp_depth, float4(L + float3(-1, 1, -1) * g_xFrame_ShadowKernelCube, slice), remappedDistance); - shadow += texture_shadowarray_cube.SampleCmpLevelZero(sampler_cmp_depth, float4(L + float3(1, 1, -1) * g_xFrame_ShadowKernelCube, slice), remappedDistance); + shadow += texture_shadowarray_cube.SampleCmpLevelZero(sampler_cmp_depth, float4(L + float3(-1, -1, -1) * g_xFrame.ShadowKernelCube, slice), remappedDistance); + shadow += texture_shadowarray_cube.SampleCmpLevelZero(sampler_cmp_depth, float4(L + float3(1, -1, -1) * g_xFrame.ShadowKernelCube, slice), remappedDistance); + shadow += texture_shadowarray_cube.SampleCmpLevelZero(sampler_cmp_depth, float4(L + float3(-1, 1, -1) * g_xFrame.ShadowKernelCube, slice), remappedDistance); + shadow += texture_shadowarray_cube.SampleCmpLevelZero(sampler_cmp_depth, float4(L + float3(1, 1, -1) * g_xFrame.ShadowKernelCube, slice), remappedDistance); shadow += texture_shadowarray_cube.SampleCmpLevelZero(sampler_cmp_depth, float4(L, slice), remappedDistance).r; - shadow += texture_shadowarray_cube.SampleCmpLevelZero(sampler_cmp_depth, float4(L + float3(-1, -1, 1) * g_xFrame_ShadowKernelCube, slice), remappedDistance); - shadow += texture_shadowarray_cube.SampleCmpLevelZero(sampler_cmp_depth, float4(L + float3(1, -1, 1) * g_xFrame_ShadowKernelCube, slice), remappedDistance); - shadow += texture_shadowarray_cube.SampleCmpLevelZero(sampler_cmp_depth, float4(L + float3(-1, 1, 1) * g_xFrame_ShadowKernelCube, slice), remappedDistance); - shadow += texture_shadowarray_cube.SampleCmpLevelZero(sampler_cmp_depth, float4(L + float3(1, 1, 1) * g_xFrame_ShadowKernelCube, slice), remappedDistance); + shadow += texture_shadowarray_cube.SampleCmpLevelZero(sampler_cmp_depth, float4(L + float3(-1, -1, 1) * g_xFrame.ShadowKernelCube, slice), remappedDistance); + shadow += texture_shadowarray_cube.SampleCmpLevelZero(sampler_cmp_depth, float4(L + float3(1, -1, 1) * g_xFrame.ShadowKernelCube, slice), remappedDistance); + shadow += texture_shadowarray_cube.SampleCmpLevelZero(sampler_cmp_depth, float4(L + float3(-1, 1, 1) * g_xFrame.ShadowKernelCube, slice), remappedDistance); + shadow += texture_shadowarray_cube.SampleCmpLevelZero(sampler_cmp_depth, float4(L + float3(1, 1, 1) * g_xFrame.ShadowKernelCube, slice), remappedDistance); shadow /= 9.0; #else shadow = texture_shadowarray_cube.SampleCmpLevelZero(sampler_cmp_depth, float4(-Lunnormalized, slice), remappedDistance).r; #endif // DISABLE_SOFT_SHADOWMAP #ifndef DISABLE_TRANSPARENT_SHADOWMAP - if (g_xFrame_Options & OPTION_BIT_TRANSPARENTSHADOWS_ENABLED) + if (g_xFrame.Options & OPTION_BIT_TRANSPARENTSHADOWS_ENABLED) { float4 transparent_shadow = texture_shadowarray_transparent_cube.SampleLevel(sampler_linear_clamp, float4(-Lunnormalized, slice), 0); #ifdef TRANSPARENT_SHADOWMAP_SECONDARY_DEPTH_CHECK @@ -137,12 +137,12 @@ inline void DirectionalLight(in ShaderEntity light, in Surface surface, inout Li { #ifdef SHADOW_MASK_ENABLED [branch] - if ((g_xFrame_Options & OPTION_BIT_RAYTRACED_SHADOWS) == 0) + if ((g_xFrame.Options & OPTION_BIT_RAYTRACED_SHADOWS) == 0) #endif // SHADOW_MASK_ENABLED { // Loop through cascades from closest (smallest) to furthest (largest) [loop] - for (uint cascade = 0; cascade < g_xFrame_ShadowCascadeCount; ++cascade) + for (uint cascade = 0; cascade < g_xFrame.ShadowCascadeCount; ++cascade) { // Project into shadow map space (no need to divide by .w because ortho projection!): float3 ShPos = mul(MatrixArray[light.GetMatrixIndex() + cascade], float4(surface.P, 1)).xyz; @@ -158,7 +158,7 @@ inline void DirectionalLight(in ShaderEntity light, in Surface surface, inout Li // If we are on cascade edge threshold and not the last cascade, then fallback to a larger cascade: [branch] - if (cascade_fade > 0 && cascade < g_xFrame_ShadowCascadeCount - 1) + if (cascade_fade > 0 && cascade < g_xFrame.ShadowCascadeCount - 1) { // Project into next shadow cascade (no need to divide by .w because ortho projection!): cascade += 1; @@ -182,9 +182,9 @@ inline void DirectionalLight(in ShaderEntity light, in Surface surface, inout Li if (any(shadow)) { float3 atmosphereTransmittance = 1; - if (g_xFrame_Options & OPTION_BIT_REALISTIC_SKY) + if (g_xFrame.Options & OPTION_BIT_REALISTIC_SKY) { - atmosphereTransmittance = GetAtmosphericLightTransmittance(g_xFrame_Atmosphere, surface.P, L, texture_transmittancelut); + atmosphereTransmittance = GetAtmosphericLightTransmittance(g_xFrame.Atmosphere, surface.P, L, texture_transmittancelut); } float3 lightColor = light.GetColor().rgb * light.GetEnergy() * shadow * atmosphereTransmittance; @@ -223,7 +223,7 @@ inline void PointLight(in ShaderEntity light, in Surface surface, inout Lighting { #ifdef SHADOW_MASK_ENABLED [branch] - if ((g_xFrame_Options & OPTION_BIT_RAYTRACED_SHADOWS) == 0) + if ((g_xFrame.Options & OPTION_BIT_RAYTRACED_SHADOWS) == 0) #endif // SHADOW_MASK_ENABLED { shadow *= shadowCube(light, L, Lunnormalized); @@ -279,7 +279,7 @@ inline void SpotLight(in ShaderEntity light, in Surface surface, inout Lighting { #ifdef SHADOW_MASK_ENABLED [branch] - if ((g_xFrame_Options & OPTION_BIT_RAYTRACED_SHADOWS) == 0) + if ((g_xFrame.Options & OPTION_BIT_RAYTRACED_SHADOWS) == 0) #endif // SHADOW_MASK_ENABLED { float4 ShPos = mul(MatrixArray[light.GetMatrixIndex() + 0], float4(surface.P, 1)); @@ -332,7 +332,7 @@ inline float3 GetAmbient(in float3 N) #else - ambient = texture_envmaparray.SampleLevel(sampler_linear_clamp, float4(N, g_xFrame_GlobalEnvProbeIndex), g_xFrame_EnvProbeMipCount).rgb; + ambient = texture_envmaparray.SampleLevel(sampler_linear_clamp, float4(N, g_xFrame.GlobalEnvProbeIndex), g_xFrame.EnvProbeMipCount).rgb; #endif // ENVMAPRENDERING @@ -365,19 +365,19 @@ inline float3 EnvironmentReflection_Global(in Surface surface) #else - float MIP = surface.roughness * g_xFrame_EnvProbeMipCount; - envColor = texture_envmaparray.SampleLevel(sampler_linear_clamp, float4(surface.R, g_xFrame_GlobalEnvProbeIndex), MIP).rgb * surface.F; + float MIP = surface.roughness * g_xFrame.EnvProbeMipCount; + envColor = texture_envmaparray.SampleLevel(sampler_linear_clamp, float4(surface.R, g_xFrame.GlobalEnvProbeIndex), MIP).rgb * surface.F; #ifdef BRDF_SHEEN envColor *= surface.sheen.albedoScaling; - MIP = surface.sheen.roughness * g_xFrame_EnvProbeMipCount; - envColor += texture_envmaparray.SampleLevel(sampler_linear_clamp, float4(surface.R, g_xFrame_GlobalEnvProbeIndex), MIP).rgb * surface.sheen.color * surface.sheen.DFG; + MIP = surface.sheen.roughness * g_xFrame.EnvProbeMipCount; + envColor += texture_envmaparray.SampleLevel(sampler_linear_clamp, float4(surface.R, g_xFrame.GlobalEnvProbeIndex), MIP).rgb * surface.sheen.color * surface.sheen.DFG; #endif // BRDF_SHEEN #ifdef BRDF_CLEARCOAT envColor *= 1 - surface.clearcoat.F; - MIP = surface.clearcoat.roughness * g_xFrame_EnvProbeMipCount; - envColor += texture_envmaparray.SampleLevel(sampler_linear_clamp, float4(surface.clearcoat.R, g_xFrame_GlobalEnvProbeIndex), MIP).rgb * surface.clearcoat.F; + MIP = surface.clearcoat.roughness * g_xFrame.EnvProbeMipCount; + envColor += texture_envmaparray.SampleLevel(sampler_linear_clamp, float4(surface.clearcoat.R, g_xFrame.GlobalEnvProbeIndex), MIP).rgb * surface.clearcoat.F; #endif // BRDF_CLEARCOAT #endif // ENVMAPRENDERING @@ -403,12 +403,12 @@ inline float4 EnvironmentReflection_Local(in Surface surface, in ShaderEntity pr float3 R_parallaxCorrected = IntersectPositionWS - probe.position; // Sample cubemap texture: - float MIP = surface.roughness * g_xFrame_EnvProbeMipCount; + float MIP = surface.roughness * g_xFrame.EnvProbeMipCount; float3 envColor = texture_envmaparray.SampleLevel(sampler_linear_clamp, float4(R_parallaxCorrected, probe.GetTextureIndex()), MIP).rgb * surface.F; #ifdef BRDF_SHEEN envColor *= surface.sheen.albedoScaling; - MIP = surface.sheen.roughness * g_xFrame_EnvProbeMipCount; + MIP = surface.sheen.roughness * g_xFrame.EnvProbeMipCount; envColor += texture_envmaparray.SampleLevel(sampler_linear_clamp, float4(R_parallaxCorrected, probe.GetTextureIndex()), MIP).rgb * surface.sheen.color * surface.sheen.DFG; #endif // BRDF_SHEEN @@ -422,7 +422,7 @@ inline float4 EnvironmentReflection_Local(in Surface surface, in ShaderEntity pr R_parallaxCorrected = IntersectPositionWS - probe.position; envColor *= 1 - surface.clearcoat.F; - MIP = surface.clearcoat.roughness * g_xFrame_EnvProbeMipCount; + MIP = surface.clearcoat.roughness * g_xFrame.EnvProbeMipCount; envColor += texture_envmaparray.SampleLevel(sampler_linear_clamp, float4(R_parallaxCorrected, probe.GetTextureIndex()), MIP).rgb * surface.clearcoat.F; #endif // BRDF_CLEARCOAT @@ -438,26 +438,26 @@ inline float4 EnvironmentReflection_Local(in Surface surface, in ShaderEntity pr inline void VoxelGI(in Surface surface, inout Lighting lighting) { - [branch] if (g_xFrame_VoxelRadianceDataRes != 0) + [branch] if (g_xFrame.VoxelRadianceDataRes != 0) { // determine blending factor (we will blend out voxel GI on grid edges): - float3 voxelSpacePos = surface.P - g_xFrame_VoxelRadianceDataCenter; - voxelSpacePos *= g_xFrame_VoxelRadianceDataSize_rcp; - voxelSpacePos *= g_xFrame_VoxelRadianceDataRes_rcp; + float3 voxelSpacePos = surface.P - g_xFrame.VoxelRadianceDataCenter; + voxelSpacePos *= g_xFrame.VoxelRadianceDataSize_rcp; + voxelSpacePos *= g_xFrame.VoxelRadianceDataRes_rcp; voxelSpacePos = saturate(abs(voxelSpacePos)); float blend = 1 - pow(max(voxelSpacePos.x, max(voxelSpacePos.y, voxelSpacePos.z)), 4); // diffuse: { - float4 trace = ConeTraceDiffuse(texture_voxelradiance, surface.P, surface.N); + float4 trace = ConeTraceDiffuse(texture_voxelgi, surface.P, surface.N); lighting.indirect.diffuse = lerp(lighting.indirect.diffuse, trace.rgb, trace.a * blend); } // specular: [branch] - if (g_xFrame_Options & OPTION_BIT_VOXELGI_REFLECTIONS_ENABLED) + if (g_xFrame.Options & OPTION_BIT_VOXELGI_REFLECTIONS_ENABLED) { - float4 trace = ConeTraceSpecular(texture_voxelradiance, surface.P, surface.N, surface.V, surface.roughness); + float4 trace = ConeTraceSpecular(texture_voxelgi, surface.P, surface.N, surface.V, surface.roughness); lighting.indirect.specular = lerp(lighting.indirect.specular, trace.rgb * surface.F, trace.a * blend); } } diff --git a/WickedEngine/shaders/lineardepthCS.hlsl b/WickedEngine/shaders/lineardepthCS.hlsl deleted file mode 100644 index c5269cfa5..000000000 --- a/WickedEngine/shaders/lineardepthCS.hlsl +++ /dev/null @@ -1,89 +0,0 @@ -#include "globals.hlsli" -#include "ShaderInterop_Renderer.h" -#include "ShaderInterop_Postprocess.h" - -RWTEXTURE2D(output_lineardepth_mip0, float, 0); -RWTEXTURE2D(output_lineardepth_mip1, float, 1); -RWTEXTURE2D(output_lineardepth_mip2, float, 2); -RWTEXTURE2D(output_lineardepth_mip3, float, 3); -RWTEXTURE2D(output_lineardepth_mip4, float, 4); -RWTEXTURE2D(output_lineardepth_mip5, float, 5); - -RWTEXTURE2D(output_depth_mip1, float, 6); -RWTEXTURE2D(output_depth_mip2, float, 7); - -groupshared float tile[POSTPROCESS_LINEARDEPTH_BLOCKSIZE][POSTPROCESS_LINEARDEPTH_BLOCKSIZE]; - -[numthreads(POSTPROCESS_LINEARDEPTH_BLOCKSIZE, POSTPROCESS_LINEARDEPTH_BLOCKSIZE, 1)] -void main(uint3 DTid : SV_DispatchThreadID, uint3 GTid : SV_GroupThreadID) -{ - // Native depth MAX chain: - // Native depth MAX = closest pixel - const float4 depths = float4( - texture_depth[clamp(DTid.xy * 2 + uint2(0, 0), 0, lineardepth_inputresolution - 1)], - texture_depth[clamp(DTid.xy * 2 + uint2(1, 0), 0, lineardepth_inputresolution - 1)], - texture_depth[clamp(DTid.xy * 2 + uint2(0, 1), 0, lineardepth_inputresolution - 1)], - texture_depth[clamp(DTid.xy * 2 + uint2(1, 1), 0, lineardepth_inputresolution - 1)] - ); - - float maxdepth = max(depths.x, max(depths.y, max(depths.z, depths.w))); - tile[GTid.x][GTid.y] = maxdepth; - output_depth_mip1[DTid.xy] = maxdepth; - GroupMemoryBarrierWithGroupSync(); - - if (GTid.x % 2 == 0 && GTid.y % 2 == 0) - { - maxdepth = max(tile[GTid.x][GTid.y], max(tile[GTid.x + 1][GTid.y], max(tile[GTid.x][GTid.y + 1], tile[GTid.x + 1][GTid.y + 1]))); - tile[GTid.x][GTid.y] = maxdepth; - output_depth_mip2[DTid.xy / 2] = maxdepth; - } - GroupMemoryBarrierWithGroupSync(); - - // Linear depth MAX chain: - // Linear depth MAX = farthest pixel - const float4 lineardepths = float4( - getLinearDepth(depths.x), - getLinearDepth(depths.y), - getLinearDepth(depths.z), - getLinearDepth(depths.w) - ) * g_xCamera_ZFarP_rcp; - output_lineardepth_mip0[DTid.xy * 2 + uint2(0, 0)] = lineardepths.x; - output_lineardepth_mip0[DTid.xy * 2 + uint2(1, 0)] = lineardepths.y; - output_lineardepth_mip0[DTid.xy * 2 + uint2(0, 1)] = lineardepths.z; - output_lineardepth_mip0[DTid.xy * 2 + uint2(1, 1)] = lineardepths.w; - - maxdepth = max(lineardepths.x, max(lineardepths.y, max(lineardepths.z, lineardepths.w))); - tile[GTid.x][GTid.y] = maxdepth; - output_lineardepth_mip1[DTid.xy] = maxdepth; - GroupMemoryBarrierWithGroupSync(); - - if (GTid.x % 2 == 0 && GTid.y % 2 == 0) - { - maxdepth = max(tile[GTid.x][GTid.y], max(tile[GTid.x + 1][GTid.y], max(tile[GTid.x][GTid.y + 1], tile[GTid.x + 1][GTid.y+ 1]))); - tile[GTid.x][GTid.y] = maxdepth; - output_lineardepth_mip2[DTid.xy / 2] = maxdepth; - } - GroupMemoryBarrierWithGroupSync(); - - if (GTid.x % 4 == 0 && GTid.y % 4 == 0) - { - maxdepth = max(tile[GTid.x][GTid.y], max(tile[GTid.x + 2][GTid.y], max(tile[GTid.x][GTid.y + 2], tile[GTid.x + 2][GTid.y + 2]))); - tile[GTid.x][GTid.y] = maxdepth; - output_lineardepth_mip3[DTid.xy / 4] = maxdepth; - } - GroupMemoryBarrierWithGroupSync(); - - if (GTid.x % 8 == 0 && GTid.y % 8 == 0) - { - maxdepth = max(tile[GTid.x][GTid.y], max(tile[GTid.x + 4][GTid.y], max(tile[GTid.x][GTid.y + 4], tile[GTid.x + 4][GTid.y + 4]))); - tile[GTid.x][GTid.y] = maxdepth; - output_lineardepth_mip4[DTid.xy / 8] = maxdepth; - } - GroupMemoryBarrierWithGroupSync(); - - if (GTid.x % 16 == 0 && GTid.y % 16 == 0) - { - maxdepth = max(tile[GTid.x][GTid.y], max(tile[GTid.x + 8][GTid.y], max(tile[GTid.x][GTid.y + 8], tile[GTid.x + 8][GTid.y + 8]))); - output_lineardepth_mip5[DTid.xy / 16] = maxdepth; - } -} diff --git a/WickedEngine/shaders/luminancePass2CS.hlsl b/WickedEngine/shaders/luminancePass2CS.hlsl index 89783ef2f..2b11eda83 100644 --- a/WickedEngine/shaders/luminancePass2CS.hlsl +++ b/WickedEngine/shaders/luminancePass2CS.hlsl @@ -39,7 +39,7 @@ void main( float lastlum = output[uint2(0, 0)]; // https://github.com/TheRealMJP/BakingLab/blob/master/BakingLab/LuminanceReduction.hlsl - float newlum = lastlum + (currentlum - lastlum) * (1 - exp(-g_xFrame_DeltaTime * luminance_adaptionrate)); + float newlum = lastlum + (currentlum - lastlum) * (1 - exp(-g_xFrame.DeltaTime * luminance_adaptionrate)); output[uint2(0, 0)] = newlum; } diff --git a/WickedEngine/shaders/motionblurCS.hlsl b/WickedEngine/shaders/motionblurCS.hlsl index 8a5857569..bf6953ac8 100644 --- a/WickedEngine/shaders/motionblurCS.hlsl +++ b/WickedEngine/shaders/motionblurCS.hlsl @@ -62,7 +62,7 @@ void main(uint3 Gid : SV_GroupID, uint3 GTid : SV_GroupThreadID) const float neighborhood_velocity_magnitude = length(neighborhood_velocity); const float4 center_color = input[pixel]; - const float2 center_velocity = texture_gbuffer2[pixel].xy * motionblur_strength; + const float2 center_velocity = texture_gbuffer1[pixel].xy * motionblur_strength; const float center_velocity_magnitude = length(center_velocity); const float center_depth = texture_lineardepth[pixel]; @@ -85,12 +85,12 @@ void main(uint3 Gid : SV_GroupID, uint3 GTid : SV_GroupThreadID) for (float i = -range; i <= range; i += 2.0f) { const float depth1 = texture_lineardepth.SampleLevel(sampler_point_clamp, uv2, 0); - const float2 velocity1 = texture_gbuffer2.SampleLevel(sampler_point_clamp, uv2, 0).xy; + const float2 velocity1 = texture_gbuffer1.SampleLevel(sampler_point_clamp, uv2, 0).xy; const float velocity_magnitude1 = length(velocity1); const float3 color1 = input.SampleLevel(sampler_point_clamp, uv2, 0).rgb; uv2 += sampling_direction; const float depth2 = texture_lineardepth.SampleLevel(sampler_point_clamp, uv2, 0); - const float2 velocity2 = texture_gbuffer2.SampleLevel(sampler_point_clamp, uv2, 0).xy; + const float2 velocity2 = texture_gbuffer1.SampleLevel(sampler_point_clamp, uv2, 0).xy; const float velocity_magnitude2 = length(velocity2); const float3 color2 = input.SampleLevel(sampler_point_clamp, uv2, 0).rgb; uv2 += sampling_direction; @@ -99,8 +99,8 @@ void main(uint3 Gid : SV_GroupID, uint3 GTid : SV_GroupThreadID) sum += float4(color1, 1); sum += float4(color2, 1); #else - float weight1 = SampleWeight(center_depth, depth1, neighborhood_velocity_magnitude, center_velocity_magnitude, velocity_magnitude1, 1000, g_xCamera_ZFarP); - float weight2 = SampleWeight(center_depth, depth2, neighborhood_velocity_magnitude, center_velocity_magnitude, velocity_magnitude2, 1000, g_xCamera_ZFarP); + float weight1 = SampleWeight(center_depth, depth1, neighborhood_velocity_magnitude, center_velocity_magnitude, velocity_magnitude1, 1000, g_xCamera.ZFarP); + float weight2 = SampleWeight(center_depth, depth2, neighborhood_velocity_magnitude, center_velocity_magnitude, velocity_magnitude2, 1000, g_xCamera.ZFarP); bool2 mirror = bool2(depth1 > depth2, velocity_magnitude2 > velocity_magnitude1); weight1 = all(mirror) ? weight2 : weight1; diff --git a/WickedEngine/shaders/motionblur_tileMaxVelocity_horizontalCS.hlsl b/WickedEngine/shaders/motionblur_tileMaxVelocity_horizontalCS.hlsl index 152240b02..c657f8874 100644 --- a/WickedEngine/shaders/motionblur_tileMaxVelocity_horizontalCS.hlsl +++ b/WickedEngine/shaders/motionblur_tileMaxVelocity_horizontalCS.hlsl @@ -17,7 +17,7 @@ void main(uint3 DTid : SV_DispatchThreadID) for (uint i = 0; i < MOTIONBLUR_TILESIZE.x; ++i) { const uint2 pixel = uint2(tile_upperleft.x + i, tile_upperleft.y); - const float2 velocity = texture_gbuffer2[pixel].xy; + const float2 velocity = texture_gbuffer1[pixel].xy; const float magnitude = length(velocity); if (magnitude > max_magnitude) { diff --git a/WickedEngine/shaders/normalsfromdepthCS.hlsl b/WickedEngine/shaders/normalsfromdepthCS.hlsl index 0b08db920..b3256830c 100644 --- a/WickedEngine/shaders/normalsfromdepthCS.hlsl +++ b/WickedEngine/shaders/normalsfromdepthCS.hlsl @@ -46,7 +46,7 @@ void main(uint3 DTid : SV_DispatchThreadID, uint3 Gid : SV_GroupID, uint3 GTid : const float center_Z = tile_Z[cross_idx[0]]; [branch] - if (center_Z >= g_xCamera_ZFarP) + if (center_Z >= g_xCamera.ZFarP) return; const uint best_Z_horizontal = abs(tile_Z[cross_idx[1]] - center_Z) < abs(tile_Z[cross_idx[2]] - center_Z) ? 1 : 2; diff --git a/WickedEngine/shaders/objectDS_prepass.hlsl b/WickedEngine/shaders/objectDS_prepass.hlsl index 8c21ff2ee..71abad1f9 100644 --- a/WickedEngine/shaders/objectDS_prepass.hlsl +++ b/WickedEngine/shaders/objectDS_prepass.hlsl @@ -1,5 +1,5 @@ #define OBJECTSHADER_COMPILE_DS -#define OBJECTSHADER_LAYOUT_POS_PREVPOS_TEX +#define OBJECTSHADER_LAYOUT_PREPASS_TEX #define OBJECTSHADER_USE_NORMAL #include "objectHF_tessellation.hlsli" diff --git a/WickedEngine/shaders/objectDS_prepass_alphatest.hlsl b/WickedEngine/shaders/objectDS_prepass_alphatest.hlsl index 8c21ff2ee..71abad1f9 100644 --- a/WickedEngine/shaders/objectDS_prepass_alphatest.hlsl +++ b/WickedEngine/shaders/objectDS_prepass_alphatest.hlsl @@ -1,5 +1,5 @@ #define OBJECTSHADER_COMPILE_DS -#define OBJECTSHADER_LAYOUT_POS_PREVPOS_TEX +#define OBJECTSHADER_LAYOUT_PREPASS_TEX #define OBJECTSHADER_USE_NORMAL #include "objectHF_tessellation.hlsli" diff --git a/WickedEngine/shaders/objectDS_simple.hlsl b/WickedEngine/shaders/objectDS_simple.hlsl index 175854253..b6b534938 100644 --- a/WickedEngine/shaders/objectDS_simple.hlsl +++ b/WickedEngine/shaders/objectDS_simple.hlsl @@ -1,5 +1,5 @@ #define OBJECTSHADER_COMPILE_DS -#define OBJECTSHADER_LAYOUT_POS_TEX +#define OBJECTSHADER_LAYOUT_SHADOW_TEX #define OBJECTSHADER_USE_COLOR #define OBJECTSHADER_USE_NORMAL #include "objectHF_tessellation.hlsli" diff --git a/WickedEngine/shaders/objectGS_voxelizer.hlsl b/WickedEngine/shaders/objectGS_voxelizer.hlsl index 4b4d2065a..5802787c1 100644 --- a/WickedEngine/shaders/objectGS_voxelizer.hlsl +++ b/WickedEngine/shaders/objectGS_voxelizer.hlsl @@ -32,7 +32,7 @@ void main( GSOutput output; // World space -> Voxel grid space: - output.pos.xyz = (input[i].pos.xyz - g_xFrame_VoxelRadianceDataCenter) * g_xFrame_VoxelRadianceDataSize_rcp; + output.pos.xyz = (input[i].pos.xyz - g_xFrame.VoxelRadianceDataCenter) * g_xFrame.VoxelRadianceDataSize_rcp; // Project onto dominant axis: [flatten] @@ -46,7 +46,7 @@ void main( } // Voxel grid space -> Clip space - output.pos.xy *= g_xFrame_VoxelRadianceDataRes_rcp; + output.pos.xy *= g_xFrame.VoxelRadianceDataRes_rcp; output.pos.zw = 1; // Append the rest of the parameters as is: diff --git a/WickedEngine/shaders/objectHF.hlsli b/WickedEngine/shaders/objectHF.hlsli index f2c64c249..5fc87abcd 100644 --- a/WickedEngine/shaders/objectHF.hlsli +++ b/WickedEngine/shaders/objectHF.hlsli @@ -20,38 +20,39 @@ #include "globals.hlsli" #include "brdf.hlsli" #include "lightingHF.hlsli" +#include "ShaderInterop_SurfelGI.h" // DEFINITIONS ////////////////// -#ifdef BINDLESS -Texture2D bindless_textures[] : register(t0, space1); -SamplerState bindless_samplers[] : register(t0, space2); -ByteAddressBuffer bindless_buffers[] : register(t0, space3); PUSHCONSTANT(push, ObjectPushConstants); +inline uint GetSubsetIndex() +{ + return push.GetSubsetIndex(); +} inline ShaderMesh GetMesh() { - return bindless_buffers[push.mesh].Load(0); + return load_mesh(push.GetMeshIndex()); } inline ShaderMaterial GetMaterial() { - return bindless_buffers[push.material].Load(0); + return load_material(push.GetMaterialIndex()); } inline ShaderMaterial GetMaterial1() { - return bindless_buffers[GetMesh().blendmaterial1].Load(0); + return load_material(GetMesh().blendmaterial1); } inline ShaderMaterial GetMaterial2() { - return bindless_buffers[GetMesh().blendmaterial2].Load(0); + return load_material(GetMesh().blendmaterial2); } inline ShaderMaterial GetMaterial3() { - return bindless_buffers[GetMesh().blendmaterial3].Load(0); + return load_material(GetMesh().blendmaterial3); } -#define sampler_objectshader bindless_samplers[g_xFrame_ObjectShaderSamplerIndex] +#define sampler_objectshader bindless_samplers[g_xFrame.ObjectShaderSamplerIndex] #define texture_basecolormap bindless_textures[GetMaterial().texture_basecolormap_index] #define texture_normalmap bindless_textures[GetMaterial().texture_normalmap_index] @@ -83,57 +84,6 @@ inline ShaderMaterial GetMaterial3() #define texture_blend3_emissivemap bindless_textures[GetMaterial3().texture_emissivemap_index] -#else - -inline ShaderMaterial GetMaterial() -{ - return g_xMaterial; -} -inline ShaderMaterial GetMaterial1() -{ - return g_xMaterial_blend1; -} -inline ShaderMaterial GetMaterial2() -{ - return g_xMaterial_blend2; -} -inline ShaderMaterial GetMaterial3() -{ - return g_xMaterial_blend3; -} - -// These are bound by wiRenderer (based on Material): -TEXTURE2D(texture_basecolormap, float4, TEXSLOT_RENDERER_BASECOLORMAP); // rgb: baseColor, a: opacity -TEXTURE2D(texture_normalmap, float3, TEXSLOT_RENDERER_NORMALMAP); // rgb: normal -TEXTURE2D(texture_surfacemap, float4, TEXSLOT_RENDERER_SURFACEMAP); // r: occlusion, g: roughness, b: metallic, a: reflectance -TEXTURE2D(texture_emissivemap, float4, TEXSLOT_RENDERER_EMISSIVEMAP); // rgba: emissive -TEXTURE2D(texture_displacementmap, float, TEXSLOT_RENDERER_DISPLACEMENTMAP); // r: heightmap -TEXTURE2D(texture_occlusionmap, float, TEXSLOT_RENDERER_OCCLUSIONMAP); // r: occlusion -TEXTURE2D(texture_transmissionmap, float, TEXSLOT_RENDERER_TRANSMISSIONMAP); // r: transmission factor -TEXTURE2D(texture_sheencolormap, float3, TEXSLOT_RENDERER_SHEENCOLORMAP); // rgb -TEXTURE2D(texture_sheenroughnessmap, float4, TEXSLOT_RENDERER_SHEENROUGHNESSMAP); // a -TEXTURE2D(texture_clearcoatmap, float, TEXSLOT_RENDERER_CLEARCOATMAP); // r -TEXTURE2D(texture_clearcoatroughnessmap, float2, TEXSLOT_RENDERER_CLEARCOATROUGHNESSMAP); // g -TEXTURE2D(texture_clearcoatnormalmap, float3, TEXSLOT_RENDERER_CLEARCOATNORMALMAP); // rgb -TEXTURE2D(texture_specularmap, float4, TEXSLOT_RENDERER_SPECULARMAP); // rgb color, a intensity - -TEXTURE2D(texture_blend1_basecolormap, float4, TEXSLOT_RENDERER_BLEND1_BASECOLORMAP); // rgb: baseColor, a: opacity -TEXTURE2D(texture_blend1_normalmap, float3, TEXSLOT_RENDERER_BLEND1_NORMALMAP); // rgb: normal -TEXTURE2D(texture_blend1_surfacemap, float4, TEXSLOT_RENDERER_BLEND1_SURFACEMAP); // r: occlusion, g: roughness, b: metallic, a: reflectance -TEXTURE2D(texture_blend1_emissivemap, float4, TEXSLOT_RENDERER_BLEND1_EMISSIVEMAP); // rgba: emissive - -TEXTURE2D(texture_blend2_basecolormap, float4, TEXSLOT_RENDERER_BLEND2_BASECOLORMAP); // rgb: baseColor, a: opacity -TEXTURE2D(texture_blend2_normalmap, float3, TEXSLOT_RENDERER_BLEND2_NORMALMAP); // rgb: normal -TEXTURE2D(texture_blend2_surfacemap, float4, TEXSLOT_RENDERER_BLEND2_SURFACEMAP); // r: occlusion, g: roughness, b: metallic, a: reflectance -TEXTURE2D(texture_blend2_emissivemap, float4, TEXSLOT_RENDERER_BLEND2_EMISSIVEMAP); // rgba: emissive - -TEXTURE2D(texture_blend3_basecolormap, float4, TEXSLOT_RENDERER_BLEND3_BASECOLORMAP); // rgb: baseColor, a: opacity -TEXTURE2D(texture_blend3_normalmap, float3, TEXSLOT_RENDERER_BLEND3_NORMALMAP); // rgb: normal -TEXTURE2D(texture_blend3_surfacemap, float4, TEXSLOT_RENDERER_BLEND3_SURFACEMAP); // r: occlusion, g: roughness, b: metallic, a: reflectance -TEXTURE2D(texture_blend3_emissivemap, float4, TEXSLOT_RENDERER_BLEND3_EMISSIVEMAP); // rgba: emissive - -#endif // BINDLESS - // These are bound by RenderPath (based on Render Path): STRUCTUREDBUFFER(EntityTiles, uint, TEXSLOT_RENDERPATH_ENTITYTILES); @@ -143,26 +93,18 @@ TEXTURE2D(texture_waterriples, float4, TEXSLOT_RENDERPATH_WATERRIPPLES); // rgb: TEXTURE2D(texture_ao, float, TEXSLOT_RENDERPATH_AO); // r: ambient occlusion TEXTURE2D(texture_ssr, float4, TEXSLOT_RENDERPATH_SSR); // rgb: screen space ray-traced reflections, a: reflection blend based on ray hit or miss TEXTURE2D(texture_rtshadow, uint4, TEXSLOT_RENDERPATH_RTSHADOW); // bitmask for max 16 shadows' visibility +TEXTURE2D(texture_surfelgi, float3, TEXSLOT_RENDERPATH_SURFELGI); // Use these to compile this file as shader prototype: //#define OBJECTSHADER_COMPILE_VS - compile vertex shader prototype //#define OBJECTSHADER_COMPILE_PS - compile pixel shader prototype -// Use these to define the expected input layout for the shader: -//#define OBJECTSHADER_LAYOUT_POS - input layout that has position and instance matrix -//#define OBJECTSHADER_LAYOUT_POS_TEX - input layout that has position and texture coords -//#define OBJECTSHADER_LAYOUT_POS_PREVPOS - input layout that has position and previous frame position -//#define OBJECTSHADER_LAYOUT_POS_PREVPOS_TEX - input layout that has position, previous frame position and texture coords -//#define OBJECTSHADER_LAYOUT_COMMON - input layout that has all the required inputs for common shaders - -// Use these to define the expected input layout for the shader, but in a fine grained manner: -// (These will not define additional capabilities) -//#define OBJECTSHADER_INPUT_POS - adds position to input layout -//#define OBJECTSHADER_INPUT_PRE - adds previous frame position to input layout -//#define OBJECTSHADER_INPUT_TEX - adds texture coordinates to input layout -//#define OBJECTSHADER_INPUT_ATL - adds atlas texture coords to input layout -//#define OBJECTSHADER_INPUT_COL - adds vertex colors to input layout -//#define OBJECTSHADER_INPUT_TAN - adds tangents to input layout +// Use these to define the expected layout for the shader: +//#define OBJECTSHADER_LAYOUT_SHADOW - layout for shadow pass +//#define OBJECTSHADER_LAYOUT_SHADOW_TEX - layout for shadow pass and alpha test or transparency +//#define OBJECTSHADER_LAYOUT_PREPASS - layout for prepass +//#define OBJECTSHADER_LAYOUT_PREPASS_TEX - layout for prepass and alpha test or dithering +//#define OBJECTSHADER_LAYOUT_COMMON - layout for common passes // Use these to enable features for the shader: // (Some of these are enabled automatically with OBJECTSHADER_LAYOUT defines) @@ -175,50 +117,37 @@ TEXTURE2D(texture_rtshadow, uint4, TEXSLOT_RENDERPATH_RTSHADOW); // bitmask fo //#define OBJECTSHADER_USE_NORMAL - shader will use normals //#define OBJECTSHADER_USE_TANGENT - shader will use tangents, normal mapping //#define OBJECTSHADER_USE_POSITION3D - shader will use world space positions -//#define OBJECTSHADER_USE_POSITIONPREV - shader will use previous frame positions //#define OBJECTSHADER_USE_EMISSIVE - shader will use emissive //#define OBJECTSHADER_USE_RENDERTARGETARRAYINDEX - shader will use dynamic render target slice selection //#define OBJECTSHADER_USE_NOCAMERA - shader will not use camera space transform +//#define OBJECTSHADER_USE_INSTANCEID - shader will use instance ID -#ifdef OBJECTSHADER_LAYOUT_POS // used by opaque shadows -#define OBJECTSHADER_INPUT_POS +#ifdef OBJECTSHADER_LAYOUT_SHADOW #define OBJECTSHADER_USE_WIND -#endif // OBJECTSHADER_LAYOUT_POS +#endif // OBJECTSHADER_LAYOUT_SHADOW -#ifdef OBJECTSHADER_LAYOUT_POS_TEX // used by shadows with alpha test or transparency -#define OBJECTSHADER_INPUT_POS -#define OBJECTSHADER_INPUT_TEX +#ifdef OBJECTSHADER_LAYOUT_SHADOW_TEX #define OBJECTSHADER_USE_WIND #define OBJECTSHADER_USE_UVSETS #define OBJECTSHADER_USE_COLOR -#endif // OBJECTSHADER_LAYOUT_POS_TEX +#endif // OBJECTSHADER_LAYOUT_SHADOW_TEX -#ifdef OBJECTSHADER_LAYOUT_POS_PREVPOS // used by depth prepass -#define OBJECTSHADER_INPUT_POS -#define OBJECTSHADER_INPUT_PRE +#ifdef OBJECTSHADER_LAYOUT_PREPASS #define OBJECTSHADER_USE_CLIPPLANE #define OBJECTSHADER_USE_WIND -#define OBJECTSHADER_USE_POSITIONPREV -#endif // OBJECTSHADER_LAYOUT_POS +#define OBJECTSHADER_USE_INSTANCEID +#endif // OBJECTSHADER_LAYOUT_SHADOW -#ifdef OBJECTSHADER_LAYOUT_POS_PREVPOS_TEX // used by depth prepass with alpha test or dithered transparency -#define OBJECTSHADER_INPUT_POS -#define OBJECTSHADER_INPUT_PRE -#define OBJECTSHADER_INPUT_TEX +#ifdef OBJECTSHADER_LAYOUT_PREPASS_TEX #define OBJECTSHADER_USE_CLIPPLANE #define OBJECTSHADER_USE_WIND -#define OBJECTSHADER_USE_POSITIONPREV #define OBJECTSHADER_USE_UVSETS #define OBJECTSHADER_USE_DITHERING -#endif // OBJECTSHADER_LAYOUT_POS_TEX +#define OBJECTSHADER_USE_INSTANCEID +#endif // OBJECTSHADER_LAYOUT_SHADOW_TEX -#ifdef OBJECTSHADER_LAYOUT_COMMON // used by common render passes -#define OBJECTSHADER_INPUT_POS -#define OBJECTSHADER_INPUT_TEX -#define OBJECTSHADER_INPUT_ATL -#define OBJECTSHADER_INPUT_COL -#define OBJECTSHADER_INPUT_TAN +#ifdef OBJECTSHADER_LAYOUT_COMMON #define OBJECTSHADER_USE_CLIPPLANE #define OBJECTSHADER_USE_WIND #define OBJECTSHADER_USE_UVSETS @@ -228,28 +157,11 @@ TEXTURE2D(texture_rtshadow, uint4, TEXSLOT_RENDERPATH_RTSHADOW); // bitmask fo #define OBJECTSHADER_USE_TANGENT #define OBJECTSHADER_USE_POSITION3D #define OBJECTSHADER_USE_EMISSIVE +#define OBJECTSHADER_USE_INSTANCEID #endif // OBJECTSHADER_LAYOUT_COMMON -#ifdef BINDLESS -static const uint instance_stride_matrix_userdata = 16 * 4; -static const uint instance_stride_atlas = 16; -static const uint instance_stride_prev = 16 * 3; - -#ifdef OBJECTSHADER_INPUT_PRE -static const uint instance_stride = instance_stride_matrix_userdata + instance_stride_prev; -#else -#ifdef OBJECTSHADER_INPUT_ATL -static const uint instance_stride = instance_stride_matrix_userdata + instance_stride_atlas; -#else -static const uint instance_stride = instance_stride_matrix_userdata; -#endif // OBJECTSHADER_INPUT_ATL -#endif // OBJECTSHADER_INPUT_PRE -#endif // BINDLESS - struct VertexInput { -#ifdef BINDLESS - // Data coming from bindless fetching: uint vertexID : SV_VertexID; uint instanceID : SV_InstanceID; @@ -272,7 +184,6 @@ struct VertexInput return ((normal_wind >> 24u) & 0xFF) / 255.0; } -#ifdef OBJECTSHADER_INPUT_TEX float2 GetUV0() { [branch] @@ -287,51 +198,17 @@ struct VertexInput return 0; return unpack_half2(bindless_buffers[GetMesh().vb_uv1].Load(vertexID * 4)); } -#endif // OBJECTSHADER_INPUT_TEX - float4x4 GetInstanceMatrix() + ShaderMeshInstancePointer GetInstancePointer() { - float4 mat0 = bindless_buffers[push.instances].Load(push.instance_offset + instanceID * instance_stride + 16 * 0); - float4 mat1 = bindless_buffers[push.instances].Load(push.instance_offset + instanceID * instance_stride + 16 * 1); - float4 mat2 = bindless_buffers[push.instances].Load(push.instance_offset + instanceID * instance_stride + 16 * 2); - return float4x4( - mat0, - mat1, - mat2, - float4(0, 0, 0, 1) - ); - } - uint4 GetInstanceUserdata() - { - return bindless_buffers[push.instances].Load(push.instance_offset + instanceID * instance_stride + 16 * 3); + if (push.instances >= 0) + return bindless_buffers[push.instances].Load(push.instance_offset + instanceID * 8); + + ShaderMeshInstancePointer poi; + poi.init(); + return poi; } -#ifdef OBJECTSHADER_INPUT_PRE - float4 GetPositionPrev() - { - int descriptor_index = GetMesh().vb_pre; - [branch] - if (descriptor_index < 0) - { - descriptor_index = GetMesh().vb_pos_nor_wind; - } - return float4(bindless_buffers[descriptor_index].Load(vertexID * 16), 1); - } - float4x4 GetInstanceMatrixPrev() - { - float4 matPrev0 = bindless_buffers[push.instances].Load(push.instance_offset + instanceID * instance_stride + 16 * 4); - float4 matPrev1 = bindless_buffers[push.instances].Load(push.instance_offset + instanceID * instance_stride + 16 * 5); - float4 matPrev2 = bindless_buffers[push.instances].Load(push.instance_offset + instanceID * instance_stride + 16 * 6); - return float4x4( - matPrev0, - matPrev1, - matPrev2, - float4(0, 0, 0, 1) - ); - } -#endif // OBJECTSHADER_INPUT_PRE - -#ifdef OBJECTSHADER_INPUT_ATL float2 GetAtlasUV() { [branch] @@ -339,13 +216,7 @@ struct VertexInput return 0; return unpack_half2(bindless_buffers[GetMesh().vb_atl].Load(vertexID * 4)); } - float4 GetInstanceAtlas() - { - return bindless_buffers[push.instances].Load(push.instance_offset + instanceID * instance_stride + 16 * 4); - } -#endif // OBJECTSHADER_INPUT_ATL -#ifdef OBJECTSHADER_INPUT_COL float4 GetVertexColor() { [branch] @@ -353,128 +224,24 @@ struct VertexInput return 1; return unpack_rgba(bindless_buffers[GetMesh().vb_col].Load(vertexID * 4)); } -#endif // OBJECTSHADER_INPUT_COL -#ifdef OBJECTSHADER_INPUT_TAN float4 GetTangent() { + [branch] + if (GetMesh().vb_tan < 0) + return 0; return unpack_utangent(bindless_buffers[GetMesh().vb_tan].Load(vertexID * 4)) * 2 - 1; } -#endif // OBJECTSHADER_INPUT_TAN - - - - -#else - // Data coming from input layout: - float4 pos : POSITION_NORMAL_WIND; - float4 GetPosition() + ShaderMeshInstance GetInstance() { - return float4(pos.xyz, 1); - } - float3 GetNormal() - { - const uint normal_wind = asuint(pos.w); - float3 normal; - normal.x = (float)((normal_wind >> 0u) & 0xFF) / 255.0 * 2 - 1; - normal.y = (float)((normal_wind >> 8u) & 0xFF) / 255.0 * 2 - 1; - normal.z = (float)((normal_wind >> 16u) & 0xFF) / 255.0 * 2 - 1; - return normal; - } - float GetWindWeight() - { - const uint normal_wind = asuint(pos.w); - return ((normal_wind >> 24u) & 0xFF) / 255.0; - } + if (push.instances >= 0) + return load_instance(GetInstancePointer().instanceID); -#ifdef OBJECTSHADER_INPUT_PRE - float4 pre : PREVPOS; - float4 GetPositionPrev() - { - return float4(pre.xyz, 1); + ShaderMeshInstance inst; + inst.init(); + return inst; } -#endif // OBJECTSHADER_INPUT_PRE - -#ifdef OBJECTSHADER_INPUT_TEX - float2 uv0 : UVSET0; - float2 uv1 : UVSET1; - float2 GetUV0() - { - return uv0; - } - float2 GetUV1() - { - return uv1; - } -#endif // OBJECTSHADER_INPUT_TEX - -#ifdef OBJECTSHADER_INPUT_ATL - float2 atl : ATLAS; - float2 GetAtlasUV() - { - return atl; - } -#endif // OBJECTSHADER_INPUT_ATL - -#ifdef OBJECTSHADER_INPUT_COL - float4 col : COLOR; - float4 GetVertexColor() - { - return col; - } -#endif // OBJECTSHADER_INPUT_COL - -#ifdef OBJECTSHADER_INPUT_TAN - float4 tan : TANGENT; - float4 GetTangent() - { - return tan * 2 - 1; - } -#endif // OBJECTSHADER_INPUT_TAN - - float4 mat0 : INSTANCEMATRIX0; - float4 mat1 : INSTANCEMATRIX1; - float4 mat2 : INSTANCEMATRIX2; - uint4 userdata : INSTANCEUSERDATA; - -#ifdef OBJECTSHADER_INPUT_PRE - float4 matPrev0 : INSTANCEMATRIXPREV0; - float4 matPrev1 : INSTANCEMATRIXPREV1; - float4 matPrev2 : INSTANCEMATRIXPREV2; - float4x4 GetInstanceMatrixPrev() - { - return float4x4( - matPrev0, - matPrev1, - matPrev2, - float4(0, 0, 0, 1) - ); - } -#endif // OBJECTSHADER_INPUT_PRE - -#ifdef OBJECTSHADER_INPUT_ATL - float4 atlasMulAdd : INSTANCEATLAS; - float4 GetInstanceAtlas() - { - return atlasMulAdd; - } -#endif // OBJECTSHADER_INPUT_ATL - - float4x4 GetInstanceMatrix() - { - return float4x4( - mat0, - mat1, - mat2, - float4(0, 0, 0, 1) - ); - } - uint4 GetInstanceUserdata() - { - return userdata; - } -#endif // BINDLESS }; @@ -486,65 +253,40 @@ struct VertexSurface float4 color; float3 normal; float4 tangent; - float4 positionPrev; uint emissiveColor; inline void create(in ShaderMaterial material, in VertexInput input) { - float4x4 WORLD = input.GetInstanceMatrix(); - uint4 userdata = input.GetInstanceUserdata(); position = input.GetPosition(); - color = material.baseColor * unpack_rgba(userdata.x); - emissiveColor = userdata.z; + color = material.baseColor * unpack_rgba(input.GetInstance().color); + color.a *= 1 - input.GetInstancePointer().GetDither(); + emissiveColor = input.GetInstance().emissive; -#ifdef OBJECTSHADER_INPUT_PRE - positionPrev = input.GetPositionPrev(); -#else - positionPrev = position; -#endif // OBJECTSHADER_INPUT_PRE - -#ifdef OBJECTSHADER_INPUT_COL if (material.IsUsingVertexColors()) { color *= input.GetVertexColor(); } -#endif // OBJECTSHADER_INPUT_COL - normal = normalize(mul((float3x3)WORLD, input.GetNormal())); + normal = normalize(mul((float3x3)input.GetInstance().transformInverseTranspose.GetMatrix(), input.GetNormal())); -#ifdef OBJECTSHADER_INPUT_TAN tangent = input.GetTangent(); - tangent.xyz = normalize(mul((float3x3)WORLD, tangent.xyz)); -#endif // OBJECTSHADER_INPUT_TAN + tangent.xyz = normalize(mul((float3x3)input.GetInstance().transformInverseTranspose.GetMatrix(), tangent.xyz)); -#ifdef OBJECTSHADER_INPUT_TEX uvsets = float4(input.GetUV0() * material.texMulAdd.xy + material.texMulAdd.zw, input.GetUV1()); -#endif // OBJECTSHADER_INPUT_TEX -#ifdef OBJECTSHADER_INPUT_ATL - float4 atlasMulAdd = input.GetInstanceAtlas(); - atlas = input.GetAtlasUV() * atlasMulAdd.xy + atlasMulAdd.zw; -#endif // OBJECTSHADER_INPUT_ATL + atlas = input.GetAtlasUV(); - position = mul(WORLD, position); + position = mul(input.GetInstance().transform.GetMatrix(), position); -#ifdef OBJECTSHADER_INPUT_PRE - positionPrev = mul(input.GetInstanceMatrixPrev(), positionPrev); -#else - positionPrev = position; -#endif // OBJECTSHADER_INPUT_PRE #ifdef OBJECTSHADER_USE_WIND if (material.IsUsingWind()) { const float windweight = input.GetWindWeight(); - const float waveoffset = dot(position.xyz, g_xFrame_WindDirection) * g_xFrame_WindWaveSize + (position.x + position.y + position.z) * g_xFrame_WindRandomness; - const float waveoffsetPrev = dot(positionPrev.xyz, g_xFrame_WindDirection) * g_xFrame_WindWaveSize + (positionPrev.x + positionPrev.y + positionPrev.z) * g_xFrame_WindRandomness; - const float3 wavedir = g_xFrame_WindDirection * windweight; - const float3 wind = sin(g_xFrame_Time * g_xFrame_WindSpeed + waveoffset) * wavedir; - const float3 windPrev = sin(g_xFrame_TimePrev * g_xFrame_WindSpeed + waveoffsetPrev) * wavedir; + const float waveoffset = dot(position.xyz, g_xFrame.WindDirection) * g_xFrame.WindWaveSize + (position.x + position.y + position.z) * g_xFrame.WindRandomness; + const float3 wavedir = g_xFrame.WindDirection * windweight; + const float3 wind = sin(g_xFrame.Time * g_xFrame.WindSpeed + waveoffset) * wavedir; position.xyz += wind; - positionPrev.xyz += windPrev; } #endif // OBJECTSHADER_USE_WIND } @@ -554,22 +296,26 @@ struct PixelInput { precise float4 pos : SV_POSITION; +#ifdef OBJECTSHADER_USE_INSTANCEID + uint instanceID : INSTANCEID; +#endif // OBJECTSHADER_USE_INSTANCEID + #ifdef OBJECTSHADER_USE_CLIPPLANE float clip : SV_ClipDistance0; #endif // OBJECTSHADER_USE_CLIPPLANE -#ifdef OBJECTSHADER_USE_POSITIONPREV - float4 pre : PREVIOUSPOSITION; -#endif // OBJECTSHADER_USE_POSITIONPREV +#ifdef OBJECTSHADER_USE_DITHERING + nointerpolation float dither : DITHER; +#endif // OBJECTSHADER_USE_DITHERING + +#ifdef OBJECTSHADER_USE_EMISSIVE + uint emissiveColor : EMISSIVECOLOR; +#endif // OBJECTSHADER_USE_EMISSIVE #ifdef OBJECTSHADER_USE_COLOR float4 color : COLOR; #endif // OBJECTSHADER_USE_COLOR -#ifdef OBJECTSHADER_USE_DITHERING - nointerpolation float dither : DITHER; -#endif // OBJECTSHADER_USE_DITHERING - #ifdef OBJECTSHADER_USE_UVSETS float4 uvsets : UVSETS; #endif // OBJECTSHADER_USE_UVSETS @@ -590,10 +336,6 @@ struct PixelInput float3 pos3D : WORLDPOSITION; #endif // OBJECTSHADER_USE_POSITION3D -#ifdef OBJECTSHADER_USE_EMISSIVE - uint emissiveColor : EMISSIVECOLOR; -#endif // OBJECTSHADER_USE_EMISSIVE - #ifdef OBJECTSHADER_USE_RENDERTARGETARRAYINDEX #ifdef VPRT_EMULATION uint RTIndex : RTINDEX; @@ -603,23 +345,6 @@ struct PixelInput #endif // OBJECTSHADER_USE_RENDERTARGETARRAYINDEX }; -struct GBuffer -{ - float4 g0 : SV_TARGET0; /*FORMAT_R11G11B10_FLOAT*/ - float4 g1 : SV_TARGET1; /*FORMAT_R8G8B8A8_FLOAT*/ -}; -inline GBuffer CreateGBuffer(in float4 color, in Surface surface) -{ - GBuffer gbuffer; - gbuffer.g0 = color; -#ifdef BRDF_CLEARCOAT - gbuffer.g1 = float4(surface.clearcoat.N * 0.5f + 0.5f, surface.clearcoat.roughness); -#else - gbuffer.g1 = float4(surface.N * 0.5f + 0.5f, surface.roughness); -#endif // BRDF_CLEARCOAT - return gbuffer; -} - // METHODS //////////// @@ -629,15 +354,16 @@ inline void ApplyEmissive(in Surface surface, inout Lighting lighting) lighting.direct.specular += surface.emissiveColor.rgb * surface.emissiveColor.a; } -inline void LightMapping(in float2 ATLAS, inout Lighting lighting) +inline void LightMapping(in int lightmap, in float2 ATLAS, inout Lighting lighting) { [branch] - if (any(ATLAS)) + if (lightmap >= 0 && any(ATLAS)) { + Texture2D texture_lightmap = bindless_textures[NonUniformResourceIndex(lightmap)]; #ifdef LIGHTMAP_QUALITY_BICUBIC - lighting.indirect.diffuse = SampleTextureCatmullRom(texture_globallightmap, sampler_linear_clamp, ATLAS).rgb; + lighting.indirect.diffuse = SampleTextureCatmullRom(texture_lightmap, sampler_linear_clamp, ATLAS).rgb; #else - lighting.indirect.diffuse = texture_globallightmap.SampleLevel(sampler_linear_clamp, ATLAS, 0).rgb; + lighting.indirect.diffuse = texture_lightmap.SampleLevel(sampler_linear_clamp, ATLAS, 0).rgb; #endif // LIGHTMAP_QUALITY_BICUBIC } } @@ -662,7 +388,7 @@ inline void NormalMapping(in float4 uvsets, inout float3 N, in float3x3 TBN, out inline float3 PlanarReflection(in Surface surface, in float2 bumpColor) { - float4 reflectionUV = mul(g_xCamera_ReflVP, float4(surface.P, 1)); + float4 reflectionUV = mul(g_xCamera.ReflVP, float4(surface.P, 1)); reflectionUV.xy /= reflectionUV.w; reflectionUV.xy = reflectionUV.xy * float2(0.5, -0.5) + 0.5; return texture_reflection.SampleLevel(sampler_linear_clamp, reflectionUV.xy + bumpColor*GetMaterial().normalMapStrength, 0).rgb; @@ -726,22 +452,28 @@ inline void ForwardLighting(inout Surface surface, inout Lighting lighting) [branch] if (decalAccumulation.a < 1) { - ShaderEntity decal = EntityArray[g_xFrame_DecalArrayOffset + entity_index]; + ShaderEntity decal = EntityArray[g_xFrame.DecalArrayOffset + entity_index]; if ((decal.layerMask & surface.layerMask) == 0) continue; float4x4 decalProjection = MatrixArray[decal.GetMatrixIndex()]; - float4 texMulAdd = decalProjection[3]; + int decalTexture = asint(decalProjection[3][0]); + int decalNormal = asint(decalProjection[3][1]); decalProjection[3] = float4(0, 0, 0, 1); const float3 clipSpacePos = mul(decalProjection, float4(surface.P, 1)).xyz; const float3 uvw = clipSpacePos.xyz * float3(0.5, -0.5, 0.5) + 0.5; [branch] if (is_saturated(uvw)) { - // mipmapping needs to be performed by hand: - const float2 decalDX = mul(P_dx, (float3x3)decalProjection).xy * texMulAdd.xy; - const float2 decalDY = mul(P_dy, (float3x3)decalProjection).xy * texMulAdd.xy; - float4 decalColor = texture_decalatlas.SampleGrad(sampler_linear_clamp, uvw.xy * texMulAdd.xy + texMulAdd.zw, decalDX, decalDY); + float4 decalColor = 1; + [branch] + if (decalTexture >= 0) + { + // mipmapping needs to be performed by hand: + const float2 decalDX = mul(P_dx, (float3x3)decalProjection).xy; + const float2 decalDY = mul(P_dy, (float3x3)decalProjection).xy; + decalColor = bindless_textures[NonUniformResourceIndex(decalTexture)].SampleGrad(sampler_objectshader, uvw.xy, decalDX, decalDY); + } // blend out if close to cube Z: float edgeBlend = 1 - pow(saturate(abs(clipSpacePos.z)), 8); decalColor.a *= edgeBlend; @@ -795,7 +527,7 @@ inline void ForwardLighting(inout Surface surface, inout Lighting lighting) [branch] if (envmapAccumulation.a < 1) { - ShaderEntity probe = EntityArray[g_xFrame_EnvProbeArrayOffset + entity_index]; + ShaderEntity probe = EntityArray[g_xFrame.EnvProbeArrayOffset + entity_index]; if ((probe.layerMask & surface.layerMask) == 0) continue; @@ -847,7 +579,7 @@ inline void ForwardLighting(inout Surface surface, inout Lighting lighting) { // Loop through light buckets for the draw call: const uint first_item = 0; - const uint last_item = first_item + g_xFrame_LightArrayCount - 1; + const uint last_item = first_item + g_xFrame.LightArrayCount - 1; const uint first_bucket = first_item / 32; const uint last_bucket = min(last_item / 32, 1); // only 2 buckets max (uint2) for forward pass! [loop] @@ -863,7 +595,7 @@ inline void ForwardLighting(inout Surface surface, inout Lighting lighting) const uint entity_index = bucket * 32 + bucket_bit_index; bucket_bits ^= 1u << bucket_bit_index; - ShaderEntity light = EntityArray[g_xFrame_LightArrayOffset + entity_index]; + ShaderEntity light = EntityArray[g_xFrame.LightArrayOffset + entity_index]; if ((light.layerMask & surface.layerMask) == 0) continue; @@ -899,12 +631,12 @@ inline void ForwardLighting(inout Surface surface, inout Lighting lighting) inline void TiledLighting(inout Surface surface, inout Lighting lighting) { const uint2 tileIndex = uint2(floor(surface.pixel / TILED_CULLING_BLOCKSIZE)); - const uint flatTileIndex = flatten2D(tileIndex, g_xFrame_EntityCullingTileCount.xy) * SHADER_ENTITY_TILE_BUCKET_COUNT; + const uint flatTileIndex = flatten2D(tileIndex, g_xFrame.EntityCullingTileCount.xy) * SHADER_ENTITY_TILE_BUCKET_COUNT; #ifndef DISABLE_DECALS [branch] - if (g_xFrame_DecalArrayCount > 0) + if (g_xFrame.DecalArrayCount > 0) { // decals are enabled, loop through them first: float4 decalAccumulation = 0; @@ -912,8 +644,8 @@ inline void TiledLighting(inout Surface surface, inout Lighting lighting) const float3 P_dy = ddy_coarse(surface.P); // Loop through decal buckets in the tile: - const uint first_item = g_xFrame_DecalArrayOffset; - const uint last_item = first_item + g_xFrame_DecalArrayCount - 1; + const uint first_item = g_xFrame.DecalArrayOffset; + const uint last_item = first_item + g_xFrame.DecalArrayCount - 1; const uint first_bucket = first_item / 32; const uint last_bucket = min(last_item / 32, max(0, SHADER_ENTITY_TILE_BUCKET_COUNT - 1)); [loop] @@ -940,7 +672,8 @@ inline void TiledLighting(inout Surface surface, inout Lighting lighting) continue; float4x4 decalProjection = MatrixArray[decal.GetMatrixIndex()]; - float4 texMulAdd = decalProjection[3]; + int decalTexture = asint(decalProjection[3][0]); + int decalNormal = asint(decalProjection[3][1]); decalProjection[3] = float4(0, 0, 0, 1); const float3 clipSpacePos = mul(decalProjection, float4(surface.P, 1)).xyz; const float3 uvw = clipSpacePos.xyz * float3(0.5, -0.5, 0.5) + 0.5; @@ -948,9 +681,14 @@ inline void TiledLighting(inout Surface surface, inout Lighting lighting) if (is_saturated(uvw)) { // mipmapping needs to be performed by hand: - const float2 decalDX = mul(P_dx, (float3x3)decalProjection).xy * texMulAdd.xy; - const float2 decalDY = mul(P_dy, (float3x3)decalProjection).xy * texMulAdd.xy; - float4 decalColor = texture_decalatlas.SampleGrad(sampler_linear_clamp, uvw.xy * texMulAdd.xy + texMulAdd.zw, decalDX, decalDY); + float4 decalColor = 1; + [branch] + if (decalTexture >= 0) + { + const float2 decalDX = mul(P_dx, (float3x3)decalProjection).xy; + const float2 decalDY = mul(P_dy, (float3x3)decalProjection).xy; + decalColor = bindless_textures[NonUniformResourceIndex(decalTexture)].SampleGrad(sampler_objectshader, uvw.xy, decalDX, decalDY); + } // blend out if close to cube Z: float edgeBlend = 1 - pow(saturate(abs(clipSpacePos.z)), 8); decalColor.a *= edgeBlend; @@ -991,11 +729,11 @@ inline void TiledLighting(inout Surface surface, inout Lighting lighting) #ifndef DISABLE_LOCALENVPMAPS [branch] - if (g_xFrame_EnvProbeArrayCount > 0) + if (g_xFrame.EnvProbeArrayCount > 0) { // Loop through envmap buckets in the tile: - const uint first_item = g_xFrame_EnvProbeArrayOffset; - const uint last_item = first_item + g_xFrame_EnvProbeArrayCount - 1; + const uint first_item = g_xFrame.EnvProbeArrayOffset; + const uint last_item = first_item + g_xFrame.EnvProbeArrayCount - 1; const uint first_bucket = first_item / 32; const uint last_bucket = min(last_item / 32, max(0, SHADER_ENTITY_TILE_BUCKET_COUNT - 1)); [loop] @@ -1067,20 +805,20 @@ inline void TiledLighting(inout Surface surface, inout Lighting lighting) #endif //DISABLE_VOXELGI [branch] - if (g_xFrame_LightArrayCount > 0) + if (g_xFrame.LightArrayCount > 0) { uint4 shadow_mask_packed = 0; #ifdef SHADOW_MASK_ENABLED [branch] - if (g_xFrame_Options & OPTION_BIT_SHADOW_MASK) + if (g_xFrame.Options & OPTION_BIT_SHADOW_MASK) { shadow_mask_packed = texture_rtshadow[surface.pixel / 2]; } #endif // SHADOW_MASK_ENABLED // Loop through light buckets in the tile: - const uint first_item = g_xFrame_LightArrayOffset; - const uint last_item = first_item + g_xFrame_LightArrayCount - 1; + const uint first_item = g_xFrame.LightArrayOffset; + const uint last_item = first_item + g_xFrame.LightArrayCount - 1; const uint first_bucket = first_item / 32; const uint last_bucket = min(last_item / 32, max(0, SHADER_ENTITY_TILE_BUCKET_COUNT - 1)); [loop] @@ -1115,9 +853,9 @@ inline void TiledLighting(inout Surface surface, inout Lighting lighting) float shadow_mask = 1; #ifdef SHADOW_MASK_ENABLED [branch] - if (g_xFrame_Options & OPTION_BIT_SHADOW_MASK && light.IsCastingShadow()) + if (g_xFrame.Options & OPTION_BIT_SHADOW_MASK && light.IsCastingShadow()) { - uint shadow_index = entity_index - g_xFrame_LightArrayOffset; + uint shadow_index = entity_index - g_xFrame.LightArrayOffset; if (shadow_index < 16) { uint mask_shift = (shadow_index % 4) * 8; @@ -1162,6 +900,15 @@ inline void TiledLighting(inout Surface surface, inout Lighting lighting) } } + +#ifndef TRANSPARENT + [branch] + if (g_xFrame.Options & OPTION_BIT_SURFELGI_ENABLED && surfel_cellvalid(surfel_cell(surface.P))) + { + lighting.indirect.diffuse = texture_surfelgi[surface.pixel]; + } +#endif // TRANSPARENT + } inline void ApplyLighting(in Surface surface, in Lighting lighting, inout float4 color) @@ -1174,7 +921,7 @@ inline void ApplyFog(in float distance, float3 P, float3 V, inout float4 color) { const float fogAmount = GetFogAmount(distance, P, V); - if (g_xFrame_Options & OPTION_BIT_REALISTIC_SKY) + if (g_xFrame.Options & OPTION_BIT_REALISTIC_SKY) { const float3 skyLuminance = texture_skyluminancelut.SampleLevel(sampler_point_clamp, float2(0.5, 0.5), 0).rgb; color.rgb = lerp(color.rgb, skyLuminance, fogAmount); @@ -1197,26 +944,23 @@ PixelInput main(VertexInput input) { PixelInput Out; +#ifdef OBJECTSHADER_USE_INSTANCEID + Out.instanceID = input.GetInstancePointer().instanceID; +#endif // OBJECTSHADER_USE_INSTANCEID + VertexSurface surface; surface.create(GetMaterial(), input); Out.pos = surface.position; #ifndef OBJECTSHADER_USE_NOCAMERA - Out.pos = mul(g_xCamera_VP, Out.pos); + Out.pos = mul(g_xCamera.VP, Out.pos); #endif // OBJECTSHADER_USE_NOCAMERA #ifdef OBJECTSHADER_USE_CLIPPLANE - Out.clip = dot(surface.position, g_xCamera_ClipPlane); + Out.clip = dot(surface.position, g_xCamera.ClipPlane); #endif // OBJECTSHADER_USE_CLIPPLANE -#ifdef OBJECTSHADER_USE_POSITIONPREV - Out.pre = surface.positionPrev; -#ifndef OBJECTSHADER_USE_NOCAMERA - Out.pre = mul(g_xCamera_PrevVP, Out.pre); -#endif // OBJECTSHADER_USE_NOCAMERA -#endif // OBJECTSHADER_USE_POSITIONPREV - #ifdef OBJECTSHADER_USE_POSITION3D Out.pos3D = surface.position.xyz; #endif // OBJECTSHADER_USE_POSITION3D @@ -1250,7 +994,7 @@ PixelInput main(VertexInput input) #endif // OBJECTSHADER_USE_EMISSIVE #ifdef OBJECTSHADER_USE_RENDERTARGETARRAYINDEX - const uint frustum_index = input.GetInstanceUserdata().y; + const uint frustum_index = input.GetInstancePointer().GetFrustumIndex(); Out.RTIndex = xCubemapRenderCams[frustum_index].properties.x; #ifndef OBJECTSHADER_USE_NOCAMERA Out.pos = mul(xCubemapRenderCams[frustum_index].VP, surface.position); @@ -1283,11 +1027,11 @@ PixelInput main(VertexInput input) // entry point: -#ifdef OUTPUT_GBUFFER -GBuffer main(PixelInput input, in bool is_frontface : SV_IsFrontFace) +#ifdef PREPASS +uint2 main(PixelInput input, in uint primitiveID : SV_PrimitiveID) : SV_TARGET #else float4 main(PixelInput input, in bool is_frontface : SV_IsFrontFace) : SV_TARGET -#endif // OUTPUT_GBUFFER +#endif // PREPASS // Pixel shader base: @@ -1295,7 +1039,7 @@ float4 main(PixelInput input, in bool is_frontface : SV_IsFrontFace) : SV_TARGET const float depth = input.pos.z; const float lineardepth = input.pos.w; const float2 pixel = input.pos.xy; - const float2 ScreenCoord = pixel * g_xFrame_InternalResolution_rcp; + const float2 ScreenCoord = pixel * g_xFrame.InternalResolution_rcp; float3 bumpColor = 0; #ifndef DISABLE_ALPHATEST @@ -1310,14 +1054,6 @@ float4 main(PixelInput input, in bool is_frontface : SV_IsFrontFace) : SV_TARGET #endif // ENVMAPRENDERING -#ifdef OBJECTSHADER_USE_POSITIONPREV - float2 pos2D = ScreenCoord * 2 - 1; - pos2D.y *= -1; - input.pre.xy /= input.pre.w; - const float2 velocity = ((input.pre.xy - g_xFrame_TemporalAAJitterPrev) - (pos2D.xy - g_xFrame_TemporalAAJitter)) * float2(0.5, -0.5); -#endif // OBJECTSHADER_USE_POSITIONPREV - - Surface surface; surface.init(); @@ -1332,7 +1068,7 @@ float4 main(PixelInput input, in bool is_frontface : SV_IsFrontFace) : SV_TARGET #ifdef OBJECTSHADER_USE_POSITION3D surface.P = input.pos3D; - surface.V = g_xCamera_CamPos - surface.P; + surface.V = g_xCamera.CamPos - surface.P; float dist = length(surface.V); surface.V /= dist; #endif // OBJECTSHADER_USE_POSITION3D @@ -1359,7 +1095,11 @@ float4 main(PixelInput input, in bool is_frontface : SV_IsFrontFace) : SV_TARGET #ifdef OBJECTSHADER_USE_UVSETS [branch] - if (GetMaterial().uvset_baseColorMap >= 0 && (g_xFrame_Options & OPTION_BIT_DISABLE_ALBEDO_MAPS) == 0) +#ifdef PREPASS + if (GetMaterial().uvset_baseColorMap >= 0) +#else + if (GetMaterial().uvset_baseColorMap >= 0 && (g_xFrame.Options & OPTION_BIT_DISABLE_ALBEDO_MAPS) == 0) +#endif // PREPASS { const float2 UV_baseColorMap = GetMaterial().uvset_baseColorMap == 0 ? input.uvsets.xy : input.uvsets.zw; float4 baseColorMap = texture_basecolormap.Sample(sampler_objectshader, UV_baseColorMap); @@ -1379,7 +1119,7 @@ float4 main(PixelInput input, in bool is_frontface : SV_IsFrontFace) : SV_TARGET float alphatest = GetMaterial().alphaTest; #ifndef TRANSPARENT #ifndef ENVMAPRENDERING - if (g_xFrame_Options & OPTION_BIT_TEMPORALAA_ENABLED) + if (g_xFrame.Options & OPTION_BIT_TEMPORALAA_ENABLED) { alphatest = clamp(blue_noise(pixel, lineardepth).r, 0, 0.99); } @@ -1462,7 +1202,7 @@ float4 main(PixelInput input, in bool is_frontface : SV_IsFrontFace) : SV_TARGET #ifdef OBJECTSHADER_USE_UVSETS [branch] - if (GetMaterial().uvset_baseColorMap >= 0 && (g_xFrame_Options & OPTION_BIT_DISABLE_ALBEDO_MAPS) == 0) + if (GetMaterial().uvset_baseColorMap >= 0 && (g_xFrame.Options & OPTION_BIT_DISABLE_ALBEDO_MAPS) == 0) { float2 uv = GetMaterial().uvset_baseColorMap == 0 ? input.uvsets.xy : input.uvsets.zw; color2 = texture_basecolormap.Sample(sampler_objectshader, uv); @@ -1524,7 +1264,7 @@ float4 main(PixelInput input, in bool is_frontface : SV_IsFrontFace) : SV_TARGET #ifdef OBJECTSHADER_USE_UVSETS [branch] - if (GetMaterial1().uvset_baseColorMap >= 0 && (g_xFrame_Options & OPTION_BIT_DISABLE_ALBEDO_MAPS) == 0) + if (GetMaterial1().uvset_baseColorMap >= 0 && (g_xFrame.Options & OPTION_BIT_DISABLE_ALBEDO_MAPS) == 0) { float2 uv = GetMaterial1().uvset_baseColorMap == 0 ? input.uvsets.xy : input.uvsets.zw; color2 = texture_blend1_basecolormap.Sample(sampler_objectshader, uv); @@ -1586,7 +1326,7 @@ float4 main(PixelInput input, in bool is_frontface : SV_IsFrontFace) : SV_TARGET #ifdef OBJECTSHADER_USE_UVSETS [branch] - if (GetMaterial2().uvset_baseColorMap >= 0 && (g_xFrame_Options & OPTION_BIT_DISABLE_ALBEDO_MAPS) == 0) + if (GetMaterial2().uvset_baseColorMap >= 0 && (g_xFrame.Options & OPTION_BIT_DISABLE_ALBEDO_MAPS) == 0) { float2 uv = GetMaterial2().uvset_baseColorMap == 0 ? input.uvsets.xy : input.uvsets.zw; color2 = texture_blend2_basecolormap.Sample(sampler_objectshader, uv); @@ -1648,7 +1388,7 @@ float4 main(PixelInput input, in bool is_frontface : SV_IsFrontFace) : SV_TARGET #ifdef OBJECTSHADER_USE_UVSETS [branch] - if (GetMaterial3().uvset_baseColorMap >= 0 && (g_xFrame_Options & OPTION_BIT_DISABLE_ALBEDO_MAPS) == 0) + if (GetMaterial3().uvset_baseColorMap >= 0 && (g_xFrame.Options & OPTION_BIT_DISABLE_ALBEDO_MAPS) == 0) { float2 uv = GetMaterial3().uvset_baseColorMap == 0 ? input.uvsets.xy : input.uvsets.zw; color2 = texture_blend3_basecolormap.Sample(sampler_objectshader, uv); @@ -1829,13 +1569,13 @@ float4 main(PixelInput input, in bool is_frontface : SV_IsFrontFace) : SV_TARGET bumpColor0 = 2 * texture_normalmap.Sample(sampler_objectshader, UV_normalMap - GetMaterial().texMulAdd.ww).rg - 1; bumpColor1 = 2 * texture_normalmap.Sample(sampler_objectshader, UV_normalMap + GetMaterial().texMulAdd.zw).rg - 1; } - bumpColor2 = texture_waterriples.SampleLevel(sampler_objectshader, ScreenCoord, 0).rg; + bumpColor2 = texture_waterriples.SampleLevel(sampler_linear_clamp, ScreenCoord, 0).rg; bumpColor = float3(bumpColor0 + bumpColor1 + bumpColor2, 1) * GetMaterial().refraction; surface.N = normalize(lerp(surface.N, mul(normalize(bumpColor), TBN), GetMaterial().normalMapStrength)); bumpColor *= GetMaterial().normalMapStrength; //REFLECTION - float4 reflectionUV = mul(g_xCamera_ReflVP, float4(surface.P, 1)); + float4 reflectionUV = mul(g_xCamera.ReflVP, float4(surface.P, 1)); reflectionUV.xy /= reflectionUV.w; reflectionUV.xy = reflectionUV.xy * float2(0.5, -0.5) + 0.5; lighting.indirect.specular += texture_reflection.SampleLevel(sampler_linear_mirror, reflectionUV.xy + bumpColor.rg, 0).rgb * surface.F; @@ -1862,7 +1602,7 @@ float4 main(PixelInput input, in bool is_frontface : SV_IsFrontFace) : SV_TARGET float2 size; float mipLevels; texture_refraction.GetDimensions(0, size.x, size.y, mipLevels); - const float2 normal2D = mul((float3x3)g_xCamera_View, surface.N.xyz).xy; + const float2 normal2D = mul((float3x3)g_xCamera.View, surface.N.xyz).xy; float2 perturbatedRefrTexCoords = ScreenCoord.xy + normal2D * GetMaterial().refraction; float4 refractiveColor = texture_refraction.SampleLevel(sampler_linear_clamp, perturbatedRefrTexCoords, surface.roughness * mipLevels); surface.refraction.rgb = surface.albedo * refractiveColor.rgb; @@ -1872,7 +1612,7 @@ float4 main(PixelInput input, in bool is_frontface : SV_IsFrontFace) : SV_TARGET #ifdef OBJECTSHADER_USE_ATLAS - LightMapping(input.atl, lighting); + LightMapping(load_instance(input.instanceID).lightmap, input.atl, lighting); #endif // OBJECTSHADER_USE_ATLAS @@ -1908,13 +1648,13 @@ float4 main(PixelInput input, in bool is_frontface : SV_IsFrontFace) : SV_TARGET #ifdef WATER // WATER REFRACTION - float sampled_lineardepth = texture_lineardepth.SampleLevel(sampler_point_clamp, ScreenCoord.xy + bumpColor.rg, 0) * g_xCamera_ZFarP; + float sampled_lineardepth = texture_lineardepth.SampleLevel(sampler_point_clamp, ScreenCoord.xy + bumpColor.rg, 0) * g_xCamera.ZFarP; float depth_difference = sampled_lineardepth - lineardepth; surface.refraction.rgb = texture_refraction.SampleLevel(sampler_linear_mirror, ScreenCoord.xy + bumpColor.rg * saturate(0.5 * depth_difference), 0).rgb; if (depth_difference < 0) { // Fix cutoff by taking unperturbed depth diff to fill the holes with fog: - sampled_lineardepth = texture_lineardepth.SampleLevel(sampler_point_clamp, ScreenCoord.xy, 0) * g_xCamera_ZFarP; + sampled_lineardepth = texture_lineardepth.SampleLevel(sampler_point_clamp, ScreenCoord.xy, 0) * g_xCamera.ZFarP; depth_difference = sampled_lineardepth - lineardepth; } // WATER FOG: @@ -1935,7 +1675,7 @@ float4 main(PixelInput input, in bool is_frontface : SV_IsFrontFace) : SV_TARGET #ifdef OBJECTSHADER_USE_POSITION3D - ApplyFog(dist, g_xCamera_CamPos, surface.V, color); + ApplyFog(dist, g_xCamera.CamPos, surface.V, color); #endif // OBJECTSHADER_USE_POSITION3D @@ -1944,13 +1684,13 @@ float4 main(PixelInput input, in bool is_frontface : SV_IsFrontFace) : SV_TARGET // end point: #ifdef PREPASS - return float4(velocity, 0, 0); /*FORMAT_R16G16_FLOAT*/ -#else -#ifdef OUTPUT_GBUFFER - return CreateGBuffer(color, surface); + PrimitiveID prim; + prim.primitiveIndex = primitiveID; + prim.instanceIndex = input.instanceID; + prim.subsetIndex = GetSubsetIndex(); + return prim.pack(); #else return color; -#endif // OUTPUT_GBUFFER #endif // PREPASS } diff --git a/WickedEngine/shaders/objectHF_tessellation.hlsli b/WickedEngine/shaders/objectHF_tessellation.hlsli index 7f2c3f04e..fe39c2217 100644 --- a/WickedEngine/shaders/objectHF_tessellation.hlsli +++ b/WickedEngine/shaders/objectHF_tessellation.hlsli @@ -25,12 +25,12 @@ ConstantOutput PatchConstantFunction(InputPatch patch) for (uint ie = 0; ie < 3; ++ie) { #if 0 - output.edges[ie] = xTessellationFactors.x; + output.edges[ie] = GetMesh().tessellation_factor; #else float3 edge = patch[(ie + 1) % 3].pos.xyz - patch[ie].pos.xyz; - float3 vec = (patch[(ie + 1) % 3].pos.xyz + patch[ie].pos.xyz) / 2 - g_xCamera_CamPos.xyz; + float3 vec = (patch[(ie + 1) % 3].pos.xyz + patch[ie].pos.xyz) / 2 - g_xCamera.CamPos.xyz; float len = sqrt(dot(edge, edge) / dot(vec, vec)); - output.edges[(ie + 1) % 3] = max(1, len * xTessellationFactors.x); + output.edges[(ie + 1) % 3] = max(1, len * GetMesh().tessellation_factor); #endif } @@ -43,9 +43,9 @@ ConstantOutput PatchConstantFunction(InputPatch patch) for (int ip = 0; ip < 4; ++ip) { culled[ip] = 1; - culled[ip] &= dot(g_xCamera_FrustumPlanes[ip + 2], patch[0].pos) < -rad; - culled[ip] &= dot(g_xCamera_FrustumPlanes[ip + 2], patch[1].pos) < -rad; - culled[ip] &= dot(g_xCamera_FrustumPlanes[ip + 2], patch[2].pos) < -rad; + culled[ip] &= dot(g_xCamera.FrustumPlanes[ip + 2], patch[0].pos) < -rad; + culled[ip] &= dot(g_xCamera.FrustumPlanes[ip + 2], patch[1].pos) < -rad; + culled[ip] &= dot(g_xCamera.FrustumPlanes[ip + 2], patch[2].pos) < -rad; } if (culled[0] || culled[1] || culled[2] || culled[3]) output.edges[0] = 0; #endif @@ -151,16 +151,16 @@ PixelInput main(ConstantOutput input, float3 uvw : SV_DomainLocation, const Outp #ifdef OBJECTSHADER_USE_CLIPPLANE - output.clip = dot(output.pos, g_xCamera_ClipPlane); + output.clip = dot(output.pos, g_xCamera.ClipPlane); #endif // OBJECTSHADER_USE_CLIPPLANE #ifndef OBJECTSHADER_USE_NOCAMERA - output.pos = mul(g_xCamera_VP, output.pos); + output.pos = mul(g_xCamera.VP, output.pos); #endif // OBJECTSHADER_USE_NOCAMERA #ifdef OBJECTSHADER_USE_POSITIONPREV #ifndef OBJECTSHADER_USE_NOCAMERA - output.pre = mul(g_xCamera_PrevVP, output.pre); + output.pre = mul(g_xCamera.PrevVP, output.pre); #endif // OBJECTSHADER_USE_NOCAMERA #endif // OBJECTSHADER_USE_POSITIONPREV diff --git a/WickedEngine/shaders/objectHS_prepass.hlsl b/WickedEngine/shaders/objectHS_prepass.hlsl index 6975d2859..326490299 100644 --- a/WickedEngine/shaders/objectHS_prepass.hlsl +++ b/WickedEngine/shaders/objectHS_prepass.hlsl @@ -1,4 +1,4 @@ #define OBJECTSHADER_COMPILE_HS -#define OBJECTSHADER_LAYOUT_POS_PREVPOS_TEX +#define OBJECTSHADER_LAYOUT_PREPASS_TEX #define OBJECTSHADER_USE_NORMAL #include "objectHF_tessellation.hlsli" diff --git a/WickedEngine/shaders/objectHS_prepass_alphatest.hlsl b/WickedEngine/shaders/objectHS_prepass_alphatest.hlsl index 6975d2859..326490299 100644 --- a/WickedEngine/shaders/objectHS_prepass_alphatest.hlsl +++ b/WickedEngine/shaders/objectHS_prepass_alphatest.hlsl @@ -1,4 +1,4 @@ #define OBJECTSHADER_COMPILE_HS -#define OBJECTSHADER_LAYOUT_POS_PREVPOS_TEX +#define OBJECTSHADER_LAYOUT_PREPASS_TEX #define OBJECTSHADER_USE_NORMAL #include "objectHF_tessellation.hlsli" diff --git a/WickedEngine/shaders/objectHS_simple.hlsl b/WickedEngine/shaders/objectHS_simple.hlsl index a0865ca53..873883df0 100644 --- a/WickedEngine/shaders/objectHS_simple.hlsl +++ b/WickedEngine/shaders/objectHS_simple.hlsl @@ -1,5 +1,5 @@ #define OBJECTSHADER_COMPILE_HS -#define OBJECTSHADER_LAYOUT_POS_TEX +#define OBJECTSHADER_LAYOUT_SHADOW_TEX #define OBJECTSHADER_USE_COLOR #define OBJECTSHADER_USE_NORMAL #include "objectHF_tessellation.hlsli" diff --git a/WickedEngine/shaders/objectPS_hologram.hlsl b/WickedEngine/shaders/objectPS_hologram.hlsl index 3525b9822..7f560ae5d 100644 --- a/WickedEngine/shaders/objectPS_hologram.hlsl +++ b/WickedEngine/shaders/objectPS_hologram.hlsl @@ -6,7 +6,7 @@ float4 main(PixelInput input) : SV_TARGET { float4 color; [branch] - if (GetMaterial().uvset_baseColorMap >= 0 && (g_xFrame_Options & OPTION_BIT_DISABLE_ALBEDO_MAPS) == 0) + if (GetMaterial().uvset_baseColorMap >= 0 && (g_xFrame.Options & OPTION_BIT_DISABLE_ALBEDO_MAPS) == 0) { const float2 UV_baseColorMap = GetMaterial().uvset_baseColorMap == 0 ? input.uvsets.xy : input.uvsets.zw; color = texture_basecolormap.Sample(sampler_objectshader, UV_baseColorMap); @@ -30,15 +30,15 @@ float4 main(PixelInput input) : SV_TARGET } color.rgb += emissiveColor.rgb * emissiveColor.a; - float time = g_xFrame_Time; - float2 uv = input.pos.xy * g_xFrame_InternalResolution_rcp; - uv.y *= g_xFrame_InternalResolution.y * g_xFrame_InternalResolution_rcp.x; + float time = g_xFrame.Time; + float2 uv = input.pos.xy * g_xFrame.InternalResolution_rcp; + uv.y *= g_xFrame.InternalResolution.y * g_xFrame.InternalResolution_rcp.x; // wave: color.a *= sin(input.pos3D.y * 30 + time * 10) * 0.5 + 0.5; // rim: - color *= lerp(0.3, 6, pow(1 - saturate(dot(normalize(input.nor), normalize(g_xCamera_CamPos - input.pos3D))), 2)); + color *= lerp(0.3, 6, pow(1 - saturate(dot(normalize(input.nor), normalize(g_xCamera.CamPos - input.pos3D))), 2)); // keep some base color color.a += 0.2; diff --git a/WickedEngine/shaders/objectPS_paintradius.hlsl b/WickedEngine/shaders/objectPS_paintradius.hlsl index fae57afa6..e76dad8bc 100644 --- a/WickedEngine/shaders/objectPS_paintradius.hlsl +++ b/WickedEngine/shaders/objectPS_paintradius.hlsl @@ -1,6 +1,6 @@ -#define OBJECTSHADER_LAYOUT_POS_TEX +#define OBJECTSHADER_LAYOUT_SHADOW_TEX #include "objectHF.hlsli" -#include "ShaderInterop_Paint.h" +#include "ShaderInterop_Renderer.h" [earlydepthstencil] float4 main(PixelInput PSIn) : SV_TARGET diff --git a/WickedEngine/shaders/objectPS_prepass.hlsl b/WickedEngine/shaders/objectPS_prepass.hlsl index c29057a68..43d8ac384 100644 --- a/WickedEngine/shaders/objectPS_prepass.hlsl +++ b/WickedEngine/shaders/objectPS_prepass.hlsl @@ -1,5 +1,5 @@ #define OBJECTSHADER_COMPILE_PS -#define OBJECTSHADER_LAYOUT_POS_PREVPOS +#define OBJECTSHADER_LAYOUT_PREPASS #define PREPASS #define DISABLE_ALPHATEST #include "objectHF.hlsli" diff --git a/WickedEngine/shaders/objectPS_prepass_alphatest.hlsl b/WickedEngine/shaders/objectPS_prepass_alphatest.hlsl index 5ad92aec1..034bdd816 100644 --- a/WickedEngine/shaders/objectPS_prepass_alphatest.hlsl +++ b/WickedEngine/shaders/objectPS_prepass_alphatest.hlsl @@ -1,5 +1,5 @@ #define OBJECTSHADER_COMPILE_PS -#define OBJECTSHADER_LAYOUT_POS_PREVPOS_TEX +#define OBJECTSHADER_LAYOUT_PREPASS_TEX #define PREPASS #include "objectHF.hlsli" diff --git a/WickedEngine/shaders/objectPS_simple.hlsl b/WickedEngine/shaders/objectPS_simple.hlsl index d44cb329d..ebcb51d9f 100644 --- a/WickedEngine/shaders/objectPS_simple.hlsl +++ b/WickedEngine/shaders/objectPS_simple.hlsl @@ -1,4 +1,4 @@ -#define OBJECTSHADER_LAYOUT_POS_TEX +#define OBJECTSHADER_LAYOUT_SHADOW_TEX #define OBJECTSHADER_USE_COLOR #include "objectHF.hlsli" diff --git a/WickedEngine/shaders/objectPS_voxelizer.hlsl b/WickedEngine/shaders/objectPS_voxelizer.hlsl index 0f06e7a8a..8a985448d 100644 --- a/WickedEngine/shaders/objectPS_voxelizer.hlsl +++ b/WickedEngine/shaders/objectPS_voxelizer.hlsl @@ -21,7 +21,7 @@ void main(PSInput input) float3 N = normalize(input.N); float3 P = input.P; - float3 diff = (P - g_xFrame_VoxelRadianceDataCenter) * g_xFrame_VoxelRadianceDataRes_rcp * g_xFrame_VoxelRadianceDataSize_rcp; + float3 diff = (P - g_xFrame.VoxelRadianceDataCenter) * g_xFrame.VoxelRadianceDataRes_rcp * g_xFrame.VoxelRadianceDataSize_rcp; float3 uvw = diff * float3(0.5f, -0.5f, 0.5f) + 0.5f; [branch] @@ -29,7 +29,7 @@ void main(PSInput input) { float4 baseColor; [branch] - if (GetMaterial().uvset_baseColorMap >= 0 && (g_xFrame_Options & OPTION_BIT_DISABLE_ALBEDO_MAPS) == 0) + if (GetMaterial().uvset_baseColorMap >= 0 && (g_xFrame.Options & OPTION_BIT_DISABLE_ALBEDO_MAPS) == 0) { const float2 UV_baseColorMap = GetMaterial().uvset_baseColorMap == 0 ? input.uvsets.xy : input.uvsets.zw; baseColor = texture_basecolormap.Sample(sampler_linear_wrap, UV_baseColorMap); @@ -63,7 +63,7 @@ void main(PSInput input) if (blend_weights.x > 0) { [branch] - if (GetMaterial().uvset_baseColorMap >= 0 && (g_xFrame_Options & OPTION_BIT_DISABLE_ALBEDO_MAPS) == 0) + if (GetMaterial().uvset_baseColorMap >= 0 && (g_xFrame.Options & OPTION_BIT_DISABLE_ALBEDO_MAPS) == 0) { float2 uv = GetMaterial().uvset_baseColorMap == 0 ? input.uvsets.xy : input.uvsets.zw; sam = texture_basecolormap.Sample(sampler_objectshader, uv); @@ -89,7 +89,7 @@ void main(PSInput input) if (blend_weights.y > 0) { [branch] - if (GetMaterial1().uvset_baseColorMap >= 0 && (g_xFrame_Options & OPTION_BIT_DISABLE_ALBEDO_MAPS) == 0) + if (GetMaterial1().uvset_baseColorMap >= 0 && (g_xFrame.Options & OPTION_BIT_DISABLE_ALBEDO_MAPS) == 0) { float2 uv = GetMaterial1().uvset_baseColorMap == 0 ? input.uvsets.xy : input.uvsets.zw; sam = texture_blend1_basecolormap.Sample(sampler_objectshader, uv); @@ -115,7 +115,7 @@ void main(PSInput input) if (blend_weights.z > 0) { [branch] - if (GetMaterial2().uvset_baseColorMap >= 0 && (g_xFrame_Options & OPTION_BIT_DISABLE_ALBEDO_MAPS) == 0) + if (GetMaterial2().uvset_baseColorMap >= 0 && (g_xFrame.Options & OPTION_BIT_DISABLE_ALBEDO_MAPS) == 0) { float2 uv = GetMaterial2().uvset_baseColorMap == 0 ? input.uvsets.xy : input.uvsets.zw; sam = texture_blend2_basecolormap.Sample(sampler_objectshader, uv); @@ -141,7 +141,7 @@ void main(PSInput input) if (blend_weights.w > 0) { [branch] - if (GetMaterial3().uvset_baseColorMap >= 0 && (g_xFrame_Options & OPTION_BIT_DISABLE_ALBEDO_MAPS) == 0) + if (GetMaterial3().uvset_baseColorMap >= 0 && (g_xFrame.Options & OPTION_BIT_DISABLE_ALBEDO_MAPS) == 0) { float2 uv = GetMaterial3().uvset_baseColorMap == 0 ? input.uvsets.xy : input.uvsets.zw; sam = texture_blend3_basecolormap.Sample(sampler_objectshader, uv); @@ -175,7 +175,7 @@ void main(PSInput input) { // Loop through light buckets for the draw call: const uint first_item = 0; - const uint last_item = first_item + g_xFrame_LightArrayCount - 1; + const uint last_item = first_item + g_xFrame.LightArrayCount - 1; const uint first_bucket = first_item / 32; const uint last_bucket = min(last_item / 32, 1); // only 2 buckets max (uint2) for forward pass! [loop] @@ -191,7 +191,7 @@ void main(PSInput input) const uint entity_index = bucket * 32 + bucket_bit_index; bucket_bits ^= 1u << bucket_bit_index; - ShaderEntity light = EntityArray[g_xFrame_LightArrayOffset + entity_index]; + ShaderEntity light = EntityArray[g_xFrame.LightArrayOffset + entity_index]; if (light.GetFlags() & ENTITY_FLAG_LIGHT_STATIC) { @@ -213,7 +213,7 @@ void main(PSInput input) [branch] if (light.IsCastingShadow() >= 0) { - const uint cascade = g_xFrame_ShadowCascadeCount - 1; // biggest cascade (coarsest resolution) will be used to voxelize + const uint cascade = g_xFrame.ShadowCascadeCount - 1; // biggest cascade (coarsest resolution) will be used to voxelize float3 ShPos = mul(MatrixArray[light.GetMatrixIndex() + cascade], float4(P, 1)).xyz; // ortho matrix, no divide by .w float3 ShTex = ShPos.xyz * float3(0.5f, -0.5f, 0.5f) + 0.5f; @@ -320,8 +320,8 @@ void main(PSInput input) uint normal_encoded = pack_unitvector(N); // output: - uint3 writecoord = floor(uvw * g_xFrame_VoxelRadianceDataRes); - uint id = flatten3D(writecoord, g_xFrame_VoxelRadianceDataRes); + uint3 writecoord = floor(uvw * g_xFrame.VoxelRadianceDataRes); + uint id = flatten3D(writecoord, g_xFrame.VoxelRadianceDataRes); InterlockedMax(output[id].colorMask, color_encoded); InterlockedMax(output[id].normalMask, normal_encoded); } diff --git a/WickedEngine/shaders/objectVS_prepass.hlsl b/WickedEngine/shaders/objectVS_prepass.hlsl index 5aca3adb7..46363f750 100644 --- a/WickedEngine/shaders/objectVS_prepass.hlsl +++ b/WickedEngine/shaders/objectVS_prepass.hlsl @@ -1,3 +1,3 @@ #define OBJECTSHADER_COMPILE_VS -#define OBJECTSHADER_LAYOUT_POS_PREVPOS +#define OBJECTSHADER_LAYOUT_PREPASS #include "objectHF.hlsli" diff --git a/WickedEngine/shaders/objectVS_prepass_alphatest.hlsl b/WickedEngine/shaders/objectVS_prepass_alphatest.hlsl index d11b3e690..eb28e2a95 100644 --- a/WickedEngine/shaders/objectVS_prepass_alphatest.hlsl +++ b/WickedEngine/shaders/objectVS_prepass_alphatest.hlsl @@ -1,3 +1,3 @@ #define OBJECTSHADER_COMPILE_VS -#define OBJECTSHADER_LAYOUT_POS_PREVPOS_TEX +#define OBJECTSHADER_LAYOUT_PREPASS_TEX #include "objectHF.hlsli" diff --git a/WickedEngine/shaders/objectVS_prepass_alphatest_tessellation.hlsl b/WickedEngine/shaders/objectVS_prepass_alphatest_tessellation.hlsl index a0ca9bcf4..6af689c42 100644 --- a/WickedEngine/shaders/objectVS_prepass_alphatest_tessellation.hlsl +++ b/WickedEngine/shaders/objectVS_prepass_alphatest_tessellation.hlsl @@ -1,5 +1,5 @@ #define OBJECTSHADER_COMPILE_VS -#define OBJECTSHADER_LAYOUT_POS_PREVPOS_TEX +#define OBJECTSHADER_LAYOUT_PREPASS_TEX #define OBJECTSHADER_USE_NOCAMERA #define OBJECTSHADER_USE_NORMAL #include "objectHF.hlsli" diff --git a/WickedEngine/shaders/objectVS_prepass_tessellation.hlsl b/WickedEngine/shaders/objectVS_prepass_tessellation.hlsl index 1c9cdb984..08bbd402f 100644 --- a/WickedEngine/shaders/objectVS_prepass_tessellation.hlsl +++ b/WickedEngine/shaders/objectVS_prepass_tessellation.hlsl @@ -1,5 +1,5 @@ #define OBJECTSHADER_COMPILE_VS -#define OBJECTSHADER_LAYOUT_POS_PREVPOS_TEX +#define OBJECTSHADER_LAYOUT_PREPASS_TEX #define OBJECTSHADER_USE_NOCAMERA #define OBJECTSHADER_USE_NORMAL #include "objectHF.hlsli" diff --git a/WickedEngine/shaders/objectVS_simple.hlsl b/WickedEngine/shaders/objectVS_simple.hlsl index f6b448015..ba84a94e2 100644 --- a/WickedEngine/shaders/objectVS_simple.hlsl +++ b/WickedEngine/shaders/objectVS_simple.hlsl @@ -1,4 +1,4 @@ #define OBJECTSHADER_COMPILE_VS -#define OBJECTSHADER_LAYOUT_POS_TEX +#define OBJECTSHADER_LAYOUT_SHADOW_TEX #define OBJECTSHADER_USE_COLOR #include "objectHF.hlsli" diff --git a/WickedEngine/shaders/objectVS_simple_tessellation.hlsl b/WickedEngine/shaders/objectVS_simple_tessellation.hlsl index 75c657964..6e58c0a4e 100644 --- a/WickedEngine/shaders/objectVS_simple_tessellation.hlsl +++ b/WickedEngine/shaders/objectVS_simple_tessellation.hlsl @@ -1,5 +1,5 @@ #define OBJECTSHADER_COMPILE_VS -#define OBJECTSHADER_LAYOUT_POS_TEX +#define OBJECTSHADER_LAYOUT_SHADOW_TEX #define OBJECTSHADER_USE_COLOR #define OBJECTSHADER_USE_NORMAL #define OBJECTSHADER_USE_NOCAMERA diff --git a/WickedEngine/shaders/oceanSimulatorCS.hlsl b/WickedEngine/shaders/oceanSimulatorCS.hlsl index 061d2a55a..a390ae5b7 100644 --- a/WickedEngine/shaders/oceanSimulatorCS.hlsl +++ b/WickedEngine/shaders/oceanSimulatorCS.hlsl @@ -17,7 +17,7 @@ void main(uint3 DTid : SV_DispatchThreadID) float2 h0_k = g_InputH0[in_index]; float2 h0_mk = g_InputH0[in_mindex]; float sin_v, cos_v; - sincos(g_InputOmega[in_index] * g_xFrame_Time * g_TimeScale, sin_v, cos_v); + sincos(g_InputOmega[in_index] * g_xFrame.Time * g_TimeScale, sin_v, cos_v); float2 ht; ht.x = (h0_k.x + h0_mk.x) * cos_v - (h0_k.y + h0_mk.y) * sin_v; diff --git a/WickedEngine/shaders/oceanSurfacePS.hlsl b/WickedEngine/shaders/oceanSurfacePS.hlsl index e15bb3f2a..c113747d3 100644 --- a/WickedEngine/shaders/oceanSurfacePS.hlsl +++ b/WickedEngine/shaders/oceanSurfacePS.hlsl @@ -11,7 +11,7 @@ TEXTURE2D(texture_gradientmap, float4, TEXSLOT_ONDEMAND1); float4 main(PSIn input) : SV_TARGET { float4 color = xOceanWaterColor; - float3 V = g_xCamera_CamPos - input.pos3D; + float3 V = g_xCamera.CamPos - input.pos3D; float dist = length(V); V /= dist; float emissive = 0; @@ -40,7 +40,7 @@ float4 main(PSIn input) : SV_TARGET TiledLighting(surface, lighting); float2 refUV = float2(1, -1)*input.ReflectionMapSamplingPos.xy / input.ReflectionMapSamplingPos.w * 0.5f + 0.5f; - float2 ScreenCoord = surface.pixel * g_xFrame_InternalResolution_rcp; + float2 ScreenCoord = surface.pixel * g_xFrame.InternalResolution_rcp; //REFLECTION float2 RefTex = float2(1, -1)*input.ReflectionMapSamplingPos.xy / input.ReflectionMapSamplingPos.w / 2.0f + 0.5f; @@ -49,24 +49,24 @@ float4 main(PSIn input) : SV_TARGET // WATER REFRACTION float lineardepth = input.pos.w; - float sampled_lineardepth = texture_lineardepth.SampleLevel(sampler_point_clamp, ScreenCoord.xy + surface.N.xz * 0.04f, 0) * g_xCamera_ZFarP; + float sampled_lineardepth = texture_lineardepth.SampleLevel(sampler_point_clamp, ScreenCoord.xy + surface.N.xz * 0.04f, 0) * g_xCamera.ZFarP; float depth_difference = sampled_lineardepth - lineardepth; surface.refraction.rgb = texture_refraction.SampleLevel(sampler_linear_mirror, ScreenCoord.xy + surface.N.xz * 0.04f * saturate(0.5 * depth_difference), 0).rgb; if (depth_difference < 0) { // Fix cutoff by taking unperturbed depth diff to fill the holes with fog: - sampled_lineardepth = texture_lineardepth.SampleLevel(sampler_point_clamp, ScreenCoord.xy, 0) * g_xCamera_ZFarP; + sampled_lineardepth = texture_lineardepth.SampleLevel(sampler_point_clamp, ScreenCoord.xy, 0) * g_xCamera.ZFarP; depth_difference = sampled_lineardepth - lineardepth; } // WATER FOG: surface.refraction.a = 1 - saturate(color.a * 0.1f * depth_difference); // Blend out at distance: - color.a = pow(saturate(1 - saturate(dist / g_xCamera_ZFarP)), 2); + color.a = pow(saturate(1 - saturate(dist / g_xCamera.ZFarP)), 2); ApplyLighting(surface, lighting, color); - ApplyFog(dist, g_xCamera_CamPos, V, color); + ApplyFog(dist, g_xCamera.CamPos, V, color); return color; } diff --git a/WickedEngine/shaders/oceanSurfaceVS.hlsl b/WickedEngine/shaders/oceanSurfaceVS.hlsl index 3a70b5624..e29002e08 100644 --- a/WickedEngine/shaders/oceanSurfaceVS.hlsl +++ b/WickedEngine/shaders/oceanSurfaceVS.hlsl @@ -12,7 +12,7 @@ static const float3 QUAD[] = { float3(0, 1, 0), }; -#define infinite g_xCamera_ZFarP +#define infinite g_xCamera.ZFarP float3 intersectPlaneClampInfinite(in float3 rayOrigin, in float3 rayDirection, in float3 planeNormal, float planeHeight) { float dist = (planeHeight - dot(planeNormal, rayOrigin)) / dot(planeNormal, rayDirection); @@ -42,8 +42,8 @@ PSIn main(uint fakeIndex : SV_VERTEXID) Out.pos.xy *= max(1, xOceanSurfaceDisplacementTolerance); // extrude screen space grid to tolerate displacement // Perform ray tracing of screen grid and plane surface to unproject to world space: - float3 o = g_xCamera_CamPos; - float4 r = mul(g_xCamera_InvVP, float4(Out.pos.xy, 0, 1)); + float3 o = g_xCamera.CamPos; + float4 r = mul(g_xCamera.InvVP, float4(Out.pos.xy, 0, 1)); r.xyz /= r.w; float3 d = normalize(o.xyz - r.xyz); @@ -52,14 +52,14 @@ PSIn main(uint fakeIndex : SV_VERTEXID) // Displace surface: float2 uv = worldPos.xz * xOceanPatchSizeRecip; float3 displacement = texture_displacementmap.SampleLevel(sampler_linear_wrap, uv + xOceanMapHalfTexel, 0).xzy; - displacement *= 1 - saturate(distance(g_xCamera_CamPos, worldPos) * 0.0025f); + displacement *= 1 - saturate(distance(g_xCamera.CamPos, worldPos) * 0.0025f); worldPos += displacement; // Reproject displaced surface and output: - Out.pos = mul(g_xCamera_VP, float4(worldPos, 1)); + Out.pos = mul(g_xCamera.VP, float4(worldPos, 1)); Out.pos3D = worldPos; Out.uv = uv; - Out.ReflectionMapSamplingPos = mul(g_xCamera_ReflVP, float4(worldPos, 1)); + Out.ReflectionMapSamplingPos = mul(g_xCamera.ReflVP, float4(worldPos, 1)); return Out; } diff --git a/WickedEngine/shaders/paint_textureCS.hlsl b/WickedEngine/shaders/paint_textureCS.hlsl index f9579d122..b0359fce8 100644 --- a/WickedEngine/shaders/paint_textureCS.hlsl +++ b/WickedEngine/shaders/paint_textureCS.hlsl @@ -1,5 +1,7 @@ #include "globals.hlsli" -#include "ShaderInterop_Paint.h" +#include "ShaderInterop_Renderer.h" + +PUSHCONSTANT(push, PaintTextureCB); TEXTURE2D(texture_brush, float4, TEXSLOT_ONDEMAND0); @@ -8,12 +10,12 @@ RWTEXTURE2D(output, unorm float4, 0); [numthreads(PAINT_TEXTURE_BLOCKSIZE, PAINT_TEXTURE_BLOCKSIZE, 1)] void main( uint3 DTid : SV_DispatchThreadID ) { - const uint2 pixel = xPaintBrushCenter + DTid.xy - xPaintBrushRadius.xx; - const float2 uv = (DTid.xy + 0.5f) / xPaintBrushRadius.xx; - const float4 color = texture_brush.SampleLevel(sampler_linear_clamp, uv, 0) * unpack_rgba(xPaintBrushColor); - const float dist = distance((float2)pixel, (float2)xPaintBrushCenter); - const float affection = xPaintBrushAmount * pow(1 - saturate(dist / (float)xPaintBrushRadius), xPaintBrushFalloff); - if (affection > 0 && dist < (float)xPaintBrushRadius) + const uint2 pixel = push.xPaintBrushCenter + DTid.xy - push.xPaintBrushRadius.xx; + const float2 uv = (DTid.xy + 0.5f) / push.xPaintBrushRadius.xx; + const float4 color = texture_brush.SampleLevel(sampler_linear_clamp, uv, 0) * unpack_rgba(push.xPaintBrushColor); + const float dist = distance((float2)pixel, (float2)push.xPaintBrushCenter); + const float affection = push.xPaintBrushAmount * pow(1 - saturate(dist / (float)push.xPaintBrushRadius), push.xPaintBrushFalloff); + if (affection > 0 && dist < (float)push.xPaintBrushRadius) { output[pixel] = lerp(output[pixel], color, affection); } diff --git a/WickedEngine/shaders/raytraceCS.hlsl b/WickedEngine/shaders/raytraceCS.hlsl index 1ffedf8d3..3d6b98fde 100644 --- a/WickedEngine/shaders/raytraceCS.hlsl +++ b/WickedEngine/shaders/raytraceCS.hlsl @@ -31,12 +31,12 @@ void main(uint3 DTid : SV_DispatchThreadID, uint groupIndex : SV_GroupIndex) RayDesc ray = CreateCameraRay(uv); // Depth of field setup: - float3 focal_point = ray.Origin + ray.Direction * g_xCamera_FocalLength; + float3 focal_point = ray.Origin + ray.Direction * g_xCamera.FocalLength; float3 coc = float3(hemispherepoint_cos(rand(seed, uv), rand(seed, uv)).xy, 0); - coc.xy *= g_xCamera_ApertureShape.xy; - coc = mul(coc, float3x3(cross(g_xCamera_Up, g_xCamera_At), g_xCamera_Up, g_xCamera_At)); - coc *= g_xCamera_FocalLength; - coc *= g_xCamera_ApertureSize; + coc.xy *= g_xCamera.ApertureShape.xy; + coc = mul(coc, float3x3(cross(g_xCamera.Up, g_xCamera.At), g_xCamera.Up, g_xCamera.At)); + coc *= g_xCamera.FocalLength; + coc *= g_xCamera.ApertureSize; coc *= 0.1f; ray.Origin = ray.Origin + coc; ray.Direction = focal_point - ray.Origin; // will be normalized before tracing! @@ -89,35 +89,23 @@ void main(uint3 DTid : SV_DispatchThreadID, uint groupIndex : SV_GroupIndex) } Surface surface; - ShaderMaterial material; #ifdef RTAPI // ray origin updated for next bounce: ray.Origin = q.WorldRayOrigin() + q.WorldRayDirection() * q.CommittedRayT(); - ShaderMesh mesh = bindless_buffers[NonUniformResourceIndex(q.CommittedInstanceID())].Load(0); - ShaderMeshSubset subset = bindless_subsets[NonUniformResourceIndex(mesh.subsetbuffer)][q.CommittedGeometryIndex()]; - material = bindless_buffers[NonUniformResourceIndex(subset.material)].Load(0); + PrimitiveID prim; + prim.primitiveIndex = q.CommittedPrimitiveIndex(); + prim.instanceIndex = q.CommittedInstanceID(); + prim.subsetIndex = q.CommittedGeometryIndex(); - EvaluateObjectSurface( - mesh, - subset, - material, - q.CommittedPrimitiveIndex(), - q.CommittedTriangleBarycentrics(), - q.CommittedObjectToWorld3x4(), - surface - ); + surface.load(prim, q.CommittedTriangleBarycentrics()); #else // ray origin updated for next bounce: ray.Origin = ray.Origin + ray.Direction * hit.distance; - EvaluateObjectSurface( - hit, - material, - surface - ); + surface.load(hit.primitiveID, hit.bary); #endif // RTAPI @@ -125,14 +113,18 @@ void main(uint3 DTid : SV_DispatchThreadID, uint groupIndex : SV_GroupIndex) surface.V = -ray.Direction; surface.update(); + result += max(0, energy * surface.emissiveColor.rgb * surface.emissiveColor.a); + + + // Light sampling: [loop] - for (uint iterator = 0; iterator < g_xFrame_LightArrayCount; iterator++) + for (uint iterator = 0; iterator < g_xFrame.LightArrayCount; iterator++) { - ShaderEntity light = EntityArray[g_xFrame_LightArrayOffset + iterator]; + ShaderEntity light = EntityArray[g_xFrame.LightArrayOffset + iterator]; Lighting lighting; lighting.create(0, 0, 0, 0); @@ -158,9 +150,9 @@ void main(uint3 DTid : SV_DispatchThreadID, uint groupIndex : SV_GroupIndex) lightColor = light.GetColor().rgb * light.GetEnergy(); float3 atmosphereTransmittance = 1; - if (g_xFrame_Options & OPTION_BIT_REALISTIC_SKY) + if (g_xFrame.Options & OPTION_BIT_REALISTIC_SKY) { - AtmosphereParameters Atmosphere = g_xFrame_Atmosphere; + AtmosphereParameters Atmosphere = g_xFrame.Atmosphere; atmosphereTransmittance = GetAtmosphericLightTransmittance(Atmosphere, surface.P, L, texture_transmittancelut); } lightColor *= atmosphereTransmittance; @@ -249,25 +241,13 @@ void main(uint3 DTid : SV_DispatchThreadID, uint groupIndex : SV_GroupIndex) ); while (q.Proceed()) { - ShaderMesh mesh = bindless_buffers[NonUniformResourceIndex(q.CandidateInstanceID())].Load(0); - ShaderMeshSubset subset = bindless_subsets[NonUniformResourceIndex(mesh.subsetbuffer)][q.CandidateGeometryIndex()]; - ShaderMaterial material = bindless_buffers[NonUniformResourceIndex(subset.material)].Load(0); - [branch] - if (!material.IsCastingShadow()) - { - continue; - } + PrimitiveID prim; + prim.primitiveIndex = q.CandidatePrimitiveIndex(); + prim.instanceIndex = q.CandidateInstanceID(); + prim.subsetIndex = q.CandidateGeometryIndex(); Surface surface; - EvaluateObjectSurface( - mesh, - subset, - material, - q.CandidatePrimitiveIndex(), - q.CandidateTriangleBarycentrics(), - q.CandidateObjectToWorld3x4(), - surface - ); + surface.load(prim, q.CandidateTriangleBarycentrics()); shadow *= lerp(1, surface.albedo * surface.transmission, surface.opacity); @@ -291,6 +271,7 @@ void main(uint3 DTid : SV_DispatchThreadID, uint groupIndex : SV_GroupIndex) } + if (bounce == 0) { primary_albedo = surface.albedo; @@ -317,7 +298,7 @@ void main(uint3 DTid : SV_DispatchThreadID, uint groupIndex : SV_GroupIndex) if (roulette <= refractChance) { // Refraction - const float3 R = refract(ray.Direction, surface.N, 1 - material.refraction); + const float3 R = refract(ray.Direction, surface.N, 1 - surface.material.refraction); ray.Direction = lerp(R, SampleHemisphere_cos(R, seed, uv), surface.roughnessBRDF); energy *= surface.albedo; diff --git a/WickedEngine/shaders/raytracingHF.hlsli b/WickedEngine/shaders/raytracingHF.hlsli index d423eb93d..0efe6309a 100644 --- a/WickedEngine/shaders/raytracingHF.hlsli +++ b/WickedEngine/shaders/raytracingHF.hlsli @@ -17,11 +17,11 @@ struct RayDesc inline RayDesc CreateCameraRay(float2 clipspace) { - float4 unprojected = mul(g_xCamera_InvVP, float4(clipspace, 0, 1)); + float4 unprojected = mul(g_xCamera.InvVP, float4(clipspace, 0, 1)); unprojected.xyz /= unprojected.w; RayDesc ray; - ray.Origin = g_xCamera_CamPos; + ray.Origin = g_xCamera.CamPos; ray.Direction = normalize(unprojected.xyz - ray.Origin); ray.TMin = 0.001; ray.TMax = FLT_MAX; @@ -33,153 +33,6 @@ inline RayDesc CreateCameraRay(float2 clipspace) // Hardware acceleration raytracing path: RAYTRACINGACCELERATIONSTRUCTURE(scene_acceleration_structure, TEXSLOT_ACCELERATION_STRUCTURE); -Texture2D bindless_textures[] : register(t0, space1); -ByteAddressBuffer bindless_buffers[] : register(t0, space2); -StructuredBuffer bindless_subsets[] : register(t0, space3); -Buffer bindless_ib[] : register(t0, space4); - -void EvaluateObjectSurface( - in ShaderMesh mesh, - in ShaderMeshSubset subset, - in ShaderMaterial material, - in uint primitiveIndex, - in float2 barycentrics, - in float3x4 worldMatrix, - out Surface surface -) -{ - uint startIndex = primitiveIndex * 3 + subset.indexOffset; - uint i0 = bindless_ib[NonUniformResourceIndex(mesh.ib)][startIndex + 0]; - uint i1 = bindless_ib[NonUniformResourceIndex(mesh.ib)][startIndex + 1]; - uint i2 = bindless_ib[NonUniformResourceIndex(mesh.ib)][startIndex + 2]; - float4 uv0 = 0, uv1 = 0, uv2 = 0; - [branch] - if (mesh.vb_uv0 >= 0) - { - uv0.xy = unpack_half2(bindless_buffers[NonUniformResourceIndex(mesh.vb_uv0)].Load(i0 * 4)); - uv1.xy = unpack_half2(bindless_buffers[NonUniformResourceIndex(mesh.vb_uv0)].Load(i1 * 4)); - uv2.xy = unpack_half2(bindless_buffers[NonUniformResourceIndex(mesh.vb_uv0)].Load(i2 * 4)); - } - [branch] - if (mesh.vb_uv1 >= 0) - { - uv0.zw = unpack_half2(bindless_buffers[NonUniformResourceIndex(mesh.vb_uv1)].Load(i0 * 4)); - uv1.zw = unpack_half2(bindless_buffers[NonUniformResourceIndex(mesh.vb_uv1)].Load(i1 * 4)); - uv2.zw = unpack_half2(bindless_buffers[NonUniformResourceIndex(mesh.vb_uv1)].Load(i2 * 4)); - } - float3 n0 = 0, n1 = 0, n2 = 0; - [branch] - if (mesh.vb_pos_nor_wind >= 0) - { - const uint stride_POS = 16; - n0 = unpack_unitvector(bindless_buffers[NonUniformResourceIndex(mesh.vb_pos_nor_wind)].Load4(i0 * stride_POS).w); - n1 = unpack_unitvector(bindless_buffers[NonUniformResourceIndex(mesh.vb_pos_nor_wind)].Load4(i1 * stride_POS).w); - n2 = unpack_unitvector(bindless_buffers[NonUniformResourceIndex(mesh.vb_pos_nor_wind)].Load4(i2 * stride_POS).w); - } - else - { - surface.init(); - return; // error, this should always be good - } - - float u = barycentrics.x; - float v = barycentrics.y; - float w = 1 - u - v; - float4 uvsets = uv0 * w + uv1 * u + uv2 * v; - - float4 baseColor = material.baseColor; - [branch] - if (material.texture_basecolormap_index >= 0 && (g_xFrame_Options & OPTION_BIT_DISABLE_ALBEDO_MAPS) == 0) - { - const float2 UV_baseColorMap = material.uvset_baseColorMap == 0 ? uvsets.xy : uvsets.zw; - float4 baseColorMap = bindless_textures[NonUniformResourceIndex(material.texture_basecolormap_index)].SampleLevel(sampler_linear_wrap, UV_baseColorMap, 0); - baseColorMap.rgb *= DEGAMMA(baseColorMap.rgb); - baseColor *= baseColorMap; - } - - [branch] - if (mesh.vb_col >= 0 && material.IsUsingVertexColors()) - { - float4 c0, c1, c2; - const uint stride_COL = 4; - c0 = unpack_rgba(bindless_buffers[NonUniformResourceIndex(mesh.vb_col)].Load(i0 * stride_COL)); - c1 = unpack_rgba(bindless_buffers[NonUniformResourceIndex(mesh.vb_col)].Load(i1 * stride_COL)); - c2 = unpack_rgba(bindless_buffers[NonUniformResourceIndex(mesh.vb_col)].Load(i2 * stride_COL)); - float4 vertexColor = c0 * w + c1 * u + c2 * v; - baseColor *= vertexColor; - } - - float4 surfaceMap = 1; - [branch] - if (material.texture_surfacemap_index >= 0) - { - const float2 UV_surfaceMap = material.uvset_surfaceMap == 0 ? uvsets.xy : uvsets.zw; - surfaceMap = bindless_textures[NonUniformResourceIndex(material.texture_surfacemap_index)].SampleLevel(sampler_linear_wrap, UV_surfaceMap, 0); - } - - float4 specularMap = 1; - [branch] - if (material.texture_specularmap_index >= 0) - { - const float2 UV_specularMap = material.uvset_specularMap == 0 ? uvsets.xy : uvsets.zw; - specularMap = bindless_textures[NonUniformResourceIndex(material.texture_specularmap_index)].SampleLevel(sampler_linear_wrap, UV_specularMap, 0); - specularMap.rgb = DEGAMMA(specularMap.rgb); - } - - surface.create(material, baseColor, surfaceMap, specularMap); - - surface.emissiveColor = material.emissiveColor; - [branch] - if (material.texture_emissivemap_index >= 0) - { - const float2 UV_emissiveMap = material.uvset_emissiveMap == 0 ? uvsets.xy : uvsets.zw; - float4 emissiveMap = bindless_textures[NonUniformResourceIndex(material.texture_emissivemap_index)].SampleLevel(sampler_linear_wrap, UV_emissiveMap, 0); - emissiveMap.rgb = DEGAMMA(emissiveMap.rgb); - surface.emissiveColor *= emissiveMap; - } - - surface.transmission = material.transmission; - if (material.texture_transmissionmap_index >= 0) - { - const float2 UV_transmissionMap = material.uvset_transmissionMap == 0 ? uvsets.xy : uvsets.zw; - float transmissionMap = bindless_textures[NonUniformResourceIndex(material.texture_transmissionmap_index)].SampleLevel(sampler_linear_wrap, UV_transmissionMap, 0).r; - surface.transmission *= transmissionMap; - } - - [branch] - if (material.IsOcclusionEnabled_Secondary() && material.texture_occlusionmap_index >= 0) - { - const float2 UV_occlusionMap = material.uvset_occlusionMap == 0 ? uvsets.xy : uvsets.zw; - surface.occlusion *= bindless_textures[NonUniformResourceIndex(material.texture_occlusionmap_index)].SampleLevel(sampler_linear_wrap, UV_occlusionMap, 0).r; - } - - surface.N = n0 * w + n1 * u + n2 * v; - surface.N = mul((float3x3)worldMatrix, surface.N); - surface.N = normalize(surface.N); - surface.facenormal = surface.N; - - [branch] - if (mesh.vb_tan >= 0 && material.texture_normalmap_index >= 0 && material.normalMapStrength > 0) - { - float4 t0, t1, t2; - const uint stride_TAN = 4; - t0 = unpack_utangent(bindless_buffers[NonUniformResourceIndex(mesh.vb_tan)].Load(i0 * stride_TAN)); - t1 = unpack_utangent(bindless_buffers[NonUniformResourceIndex(mesh.vb_tan)].Load(i1 * stride_TAN)); - t2 = unpack_utangent(bindless_buffers[NonUniformResourceIndex(mesh.vb_tan)].Load(i2 * stride_TAN)); - float4 T = t0 * w + t1 * u + t2 * v; - T = T * 2 - 1; - T.xyz = mul((float3x3)worldMatrix, T.xyz); - T.xyz = normalize(T.xyz); - float3 B = normalize(cross(T.xyz, surface.N) * T.w); - float3x3 TBN = float3x3(T.xyz, B, surface.N); - - const float2 UV_normalMap = material.uvset_normalMap == 0 ? uvsets.xy : uvsets.zw; - float3 normalMap = bindless_textures[NonUniformResourceIndex(material.texture_normalmap_index)].SampleLevel(sampler_linear_wrap, UV_normalMap, 0).rgb; - normalMap.b = normalMap.b == 0 ? 1 : normalMap.b; // fix for missing blue channel - normalMap = normalMap * 2 - 1; - surface.N = normalize(lerp(surface.N, mul(normalMap, TBN), material.normalMapStrength)); - } -} #else @@ -194,18 +47,15 @@ void EvaluateObjectSurface( groupshared uint stack[RAYTRACE_STACKSIZE][RAYTRACING_LAUNCH_BLOCKSIZE * RAYTRACING_LAUNCH_BLOCKSIZE]; #endif // RAYTRACE_STACK_SHARED -STRUCTUREDBUFFER(materialBuffer, ShaderMaterial, TEXSLOT_ONDEMAND0); -TEXTURE2D(materialTextureAtlas, float4, TEXSLOT_ONDEMAND1); -RAWBUFFER(primitiveCounterBuffer, TEXSLOT_ONDEMAND2); -STRUCTUREDBUFFER(primitiveBuffer, BVHPrimitive, TEXSLOT_ONDEMAND3); -STRUCTUREDBUFFER(primitiveDataBuffer, BVHPrimitiveData, TEXSLOT_ONDEMAND4); -STRUCTUREDBUFFER(bvhNodeBuffer, BVHNode, TEXSLOT_ONDEMAND5); +RAWBUFFER(primitiveCounterBuffer, TEXSLOT_BVH_COUNTER); +STRUCTUREDBUFFER(primitiveBuffer, BVHPrimitive, TEXSLOT_BVH_PRIMITIVES); +STRUCTUREDBUFFER(bvhNodeBuffer, BVHNode, TEXSLOT_BVH_NODES); struct RayHit { float2 bary; float distance; - uint primitiveID; + PrimitiveID primitiveID; }; inline RayHit CreateRayHit() @@ -213,135 +63,30 @@ inline RayHit CreateRayHit() RayHit hit; hit.bary = 0; hit.distance = FLT_MAX; - hit.primitiveID = ~0u; return hit; } -struct TriangleData -{ - float3 n0, n1, n2; // normals - float4 u0, u1, u2; // uv sets - float4 c0, c1, c2; // vertex colors - float3 tangent; - float3 binormal; - uint materialIndex; -}; -inline TriangleData TriangleData_Unpack(in BVHPrimitive prim, in BVHPrimitiveData primdata) -{ - TriangleData tri; - - tri.n0 = unpack_unitvector(prim.n0); - tri.n1 = unpack_unitvector(prim.n1); - tri.n2 = unpack_unitvector(prim.n2); - - tri.u0 = unpack_half4(primdata.u0); - tri.u1 = unpack_half4(primdata.u1); - tri.u2 = unpack_half4(primdata.u2); - - tri.c0 = unpack_rgba(primdata.c0); - tri.c1 = unpack_rgba(primdata.c1); - tri.c2 = unpack_rgba(primdata.c2); - - tri.tangent = unpack_unitvector(primdata.tangent); - tri.binormal = unpack_unitvector(primdata.binormal); - - tri.materialIndex = primdata.materialIndex; - - return tri; -} - -void EvaluateObjectSurface( - in RayHit hit, - out ShaderMaterial material, - out Surface surface -) -{ - surface = (Surface)0; // otherwise it won't let "out" parameter - - TriangleData tri = TriangleData_Unpack(primitiveBuffer[hit.primitiveID], primitiveDataBuffer[hit.primitiveID]); - - float u = hit.bary.x; - float v = hit.bary.y; - float w = 1 - u - v; - - float4 uvsets = tri.u0 * w + tri.u1 * u + tri.u2 * v; - float4 color = tri.c0 * w + tri.c1 * u + tri.c2 * v; - uint materialIndex = tri.materialIndex; - - material = materialBuffer[materialIndex]; - - uvsets = frac(uvsets); // emulate wrap - - float4 baseColor = material.baseColor * color; - [branch] - if (material.uvset_baseColorMap >= 0 && (g_xFrame_Options & OPTION_BIT_DISABLE_ALBEDO_MAPS) == 0) - { - const float2 UV_baseColorMap = material.uvset_baseColorMap == 0 ? uvsets.xy : uvsets.zw; - float4 baseColorMap = materialTextureAtlas.SampleLevel(sampler_linear_clamp, UV_baseColorMap * material.baseColorAtlasMulAdd.xy + material.baseColorAtlasMulAdd.zw, 0); - baseColorMap.rgb = DEGAMMA(baseColorMap.rgb); - baseColor *= baseColorMap; - } - - float4 surfaceMap = 1; - [branch] - if (material.uvset_surfaceMap >= 0) - { - const float2 UV_surfaceMap = material.uvset_surfaceMap == 0 ? uvsets.xy : uvsets.zw; - surfaceMap = materialTextureAtlas.SampleLevel(sampler_linear_clamp, UV_surfaceMap * material.surfaceMapAtlasMulAdd.xy + material.surfaceMapAtlasMulAdd.zw, 0); - } - - surface.create(material, baseColor, surfaceMap); - - surface.emissiveColor = material.emissiveColor; - [branch] - if (surface.emissiveColor.a > 0 && material.uvset_emissiveMap >= 0) - { - const float2 UV_emissiveMap = material.uvset_emissiveMap == 0 ? uvsets.xy : uvsets.zw; - float4 emissiveMap = materialTextureAtlas.SampleLevel(sampler_linear_clamp, UV_emissiveMap * material.emissiveMapAtlasMulAdd.xy + material.emissiveMapAtlasMulAdd.zw, 0); - emissiveMap.rgb = DEGAMMA(emissiveMap.rgb); - surface.emissiveColor *= emissiveMap; - } - - surface.transmission = material.transmission; - - surface.N = normalize(tri.n0 * w + tri.n1 * u + tri.n2 * v); - surface.facenormal = surface.N; - - [branch] - if (material.uvset_normalMap >= 0) - { - const float2 UV_normalMap = material.uvset_normalMap == 0 ? uvsets.xy : uvsets.zw; - float3 normalMap = materialTextureAtlas.SampleLevel(sampler_linear_clamp, UV_normalMap * material.normalMapAtlasMulAdd.xy + material.normalMapAtlasMulAdd.zw, 0).rgb; - normalMap.b = normalMap.b == 0 ? 1 : normalMap.b; // fix for missing blue channel - normalMap = normalMap.rgb * 2 - 1; - const float3x3 TBN = float3x3(tri.tangent, tri.binormal, surface.N); - surface.N = normalize(lerp(surface.N, mul(normalMap, TBN), material.normalMapStrength)); - } - -} inline void IntersectTriangle( in RayDesc ray, inout RayHit bestHit, - in BVHPrimitive prim, - uint primitiveID + in BVHPrimitive prim ) { float3 v0v1 = prim.v1() - prim.v0(); float3 v0v2 = prim.v2() - prim.v0(); float3 pvec = cross(ray.Direction, v0v2); float det = dot(v0v1, pvec); + #ifdef RAY_BACKFACE_CULLING - // if the determinant is negative the triangle is backfacing - // if the determinant is close to 0, the ray misses the triangle - if (det < 0.000001) + if (det > 0.000001 && (prim.flags & BVH_PRIMITIVE_FLAG_DOUBLE_SIDED) == 0) return; -#else +#endif // RAY_BACKFACE_CULLING + // ray and triangle are parallel if det is close to 0 if (abs(det) < 0.000001) return; -#endif - float invDet = 1 / det; + float invDet = rcp(det); float3 tvec = ray.Origin - prim.v0(); float u = dot(tvec, pvec) * invDet; @@ -358,25 +103,25 @@ inline void IntersectTriangle( if (t >= ray.TMin && t <= bestHit.distance) { bestHit.distance = t; - bestHit.primitiveID = primitiveID; + bestHit.primitiveID = prim.primitiveID(); bestHit.bary = float2(u, v); } } inline bool IntersectTriangleANY( in RayDesc ray, - in BVHPrimitive prim, - uint primitiveID + in BVHPrimitive prim ) { float3 v0v1 = prim.v1() - prim.v0(); float3 v0v2 = prim.v2() - prim.v0(); float3 pvec = cross(ray.Direction, v0v2); float det = dot(v0v1, pvec); + // ray and triangle are parallel if det is close to 0 if (abs(det) < 0.000001) return false; - float invDet = 1 / det; + float invDet = rcp(det); float3 tvec = ray.Origin - prim.v0(); float u = dot(tvec, pvec) * invDet; @@ -392,36 +137,20 @@ inline bool IntersectTriangleANY( if (t >= ray.TMin && t <= ray.TMax) { - RayHit hit; - hit.distance = t; - hit.primitiveID = primitiveID; - hit.bary = float2(u, v); - - TriangleData tri = TriangleData_Unpack(prim, primitiveDataBuffer[hit.primitiveID]); - - float u = hit.bary.x; - float v = hit.bary.y; - float w = 1 - u - v; - - float4 uvsets = tri.u0 * w + tri.u1 * u + tri.u2 * v; - float4 color = tri.c0 * w + tri.c1 * u + tri.c2 * v; - uint materialIndex = tri.materialIndex; - - ShaderMaterial material = materialBuffer[materialIndex]; - - uvsets = frac(uvsets); // emulate wrap - - float4 baseColor = material.baseColor * color; - [branch] - if (material.uvset_baseColorMap >= 0 && (g_xFrame_Options & OPTION_BIT_DISABLE_ALBEDO_MAPS) == 0) + if (prim.flags & BVH_PRIMITIVE_FLAG_TRANSPARENT) { - const float2 UV_baseColorMap = material.uvset_baseColorMap == 0 ? uvsets.xy : uvsets.zw; - float4 baseColorMap = materialTextureAtlas.SampleLevel(sampler_linear_clamp, UV_baseColorMap * material.baseColorAtlasMulAdd.xy + material.baseColorAtlasMulAdd.zw, 0); - baseColorMap.rgb = DEGAMMA(baseColorMap.rgb); - baseColor *= baseColorMap; - } + RayHit hit; + hit.distance = t; + hit.primitiveID = prim.primitiveID(); + hit.bary = float2(u, v); - return baseColor.a > material.alphaTest; + Surface surface; + if (surface.load(prim.primitiveID(), float2(u, v))) + { + return surface.opacity > surface.material.alphaTest; + } + } + return true; } return false; @@ -504,7 +233,7 @@ inline RayHit TraceRay_Closest(RayDesc ray, uint groupIndex = 0) // Leaf node const uint primitiveID = node.LeftChildIndex; const BVHPrimitive prim = primitiveBuffer[primitiveID]; - IntersectTriangle(ray, bestHit, prim, primitiveID); + IntersectTriangle(ray, bestHit, prim); } else { @@ -564,7 +293,7 @@ inline bool TraceRay_Any(RayDesc ray, uint groupIndex = 0) const uint primitiveID = node.LeftChildIndex; const BVHPrimitive prim = primitiveBuffer[primitiveID]; - if (IntersectTriangleANY(ray, prim, primitiveID)) + if (IntersectTriangleANY(ray, prim)) { shadow = true; break; diff --git a/WickedEngine/shaders/renderlightmapPS.hlsl b/WickedEngine/shaders/renderlightmapPS.hlsl index 7b944ec16..6644466c0 100644 --- a/WickedEngine/shaders/renderlightmapPS.hlsl +++ b/WickedEngine/shaders/renderlightmapPS.hlsl @@ -34,9 +34,9 @@ float4 main(Input input) : SV_TARGET surface.P = ray.Origin; [loop] - for (uint iterator = 0; iterator < g_xFrame_LightArrayCount; iterator++) + for (uint iterator = 0; iterator < g_xFrame.LightArrayCount; iterator++) { - ShaderEntity light = EntityArray[g_xFrame_LightArrayOffset + iterator]; + ShaderEntity light = EntityArray[g_xFrame.LightArrayOffset + iterator]; Lighting lighting; lighting.create(0, 0, 0, 0); @@ -63,9 +63,9 @@ float4 main(Input input) : SV_TARGET if (NdotL > 0) { float3 atmosphereTransmittance = 1.0; - if (g_xFrame_Options & OPTION_BIT_REALISTIC_SKY) + if (g_xFrame.Options & OPTION_BIT_REALISTIC_SKY) { - atmosphereTransmittance = GetAtmosphericLightTransmittance(g_xFrame_Atmosphere, surface.P, L, texture_transmittancelut); + atmosphereTransmittance = GetAtmosphericLightTransmittance(g_xFrame.Atmosphere, surface.P, L, texture_transmittancelut); } float3 lightColor = light.GetColor().rgb * light.GetEnergy() * atmosphereTransmittance; @@ -163,25 +163,13 @@ float4 main(Input input) : SV_TARGET ); while (q.Proceed()) { - ShaderMesh mesh = bindless_buffers[NonUniformResourceIndex(q.CandidateInstanceID())].Load(0); - ShaderMeshSubset subset = bindless_subsets[NonUniformResourceIndex(mesh.subsetbuffer)][q.CandidateGeometryIndex()]; - ShaderMaterial material = bindless_buffers[NonUniformResourceIndex(subset.material)].Load(0); - [branch] - if (!material.IsCastingShadow()) - { - continue; - } + PrimitiveID prim; + prim.primitiveIndex = q.CandidatePrimitiveIndex(); + prim.instanceIndex = q.CandidateInstanceID(); + prim.subsetIndex = q.CandidateGeometryIndex(); Surface surface; - EvaluateObjectSurface( - mesh, - subset, - material, - q.CandidatePrimitiveIndex(), - q.CandidateTriangleBarycentrics(), - q.CandidateObjectToWorld3x4(), - surface - ); + surface.load(prim, q.CandidateTriangleBarycentrics()); shadow *= lerp(1, surface.albedo * surface.transmission, surface.opacity); @@ -246,40 +234,29 @@ float4 main(Input input) : SV_TARGET break; } - ShaderMaterial material; - #ifdef RTAPI // ray origin updated for next bounce: ray.Origin = q.WorldRayOrigin() + q.WorldRayDirection() * q.CommittedRayT(); - ShaderMesh mesh = bindless_buffers[NonUniformResourceIndex(q.CommittedInstanceID())].Load(0); - ShaderMeshSubset subset = bindless_subsets[NonUniformResourceIndex(mesh.subsetbuffer)][q.CommittedGeometryIndex()]; - material = bindless_buffers[NonUniformResourceIndex(subset.material)].Load(0); + PrimitiveID prim; + prim.primitiveIndex = q.CommittedPrimitiveIndex(); + prim.instanceIndex = q.CommittedInstanceID(); + prim.subsetIndex = q.CommittedGeometryIndex(); - EvaluateObjectSurface( - mesh, - subset, - material, - q.CommittedPrimitiveIndex(), - q.CommittedTriangleBarycentrics(), - q.CommittedObjectToWorld3x4(), - surface - ); + surface.load(prim, q.CommittedTriangleBarycentrics()); #else // ray origin updated for next bounce: ray.Origin = ray.Origin + ray.Direction * hit.distance; - EvaluateObjectSurface( - hit, - material, - surface - ); + surface.load(hit.primitiveID, hit.bary); #endif // RTAPI surface.update(); + result += max(0, energy * surface.emissiveColor.rgb * surface.emissiveColor.a); + // Calculate chances of reflection types: const float refractChance = surface.transmission; @@ -288,7 +265,7 @@ float4 main(Input input) : SV_TARGET if (roulette < refractChance) { // Refraction - const float3 R = refract(ray.Direction, surface.N, 1 - material.refraction); + const float3 R = refract(ray.Direction, surface.N, 1 - surface.material.refraction); ray.Direction = lerp(R, SampleHemisphere_cos(R, seed, uv), surface.roughnessBRDF); energy *= surface.albedo; @@ -316,7 +293,6 @@ float4 main(Input input) : SV_TARGET } } - result += max(0, energy * surface.emissiveColor.rgb * surface.emissiveColor.a); } return float4(result, xTraceAccumulationFactor); diff --git a/WickedEngine/shaders/rtaoCS.hlsl b/WickedEngine/shaders/rtaoCS.hlsl index 9e3d3049c..1512157a9 100644 --- a/WickedEngine/shaders/rtaoCS.hlsl +++ b/WickedEngine/shaders/rtaoCS.hlsl @@ -15,16 +15,10 @@ groupshared float tile_Z[TILE_SIZE * TILE_SIZE]; [numthreads(POSTPROCESS_BLOCKSIZE, POSTPROCESS_BLOCKSIZE, 1)] void main(uint3 DTid : SV_DispatchThreadID, uint3 Gid : SV_GroupID, uint3 GTid : SV_GroupThreadID, uint groupIndex : SV_GroupIndex) { - // ray traced ao works better with GBUFFER normal: - // Reprojection issues are mostly solved by denoiser anyway const float2 uv = ((float2)DTid.xy + 0.5) * xPPResolution_rcp; - const float2 velocity = texture_gbuffer2.SampleLevel(sampler_point_clamp, uv, 0).xy; - const float2 prevUV = uv + velocity; - const float4 g1 = texture_gbuffer1.SampleLevel(sampler_linear_clamp, prevUV, 0); - const float3 N = normalize(g1.rgb * 2 - 1); - const float depth = texture_depth.SampleLevel(sampler_linear_clamp, uv, 0); - const float3 P = reconstructPosition(uv, depth); + if (depth == 0) + return; uint flatTileIdx = 0; if (GTid.y < 4) @@ -37,6 +31,18 @@ void main(uint3 DTid : SV_DispatchThreadID, uint3 Gid : SV_GroupID, uint3 GTid : } output_tiles[flatTileIdx] = 0; + const float3 P = reconstructPosition(uv, depth); + + PrimitiveID prim; + prim.unpack(texture_gbuffer0[DTid.xy * 2]); + + Surface surface; + if (!surface.load(prim, P)) + { + return; + } + float3 N = surface.facenormal; + RayDesc ray; ray.TMin = 0.01; ray.TMax = rtao_range; @@ -60,34 +66,16 @@ void main(uint3 DTid : SV_DispatchThreadID, uint3 Gid : SV_GroupID, uint3 GTid : ); while (q.Proceed()) { - ShaderMesh mesh = bindless_buffers[NonUniformResourceIndex(q.CandidateInstanceID())].Load(0); - ShaderMeshSubset subset = bindless_subsets[NonUniformResourceIndex(mesh.subsetbuffer)][q.CandidateGeometryIndex()]; - ShaderMaterial material = bindless_buffers[NonUniformResourceIndex(subset.material)].Load(0); - [branch] - if (!material.IsCastingShadow()) - { - continue; - } - [branch] - if (material.texture_basecolormap_index < 0) - { - q.CommitNonOpaqueTriangleHit(); - break; - } + PrimitiveID prim; + prim.primitiveIndex = q.CandidatePrimitiveIndex(); + prim.instanceIndex = q.CandidateInstanceID(); + prim.subsetIndex = q.CandidateGeometryIndex(); Surface surface; - EvaluateObjectSurface( - mesh, - subset, - material, - q.CandidatePrimitiveIndex(), - q.CandidateTriangleBarycentrics(), - q.CandidateObjectToWorld3x4(), - surface - ); + surface.load(prim, q.CandidateTriangleBarycentrics()); [branch] - if (surface.opacity >= material.alphaTest) + if (surface.opacity >= surface.material.alphaTest) { q.CommitNonOpaqueTriangleHit(); break; diff --git a/WickedEngine/shaders/rtao_denoise_filterCS.hlsl b/WickedEngine/shaders/rtao_denoise_filterCS.hlsl index 7786af640..c4d975fb7 100644 --- a/WickedEngine/shaders/rtao_denoise_filterCS.hlsl +++ b/WickedEngine/shaders/rtao_denoise_filterCS.hlsl @@ -22,7 +22,7 @@ float2 FFX_DNSR_Shadows_GetInvBufferDimensions() } float4x4 FFX_DNSR_Shadows_GetProjectionInverse() { - return g_xCamera_InvP; + return g_xCamera.InvP; } float FFX_DNSR_Shadows_GetDepthSimilaritySigma() diff --git a/WickedEngine/shaders/rtao_denoise_tileclassificationCS.hlsl b/WickedEngine/shaders/rtao_denoise_tileclassificationCS.hlsl index 87982a4b3..2a4a92b5f 100644 --- a/WickedEngine/shaders/rtao_denoise_tileclassificationCS.hlsl +++ b/WickedEngine/shaders/rtao_denoise_tileclassificationCS.hlsl @@ -25,19 +25,19 @@ float2 FFX_DNSR_Shadows_GetInvBufferDimensions() } float3 FFX_DNSR_Shadows_GetEye() { - return g_xCamera_CamPos; + return g_xCamera.CamPos; } float4x4 FFX_DNSR_Shadows_GetProjectionInverse() { - return g_xCamera_InvP; + return g_xCamera.InvP; } float4x4 FFX_DNSR_Shadows_GetViewProjectionInverse() { - return g_xCamera_InvVP; + return g_xCamera.InvVP; } float4x4 FFX_DNSR_Shadows_GetReprojectionMatrix() { - return g_xCamera_Reprojection; + return g_xCamera.Reprojection; } float FFX_DNSR_Shadows_ReadDepth(uint2 did) @@ -66,7 +66,7 @@ float FFX_DNSR_Shadows_ReadHistory(float2 history_uv) } float2 FFX_DNSR_Shadows_ReadVelocity(uint2 did) { - return -texture_gbuffer2[did * 2].xy; + return -texture_gbuffer1[did * 2].xy; } void FFX_DNSR_Shadows_WriteReprojectionResults(uint2 did, float2 value) diff --git a/WickedEngine/shaders/rtreflectionLIB.hlsl b/WickedEngine/shaders/rtreflectionLIB.hlsl index e83bc59e4..a044f2030 100644 --- a/WickedEngine/shaders/rtreflectionLIB.hlsl +++ b/WickedEngine/shaders/rtreflectionLIB.hlsl @@ -27,67 +27,24 @@ void RTReflection_Raygen() if (depth == 0) return; - bool disocclusion = false; - const float2 velocity = texture_gbuffer2.SampleLevel(sampler_point_clamp, uv, 0).xy; - const float2 prevUV = uv + velocity; - if (!is_saturated(prevUV)) - { - //output[DTid.xy] = float4(1, 0, 0, 1); - //return; - disocclusion = true; - } - - // Disocclusion fallback: - float depth_current = getLinearDepth(depth); - float depth_history = getLinearDepth(texture_depth_history.SampleLevel(sampler_point_clamp, prevUV, 1)); - if (abs(depth_current - depth_history) > 1) - { - //output[DTid.xy] = float4(1, 0, 0, 1); - //return; - disocclusion = true; - } - const float3 P = reconstructPosition(uv, depth); - const float3 V = normalize(g_xCamera_CamPos - P); + const float3 V = normalize(g_xCamera.CamPos - P); - float3 N; - float roughness; - if (disocclusion) + PrimitiveID prim; + prim.unpack(texture_gbuffer0[DTid.xy * 2]); + + Surface surface; + surface.load(prim, P); + if (surface.roughness > 0.6) { - // When reprojection is invalid, trace the surface parameters: - RayDesc ray; - ray.Origin = P - V * 0.005; - ray.Direction = V; - ray.TMin = 0; - ray.TMax = 0.01; - - RayPayload payload; - payload.data = -1; // indicate closesthit shader will just fill normal and roughness - - TraceRay( - scene_acceleration_structure, // AccelerationStructure - RAY_FLAG_FORCE_OPAQUE | - RAY_FLAG_ACCEPT_FIRST_HIT_AND_END_SEARCH | - 0, // RayFlags - ~0, // InstanceInclusionMask - 0, // RayContributionToHitGroupIndex - 0, // MultiplierForGeomtryContributionToShaderIndex - 0, // MissShaderIndex - ray, // Ray - payload // Payload - ); - - N = payload.data.xyz; - roughness = payload.data.w; - } - else - { - // When reprojection valid, just sample surface parameters from gbuffer: - const float4 g1 = texture_gbuffer1.SampleLevel(sampler_linear_clamp, prevUV, 0); - N = normalize(g1.rgb * 2 - 1); - roughness = g1.a; + output[DTid.xy] = float4(max(0, EnvironmentReflection_Global(surface)), 1); + output_rayLengths[DTid.xy] = FLT_MAX; + return; } + float3 N = surface.N; + float roughness = surface.roughness; + // The ray direction selection part is the same as in from ssr_raytraceCS.hlsl: float4 H; float3 L; @@ -119,7 +76,7 @@ void RTReflection_Raygen() const float3 R = L; - float seed = g_xFrame_Time; + float seed = g_xFrame.Time; RayDesc ray; ray.TMin = 0.01; @@ -149,21 +106,13 @@ void RTReflection_Raygen() [shader("closesthit")] void RTReflection_ClosestHit(inout RayPayload payload, in BuiltInTriangleIntersectionAttributes attr) { - ShaderMesh mesh = bindless_buffers[NonUniformResourceIndex(InstanceID())].Load(0); - ShaderMeshSubset subset = bindless_subsets[NonUniformResourceIndex(mesh.subsetbuffer)][GeometryIndex()]; - ShaderMaterial material = bindless_buffers[NonUniformResourceIndex(subset.material)].Load(0); + PrimitiveID prim; + prim.primitiveIndex = PrimitiveIndex(); + prim.instanceIndex = InstanceID(); + prim.subsetIndex = GeometryIndex(); Surface surface; - - EvaluateObjectSurface( - mesh, - subset, - material, - PrimitiveIndex(), - attr.barycentrics, - ObjectToWorld3x4(), - surface - ); + surface.load(prim, attr.barycentrics); [branch] if (payload.data.w < 0) @@ -185,10 +134,10 @@ void RTReflection_ClosestHit(inout RayPayload payload, in BuiltInTriangleInterse lighting.create(0, 0, GetAmbient(surface.N), 0); [loop] - for (uint iterator = 0; iterator < g_xFrame_LightArrayCount; iterator++) + for (uint iterator = 0; iterator < g_xFrame.LightArrayCount; iterator++) { - ShaderEntity light = EntityArray[g_xFrame_LightArrayOffset + iterator]; - if ((light.layerMask & material.layerMask) == 0) + ShaderEntity light = EntityArray[g_xFrame.LightArrayOffset + iterator]; + if ((light.layerMask & surface.material.layerMask) == 0) continue; if (light.GetFlags() & ENTITY_FLAG_LIGHT_STATIC) @@ -226,24 +175,16 @@ void RTReflection_ClosestHit(inout RayPayload payload, in BuiltInTriangleInterse [shader("anyhit")] void RTReflection_AnyHit(inout RayPayload payload, in BuiltInTriangleIntersectionAttributes attr) { - ShaderMesh mesh = bindless_buffers[NonUniformResourceIndex(InstanceID())].Load(0); - ShaderMeshSubset subset = bindless_subsets[NonUniformResourceIndex(mesh.subsetbuffer)][GeometryIndex()]; - ShaderMaterial material = bindless_buffers[NonUniformResourceIndex(subset.material)].Load(0); + PrimitiveID prim; + prim.primitiveIndex = PrimitiveIndex(); + prim.instanceIndex = InstanceID(); + prim.subsetIndex = GeometryIndex(); Surface surface; - - EvaluateObjectSurface( - mesh, - subset, - material, - PrimitiveIndex(), - attr.barycentrics, - ObjectToWorld3x4(), - surface - ); + surface.load(prim, attr.barycentrics); [branch] - if (surface.opacity < material.alphaTest) + if (surface.opacity < surface.material.alphaTest) { IgnoreHit(); } diff --git a/WickedEngine/shaders/rtshadow_denoise_filterCS.hlsl b/WickedEngine/shaders/rtshadow_denoise_filterCS.hlsl index a03c0d204..3916dbc0b 100644 --- a/WickedEngine/shaders/rtshadow_denoise_filterCS.hlsl +++ b/WickedEngine/shaders/rtshadow_denoise_filterCS.hlsl @@ -24,7 +24,7 @@ float2 FFX_DNSR_Shadows_GetInvBufferDimensions() } float4x4 FFX_DNSR_Shadows_GetProjectionInverse() { - return g_xCamera_InvP; + return g_xCamera.InvP; } float FFX_DNSR_Shadows_GetDepthSimilaritySigma() diff --git a/WickedEngine/shaders/rtshadow_denoise_temporalCS.hlsl b/WickedEngine/shaders/rtshadow_denoise_temporalCS.hlsl index 914b2390f..becbd4cdf 100644 --- a/WickedEngine/shaders/rtshadow_denoise_temporalCS.hlsl +++ b/WickedEngine/shaders/rtshadow_denoise_temporalCS.hlsl @@ -80,7 +80,7 @@ void main(uint3 DTid : SV_DispatchThreadID, uint3 GTid : SV_GroupThreadID, uint3 const float2 uv = (DTid.xy + 0.5f) * xPPResolution_rcp; - const float2 velocity = texture_gbuffer2.SampleLevel(sampler_point_clamp, uv, 0).xy; + const float2 velocity = texture_gbuffer1.SampleLevel(sampler_point_clamp, uv, 0).xy; const float2 prevUV = uv + velocity; if (!is_saturated(prevUV)) { diff --git a/WickedEngine/shaders/rtshadow_denoise_tileclassificationCS.hlsl b/WickedEngine/shaders/rtshadow_denoise_tileclassificationCS.hlsl index 3a5a21c1a..8474fffec 100644 --- a/WickedEngine/shaders/rtshadow_denoise_tileclassificationCS.hlsl +++ b/WickedEngine/shaders/rtshadow_denoise_tileclassificationCS.hlsl @@ -30,19 +30,19 @@ float2 FFX_DNSR_Shadows_GetInvBufferDimensions() } float3 FFX_DNSR_Shadows_GetEye() { - return g_xCamera_CamPos; + return g_xCamera.CamPos; } float4x4 FFX_DNSR_Shadows_GetProjectionInverse() { - return g_xCamera_InvP; + return g_xCamera.InvP; } float4x4 FFX_DNSR_Shadows_GetViewProjectionInverse() { - return g_xCamera_InvVP; + return g_xCamera.InvVP; } float4x4 FFX_DNSR_Shadows_GetReprojectionMatrix() { - return g_xCamera_Reprojection; + return g_xCamera.Reprojection; } float FFX_DNSR_Shadows_ReadDepth(uint2 did) @@ -71,7 +71,7 @@ float FFX_DNSR_Shadows_ReadHistory(float2 history_uv) } float2 FFX_DNSR_Shadows_ReadVelocity(uint2 did) { - return -texture_gbuffer2[did * 2].xy; + return -texture_gbuffer1[did * 2].xy; } void FFX_DNSR_Shadows_WriteReprojectionResults(uint2 did, float2 value) diff --git a/WickedEngine/shaders/screenPS.hlsl b/WickedEngine/shaders/screenPS.hlsl index 637979da4..51fdb968e 100644 --- a/WickedEngine/shaders/screenPS.hlsl +++ b/WickedEngine/shaders/screenPS.hlsl @@ -2,5 +2,12 @@ float4 main(float4 pos : SV_Position, float2 uv : TEXCOORD) : SV_TARGET { - return texture_base.SampleLevel(Sampler, uv, 0) * xColor; -} \ No newline at end of file + SamplerState sam = bindless_samplers[push.sampler_index]; + float4 color = unpack_half4(push.packed_color); + [branch] + if (push.texture_base_index >= 0) + { + color *= bindless_textures[push.texture_base_index].Sample(sam, uv); + } + return color; +} diff --git a/WickedEngine/shaders/screenspaceshadowCS.hlsl b/WickedEngine/shaders/screenspaceshadowCS.hlsl index bc4e5b3f6..6144f63fd 100644 --- a/WickedEngine/shaders/screenspaceshadowCS.hlsl +++ b/WickedEngine/shaders/screenspaceshadowCS.hlsl @@ -1,4 +1,4 @@ -#define BRDF_NDOTL_BIAS 0.1 +//#define BRDF_NDOTL_BIAS 0.1 #include "globals.hlsli" #include "ShaderInterop_Postprocess.h" #include "raytracingHF.hlsli" @@ -21,19 +21,12 @@ groupshared float tile_Z[TILE_SIZE * TILE_SIZE]; [numthreads(POSTPROCESS_BLOCKSIZE, POSTPROCESS_BLOCKSIZE, 1)] void main(uint3 DTid : SV_DispatchThreadID, uint3 Gid : SV_GroupID, uint3 GTid : SV_GroupThreadID, uint groupIndex : SV_GroupIndex) { -#ifdef RTSHADOW - - // ray traced shadow works better with GBUFFER normal: - // Reprojection issues are mostly solved by denoiser anyway const float2 uv = ((float2)DTid.xy + 0.5) * xPPResolution_rcp; - const float2 velocity = texture_gbuffer2.SampleLevel(sampler_point_clamp, uv, 0).xy; - const float2 prevUV = uv + velocity; - const float4 g1 = texture_gbuffer1.SampleLevel(sampler_linear_clamp, prevUV, 0); - const float3 N = normalize(g1.rgb * 2 - 1); - const float depth = texture_depth.SampleLevel(sampler_linear_clamp, uv, 0); - const float3 P = reconstructPosition(uv, depth); + if (depth == 0) + return; +#ifdef RTSHADOW uint flatTileIdx = 0; if (GTid.y < 4) { @@ -44,84 +37,24 @@ void main(uint3 DTid : SV_DispatchThreadID, uint3 Gid : SV_GroupID, uint3 GTid : flatTileIdx = flatten2D(Gid.xy * uint2(1, 2) + uint2(0, 1), (xPPResolution + uint2(7, 3)) / uint2(8, 4)); } output_tiles[flatTileIdx] = 0; +#endif // RTSHADOW + + float3 P = reconstructPosition(uv, depth); + + PrimitiveID prim; + prim.unpack(texture_gbuffer0[DTid.xy * 2]); + + Surface surface; + if (!surface.load(prim, P)) + { + return; + } + float3 N = surface.N; const float2 bluenoise = blue_noise(DTid.xy).xy; -#else - - // Screen space shadow will reconstruct normal from depth: - - const int2 tile_upperleft = Gid.xy * POSTPROCESS_BLOCKSIZE - TILE_BORDER; - for (uint t = groupIndex; t < TILE_SIZE * TILE_SIZE; t += POSTPROCESS_BLOCKSIZE * POSTPROCESS_BLOCKSIZE) - { - const uint2 pixel = tile_upperleft + unflatten2D(t, TILE_SIZE); - const float2 uv = (pixel + 0.5f) * xPPResolution_rcp; - const float depth = texture_depth.SampleLevel(sampler_linear_clamp, uv, 0); - const float3 position = reconstructPosition(uv, depth); - tile_XY[t] = position.xy; - tile_Z[t] = position.z; - } - GroupMemoryBarrierWithGroupSync(); - - // reconstruct flat normals from depth buffer: - // Explanation: There are two main ways to reconstruct flat normals from depth buffer: - // 1: use ddx() and ddy() on the reconstructed positions to compute triangle, this has artifacts on depth discontinuities and doesn't work in compute shader - // 2: Take 3 taps from the depth buffer, reconstruct positions and compute triangle. This can still produce artifacts - // on discontinuities, but a little less. To fix the remaining artifacts, we can take 4 taps around the center, and find the "best triangle" - // by only computing the positions from those depths that have the least amount of discontinuity - - const uint cross_idx[5] = { - flatten2D(TILE_BORDER + GTid.xy, TILE_SIZE), // 0: center - flatten2D(TILE_BORDER + GTid.xy + int2(1, 0), TILE_SIZE), // 1: right - flatten2D(TILE_BORDER + GTid.xy + int2(-1, 0), TILE_SIZE), // 2: left - flatten2D(TILE_BORDER + GTid.xy + int2(0, 1), TILE_SIZE), // 3: down - flatten2D(TILE_BORDER + GTid.xy + int2(0, -1), TILE_SIZE), // 4: up - }; - - const float center_Z = tile_Z[cross_idx[0]]; - - [branch] - if (center_Z >= g_xCamera_ZFarP) - return; - - const uint best_Z_horizontal = abs(tile_Z[cross_idx[1]] - center_Z) < abs(tile_Z[cross_idx[2]] - center_Z) ? 1 : 2; - const uint best_Z_vertical = abs(tile_Z[cross_idx[3]] - center_Z) < abs(tile_Z[cross_idx[4]] - center_Z) ? 3 : 4; - - float3 p1 = 0, p2 = 0; - if (best_Z_horizontal == 1 && best_Z_vertical == 4) - { - p1 = float3(tile_XY[cross_idx[1]], tile_Z[cross_idx[1]]); - p2 = float3(tile_XY[cross_idx[4]], tile_Z[cross_idx[4]]); - } - else if (best_Z_horizontal == 1 && best_Z_vertical == 3) - { - p1 = float3(tile_XY[cross_idx[3]], tile_Z[cross_idx[3]]); - p2 = float3(tile_XY[cross_idx[1]], tile_Z[cross_idx[1]]); - } - else if (best_Z_horizontal == 2 && best_Z_vertical == 4) - { - p1 = float3(tile_XY[cross_idx[4]], tile_Z[cross_idx[4]]); - p2 = float3(tile_XY[cross_idx[2]], tile_Z[cross_idx[2]]); - } - else if (best_Z_horizontal == 2 && best_Z_vertical == 3) - { - p1 = float3(tile_XY[cross_idx[2]], tile_Z[cross_idx[2]]); - p2 = float3(tile_XY[cross_idx[3]], tile_Z[cross_idx[3]]); - } - - const float3 P = float3(tile_XY[cross_idx[0]], tile_Z[cross_idx[0]]); - const float3 N = normalize(cross(p2 - P, p1 - P)); - -#endif // RTSHADOW - - Surface surface; - surface.init(); - surface.pixel = DTid.xy; - surface.P = P; - surface.N = N; - - const uint2 tileIndex = uint2(floor(surface.pixel * 2 / TILED_CULLING_BLOCKSIZE)); - const uint flatTileIndex = flatten2D(tileIndex, g_xFrame_EntityCullingTileCount.xy) * SHADER_ENTITY_TILE_BUCKET_COUNT; + const uint2 tileIndex = uint2(floor(DTid.xy * 2 / TILED_CULLING_BLOCKSIZE)); + const uint flatTileIndex = flatten2D(tileIndex, g_xFrame.EntityCullingTileCount.xy) * SHADER_ENTITY_TILE_BUCKET_COUNT; uint shadow_mask[4] = {0,0,0,0}; // FXC issue: can't dynamically index into uint4, unless unrolling all loops uint shadow_index = 0; @@ -131,7 +64,7 @@ void main(uint3 DTid : SV_DispatchThreadID, uint3 Gid : SV_GroupID, uint3 GTid : ray.Origin = P; #ifndef RTSHADOW - ray.Origin = mul(g_xCamera_View, float4(ray.Origin, 1)).xyz; + ray.Origin = mul(g_xCamera.View, float4(ray.Origin, 1)).xyz; const float range = xPPParams0.x; const uint samplecount = xPPParams0.y; @@ -141,11 +74,11 @@ void main(uint3 DTid : SV_DispatchThreadID, uint3 Gid : SV_GroupID, uint3 GTid : #endif // RTSHADOW [branch] - if (g_xFrame_LightArrayCount > 0) + if (g_xFrame.LightArrayCount > 0) { // Loop through light buckets in the tile: - const uint first_item = g_xFrame_LightArrayOffset; - const uint last_item = first_item + g_xFrame_LightArrayCount - 1; + const uint first_item = g_xFrame.LightArrayOffset; + const uint last_item = first_item + g_xFrame.LightArrayCount - 1; const uint first_bucket = first_item / 32; const uint last_bucket = min(last_item / 32, max(0, SHADER_ENTITY_TILE_BUCKET_COUNT - 1)); [loop] @@ -168,7 +101,7 @@ void main(uint3 DTid : SV_DispatchThreadID, uint3 Gid : SV_GroupID, uint3 GTid : [branch] if (entity_index >= first_item && entity_index <= last_item) { - shadow_index = entity_index - g_xFrame_LightArrayOffset; + shadow_index = entity_index - g_xFrame.LightArrayOffset; if (shadow_index >= MAX_RTSHADOWS) break; @@ -286,34 +219,16 @@ void main(uint3 DTid : SV_DispatchThreadID, uint3 Gid : SV_GroupID, uint3 GTid : ); while (q.Proceed()) { - ShaderMesh mesh = bindless_buffers[NonUniformResourceIndex(q.CandidateInstanceID())].Load(0); - ShaderMeshSubset subset = bindless_subsets[NonUniformResourceIndex(mesh.subsetbuffer)][q.CandidateGeometryIndex()]; - ShaderMaterial material = bindless_buffers[NonUniformResourceIndex(subset.material)].Load(0); - [branch] - if (!material.IsCastingShadow()) - { - continue; - } - [branch] - if (material.texture_basecolormap_index < 0) - { - q.CommitNonOpaqueTriangleHit(); - break; - } + PrimitiveID prim; + prim.primitiveIndex = q.CandidatePrimitiveIndex(); + prim.instanceIndex = q.CandidateInstanceID(); + prim.subsetIndex = q.CandidateGeometryIndex(); Surface surface; - EvaluateObjectSurface( - mesh, - subset, - material, - q.CandidatePrimitiveIndex(), - q.CandidateTriangleBarycentrics(), - q.CandidateObjectToWorld3x4(), - surface - ); + surface.load(prim, q.CandidateTriangleBarycentrics()); [branch] - if (surface.opacity >= material.alphaTest) + if (surface.opacity >= surface.material.alphaTest) { q.CommitNonOpaqueTriangleHit(); break; @@ -326,7 +241,7 @@ void main(uint3 DTid : SV_DispatchThreadID, uint3 Gid : SV_GroupID, uint3 GTid : #else // screen space raymarch shadow: - ray.Direction = normalize(mul((float3x3)g_xCamera_View, L)); + ray.Direction = normalize(mul((float3x3)g_xCamera.View, L)); float3 rayPos = ray.Origin + ray.Direction * stepsize * offset; float occlusion = 0; @@ -335,7 +250,7 @@ void main(uint3 DTid : SV_DispatchThreadID, uint3 Gid : SV_GroupID, uint3 GTid : { rayPos += ray.Direction * stepsize; - float4 proj = mul(g_xCamera_Proj, float4(rayPos, 1)); + float4 proj = mul(g_xCamera.Proj, float4(rayPos, 1)); proj.xyz /= proj.w; proj.xy = proj.xy * float2(0.5f, -0.5f) + float2(0.5f, 0.5f); @@ -343,7 +258,7 @@ void main(uint3 DTid : SV_DispatchThreadID, uint3 Gid : SV_GroupID, uint3 GTid : if (is_saturated(proj.xy)) { const float ray_depth_real = proj.w; - const float ray_depth_sample = texture_lineardepth.SampleLevel(sampler_point_clamp, proj.xy, 1) * g_xCamera_ZFarP; + const float ray_depth_sample = texture_lineardepth.SampleLevel(sampler_point_clamp, proj.xy, 1) * g_xCamera.ZFarP; const float ray_depth_delta = ray_depth_real - ray_depth_sample; if (ray_depth_delta > 0 && ray_depth_delta < thickness) { diff --git a/WickedEngine/shaders/shadingRateClassificationCS.hlsl b/WickedEngine/shaders/shadingRateClassificationCS.hlsl index eeb2f7b7e..f5304b661 100644 --- a/WickedEngine/shaders/shadingRateClassificationCS.hlsl +++ b/WickedEngine/shaders/shadingRateClassificationCS.hlsl @@ -21,7 +21,7 @@ void main( uint3 Gid : SV_GroupID, uint3 GTid : SV_GroupThreadID, uint groupInde GroupMemoryBarrierWithGroupSync(); uint2 dim; - texture_gbuffer2.GetDimensions(dim.x, dim.y); + texture_gbuffer1.GetDimensions(dim.x, dim.y); const uint2 tile = Gid.xy; @@ -33,7 +33,7 @@ void main( uint3 Gid : SV_GroupID, uint3 GTid : SV_GroupThreadID, uint groupInde const uint2 tile_pixel = unflatten2D(i, xShadingRateTileSize); const uint2 pixel = min(tile * xShadingRateTileSize + tile_pixel, dim - 1); - const float2 velocity = abs(texture_gbuffer2[pixel].xy); + const float2 velocity = abs(texture_gbuffer1[pixel].xy); const float magnitude = max(velocity.x, velocity.y); uint rate = 0; diff --git a/WickedEngine/shaders/shadowPS_alphatest.hlsl b/WickedEngine/shaders/shadowPS_alphatest.hlsl index d8050861d..d4e81b2d4 100644 --- a/WickedEngine/shaders/shadowPS_alphatest.hlsl +++ b/WickedEngine/shaders/shadowPS_alphatest.hlsl @@ -1,4 +1,4 @@ -#define OBJECTSHADER_LAYOUT_POS_TEX +#define OBJECTSHADER_LAYOUT_SHADOW_TEX #include "objectHF.hlsli" void main(PixelInput input) diff --git a/WickedEngine/shaders/shadowPS_transparent.hlsl b/WickedEngine/shaders/shadowPS_transparent.hlsl index 3857ffee2..50c60665d 100644 --- a/WickedEngine/shaders/shadowPS_transparent.hlsl +++ b/WickedEngine/shaders/shadowPS_transparent.hlsl @@ -1,4 +1,4 @@ -#define OBJECTSHADER_LAYOUT_POS_TEX +#define OBJECTSHADER_LAYOUT_SHADOW_TEX #define OBJECTSHADER_USE_COLOR #include "objectHF.hlsli" diff --git a/WickedEngine/shaders/shadowPS_water.hlsl b/WickedEngine/shaders/shadowPS_water.hlsl index 091c5e559..e50288bbd 100644 --- a/WickedEngine/shaders/shadowPS_water.hlsl +++ b/WickedEngine/shaders/shadowPS_water.hlsl @@ -1,4 +1,4 @@ -#define OBJECTSHADER_LAYOUT_POS_TEX +#define OBJECTSHADER_LAYOUT_SHADOW_TEX #define OBJECTSHADER_USE_COLOR #include "objectHF.hlsli" diff --git a/WickedEngine/shaders/shadowVS.hlsl b/WickedEngine/shaders/shadowVS.hlsl index 8130d56b0..63adad972 100644 --- a/WickedEngine/shaders/shadowVS.hlsl +++ b/WickedEngine/shaders/shadowVS.hlsl @@ -1,3 +1,3 @@ #define OBJECTSHADER_COMPILE_VS -#define OBJECTSHADER_LAYOUT_POS +#define OBJECTSHADER_LAYOUT_SHADOW #include "objectHF.hlsli" diff --git a/WickedEngine/shaders/shadowVS_alphatest.hlsl b/WickedEngine/shaders/shadowVS_alphatest.hlsl index 4013f127a..8d7a436b3 100644 --- a/WickedEngine/shaders/shadowVS_alphatest.hlsl +++ b/WickedEngine/shaders/shadowVS_alphatest.hlsl @@ -1,3 +1,3 @@ #define OBJECTSHADER_COMPILE_VS -#define OBJECTSHADER_LAYOUT_POS_TEX +#define OBJECTSHADER_LAYOUT_SHADOW_TEX #include "objectHF.hlsli" diff --git a/WickedEngine/shaders/shadowVS_transparent.hlsl b/WickedEngine/shaders/shadowVS_transparent.hlsl index f6b448015..ba84a94e2 100644 --- a/WickedEngine/shaders/shadowVS_transparent.hlsl +++ b/WickedEngine/shaders/shadowVS_transparent.hlsl @@ -1,4 +1,4 @@ #define OBJECTSHADER_COMPILE_VS -#define OBJECTSHADER_LAYOUT_POS_TEX +#define OBJECTSHADER_LAYOUT_SHADOW_TEX #define OBJECTSHADER_USE_COLOR #include "objectHF.hlsli" diff --git a/WickedEngine/shaders/skinningCS.hlsl b/WickedEngine/shaders/skinningCS.hlsl index 52166072b..d89f45a14 100644 --- a/WickedEngine/shaders/skinningCS.hlsl +++ b/WickedEngine/shaders/skinningCS.hlsl @@ -1,20 +1,7 @@ #include "ResourceMapping.h" -#include "ShaderInterop_Skinning.h" +#include "ShaderInterop_Renderer.h" -// This will make use of LDS to preload bones into local memory: -// #define USE_LDS - -struct Bone -{ - float4 pose0; - float4 pose1; - float4 pose2; -}; -STRUCTUREDBUFFER(boneBuffer, Bone, SKINNINGSLOT_IN_BONEBUFFER); - -#ifdef USE_LDS -groupshared Bone LDS_BoneList[SKINNING_COMPUTE_THREADCOUNT]; -#endif // USE_LDS +STRUCTUREDBUFFER(boneBuffer, ShaderTransform, SKINNINGSLOT_IN_BONEBUFFER); RAWBUFFER(vertexBuffer_POS, SKINNINGSLOT_IN_VERTEX_POS); RAWBUFFER(vertexBuffer_TAN, SKINNINGSLOT_IN_VERTEX_TAN); @@ -38,18 +25,7 @@ inline void Skinning(inout float3 pos, inout float3 nor, inout float3 tan, in fl [loop] for (uint i = 0; ((i < 4) && (weisum < 1.0f)); ++i) { - float4x4 m = float4x4( -#ifdef USE_LDS - LDS_BoneList[(uint)inBon[i]].pose0, - LDS_BoneList[(uint)inBon[i]].pose1, - LDS_BoneList[(uint)inBon[i]].pose2, -#else - boneBuffer[(uint)inBon[i]].pose0, - boneBuffer[(uint)inBon[i]].pose1, - boneBuffer[(uint)inBon[i]].pose2, -#endif // USE_LDS - float4(0, 0, 0, 1) - ); + float4x4 m = boneBuffer[(uint)inBon[i]].GetMatrix(); p += mul(m, float4(pos.xyz, 1)) * inWei[i]; n += mul((float3x3)m, nor.xyz) * inWei[i]; @@ -65,21 +41,12 @@ inline void Skinning(inout float3 pos, inout float3 nor, inout float3 tan, in fl } -[numthreads(SKINNING_COMPUTE_THREADCOUNT, 1, 1)] +[numthreads(64, 1, 1)] void main(uint3 DTid : SV_DispatchThreadID, uint3 GTid : SV_GroupThreadID) { -#ifdef USE_LDS - LDS_BoneList[GTid.x] = boneBuffer[GTid.x]; -#endif // USE_LDS - - const uint stride_POS_NOR = 16; - const uint stride_TAN = 4; - const uint stride_BON_IND = 8; - const uint stride_BON_WEI = 8; - - const uint fetchAddress_POS_NOR = DTid.x * stride_POS_NOR; - const uint fetchAddress_TAN = DTid.x * stride_TAN; - const uint fetchAddress_BON = DTid.x * (stride_BON_IND + stride_BON_WEI); + const uint fetchAddress_POS_NOR = DTid.x * sizeof(float4); + const uint fetchAddress_TAN = DTid.x * sizeof(uint); + const uint fetchAddress_BON = DTid.x * sizeof(uint4); // Manual type-conversion for pos: uint4 pos_nor_u = vertexBuffer_POS.Load4(fetchAddress_POS_NOR); @@ -120,10 +87,6 @@ void main(uint3 DTid : SV_DispatchThreadID, uint3 GTid : SV_GroupThreadID) wei.w = (float)((ind_wei_u.w >> 16) & 0x0000FFFF) / 65535.0f; } -#ifdef USE_LDS - GroupMemoryBarrierWithGroupSync(); -#endif // USE_LDS - // Perform skinning: Skinning(pos, nor.xyz, tan.xyz, ind, wei); @@ -155,4 +118,4 @@ void main(uint3 DTid : SV_DispatchThreadID, uint3 GTid : SV_GroupThreadID) // Store data: streamoutBuffer_POS.Store4(fetchAddress_POS_NOR, pos_nor_u); streamoutBuffer_TAN.Store(fetchAddress_TAN, vtan); -} \ No newline at end of file +} diff --git a/WickedEngine/shaders/skinningCS_LDS.hlsl b/WickedEngine/shaders/skinningCS_LDS.hlsl deleted file mode 100644 index 8ed342714..000000000 --- a/WickedEngine/shaders/skinningCS_LDS.hlsl +++ /dev/null @@ -1,3 +0,0 @@ -#define USE_LDS - -#include "skinningCS.hlsl" diff --git a/WickedEngine/shaders/skyAtmosphere.hlsli b/WickedEngine/shaders/skyAtmosphere.hlsli index 4fa23a7aa..7634409f0 100644 --- a/WickedEngine/shaders/skyAtmosphere.hlsli +++ b/WickedEngine/shaders/skyAtmosphere.hlsli @@ -568,7 +568,7 @@ SingleScatteringResult IntegrateScatteredLuminance( //if (Sampling.PerPixelNoise) //{ - // t = t0 + (t1 - t0) * InterleavedGradientNoise(pixPos, g_xFrame_FrameCount % 16); + // t = t0 + (t1 - t0) * InterleavedGradientNoise(pixPos, g_xFrame.FrameCount % 16); //} //else //{ diff --git a/WickedEngine/shaders/skyAtmosphere_multiScatteredLuminanceLutCS.hlsl b/WickedEngine/shaders/skyAtmosphere_multiScatteredLuminanceLutCS.hlsl index 721664265..def02623f 100644 --- a/WickedEngine/shaders/skyAtmosphere_multiScatteredLuminanceLutCS.hlsl +++ b/WickedEngine/shaders/skyAtmosphere_multiScatteredLuminanceLutCS.hlsl @@ -19,7 +19,7 @@ void main(uint3 DTid : SV_DispatchThreadID) uv = float2(FromSubUvsToUnit(uv.x, multiScatteringLUTRes.x), FromSubUvsToUnit(uv.y, multiScatteringLUTRes.y)); - AtmosphereParameters atmosphere = g_xFrame_Atmosphere; + AtmosphereParameters atmosphere = g_xFrame.Atmosphere; float cosSunZenithAngle = uv.x * 2.0 - 1.0; float3 sunDirection = float3(0.0, sqrt(saturate(1.0 - cosSunZenithAngle * cosSunZenithAngle)), cosSunZenithAngle); diff --git a/WickedEngine/shaders/skyAtmosphere_skyLuminanceLutCS.hlsl b/WickedEngine/shaders/skyAtmosphere_skyLuminanceLutCS.hlsl index de1875c52..21eb360e8 100644 --- a/WickedEngine/shaders/skyAtmosphere_skyLuminanceLutCS.hlsl +++ b/WickedEngine/shaders/skyAtmosphere_skyLuminanceLutCS.hlsl @@ -16,7 +16,7 @@ void main(uint3 DTid : SV_DispatchThreadID) float2 uv = pixelPosition * rcp(multiScatteringLUTRes); - AtmosphereParameters atmosphere = g_xFrame_Atmosphere; + AtmosphereParameters atmosphere = g_xFrame.Atmosphere; float viewHeight = atmosphere.bottomRadius + skyLuminanceSampleHeight; diff --git a/WickedEngine/shaders/skyAtmosphere_skyViewLutCS.hlsl b/WickedEngine/shaders/skyAtmosphere_skyViewLutCS.hlsl index 959021ad4..2c0a16da1 100644 --- a/WickedEngine/shaders/skyAtmosphere_skyViewLutCS.hlsl +++ b/WickedEngine/shaders/skyAtmosphere_skyViewLutCS.hlsl @@ -8,12 +8,12 @@ RWTEXTURE2D(output, float4, 0); [numthreads(8, 8, 1)] void main(uint3 DTid : SV_DispatchThreadID) { - AtmosphereParameters atmosphere = g_xFrame_Atmosphere; + AtmosphereParameters atmosphere = g_xFrame.Atmosphere; float2 pixelPosition = float2(DTid.xy) + 0.5; float2 uv = pixelPosition * rcp(skyViewLUTRes); - float3 skyRelativePosition = g_xCamera_CamPos; + float3 skyRelativePosition = g_xCamera.CamPos; float3 worldPosition = GetCameraPlanetPos(atmosphere, skyRelativePosition); float viewHeight = length(worldPosition); diff --git a/WickedEngine/shaders/skyAtmosphere_transmittanceLutCS.hlsl b/WickedEngine/shaders/skyAtmosphere_transmittanceLutCS.hlsl index 67cb40196..faafb43d7 100644 --- a/WickedEngine/shaders/skyAtmosphere_transmittanceLutCS.hlsl +++ b/WickedEngine/shaders/skyAtmosphere_transmittanceLutCS.hlsl @@ -9,7 +9,7 @@ RWTEXTURE2D(output, float4, 0); void main(uint3 DTid : SV_DispatchThreadID) { float2 pixelPosition = float2(DTid.xy) + 0.5; - AtmosphereParameters atmosphere = g_xFrame_Atmosphere; + AtmosphereParameters atmosphere = g_xFrame.Atmosphere; // Compute camera position from LUT coords const float2 uv = pixelPosition * rcp(transmittanceLUTRes); diff --git a/WickedEngine/shaders/skyHF.hlsli b/WickedEngine/shaders/skyHF.hlsli index 73c93103c..e3e05d73c 100644 --- a/WickedEngine/shaders/skyHF.hlsli +++ b/WickedEngine/shaders/skyHF.hlsli @@ -8,7 +8,7 @@ float3 AccurateAtmosphericScattering(Texture2D skyViewLutTexture, Texture2D transmittanceLUT, Texture2D multiScatteringLUT, float3 rayOrigin, float3 rayDirection, float3 sunDirection, float sunEnergy, float3 sunColor, bool enableSun, bool darkMode, bool stationary) { - AtmosphereParameters atmosphere = g_xFrame_Atmosphere; + AtmosphereParameters atmosphere = g_xFrame.Atmosphere; float3 worldDirection = rayDirection; @@ -119,7 +119,7 @@ float3 CustomAtmosphericScattering(float3 V, float3 sunDirection, float3 sunColo const float zenith = V.y; // how much is above (0: horizon, 1: directly above) const float sunScatter = saturate(sunDirection.y + 0.1f); // how much the sun is directly above. Even if sunis at horizon, we add a constant scattering amount so that light still scatters at horizon - const float atmosphereDensity = 0.5 + g_xFrame_FogHeightSky; // constant of air density, or "fog height" as interpreted here (bigger is more obstruction of sun) + const float atmosphereDensity = 0.5 + g_xFrame.FogHeightSky; // constant of air density, or "fog height" as interpreted here (bigger is more obstruction of sun) const float zenithDensity = atmosphereDensity / pow(max(0.000001f, zenith), 0.75f); const float sunScatterDensity = atmosphereDensity / pow(max(0.000001f, sunScatter), 0.75f); @@ -153,13 +153,13 @@ float3 CustomAtmosphericScattering(float3 V, float3 sunDirection, float3 sunColo void CalculateClouds(inout float3 sky, float3 V, bool dark_enabled) { - if (g_xFrame_Cloudiness <= 0) + if (g_xFrame.Cloudiness <= 0) { return; } // Trace a cloud layer plane: - const float3 o = g_xCamera_CamPos; + const float3 o = g_xCamera.CamPos; const float3 d = V; const float3 planeOrigin = float3(0, 1000, 0); const float3 planeNormal = float3(0, -1, 0); @@ -171,8 +171,8 @@ void CalculateClouds(inout float3 sky, float3 V, bool dark_enabled) } const float3 cloudPos = o + d * t; - const float2 cloudUV = cloudPos.xz * g_xFrame_CloudScale; - const float cloudTime = g_xFrame_Time * g_xFrame_CloudSpeed; + const float2 cloudUV = cloudPos.xz * g_xFrame.CloudScale; + const float cloudTime = g_xFrame.Time * g_xFrame.CloudSpeed; const float2x2 m = float2x2(1.6, 1.2, -1.2, 1.6); const uint quality = 8; @@ -224,8 +224,8 @@ void CalculateClouds(inout float3 sky, float3 V, bool dark_enabled) // lerp between "choppy clouds" and "uniform clouds". Lower cloudiness will produce choppy clouds, but very high cloudiness will switch to overcast unfiform clouds: - clouds = lerp(clouds * 9.0f * g_xFrame_Cloudiness + 0.3f, clouds * 0.5f + 0.5f, pow(saturate(g_xFrame_Cloudiness), 8)); - clouds = saturate(clouds - (1 - g_xFrame_Cloudiness)); // modulate constant cloudiness + clouds = lerp(clouds * 9.0f * g_xFrame.Cloudiness + 0.3f, clouds * 0.5f + 0.5f, pow(saturate(g_xFrame.Cloudiness), 8)); + clouds = saturate(clouds - (1 - g_xFrame.Cloudiness)); // modulate constant cloudiness clouds *= pow(1 - saturate(length(abs(cloudPos.xz * 0.00001f))), 16); //fade close to horizon if (dark_enabled) @@ -242,9 +242,9 @@ void CalculateClouds(inout float3 sky, float3 V, bool dark_enabled) // V : view direction float3 GetDynamicSkyColor(in float3 V, bool sun_enabled = true, bool clouds_enabled = true, bool dark_enabled = false, bool realistic_sky_stationary = false) { - if (g_xFrame_Options & OPTION_BIT_SIMPLE_SKY) + if (g_xFrame.Options & OPTION_BIT_SIMPLE_SKY) { - return lerp(GetHorizonColor(), GetZenithColor(), saturate(V.y * 0.5f + 0.5f)) * g_xFrame_SkyExposure; + return lerp(GetHorizonColor(), GetZenithColor(), saturate(V.y * 0.5f + 0.5f)) * g_xFrame.SkyExposure; } const float3 sunDirection = GetSunDirection(); @@ -253,14 +253,14 @@ float3 GetDynamicSkyColor(in float3 V, bool sun_enabled = true, bool clouds_enab float3 sky = float3(0, 0, 0); - if (g_xFrame_Options & OPTION_BIT_REALISTIC_SKY) + if (g_xFrame.Options & OPTION_BIT_REALISTIC_SKY) { sky = AccurateAtmosphericScattering ( texture_skyviewlut, // Sky View Lut (combination of precomputed atmospheric LUTs) texture_transmittancelut, texture_multiscatteringlut, - g_xCamera_CamPos, // Ray origin + g_xCamera.CamPos, // Ray origin V, // Ray direction sunDirection, // Position of the sun sunEnergy, // Sun energy @@ -282,7 +282,7 @@ float3 GetDynamicSkyColor(in float3 V, bool sun_enabled = true, bool clouds_enab ); } - sky *= g_xFrame_SkyExposure; + sky *= g_xFrame.SkyExposure; if (clouds_enabled) { diff --git a/WickedEngine/shaders/skyPS_dynamic.hlsl b/WickedEngine/shaders/skyPS_dynamic.hlsl index 33e86ac96..dfef0bf93 100644 --- a/WickedEngine/shaders/skyPS_dynamic.hlsl +++ b/WickedEngine/shaders/skyPS_dynamic.hlsl @@ -3,10 +3,10 @@ float4 main(float4 pos : SV_POSITION, float2 clipspace : TEXCOORD) : SV_TARGET { - float4 unprojected = mul(g_xCamera_InvVP, float4(clipspace, 0.0f, 1.0f)); + float4 unprojected = mul(g_xCamera.InvVP, float4(clipspace, 0.0f, 1.0f)); unprojected.xyz /= unprojected.w; - const float3 V = normalize(unprojected.xyz - g_xCamera_CamPos); + const float3 V = normalize(unprojected.xyz - g_xCamera.CamPos); float4 color = float4(GetDynamicSkyColor(V), 1); diff --git a/WickedEngine/shaders/skyPS_static.hlsl b/WickedEngine/shaders/skyPS_static.hlsl index 65b858136..4b9c72d3e 100644 --- a/WickedEngine/shaders/skyPS_static.hlsl +++ b/WickedEngine/shaders/skyPS_static.hlsl @@ -3,16 +3,16 @@ float4 main(float4 pos : SV_POSITION, float2 clipspace : TEXCOORD) : SV_TARGET { - float4 unprojected = mul(g_xCamera_InvVP, float4(clipspace, 0.0f, 1.0f)); + float4 unprojected = mul(g_xCamera.InvVP, float4(clipspace, 0.0f, 1.0f)); unprojected.xyz /= unprojected.w; - const float3 V = normalize(unprojected.xyz - g_xCamera_CamPos); + const float3 V = normalize(unprojected.xyz - g_xCamera.CamPos); float4 color = float4(DEGAMMA_SKY(texture_globalenvmap.SampleLevel(sampler_linear_clamp, V, 0).rgb), 1); CalculateClouds(color.rgb, V, false); - float4 pos2DPrev = mul(g_xCamera_PrevVP, float4(unprojected.xyz, 1)); - float2 velocity = ((pos2DPrev.xy / pos2DPrev.w - g_xFrame_TemporalAAJitterPrev) - (clipspace - g_xFrame_TemporalAAJitter)) * float2(0.5f, -0.5f); + float4 pos2DPrev = mul(g_xCamera.PrevVP, float4(unprojected.xyz, 1)); + float2 velocity = ((pos2DPrev.xy / pos2DPrev.w - g_xCamera.TemporalAAJitterPrev) - (clipspace - g_xCamera.TemporalAAJitter)) * float2(0.5f, -0.5f); return color; } diff --git a/WickedEngine/shaders/skyPS_velocity.hlsl b/WickedEngine/shaders/skyPS_velocity.hlsl deleted file mode 100644 index c104cb5fb..000000000 --- a/WickedEngine/shaders/skyPS_velocity.hlsl +++ /dev/null @@ -1,13 +0,0 @@ -#include "objectHF.hlsli" -#include "skyHF.hlsli" - -float4 main(float4 pos : SV_POSITION, float2 clipspace : TEXCOORD) : SV_TARGET -{ - float4 unprojected = mul(g_xCamera_InvVP, float4(clipspace, 0.0f, 1.0f)); - unprojected.xyz /= unprojected.w; - - float4 pos2DPrev = mul(g_xCamera_PrevVP, float4(unprojected.xyz, 1)); - float2 velocity = ((pos2DPrev.xy / pos2DPrev.w - g_xFrame_TemporalAAJitterPrev) - (clipspace - g_xFrame_TemporalAAJitter)) * float2(0.5f, -0.5f); - - return float4(velocity, 0, 0); -} diff --git a/WickedEngine/shaders/sphereVS.hlsl b/WickedEngine/shaders/sphereVS.hlsl index 8cbfdc9b0..f17d6bb22 100644 --- a/WickedEngine/shaders/sphereVS.hlsl +++ b/WickedEngine/shaders/sphereVS.hlsl @@ -15,6 +15,6 @@ VSOut_Sphere main( uint vID : SV_VERTEXID ) o.nor = o.pos.xyz; o.pos = mul(g_xTransform, o.pos); o.pos3D = o.pos.xyz; - o.pos = mul(g_xCamera_VP, o.pos); + o.pos = mul(g_xCamera.VP, o.pos); return o; } \ No newline at end of file diff --git a/WickedEngine/shaders/ssaoCS.hlsl b/WickedEngine/shaders/ssaoCS.hlsl index 118145b6e..4e028203f 100644 --- a/WickedEngine/shaders/ssaoCS.hlsl +++ b/WickedEngine/shaders/ssaoCS.hlsl @@ -20,7 +20,7 @@ void main(uint3 DTid : SV_DispatchThreadID, uint3 Gid : SV_GroupID, uint3 GTid : const uint2 pixel = tile_upperleft + unflatten2D(t, TILE_SIZE); const float2 uv = (pixel + 0.5f) * xPPResolution_rcp; const float depth = texture_depth.SampleLevel(sampler_linear_clamp, uv, 1); - const float3 position = reconstructPosition(uv, depth, g_xCamera_InvP); // specify matrix to get view-space position! + const float3 position = reconstructPosition(uv, depth, g_xCamera.InvP); // specify matrix to get view-space position! tile_XY[t] = position.xy; tile_Z[t] = position.z; } @@ -44,7 +44,7 @@ void main(uint3 DTid : SV_DispatchThreadID, uint3 Gid : SV_GroupID, uint3 GTid : const float center_Z = tile_Z[cross_idx[0]]; [branch] - if (center_Z >= g_xCamera_ZFarP) + if (center_Z >= g_xCamera.ZFarP) return; const uint best_Z_horizontal = abs(tile_Z[cross_idx[1]] - center_Z) < abs(tile_Z[cross_idx[2]] - center_Z) ? 1 : 2; @@ -93,7 +93,7 @@ void main(uint3 DTid : SV_DispatchThreadID, uint3 Gid : SV_GroupID, uint3 GTid : const float ray_range = ssao_range * lerp(0.2f, 1.0f, rand(seed, uv)); // modulate ray-length a bit to avoid uniform look const float3 sam = P + cone * ray_range; - float4 vProjectedCoord = mul(g_xCamera_Proj, float4(sam, 1.0f)); + float4 vProjectedCoord = mul(g_xCamera.Proj, float4(sam, 1.0f)); vProjectedCoord.xyz /= vProjectedCoord.w; vProjectedCoord.xy = vProjectedCoord.xy * float2(0.5f, -0.5f) + float2(0.5f, 0.5f); @@ -102,7 +102,7 @@ void main(uint3 DTid : SV_DispatchThreadID, uint3 Gid : SV_GroupID, uint3 GTid : { #ifdef USE_LINEARDEPTH const float ray_depth_real = vProjectedCoord.w; // .w is also linear depth, could be also written as getLinearDepth(vProjectedCoord.z) - const float ray_depth_sample = texture_lineardepth.SampleLevel(sampler_point_clamp, vProjectedCoord.xy, 0) * g_xCamera_ZFarP; + const float ray_depth_sample = texture_lineardepth.SampleLevel(sampler_point_clamp, vProjectedCoord.xy, 0) * g_xCamera.ZFarP; const float depth_fix = 1 - saturate(abs(ray_depth_real - ray_depth_sample) * 0.2f); // too much depth difference cancels the effect ao += (ray_depth_sample < ray_depth_real) * depth_fix; #else diff --git a/WickedEngine/shaders/ssr_raytraceCS.hlsl b/WickedEngine/shaders/ssr_raytraceCS.hlsl index d54b86c27..eb5b14bc4 100644 --- a/WickedEngine/shaders/ssr_raytraceCS.hlsl +++ b/WickedEngine/shaders/ssr_raytraceCS.hlsl @@ -7,9 +7,6 @@ TEXTURE2D(input, float4, TEXSLOT_ONDEMAND0); RWTEXTURE2D(texture_raytrace, float4, 0); RWTEXTURE2D(texture_rayLengths, float, 1); -// Use this to use reduced precision, but higher framerate: -#define USE_LINEARDEPTH - static const float rayTraceStrideMin = 1.0f; // Step in horizontal or vertical pixels between samples. static const float rayTraceStrideMax = 10.0f; // Define max stride between samples. Roughness will interpolate between it's min and max counterparts. static const float rayTraceMaxStep = 512.0f; // Maximum number of iterations. Higher gives better images but may be slow. @@ -20,7 +17,7 @@ static const float rayTraceMaxDistance = 1000.0f; // Maximum camera-space distan static const float rayTraceStrideCutoff = 100.0f; // More distant pixels are smaller in screen space. This value tells at what point to // start relaxing the stride to give higher quality reflections for objects far from the camera. static const float raytraceHZBBias = 0.05f; // This value tells how fast the roughness increases the level. -static const float raytraceHZBStartLevel = 0.0f; +static const float raytraceHZBStartLevel = 1.0f; static const float raytraceHZBMinStep = 0.005f; // Minimum level increasement per iteration. @@ -34,10 +31,12 @@ bool IntersectsDepthBuffer(float sceneZMax, float rayZMin, float rayZMax) { // Increase thickness along distance. float thickness = max(sceneZMax * rayTraceThicknessBias + rayTraceThicknessOffset, 1.0); - + +#if 0 // precision issues in DX12 // Effectively remove line/tiny artifacts, mostly caused by Zbuffers precision. float depthScale = min(1.0f, sceneZMax / rayTraceStrideCutoff); sceneZMax += lerp(0.05f, 0.0f, depthScale); +#endif if (raytraceThicknessInfinite) return (rayZMin >= sceneZMax); @@ -49,21 +48,22 @@ bool IntersectsDepthBuffer(float sceneZMax, float rayZMin, float rayZMax) // http://casual-effects.blogspot.com/2014/08/screen-space-ray-tracing.html bool ScreenSpaceRayTrace(float3 csOrig, float3 csDir, float jitter, float roughness, out float2 hitPixel, out float3 hitPoint, out float iterations) { - float rayLength = ((csOrig.z + csDir.z * rayTraceMaxDistance) < g_xCamera_ZNearP) ? - (g_xCamera_ZNearP - csOrig.z) / csDir.z : rayTraceMaxDistance; + csOrig += csDir * 0.001; // precision issues in DX12 + float rayLength = ((csOrig.z + csDir.z * rayTraceMaxDistance) < g_xCamera.ZNearP) ? + (g_xCamera.ZNearP - csOrig.z) / csDir.z : rayTraceMaxDistance; float3 csRayEnd = csOrig + csDir * rayLength; // Project into homogeneous clip space - float4 clipRayOrigin = mul(g_xCamera_Proj, float4(csOrig, 1.0f)); - float4 clipRayEnd = mul(g_xCamera_Proj, float4(csRayEnd, 1.0f)); + float4 clipRayOrigin = mul(g_xCamera.Proj, float4(csOrig, 1.0f)); + float4 clipRayEnd = mul(g_xCamera.Proj, float4(csRayEnd, 1.0f)); float k0 = 1.0f / clipRayOrigin.w; float k1 = 1.0f / clipRayEnd.w; float3 Q0 = csOrig * k0; float3 Q1 = csRayEnd * k1; - + // Screen-space endpoints float2 P0 = clipRayOrigin.xy * k0; float2 P1 = clipRayEnd.xy * k1; @@ -201,11 +201,7 @@ bool ScreenSpaceRayTrace(float3 csOrig, float3 csDir, float jitter, float roughn hitPixel = permute ? PQk.yx : PQk.xy; hitPixel *= xPPResolution_rcp; -#ifdef USE_LINEARDEPTH - sceneZMax = texture_lineardepth.SampleLevel(sampler_point_clamp, hitPixel, level) * g_xCamera_ZFarP; -#else - sceneZMax = getLinearDepth(texture_depth.SampleLevel(sampler_point_clamp, hitPixel, 0).r); -#endif + sceneZMax = texture_lineardepth.SampleLevel(sampler_linear_clamp, hitPixel, level) * g_xCamera.ZFarP; } // Undo the last increment, which ran after the test variables were set up @@ -226,20 +222,27 @@ bool ScreenSpaceRayTrace(float3 csOrig, float3 csDir, float jitter, float roughn void main(uint3 DTid : SV_DispatchThreadID) { const float2 uv = (DTid.xy + 0.5f) * xPPResolution_rcp; - const float depth = texture_depth.SampleLevel(sampler_point_clamp, uv, 1); + const float depth = texture_depth.SampleLevel(sampler_linear_clamp, uv, 1); if (depth == 0) return; - const float2 velocity = texture_gbuffer2.SampleLevel(sampler_point_clamp, uv, 0).xy; - const float2 prevUV = uv + velocity; + PrimitiveID prim; + prim.unpack(texture_gbuffer0[DTid.xy * 2]); - // Everything in view space: - const float4 g1 = texture_gbuffer1.SampleLevel(sampler_linear_clamp, prevUV, 0); - const float3 P = reconstructPosition(uv, depth, g_xCamera_InvP); - const float3 N = normalize(mul((float3x3)g_xCamera_View, g1.rgb * 2 - 1).xyz); - const float3 V = normalize(-P); + Surface surface; + surface.load(prim, reconstructPosition(uv, depth)); + if (surface.roughness > 0.6) + { + texture_raytrace[DTid.xy] = 0; + texture_rayLengths[DTid.xy] = 0; + return; + } - const float roughness = GetRoughness(g1.a); + // Everything in view space: + float3 N = normalize(mul((float3x3)g_xCamera.View, surface.N)); + float3 P = reconstructPosition(uv, depth, g_xCamera.InvP); + float3 V = normalize(-P); + const float roughness = GetRoughness(surface.roughness); const float roughnessFade = GetRoughnessFade(roughness, SSRMaxRoughness); if (roughnessFade <= 0) @@ -270,7 +273,7 @@ void main(uint3 DTid : SV_DispatchThreadID) #else // Old // Low-discrepancy sequence - uint2 Random = Rand_PCG16(int3((DTid.xy + 0.5f), g_xFrame_FrameCount)).xy; + uint2 Random = Rand_PCG16(int3((DTid.xy + 0.5f), g_xFrame.FrameCount)).xy; float2 Xi = HammersleyRandom16(1, Random); // SingleSPP @@ -288,7 +291,7 @@ void main(uint3 DTid : SV_DispatchThreadID) const float surfaceMargin = 0.0f; const float maxRegenCount = 15.0f; - uint2 Random = Rand_PCG16(int3((DTid.xy + 0.5f), g_xFrame_FrameCount)).xy; + uint2 Random = Rand_PCG16(int3((DTid.xy + 0.5f), g_xFrame.FrameCount)).xy; // By using an uniform importance sampling method, some rays go below the surface. // We simply re-generate them at a negligible cost, to get some nice ones. @@ -315,7 +318,7 @@ void main(uint3 DTid : SV_DispatchThreadID) #endif L = reflect(-V, H.xyz); - jitter = InterleavedGradientNoise(DTid.xy, g_xFrame_FrameCount); + jitter = InterleavedGradientNoise(DTid.xy, g_xFrame.FrameCount); } else { @@ -331,7 +334,7 @@ void main(uint3 DTid : SV_DispatchThreadID) bool hit = ScreenSpaceRayTrace(P, L, jitter, roughness, hitPixel, hitPoint, iterations); - float hitDepth = texture_depth.SampleLevel(sampler_point_clamp, hitPixel, 0); + float hitDepth = texture_depth.SampleLevel(sampler_linear_clamp, hitPixel, 1); // Output: // xy: hit pixel @@ -342,7 +345,7 @@ void main(uint3 DTid : SV_DispatchThreadID) if (hit) { - const float3 Phit = reconstructPosition(uv, hitDepth, g_xCamera_InvP); + const float3 Phit = reconstructPosition(uv, hitDepth, g_xCamera.InvP); texture_rayLengths[DTid.xy] = distance(P, Phit); } else diff --git a/WickedEngine/shaders/ssr_resolveCS.hlsl b/WickedEngine/shaders/ssr_resolveCS.hlsl index 9c2d8368e..f2c427e3a 100644 --- a/WickedEngine/shaders/ssr_resolveCS.hlsl +++ b/WickedEngine/shaders/ssr_resolveCS.hlsl @@ -63,7 +63,7 @@ void GetSampleInfo(float2 velocity, float2 neighborUV, float2 uv, float3 P, floa // BRDF Weight - float3 hitViewPosition = reconstructPosition(hitPixel, hitDepth, g_xCamera_InvP); + float3 hitViewPosition = reconstructPosition(hitPixel, hitDepth, g_xCamera.InvP); float3 L = normalize(hitViewPosition - P); float3 H = normalize(L + V); @@ -91,21 +91,27 @@ void GetSampleInfo(float2 velocity, float2 neighborUV, float2 uv, float3 P, floa void main(uint3 DTid : SV_DispatchThreadID) { const float2 uv = (DTid.xy + 0.5f) * xPPResolution_rcp; - const float depth = texture_depth.SampleLevel(sampler_point_clamp, uv, 1); + const float depth = texture_depth.SampleLevel(sampler_linear_clamp, uv, 0); if (depth == 0.0f) return; - const float2 velocity = texture_gbuffer2.SampleLevel(sampler_point_clamp, uv, 0).xy; - const float2 prevUV = uv + velocity; - // Everthing in view space: - const float4 g1 = texture_gbuffer1.SampleLevel(sampler_linear_clamp, prevUV, 0); - const float3 P = reconstructPosition(uv, depth, g_xCamera_InvP); - const float3 N = normalize(mul((float3x3)g_xCamera_View, g1.rgb * 2 - 1).xyz); + const float3 P = reconstructPosition(uv, depth, g_xCamera.InvP); const float3 V = normalize(-P); + + PrimitiveID prim; + prim.unpack(texture_gbuffer0[DTid.xy * 2]); + + Surface surface; + surface.load(prim, P); + + const float3 N = normalize(mul((float3x3)g_xCamera.View, surface.N)); + const float roughness = GetRoughness(surface.roughness); + const float NdotV = saturate(dot(N, V)); - - const float roughness = GetRoughness(g1.a); + + const float2 velocity = texture_gbuffer1.SampleLevel(sampler_point_clamp, uv, 0).xy; + const float2 prevUV = uv + velocity; // Early out, useless if the roughness is out of range float roughnessFade = GetRoughnessFade(roughness, SSRMaxRoughness); diff --git a/WickedEngine/shaders/ssr_temporalCS.hlsl b/WickedEngine/shaders/ssr_temporalCS.hlsl index 2a1f2095e..c3cba0919 100644 --- a/WickedEngine/shaders/ssr_temporalCS.hlsl +++ b/WickedEngine/shaders/ssr_temporalCS.hlsl @@ -95,12 +95,12 @@ inline void ResolverAABB(Texture2D currentColor, SamplerState currentSam [numthreads(POSTPROCESS_BLOCKSIZE, POSTPROCESS_BLOCKSIZE, 1)] void main(uint3 DTid : SV_DispatchThreadID, uint3 GTid : SV_GroupThreadID, uint3 Gid : SV_GroupID, uint groupIndex : SV_GroupIndex) { - if (texture_depth.Load(uint3(DTid.xy, 1)) == 0) + const float2 uv = (DTid.xy + 0.5f) * xPPResolution_rcp; + const float depth = texture_depth.SampleLevel(sampler_linear_clamp, uv, 0); + if (depth == 0) return; - const float2 uv = (DTid.xy + 0.5f) * xPPResolution_rcp; - - const float2 velocity = texture_gbuffer2.SampleLevel(sampler_point_clamp, uv, 0).xy; + const float2 velocity = texture_gbuffer1.SampleLevel(sampler_point_clamp, uv, 0).xy; float2 prevUV = uv + velocity; if (!is_saturated(prevUV)) { @@ -108,15 +108,22 @@ void main(uint3 DTid : SV_DispatchThreadID, uint3 GTid : SV_GroupThreadID, uint3 return; } - const float roughness = texture_gbuffer1.SampleLevel(sampler_point_clamp, prevUV, 0).a; + const float3 P = reconstructPosition(uv, depth, g_xCamera.InvP); + + PrimitiveID prim; + prim.unpack(texture_gbuffer0[DTid.xy * 2]); + + Surface surface; + surface.load(prim, P); + + const float roughness = surface.roughness; + if (roughness < 0.01) { output[DTid.xy] = resolve_current[DTid.xy]; //return; } - const float depth = texture_depth.SampleLevel(sampler_point_clamp, uv, 0); - // Secondary reprojection based on ray lengths: // https://www.ea.com/seed/news/seed-dd18-presentation-slides-raytracing (Slide 45) if (roughness < 0.5) @@ -125,9 +132,9 @@ void main(uint3 DTid : SV_DispatchThreadID, uint3 GTid : SV_GroupThreadID, uint3 if (rayLength > 0) { const float3 P = reconstructPosition(uv, depth); - const float3 V = normalize(g_xCamera_CamPos - P); + const float3 V = normalize(g_xCamera.CamPos - P); const float3 rayEnd = P - V * rayLength; - float4 rayEndPrev = mul(g_xCamera_PrevVP, float4(rayEnd, 1)); + float4 rayEndPrev = mul(g_xCamera.PrevVP, float4(rayEnd, 1)); rayEndPrev.xy /= rayEndPrev.w; prevUV = rayEndPrev.xy * float2(0.5, -0.5) + 0.5; } diff --git a/WickedEngine/shaders/stochasticSSRHF.hlsli b/WickedEngine/shaders/stochasticSSRHF.hlsli index 05ffaf5cb..0655d9072 100644 --- a/WickedEngine/shaders/stochasticSSRHF.hlsli +++ b/WickedEngine/shaders/stochasticSSRHF.hlsli @@ -1,5 +1,6 @@ #ifndef WI_STOCHASTICSSR_HF #define WI_STOCHASTICSSR_HF +#include "brdf.hlsli" // Stochastic Screen Space Reflections reference: // https://www.ea.com/frostbite/news/stochastic-screen-space-reflections diff --git a/WickedEngine/shaders/sunPS.hlsl b/WickedEngine/shaders/sunPS.hlsl index c1ff19a9b..0fb309436 100644 --- a/WickedEngine/shaders/sunPS.hlsl +++ b/WickedEngine/shaders/sunPS.hlsl @@ -4,10 +4,10 @@ float4 main(float4 pos : SV_POSITION, float2 clipspace : TEXCOORD) : SV_TARGET { - float4 unprojected = mul(g_xCamera_InvVP, float4(clipspace, 0.0f, 1.0f)); + float4 unprojected = mul(g_xCamera.InvVP, float4(clipspace, 0.0f, 1.0f)); unprojected.xyz /= unprojected.w; - const float3 origin = g_xCamera_CamPos; + const float3 origin = g_xCamera.CamPos; const float3 direction = normalize(unprojected.xyz - origin); return float4(GetDynamicSkyColor(direction, true, true, true), 1); diff --git a/WickedEngine/shaders/surfel_binningCS.hlsl b/WickedEngine/shaders/surfel_binningCS.hlsl new file mode 100644 index 000000000..065b5c1f4 --- /dev/null +++ b/WickedEngine/shaders/surfel_binningCS.hlsl @@ -0,0 +1,36 @@ +#include "globals.hlsli" +#include "ShaderInterop_SurfelGI.h" + +STRUCTUREDBUFFER(surfelBuffer, Surfel, TEXSLOT_ONDEMAND0); +RAWBUFFER(surfelStatsBuffer, TEXSLOT_ONDEMAND1); + +RWSTRUCTUREDBUFFER(surfelGridBuffer, SurfelGridCell, 0); +RWSTRUCTUREDBUFFER(surfelCellBuffer, uint, 1); + +[numthreads(64, 1, 1)] +void main(uint3 DTid : SV_DispatchThreadID) +{ + uint surfel_count = surfelStatsBuffer.Load(SURFEL_STATS_OFFSET_COUNT); + if (DTid.x >= surfel_count) + return; + + uint surfel_index = DTid.x; + Surfel surfel = surfelBuffer[surfel_index]; + if (surfel.radius > 0) + { + int3 center_cell = surfel_cell(surfel.position); + for (uint i = 0; i < 27; ++i) + { + int3 gridpos = center_cell + surfel_neighbor_offsets[i]; + + if (surfel_cellintersects(surfel, gridpos)) + { + uint cellindex = surfel_cellindex(gridpos); + uint prevCount; + InterlockedAdd(surfelGridBuffer[cellindex].count, 1, prevCount); + surfelCellBuffer[surfelGridBuffer[cellindex].offset + prevCount] = surfel_index; + } + } + + } +} diff --git a/WickedEngine/shaders/surfel_coverageCS.hlsl b/WickedEngine/shaders/surfel_coverageCS.hlsl new file mode 100644 index 000000000..f5f463184 --- /dev/null +++ b/WickedEngine/shaders/surfel_coverageCS.hlsl @@ -0,0 +1,253 @@ +#include "globals.hlsli" +#include "ShaderInterop_SurfelGI.h" +#include "brdf.hlsli" + +//#define SURFEL_DEBUG_NORMAL +//#define SURFEL_DEBUG_COLOR +#define SURFEL_DEBUG_POINT +//#define SURFEL_DEBUG_RANDOM +//#define SURFEL_DEBUG_HEATMAP + + +static const uint random_colors_size = 11; +static const float3 random_colors[random_colors_size] = { + float3(0,0,1), + float3(0,1,1), + float3(0,1,0), + float3(1,1,0), + float3(1,0,0), + float3(1,0,1), + float3(0.5,1,1), + float3(0.5,1,0.5), + float3(1,1,0.5), + float3(1,0.5,0.5), + float3(1,0.5,1), +}; +float3 random_color(uint index) +{ + return random_colors[index % random_colors_size]; +} + +STRUCTUREDBUFFER(surfelBuffer, Surfel, TEXSLOT_ONDEMAND0); +STRUCTUREDBUFFER(surfelGridBuffer, SurfelGridCell, TEXSLOT_ONDEMAND2); +STRUCTUREDBUFFER(surfelCellBuffer, uint, TEXSLOT_ONDEMAND3); +TEXTURE2D(surfelMomentsTexture, float2, TEXSLOT_ONDEMAND4); + +RWSTRUCTUREDBUFFER(surfelDataBuffer, SurfelData, 0); +RWRAWBUFFER(surfelStatsBuffer, 1); +RWTEXTURE2D(result, float3, 2); +RWTEXTURE2D(debugUAV, unorm float4, 3); + +void write_result(uint2 DTid, float4 color) +{ +#ifdef SURFEL_COVERAGE_HALFRES + result[DTid * 2 + uint2(0, 0)] = color.rgb; + result[DTid * 2 + uint2(1, 0)] = color.rgb; + result[DTid * 2 + uint2(0, 1)] = color.rgb; + result[DTid * 2 + uint2(1, 1)] = color.rgb; +#else + result[DTid] = color.rgb; +#endif // SURFEL_COVERAGE_HALFRES +} +void write_debug(uint2 DTid, float4 debug) +{ +#ifdef SURFEL_COVERAGE_HALFRES + debugUAV[DTid * 2 + uint2(0, 0)] = debug; + debugUAV[DTid * 2 + uint2(1, 0)] = debug; + debugUAV[DTid * 2 + uint2(0, 1)] = debug; + debugUAV[DTid * 2 + uint2(1, 1)] = debug; +#else + debugUAV[DTid] = debug; +#endif // SURFEL_COVERAGE_HALFRES +} + +groupshared uint GroupMinSurfelCount; + +[numthreads(16, 16, 1)] +void main(uint3 DTid : SV_DispatchThreadID, uint groupIndex : SV_GroupIndex, uint3 Gid : SV_GroupID, uint3 GTid : SV_GroupThreadID) +{ + if (groupIndex == 0) + { + GroupMinSurfelCount = ~0; + } + GroupMemoryBarrierWithGroupSync(); + +#ifdef SURFEL_COVERAGE_HALFRES + uint2 pixel = DTid.xy * 2 + GetTemporalAASampleRotation(); +#else + uint2 pixel = DTid.xy; +#endif // SURFEL_COVERAGE_HALFRES + + const float depth = texture_depth[pixel]; + if (depth == 0) + { + write_debug(DTid.xy, 0); + return; + } + + float4 debug = 0; + float4 color = 0; + + const float2 uv = ((float2)pixel + 0.5) * g_xFrame.InternalResolution_rcp; + const float3 P = reconstructPosition(uv, depth); + + uint2 primitiveID = texture_gbuffer0[pixel]; + + PrimitiveID prim; + prim.unpack(primitiveID); + + Surface surface; + if (!surface.load(prim, P)) + { + return; + } + + const float3 N = surface.facenormal; + + float coverage = 0; + + int3 gridpos = surfel_cell(P); + if (!surfel_cellvalid(gridpos)) + { + write_debug(DTid.xy, 0); + return; + } + + uint cellindex = surfel_cellindex(gridpos); + SurfelGridCell cell = surfelGridBuffer[cellindex]; + for (uint i = 0; i < cell.count; ++i) + { + uint surfel_index = surfelCellBuffer[cell.offset + i]; + Surfel surfel = surfelBuffer[surfel_index]; + + float3 L = surfel.position - P; + float dist2 = dot(L, L); + if (dist2 < sqr(surfel.radius)) + { + float3 normal = normalize(unpack_unitvector(surfel.normal)); + float dotN = dot(N, normal); + if (dotN > 0) + { + float dist = sqrt(dist2); + float contribution = 1; + + float2 moments = surfelMomentsTexture.SampleLevel(sampler_linear_clamp, surfel_moment_uv(surfel_index, normal, -L / dist), 0); + contribution *= surfel_moment_weight(moments, dist); + + + contribution *= saturate(dotN); + contribution *= saturate(1 - dist / surfel.radius); + contribution = smoothstep(0, 1, contribution); + coverage += contribution; + + color += float4(surfel.color, 1) * contribution; + +#ifdef SURFEL_DEBUG_NORMAL + debug.rgb += normal * contribution; + debug.a = 1; +#endif // SURFEL_DEBUG_NORMAL + +#ifdef SURFEL_DEBUG_RANDOM + debug += float4(random_color(surfel_index), 1) * contribution; +#endif // SURFEL_DEBUG_RANDOM + + } + +#ifdef SURFEL_DEBUG_POINT + if (dist2 <= sqr(0.05)) + debug = float4(1, 0, 1, 1); +#endif // SURFEL_DEBUG_POINT + } + + } + + if (cell.count < SURFEL_CELL_LIMIT) + { + uint surfel_count_at_pixel = 0; + surfel_count_at_pixel |= (uint(coverage) & 0xFF) << 8; + surfel_count_at_pixel |= (GTid.x & 0xF) << 4; + surfel_count_at_pixel |= (GTid.y & 0xF) << 0; + InterlockedMin(GroupMinSurfelCount, surfel_count_at_pixel); + } + + if (color.a > 0) + { + color.rgb /= color.a; + color.a = saturate(color.a); + } + +#ifdef SURFEL_DEBUG_NORMAL + debug.rgb = normalize(debug.rgb) * 0.5 + 0.5; +#endif // SURFEL_DEBUG_NORMAL + +#ifdef SURFEL_DEBUG_COLOR + debug = color; + debug.rgb = tonemap(debug.rgb); +#endif // SURFEL_DEBUG_COLOR + +#if defined(SURFEL_DEBUG_RANDOM) + if (debug.a > 0) + { + debug /= debug.a; + } + else + { + debug = 0; + } +#endif // SURFEL_DEBUG_RANDOM + +#ifdef SURFEL_DEBUG_HEATMAP + const float3 mapTex[] = { + float3(0,0,0), + float3(0,0,1), + float3(0,1,1), + float3(0,1,0), + float3(1,1,0), + float3(1,0,0), + }; + const uint mapTexLen = 5; + const uint maxHeat = 50; + float l = saturate((float)cell.count / maxHeat) * mapTexLen; + float3 a = mapTex[floor(l)]; + float3 b = mapTex[ceil(l)]; + float4 heatmap = float4(lerp(a, b, l - floor(l)), 0.8); + debug = heatmap; +#endif // SURFEL_DEBUG_HEATMAP + + + GroupMemoryBarrierWithGroupSync(); + + uint surfel_coverage = GroupMinSurfelCount; + uint2 minGTid; + minGTid.x = (surfel_coverage >> 4) & 0xF; + minGTid.y = (surfel_coverage >> 0) & 0xF; + uint coverage_amount = surfel_coverage >> 8; + if (GTid.x == minGTid.x && GTid.y == minGTid.y && coverage < SURFEL_TARGET_COVERAGE) + { + // Slow down the propagation by chance + // Closer surfaces have less chance to avoid excessive clumping of surfels + const float lineardepth = getLinearDepth(depth) * g_xCamera.ZFarP_rcp; +#ifdef SURFEL_COVERAGE_HALFRES + const float chance = pow(1 - lineardepth, 8); +#else + const float chance = pow(1 - lineardepth, 4); +#endif // SURFEL_COVERAGE_HALFRES + if (blue_noise(Gid.xy).x < chance) + return; + + uint surfel_alloc; + surfelStatsBuffer.InterlockedAdd(SURFEL_STATS_OFFSET_COUNT, 1, surfel_alloc); + if (surfel_alloc < SURFEL_CAPACITY) + { + SurfelData surfel_data = (SurfelData)0; + surfel_data.primitiveID = primitiveID; + surfel_data.bary = pack_half2(surface.bary.xy); + surfel_data.uid = surface.inst.uid; + surfel_data.inconsistency = 1; + surfelDataBuffer[surfel_alloc] = surfel_data; + } + } + + write_result(DTid.xy, color); + write_debug(DTid.xy, debug); +} diff --git a/WickedEngine/shaders/surfel_gridoffsetsCS.hlsl b/WickedEngine/shaders/surfel_gridoffsetsCS.hlsl new file mode 100644 index 000000000..ed2bbaa1c --- /dev/null +++ b/WickedEngine/shaders/surfel_gridoffsetsCS.hlsl @@ -0,0 +1,15 @@ +#include "globals.hlsli" +#include "ShaderInterop_SurfelGI.h" + +RWSTRUCTUREDBUFFER(surfelGridBuffer, SurfelGridCell, 0); +RWSTRUCTUREDBUFFER(surfelCellBuffer, uint, 1); +RWRAWBUFFER(surfelStatsBuffer, 2); + +[numthreads(64, 1, 1)] +void main(uint3 DTid : SV_DispatchThreadID) +{ + SurfelGridCell cell = surfelGridBuffer[DTid.x]; + surfelStatsBuffer.InterlockedAdd(SURFEL_STATS_OFFSET_CELLALLOCATOR, cell.count, cell.offset); + cell.count = 0; + surfelGridBuffer[DTid.x] = cell; +} diff --git a/WickedEngine/shaders/surfel_gridresetCS.hlsl b/WickedEngine/shaders/surfel_gridresetCS.hlsl new file mode 100644 index 000000000..d68f45fa3 --- /dev/null +++ b/WickedEngine/shaders/surfel_gridresetCS.hlsl @@ -0,0 +1,10 @@ +#include "globals.hlsli" +#include "ShaderInterop_SurfelGI.h" + +RWSTRUCTUREDBUFFER(surfelGridBuffer, SurfelGridCell, 0); + +[numthreads(64, 1, 1)] +void main(uint3 DTid : SV_DispatchThreadID) +{ + surfelGridBuffer[DTid.x].count = 0; +} diff --git a/WickedEngine/shaders/surfel_indirectprepareCS.hlsl b/WickedEngine/shaders/surfel_indirectprepareCS.hlsl new file mode 100644 index 000000000..9973c197f --- /dev/null +++ b/WickedEngine/shaders/surfel_indirectprepareCS.hlsl @@ -0,0 +1,15 @@ +#include "globals.hlsli" +#include "ShaderInterop_SurfelGI.h" + +RWRAWBUFFER(surfelStatsBuffer, 0); + +[numthreads(1, 1, 1)] +void main(uint3 DTid : SV_DispatchThreadID) +{ + uint surfel_count = surfelStatsBuffer.Load(SURFEL_STATS_OFFSET_COUNT); + surfel_count = min(surfel_count, SURFEL_CAPACITY); + surfelStatsBuffer.Store(SURFEL_STATS_OFFSET_COUNT, surfel_count); + surfelStatsBuffer.Store(SURFEL_STATS_OFFSET_CELLALLOCATOR, 0); + + surfelStatsBuffer.Store3(SURFEL_STATS_OFFSET_INDIRECT, uint3((surfel_count + SURFEL_INDIRECT_NUMTHREADS - 1) / SURFEL_INDIRECT_NUMTHREADS, 1, 1)); +} diff --git a/WickedEngine/shaders/surfel_raytraceCS.hlsl b/WickedEngine/shaders/surfel_raytraceCS.hlsl new file mode 100644 index 000000000..58b57ae54 --- /dev/null +++ b/WickedEngine/shaders/surfel_raytraceCS.hlsl @@ -0,0 +1,322 @@ +#include "globals.hlsli" +#include "raytracingHF.hlsli" +#include "lightingHF.hlsli" +#include "ShaderInterop_SurfelGI.h" + + +STRUCTUREDBUFFER(surfelBuffer, Surfel, TEXSLOT_ONDEMAND0); +RAWBUFFER(surfelStatsBuffer, TEXSLOT_ONDEMAND1); +STRUCTUREDBUFFER(surfelGridBuffer, SurfelGridCell, TEXSLOT_ONDEMAND2); +STRUCTUREDBUFFER(surfelCellBuffer, uint, TEXSLOT_ONDEMAND3); + +RWSTRUCTUREDBUFFER(surfelDataBuffer, SurfelData, 0); +RWTEXTURE2D(surfelMomentsTexture, float2, 1); + +void surfel_moments_write(uint2 moments_pixel, float dist) +{ + float2 prev = surfelMomentsTexture[moments_pixel]; + float2 blend = prev.x < dist ? 0.005 : 0.5; + surfelMomentsTexture[moments_pixel] = lerp(prev, float2(dist, sqr(dist)), blend); +} + +[numthreads(SURFEL_INDIRECT_NUMTHREADS, 1, 1)] +void main(uint3 DTid : SV_DispatchThreadID) +{ + uint surfel_count = surfelStatsBuffer.Load(SURFEL_STATS_OFFSET_COUNT); + if (DTid.x >= surfel_count) + return; + + uint surfel_index = DTid.x; + Surfel surfel = surfelBuffer[surfel_index]; + SurfelData surfel_data = surfelDataBuffer[surfel_index]; + + if (surfel_data.life == 0) + { + uint2 moments_pixel = unflatten2D(surfel_index, SQRT_SURFEL_CAPACITY) * SURFEL_MOMENT_TEXELS; + for (int i = 0; i < SURFEL_MOMENT_TEXELS; ++i) + { + for (int j = 0; j < SURFEL_MOMENT_TEXELS; ++j) + { + uint2 pixel_write = moments_pixel + uint2(i, j); + surfelMomentsTexture[pixel_write] = float2(surfel.radius, sqr(surfel.radius)); + } + } + } + + const float3 N = normalize(unpack_unitvector(surfel.normal)); + + float seed = 0.123456; + float2 uv = float2(frac(g_xFrame.FrameCount.x / 4096.0), (float)surfel_index / SURFEL_CAPACITY); + + RayDesc ray; + ray.Origin = surfel.position; + ray.TMin = 0.001; + ray.TMax = FLT_MAX; + ray.Direction = normalize(SampleHemisphere_cos(N, seed, uv)); + + uint2 moments_pixel = surfel_moment_pixel(surfel_index, N, ray.Direction); + float moment_blend = 0.5; + + float3 result = 0; + float3 energy = 1; + + +#ifdef RTAPI + RayQuery< + RAY_FLAG_SKIP_PROCEDURAL_PRIMITIVES | + RAY_FLAG_FORCE_OPAQUE + > q; + q.TraceRayInline( + scene_acceleration_structure, // RaytracingAccelerationStructure AccelerationStructure + 0, // uint RayFlags + 0xFF, // uint InstanceInclusionMask + ray // RayDesc Ray + ); + q.Proceed(); + if (q.CommittedStatus() != COMMITTED_TRIANGLE_HIT) +#else + RayHit hit = TraceRay_Closest(ray); + + if (hit.distance >= FLT_MAX - 1) +#endif // RTAPI + + { + surfel_data.hitpos = 0; + surfel_data.hitnormal = ~0; + + surfel_moments_write(moments_pixel, surfel.radius); + + float3 envColor; + [branch] + if (IsStaticSky()) + { + // We have envmap information in a texture: + envColor = DEGAMMA_SKY(texture_globalenvmap.SampleLevel(sampler_linear_clamp, ray.Direction, 0).rgb); + } + else + { + envColor = GetDynamicSkyColor(ray.Direction, true, true, false, true); + } + result += max(0, energy * envColor); + + // Erase the ray's energy + energy = 0; + } + + Surface surface; + + float hit_depth = 0; + +#ifdef RTAPI + + // ray origin updated for next bounce: + ray.Origin = q.WorldRayOrigin() + q.WorldRayDirection() * q.CommittedRayT(); + hit_depth = q.CommittedRayT(); + + PrimitiveID prim; + prim.primitiveIndex = q.CommittedPrimitiveIndex(); + prim.instanceIndex = q.CommittedInstanceID(); + prim.subsetIndex = q.CommittedGeometryIndex(); + + surface.load(prim, q.CommittedTriangleBarycentrics()); + +#else + + // ray origin updated for next bounce: + ray.Origin = ray.Origin + ray.Direction * hit.distance; + hit_depth = hit.distance; + + surface.load(hit.primitiveID, hit.bary); + +#endif // RTAPI + + hit_depth = min(hit_depth, surfel.radius); + surfel_moments_write(moments_pixel, hit_depth); + + surface.P = ray.Origin; + surface.V = -ray.Direction; + surface.update(); + + result += max(0, energy * surface.emissiveColor.rgb * surface.emissiveColor.a); + + // Calculate chances of reflection types: + const float specChance = dot(surface.F, 0.333f); + + float roulette = rand(seed, uv); + if (roulette < specChance) + { + // Specular reflection + const float3 R = reflect(ray.Direction, surface.N); + ray.Direction = lerp(R, SampleHemisphere_cos(R, seed, uv), surface.roughnessBRDF); + energy *= surface.F / specChance; + } + else + { + // Diffuse reflection + ray.Direction = SampleHemisphere_cos(surface.N, seed, uv); + energy *= surface.albedo / (1 - specChance); + } + + + + + + + + +#if 1 + // Light sampling: + [loop] + for (uint iterator = 0; iterator < g_xFrame.LightArrayCount; iterator++) + { + ShaderEntity light = EntityArray[g_xFrame.LightArrayOffset + iterator]; + + Lighting lighting; + lighting.create(0, 0, 0, 0); + + float3 L = 0; + float dist = 0; + float NdotL = 0; + + switch (light.GetType()) + { + case ENTITY_TYPE_DIRECTIONALLIGHT: + { + dist = FLT_MAX; + + L = light.GetDirection().xyz; + NdotL = saturate(dot(L, surface.N)); + + [branch] + if (NdotL > 0) + { + float3 atmosphereTransmittance = 1.0; + if (g_xFrame.Options & OPTION_BIT_REALISTIC_SKY) + { + atmosphereTransmittance = GetAtmosphericLightTransmittance(g_xFrame.Atmosphere, surface.P, L, texture_transmittancelut); + } + + float3 lightColor = light.GetColor().rgb * light.GetEnergy() * atmosphereTransmittance; + + lighting.direct.diffuse = lightColor; + } + } + break; + case ENTITY_TYPE_POINTLIGHT: + { + L = light.position - surface.P; + const float dist2 = dot(L, L); + const float range2 = light.GetRange() * light.GetRange(); + + [branch] + if (dist2 < range2) + { + dist = sqrt(dist2); + L /= dist; + NdotL = saturate(dot(L, surface.N)); + + [branch] + if (NdotL > 0) + { + const float3 lightColor = light.GetColor().rgb * light.GetEnergy(); + + lighting.direct.diffuse = lightColor; + + const float range2 = light.GetRange() * light.GetRange(); + const float att = saturate(1.0 - (dist2 / range2)); + const float attenuation = att * att; + + lighting.direct.diffuse *= attenuation; + } + } + } + break; + case ENTITY_TYPE_SPOTLIGHT: + { + L = light.position - surface.P; + const float dist2 = dot(L, L); + const float range2 = light.GetRange() * light.GetRange(); + + [branch] + if (dist2 < range2) + { + dist = sqrt(dist2); + L /= dist; + NdotL = saturate(dot(L, surface.N)); + + [branch] + if (NdotL > 0) + { + const float SpotFactor = dot(L, light.GetDirection()); + const float spotCutOff = light.GetConeAngleCos(); + + [branch] + if (SpotFactor > spotCutOff) + { + const float3 lightColor = light.GetColor().rgb * light.GetEnergy(); + + lighting.direct.diffuse = lightColor; + + const float range2 = light.GetRange() * light.GetRange(); + const float att = saturate(1.0 - (dist2 / range2)); + float attenuation = att * att; + attenuation *= saturate((1.0 - (1.0 - SpotFactor) * 1.0 / (1.0 - spotCutOff))); + + lighting.direct.diffuse *= attenuation; + } + } + } + } + break; + } + + if (NdotL > 0 && dist > 0) + { + float3 shadow = NdotL * energy; + + RayDesc newRay; + newRay.Origin = surface.P; + newRay.Direction = normalize(lerp(L, SampleHemisphere_cos(L, seed, uv), 0.025f)); + newRay.TMin = 0.001; + newRay.TMax = dist; +#ifdef RTAPI + q.TraceRayInline( + scene_acceleration_structure, // RaytracingAccelerationStructure AccelerationStructure + RAY_FLAG_ACCEPT_FIRST_HIT_AND_END_SEARCH, // uint RayFlags + 0xFF, // uint InstanceInclusionMask + newRay // RayDesc Ray + ); + q.Proceed(); + shadow = q.CommittedStatus() == COMMITTED_TRIANGLE_HIT ? 0 : shadow; +#else + shadow = TraceRay_Any(newRay) ? 0 : shadow; +#endif // RTAPI + if (any(shadow)) + { + result += max(0, shadow * lighting.direct.diffuse / PI); + } + } + } + +#endif + + + uint2 moments_topleft = unflatten2D(surfel_index, SQRT_SURFEL_CAPACITY) * SURFEL_MOMENT_TEXELS; + for (uint i = 0; i < SURFEL_MOMENT_TEXELS; ++i) + { + for (uint j = 0; j < SURFEL_MOMENT_TEXELS; ++j) + { + uint2 pixel_write = moments_topleft + uint2(i, j); + uint2 pixel_read = clamp(pixel_write, moments_topleft + 1, moments_topleft + SURFEL_MOMENT_TEXELS - 2); + surfelMomentsTexture[pixel_write] = surfelMomentsTexture[pixel_read]; + } + } + + surfel_data.hitpos = surface.P; + surfel_data.hitnormal = pack_unitvector(surface.facenormal); + surfel_data.hitenergy = energy; + surfel_data.traceresult = result; + + surfel_data.life++; + surfelDataBuffer[surfel_index] = surfel_data; +} diff --git a/WickedEngine/shaders/surfel_raytraceCS_rtapi.hlsl b/WickedEngine/shaders/surfel_raytraceCS_rtapi.hlsl new file mode 100644 index 000000000..7485b7f52 --- /dev/null +++ b/WickedEngine/shaders/surfel_raytraceCS_rtapi.hlsl @@ -0,0 +1,2 @@ +#define RTAPI +#include "surfel_raytraceCS.hlsl" diff --git a/WickedEngine/shaders/surfel_shadeCS.hlsl b/WickedEngine/shaders/surfel_shadeCS.hlsl new file mode 100644 index 000000000..7c838abad --- /dev/null +++ b/WickedEngine/shaders/surfel_shadeCS.hlsl @@ -0,0 +1,180 @@ +#include "globals.hlsli" +#include "brdf.hlsli" +#include "ShaderInterop_SurfelGI.h" + + +void MultiscaleMeanEstimator( + float3 y, + inout SurfelData data, + float shortWindowBlend = 0.08f +) +{ + float3 mean = data.mean; + float3 shortMean = data.shortMean; + float vbbr = data.vbbr; + float3 variance = data.variance; + float inconsistency = data.inconsistency; + + // Suppress fireflies. + { + float3 dev = sqrt(max(1e-5, variance)); + float3 highThreshold = 0.1 + shortMean + dev * 8; + float3 overflow = max(0, y - highThreshold); + y -= overflow; + } + + float3 delta = y - shortMean; + shortMean = lerp(shortMean, y, shortWindowBlend); + float3 delta2 = y - shortMean; + + // This should be a longer window than shortWindowBlend to avoid bias + // from the variance getting smaller when the short-term mean does. + float varianceBlend = shortWindowBlend * 0.5; + variance = lerp(variance, delta * delta2, varianceBlend); + float3 dev = sqrt(max(1e-5, variance)); + + float3 shortDiff = mean - shortMean; + + float relativeDiff = dot(float3(0.299, 0.587, 0.114), + abs(shortDiff) / max(1e-5, dev)); + inconsistency = lerp(inconsistency, relativeDiff, 0.08); + + float varianceBasedBlendReduction = + clamp(dot(float3(0.299, 0.587, 0.114), + 0.5 * shortMean / max(1e-5, dev)), 1.0 / 32, 1); + + float3 catchUpBlend = clamp(smoothstep(0, 1, + relativeDiff * max(0.02, inconsistency - 0.2)), 1.0 / 256, 1); + catchUpBlend *= vbbr; + + vbbr = lerp(vbbr, varianceBasedBlendReduction, 0.1); + mean = lerp(mean, y, saturate(catchUpBlend)); + + // Output + data.mean = mean; + data.shortMean = shortMean; + data.vbbr = vbbr; + data.variance = variance; + data.inconsistency = inconsistency; +} + +STRUCTUREDBUFFER(surfelBuffer, Surfel, TEXSLOT_ONDEMAND0); +RAWBUFFER(surfelStatsBuffer, TEXSLOT_ONDEMAND1); +STRUCTUREDBUFFER(surfelGridBuffer, SurfelGridCell, TEXSLOT_ONDEMAND2); +STRUCTUREDBUFFER(surfelCellBuffer, uint, TEXSLOT_ONDEMAND3); +TEXTURE2D(surfelMomentsTexture, float2, TEXSLOT_ONDEMAND4); + +RWSTRUCTUREDBUFFER(surfelDataBuffer, SurfelData, 0); + +[numthreads(SURFEL_INDIRECT_NUMTHREADS, 1, 1)] +void main(uint3 DTid : SV_DispatchThreadID) +{ + uint surfel_count = surfelStatsBuffer.Load(SURFEL_STATS_OFFSET_COUNT); + if (DTid.x >= surfel_count) + return; + + uint surfel_index = DTid.x; + Surfel surfel = surfelBuffer[surfel_index]; + SurfelData surfel_data = surfelDataBuffer[surfel_index]; + + float4 result = float4(surfel_data.traceresult, 1); + +#if 1 + // Evaluate surfel cache at hit point for multi bounce: + { + Surface surface; + surface.P = surfel_data.hitpos; + surface.N = normalize(unpack_unitvector(surfel_data.hitnormal)); + + float4 surfel_gi = 0; + uint cellindex = surfel_cellindex(surfel_cell(surface.P)); + SurfelGridCell cell = surfelGridBuffer[cellindex]; + for (uint i = 0; i < cell.count; ++i) + { + uint surfel_index = surfelCellBuffer[cell.offset + i]; + Surfel surfel = surfelBuffer[surfel_index]; + + float3 L = surfel.position - surface.P; + float dist2 = dot(L, L); + if (dist2 < sqr(surfel.radius)) + { + float3 normal = normalize(unpack_unitvector(surfel.normal)); + float dotN = dot(surface.N, normal); + if (dotN > 0) + { + float dist = sqrt(dist2); + float contribution = 1; + + float2 moments = surfelMomentsTexture.SampleLevel(sampler_linear_clamp, surfel_moment_uv(surfel_index, normal, -L / dist), 0); + contribution *= surfel_moment_weight(moments, dist); + + contribution *= saturate(1 - dist / surfel.radius); + contribution = smoothstep(0, 1, contribution); + contribution *= saturate(dotN); + + surfel_gi += float4(surfel.color, 1) * contribution; + + } + } + } + if (surfel_gi.a > 0) + { + surfel_gi.rgb /= surfel_gi.a; + surfel_gi.a = saturate(surfel_gi.a); + result.rgb += max(0, surfel_data.hitenergy * surfel_gi.rgb); + } + } +#endif + + + + +#if 1 + // Surfel irradiance sharing: + { + Surface surface; + surface.P = surfel.position; + surface.N = normalize(unpack_unitvector(surfel.normal)); + float radius = surfel.radius; + + uint cellindex = surfel_cellindex(surfel_cell(surface.P)); + SurfelGridCell cell = surfelGridBuffer[cellindex]; + for (uint i = 0; i < cell.count; ++i) + { + uint surfel_index = surfelCellBuffer[cell.offset + i]; + Surfel surfel = surfelBuffer[surfel_index]; + surfel.radius += radius; + + float3 L = surfel.position - surface.P; + float dist2 = dot(L, L); + if (dist2 < sqr(surfel.radius)) + { + float3 normal = normalize(unpack_unitvector(surfel.normal)); + float dotN = dot(surface.N, normal); + if (dotN > 0) + { + float dist = sqrt(dist2); + float contribution = 1; + + float2 moments = surfelMomentsTexture.SampleLevel(sampler_linear_clamp, surfel_moment_uv(surfel_index, normal, -L / dist), 0); + contribution *= surfel_moment_weight(moments, dist); + + contribution *= saturate(1 - dist / surfel.radius); + contribution = smoothstep(0, 1, contribution); + contribution *= saturate(dotN); + + result += float4(surfel.color, 1) * contribution; + + } + } + } + } +#endif + + result /= result.a; + + + MultiscaleMeanEstimator(result.rgb, surfel_data, 0.08); + + surfelDataBuffer[surfel_index] = surfel_data; +} diff --git a/WickedEngine/shaders/surfel_updateCS.hlsl b/WickedEngine/shaders/surfel_updateCS.hlsl new file mode 100644 index 000000000..c1813dddd --- /dev/null +++ b/WickedEngine/shaders/surfel_updateCS.hlsl @@ -0,0 +1,52 @@ +#include "globals.hlsli" +#include "ShaderInterop_SurfelGI.h" +#include "brdf.hlsli" + +RAWBUFFER(surfelStatsBuffer, TEXSLOT_ONDEMAND0); +STRUCTUREDBUFFER(surfelDataBuffer, SurfelData, TEXSLOT_ONDEMAND1); + +RWSTRUCTUREDBUFFER(surfelBuffer, Surfel, 0); +RWSTRUCTUREDBUFFER(surfelGridBuffer, SurfelGridCell, 1); + +[numthreads(SURFEL_INDIRECT_NUMTHREADS, 1, 1)] +void main(uint3 DTid : SV_DispatchThreadID) +{ + uint surfel_count = surfelStatsBuffer.Load(SURFEL_STATS_OFFSET_COUNT); + if (DTid.x >= surfel_count) + return; + + uint surfel_index = DTid.x; + SurfelData surfel_data = surfelDataBuffer[surfel_index]; + Surfel surfel = surfelBuffer[surfel_index]; + + + PrimitiveID prim; + prim.unpack(surfel_data.primitiveID); + + Surface surface; + if (surface.load(prim, unpack_half2(surfel_data.bary), surfel_data.uid)) + { + surfel.normal = pack_unitvector(surface.facenormal); + surfel.position = surface.P; + surfel.color = surfel_data.mean; + surfel.radius = SURFEL_MAX_RADIUS; + + int3 center_cell = surfel_cell(surfel.position); + for (uint i = 0; i < 27; ++i) + { + int3 gridpos = center_cell + surfel_neighbor_offsets[i]; + + if(surfel_cellintersects(surfel, gridpos)) + { + uint cellindex = surfel_cellindex(gridpos); + InterlockedAdd(surfelGridBuffer[cellindex].count, 1); + } + } + } + else + { + surfel.radius = 0; + } + + surfelBuffer[surfel_index] = surfel; +} diff --git a/WickedEngine/shaders/temporalaaCS.hlsl b/WickedEngine/shaders/temporalaaCS.hlsl index d8453f072..630e065bf 100644 --- a/WickedEngine/shaders/temporalaaCS.hlsl +++ b/WickedEngine/shaders/temporalaaCS.hlsl @@ -66,7 +66,7 @@ void main(uint3 DTid : SV_DispatchThreadID, uint3 GTid : SV_GroupThreadID, uint3 } } } - const float2 velocity = texture_gbuffer2[DTid.xy + bestOffset].xy; + const float2 velocity = texture_gbuffer1[DTid.xy + bestOffset].xy; #else @@ -94,7 +94,7 @@ void main(uint3 DTid : SV_DispatchThreadID, uint3 GTid : SV_GroupThreadID, uint3 } } } - const float2 velocity = texture_gbuffer2[bestPixel].xy; + const float2 velocity = texture_gbuffer1[bestPixel].xy; #endif // USE_LDS @@ -102,7 +102,7 @@ void main(uint3 DTid : SV_DispatchThreadID, uint3 GTid : SV_GroupThreadID, uint3 #if 0 // Disocclusion fallback: - float depth_current = texture_lineardepth[DTid.xy] * g_xCamera_ZFarP; + float depth_current = texture_lineardepth[DTid.xy] * g_xCamera.ZFarP; float depth_history = getLinearDepth(texture_depth_history.SampleLevel(sampler_point_clamp, prevUV, 0)); if (length(velocity) > 0.01 && abs(depth_current - depth_history) > 1) { @@ -119,7 +119,7 @@ void main(uint3 DTid : SV_DispatchThreadID, uint3 GTid : SV_GroupThreadID, uint3 history.rgb = clamp(history.rgb, neighborhoodMin, neighborhoodMax); // the linear filtering can cause blurry image, try to account for that: - float subpixelCorrection = frac(max(abs(velocity.x)*g_xFrame_InternalResolution.x, abs(velocity.y)*g_xFrame_InternalResolution.y)) * 0.5f; + float subpixelCorrection = frac(max(abs(velocity.x)*g_xFrame.InternalResolution.x, abs(velocity.y)*g_xFrame.InternalResolution.y)) * 0.5f; // compute a nice blend factor: float blendfactor = saturate(lerp(0.05f, 0.8f, subpixelCorrection)); diff --git a/WickedEngine/shaders/tileFrustumsCS.hlsl b/WickedEngine/shaders/tileFrustumsCS.hlsl index 7a9adc66c..c7adbb8f5 100644 --- a/WickedEngine/shaders/tileFrustumsCS.hlsl +++ b/WickedEngine/shaders/tileFrustumsCS.hlsl @@ -46,8 +46,8 @@ void main(uint3 DTid : SV_DispatchThreadID) frustum.planes[3] = ComputePlane(viewSpace[3], eyePos, viewSpace[2]); // Store the computed frustum in global memory (if our thread ID is in bounds of the grid). - if (DTid.x < g_xFrame_EntityCullingTileCount.x && DTid.y < g_xFrame_EntityCullingTileCount.y) + if (DTid.x < g_xFrame.EntityCullingTileCount.x && DTid.y < g_xFrame.EntityCullingTileCount.y) { - out_Frustums[flatten2D(DTid.xy, g_xFrame_EntityCullingTileCount.xy)] = frustum; + out_Frustums[flatten2D(DTid.xy, g_xFrame.EntityCullingTileCount.xy)] = frustum; } } diff --git a/WickedEngine/shaders/tonemapCS.hlsl b/WickedEngine/shaders/tonemapCS.hlsl index bcd92580f..3d71a1223 100644 --- a/WickedEngine/shaders/tonemapCS.hlsl +++ b/WickedEngine/shaders/tonemapCS.hlsl @@ -1,19 +1,7 @@ #include "globals.hlsli" #include "ShaderInterop_Postprocess.h" -#ifdef BINDLESS PUSHCONSTANT(push, PushConstantsTonemap); -Texture2D bindless_textures[] : register(t0, space1); -Texture3D bindless_textures3D[] : register(t0, space2); -RWTexture2D bindless_rwtextures[] : register(u0, space3); -#else -TEXTURE2D(input, float4, TEXSLOT_ONDEMAND0); -TEXTURE2D(input_luminance, float, TEXSLOT_ONDEMAND1); -TEXTURE2D(input_distortion, float4, TEXSLOT_ONDEMAND2); -TEXTURE3D(colorgrade_lookuptable, float4, TEXSLOT_ONDEMAND3); - -RWTEXTURE2D(output, unorm float4, 0); -#endif // BINDLESS // https://github.com/TheRealMJP/BakingLab/blob/master/BakingLab/ACES.hlsl // sRGB => XYZ => D65_2_D60 => AP1 => RRT_SAT @@ -57,7 +45,6 @@ float3 ACESFitted(float3 color) [numthreads(POSTPROCESS_BLOCKSIZE, POSTPROCESS_BLOCKSIZE, 1)] void main(uint3 DTid : SV_DispatchThreadID) { -#ifdef BINDLESS const float2 uv = (DTid.xy + 0.5f) * push.xPPResolution_rcp; float exposure = push.exposure; const bool is_dither = push.dither != 0; @@ -79,29 +66,6 @@ void main(uint3 DTid : SV_DispatchThreadID) { exposure *= push.eyeadaptionkey / max(bindless_textures[push.texture_input_luminance][uint2(0, 0)].r, 0.0001); } -#else - const float2 uv = (DTid.xy + 0.5f) * xPPResolution_rcp; - float exposure = tonemap_exposure; - const bool is_dither = tonemap_dither != 0; - const bool is_colorgrading = tonemap_colorgrading != 0; - const bool is_eyeadaption = tonemap_eyeadaption != 0; - const bool is_distortion = tonemap_distortion != 0; - - float2 distortion = 0; - [branch] - if (is_distortion) - { - distortion = input_distortion.SampleLevel(sampler_linear_clamp, uv, 0).rg; - } - - float4 hdr = input.SampleLevel(sampler_linear_clamp, uv + distortion, 0); - - [branch] - if (is_eyeadaption) - { - exposure *= tonemap_eyeadaptionkey / max(input_luminance[uint2(0, 0)].r, 0.0001); - } -#endif // BINDLESS hdr.rgb *= exposure; float4 ldr = float4(ACESFitted(hdr.rgb), hdr.a); @@ -116,11 +80,7 @@ void main(uint3 DTid : SV_DispatchThreadID) if (is_colorgrading) { -#ifdef BINDLESS ldr.rgb = bindless_textures3D[push.texture_colorgrade_lookuptable].SampleLevel(sampler_linear_clamp, ldr.rgb, 0).rgb; -#else - ldr.rgb = colorgrade_lookuptable.SampleLevel(sampler_linear_clamp, ldr.rgb, 0).rgb; -#endif // BINDLESS } if (is_dither) @@ -129,9 +89,5 @@ void main(uint3 DTid : SV_DispatchThreadID) ldr.rgb += (dither((float2)DTid.xy) - 0.5f) / 64.0f; } -#ifdef BINDLESS bindless_rwtextures[push.texture_output][DTid.xy] = ldr; -#else - output[DTid.xy] = ldr; -#endif // BINDLESS } diff --git a/WickedEngine/shaders/upsample_bilateral_float4CS.hlsl b/WickedEngine/shaders/upsample_bilateral_float4CS.hlsl index 0b7c388fe..4f6ba4431 100644 --- a/WickedEngine/shaders/upsample_bilateral_float4CS.hlsl +++ b/WickedEngine/shaders/upsample_bilateral_float4CS.hlsl @@ -43,7 +43,7 @@ void main(uint3 DTid : SV_DispatchThreadID) texture_lineardepth.SampleLevel(sampler_point_clamp, uv11, lowres_depthchain_mip) ); - const float4 depth_diff = abs(lineardepth_highres - lineardepth_lowres) * g_xCamera_ZFarP; + const float4 depth_diff = abs(lineardepth_highres - lineardepth_lowres) * g_xCamera.ZFarP; const float accum_diff = dot(depth_diff, float4(1, 1, 1, 1)); UPSAMPLE_FORMAT color; diff --git a/WickedEngine/shaders/vPointLightVS.hlsl b/WickedEngine/shaders/vPointLightVS.hlsl index 75f89db2f..324c7e5b4 100644 --- a/WickedEngine/shaders/vPointLightVS.hlsl +++ b/WickedEngine/shaders/vPointLightVS.hlsl @@ -7,7 +7,7 @@ VertexToPixel main(uint vID : SV_VertexID) float4 pos = CIRCLE[vID]; pos = mul(lightWorld, pos); - Out.pos = mul(g_xCamera_VP, pos); + Out.pos = mul(g_xCamera.VP, pos); Out.col = lerp( float4(lightColor.rgb, 1), float4(0, 0, 0, 0), distance(pos.xyz, float3(lightWorld._14, lightWorld._24, lightWorld._34)) / (lightEnerdis.w) diff --git a/WickedEngine/shaders/vSpotLightVS.hlsl b/WickedEngine/shaders/vSpotLightVS.hlsl index 2ad338e21..554827fc1 100644 --- a/WickedEngine/shaders/vSpotLightVS.hlsl +++ b/WickedEngine/shaders/vSpotLightVS.hlsl @@ -7,7 +7,7 @@ VertexToPixel main(uint vID : SV_VertexID) float4 pos = CONE[vID]; pos = mul(lightWorld, pos); - Out.pos = mul(g_xCamera_VP, pos); + Out.pos = mul(g_xCamera.VP, pos); Out.col = lerp( float4(lightColor.rgb, 1), float4(0, 0, 0, 0), distance(pos.xyz, float3(lightWorld._14, lightWorld._24, lightWorld._34)) / (lightEnerdis.w) diff --git a/WickedEngine/shaders/visibility_resolveCS.hlsl b/WickedEngine/shaders/visibility_resolveCS.hlsl new file mode 100644 index 000000000..b56060468 --- /dev/null +++ b/WickedEngine/shaders/visibility_resolveCS.hlsl @@ -0,0 +1,97 @@ +#include "globals.hlsli" +#include "ShaderInterop_Renderer.h" +#include "brdf.hlsli" + +RWTEXTURE2D(output_velocity, float2, 0); + +RWTEXTURE2D(output_depth_mip0, float, 1); +RWTEXTURE2D(output_depth_mip1, float, 2); +RWTEXTURE2D(output_depth_mip2, float, 3); +RWTEXTURE2D(output_depth_mip3, float, 4); +RWTEXTURE2D(output_depth_mip4, float, 5); + +RWTEXTURE2D(output_lineardepth_mip0, float, 6); +RWTEXTURE2D(output_lineardepth_mip1, float, 7); +RWTEXTURE2D(output_lineardepth_mip2, float, 8); +RWTEXTURE2D(output_lineardepth_mip3, float, 9); +RWTEXTURE2D(output_lineardepth_mip4, float, 10); + +#ifdef VISIBILITY_MSAA +TEXTURE2DMS(texture_primitiveID, uint2, TEXSLOT_ONDEMAND0); +TEXTURE2DMS(texture_depthbuffer, float, TEXSLOT_ONDEMAND1); +RWTEXTURE2D(output_primitiveID, uint2, 11); +#else +TEXTURE2D(texture_primitiveID, uint2, TEXSLOT_ONDEMAND0); +TEXTURE2D(texture_depthbuffer, float, TEXSLOT_ONDEMAND1); +#endif // VISIBILITY_MSAA + +[numthreads(16, 16, 1)] +void main(uint3 DTid : SV_DispatchThreadID, uint groupIndex : SV_GroupIndex, uint3 Gid : SV_GroupID, uint3 GTid : SV_GroupThreadID) +{ + uint2 pixel = DTid.xy; + + const float2 uv = ((float2)pixel + 0.5) * g_xFrame.InternalResolution_rcp; + const float depth = texture_depthbuffer[pixel]; + const float3 P = reconstructPosition(uv, depth); + + float3 pre = P; + + if (depth > 0) + { + uint2 primitiveID = texture_primitiveID[pixel]; + +#ifdef VISIBILITY_MSAA + output_primitiveID[pixel] = primitiveID; +#endif // VISIBILITY_MSAA + + PrimitiveID prim; + prim.unpack(primitiveID); + + Surface surface; + if (surface.load(prim, P)) + { + pre = surface.pre; + } + + } + + float4 pos2DPrev = mul(g_xCamera.PrevVP, float4(pre, 1)); + pos2DPrev.xy /= pos2DPrev.w; + float2 pos2D = uv * 2 - 1; + pos2D.y *= -1; + float2 velocity = ((pos2DPrev.xy - g_xCamera.TemporalAAJitterPrev) - (pos2D.xy - g_xCamera.TemporalAAJitter)) * float2(0.5, -0.5); + + output_velocity[pixel] = velocity; + + + + // Downsample depths: + output_depth_mip0[pixel] = depth; + float lineardepth = getLinearDepth(depth) * g_xCamera.ZFarP_rcp; + output_lineardepth_mip0[pixel] = lineardepth; + + if (GTid.x % 2 == 0 && GTid.y % 2 == 0) + { + output_depth_mip1[pixel / 2] = depth; + output_lineardepth_mip1[pixel / 2] = lineardepth; + } + + if (GTid.x % 4 == 0 && GTid.y % 4 == 0) + { + output_depth_mip2[pixel / 4] = depth; + output_lineardepth_mip2[pixel / 4] = lineardepth; + } + + if (GTid.x % 8 == 0 && GTid.y % 8 == 0) + { + output_depth_mip3[pixel / 8] = depth; + output_lineardepth_mip3[pixel / 8] = lineardepth; + } + + if (GTid.x % 16 == 0 && GTid.y % 16 == 0) + { + output_depth_mip4[pixel / 16] = depth; + output_lineardepth_mip4[pixel / 16] = lineardepth; + } + +} diff --git a/WickedEngine/shaders/visibility_resolveCS_MSAA.hlsl b/WickedEngine/shaders/visibility_resolveCS_MSAA.hlsl new file mode 100644 index 000000000..bcff67e88 --- /dev/null +++ b/WickedEngine/shaders/visibility_resolveCS_MSAA.hlsl @@ -0,0 +1,2 @@ +#define VISIBILITY_MSAA +#include "visibility_resolveCS.hlsl" diff --git a/WickedEngine/shaders/volumetricCloud_renderCS.hlsl b/WickedEngine/shaders/volumetricCloud_renderCS.hlsl index 374247d07..1bff47ffd 100644 --- a/WickedEngine/shaders/volumetricCloud_renderCS.hlsl +++ b/WickedEngine/shaders/volumetricCloud_renderCS.hlsl @@ -44,7 +44,7 @@ float GetHeightFractionForPoint(AtmosphereParameters atmosphere, float3 pos) float planetRadius = atmosphere.bottomRadius * SKY_UNIT_TO_M; float3 planetCenterWorld = atmosphere.planetCenter * SKY_UNIT_TO_M; - return saturate((distance(pos, planetCenterWorld) - (planetRadius + g_xFrame_VolumetricClouds.CloudStartHeight)) / g_xFrame_VolumetricClouds.CloudThickness); + return saturate((distance(pos, planetCenterWorld) - (planetRadius + g_xFrame.VolumetricClouds.CloudStartHeight)) / g_xFrame.VolumetricClouds.CloudThickness); } float SampleGradient(float4 gradient, float heightFraction) @@ -60,21 +60,21 @@ float GetDensityHeightGradient(float heightFraction, float3 weatherData) float mediumType = 1.0f - abs(cloudType - 0.5f) * 2.0f; float largeType = saturate(cloudType - 0.5f) * 2.0f; - float4 cloudGradient = (g_xFrame_VolumetricClouds.CloudGradientSmall * smallType) + (g_xFrame_VolumetricClouds.CloudGradientMedium * mediumType) + (g_xFrame_VolumetricClouds.CloudGradientLarge * largeType); + float4 cloudGradient = (g_xFrame.VolumetricClouds.CloudGradientSmall * smallType) + (g_xFrame.VolumetricClouds.CloudGradientMedium * mediumType) + (g_xFrame.VolumetricClouds.CloudGradientLarge * largeType); return SampleGradient(cloudGradient, heightFraction); } float3 SampleWeather(float3 pos, float heightFraction, float2 coverageWindOffset) { - float4 weatherData = texture_weatherMap.SampleLevel(sampler_linear_wrap, (pos.xz + coverageWindOffset) * g_xFrame_VolumetricClouds.WeatherScale * 0.0004, 0); + float4 weatherData = texture_weatherMap.SampleLevel(sampler_linear_wrap, (pos.xz + coverageWindOffset) * g_xFrame.VolumetricClouds.WeatherScale * 0.0004, 0); // Anvil clouds - weatherData.r = pow(abs(weatherData.r), RemapClamped(heightFraction * g_xFrame_VolumetricClouds.AnvilOverhangHeight, 0.7, 0.8, 1.0, lerp(1.0, 0.5, g_xFrame_VolumetricClouds.AnvilAmount))); + weatherData.r = pow(abs(weatherData.r), RemapClamped(heightFraction * g_xFrame.VolumetricClouds.AnvilOverhangHeight, 0.7, 0.8, 1.0, lerp(1.0, 0.5, g_xFrame.VolumetricClouds.AnvilAmount))); //weatherData.r *= lerp(1, RemapClamped(pow(heightFraction * xPPDebugParams.y, 0.5), 0.4, 0.95, 1.0, 0.2), xPPDebugParams.x); // Apply effects for coverage - weatherData.r = RemapClamped(weatherData.r * g_xFrame_VolumetricClouds.CoverageAmount, 0.0, 1.0, saturate(g_xFrame_VolumetricClouds.CoverageMinimum - 1.0), 1.0); - weatherData.g = RemapClamped(weatherData.g * g_xFrame_VolumetricClouds.TypeAmount, 0.0, 1.0, g_xFrame_VolumetricClouds.TypeOverall, 1.0); + weatherData.r = RemapClamped(weatherData.r * g_xFrame.VolumetricClouds.CoverageAmount, 0.0, 1.0, saturate(g_xFrame.VolumetricClouds.CoverageMinimum - 1.0), 1.0); + weatherData.g = RemapClamped(weatherData.g * g_xFrame.VolumetricClouds.TypeAmount, 0.0, 1.0, g_xFrame.VolumetricClouds.TypeOverall, 1.0); return weatherData.rgb; } @@ -82,7 +82,7 @@ float3 SampleWeather(float3 pos, float heightFraction, float2 coverageWindOffset float WeatherDensity(float3 weatherData) { const float wetness = saturate(weatherData.b); - return lerp(1.0, 1.0 - g_xFrame_VolumetricClouds.WeatherDensityAmount, wetness); + return lerp(1.0, 1.0 - g_xFrame.VolumetricClouds.WeatherDensityAmount, wetness); } float SampleCloudDensity(float3 p, float heightFraction, float3 weatherData, float3 windOffset, float3 windDirection, float lod, bool sampleDetail) @@ -90,10 +90,10 @@ float SampleCloudDensity(float3 p, float heightFraction, float3 weatherData, flo #ifdef CLOUD_MODE_SIMPLE_FBM float3 pos = p + windOffset; - pos += heightFraction * windDirection * g_xFrame_VolumetricClouds.SkewAlongWindDirection; + pos += heightFraction * windDirection * g_xFrame.VolumetricClouds.SkewAlongWindDirection; // Since the clouds have a massive size, we have to adjust scale accordingly - float noiseScale = max(g_xFrame_VolumetricClouds.TotalNoiseScale * 0.0004, 0.00001); + float noiseScale = max(g_xFrame.VolumetricClouds.TotalNoiseScale * 0.0004, 0.00001); float4 lowFrequencyNoises = texture_shapeNoise.SampleLevel(sampler_linear_wrap, pos * noiseScale, lod); @@ -104,7 +104,7 @@ float SampleCloudDensity(float3 p, float heightFraction, float3 weatherData, flo lowFrequencyFBM = saturate(lowFrequencyFBM); - float cloudSample = Remap(lowFrequencyNoises.r * pow(1.2 - heightFraction, 0.1), lowFrequencyFBM * g_xFrame_VolumetricClouds.ShapeNoiseMinMax.x, g_xFrame_VolumetricClouds.ShapeNoiseMinMax.y, 0.0, 1.0); + float cloudSample = Remap(lowFrequencyNoises.r * pow(1.2 - heightFraction, 0.1), lowFrequencyFBM * g_xFrame.VolumetricClouds.ShapeNoiseMinMax.x, g_xFrame.VolumetricClouds.ShapeNoiseMinMax.y, 0.0, 1.0); cloudSample *= GetDensityHeightGradient(heightFraction, weatherData); float cloudCoverage = weatherData.r; @@ -114,25 +114,25 @@ float SampleCloudDensity(float3 p, float heightFraction, float3 weatherData, flo #else float3 pos = p + windOffset; - pos += heightFraction * windDirection * g_xFrame_VolumetricClouds.SkewAlongWindDirection; + pos += heightFraction * windDirection * g_xFrame.VolumetricClouds.SkewAlongWindDirection; - float noiseScale = max(g_xFrame_VolumetricClouds.TotalNoiseScale * 0.0004, 0.00001); + float noiseScale = max(g_xFrame.VolumetricClouds.TotalNoiseScale * 0.0004, 0.00001); float4 lowFrequencyNoises = texture_shapeNoise.SampleLevel(sampler_linear_wrap, pos * noiseScale, lod); - float3 heightGradient = float3(SampleGradient(g_xFrame_VolumetricClouds.CloudGradientSmall, heightFraction), - SampleGradient(g_xFrame_VolumetricClouds.CloudGradientMedium, heightFraction), - SampleGradient(g_xFrame_VolumetricClouds.CloudGradientLarge, heightFraction)); + float3 heightGradient = float3(SampleGradient(g_xFrame.VolumetricClouds.CloudGradientSmall, heightFraction), + SampleGradient(g_xFrame.VolumetricClouds.CloudGradientMedium, heightFraction), + SampleGradient(g_xFrame.VolumetricClouds.CloudGradientLarge, heightFraction)); // Depending on the type, clouds with higher altitudes may recieve smaller noises - lowFrequencyNoises.gba *= heightGradient * g_xFrame_VolumetricClouds.ShapeNoiseHeightGradientAmount; + lowFrequencyNoises.gba *= heightGradient * g_xFrame.VolumetricClouds.ShapeNoiseHeightGradientAmount; float densityHeightGradient = GetDensityHeightGradient(heightFraction, weatherData); - float cloudSample = (lowFrequencyNoises.r + lowFrequencyNoises.g + lowFrequencyNoises.b + lowFrequencyNoises.a) * g_xFrame_VolumetricClouds.ShapeNoiseMultiplier * densityHeightGradient; - cloudSample = pow(abs(cloudSample), min(1.0, g_xFrame_VolumetricClouds.ShapeNoisePower * heightFraction)); + float cloudSample = (lowFrequencyNoises.r + lowFrequencyNoises.g + lowFrequencyNoises.b + lowFrequencyNoises.a) * g_xFrame.VolumetricClouds.ShapeNoiseMultiplier * densityHeightGradient; + cloudSample = pow(abs(cloudSample), min(1.0, g_xFrame.VolumetricClouds.ShapeNoisePower * heightFraction)); - cloudSample = smoothstep(g_xFrame_VolumetricClouds.ShapeNoiseMinMax.x, g_xFrame_VolumetricClouds.ShapeNoiseMinMax.y, cloudSample); + cloudSample = smoothstep(g_xFrame.VolumetricClouds.ShapeNoiseMinMax.x, g_xFrame.VolumetricClouds.ShapeNoiseMinMax.y, cloudSample); // Remap function for noise against coverage, see GPU Pro 7 float cloudCoverage = weatherData.r; @@ -144,10 +144,10 @@ float SampleCloudDensity(float3 p, float heightFraction, float3 weatherData, flo if (cloudSample > 0.0 && sampleDetail) { // Apply our curl noise to erode with tiny details. - float3 curlNoise = DecodeCurlNoise(texture_curlNoise.SampleLevel(sampler_linear_wrap, p.xz * g_xFrame_VolumetricClouds.CurlScale * noiseScale, 0).rgb); - pos += float3(curlNoise.r, curlNoise.b, curlNoise.g) * heightFraction * g_xFrame_VolumetricClouds.CurlNoiseModifier; + float3 curlNoise = DecodeCurlNoise(texture_curlNoise.SampleLevel(sampler_linear_wrap, p.xz * g_xFrame.VolumetricClouds.CurlScale * noiseScale, 0).rgb); + pos += float3(curlNoise.r, curlNoise.b, curlNoise.g) * heightFraction * g_xFrame.VolumetricClouds.CurlNoiseModifier; - float3 highFrequencyNoises = texture_detailNoise.SampleLevel(sampler_linear_wrap, pos * g_xFrame_VolumetricClouds.DetailScale * noiseScale, lod).rgb; + float3 highFrequencyNoises = texture_detailNoise.SampleLevel(sampler_linear_wrap, pos * g_xFrame.VolumetricClouds.DetailScale * noiseScale, lod).rgb; // Create an FBM out of the high-frequency Worley Noises float highFrequencyFBM = (highFrequencyNoises.r * 0.625) + @@ -157,10 +157,10 @@ float SampleCloudDensity(float3 p, float heightFraction, float3 weatherData, flo highFrequencyFBM = saturate(highFrequencyFBM); // Dilate detail noise based on height - float highFrequenceNoiseModifier = lerp(1.0 - highFrequencyFBM, highFrequencyFBM, saturate(heightFraction * g_xFrame_VolumetricClouds.DetailNoiseHeightFraction)); + float highFrequenceNoiseModifier = lerp(1.0 - highFrequencyFBM, highFrequencyFBM, saturate(heightFraction * g_xFrame.VolumetricClouds.DetailNoiseHeightFraction)); // Erode with base of clouds - cloudSample = Remap(cloudSample, highFrequenceNoiseModifier * g_xFrame_VolumetricClouds.DetailNoiseModifier, 1.0, 0.0, 1.0); + cloudSample = Remap(cloudSample, highFrequenceNoiseModifier * g_xFrame.VolumetricClouds.DetailNoiseModifier, 1.0, 0.0, 1.0); } return max(cloudSample, 0.0); @@ -212,7 +212,7 @@ void VolumetricShadow(inout ParticipatingMedia participatingMedia, in Atmosphere extinctionAccumulation[ms] = 0.0f; } - const float sampleCount = g_xFrame_VolumetricClouds.ShadowSampleCount; + const float sampleCount = g_xFrame.VolumetricClouds.ShadowSampleCount; const float sampleSegmentT = 0.5f; float lodOffset = 0.5; @@ -228,7 +228,7 @@ void VolumetricShadow(inout ParticipatingMedia participatingMedia, in Atmosphere float delta = t1 - t0; // 5 samples: 0.04, 0.12, 0.2, 0.28, 0.36 float t = t0 + delta * sampleSegmentT; // 5 samples: 0.02, 0.1, 0.26, 0.5, 0.82 - float shadowSampleT = g_xFrame_VolumetricClouds.ShadowStepLength * t; + float shadowSampleT = g_xFrame.VolumetricClouds.ShadowStepLength * t; float3 samplePoint = worldPosition + sunDirection * shadowSampleT; // Step futher towards the light float heightFraction = GetHeightFractionForPoint(atmosphere, samplePoint); @@ -245,8 +245,8 @@ void VolumetricShadow(inout ParticipatingMedia participatingMedia, in Atmosphere float shadowCloudDensity = SampleCloudDensity(samplePoint, heightFraction, weatherData, windOffset, windDirection, lod + lodOffset, true); - float3 shadowExtinction = g_xFrame_VolumetricClouds.ExtinctionCoefficient * shadowCloudDensity; - ParticipatingMedia shadowParticipatingMedia = SampleParticipatingMedia(0.0f, shadowExtinction, g_xFrame_VolumetricClouds.MultiScatteringScattering, g_xFrame_VolumetricClouds.MultiScatteringExtinction, 0.0f); + float3 shadowExtinction = g_xFrame.VolumetricClouds.ExtinctionCoefficient * shadowCloudDensity; + ParticipatingMedia shadowParticipatingMedia = SampleParticipatingMedia(0.0f, shadowExtinction, g_xFrame.VolumetricClouds.MultiScatteringScattering, g_xFrame.VolumetricClouds.MultiScatteringExtinction, 0.0f); [unroll] for (ms = 0; ms < MS_COUNT; ms++) @@ -260,7 +260,7 @@ void VolumetricShadow(inout ParticipatingMedia participatingMedia, in Atmosphere [unroll] for (ms = 0; ms < MS_COUNT; ms++) { - participatingMedia.transmittanceToLight[ms] *= exp(-extinctionAccumulation[ms] * g_xFrame_VolumetricClouds.ShadowStepLength); + participatingMedia.transmittanceToLight[ms] *= exp(-extinctionAccumulation[ms] * g_xFrame.VolumetricClouds.ShadowStepLength); } } @@ -269,7 +269,7 @@ void VolumetricGroundContribution(inout float3 environmentLuminance, in Atmosphe float planetRadius = atmosphere.bottomRadius * SKY_UNIT_TO_M; float3 planetCenterWorld = atmosphere.planetCenter * SKY_UNIT_TO_M; - float cloudBottomRadius = planetRadius + g_xFrame_VolumetricClouds.CloudStartHeight; + float cloudBottomRadius = planetRadius + g_xFrame.VolumetricClouds.CloudStartHeight; float cloudSampleAltitudde = length(worldPosition - planetCenterWorld); // Distance from planet center to tracing sample float cloudSampleHeightToBottom = cloudSampleAltitudde - cloudBottomRadius; // Distance from altitude to bottom of clouds @@ -279,7 +279,7 @@ void VolumetricGroundContribution(inout float3 environmentLuminance, in Atmosphe const float contributionStepLength = min(4000.0, cloudSampleHeightToBottom); const float3 groundScatterDirection = float3(0.0, -1.0, 0.0); - const float sampleCount = g_xFrame_VolumetricClouds.GroundContributionSampleCount; + const float sampleCount = g_xFrame.VolumetricClouds.GroundContributionSampleCount; const float sampleSegmentT = 0.5f; // Ground Contribution tracing loop, same idea as volumetric shadow @@ -313,7 +313,7 @@ void VolumetricGroundContribution(inout float3 environmentLuminance, in Atmosphe float contributionCloudDensity = SampleCloudDensity(samplePoint, heightFraction, weatherData, windOffset, windDirection, lod + lodOffset, true); - float3 contributionExtinction = g_xFrame_VolumetricClouds.ExtinctionCoefficient * contributionCloudDensity; + float3 contributionExtinction = g_xFrame.VolumetricClouds.ExtinctionCoefficient * contributionCloudDensity; opticalDepth += contributionExtinction * contributionStepLength * delta; @@ -366,12 +366,12 @@ ParticipatingMediaPhase SampleParticipatingMediaPhase(float basePhase, float bas float3 SampleAmbientLight(float heightFraction) { // Early experiment by adding directionality to ambient, based on: http://patapom.com/topics/Revision2013/Revision%202013%20-%20Real-time%20Volumetric%20Rendering%20Course%20Notes.pdf - //float ambientTerm = -cloudDensity * (1.0 - saturate(g_xFrame_VolumetricClouds.CloudAmbientGroundMultiplier + heightFraction)); + //float ambientTerm = -cloudDensity * (1.0 - saturate(g_xFrame.VolumetricClouds.CloudAmbientGroundMultiplier + heightFraction)); //float isotropicScatteringTopContribution = max(0.0, exp(ambientTerm) - ambientTerm * ExponentialIntegral(ambientTerm)); - float isotropicScatteringTopContribution = saturate(g_xFrame_VolumetricClouds.CloudAmbientGroundMultiplier + heightFraction); + float isotropicScatteringTopContribution = saturate(g_xFrame.VolumetricClouds.CloudAmbientGroundMultiplier + heightFraction); - if (g_xFrame_Options & OPTION_BIT_REALISTIC_SKY) + if (g_xFrame.Options & OPTION_BIT_REALISTIC_SKY) { float3 skyLuminance = texture_skyluminancelut.SampleLevel(sampler_point_clamp, float2(0.5, 0.5), 0).rgb; return isotropicScatteringTopContribution * skyLuminance; @@ -388,18 +388,18 @@ void VolumetricCloudLighting(AtmosphereParameters atmosphere, float3 startPositi inout float3 luminance, inout float3 transmittanceToView, inout float depthWeightedSum, inout float depthWeightsSum) { // Setup base parameters - //float3 albedo = g_xFrame_VolumetricClouds.Albedo * cloudDensity; - float3 albedo = pow(saturate(g_xFrame_VolumetricClouds.Albedo * cloudDensity * g_xFrame_VolumetricClouds.BeerPowder), g_xFrame_VolumetricClouds.BeerPowderPower); // Artistic approach - float3 extinction = g_xFrame_VolumetricClouds.ExtinctionCoefficient * cloudDensity; + //float3 albedo = g_xFrame.VolumetricClouds.Albedo * cloudDensity; + float3 albedo = pow(saturate(g_xFrame.VolumetricClouds.Albedo * cloudDensity * g_xFrame.VolumetricClouds.BeerPowder), g_xFrame.VolumetricClouds.BeerPowderPower); // Artistic approach + float3 extinction = g_xFrame.VolumetricClouds.ExtinctionCoefficient * cloudDensity; float3 atmosphereTransmittanceToLight = 1.0; - if (g_xFrame_Options & OPTION_BIT_REALISTIC_SKY) + if (g_xFrame.Options & OPTION_BIT_REALISTIC_SKY) { atmosphereTransmittanceToLight = GetAtmosphericLightTransmittance(atmosphere, worldPosition, sunDirection, texture_transmittancelut); // Has to be in meters } // Sample participating media with multiple scattering - ParticipatingMedia participatingMedia = SampleParticipatingMedia(albedo, extinction, g_xFrame_VolumetricClouds.MultiScatteringScattering, g_xFrame_VolumetricClouds.MultiScatteringExtinction, atmosphereTransmittanceToLight); + ParticipatingMedia participatingMedia = SampleParticipatingMedia(albedo, extinction, g_xFrame.VolumetricClouds.MultiScatteringScattering, g_xFrame.VolumetricClouds.MultiScatteringExtinction, atmosphereTransmittanceToLight); // Sample environment lighting @@ -423,8 +423,8 @@ void VolumetricCloudLighting(AtmosphereParameters atmosphere, float3 startPositi // Sample dual lob phase with multiple scattering - float phaseFunction = DualLobPhase(g_xFrame_VolumetricClouds.PhaseG, g_xFrame_VolumetricClouds.PhaseG2, g_xFrame_VolumetricClouds.PhaseBlend, -cosTheta); - ParticipatingMediaPhase participatingMediaPhase = SampleParticipatingMediaPhase(phaseFunction, g_xFrame_VolumetricClouds.MultiScatteringEccentricity); + float phaseFunction = DualLobPhase(g_xFrame.VolumetricClouds.PhaseG, g_xFrame.VolumetricClouds.PhaseG2, g_xFrame.VolumetricClouds.PhaseBlend, -cosTheta); + ParticipatingMediaPhase participatingMediaPhase = SampleParticipatingMediaPhase(phaseFunction, g_xFrame.VolumetricClouds.MultiScatteringEccentricity); // Update depth sampling @@ -466,14 +466,14 @@ void RenderClouds(float3 rayOrigin, float3 rayDirection, float t, float steps, f inout float3 luminance, inout float3 transmittanceToView, inout float depthWeightedSum, inout float depthWeightsSum) { // Wind animation offsets - float3 windDirection = float3(cos(g_xFrame_VolumetricClouds.WindAngle), -g_xFrame_VolumetricClouds.WindUpAmount, sin(g_xFrame_VolumetricClouds.WindAngle)); - float3 windOffset = g_xFrame_VolumetricClouds.WindSpeed * g_xFrame_VolumetricClouds.AnimationMultiplier * windDirection * g_xFrame_Time; + float3 windDirection = float3(cos(g_xFrame.VolumetricClouds.WindAngle), -g_xFrame.VolumetricClouds.WindUpAmount, sin(g_xFrame.VolumetricClouds.WindAngle)); + float3 windOffset = g_xFrame.VolumetricClouds.WindSpeed * g_xFrame.VolumetricClouds.AnimationMultiplier * windDirection * g_xFrame.Time; - float2 coverageWindDirection = float2(cos(g_xFrame_VolumetricClouds.CoverageWindAngle), sin(g_xFrame_VolumetricClouds.CoverageWindAngle)); - float2 coverageWindOffset = g_xFrame_VolumetricClouds.CoverageWindSpeed * g_xFrame_VolumetricClouds.AnimationMultiplier * coverageWindDirection * g_xFrame_Time; + float2 coverageWindDirection = float2(cos(g_xFrame.VolumetricClouds.CoverageWindAngle), sin(g_xFrame.VolumetricClouds.CoverageWindAngle)); + float2 coverageWindOffset = g_xFrame.VolumetricClouds.CoverageWindSpeed * g_xFrame.VolumetricClouds.AnimationMultiplier * coverageWindDirection * g_xFrame.Time; - AtmosphereParameters atmosphere = g_xFrame_Atmosphere; + AtmosphereParameters atmosphere = g_xFrame.Atmosphere; float3 sunIlluminance = GetSunColor() * GetSunEnergy(); float3 sunDirection = GetSunDirection(); @@ -483,7 +483,7 @@ void RenderClouds(float3 rayOrigin, float3 rayDirection, float t, float steps, f // Init float zeroDensitySampleCount = 0.0; - float stepLength = g_xFrame_VolumetricClouds.BigStepMarch; + float stepLength = g_xFrame.VolumetricClouds.BigStepMarch; float3 sampleWorldPosition = rayOrigin + rayDirection * t; @@ -502,13 +502,13 @@ void RenderClouds(float3 rayOrigin, float3 rayDirection, float t, float steps, f // If value is low, continue marching until we quit or hit something. sampleWorldPosition += rayDirection * stepSize * stepLength; zeroDensitySampleCount += 1.0; - stepLength = zeroDensitySampleCount > 10.0 ? g_xFrame_VolumetricClouds.BigStepMarch : 1.0; // If zero count has reached a high number, switch to big steps + stepLength = zeroDensitySampleCount > 10.0 ? g_xFrame.VolumetricClouds.BigStepMarch : 1.0; // If zero count has reached a high number, switch to big steps continue; } - float rayDepth = distance(g_xCamera_CamPos, sampleWorldPosition); - float lod = step(g_xFrame_VolumetricClouds.LODDistance, rayDepth) + g_xFrame_VolumetricClouds.LODMin; + float rayDepth = distance(g_xCamera.CamPos, sampleWorldPosition); + float lod = step(g_xFrame.VolumetricClouds.LODDistance, rayDepth) + g_xFrame.VolumetricClouds.LODMin; float cloudDensity = saturate(SampleCloudDensity(sampleWorldPosition, heightFraction, weatherData, windOffset, windDirection, lod, true)); if (cloudDensity > 0.0) @@ -529,7 +529,7 @@ void RenderClouds(float3 rayOrigin, float3 rayDirection, float t, float steps, f stepSize, heightFraction, cloudDensity, weatherData, windOffset, windDirection, coverageWindOffset, lod, luminance, transmittanceToView, depthWeightedSum, depthWeightsSum); - if (all(transmittanceToView < g_xFrame_VolumetricClouds.TransmittanceThreshold)) + if (all(transmittanceToView < g_xFrame.VolumetricClouds.TransmittanceThreshold)) { break; } @@ -539,7 +539,7 @@ void RenderClouds(float3 rayOrigin, float3 rayDirection, float t, float steps, f zeroDensitySampleCount += 1.0; } - stepLength = zeroDensitySampleCount > 10.0 ? g_xFrame_VolumetricClouds.BigStepMarch : 1.0; + stepLength = zeroDensitySampleCount > 10.0 ? g_xFrame.VolumetricClouds.BigStepMarch : 1.0; sampleWorldPosition += rayDirection * stepSize * stepLength; } @@ -548,9 +548,9 @@ void RenderClouds(float3 rayOrigin, float3 rayDirection, float t, float steps, f float CalculateAtmosphereBlend(float tDepth) { // Progressively increase alpha as clouds reaches the desired distance. - float fogDistance = saturate(tDepth * g_xFrame_VolumetricClouds.HorizonBlendAmount * 0.00001); + float fogDistance = saturate(tDepth * g_xFrame.VolumetricClouds.HorizonBlendAmount * 0.00001); - float fade = pow(fogDistance, g_xFrame_VolumetricClouds.HorizonBlendPower); + float fade = pow(fogDistance, g_xFrame.VolumetricClouds.HorizonBlendPower); fade = smoothstep(0.0, 1.0, fade); const float maxHorizonFade = 0.0; @@ -572,7 +572,7 @@ int ComputeCheckerBoardIndex(int2 renderCoord, int subPixelIndex) [numthreads(POSTPROCESS_BLOCKSIZE, POSTPROCESS_BLOCKSIZE, 1)] void main(uint3 DTid : SV_DispatchThreadID) { - int subPixelIndex = g_xFrame_FrameCount % 4; + int subPixelIndex = g_xFrame.FrameCount % 4; int checkerBoardIndex = ComputeCheckerBoardIndex(DTid.xy, subPixelIndex); uint2 halfResCoord = DTid.xy * 2 + g_HalfResIndexToCoordinateOffset[checkerBoardIndex]; @@ -582,10 +582,10 @@ void main(uint3 DTid : SV_DispatchThreadID) float y = (1 - uv.y) * 2 - 1; float2 screenPosition = float2(x, y); - float4 unprojected = mul(g_xCamera_InvVP, float4(screenPosition, 0, 1)); + float4 unprojected = mul(g_xCamera.InvVP, float4(screenPosition, 0, 1)); unprojected.xyz /= unprojected.w; - float3 rayOrigin = g_xCamera_CamPos; + float3 rayOrigin = g_xCamera.CamPos; float3 rayDirection = normalize(unprojected.xyz - rayOrigin); @@ -596,13 +596,13 @@ void main(uint3 DTid : SV_DispatchThreadID) float steps; float stepSize; { - AtmosphereParameters parameters = g_xFrame_Atmosphere; + AtmosphereParameters parameters = g_xFrame.Atmosphere; float planetRadius = parameters.bottomRadius * SKY_UNIT_TO_M; float3 planetCenterWorld = parameters.planetCenter * SKY_UNIT_TO_M; - const float cloudBottomRadius = planetRadius + g_xFrame_VolumetricClouds.CloudStartHeight; - const float cloudTopRadius = planetRadius + g_xFrame_VolumetricClouds.CloudStartHeight + g_xFrame_VolumetricClouds.CloudThickness; + const float cloudBottomRadius = planetRadius + g_xFrame.VolumetricClouds.CloudStartHeight; + const float cloudTopRadius = planetRadius + g_xFrame.VolumetricClouds.CloudStartHeight + g_xFrame.VolumetricClouds.CloudThickness; float2 tTopSolutions = RaySphereIntersect(rayOrigin, rayDirection, planetCenterWorld, cloudTopRadius); if (tTopSolutions.x > 0.0 || tTopSolutions.y > 0.0) @@ -639,7 +639,7 @@ void main(uint3 DTid : SV_DispatchThreadID) return; } - if (tMax <= tMin || tMin > g_xFrame_VolumetricClouds.RenderDistance) + if (tMax <= tMin || tMin > g_xFrame.VolumetricClouds.RenderDistance) { texture_render[DTid.xy] = float4(0.0, 0.0, 0.0, 0.0); // Inverted alpha texture_cloudDepth[DTid.xy] = FLT_MAX; @@ -653,18 +653,18 @@ void main(uint3 DTid : SV_DispatchThreadID) tToDepthBuffer = length(depthWorldPosition - rayOrigin); tMax = depth == 0.0 ? tMax : min(tMax, tToDepthBuffer); // Exclude skybox - const float marchingDistance = min(g_xFrame_VolumetricClouds.MaxMarchingDistance, tMax - tMin); + const float marchingDistance = min(g_xFrame.VolumetricClouds.MaxMarchingDistance, tMax - tMin); tMax = tMin + marchingDistance; - steps = g_xFrame_VolumetricClouds.MaxStepCount * saturate((tMax - tMin) * (1.0 / g_xFrame_VolumetricClouds.InverseDistanceStepCount)); + steps = g_xFrame.VolumetricClouds.MaxStepCount * saturate((tMax - tMin) * (1.0 / g_xFrame.VolumetricClouds.InverseDistanceStepCount)); stepSize = (tMax - tMin) / steps; //float offset = dither(DTid.xy + GetTemporalAASampleRotation()); float offset = blue_noise(DTid.xy).x; - //float offset = InterleavedGradientNoise(DTid.xy, g_xFrame_FrameCount % 16); + //float offset = InterleavedGradientNoise(DTid.xy, g_xFrame.FrameCount % 16); //t = tMin + 0.5 * stepSize; - t = tMin + offset * stepSize * g_xFrame_VolumetricClouds.BigStepMarch; // offset avg = 0.5 + t = tMin + offset * stepSize * g_xFrame.VolumetricClouds.BigStepMarch; // offset avg = 0.5 } @@ -681,7 +681,7 @@ void main(uint3 DTid : SV_DispatchThreadID) //float3 absoluteWorldPosition = rayOrigin + rayDirection * tDepth; // Could be used for other effects later that require worldPosition float approxTransmittance = dot(transmittanceToView.rgb, 1.0 / 3.0); - float grayScaleTransmittance = approxTransmittance < g_xFrame_VolumetricClouds.TransmittanceThreshold ? 0.0 : approxTransmittance; + float grayScaleTransmittance = approxTransmittance < g_xFrame.VolumetricClouds.TransmittanceThreshold ? 0.0 : approxTransmittance; float4 color = float4(luminance, grayScaleTransmittance); diff --git a/WickedEngine/shaders/volumetricCloud_reprojectCS.hlsl b/WickedEngine/shaders/volumetricCloud_reprojectCS.hlsl index 7c49f38d0..ccb5d7e98 100644 --- a/WickedEngine/shaders/volumetricCloud_reprojectCS.hlsl +++ b/WickedEngine/shaders/volumetricCloud_reprojectCS.hlsl @@ -35,13 +35,13 @@ void main(uint3 DTid : SV_DispatchThreadID) // Calculate screen dependant motion vector float4 prevPos = float4(uv * 2.0 - 1.0, 1.0, 1.0); - prevPos = mul(g_xCamera_InvP, prevPos); + prevPos = mul(g_xCamera.InvP, prevPos); prevPos = prevPos / prevPos.w; - prevPos.xyz = mul((float3x3)g_xCamera_InvV, prevPos.xyz); - prevPos.xyz = mul((float3x3)g_xCamera_PrevV, prevPos.xyz); + prevPos.xyz = mul((float3x3)g_xCamera.InvV, prevPos.xyz); + prevPos.xyz = mul((float3x3)g_xCamera.PrevV, prevPos.xyz); - float4 reproj = mul(g_xCamera_Proj, prevPos); + float4 reproj = mul(g_xCamera.Proj, prevPos); reproj /= reproj.w; float2 prevUV = reproj.xy * 0.5 + 0.5; @@ -53,14 +53,14 @@ void main(uint3 DTid : SV_DispatchThreadID) float2 screenPosition = float2(x, y); float currentCloudLinearDepth = cloud_depth_current.SampleLevel(sampler_point_clamp, uv, 0).x; - float currentCloudDepth = getInverseLinearDepth(currentCloudLinearDepth, g_xCamera_ZNearP, g_xCamera_ZFarP); + float currentCloudDepth = getInverseLinearDepth(currentCloudLinearDepth, g_xCamera.ZNearP, g_xCamera.ZFarP); float4 thisClip = float4(screenPosition, currentCloudDepth, 1.0); - float4 prevClip = mul(g_xCamera_InvVP, thisClip); - prevClip = mul(g_xCamera_PrevVP, prevClip); + float4 prevClip = mul(g_xCamera.InvVP, thisClip); + prevClip = mul(g_xCamera.PrevVP, prevClip); - //float4 prevClip = mul(g_xCamera_PrevVP, worldPosition); + //float4 prevClip = mul(g_xCamera.PrevVP, worldPosition); float2 prevScreen = prevClip.xy / prevClip.w; float2 screenVelocity = screenPosition - prevScreen; @@ -73,7 +73,7 @@ void main(uint3 DTid : SV_DispatchThreadID) bool validHistory = is_saturated(prevUV); - int subPixelIndex = g_xFrame_FrameCount % 4; + int subPixelIndex = g_xFrame.FrameCount % 4; int localIndex = (DTid.x & 1) + (DTid.y & 1) * 2; int currentIndex = ComputeCheckerBoardIndex(renderCoord, subPixelIndex); @@ -120,7 +120,7 @@ void main(uint3 DTid : SV_DispatchThreadID) float depth = texture_depth.SampleLevel(sampler_point_clamp, uv, 1).r; // Half res float3 depthWorldPosition = reconstructPosition(uv, depth); - float tToDepthBuffer = length(depthWorldPosition - g_xCamera_CamPos); + float tToDepthBuffer = length(depthWorldPosition - g_xCamera.CamPos); if (abs(tToDepthBuffer - previousDepthResult.y) > tToDepthBuffer * 0.1) { diff --git a/WickedEngine/shaders/volumetricCloud_temporalCS.hlsl b/WickedEngine/shaders/volumetricCloud_temporalCS.hlsl index 790473e11..1a1049ae0 100644 --- a/WickedEngine/shaders/volumetricCloud_temporalCS.hlsl +++ b/WickedEngine/shaders/volumetricCloud_temporalCS.hlsl @@ -84,7 +84,7 @@ inline void ResolverAABB(Texture2D currentColor, SamplerState currentSam float depth = texture_depth.SampleLevel(sampler_point_clamp, uv, 1).r; // Half res float3 depthWorldPosition = reconstructPosition(uv, depth); - float tToDepthBuffer = length(depthWorldPosition - g_xCamera_CamPos); + float tToDepthBuffer = length(depthWorldPosition - g_xCamera.CamPos); float validSampleCount = 1.0; @@ -141,13 +141,13 @@ void main(uint3 DTid : SV_DispatchThreadID) // Calculate screen dependant motion vector float4 prevPos = float4(uv * 2.0 - 1.0, 1.0, 1.0); - prevPos = mul(g_xCamera_InvP, prevPos); + prevPos = mul(g_xCamera.InvP, prevPos); prevPos = prevPos / prevPos.w; - prevPos.xyz = mul((float3x3)g_xCamera_InvV, prevPos.xyz); - prevPos.xyz = mul((float3x3)g_xCamera_PrevV, prevPos.xyz); + prevPos.xyz = mul((float3x3)g_xCamera.InvV, prevPos.xyz); + prevPos.xyz = mul((float3x3)g_xCamera.PrevV, prevPos.xyz); - float4 reproj = mul(g_xCamera_Proj, prevPos); + float4 reproj = mul(g_xCamera.Proj, prevPos); reproj /= reproj.w; float2 prevUV = reproj.xy * 0.5 + 0.5; @@ -161,14 +161,14 @@ void main(uint3 DTid : SV_DispatchThreadID) float2 screenPosition = float2(x, y); float currentCloudLinearDepth = cloud_reproject_depth[DTid.xy].x; - float currentCloudDepth = getInverseLinearDepth(currentCloudLinearDepth, g_xCamera_ZNearP, g_xCamera_ZFarP); + float currentCloudDepth = getInverseLinearDepth(currentCloudLinearDepth, g_xCamera.ZNearP, g_xCamera.ZFarP); float4 thisClip = float4(screenPosition, currentCloudDepth, 1.0); - float4 prevClip = mul(g_xCamera_InvVP, thisClip); - prevClip = mul(g_xCamera_PrevVP, prevClip); + float4 prevClip = mul(g_xCamera.InvVP, thisClip); + prevClip = mul(g_xCamera.PrevVP, prevClip); - //float4 prevClip = mul(g_xCamera_PrevVP, worldPosition); + //float4 prevClip = mul(g_xCamera.PrevVP, worldPosition); float2 prevScreen = prevClip.xy / prevClip.w; float2 screenVelocity = screenPosition - prevScreen; diff --git a/WickedEngine/shaders/volumetricLight_DirectionalPS.hlsl b/WickedEngine/shaders/volumetricLight_DirectionalPS.hlsl index bf02232e4..c39727bf3 100644 --- a/WickedEngine/shaders/volumetricLight_DirectionalPS.hlsl +++ b/WickedEngine/shaders/volumetricLight_DirectionalPS.hlsl @@ -4,7 +4,7 @@ float4 main(VertexToPixel input) : SV_TARGET { - ShaderEntity light = EntityArray[g_xFrame_LightArrayOffset + (uint)g_xColor.x]; + ShaderEntity light = EntityArray[g_xFrame.LightArrayOffset + (uint)g_xColor.x]; if (!light.IsCastingShadow()) { @@ -15,7 +15,7 @@ float4 main(VertexToPixel input) : SV_TARGET float2 ScreenCoord = input.pos2D.xy / input.pos2D.w * float2(0.5f, -0.5f) + 0.5f; float depth = max(input.pos.z, texture_depth.SampleLevel(sampler_point_clamp, ScreenCoord, 2)); float3 P = reconstructPosition(ScreenCoord, depth); - float3 V = g_xCamera_CamPos - P; + float3 V = g_xCamera.CamPos - P; float cameraDistance = length(V); V /= cameraDistance; @@ -25,7 +25,7 @@ float4 main(VertexToPixel input) : SV_TARGET const float3 L = light.GetDirection(); const float scattering = ComputeScattering(saturate(dot(L, -V))); - float3 rayEnd = g_xCamera_CamPos; + float3 rayEnd = g_xCamera.CamPos; const uint sampleCount = 16; const float stepSize = length(P - rayEnd) / sampleCount; @@ -39,7 +39,7 @@ float4 main(VertexToPixel input) : SV_TARGET { bool valid = false; - for (uint cascade = 0; cascade < g_xFrame_ShadowCascadeCount; ++cascade) + for (uint cascade = 0; cascade < g_xFrame.ShadowCascadeCount; ++cascade) { float3 ShPos = mul(MatrixArray[light.GetMatrixIndex() + cascade], float4(P, 1)).xyz; // ortho matrix, no divide by .w float3 ShTex = ShPos.xyz * float3(0.5f, -0.5f, 0.5f) + 0.5f; @@ -69,9 +69,9 @@ float4 main(VertexToPixel input) : SV_TARGET accumulation /= sampleCount; float3 atmosphereTransmittance = 1; - if (g_xFrame_Options & OPTION_BIT_REALISTIC_SKY) + if (g_xFrame.Options & OPTION_BIT_REALISTIC_SKY) { - atmosphereTransmittance = GetAtmosphericLightTransmittance(g_xFrame_Atmosphere, P, L, texture_transmittancelut); + atmosphereTransmittance = GetAtmosphericLightTransmittance(g_xFrame.Atmosphere, P, L, texture_transmittancelut); } return max(0, float4(accumulation * light.GetColor().rgb * light.GetEnergy() * atmosphereTransmittance, 1)); diff --git a/WickedEngine/shaders/volumetricLight_PointPS.hlsl b/WickedEngine/shaders/volumetricLight_PointPS.hlsl index 2f7a446c9..d016a5237 100644 --- a/WickedEngine/shaders/volumetricLight_PointPS.hlsl +++ b/WickedEngine/shaders/volumetricLight_PointPS.hlsl @@ -4,19 +4,19 @@ float4 main(VertexToPixel input) : SV_TARGET { - ShaderEntity light = EntityArray[g_xFrame_LightArrayOffset + (uint)g_xColor.x]; + ShaderEntity light = EntityArray[g_xFrame.LightArrayOffset + (uint)g_xColor.x]; float2 ScreenCoord = input.pos2D.xy / input.pos2D.w * float2(0.5f, -0.5f) + 0.5f; float depth = max(input.pos.z, texture_depth.SampleLevel(sampler_point_clamp, ScreenCoord, 2)); float3 P = reconstructPosition(ScreenCoord, depth); - float3 V = g_xCamera_CamPos - P; + float3 V = g_xCamera.CamPos - P; float cameraDistance = length(V); V /= cameraDistance; float marchedDistance = 0; float3 accumulation = 0; - float3 rayEnd = g_xCamera_CamPos; + float3 rayEnd = g_xCamera.CamPos; if (length(rayEnd - light.position) > light.GetRange()) { // if we are outside the light volume, then rayEnd will be the traced sphere frontface: diff --git a/WickedEngine/shaders/volumetricLight_SpotPS.hlsl b/WickedEngine/shaders/volumetricLight_SpotPS.hlsl index 3a81c5e86..28725e368 100644 --- a/WickedEngine/shaders/volumetricLight_SpotPS.hlsl +++ b/WickedEngine/shaders/volumetricLight_SpotPS.hlsl @@ -4,19 +4,19 @@ float4 main(VertexToPixel input) : SV_TARGET { - ShaderEntity light = EntityArray[g_xFrame_LightArrayOffset + (uint)g_xColor.x]; + ShaderEntity light = EntityArray[g_xFrame.LightArrayOffset + (uint)g_xColor.x]; float2 ScreenCoord = input.pos2D.xy / input.pos2D.w * float2(0.5f, -0.5f) + 0.5f; float depth = max(input.pos.z, texture_depth.SampleLevel(sampler_point_clamp, ScreenCoord, 2)); float3 P = reconstructPosition(ScreenCoord, depth); - float3 V = g_xCamera_CamPos - P; + float3 V = g_xCamera.CamPos - P; float cameraDistance = length(V); V /= cameraDistance; float marchedDistance = 0; float3 accumulation = 0; - float3 rayEnd = g_xCamera_CamPos; + float3 rayEnd = g_xCamera.CamPos; // todo: rayEnd should be clamped to the closest cone intersection point when camera is outside volume const uint sampleCount = 16; diff --git a/WickedEngine/shaders/voxelConeTracingHF.hlsli b/WickedEngine/shaders/voxelConeTracingHF.hlsli index a65f451ed..c79f85844 100644 --- a/WickedEngine/shaders/voxelConeTracingHF.hlsli +++ b/WickedEngine/shaders/voxelConeTracingHF.hlsli @@ -18,24 +18,24 @@ inline float4 ConeTrace(in Texture3D voxels, in float3 P, in float3 N, i // We need to offset the cone start position to avoid sampling its own voxel (self-occlusion): // Unfortunately, it will result in disconnection between nearby surfaces :( - float dist = g_xFrame_VoxelRadianceDataSize; // offset by cone dir so that first sample of all cones are not the same - float3 startPos = P + N * g_xFrame_VoxelRadianceDataSize * VOXEL_INITIAL_OFFSET * SQRT2; // sqrt2 is diagonal voxel half-extent + float dist = g_xFrame.VoxelRadianceDataSize; // offset by cone dir so that first sample of all cones are not the same + float3 startPos = P + N * g_xFrame.VoxelRadianceDataSize * VOXEL_INITIAL_OFFSET * SQRT2; // sqrt2 is diagonal voxel half-extent // We will break off the loop if the sampling distance is too far for performance reasons: - while (dist < g_xFrame_VoxelRadianceMaxDistance && alpha < 1) + while (dist < g_xFrame.VoxelRadianceMaxDistance && alpha < 1) { - float diameter = max(g_xFrame_VoxelRadianceDataSize, 2 * coneAperture * dist); - float mip = log2(diameter * g_xFrame_VoxelRadianceDataSize_rcp); + float diameter = max(g_xFrame.VoxelRadianceDataSize, 2 * coneAperture * dist); + float mip = log2(diameter * g_xFrame.VoxelRadianceDataSize_rcp); // Because we do the ray-marching in world space, we need to remap into 3d texture space before sampling: // todo: optimization could be doing ray-marching in texture space float3 tc = startPos + coneDirection * dist; - tc = (tc - g_xFrame_VoxelRadianceDataCenter) * g_xFrame_VoxelRadianceDataSize_rcp; - tc *= g_xFrame_VoxelRadianceDataRes_rcp; + tc = (tc - g_xFrame.VoxelRadianceDataCenter) * g_xFrame.VoxelRadianceDataSize_rcp; + tc *= g_xFrame.VoxelRadianceDataRes_rcp; tc = tc * float3(0.5f, -0.5f, 0.5f) + 0.5f; // break if the ray exits the voxel grid, or we sample from the last mip: - if (!is_saturated(tc) || mip >= (float)g_xFrame_VoxelRadianceDataMIPs) + if (!is_saturated(tc) || mip >= (float)g_xFrame.VoxelRadianceDataMIPs) break; float4 sam = voxels.SampleLevel(sampler_linear_clamp, tc, mip); @@ -46,7 +46,7 @@ inline float4 ConeTrace(in Texture3D voxels, in float3 P, in float3 N, i alpha += a * sam.a; // step along ray: - dist += diameter * g_xFrame_VoxelRadianceRayStepSize; + dist += diameter * g_xFrame.VoxelRadianceRayStepSize; } return float4(color, alpha); @@ -60,9 +60,9 @@ inline float4 ConeTraceDiffuse(in Texture3D voxels, in float3 P, in floa float4 amount = 0; float3x3 tangentSpace = GetTangentSpace(N); - for (uint cone = 0; cone < g_xFrame_VoxelRadianceNumCones; ++cone) // quality is between 1 and 16 cones + for (uint cone = 0; cone < g_xFrame.VoxelRadianceNumCones; ++cone) // quality is between 1 and 16 cones { - float2 hamm = hammersley2d(cone, g_xFrame_VoxelRadianceNumCones); + float2 hamm = hammersley2d(cone, g_xFrame.VoxelRadianceNumCones); float3 hemisphere = hemispherepoint_cos(hamm.x, hamm.y); float3 coneDirection = mul(hemisphere, tangentSpace); @@ -70,7 +70,7 @@ inline float4 ConeTraceDiffuse(in Texture3D voxels, in float3 P, in floa } // final radiance is average of all the cones radiances - amount *= g_xFrame_VoxelRadianceNumCones_rcp; + amount *= g_xFrame.VoxelRadianceNumCones_rcp; amount.rgb = max(0, amount.rgb); amount.a = saturate(amount.a); diff --git a/WickedEngine/shaders/voxelGS.hlsl b/WickedEngine/shaders/voxelGS.hlsl index 2d4c8ce02..34ba43ba1 100644 --- a/WickedEngine/shaders/voxelGS.hlsl +++ b/WickedEngine/shaders/voxelGS.hlsl @@ -21,11 +21,11 @@ void main( element.pos = input[0].pos; element.col = input[0].col; - element.pos.xyz = element.pos.xyz / g_xFrame_VoxelRadianceDataRes * 2 - 1; + element.pos.xyz = element.pos.xyz / g_xFrame.VoxelRadianceDataRes * 2 - 1; element.pos.y = -element.pos.y; - element.pos.xyz *= g_xFrame_VoxelRadianceDataRes; + element.pos.xyz *= g_xFrame.VoxelRadianceDataRes; element.pos.xyz += (CreateCube(i) - float3(0, 1, 0)) * 2; - element.pos.xyz *= g_xFrame_VoxelRadianceDataRes * g_xFrame_VoxelRadianceDataSize / g_xFrame_VoxelRadianceDataRes; + element.pos.xyz *= g_xFrame.VoxelRadianceDataRes * g_xFrame.VoxelRadianceDataSize / g_xFrame.VoxelRadianceDataRes; element.pos = mul(g_xTransform, float4(element.pos.xyz, 1)); element.col *= g_xColor; diff --git a/WickedEngine/shaders/voxelRadianceSecondaryBounceCS.hlsl b/WickedEngine/shaders/voxelRadianceSecondaryBounceCS.hlsl index 9fe34a5d3..0b8039aa8 100644 --- a/WickedEngine/shaders/voxelRadianceSecondaryBounceCS.hlsl +++ b/WickedEngine/shaders/voxelRadianceSecondaryBounceCS.hlsl @@ -18,12 +18,12 @@ void main( uint3 DTid : SV_DispatchThreadID ) { float3 N = unpack_unitvector(input_voxelscene[DTid.x].normalMask); - float3 P = ((float3)writecoord + 0.5f) * g_xFrame_VoxelRadianceDataRes_rcp; + float3 P = ((float3)writecoord + 0.5f) * g_xFrame.VoxelRadianceDataRes_rcp; P = P * 2 - 1; P.y *= -1; - P *= g_xFrame_VoxelRadianceDataSize; - P *= g_xFrame_VoxelRadianceDataRes; - P += g_xFrame_VoxelRadianceDataCenter; + P *= g_xFrame.VoxelRadianceDataSize; + P *= g_xFrame.VoxelRadianceDataRes; + P += g_xFrame.VoxelRadianceDataCenter; float4 radiance = ConeTraceDiffuse(input_emission, P, N); diff --git a/WickedEngine/shaders/voxelSceneCopyClearCS.hlsl b/WickedEngine/shaders/voxelSceneCopyClearCS.hlsl index 9b193bc6e..1555d5538 100644 --- a/WickedEngine/shaders/voxelSceneCopyClearCS.hlsl +++ b/WickedEngine/shaders/voxelSceneCopyClearCS.hlsl @@ -11,7 +11,7 @@ void main( uint3 DTid : SV_DispatchThreadID ) const float4 color = UnpackVoxelColor(voxel.colorMask); - const uint3 writecoord = unflatten3D(DTid.x, g_xFrame_VoxelRadianceDataRes); + const uint3 writecoord = unflatten3D(DTid.x, g_xFrame.VoxelRadianceDataRes); [branch] if (color.a > 0) @@ -19,7 +19,7 @@ void main( uint3 DTid : SV_DispatchThreadID ) #ifdef TEMPORAL_SMOOTHING // Blend voxels with the previous frame's data to avoid popping artifacts for dynamic objects: [branch] - if (g_xFrame_Options & OPTION_BIT_VOXELGI_RETARGETTED) + if (g_xFrame.Options & OPTION_BIT_VOXELGI_RETARGETTED) { // Do not perform the blend if an offset happened to the voxel grid's center. // The offset is not accounted for in the blend operation which can introduce severe light leaking. diff --git a/WickedEngine/shaders/voxelVS.hlsl b/WickedEngine/shaders/voxelVS.hlsl index d28f2183f..05f32c684 100644 --- a/WickedEngine/shaders/voxelVS.hlsl +++ b/WickedEngine/shaders/voxelVS.hlsl @@ -12,9 +12,9 @@ VSOut main( uint vertexID : SV_VERTEXID ) { VSOut o; - uint3 coord = unflatten3D(vertexID, g_xFrame_VoxelRadianceDataRes); + uint3 coord = unflatten3D(vertexID, g_xFrame.VoxelRadianceDataRes); o.pos = float4(coord, 1); - o.col = texture_voxelradiance[coord]; + o.col = texture_voxelgi[coord]; return o; -} \ No newline at end of file +} diff --git a/WickedEngine/wiEmittedParticle.cpp b/WickedEngine/wiEmittedParticle.cpp index 291e38547..e3ead606f 100644 --- a/WickedEngine/wiEmittedParticle.cpp +++ b/WickedEngine/wiEmittedParticle.cpp @@ -67,7 +67,6 @@ void wiEmittedParticle::CreateSelfBuffers() GPUBufferDesc bd; bd.Usage = USAGE_DEFAULT; bd.BindFlags = BIND_SHADER_RESOURCE | BIND_UNORDERED_ACCESS; - bd.CPUAccessFlags = 0; bd.MiscFlags = RESOURCE_MISC_BUFFER_STRUCTURED; SubresourceData data; @@ -126,13 +125,13 @@ void wiEmittedParticle::CreateSelfBuffers() data.pSysMem = &counters; bd.ByteWidth = sizeof(counters); bd.StructureByteStride = sizeof(counters); - bd.MiscFlags = RESOURCE_MISC_BUFFER_ALLOW_RAW_VIEWS; + bd.MiscFlags = RESOURCE_MISC_BUFFER_RAW; wiRenderer::GetDevice()->CreateBuffer(&bd, &data, &counterBuffer); data.pSysMem = nullptr; // Indirect Execution buffer: bd.BindFlags = BIND_UNORDERED_ACCESS; - bd.MiscFlags = RESOURCE_MISC_BUFFER_ALLOW_RAW_VIEWS | RESOURCE_MISC_INDIRECT_ARGS; + bd.MiscFlags = RESOURCE_MISC_BUFFER_RAW | RESOURCE_MISC_INDIRECT_ARGS; bd.ByteWidth = sizeof(wiGraphics::IndirectDispatchArgs) + sizeof(wiGraphics::IndirectDispatchArgs) + @@ -143,17 +142,14 @@ void wiEmittedParticle::CreateSelfBuffers() bd.Usage = USAGE_DEFAULT; bd.ByteWidth = sizeof(EmittedParticleCB); bd.BindFlags = BIND_CONSTANT_BUFFER; - bd.CPUAccessFlags = 0; - bd.MiscFlags = 0; wiRenderer::GetDevice()->CreateBuffer(&bd, nullptr, &constantBuffer); // Debug information CPU-readback buffer: { GPUBufferDesc debugBufDesc = counterBuffer.GetDesc(); - debugBufDesc.Usage = USAGE_STAGING; - debugBufDesc.CPUAccessFlags = CPU_ACCESS_READ; - debugBufDesc.BindFlags = 0; - debugBufDesc.MiscFlags = 0; + debugBufDesc.Usage = USAGE_READBACK; + debugBufDesc.BindFlags = BIND_NONE; + debugBufDesc.MiscFlags = RESOURCE_MISC_NONE; for (int i = 0; i < arraysize(statisticsReadbackBuffer); ++i) { wiRenderer::GetDevice()->CreateBuffer(&debugBufDesc, nullptr, &statisticsReadbackBuffer[i]); @@ -207,16 +203,7 @@ void wiEmittedParticle::UpdateCPU(const TransformComponent& transform, float dt) if (statisticsReadBackIndex > arraysize(statisticsReadbackBuffer)) { const uint32_t oldest_stat_index = (statisticsReadBackIndex + 1) % arraysize(statisticsReadbackBuffer); - GraphicsDevice* device = wiRenderer::GetDevice(); - Mapping mapping; - mapping._flags = Mapping::FLAG_READ; - mapping.size = sizeof(statistics); - device->Map(&statisticsReadbackBuffer[oldest_stat_index], &mapping); - if (mapping.data != nullptr) - { - memcpy(&statistics, mapping.data, sizeof(statistics)); - device->Unmap(&statisticsReadbackBuffer[oldest_stat_index]); - } + memcpy(&statistics, statisticsReadbackBuffer[oldest_stat_index].mapped_data, sizeof(statistics)); } statisticsReadBackIndex++; } @@ -233,7 +220,7 @@ void wiEmittedParticle::Restart() SetPaused(false); } -void wiEmittedParticle::UpdateGPU(const TransformComponent& transform, const MaterialComponent& material, const MeshComponent* mesh, CommandList cmd) const +void wiEmittedParticle::UpdateGPU(uint32_t materialIndex, const TransformComponent& transform, const MeshComponent* mesh, CommandList cmd) const { if (!particleBuffer.IsValid()) { @@ -241,11 +228,10 @@ void wiEmittedParticle::UpdateGPU(const TransformComponent& transform, const Mat } GraphicsDevice* device = wiRenderer::GetDevice(); + device->EventBegin("UpdateEmittedParticles", cmd); if (!IsPaused()) { - device->EventBegin("UpdateEmittedParticles", cmd); - EmittedParticleCB cb; cb.xEmitterWorld = transform.world; cb.xEmitCount = (uint32_t)emit; @@ -260,9 +246,6 @@ void wiEmittedParticle::UpdateGPU(const TransformComponent& transform, const Mat cb.xParticleSize = size; cb.xParticleMotionBlurAmount = motionBlurAmount; cb.xParticleRotation = rotation * XM_PI * 60; - cb.xParticleColor = wiMath::CompressColor(XMFLOAT4(material.baseColor.x, material.baseColor.y, material.baseColor.z, 1)); - cb.xParticleEmissive = material.emissiveColor.w; - cb.xEmitterOpacity = material.GetOpacity(); cb.xParticleMass = mass; cb.xEmitterMaxParticleCount = MAX_PARTICLES; cb.xEmitterFixedTimestep = FIXED_TIMESTEP; @@ -276,6 +259,7 @@ void wiEmittedParticle::UpdateGPU(const TransformComponent& transform, const Mat XMStoreFloat3(&cb.xParticleVelocity, XMVector3TransformNormal(XMLoadFloat3(&velocity), XMLoadFloat4x4(&transform.world))); cb.xParticleRandomColorFactor = random_color; cb.xEmitterLayerMask = layerMask; + cb.xEmitterMaterialIndex = materialIndex; cb.xEmitterOptions = 0; if (IsSPHEnabled()) @@ -304,8 +288,21 @@ void wiEmittedParticle::UpdateGPU(const TransformComponent& transform, const Mat cb.xSPH_p0 = SPH_p0; cb.xSPH_e = SPH_e; + { + GPUBarrier barriers[] = { + GPUBarrier::Buffer(&constantBuffer, RESOURCE_STATE_CONSTANT_BUFFER, RESOURCE_STATE_COPY_DST), + }; + device->Barrier(barriers, arraysize(barriers), cmd); + } device->UpdateBuffer(&constantBuffer, &cb, cmd); - device->BindConstantBuffer(CS, &constantBuffer, CB_GETBINDSLOT(EmittedParticleCB), cmd); + { + GPUBarrier barriers[] = { + GPUBarrier::Buffer(&constantBuffer, RESOURCE_STATE_COPY_DST, RESOURCE_STATE_CONSTANT_BUFFER), + }; + device->Barrier(barriers, arraysize(barriers), cmd); + } + + device->BindConstantBuffer(&constantBuffer, CB_GETBINDSLOT(EmittedParticleCB), cmd); const GPUResource* uavs[] = { &particleBuffer, @@ -316,7 +313,7 @@ void wiEmittedParticle::UpdateGPU(const TransformComponent& transform, const Mat &indirectBuffers, &distanceBuffer, }; - device->BindUAVs(CS, uavs, 0, arraysize(uavs), cmd); + device->BindUAVs(uavs, 0, arraysize(uavs), cmd); if (mesh != nullptr) { @@ -324,18 +321,18 @@ void wiEmittedParticle::UpdateGPU(const TransformComponent& transform, const Mat &mesh->indexBuffer, (mesh->streamoutBuffer_POS.IsValid() ? &mesh->streamoutBuffer_POS : &mesh->vertexBuffer_POS), }; - device->BindResources(CS, resources, TEXSLOT_ONDEMAND0, arraysize(resources), cmd); + device->BindResources(resources, TEXSLOT_ONDEMAND0, arraysize(resources), cmd); { GPUBarrier barriers[] = { - GPUBarrier::Buffer(&mesh->indexBuffer, BUFFER_STATE_INDEX_BUFFER, BUFFER_STATE_SHADER_RESOURCE), + GPUBarrier::Buffer(&mesh->indexBuffer, RESOURCE_STATE_INDEX_BUFFER, RESOURCE_STATE_SHADER_RESOURCE), }; device->Barrier(barriers, arraysize(barriers), cmd); } } - GPUBarrier barrier_indirect_uav = GPUBarrier::Buffer(&indirectBuffers, BUFFER_STATE_INDIRECT_ARGUMENT, BUFFER_STATE_UNORDERED_ACCESS); - GPUBarrier barrier_uav_indirect = GPUBarrier::Buffer(&indirectBuffers, BUFFER_STATE_UNORDERED_ACCESS, BUFFER_STATE_INDIRECT_ARGUMENT); + GPUBarrier barrier_indirect_uav = GPUBarrier::Buffer(&indirectBuffers, RESOURCE_STATE_INDIRECT_ARGUMENT, RESOURCE_STATE_UNORDERED_ACCESS); + GPUBarrier barrier_uav_indirect = GPUBarrier::Buffer(&indirectBuffers, RESOURCE_STATE_UNORDERED_ACCESS, RESOURCE_STATE_INDIRECT_ARGUMENT); GPUBarrier barrier_memory = GPUBarrier::Memory(); device->Barrier(&barrier_indirect_uav, 1, cmd); @@ -367,17 +364,16 @@ void wiEmittedParticle::UpdateGPU(const TransformComponent& transform, const Mat // 1.) Assign particles into partitioning grid: device->EventBegin("Partitioning", cmd); device->BindComputeShader(&sphpartitionCS, cmd); - device->UnbindUAVs(0, 8, cmd); const GPUResource* res_partition[] = { &aliveList[0], // CURRENT alivelist &counterBuffer, &particleBuffer, }; - device->BindResources(CS, res_partition, 0, arraysize(res_partition), cmd); + device->BindResources(res_partition, 0, arraysize(res_partition), cmd); const GPUResource* uav_partition[] = { &sphPartitionCellIndices, }; - device->BindUAVs(CS, uav_partition, 0, arraysize(uav_partition), cmd); + device->BindUAVs(uav_partition, 0, arraysize(uav_partition), cmd); device->DispatchIndirect(&indirectBuffers, ARGUMENTBUFFER_OFFSET_DISPATCHSIMULATION, cmd); device->Barrier(&barrier_memory, 1, cmd); device->EventEnd(cmd); @@ -388,11 +384,10 @@ void wiEmittedParticle::UpdateGPU(const TransformComponent& transform, const Mat // 3.) Reset grid cell offset buffer with invalid offsets (max uint): device->EventBegin("PartitionOffsetsReset", cmd); device->BindComputeShader(&sphpartitionoffsetsresetCS, cmd); - device->UnbindUAVs(0, 8, cmd); const GPUResource* uav_partitionoffsets[] = { &sphPartitionCellOffsets, }; - device->BindUAVs(CS, uav_partitionoffsets, 0, arraysize(uav_partitionoffsets), cmd); + device->BindUAVs(uav_partitionoffsets, 0, arraysize(uav_partitionoffsets), cmd); device->Dispatch((uint32_t)ceilf((float)SPH_PARTITION_BUCKET_COUNT / (float)THREADCOUNT_SIMULATION), 1, 1, cmd); device->Barrier(&barrier_memory, 1, cmd); device->EventEnd(cmd); @@ -405,7 +400,7 @@ void wiEmittedParticle::UpdateGPU(const TransformComponent& transform, const Mat &counterBuffer, &sphPartitionCellIndices, }; - device->BindResources(CS, res_partitionoffsets, 0, arraysize(res_partitionoffsets), cmd); + device->BindResources(res_partitionoffsets, 0, arraysize(res_partitionoffsets), cmd); device->DispatchIndirect(&indirectBuffers, ARGUMENTBUFFER_OFFSET_DISPATCHSIMULATION, cmd); device->Barrier(&barrier_memory, 1, cmd); device->EventEnd(cmd); @@ -415,7 +410,6 @@ void wiEmittedParticle::UpdateGPU(const TransformComponent& transform, const Mat // 5.) Compute particle density field: device->EventBegin("Density Evaluation", cmd); device->BindComputeShader(&sphdensityCS, cmd); - device->UnbindUAVs(0, 8, cmd); const GPUResource* res_density[] = { &aliveList[0], // CURRENT alivelist &counterBuffer, @@ -423,11 +417,11 @@ void wiEmittedParticle::UpdateGPU(const TransformComponent& transform, const Mat &sphPartitionCellIndices, &sphPartitionCellOffsets, }; - device->BindResources(CS, res_density, 0, arraysize(res_density), cmd); + device->BindResources(res_density, 0, arraysize(res_density), cmd); const GPUResource* uav_density[] = { &densityBuffer }; - device->BindUAVs(CS, uav_density, 0, arraysize(uav_density), cmd); + device->BindUAVs(uav_density, 0, arraysize(uav_density), cmd); device->DispatchIndirect(&indirectBuffers, ARGUMENTBUFFER_OFFSET_DISPATCHSIMULATION, cmd); device->Barrier(&barrier_memory, 1, cmd); device->EventEnd(cmd); @@ -435,7 +429,6 @@ void wiEmittedParticle::UpdateGPU(const TransformComponent& transform, const Mat // 6.) Compute particle pressure forces: device->EventBegin("Force Evaluation", cmd); device->BindComputeShader(&sphforceCS, cmd); - device->UnbindUAVs(0, 8, cmd); const GPUResource* res_force[] = { &aliveList[0], // CURRENT alivelist &counterBuffer, @@ -443,17 +436,15 @@ void wiEmittedParticle::UpdateGPU(const TransformComponent& transform, const Mat &sphPartitionCellIndices, &sphPartitionCellOffsets, }; - device->BindResources(CS, res_force, 0, arraysize(res_force), cmd); + device->BindResources(res_force, 0, arraysize(res_force), cmd); const GPUResource* uav_force[] = { &particleBuffer, }; - device->BindUAVs(CS, uav_force, 0, arraysize(uav_force), cmd); + device->BindUAVs(uav_force, 0, arraysize(uav_force), cmd); device->DispatchIndirect(&indirectBuffers, ARGUMENTBUFFER_OFFSET_DISPATCHSIMULATION, cmd); device->Barrier(&barrier_memory, 1, cmd); device->EventEnd(cmd); - device->UnbindResources(0, 3, cmd); - device->UnbindUAVs(0, 8, cmd); device->EventEnd(cmd); @@ -461,7 +452,7 @@ void wiEmittedParticle::UpdateGPU(const TransformComponent& transform, const Mat } device->EventBegin("Simulate", cmd); - device->BindUAVs(CS, uavs, 0, arraysize(uavs), cmd); + device->BindUAVs(uavs, 0, arraysize(uavs), cmd); // update CURRENT alive list, write NEW alive list if (IsSorted()) @@ -490,11 +481,6 @@ void wiEmittedParticle::UpdateGPU(const TransformComponent& transform, const Mat device->Barrier(&barrier_memory, 1, cmd); device->EventEnd(cmd); - - device->UnbindUAVs(0, arraysize(uavs), cmd); - - device->EventEnd(cmd); - } if (IsSorted()) @@ -511,26 +497,24 @@ void wiEmittedParticle::UpdateGPU(const TransformComponent& transform, const Mat const GPUResource* res[] = { &counterBuffer, }; - device->BindResources(CS, res, TEXSLOT_ONDEMAND0, arraysize(res), cmd); + device->BindResources(res, TEXSLOT_ONDEMAND0, arraysize(res), cmd); const GPUResource* uavs[] = { &indirectBuffers, }; - device->BindUAVs(CS, uavs, 0, arraysize(uavs), cmd); + device->BindUAVs(uavs, 0, arraysize(uavs), cmd); { GPUBarrier barriers[] = { GPUBarrier::Memory(), - GPUBarrier::Buffer(&counterBuffer, BUFFER_STATE_UNORDERED_ACCESS, BUFFER_STATE_SHADER_RESOURCE), - GPUBarrier::Buffer(&indirectBuffers, BUFFER_STATE_INDIRECT_ARGUMENT, BUFFER_STATE_UNORDERED_ACCESS), + GPUBarrier::Buffer(&counterBuffer, RESOURCE_STATE_UNORDERED_ACCESS, RESOURCE_STATE_SHADER_RESOURCE), + GPUBarrier::Buffer(&indirectBuffers, RESOURCE_STATE_INDIRECT_ARGUMENT, RESOURCE_STATE_UNORDERED_ACCESS), }; device->Barrier(barriers, arraysize(barriers), cmd); } device->Dispatch(1, 1, 1, cmd); - device->UnbindUAVs(0, arraysize(uavs), cmd); - device->UnbindResources(TEXSLOT_ONDEMAND0, arraysize(res), cmd); device->EventEnd(cmd); } @@ -538,7 +522,7 @@ void wiEmittedParticle::UpdateGPU(const TransformComponent& transform, const Mat { GPUBarrier barriers[] = { GPUBarrier::Memory(), - GPUBarrier::Buffer(&counterBuffer, BUFFER_STATE_SHADER_RESOURCE, BUFFER_STATE_COPY_SRC), + GPUBarrier::Buffer(&counterBuffer, RESOURCE_STATE_SHADER_RESOURCE, RESOURCE_STATE_COPY_SRC), }; device->Barrier(barriers, arraysize(barriers), cmd); } @@ -548,10 +532,10 @@ void wiEmittedParticle::UpdateGPU(const TransformComponent& transform, const Mat { const GPUBarrier barriers[] = { - GPUBarrier::Buffer(&indirectBuffers, BUFFER_STATE_UNORDERED_ACCESS, BUFFER_STATE_INDIRECT_ARGUMENT), - GPUBarrier::Buffer(&counterBuffer, BUFFER_STATE_COPY_SRC, BUFFER_STATE_SHADER_RESOURCE), - GPUBarrier::Buffer(&particleBuffer, BUFFER_STATE_UNORDERED_ACCESS, BUFFER_STATE_SHADER_RESOURCE), - GPUBarrier::Buffer(&aliveList[1], BUFFER_STATE_UNORDERED_ACCESS, BUFFER_STATE_SHADER_RESOURCE), + GPUBarrier::Buffer(&indirectBuffers, RESOURCE_STATE_UNORDERED_ACCESS, RESOURCE_STATE_INDIRECT_ARGUMENT), + GPUBarrier::Buffer(&counterBuffer, RESOURCE_STATE_COPY_SRC, RESOURCE_STATE_SHADER_RESOURCE), + GPUBarrier::Buffer(&particleBuffer, RESOURCE_STATE_UNORDERED_ACCESS, RESOURCE_STATE_SHADER_RESOURCE), + GPUBarrier::Buffer(&aliveList[1], RESOURCE_STATE_UNORDERED_ACCESS, RESOURCE_STATE_SHADER_RESOURCE), }; device->Barrier(barriers, arraysize(barriers), cmd); } @@ -559,14 +543,16 @@ void wiEmittedParticle::UpdateGPU(const TransformComponent& transform, const Mat if (mesh != nullptr) { GPUBarrier barriers[] = { - GPUBarrier::Buffer(&mesh->indexBuffer, BUFFER_STATE_SHADER_RESOURCE, BUFFER_STATE_INDEX_BUFFER), + GPUBarrier::Buffer(&mesh->indexBuffer, RESOURCE_STATE_SHADER_RESOURCE, RESOURCE_STATE_INDEX_BUFFER), }; device->Barrier(barriers, arraysize(barriers), cmd); } + + device->EventEnd(cmd); } -void wiEmittedParticle::Draw(const CameraComponent& camera, const MaterialComponent& material, CommandList cmd) const +void wiEmittedParticle::Draw(const MaterialComponent& material, CommandList cmd) const { GraphicsDevice* device = wiRenderer::GetDevice(); device->EventBegin("EmittedParticle", cmd); @@ -579,20 +565,11 @@ void wiEmittedParticle::Draw(const CameraComponent& camera, const MaterialCompon { const BLENDMODE blendMode = material.GetBlendMode(); device->BindPipelineState(&PSO[blendMode][shaderType], cmd); - if (material.textures[MaterialComponent::BASECOLORMAP].resource == nullptr) - { - device->BindResource(PS, wiTextureHelper::getWhite(), TEXSLOT_ONDEMAND0, cmd); - } - else - { - device->BindResource(PS, material.textures[MaterialComponent::BASECOLORMAP].GetGPUResource(), TEXSLOT_ONDEMAND0, cmd); - } + device->BindShadingRate(material.shadingRate, cmd); } - device->BindConstantBuffer(VS, &constantBuffer, CB_GETBINDSLOT(EmittedParticleCB), cmd); - device->BindConstantBuffer(PS, &constantBuffer, CB_GETBINDSLOT(EmittedParticleCB), cmd); - device->BindConstantBuffer(PS, &material.constantBuffer, CB_GETBINDSLOT(MaterialCB), cmd); + device->BindConstantBuffer(&constantBuffer, CB_GETBINDSLOT(EmittedParticleCB), cmd); if (ALLOW_MESH_SHADER && device->CheckCapability(GRAPHICSDEVICE_CAPABILITY_MESH_SHADER)) { @@ -601,7 +578,7 @@ void wiEmittedParticle::Draw(const CameraComponent& camera, const MaterialCompon &particleBuffer, &aliveList[1], // NEW aliveList }; - device->BindResources(MS, res, TEXSLOT_ONDEMAND20, arraysize(res), cmd); + device->BindResources(res, TEXSLOT_ONDEMAND20, arraysize(res), cmd); device->DispatchMeshIndirect(&indirectBuffers, ARGUMENTBUFFER_OFFSET_DRAWPARTICLES, cmd); } else @@ -610,7 +587,7 @@ void wiEmittedParticle::Draw(const CameraComponent& camera, const MaterialCompon &particleBuffer, &aliveList[1] // NEW aliveList }; - device->BindResources(VS, res, TEXSLOT_ONDEMAND21, arraysize(res), cmd); + device->BindResources(res, TEXSLOT_ONDEMAND21, arraysize(res), cmd); device->DrawInstancedIndirect(&indirectBuffers, ARGUMENTBUFFER_OFFSET_DRAWPARTICLES, cmd); } diff --git a/WickedEngine/wiEmittedParticle.h b/WickedEngine/wiEmittedParticle.h index c21ba5f26..e1bdde1d0 100644 --- a/WickedEngine/wiEmittedParticle.h +++ b/WickedEngine/wiEmittedParticle.h @@ -57,8 +57,8 @@ public: void Restart(); // Must have a transform and material component, but mesh is optional - void UpdateGPU(const TransformComponent& transform, const MaterialComponent& material, const MeshComponent* mesh, wiGraphics::CommandList cmd) const; - void Draw(const CameraComponent& camera, const MaterialComponent& material, wiGraphics::CommandList cmd) const; + void UpdateGPU(uint32_t materialIndex, const TransformComponent& transform, const MeshComponent* mesh, wiGraphics::CommandList cmd) const; + void Draw(const MaterialComponent& material, wiGraphics::CommandList cmd) const; ParticleCounters GetStatistics() { return statistics; } diff --git a/WickedEngine/wiEnums.h b/WickedEngine/wiEnums.h index e0cf1cebd..a6a3bfaf6 100644 --- a/WickedEngine/wiEnums.h +++ b/WickedEngine/wiEnums.h @@ -13,8 +13,7 @@ enum BLENDMODE enum GBUFFER { - GBUFFER_COLOR, - GBUFFER_NORMAL_ROUGHNESS, + GBUFFER_PRIMITIVEID, GBUFFER_VELOCITY, GBUFFER_COUNT }; @@ -40,33 +39,6 @@ enum RENDERPASS RENDERPASS_COUNT }; -enum OBJECT_VERTEXINPUT -{ - INPUT_SLOT_POSITION_NORMAL_WIND, - INPUT_SLOT_PREVPOS, - INPUT_SLOT_UV0, - INPUT_SLOT_UV1, - INPUT_SLOT_ATLAS, - INPUT_SLOT_COLOR, - INPUT_SLOT_TANGENT, - INPUT_SLOT_INSTANCEDATA, - INPUT_SLOT_COUNT, -}; -enum INSTANCETYPE -{ - INSTANCETYPE_MATRIX_USERDATA, - INSTANCETYPE_MATRIX_USERDATA_ATLAS, - INSTANCETYPE_MATRIX_USERDATA_MATRIXPREV, -}; -static const INSTANCETYPE instanceTypes[RENDERPASS_COUNT] = { - INSTANCETYPE_MATRIX_USERDATA_ATLAS, // RENDERPASS_MAIN, - INSTANCETYPE_MATRIX_USERDATA_MATRIXPREV, // RENDERPASS_PREPASS, - INSTANCETYPE_MATRIX_USERDATA_ATLAS, // RENDERPASS_ENVMAPCAPTURE, - INSTANCETYPE_MATRIX_USERDATA, // RENDERPASS_SHADOW, - INSTANCETYPE_MATRIX_USERDATA, // RENDERPASS_SHADOWCUBE, - INSTANCETYPE_MATRIX_USERDATA_ATLAS, // RENDERPASS_VOXELIZE, -}; - // There are two different kinds of stencil refs: // ENGINE : managed by the engine systems (STENCILREF enum values between 0-15) // USER : managed by the user (raw numbers between 0-15) @@ -91,24 +63,6 @@ enum STENCILREF enum CBTYPES { CBTYPE_FRAME, - CBTYPE_CAMERA, - CBTYPE_MISC, - CBTYPE_VOLUMELIGHT, - CBTYPE_CUBEMAPRENDER, - CBTYPE_TESSELLATION, - CBTYPE_RAYTRACE, - CBTYPE_MIPGEN, - CBTYPE_FILTERENVMAP, - CBTYPE_COPYTEXTURE, - CBTYPE_FORWARDENTITYMASK, - CBTYPE_POSTPROCESS, - CBTYPE_POSTPROCESS_FSR, - CBTYPE_POSTPROCESS_MSAO, - CBTYPE_POSTPROCESS_MSAO_UPSAMPLE, - CBTYPE_LENSFLARE, - CBTYPE_PAINTRADIUS, - CBTYPE_SHADINGRATECLASSIFICATION, - CBTYPE_VOLUMETRICCLOUDS, CBTYPE_COUNT }; @@ -220,7 +174,6 @@ enum SHADERTYPE PSTYPE_VOLUMETRICLIGHT_SPOT, PSTYPE_SKY_STATIC, PSTYPE_SKY_DYNAMIC, - PSTYPE_SKY_VELOCITY, PSTYPE_SUN, PSTYPE_ENVMAP, PSTYPE_ENVMAP_TERRAIN, @@ -301,7 +254,6 @@ enum SHADERTYPE CSTYPE_COPYTEXTURE2D_UNORM4_BORDEREXPAND, CSTYPE_COPYTEXTURE2D_FLOAT4_BORDEREXPAND, CSTYPE_SKINNING, - CSTYPE_SKINNING_LDS, CSTYPE_RAYTRACE, CSTYPE_PAINT_TEXTURE, CSTYPE_POSTPROCESS_BLUR_GAUSSIAN_FLOAT1, @@ -368,7 +320,6 @@ enum SHADERTYPE CSTYPE_POSTPROCESS_VOLUMETRICCLOUDS_TEMPORAL, CSTYPE_POSTPROCESS_FXAA, CSTYPE_POSTPROCESS_TEMPORALAA, - CSTYPE_POSTPROCESS_LINEARDEPTH, CSTYPE_POSTPROCESS_SHARPEN, CSTYPE_POSTPROCESS_TONEMAP, CSTYPE_POSTPROCESS_FSR_UPSCALING, @@ -389,6 +340,16 @@ enum SHADERTYPE CSTYPE_POSTPROCESS_RTAO, CSTYPE_POSTPROCESS_RTAO_DENOISE_TILECLASSIFICATION, CSTYPE_POSTPROCESS_RTAO_DENOISE_FILTER, + CSTYPE_SURFEL_COVERAGE, + CSTYPE_SURFEL_INDIRECTPREPARE, + CSTYPE_SURFEL_RAYTRACE, + CSTYPE_SURFEL_SHADE, + CSTYPE_SURFEL_UPDATE, + CSTYPE_SURFEL_GRIDRESET, + CSTYPE_SURFEL_GRIDOFFSETS, + CSTYPE_SURFEL_BINNING, + CSTYPE_VISIBILITY_RESOLVE, + CSTYPE_VISIBILITY_RESOLVE_MSAA, // raytracing pipelines: @@ -401,11 +362,6 @@ enum SHADERTYPE // input layouts enum ILTYPES { - ILTYPE_OBJECT_POS, - ILTYPE_OBJECT_POS_TEX, - ILTYPE_OBJECT_POS_PREVPOS, - ILTYPE_OBJECT_POS_PREVPOS_TEX, - ILTYPE_OBJECT_COMMON, ILTYPE_OBJECT_DEBUG, ILTYPE_RENDERLIGHTMAP, ILTYPE_VERTEXCOLOR, diff --git a/WickedEngine/wiFFTGenerator.cpp b/WickedEngine/wiFFTGenerator.cpp index 2494a9e73..c12e95d3b 100644 --- a/WickedEngine/wiFFTGenerator.cpp +++ b/WickedEngine/wiFFTGenerator.cpp @@ -37,10 +37,10 @@ namespace wiFFTGenerator // Buffers const GPUResource* srvs[1] = { &pSRV_Src }; - device->BindResources(CS, srvs, TEXSLOT_ONDEMAND0, 1, cmd); + device->BindResources(srvs, TEXSLOT_ONDEMAND0, 1, cmd); const GPUResource* uavs[1] = { &pUAV_Dst }; - device->BindUAVs(CS, uavs, 0, arraysize(uavs), cmd); + device->BindUAVs(uavs, 0, arraysize(uavs), cmd); // Shader if (istride > 1) @@ -61,8 +61,6 @@ namespace wiFFTGenerator device->Barrier(barriers, arraysize(barriers), cmd); // Unbind resource - device->UnbindResources(TEXSLOT_ONDEMAND0, 1, cmd); - device->UnbindUAVs(0, 1, cmd); } void fft_512x512_c2c( @@ -78,32 +76,32 @@ namespace wiFFTGenerator uint32_t istride = 512 * 512 / 8; cs_cbs = &fft_plan.pRadix008A_CB[0]; - device->BindConstantBuffer(CS, cs_cbs, CB_GETBINDSLOT(FFTGeneratorCB), cmd); + device->BindConstantBuffer(cs_cbs, CB_GETBINDSLOT(FFTGeneratorCB), cmd); radix008A(fft_plan, fft_plan.pBuffer_Tmp, pSRV_Src, thread_count, istride, cmd); istride /= 8; cs_cbs = &fft_plan.pRadix008A_CB[1]; - device->BindConstantBuffer(CS, cs_cbs, CB_GETBINDSLOT(FFTGeneratorCB), cmd); + device->BindConstantBuffer(cs_cbs, CB_GETBINDSLOT(FFTGeneratorCB), cmd); radix008A(fft_plan, pUAV_Dst, fft_plan.pBuffer_Tmp, thread_count, istride, cmd); istride /= 8; cs_cbs = &fft_plan.pRadix008A_CB[2]; - device->BindConstantBuffer(CS, cs_cbs, CB_GETBINDSLOT(FFTGeneratorCB), cmd); + device->BindConstantBuffer(cs_cbs, CB_GETBINDSLOT(FFTGeneratorCB), cmd); radix008A(fft_plan, fft_plan.pBuffer_Tmp, pSRV_Dst, thread_count, istride, cmd); istride /= 8; cs_cbs = &fft_plan.pRadix008A_CB[3]; - device->BindConstantBuffer(CS, cs_cbs, CB_GETBINDSLOT(FFTGeneratorCB), cmd); + device->BindConstantBuffer(cs_cbs, CB_GETBINDSLOT(FFTGeneratorCB), cmd); radix008A(fft_plan, pUAV_Dst, fft_plan.pBuffer_Tmp, thread_count, istride, cmd); istride /= 8; cs_cbs = &fft_plan.pRadix008A_CB[4]; - device->BindConstantBuffer(CS, cs_cbs, CB_GETBINDSLOT(FFTGeneratorCB), cmd); + device->BindConstantBuffer(cs_cbs, CB_GETBINDSLOT(FFTGeneratorCB), cmd); radix008A(fft_plan, fft_plan.pBuffer_Tmp, pSRV_Dst, thread_count, istride, cmd); istride /= 8; cs_cbs = &fft_plan.pRadix008A_CB[5]; - device->BindConstantBuffer(CS, cs_cbs, CB_GETBINDSLOT(FFTGeneratorCB), cmd); + device->BindConstantBuffer(cs_cbs, CB_GETBINDSLOT(FFTGeneratorCB), cmd); radix008A(fft_plan, pUAV_Dst, fft_plan.pBuffer_Tmp, thread_count, istride, cmd); } @@ -112,10 +110,7 @@ namespace wiFFTGenerator // Create 6 cbuffers for 512x512 transform. GPUBufferDesc cb_desc; - cb_desc.Usage = USAGE_IMMUTABLE; cb_desc.BindFlags = BIND_CONSTANT_BUFFER; - cb_desc.CPUAccessFlags = 0; - cb_desc.MiscFlags = 0; cb_desc.ByteWidth = sizeof(FFTGeneratorCB); cb_desc.StructureByteStride = 0; @@ -196,7 +191,6 @@ namespace wiFFTGenerator buf_desc.ByteWidth = sizeof(float) * 2 * (512 * slices) * 512; buf_desc.Usage = USAGE_DEFAULT; buf_desc.BindFlags = BIND_UNORDERED_ACCESS | BIND_SHADER_RESOURCE; - buf_desc.CPUAccessFlags = 0; buf_desc.MiscFlags = RESOURCE_MISC_BUFFER_STRUCTURED; buf_desc.StructureByteStride = sizeof(float) * 2; diff --git a/WickedEngine/wiFont.cpp b/WickedEngine/wiFont.cpp index 1c126a42e..5bf7ce5cb 100644 --- a/WickedEngine/wiFont.cpp +++ b/WickedEngine/wiFont.cpp @@ -30,7 +30,6 @@ using namespace wiRectPacker; namespace wiFont_Internal { - GPUBuffer constantBuffer; BlendState blendState; RasterizerState rasterizerState; DepthStencilState depthStencilState; @@ -282,18 +281,6 @@ void Initialize() GraphicsDevice* device = wiRenderer::GetDevice(); - { - GPUBufferDesc bd; - bd.Usage = USAGE_DYNAMIC; - bd.ByteWidth = sizeof(FontCB); - bd.BindFlags = BIND_CONSTANT_BUFFER; - bd.CPUAccessFlags = CPU_ACCESS_WRITE; - - device->CreateBuffer(&bd, nullptr, &constantBuffer); - } - - - RasterizerState rs; rs.FillMode = FILL_SOLID; rs.CullMode = CULL_FRONT; @@ -597,22 +584,10 @@ void Draw_internal(const T* text, size_t text_length, const wiFontParams& params device->BindPipelineState(&PSO, cmd); - device->BindConstantBuffer(VS, &constantBuffer, CB_GETBINDSLOT(FontCB), cmd); - device->BindConstantBuffer(PS, &constantBuffer, CB_GETBINDSLOT(FontCB), cmd); - - FontCB cb; - cb.g_xFont_BufferOffset = mem.offset; - - if (device->CheckCapability(GRAPHICSDEVICE_CAPABILITY_BINDLESS_DESCRIPTORS)) - { - cb.g_xFont_TextureIndex = device->GetDescriptorIndex(&texture, SRV); - } - else - { - device->BindResource(PS, &texture, TEXSLOT_FONTATLAS, cmd); - } - - device->BindResource(VS, mem.buffer, 0, cmd); + PushConstantsFont push; + push.buffer_index = device->GetDescriptorIndex(&mem.buffer, SRV); + push.buffer_offset = mem.offset; + push.texture_index = device->GetDescriptorIndex(&texture, SRV); const wiCanvas& canvas = canvases[cmd]; // Asserts will check that a proper canvas was set for this cmd with wiImage::SetCanvas() @@ -625,24 +600,24 @@ void Draw_internal(const T* text, size_t text_length, const wiFontParams& params if (newProps.shadowColor.getA() > 0) { // font shadow render: - XMStoreFloat4x4(&cb.g_xFont_Transform, + XMStoreFloat4x4(&push.transform, XMMatrixTranslation((float)newProps.posX + 1, (float)newProps.posY + 1, 0) * Projection ); - cb.g_xFont_Color = newProps.shadowColor.toFloat4(); - device->UpdateBuffer(&constantBuffer, &cb, cmd); + push.color = newProps.shadowColor.rgba; + device->PushConstants(&push, sizeof(push), cmd); device->DrawInstanced(4, quadCount, 0, 0, cmd); } // font base render: - XMStoreFloat4x4(&cb.g_xFont_Transform, + XMStoreFloat4x4(&push.transform, XMMatrixTranslation((float)newProps.posX, (float)newProps.posY, 0) * Projection ); - cb.g_xFont_Color = newProps.color.toFloat4(); - device->UpdateBuffer(&constantBuffer, &cb, cmd); + push.color = newProps.color.rgba; + device->PushConstants(&push, sizeof(push), cmd); device->DrawInstanced(4, quadCount, 0, 0, cmd); device->EventEnd(cmd); diff --git a/WickedEngine/wiGPUBVH.cpp b/WickedEngine/wiGPUBVH.cpp index 49a4a9d0f..397cd4ace 100644 --- a/WickedEngine/wiGPUBVH.cpp +++ b/WickedEngine/wiGPUBVH.cpp @@ -26,224 +26,19 @@ enum CSTYPES_BVH CSTYPE_BVH_COUNT }; static Shader computeShaders[CSTYPE_BVH_COUNT]; -static GPUBuffer constantBuffer; - -static const int atlasWrapBorder = 1; - -void wiGPUBVH::UpdateGlobalMaterialResources(const Scene& scene) -{ - GraphicsDevice* device = wiRenderer::GetDevice(); - - using namespace wiRectPacker; - - for (size_t i = 0; i < scene.objects.GetCount(); ++i) - { - const ObjectComponent& object = scene.objects[i]; - - if (object.meshID != INVALID_ENTITY) - { - const MeshComponent& mesh = *scene.meshes.GetComponent(object.meshID); - - for (auto& subset : mesh.subsets) - { - const MaterialComponent& material = *scene.materials.GetComponent(subset.materialID); - - if (material.textures[MaterialComponent::BASECOLORMAP].resource != nullptr) - { - sceneTextures.insert(material.textures[MaterialComponent::BASECOLORMAP].resource); - } - if (material.textures[MaterialComponent::SURFACEMAP].resource != nullptr) - { - sceneTextures.insert(material.textures[MaterialComponent::SURFACEMAP].resource); - } - if (material.textures[MaterialComponent::EMISSIVEMAP].resource != nullptr) - { - sceneTextures.insert(material.textures[MaterialComponent::EMISSIVEMAP].resource); - } - if (material.textures[MaterialComponent::NORMALMAP].resource != nullptr) - { - sceneTextures.insert(material.textures[MaterialComponent::NORMALMAP].resource); - } - } - } - - } - - repackAtlas = false; - for (auto res : sceneTextures) - { - if (res == nullptr) - { - continue; - } - - if (storedTextures.find(res) == storedTextures.end()) - { - // we need to pack this texture into the atlas - rect_xywh newRect = rect_xywh(0, 0, res->texture.desc.Width + atlasWrapBorder * 2, res->texture.desc.Height + atlasWrapBorder * 2); - storedTextures[res] = newRect; - - repackAtlas = true; - } - - } - - if (repackAtlas) - { - std::vector out_rects(storedTextures.size()); - int i = 0; - for (auto& it : storedTextures) - { - out_rects[i] = &it.second; - i++; - } - - std::vector bins; - if (pack(out_rects.data(), (int)storedTextures.size(), 16384, bins)) - { - assert(bins.size() == 1 && "The regions won't fit into the texture!"); - - TextureDesc desc; - desc.Width = (uint32_t)bins[0].size.w; - desc.Height = (uint32_t)bins[0].size.h; - desc.MipLevels = 1; - desc.ArraySize = 1; - desc.Format = FORMAT_R8G8B8A8_UNORM; - desc.SampleCount = 1; - desc.Usage = USAGE_DEFAULT; - desc.BindFlags = BIND_SHADER_RESOURCE | BIND_UNORDERED_ACCESS; - desc.CPUAccessFlags = 0; - desc.MiscFlags = 0; - - device->CreateTexture(&desc, nullptr, &globalMaterialAtlas); - device->SetName(&globalMaterialAtlas, "globalMaterialAtlas"); - } - else - { - wiBackLog::post("Tracing atlas packing failed!"); - } - } - - materialArray.clear(); - - // Pre-gather scene properties: - for (size_t i = 0; i < scene.objects.GetCount(); ++i) - { - const ObjectComponent& object = scene.objects[i]; - - if (object.meshID != INVALID_ENTITY) - { - const MeshComponent& mesh = *scene.meshes.GetComponent(object.meshID); - - for (auto& subset : mesh.subsets) - { - const MaterialComponent& material = *scene.materials.GetComponent(subset.materialID); - ShaderMaterial global_material; - material.WriteShaderMaterial(&global_material); - - // Add extended properties: - const TextureDesc& desc = globalMaterialAtlas.GetDesc(); - - if (material.textures[MaterialComponent::BASECOLORMAP].resource != nullptr) - { - rect_xywh rect = storedTextures[material.textures[MaterialComponent::BASECOLORMAP].resource]; - // eliminate border expansion: - rect.x += atlasWrapBorder; - rect.y += atlasWrapBorder; - rect.w -= atlasWrapBorder * 2; - rect.h -= atlasWrapBorder * 2; - global_material.baseColorAtlasMulAdd = XMFLOAT4((float)rect.w / (float)desc.Width, (float)rect.h / (float)desc.Height, - (float)rect.x / (float)desc.Width, (float)rect.y / (float)desc.Height); - } - - if (material.textures[MaterialComponent::SURFACEMAP].resource != nullptr) - { - rect_xywh rect = storedTextures[material.textures[MaterialComponent::SURFACEMAP].resource]; - // eliminate border expansion: - rect.x += atlasWrapBorder; - rect.y += atlasWrapBorder; - rect.w -= atlasWrapBorder * 2; - rect.h -= atlasWrapBorder * 2; - global_material.surfaceMapAtlasMulAdd = XMFLOAT4((float)rect.w / (float)desc.Width, (float)rect.h / (float)desc.Height, - (float)rect.x / (float)desc.Width, (float)rect.y / (float)desc.Height); - } - - if (material.textures[MaterialComponent::EMISSIVEMAP].resource != nullptr) - { - rect_xywh rect = storedTextures[material.textures[MaterialComponent::EMISSIVEMAP].resource]; - // eliminate border expansion: - rect.x += atlasWrapBorder; - rect.y += atlasWrapBorder; - rect.w -= atlasWrapBorder * 2; - rect.h -= atlasWrapBorder * 2; - global_material.emissiveMapAtlasMulAdd = XMFLOAT4((float)rect.w / (float)desc.Width, (float)rect.h / (float)desc.Height, - (float)rect.x / (float)desc.Width, (float)rect.y / (float)desc.Height); - } - - if (material.textures[MaterialComponent::NORMALMAP].resource != nullptr) - { - rect_xywh rect = storedTextures[material.textures[MaterialComponent::NORMALMAP].resource]; - // eliminate border expansion: - rect.x += atlasWrapBorder; - rect.y += atlasWrapBorder; - rect.w -= atlasWrapBorder * 2; - rect.h -= atlasWrapBorder * 2; - global_material.normalMapAtlasMulAdd = XMFLOAT4((float)rect.w / (float)desc.Width, (float)rect.h / (float)desc.Height, - (float)rect.x / (float)desc.Width, (float)rect.y / (float)desc.Height); - } - - materialArray.push_back(global_material); - } - } - } - - if (materialArray.empty()) - { - return; - } - - if (globalMaterialBuffer.GetDesc().ByteWidth != sizeof(ShaderMaterial) * materialArray.size()) - { - GPUBufferDesc desc; - - desc.BindFlags = BIND_SHADER_RESOURCE; - desc.StructureByteStride = sizeof(ShaderMaterial); - desc.ByteWidth = desc.StructureByteStride * (uint32_t)materialArray.size(); - desc.CPUAccessFlags = 0; - desc.Format = FORMAT_UNKNOWN; - desc.MiscFlags = RESOURCE_MISC_BUFFER_STRUCTURED; - desc.Usage = USAGE_DEFAULT; - - device->CreateBuffer(&desc, nullptr, &globalMaterialBuffer); - } - -} void wiGPUBVH::Update(const wiScene::Scene& scene) { GraphicsDevice* device = wiRenderer::GetDevice(); - if (!constantBuffer.IsValid()) - { - GPUBufferDesc bd; - bd.Usage = USAGE_DYNAMIC; - bd.CPUAccessFlags = CPU_ACCESS_WRITE; - bd.BindFlags = BIND_CONSTANT_BUFFER; - bd.ByteWidth = sizeof(BVHCB); - - device->CreateBuffer(&bd, nullptr, &constantBuffer); - device->SetName(&constantBuffer, "BVHGeneratorCB"); - } - if (!primitiveCounterBuffer.IsValid()) { GPUBufferDesc desc; desc.BindFlags = BIND_SHADER_RESOURCE; desc.StructureByteStride = sizeof(uint); desc.ByteWidth = desc.StructureByteStride; - desc.CPUAccessFlags = 0; desc.Format = FORMAT_UNKNOWN; - desc.MiscFlags = RESOURCE_MISC_BUFFER_ALLOW_RAW_VIEWS; + desc.MiscFlags = RESOURCE_MISC_BUFFER_RAW; desc.Usage = USAGE_DEFAULT; device->CreateBuffer(&desc, nullptr, &primitiveCounterBuffer); device->SetName(&primitiveCounterBuffer, "primitiveCounterBuffer"); @@ -262,6 +57,15 @@ void wiGPUBVH::Update(const wiScene::Scene& scene) totalTriangles += (uint)mesh.indices.size() / 3; } } + for (size_t i = 0; i < scene.hairs.GetCount(); ++i) + { + const wiHairParticle& hair = scene.hairs[i]; + + if (hair.meshID != INVALID_ENTITY) + { + totalTriangles += hair.segmentCount * hair.strandCount * 2; + } + } if (totalTriangles > primitiveCapacity) { @@ -272,7 +76,6 @@ void wiGPUBVH::Update(const wiScene::Scene& scene) desc.BindFlags = BIND_SHADER_RESOURCE | BIND_UNORDERED_ACCESS; desc.StructureByteStride = sizeof(BVHNode); desc.ByteWidth = desc.StructureByteStride * primitiveCapacity * 2; - desc.CPUAccessFlags = 0; desc.Format = FORMAT_UNKNOWN; desc.MiscFlags = RESOURCE_MISC_BUFFER_STRUCTURED; desc.Usage = USAGE_DEFAULT; @@ -282,7 +85,6 @@ void wiGPUBVH::Update(const wiScene::Scene& scene) desc.BindFlags = BIND_SHADER_RESOURCE | BIND_UNORDERED_ACCESS; desc.StructureByteStride = sizeof(uint); desc.ByteWidth = desc.StructureByteStride * primitiveCapacity * 2; - desc.CPUAccessFlags = 0; desc.Format = FORMAT_UNKNOWN; desc.MiscFlags = RESOURCE_MISC_BUFFER_STRUCTURED; desc.Usage = USAGE_DEFAULT; @@ -292,7 +94,6 @@ void wiGPUBVH::Update(const wiScene::Scene& scene) desc.BindFlags = BIND_SHADER_RESOURCE | BIND_UNORDERED_ACCESS; desc.StructureByteStride = sizeof(uint); desc.ByteWidth = desc.StructureByteStride * (((primitiveCapacity - 1) + 31) / 32); // bitfield for internal nodes - desc.CPUAccessFlags = 0; desc.Format = FORMAT_UNKNOWN; desc.MiscFlags = RESOURCE_MISC_BUFFER_STRUCTURED; desc.Usage = USAGE_DEFAULT; @@ -302,7 +103,6 @@ void wiGPUBVH::Update(const wiScene::Scene& scene) desc.BindFlags = BIND_SHADER_RESOURCE | BIND_UNORDERED_ACCESS; desc.StructureByteStride = sizeof(uint); desc.ByteWidth = desc.StructureByteStride * primitiveCapacity; - desc.CPUAccessFlags = 0; desc.Format = FORMAT_UNKNOWN; desc.MiscFlags = RESOURCE_MISC_BUFFER_STRUCTURED; desc.Usage = USAGE_DEFAULT; @@ -312,7 +112,6 @@ void wiGPUBVH::Update(const wiScene::Scene& scene) desc.BindFlags = BIND_SHADER_RESOURCE | BIND_UNORDERED_ACCESS; desc.StructureByteStride = sizeof(BVHPrimitive); desc.ByteWidth = desc.StructureByteStride * primitiveCapacity; - desc.CPUAccessFlags = 0; desc.Format = FORMAT_UNKNOWN; desc.MiscFlags = RESOURCE_MISC_BUFFER_STRUCTURED; desc.Usage = USAGE_DEFAULT; @@ -320,18 +119,7 @@ void wiGPUBVH::Update(const wiScene::Scene& scene) device->SetName(&primitiveBuffer, "primitiveBuffer"); desc.BindFlags = BIND_SHADER_RESOURCE | BIND_UNORDERED_ACCESS; - desc.StructureByteStride = sizeof(BVHPrimitiveData); desc.ByteWidth = desc.StructureByteStride * primitiveCapacity; - desc.CPUAccessFlags = 0; - desc.Format = FORMAT_UNKNOWN; - desc.MiscFlags = RESOURCE_MISC_BUFFER_STRUCTURED; - desc.Usage = USAGE_DEFAULT; - device->CreateBuffer(&desc, nullptr, &primitiveDataBuffer); - device->SetName(&primitiveDataBuffer, "primitiveDataBuffer"); - - desc.BindFlags = BIND_SHADER_RESOURCE | BIND_UNORDERED_ACCESS; - desc.ByteWidth = desc.StructureByteStride * primitiveCapacity; - desc.CPUAccessFlags = 0; desc.Format = FORMAT_UNKNOWN; desc.MiscFlags = RESOURCE_MISC_BUFFER_STRUCTURED; desc.Usage = USAGE_DEFAULT; @@ -339,40 +127,14 @@ void wiGPUBVH::Update(const wiScene::Scene& scene) device->CreateBuffer(&desc, nullptr, &primitiveMortonBuffer); device->SetName(&primitiveMortonBuffer, "primitiveMortonBuffer"); } - - UpdateGlobalMaterialResources(scene); } void wiGPUBVH::Build(const Scene& scene, CommandList cmd) const { GraphicsDevice* device = wiRenderer::GetDevice(); - // Pre-gather scene properties: - uint totalTriangles = 0; - for (size_t i = 0; i < scene.objects.GetCount(); ++i) - { - const ObjectComponent& object = scene.objects[i]; - - if (object.meshID != INVALID_ENTITY) - { - const MeshComponent& mesh = *scene.meshes.GetComponent(object.meshID); - - totalTriangles += (uint)mesh.indices.size() / 3; - } - } - auto range = wiProfiler::BeginRangeGPU("BVH Rebuild", cmd); - if (repackAtlas) - { - for (auto& it : storedTextures) - { - wiRenderer::CopyTexture2D(globalMaterialAtlas, -1, it.second.x + atlasWrapBorder, it.second.y + atlasWrapBorder, it.first->texture, 0, cmd, wiRenderer::BORDEREXPAND_WRAP); - } - } - device->UpdateBuffer(&globalMaterialBuffer, materialArray.data(), cmd, sizeof(ShaderMaterial) * (int)materialArray.size()); - uint32_t primitiveCount = 0; - uint32_t materialCount = 0; device->EventBegin("BVH - Primitive Builder", cmd); { @@ -380,10 +142,9 @@ void wiGPUBVH::Build(const Scene& scene, CommandList cmd) const const GPUResource* uavs[] = { &primitiveIDBuffer, &primitiveBuffer, - &primitiveDataBuffer, &primitiveMortonBuffer, }; - device->BindUAVs(CS, uavs, 0, arraysize(uavs), cmd); + device->BindUAVs(uavs, 0, arraysize(uavs), cmd); for (size_t i = 0; i < scene.objects.GetCount(); ++i) { @@ -393,34 +154,51 @@ void wiGPUBVH::Build(const Scene& scene, CommandList cmd) const { const MeshComponent& mesh = *scene.meshes.GetComponent(object.meshID); - BVHCB cb; - cb.xBVHWorld = object.transform_index >= 0 ? scene.transforms[object.transform_index].world : IDENTITYMATRIX; - cb.xBVHInstanceColor = object.color; - cb.xBVHMaterialOffset = materialCount; - cb.xBVHMeshTriangleOffset = primitiveCount; - cb.xBVHMeshTriangleCount = (uint)mesh.indices.size() / 3; - cb.xBVHMeshVertexPOSStride = sizeof(MeshComponent::Vertex_POS); + for (size_t j = 0; j < mesh.subsets.size(); ++j) + { + auto& subset = mesh.subsets[j]; - device->UpdateBuffer(&constantBuffer, &cb, cmd); + BVHPushConstants push; + push.instanceIndex = (uint)i; + push.subsetIndex = (uint)j; + push.primitiveCount = subset.indexCount / 3; + push.primitiveOffset = primitiveCount; + device->PushConstants(&push, sizeof(push), cmd); - primitiveCount += cb.xBVHMeshTriangleCount; + primitiveCount += push.primitiveCount; - device->BindConstantBuffer(CS, &constantBuffer, CB_GETBINDSLOT(BVHCB), cmd); + device->Dispatch( + (push.primitiveCount + BVH_BUILDER_GROUPSIZE - 1) / BVH_BUILDER_GROUPSIZE, + 1, + 1, + cmd + ); + } - const GPUResource* res[] = { - &globalMaterialBuffer, - &mesh.indexBuffer, - mesh.streamoutBuffer_POS.IsValid() ? &mesh.streamoutBuffer_POS : &mesh.vertexBuffer_POS, - &mesh.vertexBuffer_UV0, - &mesh.vertexBuffer_UV1, - &mesh.vertexBuffer_COL, - &mesh.vertexBuffer_SUB, - }; - device->BindResources(CS, res, TEXSLOT_ONDEMAND0, arraysize(res), cmd); + } + } - device->Dispatch((cb.xBVHMeshTriangleCount + BVH_BUILDER_GROUPSIZE - 1) / BVH_BUILDER_GROUPSIZE, 1, 1, cmd); + for (size_t i = 0; i < scene.hairs.GetCount(); ++i) + { + const wiHairParticle& hair = scene.hairs[i]; - materialCount += (uint32_t)mesh.subsets.size(); + if (hair.meshID != INVALID_ENTITY) + { + BVHPushConstants push; + push.instanceIndex = (uint)(scene.objects.GetCount() + i); + push.subsetIndex = 0; + push.primitiveCount = hair.segmentCount * hair.strandCount * 2; + push.primitiveOffset = primitiveCount; + device->PushConstants(&push, sizeof(push), cmd); + + primitiveCount += push.primitiveCount; + + device->Dispatch( + (push.primitiveCount + BVH_BUILDER_GROUPSIZE - 1) / BVH_BUILDER_GROUPSIZE, + 1, + 1, + cmd + ); } } @@ -428,9 +206,22 @@ void wiGPUBVH::Build(const Scene& scene, CommandList cmd) const GPUBarrier::Memory() }; device->Barrier(barriers, arraysize(barriers), cmd); - device->UnbindUAVs(0, arraysize(uavs), cmd); + } + + { + GPUBarrier barriers[] = { + GPUBarrier::Buffer(&primitiveCounterBuffer, RESOURCE_STATE_SHADER_RESOURCE, RESOURCE_STATE_COPY_DST), + }; + device->Barrier(barriers, arraysize(barriers), cmd); } device->UpdateBuffer(&primitiveCounterBuffer, &primitiveCount, cmd); + { + GPUBarrier barriers[] = { + GPUBarrier::Buffer(&primitiveCounterBuffer, RESOURCE_STATE_COPY_DST, RESOURCE_STATE_SHADER_RESOURCE), + }; + device->Barrier(barriers, arraysize(barriers), cmd); + } + device->EventEnd(cmd); device->EventBegin("BVH - Sort Primitive Mortons", cmd); @@ -445,14 +236,14 @@ void wiGPUBVH::Build(const Scene& scene, CommandList cmd) const &bvhParentBuffer, &bvhFlagBuffer }; - device->BindUAVs(CS, uavs, 0, arraysize(uavs), cmd); + device->BindUAVs(uavs, 0, arraysize(uavs), cmd); const GPUResource* res[] = { &primitiveCounterBuffer, &primitiveIDBuffer, &primitiveMortonBuffer, }; - device->BindResources(CS, res, TEXSLOT_ONDEMAND0, arraysize(res), cmd); + device->BindResources(res, TEXSLOT_ONDEMAND0, arraysize(res), cmd); device->Dispatch((primitiveCount + BVH_BUILDER_GROUPSIZE - 1) / BVH_BUILDER_GROUPSIZE, 1, 1, cmd); @@ -460,7 +251,6 @@ void wiGPUBVH::Build(const Scene& scene, CommandList cmd) const GPUBarrier::Memory() }; device->Barrier(barriers, arraysize(barriers), cmd); - device->UnbindUAVs(0, arraysize(uavs), cmd); } device->EventEnd(cmd); @@ -476,7 +266,7 @@ void wiGPUBVH::Build(const Scene& scene, CommandList cmd) const &bvhNodeBuffer, &bvhFlagBuffer, }; - device->BindUAVs(CS, uavs, 0, arraysize(uavs), cmd); + device->BindUAVs(uavs, 0, arraysize(uavs), cmd); const GPUResource* res[] = { &primitiveCounterBuffer, @@ -484,12 +274,11 @@ void wiGPUBVH::Build(const Scene& scene, CommandList cmd) const &primitiveBuffer, &bvhParentBuffer, }; - device->BindResources(CS, res, TEXSLOT_ONDEMAND0, arraysize(res), cmd); + device->BindResources(res, TEXSLOT_ONDEMAND0, arraysize(res), cmd); device->Dispatch((primitiveCount + BVH_BUILDER_GROUPSIZE - 1) / BVH_BUILDER_GROUPSIZE, 1, 1, cmd); device->Barrier(barriers, arraysize(barriers), cmd); - device->UnbindUAVs(0, arraysize(uavs), cmd); } device->EventEnd(cmd); @@ -505,7 +294,7 @@ void wiGPUBVH::Build(const Scene& scene, CommandList cmd) const readback_desc.Usage = USAGE_STAGING; readback_desc.CPUAccessFlags = CPU_ACCESS_READ; readback_desc.BindFlags = 0; - readback_desc.MiscFlags = 0; + readback_desc.Flags = 0; GPUBuffer readback_primitiveCounterBuffer; device->CreateBuffer(&readback_desc, nullptr, &readback_primitiveCounterBuffer); uint primitiveCount; @@ -521,7 +310,7 @@ void wiGPUBVH::Build(const Scene& scene, CommandList cmd) const readback_desc.Usage = USAGE_STAGING; readback_desc.CPUAccessFlags = CPU_ACCESS_READ; readback_desc.BindFlags = 0; - readback_desc.MiscFlags = 0; + readback_desc.Flags = 0; GPUBuffer readback_nodeBuffer; device->CreateBuffer(&readback_desc, nullptr, &readback_nodeBuffer); vector nodes(readback_desc.ByteWidth / sizeof(BVHNode)); @@ -562,7 +351,7 @@ void wiGPUBVH::Build(const Scene& scene, CommandList cmd) const readback_desc.Usage = USAGE_STAGING; readback_desc.CPUAccessFlags = CPU_ACCESS_READ; readback_desc.BindFlags = 0; - readback_desc.MiscFlags = 0; + readback_desc.Flags = 0; GPUBuffer readback_flagBuffer; device->CreateBuffer(&readback_desc, nullptr, &readback_flagBuffer); vector flags(readback_desc.ByteWidth / sizeof(uint)); @@ -581,27 +370,21 @@ void wiGPUBVH::Build(const Scene& scene, CommandList cmd) const #endif // BVH_VALIDATE } -void wiGPUBVH::Bind(SHADERSTAGE stage, CommandList cmd) const +void wiGPUBVH::Bind(CommandList cmd) const { GraphicsDevice* device = wiRenderer::GetDevice(); const GPUResource* res[] = { - &globalMaterialBuffer, - (globalMaterialAtlas.IsValid() ? &globalMaterialAtlas : wiTextureHelper::getWhite()), &primitiveCounterBuffer, &primitiveBuffer, - &primitiveDataBuffer, &bvhNodeBuffer, }; - device->BindResources(stage, res, TEXSLOT_ONDEMAND0, arraysize(res), cmd); + device->BindResources(res, TEXSLOT_BVH_COUNTER, arraysize(res), cmd); } void wiGPUBVH::Clear() { primitiveCapacity = 0; - materialArray.clear(); - storedTextures.clear(); - sceneTextures.clear(); } namespace wiGPUBVH_Internal diff --git a/WickedEngine/wiGPUBVH.h b/WickedEngine/wiGPUBVH.h index 197fad025..50c102951 100644 --- a/WickedEngine/wiGPUBVH.h +++ b/WickedEngine/wiGPUBVH.h @@ -20,23 +20,13 @@ private: wiGraphics::GPUBuffer primitiveCounterBuffer; wiGraphics::GPUBuffer primitiveIDBuffer; wiGraphics::GPUBuffer primitiveBuffer; - wiGraphics::GPUBuffer primitiveDataBuffer; wiGraphics::GPUBuffer primitiveMortonBuffer; uint32_t primitiveCapacity = 0; - // Scene material resources: - wiGraphics::GPUBuffer globalMaterialBuffer; - wiGraphics::Texture globalMaterialAtlas; - std::vector materialArray; - std::unordered_map, wiRectPacker::rect_xywh> storedTextures; - std::unordered_set> sceneTextures; - bool repackAtlas = false; - void UpdateGlobalMaterialResources(const wiScene::Scene& scene); - public: void Update(const wiScene::Scene& scene); void Build(const wiScene::Scene& scene, wiGraphics::CommandList cmd) const; - void Bind(wiGraphics::SHADERSTAGE stage, wiGraphics::CommandList cmd) const; + void Bind(wiGraphics::CommandList cmd) const; void Clear(); diff --git a/WickedEngine/wiGPUSortLib.cpp b/WickedEngine/wiGPUSortLib.cpp index f5571b781..76e44e5c7 100644 --- a/WickedEngine/wiGPUSortLib.cpp +++ b/WickedEngine/wiGPUSortLib.cpp @@ -9,7 +9,6 @@ using namespace wiGraphics; namespace wiGPUSortLib { static GPUBuffer indirectBuffer; - static GPUBuffer sortCB; static Shader kickoffSortCS; static Shader sortCS; static Shader sortInnerCS; @@ -30,19 +29,9 @@ namespace wiGPUSortLib void Initialize() { GPUBufferDesc bd; - - bd.Usage = USAGE_DYNAMIC; - bd.CPUAccessFlags = CPU_ACCESS_WRITE; - bd.BindFlags = BIND_CONSTANT_BUFFER; - bd.MiscFlags = 0; - bd.ByteWidth = sizeof(SortConstants); - wiRenderer::GetDevice()->CreateBuffer(&bd, nullptr, &sortCB); - - bd.Usage = USAGE_DEFAULT; - bd.CPUAccessFlags = 0; bd.BindFlags = BIND_UNORDERED_ACCESS; - bd.MiscFlags = RESOURCE_MISC_INDIRECT_ARGS | RESOURCE_MISC_BUFFER_ALLOW_RAW_VIEWS; + bd.MiscFlags = RESOURCE_MISC_INDIRECT_ARGS | RESOURCE_MISC_BUFFER_RAW; bd.ByteWidth = sizeof(IndirectDispatchArgs); wiRenderer::GetDevice()->CreateBuffer(&bd, nullptr, &indirectBuffer); @@ -66,10 +55,7 @@ namespace wiGPUSortLib SortConstants sc; sc.counterReadOffset = counterReadOffset; - device->UpdateBuffer(&sortCB, &sc, cmd); - device->BindConstantBuffer(CS, &sortCB, CB_GETBINDSLOT(SortConstants), cmd); - - device->UnbindUAVs(0, 8, cmd); + device->BindDynamicConstantBuffer(sc, CB_GETBINDSLOT(SortConstants), cmd); // initialize sorting arguments: { @@ -78,16 +64,16 @@ namespace wiGPUSortLib const GPUResource* res[] = { &counterBuffer_read, }; - device->BindResources(CS, res, 0, arraysize(res), cmd); + device->BindResources(res, 0, arraysize(res), cmd); const GPUResource* uavs[] = { &indirectBuffer, }; - device->BindUAVs(CS, uavs, 0, arraysize(uavs), cmd); + device->BindUAVs(uavs, 0, arraysize(uavs), cmd); { GPUBarrier barriers[] = { - GPUBarrier::Buffer(&indirectBuffer, BUFFER_STATE_INDIRECT_ARGUMENT, BUFFER_STATE_UNORDERED_ACCESS) + GPUBarrier::Buffer(&indirectBuffer, RESOURCE_STATE_INDIRECT_ARGUMENT, RESOURCE_STATE_UNORDERED_ACCESS) }; device->Barrier(barriers, arraysize(barriers), cmd); } @@ -97,25 +83,24 @@ namespace wiGPUSortLib { GPUBarrier barriers[] = { GPUBarrier::Memory(), - GPUBarrier::Buffer(&indirectBuffer, BUFFER_STATE_UNORDERED_ACCESS, BUFFER_STATE_INDIRECT_ARGUMENT) + GPUBarrier::Buffer(&indirectBuffer, RESOURCE_STATE_UNORDERED_ACCESS, RESOURCE_STATE_INDIRECT_ARGUMENT) }; device->Barrier(barriers, arraysize(barriers), cmd); } - device->UnbindUAVs(0, arraysize(uavs), cmd); } const GPUResource* uavs[] = { &indexBuffer_write, }; - device->BindUAVs(CS, uavs, 0, arraysize(uavs), cmd); + device->BindUAVs(uavs, 0, arraysize(uavs), cmd); const GPUResource* resources[] = { &counterBuffer_read, &comparisonBuffer_read, }; - device->BindResources(CS, resources, 0, arraysize(resources), cmd); + device->BindResources(resources, 0, arraysize(resources), cmd); // initial sorting: bool bDone = true; @@ -183,8 +168,7 @@ namespace wiGPUSortLib } sc.counterReadOffset = counterReadOffset; - device->UpdateBuffer(&sortCB, &sc, cmd); - device->BindConstantBuffer(CS, &sortCB, CB_GETBINDSLOT(SortConstants), cmd); + device->BindDynamicConstantBuffer(sc, CB_GETBINDSLOT(SortConstants), cmd); device->Dispatch(numThreadGroups, 1, 1, cmd); @@ -205,8 +189,6 @@ namespace wiGPUSortLib presorted *= 2; } - device->UnbindUAVs(0, arraysize(uavs), cmd); - device->UnbindResources(0, arraysize(resources), cmd); device->EventEnd(cmd); diff --git a/WickedEngine/wiGraphics.h b/WickedEngine/wiGraphics.h index 8a4b3dca8..27f8fbe48 100644 --- a/WickedEngine/wiGraphics.h +++ b/WickedEngine/wiGraphics.h @@ -4,6 +4,7 @@ #include #include #include +#include namespace wiGraphics { @@ -46,7 +47,7 @@ namespace wiGraphics }; enum PRIMITIVETOPOLOGY { - UNDEFINED, + UNDEFINED_TOPOLOGY, TRIANGLELIST, TRIANGLESTRIP, POINTLIST, @@ -101,15 +102,6 @@ namespace wiGraphics BLEND_SRC1_ALPHA, BLEND_INV_SRC1_ALPHA, }; - enum COLOR_WRITE_ENABLE - { - COLOR_WRITE_DISABLE = 0, - COLOR_WRITE_ENABLE_RED = 1, - COLOR_WRITE_ENABLE_GREEN = 2, - COLOR_WRITE_ENABLE_BLUE = 4, - COLOR_WRITE_ENABLE_ALPHA = 8, - COLOR_WRITE_ENABLE_ALL = (((COLOR_WRITE_ENABLE_RED | COLOR_WRITE_ENABLE_GREEN) | COLOR_WRITE_ENABLE_BLUE) | COLOR_WRITE_ENABLE_ALPHA) - }; enum BLEND_OP { BLEND_OP_ADD, @@ -136,10 +128,9 @@ namespace wiGraphics }; enum USAGE { - USAGE_DEFAULT, - USAGE_IMMUTABLE, - USAGE_DYNAMIC, - USAGE_STAGING, + USAGE_DEFAULT, // CPU no access, GPU read/write + USAGE_UPLOAD, // CPU write, GPU read + USAGE_READBACK, // CPU read, GPU write }; enum TEXTURE_ADDRESS_MODE { @@ -285,39 +276,12 @@ namespace wiGraphics }; enum SUBRESOURCE_TYPE { - CBV, // constant buffer view SRV, // shader resource view UAV, // unordered access view RTV, // render target view DSV, // depth stencil view }; - enum IMAGE_LAYOUT - { - IMAGE_LAYOUT_UNDEFINED, // invalid state - IMAGE_LAYOUT_RENDERTARGET, // render target, write enabled - IMAGE_LAYOUT_DEPTHSTENCIL, // depth stencil, write enabled - IMAGE_LAYOUT_DEPTHSTENCIL_READONLY, // depth stencil, read only - IMAGE_LAYOUT_SHADER_RESOURCE, // shader resource, read only - IMAGE_LAYOUT_SHADER_RESOURCE_COMPUTE, // shader resource, read only, non-pixel shader - IMAGE_LAYOUT_UNORDERED_ACCESS, // shader resource, write enabled - IMAGE_LAYOUT_COPY_SRC, // copy from - IMAGE_LAYOUT_COPY_DST, // copy to - IMAGE_LAYOUT_SHADING_RATE_SOURCE, // shading rate control per tile - }; - enum BUFFER_STATE - { - BUFFER_STATE_UNDEFINED, // invalid state - BUFFER_STATE_VERTEX_BUFFER, // vertex buffer, read only - BUFFER_STATE_INDEX_BUFFER, // index buffer, read only - BUFFER_STATE_CONSTANT_BUFFER, // constant buffer, read only - BUFFER_STATE_INDIRECT_ARGUMENT, // argument buffer to DrawIndirect() or DispatchIndirect() - BUFFER_STATE_SHADER_RESOURCE, // shader resource, read only - BUFFER_STATE_SHADER_RESOURCE_COMPUTE, // shader resource, read only, non-pixel shader - BUFFER_STATE_UNORDERED_ACCESS, // shader resource, write enabled - BUFFER_STATE_COPY_SRC, // copy from - BUFFER_STATE_COPY_DST, // copy to - BUFFER_STATE_RAYTRACING_ACCELERATION_STRUCTURE, - }; + enum SHADING_RATE { SHADING_RATE_1X1, @@ -332,33 +296,74 @@ namespace wiGraphics }; // Flags //////////////////////////////////////////// + + // Enable enum flags: + // https://www.justsoftwaresolutions.co.uk/cplusplus/using-enum-classes-as-bitfields.html + template + struct enable_bitmask_operators { + static constexpr bool enable = true; + }; + template + typename std::enable_if::enable, E>::type operator|(E lhs, E rhs) + { + typedef typename std::underlying_type::type underlying; + return static_cast( + static_cast(lhs) | static_cast(rhs)); + } + template + typename std::enable_if::enable, E&>::type operator|=(E& lhs, E rhs) + { + typedef typename std::underlying_type::type underlying; + lhs = static_cast( + static_cast(lhs) | static_cast(rhs)); + return lhs; + } + + enum COLOR_WRITE_ENABLE + { + COLOR_WRITE_DISABLE = 0, + COLOR_WRITE_ENABLE_RED = 1 << 0, + COLOR_WRITE_ENABLE_GREEN = 1 << 1, + COLOR_WRITE_ENABLE_BLUE = 1 << 2, + COLOR_WRITE_ENABLE_ALPHA = 1 << 3, + COLOR_WRITE_ENABLE_ALL = ~0, + }; + template<> + struct enable_bitmask_operators { + static const bool enable = true; + }; + enum BIND_FLAG { + BIND_NONE = 0, BIND_VERTEX_BUFFER = 1 << 0, BIND_INDEX_BUFFER = 1 << 1, BIND_CONSTANT_BUFFER = 1 << 2, BIND_SHADER_RESOURCE = 1 << 3, - BIND_STREAM_OUTPUT = 1 << 4, - BIND_RENDER_TARGET = 1 << 5, - BIND_DEPTH_STENCIL = 1 << 6, - BIND_UNORDERED_ACCESS = 1 << 7, - BIND_SHADING_RATE = 1 << 8, + BIND_RENDER_TARGET = 1 << 4, + BIND_DEPTH_STENCIL = 1 << 5, + BIND_UNORDERED_ACCESS = 1 << 6, + BIND_SHADING_RATE = 1 << 7, }; - enum CPU_ACCESS - { - CPU_ACCESS_WRITE = 1 << 0, - CPU_ACCESS_READ = 1 << 1, + template<> + struct enable_bitmask_operators { + static const bool enable = true; }; + enum RESOURCE_MISC_FLAG { - RESOURCE_MISC_SHARED = 1 << 0, - RESOURCE_MISC_TEXTURECUBE = 1 << 1, - RESOURCE_MISC_INDIRECT_ARGS = 1 << 2, - RESOURCE_MISC_BUFFER_ALLOW_RAW_VIEWS = 1 << 3, - RESOURCE_MISC_BUFFER_STRUCTURED = 1 << 4, - RESOURCE_MISC_TILED = 1 << 5, - RESOURCE_MISC_RAY_TRACING = 1 << 6, + RESOURCE_MISC_NONE = 0, + RESOURCE_MISC_TEXTURECUBE = 1 << 0, + RESOURCE_MISC_INDIRECT_ARGS = 1 << 1, + RESOURCE_MISC_BUFFER_RAW = 1 << 2, + RESOURCE_MISC_BUFFER_STRUCTURED = 1 << 3, + RESOURCE_MISC_RAY_TRACING = 1 << 4, }; + template<> + struct enable_bitmask_operators { + static const bool enable = true; + }; + enum GRAPHICSDEVICE_CAPABILITY { GRAPHICSDEVICE_CAPABILITY_TESSELLATION = 1 << 0, @@ -367,17 +372,37 @@ namespace wiGraphics GRAPHICSDEVICE_CAPABILITY_UAV_LOAD_FORMAT_COMMON = 1 << 3, // eg: R16G16B16A16_FLOAT, R8G8B8A8_UNORM and more common ones GRAPHICSDEVICE_CAPABILITY_UAV_LOAD_FORMAT_R11G11B10_FLOAT = 1 << 4, GRAPHICSDEVICE_CAPABILITY_RENDERTARGET_AND_VIEWPORT_ARRAYINDEX_WITHOUT_GS = 1 << 5, - GRAPHICSDEVICE_CAPABILITY_RAYTRACING_PIPELINE = 1 << 6, - GRAPHICSDEVICE_CAPABILITY_RAYTRACING_INLINE = 1 << 7, - GRAPHICSDEVICE_CAPABILITY_RAYTRACING_GEOMETRYINDEX = 1 << 8, - GRAPHICSDEVICE_CAPABILITY_VARIABLE_RATE_SHADING = 1 << 9, - GRAPHICSDEVICE_CAPABILITY_VARIABLE_RATE_SHADING_TIER2 = 1 << 10, - GRAPHICSDEVICE_CAPABILITY_MESH_SHADER = 1 << 11, - GRAPHICSDEVICE_CAPABILITY_BINDLESS_DESCRIPTORS = 1 << 12, + GRAPHICSDEVICE_CAPABILITY_VARIABLE_RATE_SHADING = 1 << 6, + GRAPHICSDEVICE_CAPABILITY_VARIABLE_RATE_SHADING_TIER2 = 1 << 7, + GRAPHICSDEVICE_CAPABILITY_MESH_SHADER = 1 << 8, + GRAPHICSDEVICE_CAPABILITY_RAYTRACING = 1 << 9, + }; + enum RESOURCE_STATE + { + // Common resource states: + RESOURCE_STATE_UNDEFINED = 0, // invalid state + RESOURCE_STATE_SHADER_RESOURCE = 1 << 0, // shader resource, read only + RESOURCE_STATE_SHADER_RESOURCE_COMPUTE = 1 << 1, // shader resource, read only, non-pixel shader + RESOURCE_STATE_UNORDERED_ACCESS = 1 << 2, // shader resource, write enabled + RESOURCE_STATE_COPY_SRC = 1 << 3, // copy from + RESOURCE_STATE_COPY_DST = 1 << 4, // copy to + // Texture specific resource states: + RESOURCE_STATE_RENDERTARGET = 1 << 5, // render target, write enabled + RESOURCE_STATE_DEPTHSTENCIL = 1 << 6, // depth stencil, write enabled + RESOURCE_STATE_DEPTHSTENCIL_READONLY = 1 << 7, // depth stencil, read only + RESOURCE_STATE_SHADING_RATE_SOURCE = 1 << 8, // shading rate control per tile - // helper query for full raytracing support: - GRAPHICSDEVICE_CAPABILITY_RAYTRACING = GRAPHICSDEVICE_CAPABILITY_RAYTRACING_PIPELINE | GRAPHICSDEVICE_CAPABILITY_RAYTRACING_INLINE | GRAPHICSDEVICE_CAPABILITY_RAYTRACING_GEOMETRYINDEX, + // GPUBuffer specific resource states: + RESOURCE_STATE_VERTEX_BUFFER = 1 << 9, // vertex buffer, read only + RESOURCE_STATE_INDEX_BUFFER = 1 << 10, // index buffer, read only + RESOURCE_STATE_CONSTANT_BUFFER = 1 << 11, // constant buffer, read only + RESOURCE_STATE_INDIRECT_ARGUMENT = 1 << 12, // argument buffer to DrawIndirect() or DispatchIndirect() + RESOURCE_STATE_RAYTRACING_ACCELERATION_STRUCTURE = 1 << 13, // acceleration structure storage or scratch + }; + template<> + struct enable_bitmask_operators { + static const bool enable = true; }; // Descriptor structs: @@ -431,11 +456,10 @@ namespace wiGraphics FORMAT Format = FORMAT_UNKNOWN; uint32_t SampleCount = 1; USAGE Usage = USAGE_DEFAULT; - uint32_t BindFlags = 0; - uint32_t CPUAccessFlags = 0; - uint32_t MiscFlags = 0; + BIND_FLAG BindFlags = BIND_NONE; + RESOURCE_MISC_FLAG MiscFlags = RESOURCE_MISC_NONE; ClearValue clear = {}; - IMAGE_LAYOUT layout = IMAGE_LAYOUT_SHADER_RESOURCE; + RESOURCE_STATE layout = RESOURCE_STATE_SHADER_RESOURCE; }; struct SamplerDesc { @@ -505,9 +529,8 @@ namespace wiGraphics { uint32_t ByteWidth = 0; USAGE Usage = USAGE_DEFAULT; - uint32_t BindFlags = 0; - uint32_t CPUAccessFlags = 0; - uint32_t MiscFlags = 0; + BIND_FLAG BindFlags = BIND_NONE; + RESOURCE_MISC_FLAG MiscFlags = RESOURCE_MISC_NONE; uint32_t StructureByteStride = 0; // needed for typed and structured buffer types! FORMAT Format = FORMAT_UNKNOWN; // only needed for typed buffer! }; @@ -548,16 +571,16 @@ namespace wiGraphics struct Image { const Texture* texture; - IMAGE_LAYOUT layout_before; - IMAGE_LAYOUT layout_after; + RESOURCE_STATE layout_before; + RESOURCE_STATE layout_after; int mip; int slice; }; struct Buffer { const GPUBuffer* buffer; - BUFFER_STATE state_before; - BUFFER_STATE state_after; + RESOURCE_STATE state_before; + RESOURCE_STATE state_after; }; union { @@ -573,7 +596,7 @@ namespace wiGraphics barrier.memory.resource = resource; return barrier; } - static GPUBarrier Image(const Texture* texture, IMAGE_LAYOUT before, IMAGE_LAYOUT after, + static GPUBarrier Image(const Texture* texture, RESOURCE_STATE before, RESOURCE_STATE after, int mip = -1, int slice = -1) { GPUBarrier barrier; @@ -585,7 +608,7 @@ namespace wiGraphics barrier.image.slice = slice; return barrier; } - static GPUBarrier Buffer(const GPUBuffer* buffer, BUFFER_STATE before, BUFFER_STATE after) + static GPUBarrier Buffer(const GPUBuffer* buffer, RESOURCE_STATE before, RESOURCE_STATE after) { GPUBarrier barrier; barrier.type = BUFFER_BARRIER; @@ -617,17 +640,17 @@ namespace wiGraphics STOREOP_STORE, STOREOP_DONTCARE, } storeop = STOREOP_STORE; - IMAGE_LAYOUT initial_layout = IMAGE_LAYOUT_UNDEFINED; // layout before the render pass - IMAGE_LAYOUT subpass_layout = IMAGE_LAYOUT_UNDEFINED; // layout within the render pass - IMAGE_LAYOUT final_layout = IMAGE_LAYOUT_UNDEFINED; // layout after the render pass + RESOURCE_STATE initial_layout = RESOURCE_STATE_UNDEFINED; // layout before the render pass + RESOURCE_STATE subpass_layout = RESOURCE_STATE_UNDEFINED; // layout within the render pass + RESOURCE_STATE final_layout = RESOURCE_STATE_UNDEFINED; // layout after the render pass static RenderPassAttachment RenderTarget( const Texture* resource = nullptr, LOAD_OPERATION load_op = LOADOP_LOAD, STORE_OPERATION store_op = STOREOP_STORE, - IMAGE_LAYOUT initial_layout = IMAGE_LAYOUT_SHADER_RESOURCE, - IMAGE_LAYOUT subpass_layout = IMAGE_LAYOUT_RENDERTARGET, - IMAGE_LAYOUT final_layout = IMAGE_LAYOUT_SHADER_RESOURCE + RESOURCE_STATE initial_layout = RESOURCE_STATE_SHADER_RESOURCE, + RESOURCE_STATE subpass_layout = RESOURCE_STATE_RENDERTARGET, + RESOURCE_STATE final_layout = RESOURCE_STATE_SHADER_RESOURCE ) { RenderPassAttachment attachment; @@ -645,9 +668,9 @@ namespace wiGraphics const Texture* resource = nullptr, LOAD_OPERATION load_op = LOADOP_LOAD, STORE_OPERATION store_op = STOREOP_STORE, - IMAGE_LAYOUT initial_layout = IMAGE_LAYOUT_DEPTHSTENCIL, - IMAGE_LAYOUT subpass_layout = IMAGE_LAYOUT_DEPTHSTENCIL, - IMAGE_LAYOUT final_layout = IMAGE_LAYOUT_DEPTHSTENCIL + RESOURCE_STATE initial_layout = RESOURCE_STATE_DEPTHSTENCIL, + RESOURCE_STATE subpass_layout = RESOURCE_STATE_DEPTHSTENCIL, + RESOURCE_STATE final_layout = RESOURCE_STATE_DEPTHSTENCIL ) { RenderPassAttachment attachment; @@ -663,8 +686,8 @@ namespace wiGraphics static RenderPassAttachment Resolve( const Texture* resource = nullptr, - IMAGE_LAYOUT initial_layout = IMAGE_LAYOUT_SHADER_RESOURCE, - IMAGE_LAYOUT final_layout = IMAGE_LAYOUT_SHADER_RESOURCE + RESOURCE_STATE initial_layout = RESOURCE_STATE_SHADER_RESOURCE, + RESOURCE_STATE final_layout = RESOURCE_STATE_SHADER_RESOURCE ) { RenderPassAttachment attachment; @@ -677,15 +700,15 @@ namespace wiGraphics static RenderPassAttachment ShadingRateSource( const Texture* resource = nullptr, - IMAGE_LAYOUT initial_layout = IMAGE_LAYOUT_SHADING_RATE_SOURCE, - IMAGE_LAYOUT final_layout = IMAGE_LAYOUT_SHADING_RATE_SOURCE + RESOURCE_STATE initial_layout = RESOURCE_STATE_SHADING_RATE_SOURCE, + RESOURCE_STATE final_layout = RESOURCE_STATE_SHADING_RATE_SOURCE ) { RenderPassAttachment attachment; attachment.type = SHADING_RATE_SOURCE; attachment.texture = resource; attachment.initial_layout = initial_layout; - attachment.subpass_layout = IMAGE_LAYOUT_SHADING_RATE_SOURCE; + attachment.subpass_layout = RESOURCE_STATE_SHADING_RATE_SOURCE; attachment.final_layout = final_layout; return attachment; } @@ -744,20 +767,6 @@ namespace wiGraphics int32_t right = 0; int32_t bottom = 0; }; - struct Mapping - { - enum FLAGS - { - FLAG_EMPTY = 0, - FLAG_READ = 1 << 0, - FLAG_WRITE = 1 << 1, - }; - uint32_t _flags = FLAG_EMPTY; - size_t offset = 0; - size_t size = 0; - uint32_t rowpitch = 0; // output - void* data = nullptr; // output - }; // Resources: @@ -798,6 +807,9 @@ namespace wiGraphics inline bool IsTexture() const { return type == GPU_RESOURCE_TYPE::TEXTURE; } inline bool IsBuffer() const { return type == GPU_RESOURCE_TYPE::BUFFER; } inline bool IsAccelerationStructure() const { return type == GPU_RESOURCE_TYPE::RAYTRACING_ACCELERATION_STRUCTURE; } + + void* mapped_data = nullptr; + uint32_t mapped_rowpitch = 0; }; struct GPUBuffer : public GPUResource diff --git a/WickedEngine/wiGraphicsDevice.h b/WickedEngine/wiGraphicsDevice.h index 7ecbe63f8..d58440f47 100644 --- a/WickedEngine/wiGraphicsDevice.h +++ b/WickedEngine/wiGraphicsDevice.h @@ -3,12 +3,31 @@ #include "wiGraphics.h" #include "wiPlatform.h" +#include +#include + namespace wiGraphics { typedef uint8_t CommandList; static const CommandList COMMANDLIST_COUNT = 32; static const CommandList INVALID_COMMANDLIST = COMMANDLIST_COUNT; + // Descriptor binding counts: + // It's OK increase these limits if not enough + static const uint32_t DESCRIPTORBINDER_CBV_COUNT = 15; + static const uint32_t DESCRIPTORBINDER_SRV_COUNT = 64; + static const uint32_t DESCRIPTORBINDER_UAV_COUNT = 16; + static const uint32_t DESCRIPTORBINDER_SAMPLER_COUNT = 16; + + inline size_t Align(size_t uLocation, size_t uAlign) + { + if ((0 == uAlign) || (uAlign & (uAlign - 1))) + { + assert(0); + } + return ((uLocation + (uAlign - 1)) & ~(uAlign - 1)); + } + enum QUEUE_TYPE { QUEUE_GRAPHICS, @@ -28,6 +47,7 @@ namespace wiGraphics size_t TOPLEVEL_ACCELERATION_STRUCTURE_INSTANCE_SIZE = 0; uint32_t VARIABLE_RATE_SHADING_TILE_SIZE = 0; uint64_t TIMESTAMP_FREQUENCY = 0; + size_t ALLOCATION_MIN_ALIGNMENT = 0; public: virtual ~GraphicsDevice() = default; @@ -53,10 +73,6 @@ namespace wiGraphics virtual void WriteTopLevelAccelerationStructureInstance(const RaytracingAccelerationStructureDesc::TopLevel::Instance* instance, void* dest) const {} virtual void WriteShaderIdentifier(const RaytracingPipelineState* rtpso, uint32_t group_index, void* dest) const {} - virtual void Map(const GPUResource* resource, Mapping* mapping) const = 0; - virtual void Unmap(const GPUResource* resource) const = 0; - virtual void QueryRead(const GPUQueryHeap* heap, uint32_t index, uint32_t count, uint64_t* results) const = 0; - virtual void SetCommonSampler(const StaticSampler* sam) = 0; virtual void SetName(GPUResource* pResource, const char* name) = 0; @@ -81,6 +97,7 @@ namespace wiGraphics bool IsFormatStencilSupport(FORMAT value) const; static constexpr uint32_t GetBufferCount() { return BUFFERCOUNT; } + constexpr uint32_t GetBufferIndex() const { return GetFrameCount() % BUFFERCOUNT; } constexpr bool IsDebugDevice() const { return DEBUGDEVICE; } @@ -101,14 +118,12 @@ namespace wiGraphics virtual void RenderPassEnd(CommandList cmd) = 0; virtual void BindScissorRects(uint32_t numRects, const Rect* rects, CommandList cmd) = 0; virtual void BindViewports(uint32_t NumViewports, const Viewport* pViewports, CommandList cmd) = 0; - virtual void BindResource(SHADERSTAGE stage, const GPUResource* resource, uint32_t slot, CommandList cmd, int subresource = -1) = 0; - virtual void BindResources(SHADERSTAGE stage, const GPUResource *const* resources, uint32_t slot, uint32_t count, CommandList cmd) = 0; - virtual void BindUAV(SHADERSTAGE stage, const GPUResource* resource, uint32_t slot, CommandList cmd, int subresource = -1) = 0; - virtual void BindUAVs(SHADERSTAGE stage, const GPUResource *const* resources, uint32_t slot, uint32_t count, CommandList cmd) = 0; - virtual void UnbindResources(uint32_t slot, uint32_t num, CommandList cmd) = 0; - virtual void UnbindUAVs(uint32_t slot, uint32_t num, CommandList cmd) = 0; - virtual void BindSampler(SHADERSTAGE stage, const Sampler* sampler, uint32_t slot, CommandList cmd) = 0; - virtual void BindConstantBuffer(SHADERSTAGE stage, const GPUBuffer* buffer, uint32_t slot, CommandList cmd) = 0; + virtual void BindResource(const GPUResource* resource, uint32_t slot, CommandList cmd, int subresource = -1) = 0; + virtual void BindResources(const GPUResource *const* resources, uint32_t slot, uint32_t count, CommandList cmd) = 0; + virtual void BindUAV(const GPUResource* resource, uint32_t slot, CommandList cmd, int subresource = -1) = 0; + virtual void BindUAVs(const GPUResource *const* resources, uint32_t slot, uint32_t count, CommandList cmd) = 0; + virtual void BindSampler(const Sampler* sampler, uint32_t slot, CommandList cmd) = 0; + virtual void BindConstantBuffer(const GPUBuffer* buffer, uint32_t slot, CommandList cmd, uint64_t offset = 0ull) = 0; virtual void BindVertexBuffers(const GPUBuffer *const* vertexBuffers, uint32_t slot, uint32_t count, const uint32_t* strides, const uint32_t* offsets, CommandList cmd) = 0; virtual void BindIndexBuffer(const GPUBuffer* indexBuffer, const INDEXBUFFER_FORMAT format, uint32_t offset, CommandList cmd) = 0; virtual void BindStencilRef(uint32_t value, CommandList cmd) = 0; @@ -127,34 +142,105 @@ namespace wiGraphics virtual void DispatchMesh(uint32_t threadGroupCountX, uint32_t threadGroupCountY, uint32_t threadGroupCountZ, CommandList cmd) {} virtual void DispatchMeshIndirect(const GPUBuffer* args, uint32_t args_offset, CommandList cmd) {} virtual void CopyResource(const GPUResource* pDst, const GPUResource* pSrc, CommandList cmd) = 0; - virtual void UpdateBuffer(const GPUBuffer* buffer, const void* data, CommandList cmd, int dataSize = -1) = 0; + virtual void CopyBuffer(const GPUBuffer* pDst, uint64_t dst_offset, const GPUBuffer* pSrc, uint64_t src_offset, uint64_t size, CommandList cmd) = 0; virtual void QueryBegin(const GPUQueryHeap *heap, uint32_t index, CommandList cmd) = 0; virtual void QueryEnd(const GPUQueryHeap *heap, uint32_t index, CommandList cmd) = 0; - virtual void QueryResolve(const GPUQueryHeap* heap, uint32_t index, uint32_t count, CommandList cmd) {} + virtual void QueryResolve(const GPUQueryHeap* heap, uint32_t index, uint32_t count, const GPUBuffer* dest, uint64_t dest_offset, CommandList cmd) {} + virtual void QueryReset(const GPUQueryHeap* heap, uint32_t index, uint32_t count, CommandList cmd) {} virtual void Barrier(const GPUBarrier* barriers, uint32_t numBarriers, CommandList cmd) = 0; virtual void BuildRaytracingAccelerationStructure(const RaytracingAccelerationStructure* dst, CommandList cmd, const RaytracingAccelerationStructure* src = nullptr) {} virtual void BindRaytracingPipelineState(const RaytracingPipelineState* rtpso, CommandList cmd) {} virtual void DispatchRays(const DispatchRaysDesc* desc, CommandList cmd) {} virtual void PushConstants(const void* data, uint32_t size, CommandList cmd) {} - - struct GPUAllocation - { - void* data = nullptr; // application can write to this. Reads might be not supported or slow. The offset is already applied - const GPUBuffer* buffer = nullptr; // application can bind it to the GPU - uint32_t offset = 0; // allocation's offset from the GPUbuffer's beginning - - // Returns true if the allocation was successful - inline bool IsValid() const { return data != nullptr && buffer != nullptr; } - }; - // Allocates temporary memory that the CPU can write and GPU can read. - // It is only alive for one frame and automatically invalidated after that. - // The CPU pointer gets invalidated as soon as there is a Draw() or Dispatch() event on the same thread - // This allocation can be used to provide temporary vertex buffer, index buffer or raw buffer data to shaders - virtual GPUAllocation AllocateGPU(size_t dataSize, CommandList cmd) = 0; virtual void EventBegin(const char* name, CommandList cmd) = 0; virtual void EventEnd(CommandList cmd) = 0; virtual void SetMarker(const char* name, CommandList cmd) = 0; + + + + + // Some useful helpers: + + struct GPULinearAllocator + { + GPUBuffer buffer; + size_t offset = 0; + uint64_t frame_index = 0; + } frame_allocators[BUFFERCOUNT][COMMANDLIST_COUNT]; + + struct GPUAllocation + { + void* data = nullptr; // application can write to this. Reads might be not supported or slow. The offset is already applied + GPUBuffer buffer; // application can bind it to the GPU + uint32_t offset = 0; // allocation's offset from the GPUbuffer's beginning + + // Returns true if the allocation was successful + inline bool IsValid() const { return data != nullptr && buffer.IsValid(); } + }; + // Allocates temporary memory that the CPU can write and GPU can read. + // It is only alive for one frame and automatically invalidated after that. + GPUAllocation AllocateGPU(size_t dataSize, CommandList cmd) + { + GPUAllocation allocation; + if (dataSize == 0) + return allocation; + + GPULinearAllocator& allocator = frame_allocators[GetBufferIndex()][cmd]; + if (FRAMECOUNT != allocator.frame_index) + { + allocator.frame_index = FRAMECOUNT; + allocator.offset = 0; + } + + size_t free_space = (size_t)allocator.buffer.desc.ByteWidth - allocator.offset; + if (dataSize > free_space) + { + GPUBufferDesc desc; + desc.Usage = USAGE_UPLOAD; + desc.ByteWidth = (uint32_t)Align((allocator.buffer.desc.ByteWidth + dataSize) * 2, ALLOCATION_MIN_ALIGNMENT); + desc.BindFlags = BIND_CONSTANT_BUFFER | BIND_VERTEX_BUFFER | BIND_INDEX_BUFFER | BIND_SHADER_RESOURCE; + desc.MiscFlags = RESOURCE_MISC_BUFFER_RAW; + CreateBuffer(&desc, nullptr, &allocator.buffer); + SetName(&allocator.buffer, "frame_allocator"); + allocator.offset = 0; + } + + allocation.buffer = allocator.buffer; + allocation.offset = (uint32_t)allocator.offset; + allocation.data = (void*)((size_t)allocator.buffer.mapped_data + allocator.offset); + + allocator.offset += Align(dataSize, ALLOCATION_MIN_ALIGNMENT); + + assert(allocation.IsValid()); + return allocation; + } + + // Updates a USAGE_DEFAULT buffer data + // Since it uses a GPU Copy operation, appropriate synchronization is expected + // And it cannot be used inside a RenderPass + void UpdateBuffer(const GPUBuffer* buffer, const void* data, CommandList cmd, size_t size = ~0, size_t offset = 0) + { + if (buffer == nullptr || data == nullptr) + return; + size = std::min((size_t)buffer->desc.ByteWidth, size); + if (size == 0) + return; + GPUAllocation allocation = AllocateGPU(size, cmd); + std::memcpy(allocation.data, data, size); + CopyBuffer(buffer, offset, &allocation.buffer, allocation.offset, size, cmd); + } + + // Helper util to bind a constant buffer with data for a specific command list: + // This will be done on the CPU to an UPLOAD buffer, so this can be used inside a RenderPass + // But this will be only visible on the command list it was bound to + template + void BindDynamicConstantBuffer(const T& data, uint32_t slot, wiGraphics::CommandList cmd) + { + GPUAllocation allocation = AllocateGPU(sizeof(T), cmd); + std::memcpy(allocation.data, &data, sizeof(T)); + BindConstantBuffer(&allocation.buffer, slot, cmd, allocation.offset); + } }; } diff --git a/WickedEngine/wiGraphicsDevice_DX11.cpp b/WickedEngine/wiGraphicsDevice_DX11.cpp deleted file mode 100644 index c20d668de..000000000 --- a/WickedEngine/wiGraphicsDevice_DX11.cpp +++ /dev/null @@ -1,3362 +0,0 @@ -#include "wiGraphicsDevice_DX11.h" - -#ifdef WICKEDENGINE_BUILD_DX11 - -#include "wiHelper.h" -#include "wiBackLog.h" - -#pragma comment(lib,"dxguid.lib") - -#include -#include - -// These will let the driver select the dedicated GPU in favour of the integrated one: -extern "C" { - _declspec(dllexport) DWORD NvOptimusEnablement = 0x00000001; - _declspec(dllexport) int AmdPowerXpressRequestHighPerformance = 1; -} - -using namespace Microsoft::WRL; - -namespace wiGraphics -{ - -namespace DX11_Internal -{ - -#ifdef PLATFORM_UWP - // UWP will use static link + /DELAYLOAD linker feature for the dlls (optionally) -#pragma comment(lib,"d3d11.lib") -#else - static PFN_D3D11_CREATE_DEVICE D3D11CreateDevice = nullptr; -#endif // PLATFORM_UWP - - // Engine -> Native converters - - constexpr uint32_t _ParseBindFlags(uint32_t value) - { - uint32_t _flag = 0; - - if (value & BIND_VERTEX_BUFFER) - _flag |= D3D11_BIND_VERTEX_BUFFER; - if (value & BIND_INDEX_BUFFER) - _flag |= D3D11_BIND_INDEX_BUFFER; - if (value & BIND_CONSTANT_BUFFER) - _flag |= D3D11_BIND_CONSTANT_BUFFER; - if (value & BIND_SHADER_RESOURCE) - _flag |= D3D11_BIND_SHADER_RESOURCE; - if (value & BIND_STREAM_OUTPUT) - _flag |= D3D11_BIND_STREAM_OUTPUT; - if (value & BIND_RENDER_TARGET) - _flag |= D3D11_BIND_RENDER_TARGET; - if (value & BIND_DEPTH_STENCIL) - _flag |= D3D11_BIND_DEPTH_STENCIL; - if (value & BIND_UNORDERED_ACCESS) - _flag |= D3D11_BIND_UNORDERED_ACCESS; - - return _flag; - } - constexpr uint32_t _ParseCPUAccessFlags(uint32_t value) - { - uint32_t _flag = 0; - - if (value & CPU_ACCESS_WRITE) - _flag |= D3D11_CPU_ACCESS_WRITE; - if (value & CPU_ACCESS_READ) - _flag |= D3D11_CPU_ACCESS_READ; - - return _flag; - } - constexpr uint32_t _ParseResourceMiscFlags(uint32_t value) - { - uint32_t _flag = 0; - - if (value & RESOURCE_MISC_SHARED) - _flag |= D3D11_RESOURCE_MISC_SHARED; - if (value & RESOURCE_MISC_TEXTURECUBE) - _flag |= D3D11_RESOURCE_MISC_TEXTURECUBE; - if (value & RESOURCE_MISC_INDIRECT_ARGS) - _flag |= D3D11_RESOURCE_MISC_DRAWINDIRECT_ARGS; - if (value & RESOURCE_MISC_BUFFER_ALLOW_RAW_VIEWS) - _flag |= D3D11_RESOURCE_MISC_BUFFER_ALLOW_RAW_VIEWS; - if (value & RESOURCE_MISC_BUFFER_STRUCTURED) - _flag |= D3D11_RESOURCE_MISC_BUFFER_STRUCTURED; - if (value & RESOURCE_MISC_TILED) - _flag |= D3D11_RESOURCE_MISC_TILED; - - return _flag; - } - constexpr uint32_t _ParseColorWriteMask(uint32_t value) - { - uint32_t _flag = 0; - - if (value == D3D11_COLOR_WRITE_ENABLE_ALL) - { - return D3D11_COLOR_WRITE_ENABLE_ALL; - } - else - { - if (value & COLOR_WRITE_ENABLE_RED) - _flag |= D3D11_COLOR_WRITE_ENABLE_RED; - if (value & COLOR_WRITE_ENABLE_GREEN) - _flag |= D3D11_COLOR_WRITE_ENABLE_GREEN; - if (value & COLOR_WRITE_ENABLE_BLUE) - _flag |= D3D11_COLOR_WRITE_ENABLE_BLUE; - if (value & COLOR_WRITE_ENABLE_ALPHA) - _flag |= D3D11_COLOR_WRITE_ENABLE_ALPHA; - } - - return _flag; - } - - constexpr D3D11_FILTER _ConvertFilter(FILTER value) - { - switch (value) - { - case FILTER_MIN_MAG_MIP_POINT: - return D3D11_FILTER_MIN_MAG_MIP_POINT; - break; - case FILTER_MIN_MAG_POINT_MIP_LINEAR: - return D3D11_FILTER_MIN_MAG_POINT_MIP_LINEAR; - break; - case FILTER_MIN_POINT_MAG_LINEAR_MIP_POINT: - return D3D11_FILTER_MIN_POINT_MAG_LINEAR_MIP_POINT; - break; - case FILTER_MIN_POINT_MAG_MIP_LINEAR: - return D3D11_FILTER_MIN_POINT_MAG_MIP_LINEAR; - break; - case FILTER_MIN_LINEAR_MAG_MIP_POINT: - return D3D11_FILTER_MIN_LINEAR_MAG_MIP_POINT; - break; - case FILTER_MIN_LINEAR_MAG_POINT_MIP_LINEAR: - return D3D11_FILTER_MIN_LINEAR_MAG_POINT_MIP_LINEAR; - break; - case FILTER_MIN_MAG_LINEAR_MIP_POINT: - return D3D11_FILTER_MIN_MAG_LINEAR_MIP_POINT; - break; - case FILTER_MIN_MAG_MIP_LINEAR: - return D3D11_FILTER_MIN_MAG_MIP_LINEAR; - break; - case FILTER_ANISOTROPIC: - return D3D11_FILTER_ANISOTROPIC; - break; - case FILTER_COMPARISON_MIN_MAG_MIP_POINT: - return D3D11_FILTER_COMPARISON_MIN_MAG_MIP_POINT; - break; - case FILTER_COMPARISON_MIN_MAG_POINT_MIP_LINEAR: - return D3D11_FILTER_COMPARISON_MIN_MAG_POINT_MIP_LINEAR; - break; - case FILTER_COMPARISON_MIN_POINT_MAG_LINEAR_MIP_POINT: - return D3D11_FILTER_COMPARISON_MIN_POINT_MAG_LINEAR_MIP_POINT; - break; - case FILTER_COMPARISON_MIN_POINT_MAG_MIP_LINEAR: - return D3D11_FILTER_COMPARISON_MIN_POINT_MAG_MIP_LINEAR; - break; - case FILTER_COMPARISON_MIN_LINEAR_MAG_MIP_POINT: - return D3D11_FILTER_COMPARISON_MIN_LINEAR_MAG_MIP_POINT; - break; - case FILTER_COMPARISON_MIN_LINEAR_MAG_POINT_MIP_LINEAR: - return D3D11_FILTER_COMPARISON_MIN_LINEAR_MAG_POINT_MIP_LINEAR; - break; - case FILTER_COMPARISON_MIN_MAG_LINEAR_MIP_POINT: - return D3D11_FILTER_COMPARISON_MIN_MAG_LINEAR_MIP_POINT; - break; - case FILTER_COMPARISON_MIN_MAG_MIP_LINEAR: - return D3D11_FILTER_COMPARISON_MIN_MAG_MIP_LINEAR; - break; - case FILTER_COMPARISON_ANISOTROPIC: - return D3D11_FILTER_COMPARISON_ANISOTROPIC; - break; - case FILTER_MINIMUM_MIN_MAG_MIP_POINT: - return D3D11_FILTER_MINIMUM_MIN_MAG_MIP_POINT; - break; - case FILTER_MINIMUM_MIN_MAG_POINT_MIP_LINEAR: - return D3D11_FILTER_MINIMUM_MIN_MAG_POINT_MIP_LINEAR; - break; - case FILTER_MINIMUM_MIN_POINT_MAG_LINEAR_MIP_POINT: - return D3D11_FILTER_MINIMUM_MIN_POINT_MAG_LINEAR_MIP_POINT; - break; - case FILTER_MINIMUM_MIN_POINT_MAG_MIP_LINEAR: - return D3D11_FILTER_MINIMUM_MIN_POINT_MAG_MIP_LINEAR; - break; - case FILTER_MINIMUM_MIN_LINEAR_MAG_MIP_POINT: - return D3D11_FILTER_MINIMUM_MIN_LINEAR_MAG_MIP_POINT; - break; - case FILTER_MINIMUM_MIN_LINEAR_MAG_POINT_MIP_LINEAR: - return D3D11_FILTER_MINIMUM_MIN_LINEAR_MAG_POINT_MIP_LINEAR; - break; - case FILTER_MINIMUM_MIN_MAG_LINEAR_MIP_POINT: - return D3D11_FILTER_MINIMUM_MIN_MAG_LINEAR_MIP_POINT; - break; - case FILTER_MINIMUM_MIN_MAG_MIP_LINEAR: - return D3D11_FILTER_MINIMUM_MIN_MAG_MIP_LINEAR; - break; - case FILTER_MINIMUM_ANISOTROPIC: - return D3D11_FILTER_MINIMUM_ANISOTROPIC; - break; - case FILTER_MAXIMUM_MIN_MAG_MIP_POINT: - return D3D11_FILTER_MAXIMUM_MIN_MAG_MIP_POINT; - break; - case FILTER_MAXIMUM_MIN_MAG_POINT_MIP_LINEAR: - return D3D11_FILTER_MAXIMUM_MIN_MAG_POINT_MIP_LINEAR; - break; - case FILTER_MAXIMUM_MIN_POINT_MAG_LINEAR_MIP_POINT: - return D3D11_FILTER_MAXIMUM_MIN_POINT_MAG_LINEAR_MIP_POINT; - break; - case FILTER_MAXIMUM_MIN_POINT_MAG_MIP_LINEAR: - return D3D11_FILTER_MAXIMUM_MIN_POINT_MAG_MIP_LINEAR; - break; - case FILTER_MAXIMUM_MIN_LINEAR_MAG_MIP_POINT: - return D3D11_FILTER_MAXIMUM_MIN_LINEAR_MAG_MIP_POINT; - break; - case FILTER_MAXIMUM_MIN_LINEAR_MAG_POINT_MIP_LINEAR: - return D3D11_FILTER_MAXIMUM_MIN_LINEAR_MAG_POINT_MIP_LINEAR; - break; - case FILTER_MAXIMUM_MIN_MAG_LINEAR_MIP_POINT: - return D3D11_FILTER_MAXIMUM_MIN_MAG_LINEAR_MIP_POINT; - break; - case FILTER_MAXIMUM_MIN_MAG_MIP_LINEAR: - return D3D11_FILTER_MAXIMUM_MIN_MAG_MIP_LINEAR; - break; - case FILTER_MAXIMUM_ANISOTROPIC: - return D3D11_FILTER_MAXIMUM_ANISOTROPIC; - break; - default: - break; - } - return D3D11_FILTER_MIN_MAG_MIP_POINT; - } - constexpr D3D11_TEXTURE_ADDRESS_MODE _ConvertTextureAddressMode(TEXTURE_ADDRESS_MODE value) - { - switch (value) - { - case TEXTURE_ADDRESS_WRAP: - return D3D11_TEXTURE_ADDRESS_WRAP; - break; - case TEXTURE_ADDRESS_MIRROR: - return D3D11_TEXTURE_ADDRESS_MIRROR; - break; - case TEXTURE_ADDRESS_CLAMP: - return D3D11_TEXTURE_ADDRESS_CLAMP; - break; - case TEXTURE_ADDRESS_BORDER: - return D3D11_TEXTURE_ADDRESS_BORDER; - break; - default: - break; - } - return D3D11_TEXTURE_ADDRESS_WRAP; - } - constexpr D3D11_COMPARISON_FUNC _ConvertComparisonFunc(COMPARISON_FUNC value) - { - switch (value) - { - case COMPARISON_NEVER: - return D3D11_COMPARISON_NEVER; - break; - case COMPARISON_LESS: - return D3D11_COMPARISON_LESS; - break; - case COMPARISON_EQUAL: - return D3D11_COMPARISON_EQUAL; - break; - case COMPARISON_LESS_EQUAL: - return D3D11_COMPARISON_LESS_EQUAL; - break; - case COMPARISON_GREATER: - return D3D11_COMPARISON_GREATER; - break; - case COMPARISON_NOT_EQUAL: - return D3D11_COMPARISON_NOT_EQUAL; - break; - case COMPARISON_GREATER_EQUAL: - return D3D11_COMPARISON_GREATER_EQUAL; - break; - case COMPARISON_ALWAYS: - return D3D11_COMPARISON_ALWAYS; - break; - default: - break; - } - return D3D11_COMPARISON_NEVER; - } - constexpr D3D11_FILL_MODE _ConvertFillMode(FILL_MODE value) - { - switch (value) - { - case FILL_WIREFRAME: - return D3D11_FILL_WIREFRAME; - break; - case FILL_SOLID: - return D3D11_FILL_SOLID; - break; - default: - break; - } - return D3D11_FILL_WIREFRAME; - } - constexpr D3D11_CULL_MODE _ConvertCullMode(CULL_MODE value) - { - switch (value) - { - case CULL_NONE: - return D3D11_CULL_NONE; - break; - case CULL_FRONT: - return D3D11_CULL_FRONT; - break; - case CULL_BACK: - return D3D11_CULL_BACK; - break; - default: - break; - } - return D3D11_CULL_NONE; - } - constexpr D3D11_DEPTH_WRITE_MASK _ConvertDepthWriteMask(DEPTH_WRITE_MASK value) - { - switch (value) - { - case DEPTH_WRITE_MASK_ZERO: - return D3D11_DEPTH_WRITE_MASK_ZERO; - break; - case DEPTH_WRITE_MASK_ALL: - return D3D11_DEPTH_WRITE_MASK_ALL; - break; - default: - break; - } - return D3D11_DEPTH_WRITE_MASK_ZERO; - } - constexpr D3D11_STENCIL_OP _ConvertStencilOp(STENCIL_OP value) - { - switch (value) - { - case STENCIL_OP_KEEP: - return D3D11_STENCIL_OP_KEEP; - break; - case STENCIL_OP_ZERO: - return D3D11_STENCIL_OP_ZERO; - break; - case STENCIL_OP_REPLACE: - return D3D11_STENCIL_OP_REPLACE; - break; - case STENCIL_OP_INCR_SAT: - return D3D11_STENCIL_OP_INCR_SAT; - break; - case STENCIL_OP_DECR_SAT: - return D3D11_STENCIL_OP_DECR_SAT; - break; - case STENCIL_OP_INVERT: - return D3D11_STENCIL_OP_INVERT; - break; - case STENCIL_OP_INCR: - return D3D11_STENCIL_OP_INCR; - break; - case STENCIL_OP_DECR: - return D3D11_STENCIL_OP_DECR; - break; - default: - break; - } - return D3D11_STENCIL_OP_KEEP; - } - constexpr D3D11_BLEND _ConvertBlend(BLEND value) - { - switch (value) - { - case BLEND_ZERO: - return D3D11_BLEND_ZERO; - break; - case BLEND_ONE: - return D3D11_BLEND_ONE; - break; - case BLEND_SRC_COLOR: - return D3D11_BLEND_SRC_COLOR; - break; - case BLEND_INV_SRC_COLOR: - return D3D11_BLEND_INV_SRC_COLOR; - break; - case BLEND_SRC_ALPHA: - return D3D11_BLEND_SRC_ALPHA; - break; - case BLEND_INV_SRC_ALPHA: - return D3D11_BLEND_INV_SRC_ALPHA; - break; - case BLEND_DEST_ALPHA: - return D3D11_BLEND_DEST_ALPHA; - break; - case BLEND_INV_DEST_ALPHA: - return D3D11_BLEND_INV_DEST_ALPHA; - break; - case BLEND_DEST_COLOR: - return D3D11_BLEND_DEST_COLOR; - break; - case BLEND_INV_DEST_COLOR: - return D3D11_BLEND_INV_DEST_COLOR; - break; - case BLEND_SRC_ALPHA_SAT: - return D3D11_BLEND_SRC_ALPHA_SAT; - break; - case BLEND_BLEND_FACTOR: - return D3D11_BLEND_BLEND_FACTOR; - break; - case BLEND_INV_BLEND_FACTOR: - return D3D11_BLEND_INV_BLEND_FACTOR; - break; - case BLEND_SRC1_COLOR: - return D3D11_BLEND_SRC1_COLOR; - break; - case BLEND_INV_SRC1_COLOR: - return D3D11_BLEND_INV_SRC1_COLOR; - break; - case BLEND_SRC1_ALPHA: - return D3D11_BLEND_SRC1_ALPHA; - break; - case BLEND_INV_SRC1_ALPHA: - return D3D11_BLEND_INV_SRC1_ALPHA; - break; - default: - break; - } - return D3D11_BLEND_ZERO; - } - constexpr D3D11_BLEND_OP _ConvertBlendOp(BLEND_OP value) - { - switch (value) - { - case BLEND_OP_ADD: - return D3D11_BLEND_OP_ADD; - break; - case BLEND_OP_SUBTRACT: - return D3D11_BLEND_OP_SUBTRACT; - break; - case BLEND_OP_REV_SUBTRACT: - return D3D11_BLEND_OP_REV_SUBTRACT; - break; - case BLEND_OP_MIN: - return D3D11_BLEND_OP_MIN; - break; - case BLEND_OP_MAX: - return D3D11_BLEND_OP_MAX; - break; - default: - break; - } - return D3D11_BLEND_OP_ADD; - } - constexpr D3D11_USAGE _ConvertUsage(USAGE value) - { - switch (value) - { - case USAGE_DEFAULT: - return D3D11_USAGE_DEFAULT; - break; - case USAGE_IMMUTABLE: - return D3D11_USAGE_IMMUTABLE; - break; - case USAGE_DYNAMIC: - return D3D11_USAGE_DYNAMIC; - break; - case USAGE_STAGING: - return D3D11_USAGE_STAGING; - break; - default: - break; - } - return D3D11_USAGE_DEFAULT; - } - constexpr D3D11_INPUT_CLASSIFICATION _ConvertInputClassification(INPUT_CLASSIFICATION value) - { - switch (value) - { - case INPUT_PER_VERTEX_DATA: - return D3D11_INPUT_PER_VERTEX_DATA; - break; - case INPUT_PER_INSTANCE_DATA: - return D3D11_INPUT_PER_INSTANCE_DATA; - break; - default: - break; - } - return D3D11_INPUT_PER_VERTEX_DATA; - } - constexpr DXGI_FORMAT _ConvertFormat(FORMAT value) - { - switch (value) - { - case FORMAT_UNKNOWN: - return DXGI_FORMAT_UNKNOWN; - break; - case FORMAT_R32G32B32A32_FLOAT: - return DXGI_FORMAT_R32G32B32A32_FLOAT; - break; - case FORMAT_R32G32B32A32_UINT: - return DXGI_FORMAT_R32G32B32A32_UINT; - break; - case FORMAT_R32G32B32A32_SINT: - return DXGI_FORMAT_R32G32B32A32_SINT; - break; - case FORMAT_R32G32B32_FLOAT: - return DXGI_FORMAT_R32G32B32_FLOAT; - break; - case FORMAT_R32G32B32_UINT: - return DXGI_FORMAT_R32G32B32_UINT; - break; - case FORMAT_R32G32B32_SINT: - return DXGI_FORMAT_R32G32B32_SINT; - break; - case FORMAT_R16G16B16A16_FLOAT: - return DXGI_FORMAT_R16G16B16A16_FLOAT; - break; - case FORMAT_R16G16B16A16_UNORM: - return DXGI_FORMAT_R16G16B16A16_UNORM; - break; - case FORMAT_R16G16B16A16_UINT: - return DXGI_FORMAT_R16G16B16A16_UINT; - break; - case FORMAT_R16G16B16A16_SNORM: - return DXGI_FORMAT_R16G16B16A16_SNORM; - break; - case FORMAT_R16G16B16A16_SINT: - return DXGI_FORMAT_R16G16B16A16_SINT; - break; - case FORMAT_R32G32_FLOAT: - return DXGI_FORMAT_R32G32_FLOAT; - break; - case FORMAT_R32G32_UINT: - return DXGI_FORMAT_R32G32_UINT; - break; - case FORMAT_R32G32_SINT: - return DXGI_FORMAT_R32G32_SINT; - break; - case FORMAT_R32G8X24_TYPELESS: - return DXGI_FORMAT_R32G8X24_TYPELESS; - break; - case FORMAT_D32_FLOAT_S8X24_UINT: - return DXGI_FORMAT_D32_FLOAT_S8X24_UINT; - break; - case FORMAT_R10G10B10A2_UNORM: - return DXGI_FORMAT_R10G10B10A2_UNORM; - break; - case FORMAT_R10G10B10A2_UINT: - return DXGI_FORMAT_R10G10B10A2_UINT; - break; - case FORMAT_R11G11B10_FLOAT: - return DXGI_FORMAT_R11G11B10_FLOAT; - break; - case FORMAT_R8G8B8A8_UNORM: - return DXGI_FORMAT_R8G8B8A8_UNORM; - break; - case FORMAT_R8G8B8A8_UNORM_SRGB: - return DXGI_FORMAT_R8G8B8A8_UNORM_SRGB; - break; - case FORMAT_R8G8B8A8_UINT: - return DXGI_FORMAT_R8G8B8A8_UINT; - break; - case FORMAT_R8G8B8A8_SNORM: - return DXGI_FORMAT_R8G8B8A8_SNORM; - break; - case FORMAT_R8G8B8A8_SINT: - return DXGI_FORMAT_R8G8B8A8_SINT; - break; - case FORMAT_R16G16_FLOAT: - return DXGI_FORMAT_R16G16_FLOAT; - break; - case FORMAT_R16G16_UNORM: - return DXGI_FORMAT_R16G16_UNORM; - break; - case FORMAT_R16G16_UINT: - return DXGI_FORMAT_R16G16_UINT; - break; - case FORMAT_R16G16_SNORM: - return DXGI_FORMAT_R16G16_SNORM; - break; - case FORMAT_R16G16_SINT: - return DXGI_FORMAT_R16G16_SINT; - break; - case FORMAT_R32_TYPELESS: - return DXGI_FORMAT_R32_TYPELESS; - break; - case FORMAT_D32_FLOAT: - return DXGI_FORMAT_D32_FLOAT; - break; - case FORMAT_R32_FLOAT: - return DXGI_FORMAT_R32_FLOAT; - break; - case FORMAT_R32_UINT: - return DXGI_FORMAT_R32_UINT; - break; - case FORMAT_R32_SINT: - return DXGI_FORMAT_R32_SINT; - break; - case FORMAT_R24G8_TYPELESS: - return DXGI_FORMAT_R24G8_TYPELESS; - break; - case FORMAT_D24_UNORM_S8_UINT: - return DXGI_FORMAT_D24_UNORM_S8_UINT; - break; - case FORMAT_R8G8_UNORM: - return DXGI_FORMAT_R8G8_UNORM; - break; - case FORMAT_R8G8_UINT: - return DXGI_FORMAT_R8G8_UINT; - break; - case FORMAT_R8G8_SNORM: - return DXGI_FORMAT_R8G8_SNORM; - break; - case FORMAT_R8G8_SINT: - return DXGI_FORMAT_R8G8_SINT; - break; - case FORMAT_R16_TYPELESS: - return DXGI_FORMAT_R16_TYPELESS; - break; - case FORMAT_R16_FLOAT: - return DXGI_FORMAT_R16_FLOAT; - break; - case FORMAT_D16_UNORM: - return DXGI_FORMAT_D16_UNORM; - break; - case FORMAT_R16_UNORM: - return DXGI_FORMAT_R16_UNORM; - break; - case FORMAT_R16_UINT: - return DXGI_FORMAT_R16_UINT; - break; - case FORMAT_R16_SNORM: - return DXGI_FORMAT_R16_SNORM; - break; - case FORMAT_R16_SINT: - return DXGI_FORMAT_R16_SINT; - break; - case FORMAT_R8_UNORM: - return DXGI_FORMAT_R8_UNORM; - break; - case FORMAT_R8_UINT: - return DXGI_FORMAT_R8_UINT; - break; - case FORMAT_R8_SNORM: - return DXGI_FORMAT_R8_SNORM; - break; - case FORMAT_R8_SINT: - return DXGI_FORMAT_R8_SINT; - break; - case FORMAT_BC1_UNORM: - return DXGI_FORMAT_BC1_UNORM; - break; - case FORMAT_BC1_UNORM_SRGB: - return DXGI_FORMAT_BC1_UNORM_SRGB; - break; - case FORMAT_BC2_UNORM: - return DXGI_FORMAT_BC2_UNORM; - break; - case FORMAT_BC2_UNORM_SRGB: - return DXGI_FORMAT_BC2_UNORM_SRGB; - break; - case FORMAT_BC3_UNORM: - return DXGI_FORMAT_BC3_UNORM; - break; - case FORMAT_BC3_UNORM_SRGB: - return DXGI_FORMAT_BC3_UNORM_SRGB; - break; - case FORMAT_BC4_UNORM: - return DXGI_FORMAT_BC4_UNORM; - break; - case FORMAT_BC4_SNORM: - return DXGI_FORMAT_BC4_SNORM; - break; - case FORMAT_BC5_UNORM: - return DXGI_FORMAT_BC5_UNORM; - break; - case FORMAT_BC5_SNORM: - return DXGI_FORMAT_BC5_SNORM; - break; - case FORMAT_B8G8R8A8_UNORM: - return DXGI_FORMAT_B8G8R8A8_UNORM; - break; - case FORMAT_B8G8R8A8_UNORM_SRGB: - return DXGI_FORMAT_B8G8R8A8_UNORM_SRGB; - break; - case FORMAT_BC6H_UF16: - return DXGI_FORMAT_BC6H_UF16; - break; - case FORMAT_BC6H_SF16: - return DXGI_FORMAT_BC6H_SF16; - break; - case FORMAT_BC7_UNORM: - return DXGI_FORMAT_BC7_UNORM; - break; - case FORMAT_BC7_UNORM_SRGB: - return DXGI_FORMAT_BC7_UNORM_SRGB; - break; - } - return DXGI_FORMAT_UNKNOWN; - } - - inline D3D11_TEXTURE1D_DESC _ConvertTextureDesc1D(const TextureDesc* pDesc) - { - D3D11_TEXTURE1D_DESC desc; - desc.Width = pDesc->Width; - desc.MipLevels = pDesc->MipLevels; - desc.ArraySize = pDesc->ArraySize; - desc.Format = _ConvertFormat(pDesc->Format); - desc.Usage = _ConvertUsage(pDesc->Usage); - desc.BindFlags = _ParseBindFlags(pDesc->BindFlags); - desc.CPUAccessFlags = _ParseCPUAccessFlags(pDesc->CPUAccessFlags); - desc.MiscFlags = _ParseResourceMiscFlags(pDesc->MiscFlags); - - return desc; - } - inline D3D11_TEXTURE2D_DESC _ConvertTextureDesc2D(const TextureDesc* pDesc) - { - D3D11_TEXTURE2D_DESC desc; - desc.Width = pDesc->Width; - desc.Height = pDesc->Height; - desc.MipLevels = pDesc->MipLevels; - desc.ArraySize = pDesc->ArraySize; - desc.Format = _ConvertFormat(pDesc->Format); - desc.SampleDesc.Count = pDesc->SampleCount; - desc.SampleDesc.Quality = 0; - desc.Usage = _ConvertUsage(pDesc->Usage); - desc.BindFlags = _ParseBindFlags(pDesc->BindFlags); - desc.CPUAccessFlags = _ParseCPUAccessFlags(pDesc->CPUAccessFlags); - desc.MiscFlags = _ParseResourceMiscFlags(pDesc->MiscFlags); - - return desc; - } - inline D3D11_TEXTURE3D_DESC _ConvertTextureDesc3D(const TextureDesc* pDesc) - { - D3D11_TEXTURE3D_DESC desc; - desc.Width = pDesc->Width; - desc.Height = pDesc->Height; - desc.Depth = pDesc->Depth; - desc.MipLevels = pDesc->MipLevels; - desc.Format = _ConvertFormat(pDesc->Format); - desc.Usage = _ConvertUsage(pDesc->Usage); - desc.BindFlags = _ParseBindFlags(pDesc->BindFlags); - desc.CPUAccessFlags = _ParseCPUAccessFlags(pDesc->CPUAccessFlags); - desc.MiscFlags = _ParseResourceMiscFlags(pDesc->MiscFlags); - - return desc; - } - inline D3D11_SUBRESOURCE_DATA _ConvertSubresourceData(const SubresourceData& pInitialData) - { - D3D11_SUBRESOURCE_DATA data; - data.pSysMem = pInitialData.pSysMem; - data.SysMemPitch = pInitialData.SysMemPitch; - data.SysMemSlicePitch = pInitialData.SysMemSlicePitch; - - return data; - } - - - // Native -> Engine converters - - constexpr uint32_t _ParseBindFlags_Inv(uint32_t value) - { - uint32_t _flag = 0; - - if (value & D3D11_BIND_VERTEX_BUFFER) - _flag |= BIND_VERTEX_BUFFER; - if (value & D3D11_BIND_INDEX_BUFFER) - _flag |= BIND_INDEX_BUFFER; - if (value & D3D11_BIND_CONSTANT_BUFFER) - _flag |= BIND_CONSTANT_BUFFER; - if (value & D3D11_BIND_SHADER_RESOURCE) - _flag |= BIND_SHADER_RESOURCE; - if (value & D3D11_BIND_STREAM_OUTPUT) - _flag |= BIND_STREAM_OUTPUT; - if (value & D3D11_BIND_RENDER_TARGET) - _flag |= BIND_RENDER_TARGET; - if (value & D3D11_BIND_DEPTH_STENCIL) - _flag |= BIND_DEPTH_STENCIL; - if (value & D3D11_BIND_UNORDERED_ACCESS) - _flag |= BIND_UNORDERED_ACCESS; - - return _flag; - } - constexpr uint32_t _ParseCPUAccessFlags_Inv(uint32_t value) - { - uint32_t _flag = 0; - - if (value & D3D11_CPU_ACCESS_WRITE) - _flag |= CPU_ACCESS_WRITE; - if (value & D3D11_CPU_ACCESS_READ) - _flag |= CPU_ACCESS_READ; - - return _flag; - } - constexpr uint32_t _ParseResourceMiscFlags_Inv(uint32_t value) - { - uint32_t _flag = 0; - - if (value & D3D11_RESOURCE_MISC_SHARED) - _flag |= RESOURCE_MISC_SHARED; - if (value & D3D11_RESOURCE_MISC_TEXTURECUBE) - _flag |= RESOURCE_MISC_TEXTURECUBE; - if (value & D3D11_RESOURCE_MISC_DRAWINDIRECT_ARGS) - _flag |= RESOURCE_MISC_INDIRECT_ARGS; - if (value & D3D11_RESOURCE_MISC_BUFFER_ALLOW_RAW_VIEWS) - _flag |= RESOURCE_MISC_BUFFER_ALLOW_RAW_VIEWS; - if (value & D3D11_RESOURCE_MISC_BUFFER_STRUCTURED) - _flag |= RESOURCE_MISC_BUFFER_STRUCTURED; - if (value & D3D11_RESOURCE_MISC_TILED) - _flag |= RESOURCE_MISC_TILED; - - return _flag; - } - - constexpr FORMAT _ConvertFormat_Inv(DXGI_FORMAT value) - { - switch (value) - { - case DXGI_FORMAT_UNKNOWN: - return FORMAT_UNKNOWN; - break; - case DXGI_FORMAT_R32G32B32A32_FLOAT: - return FORMAT_R32G32B32A32_FLOAT; - break; - case DXGI_FORMAT_R32G32B32A32_UINT: - return FORMAT_R32G32B32A32_UINT; - break; - case DXGI_FORMAT_R32G32B32A32_SINT: - return FORMAT_R32G32B32A32_SINT; - break; - case DXGI_FORMAT_R32G32B32_FLOAT: - return FORMAT_R32G32B32_FLOAT; - break; - case DXGI_FORMAT_R32G32B32_UINT: - return FORMAT_R32G32B32_UINT; - break; - case DXGI_FORMAT_R32G32B32_SINT: - return FORMAT_R32G32B32_SINT; - break; - case DXGI_FORMAT_R16G16B16A16_FLOAT: - return FORMAT_R16G16B16A16_FLOAT; - break; - case DXGI_FORMAT_R16G16B16A16_UNORM: - return FORMAT_R16G16B16A16_UNORM; - break; - case DXGI_FORMAT_R16G16B16A16_UINT: - return FORMAT_R16G16B16A16_UINT; - break; - case DXGI_FORMAT_R16G16B16A16_SNORM: - return FORMAT_R16G16B16A16_SNORM; - break; - case DXGI_FORMAT_R16G16B16A16_SINT: - return FORMAT_R16G16B16A16_SINT; - break; - case DXGI_FORMAT_R32G32_FLOAT: - return FORMAT_R32G32_FLOAT; - break; - case DXGI_FORMAT_R32G32_UINT: - return FORMAT_R32G32_UINT; - break; - case DXGI_FORMAT_R32G32_SINT: - return FORMAT_R32G32_SINT; - break; - case DXGI_FORMAT_R32G8X24_TYPELESS: - return FORMAT_R32G8X24_TYPELESS; - break; - case DXGI_FORMAT_D32_FLOAT_S8X24_UINT: - return FORMAT_D32_FLOAT_S8X24_UINT; - break; - case DXGI_FORMAT_R10G10B10A2_UNORM: - return FORMAT_R10G10B10A2_UNORM; - break; - case DXGI_FORMAT_R10G10B10A2_UINT: - return FORMAT_R10G10B10A2_UINT; - break; - case DXGI_FORMAT_R11G11B10_FLOAT: - return FORMAT_R11G11B10_FLOAT; - break; - case DXGI_FORMAT_R8G8B8A8_UNORM: - return FORMAT_R8G8B8A8_UNORM; - break; - case DXGI_FORMAT_R8G8B8A8_UNORM_SRGB: - return FORMAT_R8G8B8A8_UNORM_SRGB; - break; - case DXGI_FORMAT_R8G8B8A8_UINT: - return FORMAT_R8G8B8A8_UINT; - break; - case DXGI_FORMAT_R8G8B8A8_SNORM: - return FORMAT_R8G8B8A8_SNORM; - break; - case DXGI_FORMAT_R8G8B8A8_SINT: - return FORMAT_R8G8B8A8_SINT; - break; - case DXGI_FORMAT_R16G16_FLOAT: - return FORMAT_R16G16_FLOAT; - break; - case DXGI_FORMAT_R16G16_UNORM: - return FORMAT_R16G16_UNORM; - break; - case DXGI_FORMAT_R16G16_UINT: - return FORMAT_R16G16_UINT; - break; - case DXGI_FORMAT_R16G16_SNORM: - return FORMAT_R16G16_SNORM; - break; - case DXGI_FORMAT_R16G16_SINT: - return FORMAT_R16G16_SINT; - break; - case DXGI_FORMAT_R32_TYPELESS: - return FORMAT_R32_TYPELESS; - break; - case DXGI_FORMAT_D32_FLOAT: - return FORMAT_D32_FLOAT; - break; - case DXGI_FORMAT_R32_FLOAT: - return FORMAT_R32_FLOAT; - break; - case DXGI_FORMAT_R32_UINT: - return FORMAT_R32_UINT; - break; - case DXGI_FORMAT_R32_SINT: - return FORMAT_R32_SINT; - break; - case DXGI_FORMAT_R24G8_TYPELESS: - return FORMAT_R24G8_TYPELESS; - break; - case DXGI_FORMAT_D24_UNORM_S8_UINT: - return FORMAT_D24_UNORM_S8_UINT; - break; - case DXGI_FORMAT_R8G8_UNORM: - return FORMAT_R8G8_UNORM; - break; - case DXGI_FORMAT_R8G8_UINT: - return FORMAT_R8G8_UINT; - break; - case DXGI_FORMAT_R8G8_SNORM: - return FORMAT_R8G8_SNORM; - break; - case DXGI_FORMAT_R8G8_SINT: - return FORMAT_R8G8_SINT; - break; - case DXGI_FORMAT_R16_TYPELESS: - return FORMAT_R16_TYPELESS; - break; - case DXGI_FORMAT_R16_FLOAT: - return FORMAT_R16_FLOAT; - break; - case DXGI_FORMAT_D16_UNORM: - return FORMAT_D16_UNORM; - break; - case DXGI_FORMAT_R16_UNORM: - return FORMAT_R16_UNORM; - break; - case DXGI_FORMAT_R16_UINT: - return FORMAT_R16_UINT; - break; - case DXGI_FORMAT_R16_SNORM: - return FORMAT_R16_SNORM; - break; - case DXGI_FORMAT_R16_SINT: - return FORMAT_R16_SINT; - break; - case DXGI_FORMAT_R8_UNORM: - return FORMAT_R8_UNORM; - break; - case DXGI_FORMAT_R8_UINT: - return FORMAT_R8_UINT; - break; - case DXGI_FORMAT_R8_SNORM: - return FORMAT_R8_SNORM; - break; - case DXGI_FORMAT_R8_SINT: - return FORMAT_R8_SINT; - break; - case DXGI_FORMAT_BC1_UNORM: - return FORMAT_BC1_UNORM; - break; - case DXGI_FORMAT_BC1_UNORM_SRGB: - return FORMAT_BC1_UNORM_SRGB; - break; - case DXGI_FORMAT_BC2_UNORM: - return FORMAT_BC2_UNORM; - break; - case DXGI_FORMAT_BC2_UNORM_SRGB: - return FORMAT_BC2_UNORM_SRGB; - break; - case DXGI_FORMAT_BC3_UNORM: - return FORMAT_BC3_UNORM; - break; - case DXGI_FORMAT_BC3_UNORM_SRGB: - return FORMAT_BC3_UNORM_SRGB; - break; - case DXGI_FORMAT_BC4_UNORM: - return FORMAT_BC4_UNORM; - break; - case DXGI_FORMAT_BC4_SNORM: - return FORMAT_BC4_SNORM; - break; - case DXGI_FORMAT_BC5_UNORM: - return FORMAT_BC5_UNORM; - break; - case DXGI_FORMAT_BC5_SNORM: - return FORMAT_BC5_SNORM; - break; - case DXGI_FORMAT_B8G8R8A8_UNORM: - return FORMAT_B8G8R8A8_UNORM; - break; - case DXGI_FORMAT_B8G8R8A8_UNORM_SRGB: - return FORMAT_B8G8R8A8_UNORM_SRGB; - break; - case DXGI_FORMAT_BC6H_UF16: - return FORMAT_BC6H_UF16; - break; - case DXGI_FORMAT_BC6H_SF16: - return FORMAT_BC6H_SF16; - break; - case DXGI_FORMAT_BC7_UNORM: - return FORMAT_BC7_UNORM; - break; - case DXGI_FORMAT_BC7_UNORM_SRGB: - return FORMAT_BC7_UNORM_SRGB; - break; - } - return FORMAT_UNKNOWN; - } - constexpr USAGE _ConvertUsage_Inv(D3D11_USAGE value) - { - switch (value) - { - case D3D11_USAGE_DEFAULT: - return USAGE_DEFAULT; - break; - case D3D11_USAGE_IMMUTABLE: - return USAGE_IMMUTABLE; - break; - case D3D11_USAGE_DYNAMIC: - return USAGE_DYNAMIC; - break; - case D3D11_USAGE_STAGING: - return USAGE_STAGING; - break; - default: - break; - } - return USAGE_DEFAULT; - } - - inline TextureDesc _ConvertTextureDesc_Inv(const D3D11_TEXTURE1D_DESC* pDesc) - { - TextureDesc desc; - desc.Width = pDesc->Width; - desc.MipLevels = pDesc->MipLevels; - desc.ArraySize = pDesc->ArraySize; - desc.Format = _ConvertFormat_Inv(pDesc->Format); - desc.Usage = _ConvertUsage_Inv(pDesc->Usage); - desc.BindFlags = _ParseBindFlags_Inv(pDesc->BindFlags); - desc.CPUAccessFlags = _ParseCPUAccessFlags_Inv(pDesc->CPUAccessFlags); - desc.MiscFlags = _ParseResourceMiscFlags_Inv(pDesc->MiscFlags); - - return desc; - } - inline TextureDesc _ConvertTextureDesc_Inv(const D3D11_TEXTURE2D_DESC* pDesc) - { - TextureDesc desc; - desc.Width = pDesc->Width; - desc.Height = pDesc->Height; - desc.MipLevels = pDesc->MipLevels; - desc.ArraySize = pDesc->ArraySize; - desc.Format = _ConvertFormat_Inv(pDesc->Format); - desc.SampleCount = pDesc->SampleDesc.Count; - desc.Usage = _ConvertUsage_Inv(pDesc->Usage); - desc.BindFlags = _ParseBindFlags_Inv(pDesc->BindFlags); - desc.CPUAccessFlags = _ParseCPUAccessFlags_Inv(pDesc->CPUAccessFlags); - desc.MiscFlags = _ParseResourceMiscFlags_Inv(pDesc->MiscFlags); - - return desc; - } - inline TextureDesc _ConvertTextureDesc_Inv(const D3D11_TEXTURE3D_DESC* pDesc) - { - TextureDesc desc; - desc.Width = pDesc->Width; - desc.Height = pDesc->Height; - desc.Depth = pDesc->Depth; - desc.MipLevels = pDesc->MipLevels; - desc.Format = _ConvertFormat_Inv(pDesc->Format); - desc.Usage = _ConvertUsage_Inv(pDesc->Usage); - desc.BindFlags = _ParseBindFlags_Inv(pDesc->BindFlags); - desc.CPUAccessFlags = _ParseCPUAccessFlags_Inv(pDesc->CPUAccessFlags); - desc.MiscFlags = _ParseResourceMiscFlags_Inv(pDesc->MiscFlags); - - return desc; - } - - - // Local Helpers: - const void* const __nullBlob[128] = {}; // this is initialized to nullptrs and used to unbind resources! - - - struct Resource_DX11 - { - ComPtr resource; - ComPtr srv; - ComPtr uav; - std::vector> subresources_srv; - std::vector> subresources_uav; - }; - struct Texture_DX11 : public Resource_DX11 - { - ComPtr rtv; - ComPtr dsv; - std::vector> subresources_rtv; - std::vector> subresources_dsv; - }; - struct VertexShader_DX11 - { - ComPtr resource; - std::vector shadercode; - }; - struct HullShader_DX11 - { - ComPtr resource; - }; - struct DomainShader_DX11 - { - ComPtr resource; - }; - struct GeometryShader_DX11 - { - ComPtr resource; - }; - struct PixelShader_DX11 - { - ComPtr resource; - }; - struct ComputeShader_DX11 - { - ComPtr resource; - }; - struct PipelineState_DX11 - { - ComPtr bs; - ComPtr dss; - ComPtr rs; - ComPtr il; - }; - struct Sampler_DX11 - { - ComPtr resource; - }; - struct QueryHeap_DX11 - { - std::vector> resources; - }; - struct SwapChain_DX11 - { - Microsoft::WRL::ComPtr swapChain; - Microsoft::WRL::ComPtr renderTargetView; - Microsoft::WRL::ComPtr backBuffer; - }; - - Resource_DX11* to_internal(const GPUResource* param) - { - return static_cast(param->internal_state.get()); - } - Resource_DX11* to_internal(const GPUBuffer* param) - { - return static_cast(param->internal_state.get()); - } - Texture_DX11* to_internal(const Texture* param) - { - return static_cast(param->internal_state.get()); - } - PipelineState_DX11* to_internal(const PipelineState* param) - { - return static_cast(param->internal_state.get()); - } - Sampler_DX11* to_internal(const Sampler* param) - { - return static_cast(param->internal_state.get()); - } - QueryHeap_DX11* to_internal(const GPUQueryHeap* param) - { - return static_cast(param->internal_state.get()); - } - SwapChain_DX11* to_internal(const SwapChain* param) - { - return static_cast(param->internal_state.get()); - } -} -using namespace DX11_Internal; - -void GraphicsDevice_DX11::pso_validate(CommandList cmd) -{ - if (!dirty_pso[cmd]) - return; - - const PipelineState* pso = active_pso[cmd]; - const PipelineStateDesc& desc = pso != nullptr ? pso->GetDesc() : PipelineStateDesc(); - - auto internal_state = to_internal(pso); - - ID3D11VertexShader* vs = desc.vs == nullptr ? nullptr : static_cast(desc.vs->internal_state.get())->resource.Get(); - if (vs != prev_vs[cmd]) - { - deviceContexts[cmd]->VSSetShader(vs, nullptr, 0); - prev_vs[cmd] = vs; - - if (desc.vs != nullptr) - { - for (auto& x : desc.vs->auto_samplers) - { - BindSampler(VS, &x.sampler, x.slot, cmd); - } - } - } - ID3D11PixelShader* ps = desc.ps == nullptr ? nullptr : static_cast(desc.ps->internal_state.get())->resource.Get(); - if (ps != prev_ps[cmd]) - { - deviceContexts[cmd]->PSSetShader(ps, nullptr, 0); - prev_ps[cmd] = ps; - - if (desc.ps != nullptr) - { - for (auto& x : desc.ps->auto_samplers) - { - BindSampler(PS, &x.sampler, x.slot, cmd); - } - } - } - ID3D11HullShader* hs = desc.hs == nullptr ? nullptr : static_cast(desc.hs->internal_state.get())->resource.Get(); - if (hs != prev_hs[cmd]) - { - deviceContexts[cmd]->HSSetShader(hs, nullptr, 0); - prev_hs[cmd] = hs; - - if (desc.hs != nullptr) - { - for (auto& x : desc.hs->auto_samplers) - { - BindSampler(HS, &x.sampler, x.slot, cmd); - } - } - } - ID3D11DomainShader* ds = desc.ds == nullptr ? nullptr : static_cast(desc.ds->internal_state.get())->resource.Get(); - if (ds != prev_ds[cmd]) - { - deviceContexts[cmd]->DSSetShader(ds, nullptr, 0); - prev_ds[cmd] = ds; - - if (desc.ds != nullptr) - { - for (auto& x : desc.ds->auto_samplers) - { - BindSampler(DS, &x.sampler, x.slot, cmd); - } - } - } - ID3D11GeometryShader* gs = desc.gs == nullptr ? nullptr : static_cast(desc.gs->internal_state.get())->resource.Get(); - if (gs != prev_gs[cmd]) - { - deviceContexts[cmd]->GSSetShader(gs, nullptr, 0); - prev_gs[cmd] = gs; - - if (desc.gs != nullptr) - { - for (auto& x : desc.gs->auto_samplers) - { - BindSampler(GS, &x.sampler, x.slot, cmd); - } - } - } - - ID3D11BlendState* bs = desc.bs == nullptr ? nullptr : internal_state->bs.Get(); - if (desc.bs != prev_bs[cmd] || desc.sampleMask != prev_samplemask[cmd] || - blendFactor[cmd].x != prev_blendfactor[cmd].x || - blendFactor[cmd].y != prev_blendfactor[cmd].y || - blendFactor[cmd].z != prev_blendfactor[cmd].z || - blendFactor[cmd].w != prev_blendfactor[cmd].w - ) - { - const float fact[4] = { blendFactor[cmd].x, blendFactor[cmd].y, blendFactor[cmd].z, blendFactor[cmd].w }; - deviceContexts[cmd]->OMSetBlendState(bs, fact, desc.sampleMask); - prev_bs[cmd] = desc.bs; - prev_blendfactor[cmd] = blendFactor[cmd]; - prev_samplemask[cmd] = desc.sampleMask; - } - - ID3D11RasterizerState* rs = desc.rs == nullptr ? nullptr : internal_state->rs.Get(); - if (desc.rs != prev_rs[cmd]) - { - deviceContexts[cmd]->RSSetState(rs); - prev_rs[cmd] = desc.rs; - } - - ID3D11DepthStencilState* dss = desc.dss == nullptr ? nullptr : internal_state->dss.Get(); - if (desc.dss != prev_dss[cmd] || stencilRef[cmd] != prev_stencilRef[cmd]) - { - deviceContexts[cmd]->OMSetDepthStencilState(dss, stencilRef[cmd]); - prev_dss[cmd] = desc.dss; - prev_stencilRef[cmd] = stencilRef[cmd]; - } - - ID3D11InputLayout* il = desc.il == nullptr ? nullptr : internal_state->il.Get(); - if (desc.il != prev_il[cmd]) - { - deviceContexts[cmd]->IASetInputLayout(il); - prev_il[cmd] = desc.il; - } - - if (prev_pt[cmd] != desc.pt) - { - D3D11_PRIMITIVE_TOPOLOGY d3dType = D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST; - switch (desc.pt) - { - case TRIANGLELIST: - d3dType = D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST; - break; - case TRIANGLESTRIP: - d3dType = D3D11_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP; - break; - case POINTLIST: - d3dType = D3D11_PRIMITIVE_TOPOLOGY_POINTLIST; - break; - case LINELIST: - d3dType = D3D11_PRIMITIVE_TOPOLOGY_LINELIST; - break; - case LINESTRIP: - d3dType = D3D11_PRIMITIVE_TOPOLOGY_LINESTRIP; - break; - case PATCHLIST: - d3dType = D3D11_PRIMITIVE_TOPOLOGY_3_CONTROL_POINT_PATCHLIST; - break; - default: - d3dType = D3D11_PRIMITIVE_TOPOLOGY_UNDEFINED; - break; - }; - deviceContexts[cmd]->IASetPrimitiveTopology(d3dType); - - prev_pt[cmd] = desc.pt; - } -} - -// Engine functions -GraphicsDevice_DX11::GraphicsDevice_DX11(bool debuglayer) -{ - DEBUGDEVICE = debuglayer; - -#ifndef PLATFORM_UWP - HMODULE dx11 = LoadLibraryEx(L"d3d11.dll", nullptr, LOAD_LIBRARY_SEARCH_SYSTEM32); - - D3D11CreateDevice = (PFN_D3D11_CREATE_DEVICE)GetProcAddress(dx11, "D3D11CreateDevice"); - assert(D3D11CreateDevice != nullptr); -#endif // PLATFORM_UWP - - HRESULT hr = E_FAIL; - - uint32_t createDeviceFlags = 0; - - if (debuglayer) - { - createDeviceFlags |= D3D11_CREATE_DEVICE_DEBUG; - } - - D3D_DRIVER_TYPE driverTypes[] = - { - D3D_DRIVER_TYPE_HARDWARE, - D3D_DRIVER_TYPE_WARP, - D3D_DRIVER_TYPE_REFERENCE, - }; - uint32_t numDriverTypes = arraysize(driverTypes); - - D3D_FEATURE_LEVEL featureLevels[] = - { - D3D_FEATURE_LEVEL_11_1, - D3D_FEATURE_LEVEL_11_0, - }; - uint32_t numFeatureLevels = arraysize(featureLevels); - - for (uint32_t driverTypeIndex = 0; driverTypeIndex < numDriverTypes; driverTypeIndex++) - { - driverType = driverTypes[driverTypeIndex]; - hr = D3D11CreateDevice(nullptr, driverType, nullptr, createDeviceFlags, featureLevels, numFeatureLevels, D3D11_SDK_VERSION, &device - , &featureLevel, &immediateContext); - - if (SUCCEEDED(hr)) - break; - } - if (FAILED(hr)) - { - std::stringstream ss(""); - ss << "Failed to create the graphics device! ERROR: " << std::hex << hr; - wiHelper::messageBox(ss.str(), "Error!"); - wiPlatform::Exit(); - } - - ComPtr pDXGIDevice; - hr = device.As(&pDXGIDevice); - assert(SUCCEEDED(hr)); - - // Ensure that DXGI does not queue more than one frame at a time. This both reduces latency and - // ensures that the application will only render after each VSync, minimizing power consumption. - hr = pDXGIDevice->SetMaximumFrameLatency(1); - assert(SUCCEEDED(hr)); - - ComPtr DXGIAdapter; - hr = pDXGIDevice->GetParent(__uuidof(IDXGIAdapter), (void**)&DXGIAdapter); - assert(SUCCEEDED(hr)); - - hr = DXGIAdapter->GetParent(__uuidof(IDXGIFactory2), (void**)&DXGIFactory); - assert(SUCCEEDED(hr)); - - if (debuglayer) - { - ID3D11Debug* d3dDebug = nullptr; - if (SUCCEEDED(device->QueryInterface(__uuidof(ID3D11Debug), (void**)&d3dDebug))) - { - ID3D11InfoQueue* d3dInfoQueue = nullptr; - if (SUCCEEDED(d3dDebug->QueryInterface(__uuidof(ID3D11InfoQueue), (void**)&d3dInfoQueue))) - { - d3dInfoQueue->SetBreakOnSeverity(D3D11_MESSAGE_SEVERITY_CORRUPTION, true); - d3dInfoQueue->SetBreakOnSeverity(D3D11_MESSAGE_SEVERITY_ERROR, true); - - D3D11_MESSAGE_ID hide[] = - { - D3D11_MESSAGE_ID_SETPRIVATEDATA_CHANGINGPARAMS, - // Add more message IDs here as needed - }; - - D3D11_INFO_QUEUE_FILTER filter = {}; - filter.DenyList.NumIDs = _countof(hide); - filter.DenyList.pIDList = hide; - d3dInfoQueue->AddStorageFilterEntries(&filter); - d3dInfoQueue->Release(); - } - d3dDebug->Release(); - } - } - - D3D11_QUERY_DESC queryDesc = {}; - queryDesc.Query = D3D11_QUERY_TIMESTAMP_DISJOINT; - for (auto& x : disjointQueries) - { - hr = device->CreateQuery(&queryDesc, &x); - assert(SUCCEEDED(hr)); - } - - D3D_FEATURE_LEVEL aquiredFeatureLevel = device->GetFeatureLevel(); - if (aquiredFeatureLevel >= D3D_FEATURE_LEVEL_11_0) - { - capabilities |= GRAPHICSDEVICE_CAPABILITY_TESSELLATION; - } - - //D3D11_FEATURE_DATA_D3D11_OPTIONS features_0; - //hr = device->CheckFeatureSupport(D3D11_FEATURE_D3D11_OPTIONS, &features_0, sizeof(features_0)); - - //D3D11_FEATURE_DATA_D3D11_OPTIONS1 features_1; - //hr = device->CheckFeatureSupport(D3D11_FEATURE_D3D11_OPTIONS1, &features_1, sizeof(features_1)); - - D3D11_FEATURE_DATA_D3D11_OPTIONS2 features_2; - hr = device->CheckFeatureSupport(D3D11_FEATURE_D3D11_OPTIONS2, &features_2, sizeof(features_2)); - if (features_2.ConservativeRasterizationTier >= D3D11_CONSERVATIVE_RASTERIZATION_TIER_1) - { - capabilities |= GRAPHICSDEVICE_CAPABILITY_CONSERVATIVE_RASTERIZATION; - } - if (features_2.ROVsSupported == TRUE) - { - capabilities |= GRAPHICSDEVICE_CAPABILITY_RASTERIZER_ORDERED_VIEWS; - } - - if (features_2.TypedUAVLoadAdditionalFormats) - { - // More info about UAV format load support: https://docs.microsoft.com/en-us/windows/win32/direct3d12/typed-unordered-access-view-loads - capabilities |= GRAPHICSDEVICE_CAPABILITY_UAV_LOAD_FORMAT_COMMON; - - D3D11_FEATURE_DATA_FORMAT_SUPPORT2 FormatSupport = {}; - FormatSupport.InFormat = DXGI_FORMAT_R11G11B10_FLOAT; - hr = device->CheckFeatureSupport(D3D11_FEATURE_FORMAT_SUPPORT2, &FormatSupport, sizeof(FormatSupport)); - if (SUCCEEDED(hr) && (FormatSupport.OutFormatSupport2 & D3D11_FORMAT_SUPPORT2_UAV_TYPED_LOAD) != 0) - { - capabilities |= GRAPHICSDEVICE_CAPABILITY_UAV_LOAD_FORMAT_R11G11B10_FLOAT; - } - } - - D3D11_FEATURE_DATA_D3D11_OPTIONS3 features_3; - hr = device->CheckFeatureSupport(D3D11_FEATURE_D3D11_OPTIONS3, &features_3, sizeof(features_3)); - if (features_3.VPAndRTArrayIndexFromAnyShaderFeedingRasterizer == TRUE) - { - capabilities |= GRAPHICSDEVICE_CAPABILITY_RENDERTARGET_AND_VIEWPORT_ARRAYINDEX_WITHOUT_GS; - } - - CreateBackBufferResources(); - - emptyresource = std::make_shared(); - - wiBackLog::post("Created GraphicsDevice_DX11"); -} - -void GraphicsDevice_DX11::CreateBackBufferResources() -{ - //HRESULT hr; - - //hr = swapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), &backBuffer); - //if (FAILED(hr)) { - // wiHelper::messageBox("BackBuffer creation Failed!", "Error!"); - // wiPlatform::Exit(); - //} - - //hr = device->CreateRenderTargetView(backBuffer.Get(), nullptr, &renderTargetView); - //if (FAILED(hr)) { - // wiHelper::messageBox("Main Rendertarget creation Failed!", "Error!"); - // wiPlatform::Exit(); - //} -} - -bool GraphicsDevice_DX11::CreateSwapChain(const SwapChainDesc* pDesc, wiPlatform::window_type window, SwapChain* swapChain) const -{ - auto internal_state = std::static_pointer_cast(swapChain->internal_state); - if (swapChain->internal_state == nullptr) - { - internal_state = std::make_shared(); - } - swapChain->internal_state = internal_state; - swapChain->desc = *pDesc; - HRESULT hr; - - if (internal_state->swapChain == nullptr) - { - // Create swapchain: - DXGI_SWAP_CHAIN_DESC1 sd = {}; - sd.Width = pDesc->width; - sd.Height = pDesc->height; - sd.Format = _ConvertFormat(pDesc->format); - sd.Stereo = false; - sd.SampleDesc.Count = 1; - sd.SampleDesc.Quality = 0; - sd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT; - sd.BufferCount = pDesc->buffercount; - sd.Flags = 0; - sd.AlphaMode = DXGI_ALPHA_MODE_IGNORE; - sd.SwapEffect = DXGI_SWAP_EFFECT_FLIP_DISCARD; - -#ifdef PLATFORM_UWP - sd.Scaling = DXGI_SCALING_ASPECT_RATIO_STRETCH; - - hr = DXGIFactory->CreateSwapChainForCoreWindow( - device.Get(), - static_cast(winrt::get_abi(*window)), - &sd, - nullptr, - &internal_state->swapChain - ); -#else - sd.Scaling = DXGI_SCALING_STRETCH; - - DXGI_SWAP_CHAIN_FULLSCREEN_DESC fullscreenDesc; - fullscreenDesc.RefreshRate.Numerator = 60; - fullscreenDesc.RefreshRate.Denominator = 1; - fullscreenDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED; // needs to be unspecified for correct fullscreen scaling! - fullscreenDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_PROGRESSIVE; - fullscreenDesc.Windowed = !pDesc->fullscreen; - hr = DXGIFactory->CreateSwapChainForHwnd( - device.Get(), - window, - &sd, - &fullscreenDesc, - nullptr, - &internal_state->swapChain - ); -#endif - - if (FAILED(hr)) - { - return false; - } - } - else - { - // Resize swapchain: - internal_state->backBuffer.Reset(); - internal_state->renderTargetView.Reset(); - - hr = internal_state->swapChain->ResizeBuffers( - pDesc->buffercount, - pDesc->width, - pDesc->height, - _ConvertFormat(pDesc->format), - 0 - ); - assert(SUCCEEDED(hr)); - } - - hr = internal_state->swapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), &internal_state->backBuffer); - if (FAILED(hr)) - { - return false; - } - - hr = device->CreateRenderTargetView(internal_state->backBuffer.Get(), nullptr, &internal_state->renderTargetView); - if (FAILED(hr)) - { - return false; - } - - return true; -} -bool GraphicsDevice_DX11::CreateBuffer(const GPUBufferDesc *pDesc, const SubresourceData* pInitialData, GPUBuffer *pBuffer) const -{ - auto internal_state = std::make_shared(); - pBuffer->internal_state = internal_state; - pBuffer->type = GPUResource::GPU_RESOURCE_TYPE::BUFFER; - - D3D11_BUFFER_DESC desc; - desc.ByteWidth = pDesc->ByteWidth; - desc.Usage = _ConvertUsage(pDesc->Usage); - desc.BindFlags = _ParseBindFlags(pDesc->BindFlags); - desc.CPUAccessFlags = _ParseCPUAccessFlags(pDesc->CPUAccessFlags); - desc.MiscFlags = _ParseResourceMiscFlags(pDesc->MiscFlags); - desc.StructureByteStride = pDesc->StructureByteStride; - - D3D11_SUBRESOURCE_DATA data; - if (pInitialData != nullptr) - { - data = _ConvertSubresourceData(*pInitialData); - } - - pBuffer->desc = *pDesc; - HRESULT hr = device->CreateBuffer(&desc, pInitialData == nullptr ? nullptr : &data, (ID3D11Buffer**)internal_state->resource.ReleaseAndGetAddressOf()); - assert(SUCCEEDED(hr) && "GPUBuffer creation failed!"); - - if (SUCCEEDED(hr)) - { - // Create resource views if needed - if (pDesc->BindFlags & BIND_SHADER_RESOURCE) - { - CreateSubresource(pBuffer, SRV, 0); - } - if (pDesc->BindFlags & BIND_UNORDERED_ACCESS) - { - CreateSubresource(pBuffer, UAV, 0); - } - } - - return SUCCEEDED(hr); -} -bool GraphicsDevice_DX11::CreateTexture(const TextureDesc* pDesc, const SubresourceData *pInitialData, Texture *pTexture) const -{ - auto internal_state = std::make_shared(); - pTexture->internal_state = internal_state; - pTexture->type = GPUResource::GPU_RESOURCE_TYPE::TEXTURE; - - pTexture->desc = *pDesc; - - std::vector data; - if (pInitialData != nullptr) - { - uint32_t dataCount = pDesc->ArraySize * std::max(1u, pDesc->MipLevels); - data.resize(dataCount); - for (uint32_t slice = 0; slice < dataCount; ++slice) - { - data[slice] = _ConvertSubresourceData(pInitialData[slice]); - } - } - - HRESULT hr = S_OK; - - switch (pTexture->desc.type) - { - case TextureDesc::TEXTURE_1D: - { - D3D11_TEXTURE1D_DESC desc = _ConvertTextureDesc1D(&pTexture->desc); - hr = device->CreateTexture1D(&desc, data.data(), (ID3D11Texture1D**)internal_state->resource.ReleaseAndGetAddressOf()); - } - break; - case TextureDesc::TEXTURE_2D: - { - D3D11_TEXTURE2D_DESC desc = _ConvertTextureDesc2D(&pTexture->desc); - hr = device->CreateTexture2D(&desc, data.data(), (ID3D11Texture2D**)internal_state->resource.ReleaseAndGetAddressOf()); - } - break; - case TextureDesc::TEXTURE_3D: - { - D3D11_TEXTURE3D_DESC desc = _ConvertTextureDesc3D(&pTexture->desc); - hr = device->CreateTexture3D(&desc, data.data(), (ID3D11Texture3D**)internal_state->resource.ReleaseAndGetAddressOf()); - } - break; - default: - assert(0); - break; - } - - assert(SUCCEEDED(hr)); - if (FAILED(hr)) - return SUCCEEDED(hr); - - if (pTexture->desc.MipLevels == 0) - { - pTexture->desc.MipLevels = (uint32_t)log2(std::max(pTexture->desc.Width, pTexture->desc.Height)) + 1; - } - - if (pTexture->desc.BindFlags & BIND_RENDER_TARGET) - { - CreateSubresource(pTexture, RTV, 0, -1, 0, -1); - } - if (pTexture->desc.BindFlags & BIND_DEPTH_STENCIL) - { - CreateSubresource(pTexture, DSV, 0, -1, 0, -1); - } - if (pTexture->desc.BindFlags & BIND_SHADER_RESOURCE) - { - CreateSubresource(pTexture, SRV, 0, -1, 0, -1); - } - if (pTexture->desc.BindFlags & BIND_UNORDERED_ACCESS) - { - CreateSubresource(pTexture, UAV, 0, -1, 0, -1); - } - - return SUCCEEDED(hr); -} -bool GraphicsDevice_DX11::CreateShader(SHADERSTAGE stage, const void *pShaderBytecode, size_t BytecodeLength, Shader *pShader) const -{ - pShader->stage = stage; - - HRESULT hr = E_FAIL; - - switch (stage) - { - case wiGraphics::VS: - { - auto internal_state = std::make_shared(); - pShader->internal_state = internal_state; - internal_state->shadercode.resize(BytecodeLength); - std::memcpy(internal_state->shadercode.data(), pShaderBytecode, BytecodeLength); - hr = device->CreateVertexShader(pShaderBytecode, BytecodeLength, nullptr, &internal_state->resource); - } - break; - case wiGraphics::HS: - { - auto internal_state = std::make_shared(); - pShader->internal_state = internal_state; - hr = device->CreateHullShader(pShaderBytecode, BytecodeLength, nullptr, &internal_state->resource); - } - break; - case wiGraphics::DS: - { - auto internal_state = std::make_shared(); - pShader->internal_state = internal_state; - hr = device->CreateDomainShader(pShaderBytecode, BytecodeLength, nullptr, &internal_state->resource); - } - break; - case wiGraphics::GS: - { - auto internal_state = std::make_shared(); - pShader->internal_state = internal_state; - hr = device->CreateGeometryShader(pShaderBytecode, BytecodeLength, nullptr, &internal_state->resource); - } - break; - case wiGraphics::PS: - { - auto internal_state = std::make_shared(); - pShader->internal_state = internal_state; - hr = device->CreatePixelShader(pShaderBytecode, BytecodeLength, nullptr, &internal_state->resource); - } - break; - case wiGraphics::CS: - { - auto internal_state = std::make_shared(); - pShader->internal_state = internal_state; - hr = device->CreateComputeShader(pShaderBytecode, BytecodeLength, nullptr, &internal_state->resource); - } - break; - } - - assert(SUCCEEDED(hr)); - - return SUCCEEDED(hr); -} -bool GraphicsDevice_DX11::CreateSampler(const SamplerDesc *pSamplerDesc, Sampler *pSamplerState) const -{ - auto internal_state = std::make_shared(); - pSamplerState->internal_state = internal_state; - - D3D11_SAMPLER_DESC desc; - desc.Filter = _ConvertFilter(pSamplerDesc->Filter); - desc.AddressU = _ConvertTextureAddressMode(pSamplerDesc->AddressU); - desc.AddressV = _ConvertTextureAddressMode(pSamplerDesc->AddressV); - desc.AddressW = _ConvertTextureAddressMode(pSamplerDesc->AddressW); - desc.MipLODBias = pSamplerDesc->MipLODBias; - desc.MaxAnisotropy = pSamplerDesc->MaxAnisotropy; - desc.ComparisonFunc = _ConvertComparisonFunc(pSamplerDesc->ComparisonFunc); - switch (pSamplerDesc->BorderColor) - { - case SAMPLER_BORDER_COLOR_OPAQUE_BLACK: - desc.BorderColor[0] = 0.0f; - desc.BorderColor[1] = 0.0f; - desc.BorderColor[2] = 0.0f; - desc.BorderColor[3] = 1.0f; - break; - - case SAMPLER_BORDER_COLOR_OPAQUE_WHITE: - desc.BorderColor[0] = 1.0f; - desc.BorderColor[1] = 1.0f; - desc.BorderColor[2] = 1.0f; - desc.BorderColor[3] = 1.0f; - break; - - default: - desc.BorderColor[0] = 0.0f; - desc.BorderColor[1] = 0.0f; - desc.BorderColor[2] = 0.0f; - desc.BorderColor[3] = 0.0f; - break; - } - desc.MinLOD = pSamplerDesc->MinLOD; - desc.MaxLOD = pSamplerDesc->MaxLOD; - - pSamplerState->desc = *pSamplerDesc; - HRESULT hr = device->CreateSamplerState(&desc, &internal_state->resource); - assert(SUCCEEDED(hr)); - - return SUCCEEDED(hr); -} -bool GraphicsDevice_DX11::CreateQueryHeap(const GPUQueryHeapDesc* pDesc, GPUQueryHeap* pQueryHeap) const -{ - auto internal_state = std::make_shared(); - pQueryHeap->internal_state = internal_state; - - pQueryHeap->desc = *pDesc; - - D3D11_QUERY_DESC desc; - desc.MiscFlags = 0; - desc.Query = D3D11_QUERY_EVENT; - switch (pDesc->type) - { - default: - case GPU_QUERY_TYPE_TIMESTAMP: - desc.Query = D3D11_QUERY_TIMESTAMP; - break; - case GPU_QUERY_TYPE_OCCLUSION: - desc.Query = D3D11_QUERY_OCCLUSION; - break; - case GPU_QUERY_TYPE_OCCLUSION_BINARY: - desc.Query = D3D11_QUERY_OCCLUSION_PREDICATE; - break; - } - - internal_state->resources.resize(pDesc->queryCount); - for (uint32_t i = 0; i < pDesc->queryCount; ++i) - { - HRESULT hr = device->CreateQuery(&desc, &internal_state->resources[i]); - if (!SUCCEEDED(hr)) - { - return false; - } - } - - return true; -} -bool GraphicsDevice_DX11::CreatePipelineState(const PipelineStateDesc* pDesc, PipelineState* pso) const -{ - auto internal_state = std::make_shared(); - pso->internal_state = internal_state; - - pso->desc = *pDesc; - - HRESULT hr; - - - - if (pDesc->il != nullptr) - { - std::vector desc(pDesc->il->elements.size()); - for (size_t i = 0; i < desc.size(); ++i) - { - desc[i].SemanticName = pDesc->il->elements[i].SemanticName.c_str(); - desc[i].SemanticIndex = pDesc->il->elements[i].SemanticIndex; - desc[i].Format = _ConvertFormat(pDesc->il->elements[i].Format); - desc[i].InputSlot = pDesc->il->elements[i].InputSlot; - desc[i].AlignedByteOffset = pDesc->il->elements[i].AlignedByteOffset; - if (desc[i].AlignedByteOffset == InputLayout::APPEND_ALIGNED_ELEMENT) - desc[i].AlignedByteOffset = D3D11_APPEND_ALIGNED_ELEMENT; - desc[i].InputSlotClass = _ConvertInputClassification(pDesc->il->elements[i].InputSlotClass); - desc[i].InstanceDataStepRate = 0; - if (desc[i].InputSlotClass == D3D11_INPUT_PER_INSTANCE_DATA) - { - desc[i].InstanceDataStepRate = 1; - } - } - - assert(pDesc->vs != nullptr); - auto vs_internal = static_cast(pDesc->vs->internal_state.get()); - hr = device->CreateInputLayout(desc.data(), (UINT)desc.size(), vs_internal->shadercode.data(), vs_internal->shadercode.size(), &internal_state->il); - assert(SUCCEEDED(hr)); - } - - - - if (pDesc->bs != nullptr) - { - D3D11_BLEND_DESC desc; - desc.AlphaToCoverageEnable = pDesc->bs->AlphaToCoverageEnable; - desc.IndependentBlendEnable = pDesc->bs->IndependentBlendEnable; - for (int i = 0; i < 8; ++i) - { - desc.RenderTarget[i].BlendEnable = pDesc->bs->RenderTarget[i].BlendEnable; - desc.RenderTarget[i].SrcBlend = _ConvertBlend(pDesc->bs->RenderTarget[i].SrcBlend); - desc.RenderTarget[i].DestBlend = _ConvertBlend(pDesc->bs->RenderTarget[i].DestBlend); - desc.RenderTarget[i].BlendOp = _ConvertBlendOp(pDesc->bs->RenderTarget[i].BlendOp); - desc.RenderTarget[i].SrcBlendAlpha = _ConvertBlend(pDesc->bs->RenderTarget[i].SrcBlendAlpha); - desc.RenderTarget[i].DestBlendAlpha = _ConvertBlend(pDesc->bs->RenderTarget[i].DestBlendAlpha); - desc.RenderTarget[i].BlendOpAlpha = _ConvertBlendOp(pDesc->bs->RenderTarget[i].BlendOpAlpha); - desc.RenderTarget[i].RenderTargetWriteMask = _ParseColorWriteMask(pDesc->bs->RenderTarget[i].RenderTargetWriteMask); - } - - hr = device->CreateBlendState(&desc, &internal_state->bs); - assert(SUCCEEDED(hr)); - } - - - if (pDesc->dss != nullptr) - { - D3D11_DEPTH_STENCIL_DESC desc; - desc.DepthEnable = pDesc->dss->DepthEnable; - desc.DepthWriteMask = _ConvertDepthWriteMask(pDesc->dss->DepthWriteMask); - desc.DepthFunc = _ConvertComparisonFunc(pDesc->dss->DepthFunc); - desc.StencilEnable = pDesc->dss->StencilEnable; - desc.StencilReadMask = pDesc->dss->StencilReadMask; - desc.StencilWriteMask = pDesc->dss->StencilWriteMask; - desc.FrontFace.StencilDepthFailOp = _ConvertStencilOp(pDesc->dss->FrontFace.StencilDepthFailOp); - desc.FrontFace.StencilFailOp = _ConvertStencilOp(pDesc->dss->FrontFace.StencilFailOp); - desc.FrontFace.StencilFunc = _ConvertComparisonFunc(pDesc->dss->FrontFace.StencilFunc); - desc.FrontFace.StencilPassOp = _ConvertStencilOp(pDesc->dss->FrontFace.StencilPassOp); - desc.BackFace.StencilDepthFailOp = _ConvertStencilOp(pDesc->dss->BackFace.StencilDepthFailOp); - desc.BackFace.StencilFailOp = _ConvertStencilOp(pDesc->dss->BackFace.StencilFailOp); - desc.BackFace.StencilFunc = _ConvertComparisonFunc(pDesc->dss->BackFace.StencilFunc); - desc.BackFace.StencilPassOp = _ConvertStencilOp(pDesc->dss->BackFace.StencilPassOp); - - hr = device->CreateDepthStencilState(&desc, &internal_state->dss); - assert(SUCCEEDED(hr)); - } - - - if (pDesc->rs != nullptr) - { - D3D11_RASTERIZER_DESC desc; - desc.FillMode = _ConvertFillMode(pDesc->rs->FillMode); - desc.CullMode = _ConvertCullMode(pDesc->rs->CullMode); - desc.FrontCounterClockwise = pDesc->rs->FrontCounterClockwise; - desc.DepthBias = pDesc->rs->DepthBias; - desc.DepthBiasClamp = pDesc->rs->DepthBiasClamp; - desc.SlopeScaledDepthBias = pDesc->rs->SlopeScaledDepthBias; - desc.DepthClipEnable = pDesc->rs->DepthClipEnable; - desc.ScissorEnable = true; - desc.MultisampleEnable = pDesc->rs->MultisampleEnable; - desc.AntialiasedLineEnable = pDesc->rs->AntialiasedLineEnable; - - - if (CheckCapability(GRAPHICSDEVICE_CAPABILITY_CONSERVATIVE_RASTERIZATION) && pDesc->rs->ConservativeRasterizationEnable == TRUE) - { - ComPtr device3; - if (SUCCEEDED(device.As(&device3))) - { - D3D11_RASTERIZER_DESC2 desc2; - desc2.FillMode = desc.FillMode; - desc2.CullMode = desc.CullMode; - desc2.FrontCounterClockwise = desc.FrontCounterClockwise; - desc2.DepthBias = desc.DepthBias; - desc2.DepthBiasClamp = desc.DepthBiasClamp; - desc2.SlopeScaledDepthBias = desc.SlopeScaledDepthBias; - desc2.DepthClipEnable = desc.DepthClipEnable; - desc2.ScissorEnable = desc.ScissorEnable; - desc2.MultisampleEnable = desc.MultisampleEnable; - desc2.AntialiasedLineEnable = desc.AntialiasedLineEnable; - desc2.ConservativeRaster = D3D11_CONSERVATIVE_RASTERIZATION_MODE_ON; - desc2.ForcedSampleCount = pDesc->rs->ForcedSampleCount; - - ComPtr rasterizer2; - hr = device3->CreateRasterizerState2(&desc2, &rasterizer2); - assert(SUCCEEDED(hr)); - - internal_state->rs = rasterizer2; - } - } - else if (pDesc->rs->ForcedSampleCount > 0) - { - ComPtr device1; - if (SUCCEEDED(device.As(&device1))) - { - D3D11_RASTERIZER_DESC1 desc1; - desc1.FillMode = desc.FillMode; - desc1.CullMode = desc.CullMode; - desc1.FrontCounterClockwise = desc.FrontCounterClockwise; - desc1.DepthBias = desc.DepthBias; - desc1.DepthBiasClamp = desc.DepthBiasClamp; - desc1.SlopeScaledDepthBias = desc.SlopeScaledDepthBias; - desc1.DepthClipEnable = desc.DepthClipEnable; - desc1.ScissorEnable = desc.ScissorEnable; - desc1.MultisampleEnable = desc.MultisampleEnable; - desc1.AntialiasedLineEnable = desc.AntialiasedLineEnable; - desc1.ForcedSampleCount = pDesc->rs->ForcedSampleCount; - - ComPtr rasterizer1; - hr = device1->CreateRasterizerState1(&desc1, &rasterizer1); - assert(SUCCEEDED(hr)); - - internal_state->rs = rasterizer1; - } - } - - hr = device->CreateRasterizerState(&desc, &internal_state->rs); - assert(SUCCEEDED(hr)); - } - - return true; -} -bool GraphicsDevice_DX11::CreateRenderPass(const RenderPassDesc* pDesc, RenderPass* renderpass) const -{ - renderpass->internal_state = emptyresource; - - renderpass->desc = *pDesc; - - return true; -} - -int GraphicsDevice_DX11::CreateSubresource(Texture* texture, SUBRESOURCE_TYPE type, uint32_t firstSlice, uint32_t sliceCount, uint32_t firstMip, uint32_t mipCount) const -{ - auto internal_state = to_internal(texture); - - switch (type) - { - case wiGraphics::SRV: - { - D3D11_SHADER_RESOURCE_VIEW_DESC srv_desc = {}; - - // Try to resolve resource format: - switch (texture->desc.Format) - { - case FORMAT_R16_TYPELESS: - srv_desc.Format = DXGI_FORMAT_R16_UNORM; - break; - case FORMAT_R32_TYPELESS: - srv_desc.Format = DXGI_FORMAT_R32_FLOAT; - break; - case FORMAT_R24G8_TYPELESS: - srv_desc.Format = DXGI_FORMAT_R24_UNORM_X8_TYPELESS; - break; - case FORMAT_R32G8X24_TYPELESS: - srv_desc.Format = DXGI_FORMAT_R32_FLOAT_X8X24_TYPELESS; - break; - default: - srv_desc.Format = _ConvertFormat(texture->desc.Format); - break; - } - - if (texture->desc.type == TextureDesc::TEXTURE_1D) - { - if (texture->desc.ArraySize > 1) - { - srv_desc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE1DARRAY; - srv_desc.Texture1DArray.FirstArraySlice = firstSlice; - srv_desc.Texture1DArray.ArraySize = sliceCount; - srv_desc.Texture1DArray.MostDetailedMip = firstMip; - srv_desc.Texture1DArray.MipLevels = mipCount; - } - else - { - srv_desc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE1D; - srv_desc.Texture1D.MostDetailedMip = firstMip; - srv_desc.Texture1D.MipLevels = mipCount; - } - } - else if (texture->desc.type == TextureDesc::TEXTURE_2D) - { - if (texture->desc.ArraySize > 1) - { - if (texture->desc.MiscFlags & RESOURCE_MISC_TEXTURECUBE) - { - if (texture->desc.ArraySize > 6) - { - srv_desc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURECUBEARRAY; - srv_desc.TextureCubeArray.First2DArrayFace = firstSlice; - srv_desc.TextureCubeArray.NumCubes = std::min(texture->desc.ArraySize, sliceCount) / 6; - srv_desc.TextureCubeArray.MostDetailedMip = firstMip; - srv_desc.TextureCubeArray.MipLevels = mipCount; - } - else - { - srv_desc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURECUBE; - srv_desc.TextureCube.MostDetailedMip = firstMip; - srv_desc.TextureCube.MipLevels = mipCount; - } - } - else - { - if (texture->desc.SampleCount > 1) - { - srv_desc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2DMSARRAY; - srv_desc.Texture2DMSArray.FirstArraySlice = firstSlice; - srv_desc.Texture2DMSArray.ArraySize = sliceCount; - } - else - { - srv_desc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2DARRAY; - srv_desc.Texture2DArray.FirstArraySlice = firstSlice; - srv_desc.Texture2DArray.ArraySize = sliceCount; - srv_desc.Texture2DArray.MostDetailedMip = firstMip; - srv_desc.Texture2DArray.MipLevels = mipCount; - } - } - } - else - { - if (texture->desc.SampleCount > 1) - { - srv_desc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2DMS; - } - else - { - srv_desc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D; - srv_desc.Texture2D.MostDetailedMip = firstMip; - srv_desc.Texture2D.MipLevels = mipCount; - } - } - } - else if (texture->desc.type == TextureDesc::TEXTURE_3D) - { - srv_desc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE3D; - srv_desc.Texture3D.MostDetailedMip = firstMip; - srv_desc.Texture3D.MipLevels = mipCount; - } - - ComPtr srv; - HRESULT hr = device->CreateShaderResourceView(internal_state->resource.Get(), &srv_desc, &srv); - if (SUCCEEDED(hr)) - { - if (!internal_state->srv) - { - internal_state->srv = srv; - return -1; - } - internal_state->subresources_srv.push_back(srv); - return int(internal_state->subresources_srv.size() - 1); - } - else - { - assert(0); - } - } - break; - case wiGraphics::UAV: - { - D3D11_UNORDERED_ACCESS_VIEW_DESC uav_desc = {}; - - // Try to resolve resource format: - switch (texture->desc.Format) - { - case FORMAT_R16_TYPELESS: - uav_desc.Format = DXGI_FORMAT_R16_UNORM; - break; - case FORMAT_R32_TYPELESS: - uav_desc.Format = DXGI_FORMAT_R32_FLOAT; - break; - case FORMAT_R24G8_TYPELESS: - uav_desc.Format = DXGI_FORMAT_R24_UNORM_X8_TYPELESS; - break; - case FORMAT_R32G8X24_TYPELESS: - uav_desc.Format = DXGI_FORMAT_R32_FLOAT_X8X24_TYPELESS; - break; - default: - uav_desc.Format = _ConvertFormat(texture->desc.Format); - break; - } - - if (texture->desc.type == TextureDesc::TEXTURE_1D) - { - if (texture->desc.ArraySize > 1) - { - uav_desc.ViewDimension = D3D11_UAV_DIMENSION_TEXTURE1DARRAY; - uav_desc.Texture1DArray.FirstArraySlice = firstSlice; - uav_desc.Texture1DArray.ArraySize = sliceCount; - uav_desc.Texture1DArray.MipSlice = firstMip; - } - else - { - uav_desc.ViewDimension = D3D11_UAV_DIMENSION_TEXTURE1D; - uav_desc.Texture1D.MipSlice = firstMip; - } - } - else if (texture->desc.type == TextureDesc::TEXTURE_2D) - { - if (texture->desc.ArraySize > 1) - { - uav_desc.ViewDimension = D3D11_UAV_DIMENSION_TEXTURE2DARRAY; - uav_desc.Texture2DArray.FirstArraySlice = firstSlice; - uav_desc.Texture2DArray.ArraySize = sliceCount; - uav_desc.Texture2DArray.MipSlice = firstMip; - } - else - { - uav_desc.ViewDimension = D3D11_UAV_DIMENSION_TEXTURE2D; - uav_desc.Texture2D.MipSlice = firstMip; - } - } - else if (texture->desc.type == TextureDesc::TEXTURE_3D) - { - uav_desc.ViewDimension = D3D11_UAV_DIMENSION_TEXTURE3D; - uav_desc.Texture3D.MipSlice = firstMip; - uav_desc.Texture3D.FirstWSlice = 0; - uav_desc.Texture3D.WSize = -1; - } - - ComPtr uav; - HRESULT hr = device->CreateUnorderedAccessView(internal_state->resource.Get(), &uav_desc, &uav); - if (SUCCEEDED(hr)) - { - if (!internal_state->uav) - { - internal_state->uav = uav; - return -1; - } - internal_state->subresources_uav.push_back(uav); - return int(internal_state->subresources_uav.size() - 1); - } - else - { - assert(0); - } - } - break; - case wiGraphics::RTV: - { - D3D11_RENDER_TARGET_VIEW_DESC rtv_desc = {}; - - // Try to resolve resource format: - switch (texture->desc.Format) - { - case FORMAT_R16_TYPELESS: - rtv_desc.Format = DXGI_FORMAT_R16_UNORM; - break; - case FORMAT_R32_TYPELESS: - rtv_desc.Format = DXGI_FORMAT_R32_FLOAT; - break; - case FORMAT_R24G8_TYPELESS: - rtv_desc.Format = DXGI_FORMAT_R24_UNORM_X8_TYPELESS; - break; - case FORMAT_R32G8X24_TYPELESS: - rtv_desc.Format = DXGI_FORMAT_R32_FLOAT_X8X24_TYPELESS; - break; - default: - rtv_desc.Format = _ConvertFormat(texture->desc.Format); - break; - } - - if (texture->desc.type == TextureDesc::TEXTURE_1D) - { - if (texture->desc.ArraySize > 1) - { - rtv_desc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE1DARRAY; - rtv_desc.Texture1DArray.FirstArraySlice = firstSlice; - rtv_desc.Texture1DArray.ArraySize = sliceCount; - rtv_desc.Texture1DArray.MipSlice = firstMip; - } - else - { - rtv_desc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE1D; - rtv_desc.Texture1D.MipSlice = firstMip; - } - } - else if (texture->desc.type == TextureDesc::TEXTURE_2D) - { - if (texture->desc.ArraySize > 1) - { - if (texture->desc.SampleCount > 1) - { - rtv_desc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2DMSARRAY; - rtv_desc.Texture2DMSArray.FirstArraySlice = firstSlice; - rtv_desc.Texture2DMSArray.ArraySize = sliceCount; - } - else - { - rtv_desc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2DARRAY; - rtv_desc.Texture2DArray.FirstArraySlice = firstSlice; - rtv_desc.Texture2DArray.ArraySize = sliceCount; - rtv_desc.Texture2DArray.MipSlice = firstMip; - } - } - else - { - if (texture->desc.SampleCount > 1) - { - rtv_desc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2DMS; - } - else - { - rtv_desc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2D; - rtv_desc.Texture2D.MipSlice = firstMip; - } - } - } - else if (texture->desc.type == TextureDesc::TEXTURE_3D) - { - rtv_desc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE3D; - rtv_desc.Texture3D.MipSlice = firstMip; - rtv_desc.Texture3D.FirstWSlice = 0; - rtv_desc.Texture3D.WSize = -1; - } - - ComPtr rtv; - HRESULT hr = device->CreateRenderTargetView(internal_state->resource.Get(), &rtv_desc, &rtv); - if (SUCCEEDED(hr)) - { - if (!internal_state->rtv) - { - internal_state->rtv = rtv; - return -1; - } - internal_state->subresources_rtv.push_back(rtv); - return int(internal_state->subresources_rtv.size() - 1); - } - else - { - assert(0); - } - } - break; - case wiGraphics::DSV: - { - D3D11_DEPTH_STENCIL_VIEW_DESC dsv_desc = {}; - - // Try to resolve resource format: - switch (texture->desc.Format) - { - case FORMAT_R16_TYPELESS: - dsv_desc.Format = DXGI_FORMAT_D16_UNORM; - break; - case FORMAT_R32_TYPELESS: - dsv_desc.Format = DXGI_FORMAT_D32_FLOAT; - break; - case FORMAT_R24G8_TYPELESS: - dsv_desc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT; - break; - case FORMAT_R32G8X24_TYPELESS: - dsv_desc.Format = DXGI_FORMAT_D32_FLOAT_S8X24_UINT; - break; - default: - dsv_desc.Format = _ConvertFormat(texture->desc.Format); - break; - } - - if (texture->desc.type == TextureDesc::TEXTURE_1D) - { - if (texture->desc.ArraySize > 1) - { - dsv_desc.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE1DARRAY; - dsv_desc.Texture1DArray.FirstArraySlice = firstSlice; - dsv_desc.Texture1DArray.ArraySize = sliceCount; - dsv_desc.Texture1DArray.MipSlice = firstMip; - } - else - { - dsv_desc.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE1D; - dsv_desc.Texture1D.MipSlice = firstMip; - } - } - else if (texture->desc.type == TextureDesc::TEXTURE_2D) - { - if (texture->desc.ArraySize > 1) - { - if (texture->desc.SampleCount > 1) - { - dsv_desc.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2DMSARRAY; - dsv_desc.Texture2DMSArray.FirstArraySlice = firstSlice; - dsv_desc.Texture2DMSArray.ArraySize = sliceCount; - } - else - { - dsv_desc.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2DARRAY; - dsv_desc.Texture2DArray.FirstArraySlice = firstSlice; - dsv_desc.Texture2DArray.ArraySize = sliceCount; - dsv_desc.Texture2DArray.MipSlice = firstMip; - } - } - else - { - if (texture->desc.SampleCount > 1) - { - dsv_desc.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2DMS; - } - else - { - dsv_desc.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2D; - dsv_desc.Texture2D.MipSlice = firstMip; - } - } - } - - ComPtr dsv; - HRESULT hr = device->CreateDepthStencilView(internal_state->resource.Get(), &dsv_desc, &dsv); - if (SUCCEEDED(hr)) - { - if (!internal_state->dsv) - { - internal_state->dsv = dsv; - return -1; - } - internal_state->subresources_dsv.push_back(dsv); - return int(internal_state->subresources_dsv.size() - 1); - } - else - { - assert(0); - } - } - break; - default: - break; - } - return -1; -} -int GraphicsDevice_DX11::CreateSubresource(GPUBuffer* buffer, SUBRESOURCE_TYPE type, uint64_t offset, uint64_t size) const -{ - auto internal_state = to_internal(buffer); - const GPUBufferDesc& desc = buffer->GetDesc(); - HRESULT hr = E_FAIL; - - switch (type) - { - case wiGraphics::SRV: - { - D3D11_SHADER_RESOURCE_VIEW_DESC srv_desc = {}; - - if (desc.MiscFlags & RESOURCE_MISC_BUFFER_ALLOW_RAW_VIEWS) - { - // This is a Raw Buffer - srv_desc.Format = DXGI_FORMAT_R32_TYPELESS; - srv_desc.ViewDimension = D3D11_SRV_DIMENSION_BUFFEREX; - srv_desc.BufferEx.Flags = D3D11_BUFFEREX_SRV_FLAG_RAW; - srv_desc.BufferEx.FirstElement = (UINT)offset / sizeof(uint32_t); - srv_desc.BufferEx.NumElements = std::min((UINT)size, desc.ByteWidth - (UINT)offset) / sizeof(uint32_t); - } - else if (desc.MiscFlags & RESOURCE_MISC_BUFFER_STRUCTURED) - { - // This is a Structured Buffer - srv_desc.Format = DXGI_FORMAT_UNKNOWN; - srv_desc.ViewDimension = D3D11_SRV_DIMENSION_BUFFEREX; - srv_desc.BufferEx.FirstElement = (UINT)offset / desc.StructureByteStride; - srv_desc.BufferEx.NumElements = std::min((UINT)size, desc.ByteWidth - (UINT)offset) / desc.StructureByteStride; - } - else - { - // This is a Typed Buffer - uint32_t stride = GetFormatStride(desc.Format); - srv_desc.Format = _ConvertFormat(desc.Format); - srv_desc.ViewDimension = D3D11_SRV_DIMENSION_BUFFER; - srv_desc.Buffer.FirstElement = (UINT)offset / stride; - srv_desc.Buffer.NumElements = std::min((UINT)size, desc.ByteWidth - (UINT)offset) / stride; - } - - ComPtr srv; - hr = device->CreateShaderResourceView(internal_state->resource.Get(), &srv_desc, &srv); - - if (SUCCEEDED(hr)) - { - if (internal_state->srv == nullptr) - { - internal_state->srv = srv; - return -1; - } - else - { - internal_state->subresources_srv.push_back(srv); - return int(internal_state->subresources_srv.size() - 1); - } - } - else - { - assert(0); - } - } - break; - case wiGraphics::UAV: - { - D3D11_UNORDERED_ACCESS_VIEW_DESC uav_desc = {}; - uav_desc.ViewDimension = D3D11_UAV_DIMENSION_BUFFER; - - if (desc.MiscFlags & RESOURCE_MISC_BUFFER_ALLOW_RAW_VIEWS) - { - // This is a Raw Buffer - uav_desc.Format = DXGI_FORMAT_R32_TYPELESS; // Format must be DXGI_FORMAT_R32_TYPELESS, when creating Raw Unordered Access View - uav_desc.Buffer.Flags = D3D11_BUFFER_UAV_FLAG_RAW; - uav_desc.Buffer.FirstElement = (UINT)offset / sizeof(uint32_t); - uav_desc.Buffer.NumElements = std::min((UINT)size, desc.ByteWidth - (UINT)offset) / sizeof(uint32_t); - } - else if (desc.MiscFlags & RESOURCE_MISC_BUFFER_STRUCTURED) - { - // This is a Structured Buffer - uav_desc.Format = DXGI_FORMAT_UNKNOWN; // Format must be must be DXGI_FORMAT_UNKNOWN, when creating a View of a Structured Buffer - uav_desc.Buffer.FirstElement = (UINT)offset / desc.StructureByteStride; - uav_desc.Buffer.NumElements = std::min((UINT)size, desc.ByteWidth - (UINT)offset) / desc.StructureByteStride; - } - else - { - // This is a Typed Buffer - uint32_t stride = GetFormatStride(desc.Format); - uav_desc.Format = _ConvertFormat(desc.Format); - uav_desc.Buffer.FirstElement = (UINT)offset / stride; - uav_desc.Buffer.NumElements = std::min((UINT)size, desc.ByteWidth - (UINT)offset) / stride; - } - - ComPtr uav; - hr = device->CreateUnorderedAccessView(internal_state->resource.Get(), &uav_desc, &uav); - - if (SUCCEEDED(hr)) - { - if (internal_state->uav == nullptr) - { - internal_state->uav = uav; - return -1; - } - else - { - internal_state->subresources_uav.push_back(uav); - return int(internal_state->subresources_uav.size() - 1); - } - } - else - { - assert(0); - } - } - break; - default: - assert(0); - break; - } - return -1; -} - -void GraphicsDevice_DX11::Map(const GPUResource* resource, Mapping* mapping) const -{ - auto internal_state = to_internal(resource); - - D3D11_MAPPED_SUBRESOURCE map_result = {}; - D3D11_MAP map_type = D3D11_MAP_READ_WRITE; - UINT map_flags = 0; - if (mapping->_flags & Mapping::FLAG_READ) - { - if (mapping->_flags & Mapping::FLAG_WRITE) - { - map_type = D3D11_MAP_READ_WRITE; - } - else - { - map_type = D3D11_MAP_READ; - } - map_flags |= D3D11_MAP_FLAG_DO_NOT_WAIT; - } - else if (mapping->_flags & Mapping::FLAG_WRITE) - { - map_type = D3D11_MAP_WRITE_NO_OVERWRITE; - } - HRESULT hr = immediateContext->Map(internal_state->resource.Get(), 0, map_type, map_flags, &map_result); - if (SUCCEEDED(hr)) - { - mapping->data = map_result.pData; - mapping->rowpitch = map_result.RowPitch; - } - else - { - assert(0); - mapping->data = nullptr; - mapping->rowpitch = 0; - } -} -void GraphicsDevice_DX11::Unmap(const GPUResource* resource) const -{ - auto internal_state = to_internal(resource); - immediateContext->Unmap(internal_state->resource.Get(), 0); -} -void GraphicsDevice_DX11::QueryRead(const GPUQueryHeap* heap, uint32_t index, uint32_t count, uint64_t* results) const -{ - if (count == 0) - return; - - auto internal_state = to_internal(heap); - - const uint32_t _flags = D3D11_ASYNC_GETDATA_DONOTFLUSH; - - HRESULT hr = S_OK; - - assert(index + count <= internal_state->resources.size()); - for (uint32_t i = 0; i < count; ++i) - { - ID3D11Query* QUERY = internal_state->resources[index + i].Get(); - - switch (heap->desc.type) - { - case GPU_QUERY_TYPE_TIMESTAMP: - hr = immediateContext->GetData(QUERY, &results[i], sizeof(uint64_t), _flags); - break; - case GPU_QUERY_TYPE_OCCLUSION: - hr = immediateContext->GetData(QUERY, &results[i], sizeof(uint64_t), _flags); - break; - case GPU_QUERY_TYPE_OCCLUSION_BINARY: - { - BOOL passed = FALSE; - hr = immediateContext->GetData(QUERY, &passed, sizeof(BOOL), _flags); - results[i] = (uint64_t)passed; - break; - } - } - } -} - -void GraphicsDevice_DX11::SetCommonSampler(const StaticSampler* sam) -{ - common_samplers.push_back(*sam); -} - -void GraphicsDevice_DX11::SetName(GPUResource* pResource, const char* name) -{ - auto internal_state = to_internal(pResource); - internal_state->resource->SetPrivateData(WKPDID_D3DDebugObjectName, (UINT)strlen(name), name); -} - -CommandList GraphicsDevice_DX11::BeginCommandList(QUEUE_TYPE queue) -{ - CommandList cmd = cmd_count.fetch_add(1); - assert(cmd < COMMANDLIST_COUNT); - - if (deviceContexts[cmd] == nullptr) - { - // need to create one more command list: - - HRESULT hr = device->CreateDeferredContext(0, &deviceContexts[cmd]); - assert(SUCCEEDED(hr)); - - hr = deviceContexts[cmd].As(&userDefinedAnnotations[cmd]); - assert(SUCCEEDED(hr)); - - // Temporary allocations will use the following buffer type: - GPUBufferDesc frameAllocatorDesc; - frameAllocatorDesc.ByteWidth = 1024 * 1024; // 1 MB starting size - frameAllocatorDesc.BindFlags = BIND_SHADER_RESOURCE | BIND_INDEX_BUFFER | BIND_VERTEX_BUFFER; - frameAllocatorDesc.Usage = USAGE_DYNAMIC; - frameAllocatorDesc.CPUAccessFlags = CPU_ACCESS_WRITE; - frameAllocatorDesc.MiscFlags = RESOURCE_MISC_BUFFER_ALLOW_RAW_VIEWS; - bool success = CreateBuffer(&frameAllocatorDesc, nullptr, &frame_allocators[cmd].buffer); - assert(success); - SetName(&frame_allocators[cmd].buffer, "frame_allocator"); - - } - - BindPipelineState(nullptr, cmd); - BindComputeShader(nullptr, cmd); - - for (int stage = 0; stage < SHADERSTAGE_COUNT; ++stage) - { - for (auto& sam : common_samplers) - { - BindSampler((SHADERSTAGE)stage, &sam.sampler, sam.slot, cmd); - } - } - - D3D11_RECT pRects[8]; - for (uint32_t i = 0; i < 8; ++i) - { - pRects[i].bottom = INT32_MAX; - pRects[i].left = INT32_MIN; - pRects[i].right = INT32_MAX; - pRects[i].top = INT32_MIN; - } - deviceContexts[cmd]->RSSetScissorRects(8, pRects); - - stencilRef[cmd] = 0; - blendFactor[cmd] = XMFLOAT4(1, 1, 1, 1); - - prev_vs[cmd] = {}; - prev_ps[cmd] = {}; - prev_hs[cmd] = {}; - prev_ds[cmd] = {}; - prev_gs[cmd] = {}; - prev_cs[cmd] = {}; - prev_blendfactor[cmd] = {}; - prev_samplemask[cmd] = {}; - prev_bs[cmd] = {}; - prev_rs[cmd] = {}; - prev_stencilRef[cmd] = {}; - prev_dss[cmd] = {}; - prev_il[cmd] = {}; - prev_pt[cmd] = {}; - swapchains[cmd].clear(); - - memset(raster_uavs[cmd], 0, sizeof(raster_uavs[cmd])); - raster_uavs_slot[cmd] = {}; - raster_uavs_count[cmd] = {}; - - active_pso[cmd] = nullptr; - dirty_pso[cmd] = false; - active_renderpass[cmd] = nullptr; - - return cmd; -} -void GraphicsDevice_DX11::SubmitCommandLists() -{ - const int disjoint_write = FRAMECOUNT % arraysize(disjointQueries); - const int disjoint_read = (FRAMECOUNT + 1) % arraysize(disjointQueries); - immediateContext->Begin(disjointQueries[disjoint_write].Get()); - - // Execute deferred command lists: - CommandList cmd_last = cmd_count.load(); - cmd_count.store(0); - for (CommandList cmd = 0; cmd < cmd_last; ++cmd) - { - HRESULT hr = deviceContexts[cmd]->FinishCommandList(false, &commandLists[cmd]); - assert(SUCCEEDED(hr)); - immediateContext->ExecuteCommandList(commandLists[cmd].Get(), false); - commandLists[cmd].Reset(); - - for (auto& swapchain : swapchains[cmd]) - { - to_internal(swapchain)->swapChain->Present(swapchain->desc.vsync, 0); - } - } - immediateContext->ClearState(); - - immediateContext->End(disjointQueries[disjoint_write].Get()); - D3D11_QUERY_DATA_TIMESTAMP_DISJOINT disjoint; - HRESULT hr = immediateContext->GetData( - disjointQueries[disjoint_read].Get(), - &disjoint, - sizeof(disjoint), - D3D11_ASYNC_GETDATA_DONOTFLUSH - ); - if (disjoint.Disjoint == FALSE && hr == S_OK) - { - TIMESTAMP_FREQUENCY = disjoint.Frequency; - } - - FRAMECOUNT++; -} - -void GraphicsDevice_DX11::WaitForGPU() const -{ - immediateContext->Flush(); - - - D3D11_QUERY_DESC desc; - desc.MiscFlags = 0; - desc.Query = D3D11_QUERY_EVENT; - - ComPtr query; - HRESULT hr = device->CreateQuery(&desc, &query); - assert(SUCCEEDED(hr)); - immediateContext->End(query.Get()); - BOOL result; - while (immediateContext->GetData(query.Get(), &result, sizeof(result), 0) == S_FALSE); - assert(result == TRUE); -} - - -Texture GraphicsDevice_DX11::GetBackBuffer(const SwapChain* swapchain) const -{ - auto swapchain_internal = to_internal(swapchain); - - auto internal_state = std::make_shared(); - internal_state->resource = swapchain_internal->backBuffer; - - Texture result; - result.internal_state = internal_state; - result.type = GPUResource::GPU_RESOURCE_TYPE::TEXTURE; - - D3D11_TEXTURE2D_DESC desc; - swapchain_internal->backBuffer->GetDesc(&desc); - result.desc = _ConvertTextureDesc_Inv(&desc); - - return result; -} - -void GraphicsDevice_DX11::commit_allocations(CommandList cmd) -{ - // DX11 needs to unmap allocations before it can execute safely - - if (frame_allocators[cmd].dirty) - { - auto internal_state = to_internal(&frame_allocators[cmd].buffer); - deviceContexts[cmd]->Unmap(internal_state->resource.Get(), 0); - frame_allocators[cmd].dirty = false; - } -} - - -void GraphicsDevice_DX11::RenderPassBegin(const SwapChain* swapchain, CommandList cmd) -{ - swapchains[cmd].push_back(swapchain); - active_renderpass[cmd] = &dummyrenderpass; - auto internal_state = to_internal(swapchain); - - ID3D11RenderTargetView* RTV = internal_state->renderTargetView.Get(); - deviceContexts[cmd]->OMSetRenderTargets(1, &RTV, 0); - deviceContexts[cmd]->ClearRenderTargetView(RTV, swapchain->desc.clearcolor); -} -void GraphicsDevice_DX11::RenderPassBegin(const RenderPass* renderpass, CommandList cmd) -{ - active_renderpass[cmd] = renderpass; - const RenderPassDesc& desc = renderpass->GetDesc(); - - uint32_t rt_count = 0; - ID3D11RenderTargetView* RTVs[D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT] = {}; - ID3D11DepthStencilView* DSV = nullptr; - for (auto& attachment : desc.attachments) - { - const Texture* texture = attachment.texture; - int subresource = attachment.subresource; - auto internal_state = to_internal(texture); - - if (attachment.type == RenderPassAttachment::RENDERTARGET) - { - if (subresource < 0 || internal_state->subresources_rtv.empty()) - { - RTVs[rt_count] = internal_state->rtv.Get(); - } - else - { - assert(internal_state->subresources_rtv.size() > size_t(subresource) && "Invalid RTV subresource!"); - RTVs[rt_count] = internal_state->subresources_rtv[subresource].Get(); - } - - if (attachment.loadop == RenderPassAttachment::LOADOP_CLEAR) - { - deviceContexts[cmd]->ClearRenderTargetView(RTVs[rt_count], texture->desc.clear.color); - } - - rt_count++; - } - else if (attachment.type == RenderPassAttachment::DEPTH_STENCIL) - { - if (subresource < 0 || internal_state->subresources_dsv.empty()) - { - DSV = internal_state->dsv.Get(); - } - else - { - assert(internal_state->subresources_dsv.size() > size_t(subresource) && "Invalid DSV subresource!"); - DSV = internal_state->subresources_dsv[subresource].Get(); - } - - if (attachment.loadop == RenderPassAttachment::LOADOP_CLEAR) - { - uint32_t _flags = D3D11_CLEAR_DEPTH; - if (IsFormatStencilSupport(texture->desc.Format)) - _flags |= D3D11_CLEAR_STENCIL; - deviceContexts[cmd]->ClearDepthStencilView(DSV, _flags, texture->desc.clear.depthstencil.depth, texture->desc.clear.depthstencil.stencil); - } - } - } - - if (raster_uavs_count[cmd] > 0) - { - // UAVs: - const uint32_t count = raster_uavs_count[cmd]; - const uint32_t slot = raster_uavs_slot[cmd]; - - deviceContexts[cmd]->OMSetRenderTargetsAndUnorderedAccessViews(rt_count, RTVs, DSV, slot, count, &raster_uavs[cmd][slot], nullptr); - - raster_uavs_count[cmd] = 0; - raster_uavs_slot[cmd] = 8; - } - else - { - deviceContexts[cmd]->OMSetRenderTargets(rt_count, RTVs, DSV); - } -} -void GraphicsDevice_DX11::RenderPassEnd(CommandList cmd) -{ - deviceContexts[cmd]->OMSetRenderTargets(0, nullptr, nullptr); - - // Perform resolves: - int dst_counter = 0; - for (auto& attachment : active_renderpass[cmd]->desc.attachments) - { - if (attachment.type == RenderPassAttachment::RESOLVE) - { - if (attachment.texture != nullptr) - { - auto dst_internal = to_internal(attachment.texture); - - int src_counter = 0; - for (auto& src : active_renderpass[cmd]->desc.attachments) - { - if (src.type == RenderPassAttachment::RENDERTARGET && src.texture != nullptr) - { - if (src_counter == dst_counter) - { - auto src_internal = to_internal(src.texture); - deviceContexts[cmd]->ResolveSubresource(dst_internal->resource.Get(), 0, src_internal->resource.Get(), 0, _ConvertFormat(attachment.texture->desc.Format)); - break; - } - src_counter++; - } - } - } - - dst_counter++; - } - } - active_renderpass[cmd] = nullptr; -} -void GraphicsDevice_DX11::BindScissorRects(uint32_t numRects, const Rect* rects, CommandList cmd) -{ - assert(rects != nullptr); - assert(numRects <= D3D11_VIEWPORT_AND_SCISSORRECT_MAX_INDEX); - D3D11_RECT pRects[D3D11_VIEWPORT_AND_SCISSORRECT_MAX_INDEX]; - for(uint32_t i = 0; i < numRects; ++i) { - pRects[i].bottom = (LONG)rects[i].bottom; - pRects[i].left = (LONG)rects[i].left; - pRects[i].right = (LONG)rects[i].right; - pRects[i].top = (LONG)rects[i].top; - } - deviceContexts[cmd]->RSSetScissorRects(numRects, pRects); -} -void GraphicsDevice_DX11::BindViewports(uint32_t NumViewports, const Viewport* pViewports, CommandList cmd) -{ - assert(pViewports != nullptr); - assert(NumViewports <= D3D11_VIEWPORT_AND_SCISSORRECT_MAX_INDEX); - D3D11_VIEWPORT d3dViewPorts[D3D11_VIEWPORT_AND_SCISSORRECT_MAX_INDEX]; - for (uint32_t i = 0; i < NumViewports; ++i) - { - d3dViewPorts[i].TopLeftX = pViewports[i].TopLeftX; - d3dViewPorts[i].TopLeftY = pViewports[i].TopLeftY; - d3dViewPorts[i].Width = pViewports[i].Width; - d3dViewPorts[i].Height = pViewports[i].Height; - d3dViewPorts[i].MinDepth = pViewports[i].MinDepth; - d3dViewPorts[i].MaxDepth = pViewports[i].MaxDepth; - } - deviceContexts[cmd]->RSSetViewports(NumViewports, d3dViewPorts); -} -void GraphicsDevice_DX11::BindResource(SHADERSTAGE stage, const GPUResource* resource, uint32_t slot, CommandList cmd, int subresource) -{ - if (resource != nullptr && resource->IsValid()) - { - auto internal_state = to_internal(resource); - ID3D11ShaderResourceView* SRV; - - if (subresource < 0) - { - SRV = internal_state->srv.Get(); - } - else - { - assert(internal_state->subresources_srv.size() > static_cast(subresource) && "Invalid subresource!"); - SRV = internal_state->subresources_srv[subresource].Get(); - } - - switch (stage) - { - case wiGraphics::VS: - deviceContexts[cmd]->VSSetShaderResources(slot, 1, &SRV); - break; - case wiGraphics::HS: - deviceContexts[cmd]->HSSetShaderResources(slot, 1, &SRV); - break; - case wiGraphics::DS: - deviceContexts[cmd]->DSSetShaderResources(slot, 1, &SRV); - break; - case wiGraphics::GS: - deviceContexts[cmd]->GSSetShaderResources(slot, 1, &SRV); - break; - case wiGraphics::PS: - deviceContexts[cmd]->PSSetShaderResources(slot, 1, &SRV); - break; - case wiGraphics::CS: - deviceContexts[cmd]->CSSetShaderResources(slot, 1, &SRV); - break; - default: - break; - } - } -} -void GraphicsDevice_DX11::BindResources(SHADERSTAGE stage, const GPUResource *const* resources, uint32_t slot, uint32_t count, CommandList cmd) -{ - assert(count <= 16); - ID3D11ShaderResourceView* srvs[16]; - for (uint32_t i = 0; i < count; ++i) - { - srvs[i] = resources[i] != nullptr && resources[i]->IsValid() ? to_internal(resources[i])->srv.Get() : nullptr; - } - - switch (stage) - { - case wiGraphics::VS: - deviceContexts[cmd]->VSSetShaderResources(slot, count, srvs); - break; - case wiGraphics::HS: - deviceContexts[cmd]->HSSetShaderResources(slot, count, srvs); - break; - case wiGraphics::DS: - deviceContexts[cmd]->DSSetShaderResources(slot, count, srvs); - break; - case wiGraphics::GS: - deviceContexts[cmd]->GSSetShaderResources(slot, count, srvs); - break; - case wiGraphics::PS: - deviceContexts[cmd]->PSSetShaderResources(slot, count, srvs); - break; - case wiGraphics::CS: - deviceContexts[cmd]->CSSetShaderResources(slot, count, srvs); - break; - default: - break; - } -} -void GraphicsDevice_DX11::BindUAV(SHADERSTAGE stage, const GPUResource* resource, uint32_t slot, CommandList cmd, int subresource) -{ - if (resource != nullptr && resource->IsValid()) - { - auto internal_state = to_internal(resource); - ID3D11UnorderedAccessView* UAV; - - if (subresource < 0) - { - UAV = internal_state->uav.Get(); - } - else - { - assert(internal_state->subresources_uav.size() > static_cast(subresource) && "Invalid subresource!"); - UAV = internal_state->subresources_uav[subresource].Get(); - } - - if (stage == CS) - { - deviceContexts[cmd]->CSSetUnorderedAccessViews(slot, 1, &UAV, nullptr); - } - else - { - raster_uavs[cmd][slot] = UAV; - raster_uavs_slot[cmd] = std::min(raster_uavs_slot[cmd], uint8_t(slot)); - raster_uavs_count[cmd] = std::max(raster_uavs_count[cmd], uint8_t(1)); - } - } -} -void GraphicsDevice_DX11::BindUAVs(SHADERSTAGE stage, const GPUResource *const* resources, uint32_t slot, uint32_t count, CommandList cmd) -{ - assert(slot + count <= 8); - ID3D11UnorderedAccessView* uavs[8]; - for (uint32_t i = 0; i < count; ++i) - { - uavs[i] = resources[i] != nullptr && resources[i]->IsValid() ? to_internal(resources[i])->uav.Get() : nullptr; - - if(stage != CS) - { - raster_uavs[cmd][slot + i] = uavs[i]; - } - } - - if(stage == CS) - { - deviceContexts[cmd]->CSSetUnorderedAccessViews(static_cast(slot), static_cast(count), uavs, nullptr); - } - else - { - raster_uavs_slot[cmd] = std::min(raster_uavs_slot[cmd], uint8_t(slot)); - raster_uavs_count[cmd] = std::max(raster_uavs_count[cmd], uint8_t(count)); - } -} -void GraphicsDevice_DX11::UnbindResources(uint32_t slot, uint32_t num, CommandList cmd) -{ - assert(num <= arraysize(__nullBlob) && "Extend nullBlob to support more resource unbinding!"); - deviceContexts[cmd]->PSSetShaderResources(slot, num, (ID3D11ShaderResourceView**)__nullBlob); - deviceContexts[cmd]->VSSetShaderResources(slot, num, (ID3D11ShaderResourceView**)__nullBlob); - deviceContexts[cmd]->GSSetShaderResources(slot, num, (ID3D11ShaderResourceView**)__nullBlob); - deviceContexts[cmd]->HSSetShaderResources(slot, num, (ID3D11ShaderResourceView**)__nullBlob); - deviceContexts[cmd]->DSSetShaderResources(slot, num, (ID3D11ShaderResourceView**)__nullBlob); - deviceContexts[cmd]->CSSetShaderResources(slot, num, (ID3D11ShaderResourceView**)__nullBlob); -} -void GraphicsDevice_DX11::UnbindUAVs(uint32_t slot, uint32_t num, CommandList cmd) -{ - assert(num <= arraysize(__nullBlob) && "Extend nullBlob to support more resource unbinding!"); - deviceContexts[cmd]->CSSetUnorderedAccessViews(slot, num, (ID3D11UnorderedAccessView**)__nullBlob, 0); - - raster_uavs_count[cmd] = 0; - raster_uavs_slot[cmd] = 8; -} -void GraphicsDevice_DX11::BindSampler(SHADERSTAGE stage, const Sampler* sampler, uint32_t slot, CommandList cmd) -{ - if (sampler != nullptr && sampler->IsValid()) - { - auto internal_state = to_internal(sampler); - ID3D11SamplerState* SAM = internal_state->resource.Get(); - - switch (stage) - { - case wiGraphics::VS: - deviceContexts[cmd]->VSSetSamplers(slot, 1, &SAM); - break; - case wiGraphics::HS: - deviceContexts[cmd]->HSSetSamplers(slot, 1, &SAM); - break; - case wiGraphics::DS: - deviceContexts[cmd]->DSSetSamplers(slot, 1, &SAM); - break; - case wiGraphics::GS: - deviceContexts[cmd]->GSSetSamplers(slot, 1, &SAM); - break; - case wiGraphics::PS: - deviceContexts[cmd]->PSSetSamplers(slot, 1, &SAM); - break; - case wiGraphics::CS: - deviceContexts[cmd]->CSSetSamplers(slot, 1, &SAM); - break; - default: - break; - } - } -} -void GraphicsDevice_DX11::BindConstantBuffer(SHADERSTAGE stage, const GPUBuffer* buffer, uint32_t slot, CommandList cmd) -{ - ID3D11Buffer* res = buffer != nullptr && buffer->IsValid() ? (ID3D11Buffer*)to_internal(buffer)->resource.Get() : nullptr; - switch (stage) - { - case wiGraphics::VS: - deviceContexts[cmd]->VSSetConstantBuffers(slot, 1, &res); - break; - case wiGraphics::HS: - deviceContexts[cmd]->HSSetConstantBuffers(slot, 1, &res); - break; - case wiGraphics::DS: - deviceContexts[cmd]->DSSetConstantBuffers(slot, 1, &res); - break; - case wiGraphics::GS: - deviceContexts[cmd]->GSSetConstantBuffers(slot, 1, &res); - break; - case wiGraphics::PS: - deviceContexts[cmd]->PSSetConstantBuffers(slot, 1, &res); - break; - case wiGraphics::CS: - deviceContexts[cmd]->CSSetConstantBuffers(slot, 1, &res); - break; - default: - break; - } -} -void GraphicsDevice_DX11::BindVertexBuffers(const GPUBuffer *const* vertexBuffers, uint32_t slot, uint32_t count, const uint32_t* strides, const uint32_t* offsets, CommandList cmd) -{ - assert(count <= 8); - ID3D11Buffer* res[8] = {}; - for (uint32_t i = 0; i < count; ++i) - { - res[i] = vertexBuffers[i] != nullptr && vertexBuffers[i]->IsValid() ? (ID3D11Buffer*)to_internal(vertexBuffers[i])->resource.Get() : nullptr; - } - deviceContexts[cmd]->IASetVertexBuffers(slot, count, res, strides, (offsets != nullptr ? offsets : reinterpret_cast(__nullBlob))); -} -void GraphicsDevice_DX11::BindIndexBuffer(const GPUBuffer* indexBuffer, const INDEXBUFFER_FORMAT format, uint32_t offset, CommandList cmd) -{ - ID3D11Buffer* res = indexBuffer != nullptr && indexBuffer->IsValid() ? (ID3D11Buffer*)to_internal(indexBuffer)->resource.Get() : nullptr; - deviceContexts[cmd]->IASetIndexBuffer(res, (format == INDEXBUFFER_FORMAT::INDEXFORMAT_16BIT ? DXGI_FORMAT_R16_UINT : DXGI_FORMAT_R32_UINT), offset); -} -void GraphicsDevice_DX11::BindStencilRef(uint32_t value, CommandList cmd) -{ - stencilRef[cmd] = value; -} -void GraphicsDevice_DX11::BindBlendFactor(float r, float g, float b, float a, CommandList cmd) -{ - blendFactor[cmd].x = r; - blendFactor[cmd].y = g; - blendFactor[cmd].z = b; - blendFactor[cmd].w = a; -} -void GraphicsDevice_DX11::BindPipelineState(const PipelineState* pso, CommandList cmd) -{ - if (active_pso[cmd] == pso) - return; - - active_pso[cmd] = pso; - dirty_pso[cmd] = true; -} -void GraphicsDevice_DX11::BindComputeShader(const Shader* cs, CommandList cmd) -{ - ID3D11ComputeShader* _cs = cs == nullptr ? nullptr : static_cast(cs->internal_state.get())->resource.Get(); - if (_cs != prev_cs[cmd]) - { - deviceContexts[cmd]->CSSetShader(_cs, nullptr, 0); - prev_cs[cmd] = _cs; - - if (cs != nullptr) - { - for (auto& x : cs->auto_samplers) - { - BindSampler(CS, &x.sampler, x.slot, cmd); - } - } - } -} -void GraphicsDevice_DX11::Draw(uint32_t vertexCount, uint32_t startVertexLocation, CommandList cmd) -{ - pso_validate(cmd); - commit_allocations(cmd); - - deviceContexts[cmd]->Draw(vertexCount, startVertexLocation); -} -void GraphicsDevice_DX11::DrawIndexed(uint32_t indexCount, uint32_t startIndexLocation, uint32_t baseVertexLocation, CommandList cmd) -{ - pso_validate(cmd); - commit_allocations(cmd); - - deviceContexts[cmd]->DrawIndexed(indexCount, startIndexLocation, baseVertexLocation); -} -void GraphicsDevice_DX11::DrawInstanced(uint32_t vertexCount, uint32_t instanceCount, uint32_t startVertexLocation, uint32_t startInstanceLocation, CommandList cmd) -{ - pso_validate(cmd); - commit_allocations(cmd); - - deviceContexts[cmd]->DrawInstanced(vertexCount, instanceCount, startVertexLocation, startInstanceLocation); -} -void GraphicsDevice_DX11::DrawIndexedInstanced(uint32_t indexCount, uint32_t instanceCount, uint32_t startIndexLocation, uint32_t baseVertexLocation, uint32_t startInstanceLocation, CommandList cmd) -{ - pso_validate(cmd); - commit_allocations(cmd); - - deviceContexts[cmd]->DrawIndexedInstanced(indexCount, instanceCount, startIndexLocation, baseVertexLocation, startInstanceLocation); -} -void GraphicsDevice_DX11::DrawInstancedIndirect(const GPUBuffer* args, uint32_t args_offset, CommandList cmd) -{ - pso_validate(cmd); - commit_allocations(cmd); - - deviceContexts[cmd]->DrawInstancedIndirect((ID3D11Buffer*)to_internal(args)->resource.Get(), args_offset); -} -void GraphicsDevice_DX11::DrawIndexedInstancedIndirect(const GPUBuffer* args, uint32_t args_offset, CommandList cmd) -{ - pso_validate(cmd); - commit_allocations(cmd); - - deviceContexts[cmd]->DrawIndexedInstancedIndirect((ID3D11Buffer*)to_internal(args)->resource.Get(), args_offset); -} -void GraphicsDevice_DX11::Dispatch(uint32_t threadGroupCountX, uint32_t threadGroupCountY, uint32_t threadGroupCountZ, CommandList cmd) -{ - commit_allocations(cmd); - - deviceContexts[cmd]->Dispatch(threadGroupCountX, threadGroupCountY, threadGroupCountZ); -} -void GraphicsDevice_DX11::DispatchIndirect(const GPUBuffer* args, uint32_t args_offset, CommandList cmd) -{ - commit_allocations(cmd); - - deviceContexts[cmd]->DispatchIndirect((ID3D11Buffer*)to_internal(args)->resource.Get(), args_offset); -} -void GraphicsDevice_DX11::CopyResource(const GPUResource* pDst, const GPUResource* pSrc, CommandList cmd) -{ - assert(pDst != nullptr && pSrc != nullptr); - auto internal_state_src = to_internal(pSrc); - auto internal_state_dst = to_internal(pDst); - deviceContexts[cmd]->CopyResource(internal_state_dst->resource.Get(), internal_state_src->resource.Get()); -} -void GraphicsDevice_DX11::UpdateBuffer(const GPUBuffer* buffer, const void* data, CommandList cmd, int dataSize) -{ - assert(buffer->desc.Usage != USAGE_IMMUTABLE && "Cannot update IMMUTABLE GPUBuffer!"); - assert((int)buffer->desc.ByteWidth >= dataSize || dataSize < 0 && "Data size is too big!"); - - if (dataSize == 0) - { - return; - } - - auto internal_state = to_internal(buffer); - - dataSize = std::min((int)buffer->desc.ByteWidth, dataSize); - - if (buffer->desc.Usage == USAGE_DYNAMIC) - { - D3D11_MAPPED_SUBRESOURCE mappedResource; - HRESULT hr = deviceContexts[cmd]->Map(internal_state->resource.Get(), 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource); - assert(SUCCEEDED(hr) && "GPUBuffer mapping failed!"); - memcpy(mappedResource.pData, data, (dataSize >= 0 ? dataSize : buffer->desc.ByteWidth)); - deviceContexts[cmd]->Unmap(internal_state->resource.Get(), 0); - } - else if (buffer->desc.BindFlags & BIND_CONSTANT_BUFFER || dataSize < 0) - { - deviceContexts[cmd]->UpdateSubresource(internal_state->resource.Get(), 0, nullptr, data, 0, 0); - } - else - { - D3D11_BOX box = {}; - box.left = 0; - box.right = static_cast(dataSize); - box.top = 0; - box.bottom = 1; - box.front = 0; - box.back = 1; - deviceContexts[cmd]->UpdateSubresource(internal_state->resource.Get(), 0, &box, data, 0, 0); - } -} -void GraphicsDevice_DX11::QueryBegin(const GPUQueryHeap* heap, uint32_t index, CommandList cmd) -{ - auto internal_state = to_internal(heap); - deviceContexts[cmd]->Begin(internal_state->resources[index].Get()); -} -void GraphicsDevice_DX11::QueryEnd(const GPUQueryHeap* heap, uint32_t index, CommandList cmd) -{ - auto internal_state = to_internal(heap); - deviceContexts[cmd]->End(internal_state->resources[index].Get()); -} - -GraphicsDevice::GPUAllocation GraphicsDevice_DX11::AllocateGPU(size_t dataSize, CommandList cmd) -{ - GPUAllocation result; - if (dataSize == 0) - { - return result; - } - - GPUAllocator& allocator = frame_allocators[cmd]; - if (allocator.buffer.desc.ByteWidth <= dataSize) - { - // If allocation too large, grow the allocator: - allocator.buffer.desc.ByteWidth = uint32_t((dataSize + 1) * 2); - bool success = CreateBuffer(&allocator.buffer.desc, nullptr, &allocator.buffer); - assert(success); - SetName(&allocator.buffer, "frame_allocator"); - allocator.byteOffset = 0; - } - - auto internal_state = to_internal(&allocator.buffer); - - allocator.dirty = true; - - size_t position = allocator.byteOffset; - bool wrap = position == 0 || position + dataSize > allocator.buffer.desc.ByteWidth || allocator.residentFrame != FRAMECOUNT; - position = wrap ? 0 : position; - - // Issue buffer rename (realloc) on wrap, otherwise just append data: - D3D11_MAP mapping = wrap ? D3D11_MAP_WRITE_DISCARD : D3D11_MAP_WRITE_NO_OVERWRITE; - D3D11_MAPPED_SUBRESOURCE mappedResource; - HRESULT hr = deviceContexts[cmd]->Map(internal_state->resource.Get(), 0, mapping, 0, &mappedResource); - assert(SUCCEEDED(hr) && "GPUBuffer mapping failed!"); - - allocator.byteOffset = position + dataSize; - allocator.residentFrame = FRAMECOUNT; - - result.buffer = &allocator.buffer; - result.offset = (uint32_t)position; - result.data = (void*)((size_t)mappedResource.pData + position); - return result; -} - -void GraphicsDevice_DX11::EventBegin(const char* name, CommandList cmd) -{ - wchar_t text[128]; - if (wiHelper::StringConvert(name, text) > 0) - { - userDefinedAnnotations[cmd]->BeginEvent(text); - } -} -void GraphicsDevice_DX11::EventEnd(CommandList cmd) -{ - userDefinedAnnotations[cmd]->EndEvent(); -} -void GraphicsDevice_DX11::SetMarker(const char* name, CommandList cmd) -{ - wchar_t text[128]; - if (wiHelper::StringConvert(name, text) > 0) - { - userDefinedAnnotations[cmd]->SetMarker(text); - } -} - -} - -#endif // WICKEDENGINE_BUILD_DX11 diff --git a/WickedEngine/wiGraphicsDevice_DX11.h b/WickedEngine/wiGraphicsDevice_DX11.h deleted file mode 100644 index a75f0c807..000000000 --- a/WickedEngine/wiGraphicsDevice_DX11.h +++ /dev/null @@ -1,159 +0,0 @@ -#pragma once -#include "CommonInclude.h" - -#if __has_include("d3d11_3.h") -#define WICKEDENGINE_BUILD_DX11 -#endif // HAS DX11 - -#ifdef WICKEDENGINE_BUILD_DX11 -#include "wiGraphicsDevice.h" - -#include -#include -#include // ComPtr - -#include - -namespace wiGraphics -{ - - class GraphicsDevice_DX11 : public GraphicsDevice - { - protected: - D3D_DRIVER_TYPE driverType; - D3D_FEATURE_LEVEL featureLevel; - Microsoft::WRL::ComPtr DXGIFactory; - Microsoft::WRL::ComPtr device; - Microsoft::WRL::ComPtr immediateContext; - Microsoft::WRL::ComPtr deviceContexts[COMMANDLIST_COUNT]; - Microsoft::WRL::ComPtr commandLists[COMMANDLIST_COUNT]; - Microsoft::WRL::ComPtr userDefinedAnnotations[COMMANDLIST_COUNT]; - - Microsoft::WRL::ComPtr disjointQueries[BUFFERCOUNT + 3]; - - uint32_t stencilRef[COMMANDLIST_COUNT]; - XMFLOAT4 blendFactor[COMMANDLIST_COUNT]; - - ID3D11VertexShader* prev_vs[COMMANDLIST_COUNT] = {}; - ID3D11PixelShader* prev_ps[COMMANDLIST_COUNT] = {}; - ID3D11HullShader* prev_hs[COMMANDLIST_COUNT] = {}; - ID3D11DomainShader* prev_ds[COMMANDLIST_COUNT] = {}; - ID3D11GeometryShader* prev_gs[COMMANDLIST_COUNT] = {}; - ID3D11ComputeShader* prev_cs[COMMANDLIST_COUNT] = {}; - XMFLOAT4 prev_blendfactor[COMMANDLIST_COUNT] = {}; - uint32_t prev_samplemask[COMMANDLIST_COUNT] = {}; - const BlendState* prev_bs[COMMANDLIST_COUNT] = {}; - const RasterizerState* prev_rs[COMMANDLIST_COUNT] = {}; - uint32_t prev_stencilRef[COMMANDLIST_COUNT] = {}; - const DepthStencilState* prev_dss[COMMANDLIST_COUNT] = {}; - const InputLayout* prev_il[COMMANDLIST_COUNT] = {}; - PRIMITIVETOPOLOGY prev_pt[COMMANDLIST_COUNT] = {}; - std::vector swapchains[COMMANDLIST_COUNT]; - - const PipelineState* active_pso[COMMANDLIST_COUNT] = {}; - bool dirty_pso[COMMANDLIST_COUNT] = {}; - void pso_validate(CommandList cmd); - - const RenderPass* active_renderpass[COMMANDLIST_COUNT] = {}; - RenderPass dummyrenderpass; - - ID3D11UnorderedAccessView* raster_uavs[COMMANDLIST_COUNT][8] = {}; - uint8_t raster_uavs_slot[COMMANDLIST_COUNT] = {}; - uint8_t raster_uavs_count[COMMANDLIST_COUNT] = {}; - void validate_raster_uavs(CommandList cmd); - - struct GPUAllocator - { - GPUBuffer buffer; - size_t byteOffset = 0; - uint64_t residentFrame = 0; - bool dirty = false; - } frame_allocators[COMMANDLIST_COUNT]; - void commit_allocations(CommandList cmd); - - void CreateBackBufferResources(); - - std::atomic cmd_count{ 0 }; - - std::vector common_samplers; - - struct EmptyResourceHandle {}; // only care about control-block - std::shared_ptr emptyresource; - - public: - GraphicsDevice_DX11(bool debuglayer = false); - - bool CreateSwapChain(const SwapChainDesc* pDesc, wiPlatform::window_type window, SwapChain* swapChain) const override; - bool CreateBuffer(const GPUBufferDesc *pDesc, const SubresourceData* pInitialData, GPUBuffer *pBuffer) const override; - bool CreateTexture(const TextureDesc* pDesc, const SubresourceData *pInitialData, Texture *pTexture) const override; - bool CreateShader(SHADERSTAGE stage, const void *pShaderBytecode, size_t BytecodeLength, Shader *pShader) const override; - bool CreateSampler(const SamplerDesc *pSamplerDesc, Sampler *pSamplerState) const override; - bool CreateQueryHeap(const GPUQueryHeapDesc *pDesc, GPUQueryHeap *pQueryHeap) const override; - bool CreatePipelineState(const PipelineStateDesc* pDesc, PipelineState* pso) const override; - bool CreateRenderPass(const RenderPassDesc* pDesc, RenderPass* renderpass) const override; - - int CreateSubresource(Texture* texture, SUBRESOURCE_TYPE type, uint32_t firstSlice, uint32_t sliceCount, uint32_t firstMip, uint32_t mipCount) const override; - int CreateSubresource(GPUBuffer* buffer, SUBRESOURCE_TYPE type, uint64_t offset, uint64_t size = ~0) const override; - - void Map(const GPUResource* resource, Mapping* mapping) const override; - void Unmap(const GPUResource* resource) const override; - void QueryRead(const GPUQueryHeap* resource, uint32_t index, uint32_t count, uint64_t* results) const override; - - void SetCommonSampler(const StaticSampler* sam) override; - - void SetName(GPUResource* pResource, const char* name) override; - - void WaitForGPU() const override; - - CommandList BeginCommandList(QUEUE_TYPE queue = QUEUE_GRAPHICS) override; - void SubmitCommandLists() override; - - SHADERFORMAT GetShaderFormat() const override { return SHADERFORMAT_HLSL5; } - - Texture GetBackBuffer(const SwapChain* swapchain) const override; - - ///////////////Thread-sensitive//////////////////////// - - void RenderPassBegin(const SwapChain* swapchain, CommandList cmd) override; - void RenderPassBegin(const RenderPass* renderpass, CommandList cmd) override; - void RenderPassEnd(CommandList cmd) override; - void BindScissorRects(uint32_t numRects, const Rect* rects, CommandList cmd) override; - void BindViewports(uint32_t NumViewports, const Viewport* pViewports, CommandList cmd) override; - void BindResource(SHADERSTAGE stage, const GPUResource* resource, uint32_t slot, CommandList cmd, int subresource = -1) override; - void BindResources(SHADERSTAGE stage, const GPUResource *const* resources, uint32_t slot, uint32_t count, CommandList cmd) override; - void BindUAV(SHADERSTAGE stage, const GPUResource* resource, uint32_t slot, CommandList cmd, int subresource = -1) override; - void BindUAVs(SHADERSTAGE stage, const GPUResource *const* resources, uint32_t slot, uint32_t count, CommandList cmd) override; - void UnbindResources(uint32_t slot, uint32_t num, CommandList cmd) override; - void UnbindUAVs(uint32_t slot, uint32_t num, CommandList cmd) override; - void BindSampler(SHADERSTAGE stage, const Sampler* sampler, uint32_t slot, CommandList cmd) override; - void BindConstantBuffer(SHADERSTAGE stage, const GPUBuffer* buffer, uint32_t slot, CommandList cmd) override; - void BindVertexBuffers(const GPUBuffer *const* vertexBuffers, uint32_t slot, uint32_t count, const uint32_t* strides, const uint32_t* offsets, CommandList cmd) override; - void BindIndexBuffer(const GPUBuffer* indexBuffer, const INDEXBUFFER_FORMAT format, uint32_t offset, CommandList cmd) override; - void BindStencilRef(uint32_t value, CommandList cmd) override; - void BindBlendFactor(float r, float g, float b, float a, CommandList cmd) override; - void BindPipelineState(const PipelineState* pso, CommandList cmd) override; - void BindComputeShader(const Shader* cs, CommandList cmd) override; - void Draw(uint32_t vertexCount, uint32_t startVertexLocation, CommandList cmd) override; - void DrawIndexed(uint32_t indexCount, uint32_t startIndexLocation, uint32_t baseVertexLocation, CommandList cmd) override; - void DrawInstanced(uint32_t vertexCount, uint32_t instanceCount, uint32_t startVertexLocation, uint32_t startInstanceLocation, CommandList cmd) override; - void DrawIndexedInstanced(uint32_t indexCount, uint32_t instanceCount, uint32_t startIndexLocation, uint32_t baseVertexLocation, uint32_t startInstanceLocation, CommandList cmd) override; - void DrawInstancedIndirect(const GPUBuffer* args, uint32_t args_offset, CommandList cmd) override; - void DrawIndexedInstancedIndirect(const GPUBuffer* args, uint32_t args_offset, CommandList cmd) override; - void Dispatch(uint32_t threadGroupCountX, uint32_t threadGroupCountY, uint32_t threadGroupCountZ, CommandList cmd) override; - void DispatchIndirect(const GPUBuffer* args, uint32_t args_offset, CommandList cmd) override; - void CopyResource(const GPUResource* pDst, const GPUResource* pSrc, CommandList cmd) override; - void UpdateBuffer(const GPUBuffer* buffer, const void* data, CommandList cmd, int dataSize = -1) override; - void QueryBegin(const GPUQueryHeap* heap, uint32_t index, CommandList cmd) override; - void QueryEnd(const GPUQueryHeap* heap, uint32_t index, CommandList cmd) override; - void Barrier(const GPUBarrier* barriers, uint32_t numBarriers, CommandList cmd) override {} - - GPUAllocation AllocateGPU(size_t dataSize, CommandList cmd) override; - - void EventBegin(const char* name, CommandList cmd) override; - void EventEnd(CommandList cmd) override; - void SetMarker(const char* name, CommandList cmd) override; - }; - -} - -#endif // WICKEDENGINE_BUILD_DX11 diff --git a/WickedEngine/wiGraphicsDevice_DX12.cpp b/WickedEngine/wiGraphicsDevice_DX12.cpp index a9aec3748..e700fd45e 100644 --- a/WickedEngine/wiGraphicsDevice_DX12.cpp +++ b/WickedEngine/wiGraphicsDevice_DX12.cpp @@ -2,7 +2,6 @@ #ifdef WICKEDENGINE_BUILD_DX12 -#include "wiGraphicsDevice_SharedInternals.h" #include "wiHelper.h" #include "wiBackLog.h" @@ -19,19 +18,12 @@ #ifdef _DEBUG #include +#pragma comment(lib,"dxguid.lib") #endif #include #include -// Bindless allocation limits: -#define BINDLESS_RESOURCE_CAPACITY 500000 -#define BINDLESS_SAMPLER_CAPACITY 256 - -// Choose how many constant buffers will be placed in root in auto root signature: -#define CONSTANT_BUFFER_AUTO_PLACEMENT_IN_ROOT 4 -static_assert(GPU_RESOURCE_HEAP_CBV_COUNT < 32, "cbv root mask must fit into uint32_t!"); - using namespace Microsoft::WRL; namespace wiGraphics @@ -39,6 +31,14 @@ namespace wiGraphics namespace DX12_Internal { + // Bindless allocation limits: +#define BINDLESS_RESOURCE_CAPACITY 500000 +#define BINDLESS_SAMPLER_CAPACITY 256 + +// Choose how many constant buffers will be placed in root in auto root signature: +#define CONSTANT_BUFFER_AUTO_PLACEMENT_IN_ROOT 4 + static_assert(DESCRIPTORBINDER_CBV_COUNT < 32, "cbv root mask must fit into uint32_t!"); + #ifdef PLATFORM_UWP // UWP will use static link + /DELAYLOAD linker feature for the dlls (optionally) @@ -61,7 +61,7 @@ namespace DX12_Internal // Engine -> Native converters - inline uint32_t _ParseColorWriteMask(uint32_t value) + constexpr uint32_t _ParseColorWriteMask(uint32_t value) { uint32_t _flag = 0; @@ -83,6 +83,45 @@ namespace DX12_Internal return _flag; } + constexpr D3D12_RESOURCE_STATES _ParseResourceState(RESOURCE_STATE value) + { + D3D12_RESOURCE_STATES ret = {}; + + if (value & RESOURCE_STATE_UNDEFINED) + ret |= D3D12_RESOURCE_STATE_COMMON; + if (value & RESOURCE_STATE_SHADER_RESOURCE) + ret |= D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE | D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE; + if (value & RESOURCE_STATE_SHADER_RESOURCE_COMPUTE) + ret |= D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE; + if (value & RESOURCE_STATE_UNORDERED_ACCESS) + ret |= D3D12_RESOURCE_STATE_UNORDERED_ACCESS; + if (value & RESOURCE_STATE_COPY_SRC) + ret |= D3D12_RESOURCE_STATE_COPY_SOURCE; + if (value & RESOURCE_STATE_COPY_DST) + ret |= D3D12_RESOURCE_STATE_COPY_DEST; + + if (value & RESOURCE_STATE_RENDERTARGET) + ret |= D3D12_RESOURCE_STATE_RENDER_TARGET; + if (value & RESOURCE_STATE_DEPTHSTENCIL) + ret |= D3D12_RESOURCE_STATE_DEPTH_WRITE; + if (value & RESOURCE_STATE_DEPTHSTENCIL_READONLY) + ret |= D3D12_RESOURCE_STATE_DEPTH_READ; + if (value & RESOURCE_STATE_SHADING_RATE_SOURCE) + ret |= D3D12_RESOURCE_STATE_SHADING_RATE_SOURCE; + + if (value & RESOURCE_STATE_VERTEX_BUFFER) + ret |= D3D12_RESOURCE_STATE_VERTEX_AND_CONSTANT_BUFFER; + if (value & RESOURCE_STATE_INDEX_BUFFER) + ret |= D3D12_RESOURCE_STATE_INDEX_BUFFER; + if (value & RESOURCE_STATE_CONSTANT_BUFFER) + ret |= D3D12_RESOURCE_STATE_VERTEX_AND_CONSTANT_BUFFER; + if (value & RESOURCE_STATE_INDIRECT_ARGUMENT) + ret |= D3D12_RESOURCE_STATE_INDIRECT_ARGUMENT; + if (value & RESOURCE_STATE_RAYTRACING_ACCELERATION_STRUCTURE) + ret |= D3D12_RESOURCE_STATE_RAYTRACING_ACCELERATION_STRUCTURE; + + return ret; + } constexpr D3D12_FILTER _ConvertFilter(FILTER value) { @@ -675,64 +714,6 @@ namespace DX12_Internal return data; } - constexpr D3D12_RESOURCE_STATES _ConvertImageLayout(IMAGE_LAYOUT value) - { - switch (value) - { - case wiGraphics::IMAGE_LAYOUT_UNDEFINED: - return D3D12_RESOURCE_STATE_COMMON; - case wiGraphics::IMAGE_LAYOUT_RENDERTARGET: - return D3D12_RESOURCE_STATE_RENDER_TARGET; - case wiGraphics::IMAGE_LAYOUT_DEPTHSTENCIL: - return D3D12_RESOURCE_STATE_DEPTH_WRITE; - case wiGraphics::IMAGE_LAYOUT_DEPTHSTENCIL_READONLY: - return D3D12_RESOURCE_STATE_DEPTH_READ; - case wiGraphics::IMAGE_LAYOUT_SHADER_RESOURCE: - return D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE | D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE; - case wiGraphics::IMAGE_LAYOUT_SHADER_RESOURCE_COMPUTE: - return D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE; - case wiGraphics::IMAGE_LAYOUT_UNORDERED_ACCESS: - return D3D12_RESOURCE_STATE_UNORDERED_ACCESS; - case wiGraphics::IMAGE_LAYOUT_COPY_SRC: - return D3D12_RESOURCE_STATE_COPY_SOURCE; - case wiGraphics::IMAGE_LAYOUT_COPY_DST: - return D3D12_RESOURCE_STATE_COPY_DEST; - case wiGraphics::IMAGE_LAYOUT_SHADING_RATE_SOURCE: - return D3D12_RESOURCE_STATE_SHADING_RATE_SOURCE; - } - - return D3D12_RESOURCE_STATE_COMMON; - } - constexpr D3D12_RESOURCE_STATES _ConvertBufferState(BUFFER_STATE value) - { - switch (value) - { - case wiGraphics::BUFFER_STATE_UNDEFINED: - return D3D12_RESOURCE_STATE_COMMON; - case wiGraphics::BUFFER_STATE_VERTEX_BUFFER: - return D3D12_RESOURCE_STATE_VERTEX_AND_CONSTANT_BUFFER; - case wiGraphics::BUFFER_STATE_INDEX_BUFFER: - return D3D12_RESOURCE_STATE_INDEX_BUFFER; - case wiGraphics::BUFFER_STATE_CONSTANT_BUFFER: - return D3D12_RESOURCE_STATE_VERTEX_AND_CONSTANT_BUFFER; - case wiGraphics::BUFFER_STATE_INDIRECT_ARGUMENT: - return D3D12_RESOURCE_STATE_INDIRECT_ARGUMENT; - case wiGraphics::BUFFER_STATE_SHADER_RESOURCE: - return D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE | D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE; - case wiGraphics::BUFFER_STATE_SHADER_RESOURCE_COMPUTE: - return D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE; - case wiGraphics::BUFFER_STATE_UNORDERED_ACCESS: - return D3D12_RESOURCE_STATE_UNORDERED_ACCESS; - case wiGraphics::BUFFER_STATE_COPY_SRC: - return D3D12_RESOURCE_STATE_COPY_SOURCE; - case wiGraphics::BUFFER_STATE_COPY_DST: - return D3D12_RESOURCE_STATE_COPY_DEST; - case wiGraphics::BUFFER_STATE_RAYTRACING_ACCELERATION_STRUCTURE: - return D3D12_RESOURCE_STATE_RAYTRACING_ACCELERATION_STRUCTURE; - } - - return D3D12_RESOURCE_STATE_COMMON; - } constexpr D3D12_SHADER_VISIBILITY _ConvertShaderVisibility(SHADERSTAGE value) { switch (value) @@ -1034,18 +1015,6 @@ namespace DX12_Internal } - // Local Helpers: - - inline size_t Align(size_t uLocation, size_t uAlign) - { - if ((0 == uAlign) || (uAlign & (uAlign - 1))) - { - assert(0); - } - - return ((uLocation + (uAlign - 1)) & ~(uAlign - 1)); - } - enum RESOURCEBINDING { CONSTANTBUFFER, @@ -1244,7 +1213,6 @@ namespace DX12_Internal std::shared_ptr allocationhandler; D3D12MA::Allocation* allocation = nullptr; ComPtr resource; - SingleDescriptor cbv; SingleDescriptor srv; SingleDescriptor uav; std::vector subresources_srv; @@ -1254,11 +1222,8 @@ namespace DX12_Internal D3D12_GPU_VIRTUAL_ADDRESS gpu_address = 0; - GraphicsDevice::GPUAllocation dynamic[COMMANDLIST_COUNT]; - uint64_t cbv_mask_frame[COMMANDLIST_COUNT] = {}; - uint32_t cbv_mask_gfx[COMMANDLIST_COUNT] = {}; - uint32_t cbv_mask_compute[COMMANDLIST_COUNT] = {}; + uint32_t cbv_mask[COMMANDLIST_COUNT] = {}; virtual ~Resource_DX12() { @@ -1268,7 +1233,6 @@ namespace DX12_Internal if (resource) allocationhandler->destroyer_resources.push_back(std::make_pair(resource, framecount)); allocationhandler->destroylocker.unlock(); - cbv.destroy(); srv.destroy(); uav.destroy(); for (auto& x : subresources_srv) @@ -1323,16 +1287,12 @@ namespace DX12_Internal struct QueryHeap_DX12 { std::shared_ptr allocationhandler; - D3D12MA::Allocation* allocation = nullptr; - Microsoft::WRL::ComPtr resource; Microsoft::WRL::ComPtr heap; ~QueryHeap_DX12() { allocationhandler->destroylocker.lock(); uint64_t framecount = allocationhandler->framecount; - if (allocation) allocationhandler->destroyer_allocations.push_back(std::make_pair(allocation, framecount)); - if (resource) allocationhandler->destroyer_resources.push_back(std::make_pair(resource, framecount)); if (heap) allocationhandler->destroyer_queryheaps.push_back(std::make_pair(heap, framecount)); allocationhandler->destroylocker.unlock(); } @@ -1591,7 +1551,7 @@ using namespace DX12_Internal; { GPUBufferDesc uploaddesc; uploaddesc.ByteWidth = wiMath::GetNextPowerOfTwo(staging_size); - uploaddesc.Usage = USAGE_STAGING; + uploaddesc.Usage = USAGE_UPLOAD; bool upload_success = device->CreateBuffer(&uploaddesc, nullptr, &cmd.uploadbuffer); assert(upload_success); @@ -1630,78 +1590,6 @@ using namespace DX12_Internal; locker.unlock(); } - void GraphicsDevice_DX12::FrameResources::ResourceFrameAllocator::init(GraphicsDevice_DX12* device, size_t size) - { - this->device = device; - auto internal_state = std::make_shared(); - internal_state->allocationhandler = device->allocationhandler; - buffer.internal_state = internal_state; - - HRESULT hr; - - D3D12MA::ALLOCATION_DESC allocationDesc = {}; - allocationDesc.HeapType = D3D12_HEAP_TYPE_UPLOAD; - - CD3DX12_RESOURCE_DESC resdesc = CD3DX12_RESOURCE_DESC::Buffer(size); - - hr = device->allocationhandler->allocator->CreateResource( - &allocationDesc, - &resdesc, - D3D12_RESOURCE_STATE_GENERIC_READ, - nullptr, - &internal_state->allocation, - IID_PPV_ARGS(&internal_state->resource) - ); - assert(SUCCEEDED(hr)); - - void* pData; - CD3DX12_RANGE readRange(0, 0); - internal_state->resource->Map(0, &readRange, &pData); - dataCur = dataBegin = reinterpret_cast(pData); - dataEnd = dataBegin + size; - - // Because the "buffer" is created by hand in this, fill the desc to indicate how it can be used: - buffer.type = GPUResource::GPU_RESOURCE_TYPE::BUFFER; - buffer.desc.ByteWidth = (uint32_t)((size_t)dataEnd - (size_t)dataBegin); - buffer.desc.Usage = USAGE_DYNAMIC; - buffer.desc.BindFlags = BIND_VERTEX_BUFFER | BIND_INDEX_BUFFER | BIND_SHADER_RESOURCE; - buffer.desc.MiscFlags = RESOURCE_MISC_BUFFER_ALLOW_RAW_VIEWS; - - internal_state->gpu_address = internal_state->resource->GetGPUVirtualAddress(); - - D3D12_SHADER_RESOURCE_VIEW_DESC srv_desc = {}; - srv_desc.ViewDimension = D3D12_SRV_DIMENSION_BUFFER; - srv_desc.Format = DXGI_FORMAT_R32_TYPELESS; - srv_desc.Buffer.Flags = D3D12_BUFFER_SRV_FLAG_RAW; - srv_desc.Buffer.NumElements = buffer.desc.ByteWidth / sizeof(uint32_t); - srv_desc.Shader4ComponentMapping = D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING; - internal_state->srv.init(device, srv_desc, internal_state->resource.Get()); - } - uint8_t* GraphicsDevice_DX12::FrameResources::ResourceFrameAllocator::allocate(size_t dataSize, size_t alignment) - { - dataCur = reinterpret_cast(Align(reinterpret_cast(dataCur), alignment)); - - if (dataCur + dataSize > dataEnd) - { - init(device, ((size_t)dataEnd + dataSize - (size_t)dataBegin) * 2); - } - - uint8_t* retVal = dataCur; - - dataCur += dataSize; - - return retVal; - } - void GraphicsDevice_DX12::FrameResources::ResourceFrameAllocator::clear() - { - dataCur = dataBegin; - } - uint64_t GraphicsDevice_DX12::FrameResources::ResourceFrameAllocator::calculateOffset(uint8_t* address) - { - assert(address >= dataBegin && address < dataEnd); - return static_cast(address - dataBegin); - } - void GraphicsDevice_DX12::DescriptorBinder::init(GraphicsDevice_DX12* device) { this->device = device; @@ -1717,6 +1605,7 @@ using namespace DX12_Internal; ringOffset_sam = 0; memset(CBV, 0, sizeof(CBV)); + memset(CBV_offset, 0, sizeof(CBV_offset)); memset(SRV, 0, sizeof(SRV)); memset(SRV_index, -1, sizeof(SRV_index)); memset(UAV, 0, sizeof(UAV)); @@ -1728,31 +1617,24 @@ using namespace DX12_Internal; auto pso_internal = graphics ? to_internal(device->active_pso[cmd]) : to_internal(device->active_cs[cmd]); // Bind root descriptors: - if ((dirty_root_cbvs_gfx != 0 && graphics) || (dirty_root_cbvs_compute != 0 && !graphics)) + if (dirty_root_cbvs != 0) { uint32_t root_param = pso_internal->bindpoint_rootdescriptor; for (auto& x : pso_internal->root_cbvs) { - bool dirty; - if (graphics) - { - dirty = dirty_root_cbvs_gfx & (1 << x.ShaderRegister); - } - else - { - dirty = dirty_root_cbvs_compute & (1 << x.ShaderRegister); - } + bool dirty = dirty_root_cbvs & (1 << x.ShaderRegister); if (!dirty) { root_param++; continue; } - const GPUBuffer* buffer = CBV[x.ShaderRegister]; + const GPUBuffer& buffer = CBV[x.ShaderRegister]; + uint64_t offset = CBV_offset[x.ShaderRegister]; D3D12_GPU_VIRTUAL_ADDRESS address; - if (buffer == nullptr || !buffer->IsValid()) + if (!buffer.IsValid()) { // this must not happen, root descriptor must be always valid! // this happens when constant buffer was not bound by engine @@ -1762,18 +1644,9 @@ using namespace DX12_Internal; } else { - auto internal_state = to_internal(buffer); - - if (buffer->desc.Usage == USAGE_DYNAMIC) - { - GraphicsDevice::GPUAllocation allocation = internal_state->dynamic[cmd]; - address = to_internal(allocation.buffer)->gpu_address; - address += (D3D12_GPU_VIRTUAL_ADDRESS)allocation.offset; - } - else - { - address = internal_state->cbv.cbv.BufferLocation; - } + auto internal_state = to_internal(&buffer); + address = internal_state->gpu_address; + address += offset; } if (graphics) @@ -1787,14 +1660,7 @@ using namespace DX12_Internal; root_param++; } - if (graphics) - { - dirty_root_cbvs_gfx = 0; - } - else - { - dirty_root_cbvs_compute = 0; - } + dirty_root_cbvs = 0; } @@ -1864,9 +1730,9 @@ using namespace DX12_Internal; default: case D3D12_DESCRIPTOR_RANGE_TYPE_SRV: { - const GPUResource* resource = SRV[ShaderRegister]; + const GPUResource& resource = SRV[ShaderRegister]; const int subresource = SRV_index[ShaderRegister]; - if (resource == nullptr || !resource->IsValid()) + if (!resource.IsValid()) { switch (binding) { @@ -1906,9 +1772,9 @@ using namespace DX12_Internal; } else { - auto internal_state = to_internal(resource); + auto internal_state = to_internal(&resource); - if (resource->IsAccelerationStructure()) + if (resource.IsAccelerationStructure()) { device->device->CopyDescriptorsSimple(1, dst, internal_state->srv.handle, D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV); } @@ -1929,9 +1795,9 @@ using namespace DX12_Internal; case D3D12_DESCRIPTOR_RANGE_TYPE_UAV: { - const GPUResource* resource = UAV[ShaderRegister]; + const GPUResource& resource = UAV[ShaderRegister]; const int subresource = UAV_index[ShaderRegister]; - if (resource == nullptr || !resource->IsValid()) + if (!resource.IsValid()) { switch (binding) { @@ -1962,7 +1828,7 @@ using namespace DX12_Internal; } else { - auto internal_state = to_internal(resource); + auto internal_state = to_internal(&resource); if (subresource < 0) { @@ -1978,30 +1844,23 @@ using namespace DX12_Internal; case D3D12_DESCRIPTOR_RANGE_TYPE_CBV: { - const GPUBuffer* buffer = CBV[ShaderRegister]; + const GPUBuffer& buffer = CBV[ShaderRegister]; + uint64_t offset = CBV_offset[ShaderRegister]; - if (buffer == nullptr || !buffer->IsValid()) + if (!buffer.IsValid()) { device->device->CopyDescriptorsSimple(1, dst, device->nullCBV, D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV); } else { - auto internal_state = to_internal(buffer); + auto internal_state = to_internal(&buffer); - if (buffer->desc.Usage == USAGE_DYNAMIC) - { - GraphicsDevice::GPUAllocation allocation = internal_state->dynamic[cmd]; - D3D12_CONSTANT_BUFFER_VIEW_DESC cbv; - cbv.BufferLocation = to_internal(allocation.buffer)->gpu_address; - cbv.BufferLocation += (D3D12_GPU_VIRTUAL_ADDRESS)allocation.offset; - cbv.SizeInBytes = (uint32_t)Align((size_t)buffer->desc.ByteWidth, D3D12_CONSTANT_BUFFER_DATA_PLACEMENT_ALIGNMENT); + D3D12_CONSTANT_BUFFER_VIEW_DESC cbv; + cbv.BufferLocation = internal_state->gpu_address; + cbv.BufferLocation += offset; + cbv.SizeInBytes = (uint32_t)Align((size_t)buffer.desc.ByteWidth, D3D12_CONSTANT_BUFFER_DATA_PLACEMENT_ALIGNMENT); - device->device->CreateConstantBufferView(&cbv, dst); - } - else - { - device->device->CopyDescriptorsSimple(1, dst, internal_state->cbv.handle, D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV); - } + device->device->CreateConstantBufferView(&cbv, dst); } } break; @@ -2061,14 +1920,14 @@ using namespace DX12_Internal; UINT ShaderRegister = x.BaseShaderRegister + descriptor_index; - const Sampler* sampler = SAM[ShaderRegister]; - if (sampler == nullptr || !sampler->IsValid()) + const Sampler& sampler = SAM[ShaderRegister]; + if (!sampler.IsValid()) { device->device->CopyDescriptorsSimple(1, dst, device->nullSAM, D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER); } else { - auto internal_state = to_internal(sampler); + auto internal_state = to_internal(&sampler); device->device->CopyDescriptorsSimple(1, dst, internal_state->descriptor.handle, D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER); } } @@ -2239,129 +2098,36 @@ using namespace DX12_Internal; } } - void GraphicsDevice_DX12::query_flush(CommandList cmd) - { - // Perform query resolves (must be outside of render pass): - assert(active_renderpass[cmd] == nullptr); - - if (!query_resolves[cmd].empty()) - { - for (auto& x : query_resolves[cmd]) - { - auto internal_state = to_internal(x.heap); - - switch (x.heap->desc.type) - { - case GPU_QUERY_TYPE_TIMESTAMP: - GetCommandList(cmd)->ResolveQueryData( - internal_state->heap.Get(), - D3D12_QUERY_TYPE_TIMESTAMP, - x.index, - x.count, - internal_state->resource.Get(), - sizeof(uint64_t) * x.index - ); - break; - case GPU_QUERY_TYPE_OCCLUSION_BINARY: - GetCommandList(cmd)->ResolveQueryData( - internal_state->heap.Get(), - D3D12_QUERY_TYPE_BINARY_OCCLUSION, - x.index, - x.count, - internal_state->resource.Get(), - sizeof(uint64_t) * x.index - ); - break; - case GPU_QUERY_TYPE_OCCLUSION: - GetCommandList(cmd)->ResolveQueryData( - internal_state->heap.Get(), - D3D12_QUERY_TYPE_OCCLUSION, - x.index, - x.count, - internal_state->resource.Get(), - sizeof(uint64_t) * x.index - ); - break; - } - - } - query_resolves[cmd].clear(); - } - } - void GraphicsDevice_DX12::barrier_flush(CommandList cmd) - { - auto& barriers = frame_barriers[cmd]; - if (!barriers.empty()) - { - for (size_t i = 0; i < barriers.size(); ++i) - { - auto& barrier = barriers[i]; - if (barrier.Type == D3D12_RESOURCE_BARRIER_TYPE_TRANSITION && - cmd_meta[cmd].queue > QUEUE_GRAPHICS) - { - // Only graphics queue can do pixel shader state: - barrier.Transition.StateBefore &= ~D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE; - barrier.Transition.StateAfter &= ~D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE; - } - if (barrier.Type == D3D12_RESOURCE_BARRIER_TYPE_TRANSITION && - barrier.Transition.StateBefore == barrier.Transition.StateAfter) - { - // Remove NOP barriers: - barrier = barriers.back(); - barriers.pop_back(); - i--; - } - } - if (!barriers.empty()) - { - GetCommandList(cmd)->ResourceBarrier( - (UINT)barriers.size(), - barriers.data() - ); - barriers.clear(); - } - } - } void GraphicsDevice_DX12::predraw(CommandList cmd) { pso_validate(cmd); descriptors[cmd].flush(true, cmd); - if (pushconstants[cmd].size > 0) + auto pso_internal = to_internal(active_pso[cmd]); + if (pso_internal->rootconstants.Constants.Num32BitValues > 0) { - auto pso_internal = to_internal(active_pso[cmd]); - if (pso_internal->rootconstants.Constants.Num32BitValues > 0) - { - GetCommandList(cmd)->SetGraphicsRoot32BitConstants( - pso_internal->bindpoint_rootconstant, - pso_internal->rootconstants.Constants.Num32BitValues, - pushconstants[cmd].data, - 0 - ); - pushconstants[cmd].size = 0; - } + GetCommandList(cmd)->SetGraphicsRoot32BitConstants( + pso_internal->bindpoint_rootconstant, + pso_internal->rootconstants.Constants.Num32BitValues, + pushconstants[cmd].data, + 0 + ); } } void GraphicsDevice_DX12::predispatch(CommandList cmd) { - barrier_flush(cmd); - descriptors[cmd].flush(false, cmd); - if (pushconstants[cmd].size > 0) + auto cs_internal = to_internal(active_cs[cmd]); + if (cs_internal->rootconstants.Constants.Num32BitValues > 0) { - auto cs_internal = to_internal(active_cs[cmd]); - if (cs_internal->rootconstants.Constants.Num32BitValues > 0) - { - GetCommandList(cmd)->SetComputeRoot32BitConstants( - cs_internal->bindpoint_rootconstant, - cs_internal->rootconstants.Constants.Num32BitValues, - pushconstants[cmd].data, - 0 - ); - pushconstants[cmd].size = 0; - } + GetCommandList(cmd)->SetComputeRoot32BitConstants( + cs_internal->bindpoint_rootconstant, + cs_internal->rootconstants.Constants.Num32BitValues, + pushconstants[cmd].data, + 0 + ); } } @@ -2369,7 +2135,7 @@ using namespace DX12_Internal; // Engine functions GraphicsDevice_DX12::GraphicsDevice_DX12(bool debuglayer, bool gpuvalidation) { - capabilities |= GRAPHICSDEVICE_CAPABILITY_BINDLESS_DESCRIPTORS; + ALLOCATION_MIN_ALIGNMENT = D3D12_CONSTANT_BUFFER_DATA_PLACEMENT_ALIGNMENT; SHADER_IDENTIFIER_SIZE = D3D12_SHADER_IDENTIFIER_SIZE_IN_BYTES; TOPLEVEL_ACCELERATION_STRUCTURE_INSTANCE_SIZE = sizeof(D3D12_RAYTRACING_INSTANCE_DESC); @@ -2679,14 +2445,9 @@ using namespace DX12_Internal; } hr = device->CheckFeatureSupport(D3D12_FEATURE_D3D12_OPTIONS5, &features_5, sizeof(features_5)); - if (features_5.RaytracingTier >= D3D12_RAYTRACING_TIER_1_0) + if (features_5.RaytracingTier >= D3D12_RAYTRACING_TIER_1_1) { - capabilities |= GRAPHICSDEVICE_CAPABILITY_RAYTRACING_PIPELINE; - if (features_5.RaytracingTier >= D3D12_RAYTRACING_TIER_1_1) - { - capabilities |= GRAPHICSDEVICE_CAPABILITY_RAYTRACING_INLINE; - capabilities |= GRAPHICSDEVICE_CAPABILITY_RAYTRACING_GEOMETRYINDEX; - } + capabilities |= GRAPHICSDEVICE_CAPABILITY_RAYTRACING; } hr = device->CheckFeatureSupport(D3D12_FEATURE_D3D12_OPTIONS6, &features_6, sizeof(features_6)); @@ -2842,7 +2603,7 @@ using namespace DX12_Internal; nullSRV_texture3d = allocationhandler->descriptors_res.allocate(); device->CreateShaderResourceView(nullptr, &srv_desc, nullSRV_texture3d); } - if(CheckCapability(GRAPHICSDEVICE_CAPABILITY_RAYTRACING_PIPELINE) || CheckCapability(GRAPHICSDEVICE_CAPABILITY_RAYTRACING_INLINE)) + if(CheckCapability(GRAPHICSDEVICE_CAPABILITY_RAYTRACING)) { D3D12_SHADER_RESOURCE_VIEW_DESC srv_desc = {}; srv_desc.Shader4ComponentMapping = D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING; @@ -3025,15 +2786,11 @@ using namespace DX12_Internal; internal_state->allocationhandler = allocationhandler; pBuffer->internal_state = internal_state; pBuffer->type = GPUResource::GPU_RESOURCE_TYPE::BUFFER; + pBuffer->mapped_data = nullptr; + pBuffer->mapped_rowpitch = 0; pBuffer->desc = *pDesc; - if (pDesc->Usage == USAGE_DYNAMIC && pDesc->BindFlags & BIND_CONSTANT_BUFFER) - { - // this special case will use frame allocator - return true; - } - HRESULT hr = E_FAIL; size_t alignedSize = pDesc->ByteWidth; @@ -3063,18 +2820,15 @@ using namespace DX12_Internal; D3D12MA::ALLOCATION_DESC allocationDesc = {}; allocationDesc.HeapType = D3D12_HEAP_TYPE_DEFAULT; - if (pDesc->Usage == USAGE_STAGING) + if (pDesc->Usage == USAGE_READBACK) { - if (pDesc->CPUAccessFlags & CPU_ACCESS_READ) - { - allocationDesc.HeapType = D3D12_HEAP_TYPE_READBACK; - resourceState = D3D12_RESOURCE_STATE_COPY_DEST; - } - else - { - allocationDesc.HeapType = D3D12_HEAP_TYPE_UPLOAD; - resourceState = D3D12_RESOURCE_STATE_GENERIC_READ; - } + allocationDesc.HeapType = D3D12_HEAP_TYPE_READBACK; + resourceState = D3D12_RESOURCE_STATE_COPY_DEST; + } + else if (pDesc->Usage == USAGE_UPLOAD) + { + allocationDesc.HeapType = D3D12_HEAP_TYPE_UPLOAD; + resourceState = D3D12_RESOURCE_STATE_GENERIC_READ; } device->GetCopyableFootprints(&desc, 0, 1, 0, &internal_state->footprint, nullptr, nullptr, nullptr); @@ -3091,6 +2845,20 @@ using namespace DX12_Internal; internal_state->gpu_address = internal_state->resource->GetGPUVirtualAddress(); + if (pDesc->Usage == USAGE_READBACK) + { + hr = internal_state->resource->Map(0, nullptr, &pBuffer->mapped_data); + assert(SUCCEEDED(hr)); + pBuffer->mapped_rowpitch = pDesc->ByteWidth; + } + else if (pDesc->Usage == USAGE_UPLOAD) + { + D3D12_RANGE read_range = {}; + hr = internal_state->resource->Map(0, &read_range, &pBuffer->mapped_data); + assert(SUCCEEDED(hr)); + pBuffer->mapped_rowpitch = pDesc->ByteWidth; + } + // Issue data copy on request: if (pInitialData != nullptr) { @@ -3111,10 +2879,6 @@ using namespace DX12_Internal; // Create resource views if needed - if (pDesc->BindFlags & BIND_CONSTANT_BUFFER) - { - CreateSubresource(pBuffer, CBV, 0); - } if (pDesc->BindFlags & BIND_SHADER_RESOURCE) { CreateSubresource(pBuffer, SRV, 0); @@ -3132,6 +2896,8 @@ using namespace DX12_Internal; internal_state->allocationhandler = allocationhandler; pTexture->internal_state = internal_state; pTexture->type = GPUResource::GPU_RESOURCE_TYPE::TEXTURE; + pTexture->mapped_data = nullptr; + pTexture->mapped_rowpitch = 0; pTexture->desc = *pDesc; @@ -3155,7 +2921,7 @@ using namespace DX12_Internal; if (pDesc->BindFlags & BIND_DEPTH_STENCIL) { desc.Flags |= D3D12_RESOURCE_FLAG_ALLOW_DEPTH_STENCIL; - allocationDesc.Flags |= D3D12MA::ALLOCATION_FLAG_COMMITTED; + //allocationDesc.Flags |= D3D12MA::ALLOCATION_FLAG_COMMITTED; if (!(pDesc->BindFlags & BIND_SHADER_RESOURCE)) { desc.Flags |= D3D12_RESOURCE_FLAG_DENY_SHADER_RESOURCE; @@ -3164,16 +2930,11 @@ using namespace DX12_Internal; if (pDesc->BindFlags & BIND_RENDER_TARGET) { desc.Flags |= D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET; - allocationDesc.Flags |= D3D12MA::ALLOCATION_FLAG_COMMITTED; + //allocationDesc.Flags |= D3D12MA::ALLOCATION_FLAG_COMMITTED; } if (pDesc->BindFlags & BIND_UNORDERED_ACCESS) { desc.Flags |= D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS; - //desc.Flags |= D3D12_RESOURCE_FLAG_ALLOW_SIMULTANEOUS_ACCESS; - if (pInitialData == nullptr) - { - allocationDesc.Flags |= D3D12MA::ALLOCATION_FLAG_COMMITTED; - } } switch (pTexture->desc.type) @@ -3215,14 +2976,14 @@ using namespace DX12_Internal; } bool useClearValue = pDesc->BindFlags & BIND_RENDER_TARGET || pDesc->BindFlags & BIND_DEPTH_STENCIL; - D3D12_RESOURCE_STATES resourceState = _ConvertImageLayout(pTexture->desc.layout); + D3D12_RESOURCE_STATES resourceState = _ParseResourceState(pTexture->desc.layout); if (pInitialData != nullptr) { resourceState = D3D12_RESOURCE_STATE_COMMON; } - if (pTexture->desc.Usage == USAGE_STAGING) + if (pTexture->desc.Usage == USAGE_READBACK || pTexture->desc.Usage == USAGE_UPLOAD) { UINT64 RequiredSize = 0; device->GetCopyableFootprints(&desc, 0, 1, 0, &internal_state->footprint, nullptr, nullptr, &RequiredSize); @@ -3234,12 +2995,12 @@ using namespace DX12_Internal; desc.Layout = D3D12_TEXTURE_LAYOUT_ROW_MAJOR; desc.Flags = D3D12_RESOURCE_FLAG_NONE; - if (pTexture->desc.CPUAccessFlags & CPU_ACCESS_READ) + if (pTexture->desc.Usage == USAGE_READBACK) { allocationDesc.HeapType = D3D12_HEAP_TYPE_READBACK; resourceState = D3D12_RESOURCE_STATE_COPY_DEST; } - else + else if(pTexture->desc.Usage == USAGE_UPLOAD) { allocationDesc.HeapType = D3D12_HEAP_TYPE_UPLOAD; resourceState = D3D12_RESOURCE_STATE_GENERIC_READ; @@ -3256,6 +3017,20 @@ using namespace DX12_Internal; ); assert(SUCCEEDED(hr)); + if (pTexture->desc.Usage == USAGE_READBACK) + { + hr = internal_state->resource->Map(0, nullptr, &pTexture->mapped_data); + assert(SUCCEEDED(hr)); + pTexture->mapped_rowpitch = internal_state->footprint.Footprint.RowPitch; + } + else if(pTexture->desc.Usage == USAGE_UPLOAD) + { + D3D12_RANGE read_range = {}; + hr = internal_state->resource->Map(0, &read_range, &pTexture->mapped_data); + assert(SUCCEEDED(hr)); + pTexture->mapped_rowpitch = internal_state->footprint.Footprint.RowPitch; + } + if (pTexture->desc.MipLevels == 0) { pTexture->desc.MipLevels = (uint32_t)log2(std::max(pTexture->desc.Width, pTexture->desc.Height)) + 1; @@ -3952,32 +3727,6 @@ using namespace DX12_Internal; HRESULT hr = allocationhandler->device->CreateQueryHeap(&desc, IID_PPV_ARGS(&internal_state->heap)); assert(SUCCEEDED(hr)); - D3D12MA::ALLOCATION_DESC allocationDesc = {}; - allocationDesc.HeapType = D3D12_HEAP_TYPE_READBACK; - - D3D12_RESOURCE_DESC resdesc = {}; - resdesc.Dimension = D3D12_RESOURCE_DIMENSION_BUFFER; - resdesc.Format = DXGI_FORMAT_UNKNOWN; - resdesc.Width = (UINT64)(desc.Count * sizeof(uint64_t)); - resdesc.Height = 1; - resdesc.MipLevels = 1; - resdesc.Layout = D3D12_TEXTURE_LAYOUT_ROW_MAJOR; - resdesc.DepthOrArraySize = 1; - resdesc.Alignment = 0; - resdesc.Flags = D3D12_RESOURCE_FLAG_NONE; - resdesc.SampleDesc.Count = 1; - resdesc.SampleDesc.Quality = 0; - - hr = allocationhandler->allocator->CreateResource( - &allocationDesc, - &resdesc, - D3D12_RESOURCE_STATE_COPY_DEST, - nullptr, - &internal_state->allocation, - IID_PPV_ARGS(&internal_state->resource) - ); - assert(SUCCEEDED(hr)); - return SUCCEEDED(hr); } bool GraphicsDevice_DX12::CreatePipelineState(const PipelineStateDesc* pDesc, PipelineState* pso) const @@ -4658,14 +4407,14 @@ using namespace DX12_Internal; barrierdesc.Type = D3D12_RESOURCE_BARRIER_TYPE_TRANSITION; barrierdesc.Flags = D3D12_RESOURCE_BARRIER_FLAG_NONE; barrierdesc.Transition.pResource = texture_internal->resource.Get(); - barrierdesc.Transition.StateBefore = _ConvertImageLayout(attachment.initial_layout); + barrierdesc.Transition.StateBefore = _ParseResourceState(attachment.initial_layout); if (attachment.type == RenderPassAttachment::RESOLVE) { barrierdesc.Transition.StateAfter = D3D12_RESOURCE_STATE_RESOLVE_DEST; } else { - barrierdesc.Transition.StateAfter = _ConvertImageLayout(attachment.subpass_layout); + barrierdesc.Transition.StateAfter = _ParseResourceState(attachment.subpass_layout); } barrierdesc.Transition.Subresource = D3D12_RESOURCE_BARRIER_ALL_SUBRESOURCES; @@ -4695,9 +4444,9 @@ using namespace DX12_Internal; } else { - barrierdesc.Transition.StateBefore = _ConvertImageLayout(attachment.subpass_layout); + barrierdesc.Transition.StateBefore = _ParseResourceState(attachment.subpass_layout); } - barrierdesc.Transition.StateAfter = _ConvertImageLayout(attachment.final_layout); + barrierdesc.Transition.StateAfter = _ParseResourceState(attachment.final_layout); barrierdesc.Transition.Subresource = D3D12_RESOURCE_BARRIER_ALL_SUBRESOURCES; if (barrierdesc.Transition.StateBefore == barrierdesc.Transition.StateAfter) @@ -5337,23 +5086,13 @@ using namespace DX12_Internal; switch (type) { - case wiGraphics::CBV: - { - size = std::min(size, (uint64_t)buffer->desc.ByteWidth); - D3D12_CONSTANT_BUFFER_VIEW_DESC cbv_desc = {}; - cbv_desc.SizeInBytes = (uint32_t)Align(size, D3D12_CONSTANT_BUFFER_DATA_PLACEMENT_ALIGNMENT); - cbv_desc.BufferLocation = internal_state->gpu_address + offset; - internal_state->cbv.init(this, cbv_desc); - return -1; - } - break; case wiGraphics::SRV: { D3D12_SHADER_RESOURCE_VIEW_DESC srv_desc = {}; srv_desc.Shader4ComponentMapping = D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING; - if (desc.MiscFlags & RESOURCE_MISC_BUFFER_ALLOW_RAW_VIEWS) + if (desc.MiscFlags & RESOURCE_MISC_BUFFER_RAW) { // This is a Raw Buffer srv_desc.Format = DXGI_FORMAT_R32_TYPELESS; @@ -5400,7 +5139,7 @@ using namespace DX12_Internal; uav_desc.ViewDimension = D3D12_UAV_DIMENSION_BUFFER; uav_desc.Buffer.FirstElement = 0; - if (desc.MiscFlags & RESOURCE_MISC_BUFFER_ALLOW_RAW_VIEWS) + if (desc.MiscFlags & RESOURCE_MISC_BUFFER_RAW) { // This is a Raw Buffer uav_desc.Format = DXGI_FORMAT_R32_TYPELESS; @@ -5455,9 +5194,6 @@ using namespace DX12_Internal; switch (type) { default: - case wiGraphics::CBV: - return internal_state->cbv.index; - break; case wiGraphics::SRV: if (subresource < 0) { @@ -5522,53 +5258,6 @@ using namespace DX12_Internal; memcpy(dest, identifier, D3D12_SHADER_IDENTIFIER_SIZE_IN_BYTES); } - void GraphicsDevice_DX12::Map(const GPUResource* resource, Mapping* mapping) const - { - auto internal_state = to_internal(resource); - D3D12_RANGE read_range = {}; - if (mapping->_flags & Mapping::FLAG_READ) - { - read_range.Begin = mapping->offset; - read_range.End = mapping->size; - } - HRESULT hr = internal_state->resource->Map(0, &read_range, &mapping->data); - if (SUCCEEDED(hr)) - { - mapping->rowpitch = internal_state->footprint.Footprint.RowPitch; - } - else - { - assert(0); - mapping->data = nullptr; - mapping->rowpitch = 0; - } - } - void GraphicsDevice_DX12::Unmap(const GPUResource* resource) const - { - auto internal_state = to_internal(resource); - internal_state->resource->Unmap(0, nullptr); - } - void GraphicsDevice_DX12::QueryRead(const GPUQueryHeap* heap, uint32_t index, uint32_t count, uint64_t* results) const - { - if (count == 0) - return; - - auto internal_state = to_internal(heap); - - D3D12_RANGE range; - range.Begin = (size_t)index * sizeof(uint64_t); - range.End = range.Begin + sizeof(uint64_t) * count; - D3D12_RANGE nullrange = {}; - void* data = nullptr; - - HRESULT hr = internal_state->resource->Map(0, &range, &data); - if (SUCCEEDED(hr)) - { - std::memcpy(results, (void*)((size_t)data + range.Begin), sizeof(uint64_t) * count); - internal_state->resource->Unmap(0, &nullrange); - } - } - void GraphicsDevice_DX12::SetCommonSampler(const StaticSampler* sam) { common_samplers.push_back(_ConvertStaticSampler(*sam)); @@ -5605,8 +5294,6 @@ using namespace DX12_Internal; hr = device->CreateCommandAllocator(queues[queue].desc.Type, IID_PPV_ARGS(&frames[fr].commandAllocators[cmd][queue])); assert(SUCCEEDED(hr)); - frames[fr].resourceBuffer[cmd].init(this, 1024 * 1024); // 1 MB starting size - } hr = device->CreateCommandList1(0, queues[queue].desc.Type, D3D12_COMMAND_LIST_FLAG_NONE, IID_PPV_ARGS(&commandLists[cmd][queue])); @@ -5632,7 +5319,6 @@ using namespace DX12_Internal; GetCommandList(cmd)->SetDescriptorHeaps(arraysize(heaps), heaps); descriptors[cmd].reset(); - GetFrameResources().resourceBuffer[cmd].clear(); if (queue == QUEUE_GRAPHICS) { @@ -5647,7 +5333,7 @@ using namespace DX12_Internal; GetCommandList(cmd)->RSSetScissorRects(8, pRects); } - prev_pt[cmd] = PRIMITIVETOPOLOGY::UNDEFINED; + prev_pt[cmd] = UNDEFINED_TOPOLOGY; prev_pipeline_hash[cmd] = 0; active_pso[cmd] = nullptr; active_cs[cmd] = nullptr; @@ -5677,9 +5363,6 @@ using namespace DX12_Internal; cmd_count.store(0); for (CommandList cmd = 0; cmd < cmd_last; ++cmd) { - query_flush(cmd); - barrier_flush(cmd); - hr = GetCommandList(cmd)->Close(); assert(SUCCEEDED(hr)); @@ -5884,9 +5567,7 @@ using namespace DX12_Internal; barrier.Transition.StateAfter = D3D12_RESOURCE_STATE_RENDER_TARGET; barrier.Transition.Subresource = D3D12_RESOURCE_BARRIER_ALL_SUBRESOURCES; barrier.Type = D3D12_RESOURCE_BARRIER_TYPE_TRANSITION; - - frame_barriers[cmd].push_back(barrier); - barrier_flush(cmd); + GetCommandList(cmd)->ResourceBarrier(1, &barrier); D3D12_RENDER_PASS_RENDER_TARGET_DESC RTV = {}; RTV.cpuDescriptor = internal_state->backbufferRTV[internal_state->swapChain->GetCurrentBackBufferIndex()]; @@ -5905,11 +5586,7 @@ using namespace DX12_Internal; auto internal_state = to_internal(active_renderpass[cmd]); - for (uint32_t i = 0; i < internal_state->num_barriers_begin; ++i) - { - frame_barriers[cmd].push_back(internal_state->barrierdescs_begin[i]); - } - barrier_flush(cmd); + GetCommandList(cmd)->ResourceBarrier(internal_state->num_barriers_begin, internal_state->barrierdescs_begin); if (internal_state->shading_rate_image != nullptr) { @@ -5937,16 +5614,11 @@ using namespace DX12_Internal; GetCommandList(cmd)->RSSetShadingRateImage(nullptr); } - for (uint32_t i = 0; i < internal_state->num_barriers_end; ++i) - { - frame_barriers[cmd].push_back(internal_state->barrierdescs_end[i]); - } + GetCommandList(cmd)->ResourceBarrier(internal_state->num_barriers_end, internal_state->barrierdescs_end); } active_renderpass[cmd] = nullptr; - query_flush(cmd); - if (active_backbuffer[cmd]) { D3D12_RESOURCE_BARRIER barrier = {}; @@ -5956,7 +5628,7 @@ using namespace DX12_Internal; barrier.Transition.StateAfter = D3D12_RESOURCE_STATE_PRESENT; barrier.Transition.Subresource = D3D12_RESOURCE_BARRIER_ALL_SUBRESOURCES; barrier.Type = D3D12_RESOURCE_BARRIER_TYPE_TRANSITION; - frame_barriers[cmd].push_back(barrier); + GetCommandList(cmd)->ResourceBarrier(1, &barrier); active_backbuffer[cmd] = nullptr; } @@ -5990,67 +5662,62 @@ using namespace DX12_Internal; } GetCommandList(cmd)->RSSetViewports(NumViewports, d3dViewPorts); } - void GraphicsDevice_DX12::BindResource(SHADERSTAGE stage, const GPUResource* resource, uint32_t slot, CommandList cmd, int subresource) + void GraphicsDevice_DX12::BindResource(const GPUResource* resource, uint32_t slot, CommandList cmd, int subresource) { - assert(slot < GPU_RESOURCE_HEAP_SRV_COUNT); - if (descriptors[cmd].SRV[slot] != resource || descriptors[cmd].SRV_index[slot] != subresource) + assert(slot < DESCRIPTORBINDER_SRV_COUNT); + if (descriptors[cmd].SRV[slot].internal_state != resource->internal_state || descriptors[cmd].SRV_index[slot] != subresource) { - descriptors[cmd].SRV[slot] = resource; + descriptors[cmd].SRV[slot] = *resource; descriptors[cmd].SRV_index[slot] = subresource; descriptors[cmd].dirty_res = true; } } - void GraphicsDevice_DX12::BindResources(SHADERSTAGE stage, const GPUResource* const* resources, uint32_t slot, uint32_t count, CommandList cmd) + void GraphicsDevice_DX12::BindResources(const GPUResource* const* resources, uint32_t slot, uint32_t count, CommandList cmd) { if (resources != nullptr) { for (uint32_t i = 0; i < count; ++i) { - BindResource(stage, resources[i], slot + i, cmd, -1); + BindResource(resources[i], slot + i, cmd, -1); } } } - void GraphicsDevice_DX12::BindUAV(SHADERSTAGE stage, const GPUResource* resource, uint32_t slot, CommandList cmd, int subresource) + void GraphicsDevice_DX12::BindUAV(const GPUResource* resource, uint32_t slot, CommandList cmd, int subresource) { - assert(slot < GPU_RESOURCE_HEAP_UAV_COUNT); - if (descriptors[cmd].UAV[slot] != resource || descriptors[cmd].UAV_index[slot] != subresource) + assert(slot < DESCRIPTORBINDER_UAV_COUNT); + if (descriptors[cmd].UAV[slot].internal_state != resource->internal_state || descriptors[cmd].UAV_index[slot] != subresource) { - descriptors[cmd].UAV[slot] = resource; + descriptors[cmd].UAV[slot] = *resource; descriptors[cmd].UAV_index[slot] = subresource; descriptors[cmd].dirty_res = true; } } - void GraphicsDevice_DX12::BindUAVs(SHADERSTAGE stage, const GPUResource* const* resources, uint32_t slot, uint32_t count, CommandList cmd) + void GraphicsDevice_DX12::BindUAVs(const GPUResource* const* resources, uint32_t slot, uint32_t count, CommandList cmd) { if (resources != nullptr) { for (uint32_t i = 0; i < count; ++i) { - BindUAV(stage, resources[i], slot + i, cmd, -1); + BindUAV(resources[i], slot + i, cmd, -1); } } } - void GraphicsDevice_DX12::UnbindResources(uint32_t slot, uint32_t num, CommandList cmd) + void GraphicsDevice_DX12::BindSampler(const Sampler* sampler, uint32_t slot, CommandList cmd) { - } - void GraphicsDevice_DX12::UnbindUAVs(uint32_t slot, uint32_t num, CommandList cmd) - { - } - void GraphicsDevice_DX12::BindSampler(SHADERSTAGE stage, const Sampler* sampler, uint32_t slot, CommandList cmd) - { - assert(slot < GPU_SAMPLER_HEAP_COUNT); - if (descriptors[cmd].SAM[slot] != sampler) + assert(slot < DESCRIPTORBINDER_SAMPLER_COUNT); + if (descriptors[cmd].SAM[slot].internal_state != sampler->internal_state) { - descriptors[cmd].SAM[slot] = sampler; + descriptors[cmd].SAM[slot] = *sampler; descriptors[cmd].dirty_sam = true; } } - void GraphicsDevice_DX12::BindConstantBuffer(SHADERSTAGE stage, const GPUBuffer* buffer, uint32_t slot, CommandList cmd) + void GraphicsDevice_DX12::BindConstantBuffer(const GPUBuffer* buffer, uint32_t slot, CommandList cmd, uint64_t offset) { - assert(slot < GPU_RESOURCE_HEAP_CBV_COUNT); - if (buffer->desc.Usage == USAGE_DYNAMIC || descriptors[cmd].CBV[slot] != buffer) + assert(slot < DESCRIPTORBINDER_CBV_COUNT); + if (descriptors[cmd].CBV[slot].internal_state != buffer->internal_state || descriptors[cmd].CBV_offset[slot] != offset) { - descriptors[cmd].CBV[slot] = buffer; + descriptors[cmd].CBV[slot] = *buffer; + descriptors[cmd].CBV_offset[slot] = offset; descriptors[cmd].dirty_res = true; // Root constant buffer root signature state tracking: @@ -6059,23 +5726,14 @@ using namespace DX12_Internal; { // This is the first binding as constant buffer in this frame for this resource, // so clear the cbv flags completely - internal_state->cbv_mask_gfx[cmd] = 0; - internal_state->cbv_mask_compute[cmd] = 0; + internal_state->cbv_mask[cmd] = 0; internal_state->cbv_mask_frame[cmd] = FRAMECOUNT; } // CBV flag marked as bound for this slot: // Also, the corresponding slot is marked dirty - if (stage == CS) - { - internal_state->cbv_mask_compute[cmd] |= 1 << slot; - descriptors[cmd].dirty_root_cbvs_compute |= 1 << slot; - } - else - { - internal_state->cbv_mask_gfx[cmd] |= 1 << slot; - descriptors[cmd].dirty_root_cbvs_gfx |= 1 << slot; - } + internal_state->cbv_mask[cmd] |= 1 << slot; + descriptors[cmd].dirty_root_cbvs |= 1 << slot; } } void GraphicsDevice_DX12::BindVertexBuffers(const GPUBuffer* const* vertexBuffers, uint32_t slot, uint32_t count, const uint32_t* strides, const uint32_t* offsets, CommandList cmd) @@ -6164,7 +5822,7 @@ using namespace DX12_Internal; // Invalidate graphics root bindings: descriptors[cmd].dirty_res = true; descriptors[cmd].dirty_sam = true; - descriptors[cmd].dirty_root_cbvs_gfx = ~0; + descriptors[cmd].dirty_root_cbvs = ~0; // Set the bindless tables: uint32_t bindpoint = internal_state->bindpoint_bindless; @@ -6208,7 +5866,7 @@ using namespace DX12_Internal; // Invalidate compute root bindings: descriptors[cmd].dirty_res = true; descriptors[cmd].dirty_sam = true; - descriptors[cmd].dirty_root_cbvs_compute = ~0; + descriptors[cmd].dirty_root_cbvs = ~0; // Set the bindless tables: uint32_t bindpoint = internal_state->bindpoint_bindless; @@ -6280,7 +5938,6 @@ using namespace DX12_Internal; } void GraphicsDevice_DX12::CopyResource(const GPUResource* pDst, const GPUResource* pSrc, CommandList cmd) { - barrier_flush(cmd); auto internal_state_src = to_internal(pSrc); auto internal_state_dst = to_internal(pDst); D3D12_RESOURCE_DESC desc_src = internal_state_src->resource->GetDesc(); @@ -6302,71 +5959,12 @@ using namespace DX12_Internal; GetCommandList(cmd)->CopyResource(internal_state_dst->resource.Get(), internal_state_src->resource.Get()); } } - void GraphicsDevice_DX12::UpdateBuffer(const GPUBuffer* buffer, const void* data, CommandList cmd, int dataSize) + void GraphicsDevice_DX12::CopyBuffer(const GPUBuffer* pDst, uint64_t dst_offset, const GPUBuffer* pSrc, uint64_t src_offset, uint64_t size, CommandList cmd) { - assert(buffer->desc.Usage != USAGE_IMMUTABLE && "Cannot update IMMUTABLE GPUBuffer!"); - assert((int)buffer->desc.ByteWidth >= dataSize || dataSize < 0 && "Data size is too big!"); - - if (dataSize == 0) - { - return; - } - - dataSize = std::min((int)buffer->desc.ByteWidth, dataSize); - dataSize = (dataSize >= 0 ? dataSize : buffer->desc.ByteWidth); - - auto internal_state_dst = to_internal(buffer); - - GPUAllocation allocation = AllocateGPU(dataSize, cmd); - memcpy(allocation.data, data, dataSize); - - if (buffer->desc.Usage == USAGE_DYNAMIC && buffer->desc.BindFlags & BIND_CONSTANT_BUFFER) - { - // Dynamic buffer will be used from host memory directly: - internal_state_dst->dynamic[cmd] = allocation; - - // The proper binding slot is not tracked properly, but instead all the previous bindings are invalidated: - descriptors[cmd].dirty_res = true; - descriptors[cmd].dirty_root_cbvs_gfx |= internal_state_dst->cbv_mask_gfx[cmd]; - descriptors[cmd].dirty_root_cbvs_compute |= internal_state_dst->cbv_mask_compute[cmd]; - } - else - { - // Contents will be transferred to device memory: - assert(active_renderpass[cmd] == nullptr); - - auto internal_state_src = to_internal(&GetFrameResources().resourceBuffer[cmd].buffer); - - D3D12_RESOURCE_BARRIER barrier = {}; - barrier.Flags = D3D12_RESOURCE_BARRIER_FLAG_NONE; - barrier.Transition.pResource = internal_state_dst->resource.Get(); - barrier.Transition.StateBefore = D3D12_RESOURCE_STATE_COMMON; - if (buffer->desc.BindFlags & BIND_CONSTANT_BUFFER || buffer->desc.BindFlags & BIND_VERTEX_BUFFER) - { - barrier.Transition.StateBefore = D3D12_RESOURCE_STATE_VERTEX_AND_CONSTANT_BUFFER; - } - else if (buffer->desc.BindFlags & BIND_INDEX_BUFFER) - { - barrier.Transition.StateBefore = D3D12_RESOURCE_STATE_INDEX_BUFFER; - } - barrier.Transition.StateAfter = D3D12_RESOURCE_STATE_COPY_DEST; - barrier.Transition.Subresource = D3D12_RESOURCE_BARRIER_ALL_SUBRESOURCES; - barrier.Type = D3D12_RESOURCE_BARRIER_TYPE_TRANSITION; - frame_barriers[cmd].push_back(barrier); - barrier_flush(cmd); - - GetCommandList(cmd)->CopyBufferRegion( - internal_state_dst->resource.Get(), 0, - internal_state_src->resource.Get(), allocation.offset, - dataSize - ); - - barrier.Transition.StateBefore = D3D12_RESOURCE_STATE_COPY_DEST; - barrier.Transition.StateAfter = D3D12_RESOURCE_STATE_COMMON; - frame_barriers[cmd].push_back(barrier); - - } + auto src_internal = to_internal((const GPUBuffer*)pSrc); + auto dst_internal = to_internal((const GPUBuffer*)pDst); + GetCommandList(cmd)->CopyBufferRegion(dst_internal->resource.Get(), dst_offset, src_internal->resource.Get(), src_offset, size); } void GraphicsDevice_DX12::QueryBegin(const GPUQueryHeap* heap, uint32_t index, CommandList cmd) { @@ -6426,16 +6024,46 @@ using namespace DX12_Internal; break; } } - void GraphicsDevice_DX12::QueryResolve(const GPUQueryHeap* heap, uint32_t index, uint32_t count, CommandList cmd) + void GraphicsDevice_DX12::QueryResolve(const GPUQueryHeap* heap, uint32_t index, uint32_t count, const GPUBuffer* dest, uint64_t dest_offset, CommandList cmd) { - if (count == 0) - return; + assert(active_renderpass[cmd] == nullptr); // Can't resolve inside renderpass! - QueryResolver resolver; - resolver.heap = heap; - resolver.index = index; - resolver.count = count; - query_resolves[cmd].push_back(resolver); + auto internal_state = to_internal(heap); + auto dst_internal = to_internal(dest); + + switch (heap->desc.type) + { + case GPU_QUERY_TYPE_TIMESTAMP: + GetCommandList(cmd)->ResolveQueryData( + internal_state->heap.Get(), + D3D12_QUERY_TYPE_TIMESTAMP, + index, + count, + dst_internal->resource.Get(), + dest_offset + ); + break; + case GPU_QUERY_TYPE_OCCLUSION_BINARY: + GetCommandList(cmd)->ResolveQueryData( + internal_state->heap.Get(), + D3D12_QUERY_TYPE_BINARY_OCCLUSION, + index, + count, + dst_internal->resource.Get(), + dest_offset + ); + break; + case GPU_QUERY_TYPE_OCCLUSION: + GetCommandList(cmd)->ResolveQueryData( + internal_state->heap.Get(), + D3D12_QUERY_TYPE_OCCLUSION, + index, + count, + dst_internal->resource.Get(), + dest_offset + ); + break; + } } void GraphicsDevice_DX12::Barrier(const GPUBarrier* barriers, uint32_t numBarriers, CommandList cmd) { @@ -6445,6 +6073,11 @@ using namespace DX12_Internal; { const GPUBarrier& barrier = barriers[i]; + if (barrier.type == GPUBarrier::IMAGE_BARRIER && (barrier.image.texture == nullptr || !barrier.image.texture->IsValid())) + continue; + if (barrier.type == GPUBarrier::BUFFER_BARRIER && (barrier.buffer.buffer == nullptr || !barrier.buffer.buffer->IsValid())) + continue; + D3D12_RESOURCE_BARRIER barrierdesc = {}; switch (barrier.type) @@ -6462,8 +6095,8 @@ using namespace DX12_Internal; barrierdesc.Type = D3D12_RESOURCE_BARRIER_TYPE_TRANSITION; barrierdesc.Flags = D3D12_RESOURCE_BARRIER_FLAG_NONE; barrierdesc.Transition.pResource = to_internal(barrier.image.texture)->resource.Get(); - barrierdesc.Transition.StateBefore = _ConvertImageLayout(barrier.image.layout_before); - barrierdesc.Transition.StateAfter = _ConvertImageLayout(barrier.image.layout_after); + barrierdesc.Transition.StateBefore = _ParseResourceState(barrier.image.layout_before); + barrierdesc.Transition.StateAfter = _ParseResourceState(barrier.image.layout_after); if (barrier.image.mip >= 0 || barrier.image.slice >= 0) { barrierdesc.Transition.Subresource = D3D12CalcSubresource( @@ -6485,45 +6118,35 @@ using namespace DX12_Internal; barrierdesc.Type = D3D12_RESOURCE_BARRIER_TYPE_TRANSITION; barrierdesc.Flags = D3D12_RESOURCE_BARRIER_FLAG_NONE; barrierdesc.Transition.pResource = to_internal(barrier.buffer.buffer)->resource.Get(); - barrierdesc.Transition.StateBefore = _ConvertBufferState(barrier.buffer.state_before); - barrierdesc.Transition.StateAfter = _ConvertBufferState(barrier.buffer.state_after); + barrierdesc.Transition.StateBefore = _ParseResourceState(barrier.buffer.state_before); + barrierdesc.Transition.StateAfter = _ParseResourceState(barrier.buffer.state_after); barrierdesc.Transition.Subresource = D3D12_RESOURCE_BARRIER_ALL_SUBRESOURCES; } break; } - // Try to detect redundant barriers: - bool found = false; - for (auto& x : barrierdescs) + if (barrierdesc.Type == D3D12_RESOURCE_BARRIER_TYPE_TRANSITION && + cmd_meta[cmd].queue > QUEUE_GRAPHICS) { - if (x.Type == barrierdesc.Type && x.Flags == barrierdesc.Flags) - { - switch (x.Type) - { - default: - case D3D12_RESOURCE_BARRIER_TYPE_TRANSITION: - if (x.Transition.pResource == barrierdesc.Transition.pResource && - x.Transition.Subresource == barrierdesc.Transition.Subresource) - { - found = true; - x.Transition.StateAfter = barrierdesc.Transition.StateAfter; - } - break; - } - } - if (found) - break; - } - if (!found) - { - barrierdescs.push_back(barrierdesc); + // Only graphics queue can do pixel shader state: + barrierdesc.Transition.StateBefore &= ~D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE; + barrierdesc.Transition.StateAfter &= ~D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE; } + + barrierdescs.push_back(barrierdesc); + } + + if (!barrierdescs.empty()) + { + GetCommandList(cmd)->ResourceBarrier( + (UINT)barrierdescs.size(), + barrierdescs.data() + ); + barrierdescs.clear(); } } void GraphicsDevice_DX12::BuildRaytracingAccelerationStructure(const RaytracingAccelerationStructure* dst, CommandList cmd, const RaytracingAccelerationStructure* src) { - barrier_flush(cmd); - auto dst_internal = to_internal(dst); D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_DESC desc = {}; @@ -6664,24 +6287,6 @@ using namespace DX12_Internal; pushconstants[cmd].size = size; } - GraphicsDevice::GPUAllocation GraphicsDevice_DX12::AllocateGPU(size_t dataSize, CommandList cmd) - { - GPUAllocation result; - if (dataSize == 0) - { - return result; - } - - FrameResources::ResourceFrameAllocator& allocator = GetFrameResources().resourceBuffer[cmd]; - uint8_t* dest = allocator.allocate(dataSize, D3D12_CONSTANT_BUFFER_DATA_PLACEMENT_ALIGNMENT); - assert(dest != nullptr); - - result.buffer = &allocator.buffer; - result.offset = (uint32_t)allocator.calculateOffset(dest); - result.data = (void*)dest; - return result; - } - void GraphicsDevice_DX12::EventBegin(const char* name, CommandList cmd) { wchar_t text[128]; diff --git a/WickedEngine/wiGraphicsDevice_DX12.h b/WickedEngine/wiGraphicsDevice_DX12.h index adaedf978..6a8549e97 100644 --- a/WickedEngine/wiGraphicsDevice_DX12.h +++ b/WickedEngine/wiGraphicsDevice_DX12.h @@ -8,7 +8,6 @@ #ifdef WICKEDENGINE_BUILD_DX12 #include "wiGraphicsDevice.h" -#include "wiGraphicsDevice_SharedInternals.h" #include "wiMath.h" #include @@ -105,25 +104,9 @@ namespace wiGraphics { Microsoft::WRL::ComPtr fence[QUEUE_COUNT]; Microsoft::WRL::ComPtr commandAllocators[COMMANDLIST_COUNT][QUEUE_COUNT]; - - struct ResourceFrameAllocator - { - GraphicsDevice_DX12* device = nullptr; - GPUBuffer buffer; - uint8_t* dataBegin = nullptr; - uint8_t* dataCur = nullptr; - uint8_t* dataEnd = nullptr; - - void init(GraphicsDevice_DX12* device, size_t size); - - uint8_t* allocate(size_t dataSize, size_t alignment); - void clear(); - uint64_t calculateOffset(uint8_t* address); - }; - ResourceFrameAllocator resourceBuffer[COMMANDLIST_COUNT]; }; FrameResources frames[BUFFERCOUNT]; - FrameResources& GetFrameResources() { return frames[GetFrameCount() % BUFFERCOUNT]; } + FrameResources& GetFrameResources() { return frames[GetBufferIndex()]; } struct CommandListMetadata { @@ -145,15 +128,15 @@ namespace wiGraphics bool dirty_res = false; bool dirty_sam = false; - const GPUBuffer* CBV[GPU_RESOURCE_HEAP_CBV_COUNT]; - const GPUResource* SRV[GPU_RESOURCE_HEAP_SRV_COUNT]; - int SRV_index[GPU_RESOURCE_HEAP_SRV_COUNT]; - const GPUResource* UAV[GPU_RESOURCE_HEAP_UAV_COUNT]; - int UAV_index[GPU_RESOURCE_HEAP_UAV_COUNT]; - const Sampler* SAM[GPU_SAMPLER_HEAP_COUNT]; + GPUBuffer CBV[DESCRIPTORBINDER_CBV_COUNT]; + uint64_t CBV_offset[DESCRIPTORBINDER_CBV_COUNT]; + GPUResource SRV[DESCRIPTORBINDER_SRV_COUNT]; + int SRV_index[DESCRIPTORBINDER_SRV_COUNT]; + GPUResource UAV[DESCRIPTORBINDER_UAV_COUNT]; + int UAV_index[DESCRIPTORBINDER_UAV_COUNT]; + Sampler SAM[DESCRIPTORBINDER_SAMPLER_COUNT]; - uint32_t dirty_root_cbvs_gfx = 0; // bitmask - uint32_t dirty_root_cbvs_compute = 0; // bitmask + uint32_t dirty_root_cbvs = 0; // bitmask struct DescriptorHandles { @@ -197,19 +180,9 @@ namespace wiGraphics bool dirty_pso[COMMANDLIST_COUNT] = {}; void pso_validate(CommandList cmd); - void query_flush(CommandList cmd); - void barrier_flush(CommandList cmd); void predraw(CommandList cmd); void predispatch(CommandList cmd); - struct QueryResolver - { - const GPUQueryHeap* heap = nullptr; - uint32_t index = 0; - uint32_t count = 0; - }; - std::vector query_resolves[COMMANDLIST_COUNT]; - std::atomic cmd_count{ 0 }; public: @@ -237,10 +210,6 @@ namespace wiGraphics void WriteTopLevelAccelerationStructureInstance(const RaytracingAccelerationStructureDesc::TopLevel::Instance* instance, void* dest) const override; void WriteShaderIdentifier(const RaytracingPipelineState* rtpso, uint32_t group_index, void* dest) const override; - void Map(const GPUResource* resource, Mapping* mapping) const override; - void Unmap(const GPUResource* resource) const override; - void QueryRead(const GPUQueryHeap* heap, uint32_t index, uint32_t count, uint64_t* results) const override; - void SetCommonSampler(const StaticSampler* sam) override; void SetName(GPUResource* pResource, const char* name) override; @@ -263,14 +232,12 @@ namespace wiGraphics void RenderPassEnd(CommandList cmd) override; void BindScissorRects(uint32_t numRects, const Rect* rects, CommandList cmd) override; void BindViewports(uint32_t NumViewports, const Viewport* pViewports, CommandList cmd) override; - void BindResource(SHADERSTAGE stage, const GPUResource* resource, uint32_t slot, CommandList cmd, int subresource = -1) override; - void BindResources(SHADERSTAGE stage, const GPUResource *const* resources, uint32_t slot, uint32_t count, CommandList cmd) override; - void BindUAV(SHADERSTAGE stage, const GPUResource* resource, uint32_t slot, CommandList cmd, int subresource = -1) override; - void BindUAVs(SHADERSTAGE stage, const GPUResource *const* resources, uint32_t slot, uint32_t count, CommandList cmd) override; - void UnbindResources(uint32_t slot, uint32_t num, CommandList cmd) override; - void UnbindUAVs(uint32_t slot, uint32_t num, CommandList cmd) override; - void BindSampler(SHADERSTAGE stage, const Sampler* sampler, uint32_t slot, CommandList cmd) override; - void BindConstantBuffer(SHADERSTAGE stage, const GPUBuffer* buffer, uint32_t slot, CommandList cmd) override; + void BindResource(const GPUResource* resource, uint32_t slot, CommandList cmd, int subresource = -1) override; + void BindResources(const GPUResource *const* resources, uint32_t slot, uint32_t count, CommandList cmd) override; + void BindUAV(const GPUResource* resource, uint32_t slot, CommandList cmd, int subresource = -1) override; + void BindUAVs(const GPUResource *const* resources, uint32_t slot, uint32_t count, CommandList cmd) override; + void BindSampler(const Sampler* sampler, uint32_t slot, CommandList cmd) override; + void BindConstantBuffer(const GPUBuffer* buffer, uint32_t slot, CommandList cmd, uint64_t offset = 0ull) override; void BindVertexBuffers(const GPUBuffer *const* vertexBuffers, uint32_t slot, uint32_t count, const uint32_t* strides, const uint32_t* offsets, CommandList cmd) override; void BindIndexBuffer(const GPUBuffer* indexBuffer, const INDEXBUFFER_FORMAT format, uint32_t offset, CommandList cmd) override; void BindStencilRef(uint32_t value, CommandList cmd) override; @@ -289,18 +256,17 @@ namespace wiGraphics void DispatchMesh(uint32_t threadGroupCountX, uint32_t threadGroupCountY, uint32_t threadGroupCountZ, CommandList cmd) override; void DispatchMeshIndirect(const GPUBuffer* args, uint32_t args_offset, CommandList cmd) override; void CopyResource(const GPUResource* pDst, const GPUResource* pSrc, CommandList cmd) override; - void UpdateBuffer(const GPUBuffer* buffer, const void* data, CommandList cmd, int dataSize = -1) override; + void CopyBuffer(const GPUBuffer* pDst, uint64_t dst_offset, const GPUBuffer* pSrc, uint64_t src_offset, uint64_t size, CommandList cmd) override; void QueryBegin(const GPUQueryHeap* heap, uint32_t index, CommandList cmd) override; void QueryEnd(const GPUQueryHeap* heap, uint32_t index, CommandList cmd) override; - void QueryResolve(const GPUQueryHeap* heap, uint32_t index, uint32_t count, CommandList cmd) override; + void QueryResolve(const GPUQueryHeap* heap, uint32_t index, uint32_t count, const GPUBuffer* dest, uint64_t dest_offset, CommandList cmd) override; + void QueryReset(const GPUQueryHeap* heap, uint32_t index, uint32_t count, CommandList cmd) override {} void Barrier(const GPUBarrier* barriers, uint32_t numBarriers, CommandList cmd) override; void BuildRaytracingAccelerationStructure(const RaytracingAccelerationStructure* dst, CommandList cmd, const RaytracingAccelerationStructure* src = nullptr) override; void BindRaytracingPipelineState(const RaytracingPipelineState* rtpso, CommandList cmd) override; void DispatchRays(const DispatchRaysDesc* desc, CommandList cmd) override; void PushConstants(const void* data, uint32_t size, CommandList cmd) override; - GPUAllocation AllocateGPU(size_t dataSize, CommandList cmd) override; - void EventBegin(const char* name, CommandList cmd) override; void EventEnd(CommandList cmd) override; void SetMarker(const char* name, CommandList cmd) override; diff --git a/WickedEngine/wiGraphicsDevice_SharedInternals.h b/WickedEngine/wiGraphicsDevice_SharedInternals.h deleted file mode 100644 index f4d91d4be..000000000 --- a/WickedEngine/wiGraphicsDevice_SharedInternals.h +++ /dev/null @@ -1,10 +0,0 @@ -#ifndef WI_GRAPHICSDEVICE_SHAREDINTERNALS_H -#define WI_GRAPHICSDEVICE_SHAREDINTERNALS_H - -// Descriptor binding counts: -#define GPU_RESOURCE_HEAP_CBV_COUNT 15 -#define GPU_RESOURCE_HEAP_SRV_COUNT 64 -#define GPU_RESOURCE_HEAP_UAV_COUNT 16 -#define GPU_SAMPLER_HEAP_COUNT 16 - -#endif // WI_GRAPHICSDEVICE_SHAREDINTERNALS_H diff --git a/WickedEngine/wiGraphicsDevice_Vulkan.cpp b/WickedEngine/wiGraphicsDevice_Vulkan.cpp index 29e7e31b4..67a34dd27 100644 --- a/WickedEngine/wiGraphicsDevice_Vulkan.cpp +++ b/WickedEngine/wiGraphicsDevice_Vulkan.cpp @@ -7,7 +7,6 @@ #include "Utility/spirv_reflect.h" -#include "wiGraphicsDevice_SharedInternals.h" #include "wiHelper.h" #include "wiBackLog.h" #include "wiVersion.h" @@ -399,28 +398,28 @@ namespace Vulkan_Internal } return VK_STENCIL_OP_KEEP; } - constexpr VkImageLayout _ConvertImageLayout(IMAGE_LAYOUT value) + constexpr VkImageLayout _ConvertImageLayout(RESOURCE_STATE value) { switch (value) { - case wiGraphics::IMAGE_LAYOUT_UNDEFINED: + case wiGraphics::RESOURCE_STATE_UNDEFINED: return VK_IMAGE_LAYOUT_UNDEFINED; - case wiGraphics::IMAGE_LAYOUT_RENDERTARGET: + case wiGraphics::RESOURCE_STATE_RENDERTARGET: return VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL; - case wiGraphics::IMAGE_LAYOUT_DEPTHSTENCIL: + case wiGraphics::RESOURCE_STATE_DEPTHSTENCIL: return VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL; - case wiGraphics::IMAGE_LAYOUT_DEPTHSTENCIL_READONLY: + case wiGraphics::RESOURCE_STATE_DEPTHSTENCIL_READONLY: return VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL; - case wiGraphics::IMAGE_LAYOUT_SHADER_RESOURCE: - case wiGraphics::IMAGE_LAYOUT_SHADER_RESOURCE_COMPUTE: + case wiGraphics::RESOURCE_STATE_SHADER_RESOURCE: + case wiGraphics::RESOURCE_STATE_SHADER_RESOURCE_COMPUTE: return VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; - case wiGraphics::IMAGE_LAYOUT_UNORDERED_ACCESS: + case wiGraphics::RESOURCE_STATE_UNORDERED_ACCESS: return VK_IMAGE_LAYOUT_GENERAL; - case wiGraphics::IMAGE_LAYOUT_COPY_SRC: + case wiGraphics::RESOURCE_STATE_COPY_SRC: return VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL; - case wiGraphics::IMAGE_LAYOUT_COPY_DST: + case wiGraphics::RESOURCE_STATE_COPY_DST: return VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL; - case wiGraphics::IMAGE_LAYOUT_SHADING_RATE_SOURCE: + case wiGraphics::RESOURCE_STATE_SHADING_RATE_SOURCE: return VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR; } return VK_IMAGE_LAYOUT_UNDEFINED; @@ -451,82 +450,66 @@ namespace Vulkan_Internal } - inline VkAccessFlags _ParseImageLayout(IMAGE_LAYOUT value) + inline VkAccessFlags _ParseResourceState(RESOURCE_STATE value) { VkAccessFlags flags = 0; - switch (value) + if (value & RESOURCE_STATE_SHADER_RESOURCE) { - case wiGraphics::IMAGE_LAYOUT_UNDEFINED: - break; - case wiGraphics::IMAGE_LAYOUT_RENDERTARGET: - flags |= VK_ACCESS_SHADER_WRITE_BIT; - break; - case wiGraphics::IMAGE_LAYOUT_DEPTHSTENCIL: - flags |= VK_ACCESS_SHADER_WRITE_BIT; - break; - case wiGraphics::IMAGE_LAYOUT_DEPTHSTENCIL_READONLY: flags |= VK_ACCESS_SHADER_READ_BIT; - break; - case wiGraphics::IMAGE_LAYOUT_SHADER_RESOURCE: - case wiGraphics::IMAGE_LAYOUT_SHADER_RESOURCE_COMPUTE: + flags |= VK_ACCESS_UNIFORM_READ_BIT; + } + if (value & RESOURCE_STATE_SHADER_RESOURCE_COMPUTE) + { flags |= VK_ACCESS_SHADER_READ_BIT; - break; - case wiGraphics::IMAGE_LAYOUT_UNORDERED_ACCESS: + flags |= VK_ACCESS_UNIFORM_READ_BIT; + } + if (value & RESOURCE_STATE_UNORDERED_ACCESS) + { flags |= VK_ACCESS_SHADER_READ_BIT; flags |= VK_ACCESS_SHADER_WRITE_BIT; - break; - case wiGraphics::IMAGE_LAYOUT_COPY_SRC: + } + if (value & RESOURCE_STATE_COPY_SRC) + { flags |= VK_ACCESS_TRANSFER_READ_BIT; - break; - case wiGraphics::IMAGE_LAYOUT_COPY_DST: + } + if (value & RESOURCE_STATE_COPY_DST) + { flags |= VK_ACCESS_TRANSFER_WRITE_BIT; - break; } - return flags; - } - inline VkAccessFlags _ParseBufferState(BUFFER_STATE value) - { - VkAccessFlags flags = 0; - - switch (value) + if (value & RESOURCE_STATE_RENDERTARGET) + { + flags |= VK_ACCESS_SHADER_WRITE_BIT; + } + if (value & RESOURCE_STATE_DEPTHSTENCIL) + { + flags |= VK_ACCESS_SHADER_WRITE_BIT; + } + if (value & RESOURCE_STATE_DEPTHSTENCIL_READONLY) + { + flags |= VK_ACCESS_SHADER_READ_BIT; + } + + if (value & RESOURCE_STATE_VERTEX_BUFFER) { - case wiGraphics::BUFFER_STATE_UNDEFINED: - break; - case wiGraphics::BUFFER_STATE_VERTEX_BUFFER: flags |= VK_ACCESS_SHADER_READ_BIT; flags |= VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT; - break; - case wiGraphics::BUFFER_STATE_INDEX_BUFFER: + } + if (value & RESOURCE_STATE_INDEX_BUFFER) + { flags |= VK_ACCESS_SHADER_READ_BIT; flags |= VK_ACCESS_INDEX_READ_BIT; - break; - case wiGraphics::BUFFER_STATE_CONSTANT_BUFFER: + } + if (value & RESOURCE_STATE_CONSTANT_BUFFER) + { flags |= VK_ACCESS_SHADER_READ_BIT; flags |= VK_ACCESS_UNIFORM_READ_BIT; - break; - case wiGraphics::BUFFER_STATE_INDIRECT_ARGUMENT: + } + if (value & RESOURCE_STATE_INDIRECT_ARGUMENT) + { flags |= VK_ACCESS_SHADER_READ_BIT; flags |= VK_ACCESS_INDIRECT_COMMAND_READ_BIT; - break; - case wiGraphics::BUFFER_STATE_SHADER_RESOURCE: - case wiGraphics::BUFFER_STATE_SHADER_RESOURCE_COMPUTE: - flags |= VK_ACCESS_SHADER_READ_BIT; - flags |= VK_ACCESS_UNIFORM_READ_BIT; - break; - case wiGraphics::BUFFER_STATE_UNORDERED_ACCESS: - flags |= VK_ACCESS_SHADER_READ_BIT; - flags |= VK_ACCESS_SHADER_WRITE_BIT; - break; - case wiGraphics::BUFFER_STATE_COPY_SRC: - flags |= VK_ACCESS_TRANSFER_READ_BIT; - break; - case wiGraphics::BUFFER_STATE_COPY_DST: - flags |= VK_ACCESS_TRANSFER_WRITE_BIT; - break; - default: - break; } return flags; @@ -630,25 +613,12 @@ namespace Vulkan_Internal } - // Memory tools: - - inline size_t Align(size_t uLocation, size_t uAlign) - { - if ((0 == uAlign) || (uAlign & (uAlign - 1))) - { - assert(0); - } - - return ((uLocation + (uAlign - 1)) & ~(uAlign - 1)); - } - struct Buffer_Vulkan { std::shared_ptr allocationhandler; VmaAllocation allocation = nullptr; VkBuffer resource = VK_NULL_HANDLE; - int cbv_index = -1; VkBufferView srv = VK_NULL_HANDLE; int srv_index = -1; VkBufferView uav = VK_NULL_HANDLE; @@ -660,8 +630,6 @@ namespace Vulkan_Internal VkDeviceAddress address = 0; bool is_typedbuffer = false; - GraphicsDevice::GPUAllocation dynamic[COMMANDLIST_COUNT]; - ~Buffer_Vulkan() { if (allocationhandler == nullptr) @@ -679,7 +647,6 @@ namespace Vulkan_Internal { allocationhandler->destroyer_bufferviews.push_back(std::make_pair(x, framecount)); } - if (cbv_index >= 0) allocationhandler->destroyer_bindlessUniformBuffers.push_back(std::make_pair(cbv_index, framecount)); if (is_typedbuffer) { if (srv_index >= 0) allocationhandler->destroyer_bindlessUniformTexelBuffers.push_back(std::make_pair(srv_index, framecount)); @@ -1083,7 +1050,7 @@ using namespace Vulkan_Internal; { GPUBufferDesc uploaddesc; uploaddesc.ByteWidth = wiMath::GetNextPowerOfTwo(staging_size); - uploaddesc.Usage = USAGE_STAGING; + uploaddesc.Usage = USAGE_UPLOAD; bool upload_success = device->CreateBuffer(&uploaddesc, nullptr, &cmd.uploadbuffer); assert(upload_success); @@ -1172,99 +1139,6 @@ using namespace Vulkan_Internal; return value; } - void GraphicsDevice_Vulkan::FrameResources::ResourceFrameAllocator::init(GraphicsDevice_Vulkan* device, size_t size) - { - this->device = device; - auto internal_state = std::make_shared(); - internal_state->allocationhandler = device->allocationhandler; - buffer.internal_state = internal_state; - - VkBufferCreateInfo bufferInfo = {}; - bufferInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO; - bufferInfo.size = size; - bufferInfo.usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT; - bufferInfo.usage |= VK_BUFFER_USAGE_VERTEX_BUFFER_BIT; - bufferInfo.usage |= VK_BUFFER_USAGE_INDEX_BUFFER_BIT; - bufferInfo.usage |= VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT; - bufferInfo.usage |= VK_BUFFER_USAGE_STORAGE_BUFFER_BIT; - if (device->features_1_2.bufferDeviceAddress == VK_TRUE) - { - bufferInfo.usage |= VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT; - } - bufferInfo.flags = 0; - - VkResult res; - - VmaAllocationCreateInfo allocInfo = {}; - allocInfo.usage = VMA_MEMORY_USAGE_CPU_TO_GPU; - allocInfo.flags = VMA_ALLOCATION_CREATE_MAPPED_BIT; - - res = vmaCreateBuffer(device->allocationhandler->allocator, &bufferInfo, &allocInfo, &internal_state->resource, &internal_state->allocation, nullptr); - assert(res == VK_SUCCESS); - - if (bufferInfo.usage & VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT) - { - VkBufferDeviceAddressInfo info = {}; - info.sType = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO; - info.buffer = internal_state->resource; - internal_state->address = vkGetBufferDeviceAddress(device->device, &info); - } - - void* pData = internal_state->allocation->GetMappedData(); - dataCur = dataBegin = reinterpret_cast(pData); - dataEnd = dataBegin + size; - - // Because the "buffer" is created by hand in this, fill the desc to indicate how it can be used: - this->buffer.type = GPUResource::GPU_RESOURCE_TYPE::BUFFER; - this->buffer.desc.ByteWidth = (uint32_t)((size_t)dataEnd - (size_t)dataBegin); - this->buffer.desc.Usage = USAGE_DYNAMIC; - this->buffer.desc.BindFlags = BIND_VERTEX_BUFFER | BIND_INDEX_BUFFER | BIND_SHADER_RESOURCE; - this->buffer.desc.MiscFlags = RESOURCE_MISC_BUFFER_ALLOW_RAW_VIEWS; - - int index = device->allocationhandler->bindlessStorageBuffers.allocate(); - if (index >= 0) - { - VkDescriptorBufferInfo bufferInfo = {}; - bufferInfo.buffer = internal_state->resource; - bufferInfo.offset = 0; - bufferInfo.range = (VkDeviceSize)size; - VkWriteDescriptorSet write = {}; - write.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; - write.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER; - write.dstBinding = 0; - write.dstArrayElement = index; - write.descriptorCount = 1; - write.dstSet = device->allocationhandler->bindlessStorageBuffers.descriptorSet; - write.pBufferInfo = &bufferInfo; - vkUpdateDescriptorSets(device->device, 1, &write, 0, nullptr); - } - internal_state->srv_index = index; - } - uint8_t* GraphicsDevice_Vulkan::FrameResources::ResourceFrameAllocator::allocate(size_t dataSize, size_t alignment) - { - dataCur = reinterpret_cast(Align(reinterpret_cast(dataCur), alignment)); - - if (dataCur + dataSize > dataEnd) - { - init(device, ((size_t)dataEnd + dataSize - (size_t)dataBegin) * 2); - } - - uint8_t* retVal = dataCur; - - dataCur += dataSize; - - return retVal; - } - void GraphicsDevice_Vulkan::FrameResources::ResourceFrameAllocator::clear() - { - dataCur = dataBegin; - } - uint64_t GraphicsDevice_Vulkan::FrameResources::ResourceFrameAllocator::calculateOffset(uint8_t* address) - { - assert(address >= dataBegin && address < dataEnd); - return static_cast(address - dataBegin); - } - void GraphicsDevice_Vulkan::FrameResources::DescriptorBinder::init(GraphicsDevice_Vulkan* device) { this->device = device; @@ -1283,41 +1157,41 @@ using namespace Vulkan_Internal; uint32_t count = 0; poolSizes[0].type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER; - poolSizes[0].descriptorCount = GPU_RESOURCE_HEAP_CBV_COUNT * poolSize; + poolSizes[0].descriptorCount = DESCRIPTORBINDER_CBV_COUNT * poolSize; count++; poolSizes[1].type = VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE; - poolSizes[1].descriptorCount = GPU_RESOURCE_HEAP_SRV_COUNT * poolSize; + poolSizes[1].descriptorCount = DESCRIPTORBINDER_SRV_COUNT * poolSize; count++; poolSizes[2].type = VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER; - poolSizes[2].descriptorCount = GPU_RESOURCE_HEAP_SRV_COUNT * poolSize; + poolSizes[2].descriptorCount = DESCRIPTORBINDER_SRV_COUNT * poolSize; count++; poolSizes[3].type = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER; - poolSizes[3].descriptorCount = GPU_RESOURCE_HEAP_SRV_COUNT * poolSize; + poolSizes[3].descriptorCount = DESCRIPTORBINDER_SRV_COUNT * poolSize; count++; poolSizes[4].type = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE; - poolSizes[4].descriptorCount = GPU_RESOURCE_HEAP_UAV_COUNT * poolSize; + poolSizes[4].descriptorCount = DESCRIPTORBINDER_UAV_COUNT * poolSize; count++; poolSizes[5].type = VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER; - poolSizes[5].descriptorCount = GPU_RESOURCE_HEAP_UAV_COUNT * poolSize; + poolSizes[5].descriptorCount = DESCRIPTORBINDER_UAV_COUNT * poolSize; count++; poolSizes[6].type = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER; - poolSizes[6].descriptorCount = GPU_RESOURCE_HEAP_UAV_COUNT * poolSize; + poolSizes[6].descriptorCount = DESCRIPTORBINDER_UAV_COUNT * poolSize; count++; poolSizes[7].type = VK_DESCRIPTOR_TYPE_SAMPLER; - poolSizes[7].descriptorCount = GPU_SAMPLER_HEAP_COUNT * poolSize; + poolSizes[7].descriptorCount = DESCRIPTORBINDER_SAMPLER_COUNT * poolSize; count++; - if (device->CheckCapability(GRAPHICSDEVICE_CAPABILITY_RAYTRACING_PIPELINE) || device->CheckCapability(GRAPHICSDEVICE_CAPABILITY_RAYTRACING_INLINE)) + if (device->CheckCapability(GRAPHICSDEVICE_CAPABILITY_RAYTRACING)) { poolSizes[8].type = VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR; - poolSizes[8].descriptorCount = GPU_RESOURCE_HEAP_SRV_COUNT * poolSize; + poolSizes[8].descriptorCount = DESCRIPTORBINDER_SRV_COUNT * poolSize; count++; } @@ -1331,6 +1205,9 @@ using namespace Vulkan_Internal; res = vkCreateDescriptorPool(device->device, &poolInfo, nullptr, &descriptorPool); assert(res == VK_SUCCESS); + // WARNING: MUST NOT CALL reset() HERE! + // This is because init can be called mid-frame when there is allocation error, but the bindings must be retained! + } void GraphicsDevice_Vulkan::FrameResources::DescriptorBinder::destroy() { @@ -1353,6 +1230,7 @@ using namespace Vulkan_Internal; } memset(CBV, 0, sizeof(CBV)); + memset(CBV_offset, 0, sizeof(CBV_offset)); memset(SRV, 0, sizeof(SRV)); memset(SRV_index, -1, sizeof(SRV_index)); memset(UAV, 0, sizeof(UAV)); @@ -1443,14 +1321,14 @@ using namespace Vulkan_Internal; imageInfos.back() = {}; const uint32_t original_binding = unrolled_binding - VULKAN_BINDING_SHIFT_S; - const Sampler* sampler = SAM[original_binding]; - if (sampler == nullptr || !sampler->IsValid()) + const Sampler& sampler = SAM[original_binding]; + if (!sampler.IsValid()) { imageInfos.back().sampler = device->nullSampler; } else { - imageInfos.back().sampler = to_internal(sampler)->resource; + imageInfos.back().sampler = to_internal(&sampler)->resource; } } break; @@ -1462,8 +1340,8 @@ using namespace Vulkan_Internal; imageInfos.back() = {}; const uint32_t original_binding = unrolled_binding - VULKAN_BINDING_SHIFT_T; - const GPUResource* resource = SRV[original_binding]; - if (resource == nullptr || !resource->IsValid() || !resource->IsTexture()) + const GPUResource& resource = SRV[original_binding]; + if (!resource.IsValid() || !resource.IsTexture()) { switch (viewtype) { @@ -1498,14 +1376,14 @@ using namespace Vulkan_Internal; else { int subresource = SRV_index[original_binding]; - const Texture* texture = (const Texture*)resource; + auto texture_internal = to_internal((const Texture*)&resource); if (subresource >= 0) { - imageInfos.back().imageView = to_internal(texture)->subresources_srv[subresource]; + imageInfos.back().imageView = texture_internal->subresources_srv[subresource]; } else { - imageInfos.back().imageView = to_internal(texture)->srv; + imageInfos.back().imageView = texture_internal->srv; } imageInfos.back().imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; @@ -1521,8 +1399,8 @@ using namespace Vulkan_Internal; imageInfos.back().imageLayout = VK_IMAGE_LAYOUT_GENERAL; const uint32_t original_binding = unrolled_binding - VULKAN_BINDING_SHIFT_U; - const GPUResource* resource = UAV[original_binding]; - if (resource == nullptr || !resource->IsValid() || !resource->IsTexture()) + const GPUResource& resource = UAV[original_binding]; + if (!resource.IsValid() || !resource.IsTexture()) { switch (viewtype) { @@ -1556,14 +1434,14 @@ using namespace Vulkan_Internal; else { int subresource = UAV_index[original_binding]; - const Texture* texture = (const Texture*)resource; + auto texture_internal = to_internal((const Texture*)&resource); if (subresource >= 0) { - imageInfos.back().imageView = to_internal(texture)->subresources_uav[subresource]; + imageInfos.back().imageView = texture_internal->subresources_uav[subresource]; } else { - imageInfos.back().imageView = to_internal(texture)->uav; + imageInfos.back().imageView = texture_internal->uav; } } } @@ -1576,28 +1454,20 @@ using namespace Vulkan_Internal; bufferInfos.back() = {}; const uint32_t original_binding = unrolled_binding - VULKAN_BINDING_SHIFT_B; - const GPUBuffer* buffer = CBV[original_binding]; - if (buffer == nullptr || !buffer->IsValid()) + const GPUBuffer& buffer = CBV[original_binding]; + uint64_t offset = CBV_offset[original_binding]; + + if (!buffer.IsValid()) { bufferInfos.back().buffer = device->nullBuffer; bufferInfos.back().range = VK_WHOLE_SIZE; } else { - auto internal_state = to_internal(buffer); - if (buffer->desc.Usage == USAGE_DYNAMIC) - { - const GPUAllocation& allocation = internal_state->dynamic[cmd]; - bufferInfos.back().buffer = to_internal(allocation.buffer)->resource; - bufferInfos.back().offset = allocation.offset; - bufferInfos.back().range = buffer->desc.ByteWidth; - } - else - { - bufferInfos.back().buffer = internal_state->resource; - bufferInfos.back().offset = 0; - bufferInfos.back().range = buffer->desc.ByteWidth; - } + auto internal_state = to_internal(&buffer); + bufferInfos.back().buffer = internal_state->resource; + bufferInfos.back().offset = offset; + bufferInfos.back().range = (VkDeviceSize)std::min(buffer.desc.ByteWidth - offset, (uint64_t)device->properties2.properties.limits.maxUniformBufferRange); } } break; @@ -1609,22 +1479,22 @@ using namespace Vulkan_Internal; texelBufferViews.back() = {}; const uint32_t original_binding = unrolled_binding - VULKAN_BINDING_SHIFT_T; - const GPUResource* resource = SRV[original_binding]; - if (resource == nullptr || !resource->IsValid() || !resource->IsBuffer()) + const GPUResource& resource = SRV[original_binding]; + if (!resource.IsValid() || !resource.IsBuffer()) { texelBufferViews.back() = device->nullBufferView; } else { int subresource = SRV_index[original_binding]; - const GPUBuffer* buffer = (const GPUBuffer*)resource; + auto buffer_internal = to_internal((const GPUBuffer*)&resource); if (subresource >= 0) { - texelBufferViews.back() = to_internal(buffer)->subresources_srv[subresource]; + texelBufferViews.back() = buffer_internal->subresources_srv[subresource]; } else { - texelBufferViews.back() = to_internal(buffer)->srv; + texelBufferViews.back() = buffer_internal->srv; } } } @@ -1637,22 +1507,22 @@ using namespace Vulkan_Internal; texelBufferViews.back() = {}; const uint32_t original_binding = unrolled_binding - VULKAN_BINDING_SHIFT_U; - const GPUResource* resource = UAV[original_binding]; - if (resource == nullptr || !resource->IsValid() || !resource->IsBuffer()) + const GPUResource& resource = UAV[original_binding]; + if (!resource.IsValid() || !resource.IsBuffer()) { texelBufferViews.back() = device->nullBufferView; } else { int subresource = UAV_index[original_binding]; - const GPUBuffer* buffer = (const GPUBuffer*)resource; + auto buffer_internal = to_internal((const GPUBuffer*)&resource); if (subresource >= 0) { - texelBufferViews.back() = to_internal(buffer)->subresources_uav[subresource]; + texelBufferViews.back() = buffer_internal->subresources_uav[subresource]; } else { - texelBufferViews.back() = to_internal(buffer)->uav; + texelBufferViews.back() = buffer_internal->uav; } } } @@ -1668,8 +1538,8 @@ using namespace Vulkan_Internal; { // SRV const uint32_t original_binding = unrolled_binding - VULKAN_BINDING_SHIFT_T; - const GPUResource* resource = SRV[original_binding]; - if (resource == nullptr || !resource->IsValid() || !resource->IsBuffer()) + const GPUResource& resource = SRV[original_binding]; + if (!resource.IsValid() || !resource.IsBuffer()) { bufferInfos.back().buffer = device->nullBuffer; bufferInfos.back().range = VK_WHOLE_SIZE; @@ -1677,17 +1547,17 @@ using namespace Vulkan_Internal; else { int subresource = SRV_index[original_binding]; - const GPUBuffer* buffer = (const GPUBuffer*)resource; - bufferInfos.back().buffer = to_internal(buffer)->resource; - bufferInfos.back().range = buffer->desc.ByteWidth; + auto buffer_internal = to_internal((const GPUBuffer*)&resource); + bufferInfos.back().buffer = buffer_internal->resource; + bufferInfos.back().range = VK_WHOLE_SIZE; } } else { // UAV const uint32_t original_binding = unrolled_binding - VULKAN_BINDING_SHIFT_U; - const GPUResource* resource = UAV[original_binding]; - if (resource == nullptr || !resource->IsValid() || !resource->IsBuffer()) + const GPUResource& resource = UAV[original_binding]; + if (!resource.IsValid() || !resource.IsBuffer()) { bufferInfos.back().buffer = device->nullBuffer; bufferInfos.back().range = VK_WHOLE_SIZE; @@ -1695,9 +1565,9 @@ using namespace Vulkan_Internal; else { int subresource = UAV_index[original_binding]; - const GPUBuffer* buffer = (const GPUBuffer*)resource; - bufferInfos.back().buffer = to_internal(buffer)->resource; - bufferInfos.back().range = buffer->desc.ByteWidth; + auto buffer_internal = to_internal((const GPUBuffer*)&resource); + bufferInfos.back().buffer = buffer_internal->resource; + bufferInfos.back().range = VK_WHOLE_SIZE; } } } @@ -1712,15 +1582,15 @@ using namespace Vulkan_Internal; accelerationStructureViews.back().accelerationStructureCount = 1; const uint32_t original_binding = unrolled_binding - VULKAN_BINDING_SHIFT_T; - const GPUResource* resource = SRV[original_binding]; - if (resource == nullptr || !resource->IsValid() || !resource->IsAccelerationStructure()) + const GPUResource& resource = SRV[original_binding]; + if (!resource.IsValid() || !resource.IsAccelerationStructure()) { assert(0); // invalid acceleration structure! } else { - const RaytracingAccelerationStructure* as = (const RaytracingAccelerationStructure*)resource; - accelerationStructureViews.back().pAccelerationStructures = &to_internal(as)->resource; + auto as_internal = to_internal((const RaytracingAccelerationStructure*)&resource); + accelerationStructureViews.back().pAccelerationStructures = &as_internal->resource; } } break; @@ -1944,123 +1814,40 @@ using namespace Vulkan_Internal; vkCmdBindPipeline(GetCommandList(cmd), VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline); } - void GraphicsDevice_Vulkan::barrier_flush(CommandList cmd) - { - auto& memoryBarriers = frame_memoryBarriers[cmd]; - auto& imageBarriers = frame_imageBarriers[cmd]; - auto& bufferBarriers = frame_bufferBarriers[cmd]; - - if (!memoryBarriers.empty() || - !bufferBarriers.empty() || - !imageBarriers.empty() - ) - { - // Remove NOP barriers: - for (size_t i = 0; i < memoryBarriers.size(); ++i) - { - auto& barrier = memoryBarriers[i]; - if (barrier.srcAccessMask == barrier.dstAccessMask) - { - barrier = memoryBarriers.back(); - memoryBarriers.pop_back(); - i--; - } - } - for (size_t i = 0; i < bufferBarriers.size(); ++i) - { - auto& barrier = bufferBarriers[i]; - if (barrier.srcAccessMask == barrier.dstAccessMask) - { - barrier = bufferBarriers.back(); - bufferBarriers.pop_back(); - i--; - } - } - for (size_t i = 0; i < imageBarriers.size(); ++i) - { - auto& barrier = imageBarriers[i]; - if (barrier.oldLayout == barrier.newLayout) - { - barrier = imageBarriers.back(); - imageBarriers.pop_back(); - i--; - } - } - - if (!memoryBarriers.empty() || - !bufferBarriers.empty() || - !imageBarriers.empty() - ) - { - VkPipelineStageFlags srcStage = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT; - VkPipelineStageFlags dstStage = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT; - - if (CheckCapability(GRAPHICSDEVICE_CAPABILITY_RAYTRACING_PIPELINE) || CheckCapability(GRAPHICSDEVICE_CAPABILITY_RAYTRACING_INLINE)) - { - srcStage |= VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR | VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR; - dstStage |= VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR | VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR; - } - - vkCmdPipelineBarrier( - GetCommandList(cmd), - srcStage, - dstStage, - 0, - (uint32_t)memoryBarriers.size(), memoryBarriers.data(), - (uint32_t)bufferBarriers.size(), bufferBarriers.data(), - (uint32_t)imageBarriers.size(), imageBarriers.data() - ); - - memoryBarriers.clear(); - imageBarriers.clear(); - bufferBarriers.clear(); - } - } - } void GraphicsDevice_Vulkan::predraw(CommandList cmd) { pso_validate(cmd); GetFrameResources().descriptors[cmd].flush(true, cmd); - if (pushconstants[cmd].size > 0) + auto pso_internal = to_internal(active_pso[cmd]); + if (pso_internal->pushconstants.size > 0) { - auto pso_internal = to_internal(active_pso[cmd]); - if (pso_internal->pushconstants.size > 0) - { - vkCmdPushConstants( - GetCommandList(cmd), - pso_internal->pipelineLayout, - pso_internal->pushconstants.stageFlags, - pso_internal->pushconstants.offset, - pso_internal->pushconstants.size, - pushconstants[cmd].data - ); - pushconstants[cmd].size = 0; - } + vkCmdPushConstants( + GetCommandList(cmd), + pso_internal->pipelineLayout, + pso_internal->pushconstants.stageFlags, + pso_internal->pushconstants.offset, + pso_internal->pushconstants.size, + pushconstants[cmd].data + ); } } void GraphicsDevice_Vulkan::predispatch(CommandList cmd) { - barrier_flush(cmd); - GetFrameResources().descriptors[cmd].flush(false, cmd); - if (pushconstants[cmd].size > 0) + auto cs_internal = to_internal(active_cs[cmd]); + if (cs_internal->pushconstants.size > 0) { - auto cs_internal = to_internal(active_cs[cmd]); - if (cs_internal->pushconstants.size > 0) - { - vkCmdPushConstants( - GetCommandList(cmd), - cs_internal->pipelineLayout_cs, - cs_internal->pushconstants.stageFlags, - cs_internal->pushconstants.offset, - cs_internal->pushconstants.size, - pushconstants[cmd].data - ); - pushconstants[cmd].size = 0; - } + vkCmdPushConstants( + GetCommandList(cmd), + cs_internal->pipelineLayout_cs, + cs_internal->pushconstants.stageFlags, + cs_internal->pushconstants.offset, + cs_internal->pushconstants.size, + pushconstants[cmd].data + ); } } @@ -2339,21 +2126,16 @@ using namespace Vulkan_Internal; } capabilities |= GRAPHICSDEVICE_CAPABILITY_RENDERTARGET_AND_VIEWPORT_ARRAYINDEX_WITHOUT_GS; // let's hope for the best... - if (raytracing_features.rayTracingPipeline == VK_TRUE) + if ( + raytracing_features.rayTracingPipeline == VK_TRUE && + raytracing_query_features.rayQuery == VK_TRUE && + acceleration_structure_features.accelerationStructure == VK_TRUE && + features_1_2.bufferDeviceAddress == VK_TRUE + ) { - assert(acceleration_structure_features.accelerationStructure == VK_TRUE); - assert(features_1_2.bufferDeviceAddress == VK_TRUE); - capabilities |= GRAPHICSDEVICE_CAPABILITY_RAYTRACING_PIPELINE; - capabilities |= GRAPHICSDEVICE_CAPABILITY_RAYTRACING_GEOMETRYINDEX; + capabilities |= GRAPHICSDEVICE_CAPABILITY_RAYTRACING; SHADER_IDENTIFIER_SIZE = raytracing_properties.shaderGroupHandleSize; } - if (raytracing_query_features.rayQuery == VK_TRUE) - { - assert(acceleration_structure_features.accelerationStructure == VK_TRUE); - assert(features_1_2.bufferDeviceAddress == VK_TRUE); - capabilities |= GRAPHICSDEVICE_CAPABILITY_RAYTRACING_INLINE; - capabilities |= GRAPHICSDEVICE_CAPABILITY_RAYTRACING_GEOMETRYINDEX; - } if (mesh_shader_features.meshShader == VK_TRUE && mesh_shader_features.taskShader == VK_TRUE) { capabilities |= GRAPHICSDEVICE_CAPABILITY_MESH_SHADER; @@ -2368,12 +2150,7 @@ using namespace Vulkan_Internal; VARIABLE_RATE_SHADING_TILE_SIZE = std::min(fragment_shading_rate_properties.maxFragmentShadingRateAttachmentTexelSize.width, fragment_shading_rate_properties.maxFragmentShadingRateAttachmentTexelSize.height); } - assert(features_1_2.hostQueryReset == VK_TRUE); - - if (features_1_2.descriptorIndexing) - { - capabilities |= GRAPHICSDEVICE_CAPABILITY_BINDLESS_DESCRIPTORS; - } + assert(features_1_2.descriptorIndexing == VK_TRUE); VkFormatProperties formatProperties = {}; vkGetPhysicalDeviceFormatProperties(physicalDevice, _ConvertFormat(FORMAT_R11G11B10_FLOAT), &formatProperties); @@ -2729,10 +2506,6 @@ using namespace Vulkan_Internal; dynamicStateInfo.dynamicStateCount = (uint32_t)pso_dynamicStates.size(); dynamicStateInfo.pDynamicStates = pso_dynamicStates.data(); - if (features_1_2.descriptorBindingUniformBufferUpdateAfterBind) - { - allocationhandler->bindlessUniformBuffers.init(device, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, properties_1_2.maxDescriptorSetUpdateAfterBindUniformBuffers / 4); - } if (features_1_2.descriptorBindingSampledImageUpdateAfterBind) { allocationhandler->bindlessSampledImages.init(device, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, properties_1_2.maxDescriptorSetUpdateAfterBindSampledImages / 4); @@ -2757,11 +2530,18 @@ using namespace Vulkan_Internal; { allocationhandler->bindlessSamplers.init(device, VK_DESCRIPTOR_TYPE_SAMPLER, 256); } - if (CheckCapability(GRAPHICSDEVICE_CAPABILITY_RAYTRACING_PIPELINE) || CheckCapability(GRAPHICSDEVICE_CAPABILITY_RAYTRACING_INLINE)) + if (CheckCapability(GRAPHICSDEVICE_CAPABILITY_RAYTRACING)) { allocationhandler->bindlessAccelerationStructures.init(device, VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR, 32); } + ALLOCATION_MIN_ALIGNMENT = std::max( + properties2.properties.limits.minUniformBufferOffsetAlignment, + std::max( + properties2.properties.limits.minStorageBufferOffsetAlignment, + properties2.properties.limits.minTexelBufferOffsetAlignment + ) + ); wiBackLog::post("Created GraphicsDevice_Vulkan"); } @@ -3115,15 +2895,11 @@ using namespace Vulkan_Internal; internal_state->allocationhandler = allocationhandler; pBuffer->internal_state = internal_state; pBuffer->type = GPUResource::GPU_RESOURCE_TYPE::BUFFER; + pBuffer->mapped_data = nullptr; + pBuffer->mapped_rowpitch = 0; pBuffer->desc = *pDesc; - if (pDesc->Usage == USAGE_DYNAMIC && pDesc->BindFlags & BIND_CONSTANT_BUFFER) - { - // this special case will use frame allocator - return true; - } - VkBufferCreateInfo bufferInfo = {}; bufferInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO; bufferInfo.size = pBuffer->desc.ByteWidth; @@ -3162,6 +2938,14 @@ using namespace Vulkan_Internal; bufferInfo.usage |= VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT; } } + if (pBuffer->desc.MiscFlags & RESOURCE_MISC_BUFFER_RAW) + { + bufferInfo.usage |= VK_BUFFER_USAGE_STORAGE_BUFFER_BIT; + } + if (pBuffer->desc.MiscFlags & RESOURCE_MISC_BUFFER_STRUCTURED) + { + bufferInfo.usage |= VK_BUFFER_USAGE_STORAGE_BUFFER_BIT; + } if (pBuffer->desc.MiscFlags & RESOURCE_MISC_INDIRECT_ARGS) { bufferInfo.usage |= VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT; @@ -3198,28 +2982,28 @@ using namespace Vulkan_Internal; //allocInfo.flags = VMA_ALLOCATION_CREATE_STRATEGY_MIN_MEMORY_BIT; //allocInfo.flags = VMA_ALLOCATION_CREATE_STRATEGY_MIN_FRAGMENTATION_BIT; allocInfo.usage = VMA_MEMORY_USAGE_GPU_ONLY; - if (pDesc->Usage == USAGE_STAGING) + if (pDesc->Usage == USAGE_READBACK) { - if (pDesc->CPUAccessFlags & CPU_ACCESS_READ) - { - allocInfo.usage = VMA_MEMORY_USAGE_GPU_TO_CPU; - bufferInfo.usage = VK_BUFFER_USAGE_TRANSFER_DST_BIT; - } - else - { - allocInfo.usage = VMA_MEMORY_USAGE_CPU_ONLY; - allocInfo.flags = VMA_ALLOCATION_CREATE_MAPPED_BIT; - bufferInfo.usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT; - } + allocInfo.flags = VMA_ALLOCATION_CREATE_MAPPED_BIT; + allocInfo.usage = VMA_MEMORY_USAGE_GPU_TO_CPU; + bufferInfo.usage |= VK_BUFFER_USAGE_TRANSFER_DST_BIT; } - if (pDesc->Usage == USAGE_DYNAMIC) + else if(pDesc->Usage == USAGE_UPLOAD) { - allocInfo.usage = VMA_MEMORY_USAGE_CPU_TO_GPU; + allocInfo.flags = VMA_ALLOCATION_CREATE_MAPPED_BIT; + allocInfo.usage = VMA_MEMORY_USAGE_CPU_ONLY; + bufferInfo.usage |= VK_BUFFER_USAGE_TRANSFER_SRC_BIT; } res = vmaCreateBuffer(allocationhandler->allocator, &bufferInfo, &allocInfo, &internal_state->resource, &internal_state->allocation, nullptr); assert(res == VK_SUCCESS); + if (pDesc->Usage == USAGE_READBACK || pDesc->Usage == USAGE_UPLOAD) + { + pBuffer->mapped_data = internal_state->allocation->GetMappedData(); + pBuffer->mapped_rowpitch = pDesc->ByteWidth; + } + if (bufferInfo.usage & VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT) { VkBufferDeviceAddressInfo info = {}; @@ -3313,7 +3097,7 @@ using namespace Vulkan_Internal; copyAllocator.submit(cmd); } } - else if(pDesc->Usage != USAGE_STAGING) + else if(pDesc->Usage != USAGE_UPLOAD && pDesc->Usage != USAGE_READBACK) { // zero-initialize: initLocker.lock(); @@ -3339,10 +3123,6 @@ using namespace Vulkan_Internal; // Create resource views if needed - if (pDesc->BindFlags & BIND_CONSTANT_BUFFER) - { - CreateSubresource(pBuffer, CBV, 0); - } if (pDesc->BindFlags & BIND_SHADER_RESOURCE) { CreateSubresource(pBuffer, SRV, 0); @@ -3362,6 +3142,8 @@ using namespace Vulkan_Internal; internal_state->allocationhandler = allocationhandler; pTexture->internal_state = internal_state; pTexture->type = GPUResource::GPU_RESOURCE_TYPE::TEXTURE; + pTexture->mapped_data = nullptr; + pTexture->mapped_rowpitch = 0; pTexture->desc = *pDesc; @@ -3398,12 +3180,12 @@ using namespace Vulkan_Internal; if (pTexture->desc.BindFlags & BIND_RENDER_TARGET) { imageInfo.usage |= VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT; - allocInfo.flags |= VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT; + //allocInfo.flags |= VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT; } if (pTexture->desc.BindFlags & BIND_DEPTH_STENCIL) { imageInfo.usage |= VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT; - allocInfo.flags |= VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT; + //allocInfo.flags |= VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT; } if(pTexture->desc.BindFlags & BIND_SHADING_RATE) { @@ -3448,23 +3230,22 @@ using namespace Vulkan_Internal; VkResult res; - if (pTexture->desc.Usage == USAGE_STAGING) + if (pTexture->desc.Usage == USAGE_READBACK || pTexture->desc.Usage == USAGE_UPLOAD) { VkBufferCreateInfo bufferInfo = {}; bufferInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO; bufferInfo.size = imageInfo.extent.width * imageInfo.extent.height * imageInfo.extent.depth * imageInfo.arrayLayers * GetFormatStride(pTexture->desc.Format); - if (pDesc->CPUAccessFlags & CPU_ACCESS_READ) + allocInfo.flags = VMA_ALLOCATION_CREATE_MAPPED_BIT; + if (pTexture->desc.Usage == USAGE_READBACK) { - allocInfo.flags |= VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT; // I don't know why but consecutive resource downloads could fail without this allocInfo.usage = VMA_MEMORY_USAGE_GPU_TO_CPU; bufferInfo.usage = VK_BUFFER_USAGE_TRANSFER_DST_BIT; } - else + else if(pTexture->desc.Usage == USAGE_UPLOAD) { allocInfo.usage = VMA_MEMORY_USAGE_CPU_ONLY; - allocInfo.flags = VMA_ALLOCATION_CREATE_MAPPED_BIT; bufferInfo.usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT; } @@ -3480,6 +3261,12 @@ using namespace Vulkan_Internal; subresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; vkGetImageSubresourceLayout(device, image, &subresource, &internal_state->subresourcelayout); + if (pDesc->Usage == USAGE_READBACK || pTexture->desc.Usage == USAGE_UPLOAD) + { + pTexture->mapped_data = internal_state->allocation->GetMappedData(); + pTexture->mapped_rowpitch = (uint32_t)internal_state->subresourcelayout.rowPitch; + } + vkDestroyImage(device, image, nullptr); return res == VK_SUCCESS; } @@ -3572,7 +3359,7 @@ using namespace Vulkan_Internal; barrier.oldLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL; barrier.newLayout = _ConvertImageLayout(pTexture->desc.layout); barrier.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT; - barrier.dstAccessMask = _ParseImageLayout(pTexture->desc.layout); + barrier.dstAccessMask = _ParseResourceState(pTexture->desc.layout); initLocker.lock(); vkCmdPipelineBarrier( @@ -3596,7 +3383,7 @@ using namespace Vulkan_Internal; barrier.oldLayout = imageInfo.initialLayout; barrier.newLayout = _ConvertImageLayout(pTexture->desc.layout); barrier.srcAccessMask = 0; - barrier.dstAccessMask = _ParseImageLayout(pTexture->desc.layout); + barrier.dstAccessMask = _ParseResourceState(pTexture->desc.layout); if (pTexture->desc.BindFlags & BIND_DEPTH_STENCIL) { barrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT; @@ -3912,8 +3699,7 @@ using namespace Vulkan_Internal; switch (x.descriptorType) { case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER: - layouts.push_back(allocationhandler->bindlessUniformBuffers.descriptorSetLayout); - internal_state->bindlessSets.push_back(allocationhandler->bindlessUniformBuffers.descriptorSet); + assert(0); // not supported, use the raw buffers for same functionality break; case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE: layouts.push_back(allocationhandler->bindlessSampledImages.descriptorSetLayout); @@ -3966,12 +3752,13 @@ using namespace Vulkan_Internal; res = vkCreatePipelineLayout(device, &pipelineLayoutInfo, nullptr, &internal_state->pipelineLayout_cs); assert(res == VK_SUCCESS); pso_layout_cache[internal_state->binding_hash].pipelineLayout = internal_state->pipelineLayout_cs; + pso_layout_cache[internal_state->binding_hash].bindlessSets = internal_state->bindlessSets; + pso_layout_cache[internal_state->binding_hash].bindlessFirstSet = internal_state->bindlessFirstSet; } - else - { - internal_state->descriptorSetLayout = pso_layout_cache[internal_state->binding_hash].descriptorSetLayout; - internal_state->pipelineLayout_cs = pso_layout_cache[internal_state->binding_hash].pipelineLayout; - } + internal_state->descriptorSetLayout = pso_layout_cache[internal_state->binding_hash].descriptorSetLayout; + internal_state->pipelineLayout_cs = pso_layout_cache[internal_state->binding_hash].pipelineLayout; + internal_state->bindlessSets = pso_layout_cache[internal_state->binding_hash].bindlessSets; + internal_state->bindlessFirstSet = pso_layout_cache[internal_state->binding_hash].bindlessFirstSet; pso_layout_cache_mutex.unlock(); } } @@ -4223,7 +4010,6 @@ using namespace Vulkan_Internal; VkResult res = vkCreateQueryPool(device, &poolInfo, nullptr, &internal_state->pool); assert(res == VK_SUCCESS); - vkResetQueryPool(device, internal_state->pool, 0, poolInfo.queryCount); return res == VK_SUCCESS; } @@ -4293,9 +4079,10 @@ using namespace Vulkan_Internal; if (shader_internal->pushconstants.size > 0) { - internal_state->pushconstants.offset = shader_internal->pushconstants.offset; - internal_state->pushconstants.size = shader_internal->pushconstants.size; - internal_state->pushconstants.stageFlags |= shader_internal->pushconstants.stageFlags; + internal_state->pushconstants.offset = std::min(internal_state->pushconstants.offset, shader_internal->pushconstants.offset); + internal_state->pushconstants.size = std::max(internal_state->pushconstants.size, shader_internal->pushconstants.size); + //internal_state->pushconstants.stageFlags |= shader_internal->pushconstants.stageFlags; + internal_state->pushconstants.stageFlags = VK_SHADER_STAGE_ALL_GRAPHICS; // combining only the used stage flags gives some validation errors for some reason while rendering... } }; @@ -4376,8 +4163,7 @@ using namespace Vulkan_Internal; switch (x.descriptorType) { case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER: - layouts.push_back(allocationhandler->bindlessUniformBuffers.descriptorSetLayout); - pso_layout_cache[internal_state->binding_hash].bindlessSets.push_back(allocationhandler->bindlessUniformBuffers.descriptorSet); + assert(0); // not supported, use the raw buffers for same functionality break; case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE: layouts.push_back(allocationhandler->bindlessSampledImages.descriptorSetLayout); @@ -5077,7 +4863,6 @@ using namespace Vulkan_Internal; VmaAllocationCreateInfo allocInfo = {}; allocInfo.usage = VMA_MEMORY_USAGE_GPU_ONLY; - allocInfo.flags = VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT; VkResult res = vmaCreateBuffer( allocationhandler->allocator, @@ -5495,29 +5280,6 @@ using namespace Vulkan_Internal; switch (type) { - case wiGraphics::CBV: - { - int index = allocationhandler->bindlessUniformBuffers.allocate(); - if (index >= 0) - { - VkDescriptorBufferInfo bufferInfo = {}; - bufferInfo.buffer = internal_state->resource; - bufferInfo.offset = offset; - bufferInfo.range = size; - VkWriteDescriptorSet write = {}; - write.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; - write.descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER; - write.dstBinding = 0; - write.dstArrayElement = index; - write.descriptorCount = 1; - write.dstSet = allocationhandler->bindlessUniformBuffers.descriptorSet; - write.pBufferInfo = &bufferInfo; - vkUpdateDescriptorSets(device, 1, &write, 0, nullptr); - internal_state->cbv_index = index; - } - return -1; - } - break; case wiGraphics::SRV: case wiGraphics::UAV: @@ -5656,13 +5418,6 @@ using namespace Vulkan_Internal; switch (type) { default: - case wiGraphics::CBV: - if (resource->IsBuffer()) - { - auto internal_state = to_internal((const GPUBuffer*)resource); - return internal_state->cbv_index; - } - break; case wiGraphics::SRV: if (resource->IsBuffer()) { @@ -5784,82 +5539,6 @@ using namespace Vulkan_Internal; assert(res == VK_SUCCESS); } - void GraphicsDevice_Vulkan::Map(const GPUResource* resource, Mapping* mapping) const - { - VkDeviceMemory memory = VK_NULL_HANDLE; - - if (resource->type == GPUResource::GPU_RESOURCE_TYPE::BUFFER) - { - const GPUBuffer* buffer = (const GPUBuffer*)resource; - auto internal_state = to_internal(buffer); - memory = internal_state->allocation->GetMemory(); - mapping->rowpitch = (uint32_t)buffer->desc.ByteWidth; - } - else if (resource->type == GPUResource::GPU_RESOURCE_TYPE::TEXTURE) - { - const Texture* texture = (const Texture*)resource; - auto internal_state = to_internal(texture); - memory = internal_state->allocation->GetMemory(); - mapping->rowpitch = (uint32_t)internal_state->subresourcelayout.rowPitch; - } - else - { - assert(0); - return; - } - - VkDeviceSize offset = mapping->offset; - VkDeviceSize size = mapping->size; - - VkResult res = vkMapMemory(device, memory, offset, size, 0, &mapping->data); - if (res != VK_SUCCESS) - { - assert(0); - mapping->data = nullptr; - mapping->rowpitch = 0; - } - } - void GraphicsDevice_Vulkan::Unmap(const GPUResource* resource) const - { - if (resource->type == GPUResource::GPU_RESOURCE_TYPE::BUFFER) - { - const GPUBuffer* buffer = (const GPUBuffer*)resource; - auto internal_state = to_internal(buffer); - vkUnmapMemory(device, internal_state->allocation->GetMemory()); - } - else if (resource->type == GPUResource::GPU_RESOURCE_TYPE::TEXTURE) - { - const Texture* texture = (const Texture*)resource; - auto internal_state = to_internal(texture); - vkUnmapMemory(device, internal_state->allocation->GetMemory()); - } - } - void GraphicsDevice_Vulkan::QueryRead(const GPUQueryHeap* heap, uint32_t index, uint32_t count, uint64_t* results) const - { - if (count == 0) - return; - - auto internal_state = to_internal(heap); - - VkResult res = vkGetQueryPoolResults( - device, - internal_state->pool, - index, - count, - sizeof(uint64_t) * count, - results, - sizeof(uint64_t), - VK_QUERY_RESULT_64_BIT - ); - - vkResetQueryPool( - device, - internal_state->pool, - index, - count - ); - } - void GraphicsDevice_Vulkan::SetCommonSampler(const StaticSampler* sam) { common_samplers.push_back(*sam); @@ -5941,7 +5620,6 @@ using namespace Vulkan_Internal; res = vkAllocateCommandBuffers(device, &commandBufferInfo, &frame.commandBuffers[cmd][queue]); assert(res == VK_SUCCESS); - frame.resourceBuffer[cmd].init(this, 1024 * 1024); // 1 MB starting size frame.descriptors[cmd].init(this); } } @@ -5960,9 +5638,6 @@ using namespace Vulkan_Internal; // reset descriptor allocators: GetFrameResources().descriptors[cmd].reset(); - // reset immediate resource allocators: - GetFrameResources().resourceBuffer[cmd].clear(); - if (queue == QUEUE_GRAPHICS) { VkRect2D scissors[8]; @@ -6020,8 +5695,6 @@ using namespace Vulkan_Internal; cmd_count.store(0); for (CommandList cmd = 0; cmd < cmd_last; ++cmd) { - barrier_flush(cmd); - res = vkEndCommandBuffer(GetCommandList(cmd)); assert(res == VK_SUCCESS); @@ -6225,7 +5898,6 @@ using namespace Vulkan_Internal; // return; // } //} - barrier_flush(cmd); VkClearValue clearColor = { swapchain->desc.clearcolor[0], @@ -6246,8 +5918,6 @@ using namespace Vulkan_Internal; } void GraphicsDevice_Vulkan::RenderPassBegin(const RenderPass* renderpass, CommandList cmd) { - barrier_flush(cmd); - active_renderpass[cmd] = renderpass; auto internal_state = to_internal(renderpass); @@ -6257,7 +5927,7 @@ using namespace Vulkan_Internal; { vkCmdEndRenderPass(GetCommandList(cmd)); - active_renderpass[cmd] = VK_NULL_HANDLE; + active_renderpass[cmd] = nullptr; } void GraphicsDevice_Vulkan::BindScissorRects(uint32_t numRects, const Rect* rects, CommandList cmd) { @@ -6288,71 +5958,66 @@ using namespace Vulkan_Internal; } vkCmdSetViewport(GetCommandList(cmd), 0, NumViewports, vp); } - void GraphicsDevice_Vulkan::BindResource(SHADERSTAGE stage, const GPUResource* resource, uint32_t slot, CommandList cmd, int subresource) + void GraphicsDevice_Vulkan::BindResource(const GPUResource* resource, uint32_t slot, CommandList cmd, int subresource) { - assert(slot < GPU_RESOURCE_HEAP_SRV_COUNT); + assert(slot < DESCRIPTORBINDER_SRV_COUNT); auto& descriptors = GetFrameResources().descriptors[cmd]; - if (descriptors.SRV[slot] != resource || descriptors.SRV_index[slot] != subresource) + if (descriptors.SRV[slot].internal_state != resource->internal_state || descriptors.SRV_index[slot] != subresource) { - descriptors.SRV[slot] = resource; + descriptors.SRV[slot] = *resource; descriptors.SRV_index[slot] = subresource; descriptors.dirty = true; } } - void GraphicsDevice_Vulkan::BindResources(SHADERSTAGE stage, const GPUResource *const* resources, uint32_t slot, uint32_t count, CommandList cmd) + void GraphicsDevice_Vulkan::BindResources(const GPUResource *const* resources, uint32_t slot, uint32_t count, CommandList cmd) { if (resources != nullptr) { for (uint32_t i = 0; i < count; ++i) { - BindResource(stage, resources[i], slot + i, cmd, -1); + BindResource(resources[i], slot + i, cmd, -1); } } } - void GraphicsDevice_Vulkan::BindUAV(SHADERSTAGE stage, const GPUResource* resource, uint32_t slot, CommandList cmd, int subresource) + void GraphicsDevice_Vulkan::BindUAV(const GPUResource* resource, uint32_t slot, CommandList cmd, int subresource) { - assert(slot < GPU_RESOURCE_HEAP_UAV_COUNT); + assert(slot < DESCRIPTORBINDER_UAV_COUNT); auto& descriptors = GetFrameResources().descriptors[cmd]; - if (descriptors.UAV[slot] != resource || descriptors.UAV_index[slot] != subresource) + if (descriptors.UAV[slot].internal_state != resource->internal_state || descriptors.UAV_index[slot] != subresource) { - descriptors.UAV[slot] = resource; + descriptors.UAV[slot] = *resource; descriptors.UAV_index[slot] = subresource; descriptors.dirty = true; } } - void GraphicsDevice_Vulkan::BindUAVs(SHADERSTAGE stage, const GPUResource *const* resources, uint32_t slot, uint32_t count, CommandList cmd) + void GraphicsDevice_Vulkan::BindUAVs(const GPUResource *const* resources, uint32_t slot, uint32_t count, CommandList cmd) { if (resources != nullptr) { for (uint32_t i = 0; i < count; ++i) { - BindUAV(stage, resources[i], slot + i, cmd, -1); + BindUAV(resources[i], slot + i, cmd, -1); } } } - void GraphicsDevice_Vulkan::UnbindResources(uint32_t slot, uint32_t num, CommandList cmd) + void GraphicsDevice_Vulkan::BindSampler(const Sampler* sampler, uint32_t slot, CommandList cmd) { - } - void GraphicsDevice_Vulkan::UnbindUAVs(uint32_t slot, uint32_t num, CommandList cmd) - { - } - void GraphicsDevice_Vulkan::BindSampler(SHADERSTAGE stage, const Sampler* sampler, uint32_t slot, CommandList cmd) - { - assert(slot < GPU_SAMPLER_HEAP_COUNT); + assert(slot < DESCRIPTORBINDER_SAMPLER_COUNT); auto& descriptors = GetFrameResources().descriptors[cmd]; - if (descriptors.SAM[slot] != sampler) + if (descriptors.SAM[slot].internal_state != sampler->internal_state) { - descriptors.SAM[slot] = sampler; + descriptors.SAM[slot] = *sampler; descriptors.dirty = true; } } - void GraphicsDevice_Vulkan::BindConstantBuffer(SHADERSTAGE stage, const GPUBuffer* buffer, uint32_t slot, CommandList cmd) + void GraphicsDevice_Vulkan::BindConstantBuffer(const GPUBuffer* buffer, uint32_t slot, CommandList cmd, uint64_t offset) { - assert(slot < GPU_RESOURCE_HEAP_CBV_COUNT); + assert(slot < DESCRIPTORBINDER_CBV_COUNT); auto& descriptors = GetFrameResources().descriptors[cmd]; - if (buffer->desc.Usage == USAGE_DYNAMIC || descriptors.CBV[slot] != buffer) + if (descriptors.CBV[slot].internal_state != buffer->internal_state || descriptors.CBV_offset[slot] != offset) { - descriptors.CBV[slot] = buffer; + descriptors.CBV[slot] = *buffer; + descriptors.CBV_offset[slot] = offset; descriptors.dirty = true; } } @@ -6648,8 +6313,6 @@ using namespace Vulkan_Internal; } void GraphicsDevice_Vulkan::CopyResource(const GPUResource* pDst, const GPUResource* pSrc, CommandList cmd) { - barrier_flush(cmd); - if (pDst->type == GPUResource::GPU_RESOURCE_TYPE::TEXTURE && pSrc->type == GPUResource::GPU_RESOURCE_TYPE::TEXTURE) { auto internal_state_src = to_internal((const Texture*)pSrc); @@ -6658,7 +6321,7 @@ using namespace Vulkan_Internal; const TextureDesc& src_desc = ((const Texture*)pSrc)->GetDesc(); const TextureDesc& dst_desc = ((const Texture*)pDst)->GetDesc(); - if (src_desc.Usage & USAGE_STAGING) + if (src_desc.Usage == USAGE_UPLOAD) { VkBufferImageCopy copy = {}; copy.imageExtent.width = dst_desc.Width; @@ -6676,7 +6339,7 @@ using namespace Vulkan_Internal; © ); } - else if (dst_desc.Usage & USAGE_STAGING) + else if (dst_desc.Usage == USAGE_READBACK) { VkBufferImageCopy copy = {}; copy.imageExtent.width = src_desc.Width; @@ -6768,92 +6431,21 @@ using namespace Vulkan_Internal; ); } } - void GraphicsDevice_Vulkan::UpdateBuffer(const GPUBuffer* buffer, const void* data, CommandList cmd, int dataSize) + void GraphicsDevice_Vulkan::CopyBuffer(const GPUBuffer* pDst, uint64_t dst_offset, const GPUBuffer* pSrc, uint64_t src_offset, uint64_t size, CommandList cmd) { - assert(buffer->desc.Usage != USAGE_IMMUTABLE && "Cannot update IMMUTABLE GPUBuffer!"); - assert((int)buffer->desc.ByteWidth >= dataSize || dataSize < 0 && "Data size is too big!"); + auto internal_state_src = to_internal((const GPUBuffer*)pSrc); + auto internal_state_dst = to_internal((const GPUBuffer*)pDst); - if (dataSize == 0) - { - return; - } - - dataSize = std::min((int)buffer->desc.ByteWidth, dataSize); - dataSize = (dataSize >= 0 ? dataSize : buffer->desc.ByteWidth); - - auto internal_state_dst = to_internal(buffer); - - GPUAllocation allocation = AllocateGPU(dataSize, cmd); - memcpy(allocation.data, data, dataSize); - - if (buffer->desc.Usage == USAGE_DYNAMIC && buffer->desc.BindFlags & BIND_CONSTANT_BUFFER) - { - // Dynamic buffer will be used from host memory directly: - internal_state_dst->dynamic[cmd] = allocation; - GetFrameResources().descriptors[cmd].dirty = true; - } - else - { - // Contents will be transferred to device memory: - assert(active_renderpass[cmd] == nullptr); // must not be inside render pass - - auto internal_state_src = to_internal(&GetFrameResources().resourceBuffer[cmd].buffer); - - VkBufferMemoryBarrier barrier = {}; - barrier.sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER; - barrier.buffer = internal_state_dst->resource; - barrier.srcAccessMask = 0; - if (buffer->desc.BindFlags & BIND_CONSTANT_BUFFER) - { - barrier.srcAccessMask |= VK_ACCESS_UNIFORM_READ_BIT; - } - if (buffer->desc.BindFlags & BIND_VERTEX_BUFFER) - { - barrier.srcAccessMask |= VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT; - } - if (buffer->desc.BindFlags & BIND_INDEX_BUFFER) - { - barrier.srcAccessMask |= VK_ACCESS_INDEX_READ_BIT; - } - if (buffer->desc.BindFlags & BIND_SHADER_RESOURCE) - { - barrier.srcAccessMask |= VK_ACCESS_SHADER_READ_BIT; - } - if (buffer->desc.BindFlags & BIND_UNORDERED_ACCESS) - { - barrier.srcAccessMask |= VK_ACCESS_SHADER_WRITE_BIT; - } - if (buffer->desc.MiscFlags & RESOURCE_MISC_RAY_TRACING) - { - barrier.srcAccessMask |= VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_KHR; - } - barrier.dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT; - barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; - barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; - barrier.size = VK_WHOLE_SIZE; - - frame_bufferBarriers[cmd].push_back(barrier); - barrier_flush(cmd); - - VkBufferCopy copyRegion = {}; - copyRegion.size = dataSize; - copyRegion.srcOffset = (VkDeviceSize)allocation.offset; - copyRegion.dstOffset = 0; - - vkCmdCopyBuffer( - GetCommandList(cmd), - internal_state_src->resource, - internal_state_dst->resource, - 1, - ©Region - ); - - // reverse barrier: - std::swap(barrier.srcAccessMask, barrier.dstAccessMask); - frame_bufferBarriers[cmd].push_back(barrier); - - } + VkBufferCopy copy = {}; + copy.srcOffset = src_offset; + copy.dstOffset = dst_offset; + copy.size = size; + vkCmdCopyBuffer(GetCommandList(cmd), + internal_state_src->resource, + internal_state_dst->resource, + 1, © + ); } void GraphicsDevice_Vulkan::QueryBegin(const GPUQueryHeap* heap, uint32_t index, CommandList cmd) { @@ -6876,7 +6468,7 @@ using namespace Vulkan_Internal; switch (heap->desc.type) { case GPU_QUERY_TYPE_TIMESTAMP: - vkCmdWriteTimestamp(GetCommandList(cmd), VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, internal_state->pool, index); + vkCmdWriteTimestamp(GetCommandList(cmd), VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, internal_state->pool, index); break; case GPU_QUERY_TYPE_OCCLUSION_BINARY: case GPU_QUERY_TYPE_OCCLUSION: @@ -6884,6 +6476,55 @@ using namespace Vulkan_Internal; break; } } + void GraphicsDevice_Vulkan::QueryResolve(const GPUQueryHeap* heap, uint32_t index, uint32_t count, const GPUBuffer* dest, uint64_t dest_offset, CommandList cmd) + { + assert(active_renderpass[cmd] == nullptr); // Can't resolve inside renderpass! + + // Looks like the vulkan needs this barrier, otherwise the queries didn't finish + // It was still a problem with VK_QUERY_RESULT_WAIT_BIT, but that + // also caused deadlocks, so I decided to do a safer memory barrier here + GPUBarrier memory_barrier = GPUBarrier::Memory(); + Barrier(&memory_barrier, 1, cmd); + + auto internal_state = to_internal(heap); + auto dst_internal = to_internal(dest); + + VkQueryResultFlags flags = VK_QUERY_RESULT_64_BIT; + + switch (heap->desc.type) + { + case GPU_QUERY_TYPE_OCCLUSION_BINARY: + flags |= VK_QUERY_RESULT_PARTIAL_BIT; + break; + default: + break; + } + + vkCmdCopyQueryPoolResults( + GetCommandList(cmd), + internal_state->pool, + index, + count, + dst_internal->resource, + dest_offset, + sizeof(uint64_t), + flags + ); + + } + void GraphicsDevice_Vulkan::QueryReset(const GPUQueryHeap* heap, uint32_t index, uint32_t count, CommandList cmd) + { + assert(active_renderpass[cmd] == nullptr); // Can't resolve inside renderpass! + + auto internal_state = to_internal(heap); + + vkCmdResetQueryPool( + GetCommandList(cmd), + internal_state->pool, + index, + count + ); + } void GraphicsDevice_Vulkan::Barrier(const GPUBarrier* barriers, uint32_t numBarriers, CommandList cmd) { auto& memoryBarriers = frame_memoryBarriers[cmd]; @@ -6894,6 +6535,11 @@ using namespace Vulkan_Internal; { const GPUBarrier& barrier = barriers[i]; + if (barrier.type == GPUBarrier::IMAGE_BARRIER && (barrier.image.texture == nullptr || !barrier.image.texture->IsValid())) + continue; + if (barrier.type == GPUBarrier::BUFFER_BARRIER && (barrier.buffer.buffer == nullptr || !barrier.buffer.buffer->IsValid())) + continue; + switch (barrier.type) { default: @@ -6904,7 +6550,7 @@ using namespace Vulkan_Internal; barrierdesc.pNext = nullptr; barrierdesc.srcAccessMask = VK_ACCESS_MEMORY_WRITE_BIT | VK_ACCESS_SHADER_WRITE_BIT; barrierdesc.dstAccessMask = VK_ACCESS_MEMORY_READ_BIT | VK_ACCESS_SHADER_READ_BIT; - if (CheckCapability(GRAPHICSDEVICE_CAPABILITY_RAYTRACING_PIPELINE) || CheckCapability(GRAPHICSDEVICE_CAPABILITY_RAYTRACING_INLINE)) + if (CheckCapability(GRAPHICSDEVICE_CAPABILITY_RAYTRACING)) { barrierdesc.srcAccessMask |= VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_KHR | VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_KHR; barrierdesc.dstAccessMask |= VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_KHR | VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_KHR; @@ -6924,8 +6570,8 @@ using namespace Vulkan_Internal; barrierdesc.image = internal_state->resource; barrierdesc.oldLayout = _ConvertImageLayout(barrier.image.layout_before); barrierdesc.newLayout = _ConvertImageLayout(barrier.image.layout_after); - barrierdesc.srcAccessMask = _ParseImageLayout(barrier.image.layout_before); - barrierdesc.dstAccessMask = _ParseImageLayout(barrier.image.layout_after); + barrierdesc.srcAccessMask = _ParseResourceState(barrier.image.layout_before); + barrierdesc.dstAccessMask = _ParseResourceState(barrier.image.layout_after); if (desc.BindFlags & BIND_DEPTH_STENCIL) { barrierdesc.subresourceRange.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT; @@ -6955,28 +6601,7 @@ using namespace Vulkan_Internal; barrierdesc.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; barrierdesc.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; - bool found = false; - for (auto& x : imageBarriers) - { - // Two duplicate barriers will be combined into one: - if (x.image == barrierdesc.image && - x.subresourceRange.baseMipLevel == barrierdesc.subresourceRange.baseMipLevel && - x.subresourceRange.levelCount == barrierdesc.subresourceRange.levelCount && - x.subresourceRange.baseArrayLayer == barrierdesc.subresourceRange.baseArrayLayer && - x.subresourceRange.layerCount == barrierdesc.subresourceRange.layerCount - ) - { - found = true; - x.newLayout = barrierdesc.newLayout; - x.dstAccessMask |= barrierdesc.dstAccessMask; - break; - } - } - - if (!found) - { - imageBarriers.push_back(barrierdesc); - } + imageBarriers.push_back(barrierdesc); } break; case GPUBarrier::BUFFER_BARRIER: @@ -6989,39 +6614,48 @@ using namespace Vulkan_Internal; barrierdesc.buffer = internal_state->resource; barrierdesc.size = barrier.buffer.buffer->GetDesc().ByteWidth; barrierdesc.offset = 0; - barrierdesc.srcAccessMask = _ParseBufferState(barrier.buffer.state_before); - barrierdesc.dstAccessMask = _ParseBufferState(barrier.buffer.state_after); + barrierdesc.srcAccessMask = _ParseResourceState(barrier.buffer.state_before); + barrierdesc.dstAccessMask = _ParseResourceState(barrier.buffer.state_after); barrierdesc.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; barrierdesc.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; - bool found = false; - for (auto& x : bufferBarriers) - { - // Two duplicate barriers will be combined into one: - if (x.buffer == barrierdesc.buffer && - x.srcAccessMask == barrierdesc.srcAccessMask && - x.dstAccessMask == barrierdesc.dstAccessMask - ) - { - found = true; - x.dstAccessMask |= barrierdesc.dstAccessMask; - break; - } - } - - if (!found) - { - bufferBarriers.push_back(barrierdesc); - } + bufferBarriers.push_back(barrierdesc); } break; } } + + if (!memoryBarriers.empty() || + !bufferBarriers.empty() || + !imageBarriers.empty() + ) + { + VkPipelineStageFlags srcStage = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT; + VkPipelineStageFlags dstStage = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT; + + if (CheckCapability(GRAPHICSDEVICE_CAPABILITY_RAYTRACING)) + { + srcStage |= VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR | VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR; + dstStage |= VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR | VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR; + } + + vkCmdPipelineBarrier( + GetCommandList(cmd), + srcStage, + dstStage, + 0, + (uint32_t)memoryBarriers.size(), memoryBarriers.data(), + (uint32_t)bufferBarriers.size(), bufferBarriers.data(), + (uint32_t)imageBarriers.size(), imageBarriers.data() + ); + + memoryBarriers.clear(); + imageBarriers.clear(); + bufferBarriers.clear(); + } } void GraphicsDevice_Vulkan::BuildRaytracingAccelerationStructure(const RaytracingAccelerationStructure* dst, CommandList cmd, const RaytracingAccelerationStructure* src) { - barrier_flush(cmd); - auto dst_internal = to_internal(dst); VkAccelerationStructureBuildGeometryInfoKHR info = dst_internal->buildInfo; @@ -7176,24 +6810,6 @@ using namespace Vulkan_Internal; pushconstants[cmd].size = size; } - GraphicsDevice::GPUAllocation GraphicsDevice_Vulkan::AllocateGPU(size_t dataSize, CommandList cmd) - { - GPUAllocation result; - if (dataSize == 0) - { - return result; - } - - FrameResources::ResourceFrameAllocator& allocator = GetFrameResources().resourceBuffer[cmd]; - uint8_t* dest = allocator.allocate(dataSize, 256); - assert(dest != nullptr); - - result.buffer = &allocator.buffer; - result.offset = (uint32_t)allocator.calculateOffset(dest); - result.data = (void*)dest; - return result; - } - void GraphicsDevice_Vulkan::EventBegin(const char* name, CommandList cmd) { if (!debugUtils) @@ -7207,7 +6823,6 @@ using namespace Vulkan_Internal; label.color[3] = 1.0f; vkCmdBeginDebugUtilsLabelEXT(GetCommandList(cmd), &label); } - void GraphicsDevice_Vulkan::EventEnd(CommandList cmd) { if (!debugUtils) @@ -7215,7 +6830,6 @@ using namespace Vulkan_Internal; vkCmdEndDebugUtilsLabelEXT(GetCommandList(cmd)); } - void GraphicsDevice_Vulkan::SetMarker(const char* name, CommandList cmd) { if (!debugUtils) diff --git a/WickedEngine/wiGraphicsDevice_Vulkan.h b/WickedEngine/wiGraphicsDevice_Vulkan.h index 09ee8c9f4..e362994b8 100644 --- a/WickedEngine/wiGraphicsDevice_Vulkan.h +++ b/WickedEngine/wiGraphicsDevice_Vulkan.h @@ -8,7 +8,6 @@ #ifdef WICKEDENGINE_BUILD_VULKAN #include "wiGraphicsDevice.h" -#include "wiGraphicsDevice_SharedInternals.h" #include "wiMath.h" #ifdef _WIN32 @@ -203,12 +202,13 @@ namespace wiGraphics std::vector accelerationStructureViews; bool dirty = false; - const GPUBuffer* CBV[GPU_RESOURCE_HEAP_CBV_COUNT]; - const GPUResource* SRV[GPU_RESOURCE_HEAP_SRV_COUNT]; - int SRV_index[GPU_RESOURCE_HEAP_SRV_COUNT]; - const GPUResource* UAV[GPU_RESOURCE_HEAP_UAV_COUNT]; - int UAV_index[GPU_RESOURCE_HEAP_UAV_COUNT]; - const Sampler* SAM[GPU_SAMPLER_HEAP_COUNT]; + GPUBuffer CBV[DESCRIPTORBINDER_CBV_COUNT]; + uint64_t CBV_offset[DESCRIPTORBINDER_CBV_COUNT]; + GPUResource SRV[DESCRIPTORBINDER_SRV_COUNT]; + int SRV_index[DESCRIPTORBINDER_SRV_COUNT]; + GPUResource UAV[DESCRIPTORBINDER_UAV_COUNT]; + int UAV_index[DESCRIPTORBINDER_UAV_COUNT]; + Sampler SAM[DESCRIPTORBINDER_SAMPLER_COUNT]; void init(GraphicsDevice_Vulkan* device); void destroy(); @@ -216,27 +216,10 @@ namespace wiGraphics void flush(bool graphics, CommandList cmd); }; DescriptorBinder descriptors[COMMANDLIST_COUNT]; - - - struct ResourceFrameAllocator - { - GraphicsDevice_Vulkan* device = nullptr; - GPUBuffer buffer; - uint8_t* dataBegin = nullptr; - uint8_t* dataCur = nullptr; - uint8_t* dataEnd = nullptr; - - void init(GraphicsDevice_Vulkan* device, size_t size); - - uint8_t* allocate(size_t dataSize, size_t alignment); - void clear(); - uint64_t calculateOffset(uint8_t* address); - }; - ResourceFrameAllocator resourceBuffer[COMMANDLIST_COUNT]; }; FrameResources frames[BUFFERCOUNT]; - const FrameResources& GetFrameResources() const { return frames[GetFrameCount() % BUFFERCOUNT]; } - FrameResources& GetFrameResources() { return frames[GetFrameCount() % BUFFERCOUNT]; } + const FrameResources& GetFrameResources() const { return frames[GetBufferIndex()]; } + FrameResources& GetFrameResources() { return frames[GetBufferIndex()]; } struct CommandListMetadata { @@ -286,10 +269,10 @@ namespace wiGraphics bool dirty_pso[COMMANDLIST_COUNT] = {}; void pso_validate(CommandList cmd); - void barrier_flush(CommandList cmd); void predraw(CommandList cmd); void predispatch(CommandList cmd); + std::atomic cmd_count{ 0 }; std::vector common_samplers; @@ -319,10 +302,6 @@ namespace wiGraphics void WriteTopLevelAccelerationStructureInstance(const RaytracingAccelerationStructureDesc::TopLevel::Instance* instance, void* dest) const override; void WriteShaderIdentifier(const RaytracingPipelineState* rtpso, uint32_t group_index, void* dest) const override; - void Map(const GPUResource* resource, Mapping* mapping) const override; - void Unmap(const GPUResource* resource) const override; - void QueryRead(const GPUQueryHeap* heap, uint32_t index, uint32_t count, uint64_t* results) const override; - void SetCommonSampler(const StaticSampler* sam) override; void SetName(GPUResource* pResource, const char* name) override; @@ -345,14 +324,12 @@ namespace wiGraphics void RenderPassEnd(CommandList cmd) override; void BindScissorRects(uint32_t numRects, const Rect* rects, CommandList cmd) override; void BindViewports(uint32_t NumViewports, const Viewport *pViewports, CommandList cmd) override; - void BindResource(SHADERSTAGE stage, const GPUResource* resource, uint32_t slot, CommandList cmd, int subresource = -1) override; - void BindResources(SHADERSTAGE stage, const GPUResource *const* resources, uint32_t slot, uint32_t count, CommandList cmd) override; - void BindUAV(SHADERSTAGE stage, const GPUResource* resource, uint32_t slot, CommandList cmd, int subresource = -1) override; - void BindUAVs(SHADERSTAGE stage, const GPUResource *const* resources, uint32_t slot, uint32_t count, CommandList cmd) override; - void UnbindResources(uint32_t slot, uint32_t num, CommandList cmd) override; - void UnbindUAVs(uint32_t slot, uint32_t num, CommandList cmd) override; - void BindSampler(SHADERSTAGE stage, const Sampler* sampler, uint32_t slot, CommandList cmd) override; - void BindConstantBuffer(SHADERSTAGE stage, const GPUBuffer* buffer, uint32_t slot, CommandList cmd) override; + void BindResource(const GPUResource* resource, uint32_t slot, CommandList cmd, int subresource = -1) override; + void BindResources(const GPUResource *const* resources, uint32_t slot, uint32_t count, CommandList cmd) override; + void BindUAV(const GPUResource* resource, uint32_t slot, CommandList cmd, int subresource = -1) override; + void BindUAVs(const GPUResource *const* resources, uint32_t slot, uint32_t count, CommandList cmd) override; + void BindSampler(const Sampler* sampler, uint32_t slot, CommandList cmd) override; + void BindConstantBuffer(const GPUBuffer* buffer, uint32_t slot, CommandList cmd, uint64_t offset = 0ull) override; void BindVertexBuffers(const GPUBuffer *const* vertexBuffers, uint32_t slot, uint32_t count, const uint32_t* strides, const uint32_t* offsets, CommandList cmd) override; void BindIndexBuffer(const GPUBuffer* indexBuffer, const INDEXBUFFER_FORMAT format, uint32_t offset, CommandList cmd) override; void BindStencilRef(uint32_t value, CommandList cmd) override; @@ -371,17 +348,17 @@ namespace wiGraphics void DispatchMesh(uint32_t threadGroupCountX, uint32_t threadGroupCountY, uint32_t threadGroupCountZ, CommandList cmd) override; void DispatchMeshIndirect(const GPUBuffer* args, uint32_t args_offset, CommandList cmd) override; void CopyResource(const GPUResource* pDst, const GPUResource* pSrc, CommandList cmd) override; - void UpdateBuffer(const GPUBuffer* buffer, const void* data, CommandList cmd, int dataSize = -1) override; + void CopyBuffer(const GPUBuffer* pDst, uint64_t dst_offset, const GPUBuffer* pSrc, uint64_t src_offset, uint64_t size, CommandList cmd) override; void QueryBegin(const GPUQueryHeap* heap, uint32_t index, CommandList cmd) override; void QueryEnd(const GPUQueryHeap* heap, uint32_t index, CommandList cmd) override; + void QueryResolve(const GPUQueryHeap* heap, uint32_t index, uint32_t count, const GPUBuffer* dest, uint64_t dest_offset, CommandList cmd) override; + void QueryReset(const GPUQueryHeap* heap, uint32_t index, uint32_t count, CommandList cmd) override; void Barrier(const GPUBarrier* barriers, uint32_t numBarriers, CommandList cmd) override; void BuildRaytracingAccelerationStructure(const RaytracingAccelerationStructure* dst, CommandList cmd, const RaytracingAccelerationStructure* src = nullptr) override; void BindRaytracingPipelineState(const RaytracingPipelineState* rtpso, CommandList cmd) override; void DispatchRays(const DispatchRaysDesc* desc, CommandList cmd) override; void PushConstants(const void* data, uint32_t size, CommandList cmd) override; - GPUAllocation AllocateGPU(size_t dataSize, CommandList cmd) override; - void EventBegin(const char* name, CommandList cmd) override; void EventEnd(CommandList cmd) override; void SetMarker(const char* name, CommandList cmd) override; @@ -486,7 +463,6 @@ namespace wiGraphics locker.unlock(); } }; - BindlessDescriptorHeap bindlessUniformBuffers; BindlessDescriptorHeap bindlessSampledImages; BindlessDescriptorHeap bindlessUniformTexelBuffers; BindlessDescriptorHeap bindlessStorageBuffers; @@ -521,7 +497,6 @@ namespace wiGraphics ~AllocationHandler() { - bindlessUniformBuffers.destroy(device); bindlessSampledImages.destroy(device); bindlessUniformTexelBuffers.destroy(device); bindlessStorageBuffers.destroy(device); @@ -741,7 +716,6 @@ namespace wiGraphics { int index= destroyer_bindlessUniformBuffers.front().first; destroyer_bindlessUniformBuffers.pop_front(); - bindlessUniformBuffers.free(index); } else { diff --git a/WickedEngine/wiHairParticle.cpp b/WickedEngine/wiHairParticle.cpp index badbf8bc6..c879c1c37 100644 --- a/WickedEngine/wiHairParticle.cpp +++ b/WickedEngine/wiHairParticle.cpp @@ -48,111 +48,168 @@ void wiHairParticle::UpdateCPU(const TransformComponent& transform, const MeshCo aabb = AABB(_min, _max); aabb = aabb.transform(world); - if (dt > 0) + GraphicsDevice* device = wiRenderer::GetDevice(); + + if (_flags & REBUILD_BUFFERS || !cb.IsValid() || (strandCount * segmentCount) != simulationBuffer.GetDesc().ByteWidth / sizeof(PatchSimulationData)) { - GraphicsDevice* device = wiRenderer::GetDevice(); + _flags &= ~REBUILD_BUFFERS; + regenerate_frame = true; - if (_flags & REBUILD_BUFFERS || !cb.IsValid() || (strandCount * segmentCount) != particleBuffer.GetDesc().ByteWidth / sizeof(Patch)) + GPUBufferDesc bd; + bd.Usage = USAGE_DEFAULT; + bd.BindFlags = BIND_SHADER_RESOURCE | BIND_UNORDERED_ACCESS; + bd.MiscFlags = RESOURCE_MISC_BUFFER_STRUCTURED; + + if (strandCount * segmentCount > 0) { - _flags &= ~REBUILD_BUFFERS; - regenerate_frame = true; + bd.StructureByteStride = sizeof(PatchSimulationData); + bd.ByteWidth = bd.StructureByteStride * strandCount * segmentCount; + device->CreateBuffer(&bd, nullptr, &simulationBuffer); + device->SetName(&simulationBuffer, "simulationBuffer"); + + bd.MiscFlags = RESOURCE_MISC_BUFFER_RAW; + bd.StructureByteStride = sizeof(MeshComponent::Vertex_POS); + bd.ByteWidth = bd.StructureByteStride * 4 * strandCount * segmentCount; + device->CreateBuffer(&bd, nullptr, &vertexBuffer_POS[0]); + device->SetName(&vertexBuffer_POS[0], "vertexBuffer_POS[0]"); + device->CreateBuffer(&bd, nullptr, &vertexBuffer_POS[1]); + device->SetName(&vertexBuffer_POS[1], "vertexBuffer_POS[1]"); + + bd.StructureByteStride = sizeof(MeshComponent::Vertex_TEX); + bd.ByteWidth = bd.StructureByteStride * 4 * strandCount * segmentCount; + device->CreateBuffer(&bd, nullptr, &vertexBuffer_TEX); + device->SetName(&vertexBuffer_TEX, "vertexBuffer_TEX"); - GPUBufferDesc bd; - bd.Usage = USAGE_DEFAULT; bd.BindFlags = BIND_SHADER_RESOURCE | BIND_UNORDERED_ACCESS; - bd.CPUAccessFlags = 0; - bd.MiscFlags = RESOURCE_MISC_BUFFER_STRUCTURED; - - if (strandCount*segmentCount > 0) - { - bd.StructureByteStride = sizeof(Patch); - bd.ByteWidth = bd.StructureByteStride * strandCount * segmentCount; - device->CreateBuffer(&bd, nullptr, &particleBuffer); - - bd.StructureByteStride = sizeof(PatchSimulationData); - bd.ByteWidth = bd.StructureByteStride * strandCount * segmentCount; - device->CreateBuffer(&bd, nullptr, &simulationBuffer); - - bd.StructureByteStride = sizeof(uint); - bd.ByteWidth = bd.StructureByteStride * strandCount * segmentCount; - device->CreateBuffer(&bd, nullptr, &culledIndexBuffer); - } - - bd.Usage = USAGE_DEFAULT; - bd.ByteWidth = sizeof(HairParticleCB); - bd.BindFlags = BIND_CONSTANT_BUFFER; - bd.CPUAccessFlags = 0; - bd.MiscFlags = 0; - device->CreateBuffer(&bd, nullptr, &cb); - - if (vertex_lengths.size() != mesh.vertex_positions.size()) - { - vertex_lengths.resize(mesh.vertex_positions.size()); - std::fill(vertex_lengths.begin(), vertex_lengths.end(), 1.0f); - } - - indices.clear(); - for (size_t j = 0; j < mesh.indices.size(); j += 3) - { - const uint32_t triangle[] = { - mesh.indices[j + 0], - mesh.indices[j + 1], - mesh.indices[j + 2], - }; - if (vertex_lengths[triangle[0]] > 0 || vertex_lengths[triangle[1]] > 0 || vertex_lengths[triangle[2]] > 0) - { - indices.push_back(triangle[0]); - indices.push_back(triangle[1]); - indices.push_back(triangle[2]); - } - } - - if (!vertex_lengths.empty()) - { - std::vector ulengths; - ulengths.reserve(vertex_lengths.size()); - for (auto& x : vertex_lengths) - { - ulengths.push_back(uint8_t(wiMath::Clamp(x, 0, 1) * 255.0f)); - } - - bd.MiscFlags = 0; - bd.BindFlags = BIND_SHADER_RESOURCE; - bd.Format = FORMAT_R8_UNORM; - bd.StructureByteStride = sizeof(uint8_t); - bd.ByteWidth = bd.StructureByteStride * (uint32_t)ulengths.size(); - SubresourceData initData; - initData.pSysMem = ulengths.data(); - device->CreateBuffer(&bd, &initData, &vertexBuffer_length); - } - if (!indices.empty()) - { - bd.MiscFlags = 0; - bd.BindFlags = BIND_SHADER_RESOURCE; - bd.Format = FORMAT_R32_UINT; - bd.StructureByteStride = sizeof(uint32_t); - bd.ByteWidth = bd.StructureByteStride * (uint32_t)indices.size(); - SubresourceData initData; - initData.pSysMem = indices.data(); - device->CreateBuffer(&bd, &initData, &indexBuffer); - } + bd.MiscFlags = RESOURCE_MISC_NONE; + bd.Format = FORMAT_R32_UINT; + bd.StructureByteStride = sizeof(uint); + bd.ByteWidth = bd.StructureByteStride * 6 * strandCount * segmentCount; + device->CreateBuffer(&bd, nullptr, &primitiveBuffer); + device->SetName(&primitiveBuffer, "primitiveBuffer"); + bd.BindFlags = BIND_INDEX_BUFFER | BIND_UNORDERED_ACCESS; + bd.MiscFlags = RESOURCE_MISC_NONE; + bd.Format = FORMAT_R32_UINT; + bd.StructureByteStride = sizeof(uint); + bd.ByteWidth = bd.StructureByteStride * 6 * strandCount * segmentCount; + device->CreateBuffer(&bd, nullptr, &culledIndexBuffer); + device->SetName(&culledIndexBuffer, "culledIndexBuffer"); } - if (!indirectBuffer.IsValid()) + bd.Usage = USAGE_DEFAULT; + bd.ByteWidth = sizeof(HairParticleCB); + bd.BindFlags = BIND_CONSTANT_BUFFER; + bd.MiscFlags = RESOURCE_MISC_NONE; + device->CreateBuffer(&bd, nullptr, &cb); + + if (vertex_lengths.size() != mesh.vertex_positions.size()) { - GPUBufferDesc desc; - desc.ByteWidth = sizeof(uint) + sizeof(IndirectDrawArgsInstanced); // counter + draw args - desc.MiscFlags = RESOURCE_MISC_BUFFER_ALLOW_RAW_VIEWS | RESOURCE_MISC_INDIRECT_ARGS; - desc.BindFlags = BIND_UNORDERED_ACCESS; - device->CreateBuffer(&desc, nullptr, &indirectBuffer); + vertex_lengths.resize(mesh.vertex_positions.size()); + std::fill(vertex_lengths.begin(), vertex_lengths.end(), 1.0f); + } + + indices.clear(); + for (size_t j = 0; j < mesh.indices.size(); j += 3) + { + const uint32_t triangle[] = { + mesh.indices[j + 0], + mesh.indices[j + 1], + mesh.indices[j + 2], + }; + if (vertex_lengths[triangle[0]] > 0 || vertex_lengths[triangle[1]] > 0 || vertex_lengths[triangle[2]] > 0) + { + indices.push_back(triangle[0]); + indices.push_back(triangle[1]); + indices.push_back(triangle[2]); + } + } + + if (!vertex_lengths.empty()) + { + std::vector ulengths; + ulengths.reserve(vertex_lengths.size()); + for (auto& x : vertex_lengths) + { + ulengths.push_back(uint8_t(wiMath::Clamp(x, 0, 1) * 255.0f)); + } + + bd.MiscFlags = RESOURCE_MISC_NONE; + bd.BindFlags = BIND_SHADER_RESOURCE; + bd.Format = FORMAT_R8_UNORM; + bd.StructureByteStride = sizeof(uint8_t); + bd.ByteWidth = bd.StructureByteStride * (uint32_t)ulengths.size(); + SubresourceData initData; + initData.pSysMem = ulengths.data(); + device->CreateBuffer(&bd, &initData, &vertexBuffer_length); + } + if (!indices.empty()) + { + bd.MiscFlags = RESOURCE_MISC_NONE; + bd.BindFlags = BIND_SHADER_RESOURCE; + bd.Format = FORMAT_R32_UINT; + bd.StructureByteStride = sizeof(uint32_t); + bd.ByteWidth = bd.StructureByteStride * (uint32_t)indices.size(); + SubresourceData initData; + initData.pSysMem = indices.data(); + device->CreateBuffer(&bd, &initData, &indexBuffer); + } + + if (device->CheckCapability(GRAPHICSDEVICE_CAPABILITY_RAYTRACING)) + { + RaytracingAccelerationStructureDesc desc; + desc.type = RaytracingAccelerationStructureDesc::BOTTOMLEVEL; + desc._flags |= RaytracingAccelerationStructureDesc::FLAG_ALLOW_UPDATE; + desc._flags |= RaytracingAccelerationStructureDesc::FLAG_PREFER_FAST_BUILD; + + desc.bottomlevel.geometries.emplace_back(); + auto& geometry = desc.bottomlevel.geometries.back(); + geometry.type = RaytracingAccelerationStructureDesc::BottomLevel::Geometry::TRIANGLES; + geometry.triangles.vertexBuffer = vertexBuffer_POS[0]; + geometry.triangles.indexBuffer = primitiveBuffer; + geometry.triangles.indexFormat = INDEXFORMAT_32BIT; + geometry.triangles.indexCount = primitiveBuffer.desc.ByteWidth / primitiveBuffer.desc.StructureByteStride; + geometry.triangles.indexOffset = 0; + geometry.triangles.vertexCount = vertexBuffer_POS[0].desc.ByteWidth / vertexBuffer_POS[0].desc.StructureByteStride; + geometry.triangles.vertexFormat = FORMAT_R32G32B32_FLOAT; + geometry.triangles.vertexStride = sizeof(MeshComponent::Vertex_POS); + + bool success = device->CreateRaytracingAccelerationStructure(&desc, &BLAS); + assert(success); + device->SetName(&BLAS, "BLAS_hair"); } } + if (!indirectBuffer.IsValid()) + { + GPUBufferDesc desc; + desc.ByteWidth = sizeof(uint) + sizeof(IndirectDrawArgsIndexedInstanced); // counter + draw args + desc.MiscFlags = RESOURCE_MISC_BUFFER_RAW | RESOURCE_MISC_INDIRECT_ARGS; + desc.BindFlags = BIND_UNORDERED_ACCESS; + device->CreateBuffer(&desc, nullptr, &indirectBuffer); + } + + if (!subsetBuffer.IsValid()) + { + GPUBufferDesc desc; + desc.StructureByteStride = sizeof(ShaderMeshSubset); + desc.ByteWidth = desc.StructureByteStride; + desc.MiscFlags = RESOURCE_MISC_BUFFER_RAW; + desc.BindFlags = BIND_SHADER_RESOURCE; + device->CreateBuffer(&desc, nullptr, &subsetBuffer); + } + + std::swap(vertexBuffer_POS[0], vertexBuffer_POS[1]); + + if (BLAS.IsValid() && !BLAS.desc.bottomlevel.geometries.empty()) + { + BLAS.desc.bottomlevel.geometries.back().triangles.vertexBuffer = vertexBuffer_POS[0]; + } + } -void wiHairParticle::UpdateGPU(const MeshComponent& mesh, const MaterialComponent& material, CommandList cmd) const +void wiHairParticle::UpdateGPU(uint32_t instanceIndex, uint32_t materialIndex, const MeshComponent& mesh, const MaterialComponent& material, CommandList cmd) const { - if (strandCount == 0 || !particleBuffer.IsValid()) + if (strandCount == 0 || !simulationBuffer.IsValid()) { return; } @@ -165,10 +222,8 @@ void wiHairParticle::UpdateGPU(const MeshComponent& mesh, const MaterialComponen { desc = material.textures[MaterialComponent::BASECOLORMAP].resource->texture.GetDesc(); } - HairParticleCB hcb; - hcb.xWorld = world; - hcb.xColor = material.baseColor; + hcb.xHairWorld = world; hcb.xHairRegenerate = regenerate_frame ? 1 : 0; hcb.xLength = length; hcb.xStiffness = stiffness; @@ -188,31 +243,48 @@ void wiHairParticle::UpdateGPU(const MeshComponent& mesh, const MaterialComponen hcb.xHairTexMul = float2(1.0f / (float)hcb.xHairFramesXY.x, 1.0f / (float)hcb.xHairFramesXY.y); hcb.xHairAspect = (float)std::max(1u, desc.Width) / (float)std::max(1u, desc.Height); hcb.xHairLayerMask = layerMask; + hcb.xHairInstanceIndex = instanceIndex; device->UpdateBuffer(&cb, &hcb, cmd); + ShaderMeshSubset subset; + subset.init(); + subset.indexOffset = 0; + subset.materialIndex = materialIndex; + device->UpdateBuffer(&subsetBuffer, &subset, cmd); + + { + GPUBarrier barriers[] = { + GPUBarrier::Buffer(&cb, RESOURCE_STATE_COPY_DST, RESOURCE_STATE_CONSTANT_BUFFER), + GPUBarrier::Buffer(&subsetBuffer, RESOURCE_STATE_COPY_DST, RESOURCE_STATE_SHADER_RESOURCE), + }; + device->Barrier(barriers, arraysize(barriers), cmd); + } + // Simulate: { device->BindComputeShader(&cs_simulate, cmd); - device->BindConstantBuffer(CS, &cb, CB_GETBINDSLOT(HairParticleCB), cmd); + device->BindConstantBuffer(&cb, CB_GETBINDSLOT(HairParticleCB), cmd); const GPUResource* uavs[] = { - &particleBuffer, &simulationBuffer, + &vertexBuffer_POS[0], + &vertexBuffer_TEX, + &primitiveBuffer, &culledIndexBuffer, &indirectBuffer }; - device->BindUAVs(CS, uavs, 0, arraysize(uavs), cmd); + device->BindUAVs(uavs, 0, arraysize(uavs), cmd); const GPUResource* res[] = { indexBuffer.IsValid() ? &indexBuffer : &mesh.indexBuffer, mesh.streamoutBuffer_POS.IsValid() ? &mesh.streamoutBuffer_POS : &mesh.vertexBuffer_POS, &vertexBuffer_length }; - device->BindResources(CS, res, TEXSLOT_ONDEMAND0, arraysize(res), cmd); + device->BindResources(res, TEXSLOT_ONDEMAND0, arraysize(res), cmd); { GPUBarrier barriers[] = { - GPUBarrier::Buffer(&mesh.indexBuffer, BUFFER_STATE_INDEX_BUFFER, BUFFER_STATE_SHADER_RESOURCE), + GPUBarrier::Buffer(&mesh.indexBuffer, RESOURCE_STATE_INDEX_BUFFER, RESOURCE_STATE_SHADER_RESOURCE), }; device->Barrier(barriers, arraysize(barriers), cmd); } @@ -224,8 +296,6 @@ void wiHairParticle::UpdateGPU(const MeshComponent& mesh, const MaterialComponen }; device->Barrier(barriers, arraysize(barriers), cmd); - device->UnbindUAVs(0, arraysize(uavs), cmd); - device->UnbindResources(TEXSLOT_ONDEMAND0, arraysize(res), cmd); } // Finish update (reset counter, create indirect draw args): @@ -235,24 +305,25 @@ void wiHairParticle::UpdateGPU(const MeshComponent& mesh, const MaterialComponen const GPUResource* uavs[] = { &indirectBuffer }; - device->BindUAVs(CS, uavs, 0, arraysize(uavs), cmd); + device->BindUAVs(uavs, 0, arraysize(uavs), cmd); device->Dispatch(1, 1, 1, cmd); GPUBarrier barriers[] = { GPUBarrier::Memory(), - GPUBarrier::Buffer(&indirectBuffer, BUFFER_STATE_UNORDERED_ACCESS, BUFFER_STATE_INDIRECT_ARGUMENT), - GPUBarrier::Buffer(&culledIndexBuffer, BUFFER_STATE_UNORDERED_ACCESS, BUFFER_STATE_SHADER_RESOURCE), - GPUBarrier::Buffer(&particleBuffer, BUFFER_STATE_UNORDERED_ACCESS, BUFFER_STATE_SHADER_RESOURCE), + GPUBarrier::Buffer(&indirectBuffer, RESOURCE_STATE_UNORDERED_ACCESS, RESOURCE_STATE_INDIRECT_ARGUMENT), + GPUBarrier::Buffer(&vertexBuffer_POS[0], RESOURCE_STATE_UNORDERED_ACCESS, RESOURCE_STATE_SHADER_RESOURCE), + GPUBarrier::Buffer(&vertexBuffer_TEX, RESOURCE_STATE_UNORDERED_ACCESS, RESOURCE_STATE_SHADER_RESOURCE), + GPUBarrier::Buffer(&primitiveBuffer, RESOURCE_STATE_UNORDERED_ACCESS, RESOURCE_STATE_SHADER_RESOURCE), + GPUBarrier::Buffer(&culledIndexBuffer, RESOURCE_STATE_UNORDERED_ACCESS, RESOURCE_STATE_INDEX_BUFFER), }; device->Barrier(barriers, arraysize(barriers), cmd); - device->UnbindUAVs(0, arraysize(uavs), cmd); } { GPUBarrier barriers[] = { - GPUBarrier::Buffer(&mesh.indexBuffer, BUFFER_STATE_SHADER_RESOURCE, BUFFER_STATE_INDEX_BUFFER), + GPUBarrier::Buffer(&mesh.indexBuffer, RESOURCE_STATE_SHADER_RESOURCE, RESOURCE_STATE_INDEX_BUFFER), }; device->Barrier(barriers, arraysize(barriers), cmd); } @@ -262,7 +333,7 @@ void wiHairParticle::UpdateGPU(const MeshComponent& mesh, const MaterialComponen regenerate_frame = false; } -void wiHairParticle::Draw(const CameraComponent& camera, const MaterialComponent& material, RENDERPASS renderPass, CommandList cmd) const +void wiHairParticle::Draw(const MaterialComponent& material, RENDERPASS renderPass, CommandList cmd) const { if (strandCount == 0 || !cb.IsValid()) { @@ -281,36 +352,24 @@ void wiHairParticle::Draw(const CameraComponent& camera, const MaterialComponent return; } device->BindPipelineState(&PSO_wire, cmd); - device->BindResource(VS, wiTextureHelper::getWhite(), TEXSLOT_ONDEMAND0, cmd); + device->BindResource(wiTextureHelper::getWhite(), TEXSLOT_ONDEMAND0, cmd); } else { device->BindPipelineState(&PSO[renderPass], cmd); - if (material.textures[MaterialComponent::BASECOLORMAP].resource == nullptr) - { - device->BindResource(PS, wiTextureHelper::getWhite(), TEXSLOT_ONDEMAND0, cmd); - device->BindResource(VS, wiTextureHelper::getWhite(), TEXSLOT_ONDEMAND0, cmd); - } - else - { - device->BindResource(PS, material.textures[MaterialComponent::BASECOLORMAP].GetGPUResource(), TEXSLOT_ONDEMAND0, cmd); - device->BindResource(VS, material.textures[MaterialComponent::BASECOLORMAP].GetGPUResource(), TEXSLOT_ONDEMAND0, cmd); - } - if (renderPass != RENDERPASS_PREPASS) // depth only alpha test will be full res { device->BindShadingRate(material.shadingRate, cmd); } } - device->BindConstantBuffer(VS, &cb, CB_GETBINDSLOT(HairParticleCB), cmd); - device->BindConstantBuffer(PS, &material.constantBuffer, CB_GETBINDSLOT(MaterialCB), cmd); + device->BindConstantBuffer(&cb, CB_GETBINDSLOT(HairParticleCB), cmd); + device->BindResource(&primitiveBuffer, 0, cmd); - device->BindResource(VS, &particleBuffer, 0, cmd); - device->BindResource(VS, &culledIndexBuffer, 1, cmd); + device->BindIndexBuffer(&culledIndexBuffer, INDEXFORMAT_32BIT, 0, cmd); - device->DrawInstancedIndirect(&indirectBuffer, 4, cmd); + device->DrawIndexedInstancedIndirect(&indirectBuffer, 4, cmd); device->EventEnd(cmd); } @@ -398,7 +457,7 @@ namespace wiHairParticle_Internal desc.bs = &bs; desc.rs = &ncrs; desc.dss = &dss_default; - desc.pt = TRIANGLESTRIP; + desc.pt = TRIANGLELIST; switch (i) { @@ -422,7 +481,7 @@ namespace wiHairParticle_Internal desc.bs = &bs; desc.rs = &wirers; desc.dss = &dss_default; - desc.pt = TRIANGLESTRIP; + desc.pt = TRIANGLELIST; device->CreatePipelineState(&desc, &PSO_wire); } diff --git a/WickedEngine/wiHairParticle.h b/WickedEngine/wiHairParticle.h index e7ca4b284..851b1679b 100644 --- a/WickedEngine/wiHairParticle.h +++ b/WickedEngine/wiHairParticle.h @@ -15,20 +15,24 @@ namespace wiScene class wiHairParticle { -private: +public: wiGraphics::GPUBuffer cb; - wiGraphics::GPUBuffer particleBuffer; wiGraphics::GPUBuffer simulationBuffer; + wiGraphics::GPUBuffer vertexBuffer_POS[2]; + wiGraphics::GPUBuffer vertexBuffer_TEX; + wiGraphics::GPUBuffer primitiveBuffer; wiGraphics::GPUBuffer culledIndexBuffer; wiGraphics::GPUBuffer indirectBuffer; + wiGraphics::GPUBuffer subsetBuffer; wiGraphics::GPUBuffer indexBuffer; wiGraphics::GPUBuffer vertexBuffer_length; -public: + + wiGraphics::RaytracingAccelerationStructure BLAS; void UpdateCPU(const TransformComponent& transform, const MeshComponent& mesh, float dt); - void UpdateGPU(const MeshComponent& mesh, const MaterialComponent& material, wiGraphics::CommandList cmd) const; - void Draw(const CameraComponent& camera, const MaterialComponent& material, RENDERPASS renderPass, wiGraphics::CommandList cmd) const; + void UpdateGPU(uint32_t instanceIndex, uint32_t materialIndex, const MeshComponent& mesh, const MaterialComponent& material, wiGraphics::CommandList cmd) const; + void Draw(const MaterialComponent& material, RENDERPASS renderPass, wiGraphics::CommandList cmd) const; enum FLAGS { diff --git a/WickedEngine/wiHelper.cpp b/WickedEngine/wiHelper.cpp index 9d15b02bb..de68a734f 100644 --- a/WickedEngine/wiHelper.cpp +++ b/WickedEngine/wiHelper.cpp @@ -113,49 +113,28 @@ namespace wiHelper Texture stagingTex; TextureDesc staging_desc = desc; - staging_desc.Usage = USAGE_STAGING; - staging_desc.CPUAccessFlags = CPU_ACCESS_READ; - staging_desc.BindFlags = 0; - staging_desc.MiscFlags = 0; + staging_desc.Usage = USAGE_READBACK; staging_desc.MipLevels = 1; - staging_desc.layout = IMAGE_LAYOUT_COPY_DST; + staging_desc.layout = RESOURCE_STATE_COPY_DST; bool success = device->CreateTexture(&staging_desc, nullptr, &stagingTex); assert(success); CommandList cmd = device->BeginCommandList(); - { - GPUBarrier barriers[] = { - GPUBarrier::Image(&texture, texture.desc.layout, IMAGE_LAYOUT_COPY_SRC, 0) - }; - device->Barrier(barriers, arraysize(barriers), cmd); - } - device->CopyResource(&stagingTex, &texture, cmd); - { - GPUBarrier barriers[] = { - GPUBarrier::Image(&texture, IMAGE_LAYOUT_COPY_SRC, texture.desc.layout, 0) - }; - device->Barrier(barriers, arraysize(barriers), cmd); - } - device->SubmitCommandLists(); device->WaitForGPU(); - Mapping mapping; - mapping._flags = Mapping::FLAG_READ; - mapping.size = data_size; - device->Map(&stagingTex, &mapping); - if (mapping.data != nullptr) + if (stagingTex.mapped_data != nullptr) { - if (mapping.rowpitch / data_stride != desc.Width) + if (stagingTex.mapped_rowpitch / data_stride != desc.Width) { // Copy padded texture row by row: const uint32_t cpysize = desc.Width * data_stride; for (uint32_t i = 0; i < desc.Height; ++i) { - void* src = (void*)((size_t)mapping.data + size_t(i * mapping.rowpitch)); + void* src = (void*)((size_t)stagingTex.mapped_data + size_t(i * stagingTex.mapped_rowpitch)); void* dst = (void*)((size_t)texturedata.data() + size_t(i * cpysize)); memcpy(dst, src, cpysize); } @@ -163,16 +142,15 @@ namespace wiHelper else { // Copy whole - std::memcpy(texturedata.data(), mapping.data, texturedata.size()); + std::memcpy(texturedata.data(), stagingTex.mapped_data, texturedata.size()); } - device->Unmap(&stagingTex); } else { assert(0); } - return mapping.data != nullptr; + return stagingTex.mapped_data != nullptr; } bool saveTextureToMemoryFile(const wiGraphics::Texture& texture, const std::string& fileExtension, std::vector& filedata) diff --git a/WickedEngine/wiImage.cpp b/WickedEngine/wiImage.cpp index 99946d895..8760151ba 100644 --- a/WickedEngine/wiImage.cpp +++ b/WickedEngine/wiImage.cpp @@ -18,15 +18,10 @@ namespace wiImage enum IMAGE_SHADER { IMAGE_SHADER_STANDARD, - IMAGE_SHADER_SEPARATENORMALMAP, - IMAGE_SHADER_MASKED, - IMAGE_SHADER_BACKGROUND, - IMAGE_SHADER_BACKGROUND_MASKED, IMAGE_SHADER_FULLSCREEN, IMAGE_SHADER_COUNT }; - GPUBuffer constantBuffer; Shader vertexShader; Shader screenVS; Shader imagePS[IMAGE_SHADER_COUNT]; @@ -96,36 +91,46 @@ namespace wiImage sampler = wiRenderer::GetSampler(SSLOT_ANISO_CLAMP); } - if (device->CheckCapability(GRAPHICSDEVICE_CAPABILITY_BINDLESS_DESCRIPTORS)) + PushConstantsImage push; + push.texture_base_index = device->GetDescriptorIndex(texture, SRV); + push.texture_mask_index = device->GetDescriptorIndex(params.maskMap, SRV); + if (params.isBackgroundEnabled()) { - PushConstantsImage push; - push.texture_base_index = device->GetDescriptorIndex(texture, SRV); - push.texture_mask_index = device->GetDescriptorIndex(params.maskMap, SRV); push.texture_background_index = device->GetDescriptorIndex(&backgroundTextures[cmd], SRV); - push.sampler_index = device->GetDescriptorIndex(sampler); - device->PushConstants(&push, sizeof(push), cmd); } else { - device->BindResource(PS, texture, TEXSLOT_IMAGE_BASE, cmd); - device->BindResource(PS, params.maskMap, TEXSLOT_IMAGE_MASK, cmd); - device->BindResource(PS, &backgroundTextures[cmd], TEXSLOT_IMAGE_BACKGROUND, cmd); - device->BindSampler(PS, sampler, SSLOT_ONDEMAND0, cmd); + push.texture_background_index = -1; } + push.sampler_index = device->GetDescriptorIndex(sampler); - ImageCB cb; - cb.xColor = params.color; + XMFLOAT4 color = params.color; const float darken = 1 - params.fade; - cb.xColor.x *= darken; - cb.xColor.y *= darken; - cb.xColor.z *= darken; - cb.xColor.w *= params.opacity; + color.x *= darken; + color.y *= darken; + color.z *= darken; + color.w *= params.opacity; + + XMHALF4 packed_color; + packed_color.x = XMConvertFloatToHalf(color.x); + packed_color.y = XMConvertFloatToHalf(color.y); + packed_color.z = XMConvertFloatToHalf(color.z); + packed_color.w = XMConvertFloatToHalf(color.w); + + push.packed_color.x = uint(packed_color.v); + push.packed_color.y = uint(packed_color.v >> 32ull); + + push.flags = 0; + if (params.isExtractNormalMapEnabled()) + { + push.flags |= IMAGE_FLAG_EXTRACT_NORMALMAP; + } if (params.isFullScreenEnabled()) { + // Full screen image uses a fast path with full screen triangle and no effects device->BindPipelineState(&imagePSO[IMAGE_SHADER_FULLSCREEN][params.blendFlag][params.stencilComp][params.stencilRefMode], cmd); - device->UpdateBuffer(&constantBuffer, &cb, cmd); - device->BindConstantBuffer(PS, &constantBuffer, CB_GETBINDSLOT(ImageCB), cmd); + device->PushConstants(&push, sizeof(push), cmd); device->Draw(3, 0, cmd); device->EventEnd(cmd); return; @@ -161,13 +166,13 @@ namespace wiImage { XMVECTOR V = XMVectorSet(params.corners[i].x - params.pivot.x, params.corners[i].y - params.pivot.y, 0, 1); V = XMVector2Transform(V, M); // division by w will happen on GPU - XMStoreFloat4(&cb.xCorners[i], V); + XMStoreFloat4(&push.corners[i], V); } if (params.isMirrorEnabled()) { - std::swap(cb.xCorners[0], cb.xCorners[1]); - std::swap(cb.xCorners[2], cb.xCorners[3]); + std::swap(push.corners[0], push.corners[1]); + std::swap(push.corners[2], push.corners[3]); } const TextureDesc& desc = texture->GetDesc(); @@ -176,73 +181,35 @@ namespace wiImage if (params.isDrawRectEnabled()) { - cb.xTexMulAdd.x = params.drawRect.z * inv_width; // drawRec.width: mul - cb.xTexMulAdd.y = params.drawRect.w * inv_height; // drawRec.heigh: mul - cb.xTexMulAdd.z = params.drawRect.x * inv_width; // drawRec.x: add - cb.xTexMulAdd.w = params.drawRect.y * inv_height; // drawRec.y: add + push.texMulAdd.x = params.drawRect.z * inv_width; // drawRec.width: mul + push.texMulAdd.y = params.drawRect.w * inv_height; // drawRec.heigh: mul + push.texMulAdd.z = params.drawRect.x * inv_width; // drawRec.x: add + push.texMulAdd.w = params.drawRect.y * inv_height; // drawRec.y: add } else { - cb.xTexMulAdd = XMFLOAT4(1, 1, 0, 0); // disabled draw rect + push.texMulAdd = XMFLOAT4(1, 1, 0, 0); // disabled draw rect } - cb.xTexMulAdd.z += params.texOffset.x * inv_width; // texOffset.x: add - cb.xTexMulAdd.w += params.texOffset.y * inv_height; // texOffset.y: add + push.texMulAdd.z += params.texOffset.x * inv_width; // texOffset.x: add + push.texMulAdd.w += params.texOffset.y * inv_height; // texOffset.y: add if (params.isDrawRect2Enabled()) { - cb.xTexMulAdd2.x = params.drawRect2.z * inv_width; // drawRec.width: mul - cb.xTexMulAdd2.y = params.drawRect2.w * inv_height; // drawRec.heigh: mul - cb.xTexMulAdd2.z = params.drawRect2.x * inv_width; // drawRec.x: add - cb.xTexMulAdd2.w = params.drawRect2.y * inv_height; // drawRec.y: add + push.texMulAdd2.x = params.drawRect2.z * inv_width; // drawRec.width: mul + push.texMulAdd2.y = params.drawRect2.w * inv_height; // drawRec.heigh: mul + push.texMulAdd2.z = params.drawRect2.x * inv_width; // drawRec.x: add + push.texMulAdd2.w = params.drawRect2.y * inv_height; // drawRec.y: add } else { - cb.xTexMulAdd2 = XMFLOAT4(1, 1, 0, 0); // disabled draw rect + push.texMulAdd2 = XMFLOAT4(1, 1, 0, 0); // disabled draw rect } - cb.xTexMulAdd2.z += params.texOffset2.x * inv_width; // texOffset.x: add - cb.xTexMulAdd2.w += params.texOffset2.y * inv_height; // texOffset.y: add + push.texMulAdd2.z += params.texOffset2.x * inv_width; // texOffset.x: add + push.texMulAdd2.w += params.texOffset2.y * inv_height; // texOffset.y: add - device->UpdateBuffer(&constantBuffer, &cb, cmd); + device->BindPipelineState(&imagePSO[IMAGE_SHADER_STANDARD][params.blendFlag][params.stencilComp][params.stencilRefMode], cmd); - // Determine relevant image rendering pixel shader: - IMAGE_SHADER targetShader; - const bool NormalmapSeparate = params.isExtractNormalMapEnabled(); - const bool Mask = params.maskMap != nullptr; - const bool background_blur = params.isBackgroundEnabled(); - if (NormalmapSeparate) - { - targetShader = IMAGE_SHADER_SEPARATENORMALMAP; - } - else - { - if (Mask) - { - if (background_blur) - { - targetShader = IMAGE_SHADER_BACKGROUND_MASKED; - } - else - { - targetShader = IMAGE_SHADER_MASKED; - } - } - else - { - if (background_blur) - { - targetShader = IMAGE_SHADER_BACKGROUND; - } - else - { - targetShader = IMAGE_SHADER_STANDARD; - } - } - } - - device->BindPipelineState(&imagePSO[targetShader][params.blendFlag][params.stencilComp][params.stencilRefMode], cmd); - - device->BindConstantBuffer(VS, &constantBuffer, CB_GETBINDSLOT(ImageCB), cmd); - device->BindConstantBuffer(PS, &constantBuffer, CB_GETBINDSLOT(ImageCB), cmd); + device->PushConstants(&push, sizeof(push), cmd); device->Draw(4, 0, cmd); @@ -258,10 +225,6 @@ namespace wiImage wiRenderer::LoadShader(VS, screenVS, "screenVS.cso"); wiRenderer::LoadShader(PS, imagePS[IMAGE_SHADER_STANDARD], "imagePS.cso"); - wiRenderer::LoadShader(PS, imagePS[IMAGE_SHADER_SEPARATENORMALMAP], "imagePS_separatenormalmap.cso"); - wiRenderer::LoadShader(PS, imagePS[IMAGE_SHADER_MASKED], "imagePS_masked.cso"); - wiRenderer::LoadShader(PS, imagePS[IMAGE_SHADER_BACKGROUND], "imagePS_backgroundblur.cso"); - wiRenderer::LoadShader(PS, imagePS[IMAGE_SHADER_BACKGROUND_MASKED], "imagePS_backgroundblur_masked.cso"); wiRenderer::LoadShader(PS, imagePS[IMAGE_SHADER_FULLSCREEN], "screenPS.cso"); @@ -303,15 +266,6 @@ namespace wiImage { GraphicsDevice* device = wiRenderer::GetDevice(); - { - GPUBufferDesc bd; - bd.Usage = USAGE_DYNAMIC; - bd.ByteWidth = sizeof(ImageCB); - bd.BindFlags = BIND_CONSTANT_BUFFER; - bd.CPUAccessFlags = CPU_ACCESS_WRITE; - device->CreateBuffer(&bd, nullptr, &constantBuffer); - } - RasterizerState rs; rs.FillMode = FILL_SOLID; rs.CullMode = CULL_NONE; diff --git a/WickedEngine/wiOcean.cpp b/WickedEngine/wiOcean.cpp index 3e5d47526..93a715dbf 100644 --- a/WickedEngine/wiOcean.cpp +++ b/WickedEngine/wiOcean.cpp @@ -21,7 +21,6 @@ namespace wiOcean_Internal Shader wireframePS; Shader oceanSurfPS; - GPUBuffer shadingCB; RasterizerState rasterizerState; RasterizerState wireRS; DepthStencilState depthStencilState; @@ -126,7 +125,6 @@ void wiOcean::Create(const OceanParameters& params) GPUBufferDesc buf_desc; buf_desc.Usage = USAGE_DEFAULT; buf_desc.BindFlags = BIND_UNORDERED_ACCESS | BIND_SHADER_RESOURCE; - buf_desc.CPUAccessFlags = 0; buf_desc.MiscFlags = RESOURCE_MISC_BUFFER_STRUCTURED; SubresourceData init_data; @@ -167,7 +165,6 @@ void wiOcean::Create(const OceanParameters& params) tex_desc.SampleCount = 1; tex_desc.Usage = USAGE_DEFAULT; tex_desc.BindFlags = BIND_SHADER_RESOURCE | BIND_UNORDERED_ACCESS; - tex_desc.CPUAccessFlags = 0; tex_desc.Format = FORMAT_R16G16B16A16_FLOAT; tex_desc.MipLevels = 0; @@ -200,17 +197,12 @@ void wiOcean::Create(const OceanParameters& params) init_cb0.pSysMem = &immutable_consts; GPUBufferDesc cb_desc; - cb_desc.Usage = USAGE_IMMUTABLE; cb_desc.BindFlags = BIND_CONSTANT_BUFFER; - cb_desc.CPUAccessFlags = 0; - cb_desc.MiscFlags = 0; cb_desc.ByteWidth = sizeof(Ocean_Simulation_ImmutableCB); device->CreateBuffer(&cb_desc, &init_cb0, &immutableCB); cb_desc.Usage = USAGE_DEFAULT; cb_desc.BindFlags = BIND_CONSTANT_BUFFER; - cb_desc.CPUAccessFlags = 0; - cb_desc.MiscFlags = 0; cb_desc.ByteWidth = sizeof(Ocean_Simulation_PerFrameCB); device->CreateBuffer(&cb_desc, nullptr, &perFrameCB); } @@ -277,19 +269,32 @@ void wiOcean::UpdateDisplacementMap(const OceanParameters& params, CommandList c &buffer_Float2_H0, &buffer_Float_Omega }; - device->BindResources(CS, cs0_srvs, TEXSLOT_ONDEMAND0, arraysize(cs0_srvs), cmd); + device->BindResources(cs0_srvs, TEXSLOT_ONDEMAND0, arraysize(cs0_srvs), cmd); const GPUResource* cs0_uavs[1] = { &buffer_Float2_Ht }; - device->BindUAVs(CS, cs0_uavs, 0, arraysize(cs0_uavs), cmd); + device->BindUAVs(cs0_uavs, 0, arraysize(cs0_uavs), cmd); Ocean_Simulation_PerFrameCB perFrameData; perFrameData.g_TimeScale = params.time_scale; perFrameData.g_ChoppyScale = params.choppy_scale; perFrameData.g_GridLen = params.dmap_dim / params.patch_length; - device->UpdateBuffer(&perFrameCB, &perFrameData, cmd); - device->BindConstantBuffer(CS, &immutableCB, CB_GETBINDSLOT(Ocean_Simulation_ImmutableCB), cmd); - device->BindConstantBuffer(CS, &perFrameCB, CB_GETBINDSLOT(Ocean_Simulation_PerFrameCB), cmd); + { + GPUBarrier barriers[] = { + GPUBarrier::Buffer(&perFrameCB, RESOURCE_STATE_CONSTANT_BUFFER, RESOURCE_STATE_COPY_DST), + }; + device->Barrier(barriers, arraysize(barriers), cmd); + } + device->UpdateBuffer(&perFrameCB, &perFrameData, cmd); + { + GPUBarrier barriers[] = { + GPUBarrier::Buffer(&perFrameCB, RESOURCE_STATE_COPY_DST, RESOURCE_STATE_CONSTANT_BUFFER), + }; + device->Barrier(barriers, arraysize(barriers), cmd); + } + + device->BindConstantBuffer(&immutableCB, CB_GETBINDSLOT(Ocean_Simulation_ImmutableCB), cmd); + device->BindConstantBuffer(&perFrameCB, CB_GETBINDSLOT(Ocean_Simulation_PerFrameCB), cmd); // Run the CS uint32_t group_count_x = (params.dmap_dim + OCEAN_COMPUTE_TILESIZE - 1) / OCEAN_COMPUTE_TILESIZE; @@ -300,8 +305,6 @@ void wiOcean::UpdateDisplacementMap(const OceanParameters& params, CommandList c }; device->Barrier(barriers, arraysize(barriers), cmd); - device->UnbindUAVs(0, 1, cmd); - device->UnbindResources(TEXSLOT_ONDEMAND0, 2, cmd); // ------------------------------------ Perform FFT ------------------------------------------- @@ -309,31 +312,29 @@ void wiOcean::UpdateDisplacementMap(const OceanParameters& params, CommandList c - device->BindConstantBuffer(CS, &immutableCB, CB_GETBINDSLOT(Ocean_Simulation_ImmutableCB), cmd); - device->BindConstantBuffer(CS, &perFrameCB, CB_GETBINDSLOT(Ocean_Simulation_PerFrameCB), cmd); + device->BindConstantBuffer(&immutableCB, CB_GETBINDSLOT(Ocean_Simulation_ImmutableCB), cmd); + device->BindConstantBuffer(&perFrameCB, CB_GETBINDSLOT(Ocean_Simulation_PerFrameCB), cmd); // Update displacement map: device->BindComputeShader(&updateDisplacementMapCS, cmd); const GPUResource* cs_uavs[] = { &displacementMap }; - device->BindUAVs(CS, cs_uavs, 0, 1, cmd); + device->BindUAVs(cs_uavs, 0, 1, cmd); const GPUResource* cs_srvs[1] = { &buffer_Float_Dxyz }; - device->BindResources(CS, cs_srvs, TEXSLOT_ONDEMAND0, 1, cmd); + device->BindResources(cs_srvs, TEXSLOT_ONDEMAND0, 1, cmd); device->Dispatch(params.dmap_dim / OCEAN_COMPUTE_TILESIZE, params.dmap_dim / OCEAN_COMPUTE_TILESIZE, 1, cmd); device->Barrier(barriers, arraysize(barriers), cmd); // Update gradient map: device->BindComputeShader(&updateGradientFoldingCS, cmd); cs_uavs[0] = { &gradientMap }; - device->BindUAVs(CS, cs_uavs, 0, 1, cmd); + device->BindUAVs(cs_uavs, 0, 1, cmd); cs_srvs[0] = &displacementMap; - device->BindResources(CS, cs_srvs, TEXSLOT_ONDEMAND0, 1, cmd); + device->BindResources(cs_srvs, TEXSLOT_ONDEMAND0, 1, cmd); device->Dispatch(params.dmap_dim / OCEAN_COMPUTE_TILESIZE, params.dmap_dim / OCEAN_COMPUTE_TILESIZE, 1, cmd); device->Barrier(barriers, arraysize(barriers), cmd); // Unbind - device->UnbindUAVs(0, 1, cmd); - device->UnbindResources(TEXSLOT_ONDEMAND0, 1, cmd); wiRenderer::GenerateMipChain(gradientMap, wiRenderer::MIPGENFILTER_LINEAR, cmd); @@ -371,13 +372,10 @@ void wiOcean::Render(const CameraComponent& camera, const OceanParameters& param cb.xOceanWaterHeight = params.waterHeight; cb.xOceanSurfaceDisplacementTolerance = std::max(1.0f, params.surfaceDisplacementTolerance); - device->UpdateBuffer(&shadingCB, &cb, cmd); + device->BindDynamicConstantBuffer(cb, CB_GETBINDSLOT(Ocean_RenderCB), cmd); - device->BindConstantBuffer(VS, &shadingCB, CB_GETBINDSLOT(Ocean_RenderCB), cmd); - device->BindConstantBuffer(PS, &shadingCB, CB_GETBINDSLOT(Ocean_RenderCB), cmd); - - device->BindResource(VS, &displacementMap, TEXSLOT_ONDEMAND0, cmd); - device->BindResource(PS, &gradientMap, TEXSLOT_ONDEMAND1, cmd); + device->BindResource(&displacementMap, TEXSLOT_ONDEMAND0, cmd); + device->BindResource(&gradientMap, TEXSLOT_ONDEMAND1, cmd); device->Draw(dim.x*dim.y*6, 0, cmd); @@ -390,15 +388,6 @@ void wiOcean::Initialize() GraphicsDevice* device = wiRenderer::GetDevice(); - GPUBufferDesc cb_desc; - cb_desc.Usage = USAGE_DYNAMIC; - cb_desc.CPUAccessFlags = CPU_ACCESS_WRITE; - cb_desc.ByteWidth = sizeof(Ocean_RenderCB); - cb_desc.StructureByteStride = 0; - cb_desc.BindFlags = BIND_CONSTANT_BUFFER; - device->CreateBuffer(&cb_desc, nullptr, &shadingCB); - - RasterizerState ras_desc; ras_desc.FillMode = FILL_SOLID; ras_desc.CullMode = CULL_NONE; diff --git a/WickedEngine/wiPhysicsEngine_Bullet.cpp b/WickedEngine/wiPhysicsEngine_Bullet.cpp index 48f624c11..01d7133c2 100644 --- a/WickedEngine/wiPhysicsEngine_Bullet.cpp +++ b/WickedEngine/wiPhysicsEngine_Bullet.cpp @@ -425,15 +425,6 @@ namespace wiPhysicsEngine const ArmatureComponent* armature = mesh.IsSkinned() ? scene.armatures.GetComponent(mesh.armatureID) : nullptr; mesh.SetDynamic(true); - if (!mesh.vertexBuffer_PRE.IsValid()) - { - using namespace wiGraphics; - GraphicsDevice* device = wiRenderer::GetDevice(); - device->CreateBuffer(&mesh.vertexBuffer_POS.desc, nullptr, &mesh.streamoutBuffer_POS); - device->CreateBuffer(&mesh.vertexBuffer_POS.desc, nullptr, &mesh.vertexBuffer_PRE); - device->CreateBuffer(&mesh.vertexBuffer_TAN.desc, nullptr, &mesh.streamoutBuffer_TAN); - } - if (physicscomponent._flags & SoftBodyPhysicsComponent::FORCE_RESET) { physicscomponent._flags &= ~SoftBodyPhysicsComponent::FORCE_RESET; diff --git a/WickedEngine/wiPlatform.h b/WickedEngine/wiPlatform.h index 80d0508fc..da6cd5a84 100644 --- a/WickedEngine/wiPlatform.h +++ b/WickedEngine/wiPlatform.h @@ -8,6 +8,7 @@ #ifdef _WIN32 +#define NOMINMAX #define WIN32_LEAN_AND_MEAN #include #include diff --git a/WickedEngine/wiProfiler.cpp b/WickedEngine/wiProfiler.cpp index c9ff27bb1..72eae13d2 100644 --- a/WickedEngine/wiProfiler.cpp +++ b/WickedEngine/wiProfiler.cpp @@ -24,7 +24,7 @@ namespace wiProfiler range_id cpu_frame; range_id gpu_frame; GPUQueryHeap queryHeap[wiGraphics::GraphicsDevice::GetBufferCount() + 1]; - std::vector queryResults; + GPUBuffer queryResultBuffer[arraysize(queryHeap)]; std::atomic nextQuery{ 0 }; uint32_t writtenQueries[arraysize(queryHeap)] = {}; int queryheap_idx = 0; @@ -58,21 +58,38 @@ namespace wiProfiler ranges.reserve(100); + GraphicsDevice* device = wiRenderer::GetDevice(); + GPUQueryHeapDesc desc; desc.type = GPU_QUERY_TYPE_TIMESTAMP; desc.queryCount = 1024; + + GPUBufferDesc bd; + bd.Usage = USAGE_READBACK; + bd.ByteWidth = desc.queryCount * sizeof(uint64_t); + for (int i = 0; i < arraysize(queryHeap); ++i) { - bool success = wiRenderer::GetDevice()->CreateQueryHeap(&desc, &queryHeap[i]); + bool success = device->CreateQueryHeap(&desc, &queryHeap[i]); + assert(success); + + success = device->CreateBuffer(&bd, nullptr, &queryResultBuffer[i]); assert(success); } - - queryResults.resize(desc.queryCount); } cpu_frame = BeginRangeCPU("CPU Frame"); - CommandList cmd = wiRenderer::GetDevice()->BeginCommandList(); + GraphicsDevice* device = wiRenderer::GetDevice(); + CommandList cmd = device->BeginCommandList(); + + device->QueryReset( + &queryHeap[queryheap_idx], + 0, + queryHeap[queryheap_idx].desc.queryCount, + cmd + ); + gpu_frame = BeginRangeGPU("GPU Frame", cmd); } void EndFrame(CommandList cmd) @@ -91,15 +108,19 @@ namespace wiProfiler double gpu_frequency = (double)device->GetTimestampFrequency() / 1000.0; - device->QueryResolve(&queryHeap[queryheap_idx], 0, nextQuery.load(), cmd); + device->QueryResolve( + &queryHeap[queryheap_idx], + 0, + nextQuery.load(), + &queryResultBuffer[queryheap_idx], + 0ull, + cmd + ); writtenQueries[queryheap_idx] = nextQuery.load(); nextQuery.store(0); queryheap_idx = (queryheap_idx + 1) % arraysize(queryHeap); - if (writtenQueries[queryheap_idx] > 0) - { - wiRenderer::GetDevice()->QueryRead(&queryHeap[queryheap_idx], 0, writtenQueries[queryheap_idx], queryResults.data()); - } + uint64_t* queryResults = (uint64_t*)queryResultBuffer[queryheap_idx].mapped_data; for (auto& x : ranges) { @@ -114,7 +135,7 @@ namespace wiProfiler { int begin_query = range.gpuBegin[queryheap_idx]; int end_query = range.gpuEnd[queryheap_idx]; - if (begin_query >= 0 && end_query >= 0) + if (queryResultBuffer[queryheap_idx].mapped_data != nullptr && begin_query >= 0 && end_query >= 0) { uint64_t begin_result = queryResults[begin_query]; uint64_t end_result = queryResults[end_query]; diff --git a/WickedEngine/wiRenderer.cpp b/WickedEngine/wiRenderer.cpp index 661421821..de13be786 100644 --- a/WickedEngine/wiRenderer.cpp +++ b/WickedEngine/wiRenderer.cpp @@ -22,11 +22,9 @@ #include "wiShaderCompiler.h" #include "shaders/ShaderInterop_Postprocess.h" -#include "shaders/ShaderInterop_Skinning.h" #include "shaders/ShaderInterop_Raytracing.h" #include "shaders/ShaderInterop_BVH.h" -#include "shaders/ShaderInterop_Utility.h" -#include "shaders/ShaderInterop_Paint.h" +#include "shaders/ShaderInterop_SurfelGI.h" #include #include @@ -64,6 +62,15 @@ inline LinearAllocator& GetRenderFrameAllocator(CommandList cmd) return renderFrameAllocators[cmd]; } +std::vector barrier_stack[COMMANDLIST_COUNT]; +void barrier_stack_flush(CommandList cmd) +{ + if (barrier_stack[cmd].empty()) + return; + device->Barrier(barrier_stack[cmd].data(), (uint32_t)barrier_stack[cmd].size(), cmd); + barrier_stack[cmd].clear(); +} + float GAMMA = 2.2f; uint32_t SHADOWRES_2D = 1024; uint32_t SHADOWRES_CUBE = 256; @@ -83,18 +90,20 @@ bool voxelHelper = false; bool advancedLightCulling = true; bool variableRateShadingClassification = false; bool variableRateShadingClassificationDebug = false; -bool ldsSkinningEnabled = true; float GameSpeed = 1; bool debugLightCulling = false; bool occlusionCulling = false; bool temporalAA = false; bool temporalAADEBUG = false; -uint32_t raytraceBounceCount = 2; +uint32_t raytraceBounceCount = 3; bool raytraceDebugVisualizer = false; bool raytracedShadows = false; bool tessellationEnabled = true; bool disableAlbedoMaps = false; +bool forceDiffuseLighting = false; bool SCREENSPACESHADOWS = false; +bool SURFELGI = false; +bool SURFELGI_DEBUG = false; struct VoxelizedSceneData @@ -351,87 +360,6 @@ struct RenderQueue } }; -struct Instance -{ - XMFLOAT4 mat0; - XMFLOAT4 mat1; - XMFLOAT4 mat2; - XMUINT4 userdata; - - inline void Create( - const XMFLOAT4X4& matIn, - const XMFLOAT4& colorIn = XMFLOAT4(1, 1, 1, 1), - float dither = 0, - uint32_t subInstance = 0, - const XMFLOAT4& emissiveColor = XMFLOAT4(1, 1, 1, 1) - ) volatile - { - mat0.x = matIn._11; - mat0.y = matIn._21; - mat0.z = matIn._31; - mat0.w = matIn._41; - - mat1.x = matIn._12; - mat1.y = matIn._22; - mat1.z = matIn._32; - mat1.w = matIn._42; - - mat2.x = matIn._13; - mat2.y = matIn._23; - mat2.z = matIn._33; - mat2.w = matIn._43; - - XMFLOAT4 color = colorIn; - color.w *= 1 - dither; - userdata.x = wiMath::CompressColor(color); - userdata.y = subInstance; - - userdata.z = wiMath::CompressColor(emissiveColor); - userdata.w = 0; - } -}; -struct InstancePrev -{ - XMFLOAT4 mat0; - XMFLOAT4 mat1; - XMFLOAT4 mat2; - - inline void Create(const XMFLOAT4X4& matIn) volatile - { - mat0.x = matIn._11; - mat0.y = matIn._21; - mat0.z = matIn._31; - mat0.w = matIn._41; - - mat1.x = matIn._12; - mat1.y = matIn._22; - mat1.z = matIn._32; - mat1.w = matIn._42; - - mat2.x = matIn._13; - mat2.y = matIn._23; - mat2.z = matIn._33; - mat2.w = matIn._43; - } -}; -struct InstanceAtlas -{ - XMFLOAT4 atlasMulAdd; - - InstanceAtlas(){} - InstanceAtlas(const XMFLOAT4& atlasRemap) - { - Create(atlasRemap); - } - inline void Create(const XMFLOAT4& atlasRemap) volatile - { - atlasMulAdd.x = atlasRemap.x; - atlasMulAdd.y = atlasRemap.y; - atlasMulAdd.z = atlasRemap.z; - atlasMulAdd.w = atlasRemap.w; - } -}; - const Sampler* GetSampler(int slot) { @@ -510,49 +438,6 @@ const std::vector& GetCustomShaders() } -ILTYPES GetILTYPE(RENDERPASS renderPass, bool tessellation, bool alphatest, bool transparent) -{ - ILTYPES realVL = ILTYPE_OBJECT_POS_TEX; - - switch (renderPass) - { - case RENDERPASS_MAIN: - case RENDERPASS_ENVMAPCAPTURE: - case RENDERPASS_VOXELIZE: - realVL = ILTYPE_OBJECT_COMMON; - break; - case RENDERPASS_PREPASS: - if (tessellation) - { - realVL = ILTYPE_OBJECT_POS_PREVPOS_TEX; // tessellation needs tex because displacement mapping - } - else - { - if (alphatest) - { - realVL = ILTYPE_OBJECT_POS_PREVPOS_TEX; - } - else - { - realVL = ILTYPE_OBJECT_POS_PREVPOS; - } - } - break; - case RENDERPASS_SHADOW: - case RENDERPASS_SHADOWCUBE: - if (alphatest || transparent) - { - realVL = ILTYPE_OBJECT_POS_TEX; - } - else - { - realVL = ILTYPE_OBJECT_POS; - } - break; - } - - return realVL; -} SHADERTYPE GetVSTYPE(RENDERPASS renderPass, bool tessellation, bool alphatest, bool transparent) { SHADERTYPE realVS = VSTYPE_OBJECT_SIMPLE; @@ -811,20 +696,6 @@ PipelineState PSO_impostor_wire; PipelineState PSO_captureimpostor_albedo; PipelineState PSO_captureimpostor_normal; PipelineState PSO_captureimpostor_surface; -inline const PipelineState* GetImpostorPSO(RENDERPASS renderPass) -{ - if (IsWireRender()) - { - switch (renderPass) - { - case RENDERPASS_MAIN: - return &PSO_impostor_wire; - } - return nullptr; - } - - return &PSO_impostor[renderPass]; -} PipelineState PSO_lightvisualizer[LightComponent::LIGHTTYPE_COUNT]; PipelineState PSO_volumetriclight[LightComponent::LIGHTTYPE_COUNT]; @@ -850,7 +721,6 @@ enum SKYRENDERING SKYRENDERING_STATIC, SKYRENDERING_DYNAMIC, SKYRENDERING_SUN, - SKYRENDERING_VELOCITY, SKYRENDERING_ENVMAPCAPTURE_STATIC, SKYRENDERING_ENVMAPCAPTURE_DYNAMIC, SKYRENDERING_COUNT @@ -962,91 +832,28 @@ void LoadShaders() wiJobSystem::Execute(ctx, [](wiJobArgs args) { inputLayouts[ILTYPE_OBJECT_DEBUG].elements = { - { "POSITION_NORMAL_WIND", 0, MeshComponent::Vertex_POS::FORMAT, INPUT_SLOT_POSITION_NORMAL_WIND, InputLayout::APPEND_ALIGNED_ELEMENT, INPUT_PER_VERTEX_DATA }, + { "POSITION_NORMAL_WIND", 0, MeshComponent::Vertex_POS::FORMAT, 0, InputLayout::APPEND_ALIGNED_ELEMENT, INPUT_PER_VERTEX_DATA }, }; LoadShader(VS, shaders[VSTYPE_OBJECT_DEBUG], "objectVS_debug.cso"); }); wiJobSystem::Execute(ctx, [](wiJobArgs args) { - inputLayouts[ILTYPE_OBJECT_COMMON].elements = - { - { "POSITION_NORMAL_WIND", 0, MeshComponent::Vertex_POS::FORMAT, INPUT_SLOT_POSITION_NORMAL_WIND, InputLayout::APPEND_ALIGNED_ELEMENT, INPUT_PER_VERTEX_DATA }, - { "UVSET", 0, MeshComponent::Vertex_TEX::FORMAT, INPUT_SLOT_UV0, InputLayout::APPEND_ALIGNED_ELEMENT, INPUT_PER_VERTEX_DATA }, - { "UVSET", 1, MeshComponent::Vertex_TEX::FORMAT, INPUT_SLOT_UV1, InputLayout::APPEND_ALIGNED_ELEMENT, INPUT_PER_VERTEX_DATA }, - { "ATLAS", 0, MeshComponent::Vertex_TEX::FORMAT, INPUT_SLOT_ATLAS, InputLayout::APPEND_ALIGNED_ELEMENT, INPUT_PER_VERTEX_DATA }, - { "COLOR", 0, MeshComponent::Vertex_COL::FORMAT, INPUT_SLOT_COLOR, InputLayout::APPEND_ALIGNED_ELEMENT, INPUT_PER_VERTEX_DATA }, - { "TANGENT", 0, MeshComponent::Vertex_TAN::FORMAT, INPUT_SLOT_TANGENT, InputLayout::APPEND_ALIGNED_ELEMENT, INPUT_PER_VERTEX_DATA }, - - { "INSTANCEMATRIX", 0, FORMAT_R32G32B32A32_FLOAT, INPUT_SLOT_INSTANCEDATA, InputLayout::APPEND_ALIGNED_ELEMENT, INPUT_PER_INSTANCE_DATA }, - { "INSTANCEMATRIX", 1, FORMAT_R32G32B32A32_FLOAT, INPUT_SLOT_INSTANCEDATA, InputLayout::APPEND_ALIGNED_ELEMENT, INPUT_PER_INSTANCE_DATA }, - { "INSTANCEMATRIX", 2, FORMAT_R32G32B32A32_FLOAT, INPUT_SLOT_INSTANCEDATA, InputLayout::APPEND_ALIGNED_ELEMENT, INPUT_PER_INSTANCE_DATA }, - { "INSTANCEUSERDATA", 0, FORMAT_R32G32B32A32_UINT, INPUT_SLOT_INSTANCEDATA, InputLayout::APPEND_ALIGNED_ELEMENT, INPUT_PER_INSTANCE_DATA }, - { "INSTANCEATLAS", 0, FORMAT_R32G32B32A32_FLOAT, INPUT_SLOT_INSTANCEDATA, InputLayout::APPEND_ALIGNED_ELEMENT, INPUT_PER_INSTANCE_DATA }, - }; LoadShader(VS, shaders[VSTYPE_OBJECT_COMMON], "objectVS_common.cso"); }); wiJobSystem::Execute(ctx, [](wiJobArgs args) { - inputLayouts[ILTYPE_OBJECT_POS_PREVPOS].elements = - { - { "POSITION_NORMAL_WIND", 0, MeshComponent::Vertex_POS::FORMAT, INPUT_SLOT_POSITION_NORMAL_WIND, InputLayout::APPEND_ALIGNED_ELEMENT, INPUT_PER_VERTEX_DATA }, - { "PREVPOS", 0, MeshComponent::Vertex_POS::FORMAT, INPUT_SLOT_PREVPOS, InputLayout::APPEND_ALIGNED_ELEMENT, INPUT_PER_VERTEX_DATA }, - - { "INSTANCEMATRIX", 0, FORMAT_R32G32B32A32_FLOAT, INPUT_SLOT_INSTANCEDATA, InputLayout::APPEND_ALIGNED_ELEMENT, INPUT_PER_INSTANCE_DATA }, - { "INSTANCEMATRIX", 1, FORMAT_R32G32B32A32_FLOAT, INPUT_SLOT_INSTANCEDATA, InputLayout::APPEND_ALIGNED_ELEMENT, INPUT_PER_INSTANCE_DATA }, - { "INSTANCEMATRIX", 2, FORMAT_R32G32B32A32_FLOAT, INPUT_SLOT_INSTANCEDATA, InputLayout::APPEND_ALIGNED_ELEMENT, INPUT_PER_INSTANCE_DATA }, - { "INSTANCEUSERDATA", 0, FORMAT_R32G32B32A32_UINT, INPUT_SLOT_INSTANCEDATA, InputLayout::APPEND_ALIGNED_ELEMENT, INPUT_PER_INSTANCE_DATA }, - { "INSTANCEMATRIXPREV", 0, FORMAT_R32G32B32A32_FLOAT, INPUT_SLOT_INSTANCEDATA, InputLayout::APPEND_ALIGNED_ELEMENT, INPUT_PER_INSTANCE_DATA }, - { "INSTANCEMATRIXPREV", 1, FORMAT_R32G32B32A32_FLOAT, INPUT_SLOT_INSTANCEDATA, InputLayout::APPEND_ALIGNED_ELEMENT, INPUT_PER_INSTANCE_DATA }, - { "INSTANCEMATRIXPREV", 2, FORMAT_R32G32B32A32_FLOAT, INPUT_SLOT_INSTANCEDATA, InputLayout::APPEND_ALIGNED_ELEMENT, INPUT_PER_INSTANCE_DATA }, - }; LoadShader(VS, shaders[VSTYPE_OBJECT_PREPASS], "objectVS_prepass.cso"); }); wiJobSystem::Execute(ctx, [](wiJobArgs args) { - inputLayouts[ILTYPE_OBJECT_POS_PREVPOS_TEX].elements = - { - { "POSITION_NORMAL_WIND", 0, MeshComponent::Vertex_POS::FORMAT, INPUT_SLOT_POSITION_NORMAL_WIND, InputLayout::APPEND_ALIGNED_ELEMENT, INPUT_PER_VERTEX_DATA }, - { "PREVPOS", 0, MeshComponent::Vertex_POS::FORMAT, INPUT_SLOT_PREVPOS, InputLayout::APPEND_ALIGNED_ELEMENT, INPUT_PER_VERTEX_DATA }, - { "UVSET", 0, MeshComponent::Vertex_TEX::FORMAT, INPUT_SLOT_UV0, InputLayout::APPEND_ALIGNED_ELEMENT, INPUT_PER_VERTEX_DATA }, - { "UVSET", 1, MeshComponent::Vertex_TEX::FORMAT, INPUT_SLOT_UV1, InputLayout::APPEND_ALIGNED_ELEMENT, INPUT_PER_VERTEX_DATA }, - - { "INSTANCEMATRIX", 0, FORMAT_R32G32B32A32_FLOAT, INPUT_SLOT_INSTANCEDATA, InputLayout::APPEND_ALIGNED_ELEMENT, INPUT_PER_INSTANCE_DATA }, - { "INSTANCEMATRIX", 1, FORMAT_R32G32B32A32_FLOAT, INPUT_SLOT_INSTANCEDATA, InputLayout::APPEND_ALIGNED_ELEMENT, INPUT_PER_INSTANCE_DATA }, - { "INSTANCEMATRIX", 2, FORMAT_R32G32B32A32_FLOAT, INPUT_SLOT_INSTANCEDATA, InputLayout::APPEND_ALIGNED_ELEMENT, INPUT_PER_INSTANCE_DATA }, - { "INSTANCEUSERDATA", 0, FORMAT_R32G32B32A32_UINT, INPUT_SLOT_INSTANCEDATA, InputLayout::APPEND_ALIGNED_ELEMENT, INPUT_PER_INSTANCE_DATA }, - { "INSTANCEMATRIXPREV", 0, FORMAT_R32G32B32A32_FLOAT, INPUT_SLOT_INSTANCEDATA, InputLayout::APPEND_ALIGNED_ELEMENT, INPUT_PER_INSTANCE_DATA }, - { "INSTANCEMATRIXPREV", 1, FORMAT_R32G32B32A32_FLOAT, INPUT_SLOT_INSTANCEDATA, InputLayout::APPEND_ALIGNED_ELEMENT, INPUT_PER_INSTANCE_DATA }, - { "INSTANCEMATRIXPREV", 2, FORMAT_R32G32B32A32_FLOAT, INPUT_SLOT_INSTANCEDATA, InputLayout::APPEND_ALIGNED_ELEMENT, INPUT_PER_INSTANCE_DATA }, - }; LoadShader(VS, shaders[VSTYPE_OBJECT_PREPASS_ALPHATEST], "objectVS_prepass_alphatest.cso"); }); wiJobSystem::Execute(ctx, [](wiJobArgs args) { - inputLayouts[ILTYPE_OBJECT_POS].elements = - { - { "POSITION_NORMAL_WIND", 0, MeshComponent::Vertex_POS::FORMAT, INPUT_SLOT_POSITION_NORMAL_WIND, InputLayout::APPEND_ALIGNED_ELEMENT, INPUT_PER_VERTEX_DATA }, - - { "INSTANCEMATRIX", 0, FORMAT_R32G32B32A32_FLOAT, INPUT_SLOT_INSTANCEDATA, InputLayout::APPEND_ALIGNED_ELEMENT, INPUT_PER_INSTANCE_DATA }, - { "INSTANCEMATRIX", 1, FORMAT_R32G32B32A32_FLOAT, INPUT_SLOT_INSTANCEDATA, InputLayout::APPEND_ALIGNED_ELEMENT, INPUT_PER_INSTANCE_DATA }, - { "INSTANCEMATRIX", 2, FORMAT_R32G32B32A32_FLOAT, INPUT_SLOT_INSTANCEDATA, InputLayout::APPEND_ALIGNED_ELEMENT, INPUT_PER_INSTANCE_DATA }, - { "INSTANCEUSERDATA", 0, FORMAT_R32G32B32A32_UINT, INPUT_SLOT_INSTANCEDATA, InputLayout::APPEND_ALIGNED_ELEMENT, INPUT_PER_INSTANCE_DATA }, - }; LoadShader(VS, shaders[VSTYPE_SHADOW], "shadowVS.cso"); }); wiJobSystem::Execute(ctx, [](wiJobArgs args) { - inputLayouts[ILTYPE_OBJECT_POS_TEX].elements = - { - { "POSITION_NORMAL_WIND", 0, MeshComponent::Vertex_POS::FORMAT, INPUT_SLOT_POSITION_NORMAL_WIND, InputLayout::APPEND_ALIGNED_ELEMENT, INPUT_PER_VERTEX_DATA }, - { "UVSET", 0, MeshComponent::Vertex_TEX::FORMAT, INPUT_SLOT_UV0, InputLayout::APPEND_ALIGNED_ELEMENT, INPUT_PER_VERTEX_DATA }, - { "UVSET", 1, MeshComponent::Vertex_TEX::FORMAT, INPUT_SLOT_UV1, InputLayout::APPEND_ALIGNED_ELEMENT, INPUT_PER_VERTEX_DATA }, - - { "INSTANCEMATRIX", 0, FORMAT_R32G32B32A32_FLOAT, INPUT_SLOT_INSTANCEDATA, InputLayout::APPEND_ALIGNED_ELEMENT, INPUT_PER_INSTANCE_DATA }, - { "INSTANCEMATRIX", 1, FORMAT_R32G32B32A32_FLOAT, INPUT_SLOT_INSTANCEDATA, InputLayout::APPEND_ALIGNED_ELEMENT, INPUT_PER_INSTANCE_DATA }, - { "INSTANCEMATRIX", 2, FORMAT_R32G32B32A32_FLOAT, INPUT_SLOT_INSTANCEDATA, InputLayout::APPEND_ALIGNED_ELEMENT, INPUT_PER_INSTANCE_DATA }, - { "INSTANCEUSERDATA", 0, FORMAT_R32G32B32A32_UINT, INPUT_SLOT_INSTANCEDATA, InputLayout::APPEND_ALIGNED_ELEMENT, INPUT_PER_INSTANCE_DATA }, - }; LoadShader(VS, shaders[VSTYPE_OBJECT_SIMPLE], "objectVS_simple.cso"); LoadShader(VS, shaders[VSTYPE_SHADOW_ALPHATEST], "shadowVS_alphatest.cso"); LoadShader(VS, shaders[VSTYPE_SHADOW_TRANSPARENT], "shadowVS_transparent.cso"); @@ -1161,7 +968,6 @@ void LoadShaders() wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(PS, shaders[PSTYPE_VERTEXCOLOR], "vertexcolorPS.cso"); }); wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(PS, shaders[PSTYPE_SKY_STATIC], "skyPS_static.cso"); }); wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(PS, shaders[PSTYPE_SKY_DYNAMIC], "skyPS_dynamic.cso"); }); - wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(PS, shaders[PSTYPE_SKY_VELOCITY], "skyPS_velocity.cso"); }); wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(PS, shaders[PSTYPE_SUN], "sunPS.cso"); }); wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(PS, shaders[PSTYPE_SHADOW_ALPHATEST], "shadowPS_alphatest.cso"); }); wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(PS, shaders[PSTYPE_SHADOW_TRANSPARENT], "shadowPS_transparent.cso"); }); @@ -1170,7 +976,7 @@ void LoadShaders() wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(PS, shaders[PSTYPE_VOXELIZER_TERRAIN], "objectPS_voxelizer_terrain.cso"); }); wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(PS, shaders[PSTYPE_VOXEL], "voxelPS.cso"); }); wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(PS, shaders[PSTYPE_FORCEFIELDVISUALIZER], "forceFieldVisualizerPS.cso"); }); - if (device->CheckCapability(GRAPHICSDEVICE_CAPABILITY_RAYTRACING_INLINE)) + if (device->CheckCapability(GRAPHICSDEVICE_CAPABILITY_RAYTRACING)) { wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(PS, shaders[PSTYPE_RENDERLIGHTMAP], "renderlightmapPS_rtapi.cso", SHADERMODEL_6_5); }); } @@ -1220,8 +1026,7 @@ void LoadShaders() wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_COPYTEXTURE2D_UNORM4_BORDEREXPAND], "copytexture2D_unorm4_borderexpandCS.cso"); }); wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_COPYTEXTURE2D_FLOAT4_BORDEREXPAND], "copytexture2D_float4_borderexpandCS.cso"); }); wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_SKINNING], "skinningCS.cso"); }); - wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_SKINNING_LDS], "skinningCS_LDS.cso"); }); - if (device->CheckCapability(GRAPHICSDEVICE_CAPABILITY_RAYTRACING_INLINE)) + if (device->CheckCapability(GRAPHICSDEVICE_CAPABILITY_RAYTRACING)) { wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_RAYTRACE], "raytraceCS_rtapi.cso", SHADERMODEL_6_5); }); } @@ -1296,7 +1101,6 @@ void LoadShaders() wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_POSTPROCESS_VOLUMETRICCLOUDS_TEMPORAL], "volumetricCloud_temporalCS.cso"); }); wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_POSTPROCESS_FXAA], "fxaaCS.cso"); }); wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_POSTPROCESS_TEMPORALAA], "temporalaaCS.cso"); }); - wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_POSTPROCESS_LINEARDEPTH], "lineardepthCS.cso"); }); wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_POSTPROCESS_SHARPEN], "sharpenCS.cso"); }); wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_POSTPROCESS_TONEMAP], "tonemapCS.cso"); }); wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_POSTPROCESS_FSR_UPSCALING], "fsr_upscalingCS.cso"); }); @@ -1311,7 +1115,7 @@ void LoadShaders() wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_POSTPROCESS_NORMALSFROMDEPTH], "normalsfromdepthCS.cso"); }); wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_POSTPROCESS_SCREENSPACESHADOW], "screenspaceshadowCS.cso"); }); - if (device->CheckCapability(GRAPHICSDEVICE_CAPABILITY_RAYTRACING_INLINE)) + if (device->CheckCapability(GRAPHICSDEVICE_CAPABILITY_RAYTRACING)) { wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_POSTPROCESS_RTSHADOW], "rtshadowCS.cso", SHADERMODEL_6_5); }); wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_POSTPROCESS_RTSHADOW_DENOISE_TILECLASSIFICATION], "rtshadow_denoise_tileclassificationCS.cso"); }); @@ -1324,6 +1128,25 @@ void LoadShaders() } + wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_SURFEL_COVERAGE], "surfel_coverageCS.cso"); }); + wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_SURFEL_INDIRECTPREPARE], "surfel_indirectprepareCS.cso"); }); + wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_SURFEL_UPDATE], "surfel_updateCS.cso"); }); + wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_SURFEL_GRIDRESET], "surfel_gridresetCS.cso"); }); + wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_SURFEL_GRIDOFFSETS], "surfel_gridoffsetsCS.cso"); }); + wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_SURFEL_BINNING], "surfel_binningCS.cso"); }); + wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_SURFEL_SHADE], "surfel_shadeCS.cso"); }); + if (device->CheckCapability(GRAPHICSDEVICE_CAPABILITY_RAYTRACING)) + { + wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_SURFEL_RAYTRACE], "surfel_raytraceCS_rtapi.cso", SHADERMODEL_6_5); }); + } + else + { + wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_SURFEL_RAYTRACE], "surfel_raytraceCS.cso"); }); + } + + wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_VISIBILITY_RESOLVE], "visibility_resolveCS.cso"); }); + wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_VISIBILITY_RESOLVE_MSAA], "visibility_resolveCS_MSAA.cso"); }); + wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(HS, shaders[HSTYPE_OBJECT], "objectHS.cso"); }); wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(HS, shaders[HSTYPE_OBJECT_PREPASS], "objectHS_prepass.cso"); }); wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(HS, shaders[HSTYPE_OBJECT_PREPASS_ALPHATEST], "objectHS_prepass_alphatest.cso"); }); @@ -1352,7 +1175,6 @@ void LoadShaders() { const bool transparency = blendMode != BLENDMODE_OPAQUE; SHADERTYPE realVS = GetVSTYPE((RENDERPASS)renderPass, tessellation, alphatest, transparency); - ILTYPES realVL = GetILTYPE((RENDERPASS)renderPass, tessellation, alphatest, transparency); SHADERTYPE realHS = GetHSTYPE((RENDERPASS)renderPass, tessellation, alphatest); SHADERTYPE realDS = GetDSTYPE((RENDERPASS)renderPass, tessellation, alphatest); SHADERTYPE realGS = GetGSTYPE((RENDERPASS)renderPass, alphatest, transparency); @@ -1364,18 +1186,12 @@ void LoadShaders() } PipelineStateDesc desc; - desc.il = realVL < ILTYPE_COUNT ? &inputLayouts[realVL] : nullptr; desc.vs = realVS < SHADERTYPE_COUNT ? &shaders[realVS] : nullptr; desc.hs = realHS < SHADERTYPE_COUNT ? &shaders[realHS] : nullptr; desc.ds = realDS < SHADERTYPE_COUNT ? &shaders[realDS] : nullptr; desc.gs = realGS < SHADERTYPE_COUNT ? &shaders[realGS] : nullptr; desc.ps = realPS < SHADERTYPE_COUNT ? &shaders[realPS] : nullptr; - if (device->CheckCapability(GRAPHICSDEVICE_CAPABILITY_BINDLESS_DESCRIPTORS)) - { - desc.il = nullptr; - } - switch (blendMode) { case BLENDMODE_OPAQUE: @@ -1488,13 +1304,11 @@ void LoadShaders() wiJobSystem::Dispatch(ctx, RENDERPASS_COUNT, 1, [](wiJobArgs args) { SHADERTYPE realVS = GetVSTYPE((RENDERPASS) args.jobIndex, false, false, false); - ILTYPES realVL = GetILTYPE((RENDERPASS)args.jobIndex, false, false, false); PipelineStateDesc desc; desc.rs = &rasterizers[RSTYPE_FRONT]; desc.bs = &blendStates[BSTYPE_OPAQUE]; desc.dss = &depthStencils[DSSTYPE_DEFAULT]; - desc.il = &inputLayouts[realVL]; desc.vs = &shaders[realVS]; switch (args.jobIndex) @@ -1535,11 +1349,9 @@ void LoadShaders() // Hologram sample shader will be registered as custom shader: wiJobSystem::Execute(ctx, [](wiJobArgs args) { SHADERTYPE realVS = GetVSTYPE(RENDERPASS_MAIN, false, false, true); - ILTYPES realVL = GetILTYPE(RENDERPASS_MAIN, false, false, true); PipelineStateDesc desc; desc.vs = &shaders[realVS]; - desc.il = &inputLayouts[realVL]; desc.ps = &shaders[PSTYPE_OBJECT_HOLOGRAM]; desc.bs = &blendStates[BSTYPE_ADDITIVE]; @@ -1565,12 +1377,6 @@ void LoadShaders() desc.rs = &rasterizers[RSTYPE_WIRE]; desc.bs = &blendStates[BSTYPE_OPAQUE]; desc.dss = &depthStencils[DSSTYPE_DEFAULT]; - desc.il = &inputLayouts[ILTYPE_OBJECT_POS_TEX]; - - if (device->CheckCapability(GRAPHICSDEVICE_CAPABILITY_BINDLESS_DESCRIPTORS)) - { - desc.il = nullptr; - } device->CreatePipelineState(&desc, &PSO_object_wire); @@ -1643,7 +1449,6 @@ void LoadShaders() desc.rs = &rasterizers[RSTYPE_DOUBLESIDED]; desc.bs = &blendStates[BSTYPE_OPAQUE]; desc.dss = &depthStencils[DSSTYPE_CAPTUREIMPOSTOR]; - desc.il = &inputLayouts[ILTYPE_OBJECT_COMMON]; desc.ps = &shaders[PSTYPE_CAPTUREIMPOSTOR_ALBEDO]; device->CreatePipelineState(&desc, &PSO_captureimpostor_albedo); @@ -1790,11 +1595,6 @@ void LoadShaders() desc.vs = &shaders[VSTYPE_SKY]; desc.ps = &shaders[PSTYPE_SUN]; break; - case SKYRENDERING_VELOCITY: - desc.bs = &blendStates[BSTYPE_OPAQUE]; - desc.vs = &shaders[VSTYPE_SKY]; - desc.ps = &shaders[PSTYPE_SKY_VELOCITY]; - break; case SKYRENDERING_ENVMAPCAPTURE_STATIC: desc.bs = &blendStates[BSTYPE_OPAQUE]; desc.vs = &shaders[VSTYPE_ENVMAP_SKY]; @@ -1887,7 +1687,6 @@ void LoadShaders() case DEBUGRENDERING_PAINTRADIUS: desc.vs = &shaders[VSTYPE_OBJECT_SIMPLE]; desc.ps = &shaders[PSTYPE_OBJECT_PAINTRADIUS]; - desc.il = &inputLayouts[ILTYPE_OBJECT_POS_TEX]; desc.dss = &depthStencils[DSSTYPE_DEPTHREAD]; desc.rs = &rasterizers[RSTYPE_FRONT]; desc.bs = &blendStates[BSTYPE_TRANSPARENT]; @@ -1931,8 +1730,7 @@ void LoadShaders() device->CreatePipelineState(&desc, &PSO_debug[args.jobIndex]); }); - if(device->CheckCapability(GRAPHICSDEVICE_CAPABILITY_RAYTRACING_PIPELINE) && - device->CheckCapability(GRAPHICSDEVICE_CAPABILITY_RAYTRACING_GEOMETRYINDEX)) + if(device->CheckCapability(GRAPHICSDEVICE_CAPABILITY_RAYTRACING)) { wiJobSystem::Execute(ctx, [](wiJobArgs args) { @@ -1993,9 +1791,7 @@ void LoadBuffers() GPUBufferDesc bd; // The following buffers will be DEFAULT (long lifetime, slow update, fast read): - bd.CPUAccessFlags = 0; bd.Usage = USAGE_DEFAULT; - bd.MiscFlags = 0; bd.ByteWidth = sizeof(FrameCB); bd.BindFlags = BIND_CONSTANT_BUFFER; @@ -2017,81 +1813,6 @@ void LoadBuffers() device->CreateBuffer(&bd, nullptr, &resourceBuffers[RBTYPE_MATRIXARRAY]); device->SetName(&resourceBuffers[RBTYPE_MATRIXARRAY], "MatrixArray"); - - // The following buffers will be DYNAMIC (short lifetime, fast update, slow read): - bd.Usage = USAGE_DYNAMIC; - bd.CPUAccessFlags = CPU_ACCESS_WRITE; - bd.MiscFlags = 0; - bd.BindFlags = BIND_CONSTANT_BUFFER; - - bd.ByteWidth = sizeof(CameraCB); - device->CreateBuffer(&bd, nullptr, &constantBuffers[CBTYPE_CAMERA]); - device->SetName(&constantBuffers[CBTYPE_CAMERA], "CameraCB"); - - bd.ByteWidth = sizeof(MiscCB); - device->CreateBuffer(&bd, nullptr, &constantBuffers[CBTYPE_MISC]); - device->SetName(&constantBuffers[CBTYPE_MISC], "MiscCB"); - - bd.ByteWidth = sizeof(VolumeLightCB); - device->CreateBuffer(&bd, nullptr, &constantBuffers[CBTYPE_VOLUMELIGHT]); - device->SetName(&constantBuffers[CBTYPE_VOLUMELIGHT], "VolumelightCB"); - - bd.ByteWidth = sizeof(CubemapRenderCB); - device->CreateBuffer(&bd, nullptr, &constantBuffers[CBTYPE_CUBEMAPRENDER]); - device->SetName(&constantBuffers[CBTYPE_CUBEMAPRENDER], "CubemapRenderCB"); - - bd.ByteWidth = sizeof(TessellationCB); - device->CreateBuffer(&bd, nullptr, &constantBuffers[CBTYPE_TESSELLATION]); - device->SetName(&constantBuffers[CBTYPE_TESSELLATION], "TessellationCB"); - - bd.ByteWidth = sizeof(RaytracingCB); - device->CreateBuffer(&bd, nullptr, &constantBuffers[CBTYPE_RAYTRACE]); - device->SetName(&constantBuffers[CBTYPE_RAYTRACE], "RayTraceCB"); - - bd.ByteWidth = sizeof(GenerateMIPChainCB); - device->CreateBuffer(&bd, nullptr, &constantBuffers[CBTYPE_MIPGEN]); - device->SetName(&constantBuffers[CBTYPE_MIPGEN], "MipGeneratorCB"); - - bd.ByteWidth = sizeof(FilterEnvmapCB); - device->CreateBuffer(&bd, nullptr, &constantBuffers[CBTYPE_FILTERENVMAP]); - device->SetName(&constantBuffers[CBTYPE_FILTERENVMAP], "FilterEnvmapCB"); - - bd.ByteWidth = sizeof(CopyTextureCB); - device->CreateBuffer(&bd, nullptr, &constantBuffers[CBTYPE_COPYTEXTURE]); - device->SetName(&constantBuffers[CBTYPE_COPYTEXTURE], "CopyTextureCB"); - - bd.ByteWidth = sizeof(ForwardEntityMaskCB); - device->CreateBuffer(&bd, nullptr, &constantBuffers[CBTYPE_FORWARDENTITYMASK]); - device->SetName(&constantBuffers[CBTYPE_FORWARDENTITYMASK], "ForwardEntityMaskCB"); - - bd.ByteWidth = sizeof(PostProcessCB); - device->CreateBuffer(&bd, nullptr, &constantBuffers[CBTYPE_POSTPROCESS]); - device->SetName(&constantBuffers[CBTYPE_POSTPROCESS], "PostProcessCB"); - - bd.ByteWidth = sizeof(FSRCB); - device->CreateBuffer(&bd, nullptr, &constantBuffers[CBTYPE_POSTPROCESS_FSR]); - device->SetName(&constantBuffers[CBTYPE_POSTPROCESS_FSR], "FSRCB"); - - bd.ByteWidth = sizeof(MSAOCB); - device->CreateBuffer(&bd, nullptr, &constantBuffers[CBTYPE_POSTPROCESS_MSAO]); - device->SetName(&constantBuffers[CBTYPE_POSTPROCESS_MSAO], "MSAOCB"); - - bd.ByteWidth = sizeof(MSAO_UPSAMPLECB); - device->CreateBuffer(&bd, nullptr, &constantBuffers[CBTYPE_POSTPROCESS_MSAO_UPSAMPLE]); - device->SetName(&constantBuffers[CBTYPE_POSTPROCESS_MSAO_UPSAMPLE], "MSAO_UPSAMPLECB"); - - bd.ByteWidth = sizeof(LensFlareCB); - device->CreateBuffer(&bd, nullptr, &constantBuffers[CBTYPE_LENSFLARE]); - device->SetName(&constantBuffers[CBTYPE_LENSFLARE], "LensFlareCB"); - - bd.ByteWidth = sizeof(PaintRadiusCB); - device->CreateBuffer(&bd, nullptr, &constantBuffers[CBTYPE_PAINTRADIUS]); - device->SetName(&constantBuffers[CBTYPE_PAINTRADIUS], "PaintRadiusCB"); - - bd.ByteWidth = sizeof(ShadingRateClassificationCB); - device->CreateBuffer(&bd, nullptr, &constantBuffers[CBTYPE_SHADINGRATECLASSIFICATION]); - device->SetName(&constantBuffers[CBTYPE_SHADINGRATECLASSIFICATION], "ShadingRateClassificationCB"); - { TextureDesc desc; desc.BindFlags = BIND_SHADER_RESOURCE; @@ -2703,22 +2424,6 @@ ForwardEntityMaskCB ForwardEntityCullingCPU(const Visibility& vis, const AABB& b return cb; } -void BindConstantBuffers(SHADERSTAGE stage, CommandList cmd) -{ - device->BindConstantBuffer(stage, &constantBuffers[CBTYPE_FRAME], CB_GETBINDSLOT(FrameCB), cmd); - device->BindConstantBuffer(stage, &constantBuffers[CBTYPE_CAMERA], CB_GETBINDSLOT(CameraCB), cmd); -} -void BindShadowmaps(SHADERSTAGE stage, CommandList cmd) -{ - device->BindResource(stage, &shadowMapArray_2D, TEXSLOT_SHADOWARRAY_2D, cmd); - device->BindResource(stage, &shadowMapArray_Cube, TEXSLOT_SHADOWARRAY_CUBE, cmd); - if (GetTransparentShadowsEnabled()) - { - device->BindResource(stage, &shadowMapArray_Transparent_2D, TEXSLOT_SHADOWARRAY_TRANSPARENT_2D, cmd); - device->BindResource(stage, &shadowMapArray_Transparent_Cube, TEXSLOT_SHADOWARRAY_TRANSPARENT_CUBE, cmd); - } -} - void RenderMeshes( const Visibility& vis, const RenderQueue& renderQueue, @@ -2734,189 +2439,37 @@ void RenderMeshes( return; device->EventBegin("RenderMeshes", cmd); - const bool bindless = device->CheckCapability(GRAPHICSDEVICE_CAPABILITY_BINDLESS_DESCRIPTORS); tessellation = tessellation && device->CheckCapability(GRAPHICSDEVICE_CAPABILITY_TESSELLATION); - if (tessellation) - { - BindConstantBuffers(DS, cmd); - } - - const TextureDesc& lightmap_desc = vis.scene->lightmap.GetDesc(); - const float lightmap_width_rcp = 1.0f / lightmap_desc.Width; - const float lightmap_height_rcp = 1.0f / lightmap_desc.Height; - + // Do we need to compute a light mask for this pass on the CPU? const bool forwardLightmaskRequest = renderPass == RENDERPASS_ENVMAPCAPTURE || renderPass == RENDERPASS_VOXELIZE; - const INSTANCETYPE instanceRequest = instanceTypes[renderPass]; - struct Instance_MATRIX_USERDATA - { - Instance instance; - }; - struct Instance_MATRIX_USERDATA_ATLAS - { - Instance instance; - InstanceAtlas instanceAtlas; - }; - struct Instance_MATRIX_USERDATA_MATRIXPREV - { - Instance instance; - InstancePrev instancePrev; - }; - // Pre-allocate space for all the instances in GPU-buffer: - uint32_t instanceDataSize = 0; - switch (instanceRequest) - { - default: - case INSTANCETYPE_MATRIX_USERDATA: - instanceDataSize = sizeof(Instance_MATRIX_USERDATA); - break; - case INSTANCETYPE_MATRIX_USERDATA_ATLAS: - instanceDataSize = sizeof(Instance_MATRIX_USERDATA_ATLAS); - break; - case INSTANCETYPE_MATRIX_USERDATA_MATRIXPREV: - instanceDataSize = sizeof(Instance_MATRIX_USERDATA_MATRIXPREV); - break; - } + uint32_t instanceDataSize = sizeof(ShaderMeshInstancePointer); size_t alloc_size = renderQueue.batchCount * frustum_count * instanceDataSize; GraphicsDevice::GPUAllocation instances = device->AllocateGPU(alloc_size, cmd); - // Purpose of InstancedBatch: - // The RenderQueue is sorted by meshIndex. There can be multiple instances for a single meshIndex, - // and the InstancedBatchArray contains this information. The array size will be the unique mesh count here. + // This will correspond to a single draw call + // It's used to render multiple instances of a single mesh struct InstancedBatch { - uint32_t meshIndex; - int instanceCount; - uint32_t dataOffset; - uint8_t userStencilRefOverride; - uint8_t forceAlphatestForDithering; // padded bool - uint16_t padding; + uint32_t meshIndex = ~0u; + uint32_t instanceCount = 0; + uint32_t dataOffset = 0; + uint8_t userStencilRefOverride = 0; + bool forceAlphatestForDithering = false; AABB aabb; - }; - InstancedBatch* instancedBatchArray = nullptr; - int instancedBatchCount = 0; + } instancedBatch = {}; - // The following loop is writing the instancing batches to a GPUBuffer: - size_t prevMeshIndex = ~0; - uint8_t prevUserStencilRefOverride = 0; - uint32_t instanceCount = 0; - for (uint32_t batchID = 0; batchID < renderQueue.batchCount; ++batchID) // Do not break out of this loop! + + // This will be called every time we start a new draw call: + auto batch_flush = [&]() { - const RenderBatch& batch = renderQueue.batchArray[batchID]; - const uint32_t meshIndex = batch.GetMeshIndex(); - const uint32_t instanceIndex = batch.GetInstanceIndex(); - const ObjectComponent& instance = vis.scene->objects[instanceIndex]; - const AABB& instanceAABB = vis.scene->aabb_objects[instanceIndex]; - const uint8_t userStencilRefOverride = instance.userStencilRef; - - // When we encounter a new mesh inside the global instance array, we begin a new InstancedBatch: - if (meshIndex != prevMeshIndex || userStencilRefOverride != prevUserStencilRefOverride) - { - prevMeshIndex = meshIndex; - prevUserStencilRefOverride = userStencilRefOverride; - - instancedBatchCount++; - InstancedBatch* instancedBatch = (InstancedBatch*)GetRenderFrameAllocator(cmd).allocate(sizeof(InstancedBatch)); - instancedBatch->meshIndex = meshIndex; - instancedBatch->instanceCount = 0; - instancedBatch->dataOffset = instances.offset + instanceCount * instanceDataSize; - instancedBatch->userStencilRefOverride = userStencilRefOverride; - instancedBatch->forceAlphatestForDithering = 0; - instancedBatch->aabb = AABB(); - if (instancedBatchArray == nullptr) - { - instancedBatchArray = instancedBatch; - } - } - - InstancedBatch& current_batch = instancedBatchArray[instancedBatchCount - 1]; - - float dither = instance.GetTransparency(); - - if (instance.IsImpostorPlacement()) - { - float distance = wiMath::Distance(instanceAABB.getCenter(), vis.camera->Eye); - float swapDistance = instance.impostorSwapDistance; - float fadeThreshold = instance.impostorFadeThresholdRadius; - dither = std::max(0.0f, distance - swapDistance) / fadeThreshold; - } - - if (dither > 0) - { - current_batch.forceAlphatestForDithering = 1; - } - - if (forwardLightmaskRequest) - { - current_batch.aabb = AABB::Merge(current_batch.aabb, instanceAABB); - } - - const XMFLOAT4X4& worldMatrix = instance.transform_index >= 0 ? vis.scene->transforms[instance.transform_index].world : IDENTITYMATRIX; - - for (uint32_t frustum_index = 0; frustum_index < frustum_count; ++frustum_index) - { - if (frusta != nullptr && !frusta[frustum_index].CheckBoxFast(instanceAABB)) - { - // In case multiple cameras were provided and no intersection detected with frustum, we don't add the instance for the face: - continue; - } - - // Write into actual GPU-buffer: - switch (instanceRequest) - { - default: - case INSTANCETYPE_MATRIX_USERDATA: - ((volatile Instance_MATRIX_USERDATA*)instances.data)[instanceCount].instance.Create(worldMatrix, instance.color, dither, frustum_index, instance.emissiveColor); - break; - case INSTANCETYPE_MATRIX_USERDATA_ATLAS: - ((volatile Instance_MATRIX_USERDATA_ATLAS*)instances.data)[instanceCount].instance.Create(worldMatrix, instance.color, dither, frustum_index, instance.emissiveColor); - { - XMFLOAT4 lightMapMulAdd; - if (instance.lightmap.IsValid()) - { - auto rect = instance.lightmap_rect; - - // eliminate border expansion: - rect.x += Scene::atlasClampBorder; - rect.y += Scene::atlasClampBorder; - rect.w -= Scene::atlasClampBorder * 2; - rect.h -= Scene::atlasClampBorder * 2; - - lightMapMulAdd = XMFLOAT4( - (float)rect.w / (float)lightmap_desc.Width, - (float)rect.h / (float)lightmap_desc.Height, - (float)rect.x / (float)lightmap_desc.Width, - (float)rect.y / (float)lightmap_desc.Height - ); - } - else - { - lightMapMulAdd = XMFLOAT4(0, 0, 0, 0); - } - ((volatile Instance_MATRIX_USERDATA_ATLAS*)instances.data)[instanceCount].instanceAtlas.Create(lightMapMulAdd); - } - break; - case INSTANCETYPE_MATRIX_USERDATA_MATRIXPREV: - ((volatile Instance_MATRIX_USERDATA_MATRIXPREV*)instances.data)[instanceCount].instance.Create(worldMatrix, instance.color, dither, frustum_index, instance.emissiveColor); - ((volatile Instance_MATRIX_USERDATA_MATRIXPREV*)instances.data)[instanceCount].instancePrev.Create(instance.prev_transform_index >= 0 ? vis.scene->prev_transforms[instance.prev_transform_index].world_prev : IDENTITYMATRIX); - break; - } - - current_batch.instanceCount++; // next instance in current InstancedBatch - instanceCount++; - } - - } - - // Render instanced batches: - for (int instancedBatchID = 0; instancedBatchID < instancedBatchCount; ++instancedBatchID) - { - const InstancedBatch& instancedBatch = instancedBatchArray[instancedBatchID]; + if (instancedBatch.instanceCount == 0) + return; const MeshComponent& mesh = vis.scene->meshes[instancedBatch.meshIndex]; const bool forceAlphaTestForDithering = instancedBatch.forceAlphatestForDithering != 0; const uint8_t userStencilRefOverride = instancedBatch.userStencilRefOverride; @@ -2925,71 +2478,17 @@ void RenderMeshes( const bool tessellatorRequested = tessF > 0 && tessellation; const bool terrain = mesh.IsTerrain(); - if (tessellatorRequested) - { - TessellationCB tessCB; - tessCB.xTessellationFactors = XMFLOAT4(tessF, tessF, tessF, tessF); - device->UpdateBuffer(&constantBuffers[CBTYPE_TESSELLATION], &tessCB, cmd); - device->BindConstantBuffer(HS, &constantBuffers[CBTYPE_TESSELLATION], CBSLOT_RENDERER_TESSELLATION, cmd); - } - if (forwardLightmaskRequest) { ForwardEntityMaskCB cb = ForwardEntityCullingCPU(vis, instancedBatch.aabb, renderPass); - device->UpdateBuffer(&constantBuffers[CBTYPE_FORWARDENTITYMASK], &cb, cmd); - device->BindConstantBuffer(PS, &constantBuffers[CBTYPE_FORWARDENTITYMASK], CB_GETBINDSLOT(ForwardEntityMaskCB), cmd); + device->BindDynamicConstantBuffer(cb, CB_GETBINDSLOT(ForwardEntityMaskCB), cmd); } device->BindIndexBuffer(&mesh.indexBuffer, mesh.GetIndexFormat(), 0, cmd); - ObjectPushConstants push; // used with bindless model only - - if (bindless) - { - push.mesh = device->GetDescriptorIndex(&mesh.descriptor, SRV); - push.instances = device->GetDescriptorIndex(instances.buffer, SRV); - push.instance_offset = instancedBatch.dataOffset; - } - else - { - const GPUBuffer* vbs[] = { - mesh.streamoutBuffer_POS.IsValid() ? &mesh.streamoutBuffer_POS : &mesh.vertexBuffer_POS, - mesh.vertexBuffer_PRE.IsValid() ? &mesh.vertexBuffer_PRE : &mesh.vertexBuffer_POS, - &mesh.vertexBuffer_UV0, - &mesh.vertexBuffer_UV1, - &mesh.vertexBuffer_ATL, - &mesh.vertexBuffer_COL, - mesh.streamoutBuffer_TAN.IsValid() ? &mesh.streamoutBuffer_TAN : &mesh.vertexBuffer_TAN, - instances.buffer - }; - uint32_t strides[] = { - sizeof(MeshComponent::Vertex_POS), - sizeof(MeshComponent::Vertex_POS), - sizeof(MeshComponent::Vertex_TEX), - sizeof(MeshComponent::Vertex_TEX), - sizeof(MeshComponent::Vertex_TEX), - sizeof(MeshComponent::Vertex_COL), - sizeof(MeshComponent::Vertex_TAN), - instanceDataSize - }; - uint32_t offsets[] = { - 0, - 0, - 0, - 0, - 0, - 0, - 0, - instancedBatch.dataOffset - }; - static_assert(arraysize(vbs) == INPUT_SLOT_COUNT, "This layout must conform to OBJECT_VERTEXINPUT enum!"); - static_assert(arraysize(vbs) == arraysize(strides), "Mismatch between vertex buffers and strides!"); - static_assert(arraysize(vbs) == arraysize(offsets), "Mismatch between vertex buffers and offsets!"); - device->BindVertexBuffers(vbs, 0, arraysize(vbs), strides, offsets, cmd); - } - - for (const MeshComponent::MeshSubset& subset : mesh.subsets) + for (size_t subsetIndex = 0; subsetIndex < mesh.subsets.size(); ++subsetIndex) { + const MeshComponent::MeshSubset& subset = mesh.subsets[subsetIndex]; if (subset.indexCount == 0) { continue; @@ -3063,72 +2562,17 @@ void RenderMeshes( device->BindShadingRate(material.shadingRate, cmd); } - if (bindless) - { - push.material = device->GetDescriptorIndex(&material.constantBuffer, SRV); - device->PushConstants(&push, sizeof(push), cmd); - } - else - { - device->BindConstantBuffer(VS, &material.constantBuffer, CB_GETBINDSLOT(MaterialCB), cmd); - device->BindConstantBuffer(PS, &material.constantBuffer, CB_GETBINDSLOT(MaterialCB), cmd); + assert(subsetIndex < 256u); // subsets must be represented as 8-bit - // Bind all material textures: - const GPUResource* materialtextures[MaterialComponent::TEXTURESLOT_COUNT]; - material.WriteTextures(materialtextures, arraysize(materialtextures)); - device->BindResources(PS, materialtextures, TEXSLOT_RENDERER_BASECOLORMAP, arraysize(materialtextures), cmd); - - if (tessellatorRequested) - { - device->BindConstantBuffer(DS, &material.constantBuffer, CB_GETBINDSLOT(MaterialCB), cmd); - device->BindResources(DS, materialtextures, TEXSLOT_RENDERER_BASECOLORMAP, arraysize(materialtextures), cmd); - } - - if (terrain) - { - if (mesh.terrain_material1 == INVALID_ENTITY || !vis.scene->materials.Contains(mesh.terrain_material1)) - { - device->BindResources(PS, materialtextures, TEXSLOT_RENDERER_BLEND1_BASECOLORMAP, 4, cmd); - device->BindConstantBuffer(PS, &material.constantBuffer, CB_GETBINDSLOT(MaterialCB_Blend1), cmd); - } - else - { - const MaterialComponent& blendmat = *vis.scene->materials.GetComponent(mesh.terrain_material1); - const GPUResource* res[4]; - blendmat.WriteTextures(res, arraysize(res)); - device->BindResources(PS, res, TEXSLOT_RENDERER_BLEND1_BASECOLORMAP, arraysize(res), cmd); - device->BindConstantBuffer(PS, &blendmat.constantBuffer, CB_GETBINDSLOT(MaterialCB_Blend1), cmd); - } - - if (mesh.terrain_material2 == INVALID_ENTITY || !vis.scene->materials.Contains(mesh.terrain_material2)) - { - device->BindResources(PS, materialtextures, TEXSLOT_RENDERER_BLEND2_BASECOLORMAP, 4, cmd); - device->BindConstantBuffer(PS, &material.constantBuffer, CB_GETBINDSLOT(MaterialCB_Blend2), cmd); - } - else - { - const MaterialComponent& blendmat = *vis.scene->materials.GetComponent(mesh.terrain_material2); - const GPUResource* res[4]; - blendmat.WriteTextures(res, arraysize(res)); - device->BindResources(PS, res, TEXSLOT_RENDERER_BLEND2_BASECOLORMAP, arraysize(res), cmd); - device->BindConstantBuffer(PS, &blendmat.constantBuffer, CB_GETBINDSLOT(MaterialCB_Blend2), cmd); - } - - if (mesh.terrain_material3 == INVALID_ENTITY || !vis.scene->materials.Contains(mesh.terrain_material3)) - { - device->BindResources(PS, materialtextures, TEXSLOT_RENDERER_BLEND3_BASECOLORMAP, 4, cmd); - device->BindConstantBuffer(PS, &material.constantBuffer, CB_GETBINDSLOT(MaterialCB_Blend3), cmd); - } - else - { - const MaterialComponent& blendmat = *vis.scene->materials.GetComponent(mesh.terrain_material3); - const GPUResource* res[4]; - blendmat.WriteTextures(res, arraysize(res)); - device->BindResources(PS, res, TEXSLOT_RENDERER_BLEND3_BASECOLORMAP, arraysize(res), cmd); - device->BindConstantBuffer(PS, &blendmat.constantBuffer, CB_GETBINDSLOT(MaterialCB_Blend3), cmd); - } - } - } + ObjectPushConstants push; + push.init( + instancedBatch.meshIndex, + (uint)subsetIndex, + subset.materialIndex, + device->GetDescriptorIndex(&instances.buffer, SRV), + instancedBatch.dataOffset + ); + device->PushConstants(&push, sizeof(push), cmd); if (pso_backside != nullptr) { @@ -3139,9 +2583,74 @@ void RenderMeshes( device->BindPipelineState(pso, cmd); device->DrawIndexedInstanced(subset.indexCount, instancedBatch.instanceCount, subset.indexOffset, 0, 0, cmd); } + }; + + // The following loop is writing the instancing batches to a GPUBuffer: + // RenderQueue is sorted based on mesh index, so when a new mesh or stencil request is encountered, we need to flush the batch + uint32_t instanceCount = 0; + for (uint32_t batchID = 0; batchID < renderQueue.batchCount; ++batchID) // Do not break out of this loop! + { + const RenderBatch& batch = renderQueue.batchArray[batchID]; + const uint32_t meshIndex = batch.GetMeshIndex(); + const uint32_t instanceIndex = batch.GetInstanceIndex(); + const ObjectComponent& instance = vis.scene->objects[instanceIndex]; + const AABB& instanceAABB = vis.scene->aabb_objects[instanceIndex]; + const uint8_t userStencilRefOverride = instance.userStencilRef; + + // When we encounter a new mesh inside the global instance array, we begin a new RenderBatch: + if (meshIndex != instancedBatch.meshIndex || userStencilRefOverride != instancedBatch.userStencilRefOverride) + { + batch_flush(); + + instancedBatch = {}; + instancedBatch.meshIndex = meshIndex; + instancedBatch.instanceCount = 0; + instancedBatch.dataOffset = instances.offset + instanceCount * instanceDataSize; + instancedBatch.userStencilRefOverride = userStencilRefOverride; + instancedBatch.forceAlphatestForDithering = 0; + instancedBatch.aabb = AABB(); + } + + float dither = instance.GetTransparency(); + + if (instance.IsImpostorPlacement()) + { + float distance = wiMath::Distance(instanceAABB.getCenter(), vis.camera->Eye); + float swapDistance = instance.impostorSwapDistance; + float fadeThreshold = instance.impostorFadeThresholdRadius; + dither = std::max(0.0f, distance - swapDistance) / fadeThreshold; + } + + if (dither > 0) + { + instancedBatch.forceAlphatestForDithering = 1; + } + + if (forwardLightmaskRequest) + { + instancedBatch.aabb = AABB::Merge(instancedBatch.aabb, instanceAABB); + } + + for (uint32_t frustum_index = 0; frustum_index < frustum_count; ++frustum_index) + { + if (frusta != nullptr && !frusta[frustum_index].CheckBoxFast(instanceAABB)) + { + // In case multiple cameras were provided and no intersection detected with frustum, we don't add the instance for the face: + continue; + } + + // Write into actual GPU-buffer: + ShaderMeshInstancePointer poi; + poi.Create(instanceIndex, frustum_index, dither); + std::memcpy((ShaderMeshInstancePointer*)instances.data + instanceCount, &poi, sizeof(ShaderMeshInstancePointer)); + + instancedBatch.instanceCount++; // next instance in current InstancedBatch + instanceCount++; + } + } - GetRenderFrameAllocator(cmd).free(sizeof(InstancedBatch) * instancedBatchCount); + batch_flush(); device->EventEnd(cmd); } @@ -3152,9 +2661,18 @@ void RenderImpostors( CommandList cmd ) { - const PipelineState* impostorRequest = GetImpostorPSO(renderPass); + const PipelineState* pso = &PSO_impostor[renderPass]; + if (IsWireRender()) + { + switch (renderPass) + { + case RENDERPASS_MAIN: + pso = &PSO_impostor_wire; + } + return; + } - if (vis.scene->impostors.GetCount() > 0 && impostorRequest != nullptr) + if (vis.scene->impostors.GetCount() > 0 && pso != nullptr) { uint32_t instanceCount = 0; for (size_t impostorID = 0; impostorID < vis.scene->impostors.GetCount(); ++impostorID) @@ -3162,7 +2680,7 @@ void RenderImpostors( const ImpostorComponent& impostor = vis.scene->impostors[impostorID]; if (vis.camera->frustum.CheckBoxFast(impostor.aabb)) { - instanceCount += (uint32_t)impostor.instanceMatrices.size(); + instanceCount += (uint32_t)impostor.instances.size(); } } @@ -3174,7 +2692,7 @@ void RenderImpostors( device->EventBegin("RenderImpostors", cmd); // Pre-allocate space for all the instances in GPU-buffer: - const uint32_t instanceDataSize = sizeof(Instance); + const uint32_t instanceDataSize = sizeof(ShaderMeshInstancePointer); const size_t alloc_size = instanceCount * instanceDataSize; GraphicsDevice::GPUAllocation instances = device->AllocateGPU(alloc_size, cmd); @@ -3187,9 +2705,16 @@ void RenderImpostors( continue; } - for (auto& mat : impostor.instanceMatrices) + for (auto& instanceIndex : impostor.instances) { - const XMFLOAT3 center = *((XMFLOAT3*)&mat._41); + const ShaderMeshInstance& instance = vis.scene->instanceData[instanceIndex]; + const AABB& aabb = vis.scene->aabb_objects[instanceIndex]; + if (!vis.camera->frustum.CheckBoxFast(aabb)) + { + continue; + } + + const XMFLOAT3 center = aabb.getCenter(); float distance = wiMath::Distance(vis.camera->Eye, center); if (distance < impostor.swapInDistance - impostor.fadeThresholdRadius) @@ -3199,22 +2724,22 @@ void RenderImpostors( float dither = std::max(0.0f, impostor.swapInDistance - distance) / impostor.fadeThresholdRadius; - ((volatile Instance*)instances.data)[drawableInstanceCount].Create(mat, impostor.color, dither, uint32_t(impostorID * impostorCaptureAngles * 3)); + // Write into actual GPU-buffer: + ShaderMeshInstancePointer poi; + poi.Create(instanceIndex, uint32_t(impostorID * impostorCaptureAngles * 3), dither); + std::memcpy((ShaderMeshInstancePointer*)instances.data + drawableInstanceCount, &poi, sizeof(ShaderMeshInstancePointer)); drawableInstanceCount++; } } device->BindStencilRef(STENCILREF_DEFAULT, cmd); - device->BindPipelineState(impostorRequest, cmd); + device->BindPipelineState(pso, cmd); - MiscCB cb; - cb.g_xColor.x = (float)instances.offset; - device->UpdateBuffer(&constantBuffers[CBTYPE_MISC], &cb, cmd); - device->BindConstantBuffer(VS, &constantBuffers[CBTYPE_MISC], CB_GETBINDSLOT(MiscCB), cmd); + device->PushConstants(&instances.offset, sizeof(uint), cmd); - device->BindResource(VS, instances.buffer, TEXSLOT_ONDEMAND21, cmd); - device->BindResource(PS, &vis.scene->impostorArray, TEXSLOT_ONDEMAND0, cmd); + device->BindResource(&instances.buffer, TEXSLOT_ONDEMAND21, cmd); + device->BindResource(&vis.scene->impostorArray, TEXSLOT_ONDEMAND0, cmd); device->Draw(drawableInstanceCount * 6, 0, cmd); @@ -3542,81 +3067,81 @@ void UpdatePerFrameData( wiJobSystem::Wait(ctx); - if (!device->CheckCapability(GRAPHICSDEVICE_CAPABILITY_RAYTRACING_PIPELINE) && !device->CheckCapability(GRAPHICSDEVICE_CAPABILITY_RAYTRACING_INLINE) && scene.IsAccelerationStructureUpdateRequested()) + if (!device->CheckCapability(GRAPHICSDEVICE_CAPABILITY_RAYTRACING) && scene.IsAccelerationStructureUpdateRequested()) { scene.BVH.Update(scene); } // Update CPU-side frame constant buffer: - frameCB.g_xFrame_ConstantOne = 1; - frameCB.g_xFrame_CanvasSize = float2(canvas.GetLogicalWidth(), canvas.GetLogicalHeight()); - frameCB.g_xFrame_CanvasSize_rcp = float2(1.0f / frameCB.g_xFrame_CanvasSize.x, 1.0f / frameCB.g_xFrame_CanvasSize.y); - frameCB.g_xFrame_InternalResolution = float2((float)internalResolution.x, (float)internalResolution.y); - frameCB.g_xFrame_InternalResolution_rcp = float2(1.0f / frameCB.g_xFrame_InternalResolution.x, 1.0f / frameCB.g_xFrame_InternalResolution.y); - frameCB.g_xFrame_Gamma = GetGamma(); - frameCB.g_xFrame_SunColor = vis.scene->weather.sunColor; - frameCB.g_xFrame_SunDirection = vis.scene->weather.sunDirection; - frameCB.g_xFrame_SunEnergy = vis.scene->weather.sunEnergy; - frameCB.g_xFrame_ShadowCascadeCount = CASCADE_COUNT; - frameCB.g_xFrame_Ambient = vis.scene->weather.ambient; - frameCB.g_xFrame_Cloudiness = vis.scene->weather.cloudiness; - frameCB.g_xFrame_CloudScale = vis.scene->weather.cloudScale; - frameCB.g_xFrame_CloudSpeed = vis.scene->weather.cloudSpeed; - frameCB.g_xFrame_Fog = float4(vis.scene->weather.fogStart, vis.scene->weather.fogEnd, vis.scene->weather.fogHeightStart, vis.scene->weather.fogHeightEnd); - frameCB.g_xFrame_FogHeightSky = vis.scene->weather.fogHeightSky; - frameCB.g_xFrame_Horizon = vis.scene->weather.horizon; - frameCB.g_xFrame_Zenith = vis.scene->weather.zenith; - frameCB.g_xFrame_SkyExposure = vis.scene->weather.skyExposure; - frameCB.g_xFrame_VoxelRadianceMaxDistance = voxelSceneData.maxDistance; - frameCB.g_xFrame_VoxelRadianceDataSize = voxelSceneData.voxelsize; - frameCB.g_xFrame_VoxelRadianceDataSize_rcp = 1.0f / (float)frameCB.g_xFrame_VoxelRadianceDataSize; - frameCB.g_xFrame_VoxelRadianceDataRes = GetVoxelRadianceEnabled() ? (uint)voxelSceneData.res : 0; - frameCB.g_xFrame_VoxelRadianceDataRes_rcp = 1.0f / (float)frameCB.g_xFrame_VoxelRadianceDataRes; - frameCB.g_xFrame_VoxelRadianceDataMIPs = voxelSceneData.mips; - frameCB.g_xFrame_VoxelRadianceNumCones = std::max(std::min(voxelSceneData.numCones, 16u), 1u); - frameCB.g_xFrame_VoxelRadianceNumCones_rcp = 1.0f / (float)frameCB.g_xFrame_VoxelRadianceNumCones; - frameCB.g_xFrame_VoxelRadianceRayStepSize = voxelSceneData.rayStepSize; - frameCB.g_xFrame_VoxelRadianceDataCenter = voxelSceneData.center; - frameCB.g_xFrame_EntityCullingTileCount = GetEntityCullingTileCount(internalResolution); - frameCB.g_xFrame_ObjectShaderSamplerIndex = device->GetDescriptorIndex(&samplers[SSLOT_OBJECTSHADER]); + frameCB.ConstantOne = 1; + frameCB.CanvasSize = float2(canvas.GetLogicalWidth(), canvas.GetLogicalHeight()); + frameCB.CanvasSize_rcp = float2(1.0f / frameCB.CanvasSize.x, 1.0f / frameCB.CanvasSize.y); + frameCB.InternalResolution = float2((float)internalResolution.x, (float)internalResolution.y); + frameCB.InternalResolution_rcp = float2(1.0f / frameCB.InternalResolution.x, 1.0f / frameCB.InternalResolution.y); + frameCB.Gamma = GetGamma(); + frameCB.SunColor = vis.scene->weather.sunColor; + frameCB.SunDirection = vis.scene->weather.sunDirection; + frameCB.SunEnergy = vis.scene->weather.sunEnergy; + frameCB.ShadowCascadeCount = CASCADE_COUNT; + frameCB.Ambient = vis.scene->weather.ambient; + frameCB.Cloudiness = vis.scene->weather.cloudiness; + frameCB.CloudScale = vis.scene->weather.cloudScale; + frameCB.CloudSpeed = vis.scene->weather.cloudSpeed; + frameCB.Fog = float4(vis.scene->weather.fogStart, vis.scene->weather.fogEnd, vis.scene->weather.fogHeightStart, vis.scene->weather.fogHeightEnd); + frameCB.FogHeightSky = vis.scene->weather.fogHeightSky; + frameCB.Horizon = vis.scene->weather.horizon; + frameCB.Zenith = vis.scene->weather.zenith; + frameCB.SkyExposure = vis.scene->weather.skyExposure; + frameCB.VoxelRadianceMaxDistance = voxelSceneData.maxDistance; + frameCB.VoxelRadianceDataSize = voxelSceneData.voxelsize; + frameCB.VoxelRadianceDataSize_rcp = 1.0f / (float)frameCB.VoxelRadianceDataSize; + frameCB.VoxelRadianceDataRes = GetVoxelRadianceEnabled() ? (uint)voxelSceneData.res : 0; + frameCB.VoxelRadianceDataRes_rcp = 1.0f / (float)frameCB.VoxelRadianceDataRes; + frameCB.VoxelRadianceDataMIPs = voxelSceneData.mips; + frameCB.VoxelRadianceNumCones = std::max(std::min(voxelSceneData.numCones, 16u), 1u); + frameCB.VoxelRadianceNumCones_rcp = 1.0f / (float)frameCB.VoxelRadianceNumCones; + frameCB.VoxelRadianceRayStepSize = voxelSceneData.rayStepSize; + frameCB.VoxelRadianceDataCenter = voxelSceneData.center; + frameCB.EntityCullingTileCount = GetEntityCullingTileCount(internalResolution); + frameCB.ObjectShaderSamplerIndex = device->GetDescriptorIndex(&samplers[SSLOT_OBJECTSHADER]); // The order is very important here: - frameCB.g_xFrame_DecalArrayOffset = 0; - frameCB.g_xFrame_DecalArrayCount = (uint)vis.visibleDecals.size(); - frameCB.g_xFrame_EnvProbeArrayOffset = frameCB.g_xFrame_DecalArrayCount; - frameCB.g_xFrame_EnvProbeArrayCount = std::min(vis.scene->envmapCount, (uint)vis.visibleEnvProbes.size()); - frameCB.g_xFrame_LightArrayOffset = frameCB.g_xFrame_EnvProbeArrayOffset + frameCB.g_xFrame_EnvProbeArrayCount; - frameCB.g_xFrame_LightArrayCount = (uint)vis.visibleLights.size(); - frameCB.g_xFrame_ForceFieldArrayOffset = frameCB.g_xFrame_LightArrayOffset + frameCB.g_xFrame_LightArrayCount; - frameCB.g_xFrame_ForceFieldArrayCount = (uint)vis.scene->forces.GetCount(); + frameCB.DecalArrayOffset = 0; + frameCB.DecalArrayCount = (uint)vis.visibleDecals.size(); + frameCB.EnvProbeArrayOffset = frameCB.DecalArrayCount; + frameCB.EnvProbeArrayCount = std::min(vis.scene->envmapCount, (uint)vis.visibleEnvProbes.size()); + frameCB.LightArrayOffset = frameCB.EnvProbeArrayOffset + frameCB.EnvProbeArrayCount; + frameCB.LightArrayCount = (uint)vis.visibleLights.size(); + frameCB.ForceFieldArrayOffset = frameCB.LightArrayOffset + frameCB.LightArrayCount; + frameCB.ForceFieldArrayCount = (uint)vis.scene->forces.GetCount(); - frameCB.g_xFrame_GlobalEnvProbeIndex = 0; - frameCB.g_xFrame_EnvProbeMipCount = 0; - frameCB.g_xFrame_EnvProbeMipCount_rcp = 1.0f; + frameCB.GlobalEnvProbeIndex = 0; + frameCB.EnvProbeMipCount = 0; + frameCB.EnvProbeMipCount_rcp = 1.0f; if (vis.scene->envmapArray.IsValid()) { - frameCB.g_xFrame_EnvProbeMipCount = vis.scene->envmapArray.GetDesc().MipLevels; - frameCB.g_xFrame_EnvProbeMipCount_rcp = 1.0f / (float)frameCB.g_xFrame_EnvProbeMipCount; + frameCB.EnvProbeMipCount = vis.scene->envmapArray.GetDesc().MipLevels; + frameCB.EnvProbeMipCount_rcp = 1.0f / (float)frameCB.EnvProbeMipCount; } - frameCB.g_xFrame_DeltaTime = dt * GetGameSpeed(); - frameCB.g_xFrame_TimePrev = frameCB.g_xFrame_Time; - frameCB.g_xFrame_Time += frameCB.g_xFrame_DeltaTime; - frameCB.g_xFrame_WindSpeed = vis.scene->weather.windSpeed; - frameCB.g_xFrame_WindRandomness = vis.scene->weather.windRandomness; - frameCB.g_xFrame_WindWaveSize = vis.scene->weather.windWaveSize; - frameCB.g_xFrame_WindDirection = vis.scene->weather.windDirection; - frameCB.g_xFrame_StaticSkyGamma = 0.0f; + frameCB.DeltaTime = dt * GetGameSpeed(); + frameCB.TimePrev = frameCB.Time; + frameCB.Time += frameCB.DeltaTime; + frameCB.WindSpeed = vis.scene->weather.windSpeed; + frameCB.WindRandomness = vis.scene->weather.windRandomness; + frameCB.WindWaveSize = vis.scene->weather.windWaveSize; + frameCB.WindDirection = vis.scene->weather.windDirection; + frameCB.StaticSkyGamma = 0.0f; if (vis.scene->weather.skyMap != nullptr) { bool hdr = !device->IsFormatUnorm(vis.scene->weather.skyMap->texture.desc.Format); - frameCB.g_xFrame_StaticSkyGamma = hdr ? 1.0f : frameCB.g_xFrame_Gamma; + frameCB.StaticSkyGamma = hdr ? 1.0f : frameCB.Gamma; } - frameCB.g_xFrame_FrameCount = (uint)device->GetFrameCount(); - frameCB.g_xFrame_TemporalAASampleRotation = 0; + frameCB.FrameCount = (uint)device->GetFrameCount(); + frameCB.TemporalAASampleRotation = 0; if (GetTemporalAAEnabled()) { - uint id = frameCB.g_xFrame_FrameCount % 4; + uint id = frameCB.FrameCount % 4; uint x = 0; uint y = 0; switch (id) @@ -3634,72 +3159,80 @@ void UpdatePerFrameData( default: break; } - frameCB.g_xFrame_TemporalAASampleRotation = (x & 0x000000FF) | ((y & 0x000000FF) << 8); + frameCB.TemporalAASampleRotation = (x & 0x000000FF) | ((y & 0x000000FF) << 8); } - frameCB.g_xFrame_ShadowKernel2D = 1.0f / SHADOWRES_2D; - frameCB.g_xFrame_ShadowKernelCube = 1.0f / SHADOWRES_CUBE; + frameCB.ShadowKernel2D = 1.0f / SHADOWRES_2D; + frameCB.ShadowKernelCube = 1.0f / SHADOWRES_CUBE; - frameCB.g_xFrame_WorldBoundsMin = vis.scene->bounds.getMin(); - frameCB.g_xFrame_WorldBoundsMax = vis.scene->bounds.getMax(); - frameCB.g_xFrame_WorldBoundsExtents.x = abs(frameCB.g_xFrame_WorldBoundsMax.x - frameCB.g_xFrame_WorldBoundsMin.x); - frameCB.g_xFrame_WorldBoundsExtents.y = abs(frameCB.g_xFrame_WorldBoundsMax.y - frameCB.g_xFrame_WorldBoundsMin.y); - frameCB.g_xFrame_WorldBoundsExtents.z = abs(frameCB.g_xFrame_WorldBoundsMax.z - frameCB.g_xFrame_WorldBoundsMin.z); - frameCB.g_xFrame_WorldBoundsExtents_rcp.x = 1.0f / frameCB.g_xFrame_WorldBoundsExtents.x; - frameCB.g_xFrame_WorldBoundsExtents_rcp.y = 1.0f / frameCB.g_xFrame_WorldBoundsExtents.y; - frameCB.g_xFrame_WorldBoundsExtents_rcp.z = 1.0f / frameCB.g_xFrame_WorldBoundsExtents.z; + frameCB.WorldBoundsMin = vis.scene->bounds.getMin(); + frameCB.WorldBoundsMax = vis.scene->bounds.getMax(); + frameCB.WorldBoundsExtents.x = abs(frameCB.WorldBoundsMax.x - frameCB.WorldBoundsMin.x); + frameCB.WorldBoundsExtents.y = abs(frameCB.WorldBoundsMax.y - frameCB.WorldBoundsMin.y); + frameCB.WorldBoundsExtents.z = abs(frameCB.WorldBoundsMax.z - frameCB.WorldBoundsMin.z); + frameCB.WorldBoundsExtents_rcp.x = 1.0f / frameCB.WorldBoundsExtents.x; + frameCB.WorldBoundsExtents_rcp.y = 1.0f / frameCB.WorldBoundsExtents.y; + frameCB.WorldBoundsExtents_rcp.z = 1.0f / frameCB.WorldBoundsExtents.z; - frameCB.g_xFrame_BlueNoisePhase = (frameCB.g_xFrame_FrameCount & 0xFF) * 1.6180339887f; + frameCB.BlueNoisePhase = (frameCB.FrameCount & 0xFF) * 1.6180339887f; - frameCB.g_xFrame_Options = 0; + frameCB.Options = 0; if (GetTemporalAAEnabled()) { - frameCB.g_xFrame_Options |= OPTION_BIT_TEMPORALAA_ENABLED; + frameCB.Options |= OPTION_BIT_TEMPORALAA_ENABLED; } if (GetTransparentShadowsEnabled()) { - frameCB.g_xFrame_Options |= OPTION_BIT_TRANSPARENTSHADOWS_ENABLED; + frameCB.Options |= OPTION_BIT_TRANSPARENTSHADOWS_ENABLED; } if (GetVoxelRadianceEnabled()) { - frameCB.g_xFrame_Options |= OPTION_BIT_VOXELGI_ENABLED; + frameCB.Options |= OPTION_BIT_VOXELGI_ENABLED; } if (GetVoxelRadianceReflectionsEnabled()) { - frameCB.g_xFrame_Options |= OPTION_BIT_VOXELGI_REFLECTIONS_ENABLED; + frameCB.Options |= OPTION_BIT_VOXELGI_REFLECTIONS_ENABLED; } if (voxelSceneData.centerChangedThisFrame) { - frameCB.g_xFrame_Options |= OPTION_BIT_VOXELGI_RETARGETTED; + frameCB.Options |= OPTION_BIT_VOXELGI_RETARGETTED; } if (vis.scene->weather.IsSimpleSky()) { - frameCB.g_xFrame_Options |= OPTION_BIT_SIMPLE_SKY; + frameCB.Options |= OPTION_BIT_SIMPLE_SKY; } if (vis.scene->weather.IsRealisticSky()) { - frameCB.g_xFrame_Options |= OPTION_BIT_REALISTIC_SKY; + frameCB.Options |= OPTION_BIT_REALISTIC_SKY; } if (vis.scene->weather.IsHeightFog()) { - frameCB.g_xFrame_Options |= OPTION_BIT_HEIGHT_FOG; + frameCB.Options |= OPTION_BIT_HEIGHT_FOG; } - if (device->CheckCapability(GRAPHICSDEVICE_CAPABILITY_RAYTRACING_INLINE) && GetRaytracedShadowsEnabled()) + if (device->CheckCapability(GRAPHICSDEVICE_CAPABILITY_RAYTRACING) && GetRaytracedShadowsEnabled()) { - frameCB.g_xFrame_Options |= OPTION_BIT_RAYTRACED_SHADOWS; - frameCB.g_xFrame_Options |= OPTION_BIT_SHADOW_MASK; - } - if (IsDisableAlbedoMaps()) - { - frameCB.g_xFrame_Options |= OPTION_BIT_DISABLE_ALBEDO_MAPS; + frameCB.Options |= OPTION_BIT_RAYTRACED_SHADOWS; + frameCB.Options |= OPTION_BIT_SHADOW_MASK; } if (GetScreenSpaceShadowsEnabled()) { - frameCB.g_xFrame_Options |= OPTION_BIT_SHADOW_MASK; + frameCB.Options |= OPTION_BIT_SHADOW_MASK; + } + if (GetSurfelGIEnabled()) + { + frameCB.Options |= OPTION_BIT_SURFELGI_ENABLED; + } + if (IsDisableAlbedoMaps()) + { + frameCB.Options |= OPTION_BIT_DISABLE_ALBEDO_MAPS; + } + if (IsForceDiffuseLighting()) + { + frameCB.Options |= OPTION_BIT_FORCE_DIFFUSE_LIGHTING; } - frameCB.g_xFrame_Atmosphere = vis.scene->weather.atmosphereParameters; - frameCB.g_xFrame_VolumetricClouds = vis.scene->weather.volumetricCloudParameters; - + frameCB.Atmosphere = vis.scene->weather.atmosphereParameters; + frameCB.VolumetricClouds = vis.scene->weather.volumetricCloudParameters; + frameCB.scene = vis.scene->shaderscene; // Create volumetric cloud static resources if needed: @@ -3713,7 +3246,7 @@ void UpdatePerFrameData( shape_desc.MipLevels = 6; shape_desc.Format = FORMAT_R8G8B8A8_UNORM; shape_desc.BindFlags = BIND_SHADER_RESOURCE | BIND_UNORDERED_ACCESS; - shape_desc.layout = IMAGE_LAYOUT_SHADER_RESOURCE_COMPUTE; + shape_desc.layout = RESOURCE_STATE_SHADER_RESOURCE_COMPUTE; device->CreateTexture(&shape_desc, nullptr, &texture_shapeNoise); device->SetName(&texture_shapeNoise, "texture_shapeNoise"); @@ -3734,7 +3267,7 @@ void UpdatePerFrameData( detail_desc.MipLevels = 6; detail_desc.Format = FORMAT_R8G8B8A8_UNORM; detail_desc.BindFlags = BIND_SHADER_RESOURCE | BIND_UNORDERED_ACCESS; - detail_desc.layout = IMAGE_LAYOUT_SHADER_RESOURCE_COMPUTE; + detail_desc.layout = RESOURCE_STATE_SHADER_RESOURCE_COMPUTE; device->CreateTexture(&detail_desc, nullptr, &texture_detailNoise); device->SetName(&texture_detailNoise, "texture_detailNoise"); @@ -3753,7 +3286,7 @@ void UpdatePerFrameData( texture_desc.Height = 128; texture_desc.Format = FORMAT_R8G8B8A8_UNORM; texture_desc.BindFlags = BIND_SHADER_RESOURCE | BIND_UNORDERED_ACCESS; - texture_desc.layout = IMAGE_LAYOUT_SHADER_RESOURCE_COMPUTE; + texture_desc.layout = RESOURCE_STATE_SHADER_RESOURCE_COMPUTE; device->CreateTexture(&texture_desc, nullptr, &texture_curlNoise); device->SetName(&texture_curlNoise, "texture_curlNoise"); @@ -3770,30 +3303,26 @@ void UpdateRenderData( CommandList cmd ) { - device->UpdateBuffer(&constantBuffers[CBTYPE_FRAME], &frameCB, cmd); - UpdateCameraCB( - *vis.camera, - *vis.camera, - *vis.camera, - cmd - ); + device->EventBegin("UpdateRenderData", cmd); - BindCommonResources(cmd); - - // Update dirty material constant buffers: - for (size_t i = 0; i < vis.scene->materials.GetCount(); ++i) + // Begin copy barriers: { - const MaterialComponent& material = vis.scene->materials[i]; - if (material.dirty_buffer) - { - material.dirty_buffer = false; - - ShaderMaterial shadermaterial; - material.WriteShaderMaterial(&shadermaterial); - device->UpdateBuffer(&material.constantBuffer, &shadermaterial, cmd); - } + GPUBarrier barriers[] = { + GPUBarrier::Buffer(&constantBuffers[CBTYPE_FRAME], RESOURCE_STATE_CONSTANT_BUFFER, RESOURCE_STATE_COPY_DST), + GPUBarrier::Buffer(&vis.scene->instanceBuffer, RESOURCE_STATE_SHADER_RESOURCE, RESOURCE_STATE_COPY_DST), + GPUBarrier::Buffer(&vis.scene->meshBuffer, RESOURCE_STATE_SHADER_RESOURCE, RESOURCE_STATE_COPY_DST), + GPUBarrier::Buffer(&vis.scene->materialBuffer, RESOURCE_STATE_SHADER_RESOURCE, RESOURCE_STATE_COPY_DST), + GPUBarrier::Buffer(&resourceBuffers[RBTYPE_ENTITYARRAY], RESOURCE_STATE_SHADER_RESOURCE, RESOURCE_STATE_COPY_DST), + GPUBarrier::Buffer(&resourceBuffers[RBTYPE_MATRIXARRAY], RESOURCE_STATE_SHADER_RESOURCE, RESOURCE_STATE_COPY_DST), + }; + device->Barrier(barriers, arraysize(barriers), cmd); } + device->UpdateBuffer(&constantBuffers[CBTYPE_FRAME], &frameCB, cmd); + device->UpdateBuffer(&vis.scene->instanceBuffer, vis.scene->instanceData.data(), cmd); + device->UpdateBuffer(&vis.scene->meshBuffer, vis.scene->meshData.data(), cmd); + device->UpdateBuffer(&vis.scene->materialBuffer, vis.scene->materialData.data(), cmd); + // Fill Entity Array with decals + envprobes + lights in the frustum: { // Reserve temporary entity array for GPU data upload: @@ -3842,34 +3371,19 @@ void UpdateRenderData( entityArray[entityCounter].SetIndices(matrixCounter, 0); matrixArray[matrixCounter] = XMMatrixInverse(nullptr, XMLoadFloat4x4(&decal.world)); - XMFLOAT4 atlasMulAdd; + int texture = -1; if (decal.texture != nullptr) { - const TextureDesc& desc = vis.scene->decalAtlas.GetDesc(); - - wiRectPacker::rect_xywh rect = vis.scene->packedDecals.at(decal.texture); - - // eliminate border expansion: - rect.x += Scene::atlasClampBorder; - rect.y += Scene::atlasClampBorder; - rect.w -= Scene::atlasClampBorder * 2; - rect.h -= Scene::atlasClampBorder * 2; - - atlasMulAdd = XMFLOAT4( - (float)rect.w / (float)desc.Width, - (float)rect.h / (float)desc.Height, - (float)rect.x / (float)desc.Width, - (float)rect.y / (float)desc.Height - ); + texture = device->GetDescriptorIndex(&decal.texture->texture, SRV); } - else + int normal = -1; + if (decal.normal != nullptr) { - atlasMulAdd = XMFLOAT4(0, 0, 0, 0); + normal = device->GetDescriptorIndex(&decal.normal->texture, SRV); } - matrixArray[matrixCounter].r[0] = XMVectorSetW(matrixArray[matrixCounter].r[0], atlasMulAdd.x); - matrixArray[matrixCounter].r[1] = XMVectorSetW(matrixArray[matrixCounter].r[1], atlasMulAdd.y); - matrixArray[matrixCounter].r[2] = XMVectorSetW(matrixArray[matrixCounter].r[2], atlasMulAdd.z); - matrixArray[matrixCounter].r[3] = XMVectorSetW(matrixArray[matrixCounter].r[3], atlasMulAdd.w); + matrixArray[matrixCounter].r[0] = XMVectorSetW(matrixArray[matrixCounter].r[0], *(float*)&texture); + matrixArray[matrixCounter].r[1] = XMVectorSetW(matrixArray[matrixCounter].r[1], *(float*)&normal); + matrixCounter++; entityCounter++; @@ -4077,32 +3591,54 @@ void UpdateRenderData( device->UpdateBuffer(&resourceBuffers[RBTYPE_ENTITYARRAY], entityArray, cmd, sizeof(ShaderEntity)*entityCounter); device->UpdateBuffer(&resourceBuffers[RBTYPE_MATRIXARRAY], matrixArray, cmd, sizeof(XMMATRIX)*matrixCounter); + // Temporary array for GPU entities can be freed now: GetRenderFrameAllocator(cmd).free(sizeof(ShaderEntity)*SHADER_ENTITY_COUNT); GetRenderFrameAllocator(cmd).free(sizeof(XMMATRIX)*MATRIXARRAY_COUNT); } + // End copy barriers: + { + GPUBarrier barriers[] = { + GPUBarrier::Buffer(&constantBuffers[CBTYPE_FRAME], RESOURCE_STATE_COPY_DST, RESOURCE_STATE_CONSTANT_BUFFER), + GPUBarrier::Buffer(&vis.scene->instanceBuffer, RESOURCE_STATE_COPY_DST, RESOURCE_STATE_SHADER_RESOURCE), + GPUBarrier::Buffer(&vis.scene->meshBuffer, RESOURCE_STATE_COPY_DST, RESOURCE_STATE_SHADER_RESOURCE), + GPUBarrier::Buffer(&vis.scene->materialBuffer, RESOURCE_STATE_COPY_DST, RESOURCE_STATE_SHADER_RESOURCE), + GPUBarrier::Buffer(&resourceBuffers[RBTYPE_ENTITYARRAY], RESOURCE_STATE_COPY_DST, RESOURCE_STATE_SHADER_RESOURCE), + GPUBarrier::Buffer(&resourceBuffers[RBTYPE_MATRIXARRAY], RESOURCE_STATE_COPY_DST, RESOURCE_STATE_SHADER_RESOURCE), + }; + device->Barrier(barriers, arraysize(barriers), cmd); + } + + BindCommonResources(cmd); + UpdateCameraCB( + *vis.camera, + *vis.camera, + *vis.camera, + cmd + ); + auto range = wiProfiler::BeginRangeGPU("Skinning", cmd); device->EventBegin("Skinning", cmd); { - bool streamOutSetUp = false; - SHADERTYPE lastCS = CSTYPE_SKINNING_LDS; - GPUBarrier* barriers_start = (GPUBarrier*)GetRenderFrameAllocator(cmd).top(); - uint32_t numBarriers = 0; + for (size_t i = 0; i < vis.scene->armatures.GetCount(); ++i) + { + const ArmatureComponent& armature = vis.scene->armatures[i]; + // Upload bones for skinning to shader + device->UpdateBuffer(&armature.boneBuffer, armature.boneData.data(), cmd); + + barrier_stack[cmd].push_back(GPUBarrier::Buffer(&armature.boneBuffer, RESOURCE_STATE_COPY_DST, RESOURCE_STATE_SHADER_RESOURCE)); + } + barrier_stack_flush(cmd); for (size_t i = 0; i < vis.scene->meshes.GetCount(); ++i) { Entity entity = vis.scene->meshes.GetEntity(i); const MeshComponent& mesh = vis.scene->meshes[i]; - if (mesh.dirty_bindless && device->CheckCapability(GRAPHICSDEVICE_CAPABILITY_BINDLESS_DESCRIPTORS)) + if (mesh.dirty_subsets) { - mesh.dirty_bindless = false; - - ShaderMesh shadermesh; - mesh.WriteShaderMesh(&shadermesh); - - int mesh_descriptor = device->GetDescriptorIndex(&mesh.descriptor, SRV); + mesh.dirty_subsets = false; size_t tmp_alloc = sizeof(ShaderMeshSubset) * mesh.subsets.size(); ShaderMeshSubset* subsetarray = (ShaderMeshSubset*)GetRenderFrameAllocator(cmd).allocate(tmp_alloc); @@ -4111,25 +3647,19 @@ void UpdateRenderData( { ShaderMeshSubset& shadersubset = subsetarray[j++]; shadersubset.indexOffset = x.indexOffset; - shadersubset.indexCount = x.indexCount; - shadersubset.mesh = mesh_descriptor; - - const MaterialComponent* material = vis.scene->materials.GetComponent(x.materialID); - if (material != nullptr) - { - shadersubset.material = device->GetDescriptorIndex(&material->constantBuffer, SRV); - } + shadersubset.materialIndex = (uint)vis.scene->materials.GetIndex(x.materialID); } - - device->UpdateBuffer(&mesh.descriptor, &shadermesh, cmd); - device->UpdateBuffer(&mesh.subsetBuffer, subsetarray, cmd); GetRenderFrameAllocator(cmd).free(tmp_alloc); + + device->UpdateBuffer(&mesh.subsetBuffer, subsetarray, cmd); + barrier_stack[cmd].push_back(GPUBarrier::Buffer(&mesh.subsetBuffer, RESOURCE_STATE_COPY_DST, RESOURCE_STATE_SHADER_RESOURCE)); } if (mesh.dirty_morph) { mesh.dirty_morph = false; wiRenderer::GetDevice()->UpdateBuffer(&mesh.vertexBuffer_POS, mesh.vertex_positions_morphed.data(), cmd); + barrier_stack[cmd].push_back(GPUBarrier::Buffer(&mesh.vertexBuffer_POS, RESOURCE_STATE_COPY_DST, RESOURCE_STATE_SHADER_RESOURCE)); } if (mesh.IsSkinned() && vis.scene->armatures.Contains(mesh.armatureID)) @@ -4144,36 +3674,7 @@ void UpdateRenderData( const ArmatureComponent& armature = *vis.scene->armatures.GetComponent(mesh.armatureID); - if (!streamOutSetUp) - { - // Set up skinning shader - streamOutSetUp = true; - GPUBuffer* vbs[] = { - nullptr,nullptr,nullptr,nullptr,nullptr,nullptr,nullptr,nullptr - }; - const uint32_t strides[] = { - 0,0,0,0,0,0,0,0 - }; - device->BindVertexBuffers(vbs, 0, arraysize(vbs), strides, nullptr, cmd); - device->BindComputeShader(&shaders[CSTYPE_SKINNING_LDS], cmd); - } - - SHADERTYPE targetCS = CSTYPE_SKINNING_LDS; - - if (!GetLDSSkinningEnabled() || armature.boneData.size() > SKINNING_COMPUTE_THREADCOUNT) - { - // If we have more bones that can fit into LDS, we switch to a skinning shader which loads from device memory: - targetCS = CSTYPE_SKINNING; - } - - if (targetCS != lastCS) - { - lastCS = targetCS; - device->BindComputeShader(&shaders[targetCS], cmd); - } - - // Upload bones for skinning to shader - device->UpdateBuffer(&armature.boneBuffer, armature.boneData.data(), cmd, (int)(sizeof(ArmatureComponent::ShaderBoneType) * armature.boneData.size())); + device->BindComputeShader(&shaders[CSTYPE_SKINNING], cmd); // Do the skinning const GPUResource* vbs[] = { @@ -4187,50 +3688,41 @@ void UpdateRenderData( &mesh.streamoutBuffer_TAN, }; - numBarriers += arraysize(uavs); - GPUBarrier* barriers = (GPUBarrier*)GetRenderFrameAllocator(cmd).allocate(sizeof(GPUBarrier) * arraysize(uavs)); - barriers[0] = GPUBarrier::Buffer(&mesh.streamoutBuffer_POS, BUFFER_STATE_UNORDERED_ACCESS, BUFFER_STATE_SHADER_RESOURCE); - barriers[1] = GPUBarrier::Buffer(&mesh.streamoutBuffer_TAN, BUFFER_STATE_UNORDERED_ACCESS, BUFFER_STATE_SHADER_RESOURCE); - // Barriers will be issued later... + device->BindResources(vbs, SKINNINGSLOT_IN_VERTEX_POS, arraysize(vbs), cmd); + device->BindUAVs(uavs, 0, arraysize(uavs), cmd); - device->BindResources(CS, vbs, SKINNINGSLOT_IN_VERTEX_POS, arraysize(vbs), cmd); - device->BindUAVs(CS, uavs, 0, arraysize(uavs), cmd); + device->Dispatch(((uint32_t)mesh.vertex_positions.size() + 63) / 64, 1, 1, cmd); + + barrier_stack[cmd].push_back(GPUBarrier::Buffer(&mesh.streamoutBuffer_POS, RESOURCE_STATE_UNORDERED_ACCESS, RESOURCE_STATE_SHADER_RESOURCE)); + barrier_stack[cmd].push_back(GPUBarrier::Buffer(&mesh.streamoutBuffer_TAN, RESOURCE_STATE_UNORDERED_ACCESS, RESOURCE_STATE_SHADER_RESOURCE)); - device->Dispatch(((uint32_t)mesh.vertex_positions.size() + SKINNING_COMPUTE_THREADCOUNT - 1) / SKINNING_COMPUTE_THREADCOUNT, 1, 1, cmd); } } - if (streamOutSetUp) + // Soft body updates: + for (size_t i = 0; i < vis.scene->softbodies.GetCount(); ++i) { - numBarriers++; - GPUBarrier* barriers = (GPUBarrier*)GetRenderFrameAllocator(cmd).allocate(sizeof(GPUBarrier)); - barriers[0] = GPUBarrier::Memory(); - device->Barrier(barriers_start, numBarriers, cmd); - GetRenderFrameAllocator(cmd).free(sizeof(GPUBarrier) * numBarriers); + Entity entity = vis.scene->softbodies.GetEntity(i); + const SoftBodyPhysicsComponent& softbody = vis.scene->softbodies[i]; - device->UnbindUAVs(0, 2, cmd); - device->UnbindResources(SKINNINGSLOT_IN_VERTEX_POS, 4, cmd); + const MeshComponent* mesh = vis.scene->meshes.GetComponent(entity); + if (mesh != nullptr) + { + device->UpdateBuffer(&mesh->streamoutBuffer_POS, softbody.vertex_positions_simulation.data(), cmd); + device->UpdateBuffer(&mesh->streamoutBuffer_TAN, softbody.vertex_tangents_simulation.data(), cmd); + + barrier_stack[cmd].push_back(GPUBarrier::Buffer(&mesh->streamoutBuffer_POS, RESOURCE_STATE_COPY_DST, RESOURCE_STATE_SHADER_RESOURCE)); + barrier_stack[cmd].push_back(GPUBarrier::Buffer(&mesh->streamoutBuffer_TAN, RESOURCE_STATE_COPY_DST, RESOURCE_STATE_SHADER_RESOURCE)); + } } + barrier_stack_flush(cmd); + } device->EventEnd(cmd); wiProfiler::EndRange(range); // skinning - // Soft body updates: - for (size_t i = 0; i < vis.scene->softbodies.GetCount(); ++i) - { - Entity entity = vis.scene->softbodies.GetEntity(i); - const SoftBodyPhysicsComponent& softbody = vis.scene->softbodies[i]; - - const MeshComponent* mesh = vis.scene->meshes.GetComponent(entity); - if (mesh != nullptr) - { - device->UpdateBuffer(&mesh->streamoutBuffer_POS, softbody.vertex_positions_simulation.data(), cmd); - device->UpdateBuffer(&mesh->streamoutBuffer_TAN, softbody.vertex_tangents_simulation.data(), cmd); - } - } - // GPU Particle systems simulation/sorting/culling: if (!vis.visibleEmitters.empty()) { @@ -4243,7 +3735,7 @@ void UpdateRenderData( const MaterialComponent& material = *vis.scene->materials.GetComponent(entity); const MeshComponent* mesh = vis.scene->meshes.GetComponent(emitter.meshID); - emitter.UpdateGPU(transform, material, mesh, cmd); + emitter.UpdateGPU((uint32_t)vis.scene->materials.GetIndex(entity), transform, mesh, cmd); } wiProfiler::EndRange(range); } @@ -4260,9 +3752,10 @@ void UpdateRenderData( if (mesh != nullptr) { Entity entity = vis.scene->hairs.GetEntity(hairIndex); - const MaterialComponent& material = *vis.scene->materials.GetComponent(entity); + size_t materialIndex = vis.scene->materials.GetIndex(entity); + const MaterialComponent& material = vis.scene->materials[materialIndex]; - hair.UpdateGPU(*mesh, material, cmd); + hair.UpdateGPU((uint32_t)vis.scene->objects.GetCount() + hairIndex, (uint32_t)materialIndex, *mesh, material, cmd); } } wiProfiler::EndRange(range); @@ -4294,11 +3787,11 @@ void UpdateRenderData( const GPUResource* uavs[] = { &texture_shapeNoise, }; - device->BindUAVs(CS, uavs, 0, arraysize(uavs), cmd); + device->BindUAVs(uavs, 0, arraysize(uavs), cmd); { GPUBarrier barriers[] = { - GPUBarrier::Image(&texture_shapeNoise, texture_shapeNoise.desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS), + GPUBarrier::Image(&texture_shapeNoise, texture_shapeNoise.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS), }; device->Barrier(barriers, arraysize(barriers), cmd); } @@ -4309,7 +3802,6 @@ void UpdateRenderData( device->Dispatch(noiseThreadXY, noiseThreadXY, noiseThreadZ, cmd); - device->UnbindUAVs(0, arraysize(uavs), cmd); device->EventEnd(cmd); } @@ -4321,11 +3813,11 @@ void UpdateRenderData( const GPUResource* uavs[] = { &texture_detailNoise, }; - device->BindUAVs(CS, uavs, 0, arraysize(uavs), cmd); + device->BindUAVs(uavs, 0, arraysize(uavs), cmd); { GPUBarrier barriers[] = { - GPUBarrier::Image(&texture_detailNoise, texture_detailNoise.desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS), + GPUBarrier::Image(&texture_detailNoise, texture_detailNoise.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS), }; device->Barrier(barriers, arraysize(barriers), cmd); } @@ -4335,14 +3827,13 @@ void UpdateRenderData( device->Dispatch(noiseThreadXYZ, noiseThreadXYZ, noiseThreadXYZ, cmd); - device->UnbindUAVs(0, arraysize(uavs), cmd); device->EventEnd(cmd); } { GPUBarrier barriers[] = { - GPUBarrier::Image(&texture_shapeNoise, IMAGE_LAYOUT_UNORDERED_ACCESS, texture_shapeNoise.desc.layout), - GPUBarrier::Image(&texture_detailNoise, IMAGE_LAYOUT_UNORDERED_ACCESS, texture_detailNoise.desc.layout), + GPUBarrier::Image(&texture_shapeNoise, RESOURCE_STATE_UNORDERED_ACCESS, texture_shapeNoise.desc.layout), + GPUBarrier::Image(&texture_detailNoise, RESOURCE_STATE_UNORDERED_ACCESS, texture_detailNoise.desc.layout), }; device->Barrier(barriers, arraysize(barriers), cmd); } @@ -4359,11 +3850,11 @@ void UpdateRenderData( const GPUResource* uavs[] = { &texture_curlNoise, }; - device->BindUAVs(CS, uavs, 0, arraysize(uavs), cmd); + device->BindUAVs(uavs, 0, arraysize(uavs), cmd); { GPUBarrier barriers[] = { - GPUBarrier::Image(&texture_curlNoise, texture_curlNoise.desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS), + GPUBarrier::Image(&texture_curlNoise, texture_curlNoise.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS), }; device->Barrier(barriers, arraysize(barriers), cmd); } @@ -4374,7 +3865,13 @@ void UpdateRenderData( device->Dispatch(curlThread, curlThread, 1, cmd); - device->UnbindUAVs(0, arraysize(uavs), cmd); + { + GPUBarrier barriers[] = { + GPUBarrier::Image(&texture_curlNoise, RESOURCE_STATE_UNORDERED_ACCESS, texture_curlNoise.desc.layout), + }; + device->Barrier(barriers, arraysize(barriers), cmd); + } + device->EventEnd(cmd); } @@ -4386,11 +3883,11 @@ void UpdateRenderData( const GPUResource* uavs[] = { &texture_weatherMap, }; - device->BindUAVs(CS, uavs, 0, arraysize(uavs), cmd); + device->BindUAVs(uavs, 0, arraysize(uavs), cmd); { GPUBarrier barriers[] = { - GPUBarrier::Image(&texture_weatherMap, texture_weatherMap.desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS), + GPUBarrier::Image(&texture_weatherMap, texture_weatherMap.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS), }; device->Barrier(barriers, arraysize(barriers), cmd); } @@ -4403,20 +3900,21 @@ void UpdateRenderData( { GPUBarrier barriers[] = { GPUBarrier::Memory(), - GPUBarrier::Image(&texture_weatherMap, IMAGE_LAYOUT_UNORDERED_ACCESS, texture_weatherMap.desc.layout), + GPUBarrier::Image(&texture_weatherMap, RESOURCE_STATE_UNORDERED_ACCESS, texture_weatherMap.desc.layout), }; device->Barrier(barriers, arraysize(barriers), cmd); } - device->UnbindUAVs(0, arraysize(uavs), cmd); device->EventEnd(cmd); } volumetric_clouds_precomputed = true; } + + device->EventEnd(cmd); } void UpdateRaytracingAccelerationStructures(const Scene& scene, CommandList cmd) { - if (device->CheckCapability(GRAPHICSDEVICE_CAPABILITY_RAYTRACING_PIPELINE) || device->CheckCapability(GRAPHICSDEVICE_CAPABILITY_RAYTRACING_INLINE)) + if (device->CheckCapability(GRAPHICSDEVICE_CAPABILITY_RAYTRACING)) { if (!scene.TLAS.IsValid()) @@ -4449,6 +3947,16 @@ void UpdateRaytracingAccelerationStructures(const Scene& scene, CommandList cmd) } } + for (size_t i = 0; i < scene.hairs.GetCount(); ++i) + { + const wiHairParticle& hair = scene.hairs[i]; + + if (hair.meshID != INVALID_ENTITY && hair.BLAS.IsValid()) + { + device->BuildRaytracingAccelerationStructure(&hair.BLAS, cmd, nullptr); + } + } + { GPUBarrier barriers[] = { GPUBarrier::Memory(), @@ -4467,7 +3975,20 @@ void UpdateRaytracingAccelerationStructures(const Scene& scene, CommandList cmd) auto range = wiProfiler::BeginRangeGPU("TLAS Update (GPU)", cmd); device->EventBegin("TLAS Update", cmd); + { + GPUBarrier barriers[] = { + GPUBarrier::Buffer(&scene.TLAS.desc.toplevel.instanceBuffer, RESOURCE_STATE_SHADER_RESOURCE, RESOURCE_STATE_COPY_DST), + }; + device->Barrier(barriers, arraysize(barriers), cmd); + } device->UpdateBuffer(&scene.TLAS.desc.toplevel.instanceBuffer, scene.TLAS_instances.data(), cmd); + { + GPUBarrier barriers[] = { + GPUBarrier::Buffer(&scene.TLAS.desc.toplevel.instanceBuffer, RESOURCE_STATE_COPY_DST, RESOURCE_STATE_SHADER_RESOURCE), + }; + device->Barrier(barriers, arraysize(barriers), cmd); + } + device->BuildRaytracingAccelerationStructure(&scene.TLAS, cmd, nullptr); { @@ -4484,11 +4005,31 @@ void UpdateRaytracingAccelerationStructures(const Scene& scene, CommandList cmd) } else { + BindCommonResources(cmd); scene.BVH.Build(scene, cmd); } scene.acceleration_structure_update_requested = false; } + + +void OcclusionCulling_Reset(const Visibility& vis, wiGraphics::CommandList cmd) +{ + if (!GetOcclusionCullingEnabled() || GetFreezeCullingCameraEnabled()) + { + return; + } + + int query_write = vis.scene->queryheap_idx; + const GPUQueryHeap& queryHeap = vis.scene->queryHeap[query_write]; + + device->QueryReset( + &queryHeap, + 0, + queryHeap.desc.queryCount, + cmd + ); +} void OcclusionCulling_Render(const CameraComponent& camera_previous, const Visibility& vis, CommandList cmd) { if (!GetOcclusionCullingEnabled() || GetFreezeCullingCameraEnabled()) @@ -4506,7 +4047,6 @@ void OcclusionCulling_Render(const CameraComponent& camera_previous, const Visib const GPUQueryHeap& queryHeap = vis.scene->queryHeap[query_write]; device->BindPipelineState(&PSO_occlusionquery, cmd); - const bool bindless = device->CheckCapability(GRAPHICSDEVICE_CAPABILITY_BINDLESS_DESCRIPTORS); XMMATRIX VP = camera_previous.GetViewProjection(); @@ -4525,18 +4065,7 @@ void OcclusionCulling_Render(const CameraComponent& camera_previous, const Visib const XMMATRIX transform = aabb.getAsBoxMatrix() * VP; - if (bindless) - { - device->PushConstants(&transform, sizeof(transform), cmd); - } - else - { - MiscCB cb; - XMStoreFloat4x4(&cb.g_xTransform, transform); - device->UpdateBuffer(&constantBuffers[CBTYPE_MISC], &cb, cmd); - device->BindConstantBuffer(VS, &constantBuffers[CBTYPE_MISC], CB_GETBINDSLOT(MiscCB), cmd); - - } + device->PushConstants(&transform, sizeof(transform), cmd); // render bounding box to later read the occlusion status device->QueryBegin(&queryHeap, queryIndex, cmd); @@ -4545,18 +4074,33 @@ void OcclusionCulling_Render(const CameraComponent& camera_previous, const Visib } } - device->QueryResolve( - &queryHeap, - 0, - vis.scene->writtenQueries[query_write], - cmd - ); - device->EventEnd(cmd); } wiProfiler::EndRange(range); // Occlusion Culling Render } +void OcclusionCulling_Resolve(const Visibility& vis, wiGraphics::CommandList cmd) +{ + if (!GetOcclusionCullingEnabled() || GetFreezeCullingCameraEnabled()) + { + return; + } + + if (!vis.visibleObjects.empty()) + { + int query_write = vis.scene->queryheap_idx; + const GPUQueryHeap& queryHeap = vis.scene->queryHeap[query_write]; + + device->QueryResolve( + &queryHeap, + 0, + vis.scene->writtenQueries[query_write], + &vis.scene->queryResultBuffer[query_write], + 0ull, + cmd + ); + } +} void DrawWaterRipples(const Visibility& vis, CommandList cmd) { @@ -4598,7 +4142,7 @@ void DrawSoftParticles( wiProfiler::BeginRangeGPU("EmittedParticles - Render (Distortion)", cmd) : wiProfiler::BeginRangeGPU("EmittedParticles - Render", cmd); - device->BindResource(PS, &lineardepth, TEXSLOT_LINEARDEPTH, cmd); + device->BindResource(&lineardepth, TEXSLOT_LINEARDEPTH, cmd); // Sort emitters based on distance: assert(emitterCount < 0x0000FFFF); // watch out for sorting hash truncation! @@ -4623,11 +4167,11 @@ void DrawSoftParticles( if (distortion && emitter.shaderType == wiEmittedParticle::SOFT_DISTORTION) { - emitter.Draw(*vis.camera, material, cmd); + emitter.Draw(material, cmd); } else if (!distortion && (emitter.shaderType == wiEmittedParticle::SOFT || emitter.shaderType == wiEmittedParticle::SOFT_LIGHTING || emitter.shaderType == wiEmittedParticle::SIMPLE || IsWireRender())) { - emitter.Draw(*vis.camera, material, cmd); + emitter.Draw(material, cmd); } } @@ -4644,9 +4188,6 @@ void DrawLightVisualizers( { device->EventBegin("Light Visualizer Render", cmd); - device->BindConstantBuffer(PS, &constantBuffers[CBTYPE_VOLUMELIGHT], CB_GETBINDSLOT(VolumeLightCB), cmd); - device->BindConstantBuffer(VS, &constantBuffers[CBTYPE_VOLUMELIGHT], CB_GETBINDSLOT(VolumeLightCB), cmd); - XMMATRIX camrot = XMLoadFloat3x3(&vis.camera->rotationMatrix); XMMATRIX VP = vis.camera->GetViewProjection(); @@ -4675,7 +4216,7 @@ void DrawLightVisualizers( XMMatrixTranslationFromVector(XMLoadFloat3(&light.position)) ); - device->UpdateBuffer(&constantBuffers[CBTYPE_VOLUMELIGHT], &lcb, cmd); + device->BindDynamicConstantBuffer(lcb, CB_GETBINDSLOT(VolumeLightCB), cmd); device->Draw(108, 0, cmd); // circle } @@ -4689,7 +4230,7 @@ void DrawLightVisualizers( XMMatrixTranslationFromVector(XMLoadFloat3(&light.position)) ); - device->UpdateBuffer(&constantBuffers[CBTYPE_VOLUMELIGHT], &lcb, cmd); + device->BindDynamicConstantBuffer(lcb, CB_GETBINDSLOT(VolumeLightCB), cmd); device->Draw(192, 0, cmd); // cone } @@ -4713,13 +4254,9 @@ void DrawVolumeLights( { device->EventBegin("Volumetric Light Render", cmd); - BindShadowmaps(PS, cmd); + BindCommonResources(cmd); - device->BindResource(PS, &depthbuffer, TEXSLOT_DEPTH, cmd); - device->BindResource(PS, &textures[TEXTYPE_2D_SKYATMOSPHERE_SKYVIEWLUT], TEXSLOT_SKYVIEWLUT, cmd); - device->BindResource(PS, &textures[TEXTYPE_2D_SKYATMOSPHERE_TRANSMITTANCELUT], TEXSLOT_TRANSMITTANCELUT, cmd); - device->BindResource(PS, &textures[TEXTYPE_2D_SKYATMOSPHERE_MULTISCATTEREDLUMINANCELUT], TEXSLOT_MULTISCATTERINGLUT, cmd); - device->BindResource(PS, &textures[TEXTYPE_2D_SKYATMOSPHERE_SKYLUMINANCELUT], TEXSLOT_SKYLUMINANCELUT, cmd); + device->BindResource(&depthbuffer, TEXSLOT_DEPTH, cmd); XMMATRIX VP = vis.camera->GetViewProjection(); @@ -4747,9 +4284,7 @@ void DrawVolumeLights( { MiscCB miscCb; miscCb.g_xColor.x = float(i); - device->UpdateBuffer(&constantBuffers[CBTYPE_MISC], &miscCb, cmd); - device->BindConstantBuffer(VS, &constantBuffers[CBTYPE_MISC], CB_GETBINDSLOT(MiscCB), cmd); - device->BindConstantBuffer(PS, &constantBuffers[CBTYPE_MISC], CB_GETBINDSLOT(MiscCB), cmd); + device->BindDynamicConstantBuffer(miscCb, CB_GETBINDSLOT(MiscCB), cmd); device->Draw(3, 0, cmd); // full screen triangle } @@ -4760,9 +4295,7 @@ void DrawVolumeLights( miscCb.g_xColor.x = float(i); float sca = light.GetRange() + 1; XMStoreFloat4x4(&miscCb.g_xTransform, XMMatrixScaling(sca, sca, sca)*XMMatrixTranslationFromVector(XMLoadFloat3(&light.position)) * VP); - device->UpdateBuffer(&constantBuffers[CBTYPE_MISC], &miscCb, cmd); - device->BindConstantBuffer(VS, &constantBuffers[CBTYPE_MISC], CB_GETBINDSLOT(MiscCB), cmd); - device->BindConstantBuffer(PS, &constantBuffers[CBTYPE_MISC], CB_GETBINDSLOT(MiscCB), cmd); + device->BindDynamicConstantBuffer(miscCb, CB_GETBINDSLOT(MiscCB), cmd); device->Draw(240, 0, cmd); // icosphere } @@ -4778,9 +4311,7 @@ void DrawVolumeLights( XMMatrixTranslationFromVector(XMLoadFloat3(&light.position)) * VP ); - device->UpdateBuffer(&constantBuffers[CBTYPE_MISC], &miscCb, cmd); - device->BindConstantBuffer(VS, &constantBuffers[CBTYPE_MISC], CB_GETBINDSLOT(MiscCB), cmd); - device->BindConstantBuffer(PS, &constantBuffers[CBTYPE_MISC], CB_GETBINDSLOT(MiscCB), cmd); + device->BindDynamicConstantBuffer(miscCb, CB_GETBINDSLOT(MiscCB), cmd); device->Draw(192, 0, cmd); // cone } @@ -4809,7 +4340,7 @@ void DrawLensFlares( device->EventBegin("Lens Flares", cmd); - device->BindResource(VS, &depthbuffer, TEXSLOT_DEPTH, cmd); + device->BindResource(&depthbuffer, TEXSLOT_DEPTH, cmd); for (auto visibleLight : vis.visibleLights) { @@ -4831,11 +4362,11 @@ void DrawLensFlares( // Directional light can use occlusion texture (eg. clouds): if (texture_directional_occlusion == nullptr) { - device->BindResource(VS, wiTextureHelper::getWhite(), TEXSLOT_ONDEMAND0, cmd); + device->BindResource(wiTextureHelper::getWhite(), TEXSLOT_ONDEMAND0, cmd); } else { - device->BindResource(VS, texture_directional_occlusion, TEXSLOT_ONDEMAND0, cmd); + device->BindResource(texture_directional_occlusion, TEXSLOT_ONDEMAND0, cmd); } } else @@ -4844,18 +4375,17 @@ void DrawLensFlares( POS = XMLoadFloat3(&light.position); // not using occlusion texture - device->BindResource(VS, wiTextureHelper::getWhite(), TEXSLOT_ONDEMAND0, cmd); + device->BindResource(wiTextureHelper::getWhite(), TEXSLOT_ONDEMAND0, cmd); } if (XMVectorGetX(XMVector3Dot(XMVectorSubtract(POS, vis.camera->GetEye()), vis.camera->GetAt())) > 0) // check if the camera is facing towards the flare or not { device->BindPipelineState(&PSO_lensflare, cmd); - device->BindConstantBuffer(VS, &constantBuffers[CBTYPE_LENSFLARE], CB_GETBINDSLOT(LensFlareCB), cmd); // Get the screen position of the flare: XMVECTOR flarePos = XMVector3Project(POS, 0, 0, 1, 1, 1, 0, vis.camera->GetProjection(), vis.camera->GetView(), XMMatrixIdentity()); - LensFlareCB cb; + LensFlarePush cb; XMStoreFloat3(&cb.xLensFlarePos, flarePos); uint32_t i = 0; @@ -4873,9 +4403,9 @@ void DrawLensFlares( cb.xLensFlareSize.x = (float)x->texture.desc.Width; cb.xLensFlareSize.y = (float)x->texture.desc.Height; - device->UpdateBuffer(&constantBuffers[CBTYPE_LENSFLARE], &cb, cmd); + device->PushConstants(&cb, sizeof(cb), cmd); - device->BindResource(PS, &x->texture, TEXSLOT_ONDEMAND1, cmd); + device->BindResource(&x->texture, TEXSLOT_ONDEMAND1, cmd); device->Draw(4, 0, cmd); i++; } @@ -4910,17 +4440,15 @@ void SetShadowProps2D(int resolution, int count) desc.ArraySize = SHADOWCOUNT_2D; desc.SampleCount = 1; desc.Usage = USAGE_DEFAULT; - desc.CPUAccessFlags = 0; - desc.MiscFlags = 0; desc.BindFlags = BIND_DEPTH_STENCIL | BIND_SHADER_RESOURCE; desc.Format = FORMAT_R16_TYPELESS; - desc.layout = IMAGE_LAYOUT_SHADER_RESOURCE; + desc.layout = RESOURCE_STATE_SHADER_RESOURCE; device->CreateTexture(&desc, nullptr, &shadowMapArray_2D); desc.BindFlags = BIND_RENDER_TARGET | BIND_SHADER_RESOURCE; desc.Format = FORMAT_R16G16B16A16_FLOAT; - desc.layout = IMAGE_LAYOUT_SHADER_RESOURCE; + desc.layout = RESOURCE_STATE_SHADER_RESOURCE; desc.clear.color[0] = 1; desc.clear.color[1] = 1; desc.clear.color[2] = 1; @@ -4944,9 +4472,9 @@ void SetShadowProps2D(int resolution, int count) &shadowMapArray_2D, RenderPassAttachment::LOADOP_CLEAR, RenderPassAttachment::STOREOP_STORE, - IMAGE_LAYOUT_SHADER_RESOURCE, - IMAGE_LAYOUT_DEPTHSTENCIL, - IMAGE_LAYOUT_SHADER_RESOURCE + RESOURCE_STATE_SHADER_RESOURCE, + RESOURCE_STATE_DEPTHSTENCIL, + RESOURCE_STATE_SHADER_RESOURCE ) ); renderpassdesc.attachments.back().subresource = subresource_index; @@ -4956,9 +4484,9 @@ void SetShadowProps2D(int resolution, int count) &shadowMapArray_Transparent_2D, RenderPassAttachment::LOADOP_CLEAR, RenderPassAttachment::STOREOP_STORE, - IMAGE_LAYOUT_SHADER_RESOURCE, - IMAGE_LAYOUT_RENDERTARGET, - IMAGE_LAYOUT_SHADER_RESOURCE + RESOURCE_STATE_SHADER_RESOURCE, + RESOURCE_STATE_RENDERTARGET, + RESOURCE_STATE_SHADER_RESOURCE ) ); renderpassdesc.attachments.back().subresource = subresource_index; @@ -4988,17 +4516,16 @@ void SetShadowPropsCube(int resolution, int count) desc.ArraySize = 6 * SHADOWCOUNT_CUBE; desc.SampleCount = 1; desc.Usage = USAGE_DEFAULT; - desc.CPUAccessFlags = 0; desc.MiscFlags = RESOURCE_MISC_TEXTURECUBE; desc.BindFlags = BIND_DEPTH_STENCIL | BIND_SHADER_RESOURCE; desc.Format = FORMAT_R16_TYPELESS; - desc.layout = IMAGE_LAYOUT_SHADER_RESOURCE; + desc.layout = RESOURCE_STATE_SHADER_RESOURCE; device->CreateTexture(&desc, nullptr, &shadowMapArray_Cube); desc.BindFlags = BIND_RENDER_TARGET | BIND_SHADER_RESOURCE; desc.Format = FORMAT_R16G16B16A16_FLOAT; - desc.layout = IMAGE_LAYOUT_SHADER_RESOURCE; + desc.layout = RESOURCE_STATE_SHADER_RESOURCE; desc.clear.color[0] = 1; desc.clear.color[1] = 1; desc.clear.color[2] = 1; @@ -5021,9 +4548,9 @@ void SetShadowPropsCube(int resolution, int count) &shadowMapArray_Cube, RenderPassAttachment::LOADOP_CLEAR, RenderPassAttachment::STOREOP_STORE, - IMAGE_LAYOUT_SHADER_RESOURCE, - IMAGE_LAYOUT_DEPTHSTENCIL, - IMAGE_LAYOUT_SHADER_RESOURCE + RESOURCE_STATE_SHADER_RESOURCE, + RESOURCE_STATE_DEPTHSTENCIL, + RESOURCE_STATE_SHADER_RESOURCE ) ); renderpassdesc.attachments.back().subresource = subresource_index; @@ -5033,9 +4560,9 @@ void SetShadowPropsCube(int resolution, int count) &shadowMapArray_Transparent_Cube, RenderPassAttachment::LOADOP_CLEAR, RenderPassAttachment::STOREOP_STORE, - IMAGE_LAYOUT_SHADER_RESOURCE, - IMAGE_LAYOUT_RENDERTARGET, - IMAGE_LAYOUT_SHADER_RESOURCE + RESOURCE_STATE_SHADER_RESOURCE, + RESOURCE_STATE_RENDERTARGET, + RESOURCE_STATE_SHADER_RESOURCE ) ); renderpassdesc.attachments.back().subresource = subresource_index; @@ -5059,8 +4586,7 @@ void DrawShadowmaps( auto range = wiProfiler::BeginRangeGPU("Shadow Rendering", cmd); BindCommonResources(cmd); - BindConstantBuffers(VS, cmd); - BindConstantBuffers(PS, cmd); + BoundingFrustum cam_frustum; BoundingFrustum::CreateFromMatrix(cam_frustum, vis.camera->GetProjection()); @@ -5068,7 +4594,6 @@ void DrawShadowmaps( cam_frustum.Transform(cam_frustum, vis.camera->GetInvView()); XMStoreFloat4(&cam_frustum.Orientation, XMQuaternionNormalize(XMLoadFloat4(&cam_frustum.Orientation))); - device->UnbindResources(TEXSLOT_SHADOWARRAY_2D, 2, cmd); uint32_t shadowCounter_2D = SHADOWRES_2D > 0 ? 0 : SHADOWCOUNT_2D; uint32_t shadowCounter_Cube = SHADOWRES_CUBE > 0 ? 0 : SHADOWCOUNT_CUBE; @@ -5132,8 +4657,8 @@ void DrawShadowmaps( if (!renderQueue.empty()) { CameraCB cb; - XMStoreFloat4x4(&cb.g_xCamera_VP, shcams[cascade].VP); - device->UpdateBuffer(&constantBuffers[CBTYPE_CAMERA], &cb, cmd); + XMStoreFloat4x4(&cb.VP, shcams[cascade].VP); + device->BindDynamicConstantBuffer(cb, CBSLOT_RENDERER_CAMERA, cmd); Viewport vp; vp.TopLeftX = 0; @@ -5196,8 +4721,8 @@ void DrawShadowmaps( if (!renderQueue.empty()) { CameraCB cb; - XMStoreFloat4x4(&cb.g_xCamera_VP, shcam.VP); - device->UpdateBuffer(&constantBuffers[CBTYPE_CAMERA], &cb, cmd); + XMStoreFloat4x4(&cb.VP, shcam.VP); + device->BindDynamicConstantBuffer(cb, CBSLOT_RENDERER_CAMERA, cmd); Viewport vp; vp.TopLeftX = 0; @@ -5258,9 +4783,7 @@ void DrawShadowmaps( { MiscCB miscCb; miscCb.g_xColor = float4(light.position.x, light.position.y, light.position.z, 0); - device->UpdateBuffer(&constantBuffers[CBTYPE_MISC], &miscCb, cmd); - device->BindConstantBuffer(VS, &constantBuffers[CBTYPE_MISC], CB_GETBINDSLOT(MiscCB), cmd); - device->BindConstantBuffer(PS, &constantBuffers[CBTYPE_MISC], CB_GETBINDSLOT(MiscCB), cmd); + device->BindDynamicConstantBuffer(miscCb, CB_GETBINDSLOT(MiscCB), cmd); const float zNearP = 0.1f; const float zFarP = std::max(1.0f, light.GetRange()); @@ -5286,8 +4809,7 @@ void DrawShadowmaps( frustum_count++; } } - device->UpdateBuffer(&constantBuffers[CBTYPE_CUBEMAPRENDER], &cb, cmd); - device->BindConstantBuffer(VS, &constantBuffers[CBTYPE_CUBEMAPRENDER], CB_GETBINDSLOT(CubemapRenderCB), cmd); + device->BindDynamicConstantBuffer(cb, CB_GETBINDSLOT(CubemapRenderCB), cmd); Viewport vp; vp.TopLeftX = 0; @@ -5336,32 +4858,10 @@ void DrawScene( device->BindShadingRate(SHADING_RATE_1X1, cmd); BindCommonResources(cmd); - BindShadowmaps(PS, cmd); - BindConstantBuffers(VS, cmd); - BindConstantBuffers(PS, cmd); - device->BindResource(PS, &vis.scene->envmapArray, TEXSLOT_ENVMAPARRAY, cmd); - device->BindResource(PS, &textures[TEXTYPE_2D_SKYATMOSPHERE_SKYVIEWLUT], TEXSLOT_SKYVIEWLUT, cmd); - device->BindResource(PS, &textures[TEXTYPE_2D_SKYATMOSPHERE_TRANSMITTANCELUT], TEXSLOT_TRANSMITTANCELUT, cmd); - device->BindResource(PS, &textures[TEXTYPE_2D_SKYATMOSPHERE_MULTISCATTEREDLUMINANCELUT], TEXSLOT_MULTISCATTERINGLUT, cmd); - device->BindResource(PS, &textures[TEXTYPE_2D_SKYATMOSPHERE_SKYLUMINANCELUT], TEXSLOT_SKYLUMINANCELUT, cmd); - device->BindResource(PS, GetVoxelRadianceSecondaryBounceEnabled() ? &textures[TEXTYPE_3D_VOXELRADIANCE_HELPER] : &textures[TEXTYPE_3D_VOXELRADIANCE], TEXSLOT_VOXELRADIANCE, cmd); - - if (vis.scene->weather.skyMap != nullptr) + if (device->CheckCapability(GRAPHICSDEVICE_CAPABILITY_RAYTRACING)) { - device->BindResource(PS, &vis.scene->weather.skyMap->texture, TEXSLOT_GLOBALENVMAP, cmd); - } - - device->BindResource(PS, &vis.scene->lightmap, TEXSLOT_GLOBALLIGHTMAP, cmd); - if (vis.scene->decalAtlas.IsValid()) - { - device->BindResource(PS, &vis.scene->decalAtlas, TEXSLOT_DECALATLAS, cmd); - } - - if (device->CheckCapability(GRAPHICSDEVICE_CAPABILITY_RAYTRACING_PIPELINE) || device->CheckCapability(GRAPHICSDEVICE_CAPABILITY_RAYTRACING_INLINE)) - { - device->BindResource(PS, &vis.scene->TLAS, TEXSLOT_ACCELERATION_STRUCTURE, cmd); - device->BindResource(CS, &vis.scene->TLAS, TEXSLOT_ACCELERATION_STRUCTURE, cmd); + device->BindResource(&vis.scene->TLAS, TEXSLOT_ACCELERATION_STRUCTURE, cmd); } if (transparent && vis.scene->weather.IsOceanEnabled()) @@ -5379,7 +4879,7 @@ void DrawScene( Entity entity = vis.scene->hairs.GetEntity(hairIndex); const MaterialComponent& material = *vis.scene->materials.GetComponent(entity); - hair.Draw(*vis.camera, material, renderPass, cmd); + hair.Draw(material, renderPass, cmd); } } } @@ -5468,7 +4968,6 @@ void DrawDebugWorld( bd.Usage = USAGE_DEFAULT; bd.ByteWidth = sizeof(verts); bd.BindFlags = BIND_VERTEX_BUFFER; - bd.CPUAccessFlags = 0; SubresourceData InitData; InitData.pSysMem = verts; device->CreateBuffer(&bd, &InitData, &wirecubeVB); @@ -5481,7 +4980,6 @@ void DrawDebugWorld( bd.Usage = USAGE_DEFAULT; bd.ByteWidth = sizeof(indices); bd.BindFlags = BIND_INDEX_BUFFER; - bd.CPUAccessFlags = 0; InitData.pSysMem = indices; device->CreateBuffer(&bd, &InitData, &wirecubeIB); } @@ -5489,8 +4987,6 @@ void DrawDebugWorld( device->EventBegin("DrawDebugWorld", cmd); BindCommonResources(cmd); - BindConstantBuffers(VS, cmd); - BindConstantBuffers(PS, cmd); if (debugPartitionTree) { @@ -5517,9 +5013,7 @@ void DrawDebugWorld( XMStoreFloat4x4(&sb.g_xTransform, aabb.getAsBoxMatrix()*camera.GetViewProjection()); sb.g_xColor = XMFLOAT4(1, 0, 0, 1); - device->UpdateBuffer(&constantBuffers[CBTYPE_MISC], &sb, cmd); - device->BindConstantBuffer(VS, &constantBuffers[CBTYPE_MISC], CB_GETBINDSLOT(MiscCB), cmd); - device->BindConstantBuffer(PS, &constantBuffers[CBTYPE_MISC], CB_GETBINDSLOT(MiscCB), cmd); + device->BindDynamicConstantBuffer(sb, CB_GETBINDSLOT(MiscCB), cmd); device->DrawIndexed(24, 0, 0, cmd); } @@ -5531,9 +5025,7 @@ void DrawDebugWorld( XMStoreFloat4x4(&sb.g_xTransform, aabb.getAsBoxMatrix()*camera.GetViewProjection()); sb.g_xColor = XMFLOAT4(1, 1, 0, 1); - device->UpdateBuffer(&constantBuffers[CBTYPE_MISC], &sb, cmd); - device->BindConstantBuffer(VS, &constantBuffers[CBTYPE_MISC], CB_GETBINDSLOT(MiscCB), cmd); - device->BindConstantBuffer(PS, &constantBuffers[CBTYPE_MISC], CB_GETBINDSLOT(MiscCB), cmd); + device->BindDynamicConstantBuffer(sb, CB_GETBINDSLOT(MiscCB), cmd); device->DrawIndexed(24, 0, 0, cmd); } @@ -5545,9 +5037,7 @@ void DrawDebugWorld( XMStoreFloat4x4(&sb.g_xTransform, aabb.getAsBoxMatrix()*camera.GetViewProjection()); sb.g_xColor = XMFLOAT4(1, 0, 1, 1); - device->UpdateBuffer(&constantBuffers[CBTYPE_MISC], &sb, cmd); - device->BindConstantBuffer(VS, &constantBuffers[CBTYPE_MISC], CB_GETBINDSLOT(MiscCB), cmd); - device->BindConstantBuffer(PS, &constantBuffers[CBTYPE_MISC], CB_GETBINDSLOT(MiscCB), cmd); + device->BindDynamicConstantBuffer(sb, CB_GETBINDSLOT(MiscCB), cmd); device->DrawIndexed(24, 0, 0, cmd); } @@ -5559,9 +5049,7 @@ void DrawDebugWorld( XMStoreFloat4x4(&sb.g_xTransform, aabb.getAsBoxMatrix()*camera.GetViewProjection()); sb.g_xColor = XMFLOAT4(0, 1, 1, 1); - device->UpdateBuffer(&constantBuffers[CBTYPE_MISC], &sb, cmd); - device->BindConstantBuffer(VS, &constantBuffers[CBTYPE_MISC], CB_GETBINDSLOT(MiscCB), cmd); - device->BindConstantBuffer(PS, &constantBuffers[CBTYPE_MISC], CB_GETBINDSLOT(MiscCB), cmd); + device->BindDynamicConstantBuffer(sb, CB_GETBINDSLOT(MiscCB), cmd); device->DrawIndexed(24, 0, 0, cmd); } @@ -5578,9 +5066,7 @@ void DrawDebugWorld( MiscCB sb; XMStoreFloat4x4(&sb.g_xTransform, camera.GetViewProjection()); sb.g_xColor = XMFLOAT4(1, 1, 1, 1); - device->UpdateBuffer(&constantBuffers[CBTYPE_MISC], &sb, cmd); - device->BindConstantBuffer(VS, &constantBuffers[CBTYPE_MISC], CB_GETBINDSLOT(MiscCB), cmd); - device->BindConstantBuffer(PS, &constantBuffers[CBTYPE_MISC], CB_GETBINDSLOT(MiscCB), cmd); + device->BindDynamicConstantBuffer(sb, CB_GETBINDSLOT(MiscCB), cmd); for (size_t i = 0; i < scene.armatures.GetCount(); ++i) { @@ -5625,7 +5111,7 @@ void DrawDebugWorld( } const GPUBuffer* vbs[] = { - mem.buffer + &mem.buffer }; const uint32_t strides[] = { sizeof(XMFLOAT4) + sizeof(XMFLOAT4), @@ -5651,9 +5137,7 @@ void DrawDebugWorld( MiscCB sb; XMStoreFloat4x4(&sb.g_xTransform, camera.GetViewProjection()); sb.g_xColor = XMFLOAT4(1, 1, 1, 1); - device->UpdateBuffer(&constantBuffers[CBTYPE_MISC], &sb, cmd); - device->BindConstantBuffer(VS, &constantBuffers[CBTYPE_MISC], CB_GETBINDSLOT(MiscCB), cmd); - device->BindConstantBuffer(PS, &constantBuffers[CBTYPE_MISC], CB_GETBINDSLOT(MiscCB), cmd); + device->BindDynamicConstantBuffer(sb, CB_GETBINDSLOT(MiscCB), cmd); struct Vertex { @@ -5678,7 +5162,7 @@ void DrawDebugWorld( } const GPUBuffer* vbs[] = { - mem.buffer, + &mem.buffer, }; const uint32_t strides[] = { sizeof(Vertex), @@ -5704,9 +5188,7 @@ void DrawDebugWorld( MiscCB sb; XMStoreFloat4x4(&sb.g_xTransform, camera.GetViewProjection()); sb.g_xColor = XMFLOAT4(1, 1, 1, 1); - device->UpdateBuffer(&constantBuffers[CBTYPE_MISC], &sb, cmd); - device->BindConstantBuffer(VS, &constantBuffers[CBTYPE_MISC], CB_GETBINDSLOT(MiscCB), cmd); - device->BindConstantBuffer(PS, &constantBuffers[CBTYPE_MISC], CB_GETBINDSLOT(MiscCB), cmd); + device->BindDynamicConstantBuffer(sb, CB_GETBINDSLOT(MiscCB), cmd); struct Vertex { @@ -5731,7 +5213,7 @@ void DrawDebugWorld( } const GPUBuffer* vbs[] = { - mem.buffer, + &mem.buffer, }; const uint32_t strides[] = { sizeof(Vertex), @@ -5757,9 +5239,7 @@ void DrawDebugWorld( MiscCB sb; XMStoreFloat4x4(&sb.g_xTransform, camera.GetViewProjection()); sb.g_xColor = XMFLOAT4(1, 1, 1, 1); - device->UpdateBuffer(&constantBuffers[CBTYPE_MISC], &sb, cmd); - device->BindConstantBuffer(VS, &constantBuffers[CBTYPE_MISC], CB_GETBINDSLOT(MiscCB), cmd); - device->BindConstantBuffer(PS, &constantBuffers[CBTYPE_MISC], CB_GETBINDSLOT(MiscCB), cmd); + device->BindDynamicConstantBuffer(sb, CB_GETBINDSLOT(MiscCB), cmd); struct LineSegment { @@ -5781,7 +5261,7 @@ void DrawDebugWorld( } const GPUBuffer* vbs[] = { - mem.buffer, + &mem.buffer, }; const uint32_t strides[] = { sizeof(XMFLOAT4) + sizeof(XMFLOAT4), @@ -5807,9 +5287,7 @@ void DrawDebugWorld( MiscCB sb; XMStoreFloat4x4(&sb.g_xTransform, canvas.GetProjection()); sb.g_xColor = XMFLOAT4(1, 1, 1, 1); - device->UpdateBuffer(&constantBuffers[CBTYPE_MISC], &sb, cmd); - device->BindConstantBuffer(VS, &constantBuffers[CBTYPE_MISC], CB_GETBINDSLOT(MiscCB), cmd); - device->BindConstantBuffer(PS, &constantBuffers[CBTYPE_MISC], CB_GETBINDSLOT(MiscCB), cmd); + device->BindDynamicConstantBuffer(sb, CB_GETBINDSLOT(MiscCB), cmd); struct LineSegment { @@ -5831,7 +5309,7 @@ void DrawDebugWorld( } const GPUBuffer* vbs[] = { - mem.buffer, + &mem.buffer, }; const uint32_t strides[] = { sizeof(XMFLOAT4) + sizeof(XMFLOAT4), @@ -5857,9 +5335,7 @@ void DrawDebugWorld( MiscCB sb; XMStoreFloat4x4(&sb.g_xTransform, camera.GetProjection()); // only projection, we will expand in view space on CPU below to be camera facing! sb.g_xColor = XMFLOAT4(1, 1, 1, 1); - device->UpdateBuffer(&constantBuffers[CBTYPE_MISC], &sb, cmd); - device->BindConstantBuffer(VS, &constantBuffers[CBTYPE_MISC], CB_GETBINDSLOT(MiscCB), cmd); - device->BindConstantBuffer(PS, &constantBuffers[CBTYPE_MISC], CB_GETBINDSLOT(MiscCB), cmd); + device->BindDynamicConstantBuffer(sb, CB_GETBINDSLOT(MiscCB), cmd); // Will generate 2 line segments for each point forming a cross section: struct LineSegment @@ -5896,7 +5372,7 @@ void DrawDebugWorld( } const GPUBuffer* vbs[] = { - mem.buffer, + &mem.buffer, }; const uint32_t strides[] = { sizeof(XMFLOAT4) + sizeof(XMFLOAT4), @@ -5935,9 +5411,7 @@ void DrawDebugWorld( XMStoreFloat4x4(&sb.g_xTransform, XMLoadFloat4x4(&x.first)*camera.GetViewProjection()); sb.g_xColor = x.second; - device->UpdateBuffer(&constantBuffers[CBTYPE_MISC], &sb, cmd); - device->BindConstantBuffer(VS, &constantBuffers[CBTYPE_MISC], CB_GETBINDSLOT(MiscCB), cmd); - device->BindConstantBuffer(PS, &constantBuffers[CBTYPE_MISC], CB_GETBINDSLOT(MiscCB), cmd); + device->BindDynamicConstantBuffer(sb, CB_GETBINDSLOT(MiscCB), cmd); device->DrawIndexed(24, 0, 0, cmd); } @@ -5991,7 +5465,6 @@ void DrawDebugWorld( bd.Usage = USAGE_DEFAULT; bd.ByteWidth = uint32_t(vertices.size() * sizeof(Vertex)); bd.BindFlags = BIND_VERTEX_BUFFER; - bd.CPUAccessFlags = 0; SubresourceData InitData; InitData.pSysMem = vertices.data(); device->CreateBuffer(&bd, &InitData, &wiresphereVB); @@ -6016,7 +5489,6 @@ void DrawDebugWorld( bd.Usage = USAGE_DEFAULT; bd.ByteWidth = uint32_t(indices.size() * sizeof(uint16_t)); bd.BindFlags = BIND_INDEX_BUFFER; - bd.CPUAccessFlags = 0; InitData.pSysMem = indices.data(); device->CreateBuffer(&bd, &InitData, &wiresphereIB); } @@ -6044,9 +5516,7 @@ void DrawDebugWorld( ); sb.g_xColor = x.second; - device->UpdateBuffer(&constantBuffers[CBTYPE_MISC], &sb, cmd); - device->BindConstantBuffer(VS, &constantBuffers[CBTYPE_MISC], CB_GETBINDSLOT(MiscCB), cmd); - device->BindConstantBuffer(PS, &constantBuffers[CBTYPE_MISC], CB_GETBINDSLOT(MiscCB), cmd); + device->BindDynamicConstantBuffer(sb, CB_GETBINDSLOT(MiscCB), cmd); device->DrawIndexed(wiresphereIB.GetDesc().ByteWidth / sizeof(uint16_t), 0, 0, cmd); } @@ -6064,9 +5534,7 @@ void DrawDebugWorld( MiscCB sb; XMStoreFloat4x4(&sb.g_xTransform, camera.GetViewProjection()); sb.g_xColor = XMFLOAT4(1, 1, 1, 1); - device->UpdateBuffer(&constantBuffers[CBTYPE_MISC], &sb, cmd); - device->BindConstantBuffer(VS, &constantBuffers[CBTYPE_MISC], CB_GETBINDSLOT(MiscCB), cmd); - device->BindConstantBuffer(PS, &constantBuffers[CBTYPE_MISC], CB_GETBINDSLOT(MiscCB), cmd); + device->BindDynamicConstantBuffer(sb, CB_GETBINDSLOT(MiscCB), cmd); const int segmentcount = 18 + 1 + 18 + 1; const int linecount = (int)renderableCapsules.size() * segmentcount; @@ -6136,7 +5604,7 @@ void DrawDebugWorld( } const GPUBuffer* vbs[] = { - mem.buffer, + &mem.buffer, }; const uint32_t strides[] = { sizeof(XMFLOAT4) + sizeof(XMFLOAT4), @@ -6167,17 +5635,15 @@ void DrawDebugWorld( const EnvironmentProbeComponent& probe = scene.probes[i]; XMStoreFloat4x4(&sb.g_xTransform, XMMatrixTranslationFromVector(XMLoadFloat3(&probe.position))); - device->UpdateBuffer(&constantBuffers[CBTYPE_MISC], &sb, cmd); - device->BindConstantBuffer(VS, &constantBuffers[CBTYPE_MISC], CB_GETBINDSLOT(MiscCB), cmd); - device->BindConstantBuffer(PS, &constantBuffers[CBTYPE_MISC], CB_GETBINDSLOT(MiscCB), cmd); + device->BindDynamicConstantBuffer(sb, CB_GETBINDSLOT(MiscCB), cmd); if (probe.textureIndex < 0) { - device->BindResource(PS, wiTextureHelper::getBlackCubeMap(), TEXSLOT_ONDEMAND0, cmd); + device->BindResource(wiTextureHelper::getBlackCubeMap(), TEXSLOT_ONDEMAND0, cmd); } else { - device->BindResource(PS, &scene.envmapArray, TEXSLOT_ONDEMAND0, cmd, scene.envmapArray.GetDesc().MipLevels + probe.textureIndex); + device->BindResource(&scene.envmapArray, TEXSLOT_ONDEMAND0, cmd, scene.envmapArray.GetDesc().MipLevels + probe.textureIndex); } device->Draw(2880, 0, cmd); // uv-sphere @@ -6212,9 +5678,7 @@ void DrawDebugWorld( XMStoreFloat4x4(&sb.g_xTransform, XMLoadFloat4x4(&transform.world)*camera.GetViewProjection()); sb.g_xColor = float4(0, 1, 1, 1); - device->UpdateBuffer(&constantBuffers[CBTYPE_MISC], &sb, cmd); - device->BindConstantBuffer(VS, &constantBuffers[CBTYPE_MISC], CB_GETBINDSLOT(MiscCB), cmd); - device->BindConstantBuffer(PS, &constantBuffers[CBTYPE_MISC], CB_GETBINDSLOT(MiscCB), cmd); + device->BindDynamicConstantBuffer(sb, CB_GETBINDSLOT(MiscCB), cmd); device->DrawIndexed(24, 0, 0, cmd); } @@ -6259,10 +5723,8 @@ void DrawDebugWorld( gridVertexCount = arraysize(verts) / 2; GPUBufferDesc bd; - bd.Usage = USAGE_IMMUTABLE; bd.ByteWidth = sizeof(verts); bd.BindFlags = BIND_VERTEX_BUFFER; - bd.CPUAccessFlags = 0; SubresourceData InitData; InitData.pSysMem = verts; device->CreateBuffer(&bd, &InitData, &grid); @@ -6272,9 +5734,7 @@ void DrawDebugWorld( XMStoreFloat4x4(&sb.g_xTransform, camera.GetViewProjection()); sb.g_xColor = float4(1, 1, 1, 1); - device->UpdateBuffer(&constantBuffers[CBTYPE_MISC], &sb, cmd); - device->BindConstantBuffer(VS, &constantBuffers[CBTYPE_MISC], CB_GETBINDSLOT(MiscCB), cmd); - device->BindConstantBuffer(PS, &constantBuffers[CBTYPE_MISC], CB_GETBINDSLOT(MiscCB), cmd); + device->BindDynamicConstantBuffer(sb, CB_GETBINDSLOT(MiscCB), cmd); const GPUBuffer* vbs[] = { &grid, @@ -6294,17 +5754,14 @@ void DrawDebugWorld( device->BindPipelineState(&PSO_debug[DEBUGRENDERING_VOXEL], cmd); - device->BindResource(VS, GetVoxelRadianceSecondaryBounceEnabled() ? &textures[TEXTYPE_3D_VOXELRADIANCE_HELPER] : &textures[TEXTYPE_3D_VOXELRADIANCE], TEXSLOT_VOXELRADIANCE, cmd); + device->BindResource(GetVoxelRadianceSecondaryBounceEnabled() ? &textures[TEXTYPE_3D_VOXELRADIANCE_HELPER] : &textures[TEXTYPE_3D_VOXELRADIANCE], TEXSLOT_VOXELGI, cmd); MiscCB sb; XMStoreFloat4x4(&sb.g_xTransform, XMMatrixTranslationFromVector(XMLoadFloat3(&voxelSceneData.center)) * camera.GetViewProjection()); sb.g_xColor = float4(1, 1, 1, 1); - device->UpdateBuffer(&constantBuffers[CBTYPE_MISC], &sb, cmd); - device->BindConstantBuffer(VS, &constantBuffers[CBTYPE_MISC], CB_GETBINDSLOT(MiscCB), cmd); - device->BindConstantBuffer(GS, &constantBuffers[CBTYPE_MISC], CB_GETBINDSLOT(MiscCB), cmd); - device->BindConstantBuffer(PS, &constantBuffers[CBTYPE_MISC], CB_GETBINDSLOT(MiscCB), cmd); + device->BindDynamicConstantBuffer(sb, CB_GETBINDSLOT(MiscCB), cmd); device->Draw(voxelSceneData.res * voxelSceneData.res * voxelSceneData.res, 0, cmd); @@ -6325,9 +5782,8 @@ void DrawDebugWorld( XMStoreFloat4x4(&sb.g_xTransform, XMLoadFloat4x4(&transform.world)*camera.GetViewProjection()); sb.g_xColor = float4(0, 1, 0, 1); - device->UpdateBuffer(&constantBuffers[CBTYPE_MISC], &sb, cmd); - device->BindConstantBuffer(VS, &constantBuffers[CBTYPE_MISC], CB_GETBINDSLOT(MiscCB), cmd); - device->BindConstantBuffer(PS, &constantBuffers[CBTYPE_MISC], CB_GETBINDSLOT(MiscCB), cmd); + + device->BindDynamicConstantBuffer(sb, CB_GETBINDSLOT(MiscCB), cmd); if (mesh == nullptr) { @@ -6377,56 +5833,10 @@ void DrawDebugWorld( const MeshComponent::MeshSubset& subset = mesh.subsets[x.subset]; const MaterialComponent& material = *scene.materials.GetComponent(subset.materialID); - GraphicsDevice::GPUAllocation mem = device->AllocateGPU(sizeof(Instance), cmd); - volatile Instance* buff = (volatile Instance*)mem.data; - buff->Create(transform.world); - - if (device->CheckCapability(GRAPHICSDEVICE_CAPABILITY_BINDLESS_DESCRIPTORS)) - { - ObjectPushConstants push; - push.material = device->GetDescriptorIndex(&material.constantBuffer, SRV); - push.mesh = device->GetDescriptorIndex(&mesh.descriptor, SRV); - push.instances = device->GetDescriptorIndex(mem.buffer, SRV); - push.instance_offset = mem.offset; - device->PushConstants(&push, sizeof(push), cmd); - } - else - { - const GPUBuffer* vbs[] = { - mesh.streamoutBuffer_POS.IsValid() ? &mesh.streamoutBuffer_POS : &mesh.vertexBuffer_POS, - nullptr, - &mesh.vertexBuffer_UV0, - &mesh.vertexBuffer_UV1, - nullptr, - nullptr, - nullptr, - mem.buffer - }; - uint32_t strides[] = { - sizeof(MeshComponent::Vertex_POS), - sizeof(MeshComponent::Vertex_POS), - sizeof(MeshComponent::Vertex_TEX), - sizeof(MeshComponent::Vertex_TEX), - sizeof(MeshComponent::Vertex_TEX), - sizeof(MeshComponent::Vertex_COL), - sizeof(MeshComponent::Vertex_TAN), - sizeof(Instance) - }; - uint32_t offsets[] = { - 0, - 0, - 0, - 0, - 0, - 0, - 0, - mem.offset - }; - device->BindVertexBuffers(vbs, 0, arraysize(vbs), strides, offsets, cmd); - - device->BindConstantBuffer(VS, &material.constantBuffer, CB_GETBINDSLOT(MaterialCB), cmd); - device->BindConstantBuffer(PS, &material.constantBuffer, CB_GETBINDSLOT(MaterialCB), cmd); - } + GraphicsDevice::GPUAllocation mem = device->AllocateGPU(sizeof(ShaderMeshInstancePointer), cmd); + volatile ShaderMeshInstancePointer* buff = (volatile ShaderMeshInstancePointer*)mem.data; + buff->instanceID = (uint)scene.objects.GetIndex(x.objectEntity); + buff->userdata = 0; device->BindIndexBuffer(&mesh.indexBuffer, mesh.GetIndexFormat(), 0, cmd); @@ -6435,8 +5845,17 @@ void DrawDebugWorld( cb.xPaintRadCenter = x.center; cb.xPaintRadRadius = x.radius; cb.xPaintRadUVSET = x.uvset; - device->UpdateBuffer(&constantBuffers[CBTYPE_PAINTRADIUS], &cb, cmd); - device->BindConstantBuffer(PS, &constantBuffers[CBTYPE_PAINTRADIUS], CB_GETBINDSLOT(PaintRadiusCB), cmd); + device->BindDynamicConstantBuffer(cb, CB_GETBINDSLOT(PaintRadiusCB), cmd); + + ObjectPushConstants push; + push.init( + (uint)scene.meshes.GetIndex(object.meshID), + x.subset, + subset.materialIndex, + device->GetDescriptorIndex(&mem.buffer, SRV), + mem.offset + ); + device->PushConstants(&push, sizeof(push), cmd); device->DrawIndexedInstanced(subset.indexCount, 1, subset.indexOffset, 0, 0, cmd); } @@ -6458,9 +5877,8 @@ void DrawDebugWorld( XMStoreFloat4x4(&sb.g_xTransform, camera.GetViewProjection()); sb.g_xColor = XMFLOAT4(camera.Eye.x, camera.Eye.y, camera.Eye.z, (float)i); - device->UpdateBuffer(&constantBuffers[CBTYPE_MISC], &sb, cmd); - device->BindConstantBuffer(VS, &constantBuffers[CBTYPE_MISC], CB_GETBINDSLOT(MiscCB), cmd); - device->BindConstantBuffer(PS, &constantBuffers[CBTYPE_MISC], CB_GETBINDSLOT(MiscCB), cmd); + + device->BindDynamicConstantBuffer(sb, CB_GETBINDSLOT(MiscCB), cmd); switch (force.type) { @@ -6506,7 +5924,6 @@ void DrawDebugWorld( bd.Usage = USAGE_DEFAULT; bd.ByteWidth = sizeof(verts); bd.BindFlags = BIND_VERTEX_BUFFER; - bd.CPUAccessFlags = 0; SubresourceData InitData; InitData.pSysMem = verts; device->CreateBuffer(&bd, &InitData, &wirecamVB); @@ -6521,7 +5938,6 @@ void DrawDebugWorld( bd.Usage = USAGE_DEFAULT; bd.ByteWidth = sizeof(indices); bd.BindFlags = BIND_INDEX_BUFFER; - bd.CPUAccessFlags = 0; InitData.pSysMem = indices; device->CreateBuffer(&bd, &InitData, &wirecamIB); } @@ -6548,9 +5964,7 @@ void DrawDebugWorld( const float aspect = cam.width / cam.height; XMStoreFloat4x4(&sb.g_xTransform, XMMatrixScaling(aspect * 0.5f, 0.5f, 0.5f) * cam.GetInvView()*camera.GetViewProjection()); - device->UpdateBuffer(&constantBuffers[CBTYPE_MISC], &sb, cmd); - device->BindConstantBuffer(VS, &constantBuffers[CBTYPE_MISC], CB_GETBINDSLOT(MiscCB), cmd); - device->BindConstantBuffer(PS, &constantBuffers[CBTYPE_MISC], CB_GETBINDSLOT(MiscCB), cmd); + device->BindDynamicConstantBuffer(sb, CB_GETBINDSLOT(MiscCB), cmd); device->DrawIndexed(32, 0, 0, cmd); } @@ -6577,17 +5991,17 @@ void RenderAtmosphericScatteringTextures(CommandList cmd) device->EventBegin("TransmittanceLut", cmd); device->BindComputeShader(&shaders[CSTYPE_SKYATMOSPHERE_TRANSMITTANCELUT], cmd); - device->BindResource(CS, &textures[TEXTYPE_2D_SKYATMOSPHERE_TRANSMITTANCELUT], TEXSLOT_ONDEMAND0, cmd); // empty - device->BindResource(CS, &textures[TEXTYPE_2D_SKYATMOSPHERE_MULTISCATTEREDLUMINANCELUT], TEXSLOT_ONDEMAND1, cmd); // empty + device->BindResource(&textures[TEXTYPE_2D_SKYATMOSPHERE_TRANSMITTANCELUT], TEXSLOT_ONDEMAND0, cmd); // empty + device->BindResource(&textures[TEXTYPE_2D_SKYATMOSPHERE_MULTISCATTEREDLUMINANCELUT], TEXSLOT_ONDEMAND1, cmd); // empty const GPUResource* uavs[] = { &textures[TEXTYPE_2D_SKYATMOSPHERE_TRANSMITTANCELUT], }; - device->BindUAVs(CS, uavs, 0, arraysize(uavs), cmd); + device->BindUAVs(uavs, 0, arraysize(uavs), cmd); { GPUBarrier barriers[] = { - GPUBarrier::Image(&textures[TEXTYPE_2D_SKYATMOSPHERE_TRANSMITTANCELUT], textures[TEXTYPE_2D_SKYATMOSPHERE_TRANSMITTANCELUT].desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS) + GPUBarrier::Image(&textures[TEXTYPE_2D_SKYATMOSPHERE_TRANSMITTANCELUT], textures[TEXTYPE_2D_SKYATMOSPHERE_TRANSMITTANCELUT].desc.layout, RESOURCE_STATE_UNORDERED_ACCESS) }; device->Barrier(barriers, arraysize(barriers), cmd); } @@ -6603,12 +6017,11 @@ void RenderAtmosphericScatteringTextures(CommandList cmd) { GPUBarrier barriers[] = { GPUBarrier::Memory(), - GPUBarrier::Image(&textures[TEXTYPE_2D_SKYATMOSPHERE_TRANSMITTANCELUT], IMAGE_LAYOUT_UNORDERED_ACCESS, textures[TEXTYPE_2D_SKYATMOSPHERE_TRANSMITTANCELUT].desc.layout) + GPUBarrier::Image(&textures[TEXTYPE_2D_SKYATMOSPHERE_TRANSMITTANCELUT], RESOURCE_STATE_UNORDERED_ACCESS, textures[TEXTYPE_2D_SKYATMOSPHERE_TRANSMITTANCELUT].desc.layout) }; device->Barrier(barriers, arraysize(barriers), cmd); } - device->UnbindUAVs(0, arraysize(uavs), cmd); device->EventEnd(cmd); } @@ -6618,17 +6031,17 @@ void RenderAtmosphericScatteringTextures(CommandList cmd) device->BindComputeShader(&shaders[CSTYPE_SKYATMOSPHERE_MULTISCATTEREDLUMINANCELUT], cmd); // Use transmittance from previous pass - device->BindResource(CS, &textures[TEXTYPE_2D_SKYATMOSPHERE_TRANSMITTANCELUT], TEXSLOT_ONDEMAND0, cmd); - device->BindResource(CS, &textures[TEXTYPE_2D_SKYATMOSPHERE_MULTISCATTEREDLUMINANCELUT], TEXSLOT_ONDEMAND1, cmd); + device->BindResource(&textures[TEXTYPE_2D_SKYATMOSPHERE_TRANSMITTANCELUT], TEXSLOT_ONDEMAND0, cmd); + device->BindResource(&textures[TEXTYPE_2D_SKYATMOSPHERE_MULTISCATTEREDLUMINANCELUT], TEXSLOT_ONDEMAND1, cmd); const GPUResource* uavs[] = { &textures[TEXTYPE_2D_SKYATMOSPHERE_MULTISCATTEREDLUMINANCELUT], }; - device->BindUAVs(CS, uavs, 0, arraysize(uavs), cmd); + device->BindUAVs(uavs, 0, arraysize(uavs), cmd); { GPUBarrier barriers[] = { - GPUBarrier::Image(&textures[TEXTYPE_2D_SKYATMOSPHERE_MULTISCATTEREDLUMINANCELUT], textures[TEXTYPE_2D_SKYATMOSPHERE_MULTISCATTEREDLUMINANCELUT].desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS) + GPUBarrier::Image(&textures[TEXTYPE_2D_SKYATMOSPHERE_MULTISCATTEREDLUMINANCELUT], textures[TEXTYPE_2D_SKYATMOSPHERE_MULTISCATTEREDLUMINANCELUT].desc.layout, RESOURCE_STATE_UNORDERED_ACCESS) }; device->Barrier(barriers, arraysize(barriers), cmd); } @@ -6641,12 +6054,11 @@ void RenderAtmosphericScatteringTextures(CommandList cmd) { GPUBarrier barriers[] = { GPUBarrier::Memory(), - GPUBarrier::Image(&textures[TEXTYPE_2D_SKYATMOSPHERE_MULTISCATTEREDLUMINANCELUT], IMAGE_LAYOUT_UNORDERED_ACCESS, textures[TEXTYPE_2D_SKYATMOSPHERE_MULTISCATTEREDLUMINANCELUT].desc.layout) + GPUBarrier::Image(&textures[TEXTYPE_2D_SKYATMOSPHERE_MULTISCATTEREDLUMINANCELUT], RESOURCE_STATE_UNORDERED_ACCESS, textures[TEXTYPE_2D_SKYATMOSPHERE_MULTISCATTEREDLUMINANCELUT].desc.layout) }; device->Barrier(barriers, arraysize(barriers), cmd); } - device->UnbindUAVs(0, arraysize(uavs), cmd); device->EventEnd(cmd); } @@ -6655,17 +6067,17 @@ void RenderAtmosphericScatteringTextures(CommandList cmd) device->EventBegin("EnvironmentLuminanceLut", cmd); device->BindComputeShader(&shaders[CSTYPE_SKYATMOSPHERE_SKYLUMINANCELUT], cmd); - device->BindResource(CS, &textures[TEXTYPE_2D_SKYATMOSPHERE_TRANSMITTANCELUT], TEXSLOT_ONDEMAND0, cmd); - device->BindResource(CS, &textures[TEXTYPE_2D_SKYATMOSPHERE_MULTISCATTEREDLUMINANCELUT], TEXSLOT_ONDEMAND1, cmd); + device->BindResource(&textures[TEXTYPE_2D_SKYATMOSPHERE_TRANSMITTANCELUT], TEXSLOT_ONDEMAND0, cmd); + device->BindResource(&textures[TEXTYPE_2D_SKYATMOSPHERE_MULTISCATTEREDLUMINANCELUT], TEXSLOT_ONDEMAND1, cmd); const GPUResource* uavs[] = { &textures[TEXTYPE_2D_SKYATMOSPHERE_SKYLUMINANCELUT], }; - device->BindUAVs(CS, uavs, 0, arraysize(uavs), cmd); + device->BindUAVs(uavs, 0, arraysize(uavs), cmd); { GPUBarrier barriers[] = { - GPUBarrier::Image(&textures[TEXTYPE_2D_SKYATMOSPHERE_SKYLUMINANCELUT], textures[TEXTYPE_2D_SKYATMOSPHERE_SKYLUMINANCELUT].desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS) + GPUBarrier::Image(&textures[TEXTYPE_2D_SKYATMOSPHERE_SKYLUMINANCELUT], textures[TEXTYPE_2D_SKYATMOSPHERE_SKYLUMINANCELUT].desc.layout, RESOURCE_STATE_UNORDERED_ACCESS) }; device->Barrier(barriers, arraysize(barriers), cmd); } @@ -6678,12 +6090,11 @@ void RenderAtmosphericScatteringTextures(CommandList cmd) { GPUBarrier barriers[] = { GPUBarrier::Memory(), - GPUBarrier::Image(&textures[TEXTYPE_2D_SKYATMOSPHERE_SKYLUMINANCELUT], IMAGE_LAYOUT_UNORDERED_ACCESS, textures[TEXTYPE_2D_SKYATMOSPHERE_SKYLUMINANCELUT].desc.layout) + GPUBarrier::Image(&textures[TEXTYPE_2D_SKYATMOSPHERE_SKYLUMINANCELUT], RESOURCE_STATE_UNORDERED_ACCESS, textures[TEXTYPE_2D_SKYATMOSPHERE_SKYLUMINANCELUT].desc.layout) }; device->Barrier(barriers, arraysize(barriers), cmd); } - device->UnbindUAVs(0, arraysize(uavs), cmd); device->EventEnd(cmd); } @@ -6702,17 +6113,17 @@ void RefreshAtmosphericScatteringTextures(CommandList cmd) device->EventBegin("SkyViewLut", cmd); device->BindComputeShader(&shaders[CSTYPE_SKYATMOSPHERE_SKYVIEWLUT], cmd); - device->BindResource(CS, &textures[TEXTYPE_2D_SKYATMOSPHERE_TRANSMITTANCELUT], TEXSLOT_ONDEMAND0, cmd); - device->BindResource(CS, &textures[TEXTYPE_2D_SKYATMOSPHERE_MULTISCATTEREDLUMINANCELUT], TEXSLOT_ONDEMAND1, cmd); + device->BindResource(&textures[TEXTYPE_2D_SKYATMOSPHERE_TRANSMITTANCELUT], TEXSLOT_ONDEMAND0, cmd); + device->BindResource(&textures[TEXTYPE_2D_SKYATMOSPHERE_MULTISCATTEREDLUMINANCELUT], TEXSLOT_ONDEMAND1, cmd); const GPUResource* uavs[] = { &textures[TEXTYPE_2D_SKYATMOSPHERE_SKYVIEWLUT], }; - device->BindUAVs(CS, uavs, 0, arraysize(uavs), cmd); + device->BindUAVs(uavs, 0, arraysize(uavs), cmd); { GPUBarrier barriers[] = { - GPUBarrier::Image(&textures[TEXTYPE_2D_SKYATMOSPHERE_SKYVIEWLUT], textures[TEXTYPE_2D_SKYATMOSPHERE_SKYVIEWLUT].desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS) + GPUBarrier::Image(&textures[TEXTYPE_2D_SKYATMOSPHERE_SKYVIEWLUT], textures[TEXTYPE_2D_SKYATMOSPHERE_SKYVIEWLUT].desc.layout, RESOURCE_STATE_UNORDERED_ACCESS) }; device->Barrier(barriers, arraysize(barriers), cmd); } @@ -6728,12 +6139,11 @@ void RefreshAtmosphericScatteringTextures(CommandList cmd) { GPUBarrier barriers[] = { GPUBarrier::Memory(), - GPUBarrier::Image(&textures[TEXTYPE_2D_SKYATMOSPHERE_SKYVIEWLUT], IMAGE_LAYOUT_UNORDERED_ACCESS, textures[TEXTYPE_2D_SKYATMOSPHERE_SKYVIEWLUT].desc.layout) + GPUBarrier::Image(&textures[TEXTYPE_2D_SKYATMOSPHERE_SKYVIEWLUT], RESOURCE_STATE_UNORDERED_ACCESS, textures[TEXTYPE_2D_SKYATMOSPHERE_SKYVIEWLUT].desc.layout) }; device->Barrier(barriers, arraysize(barriers), cmd); } - device->UnbindUAVs(0, arraysize(uavs), cmd); device->EventEnd(cmd); } @@ -6746,31 +6156,13 @@ void DrawSky(const Scene& scene, CommandList cmd) if (scene.weather.skyMap != nullptr) { device->BindPipelineState(&PSO_sky[SKYRENDERING_STATIC], cmd); - device->BindResource(PS, &scene.weather.skyMap->texture, TEXSLOT_GLOBALENVMAP, cmd); } else { device->BindPipelineState(&PSO_sky[SKYRENDERING_DYNAMIC], cmd); - device->BindResource(PS, &textures[TEXTYPE_2D_SKYATMOSPHERE_SKYVIEWLUT], TEXSLOT_SKYVIEWLUT, cmd); - device->BindResource(PS, &textures[TEXTYPE_2D_SKYATMOSPHERE_TRANSMITTANCELUT], TEXSLOT_TRANSMITTANCELUT, cmd); - device->BindResource(PS, &textures[TEXTYPE_2D_SKYATMOSPHERE_MULTISCATTEREDLUMINANCELUT], TEXSLOT_MULTISCATTERINGLUT, cmd); } - BindConstantBuffers(VS, cmd); - BindConstantBuffers(PS, cmd); - - device->Draw(3, 0, cmd); - - device->EventEnd(cmd); -} -void DrawSkyVelocity(CommandList cmd) -{ - device->EventBegin("DrawSkyVelocity", cmd); - - device->BindPipelineState(&PSO_sky[SKYRENDERING_VELOCITY], cmd); - - BindConstantBuffers(VS, cmd); - BindConstantBuffers(PS, cmd); + BindCommonResources(cmd); device->Draw(3, 0, cmd); @@ -6782,12 +6174,7 @@ void DrawSun(CommandList cmd) device->BindPipelineState(&PSO_sky[SKYRENDERING_SUN], cmd); - device->BindResource(PS, &textures[TEXTYPE_2D_SKYATMOSPHERE_SKYVIEWLUT], TEXSLOT_SKYVIEWLUT, cmd); - device->BindResource(PS, &textures[TEXTYPE_2D_SKYATMOSPHERE_TRANSMITTANCELUT], TEXSLOT_TRANSMITTANCELUT, cmd); - device->BindResource(PS, &textures[TEXTYPE_2D_SKYATMOSPHERE_MULTISCATTEREDLUMINANCELUT], TEXSLOT_MULTISCATTERINGLUT, cmd); - - BindConstantBuffers(VS, cmd); - BindConstantBuffers(PS, cmd); + BindCommonResources(cmd); device->Draw(3, 0, cmd); @@ -6814,6 +6201,7 @@ void RefreshEnvProbes(const Visibility& vis, CommandList cmd) auto render_probe = [&](const EnvironmentProbeComponent& probe, const AABB& probe_aabb) { + const SHCAM cameras[] = { SHCAM(probe.position, XMFLOAT4(0.5f, -0.5f, -0.5f, -0.5f), zNearP, zFarP, XM_PIDIV2), //+x SHCAM(probe.position, XMFLOAT4(0.5f, 0.5f, 0.5f, -0.5f), zNearP, zFarP, XM_PIDIV2), //-x @@ -6831,27 +6219,19 @@ void RefreshEnvProbes(const Visibility& vis, CommandList cmd) XMStoreFloat4x4(&cb.xCubemapRenderCams[i].VP, cameras[i].VP); cb.xCubemapRenderCams[i].properties = uint4(i, 0, 0, 0); } - - device->UpdateBuffer(&constantBuffers[CBTYPE_CUBEMAPRENDER], &cb, cmd); - device->BindConstantBuffer(VS, &constantBuffers[CBTYPE_CUBEMAPRENDER], CB_GETBINDSLOT(CubemapRenderCB), cmd); + device->BindDynamicConstantBuffer(cb, CB_GETBINDSLOT(CubemapRenderCB), cmd); CameraCB camcb; - camcb.g_xCamera_CamPos = probe.position; // only this will be used by envprobe rendering shaders the rest is read from cubemaprenderCB - device->UpdateBuffer(&constantBuffers[CBTYPE_CAMERA], &camcb, cmd); + camcb.CamPos = probe.position; // only this will be used by envprobe rendering shaders the rest is read from cubemaprenderCB + device->BindDynamicConstantBuffer(camcb, CBSLOT_RENDERER_CAMERA, cmd); if (vis.scene->weather.IsRealisticSky()) { // Refresh atmospheric textures, since each probe has different positions RefreshAtmosphericScatteringTextures(cmd); + device->BindResource(&textures[TEXTYPE_2D_SKYATMOSPHERE_SKYLUMINANCELUT], TEXSLOT_SKYLUMINANCELUT, cmd); } - // Bind the atmospheric textures, as lighting and sky needs them - device->BindResource(PS, &textures[TEXTYPE_2D_SKYATMOSPHERE_SKYVIEWLUT], TEXSLOT_SKYVIEWLUT, cmd); - device->BindResource(PS, &textures[TEXTYPE_2D_SKYATMOSPHERE_TRANSMITTANCELUT], TEXSLOT_TRANSMITTANCELUT, cmd); - device->BindResource(PS, &textures[TEXTYPE_2D_SKYATMOSPHERE_MULTISCATTEREDLUMINANCELUT], TEXSLOT_MULTISCATTERINGLUT, cmd); - device->BindResource(PS, &textures[TEXTYPE_2D_SKYATMOSPHERE_SKYLUMINANCELUT], TEXSLOT_SKYLUMINANCELUT, cmd); - - device->RenderPassBegin(&vis.scene->renderpasses_envmap[probe.textureIndex], cmd); // Scene will only be rendered if this is a real probe entity: @@ -6878,9 +6258,6 @@ void RefreshEnvProbes(const Visibility& vis, CommandList cmd) if (!renderQueue.empty()) { - BindShadowmaps(PS, cmd); - device->BindResource(PS, &vis.scene->lightmap, TEXSLOT_GLOBALLIGHTMAP, cmd); - RenderMeshes(vis, renderQueue, RENDERPASS_ENVMAPCAPTURE, RENDERTYPE_ALL, cmd, false, frusta, arraysize(frusta)); GetRenderFrameAllocator(cmd).free(sizeof(RenderBatch) * renderQueue.batchCount); @@ -6892,7 +6269,7 @@ void RefreshEnvProbes(const Visibility& vis, CommandList cmd) if (vis.scene->weather.skyMap != nullptr) { device->BindPipelineState(&PSO_sky[SKYRENDERING_ENVMAPCAPTURE_STATIC], cmd); - device->BindResource(PS, &vis.scene->weather.skyMap->texture, TEXSLOT_ONDEMAND0, cmd); + device->BindResource(&vis.scene->weather.skyMap->texture, TEXSLOT_ONDEMAND0, cmd); } else { @@ -6924,18 +6301,18 @@ void RefreshEnvProbes(const Visibility& vis, CommandList cmd) { { GPUBarrier barriers[] = { - GPUBarrier::Image(&vis.scene->envmapArray, IMAGE_LAYOUT_SHADER_RESOURCE, IMAGE_LAYOUT_UNORDERED_ACCESS, i, arrayIndex * 6 + 0), - GPUBarrier::Image(&vis.scene->envmapArray, IMAGE_LAYOUT_SHADER_RESOURCE, IMAGE_LAYOUT_UNORDERED_ACCESS, i, arrayIndex * 6 + 1), - GPUBarrier::Image(&vis.scene->envmapArray, IMAGE_LAYOUT_SHADER_RESOURCE, IMAGE_LAYOUT_UNORDERED_ACCESS, i, arrayIndex * 6 + 2), - GPUBarrier::Image(&vis.scene->envmapArray, IMAGE_LAYOUT_SHADER_RESOURCE, IMAGE_LAYOUT_UNORDERED_ACCESS, i, arrayIndex * 6 + 3), - GPUBarrier::Image(&vis.scene->envmapArray, IMAGE_LAYOUT_SHADER_RESOURCE, IMAGE_LAYOUT_UNORDERED_ACCESS, i, arrayIndex * 6 + 4), - GPUBarrier::Image(&vis.scene->envmapArray, IMAGE_LAYOUT_SHADER_RESOURCE, IMAGE_LAYOUT_UNORDERED_ACCESS, i, arrayIndex * 6 + 5), + GPUBarrier::Image(&vis.scene->envmapArray, RESOURCE_STATE_SHADER_RESOURCE, RESOURCE_STATE_UNORDERED_ACCESS, i, arrayIndex * 6 + 0), + GPUBarrier::Image(&vis.scene->envmapArray, RESOURCE_STATE_SHADER_RESOURCE, RESOURCE_STATE_UNORDERED_ACCESS, i, arrayIndex * 6 + 1), + GPUBarrier::Image(&vis.scene->envmapArray, RESOURCE_STATE_SHADER_RESOURCE, RESOURCE_STATE_UNORDERED_ACCESS, i, arrayIndex * 6 + 2), + GPUBarrier::Image(&vis.scene->envmapArray, RESOURCE_STATE_SHADER_RESOURCE, RESOURCE_STATE_UNORDERED_ACCESS, i, arrayIndex * 6 + 3), + GPUBarrier::Image(&vis.scene->envmapArray, RESOURCE_STATE_SHADER_RESOURCE, RESOURCE_STATE_UNORDERED_ACCESS, i, arrayIndex * 6 + 4), + GPUBarrier::Image(&vis.scene->envmapArray, RESOURCE_STATE_SHADER_RESOURCE, RESOURCE_STATE_UNORDERED_ACCESS, i, arrayIndex * 6 + 5), }; device->Barrier(barriers, arraysize(barriers), cmd); } - device->BindUAV(CS, &vis.scene->envmapArray, 0, cmd, i); - device->BindResource(CS, &vis.scene->envmapArray, TEXSLOT_ONDEMAND0, cmd, std::max(0, (int)i - 2)); + device->BindUAV(&vis.scene->envmapArray, 0, cmd, i); + device->BindResource(&vis.scene->envmapArray, TEXSLOT_ONDEMAND0, cmd, std::max(0, (int)i - 2)); FilterEnvmapCB cb; cb.filterResolution.x = desc.Width; @@ -6945,8 +6322,7 @@ void RefreshEnvProbes(const Visibility& vis, CommandList cmd) cb.filterArrayIndex = arrayIndex; cb.filterRoughness = (float)i / (float)desc.MipLevels; cb.filterRayCount = 128; - device->UpdateBuffer(&constantBuffers[CBTYPE_FILTERENVMAP], &cb, cmd); - device->BindConstantBuffer(CS, &constantBuffers[CBTYPE_FILTERENVMAP], CB_GETBINDSLOT(FilterEnvmapCB), cmd); + device->PushConstants(&cb, sizeof(cb), cmd); device->Dispatch( std::max(1u, (uint32_t)ceilf((float)desc.Width / GENERATEMIPCHAIN_2D_BLOCK_SIZE)), @@ -6957,12 +6333,12 @@ void RefreshEnvProbes(const Visibility& vis, CommandList cmd) { GPUBarrier barriers[] = { GPUBarrier::Memory(), - GPUBarrier::Image(&vis.scene->envmapArray, IMAGE_LAYOUT_UNORDERED_ACCESS, IMAGE_LAYOUT_SHADER_RESOURCE, i, arrayIndex * 6 + 0), - GPUBarrier::Image(&vis.scene->envmapArray, IMAGE_LAYOUT_UNORDERED_ACCESS, IMAGE_LAYOUT_SHADER_RESOURCE, i, arrayIndex * 6 + 1), - GPUBarrier::Image(&vis.scene->envmapArray, IMAGE_LAYOUT_UNORDERED_ACCESS, IMAGE_LAYOUT_SHADER_RESOURCE, i, arrayIndex * 6 + 2), - GPUBarrier::Image(&vis.scene->envmapArray, IMAGE_LAYOUT_UNORDERED_ACCESS, IMAGE_LAYOUT_SHADER_RESOURCE, i, arrayIndex * 6 + 3), - GPUBarrier::Image(&vis.scene->envmapArray, IMAGE_LAYOUT_UNORDERED_ACCESS, IMAGE_LAYOUT_SHADER_RESOURCE, i, arrayIndex * 6 + 4), - GPUBarrier::Image(&vis.scene->envmapArray, IMAGE_LAYOUT_UNORDERED_ACCESS, IMAGE_LAYOUT_SHADER_RESOURCE, i, arrayIndex * 6 + 5), + GPUBarrier::Image(&vis.scene->envmapArray, RESOURCE_STATE_UNORDERED_ACCESS, RESOURCE_STATE_SHADER_RESOURCE, i, arrayIndex * 6 + 0), + GPUBarrier::Image(&vis.scene->envmapArray, RESOURCE_STATE_UNORDERED_ACCESS, RESOURCE_STATE_SHADER_RESOURCE, i, arrayIndex * 6 + 1), + GPUBarrier::Image(&vis.scene->envmapArray, RESOURCE_STATE_UNORDERED_ACCESS, RESOURCE_STATE_SHADER_RESOURCE, i, arrayIndex * 6 + 2), + GPUBarrier::Image(&vis.scene->envmapArray, RESOURCE_STATE_UNORDERED_ACCESS, RESOURCE_STATE_SHADER_RESOURCE, i, arrayIndex * 6 + 3), + GPUBarrier::Image(&vis.scene->envmapArray, RESOURCE_STATE_UNORDERED_ACCESS, RESOURCE_STATE_SHADER_RESOURCE, i, arrayIndex * 6 + 4), + GPUBarrier::Image(&vis.scene->envmapArray, RESOURCE_STATE_UNORDERED_ACCESS, RESOURCE_STATE_SHADER_RESOURCE, i, arrayIndex * 6 + 5), }; device->Barrier(barriers, arraysize(barriers), cmd); } @@ -6970,7 +6346,6 @@ void RefreshEnvProbes(const Visibility& vis, CommandList cmd) desc.Width *= 2; desc.Height *= 2; } - device->UnbindUAVs(0, 1, cmd); } device->EventEnd(cmd); }; @@ -7014,18 +6389,6 @@ void RefreshImpostors(const Scene& scene, CommandList cmd) BindCommonResources(cmd); - struct InstBuf - { - Instance instance; - InstancePrev instancePrev; - InstanceAtlas instanceAtlas; - }; - GraphicsDevice::GPUAllocation mem = device->AllocateGPU(sizeof(InstBuf), cmd); - volatile InstBuf* buff = (volatile InstBuf*)mem.data; - buff->instance.Create(IDENTITYMATRIX); - buff->instancePrev.Create(IDENTITYMATRIX); - buff->instanceAtlas.Create(XMFLOAT4(1, 1, 0, 0)); - for (uint32_t impostorIndex = 0; impostorIndex < scene.impostors.GetCount(); ++impostorIndex) { const ImpostorComponent& impostor = scene.impostors[impostorIndex]; @@ -7039,50 +6402,6 @@ void RefreshImpostors(const Scene& scene, CommandList cmd) // impostor camera will fit around mesh bounding sphere: const SPHERE boundingsphere = mesh.GetBoundingSphere(); - ObjectPushConstants push; // used with bindless model only - - const bool bindless = device->CheckCapability(GRAPHICSDEVICE_CAPABILITY_BINDLESS_DESCRIPTORS); - if (bindless) - { - push.mesh = device->GetDescriptorIndex(&mesh.descriptor, SRV); - push.instances = device->GetDescriptorIndex(mem.buffer, SRV); - push.instance_offset = mem.offset; - } - else - { - const GPUBuffer* vbs[] = { - mesh.streamoutBuffer_POS.IsValid() ? &mesh.streamoutBuffer_POS : &mesh.vertexBuffer_POS, - mesh.vertexBuffer_PRE.IsValid() ? &mesh.vertexBuffer_PRE : &mesh.vertexBuffer_POS, - &mesh.vertexBuffer_UV0, - &mesh.vertexBuffer_UV1, - &mesh.vertexBuffer_ATL, - &mesh.vertexBuffer_COL, - mesh.streamoutBuffer_TAN.IsValid() ? &mesh.streamoutBuffer_TAN : &mesh.vertexBuffer_TAN, - mem.buffer - }; - uint32_t strides[] = { - sizeof(MeshComponent::Vertex_POS), - sizeof(MeshComponent::Vertex_POS), - sizeof(MeshComponent::Vertex_TEX), - sizeof(MeshComponent::Vertex_TEX), - sizeof(MeshComponent::Vertex_TEX), - sizeof(MeshComponent::Vertex_COL), - sizeof(MeshComponent::Vertex_TAN), - sizeof(InstBuf) - }; - uint32_t offsets[] = { - 0, - 0, - 0, - 0, - 0, - 0, - 0, - mem.offset - }; - device->BindVertexBuffers(vbs, 0, arraysize(vbs), strides, offsets, cmd); - } - device->BindIndexBuffer(&mesh.indexBuffer, mesh.GetIndexFormat(), 0, cmd); for (int prop = 0; prop < 3; ++prop) @@ -7129,28 +6448,23 @@ void RefreshImpostors(const Scene& scene, CommandList cmd) viewport.Width = (float)scene.impostorTextureDim; device->BindViewports(1, &viewport, cmd); - for (auto& subset : mesh.subsets) + for (size_t subsetIndex = 0; subsetIndex < mesh.subsets.size(); ++subsetIndex) { + const MeshComponent::MeshSubset& subset = mesh.subsets[subsetIndex]; if (subset.indexCount == 0) { continue; } const MaterialComponent& material = *scene.materials.GetComponent(subset.materialID); - if (bindless) - { - push.material = device->GetDescriptorIndex(&material.constantBuffer, SRV); - device->PushConstants(&push, sizeof(push), cmd); - } - else - { - device->BindConstantBuffer(VS, &material.constantBuffer, CB_GETBINDSLOT(MaterialCB), cmd); - device->BindConstantBuffer(PS, &material.constantBuffer, CB_GETBINDSLOT(MaterialCB), cmd); - - const GPUResource* res[4]; - material.WriteTextures(res, arraysize(res)); - device->BindResources(PS, res, TEXSLOT_ONDEMAND0, arraysize(res), cmd); - } + ObjectPushConstants push; + push.init( + (uint)scene.meshes.GetIndex(entity), + (uint)subsetIndex, + subset.materialIndex, + -1, 0 + ); + device->PushConstants(&push, sizeof(push), cmd); device->DrawIndexedInstanced(subset.indexCount, 1, subset.indexOffset, 0, 0, cmd); } @@ -7216,10 +6530,10 @@ void VoxelRadiance(const Visibility& vis, CommandList cmd) device->BindViewports(1, &vp, cmd); GPUResource* UAVs[] = { &resourceBuffers[RBTYPE_VOXELSCENE] }; - device->BindUAVs(PS, UAVs, 0, 1, cmd); + device->BindUAVs(UAVs, 0, 1, cmd); BindCommonResources(cmd); - BindShadowmaps(PS, cmd); + device->RenderPassBegin(&renderpass_voxelize, cmd); RenderMeshes(vis, renderQueue, RENDERPASS_VOXELIZE, RENDERTYPE_OPAQUE, cmd, false, nullptr, 1); @@ -7236,8 +6550,8 @@ void VoxelRadiance(const Visibility& vis, CommandList cmd) // Copy the packed voxel scene data to a 3D texture, then delete the voxel scene emission data. The cone tracing will operate on the 3D texture device->EventBegin("Voxel Scene Copy - Clear", cmd); - device->BindUAV(CS, &resourceBuffers[RBTYPE_VOXELSCENE], 0, cmd); - device->BindUAV(CS, &textures[TEXTYPE_3D_VOXELRADIANCE], 1, cmd); + device->BindUAV(&resourceBuffers[RBTYPE_VOXELSCENE], 0, cmd); + device->BindUAV(&textures[TEXTYPE_3D_VOXELRADIANCE], 1, cmd); static bool smooth_copy = true; if (smooth_copy) @@ -7261,13 +6575,12 @@ void VoxelRadiance(const Visibility& vis, CommandList cmd) if (voxelSceneData.secondaryBounceEnabled) { device->EventBegin("Voxel Radiance Secondary Bounce", cmd); - device->UnbindUAVs(1, 1, cmd); // Pre-integrate the voxel texture by creating blurred mip levels: GenerateMipChain(textures[TEXTYPE_3D_VOXELRADIANCE], MIPGENFILTER_LINEAR, cmd); - device->BindResource(CS, &textures[TEXTYPE_3D_VOXELRADIANCE], 0, cmd); - device->BindResource(CS, &resourceBuffers[RBTYPE_VOXELSCENE], 1, cmd); - device->BindUAV(CS, &textures[TEXTYPE_3D_VOXELRADIANCE_HELPER], 0, cmd); + device->BindResource(&textures[TEXTYPE_3D_VOXELRADIANCE], 0, cmd); + device->BindResource(&resourceBuffers[RBTYPE_VOXELSCENE], 1, cmd); + device->BindUAV(&textures[TEXTYPE_3D_VOXELRADIANCE_HELPER], 0, cmd); device->BindComputeShader(&shaders[CSTYPE_VOXELRADIANCESECONDARYBOUNCE], cmd); device->Dispatch(voxelSceneData.res / 8, voxelSceneData.res / 8, voxelSceneData.res / 8, cmd); device->EventEnd(cmd); @@ -7280,8 +6593,7 @@ void VoxelRadiance(const Visibility& vis, CommandList cmd) } device->EventBegin("Voxel Scene Clear Normals", cmd); - device->UnbindResources(1, 1, cmd); - device->BindUAV(CS, &resourceBuffers[RBTYPE_VOXELSCENE], 0, cmd); + device->BindUAV(&resourceBuffers[RBTYPE_VOXELSCENE], 0, cmd); device->BindComputeShader(&shaders[CSTYPE_VOXELCLEARONLYNORMAL], cmd); device->Dispatch((uint32_t)(voxelSceneData.res * voxelSceneData.res * voxelSceneData.res / 256), 1, 1, cmd); device->EventEnd(cmd); @@ -7296,7 +6608,6 @@ void VoxelRadiance(const Visibility& vis, CommandList cmd) result = &textures[TEXTYPE_3D_VOXELRADIANCE_HELPER]; } - device->UnbindUAVs(0, 2, cmd); // Pre-integrate the voxel texture by creating blurred mip levels: @@ -7321,7 +6632,6 @@ void CreateTiledLightResources(TiledLightResources& res, XMUINT2 resolution) bd.BindFlags = BIND_SHADER_RESOURCE | BIND_UNORDERED_ACCESS; bd.MiscFlags = RESOURCE_MISC_BUFFER_STRUCTURED; bd.Usage = USAGE_DEFAULT; - bd.CPUAccessFlags = 0; device->CreateBuffer(&bd, nullptr, &res.tileFrustums); device->SetName(&res.tileFrustums, "tileFrustums"); @@ -7332,7 +6642,6 @@ void CreateTiledLightResources(TiledLightResources& res, XMUINT2 resolution) bd.ByteWidth = tileCount.x * tileCount.y * bd.StructureByteStride * SHADER_ENTITY_TILE_BUCKET_COUNT; bd.Usage = USAGE_DEFAULT; bd.BindFlags = BIND_UNORDERED_ACCESS | BIND_SHADER_RESOURCE; - bd.CPUAccessFlags = 0; bd.MiscFlags = RESOURCE_MISC_BUFFER_STRUCTURED; device->CreateBuffer(&bd, nullptr, &res.entityTiles_Opaque); device->CreateBuffer(&bd, nullptr, &res.entityTiles_Transparent); @@ -7352,7 +6661,7 @@ void ComputeTiledLightCulling( BindCommonResources(cmd); - device->BindResource(CS, &depthbuffer, TEXSLOT_DEPTH, cmd); + device->BindResource(&depthbuffer, TEXSLOT_DEPTH, cmd); // Frustum computation { @@ -7362,12 +6671,12 @@ void ComputeTiledLightCulling( const GPUResource* uavs[] = { &res.tileFrustums }; - device->BindUAVs(CS, uavs, 0, arraysize(uavs), cmd); + device->BindUAVs(uavs, 0, arraysize(uavs), cmd); { GPUBarrier barriers[] = { GPUBarrier::Memory(&res.tileFrustums), - GPUBarrier::Buffer(&res.tileFrustums, BUFFER_STATE_SHADER_RESOURCE, BUFFER_STATE_UNORDERED_ACCESS) + GPUBarrier::Buffer(&res.tileFrustums, RESOURCE_STATE_SHADER_RESOURCE, RESOURCE_STATE_UNORDERED_ACCESS) }; device->Barrier(barriers, arraysize(barriers), cmd); } @@ -7378,7 +6687,6 @@ void ComputeTiledLightCulling( 1, cmd ); - device->UnbindUAVs(0, arraysize(uavs), cmd); device->EventEnd(cmd); } @@ -7387,12 +6695,12 @@ void ComputeTiledLightCulling( { device->EventBegin("Entity Culling", cmd); - device->BindResource(CS, &res.tileFrustums, TEXSLOT_ONDEMAND0, cmd); + device->BindResource(&res.tileFrustums, TEXSLOT_ONDEMAND0, cmd); if (GetDebugLightCulling() && debugUAV.IsValid()) { device->BindComputeShader(&shaders[GetAdvancedLightCulling() ? CSTYPE_LIGHTCULLING_ADVANCED_DEBUG : CSTYPE_LIGHTCULLING_DEBUG], cmd); - device->BindUAV(CS, &debugUAV, 3, cmd); + device->BindUAV(&debugUAV, 3, cmd); } else { @@ -7403,14 +6711,14 @@ void ComputeTiledLightCulling( &res.entityTiles_Transparent, &res.entityTiles_Opaque, }; - device->BindUAVs(CS, uavs, 0, arraysize(uavs), cmd); + device->BindUAVs(uavs, 0, arraysize(uavs), cmd); { GPUBarrier barriers[] = { GPUBarrier::Memory(&res.tileFrustums), - GPUBarrier::Buffer(&res.tileFrustums, BUFFER_STATE_UNORDERED_ACCESS, BUFFER_STATE_SHADER_RESOURCE), - GPUBarrier::Buffer(&res.entityTiles_Transparent, BUFFER_STATE_SHADER_RESOURCE, BUFFER_STATE_UNORDERED_ACCESS), - GPUBarrier::Buffer(&res.entityTiles_Opaque, BUFFER_STATE_SHADER_RESOURCE, BUFFER_STATE_UNORDERED_ACCESS), + GPUBarrier::Buffer(&res.tileFrustums, RESOURCE_STATE_UNORDERED_ACCESS, RESOURCE_STATE_SHADER_RESOURCE), + GPUBarrier::Buffer(&res.entityTiles_Transparent, RESOURCE_STATE_SHADER_RESOURCE, RESOURCE_STATE_UNORDERED_ACCESS), + GPUBarrier::Buffer(&res.entityTiles_Opaque, RESOURCE_STATE_SHADER_RESOURCE, RESOURCE_STATE_UNORDERED_ACCESS), }; device->Barrier(barriers, arraysize(barriers), cmd); } @@ -7421,13 +6729,12 @@ void ComputeTiledLightCulling( GPUBarrier barriers[] = { GPUBarrier::Memory(&res.entityTiles_Opaque), GPUBarrier::Memory(&res.entityTiles_Transparent), - GPUBarrier::Buffer(&res.entityTiles_Opaque, BUFFER_STATE_UNORDERED_ACCESS, BUFFER_STATE_SHADER_RESOURCE), - GPUBarrier::Buffer(&res.entityTiles_Transparent, BUFFER_STATE_UNORDERED_ACCESS, BUFFER_STATE_SHADER_RESOURCE), + GPUBarrier::Buffer(&res.entityTiles_Opaque, RESOURCE_STATE_UNORDERED_ACCESS, RESOURCE_STATE_SHADER_RESOURCE), + GPUBarrier::Buffer(&res.entityTiles_Transparent, RESOURCE_STATE_UNORDERED_ACCESS, RESOURCE_STATE_SHADER_RESOURCE), }; device->Barrier(barriers, arraysize(barriers), cmd); } - device->UnbindUAVs(0, arraysize(uavs), cmd); device->EventEnd(cmd); } @@ -7438,8 +6745,8 @@ void ResolveMSAADepthBuffer(const Texture& dst, const Texture& src, CommandList { device->EventBegin("ResolveMSAADepthBuffer", cmd); - device->BindResource(CS, &src, TEXSLOT_ONDEMAND0, cmd); - device->BindUAV(CS, &dst, 0, cmd); + device->BindResource(&src, TEXSLOT_ONDEMAND0, cmd); + device->BindUAV(&dst, 0, cmd); const TextureDesc& desc = src.GetDesc(); @@ -7447,8 +6754,6 @@ void ResolveMSAADepthBuffer(const Texture& dst, const Texture& src, CommandList device->Dispatch((desc.Width + 7) / 8, (desc.Height + 7) / 8, 1, cmd); - device->UnbindResources(TEXSLOT_ONDEMAND0, 1, cmd); - device->UnbindUAVs(0, 1, cmd); device->EventEnd(cmd); } @@ -7458,11 +6763,10 @@ void DownsampleDepthBuffer(const wiGraphics::Texture& src, wiGraphics::CommandLi device->BindPipelineState(&PSO_downsampledepthbuffer, cmd); - device->BindResource(PS, &src, TEXSLOT_ONDEMAND0, cmd); + device->BindResource(&src, TEXSLOT_ONDEMAND0, cmd); device->Draw(3, 0, cmd); - device->UnbindResources(TEXSLOT_ONDEMAND0, 1, cmd); device->EventEnd(cmd); } @@ -7500,12 +6804,12 @@ void GenerateMipChain(const Texture& texture, MIPGENFILTER filter, CommandList c case MIPGENFILTER_POINT: device->EventBegin("GenerateMipChain CubeArray - PointFilter", cmd); device->BindComputeShader(&shaders[hdr ? CSTYPE_GENERATEMIPCHAINCUBEARRAY_FLOAT4 : CSTYPE_GENERATEMIPCHAINCUBEARRAY_UNORM4], cmd); - device->BindSampler(CS, &samplers[SSLOT_POINT_CLAMP], SSLOT_ONDEMAND0, cmd); + device->BindSampler(&samplers[SSLOT_POINT_CLAMP], SSLOT_ONDEMAND0, cmd); break; case MIPGENFILTER_LINEAR: device->EventBegin("GenerateMipChain CubeArray - LinearFilter", cmd); device->BindComputeShader(&shaders[hdr ? CSTYPE_GENERATEMIPCHAINCUBEARRAY_FLOAT4 : CSTYPE_GENERATEMIPCHAINCUBEARRAY_UNORM4], cmd); - device->BindSampler(CS, &samplers[SSLOT_LINEAR_CLAMP], SSLOT_ONDEMAND0, cmd); + device->BindSampler(&samplers[SSLOT_LINEAR_CLAMP], SSLOT_ONDEMAND0, cmd); break; default: assert(0); @@ -7516,18 +6820,18 @@ void GenerateMipChain(const Texture& texture, MIPGENFILTER filter, CommandList c { { GPUBarrier barriers[] = { - GPUBarrier::Image(&texture, texture.desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS, i + 1, options.arrayIndex * 6 + 0), - GPUBarrier::Image(&texture, texture.desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS, i + 1, options.arrayIndex * 6 + 1), - GPUBarrier::Image(&texture, texture.desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS, i + 1, options.arrayIndex * 6 + 2), - GPUBarrier::Image(&texture, texture.desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS, i + 1, options.arrayIndex * 6 + 3), - GPUBarrier::Image(&texture, texture.desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS, i + 1, options.arrayIndex * 6 + 4), - GPUBarrier::Image(&texture, texture.desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS, i + 1, options.arrayIndex * 6 + 5), + GPUBarrier::Image(&texture, texture.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS, i + 1, options.arrayIndex * 6 + 0), + GPUBarrier::Image(&texture, texture.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS, i + 1, options.arrayIndex * 6 + 1), + GPUBarrier::Image(&texture, texture.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS, i + 1, options.arrayIndex * 6 + 2), + GPUBarrier::Image(&texture, texture.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS, i + 1, options.arrayIndex * 6 + 3), + GPUBarrier::Image(&texture, texture.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS, i + 1, options.arrayIndex * 6 + 4), + GPUBarrier::Image(&texture, texture.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS, i + 1, options.arrayIndex * 6 + 5), }; device->Barrier(barriers, arraysize(barriers), cmd); } - device->BindUAV(CS, &texture, 0, cmd, i + 1); - device->BindResource(CS, &texture, TEXSLOT_ONDEMAND0, cmd, i); + device->BindUAV(&texture, 0, cmd, i + 1); + device->BindResource(&texture, TEXSLOT_ONDEMAND0, cmd, i); desc.Width = std::max(1u, desc.Width / 2); desc.Height = std::max(1u, desc.Height / 2); @@ -7538,8 +6842,7 @@ void GenerateMipChain(const Texture& texture, MIPGENFILTER filter, CommandList c cb.outputResolution_rcp.y = 1.0f / cb.outputResolution.y; cb.arrayIndex = options.arrayIndex; cb.mipgen_options = 0; - device->UpdateBuffer(&constantBuffers[CBTYPE_MIPGEN], &cb, cmd); - device->BindConstantBuffer(CS, &constantBuffers[CBTYPE_MIPGEN], CB_GETBINDSLOT(GenerateMIPChainCB), cmd); + device->PushConstants(&cb, sizeof(cb), cmd); device->Dispatch( std::max(1u, (desc.Width + GENERATEMIPCHAIN_2D_BLOCK_SIZE - 1) / GENERATEMIPCHAIN_2D_BLOCK_SIZE), @@ -7550,12 +6853,12 @@ void GenerateMipChain(const Texture& texture, MIPGENFILTER filter, CommandList c { GPUBarrier barriers[] = { GPUBarrier::Memory(), - GPUBarrier::Image(&texture, IMAGE_LAYOUT_UNORDERED_ACCESS, texture.desc.layout, i + 1, options.arrayIndex * 6 + 0), - GPUBarrier::Image(&texture, IMAGE_LAYOUT_UNORDERED_ACCESS, texture.desc.layout, i + 1, options.arrayIndex * 6 + 1), - GPUBarrier::Image(&texture, IMAGE_LAYOUT_UNORDERED_ACCESS, texture.desc.layout, i + 1, options.arrayIndex * 6 + 2), - GPUBarrier::Image(&texture, IMAGE_LAYOUT_UNORDERED_ACCESS, texture.desc.layout, i + 1, options.arrayIndex * 6 + 3), - GPUBarrier::Image(&texture, IMAGE_LAYOUT_UNORDERED_ACCESS, texture.desc.layout, i + 1, options.arrayIndex * 6 + 4), - GPUBarrier::Image(&texture, IMAGE_LAYOUT_UNORDERED_ACCESS, texture.desc.layout, i + 1, options.arrayIndex * 6 + 5), + GPUBarrier::Image(&texture, RESOURCE_STATE_UNORDERED_ACCESS, texture.desc.layout, i + 1, options.arrayIndex * 6 + 0), + GPUBarrier::Image(&texture, RESOURCE_STATE_UNORDERED_ACCESS, texture.desc.layout, i + 1, options.arrayIndex * 6 + 1), + GPUBarrier::Image(&texture, RESOURCE_STATE_UNORDERED_ACCESS, texture.desc.layout, i + 1, options.arrayIndex * 6 + 2), + GPUBarrier::Image(&texture, RESOURCE_STATE_UNORDERED_ACCESS, texture.desc.layout, i + 1, options.arrayIndex * 6 + 3), + GPUBarrier::Image(&texture, RESOURCE_STATE_UNORDERED_ACCESS, texture.desc.layout, i + 1, options.arrayIndex * 6 + 4), + GPUBarrier::Image(&texture, RESOURCE_STATE_UNORDERED_ACCESS, texture.desc.layout, i + 1, options.arrayIndex * 6 + 5), }; device->Barrier(barriers, arraysize(barriers), cmd); } @@ -7569,12 +6872,12 @@ void GenerateMipChain(const Texture& texture, MIPGENFILTER filter, CommandList c case MIPGENFILTER_POINT: device->EventBegin("GenerateMipChain Cube - PointFilter", cmd); device->BindComputeShader(&shaders[hdr ? CSTYPE_GENERATEMIPCHAINCUBE_FLOAT4 : CSTYPE_GENERATEMIPCHAINCUBE_UNORM4], cmd); - device->BindSampler(CS, &samplers[SSLOT_POINT_CLAMP], SSLOT_ONDEMAND0, cmd); + device->BindSampler(&samplers[SSLOT_POINT_CLAMP], SSLOT_ONDEMAND0, cmd); break; case MIPGENFILTER_LINEAR: device->EventBegin("GenerateMipChain Cube - LinearFilter", cmd); device->BindComputeShader(&shaders[hdr ? CSTYPE_GENERATEMIPCHAINCUBE_FLOAT4 : CSTYPE_GENERATEMIPCHAINCUBE_UNORM4], cmd); - device->BindSampler(CS, &samplers[SSLOT_LINEAR_CLAMP], SSLOT_ONDEMAND0, cmd); + device->BindSampler(&samplers[SSLOT_LINEAR_CLAMP], SSLOT_ONDEMAND0, cmd); break; default: assert(0); // not implemented @@ -7583,8 +6886,8 @@ void GenerateMipChain(const Texture& texture, MIPGENFILTER filter, CommandList c for (uint32_t i = 0; i < desc.MipLevels - 1; ++i) { - device->BindUAV(CS, &texture, 0, cmd, i + 1); - device->BindResource(CS, &texture, TEXSLOT_ONDEMAND0, cmd, i); + device->BindUAV(&texture, 0, cmd, i + 1); + device->BindResource(&texture, TEXSLOT_ONDEMAND0, cmd, i); desc.Width = std::max(1u, desc.Width / 2); desc.Height = std::max(1u, desc.Height / 2); @@ -7595,8 +6898,7 @@ void GenerateMipChain(const Texture& texture, MIPGENFILTER filter, CommandList c cb.outputResolution_rcp.y = 1.0f / cb.outputResolution.y; cb.arrayIndex = 0; cb.mipgen_options = 0; - device->UpdateBuffer(&constantBuffers[CBTYPE_MIPGEN], &cb, cmd); - device->BindConstantBuffer(CS, &constantBuffers[CBTYPE_MIPGEN], CB_GETBINDSLOT(GenerateMIPChainCB), cmd); + device->PushConstants(&cb, sizeof(cb), cmd); device->Dispatch( std::max(1u, (desc.Width + GENERATEMIPCHAIN_2D_BLOCK_SIZE - 1) / GENERATEMIPCHAIN_2D_BLOCK_SIZE), @@ -7620,12 +6922,12 @@ void GenerateMipChain(const Texture& texture, MIPGENFILTER filter, CommandList c case MIPGENFILTER_POINT: device->EventBegin("GenerateMipChain 2D - PointFilter", cmd); device->BindComputeShader(&shaders[hdr ? CSTYPE_GENERATEMIPCHAIN2D_FLOAT4 : CSTYPE_GENERATEMIPCHAIN2D_UNORM4], cmd); - device->BindSampler(CS, &samplers[SSLOT_POINT_CLAMP], SSLOT_ONDEMAND0, cmd); + device->BindSampler(&samplers[SSLOT_POINT_CLAMP], SSLOT_ONDEMAND0, cmd); break; case MIPGENFILTER_LINEAR: device->EventBegin("GenerateMipChain 2D - LinearFilter", cmd); device->BindComputeShader(&shaders[hdr ? CSTYPE_GENERATEMIPCHAIN2D_FLOAT4 : CSTYPE_GENERATEMIPCHAIN2D_UNORM4], cmd); - device->BindSampler(CS, &samplers[SSLOT_LINEAR_CLAMP], SSLOT_ONDEMAND0, cmd); + device->BindSampler(&samplers[SSLOT_LINEAR_CLAMP], SSLOT_ONDEMAND0, cmd); break; case MIPGENFILTER_GAUSSIAN: { @@ -7649,13 +6951,13 @@ void GenerateMipChain(const Texture& texture, MIPGENFILTER filter, CommandList c { { GPUBarrier barriers[] = { - GPUBarrier::Image(&texture,texture.desc.layout,IMAGE_LAYOUT_UNORDERED_ACCESS,i + 1), + GPUBarrier::Image(&texture,texture.desc.layout,RESOURCE_STATE_UNORDERED_ACCESS,i + 1), }; device->Barrier(barriers, arraysize(barriers), cmd); } - device->BindUAV(CS, &texture, 0, cmd, i + 1); - device->BindResource(CS, &texture, TEXSLOT_ONDEMAND0, cmd, i); + device->BindUAV(&texture, 0, cmd, i + 1); + device->BindResource(&texture, TEXSLOT_ONDEMAND0, cmd, i); desc.Width = std::max(1u, desc.Width / 2); desc.Height = std::max(1u, desc.Height / 2); @@ -7670,8 +6972,7 @@ void GenerateMipChain(const Texture& texture, MIPGENFILTER filter, CommandList c { cb.mipgen_options |= MIPGEN_OPTION_BIT_PRESERVE_COVERAGE; } - device->UpdateBuffer(&constantBuffers[CBTYPE_MIPGEN], &cb, cmd); - device->BindConstantBuffer(CS, &constantBuffers[CBTYPE_MIPGEN], CB_GETBINDSLOT(GenerateMIPChainCB), cmd); + device->PushConstants(&cb, sizeof(cb), cmd); device->Dispatch( std::max(1u, (desc.Width + GENERATEMIPCHAIN_2D_BLOCK_SIZE - 1) / GENERATEMIPCHAIN_2D_BLOCK_SIZE), @@ -7682,15 +6983,13 @@ void GenerateMipChain(const Texture& texture, MIPGENFILTER filter, CommandList c { GPUBarrier barriers[] = { GPUBarrier::Memory(), - GPUBarrier::Image(&texture,IMAGE_LAYOUT_UNORDERED_ACCESS,texture.desc.layout,i + 1), + GPUBarrier::Image(&texture,RESOURCE_STATE_UNORDERED_ACCESS,texture.desc.layout,i + 1), }; device->Barrier(barriers, arraysize(barriers), cmd); } } } - device->UnbindResources(TEXSLOT_ONDEMAND0, 1, cmd); - device->UnbindUAVs(0, 1, cmd); device->EventEnd(cmd); } @@ -7701,12 +7000,12 @@ void GenerateMipChain(const Texture& texture, MIPGENFILTER filter, CommandList c case MIPGENFILTER_POINT: device->EventBegin("GenerateMipChain 3D - PointFilter", cmd); device->BindComputeShader(&shaders[hdr ? CSTYPE_GENERATEMIPCHAIN3D_FLOAT4 : CSTYPE_GENERATEMIPCHAIN3D_UNORM4], cmd); - device->BindSampler(CS, &samplers[SSLOT_POINT_CLAMP], SSLOT_ONDEMAND0, cmd); + device->BindSampler(&samplers[SSLOT_POINT_CLAMP], SSLOT_ONDEMAND0, cmd); break; case MIPGENFILTER_LINEAR: device->EventBegin("GenerateMipChain 3D - LinearFilter", cmd); device->BindComputeShader(&shaders[hdr ? CSTYPE_GENERATEMIPCHAIN3D_FLOAT4 : CSTYPE_GENERATEMIPCHAIN3D_UNORM4], cmd); - device->BindSampler(CS, &samplers[SSLOT_LINEAR_CLAMP], SSLOT_ONDEMAND0, cmd); + device->BindSampler(&samplers[SSLOT_LINEAR_CLAMP], SSLOT_ONDEMAND0, cmd); break; default: assert(0); // not implemented @@ -7715,8 +7014,8 @@ void GenerateMipChain(const Texture& texture, MIPGENFILTER filter, CommandList c for (uint32_t i = 0; i < desc.MipLevels - 1; ++i) { - device->BindUAV(CS, &texture, 0, cmd, i + 1); - device->BindResource(CS, &texture, TEXSLOT_ONDEMAND0, cmd, i); + device->BindUAV(&texture, 0, cmd, i + 1); + device->BindResource(&texture, TEXSLOT_ONDEMAND0, cmd, i); desc.Width = std::max(1u, desc.Width / 2); desc.Height = std::max(1u, desc.Height / 2); desc.Depth = std::max(1u, desc.Depth / 2); @@ -7730,8 +7029,7 @@ void GenerateMipChain(const Texture& texture, MIPGENFILTER filter, CommandList c cb.outputResolution_rcp.z = 1.0f / cb.outputResolution.z; cb.arrayIndex = options.arrayIndex >= 0 ? (uint)options.arrayIndex : 0; cb.mipgen_options = 0; - device->UpdateBuffer(&constantBuffers[CBTYPE_MIPGEN], &cb, cmd); - device->BindConstantBuffer(CS, &constantBuffers[CBTYPE_MIPGEN], CB_GETBINDSLOT(GenerateMIPChainCB), cmd); + device->PushConstants(&cb, sizeof(cb), cmd); device->Dispatch( std::max(1u, (desc.Width + GENERATEMIPCHAIN_3D_BLOCK_SIZE - 1) / GENERATEMIPCHAIN_3D_BLOCK_SIZE), @@ -7745,8 +7043,6 @@ void GenerateMipChain(const Texture& texture, MIPGENFILTER filter, CommandList c device->Barrier(barriers, arraysize(barriers), cmd); } - device->UnbindResources(TEXSLOT_ONDEMAND0, 1, cmd); - device->UnbindUAVs(0, 1, cmd); device->EventEnd(cmd); } @@ -7800,29 +7096,26 @@ void CopyTexture2D(const Texture& dst, int DstMIP, int DstX, int DstY, const Tex cb.xCopySrcSize.y = desc_src.Height >> SrcMIP; cb.xCopySrcMIP = SrcMIP; cb.xCopyBorderExpandStyle = (uint)borderExpand; - device->UpdateBuffer(&constantBuffers[CBTYPE_COPYTEXTURE], &cb, cmd); + device->PushConstants(&cb, sizeof(cb), cmd); - device->BindConstantBuffer(CS, &constantBuffers[CBTYPE_COPYTEXTURE], CB_GETBINDSLOT(CopyTextureCB), cmd); + device->BindResource(&src, TEXSLOT_ONDEMAND0, cmd); - device->BindResource(CS, &src, TEXSLOT_ONDEMAND0, cmd); - - device->BindUAV(CS, &dst, 0, cmd, DstMIP); + device->BindUAV(&dst, 0, cmd, DstMIP); { GPUBarrier barriers[] = { - GPUBarrier::Image(&dst,dst.desc.layout,IMAGE_LAYOUT_UNORDERED_ACCESS, DstMIP), + GPUBarrier::Image(&dst,dst.desc.layout,RESOURCE_STATE_UNORDERED_ACCESS, DstMIP), }; device->Barrier(barriers, arraysize(barriers), cmd); } device->Dispatch((cb.xCopySrcSize.x + 7) / 8, (cb.xCopySrcSize.y + 7) / 8, 1, cmd); - device->UnbindUAVs(0, 1, cmd); { GPUBarrier barriers[] = { GPUBarrier::Memory(), - GPUBarrier::Image(&dst,IMAGE_LAYOUT_UNORDERED_ACCESS,dst.desc.layout, DstMIP), + GPUBarrier::Image(&dst,RESOURCE_STATE_UNORDERED_ACCESS,dst.desc.layout, DstMIP), }; device->Barrier(barriers, arraysize(barriers), cmd); } @@ -7841,17 +7134,17 @@ void RayTraceScene( ) { // Set up tracing resources: - if (device->CheckCapability(GRAPHICSDEVICE_CAPABILITY_RAYTRACING_INLINE)) + if (device->CheckCapability(GRAPHICSDEVICE_CAPABILITY_RAYTRACING)) { if (!scene.TLAS.IsValid()) { return; } - device->BindResource(CS, &scene.TLAS, TEXSLOT_ACCELERATION_STRUCTURE, cmd); + device->BindResource(&scene.TLAS, TEXSLOT_ACCELERATION_STRUCTURE, cmd); } else { - scene.BVH.Bind(CS, cmd); + scene.BVH.Bind(cmd); } device->EventBegin("RayTraceScene", cmd); @@ -7859,16 +7152,8 @@ void RayTraceScene( const TextureDesc& desc = output.GetDesc(); - if (scene.weather.skyMap != nullptr) - { - device->BindResource(CS, &scene.weather.skyMap->texture, TEXSLOT_GLOBALENVMAP, cmd); - } - else - { - device->BindResource(CS, &textures[TEXTYPE_2D_SKYATMOSPHERE_SKYVIEWLUT], TEXSLOT_SKYVIEWLUT, cmd); - device->BindResource(CS, &textures[TEXTYPE_2D_SKYATMOSPHERE_TRANSMITTANCELUT], TEXSLOT_TRANSMITTANCELUT, cmd); - device->BindResource(CS, &textures[TEXTYPE_2D_SKYATMOSPHERE_MULTISCATTEREDLUMINANCELUT], TEXSLOT_MULTISCATTERINGLUT, cmd); - } + BindCommonResources(cmd); + const XMFLOAT4& halton = wiMath::GetHaltonSequence(accumulation_sample); RaytracingCB cb; @@ -7880,30 +7165,29 @@ void RayTraceScene( cb.xTraceResolution_rcp.y = 1.0f / cb.xTraceResolution.y; cb.xTraceUserData.x = raytraceBounceCount; cb.xTraceSampleIndex = (uint32_t)accumulation_sample; - device->UpdateBuffer(&constantBuffers[CBTYPE_RAYTRACE], &cb, cmd); - device->BindConstantBuffer(CS, &constantBuffers[CBTYPE_RAYTRACE], CB_GETBINDSLOT(RaytracingCB), cmd); + device->BindDynamicConstantBuffer(cb, CB_GETBINDSLOT(RaytracingCB), cmd); device->BindComputeShader(&shaders[CSTYPE_RAYTRACE], cmd); const GPUResource* uavs[] = { &output, }; - device->BindUAVs(CS, uavs, 0, arraysize(uavs), cmd); + device->BindUAVs(uavs, 0, arraysize(uavs), cmd); { GPUBarrier barriers[] = { - GPUBarrier::Image(&output, output.desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS), + GPUBarrier::Image(&output, output.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS), }; device->Barrier(barriers, arraysize(barriers), cmd); } if (output_albedo != nullptr) { - device->BindUAV(CS, output_albedo, 1, cmd); + device->BindUAV(output_albedo, 1, cmd); } if (output_normal != nullptr) { - device->BindUAV(CS, output_normal, 2, cmd); + device->BindUAV(output_normal, 2, cmd); } device->Dispatch( @@ -7915,12 +7199,11 @@ void RayTraceScene( { GPUBarrier barriers[] = { GPUBarrier::Memory(), - GPUBarrier::Image(&output, IMAGE_LAYOUT_UNORDERED_ACCESS, output.desc.layout), + GPUBarrier::Image(&output, RESOURCE_STATE_UNORDERED_ACCESS, output.desc.layout), }; device->Barrier(barriers, arraysize(barriers), cmd); } - device->UnbindUAVs(0, 3, cmd); wiProfiler::EndRange(range); device->EventEnd(cmd); // RayTraceScene @@ -7929,130 +7212,28 @@ void RayTraceSceneBVH(const Scene& scene, CommandList cmd) { device->EventBegin("RayTraceSceneBVH", cmd); device->BindPipelineState(&PSO_debug[DEBUGRENDERING_RAYTRACE_BVH], cmd); - scene.BVH.Bind(PS, cmd); + scene.BVH.Bind(cmd); device->Draw(3, 0, cmd); device->EventEnd(cmd); } - -void RefreshDecalAtlas(const Scene& scene, CommandList cmd) +void RefreshLightmaps(const Scene& scene, CommandList cmd) { - using namespace wiRectPacker; - - if (scene.decal_repack_needed) - { - for (uint32_t mip = 0; mip < scene.decalAtlas.GetDesc().MipLevels; ++mip) - { - for (auto& it : scene.packedDecals) - { - if (mip < it.first->texture.desc.MipLevels) - { - CopyTexture2D(scene.decalAtlas, mip, (it.second.x >> mip) + Scene::atlasClampBorder, (it.second.y >> mip) + Scene::atlasClampBorder, it.first->texture, mip, cmd, BORDEREXPAND_CLAMP); - } - } - } - scene.decal_repack_needed = false; - } -} - -void RenderObjectLightMap(const Scene& scene, const ObjectComponent& object, CommandList cmd) -{ - device->EventBegin("RenderObjectLightMap", cmd); - - const MeshComponent& mesh = *scene.meshes.GetComponent(object.meshID); - assert(!mesh.vertex_atlas.empty()); - assert(mesh.vertexBuffer_ATL.IsValid()); - - const TextureDesc& desc = object.lightmap.GetDesc(); - - if (object.lightmapIterationCount == 0) - { - device->RenderPassBegin(&object.renderpass_lightmap_clear, cmd); - } - else - { - device->RenderPassBegin(&object.renderpass_lightmap_accumulate, cmd); - } - - Viewport vp; - vp.Width = (float)desc.Width; - vp.Height = (float)desc.Height; - device->BindViewports(1, &vp, cmd); - - const TransformComponent& transform = scene.transforms[object.transform_index]; - - MiscCB misccb; - misccb.g_xTransform = transform.world; - device->UpdateBuffer(&constantBuffers[CBTYPE_MISC], &misccb, cmd); - device->BindConstantBuffer(VS, &constantBuffers[CBTYPE_MISC], CB_GETBINDSLOT(MiscCB), cmd); - - const GPUBuffer* vbs[] = { - &mesh.vertexBuffer_POS, - &mesh.vertexBuffer_ATL, - }; - uint32_t strides[] = { - sizeof(MeshComponent::Vertex_POS), - sizeof(MeshComponent::Vertex_TEX), - }; - uint32_t offsets[] = { - 0, - 0, - }; - device->BindVertexBuffers(vbs, 0, arraysize(vbs), strides, offsets, cmd); - device->BindIndexBuffer(&mesh.indexBuffer, mesh.GetIndexFormat(), 0, cmd); - - RaytracingCB cb; - cb.xTraceResolution.x = desc.Width; - cb.xTraceResolution.y = desc.Height; - cb.xTraceResolution_rcp.x = 1.0f / cb.xTraceResolution.x; - cb.xTraceResolution_rcp.y = 1.0f / cb.xTraceResolution.y; - XMFLOAT4 halton = wiMath::GetHaltonSequence(object.lightmapIterationCount); // for jittering the rasterization (good for eliminating atlas border artifacts) - cb.xTracePixelOffset.x = (halton.x * 2 - 1) * cb.xTraceResolution_rcp.x; - cb.xTracePixelOffset.y = (halton.y * 2 - 1) * cb.xTraceResolution_rcp.y; - cb.xTracePixelOffset.x *= 1.4f; // boost the jitter by a bit - cb.xTracePixelOffset.y *= 1.4f; // boost the jitter by a bit - cb.xTraceAccumulationFactor = 1.0f / (object.lightmapIterationCount + 1.0f); // accumulation factor (alpha) - cb.xTraceUserData.x = raytraceBounceCount; - cb.xTraceSampleIndex = object.lightmapIterationCount; - device->UpdateBuffer(&constantBuffers[CBTYPE_RAYTRACE], &cb, cmd); - device->BindConstantBuffer(VS, &constantBuffers[CBTYPE_RAYTRACE], CB_GETBINDSLOT(RaytracingCB), cmd); - device->BindConstantBuffer(PS, &constantBuffers[CBTYPE_RAYTRACE], CB_GETBINDSLOT(RaytracingCB), cmd); - - device->BindPipelineState(&PSO_renderlightmap, cmd); - - if (scene.weather.skyMap != nullptr) - { - device->BindResource(PS, &scene.weather.skyMap->texture, TEXSLOT_GLOBALENVMAP, cmd); - } - else - { - device->BindResource(PS, &textures[TEXTYPE_2D_SKYATMOSPHERE_SKYVIEWLUT], TEXSLOT_SKYVIEWLUT, cmd); - device->BindResource(PS, &textures[TEXTYPE_2D_SKYATMOSPHERE_TRANSMITTANCELUT], TEXSLOT_TRANSMITTANCELUT, cmd); - device->BindResource(PS, &textures[TEXTYPE_2D_SKYATMOSPHERE_MULTISCATTEREDLUMINANCELUT], TEXSLOT_MULTISCATTERINGLUT, cmd); - } - - device->DrawIndexedInstanced((uint32_t)mesh.indices.size(), 1, 0, 0, 0, cmd); - object.lightmapIterationCount++; - - device->RenderPassEnd(cmd); - - device->EventEnd(cmd); -} -void RefreshLightmapAtlas(const Scene& scene, CommandList cmd) -{ - if (scene.lightmap_refresh_needed.load() || scene.lightmap_repack_needed.load()) + if (scene.lightmap_refresh_needed.load()) { auto range = wiProfiler::BeginRangeGPU("Lightmap Processing", cmd); - if (device->CheckCapability(GRAPHICSDEVICE_CAPABILITY_RAYTRACING_INLINE)) + if (device->CheckCapability(GRAPHICSDEVICE_CAPABILITY_RAYTRACING)) { - device->BindResource(PS, &scene.TLAS, TEXSLOT_ACCELERATION_STRUCTURE, cmd); + device->BindResource(&scene.TLAS, TEXSLOT_ACCELERATION_STRUCTURE, cmd); } else { - scene.BVH.Bind(PS, cmd); + scene.BVH.Bind(cmd); } + BindCommonResources(cmd); + // Render lightmaps for each object: for (uint32_t i = 0; i < scene.objects.GetCount(); ++i) { @@ -8062,17 +7243,76 @@ void RefreshLightmapAtlas(const Scene& scene, CommandList cmd) if (object.IsLightmapRenderRequested()) { - RenderObjectLightMap(scene, object, cmd); - } + device->EventBegin("RenderObjectLightMap", cmd); - if (object.IsLightmapRenderRequested() || scene.lightmap_repack_needed) - { - // copy object' lightmap into scene's lightmap atlas - CopyTexture2D(scene.lightmap, -1, object.lightmap_rect.x + Scene::atlasClampBorder, object.lightmap_rect.y + Scene::atlasClampBorder, object.lightmap, 0, cmd); + const MeshComponent& mesh = *scene.meshes.GetComponent(object.meshID); + assert(!mesh.vertex_atlas.empty()); + assert(mesh.vertexBuffer_ATL.IsValid()); + + const TextureDesc& desc = object.lightmap.GetDesc(); + + if (object.lightmapIterationCount == 0) + { + device->RenderPassBegin(&object.renderpass_lightmap_clear, cmd); + } + else + { + device->RenderPassBegin(&object.renderpass_lightmap_accumulate, cmd); + } + + Viewport vp; + vp.Width = (float)desc.Width; + vp.Height = (float)desc.Height; + device->BindViewports(1, &vp, cmd); + + const TransformComponent& transform = scene.transforms[object.transform_index]; + + MiscCB misccb; + misccb.g_xTransform = transform.world; + + device->BindDynamicConstantBuffer(misccb, CB_GETBINDSLOT(MiscCB), cmd); + + const GPUBuffer* vbs[] = { + &mesh.vertexBuffer_POS, + &mesh.vertexBuffer_ATL, + }; + uint32_t strides[] = { + sizeof(MeshComponent::Vertex_POS), + sizeof(MeshComponent::Vertex_TEX), + }; + uint32_t offsets[] = { + 0, + 0, + }; + device->BindVertexBuffers(vbs, 0, arraysize(vbs), strides, offsets, cmd); + device->BindIndexBuffer(&mesh.indexBuffer, mesh.GetIndexFormat(), 0, cmd); + + RaytracingCB cb; + cb.xTraceResolution.x = desc.Width; + cb.xTraceResolution.y = desc.Height; + cb.xTraceResolution_rcp.x = 1.0f / cb.xTraceResolution.x; + cb.xTraceResolution_rcp.y = 1.0f / cb.xTraceResolution.y; + XMFLOAT4 halton = wiMath::GetHaltonSequence(object.lightmapIterationCount); // for jittering the rasterization (good for eliminating atlas border artifacts) + cb.xTracePixelOffset.x = (halton.x * 2 - 1) * cb.xTraceResolution_rcp.x; + cb.xTracePixelOffset.y = (halton.y * 2 - 1) * cb.xTraceResolution_rcp.y; + cb.xTracePixelOffset.x *= 1.4f; // boost the jitter by a bit + cb.xTracePixelOffset.y *= 1.4f; // boost the jitter by a bit + cb.xTraceAccumulationFactor = 1.0f / (object.lightmapIterationCount + 1.0f); // accumulation factor (alpha) + cb.xTraceUserData.x = raytraceBounceCount; + cb.xTraceSampleIndex = object.lightmapIterationCount; + device->BindDynamicConstantBuffer(cb, CB_GETBINDSLOT(RaytracingCB), cmd); + + device->BindPipelineState(&PSO_renderlightmap, cmd); + + device->DrawIndexedInstanced((uint32_t)mesh.indices.size(), 1, 0, 0, 0, cmd); + object.lightmapIterationCount++; + + device->RenderPassEnd(cmd); + + device->EventEnd(cmd); } } - scene.lightmap_repack_needed.store(false); scene.lightmap_refresh_needed.store(false); wiProfiler::EndRange(range); } @@ -8080,29 +7320,40 @@ void RefreshLightmapAtlas(const Scene& scene, CommandList cmd) void BindCommonResources(CommandList cmd) { - for (int i = 0; i < SHADERSTAGE_COUNT; ++i) - { - SHADERSTAGE stage = (SHADERSTAGE)i; + device->BindConstantBuffer(&constantBuffers[CBTYPE_FRAME], CBSLOT_RENDERER_FRAME, cmd); - device->BindSampler(stage, &samplers[SSLOT_OBJECTSHADER], SSLOT_OBJECTSHADER, cmd); + device->BindSampler(&samplers[SSLOT_OBJECTSHADER], SSLOT_OBJECTSHADER, cmd); - BindConstantBuffers(stage, cmd); + device->BindResource(wiTextureHelper::getRandom64x64(), TEXSLOT_RANDOM64X64, cmd); + device->BindResource(wiTextureHelper::getBlueNoise(), TEXSLOT_BLUENOISE, cmd); - device->BindResource(stage, wiTextureHelper::getRandom64x64(), TEXSLOT_RANDOM64X64, cmd); - device->BindResource(stage, wiTextureHelper::getBlueNoise(), TEXSLOT_BLUENOISE, cmd); - } - - device->BindResource(PS, &textures[TEXTYPE_2D_SHEENLUT], TEXSLOT_SHEENLUT, cmd); - device->BindResource(CS, &textures[TEXTYPE_2D_SHEENLUT], TEXSLOT_SHEENLUT, cmd); + device->BindResource(&textures[TEXTYPE_2D_SHEENLUT], TEXSLOT_SHEENLUT, cmd); // Bind the GPU entity array for all shaders that need it here: GPUResource* resources[] = { &resourceBuffers[RBTYPE_ENTITYARRAY], &resourceBuffers[RBTYPE_MATRIXARRAY], }; - device->BindResources(VS, resources, SBSLOT_ENTITYARRAY, arraysize(resources), cmd); - device->BindResources(PS, resources, SBSLOT_ENTITYARRAY, arraysize(resources), cmd); - device->BindResources(CS, resources, SBSLOT_ENTITYARRAY, arraysize(resources), cmd); + device->BindResources(resources, SBSLOT_ENTITYARRAY, arraysize(resources), cmd); + device->BindResources(resources, SBSLOT_ENTITYARRAY, arraysize(resources), cmd); + device->BindResources(resources, SBSLOT_ENTITYARRAY, arraysize(resources), cmd); + + device->BindResource(&shadowMapArray_2D, TEXSLOT_SHADOWARRAY_2D, cmd); + device->BindResource(&shadowMapArray_Cube, TEXSLOT_SHADOWARRAY_CUBE, cmd); + if (GetTransparentShadowsEnabled()) + { + device->BindResource(&shadowMapArray_Transparent_2D, TEXSLOT_SHADOWARRAY_TRANSPARENT_2D, cmd); + device->BindResource(&shadowMapArray_Transparent_Cube, TEXSLOT_SHADOWARRAY_TRANSPARENT_CUBE, cmd); + } + + // Bind the atmospheric textures, as lighting and sky needs them + device->BindResource(&textures[TEXTYPE_2D_SKYATMOSPHERE_SKYVIEWLUT], TEXSLOT_SKYVIEWLUT, cmd); + device->BindResource(&textures[TEXTYPE_2D_SKYATMOSPHERE_TRANSMITTANCELUT], TEXSLOT_TRANSMITTANCELUT, cmd); + device->BindResource(&textures[TEXTYPE_2D_SKYATMOSPHERE_MULTISCATTEREDLUMINANCELUT], TEXSLOT_MULTISCATTERINGLUT, cmd); + device->BindResource(&textures[TEXTYPE_2D_SKYATMOSPHERE_SKYLUMINANCELUT], TEXSLOT_SKYLUMINANCELUT, cmd); + + device->BindResource(GetVoxelRadianceSecondaryBounceEnabled() ? &textures[TEXTYPE_3D_VOXELRADIANCE_HELPER] : &textures[TEXTYPE_3D_VOXELRADIANCE], TEXSLOT_VOXELGI, cmd); + } void UpdateCameraCB( @@ -8114,45 +7365,45 @@ void UpdateCameraCB( { CameraCB cb; - XMStoreFloat4x4(&cb.g_xCamera_VP, camera.GetViewProjection()); - XMStoreFloat4x4(&cb.g_xCamera_View, camera.GetView()); - XMStoreFloat4x4(&cb.g_xCamera_Proj, camera.GetProjection()); - cb.g_xCamera_CamPos = camera.Eye; - cb.g_xCamera_DistanceFromOrigin = XMVectorGetX(XMVector3Length(XMLoadFloat3(&cb.g_xCamera_CamPos))); - XMStoreFloat4x4(&cb.g_xCamera_InvV, camera.GetInvView()); - XMStoreFloat4x4(&cb.g_xCamera_InvP, camera.GetInvProjection()); - XMStoreFloat4x4(&cb.g_xCamera_InvVP, camera.GetInvViewProjection()); - cb.g_xCamera_At = camera.At; - cb.g_xCamera_Up = camera.Up; - cb.g_xCamera_ZNearP = camera.zNearP; - cb.g_xCamera_ZFarP = camera.zFarP; - cb.g_xCamera_ZNearP_rcp = 1.0f / std::max(0.0001f, cb.g_xCamera_ZNearP); - cb.g_xCamera_ZFarP_rcp = 1.0f / std::max(0.0001f, cb.g_xCamera_ZFarP); - cb.g_xCamera_ZRange = abs(cb.g_xCamera_ZFarP - cb.g_xCamera_ZNearP); - cb.g_xCamera_ZRange_rcp = 1.0f / std::max(0.0001f, cb.g_xCamera_ZRange); - cb.g_xCamera_ClipPlane = camera.clipPlane; + XMStoreFloat4x4(&cb.VP, camera.GetViewProjection()); + XMStoreFloat4x4(&cb.View, camera.GetView()); + XMStoreFloat4x4(&cb.Proj, camera.GetProjection()); + cb.CamPos = camera.Eye; + cb.DistanceFromOrigin = XMVectorGetX(XMVector3Length(XMLoadFloat3(&cb.CamPos))); + XMStoreFloat4x4(&cb.InvV, camera.GetInvView()); + XMStoreFloat4x4(&cb.InvP, camera.GetInvProjection()); + XMStoreFloat4x4(&cb.InvVP, camera.GetInvViewProjection()); + cb.At = camera.At; + cb.Up = camera.Up; + cb.ZNearP = camera.zNearP; + cb.ZFarP = camera.zFarP; + cb.ZNearP_rcp = 1.0f / std::max(0.0001f, cb.ZNearP); + cb.ZFarP_rcp = 1.0f / std::max(0.0001f, cb.ZFarP); + cb.ZRange = abs(cb.ZFarP - cb.ZNearP); + cb.ZRange_rcp = 1.0f / std::max(0.0001f, cb.ZRange); + cb.ClipPlane = camera.clipPlane; - static_assert(arraysize(camera.frustum.planes) == arraysize(cb.g_xCamera_FrustumPlanes), "Mismatch!"); + static_assert(arraysize(camera.frustum.planes) == arraysize(cb.FrustumPlanes), "Mismatch!"); for (int i = 0; i < arraysize(camera.frustum.planes); ++i) { - cb.g_xCamera_FrustumPlanes[i] = camera.frustum.planes[i]; + cb.FrustumPlanes[i] = camera.frustum.planes[i]; } - cb.g_xFrame_TemporalAAJitter = camera.jitter; - cb.g_xFrame_TemporalAAJitterPrev = camera_previous.jitter; + cb.TemporalAAJitter = camera.jitter; + cb.TemporalAAJitterPrev = camera_previous.jitter; - XMStoreFloat4x4(&cb.g_xCamera_PrevV, camera_previous.GetView()); - XMStoreFloat4x4(&cb.g_xCamera_PrevP, camera_previous.GetProjection()); - XMStoreFloat4x4(&cb.g_xCamera_PrevVP, camera_previous.GetViewProjection()); - XMStoreFloat4x4(&cb.g_xCamera_PrevInvVP, camera_previous.GetInvViewProjection()); - XMStoreFloat4x4(&cb.g_xCamera_ReflVP, camera_reflection.GetViewProjection()); - XMStoreFloat4x4(&cb.g_xCamera_Reprojection, camera.GetInvViewProjection() * camera_previous.GetViewProjection()); + XMStoreFloat4x4(&cb.PrevV, camera_previous.GetView()); + XMStoreFloat4x4(&cb.PrevP, camera_previous.GetProjection()); + XMStoreFloat4x4(&cb.PrevVP, camera_previous.GetViewProjection()); + XMStoreFloat4x4(&cb.PrevInvVP, camera_previous.GetInvViewProjection()); + XMStoreFloat4x4(&cb.ReflVP, camera_reflection.GetViewProjection()); + XMStoreFloat4x4(&cb.Reprojection, camera.GetInvViewProjection() * camera_previous.GetViewProjection()); - cb.g_xCamera_FocalLength = camera.focal_length; - cb.g_xCamera_ApertureSize = camera.aperture_size; - cb.g_xCamera_ApertureShape = camera.aperture_shape; + cb.FocalLength = camera.focal_length; + cb.ApertureSize = camera.aperture_size; + cb.ApertureShape = camera.aperture_shape; - device->UpdateBuffer(&constantBuffers[CBTYPE_CAMERA], &cb, cmd); + device->BindDynamicConstantBuffer(cb, CBSLOT_RENDERER_CAMERA, cmd); } void CreateLuminanceResources(LuminanceResources& res, XMUINT2 resolution) @@ -8180,18 +7431,17 @@ const Texture* ComputeLuminance( PostProcessCB cb; cb.luminance_adaptionrate = adaption_rate; - device->UpdateBuffer(&constantBuffers[CBTYPE_POSTPROCESS], &cb, cmd); - device->BindConstantBuffer(CS, &constantBuffers[CBTYPE_POSTPROCESS], CB_GETBINDSLOT(PostProcessCB), cmd); + device->BindDynamicConstantBuffer(cb, CB_GETBINDSLOT(PostProcessCB), cmd); // Pass 1 : Compute log luminance and reduction { device->BindComputeShader(&shaders[CSTYPE_LUMINANCE_PASS1], cmd); - device->BindResource(CS, &sourceImage, TEXSLOT_ONDEMAND0, cmd); - device->BindUAV(CS, &res.reductiontex, 0, cmd); + device->BindResource(&sourceImage, TEXSLOT_ONDEMAND0, cmd); + device->BindUAV(&res.reductiontex, 0, cmd); { GPUBarrier barriers[] = { - GPUBarrier::Image(&res.reductiontex, res.reductiontex.desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS), + GPUBarrier::Image(&res.reductiontex, res.reductiontex.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS), }; device->Barrier(barriers, arraysize(barriers), cmd); } @@ -8201,7 +7451,7 @@ const Texture* ComputeLuminance( { GPUBarrier barriers[] = { GPUBarrier::Memory(), - GPUBarrier::Image(&res.reductiontex, IMAGE_LAYOUT_UNORDERED_ACCESS, res.reductiontex.desc.layout), + GPUBarrier::Image(&res.reductiontex, RESOURCE_STATE_UNORDERED_ACCESS, res.reductiontex.desc.layout), }; device->Barrier(barriers, arraysize(barriers), cmd); } @@ -8211,12 +7461,12 @@ const Texture* ComputeLuminance( { device->BindComputeShader(&shaders[CSTYPE_LUMINANCE_PASS2], cmd); - device->BindUAV(CS, &res.luminance, 0, cmd); - device->BindResource(CS, &res.reductiontex, TEXSLOT_ONDEMAND0, cmd); + device->BindUAV(&res.luminance, 0, cmd); + device->BindResource(&res.reductiontex, TEXSLOT_ONDEMAND0, cmd); { GPUBarrier barriers[] = { - GPUBarrier::Image(&res.luminance, res.luminance.desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS), + GPUBarrier::Image(&res.luminance, res.luminance.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS), }; device->Barrier(barriers, arraysize(barriers), cmd); } @@ -8226,12 +7476,11 @@ const Texture* ComputeLuminance( { GPUBarrier barriers[] = { GPUBarrier::Memory(), - GPUBarrier::Image(&res.luminance, IMAGE_LAYOUT_UNORDERED_ACCESS, res.luminance.desc.layout), + GPUBarrier::Image(&res.luminance, RESOURCE_STATE_UNORDERED_ACCESS, res.luminance.desc.layout), }; device->Barrier(barriers, arraysize(barriers), cmd); } - device->UnbindUAVs(0, 1, cmd); } wiProfiler::EndRange(range); @@ -8253,11 +7502,11 @@ void ComputeShadingRateClassification( if (GetVariableRateShadingClassificationDebug()) { - device->BindUAV(CS, &debugUAV, 1, cmd); + device->BindUAV(&debugUAV, 1, cmd); { GPUBarrier barriers[] = { - GPUBarrier::Image(&debugUAV, debugUAV.desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS), + GPUBarrier::Image(&debugUAV, debugUAV.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS), }; device->Barrier(barriers, arraysize(barriers), cmd); } @@ -8269,8 +7518,8 @@ void ComputeShadingRateClassification( device->BindComputeShader(&shaders[CSTYPE_SHADINGRATECLASSIFICATION], cmd); } - device->BindResource(CS, &gbuffer[GBUFFER_VELOCITY], TEXSLOT_GBUFFER2, cmd); - device->BindResource(CS, &lineardepth, TEXSLOT_LINEARDEPTH, cmd); + device->BindResource(&gbuffer[GBUFFER_VELOCITY], TEXSLOT_GBUFFER1, cmd); + device->BindResource(&lineardepth, TEXSLOT_LINEARDEPTH, cmd); const TextureDesc& desc = output.GetDesc(); @@ -8283,17 +7532,16 @@ void ComputeShadingRateClassification( device->WriteShadingRateValue(SHADING_RATE_2X4, &cb.SHADING_RATE_2X4); device->WriteShadingRateValue(SHADING_RATE_4X2, &cb.SHADING_RATE_4X2); device->WriteShadingRateValue(SHADING_RATE_4X4, &cb.SHADING_RATE_4X4); - device->UpdateBuffer(&constantBuffers[CBTYPE_SHADINGRATECLASSIFICATION], &cb, cmd); - device->BindConstantBuffer(CS, &constantBuffers[CBTYPE_SHADINGRATECLASSIFICATION], CB_GETBINDSLOT(PostProcessCB), cmd); + device->BindDynamicConstantBuffer(cb, CB_GETBINDSLOT(PostProcessCB), cmd); const GPUResource* uavs[] = { &output, }; - device->BindUAVs(CS, uavs, 0, arraysize(uavs), cmd); + device->BindUAVs(uavs, 0, arraysize(uavs), cmd); { GPUBarrier barriers[] = { - GPUBarrier::Image(&output, output.desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS), + GPUBarrier::Image(&output, output.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS), }; device->Barrier(barriers, arraysize(barriers), cmd); } @@ -8304,7 +7552,7 @@ void ComputeShadingRateClassification( { GPUBarrier barriers[] = { GPUBarrier::Memory(), - GPUBarrier::Image(&output, IMAGE_LAYOUT_UNORDERED_ACCESS, output.desc.layout), + GPUBarrier::Image(&output, RESOURCE_STATE_UNORDERED_ACCESS, output.desc.layout), }; device->Barrier(barriers, arraysize(barriers), cmd); } @@ -8313,18 +7561,430 @@ void ComputeShadingRateClassification( { { GPUBarrier barriers[] = { - GPUBarrier::Image(&debugUAV, IMAGE_LAYOUT_UNORDERED_ACCESS, debugUAV.desc.layout), + GPUBarrier::Image(&debugUAV, RESOURCE_STATE_UNORDERED_ACCESS, debugUAV.desc.layout), }; device->Barrier(barriers, arraysize(barriers), cmd); } } - device->UnbindUAVs(0, arraysize(uavs), cmd); wiProfiler::EndRange(range); device->EventEnd(cmd); } +void VisibilityResolve( + const Texture& depthbuffer, + const Texture& texture_primitiveID, // can be MSAA + const Texture gbuffer[GBUFFER_COUNT], + const Texture& depthbuffer_resolved, + const Texture& lineardepth, + CommandList cmd +) +{ + device->EventBegin("VisibilityResolve", cmd); + auto range = wiProfiler::BeginRangeGPU("VisibilityResolve", cmd); + + BindCommonResources(cmd); + + const bool msaa = texture_primitiveID.desc.SampleCount > 1; + + device->BindComputeShader(&shaders[msaa ? CSTYPE_VISIBILITY_RESOLVE_MSAA : CSTYPE_VISIBILITY_RESOLVE], cmd); + + + device->BindResource(&texture_primitiveID, TEXSLOT_ONDEMAND0, cmd); + device->BindResource(&depthbuffer, TEXSLOT_ONDEMAND1, cmd); + + device->BindUAV(&gbuffer[GBUFFER_VELOCITY], 0, cmd); + device->BindUAV(&depthbuffer_resolved, 1, cmd, 0); + device->BindUAV(&depthbuffer_resolved, 2, cmd, 1); + device->BindUAV(&depthbuffer_resolved, 3, cmd, 2); + device->BindUAV(&depthbuffer_resolved, 4, cmd, 3); + device->BindUAV(&depthbuffer_resolved, 5, cmd, 4); + device->BindUAV(&lineardepth, 6, cmd, 0); + device->BindUAV(&lineardepth, 7, cmd, 1); + device->BindUAV(&lineardepth, 8, cmd, 2); + device->BindUAV(&lineardepth, 9, cmd, 3); + device->BindUAV(&lineardepth, 10, cmd, 4); + + { + GPUBarrier barriers[] = { + GPUBarrier::Image(&gbuffer[GBUFFER_VELOCITY], gbuffer[GBUFFER_VELOCITY].desc.layout, RESOURCE_STATE_UNORDERED_ACCESS), + GPUBarrier::Image(&depthbuffer_resolved, depthbuffer_resolved.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS), + GPUBarrier::Image(&lineardepth, lineardepth.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS), + }; + device->Barrier(barriers, arraysize(barriers), cmd); + } + + if (msaa) + { + device->BindUAV(&gbuffer[GBUFFER_PRIMITIVEID], 11, cmd); + { + GPUBarrier barriers[] = { + GPUBarrier::Image(&gbuffer[GBUFFER_PRIMITIVEID], gbuffer[GBUFFER_PRIMITIVEID].desc.layout, RESOURCE_STATE_UNORDERED_ACCESS), + }; + device->Barrier(barriers, arraysize(barriers), cmd); + } + } + + device->Dispatch( + (depthbuffer.desc.Width + 15) / 16, + (depthbuffer.desc.Height + 15) / 16, + 1, + cmd + ); + + { + GPUBarrier barriers[] = { + GPUBarrier::Memory(), + GPUBarrier::Image(&gbuffer[GBUFFER_VELOCITY], RESOURCE_STATE_UNORDERED_ACCESS, gbuffer[GBUFFER_VELOCITY].desc.layout), + GPUBarrier::Image(&depthbuffer_resolved, RESOURCE_STATE_UNORDERED_ACCESS, depthbuffer_resolved.desc.layout), + GPUBarrier::Image(&lineardepth, RESOURCE_STATE_UNORDERED_ACCESS, lineardepth.desc.layout), + }; + device->Barrier(barriers, arraysize(barriers), cmd); + } + + if (msaa) + { + { + GPUBarrier barriers[] = { + GPUBarrier::Image(&gbuffer[GBUFFER_PRIMITIVEID], RESOURCE_STATE_UNORDERED_ACCESS, gbuffer[GBUFFER_PRIMITIVEID].desc.layout), + }; + device->Barrier(barriers, arraysize(barriers), cmd); + } + } + + + wiProfiler::EndRange(range); + device->EventEnd(cmd); +} + +void CreateSurfelGIResources(SurfelGIResources& res, XMUINT2 resolution) +{ + TextureDesc desc; + desc.Width = resolution.x; + desc.Height = resolution.y; + desc.Format = FORMAT_R11G11B10_FLOAT; + desc.BindFlags = BIND_SHADER_RESOURCE | BIND_UNORDERED_ACCESS; + desc.layout = RESOURCE_STATE_SHADER_RESOURCE_COMPUTE; + device->CreateTexture(&desc, nullptr, &res.result); + device->SetName(&res.result, "surfelGI.result"); +} +void SurfelGI_Coverage( + const SurfelGIResources& res, + const Scene& scene, + const Texture& depthbuffer, + const Texture gbuffer[GBUFFER_COUNT], + const Texture& debugUAV, + CommandList cmd +) +{ + device->EventBegin("SurfelGI - Coverage", cmd); + auto prof_range = wiProfiler::BeginRangeGPU("SurfelGI - Coverage", cmd); + + + // Coverage: + { + device->EventBegin("Coverage", cmd); + device->BindComputeShader(&shaders[CSTYPE_SURFEL_COVERAGE], cmd); + + device->BindResource(&depthbuffer, TEXSLOT_DEPTH, cmd); + device->BindResource(&gbuffer[GBUFFER_PRIMITIVEID], TEXSLOT_GBUFFER0, cmd); + device->BindResource(&gbuffer[GBUFFER_VELOCITY], TEXSLOT_GBUFFER1, cmd); + + device->BindResource(&scene.surfelBuffer, TEXSLOT_ONDEMAND0, cmd); + device->BindResource(&scene.surfelStatsBuffer, TEXSLOT_ONDEMAND1, cmd); + device->BindResource(&scene.surfelGridBuffer, TEXSLOT_ONDEMAND2, cmd); + device->BindResource(&scene.surfelCellBuffer, TEXSLOT_ONDEMAND3, cmd); + device->BindResource(&scene.surfelMomentsTexture, TEXSLOT_ONDEMAND4, cmd); + + const GPUResource* uavs[] = { + &scene.surfelDataBuffer, + &scene.surfelStatsBuffer, + &res.result, + &debugUAV + }; + device->BindUAVs(uavs, 0, arraysize(uavs), cmd); + + { + GPUBarrier barriers[] = { + GPUBarrier::Buffer(&scene.surfelStatsBuffer, RESOURCE_STATE_INDIRECT_ARGUMENT, RESOURCE_STATE_UNORDERED_ACCESS), + GPUBarrier::Image(&res.result, res.result.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS), + GPUBarrier::Image(&debugUAV, debugUAV.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS), + }; + device->Barrier(barriers, arraysize(barriers), cmd); + } + +#ifdef SURFEL_COVERAGE_HALFRES + device->Dispatch( + (res.result.desc.Width / 2 + 15) / 16, + (res.result.desc.Height / 2 + 15) / 16, + 1, + cmd + ); +#else + device->Dispatch( + (res.result.desc.Width + 15) / 16, + (res.result.desc.Height + 15) / 16, + 1, + cmd + ); +#endif // SURFEL_COVERAGE_HALFRES + + { + GPUBarrier barriers[] = { + GPUBarrier::Memory(), + GPUBarrier::Image(&res.result, RESOURCE_STATE_UNORDERED_ACCESS, res.result.desc.layout), + GPUBarrier::Image(&debugUAV, RESOURCE_STATE_UNORDERED_ACCESS, debugUAV.desc.layout), + }; + device->Barrier(barriers, arraysize(barriers), cmd); + } + + device->EventEnd(cmd); + } + + // surfel count -> indirect args (for next frame): + { + device->EventBegin("Indirect args", cmd); + const GPUResource* uavs[] = { + &scene.surfelStatsBuffer, + }; + device->BindUAVs(uavs, 0, arraysize(uavs), cmd); + + device->BindComputeShader(&shaders[CSTYPE_SURFEL_INDIRECTPREPARE], cmd); + device->Dispatch(1, 1, 1, cmd); + + device->EventEnd(cmd); + } + + + wiProfiler::EndRange(prof_range); + device->EventEnd(cmd); +} +void SurfelGI( + const SurfelGIResources& res, + const wiScene::Scene& scene, + wiGraphics::CommandList cmd +) +{ + auto prof_range = wiProfiler::BeginRangeGPU("SurfelGI", cmd); + device->EventBegin("SurfelGI", cmd); + + BindCommonResources(cmd); + + + // Grid reset: + { + device->EventBegin("Grid Reset", cmd); + device->BindComputeShader(&shaders[CSTYPE_SURFEL_GRIDRESET], cmd); + + const GPUResource* uavs[] = { + &scene.surfelGridBuffer, + }; + device->BindUAVs(uavs, 0, arraysize(uavs), cmd); + + { + GPUBarrier barriers[] = { + GPUBarrier::Buffer(&scene.surfelGridBuffer, RESOURCE_STATE_SHADER_RESOURCE_COMPUTE, RESOURCE_STATE_UNORDERED_ACCESS), + }; + device->Barrier(barriers, arraysize(barriers), cmd); + } + + device->Dispatch( + (SURFEL_TABLE_SIZE + 63) / 64, + 1, + 1, + cmd + ); + + device->EventEnd(cmd); + } + + // Update: + { + device->EventBegin("Update", cmd); + device->BindComputeShader(&shaders[CSTYPE_SURFEL_UPDATE], cmd); + + device->BindResource(&scene.surfelStatsBuffer, TEXSLOT_ONDEMAND0, cmd); + device->BindResource(&scene.surfelDataBuffer, TEXSLOT_ONDEMAND1, cmd); + + const GPUResource* uavs[] = { + &scene.surfelBuffer, + &scene.surfelGridBuffer, + }; + device->BindUAVs(uavs, 0, arraysize(uavs), cmd); + + { + GPUBarrier barriers[] = { + GPUBarrier::Buffer(&scene.surfelBuffer, RESOURCE_STATE_SHADER_RESOURCE_COMPUTE, RESOURCE_STATE_UNORDERED_ACCESS), + }; + device->Barrier(barriers, arraysize(barriers), cmd); + } + + device->DispatchIndirect(&scene.surfelStatsBuffer, SURFEL_STATS_OFFSET_INDIRECT, cmd); + + { + GPUBarrier barriers[] = { + GPUBarrier::Memory(), + GPUBarrier::Buffer(&scene.surfelBuffer, RESOURCE_STATE_UNORDERED_ACCESS, RESOURCE_STATE_SHADER_RESOURCE_COMPUTE), + }; + device->Barrier(barriers, arraysize(barriers), cmd); + } + + device->EventEnd(cmd); + } + + // Grid offsets: + { + device->EventBegin("Grid Offsets", cmd); + device->BindComputeShader(&shaders[CSTYPE_SURFEL_GRIDOFFSETS], cmd); + + const GPUResource* uavs[] = { + &scene.surfelGridBuffer, + &scene.surfelCellBuffer, + &scene.surfelStatsBuffer, + }; + device->BindUAVs(uavs, 0, arraysize(uavs), cmd); + + { + GPUBarrier barriers[] = { + GPUBarrier::Buffer(&scene.surfelCellBuffer, RESOURCE_STATE_SHADER_RESOURCE_COMPUTE, RESOURCE_STATE_UNORDERED_ACCESS), + GPUBarrier::Buffer(&scene.surfelStatsBuffer, RESOURCE_STATE_INDIRECT_ARGUMENT, RESOURCE_STATE_UNORDERED_ACCESS), + }; + device->Barrier(barriers, arraysize(barriers), cmd); + } + + device->Dispatch( + (SURFEL_TABLE_SIZE + 63) / 64, + 1, + 1, + cmd + ); + + { + GPUBarrier barriers[] = { + GPUBarrier::Memory(), + GPUBarrier::Buffer(&scene.surfelStatsBuffer, RESOURCE_STATE_UNORDERED_ACCESS, RESOURCE_STATE_INDIRECT_ARGUMENT), + }; + device->Barrier(barriers, arraysize(barriers), cmd); + } + + device->EventEnd(cmd); + } + + // Binning: + { + device->EventBegin("Binning", cmd); + device->BindComputeShader(&shaders[CSTYPE_SURFEL_BINNING], cmd); + + device->BindResource(&scene.surfelBuffer, TEXSLOT_ONDEMAND0, cmd); + device->BindResource(&scene.surfelStatsBuffer, TEXSLOT_ONDEMAND1, cmd); + + const GPUResource* uavs[] = { + &scene.surfelGridBuffer, + &scene.surfelCellBuffer, + }; + device->BindUAVs(uavs, 0, arraysize(uavs), cmd); + + device->DispatchIndirect(&scene.surfelStatsBuffer, SURFEL_STATS_OFFSET_INDIRECT, cmd); + + { + GPUBarrier barriers[] = { + GPUBarrier::Memory(), + GPUBarrier::Buffer(&scene.surfelGridBuffer, RESOURCE_STATE_UNORDERED_ACCESS, RESOURCE_STATE_SHADER_RESOURCE_COMPUTE), + GPUBarrier::Buffer(&scene.surfelCellBuffer, RESOURCE_STATE_UNORDERED_ACCESS, RESOURCE_STATE_SHADER_RESOURCE_COMPUTE), + }; + device->Barrier(barriers, arraysize(barriers), cmd); + } + + device->EventEnd(cmd); + } + + + + // Raytracing: + { + device->EventBegin("Raytrace", cmd); + if (device->CheckCapability(GRAPHICSDEVICE_CAPABILITY_RAYTRACING)) + { + if (!scene.TLAS.IsValid()) + { + return; + } + device->BindResource(&scene.TLAS, TEXSLOT_ACCELERATION_STRUCTURE, cmd); + } + else + { + scene.BVH.Bind(cmd); + } + + device->BindComputeShader(&shaders[CSTYPE_SURFEL_RAYTRACE], cmd); + + device->BindResource(&scene.surfelBuffer, TEXSLOT_ONDEMAND0, cmd); + device->BindResource(&scene.surfelStatsBuffer, TEXSLOT_ONDEMAND1, cmd); + device->BindResource(&scene.surfelGridBuffer, TEXSLOT_ONDEMAND2, cmd); + device->BindResource(&scene.surfelCellBuffer, TEXSLOT_ONDEMAND3, cmd); + + const GPUResource* uavs[] = { + &scene.surfelDataBuffer, + &scene.surfelMomentsTexture, + }; + device->BindUAVs(uavs, 0, arraysize(uavs), cmd); + + { + GPUBarrier barriers[] = { + GPUBarrier::Buffer(&scene.surfelDataBuffer, RESOURCE_STATE_SHADER_RESOURCE_COMPUTE, RESOURCE_STATE_UNORDERED_ACCESS), + GPUBarrier::Image(&scene.surfelMomentsTexture, RESOURCE_STATE_SHADER_RESOURCE_COMPUTE, RESOURCE_STATE_UNORDERED_ACCESS), + }; + device->Barrier(barriers, arraysize(barriers), cmd); + } + + device->DispatchIndirect(&scene.surfelStatsBuffer, SURFEL_STATS_OFFSET_INDIRECT, cmd); + + { + GPUBarrier barriers[] = { + GPUBarrier::Memory(), + GPUBarrier::Image(&scene.surfelMomentsTexture, RESOURCE_STATE_UNORDERED_ACCESS, RESOURCE_STATE_SHADER_RESOURCE_COMPUTE), + }; + device->Barrier(barriers, arraysize(barriers), cmd); + } + + device->EventEnd(cmd); + } + + // Shading: + { + device->EventBegin("Shade", cmd); + + device->BindComputeShader(&shaders[CSTYPE_SURFEL_SHADE], cmd); + + device->BindResource(&scene.surfelBuffer, TEXSLOT_ONDEMAND0, cmd); + device->BindResource(&scene.surfelStatsBuffer, TEXSLOT_ONDEMAND1, cmd); + device->BindResource(&scene.surfelGridBuffer, TEXSLOT_ONDEMAND2, cmd); + device->BindResource(&scene.surfelCellBuffer, TEXSLOT_ONDEMAND3, cmd); + device->BindResource(&scene.surfelMomentsTexture, TEXSLOT_ONDEMAND4, cmd); + + const GPUResource* uavs[] = { + &scene.surfelDataBuffer, + }; + device->BindUAVs(uavs, 0, arraysize(uavs), cmd); + + device->DispatchIndirect(&scene.surfelStatsBuffer, SURFEL_STATS_OFFSET_INDIRECT, cmd); + + { + GPUBarrier barriers[] = { + GPUBarrier::Memory(), + GPUBarrier::Buffer(&scene.surfelDataBuffer, RESOURCE_STATE_UNORDERED_ACCESS, RESOURCE_STATE_SHADER_RESOURCE_COMPUTE), + }; + device->Barrier(barriers, arraysize(barriers), cmd); + } + + device->EventEnd(cmd); + } + + wiProfiler::EndRange(prof_range); + device->EventEnd(cmd); +} + void Postprocess_Blur_Gaussian( const Texture& input, const Texture& temp, @@ -8366,7 +8026,6 @@ void Postprocess_Blur_Gaussian( break; } device->BindComputeShader(&shaders[cs], cmd); - device->BindConstantBuffer(CS, &constantBuffers[CBTYPE_POSTPROCESS], CB_GETBINDSLOT(PostProcessCB), cmd); // Horizontal: { @@ -8384,14 +8043,14 @@ void Postprocess_Blur_Gaussian( cb.xPPResolution_rcp.y = 1.0f / cb.xPPResolution.y; cb.xPPParams0.x = 1; cb.xPPParams0.y = 0; - device->UpdateBuffer(&constantBuffers[CBTYPE_POSTPROCESS], &cb, cmd); + device->BindDynamicConstantBuffer(cb, CB_GETBINDSLOT(PostProcessCB), cmd); - device->BindResource(CS, &input, TEXSLOT_ONDEMAND0, cmd, mip_src); - device->BindUAV(CS, &temp, 0, cmd, mip_dst); + device->BindResource(&input, TEXSLOT_ONDEMAND0, cmd, mip_src); + device->BindUAV(&temp, 0, cmd, mip_dst); { GPUBarrier barriers[] = { - GPUBarrier::Image(&temp, temp.desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS, mip_dst), + GPUBarrier::Image(&temp, temp.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS, mip_dst), }; device->Barrier(barriers, arraysize(barriers), cmd); } @@ -8406,12 +8065,11 @@ void Postprocess_Blur_Gaussian( { GPUBarrier barriers[] = { GPUBarrier::Memory(), - GPUBarrier::Image(&temp, IMAGE_LAYOUT_UNORDERED_ACCESS, temp.desc.layout, mip_dst), + GPUBarrier::Image(&temp, RESOURCE_STATE_UNORDERED_ACCESS, temp.desc.layout, mip_dst), }; device->Barrier(barriers, arraysize(barriers), cmd); } - device->UnbindUAVs(0, 1, cmd); } // Vertical: @@ -8430,14 +8088,14 @@ void Postprocess_Blur_Gaussian( cb.xPPResolution_rcp.y = 1.0f / cb.xPPResolution.y; cb.xPPParams0.x = 0; cb.xPPParams0.y = 1; - device->UpdateBuffer(&constantBuffers[CBTYPE_POSTPROCESS], &cb, cmd); + device->BindDynamicConstantBuffer(cb, CB_GETBINDSLOT(PostProcessCB), cmd); - device->BindResource(CS, &temp, TEXSLOT_ONDEMAND0, cmd, mip_dst); // <- also mip_dst because it's second pass! - device->BindUAV(CS, &output, 0, cmd, mip_dst); + device->BindResource(&temp, TEXSLOT_ONDEMAND0, cmd, mip_dst); // <- also mip_dst because it's second pass! + device->BindUAV(&output, 0, cmd, mip_dst); { GPUBarrier barriers[] = { - GPUBarrier::Image(&output, output.desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS, mip_dst), + GPUBarrier::Image(&output, output.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS, mip_dst), }; device->Barrier(barriers, arraysize(barriers), cmd); } @@ -8452,12 +8110,11 @@ void Postprocess_Blur_Gaussian( { GPUBarrier barriers[] = { GPUBarrier::Memory(), - GPUBarrier::Image(&output, IMAGE_LAYOUT_UNORDERED_ACCESS, output.desc.layout, mip_dst), + GPUBarrier::Image(&output, RESOURCE_STATE_UNORDERED_ACCESS, output.desc.layout, mip_dst), }; device->Barrier(barriers, arraysize(barriers), cmd); } - device->UnbindUAVs(0, 1, cmd); } device->EventEnd(cmd); @@ -8505,9 +8162,8 @@ void Postprocess_Blur_Bilateral( break; } device->BindComputeShader(&shaders[cs], cmd); - device->BindConstantBuffer(CS, &constantBuffers[CBTYPE_POSTPROCESS], CB_GETBINDSLOT(PostProcessCB), cmd); - device->BindResource(CS, &lineardepth, TEXSLOT_LINEARDEPTH, cmd); + device->BindResource(&lineardepth, TEXSLOT_LINEARDEPTH, cmd); // Horizontal: { @@ -8526,14 +8182,14 @@ void Postprocess_Blur_Bilateral( cb.xPPParams0.x = 1; cb.xPPParams0.y = 0; cb.xPPParams0.w = depth_threshold; - device->UpdateBuffer(&constantBuffers[CBTYPE_POSTPROCESS], &cb, cmd); + device->BindDynamicConstantBuffer(cb, CB_GETBINDSLOT(PostProcessCB), cmd); - device->BindResource(CS, &input, TEXSLOT_ONDEMAND0, cmd, mip_src); - device->BindUAV(CS, &temp, 0, cmd, mip_dst); + device->BindResource(&input, TEXSLOT_ONDEMAND0, cmd, mip_src); + device->BindUAV(&temp, 0, cmd, mip_dst); { GPUBarrier barriers[] = { - GPUBarrier::Image(&temp, temp.desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS, mip_dst), + GPUBarrier::Image(&temp, temp.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS, mip_dst), }; device->Barrier(barriers, arraysize(barriers), cmd); } @@ -8548,12 +8204,11 @@ void Postprocess_Blur_Bilateral( { GPUBarrier barriers[] = { GPUBarrier::Memory(), - GPUBarrier::Image(&temp, IMAGE_LAYOUT_UNORDERED_ACCESS, temp.desc.layout, mip_dst), + GPUBarrier::Image(&temp, RESOURCE_STATE_UNORDERED_ACCESS, temp.desc.layout, mip_dst), }; device->Barrier(barriers, arraysize(barriers), cmd); } - device->UnbindUAVs(0, 1, cmd); } // Vertical: @@ -8573,14 +8228,14 @@ void Postprocess_Blur_Bilateral( cb.xPPParams0.x = 0; cb.xPPParams0.y = 1; cb.xPPParams0.w = depth_threshold; - device->UpdateBuffer(&constantBuffers[CBTYPE_POSTPROCESS], &cb, cmd); + device->BindDynamicConstantBuffer(cb, CB_GETBINDSLOT(PostProcessCB), cmd); - device->BindResource(CS, &temp, TEXSLOT_ONDEMAND0, cmd, mip_dst); // <- also mip_dst because it's second pass! - device->BindUAV(CS, &output, 0, cmd, mip_dst); + device->BindResource(&temp, TEXSLOT_ONDEMAND0, cmd, mip_dst); // <- also mip_dst because it's second pass! + device->BindUAV(&output, 0, cmd, mip_dst); { GPUBarrier barriers[] = { - GPUBarrier::Image(&output, output.desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS, mip_dst), + GPUBarrier::Image(&output, output.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS, mip_dst), }; device->Barrier(barriers, arraysize(barriers), cmd); } @@ -8595,12 +8250,11 @@ void Postprocess_Blur_Bilateral( { GPUBarrier barriers[] = { GPUBarrier::Memory(), - GPUBarrier::Image(&output, IMAGE_LAYOUT_UNORDERED_ACCESS, output.desc.layout, mip_dst), + GPUBarrier::Image(&output, RESOURCE_STATE_UNORDERED_ACCESS, output.desc.layout, mip_dst), }; device->Barrier(barriers, arraysize(barriers), cmd); } - device->UnbindUAVs(0, 1, cmd); } device->EventEnd(cmd); @@ -8612,7 +8266,7 @@ void CreateSSAOResources(SSAOResources& res, XMUINT2 resolution) desc.Width = resolution.x / 2; desc.Height = resolution.y / 2; desc.BindFlags = BIND_UNORDERED_ACCESS | BIND_SHADER_RESOURCE; - desc.layout = IMAGE_LAYOUT_SHADER_RESOURCE_COMPUTE; + desc.layout = RESOURCE_STATE_SHADER_RESOURCE_COMPUTE; device->CreateTexture(&desc, nullptr, &res.temp); } void Postprocess_SSAO( @@ -8631,8 +8285,8 @@ void Postprocess_SSAO( device->BindComputeShader(&shaders[CSTYPE_POSTPROCESS_SSAO], cmd); - device->BindResource(CS, &depthbuffer, TEXSLOT_DEPTH, cmd); - device->BindResource(CS, &lineardepth, TEXSLOT_LINEARDEPTH, cmd); + device->BindResource(&depthbuffer, TEXSLOT_DEPTH, cmd); + device->BindResource(&lineardepth, TEXSLOT_LINEARDEPTH, cmd); const TextureDesc& desc = output.GetDesc(); @@ -8644,17 +8298,16 @@ void Postprocess_SSAO( cb.ssao_range = range; cb.ssao_samplecount = (float)samplecount; cb.ssao_power = power; - device->UpdateBuffer(&constantBuffers[CBTYPE_POSTPROCESS], &cb, cmd); - device->BindConstantBuffer(CS, &constantBuffers[CBTYPE_POSTPROCESS], CB_GETBINDSLOT(PostProcessCB), cmd); + device->BindDynamicConstantBuffer(cb, CB_GETBINDSLOT(PostProcessCB), cmd); const GPUResource* uavs[] = { &output, }; - device->BindUAVs(CS, uavs, 0, arraysize(uavs), cmd); + device->BindUAVs(uavs, 0, arraysize(uavs), cmd); { GPUBarrier barriers[] = { - GPUBarrier::Image(&output, output.desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS), + GPUBarrier::Image(&output, output.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS), }; device->Barrier(barriers, arraysize(barriers), cmd); } @@ -8669,12 +8322,11 @@ void Postprocess_SSAO( { GPUBarrier barriers[] = { GPUBarrier::Memory(), - GPUBarrier::Image(&output, IMAGE_LAYOUT_UNORDERED_ACCESS, output.desc.layout), + GPUBarrier::Image(&output, RESOURCE_STATE_UNORDERED_ACCESS, output.desc.layout), }; device->Barrier(barriers, arraysize(barriers), cmd); } - device->UnbindUAVs(0, arraysize(uavs), cmd); Postprocess_Blur_Bilateral(output, lineardepth, res.temp, output, cmd, 1.2f, -1, -1, true); @@ -8695,7 +8347,7 @@ void Postprocess_HBAO( device->BindComputeShader(&shaders[CSTYPE_POSTPROCESS_HBAO], cmd); - device->BindResource(CS, &lineardepth, TEXSLOT_LINEARDEPTH, cmd); + device->BindResource(&lineardepth, TEXSLOT_LINEARDEPTH, cmd); const TextureDesc& desc = output.GetDesc(); @@ -8723,20 +8375,19 @@ void Postprocess_HBAO( cb.xPPParams1.z = UVToViewBX; cb.xPPParams1.w = UVToViewBY; - device->UpdateBuffer(&constantBuffers[CBTYPE_POSTPROCESS], &cb, cmd); - device->BindConstantBuffer(CS, &constantBuffers[CBTYPE_POSTPROCESS], CB_GETBINDSLOT(PostProcessCB), cmd); + device->BindDynamicConstantBuffer(cb, CB_GETBINDSLOT(PostProcessCB), cmd); // horizontal pass: { - device->BindResource(CS, wiTextureHelper::getWhite(), TEXSLOT_ONDEMAND0, cmd); + device->BindResource(wiTextureHelper::getWhite(), TEXSLOT_ONDEMAND0, cmd); const GPUResource* uavs[] = { &res.temp, }; - device->BindUAVs(CS, uavs, 0, arraysize(uavs), cmd); + device->BindUAVs(uavs, 0, arraysize(uavs), cmd); { GPUBarrier barriers[] = { - GPUBarrier::Image(&res.temp, res.temp.desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS), + GPUBarrier::Image(&res.temp, res.temp.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS), }; device->Barrier(barriers, arraysize(barriers), cmd); } @@ -8751,30 +8402,28 @@ void Postprocess_HBAO( { GPUBarrier barriers[] = { GPUBarrier::Memory(), - GPUBarrier::Image(&res.temp, IMAGE_LAYOUT_UNORDERED_ACCESS, res.temp.desc.layout), + GPUBarrier::Image(&res.temp, RESOURCE_STATE_UNORDERED_ACCESS, res.temp.desc.layout), }; device->Barrier(barriers, arraysize(barriers), cmd); } - device->UnbindUAVs(0, arraysize(uavs), cmd); } // vertical pass: { cb.xPPParams0.x = 0; cb.xPPParams0.y = 1; - device->UpdateBuffer(&constantBuffers[CBTYPE_POSTPROCESS], &cb, cmd); - device->BindConstantBuffer(CS, &constantBuffers[CBTYPE_POSTPROCESS], CB_GETBINDSLOT(PostProcessCB), cmd); + device->BindDynamicConstantBuffer(cb, CB_GETBINDSLOT(PostProcessCB), cmd); - device->BindResource(CS, &res.temp, TEXSLOT_ONDEMAND0, cmd); + device->BindResource(&res.temp, TEXSLOT_ONDEMAND0, cmd); const GPUResource* uavs[] = { &output, }; - device->BindUAVs(CS, uavs, 0, arraysize(uavs), cmd); + device->BindUAVs(uavs, 0, arraysize(uavs), cmd); { GPUBarrier barriers[] = { - GPUBarrier::Image(&output, output.desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS), + GPUBarrier::Image(&output, output.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS), }; device->Barrier(barriers, arraysize(barriers), cmd); } @@ -8789,13 +8438,11 @@ void Postprocess_HBAO( { GPUBarrier barriers[] = { GPUBarrier::Memory(), - GPUBarrier::Image(&output, IMAGE_LAYOUT_UNORDERED_ACCESS, output.desc.layout), + GPUBarrier::Image(&output, RESOURCE_STATE_UNORDERED_ACCESS, output.desc.layout), }; device->Barrier(barriers, arraysize(barriers), cmd); } - device->UnbindUAVs(0, arraysize(uavs), cmd); - device->UnbindResources(TEXSLOT_ONDEMAND1, 1, cmd); } Postprocess_Blur_Bilateral(output, lineardepth, res.temp, output, cmd, 1.2f, -1, -1, true); @@ -8810,7 +8457,7 @@ void CreateMSAOResources(MSAOResources& res, XMUINT2 resolution) saved_desc.Width = resolution.x; saved_desc.Height = resolution.y; saved_desc.BindFlags = BIND_SHADER_RESOURCE | BIND_UNORDERED_ACCESS; - saved_desc.layout = IMAGE_LAYOUT_SHADER_RESOURCE_COMPUTE; + saved_desc.layout = RESOURCE_STATE_SHADER_RESOURCE_COMPUTE; const uint32_t bufferWidth = saved_desc.Width; const uint32_t bufferWidth1 = (bufferWidth + 1) / 2; @@ -8905,7 +8552,7 @@ void Postprocess_MSAO( { device->BindComputeShader(&shaders[CSTYPE_POSTPROCESS_MSAO_PREPAREDEPTHBUFFERS1], cmd); - device->BindResource(CS, &lineardepth, TEXSLOT_LINEARDEPTH, cmd); + device->BindResource(&lineardepth, TEXSLOT_LINEARDEPTH, cmd); const GPUResource* uavs[] = { &res.texture_lineardepth_downsize1, @@ -8913,14 +8560,14 @@ void Postprocess_MSAO( &res.texture_lineardepth_downsize2, &res.texture_lineardepth_tiled2, }; - device->BindUAVs(CS, uavs, 0, arraysize(uavs), cmd); + device->BindUAVs(uavs, 0, arraysize(uavs), cmd); { GPUBarrier barriers[] = { - GPUBarrier::Image(&res.texture_lineardepth_downsize1, res.texture_lineardepth_downsize1.desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS), - GPUBarrier::Image(&res.texture_lineardepth_tiled1, res.texture_lineardepth_tiled1.desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS), - GPUBarrier::Image(&res.texture_lineardepth_downsize2, res.texture_lineardepth_downsize2.desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS), - GPUBarrier::Image(&res.texture_lineardepth_tiled2, res.texture_lineardepth_tiled2.desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS), + GPUBarrier::Image(&res.texture_lineardepth_downsize1, res.texture_lineardepth_downsize1.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS), + GPUBarrier::Image(&res.texture_lineardepth_tiled1, res.texture_lineardepth_tiled1.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS), + GPUBarrier::Image(&res.texture_lineardepth_downsize2, res.texture_lineardepth_downsize2.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS), + GPUBarrier::Image(&res.texture_lineardepth_tiled2, res.texture_lineardepth_tiled2.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS), }; device->Barrier(barriers, arraysize(barriers), cmd); } @@ -8931,22 +8578,21 @@ void Postprocess_MSAO( { GPUBarrier barriers[] = { GPUBarrier::Memory(), - GPUBarrier::Image(&res.texture_lineardepth_downsize1, IMAGE_LAYOUT_UNORDERED_ACCESS, res.texture_lineardepth_downsize1.desc.layout), - GPUBarrier::Image(&res.texture_lineardepth_tiled1, IMAGE_LAYOUT_UNORDERED_ACCESS, res.texture_lineardepth_tiled1.desc.layout), - GPUBarrier::Image(&res.texture_lineardepth_downsize2, IMAGE_LAYOUT_UNORDERED_ACCESS, res.texture_lineardepth_downsize2.desc.layout), - GPUBarrier::Image(&res.texture_lineardepth_tiled2, IMAGE_LAYOUT_UNORDERED_ACCESS, res.texture_lineardepth_tiled2.desc.layout), + GPUBarrier::Image(&res.texture_lineardepth_downsize1, RESOURCE_STATE_UNORDERED_ACCESS, res.texture_lineardepth_downsize1.desc.layout), + GPUBarrier::Image(&res.texture_lineardepth_tiled1, RESOURCE_STATE_UNORDERED_ACCESS, res.texture_lineardepth_tiled1.desc.layout), + GPUBarrier::Image(&res.texture_lineardepth_downsize2, RESOURCE_STATE_UNORDERED_ACCESS, res.texture_lineardepth_downsize2.desc.layout), + GPUBarrier::Image(&res.texture_lineardepth_tiled2, RESOURCE_STATE_UNORDERED_ACCESS, res.texture_lineardepth_tiled2.desc.layout), }; device->Barrier(barriers, arraysize(barriers), cmd); } - device->UnbindUAVs(0, arraysize(uavs), cmd); } // Depth downsampling + deinterleaving pass2: { device->BindComputeShader(&shaders[CSTYPE_POSTPROCESS_MSAO_PREPAREDEPTHBUFFERS2], cmd); - device->BindResource(CS, &res.texture_lineardepth_downsize2, TEXSLOT_ONDEMAND0, cmd); + device->BindResource(&res.texture_lineardepth_downsize2, TEXSLOT_ONDEMAND0, cmd); const GPUResource* uavs[] = { &res.texture_lineardepth_downsize3, @@ -8954,14 +8600,14 @@ void Postprocess_MSAO( &res.texture_lineardepth_downsize4, &res.texture_lineardepth_tiled4, }; - device->BindUAVs(CS, uavs, 0, arraysize(uavs), cmd); + device->BindUAVs(uavs, 0, arraysize(uavs), cmd); { GPUBarrier barriers[] = { - GPUBarrier::Image(&res.texture_lineardepth_downsize3, res.texture_lineardepth_downsize3.desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS), - GPUBarrier::Image(&res.texture_lineardepth_tiled3, res.texture_lineardepth_tiled3.desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS), - GPUBarrier::Image(&res.texture_lineardepth_downsize4, res.texture_lineardepth_downsize4.desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS), - GPUBarrier::Image(&res.texture_lineardepth_tiled4, res.texture_lineardepth_tiled4.desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS), + GPUBarrier::Image(&res.texture_lineardepth_downsize3, res.texture_lineardepth_downsize3.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS), + GPUBarrier::Image(&res.texture_lineardepth_tiled3, res.texture_lineardepth_tiled3.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS), + GPUBarrier::Image(&res.texture_lineardepth_downsize4, res.texture_lineardepth_downsize4.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS), + GPUBarrier::Image(&res.texture_lineardepth_tiled4, res.texture_lineardepth_tiled4.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS), }; device->Barrier(barriers, arraysize(barriers), cmd); } @@ -8972,15 +8618,14 @@ void Postprocess_MSAO( { GPUBarrier barriers[] = { GPUBarrier::Memory(), - GPUBarrier::Image(&res.texture_lineardepth_downsize3, IMAGE_LAYOUT_UNORDERED_ACCESS, res.texture_lineardepth_downsize3.desc.layout), - GPUBarrier::Image(&res.texture_lineardepth_tiled3, IMAGE_LAYOUT_UNORDERED_ACCESS, res.texture_lineardepth_tiled3.desc.layout), - GPUBarrier::Image(&res.texture_lineardepth_downsize4, IMAGE_LAYOUT_UNORDERED_ACCESS, res.texture_lineardepth_downsize4.desc.layout), - GPUBarrier::Image(&res.texture_lineardepth_tiled4, IMAGE_LAYOUT_UNORDERED_ACCESS, res.texture_lineardepth_tiled4.desc.layout), + GPUBarrier::Image(&res.texture_lineardepth_downsize3, RESOURCE_STATE_UNORDERED_ACCESS, res.texture_lineardepth_downsize3.desc.layout), + GPUBarrier::Image(&res.texture_lineardepth_tiled3, RESOURCE_STATE_UNORDERED_ACCESS, res.texture_lineardepth_tiled3.desc.layout), + GPUBarrier::Image(&res.texture_lineardepth_downsize4, RESOURCE_STATE_UNORDERED_ACCESS, res.texture_lineardepth_downsize4.desc.layout), + GPUBarrier::Image(&res.texture_lineardepth_tiled4, RESOURCE_STATE_UNORDERED_ACCESS, res.texture_lineardepth_tiled4.desc.layout), }; device->Barrier(barriers, arraysize(barriers), cmd); } - device->UnbindUAVs(0, arraysize(uavs), cmd); } @@ -9110,19 +8755,18 @@ void Postprocess_MSAO( cb.xRejectFadeoff = 1.0f / -RejectionFalloff; cb.xRcpAccentuation = 1.0f / (1.0f + Accentuation); - device->UpdateBuffer(&constantBuffers[CBTYPE_POSTPROCESS_MSAO], &cb, cmd); - device->BindConstantBuffer(CS, &constantBuffers[CBTYPE_POSTPROCESS_MSAO], CB_GETBINDSLOT(MSAOCB), cmd); + device->BindDynamicConstantBuffer(cb, CB_GETBINDSLOT(MSAOCB), cmd); - device->BindResource(CS, &read_depth, TEXSLOT_ONDEMAND0, cmd); + device->BindResource(&read_depth, TEXSLOT_ONDEMAND0, cmd); const GPUResource* uavs[] = { &write_result, }; - device->BindUAVs(CS, uavs, 0, arraysize(uavs), cmd); + device->BindUAVs(uavs, 0, arraysize(uavs), cmd); { GPUBarrier barriers[] = { - GPUBarrier::Image(&write_result, write_result.desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS), + GPUBarrier::Image(&write_result, write_result.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS), }; device->Barrier(barriers, arraysize(barriers), cmd); } @@ -9141,12 +8785,11 @@ void Postprocess_MSAO( { GPUBarrier barriers[] = { GPUBarrier::Memory(), - GPUBarrier::Image(&write_result, IMAGE_LAYOUT_UNORDERED_ACCESS, write_result.desc.layout), + GPUBarrier::Image(&write_result, RESOURCE_STATE_UNORDERED_ACCESS, write_result.desc.layout), }; device->Barrier(barriers, arraysize(barriers), cmd); } - device->UnbindUAVs(0, arraysize(uavs), cmd); }; // end of lambda: msao_compute msao_compute(res.texture_ao_merged4, res.texture_lineardepth_tiled4); @@ -9209,28 +8852,27 @@ void Postprocess_MSAO( cb.kBlurTolerance = kBlurTolerance; cb.kUpsampleTolerance = kUpsampleTolerance; - device->UpdateBuffer(&constantBuffers[CBTYPE_POSTPROCESS_MSAO_UPSAMPLE], &cb, cmd); - device->BindConstantBuffer(CS, &constantBuffers[CBTYPE_POSTPROCESS_MSAO_UPSAMPLE], CB_GETBINDSLOT(MSAO_UPSAMPLECB), cmd); + device->BindDynamicConstantBuffer(cb, CB_GETBINDSLOT(MSAO_UPSAMPLECB), cmd); - device->BindUAV(CS, &Destination, 0, cmd); - device->BindResource(CS, &LoResDepth, TEXSLOT_ONDEMAND0, cmd); - device->BindResource(CS, &HiResDepth, TEXSLOT_ONDEMAND1, cmd); + device->BindUAV(&Destination, 0, cmd); + device->BindResource(&LoResDepth, TEXSLOT_ONDEMAND0, cmd); + device->BindResource(&HiResDepth, TEXSLOT_ONDEMAND1, cmd); if (InterleavedAO != nullptr) { - device->BindResource(CS, InterleavedAO, TEXSLOT_ONDEMAND2, cmd); + device->BindResource(InterleavedAO, TEXSLOT_ONDEMAND2, cmd); } if (HighQualityAO != nullptr) { - device->BindResource(CS, HighQualityAO, TEXSLOT_ONDEMAND3, cmd); + device->BindResource(HighQualityAO, TEXSLOT_ONDEMAND3, cmd); } if (HiResAO != nullptr) { - device->BindResource(CS, HiResAO, TEXSLOT_ONDEMAND4, cmd); + device->BindResource(HiResAO, TEXSLOT_ONDEMAND4, cmd); } { GPUBarrier barriers[] = { - GPUBarrier::Image(&Destination, Destination.desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS), + GPUBarrier::Image(&Destination, Destination.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS), }; device->Barrier(barriers, arraysize(barriers), cmd); } @@ -9240,7 +8882,7 @@ void Postprocess_MSAO( { GPUBarrier barriers[] = { GPUBarrier::Memory(), - GPUBarrier::Image(&Destination, IMAGE_LAYOUT_UNORDERED_ACCESS, Destination.desc.layout), + GPUBarrier::Image(&Destination, RESOURCE_STATE_UNORDERED_ACCESS, Destination.desc.layout), }; device->Barrier(barriers, arraysize(barriers), cmd); } @@ -9291,7 +8933,7 @@ void CreateRTAOResources(RTAOResources& res, XMUINT2 resolution) desc.Width = resolution.x / 2; desc.Height = resolution.y / 2; desc.BindFlags = BIND_SHADER_RESOURCE | BIND_UNORDERED_ACCESS; - desc.layout = IMAGE_LAYOUT_SHADER_RESOURCE_COMPUTE; + desc.layout = RESOURCE_STATE_SHADER_RESOURCE_COMPUTE; desc.Format = FORMAT_R11G11B10_FLOAT; device->CreateTexture(&desc, nullptr, &res.normals); @@ -9334,7 +8976,7 @@ void Postprocess_RTAO( float power ) { - if (!wiRenderer::device->CheckCapability(GRAPHICSDEVICE_CAPABILITY_RAYTRACING_INLINE)) + if (!device->CheckCapability(GRAPHICSDEVICE_CAPABILITY_RAYTRACING)) return; if (scene.objects.GetCount() <= 0) @@ -9353,20 +8995,19 @@ void Postprocess_RTAO( device->BindComputeShader(&shaders[CSTYPE_POSTPROCESS_RTAO], cmd); - device->BindResource(CS, &scene.TLAS, TEXSLOT_ACCELERATION_STRUCTURE, cmd); - device->BindResource(CS, &depthbuffer, TEXSLOT_DEPTH, cmd); - device->BindResource(CS, &lineardepth, TEXSLOT_LINEARDEPTH, cmd); + device->BindResource(&scene.TLAS, TEXSLOT_ACCELERATION_STRUCTURE, cmd); + device->BindResource(&depthbuffer, TEXSLOT_DEPTH, cmd); + device->BindResource(&lineardepth, TEXSLOT_LINEARDEPTH, cmd); - device->BindResource(CS, &gbuffer[GBUFFER_COLOR], TEXSLOT_GBUFFER0, cmd); - device->BindResource(CS, &gbuffer[GBUFFER_NORMAL_ROUGHNESS], TEXSLOT_GBUFFER1, cmd); - device->BindResource(CS, &gbuffer[GBUFFER_VELOCITY], TEXSLOT_GBUFFER2, cmd); + device->BindResource(&gbuffer[GBUFFER_PRIMITIVEID], TEXSLOT_GBUFFER0, cmd); + device->BindResource(&gbuffer[GBUFFER_VELOCITY], TEXSLOT_GBUFFER1, cmd); const GPUResource* uavs[] = { &output, &res.normals, &res.tiles }; - device->BindUAVs(CS, uavs, 0, arraysize(uavs), cmd); + device->BindUAVs(uavs, 0, arraysize(uavs), cmd); PostProcessCB cb; cb.xPPResolution.x = desc.Width; @@ -9376,14 +9017,13 @@ void Postprocess_RTAO( cb.rtao_range = range; cb.rtao_power = power; cb.xPPParams0.w = (float)res.frame; - device->UpdateBuffer(&constantBuffers[CBTYPE_POSTPROCESS], &cb, cmd); - device->BindConstantBuffer(CS, &constantBuffers[CBTYPE_POSTPROCESS], CB_GETBINDSLOT(PostProcessCB), cmd); + device->BindDynamicConstantBuffer(cb, CB_GETBINDSLOT(PostProcessCB), cmd); { GPUBarrier barriers[] = { - GPUBarrier::Image(&output, output.desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS), - GPUBarrier::Image(&res.normals, res.normals.desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS), - GPUBarrier::Buffer(&res.tiles, BUFFER_STATE_SHADER_RESOURCE_COMPUTE, BUFFER_STATE_UNORDERED_ACCESS), + GPUBarrier::Image(&output, output.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS), + GPUBarrier::Image(&res.normals, res.normals.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS), + GPUBarrier::Buffer(&res.tiles, RESOURCE_STATE_SHADER_RESOURCE_COMPUTE, RESOURCE_STATE_UNORDERED_ACCESS), }; device->Barrier(barriers, arraysize(barriers), cmd); } @@ -9398,16 +9038,15 @@ void Postprocess_RTAO( { GPUBarrier barriers[] = { GPUBarrier::Memory(), - GPUBarrier::Image(&res.normals, IMAGE_LAYOUT_UNORDERED_ACCESS, res.normals.desc.layout), - GPUBarrier::Buffer(&res.tiles, BUFFER_STATE_UNORDERED_ACCESS, BUFFER_STATE_SHADER_RESOURCE_COMPUTE), + GPUBarrier::Image(&res.normals, RESOURCE_STATE_UNORDERED_ACCESS, res.normals.desc.layout), + GPUBarrier::Buffer(&res.tiles, RESOURCE_STATE_UNORDERED_ACCESS, RESOURCE_STATE_SHADER_RESOURCE_COMPUTE), }; device->Barrier(barriers, arraysize(barriers), cmd); } device->EventEnd(cmd); - device->UpdateBuffer(&constantBuffers[CBTYPE_POSTPROCESS], &cb, cmd); - device->BindConstantBuffer(CS, &constantBuffers[CBTYPE_POSTPROCESS], CB_GETBINDSLOT(PostProcessCB), cmd); + device->BindDynamicConstantBuffer(cb, CB_GETBINDSLOT(PostProcessCB), cmd); int temporal_output = res.frame % 2; int temporal_history = 1 - temporal_output; @@ -9417,25 +9056,25 @@ void Postprocess_RTAO( device->EventBegin("Denoise - Tile Classification", cmd); device->BindComputeShader(&shaders[CSTYPE_POSTPROCESS_RTAO_DENOISE_TILECLASSIFICATION], cmd); - device->BindResource(CS, &depthbuffer, TEXSLOT_DEPTH, cmd); - device->BindResource(CS, &res.normals, TEXSLOT_ONDEMAND0, cmd); - device->BindResource(CS, &res.tiles, TEXSLOT_ONDEMAND1, cmd); - device->BindResource(CS, &res.moments[temporal_history], TEXSLOT_ONDEMAND2, cmd); - device->BindResource(CS, &res.scratch[1], TEXSLOT_ONDEMAND3, cmd); - device->BindResource(CS, &depth_history, TEXSLOT_ONDEMAND4, cmd); + device->BindResource(&depthbuffer, TEXSLOT_DEPTH, cmd); + device->BindResource(&res.normals, TEXSLOT_ONDEMAND0, cmd); + device->BindResource(&res.tiles, TEXSLOT_ONDEMAND1, cmd); + device->BindResource(&res.moments[temporal_history], TEXSLOT_ONDEMAND2, cmd); + device->BindResource(&res.scratch[1], TEXSLOT_ONDEMAND3, cmd); + device->BindResource(&depth_history, TEXSLOT_ONDEMAND4, cmd); const GPUResource* uavs[] = { &res.scratch[0], &res.moments[temporal_output], &res.metadata }; - device->BindUAVs(CS, uavs, 0, arraysize(uavs), cmd); + device->BindUAVs(uavs, 0, arraysize(uavs), cmd); { GPUBarrier barriers[] = { - GPUBarrier::Image(&res.scratch[0], res.scratch[0].desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS), - GPUBarrier::Image(&res.moments[temporal_output], res.moments[temporal_output].desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS), - GPUBarrier::Buffer(&res.metadata, BUFFER_STATE_SHADER_RESOURCE_COMPUTE, BUFFER_STATE_UNORDERED_ACCESS) + GPUBarrier::Image(&res.scratch[0], res.scratch[0].desc.layout, RESOURCE_STATE_UNORDERED_ACCESS), + GPUBarrier::Image(&res.moments[temporal_output], res.moments[temporal_output].desc.layout, RESOURCE_STATE_UNORDERED_ACCESS), + GPUBarrier::Buffer(&res.metadata, RESOURCE_STATE_SHADER_RESOURCE_COMPUTE, RESOURCE_STATE_UNORDERED_ACCESS) }; device->Barrier(barriers, arraysize(barriers), cmd); } @@ -9450,9 +9089,9 @@ void Postprocess_RTAO( { GPUBarrier barriers[] = { GPUBarrier::Memory(), - GPUBarrier::Image(&res.scratch[0], IMAGE_LAYOUT_UNORDERED_ACCESS, res.scratch[0].desc.layout), - GPUBarrier::Image(&res.moments[temporal_output], IMAGE_LAYOUT_UNORDERED_ACCESS, res.moments[temporal_output].desc.layout), - GPUBarrier::Buffer(&res.metadata, BUFFER_STATE_UNORDERED_ACCESS, BUFFER_STATE_SHADER_RESOURCE_COMPUTE) + GPUBarrier::Image(&res.scratch[0], RESOURCE_STATE_UNORDERED_ACCESS, res.scratch[0].desc.layout), + GPUBarrier::Image(&res.moments[temporal_output], RESOURCE_STATE_UNORDERED_ACCESS, res.moments[temporal_output].desc.layout), + GPUBarrier::Buffer(&res.metadata, RESOURCE_STATE_UNORDERED_ACCESS, RESOURCE_STATE_SHADER_RESOURCE_COMPUTE) }; device->Barrier(barriers, arraysize(barriers), cmd); } @@ -9465,29 +9104,28 @@ void Postprocess_RTAO( device->EventBegin("Denoise - Filter", cmd); device->BindComputeShader(&shaders[CSTYPE_POSTPROCESS_RTAO_DENOISE_FILTER], cmd); - device->BindResource(CS, &depthbuffer, TEXSLOT_DEPTH, cmd); - device->BindResource(CS, &res.normals, TEXSLOT_ONDEMAND0, cmd); - device->BindResource(CS, &res.metadata, TEXSLOT_ONDEMAND1, cmd); + device->BindResource(&depthbuffer, TEXSLOT_DEPTH, cmd); + device->BindResource(&res.normals, TEXSLOT_ONDEMAND0, cmd); + device->BindResource(&res.metadata, TEXSLOT_ONDEMAND1, cmd); // pass0: { - device->BindResource(CS, &res.scratch[0], TEXSLOT_ONDEMAND2, cmd); + device->BindResource(&res.scratch[0], TEXSLOT_ONDEMAND2, cmd); const GPUResource* uavs[] = { &res.scratch[1], &output }; - device->BindUAVs(CS, uavs, 0, arraysize(uavs), cmd); + device->BindUAVs(uavs, 0, arraysize(uavs), cmd); { GPUBarrier barriers[] = { - GPUBarrier::Image(&res.scratch[1], res.scratch[1].desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS), + GPUBarrier::Image(&res.scratch[1], res.scratch[1].desc.layout, RESOURCE_STATE_UNORDERED_ACCESS), }; device->Barrier(barriers, arraysize(barriers), cmd); } cb.xPPParams1.x = 0; cb.xPPParams1.y = 1; - device->UpdateBuffer(&constantBuffers[CBTYPE_POSTPROCESS], &cb, cmd); - device->BindConstantBuffer(CS, &constantBuffers[CBTYPE_POSTPROCESS], CB_GETBINDSLOT(PostProcessCB), cmd); + device->BindDynamicConstantBuffer(cb, CB_GETBINDSLOT(PostProcessCB), cmd); device->Dispatch( (desc.Width + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE, @@ -9499,25 +9137,24 @@ void Postprocess_RTAO( // pass1: { - device->BindResource(CS, &res.scratch[1], TEXSLOT_ONDEMAND2, cmd); + device->BindResource(&res.scratch[1], TEXSLOT_ONDEMAND2, cmd); const GPUResource* uavs[] = { &res.scratch[0], &output }; - device->BindUAVs(CS, uavs, 0, arraysize(uavs), cmd); + device->BindUAVs(uavs, 0, arraysize(uavs), cmd); { GPUBarrier barriers[] = { GPUBarrier::Memory(), - GPUBarrier::Image(&res.scratch[1], IMAGE_LAYOUT_UNORDERED_ACCESS, res.scratch[1].desc.layout), - GPUBarrier::Image(&res.scratch[0], res.scratch[0].desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS), + GPUBarrier::Image(&res.scratch[1], RESOURCE_STATE_UNORDERED_ACCESS, res.scratch[1].desc.layout), + GPUBarrier::Image(&res.scratch[0], res.scratch[0].desc.layout, RESOURCE_STATE_UNORDERED_ACCESS), }; device->Barrier(barriers, arraysize(barriers), cmd); } cb.xPPParams1.x = 1; cb.xPPParams1.y = 2; - device->UpdateBuffer(&constantBuffers[CBTYPE_POSTPROCESS], &cb, cmd); - device->BindConstantBuffer(CS, &constantBuffers[CBTYPE_POSTPROCESS], CB_GETBINDSLOT(PostProcessCB), cmd); + device->BindDynamicConstantBuffer(cb, CB_GETBINDSLOT(PostProcessCB), cmd); device->Dispatch( (desc.Width + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE, @@ -9529,25 +9166,24 @@ void Postprocess_RTAO( // pass2: { - device->BindResource(CS, &res.scratch[0], TEXSLOT_ONDEMAND2, cmd); + device->BindResource(&res.scratch[0], TEXSLOT_ONDEMAND2, cmd); const GPUResource* uavs[] = { &res.scratch[1], &output }; - device->BindUAVs(CS, uavs, 0, arraysize(uavs), cmd); + device->BindUAVs(uavs, 0, arraysize(uavs), cmd); { GPUBarrier barriers[] = { GPUBarrier::Memory(), - GPUBarrier::Image(&res.scratch[0], IMAGE_LAYOUT_UNORDERED_ACCESS, res.scratch[0].desc.layout), - GPUBarrier::Image(&res.scratch[1], res.scratch[0].desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS), + GPUBarrier::Image(&res.scratch[0], RESOURCE_STATE_UNORDERED_ACCESS, res.scratch[0].desc.layout), + GPUBarrier::Image(&res.scratch[1], res.scratch[0].desc.layout, RESOURCE_STATE_UNORDERED_ACCESS), }; device->Barrier(barriers, arraysize(barriers), cmd); } cb.xPPParams1.x = 2; cb.xPPParams1.y = 4; - device->UpdateBuffer(&constantBuffers[CBTYPE_POSTPROCESS], &cb, cmd); - device->BindConstantBuffer(CS, &constantBuffers[CBTYPE_POSTPROCESS], CB_GETBINDSLOT(PostProcessCB), cmd); + device->BindDynamicConstantBuffer(cb, CB_GETBINDSLOT(PostProcessCB), cmd); device->Dispatch( (desc.Width + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE, @@ -9560,8 +9196,8 @@ void Postprocess_RTAO( { GPUBarrier barriers[] = { GPUBarrier::Memory(), - GPUBarrier::Image(&res.scratch[1], IMAGE_LAYOUT_UNORDERED_ACCESS, res.scratch[1].desc.layout), - GPUBarrier::Image(&output, IMAGE_LAYOUT_UNORDERED_ACCESS, output.desc.layout), + GPUBarrier::Image(&res.scratch[1], RESOURCE_STATE_UNORDERED_ACCESS, res.scratch[1].desc.layout), + GPUBarrier::Image(&output, RESOURCE_STATE_UNORDERED_ACCESS, output.desc.layout), }; device->Barrier(barriers, arraysize(barriers), cmd); } @@ -9579,7 +9215,7 @@ void CreateRTReflectionResources(RTReflectionResources& res, XMUINT2 resolution) desc.Width = resolution.x / 2; desc.Height = resolution.y / 2; desc.BindFlags = BIND_SHADER_RESOURCE | BIND_UNORDERED_ACCESS; - desc.layout = IMAGE_LAYOUT_SHADER_RESOURCE_COMPUTE; + desc.layout = RESOURCE_STATE_SHADER_RESOURCE_COMPUTE; desc.Format = FORMAT_R11G11B10_FLOAT; device->CreateTexture(&desc, nullptr, &res.temporal[0]); @@ -9602,9 +9238,7 @@ void Postprocess_RTReflection( float range ) { - if (!wiRenderer::device->CheckCapability(GRAPHICSDEVICE_CAPABILITY_RAYTRACING_PIPELINE)) - return; - if (!wiRenderer::device->CheckCapability(GRAPHICSDEVICE_CAPABILITY_RAYTRACING_GEOMETRYINDEX)) + if (!device->CheckCapability(GRAPHICSDEVICE_CAPABILITY_RAYTRACING)) return; if (scene.objects.GetCount() <= 0) @@ -9620,29 +9254,13 @@ void Postprocess_RTReflection( device->BindRaytracingPipelineState(&RTPSO_reflection, cmd); BindCommonResources(cmd); - BindShadowmaps(LIB, cmd); - device->BindResource(LIB, &scene.TLAS, TEXSLOT_ACCELERATION_STRUCTURE, cmd); - device->BindResource(LIB, &depthbuffer, TEXSLOT_DEPTH, cmd); - device->BindResource(LIB, &gbuffer[GBUFFER_NORMAL_ROUGHNESS], TEXSLOT_GBUFFER1, cmd); - device->BindResource(LIB, &gbuffer[GBUFFER_VELOCITY], TEXSLOT_GBUFFER2, cmd); + device->BindResource(&scene.TLAS, TEXSLOT_ACCELERATION_STRUCTURE, cmd); + device->BindResource(&depthbuffer, TEXSLOT_DEPTH, cmd); + device->BindResource(&gbuffer[GBUFFER_PRIMITIVEID], TEXSLOT_GBUFFER0, cmd); + device->BindResource(&gbuffer[GBUFFER_VELOCITY], TEXSLOT_GBUFFER1, cmd); - device->BindResource(LIB, &depth_history, TEXSLOT_ONDEMAND2, cmd); - - device->BindResource(LIB, &resourceBuffers[RBTYPE_ENTITYARRAY], SBSLOT_ENTITYARRAY, cmd); - device->BindResource(LIB, &resourceBuffers[RBTYPE_MATRIXARRAY], SBSLOT_MATRIXARRAY, cmd); - device->BindResource(LIB, GetVoxelRadianceSecondaryBounceEnabled() ? &textures[TEXTYPE_3D_VOXELRADIANCE_HELPER] : &textures[TEXTYPE_3D_VOXELRADIANCE], TEXSLOT_VOXELRADIANCE, cmd); - device->BindResource(LIB, &scene.envmapArray, TEXSLOT_ENVMAPARRAY, cmd); - device->BindResource(LIB, &textures[TEXTYPE_2D_SKYATMOSPHERE_TRANSMITTANCELUT], TEXSLOT_TRANSMITTANCELUT, cmd); - device->BindResource(LIB, &textures[TEXTYPE_2D_SKYATMOSPHERE_MULTISCATTEREDLUMINANCELUT], TEXSLOT_MULTISCATTERINGLUT, cmd); - device->BindResource(LIB, &textures[TEXTYPE_2D_SKYATMOSPHERE_SKYVIEWLUT], TEXSLOT_SKYVIEWLUT, cmd); - device->BindResource(LIB, &textures[TEXTYPE_2D_SKYATMOSPHERE_SKYLUMINANCELUT], TEXSLOT_SKYLUMINANCELUT, cmd); - - device->BindResource(LIB, &scene.lightmap, TEXSLOT_GLOBALLIGHTMAP, cmd); - if (scene.decalAtlas.IsValid()) - { - device->BindResource(LIB, &scene.decalAtlas, TEXSLOT_DECALATLAS, cmd); - } + device->BindResource(&depth_history, TEXSLOT_ONDEMAND2, cmd); PostProcessCB cb; cb.xPPResolution.x = desc.Width; @@ -9650,8 +9268,7 @@ void Postprocess_RTReflection( cb.xPPResolution_rcp.x = 1.0f / cb.xPPResolution.x; cb.xPPResolution_rcp.y = 1.0f / cb.xPPResolution.y; cb.rtreflection_range = range; - device->UpdateBuffer(&constantBuffers[CBTYPE_POSTPROCESS], &cb, cmd); - device->BindConstantBuffer(LIB, &constantBuffers[CBTYPE_POSTPROCESS], CB_GETBINDSLOT(PostProcessCB), cmd); + device->BindDynamicConstantBuffer(cb, CB_GETBINDSLOT(PostProcessCB), cmd); size_t shaderIdentifierSize = device->GetShaderIdentifierSize(); GraphicsDevice::GPUAllocation shadertable_raygen = device->AllocateGPU(shaderIdentifierSize, cmd); @@ -9663,16 +9280,16 @@ void Postprocess_RTReflection( device->WriteShaderIdentifier(&RTPSO_reflection, 2, shadertable_hitgroup.data); DispatchRaysDesc dispatchraysdesc; - dispatchraysdesc.raygeneration.buffer = shadertable_raygen.buffer; + dispatchraysdesc.raygeneration.buffer = &shadertable_raygen.buffer; dispatchraysdesc.raygeneration.offset = shadertable_raygen.offset; dispatchraysdesc.raygeneration.size = shaderIdentifierSize; - dispatchraysdesc.miss.buffer = shadertable_miss.buffer; + dispatchraysdesc.miss.buffer = &shadertable_miss.buffer; dispatchraysdesc.miss.offset = shadertable_miss.offset; dispatchraysdesc.miss.size = shaderIdentifierSize; dispatchraysdesc.miss.stride = shaderIdentifierSize; - dispatchraysdesc.hitgroup.buffer = shadertable_hitgroup.buffer; + dispatchraysdesc.hitgroup.buffer = &shadertable_hitgroup.buffer; dispatchraysdesc.hitgroup.offset = shadertable_hitgroup.offset; dispatchraysdesc.hitgroup.size = shaderIdentifierSize; dispatchraysdesc.hitgroup.stride = shaderIdentifierSize; @@ -9684,12 +9301,12 @@ void Postprocess_RTReflection( &output, &res.rayLengths }; - device->BindUAVs(CS, uavs, 0, arraysize(uavs), cmd); + device->BindUAVs(uavs, 0, arraysize(uavs), cmd); { GPUBarrier barriers[] = { - GPUBarrier::Image(&output, output.desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS), - GPUBarrier::Image(&res.rayLengths, res.rayLengths.desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS), + GPUBarrier::Image(&output, output.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS), + GPUBarrier::Image(&res.rayLengths, res.rayLengths.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS), }; device->Barrier(barriers, arraysize(barriers), cmd); } @@ -9699,18 +9316,16 @@ void Postprocess_RTReflection( { GPUBarrier barriers[] = { GPUBarrier::Memory(), - GPUBarrier::Image(&output, IMAGE_LAYOUT_UNORDERED_ACCESS, output.desc.layout), - GPUBarrier::Image(&res.rayLengths, IMAGE_LAYOUT_UNORDERED_ACCESS, res.rayLengths.desc.layout), + GPUBarrier::Image(&output, RESOURCE_STATE_UNORDERED_ACCESS, output.desc.layout), + GPUBarrier::Image(&res.rayLengths, RESOURCE_STATE_UNORDERED_ACCESS, res.rayLengths.desc.layout), }; device->Barrier(barriers, arraysize(barriers), cmd); } - device->UpdateBuffer(&constantBuffers[CBTYPE_POSTPROCESS], &cb, cmd); - device->BindConstantBuffer(CS, &constantBuffers[CBTYPE_POSTPROCESS], CB_GETBINDSLOT(PostProcessCB), cmd); + device->BindDynamicConstantBuffer(cb, CB_GETBINDSLOT(PostProcessCB), cmd); - device->BindResource(CS, &gbuffer[GBUFFER_COLOR], TEXSLOT_GBUFFER0, cmd); - device->BindResource(CS, &gbuffer[GBUFFER_NORMAL_ROUGHNESS], TEXSLOT_GBUFFER1, cmd); - device->BindResource(CS, &gbuffer[GBUFFER_VELOCITY], TEXSLOT_GBUFFER2, cmd); + device->BindResource(&gbuffer[GBUFFER_PRIMITIVEID], TEXSLOT_GBUFFER0, cmd); + device->BindResource(&gbuffer[GBUFFER_VELOCITY], TEXSLOT_GBUFFER1, cmd); int temporal_output = device->GetFrameCount() % 2; int temporal_history = 1 - temporal_output; @@ -9720,20 +9335,20 @@ void Postprocess_RTReflection( device->EventBegin("Temporal pass", cmd); device->BindComputeShader(&shaders[CSTYPE_POSTPROCESS_SSR_TEMPORAL], cmd); - device->BindResource(CS, &depthbuffer, TEXSLOT_DEPTH, cmd); - device->BindResource(CS, &output, TEXSLOT_ONDEMAND0, cmd); - device->BindResource(CS, &res.temporal[temporal_history], TEXSLOT_ONDEMAND1, cmd); - device->BindResource(CS, &depth_history, TEXSLOT_ONDEMAND2, cmd); - device->BindResource(CS, &res.rayLengths, TEXSLOT_ONDEMAND3, cmd); + device->BindResource(&depthbuffer, TEXSLOT_DEPTH, cmd); + device->BindResource(&output, TEXSLOT_ONDEMAND0, cmd); + device->BindResource(&res.temporal[temporal_history], TEXSLOT_ONDEMAND1, cmd); + device->BindResource(&depth_history, TEXSLOT_ONDEMAND2, cmd); + device->BindResource(&res.rayLengths, TEXSLOT_ONDEMAND3, cmd); const GPUResource* uavs[] = { &res.temporal[temporal_output], }; - device->BindUAVs(CS, uavs, 0, arraysize(uavs), cmd); + device->BindUAVs(uavs, 0, arraysize(uavs), cmd); { GPUBarrier barriers[] = { - GPUBarrier::Image(&res.temporal[temporal_output], res.temporal[temporal_output].desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS), + GPUBarrier::Image(&res.temporal[temporal_output], res.temporal[temporal_output].desc.layout, RESOURCE_STATE_UNORDERED_ACCESS), }; device->Barrier(barriers, arraysize(barriers), cmd); } @@ -9748,12 +9363,11 @@ void Postprocess_RTReflection( { GPUBarrier barriers[] = { GPUBarrier::Memory(), - GPUBarrier::Image(&res.temporal[temporal_output], IMAGE_LAYOUT_UNORDERED_ACCESS, res.temporal[temporal_output].desc.layout), + GPUBarrier::Image(&res.temporal[temporal_output], RESOURCE_STATE_UNORDERED_ACCESS, res.temporal[temporal_output].desc.layout), }; device->Barrier(barriers, arraysize(barriers), cmd); } - device->UnbindUAVs(0, arraysize(uavs), cmd); device->EventEnd(cmd); } @@ -9762,17 +9376,17 @@ void Postprocess_RTReflection( device->EventBegin("Median blur pass", cmd); device->BindComputeShader(&shaders[CSTYPE_POSTPROCESS_SSR_MEDIAN], cmd); - device->BindResource(CS, &depthbuffer, TEXSLOT_DEPTH, cmd); - device->BindResource(CS, &res.temporal[temporal_output], TEXSLOT_ONDEMAND0, cmd); + device->BindResource(&depthbuffer, TEXSLOT_DEPTH, cmd); + device->BindResource(&res.temporal[temporal_output], TEXSLOT_ONDEMAND0, cmd); const GPUResource* uavs[] = { &output, }; - device->BindUAVs(CS, uavs, 0, arraysize(uavs), cmd); + device->BindUAVs(uavs, 0, arraysize(uavs), cmd); { GPUBarrier barriers[] = { - GPUBarrier::Image(&output, output.desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS), + GPUBarrier::Image(&output, output.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS), }; device->Barrier(barriers, arraysize(barriers), cmd); } @@ -9787,12 +9401,11 @@ void Postprocess_RTReflection( { GPUBarrier barriers[] = { GPUBarrier::Memory(), - GPUBarrier::Image(&output, IMAGE_LAYOUT_UNORDERED_ACCESS, output.desc.layout), + GPUBarrier::Image(&output, RESOURCE_STATE_UNORDERED_ACCESS, output.desc.layout), }; device->Barrier(barriers, arraysize(barriers), cmd); } - device->UnbindUAVs(0, arraysize(uavs), cmd); device->EventEnd(cmd); } @@ -9807,7 +9420,7 @@ void CreateSSRResources(SSRResources& res, XMUINT2 resolution) desc.Height = resolution.y / 2; desc.Format = FORMAT_R16G16B16A16_FLOAT; desc.BindFlags = BIND_SHADER_RESOURCE | BIND_UNORDERED_ACCESS; - desc.layout = IMAGE_LAYOUT_SHADER_RESOURCE_COMPUTE; + desc.layout = RESOURCE_STATE_SHADER_RESOURCE_COMPUTE; device->CreateTexture(&desc, nullptr, &res.texture_raytrace); device->CreateTexture(&desc, nullptr, &res.texture_temporal[0]); device->CreateTexture(&desc, nullptr, &res.texture_temporal[1]); @@ -9830,18 +9443,16 @@ void Postprocess_SSR( device->EventBegin("Postprocess_SSR", cmd); auto range = wiProfiler::BeginRangeGPU("SSR", cmd); - device->UnbindResources(TEXSLOT_RENDERPATH_SSR, 1, cmd); BindCommonResources(cmd); const TextureDesc& input_desc = input.GetDesc(); const TextureDesc& desc = output.GetDesc(); - device->BindResource(CS, &depthbuffer, TEXSLOT_DEPTH, cmd); - device->BindResource(CS, &lineardepth, TEXSLOT_LINEARDEPTH, cmd); - device->BindResource(CS, &gbuffer[GBUFFER_COLOR], TEXSLOT_GBUFFER0, cmd); - device->BindResource(CS, &gbuffer[GBUFFER_NORMAL_ROUGHNESS], TEXSLOT_GBUFFER1, cmd); - device->BindResource(CS, &gbuffer[GBUFFER_VELOCITY], TEXSLOT_GBUFFER2, cmd); + device->BindResource(&depthbuffer, TEXSLOT_DEPTH, cmd); + device->BindResource(&lineardepth, TEXSLOT_LINEARDEPTH, cmd); + device->BindResource(&gbuffer[GBUFFER_PRIMITIVEID], TEXSLOT_GBUFFER0, cmd); + device->BindResource(&gbuffer[GBUFFER_VELOCITY], TEXSLOT_GBUFFER1, cmd); PostProcessCB cb; cb.xPPResolution.x = desc.Width; @@ -9850,25 +9461,24 @@ void Postprocess_SSR( cb.xPPResolution_rcp.y = 1.0f / cb.xPPResolution.y; cb.ssr_input_maxmip = float(input_desc.MipLevels - 1); cb.ssr_input_resolution_max = (float)std::max(input_desc.Width, input_desc.Height); - device->UpdateBuffer(&constantBuffers[CBTYPE_POSTPROCESS], &cb, cmd); - device->BindConstantBuffer(CS, &constantBuffers[CBTYPE_POSTPROCESS], CB_GETBINDSLOT(PostProcessCB), cmd); + device->BindDynamicConstantBuffer(cb, CB_GETBINDSLOT(PostProcessCB), cmd); // Raytrace pass: { device->EventBegin("Stochastic Raytrace pass", cmd); device->BindComputeShader(&shaders[CSTYPE_POSTPROCESS_SSR_RAYTRACE], cmd); - device->BindResource(CS, &input, TEXSLOT_ONDEMAND0, cmd); + device->BindResource(&input, TEXSLOT_ONDEMAND0, cmd); const GPUResource* uavs[] = { &res.texture_raytrace, &res.rayLengths }; - device->BindUAVs(CS, uavs, 0, arraysize(uavs), cmd); + device->BindUAVs(uavs, 0, arraysize(uavs), cmd); { GPUBarrier barriers[] = { - GPUBarrier::Image(&res.texture_raytrace, res.texture_raytrace.desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS), + GPUBarrier::Image(&res.texture_raytrace, res.texture_raytrace.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS), }; device->Barrier(barriers, arraysize(barriers), cmd); } @@ -9883,12 +9493,11 @@ void Postprocess_SSR( { GPUBarrier barriers[] = { GPUBarrier::Memory(), - GPUBarrier::Image(&res.texture_raytrace, IMAGE_LAYOUT_UNORDERED_ACCESS, res.texture_raytrace.desc.layout), + GPUBarrier::Image(&res.texture_raytrace, RESOURCE_STATE_UNORDERED_ACCESS, res.texture_raytrace.desc.layout), }; device->Barrier(barriers, arraysize(barriers), cmd); } - device->UnbindUAVs(0, arraysize(uavs), cmd); device->EventEnd(cmd); } @@ -9897,18 +9506,18 @@ void Postprocess_SSR( device->EventBegin("Resolve pass", cmd); device->BindComputeShader(&shaders[CSTYPE_POSTPROCESS_SSR_RESOLVE], cmd); - device->BindResource(CS, &res.texture_raytrace, TEXSLOT_ONDEMAND0, cmd); - device->BindResource(CS, &input, TEXSLOT_ONDEMAND1, cmd); - device->BindResource(CS, &depth_history, TEXSLOT_ONDEMAND2, cmd); + device->BindResource(&res.texture_raytrace, TEXSLOT_ONDEMAND0, cmd); + device->BindResource(&input, TEXSLOT_ONDEMAND1, cmd); + device->BindResource(&depth_history, TEXSLOT_ONDEMAND2, cmd); const GPUResource* uavs[] = { &output, }; - device->BindUAVs(CS, uavs, 0, arraysize(uavs), cmd); + device->BindUAVs(uavs, 0, arraysize(uavs), cmd); { GPUBarrier barriers[] = { - GPUBarrier::Image(&output, output.desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS), + GPUBarrier::Image(&output, output.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS), }; device->Barrier(barriers, arraysize(barriers), cmd); } @@ -9923,12 +9532,11 @@ void Postprocess_SSR( { GPUBarrier barriers[] = { GPUBarrier::Memory(), - GPUBarrier::Image(&output, IMAGE_LAYOUT_UNORDERED_ACCESS, output.desc.layout), + GPUBarrier::Image(&output, RESOURCE_STATE_UNORDERED_ACCESS, output.desc.layout), }; device->Barrier(barriers, arraysize(barriers), cmd); } - device->UnbindUAVs(0, arraysize(uavs), cmd); device->EventEnd(cmd); } @@ -9940,19 +9548,19 @@ void Postprocess_SSR( device->EventBegin("Temporal pass", cmd); device->BindComputeShader(&shaders[CSTYPE_POSTPROCESS_SSR_TEMPORAL], cmd); - device->BindResource(CS, &output, TEXSLOT_ONDEMAND0, cmd); - device->BindResource(CS, &res.texture_temporal[temporal_history], TEXSLOT_ONDEMAND1, cmd); - device->BindResource(CS, &depth_history, TEXSLOT_ONDEMAND2, cmd); - device->BindResource(CS, &res.rayLengths, TEXSLOT_ONDEMAND3, cmd); + device->BindResource(&output, TEXSLOT_ONDEMAND0, cmd); + device->BindResource(&res.texture_temporal[temporal_history], TEXSLOT_ONDEMAND1, cmd); + device->BindResource(&depth_history, TEXSLOT_ONDEMAND2, cmd); + device->BindResource(&res.rayLengths, TEXSLOT_ONDEMAND3, cmd); const GPUResource* uavs[] = { &res.texture_temporal[temporal_output], }; - device->BindUAVs(CS, uavs, 0, arraysize(uavs), cmd); + device->BindUAVs(uavs, 0, arraysize(uavs), cmd); { GPUBarrier barriers[] = { - GPUBarrier::Image(&res.texture_temporal[temporal_output], res.texture_temporal[temporal_output].desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS), + GPUBarrier::Image(&res.texture_temporal[temporal_output], res.texture_temporal[temporal_output].desc.layout, RESOURCE_STATE_UNORDERED_ACCESS), }; device->Barrier(barriers, arraysize(barriers), cmd); } @@ -9967,12 +9575,11 @@ void Postprocess_SSR( { GPUBarrier barriers[] = { GPUBarrier::Memory(), - GPUBarrier::Image(&res.texture_temporal[temporal_output], IMAGE_LAYOUT_UNORDERED_ACCESS, res.texture_temporal[temporal_output].desc.layout), + GPUBarrier::Image(&res.texture_temporal[temporal_output], RESOURCE_STATE_UNORDERED_ACCESS, res.texture_temporal[temporal_output].desc.layout), }; device->Barrier(barriers, arraysize(barriers), cmd); } - device->UnbindUAVs(0, arraysize(uavs), cmd); device->EventEnd(cmd); } @@ -9981,16 +9588,16 @@ void Postprocess_SSR( device->EventBegin("Median blur pass", cmd); device->BindComputeShader(&shaders[CSTYPE_POSTPROCESS_SSR_MEDIAN], cmd); - device->BindResource(CS, &res.texture_temporal[temporal_output], TEXSLOT_ONDEMAND0, cmd); + device->BindResource(&res.texture_temporal[temporal_output], TEXSLOT_ONDEMAND0, cmd); const GPUResource* uavs[] = { &output, }; - device->BindUAVs(CS, uavs, 0, arraysize(uavs), cmd); + device->BindUAVs(uavs, 0, arraysize(uavs), cmd); { GPUBarrier barriers[] = { - GPUBarrier::Image(&output, output.desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS), + GPUBarrier::Image(&output, output.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS), }; device->Barrier(barriers, arraysize(barriers), cmd); } @@ -10005,12 +9612,11 @@ void Postprocess_SSR( { GPUBarrier barriers[] = { GPUBarrier::Memory(), - GPUBarrier::Image(&output, IMAGE_LAYOUT_UNORDERED_ACCESS, output.desc.layout), + GPUBarrier::Image(&output, RESOURCE_STATE_UNORDERED_ACCESS, output.desc.layout), }; device->Barrier(barriers, arraysize(barriers), cmd); } - device->UnbindUAVs(0, arraysize(uavs), cmd); device->EventEnd(cmd); } @@ -10023,7 +9629,7 @@ void CreateRTShadowResources(RTShadowResources& res, XMUINT2 resolution) desc.Width = resolution.x / 2; desc.Height = resolution.y / 2; desc.BindFlags = BIND_SHADER_RESOURCE | BIND_UNORDERED_ACCESS; - desc.layout = IMAGE_LAYOUT_SHADER_RESOURCE_COMPUTE; + desc.layout = RESOURCE_STATE_SHADER_RESOURCE_COMPUTE; desc.Format = FORMAT_R32G32B32A32_UINT; device->CreateTexture(&desc, nullptr, &res.temp); @@ -10080,7 +9686,7 @@ void Postprocess_RTShadow( CommandList cmd ) { - if (!wiRenderer::device->CheckCapability(GRAPHICSDEVICE_CAPABILITY_RAYTRACING_INLINE)) + if (!device->CheckCapability(GRAPHICSDEVICE_CAPABILITY_RAYTRACING)) return; if (scene.objects.GetCount() <= 0) @@ -10097,7 +9703,7 @@ void Postprocess_RTShadow( device->EventBegin("Raytrace", cmd); - device->BindResource(CS, &scene.TLAS, TEXSLOT_ACCELERATION_STRUCTURE, cmd); + device->BindResource(&scene.TLAS, TEXSLOT_ACCELERATION_STRUCTURE, cmd); PostProcessCB cb; cb.xPPResolution.x = desc.Width; @@ -10105,32 +9711,30 @@ void Postprocess_RTShadow( cb.xPPResolution_rcp.x = 1.0f / cb.xPPResolution.x; cb.xPPResolution_rcp.y = 1.0f / cb.xPPResolution.y; cb.xPPParams0.w = (float)res.frame; - device->UpdateBuffer(&constantBuffers[CBTYPE_POSTPROCESS], &cb, cmd); - device->BindConstantBuffer(CS, &constantBuffers[CBTYPE_POSTPROCESS], CB_GETBINDSLOT(PostProcessCB), cmd); + device->BindDynamicConstantBuffer(cb, CB_GETBINDSLOT(PostProcessCB), cmd); device->BindComputeShader(&shaders[CSTYPE_POSTPROCESS_RTSHADOW], cmd); - device->BindResource(CS, &depthbuffer, TEXSLOT_DEPTH, cmd); - device->BindResource(CS, &lineardepth, TEXSLOT_LINEARDEPTH, cmd); + device->BindResource(&depthbuffer, TEXSLOT_DEPTH, cmd); + device->BindResource(&lineardepth, TEXSLOT_LINEARDEPTH, cmd); - device->BindResource(CS, &entityTiles_Opaque, TEXSLOT_RENDERPATH_ENTITYTILES, cmd); + device->BindResource(&entityTiles_Opaque, TEXSLOT_RENDERPATH_ENTITYTILES, cmd); - device->BindResource(CS, &gbuffer[GBUFFER_COLOR], TEXSLOT_GBUFFER0, cmd); - device->BindResource(CS, &gbuffer[GBUFFER_NORMAL_ROUGHNESS], TEXSLOT_GBUFFER1, cmd); - device->BindResource(CS, &gbuffer[GBUFFER_VELOCITY], TEXSLOT_GBUFFER2, cmd); + device->BindResource(&gbuffer[GBUFFER_PRIMITIVEID], TEXSLOT_GBUFFER0, cmd); + device->BindResource(&gbuffer[GBUFFER_VELOCITY], TEXSLOT_GBUFFER1, cmd); const GPUResource* uavs[] = { &res.temp, &res.normals, &res.tiles }; - device->BindUAVs(CS, uavs, 0, arraysize(uavs), cmd); + device->BindUAVs(uavs, 0, arraysize(uavs), cmd); { GPUBarrier barriers[] = { - GPUBarrier::Image(&res.temp, res.temp.desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS), - GPUBarrier::Image(&res.normals, res.normals.desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS), - GPUBarrier::Buffer(&res.tiles, BUFFER_STATE_SHADER_RESOURCE_COMPUTE, BUFFER_STATE_UNORDERED_ACCESS), + GPUBarrier::Image(&res.temp, res.temp.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS), + GPUBarrier::Image(&res.normals, res.normals.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS), + GPUBarrier::Buffer(&res.tiles, RESOURCE_STATE_SHADER_RESOURCE_COMPUTE, RESOURCE_STATE_UNORDERED_ACCESS), }; device->Barrier(barriers, arraysize(barriers), cmd); } @@ -10145,13 +9749,12 @@ void Postprocess_RTShadow( { GPUBarrier barriers[] = { GPUBarrier::Memory(), - GPUBarrier::Image(&res.normals, IMAGE_LAYOUT_UNORDERED_ACCESS, res.normals.desc.layout), - GPUBarrier::Buffer(&res.tiles, BUFFER_STATE_UNORDERED_ACCESS, BUFFER_STATE_SHADER_RESOURCE_COMPUTE), + GPUBarrier::Image(&res.normals, RESOURCE_STATE_UNORDERED_ACCESS, res.normals.desc.layout), + GPUBarrier::Buffer(&res.tiles, RESOURCE_STATE_UNORDERED_ACCESS, RESOURCE_STATE_SHADER_RESOURCE_COMPUTE), }; device->Barrier(barriers, arraysize(barriers), cmd); } - device->UnbindUAVs(0, arraysize(uavs), cmd); device->EventEnd(cmd); int temporal_output = res.frame % 2; @@ -10162,18 +9765,18 @@ void Postprocess_RTShadow( device->EventBegin("Denoise - Tile Classification", cmd); device->BindComputeShader(&shaders[CSTYPE_POSTPROCESS_RTSHADOW_DENOISE_TILECLASSIFICATION], cmd); - device->BindResource(CS, &depthbuffer, TEXSLOT_DEPTH, cmd); - device->BindResource(CS, &res.normals, TEXSLOT_ONDEMAND0, cmd); - device->BindResource(CS, &depth_history, TEXSLOT_ONDEMAND1, cmd); - device->BindResource(CS, &res.tiles, TEXSLOT_ONDEMAND2, cmd); - device->BindResource(CS, &res.moments[0][temporal_history], TEXSLOT_ONDEMAND3, cmd); - device->BindResource(CS, &res.moments[1][temporal_history], TEXSLOT_ONDEMAND4, cmd); - device->BindResource(CS, &res.moments[2][temporal_history], TEXSLOT_ONDEMAND5, cmd); - device->BindResource(CS, &res.moments[3][temporal_history], TEXSLOT_ONDEMAND6, cmd); - device->BindResource(CS, &res.scratch[0][1], TEXSLOT_ONDEMAND7, cmd); - device->BindResource(CS, &res.scratch[1][1], TEXSLOT_ONDEMAND8, cmd); - device->BindResource(CS, &res.scratch[2][1], TEXSLOT_ONDEMAND9, cmd); - device->BindResource(CS, &res.scratch[3][1], TEXSLOT_ONDEMAND10, cmd); + device->BindResource(&depthbuffer, TEXSLOT_DEPTH, cmd); + device->BindResource(&res.normals, TEXSLOT_ONDEMAND0, cmd); + device->BindResource(&depth_history, TEXSLOT_ONDEMAND1, cmd); + device->BindResource(&res.tiles, TEXSLOT_ONDEMAND2, cmd); + device->BindResource(&res.moments[0][temporal_history], TEXSLOT_ONDEMAND3, cmd); + device->BindResource(&res.moments[1][temporal_history], TEXSLOT_ONDEMAND4, cmd); + device->BindResource(&res.moments[2][temporal_history], TEXSLOT_ONDEMAND5, cmd); + device->BindResource(&res.moments[3][temporal_history], TEXSLOT_ONDEMAND6, cmd); + device->BindResource(&res.scratch[0][1], TEXSLOT_ONDEMAND7, cmd); + device->BindResource(&res.scratch[1][1], TEXSLOT_ONDEMAND8, cmd); + device->BindResource(&res.scratch[2][1], TEXSLOT_ONDEMAND9, cmd); + device->BindResource(&res.scratch[3][1], TEXSLOT_ONDEMAND10, cmd); const GPUResource* uavs[] = { &res.metadata, @@ -10186,19 +9789,19 @@ void Postprocess_RTShadow( &res.moments[2][temporal_output], &res.moments[3][temporal_output], }; - device->BindUAVs(CS, uavs, 0, arraysize(uavs), cmd); + device->BindUAVs(uavs, 0, arraysize(uavs), cmd); { GPUBarrier barriers[] = { - GPUBarrier::Buffer(&res.metadata, BUFFER_STATE_SHADER_RESOURCE_COMPUTE, BUFFER_STATE_UNORDERED_ACCESS), - GPUBarrier::Image(&res.scratch[0][0], res.scratch[0][0].desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS), - GPUBarrier::Image(&res.scratch[1][0], res.scratch[1][0].desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS), - GPUBarrier::Image(&res.scratch[2][0], res.scratch[2][0].desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS), - GPUBarrier::Image(&res.scratch[3][0], res.scratch[3][0].desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS), - GPUBarrier::Image(&res.moments[0][temporal_output], res.moments[0][temporal_output].desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS), - GPUBarrier::Image(&res.moments[1][temporal_output], res.moments[1][temporal_output].desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS), - GPUBarrier::Image(&res.moments[2][temporal_output], res.moments[2][temporal_output].desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS), - GPUBarrier::Image(&res.moments[3][temporal_output], res.moments[3][temporal_output].desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS), + GPUBarrier::Buffer(&res.metadata, RESOURCE_STATE_SHADER_RESOURCE_COMPUTE, RESOURCE_STATE_UNORDERED_ACCESS), + GPUBarrier::Image(&res.scratch[0][0], res.scratch[0][0].desc.layout, RESOURCE_STATE_UNORDERED_ACCESS), + GPUBarrier::Image(&res.scratch[1][0], res.scratch[1][0].desc.layout, RESOURCE_STATE_UNORDERED_ACCESS), + GPUBarrier::Image(&res.scratch[2][0], res.scratch[2][0].desc.layout, RESOURCE_STATE_UNORDERED_ACCESS), + GPUBarrier::Image(&res.scratch[3][0], res.scratch[3][0].desc.layout, RESOURCE_STATE_UNORDERED_ACCESS), + GPUBarrier::Image(&res.moments[0][temporal_output], res.moments[0][temporal_output].desc.layout, RESOURCE_STATE_UNORDERED_ACCESS), + GPUBarrier::Image(&res.moments[1][temporal_output], res.moments[1][temporal_output].desc.layout, RESOURCE_STATE_UNORDERED_ACCESS), + GPUBarrier::Image(&res.moments[2][temporal_output], res.moments[2][temporal_output].desc.layout, RESOURCE_STATE_UNORDERED_ACCESS), + GPUBarrier::Image(&res.moments[3][temporal_output], res.moments[3][temporal_output].desc.layout, RESOURCE_STATE_UNORDERED_ACCESS), }; device->Barrier(barriers, arraysize(barriers), cmd); } @@ -10213,20 +9816,19 @@ void Postprocess_RTShadow( { GPUBarrier barriers[] = { GPUBarrier::Memory(), - GPUBarrier::Buffer(&res.metadata, BUFFER_STATE_UNORDERED_ACCESS, BUFFER_STATE_SHADER_RESOURCE_COMPUTE), - GPUBarrier::Image(&res.scratch[0][0], IMAGE_LAYOUT_UNORDERED_ACCESS, res.scratch[0][0].desc.layout), - GPUBarrier::Image(&res.scratch[1][0], IMAGE_LAYOUT_UNORDERED_ACCESS, res.scratch[1][0].desc.layout), - GPUBarrier::Image(&res.scratch[2][0], IMAGE_LAYOUT_UNORDERED_ACCESS, res.scratch[2][0].desc.layout), - GPUBarrier::Image(&res.scratch[3][0], IMAGE_LAYOUT_UNORDERED_ACCESS, res.scratch[3][0].desc.layout), - GPUBarrier::Image(&res.moments[0][temporal_output], IMAGE_LAYOUT_UNORDERED_ACCESS, res.moments[0][temporal_output].desc.layout), - GPUBarrier::Image(&res.moments[1][temporal_output], IMAGE_LAYOUT_UNORDERED_ACCESS, res.moments[1][temporal_output].desc.layout), - GPUBarrier::Image(&res.moments[2][temporal_output], IMAGE_LAYOUT_UNORDERED_ACCESS, res.moments[2][temporal_output].desc.layout), - GPUBarrier::Image(&res.moments[3][temporal_output], IMAGE_LAYOUT_UNORDERED_ACCESS, res.moments[3][temporal_output].desc.layout), + GPUBarrier::Buffer(&res.metadata, RESOURCE_STATE_UNORDERED_ACCESS, RESOURCE_STATE_SHADER_RESOURCE_COMPUTE), + GPUBarrier::Image(&res.scratch[0][0], RESOURCE_STATE_UNORDERED_ACCESS, res.scratch[0][0].desc.layout), + GPUBarrier::Image(&res.scratch[1][0], RESOURCE_STATE_UNORDERED_ACCESS, res.scratch[1][0].desc.layout), + GPUBarrier::Image(&res.scratch[2][0], RESOURCE_STATE_UNORDERED_ACCESS, res.scratch[2][0].desc.layout), + GPUBarrier::Image(&res.scratch[3][0], RESOURCE_STATE_UNORDERED_ACCESS, res.scratch[3][0].desc.layout), + GPUBarrier::Image(&res.moments[0][temporal_output], RESOURCE_STATE_UNORDERED_ACCESS, res.moments[0][temporal_output].desc.layout), + GPUBarrier::Image(&res.moments[1][temporal_output], RESOURCE_STATE_UNORDERED_ACCESS, res.moments[1][temporal_output].desc.layout), + GPUBarrier::Image(&res.moments[2][temporal_output], RESOURCE_STATE_UNORDERED_ACCESS, res.moments[2][temporal_output].desc.layout), + GPUBarrier::Image(&res.moments[3][temporal_output], RESOURCE_STATE_UNORDERED_ACCESS, res.moments[3][temporal_output].desc.layout), }; device->Barrier(barriers, arraysize(barriers), cmd); } - device->UnbindUAVs(0, arraysize(uavs), cmd); device->EventEnd(cmd); } @@ -10235,16 +9837,16 @@ void Postprocess_RTShadow( device->EventBegin("Denoise - Filter", cmd); device->BindComputeShader(&shaders[CSTYPE_POSTPROCESS_RTSHADOW_DENOISE_FILTER], cmd); - device->BindResource(CS, &depthbuffer, TEXSLOT_DEPTH, cmd); - device->BindResource(CS, &res.normals, TEXSLOT_ONDEMAND0, cmd); - device->BindResource(CS, &res.metadata, TEXSLOT_ONDEMAND1, cmd); + device->BindResource(&depthbuffer, TEXSLOT_DEPTH, cmd); + device->BindResource(&res.normals, TEXSLOT_ONDEMAND0, cmd); + device->BindResource(&res.metadata, TEXSLOT_ONDEMAND1, cmd); // pass0: { - device->BindResource(CS, &res.scratch[0][0], TEXSLOT_ONDEMAND2, cmd); - device->BindResource(CS, &res.scratch[1][0], TEXSLOT_ONDEMAND3, cmd); - device->BindResource(CS, &res.scratch[2][0], TEXSLOT_ONDEMAND4, cmd); - device->BindResource(CS, &res.scratch[3][0], TEXSLOT_ONDEMAND5, cmd); + device->BindResource(&res.scratch[0][0], TEXSLOT_ONDEMAND2, cmd); + device->BindResource(&res.scratch[1][0], TEXSLOT_ONDEMAND3, cmd); + device->BindResource(&res.scratch[2][0], TEXSLOT_ONDEMAND4, cmd); + device->BindResource(&res.scratch[3][0], TEXSLOT_ONDEMAND5, cmd); const GPUResource* uavs[] = { &res.scratch[0][1], &res.scratch[1][1], @@ -10252,22 +9854,21 @@ void Postprocess_RTShadow( &res.scratch[3][1], &res.denoised }; - device->BindUAVs(CS, uavs, 0, arraysize(uavs), cmd); + device->BindUAVs(uavs, 0, arraysize(uavs), cmd); { GPUBarrier barriers[] = { - GPUBarrier::Image(&res.scratch[0][1], res.scratch[0][1].desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS), - GPUBarrier::Image(&res.scratch[1][1], res.scratch[1][1].desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS), - GPUBarrier::Image(&res.scratch[2][1], res.scratch[2][1].desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS), - GPUBarrier::Image(&res.scratch[3][1], res.scratch[3][1].desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS), - GPUBarrier::Image(&res.denoised, res.denoised.desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS), + GPUBarrier::Image(&res.scratch[0][1], res.scratch[0][1].desc.layout, RESOURCE_STATE_UNORDERED_ACCESS), + GPUBarrier::Image(&res.scratch[1][1], res.scratch[1][1].desc.layout, RESOURCE_STATE_UNORDERED_ACCESS), + GPUBarrier::Image(&res.scratch[2][1], res.scratch[2][1].desc.layout, RESOURCE_STATE_UNORDERED_ACCESS), + GPUBarrier::Image(&res.scratch[3][1], res.scratch[3][1].desc.layout, RESOURCE_STATE_UNORDERED_ACCESS), + GPUBarrier::Image(&res.denoised, res.denoised.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS), }; device->Barrier(barriers, arraysize(barriers), cmd); } cb.xPPParams1.x = 0; cb.xPPParams1.y = 1; - device->UpdateBuffer(&constantBuffers[CBTYPE_POSTPROCESS], &cb, cmd); - device->BindConstantBuffer(CS, &constantBuffers[CBTYPE_POSTPROCESS], CB_GETBINDSLOT(PostProcessCB), cmd); + device->BindDynamicConstantBuffer(cb, CB_GETBINDSLOT(PostProcessCB), cmd); device->Dispatch( (desc.Width + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE, @@ -10279,10 +9880,10 @@ void Postprocess_RTShadow( // pass1: { - device->BindResource(CS, &res.scratch[0][1], TEXSLOT_ONDEMAND2, cmd); - device->BindResource(CS, &res.scratch[1][1], TEXSLOT_ONDEMAND3, cmd); - device->BindResource(CS, &res.scratch[2][1], TEXSLOT_ONDEMAND4, cmd); - device->BindResource(CS, &res.scratch[3][1], TEXSLOT_ONDEMAND5, cmd); + device->BindResource(&res.scratch[0][1], TEXSLOT_ONDEMAND2, cmd); + device->BindResource(&res.scratch[1][1], TEXSLOT_ONDEMAND3, cmd); + device->BindResource(&res.scratch[2][1], TEXSLOT_ONDEMAND4, cmd); + device->BindResource(&res.scratch[3][1], TEXSLOT_ONDEMAND5, cmd); const GPUResource* uavs[] = { &res.scratch[0][0], &res.scratch[1][0], @@ -10290,26 +9891,25 @@ void Postprocess_RTShadow( &res.scratch[3][0], &res.denoised }; - device->BindUAVs(CS, uavs, 0, arraysize(uavs), cmd); + device->BindUAVs(uavs, 0, arraysize(uavs), cmd); { GPUBarrier barriers[] = { GPUBarrier::Memory(), - GPUBarrier::Image(&res.scratch[0][1], IMAGE_LAYOUT_UNORDERED_ACCESS, res.scratch[0][1].desc.layout), - GPUBarrier::Image(&res.scratch[1][1], IMAGE_LAYOUT_UNORDERED_ACCESS, res.scratch[1][1].desc.layout), - GPUBarrier::Image(&res.scratch[2][1], IMAGE_LAYOUT_UNORDERED_ACCESS, res.scratch[2][1].desc.layout), - GPUBarrier::Image(&res.scratch[3][1], IMAGE_LAYOUT_UNORDERED_ACCESS, res.scratch[3][1].desc.layout), - GPUBarrier::Image(&res.scratch[0][0], res.scratch[0][0].desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS), - GPUBarrier::Image(&res.scratch[1][0], res.scratch[1][0].desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS), - GPUBarrier::Image(&res.scratch[2][0], res.scratch[2][0].desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS), - GPUBarrier::Image(&res.scratch[3][0], res.scratch[3][0].desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS), + GPUBarrier::Image(&res.scratch[0][1], RESOURCE_STATE_UNORDERED_ACCESS, res.scratch[0][1].desc.layout), + GPUBarrier::Image(&res.scratch[1][1], RESOURCE_STATE_UNORDERED_ACCESS, res.scratch[1][1].desc.layout), + GPUBarrier::Image(&res.scratch[2][1], RESOURCE_STATE_UNORDERED_ACCESS, res.scratch[2][1].desc.layout), + GPUBarrier::Image(&res.scratch[3][1], RESOURCE_STATE_UNORDERED_ACCESS, res.scratch[3][1].desc.layout), + GPUBarrier::Image(&res.scratch[0][0], res.scratch[0][0].desc.layout, RESOURCE_STATE_UNORDERED_ACCESS), + GPUBarrier::Image(&res.scratch[1][0], res.scratch[1][0].desc.layout, RESOURCE_STATE_UNORDERED_ACCESS), + GPUBarrier::Image(&res.scratch[2][0], res.scratch[2][0].desc.layout, RESOURCE_STATE_UNORDERED_ACCESS), + GPUBarrier::Image(&res.scratch[3][0], res.scratch[3][0].desc.layout, RESOURCE_STATE_UNORDERED_ACCESS), }; device->Barrier(barriers, arraysize(barriers), cmd); } cb.xPPParams1.x = 1; cb.xPPParams1.y = 2; - device->UpdateBuffer(&constantBuffers[CBTYPE_POSTPROCESS], &cb, cmd); - device->BindConstantBuffer(CS, &constantBuffers[CBTYPE_POSTPROCESS], CB_GETBINDSLOT(PostProcessCB), cmd); + device->BindDynamicConstantBuffer(cb, CB_GETBINDSLOT(PostProcessCB), cmd); device->Dispatch( (desc.Width + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE, @@ -10321,10 +9921,10 @@ void Postprocess_RTShadow( // pass2: { - device->BindResource(CS, &res.scratch[0][0], TEXSLOT_ONDEMAND2, cmd); - device->BindResource(CS, &res.scratch[1][0], TEXSLOT_ONDEMAND3, cmd); - device->BindResource(CS, &res.scratch[2][0], TEXSLOT_ONDEMAND4, cmd); - device->BindResource(CS, &res.scratch[3][0], TEXSLOT_ONDEMAND5, cmd); + device->BindResource(&res.scratch[0][0], TEXSLOT_ONDEMAND2, cmd); + device->BindResource(&res.scratch[1][0], TEXSLOT_ONDEMAND3, cmd); + device->BindResource(&res.scratch[2][0], TEXSLOT_ONDEMAND4, cmd); + device->BindResource(&res.scratch[3][0], TEXSLOT_ONDEMAND5, cmd); const GPUResource* uavs[] = { &res.scratch[0][1], &res.scratch[1][1], @@ -10332,26 +9932,25 @@ void Postprocess_RTShadow( &res.scratch[3][1], &res.denoised }; - device->BindUAVs(CS, uavs, 0, arraysize(uavs), cmd); + device->BindUAVs(uavs, 0, arraysize(uavs), cmd); { GPUBarrier barriers[] = { GPUBarrier::Memory(), - GPUBarrier::Image(&res.scratch[0][0], IMAGE_LAYOUT_UNORDERED_ACCESS, res.scratch[0][0].desc.layout), - GPUBarrier::Image(&res.scratch[1][0], IMAGE_LAYOUT_UNORDERED_ACCESS, res.scratch[1][0].desc.layout), - GPUBarrier::Image(&res.scratch[2][0], IMAGE_LAYOUT_UNORDERED_ACCESS, res.scratch[2][0].desc.layout), - GPUBarrier::Image(&res.scratch[3][0], IMAGE_LAYOUT_UNORDERED_ACCESS, res.scratch[3][0].desc.layout), - GPUBarrier::Image(&res.scratch[0][1], res.scratch[0][0].desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS), - GPUBarrier::Image(&res.scratch[1][1], res.scratch[1][0].desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS), - GPUBarrier::Image(&res.scratch[2][1], res.scratch[2][0].desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS), - GPUBarrier::Image(&res.scratch[3][1], res.scratch[3][0].desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS), + GPUBarrier::Image(&res.scratch[0][0], RESOURCE_STATE_UNORDERED_ACCESS, res.scratch[0][0].desc.layout), + GPUBarrier::Image(&res.scratch[1][0], RESOURCE_STATE_UNORDERED_ACCESS, res.scratch[1][0].desc.layout), + GPUBarrier::Image(&res.scratch[2][0], RESOURCE_STATE_UNORDERED_ACCESS, res.scratch[2][0].desc.layout), + GPUBarrier::Image(&res.scratch[3][0], RESOURCE_STATE_UNORDERED_ACCESS, res.scratch[3][0].desc.layout), + GPUBarrier::Image(&res.scratch[0][1], res.scratch[0][0].desc.layout, RESOURCE_STATE_UNORDERED_ACCESS), + GPUBarrier::Image(&res.scratch[1][1], res.scratch[1][0].desc.layout, RESOURCE_STATE_UNORDERED_ACCESS), + GPUBarrier::Image(&res.scratch[2][1], res.scratch[2][0].desc.layout, RESOURCE_STATE_UNORDERED_ACCESS), + GPUBarrier::Image(&res.scratch[3][1], res.scratch[3][0].desc.layout, RESOURCE_STATE_UNORDERED_ACCESS), }; device->Barrier(barriers, arraysize(barriers), cmd); } cb.xPPParams1.x = 2; cb.xPPParams1.y = 4; - device->UpdateBuffer(&constantBuffers[CBTYPE_POSTPROCESS], &cb, cmd); - device->BindConstantBuffer(CS, &constantBuffers[CBTYPE_POSTPROCESS], CB_GETBINDSLOT(PostProcessCB), cmd); + device->BindDynamicConstantBuffer(cb, CB_GETBINDSLOT(PostProcessCB), cmd); device->Dispatch( (desc.Width + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE, @@ -10364,16 +9963,15 @@ void Postprocess_RTShadow( { GPUBarrier barriers[] = { GPUBarrier::Memory(), - GPUBarrier::Image(&res.scratch[0][1], IMAGE_LAYOUT_UNORDERED_ACCESS, res.scratch[0][1].desc.layout), - GPUBarrier::Image(&res.scratch[1][1], IMAGE_LAYOUT_UNORDERED_ACCESS, res.scratch[1][1].desc.layout), - GPUBarrier::Image(&res.scratch[2][1], IMAGE_LAYOUT_UNORDERED_ACCESS, res.scratch[2][1].desc.layout), - GPUBarrier::Image(&res.scratch[3][1], IMAGE_LAYOUT_UNORDERED_ACCESS, res.scratch[3][1].desc.layout), - GPUBarrier::Image(&res.denoised, IMAGE_LAYOUT_UNORDERED_ACCESS, res.denoised.desc.layout), + GPUBarrier::Image(&res.scratch[0][1], RESOURCE_STATE_UNORDERED_ACCESS, res.scratch[0][1].desc.layout), + GPUBarrier::Image(&res.scratch[1][1], RESOURCE_STATE_UNORDERED_ACCESS, res.scratch[1][1].desc.layout), + GPUBarrier::Image(&res.scratch[2][1], RESOURCE_STATE_UNORDERED_ACCESS, res.scratch[2][1].desc.layout), + GPUBarrier::Image(&res.scratch[3][1], RESOURCE_STATE_UNORDERED_ACCESS, res.scratch[3][1].desc.layout), + GPUBarrier::Image(&res.denoised, RESOURCE_STATE_UNORDERED_ACCESS, res.denoised.desc.layout), }; device->Barrier(barriers, arraysize(barriers), cmd); } - device->UnbindUAVs(0, arraysize(uavs), cmd); device->EventEnd(cmd); } res.frame++; @@ -10383,23 +9981,23 @@ void Postprocess_RTShadow( device->EventBegin("Temporal Denoise", cmd); device->BindComputeShader(&shaders[CSTYPE_POSTPROCESS_RTSHADOW_DENOISE_TEMPORAL], cmd); - device->BindResource(CS, &depthbuffer, TEXSLOT_DEPTH, cmd); - device->BindResource(CS, &res.temp, TEXSLOT_ONDEMAND0, cmd); - device->BindResource(CS, &res.temporal[temporal_history], TEXSLOT_ONDEMAND1, cmd); - device->BindResource(CS, &depth_history, TEXSLOT_ONDEMAND2, cmd); - device->BindResource(CS, &res.denoised, TEXSLOT_ONDEMAND3, cmd); + device->BindResource(&depthbuffer, TEXSLOT_DEPTH, cmd); + device->BindResource(&res.temp, TEXSLOT_ONDEMAND0, cmd); + device->BindResource(&res.temporal[temporal_history], TEXSLOT_ONDEMAND1, cmd); + device->BindResource(&depth_history, TEXSLOT_ONDEMAND2, cmd); + device->BindResource(&res.denoised, TEXSLOT_ONDEMAND3, cmd); const GPUResource* uavs[] = { &res.temporal[temporal_output], &output, }; - device->BindUAVs(CS, uavs, 0, arraysize(uavs), cmd); + device->BindUAVs(uavs, 0, arraysize(uavs), cmd); { GPUBarrier barriers[] = { - GPUBarrier::Image(&res.temp, IMAGE_LAYOUT_UNORDERED_ACCESS, res.temp.desc.layout), - GPUBarrier::Image(&res.temporal[temporal_output], res.temporal[temporal_output].desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS), - GPUBarrier::Image(&output, output.desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS), + GPUBarrier::Image(&res.temp, RESOURCE_STATE_UNORDERED_ACCESS, res.temp.desc.layout), + GPUBarrier::Image(&res.temporal[temporal_output], res.temporal[temporal_output].desc.layout, RESOURCE_STATE_UNORDERED_ACCESS), + GPUBarrier::Image(&output, output.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS), }; device->Barrier(barriers, arraysize(barriers), cmd); } @@ -10414,13 +10012,12 @@ void Postprocess_RTShadow( { GPUBarrier barriers[] = { GPUBarrier::Memory(), - GPUBarrier::Image(&res.temporal[temporal_output], IMAGE_LAYOUT_UNORDERED_ACCESS, res.temporal[temporal_output].desc.layout), - GPUBarrier::Image(&output, IMAGE_LAYOUT_UNORDERED_ACCESS, output.desc.layout), + GPUBarrier::Image(&res.temporal[temporal_output], RESOURCE_STATE_UNORDERED_ACCESS, res.temporal[temporal_output].desc.layout), + GPUBarrier::Image(&output, RESOURCE_STATE_UNORDERED_ACCESS, output.desc.layout), }; device->Barrier(barriers, arraysize(barriers), cmd); } - device->UnbindUAVs(0, arraysize(uavs), cmd); device->EventEnd(cmd); } @@ -10435,6 +10032,7 @@ void Postprocess_ScreenSpaceShadow( const Texture& depthbuffer, const Texture& lineardepth, const GPUBuffer& entityTiles_Opaque, + const Texture gbuffer[GBUFFER_COUNT], const Texture& output, CommandList cmd, float range, @@ -10453,24 +10051,26 @@ void Postprocess_ScreenSpaceShadow( cb.xPPResolution_rcp.y = 1.0f / cb.xPPResolution.y; cb.xPPParams0.x = range; cb.xPPParams0.y = (float)samplecount; - device->UpdateBuffer(&constantBuffers[CBTYPE_POSTPROCESS], &cb, cmd); - device->BindConstantBuffer(CS, &constantBuffers[CBTYPE_POSTPROCESS], CB_GETBINDSLOT(PostProcessCB), cmd); + device->BindDynamicConstantBuffer(cb, CB_GETBINDSLOT(PostProcessCB), cmd); device->BindComputeShader(&shaders[CSTYPE_POSTPROCESS_SCREENSPACESHADOW], cmd); - device->BindResource(CS, &depthbuffer, TEXSLOT_DEPTH, cmd); - device->BindResource(CS, &lineardepth, TEXSLOT_LINEARDEPTH, cmd); + device->BindResource(&depthbuffer, TEXSLOT_DEPTH, cmd); + device->BindResource(&lineardepth, TEXSLOT_LINEARDEPTH, cmd); - device->BindResource(CS, &entityTiles_Opaque, TEXSLOT_RENDERPATH_ENTITYTILES, cmd); + device->BindResource(&entityTiles_Opaque, TEXSLOT_RENDERPATH_ENTITYTILES, cmd); + + device->BindResource(&gbuffer[GBUFFER_PRIMITIVEID], TEXSLOT_GBUFFER0, cmd); + device->BindResource(&gbuffer[GBUFFER_VELOCITY], TEXSLOT_GBUFFER1, cmd); const GPUResource* uavs[] = { &output, }; - device->BindUAVs(CS, uavs, 0, arraysize(uavs), cmd); + device->BindUAVs(uavs, 0, arraysize(uavs), cmd); { GPUBarrier barriers[] = { - GPUBarrier::Image(&output, output.desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS), + GPUBarrier::Image(&output, output.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS), }; device->Barrier(barriers, arraysize(barriers), cmd); } @@ -10485,12 +10085,11 @@ void Postprocess_ScreenSpaceShadow( { GPUBarrier barriers[] = { GPUBarrier::Memory(), - GPUBarrier::Image(&output, IMAGE_LAYOUT_UNORDERED_ACCESS, output.desc.layout), + GPUBarrier::Image(&output, RESOURCE_STATE_UNORDERED_ACCESS, output.desc.layout), }; device->Barrier(barriers, arraysize(barriers), cmd); } - device->UnbindUAVs(0, arraysize(uavs), cmd); wiProfiler::EndRange(prof_range); device->EventEnd(cmd); @@ -10507,7 +10106,7 @@ void Postprocess_LightShafts( device->BindComputeShader(&shaders[CSTYPE_POSTPROCESS_LIGHTSHAFTS], cmd); - device->BindResource(CS, &input, TEXSLOT_ONDEMAND0, cmd); + device->BindResource(&input, TEXSLOT_ONDEMAND0, cmd); const TextureDesc& desc = output.GetDesc(); @@ -10522,17 +10121,16 @@ void Postprocess_LightShafts( cb.xPPParams0.w = 0.2f; // exposure cb.xPPParams1.x = center.x; cb.xPPParams1.y = center.y; - device->UpdateBuffer(&constantBuffers[CBTYPE_POSTPROCESS], &cb, cmd); - device->BindConstantBuffer(CS, &constantBuffers[CBTYPE_POSTPROCESS], CB_GETBINDSLOT(PostProcessCB), cmd); + device->BindDynamicConstantBuffer(cb, CB_GETBINDSLOT(PostProcessCB), cmd); const GPUResource* uavs[] = { &output, }; - device->BindUAVs(CS, uavs, 0, arraysize(uavs), cmd); + device->BindUAVs(uavs, 0, arraysize(uavs), cmd); { GPUBarrier barriers[] = { - GPUBarrier::Image(&output, output.desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS), + GPUBarrier::Image(&output, output.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS), }; device->Barrier(barriers, arraysize(barriers), cmd); } @@ -10547,12 +10145,11 @@ void Postprocess_LightShafts( { GPUBarrier barriers[] = { GPUBarrier::Memory(), - GPUBarrier::Image(&output, IMAGE_LAYOUT_UNORDERED_ACCESS, output.desc.layout), + GPUBarrier::Image(&output, RESOURCE_STATE_UNORDERED_ACCESS, output.desc.layout), }; device->Barrier(barriers, arraysize(barriers), cmd); } - device->UnbindUAVs(0, arraysize(uavs), cmd); wiProfiler::EndRange(range); device->EventEnd(cmd); @@ -10595,7 +10192,7 @@ void CreateDepthOfFieldResources(DepthOfFieldResources& res, XMUINT2 resolution) bufferdesc.BindFlags = BIND_SHADER_RESOURCE | BIND_UNORDERED_ACCESS; bufferdesc.ByteWidth = TILE_STATISTICS_CAPACITY * sizeof(uint); - bufferdesc.MiscFlags = RESOURCE_MISC_BUFFER_ALLOW_RAW_VIEWS | RESOURCE_MISC_INDIRECT_ARGS; + bufferdesc.MiscFlags = RESOURCE_MISC_BUFFER_RAW | RESOURCE_MISC_INDIRECT_ARGS; device->CreateBuffer(&bufferdesc, nullptr, &res.buffer_tile_statistics); bufferdesc.MiscFlags = RESOURCE_MISC_BUFFER_STRUCTURED; @@ -10618,7 +10215,7 @@ void Postprocess_DepthOfField( device->EventBegin("Postprocess_DepthOfField", cmd); auto range = wiProfiler::BeginRangeGPU("Depth of Field", cmd); - device->BindResource(CS, &lineardepth, TEXSLOT_LINEARDEPTH, cmd); + device->BindResource(&lineardepth, TEXSLOT_LINEARDEPTH, cmd); const TextureDesc& desc = output.GetDesc(); @@ -10629,8 +10226,7 @@ void Postprocess_DepthOfField( cb.xPPResolution_rcp.y = 1.0f / cb.xPPResolution.y; cb.dof_cocscale = coc_scale; cb.dof_maxcoc = max_coc; - device->UpdateBuffer(&constantBuffers[CBTYPE_POSTPROCESS], &cb, cmd); - device->BindConstantBuffer(CS, &constantBuffers[CBTYPE_POSTPROCESS], CB_GETBINDSLOT(PostProcessCB), cmd); + device->BindDynamicConstantBuffer(cb, CB_GETBINDSLOT(PostProcessCB), cmd); // Compute tile max COC (horizontal): { @@ -10641,12 +10237,12 @@ void Postprocess_DepthOfField( &res.texture_tilemax_horizontal, &res.texture_tilemin_horizontal, }; - device->BindUAVs(CS, uavs, 0, arraysize(uavs), cmd); + device->BindUAVs(uavs, 0, arraysize(uavs), cmd); { GPUBarrier barriers[] = { - GPUBarrier::Image(&res.texture_tilemax_horizontal, res.texture_tilemax_horizontal.desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS), - GPUBarrier::Image(&res.texture_tilemin_horizontal, res.texture_tilemin_horizontal.desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS), + GPUBarrier::Image(&res.texture_tilemax_horizontal, res.texture_tilemax_horizontal.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS), + GPUBarrier::Image(&res.texture_tilemin_horizontal, res.texture_tilemin_horizontal.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS), }; device->Barrier(barriers, arraysize(barriers), cmd); } @@ -10661,13 +10257,12 @@ void Postprocess_DepthOfField( { GPUBarrier barriers[] = { GPUBarrier::Memory(), - GPUBarrier::Image(&res.texture_tilemax_horizontal, IMAGE_LAYOUT_UNORDERED_ACCESS, res.texture_tilemax_horizontal.desc.layout), - GPUBarrier::Image(&res.texture_tilemin_horizontal, IMAGE_LAYOUT_UNORDERED_ACCESS, res.texture_tilemin_horizontal.desc.layout), + GPUBarrier::Image(&res.texture_tilemax_horizontal, RESOURCE_STATE_UNORDERED_ACCESS, res.texture_tilemax_horizontal.desc.layout), + GPUBarrier::Image(&res.texture_tilemin_horizontal, RESOURCE_STATE_UNORDERED_ACCESS, res.texture_tilemin_horizontal.desc.layout), }; device->Barrier(barriers, arraysize(barriers), cmd); } - device->UnbindUAVs(0, arraysize(uavs), cmd); device->EventEnd(cmd); } @@ -10680,18 +10275,18 @@ void Postprocess_DepthOfField( &res.texture_tilemax_horizontal, &res.texture_tilemin_horizontal }; - device->BindResources(CS, resarray, TEXSLOT_ONDEMAND0, arraysize(resarray), cmd); + device->BindResources(resarray, TEXSLOT_ONDEMAND0, arraysize(resarray), cmd); const GPUResource* uavs[] = { &res.texture_tilemax, &res.texture_tilemin, }; - device->BindUAVs(CS, uavs, 0, arraysize(uavs), cmd); + device->BindUAVs(uavs, 0, arraysize(uavs), cmd); { GPUBarrier barriers[] = { - GPUBarrier::Image(&res.texture_tilemax, res.texture_tilemax.desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS), - GPUBarrier::Image(&res.texture_tilemin, res.texture_tilemin.desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS), + GPUBarrier::Image(&res.texture_tilemax, res.texture_tilemax.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS), + GPUBarrier::Image(&res.texture_tilemin, res.texture_tilemin.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS), }; device->Barrier(barriers, arraysize(barriers), cmd); } @@ -10706,13 +10301,12 @@ void Postprocess_DepthOfField( { GPUBarrier barriers[] = { GPUBarrier::Memory(), - GPUBarrier::Image(&res.texture_tilemax, IMAGE_LAYOUT_UNORDERED_ACCESS, res.texture_tilemax.desc.layout), - GPUBarrier::Image(&res.texture_tilemin, IMAGE_LAYOUT_UNORDERED_ACCESS, res.texture_tilemin.desc.layout), + GPUBarrier::Image(&res.texture_tilemax, RESOURCE_STATE_UNORDERED_ACCESS, res.texture_tilemax.desc.layout), + GPUBarrier::Image(&res.texture_tilemin, RESOURCE_STATE_UNORDERED_ACCESS, res.texture_tilemin.desc.layout), }; device->Barrier(barriers, arraysize(barriers), cmd); } - device->UnbindUAVs(0, arraysize(uavs), cmd); device->EventEnd(cmd); } @@ -10725,7 +10319,7 @@ void Postprocess_DepthOfField( &res.texture_tilemax, &res.texture_tilemin }; - device->BindResources(CS, resarray, TEXSLOT_ONDEMAND0, arraysize(resarray), cmd); + device->BindResources(resarray, TEXSLOT_ONDEMAND0, arraysize(resarray), cmd); const GPUResource* uavs[] = { &res.buffer_tile_statistics, @@ -10734,11 +10328,11 @@ void Postprocess_DepthOfField( &res.buffer_tiles_expensive, &res.texture_neighborhoodmax }; - device->BindUAVs(CS, uavs, 0, arraysize(uavs), cmd); + device->BindUAVs(uavs, 0, arraysize(uavs), cmd); { GPUBarrier barriers[] = { - GPUBarrier::Image(&res.texture_neighborhoodmax, res.texture_neighborhoodmax.desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS), + GPUBarrier::Image(&res.texture_neighborhoodmax, res.texture_neighborhoodmax.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS), }; device->Barrier(barriers, arraysize(barriers), cmd); } @@ -10753,12 +10347,11 @@ void Postprocess_DepthOfField( { GPUBarrier barriers[] = { GPUBarrier::Memory(), - GPUBarrier::Image(&res.texture_neighborhoodmax, IMAGE_LAYOUT_UNORDERED_ACCESS, res.texture_neighborhoodmax.desc.layout), + GPUBarrier::Image(&res.texture_neighborhoodmax, RESOURCE_STATE_UNORDERED_ACCESS, res.texture_neighborhoodmax.desc.layout), }; device->Barrier(barriers, arraysize(barriers), cmd); } - device->UnbindUAVs(0, arraysize(uavs), cmd); device->EventEnd(cmd); } @@ -10767,7 +10360,7 @@ void Postprocess_DepthOfField( device->EventBegin("Kickjobs", cmd); device->BindComputeShader(&shaders[CSTYPE_POSTPROCESS_DEPTHOFFIELD_KICKJOBS], cmd); - device->BindResource(CS, &res.texture_tilemax, TEXSLOT_ONDEMAND0, cmd); + device->BindResource(&res.texture_tilemax, TEXSLOT_ONDEMAND0, cmd); const GPUResource* uavs[] = { &res.buffer_tile_statistics, @@ -10775,17 +10368,16 @@ void Postprocess_DepthOfField( &res.buffer_tiles_cheap, &res.buffer_tiles_expensive }; - device->BindUAVs(CS, uavs, 0, arraysize(uavs), cmd); + device->BindUAVs(uavs, 0, arraysize(uavs), cmd); device->Dispatch(1, 1, 1, cmd); GPUBarrier barriers[] = { GPUBarrier::Memory(), - GPUBarrier::Buffer(&res.buffer_tile_statistics, BUFFER_STATE_UNORDERED_ACCESS, BUFFER_STATE_INDIRECT_ARGUMENT), + GPUBarrier::Buffer(&res.buffer_tile_statistics, RESOURCE_STATE_UNORDERED_ACCESS, RESOURCE_STATE_INDIRECT_ARGUMENT), }; device->Barrier(barriers, arraysize(barriers), cmd); - device->UnbindUAVs(0, arraysize(uavs), cmd); device->EventEnd(cmd); } @@ -10794,8 +10386,7 @@ void Postprocess_DepthOfField( cb.xPPResolution.y = desc.Height / 2; cb.xPPResolution_rcp.x = 1.0f / cb.xPPResolution.x; cb.xPPResolution_rcp.y = 1.0f / cb.xPPResolution.y; - device->UpdateBuffer(&constantBuffers[CBTYPE_POSTPROCESS], &cb, cmd); - device->BindConstantBuffer(CS, &constantBuffers[CBTYPE_POSTPROCESS], CB_GETBINDSLOT(PostProcessCB), cmd); + device->BindDynamicConstantBuffer(cb, CB_GETBINDSLOT(PostProcessCB), cmd); // Prepass: { @@ -10805,47 +10396,46 @@ void Postprocess_DepthOfField( &input, &res.texture_neighborhoodmax, }; - device->BindResources(CS, resarray, TEXSLOT_ONDEMAND0, arraysize(resarray), cmd); + device->BindResources(resarray, TEXSLOT_ONDEMAND0, arraysize(resarray), cmd); const GPUResource* uavs[] = { &res.texture_presort, &res.texture_prefilter }; - device->BindUAVs(CS, uavs, 0, arraysize(uavs), cmd); + device->BindUAVs(uavs, 0, arraysize(uavs), cmd); { GPUBarrier barriers[] = { - GPUBarrier::Buffer(&res.buffer_tiles_earlyexit, BUFFER_STATE_UNORDERED_ACCESS, BUFFER_STATE_SHADER_RESOURCE), - GPUBarrier::Buffer(&res.buffer_tiles_cheap, BUFFER_STATE_UNORDERED_ACCESS, BUFFER_STATE_SHADER_RESOURCE), - GPUBarrier::Buffer(&res.buffer_tiles_expensive, BUFFER_STATE_UNORDERED_ACCESS, BUFFER_STATE_SHADER_RESOURCE), - GPUBarrier::Image(&res.texture_presort, res.texture_presort.desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS), - GPUBarrier::Image(&res.texture_prefilter, res.texture_prefilter.desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS), + GPUBarrier::Buffer(&res.buffer_tiles_earlyexit, RESOURCE_STATE_UNORDERED_ACCESS, RESOURCE_STATE_SHADER_RESOURCE), + GPUBarrier::Buffer(&res.buffer_tiles_cheap, RESOURCE_STATE_UNORDERED_ACCESS, RESOURCE_STATE_SHADER_RESOURCE), + GPUBarrier::Buffer(&res.buffer_tiles_expensive, RESOURCE_STATE_UNORDERED_ACCESS, RESOURCE_STATE_SHADER_RESOURCE), + GPUBarrier::Image(&res.texture_presort, res.texture_presort.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS), + GPUBarrier::Image(&res.texture_prefilter, res.texture_prefilter.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS), }; device->Barrier(barriers, arraysize(barriers), cmd); } - device->BindResource(CS, &res.buffer_tiles_earlyexit, TEXSLOT_ONDEMAND2, cmd); + device->BindResource(&res.buffer_tiles_earlyexit, TEXSLOT_ONDEMAND2, cmd); device->BindComputeShader(&shaders[CSTYPE_POSTPROCESS_DEPTHOFFIELD_PREPASS_EARLYEXIT], cmd); device->DispatchIndirect(&res.buffer_tile_statistics, INDIRECT_OFFSET_EARLYEXIT, cmd); - device->BindResource(CS, &res.buffer_tiles_cheap, TEXSLOT_ONDEMAND2, cmd); + device->BindResource(&res.buffer_tiles_cheap, TEXSLOT_ONDEMAND2, cmd); device->BindComputeShader(&shaders[CSTYPE_POSTPROCESS_DEPTHOFFIELD_PREPASS], cmd); device->DispatchIndirect(&res.buffer_tile_statistics, INDIRECT_OFFSET_CHEAP, cmd); - device->BindResource(CS, &res.buffer_tiles_expensive, TEXSLOT_ONDEMAND2, cmd); + device->BindResource(&res.buffer_tiles_expensive, TEXSLOT_ONDEMAND2, cmd); device->BindComputeShader(&shaders[CSTYPE_POSTPROCESS_DEPTHOFFIELD_PREPASS], cmd); device->DispatchIndirect(&res.buffer_tile_statistics, INDIRECT_OFFSET_EXPENSIVE, cmd); { GPUBarrier barriers[] = { GPUBarrier::Memory(), - GPUBarrier::Image(&res.texture_presort, IMAGE_LAYOUT_UNORDERED_ACCESS, res.texture_presort.desc.layout), - GPUBarrier::Image(&res.texture_prefilter, IMAGE_LAYOUT_UNORDERED_ACCESS, res.texture_prefilter.desc.layout), + GPUBarrier::Image(&res.texture_presort, RESOURCE_STATE_UNORDERED_ACCESS, res.texture_presort.desc.layout), + GPUBarrier::Image(&res.texture_prefilter, RESOURCE_STATE_UNORDERED_ACCESS, res.texture_prefilter.desc.layout), }; device->Barrier(barriers, arraysize(barriers), cmd); } - device->UnbindUAVs(0, arraysize(uavs), cmd); device->EventEnd(cmd); } @@ -10861,18 +10451,18 @@ void Postprocess_DepthOfField( &res.buffer_tiles_cheap, &res.buffer_tiles_expensive }; - device->BindResources(CS, resarray, TEXSLOT_ONDEMAND0, arraysize(resarray), cmd); + device->BindResources(resarray, TEXSLOT_ONDEMAND0, arraysize(resarray), cmd); const GPUResource* uavs[] = { &res.texture_main, &res.texture_alpha1 }; - device->BindUAVs(CS, uavs, 0, arraysize(uavs), cmd); + device->BindUAVs(uavs, 0, arraysize(uavs), cmd); { GPUBarrier barriers[] = { - GPUBarrier::Image(&res.texture_main, res.texture_main.desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS), - GPUBarrier::Image(&res.texture_alpha1, res.texture_alpha1.desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS), + GPUBarrier::Image(&res.texture_main, res.texture_main.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS), + GPUBarrier::Image(&res.texture_alpha1, res.texture_alpha1.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS), }; device->Barrier(barriers, arraysize(barriers), cmd); } @@ -10889,13 +10479,12 @@ void Postprocess_DepthOfField( { GPUBarrier barriers[] = { GPUBarrier::Memory(), - GPUBarrier::Image(&res.texture_main, IMAGE_LAYOUT_UNORDERED_ACCESS, res.texture_main.desc.layout), - GPUBarrier::Image(&res.texture_alpha1, IMAGE_LAYOUT_UNORDERED_ACCESS, res.texture_alpha1.desc.layout), + GPUBarrier::Image(&res.texture_main, RESOURCE_STATE_UNORDERED_ACCESS, res.texture_main.desc.layout), + GPUBarrier::Image(&res.texture_alpha1, RESOURCE_STATE_UNORDERED_ACCESS, res.texture_alpha1.desc.layout), }; device->Barrier(barriers, arraysize(barriers), cmd); } - device->UnbindUAVs(0, arraysize(uavs), cmd); device->EventEnd(cmd); } @@ -10908,18 +10497,18 @@ void Postprocess_DepthOfField( &res.texture_main, &res.texture_alpha1 }; - device->BindResources(CS, resarray, TEXSLOT_ONDEMAND0, arraysize(resarray), cmd); + device->BindResources(resarray, TEXSLOT_ONDEMAND0, arraysize(resarray), cmd); const GPUResource* uavs[] = { &res.texture_postfilter, &res.texture_alpha2 }; - device->BindUAVs(CS, uavs, 0, arraysize(uavs), cmd); + device->BindUAVs(uavs, 0, arraysize(uavs), cmd); { GPUBarrier barriers[] = { - GPUBarrier::Image(&res.texture_postfilter, res.texture_postfilter.desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS), - GPUBarrier::Image(&res.texture_alpha2, res.texture_alpha2.desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS), + GPUBarrier::Image(&res.texture_postfilter, res.texture_postfilter.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS), + GPUBarrier::Image(&res.texture_alpha2, res.texture_alpha2.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS), }; device->Barrier(barriers, arraysize(barriers), cmd); } @@ -10934,13 +10523,12 @@ void Postprocess_DepthOfField( { GPUBarrier barriers[] = { GPUBarrier::Memory(), - GPUBarrier::Image(&res.texture_postfilter, IMAGE_LAYOUT_UNORDERED_ACCESS, res.texture_postfilter.desc.layout), - GPUBarrier::Image(&res.texture_alpha2, IMAGE_LAYOUT_UNORDERED_ACCESS, res.texture_alpha2.desc.layout), + GPUBarrier::Image(&res.texture_postfilter, RESOURCE_STATE_UNORDERED_ACCESS, res.texture_postfilter.desc.layout), + GPUBarrier::Image(&res.texture_alpha2, RESOURCE_STATE_UNORDERED_ACCESS, res.texture_alpha2.desc.layout), }; device->Barrier(barriers, arraysize(barriers), cmd); } - device->UnbindUAVs(0, arraysize(uavs), cmd); device->EventEnd(cmd); } @@ -10949,8 +10537,7 @@ void Postprocess_DepthOfField( cb.xPPResolution.y = desc.Height; cb.xPPResolution_rcp.x = 1.0f / cb.xPPResolution.x; cb.xPPResolution_rcp.y = 1.0f / cb.xPPResolution.y; - device->UpdateBuffer(&constantBuffers[CBTYPE_POSTPROCESS], &cb, cmd); - device->BindConstantBuffer(CS, &constantBuffers[CBTYPE_POSTPROCESS], CB_GETBINDSLOT(PostProcessCB), cmd); + device->BindDynamicConstantBuffer(cb, CB_GETBINDSLOT(PostProcessCB), cmd); // Upsample pass: { @@ -10963,16 +10550,16 @@ void Postprocess_DepthOfField( &res.texture_alpha2, &res.texture_neighborhoodmax }; - device->BindResources(CS, resarray, TEXSLOT_ONDEMAND0, arraysize(resarray), cmd); + device->BindResources(resarray, TEXSLOT_ONDEMAND0, arraysize(resarray), cmd); const GPUResource* uavs[] = { &output, }; - device->BindUAVs(CS, uavs, 0, arraysize(uavs), cmd); + device->BindUAVs(uavs, 0, arraysize(uavs), cmd); { GPUBarrier barriers[] = { - GPUBarrier::Image(&output, output.desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS), + GPUBarrier::Image(&output, output.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS), }; device->Barrier(barriers, arraysize(barriers), cmd); } @@ -10987,12 +10574,11 @@ void Postprocess_DepthOfField( { GPUBarrier barriers[] = { GPUBarrier::Memory(), - GPUBarrier::Image(&output, IMAGE_LAYOUT_UNORDERED_ACCESS, output.desc.layout), + GPUBarrier::Image(&output, RESOURCE_STATE_UNORDERED_ACCESS, output.desc.layout), }; device->Barrier(barriers, arraysize(barriers), cmd); } - device->UnbindUAVs(0, arraysize(uavs), cmd); device->EventEnd(cmd); } @@ -11012,7 +10598,7 @@ void Postprocess_Outline( device->BindPipelineState(&PSO_outline, cmd); - device->BindResource(PS, &input, TEXSLOT_ONDEMAND0, cmd); + device->BindResource(&input, TEXSLOT_ONDEMAND0, cmd); PostProcessCB cb; cb.xPPResolution.x = (uint)input.GetDesc().Width; @@ -11025,8 +10611,7 @@ void Postprocess_Outline( cb.xPPParams1.y = color.y; cb.xPPParams1.z = color.z; cb.xPPParams1.w = color.w; - device->UpdateBuffer(&constantBuffers[CBTYPE_POSTPROCESS], &cb, cmd); - device->BindConstantBuffer(PS, &constantBuffers[CBTYPE_POSTPROCESS], CB_GETBINDSLOT(PostProcessCB), cmd); + device->BindDynamicConstantBuffer(cb, CB_GETBINDSLOT(PostProcessCB), cmd); device->Draw(3, 0, cmd); @@ -11054,7 +10639,7 @@ void CreateMotionBlurResources(MotionBlurResources& res, XMUINT2 resolution) bufferdesc.BindFlags = BIND_SHADER_RESOURCE | BIND_UNORDERED_ACCESS; bufferdesc.ByteWidth = TILE_STATISTICS_CAPACITY * sizeof(uint); - bufferdesc.MiscFlags = RESOURCE_MISC_BUFFER_ALLOW_RAW_VIEWS | RESOURCE_MISC_INDIRECT_ARGS; + bufferdesc.MiscFlags = RESOURCE_MISC_BUFFER_RAW | RESOURCE_MISC_INDIRECT_ARGS; device->CreateBuffer(&bufferdesc, nullptr, &res.buffer_tile_statistics); bufferdesc.MiscFlags = RESOURCE_MISC_BUFFER_STRUCTURED; @@ -11077,8 +10662,8 @@ void Postprocess_MotionBlur( device->EventBegin("Postprocess_MotionBlur", cmd); auto range = wiProfiler::BeginRangeGPU("MotionBlur", cmd); - device->BindResource(CS, &lineardepth, TEXSLOT_LINEARDEPTH, cmd); - device->BindResource(CS, &gbuffer[GBUFFER_VELOCITY], TEXSLOT_GBUFFER2, cmd); + device->BindResource(&lineardepth, TEXSLOT_LINEARDEPTH, cmd); + device->BindResource(&gbuffer[GBUFFER_VELOCITY], TEXSLOT_GBUFFER1, cmd); const TextureDesc& desc = output.GetDesc(); @@ -11088,8 +10673,7 @@ void Postprocess_MotionBlur( cb.xPPResolution_rcp.x = 1.0f / cb.xPPResolution.x; cb.xPPResolution_rcp.y = 1.0f / cb.xPPResolution.y; cb.motionblur_strength = strength; - device->UpdateBuffer(&constantBuffers[CBTYPE_POSTPROCESS], &cb, cmd); - device->BindConstantBuffer(CS, &constantBuffers[CBTYPE_POSTPROCESS], CB_GETBINDSLOT(PostProcessCB), cmd); + device->BindDynamicConstantBuffer(cb, CB_GETBINDSLOT(PostProcessCB), cmd); // Compute tile max velocities (horizontal): { @@ -11100,12 +10684,12 @@ void Postprocess_MotionBlur( &res.texture_tilemax_horizontal, &res.texture_tilemin_horizontal, }; - device->BindUAVs(CS, uavs, 0, arraysize(uavs), cmd); + device->BindUAVs(uavs, 0, arraysize(uavs), cmd); { GPUBarrier barriers[] = { - GPUBarrier::Image(&res.texture_tilemax_horizontal, res.texture_tilemax_horizontal.desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS), - GPUBarrier::Image(&res.texture_tilemin_horizontal, res.texture_tilemin_horizontal.desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS), + GPUBarrier::Image(&res.texture_tilemax_horizontal, res.texture_tilemax_horizontal.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS), + GPUBarrier::Image(&res.texture_tilemin_horizontal, res.texture_tilemin_horizontal.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS), }; device->Barrier(barriers, arraysize(barriers), cmd); } @@ -11120,13 +10704,12 @@ void Postprocess_MotionBlur( { GPUBarrier barriers[] = { GPUBarrier::Memory(), - GPUBarrier::Image(&res.texture_tilemax_horizontal, IMAGE_LAYOUT_UNORDERED_ACCESS, res.texture_tilemax_horizontal.desc.layout), - GPUBarrier::Image(&res.texture_tilemin_horizontal, IMAGE_LAYOUT_UNORDERED_ACCESS, res.texture_tilemin_horizontal.desc.layout), + GPUBarrier::Image(&res.texture_tilemax_horizontal, RESOURCE_STATE_UNORDERED_ACCESS, res.texture_tilemax_horizontal.desc.layout), + GPUBarrier::Image(&res.texture_tilemin_horizontal, RESOURCE_STATE_UNORDERED_ACCESS, res.texture_tilemin_horizontal.desc.layout), }; device->Barrier(barriers, arraysize(barriers), cmd); } - device->UnbindUAVs(0, arraysize(uavs), cmd); device->EventEnd(cmd); } @@ -11135,18 +10718,18 @@ void Postprocess_MotionBlur( device->EventBegin("TileMax - Vertical", cmd); device->BindComputeShader(&shaders[CSTYPE_POSTPROCESS_MOTIONBLUR_TILEMAXVELOCITY_VERTICAL], cmd); - device->BindResource(CS, &res.texture_tilemax_horizontal, TEXSLOT_ONDEMAND0, cmd); + device->BindResource(&res.texture_tilemax_horizontal, TEXSLOT_ONDEMAND0, cmd); const GPUResource* uavs[] = { &res.texture_tilemax, &res.texture_tilemin, }; - device->BindUAVs(CS, uavs, 0, arraysize(uavs), cmd); + device->BindUAVs(uavs, 0, arraysize(uavs), cmd); { GPUBarrier barriers[] = { - GPUBarrier::Image(&res.texture_tilemax, res.texture_tilemax.desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS), - GPUBarrier::Image(&res.texture_tilemin, res.texture_tilemin.desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS), + GPUBarrier::Image(&res.texture_tilemax, res.texture_tilemax.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS), + GPUBarrier::Image(&res.texture_tilemin, res.texture_tilemin.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS), }; device->Barrier(barriers, arraysize(barriers), cmd); } @@ -11161,13 +10744,12 @@ void Postprocess_MotionBlur( { GPUBarrier barriers[] = { GPUBarrier::Memory(), - GPUBarrier::Image(&res.texture_tilemax, IMAGE_LAYOUT_UNORDERED_ACCESS, res.texture_tilemax.desc.layout), - GPUBarrier::Image(&res.texture_tilemin, IMAGE_LAYOUT_UNORDERED_ACCESS, res.texture_tilemin.desc.layout), + GPUBarrier::Image(&res.texture_tilemax, RESOURCE_STATE_UNORDERED_ACCESS, res.texture_tilemax.desc.layout), + GPUBarrier::Image(&res.texture_tilemin, RESOURCE_STATE_UNORDERED_ACCESS, res.texture_tilemin.desc.layout), }; device->Barrier(barriers, arraysize(barriers), cmd); } - device->UnbindUAVs(0, arraysize(uavs), cmd); device->EventEnd(cmd); } @@ -11180,7 +10762,7 @@ void Postprocess_MotionBlur( &res.texture_tilemax, &res.texture_tilemin }; - device->BindResources(CS, resarray, TEXSLOT_ONDEMAND0, arraysize(resarray), cmd); + device->BindResources(resarray, TEXSLOT_ONDEMAND0, arraysize(resarray), cmd); const GPUResource* uavs[] = { &res.buffer_tile_statistics, @@ -11189,11 +10771,11 @@ void Postprocess_MotionBlur( &res.buffer_tiles_expensive, &res.texture_neighborhoodmax }; - device->BindUAVs(CS, uavs, 0, arraysize(uavs), cmd); + device->BindUAVs(uavs, 0, arraysize(uavs), cmd); { GPUBarrier barriers[] = { - GPUBarrier::Image(&res.texture_neighborhoodmax, res.texture_neighborhoodmax.desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS), + GPUBarrier::Image(&res.texture_neighborhoodmax, res.texture_neighborhoodmax.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS), }; device->Barrier(barriers, arraysize(barriers), cmd); } @@ -11208,12 +10790,11 @@ void Postprocess_MotionBlur( { GPUBarrier barriers[] = { GPUBarrier::Memory(), - GPUBarrier::Image(&res.texture_neighborhoodmax, IMAGE_LAYOUT_UNORDERED_ACCESS, res.texture_neighborhoodmax.desc.layout), + GPUBarrier::Image(&res.texture_neighborhoodmax, RESOURCE_STATE_UNORDERED_ACCESS, res.texture_neighborhoodmax.desc.layout), }; device->Barrier(barriers, arraysize(barriers), cmd); } - device->UnbindUAVs(0, arraysize(uavs), cmd); device->EventEnd(cmd); } @@ -11222,7 +10803,7 @@ void Postprocess_MotionBlur( device->EventBegin("Kickjobs", cmd); device->BindComputeShader(&shaders[CSTYPE_POSTPROCESS_MOTIONBLUR_KICKJOBS], cmd); - device->BindResource(CS, &res.texture_tilemax, TEXSLOT_ONDEMAND0, cmd); + device->BindResource(&res.texture_tilemax, TEXSLOT_ONDEMAND0, cmd); const GPUResource* uavs[] = { &res.buffer_tile_statistics, @@ -11230,17 +10811,16 @@ void Postprocess_MotionBlur( &res.buffer_tiles_cheap, &res.buffer_tiles_expensive }; - device->BindUAVs(CS, uavs, 0, arraysize(uavs), cmd); + device->BindUAVs(uavs, 0, arraysize(uavs), cmd); device->Dispatch(1, 1, 1, cmd); GPUBarrier barriers[] = { GPUBarrier::Memory(), - GPUBarrier::Buffer(&res.buffer_tile_statistics, BUFFER_STATE_UNORDERED_ACCESS, BUFFER_STATE_INDIRECT_ARGUMENT), + GPUBarrier::Buffer(&res.buffer_tile_statistics, RESOURCE_STATE_UNORDERED_ACCESS, RESOURCE_STATE_INDIRECT_ARGUMENT), }; device->Barrier(barriers, arraysize(barriers), cmd); - device->UnbindUAVs(0, arraysize(uavs), cmd); device->EventEnd(cmd); } @@ -11255,19 +10835,19 @@ void Postprocess_MotionBlur( &res.buffer_tiles_cheap, &res.buffer_tiles_expensive, }; - device->BindResources(CS, resarray, TEXSLOT_ONDEMAND0, arraysize(resarray), cmd); + device->BindResources(resarray, TEXSLOT_ONDEMAND0, arraysize(resarray), cmd); const GPUResource* uavs[] = { &output, }; - device->BindUAVs(CS, uavs, 0, arraysize(uavs), cmd); + device->BindUAVs(uavs, 0, arraysize(uavs), cmd); { GPUBarrier barriers[] = { - GPUBarrier::Buffer(&res.buffer_tiles_earlyexit, BUFFER_STATE_UNORDERED_ACCESS, BUFFER_STATE_SHADER_RESOURCE), - GPUBarrier::Buffer(&res.buffer_tiles_cheap, BUFFER_STATE_UNORDERED_ACCESS, BUFFER_STATE_SHADER_RESOURCE), - GPUBarrier::Buffer(&res.buffer_tiles_expensive, BUFFER_STATE_UNORDERED_ACCESS, BUFFER_STATE_SHADER_RESOURCE), - GPUBarrier::Image(&output, output.desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS), + GPUBarrier::Buffer(&res.buffer_tiles_earlyexit, RESOURCE_STATE_UNORDERED_ACCESS, RESOURCE_STATE_SHADER_RESOURCE), + GPUBarrier::Buffer(&res.buffer_tiles_cheap, RESOURCE_STATE_UNORDERED_ACCESS, RESOURCE_STATE_SHADER_RESOURCE), + GPUBarrier::Buffer(&res.buffer_tiles_expensive, RESOURCE_STATE_UNORDERED_ACCESS, RESOURCE_STATE_SHADER_RESOURCE), + GPUBarrier::Image(&output, output.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS), }; device->Barrier(barriers, arraysize(barriers), cmd); } @@ -11284,13 +10864,11 @@ void Postprocess_MotionBlur( { GPUBarrier barriers[] = { GPUBarrier::Memory(), - GPUBarrier::Image(&output, IMAGE_LAYOUT_UNORDERED_ACCESS, output.desc.layout), + GPUBarrier::Image(&output, RESOURCE_STATE_UNORDERED_ACCESS, output.desc.layout), }; device->Barrier(barriers, arraysize(barriers), cmd); } - device->UnbindUAVs(0, arraysize(uavs), cmd); - device->UnbindResources(TEXSLOT_ONDEMAND0, arraysize(resarray), cmd); device->EventEnd(cmd); } @@ -11346,21 +10924,20 @@ void Postprocess_Bloom( cb.xPPResolution_rcp.x = 1.0f / cb.xPPResolution.x; cb.xPPResolution_rcp.y = 1.0f / cb.xPPResolution.y; cb.xPPParams0.x = threshold; - device->UpdateBuffer(&constantBuffers[CBTYPE_POSTPROCESS], &cb, cmd); - device->BindConstantBuffer(CS, &constantBuffers[CBTYPE_POSTPROCESS], CB_GETBINDSLOT(PostProcessCB), cmd); + device->BindDynamicConstantBuffer(cb, CB_GETBINDSLOT(PostProcessCB), cmd); device->BindComputeShader(&shaders[CSTYPE_POSTPROCESS_BLOOMSEPARATE], cmd); - device->BindResource(CS, &input, TEXSLOT_ONDEMAND0, cmd); + device->BindResource(&input, TEXSLOT_ONDEMAND0, cmd); const GPUResource* uavs[] = { &res.texture_bloom, }; - device->BindUAVs(CS, uavs, 0, arraysize(uavs), cmd); + device->BindUAVs(uavs, 0, arraysize(uavs), cmd); { GPUBarrier barriers[] = { - GPUBarrier::Image(&res.texture_bloom, res.texture_bloom.desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS), + GPUBarrier::Image(&res.texture_bloom, res.texture_bloom.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS), }; device->Barrier(barriers, arraysize(barriers), cmd); } @@ -11375,12 +10952,11 @@ void Postprocess_Bloom( { GPUBarrier barriers[] = { GPUBarrier::Memory(), - GPUBarrier::Image(&res.texture_bloom, IMAGE_LAYOUT_UNORDERED_ACCESS, res.texture_bloom.desc.layout), + GPUBarrier::Image(&res.texture_bloom, RESOURCE_STATE_UNORDERED_ACCESS, res.texture_bloom.desc.layout), }; device->Barrier(barriers, arraysize(barriers), cmd); } - device->UnbindUAVs(0, arraysize(uavs), cmd); device->EventEnd(cmd); } @@ -11402,22 +10978,21 @@ void Postprocess_Bloom( cb.xPPResolution.y = desc.Height; cb.xPPResolution_rcp.x = 1.0f / cb.xPPResolution.x; cb.xPPResolution_rcp.y = 1.0f / cb.xPPResolution.y; - device->UpdateBuffer(&constantBuffers[CBTYPE_POSTPROCESS], &cb, cmd); - device->BindConstantBuffer(CS, &constantBuffers[CBTYPE_POSTPROCESS], CB_GETBINDSLOT(PostProcessCB), cmd); + device->BindDynamicConstantBuffer(cb, CB_GETBINDSLOT(PostProcessCB), cmd); device->BindComputeShader(&shaders[CSTYPE_POSTPROCESS_BLOOMCOMBINE], cmd); - device->BindResource(CS, &input, TEXSLOT_ONDEMAND0, cmd); - device->BindResource(CS, &res.texture_bloom, TEXSLOT_ONDEMAND1, cmd); + device->BindResource(&input, TEXSLOT_ONDEMAND0, cmd); + device->BindResource(&res.texture_bloom, TEXSLOT_ONDEMAND1, cmd); const GPUResource* uavs[] = { &output, }; - device->BindUAVs(CS, uavs, 0, arraysize(uavs), cmd); + device->BindUAVs(uavs, 0, arraysize(uavs), cmd); { GPUBarrier barriers[] = { - GPUBarrier::Image(&output, output.desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS), + GPUBarrier::Image(&output, output.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS), }; device->Barrier(barriers, arraysize(barriers), cmd); } @@ -11432,12 +11007,11 @@ void Postprocess_Bloom( { GPUBarrier barriers[] = { GPUBarrier::Memory(), - GPUBarrier::Image(&output, IMAGE_LAYOUT_UNORDERED_ACCESS, output.desc.layout), + GPUBarrier::Image(&output, RESOURCE_STATE_UNORDERED_ACCESS, output.desc.layout), }; device->Barrier(barriers, arraysize(barriers), cmd); } - device->UnbindUAVs(0, arraysize(uavs), cmd); device->EventEnd(cmd); } @@ -11455,7 +11029,7 @@ void CreateVolumetricCloudResources(VolumetricCloudResources& res, XMUINT2 resol desc.Width = renderResolution.x; desc.Height = renderResolution.y; desc.Format = FORMAT_R16G16B16A16_FLOAT; - desc.layout = IMAGE_LAYOUT_SHADER_RESOURCE_COMPUTE; + desc.layout = RESOURCE_STATE_SHADER_RESOURCE_COMPUTE; device->CreateTexture(&desc, nullptr, &res.texture_cloudRender); device->SetName(&res.texture_cloudRender, "texture_cloudRender"); desc.Format = FORMAT_R16G16_FLOAT; @@ -11508,32 +11082,31 @@ void Postprocess_VolumetricClouds( cb.xPPParams0.y = (float)res.texture_reproject[0].GetDesc().Height; cb.xPPParams0.z = 1.0f / cb.xPPParams0.x; cb.xPPParams0.w = 1.0f / cb.xPPParams0.y; - device->UpdateBuffer(&constantBuffers[CBTYPE_POSTPROCESS], &cb, cmd); - device->BindConstantBuffer(CS, &constantBuffers[CBTYPE_POSTPROCESS], CB_GETBINDSLOT(PostProcessCB), cmd); + device->BindDynamicConstantBuffer(cb, CB_GETBINDSLOT(PostProcessCB), cmd); // Cloud pass: { device->EventBegin("Volumetric Cloud Rendering", cmd); device->BindComputeShader(&shaders[CSTYPE_POSTPROCESS_VOLUMETRICCLOUDS_RENDER], cmd); - device->BindResource(CS, &depthbuffer, TEXSLOT_DEPTH, cmd); - device->BindResource(CS, &texture_shapeNoise, TEXSLOT_ONDEMAND1, cmd); - device->BindResource(CS, &texture_detailNoise, TEXSLOT_ONDEMAND2, cmd); - device->BindResource(CS, &texture_curlNoise, TEXSLOT_ONDEMAND3, cmd); - device->BindResource(CS, &texture_weatherMap, TEXSLOT_ONDEMAND4, cmd); - device->BindResource(CS, &textures[TEXTYPE_2D_SKYATMOSPHERE_TRANSMITTANCELUT], TEXSLOT_TRANSMITTANCELUT, cmd); - device->BindResource(CS, &textures[TEXTYPE_2D_SKYATMOSPHERE_SKYLUMINANCELUT], TEXSLOT_SKYLUMINANCELUT, cmd); + device->BindResource(&depthbuffer, TEXSLOT_DEPTH, cmd); + device->BindResource(&texture_shapeNoise, TEXSLOT_ONDEMAND1, cmd); + device->BindResource(&texture_detailNoise, TEXSLOT_ONDEMAND2, cmd); + device->BindResource(&texture_curlNoise, TEXSLOT_ONDEMAND3, cmd); + device->BindResource(&texture_weatherMap, TEXSLOT_ONDEMAND4, cmd); + device->BindResource(&textures[TEXTYPE_2D_SKYATMOSPHERE_TRANSMITTANCELUT], TEXSLOT_TRANSMITTANCELUT, cmd); + device->BindResource(&textures[TEXTYPE_2D_SKYATMOSPHERE_SKYLUMINANCELUT], TEXSLOT_SKYLUMINANCELUT, cmd); const GPUResource* uavs[] = { &res.texture_cloudRender, &res.texture_cloudDepth, }; - device->BindUAVs(CS, uavs, 0, arraysize(uavs), cmd); + device->BindUAVs(uavs, 0, arraysize(uavs), cmd); { GPUBarrier barriers[] = { - GPUBarrier::Image(&res.texture_cloudRender, res.texture_cloudRender.desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS), - GPUBarrier::Image(&res.texture_cloudDepth, res.texture_cloudDepth.desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS), + GPUBarrier::Image(&res.texture_cloudRender, res.texture_cloudRender.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS), + GPUBarrier::Image(&res.texture_cloudDepth, res.texture_cloudDepth.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS), }; device->Barrier(barriers, arraysize(barriers), cmd); } @@ -11548,13 +11121,12 @@ void Postprocess_VolumetricClouds( { GPUBarrier barriers[] = { GPUBarrier::Memory(), - GPUBarrier::Image(&res.texture_cloudRender, IMAGE_LAYOUT_UNORDERED_ACCESS, res.texture_cloudRender.desc.layout), - GPUBarrier::Image(&res.texture_cloudDepth, IMAGE_LAYOUT_UNORDERED_ACCESS, res.texture_cloudDepth.desc.layout), + GPUBarrier::Image(&res.texture_cloudRender, RESOURCE_STATE_UNORDERED_ACCESS, res.texture_cloudRender.desc.layout), + GPUBarrier::Image(&res.texture_cloudDepth, RESOURCE_STATE_UNORDERED_ACCESS, res.texture_cloudDepth.desc.layout), }; device->Barrier(barriers, arraysize(barriers), cmd); } - device->UnbindUAVs(0, arraysize(uavs), cmd); device->EventEnd(cmd); } @@ -11563,8 +11135,7 @@ void Postprocess_VolumetricClouds( cb.xPPResolution.y = reprojection_desc.Height; cb.xPPResolution_rcp.x = 1.0f / cb.xPPResolution.x; cb.xPPResolution_rcp.y = 1.0f / cb.xPPResolution.y; - device->UpdateBuffer(&constantBuffers[CBTYPE_POSTPROCESS], &cb, cmd); - device->BindConstantBuffer(CS, &constantBuffers[CBTYPE_POSTPROCESS], CB_GETBINDSLOT(PostProcessCB), cmd); + device->BindDynamicConstantBuffer(cb, CB_GETBINDSLOT(PostProcessCB), cmd); int temporal_output = device->GetFrameCount() % 2; int temporal_history = 1 - temporal_output; @@ -11574,22 +11145,22 @@ void Postprocess_VolumetricClouds( device->EventBegin("Volumetric Cloud Reproject", cmd); device->BindComputeShader(&shaders[CSTYPE_POSTPROCESS_VOLUMETRICCLOUDS_REPROJECT], cmd); - device->BindResource(CS, &depthbuffer, TEXSLOT_DEPTH, cmd); - device->BindResource(CS, &res.texture_cloudRender, TEXSLOT_ONDEMAND0, cmd); - device->BindResource(CS, &res.texture_cloudDepth, TEXSLOT_ONDEMAND1, cmd); - device->BindResource(CS, &res.texture_reproject[temporal_history], TEXSLOT_ONDEMAND2, cmd); - device->BindResource(CS, &res.texture_reproject_depth[temporal_history], TEXSLOT_ONDEMAND3, cmd); + device->BindResource(&depthbuffer, TEXSLOT_DEPTH, cmd); + device->BindResource(&res.texture_cloudRender, TEXSLOT_ONDEMAND0, cmd); + device->BindResource(&res.texture_cloudDepth, TEXSLOT_ONDEMAND1, cmd); + device->BindResource(&res.texture_reproject[temporal_history], TEXSLOT_ONDEMAND2, cmd); + device->BindResource(&res.texture_reproject_depth[temporal_history], TEXSLOT_ONDEMAND3, cmd); const GPUResource* uavs[] = { &res.texture_reproject[temporal_output], &res.texture_reproject_depth[temporal_output], }; - device->BindUAVs(CS, uavs, 0, arraysize(uavs), cmd); + device->BindUAVs(uavs, 0, arraysize(uavs), cmd); { GPUBarrier barriers[] = { - GPUBarrier::Image(&res.texture_reproject[temporal_output], res.texture_reproject[temporal_output].desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS), - GPUBarrier::Image(&res.texture_reproject_depth[temporal_output], res.texture_reproject_depth[temporal_output].desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS), + GPUBarrier::Image(&res.texture_reproject[temporal_output], res.texture_reproject[temporal_output].desc.layout, RESOURCE_STATE_UNORDERED_ACCESS), + GPUBarrier::Image(&res.texture_reproject_depth[temporal_output], res.texture_reproject_depth[temporal_output].desc.layout, RESOURCE_STATE_UNORDERED_ACCESS), }; device->Barrier(barriers, arraysize(barriers), cmd); } @@ -11604,13 +11175,12 @@ void Postprocess_VolumetricClouds( { GPUBarrier barriers[] = { GPUBarrier::Memory(), - GPUBarrier::Image(&res.texture_reproject[temporal_output], IMAGE_LAYOUT_UNORDERED_ACCESS, res.texture_reproject[temporal_output].desc.layout), - GPUBarrier::Image(&res.texture_reproject_depth[temporal_output], IMAGE_LAYOUT_UNORDERED_ACCESS, res.texture_reproject_depth[temporal_output].desc.layout), + GPUBarrier::Image(&res.texture_reproject[temporal_output], RESOURCE_STATE_UNORDERED_ACCESS, res.texture_reproject[temporal_output].desc.layout), + GPUBarrier::Image(&res.texture_reproject_depth[temporal_output], RESOURCE_STATE_UNORDERED_ACCESS, res.texture_reproject_depth[temporal_output].desc.layout), }; device->Barrier(barriers, arraysize(barriers), cmd); } - device->UnbindUAVs(0, arraysize(uavs), cmd); device->EventEnd(cmd); } @@ -11619,21 +11189,21 @@ void Postprocess_VolumetricClouds( device->EventBegin("Volumetric Cloud Temporal", cmd); device->BindComputeShader(&shaders[CSTYPE_POSTPROCESS_VOLUMETRICCLOUDS_TEMPORAL], cmd); - device->BindResource(CS, &depthbuffer, TEXSLOT_DEPTH, cmd); - device->BindResource(CS, &res.texture_reproject[temporal_output], TEXSLOT_ONDEMAND0, cmd); - device->BindResource(CS, &res.texture_reproject_depth[temporal_output], TEXSLOT_ONDEMAND1, cmd); - device->BindResource(CS, &res.texture_temporal[temporal_history], TEXSLOT_ONDEMAND2, cmd); + device->BindResource(&depthbuffer, TEXSLOT_DEPTH, cmd); + device->BindResource(&res.texture_reproject[temporal_output], TEXSLOT_ONDEMAND0, cmd); + device->BindResource(&res.texture_reproject_depth[temporal_output], TEXSLOT_ONDEMAND1, cmd); + device->BindResource(&res.texture_temporal[temporal_history], TEXSLOT_ONDEMAND2, cmd); const GPUResource* uavs[] = { &res.texture_temporal[temporal_output], &res.texture_cloudMask, }; - device->BindUAVs(CS, uavs, 0, arraysize(uavs), cmd); + device->BindUAVs(uavs, 0, arraysize(uavs), cmd); { GPUBarrier barriers[] = { - GPUBarrier::Image(&res.texture_temporal[temporal_output], res.texture_temporal[temporal_output].desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS), - GPUBarrier::Image(&res.texture_cloudMask, res.texture_cloudMask.desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS), + GPUBarrier::Image(&res.texture_temporal[temporal_output], res.texture_temporal[temporal_output].desc.layout, RESOURCE_STATE_UNORDERED_ACCESS), + GPUBarrier::Image(&res.texture_cloudMask, res.texture_cloudMask.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS), }; device->Barrier(barriers, arraysize(barriers), cmd); } @@ -11648,13 +11218,12 @@ void Postprocess_VolumetricClouds( { GPUBarrier barriers[] = { GPUBarrier::Memory(), - GPUBarrier::Image(&res.texture_temporal[temporal_output], IMAGE_LAYOUT_UNORDERED_ACCESS, res.texture_temporal[temporal_output].desc.layout), - GPUBarrier::Image(&res.texture_cloudMask, IMAGE_LAYOUT_UNORDERED_ACCESS, res.texture_cloudMask.desc.layout), + GPUBarrier::Image(&res.texture_temporal[temporal_output], RESOURCE_STATE_UNORDERED_ACCESS, res.texture_temporal[temporal_output].desc.layout), + GPUBarrier::Image(&res.texture_cloudMask, RESOURCE_STATE_UNORDERED_ACCESS, res.texture_cloudMask.desc.layout), }; device->Barrier(barriers, arraysize(barriers), cmd); } - device->UnbindUAVs(0, arraysize(uavs), cmd); device->EventEnd(cmd); } @@ -11672,7 +11241,7 @@ void Postprocess_FXAA( device->BindComputeShader(&shaders[CSTYPE_POSTPROCESS_FXAA], cmd); - device->BindResource(CS, &input, TEXSLOT_ONDEMAND0, cmd); + device->BindResource(&input, TEXSLOT_ONDEMAND0, cmd); const TextureDesc& desc = output.GetDesc(); @@ -11681,17 +11250,16 @@ void Postprocess_FXAA( cb.xPPResolution.y = desc.Height; cb.xPPResolution_rcp.x = 1.0f / cb.xPPResolution.x; cb.xPPResolution_rcp.y = 1.0f / cb.xPPResolution.y; - device->UpdateBuffer(&constantBuffers[CBTYPE_POSTPROCESS], &cb, cmd); - device->BindConstantBuffer(CS, &constantBuffers[CBTYPE_POSTPROCESS], CB_GETBINDSLOT(PostProcessCB), cmd); + device->BindDynamicConstantBuffer(cb, CB_GETBINDSLOT(PostProcessCB), cmd); const GPUResource* uavs[] = { &output, }; - device->BindUAVs(CS, uavs, 0, arraysize(uavs), cmd); + device->BindUAVs(uavs, 0, arraysize(uavs), cmd); { GPUBarrier barriers[] = { - GPUBarrier::Image(&output, output.desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS), + GPUBarrier::Image(&output, output.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS), }; device->Barrier(barriers, arraysize(barriers), cmd); } @@ -11706,12 +11274,11 @@ void Postprocess_FXAA( { GPUBarrier barriers[] = { GPUBarrier::Memory(), - GPUBarrier::Image(&output, IMAGE_LAYOUT_UNORDERED_ACCESS, output.desc.layout), + GPUBarrier::Image(&output, RESOURCE_STATE_UNORDERED_ACCESS, output.desc.layout), }; device->Barrier(barriers, arraysize(barriers), cmd); } - device->UnbindUAVs(0, arraysize(uavs), cmd); wiProfiler::EndRange(range); device->EventEnd(cmd); @@ -11731,11 +11298,11 @@ void Postprocess_TemporalAA( device->BindComputeShader(&shaders[CSTYPE_POSTPROCESS_TEMPORALAA], cmd); - device->BindResource(CS, &input_current, TEXSLOT_ONDEMAND0, cmd); - device->BindResource(CS, &input_history, TEXSLOT_ONDEMAND1, cmd); - device->BindResource(CS, &depth_history, TEXSLOT_ONDEMAND2, cmd); - device->BindResource(CS, &lineardepth, TEXSLOT_LINEARDEPTH, cmd); - device->BindResource(CS, &gbuffer[GBUFFER_VELOCITY], TEXSLOT_GBUFFER2, cmd); + device->BindResource(&input_current, TEXSLOT_ONDEMAND0, cmd); + device->BindResource(&input_history, TEXSLOT_ONDEMAND1, cmd); + device->BindResource(&depth_history, TEXSLOT_ONDEMAND2, cmd); + device->BindResource(&lineardepth, TEXSLOT_LINEARDEPTH, cmd); + device->BindResource(&gbuffer[GBUFFER_VELOCITY], TEXSLOT_GBUFFER1, cmd); const TextureDesc& desc = output.GetDesc(); @@ -11744,17 +11311,16 @@ void Postprocess_TemporalAA( cb.xPPResolution.y = desc.Height; cb.xPPResolution_rcp.x = 1.0f / cb.xPPResolution.x; cb.xPPResolution_rcp.y = 1.0f / cb.xPPResolution.y; - device->UpdateBuffer(&constantBuffers[CBTYPE_POSTPROCESS], &cb, cmd); - device->BindConstantBuffer(CS, &constantBuffers[CBTYPE_POSTPROCESS], CB_GETBINDSLOT(PostProcessCB), cmd); + device->BindDynamicConstantBuffer(cb, CB_GETBINDSLOT(PostProcessCB), cmd); const GPUResource* uavs[] = { &output, }; - device->BindUAVs(CS, uavs, 0, arraysize(uavs), cmd); + device->BindUAVs(uavs, 0, arraysize(uavs), cmd); { GPUBarrier barriers[] = { - GPUBarrier::Image(&output, output.desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS), + GPUBarrier::Image(&output, output.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS), }; device->Barrier(barriers, arraysize(barriers), cmd); } @@ -11769,81 +11335,11 @@ void Postprocess_TemporalAA( { GPUBarrier barriers[] = { GPUBarrier::Memory(), - GPUBarrier::Image(&output, IMAGE_LAYOUT_UNORDERED_ACCESS, output.desc.layout), + GPUBarrier::Image(&output, RESOURCE_STATE_UNORDERED_ACCESS, output.desc.layout), }; device->Barrier(barriers, arraysize(barriers), cmd); } - device->UnbindUAVs(0, arraysize(uavs), cmd); - - wiProfiler::EndRange(range); - device->EventEnd(cmd); -} -void Postprocess_DepthPyramid( - const Texture& depthbuffer, - const Texture& lineardepth, - CommandList cmd -) -{ - device->EventBegin("Postprocess_DepthPyramid", cmd); - auto range = wiProfiler::BeginRangeGPU("Depth Pyramid", cmd); - - BindCommonResources(cmd); - - const TextureDesc& desc = lineardepth.GetDesc(); - - PostProcessCB cb; - cb.xPPResolution.x = desc.Width / 2; // downsample res - cb.xPPResolution.y = desc.Height / 2; // downsample res - cb.xPPResolution_rcp.x = 1.0f / cb.xPPResolution.x; - cb.xPPResolution_rcp.y = 1.0f / cb.xPPResolution.y; - cb.xPPParams0.x = (float)depthbuffer.GetDesc().Width; - cb.xPPParams0.y = (float)depthbuffer.GetDesc().Height; - cb.xPPParams0.z = 1.0f / cb.xPPParams0.x; - cb.xPPParams0.w = 1.0f / cb.xPPParams0.y; - device->UpdateBuffer(&constantBuffers[CBTYPE_POSTPROCESS], &cb, cmd); - device->BindConstantBuffer(CS, &constantBuffers[CBTYPE_POSTPROCESS], CB_GETBINDSLOT(PostProcessCB), cmd); - - device->BindResource(CS, &depthbuffer, TEXSLOT_DEPTH, cmd, 0); // full res native depth - - device->BindUAV(CS, &lineardepth, 0, cmd, 0); // full res linear depth - device->BindUAV(CS, &lineardepth, 1, cmd, 1); // 2x downsample linear depth - device->BindUAV(CS, &lineardepth, 2, cmd, 2); // 4x downsample linear depth - device->BindUAV(CS, &lineardepth, 3, cmd, 3); // 8x downsample linear depth - device->BindUAV(CS, &lineardepth, 4, cmd, 4); // 16x downsample linear depth - device->BindUAV(CS, &lineardepth, 5, cmd, 5); // 32x downsample linear depth - - device->BindUAV(CS, &depthbuffer, 6, cmd, 1); // 2x downsample native depth - device->BindUAV(CS, &depthbuffer, 7, cmd, 2); // 4x downsample native depth - - { - GPUBarrier barriers[] = { - GPUBarrier::Image(&lineardepth, lineardepth.desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS), - GPUBarrier::Image(&depthbuffer, depthbuffer.desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS, 1), - GPUBarrier::Image(&depthbuffer, depthbuffer.desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS, 2), - }; - device->Barrier(barriers, arraysize(barriers), cmd); - } - - device->BindComputeShader(&shaders[CSTYPE_POSTPROCESS_LINEARDEPTH], cmd); - device->Dispatch( - (desc.Width + POSTPROCESS_LINEARDEPTH_BLOCKSIZE - 1) / POSTPROCESS_LINEARDEPTH_BLOCKSIZE, - (desc.Height + POSTPROCESS_LINEARDEPTH_BLOCKSIZE - 1) / POSTPROCESS_LINEARDEPTH_BLOCKSIZE, - 1, - cmd - ); - - { - GPUBarrier barriers[] = { - GPUBarrier::Memory(), - GPUBarrier::Image(&lineardepth, IMAGE_LAYOUT_UNORDERED_ACCESS, lineardepth.desc.layout), - GPUBarrier::Image(&depthbuffer, IMAGE_LAYOUT_UNORDERED_ACCESS, depthbuffer.desc.layout, 1), - GPUBarrier::Image(&depthbuffer, IMAGE_LAYOUT_UNORDERED_ACCESS, depthbuffer.desc.layout, 2), - }; - device->Barrier(barriers, arraysize(barriers), cmd); - } - - device->UnbindUAVs(0, 8, cmd); wiProfiler::EndRange(range); device->EventEnd(cmd); @@ -11859,7 +11355,7 @@ void Postprocess_Sharpen( device->BindComputeShader(&shaders[CSTYPE_POSTPROCESS_SHARPEN], cmd); - device->BindResource(CS, &input, TEXSLOT_ONDEMAND0, cmd); + device->BindResource(&input, TEXSLOT_ONDEMAND0, cmd); const TextureDesc& desc = output.GetDesc(); @@ -11869,17 +11365,16 @@ void Postprocess_Sharpen( cb.xPPResolution_rcp.x = 1.0f / cb.xPPResolution.x; cb.xPPResolution_rcp.y = 1.0f / cb.xPPResolution.y; cb.xPPParams0.x = amount; - device->UpdateBuffer(&constantBuffers[CBTYPE_POSTPROCESS], &cb, cmd); - device->BindConstantBuffer(CS, &constantBuffers[CBTYPE_POSTPROCESS], CB_GETBINDSLOT(PostProcessCB), cmd); + device->BindDynamicConstantBuffer(cb, CB_GETBINDSLOT(PostProcessCB), cmd); const GPUResource* uavs[] = { &output, }; - device->BindUAVs(CS, uavs, 0, arraysize(uavs), cmd); + device->BindUAVs(uavs, 0, arraysize(uavs), cmd); { GPUBarrier barriers[] = { - GPUBarrier::Image(&output, output.desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS), + GPUBarrier::Image(&output, output.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS), }; device->Barrier(barriers, arraysize(barriers), cmd); } @@ -11894,12 +11389,11 @@ void Postprocess_Sharpen( { GPUBarrier barriers[] = { GPUBarrier::Memory(), - GPUBarrier::Image(&output, IMAGE_LAYOUT_UNORDERED_ACCESS, output.desc.layout), + GPUBarrier::Image(&output, RESOURCE_STATE_UNORDERED_ACCESS, output.desc.layout), }; device->Barrier(barriers, arraysize(barriers), cmd); } - device->UnbindUAVs(0, arraysize(uavs), cmd); device->EventEnd(cmd); } @@ -11935,44 +11429,21 @@ void Postprocess_Tonemap( assert(texture_colorgradinglut == nullptr || texture_colorgradinglut->desc.type == TextureDesc::TEXTURE_3D); // This must be a 3D lut - if (device->CheckCapability(GRAPHICSDEVICE_CAPABILITY_BINDLESS_DESCRIPTORS)) - { - PushConstantsTonemap push = {}; - push.xPPResolution_rcp = cb.xPPResolution_rcp; - push.exposure = cb.tonemap_exposure; - push.dither = cb.tonemap_dither; - push.eyeadaptionkey = cb.tonemap_eyeadaptionkey; - push.texture_input = device->GetDescriptorIndex(&input, SRV); - push.texture_input_luminance = device->GetDescriptorIndex(texture_luminance, SRV); - push.texture_input_distortion = device->GetDescriptorIndex(texture_distortion, SRV); - push.texture_colorgrade_lookuptable = device->GetDescriptorIndex(texture_colorgradinglut, SRV); - push.texture_output = device->GetDescriptorIndex(&output, UAV); - device->PushConstants(&push, sizeof(push), cmd); - } - else - { - device->UnbindResources(TEXSLOT_ONDEMAND0, 4, cmd); - - device->BindResource(CS, &input, TEXSLOT_ONDEMAND0, cmd); - device->BindResource(CS, texture_luminance, TEXSLOT_ONDEMAND1, cmd); - device->BindResource(CS, texture_distortion, TEXSLOT_ONDEMAND2, cmd); - - if (texture_colorgradinglut != nullptr) - { - device->BindResource(CS, texture_colorgradinglut, TEXSLOT_ONDEMAND3, cmd); - } - device->UpdateBuffer(&constantBuffers[CBTYPE_POSTPROCESS], &cb, cmd); - device->BindConstantBuffer(CS, &constantBuffers[CBTYPE_POSTPROCESS], CB_GETBINDSLOT(PostProcessCB), cmd); - - const GPUResource* uavs[] = { - &output, - }; - device->BindUAVs(CS, uavs, 0, arraysize(uavs), cmd); - } + PushConstantsTonemap push = {}; + push.xPPResolution_rcp = cb.xPPResolution_rcp; + push.exposure = cb.tonemap_exposure; + push.dither = cb.tonemap_dither; + push.eyeadaptionkey = cb.tonemap_eyeadaptionkey; + push.texture_input = device->GetDescriptorIndex(&input, SRV); + push.texture_input_luminance = device->GetDescriptorIndex(texture_luminance, SRV); + push.texture_input_distortion = device->GetDescriptorIndex(texture_distortion, SRV); + push.texture_colorgrade_lookuptable = device->GetDescriptorIndex(texture_colorgradinglut, SRV); + push.texture_output = device->GetDescriptorIndex(&output, UAV); + device->PushConstants(&push, sizeof(push), cmd); { GPUBarrier barriers[] = { - GPUBarrier::Image(&output, output.desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS), + GPUBarrier::Image(&output, output.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS), }; device->Barrier(barriers, arraysize(barriers), cmd); } @@ -11987,12 +11458,11 @@ void Postprocess_Tonemap( { GPUBarrier barriers[] = { GPUBarrier::Memory(), - GPUBarrier::Image(&output, IMAGE_LAYOUT_UNORDERED_ACCESS, output.desc.layout), + GPUBarrier::Image(&output, RESOURCE_STATE_UNORDERED_ACCESS, output.desc.layout), }; device->Barrier(barriers, arraysize(barriers), cmd); } - device->UnbindUAVs(0, 1, cmd); device->EventEnd(cmd); } @@ -12044,19 +11514,18 @@ void Postprocess_FSR( static_cast(temp.desc.Height) ); - device->UpdateBuffer(&constantBuffers[CBTYPE_POSTPROCESS_FSR], &cb, cmd); - device->BindConstantBuffer(CS, &constantBuffers[CBTYPE_POSTPROCESS_FSR], CB_GETBINDSLOT(FSRCB), cmd); + device->BindDynamicConstantBuffer(cb, CB_GETBINDSLOT(FSRCB), cmd); - device->BindResource(CS, &input, TEXSLOT_ONDEMAND0, cmd); + device->BindResource(&input, TEXSLOT_ONDEMAND0, cmd); const GPUResource* uavs[] = { &temp, }; - device->BindUAVs(CS, uavs, 0, arraysize(uavs), cmd); + device->BindUAVs(uavs, 0, arraysize(uavs), cmd); { GPUBarrier barriers[] = { - GPUBarrier::Image(&temp, temp.desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS), + GPUBarrier::Image(&temp, temp.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS), }; device->Barrier(barriers, arraysize(barriers), cmd); } @@ -12066,12 +11535,11 @@ void Postprocess_FSR( { GPUBarrier barriers[] = { GPUBarrier::Memory(), - GPUBarrier::Image(&temp, IMAGE_LAYOUT_UNORDERED_ACCESS, temp.desc.layout), + GPUBarrier::Image(&temp, RESOURCE_STATE_UNORDERED_ACCESS, temp.desc.layout), }; device->Barrier(barriers, arraysize(barriers), cmd); } - device->UnbindUAVs(0, arraysize(uavs), cmd); } // Sharpen: @@ -12079,19 +11547,18 @@ void Postprocess_FSR( device->BindComputeShader(&shaders[CSTYPE_POSTPROCESS_FSR_SHARPEN], cmd); FsrRcasCon(cb.const0, sharpness); - device->UpdateBuffer(&constantBuffers[CBTYPE_POSTPROCESS_FSR], &cb, cmd); - device->BindConstantBuffer(CS, &constantBuffers[CBTYPE_POSTPROCESS_FSR], CB_GETBINDSLOT(FSRCB), cmd); + device->BindDynamicConstantBuffer(cb, CB_GETBINDSLOT(FSRCB), cmd); - device->BindResource(CS, &temp, TEXSLOT_ONDEMAND0, cmd); + device->BindResource(&temp, TEXSLOT_ONDEMAND0, cmd); const GPUResource* uavs[] = { &output, }; - device->BindUAVs(CS, uavs, 0, arraysize(uavs), cmd); + device->BindUAVs(uavs, 0, arraysize(uavs), cmd); { GPUBarrier barriers[] = { - GPUBarrier::Image(&output, output.desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS), + GPUBarrier::Image(&output, output.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS), }; device->Barrier(barriers, arraysize(barriers), cmd); } @@ -12101,12 +11568,11 @@ void Postprocess_FSR( { GPUBarrier barriers[] = { GPUBarrier::Memory(), - GPUBarrier::Image(&output, IMAGE_LAYOUT_UNORDERED_ACCESS, output.desc.layout), + GPUBarrier::Image(&output, RESOURCE_STATE_UNORDERED_ACCESS, output.desc.layout), }; device->Barrier(barriers, arraysize(barriers), cmd); } - device->UnbindUAVs(0, arraysize(uavs), cmd); } wiProfiler::EndRange(range); @@ -12123,7 +11589,7 @@ void Postprocess_Chromatic_Aberration( device->BindComputeShader(&shaders[CSTYPE_POSTPROCESS_CHROMATIC_ABERRATION], cmd); - device->BindResource(CS, &input, TEXSLOT_ONDEMAND0, cmd); + device->BindResource(&input, TEXSLOT_ONDEMAND0, cmd); const TextureDesc& desc = output.GetDesc(); @@ -12133,17 +11599,16 @@ void Postprocess_Chromatic_Aberration( cb.xPPResolution_rcp.x = 1.0f / cb.xPPResolution.x; cb.xPPResolution_rcp.y = 1.0f / cb.xPPResolution.y; cb.xPPParams0.x = amount; - device->UpdateBuffer(&constantBuffers[CBTYPE_POSTPROCESS], &cb, cmd); - device->BindConstantBuffer(CS, &constantBuffers[CBTYPE_POSTPROCESS], CB_GETBINDSLOT(PostProcessCB), cmd); + device->BindDynamicConstantBuffer(cb, CB_GETBINDSLOT(PostProcessCB), cmd); const GPUResource* uavs[] = { &output, }; - device->BindUAVs(CS, uavs, 0, arraysize(uavs), cmd); + device->BindUAVs(uavs, 0, arraysize(uavs), cmd); { GPUBarrier barriers[] = { - GPUBarrier::Image(&output, output.desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS), + GPUBarrier::Image(&output, output.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS), }; device->Barrier(barriers, arraysize(barriers), cmd); } @@ -12158,12 +11623,11 @@ void Postprocess_Chromatic_Aberration( { GPUBarrier barriers[] = { GPUBarrier::Memory(), - GPUBarrier::Image(&output, IMAGE_LAYOUT_UNORDERED_ACCESS, output.desc.layout), + GPUBarrier::Image(&output, RESOURCE_STATE_UNORDERED_ACCESS, output.desc.layout), }; device->Barrier(barriers, arraysize(barriers), cmd); } - device->UnbindUAVs(0, arraysize(uavs), cmd); device->EventEnd(cmd); } @@ -12194,16 +11658,14 @@ void Postprocess_Upsample_Bilateral( cb.xPPParams1.y = (float)input.GetDesc().Height; cb.xPPParams1.z = 1.0f / cb.xPPParams1.x; cb.xPPParams1.w = 1.0f / cb.xPPParams1.y; - device->UpdateBuffer(&constantBuffers[CBTYPE_POSTPROCESS], &cb, cmd); + device->BindDynamicConstantBuffer(cb, CB_GETBINDSLOT(PostProcessCB), cmd); if (pixelshader) { device->BindPipelineState(&PSO_upsample_bilateral, cmd); - device->BindConstantBuffer(PS, &constantBuffers[CBTYPE_POSTPROCESS], CB_GETBINDSLOT(PostProcessCB), cmd); - - device->BindResource(PS, &input, TEXSLOT_ONDEMAND0, cmd); - device->BindResource(PS, &lineardepth, TEXSLOT_LINEARDEPTH, cmd); + device->BindResource(&input, TEXSLOT_ONDEMAND0, cmd); + device->BindResource(&lineardepth, TEXSLOT_LINEARDEPTH, cmd); device->Draw(3, 0, cmd); } @@ -12240,19 +11702,17 @@ void Postprocess_Upsample_Bilateral( } device->BindComputeShader(&shaders[cs], cmd); - device->BindConstantBuffer(CS, &constantBuffers[CBTYPE_POSTPROCESS], CB_GETBINDSLOT(PostProcessCB), cmd); - - device->BindResource(CS, &input, TEXSLOT_ONDEMAND0, cmd); - device->BindResource(CS, &lineardepth, TEXSLOT_LINEARDEPTH, cmd); + device->BindResource(&input, TEXSLOT_ONDEMAND0, cmd); + device->BindResource(&lineardepth, TEXSLOT_LINEARDEPTH, cmd); const GPUResource* uavs[] = { &output, }; - device->BindUAVs(CS, uavs, 0, arraysize(uavs), cmd); + device->BindUAVs(uavs, 0, arraysize(uavs), cmd); { GPUBarrier barriers[] = { - GPUBarrier::Image(&output, output.desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS), + GPUBarrier::Image(&output, output.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS), }; device->Barrier(barriers, arraysize(barriers), cmd); } @@ -12267,12 +11727,11 @@ void Postprocess_Upsample_Bilateral( { GPUBarrier barriers[] = { GPUBarrier::Memory(), - GPUBarrier::Image(&output, IMAGE_LAYOUT_UNORDERED_ACCESS, output.desc.layout), + GPUBarrier::Image(&output, RESOURCE_STATE_UNORDERED_ACCESS, output.desc.layout), }; device->Barrier(barriers, arraysize(barriers), cmd); } - device->UnbindUAVs(0, arraysize(uavs), cmd); } device->EventEnd(cmd); @@ -12292,21 +11751,20 @@ void Postprocess_Downsample4x( cb.xPPResolution.y = desc.Height; cb.xPPResolution_rcp.x = 1.0f / cb.xPPResolution.x; cb.xPPResolution_rcp.y = 1.0f / cb.xPPResolution.y; - device->UpdateBuffer(&constantBuffers[CBTYPE_POSTPROCESS], &cb, cmd); - device->BindConstantBuffer(CS, &constantBuffers[CBTYPE_POSTPROCESS], CB_GETBINDSLOT(PostProcessCB), cmd); + device->BindDynamicConstantBuffer(cb, CB_GETBINDSLOT(PostProcessCB), cmd); device->BindComputeShader(&shaders[CSTYPE_POSTPROCESS_DOWNSAMPLE4X], cmd); - device->BindResource(CS, &input, TEXSLOT_ONDEMAND0, cmd); + device->BindResource(&input, TEXSLOT_ONDEMAND0, cmd); const GPUResource* uavs[] = { &output, }; - device->BindUAVs(CS, uavs, 0, arraysize(uavs), cmd); + device->BindUAVs(uavs, 0, arraysize(uavs), cmd); { GPUBarrier barriers[] = { - GPUBarrier::Image(&output, output.desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS), + GPUBarrier::Image(&output, output.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS), }; device->Barrier(barriers, arraysize(barriers), cmd); } @@ -12321,12 +11779,11 @@ void Postprocess_Downsample4x( { GPUBarrier barriers[] = { GPUBarrier::Memory(), - GPUBarrier::Image(&output, IMAGE_LAYOUT_UNORDERED_ACCESS, output.desc.layout), + GPUBarrier::Image(&output, RESOURCE_STATE_UNORDERED_ACCESS, output.desc.layout), }; device->Barrier(barriers, arraysize(barriers), cmd); } - device->UnbindUAVs(0, arraysize(uavs), cmd); device->EventEnd(cmd); } void Postprocess_NormalsFromDepth( @@ -12345,21 +11802,20 @@ void Postprocess_NormalsFromDepth( cb.xPPResolution_rcp.x = 1.0f / cb.xPPResolution.x; cb.xPPResolution_rcp.y = 1.0f / cb.xPPResolution.y; cb.xPPParams0.x = floorf(std::max(1.0f, log2f(std::max((float)desc.Width / (float)depthbuffer.GetDesc().Width, (float)desc.Height / (float)depthbuffer.GetDesc().Height)))); - device->UpdateBuffer(&constantBuffers[CBTYPE_POSTPROCESS], &cb, cmd); - device->BindConstantBuffer(CS, &constantBuffers[CBTYPE_POSTPROCESS], CB_GETBINDSLOT(PostProcessCB), cmd); + device->BindDynamicConstantBuffer(cb, CB_GETBINDSLOT(PostProcessCB), cmd); device->BindComputeShader(&shaders[CSTYPE_POSTPROCESS_NORMALSFROMDEPTH], cmd); - device->BindResource(CS, &depthbuffer, TEXSLOT_DEPTH, cmd); + device->BindResource(&depthbuffer, TEXSLOT_DEPTH, cmd); const GPUResource* uavs[] = { &output, }; - device->BindUAVs(CS, uavs, 0, arraysize(uavs), cmd); + device->BindUAVs(uavs, 0, arraysize(uavs), cmd); { GPUBarrier barriers[] = { - GPUBarrier::Image(&output, output.desc.layout, IMAGE_LAYOUT_UNORDERED_ACCESS), + GPUBarrier::Image(&output, output.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS), }; device->Barrier(barriers, arraysize(barriers), cmd); } @@ -12374,12 +11830,11 @@ void Postprocess_NormalsFromDepth( { GPUBarrier barriers[] = { GPUBarrier::Memory(), - GPUBarrier::Image(&output, IMAGE_LAYOUT_UNORDERED_ACCESS, output.desc.layout), + GPUBarrier::Image(&output, RESOURCE_STATE_UNORDERED_ACCESS, output.desc.layout), }; device->Barrier(barriers, arraysize(barriers), cmd); } - device->UnbindUAVs(0, arraysize(uavs), cmd); device->EventEnd(cmd); } @@ -12484,8 +11939,6 @@ void SetOcclusionCullingEnabled(bool value) occlusionCulling = value; } bool GetOcclusionCullingEnabled() { return occlusionCulling; } -void SetLDSSkinningEnabled(bool enabled) { ldsSkinningEnabled = enabled; } -bool GetLDSSkinningEnabled() { return ldsSkinningEnabled; } void SetTemporalAAEnabled(bool enabled) { temporalAA = enabled; } bool GetTemporalAAEnabled() { return temporalAA; } void SetTemporalAADebugEnabled(bool enabled) { temporalAADEBUG = enabled; } @@ -12506,8 +11959,6 @@ void SetVoxelRadianceEnabled(bool enabled) desc.Format = FORMAT_R16G16B16A16_FLOAT; desc.BindFlags = BIND_UNORDERED_ACCESS | BIND_SHADER_RESOURCE; desc.Usage = USAGE_DEFAULT; - desc.CPUAccessFlags = 0; - desc.MiscFlags = 0; device->CreateTexture(&desc, nullptr, &textures[TEXTYPE_3D_VOXELRADIANCE]); @@ -12540,7 +11991,6 @@ void SetVoxelRadianceEnabled(bool enabled) desc.StructureByteStride = sizeof(uint32_t) * 2; desc.ByteWidth = desc.StructureByteStride * voxelSceneData.res * voxelSceneData.res * voxelSceneData.res; desc.BindFlags = BIND_UNORDERED_ACCESS | BIND_SHADER_RESOURCE; - desc.CPUAccessFlags = 0; desc.MiscFlags = RESOURCE_MISC_BUFFER_STRUCTURED; desc.Usage = USAGE_DEFAULT; @@ -12603,6 +12053,14 @@ bool IsDisableAlbedoMaps() { return disableAlbedoMaps; } +void SetForceDiffuseLighting(bool value) +{ + forceDiffuseLighting = value; +} +bool IsForceDiffuseLighting() +{ + return forceDiffuseLighting; +} void SetScreenSpaceShadowsEnabled(bool value) { SCREENSPACESHADOWS = value; @@ -12611,5 +12069,21 @@ bool GetScreenSpaceShadowsEnabled() { return SCREENSPACESHADOWS; } +void SetSurfelGIEnabled(bool value) +{ + SURFELGI = value; +} +bool GetSurfelGIEnabled() +{ + return SURFELGI; +} +void SetSurfelGIDebugEnabled(bool value) +{ + SURFELGI_DEBUG = value; +} +bool GetSurfelGIDebugEnabled() +{ + return SURFELGI_DEBUG; +} } diff --git a/WickedEngine/wiRenderer.h b/WickedEngine/wiRenderer.h index 99ac15a6f..012f9f12b 100644 --- a/WickedEngine/wiRenderer.h +++ b/WickedEngine/wiRenderer.h @@ -69,7 +69,7 @@ namespace wiRenderer wiGraphics::SHADERSTAGE stage, wiGraphics::Shader& shader, const std::string& filename, - wiGraphics::SHADERMODEL minshadermodel = wiGraphics::SHADERMODEL_5_0 + wiGraphics::SHADERMODEL minshadermodel = wiGraphics::SHADERMODEL_6_0 ); @@ -209,8 +209,6 @@ namespace wiRenderer void RefreshAtmosphericScatteringTextures(wiGraphics::CommandList cmd); // Draw skydome centered to camera. void DrawSky(const wiScene::Scene& scene, wiGraphics::CommandList cmd); - // Draw sky velocity buffer - void DrawSkyVelocity(wiGraphics::CommandList cmd); // Draw shadow maps for each visible light that has associated shadow maps void DrawSun(wiGraphics::CommandList cmd); // Draw shadow maps for each visible light that has associated shadow maps @@ -254,10 +252,8 @@ namespace wiRenderer void RefreshEnvProbes(const Visibility& vis, wiGraphics::CommandList cmd); // Call once per frame to re-render out of date impostors void RefreshImpostors(const wiScene::Scene& scene, wiGraphics::CommandList cmd); - // Call once per frame to repack out of date decals in the atlas - void RefreshDecalAtlas(const wiScene::Scene& scene, wiGraphics::CommandList cmd); // Call once per frame to repack out of date lightmaps in the atlas - void RefreshLightmapAtlas(const wiScene::Scene& scene, wiGraphics::CommandList cmd); + void RefreshLightmaps(const wiScene::Scene& scene, wiGraphics::CommandList cmd); // Voxelize the scene into a voxel grid 3D texture void VoxelRadiance(const Visibility& vis, wiGraphics::CommandList cmd); // Run a compute shader that will resolve a MSAA depth buffer to a single-sample texture @@ -301,6 +297,34 @@ namespace wiRenderer wiGraphics::CommandList cmd ); + void VisibilityResolve( + const wiGraphics::Texture& depthbuffer, + const wiGraphics::Texture& texture_primitiveID, // can be MSAA + const wiGraphics::Texture gbuffer[GBUFFER_COUNT], + const wiGraphics::Texture& depthbuffer_resolved, + const wiGraphics::Texture& lineardepth, + wiGraphics::CommandList cmd + ); + + struct SurfelGIResources + { + wiGraphics::Texture result; + }; + void CreateSurfelGIResources(SurfelGIResources& res, XMUINT2 resolution); + void SurfelGI_Coverage( + const SurfelGIResources& res, + const wiScene::Scene& scene, + const wiGraphics::Texture& depthbuffer, + const wiGraphics::Texture gbuffer[GBUFFER_COUNT], + const wiGraphics::Texture& debugUAV, + wiGraphics::CommandList cmd + ); + void SurfelGI( + const SurfelGIResources& res, + const wiScene::Scene& scene, + wiGraphics::CommandList cmd + ); + void Postprocess_Blur_Gaussian( const wiGraphics::Texture& input, const wiGraphics::Texture& temp, @@ -466,6 +490,7 @@ namespace wiRenderer const wiGraphics::Texture& depthbuffer, const wiGraphics::Texture& lineardepth, const wiGraphics::GPUBuffer& entityTiles_Opaque, + const wiGraphics::Texture gbuffer[GBUFFER_COUNT], const wiGraphics::Texture& output, wiGraphics::CommandList cmd, float range = 1, @@ -576,11 +601,6 @@ namespace wiRenderer const wiGraphics::Texture& output, wiGraphics::CommandList cmd ); - void Postprocess_DepthPyramid( - const wiGraphics::Texture& depthbuffer, - const wiGraphics::Texture& lineardepth, - wiGraphics::CommandList cmd - ); void Postprocess_Sharpen( const wiGraphics::Texture& input, const wiGraphics::Texture& output, @@ -643,7 +663,9 @@ namespace wiRenderer void RayTraceSceneBVH(const wiScene::Scene& scene, wiGraphics::CommandList cmd); // Render occluders against a depth buffer + void OcclusionCulling_Reset(const Visibility& vis, wiGraphics::CommandList cmd); void OcclusionCulling_Render(const wiScene::CameraComponent& camera_previous, const Visibility& vis, wiGraphics::CommandList cmd); + void OcclusionCulling_Resolve(const Visibility& vis, wiGraphics::CommandList cmd); enum MIPGENFILTER @@ -725,8 +747,6 @@ namespace wiRenderer bool GetVariableRateShadingClassificationDebug(); void SetOcclusionCullingEnabled(bool enabled); bool GetOcclusionCullingEnabled(); - void SetLDSSkinningEnabled(bool enabled); - bool GetLDSSkinningEnabled(); void SetTemporalAAEnabled(bool enabled); bool GetTemporalAAEnabled(); void SetTemporalAADebugEnabled(bool enabled); @@ -760,8 +780,14 @@ namespace wiRenderer bool GetTessellationEnabled(); void SetDisableAlbedoMaps(bool value); bool IsDisableAlbedoMaps(); + void SetForceDiffuseLighting(bool value); + bool IsForceDiffuseLighting(); void SetScreenSpaceShadowsEnabled(bool value); bool GetScreenSpaceShadowsEnabled(); + void SetSurfelGIEnabled(bool value); + bool GetSurfelGIEnabled(); + void SetSurfelGIDebugEnabled(bool value); + bool GetSurfelGIDebugEnabled(); // Gets pick ray according to the current screen resolution and pointer coordinates. Can be used as input into RayIntersectWorld() RAY GetPickRay(long cursorX, long cursorY, const wiCanvas& canvas, const wiScene::CameraComponent& camera = wiScene::GetCamera()); diff --git a/WickedEngine/wiResourceManager.cpp b/WickedEngine/wiResourceManager.cpp index 65d3552f4..23328d7cf 100644 --- a/WickedEngine/wiResourceManager.cpp +++ b/WickedEngine/wiResourceManager.cpp @@ -105,16 +105,13 @@ namespace wiResourceManager TextureDesc desc; desc.ArraySize = 1; desc.BindFlags = BIND_SHADER_RESOURCE; - desc.CPUAccessFlags = 0; desc.Width = dds.GetWidth(); desc.Height = dds.GetHeight(); desc.Depth = dds.GetDepth(); desc.MipLevels = dds.GetMipCount(); desc.ArraySize = dds.GetArraySize(); - desc.MiscFlags = 0; - desc.Usage = USAGE_IMMUTABLE; desc.Format = FORMAT_R8G8B8A8_UNORM; - desc.layout = IMAGE_LAYOUT_SHADER_RESOURCE; + desc.layout = RESOURCE_STATE_SHADER_RESOURCE; if (dds.IsCubemap()) { @@ -251,7 +248,7 @@ namespace wiResourceManager TextureDesc desc; desc.Height = uint32_t(height); desc.Width = uint32_t(width); - desc.layout = IMAGE_LAYOUT_SHADER_RESOURCE; + desc.layout = RESOURCE_STATE_SHADER_RESOURCE; if (flags & IMPORT_COLORGRADINGLUT) { @@ -294,12 +291,10 @@ namespace wiResourceManager else { desc.BindFlags = BIND_SHADER_RESOURCE | BIND_UNORDERED_ACCESS; - desc.CPUAccessFlags = 0; desc.Format = FORMAT_R8G8B8A8_UNORM; desc.MipLevels = (uint32_t)log2(std::max(width, height)) + 1; - desc.MiscFlags = 0; desc.Usage = USAGE_DEFAULT; - desc.layout = IMAGE_LAYOUT_SHADER_RESOURCE; + desc.layout = RESOURCE_STATE_SHADER_RESOURCE; uint32_t mipwidth = width; std::vector InitData(desc.MipLevels); diff --git a/WickedEngine/wiScene.cpp b/WickedEngine/wiScene.cpp index 2e5c081d3..abae826f3 100644 --- a/WickedEngine/wiScene.cpp +++ b/WickedEngine/wiScene.cpp @@ -11,6 +11,8 @@ #include "wiRenderer.h" #include "wiBackLog.h" +#include "shaders/ShaderInterop_SurfelGI.h" + #include #include @@ -263,7 +265,7 @@ namespace wiScene dest->sheenRoughness = sheenRoughness; dest->clearcoat = clearcoat; dest->clearcoatRoughness = clearcoatRoughness; - dest->alphaTest = 1 - alphaRef + 1.0f / 256.0f; // 256 so that it is just about smaller than 1 unorm unit (1.0/255.0) + dest->alphaTest = 1 - alphaRef; dest->layerMask = layerMask; dest->transmission = transmission; dest->options = 0; @@ -295,6 +297,14 @@ namespace wiScene { dest->options |= SHADERMATERIAL_OPTION_BIT_CAST_SHADOW; } + if (IsDoubleSided()) + { + dest->options |= SHADERMATERIAL_OPTION_BIT_DOUBLE_SIDED; + } + if (GetRenderTypes() & RENDERTYPE_TRANSPARENT) + { + dest->options |= SHADERMATERIAL_OPTION_BIT_TRANSPARENT; + } GraphicsDevice* device = wiRenderer::GetDevice(); dest->texture_basecolormap_index = device->GetDescriptorIndex(textures[BASECOLORMAP].GetGPUResource(), SRV); @@ -354,24 +364,6 @@ namespace wiScene x.resource = wiResourceManager::Load(x.name, wiResourceManager::IMPORT_RETAIN_FILEDATA); } } - - ShaderMaterial shadermat; - WriteShaderMaterial(&shadermat); - - SubresourceData data; - data.pSysMem = &shadermat; - - GraphicsDevice* device = wiRenderer::GetDevice(); - GPUBufferDesc desc; - desc.Usage = USAGE_DEFAULT; - desc.BindFlags = BIND_CONSTANT_BUFFER; - if (device->CheckCapability(GRAPHICSDEVICE_CAPABILITY_BINDLESS_DESCRIPTORS)) - { - desc.BindFlags |= BIND_SHADER_RESOURCE; - desc.MiscFlags = RESOURCE_MISC_BUFFER_ALLOW_RAW_VIEWS; - } - desc.ByteWidth = sizeof(MaterialCB); - device->CreateBuffer(&desc, &data, &constantBuffer); } uint32_t MaterialComponent::GetStencilRef() const { @@ -382,14 +374,23 @@ namespace wiScene { GraphicsDevice* device = wiRenderer::GetDevice(); + vertex_subsets.resize(vertex_positions.size()); + uint32_t subsetCounter = 0; + for (auto& subset : subsets) + { + for (uint32_t i = 0; i < subset.indexCount; ++i) + { + uint32_t index = indices[subset.indexOffset + i]; + vertex_subsets[index] = subsetCounter; + } + subsetCounter++; + } + // Create index buffer GPU data: { GPUBufferDesc bd; - bd.Usage = USAGE_IMMUTABLE; - bd.CPUAccessFlags = 0; bd.BindFlags = BIND_INDEX_BUFFER | BIND_SHADER_RESOURCE; - bd.MiscFlags = 0; - if (device->CheckCapability(GRAPHICSDEVICE_CAPABILITY_RAYTRACING_PIPELINE) || device->CheckCapability(GRAPHICSDEVICE_CAPABILITY_RAYTRACING_INLINE)) + if (device->CheckCapability(GRAPHICSDEVICE_CAPABILITY_RAYTRACING)) { bd.MiscFlags |= RESOURCE_MISC_RAY_TRACING; } @@ -451,10 +452,9 @@ namespace wiScene GPUBufferDesc bd; bd.Usage = USAGE_DEFAULT; - bd.CPUAccessFlags = 0; bd.BindFlags = BIND_VERTEX_BUFFER | BIND_SHADER_RESOURCE; - bd.MiscFlags = RESOURCE_MISC_BUFFER_ALLOW_RAW_VIEWS; - if (device->CheckCapability(GRAPHICSDEVICE_CAPABILITY_RAYTRACING_PIPELINE) || device->CheckCapability(GRAPHICSDEVICE_CAPABILITY_RAYTRACING_INLINE)) + bd.MiscFlags = RESOURCE_MISC_BUFFER_RAW; + if (device->CheckCapability(GRAPHICSDEVICE_CAPABILITY_RAYTRACING)) { bd.MiscFlags |= RESOURCE_MISC_RAY_TRACING; } @@ -549,9 +549,8 @@ namespace wiScene GPUBufferDesc bd; bd.Usage = USAGE_DEFAULT; - bd.CPUAccessFlags = 0; bd.BindFlags = BIND_VERTEX_BUFFER | BIND_SHADER_RESOURCE; - bd.MiscFlags = RESOURCE_MISC_BUFFER_ALLOW_RAW_VIEWS; + bd.MiscFlags = RESOURCE_MISC_BUFFER_RAW; bd.StructureByteStride = sizeof(Vertex_TAN); bd.ByteWidth = (uint32_t)(bd.StructureByteStride * vertices.size()); @@ -583,10 +582,8 @@ namespace wiScene } GPUBufferDesc bd; - bd.Usage = USAGE_IMMUTABLE; bd.BindFlags = BIND_SHADER_RESOURCE; - bd.CPUAccessFlags = 0; - bd.MiscFlags = RESOURCE_MISC_BUFFER_ALLOW_RAW_VIEWS; + bd.MiscFlags = RESOURCE_MISC_BUFFER_RAW; bd.ByteWidth = (uint32_t)(sizeof(Vertex_BON) * vertices.size()); SubresourceData InitData; @@ -595,8 +592,7 @@ namespace wiScene bd.Usage = USAGE_DEFAULT; bd.BindFlags = BIND_VERTEX_BUFFER | BIND_UNORDERED_ACCESS | BIND_SHADER_RESOURCE; - bd.CPUAccessFlags = 0; - bd.MiscFlags = RESOURCE_MISC_BUFFER_ALLOW_RAW_VIEWS; + bd.MiscFlags = RESOURCE_MISC_BUFFER_RAW; if (!vertex_tangents.empty()) { @@ -606,7 +602,7 @@ namespace wiScene } bd.ByteWidth = (uint32_t)(sizeof(Vertex_POS) * vertex_positions.size()); - if (device->CheckCapability(GRAPHICSDEVICE_CAPABILITY_RAYTRACING_PIPELINE) || device->CheckCapability(GRAPHICSDEVICE_CAPABILITY_RAYTRACING_INLINE)) + if (device->CheckCapability(GRAPHICSDEVICE_CAPABILITY_RAYTRACING)) { bd.MiscFlags |= RESOURCE_MISC_RAY_TRACING; } @@ -624,10 +620,8 @@ namespace wiScene } GPUBufferDesc bd; - bd.Usage = USAGE_IMMUTABLE; - bd.CPUAccessFlags = 0; bd.BindFlags = BIND_VERTEX_BUFFER | BIND_SHADER_RESOURCE; - bd.MiscFlags = RESOURCE_MISC_BUFFER_ALLOW_RAW_VIEWS; + bd.MiscFlags = RESOURCE_MISC_BUFFER_RAW; bd.StructureByteStride = sizeof(Vertex_TEX); bd.ByteWidth = (uint32_t)(bd.StructureByteStride * vertices.size()); @@ -647,10 +641,8 @@ namespace wiScene } GPUBufferDesc bd; - bd.Usage = USAGE_IMMUTABLE; - bd.CPUAccessFlags = 0; bd.BindFlags = BIND_VERTEX_BUFFER | BIND_SHADER_RESOURCE; - bd.MiscFlags = RESOURCE_MISC_BUFFER_ALLOW_RAW_VIEWS; + bd.MiscFlags = RESOURCE_MISC_BUFFER_RAW; bd.StructureByteStride = sizeof(Vertex_TEX); bd.ByteWidth = (uint32_t)(bd.StructureByteStride * vertices.size()); @@ -664,10 +656,8 @@ namespace wiScene if (!vertex_colors.empty()) { GPUBufferDesc bd; - bd.Usage = USAGE_IMMUTABLE; - bd.CPUAccessFlags = 0; bd.BindFlags = BIND_VERTEX_BUFFER | BIND_SHADER_RESOURCE; - bd.MiscFlags = RESOURCE_MISC_BUFFER_ALLOW_RAW_VIEWS; + bd.MiscFlags = RESOURCE_MISC_BUFFER_RAW; bd.StructureByteStride = sizeof(Vertex_COL); bd.ByteWidth = (uint32_t)(bd.StructureByteStride * vertex_colors.size()); @@ -687,10 +677,8 @@ namespace wiScene } GPUBufferDesc bd; - bd.Usage = USAGE_IMMUTABLE; - bd.CPUAccessFlags = 0; bd.BindFlags = BIND_VERTEX_BUFFER | BIND_SHADER_RESOURCE; - bd.MiscFlags = RESOURCE_MISC_BUFFER_ALLOW_RAW_VIEWS; + bd.MiscFlags = RESOURCE_MISC_BUFFER_RAW; bd.StructureByteStride = sizeof(Vertex_TEX); bd.ByteWidth = (uint32_t)(bd.StructureByteStride * vertices.size()); @@ -700,43 +688,22 @@ namespace wiScene device->SetName(&vertexBuffer_ATL, "vertexBuffer_ATL"); } - // vertexBuffer - SUBSETS - { - vertex_subsets.resize(vertex_positions.size()); - - uint32_t subsetCounter = 0; - for (auto& subset : subsets) - { - for (uint32_t i = 0; i < subset.indexCount; ++i) - { - uint32_t index = indices[subset.indexOffset + i]; - vertex_subsets[index] = subsetCounter; - } - subsetCounter++; - } - - GPUBufferDesc bd; - bd.Usage = USAGE_IMMUTABLE; - bd.CPUAccessFlags = 0; - bd.BindFlags = BIND_VERTEX_BUFFER | BIND_SHADER_RESOURCE; - bd.MiscFlags = 0; - bd.StructureByteStride = sizeof(uint8_t); - bd.ByteWidth = (uint32_t)(bd.StructureByteStride * vertex_subsets.size()); - bd.Format = FORMAT_R8_UINT; - - SubresourceData InitData; - InitData.pSysMem = vertex_subsets.data(); - device->CreateBuffer(&bd, &InitData, &vertexBuffer_SUB); - device->SetName(&vertexBuffer_SUB, "vertexBuffer_SUB"); - } - // vertexBuffer_PRE will be created on demand later! vertexBuffer_PRE = GPUBuffer(); + GPUBufferDesc desc; + desc.BindFlags = BIND_SHADER_RESOURCE; + desc.MiscFlags = RESOURCE_MISC_BUFFER_RAW; + desc.StructureByteStride = sizeof(ShaderMeshSubset); + desc.ByteWidth = desc.StructureByteStride * (uint32_t)subsets.size(); + bool success = device->CreateBuffer(&desc, nullptr, &subsetBuffer); + assert(success); + dirty_subsets = true; - if (device->CheckCapability(GRAPHICSDEVICE_CAPABILITY_RAYTRACING_PIPELINE) || device->CheckCapability(GRAPHICSDEVICE_CAPABILITY_RAYTRACING_INLINE)) + + if (device->CheckCapability(GRAPHICSDEVICE_CAPABILITY_RAYTRACING)) { - BLAS_state = BLAS_STATE_NEEDS_REBUILD; + BLAS_state = MeshComponent::BLAS_STATE_NEEDS_REBUILD; RaytracingAccelerationStructureDesc desc; desc.type = RaytracingAccelerationStructureDesc::BOTTOMLEVEL; @@ -770,25 +737,6 @@ namespace wiScene assert(success); device->SetName(&BLAS, "BLAS"); } - - if(device->CheckCapability(GRAPHICSDEVICE_CAPABILITY_BINDLESS_DESCRIPTORS)) - { - dirty_bindless = true; - - GPUBufferDesc desc; - desc.BindFlags = BIND_SHADER_RESOURCE; - desc.MiscFlags = RESOURCE_MISC_BUFFER_ALLOW_RAW_VIEWS; - desc.ByteWidth = sizeof(ShaderMesh); - bool success = device->CreateBuffer(&desc, nullptr, &descriptor); - assert(success); - - desc.BindFlags = BIND_SHADER_RESOURCE; - desc.MiscFlags = RESOURCE_MISC_BUFFER_STRUCTURED; - desc.StructureByteStride = sizeof(ShaderMeshSubset); - desc.ByteWidth = desc.StructureByteStride * (uint32_t)subsets.size(); - success = device->CreateBuffer(&desc, nullptr, &subsetBuffer); - assert(success); - } } void MeshComponent::WriteShaderMesh(ShaderMesh* dest) const { @@ -819,6 +767,16 @@ namespace wiScene dest->blendmaterial2 = terrain_material2_index; dest->blendmaterial3 = terrain_material3_index; dest->subsetbuffer = device->GetDescriptorIndex(&subsetBuffer, SRV); + dest->aabb_min = aabb._min; + dest->aabb_max = aabb._max; + dest->tessellation_factor = tessellationFactor; + + dest->flags = 0; + if (IsDoubleSided()) + { + dest->flags |= SHADERMESH_FLAG_DOUBLE_SIDED; + } + } void MeshComponent::ComputeNormals(COMPUTE_NORMALS compute) { @@ -1291,13 +1249,10 @@ namespace wiScene GraphicsDevice* device = wiRenderer::GetDevice(); GPUBufferDesc bd; - bd.Usage = USAGE_DYNAMIC; - bd.CPUAccessFlags = CPU_ACCESS_WRITE; - - bd.ByteWidth = sizeof(ArmatureComponent::ShaderBoneType) * (uint32_t)boneCollection.size(); + bd.ByteWidth = sizeof(ShaderTransform) * (uint32_t)boneCollection.size(); bd.BindFlags = BIND_SHADER_RESOURCE; bd.MiscFlags = RESOURCE_MISC_BUFFER_STRUCTURED; - bd.StructureByteStride = sizeof(ArmatureComponent::ShaderBoneType); + bd.StructureByteStride = sizeof(ShaderTransform); device->CreateBuffer(&bd, nullptr, &boneBuffer); } @@ -1456,9 +1411,45 @@ namespace wiScene GraphicsDevice* device = wiRenderer::GetDevice(); - if (device->CheckCapability(GRAPHICSDEVICE_CAPABILITY_RAYTRACING_PIPELINE) || device->CheckCapability(GRAPHICSDEVICE_CAPABILITY_RAYTRACING_INLINE)) + instanceData.resize(objects.GetCount() + hairs.GetCount()); + if (instanceBuffer.desc.ByteWidth < (instanceData.size() * sizeof(ShaderMeshInstance))) { - TLAS_instances.resize(objects.GetCount() * device->GetTopLevelAccelerationStructureInstanceSize()); + GPUBufferDesc desc; + desc.StructureByteStride = sizeof(ShaderMeshInstance); + desc.ByteWidth = desc.StructureByteStride * (uint32_t)instanceData.size(); + desc.BindFlags = BIND_SHADER_RESOURCE; + desc.MiscFlags = RESOURCE_MISC_BUFFER_RAW; + device->CreateBuffer(&desc, nullptr, &instanceBuffer); + device->SetName(&instanceBuffer, "instanceBuffer"); + } + + meshData.resize(meshes.GetCount() + hairs.GetCount()); + if (meshBuffer.desc.ByteWidth < (meshData.size() * sizeof(ShaderMesh))) + { + GPUBufferDesc desc; + desc.StructureByteStride = sizeof(ShaderMesh); + desc.ByteWidth = desc.StructureByteStride * (uint32_t)meshData.size(); + desc.BindFlags = BIND_SHADER_RESOURCE; + desc.MiscFlags = RESOURCE_MISC_BUFFER_RAW; + device->CreateBuffer(&desc, nullptr, &meshBuffer); + device->SetName(&meshBuffer, "meshBuffer"); + } + + materialData.resize(materials.GetCount()); + if (materialBuffer.desc.ByteWidth < (materialData.size() * sizeof(ShaderMaterial))) + { + GPUBufferDesc desc; + desc.StructureByteStride = sizeof(ShaderMaterial); + desc.ByteWidth = desc.StructureByteStride * (uint32_t)materialData.size(); + desc.BindFlags = BIND_SHADER_RESOURCE; + desc.MiscFlags = RESOURCE_MISC_BUFFER_RAW; + device->CreateBuffer(&desc, nullptr, &materialBuffer); + device->SetName(&materialBuffer, "materialBuffer"); + } + + if (device->CheckCapability(GRAPHICSDEVICE_CAPABILITY_RAYTRACING)) + { + TLAS_instances.resize(instanceData.size() * device->GetTopLevelAccelerationStructureInstanceSize()); } // Occlusion culling read: @@ -1468,13 +1459,20 @@ namespace wiScene { GPUQueryHeapDesc desc; desc.type = GPU_QUERY_TYPE_OCCLUSION_BINARY; - desc.queryCount = 2048; + desc.queryCount = 8192; + + GPUBufferDesc bd; + bd.Usage = USAGE_READBACK; + bd.ByteWidth = desc.queryCount * sizeof(uint64_t); + for (int i = 0; i < arraysize(queryHeap); ++i) { - bool success = wiRenderer::GetDevice()->CreateQueryHeap(&desc, &queryHeap[i]); + bool success = device->CreateQueryHeap(&desc, &queryHeap[i]); + assert(success); + + success = device->CreateBuffer(&bd, nullptr, &queryResultBuffer[i]); assert(success); } - queryResults.resize(desc.queryCount); } // Previously allocated and written query count (newest one) is saved: @@ -1483,17 +1481,6 @@ namespace wiScene // Advance to next query heap to use (this will be the oldest one that was written) queryheap_idx = (queryheap_idx + 1) % arraysize(queryHeap); - - // Read back data from the oldest query heap: - if (writtenQueries[queryheap_idx] > 0) - { - device->QueryRead( - &queryHeap[queryheap_idx], - 0, - writtenQueries[queryheap_idx], - queryResults.data() - ); - } } wiJobSystem::context ctx; @@ -1522,10 +1509,10 @@ namespace wiScene RunWeatherUpdateSystem(ctx); - wiPhysicsEngine::RunPhysicsUpdateSystem(ctx, *this, dt); - wiJobSystem::Wait(ctx); // dependencies + wiPhysicsEngine::RunPhysicsUpdateSystem(ctx, *this, dt); + RunObjectUpdateSystem(ctx); RunCameraUpdateSystem(ctx); @@ -1551,15 +1538,20 @@ namespace wiScene bounds = AABB::Merge(bounds, group_bound); } - if (device->CheckCapability(GRAPHICSDEVICE_CAPABILITY_RAYTRACING_PIPELINE) || device->CheckCapability(GRAPHICSDEVICE_CAPABILITY_RAYTRACING_INLINE)) + if (lightmap_refresh_needed.load()) + { + SetAccelerationStructureUpdateRequested(true); + } + + if (device->CheckCapability(GRAPHICSDEVICE_CAPABILITY_RAYTRACING)) { // Recreate top level acceleration structure if the object count changed: - if (objects.GetCount() > 0 && objects.GetCount() != TLAS.desc.toplevel.count) + if ((uint32_t)instanceData.size() != TLAS.desc.toplevel.count) { RaytracingAccelerationStructureDesc desc; desc._flags = RaytracingAccelerationStructureDesc::FLAG_PREFER_FAST_BUILD; desc.type = RaytracingAccelerationStructureDesc::TOPLEVEL; - desc.toplevel.count = (uint32_t)objects.GetCount(); + desc.toplevel.count = (uint32_t)instanceData.size(); GPUBufferDesc bufdesc; bufdesc.MiscFlags |= RESOURCE_MISC_RAY_TRACING; bufdesc.ByteWidth = desc.toplevel.count * (uint32_t)device->GetTopLevelAccelerationStructureInstanceSize(); @@ -1572,92 +1564,6 @@ namespace wiScene } } - if (lightmap_refresh_needed.load()) - { - SetAccelerationStructureUpdateRequested(true); - } - if (lightmap_repack_needed.load()) - { - std::vector bins; - if (wiRectPacker::pack(lightmap_rects.data(), (int)lightmap_rect_allocator.load(), 16384, bins)) - { - assert(bins.size() == 1 && "The regions won't fit into the texture!"); - - TextureDesc desc; - desc.Width = (uint32_t)bins[0].size.w; - desc.Height = (uint32_t)bins[0].size.h; - desc.MipLevels = 1; - desc.ArraySize = 1; - desc.Format = FORMAT_R11G11B10_FLOAT; - desc.SampleCount = 1; - desc.Usage = USAGE_DEFAULT; - desc.BindFlags = BIND_SHADER_RESOURCE | BIND_UNORDERED_ACCESS; - desc.CPUAccessFlags = 0; - desc.MiscFlags = 0; - - device->CreateTexture(&desc, nullptr, &lightmap); - device->SetName(&lightmap, "Scene::lightmap"); - } - else - { - wiBackLog::post("Global Lightmap atlas packing failed!"); - } - } - if (!lightmap.IsValid()) - { - // In case no lightmaps, still create a dummy texture - TextureDesc desc; - desc.Width = 1; - desc.Height = 1; - desc.Format = FORMAT_R11G11B10_FLOAT; - desc.BindFlags = BIND_SHADER_RESOURCE; - device->CreateTexture(&desc, nullptr, &lightmap); - } - - // Update atlas texture if it is invalidated: - if (decal_repack_needed) - { - std::vector out_rects(packedDecals.size()); - int i = 0; - for (auto& it : packedDecals) - { - out_rects[i] = &it.second; - i++; - } - - std::vector bins; - if (wiRectPacker::pack(out_rects.data(), (int)packedDecals.size(), 16384, bins)) - { - assert(bins.size() == 1 && "The regions won't fit into the texture!"); - - TextureDesc desc; - desc.Width = (uint32_t)bins[0].size.w; - desc.Height = (uint32_t)bins[0].size.h; - desc.MipLevels = 0; - desc.ArraySize = 1; - desc.Format = FORMAT_R8G8B8A8_UNORM; - desc.SampleCount = 1; - desc.Usage = USAGE_DEFAULT; - desc.BindFlags = BIND_SHADER_RESOURCE | BIND_UNORDERED_ACCESS; - desc.CPUAccessFlags = 0; - desc.MiscFlags = 0; - - device->CreateTexture(&desc, nullptr, &decalAtlas); - device->SetName(&decalAtlas, "Scene::decalAtlas"); - - for (uint32_t i = 0; i < decalAtlas.GetDesc().MipLevels; ++i) - { - int subresource_index; - subresource_index = device->CreateSubresource(&decalAtlas, UAV, 0, 1, i, 1); - assert(subresource_index == i); - } - } - else - { - wiBackLog::post("Decal atlas packing failed!"); - } - } - // Update water ripples: for (size_t i = 0; i < waterRipples.size(); ++i) { @@ -1673,6 +1579,64 @@ namespace wiScene } } + if (wiRenderer::GetSurfelGIEnabled() && !surfelBuffer.IsValid()) + { + GPUBufferDesc desc; + desc.StructureByteStride = sizeof(Surfel); + desc.ByteWidth = desc.StructureByteStride * SURFEL_CAPACITY; + desc.MiscFlags = RESOURCE_MISC_BUFFER_STRUCTURED; + desc.BindFlags = BIND_SHADER_RESOURCE | BIND_UNORDERED_ACCESS; + device->CreateBuffer(&desc, nullptr, &surfelBuffer); + device->SetName(&surfelBuffer, "surfelBuffer"); + + desc.StructureByteStride = sizeof(SurfelData); + desc.ByteWidth = desc.StructureByteStride * SURFEL_CAPACITY; + desc.MiscFlags = RESOURCE_MISC_BUFFER_STRUCTURED; + device->CreateBuffer(&desc, nullptr, &surfelDataBuffer); + device->SetName(&surfelDataBuffer, "surfelDataBuffer"); + + desc.StructureByteStride = sizeof(uint); + desc.ByteWidth = desc.StructureByteStride * 5; + desc.MiscFlags = RESOURCE_MISC_BUFFER_RAW | RESOURCE_MISC_INDIRECT_ARGS; + device->CreateBuffer(&desc, nullptr, &surfelStatsBuffer); + device->SetName(&surfelStatsBuffer, "surfelStatsBuffer"); + + desc.StructureByteStride = sizeof(SurfelGridCell); + desc.ByteWidth = desc.StructureByteStride * SURFEL_TABLE_SIZE; + desc.MiscFlags = RESOURCE_MISC_BUFFER_STRUCTURED; + device->CreateBuffer(&desc, nullptr, &surfelGridBuffer); + device->SetName(&surfelGridBuffer, "surfelGridBuffer"); + + desc.StructureByteStride = sizeof(uint); + desc.ByteWidth = desc.StructureByteStride * SURFEL_CAPACITY * 27; // each surfel can be in 3x3x3=27 cells + desc.MiscFlags = RESOURCE_MISC_BUFFER_STRUCTURED; + device->CreateBuffer(&desc, nullptr, &surfelCellBuffer); + device->SetName(&surfelCellBuffer, "surfelCellBuffer"); + + TextureDesc tex; + tex.Width = SURFEL_MOMENT_ATLAS_TEXELS; + tex.Height = SURFEL_MOMENT_ATLAS_TEXELS; + tex.Format = FORMAT_R16G16_FLOAT; + tex.BindFlags = BIND_UNORDERED_ACCESS | BIND_SHADER_RESOURCE; + device->CreateTexture(&tex, nullptr, &surfelMomentsTexture); + device->SetName(&surfelMomentsTexture, "surfelMomentsTexture"); + } + + // Bindless scene resources: + shaderscene.instancebuffer = device->GetDescriptorIndex(&instanceBuffer, SRV); + shaderscene.meshbuffer = device->GetDescriptorIndex(&meshBuffer, SRV); + shaderscene.materialbuffer = device->GetDescriptorIndex(&materialBuffer, SRV); + shaderscene.TLAS = device->GetDescriptorIndex(&TLAS, SRV); + shaderscene.envmaparray = device->GetDescriptorIndex(&envmapArray, SRV); + + if (weather.skyMap == nullptr) + { + shaderscene.globalenvmap = -1; + } + else + { + shaderscene.globalenvmap = device->GetDescriptorIndex(&weather.skyMap->texture, SRV); + } } void Scene::Clear() { @@ -1708,8 +1672,13 @@ namespace wiScene TLAS = RaytracingAccelerationStructure(); BVH.Clear(); - packedDecals.clear(); waterRipples.clear(); + + surfelBuffer = {}; + surfelDataBuffer = {}; + surfelStatsBuffer = {}; + surfelGridBuffer = {}; + surfelCellBuffer = {}; } void Scene::Merge(Scene& other) { @@ -2700,7 +2669,9 @@ namespace wiScene XMMATRIX W = XMLoadFloat4x4(&bone.world); XMMATRIX M = B * W * R; - armature.boneData[boneIndex++].Store(M); + XMFLOAT4X4 mat; + XMStoreFloat4x4(&mat, M); + armature.boneData[boneIndex++].Create(mat); const float bone_radius = 1; XMFLOAT3 bonepos = bone.GetPosition(); @@ -2712,7 +2683,7 @@ namespace wiScene armature.aabb = AABB(_min, _max); - if (!armature.boneBuffer.IsValid()) + if (!armature.boneBuffer.IsValid() || armature.boneBuffer.desc.ByteWidth != armature.boneData.size() * sizeof(ShaderTransform)) { armature.CreateRenderData(); } @@ -2726,12 +2697,18 @@ namespace wiScene MeshComponent& mesh = meshes[args.jobIndex]; GraphicsDevice* device = wiRenderer::GetDevice(); - if (mesh.IsSkinned() && armatures.Contains(mesh.armatureID)) + if (!mesh.vertexBuffer_PRE.IsValid()) { const SoftBodyPhysicsComponent* softbody = softbodies.GetComponent(entity); - if (softbody == nullptr || softbody->vertex_positions_simulation.empty()) + if (softbody != nullptr && wiPhysicsEngine::IsSimulationEnabled()) { - if (!mesh.vertexBuffer_PRE.IsValid()) + device->CreateBuffer(&mesh.vertexBuffer_POS.desc, nullptr, &mesh.streamoutBuffer_POS); + device->CreateBuffer(&mesh.vertexBuffer_POS.desc, nullptr, &mesh.vertexBuffer_PRE); + device->CreateBuffer(&mesh.vertexBuffer_TAN.desc, nullptr, &mesh.streamoutBuffer_TAN); + } + else if (mesh.IsSkinned() && armatures.Contains(mesh.armatureID)) + { + if (softbody == nullptr || softbody->vertex_positions_simulation.empty()) { device->CreateBuffer(&mesh.streamoutBuffer_POS.GetDesc(), nullptr, &mesh.vertexBuffer_PRE); } @@ -2740,7 +2717,6 @@ namespace wiScene if (mesh.streamoutBuffer_POS.IsValid() && mesh.vertexBuffer_PRE.IsValid()) { - mesh.dirty_bindless = true; std::swap(mesh.streamoutBuffer_POS, mesh.vertexBuffer_PRE); } @@ -2772,6 +2748,10 @@ namespace wiScene mesh.BLAS_state = MeshComponent::BLAS_STATE_NEEDS_REBUILD; geometry.triangles.vertexBuffer = mesh.streamoutBuffer_POS; } + if (material->IsDoubleSided()) + { + mesh._flags |= MeshComponent::TLAS_FORCE_DOUBLE_SIDED; + } } } else @@ -2789,48 +2769,9 @@ namespace wiScene } } - if (device->CheckCapability(GRAPHICSDEVICE_CAPABILITY_BINDLESS_DESCRIPTORS)) - { - if (mesh.terrain_material1 != INVALID_ENTITY) - { - const MaterialComponent* mat = materials.GetComponent(mesh.terrain_material1); - if (mat != nullptr) - { - int index = device->GetDescriptorIndex(&mat->constantBuffer, SRV); - if (mesh.terrain_material1_index != index) - { - mesh.dirty_bindless = true; - mesh.terrain_material1_index = index; - } - } - } - if (mesh.terrain_material2 != INVALID_ENTITY) - { - const MaterialComponent* mat = materials.GetComponent(mesh.terrain_material2); - if (mat != nullptr) - { - int index = device->GetDescriptorIndex(&mat->constantBuffer, SRV); - if (mesh.terrain_material2_index != index) - { - mesh.dirty_bindless = true; - mesh.terrain_material2_index = index; - } - } - } - if (mesh.terrain_material3 != INVALID_ENTITY) - { - const MaterialComponent* mat = materials.GetComponent(mesh.terrain_material3); - if (mat != nullptr) - { - int index = device->GetDescriptorIndex(&mat->constantBuffer, SRV); - if (mesh.terrain_material3_index != index) - { - mesh.dirty_bindless = true; - mesh.terrain_material3_index = index; - } - } - } - } + mesh.terrain_material1_index = (uint32_t)materials.GetIndex(mesh.terrain_material1); + mesh.terrain_material2_index = (uint32_t)materials.GetIndex(mesh.terrain_material2); + mesh.terrain_material3_index = (uint32_t)materials.GetIndex(mesh.terrain_material3); // Update morph targets if needed: if (mesh.dirty_morph && !mesh.targets.empty()) @@ -2868,6 +2809,9 @@ namespace wiScene mesh.aabb = AABB(_min, _max); } + ShaderMesh& shadermesh = meshData[args.jobIndex]; + mesh.WriteShaderMesh(&shadermesh); + }); } void Scene::RunMaterialUpdateSystem(wiJobSystem::context& ctx) @@ -2882,11 +2826,6 @@ namespace wiScene material.layerMask = layer->layerMask; } - if (!material.constantBuffer.IsValid()) - { - material.CreateRenderData(); - } - material.texAnimElapsedTime += dt * material.texAnimFrameRate; if (material.texAnimElapsedTime >= 1.0f) { @@ -2906,9 +2845,11 @@ namespace wiScene if (material.IsDirty()) { material.SetDirty(false); - material.dirty_buffer = true; } + ShaderMaterial& shadermat = materialData[args.jobIndex]; + material.WriteShaderMaterial(&shadermat); + }); } void Scene::RunImpostorUpdateSystem(wiJobSystem::context& ctx) @@ -2924,14 +2865,14 @@ namespace wiScene desc.BindFlags = BIND_DEPTH_STENCIL; desc.ArraySize = 1; desc.Format = FORMAT_D16_UNORM; - desc.layout = IMAGE_LAYOUT_DEPTHSTENCIL; + desc.layout = RESOURCE_STATE_DEPTHSTENCIL; device->CreateTexture(&desc, nullptr, &impostorDepthStencil); device->SetName(&impostorDepthStencil, "impostorDepthStencil"); desc.BindFlags = BIND_RENDER_TARGET | BIND_SHADER_RESOURCE | BIND_UNORDERED_ACCESS; desc.ArraySize = maxImpostorCount * impostorCaptureAngles * 3; desc.Format = FORMAT_R8G8B8A8_UNORM; - desc.layout = IMAGE_LAYOUT_SHADER_RESOURCE; + desc.layout = RESOURCE_STATE_SHADER_RESOURCE; device->CreateTexture(&desc, nullptr, &impostorArray); device->SetName(&impostorArray, "impostorArray"); @@ -2969,7 +2910,7 @@ namespace wiScene ImpostorComponent& impostor = impostors[args.jobIndex]; impostor.aabb = AABB(); - impostor.instanceMatrices.clear(); + impostor.instances.clear(); if (impostor.IsDirty()) { @@ -2982,9 +2923,6 @@ namespace wiScene { assert(objects.GetCount() == aabb_objects.GetCount()); - lightmap_rects.resize(objects.GetCount()); - lightmap_rect_allocator.store(0); - parallel_bounds.clear(); parallel_bounds.resize((size_t)wiJobSystem::DispatchGroupCount((uint32_t)objects.GetCount(), small_subtask_groupsize)); @@ -2998,9 +2936,9 @@ namespace wiScene { object.occlusionHistory <<= 1; // advance history by 1 frame int query_id = object.occlusionQueries[queryheap_idx]; - if (query_id >= 0 && (int)writtenQueries[queryheap_idx] > query_id) + if (queryResultBuffer[queryheap_idx].mapped_data != nullptr && query_id >= 0 && (int)writtenQueries[queryheap_idx] > query_id) { - uint64_t visible = queryResults[query_id]; + uint64_t visible = ((uint64_t*)queryResultBuffer[queryheap_idx].mapped_data)[query_id]; if (visible) { object.occlusionHistory |= 1; // visible @@ -3082,12 +3020,7 @@ namespace wiScene const SPHERE boundingsphere = mesh->GetBoundingSphere(); locker.lock(); - impostor->instanceMatrices.emplace_back(); - XMStoreFloat4x4(&impostor->instanceMatrices.back(), - XMMatrixScaling(boundingsphere.radius, boundingsphere.radius, boundingsphere.radius) * - XMMatrixTranslation(boundingsphere.center.x, boundingsphere.center.y, boundingsphere.center.z) * - W - ); + impostor->instances.push_back(args.jobIndex); locker.unlock(); } @@ -3113,26 +3046,55 @@ namespace wiScene object.prev_transform_index = -1; } - if (TLAS.IsValid()) + // Create GPU instance data: + const XMFLOAT4X4& worldMatrix = object.transform_index >= 0 ? transforms[object.transform_index].world : IDENTITYMATRIX; + const XMFLOAT4X4& worldMatrixPrev = object.prev_transform_index >= 0 ? prev_transforms[object.prev_transform_index].world_prev : IDENTITYMATRIX; + + XMMATRIX worldMatrixInverseTranspose = XMLoadFloat4x4(&worldMatrix); + worldMatrixInverseTranspose = XMMatrixInverse(nullptr, worldMatrixInverseTranspose); + worldMatrixInverseTranspose = XMMatrixTranspose(worldMatrixInverseTranspose); + XMFLOAT4X4 transformIT; + XMStoreFloat4x4(&transformIT, worldMatrixInverseTranspose); + + GraphicsDevice* device = wiRenderer::GetDevice(); + ShaderMeshInstance& inst = instanceData[args.jobIndex]; + inst.init(); + inst.transform.Create(worldMatrix); + inst.transformInverseTranspose.Create(transformIT); + inst.transformPrev.Create(worldMatrixPrev); + if (object.lightmap.IsValid()) { - GraphicsDevice* device = wiRenderer::GetDevice(); + inst.lightmap = device->GetDescriptorIndex(&object.lightmap, SRV); + } + inst.uid = entity; + inst.color = wiMath::CompressColor(object.color); + inst.emissive = wiMath::CompressColor(object.emissiveColor); + inst.meshIndex = (uint)meshes.GetIndex(object.meshID); + + if (!TLAS_instances.empty()) + { + // TLAS instance data: RaytracingAccelerationStructureDesc::TopLevel::Instance instance = {}; - const XMFLOAT4X4& worldMatrix = object.transform_index >= 0 ? transforms[object.transform_index].world : IDENTITYMATRIX; instance = {}; instance.transform = XMFLOAT3X4( worldMatrix._11, worldMatrix._21, worldMatrix._31, worldMatrix._41, worldMatrix._12, worldMatrix._22, worldMatrix._32, worldMatrix._42, worldMatrix._13, worldMatrix._23, worldMatrix._33, worldMatrix._43 ); - instance.InstanceID = (uint32_t)device->GetDescriptorIndex(&mesh->descriptor, SRV); + instance.InstanceID = args.jobIndex; instance.InstanceMask = 1; instance.bottomlevel = mesh->BLAS; + if (mesh->IsDoubleSided() || mesh->_flags & MeshComponent::TLAS_FORCE_DOUBLE_SIDED) + { + instance.Flags |= RaytracingAccelerationStructureDesc::TopLevel::Instance::FLAG_TRIANGLE_CULL_DISABLE; + } + if (XMVectorGetX(XMMatrixDeterminant(W)) > 0) { // There is a mismatch between object space winding and BLAS winding: // https://docs.microsoft.com/en-us/windows/win32/api/d3d12/ne-d3d12-d3d12_raytracing_instance_flags - instance.Flags = RaytracingAccelerationStructureDesc::TopLevel::Instance::FLAG_TRIANGLE_FRONT_COUNTERCLOCKWISE; + instance.Flags |= RaytracingAccelerationStructureDesc::TopLevel::Instance::FLAG_TRIANGLE_FRONT_COUNTERCLOCKWISE; } void* dest = (void*)((size_t)TLAS_instances.data() + (size_t)args.jobIndex * device->GetTopLevelAccelerationStructureInstanceSize()); @@ -3140,60 +3102,44 @@ namespace wiScene } // lightmap things: - if (dt > 0) + if (object.IsLightmapRenderRequested() && dt > 0) { - if (object.IsLightmapRenderRequested() && dt > 0) + if (!object.lightmap.IsValid()) { - if (!object.lightmap.IsValid()) { - { - // Unfortunately, fp128 format only correctly downloads from GPU if it is pow2 size: - object.lightmapWidth = wiMath::GetNextPowerOfTwo(object.lightmapWidth + 1) / 2; - object.lightmapHeight = wiMath::GetNextPowerOfTwo(object.lightmapHeight + 1) / 2; - } - - TextureDesc desc; - desc.Width = object.lightmapWidth; - desc.Height = object.lightmapHeight; - desc.BindFlags = BIND_RENDER_TARGET | BIND_SHADER_RESOURCE; - // Note: we need the full precision format to achieve correct accumulative blending! - // But the global atlas will have less precision for good bandwidth for sampling - desc.Format = FORMAT_R32G32B32A32_FLOAT; - - GraphicsDevice* device = wiRenderer::GetDevice(); - device->CreateTexture(&desc, nullptr, &object.lightmap); - device->SetName(&object.lightmap, "object.lightmap"); - - RenderPassDesc renderpassdesc; - - renderpassdesc.attachments.push_back(RenderPassAttachment::RenderTarget(&object.lightmap, RenderPassAttachment::LOADOP_CLEAR)); - - device->CreateRenderPass(&renderpassdesc, &object.renderpass_lightmap_clear); - - renderpassdesc.attachments.back().loadop = RenderPassAttachment::LOADOP_LOAD; - device->CreateRenderPass(&renderpassdesc, &object.renderpass_lightmap_accumulate); + // Unfortunately, fp128 format only correctly downloads from GPU if it is pow2 size: + object.lightmapWidth = wiMath::GetNextPowerOfTwo(object.lightmapWidth + 1) / 2; + object.lightmapHeight = wiMath::GetNextPowerOfTwo(object.lightmapHeight + 1) / 2; } - lightmap_refresh_needed.store(true); - } - if (!object.lightmapTextureData.empty() && !object.lightmap.IsValid()) - { - // Create a GPU-side per object lighmap if there is none yet, so that copying into atlas can be done efficiently: - wiTextureHelper::CreateTexture(object.lightmap, object.lightmapTextureData.data(), object.lightmapWidth, object.lightmapHeight, object.GetLightmapFormat()); - } + TextureDesc desc; + desc.Width = object.lightmapWidth; + desc.Height = object.lightmapHeight; + desc.BindFlags = BIND_RENDER_TARGET | BIND_SHADER_RESOURCE; + // Note: we need the full precision format to achieve correct accumulative blending! + // But the global atlas will have less precision for good bandwidth for sampling + desc.Format = FORMAT_R32G32B32A32_FLOAT; - if (object.lightmap.IsValid()) - { - if (object.lightmap_rect.w == 0) - { - // we need to pack this lightmap texture into the atlas - object.lightmap_rect = wiRectPacker::rect_xywh(0, 0, object.lightmap.GetDesc().Width + atlasClampBorder * 2, object.lightmap.GetDesc().Height + atlasClampBorder * 2); - lightmap_repack_needed.store(true); // will need to repack all in this case! - } - // lightmap rects' state is always updated, in case one needs repacking - uint32_t alloc = lightmap_rect_allocator.fetch_add(1); - lightmap_rects[alloc] = &object.lightmap_rect; + GraphicsDevice* device = wiRenderer::GetDevice(); + device->CreateTexture(&desc, nullptr, &object.lightmap); + device->SetName(&object.lightmap, "object.lightmap"); + + RenderPassDesc renderpassdesc; + + renderpassdesc.attachments.push_back(RenderPassAttachment::RenderTarget(&object.lightmap, RenderPassAttachment::LOADOP_CLEAR)); + + device->CreateRenderPass(&renderpassdesc, &object.renderpass_lightmap_clear); + + renderpassdesc.attachments.back().loadop = RenderPassAttachment::LOADOP_LOAD; + device->CreateRenderPass(&renderpassdesc, &object.renderpass_lightmap_accumulate); } + lightmap_refresh_needed.store(true); + } + + if (!object.lightmapTextureData.empty() && !object.lightmap.IsValid()) + { + // Create a GPU-side per object lighmap if there is none yet, so that copying into atlas can be done efficiently: + wiTextureHelper::CreateTexture(object.lightmap, object.lightmapTextureData.data(), object.lightmapWidth, object.lightmapHeight, object.GetLightmapFormat()); } } @@ -3281,18 +3227,6 @@ namespace wiScene decal.emissive = material.GetEmissiveStrength(); decal.texture = material.textures[MaterialComponent::BASECOLORMAP].resource; decal.normal = material.textures[MaterialComponent::NORMALMAP].resource; - - // atlas part is not thread safe: - if (decal.texture != nullptr && decal.texture->texture.IsValid()) - { - if (packedDecals.find(decal.texture) == packedDecals.end()) - { - // we need to pack this decal texture into the atlas - wiRectPacker::rect_xywh newRect = wiRectPacker::rect_xywh(0, 0, decal.texture->texture.desc.Width + atlasClampBorder * 2, decal.texture->texture.desc.Height + atlasClampBorder * 2); - packedDecals[decal.texture] = newRect; - decal_repack_needed = true; - } - } } } void Scene::RunProbeUpdateSystem(wiJobSystem::context& ctx) @@ -3306,28 +3240,26 @@ namespace wiScene TextureDesc desc; desc.ArraySize = 6; desc.BindFlags = BIND_DEPTH_STENCIL; - desc.CPUAccessFlags = 0; desc.Format = FORMAT_D16_UNORM; desc.Height = envmapRes; desc.Width = envmapRes; desc.MipLevels = 1; desc.MiscFlags = RESOURCE_MISC_TEXTURECUBE; desc.Usage = USAGE_DEFAULT; - desc.layout = IMAGE_LAYOUT_DEPTHSTENCIL; + desc.layout = RESOURCE_STATE_DEPTHSTENCIL; device->CreateTexture(&desc, nullptr, &envrenderingDepthBuffer); device->SetName(&envrenderingDepthBuffer, "envrenderingDepthBuffer"); desc.ArraySize = envmapCount * 6; desc.BindFlags = BIND_SHADER_RESOURCE | BIND_RENDER_TARGET | BIND_UNORDERED_ACCESS; - desc.CPUAccessFlags = 0; desc.Format = FORMAT_R11G11B10_FLOAT; desc.Height = envmapRes; desc.Width = envmapRes; desc.MipLevels = envmapMIPs; desc.MiscFlags = RESOURCE_MISC_TEXTURECUBE; desc.Usage = USAGE_DEFAULT; - desc.layout = IMAGE_LAYOUT_SHADER_RESOURCE; + desc.layout = RESOURCE_STATE_SHADER_RESOURCE; device->CreateTexture(&desc, nullptr, &envmapArray); device->SetName(&envmapArray, "envmapArray"); @@ -3557,6 +3489,45 @@ namespace wiScene const TransformComponent& transform = *transforms.GetComponent(entity); hair.UpdateCPU(transform, *mesh, dt); + + GraphicsDevice* device = wiRenderer::GetDevice(); + + size_t meshIndex = meshes.GetCount() + args.jobIndex; + ShaderMesh& mesh = meshData[meshIndex]; + mesh.ib = device->GetDescriptorIndex(&hair.primitiveBuffer, SRV); + mesh.vb_pos_nor_wind = device->GetDescriptorIndex(&hair.vertexBuffer_POS[0], SRV); + mesh.vb_pre = device->GetDescriptorIndex(&hair.vertexBuffer_POS[1], SRV); + mesh.vb_uv0 = device->GetDescriptorIndex(&hair.vertexBuffer_TEX, SRV); + mesh.subsetbuffer = device->GetDescriptorIndex(&hair.subsetBuffer, SRV); + mesh.flags |= SHADERMESH_FLAG_DOUBLE_SIDED; + + size_t instanceIndex = objects.GetCount() + args.jobIndex; + ShaderMeshInstance& inst = instanceData[instanceIndex]; + inst.init(); + inst.uid = entity; + // every vertex is pretransformed and simulated in worldspace for hair particle: + inst.transform.Create(IDENTITYMATRIX); + inst.transformPrev.Create(IDENTITYMATRIX); + inst.meshIndex = (uint)meshIndex; + + if (!TLAS_instances.empty()) + { + // TLAS instance data: + RaytracingAccelerationStructureDesc::TopLevel::Instance instance = {}; + instance = {}; + instance.transform = XMFLOAT3X4( + IDENTITYMATRIX._11, IDENTITYMATRIX._21, IDENTITYMATRIX._31, IDENTITYMATRIX._41, + IDENTITYMATRIX._12, IDENTITYMATRIX._22, IDENTITYMATRIX._32, IDENTITYMATRIX._42, + IDENTITYMATRIX._13, IDENTITYMATRIX._23, IDENTITYMATRIX._33, IDENTITYMATRIX._43 + ); + instance.InstanceID = (uint32_t)instanceIndex; + instance.InstanceMask = 1; + instance.bottomlevel = hair.BLAS; + instance.Flags = RaytracingAccelerationStructureDesc::TopLevel::Instance::FLAG_TRIANGLE_CULL_DISABLE; + + void* dest = (void*)((size_t)TLAS_instances.data() + instanceIndex * device->GetTopLevelAccelerationStructureInstanceSize()); + device->WriteTopLevelAccelerationStructureInstance(&instance, dest); + } } } @@ -3643,11 +3614,17 @@ namespace wiScene const XMUINT4& ind = mesh.vertex_boneindices[index]; const XMFLOAT4& wei = mesh.vertex_boneweights[index]; + const XMFLOAT4X4 mat[] = { + armature.boneData[ind.x].GetMatrix(), + armature.boneData[ind.y].GetMatrix(), + armature.boneData[ind.z].GetMatrix(), + armature.boneData[ind.w].GetMatrix(), + }; const XMMATRIX M[] = { - armature.boneData[ind.x].Load(), - armature.boneData[ind.y].Load(), - armature.boneData[ind.z].Load(), - armature.boneData[ind.w].Load(), + XMMatrixTranspose(XMLoadFloat4x4(&mat[0])), + XMMatrixTranspose(XMLoadFloat4x4(&mat[1])), + XMMatrixTranspose(XMLoadFloat4x4(&mat[2])), + XMMatrixTranspose(XMLoadFloat4x4(&mat[3])), }; XMVECTOR skinned; diff --git a/WickedEngine/wiScene.h b/WickedEngine/wiScene.h index 6e1d31278..66d307cc2 100644 --- a/WickedEngine/wiScene.h +++ b/WickedEngine/wiScene.h @@ -223,9 +223,7 @@ namespace wiScene int customShaderID = -1; // Non-serialized attributes: - wiGraphics::GPUBuffer constantBuffer; uint32_t layerMask = ~0u; - mutable bool dirty_buffer = false; // User stencil value can be in range [0, 15] inline void SetUserStencilRef(uint8_t value) @@ -324,6 +322,7 @@ namespace wiScene TERRAIN = 1 << 3, _DEPRECATED_DIRTY_MORPH = 1 << 4, _DEPRECATED_DIRTY_BINDLESS = 1 << 5, + TLAS_FORCE_DOUBLE_SIDED = 1 << 6, }; uint32_t _flags = RENDERABLE; @@ -384,9 +383,7 @@ namespace wiScene wiGraphics::GPUBuffer vertexBuffer_PRE; wiGraphics::GPUBuffer streamoutBuffer_POS; wiGraphics::GPUBuffer streamoutBuffer_TAN; - wiGraphics::GPUBuffer vertexBuffer_SUB; std::vector vertex_subsets; - wiGraphics::GPUBuffer descriptor; wiGraphics::GPUBuffer subsetBuffer; wiGraphics::RaytracingAccelerationStructure BLAS; @@ -399,12 +396,12 @@ namespace wiScene mutable BLAS_STATE BLAS_state = BLAS_STATE_NEEDS_REBUILD; // Only valid for 1 frame material component indices: - int terrain_material1_index = -1; - int terrain_material2_index = -1; - int terrain_material3_index = -1; + uint32_t terrain_material1_index = ~0u; + uint32_t terrain_material2_index = ~0u; + uint32_t terrain_material3_index = ~0u; mutable bool dirty_morph = false; - mutable bool dirty_bindless = true; + mutable bool dirty_subsets = true; inline void SetRenderable(bool value) { if (value) { _flags |= RENDERABLE; } else { _flags &= ~RENDERABLE; } } inline void SetDoubleSided(bool value) { if (value) { _flags |= DOUBLE_SIDED; } else { _flags &= ~DOUBLE_SIDED; } } @@ -596,7 +593,7 @@ namespace wiScene AABB aabb; XMFLOAT4 color; float fadeThresholdRadius; - std::vector instanceMatrices; + std::vector instances; mutable bool render_dirty = false; inline void SetDirty(bool value = true) { if (value) { _flags |= DIRTY; } else { _flags &= ~DIRTY; } } @@ -794,31 +791,7 @@ namespace wiScene // Non-serialized attributes: AABB aabb; - struct ShaderBoneType - { - XMFLOAT4 pose0; - XMFLOAT4 pose1; - XMFLOAT4 pose2; - - inline void Store(const XMMATRIX& M) - { - XMFLOAT4X4 mat; - XMStoreFloat4x4(&mat, M); - pose0 = XMFLOAT4(mat._11, mat._21, mat._31, mat._41); - pose1 = XMFLOAT4(mat._12, mat._22, mat._32, mat._42); - pose2 = XMFLOAT4(mat._13, mat._23, mat._33, mat._43); - } - inline XMMATRIX Load() const - { - return XMMATRIX( - pose0.x, pose1.x, pose2.x, 0, - pose0.y, pose1.y, pose2.y, 0, - pose0.z, pose1.z, pose2.z, 0, - pose0.w, pose1.w, pose2.w, 1 - ); - } - }; - std::vector boneData; + std::vector boneData; wiGraphics::GPUBuffer boneBuffer; void CreateRenderData(); @@ -1297,13 +1270,42 @@ namespace wiScene void SetAccelerationStructureUpdateRequested(bool value = true) { acceleration_structure_update_requested = value; } bool IsAccelerationStructureUpdateRequested() const { return acceleration_structure_update_requested; } + // Shader visible scene parameters: + ShaderScene shaderscene; + + // Instances for bindless visiblity indexing: + // contains in order: + // 1) objects + // 2) hair particles + std::vector instanceData; + wiGraphics::GPUBuffer instanceBuffer; + + // Meshes for bindless visiblity indexing: + // contains in order: + // 1) meshes + // 2) hair particles + std::vector meshData; + wiGraphics::GPUBuffer meshBuffer; + + std::vector materialData; + wiGraphics::GPUBuffer materialBuffer; + // Occlusion query state: wiGraphics::GPUQueryHeap queryHeap[arraysize(ObjectComponent::occlusionQueries)]; - std::vector queryResults; + wiGraphics::GPUBuffer queryResultBuffer[arraysize(queryHeap)]; uint32_t writtenQueries[arraysize(queryHeap)] = {}; int queryheap_idx = 0; std::atomic queryAllocator{ 0 }; + // Surfel GI resources: + wiGraphics::GPUBuffer surfelBuffer; + wiGraphics::GPUBuffer surfelDataBuffer; + wiGraphics::GPUBuffer surfelStatsBuffer; + wiGraphics::GPUBuffer surfelGridBuffer; + wiGraphics::GPUBuffer surfelCellBuffer; + wiGraphics::Texture surfelMomentsTexture; + + // Environment probe cubemap array state: static constexpr uint32_t envmapCount = 16; static constexpr uint32_t envmapRes = 128; @@ -1319,21 +1321,8 @@ namespace wiScene wiGraphics::Texture impostorArray; std::vector renderpasses_impostor; - // Atlas packing border size in pixels: - static constexpr int atlasClampBorder = 1; - - // Lightmap atlas state: - wiGraphics::Texture lightmap; - std::vector lightmap_rects; - std::atomic lightmap_rect_allocator{ 0 }; - mutable std::atomic_bool lightmap_repack_needed{ false }; mutable std::atomic_bool lightmap_refresh_needed{ false }; - // Decal atlas state: - wiGraphics::Texture decalAtlas; - mutable bool decal_repack_needed{ false }; - std::unordered_map, wiRectPacker::rect_xywh> packedDecals; - // Ocean GPU state: wiOcean ocean; void OceanRegenerate() { ocean.Create(weather.oceanParameters); } diff --git a/WickedEngine/wiShaderCompiler.cpp b/WickedEngine/wiShaderCompiler.cpp index 31a238aa7..8b36e3812 100644 --- a/WickedEngine/wiShaderCompiler.cpp +++ b/WickedEngine/wiShaderCompiler.cpp @@ -12,7 +12,7 @@ #ifdef PLATFORM_WINDOWS_DESKTOP #define SHADERCOMPILER_ENABLED #define SHADERCOMPILER_ENABLED_DXCOMPILER -#define SHADERCOMPILER_ENABLED_D3DCOMPILER +//#define SHADERCOMPILER_ENABLED_D3DCOMPILER #include // ComPtr #endif // _WIN32 @@ -57,6 +57,10 @@ namespace wiShaderCompiler //L"-no-legacy-cbuf-layout", //L"-pack-optimized", //L"-all-resources-bound", + //L"-Gis", // Force IEEE strictness + //L"-Gec", // Enable backward compatibility mode + //L"-Ges", // Enable strict mode + //L"-O0", // Optimization Level 0 }; if (input.flags & FLAG_DISABLE_OPTIMIZATION) diff --git a/WickedEngine/wiTextureHelper.cpp b/WickedEngine/wiTextureHelper.cpp index 2c71017cd..261c493e7 100644 --- a/WickedEngine/wiTextureHelper.cpp +++ b/WickedEngine/wiTextureHelper.cpp @@ -95,11 +95,9 @@ namespace wiTextureHelper texDesc.MipLevels = 1; texDesc.ArraySize = 6; texDesc.Format = FORMAT_R8G8B8A8_UNORM; - texDesc.CPUAccessFlags = 0; texDesc.SampleCount = 1; texDesc.Usage = USAGE_DEFAULT; texDesc.BindFlags = BIND_SHADER_RESOURCE; - texDesc.CPUAccessFlags = 0; texDesc.MiscFlags = RESOURCE_MISC_TEXTURECUBE; SubresourceData pData[6]; @@ -256,10 +254,7 @@ namespace wiTextureHelper textureDesc.ArraySize = 1; textureDesc.Format = format; textureDesc.SampleCount = 1; - textureDesc.Usage = USAGE_IMMUTABLE; textureDesc.BindFlags = BIND_SHADER_RESOURCE; - textureDesc.CPUAccessFlags = 0; - textureDesc.MiscFlags = 0; SubresourceData InitData; InitData.pSysMem = data; diff --git a/WickedEngine/wiVersion.cpp b/WickedEngine/wiVersion.cpp index 0c1724b08..45c3ee405 100644 --- a/WickedEngine/wiVersion.cpp +++ b/WickedEngine/wiVersion.cpp @@ -7,9 +7,9 @@ namespace wiVersion // main engine core const int major = 0; // minor features, major updates, breaking compatibility changes - const int minor = 56; + const int minor = 57; // minor bug fixes, alterations, refactors, updates - const int revision = 85; + const int revision = 0; const std::string version_string = std::to_string(major) + "." + std::to_string(minor) + "." + std::to_string(revision); diff --git a/WickedEngine/wiWidget.cpp b/WickedEngine/wiWidget.cpp index 424d3c598..c90cc018e 100644 --- a/WickedEngine/wiWidget.cpp +++ b/WickedEngine/wiWidget.cpp @@ -1326,8 +1326,7 @@ void wiComboBox::Render(const wiCanvas& canvas, CommandList cmd) const XMMatrixTranslation(translation.x + scale.x + 1 + scale.y * 0.5f, translation.y + scale.y * 0.5f, 0) * Projection ); - device->UpdateBuffer(wiRenderer::GetConstantBuffer(CBTYPE_MISC), &cb, cmd); - device->BindConstantBuffer(VS, wiRenderer::GetConstantBuffer(CBTYPE_MISC), CBSLOT_RENDERER_MISC, cmd); + device->BindDynamicConstantBuffer(cb, CBSLOT_RENDERER_MISC, cmd); const GPUBuffer* vbs[] = { &vb_triangle, }; @@ -2337,10 +2336,7 @@ void wiColorPicker::Render(const wiCanvas& canvas, CommandList cmd) const GPUBufferDesc desc; desc.BindFlags = BIND_VERTEX_BUFFER; desc.ByteWidth = (uint32_t)(vertices.size() * sizeof(Vertex)); - desc.CPUAccessFlags = 0; - desc.MiscFlags = 0; desc.StructureByteStride = 0; - desc.Usage = USAGE_IMMUTABLE; SubresourceData data; data.pSysMem = vertices.data(); device->CreateBuffer(&desc, &data, &vb_hue); @@ -2364,10 +2360,7 @@ void wiColorPicker::Render(const wiCanvas& canvas, CommandList cmd) const GPUBufferDesc desc; desc.BindFlags = BIND_VERTEX_BUFFER; desc.ByteWidth = (uint32_t)(vertices.size() * sizeof(Vertex)); - desc.CPUAccessFlags = 0; - desc.MiscFlags = 0; desc.StructureByteStride = 0; - desc.Usage = USAGE_IMMUTABLE; SubresourceData data; data.pSysMem = vertices.data(); device->CreateBuffer(&desc, &data, &vb_picker_saturation); @@ -2405,10 +2398,7 @@ void wiColorPicker::Render(const wiCanvas& canvas, CommandList cmd) const GPUBufferDesc desc; desc.BindFlags = BIND_VERTEX_BUFFER; desc.ByteWidth = (uint32_t)sizeof(vertices); - desc.CPUAccessFlags = 0; - desc.MiscFlags = 0; desc.StructureByteStride = 0; - desc.Usage = USAGE_IMMUTABLE; SubresourceData data; data.pSysMem = vertices; device->CreateBuffer(&desc, &data, &vb_picker_hue); @@ -2426,10 +2416,6 @@ void wiColorPicker::Render(const wiCanvas& canvas, CommandList cmd) const GPUBufferDesc desc; desc.BindFlags = BIND_VERTEX_BUFFER; desc.ByteWidth = (uint32_t)sizeof(vertices); - desc.CPUAccessFlags = 0; - desc.MiscFlags = 0; - desc.StructureByteStride = 0; - desc.Usage = USAGE_IMMUTABLE; SubresourceData data; data.pSysMem = vertices; device->CreateBuffer(&desc, &data, &vb_preview); @@ -2442,7 +2428,6 @@ void wiColorPicker::Render(const wiCanvas& canvas, CommandList cmd) const const XMMATRIX Projection = canvas.GetProjection(); - device->BindConstantBuffer(VS, wiRenderer::GetConstantBuffer(CBTYPE_MISC), CBSLOT_RENDERER_MISC, cmd); device->BindPipelineState(&PSO_colored, cmd); ApplyScissor(canvas, scissorRect, cmd); @@ -2484,9 +2469,9 @@ void wiColorPicker::Render(const wiCanvas& canvas, CommandList cmd) const Projection ); cb.g_xColor = IsEnabled() ? float4(1, 1, 1, 1) : float4(0.5f, 0.5f, 0.5f, 1); - device->UpdateBuffer(wiRenderer::GetConstantBuffer(CBTYPE_MISC), &cb, cmd); + device->BindDynamicConstantBuffer(cb, CBSLOT_RENDERER_MISC, cmd); const GPUBuffer* vbs[] = { - vb_saturation.buffer, + &vb_saturation.buffer, }; const uint32_t strides[] = { sizeof(Vertex), @@ -2505,7 +2490,7 @@ void wiColorPicker::Render(const wiCanvas& canvas, CommandList cmd) const Projection ); cb.g_xColor = IsEnabled() ? float4(1, 1, 1, 1) : float4(0.5f, 0.5f, 0.5f, 1); - device->UpdateBuffer(wiRenderer::GetConstantBuffer(CBTYPE_MISC), &cb, cmd); + device->BindDynamicConstantBuffer(cb, CBSLOT_RENDERER_MISC, cmd); const GPUBuffer* vbs[] = { &vb_hue, }; @@ -2532,7 +2517,7 @@ void wiColorPicker::Render(const wiCanvas& canvas, CommandList cmd) const rgb result = hsv2rgb(source); cb.g_xColor = float4(1 - result.r, 1 - result.g, 1 - result.b, 1); - device->UpdateBuffer(wiRenderer::GetConstantBuffer(CBTYPE_MISC), &cb, cmd); + device->BindDynamicConstantBuffer(cb, CBSLOT_RENDERER_MISC, cmd); const GPUBuffer* vbs[] = { &vb_picker_hue, }; @@ -2583,7 +2568,7 @@ void wiColorPicker::Render(const wiCanvas& canvas, CommandList cmd) const Projection ); cb.g_xColor = float4(1 - final_color.toFloat3().x, 1 - final_color.toFloat3().y, 1 - final_color.toFloat3().z, 1); - device->UpdateBuffer(wiRenderer::GetConstantBuffer(CBTYPE_MISC), &cb, cmd); + device->BindDynamicConstantBuffer(cb, CBSLOT_RENDERER_MISC, cmd); const GPUBuffer* vbs[] = { &vb_picker_saturation, }; @@ -2602,7 +2587,7 @@ void wiColorPicker::Render(const wiCanvas& canvas, CommandList cmd) const Projection ); cb.g_xColor = final_color.toFloat4(); - device->UpdateBuffer(wiRenderer::GetConstantBuffer(CBTYPE_MISC), &cb, cmd); + device->BindDynamicConstantBuffer(cb, CBSLOT_RENDERER_MISC, cmd); const GPUBuffer* vbs[] = { &vb_preview, }; @@ -2990,8 +2975,7 @@ void wiTreeList::Render(const wiCanvas& canvas, CommandList cmd) const XMMatrixTranslation(open_box.pos.x + open_box.siz.x * 0.5f, open_box.pos.y + open_box.siz.y * 0.25f, 0) * Projection ); - device->UpdateBuffer(wiRenderer::GetConstantBuffer(CBTYPE_MISC), &cb, cmd); - device->BindConstantBuffer(VS, wiRenderer::GetConstantBuffer(CBTYPE_MISC), CBSLOT_RENDERER_MISC, cmd); + device->BindDynamicConstantBuffer(cb, CBSLOT_RENDERER_MISC, cmd); const GPUBuffer* vbs[] = { &vb_triangle, }; diff --git a/appveyor.yml b/appveyor.yml index 378cdfaa2..ecc6a78a7 100644 --- a/appveyor.yml +++ b/appveyor.yml @@ -12,7 +12,7 @@ before_build: build_script: - msbuild "C:\projects\wickedengine\WickedEngine.sln" /t:OfflineShaderCompiler /m /verbosity:minimal /logger:"C:\Program Files\AppVeyor\BuildAgent\Appveyor.MSBuildLogger.dll" - cd "C:\projects\wickedengine\WickedEngine" - - call "../BUILD/x64/Release/OfflineShaderCompiler/OfflineShaderCompiler.exe" hlsl5 hlsl6 spirv shaderdump + - call "../BUILD/x64/Release/OfflineShaderCompiler/OfflineShaderCompiler.exe" hlsl6 spirv shaderdump - cd .. - msbuild "C:\projects\wickedengine\WickedEngine.sln" /t:rebuild /m /verbosity:minimal /logger:"C:\Program Files\AppVeyor\BuildAgent\Appveyor.MSBuildLogger.dll" diff --git a/credits.txt b/credits.txt index 0922cc00d..95050361e 100644 --- a/credits.txt +++ b/credits.txt @@ -37,4 +37,5 @@ Patreon supporters: - Quifeng Jin - TheGameCreators - Joseph Goldin +- Yuri