diff --git a/Content/Documentation/WickedEngine-Documentation.md b/Content/Documentation/WickedEngine-Documentation.md
index b264059d5..4bf7942d0 100644
--- a/Content/Documentation/WickedEngine-Documentation.md
+++ b/Content/Documentation/WickedEngine-Documentation.md
@@ -481,18 +481,18 @@ 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 `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.
+Important: The `SHADER_RESOURCE` state cannot be used on the compute queue. The device could convert these to `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 going 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()`.
###### HDR Display
To present content to a HDR display, set the `SwapChainDesc::allow_hdr` to `true` when creating the `SwapChain`. Also, select a texture format for the swapChain that can be used for HDR content. The formats that are capable of HDR, are:
-- `FORMAT_R10G10B10A2_UNORM`, which supports both the `COLOR_SPACE_SRGB` (which is SDR) and `COLOR_SPACE_HDR10_ST2084` (HDR10) color spaces.
-- `FORMAT_R16G16B16A16_FLOAT`, which supports the `COLOR_SPACE_HDR_LINEAR` color space.
+- `R10G10B10A2_UNORM`, which supports both the `SRGB` (which is SDR) and `HDR10_ST2084` (HDR10) color spaces.
+- `R16G16B16A16_FLOAT`, which supports the `HDR_LINEAR` color space.
If the display associated with the `SwapChain` doesn't support HDR output, HDR will be disabled and the `SwapChain` can fall back to an appropriate format that is supported. To check the final color space of the `SwapChain`, call the `GraphicsDevice::GetSwapChainColorSpace()` function providing a valid `SwapChain` as argument. The function returns the actual `COLOR_SPACE` of the `SwapChain`.
-To check whether the display associated with the `SwapChain` is HDR capable, call the `GraphicsDevice::GetSwapChainHDRSupport()` function providing a valid `SwapChain` as argument. This will return whether the display supports HDR or not, regardless of the current format of the `SwapChain`.
+To check whether the display associated with the `SwapChain` is HDR capable, call the `GraphicsDevice::IsSwapChainSupportsHDR()` function providing a valid `SwapChain` as argument. This will return whether the display supports HDR or not, regardless of the current format of the `SwapChain`.
It is not enough to set up a HDR `SwapChain` to render correct HDR content, because great care must be taken to blend elements in linear color space, and correctly convert to the display's color space before presenting. This is a responsibility of shaders.
@@ -529,11 +529,11 @@ By default, the `subresource` parameter is `-1`, which means that the entire res
There are different resource types regarding how to bind resources. These slots have separate binding points from each other, so they don't interfere between each other.
- Shader resources
-These are read only resources. `GPUBuffer`s and `Texture`s can be bound as shader resources if they were created with a `BindFlags` in their description that has the `BIND_SHADER_RESOURCE` bit set. Use the `GraphicsDevice::BindResource()` function to bind a single shader resource, or the `GraphicsDevice::BindResources()` to bind a bundle of shader resources, occupying a number of slots starting from the bind slot. Use the `GraphicsDevice::UnbindResources()` function to unbind several shader resource slots manually, which is useful for removing debug device warnings.
+These are read only resources. `GPUBuffer`s and `Texture`s can be bound as shader resources if they were created with a `BindFlags` in their description that has the `SHADER_RESOURCE` bit set. Use the `GraphicsDevice::BindResource()` function to bind a single shader resource, or the `GraphicsDevice::BindResources()` to bind a bundle of shader resources, occupying a number of slots starting from the bind slot. Use the `GraphicsDevice::UnbindResources()` function to unbind several shader resource slots manually, which is useful for removing debug device warnings.
- UAV
-Unordered Access Views, in other words resources with read-write access. `GPUBuffer`s and `Texture`s can be bound as shader resources if they were created with a `BindFlags` in their description that has the `BIND_UNORDERED_ACCESS` bit set. Use the `GraphicsDevice::BindUAV()` function to bind a single UAV resource, or the `GraphicsDevice::BindUAVs()` to bind a bundle of UAV resources, occupying a number of slots starting from the bind slot. Use the `GraphicsDevice::UnbindUAVs()` function to unbind several UAV slots manually, which is useful for removing debug device warnings.
+Unordered Access Views, in other words resources with read-write access. `GPUBuffer`s and `Texture`s can be bound as shader resources if they were created with a `BindFlags` in their description that has the `UNORDERED_ACCESS` bit set. Use the `GraphicsDevice::BindUAV()` function to bind a single UAV resource, or the `GraphicsDevice::BindUAVs()` to bind a bundle of UAV resources, occupying a number of slots starting from the bind slot. Use the `GraphicsDevice::UnbindUAVs()` function to unbind several UAV slots manually, which is useful for removing debug device warnings.
- Constant buffers
-Only `GPUBuffer`s can be set as constant buffers if they were created with a `BindFlags` in their description that has the `BIND_CONSTANT_BUFFER` bit set. The resource can't be a constant buffer at the same time when it is also a shader resource or a UAV or a vertex buffer or an index buffer. Use the `GraphicsDevice::BindConstantBuffer()` function to bind constant buffers.
+Only `GPUBuffer`s can be set as constant buffers if they were created with a `BindFlags` in their description that has the `CONSTANT_BUFFER` bit set. The resource can't be a constant buffer at the same time when it is also a shader resource or a UAV or a vertex buffer or an index buffer. Use the `GraphicsDevice::BindConstantBuffer()` function to bind constant buffers.
- Samplers
Only `Sampler` can be bound as sampler. Use the `GraphicsDevice::BindSampler()` function to bind samplers. Additionally, you can specify auto samplers and common samplers and avoid binding them every time.
@@ -597,7 +597,7 @@ The subresource indices are valid as long as the resource is valid that they wer
The pipeline states are subject to shader compilations. Shader compilation will happen when a pipeline state is bound inside a render pass for the first time. This is required because the render target formats are necessary information for compilation, but they are not part of the pipeline state description. This choice was made for increased flexibility of defining pipeline states. However, unlike APIs where state subsets (like RasterizerDesc, or BlendStateDesc) can be bound individually, the grouping of states is more optimal regarding CPU time, because state hashes are computed only once for the whole pipeline state at creation time, as opposed to binding time for each individual state. This approach is also less prone to user error when the developer might forget setting any subset of state and the leftover state from previous render passes are incorrect.
-Shaders still need to be created with `GraphicsDevice::CreateShader()` in a similar to CreateTexture(), etc. This could result in shader compilation/hashing in some graphics APIs like DirectX 11. The CreateShader() function expects a `wiGraphics::SHADERSTAGE` enum value which will define the type of shader:
+Shaders still need to be created with `GraphicsDevice::CreateShader()` in a similar to CreateTexture(), etc. This could result in shader compilation/hashing in some graphics APIs like DirectX 11. The CreateShader() function expects a `wiGraphics::ShaderStage` enum value which will define the type of shader:
- `MS`: Mesh Shader
- `AS`: Amplification Shader, or Task Shader
@@ -608,7 +608,7 @@ Shaders still need to be created with `GraphicsDevice::CreateShader()` in a simi
- `PS`: Pixel Shader
- `CS`: Compute Shader
- `LIB`: Library shader
-- `SHADERSTAGE_COUNT`: Invalid Shader. This can be used to enumerate through all shader stages like:
+- `ShaderStage::COUNT`: Invalid Shader. This can be used to enumerate through all shader stages like:
```cpp
device->BindResource(, myTexture, 5, cmd); // Binds myTexture to slot 5
@@ -624,11 +624,11 @@ Render passes are defining regions in GPU execution where a number of render tar
- `RESOLVE`: The attachment will be used as MSAA resolve destination. The resolve source is chosen among the `RENDERTARGET` attachments in the same render pass, in the order they were declared in. The declaration order of the `RENDERTARGET` and `RESOLVE` attachment must match to correctly deduce source and destination targets for resolve operations.
- Load Operation:
-Defines how the texture contents are initialized at the start of the render pass. `LOADOP_LOAD` says that the previous texture content will be retained. `LOADOP_CLEAR` says that the previous contents of the texture will be lost and instead the texture clear color will be used to fill the texture. `LOADOP_DONTCARE` says that the texture contents are undefined, so this should only be used when the developer can ensure that the whole texture will be rendered to and not leaving any region empty (in which case, undefined results will be present in the texture).
+Defines how the texture contents are initialized at the start of the render pass. `LoadOp::LOAD` says that the previous texture content will be retained. `LoadOp::CLEAR` says that the previous contents of the texture will be lost and instead the texture clear color will be used to fill the texture. `LoadOp::DONTCARE` says that the texture contents are undefined, so this should only be used when the developer can ensure that the whole texture will be rendered to and not leaving any region empty (in which case, undefined results will be present in the texture).
- 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).
+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 `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`.
+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 `RENDERTARGET`, for `DEPTH_STENCIL` type, it must be either `DEPTHSTENCIL` or `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).
@@ -640,9 +640,9 @@ Notes:
`GPUBarrier`s can be used to state dependencies between GPU workloads. There are different kinds of barriers:
- 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".
+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 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 `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.
+Image barriers are stating resource state transition for [textures](#textures). The most common use case for example is to transition from `RENDERTARGET` to `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 `SHADER_RESOURCE`, the layout must be transitioned to `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.
@@ -669,15 +669,15 @@ Related topics: [Creating Resources](#creating-resources), [Destroying Resources
##### Updating GPU buffers
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.
+- `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).
+- `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 `DEFAULT` buffer from this by first filling the `UPLOAD` buffer from the CPU, then let the GPU copy its contents to the `DEFAULT` buffer with a shader or copy operation.
+- `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:
-- `GPU_QUERY_TYPE_TIMESTAMP` is used to write a timestamp value to the designated query inside the heap. Use `GraphicsDevice::QueryEnd()` to record this type.
-- `GPU_QUERY_TYPE_OCCLUSION` is used to retrieve depth test passed sample count for drawing commands between `GraphicsDevice::QueryBegin()` and `GraphicsDevice::QueryEnd()`.
-- `GPU_QUERY_TYPE_OCCLUSION_BINARY` is the same as `GPU_QUERY_TYPE_OCCLUSION`, but only returns whether any samples passed depth test or not. It can be more optimal than `GPU_QUERY_TYPE_OCCLUSION`.
+The `GPUQueryHeap` can be used to retrieve information from GPU to CPU. There are different query types (`GpuQueryType` enum):
+- `TIMESTAMP` is used to write a timestamp value to the designated query inside the heap. Use `GraphicsDevice::QueryEnd()` to record this type.
+- `OCCLUSION` is used to retrieve depth test passed sample count for drawing commands between `GraphicsDevice::QueryBegin()` and `GraphicsDevice::QueryEnd()`.
+- `OCCLUSION_BINARY` is the same as `OCCLUSION`, but only returns whether any samples passed depth test or not. It can be more optimal than `OCCLUSION`.
The `GPUQueryHeap` is designed to retrieve query results in a bulk, instead of one by one, which can be implemented more optimally. However, retrieving queries one by one will still be possible if needed. The `GraphicsDevice::QueryResolve()` function will issue a GPU operation that will write the query results to a CPU visible heap. The `GraphicsDevice::QueryRead()` function can be called on the CPU timeline to read resolved query data in bulk. Reading queries must be done when the GPU finished executing the `GraphicsDevice::QueryResolve()`, which is usually after a few frames of latency.
@@ -690,8 +690,8 @@ Binding a ray tracing pipeline state is required to dispatch ray tracing shaders
##### Variable Rate Shading
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 `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.
+- `BindShadingRate()`: Set the shading rate for the following draw calls. The first parameter is the shading rate, which is by default `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 `RATE_SOURCE` type. The texture must be using the `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 `ShadingRate` 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 `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.
@@ -758,7 +758,7 @@ Hardware accelerated ray tracing API is now available, so a variety of renderer
After the acceleration structures are updated, ray tracing shaders can use it after binding to a shader resource slot.
#### Ray tracing (legacy)
-Ray tracing can be used in multiple ways to render the scene. The `RayTraceScene()` function will render the scene with the rays that are provided as the `RayBuffers` type argument. For example, to render the scene from the camera perspective, first create rays that originate from the camera and shoot towards the caera far plane for every pixel. The `GenerateScreenRayBuffers()` helper function implements this functionality, by expecting a [CameraComponent](#cameracomponent) argument and returns a `RayBuffers` structure. The result will be written to a texture that is provided as parameter. The texture must have been created with `BIND_UNORDERED_ACCESS` bind flags, because it will be written in compute shaders. The scene BVH structure must have been already built to use this, it can be accomplished by calling [wiRenderer::BuildSceneBVH()](#build-scene-bvh). The [RenderPath3D_Pathracing](#renderpath3d_pathtracing) uses this ray tracing functionality to render a path traced scene.
+Ray tracing can be used in multiple ways to render the scene. The `RayTraceScene()` function will render the scene with the rays that are provided as the `RayBuffers` type argument. For example, to render the scene from the camera perspective, first create rays that originate from the camera and shoot towards the caera far plane for every pixel. The `GenerateScreenRayBuffers()` helper function implements this functionality, by expecting a [CameraComponent](#cameracomponent) argument and returns a `RayBuffers` structure. The result will be written to a texture that is provided as parameter. The texture must have been created with `UNORDERED_ACCESS` bind flags, because it will be written in compute shaders. The scene BVH structure must have been already built to use this, it can be accomplished by calling [wiRenderer::BuildSceneBVH()](#build-scene-bvh). The [RenderPath3D_Pathracing](#renderpath3d_pathtracing) uses this ray tracing functionality to render a path traced scene.
Other than path tracing, the scene BVH can be rendered by using the `RayTraceSceneBVH` function. This will render the bounding box hierarchy to the screen as a heatmap. Blue colors mean that few boxes were hit per pixel, and with more bounding box hits the colors go to green, yellow, red, and finaly white. This is useful to determine how expensive a the scene is with regards to ray tracing performance.
@@ -801,7 +801,7 @@ Please use the `wiRenderer::CombineStencilrefs()` function to specify stencil ma
The [Pipeline States](#pipeline-states) have a `DepthStencilState` type member which will control how the stencil mask is used in the graphics pipeline for any custom rendering effect. The functionality is supposed to be equivalent and closely matching of what DirectX 11 provides, so for further information, refer to the [DirectX 11 documentation of Depth Stencil States](https://docs.microsoft.com/en-us/windows/win32/direct3d11/d3d10-graphics-programming-guide-depth-stencil).
#### Loading Shaders
-While the [GraphicsDevice is responsible of creating shaders and pipeline states](#pipeline-states-and-shaders), loading the shader files themselves are not handled by the graphics device. The `wiRenderer::LoadShader()` is a helper function that provides this feature. This is internally loading shaders from a common shader path, that is by default the "../WickedEngine/shaders" directory (relative to the application working directory), so the filename provided to this function must be relative to that path. Every system in the engine that loads shaders uses this function to load shaders from the same folder, which makes it very easy to reload shaders on demand with the `wiRenderer::ReloadShaders()` function. This is useful for when the developer modifies a shader and recompiles it, the engine can reload it while the application is running. The developer can modify the common shader path with the `wiRenderer::SetShaderPath()` to any path of preference. The developer is free to load shaders with a custom loader, from any path too, but the `wiRenderer::ReloadShaders()` functionality might not work in that case for those shaders.
+While the [GraphicsDevice is responsible of creating shaders and pipeline states](#pipeline-states-and-shaders), loading the shader files themselves are not handled by the graphics device. The `wiRenderer::LoadShader(ShaderStage::)` is a helper function that provides this feature. This is internally loading shaders from a common shader path, that is by default the "../WickedEngine/shaders" directory (relative to the application working directory), so the filename provided to this function must be relative to that path. Every system in the engine that loads shaders uses this function to load shaders from the same folder, which makes it very easy to reload shaders on demand with the `wiRenderer::ReloadShaders()` function. This is useful for when the developer modifies a shader and recompiles it, the engine can reload it while the application is running. The developer can modify the common shader path with the `wiRenderer::SetShaderPath()` to any path of preference. The developer is free to load shaders with a custom loader, from any path too, but the `wiRenderer::ReloadShaders()` functionality might not work in that case for those shaders.
#### Debug Draw
Debug geometry can be rendered by calling the `wiRenderer::DrawDebugWorld()` function and setting up debug geometries, or enabling debug features. The `DrawDebugWorld()` is already called by [RenderPath3D](#renderpath3d), so the developer can simply just worry about configure debug drawing features and add debug geometries and drawing will happen at the right place (if the developer decided to use [RenderPath3D](#renderpath3d) in their application).
diff --git a/Editor/Editor.cpp b/Editor/Editor.cpp
index 5783314a2..afb625deb 100644
--- a/Editor/Editor.cpp
+++ b/Editor/Editor.cpp
@@ -201,37 +201,38 @@ void EditorComponent::ResizeBuffers()
init(main->canvas);
RenderPath2D::ResizeBuffers();
- GraphicsDevice* device = wiRenderer::GetDevice();
- bool hr;
+ GraphicsDevice* device = wiGraphics::GetDevice();
renderPath->init(*this);
renderPath->ResizeBuffers();
if(renderPath->GetDepthStencil() != nullptr)
{
+ bool success = false;
+
XMUINT2 internalResolution = GetInternalResolution();
TextureDesc desc;
- desc.Width = internalResolution.x;
- desc.Height = internalResolution.y;
+ desc.width = internalResolution.x;
+ desc.height = internalResolution.y;
- desc.Format = FORMAT_R8_UNORM;
- desc.BindFlags = BIND_RENDER_TARGET | BIND_SHADER_RESOURCE;
+ desc.format = Format::R8_UNORM;
+ desc.bind_flags = BindFlag::RENDER_TARGET | BindFlag::SHADER_RESOURCE;
if (renderPath->getMSAASampleCount() > 1)
{
- desc.SampleCount = renderPath->getMSAASampleCount();
- hr = device->CreateTexture(&desc, nullptr, &rt_selectionOutline_MSAA);
- assert(hr);
- desc.SampleCount = 1;
+ desc.sample_count = renderPath->getMSAASampleCount();
+ success = device->CreateTexture(&desc, nullptr, &rt_selectionOutline_MSAA);
+ assert(success);
+ desc.sample_count = 1;
}
- hr = device->CreateTexture(&desc, nullptr, &rt_selectionOutline[0]);
- assert(hr);
- hr = device->CreateTexture(&desc, nullptr, &rt_selectionOutline[1]);
- assert(hr);
+ success = device->CreateTexture(&desc, nullptr, &rt_selectionOutline[0]);
+ assert(success);
+ success = device->CreateTexture(&desc, nullptr, &rt_selectionOutline[1]);
+ assert(success);
{
RenderPassDesc desc;
- desc.attachments.push_back(RenderPassAttachment::RenderTarget(&rt_selectionOutline[0], RenderPassAttachment::LOADOP_CLEAR));
+ desc.attachments.push_back(RenderPassAttachment::RenderTarget(&rt_selectionOutline[0], RenderPassAttachment::LoadOp::CLEAR));
if (renderPath->getMSAASampleCount() > 1)
{
desc.attachments[0].texture = &rt_selectionOutline_MSAA;
@@ -240,15 +241,15 @@ void EditorComponent::ResizeBuffers()
desc.attachments.push_back(
RenderPassAttachment::DepthStencil(
renderPath->GetDepthStencil(),
- RenderPassAttachment::LOADOP_LOAD,
- RenderPassAttachment::STOREOP_STORE,
- RESOURCE_STATE_DEPTHSTENCIL_READONLY,
- RESOURCE_STATE_DEPTHSTENCIL_READONLY,
- RESOURCE_STATE_DEPTHSTENCIL_READONLY
+ RenderPassAttachment::LoadOp::LOAD,
+ RenderPassAttachment::StoreOp::STORE,
+ ResourceState::DEPTHSTENCIL_READONLY,
+ ResourceState::DEPTHSTENCIL_READONLY,
+ ResourceState::DEPTHSTENCIL_READONLY
)
);
- hr = device->CreateRenderPass(&desc, &renderpass_selectionOutline[0]);
- assert(hr);
+ success = device->CreateRenderPass(&desc, &renderpass_selectionOutline[0]);
+ assert(success);
if (renderPath->getMSAASampleCount() == 1)
{
@@ -258,8 +259,8 @@ void EditorComponent::ResizeBuffers()
{
desc.attachments[1].texture = &rt_selectionOutline[1]; // resolve
}
- hr = device->CreateRenderPass(&desc, &renderpass_selectionOutline[1]);
- assert(hr);
+ success = device->CreateRenderPass(&desc, &renderpass_selectionOutline[1]);
+ assert(success);
}
}
@@ -1921,14 +1922,14 @@ void EditorComponent::Render() const
// Selection outline:
if(renderPath->GetDepthStencil() != nullptr && !translator.selected.empty())
{
- GraphicsDevice* device = wiRenderer::GetDevice();
+ GraphicsDevice* device = wiGraphics::GetDevice();
CommandList cmd = device->BeginCommandList();
device->EventBegin("Editor - Selection Outline Mask", cmd);
Viewport vp;
- vp.Width = (float)rt_selectionOutline[0].GetDesc().Width;
- vp.Height = (float)rt_selectionOutline[0].GetDesc().Height;
+ vp.width = (float)rt_selectionOutline[0].GetDesc().width;
+ vp.height = (float)rt_selectionOutline[0].GetDesc().height;
device->BindViewports(1, &vp, cmd);
wiImageParams fx;
@@ -1980,7 +1981,7 @@ void EditorComponent::Compose(CommandList cmd) const
const float selectionColorIntensity = std::sin(selectionOutlineTimer * XM_2PI * 0.8f) * 0.5f + 0.5f;
if (renderPath->GetDepthStencil() != nullptr && !translator.selected.empty())
{
- GraphicsDevice* device = wiRenderer::GetDevice();
+ GraphicsDevice* device = wiGraphics::GetDevice();
device->EventBegin("Editor - Selection Outline", cmd);
wiRenderer::BindCommonResources(cmd);
float opacity = wiMath::Lerp(0.4f, 1.0f, selectionColorIntensity);
diff --git a/Editor/MaterialWindow.cpp b/Editor/MaterialWindow.cpp
index c9402cb63..70b89efcd 100644
--- a/Editor/MaterialWindow.cpp
+++ b/Editor/MaterialWindow.cpp
@@ -178,7 +178,7 @@ void MaterialWindow::Create(EditorComponent* editor)
MaterialComponent* material = wiScene::GetScene().materials.GetComponent(entity);
if (material != nullptr)
{
- material->shadingRate = (SHADING_RATE)args.iValue;
+ material->shadingRate = (ShadingRate)args.iValue;
}
});
shadingRateComboBox.AddItem("1X1");
@@ -800,7 +800,7 @@ void MaterialWindow::SetEntity(Entity entity)
clearcoatSlider.SetValue(material->clearcoat);
clearcoatRoughnessSlider.SetValue(material->clearcoatRoughness);
- shadingRateComboBox.SetEnabled(wiRenderer::GetDevice()->CheckCapability(GRAPHICSDEVICE_CAPABILITY_VARIABLE_RATE_SHADING));
+ shadingRateComboBox.SetEnabled(wiGraphics::GetDevice()->CheckCapability(GraphicsDeviceCapability::VARIABLE_RATE_SHADING));
if (material->IsUsingSpecularGlossinessWorkflow())
{
diff --git a/Editor/ModelImporter_GLTF.cpp b/Editor/ModelImporter_GLTF.cpp
index 1cbe136ad..3c0a677ab 100644
--- a/Editor/ModelImporter_GLTF.cpp
+++ b/Editor/ModelImporter_GLTF.cpp
@@ -118,8 +118,8 @@ namespace tinygltf
return false;
}
- image->width = resource->texture.desc.Width;
- image->height = resource->texture.desc.Height;
+ image->width = resource->texture.desc.width;
+ image->height = resource->texture.desc.height;
image->component = 4;
wiResourceManager::ResourceSerializer* seri = (wiResourceManager::ResourceSerializer*)userdata;
diff --git a/Editor/PaintToolWindow.cpp b/Editor/PaintToolWindow.cpp
index f2cfbe094..8ff8e0fae 100644
--- a/Editor/PaintToolWindow.cpp
+++ b/Editor/PaintToolWindow.cpp
@@ -293,11 +293,11 @@ void PaintToolWindow::Update(float dt)
uv.y = vertex_uvset[intersect.vertexID0].y * w +
vertex_uvset[intersect.vertexID1].y * u +
vertex_uvset[intersect.vertexID2].y * v;
- uint2 center = XMUINT2(uint32_t(uv.x * desc.Width), uint32_t(uv.y * desc.Height));
+ uint2 center = XMUINT2(uint32_t(uv.x * desc.width), uint32_t(uv.y * desc.height));
if (painting)
{
- GraphicsDevice* device = wiRenderer::GetDevice();
+ GraphicsDevice* device = wiGraphics::GetDevice();
CommandList cmd = device->BeginCommandList();
RecordHistory(true, cmd);
@@ -338,8 +338,8 @@ void PaintToolWindow::Update(float dt)
paintrad.radius = radius;
paintrad.center = center;
paintrad.uvset = uvset;
- paintrad.dimensions.x = desc.Width;
- paintrad.dimensions.y = desc.Height;
+ paintrad.dimensions.x = desc.width;
+ paintrad.dimensions.y = desc.height;
wiRenderer::DrawPaintRadius(paintrad);
}
break;
@@ -951,19 +951,20 @@ void PaintToolWindow::RecordHistory(bool start, CommandList cmd)
if (start)
{
// Make a copy of texture to edit and replace material resource:
- GraphicsDevice* device = wiRenderer::GetDevice();
+ GraphicsDevice* device = wiGraphics::GetDevice();
Texture newTex;
TextureDesc desc = editTexture.GetDesc();
- desc.Format = FORMAT_R8G8B8A8_UNORM; // force format to one that is writable by GPU
+ desc.format = Format::R8G8B8A8_UNORM; // force format to one that is writable by GPU
device->CreateTexture(&desc, nullptr, &newTex);
- for (uint32_t i = 0; i < newTex.GetDesc().MipLevels; ++i)
+ for (uint32_t i = 0; i < newTex.GetDesc().mip_levels; ++i)
{
int subresource_index;
- subresource_index = device->CreateSubresource(&newTex, SRV, 0, 1, i, 1);
+ subresource_index = device->CreateSubresource(&newTex, SubresourceType::SRV, 0, 1, i, 1);
assert(subresource_index == i);
- subresource_index = device->CreateSubresource(&newTex, UAV, 0, 1, i, 1);
+ subresource_index = device->CreateSubresource(&newTex, SubresourceType::UAV, 0, 1, i, 1);
assert(subresource_index == i);
}
+ assert(cmd != wiGraphics::INVALID_COMMANDLIST);
wiRenderer::CopyTexture2D(newTex, -1, 0, 0, editTexture, 0, cmd);
ReplaceEditTextureSlot(*material, newTex);
}
diff --git a/Editor/PaintToolWindow.h b/Editor/PaintToolWindow.h
index 95ccc33cc..c34563601 100644
--- a/Editor/PaintToolWindow.h
+++ b/Editor/PaintToolWindow.h
@@ -56,6 +56,6 @@ public:
void SetEntity(wiECS::Entity value, int subsetindex = -1);
wiArchive* currentHistory = nullptr;
- void RecordHistory(bool start, wiGraphics::CommandList cmd = ~0);
+ void RecordHistory(bool start, wiGraphics::CommandList cmd = wiGraphics::INVALID_COMMANDLIST);
void ConsumeHistoryOperation(wiArchive& archive, bool undo);
};
diff --git a/Editor/PostprocessWindow.cpp b/Editor/PostprocessWindow.cpp
index 9abc14ef6..2717f34c2 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))
+ if (wiGraphics::GetDevice()->CheckCapability(GraphicsDeviceCapability::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));
+ raytracedReflectionsCheckBox.SetEnabled(wiGraphics::GetDevice()->CheckCapability(GraphicsDeviceCapability::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 dd389361b..f70587b2a 100644
--- a/Editor/RendererWindow.cpp
+++ b/Editor/RendererWindow.cpp
@@ -181,7 +181,7 @@ void RendererWindow::Create(EditorComponent* editor)
});
variableRateShadingClassificationCheckBox.SetCheck(wiRenderer::GetVariableRateShadingClassification());
AddWidget(&variableRateShadingClassificationCheckBox);
- variableRateShadingClassificationCheckBox.SetEnabled(wiRenderer::GetDevice()->CheckCapability(wiGraphics::GRAPHICSDEVICE_CAPABILITY_VARIABLE_RATE_SHADING_TIER2));
+ variableRateShadingClassificationCheckBox.SetEnabled(wiGraphics::GetDevice()->CheckCapability(wiGraphics::GraphicsDeviceCapability::VARIABLE_RATE_SHADING_TIER2));
variableRateShadingClassificationDebugCheckBox.Create("DEBUG: ");
variableRateShadingClassificationDebugCheckBox.SetTooltip("Toggle visualization of variable rate shading classification feature");
@@ -192,7 +192,7 @@ void RendererWindow::Create(EditorComponent* editor)
});
variableRateShadingClassificationDebugCheckBox.SetCheck(wiRenderer::GetVariableRateShadingClassificationDebug());
AddWidget(&variableRateShadingClassificationDebugCheckBox);
- variableRateShadingClassificationDebugCheckBox.SetEnabled(wiRenderer::GetDevice()->CheckCapability(wiGraphics::GRAPHICSDEVICE_CAPABILITY_VARIABLE_RATE_SHADING_TIER2));
+ variableRateShadingClassificationDebugCheckBox.SetEnabled(wiGraphics::GetDevice()->CheckCapability(wiGraphics::GraphicsDeviceCapability::VARIABLE_RATE_SHADING_TIER2));
advancedLightCullingCheckBox.Create("2.5D Light Culling: ");
advancedLightCullingCheckBox.SetTooltip("Enable a more aggressive light culling approach which can result in slower culling but faster rendering (Tiled renderer only)");
@@ -223,7 +223,7 @@ void RendererWindow::Create(EditorComponent* editor)
});
tessellationCheckBox.SetCheck(wiRenderer::GetTessellationEnabled());
AddWidget(&tessellationCheckBox);
- tessellationCheckBox.SetEnabled(wiRenderer::GetDevice()->CheckCapability(wiGraphics::GRAPHICSDEVICE_CAPABILITY_TESSELLATION));
+ tessellationCheckBox.SetEnabled(wiGraphics::GetDevice()->CheckCapability(wiGraphics::GraphicsDeviceCapability::TESSELLATION));
speedMultiplierSlider.Create(0, 4, 1, 100000, "Speed: ");
speedMultiplierSlider.SetTooltip("Adjust the global speed (time multiplier)");
@@ -249,7 +249,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))
+ if (wiGraphics::GetDevice()->CheckCapability(wiGraphics::GraphicsDeviceCapability::RAYTRACING))
{
shadowTypeComboBox.AddItem("Ray traced");
}
@@ -422,16 +422,16 @@ void RendererWindow::Create(EditorComponent* editor)
switch (args.iValue)
{
case 0:
- desc.Filter = wiGraphics::FILTER_MIN_MAG_MIP_POINT;
+ desc.filter = wiGraphics::Filter::MIN_MAG_MIP_POINT;
break;
case 1:
- desc.Filter = wiGraphics::FILTER_MIN_MAG_LINEAR_MIP_POINT;
+ desc.filter = wiGraphics::Filter::MIN_MAG_LINEAR_MIP_POINT;
break;
case 2:
- desc.Filter = wiGraphics::FILTER_MIN_MAG_MIP_LINEAR;
+ desc.filter = wiGraphics::Filter::MIN_MAG_MIP_LINEAR;
break;
case 3:
- desc.Filter = wiGraphics::FILTER_ANISOTROPIC;
+ desc.filter = wiGraphics::Filter::ANISOTROPIC;
break;
default:
break;
@@ -450,7 +450,7 @@ void RendererWindow::Create(EditorComponent* editor)
mipLodBiasSlider.SetPos(XMFLOAT2(x, y += step));
mipLodBiasSlider.OnSlide([&](wiEventArgs args) {
wiGraphics::SamplerDesc desc = wiRenderer::GetSampler(SSLOT_OBJECTSHADER)->GetDesc();
- desc.MipLODBias = wiMath::Clamp(args.fValue, -15.9f, 15.9f);
+ desc.mip_lod_bias = wiMath::Clamp(args.fValue, -15.9f, 15.9f);
wiRenderer::ModifyObjectSampler(desc);
});
AddWidget(&mipLodBiasSlider);
@@ -727,20 +727,20 @@ void RendererWindow::UpdateSwapChainFormats(wiGraphics::SwapChain* swapChain)
{
swapchainComboBox.OnSelect(nullptr);
swapchainComboBox.ClearItems();
- swapchainComboBox.AddItem("SDR 8bit", wiGraphics::FORMAT_R8G8B8A8_UNORM);
- swapchainComboBox.AddItem("SDR 10bit", wiGraphics::FORMAT_R10G10B10A2_UNORM);
- if (wiRenderer::GetDevice()->GetSwapChainHDRSupport(swapChain))
+ swapchainComboBox.AddItem("SDR 8bit", static_cast(wiGraphics::Format::R8G8B8A8_UNORM));
+ swapchainComboBox.AddItem("SDR 10bit", static_cast(wiGraphics::Format::R10G10B10A2_UNORM));
+ if (wiGraphics::GetDevice()->IsSwapChainSupportsHDR(swapChain))
{
- swapchainComboBox.AddItem("HDR 10bit", wiGraphics::FORMAT_R10G10B10A2_UNORM);
- swapchainComboBox.AddItem("HDR 16bit", wiGraphics::FORMAT_R16G16B16A16_FLOAT);
+ swapchainComboBox.AddItem("HDR 10bit", static_cast(wiGraphics::Format::R10G10B10A2_UNORM));
+ swapchainComboBox.AddItem("HDR 16bit", static_cast(wiGraphics::Format::R16G16B16A16_FLOAT));
switch (swapChain->desc.format)
{
default:
- case wiGraphics::FORMAT_R8G8B8A8_UNORM:
+ case wiGraphics::Format::R8G8B8A8_UNORM:
swapchainComboBox.SetSelected(0);
break;
- case wiGraphics::FORMAT_R10G10B10A2_UNORM:
+ case wiGraphics::Format::R10G10B10A2_UNORM:
if (swapChain->desc.allow_hdr)
{
swapchainComboBox.SetSelected(2);
@@ -750,7 +750,7 @@ void RendererWindow::UpdateSwapChainFormats(wiGraphics::SwapChain* swapChain)
swapchainComboBox.SetSelected(1);
}
break;
- case wiGraphics::FORMAT_R16G16B16A16_FLOAT:
+ case wiGraphics::Format::R16G16B16A16_FLOAT:
swapchainComboBox.SetSelected(4);
break;
}
@@ -760,13 +760,13 @@ void RendererWindow::UpdateSwapChainFormats(wiGraphics::SwapChain* swapChain)
switch (swapChain->desc.format)
{
default:
- case wiGraphics::FORMAT_R8G8B8A8_UNORM:
+ case wiGraphics::Format::R8G8B8A8_UNORM:
swapchainComboBox.SetSelected(0);
break;
- case wiGraphics::FORMAT_R10G10B10A2_UNORM:
+ case wiGraphics::Format::R10G10B10A2_UNORM:
swapchainComboBox.SetSelected(1);
break;
- case wiGraphics::FORMAT_R16G16B16A16_FLOAT:
+ case wiGraphics::Format::R16G16B16A16_FLOAT:
swapchainComboBox.SetSelected(1);
break;
}
@@ -774,7 +774,7 @@ void RendererWindow::UpdateSwapChainFormats(wiGraphics::SwapChain* swapChain)
swapchainComboBox.OnSelect([=](wiEventArgs args) {
- swapChain->desc.format = (wiGraphics::FORMAT)args.userdata;
+ swapChain->desc.format = (wiGraphics::Format)args.userdata;
switch (args.iValue)
{
default:
@@ -788,7 +788,7 @@ void RendererWindow::UpdateSwapChainFormats(wiGraphics::SwapChain* swapChain)
break;
}
- bool success = wiRenderer::GetDevice()->CreateSwapChain(&swapChain->desc, nullptr, swapChain);
+ bool success = wiGraphics::GetDevice()->CreateSwapChain(&swapChain->desc, nullptr, swapChain);
assert(success);
});
}
diff --git a/Editor/Translator.cpp b/Editor/Translator.cpp
index 86904dfb6..4adc8c3d0 100644
--- a/Editor/Translator.cpp
+++ b/Editor/Translator.cpp
@@ -24,7 +24,7 @@ namespace Translator_Internal
{
void LoadShaders()
{
- GraphicsDevice* device = wiRenderer::GetDevice();
+ GraphicsDevice* device = wiGraphics::GetDevice();
{
PipelineStateDesc desc;
@@ -35,7 +35,7 @@ namespace Translator_Internal
desc.dss = wiRenderer::GetDepthStencilState(DSSTYPE_XRAY);
desc.rs = wiRenderer::GetRasterizerState(RSTYPE_DOUBLESIDED);
desc.bs = wiRenderer::GetBlendState(BSTYPE_ADDITIVE);
- desc.pt = TRIANGLELIST;
+ desc.pt = PrimitiveTopology::TRIANGLELIST;
device->CreatePipelineState(&desc, &pso_solidpart);
}
@@ -49,7 +49,7 @@ namespace Translator_Internal
desc.dss = wiRenderer::GetDepthStencilState(DSSTYPE_XRAY);
desc.rs = wiRenderer::GetRasterizerState(RSTYPE_WIRE_DOUBLESIDED_SMOOTH);
desc.bs = wiRenderer::GetBlendState(BSTYPE_TRANSPARENT);
- desc.pt = LINELIST;
+ desc.pt = PrimitiveTopology::LINELIST;
device->CreatePipelineState(&desc, &pso_wirepart);
}
@@ -58,7 +58,7 @@ namespace Translator_Internal
void Translator::Create()
{
- GraphicsDevice* device = wiRenderer::GetDevice();
+ GraphicsDevice* device = wiGraphics::GetDevice();
if (!vertexBuffer_Axis.IsValid())
{
@@ -70,9 +70,9 @@ void Translator::Create()
vertexCount_Axis = arraysize(verts) / 2;
GPUBufferDesc bd;
- bd.Usage = USAGE_DEFAULT;
- bd.Size = sizeof(verts);
- bd.BindFlags = BIND_VERTEX_BUFFER;
+ bd.usage = Usage::DEFAULT;
+ bd.size = sizeof(verts);
+ bd.bind_flags = BindFlag::VERTEX_BUFFER;
device->CreateBuffer(&bd, verts, &vertexBuffer_Axis);
}
@@ -93,9 +93,9 @@ void Translator::Create()
vertexCount_Plane = arraysize(verts) / 2;
GPUBufferDesc bd;
- bd.Usage = USAGE_DEFAULT;
- bd.Size = sizeof(verts);
- bd.BindFlags = BIND_VERTEX_BUFFER;
+ bd.usage = Usage::DEFAULT;
+ bd.size = sizeof(verts);
+ bd.bind_flags = BindFlag::VERTEX_BUFFER;
device->CreateBuffer(&bd, verts, &vertexBuffer_Plane);
}
@@ -146,9 +146,9 @@ void Translator::Create()
vertexCount_Origin = arraysize(verts) / 2;
GPUBufferDesc bd;
- bd.Usage = USAGE_DEFAULT;
- bd.Size = sizeof(verts);
- bd.BindFlags = BIND_VERTEX_BUFFER;
+ bd.usage = Usage::DEFAULT;
+ bd.size = sizeof(verts);
+ bd.bind_flags = BindFlag::VERTEX_BUFFER;
device->CreateBuffer(&bd, verts, &vertexBuffer_Origin);
}
@@ -429,7 +429,7 @@ void Translator::Draw(const CameraComponent& camera, CommandList cmd) const
Scene& scene = wiScene::GetScene();
- GraphicsDevice* device = wiRenderer::GetDevice();
+ GraphicsDevice* device = wiGraphics::GetDevice();
device->EventBegin("Editor - Translator", cmd);
diff --git a/Example_ImGui/Example_ImGui.cpp b/Example_ImGui/Example_ImGui.cpp
index e033bd519..9f55b4484 100644
--- a/Example_ImGui/Example_ImGui.cpp
+++ b/Example_ImGui/Example_ImGui.cpp
@@ -47,28 +47,28 @@ bool ImGui_Impl_CreateDeviceObjects()
// Upload texture to graphics system
TextureDesc textureDesc;
- textureDesc.Width = width;
- textureDesc.Height = height;
- textureDesc.MipLevels = 1;
- textureDesc.ArraySize = 1;
- textureDesc.Format = FORMAT_R8G8B8A8_UNORM;
- textureDesc.BindFlags = BIND_SHADER_RESOURCE;
+ textureDesc.width = width;
+ textureDesc.height = height;
+ textureDesc.mip_levels = 1;
+ textureDesc.array_size = 1;
+ textureDesc.format = Format::R8G8B8A8_UNORM;
+ textureDesc.bind_flags = BindFlag::SHADER_RESOURCE;
SubresourceData textureData;
- textureData.pData = pixels;
- textureData.rowPitch = width * GetFormatStride(textureDesc.Format);
- textureData.slicePitch = textureData.rowPitch * height;
+ textureData.data_ptr = pixels;
+ textureData.row_pitch = width * GetFormatStride(textureDesc.format);
+ textureData.slice_pitch = textureData.row_pitch * height;
- wiRenderer::GetDevice()->CreateTexture(&textureDesc, &textureData, &fontTexture);
+ wiGraphics::GetDevice()->CreateTexture(&textureDesc, &textureData, &fontTexture);
// Store our identifier
io.Fonts->SetTexID((ImTextureID)&fontTexture);
imguiInputLayout.elements =
{
- { "POSITION", 0, FORMAT_R32G32_FLOAT, 0, (uint32_t)IM_OFFSETOF(ImDrawVert, pos), INPUT_PER_VERTEX_DATA },
- { "TEXCOORD", 0, FORMAT_R32G32_FLOAT, 0, (uint32_t)IM_OFFSETOF(ImDrawVert, uv), INPUT_PER_VERTEX_DATA },
- { "COLOR", 0, FORMAT_R8G8B8A8_UNORM, 0, (uint32_t)IM_OFFSETOF(ImDrawVert, col), INPUT_PER_VERTEX_DATA },
+ { "POSITION", 0, Format::R32G32_FLOAT, 0, (uint32_t)IM_OFFSETOF(ImDrawVert, pos), InputClassification::PER_VERTEX_DATA },
+ { "TEXCOORD", 0, Format::R32G32_FLOAT, 0, (uint32_t)IM_OFFSETOF(ImDrawVert, uv), InputClassification::PER_VERTEX_DATA },
+ { "COLOR", 0, Format::R8G8B8A8_UNORM, 0, (uint32_t)IM_OFFSETOF(ImDrawVert, col), InputClassification::PER_VERTEX_DATA },
};
// Create pipeline
@@ -79,8 +79,8 @@ bool ImGui_Impl_CreateDeviceObjects()
desc.dss = wiRenderer::GetDepthStencilState(DSSTYPE_DEPTHREAD);
desc.rs = wiRenderer::GetRasterizerState(RSTYPE_DOUBLESIDED);
desc.bs = wiRenderer::GetBlendState(BSTYPE_TRANSPARENT);
- desc.pt = TRIANGLELIST;
- wiRenderer::GetDevice()->CreatePipelineState(&desc, &imguiPSO);
+ desc.pt = PrimitiveTopology::TRIANGLELIST;
+ wiGraphics::GetDevice()->CreatePipelineState(&desc, &imguiPSO);
return true;
}
@@ -106,8 +106,8 @@ void Example_ImGui::Initialize()
auto shaderPath = wiRenderer::GetShaderSourcePath();
wiRenderer::SetShaderSourcePath(wiHelper::GetCurrentPath() + "/");
- wiRenderer::LoadShader(VS, imguiVS, "ImGuiVS.cso");
- wiRenderer::LoadShader(PS, imguiPS, "ImGuiPS.cso");
+ wiRenderer::LoadShader(ShaderStage::VS, imguiVS, "ImGuiVS.cso");
+ wiRenderer::LoadShader(ShaderStage::PS, imguiPS, "ImGuiPS.cso");
wiRenderer::SetShaderSourcePath(shaderPath);
}
@@ -173,7 +173,7 @@ void Example_ImGui::Compose(wiGraphics::CommandList cmd)
auto* bd = ImGui_Impl_GetBackendData();
- GraphicsDevice* device = wiRenderer::GetDevice();
+ GraphicsDevice* device = wiGraphics::GetDevice();
// Get memory for vertex and index buffers
const uint64_t vbSize = sizeof(ImDrawVert) * drawData->TotalVtxCount;
@@ -232,11 +232,11 @@ void Example_ImGui::Compose(wiGraphics::CommandList cmd)
};
device->BindVertexBuffers(vbs, 0, 1, strides, offsets, cmd);
- device->BindIndexBuffer(&indexBufferAllocation.buffer, INDEXFORMAT_16BIT, indexBufferAllocation.offset, cmd);
+ device->BindIndexBuffer(&indexBufferAllocation.buffer, IndexBufferFormat::UINT16, indexBufferAllocation.offset, cmd);
Viewport viewport;
- viewport.Width = (float)fb_width;
- viewport.Height = (float)fb_height;
+ viewport.width = (float)fb_width;
+ viewport.height = (float)fb_height;
device->BindViewports(1, &viewport, cmd);
device->BindPipelineState(&imguiPSO, cmd);
diff --git a/WickedEngine/CommonInclude.h b/WickedEngine/CommonInclude.h
index f17ca1438..ebc704dce 100644
--- a/WickedEngine/CommonInclude.h
+++ b/WickedEngine/CommonInclude.h
@@ -7,6 +7,7 @@
#include
#include
#include
+#include
#if __has_include("DirectXMath.h")
// In this case, DirectXMath is coming from Windows SDK.
@@ -34,4 +35,46 @@ static const XMFLOAT4X4 IDENTITYMATRIX = XMFLOAT4X4(1, 0, 0, 0, 0, 1, 0, 0, 0, 0
#endif
#define ALIGN_16 void* operator new(size_t i){return _mm_malloc(i, 16);} void operator delete(void* p){_mm_free(p);}
+// Enable enum flags:
+// https://www.justsoftwaresolutions.co.uk/cplusplus/using-enum-classes-as-bitfields.html
+template
+struct enable_bitmask_operators {
+ static constexpr bool enable = false;
+};
+template
+constexpr 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
+constexpr 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;
+}
+template
+constexpr 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
+constexpr 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;
+}
+template
+constexpr bool has_flag(E lhs, E rhs)
+{
+ return (lhs & rhs) == rhs;
+}
+
#endif //WICKEDENGINE_COMMONINCLUDE_H
diff --git a/WickedEngine/MainComponent.cpp b/WickedEngine/MainComponent.cpp
index 445f5bda6..c4ebfc030 100644
--- a/WickedEngine/MainComponent.cpp
+++ b/WickedEngine/MainComponent.cpp
@@ -19,10 +19,13 @@
#include "wiGraphicsDevice_DX12.h"
#include "wiGraphicsDevice_Vulkan.h"
-#include "Utility/replace_new.h"
-
#include
#include
+#include
+#include
+#include
+
+std::atomic number_of_heap_allocations{ 0 };
using namespace wiGraphics;
@@ -65,7 +68,6 @@ void MainComponent::ActivatePath(RenderPath* component, float fadeSeconds, wiCol
void MainComponent::Run()
{
- GraphicsDevice* device = wiRenderer::GetDevice();
if (!initialized)
{
@@ -76,14 +78,14 @@ void MainComponent::Run()
if (!wiInitializer::IsInitializeFinished())
{
// Until engine is not loaded, present initialization screen...
- CommandList cmd = device->BeginCommandList();
- device->RenderPassBegin(&swapChain, cmd);
+ CommandList cmd = graphicsDevice->BeginCommandList();
+ graphicsDevice->RenderPassBegin(&swapChain, cmd);
wiImage::SetCanvas(canvas, cmd);
wiFont::SetCanvas(canvas, cmd);
Viewport viewport;
- viewport.Width = (float)swapChain.desc.width;
- viewport.Height = (float)swapChain.desc.height;
- device->BindViewports(1, &viewport, cmd);
+ viewport.width = (float)swapChain.desc.width;
+ viewport.height = (float)swapChain.desc.height;
+ graphicsDevice->BindViewports(1, &viewport, cmd);
wiFontParams params;
params.posX = 5.f;
params.posY = 5.f;
@@ -95,8 +97,8 @@ void MainComponent::Run()
params.posY = screenheight - textheight;
}
wiFont::Draw(text, params, cmd);
- device->RenderPassEnd(cmd);
- device->SubmitCommandLists();
+ graphicsDevice->RenderPassEnd(cmd);
+ graphicsDevice->SubmitCommandLists();
return;
}
@@ -127,7 +129,7 @@ void MainComponent::Run()
fadeManager.Update(dt);
- COLOR_SPACE colorspace = device->GetSwapChainColorSpace(&swapChain);
+ ColorSpace colorspace = graphicsDevice->GetSwapChainColorSpace(&swapChain);
if (GetActivePath() != nullptr)
{
@@ -170,43 +172,43 @@ void MainComponent::Run()
wiInput::Update(window);
// Begin final compositing:
- CommandList cmd = device->BeginCommandList();
+ CommandList cmd = graphicsDevice->BeginCommandList();
wiImage::SetCanvas(canvas, cmd);
wiFont::SetCanvas(canvas, cmd);
Viewport viewport;
- viewport.Width = (float)swapChain.desc.width;
- viewport.Height = (float)swapChain.desc.height;
- device->BindViewports(1, &viewport, cmd);
+ viewport.width = (float)swapChain.desc.width;
+ viewport.height = (float)swapChain.desc.height;
+ graphicsDevice->BindViewports(1, &viewport, cmd);
- bool colorspace_conversion_required = colorspace == COLOR_SPACE_HDR10_ST2084;
+ bool colorspace_conversion_required = colorspace == ColorSpace::HDR10_ST2084;
if (colorspace_conversion_required)
{
// In HDR10, we perform the compositing in a custom linear color space render target
- device->RenderPassBegin(&renderpass, cmd);
+ graphicsDevice->RenderPassBegin(&renderpass, cmd);
}
else
{
// If swapchain is SRGB or Linear HDR, it can be used for blending
// - If it is SRGB, the render path will ensure tonemapping to SDR
// - If it is Linear HDR, we can blend trivially in linear space
- device->RenderPassBegin(&swapChain, cmd);
+ graphicsDevice->RenderPassBegin(&swapChain, cmd);
}
Compose(cmd);
- device->RenderPassEnd(cmd);
+ graphicsDevice->RenderPassEnd(cmd);
if (colorspace_conversion_required)
{
// In HDR10, we perform a final mapping from linear to HDR10, into the swapchain
- device->RenderPassBegin(&swapChain, cmd);
+ graphicsDevice->RenderPassBegin(&swapChain, cmd);
wiImageParams fx;
fx.enableFullScreen();
fx.enableHDR10OutputMapping();
wiImage::Draw(&rendertarget, fx, cmd);
- device->RenderPassEnd(cmd);
+ graphicsDevice->RenderPassEnd(cmd);
}
wiProfiler::EndFrame(cmd);
- device->SubmitCommandLists();
+ graphicsDevice->SubmitCommandLists();
}
void MainComponent::Update(float dt)
@@ -259,8 +261,6 @@ void MainComponent::Compose(CommandList cmd)
GetActivePath()->Compose(cmd);
}
- GraphicsDevice* device = wiRenderer::GetDevice();
-
if (fadeManager.IsActive())
{
// display fade rect
@@ -292,13 +292,13 @@ void MainComponent::Compose(CommandList cmd)
#endif
#ifdef WICKEDENGINE_BUILD_DX12
- if (dynamic_cast(device))
+ if (dynamic_cast(graphicsDevice.get()))
{
ss << "[DX12]";
}
#endif
#ifdef WICKEDENGINE_BUILD_VULKAN
- if (dynamic_cast(device))
+ if (dynamic_cast(graphicsDevice.get()))
{
ss << "[Vulkan]";
}
@@ -307,7 +307,7 @@ void MainComponent::Compose(CommandList cmd)
#ifdef _DEBUG
ss << "[DEBUG]";
#endif
- if (device->IsDebugDevice())
+ if (graphicsDevice->IsDebugDevice())
{
ss << "[debugdevice]";
}
@@ -324,17 +324,17 @@ void MainComponent::Compose(CommandList cmd)
if (infoDisplay.colorspace)
{
ss << "Color Space: ";
- COLOR_SPACE colorSpace = device->GetSwapChainColorSpace(&swapChain);
+ ColorSpace colorSpace = graphicsDevice->GetSwapChainColorSpace(&swapChain);
switch (colorSpace)
{
default:
- case wiGraphics::COLOR_SPACE_SRGB:
+ case wiGraphics::ColorSpace::SRGB:
ss << "sRGB";
break;
- case wiGraphics::COLOR_SPACE_HDR10_ST2084:
+ case wiGraphics::ColorSpace::HDR10_ST2084:
ss << "ST.2084 (HDR10)";
break;
- case wiGraphics::COLOR_SPACE_HDR_LINEAR:
+ case wiGraphics::ColorSpace::HDR_LINEAR:
ss << "Linear (HDR)";
break;
}
@@ -359,14 +359,18 @@ void MainComponent::Compose(CommandList cmd)
}
if (infoDisplay.heap_allocation_counter)
{
- ss << "Heap allocations per frame: " << number_of_allocs.load() << std::endl;
- number_of_allocs.store(0);
+ ss << "Heap allocations per frame: " << number_of_heap_allocations.load() << std::endl;
+ number_of_heap_allocations.store(0);
+ }
+ if (infoDisplay.pipeline_count)
+ {
+ ss << "Graphics pipelines active: " << graphicsDevice->GetActivePipelineCount() << std::endl;
}
#ifdef _DEBUG
ss << "Warning: This is a [DEBUG] build, performance will be slow!" << std::endl;
#endif
- if (wiRenderer::GetDevice()->IsDebugDevice())
+ if (graphicsDevice->IsDebugDevice())
{
ss << "Warning: Graphics is in [debugdevice] mode, performance will be slow!" << std::endl;
}
@@ -392,7 +396,7 @@ void MainComponent::SetWindow(wiPlatform::window_type window, bool fullscreen)
this->window = window;
// User can also create a graphics device if custom logic is desired, but they must do before this function!
- if (wiRenderer::GetDevice() == nullptr)
+ if (graphicsDevice == nullptr)
{
bool debugdevice = wiStartupArguments::HasArgument("debugdevice");
bool gpuvalidation = wiStartupArguments::HasArgument("gpuvalidation");
@@ -430,17 +434,18 @@ void MainComponent::SetWindow(wiPlatform::window_type window, bool fullscreen)
{
#ifdef WICKEDENGINE_BUILD_VULKAN
wiRenderer::SetShaderPath(wiRenderer::GetShaderPath() + "spirv/");
- wiRenderer::SetDevice(std::make_shared(window, debugdevice));
+ graphicsDevice = std::make_unique(window, debugdevice);
#endif
}
else if (use_dx12)
{
#ifdef WICKEDENGINE_BUILD_DX12
wiRenderer::SetShaderPath(wiRenderer::GetShaderPath() + "hlsl6/");
- wiRenderer::SetDevice(std::make_shared(debugdevice, gpuvalidation));
+ graphicsDevice = std::make_unique(debugdevice, gpuvalidation);
#endif
}
}
+ wiGraphics::GetDevice() = graphicsDevice.get();
canvas.init(window);
@@ -453,37 +458,66 @@ void MainComponent::SetWindow(wiPlatform::window_type window, bool fullscreen)
else
{
// initialize for the first time
- desc.buffercount = 3;
- desc.format = FORMAT_R10G10B10A2_UNORM;
+ desc.buffer_count = 3;
+ desc.format = Format::R10G10B10A2_UNORM;
}
desc.width = canvas.GetPhysicalWidth();
desc.height = canvas.GetPhysicalHeight();
desc.allow_hdr = allow_hdr;
- bool success = wiRenderer::GetDevice()->CreateSwapChain(&desc, window, &swapChain);
+ bool success = graphicsDevice->CreateSwapChain(&desc, window, &swapChain);
assert(success);
swapChainVsyncChangeEvent = wiEvent::Subscribe(SYSTEM_EVENT_SET_VSYNC, [this](uint64_t userdata) {
SwapChainDesc desc = swapChain.desc;
desc.vsync = userdata != 0;
- bool success = wiRenderer::GetDevice()->CreateSwapChain(&desc, nullptr, &swapChain);
+ bool success = graphicsDevice->CreateSwapChain(&desc, nullptr, &swapChain);
assert(success);
});
- if (wiRenderer::GetDevice()->GetSwapChainColorSpace(&swapChain) == COLOR_SPACE_HDR10_ST2084)
+ if (graphicsDevice->GetSwapChainColorSpace(&swapChain) == ColorSpace::HDR10_ST2084)
{
TextureDesc desc;
- desc.Width = swapChain.desc.width;
- desc.Height = swapChain.desc.height;
- desc.Format = FORMAT_R11G11B10_FLOAT;
- desc.BindFlags = BIND_RENDER_TARGET | BIND_SHADER_RESOURCE;
- bool success = wiRenderer::GetDevice()->CreateTexture(&desc, nullptr, &rendertarget);
+ desc.width = swapChain.desc.width;
+ desc.height = swapChain.desc.height;
+ desc.format = Format::R11G11B10_FLOAT;
+ desc.bind_flags = BindFlag::RENDER_TARGET | BindFlag::SHADER_RESOURCE;
+ bool success = graphicsDevice->CreateTexture(&desc, nullptr, &rendertarget);
assert(success);
- wiRenderer::GetDevice()->SetName(&rendertarget, "MainComponent::rendertarget");
+ graphicsDevice->SetName(&rendertarget, "MainComponent::rendertarget");
RenderPassDesc renderpassdesc;
- renderpassdesc.attachments.push_back(RenderPassAttachment::RenderTarget(&rendertarget, RenderPassAttachment::LOADOP_CLEAR));
- success = wiRenderer::GetDevice()->CreateRenderPass(&renderpassdesc, &renderpass);
+ renderpassdesc.attachments.push_back(RenderPassAttachment::RenderTarget(&rendertarget, RenderPassAttachment::LoadOp::CLEAR));
+ success = graphicsDevice->CreateRenderPass(&renderpassdesc, &renderpass);
assert(success);
}
}
+
+// Heap alloc replacements are used to count heap allocations:
+// It is good practice to reduce the amount of heap allocations that happen during the frame,
+// so keep an eye on the info display of the engine while MainComponent::InfoDisplayer::heap_allocation_counter is enabled
+
+void* operator new(std::size_t size) {
+ number_of_heap_allocations.fetch_add(1);
+ void* p = malloc(size);
+ if (!p) throw std::bad_alloc();
+ return p;
+}
+void* operator new[](std::size_t size) {
+ number_of_heap_allocations.fetch_add(1);
+ void* p = malloc(size);
+ if (!p) throw std::bad_alloc();
+ return p;
+}
+void* operator new[](std::size_t size, const std::nothrow_t&) throw() {
+ number_of_heap_allocations.fetch_add(1);
+ return malloc(size);
+}
+void* operator new(std::size_t size, const std::nothrow_t&) throw() {
+ number_of_heap_allocations.fetch_add(1);
+ return malloc(size);
+}
+void operator delete(void* ptr) throw() { free(ptr); }
+void operator delete (void* ptr, const std::nothrow_t&) throw() { free(ptr); }
+void operator delete[](void* ptr) throw() { free(ptr); }
+void operator delete[](void* ptr, const std::nothrow_t&) throw() { free(ptr); }
diff --git a/WickedEngine/MainComponent.h b/WickedEngine/MainComponent.h
index d3d933046..14666f4d5 100644
--- a/WickedEngine/MainComponent.h
+++ b/WickedEngine/MainComponent.h
@@ -8,11 +8,14 @@
#include "wiEvent.h"
#include "wiCanvas.h"
+#include
+
class RenderPath;
class MainComponent
{
protected:
+ std::unique_ptr graphicsDevice;
wiEvent::Handle swapChainVsyncChangeEvent;
RenderPath* activePath = nullptr;
@@ -96,6 +99,8 @@ public:
bool colorspace = false;
// display number of heap allocations per frame
bool heap_allocation_counter = false;
+ // display the active graphics pipeline count
+ bool pipeline_count = false;
// text size
int size = 16;
// display default color grading helper texture in top left corner of the screen
diff --git a/WickedEngine/MainComponent_BindLua.cpp b/WickedEngine/MainComponent_BindLua.cpp
index d7b0fbb59..6f872cc74 100644
--- a/WickedEngine/MainComponent_BindLua.cpp
+++ b/WickedEngine/MainComponent_BindLua.cpp
@@ -17,6 +17,7 @@ Luna::FunctionType MainComponent_BindLua::methods[] = {
lunamethod(MainComponent_BindLua, SetWatermarkDisplay),
lunamethod(MainComponent_BindLua, SetFPSDisplay),
lunamethod(MainComponent_BindLua, SetResolutionDisplay),
+ lunamethod(MainComponent_BindLua, SetPipelineCountDisplay),
lunamethod(MainComponent_BindLua, GetCanvas),
{ NULL, NULL }
};
@@ -256,6 +257,22 @@ int MainComponent_BindLua::SetResolutionDisplay(lua_State *L)
wiLua::SError(L, "SetResolutionDisplay(bool active) not enough arguments!");
return 0;
}
+int MainComponent_BindLua::SetPipelineCountDisplay(lua_State *L)
+{
+ if (component == nullptr)
+ {
+ wiLua::SError(L, "SetPipelineCountDisplay() component is empty!");
+ return 0;
+ }
+ int argc = wiLua::SGetArgCount(L);
+ if (argc > 0)
+ {
+ component->infoDisplay.pipeline_count = wiLua::SGetBool(L, 1);
+ }
+ else
+ wiLua::SError(L, "SetPipelineCountDisplay(bool active) not enough arguments!");
+ return 0;
+}
int MainComponent_BindLua::GetCanvas(lua_State* L)
{
diff --git a/WickedEngine/MainComponent_BindLua.h b/WickedEngine/MainComponent_BindLua.h
index 632c20c1e..0c4cc580f 100644
--- a/WickedEngine/MainComponent_BindLua.h
+++ b/WickedEngine/MainComponent_BindLua.h
@@ -45,6 +45,7 @@ public:
int SetWatermarkDisplay(lua_State *L);
int SetFPSDisplay(lua_State *L);
int SetResolutionDisplay(lua_State *L);
+ int SetPipelineCountDisplay(lua_State* L);
int GetCanvas(lua_State* L);
diff --git a/WickedEngine/RenderPath.h b/WickedEngine/RenderPath.h
index b8104ac2e..9901fb318 100644
--- a/WickedEngine/RenderPath.h
+++ b/WickedEngine/RenderPath.h
@@ -36,6 +36,6 @@ public:
inline uint32_t getLayerMask() const { return layerMask; }
inline void setlayerMask(uint32_t value) { layerMask = value; }
- wiGraphics::COLOR_SPACE colorspace = wiGraphics::COLOR_SPACE_SRGB;
+ wiGraphics::ColorSpace colorspace = wiGraphics::ColorSpace::SRGB;
};
diff --git a/WickedEngine/RenderPath2D.cpp b/WickedEngine/RenderPath2D.cpp
index fb4cc0fd3..43541b4f4 100644
--- a/WickedEngine/RenderPath2D.cpp
+++ b/WickedEngine/RenderPath2D.cpp
@@ -12,21 +12,21 @@ void RenderPath2D::ResizeBuffers()
current_buffersize = GetInternalResolution();
current_layoutscale = 0; // invalidate layout
- GraphicsDevice* device = wiRenderer::GetDevice();
+ GraphicsDevice* device = wiGraphics::GetDevice();
const Texture* dsv = GetDepthStencil();
- if(dsv != nullptr && (resolutionScale != 1.0f || dsv->GetDesc().SampleCount > 1))
+ if(dsv != nullptr && (resolutionScale != 1.0f || dsv->GetDesc().sample_count > 1))
{
TextureDesc desc = GetDepthStencil()->GetDesc();
- desc.layout = RESOURCE_STATE_SHADER_RESOURCE;
- desc.BindFlags = BIND_RENDER_TARGET | BIND_SHADER_RESOURCE;
- desc.Format = FORMAT_R8G8B8A8_UNORM;
+ desc.layout = ResourceState::SHADER_RESOURCE;
+ desc.bind_flags = BindFlag::RENDER_TARGET | BindFlag::SHADER_RESOURCE;
+ desc.format = Format::R8G8B8A8_UNORM;
device->CreateTexture(&desc, nullptr, &rtStenciled);
device->SetName(&rtStenciled, "rtStenciled");
- if (desc.SampleCount > 1)
+ if (desc.sample_count > 1)
{
- desc.SampleCount = 1;
+ desc.sample_count = 1;
device->CreateTexture(&desc, nullptr, &rtStenciled_resolved);
device->SetName(&rtStenciled_resolved, "rtStenciled_resolved");
}
@@ -38,10 +38,10 @@ void RenderPath2D::ResizeBuffers()
{
TextureDesc desc;
- desc.BindFlags = BIND_RENDER_TARGET | BIND_SHADER_RESOURCE;
- desc.Format = FORMAT_R8G8B8A8_UNORM;
- desc.Width = GetPhysicalWidth();
- desc.Height = GetPhysicalHeight();
+ desc.bind_flags = BindFlag::RENDER_TARGET | BindFlag::SHADER_RESOURCE;
+ desc.format = Format::R8G8B8A8_UNORM;
+ desc.width = GetPhysicalWidth();
+ desc.height = GetPhysicalHeight();
device->CreateTexture(&desc, nullptr, &rtFinal);
device->SetName(&rtFinal, "rtFinal");
}
@@ -49,19 +49,19 @@ void RenderPath2D::ResizeBuffers()
if (rtStenciled.IsValid())
{
RenderPassDesc desc;
- desc.attachments.push_back(RenderPassAttachment::RenderTarget(&rtStenciled, RenderPassAttachment::LOADOP_CLEAR));
+ desc.attachments.push_back(RenderPassAttachment::RenderTarget(&rtStenciled, RenderPassAttachment::LoadOp::CLEAR));
desc.attachments.push_back(
RenderPassAttachment::DepthStencil(
dsv,
- RenderPassAttachment::LOADOP_LOAD,
- RenderPassAttachment::STOREOP_STORE,
- RESOURCE_STATE_DEPTHSTENCIL_READONLY,
- RESOURCE_STATE_DEPTHSTENCIL_READONLY,
- RESOURCE_STATE_DEPTHSTENCIL_READONLY
+ RenderPassAttachment::LoadOp::LOAD,
+ RenderPassAttachment::StoreOp::STORE,
+ ResourceState::DEPTHSTENCIL_READONLY,
+ ResourceState::DEPTHSTENCIL_READONLY,
+ ResourceState::DEPTHSTENCIL_READONLY
)
);
- if (rtStenciled.GetDesc().SampleCount > 1)
+ if (rtStenciled.GetDesc().sample_count > 1)
{
desc.attachments.push_back(RenderPassAttachment::Resolve(&rtStenciled_resolved));
}
@@ -72,18 +72,18 @@ void RenderPath2D::ResizeBuffers()
}
{
RenderPassDesc desc;
- desc.attachments.push_back(RenderPassAttachment::RenderTarget(&rtFinal, RenderPassAttachment::LOADOP_CLEAR));
+ desc.attachments.push_back(RenderPassAttachment::RenderTarget(&rtFinal, RenderPassAttachment::LoadOp::CLEAR));
if(dsv != nullptr && !rtStenciled.IsValid())
{
desc.attachments.push_back(
RenderPassAttachment::DepthStencil(
dsv,
- RenderPassAttachment::LOADOP_LOAD,
- RenderPassAttachment::STOREOP_STORE,
- RESOURCE_STATE_DEPTHSTENCIL_READONLY,
- RESOURCE_STATE_DEPTHSTENCIL_READONLY,
- RESOURCE_STATE_DEPTHSTENCIL_READONLY
+ RenderPassAttachment::LoadOp::LOAD,
+ RenderPassAttachment::StoreOp::STORE,
+ ResourceState::DEPTHSTENCIL_READONLY,
+ ResourceState::DEPTHSTENCIL_READONLY,
+ ResourceState::DEPTHSTENCIL_READONLY
)
);
}
@@ -135,17 +135,17 @@ void RenderPath2D::Update(float dt)
}
}
- if (colorspace != COLOR_SPACE_SRGB && (rtLinearColorSpace.desc.Width != rtFinal.desc.Width || rtLinearColorSpace.desc.Height != rtFinal.desc.Height))
+ if (colorspace != ColorSpace::SRGB && (rtLinearColorSpace.desc.width != rtFinal.desc.width || rtLinearColorSpace.desc.height != rtFinal.desc.height))
{
TextureDesc desc = rtFinal.desc;
- desc.Format = FORMAT_R16G16B16A16_FLOAT;
- bool success = wiRenderer::GetDevice()->CreateTexture(&desc, nullptr, &rtLinearColorSpace);
+ desc.format = Format::R16G16B16A16_FLOAT;
+ bool success = wiGraphics::GetDevice()->CreateTexture(&desc, nullptr, &rtLinearColorSpace);
assert(success);
- wiRenderer::GetDevice()->SetName(&rtLinearColorSpace, "rtLinearColorSpace");
+ wiGraphics::GetDevice()->SetName(&rtLinearColorSpace, "rtLinearColorSpace");
RenderPassDesc renderpassdesc;
- renderpassdesc.attachments.push_back(RenderPassAttachment::RenderTarget(&rtLinearColorSpace, RenderPassAttachment::LOADOP_CLEAR));
- success = wiRenderer::GetDevice()->CreateRenderPass(&renderpassdesc, &renderpass_linearize);
+ renderpassdesc.attachments.push_back(RenderPassAttachment::RenderTarget(&rtLinearColorSpace, RenderPassAttachment::LoadOp::CLEAR));
+ success = wiGraphics::GetDevice()->CreateRenderPass(&renderpassdesc, &renderpass_linearize);
assert(success);
}
@@ -180,7 +180,7 @@ void RenderPath2D::FixedUpdate()
}
void RenderPath2D::Render() const
{
- GraphicsDevice* device = wiRenderer::GetDevice();
+ GraphicsDevice* device = wiGraphics::GetDevice();
CommandList cmd = device->BeginCommandList();
wiImage::SetCanvas(*this, cmd);
wiFont::SetCanvas(*this, cmd);
@@ -199,8 +199,8 @@ void RenderPath2D::Render() const
device->RenderPassBegin(&renderpass_stenciled, cmd);
Viewport vp;
- vp.Width = (float)rtStenciled.GetDesc().Width;
- vp.Height = (float)rtStenciled.GetDesc().Height;
+ vp.width = (float)rtStenciled.GetDesc().width;
+ vp.height = (float)rtStenciled.GetDesc().height;
device->BindViewports(1, &vp, cmd);
device->EventBegin("STENCIL Sprite Layers", cmd);
@@ -224,8 +224,8 @@ void RenderPath2D::Render() const
device->RenderPassBegin(&renderpass_final, cmd);
Viewport vp;
- vp.Width = (float)rtFinal.GetDesc().Width;
- vp.Height = (float)rtFinal.GetDesc().Height;
+ vp.width = (float)rtFinal.GetDesc().width;
+ vp.height = (float)rtFinal.GetDesc().height;
device->BindViewports(1, &vp, cmd);
if (GetDepthStencil() != nullptr)
@@ -235,7 +235,7 @@ void RenderPath2D::Render() const
device->EventBegin("Copy STENCIL Sprite Layers", cmd);
wiImageParams fx;
fx.enableFullScreen();
- if (rtStenciled.GetDesc().SampleCount > 1)
+ if (rtStenciled.GetDesc().sample_count > 1)
{
wiImage::Draw(&rtStenciled_resolved, fx, cmd);
}
@@ -293,7 +293,7 @@ void RenderPath2D::Render() const
device->RenderPassEnd(cmd);
- if (colorspace != COLOR_SPACE_SRGB)
+ if (colorspace != ColorSpace::SRGB)
{
// Convert the regular SRGB result of the render path to linear space for HDR compositing:
device->RenderPassBegin(&renderpass_linearize, cmd);
diff --git a/WickedEngine/RenderPath3D.cpp b/WickedEngine/RenderPath3D.cpp
index 8911f6266..b9bece9f0 100644
--- a/WickedEngine/RenderPath3D.cpp
+++ b/WickedEngine/RenderPath3D.cpp
@@ -10,7 +10,7 @@ using namespace wiGraphics;
void RenderPath3D::ResizeBuffers()
{
- GraphicsDevice* device = wiRenderer::GetDevice();
+ GraphicsDevice* device = wiGraphics::GetDevice();
XMUINT2 internalResolution = GetInternalResolution();
@@ -20,19 +20,19 @@ void RenderPath3D::ResizeBuffers()
{
TextureDesc desc;
- 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 = 1;
+ desc.format = Format::R11G11B10_FLOAT;
+ desc.bind_flags = BindFlag::RENDER_TARGET | BindFlag::SHADER_RESOURCE | BindFlag::UNORDERED_ACCESS;
+ desc.width = internalResolution.x;
+ desc.height = internalResolution.y;
+ desc.sample_count = 1;
device->CreateTexture(&desc, nullptr, &rtMain);
device->SetName(&rtMain, "rtMain");
if (getMSAASampleCount() > 1)
{
- desc.SampleCount = getMSAASampleCount();
- desc.BindFlags = BIND_RENDER_TARGET | BIND_SHADER_RESOURCE;
+ desc.sample_count = getMSAASampleCount();
+ desc.bind_flags = BindFlag::RENDER_TARGET | BindFlag::SHADER_RESOURCE;
device->CreateTexture(&desc, nullptr, &rtMain_render);
device->SetName(&rtMain_render, "rtMain_render");
@@ -44,26 +44,26 @@ void RenderPath3D::ResizeBuffers()
}
{
TextureDesc desc;
- desc.Width = internalResolution.x;
- desc.Height = internalResolution.y;
- desc.layout = RESOURCE_STATE_SHADER_RESOURCE_COMPUTE;
- desc.SampleCount = 1;
+ desc.width = internalResolution.x;
+ desc.height = internalResolution.y;
+ desc.layout = ResourceState::SHADER_RESOURCE_COMPUTE;
+ desc.sample_count = 1;
- desc.BindFlags = BIND_RENDER_TARGET | BIND_SHADER_RESOURCE | BIND_UNORDERED_ACCESS;
- desc.Format = FORMAT_R32G32_UINT;
+ desc.bind_flags = BindFlag::RENDER_TARGET | BindFlag::SHADER_RESOURCE | BindFlag::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;
+ desc.bind_flags = BindFlag::SHADER_RESOURCE | BindFlag::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 = rtGbuffer[GBUFFER_PRIMITIVEID].desc;
- desc.SampleCount = getMSAASampleCount();
- desc.BindFlags = BIND_RENDER_TARGET | BIND_SHADER_RESOURCE;
+ desc.sample_count = getMSAASampleCount();
+ desc.bind_flags = BindFlag::RENDER_TARGET | BindFlag::SHADER_RESOURCE;
device->CreateTexture(&desc, nullptr, &rtPrimitiveID_render);
device->SetName(&rtPrimitiveID_render, "rtPrimitiveID_render");
@@ -75,26 +75,26 @@ void RenderPath3D::ResizeBuffers()
}
{
TextureDesc desc;
- desc.BindFlags = BIND_RENDER_TARGET | BIND_SHADER_RESOURCE;
- desc.Format = FORMAT_R16G16_FLOAT;
- desc.Width = internalResolution.x;
- desc.Height = internalResolution.y;
- desc.SampleCount = getMSAASampleCount();
+ desc.bind_flags = BindFlag::RENDER_TARGET | BindFlag::SHADER_RESOURCE;
+ desc.format = Format::R16G16_FLOAT;
+ desc.width = internalResolution.x;
+ desc.height = internalResolution.y;
+ desc.sample_count = getMSAASampleCount();
device->CreateTexture(&desc, nullptr, &rtParticleDistortion);
device->SetName(&rtParticleDistortion, "rtParticleDistortion");
if (getMSAASampleCount() > 1)
{
- desc.SampleCount = 1;
+ desc.sample_count = 1;
device->CreateTexture(&desc, nullptr, &rtParticleDistortion_Resolved);
device->SetName(&rtParticleDistortion_Resolved, "rtParticleDistortion_Resolved");
}
}
{
TextureDesc desc;
- desc.Format = FORMAT_R16G16B16A16_FLOAT;
- desc.BindFlags = BIND_RENDER_TARGET | BIND_SHADER_RESOURCE | BIND_UNORDERED_ACCESS;
- desc.Width = internalResolution.x / 4;
- desc.Height = internalResolution.y / 4;
+ desc.format = Format::R16G16B16A16_FLOAT;
+ desc.bind_flags = BindFlag::RENDER_TARGET | BindFlag::SHADER_RESOURCE | BindFlag::UNORDERED_ACCESS;
+ desc.width = internalResolution.x / 4;
+ desc.height = internalResolution.y / 4;
device->CreateTexture(&desc, nullptr, &rtVolumetricLights[0]);
device->SetName(&rtVolumetricLights[0], "rtVolumetricLights[0]");
device->CreateTexture(&desc, nullptr, &rtVolumetricLights[1]);
@@ -102,80 +102,80 @@ void RenderPath3D::ResizeBuffers()
}
{
TextureDesc desc;
- desc.BindFlags = BIND_RENDER_TARGET | BIND_SHADER_RESOURCE;
- desc.Format = FORMAT_R16G16_FLOAT;
- desc.Width = internalResolution.x;
- desc.Height = internalResolution.y;
+ desc.bind_flags = BindFlag::RENDER_TARGET | BindFlag::SHADER_RESOURCE;
+ desc.format = Format::R16G16_FLOAT;
+ desc.width = internalResolution.x;
+ desc.height = internalResolution.y;
device->CreateTexture(&desc, nullptr, &rtWaterRipple);
device->SetName(&rtWaterRipple, "rtWaterRipple");
}
{
TextureDesc desc;
- desc.BindFlags = BIND_SHADER_RESOURCE | BIND_UNORDERED_ACCESS | BIND_RENDER_TARGET;
- desc.Format = FORMAT_R11G11B10_FLOAT;
- desc.Width = internalResolution.x / 2;
- desc.Height = internalResolution.y / 2;
- desc.MipLevels = std::min(8u, (uint32_t)std::log2(std::max(desc.Width, desc.Height)));
+ desc.bind_flags = BindFlag::SHADER_RESOURCE | BindFlag::UNORDERED_ACCESS | BindFlag::RENDER_TARGET;
+ desc.format = Format::R11G11B10_FLOAT;
+ desc.width = internalResolution.x / 2;
+ desc.height = internalResolution.y / 2;
+ desc.mip_levels = std::min(8u, (uint32_t)std::log2(std::max(desc.width, desc.height)));
device->CreateTexture(&desc, nullptr, &rtSceneCopy);
device->SetName(&rtSceneCopy, "rtSceneCopy");
- desc.BindFlags = BIND_SHADER_RESOURCE | BIND_UNORDERED_ACCESS;
+ desc.bind_flags = BindFlag::SHADER_RESOURCE | BindFlag::UNORDERED_ACCESS;
device->CreateTexture(&desc, nullptr, &rtSceneCopy_tmp);
device->SetName(&rtSceneCopy_tmp, "rtSceneCopy_tmp");
- for (uint32_t i = 0; i < rtSceneCopy.GetDesc().MipLevels; ++i)
+ for (uint32_t i = 0; i < rtSceneCopy.GetDesc().mip_levels; ++i)
{
int subresource_index;
- subresource_index = device->CreateSubresource(&rtSceneCopy, SRV, 0, 1, i, 1);
+ subresource_index = device->CreateSubresource(&rtSceneCopy, SubresourceType::SRV, 0, 1, i, 1);
assert(subresource_index == i);
- subresource_index = device->CreateSubresource(&rtSceneCopy_tmp, SRV, 0, 1, i, 1);
+ subresource_index = device->CreateSubresource(&rtSceneCopy_tmp, SubresourceType::SRV, 0, 1, i, 1);
assert(subresource_index == i);
- subresource_index = device->CreateSubresource(&rtSceneCopy, UAV, 0, 1, i, 1);
+ subresource_index = device->CreateSubresource(&rtSceneCopy, SubresourceType::UAV, 0, 1, i, 1);
assert(subresource_index == i);
- subresource_index = device->CreateSubresource(&rtSceneCopy_tmp, UAV, 0, 1, i, 1);
+ subresource_index = device->CreateSubresource(&rtSceneCopy_tmp, SubresourceType::UAV, 0, 1, i, 1);
assert(subresource_index == i);
}
}
{
TextureDesc desc;
- desc.BindFlags = BIND_RENDER_TARGET | BIND_SHADER_RESOURCE;
- desc.Format = FORMAT_R11G11B10_FLOAT;
- desc.Width = internalResolution.x / 4;
- desc.Height = internalResolution.y / 4;
+ desc.bind_flags = BindFlag::RENDER_TARGET | BindFlag::SHADER_RESOURCE;
+ desc.format = Format::R11G11B10_FLOAT;
+ desc.width = internalResolution.x / 4;
+ desc.height = internalResolution.y / 4;
device->CreateTexture(&desc, nullptr, &rtReflection);
device->SetName(&rtReflection, "rtReflection");
}
{
TextureDesc desc;
- desc.BindFlags = BIND_RENDER_TARGET | BIND_SHADER_RESOURCE;
- desc.Format = FORMAT_R11G11B10_FLOAT;
- desc.Width = internalResolution.x;
- desc.Height = internalResolution.y;
- desc.SampleCount = getMSAASampleCount();
+ desc.bind_flags = BindFlag::RENDER_TARGET | BindFlag::SHADER_RESOURCE;
+ desc.format = Format::R11G11B10_FLOAT;
+ desc.width = internalResolution.x;
+ desc.height = internalResolution.y;
+ desc.sample_count = getMSAASampleCount();
device->CreateTexture(&desc, nullptr, &rtSun[0]);
device->SetName(&rtSun[0], "rtSun[0]");
- desc.BindFlags = BIND_SHADER_RESOURCE | BIND_UNORDERED_ACCESS;
- desc.SampleCount = 1;
- desc.Width = internalResolution.x / 2;
- desc.Height = internalResolution.y / 2;
+ desc.bind_flags = BindFlag::SHADER_RESOURCE | BindFlag::UNORDERED_ACCESS;
+ desc.sample_count = 1;
+ desc.width = internalResolution.x / 2;
+ desc.height = internalResolution.y / 2;
device->CreateTexture(&desc, nullptr, &rtSun[1]);
device->SetName(&rtSun[1], "rtSun[1]");
if (getMSAASampleCount() > 1)
{
- desc.Width = internalResolution.x;
- desc.Height = internalResolution.y;
- desc.SampleCount = 1;
+ desc.width = internalResolution.x;
+ desc.height = internalResolution.y;
+ desc.sample_count = 1;
device->CreateTexture(&desc, nullptr, &rtSun_resolved);
device->SetName(&rtSun_resolved, "rtSun_resolved");
}
}
{
TextureDesc desc;
- desc.BindFlags = BIND_SHADER_RESOURCE | BIND_UNORDERED_ACCESS;
- desc.Format = FORMAT_R11G11B10_FLOAT;
- desc.Width = internalResolution.x;
- desc.Height = internalResolution.y;
+ desc.bind_flags = BindFlag::SHADER_RESOURCE | BindFlag::UNORDERED_ACCESS;
+ desc.format = Format::R11G11B10_FLOAT;
+ desc.width = internalResolution.x;
+ desc.height = internalResolution.y;
device->CreateTexture(&desc, nullptr, &rtTemporalAA[0]);
device->SetName(&rtTemporalAA[0], "rtTemporalAA[0]");
device->CreateTexture(&desc, nullptr, &rtTemporalAA[1]);
@@ -183,41 +183,41 @@ void RenderPath3D::ResizeBuffers()
}
{
TextureDesc desc;
- desc.BindFlags = BIND_RENDER_TARGET | BIND_SHADER_RESOURCE | BIND_UNORDERED_ACCESS;
- desc.Format = FORMAT_R11G11B10_FLOAT;
- desc.Width = internalResolution.x;
- desc.Height = internalResolution.y;
+ desc.bind_flags = BindFlag::RENDER_TARGET | BindFlag::SHADER_RESOURCE | BindFlag::UNORDERED_ACCESS;
+ desc.format = Format::R11G11B10_FLOAT;
+ desc.width = internalResolution.x;
+ desc.height = internalResolution.y;
device->CreateTexture(&desc, nullptr, &rtPostprocess);
device->SetName(&rtPostprocess, "rtPostprocess");
}
{
TextureDesc desc;
- desc.BindFlags = BIND_RENDER_TARGET | BIND_SHADER_RESOURCE | BIND_UNORDERED_ACCESS;
- desc.Format = FORMAT_R10G10B10A2_UNORM;
- desc.Width = internalResolution.x / 4;
- desc.Height = internalResolution.y / 4;
- desc.BindFlags = BIND_UNORDERED_ACCESS | BIND_SHADER_RESOURCE;
+ desc.bind_flags = BindFlag::RENDER_TARGET | BindFlag::SHADER_RESOURCE | BindFlag::UNORDERED_ACCESS;
+ desc.format = Format::R10G10B10A2_UNORM;
+ desc.width = internalResolution.x / 4;
+ desc.height = internalResolution.y / 4;
+ desc.bind_flags = BindFlag::UNORDERED_ACCESS | BindFlag::SHADER_RESOURCE;
device->CreateTexture(&desc, nullptr, &rtGUIBlurredBackground[0]);
device->SetName(&rtGUIBlurredBackground[0], "rtGUIBlurredBackground[0]");
- desc.Width /= 4;
- desc.Height /= 4;
+ desc.width /= 4;
+ desc.height /= 4;
device->CreateTexture(&desc, nullptr, &rtGUIBlurredBackground[1]);
device->SetName(&rtGUIBlurredBackground[1], "rtGUIBlurredBackground[1]");
device->CreateTexture(&desc, nullptr, &rtGUIBlurredBackground[2]);
device->SetName(&rtGUIBlurredBackground[2], "rtGUIBlurredBackground[2]");
}
- if(device->CheckCapability(GRAPHICSDEVICE_CAPABILITY_VARIABLE_RATE_SHADING_TIER2) &&
+ if(device->CheckCapability(GraphicsDeviceCapability::VARIABLE_RATE_SHADING_TIER2) &&
wiRenderer::GetVariableRateShadingClassification())
{
uint32_t tileSize = device->GetVariableRateShadingTileSize();
TextureDesc desc;
- 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;
- desc.Height = (internalResolution.y + tileSize - 1) / tileSize;
+ desc.layout = ResourceState::UNORDERED_ACCESS;
+ desc.bind_flags = BindFlag::UNORDERED_ACCESS | BindFlag::SHADING_RATE;
+ desc.format = Format::R8_UINT;
+ desc.width = (internalResolution.x + tileSize - 1) / tileSize;
+ desc.height = (internalResolution.y + tileSize - 1) / tileSize;
device->CreateTexture(&desc, nullptr, &rtShadingRate);
device->SetName(&rtShadingRate, "rtShadingRate");
@@ -229,66 +229,66 @@ void RenderPath3D::ResizeBuffers()
// Depth buffers:
{
TextureDesc desc;
- desc.Width = internalResolution.x;
- desc.Height = internalResolution.y;
+ desc.width = internalResolution.x;
+ desc.height = internalResolution.y;
- desc.SampleCount = getMSAASampleCount();
- desc.layout = RESOURCE_STATE_DEPTHSTENCIL_READONLY;
- desc.Format = FORMAT_R32G8X24_TYPELESS;
- desc.BindFlags = BIND_DEPTH_STENCIL | BIND_SHADER_RESOURCE;
+ desc.sample_count = getMSAASampleCount();
+ desc.layout = ResourceState::DEPTHSTENCIL_READONLY;
+ desc.format = Format::R32G8X24_TYPELESS;
+ desc.bind_flags = BindFlag::DEPTH_STENCIL | BindFlag::SHADER_RESOURCE;
device->CreateTexture(&desc, nullptr, &depthBuffer_Main);
device->SetName(&depthBuffer_Main, "depthBuffer_Main");
- 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 = 5;
+ desc.layout = ResourceState::SHADER_RESOURCE_COMPUTE;
+ desc.format = Format::R32_FLOAT;
+ desc.bind_flags = BindFlag::SHADER_RESOURCE | BindFlag::UNORDERED_ACCESS;
+ desc.sample_count = 1;
+ desc.mip_levels = 5;
device->CreateTexture(&desc, nullptr, &depthBuffer_Copy);
device->SetName(&depthBuffer_Copy, "depthBuffer_Copy");
device->CreateTexture(&desc, nullptr, &depthBuffer_Copy1);
device->SetName(&depthBuffer_Copy1, "depthBuffer_Copy1");
- for (uint32_t i = 0; i < depthBuffer_Copy.desc.MipLevels; ++i)
+ for (uint32_t i = 0; i < depthBuffer_Copy.desc.mip_levels; ++i)
{
int subresource = 0;
- subresource = device->CreateSubresource(&depthBuffer_Copy, SRV, 0, 1, i, 1);
+ subresource = device->CreateSubresource(&depthBuffer_Copy, SubresourceType::SRV, 0, 1, i, 1);
assert(subresource == i);
- subresource = device->CreateSubresource(&depthBuffer_Copy, UAV, 0, 1, i, 1);
+ subresource = device->CreateSubresource(&depthBuffer_Copy, SubresourceType::UAV, 0, 1, i, 1);
assert(subresource == i);
- subresource = device->CreateSubresource(&depthBuffer_Copy1, SRV, 0, 1, i, 1);
+ subresource = device->CreateSubresource(&depthBuffer_Copy1, SubresourceType::SRV, 0, 1, i, 1);
assert(subresource == i);
- subresource = device->CreateSubresource(&depthBuffer_Copy1, UAV, 0, 1, i, 1);
+ subresource = device->CreateSubresource(&depthBuffer_Copy1, SubresourceType::UAV, 0, 1, i, 1);
assert(subresource == i);
}
}
{
TextureDesc desc;
- desc.BindFlags = BIND_DEPTH_STENCIL | BIND_SHADER_RESOURCE;
- desc.Format = FORMAT_R32_TYPELESS;
- desc.Width = internalResolution.x / 4;
- desc.Height = internalResolution.y / 4;
- desc.layout = RESOURCE_STATE_DEPTHSTENCIL_READONLY;
+ desc.bind_flags = BindFlag::DEPTH_STENCIL | BindFlag::SHADER_RESOURCE;
+ desc.format = Format::R32_TYPELESS;
+ desc.width = internalResolution.x / 4;
+ desc.height = internalResolution.y / 4;
+ desc.layout = ResourceState::DEPTHSTENCIL_READONLY;
device->CreateTexture(&desc, nullptr, &depthBuffer_Reflection);
device->SetName(&depthBuffer_Reflection, "depthBuffer_Reflection");
}
{
TextureDesc desc;
- desc.BindFlags = BIND_SHADER_RESOURCE | BIND_UNORDERED_ACCESS;
- desc.Format = FORMAT_R32_FLOAT;
- desc.Width = internalResolution.x;
- desc.Height = internalResolution.y;
- desc.MipLevels = 5;
- desc.layout = RESOURCE_STATE_SHADER_RESOURCE_COMPUTE;
+ desc.bind_flags = BindFlag::SHADER_RESOURCE | BindFlag::UNORDERED_ACCESS;
+ desc.format = Format::R32_FLOAT;
+ desc.width = internalResolution.x;
+ desc.height = internalResolution.y;
+ desc.mip_levels = 5;
+ desc.layout = ResourceState::SHADER_RESOURCE_COMPUTE;
device->CreateTexture(&desc, nullptr, &rtLinearDepth);
device->SetName(&rtLinearDepth, "rtLinearDepth");
- for (uint32_t i = 0; i < desc.MipLevels; ++i)
+ for (uint32_t i = 0; i < desc.mip_levels; ++i)
{
int subresource_index;
- subresource_index = device->CreateSubresource(&rtLinearDepth, SRV, 0, 1, i, 1);
+ subresource_index = device->CreateSubresource(&rtLinearDepth, SubresourceType::SRV, 0, 1, i, 1);
assert(subresource_index == i);
- subresource_index = device->CreateSubresource(&rtLinearDepth, UAV, 0, 1, i, 1);
+ subresource_index = device->CreateSubresource(&rtLinearDepth, SubresourceType::UAV, 0, 1, i, 1);
assert(subresource_index == i);
}
}
@@ -299,35 +299,35 @@ void RenderPath3D::ResizeBuffers()
desc.attachments.push_back(
RenderPassAttachment::DepthStencil(
&depthBuffer_Main,
- RenderPassAttachment::LOADOP_CLEAR,
- RenderPassAttachment::STOREOP_STORE,
- RESOURCE_STATE_DEPTHSTENCIL_READONLY,
- RESOURCE_STATE_DEPTHSTENCIL,
- RESOURCE_STATE_SHADER_RESOURCE
+ RenderPassAttachment::LoadOp::CLEAR,
+ RenderPassAttachment::StoreOp::STORE,
+ ResourceState::DEPTHSTENCIL_READONLY,
+ ResourceState::DEPTHSTENCIL,
+ ResourceState::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
+ RenderPassAttachment::LoadOp::DONTCARE,
+ RenderPassAttachment::StoreOp::STORE,
+ ResourceState::SHADER_RESOURCE_COMPUTE,
+ ResourceState::RENDERTARGET,
+ ResourceState::SHADER_RESOURCE_COMPUTE
)
);
device->CreateRenderPass(&desc, &renderpass_depthprepass);
desc.attachments.clear();
- desc.attachments.push_back(RenderPassAttachment::RenderTarget(&rtMain_render, 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,
- RESOURCE_STATE_SHADER_RESOURCE,
- RESOURCE_STATE_DEPTHSTENCIL_READONLY,
- RESOURCE_STATE_DEPTHSTENCIL_READONLY
+ RenderPassAttachment::LoadOp::LOAD,
+ RenderPassAttachment::StoreOp::STORE,
+ ResourceState::SHADER_RESOURCE,
+ ResourceState::DEPTHSTENCIL_READONLY,
+ ResourceState::DEPTHSTENCIL_READONLY
)
);
if (getMSAASampleCount() > 1)
@@ -335,24 +335,24 @@ void RenderPath3D::ResizeBuffers()
desc.attachments.push_back(RenderPassAttachment::Resolve(&rtMain));
}
- if (device->CheckCapability(GRAPHICSDEVICE_CAPABILITY_VARIABLE_RATE_SHADING_TIER2) && rtShadingRate.IsValid())
+ if (device->CheckCapability(GraphicsDeviceCapability::VARIABLE_RATE_SHADING_TIER2) && rtShadingRate.IsValid())
{
- desc.attachments.push_back(RenderPassAttachment::ShadingRateSource(&rtShadingRate, RESOURCE_STATE_UNORDERED_ACCESS, RESOURCE_STATE_UNORDERED_ACCESS));
+ desc.attachments.push_back(RenderPassAttachment::ShadingRateSource(&rtShadingRate, ResourceState::UNORDERED_ACCESS, ResourceState::UNORDERED_ACCESS));
}
device->CreateRenderPass(&desc, &renderpass_main);
}
{
RenderPassDesc desc;
- desc.attachments.push_back(RenderPassAttachment::RenderTarget(&rtMain_render, 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,
- RESOURCE_STATE_DEPTHSTENCIL_READONLY,
- RESOURCE_STATE_DEPTHSTENCIL,
- RESOURCE_STATE_DEPTHSTENCIL_READONLY
+ RenderPassAttachment::LoadOp::LOAD,
+ RenderPassAttachment::StoreOp::STORE,
+ ResourceState::DEPTHSTENCIL_READONLY,
+ ResourceState::DEPTHSTENCIL,
+ ResourceState::DEPTHSTENCIL_READONLY
)
);
if (getMSAASampleCount() > 1)
@@ -366,11 +366,11 @@ void RenderPath3D::ResizeBuffers()
desc.attachments.push_back(
RenderPassAttachment::DepthStencil(
&depthBuffer_Reflection,
- RenderPassAttachment::LOADOP_CLEAR,
- RenderPassAttachment::STOREOP_STORE,
- RESOURCE_STATE_DEPTHSTENCIL_READONLY,
- RESOURCE_STATE_DEPTHSTENCIL,
- RESOURCE_STATE_SHADER_RESOURCE
+ RenderPassAttachment::LoadOp::CLEAR,
+ RenderPassAttachment::StoreOp::STORE,
+ ResourceState::DEPTHSTENCIL_READONLY,
+ ResourceState::DEPTHSTENCIL,
+ ResourceState::SHADER_RESOURCE
)
);
@@ -381,21 +381,21 @@ void RenderPath3D::ResizeBuffers()
desc.attachments.push_back(
RenderPassAttachment::RenderTarget(
&rtReflection,
- RenderPassAttachment::LOADOP_DONTCARE,
- RenderPassAttachment::STOREOP_STORE,
- RESOURCE_STATE_SHADER_RESOURCE,
- RESOURCE_STATE_RENDERTARGET,
- RESOURCE_STATE_SHADER_RESOURCE
+ RenderPassAttachment::LoadOp::DONTCARE,
+ RenderPassAttachment::StoreOp::STORE,
+ ResourceState::SHADER_RESOURCE,
+ ResourceState::RENDERTARGET,
+ ResourceState::SHADER_RESOURCE
)
);
desc.attachments.push_back(
RenderPassAttachment::DepthStencil(
&depthBuffer_Reflection,
- RenderPassAttachment::LOADOP_LOAD,
- RenderPassAttachment::STOREOP_DONTCARE,
- RESOURCE_STATE_SHADER_RESOURCE,
- RESOURCE_STATE_DEPTHSTENCIL_READONLY,
- RESOURCE_STATE_DEPTHSTENCIL_READONLY
+ RenderPassAttachment::LoadOp::LOAD,
+ RenderPassAttachment::StoreOp::DONTCARE,
+ ResourceState::SHADER_RESOURCE,
+ ResourceState::DEPTHSTENCIL_READONLY,
+ ResourceState::DEPTHSTENCIL_READONLY
)
);
@@ -403,7 +403,7 @@ void RenderPath3D::ResizeBuffers()
}
{
RenderPassDesc desc;
- desc.attachments.push_back(RenderPassAttachment::RenderTarget(&rtSceneCopy, RenderPassAttachment::LOADOP_DONTCARE));
+ desc.attachments.push_back(RenderPassAttachment::RenderTarget(&rtSceneCopy, RenderPassAttachment::LoadOp::DONTCARE));
device->CreateRenderPass(&desc, &renderpass_downsamplescene);
}
@@ -412,17 +412,17 @@ void RenderPath3D::ResizeBuffers()
desc.attachments.push_back(
RenderPassAttachment::DepthStencil(
&depthBuffer_Main,
- RenderPassAttachment::LOADOP_LOAD,
- RenderPassAttachment::STOREOP_STORE,
- RESOURCE_STATE_DEPTHSTENCIL_READONLY,
- RESOURCE_STATE_DEPTHSTENCIL_READONLY,
- RESOURCE_STATE_DEPTHSTENCIL_READONLY
+ RenderPassAttachment::LoadOp::LOAD,
+ RenderPassAttachment::StoreOp::STORE,
+ ResourceState::DEPTHSTENCIL_READONLY,
+ ResourceState::DEPTHSTENCIL_READONLY,
+ ResourceState::DEPTHSTENCIL_READONLY
)
);
- desc.attachments.push_back(RenderPassAttachment::RenderTarget(&rtSun[0], RenderPassAttachment::LOADOP_CLEAR));
+ desc.attachments.push_back(RenderPassAttachment::RenderTarget(&rtSun[0], RenderPassAttachment::LoadOp::CLEAR));
if (getMSAASampleCount() > 1)
{
- desc.attachments.back().storeop = RenderPassAttachment::STOREOP_DONTCARE;
+ desc.attachments.back().storeop = RenderPassAttachment::StoreOp::DONTCARE;
desc.attachments.push_back(RenderPassAttachment::Resolve(&rtSun_resolved));
}
@@ -430,21 +430,21 @@ void RenderPath3D::ResizeBuffers()
}
{
RenderPassDesc desc;
- desc.attachments.push_back(RenderPassAttachment::RenderTarget(&rtVolumetricLights[0], RenderPassAttachment::LOADOP_CLEAR));
+ desc.attachments.push_back(RenderPassAttachment::RenderTarget(&rtVolumetricLights[0], RenderPassAttachment::LoadOp::CLEAR));
device->CreateRenderPass(&desc, &renderpass_volumetriclight);
}
{
RenderPassDesc desc;
- desc.attachments.push_back(RenderPassAttachment::RenderTarget(&rtParticleDistortion, RenderPassAttachment::LOADOP_CLEAR));
+ desc.attachments.push_back(RenderPassAttachment::RenderTarget(&rtParticleDistortion, RenderPassAttachment::LoadOp::CLEAR));
desc.attachments.push_back(
RenderPassAttachment::DepthStencil(
&depthBuffer_Main,
- RenderPassAttachment::LOADOP_LOAD,
- RenderPassAttachment::STOREOP_STORE,
- RESOURCE_STATE_DEPTHSTENCIL_READONLY,
- RESOURCE_STATE_DEPTHSTENCIL_READONLY,
- RESOURCE_STATE_DEPTHSTENCIL_READONLY
+ RenderPassAttachment::LoadOp::LOAD,
+ RenderPassAttachment::StoreOp::STORE,
+ ResourceState::DEPTHSTENCIL_READONLY,
+ ResourceState::DEPTHSTENCIL_READONLY,
+ ResourceState::DEPTHSTENCIL_READONLY
)
);
@@ -457,7 +457,7 @@ void RenderPath3D::ResizeBuffers()
}
{
RenderPassDesc desc;
- desc.attachments.push_back(RenderPassAttachment::RenderTarget(&rtWaterRipple, RenderPassAttachment::LOADOP_CLEAR));
+ desc.attachments.push_back(RenderPassAttachment::RenderTarget(&rtWaterRipple, RenderPassAttachment::LoadOp::CLEAR));
device->CreateRenderPass(&desc, &renderpass_waterripples);
}
@@ -466,30 +466,30 @@ void RenderPath3D::ResizeBuffers()
// Other resources:
{
TextureDesc desc;
- desc.Width = internalResolution.x;
- desc.Height = internalResolution.y;
- 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.width = internalResolution.x;
+ desc.height = internalResolution.y;
+ desc.mip_levels = 1;
+ desc.array_size = 1;
+ desc.format = Format::R8G8B8A8_UNORM;
+ desc.sample_count = 1;
+ desc.usage = Usage::DEFAULT;
+ desc.bind_flags = BindFlag::SHADER_RESOURCE | BindFlag::UNORDERED_ACCESS;
device->CreateTexture(&desc, nullptr, &debugUAV);
device->SetName(&debugUAV, "debugUAV");
}
wiRenderer::CreateTiledLightResources(tiledLightResources, internalResolution);
- wiRenderer::CreateTiledLightResources(tiledLightResources_planarReflection, XMUINT2(depthBuffer_Reflection.desc.Width, depthBuffer_Reflection.desc.Height));
+ wiRenderer::CreateTiledLightResources(tiledLightResources_planarReflection, XMUINT2(depthBuffer_Reflection.desc.width, depthBuffer_Reflection.desc.height));
wiRenderer::CreateLuminanceResources(luminanceResources, internalResolution);
wiRenderer::CreateScreenSpaceShadowResources(screenspaceshadowResources, internalResolution);
wiRenderer::CreateDepthOfFieldResources(depthoffieldResources, internalResolution);
wiRenderer::CreateMotionBlurResources(motionblurResources, internalResolution);
wiRenderer::CreateVolumetricCloudResources(volumetriccloudResources, internalResolution);
- wiRenderer::CreateVolumetricCloudResources(volumetriccloudResources_reflection, XMUINT2(depthBuffer_Reflection.desc.Width, depthBuffer_Reflection.desc.Height));
+ 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))
+ if (device->CheckCapability(GraphicsDeviceCapability::RAYTRACING))
{
wiRenderer::CreateRTShadowResources(rtshadowResources, internalResolution);
}
@@ -510,7 +510,7 @@ void RenderPath3D::PreUpdate()
void RenderPath3D::Update(float dt)
{
- if (rtMain_render.desc.SampleCount != msaaSampleCount)
+ if (rtMain_render.desc.sample_count != msaaSampleCount)
{
ResizeBuffers();
}
@@ -561,7 +561,7 @@ void RenderPath3D::Update(float dt)
if (wiRenderer::GetTemporalAAEnabled())
{
- const XMFLOAT4& halton = wiMath::GetHaltonSequence(wiRenderer::GetDevice()->GetFrameCount() % 256);
+ const XMFLOAT4& halton = wiMath::GetHaltonSequence(wiGraphics::GetDevice()->GetFrameCount() % 256);
camera->jitter.x = (halton.x * 2 - 1) / (float)internalResolution.x;
camera->jitter.y = (halton.y * 2 - 1) / (float)internalResolution.y;
}
@@ -592,16 +592,16 @@ void RenderPath3D::Update(float dt)
rtShadow = {};
}
- GraphicsDevice* device = wiRenderer::GetDevice();
+ GraphicsDevice* device = wiGraphics::GetDevice();
if((wiRenderer::GetScreenSpaceShadowsEnabled() || wiRenderer::GetRaytracedShadowsEnabled()) && !rtShadow.IsValid())
{
TextureDesc desc;
- desc.BindFlags = BIND_SHADER_RESOURCE | BIND_UNORDERED_ACCESS;
- desc.Format = FORMAT_R32G32B32A32_UINT;
- desc.Width = internalResolution.x / 2;
- desc.Height = internalResolution.y / 2;
- desc.layout = RESOURCE_STATE_SHADER_RESOURCE_COMPUTE;
+ desc.bind_flags = BindFlag::SHADER_RESOURCE | BindFlag::UNORDERED_ACCESS;
+ desc.format = Format::R32G32B32A32_UINT;
+ desc.width = internalResolution.x / 2;
+ desc.height = internalResolution.y / 2;
+ desc.layout = ResourceState::SHADER_RESOURCE_COMPUTE;
device->CreateTexture(&desc, nullptr, &rtShadow);
device->SetName(&rtShadow, "rtShadow");
}
@@ -611,29 +611,29 @@ void RenderPath3D::Update(float dt)
camera->canvas = *this;
camera->width = (float)internalResolution.x;
camera->height = (float)internalResolution.y;
- camera->texture_depth_index = device->GetDescriptorIndex(&depthBuffer_Copy, SRV);
- camera->texture_lineardepth_index = device->GetDescriptorIndex(&rtLinearDepth, SRV);
- camera->texture_gbuffer0_index = device->GetDescriptorIndex(&rtGbuffer[GBUFFER_PRIMITIVEID], SRV);
- camera->texture_gbuffer1_index = device->GetDescriptorIndex(&rtGbuffer[GBUFFER_VELOCITY], SRV);
- camera->buffer_entitytiles_opaque_index = device->GetDescriptorIndex(&tiledLightResources.entityTiles_Opaque, SRV);
- camera->buffer_entitytiles_transparent_index = device->GetDescriptorIndex(&tiledLightResources.entityTiles_Transparent, SRV);
- camera->texture_reflection_index = device->GetDescriptorIndex(&rtReflection, SRV);
- camera->texture_refraction_index = device->GetDescriptorIndex(&rtSceneCopy, SRV);
- camera->texture_waterriples_index = device->GetDescriptorIndex(&rtWaterRipple, SRV);
- camera->texture_ao_index = device->GetDescriptorIndex(&rtAO, SRV);
- camera->texture_ssr_index = device->GetDescriptorIndex(&rtSSR, SRV);
- camera->texture_rtshadow_index = device->GetDescriptorIndex(&rtShadow, SRV);
- camera->texture_surfelgi_index = device->GetDescriptorIndex(&surfelGIResources.result, SRV);
+ camera->texture_depth_index = device->GetDescriptorIndex(&depthBuffer_Copy, SubresourceType::SRV);
+ camera->texture_lineardepth_index = device->GetDescriptorIndex(&rtLinearDepth, SubresourceType::SRV);
+ camera->texture_gbuffer0_index = device->GetDescriptorIndex(&rtGbuffer[GBUFFER_PRIMITIVEID], SubresourceType::SRV);
+ camera->texture_gbuffer1_index = device->GetDescriptorIndex(&rtGbuffer[GBUFFER_VELOCITY], SubresourceType::SRV);
+ camera->buffer_entitytiles_opaque_index = device->GetDescriptorIndex(&tiledLightResources.entityTiles_Opaque, SubresourceType::SRV);
+ camera->buffer_entitytiles_transparent_index = device->GetDescriptorIndex(&tiledLightResources.entityTiles_Transparent, SubresourceType::SRV);
+ camera->texture_reflection_index = device->GetDescriptorIndex(&rtReflection, SubresourceType::SRV);
+ camera->texture_refraction_index = device->GetDescriptorIndex(&rtSceneCopy, SubresourceType::SRV);
+ camera->texture_waterriples_index = device->GetDescriptorIndex(&rtWaterRipple, SubresourceType::SRV);
+ camera->texture_ao_index = device->GetDescriptorIndex(&rtAO, SubresourceType::SRV);
+ camera->texture_ssr_index = device->GetDescriptorIndex(&rtSSR, SubresourceType::SRV);
+ camera->texture_rtshadow_index = device->GetDescriptorIndex(&rtShadow, SubresourceType::SRV);
+ camera->texture_surfelgi_index = device->GetDescriptorIndex(&surfelGIResources.result, SubresourceType::SRV);
camera_reflection.canvas = *this;
- camera_reflection.width = (float)depthBuffer_Reflection.desc.Width;
- camera_reflection.height = (float)depthBuffer_Reflection.desc.Height;
- camera_reflection.texture_depth_index = device->GetDescriptorIndex(&depthBuffer_Reflection, SRV);
+ camera_reflection.width = (float)depthBuffer_Reflection.desc.width;
+ camera_reflection.height = (float)depthBuffer_Reflection.desc.height;
+ camera_reflection.texture_depth_index = device->GetDescriptorIndex(&depthBuffer_Reflection, SubresourceType::SRV);
camera_reflection.texture_lineardepth_index = -1;
camera_reflection.texture_gbuffer0_index = -1;
camera_reflection.texture_gbuffer1_index = -1;
- camera_reflection.buffer_entitytiles_opaque_index = device->GetDescriptorIndex(&tiledLightResources_planarReflection.entityTiles_Opaque, SRV);
- camera_reflection.buffer_entitytiles_transparent_index = device->GetDescriptorIndex(&tiledLightResources_planarReflection.entityTiles_Transparent, SRV);
+ camera_reflection.buffer_entitytiles_opaque_index = device->GetDescriptorIndex(&tiledLightResources_planarReflection.entityTiles_Opaque, SubresourceType::SRV);
+ camera_reflection.buffer_entitytiles_transparent_index = device->GetDescriptorIndex(&tiledLightResources_planarReflection.entityTiles_Transparent, SubresourceType::SRV);
camera_reflection.texture_reflection_index = -1;
camera_reflection.texture_refraction_index = -1;
camera_reflection.texture_waterriples_index = -1;
@@ -645,12 +645,11 @@ void RenderPath3D::Update(float dt)
void RenderPath3D::Render() const
{
- GraphicsDevice* device = wiRenderer::GetDevice();
+ GraphicsDevice* device = wiGraphics::GetDevice();
wiJobSystem::context ctx;
- CommandList cmd;
// Preparing the frame:
- cmd = device->BeginCommandList();
+ CommandList cmd = device->BeginCommandList();
CommandList cmd_prepareframe = cmd;
wiJobSystem::Execute(ctx, [this, cmd](wiJobArgs args) {
wiRenderer::BindCameraCB(
@@ -667,7 +666,7 @@ void RenderPath3D::Render() const
device->WaitCommandList(cmd, cmd_prepareframe);
wiJobSystem::Execute(ctx, [this, cmd](wiJobArgs args) {
- GraphicsDevice* device = wiRenderer::GetDevice();
+ GraphicsDevice* device = wiGraphics::GetDevice();
wiRenderer::BindCameraCB(
*camera,
@@ -708,7 +707,7 @@ void RenderPath3D::Render() const
CommandList cmd_maincamera_prepass = cmd;
wiJobSystem::Execute(ctx, [this, cmd](wiJobArgs args) {
- GraphicsDevice* device = wiRenderer::GetDevice();
+ GraphicsDevice* device = wiGraphics::GetDevice();
wiRenderer::BindCameraCB(
*camera,
@@ -725,8 +724,8 @@ void RenderPath3D::Render() const
auto range = wiProfiler::BeginRangeGPU("Z-Prepass", cmd);
Viewport vp;
- vp.Width = (float)depthBuffer_Main.GetDesc().Width;
- vp.Height = (float)depthBuffer_Main.GetDesc().Height;
+ vp.width = (float)depthBuffer_Main.GetDesc().width;
+ vp.height = (float)depthBuffer_Main.GetDesc().height;
device->BindViewports(1, &vp, cmd);
wiRenderer::DrawScene(visibility_main, RENDERPASS_PREPASS, cmd, drawscene_flags);
@@ -752,7 +751,7 @@ void RenderPath3D::Render() const
CommandList cmd_maincamera_compute_effects = cmd;
wiJobSystem::Execute(ctx, [this, cmd](wiJobArgs args) {
- GraphicsDevice* device = wiRenderer::GetDevice();
+ GraphicsDevice* device = wiGraphics::GetDevice();
wiRenderer::BindCameraCB(
*camera,
@@ -782,7 +781,7 @@ void RenderPath3D::Render() const
RenderAO(cmd);
- if (wiRenderer::GetVariableRateShadingClassification() && device->CheckCapability(GRAPHICSDEVICE_CAPABILITY_VARIABLE_RATE_SHADING_TIER2))
+ if (wiRenderer::GetVariableRateShadingClassification() && device->CheckCapability(GraphicsDeviceCapability::VARIABLE_RATE_SHADING_TIER2))
{
wiRenderer::ComputeShadingRateClassification(
rtShadingRate,
@@ -875,7 +874,7 @@ void RenderPath3D::Render() const
cmd = device->BeginCommandList();
wiJobSystem::Execute(ctx, [cmd, this](wiJobArgs args) {
- GraphicsDevice* device = wiRenderer::GetDevice();
+ GraphicsDevice* device = wiGraphics::GetDevice();
wiRenderer::BindCameraCB(
camera_reflection,
@@ -888,8 +887,8 @@ void RenderPath3D::Render() const
auto range = wiProfiler::BeginRangeGPU("Planar Reflections Z-Prepass", cmd);
Viewport vp;
- vp.Width = (float)depthBuffer_Reflection.GetDesc().Width;
- vp.Height = (float)depthBuffer_Reflection.GetDesc().Height;
+ vp.width = (float)depthBuffer_Reflection.GetDesc().width;
+ vp.height = (float)depthBuffer_Reflection.GetDesc().height;
device->BindViewports(1, &vp, cmd);
device->RenderPassBegin(&renderpass_reflection_depthprepass, cmd);
@@ -915,7 +914,7 @@ void RenderPath3D::Render() const
cmd = device->BeginCommandList();
wiJobSystem::Execute(ctx, [cmd, this](wiJobArgs args) {
- GraphicsDevice* device = wiRenderer::GetDevice();
+ GraphicsDevice* device = wiGraphics::GetDevice();
wiRenderer::BindCameraCB(
camera_reflection,
@@ -934,8 +933,8 @@ void RenderPath3D::Render() const
auto range = wiProfiler::BeginRangeGPU("Planar Reflections", cmd);
Viewport vp;
- vp.Width = (float)depthBuffer_Reflection.GetDesc().Width;
- vp.Height = (float)depthBuffer_Reflection.GetDesc().Height;
+ vp.width = (float)depthBuffer_Reflection.GetDesc().width;
+ vp.height = (float)depthBuffer_Reflection.GetDesc().height;
device->BindViewports(1, &vp, cmd);
@@ -966,7 +965,7 @@ void RenderPath3D::Render() const
device->WaitCommandList(cmd, cmd_maincamera_compute_effects);
wiJobSystem::Execute(ctx, [this, cmd](wiJobArgs args) {
- GraphicsDevice* device = wiRenderer::GetDevice();
+ GraphicsDevice* device = wiGraphics::GetDevice();
device->EventBegin("Opaque Scene", cmd);
wiRenderer::BindCameraCB(
@@ -991,8 +990,8 @@ void RenderPath3D::Render() const
// Depth buffers were created on COMPUTE queue, so make them available for pixel shaders here:
{
GPUBarrier barriers[] = {
- GPUBarrier::Image(&rtLinearDepth, rtLinearDepth.desc.layout, RESOURCE_STATE_SHADER_RESOURCE),
- GPUBarrier::Image(&depthBuffer_Copy, depthBuffer_Copy.desc.layout, RESOURCE_STATE_SHADER_RESOURCE),
+ GPUBarrier::Image(&rtLinearDepth, rtLinearDepth.desc.layout, ResourceState::SHADER_RESOURCE),
+ GPUBarrier::Image(&depthBuffer_Copy, depthBuffer_Copy.desc.layout, ResourceState::SHADER_RESOURCE),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
@@ -1000,13 +999,13 @@ void RenderPath3D::Render() const
auto range = wiProfiler::BeginRangeGPU("Opaque Scene", cmd);
Viewport vp;
- vp.Width = (float)depthBuffer_Main.GetDesc().Width;
- vp.Height = (float)depthBuffer_Main.GetDesc().Height;
+ vp.width = (float)depthBuffer_Main.GetDesc().width;
+ vp.height = (float)depthBuffer_Main.GetDesc().height;
device->BindViewports(1, &vp, cmd);
if (wiRenderer::GetRaytracedShadowsEnabled() || wiRenderer::GetScreenSpaceShadowsEnabled())
{
- GPUBarrier barrier = GPUBarrier::Image(&rtShadow, rtShadow.desc.layout, RESOURCE_STATE_SHADER_RESOURCE);
+ GPUBarrier barrier = GPUBarrier::Image(&rtShadow, rtShadow.desc.layout, ResourceState::SHADER_RESOURCE);
device->Barrier(&barrier, 1, cmd);
}
@@ -1037,7 +1036,7 @@ void RenderPath3D::Render() const
if (wiRenderer::GetRaytracedShadowsEnabled() || wiRenderer::GetScreenSpaceShadowsEnabled())
{
- GPUBarrier barrier = GPUBarrier::Image(&rtShadow, RESOURCE_STATE_SHADER_RESOURCE, rtShadow.desc.layout);
+ GPUBarrier barrier = GPUBarrier::Image(&rtShadow, ResourceState::SHADER_RESOURCE, rtShadow.desc.layout);
device->Barrier(&barrier, 1, cmd);
}
@@ -1048,7 +1047,7 @@ void RenderPath3D::Render() const
cmd = device->BeginCommandList();
wiJobSystem::Execute(ctx, [this, cmd](wiJobArgs args) {
- GraphicsDevice* device = wiRenderer::GetDevice();
+ GraphicsDevice* device = wiGraphics::GetDevice();
wiRenderer::BindCameraCB(
*camera,
@@ -1071,8 +1070,8 @@ void RenderPath3D::Render() const
// Depth buffers expect a non-pixel shader resource state as they are generated on compute queue:
{
GPUBarrier barriers[] = {
- GPUBarrier::Image(&rtLinearDepth, RESOURCE_STATE_SHADER_RESOURCE, rtLinearDepth.desc.layout),
- GPUBarrier::Image(&depthBuffer_Copy, RESOURCE_STATE_SHADER_RESOURCE, depthBuffer_Copy.desc.layout),
+ GPUBarrier::Image(&rtLinearDepth, ResourceState::SHADER_RESOURCE, rtLinearDepth.desc.layout),
+ GPUBarrier::Image(&depthBuffer_Copy, ResourceState::SHADER_RESOURCE, depthBuffer_Copy.desc.layout),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
@@ -1086,7 +1085,7 @@ void RenderPath3D::Render() const
void RenderPath3D::Compose(CommandList cmd) const
{
- GraphicsDevice* device = wiRenderer::GetDevice();
+ GraphicsDevice* device = wiGraphics::GetDevice();
wiImageParams fx;
fx.blendFlag = BLENDMODE_OPAQUE;
@@ -1186,7 +1185,7 @@ void RenderPath3D::RenderLightShafts(CommandList cmd) const
XMVECTOR sunDirection = XMLoadFloat3(&scene->weather.sunDirection);
if (getLightShaftsEnabled() && XMVectorGetX(XMVector3Dot(sunDirection, camera->GetAt())) > 0)
{
- GraphicsDevice* device = wiRenderer::GetDevice();
+ GraphicsDevice* device = wiGraphics::GetDevice();
device->EventBegin("Light Shafts", cmd);
@@ -1195,8 +1194,8 @@ void RenderPath3D::RenderLightShafts(CommandList cmd) const
device->RenderPassBegin(&renderpass_lightshafts, cmd);
Viewport vp;
- vp.Width = (float)depthBuffer_Main.GetDesc().Width;
- vp.Height = (float)depthBuffer_Main.GetDesc().Height;
+ vp.width = (float)depthBuffer_Main.GetDesc().width;
+ vp.height = (float)depthBuffer_Main.GetDesc().height;
device->BindViewports(1, &vp, cmd);
wiRenderer::DrawSun(cmd);
@@ -1234,13 +1233,13 @@ void RenderPath3D::RenderVolumetrics(CommandList cmd) const
{
auto range = wiProfiler::BeginRangeGPU("Volumetric Lights", cmd);
- GraphicsDevice* device = wiRenderer::GetDevice();
+ GraphicsDevice* device = wiGraphics::GetDevice();
device->RenderPassBegin(&renderpass_volumetriclight, cmd);
Viewport vp;
- vp.Width = (float)rtVolumetricLights[0].GetDesc().Width;
- vp.Height = (float)rtVolumetricLights[0].GetDesc().Height;
+ vp.width = (float)rtVolumetricLights[0].GetDesc().width;
+ vp.height = (float)rtVolumetricLights[0].GetDesc().height;
device->BindViewports(1, &vp, cmd);
wiRenderer::DrawVolumeLights(visibility_main, cmd);
@@ -1260,7 +1259,7 @@ void RenderPath3D::RenderVolumetrics(CommandList cmd) const
}
void RenderPath3D::RenderSceneMIPChain(CommandList cmd) const
{
- GraphicsDevice* device = wiRenderer::GetDevice();
+ GraphicsDevice* device = wiGraphics::GetDevice();
auto range = wiProfiler::BeginRangeGPU("Scene MIP Chain", cmd);
device->EventBegin("RenderSceneMIPChain", cmd);
@@ -1268,8 +1267,8 @@ void RenderPath3D::RenderSceneMIPChain(CommandList cmd) const
device->RenderPassBegin(&renderpass_downsamplescene, cmd);
Viewport vp;
- vp.Width = (float)rtSceneCopy.GetDesc().Width;
- vp.Height = (float)rtSceneCopy.GetDesc().Height;
+ vp.width = (float)rtSceneCopy.GetDesc().width;
+ vp.height = (float)rtSceneCopy.GetDesc().height;
device->BindViewports(1, &vp, cmd);
wiImageParams fx;
@@ -1290,7 +1289,7 @@ void RenderPath3D::RenderSceneMIPChain(CommandList cmd) const
}
void RenderPath3D::RenderTransparents(CommandList cmd) const
{
- GraphicsDevice* device = wiRenderer::GetDevice();
+ GraphicsDevice* device = wiGraphics::GetDevice();
// Water ripple rendering:
if(!scene->waterRipples.empty())
@@ -1298,8 +1297,8 @@ void RenderPath3D::RenderTransparents(CommandList cmd) const
device->RenderPassBegin(&renderpass_waterripples, cmd);
Viewport vp;
- vp.Width = (float)rtWaterRipple.GetDesc().Width;
- vp.Height = (float)rtWaterRipple.GetDesc().Height;
+ vp.width = (float)rtWaterRipple.GetDesc().width;
+ vp.height = (float)rtWaterRipple.GetDesc().height;
device->BindViewports(1, &vp, cmd);
wiRenderer::DrawWaterRipples(visibility_main, cmd);
@@ -1311,8 +1310,8 @@ void RenderPath3D::RenderTransparents(CommandList cmd) const
device->RenderPassBegin(&renderpass_transparent, cmd);
Viewport vp;
- vp.Width = (float)depthBuffer_Main.GetDesc().Width;
- vp.Height = (float)depthBuffer_Main.GetDesc().Height;
+ vp.width = (float)depthBuffer_Main.GetDesc().width;
+ vp.height = (float)depthBuffer_Main.GetDesc().height;
device->BindViewports(1, &vp, cmd);
// Transparent scene
@@ -1372,8 +1371,8 @@ void RenderPath3D::RenderTransparents(CommandList cmd) const
device->RenderPassBegin(&renderpass_particledistortion, cmd);
Viewport vp;
- vp.Width = (float)rtParticleDistortion.GetDesc().Width;
- vp.Height = (float)rtParticleDistortion.GetDesc().Height;
+ vp.width = (float)rtParticleDistortion.GetDesc().width;
+ vp.height = (float)rtParticleDistortion.GetDesc().height;
device->BindViewports(1, &vp, cmd);
wiRenderer::DrawSoftParticles(visibility_main, rtLinearDepth, true, cmd);
@@ -1383,7 +1382,7 @@ void RenderPath3D::RenderTransparents(CommandList cmd) const
}
void RenderPath3D::RenderPostprocessChain(CommandList cmd) const
{
- GraphicsDevice* device = wiRenderer::GetDevice();
+ GraphicsDevice* device = wiGraphics::GetDevice();
const Texture* rt_first = nullptr; // not ping-ponged with read / write
const Texture* rt_read = &rtMain;
@@ -1393,7 +1392,7 @@ void RenderPath3D::RenderPostprocessChain(CommandList cmd) const
{
if (wiRenderer::GetTemporalAAEnabled() && !wiRenderer::GetTemporalAADebugEnabled())
{
- GraphicsDevice* device = wiRenderer::GetDevice();
+ GraphicsDevice* device = wiGraphics::GetDevice();
int output = device->GetFrameCount() % 2;
int history = 1 - output;
@@ -1539,33 +1538,33 @@ void RenderPath3D::setAO(AO value)
XMUINT2 internalResolution = GetInternalResolution();
TextureDesc desc;
- desc.BindFlags = BIND_SHADER_RESOURCE | BIND_UNORDERED_ACCESS;
- desc.Format = FORMAT_R8_UNORM;
- desc.layout = RESOURCE_STATE_SHADER_RESOURCE_COMPUTE;
+ desc.bind_flags = BindFlag::SHADER_RESOURCE | BindFlag::UNORDERED_ACCESS;
+ desc.format = Format::R8_UNORM;
+ desc.layout = ResourceState::SHADER_RESOURCE_COMPUTE;
switch (ao)
{
case RenderPath3D::AO_SSAO:
case RenderPath3D::AO_HBAO:
- desc.Width = internalResolution.x / 2;
- desc.Height = internalResolution.y / 2;
+ desc.width = internalResolution.x / 2;
+ desc.height = internalResolution.y / 2;
wiRenderer::CreateSSAOResources(ssaoResources, internalResolution);
break;
case RenderPath3D::AO_MSAO:
- desc.Width = internalResolution.x;
- desc.Height = internalResolution.y;
+ desc.width = internalResolution.x;
+ desc.height = internalResolution.y;
wiRenderer::CreateMSAOResources(msaoResources, internalResolution);
break;
case RenderPath3D::AO_RTAO:
- desc.Width = internalResolution.x / 2;
- desc.Height = internalResolution.y / 2;
+ desc.width = internalResolution.x / 2;
+ desc.height = internalResolution.y / 2;
wiRenderer::CreateRTAOResources(rtaoResources, internalResolution);
break;
default:
break;
}
- GraphicsDevice* device = wiRenderer::GetDevice();
+ GraphicsDevice* device = wiGraphics::GetDevice();
device->CreateTexture(&desc, nullptr, &rtAO);
device->SetName(&rtAO, "rtAO");
}
@@ -1576,14 +1575,14 @@ void RenderPath3D::setSSREnabled(bool value)
if (value)
{
- GraphicsDevice* device = wiRenderer::GetDevice();
+ GraphicsDevice* device = wiGraphics::GetDevice();
XMUINT2 internalResolution = GetInternalResolution();
TextureDesc desc;
- desc.BindFlags = BIND_SHADER_RESOURCE | BIND_UNORDERED_ACCESS;
- desc.Format = FORMAT_R16G16B16A16_FLOAT;
- desc.Width = internalResolution.x / 2;
- desc.Height = internalResolution.y / 2;
+ desc.bind_flags = BindFlag::SHADER_RESOURCE | BindFlag::UNORDERED_ACCESS;
+ desc.format = Format::R16G16B16A16_FLOAT;
+ desc.width = internalResolution.x / 2;
+ desc.height = internalResolution.y / 2;
device->CreateTexture(&desc, nullptr, &rtSSR);
device->SetName(&rtSSR, "rtSSR");
@@ -1601,14 +1600,14 @@ void RenderPath3D::setRaytracedReflectionsEnabled(bool value)
if (value)
{
- GraphicsDevice* device = wiRenderer::GetDevice();
+ GraphicsDevice* device = wiGraphics::GetDevice();
XMUINT2 internalResolution = GetInternalResolution();
TextureDesc desc;
- desc.BindFlags = BIND_SHADER_RESOURCE | BIND_UNORDERED_ACCESS;
- desc.Format = FORMAT_R11G11B10_FLOAT;
- desc.Width = internalResolution.x / 2;
- desc.Height = internalResolution.y / 2;
+ desc.bind_flags = BindFlag::SHADER_RESOURCE | BindFlag::UNORDERED_ACCESS;
+ desc.format = Format::R11G11B10_FLOAT;
+ desc.width = internalResolution.x / 2;
+ desc.height = internalResolution.y / 2;
device->CreateTexture(&desc, nullptr, &rtSSR);
device->SetName(&rtSSR, "rtSSR");
@@ -1626,13 +1625,13 @@ void RenderPath3D::setFSREnabled(bool value)
if (resolutionScale < 1.0f && fsrEnabled)
{
- GraphicsDevice* device = wiRenderer::GetDevice();
+ GraphicsDevice* device = wiGraphics::GetDevice();
TextureDesc desc;
- desc.BindFlags = BIND_SHADER_RESOURCE | BIND_UNORDERED_ACCESS;
- desc.Format = rtPostprocess.desc.Format;
- desc.Width = GetPhysicalWidth();
- desc.Height = GetPhysicalHeight();
+ desc.bind_flags = BindFlag::SHADER_RESOURCE | BindFlag::UNORDERED_ACCESS;
+ desc.format = rtPostprocess.desc.format;
+ desc.width = GetPhysicalWidth();
+ desc.height = GetPhysicalHeight();
device->CreateTexture(&desc, nullptr, &rtFSR[0]);
device->SetName(&rtFSR[0], "rtFSR[0]");
device->CreateTexture(&desc, nullptr, &rtFSR[1]);
diff --git a/WickedEngine/RenderPath3D_PathTracing.cpp b/WickedEngine/RenderPath3D_PathTracing.cpp
index 5b637d15b..c5bc32d43 100644
--- a/WickedEngine/RenderPath3D_PathTracing.cpp
+++ b/WickedEngine/RenderPath3D_PathTracing.cpp
@@ -40,22 +40,22 @@ void RenderPath3D_PathTracing::ResizeBuffers()
{
RenderPath2D::ResizeBuffers(); // we don't need to use any buffers from RenderPath3D, so skip those
- GraphicsDevice* device = wiRenderer::GetDevice();
+ GraphicsDevice* device = wiGraphics::GetDevice();
XMUINT2 internalResolution = GetInternalResolution();
{
TextureDesc desc;
- desc.BindFlags = BIND_UNORDERED_ACCESS | BIND_SHADER_RESOURCE | BIND_RENDER_TARGET;
- desc.Format = FORMAT_R32G32B32A32_FLOAT;
- desc.Width = internalResolution.x;
- desc.Height = internalResolution.y;
+ desc.bind_flags = BindFlag::UNORDERED_ACCESS | BindFlag::SHADER_RESOURCE | BindFlag::RENDER_TARGET;
+ desc.format = Format::R32G32B32A32_FLOAT;
+ desc.width = internalResolution.x;
+ desc.height = internalResolution.y;
device->CreateTexture(&desc, nullptr, &traceResult);
device->SetName(&traceResult, "traceResult");
#ifdef OPEN_IMAGE_DENOISE
- desc.BindFlags = BIND_UNORDERED_ACCESS;
- desc.layout = RESOURCE_STATE_UNORDERED_ACCESS;
+ desc.bind_flags = BindFlag::UNORDERED_ACCESS;
+ desc.layout = ResourceState::UNORDERED_ACCESS;
device->CreateTexture(&desc, nullptr, &denoiserAlbedo);
device->SetName(&denoiserAlbedo, "denoiserAlbedo");
device->CreateTexture(&desc, nullptr, &denoiserNormal);
@@ -64,22 +64,22 @@ void RenderPath3D_PathTracing::ResizeBuffers()
}
{
TextureDesc desc;
- desc.BindFlags = BIND_SHADER_RESOURCE | BIND_UNORDERED_ACCESS;
- desc.Format = FORMAT_R11G11B10_FLOAT;
- desc.Width = internalResolution.x;
- desc.Height = internalResolution.y;
+ desc.bind_flags = BindFlag::SHADER_RESOURCE | BindFlag::UNORDERED_ACCESS;
+ desc.format = Format::R11G11B10_FLOAT;
+ desc.width = internalResolution.x;
+ desc.height = internalResolution.y;
device->CreateTexture(&desc, nullptr, &rtPostprocess);
device->SetName(&rtPostprocess, "rtPostprocess");
- desc.Width /= 4;
- desc.Height /= 4;
- desc.BindFlags = BIND_UNORDERED_ACCESS | BIND_SHADER_RESOURCE;
+ desc.width /= 4;
+ desc.height /= 4;
+ desc.bind_flags = BindFlag::UNORDERED_ACCESS | BindFlag::SHADER_RESOURCE;
device->CreateTexture(&desc, nullptr, &rtGUIBlurredBackground[0]);
device->SetName(&rtGUIBlurredBackground[0], "rtGUIBlurredBackground[0]");
- desc.Width /= 4;
- desc.Height /= 4;
+ desc.width /= 4;
+ desc.height /= 4;
device->CreateTexture(&desc, nullptr, &rtGUIBlurredBackground[1]);
device->SetName(&rtGUIBlurredBackground[1], "rtGUIBlurredBackground[1]");
device->CreateTexture(&desc, nullptr, &rtGUIBlurredBackground[2]);
@@ -88,7 +88,7 @@ void RenderPath3D_PathTracing::ResizeBuffers()
{
RenderPassDesc desc;
- desc.attachments.push_back(RenderPassAttachment::RenderTarget(&traceResult, RenderPassAttachment::LOADOP_CLEAR));
+ desc.attachments.push_back(RenderPassAttachment::RenderTarget(&traceResult, RenderPassAttachment::LoadOp::CLEAR));
device->CreateRenderPass(&desc, &renderpass_debugbvh);
}
@@ -175,8 +175,8 @@ void RenderPath3D_PathTracing::Update(float dt)
wiJobSystem::Execute(denoiserContext, [&](wiJobArgs args) {
- size_t width = (size_t)traceResult.desc.Width;
- size_t height = (size_t)traceResult.desc.Height;
+ size_t width = (size_t)traceResult.desc.width;
+ size_t height = (size_t)traceResult.desc.height;
{
// https://github.com/OpenImageDenoise/oidn#c11-api-example
@@ -220,17 +220,17 @@ void RenderPath3D_PathTracing::Update(float dt)
}
}
- GraphicsDevice* device = wiRenderer::GetDevice();
+ GraphicsDevice* device = wiGraphics::GetDevice();
TextureDesc desc;
- desc.Width = (uint32_t)width;
- desc.Height = (uint32_t)height;
- desc.BindFlags = BIND_SHADER_RESOURCE;
- desc.Format = FORMAT_R32G32B32A32_FLOAT;
+ desc.width = (uint32_t)width;
+ desc.height = (uint32_t)height;
+ desc.bind_flags = BindFlag::SHADER_RESOURCE;
+ desc.format = Format::R32G32B32A32_FLOAT;
SubresourceData initdata;
- initdata.pData = texturedata_dst.data();
- initdata.rowPitch = uint32_t(sizeof(XMFLOAT4) * width);
+ initdata.data_ptr = texturedata_dst.data();
+ initdata.row_pitch = uint32_t(sizeof(XMFLOAT4) * width);
device->CreateTexture(&desc, &initdata, &denoiserResult);
});
@@ -247,14 +247,13 @@ void RenderPath3D_PathTracing::Update(float dt)
void RenderPath3D_PathTracing::Render() const
{
- GraphicsDevice* device = wiRenderer::GetDevice();
+ GraphicsDevice* device = wiGraphics::GetDevice();
wiJobSystem::context ctx;
- CommandList cmd;
if (sam < target)
{
// Setup:
- cmd = device->BeginCommandList();
+ CommandList cmd = device->BeginCommandList();
wiJobSystem::Execute(ctx, [this, cmd](wiJobArgs args) {
wiRenderer::BindCameraCB(
@@ -276,7 +275,7 @@ void RenderPath3D_PathTracing::Render() const
cmd = device->BeginCommandList();
wiJobSystem::Execute(ctx, [this, cmd](wiJobArgs args) {
- GraphicsDevice* device = wiRenderer::GetDevice();
+ GraphicsDevice* device = wiGraphics::GetDevice();
wiRenderer::BindCameraCB(
*camera,
@@ -291,8 +290,8 @@ void RenderPath3D_PathTracing::Render() const
device->RenderPassBegin(&renderpass_debugbvh, cmd);
Viewport vp;
- vp.Width = (float)traceResult.GetDesc().Width;
- vp.Height = (float)traceResult.GetDesc().Height;
+ vp.width = (float)traceResult.GetDesc().width;
+ vp.height = (float)traceResult.GetDesc().height;
device->BindViewports(1, &vp, cmd);
wiRenderer::RayTraceSceneBVH(*scene, cmd);
@@ -320,10 +319,10 @@ void RenderPath3D_PathTracing::Render() const
}
// Tonemap etc:
- cmd = device->BeginCommandList();
+ CommandList cmd = device->BeginCommandList();
wiJobSystem::Execute(ctx, [this, cmd](wiJobArgs args) {
- GraphicsDevice* device = wiRenderer::GetDevice();
+ GraphicsDevice* device = wiGraphics::GetDevice();
wiRenderer::BindCameraCB(
*camera,
@@ -390,7 +389,7 @@ void RenderPath3D_PathTracing::Render() const
void RenderPath3D_PathTracing::Compose(CommandList cmd) const
{
- GraphicsDevice* device = wiRenderer::GetDevice();
+ GraphicsDevice* device = wiGraphics::GetDevice();
device->EventBegin("RenderPath3D_PathTracing::Compose", cmd);
diff --git a/WickedEngine/Texture_BindLua.h b/WickedEngine/Texture_BindLua.h
index 23c6d69af..e5060a6ac 100644
--- a/WickedEngine/Texture_BindLua.h
+++ b/WickedEngine/Texture_BindLua.h
@@ -1,7 +1,7 @@
#pragma once
#include "wiLua.h"
#include "wiLuna.h"
-#include "wiRenderer.h"
+#include "wiGraphics.h"
class Texture_BindLua
{
diff --git a/WickedEngine/Utility/replace_new.h b/WickedEngine/Utility/replace_new.h
deleted file mode 100644
index 609ddf740..000000000
--- a/WickedEngine/Utility/replace_new.h
+++ /dev/null
@@ -1,31 +0,0 @@
-#pragma once
-#include
-#include
-#include
-
-std::atomic number_of_allocs{ 0 };
-
-void* operator new(std::size_t size) {
- number_of_allocs.fetch_add(1);
- void* p = malloc(size);
- if (!p) throw std::bad_alloc();
- return p;
-}
-void* operator new[](std::size_t size) {
- number_of_allocs.fetch_add(1);
- void* p = malloc(size);
- if (!p) throw std::bad_alloc();
- return p;
-}
-void* operator new[](std::size_t size, const std::nothrow_t&) throw() {
- number_of_allocs.fetch_add(1);
- return malloc(size);
-}
-void* operator new(std::size_t size, const std::nothrow_t&) throw() {
- number_of_allocs.fetch_add(1);
- return malloc(size);
-}
-void operator delete(void* ptr) throw() { free(ptr); }
-void operator delete (void* ptr, const std::nothrow_t&) throw() { free(ptr); }
-void operator delete[](void* ptr) throw() { free(ptr); }
-void operator delete[](void* ptr, const std::nothrow_t&) throw() { free(ptr); }
diff --git a/WickedEngine/WickedEngine_SOURCE.vcxitems b/WickedEngine/WickedEngine_SOURCE.vcxitems
index 2680ef2ed..faf209c8e 100644
--- a/WickedEngine/WickedEngine_SOURCE.vcxitems
+++ b/WickedEngine/WickedEngine_SOURCE.vcxitems
@@ -241,7 +241,6 @@
-
diff --git a/WickedEngine/WickedEngine_SOURCE.vcxitems.filters b/WickedEngine/WickedEngine_SOURCE.vcxitems.filters
index 62705ac20..483f97675 100644
--- a/WickedEngine/WickedEngine_SOURCE.vcxitems.filters
+++ b/WickedEngine/WickedEngine_SOURCE.vcxitems.filters
@@ -1020,9 +1020,6 @@
ENGINE\Graphics\API
-
- UTILITY
-
ENGINE\Graphics
diff --git a/WickedEngine/offlineshadercompiler.cpp b/WickedEngine/offlineshadercompiler.cpp
index 5ec429f2f..c9b796d5d 100644
--- a/WickedEngine/offlineshadercompiler.cpp
+++ b/WickedEngine/offlineshadercompiler.cpp
@@ -8,11 +8,11 @@
#include
std::mutex locker;
-std::vector shaders[wiGraphics::SHADERSTAGE_COUNT];
-std::unordered_map minshadermodels;
+std::vector shaders[static_cast(wiGraphics::ShaderStage::Count)];
+std::unordered_map minshadermodels;
struct Target
{
- wiGraphics::SHADERFORMAT format;
+ wiGraphics::ShaderFormat format;
std::string dir;
};
std::vector targets;
@@ -20,6 +20,8 @@ std::unordered_map results;
bool rebuild = false;
bool shaderdump_enabled = false;
+using namespace wiGraphics;
+
int main(int argc, char* argv[])
{
std::cout << "[Wicked Engine Offline Shader Compiler]" << std::endl;
@@ -35,17 +37,17 @@ int main(int argc, char* argv[])
if (wiStartupArguments::HasArgument("hlsl5"))
{
- targets.push_back({ wiGraphics::SHADERFORMAT_HLSL5, "shaders/hlsl5/" });
+ targets.push_back({ ShaderFormat::HLSL5, "shaders/hlsl5/" });
std::cout << "hlsl5 ";
}
if (wiStartupArguments::HasArgument("hlsl6"))
{
- targets.push_back({ wiGraphics::SHADERFORMAT_HLSL6, "shaders/hlsl6/" });
+ targets.push_back({ ShaderFormat::HLSL6, "shaders/hlsl6/" });
std::cout << "hlsl6 ";
}
if (wiStartupArguments::HasArgument("spirv"))
{
- targets.push_back({ wiGraphics::SHADERFORMAT_SPIRV, "shaders/spirv/" });
+ targets.push_back({ ShaderFormat::SPIRV, "shaders/spirv/" });
std::cout << "spirv ";
}
@@ -67,14 +69,14 @@ int main(int argc, char* argv[])
if (targets.empty())
{
targets = {
- //{ wiGraphics::SHADERFORMAT_HLSL5, "shaders/hlsl5/" },
- { wiGraphics::SHADERFORMAT_HLSL6, "shaders/hlsl6/" },
- { wiGraphics::SHADERFORMAT_SPIRV, "shaders/spirv/" },
+ //{ ShaderFormat::HLSL5, "shaders/hlsl5/" },
+ { ShaderFormat::HLSL6, "shaders/hlsl6/" },
+ { ShaderFormat::SPIRV, "shaders/spirv/" },
};
std::cout << "No shader formats were specified, assuming command arguments: hlsl5 spirv hlsl6" << std::endl;
}
- shaders[wiGraphics::CS] = {
+ shaders[static_cast(ShaderStage::CS)] = {
"hairparticle_simulateCS.hlsl" ,
"hairparticle_finishUpdateCS.hlsl" ,
"emittedparticle_simulateCS.hlsl" ,
@@ -233,7 +235,7 @@ int main(int argc, char* argv[])
"surfel_raytraceCS.hlsl",
};
- shaders[wiGraphics::PS] = {
+ shaders[static_cast(ShaderStage::PS)] = {
"emittedparticlePS_soft.hlsl" ,
"screenPS.hlsl" ,
"imagePS.hlsl" ,
@@ -309,7 +311,7 @@ int main(int argc, char* argv[])
"captureImpostorPS_albedo.hlsl" ,
};
- shaders[wiGraphics::VS] = {
+ shaders[static_cast(ShaderStage::VS)] = {
"hairparticleVS.hlsl" ,
"emittedparticleVS.hlsl" ,
"imageVS.hlsl" ,
@@ -357,7 +359,7 @@ int main(int argc, char* argv[])
"cubeVS.hlsl",
};
- shaders[wiGraphics::GS] = {
+ shaders[static_cast(ShaderStage::GS)] = {
"envMap_skyGS_emulation.hlsl" ,
"envMapGS_emulation.hlsl" ,
"cubeShadowGS_emulation.hlsl" ,
@@ -367,37 +369,37 @@ int main(int argc, char* argv[])
"objectGS_voxelizer.hlsl" ,
};
- shaders[wiGraphics::DS] = {
+ shaders[static_cast(ShaderStage::DS)] = {
"objectDS.hlsl",
"objectDS_prepass.hlsl",
"objectDS_prepass_alphatest.hlsl",
"objectDS_simple.hlsl",
};
- shaders[wiGraphics::HS] = {
+ shaders[static_cast(ShaderStage::HS)] = {
"objectHS.hlsl",
"objectHS_prepass.hlsl",
"objectHS_prepass_alphatest.hlsl",
"objectHS_simple.hlsl",
};
- shaders[wiGraphics::AS] = {
+ shaders[static_cast(ShaderStage::AS)] = {
};
- shaders[wiGraphics::MS] = {
+ shaders[static_cast(ShaderStage::MS)] = {
"emittedparticleMS.hlsl",
};
- shaders[wiGraphics::LIB] = {
+ shaders[static_cast(ShaderStage::LIB)] = {
"rtreflectionLIB.hlsl",
};
- minshadermodels["renderlightmapPS_rtapi.hlsl"] = wiGraphics::SHADERMODEL_6_5;
- minshadermodels["raytraceCS_rtapi.hlsl"] = wiGraphics::SHADERMODEL_6_5;
- minshadermodels["rtshadowCS.hlsl"] = wiGraphics::SHADERMODEL_6_5;
- minshadermodels["rtaoCS.hlsl"] = wiGraphics::SHADERMODEL_6_5;
- minshadermodels["surfel_raytraceCS_rtapi.hlsl"] = wiGraphics::SHADERMODEL_6_5;
+ minshadermodels["renderlightmapPS_rtapi.hlsl"] = ShaderModel::SM_6_5;
+ minshadermodels["raytraceCS_rtapi.hlsl"] = ShaderModel::SM_6_5;
+ minshadermodels["rtshadowCS.hlsl"] = ShaderModel::SM_6_5;
+ minshadermodels["rtaoCS.hlsl"] = ShaderModel::SM_6_5;
+ minshadermodels["surfel_raytraceCS_rtapi.hlsl"] = ShaderModel::SM_6_5;
wiShaderCompiler::Initialize();
wiJobSystem::Initialize();
@@ -414,14 +416,14 @@ int main(int argc, char* argv[])
std::string SHADERPATH = target.dir;
wiHelper::DirectoryCreate(SHADERPATH);
- for (int i = 0; i < wiGraphics::SHADERSTAGE_COUNT; ++i)
+ for (int i = 0; i < static_cast(ShaderStage::Count); ++i)
{
- if (target.format == wiGraphics::SHADERFORMAT_HLSL5)
+ if (target.format == ShaderFormat::HLSL5)
{
if (
- i == wiGraphics::MS ||
- i == wiGraphics::AS ||
- i == wiGraphics::LIB
+ i == static_cast(ShaderStage::MS) ||
+ i == static_cast(ShaderStage::AS) ||
+ i == static_cast(ShaderStage::LIB)
)
{
// shader stage not applicable to HLSL5
@@ -440,7 +442,7 @@ int main(int argc, char* argv[])
wiShaderCompiler::CompilerInput input;
input.format = target.format;
- input.stage = (wiGraphics::SHADERSTAGE)i;
+ input.stage = (wiGraphics::ShaderStage)i;
input.shadersourcefilename = SHADERSOURCEPATH + shader;
input.include_directories.push_back(SHADERSOURCEPATH);
@@ -450,7 +452,7 @@ int main(int argc, char* argv[])
// increase min shader model only for specific shaders
input.minshadermodel = it->second;
}
- if (input.minshadermodel > wiGraphics::SHADERMODEL_5_0 && target.format == wiGraphics::SHADERFORMAT_HLSL5)
+ if (input.minshadermodel > ShaderModel::SM_5_0 && target.format == ShaderFormat::HLSL5)
{
// if shader format cannot support shader model, then we cancel the task without returning error
return;
diff --git a/WickedEngine/wiBackLog.cpp b/WickedEngine/wiBackLog.cpp
index 1242d739f..8d9383d00 100644
--- a/WickedEngine/wiBackLog.cpp
+++ b/WickedEngine/wiBackLog.cpp
@@ -1,7 +1,6 @@
#include "wiBackLog.h"
#include "wiMath.h"
#include "wiResourceManager.h"
-#include "wiRenderer.h"
#include "wiTextureHelper.h"
#include "wiSpinLock.h"
#include "wiFont.h"
@@ -124,13 +123,13 @@ namespace wiBackLog
rect.right = (int32_t)canvas.GetPhysicalWidth();
rect.top = 0;
rect.bottom = int32_t(canvas.GetPhysicalHeight() * 0.9f);
- wiRenderer::GetDevice()->BindScissorRects(1, &rect, cmd);
+ wiGraphics::GetDevice()->BindScissorRects(1, &rect, cmd);
font.Draw(cmd);
rect.left = -INT_MAX;
rect.right = INT_MAX;
rect.top = -INT_MAX;
rect.bottom = INT_MAX;
- wiRenderer::GetDevice()->BindScissorRects(1, &rect, cmd);
+ wiGraphics::GetDevice()->BindScissorRects(1, &rect, cmd);
}
}
diff --git a/WickedEngine/wiEmittedParticle.cpp b/WickedEngine/wiEmittedParticle.cpp
index 473176e42..0ebd073eb 100644
--- a/WickedEngine/wiEmittedParticle.cpp
+++ b/WickedEngine/wiEmittedParticle.cpp
@@ -57,24 +57,24 @@ void wiEmittedParticle::SetMaxParticleCount(uint32_t value)
void wiEmittedParticle::CreateSelfBuffers()
{
- GraphicsDevice* device = wiRenderer::GetDevice();
+ GraphicsDevice* device = wiGraphics::GetDevice();
- if (particleBuffer.desc.Size < MAX_PARTICLES * sizeof(Particle))
+ if (particleBuffer.desc.size < MAX_PARTICLES * sizeof(Particle))
{
GPUBufferDesc bd;
- bd.Usage = USAGE_DEFAULT;
- bd.BindFlags = BIND_SHADER_RESOURCE | BIND_UNORDERED_ACCESS;
- bd.MiscFlags = RESOURCE_MISC_BUFFER_STRUCTURED;
+ bd.usage = Usage::DEFAULT;
+ bd.bind_flags = BindFlag::SHADER_RESOURCE | BindFlag::UNORDERED_ACCESS;
+ bd.misc_flags = ResourceMiscFlag::BUFFER_STRUCTURED;
// Particle buffer:
- bd.Stride = sizeof(Particle);
- bd.Size = bd.Stride * MAX_PARTICLES;
+ bd.stride = sizeof(Particle);
+ bd.size = bd.stride * MAX_PARTICLES;
device->CreateBuffer(&bd, nullptr, &particleBuffer);
device->SetName(&particleBuffer, "particleBuffer");
// Alive index lists (double buffered):
- bd.Stride = sizeof(uint32_t);
- bd.Size = bd.Stride * MAX_PARTICLES;
+ bd.stride = sizeof(uint32_t);
+ bd.size = bd.stride * MAX_PARTICLES;
device->CreateBuffer(&bd, nullptr, &aliveList[0]);
device->SetName(&aliveList[0], "aliveList[0]");
device->CreateBuffer(&bd, nullptr, &aliveList[1]);
@@ -94,45 +94,45 @@ void wiEmittedParticle::CreateSelfBuffers()
device->SetName(&deadList, "deadList");
- bd.MiscFlags = RESOURCE_MISC_BUFFER_RAW;
- if (device->CheckCapability(GRAPHICSDEVICE_CAPABILITY_RAYTRACING))
+ bd.misc_flags = ResourceMiscFlag::BUFFER_RAW;
+ if (device->CheckCapability(GraphicsDeviceCapability::RAYTRACING))
{
- bd.MiscFlags |= RESOURCE_MISC_RAY_TRACING;
+ bd.misc_flags |= ResourceMiscFlag::RAY_TRACING;
}
- bd.Stride = sizeof(MeshComponent::Vertex_POS);
- bd.Size = bd.Stride * 4 * MAX_PARTICLES;
+ bd.stride = sizeof(MeshComponent::Vertex_POS);
+ bd.size = bd.stride * 4 * MAX_PARTICLES;
std::vector positionData(4 * MAX_PARTICLES);
std::fill(positionData.begin(), positionData.end(), MeshComponent::Vertex_POS());
device->CreateBuffer(&bd, positionData.data(), &vertexBuffer_POS);
device->SetName(&vertexBuffer_POS, "vertexBuffer_POS");
- bd.MiscFlags = RESOURCE_MISC_BUFFER_RAW;
- bd.Stride = sizeof(MeshComponent::Vertex_TEX);
- bd.Size = bd.Stride * 4 * MAX_PARTICLES;
+ bd.misc_flags = ResourceMiscFlag::BUFFER_RAW;
+ bd.stride = sizeof(MeshComponent::Vertex_TEX);
+ bd.size = bd.stride * 4 * MAX_PARTICLES;
device->CreateBuffer(&bd, nullptr, &vertexBuffer_TEX);
device->SetName(&vertexBuffer_TEX, "vertexBuffer_TEX");
- bd.MiscFlags = RESOURCE_MISC_BUFFER_RAW;
- bd.Stride = sizeof(MeshComponent::Vertex_TEX);
- bd.Size = bd.Stride * 4 * MAX_PARTICLES;
+ bd.misc_flags = ResourceMiscFlag::BUFFER_RAW;
+ bd.stride = sizeof(MeshComponent::Vertex_TEX);
+ bd.size = bd.stride * 4 * MAX_PARTICLES;
device->CreateBuffer(&bd, nullptr, &vertexBuffer_TEX2);
device->SetName(&vertexBuffer_TEX2, "vertexBuffer_TEX2");
- bd.MiscFlags = RESOURCE_MISC_BUFFER_RAW;
- bd.Stride = sizeof(MeshComponent::Vertex_COL);
- bd.Size = bd.Stride * 4 * MAX_PARTICLES;
+ bd.misc_flags = ResourceMiscFlag::BUFFER_RAW;
+ bd.stride = sizeof(MeshComponent::Vertex_COL);
+ bd.size = bd.stride * 4 * MAX_PARTICLES;
device->CreateBuffer(&bd, nullptr, &vertexBuffer_COL);
device->SetName(&vertexBuffer_COL, "vertexBuffer_COL");
- bd.BindFlags = BIND_SHADER_RESOURCE;
- bd.MiscFlags = RESOURCE_MISC_NONE;
- if (device->CheckCapability(GRAPHICSDEVICE_CAPABILITY_RAYTRACING))
+ bd.bind_flags = BindFlag::SHADER_RESOURCE;
+ bd.misc_flags = ResourceMiscFlag::NONE;
+ if (device->CheckCapability(GraphicsDeviceCapability::RAYTRACING))
{
- bd.MiscFlags |= RESOURCE_MISC_RAY_TRACING;
+ bd.misc_flags |= ResourceMiscFlag::RAY_TRACING;
}
- bd.Format = FORMAT_R32_UINT;
- bd.Stride = sizeof(uint);
- bd.Size = bd.Stride * 6 * MAX_PARTICLES;
+ bd.format = Format::R32_UINT;
+ bd.stride = sizeof(uint);
+ bd.size = bd.stride * 6 * MAX_PARTICLES;
std::vector primitiveData(6 * MAX_PARTICLES);
for (uint particleID = 0; particleID < MAX_PARTICLES; ++particleID)
{
@@ -149,15 +149,15 @@ void wiEmittedParticle::CreateSelfBuffers()
device->SetName(&primitiveBuffer, "primitiveBuffer");
}
- if (IsSorted() && distanceBuffer.desc.Size < MAX_PARTICLES * sizeof(float))
+ if (IsSorted() && distanceBuffer.desc.size < MAX_PARTICLES * sizeof(float))
{
// Distance buffer:
GPUBufferDesc bd;
- bd.Usage = USAGE_DEFAULT;
- bd.BindFlags = BIND_SHADER_RESOURCE | BIND_UNORDERED_ACCESS;
- bd.MiscFlags = RESOURCE_MISC_BUFFER_STRUCTURED;
- bd.Stride = sizeof(float);
- bd.Size = bd.Stride * MAX_PARTICLES;
+ bd.usage = Usage::DEFAULT;
+ bd.bind_flags = BindFlag::SHADER_RESOURCE | BindFlag::UNORDERED_ACCESS;
+ bd.misc_flags = ResourceMiscFlag::BUFFER_STRUCTURED;
+ bd.stride = sizeof(float);
+ bd.size = bd.stride * MAX_PARTICLES;
std::vector distances(MAX_PARTICLES);
std::fill(distances.begin(), distances.end(), 0.0f);
device->CreateBuffer(&bd, distances.data(), &distanceBuffer);
@@ -167,30 +167,30 @@ void wiEmittedParticle::CreateSelfBuffers()
if (IsSPHEnabled())
{
GPUBufferDesc bd;
- bd.Usage = USAGE_DEFAULT;
- bd.BindFlags = BIND_SHADER_RESOURCE | BIND_UNORDERED_ACCESS;
- bd.MiscFlags = RESOURCE_MISC_BUFFER_STRUCTURED;
+ bd.usage = Usage::DEFAULT;
+ bd.bind_flags = BindFlag::SHADER_RESOURCE | BindFlag::UNORDERED_ACCESS;
+ bd.misc_flags = ResourceMiscFlag::BUFFER_STRUCTURED;
- if (sphPartitionCellIndices.desc.Size < MAX_PARTICLES * sizeof(float))
+ if (sphPartitionCellIndices.desc.size < MAX_PARTICLES * sizeof(float))
{
// SPH Partitioning grid indices per particle:
- bd.Stride = sizeof(float); // really, it is uint, but sorting is performing comparisons on floats, so whateva
- bd.Size = bd.Stride * MAX_PARTICLES;
+ bd.stride = sizeof(float); // really, it is uint, but sorting is performing comparisons on floats, so whateva
+ bd.size = bd.stride * MAX_PARTICLES;
device->CreateBuffer(&bd, nullptr, &sphPartitionCellIndices);
device->SetName(&sphPartitionCellIndices, "sphPartitionCellIndices");
// Density buffer (for SPH simulation):
- bd.Stride = sizeof(float);
- bd.Size = bd.Stride * MAX_PARTICLES;
+ bd.stride = sizeof(float);
+ bd.size = bd.stride * MAX_PARTICLES;
device->CreateBuffer(&bd, nullptr, &densityBuffer);
device->SetName(&densityBuffer, "densityBuffer");
}
- if (sphPartitionCellOffsets.desc.Size < SPH_PARTITION_BUCKET_COUNT * sizeof(uint32_t))
+ if (sphPartitionCellOffsets.desc.size < SPH_PARTITION_BUCKET_COUNT * sizeof(uint32_t))
{
// SPH Partitioning grid cell offsets into particle index list:
- bd.Stride = sizeof(uint32_t);
- bd.Size = bd.Stride * SPH_PARTITION_BUCKET_COUNT;
+ bd.stride = sizeof(uint32_t);
+ bd.size = bd.stride * SPH_PARTITION_BUCKET_COUNT;
device->CreateBuffer(&bd, nullptr, &sphPartitionCellOffsets);
device->SetName(&sphPartitionCellOffsets, "sphPartitionCellOffsets");
}
@@ -212,12 +212,12 @@ void wiEmittedParticle::CreateSelfBuffers()
counters.aliveCount_afterSimulation = 0;
GPUBufferDesc bd;
- bd.Usage = USAGE_DEFAULT;
- bd.BindFlags = BIND_SHADER_RESOURCE | BIND_UNORDERED_ACCESS;
- bd.MiscFlags = RESOURCE_MISC_BUFFER_STRUCTURED;
- bd.Size = sizeof(counters);
- bd.Stride = sizeof(counters);
- bd.MiscFlags = RESOURCE_MISC_BUFFER_RAW;
+ bd.usage = Usage::DEFAULT;
+ bd.bind_flags = BindFlag::SHADER_RESOURCE | BindFlag::UNORDERED_ACCESS;
+ bd.misc_flags = ResourceMiscFlag::BUFFER_STRUCTURED;
+ bd.size = sizeof(counters);
+ bd.stride = sizeof(counters);
+ bd.misc_flags = ResourceMiscFlag::BUFFER_RAW;
device->CreateBuffer(&bd, &counters, &counterBuffer);
device->SetName(&counterBuffer, "counterBuffer");
}
@@ -227,10 +227,10 @@ void wiEmittedParticle::CreateSelfBuffers()
GPUBufferDesc bd;
// Indirect Execution buffer:
- bd.Usage = USAGE_DEFAULT;
- bd.BindFlags = BIND_UNORDERED_ACCESS;
- bd.MiscFlags = RESOURCE_MISC_BUFFER_RAW | RESOURCE_MISC_INDIRECT_ARGS;
- bd.Size =
+ bd.usage = Usage::DEFAULT;
+ bd.bind_flags = BindFlag::UNORDERED_ACCESS;
+ bd.misc_flags = ResourceMiscFlag::BUFFER_RAW | ResourceMiscFlag::INDIRECT_ARGS;
+ bd.size =
sizeof(wiGraphics::IndirectDispatchArgs) +
sizeof(wiGraphics::IndirectDispatchArgs) +
sizeof(wiGraphics::IndirectDrawArgsInstanced);
@@ -238,19 +238,19 @@ void wiEmittedParticle::CreateSelfBuffers()
device->SetName(&indirectBuffers, "indirectBuffers");
// Constant buffer:
- bd.Usage = USAGE_DEFAULT;
- bd.Size = sizeof(EmittedParticleCB);
- bd.BindFlags = BIND_CONSTANT_BUFFER;
- bd.MiscFlags = RESOURCE_MISC_NONE;
+ bd.usage = Usage::DEFAULT;
+ bd.size = sizeof(EmittedParticleCB);
+ bd.bind_flags = BindFlag::CONSTANT_BUFFER;
+ bd.misc_flags = ResourceMiscFlag::NONE;
device->CreateBuffer(&bd, nullptr, &constantBuffer);
device->SetName(&constantBuffer, "constantBuffer");
// Debug information CPU-readback buffer:
{
GPUBufferDesc debugBufDesc = counterBuffer.GetDesc();
- debugBufDesc.Usage = USAGE_READBACK;
- debugBufDesc.BindFlags = BIND_NONE;
- debugBufDesc.MiscFlags = RESOURCE_MISC_NONE;
+ debugBufDesc.usage = Usage::READBACK;
+ debugBufDesc.bind_flags = BindFlag::NONE;
+ debugBufDesc.misc_flags = ResourceMiscFlag::NONE;
for (int i = 0; i < arraysize(statisticsReadbackBuffer); ++i)
{
device->CreateBuffer(&debugBufDesc, nullptr, &statisticsReadbackBuffer[i]);
@@ -262,31 +262,31 @@ void wiEmittedParticle::CreateSelfBuffers()
if (!subsetBuffer.IsValid())
{
GPUBufferDesc desc;
- desc.Stride = sizeof(ShaderMeshSubset);
- desc.Size = desc.Stride;
- desc.MiscFlags = RESOURCE_MISC_BUFFER_RAW;
- desc.BindFlags = BIND_SHADER_RESOURCE;
+ desc.stride = sizeof(ShaderMeshSubset);
+ desc.size = desc.stride;
+ desc.misc_flags = ResourceMiscFlag::BUFFER_RAW;
+ desc.bind_flags = BindFlag::SHADER_RESOURCE;
device->CreateBuffer(&desc, nullptr, &subsetBuffer);
}
- if (device->CheckCapability(GRAPHICSDEVICE_CAPABILITY_RAYTRACING) && primitiveBuffer.IsValid())
+ if (device->CheckCapability(GraphicsDeviceCapability::RAYTRACING) && primitiveBuffer.IsValid())
{
RaytracingAccelerationStructureDesc desc;
- desc.type = RaytracingAccelerationStructureDesc::BOTTOMLEVEL;
- desc._flags |= RaytracingAccelerationStructureDesc::FLAG_ALLOW_UPDATE;
- desc._flags |= RaytracingAccelerationStructureDesc::FLAG_PREFER_FAST_BUILD;
+ desc.type = RaytracingAccelerationStructureDesc::Type::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;
- geometry.triangles.indexBuffer = primitiveBuffer;
- geometry.triangles.indexFormat = INDEXFORMAT_32BIT;
- geometry.triangles.indexCount = (uint32_t)(primitiveBuffer.desc.Size / primitiveBuffer.desc.Stride);
- geometry.triangles.indexOffset = 0;
- geometry.triangles.vertexCount = (uint32_t)(vertexBuffer_POS.desc.Size / vertexBuffer_POS.desc.Stride);
- geometry.triangles.vertexFormat = FORMAT_R32G32B32_FLOAT;
- geometry.triangles.vertexStride = sizeof(MeshComponent::Vertex_POS);
+ desc.bottom_level.geometries.emplace_back();
+ auto& geometry = desc.bottom_level.geometries.back();
+ geometry.type = RaytracingAccelerationStructureDesc::BottomLevel::Geometry::Type::TRIANGLES;
+ geometry.triangles.vertex_buffer = vertexBuffer_POS;
+ geometry.triangles.index_buffer = primitiveBuffer;
+ geometry.triangles.index_format = IndexBufferFormat::UINT32;
+ geometry.triangles.index_count = (uint32_t)(primitiveBuffer.desc.size / primitiveBuffer.desc.stride);
+ geometry.triangles.index_offset = 0;
+ geometry.triangles.vertex_count = (uint32_t)(vertexBuffer_POS.desc.size / vertexBuffer_POS.desc.stride);
+ geometry.triangles.vertex_format = Format::R32G32B32_FLOAT;
+ geometry.triangles.vertex_stride = sizeof(MeshComponent::Vertex_POS);
bool success = device->CreateRaytracingAccelerationStructure(&desc, &BLAS);
assert(success);
@@ -302,25 +302,25 @@ uint64_t wiEmittedParticle::GetMemorySizeInBytes() const
uint64_t retVal = 0;
- retVal += particleBuffer.GetDesc().Size;
- retVal += aliveList[0].GetDesc().Size;
- retVal += aliveList[1].GetDesc().Size;
- retVal += deadList.GetDesc().Size;
- retVal += distanceBuffer.GetDesc().Size;
- retVal += sphPartitionCellIndices.GetDesc().Size;
- retVal += sphPartitionCellOffsets.GetDesc().Size;
- retVal += densityBuffer.GetDesc().Size;
- retVal += counterBuffer.GetDesc().Size;
- retVal += indirectBuffers.GetDesc().Size;
- retVal += constantBuffer.GetDesc().Size;
- retVal += vertexBuffer_POS.GetDesc().Size;
- retVal += vertexBuffer_TEX.GetDesc().Size;
- retVal += vertexBuffer_TEX2.GetDesc().Size;
- retVal += vertexBuffer_COL.GetDesc().Size;
- retVal += primitiveBuffer.GetDesc().Size;
- retVal += culledIndirectionBuffer.GetDesc().Size;
- retVal += culledIndirectionBuffer2.GetDesc().Size;
- retVal += subsetBuffer.GetDesc().Size;
+ retVal += particleBuffer.GetDesc().size;
+ retVal += aliveList[0].GetDesc().size;
+ retVal += aliveList[1].GetDesc().size;
+ retVal += deadList.GetDesc().size;
+ retVal += distanceBuffer.GetDesc().size;
+ retVal += sphPartitionCellIndices.GetDesc().size;
+ retVal += sphPartitionCellOffsets.GetDesc().size;
+ retVal += densityBuffer.GetDesc().size;
+ retVal += counterBuffer.GetDesc().size;
+ retVal += indirectBuffers.GetDesc().size;
+ retVal += constantBuffer.GetDesc().size;
+ retVal += vertexBuffer_POS.GetDesc().size;
+ retVal += vertexBuffer_TEX.GetDesc().size;
+ retVal += vertexBuffer_TEX2.GetDesc().size;
+ retVal += vertexBuffer_COL.GetDesc().size;
+ retVal += primitiveBuffer.GetDesc().size;
+ retVal += culledIndirectionBuffer.GetDesc().size;
+ retVal += culledIndirectionBuffer2.GetDesc().size;
+ retVal += subsetBuffer.GetDesc().size;
return retVal;
}
@@ -372,7 +372,7 @@ void wiEmittedParticle::UpdateGPU(uint32_t instanceIndex, uint32_t materialIndex
return;
}
- GraphicsDevice* device = wiRenderer::GetDevice();
+ GraphicsDevice* device = wiGraphics::GetDevice();
device->EventBegin("UpdateEmittedParticles", cmd);
if (!IsPaused())
@@ -421,7 +421,7 @@ void wiEmittedParticle::UpdateGPU(uint32_t instanceIndex, uint32_t materialIndex
{
cb.xEmitterOptions |= EMITTER_OPTION_BIT_FRAME_BLENDING_ENABLED;
}
- if (ALLOW_MESH_SHADER && device->CheckCapability(GRAPHICSDEVICE_CAPABILITY_MESH_SHADER))
+ if (ALLOW_MESH_SHADER && device->CheckCapability(GraphicsDeviceCapability::MESH_SHADER))
{
cb.xEmitterOptions |= EMITTER_OPTION_BIT_MESH_SHADER_ENABLED;
}
@@ -441,15 +441,15 @@ void wiEmittedParticle::UpdateGPU(uint32_t instanceIndex, uint32_t materialIndex
{
GPUBarrier barriers[] = {
- GPUBarrier::Buffer(&constantBuffer, RESOURCE_STATE_CONSTANT_BUFFER, RESOURCE_STATE_COPY_DST),
+ GPUBarrier::Buffer(&constantBuffer, ResourceState::CONSTANT_BUFFER, ResourceState::COPY_DST),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
device->UpdateBuffer(&constantBuffer, &cb, cmd);
{
GPUBarrier barriers[] = {
- GPUBarrier::Buffer(&constantBuffer, RESOURCE_STATE_COPY_DST, RESOURCE_STATE_CONSTANT_BUFFER),
- GPUBarrier::Buffer(&subsetBuffer, RESOURCE_STATE_COPY_DST, RESOURCE_STATE_SHADER_RESOURCE),
+ GPUBarrier::Buffer(&constantBuffer, ResourceState::COPY_DST, ResourceState::CONSTANT_BUFFER),
+ GPUBarrier::Buffer(&subsetBuffer, ResourceState::COPY_DST, ResourceState::SHADER_RESOURCE),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
@@ -482,8 +482,8 @@ void wiEmittedParticle::UpdateGPU(uint32_t instanceIndex, uint32_t materialIndex
device->BindResources(resources, TEXSLOT_ONDEMAND0, arraysize(resources), cmd);
}
- 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_indirect_uav = GPUBarrier::Buffer(&indirectBuffers, ResourceState::INDIRECT_ARGUMENT, ResourceState::UNORDERED_ACCESS);
+ GPUBarrier barrier_uav_indirect = GPUBarrier::Buffer(&indirectBuffers, ResourceState::UNORDERED_ACCESS, ResourceState::INDIRECT_ARGUMENT);
GPUBarrier barrier_memory = GPUBarrier::Memory();
device->Barrier(&barrier_indirect_uav, 1, cmd);
@@ -632,8 +632,8 @@ void wiEmittedParticle::UpdateGPU(uint32_t instanceIndex, uint32_t materialIndex
{
GPUBarrier barriers[] = {
GPUBarrier::Memory(),
- GPUBarrier::Buffer(&counterBuffer, RESOURCE_STATE_UNORDERED_ACCESS, RESOURCE_STATE_SHADER_RESOURCE),
- GPUBarrier::Buffer(&distanceBuffer, RESOURCE_STATE_UNORDERED_ACCESS, RESOURCE_STATE_SHADER_RESOURCE_COMPUTE),
+ GPUBarrier::Buffer(&counterBuffer, ResourceState::UNORDERED_ACCESS, ResourceState::SHADER_RESOURCE),
+ GPUBarrier::Buffer(&distanceBuffer, ResourceState::UNORDERED_ACCESS, ResourceState::SHADER_RESOURCE_COMPUTE),
};
}
device->EventEnd(cmd);
@@ -664,7 +664,7 @@ void wiEmittedParticle::UpdateGPU(uint32_t instanceIndex, uint32_t materialIndex
{
GPUBarrier barriers[] = {
GPUBarrier::Memory(),
- GPUBarrier::Buffer(&indirectBuffers, RESOURCE_STATE_INDIRECT_ARGUMENT, RESOURCE_STATE_UNORDERED_ACCESS),
+ GPUBarrier::Buffer(&indirectBuffers, ResourceState::INDIRECT_ARGUMENT, ResourceState::UNORDERED_ACCESS),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
@@ -678,7 +678,7 @@ void wiEmittedParticle::UpdateGPU(uint32_t instanceIndex, uint32_t materialIndex
{
GPUBarrier barriers[] = {
GPUBarrier::Memory(),
- GPUBarrier::Buffer(&counterBuffer, RESOURCE_STATE_SHADER_RESOURCE, RESOURCE_STATE_COPY_SRC),
+ GPUBarrier::Buffer(&counterBuffer, ResourceState::SHADER_RESOURCE, ResourceState::COPY_SRC),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
@@ -688,16 +688,16 @@ void wiEmittedParticle::UpdateGPU(uint32_t instanceIndex, uint32_t materialIndex
{
const GPUBarrier barriers[] = {
- 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),
- GPUBarrier::Buffer(&vertexBuffer_POS, RESOURCE_STATE_UNORDERED_ACCESS, RESOURCE_STATE_SHADER_RESOURCE),
- GPUBarrier::Buffer(&vertexBuffer_TEX, RESOURCE_STATE_UNORDERED_ACCESS, RESOURCE_STATE_SHADER_RESOURCE),
- GPUBarrier::Buffer(&vertexBuffer_TEX2, RESOURCE_STATE_UNORDERED_ACCESS, RESOURCE_STATE_SHADER_RESOURCE),
- GPUBarrier::Buffer(&vertexBuffer_COL, RESOURCE_STATE_UNORDERED_ACCESS, RESOURCE_STATE_SHADER_RESOURCE),
- GPUBarrier::Buffer(&culledIndirectionBuffer, RESOURCE_STATE_UNORDERED_ACCESS, RESOURCE_STATE_SHADER_RESOURCE_COMPUTE),
- GPUBarrier::Buffer(&culledIndirectionBuffer2, RESOURCE_STATE_UNORDERED_ACCESS, RESOURCE_STATE_SHADER_RESOURCE_COMPUTE),
+ GPUBarrier::Buffer(&indirectBuffers, ResourceState::UNORDERED_ACCESS, ResourceState::INDIRECT_ARGUMENT),
+ GPUBarrier::Buffer(&counterBuffer, ResourceState::COPY_SRC, ResourceState::SHADER_RESOURCE),
+ GPUBarrier::Buffer(&particleBuffer, ResourceState::UNORDERED_ACCESS, ResourceState::SHADER_RESOURCE),
+ GPUBarrier::Buffer(&aliveList[1], ResourceState::UNORDERED_ACCESS, ResourceState::SHADER_RESOURCE),
+ GPUBarrier::Buffer(&vertexBuffer_POS, ResourceState::UNORDERED_ACCESS, ResourceState::SHADER_RESOURCE),
+ GPUBarrier::Buffer(&vertexBuffer_TEX, ResourceState::UNORDERED_ACCESS, ResourceState::SHADER_RESOURCE),
+ GPUBarrier::Buffer(&vertexBuffer_TEX2, ResourceState::UNORDERED_ACCESS, ResourceState::SHADER_RESOURCE),
+ GPUBarrier::Buffer(&vertexBuffer_COL, ResourceState::UNORDERED_ACCESS, ResourceState::SHADER_RESOURCE),
+ GPUBarrier::Buffer(&culledIndirectionBuffer, ResourceState::UNORDERED_ACCESS, ResourceState::SHADER_RESOURCE_COMPUTE),
+ GPUBarrier::Buffer(&culledIndirectionBuffer2, ResourceState::UNORDERED_ACCESS, ResourceState::SHADER_RESOURCE_COMPUTE),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
@@ -708,7 +708,7 @@ void wiEmittedParticle::UpdateGPU(uint32_t instanceIndex, uint32_t materialIndex
void wiEmittedParticle::Draw(const MaterialComponent& material, CommandList cmd) const
{
- GraphicsDevice* device = wiRenderer::GetDevice();
+ GraphicsDevice* device = wiGraphics::GetDevice();
device->EventBegin("EmittedParticle", cmd);
if (wiRenderer::IsWireRender())
@@ -733,7 +733,7 @@ void wiEmittedParticle::Draw(const MaterialComponent& material, CommandList cmd)
};
device->BindResources(res, TEXSLOT_ONDEMAND20, arraysize(res), cmd);
- if (ALLOW_MESH_SHADER && device->CheckCapability(GRAPHICSDEVICE_CAPABILITY_MESH_SHADER))
+ if (ALLOW_MESH_SHADER && device->CheckCapability(GraphicsDeviceCapability::MESH_SHADER))
{
device->DispatchMeshIndirect(&indirectBuffers, ARGUMENTBUFFER_OFFSET_DRAWPARTICLES, cmd);
}
@@ -750,43 +750,41 @@ namespace wiEmittedParticle_Internal
{
void LoadShaders()
{
- std::string path = wiRenderer::GetShaderPath();
+ wiRenderer::LoadShader(ShaderStage::VS, vertexShader, "emittedparticleVS.cso");
- wiRenderer::LoadShader(VS, vertexShader, "emittedparticleVS.cso");
-
- if (ALLOW_MESH_SHADER && wiRenderer::GetDevice()->CheckCapability(GRAPHICSDEVICE_CAPABILITY_MESH_SHADER))
+ if (ALLOW_MESH_SHADER && wiGraphics::GetDevice()->CheckCapability(GraphicsDeviceCapability::MESH_SHADER))
{
- wiRenderer::LoadShader(MS, meshShader, "emittedparticleMS.cso");
+ wiRenderer::LoadShader(ShaderStage::MS, meshShader, "emittedparticleMS.cso");
}
- wiRenderer::LoadShader(PS, pixelShader[wiEmittedParticle::SOFT], "emittedparticlePS_soft.cso");
- wiRenderer::LoadShader(PS, pixelShader[wiEmittedParticle::SOFT_DISTORTION], "emittedparticlePS_soft_distortion.cso");
- wiRenderer::LoadShader(PS, pixelShader[wiEmittedParticle::SIMPLE], "emittedparticlePS_simple.cso");
- wiRenderer::LoadShader(PS, pixelShader[wiEmittedParticle::SOFT_LIGHTING], "emittedparticlePS_soft_lighting.cso");
+ wiRenderer::LoadShader(ShaderStage::PS, pixelShader[wiEmittedParticle::SOFT], "emittedparticlePS_soft.cso");
+ wiRenderer::LoadShader(ShaderStage::PS, pixelShader[wiEmittedParticle::SOFT_DISTORTION], "emittedparticlePS_soft_distortion.cso");
+ wiRenderer::LoadShader(ShaderStage::PS, pixelShader[wiEmittedParticle::SIMPLE], "emittedparticlePS_simple.cso");
+ wiRenderer::LoadShader(ShaderStage::PS, pixelShader[wiEmittedParticle::SOFT_LIGHTING], "emittedparticlePS_soft_lighting.cso");
- wiRenderer::LoadShader(CS, kickoffUpdateCS, "emittedparticle_kickoffUpdateCS.cso");
- wiRenderer::LoadShader(CS, finishUpdateCS, "emittedparticle_finishUpdateCS.cso");
- wiRenderer::LoadShader(CS, emitCS, "emittedparticle_emitCS.cso");
- wiRenderer::LoadShader(CS, emitCS_VOLUME, "emittedparticle_emitCS_volume.cso");
- wiRenderer::LoadShader(CS, emitCS_FROMMESH, "emittedparticle_emitCS_FROMMESH.cso");
- wiRenderer::LoadShader(CS, sphpartitionCS, "emittedparticle_sphpartitionCS.cso");
- wiRenderer::LoadShader(CS, sphpartitionoffsetsCS, "emittedparticle_sphpartitionoffsetsCS.cso");
- wiRenderer::LoadShader(CS, sphpartitionoffsetsresetCS, "emittedparticle_sphpartitionoffsetsresetCS.cso");
- wiRenderer::LoadShader(CS, sphdensityCS, "emittedparticle_sphdensityCS.cso");
- wiRenderer::LoadShader(CS, sphforceCS, "emittedparticle_sphforceCS.cso");
- wiRenderer::LoadShader(CS, simulateCS, "emittedparticle_simulateCS.cso");
- wiRenderer::LoadShader(CS, simulateCS_SORTING, "emittedparticle_simulateCS_SORTING.cso");
- wiRenderer::LoadShader(CS, simulateCS_DEPTHCOLLISIONS, "emittedparticle_simulateCS_DEPTHCOLLISIONS.cso");
- wiRenderer::LoadShader(CS, simulateCS_SORTING_DEPTHCOLLISIONS, "emittedparticle_simulateCS_SORTING_DEPTHCOLLISIONS.cso");
+ wiRenderer::LoadShader(ShaderStage::CS, kickoffUpdateCS, "emittedparticle_kickoffUpdateCS.cso");
+ wiRenderer::LoadShader(ShaderStage::CS, finishUpdateCS, "emittedparticle_finishUpdateCS.cso");
+ wiRenderer::LoadShader(ShaderStage::CS, emitCS, "emittedparticle_emitCS.cso");
+ wiRenderer::LoadShader(ShaderStage::CS, emitCS_VOLUME, "emittedparticle_emitCS_volume.cso");
+ wiRenderer::LoadShader(ShaderStage::CS, emitCS_FROMMESH, "emittedparticle_emitCS_FROMMESH.cso");
+ wiRenderer::LoadShader(ShaderStage::CS, sphpartitionCS, "emittedparticle_sphpartitionCS.cso");
+ wiRenderer::LoadShader(ShaderStage::CS, sphpartitionoffsetsCS, "emittedparticle_sphpartitionoffsetsCS.cso");
+ wiRenderer::LoadShader(ShaderStage::CS, sphpartitionoffsetsresetCS, "emittedparticle_sphpartitionoffsetsresetCS.cso");
+ wiRenderer::LoadShader(ShaderStage::CS, sphdensityCS, "emittedparticle_sphdensityCS.cso");
+ wiRenderer::LoadShader(ShaderStage::CS, sphforceCS, "emittedparticle_sphforceCS.cso");
+ wiRenderer::LoadShader(ShaderStage::CS, simulateCS, "emittedparticle_simulateCS.cso");
+ wiRenderer::LoadShader(ShaderStage::CS, simulateCS_SORTING, "emittedparticle_simulateCS_SORTING.cso");
+ wiRenderer::LoadShader(ShaderStage::CS, simulateCS_DEPTHCOLLISIONS, "emittedparticle_simulateCS_DEPTHCOLLISIONS.cso");
+ wiRenderer::LoadShader(ShaderStage::CS, simulateCS_SORTING_DEPTHCOLLISIONS, "emittedparticle_simulateCS_SORTING_DEPTHCOLLISIONS.cso");
- GraphicsDevice* device = wiRenderer::GetDevice();
+ GraphicsDevice* device = wiGraphics::GetDevice();
for (int i = 0; i < BLENDMODE_COUNT; ++i)
{
PipelineStateDesc desc;
- desc.pt = TRIANGLESTRIP;
- if (ALLOW_MESH_SHADER && wiRenderer::GetDevice()->CheckCapability(GRAPHICSDEVICE_CAPABILITY_MESH_SHADER))
+ desc.pt = PrimitiveTopology::TRIANGLESTRIP;
+ if (ALLOW_MESH_SHADER && wiGraphics::GetDevice()->CheckCapability(GraphicsDeviceCapability::MESH_SHADER))
{
desc.ms = &meshShader;
}
@@ -807,8 +805,8 @@ namespace wiEmittedParticle_Internal
{
PipelineStateDesc desc;
- desc.pt = TRIANGLESTRIP;
- if (ALLOW_MESH_SHADER && wiRenderer::GetDevice()->CheckCapability(GRAPHICSDEVICE_CAPABILITY_MESH_SHADER))
+ desc.pt = PrimitiveTopology::TRIANGLESTRIP;
+ if (ALLOW_MESH_SHADER && wiGraphics::GetDevice()->CheckCapability(GraphicsDeviceCapability::MESH_SHADER))
{
desc.ms = &meshShader;
}
@@ -832,73 +830,73 @@ void wiEmittedParticle::Initialize()
wiTimer timer;
RasterizerState rs;
- rs.FillMode = FILL_SOLID;
- rs.CullMode = CULL_NONE;
- rs.FrontCounterClockwise = true;
- rs.DepthBias = 0;
- rs.DepthBiasClamp = 0;
- rs.SlopeScaledDepthBias = 0;
- rs.DepthClipEnable = false;
- rs.MultisampleEnable = false;
- rs.AntialiasedLineEnable = false;
+ rs.fill_mode = FillMode::SOLID;
+ rs.cull_mode = CullMode::NONE;
+ rs.front_counter_clockwise = true;
+ rs.depth_bias = 0;
+ rs.depth_bias_clamp = 0;
+ rs.slope_scaled_depth_bias = 0;
+ rs.depth_clip_enable = false;
+ rs.multisample_enable = false;
+ rs.antialiased_line_enable = false;
rasterizerState = rs;
- rs.FillMode = FILL_WIREFRAME;
- rs.CullMode = CULL_NONE;
- rs.FrontCounterClockwise = true;
- rs.DepthBias = 0;
- rs.DepthBiasClamp = 0;
- rs.SlopeScaledDepthBias = 0;
- rs.DepthClipEnable = false;
- rs.MultisampleEnable = false;
- rs.AntialiasedLineEnable = false;
+ rs.fill_mode = FillMode::WIREFRAME;
+ rs.cull_mode = CullMode::NONE;
+ rs.front_counter_clockwise = true;
+ rs.depth_bias = 0;
+ rs.depth_bias_clamp = 0;
+ rs.slope_scaled_depth_bias = 0;
+ rs.depth_clip_enable = false;
+ rs.multisample_enable = false;
+ rs.antialiased_line_enable = false;
wireFrameRS = rs;
DepthStencilState dsd;
- dsd.DepthEnable = true;
- dsd.DepthWriteMask = DEPTH_WRITE_MASK_ZERO;
- dsd.DepthFunc = COMPARISON_GREATER_EQUAL;
- dsd.StencilEnable = false;
+ dsd.depth_enable = true;
+ dsd.depth_write_mask = DepthWriteMask::ZERO;
+ dsd.depth_func = ComparisonFunc::GREATER_EQUAL;
+ dsd.stencil_enable = false;
depthStencilState = dsd;
BlendState bd;
- bd.RenderTarget[0].BlendEnable = true;
- bd.RenderTarget[0].SrcBlend = BLEND_SRC_ALPHA;
- bd.RenderTarget[0].DestBlend = BLEND_INV_SRC_ALPHA;
- bd.RenderTarget[0].BlendOp = BLEND_OP_ADD;
- bd.RenderTarget[0].SrcBlendAlpha = BLEND_ONE;
- bd.RenderTarget[0].DestBlendAlpha = BLEND_INV_SRC_ALPHA;
- bd.RenderTarget[0].BlendOpAlpha = BLEND_OP_ADD;
- bd.RenderTarget[0].RenderTargetWriteMask = COLOR_WRITE_ENABLE_ALL;
- bd.IndependentBlendEnable = false;
+ bd.render_target[0].blend_enable = true;
+ bd.render_target[0].src_blend = Blend::SRC_ALPHA;
+ bd.render_target[0].dest_blend = Blend::INV_SRC_ALPHA;
+ bd.render_target[0].blend_op = BlendOp::ADD;
+ bd.render_target[0].src_blend_alpha = Blend::ONE;
+ bd.render_target[0].dest_blend_alpha = Blend::INV_SRC_ALPHA;
+ bd.render_target[0].blend_op_alpha = BlendOp::ADD;
+ bd.render_target[0].render_target_write_mask = ColorWrite::ENABLE_ALL;
+ bd.independent_blend_enable = false;
blendStates[BLENDMODE_ALPHA] = bd;
- bd.RenderTarget[0].BlendEnable = true;
- bd.RenderTarget[0].SrcBlend = BLEND_SRC_ALPHA;
- bd.RenderTarget[0].DestBlend = BLEND_ONE;
- bd.RenderTarget[0].BlendOp = BLEND_OP_ADD;
- bd.RenderTarget[0].SrcBlendAlpha = BLEND_ZERO;
- bd.RenderTarget[0].DestBlendAlpha = BLEND_ONE;
- bd.RenderTarget[0].BlendOpAlpha = BLEND_OP_ADD;
- bd.RenderTarget[0].RenderTargetWriteMask = COLOR_WRITE_ENABLE_ALL;
- bd.IndependentBlendEnable = false;
+ bd.render_target[0].blend_enable = true;
+ bd.render_target[0].src_blend = Blend::SRC_ALPHA;
+ bd.render_target[0].dest_blend = Blend::ONE;
+ bd.render_target[0].blend_op = BlendOp::ADD;
+ bd.render_target[0].src_blend_alpha = Blend::ZERO;
+ bd.render_target[0].dest_blend_alpha = Blend::ONE;
+ bd.render_target[0].blend_op_alpha = BlendOp::ADD;
+ bd.render_target[0].render_target_write_mask = ColorWrite::ENABLE_ALL;
+ bd.independent_blend_enable = false;
blendStates[BLENDMODE_ADDITIVE] = bd;
- bd.RenderTarget[0].BlendEnable = true;
- bd.RenderTarget[0].SrcBlend = BLEND_ONE;
- bd.RenderTarget[0].DestBlend = BLEND_INV_SRC_ALPHA;
- bd.RenderTarget[0].BlendOp = BLEND_OP_ADD;
- bd.RenderTarget[0].SrcBlendAlpha = BLEND_ONE;
- bd.RenderTarget[0].DestBlendAlpha = BLEND_ONE;
- bd.RenderTarget[0].BlendOpAlpha = BLEND_OP_ADD;
- bd.RenderTarget[0].RenderTargetWriteMask = COLOR_WRITE_ENABLE_ALL;
- bd.IndependentBlendEnable = false;
+ bd.render_target[0].blend_enable = true;
+ bd.render_target[0].src_blend = Blend::ONE;
+ bd.render_target[0].dest_blend = Blend::INV_SRC_ALPHA;
+ bd.render_target[0].blend_op = BlendOp::ADD;
+ bd.render_target[0].src_blend_alpha = Blend::ONE;
+ bd.render_target[0].dest_blend_alpha = Blend::ONE;
+ bd.render_target[0].blend_op_alpha = BlendOp::ADD;
+ bd.render_target[0].render_target_write_mask = ColorWrite::ENABLE_ALL;
+ bd.independent_blend_enable = false;
blendStates[BLENDMODE_PREMULTIPLIED] = bd;
- bd.RenderTarget[0].BlendEnable = false;
+ bd.render_target[0].blend_enable = false;
blendStates[BLENDMODE_OPAQUE] = bd;
static wiEvent::Handle handle = wiEvent::Subscribe(SYSTEM_EVENT_RELOAD_SHADERS, [](uint64_t userdata) { wiEmittedParticle_Internal::LoadShaders(); });
diff --git a/WickedEngine/wiFFTGenerator.cpp b/WickedEngine/wiFFTGenerator.cpp
index 517807abd..2e0beeb96 100644
--- a/WickedEngine/wiFFTGenerator.cpp
+++ b/WickedEngine/wiFFTGenerator.cpp
@@ -33,7 +33,7 @@ namespace wiFFTGenerator
// Setup execution configuration
uint32_t grid = thread_count / COHERENCY_GRANULARITY;
- GraphicsDevice* device = wiRenderer::GetDevice();
+ GraphicsDevice* device = wiGraphics::GetDevice();
// Buffers
const GPUResource* srvs[1] = { &pSRV_Src };
@@ -71,7 +71,7 @@ namespace wiFFTGenerator
CommandList cmd)
{
const uint32_t thread_count = fft_plan.slices * (512 * 512) / 8;
- GraphicsDevice* device = wiRenderer::GetDevice();
+ GraphicsDevice* device = wiGraphics::GetDevice();
const GPUBuffer* cs_cbs;
uint32_t istride = 512 * 512 / 8;
@@ -110,9 +110,9 @@ namespace wiFFTGenerator
// Create 6 cbuffers for 512x512 transform.
GPUBufferDesc cb_desc;
- cb_desc.BindFlags = BIND_CONSTANT_BUFFER;
- cb_desc.Size = sizeof(FFTGeneratorCB);
- cb_desc.Stride = 0;
+ cb_desc.bind_flags = BindFlag::CONSTANT_BUFFER;
+ cb_desc.size = sizeof(FFTGeneratorCB);
+ cb_desc.stride = 0;
// Buffer 0
const uint32_t thread_count = slices * (512 * 512) / 8;
@@ -168,7 +168,7 @@ namespace wiFFTGenerator
void fft512x512_create_plan(CSFFT512x512_Plan& plan, uint32_t slices)
{
- GraphicsDevice* device = wiRenderer::GetDevice();
+ GraphicsDevice* device = wiGraphics::GetDevice();
plan.slices = slices;
@@ -178,21 +178,19 @@ namespace wiFFTGenerator
// Temp buffer
GPUBufferDesc buf_desc;
- buf_desc.Size = sizeof(float) * 2 * (512 * slices) * 512;
- buf_desc.Usage = USAGE_DEFAULT;
- buf_desc.BindFlags = BIND_UNORDERED_ACCESS | BIND_SHADER_RESOURCE;
- buf_desc.MiscFlags = RESOURCE_MISC_BUFFER_STRUCTURED;
- buf_desc.Stride = sizeof(float) * 2;
+ buf_desc.size = sizeof(float) * 2 * (512 * slices) * 512;
+ buf_desc.usage = Usage::DEFAULT;
+ buf_desc.bind_flags = BindFlag::UNORDERED_ACCESS | BindFlag::SHADER_RESOURCE;
+ buf_desc.misc_flags = ResourceMiscFlag::BUFFER_STRUCTURED;
+ buf_desc.stride = sizeof(float) * 2;
device->CreateBuffer(&buf_desc, nullptr, &plan.pBuffer_Tmp);
}
void LoadShaders()
{
- std::string path = wiRenderer::GetShaderPath();
-
- wiRenderer::LoadShader(CS, radix008A_CS, "fft_512x512_c2c_CS.cso");
- wiRenderer::LoadShader(CS, radix008A_CS2, "fft_512x512_c2c_v2_CS.cso");
+ wiRenderer::LoadShader(ShaderStage::CS, radix008A_CS, "fft_512x512_c2c_CS.cso");
+ wiRenderer::LoadShader(ShaderStage::CS, radix008A_CS2, "fft_512x512_c2c_v2_CS.cso");
}
}
diff --git a/WickedEngine/wiFont.cpp b/WickedEngine/wiFont.cpp
index 295f54c7a..5a740a88c 100644
--- a/WickedEngine/wiFont.cpp
+++ b/WickedEngine/wiFont.cpp
@@ -36,7 +36,6 @@ namespace wiFont_Internal
DepthStencilState depthStencilState;
Sampler sampler;
- InputLayout inputLayout;
Shader vertexShader;
Shader pixelShader;
PipelineState PSO;
@@ -246,16 +245,14 @@ namespace wiFont
void LoadShaders()
{
- std::string path = wiRenderer::GetShaderPath();
-
- wiRenderer::LoadShader(VS, vertexShader, "fontVS.cso");
+ wiRenderer::LoadShader(ShaderStage::VS, vertexShader, "fontVS.cso");
pixelShader.auto_samplers.emplace_back();
pixelShader.auto_samplers.back().sampler = sampler;
pixelShader.auto_samplers.back().slot = SSLOT_ONDEMAND1;
- wiRenderer::LoadShader(PS, pixelShader, "fontPS.cso");
+ wiRenderer::LoadShader(ShaderStage::PS, pixelShader, "fontPS.cso");
PipelineStateDesc desc;
@@ -264,8 +261,8 @@ void LoadShaders()
desc.bs = &blendState;
desc.dss = &depthStencilState;
desc.rs = &rasterizerState;
- desc.pt = TRIANGLESTRIP;
- wiRenderer::GetDevice()->CreatePipelineState(&desc, &PSO);
+ desc.pt = PrimitiveTopology::TRIANGLESTRIP;
+ wiGraphics::GetDevice()->CreatePipelineState(&desc, &PSO);
}
void Initialize()
{
@@ -282,48 +279,48 @@ void Initialize()
AddFontStyle("arial", arial, sizeof(arial));
}
- GraphicsDevice* device = wiRenderer::GetDevice();
+ GraphicsDevice* device = wiGraphics::GetDevice();
RasterizerState rs;
- rs.FillMode = FILL_SOLID;
- rs.CullMode = CULL_FRONT;
- rs.FrontCounterClockwise = true;
- rs.DepthBias = 0;
- rs.DepthBiasClamp = 0;
- rs.SlopeScaledDepthBias = 0;
- rs.DepthClipEnable = false;
- rs.MultisampleEnable = false;
- rs.AntialiasedLineEnable = false;
+ rs.fill_mode = FillMode::SOLID;
+ rs.cull_mode = CullMode::FRONT;
+ rs.front_counter_clockwise = true;
+ rs.depth_bias = 0;
+ rs.depth_bias_clamp = 0;
+ rs.slope_scaled_depth_bias = 0;
+ rs.depth_clip_enable = false;
+ rs.multisample_enable = false;
+ rs.antialiased_line_enable = false;
rasterizerState = rs;
BlendState bd;
- bd.RenderTarget[0].BlendEnable = true;
- bd.RenderTarget[0].SrcBlend = BLEND_ONE;
- bd.RenderTarget[0].DestBlend = BLEND_INV_SRC_ALPHA;
- bd.RenderTarget[0].BlendOp = BLEND_OP_ADD;
- bd.RenderTarget[0].SrcBlendAlpha = BLEND_ONE;
- bd.RenderTarget[0].DestBlendAlpha = BLEND_INV_SRC_ALPHA;
- bd.RenderTarget[0].BlendOpAlpha = BLEND_OP_ADD;
- bd.RenderTarget[0].RenderTargetWriteMask = COLOR_WRITE_ENABLE_ALL;
- bd.IndependentBlendEnable = false;
+ bd.render_target[0].blend_enable = true;
+ bd.render_target[0].src_blend = Blend::ONE;
+ bd.render_target[0].dest_blend = Blend::INV_SRC_ALPHA;
+ bd.render_target[0].blend_op = BlendOp::ADD;
+ bd.render_target[0].src_blend_alpha = Blend::ONE;
+ bd.render_target[0].dest_blend_alpha = Blend::INV_SRC_ALPHA;
+ bd.render_target[0].blend_op_alpha = BlendOp::ADD;
+ bd.render_target[0].render_target_write_mask = ColorWrite::ENABLE_ALL;
+ bd.independent_blend_enable = false;
blendState = bd;
DepthStencilState dsd;
- dsd.DepthEnable = false;
- dsd.StencilEnable = false;
+ dsd.depth_enable = false;
+ dsd.stencil_enable = false;
depthStencilState = dsd;
SamplerDesc samplerDesc;
- samplerDesc.Filter = FILTER_MIN_MAG_LINEAR_MIP_POINT;
- samplerDesc.AddressU = TEXTURE_ADDRESS_BORDER;
- samplerDesc.AddressV = TEXTURE_ADDRESS_BORDER;
- samplerDesc.AddressW = TEXTURE_ADDRESS_BORDER;
- samplerDesc.MipLODBias = 0.0f;
- samplerDesc.MaxAnisotropy = 0;
- samplerDesc.ComparisonFunc = COMPARISON_NEVER;
- samplerDesc.BorderColor = SAMPLER_BORDER_COLOR_TRANSPARENT_BLACK;
- samplerDesc.MinLOD = 0;
- samplerDesc.MaxLOD = FLT_MAX;
+ samplerDesc.filter = Filter::MIN_MAG_LINEAR_MIP_POINT;
+ samplerDesc.address_u = TextureAddressMode::BORDER;
+ samplerDesc.address_v = TextureAddressMode::BORDER;
+ samplerDesc.address_w = TextureAddressMode::BORDER;
+ samplerDesc.mip_lod_bias = 0.0f;
+ samplerDesc.max_anisotropy = 0;
+ samplerDesc.comparison_func = ComparisonFunc::NEVER;
+ samplerDesc.border_color = SamplerBorderColor::TRANSPARENT_BLACK;
+ samplerDesc.min_lod = 0;
+ samplerDesc.max_lod = FLT_MAX;
device->CreateSampler(&samplerDesc, &sampler);
static wiEvent::Handle handle1 = wiEvent::Subscribe(SYSTEM_EVENT_RELOAD_SHADERS, [](uint64_t userdata) { LoadShaders(); });
@@ -445,7 +442,7 @@ void UpdatePendingGlyphs()
}
// Upload the CPU-side texture atlas bitmap to the GPU:
- wiTextureHelper::CreateTexture(texture, bitmap.data(), bitmapWidth, bitmapHeight, FORMAT_R8_UNORM);
+ wiTextureHelper::CreateTexture(texture, bitmap.data(), bitmapWidth, bitmapHeight, Format::R8_UNORM);
}
}
@@ -571,7 +568,7 @@ void Draw_internal(const T* text, size_t text_length, const wiFontParams& params
else if (params.v_align == WIFALIGN_BOTTOM)
newProps.posY -= textHeight_internal(text, newProps);
- GraphicsDevice* device = wiRenderer::GetDevice();
+ GraphicsDevice* device = wiGraphics::GetDevice();
GraphicsDevice::GPUAllocation mem = device->AllocateGPU(sizeof(FontVertex) * text_length * 4, cmd);
if (!mem.IsValid())
@@ -588,9 +585,9 @@ void Draw_internal(const T* text, size_t text_length, const wiFontParams& params
device->BindPipelineState(&PSO, cmd);
PushConstantsFont push;
- push.buffer_index = device->GetDescriptorIndex(&mem.buffer, SRV);
+ push.buffer_index = device->GetDescriptorIndex(&mem.buffer, SubresourceType::SRV);
push.buffer_offset = (uint32_t)mem.offset;
- push.texture_index = device->GetDescriptorIndex(&texture, SRV);
+ push.texture_index = device->GetDescriptorIndex(&texture, SubresourceType::SRV);
const wiCanvas& canvas = canvases[cmd];
// Asserts will check that a proper canvas was set for this cmd with wiImage::SetCanvas()
diff --git a/WickedEngine/wiGPUBVH.cpp b/WickedEngine/wiGPUBVH.cpp
index b23500730..ba5220bba 100644
--- a/WickedEngine/wiGPUBVH.cpp
+++ b/WickedEngine/wiGPUBVH.cpp
@@ -30,7 +30,7 @@ static Shader computeShaders[CSTYPE_BVH_COUNT];
void wiGPUBVH::Update(const wiScene::Scene& scene)
{
- GraphicsDevice* device = wiRenderer::GetDevice();
+ GraphicsDevice* device = wiGraphics::GetDevice();
// Pre-gather scene properties:
uint totalTriangles = 0;
@@ -63,12 +63,12 @@ void wiGPUBVH::Update(const wiScene::Scene& scene)
if (totalTriangles > 0 && !primitiveCounterBuffer.IsValid())
{
GPUBufferDesc desc;
- desc.BindFlags = BIND_SHADER_RESOURCE;
- desc.Stride = sizeof(uint);
- desc.Size = desc.Stride;
- desc.Format = FORMAT_UNKNOWN;
- desc.MiscFlags = RESOURCE_MISC_BUFFER_RAW;
- desc.Usage = USAGE_DEFAULT;
+ desc.bind_flags = BindFlag::SHADER_RESOURCE;
+ desc.stride = sizeof(uint);
+ desc.size = desc.stride;
+ desc.format = Format::UNKNOWN;
+ desc.misc_flags = ResourceMiscFlag::BUFFER_RAW;
+ desc.usage = Usage::DEFAULT;
device->CreateBuffer(&desc, nullptr, &primitiveCounterBuffer);
device->SetName(&primitiveCounterBuffer, "primitiveCounterBuffer");
}
@@ -84,64 +84,64 @@ void wiGPUBVH::Update(const wiScene::Scene& scene)
GPUBufferDesc desc;
- desc.BindFlags = BIND_SHADER_RESOURCE | BIND_UNORDERED_ACCESS;
- desc.Stride = sizeof(BVHNode);
- desc.Size = desc.Stride * primitiveCapacity * 2;
- desc.Format = FORMAT_UNKNOWN;
- desc.MiscFlags = RESOURCE_MISC_BUFFER_RAW;
- desc.Usage = USAGE_DEFAULT;
+ desc.bind_flags = BindFlag::SHADER_RESOURCE | BindFlag::UNORDERED_ACCESS;
+ desc.stride = sizeof(BVHNode);
+ desc.size = desc.stride * primitiveCapacity * 2;
+ desc.format = Format::UNKNOWN;
+ desc.misc_flags = ResourceMiscFlag::BUFFER_RAW;
+ desc.usage = Usage::DEFAULT;
device->CreateBuffer(&desc, nullptr, &bvhNodeBuffer);
device->SetName(&bvhNodeBuffer, "BVHNodeBuffer");
- desc.BindFlags = BIND_SHADER_RESOURCE | BIND_UNORDERED_ACCESS;
- desc.Stride = sizeof(uint);
- desc.Size = desc.Stride * primitiveCapacity * 2;
- desc.Format = FORMAT_UNKNOWN;
- desc.MiscFlags = RESOURCE_MISC_BUFFER_STRUCTURED;
- desc.Usage = USAGE_DEFAULT;
+ desc.bind_flags = BindFlag::SHADER_RESOURCE | BindFlag::UNORDERED_ACCESS;
+ desc.stride = sizeof(uint);
+ desc.size = desc.stride * primitiveCapacity * 2;
+ desc.format = Format::UNKNOWN;
+ desc.misc_flags = ResourceMiscFlag::BUFFER_STRUCTURED;
+ desc.usage = Usage::DEFAULT;
device->CreateBuffer(&desc, nullptr, &bvhParentBuffer);
device->SetName(&bvhParentBuffer, "BVHParentBuffer");
- desc.BindFlags = BIND_SHADER_RESOURCE | BIND_UNORDERED_ACCESS;
- desc.Stride = sizeof(uint);
- desc.Size = desc.Stride * (((primitiveCapacity - 1) + 31) / 32); // bitfield for internal nodes
- desc.Format = FORMAT_UNKNOWN;
- desc.MiscFlags = RESOURCE_MISC_BUFFER_STRUCTURED;
- desc.Usage = USAGE_DEFAULT;
+ desc.bind_flags = BindFlag::SHADER_RESOURCE | BindFlag::UNORDERED_ACCESS;
+ desc.stride = sizeof(uint);
+ desc.size = desc.stride * (((primitiveCapacity - 1) + 31) / 32); // bitfield for internal nodes
+ desc.format = Format::UNKNOWN;
+ desc.misc_flags = ResourceMiscFlag::BUFFER_STRUCTURED;
+ desc.usage = Usage::DEFAULT;
device->CreateBuffer(&desc, nullptr, &bvhFlagBuffer);
device->SetName(&bvhFlagBuffer, "BVHFlagBuffer");
- desc.BindFlags = BIND_SHADER_RESOURCE | BIND_UNORDERED_ACCESS;
- desc.Stride = sizeof(uint);
- desc.Size = desc.Stride * primitiveCapacity;
- desc.Format = FORMAT_UNKNOWN;
- desc.MiscFlags = RESOURCE_MISC_BUFFER_STRUCTURED;
- desc.Usage = USAGE_DEFAULT;
+ desc.bind_flags = BindFlag::SHADER_RESOURCE | BindFlag::UNORDERED_ACCESS;
+ desc.stride = sizeof(uint);
+ desc.size = desc.stride * primitiveCapacity;
+ desc.format = Format::UNKNOWN;
+ desc.misc_flags = ResourceMiscFlag::BUFFER_STRUCTURED;
+ desc.usage = Usage::DEFAULT;
device->CreateBuffer(&desc, nullptr, &primitiveIDBuffer);
device->SetName(&primitiveIDBuffer, "primitiveIDBuffer");
- desc.BindFlags = BIND_SHADER_RESOURCE | BIND_UNORDERED_ACCESS;
- desc.Stride = sizeof(BVHPrimitive);
- desc.Size = desc.Stride * primitiveCapacity;
- desc.Format = FORMAT_UNKNOWN;
- desc.MiscFlags = RESOURCE_MISC_BUFFER_RAW;
- desc.Usage = USAGE_DEFAULT;
+ desc.bind_flags = BindFlag::SHADER_RESOURCE | BindFlag::UNORDERED_ACCESS;
+ desc.stride = sizeof(BVHPrimitive);
+ desc.size = desc.stride * primitiveCapacity;
+ desc.format = Format::UNKNOWN;
+ desc.misc_flags = ResourceMiscFlag::BUFFER_RAW;
+ desc.usage = Usage::DEFAULT;
device->CreateBuffer(&desc, nullptr, &primitiveBuffer);
device->SetName(&primitiveBuffer, "primitiveBuffer");
- desc.BindFlags = BIND_SHADER_RESOURCE | BIND_UNORDERED_ACCESS;
- desc.Size = desc.Stride * primitiveCapacity;
- desc.Format = FORMAT_UNKNOWN;
- desc.MiscFlags = RESOURCE_MISC_BUFFER_STRUCTURED;
- desc.Usage = USAGE_DEFAULT;
- desc.Stride = sizeof(float); // morton buffer is float because sorting must be done and gpu sort operates on floats for now!
+ desc.bind_flags = BindFlag::SHADER_RESOURCE | BindFlag::UNORDERED_ACCESS;
+ desc.size = desc.stride * primitiveCapacity;
+ desc.format = Format::UNKNOWN;
+ desc.misc_flags = ResourceMiscFlag::BUFFER_STRUCTURED;
+ desc.usage = Usage::DEFAULT;
+ desc.stride = sizeof(float); // morton buffer is float because sorting must be done and gpu sort operates on floats for now!
device->CreateBuffer(&desc, nullptr, &primitiveMortonBuffer);
device->SetName(&primitiveMortonBuffer, "primitiveMortonBuffer");
}
}
void wiGPUBVH::Build(const Scene& scene, CommandList cmd) const
{
- GraphicsDevice* device = wiRenderer::GetDevice();
+ GraphicsDevice* device = wiGraphics::GetDevice();
auto range = wiProfiler::BeginRangeGPU("BVH Rebuild", cmd);
@@ -245,14 +245,14 @@ void wiGPUBVH::Build(const Scene& scene, CommandList cmd) const
{
GPUBarrier barriers[] = {
- GPUBarrier::Buffer(&primitiveCounterBuffer, RESOURCE_STATE_SHADER_RESOURCE, RESOURCE_STATE_COPY_DST),
+ GPUBarrier::Buffer(&primitiveCounterBuffer, ResourceState::SHADER_RESOURCE, ResourceState::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),
+ GPUBarrier::Buffer(&primitiveCounterBuffer, ResourceState::COPY_DST, ResourceState::SHADER_RESOURCE),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
@@ -326,9 +326,9 @@ void wiGPUBVH::Build(const Scene& scene, CommandList cmd) const
// Download primitive count:
readback_desc = primitiveCounterBuffer.GetDesc();
- readback_desc.Usage = USAGE_STAGING;
+ readback_desc.usage = USAGE_STAGING;
readback_desc.CPUAccessFlags = CPU_ACCESS_READ;
- readback_desc.BindFlags = 0;
+ readback_desc.bind_flags = 0;
readback_desc.Flags = 0;
GPUBuffer readback_primitiveCounterBuffer;
device->CreateBuffer(&readback_desc, nullptr, &readback_primitiveCounterBuffer);
@@ -342,13 +342,13 @@ void wiGPUBVH::Build(const Scene& scene, CommandList cmd) const
// Validate node buffer:
readback_desc = bvhNodeBuffer.GetDesc();
- readback_desc.Usage = USAGE_STAGING;
+ readback_desc.usage = USAGE_STAGING;
readback_desc.CPUAccessFlags = CPU_ACCESS_READ;
- readback_desc.BindFlags = 0;
+ readback_desc.bind_flags = 0;
readback_desc.Flags = 0;
GPUBuffer readback_nodeBuffer;
device->CreateBuffer(&readback_desc, nullptr, &readback_nodeBuffer);
- vector nodes(readback_desc.Size / sizeof(BVHNode));
+ vector nodes(readback_desc.size / sizeof(BVHNode));
download_success = device->DownloadResource(&bvhNodeBuffer, &readback_nodeBuffer, nodes.data(), cmd);
assert(download_success);
set visitedLeafs;
@@ -383,13 +383,13 @@ void wiGPUBVH::Build(const Scene& scene, CommandList cmd) const
// Validate flag buffer:
readback_desc = bvhFlagBuffer.GetDesc();
- readback_desc.Usage = USAGE_STAGING;
+ readback_desc.usage = USAGE_STAGING;
readback_desc.CPUAccessFlags = CPU_ACCESS_READ;
- readback_desc.BindFlags = 0;
+ readback_desc.bind_flags = 0;
readback_desc.Flags = 0;
GPUBuffer readback_flagBuffer;
device->CreateBuffer(&readback_desc, nullptr, &readback_flagBuffer);
- vector flags(readback_desc.Size / sizeof(uint));
+ vector flags(readback_desc.size / sizeof(uint));
download_success = device->DownloadResource(&bvhFlagBuffer, &readback_flagBuffer, flags.data(), cmd);
assert(download_success);
for (auto& x : flags)
@@ -415,9 +415,9 @@ namespace wiGPUBVH_Internal
{
void LoadShaders()
{
- wiRenderer::LoadShader(CS, computeShaders[CSTYPE_BVH_PRIMITIVES], "bvh_primitivesCS.cso");
- wiRenderer::LoadShader(CS, computeShaders[CSTYPE_BVH_HIERARCHY], "bvh_hierarchyCS.cso");
- wiRenderer::LoadShader(CS, computeShaders[CSTYPE_BVH_PROPAGATEAABB], "bvh_propagateaabbCS.cso");
+ wiRenderer::LoadShader(ShaderStage::CS, computeShaders[CSTYPE_BVH_PRIMITIVES], "bvh_primitivesCS.cso");
+ wiRenderer::LoadShader(ShaderStage::CS, computeShaders[CSTYPE_BVH_HIERARCHY], "bvh_hierarchyCS.cso");
+ wiRenderer::LoadShader(ShaderStage::CS, computeShaders[CSTYPE_BVH_PROPAGATEAABB], "bvh_propagateaabbCS.cso");
}
}
diff --git a/WickedEngine/wiGPUSortLib.cpp b/WickedEngine/wiGPUSortLib.cpp
index 6118aff18..07125a681 100644
--- a/WickedEngine/wiGPUSortLib.cpp
+++ b/WickedEngine/wiGPUSortLib.cpp
@@ -19,12 +19,10 @@ namespace wiGPUSortLib
void LoadShaders()
{
- std::string path = wiRenderer::GetShaderPath();
-
- wiRenderer::LoadShader(CS, kickoffSortCS, "gpusortlib_kickoffSortCS.cso");
- wiRenderer::LoadShader(CS, sortCS, "gpusortlib_sortCS.cso");
- wiRenderer::LoadShader(CS, sortInnerCS, "gpusortlib_sortInnerCS.cso");
- wiRenderer::LoadShader(CS, sortStepCS, "gpusortlib_sortStepCS.cso");
+ wiRenderer::LoadShader(ShaderStage::CS, kickoffSortCS, "gpusortlib_kickoffSortCS.cso");
+ wiRenderer::LoadShader(ShaderStage::CS, sortCS, "gpusortlib_sortCS.cso");
+ wiRenderer::LoadShader(ShaderStage::CS, sortInnerCS, "gpusortlib_sortInnerCS.cso");
+ wiRenderer::LoadShader(ShaderStage::CS, sortStepCS, "gpusortlib_sortStepCS.cso");
}
@@ -33,11 +31,11 @@ namespace wiGPUSortLib
wiTimer timer;
GPUBufferDesc bd;
- bd.Usage = USAGE_DEFAULT;
- bd.BindFlags = BIND_UNORDERED_ACCESS;
- bd.MiscFlags = RESOURCE_MISC_INDIRECT_ARGS | RESOURCE_MISC_BUFFER_RAW;
- bd.Size = sizeof(IndirectDispatchArgs);
- wiRenderer::GetDevice()->CreateBuffer(&bd, nullptr, &indirectBuffer);
+ bd.usage = Usage::DEFAULT;
+ bd.bind_flags = BindFlag::UNORDERED_ACCESS;
+ bd.misc_flags = ResourceMiscFlag::INDIRECT_ARGS | ResourceMiscFlag::BUFFER_RAW;
+ bd.size = sizeof(IndirectDispatchArgs);
+ wiGraphics::GetDevice()->CreateBuffer(&bd, nullptr, &indirectBuffer);
static wiEvent::Handle handle = wiEvent::Subscribe(SYSTEM_EVENT_RELOAD_SHADERS, [](uint64_t userdata) { LoadShaders(); });
LoadShaders();
@@ -54,7 +52,7 @@ namespace wiGPUSortLib
const GPUBuffer& indexBuffer_write,
CommandList cmd)
{
- GraphicsDevice* device = wiRenderer::GetDevice();
+ GraphicsDevice* device = wiGraphics::GetDevice();
device->EventBegin("GPUSortLib", cmd);
@@ -79,7 +77,7 @@ namespace wiGPUSortLib
{
GPUBarrier barriers[] = {
- GPUBarrier::Buffer(&indirectBuffer, RESOURCE_STATE_INDIRECT_ARGUMENT, RESOURCE_STATE_UNORDERED_ACCESS)
+ GPUBarrier::Buffer(&indirectBuffer, ResourceState::INDIRECT_ARGUMENT, ResourceState::UNORDERED_ACCESS)
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
@@ -89,7 +87,7 @@ namespace wiGPUSortLib
{
GPUBarrier barriers[] = {
GPUBarrier::Memory(),
- GPUBarrier::Buffer(&indirectBuffer, RESOURCE_STATE_UNORDERED_ACCESS, RESOURCE_STATE_INDIRECT_ARGUMENT)
+ GPUBarrier::Buffer(&indirectBuffer, ResourceState::UNORDERED_ACCESS, ResourceState::INDIRECT_ARGUMENT)
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
diff --git a/WickedEngine/wiGUI.cpp b/WickedEngine/wiGUI.cpp
index 527557f07..5bc3175a7 100644
--- a/WickedEngine/wiGUI.cpp
+++ b/WickedEngine/wiGUI.cpp
@@ -1,5 +1,4 @@
#include "wiGUI.h"
-#include "wiRenderer.h"
#include "wiInput.h"
#include "wiIntersect.h"
#include "wiProfiler.h"
@@ -75,7 +74,7 @@ void wiGUI::Render(const wiCanvas& canvas, CommandList cmd) const
scissorRect.right = (int32_t)(canvas.GetPhysicalWidth());
scissorRect.top = (int32_t)(0);
- GraphicsDevice* device = wiRenderer::GetDevice();
+ GraphicsDevice* device = wiGraphics::GetDevice();
device->EventBegin("GUI", cmd);
// Rendering is back to front:
diff --git a/WickedEngine/wiGraphics.h b/WickedEngine/wiGraphics.h
index fab8b7c7b..2b7ab66c9 100644
--- a/WickedEngine/wiGraphics.h
+++ b/WickedEngine/wiGraphics.h
@@ -13,41 +13,41 @@ namespace wiGraphics
struct GPUBuffer;
struct Texture;
- enum SHADERSTAGE
+ enum class ShaderStage
{
- MS,
- AS,
- VS,
- HS,
- DS,
- GS,
- PS,
- CS,
- LIB,
- SHADERSTAGE_COUNT,
+ MS, // Mesh Shader
+ AS, // Amplification Shader
+ VS, // Vertex Shader
+ HS, // Hull Shader
+ DS, // Domain Shader
+ GS, // Geometry Shader
+ PS, // Pixel Shader
+ CS, // Compute Shader
+ LIB, // Shader Library
+ Count,
};
- enum SHADERFORMAT
+ enum class ShaderFormat
{
- SHADERFORMAT_NONE,
- SHADERFORMAT_HLSL5,
- SHADERFORMAT_HLSL6,
- SHADERFORMAT_SPIRV,
+ NONE, // Not used
+ HLSL5, // DXBC
+ HLSL6, // DXIL
+ SPIRV, // SPIR-V
};
- enum SHADERMODEL
+ enum class ShaderModel
{
- SHADERMODEL_5_0,
- SHADERMODEL_6_0,
- SHADERMODEL_6_1,
- SHADERMODEL_6_2,
- SHADERMODEL_6_3,
- SHADERMODEL_6_4,
- SHADERMODEL_6_5,
- SHADERMODEL_6_6,
- SHADERMODEL_6_7,
+ SM_5_0,
+ SM_6_0,
+ SM_6_1,
+ SM_6_2,
+ SM_6_3,
+ SM_6_4,
+ SM_6_5,
+ SM_6_6,
+ SM_6_7,
};
- enum PRIMITIVETOPOLOGY
+ enum class PrimitiveTopology
{
- UNDEFINED_TOPOLOGY,
+ UNDEFINED,
TRIANGLELIST,
TRIANGLESTRIP,
POINTLIST,
@@ -55,227 +55,227 @@ namespace wiGraphics
LINESTRIP,
PATCHLIST,
};
- enum COMPARISON_FUNC
+ enum class ComparisonFunc
{
- COMPARISON_NEVER,
- COMPARISON_LESS,
- COMPARISON_EQUAL,
- COMPARISON_LESS_EQUAL,
- COMPARISON_GREATER,
- COMPARISON_NOT_EQUAL,
- COMPARISON_GREATER_EQUAL,
- COMPARISON_ALWAYS,
+ NEVER,
+ LESS,
+ EQUAL,
+ LESS_EQUAL,
+ GREATER,
+ NOT_EQUAL,
+ GREATER_EQUAL,
+ ALWAYS,
};
- enum DEPTH_WRITE_MASK
+ enum class DepthWriteMask
{
- DEPTH_WRITE_MASK_ZERO,
- DEPTH_WRITE_MASK_ALL,
+ ZERO, // Disables depth write
+ ALL, // Enables depth write
};
- enum STENCIL_OP
+ enum class StencilOp
{
- STENCIL_OP_KEEP,
- STENCIL_OP_ZERO,
- STENCIL_OP_REPLACE,
- STENCIL_OP_INCR_SAT,
- STENCIL_OP_DECR_SAT,
- STENCIL_OP_INVERT,
- STENCIL_OP_INCR,
- STENCIL_OP_DECR,
+ KEEP,
+ ZERO,
+ REPLACE,
+ INCR_SAT,
+ DECR_SAT,
+ INVERT,
+ INCR,
+ DECR,
};
- enum BLEND
+ enum class Blend
{
- BLEND_ZERO,
- BLEND_ONE,
- BLEND_SRC_COLOR,
- BLEND_INV_SRC_COLOR,
- BLEND_SRC_ALPHA,
- BLEND_INV_SRC_ALPHA,
- BLEND_DEST_ALPHA,
- BLEND_INV_DEST_ALPHA,
- BLEND_DEST_COLOR,
- BLEND_INV_DEST_COLOR,
- BLEND_SRC_ALPHA_SAT,
- BLEND_BLEND_FACTOR,
- BLEND_INV_BLEND_FACTOR,
- BLEND_SRC1_COLOR,
- BLEND_INV_SRC1_COLOR,
- BLEND_SRC1_ALPHA,
- BLEND_INV_SRC1_ALPHA,
+ ZERO,
+ ONE,
+ SRC_COLOR,
+ INV_SRC_COLOR,
+ SRC_ALPHA,
+ INV_SRC_ALPHA,
+ DEST_ALPHA,
+ INV_DEST_ALPHA,
+ DEST_COLOR,
+ INV_DEST_COLOR,
+ SRC_ALPHA_SAT,
+ BLEND_FACTOR,
+ INV_BLEND_FACTOR,
+ SRC1_COLOR,
+ INV_SRC1_COLOR,
+ SRC1_ALPHA,
+ INV_SRC1_ALPHA,
};
- enum BLEND_OP
+ enum class BlendOp
{
- BLEND_OP_ADD,
- BLEND_OP_SUBTRACT,
- BLEND_OP_REV_SUBTRACT,
- BLEND_OP_MIN,
- BLEND_OP_MAX,
+ ADD,
+ SUBTRACT,
+ REV_SUBTRACT,
+ MIN,
+ MAX,
};
- enum FILL_MODE
+ enum class FillMode
{
- FILL_WIREFRAME,
- FILL_SOLID,
+ WIREFRAME,
+ SOLID,
};
- enum CULL_MODE
+ enum class CullMode
{
- CULL_NONE,
- CULL_FRONT,
- CULL_BACK,
+ NONE,
+ FRONT,
+ BACK,
};
- enum INPUT_CLASSIFICATION
+ enum class InputClassification
{
- INPUT_PER_VERTEX_DATA,
- INPUT_PER_INSTANCE_DATA,
+ PER_VERTEX_DATA,
+ PER_INSTANCE_DATA,
};
- enum USAGE
+ enum class Usage
{
- USAGE_DEFAULT, // CPU no access, GPU read/write
- USAGE_UPLOAD, // CPU write, GPU read
- USAGE_READBACK, // CPU read, GPU write
+ DEFAULT, // CPU no access, GPU read/write
+ UPLOAD, // CPU write, GPU read
+ READBACK, // CPU read, GPU write
};
- enum TEXTURE_ADDRESS_MODE
+ enum class TextureAddressMode
{
- TEXTURE_ADDRESS_WRAP,
- TEXTURE_ADDRESS_MIRROR,
- TEXTURE_ADDRESS_CLAMP,
- TEXTURE_ADDRESS_BORDER,
- TEXTURE_ADDRESS_MIRROR_ONCE,
+ WRAP,
+ MIRROR,
+ CLAMP,
+ BORDER,
+ MIRROR_ONCE,
};
- enum FILTER
+ enum class Filter
{
- FILTER_MIN_MAG_MIP_POINT,
- FILTER_MIN_MAG_POINT_MIP_LINEAR,
- FILTER_MIN_POINT_MAG_LINEAR_MIP_POINT,
- FILTER_MIN_POINT_MAG_MIP_LINEAR,
- FILTER_MIN_LINEAR_MAG_MIP_POINT,
- FILTER_MIN_LINEAR_MAG_POINT_MIP_LINEAR,
- FILTER_MIN_MAG_LINEAR_MIP_POINT,
- FILTER_MIN_MAG_MIP_LINEAR,
- FILTER_ANISOTROPIC,
- FILTER_COMPARISON_MIN_MAG_MIP_POINT,
- FILTER_COMPARISON_MIN_MAG_POINT_MIP_LINEAR,
- FILTER_COMPARISON_MIN_POINT_MAG_LINEAR_MIP_POINT,
- FILTER_COMPARISON_MIN_POINT_MAG_MIP_LINEAR,
- FILTER_COMPARISON_MIN_LINEAR_MAG_MIP_POINT,
- FILTER_COMPARISON_MIN_LINEAR_MAG_POINT_MIP_LINEAR,
- FILTER_COMPARISON_MIN_MAG_LINEAR_MIP_POINT,
- FILTER_COMPARISON_MIN_MAG_MIP_LINEAR,
- FILTER_COMPARISON_ANISOTROPIC,
- FILTER_MINIMUM_MIN_MAG_MIP_POINT,
- FILTER_MINIMUM_MIN_MAG_POINT_MIP_LINEAR,
- FILTER_MINIMUM_MIN_POINT_MAG_LINEAR_MIP_POINT,
- FILTER_MINIMUM_MIN_POINT_MAG_MIP_LINEAR,
- FILTER_MINIMUM_MIN_LINEAR_MAG_MIP_POINT,
- FILTER_MINIMUM_MIN_LINEAR_MAG_POINT_MIP_LINEAR,
- FILTER_MINIMUM_MIN_MAG_LINEAR_MIP_POINT,
- FILTER_MINIMUM_MIN_MAG_MIP_LINEAR,
- FILTER_MINIMUM_ANISOTROPIC,
- FILTER_MAXIMUM_MIN_MAG_MIP_POINT,
- FILTER_MAXIMUM_MIN_MAG_POINT_MIP_LINEAR,
- FILTER_MAXIMUM_MIN_POINT_MAG_LINEAR_MIP_POINT,
- FILTER_MAXIMUM_MIN_POINT_MAG_MIP_LINEAR,
- FILTER_MAXIMUM_MIN_LINEAR_MAG_MIP_POINT,
- FILTER_MAXIMUM_MIN_LINEAR_MAG_POINT_MIP_LINEAR,
- FILTER_MAXIMUM_MIN_MAG_LINEAR_MIP_POINT,
- FILTER_MAXIMUM_MIN_MAG_MIP_LINEAR,
- FILTER_MAXIMUM_ANISOTROPIC,
+ MIN_MAG_MIP_POINT,
+ MIN_MAG_POINT_MIP_LINEAR,
+ MIN_POINT_MAG_LINEAR_MIP_POINT,
+ MIN_POINT_MAG_MIP_LINEAR,
+ MIN_LINEAR_MAG_MIP_POINT,
+ MIN_LINEAR_MAG_POINT_MIP_LINEAR,
+ MIN_MAG_LINEAR_MIP_POINT,
+ MIN_MAG_MIP_LINEAR,
+ ANISOTROPIC,
+ COMPARISON_MIN_MAG_MIP_POINT,
+ COMPARISON_MIN_MAG_POINT_MIP_LINEAR,
+ COMPARISON_MIN_POINT_MAG_LINEAR_MIP_POINT,
+ COMPARISON_MIN_POINT_MAG_MIP_LINEAR,
+ COMPARISON_MIN_LINEAR_MAG_MIP_POINT,
+ COMPARISON_MIN_LINEAR_MAG_POINT_MIP_LINEAR,
+ COMPARISON_MIN_MAG_LINEAR_MIP_POINT,
+ COMPARISON_MIN_MAG_MIP_LINEAR,
+ COMPARISON_ANISOTROPIC,
+ MINIMUM_MIN_MAG_MIP_POINT,
+ MINIMUM_MIN_MAG_POINT_MIP_LINEAR,
+ MINIMUM_MIN_POINT_MAG_LINEAR_MIP_POINT,
+ MINIMUM_MIN_POINT_MAG_MIP_LINEAR,
+ MINIMUM_MIN_LINEAR_MAG_MIP_POINT,
+ MINIMUM_MIN_LINEAR_MAG_POINT_MIP_LINEAR,
+ MINIMUM_MIN_MAG_LINEAR_MIP_POINT,
+ MINIMUM_MIN_MAG_MIP_LINEAR,
+ MINIMUM_ANISOTROPIC,
+ MAXIMUM_MIN_MAG_MIP_POINT,
+ MAXIMUM_MIN_MAG_POINT_MIP_LINEAR,
+ MAXIMUM_MIN_POINT_MAG_LINEAR_MIP_POINT,
+ MAXIMUM_MIN_POINT_MAG_MIP_LINEAR,
+ MAXIMUM_MIN_LINEAR_MAG_MIP_POINT,
+ MAXIMUM_MIN_LINEAR_MAG_POINT_MIP_LINEAR,
+ MAXIMUM_MIN_MAG_LINEAR_MIP_POINT,
+ MAXIMUM_MIN_MAG_MIP_LINEAR,
+ MAXIMUM_ANISOTROPIC,
};
- enum SAMPLER_BORDER_COLOR
+ enum class SamplerBorderColor
{
- SAMPLER_BORDER_COLOR_TRANSPARENT_BLACK,
- SAMPLER_BORDER_COLOR_OPAQUE_BLACK,
- SAMPLER_BORDER_COLOR_OPAQUE_WHITE,
+ TRANSPARENT_BLACK,
+ OPAQUE_BLACK,
+ OPAQUE_WHITE,
};
- enum FORMAT
+ enum class Format
{
- FORMAT_UNKNOWN,
+ UNKNOWN,
- FORMAT_R32G32B32A32_FLOAT,
- FORMAT_R32G32B32A32_UINT,
- FORMAT_R32G32B32A32_SINT,
+ R32G32B32A32_FLOAT,
+ R32G32B32A32_UINT,
+ R32G32B32A32_SINT,
- FORMAT_R32G32B32_FLOAT,
- FORMAT_R32G32B32_UINT,
- FORMAT_R32G32B32_SINT,
+ R32G32B32_FLOAT,
+ R32G32B32_UINT,
+ R32G32B32_SINT,
- FORMAT_R16G16B16A16_FLOAT,
- FORMAT_R16G16B16A16_UNORM,
- FORMAT_R16G16B16A16_UINT,
- FORMAT_R16G16B16A16_SNORM,
- FORMAT_R16G16B16A16_SINT,
+ R16G16B16A16_FLOAT,
+ R16G16B16A16_UNORM,
+ R16G16B16A16_UINT,
+ R16G16B16A16_SNORM,
+ R16G16B16A16_SINT,
- FORMAT_R32G32_FLOAT,
- FORMAT_R32G32_UINT,
- FORMAT_R32G32_SINT,
- FORMAT_R32G8X24_TYPELESS, // depth (32-bit) + stencil (8-bit) + shader resource (32-bit)
- FORMAT_D32_FLOAT_S8X24_UINT, // depth (32-bit) + stencil (8-bit)
+ R32G32_FLOAT,
+ R32G32_UINT,
+ R32G32_SINT,
+ R32G8X24_TYPELESS, // depth (32-bit) + stencil (8-bit) + shader resource (32-bit)
+ D32_FLOAT_S8X24_UINT, // depth (32-bit) + stencil (8-bit)
- FORMAT_R10G10B10A2_UNORM,
- FORMAT_R10G10B10A2_UINT,
- FORMAT_R11G11B10_FLOAT,
- FORMAT_R8G8B8A8_UNORM,
- FORMAT_R8G8B8A8_UNORM_SRGB,
- FORMAT_R8G8B8A8_UINT,
- FORMAT_R8G8B8A8_SNORM,
- FORMAT_R8G8B8A8_SINT,
- FORMAT_B8G8R8A8_UNORM,
- FORMAT_B8G8R8A8_UNORM_SRGB,
- FORMAT_R16G16_FLOAT,
- FORMAT_R16G16_UNORM,
- FORMAT_R16G16_UINT,
- FORMAT_R16G16_SNORM,
- FORMAT_R16G16_SINT,
- FORMAT_R32_TYPELESS, // depth (32-bit) + shader resource (32-bit)
- FORMAT_D32_FLOAT, // depth (32-bit)
- FORMAT_R32_FLOAT,
- FORMAT_R32_UINT,
- FORMAT_R32_SINT,
- FORMAT_R24G8_TYPELESS, // depth (24-bit) + stencil (8-bit) + shader resource (24-bit)
- FORMAT_D24_UNORM_S8_UINT, // depth (24-bit) + stencil (8-bit)
+ R10G10B10A2_UNORM,
+ R10G10B10A2_UINT,
+ R11G11B10_FLOAT,
+ R8G8B8A8_UNORM,
+ R8G8B8A8_UNORM_SRGB,
+ R8G8B8A8_UINT,
+ R8G8B8A8_SNORM,
+ R8G8B8A8_SINT,
+ B8G8R8A8_UNORM,
+ B8G8R8A8_UNORM_SRGB,
+ R16G16_FLOAT,
+ R16G16_UNORM,
+ R16G16_UINT,
+ R16G16_SNORM,
+ R16G16_SINT,
+ R32_TYPELESS, // depth (32-bit) + shader resource (32-bit)
+ D32_FLOAT, // depth (32-bit)
+ R32_FLOAT,
+ R32_UINT,
+ R32_SINT,
+ R24G8_TYPELESS, // depth (24-bit) + stencil (8-bit) + shader resource (24-bit)
+ D24_UNORM_S8_UINT, // depth (24-bit) + stencil (8-bit)
- FORMAT_R8G8_UNORM,
- FORMAT_R8G8_UINT,
- FORMAT_R8G8_SNORM,
- FORMAT_R8G8_SINT,
- FORMAT_R16_TYPELESS, // depth (16-bit) + shader resource (16-bit)
- FORMAT_R16_FLOAT,
- FORMAT_D16_UNORM, // depth (16-bit)
- FORMAT_R16_UNORM,
- FORMAT_R16_UINT,
- FORMAT_R16_SNORM,
- FORMAT_R16_SINT,
+ R8G8_UNORM,
+ R8G8_UINT,
+ R8G8_SNORM,
+ R8G8_SINT,
+ R16_TYPELESS, // depth (16-bit) + shader resource (16-bit)
+ R16_FLOAT,
+ D16_UNORM, // depth (16-bit)
+ R16_UNORM,
+ R16_UINT,
+ R16_SNORM,
+ R16_SINT,
- FORMAT_R8_UNORM,
- FORMAT_R8_UINT,
- FORMAT_R8_SNORM,
- FORMAT_R8_SINT,
+ R8_UNORM,
+ R8_UINT,
+ R8_SNORM,
+ R8_SINT,
- FORMAT_BC1_UNORM,
- FORMAT_BC1_UNORM_SRGB,
- FORMAT_BC2_UNORM,
- FORMAT_BC2_UNORM_SRGB,
- FORMAT_BC3_UNORM,
- FORMAT_BC3_UNORM_SRGB,
- FORMAT_BC4_UNORM,
- FORMAT_BC4_SNORM,
- FORMAT_BC5_UNORM,
- FORMAT_BC5_SNORM,
- FORMAT_BC6H_UF16,
- FORMAT_BC6H_SF16,
- FORMAT_BC7_UNORM,
- FORMAT_BC7_UNORM_SRGB
+ BC1_UNORM,
+ BC1_UNORM_SRGB,
+ BC2_UNORM,
+ BC2_UNORM_SRGB,
+ BC3_UNORM,
+ BC3_UNORM_SRGB,
+ BC4_UNORM,
+ BC4_SNORM,
+ BC5_UNORM,
+ BC5_SNORM,
+ BC6H_UF16,
+ BC6H_SF16,
+ BC7_UNORM,
+ BC7_UNORM_SRGB
};
- enum GPU_QUERY_TYPE
+ enum class GpuQueryType
{
- GPU_QUERY_TYPE_TIMESTAMP, // retrieve time point of gpu execution
- GPU_QUERY_TYPE_OCCLUSION, // how many samples passed depth test?
- GPU_QUERY_TYPE_OCCLUSION_BINARY, // depth test passed or not?
+ TIMESTAMP, // retrieve time point of gpu execution
+ OCCLUSION, // how many samples passed depth test?
+ OCCLUSION_BINARY, // depth test passed or not?
};
- enum INDEXBUFFER_FORMAT
+ enum class IndexBufferFormat
{
- INDEXFORMAT_16BIT,
- INDEXFORMAT_32BIT,
+ UINT16,
+ UINT32,
};
- enum SUBRESOURCE_TYPE
+ enum class SubresourceType
{
SRV, // shader resource view
UAV, // unordered access view
@@ -283,172 +283,139 @@ namespace wiGraphics
DSV, // depth stencil view
};
- enum SHADING_RATE
+ enum class ShadingRate
{
- SHADING_RATE_1X1,
- SHADING_RATE_1X2,
- SHADING_RATE_2X1,
- SHADING_RATE_2X2,
- SHADING_RATE_2X4,
- SHADING_RATE_4X2,
- SHADING_RATE_4X4,
+ RATE_1X1, // Default/full shading rate
+ RATE_1X2,
+ RATE_2X1,
+ RATE_2X2,
+ RATE_2X4,
+ RATE_4X2,
+ RATE_4X4,
- SHADING_RATE_INVALID
+ RATE_INVALID
};
- enum PREDICATION_OP
+ enum class PredicationOp
{
- PREDICATION_OP_EQUAL_ZERO,
- PREDICATION_OP_NOT_EQUAL_ZERO,
+ EQUAL_ZERO,
+ NOT_EQUAL_ZERO,
};
// 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 = false;
- };
- template
- typename std::enable_if::enable, E>::type operator|(E lhs, E rhs)
+ enum class ColorWrite
{
- 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;
+ DISABLE = 0,
+ ENABLE_RED = 1 << 0,
+ ENABLE_GREEN = 1 << 1,
+ ENABLE_BLUE = 1 << 2,
+ ENABLE_ALPHA = 1 << 3,
+ ENABLE_ALL = ~0,
};
- enum BIND_FLAG
+ enum class BindFlag
{
- BIND_NONE = 0,
- BIND_VERTEX_BUFFER = 1 << 0,
- BIND_INDEX_BUFFER = 1 << 1,
- BIND_CONSTANT_BUFFER = 1 << 2,
- BIND_SHADER_RESOURCE = 1 << 3,
- BIND_RENDER_TARGET = 1 << 4,
- BIND_DEPTH_STENCIL = 1 << 5,
- BIND_UNORDERED_ACCESS = 1 << 6,
- BIND_SHADING_RATE = 1 << 7,
- };
- template<>
- struct enable_bitmask_operators {
- static const bool enable = true;
+ NONE = 0,
+ VERTEX_BUFFER = 1 << 0,
+ INDEX_BUFFER = 1 << 1,
+ CONSTANT_BUFFER = 1 << 2,
+ SHADER_RESOURCE = 1 << 3,
+ RENDER_TARGET = 1 << 4,
+ DEPTH_STENCIL = 1 << 5,
+ UNORDERED_ACCESS = 1 << 6,
+ SHADING_RATE = 1 << 7,
};
- enum RESOURCE_MISC_FLAG
+ enum class ResourceMiscFlag
{
- 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,
- RESOURCE_MISC_PREDICATION = 1 << 5,
- };
- template<>
- struct enable_bitmask_operators {
- static const bool enable = true;
+ NONE = 0,
+ TEXTURECUBE = 1 << 0,
+ INDIRECT_ARGS = 1 << 1,
+ BUFFER_RAW = 1 << 2,
+ BUFFER_STRUCTURED = 1 << 3,
+ RAY_TRACING = 1 << 4,
+ PREDICATION = 1 << 5,
};
- enum GRAPHICSDEVICE_CAPABILITY
+ enum class GraphicsDeviceCapability
{
- GRAPHICSDEVICE_CAPABILITY_TESSELLATION = 1 << 0,
- GRAPHICSDEVICE_CAPABILITY_CONSERVATIVE_RASTERIZATION = 1 << 1,
- GRAPHICSDEVICE_CAPABILITY_RASTERIZER_ORDERED_VIEWS = 1 << 2,
- 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_VARIABLE_RATE_SHADING = 1 << 6,
- GRAPHICSDEVICE_CAPABILITY_VARIABLE_RATE_SHADING_TIER2 = 1 << 7,
- GRAPHICSDEVICE_CAPABILITY_MESH_SHADER = 1 << 8,
- GRAPHICSDEVICE_CAPABILITY_RAYTRACING = 1 << 9,
- GRAPHICSDEVICE_CAPABILITY_PREDICATION = 1 << 10,
- GRAPHICSDEVICE_CAPABILITY_SAMPLER_MINMAX = 1 << 11,
+ NONE = 0,
+ TESSELLATION = 1 << 0,
+ CONSERVATIVE_RASTERIZATION = 1 << 1,
+ RASTERIZER_ORDERED_VIEWS = 1 << 2,
+ UAV_LOAD_FORMAT_COMMON = 1 << 3, // eg: R16G16B16A16_FLOAT, R8G8B8A8_UNORM and more common ones
+ UAV_LOAD_FORMAT_R11G11B10_FLOAT = 1 << 4,
+ RENDERTARGET_AND_VIEWPORT_ARRAYINDEX_WITHOUT_GS = 1 << 5,
+ VARIABLE_RATE_SHADING = 1 << 6,
+ VARIABLE_RATE_SHADING_TIER2 = 1 << 7,
+ MESH_SHADER = 1 << 8,
+ RAYTRACING = 1 << 9,
+ PREDICATION = 1 << 10,
+ SAMPLER_MINMAX = 1 << 11,
};
- enum RESOURCE_STATE
+
+ enum class ResourceState
{
// 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
+ UNDEFINED = 0, // invalid state
+ SHADER_RESOURCE = 1 << 0, // shader resource, read only
+ SHADER_RESOURCE_COMPUTE = 1 << 1, // shader resource, read only, non-pixel shader
+ UNORDERED_ACCESS = 1 << 2, // shader resource, write enabled
+ COPY_SRC = 1 << 3, // copy from
+ 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
+ RENDERTARGET = 1 << 5, // render target, write enabled
+ DEPTHSTENCIL = 1 << 6, // depth stencil, write enabled
+ DEPTHSTENCIL_READONLY = 1 << 7, // depth stencil, read only
+ SHADING_RATE_SOURCE = 1 << 8, // shading rate control per tile
// 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
- RESOURCE_STATE_PREDICATION = 1 << 14 // storage for predication comparison value
- };
- template<>
- struct enable_bitmask_operators {
- static const bool enable = true;
+ VERTEX_BUFFER = 1 << 9, // vertex buffer, read only
+ INDEX_BUFFER = 1 << 10, // index buffer, read only
+ CONSTANT_BUFFER = 1 << 11, // constant buffer, read only
+ INDIRECT_ARGUMENT = 1 << 12, // argument buffer to DrawIndirect() or DispatchIndirect()
+ RAYTRACING_ACCELERATION_STRUCTURE = 1 << 13, // acceleration structure storage or scratch
+ PREDICATION = 1 << 14 // storage for predication comparison value
};
- enum COLOR_SPACE
+ enum class ColorSpace
{
- COLOR_SPACE_SRGB, // SDR color space (8 or 10 bits per channel)
- COLOR_SPACE_HDR10_ST2084, // HDR10 color space (10 bits per channel)
- COLOR_SPACE_HDR_LINEAR, // HDR color space (16 bits per channel)
+ SRGB, // SDR color space (8 or 10 bits per channel)
+ HDR10_ST2084, // HDR10 color space (10 bits per channel)
+ HDR_LINEAR, // HDR color space (16 bits per channel)
};
+
// Descriptor structs:
struct Viewport
{
- float TopLeftX = 0.0f;
- float TopLeftY = 0.0f;
- float Width = 0.0f;
- float Height = 0.0f;
- float MinDepth = 0.0f;
- float MaxDepth = 1.0f;
+ float top_left_x = 0;
+ float top_left_y = 0;
+ float width = 0;
+ float height = 0;
+ float min_depth = 0;
+ float max_depth = 1;
};
+
struct InputLayout
{
- static const uint32_t APPEND_ALIGNED_ELEMENT = 0xffffffff; // automatically figure out AlignedByteOffset depending on Format
+ static const uint32_t APPEND_ALIGNED_ELEMENT = ~0u; // automatically figure out AlignedByteOffset depending on Format
struct Element
{
- std::string SemanticName;
- uint32_t SemanticIndex = 0;
- FORMAT Format = FORMAT_UNKNOWN;
- uint32_t InputSlot = 0;
- uint32_t AlignedByteOffset = APPEND_ALIGNED_ELEMENT;
- INPUT_CLASSIFICATION InputSlotClass = INPUT_CLASSIFICATION::INPUT_PER_VERTEX_DATA;
+ std::string semantic_name;
+ uint32_t semantic_index = 0;
+ Format format = Format::UNKNOWN;
+ uint32_t input_slot = 0;
+ uint32_t aligned_byte_offset = APPEND_ALIGNED_ELEMENT;
+ InputClassification input_slot_class = InputClassification::PER_VERTEX_DATA;
};
std::vector elements;
};
+
union ClearValue
{
float color[4];
@@ -456,107 +423,115 @@ namespace wiGraphics
{
float depth;
uint32_t stencil;
- } depthstencil;
+ } depth_stencil;
};
+
struct TextureDesc
{
- enum TEXTURE_TYPE
+ enum class Type
{
TEXTURE_1D,
TEXTURE_2D,
TEXTURE_3D,
- } type = TEXTURE_2D;
- uint32_t Width = 0;
- uint32_t Height = 0;
- uint32_t Depth = 0;
- uint32_t ArraySize = 1;
- uint32_t MipLevels = 1;
- FORMAT Format = FORMAT_UNKNOWN;
- uint32_t SampleCount = 1;
- USAGE Usage = USAGE_DEFAULT;
- BIND_FLAG BindFlags = BIND_NONE;
- RESOURCE_MISC_FLAG MiscFlags = RESOURCE_MISC_NONE;
+ } type = Type::TEXTURE_2D;
+ uint32_t width = 0;
+ uint32_t height = 0;
+ uint32_t depth = 0;
+ uint32_t array_size = 1;
+ uint32_t mip_levels = 1;
+ Format format = Format::UNKNOWN;
+ uint32_t sample_count = 1;
+ Usage usage = Usage::DEFAULT;
+ BindFlag bind_flags = BindFlag::NONE;
+ ResourceMiscFlag misc_flags = ResourceMiscFlag::NONE;
ClearValue clear = {};
- RESOURCE_STATE layout = RESOURCE_STATE_SHADER_RESOURCE;
+ ResourceState layout = ResourceState::SHADER_RESOURCE;
};
+
struct SamplerDesc
{
- FILTER Filter = FILTER_MIN_MAG_MIP_POINT;
- TEXTURE_ADDRESS_MODE AddressU = TEXTURE_ADDRESS_CLAMP;
- TEXTURE_ADDRESS_MODE AddressV = TEXTURE_ADDRESS_CLAMP;
- TEXTURE_ADDRESS_MODE AddressW = TEXTURE_ADDRESS_CLAMP;
- float MipLODBias = 0.0f;
- uint32_t MaxAnisotropy = 0;
- COMPARISON_FUNC ComparisonFunc = COMPARISON_NEVER;
- SAMPLER_BORDER_COLOR BorderColor = SAMPLER_BORDER_COLOR_TRANSPARENT_BLACK;
- float MinLOD = 0.0f;
- float MaxLOD = FLT_MAX;
+ Filter filter = Filter::MIN_MAG_MIP_POINT;
+ TextureAddressMode address_u = TextureAddressMode::CLAMP;
+ TextureAddressMode address_v = TextureAddressMode::CLAMP;
+ TextureAddressMode address_w = TextureAddressMode::CLAMP;
+ float mip_lod_bias = 0;
+ uint32_t max_anisotropy = 0;
+ ComparisonFunc comparison_func = ComparisonFunc::NEVER;
+ SamplerBorderColor border_color = SamplerBorderColor::TRANSPARENT_BLACK;
+ float min_lod = 0;
+ float max_lod = FLT_MAX;
};
+
struct RasterizerState
{
- FILL_MODE FillMode = FILL_SOLID;
- CULL_MODE CullMode = CULL_NONE;
- bool FrontCounterClockwise = false;
- int32_t DepthBias = 0;
- float DepthBiasClamp = 0.0f;
- float SlopeScaledDepthBias = 0.0f;
- bool DepthClipEnable = false;
- bool MultisampleEnable = false;
- bool AntialiasedLineEnable = false;
- bool ConservativeRasterizationEnable = false;
- uint32_t ForcedSampleCount = 0;
+ FillMode fill_mode = FillMode::SOLID;
+ CullMode cull_mode = CullMode::NONE;
+ bool front_counter_clockwise = false;
+ int32_t depth_bias = 0;
+ float depth_bias_clamp = 0;
+ float slope_scaled_depth_bias = 0;
+ bool depth_clip_enable = false;
+ bool multisample_enable = false;
+ bool antialiased_line_enable = false;
+ bool conservative_rasterization_enable = false;
+ uint32_t forced_sample_count = 0;
};
+
struct DepthStencilState
{
- bool DepthEnable = false;
- DEPTH_WRITE_MASK DepthWriteMask = DEPTH_WRITE_MASK_ZERO;
- COMPARISON_FUNC DepthFunc = COMPARISON_NEVER;
- bool StencilEnable = false;
- uint8_t StencilReadMask = 0xff;
- uint8_t StencilWriteMask = 0xff;
+ bool depth_enable = false;
+ DepthWriteMask depth_write_mask = DepthWriteMask::ZERO;
+ ComparisonFunc depth_func = ComparisonFunc::NEVER;
+ bool stencil_enable = false;
+ uint8_t stencil_read_mask = 0xff;
+ uint8_t stencil_write_mask = 0xff;
struct DepthStencilOp
{
- STENCIL_OP StencilFailOp = STENCIL_OP_KEEP;
- STENCIL_OP StencilDepthFailOp = STENCIL_OP_KEEP;
- STENCIL_OP StencilPassOp = STENCIL_OP_KEEP;
- COMPARISON_FUNC StencilFunc = COMPARISON_NEVER;
+ StencilOp stencil_fail_op = StencilOp::KEEP;
+ StencilOp stencil_depth_fail_op = StencilOp::KEEP;
+ StencilOp stencil_pass_op = StencilOp::KEEP;
+ ComparisonFunc stencil_func = ComparisonFunc::NEVER;
};
- DepthStencilOp FrontFace;
- DepthStencilOp BackFace;
+ DepthStencilOp front_face;
+ DepthStencilOp back_face;
};
+
struct BlendState
{
- bool AlphaToCoverageEnable = false;
- bool IndependentBlendEnable = false;
+ bool alpha_to_coverage_enable = false;
+ bool independent_blend_enable = false;
struct RenderTargetBlendState
{
- bool BlendEnable = false;
- BLEND SrcBlend = BLEND_SRC_ALPHA;
- BLEND DestBlend = BLEND_INV_SRC_ALPHA;
- BLEND_OP BlendOp = BLEND_OP_ADD;
- BLEND SrcBlendAlpha = BLEND_ONE;
- BLEND DestBlendAlpha = BLEND_ONE;
- BLEND_OP BlendOpAlpha = BLEND_OP_ADD;
- COLOR_WRITE_ENABLE RenderTargetWriteMask = COLOR_WRITE_ENABLE_ALL;
+ bool blend_enable = false;
+ Blend src_blend = Blend::SRC_ALPHA;
+ Blend dest_blend = Blend::INV_SRC_ALPHA;
+ BlendOp blend_op = BlendOp::ADD;
+ Blend src_blend_alpha = Blend::ONE;
+ Blend dest_blend_alpha = Blend::ONE;
+ BlendOp blend_op_alpha = BlendOp::ADD;
+ ColorWrite render_target_write_mask = ColorWrite::ENABLE_ALL;
};
- RenderTargetBlendState RenderTarget[8];
+ RenderTargetBlendState render_target[8];
};
+
struct GPUBufferDesc
{
- uint64_t Size = 0;
- USAGE Usage = USAGE_DEFAULT;
- BIND_FLAG BindFlags = BIND_NONE;
- RESOURCE_MISC_FLAG MiscFlags = RESOURCE_MISC_NONE;
- uint32_t Stride = 0; // needed for typed and structured buffer types!
- FORMAT Format = FORMAT_UNKNOWN; // only needed for typed buffer!
+ uint64_t size = 0;
+ Usage usage = Usage::DEFAULT;
+ BindFlag bind_flags = BindFlag::NONE;
+ ResourceMiscFlag misc_flags = ResourceMiscFlag::NONE;
+ uint32_t stride = 0; // needed for typed and structured buffer types!
+ Format format = Format::UNKNOWN; // only needed for typed buffer!
};
+
struct GPUQueryHeapDesc
{
- GPU_QUERY_TYPE type = GPU_QUERY_TYPE_TIMESTAMP;
- uint32_t queryCount = 0;
+ GpuQueryType type = GpuQueryType::TIMESTAMP;
+ uint32_t query_count = 0;
};
+
struct PipelineStateDesc
{
const Shader* vs = nullptr;
@@ -570,18 +545,19 @@ namespace wiGraphics
const RasterizerState* rs = nullptr;
const DepthStencilState* dss = nullptr;
const InputLayout* il = nullptr;
- PRIMITIVETOPOLOGY pt = TRIANGLELIST;
- uint32_t patchControlPoints = 3;
- uint32_t sampleMask = 0xFFFFFFFF;
+ PrimitiveTopology pt = PrimitiveTopology::TRIANGLELIST;
+ uint32_t patch_control_points = 3;
+ uint32_t sample_mask = 0xFFFFFFFF;
};
+
struct GPUBarrier
{
- enum TYPE
+ enum class Type
{
- MEMORY_BARRIER, // UAV accesses
- IMAGE_BARRIER, // image layout transition
- BUFFER_BARRIER, // buffer state transition
- } type = MEMORY_BARRIER;
+ MEMORY, // UAV accesses
+ IMAGE, // image layout transition
+ BUFFER, // buffer state transition
+ } type = Type::MEMORY;
struct Memory
{
@@ -590,16 +566,16 @@ namespace wiGraphics
struct Image
{
const Texture* texture;
- RESOURCE_STATE layout_before;
- RESOURCE_STATE layout_after;
+ ResourceState layout_before;
+ ResourceState layout_after;
int mip;
int slice;
};
struct Buffer
{
const GPUBuffer* buffer;
- RESOURCE_STATE state_before;
- RESOURCE_STATE state_after;
+ ResourceState state_before;
+ ResourceState state_after;
};
union
{
@@ -611,15 +587,15 @@ namespace wiGraphics
static GPUBarrier Memory(const GPUResource* resource = nullptr)
{
GPUBarrier barrier;
- barrier.type = MEMORY_BARRIER;
+ barrier.type = Type::MEMORY;
barrier.memory.resource = resource;
return barrier;
}
- static GPUBarrier Image(const Texture* texture, RESOURCE_STATE before, RESOURCE_STATE after,
+ static GPUBarrier Image(const Texture* texture, ResourceState before, ResourceState after,
int mip = -1, int slice = -1)
{
GPUBarrier barrier;
- barrier.type = IMAGE_BARRIER;
+ barrier.type = Type::IMAGE;
barrier.image.texture = texture;
barrier.image.layout_before = before;
barrier.image.layout_after = after;
@@ -627,53 +603,54 @@ namespace wiGraphics
barrier.image.slice = slice;
return barrier;
}
- static GPUBarrier Buffer(const GPUBuffer* buffer, RESOURCE_STATE before, RESOURCE_STATE after)
+ static GPUBarrier Buffer(const GPUBuffer* buffer, ResourceState before, ResourceState after)
{
GPUBarrier barrier;
- barrier.type = BUFFER_BARRIER;
+ barrier.type = Type::BUFFER;
barrier.buffer.buffer = buffer;
barrier.buffer.state_before = before;
barrier.buffer.state_after = after;
return barrier;
}
};
+
struct RenderPassAttachment
{
- enum TYPE
+ enum class Type
{
RENDERTARGET,
DEPTH_STENCIL,
RESOLVE,
SHADING_RATE_SOURCE
- } type = RENDERTARGET;
- enum LOAD_OPERATION
+ } type = Type::RENDERTARGET;
+ enum class LoadOp
{
- LOADOP_LOAD,
- LOADOP_CLEAR,
- LOADOP_DONTCARE,
- } loadop = LOADOP_LOAD;
+ LOAD,
+ CLEAR,
+ DONTCARE,
+ } loadop = LoadOp::LOAD;
const Texture* texture = nullptr;
int subresource = -1;
- enum STORE_OPERATION
+ enum class StoreOp
{
- STOREOP_STORE,
- STOREOP_DONTCARE,
- } storeop = STOREOP_STORE;
- 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
+ STORE,
+ DONTCARE,
+ } storeop = StoreOp::STORE;
+ ResourceState initial_layout = ResourceState::UNDEFINED; // layout before the render pass
+ ResourceState subpass_layout = ResourceState::UNDEFINED; // layout within the render pass
+ ResourceState final_layout = ResourceState::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,
- RESOURCE_STATE initial_layout = RESOURCE_STATE_SHADER_RESOURCE,
- RESOURCE_STATE subpass_layout = RESOURCE_STATE_RENDERTARGET,
- RESOURCE_STATE final_layout = RESOURCE_STATE_SHADER_RESOURCE
+ LoadOp load_op = LoadOp::LOAD,
+ StoreOp store_op = StoreOp::STORE,
+ ResourceState initial_layout = ResourceState::SHADER_RESOURCE,
+ ResourceState subpass_layout = ResourceState::RENDERTARGET,
+ ResourceState final_layout = ResourceState::SHADER_RESOURCE
)
{
RenderPassAttachment attachment;
- attachment.type = RENDERTARGET;
+ attachment.type = Type::RENDERTARGET;
attachment.texture = resource;
attachment.loadop = load_op;
attachment.storeop = store_op;
@@ -685,15 +662,15 @@ namespace wiGraphics
static RenderPassAttachment DepthStencil(
const Texture* resource = nullptr,
- LOAD_OPERATION load_op = LOADOP_LOAD,
- STORE_OPERATION store_op = STOREOP_STORE,
- RESOURCE_STATE initial_layout = RESOURCE_STATE_DEPTHSTENCIL,
- RESOURCE_STATE subpass_layout = RESOURCE_STATE_DEPTHSTENCIL,
- RESOURCE_STATE final_layout = RESOURCE_STATE_DEPTHSTENCIL
+ LoadOp load_op = LoadOp::LOAD,
+ StoreOp store_op = StoreOp::STORE,
+ ResourceState initial_layout = ResourceState::DEPTHSTENCIL,
+ ResourceState subpass_layout = ResourceState::DEPTHSTENCIL,
+ ResourceState final_layout = ResourceState::DEPTHSTENCIL
)
{
RenderPassAttachment attachment;
- attachment.type = DEPTH_STENCIL;
+ attachment.type = Type::DEPTH_STENCIL;
attachment.texture = resource;
attachment.loadop = load_op;
attachment.storeop = store_op;
@@ -705,12 +682,12 @@ namespace wiGraphics
static RenderPassAttachment Resolve(
const Texture* resource = nullptr,
- RESOURCE_STATE initial_layout = RESOURCE_STATE_SHADER_RESOURCE,
- RESOURCE_STATE final_layout = RESOURCE_STATE_SHADER_RESOURCE
+ ResourceState initial_layout = ResourceState::SHADER_RESOURCE,
+ ResourceState final_layout = ResourceState::SHADER_RESOURCE
)
{
RenderPassAttachment attachment;
- attachment.type = RESOLVE;
+ attachment.type = Type::RESOLVE;
attachment.texture = resource;
attachment.initial_layout = initial_layout;
attachment.final_layout = final_layout;
@@ -719,67 +696,74 @@ namespace wiGraphics
static RenderPassAttachment ShadingRateSource(
const Texture* resource = nullptr,
- RESOURCE_STATE initial_layout = RESOURCE_STATE_SHADING_RATE_SOURCE,
- RESOURCE_STATE final_layout = RESOURCE_STATE_SHADING_RATE_SOURCE
+ ResourceState initial_layout = ResourceState::SHADING_RATE_SOURCE,
+ ResourceState final_layout = ResourceState::SHADING_RATE_SOURCE
)
{
RenderPassAttachment attachment;
- attachment.type = SHADING_RATE_SOURCE;
+ attachment.type = Type::SHADING_RATE_SOURCE;
attachment.texture = resource;
attachment.initial_layout = initial_layout;
- attachment.subpass_layout = RESOURCE_STATE_SHADING_RATE_SOURCE;
+ attachment.subpass_layout = ResourceState::SHADING_RATE_SOURCE;
attachment.final_layout = final_layout;
return attachment;
}
};
+
struct RenderPassDesc
{
- enum FLAGS
+ enum class Flags
{
- FLAG_EMPTY = 0,
- FLAG_ALLOW_UAV_WRITES = 1 << 0,
+ EMPTY = 0,
+ ALLOW_UAV_WRITES = 1 << 0,
};
- uint32_t _flags = FLAG_EMPTY;
+ Flags flags = Flags::EMPTY;
std::vector attachments;
};
+
struct SwapChainDesc
{
uint32_t width = 0;
uint32_t height = 0;
- uint32_t buffercount = 2;
- FORMAT format = FORMAT_R10G10B10A2_UNORM;
+ uint32_t buffer_count = 2;
+ Format format = Format::R10G10B10A2_UNORM;
bool fullscreen = false;
bool vsync = true;
- float clearcolor[4] = { 0,0,0,1 };
+ float clear_color[4] = { 0,0,0,1 };
bool allow_hdr = true;
};
+
struct IndirectDrawArgsInstanced
{
- uint32_t VertexCountPerInstance = 0;
- uint32_t InstanceCount = 0;
- uint32_t StartVertexLocation = 0;
- uint32_t StartInstanceLocation = 0;
+ uint32_t vertex_count_per_instance = 0;
+ uint32_t instance_count = 0;
+ uint32_t start_vertex_location = 0;
+ uint32_t start_instance_location = 0;
};
+
struct IndirectDrawArgsIndexedInstanced
{
- uint32_t IndexCountPerInstance = 0;
- uint32_t InstanceCount = 0;
- uint32_t StartIndexLocation = 0;
- int32_t BaseVertexLocation = 0;
- uint32_t StartInstanceLocation = 0;
+ uint32_t index_count_per_instance = 0;
+ uint32_t instance_count = 0;
+ uint32_t start_index_location = 0;
+ int32_t base_vertex_location = 0;
+ uint32_t start_instance_location = 0;
};
+
struct IndirectDispatchArgs
{
- uint32_t ThreadGroupCountX = 0;
- uint32_t ThreadGroupCountY = 0;
- uint32_t ThreadGroupCountZ = 0;
+ uint32_t thread_group_count_x = 0;
+ uint32_t thread_group_count_y = 0;
+ uint32_t thread_group_count_z = 0;
};
+
struct SubresourceData
{
- const void *pData = nullptr;
- uint32_t rowPitch = 0;
- uint32_t slicePitch = 0;
+ const void *data_ptr = nullptr;
+ uint32_t row_pitch = 0;
+ uint32_t slice_pitch = 0;
};
+
struct Rect
{
int32_t left = 0;
@@ -803,6 +787,7 @@ namespace wiGraphics
const SamplerDesc& GetDesc() const { return desc; }
};
+
struct StaticSampler
{
Sampler sampler;
@@ -811,22 +796,22 @@ namespace wiGraphics
struct Shader : public GraphicsDeviceChild
{
- SHADERSTAGE stage = SHADERSTAGE_COUNT;
+ ShaderStage stage = ShaderStage::Count;
std::vector auto_samplers; // ability to set static samplers without explicit root signature
};
struct GPUResource : public GraphicsDeviceChild
{
- enum class GPU_RESOURCE_TYPE
+ enum class Type
{
BUFFER,
TEXTURE,
RAYTRACING_ACCELERATION_STRUCTURE,
UNKNOWN_TYPE,
- } type = GPU_RESOURCE_TYPE::UNKNOWN_TYPE;
- 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; }
+ } type = Type::UNKNOWN_TYPE;
+ inline bool IsTexture() const { return type == Type::TEXTURE; }
+ inline bool IsBuffer() const { return type == Type::BUFFER; }
+ inline bool IsAccelerationStructure() const { return type == Type::RAYTRACING_ACCELERATION_STRUCTURE; }
void* mapped_data = nullptr;
uint32_t mapped_rowpitch = 0;
@@ -879,7 +864,7 @@ namespace wiGraphics
struct RaytracingAccelerationStructureDesc
{
- enum FLAGS
+ enum Flags
{
FLAG_EMPTY = 0,
FLAG_ALLOW_UPDATE = 1 << 0,
@@ -888,13 +873,13 @@ namespace wiGraphics
FLAG_PREFER_FAST_BUILD = 1 << 3,
FLAG_MINIMIZE_MEMORY = 1 << 4,
};
- uint32_t _flags = FLAG_EMPTY;
+ uint32_t flags = FLAG_EMPTY;
- enum TYPE
+ enum class Type
{
BOTTOMLEVEL,
TOPLEVEL,
- } type = BOTTOMLEVEL;
+ } type = Type::BOTTOMLEVEL;
struct BottomLevel
{
@@ -907,31 +892,31 @@ namespace wiGraphics
FLAG_NO_DUPLICATE_ANYHIT_INVOCATION = 1 << 1,
FLAG_USE_TRANSFORM = 1 << 2,
};
- uint32_t _flags = FLAG_EMPTY;
+ uint32_t flags = FLAG_EMPTY;
- enum TYPE
+ enum class Type
{
TRIANGLES,
PROCEDURAL_AABBS,
- } type = TRIANGLES;
+ } type = Type::TRIANGLES;
struct Triangles
{
- GPUBuffer vertexBuffer;
- GPUBuffer indexBuffer;
- uint32_t indexCount = 0;
- uint32_t indexOffset = 0;
- uint32_t vertexCount = 0;
- uint32_t vertexByteOffset = 0;
- uint32_t vertexStride = 0;
- INDEXBUFFER_FORMAT indexFormat = INDEXFORMAT_32BIT;
- FORMAT vertexFormat = FORMAT_R32G32B32_FLOAT;
- GPUBuffer transform3x4Buffer;
- uint32_t transform3x4BufferOffset = 0;
+ GPUBuffer vertex_buffer;
+ GPUBuffer index_buffer;
+ uint32_t index_count = 0;
+ uint32_t index_offset = 0;
+ uint32_t vertex_count = 0;
+ uint32_t vertex_byte_offset = 0;
+ uint32_t vertex_stride = 0;
+ IndexBufferFormat index_format = IndexBufferFormat::UINT32;
+ Format vertex_format = Format::R32G32B32_FLOAT;
+ GPUBuffer transform_3x4_buffer;
+ uint32_t transform_3x4_buffer_offset = 0;
} triangles;
struct Procedural_AABBs
{
- GPUBuffer aabbBuffer;
+ GPUBuffer aabb_buffer;
uint32_t offset = 0;
uint32_t count = 0;
uint32_t stride = 0;
@@ -939,7 +924,7 @@ namespace wiGraphics
};
std::vector geometries;
- } bottomlevel;
+ } bottom_level;
struct TopLevel
{
@@ -954,16 +939,16 @@ namespace wiGraphics
FLAG_FORCE_NON_OPAQUE = 1 << 3,
};
XMFLOAT3X4 transform;
- uint32_t InstanceID : 24;
- uint32_t InstanceMask : 8;
- uint32_t InstanceContributionToHitGroupIndex : 24;
- uint32_t Flags : 8;
- GPUResource bottomlevel;
+ uint32_t instance_id : 24;
+ uint32_t instance_mask : 8;
+ uint32_t instance_contribution_to_hit_group_index : 24;
+ uint32_t flags : 8;
+ GPUResource bottom_level;
};
- GPUBuffer instanceBuffer;
+ GPUBuffer instance_buffer;
uint32_t offset = 0;
uint32_t count = 0;
- } toplevel;
+ } top_level;
};
struct RaytracingAccelerationStructure : public GPUResource
{
@@ -974,35 +959,35 @@ namespace wiGraphics
struct ShaderLibrary
{
- enum TYPE
+ enum class Type
{
RAYGENERATION,
MISS,
CLOSESTHIT,
ANYHIT,
INTERSECTION,
- } type = RAYGENERATION;
+ } type = Type::RAYGENERATION;
const Shader* shader = nullptr;
std::string function_name;
};
struct ShaderHitGroup
{
- enum TYPE
+ enum class Type
{
GENERAL, // raygen or miss
TRIANGLES,
PROCEDURAL,
- } type = TRIANGLES;
+ } type = Type::TRIANGLES;
std::string name;
uint32_t general_shader = ~0;
- uint32_t closesthit_shader = ~0;
- uint32_t anyhit_shader = ~0;
+ uint32_t closest_hit_shader = ~0;
+ uint32_t any_hit_shader = ~0;
uint32_t intersection_shader = ~0;
};
struct RaytracingPipelineStateDesc
{
- std::vector shaderlibraries;
- std::vector hitgroups;
+ std::vector shader_libraries;
+ std::vector hit_groups;
uint32_t max_trace_recursion_depth = 1;
uint32_t max_attribute_size_in_bytes = 0;
uint32_t max_payload_size_in_bytes = 0;
@@ -1023,74 +1008,74 @@ namespace wiGraphics
};
struct DispatchRaysDesc
{
- ShaderTable raygeneration;
+ ShaderTable ray_generation;
ShaderTable miss;
- ShaderTable hitgroup;
+ ShaderTable hit_group;
ShaderTable callable;
- uint32_t Width = 1;
- uint32_t Height = 1;
- uint32_t Depth = 1;
+ uint32_t width = 1;
+ uint32_t height = 1;
+ uint32_t depth = 1;
};
- constexpr bool IsFormatUnorm(FORMAT format)
+ constexpr bool IsFormatUnorm(Format format)
{
switch (format)
{
- case FORMAT_R16G16B16A16_UNORM:
- case FORMAT_R10G10B10A2_UNORM:
- case FORMAT_R8G8B8A8_UNORM:
- case FORMAT_R8G8B8A8_UNORM_SRGB:
- case FORMAT_B8G8R8A8_UNORM:
- case FORMAT_B8G8R8A8_UNORM_SRGB:
- case FORMAT_R16G16_UNORM:
- case FORMAT_D24_UNORM_S8_UINT:
- case FORMAT_R8G8_UNORM:
- case FORMAT_D16_UNORM:
- case FORMAT_R16_UNORM:
- case FORMAT_R8_UNORM:
+ case Format::R16G16B16A16_UNORM:
+ case Format::R10G10B10A2_UNORM:
+ case Format::R8G8B8A8_UNORM:
+ case Format::R8G8B8A8_UNORM_SRGB:
+ case Format::B8G8R8A8_UNORM:
+ case Format::B8G8R8A8_UNORM_SRGB:
+ case Format::R16G16_UNORM:
+ case Format::D24_UNORM_S8_UINT:
+ case Format::R8G8_UNORM:
+ case Format::D16_UNORM:
+ case Format::R16_UNORM:
+ case Format::R8_UNORM:
return true;
}
return false;
}
- constexpr bool IsFormatBlockCompressed(FORMAT format)
+ constexpr bool IsFormatBlockCompressed(Format format)
{
switch (format)
{
- case FORMAT_BC1_UNORM:
- case FORMAT_BC1_UNORM_SRGB:
- case FORMAT_BC2_UNORM:
- case FORMAT_BC2_UNORM_SRGB:
- case FORMAT_BC3_UNORM:
- case FORMAT_BC3_UNORM_SRGB:
- case FORMAT_BC4_UNORM:
- case FORMAT_BC4_SNORM:
- case FORMAT_BC5_UNORM:
- case FORMAT_BC5_SNORM:
- case FORMAT_BC6H_UF16:
- case FORMAT_BC6H_SF16:
- case FORMAT_BC7_UNORM:
- case FORMAT_BC7_UNORM_SRGB:
+ case Format::BC1_UNORM:
+ case Format::BC1_UNORM_SRGB:
+ case Format::BC2_UNORM:
+ case Format::BC2_UNORM_SRGB:
+ case Format::BC3_UNORM:
+ case Format::BC3_UNORM_SRGB:
+ case Format::BC4_UNORM:
+ case Format::BC4_SNORM:
+ case Format::BC5_UNORM:
+ case Format::BC5_SNORM:
+ case Format::BC6H_UF16:
+ case Format::BC6H_SF16:
+ case Format::BC7_UNORM:
+ case Format::BC7_UNORM_SRGB:
return true;
}
return false;
}
- constexpr bool IsFormatStencilSupport(FORMAT format)
+ constexpr bool IsFormatStencilSupport(Format format)
{
switch (format)
{
- case FORMAT_R32G8X24_TYPELESS:
- case FORMAT_D32_FLOAT_S8X24_UINT:
- case FORMAT_R24G8_TYPELESS:
- case FORMAT_D24_UNORM_S8_UINT:
+ case Format::R32G8X24_TYPELESS:
+ case Format::D32_FLOAT_S8X24_UINT:
+ case Format::R24G8_TYPELESS:
+ case Format::D24_UNORM_S8_UINT:
return true;
}
return false;
}
- constexpr uint32_t GetFormatBlockSize(FORMAT format)
+ constexpr uint32_t GetFormatBlockSize(Format format)
{
if(IsFormatBlockCompressed(format))
{
@@ -1098,91 +1083,91 @@ namespace wiGraphics
}
return 1u;
}
- constexpr uint32_t GetFormatStride(FORMAT format)
+ constexpr uint32_t GetFormatStride(Format format)
{
switch (format)
{
- case FORMAT_BC1_UNORM:
- case FORMAT_BC1_UNORM_SRGB:
- case FORMAT_BC4_SNORM:
- case FORMAT_BC4_UNORM:
+ case Format::BC1_UNORM:
+ case Format::BC1_UNORM_SRGB:
+ case Format::BC4_SNORM:
+ case Format::BC4_UNORM:
return 8u;
- case FORMAT_R32G32B32A32_FLOAT:
- case FORMAT_R32G32B32A32_UINT:
- case FORMAT_R32G32B32A32_SINT:
- case FORMAT_BC2_UNORM:
- case FORMAT_BC2_UNORM_SRGB:
- case FORMAT_BC3_UNORM:
- case FORMAT_BC3_UNORM_SRGB:
- case FORMAT_BC5_SNORM:
- case FORMAT_BC5_UNORM:
- case FORMAT_BC6H_UF16:
- case FORMAT_BC6H_SF16:
- case FORMAT_BC7_UNORM:
- case FORMAT_BC7_UNORM_SRGB:
+ case Format::R32G32B32A32_FLOAT:
+ case Format::R32G32B32A32_UINT:
+ case Format::R32G32B32A32_SINT:
+ case Format::BC2_UNORM:
+ case Format::BC2_UNORM_SRGB:
+ case Format::BC3_UNORM:
+ case Format::BC3_UNORM_SRGB:
+ case Format::BC5_SNORM:
+ case Format::BC5_UNORM:
+ case Format::BC6H_UF16:
+ case Format::BC6H_SF16:
+ case Format::BC7_UNORM:
+ case Format::BC7_UNORM_SRGB:
return 16u;
- case FORMAT_R32G32B32_FLOAT:
- case FORMAT_R32G32B32_UINT:
- case FORMAT_R32G32B32_SINT:
+ case Format::R32G32B32_FLOAT:
+ case Format::R32G32B32_UINT:
+ case Format::R32G32B32_SINT:
return 12u;
- case FORMAT_R16G16B16A16_FLOAT:
- case FORMAT_R16G16B16A16_UNORM:
- case FORMAT_R16G16B16A16_UINT:
- case FORMAT_R16G16B16A16_SNORM:
- case FORMAT_R16G16B16A16_SINT:
+ case Format::R16G16B16A16_FLOAT:
+ case Format::R16G16B16A16_UNORM:
+ case Format::R16G16B16A16_UINT:
+ case Format::R16G16B16A16_SNORM:
+ case Format::R16G16B16A16_SINT:
return 8u;
- case FORMAT_R32G32_FLOAT:
- case FORMAT_R32G32_UINT:
- case FORMAT_R32G32_SINT:
- case FORMAT_R32G8X24_TYPELESS:
- case FORMAT_D32_FLOAT_S8X24_UINT:
+ case Format::R32G32_FLOAT:
+ case Format::R32G32_UINT:
+ case Format::R32G32_SINT:
+ case Format::R32G8X24_TYPELESS:
+ case Format::D32_FLOAT_S8X24_UINT:
return 8u;
- case FORMAT_R10G10B10A2_UNORM:
- case FORMAT_R10G10B10A2_UINT:
- case FORMAT_R11G11B10_FLOAT:
- case FORMAT_R8G8B8A8_UNORM:
- case FORMAT_R8G8B8A8_UNORM_SRGB:
- case FORMAT_R8G8B8A8_UINT:
- case FORMAT_R8G8B8A8_SNORM:
- case FORMAT_R8G8B8A8_SINT:
- case FORMAT_B8G8R8A8_UNORM:
- case FORMAT_B8G8R8A8_UNORM_SRGB:
- case FORMAT_R16G16_FLOAT:
- case FORMAT_R16G16_UNORM:
- case FORMAT_R16G16_UINT:
- case FORMAT_R16G16_SNORM:
- case FORMAT_R16G16_SINT:
- case FORMAT_R32_TYPELESS:
- case FORMAT_D32_FLOAT:
- case FORMAT_R32_FLOAT:
- case FORMAT_R32_UINT:
- case FORMAT_R32_SINT:
- case FORMAT_R24G8_TYPELESS:
- case FORMAT_D24_UNORM_S8_UINT:
+ case Format::R10G10B10A2_UNORM:
+ case Format::R10G10B10A2_UINT:
+ case Format::R11G11B10_FLOAT:
+ case Format::R8G8B8A8_UNORM:
+ case Format::R8G8B8A8_UNORM_SRGB:
+ case Format::R8G8B8A8_UINT:
+ case Format::R8G8B8A8_SNORM:
+ case Format::R8G8B8A8_SINT:
+ case Format::B8G8R8A8_UNORM:
+ case Format::B8G8R8A8_UNORM_SRGB:
+ case Format::R16G16_FLOAT:
+ case Format::R16G16_UNORM:
+ case Format::R16G16_UINT:
+ case Format::R16G16_SNORM:
+ case Format::R16G16_SINT:
+ case Format::R32_TYPELESS:
+ case Format::D32_FLOAT:
+ case Format::R32_FLOAT:
+ case Format::R32_UINT:
+ case Format::R32_SINT:
+ case Format::R24G8_TYPELESS:
+ case Format::D24_UNORM_S8_UINT:
return 4u;
- case FORMAT_R8G8_UNORM:
- case FORMAT_R8G8_UINT:
- case FORMAT_R8G8_SNORM:
- case FORMAT_R8G8_SINT:
- case FORMAT_R16_TYPELESS:
- case FORMAT_R16_FLOAT:
- case FORMAT_D16_UNORM:
- case FORMAT_R16_UNORM:
- case FORMAT_R16_UINT:
- case FORMAT_R16_SNORM:
- case FORMAT_R16_SINT:
+ case Format::R8G8_UNORM:
+ case Format::R8G8_UINT:
+ case Format::R8G8_SNORM:
+ case Format::R8G8_SINT:
+ case Format::R16_TYPELESS:
+ case Format::R16_FLOAT:
+ case Format::D16_UNORM:
+ case Format::R16_UNORM:
+ case Format::R16_UINT:
+ case Format::R16_SNORM:
+ case Format::R16_SINT:
return 2u;
- case FORMAT_R8_UNORM:
- case FORMAT_R8_UINT:
- case FORMAT_R8_SNORM:
- case FORMAT_R8_SINT:
+ case Format::R8_UNORM:
+ case Format::R8_UINT:
+ case Format::R8_SNORM:
+ case Format::R8_SINT:
return 1u;
@@ -1195,3 +1180,28 @@ namespace wiGraphics
}
}
+
+template<>
+struct enable_bitmask_operators {
+ static const bool enable = true;
+};
+template<>
+struct enable_bitmask_operators {
+ static const bool enable = true;
+};
+template<>
+struct enable_bitmask_operators {
+ static const bool enable = true;
+};
+template<>
+struct enable_bitmask_operators {
+ static const bool enable = true;
+};
+template<>
+struct enable_bitmask_operators {
+ static const bool enable = true;
+};
+template<>
+struct enable_bitmask_operators {
+ static const bool enable = true;
+};
diff --git a/WickedEngine/wiGraphicsDevice.h b/WickedEngine/wiGraphicsDevice.h
index 50a251494..7043545c4 100644
--- a/WickedEngine/wiGraphicsDevice.h
+++ b/WickedEngine/wiGraphicsDevice.h
@@ -12,17 +12,22 @@ namespace wiGraphics
// Use GraphicsDevice::BeginCommandList() to start a command list
// Use GraphicsDevice::SubmitCommandLists() to give all started command lists to the GPU for execution
// CommandList recording is not thread safe
- typedef uint8_t CommandList;
- static const CommandList COMMANDLIST_COUNT = 32; // If you increase command list count, more memory will be statically allocated for per-command list resources
- static const CommandList INVALID_COMMANDLIST = COMMANDLIST_COUNT;
+ struct CommandList
+ {
+ using index_type = uint8_t;
+ index_type index = ~0;
+ constexpr operator index_type() const { return index; }
+ };
+ static constexpr CommandList::index_type COMMANDLIST_COUNT = 32; // If you increase command list count, more memory will be statically allocated for per-command list resources
+ static constexpr CommandList INVALID_COMMANDLIST; // CommandList is invalid if it's just declared, but not started
// Descriptor binding counts:
// It's OK increase these limits if not enough
// But it's better to refactor shaders to use bindless descriptors if they require more resources
- 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;
+ static constexpr uint32_t DESCRIPTORBINDER_CBV_COUNT = 15;
+ static constexpr uint32_t DESCRIPTORBINDER_SRV_COUNT = 64;
+ static constexpr uint32_t DESCRIPTORBINDER_UAV_COUNT = 16;
+ static constexpr uint32_t DESCRIPTORBINDER_SAMPLER_COUNT = 16;
struct DescriptorBindingTable
{
GPUBuffer CBV[DESCRIPTORBINDER_CBV_COUNT];
@@ -57,7 +62,7 @@ namespace wiGraphics
static const uint32_t BUFFERCOUNT = 2;
uint64_t FRAMECOUNT = 0;
bool DEBUGDEVICE = false;
- uint32_t capabilities = 0;
+ GraphicsDeviceCapability capabilities = GraphicsDeviceCapability::NONE;
size_t SHADER_IDENTIFIER_SIZE = 0;
size_t TOPLEVEL_ACCELERATION_STRUCTURE_INSTANCE_SIZE = 0;
uint32_t VARIABLE_RATE_SHADING_TILE_SIZE = 0;
@@ -67,10 +72,11 @@ namespace wiGraphics
public:
virtual ~GraphicsDevice() = default;
+ // Create a SwapChain. If the SwapChain is to be recreated, the window handle can be nullptr.
virtual bool CreateSwapChain(const SwapChainDesc* pDesc, wiPlatform::window_type window, SwapChain* swapChain) const = 0;
virtual bool CreateBuffer(const GPUBufferDesc *pDesc, const void* pInitialData, GPUBuffer *pBuffer) const = 0;
virtual bool CreateTexture(const TextureDesc* pDesc, const SubresourceData *pInitialData, Texture *pTexture) const = 0;
- virtual bool CreateShader(SHADERSTAGE stage, const void *pShaderBytecode, size_t BytecodeLength, Shader *pShader) const = 0;
+ virtual bool CreateShader(ShaderStage stage, const void *pShaderBytecode, size_t BytecodeLength, Shader *pShader) const = 0;
virtual bool CreateSampler(const SamplerDesc *pSamplerDesc, Sampler *pSamplerState) const = 0;
virtual bool CreateQueryHeap(const GPUQueryHeapDesc *pDesc, GPUQueryHeap *pQueryHeap) const = 0;
virtual bool CreatePipelineState(const PipelineStateDesc* pDesc, PipelineState* pso) const = 0;
@@ -78,18 +84,20 @@ namespace wiGraphics
virtual bool CreateRaytracingAccelerationStructure(const RaytracingAccelerationStructureDesc* pDesc, RaytracingAccelerationStructure* bvh) const { return false; }
virtual bool CreateRaytracingPipelineState(const RaytracingPipelineStateDesc* pDesc, RaytracingPipelineState* rtpso) const { return false; }
- virtual int CreateSubresource(Texture* texture, SUBRESOURCE_TYPE type, uint32_t firstSlice, uint32_t sliceCount, uint32_t firstMip, uint32_t mipCount) const = 0;
- virtual int CreateSubresource(GPUBuffer* buffer, SUBRESOURCE_TYPE type, uint64_t offset, uint64_t size = ~0) const = 0;
+ virtual int CreateSubresource(Texture* texture, SubresourceType type, uint32_t firstSlice, uint32_t sliceCount, uint32_t firstMip, uint32_t mipCount) const = 0;
+ virtual int CreateSubresource(GPUBuffer* buffer, SubresourceType type, uint64_t offset, uint64_t size = ~0) const = 0;
- virtual int GetDescriptorIndex(const GPUResource* resource, SUBRESOURCE_TYPE type, int subresource = -1) const = 0;
+ virtual int GetDescriptorIndex(const GPUResource* resource, SubresourceType type, int subresource = -1) const = 0;
virtual int GetDescriptorIndex(const Sampler* sampler) const = 0;
- virtual void WriteShadingRateValue(SHADING_RATE rate, void* dest) const {};
+ virtual void WriteShadingRateValue(ShadingRate rate, void* dest) const {};
virtual void WriteTopLevelAccelerationStructureInstance(const RaytracingAccelerationStructureDesc::TopLevel::Instance* instance, void* dest) const {}
virtual void WriteShaderIdentifier(const RaytracingPipelineState* rtpso, uint32_t group_index, void* dest) const {}
-
+
+ // Set a sampler that can be used by any shaders that will be created after this call, without needing to bind that sampler
virtual void SetCommonSampler(const StaticSampler* sam) = 0;
+ // Set a debug name for the GPUResource, which will be visible in graphics debuggers
virtual void SetName(GPUResource* pResource, const char* name) = 0;
// Begin a new command list for GPU command recording.
@@ -99,16 +107,29 @@ namespace wiGraphics
// This will make every command list to be in "available" state and restarts them
virtual void SubmitCommandLists() = 0;
+ // The CPU will wait until all submitted GPU work is finished execution
virtual void WaitForGPU() const = 0;
+
+ // The current PipelineState cache will be cleared. It is useful to clear this when reloading shaders, to avoid accumulating unused pipeline states
virtual void ClearPipelineStateCache() = 0;
+ // Returns the number of active pipelines. Active pipelines are the pipelines that were compiled internally for a set of render target formats
+ // One PipelineState object can be compiled internally for multiple render target or depth-stencil formats, or sample counts
+ virtual size_t GetActivePipelineCount() const = 0;
+
+ // Returns the number of elapsed frames (submits)
+ // It is incremented when calling SubmitCommandLists()
constexpr uint64_t GetFrameCount() const { return FRAMECOUNT; }
- inline bool CheckCapability(GRAPHICSDEVICE_CAPABILITY capability) const { return capabilities & capability; }
+ // Check whether the graphics device supports a feature or not
+ constexpr bool CheckCapability(GraphicsDeviceCapability capability) const { return has_flag(capabilities, capability); }
+ // Returns the buffer count, which is the array size of buffered resources used by both the CPU and GPU
static constexpr uint32_t GetBufferCount() { return BUFFERCOUNT; }
+ // Returns the current buffer index, which is in range [0, GetBufferCount() - 1]
constexpr uint32_t GetBufferIndex() const { return GetFrameCount() % BUFFERCOUNT; }
+ // Returns whether the graphics debug layer is enabled. It can be enabled when creating the device.
constexpr bool IsDebugDevice() const { return DEBUGDEVICE; }
constexpr size_t GetShaderIdentifierSize() const { return SHADER_IDENTIFIER_SIZE; }
@@ -116,17 +137,23 @@ namespace wiGraphics
constexpr uint32_t GetVariableRateShadingTileSize() const { return VARIABLE_RATE_SHADING_TILE_SIZE; }
constexpr uint64_t GetTimestampFrequency() const { return TIMESTAMP_FREQUENCY; }
- virtual SHADERFORMAT GetShaderFormat() const = 0;
+ // Get the shader binary format that the underlying graphics API consumes
+ virtual ShaderFormat GetShaderFormat() const = 0;
+ // Get a Texture resource that represents the current back buffer of the SwapChain
virtual Texture GetBackBuffer(const SwapChain* swapchain) const = 0;
-
// Returns the current color space of the swapchain output
- virtual COLOR_SPACE GetSwapChainColorSpace(const SwapChain* swapchain) const = 0;
+ virtual ColorSpace GetSwapChainColorSpace(const SwapChain* swapchain) const = 0;
// Returns true if the swapchain could support HDR output regardless of current format
// Returns false if the swapchain couldn't support HDR output
- virtual bool GetSwapChainHDRSupport(const SwapChain* swapchain) const = 0;
+ virtual bool IsSwapChainSupportsHDR(const SwapChain* swapchain) const = 0;
- ///////////////Thread-sensitive////////////////////////
+ /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ // Command List functions are below:
+ // - These are used to record rendering commands to a CommandList
+ // - To get a CommandList that can be recorded into, call BeginCommandList()
+ // - These commands are not immediately executed, but they begin executing on the GPU after calling SubmitCommandLists()
+ // - These are not thread safe, only a single thread should use a single CommandList at one time
virtual void WaitCommandList(CommandList cmd, CommandList wait_for) = 0;
virtual void RenderPassBegin(const SwapChain* swapchain, CommandList cmd) = 0;
@@ -141,10 +168,10 @@ namespace wiGraphics
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 uint64_t* offsets, CommandList cmd) = 0;
- virtual void BindIndexBuffer(const GPUBuffer* indexBuffer, const INDEXBUFFER_FORMAT format, uint64_t offset, CommandList cmd) = 0;
+ virtual void BindIndexBuffer(const GPUBuffer* indexBuffer, const IndexBufferFormat format, uint64_t offset, CommandList cmd) = 0;
virtual void BindStencilRef(uint32_t value, CommandList cmd) = 0;
virtual void BindBlendFactor(float r, float g, float b, float a, CommandList cmd) = 0;
- virtual void BindShadingRate(SHADING_RATE rate, CommandList cmd) {}
+ virtual void BindShadingRate(ShadingRate rate, CommandList cmd) {}
virtual void BindPipelineState(const PipelineState* pso, CommandList cmd) = 0;
virtual void BindComputeShader(const Shader* cs, CommandList cmd) = 0;
virtual void Draw(uint32_t vertexCount, uint32_t startVertexLocation, CommandList cmd) = 0;
@@ -168,7 +195,7 @@ namespace wiGraphics
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) = 0;
- virtual void PredicationBegin(const GPUBuffer* buffer, uint64_t offset, PREDICATION_OP op, CommandList cmd) {}
+ virtual void PredicationBegin(const GPUBuffer* buffer, uint64_t offset, PredicationOp op, CommandList cmd) {}
virtual void PredicationEnd(CommandList cmd) {}
virtual void EventBegin(const char* name, CommandList cmd) = 0;
@@ -211,14 +238,14 @@ namespace wiGraphics
allocator.offset = 0;
}
- const uint64_t free_space = allocator.buffer.desc.Size - allocator.offset;
+ const uint64_t free_space = allocator.buffer.desc.size - allocator.offset;
if (dataSize > free_space)
{
GPUBufferDesc desc;
- desc.Usage = USAGE_UPLOAD;
- desc.Size = AlignTo((allocator.buffer.desc.Size + 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;
+ desc.usage = Usage::UPLOAD;
+ desc.size = AlignTo((allocator.buffer.desc.size + dataSize) * 2, ALLOCATION_MIN_ALIGNMENT);
+ desc.bind_flags = BindFlag::CONSTANT_BUFFER | BindFlag::VERTEX_BUFFER | BindFlag::INDEX_BUFFER | BindFlag::SHADER_RESOURCE;
+ desc.misc_flags = ResourceMiscFlag::BUFFER_RAW;
CreateBuffer(&desc, nullptr, &allocator.buffer);
SetName(&allocator.buffer, "frame_allocator");
allocator.offset = 0;
@@ -234,14 +261,14 @@ namespace wiGraphics
return allocation;
}
- // Updates a USAGE_DEFAULT buffer data
+ // 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, uint64_t size = ~0, uint64_t offset = 0)
{
if (buffer == nullptr || data == nullptr)
return;
- size = std::min(buffer->desc.Size, size);
+ size = std::min(buffer->desc.size, size);
if (size == 0)
return;
GPUAllocation allocation = AllocateGPU(size, cmd);
@@ -261,4 +288,14 @@ namespace wiGraphics
}
};
+
+ // This is a helper to get access to a global device instance
+ // - The engine uses this, but it is not necessary to use a single global device object
+ // - This is not a lifetime managing object, just a way to globally expose a reference to an object by pointer
+ inline GraphicsDevice*& GetDevice()
+ {
+ static GraphicsDevice* device = nullptr;
+ return device;
+ }
+
}
diff --git a/WickedEngine/wiGraphicsDevice_DX12.cpp b/WickedEngine/wiGraphicsDevice_DX12.cpp
index f973e7de4..19a4abc67 100644
--- a/WickedEngine/wiGraphicsDevice_DX12.cpp
+++ b/WickedEngine/wiGraphicsDevice_DX12.cpp
@@ -61,179 +61,179 @@ namespace DX12_Internal
ComPtr dxcUtils;
// Engine -> Native converters
- constexpr uint32_t _ParseColorWriteMask(uint32_t value)
+ constexpr uint32_t _ParseColorWriteMask(ColorWrite value)
{
uint32_t _flag = 0;
- if (value == D3D12_COLOR_WRITE_ENABLE_ALL)
+ if (value == ColorWrite::ENABLE_ALL)
{
return D3D12_COLOR_WRITE_ENABLE_ALL;
}
else
{
- if (value & COLOR_WRITE_ENABLE_RED)
+ if (has_flag(value, ColorWrite::ENABLE_RED))
_flag |= D3D12_COLOR_WRITE_ENABLE_RED;
- if (value & COLOR_WRITE_ENABLE_GREEN)
+ if (has_flag(value, ColorWrite::ENABLE_GREEN))
_flag |= D3D12_COLOR_WRITE_ENABLE_GREEN;
- if (value & COLOR_WRITE_ENABLE_BLUE)
+ if (has_flag(value, ColorWrite::ENABLE_BLUE))
_flag |= D3D12_COLOR_WRITE_ENABLE_BLUE;
- if (value & COLOR_WRITE_ENABLE_ALPHA)
+ if (has_flag(value, ColorWrite::ENABLE_ALPHA))
_flag |= D3D12_COLOR_WRITE_ENABLE_ALPHA;
}
return _flag;
}
- constexpr D3D12_RESOURCE_STATES _ParseResourceState(RESOURCE_STATE value)
+ constexpr D3D12_RESOURCE_STATES _ParseResourceState(ResourceState value)
{
D3D12_RESOURCE_STATES ret = {};
- if (value & RESOURCE_STATE_UNDEFINED)
+ if (has_flag(value, ResourceState::UNDEFINED))
ret |= D3D12_RESOURCE_STATE_COMMON;
- if (value & RESOURCE_STATE_SHADER_RESOURCE)
+ if (has_flag(value, ResourceState::SHADER_RESOURCE))
ret |= D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE | D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE;
- if (value & RESOURCE_STATE_SHADER_RESOURCE_COMPUTE)
+ if (has_flag(value, ResourceState::SHADER_RESOURCE_COMPUTE))
ret |= D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE;
- if (value & RESOURCE_STATE_UNORDERED_ACCESS)
+ if (has_flag(value, ResourceState::UNORDERED_ACCESS))
ret |= D3D12_RESOURCE_STATE_UNORDERED_ACCESS;
- if (value & RESOURCE_STATE_COPY_SRC)
+ if (has_flag(value, ResourceState::COPY_SRC))
ret |= D3D12_RESOURCE_STATE_COPY_SOURCE;
- if (value & RESOURCE_STATE_COPY_DST)
+ if (has_flag(value, ResourceState::COPY_DST))
ret |= D3D12_RESOURCE_STATE_COPY_DEST;
- if (value & RESOURCE_STATE_RENDERTARGET)
+ if (has_flag(value, ResourceState::RENDERTARGET))
ret |= D3D12_RESOURCE_STATE_RENDER_TARGET;
- if (value & RESOURCE_STATE_DEPTHSTENCIL)
+ if (has_flag(value, ResourceState::DEPTHSTENCIL))
ret |= D3D12_RESOURCE_STATE_DEPTH_WRITE;
- if (value & RESOURCE_STATE_DEPTHSTENCIL_READONLY)
+ if (has_flag(value, ResourceState::DEPTHSTENCIL_READONLY))
ret |= D3D12_RESOURCE_STATE_DEPTH_READ;
- if (value & RESOURCE_STATE_SHADING_RATE_SOURCE)
+ if (has_flag(value, ResourceState::SHADING_RATE_SOURCE))
ret |= D3D12_RESOURCE_STATE_SHADING_RATE_SOURCE;
- if (value & RESOURCE_STATE_VERTEX_BUFFER)
+ if (has_flag(value, ResourceState::VERTEX_BUFFER))
ret |= D3D12_RESOURCE_STATE_VERTEX_AND_CONSTANT_BUFFER;
- if (value & RESOURCE_STATE_INDEX_BUFFER)
+ if (has_flag(value, ResourceState::INDEX_BUFFER))
ret |= D3D12_RESOURCE_STATE_INDEX_BUFFER;
- if (value & RESOURCE_STATE_CONSTANT_BUFFER)
+ if (has_flag(value, ResourceState::CONSTANT_BUFFER))
ret |= D3D12_RESOURCE_STATE_VERTEX_AND_CONSTANT_BUFFER;
- if (value & RESOURCE_STATE_INDIRECT_ARGUMENT)
+ if (has_flag(value, ResourceState::INDIRECT_ARGUMENT))
ret |= D3D12_RESOURCE_STATE_INDIRECT_ARGUMENT;
- if (value & RESOURCE_STATE_RAYTRACING_ACCELERATION_STRUCTURE)
+ if (has_flag(value, ResourceState::RAYTRACING_ACCELERATION_STRUCTURE))
ret |= D3D12_RESOURCE_STATE_RAYTRACING_ACCELERATION_STRUCTURE;
- if (value & RESOURCE_STATE_PREDICATION)
+ if (has_flag(value, ResourceState::PREDICATION))
ret |= D3D12_RESOURCE_STATE_PREDICATION;
return ret;
}
- constexpr D3D12_FILTER _ConvertFilter(FILTER value)
+ constexpr D3D12_FILTER _ConvertFilter(Filter value)
{
switch (value)
{
- case FILTER_MIN_MAG_MIP_POINT:
+ case Filter::MIN_MAG_MIP_POINT:
return D3D12_FILTER_MIN_MAG_MIP_POINT;
break;
- case FILTER_MIN_MAG_POINT_MIP_LINEAR:
+ case Filter::MIN_MAG_POINT_MIP_LINEAR:
return D3D12_FILTER_MIN_MAG_POINT_MIP_LINEAR;
break;
- case FILTER_MIN_POINT_MAG_LINEAR_MIP_POINT:
+ case Filter::MIN_POINT_MAG_LINEAR_MIP_POINT:
return D3D12_FILTER_MIN_POINT_MAG_LINEAR_MIP_POINT;
break;
- case FILTER_MIN_POINT_MAG_MIP_LINEAR:
+ case Filter::MIN_POINT_MAG_MIP_LINEAR:
return D3D12_FILTER_MIN_POINT_MAG_MIP_LINEAR;
break;
- case FILTER_MIN_LINEAR_MAG_MIP_POINT:
+ case Filter::MIN_LINEAR_MAG_MIP_POINT:
return D3D12_FILTER_MIN_LINEAR_MAG_MIP_POINT;
break;
- case FILTER_MIN_LINEAR_MAG_POINT_MIP_LINEAR:
+ case Filter::MIN_LINEAR_MAG_POINT_MIP_LINEAR:
return D3D12_FILTER_MIN_LINEAR_MAG_POINT_MIP_LINEAR;
break;
- case FILTER_MIN_MAG_LINEAR_MIP_POINT:
+ case Filter::MIN_MAG_LINEAR_MIP_POINT:
return D3D12_FILTER_MIN_MAG_LINEAR_MIP_POINT;
break;
- case FILTER_MIN_MAG_MIP_LINEAR:
+ case Filter::MIN_MAG_MIP_LINEAR:
return D3D12_FILTER_MIN_MAG_MIP_LINEAR;
break;
- case FILTER_ANISOTROPIC:
+ case Filter::ANISOTROPIC:
return D3D12_FILTER_ANISOTROPIC;
break;
- case FILTER_COMPARISON_MIN_MAG_MIP_POINT:
+ case Filter::COMPARISON_MIN_MAG_MIP_POINT:
return D3D12_FILTER_COMPARISON_MIN_MAG_MIP_POINT;
break;
- case FILTER_COMPARISON_MIN_MAG_POINT_MIP_LINEAR:
+ case Filter::COMPARISON_MIN_MAG_POINT_MIP_LINEAR:
return D3D12_FILTER_COMPARISON_MIN_MAG_POINT_MIP_LINEAR;
break;
- case FILTER_COMPARISON_MIN_POINT_MAG_LINEAR_MIP_POINT:
+ case Filter::COMPARISON_MIN_POINT_MAG_LINEAR_MIP_POINT:
return D3D12_FILTER_COMPARISON_MIN_POINT_MAG_LINEAR_MIP_POINT;
break;
- case FILTER_COMPARISON_MIN_POINT_MAG_MIP_LINEAR:
+ case Filter::COMPARISON_MIN_POINT_MAG_MIP_LINEAR:
return D3D12_FILTER_COMPARISON_MIN_POINT_MAG_MIP_LINEAR;
break;
- case FILTER_COMPARISON_MIN_LINEAR_MAG_MIP_POINT:
+ case Filter::COMPARISON_MIN_LINEAR_MAG_MIP_POINT:
return D3D12_FILTER_COMPARISON_MIN_LINEAR_MAG_MIP_POINT;
break;
- case FILTER_COMPARISON_MIN_LINEAR_MAG_POINT_MIP_LINEAR:
+ case Filter::COMPARISON_MIN_LINEAR_MAG_POINT_MIP_LINEAR:
return D3D12_FILTER_COMPARISON_MIN_LINEAR_MAG_POINT_MIP_LINEAR;
break;
- case FILTER_COMPARISON_MIN_MAG_LINEAR_MIP_POINT:
+ case Filter::COMPARISON_MIN_MAG_LINEAR_MIP_POINT:
return D3D12_FILTER_COMPARISON_MIN_MAG_LINEAR_MIP_POINT;
break;
- case FILTER_COMPARISON_MIN_MAG_MIP_LINEAR:
+ case Filter::COMPARISON_MIN_MAG_MIP_LINEAR:
return D3D12_FILTER_COMPARISON_MIN_MAG_MIP_LINEAR;
break;
- case FILTER_COMPARISON_ANISOTROPIC:
+ case Filter::COMPARISON_ANISOTROPIC:
return D3D12_FILTER_COMPARISON_ANISOTROPIC;
break;
- case FILTER_MINIMUM_MIN_MAG_MIP_POINT:
+ case Filter::MINIMUM_MIN_MAG_MIP_POINT:
return D3D12_FILTER_MINIMUM_MIN_MAG_MIP_POINT;
break;
- case FILTER_MINIMUM_MIN_MAG_POINT_MIP_LINEAR:
+ case Filter::MINIMUM_MIN_MAG_POINT_MIP_LINEAR:
return D3D12_FILTER_MINIMUM_MIN_MAG_POINT_MIP_LINEAR;
break;
- case FILTER_MINIMUM_MIN_POINT_MAG_LINEAR_MIP_POINT:
+ case Filter::MINIMUM_MIN_POINT_MAG_LINEAR_MIP_POINT:
return D3D12_FILTER_MINIMUM_MIN_POINT_MAG_LINEAR_MIP_POINT;
break;
- case FILTER_MINIMUM_MIN_POINT_MAG_MIP_LINEAR:
+ case Filter::MINIMUM_MIN_POINT_MAG_MIP_LINEAR:
return D3D12_FILTER_MINIMUM_MIN_POINT_MAG_MIP_LINEAR;
break;
- case FILTER_MINIMUM_MIN_LINEAR_MAG_MIP_POINT:
+ case Filter::MINIMUM_MIN_LINEAR_MAG_MIP_POINT:
return D3D12_FILTER_MINIMUM_MIN_LINEAR_MAG_MIP_POINT;
break;
- case FILTER_MINIMUM_MIN_LINEAR_MAG_POINT_MIP_LINEAR:
+ case Filter::MINIMUM_MIN_LINEAR_MAG_POINT_MIP_LINEAR:
return D3D12_FILTER_MINIMUM_MIN_LINEAR_MAG_POINT_MIP_LINEAR;
break;
- case FILTER_MINIMUM_MIN_MAG_LINEAR_MIP_POINT:
+ case Filter::MINIMUM_MIN_MAG_LINEAR_MIP_POINT:
return D3D12_FILTER_MINIMUM_MIN_MAG_LINEAR_MIP_POINT;
break;
- case FILTER_MINIMUM_MIN_MAG_MIP_LINEAR:
+ case Filter::MINIMUM_MIN_MAG_MIP_LINEAR:
return D3D12_FILTER_MINIMUM_MIN_MAG_MIP_LINEAR;
break;
- case FILTER_MINIMUM_ANISOTROPIC:
+ case Filter::MINIMUM_ANISOTROPIC:
return D3D12_FILTER_MINIMUM_ANISOTROPIC;
break;
- case FILTER_MAXIMUM_MIN_MAG_MIP_POINT:
+ case Filter::MAXIMUM_MIN_MAG_MIP_POINT:
return D3D12_FILTER_MAXIMUM_MIN_MAG_MIP_POINT;
break;
- case FILTER_MAXIMUM_MIN_MAG_POINT_MIP_LINEAR:
+ case Filter::MAXIMUM_MIN_MAG_POINT_MIP_LINEAR:
return D3D12_FILTER_MAXIMUM_MIN_MAG_POINT_MIP_LINEAR;
break;
- case FILTER_MAXIMUM_MIN_POINT_MAG_LINEAR_MIP_POINT:
+ case Filter::MAXIMUM_MIN_POINT_MAG_LINEAR_MIP_POINT:
return D3D12_FILTER_MAXIMUM_MIN_POINT_MAG_LINEAR_MIP_POINT;
break;
- case FILTER_MAXIMUM_MIN_POINT_MAG_MIP_LINEAR:
+ case Filter::MAXIMUM_MIN_POINT_MAG_MIP_LINEAR:
return D3D12_FILTER_MAXIMUM_MIN_POINT_MAG_MIP_LINEAR;
break;
- case FILTER_MAXIMUM_MIN_LINEAR_MAG_MIP_POINT:
+ case Filter::MAXIMUM_MIN_LINEAR_MAG_MIP_POINT:
return D3D12_FILTER_MAXIMUM_MIN_LINEAR_MAG_MIP_POINT;
break;
- case FILTER_MAXIMUM_MIN_LINEAR_MAG_POINT_MIP_LINEAR:
+ case Filter::MAXIMUM_MIN_LINEAR_MAG_POINT_MIP_LINEAR:
return D3D12_FILTER_MAXIMUM_MIN_LINEAR_MAG_POINT_MIP_LINEAR;
break;
- case FILTER_MAXIMUM_MIN_MAG_LINEAR_MIP_POINT:
+ case Filter::MAXIMUM_MIN_MAG_LINEAR_MIP_POINT:
return D3D12_FILTER_MAXIMUM_MIN_MAG_LINEAR_MIP_POINT;
break;
- case FILTER_MAXIMUM_MIN_MAG_MIP_LINEAR:
+ case Filter::MAXIMUM_MIN_MAG_MIP_LINEAR:
return D3D12_FILTER_MAXIMUM_MIN_MAG_MIP_LINEAR;
break;
- case FILTER_MAXIMUM_ANISOTROPIC:
+ case Filter::MAXIMUM_ANISOTROPIC:
return D3D12_FILTER_MAXIMUM_ANISOTROPIC;
break;
default:
@@ -241,21 +241,21 @@ namespace DX12_Internal
}
return D3D12_FILTER_MIN_MAG_MIP_POINT;
}
- constexpr D3D_PRIMITIVE_TOPOLOGY _ConvertPrimitiveTopology(PRIMITIVETOPOLOGY topology, uint32_t controlPoints)
+ constexpr D3D_PRIMITIVE_TOPOLOGY _ConvertPrimitiveTopology(PrimitiveTopology topology, uint32_t controlPoints)
{
switch (topology)
{
- case POINTLIST:
+ case PrimitiveTopology::POINTLIST:
return D3D_PRIMITIVE_TOPOLOGY_POINTLIST;
- case LINELIST:
+ case PrimitiveTopology::LINELIST:
return D3D_PRIMITIVE_TOPOLOGY_LINELIST;
- case LINESTRIP:
+ case PrimitiveTopology::LINESTRIP:
return D3D_PRIMITIVE_TOPOLOGY_LINESTRIP;
- case TRIANGLELIST:
+ case PrimitiveTopology::TRIANGLELIST:
return D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST;
- case TRIANGLESTRIP:
+ case PrimitiveTopology::TRIANGLESTRIP:
return D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP;
- case PATCHLIST:
+ case PrimitiveTopology::PATCHLIST:
if (controlPoints == 0 || controlPoints > 32)
{
assert(false && "Invalid PatchList control points");
@@ -266,64 +266,64 @@ namespace DX12_Internal
return D3D_PRIMITIVE_TOPOLOGY_UNDEFINED;
}
}
- constexpr D3D12_TEXTURE_ADDRESS_MODE _ConvertTextureAddressMode(TEXTURE_ADDRESS_MODE value)
+ constexpr D3D12_TEXTURE_ADDRESS_MODE _ConvertTextureAddressMode(TextureAddressMode value)
{
switch (value)
{
- case TEXTURE_ADDRESS_WRAP:
+ case TextureAddressMode::WRAP:
return D3D12_TEXTURE_ADDRESS_MODE_WRAP;
- case TEXTURE_ADDRESS_MIRROR:
+ case TextureAddressMode::MIRROR:
return D3D12_TEXTURE_ADDRESS_MODE_MIRROR;
- case TEXTURE_ADDRESS_CLAMP:
+ case TextureAddressMode::CLAMP:
return D3D12_TEXTURE_ADDRESS_MODE_CLAMP;
- case TEXTURE_ADDRESS_BORDER:
+ case TextureAddressMode::BORDER:
return D3D12_TEXTURE_ADDRESS_MODE_BORDER;
- case TEXTURE_ADDRESS_MIRROR_ONCE:
+ case TextureAddressMode::MIRROR_ONCE:
return D3D12_TEXTURE_ADDRESS_MODE_MIRROR_ONCE;
default:
return D3D12_TEXTURE_ADDRESS_MODE_WRAP;
}
}
- constexpr D3D12_STATIC_BORDER_COLOR _ConvertSamplerBorderColor(SAMPLER_BORDER_COLOR value)
+ constexpr D3D12_STATIC_BORDER_COLOR _ConvertSamplerBorderColor(SamplerBorderColor value)
{
switch (value)
{
- case SAMPLER_BORDER_COLOR_TRANSPARENT_BLACK:
+ case SamplerBorderColor::TRANSPARENT_BLACK:
return D3D12_STATIC_BORDER_COLOR_TRANSPARENT_BLACK;
- case SAMPLER_BORDER_COLOR_OPAQUE_BLACK:
+ case SamplerBorderColor::OPAQUE_BLACK:
return D3D12_STATIC_BORDER_COLOR_OPAQUE_BLACK;
- case SAMPLER_BORDER_COLOR_OPAQUE_WHITE:
+ case SamplerBorderColor::OPAQUE_WHITE:
return D3D12_STATIC_BORDER_COLOR_OPAQUE_WHITE;
default:
return D3D12_STATIC_BORDER_COLOR_TRANSPARENT_BLACK;
}
}
- constexpr D3D12_COMPARISON_FUNC _ConvertComparisonFunc(COMPARISON_FUNC value)
+ constexpr D3D12_COMPARISON_FUNC _ConvertComparisonFunc(ComparisonFunc value)
{
switch (value)
{
- case COMPARISON_NEVER:
+ case ComparisonFunc::NEVER:
return D3D12_COMPARISON_FUNC_NEVER;
break;
- case COMPARISON_LESS:
+ case ComparisonFunc::LESS:
return D3D12_COMPARISON_FUNC_LESS;
break;
- case COMPARISON_EQUAL:
+ case ComparisonFunc::EQUAL:
return D3D12_COMPARISON_FUNC_EQUAL;
break;
- case COMPARISON_LESS_EQUAL:
+ case ComparisonFunc::LESS_EQUAL:
return D3D12_COMPARISON_FUNC_LESS_EQUAL;
break;
- case COMPARISON_GREATER:
+ case ComparisonFunc::GREATER:
return D3D12_COMPARISON_FUNC_GREATER;
break;
- case COMPARISON_NOT_EQUAL:
+ case ComparisonFunc::NOT_EQUAL:
return D3D12_COMPARISON_FUNC_NOT_EQUAL;
break;
- case COMPARISON_GREATER_EQUAL:
+ case ComparisonFunc::GREATER_EQUAL:
return D3D12_COMPARISON_FUNC_GREATER_EQUAL;
break;
- case COMPARISON_ALWAYS:
+ case ComparisonFunc::ALWAYS:
return D3D12_COMPARISON_FUNC_ALWAYS;
break;
default:
@@ -331,14 +331,14 @@ namespace DX12_Internal
}
return D3D12_COMPARISON_FUNC_NEVER;
}
- constexpr D3D12_FILL_MODE _ConvertFillMode(FILL_MODE value)
+ constexpr D3D12_FILL_MODE _ConvertFillMode(FillMode value)
{
switch (value)
{
- case FILL_WIREFRAME:
+ case FillMode::WIREFRAME:
return D3D12_FILL_MODE_WIREFRAME;
break;
- case FILL_SOLID:
+ case FillMode::SOLID:
return D3D12_FILL_MODE_SOLID;
break;
default:
@@ -346,17 +346,17 @@ namespace DX12_Internal
}
return D3D12_FILL_MODE_WIREFRAME;
}
- constexpr D3D12_CULL_MODE _ConvertCullMode(CULL_MODE value)
+ constexpr D3D12_CULL_MODE _ConvertCullMode(CullMode value)
{
switch (value)
{
- case CULL_NONE:
+ case CullMode::NONE:
return D3D12_CULL_MODE_NONE;
break;
- case CULL_FRONT:
+ case CullMode::FRONT:
return D3D12_CULL_MODE_FRONT;
break;
- case CULL_BACK:
+ case CullMode::BACK:
return D3D12_CULL_MODE_BACK;
break;
default:
@@ -364,14 +364,14 @@ namespace DX12_Internal
}
return D3D12_CULL_MODE_NONE;
}
- constexpr D3D12_DEPTH_WRITE_MASK _ConvertDepthWriteMask(DEPTH_WRITE_MASK value)
+ constexpr D3D12_DEPTH_WRITE_MASK _ConvertDepthWriteMask(DepthWriteMask value)
{
switch (value)
{
- case DEPTH_WRITE_MASK_ZERO:
+ case DepthWriteMask::ZERO:
return D3D12_DEPTH_WRITE_MASK_ZERO;
break;
- case DEPTH_WRITE_MASK_ALL:
+ case DepthWriteMask::ALL:
return D3D12_DEPTH_WRITE_MASK_ALL;
break;
default:
@@ -379,32 +379,32 @@ namespace DX12_Internal
}
return D3D12_DEPTH_WRITE_MASK_ZERO;
}
- constexpr D3D12_STENCIL_OP _ConvertStencilOp(STENCIL_OP value)
+ constexpr D3D12_STENCIL_OP _ConvertStencilOp(StencilOp value)
{
switch (value)
{
- case STENCIL_OP_KEEP:
+ case StencilOp::KEEP:
return D3D12_STENCIL_OP_KEEP;
break;
- case STENCIL_OP_ZERO:
+ case StencilOp::ZERO:
return D3D12_STENCIL_OP_ZERO;
break;
- case STENCIL_OP_REPLACE:
+ case StencilOp::REPLACE:
return D3D12_STENCIL_OP_REPLACE;
break;
- case STENCIL_OP_INCR_SAT:
+ case StencilOp::INCR_SAT:
return D3D12_STENCIL_OP_INCR_SAT;
break;
- case STENCIL_OP_DECR_SAT:
+ case StencilOp::DECR_SAT:
return D3D12_STENCIL_OP_DECR_SAT;
break;
- case STENCIL_OP_INVERT:
+ case StencilOp::INVERT:
return D3D12_STENCIL_OP_INVERT;
break;
- case STENCIL_OP_INCR:
+ case StencilOp::INCR:
return D3D12_STENCIL_OP_INCR;
break;
- case STENCIL_OP_DECR:
+ case StencilOp::DECR:
return D3D12_STENCIL_OP_DECR;
break;
default:
@@ -412,297 +412,297 @@ namespace DX12_Internal
}
return D3D12_STENCIL_OP_KEEP;
}
- constexpr D3D12_BLEND _ConvertBlend(BLEND value)
+ constexpr D3D12_BLEND _ConvertBlend(Blend value)
{
switch (value)
{
- case BLEND_ZERO:
+ case Blend::ZERO:
return D3D12_BLEND_ZERO;
- case BLEND_ONE:
+ case Blend::ONE:
return D3D12_BLEND_ONE;
- case BLEND_SRC_COLOR:
+ case Blend::SRC_COLOR:
return D3D12_BLEND_SRC_COLOR;
- case BLEND_INV_SRC_COLOR:
+ case Blend::INV_SRC_COLOR:
return D3D12_BLEND_INV_SRC_COLOR;
- case BLEND_SRC_ALPHA:
+ case Blend::SRC_ALPHA:
return D3D12_BLEND_SRC_ALPHA;
- case BLEND_INV_SRC_ALPHA:
+ case Blend::INV_SRC_ALPHA:
return D3D12_BLEND_INV_SRC_ALPHA;
- case BLEND_DEST_ALPHA:
+ case Blend::DEST_ALPHA:
return D3D12_BLEND_DEST_ALPHA;
- case BLEND_INV_DEST_ALPHA:
+ case Blend::INV_DEST_ALPHA:
return D3D12_BLEND_INV_DEST_ALPHA;
- case BLEND_DEST_COLOR:
+ case Blend::DEST_COLOR:
return D3D12_BLEND_DEST_COLOR;
- case BLEND_INV_DEST_COLOR:
+ case Blend::INV_DEST_COLOR:
return D3D12_BLEND_INV_DEST_COLOR;
- case BLEND_SRC_ALPHA_SAT:
+ case Blend::SRC_ALPHA_SAT:
return D3D12_BLEND_SRC_ALPHA_SAT;
- case BLEND_BLEND_FACTOR:
+ case Blend::BLEND_FACTOR:
return D3D12_BLEND_BLEND_FACTOR;
- case BLEND_INV_BLEND_FACTOR:
+ case Blend::INV_BLEND_FACTOR:
return D3D12_BLEND_INV_BLEND_FACTOR;
- case BLEND_SRC1_COLOR:
+ case Blend::SRC1_COLOR:
return D3D12_BLEND_SRC1_COLOR;
- case BLEND_INV_SRC1_COLOR:
+ case Blend::INV_SRC1_COLOR:
return D3D12_BLEND_INV_SRC1_COLOR;
- case BLEND_SRC1_ALPHA:
+ case Blend::SRC1_ALPHA:
return D3D12_BLEND_SRC1_ALPHA;
- case BLEND_INV_SRC1_ALPHA:
+ case Blend::INV_SRC1_ALPHA:
return D3D12_BLEND_INV_SRC1_ALPHA;
default:
return D3D12_BLEND_ZERO;
}
}
- constexpr D3D12_BLEND _ConvertAlphaBlend(BLEND value)
+ constexpr D3D12_BLEND _ConvertAlphaBlend(Blend value)
{
switch (value)
{
- case BLEND_SRC_COLOR:
+ case Blend::SRC_COLOR:
return D3D12_BLEND_SRC_ALPHA;
- case BLEND_INV_SRC_COLOR:
+ case Blend::INV_SRC_COLOR:
return D3D12_BLEND_INV_SRC_ALPHA;
- case BLEND_DEST_COLOR:
+ case Blend::DEST_COLOR:
return D3D12_BLEND_DEST_ALPHA;
- case BLEND_INV_DEST_COLOR:
+ case Blend::INV_DEST_COLOR:
return D3D12_BLEND_INV_DEST_ALPHA;
- case BLEND_SRC1_COLOR:
+ case Blend::SRC1_COLOR:
return D3D12_BLEND_SRC1_ALPHA;
- case BLEND_INV_SRC1_COLOR:
+ case Blend::INV_SRC1_COLOR:
return D3D12_BLEND_INV_SRC1_ALPHA;
default:
return _ConvertBlend(value);
}
}
- constexpr D3D12_BLEND_OP _ConvertBlendOp(BLEND_OP value)
+ constexpr D3D12_BLEND_OP _ConvertBlendOp(BlendOp value)
{
switch (value)
{
- case BLEND_OP_ADD:
+ case BlendOp::ADD:
return D3D12_BLEND_OP_ADD;
- case BLEND_OP_SUBTRACT:
+ case BlendOp::SUBTRACT:
return D3D12_BLEND_OP_SUBTRACT;
- case BLEND_OP_REV_SUBTRACT:
+ case BlendOp::REV_SUBTRACT:
return D3D12_BLEND_OP_REV_SUBTRACT;
- case BLEND_OP_MIN:
+ case BlendOp::MIN:
return D3D12_BLEND_OP_MIN;
- case BLEND_OP_MAX:
+ case BlendOp::MAX:
return D3D12_BLEND_OP_MAX;
default:
return D3D12_BLEND_OP_ADD;
}
}
- constexpr D3D12_INPUT_CLASSIFICATION _ConvertInputClassification(INPUT_CLASSIFICATION value)
+ constexpr D3D12_INPUT_CLASSIFICATION _ConvertInputClassification(InputClassification value)
{
switch (value)
{
- case INPUT_PER_INSTANCE_DATA:
+ case InputClassification::PER_INSTANCE_DATA:
return D3D12_INPUT_CLASSIFICATION_PER_INSTANCE_DATA;
break;
default:
return D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA;
}
}
- constexpr DXGI_FORMAT _ConvertFormat(FORMAT value)
+ constexpr DXGI_FORMAT _ConvertFormat(Format value)
{
switch (value)
{
- case FORMAT_UNKNOWN:
+ case Format::UNKNOWN:
return DXGI_FORMAT_UNKNOWN;
break;
- case FORMAT_R32G32B32A32_FLOAT:
+ case Format::R32G32B32A32_FLOAT:
return DXGI_FORMAT_R32G32B32A32_FLOAT;
break;
- case FORMAT_R32G32B32A32_UINT:
+ case Format::R32G32B32A32_UINT:
return DXGI_FORMAT_R32G32B32A32_UINT;
break;
- case FORMAT_R32G32B32A32_SINT:
+ case Format::R32G32B32A32_SINT:
return DXGI_FORMAT_R32G32B32A32_SINT;
break;
- case FORMAT_R32G32B32_FLOAT:
+ case Format::R32G32B32_FLOAT:
return DXGI_FORMAT_R32G32B32_FLOAT;
break;
- case FORMAT_R32G32B32_UINT:
+ case Format::R32G32B32_UINT:
return DXGI_FORMAT_R32G32B32_UINT;
break;
- case FORMAT_R32G32B32_SINT:
+ case Format::R32G32B32_SINT:
return DXGI_FORMAT_R32G32B32_SINT;
break;
- case FORMAT_R16G16B16A16_FLOAT:
+ case Format::R16G16B16A16_FLOAT:
return DXGI_FORMAT_R16G16B16A16_FLOAT;
break;
- case FORMAT_R16G16B16A16_UNORM:
+ case Format::R16G16B16A16_UNORM:
return DXGI_FORMAT_R16G16B16A16_UNORM;
break;
- case FORMAT_R16G16B16A16_UINT:
+ case Format::R16G16B16A16_UINT:
return DXGI_FORMAT_R16G16B16A16_UINT;
break;
- case FORMAT_R16G16B16A16_SNORM:
+ case Format::R16G16B16A16_SNORM:
return DXGI_FORMAT_R16G16B16A16_SNORM;
break;
- case FORMAT_R16G16B16A16_SINT:
+ case Format::R16G16B16A16_SINT:
return DXGI_FORMAT_R16G16B16A16_SINT;
break;
- case FORMAT_R32G32_FLOAT:
+ case Format::R32G32_FLOAT:
return DXGI_FORMAT_R32G32_FLOAT;
break;
- case FORMAT_R32G32_UINT:
+ case Format::R32G32_UINT:
return DXGI_FORMAT_R32G32_UINT;
break;
- case FORMAT_R32G32_SINT:
+ case Format::R32G32_SINT:
return DXGI_FORMAT_R32G32_SINT;
break;
- case FORMAT_R32G8X24_TYPELESS:
+ case Format::R32G8X24_TYPELESS:
return DXGI_FORMAT_R32G8X24_TYPELESS;
break;
- case FORMAT_D32_FLOAT_S8X24_UINT:
+ case Format::D32_FLOAT_S8X24_UINT:
return DXGI_FORMAT_D32_FLOAT_S8X24_UINT;
break;
- case FORMAT_R10G10B10A2_UNORM:
+ case Format::R10G10B10A2_UNORM:
return DXGI_FORMAT_R10G10B10A2_UNORM;
break;
- case FORMAT_R10G10B10A2_UINT:
+ case Format::R10G10B10A2_UINT:
return DXGI_FORMAT_R10G10B10A2_UINT;
break;
- case FORMAT_R11G11B10_FLOAT:
+ case Format::R11G11B10_FLOAT:
return DXGI_FORMAT_R11G11B10_FLOAT;
break;
- case FORMAT_R8G8B8A8_UNORM:
+ case Format::R8G8B8A8_UNORM:
return DXGI_FORMAT_R8G8B8A8_UNORM;
break;
- case FORMAT_R8G8B8A8_UNORM_SRGB:
+ case Format::R8G8B8A8_UNORM_SRGB:
return DXGI_FORMAT_R8G8B8A8_UNORM_SRGB;
break;
- case FORMAT_R8G8B8A8_UINT:
+ case Format::R8G8B8A8_UINT:
return DXGI_FORMAT_R8G8B8A8_UINT;
break;
- case FORMAT_R8G8B8A8_SNORM:
+ case Format::R8G8B8A8_SNORM:
return DXGI_FORMAT_R8G8B8A8_SNORM;
break;
- case FORMAT_R8G8B8A8_SINT:
+ case Format::R8G8B8A8_SINT:
return DXGI_FORMAT_R8G8B8A8_SINT;
break;
- case FORMAT_R16G16_FLOAT:
+ case Format::R16G16_FLOAT:
return DXGI_FORMAT_R16G16_FLOAT;
break;
- case FORMAT_R16G16_UNORM:
+ case Format::R16G16_UNORM:
return DXGI_FORMAT_R16G16_UNORM;
break;
- case FORMAT_R16G16_UINT:
+ case Format::R16G16_UINT:
return DXGI_FORMAT_R16G16_UINT;
break;
- case FORMAT_R16G16_SNORM:
+ case Format::R16G16_SNORM:
return DXGI_FORMAT_R16G16_SNORM;
break;
- case FORMAT_R16G16_SINT:
+ case Format::R16G16_SINT:
return DXGI_FORMAT_R16G16_SINT;
break;
- case FORMAT_R32_TYPELESS:
+ case Format::R32_TYPELESS:
return DXGI_FORMAT_R32_TYPELESS;
break;
- case FORMAT_D32_FLOAT:
+ case Format::D32_FLOAT:
return DXGI_FORMAT_D32_FLOAT;
break;
- case FORMAT_R32_FLOAT:
+ case Format::R32_FLOAT:
return DXGI_FORMAT_R32_FLOAT;
break;
- case FORMAT_R32_UINT:
+ case Format::R32_UINT:
return DXGI_FORMAT_R32_UINT;
break;
- case FORMAT_R32_SINT:
+ case Format::R32_SINT:
return DXGI_FORMAT_R32_SINT;
break;
- case FORMAT_R8G8_UNORM:
+ case Format::R8G8_UNORM:
return DXGI_FORMAT_R8G8_UNORM;
break;
- case FORMAT_R8G8_UINT:
+ case Format::R8G8_UINT:
return DXGI_FORMAT_R8G8_UINT;
break;
- case FORMAT_R8G8_SNORM:
+ case Format::R8G8_SNORM:
return DXGI_FORMAT_R8G8_SNORM;
break;
- case FORMAT_R8G8_SINT:
+ case Format::R8G8_SINT:
return DXGI_FORMAT_R8G8_SINT;
break;
- case FORMAT_R16_TYPELESS:
+ case Format::R16_TYPELESS:
return DXGI_FORMAT_R16_TYPELESS;
break;
- case FORMAT_R16_FLOAT:
+ case Format::R16_FLOAT:
return DXGI_FORMAT_R16_FLOAT;
break;
- case FORMAT_D16_UNORM:
+ case Format::D16_UNORM:
return DXGI_FORMAT_D16_UNORM;
break;
- case FORMAT_R16_UNORM:
+ case Format::R16_UNORM:
return DXGI_FORMAT_R16_UNORM;
break;
- case FORMAT_R16_UINT:
+ case Format::R16_UINT:
return DXGI_FORMAT_R16_UINT;
break;
- case FORMAT_R16_SNORM:
+ case Format::R16_SNORM:
return DXGI_FORMAT_R16_SNORM;
break;
- case FORMAT_R16_SINT:
+ case Format::R16_SINT:
return DXGI_FORMAT_R16_SINT;
break;
- case FORMAT_R8_UNORM:
+ case Format::R8_UNORM:
return DXGI_FORMAT_R8_UNORM;
break;
- case FORMAT_R8_UINT:
+ case Format::R8_UINT:
return DXGI_FORMAT_R8_UINT;
break;
- case FORMAT_R8_SNORM:
+ case Format::R8_SNORM:
return DXGI_FORMAT_R8_SNORM;
break;
- case FORMAT_R8_SINT:
+ case Format::R8_SINT:
return DXGI_FORMAT_R8_SINT;
break;
- case FORMAT_BC1_UNORM:
+ case Format::BC1_UNORM:
return DXGI_FORMAT_BC1_UNORM;
break;
- case FORMAT_BC1_UNORM_SRGB:
+ case Format::BC1_UNORM_SRGB:
return DXGI_FORMAT_BC1_UNORM_SRGB;
break;
- case FORMAT_BC2_UNORM:
+ case Format::BC2_UNORM:
return DXGI_FORMAT_BC2_UNORM;
break;
- case FORMAT_BC2_UNORM_SRGB:
+ case Format::BC2_UNORM_SRGB:
return DXGI_FORMAT_BC2_UNORM_SRGB;
break;
- case FORMAT_BC3_UNORM:
+ case Format::BC3_UNORM:
return DXGI_FORMAT_BC3_UNORM;
break;
- case FORMAT_BC3_UNORM_SRGB:
+ case Format::BC3_UNORM_SRGB:
return DXGI_FORMAT_BC3_UNORM_SRGB;
break;
- case FORMAT_BC4_UNORM:
+ case Format::BC4_UNORM:
return DXGI_FORMAT_BC4_UNORM;
break;
- case FORMAT_BC4_SNORM:
+ case Format::BC4_SNORM:
return DXGI_FORMAT_BC4_SNORM;
break;
- case FORMAT_BC5_UNORM:
+ case Format::BC5_UNORM:
return DXGI_FORMAT_BC5_UNORM;
break;
- case FORMAT_BC5_SNORM:
+ case Format::BC5_SNORM:
return DXGI_FORMAT_BC5_SNORM;
break;
- case FORMAT_B8G8R8A8_UNORM:
+ case Format::B8G8R8A8_UNORM:
return DXGI_FORMAT_B8G8R8A8_UNORM;
break;
- case FORMAT_B8G8R8A8_UNORM_SRGB:
+ case Format::B8G8R8A8_UNORM_SRGB:
return DXGI_FORMAT_B8G8R8A8_UNORM_SRGB;
break;
- case FORMAT_BC6H_UF16:
+ case Format::BC6H_UF16:
return DXGI_FORMAT_BC6H_UF16;
break;
- case FORMAT_BC6H_SF16:
+ case Format::BC6H_SF16:
return DXGI_FORMAT_BC6H_SF16;
break;
- case FORMAT_BC7_UNORM:
+ case Format::BC7_UNORM:
return DXGI_FORMAT_BC7_UNORM;
break;
- case FORMAT_BC7_UNORM_SRGB:
+ case Format::BC7_UNORM_SRGB:
return DXGI_FORMAT_BC7_UNORM_SRGB;
break;
}
@@ -711,52 +711,52 @@ namespace DX12_Internal
constexpr D3D12_SUBRESOURCE_DATA _ConvertSubresourceData(const SubresourceData& pInitialData)
{
D3D12_SUBRESOURCE_DATA data = {};
- data.pData = pInitialData.pData;
- data.RowPitch = pInitialData.rowPitch;
- data.SlicePitch = pInitialData.slicePitch;
+ data.pData = pInitialData.data_ptr;
+ data.RowPitch = pInitialData.row_pitch;
+ data.SlicePitch = pInitialData.slice_pitch;
return data;
}
- constexpr D3D12_SHADER_VISIBILITY _ConvertShaderVisibility(SHADERSTAGE value)
+ constexpr D3D12_SHADER_VISIBILITY _ConvertShaderVisibility(ShaderStage value)
{
switch (value)
{
- case MS:
+ case ShaderStage::MS:
return D3D12_SHADER_VISIBILITY_MESH;
- case AS:
+ case ShaderStage::AS:
return D3D12_SHADER_VISIBILITY_AMPLIFICATION;
- case VS:
+ case ShaderStage::VS:
return D3D12_SHADER_VISIBILITY_VERTEX;
- case HS:
+ case ShaderStage::HS:
return D3D12_SHADER_VISIBILITY_HULL;
- case DS:
+ case ShaderStage::DS:
return D3D12_SHADER_VISIBILITY_DOMAIN;
- case GS:
+ case ShaderStage::GS:
return D3D12_SHADER_VISIBILITY_GEOMETRY;
- case PS:
+ case ShaderStage::PS:
return D3D12_SHADER_VISIBILITY_PIXEL;
default:
return D3D12_SHADER_VISIBILITY_ALL;
}
return D3D12_SHADER_VISIBILITY_ALL;
}
- constexpr D3D12_SHADING_RATE _ConvertShadingRate(SHADING_RATE value)
+ constexpr D3D12_SHADING_RATE _ConvertShadingRate(ShadingRate value)
{
switch (value)
{
- case wiGraphics::SHADING_RATE_1X1:
+ case ShadingRate::RATE_1X1:
return D3D12_SHADING_RATE_1X1;
- case wiGraphics::SHADING_RATE_1X2:
+ case ShadingRate::RATE_1X2:
return D3D12_SHADING_RATE_1X2;
- case wiGraphics::SHADING_RATE_2X1:
+ case ShadingRate::RATE_2X1:
return D3D12_SHADING_RATE_2X1;
- case wiGraphics::SHADING_RATE_2X2:
+ case ShadingRate::RATE_2X2:
return D3D12_SHADING_RATE_2X2;
- case wiGraphics::SHADING_RATE_2X4:
+ case ShadingRate::RATE_2X4:
return D3D12_SHADING_RATE_2X4;
- case wiGraphics::SHADING_RATE_4X2:
+ case ShadingRate::RATE_4X2:
return D3D12_SHADING_RATE_4X2;
- case wiGraphics::SHADING_RATE_4X4:
+ case ShadingRate::RATE_4X4:
return D3D12_SHADING_RATE_4X4;
default:
return D3D12_SHADING_RATE_1X1;
@@ -767,225 +767,225 @@ namespace DX12_Internal
{
D3D12_STATIC_SAMPLER_DESC desc = {};
desc.ShaderRegister = x.slot;
- desc.Filter = _ConvertFilter(x.sampler.desc.Filter);
- desc.AddressU = _ConvertTextureAddressMode(x.sampler.desc.AddressU);
- desc.AddressV = _ConvertTextureAddressMode(x.sampler.desc.AddressV);
- desc.AddressW = _ConvertTextureAddressMode(x.sampler.desc.AddressW);
- desc.MipLODBias = x.sampler.desc.MipLODBias;
- desc.MaxAnisotropy = x.sampler.desc.MaxAnisotropy;
- desc.ComparisonFunc = _ConvertComparisonFunc(x.sampler.desc.ComparisonFunc);
- desc.BorderColor = _ConvertSamplerBorderColor(x.sampler.desc.BorderColor);
- desc.MinLOD = x.sampler.desc.MinLOD;
- desc.MaxLOD = x.sampler.desc.MaxLOD;
+ desc.Filter = _ConvertFilter(x.sampler.desc.filter);
+ desc.AddressU = _ConvertTextureAddressMode(x.sampler.desc.address_u);
+ desc.AddressV = _ConvertTextureAddressMode(x.sampler.desc.address_v);
+ desc.AddressW = _ConvertTextureAddressMode(x.sampler.desc.address_w);
+ desc.MipLODBias = x.sampler.desc.mip_lod_bias;
+ desc.MaxAnisotropy = x.sampler.desc.max_anisotropy;
+ desc.ComparisonFunc = _ConvertComparisonFunc(x.sampler.desc.comparison_func);
+ desc.BorderColor = _ConvertSamplerBorderColor(x.sampler.desc.border_color);
+ desc.MinLOD = x.sampler.desc.min_lod;
+ desc.MaxLOD = x.sampler.desc.max_lod;
desc.ShaderVisibility = D3D12_SHADER_VISIBILITY_ALL;
return desc;
}
// Native -> Engine converters
- constexpr FORMAT _ConvertFormat_Inv(DXGI_FORMAT value)
+ constexpr Format _ConvertFormat_Inv(DXGI_FORMAT value)
{
switch (value)
{
case DXGI_FORMAT_UNKNOWN:
- return FORMAT_UNKNOWN;
+ return Format::UNKNOWN;
break;
case DXGI_FORMAT_R32G32B32A32_FLOAT:
- return FORMAT_R32G32B32A32_FLOAT;
+ return Format::R32G32B32A32_FLOAT;
break;
case DXGI_FORMAT_R32G32B32A32_UINT:
- return FORMAT_R32G32B32A32_UINT;
+ return Format::R32G32B32A32_UINT;
break;
case DXGI_FORMAT_R32G32B32A32_SINT:
- return FORMAT_R32G32B32A32_SINT;
+ return Format::R32G32B32A32_SINT;
break;
case DXGI_FORMAT_R32G32B32_FLOAT:
- return FORMAT_R32G32B32_FLOAT;
+ return Format::R32G32B32_FLOAT;
break;
case DXGI_FORMAT_R32G32B32_UINT:
- return FORMAT_R32G32B32_UINT;
+ return Format::R32G32B32_UINT;
break;
case DXGI_FORMAT_R32G32B32_SINT:
- return FORMAT_R32G32B32_SINT;
+ return Format::R32G32B32_SINT;
break;
case DXGI_FORMAT_R16G16B16A16_FLOAT:
- return FORMAT_R16G16B16A16_FLOAT;
+ return Format::R16G16B16A16_FLOAT;
break;
case DXGI_FORMAT_R16G16B16A16_UNORM:
- return FORMAT_R16G16B16A16_UNORM;
+ return Format::R16G16B16A16_UNORM;
break;
case DXGI_FORMAT_R16G16B16A16_UINT:
- return FORMAT_R16G16B16A16_UINT;
+ return Format::R16G16B16A16_UINT;
break;
case DXGI_FORMAT_R16G16B16A16_SNORM:
- return FORMAT_R16G16B16A16_SNORM;
+ return Format::R16G16B16A16_SNORM;
break;
case DXGI_FORMAT_R16G16B16A16_SINT:
- return FORMAT_R16G16B16A16_SINT;
+ return Format::R16G16B16A16_SINT;
break;
case DXGI_FORMAT_R32G32_FLOAT:
- return FORMAT_R32G32_FLOAT;
+ return Format::R32G32_FLOAT;
break;
case DXGI_FORMAT_R32G32_UINT:
- return FORMAT_R32G32_UINT;
+ return Format::R32G32_UINT;
break;
case DXGI_FORMAT_R32G32_SINT:
- return FORMAT_R32G32_SINT;
+ return Format::R32G32_SINT;
break;
case DXGI_FORMAT_R32G8X24_TYPELESS:
- return FORMAT_R32G8X24_TYPELESS;
+ return Format::R32G8X24_TYPELESS;
break;
case DXGI_FORMAT_D32_FLOAT_S8X24_UINT:
- return FORMAT_D32_FLOAT_S8X24_UINT;
+ return Format::D32_FLOAT_S8X24_UINT;
break;
case DXGI_FORMAT_R10G10B10A2_UNORM:
- return FORMAT_R10G10B10A2_UNORM;
+ return Format::R10G10B10A2_UNORM;
break;
case DXGI_FORMAT_R10G10B10A2_UINT:
- return FORMAT_R10G10B10A2_UINT;
+ return Format::R10G10B10A2_UINT;
break;
case DXGI_FORMAT_R11G11B10_FLOAT:
- return FORMAT_R11G11B10_FLOAT;
+ return Format::R11G11B10_FLOAT;
break;
case DXGI_FORMAT_R8G8B8A8_UNORM:
- return FORMAT_R8G8B8A8_UNORM;
+ return Format::R8G8B8A8_UNORM;
break;
case DXGI_FORMAT_R8G8B8A8_UNORM_SRGB:
- return FORMAT_R8G8B8A8_UNORM_SRGB;
+ return Format::R8G8B8A8_UNORM_SRGB;
break;
case DXGI_FORMAT_R8G8B8A8_UINT:
- return FORMAT_R8G8B8A8_UINT;
+ return Format::R8G8B8A8_UINT;
break;
case DXGI_FORMAT_R8G8B8A8_SNORM:
- return FORMAT_R8G8B8A8_SNORM;
+ return Format::R8G8B8A8_SNORM;
break;
case DXGI_FORMAT_R8G8B8A8_SINT:
- return FORMAT_R8G8B8A8_SINT;
+ return Format::R8G8B8A8_SINT;
break;
case DXGI_FORMAT_R16G16_FLOAT:
- return FORMAT_R16G16_FLOAT;
+ return Format::R16G16_FLOAT;
break;
case DXGI_FORMAT_R16G16_UNORM:
- return FORMAT_R16G16_UNORM;
+ return Format::R16G16_UNORM;
break;
case DXGI_FORMAT_R16G16_UINT:
- return FORMAT_R16G16_UINT;
+ return Format::R16G16_UINT;
break;
case DXGI_FORMAT_R16G16_SNORM:
- return FORMAT_R16G16_SNORM;
+ return Format::R16G16_SNORM;
break;
case DXGI_FORMAT_R16G16_SINT:
- return FORMAT_R16G16_SINT;
+ return Format::R16G16_SINT;
break;
case DXGI_FORMAT_R32_TYPELESS:
- return FORMAT_R32_TYPELESS;
+ return Format::R32_TYPELESS;
break;
case DXGI_FORMAT_D32_FLOAT:
- return FORMAT_D32_FLOAT;
+ return Format::D32_FLOAT;
break;
case DXGI_FORMAT_R32_FLOAT:
- return FORMAT_R32_FLOAT;
+ return Format::R32_FLOAT;
break;
case DXGI_FORMAT_R32_UINT:
- return FORMAT_R32_UINT;
+ return Format::R32_UINT;
break;
case DXGI_FORMAT_R32_SINT:
- return FORMAT_R32_SINT;
+ return Format::R32_SINT;
break;
case DXGI_FORMAT_R8G8_UNORM:
- return FORMAT_R8G8_UNORM;
+ return Format::R8G8_UNORM;
break;
case DXGI_FORMAT_R8G8_UINT:
- return FORMAT_R8G8_UINT;
+ return Format::R8G8_UINT;
break;
case DXGI_FORMAT_R8G8_SNORM:
- return FORMAT_R8G8_SNORM;
+ return Format::R8G8_SNORM;
break;
case DXGI_FORMAT_R8G8_SINT:
- return FORMAT_R8G8_SINT;
+ return Format::R8G8_SINT;
break;
case DXGI_FORMAT_R16_TYPELESS:
- return FORMAT_R16_TYPELESS;
+ return Format::R16_TYPELESS;
break;
case DXGI_FORMAT_R16_FLOAT:
- return FORMAT_R16_FLOAT;
+ return Format::R16_FLOAT;
break;
case DXGI_FORMAT_D16_UNORM:
- return FORMAT_D16_UNORM;
+ return Format::D16_UNORM;
break;
case DXGI_FORMAT_R16_UNORM:
- return FORMAT_R16_UNORM;
+ return Format::R16_UNORM;
break;
case DXGI_FORMAT_R16_UINT:
- return FORMAT_R16_UINT;
+ return Format::R16_UINT;
break;
case DXGI_FORMAT_R16_SNORM:
- return FORMAT_R16_SNORM;
+ return Format::R16_SNORM;
break;
case DXGI_FORMAT_R16_SINT:
- return FORMAT_R16_SINT;
+ return Format::R16_SINT;
break;
case DXGI_FORMAT_R8_UNORM:
- return FORMAT_R8_UNORM;
+ return Format::R8_UNORM;
break;
case DXGI_FORMAT_R8_UINT:
- return FORMAT_R8_UINT;
+ return Format::R8_UINT;
break;
case DXGI_FORMAT_R8_SNORM:
- return FORMAT_R8_SNORM;
+ return Format::R8_SNORM;
break;
case DXGI_FORMAT_R8_SINT:
- return FORMAT_R8_SINT;
+ return Format::R8_SINT;
break;
case DXGI_FORMAT_BC1_UNORM:
- return FORMAT_BC1_UNORM;
+ return Format::BC1_UNORM;
break;
case DXGI_FORMAT_BC1_UNORM_SRGB:
- return FORMAT_BC1_UNORM_SRGB;
+ return Format::BC1_UNORM_SRGB;
break;
case DXGI_FORMAT_BC2_UNORM:
- return FORMAT_BC2_UNORM;
+ return Format::BC2_UNORM;
break;
case DXGI_FORMAT_BC2_UNORM_SRGB:
- return FORMAT_BC2_UNORM_SRGB;
+ return Format::BC2_UNORM_SRGB;
break;
case DXGI_FORMAT_BC3_UNORM:
- return FORMAT_BC3_UNORM;
+ return Format::BC3_UNORM;
break;
case DXGI_FORMAT_BC3_UNORM_SRGB:
- return FORMAT_BC3_UNORM_SRGB;
+ return Format::BC3_UNORM_SRGB;
break;
case DXGI_FORMAT_BC4_UNORM:
- return FORMAT_BC4_UNORM;
+ return Format::BC4_UNORM;
break;
case DXGI_FORMAT_BC4_SNORM:
- return FORMAT_BC4_SNORM;
+ return Format::BC4_SNORM;
break;
case DXGI_FORMAT_BC5_UNORM:
- return FORMAT_BC5_UNORM;
+ return Format::BC5_UNORM;
break;
case DXGI_FORMAT_BC5_SNORM:
- return FORMAT_BC5_SNORM;
+ return Format::BC5_SNORM;
break;
case DXGI_FORMAT_B8G8R8A8_UNORM:
- return FORMAT_B8G8R8A8_UNORM;
+ return Format::B8G8R8A8_UNORM;
break;
case DXGI_FORMAT_B8G8R8A8_UNORM_SRGB:
- return FORMAT_B8G8R8A8_UNORM_SRGB;
+ return Format::B8G8R8A8_UNORM_SRGB;
break;
case DXGI_FORMAT_BC6H_UF16:
- return FORMAT_BC6H_UF16;
+ return Format::BC6H_UF16;
break;
case DXGI_FORMAT_BC6H_SF16:
- return FORMAT_BC6H_SF16;
+ return Format::BC6H_SF16;
break;
case DXGI_FORMAT_BC7_UNORM:
- return FORMAT_BC7_UNORM;
+ return Format::BC7_UNORM;
break;
case DXGI_FORMAT_BC7_UNORM_SRGB:
- return FORMAT_BC7_UNORM_SRGB;
+ return Format::BC7_UNORM_SRGB;
break;
}
- return FORMAT_UNKNOWN;
+ return Format::UNKNOWN;
}
constexpr TextureDesc _ConvertTextureDesc_Inv(const D3D12_RESOURCE_DESC& desc)
{
@@ -994,23 +994,23 @@ namespace DX12_Internal
switch (desc.Dimension)
{
case D3D12_RESOURCE_DIMENSION_TEXTURE1D:
- retVal.type = TextureDesc::TEXTURE_1D;
- retVal.ArraySize = desc.DepthOrArraySize;
+ retVal.type = TextureDesc::Type::TEXTURE_1D;
+ retVal.array_size = desc.DepthOrArraySize;
break;
default:
case D3D12_RESOURCE_DIMENSION_TEXTURE2D:
- retVal.type = TextureDesc::TEXTURE_2D;
- retVal.ArraySize = desc.DepthOrArraySize;
+ retVal.type = TextureDesc::Type::TEXTURE_2D;
+ retVal.array_size = desc.DepthOrArraySize;
break;
case D3D12_RESOURCE_DIMENSION_TEXTURE3D:
- retVal.type = TextureDesc::TEXTURE_3D;
- retVal.Depth = desc.DepthOrArraySize;
+ retVal.type = TextureDesc::Type::TEXTURE_3D;
+ retVal.depth = desc.DepthOrArraySize;
break;
}
- retVal.Format = _ConvertFormat_Inv(desc.Format);
- retVal.Width = (uint32_t)desc.Width;
- retVal.Height = desc.Height;
- retVal.MipLevels = desc.MipLevels;
+ retVal.format = _ConvertFormat_Inv(desc.Format);
+ retVal.width = (uint32_t)desc.Width;
+ retVal.height = desc.Height;
+ retVal.mip_levels = desc.MipLevels;
return retVal;
}
@@ -1420,7 +1420,7 @@ namespace DX12_Internal
Texture dummyTexture;
RenderPass renderpass;
- COLOR_SPACE colorSpace = COLOR_SPACE_SRGB;
+ ColorSpace colorSpace = ColorSpace::SRGB;
~SwapChain_DX12()
{
@@ -1534,12 +1534,12 @@ using namespace DX12_Internal;
}
CopyCMD cmd = freelist.back();
- if (cmd.uploadbuffer.desc.Size < staging_size)
+ if (cmd.uploadbuffer.desc.size < staging_size)
{
// Try to search for a staging buffer that can fit the request:
for (size_t i = 0; i < freelist.size(); ++i)
{
- if (freelist[i].uploadbuffer.desc.Size >= staging_size)
+ if (freelist[i].uploadbuffer.desc.size >= staging_size)
{
cmd = freelist[i];
std::swap(freelist[i], freelist.back());
@@ -1551,11 +1551,11 @@ using namespace DX12_Internal;
locker.unlock();
// If no buffer was found that fits the data, create one:
- if (cmd.uploadbuffer.desc.Size < staging_size)
+ if (cmd.uploadbuffer.desc.size < staging_size)
{
GPUBufferDesc uploadBufferDesc;
- uploadBufferDesc.Size = wiMath::GetNextPowerOfTwo(staging_size);
- uploadBufferDesc.Usage = USAGE_UPLOAD;
+ uploadBufferDesc.size = wiMath::GetNextPowerOfTwo(staging_size);
+ uploadBufferDesc.usage = Usage::UPLOAD;
bool upload_success = device->CreateBuffer(&uploadBufferDesc, nullptr, &cmd.uploadbuffer);
assert(upload_success);
}
@@ -1850,7 +1850,7 @@ using namespace DX12_Internal;
D3D12_CONSTANT_BUFFER_VIEW_DESC cbv;
cbv.BufferLocation = internal_state->gpu_address;
cbv.BufferLocation += offset;
- cbv.SizeInBytes = AlignTo((UINT)buffer.desc.Size, D3D12_CONSTANT_BUFFER_DATA_PLACEMENT_ALIGNMENT);
+ cbv.SizeInBytes = AlignTo((UINT)buffer.desc.size, D3D12_CONSTANT_BUFFER_DATA_PLACEMENT_ALIGNMENT);
device->device->CreateConstantBufferView(&cbv, dst);
}
@@ -1974,51 +1974,51 @@ using namespace DX12_Internal;
sampleDesc.Quality = 0;
for (auto& attachment : active_renderpass[cmd]->desc.attachments)
{
- if (attachment.type == RenderPassAttachment::RESOLVE ||
- attachment.type == RenderPassAttachment::SHADING_RATE_SOURCE ||
+ if (attachment.type == RenderPassAttachment::Type::RESOLVE ||
+ attachment.type == RenderPassAttachment::Type::SHADING_RATE_SOURCE ||
attachment.texture == nullptr)
continue;
switch (attachment.type)
{
- case RenderPassAttachment::RENDERTARGET:
- switch (attachment.texture->desc.Format)
+ case RenderPassAttachment::Type::RENDERTARGET:
+ switch (attachment.texture->desc.format)
{
- case FORMAT_R16_TYPELESS:
+ case Format::R16_TYPELESS:
formats.RTFormats[formats.NumRenderTargets] = DXGI_FORMAT_R16_UNORM;
break;
- case FORMAT_R32_TYPELESS:
+ case Format::R32_TYPELESS:
formats.RTFormats[formats.NumRenderTargets] = DXGI_FORMAT_R32_FLOAT;
break;
- case FORMAT_R24G8_TYPELESS:
+ case Format::R24G8_TYPELESS:
formats.RTFormats[formats.NumRenderTargets] = DXGI_FORMAT_R24_UNORM_X8_TYPELESS;
break;
- case FORMAT_R32G8X24_TYPELESS:
+ case Format::R32G8X24_TYPELESS:
formats.RTFormats[formats.NumRenderTargets] = DXGI_FORMAT_R32_FLOAT_X8X24_TYPELESS;
break;
default:
- formats.RTFormats[formats.NumRenderTargets] = _ConvertFormat(attachment.texture->desc.Format);
+ formats.RTFormats[formats.NumRenderTargets] = _ConvertFormat(attachment.texture->desc.format);
break;
}
formats.NumRenderTargets++;
break;
- case RenderPassAttachment::DEPTH_STENCIL:
- switch (attachment.texture->desc.Format)
+ case RenderPassAttachment::Type::DEPTH_STENCIL:
+ switch (attachment.texture->desc.format)
{
- case FORMAT_R16_TYPELESS:
+ case Format::R16_TYPELESS:
DSFormat = DXGI_FORMAT_D16_UNORM;
break;
- case FORMAT_R32_TYPELESS:
+ case Format::R32_TYPELESS:
DSFormat = DXGI_FORMAT_D32_FLOAT;
break;
- case FORMAT_R24G8_TYPELESS:
+ case Format::R24G8_TYPELESS:
DSFormat = DXGI_FORMAT_D24_UNORM_S8_UINT;
break;
- case FORMAT_R32G8X24_TYPELESS:
+ case Format::R32G8X24_TYPELESS:
DSFormat = DXGI_FORMAT_D32_FLOAT_S8X24_UINT;
break;
default:
- DSFormat = _ConvertFormat(attachment.texture->desc.Format);
+ DSFormat = _ConvertFormat(attachment.texture->desc.format);
break;
}
break;
@@ -2027,7 +2027,7 @@ using namespace DX12_Internal;
break;
}
- sampleDesc.Count = attachment.texture->desc.SampleCount;
+ sampleDesc.Count = attachment.texture->desc.sample_count;
sampleDesc.Quality = 0;
}
stream.stream1.DSFormat = DSFormat;
@@ -2037,7 +2037,7 @@ using namespace DX12_Internal;
D3D12_PIPELINE_STATE_STREAM_DESC streamDesc = {};
streamDesc.pPipelineStateSubobjectStream = &stream;
streamDesc.SizeInBytes = sizeof(stream.stream1);
- if (CheckCapability(GRAPHICSDEVICE_CAPABILITY_MESH_SHADER))
+ if (CheckCapability(GraphicsDeviceCapability::MESH_SHADER))
{
streamDesc.SizeInBytes += sizeof(stream.stream2);
}
@@ -2391,8 +2391,8 @@ using namespace DX12_Internal;
// Query features:
- capabilities |= GRAPHICSDEVICE_CAPABILITY_TESSELLATION;
- capabilities |= GRAPHICSDEVICE_CAPABILITY_PREDICATION;
+ capabilities |= GraphicsDeviceCapability::TESSELLATION;
+ capabilities |= GraphicsDeviceCapability::PREDICATION;
// Init feature check (https://devblogs.microsoft.com/directx/introducing-a-new-api-for-checking-feature-support-in-direct3d-12/)
CD3DX12FeatureSupport features;
@@ -2401,26 +2401,26 @@ using namespace DX12_Internal;
if (features.ConservativeRasterizationTier() >= D3D12_CONSERVATIVE_RASTERIZATION_TIER_1)
{
- capabilities |= GRAPHICSDEVICE_CAPABILITY_CONSERVATIVE_RASTERIZATION;
+ capabilities |= GraphicsDeviceCapability::CONSERVATIVE_RASTERIZATION;
}
if (features.ROVsSupported() == TRUE)
{
- capabilities |= GRAPHICSDEVICE_CAPABILITY_RASTERIZER_ORDERED_VIEWS;
+ capabilities |= GraphicsDeviceCapability::RASTERIZER_ORDERED_VIEWS;
}
if (features.VPAndRTArrayIndexFromAnyShaderFeedingRasterizerSupportedWithoutGSEmulation() == TRUE)
{
- capabilities |= GRAPHICSDEVICE_CAPABILITY_RENDERTARGET_AND_VIEWPORT_ARRAYINDEX_WITHOUT_GS;
+ capabilities |= GraphicsDeviceCapability::RENDERTARGET_AND_VIEWPORT_ARRAYINDEX_WITHOUT_GS;
}
if (features.TiledResourcesTier() >= D3D12_TILED_RESOURCES_TIER_2)
{
// https://docs.microsoft.com/en-us/windows/win32/direct3d11/tiled-resources-texture-sampling-features
- capabilities |= GRAPHICSDEVICE_CAPABILITY_SAMPLER_MINMAX;
+ capabilities |= GraphicsDeviceCapability::SAMPLER_MINMAX;
}
if (features.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;
+ capabilities |= GraphicsDeviceCapability::UAV_LOAD_FORMAT_COMMON;
D3D12_FORMAT_SUPPORT1 formatSupport1 = D3D12_FORMAT_SUPPORT1_NONE;
D3D12_FORMAT_SUPPORT2 formatSupport2 = D3D12_FORMAT_SUPPORT2_NONE;
@@ -2428,21 +2428,21 @@ using namespace DX12_Internal;
hr = features.FormatSupport(DXGI_FORMAT_R11G11B10_FLOAT, formatSupport1, formatSupport2);
if (SUCCEEDED(hr) && (formatSupport2 & D3D12_FORMAT_SUPPORT2_UAV_TYPED_LOAD) != 0)
{
- capabilities |= GRAPHICSDEVICE_CAPABILITY_UAV_LOAD_FORMAT_R11G11B10_FLOAT;
+ capabilities |= GraphicsDeviceCapability::UAV_LOAD_FORMAT_R11G11B10_FLOAT;
}
}
if (features.RaytracingTier() >= D3D12_RAYTRACING_TIER_1_1)
{
- capabilities |= GRAPHICSDEVICE_CAPABILITY_RAYTRACING;
+ capabilities |= GraphicsDeviceCapability::RAYTRACING;
}
if (features.VariableShadingRateTier() >= D3D12_VARIABLE_SHADING_RATE_TIER_1)
{
- capabilities |= GRAPHICSDEVICE_CAPABILITY_VARIABLE_RATE_SHADING;
+ capabilities |= GraphicsDeviceCapability::VARIABLE_RATE_SHADING;
if (features.VariableShadingRateTier() >= D3D12_VARIABLE_SHADING_RATE_TIER_2)
{
- capabilities |= GRAPHICSDEVICE_CAPABILITY_VARIABLE_RATE_SHADING_TIER2;
+ capabilities |= GraphicsDeviceCapability::VARIABLE_RATE_SHADING_TIER2;
VARIABLE_RATE_SHADING_TILE_SIZE = features.ShadingRateImageTileSize();
}
}
@@ -2451,7 +2451,7 @@ using namespace DX12_Internal;
if (features.MeshShaderTier() >= D3D12_MESH_SHADER_TIER_1)
{
- capabilities |= GRAPHICSDEVICE_CAPABILITY_MESH_SHADER;
+ capabilities |= GraphicsDeviceCapability::MESH_SHADER;
}
if (features.HighestRootSignatureVersion() < D3D_ROOT_SIGNATURE_VERSION_1_1)
@@ -2491,7 +2491,7 @@ using namespace DX12_Internal;
hr = device->CreateCommandSignature(&cmd_desc, nullptr, IID_PPV_ARGS(&drawIndexedInstancedIndirectCommandSignature));
assert(SUCCEEDED(hr));
- if (CheckCapability(GRAPHICSDEVICE_CAPABILITY_MESH_SHADER))
+ if (CheckCapability(GraphicsDeviceCapability::MESH_SHADER))
{
D3D12_INDIRECT_ARGUMENT_DESC dispatchMeshArgs[1];
dispatchMeshArgs[0].Type = D3D12_INDIRECT_ARGUMENT_TYPE_DISPATCH_MESH;
@@ -2587,7 +2587,7 @@ using namespace DX12_Internal;
nullSRV_texture3d = allocationhandler->descriptors_res.allocate();
device->CreateShaderResourceView(nullptr, &srv_desc, nullSRV_texture3d);
}
- if(CheckCapability(GRAPHICSDEVICE_CAPABILITY_RAYTRACING))
+ if(CheckCapability(GraphicsDeviceCapability::RAYTRACING))
{
D3D12_SHADER_RESOURCE_VIEW_DESC srv_desc = {};
srv_desc.Shader4ComponentMapping = D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING;
@@ -2682,7 +2682,7 @@ using namespace DX12_Internal;
swapChainDesc.SampleDesc.Count = 1;
swapChainDesc.SampleDesc.Quality = 0;
swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
- swapChainDesc.BufferCount = pDesc->buffercount;
+ swapChainDesc.BufferCount = pDesc->buffer_count;
swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_FLIP_DISCARD;
swapChainDesc.AlphaMode = DXGI_ALPHA_MODE_IGNORE;
swapChainDesc.Flags = swapChainFlags;
@@ -2736,7 +2736,7 @@ using namespace DX12_Internal;
internal_state->backbufferRTV.clear();
hr = internal_state->swapChain->ResizeBuffers(
- pDesc->buffercount,
+ pDesc->buffer_count,
pDesc->width,
pDesc->height,
_ConvertFormat(pDesc->format),
@@ -2745,21 +2745,21 @@ using namespace DX12_Internal;
assert(SUCCEEDED(hr));
}
- const bool hdr = pDesc->allow_hdr && GetSwapChainHDRSupport(swapChain);
+ const bool hdr = pDesc->allow_hdr && IsSwapChainSupportsHDR(swapChain);
// Ensure correct color space:
// https://github.com/microsoft/DirectX-Graphics-Samples/blob/master/Samples/Desktop/D3D12HDR/src/D3D12HDR.cpp
{
- internal_state->colorSpace = COLOR_SPACE_SRGB; // reset to SDR, in case anything below fails to set HDR state
+ internal_state->colorSpace = ColorSpace::SRGB; // reset to SDR, in case anything below fails to set HDR state
DXGI_COLOR_SPACE_TYPE colorSpace = {};
switch (pDesc->format)
{
- case FORMAT_R10G10B10A2_UNORM:
+ case Format::R10G10B10A2_UNORM:
// This format is either HDR10 (ST.2084), or SDR (SRGB)
colorSpace = hdr ? DXGI_COLOR_SPACE_RGB_FULL_G2084_NONE_P2020 : DXGI_COLOR_SPACE_RGB_FULL_G22_NONE_P709;
break;
- case FORMAT_R16G16B16A16_FLOAT:
+ case Format::R16G16B16A16_FLOAT:
// This format is HDR (Linear):
colorSpace = DXGI_COLOR_SPACE_RGB_FULL_G10_NONE_P709;
break;
@@ -2782,13 +2782,13 @@ using namespace DX12_Internal;
{
default:
case DXGI_COLOR_SPACE_RGB_FULL_G22_NONE_P709:
- internal_state->colorSpace = COLOR_SPACE_SRGB;
+ internal_state->colorSpace = ColorSpace::SRGB;
break;
case DXGI_COLOR_SPACE_RGB_FULL_G10_NONE_P709:
- internal_state->colorSpace = COLOR_SPACE_HDR_LINEAR;
+ internal_state->colorSpace = ColorSpace::HDR_LINEAR;
break;
case DXGI_COLOR_SPACE_RGB_FULL_G2084_NONE_P2020:
- internal_state->colorSpace = COLOR_SPACE_HDR10_ST2084;
+ internal_state->colorSpace = ColorSpace::HDR10_ST2084;
break;
}
}
@@ -2796,8 +2796,8 @@ using namespace DX12_Internal;
}
}
- internal_state->backBuffers.resize(pDesc->buffercount);
- internal_state->backbufferRTV.resize(pDesc->buffercount);
+ internal_state->backBuffers.resize(pDesc->buffer_count);
+ internal_state->backbufferRTV.resize(pDesc->buffer_count);
// We can create swapchain just with given supported format, thats why we specify format in RTV
// For example: BGRA8UNorm for SwapChain BGRA8UNormSrgb for RTV.
@@ -2805,7 +2805,7 @@ using namespace DX12_Internal;
rtvDesc.Format = _ConvertFormat(pDesc->format);
rtvDesc.ViewDimension = D3D12_RTV_DIMENSION_TEXTURE2D;
- for (uint32_t i = 0; i < pDesc->buffercount; ++i)
+ for (uint32_t i = 0; i < pDesc->buffer_count; ++i)
{
hr = internal_state->swapChain->GetBuffer(i, IID_PPV_ARGS(&internal_state->backBuffers[i]));
assert(SUCCEEDED(hr));
@@ -2814,7 +2814,7 @@ using namespace DX12_Internal;
device->CreateRenderTargetView(internal_state->backBuffers[i].Get(), &rtvDesc, internal_state->backbufferRTV[i]);
}
- internal_state->dummyTexture.desc.Format = pDesc->format;
+ internal_state->dummyTexture.desc.format = pDesc->format;
internal_state->renderpass = RenderPass();
wiHelper::hash_combine(internal_state->renderpass.hash, pDesc->format);
internal_state->renderpass.desc.attachments.push_back(RenderPassAttachment::RenderTarget(&internal_state->dummyTexture));
@@ -2826,7 +2826,7 @@ using namespace DX12_Internal;
auto internal_state = std::make_shared();
internal_state->allocationhandler = allocationhandler;
pBuffer->internal_state = internal_state;
- pBuffer->type = GPUResource::GPU_RESOURCE_TYPE::BUFFER;
+ pBuffer->type = GPUResource::Type::BUFFER;
pBuffer->mapped_data = nullptr;
pBuffer->mapped_rowpitch = 0;
@@ -2834,8 +2834,8 @@ using namespace DX12_Internal;
HRESULT hr = E_FAIL;
- UINT64 alignedSize = pDesc->Size;
- if (pDesc->BindFlags & BIND_CONSTANT_BUFFER)
+ UINT64 alignedSize = pDesc->size;
+ if (has_flag(pDesc->bind_flags, BindFlag::CONSTANT_BUFFER))
{
alignedSize = AlignTo(alignedSize, D3D12_CONSTANT_BUFFER_DATA_PLACEMENT_ALIGNMENT);
}
@@ -2850,12 +2850,12 @@ using namespace DX12_Internal;
resourceDesc.DepthOrArraySize = 1;
resourceDesc.Alignment = 0;
resourceDesc.Flags = D3D12_RESOURCE_FLAG_NONE;
- if (pDesc->BindFlags & BIND_UNORDERED_ACCESS)
+ if (has_flag(pDesc->bind_flags, BindFlag::UNORDERED_ACCESS))
{
resourceDesc.Flags |= D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS;
}
- if (!(pDesc->BindFlags & BIND_SHADER_RESOURCE) && !(pDesc->MiscFlags & RESOURCE_MISC_RAY_TRACING))
+ if (!has_flag(pDesc->bind_flags, BindFlag::SHADER_RESOURCE) && !has_flag(pDesc->misc_flags, ResourceMiscFlag::RAY_TRACING))
{
resourceDesc.Flags |= D3D12_RESOURCE_FLAG_DENY_SHADER_RESOURCE;
}
@@ -2867,13 +2867,13 @@ using namespace DX12_Internal;
D3D12MA::ALLOCATION_DESC allocationDesc = {};
allocationDesc.HeapType = D3D12_HEAP_TYPE_DEFAULT;
- if (pDesc->Usage == USAGE_READBACK)
+ if (pDesc->usage == Usage::READBACK)
{
allocationDesc.HeapType = D3D12_HEAP_TYPE_READBACK;
resourceState = D3D12_RESOURCE_STATE_COPY_DEST;
resourceDesc.Flags |= D3D12_RESOURCE_FLAG_DENY_SHADER_RESOURCE;
}
- else if (pDesc->Usage == USAGE_UPLOAD)
+ else if (pDesc->usage == Usage::UPLOAD)
{
allocationDesc.HeapType = D3D12_HEAP_TYPE_UPLOAD;
resourceState = D3D12_RESOURCE_STATE_GENERIC_READ;
@@ -2893,33 +2893,33 @@ using namespace DX12_Internal;
internal_state->gpu_address = internal_state->resource->GetGPUVirtualAddress();
- if (pDesc->Usage == USAGE_READBACK)
+ if (pDesc->usage == Usage::READBACK)
{
hr = internal_state->resource->Map(0, nullptr, &pBuffer->mapped_data);
assert(SUCCEEDED(hr));
- pBuffer->mapped_rowpitch = static_cast(pDesc->Size);
+ pBuffer->mapped_rowpitch = static_cast(pDesc->size);
}
- else if (pDesc->Usage == USAGE_UPLOAD)
+ 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 = static_cast(pDesc->Size);
+ pBuffer->mapped_rowpitch = static_cast(pDesc->size);
}
// Issue data copy on request:
if (pInitialData != nullptr)
{
- auto cmd = copyAllocator.allocate(pDesc->Size);
+ auto cmd = copyAllocator.allocate(pDesc->size);
- memcpy(cmd.uploadbuffer.mapped_data, pInitialData, pDesc->Size);
+ memcpy(cmd.uploadbuffer.mapped_data, pInitialData, pDesc->size);
cmd.commandList->CopyBufferRegion(
internal_state->resource.Get(),
0,
to_internal(&cmd.uploadbuffer)->resource.Get(),
0,
- pDesc->Size
+ pDesc->size
);
copyAllocator.submit(cmd);
@@ -2927,13 +2927,13 @@ using namespace DX12_Internal;
// Create resource views if needed
- if (pDesc->BindFlags & BIND_SHADER_RESOURCE)
+ if (has_flag(pDesc->bind_flags, BindFlag::SHADER_RESOURCE))
{
- CreateSubresource(pBuffer, SRV, 0);
+ CreateSubresource(pBuffer, SubresourceType::SRV, 0);
}
- if (pDesc->BindFlags & BIND_UNORDERED_ACCESS)
+ if (has_flag(pDesc->bind_flags, BindFlag::UNORDERED_ACCESS))
{
- CreateSubresource(pBuffer, UAV, 0);
+ CreateSubresource(pBuffer, SubresourceType::UAV, 0);
}
return SUCCEEDED(hr);
@@ -2943,7 +2943,7 @@ using namespace DX12_Internal;
auto internal_state = std::make_shared();
internal_state->allocationhandler = allocationhandler;
pTexture->internal_state = internal_state;
- pTexture->type = GPUResource::GPU_RESOURCE_TYPE::TEXTURE;
+ pTexture->type = GPUResource::Type::TEXTURE;
pTexture->mapped_data = nullptr;
pTexture->mapped_rowpitch = 0;
@@ -2956,46 +2956,46 @@ using namespace DX12_Internal;
allocationDesc.HeapType = D3D12_HEAP_TYPE_DEFAULT;
D3D12_RESOURCE_DESC desc;
- desc.Format = _ConvertFormat(pDesc->Format);
- desc.Width = pDesc->Width;
- desc.Height = pDesc->Height;
- desc.MipLevels = pDesc->MipLevels;
+ desc.Format = _ConvertFormat(pDesc->format);
+ desc.Width = pDesc->width;
+ desc.Height = pDesc->height;
+ desc.MipLevels = pDesc->mip_levels;
desc.Layout = D3D12_TEXTURE_LAYOUT_UNKNOWN;
- desc.DepthOrArraySize = (UINT16)pDesc->ArraySize;
- desc.SampleDesc.Count = pDesc->SampleCount;
+ desc.DepthOrArraySize = (UINT16)pDesc->array_size;
+ desc.SampleDesc.Count = pDesc->sample_count;
desc.SampleDesc.Quality = 0;
desc.Alignment = 0;
desc.Flags = D3D12_RESOURCE_FLAG_NONE;
- if (pDesc->BindFlags & BIND_DEPTH_STENCIL)
+ if (has_flag(pDesc->bind_flags, BindFlag::DEPTH_STENCIL))
{
desc.Flags |= D3D12_RESOURCE_FLAG_ALLOW_DEPTH_STENCIL;
//allocationDesc.Flags |= D3D12MA::ALLOCATION_FLAG_COMMITTED;
- if (!(pDesc->BindFlags & BIND_SHADER_RESOURCE))
+ if (!has_flag(pDesc->bind_flags, BindFlag::SHADER_RESOURCE))
{
desc.Flags |= D3D12_RESOURCE_FLAG_DENY_SHADER_RESOURCE;
}
}
- if (pDesc->BindFlags & BIND_RENDER_TARGET)
+ if (has_flag(pDesc->bind_flags, BindFlag::RENDER_TARGET))
{
desc.Flags |= D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET;
//allocationDesc.Flags |= D3D12MA::ALLOCATION_FLAG_COMMITTED;
}
- if (pDesc->BindFlags & BIND_UNORDERED_ACCESS)
+ if (has_flag(pDesc->bind_flags, BindFlag::UNORDERED_ACCESS))
{
desc.Flags |= D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS;
}
switch (pTexture->desc.type)
{
- case TextureDesc::TEXTURE_1D:
+ case TextureDesc::Type::TEXTURE_1D:
desc.Dimension = D3D12_RESOURCE_DIMENSION_TEXTURE1D;
break;
- case TextureDesc::TEXTURE_2D:
+ case TextureDesc::Type::TEXTURE_2D:
desc.Dimension = D3D12_RESOURCE_DIMENSION_TEXTURE2D;
break;
- case TextureDesc::TEXTURE_3D:
+ case TextureDesc::Type::TEXTURE_3D:
desc.Dimension = D3D12_RESOURCE_DIMENSION_TEXTURE3D;
- desc.DepthOrArraySize = (UINT16)pDesc->Depth;
+ desc.DepthOrArraySize = (UINT16)pDesc->depth;
break;
default:
assert(0);
@@ -3007,8 +3007,8 @@ using namespace DX12_Internal;
optimizedClearValue.Color[1] = pTexture->desc.clear.color[1];
optimizedClearValue.Color[2] = pTexture->desc.clear.color[2];
optimizedClearValue.Color[3] = pTexture->desc.clear.color[3];
- optimizedClearValue.DepthStencil.Depth = pTexture->desc.clear.depthstencil.depth;
- optimizedClearValue.DepthStencil.Stencil = pTexture->desc.clear.depthstencil.stencil;
+ optimizedClearValue.DepthStencil.Depth = pTexture->desc.clear.depth_stencil.depth;
+ optimizedClearValue.DepthStencil.Stencil = pTexture->desc.clear.depth_stencil.stencil;
optimizedClearValue.Format = desc.Format;
if (optimizedClearValue.Format == DXGI_FORMAT_R16_TYPELESS)
{
@@ -3022,7 +3022,7 @@ using namespace DX12_Internal;
{
optimizedClearValue.Format = DXGI_FORMAT_D32_FLOAT_S8X24_UINT;
}
- bool useClearValue = pDesc->BindFlags & BIND_RENDER_TARGET || pDesc->BindFlags & BIND_DEPTH_STENCIL;
+ bool useClearValue = has_flag(pDesc->bind_flags, BindFlag::RENDER_TARGET) || has_flag(pDesc->bind_flags, BindFlag::DEPTH_STENCIL);
D3D12_RESOURCE_STATES resourceState = _ParseResourceState(pTexture->desc.layout);
@@ -3031,7 +3031,7 @@ using namespace DX12_Internal;
resourceState = D3D12_RESOURCE_STATE_COMMON;
}
- if (pTexture->desc.Usage == USAGE_READBACK || pTexture->desc.Usage == USAGE_UPLOAD)
+ 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);
@@ -3043,12 +3043,12 @@ using namespace DX12_Internal;
desc.Layout = D3D12_TEXTURE_LAYOUT_ROW_MAJOR;
desc.Flags = D3D12_RESOURCE_FLAG_NONE;
- if (pTexture->desc.Usage == USAGE_READBACK)
+ if (pTexture->desc.usage == Usage::READBACK)
{
allocationDesc.HeapType = D3D12_HEAP_TYPE_READBACK;
resourceState = D3D12_RESOURCE_STATE_COPY_DEST;
}
- else if(pTexture->desc.Usage == USAGE_UPLOAD)
+ else if(pTexture->desc.usage == Usage::UPLOAD)
{
allocationDesc.HeapType = D3D12_HEAP_TYPE_UPLOAD;
resourceState = D3D12_RESOURCE_STATE_GENERIC_READ;
@@ -3065,13 +3065,13 @@ using namespace DX12_Internal;
);
assert(SUCCEEDED(hr));
- if (pTexture->desc.Usage == USAGE_READBACK)
+ 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)
+ else if(pTexture->desc.usage == Usage::UPLOAD)
{
D3D12_RANGE read_range = {};
hr = internal_state->resource->Map(0, &read_range, &pTexture->mapped_data);
@@ -3079,15 +3079,15 @@ using namespace DX12_Internal;
pTexture->mapped_rowpitch = internal_state->footprint.Footprint.RowPitch;
}
- if (pTexture->desc.MipLevels == 0)
+ if (pTexture->desc.mip_levels == 0)
{
- pTexture->desc.MipLevels = (uint32_t)log2(std::max(pTexture->desc.Width, pTexture->desc.Height)) + 1;
+ pTexture->desc.mip_levels = (uint32_t)log2(std::max(pTexture->desc.width, pTexture->desc.height)) + 1;
}
// Issue data copy on request:
if (pInitialData != nullptr)
{
- uint32_t dataCount = pDesc->ArraySize * std::max(1u, pDesc->MipLevels);
+ uint32_t dataCount = pDesc->array_size * std::max(1u, pDesc->mip_levels);
std::vector data(dataCount);
for (uint32_t slice = 0; slice < dataCount; ++slice)
{
@@ -3130,26 +3130,26 @@ using namespace DX12_Internal;
copyAllocator.submit(cmd);
}
- if (pTexture->desc.BindFlags & BIND_RENDER_TARGET)
+ if (has_flag(pTexture->desc.bind_flags, BindFlag::RENDER_TARGET))
{
- CreateSubresource(pTexture, RTV, 0, -1, 0, -1);
+ CreateSubresource(pTexture, SubresourceType::RTV, 0, -1, 0, -1);
}
- if (pTexture->desc.BindFlags & BIND_DEPTH_STENCIL)
+ if (has_flag(pTexture->desc.bind_flags, BindFlag::DEPTH_STENCIL))
{
- CreateSubresource(pTexture, DSV, 0, -1, 0, -1);
+ CreateSubresource(pTexture, SubresourceType::DSV, 0, -1, 0, -1);
}
- if (pTexture->desc.BindFlags & BIND_SHADER_RESOURCE)
+ if (has_flag(pTexture->desc.bind_flags, BindFlag::SHADER_RESOURCE))
{
- CreateSubresource(pTexture, SRV, 0, -1, 0, -1);
+ CreateSubresource(pTexture, SubresourceType::SRV, 0, -1, 0, -1);
}
- if (pTexture->desc.BindFlags & BIND_UNORDERED_ACCESS)
+ if (has_flag(pTexture->desc.bind_flags, BindFlag::UNORDERED_ACCESS))
{
- CreateSubresource(pTexture, UAV, 0, -1, 0, -1);
+ CreateSubresource(pTexture, SubresourceType::UAV, 0, -1, 0, -1);
}
return SUCCEEDED(hr);
}
- bool GraphicsDevice_DX12::CreateShader(SHADERSTAGE stage, const void* pShaderBytecode, size_t BytecodeLength, Shader* pShader) const
+ bool GraphicsDevice_DX12::CreateShader(ShaderStage stage, const void* pShaderBytecode, size_t BytecodeLength, Shader* pShader) const
{
auto internal_state = std::make_shared();
internal_state->allocationhandler = allocationhandler;
@@ -3401,7 +3401,7 @@ using namespace DX12_Internal;
ReflectionData.Ptr = pShaderBytecode;
ReflectionData.Size = (SIZE_T)BytecodeLength;
- if (stage == LIB)
+ if (stage == ShaderStage::LIB)
{
ComPtr reflection;
hr = dxcUtils->CreateReflection(&ReflectionData, IID_PPV_ARGS(&reflection));
@@ -3471,25 +3471,25 @@ using namespace DX12_Internal;
{
switch (stage)
{
- case MS:
+ case ShaderStage::MS:
sam.ShaderVisibility = D3D12_SHADER_VISIBILITY_MESH;
break;
- case AS:
+ case ShaderStage::AS:
sam.ShaderVisibility = D3D12_SHADER_VISIBILITY_AMPLIFICATION;
break;
- case VS:
+ case ShaderStage::VS:
sam.ShaderVisibility = D3D12_SHADER_VISIBILITY_VERTEX;
break;
- case HS:
+ case ShaderStage::HS:
sam.ShaderVisibility = D3D12_SHADER_VISIBILITY_HULL;
break;
- case DS:
+ case ShaderStage::DS:
sam.ShaderVisibility = D3D12_SHADER_VISIBILITY_DOMAIN;
break;
- case GS:
+ case ShaderStage::GS:
sam.ShaderVisibility = D3D12_SHADER_VISIBILITY_GEOMETRY;
break;
- case PS:
+ case ShaderStage::PS:
sam.ShaderVisibility = D3D12_SHADER_VISIBILITY_PIXEL;
break;
default:
@@ -3499,7 +3499,7 @@ using namespace DX12_Internal;
}
- if (stage == CS || stage == LIB)
+ if (stage == ShaderStage::CS || stage == ShaderStage::LIB)
{
std::vector params;
@@ -3708,7 +3708,7 @@ using namespace DX12_Internal;
}
}
- if (stage == CS)
+ if (stage == ShaderStage::CS)
{
struct PSO_STREAM
{
@@ -3736,23 +3736,23 @@ using namespace DX12_Internal;
pSamplerState->internal_state = internal_state;
D3D12_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)
+ desc.Filter = _ConvertFilter(pSamplerDesc->filter);
+ desc.AddressU = _ConvertTextureAddressMode(pSamplerDesc->address_u);
+ desc.AddressV = _ConvertTextureAddressMode(pSamplerDesc->address_v);
+ desc.AddressW = _ConvertTextureAddressMode(pSamplerDesc->address_w);
+ desc.MipLODBias = pSamplerDesc->mip_lod_bias;
+ desc.MaxAnisotropy = pSamplerDesc->max_anisotropy;
+ desc.ComparisonFunc = _ConvertComparisonFunc(pSamplerDesc->comparison_func);
+ switch (pSamplerDesc->border_color)
{
- case SAMPLER_BORDER_COLOR_OPAQUE_BLACK:
+ case SamplerBorderColor::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:
+ case SamplerBorderColor::OPAQUE_WHITE:
desc.BorderColor[0] = 1.0f;
desc.BorderColor[1] = 1.0f;
desc.BorderColor[2] = 1.0f;
@@ -3766,8 +3766,8 @@ using namespace DX12_Internal;
desc.BorderColor[3] = 0.0f;
break;
}
- desc.MinLOD = pSamplerDesc->MinLOD;
- desc.MaxLOD = pSamplerDesc->MaxLOD;
+ desc.MinLOD = pSamplerDesc->min_lod;
+ desc.MaxLOD = pSamplerDesc->max_lod;
pSamplerState->desc = *pSamplerDesc;
@@ -3784,16 +3784,16 @@ using namespace DX12_Internal;
pQueryHeap->desc = *pDesc;
D3D12_QUERY_HEAP_DESC desc = {};
- desc.Count = pDesc->queryCount;
+ desc.Count = pDesc->query_count;
switch (pDesc->type)
{
default:
- case GPU_QUERY_TYPE_TIMESTAMP:
+ case GpuQueryType::TIMESTAMP:
desc.Type = D3D12_QUERY_HEAP_TYPE_TIMESTAMP;
break;
- case GPU_QUERY_TYPE_OCCLUSION:
- case GPU_QUERY_TYPE_OCCLUSION_BINARY:
+ case GpuQueryType::OCCLUSION:
+ case GpuQueryType::OCCLUSION_BINARY:
desc.Type = D3D12_QUERY_HEAP_TYPE_OCCLUSION;
break;
}
@@ -3824,7 +3824,7 @@ using namespace DX12_Internal;
wiHelper::hash_combine(pso->hash, pDesc->bs);
wiHelper::hash_combine(pso->hash, pDesc->dss);
wiHelper::hash_combine(pso->hash, pDesc->pt);
- wiHelper::hash_combine(pso->hash, pDesc->sampleMask);
+ wiHelper::hash_combine(pso->hash, pDesc->sample_mask);
HRESULT hr = S_OK;
@@ -4205,51 +4205,51 @@ using namespace DX12_Internal;
RasterizerState pRasterizerStateDesc = pso->desc.rs != nullptr ? *pso->desc.rs : RasterizerState();
CD3DX12_RASTERIZER_DESC rs = {};
- rs.FillMode = _ConvertFillMode(pRasterizerStateDesc.FillMode);
- rs.CullMode = _ConvertCullMode(pRasterizerStateDesc.CullMode);
- rs.FrontCounterClockwise = pRasterizerStateDesc.FrontCounterClockwise;
- rs.DepthBias = pRasterizerStateDesc.DepthBias;
- rs.DepthBiasClamp = pRasterizerStateDesc.DepthBiasClamp;
- rs.SlopeScaledDepthBias = pRasterizerStateDesc.SlopeScaledDepthBias;
- rs.DepthClipEnable = pRasterizerStateDesc.DepthClipEnable;
- rs.MultisampleEnable = pRasterizerStateDesc.MultisampleEnable;
- rs.AntialiasedLineEnable = pRasterizerStateDesc.AntialiasedLineEnable;
- rs.ConservativeRaster = ((CheckCapability(GRAPHICSDEVICE_CAPABILITY_CONSERVATIVE_RASTERIZATION) && pRasterizerStateDesc.ConservativeRasterizationEnable) ? D3D12_CONSERVATIVE_RASTERIZATION_MODE_ON : D3D12_CONSERVATIVE_RASTERIZATION_MODE_OFF);
- rs.ForcedSampleCount = pRasterizerStateDesc.ForcedSampleCount;
+ rs.FillMode = _ConvertFillMode(pRasterizerStateDesc.fill_mode);
+ rs.CullMode = _ConvertCullMode(pRasterizerStateDesc.cull_mode);
+ rs.FrontCounterClockwise = pRasterizerStateDesc.front_counter_clockwise;
+ rs.DepthBias = pRasterizerStateDesc.depth_bias;
+ rs.DepthBiasClamp = pRasterizerStateDesc.depth_bias_clamp;
+ rs.SlopeScaledDepthBias = pRasterizerStateDesc.slope_scaled_depth_bias;
+ rs.DepthClipEnable = pRasterizerStateDesc.depth_clip_enable;
+ rs.MultisampleEnable = pRasterizerStateDesc.multisample_enable;
+ rs.AntialiasedLineEnable = pRasterizerStateDesc.antialiased_line_enable;
+ rs.ConservativeRaster = ((CheckCapability(GraphicsDeviceCapability::CONSERVATIVE_RASTERIZATION) && pRasterizerStateDesc.conservative_rasterization_enable) ? D3D12_CONSERVATIVE_RASTERIZATION_MODE_ON : D3D12_CONSERVATIVE_RASTERIZATION_MODE_OFF);
+ rs.ForcedSampleCount = pRasterizerStateDesc.forced_sample_count;
stream.stream1.RS = rs;
DepthStencilState pDepthStencilStateDesc = pso->desc.dss != nullptr ? *pso->desc.dss : DepthStencilState();
CD3DX12_DEPTH_STENCIL_DESC dss = {};
- dss.DepthEnable = pDepthStencilStateDesc.DepthEnable;
- dss.DepthWriteMask = _ConvertDepthWriteMask(pDepthStencilStateDesc.DepthWriteMask);
- dss.DepthFunc = _ConvertComparisonFunc(pDepthStencilStateDesc.DepthFunc);
- dss.StencilEnable = pDepthStencilStateDesc.StencilEnable;
- dss.StencilReadMask = pDepthStencilStateDesc.StencilReadMask;
- dss.StencilWriteMask = pDepthStencilStateDesc.StencilWriteMask;
- dss.FrontFace.StencilDepthFailOp = _ConvertStencilOp(pDepthStencilStateDesc.FrontFace.StencilDepthFailOp);
- dss.FrontFace.StencilFailOp = _ConvertStencilOp(pDepthStencilStateDesc.FrontFace.StencilFailOp);
- dss.FrontFace.StencilFunc = _ConvertComparisonFunc(pDepthStencilStateDesc.FrontFace.StencilFunc);
- dss.FrontFace.StencilPassOp = _ConvertStencilOp(pDepthStencilStateDesc.FrontFace.StencilPassOp);
- dss.BackFace.StencilDepthFailOp = _ConvertStencilOp(pDepthStencilStateDesc.BackFace.StencilDepthFailOp);
- dss.BackFace.StencilFailOp = _ConvertStencilOp(pDepthStencilStateDesc.BackFace.StencilFailOp);
- dss.BackFace.StencilFunc = _ConvertComparisonFunc(pDepthStencilStateDesc.BackFace.StencilFunc);
- dss.BackFace.StencilPassOp = _ConvertStencilOp(pDepthStencilStateDesc.BackFace.StencilPassOp);
+ dss.DepthEnable = pDepthStencilStateDesc.depth_enable;
+ dss.DepthWriteMask = _ConvertDepthWriteMask(pDepthStencilStateDesc.depth_write_mask);
+ dss.DepthFunc = _ConvertComparisonFunc(pDepthStencilStateDesc.depth_func);
+ dss.StencilEnable = pDepthStencilStateDesc.stencil_enable;
+ dss.StencilReadMask = pDepthStencilStateDesc.stencil_read_mask;
+ dss.StencilWriteMask = pDepthStencilStateDesc.stencil_write_mask;
+ dss.FrontFace.StencilDepthFailOp = _ConvertStencilOp(pDepthStencilStateDesc.front_face.stencil_depth_fail_op);
+ dss.FrontFace.StencilFailOp = _ConvertStencilOp(pDepthStencilStateDesc.front_face.stencil_fail_op);
+ dss.FrontFace.StencilFunc = _ConvertComparisonFunc(pDepthStencilStateDesc.front_face.stencil_func);
+ dss.FrontFace.StencilPassOp = _ConvertStencilOp(pDepthStencilStateDesc.front_face.stencil_pass_op);
+ dss.BackFace.StencilDepthFailOp = _ConvertStencilOp(pDepthStencilStateDesc.back_face.stencil_depth_fail_op);
+ dss.BackFace.StencilFailOp = _ConvertStencilOp(pDepthStencilStateDesc.back_face.stencil_fail_op);
+ dss.BackFace.StencilFunc = _ConvertComparisonFunc(pDepthStencilStateDesc.back_face.stencil_func);
+ dss.BackFace.StencilPassOp = _ConvertStencilOp(pDepthStencilStateDesc.back_face.stencil_pass_op);
stream.stream1.DSS = dss;
BlendState pBlendStateDesc = pso->desc.bs != nullptr ? *pso->desc.bs : BlendState();
CD3DX12_BLEND_DESC bd = {};
- bd.AlphaToCoverageEnable = pBlendStateDesc.AlphaToCoverageEnable;
- bd.IndependentBlendEnable = pBlendStateDesc.IndependentBlendEnable;
+ bd.AlphaToCoverageEnable = pBlendStateDesc.alpha_to_coverage_enable;
+ bd.IndependentBlendEnable = pBlendStateDesc.independent_blend_enable;
for (int i = 0; i < 8; ++i)
{
- bd.RenderTarget[i].BlendEnable = pBlendStateDesc.RenderTarget[i].BlendEnable;
- bd.RenderTarget[i].SrcBlend = _ConvertBlend(pBlendStateDesc.RenderTarget[i].SrcBlend);
- bd.RenderTarget[i].DestBlend = _ConvertBlend(pBlendStateDesc.RenderTarget[i].DestBlend);
- bd.RenderTarget[i].BlendOp = _ConvertBlendOp(pBlendStateDesc.RenderTarget[i].BlendOp);
- bd.RenderTarget[i].SrcBlendAlpha = _ConvertAlphaBlend(pBlendStateDesc.RenderTarget[i].SrcBlendAlpha);
- bd.RenderTarget[i].DestBlendAlpha = _ConvertAlphaBlend(pBlendStateDesc.RenderTarget[i].DestBlendAlpha);
- bd.RenderTarget[i].BlendOpAlpha = _ConvertBlendOp(pBlendStateDesc.RenderTarget[i].BlendOpAlpha);
- bd.RenderTarget[i].RenderTargetWriteMask = _ParseColorWriteMask(pBlendStateDesc.RenderTarget[i].RenderTargetWriteMask);
+ bd.RenderTarget[i].BlendEnable = pBlendStateDesc.render_target[i].blend_enable;
+ bd.RenderTarget[i].SrcBlend = _ConvertBlend(pBlendStateDesc.render_target[i].src_blend);
+ bd.RenderTarget[i].DestBlend = _ConvertBlend(pBlendStateDesc.render_target[i].dest_blend);
+ bd.RenderTarget[i].BlendOp = _ConvertBlendOp(pBlendStateDesc.render_target[i].blend_op);
+ bd.RenderTarget[i].SrcBlendAlpha = _ConvertAlphaBlend(pBlendStateDesc.render_target[i].src_blend_alpha);
+ bd.RenderTarget[i].DestBlendAlpha = _ConvertAlphaBlend(pBlendStateDesc.render_target[i].dest_blend_alpha);
+ bd.RenderTarget[i].BlendOpAlpha = _ConvertBlendOp(pBlendStateDesc.render_target[i].blend_op_alpha);
+ bd.RenderTarget[i].RenderTargetWriteMask = _ParseColorWriteMask(pBlendStateDesc.render_target[i].render_target_write_mask);
}
stream.stream1.BD = bd;
@@ -4261,14 +4261,14 @@ using namespace DX12_Internal;
elements.resize(il.NumElements);
for (uint32_t i = 0; i < il.NumElements; ++i)
{
- elements[i].SemanticName = pso->desc.il->elements[i].SemanticName.c_str();
- elements[i].SemanticIndex = pso->desc.il->elements[i].SemanticIndex;
- elements[i].Format = _ConvertFormat(pso->desc.il->elements[i].Format);
- elements[i].InputSlot = pso->desc.il->elements[i].InputSlot;
- elements[i].AlignedByteOffset = pso->desc.il->elements[i].AlignedByteOffset;
+ elements[i].SemanticName = pso->desc.il->elements[i].semantic_name.c_str();
+ elements[i].SemanticIndex = pso->desc.il->elements[i].semantic_index;
+ elements[i].Format = _ConvertFormat(pso->desc.il->elements[i].format);
+ elements[i].InputSlot = pso->desc.il->elements[i].input_slot;
+ elements[i].AlignedByteOffset = pso->desc.il->elements[i].aligned_byte_offset;
if (elements[i].AlignedByteOffset == InputLayout::APPEND_ALIGNED_ELEMENT)
elements[i].AlignedByteOffset = D3D12_APPEND_ALIGNED_ELEMENT;
- elements[i].InputSlotClass = _ConvertInputClassification(pso->desc.il->elements[i].InputSlotClass);
+ elements[i].InputSlotClass = _ConvertInputClassification(pso->desc.il->elements[i].input_slot_class);
elements[i].InstanceDataStepRate = 0;
if (elements[i].InputSlotClass == D3D12_INPUT_CLASSIFICATION_PER_INSTANCE_DATA)
{
@@ -4279,23 +4279,23 @@ using namespace DX12_Internal;
il.pInputElementDescs = elements.data();
stream.stream1.IL = il;
- stream.stream1.SampleMask = pso->desc.sampleMask;
+ stream.stream1.SampleMask = pso->desc.sample_mask;
- internal_state->primitiveTopology = _ConvertPrimitiveTopology(pDesc->pt, pDesc->patchControlPoints);
+ internal_state->primitiveTopology = _ConvertPrimitiveTopology(pDesc->pt, pDesc->patch_control_points);
switch (pso->desc.pt)
{
- case POINTLIST:
+ case PrimitiveTopology::POINTLIST:
stream.stream1.PT = D3D12_PRIMITIVE_TOPOLOGY_TYPE_POINT;
break;
- case LINELIST:
- case LINESTRIP:
+ case PrimitiveTopology::LINELIST:
+ case PrimitiveTopology::LINESTRIP:
stream.stream1.PT = D3D12_PRIMITIVE_TOPOLOGY_TYPE_LINE;
break;
- case TRIANGLELIST:
- case TRIANGLESTRIP:
+ case PrimitiveTopology::TRIANGLELIST:
+ case PrimitiveTopology::TRIANGLESTRIP:
stream.stream1.PT = D3D12_PRIMITIVE_TOPOLOGY_TYPE_TRIANGLE;
break;
- case PATCHLIST:
+ case PrimitiveTopology::PATCHLIST:
stream.stream1.PT = D3D12_PRIMITIVE_TOPOLOGY_TYPE_PATCH;
break;
default:
@@ -4316,7 +4316,7 @@ using namespace DX12_Internal;
renderpass->desc = *pDesc;
- if (renderpass->desc._flags & RenderPassDesc::FLAG_ALLOW_UAV_WRITES)
+ if (has_flag(renderpass->desc.flags, RenderPassDesc::Flags::ALLOW_UAV_WRITES))
{
internal_state->flags |= D3D12_RENDER_PASS_FLAG_ALLOW_UAV_WRITES;
}
@@ -4326,10 +4326,10 @@ using namespace DX12_Internal;
int resolve_dst_counter = 0;
for (auto& attachment : pDesc->attachments)
{
- if (attachment.type == RenderPassAttachment::RENDERTARGET || attachment.type == RenderPassAttachment::DEPTH_STENCIL)
+ if (attachment.type == RenderPassAttachment::Type::RENDERTARGET || attachment.type == RenderPassAttachment::Type::DEPTH_STENCIL)
{
- wiHelper::hash_combine(renderpass->hash, attachment.texture->desc.Format);
- wiHelper::hash_combine(renderpass->hash, attachment.texture->desc.SampleCount);
+ wiHelper::hash_combine(renderpass->hash, attachment.texture->desc.format);
+ wiHelper::hash_combine(renderpass->hash, attachment.texture->desc.sample_count);
}
const Texture* texture = attachment.texture;
@@ -4337,9 +4337,9 @@ using namespace DX12_Internal;
auto texture_internal = to_internal(texture);
D3D12_CLEAR_VALUE clear_value;
- clear_value.Format = _ConvertFormat(texture->desc.Format);
+ clear_value.Format = _ConvertFormat(texture->desc.format);
- if (attachment.type == RenderPassAttachment::RENDERTARGET)
+ if (attachment.type == RenderPassAttachment::Type::RENDERTARGET)
{
if (subresource < 0 || texture_internal->subresources_rtv.empty())
@@ -4355,10 +4355,10 @@ using namespace DX12_Internal;
switch (attachment.loadop)
{
default:
- case RenderPassAttachment::LOADOP_LOAD:
+ case RenderPassAttachment::LoadOp::LOAD:
internal_state->RTVs[internal_state->rt_count].BeginningAccess.Type = D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_PRESERVE;
break;
- case RenderPassAttachment::LOADOP_CLEAR:
+ case RenderPassAttachment::LoadOp::CLEAR:
internal_state->RTVs[internal_state->rt_count].BeginningAccess.Type = D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_CLEAR;
clear_value.Color[0] = texture->desc.clear.color[0];
clear_value.Color[1] = texture->desc.clear.color[1];
@@ -4366,7 +4366,7 @@ using namespace DX12_Internal;
clear_value.Color[3] = texture->desc.clear.color[3];
internal_state->RTVs[internal_state->rt_count].BeginningAccess.Clear.ClearValue = clear_value;
break;
- case RenderPassAttachment::LOADOP_DONTCARE:
+ case RenderPassAttachment::LoadOp::DONTCARE:
internal_state->RTVs[internal_state->rt_count].BeginningAccess.Type = D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_DISCARD;
break;
}
@@ -4374,17 +4374,17 @@ using namespace DX12_Internal;
switch (attachment.storeop)
{
default:
- case RenderPassAttachment::STOREOP_STORE:
+ case RenderPassAttachment::StoreOp::STORE:
internal_state->RTVs[internal_state->rt_count].EndingAccess.Type = D3D12_RENDER_PASS_ENDING_ACCESS_TYPE_PRESERVE;
break;
- case RenderPassAttachment::STOREOP_DONTCARE:
+ case RenderPassAttachment::StoreOp::DONTCARE:
internal_state->RTVs[internal_state->rt_count].EndingAccess.Type = D3D12_RENDER_PASS_ENDING_ACCESS_TYPE_DISCARD;
break;
}
internal_state->rt_count++;
}
- else if (attachment.type == RenderPassAttachment::DEPTH_STENCIL)
+ else if (attachment.type == RenderPassAttachment::Type::DEPTH_STENCIL)
{
if (subresource < 0 || texture_internal->subresources_dsv.empty())
{
@@ -4399,19 +4399,19 @@ using namespace DX12_Internal;
switch (attachment.loadop)
{
default:
- case RenderPassAttachment::LOADOP_LOAD:
+ case RenderPassAttachment::LoadOp::LOAD:
internal_state->DSV.DepthBeginningAccess.Type = D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_PRESERVE;
internal_state->DSV.StencilBeginningAccess.Type = D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_PRESERVE;
break;
- case RenderPassAttachment::LOADOP_CLEAR:
+ case RenderPassAttachment::LoadOp::CLEAR:
internal_state->DSV.DepthBeginningAccess.Type = D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_CLEAR;
internal_state->DSV.StencilBeginningAccess.Type = D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_CLEAR;
- clear_value.DepthStencil.Depth = texture->desc.clear.depthstencil.depth;
- clear_value.DepthStencil.Stencil = texture->desc.clear.depthstencil.stencil;
+ clear_value.DepthStencil.Depth = texture->desc.clear.depth_stencil.depth;
+ clear_value.DepthStencil.Stencil = texture->desc.clear.depth_stencil.stencil;
internal_state->DSV.DepthBeginningAccess.Clear.ClearValue = clear_value;
internal_state->DSV.StencilBeginningAccess.Clear.ClearValue = clear_value;
break;
- case RenderPassAttachment::LOADOP_DONTCARE:
+ case RenderPassAttachment::LoadOp::DONTCARE:
internal_state->DSV.DepthBeginningAccess.Type = D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_DISCARD;
internal_state->DSV.StencilBeginningAccess.Type = D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_DISCARD;
break;
@@ -4420,24 +4420,24 @@ using namespace DX12_Internal;
switch (attachment.storeop)
{
default:
- case RenderPassAttachment::STOREOP_STORE:
+ case RenderPassAttachment::StoreOp::STORE:
internal_state->DSV.DepthEndingAccess.Type = D3D12_RENDER_PASS_ENDING_ACCESS_TYPE_PRESERVE;
internal_state->DSV.StencilEndingAccess.Type = D3D12_RENDER_PASS_ENDING_ACCESS_TYPE_PRESERVE;
break;
- case RenderPassAttachment::STOREOP_DONTCARE:
+ case RenderPassAttachment::StoreOp::DONTCARE:
internal_state->DSV.DepthEndingAccess.Type = D3D12_RENDER_PASS_ENDING_ACCESS_TYPE_DISCARD;
internal_state->DSV.StencilEndingAccess.Type = D3D12_RENDER_PASS_ENDING_ACCESS_TYPE_DISCARD;
break;
}
}
- else if (attachment.type == RenderPassAttachment::RESOLVE)
+ else if (attachment.type == RenderPassAttachment::Type::RESOLVE)
{
if (texture != nullptr)
{
int resolve_src_counter = 0;
for (auto& src : renderpass->desc.attachments)
{
- if (src.type == RenderPassAttachment::RENDERTARGET && src.texture != nullptr)
+ if (src.type == RenderPassAttachment::Type::RENDERTARGET && src.texture != nullptr)
{
if (resolve_src_counter == resolve_dst_counter)
{
@@ -4454,8 +4454,8 @@ using namespace DX12_Internal;
src_RTV.EndingAccess.Resolve.pSubresourceParameters = &internal_state->resolve_subresources[resolve_src_counter];
internal_state->resolve_subresources[resolve_src_counter].SrcRect.left = 0;
- internal_state->resolve_subresources[resolve_src_counter].SrcRect.right = (LONG)texture->desc.Width;
- internal_state->resolve_subresources[resolve_src_counter].SrcRect.bottom = (LONG)texture->desc.Height;
+ internal_state->resolve_subresources[resolve_src_counter].SrcRect.right = (LONG)texture->desc.width;
+ internal_state->resolve_subresources[resolve_src_counter].SrcRect.bottom = (LONG)texture->desc.height;
internal_state->resolve_subresources[resolve_src_counter].SrcRect.top = 0;
break;
@@ -4466,7 +4466,7 @@ using namespace DX12_Internal;
}
resolve_dst_counter++;
}
- else if (attachment.type == RenderPassAttachment::SHADING_RATE_SOURCE)
+ else if (attachment.type == RenderPassAttachment::Type::SHADING_RATE_SOURCE)
{
internal_state->shading_rate_image = texture;
}
@@ -4487,7 +4487,7 @@ using namespace DX12_Internal;
barrierdesc.Flags = D3D12_RESOURCE_BARRIER_FLAG_NONE;
barrierdesc.Transition.pResource = texture_internal->resource.Get();
barrierdesc.Transition.StateBefore = _ParseResourceState(attachment.initial_layout);
- if (attachment.type == RenderPassAttachment::RESOLVE)
+ if (attachment.type == RenderPassAttachment::Type::RESOLVE)
{
barrierdesc.Transition.StateAfter = D3D12_RESOURCE_STATE_RESOLVE_DEST;
}
@@ -4517,7 +4517,7 @@ 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();
- if (attachment.type == RenderPassAttachment::RESOLVE)
+ if (attachment.type == RenderPassAttachment::Type::RESOLVE)
{
barrierdesc.Transition.StateBefore = D3D12_RESOURCE_STATE_RESOLVE_DEST;
}
@@ -4542,27 +4542,27 @@ using namespace DX12_Internal;
auto internal_state = std::make_shared();
internal_state->allocationhandler = allocationhandler;
bvh->internal_state = internal_state;
- bvh->type = GPUResource::GPU_RESOURCE_TYPE::RAYTRACING_ACCELERATION_STRUCTURE;
+ bvh->type = GPUResource::Type::RAYTRACING_ACCELERATION_STRUCTURE;
bvh->desc = *pDesc;
- if (pDesc->_flags & RaytracingAccelerationStructureDesc::FLAG_ALLOW_UPDATE)
+ if (pDesc->flags & RaytracingAccelerationStructureDesc::FLAG_ALLOW_UPDATE)
{
internal_state->desc.Flags |= D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_ALLOW_UPDATE;
}
- if (pDesc->_flags & RaytracingAccelerationStructureDesc::FLAG_ALLOW_COMPACTION)
+ if (pDesc->flags & RaytracingAccelerationStructureDesc::FLAG_ALLOW_COMPACTION)
{
internal_state->desc.Flags |= D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_ALLOW_COMPACTION;
}
- if (pDesc->_flags & RaytracingAccelerationStructureDesc::FLAG_PREFER_FAST_TRACE)
+ if (pDesc->flags & RaytracingAccelerationStructureDesc::FLAG_PREFER_FAST_TRACE)
{
internal_state->desc.Flags |= D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_PREFER_FAST_TRACE;
}
- if (pDesc->_flags & RaytracingAccelerationStructureDesc::FLAG_PREFER_FAST_BUILD)
+ if (pDesc->flags & RaytracingAccelerationStructureDesc::FLAG_PREFER_FAST_BUILD)
{
internal_state->desc.Flags |= D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_PREFER_FAST_BUILD;
}
- if (pDesc->_flags & RaytracingAccelerationStructureDesc::FLAG_MINIMIZE_MEMORY)
+ if (pDesc->flags & RaytracingAccelerationStructureDesc::FLAG_MINIMIZE_MEMORY)
{
internal_state->desc.Flags |= D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_MINIMIZE_MEMORY;
}
@@ -4570,38 +4570,38 @@ using namespace DX12_Internal;
switch (pDesc->type)
{
- case RaytracingAccelerationStructureDesc::BOTTOMLEVEL:
+ case RaytracingAccelerationStructureDesc::Type::BOTTOMLEVEL:
{
internal_state->desc.Type = D3D12_RAYTRACING_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL;
internal_state->desc.DescsLayout = D3D12_ELEMENTS_LAYOUT_ARRAY;
- for (auto& x : pDesc->bottomlevel.geometries)
+ for (auto& x : pDesc->bottom_level.geometries)
{
auto& geometry = internal_state->geometries.emplace_back();
geometry = {};
- if (x.type == RaytracingAccelerationStructureDesc::BottomLevel::Geometry::TRIANGLES)
+ if (x.type == RaytracingAccelerationStructureDesc::BottomLevel::Geometry::Type::TRIANGLES)
{
geometry.Type = D3D12_RAYTRACING_GEOMETRY_TYPE_TRIANGLES;
- geometry.Triangles.VertexBuffer.StartAddress = to_internal(&x.triangles.vertexBuffer)->gpu_address + (D3D12_GPU_VIRTUAL_ADDRESS)x.triangles.vertexByteOffset;
- geometry.Triangles.VertexBuffer.StrideInBytes = (UINT64)x.triangles.vertexStride;
- geometry.Triangles.VertexCount = x.triangles.vertexCount;
- geometry.Triangles.VertexFormat = _ConvertFormat(x.triangles.vertexFormat);
- geometry.Triangles.IndexFormat = (x.triangles.indexFormat == INDEXBUFFER_FORMAT::INDEXFORMAT_16BIT ? DXGI_FORMAT_R16_UINT : DXGI_FORMAT_R32_UINT);
- geometry.Triangles.IndexBuffer = to_internal(&x.triangles.indexBuffer)->gpu_address +
- (D3D12_GPU_VIRTUAL_ADDRESS)x.triangles.indexOffset * (x.triangles.indexFormat == INDEXBUFFER_FORMAT::INDEXFORMAT_16BIT ? sizeof(uint16_t) : sizeof(uint32_t));
- geometry.Triangles.IndexCount = x.triangles.indexCount;
+ geometry.Triangles.VertexBuffer.StartAddress = to_internal(&x.triangles.vertex_buffer)->gpu_address + (D3D12_GPU_VIRTUAL_ADDRESS)x.triangles.vertex_byte_offset;
+ geometry.Triangles.VertexBuffer.StrideInBytes = (UINT64)x.triangles.vertex_stride;
+ geometry.Triangles.VertexCount = x.triangles.vertex_count;
+ geometry.Triangles.VertexFormat = _ConvertFormat(x.triangles.vertex_format);
+ geometry.Triangles.IndexFormat = (x.triangles.index_format == IndexBufferFormat::UINT16 ? DXGI_FORMAT_R16_UINT : DXGI_FORMAT_R32_UINT);
+ geometry.Triangles.IndexBuffer = to_internal(&x.triangles.index_buffer)->gpu_address +
+ (D3D12_GPU_VIRTUAL_ADDRESS)x.triangles.index_offset * (x.triangles.index_format == IndexBufferFormat::UINT16 ? sizeof(uint16_t) : sizeof(uint32_t));
+ geometry.Triangles.IndexCount = x.triangles.index_count;
- if (x._flags & RaytracingAccelerationStructureDesc::BottomLevel::Geometry::FLAG_USE_TRANSFORM)
+ if (x.flags & RaytracingAccelerationStructureDesc::BottomLevel::Geometry::FLAG_USE_TRANSFORM)
{
- geometry.Triangles.Transform3x4 = to_internal(&x.triangles.transform3x4Buffer)->gpu_address +
- (D3D12_GPU_VIRTUAL_ADDRESS)x.triangles.transform3x4BufferOffset;
+ geometry.Triangles.Transform3x4 = to_internal(&x.triangles.transform_3x4_buffer)->gpu_address +
+ (D3D12_GPU_VIRTUAL_ADDRESS)x.triangles.transform_3x4_buffer_offset;
}
}
- else if (x.type == RaytracingAccelerationStructureDesc::BottomLevel::Geometry::PROCEDURAL_AABBS)
+ else if (x.type == RaytracingAccelerationStructureDesc::BottomLevel::Geometry::Type::PROCEDURAL_AABBS)
{
geometry.Type = D3D12_RAYTRACING_GEOMETRY_TYPE_PROCEDURAL_PRIMITIVE_AABBS;
- geometry.AABBs.AABBs.StartAddress = to_internal(&x.aabbs.aabbBuffer)->gpu_address +
+ geometry.AABBs.AABBs.StartAddress = to_internal(&x.aabbs.aabb_buffer)->gpu_address +
(D3D12_GPU_VIRTUAL_ADDRESS)x.aabbs.offset;
geometry.AABBs.AABBs.StrideInBytes = (UINT64)x.aabbs.stride;
geometry.AABBs.AABBCount = x.aabbs.count;
@@ -4612,14 +4612,14 @@ using namespace DX12_Internal;
internal_state->desc.NumDescs = (UINT)internal_state->geometries.size();
}
break;
- case RaytracingAccelerationStructureDesc::TOPLEVEL:
+ case RaytracingAccelerationStructureDesc::Type::TOPLEVEL:
{
internal_state->desc.Type = D3D12_RAYTRACING_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL;
internal_state->desc.DescsLayout = D3D12_ELEMENTS_LAYOUT_ARRAY;
- internal_state->desc.InstanceDescs = to_internal(&pDesc->toplevel.instanceBuffer)->gpu_address +
- (D3D12_GPU_VIRTUAL_ADDRESS)pDesc->toplevel.offset;
- internal_state->desc.NumDescs = (UINT)pDesc->toplevel.count;
+ internal_state->desc.InstanceDescs = to_internal(&pDesc->top_level.instance_buffer)->gpu_address +
+ (D3D12_GPU_VIRTUAL_ADDRESS)pDesc->top_level.offset;
+ internal_state->desc.NumDescs = (UINT)pDesc->top_level.count;
}
break;
}
@@ -4668,7 +4668,7 @@ using namespace DX12_Internal;
internal_state->srv.init(this, srv_desc, nullptr);
GPUBufferDesc scratch_desc;
- scratch_desc.Size = (uint32_t)std::max(internal_state->info.ScratchDataSizeInBytes, internal_state->info.UpdateScratchDataSizeInBytes);
+ scratch_desc.size = (uint32_t)std::max(internal_state->info.ScratchDataSizeInBytes, internal_state->info.UpdateScratchDataSizeInBytes);
return CreateBuffer(&scratch_desc, nullptr, &internal_state->scratch);
}
@@ -4709,14 +4709,14 @@ using namespace DX12_Internal;
auto& subobject = subobjects.emplace_back();
subobject = {};
subobject.Type = D3D12_STATE_SUBOBJECT_TYPE_GLOBAL_ROOT_SIGNATURE;
- auto shader_internal = to_internal(pDesc->shaderlibraries.front().shader); // think better way
+ auto shader_internal = to_internal(pDesc->shader_libraries.front().shader); // think better way
global_rootsig.pGlobalRootSignature = shader_internal->rootSignature.Get();
subobject.pDesc = &global_rootsig;
}
- internal_state->exports.reserve(pDesc->shaderlibraries.size());
- internal_state->library_descs.reserve(pDesc->shaderlibraries.size());
- for(auto& x : pDesc->shaderlibraries)
+ internal_state->exports.reserve(pDesc->shader_libraries.size());
+ internal_state->library_descs.reserve(pDesc->shader_libraries.size());
+ for(auto& x : pDesc->shader_libraries)
{
auto& subobject = subobjects.emplace_back();
subobject = {};
@@ -4736,12 +4736,12 @@ using namespace DX12_Internal;
subobject.pDesc = &library_desc;
}
- internal_state->hitgroup_descs.reserve(pDesc->hitgroups.size());
- for (auto& x : pDesc->hitgroups)
+ internal_state->hitgroup_descs.reserve(pDesc->hit_groups.size());
+ for (auto& x : pDesc->hit_groups)
{
wiHelper::StringConvert(x.name, internal_state->group_strings.emplace_back());
- if (x.type == ShaderHitGroup::GENERAL)
+ if (x.type == ShaderHitGroup::Type::GENERAL)
continue;
auto& subobject = subobjects.emplace_back();
subobject = {};
@@ -4751,10 +4751,10 @@ using namespace DX12_Internal;
switch (x.type)
{
default:
- case ShaderHitGroup::TRIANGLES:
+ case ShaderHitGroup::Type::TRIANGLES:
hitgroup_desc.Type = D3D12_HIT_GROUP_TYPE_TRIANGLES;
break;
- case ShaderHitGroup::PROCEDURAL:
+ case ShaderHitGroup::Type::PROCEDURAL:
hitgroup_desc.Type = D3D12_HIT_GROUP_TYPE_PROCEDURAL_PRIMITIVE;
break;
}
@@ -4762,13 +4762,13 @@ using namespace DX12_Internal;
{
hitgroup_desc.HitGroupExport = internal_state->group_strings.back().c_str();
}
- if (x.closesthit_shader != ~0)
+ if (x.closest_hit_shader != ~0)
{
- hitgroup_desc.ClosestHitShaderImport = internal_state->exports[x.closesthit_shader].Name;
+ hitgroup_desc.ClosestHitShaderImport = internal_state->exports[x.closest_hit_shader].Name;
}
- if (x.anyhit_shader != ~0)
+ if (x.any_hit_shader != ~0)
{
- hitgroup_desc.AnyHitShaderImport = internal_state->exports[x.anyhit_shader].Name;
+ hitgroup_desc.AnyHitShaderImport = internal_state->exports[x.any_hit_shader].Name;
}
if (x.intersection_shader != ~0)
{
@@ -4786,40 +4786,40 @@ using namespace DX12_Internal;
return SUCCEEDED(hr);
}
- int GraphicsDevice_DX12::CreateSubresource(Texture* texture, SUBRESOURCE_TYPE type, uint32_t firstSlice, uint32_t sliceCount, uint32_t firstMip, uint32_t mipCount) const
+ int GraphicsDevice_DX12::CreateSubresource(Texture* texture, SubresourceType 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:
+ case SubresourceType::SRV:
{
D3D12_SHADER_RESOURCE_VIEW_DESC srv_desc = {};
srv_desc.Shader4ComponentMapping = D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING;
// Try to resolve resource format:
- switch (texture->desc.Format)
+ switch (texture->desc.format)
{
- case FORMAT_R16_TYPELESS:
+ case Format::R16_TYPELESS:
srv_desc.Format = DXGI_FORMAT_R16_UNORM;
break;
- case FORMAT_R32_TYPELESS:
+ case Format::R32_TYPELESS:
srv_desc.Format = DXGI_FORMAT_R32_FLOAT;
break;
- case FORMAT_R24G8_TYPELESS:
+ case Format::R24G8_TYPELESS:
srv_desc.Format = DXGI_FORMAT_R24_UNORM_X8_TYPELESS;
break;
- case FORMAT_R32G8X24_TYPELESS:
+ case Format::R32G8X24_TYPELESS:
srv_desc.Format = DXGI_FORMAT_R32_FLOAT_X8X24_TYPELESS;
break;
default:
- srv_desc.Format = _ConvertFormat(texture->desc.Format);
+ srv_desc.Format = _ConvertFormat(texture->desc.format);
break;
}
- if (texture->desc.type == TextureDesc::TEXTURE_1D)
+ if (texture->desc.type == TextureDesc::Type::TEXTURE_1D)
{
- if (texture->desc.ArraySize > 1)
+ if (texture->desc.array_size > 1)
{
srv_desc.ViewDimension = D3D12_SRV_DIMENSION_TEXTURE1DARRAY;
srv_desc.Texture1DArray.FirstArraySlice = firstSlice;
@@ -4834,17 +4834,17 @@ using namespace DX12_Internal;
srv_desc.Texture1D.MipLevels = mipCount;
}
}
- else if (texture->desc.type == TextureDesc::TEXTURE_2D)
+ else if (texture->desc.type == TextureDesc::Type::TEXTURE_2D)
{
- if (texture->desc.ArraySize > 1)
+ if (texture->desc.array_size > 1)
{
- if (texture->desc.MiscFlags & RESOURCE_MISC_TEXTURECUBE)
+ if (has_flag(texture->desc.misc_flags, ResourceMiscFlag::TEXTURECUBE))
{
- if (texture->desc.ArraySize > 6)
+ if (texture->desc.array_size > 6)
{
srv_desc.ViewDimension = D3D12_SRV_DIMENSION_TEXTURECUBEARRAY;
srv_desc.TextureCubeArray.First2DArrayFace = firstSlice;
- srv_desc.TextureCubeArray.NumCubes = std::min(texture->desc.ArraySize, sliceCount) / 6;
+ srv_desc.TextureCubeArray.NumCubes = std::min(texture->desc.array_size, sliceCount) / 6;
srv_desc.TextureCubeArray.MostDetailedMip = firstMip;
srv_desc.TextureCubeArray.MipLevels = mipCount;
}
@@ -4857,7 +4857,7 @@ using namespace DX12_Internal;
}
else
{
- if (texture->desc.SampleCount > 1)
+ if (texture->desc.sample_count > 1)
{
srv_desc.ViewDimension = D3D12_SRV_DIMENSION_TEXTURE2DMSARRAY;
srv_desc.Texture2DMSArray.FirstArraySlice = firstSlice;
@@ -4875,7 +4875,7 @@ using namespace DX12_Internal;
}
else
{
- if (texture->desc.SampleCount > 1)
+ if (texture->desc.sample_count > 1)
{
srv_desc.ViewDimension = D3D12_SRV_DIMENSION_TEXTURE2DMS;
}
@@ -4887,7 +4887,7 @@ using namespace DX12_Internal;
}
}
}
- else if (texture->desc.type == TextureDesc::TEXTURE_3D)
+ else if (texture->desc.type == TextureDesc::Type::TEXTURE_3D)
{
srv_desc.ViewDimension = D3D12_SRV_DIMENSION_TEXTURE3D;
srv_desc.Texture3D.MostDetailedMip = firstMip;
@@ -4906,33 +4906,33 @@ using namespace DX12_Internal;
return int(internal_state->subresources_srv.size() - 1);
}
break;
- case wiGraphics::UAV:
+ case SubresourceType::UAV:
{
D3D12_UNORDERED_ACCESS_VIEW_DESC uav_desc = {};
// Try to resolve resource format:
- switch (texture->desc.Format)
+ switch (texture->desc.format)
{
- case FORMAT_R16_TYPELESS:
+ case Format::R16_TYPELESS:
uav_desc.Format = DXGI_FORMAT_R16_UNORM;
break;
- case FORMAT_R32_TYPELESS:
+ case Format::R32_TYPELESS:
uav_desc.Format = DXGI_FORMAT_R32_FLOAT;
break;
- case FORMAT_R24G8_TYPELESS:
+ case Format::R24G8_TYPELESS:
uav_desc.Format = DXGI_FORMAT_R24_UNORM_X8_TYPELESS;
break;
- case FORMAT_R32G8X24_TYPELESS:
+ case Format::R32G8X24_TYPELESS:
uav_desc.Format = DXGI_FORMAT_R32_FLOAT_X8X24_TYPELESS;
break;
default:
- uav_desc.Format = _ConvertFormat(texture->desc.Format);
+ uav_desc.Format = _ConvertFormat(texture->desc.format);
break;
}
- if (texture->desc.type == TextureDesc::TEXTURE_1D)
+ if (texture->desc.type == TextureDesc::Type::TEXTURE_1D)
{
- if (texture->desc.ArraySize > 1)
+ if (texture->desc.array_size > 1)
{
uav_desc.ViewDimension = D3D12_UAV_DIMENSION_TEXTURE1DARRAY;
uav_desc.Texture1DArray.FirstArraySlice = firstSlice;
@@ -4945,9 +4945,9 @@ using namespace DX12_Internal;
uav_desc.Texture1D.MipSlice = firstMip;
}
}
- else if (texture->desc.type == TextureDesc::TEXTURE_2D)
+ else if (texture->desc.type == TextureDesc::Type::TEXTURE_2D)
{
- if (texture->desc.ArraySize > 1)
+ if (texture->desc.array_size > 1)
{
uav_desc.ViewDimension = D3D12_UAV_DIMENSION_TEXTURE2DARRAY;
uav_desc.Texture2DArray.FirstArraySlice = firstSlice;
@@ -4960,7 +4960,7 @@ using namespace DX12_Internal;
uav_desc.Texture2D.MipSlice = firstMip;
}
}
- else if (texture->desc.type == TextureDesc::TEXTURE_3D)
+ else if (texture->desc.type == TextureDesc::Type::TEXTURE_3D)
{
uav_desc.ViewDimension = D3D12_UAV_DIMENSION_TEXTURE3D;
uav_desc.Texture3D.MipSlice = firstMip;
@@ -4980,33 +4980,33 @@ using namespace DX12_Internal;
return int(internal_state->subresources_uav.size() - 1);
}
break;
- case wiGraphics::RTV:
+ case SubresourceType::RTV:
{
D3D12_RENDER_TARGET_VIEW_DESC rtv_desc = {};
// Try to resolve resource format:
- switch (texture->desc.Format)
+ switch (texture->desc.format)
{
- case FORMAT_R16_TYPELESS:
+ case Format::R16_TYPELESS:
rtv_desc.Format = DXGI_FORMAT_R16_UNORM;
break;
- case FORMAT_R32_TYPELESS:
+ case Format::R32_TYPELESS:
rtv_desc.Format = DXGI_FORMAT_R32_FLOAT;
break;
- case FORMAT_R24G8_TYPELESS:
+ case Format::R24G8_TYPELESS:
rtv_desc.Format = DXGI_FORMAT_R24_UNORM_X8_TYPELESS;
break;
- case FORMAT_R32G8X24_TYPELESS:
+ case Format::R32G8X24_TYPELESS:
rtv_desc.Format = DXGI_FORMAT_R32_FLOAT_X8X24_TYPELESS;
break;
default:
- rtv_desc.Format = _ConvertFormat(texture->desc.Format);
+ rtv_desc.Format = _ConvertFormat(texture->desc.format);
break;
}
- if (texture->desc.type == TextureDesc::TEXTURE_1D)
+ if (texture->desc.type == TextureDesc::Type::TEXTURE_1D)
{
- if (texture->desc.ArraySize > 1)
+ if (texture->desc.array_size > 1)
{
rtv_desc.ViewDimension = D3D12_RTV_DIMENSION_TEXTURE1DARRAY;
rtv_desc.Texture1DArray.FirstArraySlice = firstSlice;
@@ -5019,11 +5019,11 @@ using namespace DX12_Internal;
rtv_desc.Texture1D.MipSlice = firstMip;
}
}
- else if (texture->desc.type == TextureDesc::TEXTURE_2D)
+ else if (texture->desc.type == TextureDesc::Type::TEXTURE_2D)
{
- if (texture->desc.ArraySize > 1)
+ if (texture->desc.array_size > 1)
{
- if (texture->desc.SampleCount > 1)
+ if (texture->desc.sample_count > 1)
{
rtv_desc.ViewDimension = D3D12_RTV_DIMENSION_TEXTURE2DMSARRAY;
rtv_desc.Texture2DMSArray.FirstArraySlice = firstSlice;
@@ -5039,7 +5039,7 @@ using namespace DX12_Internal;
}
else
{
- if (texture->desc.SampleCount > 1)
+ if (texture->desc.sample_count > 1)
{
rtv_desc.ViewDimension = D3D12_RTV_DIMENSION_TEXTURE2DMS;
}
@@ -5050,7 +5050,7 @@ using namespace DX12_Internal;
}
}
}
- else if (texture->desc.type == TextureDesc::TEXTURE_3D)
+ else if (texture->desc.type == TextureDesc::Type::TEXTURE_3D)
{
rtv_desc.ViewDimension = D3D12_RTV_DIMENSION_TEXTURE3D;
rtv_desc.Texture3D.MipSlice = firstMip;
@@ -5070,33 +5070,33 @@ using namespace DX12_Internal;
return int(internal_state->subresources_rtv.size() - 1);
}
break;
- case wiGraphics::DSV:
+ case SubresourceType::DSV:
{
D3D12_DEPTH_STENCIL_VIEW_DESC dsv_desc = {};
// Try to resolve resource format:
- switch (texture->desc.Format)
+ switch (texture->desc.format)
{
- case FORMAT_R16_TYPELESS:
+ case Format::R16_TYPELESS:
dsv_desc.Format = DXGI_FORMAT_D16_UNORM;
break;
- case FORMAT_R32_TYPELESS:
+ case Format::R32_TYPELESS:
dsv_desc.Format = DXGI_FORMAT_D32_FLOAT;
break;
- case FORMAT_R24G8_TYPELESS:
+ case Format::R24G8_TYPELESS:
dsv_desc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;
break;
- case FORMAT_R32G8X24_TYPELESS:
+ case Format::R32G8X24_TYPELESS:
dsv_desc.Format = DXGI_FORMAT_D32_FLOAT_S8X24_UINT;
break;
default:
- dsv_desc.Format = _ConvertFormat(texture->desc.Format);
+ dsv_desc.Format = _ConvertFormat(texture->desc.format);
break;
}
- if (texture->desc.type == TextureDesc::TEXTURE_1D)
+ if (texture->desc.type == TextureDesc::Type::TEXTURE_1D)
{
- if (texture->desc.ArraySize > 1)
+ if (texture->desc.array_size > 1)
{
dsv_desc.ViewDimension = D3D12_DSV_DIMENSION_TEXTURE1DARRAY;
dsv_desc.Texture1DArray.FirstArraySlice = firstSlice;
@@ -5109,11 +5109,11 @@ using namespace DX12_Internal;
dsv_desc.Texture1D.MipSlice = firstMip;
}
}
- else if (texture->desc.type == TextureDesc::TEXTURE_2D)
+ else if (texture->desc.type == TextureDesc::Type::TEXTURE_2D)
{
- if (texture->desc.ArraySize > 1)
+ if (texture->desc.array_size > 1)
{
- if (texture->desc.SampleCount > 1)
+ if (texture->desc.sample_count > 1)
{
dsv_desc.ViewDimension = D3D12_DSV_DIMENSION_TEXTURE2DMSARRAY;
dsv_desc.Texture2DMSArray.FirstArraySlice = firstSlice;
@@ -5129,7 +5129,7 @@ using namespace DX12_Internal;
}
else
{
- if (texture->desc.SampleCount > 1)
+ if (texture->desc.sample_count > 1)
{
dsv_desc.ViewDimension = D3D12_DSV_DIMENSION_TEXTURE2DMS;
}
@@ -5158,7 +5158,7 @@ using namespace DX12_Internal;
}
return -1;
}
- int GraphicsDevice_DX12::CreateSubresource(GPUBuffer* buffer, SUBRESOURCE_TYPE type, uint64_t offset, uint64_t size) const
+ int GraphicsDevice_DX12::CreateSubresource(GPUBuffer* buffer, SubresourceType type, uint64_t offset, uint64_t size) const
{
auto internal_state = to_internal(buffer);
const GPUBufferDesc& desc = buffer->GetDesc();
@@ -5166,37 +5166,37 @@ using namespace DX12_Internal;
switch (type)
{
- case wiGraphics::SRV:
+ case SubresourceType::SRV:
{
D3D12_SHADER_RESOURCE_VIEW_DESC srv_desc = {};
srv_desc.Shader4ComponentMapping = D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING;
- if (desc.MiscFlags & RESOURCE_MISC_BUFFER_RAW)
+ if (has_flag(desc.misc_flags, ResourceMiscFlag::BUFFER_RAW))
{
// This is a Raw Buffer
srv_desc.Format = DXGI_FORMAT_R32_TYPELESS;
srv_desc.ViewDimension = D3D12_SRV_DIMENSION_BUFFER;
srv_desc.Buffer.FirstElement = (UINT)offset / sizeof(uint32_t);
srv_desc.Buffer.Flags = D3D12_BUFFER_SRV_FLAG_RAW;
- srv_desc.Buffer.NumElements = (UINT)std::min(size, desc.Size - offset) / sizeof(uint32_t);
+ srv_desc.Buffer.NumElements = (UINT)std::min(size, desc.size - offset) / sizeof(uint32_t);
}
- else if (desc.MiscFlags & RESOURCE_MISC_BUFFER_STRUCTURED)
+ else if (has_flag(desc.misc_flags, ResourceMiscFlag::BUFFER_STRUCTURED))
{
// This is a Structured Buffer
srv_desc.Format = DXGI_FORMAT_UNKNOWN;
srv_desc.ViewDimension = D3D12_SRV_DIMENSION_BUFFER;
- srv_desc.Buffer.FirstElement = (UINT)offset / desc.Stride;
- srv_desc.Buffer.NumElements = (UINT)std::min(size, desc.Size - offset) / desc.Stride;
- srv_desc.Buffer.StructureByteStride = desc.Stride;
+ srv_desc.Buffer.FirstElement = (UINT)offset / desc.stride;
+ srv_desc.Buffer.NumElements = (UINT)std::min(size, desc.size - offset) / desc.stride;
+ srv_desc.Buffer.StructureByteStride = desc.stride;
}
else
{
// This is a Typed Buffer
- uint32_t stride = GetFormatStride(desc.Format);
- srv_desc.Format = _ConvertFormat(desc.Format);
+ uint32_t stride = GetFormatStride(desc.format);
+ srv_desc.Format = _ConvertFormat(desc.format);
srv_desc.ViewDimension = D3D12_SRV_DIMENSION_BUFFER;
srv_desc.Buffer.FirstElement = offset / stride;
- srv_desc.Buffer.NumElements = (UINT)std::min(size, desc.Size - offset) / stride;
+ srv_desc.Buffer.NumElements = (UINT)std::min(size, desc.size - offset) / stride;
}
SingleDescriptor descriptor;
@@ -5211,36 +5211,36 @@ using namespace DX12_Internal;
return int(internal_state->subresources_srv.size() - 1);
}
break;
- case wiGraphics::UAV:
+ case SubresourceType::UAV:
{
D3D12_UNORDERED_ACCESS_VIEW_DESC uav_desc = {};
uav_desc.ViewDimension = D3D12_UAV_DIMENSION_BUFFER;
uav_desc.Buffer.FirstElement = 0;
- if (desc.MiscFlags & RESOURCE_MISC_BUFFER_RAW)
+ if (has_flag(desc.misc_flags, ResourceMiscFlag::BUFFER_RAW))
{
// This is a Raw Buffer
uav_desc.Format = DXGI_FORMAT_R32_TYPELESS;
uav_desc.Buffer.Flags = D3D12_BUFFER_UAV_FLAG_RAW;
uav_desc.Buffer.FirstElement = (UINT)offset / sizeof(uint32_t);
- uav_desc.Buffer.NumElements = (UINT)std::min(size, desc.Size - offset) / sizeof(uint32_t);
+ uav_desc.Buffer.NumElements = (UINT)std::min(size, desc.size - offset) / sizeof(uint32_t);
}
- else if (desc.MiscFlags & RESOURCE_MISC_BUFFER_STRUCTURED)
+ else if (has_flag(desc.misc_flags, ResourceMiscFlag::BUFFER_STRUCTURED))
{
// This is a Structured Buffer
uav_desc.Format = DXGI_FORMAT_UNKNOWN;
- uav_desc.Buffer.FirstElement = (UINT)offset / desc.Stride;
- uav_desc.Buffer.NumElements = (UINT)std::min(size, desc.Size - offset) / desc.Stride;
- uav_desc.Buffer.StructureByteStride = desc.Stride;
+ uav_desc.Buffer.FirstElement = (UINT)offset / desc.stride;
+ uav_desc.Buffer.NumElements = (UINT)std::min(size, desc.size - offset) / desc.stride;
+ uav_desc.Buffer.StructureByteStride = desc.stride;
}
else
{
// This is a Typed Buffer
- uint32_t stride = GetFormatStride(desc.Format);
- uav_desc.Format = _ConvertFormat(desc.Format);
+ uint32_t stride = GetFormatStride(desc.format);
+ uav_desc.Format = _ConvertFormat(desc.format);
uav_desc.Buffer.FirstElement = (UINT)offset / stride;
- uav_desc.Buffer.NumElements = (UINT)std::min(size, desc.Size - offset) / stride;
+ uav_desc.Buffer.NumElements = (UINT)std::min(size, desc.size - offset) / stride;
}
SingleDescriptor descriptor;
@@ -5263,7 +5263,7 @@ using namespace DX12_Internal;
return -1;
}
- int GraphicsDevice_DX12::GetDescriptorIndex(const GPUResource* resource, SUBRESOURCE_TYPE type, int subresource) const
+ int GraphicsDevice_DX12::GetDescriptorIndex(const GPUResource* resource, SubresourceType type, int subresource) const
{
if (resource == nullptr || !resource->IsValid())
return -1;
@@ -5273,7 +5273,7 @@ using namespace DX12_Internal;
switch (type)
{
default:
- case wiGraphics::SRV:
+ case SubresourceType::SRV:
if (subresource < 0)
{
return internal_state->srv.index;
@@ -5283,7 +5283,7 @@ using namespace DX12_Internal;
return internal_state->subresources_srv[subresource].index;
}
break;
- case wiGraphics::UAV:
+ case SubresourceType::UAV:
if (subresource < 0)
{
return internal_state->uav.index;
@@ -5306,7 +5306,7 @@ using namespace DX12_Internal;
return internal_state->descriptor.index;
}
- void GraphicsDevice_DX12::WriteShadingRateValue(SHADING_RATE rate, void* dest) const
+ void GraphicsDevice_DX12::WriteShadingRateValue(ShadingRate rate, void* dest) const
{
D3D12_SHADING_RATE _rate = _ConvertShadingRate(rate);
if (!additionalShadingRatesSupported)
@@ -5318,12 +5318,12 @@ using namespace DX12_Internal;
void GraphicsDevice_DX12::WriteTopLevelAccelerationStructureInstance(const RaytracingAccelerationStructureDesc::TopLevel::Instance* instance, void* dest) const
{
D3D12_RAYTRACING_INSTANCE_DESC* desc = (D3D12_RAYTRACING_INSTANCE_DESC*)dest;
- desc->AccelerationStructure = to_internal(&instance->bottomlevel)->gpu_address;
+ desc->AccelerationStructure = to_internal(&instance->bottom_level)->gpu_address;
memcpy(desc->Transform, &instance->transform, sizeof(desc->Transform));
- desc->InstanceID = instance->InstanceID;
- desc->InstanceMask = instance->InstanceMask;
- desc->InstanceContributionToHitGroupIndex = instance->InstanceContributionToHitGroupIndex;
- desc->Flags = instance->Flags;
+ desc->InstanceID = instance->instance_id;
+ desc->InstanceMask = instance->instance_mask;
+ desc->InstanceContributionToHitGroupIndex = instance->instance_contribution_to_hit_group_index;
+ desc->Flags = instance->flags;
}
void GraphicsDevice_DX12::WriteShaderIdentifier(const RaytracingPipelineState* rtpso, uint32_t group_index, void* dest) const
{
@@ -5359,7 +5359,7 @@ using namespace DX12_Internal;
{
HRESULT hr;
- CommandList cmd = cmd_count.fetch_add(1);
+ CommandList cmd{ cmd_count.fetch_add(1) };
assert(cmd < COMMANDLIST_COUNT);
cmd_meta[cmd].queue = queue;
cmd_meta[cmd].waits.clear();
@@ -5420,7 +5420,7 @@ using namespace DX12_Internal;
active_rootsig_graphics[cmd] = nullptr;
active_rootsig_compute[cmd] = nullptr;
active_renderpass[cmd] = nullptr;
- prev_shadingrate[cmd] = SHADING_RATE_INVALID;
+ prev_shadingrate[cmd] = ShadingRate::RATE_INVALID;
dirty_pso[cmd] = false;
pushconstants[cmd] = {};
swapchains[cmd].clear();
@@ -5438,9 +5438,9 @@ using namespace DX12_Internal;
QUEUE_TYPE submit_queue = QUEUE_COUNT;
- CommandList cmd_last = cmd_count.load();
+ CommandList::index_type cmd_last = cmd_count.load();
cmd_count.store(0);
- for (CommandList cmd = 0; cmd < cmd_last; ++cmd)
+ for (CommandList::index_type cmd = 0; cmd < cmd_last; ++cmd)
{
hr = GetCommandList(cmd)->Close();
assert(SUCCEEDED(hr));
@@ -5504,7 +5504,7 @@ using namespace DX12_Internal;
// submit last cmd batch:
assert(submit_queue < QUEUE_COUNT);
- assert(queues[submit_queue].submit_cmds > 0);
+ assert(queues[submit_queue].submit_count > 0);
queues[submit_queue].queue->ExecuteCommandLists(
queues[submit_queue].submit_count,
queues[submit_queue].submit_cmds
@@ -5518,7 +5518,7 @@ using namespace DX12_Internal;
assert(SUCCEEDED(hr));
}
- for (CommandList cmd = 0; cmd < cmd_last; ++cmd)
+ for (CommandList::index_type cmd = 0; cmd < cmd_last; ++cmd)
{
for (auto& swapchain : swapchains[cmd])
{
@@ -5641,18 +5641,18 @@ using namespace DX12_Internal;
device->GetCopyableFootprints(&desc, 0, 1, 0, &internal_state->footprint, nullptr, nullptr, nullptr);
Texture result;
- result.type = GPUResource::GPU_RESOURCE_TYPE::TEXTURE;
+ result.type = GPUResource::Type::TEXTURE;
result.internal_state = internal_state;
result.desc = _ConvertTextureDesc_Inv(desc);
return result;
}
- COLOR_SPACE GraphicsDevice_DX12::GetSwapChainColorSpace(const SwapChain* swapchain) const
+ ColorSpace GraphicsDevice_DX12::GetSwapChainColorSpace(const SwapChain* swapchain) const
{
auto internal_state = to_internal(swapchain);
return internal_state->colorSpace;
}
- bool GraphicsDevice_DX12::GetSwapChainHDRSupport(const SwapChain* swapchain) const
+ bool GraphicsDevice_DX12::IsSwapChainSupportsHDR(const SwapChain* swapchain) const
{
auto internal_state = to_internal(swapchain);
@@ -5700,10 +5700,10 @@ using namespace DX12_Internal;
D3D12_RENDER_PASS_RENDER_TARGET_DESC RTV = {};
RTV.cpuDescriptor = internal_state->backbufferRTV[internal_state->swapChain->GetCurrentBackBufferIndex()];
RTV.BeginningAccess.Type = D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_CLEAR;
- RTV.BeginningAccess.Clear.ClearValue.Color[0] = swapchain->desc.clearcolor[0];
- RTV.BeginningAccess.Clear.ClearValue.Color[1] = swapchain->desc.clearcolor[1];
- RTV.BeginningAccess.Clear.ClearValue.Color[2] = swapchain->desc.clearcolor[2];
- RTV.BeginningAccess.Clear.ClearValue.Color[3] = swapchain->desc.clearcolor[3];
+ RTV.BeginningAccess.Clear.ClearValue.Color[0] = swapchain->desc.clear_color[0];
+ RTV.BeginningAccess.Clear.ClearValue.Color[1] = swapchain->desc.clear_color[1];
+ RTV.BeginningAccess.Clear.ClearValue.Color[2] = swapchain->desc.clear_color[2];
+ RTV.BeginningAccess.Clear.ClearValue.Color[3] = swapchain->desc.clear_color[3];
RTV.EndingAccess.Type = D3D12_RENDER_PASS_ENDING_ACCESS_TYPE_PRESERVE;
GetCommandList(cmd)->BeginRenderPass(1, &RTV, nullptr, D3D12_RENDER_PASS_FLAG_ALLOW_UAV_WRITES);
@@ -5782,12 +5782,12 @@ using namespace DX12_Internal;
assert(NumViewports < arraysize(d3dViewPorts));
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;
+ d3dViewPorts[i].TopLeftX = pViewports[i].top_left_x;
+ d3dViewPorts[i].TopLeftY = pViewports[i].top_left_y;
+ d3dViewPorts[i].Width = pViewports[i].width;
+ d3dViewPorts[i].Height = pViewports[i].height;
+ d3dViewPorts[i].MinDepth = pViewports[i].min_depth;
+ d3dViewPorts[i].MaxDepth = pViewports[i].max_depth;
}
GetCommandList(cmd)->RSSetViewports(NumViewports, d3dViewPorts);
}
@@ -5878,7 +5878,7 @@ using namespace DX12_Internal;
if (vertexBuffers[i] != nullptr)
{
res[i].BufferLocation = vertexBuffers[i]->IsValid() ? to_internal(vertexBuffers[i])->gpu_address : 0;
- res[i].SizeInBytes = (UINT)vertexBuffers[i]->desc.Size;
+ res[i].SizeInBytes = (UINT)vertexBuffers[i]->desc.size;
if (offsets != nullptr)
{
res[i].BufferLocation += offsets[i];
@@ -5889,7 +5889,7 @@ using namespace DX12_Internal;
}
GetCommandList(cmd)->IASetVertexBuffers(slot, count, res);
}
- void GraphicsDevice_DX12::BindIndexBuffer(const GPUBuffer* indexBuffer, const INDEXBUFFER_FORMAT format, uint64_t offset, CommandList cmd)
+ void GraphicsDevice_DX12::BindIndexBuffer(const GPUBuffer* indexBuffer, const IndexBufferFormat format, uint64_t offset, CommandList cmd)
{
D3D12_INDEX_BUFFER_VIEW res = {};
if (indexBuffer != nullptr)
@@ -5897,8 +5897,8 @@ using namespace DX12_Internal;
auto internal_state = to_internal(indexBuffer);
res.BufferLocation = internal_state->gpu_address + (D3D12_GPU_VIRTUAL_ADDRESS)offset;
- res.Format = (format == INDEXBUFFER_FORMAT::INDEXFORMAT_16BIT ? DXGI_FORMAT_R16_UINT : DXGI_FORMAT_R32_UINT);
- res.SizeInBytes = (UINT)(indexBuffer->desc.Size - offset);
+ res.Format = (format == IndexBufferFormat::UINT16 ? DXGI_FORMAT_R16_UINT : DXGI_FORMAT_R32_UINT);
+ res.SizeInBytes = (UINT)(indexBuffer->desc.size - offset);
}
GetCommandList(cmd)->IASetIndexBuffer(&res);
}
@@ -5911,9 +5911,9 @@ using namespace DX12_Internal;
const float blendFactor[4] = { r, g, b, a };
GetCommandList(cmd)->OMSetBlendFactor(blendFactor);
}
- void GraphicsDevice_DX12::BindShadingRate(SHADING_RATE rate, CommandList cmd)
+ void GraphicsDevice_DX12::BindShadingRate(ShadingRate rate, CommandList cmd)
{
- if (CheckCapability(GRAPHICSDEVICE_CAPABILITY_VARIABLE_RATE_SHADING) && prev_shadingrate[cmd] != rate)
+ if (CheckCapability(GraphicsDeviceCapability::VARIABLE_RATE_SHADING) && prev_shadingrate[cmd] != rate)
{
prev_shadingrate[cmd] = rate;
@@ -5977,7 +5977,7 @@ using namespace DX12_Internal;
active_pso[cmd] = nullptr;
active_rt[cmd] = nullptr;
- assert(cs->stage == CS || cs->stage == LIB);
+ assert(cs->stage == ShaderStage::CS || cs->stage == ShaderStage::LIB);
if (active_cs[cmd] != cs)
{
prev_pipeline_hash[cmd] = 0;
@@ -5986,7 +5986,7 @@ using namespace DX12_Internal;
auto internal_state = to_internal(cs);
- if (cs->stage == CS)
+ if (cs->stage == ShaderStage::CS)
{
GetCommandList(cmd)->SetPipelineState(internal_state->resource.Get());
}
@@ -6105,21 +6105,21 @@ using namespace DX12_Internal;
switch (heap->desc.type)
{
- case GPU_QUERY_TYPE_TIMESTAMP:
+ case GpuQueryType::TIMESTAMP:
GetCommandList(cmd)->BeginQuery(
internal_state->heap.Get(),
D3D12_QUERY_TYPE_TIMESTAMP,
index
);
break;
- case GPU_QUERY_TYPE_OCCLUSION_BINARY:
+ case GpuQueryType::OCCLUSION_BINARY:
GetCommandList(cmd)->BeginQuery(
internal_state->heap.Get(),
D3D12_QUERY_TYPE_BINARY_OCCLUSION,
index
);
break;
- case GPU_QUERY_TYPE_OCCLUSION:
+ case GpuQueryType::OCCLUSION:
GetCommandList(cmd)->BeginQuery(
internal_state->heap.Get(),
D3D12_QUERY_TYPE_OCCLUSION,
@@ -6134,21 +6134,21 @@ using namespace DX12_Internal;
switch (heap->desc.type)
{
- case GPU_QUERY_TYPE_TIMESTAMP:
+ case GpuQueryType::TIMESTAMP:
GetCommandList(cmd)->EndQuery(
internal_state->heap.Get(),
D3D12_QUERY_TYPE_TIMESTAMP,
index
);
break;
- case GPU_QUERY_TYPE_OCCLUSION_BINARY:
+ case GpuQueryType::OCCLUSION_BINARY:
GetCommandList(cmd)->EndQuery(
internal_state->heap.Get(),
D3D12_QUERY_TYPE_BINARY_OCCLUSION,
index
);
break;
- case GPU_QUERY_TYPE_OCCLUSION:
+ case GpuQueryType::OCCLUSION:
GetCommandList(cmd)->EndQuery(
internal_state->heap.Get(),
D3D12_QUERY_TYPE_OCCLUSION,
@@ -6166,7 +6166,7 @@ using namespace DX12_Internal;
switch (heap->desc.type)
{
- case GPU_QUERY_TYPE_TIMESTAMP:
+ case GpuQueryType::TIMESTAMP:
GetCommandList(cmd)->ResolveQueryData(
internal_state->heap.Get(),
D3D12_QUERY_TYPE_TIMESTAMP,
@@ -6176,7 +6176,7 @@ using namespace DX12_Internal;
dest_offset
);
break;
- case GPU_QUERY_TYPE_OCCLUSION_BINARY:
+ case GpuQueryType::OCCLUSION_BINARY:
GetCommandList(cmd)->ResolveQueryData(
internal_state->heap.Get(),
D3D12_QUERY_TYPE_BINARY_OCCLUSION,
@@ -6186,7 +6186,7 @@ using namespace DX12_Internal;
dest_offset
);
break;
- case GPU_QUERY_TYPE_OCCLUSION:
+ case GpuQueryType::OCCLUSION:
GetCommandList(cmd)->ResolveQueryData(
internal_state->heap.Get(),
D3D12_QUERY_TYPE_OCCLUSION,
@@ -6208,9 +6208,9 @@ using namespace DX12_Internal;
{
const GPUBarrier& barrier = barriers[i];
- if (barrier.type == GPUBarrier::IMAGE_BARRIER && (barrier.image.texture == nullptr || !barrier.image.texture->IsValid()))
+ if (barrier.type == GPUBarrier::Type::IMAGE && (barrier.image.texture == nullptr || !barrier.image.texture->IsValid()))
continue;
- if (barrier.type == GPUBarrier::BUFFER_BARRIER && (barrier.buffer.buffer == nullptr || !barrier.buffer.buffer->IsValid()))
+ if (barrier.type == GPUBarrier::Type::BUFFER && (barrier.buffer.buffer == nullptr || !barrier.buffer.buffer->IsValid()))
continue;
D3D12_RESOURCE_BARRIER barrierdesc = {};
@@ -6218,14 +6218,14 @@ using namespace DX12_Internal;
switch (barrier.type)
{
default:
- case GPUBarrier::MEMORY_BARRIER:
+ case GPUBarrier::Type::MEMORY:
{
barrierdesc.Type = D3D12_RESOURCE_BARRIER_TYPE_UAV;
barrierdesc.Flags = D3D12_RESOURCE_BARRIER_FLAG_NONE;
barrierdesc.UAV.pResource = barrier.memory.resource == nullptr ? nullptr : to_internal(barrier.memory.resource)->resource.Get();
}
break;
- case GPUBarrier::IMAGE_BARRIER:
+ case GPUBarrier::Type::IMAGE:
{
barrierdesc.Type = D3D12_RESOURCE_BARRIER_TYPE_TRANSITION;
barrierdesc.Flags = D3D12_RESOURCE_BARRIER_FLAG_NONE;
@@ -6238,8 +6238,8 @@ using namespace DX12_Internal;
(UINT)std::max(0, barrier.image.mip),
(UINT)std::max(0, barrier.image.slice),
0,
- barrier.image.texture->desc.MipLevels,
- barrier.image.texture->desc.ArraySize
+ barrier.image.texture->desc.mip_levels,
+ barrier.image.texture->desc.array_size
);
}
else
@@ -6248,7 +6248,7 @@ using namespace DX12_Internal;
}
}
break;
- case GPUBarrier::BUFFER_BARRIER:
+ case GPUBarrier::Type::BUFFER:
{
barrierdesc.Type = D3D12_RESOURCE_BARRIER_TYPE_TRANSITION;
barrierdesc.Flags = D3D12_RESOURCE_BARRIER_FLAG_NONE;
@@ -6295,46 +6295,46 @@ using namespace DX12_Internal;
// The real GPU addresses get filled here:
switch (dst->desc.type)
{
- case RaytracingAccelerationStructureDesc::BOTTOMLEVEL:
+ case RaytracingAccelerationStructureDesc::Type::BOTTOMLEVEL:
{
size_t i = 0;
- for (auto& x : dst->desc.bottomlevel.geometries)
+ for (auto& x : dst->desc.bottom_level.geometries)
{
auto& geometry = geometries[i++];
- if (x._flags & RaytracingAccelerationStructureDesc::BottomLevel::Geometry::FLAG_OPAQUE)
+ if (x.flags & RaytracingAccelerationStructureDesc::BottomLevel::Geometry::FLAG_OPAQUE)
{
geometry.Flags |= D3D12_RAYTRACING_GEOMETRY_FLAG_OPAQUE;
}
- if (x._flags & RaytracingAccelerationStructureDesc::BottomLevel::Geometry::FLAG_NO_DUPLICATE_ANYHIT_INVOCATION)
+ if (x.flags & RaytracingAccelerationStructureDesc::BottomLevel::Geometry::FLAG_NO_DUPLICATE_ANYHIT_INVOCATION)
{
geometry.Flags |= D3D12_RAYTRACING_GEOMETRY_FLAG_NO_DUPLICATE_ANYHIT_INVOCATION;
}
- if (x.type == RaytracingAccelerationStructureDesc::BottomLevel::Geometry::TRIANGLES)
+ if (x.type == RaytracingAccelerationStructureDesc::BottomLevel::Geometry::Type::TRIANGLES)
{
- geometry.Triangles.VertexBuffer.StartAddress = to_internal(&x.triangles.vertexBuffer)->gpu_address +
- (D3D12_GPU_VIRTUAL_ADDRESS)x.triangles.vertexByteOffset;
- geometry.Triangles.IndexBuffer = to_internal(&x.triangles.indexBuffer)->gpu_address +
- (D3D12_GPU_VIRTUAL_ADDRESS)x.triangles.indexOffset * (x.triangles.indexFormat == INDEXBUFFER_FORMAT::INDEXFORMAT_16BIT ? sizeof(uint16_t) : sizeof(uint32_t));
+ geometry.Triangles.VertexBuffer.StartAddress = to_internal(&x.triangles.vertex_buffer)->gpu_address +
+ (D3D12_GPU_VIRTUAL_ADDRESS)x.triangles.vertex_byte_offset;
+ geometry.Triangles.IndexBuffer = to_internal(&x.triangles.index_buffer)->gpu_address +
+ (D3D12_GPU_VIRTUAL_ADDRESS)x.triangles.index_offset * (x.triangles.index_format == IndexBufferFormat::UINT16 ? sizeof(uint16_t) : sizeof(uint32_t));
- if (x._flags & RaytracingAccelerationStructureDesc::BottomLevel::Geometry::FLAG_USE_TRANSFORM)
+ if (x.flags & RaytracingAccelerationStructureDesc::BottomLevel::Geometry::FLAG_USE_TRANSFORM)
{
- geometry.Triangles.Transform3x4 = to_internal(&x.triangles.transform3x4Buffer)->gpu_address +
- (D3D12_GPU_VIRTUAL_ADDRESS)x.triangles.transform3x4BufferOffset;
+ geometry.Triangles.Transform3x4 = to_internal(&x.triangles.transform_3x4_buffer)->gpu_address +
+ (D3D12_GPU_VIRTUAL_ADDRESS)x.triangles.transform_3x4_buffer_offset;
}
}
- else if (x.type == RaytracingAccelerationStructureDesc::BottomLevel::Geometry::PROCEDURAL_AABBS)
+ else if (x.type == RaytracingAccelerationStructureDesc::BottomLevel::Geometry::Type::PROCEDURAL_AABBS)
{
- geometry.AABBs.AABBs.StartAddress = to_internal(&x.aabbs.aabbBuffer)->gpu_address +
+ geometry.AABBs.AABBs.StartAddress = to_internal(&x.aabbs.aabb_buffer)->gpu_address +
(D3D12_GPU_VIRTUAL_ADDRESS)x.aabbs.offset;
}
}
}
break;
- case RaytracingAccelerationStructureDesc::TOPLEVEL:
+ case RaytracingAccelerationStructureDesc::Type::TOPLEVEL:
{
- desc.Inputs.InstanceDescs = to_internal(&dst->desc.toplevel.instanceBuffer)->gpu_address +
- (D3D12_GPU_VIRTUAL_ADDRESS)dst->desc.toplevel.offset;
+ desc.Inputs.InstanceDescs = to_internal(&dst->desc.top_level.instance_buffer)->gpu_address +
+ (D3D12_GPU_VIRTUAL_ADDRESS)dst->desc.top_level.offset;
}
break;
}
@@ -6357,7 +6357,7 @@ using namespace DX12_Internal;
prev_pipeline_hash[cmd] = 0;
active_rt[cmd] = rtpso;
- BindComputeShader(rtpso->desc.shaderlibraries.front().shader, cmd);
+ BindComputeShader(rtpso->desc.shader_libraries.front().shader, cmd);
auto internal_state = to_internal(rtpso);
GetCommandList(cmd)->SetPipelineState1(internal_state->resource.Get());
@@ -6368,17 +6368,17 @@ using namespace DX12_Internal;
D3D12_DISPATCH_RAYS_DESC dispatchrays_desc = {};
- dispatchrays_desc.Width = desc->Width;
- dispatchrays_desc.Height = desc->Height;
- dispatchrays_desc.Depth = desc->Depth;
+ dispatchrays_desc.Width = desc->width;
+ dispatchrays_desc.Height = desc->height;
+ dispatchrays_desc.Depth = desc->depth;
- if (desc->raygeneration.buffer != nullptr)
+ if (desc->ray_generation.buffer != nullptr)
{
dispatchrays_desc.RayGenerationShaderRecord.StartAddress =
- to_internal(desc->raygeneration.buffer)->gpu_address +
- (D3D12_GPU_VIRTUAL_ADDRESS)desc->raygeneration.offset;
+ to_internal(desc->ray_generation.buffer)->gpu_address +
+ (D3D12_GPU_VIRTUAL_ADDRESS)desc->ray_generation.offset;
dispatchrays_desc.RayGenerationShaderRecord.SizeInBytes =
- desc->raygeneration.size;
+ desc->ray_generation.size;
}
if (desc->miss.buffer != nullptr)
@@ -6392,15 +6392,15 @@ using namespace DX12_Internal;
desc->miss.stride;
}
- if (desc->hitgroup.buffer != nullptr)
+ if (desc->hit_group.buffer != nullptr)
{
dispatchrays_desc.HitGroupTable.StartAddress =
- to_internal(desc->hitgroup.buffer)->gpu_address +
- (D3D12_GPU_VIRTUAL_ADDRESS)desc->hitgroup.offset;
+ to_internal(desc->hit_group.buffer)->gpu_address +
+ (D3D12_GPU_VIRTUAL_ADDRESS)desc->hit_group.offset;
dispatchrays_desc.HitGroupTable.SizeInBytes =
- desc->hitgroup.size;
+ desc->hit_group.size;
dispatchrays_desc.HitGroupTable.StrideInBytes =
- desc->hitgroup.stride;
+ desc->hit_group.stride;
}
if (desc->callable.buffer != nullptr)
@@ -6421,17 +6421,17 @@ using namespace DX12_Internal;
std::memcpy(pushconstants[cmd].data, data, size);
pushconstants[cmd].size = size;
}
- void GraphicsDevice_DX12::PredicationBegin(const GPUBuffer* buffer, uint64_t offset, PREDICATION_OP op, CommandList cmd)
+ void GraphicsDevice_DX12::PredicationBegin(const GPUBuffer* buffer, uint64_t offset, PredicationOp op, CommandList cmd)
{
auto internal_state = to_internal(buffer);
D3D12_PREDICATION_OP operation;
switch (op)
{
default:
- case wiGraphics::PREDICATION_OP_EQUAL_ZERO:
+ case PredicationOp::EQUAL_ZERO:
operation = D3D12_PREDICATION_OP_EQUAL_ZERO;
break;
- case wiGraphics::PREDICATION_OP_NOT_EQUAL_ZERO:
+ case PredicationOp::NOT_EQUAL_ZERO:
operation = D3D12_PREDICATION_OP_NOT_EQUAL_ZERO;
break;
}
diff --git a/WickedEngine/wiGraphicsDevice_DX12.h b/WickedEngine/wiGraphicsDevice_DX12.h
index efa00c810..5e4495c2b 100644
--- a/WickedEngine/wiGraphicsDevice_DX12.h
+++ b/WickedEngine/wiGraphicsDevice_DX12.h
@@ -24,7 +24,7 @@
namespace wiGraphics
{
- class GraphicsDevice_DX12 : public GraphicsDevice
+ class GraphicsDevice_DX12 final : public GraphicsDevice
{
protected:
Microsoft::WRL::ComPtr dxgiFactory;
@@ -110,7 +110,7 @@ namespace wiGraphics
} cmd_meta[COMMANDLIST_COUNT];
Microsoft::WRL::ComPtr commandLists[COMMANDLIST_COUNT][QUEUE_COUNT];
- inline ID3D12GraphicsCommandList6* GetCommandList(CommandList cmd)
+ inline ID3D12GraphicsCommandList6* GetCommandList(CommandList::index_type cmd)
{
return (ID3D12GraphicsCommandList6*)commandLists[cmd][cmd_meta[cmd].queue].Get();
}
@@ -153,7 +153,7 @@ namespace wiGraphics
const ID3D12RootSignature* active_rootsig_graphics[COMMANDLIST_COUNT] = {};
const ID3D12RootSignature* active_rootsig_compute[COMMANDLIST_COUNT] = {};
const RenderPass* active_renderpass[COMMANDLIST_COUNT] = {};
- SHADING_RATE prev_shadingrate[COMMANDLIST_COUNT] = {};
+ ShadingRate prev_shadingrate[COMMANDLIST_COUNT] = {};
std::vector swapchains[COMMANDLIST_COUNT];
Microsoft::WRL::ComPtr active_backbuffer[COMMANDLIST_COUNT];
@@ -170,7 +170,7 @@ namespace wiGraphics
void predraw(CommandList cmd);
void predispatch(CommandList cmd);
- std::atomic cmd_count{ 0 };
+ std::atomic cmd_count{ 0 };
public:
GraphicsDevice_DX12(bool debuglayer = false, bool gpuvalidation = false);
@@ -179,7 +179,7 @@ namespace wiGraphics
bool CreateSwapChain(const SwapChainDesc* pDesc, wiPlatform::window_type window, SwapChain* swapChain) const override;
bool CreateBuffer(const GPUBufferDesc *pDesc, const void* 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 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;
@@ -187,13 +187,13 @@ namespace wiGraphics
bool CreateRaytracingAccelerationStructure(const RaytracingAccelerationStructureDesc* pDesc, RaytracingAccelerationStructure* bvh) const override;
bool CreateRaytracingPipelineState(const RaytracingPipelineStateDesc* pDesc, RaytracingPipelineState* rtpso) 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;
+ int CreateSubresource(Texture* texture, SubresourceType type, uint32_t firstSlice, uint32_t sliceCount, uint32_t firstMip, uint32_t mipCount) const override;
+ int CreateSubresource(GPUBuffer* buffer, SubresourceType type, uint64_t offset, uint64_t size = ~0) const override;
- int GetDescriptorIndex(const GPUResource* resource, SUBRESOURCE_TYPE type, int subresource = -1) const override;
+ int GetDescriptorIndex(const GPUResource* resource, SubresourceType type, int subresource = -1) const override;
int GetDescriptorIndex(const Sampler* sampler) const override;
- void WriteShadingRateValue(SHADING_RATE rate, void* dest) const override;
+ void WriteShadingRateValue(ShadingRate rate, void* dest) const override;
void WriteTopLevelAccelerationStructureInstance(const RaytracingAccelerationStructureDesc::TopLevel::Instance* instance, void* dest) const override;
void WriteShaderIdentifier(const RaytracingPipelineState* rtpso, uint32_t group_index, void* dest) const override;
@@ -206,13 +206,14 @@ namespace wiGraphics
void WaitForGPU() const override;
void ClearPipelineStateCache() override;
+ size_t GetActivePipelineCount() const override { return pipelines_global.size(); }
- SHADERFORMAT GetShaderFormat() const override { return SHADERFORMAT_HLSL6; }
+ ShaderFormat GetShaderFormat() const override { return ShaderFormat::HLSL6; }
Texture GetBackBuffer(const SwapChain* swapchain) const override;
- COLOR_SPACE GetSwapChainColorSpace(const SwapChain* swapchain) const override;
- bool GetSwapChainHDRSupport(const SwapChain* swapchain) const override;
+ ColorSpace GetSwapChainColorSpace(const SwapChain* swapchain) const override;
+ bool IsSwapChainSupportsHDR(const SwapChain* swapchain) const override;
///////////////Thread-sensitive////////////////////////
@@ -229,10 +230,10 @@ namespace wiGraphics
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 uint64_t* offsets, CommandList cmd) override;
- void BindIndexBuffer(const GPUBuffer* indexBuffer, const INDEXBUFFER_FORMAT format, uint64_t offset, CommandList cmd) override;
+ void BindIndexBuffer(const GPUBuffer* indexBuffer, const IndexBufferFormat format, uint64_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 BindShadingRate(SHADING_RATE rate, CommandList cmd) override;
+ void BindShadingRate(ShadingRate rate, 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;
@@ -256,7 +257,7 @@ namespace wiGraphics
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;
- void PredicationBegin(const GPUBuffer* buffer, uint64_t offset, PREDICATION_OP op, CommandList cmd) override;
+ void PredicationBegin(const GPUBuffer* buffer, uint64_t offset, PredicationOp op, CommandList cmd) override;
void PredicationEnd(CommandList cmd) override;
void EventBegin(const char* name, CommandList cmd) override;
diff --git a/WickedEngine/wiGraphicsDevice_Vulkan.cpp b/WickedEngine/wiGraphicsDevice_Vulkan.cpp
index 17a635328..660f54678 100644
--- a/WickedEngine/wiGraphicsDevice_Vulkan.cpp
+++ b/WickedEngine/wiGraphicsDevice_Vulkan.cpp
@@ -40,315 +40,315 @@ namespace wiGraphics
namespace Vulkan_Internal
{
// Converters:
- constexpr VkFormat _ConvertFormat(FORMAT value)
+ constexpr VkFormat _ConvertFormat(Format value)
{
switch (value)
{
- case FORMAT_UNKNOWN:
+ case Format::UNKNOWN:
return VK_FORMAT_UNDEFINED;
break;
- case FORMAT_R32G32B32A32_FLOAT:
+ case Format::R32G32B32A32_FLOAT:
return VK_FORMAT_R32G32B32A32_SFLOAT;
break;
- case FORMAT_R32G32B32A32_UINT:
+ case Format::R32G32B32A32_UINT:
return VK_FORMAT_R32G32B32A32_UINT;
break;
- case FORMAT_R32G32B32A32_SINT:
+ case Format::R32G32B32A32_SINT:
return VK_FORMAT_R32G32B32A32_SINT;
break;
- case FORMAT_R32G32B32_FLOAT:
+ case Format::R32G32B32_FLOAT:
return VK_FORMAT_R32G32B32_SFLOAT;
break;
- case FORMAT_R32G32B32_UINT:
+ case Format::R32G32B32_UINT:
return VK_FORMAT_R32G32B32_UINT;
break;
- case FORMAT_R32G32B32_SINT:
+ case Format::R32G32B32_SINT:
return VK_FORMAT_R32G32B32_SINT;
break;
- case FORMAT_R16G16B16A16_FLOAT:
+ case Format::R16G16B16A16_FLOAT:
return VK_FORMAT_R16G16B16A16_SFLOAT;
break;
- case FORMAT_R16G16B16A16_UNORM:
+ case Format::R16G16B16A16_UNORM:
return VK_FORMAT_R16G16B16A16_UNORM;
break;
- case FORMAT_R16G16B16A16_UINT:
+ case Format::R16G16B16A16_UINT:
return VK_FORMAT_R16G16B16A16_UINT;
break;
- case FORMAT_R16G16B16A16_SNORM:
+ case Format::R16G16B16A16_SNORM:
return VK_FORMAT_R16G16B16A16_SNORM;
break;
- case FORMAT_R16G16B16A16_SINT:
+ case Format::R16G16B16A16_SINT:
return VK_FORMAT_R16G16B16A16_SINT;
break;
- case FORMAT_R32G32_FLOAT:
+ case Format::R32G32_FLOAT:
return VK_FORMAT_R32G32_SFLOAT;
break;
- case FORMAT_R32G32_UINT:
+ case Format::R32G32_UINT:
return VK_FORMAT_R32G32_UINT;
break;
- case FORMAT_R32G32_SINT:
+ case Format::R32G32_SINT:
return VK_FORMAT_R32G32_SINT;
break;
- case FORMAT_R32G8X24_TYPELESS:
+ case Format::R32G8X24_TYPELESS:
return VK_FORMAT_D32_SFLOAT_S8_UINT;
break;
- case FORMAT_D32_FLOAT_S8X24_UINT:
+ case Format::D32_FLOAT_S8X24_UINT:
return VK_FORMAT_D32_SFLOAT_S8_UINT;
break;
- case FORMAT_R10G10B10A2_UNORM:
+ case Format::R10G10B10A2_UNORM:
return VK_FORMAT_A2B10G10R10_UNORM_PACK32;
break;
- case FORMAT_R10G10B10A2_UINT:
+ case Format::R10G10B10A2_UINT:
return VK_FORMAT_A2B10G10R10_UINT_PACK32;
break;
- case FORMAT_R11G11B10_FLOAT:
+ case Format::R11G11B10_FLOAT:
return VK_FORMAT_B10G11R11_UFLOAT_PACK32;
break;
- case FORMAT_R8G8B8A8_UNORM:
+ case Format::R8G8B8A8_UNORM:
return VK_FORMAT_R8G8B8A8_UNORM;
break;
- case FORMAT_R8G8B8A8_UNORM_SRGB:
+ case Format::R8G8B8A8_UNORM_SRGB:
return VK_FORMAT_R8G8B8A8_SRGB;
break;
- case FORMAT_R8G8B8A8_UINT:
+ case Format::R8G8B8A8_UINT:
return VK_FORMAT_R8G8B8A8_UINT;
break;
- case FORMAT_R8G8B8A8_SNORM:
+ case Format::R8G8B8A8_SNORM:
return VK_FORMAT_R8G8B8A8_SNORM;
break;
- case FORMAT_R8G8B8A8_SINT:
+ case Format::R8G8B8A8_SINT:
return VK_FORMAT_R8G8B8A8_SINT;
break;
- case FORMAT_R16G16_FLOAT:
+ case Format::R16G16_FLOAT:
return VK_FORMAT_R16G16_SFLOAT;
break;
- case FORMAT_R16G16_UNORM:
+ case Format::R16G16_UNORM:
return VK_FORMAT_R16G16_UNORM;
break;
- case FORMAT_R16G16_UINT:
+ case Format::R16G16_UINT:
return VK_FORMAT_R16G16_UINT;
break;
- case FORMAT_R16G16_SNORM:
+ case Format::R16G16_SNORM:
return VK_FORMAT_R16G16_SNORM;
break;
- case FORMAT_R16G16_SINT:
+ case Format::R16G16_SINT:
return VK_FORMAT_R16G16_SINT;
break;
- case FORMAT_R32_TYPELESS:
+ case Format::R32_TYPELESS:
return VK_FORMAT_D32_SFLOAT;
break;
- case FORMAT_D32_FLOAT:
+ case Format::D32_FLOAT:
return VK_FORMAT_D32_SFLOAT;
break;
- case FORMAT_R32_FLOAT:
+ case Format::R32_FLOAT:
return VK_FORMAT_R32_SFLOAT;
break;
- case FORMAT_R32_UINT:
+ case Format::R32_UINT:
return VK_FORMAT_R32_UINT;
break;
- case FORMAT_R32_SINT:
+ case Format::R32_SINT:
return VK_FORMAT_R32_SINT;
break;
- case FORMAT_R24G8_TYPELESS:
+ case Format::R24G8_TYPELESS:
return VK_FORMAT_D24_UNORM_S8_UINT;
break;
- case FORMAT_D24_UNORM_S8_UINT:
+ case Format::D24_UNORM_S8_UINT:
return VK_FORMAT_D24_UNORM_S8_UINT;
break;
- case FORMAT_R8G8_UNORM:
+ case Format::R8G8_UNORM:
return VK_FORMAT_R8G8_UNORM;
break;
- case FORMAT_R8G8_UINT:
+ case Format::R8G8_UINT:
return VK_FORMAT_R8G8_UINT;
break;
- case FORMAT_R8G8_SNORM:
+ case Format::R8G8_SNORM:
return VK_FORMAT_R8G8_SNORM;
break;
- case FORMAT_R8G8_SINT:
+ case Format::R8G8_SINT:
return VK_FORMAT_R8G8_SINT;
break;
- case FORMAT_R16_TYPELESS:
+ case Format::R16_TYPELESS:
return VK_FORMAT_D16_UNORM;
break;
- case FORMAT_R16_FLOAT:
+ case Format::R16_FLOAT:
return VK_FORMAT_R16_SFLOAT;
break;
- case FORMAT_D16_UNORM:
+ case Format::D16_UNORM:
return VK_FORMAT_D16_UNORM;
break;
- case FORMAT_R16_UNORM:
+ case Format::R16_UNORM:
return VK_FORMAT_R16_UNORM;
break;
- case FORMAT_R16_UINT:
+ case Format::R16_UINT:
return VK_FORMAT_R16_UINT;
break;
- case FORMAT_R16_SNORM:
+ case Format::R16_SNORM:
return VK_FORMAT_R16_SNORM;
break;
- case FORMAT_R16_SINT:
+ case Format::R16_SINT:
return VK_FORMAT_R16_SINT;
break;
- case FORMAT_R8_UNORM:
+ case Format::R8_UNORM:
return VK_FORMAT_R8_UNORM;
break;
- case FORMAT_R8_UINT:
+ case Format::R8_UINT:
return VK_FORMAT_R8_UINT;
break;
- case FORMAT_R8_SNORM:
+ case Format::R8_SNORM:
return VK_FORMAT_R8_SNORM;
break;
- case FORMAT_R8_SINT:
+ case Format::R8_SINT:
return VK_FORMAT_R8_SINT;
break;
- case FORMAT_BC1_UNORM:
+ case Format::BC1_UNORM:
return VK_FORMAT_BC1_RGBA_UNORM_BLOCK;
break;
- case FORMAT_BC1_UNORM_SRGB:
+ case Format::BC1_UNORM_SRGB:
return VK_FORMAT_BC1_RGBA_SRGB_BLOCK;
break;
- case FORMAT_BC2_UNORM:
+ case Format::BC2_UNORM:
return VK_FORMAT_BC2_UNORM_BLOCK;
break;
- case FORMAT_BC2_UNORM_SRGB:
+ case Format::BC2_UNORM_SRGB:
return VK_FORMAT_BC2_SRGB_BLOCK;
break;
- case FORMAT_BC3_UNORM:
+ case Format::BC3_UNORM:
return VK_FORMAT_BC3_UNORM_BLOCK;
break;
- case FORMAT_BC3_UNORM_SRGB:
+ case Format::BC3_UNORM_SRGB:
return VK_FORMAT_BC3_SRGB_BLOCK;
break;
- case FORMAT_BC4_UNORM:
+ case Format::BC4_UNORM:
return VK_FORMAT_BC4_UNORM_BLOCK;
break;
- case FORMAT_BC4_SNORM:
+ case Format::BC4_SNORM:
return VK_FORMAT_BC4_SNORM_BLOCK;
break;
- case FORMAT_BC5_UNORM:
+ case Format::BC5_UNORM:
return VK_FORMAT_BC5_UNORM_BLOCK;
break;
- case FORMAT_BC5_SNORM:
+ case Format::BC5_SNORM:
return VK_FORMAT_BC5_SNORM_BLOCK;
break;
- case FORMAT_B8G8R8A8_UNORM:
+ case Format::B8G8R8A8_UNORM:
return VK_FORMAT_B8G8R8A8_UNORM;
break;
- case FORMAT_B8G8R8A8_UNORM_SRGB:
+ case Format::B8G8R8A8_UNORM_SRGB:
return VK_FORMAT_B8G8R8A8_SRGB;
break;
- case FORMAT_BC6H_UF16:
+ case Format::BC6H_UF16:
return VK_FORMAT_BC6H_UFLOAT_BLOCK;
break;
- case FORMAT_BC6H_SF16:
+ case Format::BC6H_SF16:
return VK_FORMAT_BC6H_SFLOAT_BLOCK;
break;
- case FORMAT_BC7_UNORM:
+ case Format::BC7_UNORM:
return VK_FORMAT_BC7_UNORM_BLOCK;
break;
- case FORMAT_BC7_UNORM_SRGB:
+ case Format::BC7_UNORM_SRGB:
return VK_FORMAT_BC7_SRGB_BLOCK;
break;
}
return VK_FORMAT_UNDEFINED;
}
- constexpr VkCompareOp _ConvertComparisonFunc(COMPARISON_FUNC value)
+ constexpr VkCompareOp _ConvertComparisonFunc(ComparisonFunc value)
{
switch (value)
{
- case COMPARISON_NEVER:
+ case ComparisonFunc::NEVER:
return VK_COMPARE_OP_NEVER;
- case COMPARISON_LESS:
+ case ComparisonFunc::LESS:
return VK_COMPARE_OP_LESS;
- case COMPARISON_EQUAL:
+ case ComparisonFunc::EQUAL:
return VK_COMPARE_OP_EQUAL;
- case COMPARISON_LESS_EQUAL:
+ case ComparisonFunc::LESS_EQUAL:
return VK_COMPARE_OP_LESS_OR_EQUAL;
- case COMPARISON_GREATER:
+ case ComparisonFunc::GREATER:
return VK_COMPARE_OP_GREATER;
- case COMPARISON_NOT_EQUAL:
+ case ComparisonFunc::NOT_EQUAL:
return VK_COMPARE_OP_NOT_EQUAL;
- case COMPARISON_GREATER_EQUAL:
+ case ComparisonFunc::GREATER_EQUAL:
return VK_COMPARE_OP_GREATER_OR_EQUAL;
- case COMPARISON_ALWAYS:
+ case ComparisonFunc::ALWAYS:
return VK_COMPARE_OP_ALWAYS;
default:
return VK_COMPARE_OP_NEVER;
}
}
- constexpr VkBlendFactor _ConvertBlend(BLEND value)
+ constexpr VkBlendFactor _ConvertBlend(Blend value)
{
switch (value)
{
- case BLEND_ZERO:
+ case Blend::ZERO:
return VK_BLEND_FACTOR_ZERO;
- case BLEND_ONE:
+ case Blend::ONE:
return VK_BLEND_FACTOR_ONE;
- case BLEND_SRC_COLOR:
+ case Blend::SRC_COLOR:
return VK_BLEND_FACTOR_SRC_COLOR;
- case BLEND_INV_SRC_COLOR:
+ case Blend::INV_SRC_COLOR:
return VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR;
- case BLEND_SRC_ALPHA:
+ case Blend::SRC_ALPHA:
return VK_BLEND_FACTOR_SRC_ALPHA;
- case BLEND_INV_SRC_ALPHA:
+ case Blend::INV_SRC_ALPHA:
return VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;
- case BLEND_DEST_ALPHA:
+ case Blend::DEST_ALPHA:
return VK_BLEND_FACTOR_DST_ALPHA;
- case BLEND_INV_DEST_ALPHA:
+ case Blend::INV_DEST_ALPHA:
return VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA;
- case BLEND_DEST_COLOR:
+ case Blend::DEST_COLOR:
return VK_BLEND_FACTOR_DST_COLOR;
- case BLEND_INV_DEST_COLOR:
+ case Blend::INV_DEST_COLOR:
return VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR;
- case BLEND_SRC_ALPHA_SAT:
+ case Blend::SRC_ALPHA_SAT:
return VK_BLEND_FACTOR_SRC_ALPHA_SATURATE;
- case BLEND_BLEND_FACTOR:
+ case Blend::BLEND_FACTOR:
return VK_BLEND_FACTOR_CONSTANT_COLOR;
- case BLEND_INV_BLEND_FACTOR:
+ case Blend::INV_BLEND_FACTOR:
return VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR;
break;
- case BLEND_SRC1_COLOR:
+ case Blend::SRC1_COLOR:
return VK_BLEND_FACTOR_SRC1_COLOR;
- case BLEND_INV_SRC1_COLOR:
+ case Blend::INV_SRC1_COLOR:
return VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR;
- case BLEND_SRC1_ALPHA:
+ case Blend::SRC1_ALPHA:
return VK_BLEND_FACTOR_SRC1_ALPHA;
- case BLEND_INV_SRC1_ALPHA:
+ case Blend::INV_SRC1_ALPHA:
return VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA;
default:
return VK_BLEND_FACTOR_ZERO;
}
}
- constexpr VkBlendOp _ConvertBlendOp(BLEND_OP value)
+ constexpr VkBlendOp _ConvertBlendOp(BlendOp value)
{
switch (value)
{
- case BLEND_OP_ADD:
+ case BlendOp::ADD:
return VK_BLEND_OP_ADD;
- case BLEND_OP_SUBTRACT:
+ case BlendOp::SUBTRACT:
return VK_BLEND_OP_SUBTRACT;
- case BLEND_OP_REV_SUBTRACT:
+ case BlendOp::REV_SUBTRACT:
return VK_BLEND_OP_REVERSE_SUBTRACT;
- case BLEND_OP_MIN:
+ case BlendOp::MIN:
return VK_BLEND_OP_MIN;
- case BLEND_OP_MAX:
+ case BlendOp::MAX:
return VK_BLEND_OP_MAX;
default:
return VK_BLEND_OP_ADD;
}
}
- constexpr VkSamplerAddressMode _ConvertTextureAddressMode(TEXTURE_ADDRESS_MODE value, const VkPhysicalDeviceVulkan12Features& features_1_2)
+ constexpr VkSamplerAddressMode _ConvertTextureAddressMode(TextureAddressMode value, const VkPhysicalDeviceVulkan12Features& features_1_2)
{
switch (value)
{
- case TEXTURE_ADDRESS_WRAP:
+ case TextureAddressMode::WRAP:
return VK_SAMPLER_ADDRESS_MODE_REPEAT;
- case TEXTURE_ADDRESS_MIRROR:
+ case TextureAddressMode::MIRROR:
return VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT;
- case TEXTURE_ADDRESS_CLAMP:
+ case TextureAddressMode::CLAMP:
return VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
- case TEXTURE_ADDRESS_BORDER:
+ case TextureAddressMode::BORDER:
return VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER;
- case TEXTURE_ADDRESS_MIRROR_ONCE:
+ case TextureAddressMode::MIRROR_ONCE:
if (features_1_2.samplerMirrorClampToEdge == VK_TRUE)
{
return VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE;
@@ -358,46 +358,46 @@ namespace Vulkan_Internal
return VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
}
}
- constexpr VkBorderColor _ConvertSamplerBorderColor(SAMPLER_BORDER_COLOR value)
+ constexpr VkBorderColor _ConvertSamplerBorderColor(SamplerBorderColor value)
{
switch (value)
{
- case SAMPLER_BORDER_COLOR_TRANSPARENT_BLACK:
+ case SamplerBorderColor::TRANSPARENT_BLACK:
return VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK;
- case SAMPLER_BORDER_COLOR_OPAQUE_BLACK:
+ case SamplerBorderColor::OPAQUE_BLACK:
return VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK;
- case SAMPLER_BORDER_COLOR_OPAQUE_WHITE:
+ case SamplerBorderColor::OPAQUE_WHITE:
return VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE;
default:
return VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK;
}
}
- constexpr VkStencilOp _ConvertStencilOp(STENCIL_OP value)
+ constexpr VkStencilOp _ConvertStencilOp(StencilOp value)
{
switch (value)
{
- case wiGraphics::STENCIL_OP_KEEP:
+ case wiGraphics::StencilOp::KEEP:
return VK_STENCIL_OP_KEEP;
break;
- case wiGraphics::STENCIL_OP_ZERO:
+ case wiGraphics::StencilOp::ZERO:
return VK_STENCIL_OP_ZERO;
break;
- case wiGraphics::STENCIL_OP_REPLACE:
+ case wiGraphics::StencilOp::REPLACE:
return VK_STENCIL_OP_REPLACE;
break;
- case wiGraphics::STENCIL_OP_INCR_SAT:
+ case wiGraphics::StencilOp::INCR_SAT:
return VK_STENCIL_OP_INCREMENT_AND_CLAMP;
break;
- case wiGraphics::STENCIL_OP_DECR_SAT:
+ case wiGraphics::StencilOp::DECR_SAT:
return VK_STENCIL_OP_DECREMENT_AND_CLAMP;
break;
- case wiGraphics::STENCIL_OP_INVERT:
+ case wiGraphics::StencilOp::INVERT:
return VK_STENCIL_OP_INVERT;
break;
- case wiGraphics::STENCIL_OP_INCR:
+ case wiGraphics::StencilOp::INCR:
return VK_STENCIL_OP_INCREMENT_AND_WRAP;
break;
- case wiGraphics::STENCIL_OP_DECR:
+ case wiGraphics::StencilOp::DECR:
return VK_STENCIL_OP_DECREMENT_AND_WRAP;
break;
default:
@@ -405,115 +405,115 @@ namespace Vulkan_Internal
}
return VK_STENCIL_OP_KEEP;
}
- constexpr VkImageLayout _ConvertImageLayout(RESOURCE_STATE value)
+ constexpr VkImageLayout _ConvertImageLayout(ResourceState value)
{
switch (value)
{
- case wiGraphics::RESOURCE_STATE_UNDEFINED:
+ case ResourceState::UNDEFINED:
return VK_IMAGE_LAYOUT_UNDEFINED;
- case wiGraphics::RESOURCE_STATE_RENDERTARGET:
+ case ResourceState::RENDERTARGET:
return VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
- case wiGraphics::RESOURCE_STATE_DEPTHSTENCIL:
+ case ResourceState::DEPTHSTENCIL:
return VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
- case wiGraphics::RESOURCE_STATE_DEPTHSTENCIL_READONLY:
+ case ResourceState::DEPTHSTENCIL_READONLY:
return VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL;
- case wiGraphics::RESOURCE_STATE_SHADER_RESOURCE:
- case wiGraphics::RESOURCE_STATE_SHADER_RESOURCE_COMPUTE:
+ case ResourceState::SHADER_RESOURCE:
+ case ResourceState::SHADER_RESOURCE_COMPUTE:
return VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
- case wiGraphics::RESOURCE_STATE_UNORDERED_ACCESS:
+ case ResourceState::UNORDERED_ACCESS:
return VK_IMAGE_LAYOUT_GENERAL;
- case wiGraphics::RESOURCE_STATE_COPY_SRC:
+ case ResourceState::COPY_SRC:
return VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL;
- case wiGraphics::RESOURCE_STATE_COPY_DST:
+ case ResourceState::COPY_DST:
return VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
- case wiGraphics::RESOURCE_STATE_SHADING_RATE_SOURCE:
+ case ResourceState::SHADING_RATE_SOURCE:
return VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR;
}
return VK_IMAGE_LAYOUT_UNDEFINED;
}
- constexpr VkShaderStageFlags _ConvertStageFlags(SHADERSTAGE value)
+ constexpr VkShaderStageFlags _ConvertStageFlags(ShaderStage value)
{
switch (value)
{
- case wiGraphics::MS:
+ case ShaderStage::MS:
return VK_SHADER_STAGE_MESH_BIT_NV;
- case wiGraphics::AS:
+ case ShaderStage::AS:
return VK_SHADER_STAGE_TASK_BIT_NV;
- case wiGraphics::VS:
+ case ShaderStage::VS:
return VK_SHADER_STAGE_VERTEX_BIT;
- case wiGraphics::HS:
+ case ShaderStage::HS:
return VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT;
- case wiGraphics::DS:
+ case ShaderStage::DS:
return VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT;
- case wiGraphics::GS:
+ case ShaderStage::GS:
return VK_SHADER_STAGE_GEOMETRY_BIT;
- case wiGraphics::PS:
+ case ShaderStage::PS:
return VK_SHADER_STAGE_FRAGMENT_BIT;
- case wiGraphics::CS:
+ case ShaderStage::CS:
return VK_SHADER_STAGE_COMPUTE_BIT;
default:
return VK_SHADER_STAGE_ALL;
}
}
- constexpr VkAccessFlags _ParseResourceState(RESOURCE_STATE value)
+ constexpr VkAccessFlags _ParseResourceState(ResourceState value)
{
VkAccessFlags flags = 0;
- if (value & RESOURCE_STATE_SHADER_RESOURCE)
+ if (has_flag(value, ResourceState::SHADER_RESOURCE))
{
flags |= VK_ACCESS_SHADER_READ_BIT;
}
- if (value & RESOURCE_STATE_SHADER_RESOURCE_COMPUTE)
+ if (has_flag(value, ResourceState::SHADER_RESOURCE_COMPUTE))
{
flags |= VK_ACCESS_SHADER_READ_BIT;
}
- if (value & RESOURCE_STATE_UNORDERED_ACCESS)
+ if (has_flag(value, ResourceState::UNORDERED_ACCESS))
{
flags |= VK_ACCESS_SHADER_READ_BIT;
flags |= VK_ACCESS_SHADER_WRITE_BIT;
}
- if (value & RESOURCE_STATE_COPY_SRC)
+ if (has_flag(value, ResourceState::COPY_SRC))
{
flags |= VK_ACCESS_TRANSFER_READ_BIT;
}
- if (value & RESOURCE_STATE_COPY_DST)
+ if (has_flag(value, ResourceState::COPY_DST))
{
flags |= VK_ACCESS_TRANSFER_WRITE_BIT;
}
- if (value & RESOURCE_STATE_RENDERTARGET)
+ if (has_flag(value, ResourceState::RENDERTARGET))
{
flags |= VK_ACCESS_COLOR_ATTACHMENT_READ_BIT;
flags |= VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
}
- if (value & RESOURCE_STATE_DEPTHSTENCIL)
+ if (has_flag(value, ResourceState::DEPTHSTENCIL))
{
flags |= VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT;
flags |= VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
}
- if (value & RESOURCE_STATE_DEPTHSTENCIL_READONLY)
+ if (has_flag(value, ResourceState::DEPTHSTENCIL_READONLY))
{
flags |= VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT;
}
- if (value & RESOURCE_STATE_VERTEX_BUFFER)
+ if (has_flag(value, ResourceState::VERTEX_BUFFER))
{
flags |= VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT;
}
- if (value & RESOURCE_STATE_INDEX_BUFFER)
+ if (has_flag(value, ResourceState::INDEX_BUFFER))
{
flags |= VK_ACCESS_INDEX_READ_BIT;
}
- if (value & RESOURCE_STATE_CONSTANT_BUFFER)
+ if (has_flag(value, ResourceState::CONSTANT_BUFFER))
{
flags |= VK_ACCESS_UNIFORM_READ_BIT;
}
- if (value & RESOURCE_STATE_INDIRECT_ARGUMENT)
+ if (has_flag(value, ResourceState::INDIRECT_ARGUMENT))
{
flags |= VK_ACCESS_INDIRECT_COMMAND_READ_BIT;
}
- if (value & RESOURCE_STATE_PREDICATION)
+ if (has_flag(value, ResourceState::PREDICATION))
{
flags |= VK_ACCESS_CONDITIONAL_RENDERING_READ_BIT_EXT;
}
@@ -826,7 +826,7 @@ namespace Vulkan_Internal
size_t binding_hash = 0;
VkGraphicsPipelineCreateInfo pipelineInfo = {};
- VkPipelineShaderStageCreateInfo shaderStages[SHADERSTAGE_COUNT] = {};
+ VkPipelineShaderStageCreateInfo shaderStages[static_cast(ShaderStage::Count)] = {};
VkPipelineInputAssemblyStateCreateInfo inputAssembly = {};
VkPipelineRasterizationStateCreateInfo rasterizer = {};
VkPipelineRasterizationDepthClipStateCreateInfoEXT depthclip = {};
@@ -916,7 +916,7 @@ namespace Vulkan_Internal
VkSemaphore swapchainAcquireSemaphore = VK_NULL_HANDLE;
VkSemaphore swapchainReleaseSemaphore = VK_NULL_HANDLE;
- COLOR_SPACE colorSpace = COLOR_SPACE_SRGB;
+ ColorSpace colorSpace = ColorSpace::SRGB;
SwapChainDesc desc;
std::mutex locker;
@@ -1053,18 +1053,18 @@ namespace Vulkan_Internal
}
// For now, we only include the color spaces that were tested successfully:
- COLOR_SPACE prev_colorspace = internal_state->colorSpace;
+ ColorSpace prev_colorspace = internal_state->colorSpace;
switch (surfaceFormat.colorSpace)
{
default:
case VK_COLOR_SPACE_SRGB_NONLINEAR_KHR:
- internal_state->colorSpace = COLOR_SPACE_SRGB;
+ internal_state->colorSpace = ColorSpace::SRGB;
break;
case VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT:
- internal_state->colorSpace = COLOR_SPACE_HDR_LINEAR;
+ internal_state->colorSpace = ColorSpace::HDR_LINEAR;
break;
case VK_COLOR_SPACE_HDR10_ST2084_EXT:
- internal_state->colorSpace = COLOR_SPACE_HDR10_ST2084;
+ internal_state->colorSpace = ColorSpace::HDR10_ST2084;
break;
}
@@ -1092,7 +1092,7 @@ namespace Vulkan_Internal
internal_state->swapChainExtent.height = std::max(swapchain_capabilities.minImageExtent.height, std::min(swapchain_capabilities.maxImageExtent.height, internal_state->swapChainExtent.height));
}
- uint32_t imageCount = std::max(internal_state->desc.buffercount, swapchain_capabilities.minImageCount);
+ uint32_t imageCount = std::max(internal_state->desc.buffer_count, swapchain_capabilities.minImageCount);
if ((swapchain_capabilities.maxImageCount > 0) && (imageCount > swapchain_capabilities.maxImageCount))
{
imageCount = swapchain_capabilities.maxImageCount;
@@ -1395,12 +1395,12 @@ using namespace Vulkan_Internal;
}
CopyCMD cmd = freelist.back();
- if (cmd.uploadbuffer.desc.Size < staging_size)
+ if (cmd.uploadbuffer.desc.size < staging_size)
{
// Try to search for a staging buffer that can fit the request:
for (size_t i = 0; i < freelist.size(); ++i)
{
- if (freelist[i].uploadbuffer.desc.Size >= staging_size)
+ if (freelist[i].uploadbuffer.desc.size >= staging_size)
{
cmd = freelist[i];
std::swap(freelist[i], freelist.back());
@@ -1412,11 +1412,11 @@ using namespace Vulkan_Internal;
locker.unlock();
// If no buffer was found that fits the data, create one:
- if (cmd.uploadbuffer.desc.Size < staging_size)
+ if (cmd.uploadbuffer.desc.size < staging_size)
{
GPUBufferDesc uploaddesc;
- uploaddesc.Size = wiMath::GetNextPowerOfTwo(staging_size);
- uploaddesc.Usage = USAGE_UPLOAD;
+ uploaddesc.size = wiMath::GetNextPowerOfTwo(staging_size);
+ uploaddesc.usage = Usage::UPLOAD;
bool upload_success = device->CreateBuffer(&uploaddesc, nullptr, &cmd.uploadbuffer);
assert(upload_success);
}
@@ -1542,7 +1542,7 @@ using namespace Vulkan_Internal;
poolSizes[7].descriptorCount = DESCRIPTORBINDER_SAMPLER_COUNT * poolSize;
count++;
- if (device->CheckCapability(GRAPHICSDEVICE_CAPABILITY_RAYTRACING))
+ if (device->CheckCapability(GraphicsDeviceCapability::RAYTRACING))
{
poolSizes[8].type = VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR;
poolSizes[8].descriptorCount = DESCRIPTORBINDER_SRV_COUNT * poolSize;
@@ -1829,7 +1829,7 @@ using namespace Vulkan_Internal;
auto internal_state = to_internal(&buffer);
bufferInfos.back().buffer = internal_state->resource;
bufferInfos.back().offset = offset;
- bufferInfos.back().range = std::min(buffer.desc.Size - offset, (uint64_t)device->properties2.properties.limits.maxUniformBufferRange);
+ bufferInfos.back().range = std::min(buffer.desc.size - offset, (uint64_t)device->properties2.properties.limits.maxUniformBufferRange);
}
}
break;
@@ -1974,7 +1974,7 @@ using namespace Vulkan_Internal;
{
bindPoint = VK_PIPELINE_BIND_POINT_COMPUTE;
- if (device->active_cs[cmd]->stage == LIB)
+ if (device->active_cs[cmd]->stage == ShaderStage::LIB)
{
bindPoint = VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR;
}
@@ -2028,23 +2028,23 @@ using namespace Vulkan_Internal;
multisampling.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT;
if (active_renderpass[cmd]->desc.attachments.size() > 0 && active_renderpass[cmd]->desc.attachments[0].texture != nullptr)
{
- multisampling.rasterizationSamples = (VkSampleCountFlagBits)active_renderpass[cmd]->desc.attachments[0].texture->desc.SampleCount;
+ multisampling.rasterizationSamples = (VkSampleCountFlagBits)active_renderpass[cmd]->desc.attachments[0].texture->desc.sample_count;
}
if (pso->desc.rs != nullptr)
{
const RasterizerState& desc = *pso->desc.rs;
- if (desc.ForcedSampleCount > 1)
+ if (desc.forced_sample_count > 1)
{
- multisampling.rasterizationSamples = (VkSampleCountFlagBits)desc.ForcedSampleCount;
+ multisampling.rasterizationSamples = (VkSampleCountFlagBits)desc.forced_sample_count;
}
}
multisampling.minSampleShading = 1.0f;
VkSampleMask samplemask = internal_state->samplemask;
- samplemask = pso->desc.sampleMask;
+ samplemask = pso->desc.sample_mask;
multisampling.pSampleMask = &samplemask;
if (pso->desc.bs != nullptr)
{
- multisampling.alphaToCoverageEnable = pso->desc.bs->AlphaToCoverageEnable ? VK_TRUE : VK_FALSE;
+ multisampling.alphaToCoverageEnable = pso->desc.bs->alpha_to_coverage_enable ? VK_TRUE : VK_FALSE;
}
else
{
@@ -2061,45 +2061,45 @@ using namespace Vulkan_Internal;
const size_t blend_loopCount = active_renderpass[cmd]->desc.attachments.size();
for (size_t i = 0; i < blend_loopCount; ++i)
{
- if (active_renderpass[cmd]->desc.attachments[i].type != RenderPassAttachment::RENDERTARGET)
+ if (active_renderpass[cmd]->desc.attachments[i].type != RenderPassAttachment::Type::RENDERTARGET)
{
continue;
}
size_t attachmentIndex = 0;
- if (pso->desc.bs->IndependentBlendEnable)
+ if (pso->desc.bs->independent_blend_enable)
attachmentIndex = i;
- const auto& desc = pso->desc.bs->RenderTarget[attachmentIndex];
+ const auto& desc = pso->desc.bs->render_target[attachmentIndex];
VkPipelineColorBlendAttachmentState& attachment = colorBlendAttachments[numBlendAttachments];
numBlendAttachments++;
- attachment.blendEnable = desc.BlendEnable ? VK_TRUE : VK_FALSE;
+ attachment.blendEnable = desc.blend_enable ? VK_TRUE : VK_FALSE;
attachment.colorWriteMask = 0;
- if (desc.RenderTargetWriteMask & COLOR_WRITE_ENABLE_RED)
+ if (has_flag(desc.render_target_write_mask, ColorWrite::ENABLE_RED))
{
attachment.colorWriteMask |= VK_COLOR_COMPONENT_R_BIT;
}
- if (desc.RenderTargetWriteMask & COLOR_WRITE_ENABLE_GREEN)
+ if (has_flag(desc.render_target_write_mask, ColorWrite::ENABLE_GREEN))
{
attachment.colorWriteMask |= VK_COLOR_COMPONENT_G_BIT;
}
- if (desc.RenderTargetWriteMask & COLOR_WRITE_ENABLE_BLUE)
+ if (has_flag(desc.render_target_write_mask, ColorWrite::ENABLE_BLUE))
{
attachment.colorWriteMask |= VK_COLOR_COMPONENT_B_BIT;
}
- if (desc.RenderTargetWriteMask & COLOR_WRITE_ENABLE_ALPHA)
+ if (has_flag(desc.render_target_write_mask, ColorWrite::ENABLE_ALPHA))
{
attachment.colorWriteMask |= VK_COLOR_COMPONENT_A_BIT;
}
- attachment.srcColorBlendFactor = _ConvertBlend(desc.SrcBlend);
- attachment.dstColorBlendFactor = _ConvertBlend(desc.DestBlend);
- attachment.colorBlendOp = _ConvertBlendOp(desc.BlendOp);
- attachment.srcAlphaBlendFactor = _ConvertBlend(desc.SrcBlendAlpha);
- attachment.dstAlphaBlendFactor = _ConvertBlend(desc.DestBlendAlpha);
- attachment.alphaBlendOp = _ConvertBlendOp(desc.BlendOpAlpha);
+ attachment.srcColorBlendFactor = _ConvertBlend(desc.src_blend);
+ attachment.dstColorBlendFactor = _ConvertBlend(desc.dest_blend);
+ attachment.colorBlendOp = _ConvertBlendOp(desc.blend_op);
+ attachment.srcAlphaBlendFactor = _ConvertBlend(desc.src_blend_alpha);
+ attachment.dstAlphaBlendFactor = _ConvertBlend(desc.dest_blend_alpha);
+ attachment.alphaBlendOp = _ConvertBlendOp(desc.blend_op_alpha);
}
VkPipelineColorBlendStateCreateInfo colorBlending = {};
@@ -2125,13 +2125,13 @@ using namespace Vulkan_Internal;
uint32_t lastBinding = 0xFFFFFFFF;
for (auto& x : pso->desc.il->elements)
{
- if (x.InputSlot == lastBinding)
+ if (x.input_slot == lastBinding)
continue;
- lastBinding = x.InputSlot;
+ lastBinding = x.input_slot;
VkVertexInputBindingDescription& bind = bindings.emplace_back();
- bind.binding = x.InputSlot;
- bind.inputRate = x.InputSlotClass == INPUT_PER_VERTEX_DATA ? VK_VERTEX_INPUT_RATE_VERTEX : VK_VERTEX_INPUT_RATE_INSTANCE;
- bind.stride = vb_strides[cmd][x.InputSlot];
+ bind.binding = x.input_slot;
+ bind.inputRate = x.input_slot_class == InputClassification::PER_VERTEX_DATA ? VK_VERTEX_INPUT_RATE_VERTEX : VK_VERTEX_INPUT_RATE_INSTANCE;
+ bind.stride = vb_strides[cmd][x.input_slot];
}
uint32_t offset = 0;
@@ -2140,20 +2140,20 @@ using namespace Vulkan_Internal;
for (auto& x : pso->desc.il->elements)
{
VkVertexInputAttributeDescription attr = {};
- attr.binding = x.InputSlot;
+ attr.binding = x.input_slot;
if (attr.binding != lastBinding)
{
lastBinding = attr.binding;
offset = 0;
}
- attr.format = _ConvertFormat(x.Format);
+ attr.format = _ConvertFormat(x.format);
attr.location = i;
- attr.offset = x.AlignedByteOffset;
+ attr.offset = x.aligned_byte_offset;
if (attr.offset == InputLayout::APPEND_ALIGNED_ELEMENT)
{
// need to manually resolve this from the format spec.
attr.offset = offset;
- offset += GetFormatStride(x.Format);
+ offset += GetFormatStride(x.format);
}
attributes.push_back(attr);
@@ -2511,15 +2511,15 @@ using namespace Vulkan_Internal;
if (features2.features.tessellationShader == VK_TRUE)
{
- capabilities |= GRAPHICSDEVICE_CAPABILITY_TESSELLATION;
+ capabilities |= GraphicsDeviceCapability::TESSELLATION;
}
if (features2.features.shaderStorageImageExtendedFormats == VK_TRUE)
{
- capabilities |= GRAPHICSDEVICE_CAPABILITY_UAV_LOAD_FORMAT_COMMON;
+ capabilities |= GraphicsDeviceCapability::UAV_LOAD_FORMAT_COMMON;
}
if (features_1_2.shaderOutputLayer == VK_TRUE && features_1_2.shaderOutputViewportIndex)
{
- capabilities |= GRAPHICSDEVICE_CAPABILITY_RENDERTARGET_AND_VIEWPORT_ARRAYINDEX_WITHOUT_GS;
+ capabilities |= GraphicsDeviceCapability::RENDERTARGET_AND_VIEWPORT_ARRAYINDEX_WITHOUT_GS;
}
if (
@@ -2528,38 +2528,38 @@ using namespace Vulkan_Internal;
acceleration_structure_features.accelerationStructure == VK_TRUE &&
features_1_2.bufferDeviceAddress == VK_TRUE)
{
- capabilities |= GRAPHICSDEVICE_CAPABILITY_RAYTRACING;
+ capabilities |= GraphicsDeviceCapability::RAYTRACING;
SHADER_IDENTIFIER_SIZE = raytracing_properties.shaderGroupHandleSize;
}
if (mesh_shader_features.meshShader == VK_TRUE && mesh_shader_features.taskShader == VK_TRUE)
{
- capabilities |= GRAPHICSDEVICE_CAPABILITY_MESH_SHADER;
+ capabilities |= GraphicsDeviceCapability::MESH_SHADER;
}
if (fragment_shading_rate_features.pipelineFragmentShadingRate == VK_TRUE)
{
- capabilities |= GRAPHICSDEVICE_CAPABILITY_VARIABLE_RATE_SHADING;
+ capabilities |= GraphicsDeviceCapability::VARIABLE_RATE_SHADING;
}
if (fragment_shading_rate_features.attachmentFragmentShadingRate == VK_TRUE)
{
- capabilities |= GRAPHICSDEVICE_CAPABILITY_VARIABLE_RATE_SHADING_TIER2;
+ capabilities |= GraphicsDeviceCapability::VARIABLE_RATE_SHADING_TIER2;
VARIABLE_RATE_SHADING_TILE_SIZE = std::min(fragment_shading_rate_properties.maxFragmentShadingRateAttachmentTexelSize.width, fragment_shading_rate_properties.maxFragmentShadingRateAttachmentTexelSize.height);
}
VkFormatProperties formatProperties = {};
- vkGetPhysicalDeviceFormatProperties(physicalDevice, _ConvertFormat(FORMAT_R11G11B10_FLOAT), &formatProperties);
+ vkGetPhysicalDeviceFormatProperties(physicalDevice, _ConvertFormat(Format::R11G11B10_FLOAT), &formatProperties);
if (formatProperties.optimalTilingFeatures & VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT)
{
- capabilities |= GRAPHICSDEVICE_CAPABILITY_UAV_LOAD_FORMAT_R11G11B10_FLOAT;
+ capabilities |= GraphicsDeviceCapability::UAV_LOAD_FORMAT_R11G11B10_FLOAT;
}
if (conditional_rendering_features.conditionalRendering == VK_TRUE)
{
- capabilities |= GRAPHICSDEVICE_CAPABILITY_PREDICATION;
+ capabilities |= GraphicsDeviceCapability::PREDICATION;
}
if (features_1_2.samplerFilterMinmax == VK_TRUE)
{
- capabilities |= GRAPHICSDEVICE_CAPABILITY_SAMPLER_MINMAX;
+ capabilities |= GraphicsDeviceCapability::SAMPLER_MINMAX;
}
// Find queue families:
@@ -2900,7 +2900,7 @@ using namespace Vulkan_Internal;
pso_dynamicStates.push_back(VK_DYNAMIC_STATE_SCISSOR);
pso_dynamicStates.push_back(VK_DYNAMIC_STATE_STENCIL_REFERENCE);
pso_dynamicStates.push_back(VK_DYNAMIC_STATE_BLEND_CONSTANTS);
- if (CheckCapability(GRAPHICSDEVICE_CAPABILITY_VARIABLE_RATE_SHADING))
+ if (CheckCapability(GraphicsDeviceCapability::VARIABLE_RATE_SHADING))
{
pso_dynamicStates.push_back(VK_DYNAMIC_STATE_FRAGMENT_SHADING_RATE_KHR);
}
@@ -2934,7 +2934,7 @@ using namespace Vulkan_Internal;
allocationhandler->bindlessSamplers.init(device, VK_DESCRIPTOR_TYPE_SAMPLER, 256);
}
- if (CheckCapability(GRAPHICSDEVICE_CAPABILITY_RAYTRACING))
+ if (CheckCapability(GraphicsDeviceCapability::RAYTRACING))
{
allocationhandler->bindlessAccelerationStructures.init(device, VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR, 32);
}
@@ -3172,7 +3172,7 @@ using namespace Vulkan_Internal;
auto internal_state = std::make_shared();
internal_state->allocationhandler = allocationhandler;
pBuffer->internal_state = internal_state;
- pBuffer->type = GPUResource::GPU_RESOURCE_TYPE::BUFFER;
+ pBuffer->type = GPUResource::Type::BUFFER;
pBuffer->mapped_data = nullptr;
pBuffer->mapped_rowpitch = 0;
@@ -3180,23 +3180,23 @@ using namespace Vulkan_Internal;
VkBufferCreateInfo bufferInfo = {};
bufferInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
- bufferInfo.size = pBuffer->desc.Size;
+ bufferInfo.size = pBuffer->desc.size;
bufferInfo.usage = 0;
- if (pBuffer->desc.BindFlags & BIND_VERTEX_BUFFER)
+ if (has_flag(pBuffer->desc.bind_flags, BindFlag::VERTEX_BUFFER))
{
bufferInfo.usage |= VK_BUFFER_USAGE_VERTEX_BUFFER_BIT;
}
- if (pBuffer->desc.BindFlags & BIND_INDEX_BUFFER)
+ if (has_flag(pBuffer->desc.bind_flags, BindFlag::INDEX_BUFFER))
{
bufferInfo.usage |= VK_BUFFER_USAGE_INDEX_BUFFER_BIT;
}
- if (pBuffer->desc.BindFlags & BIND_CONSTANT_BUFFER)
+ if (has_flag(pBuffer->desc.bind_flags, BindFlag::CONSTANT_BUFFER))
{
bufferInfo.usage |= VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT;
}
- if (pBuffer->desc.BindFlags & BIND_SHADER_RESOURCE)
+ if (has_flag(pBuffer->desc.bind_flags, BindFlag::SHADER_RESOURCE))
{
- if (pBuffer->desc.Format == FORMAT_UNKNOWN)
+ if (pBuffer->desc.format == Format::UNKNOWN)
{
bufferInfo.usage |= VK_BUFFER_USAGE_STORAGE_BUFFER_BIT;
}
@@ -3205,9 +3205,9 @@ using namespace Vulkan_Internal;
bufferInfo.usage |= VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT;
}
}
- if (pBuffer->desc.BindFlags & BIND_UNORDERED_ACCESS)
+ if (has_flag(pBuffer->desc.bind_flags, BindFlag::UNORDERED_ACCESS))
{
- if (pBuffer->desc.Format == FORMAT_UNKNOWN)
+ if (pBuffer->desc.format == Format::UNKNOWN)
{
bufferInfo.usage |= VK_BUFFER_USAGE_STORAGE_BUFFER_BIT;
}
@@ -3216,24 +3216,24 @@ using namespace Vulkan_Internal;
bufferInfo.usage |= VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT;
}
}
- if (pBuffer->desc.MiscFlags & RESOURCE_MISC_BUFFER_RAW)
+ if (has_flag(pBuffer->desc.misc_flags, ResourceMiscFlag::BUFFER_RAW))
{
bufferInfo.usage |= VK_BUFFER_USAGE_STORAGE_BUFFER_BIT;
}
- if (pBuffer->desc.MiscFlags & RESOURCE_MISC_BUFFER_STRUCTURED)
+ if (has_flag(pBuffer->desc.misc_flags, ResourceMiscFlag::BUFFER_STRUCTURED))
{
bufferInfo.usage |= VK_BUFFER_USAGE_STORAGE_BUFFER_BIT;
}
- if (pBuffer->desc.MiscFlags & RESOURCE_MISC_INDIRECT_ARGS)
+ if (has_flag(pBuffer->desc.misc_flags, ResourceMiscFlag::INDIRECT_ARGS))
{
bufferInfo.usage |= VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT;
}
- if (pBuffer->desc.MiscFlags & RESOURCE_MISC_RAY_TRACING)
+ if (has_flag(pBuffer->desc.misc_flags, ResourceMiscFlag::RAY_TRACING))
{
bufferInfo.usage |= VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR;
bufferInfo.usage |= VK_BUFFER_USAGE_SHADER_BINDING_TABLE_BIT_KHR;
}
- if (pBuffer->desc.MiscFlags & RESOURCE_MISC_PREDICATION)
+ if (has_flag(pBuffer->desc.misc_flags, ResourceMiscFlag::PREDICATION))
{
bufferInfo.usage |= VK_BUFFER_USAGE_CONDITIONAL_RENDERING_BIT_EXT;
}
@@ -3261,13 +3261,13 @@ 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_READBACK)
+ if (pDesc->usage == Usage::READBACK)
{
allocInfo.flags = VMA_ALLOCATION_CREATE_MAPPED_BIT;
allocInfo.usage = VMA_MEMORY_USAGE_GPU_TO_CPU;
bufferInfo.usage |= VK_BUFFER_USAGE_TRANSFER_DST_BIT;
}
- else if(pDesc->Usage == USAGE_UPLOAD)
+ else if(pDesc->usage == Usage::UPLOAD)
{
allocInfo.flags = VMA_ALLOCATION_CREATE_MAPPED_BIT;
allocInfo.usage = VMA_MEMORY_USAGE_CPU_ONLY; // yes, not using VMA_MEMORY_USAGE_CPU_TO_GPU, as it had worse performance for CPU write
@@ -3277,10 +3277,10 @@ using namespace Vulkan_Internal;
VkResult 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)
+ if (pDesc->usage == Usage::READBACK || pDesc->usage == Usage::UPLOAD)
{
pBuffer->mapped_data = internal_state->allocation->GetMappedData();
- pBuffer->mapped_rowpitch = static_cast(pDesc->Size);
+ pBuffer->mapped_rowpitch = static_cast(pDesc->size);
}
if (bufferInfo.usage & VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT)
@@ -3294,9 +3294,9 @@ using namespace Vulkan_Internal;
// Issue data copy on request:
if (pInitialData != nullptr)
{
- auto cmd = copyAllocator.allocate(pDesc->Size);
+ auto cmd = copyAllocator.allocate(pDesc->size);
- memcpy(cmd.uploadbuffer.mapped_data, pInitialData, pBuffer->desc.Size);
+ memcpy(cmd.uploadbuffer.mapped_data, pInitialData, pBuffer->desc.size);
VkBufferMemoryBarrier barrier = {};
barrier.sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER;
@@ -3319,7 +3319,7 @@ using namespace Vulkan_Internal;
);
VkBufferCopy copyRegion = {};
- copyRegion.size = pBuffer->desc.Size;
+ copyRegion.size = pBuffer->desc.size;
copyRegion.srcOffset = 0;
copyRegion.dstOffset = 0;
@@ -3333,31 +3333,31 @@ using namespace Vulkan_Internal;
std::swap(barrier.srcAccessMask, barrier.dstAccessMask);
- if (pBuffer->desc.BindFlags & BIND_CONSTANT_BUFFER)
+ if (has_flag(pBuffer->desc.bind_flags, BindFlag::CONSTANT_BUFFER))
{
barrier.dstAccessMask |= VK_ACCESS_UNIFORM_READ_BIT;
}
- if (pBuffer->desc.BindFlags & BIND_VERTEX_BUFFER)
+ if (has_flag(pBuffer->desc.bind_flags, BindFlag::VERTEX_BUFFER))
{
barrier.dstAccessMask |= VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT;
}
- if (pBuffer->desc.BindFlags & BIND_INDEX_BUFFER)
+ if (has_flag(pBuffer->desc.bind_flags, BindFlag::INDEX_BUFFER))
{
barrier.dstAccessMask |= VK_ACCESS_INDEX_READ_BIT;
}
- if(pBuffer->desc.BindFlags & BIND_SHADER_RESOURCE)
+ if (has_flag(pBuffer->desc.bind_flags, BindFlag::SHADER_RESOURCE))
{
barrier.dstAccessMask |= VK_ACCESS_SHADER_READ_BIT;
}
- if (pBuffer->desc.BindFlags & BIND_UNORDERED_ACCESS)
+ if (has_flag(pBuffer->desc.bind_flags, BindFlag::UNORDERED_ACCESS))
{
barrier.dstAccessMask |= VK_ACCESS_SHADER_WRITE_BIT;
}
- if (pBuffer->desc.MiscFlags & RESOURCE_MISC_INDIRECT_ARGS)
+ if (has_flag(pBuffer->desc.misc_flags, ResourceMiscFlag::INDIRECT_ARGS))
{
barrier.dstAccessMask |= VK_ACCESS_INDIRECT_COMMAND_READ_BIT;
}
- if (pBuffer->desc.MiscFlags & RESOURCE_MISC_RAY_TRACING)
+ if (has_flag(pBuffer->desc.misc_flags, ResourceMiscFlag::RAY_TRACING))
{
barrier.dstAccessMask |= VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_KHR;
}
@@ -3375,7 +3375,7 @@ using namespace Vulkan_Internal;
copyAllocator.submit(cmd);
}
- if (pDesc->Format == FORMAT_UNKNOWN)
+ if (pDesc->format == Format::UNKNOWN)
{
internal_state->is_typedbuffer = false;
}
@@ -3386,13 +3386,13 @@ using namespace Vulkan_Internal;
// Create resource views if needed
- if (pDesc->BindFlags & BIND_SHADER_RESOURCE)
+ if (has_flag(pDesc->bind_flags, BindFlag::SHADER_RESOURCE))
{
- CreateSubresource(pBuffer, SRV, 0);
+ CreateSubresource(pBuffer, SubresourceType::SRV, 0);
}
- if (pDesc->BindFlags & BIND_UNORDERED_ACCESS)
+ if (has_flag(pDesc->bind_flags, BindFlag::UNORDERED_ACCESS))
{
- CreateSubresource(pBuffer, UAV, 0);
+ CreateSubresource(pBuffer, SubresourceType::UAV, 0);
}
return res == VK_SUCCESS;
@@ -3402,15 +3402,15 @@ using namespace Vulkan_Internal;
auto internal_state = std::make_shared();
internal_state->allocationhandler = allocationhandler;
pTexture->internal_state = internal_state;
- pTexture->type = GPUResource::GPU_RESOURCE_TYPE::TEXTURE;
+ pTexture->type = GPUResource::Type::TEXTURE;
pTexture->mapped_data = nullptr;
pTexture->mapped_rowpitch = 0;
pTexture->desc = *pDesc;
- if (pTexture->desc.MipLevels == 0)
+ if (pTexture->desc.mip_levels == 0)
{
- pTexture->desc.MipLevels = (uint32_t)log2(std::max(pTexture->desc.Width, pTexture->desc.Height)) + 1;
+ pTexture->desc.mip_levels = (uint32_t)log2(std::max(pTexture->desc.width, pTexture->desc.height)) + 1;
}
VmaAllocationCreateInfo allocInfo = {};
@@ -3420,35 +3420,35 @@ using namespace Vulkan_Internal;
VkImageCreateInfo imageInfo = {};
imageInfo.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
- imageInfo.extent.width = pTexture->desc.Width;
- imageInfo.extent.height = pTexture->desc.Height;
+ imageInfo.extent.width = pTexture->desc.width;
+ imageInfo.extent.height = pTexture->desc.height;
imageInfo.extent.depth = 1;
- imageInfo.format = _ConvertFormat(pTexture->desc.Format);
- imageInfo.arrayLayers = pTexture->desc.ArraySize;
- imageInfo.mipLevels = pTexture->desc.MipLevels;
- imageInfo.samples = (VkSampleCountFlagBits)pTexture->desc.SampleCount;
+ imageInfo.format = _ConvertFormat(pTexture->desc.format);
+ imageInfo.arrayLayers = pTexture->desc.array_size;
+ imageInfo.mipLevels = pTexture->desc.mip_levels;
+ imageInfo.samples = (VkSampleCountFlagBits)pTexture->desc.sample_count;
imageInfo.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
imageInfo.tiling = VK_IMAGE_TILING_OPTIMAL;
imageInfo.usage = 0;
- if (pTexture->desc.BindFlags & BIND_SHADER_RESOURCE)
+ if (has_flag(pTexture->desc.bind_flags, BindFlag::SHADER_RESOURCE))
{
imageInfo.usage |= VK_IMAGE_USAGE_SAMPLED_BIT;
}
- if (pTexture->desc.BindFlags & BIND_UNORDERED_ACCESS)
+ if (has_flag(pTexture->desc.bind_flags, BindFlag::UNORDERED_ACCESS))
{
imageInfo.usage |= VK_IMAGE_USAGE_STORAGE_BIT;
}
- if (pTexture->desc.BindFlags & BIND_RENDER_TARGET)
+ if (has_flag(pTexture->desc.bind_flags, BindFlag::RENDER_TARGET))
{
imageInfo.usage |= VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
//allocInfo.flags |= VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT;
}
- if (pTexture->desc.BindFlags & BIND_DEPTH_STENCIL)
+ if (has_flag(pTexture->desc.bind_flags, BindFlag::DEPTH_STENCIL))
{
imageInfo.usage |= VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
//allocInfo.flags |= VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT;
}
- if(pTexture->desc.BindFlags & BIND_SHADING_RATE)
+ if (has_flag(pTexture->desc.bind_flags, BindFlag::SHADING_RATE))
{
imageInfo.usage |= VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR;
}
@@ -3456,7 +3456,7 @@ using namespace Vulkan_Internal;
imageInfo.usage |= VK_IMAGE_USAGE_TRANSFER_DST_BIT;
imageInfo.flags = 0;
- if (pTexture->desc.MiscFlags & RESOURCE_MISC_TEXTURECUBE)
+ if (has_flag(pTexture->desc.misc_flags, ResourceMiscFlag::TEXTURECUBE))
{
imageInfo.flags |= VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT;
}
@@ -3474,15 +3474,15 @@ using namespace Vulkan_Internal;
switch (pTexture->desc.type)
{
- case TextureDesc::TEXTURE_1D:
+ case TextureDesc::Type::TEXTURE_1D:
imageInfo.imageType = VK_IMAGE_TYPE_1D;
break;
- case TextureDesc::TEXTURE_2D:
+ case TextureDesc::Type::TEXTURE_2D:
imageInfo.imageType = VK_IMAGE_TYPE_2D;
break;
- case TextureDesc::TEXTURE_3D:
+ case TextureDesc::Type::TEXTURE_3D:
imageInfo.imageType = VK_IMAGE_TYPE_3D;
- imageInfo.extent.depth = pTexture->desc.Depth;
+ imageInfo.extent.depth = pTexture->desc.depth;
break;
default:
assert(0);
@@ -3491,20 +3491,20 @@ using namespace Vulkan_Internal;
VkResult res;
- if (pTexture->desc.Usage == USAGE_READBACK || pTexture->desc.Usage == USAGE_UPLOAD)
+ 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);
+ GetFormatStride(pTexture->desc.format);
allocInfo.flags = VMA_ALLOCATION_CREATE_MAPPED_BIT;
- if (pTexture->desc.Usage == USAGE_READBACK)
+ if (pTexture->desc.usage == Usage::READBACK)
{
allocInfo.usage = VMA_MEMORY_USAGE_GPU_TO_CPU;
bufferInfo.usage = VK_BUFFER_USAGE_TRANSFER_DST_BIT;
}
- else if(pTexture->desc.Usage == USAGE_UPLOAD)
+ else if(pTexture->desc.usage == Usage::UPLOAD)
{
allocInfo.usage = VMA_MEMORY_USAGE_CPU_ONLY; // yes, not using VMA_MEMORY_USAGE_CPU_TO_GPU, as it had worse performance for CPU write
bufferInfo.usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT;
@@ -3522,7 +3522,7 @@ 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)
+ 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;
@@ -3546,17 +3546,17 @@ using namespace Vulkan_Internal;
VkDeviceSize copyOffset = 0;
uint32_t initDataIdx = 0;
- for (uint32_t layer = 0; layer < pDesc->ArraySize; ++layer)
+ for (uint32_t layer = 0; layer < pDesc->array_size; ++layer)
{
uint32_t width = imageInfo.extent.width;
uint32_t height = imageInfo.extent.height;
uint32_t depth = imageInfo.extent.depth;
- for (uint32_t mip = 0; mip < pDesc->MipLevels; ++mip)
+ for (uint32_t mip = 0; mip < pDesc->mip_levels; ++mip)
{
const SubresourceData& subresourceData = pInitialData[initDataIdx++];
- VkDeviceSize copySize = subresourceData.rowPitch * height * depth / GetFormatBlockSize(pDesc->Format);
+ VkDeviceSize copySize = subresourceData.row_pitch * height * depth / GetFormatBlockSize(pDesc->format);
uint8_t* cpyaddr = (uint8_t*)cmd.uploadbuffer.mapped_data + copyOffset;
- memcpy(cpyaddr, subresourceData.pData, copySize);
+ memcpy(cpyaddr, subresourceData.data_ptr, copySize);
VkBufferImageCopy copyRegion = {};
copyRegion.bufferOffset = copyOffset;
@@ -3581,7 +3581,7 @@ using namespace Vulkan_Internal;
copyRegions.push_back(copyRegion);
- copyOffset += AlignTo(copySize, (VkDeviceSize)GetFormatStride(pDesc->Format));
+ copyOffset += AlignTo(copySize, (VkDeviceSize)GetFormatStride(pDesc->format));
}
}
@@ -3643,10 +3643,10 @@ using namespace Vulkan_Internal;
barrier.newLayout = _ConvertImageLayout(pTexture->desc.layout);
barrier.srcAccessMask = 0;
barrier.dstAccessMask = _ParseResourceState(pTexture->desc.layout);
- if (pTexture->desc.BindFlags & BIND_DEPTH_STENCIL)
+ if (has_flag(pTexture->desc.bind_flags, BindFlag::DEPTH_STENCIL))
{
barrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
- if (IsFormatStencilSupport(pTexture->desc.Format))
+ if (IsFormatStencilSupport(pTexture->desc.format))
{
barrier.subresourceRange.aspectMask |= VK_IMAGE_ASPECT_STENCIL_BIT;
}
@@ -3676,26 +3676,26 @@ using namespace Vulkan_Internal;
initLocker.unlock();
}
- if (pTexture->desc.BindFlags & BIND_RENDER_TARGET)
+ if (has_flag(pTexture->desc.bind_flags, BindFlag::RENDER_TARGET))
{
- CreateSubresource(pTexture, RTV, 0, -1, 0, -1);
+ CreateSubresource(pTexture, SubresourceType::RTV, 0, -1, 0, -1);
}
- if (pTexture->desc.BindFlags & BIND_DEPTH_STENCIL)
+ if (has_flag(pTexture->desc.bind_flags, BindFlag::DEPTH_STENCIL))
{
- CreateSubresource(pTexture, DSV, 0, -1, 0, -1);
+ CreateSubresource(pTexture, SubresourceType::DSV, 0, -1, 0, -1);
}
- if (pTexture->desc.BindFlags & BIND_SHADER_RESOURCE)
+ if (has_flag(pTexture->desc.bind_flags, BindFlag::SHADER_RESOURCE))
{
- CreateSubresource(pTexture, SRV, 0, -1, 0, -1);
+ CreateSubresource(pTexture, SubresourceType::SRV, 0, -1, 0, -1);
}
- if (pTexture->desc.BindFlags & BIND_UNORDERED_ACCESS)
+ if (has_flag(pTexture->desc.bind_flags, BindFlag::UNORDERED_ACCESS))
{
- CreateSubresource(pTexture, UAV, 0, -1, 0, -1);
+ CreateSubresource(pTexture, SubresourceType::UAV, 0, -1, 0, -1);
}
return res == VK_SUCCESS;
}
- bool GraphicsDevice_Vulkan::CreateShader(SHADERSTAGE stage, const void *pShaderBytecode, size_t BytecodeLength, Shader *pShader) const
+ bool GraphicsDevice_Vulkan::CreateShader(ShaderStage stage, const void *pShaderBytecode, size_t BytecodeLength, Shader *pShader) const
{
auto internal_state = std::make_shared();
internal_state->allocationhandler = allocationhandler;
@@ -3717,28 +3717,28 @@ using namespace Vulkan_Internal;
internal_state->stageInfo.pName = "main";
switch (stage)
{
- case wiGraphics::MS:
+ case ShaderStage::MS:
internal_state->stageInfo.stage = VK_SHADER_STAGE_MESH_BIT_NV;
break;
- case wiGraphics::AS:
+ case ShaderStage::AS:
internal_state->stageInfo.stage = VK_SHADER_STAGE_TASK_BIT_NV;
break;
- case wiGraphics::VS:
+ case ShaderStage::VS:
internal_state->stageInfo.stage = VK_SHADER_STAGE_VERTEX_BIT;
break;
- case wiGraphics::HS:
+ case ShaderStage::HS:
internal_state->stageInfo.stage = VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT;
break;
- case wiGraphics::DS:
+ case ShaderStage::DS:
internal_state->stageInfo.stage = VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT;
break;
- case wiGraphics::GS:
+ case ShaderStage::GS:
internal_state->stageInfo.stage = VK_SHADER_STAGE_GEOMETRY_BIT;
break;
- case wiGraphics::PS:
+ case ShaderStage::PS:
internal_state->stageInfo.stage = VK_SHADER_STAGE_FRAGMENT_BIT;
break;
- case wiGraphics::CS:
+ case ShaderStage::CS:
internal_state->stageInfo.stage = VK_SHADER_STAGE_COMPUTE_BIT;
break;
default:
@@ -3885,7 +3885,7 @@ using namespace Vulkan_Internal;
spvReflectDestroyShaderModule(&module);
- if (stage == CS || stage == LIB)
+ if (stage == ShaderStage::CS || stage == ShaderStage::LIB)
{
internal_state->binding_hash = 0;
size_t i = 0;
@@ -4000,7 +4000,7 @@ using namespace Vulkan_Internal;
}
}
- if (stage == CS)
+ if (stage == ShaderStage::CS)
{
VkComputePipelineCreateInfo pipelineInfo = {};
pipelineInfo.sType = VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO;
@@ -4031,146 +4031,146 @@ using namespace Vulkan_Internal;
createInfo.pNext = nullptr;
- switch (pSamplerDesc->Filter)
+ switch (pSamplerDesc->filter)
{
- case FILTER_MIN_MAG_MIP_POINT:
- case FILTER_MINIMUM_MIN_MAG_MIP_POINT:
- case FILTER_MAXIMUM_MIN_MAG_MIP_POINT:
+ case Filter::MIN_MAG_MIP_POINT:
+ case Filter::MINIMUM_MIN_MAG_MIP_POINT:
+ case Filter::MAXIMUM_MIN_MAG_MIP_POINT:
createInfo.minFilter = VK_FILTER_NEAREST;
createInfo.magFilter = VK_FILTER_NEAREST;
createInfo.mipmapMode = VK_SAMPLER_MIPMAP_MODE_NEAREST;
createInfo.anisotropyEnable = false;
createInfo.compareEnable = false;
break;
- case FILTER_MIN_MAG_POINT_MIP_LINEAR:
- case FILTER_MINIMUM_MIN_MAG_POINT_MIP_LINEAR:
- case FILTER_MAXIMUM_MIN_MAG_POINT_MIP_LINEAR:
+ case Filter::MIN_MAG_POINT_MIP_LINEAR:
+ case Filter::MINIMUM_MIN_MAG_POINT_MIP_LINEAR:
+ case Filter::MAXIMUM_MIN_MAG_POINT_MIP_LINEAR:
createInfo.minFilter = VK_FILTER_NEAREST;
createInfo.magFilter = VK_FILTER_NEAREST;
createInfo.mipmapMode = VK_SAMPLER_MIPMAP_MODE_LINEAR;
createInfo.anisotropyEnable = false;
createInfo.compareEnable = false;
break;
- case FILTER_MIN_POINT_MAG_LINEAR_MIP_POINT:
- case FILTER_MINIMUM_MIN_POINT_MAG_LINEAR_MIP_POINT:
- case FILTER_MAXIMUM_MIN_POINT_MAG_LINEAR_MIP_POINT:
+ case Filter::MIN_POINT_MAG_LINEAR_MIP_POINT:
+ case Filter::MINIMUM_MIN_POINT_MAG_LINEAR_MIP_POINT:
+ case Filter::MAXIMUM_MIN_POINT_MAG_LINEAR_MIP_POINT:
createInfo.minFilter = VK_FILTER_NEAREST;
createInfo.magFilter = VK_FILTER_LINEAR;
createInfo.mipmapMode = VK_SAMPLER_MIPMAP_MODE_NEAREST;
createInfo.anisotropyEnable = false;
createInfo.compareEnable = false;
break;
- case FILTER_MIN_POINT_MAG_MIP_LINEAR:
- case FILTER_MINIMUM_MIN_POINT_MAG_MIP_LINEAR:
- case FILTER_MAXIMUM_MIN_POINT_MAG_MIP_LINEAR:
+ case Filter::MIN_POINT_MAG_MIP_LINEAR:
+ case Filter::MINIMUM_MIN_POINT_MAG_MIP_LINEAR:
+ case Filter::MAXIMUM_MIN_POINT_MAG_MIP_LINEAR:
createInfo.minFilter = VK_FILTER_NEAREST;
createInfo.magFilter = VK_FILTER_LINEAR;
createInfo.mipmapMode = VK_SAMPLER_MIPMAP_MODE_LINEAR;
createInfo.anisotropyEnable = false;
createInfo.compareEnable = false;
break;
- case FILTER_MIN_LINEAR_MAG_MIP_POINT:
- case FILTER_MINIMUM_MIN_LINEAR_MAG_MIP_POINT:
- case FILTER_MAXIMUM_MIN_LINEAR_MAG_MIP_POINT:
+ case Filter::MIN_LINEAR_MAG_MIP_POINT:
+ case Filter::MINIMUM_MIN_LINEAR_MAG_MIP_POINT:
+ case Filter::MAXIMUM_MIN_LINEAR_MAG_MIP_POINT:
createInfo.minFilter = VK_FILTER_LINEAR;
createInfo.magFilter = VK_FILTER_NEAREST;
createInfo.mipmapMode = VK_SAMPLER_MIPMAP_MODE_NEAREST;
createInfo.anisotropyEnable = false;
createInfo.compareEnable = false;
break;
- case FILTER_MIN_LINEAR_MAG_POINT_MIP_LINEAR:
- case FILTER_MINIMUM_MIN_LINEAR_MAG_POINT_MIP_LINEAR:
- case FILTER_MAXIMUM_MIN_LINEAR_MAG_POINT_MIP_LINEAR:
+ case Filter::MIN_LINEAR_MAG_POINT_MIP_LINEAR:
+ case Filter::MINIMUM_MIN_LINEAR_MAG_POINT_MIP_LINEAR:
+ case Filter::MAXIMUM_MIN_LINEAR_MAG_POINT_MIP_LINEAR:
createInfo.minFilter = VK_FILTER_LINEAR;
createInfo.magFilter = VK_FILTER_NEAREST;
createInfo.mipmapMode = VK_SAMPLER_MIPMAP_MODE_LINEAR;
createInfo.anisotropyEnable = false;
createInfo.compareEnable = false;
break;
- case FILTER_MIN_MAG_LINEAR_MIP_POINT:
- case FILTER_MINIMUM_MIN_MAG_LINEAR_MIP_POINT:
- case FILTER_MAXIMUM_MIN_MAG_LINEAR_MIP_POINT:
+ case Filter::MIN_MAG_LINEAR_MIP_POINT:
+ case Filter::MINIMUM_MIN_MAG_LINEAR_MIP_POINT:
+ case Filter::MAXIMUM_MIN_MAG_LINEAR_MIP_POINT:
createInfo.minFilter = VK_FILTER_LINEAR;
createInfo.magFilter = VK_FILTER_LINEAR;
createInfo.mipmapMode = VK_SAMPLER_MIPMAP_MODE_NEAREST;
createInfo.anisotropyEnable = false;
createInfo.compareEnable = false;
break;
- case FILTER_MIN_MAG_MIP_LINEAR:
- case FILTER_MINIMUM_MIN_MAG_MIP_LINEAR:
- case FILTER_MAXIMUM_MIN_MAG_MIP_LINEAR:
+ case Filter::MIN_MAG_MIP_LINEAR:
+ case Filter::MINIMUM_MIN_MAG_MIP_LINEAR:
+ case Filter::MAXIMUM_MIN_MAG_MIP_LINEAR:
createInfo.minFilter = VK_FILTER_LINEAR;
createInfo.magFilter = VK_FILTER_LINEAR;
createInfo.mipmapMode = VK_SAMPLER_MIPMAP_MODE_LINEAR;
createInfo.anisotropyEnable = false;
createInfo.compareEnable = false;
break;
- case FILTER_ANISOTROPIC:
- case FILTER_MINIMUM_ANISOTROPIC:
- case FILTER_MAXIMUM_ANISOTROPIC:
+ case Filter::ANISOTROPIC:
+ case Filter::MINIMUM_ANISOTROPIC:
+ case Filter::MAXIMUM_ANISOTROPIC:
createInfo.minFilter = VK_FILTER_LINEAR;
createInfo.magFilter = VK_FILTER_LINEAR;
createInfo.mipmapMode = VK_SAMPLER_MIPMAP_MODE_LINEAR;
createInfo.anisotropyEnable = true;
createInfo.compareEnable = false;
break;
- case FILTER_COMPARISON_MIN_MAG_MIP_POINT:
+ case Filter::COMPARISON_MIN_MAG_MIP_POINT:
createInfo.minFilter = VK_FILTER_NEAREST;
createInfo.magFilter = VK_FILTER_NEAREST;
createInfo.mipmapMode = VK_SAMPLER_MIPMAP_MODE_NEAREST;
createInfo.anisotropyEnable = false;
createInfo.compareEnable = true;
break;
- case FILTER_COMPARISON_MIN_MAG_POINT_MIP_LINEAR:
+ case Filter::COMPARISON_MIN_MAG_POINT_MIP_LINEAR:
createInfo.minFilter = VK_FILTER_NEAREST;
createInfo.magFilter = VK_FILTER_NEAREST;
createInfo.mipmapMode = VK_SAMPLER_MIPMAP_MODE_LINEAR;
createInfo.anisotropyEnable = false;
createInfo.compareEnable = true;
break;
- case FILTER_COMPARISON_MIN_POINT_MAG_LINEAR_MIP_POINT:
+ case Filter::COMPARISON_MIN_POINT_MAG_LINEAR_MIP_POINT:
createInfo.minFilter = VK_FILTER_NEAREST;
createInfo.magFilter = VK_FILTER_LINEAR;
createInfo.mipmapMode = VK_SAMPLER_MIPMAP_MODE_NEAREST;
createInfo.anisotropyEnable = false;
createInfo.compareEnable = true;
break;
- case FILTER_COMPARISON_MIN_POINT_MAG_MIP_LINEAR:
+ case Filter::COMPARISON_MIN_POINT_MAG_MIP_LINEAR:
createInfo.minFilter = VK_FILTER_NEAREST;
createInfo.magFilter = VK_FILTER_NEAREST;
createInfo.mipmapMode = VK_SAMPLER_MIPMAP_MODE_NEAREST;
createInfo.anisotropyEnable = false;
createInfo.compareEnable = true;
break;
- case FILTER_COMPARISON_MIN_LINEAR_MAG_MIP_POINT:
+ case Filter::COMPARISON_MIN_LINEAR_MAG_MIP_POINT:
createInfo.minFilter = VK_FILTER_LINEAR;
createInfo.magFilter = VK_FILTER_NEAREST;
createInfo.mipmapMode = VK_SAMPLER_MIPMAP_MODE_NEAREST;
createInfo.anisotropyEnable = false;
createInfo.compareEnable = true;
break;
- case FILTER_COMPARISON_MIN_LINEAR_MAG_POINT_MIP_LINEAR:
+ case Filter::COMPARISON_MIN_LINEAR_MAG_POINT_MIP_LINEAR:
createInfo.minFilter = VK_FILTER_LINEAR;
createInfo.magFilter = VK_FILTER_NEAREST;
createInfo.mipmapMode = VK_SAMPLER_MIPMAP_MODE_LINEAR;
createInfo.anisotropyEnable = false;
createInfo.compareEnable = true;
break;
- case FILTER_COMPARISON_MIN_MAG_LINEAR_MIP_POINT:
+ case Filter::COMPARISON_MIN_MAG_LINEAR_MIP_POINT:
createInfo.minFilter = VK_FILTER_LINEAR;
createInfo.magFilter = VK_FILTER_LINEAR;
createInfo.mipmapMode = VK_SAMPLER_MIPMAP_MODE_NEAREST;
createInfo.anisotropyEnable = false;
createInfo.compareEnable = true;
break;
- case FILTER_COMPARISON_MIN_MAG_MIP_LINEAR:
+ case Filter::COMPARISON_MIN_MAG_MIP_LINEAR:
createInfo.minFilter = VK_FILTER_LINEAR;
createInfo.magFilter = VK_FILTER_LINEAR;
createInfo.mipmapMode = VK_SAMPLER_MIPMAP_MODE_LINEAR;
createInfo.anisotropyEnable = false;
createInfo.compareEnable = true;
break;
- case FILTER_COMPARISON_ANISOTROPIC:
+ case Filter::COMPARISON_ANISOTROPIC:
createInfo.minFilter = VK_FILTER_LINEAR;
createInfo.magFilter = VK_FILTER_LINEAR;
createInfo.mipmapMode = VK_SAMPLER_MIPMAP_MODE_LINEAR;
@@ -4188,31 +4188,31 @@ using namespace Vulkan_Internal;
VkSamplerReductionModeCreateInfo reductionmode = {};
reductionmode.sType = VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO;
- if (CheckCapability(GRAPHICSDEVICE_CAPABILITY_SAMPLER_MINMAX))
+ if (CheckCapability(GraphicsDeviceCapability::SAMPLER_MINMAX))
{
- switch (pSamplerDesc->Filter)
+ switch (pSamplerDesc->filter)
{
- case FILTER_MINIMUM_MIN_MAG_MIP_POINT:
- case FILTER_MINIMUM_MIN_MAG_POINT_MIP_LINEAR:
- case FILTER_MINIMUM_MIN_POINT_MAG_LINEAR_MIP_POINT:
- case FILTER_MINIMUM_MIN_POINT_MAG_MIP_LINEAR:
- case FILTER_MINIMUM_MIN_LINEAR_MAG_MIP_POINT:
- case FILTER_MINIMUM_MIN_LINEAR_MAG_POINT_MIP_LINEAR:
- case FILTER_MINIMUM_MIN_MAG_LINEAR_MIP_POINT:
- case FILTER_MINIMUM_MIN_MAG_MIP_LINEAR:
- case FILTER_MINIMUM_ANISOTROPIC:
+ case Filter::MINIMUM_MIN_MAG_MIP_POINT:
+ case Filter::MINIMUM_MIN_MAG_POINT_MIP_LINEAR:
+ case Filter::MINIMUM_MIN_POINT_MAG_LINEAR_MIP_POINT:
+ case Filter::MINIMUM_MIN_POINT_MAG_MIP_LINEAR:
+ case Filter::MINIMUM_MIN_LINEAR_MAG_MIP_POINT:
+ case Filter::MINIMUM_MIN_LINEAR_MAG_POINT_MIP_LINEAR:
+ case Filter::MINIMUM_MIN_MAG_LINEAR_MIP_POINT:
+ case Filter::MINIMUM_MIN_MAG_MIP_LINEAR:
+ case Filter::MINIMUM_ANISOTROPIC:
reductionmode.reductionMode = VK_SAMPLER_REDUCTION_MODE_MIN;
createInfo.pNext = &reductionmode;
break;
- case FILTER_MAXIMUM_MIN_MAG_MIP_POINT:
- case FILTER_MAXIMUM_MIN_MAG_POINT_MIP_LINEAR:
- case FILTER_MAXIMUM_MIN_POINT_MAG_LINEAR_MIP_POINT:
- case FILTER_MAXIMUM_MIN_POINT_MAG_MIP_LINEAR:
- case FILTER_MAXIMUM_MIN_LINEAR_MAG_MIP_POINT:
- case FILTER_MAXIMUM_MIN_LINEAR_MAG_POINT_MIP_LINEAR:
- case FILTER_MAXIMUM_MIN_MAG_LINEAR_MIP_POINT:
- case FILTER_MAXIMUM_MIN_MAG_MIP_LINEAR:
- case FILTER_MAXIMUM_ANISOTROPIC:
+ case Filter::MAXIMUM_MIN_MAG_MIP_POINT:
+ case Filter::MAXIMUM_MIN_MAG_POINT_MIP_LINEAR:
+ case Filter::MAXIMUM_MIN_POINT_MAG_LINEAR_MIP_POINT:
+ case Filter::MAXIMUM_MIN_POINT_MAG_MIP_LINEAR:
+ case Filter::MAXIMUM_MIN_LINEAR_MAG_MIP_POINT:
+ case Filter::MAXIMUM_MIN_LINEAR_MAG_POINT_MIP_LINEAR:
+ case Filter::MAXIMUM_MIN_MAG_LINEAR_MIP_POINT:
+ case Filter::MAXIMUM_MIN_MAG_MIP_LINEAR:
+ case Filter::MAXIMUM_ANISOTROPIC:
reductionmode.reductionMode = VK_SAMPLER_REDUCTION_MODE_MAX;
createInfo.pNext = &reductionmode;
break;
@@ -4221,15 +4221,15 @@ using namespace Vulkan_Internal;
}
}
- createInfo.addressModeU = _ConvertTextureAddressMode(pSamplerDesc->AddressU, features_1_2);
- createInfo.addressModeV = _ConvertTextureAddressMode(pSamplerDesc->AddressV, features_1_2);
- createInfo.addressModeW = _ConvertTextureAddressMode(pSamplerDesc->AddressW, features_1_2);
- createInfo.maxAnisotropy = static_cast(pSamplerDesc->MaxAnisotropy);
- createInfo.compareOp = _ConvertComparisonFunc(pSamplerDesc->ComparisonFunc);
- createInfo.minLod = pSamplerDesc->MinLOD;
- createInfo.maxLod = pSamplerDesc->MaxLOD;
- createInfo.mipLodBias = pSamplerDesc->MipLODBias;
- createInfo.borderColor = _ConvertSamplerBorderColor(pSamplerDesc->BorderColor);
+ createInfo.addressModeU = _ConvertTextureAddressMode(pSamplerDesc->address_u, features_1_2);
+ createInfo.addressModeV = _ConvertTextureAddressMode(pSamplerDesc->address_v, features_1_2);
+ createInfo.addressModeW = _ConvertTextureAddressMode(pSamplerDesc->address_w, features_1_2);
+ createInfo.maxAnisotropy = static_cast(pSamplerDesc->max_anisotropy);
+ createInfo.compareOp = _ConvertComparisonFunc(pSamplerDesc->comparison_func);
+ createInfo.minLod = pSamplerDesc->min_lod;
+ createInfo.maxLod = pSamplerDesc->max_lod;
+ createInfo.mipLodBias = pSamplerDesc->mip_lod_bias;
+ createInfo.borderColor = _ConvertSamplerBorderColor(pSamplerDesc->border_color);
createInfo.unnormalizedCoordinates = VK_FALSE;
VkResult res = vkCreateSampler(device, &createInfo, nullptr, &internal_state->resource);
@@ -4267,15 +4267,15 @@ using namespace Vulkan_Internal;
VkQueryPoolCreateInfo poolInfo = {};
poolInfo.sType = VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO;
- poolInfo.queryCount = pDesc->queryCount;
+ poolInfo.queryCount = pDesc->query_count;
switch (pDesc->type)
{
- case GPU_QUERY_TYPE_TIMESTAMP:
+ case GpuQueryType::TIMESTAMP:
poolInfo.queryType = VK_QUERY_TYPE_TIMESTAMP;
break;
- case GPU_QUERY_TYPE_OCCLUSION:
- case GPU_QUERY_TYPE_OCCLUSION_BINARY:
+ case GpuQueryType::OCCLUSION:
+ case GpuQueryType::OCCLUSION_BINARY:
poolInfo.queryType = VK_QUERY_TYPE_OCCLUSION;
break;
}
@@ -4306,7 +4306,7 @@ using namespace Vulkan_Internal;
wiHelper::hash_combine(pso->hash, pDesc->bs);
wiHelper::hash_combine(pso->hash, pDesc->dss);
wiHelper::hash_combine(pso->hash, pDesc->pt);
- wiHelper::hash_combine(pso->hash, pDesc->sampleMask);
+ wiHelper::hash_combine(pso->hash, pDesc->sample_mask);
VkResult res = VK_SUCCESS;
@@ -4558,22 +4558,22 @@ using namespace Vulkan_Internal;
inputAssembly.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO;
switch (pso->desc.pt)
{
- case POINTLIST:
+ case PrimitiveTopology::POINTLIST:
inputAssembly.topology = VK_PRIMITIVE_TOPOLOGY_POINT_LIST;
break;
- case LINELIST:
+ case PrimitiveTopology::LINELIST:
inputAssembly.topology = VK_PRIMITIVE_TOPOLOGY_LINE_LIST;
break;
- case LINESTRIP:
+ case PrimitiveTopology::LINESTRIP:
inputAssembly.topology = VK_PRIMITIVE_TOPOLOGY_LINE_STRIP;
break;
- case TRIANGLESTRIP:
+ case PrimitiveTopology::TRIANGLESTRIP:
inputAssembly.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP;
break;
- case TRIANGLELIST:
+ case PrimitiveTopology::TRIANGLELIST:
inputAssembly.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
break;
- case PATCHLIST:
+ case PrimitiveTopology::PATCHLIST:
inputAssembly.topology = VK_PRIMITIVE_TOPOLOGY_PATCH_LIST;
break;
default:
@@ -4611,39 +4611,39 @@ using namespace Vulkan_Internal;
{
const RasterizerState& desc = *pso->desc.rs;
- switch (desc.FillMode)
+ switch (desc.fill_mode)
{
- case FILL_WIREFRAME:
+ case FillMode::WIREFRAME:
rasterizer.polygonMode = VK_POLYGON_MODE_LINE;
break;
- case FILL_SOLID:
+ case FillMode::SOLID:
default:
rasterizer.polygonMode = VK_POLYGON_MODE_FILL;
break;
}
- switch (desc.CullMode)
+ switch (desc.cull_mode)
{
- case CULL_BACK:
+ case CullMode::BACK:
rasterizer.cullMode = VK_CULL_MODE_BACK_BIT;
break;
- case CULL_FRONT:
+ case CullMode::FRONT:
rasterizer.cullMode = VK_CULL_MODE_FRONT_BIT;
break;
- case CULL_NONE:
+ case CullMode::NONE:
default:
rasterizer.cullMode = VK_CULL_MODE_NONE;
break;
}
- rasterizer.frontFace = desc.FrontCounterClockwise ? VK_FRONT_FACE_COUNTER_CLOCKWISE : VK_FRONT_FACE_CLOCKWISE;
- rasterizer.depthBiasEnable = desc.DepthBias != 0 || desc.SlopeScaledDepthBias != 0;
- rasterizer.depthBiasConstantFactor = static_cast(desc.DepthBias);
- rasterizer.depthBiasClamp = desc.DepthBiasClamp;
- rasterizer.depthBiasSlopeFactor = desc.SlopeScaledDepthBias;
+ rasterizer.frontFace = desc.front_counter_clockwise ? VK_FRONT_FACE_COUNTER_CLOCKWISE : VK_FRONT_FACE_CLOCKWISE;
+ rasterizer.depthBiasEnable = desc.depth_bias != 0 || desc.slope_scaled_depth_bias != 0;
+ rasterizer.depthBiasConstantFactor = static_cast(desc.depth_bias);
+ rasterizer.depthBiasClamp = desc.depth_bias_clamp;
+ rasterizer.depthBiasSlopeFactor = desc.slope_scaled_depth_bias;
// depth clip is extension in Vulkan 1.1:
- depthclip.depthClipEnable = desc.DepthClipEnable ? VK_TRUE : VK_FALSE;
+ depthclip.depthClipEnable = desc.depth_clip_enable ? VK_TRUE : VK_FALSE;
}
pipelineInfo.pRasterizationState = &rasterizer;
@@ -4677,27 +4677,27 @@ using namespace Vulkan_Internal;
depthstencil.sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO;
if (pso->desc.dss != nullptr)
{
- depthstencil.depthTestEnable = pso->desc.dss->DepthEnable ? VK_TRUE : VK_FALSE;
- depthstencil.depthWriteEnable = pso->desc.dss->DepthWriteMask == DEPTH_WRITE_MASK_ZERO ? VK_FALSE : VK_TRUE;
- depthstencil.depthCompareOp = _ConvertComparisonFunc(pso->desc.dss->DepthFunc);
+ depthstencil.depthTestEnable = pso->desc.dss->depth_enable ? VK_TRUE : VK_FALSE;
+ depthstencil.depthWriteEnable = pso->desc.dss->depth_write_mask == DepthWriteMask::ZERO ? VK_FALSE : VK_TRUE;
+ depthstencil.depthCompareOp = _ConvertComparisonFunc(pso->desc.dss->depth_func);
- depthstencil.stencilTestEnable = pso->desc.dss->StencilEnable ? VK_TRUE : VK_FALSE;
+ depthstencil.stencilTestEnable = pso->desc.dss->stencil_enable ? VK_TRUE : VK_FALSE;
- depthstencil.front.compareMask = pso->desc.dss->StencilReadMask;
- depthstencil.front.writeMask = pso->desc.dss->StencilWriteMask;
+ depthstencil.front.compareMask = pso->desc.dss->stencil_read_mask;
+ depthstencil.front.writeMask = pso->desc.dss->stencil_write_mask;
depthstencil.front.reference = 0; // runtime supplied
- depthstencil.front.compareOp = _ConvertComparisonFunc(pso->desc.dss->FrontFace.StencilFunc);
- depthstencil.front.passOp = _ConvertStencilOp(pso->desc.dss->FrontFace.StencilPassOp);
- depthstencil.front.failOp = _ConvertStencilOp(pso->desc.dss->FrontFace.StencilFailOp);
- depthstencil.front.depthFailOp = _ConvertStencilOp(pso->desc.dss->FrontFace.StencilDepthFailOp);
+ depthstencil.front.compareOp = _ConvertComparisonFunc(pso->desc.dss->front_face.stencil_func);
+ depthstencil.front.passOp = _ConvertStencilOp(pso->desc.dss->front_face.stencil_pass_op);
+ depthstencil.front.failOp = _ConvertStencilOp(pso->desc.dss->front_face.stencil_fail_op);
+ depthstencil.front.depthFailOp = _ConvertStencilOp(pso->desc.dss->front_face.stencil_depth_fail_op);
- depthstencil.back.compareMask = pso->desc.dss->StencilReadMask;
- depthstencil.back.writeMask = pso->desc.dss->StencilWriteMask;
+ depthstencil.back.compareMask = pso->desc.dss->stencil_read_mask;
+ depthstencil.back.writeMask = pso->desc.dss->stencil_write_mask;
depthstencil.back.reference = 0; // runtime supplied
- depthstencil.back.compareOp = _ConvertComparisonFunc(pso->desc.dss->BackFace.StencilFunc);
- depthstencil.back.passOp = _ConvertStencilOp(pso->desc.dss->BackFace.StencilPassOp);
- depthstencil.back.failOp = _ConvertStencilOp(pso->desc.dss->BackFace.StencilFailOp);
- depthstencil.back.depthFailOp = _ConvertStencilOp(pso->desc.dss->BackFace.StencilDepthFailOp);
+ depthstencil.back.compareOp = _ConvertComparisonFunc(pso->desc.dss->back_face.stencil_func);
+ depthstencil.back.passOp = _ConvertStencilOp(pso->desc.dss->back_face.stencil_pass_op);
+ depthstencil.back.failOp = _ConvertStencilOp(pso->desc.dss->back_face.stencil_fail_op);
+ depthstencil.back.depthFailOp = _ConvertStencilOp(pso->desc.dss->back_face.stencil_depth_fail_op);
depthstencil.depthBoundsTestEnable = VK_FALSE;
}
@@ -4708,7 +4708,7 @@ using namespace Vulkan_Internal;
// Tessellation:
VkPipelineTessellationStateCreateInfo& tessellationInfo = internal_state->tessellationInfo;
tessellationInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO;
- tessellationInfo.patchControlPoints = pDesc->patchControlPoints;
+ tessellationInfo.patchControlPoints = pDesc->patch_control_points;
pipelineInfo.pTessellationState = &tessellationInfo;
@@ -4729,10 +4729,10 @@ using namespace Vulkan_Internal;
wiHelper::hash_combine(renderpass->hash, pDesc->attachments.size());
for (auto& attachment : pDesc->attachments)
{
- if (attachment.type == RenderPassAttachment::RENDERTARGET || attachment.type == RenderPassAttachment::DEPTH_STENCIL)
+ if (attachment.type == RenderPassAttachment::Type::RENDERTARGET || attachment.type == RenderPassAttachment::Type::DEPTH_STENCIL)
{
- wiHelper::hash_combine(renderpass->hash, attachment.texture->desc.Format);
- wiHelper::hash_combine(renderpass->hash, attachment.texture->desc.SampleCount);
+ wiHelper::hash_combine(renderpass->hash, attachment.texture->desc.format);
+ wiHelper::hash_combine(renderpass->hash, attachment.texture->desc.sample_count);
}
}
@@ -4768,19 +4768,19 @@ using namespace Vulkan_Internal;
auto texture_internal_state = to_internal(texture);
attachmentDescriptions[validAttachmentCount].sType = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2;
- attachmentDescriptions[validAttachmentCount].format = _ConvertFormat(texdesc.Format);
- attachmentDescriptions[validAttachmentCount].samples = (VkSampleCountFlagBits)texdesc.SampleCount;
+ attachmentDescriptions[validAttachmentCount].format = _ConvertFormat(texdesc.format);
+ attachmentDescriptions[validAttachmentCount].samples = (VkSampleCountFlagBits)texdesc.sample_count;
switch (attachment.loadop)
{
default:
- case RenderPassAttachment::LOADOP_LOAD:
+ case RenderPassAttachment::LoadOp::LOAD:
attachmentDescriptions[validAttachmentCount].loadOp = VK_ATTACHMENT_LOAD_OP_LOAD;
break;
- case RenderPassAttachment::LOADOP_CLEAR:
+ case RenderPassAttachment::LoadOp::CLEAR:
attachmentDescriptions[validAttachmentCount].loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
break;
- case RenderPassAttachment::LOADOP_DONTCARE:
+ case RenderPassAttachment::LoadOp::DONTCARE:
attachmentDescriptions[validAttachmentCount].loadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
break;
}
@@ -4788,10 +4788,10 @@ using namespace Vulkan_Internal;
switch (attachment.storeop)
{
default:
- case RenderPassAttachment::STOREOP_STORE:
+ case RenderPassAttachment::StoreOp::STORE:
attachmentDescriptions[validAttachmentCount].storeOp = VK_ATTACHMENT_STORE_OP_STORE;
break;
- case RenderPassAttachment::STOREOP_DONTCARE:
+ case RenderPassAttachment::StoreOp::DONTCARE:
attachmentDescriptions[validAttachmentCount].storeOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
break;
}
@@ -4802,7 +4802,7 @@ using namespace Vulkan_Internal;
attachmentDescriptions[validAttachmentCount].initialLayout = _ConvertImageLayout(attachment.initial_layout);
attachmentDescriptions[validAttachmentCount].finalLayout = _ConvertImageLayout(attachment.final_layout);
- if (attachment.type == RenderPassAttachment::RENDERTARGET)
+ if (attachment.type == RenderPassAttachment::Type::RENDERTARGET)
{
if (subresource < 0 || texture_internal_state->subresources_rtv.empty())
{
@@ -4825,7 +4825,7 @@ using namespace Vulkan_Internal;
subpass.colorAttachmentCount++;
subpass.pColorAttachments = colorAttachmentRefs;
}
- else if (attachment.type == RenderPassAttachment::DEPTH_STENCIL)
+ else if (attachment.type == RenderPassAttachment::Type::DEPTH_STENCIL)
{
if (subresource < 0 || texture_internal_state->subresources_dsv.empty())
{
@@ -4847,19 +4847,19 @@ using namespace Vulkan_Internal;
depthAttachmentRef.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
subpass.pDepthStencilAttachment = &depthAttachmentRef;
- if (IsFormatStencilSupport(texdesc.Format))
+ if (IsFormatStencilSupport(texdesc.format))
{
depthAttachmentRef.aspectMask |= VK_IMAGE_ASPECT_STENCIL_BIT;
switch (attachment.loadop)
{
default:
- case RenderPassAttachment::LOADOP_LOAD:
+ case RenderPassAttachment::LoadOp::LOAD:
attachmentDescriptions[validAttachmentCount].stencilLoadOp = VK_ATTACHMENT_LOAD_OP_LOAD;
break;
- case RenderPassAttachment::LOADOP_CLEAR:
+ case RenderPassAttachment::LoadOp::CLEAR:
attachmentDescriptions[validAttachmentCount].stencilLoadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
break;
- case RenderPassAttachment::LOADOP_DONTCARE:
+ case RenderPassAttachment::LoadOp::DONTCARE:
attachmentDescriptions[validAttachmentCount].stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
break;
}
@@ -4867,16 +4867,16 @@ using namespace Vulkan_Internal;
switch (attachment.storeop)
{
default:
- case RenderPassAttachment::STOREOP_STORE:
+ case RenderPassAttachment::StoreOp::STORE:
attachmentDescriptions[validAttachmentCount].stencilStoreOp = VK_ATTACHMENT_STORE_OP_STORE;
break;
- case RenderPassAttachment::STOREOP_DONTCARE:
+ case RenderPassAttachment::StoreOp::DONTCARE:
attachmentDescriptions[validAttachmentCount].stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
break;
}
}
}
- else if (attachment.type == RenderPassAttachment::RESOLVE)
+ else if (attachment.type == RenderPassAttachment::Type::RESOLVE)
{
resolveAttachmentRefs[resolvecount].sType = VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2;
@@ -4907,7 +4907,7 @@ using namespace Vulkan_Internal;
resolvecount++;
subpass.pResolveAttachments = resolveAttachmentRefs;
}
- else if (attachment.type == RenderPassAttachment::SHADING_RATE_SOURCE && CheckCapability(GRAPHICSDEVICE_CAPABILITY_VARIABLE_RATE_SHADING_TIER2))
+ else if (attachment.type == RenderPassAttachment::Type::SHADING_RATE_SOURCE && CheckCapability(GraphicsDeviceCapability::VARIABLE_RATE_SHADING_TIER2))
{
shadingRateAttachmentRef.sType = VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2;
@@ -4962,8 +4962,8 @@ using namespace Vulkan_Internal;
const TextureDesc& texdesc = desc.attachments[0].texture->desc;
auto texture_internal = to_internal(desc.attachments[0].texture);
framebufferInfo.pAttachments = attachments;
- framebufferInfo.width = texdesc.Width;
- framebufferInfo.height = texdesc.Height;
+ framebufferInfo.width = texdesc.width;
+ framebufferInfo.height = texdesc.height;
if (desc.attachments[0].subresource >= 0)
{
framebufferInfo.layers = texture_internal->subresources_framebuffer_layercount[0];
@@ -4972,7 +4972,7 @@ using namespace Vulkan_Internal;
{
framebufferInfo.layers = texture_internal->framebuffer_layercount;
}
- framebufferInfo.layers = std::min(framebufferInfo.layers, texdesc.ArraySize);
+ framebufferInfo.layers = std::min(framebufferInfo.layers, texdesc.array_size);
}
else
{
@@ -5003,23 +5003,23 @@ using namespace Vulkan_Internal;
int i = 0;
for (auto& attachment : desc.attachments)
{
- if (desc.attachments[i].type == RenderPassAttachment::RESOLVE ||
- desc.attachments[i].type == RenderPassAttachment::SHADING_RATE_SOURCE ||
+ if (desc.attachments[i].type == RenderPassAttachment::Type::RESOLVE ||
+ desc.attachments[i].type == RenderPassAttachment::Type::SHADING_RATE_SOURCE ||
attachment.texture == nullptr)
continue;
const ClearValue& clear = desc.attachments[i].texture->desc.clear;
- if (desc.attachments[i].type == RenderPassAttachment::RENDERTARGET)
+ if (desc.attachments[i].type == RenderPassAttachment::Type::RENDERTARGET)
{
internal_state->clearColors[i].color.float32[0] = clear.color[0];
internal_state->clearColors[i].color.float32[1] = clear.color[1];
internal_state->clearColors[i].color.float32[2] = clear.color[2];
internal_state->clearColors[i].color.float32[3] = clear.color[3];
}
- else if (desc.attachments[i].type == RenderPassAttachment::DEPTH_STENCIL)
+ else if (desc.attachments[i].type == RenderPassAttachment::Type::DEPTH_STENCIL)
{
- internal_state->clearColors[i].depthStencil.depth = clear.depthstencil.depth;
- internal_state->clearColors[i].depthStencil.stencil = clear.depthstencil.stencil;
+ internal_state->clearColors[i].depthStencil.depth = clear.depth_stencil.depth;
+ internal_state->clearColors[i].depthStencil.stencil = clear.depth_stencil.stencil;
}
else
{
@@ -5036,40 +5036,40 @@ using namespace Vulkan_Internal;
auto internal_state = std::make_shared();
internal_state->allocationhandler = allocationhandler;
bvh->internal_state = internal_state;
- bvh->type = GPUResource::GPU_RESOURCE_TYPE::RAYTRACING_ACCELERATION_STRUCTURE;
+ bvh->type = GPUResource::Type::RAYTRACING_ACCELERATION_STRUCTURE;
bvh->desc = *pDesc;
internal_state->buildInfo.sType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR;
internal_state->buildInfo.flags = 0;
- if (bvh->desc._flags & RaytracingAccelerationStructureDesc::FLAG_ALLOW_UPDATE)
+ if (bvh->desc.flags & RaytracingAccelerationStructureDesc::FLAG_ALLOW_UPDATE)
{
internal_state->buildInfo.flags |= VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_KHR;
}
- if (bvh->desc._flags & RaytracingAccelerationStructureDesc::FLAG_ALLOW_COMPACTION)
+ if (bvh->desc.flags & RaytracingAccelerationStructureDesc::FLAG_ALLOW_COMPACTION)
{
internal_state->buildInfo.flags |= VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_KHR;
}
- if (bvh->desc._flags & RaytracingAccelerationStructureDesc::FLAG_PREFER_FAST_TRACE)
+ if (bvh->desc.flags & RaytracingAccelerationStructureDesc::FLAG_PREFER_FAST_TRACE)
{
internal_state->buildInfo.flags |= VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_KHR;
}
- if (bvh->desc._flags & RaytracingAccelerationStructureDesc::FLAG_PREFER_FAST_BUILD)
+ if (bvh->desc.flags & RaytracingAccelerationStructureDesc::FLAG_PREFER_FAST_BUILD)
{
internal_state->buildInfo.flags |= VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_KHR;
}
- if (bvh->desc._flags & RaytracingAccelerationStructureDesc::FLAG_MINIMIZE_MEMORY)
+ if (bvh->desc.flags & RaytracingAccelerationStructureDesc::FLAG_MINIMIZE_MEMORY)
{
internal_state->buildInfo.flags |= VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_KHR;
}
switch (pDesc->type)
{
- case RaytracingAccelerationStructureDesc::BOTTOMLEVEL:
+ case RaytracingAccelerationStructureDesc::Type::BOTTOMLEVEL:
{
internal_state->buildInfo.type = VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_KHR;
- for (auto& x : pDesc->bottomlevel.geometries)
+ for (auto& x : pDesc->bottom_level.geometries)
{
internal_state->geometries.emplace_back();
auto& geometry = internal_state->geometries.back();
@@ -5079,18 +5079,18 @@ using namespace Vulkan_Internal;
internal_state->primitiveCounts.emplace_back();
uint32_t& primitiveCount = internal_state->primitiveCounts.back();
- if (x.type == RaytracingAccelerationStructureDesc::BottomLevel::Geometry::TRIANGLES)
+ if (x.type == RaytracingAccelerationStructureDesc::BottomLevel::Geometry::Type::TRIANGLES)
{
geometry.geometryType = VK_GEOMETRY_TYPE_TRIANGLES_KHR;
geometry.geometry.triangles.sType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR;
- geometry.geometry.triangles.indexType = x.triangles.indexFormat == INDEXFORMAT_16BIT ? VK_INDEX_TYPE_UINT16 : VK_INDEX_TYPE_UINT32;
- geometry.geometry.triangles.maxVertex = x.triangles.vertexCount;
- geometry.geometry.triangles.vertexStride = x.triangles.vertexStride;
- geometry.geometry.triangles.vertexFormat = _ConvertFormat(x.triangles.vertexFormat);
+ geometry.geometry.triangles.indexType = x.triangles.index_format == IndexBufferFormat::UINT16 ? VK_INDEX_TYPE_UINT16 : VK_INDEX_TYPE_UINT32;
+ geometry.geometry.triangles.maxVertex = x.triangles.vertex_count;
+ geometry.geometry.triangles.vertexStride = x.triangles.vertex_stride;
+ geometry.geometry.triangles.vertexFormat = _ConvertFormat(x.triangles.vertex_format);
- primitiveCount = x.triangles.indexCount / 3;
+ primitiveCount = x.triangles.index_count / 3;
}
- else if (x.type == RaytracingAccelerationStructureDesc::BottomLevel::Geometry::PROCEDURAL_AABBS)
+ else if (x.type == RaytracingAccelerationStructureDesc::BottomLevel::Geometry::Type::PROCEDURAL_AABBS)
{
geometry.geometryType = VK_GEOMETRY_TYPE_AABBS_KHR;
geometry.geometry.aabbs.sType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR;
@@ -5103,7 +5103,7 @@ using namespace Vulkan_Internal;
}
break;
- case RaytracingAccelerationStructureDesc::TOPLEVEL:
+ case RaytracingAccelerationStructureDesc::Type::TOPLEVEL:
{
internal_state->buildInfo.type = VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_KHR;
@@ -5117,7 +5117,7 @@ using namespace Vulkan_Internal;
internal_state->primitiveCounts.emplace_back();
uint32_t& primitiveCount = internal_state->primitiveCounts.back();
- primitiveCount = pDesc->toplevel.count;
+ primitiveCount = pDesc->top_level.count;
}
break;
}
@@ -5188,7 +5188,7 @@ using namespace Vulkan_Internal;
+ internal_state->sizeInfo.accelerationStructureSize;
- if (pDesc->type == RaytracingAccelerationStructureDesc::TOPLEVEL)
+ if (pDesc->type == RaytracingAccelerationStructureDesc::Type::TOPLEVEL)
{
internal_state->index = allocationhandler->bindlessAccelerationStructures.allocate();
if (internal_state->index >= 0)
@@ -5235,7 +5235,7 @@ using namespace Vulkan_Internal;
info.flags = 0;
std::vector stages;
- for (auto& x : pDesc->shaderlibraries)
+ for (auto& x : pDesc->shader_libraries)
{
stages.emplace_back();
auto& stage = stages.back();
@@ -5245,19 +5245,19 @@ using namespace Vulkan_Internal;
switch (x.type)
{
default:
- case ShaderLibrary::RAYGENERATION:
+ case ShaderLibrary::Type::RAYGENERATION:
stage.stage = VK_SHADER_STAGE_RAYGEN_BIT_KHR;
break;
- case ShaderLibrary::MISS:
+ case ShaderLibrary::Type::MISS:
stage.stage = VK_SHADER_STAGE_MISS_BIT_KHR;
break;
- case ShaderLibrary::CLOSESTHIT:
+ case ShaderLibrary::Type::CLOSESTHIT:
stage.stage = VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR;
break;
- case ShaderLibrary::ANYHIT:
+ case ShaderLibrary::Type::ANYHIT:
stage.stage = VK_SHADER_STAGE_ANY_HIT_BIT_KHR;
break;
- case ShaderLibrary::INTERSECTION:
+ case ShaderLibrary::Type::INTERSECTION:
stage.stage = VK_SHADER_STAGE_INTERSECTION_BIT_KHR;
break;
}
@@ -5267,8 +5267,8 @@ using namespace Vulkan_Internal;
info.pStages = stages.data();
std::vector groups;
- groups.reserve(pDesc->hitgroups.size());
- for (auto& x : pDesc->hitgroups)
+ groups.reserve(pDesc->hit_groups.size());
+ for (auto& x : pDesc->hit_groups)
{
groups.emplace_back();
auto& group = groups.back();
@@ -5277,19 +5277,19 @@ using namespace Vulkan_Internal;
switch (x.type)
{
default:
- case ShaderHitGroup::GENERAL:
+ case ShaderHitGroup::Type::GENERAL:
group.type = VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_KHR;
break;
- case ShaderHitGroup::TRIANGLES:
+ case ShaderHitGroup::Type::TRIANGLES:
group.type = VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_KHR;
break;
- case ShaderHitGroup::PROCEDURAL:
+ case ShaderHitGroup::Type::PROCEDURAL:
group.type = VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_KHR;
break;
}
group.generalShader = x.general_shader;
- group.closestHitShader = x.closesthit_shader;
- group.anyHitShader = x.anyhit_shader;
+ group.closestHitShader = x.closest_hit_shader;
+ group.anyHitShader = x.any_hit_shader;
group.intersectionShader = x.intersection_shader;
}
info.groupCount = (uint32_t)groups.size();
@@ -5297,7 +5297,7 @@ using namespace Vulkan_Internal;
info.maxPipelineRayRecursionDepth = pDesc->max_trace_recursion_depth;
- info.layout = to_internal(pDesc->shaderlibraries.front().shader)->pipelineLayout_cs; // think better way
+ info.layout = to_internal(pDesc->shader_libraries.front().shader)->pipelineLayout_cs; // think better way
//VkRayTracingPipelineInterfaceCreateInfoKHR library_interface = {};
//library_interface.sType = VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR;
@@ -5322,7 +5322,7 @@ using namespace Vulkan_Internal;
return res == VK_SUCCESS;
}
- int GraphicsDevice_Vulkan::CreateSubresource(Texture* texture, SUBRESOURCE_TYPE type, uint32_t firstSlice, uint32_t sliceCount, uint32_t firstMip, uint32_t mipCount) const
+ int GraphicsDevice_Vulkan::CreateSubresource(Texture* texture, SubresourceType type, uint32_t firstSlice, uint32_t sliceCount, uint32_t firstMip, uint32_t mipCount) const
{
auto internal_state = to_internal(texture);
@@ -5335,11 +5335,11 @@ using namespace Vulkan_Internal;
view_desc.subresourceRange.layerCount = sliceCount;
view_desc.subresourceRange.baseMipLevel = firstMip;
view_desc.subresourceRange.levelCount = mipCount;
- view_desc.format = _ConvertFormat(texture->desc.Format);
+ view_desc.format = _ConvertFormat(texture->desc.format);
- if (texture->desc.type == TextureDesc::TEXTURE_1D)
+ if (texture->desc.type == TextureDesc::Type::TEXTURE_1D)
{
- if (texture->desc.ArraySize > 1)
+ if (texture->desc.array_size > 1)
{
view_desc.viewType = VK_IMAGE_VIEW_TYPE_1D_ARRAY;
}
@@ -5348,13 +5348,13 @@ using namespace Vulkan_Internal;
view_desc.viewType = VK_IMAGE_VIEW_TYPE_1D;
}
}
- else if (texture->desc.type == TextureDesc::TEXTURE_2D)
+ else if (texture->desc.type == TextureDesc::Type::TEXTURE_2D)
{
- if (texture->desc.ArraySize > 1)
+ if (texture->desc.array_size > 1)
{
- if (texture->desc.MiscFlags & RESOURCE_MISC_TEXTURECUBE)
+ if (has_flag(texture->desc.misc_flags, ResourceMiscFlag::TEXTURECUBE))
{
- if (texture->desc.ArraySize > 6 && sliceCount > 6)
+ if (texture->desc.array_size > 6 && sliceCount > 6)
{
view_desc.viewType = VK_IMAGE_VIEW_TYPE_CUBE_ARRAY;
}
@@ -5373,30 +5373,30 @@ using namespace Vulkan_Internal;
view_desc.viewType = VK_IMAGE_VIEW_TYPE_2D;
}
}
- else if (texture->desc.type == TextureDesc::TEXTURE_3D)
+ else if (texture->desc.type == TextureDesc::Type::TEXTURE_3D)
{
view_desc.viewType = VK_IMAGE_VIEW_TYPE_3D;
}
switch (type)
{
- case wiGraphics::SRV:
+ case SubresourceType::SRV:
{
- switch (texture->desc.Format)
+ switch (texture->desc.format)
{
- case FORMAT_R16_TYPELESS:
+ case Format::R16_TYPELESS:
view_desc.format = VK_FORMAT_D16_UNORM;
view_desc.subresourceRange.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
break;
- case FORMAT_R32_TYPELESS:
+ case Format::R32_TYPELESS:
view_desc.format = VK_FORMAT_D32_SFLOAT;
view_desc.subresourceRange.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
break;
- case FORMAT_R24G8_TYPELESS:
+ case Format::R24G8_TYPELESS:
view_desc.format = VK_FORMAT_D24_UNORM_S8_UINT;
view_desc.subresourceRange.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
break;
- case FORMAT_R32G8X24_TYPELESS:
+ case Format::R32G8X24_TYPELESS:
view_desc.format = VK_FORMAT_D32_SFLOAT_S8_UINT;
view_desc.subresourceRange.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
break;
@@ -5440,7 +5440,7 @@ using namespace Vulkan_Internal;
}
}
break;
- case wiGraphics::UAV:
+ case SubresourceType::UAV:
{
if (view_desc.viewType == VK_IMAGE_VIEW_TYPE_CUBE || view_desc.viewType == VK_IMAGE_VIEW_TYPE_CUBE_ARRAY)
{
@@ -5485,7 +5485,7 @@ using namespace Vulkan_Internal;
}
}
break;
- case wiGraphics::RTV:
+ case SubresourceType::RTV:
{
VkImageView rtv;
view_desc.subresourceRange.levelCount = 1;
@@ -5509,24 +5509,24 @@ using namespace Vulkan_Internal;
}
}
break;
- case wiGraphics::DSV:
+ case SubresourceType::DSV:
{
view_desc.subresourceRange.levelCount = 1;
view_desc.subresourceRange.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
- switch (texture->desc.Format)
+ switch (texture->desc.format)
{
- case FORMAT_R16_TYPELESS:
+ case Format::R16_TYPELESS:
view_desc.format = VK_FORMAT_D16_UNORM;
break;
- case FORMAT_R32_TYPELESS:
+ case Format::R32_TYPELESS:
view_desc.format = VK_FORMAT_D32_SFLOAT;
break;
- case FORMAT_R24G8_TYPELESS:
+ case Format::R24G8_TYPELESS:
view_desc.format = VK_FORMAT_D24_UNORM_S8_UINT;
view_desc.subresourceRange.aspectMask |= VK_IMAGE_ASPECT_STENCIL_BIT;
break;
- case FORMAT_R32G8X24_TYPELESS:
+ case Format::R32G8X24_TYPELESS:
view_desc.format = VK_FORMAT_D32_SFLOAT_S8_UINT;
view_desc.subresourceRange.aspectMask |= VK_IMAGE_ASPECT_STENCIL_BIT;
break;
@@ -5558,7 +5558,7 @@ using namespace Vulkan_Internal;
}
return -1;
}
- int GraphicsDevice_Vulkan::CreateSubresource(GPUBuffer* buffer, SUBRESOURCE_TYPE type, uint64_t offset, uint64_t size) const
+ int GraphicsDevice_Vulkan::CreateSubresource(GPUBuffer* buffer, SubresourceType type, uint64_t offset, uint64_t size) const
{
auto internal_state = to_internal(buffer);
const GPUBufferDesc& desc = buffer->GetDesc();
@@ -5567,10 +5567,10 @@ using namespace Vulkan_Internal;
switch (type)
{
- case wiGraphics::SRV:
- case wiGraphics::UAV:
+ case SubresourceType::SRV:
+ case SubresourceType::UAV:
{
- if (desc.Format == FORMAT_UNKNOWN)
+ if (desc.format == Format::UNKNOWN)
{
// Raw buffer
int index = allocationhandler->bindlessStorageBuffers.allocate();
@@ -5591,7 +5591,7 @@ using namespace Vulkan_Internal;
vkUpdateDescriptorSets(device, 1, &write, 0, nullptr);
}
- if (type == SRV)
+ if (type == SubresourceType::SRV)
{
if (internal_state->srv_index == -1)
{
@@ -5620,16 +5620,16 @@ using namespace Vulkan_Internal;
srv_desc.sType = VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO;
srv_desc.buffer = internal_state->resource;
srv_desc.flags = 0;
- srv_desc.format = _ConvertFormat(desc.Format);
+ srv_desc.format = _ConvertFormat(desc.format);
srv_desc.offset = AlignTo(offset, properties2.properties.limits.minTexelBufferOffsetAlignment); // damn, if this needs alignment, that could break a lot of things! (index buffer, index offset?)
- srv_desc.range = std::min(size, (uint64_t)desc.Size - srv_desc.offset);
+ srv_desc.range = std::min(size, (uint64_t)desc.size - srv_desc.offset);
VkBufferView view;
res = vkCreateBufferView(device, &srv_desc, nullptr, &view);
if (res == VK_SUCCESS)
{
- if (type == SRV)
+ if (type == SubresourceType::SRV)
{
int index = allocationhandler->bindlessUniformTexelBuffers.allocate();
if (index >= 0)
@@ -5696,7 +5696,7 @@ using namespace Vulkan_Internal;
return -1;
}
- int GraphicsDevice_Vulkan::GetDescriptorIndex(const GPUResource* resource, SUBRESOURCE_TYPE type, int subresource) const
+ int GraphicsDevice_Vulkan::GetDescriptorIndex(const GPUResource* resource, SubresourceType type, int subresource) const
{
if (resource == nullptr || !resource->IsValid())
return -1;
@@ -5704,7 +5704,7 @@ using namespace Vulkan_Internal;
switch (type)
{
default:
- case wiGraphics::SRV:
+ case SubresourceType::SRV:
if (resource->IsBuffer())
{
auto internal_state = to_internal((const GPUBuffer*)resource);
@@ -5735,7 +5735,7 @@ using namespace Vulkan_Internal;
return internal_state->index;
}
break;
- case wiGraphics::UAV:
+ case SubresourceType::UAV:
if (resource->IsBuffer())
{
auto internal_state = to_internal((const GPUBuffer*)resource);
@@ -5774,7 +5774,7 @@ using namespace Vulkan_Internal;
return internal_state->index;
}
- void GraphicsDevice_Vulkan::WriteShadingRateValue(SHADING_RATE rate, void* dest) const
+ void GraphicsDevice_Vulkan::WriteShadingRateValue(ShadingRate rate, void* dest) const
{
// How to compute shading rate value texel data:
// https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#primsrast-fragment-shading-rate-attachment
@@ -5782,25 +5782,25 @@ using namespace Vulkan_Internal;
switch (rate)
{
default:
- case wiGraphics::SHADING_RATE_1X1:
+ case ShadingRate::RATE_1X1:
*(uint8_t*)dest = 0;
break;
- case wiGraphics::SHADING_RATE_1X2:
+ case ShadingRate::RATE_1X2:
*(uint8_t*)dest = 0x1;
break;
- case wiGraphics::SHADING_RATE_2X1:
+ case ShadingRate::RATE_2X1:
*(uint8_t*)dest = 0x4;
break;
- case wiGraphics::SHADING_RATE_2X2:
+ case ShadingRate::RATE_2X2:
*(uint8_t*)dest = 0x5;
break;
- case wiGraphics::SHADING_RATE_2X4:
+ case ShadingRate::RATE_2X4:
*(uint8_t*)dest = 0x6;
break;
- case wiGraphics::SHADING_RATE_4X2:
+ case ShadingRate::RATE_4X2:
*(uint8_t*)dest = 0x9;
break;
- case wiGraphics::SHADING_RATE_4X4:
+ case ShadingRate::RATE_4X4:
*(uint8_t*)dest = 0xa;
break;
}
@@ -5810,13 +5810,13 @@ using namespace Vulkan_Internal;
{
VkAccelerationStructureInstanceKHR* desc = (VkAccelerationStructureInstanceKHR*)dest;
memcpy(&desc->transform, &instance->transform, sizeof(desc->transform));
- desc->instanceCustomIndex = instance->InstanceID;
- desc->mask = instance->InstanceMask;
- desc->instanceShaderBindingTableRecordOffset = instance->InstanceContributionToHitGroupIndex;
- desc->flags = instance->Flags;
+ desc->instanceCustomIndex = instance->instance_id;
+ desc->mask = instance->instance_mask;
+ desc->instanceShaderBindingTableRecordOffset = instance->instance_contribution_to_hit_group_index;
+ desc->flags = instance->flags;
- assert(instance->bottomlevel.IsAccelerationStructure());
- auto internal_state = to_internal((RaytracingAccelerationStructure*)&instance->bottomlevel);
+ assert(instance->bottom_level.IsAccelerationStructure());
+ auto internal_state = to_internal((RaytracingAccelerationStructure*)&instance->bottom_level);
desc->accelerationStructureReference = internal_state->as_address;
}
void GraphicsDevice_Vulkan::WriteShaderIdentifier(const RaytracingPipelineState* rtpso, uint32_t group_index, void* dest) const
@@ -5866,7 +5866,7 @@ using namespace Vulkan_Internal;
{
VkResult res;
- CommandList cmd = cmd_count.fetch_add(1);
+ CommandList cmd{ cmd_count.fetch_add(1) };
assert(cmd < COMMANDLIST_COUNT);
cmd_meta[cmd].queue = queue;
cmd_meta[cmd].waits.clear();
@@ -5948,7 +5948,7 @@ using namespace Vulkan_Internal;
active_rt[cmd] = nullptr;
active_renderpass[cmd] = nullptr;
dirty_pso[cmd] = false;
- prev_shadingrate[cmd] = SHADING_RATE_INVALID;
+ prev_shadingrate[cmd] = ShadingRate::RATE_INVALID;
pushconstants[cmd] = {};
vb_hash[cmd] = 0;
for (int i = 0; i < arraysize(vb_strides[cmd]); ++i)
@@ -5979,9 +5979,9 @@ using namespace Vulkan_Internal;
uint64_t copy_sync = copyAllocator.flush();
- CommandList cmd_last = cmd_count.load();
+ CommandList::index_type cmd_last = cmd_count.load();
cmd_count.store(0);
- for (CommandList cmd = 0; cmd < cmd_last; ++cmd)
+ for (CommandList::index_type cmd = 0; cmd < cmd_last; ++cmd)
{
res = vkEndCommandBuffer(GetCommandList(cmd));
assert(res == VK_SUCCESS);
@@ -6159,21 +6159,21 @@ using namespace Vulkan_Internal;
internal_state->resource = swapchain_internal->swapChainImages[swapchain_internal->swapChainImageIndex];
Texture result;
- result.type = GPUResource::GPU_RESOURCE_TYPE::TEXTURE;
+ result.type = GPUResource::Type::TEXTURE;
result.internal_state = internal_state;
- result.desc.type = TextureDesc::TEXTURE_2D;
- result.desc.Width = swapchain_internal->swapChainExtent.width;
- result.desc.Height = swapchain_internal->swapChainExtent.height;
- result.desc.Format = swapchain->desc.format;
+ result.desc.type = TextureDesc::Type::TEXTURE_2D;
+ result.desc.width = swapchain_internal->swapChainExtent.width;
+ result.desc.height = swapchain_internal->swapChainExtent.height;
+ result.desc.format = swapchain->desc.format;
return result;
}
- COLOR_SPACE GraphicsDevice_Vulkan::GetSwapChainColorSpace(const SwapChain* swapchain) const
+ ColorSpace GraphicsDevice_Vulkan::GetSwapChainColorSpace(const SwapChain* swapchain) const
{
auto internal_state = to_internal(swapchain);
return internal_state->colorSpace;
}
- bool GraphicsDevice_Vulkan::GetSwapChainHDRSupport(const SwapChain* swapchain) const
+ bool GraphicsDevice_Vulkan::IsSwapChainSupportsHDR(const SwapChain* swapchain) const
{
auto internal_state = to_internal(swapchain);
@@ -6235,10 +6235,10 @@ using namespace Vulkan_Internal;
}
VkClearValue clearColor = {
- swapchain->desc.clearcolor[0],
- swapchain->desc.clearcolor[1],
- swapchain->desc.clearcolor[2],
- swapchain->desc.clearcolor[3],
+ swapchain->desc.clear_color[0],
+ swapchain->desc.clear_color[1],
+ swapchain->desc.clear_color[2],
+ swapchain->desc.clear_color[3],
};
VkRenderPassBeginInfo renderPassInfo = {};
renderPassInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
@@ -6287,12 +6287,12 @@ using namespace Vulkan_Internal;
assert(NumViewports < properties2.properties.limits.maxViewports);
for (uint32_t i = 0; i < NumViewports; ++i)
{
- vp[i].x = pViewports[i].TopLeftX;
- vp[i].y = pViewports[i].TopLeftY + pViewports[i].Height;
- vp[i].width = pViewports[i].Width;
- vp[i].height = -pViewports[i].Height;
- vp[i].minDepth = pViewports[i].MinDepth;
- vp[i].maxDepth = pViewports[i].MaxDepth;
+ vp[i].x = pViewports[i].top_left_x;
+ vp[i].y = pViewports[i].top_left_y + pViewports[i].height;
+ vp[i].width = pViewports[i].width;
+ vp[i].height = -pViewports[i].height;
+ vp[i].minDepth = pViewports[i].min_depth;
+ vp[i].maxDepth = pViewports[i].max_depth;
}
vkCmdSetViewport(GetCommandList(cmd), 0, NumViewports, vp);
}
@@ -6398,12 +6398,12 @@ using namespace Vulkan_Internal;
dirty_pso[cmd] = true;
}
}
- void GraphicsDevice_Vulkan::BindIndexBuffer(const GPUBuffer* indexBuffer, const INDEXBUFFER_FORMAT format, uint64_t offset, CommandList cmd)
+ void GraphicsDevice_Vulkan::BindIndexBuffer(const GPUBuffer* indexBuffer, const IndexBufferFormat format, uint64_t offset, CommandList cmd)
{
if (indexBuffer != nullptr)
{
auto internal_state = to_internal(indexBuffer);
- vkCmdBindIndexBuffer(GetCommandList(cmd), internal_state->resource, offset, format == INDEXFORMAT_16BIT ? VK_INDEX_TYPE_UINT16 : VK_INDEX_TYPE_UINT32);
+ vkCmdBindIndexBuffer(GetCommandList(cmd), internal_state->resource, offset, format == IndexBufferFormat::UINT16 ? VK_INDEX_TYPE_UINT16 : VK_INDEX_TYPE_UINT32);
}
}
void GraphicsDevice_Vulkan::BindStencilRef(uint32_t value, CommandList cmd)
@@ -6415,40 +6415,40 @@ using namespace Vulkan_Internal;
float blendConstants[] = { r, g, b, a };
vkCmdSetBlendConstants(GetCommandList(cmd), blendConstants);
}
- void GraphicsDevice_Vulkan::BindShadingRate(SHADING_RATE rate, CommandList cmd)
+ void GraphicsDevice_Vulkan::BindShadingRate(ShadingRate rate, CommandList cmd)
{
- if (CheckCapability(GRAPHICSDEVICE_CAPABILITY_VARIABLE_RATE_SHADING) && prev_shadingrate[cmd] != rate)
+ if (CheckCapability(GraphicsDeviceCapability::VARIABLE_RATE_SHADING) && prev_shadingrate[cmd] != rate)
{
prev_shadingrate[cmd] = rate;
VkExtent2D fragmentSize;
switch (rate)
{
- case wiGraphics::SHADING_RATE_1X1:
+ case ShadingRate::RATE_1X1:
fragmentSize.width = 1;
fragmentSize.height = 1;
break;
- case wiGraphics::SHADING_RATE_1X2:
+ case ShadingRate::RATE_1X2:
fragmentSize.width = 1;
fragmentSize.height = 2;
break;
- case wiGraphics::SHADING_RATE_2X1:
+ case ShadingRate::RATE_2X1:
fragmentSize.width = 2;
fragmentSize.height = 1;
break;
- case wiGraphics::SHADING_RATE_2X2:
+ case ShadingRate::RATE_2X2:
fragmentSize.width = 2;
fragmentSize.height = 2;
break;
- case wiGraphics::SHADING_RATE_2X4:
+ case ShadingRate::RATE_2X4:
fragmentSize.width = 2;
fragmentSize.height = 4;
break;
- case wiGraphics::SHADING_RATE_4X2:
+ case ShadingRate::RATE_4X2:
fragmentSize.width = 4;
fragmentSize.height = 2;
break;
- case wiGraphics::SHADING_RATE_4X4:
+ case ShadingRate::RATE_4X4:
fragmentSize.width = 4;
fragmentSize.height = 4;
break;
@@ -6539,7 +6539,7 @@ using namespace Vulkan_Internal;
}
void GraphicsDevice_Vulkan::BindComputeShader(const Shader* cs, CommandList cmd)
{
- assert(cs->stage == CS || cs->stage == LIB);
+ assert(cs->stage == ShaderStage::CS || cs->stage == ShaderStage::LIB);
if (active_cs[cmd] != cs)
{
if (active_cs[cmd] == nullptr)
@@ -6559,7 +6559,7 @@ using namespace Vulkan_Internal;
active_cs[cmd] = cs;
auto internal_state = to_internal(cs);
- if (cs->stage == CS)
+ if (cs->stage == ShaderStage::CS)
{
vkCmdBindPipeline(GetCommandList(cmd), VK_PIPELINE_BIND_POINT_COMPUTE, internal_state->pipeline_cs);
@@ -6577,7 +6577,7 @@ using namespace Vulkan_Internal;
);
}
}
- else if (cs->stage == LIB)
+ else if (cs->stage == ShaderStage::LIB)
{
if (!internal_state->bindlessSets.empty())
{
@@ -6651,7 +6651,7 @@ using namespace Vulkan_Internal;
}
void GraphicsDevice_Vulkan::CopyResource(const GPUResource* pDst, const GPUResource* pSrc, CommandList cmd)
{
- if (pDst->type == GPUResource::GPU_RESOURCE_TYPE::TEXTURE && pSrc->type == GPUResource::GPU_RESOURCE_TYPE::TEXTURE)
+ if (pDst->type == GPUResource::Type::TEXTURE && pSrc->type == GPUResource::Type::TEXTURE)
{
auto internal_state_src = to_internal((const Texture*)pSrc);
auto internal_state_dst = to_internal((const Texture*)pDst);
@@ -6659,13 +6659,13 @@ 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_UPLOAD)
+ if (src_desc.usage == Usage::UPLOAD)
{
VkBufferImageCopy copy = {};
- copy.imageExtent.width = dst_desc.Width;
- copy.imageExtent.height = dst_desc.Height;
+ copy.imageExtent.width = dst_desc.width;
+ copy.imageExtent.height = dst_desc.height;
copy.imageExtent.depth = 1;
- copy.imageExtent.width = dst_desc.Width;
+ copy.imageExtent.width = dst_desc.width;
copy.imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
copy.imageSubresource.layerCount = 1;
vkCmdCopyBufferToImage(
@@ -6677,13 +6677,13 @@ using namespace Vulkan_Internal;
©
);
}
- else if (dst_desc.Usage == USAGE_READBACK)
+ else if (dst_desc.usage == Usage::READBACK)
{
VkBufferImageCopy copy = {};
- copy.imageExtent.width = src_desc.Width;
- copy.imageExtent.height = src_desc.Height;
+ copy.imageExtent.width = src_desc.width;
+ copy.imageExtent.height = src_desc.height;
copy.imageExtent.depth = 1;
- copy.imageExtent.width = src_desc.Width;
+ copy.imageExtent.width = src_desc.width;
copy.imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
copy.imageSubresource.layerCount = 1;
vkCmdCopyImageToBuffer(
@@ -6698,9 +6698,9 @@ using namespace Vulkan_Internal;
else
{
VkImageCopy copy = {};
- copy.extent.width = dst_desc.Width;
- copy.extent.height = dst_desc.Height;
- copy.extent.depth = std::max(1u, dst_desc.Depth);
+ copy.extent.width = dst_desc.width;
+ copy.extent.height = dst_desc.height;
+ copy.extent.depth = std::max(1u, dst_desc.depth);
copy.srcOffset.x = 0;
copy.srcOffset.y = 0;
@@ -6710,10 +6710,10 @@ using namespace Vulkan_Internal;
copy.dstOffset.y = 0;
copy.dstOffset.z = 0;
- if (src_desc.BindFlags & BIND_DEPTH_STENCIL)
+ if (has_flag(src_desc.bind_flags, BindFlag::DEPTH_STENCIL))
{
copy.srcSubresource.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
- if (IsFormatStencilSupport(src_desc.Format))
+ if (IsFormatStencilSupport(src_desc.format))
{
copy.srcSubresource.aspectMask |= VK_IMAGE_ASPECT_STENCIL_BIT;
}
@@ -6723,13 +6723,13 @@ using namespace Vulkan_Internal;
copy.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
}
copy.srcSubresource.baseArrayLayer = 0;
- copy.srcSubresource.layerCount = src_desc.ArraySize;
+ copy.srcSubresource.layerCount = src_desc.array_size;
copy.srcSubresource.mipLevel = 0;
- if (dst_desc.BindFlags & BIND_DEPTH_STENCIL)
+ if (has_flag(dst_desc.bind_flags, BindFlag::DEPTH_STENCIL))
{
copy.dstSubresource.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
- if (IsFormatStencilSupport(dst_desc.Format))
+ if (IsFormatStencilSupport(dst_desc.format))
{
copy.dstSubresource.aspectMask |= VK_IMAGE_ASPECT_STENCIL_BIT;
}
@@ -6739,7 +6739,7 @@ using namespace Vulkan_Internal;
copy.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
}
copy.dstSubresource.baseArrayLayer = 0;
- copy.dstSubresource.layerCount = dst_desc.ArraySize;
+ copy.dstSubresource.layerCount = dst_desc.array_size;
copy.dstSubresource.mipLevel = 0;
vkCmdCopyImage(GetCommandList(cmd),
@@ -6749,7 +6749,7 @@ using namespace Vulkan_Internal;
);
}
}
- else if (pDst->type == GPUResource::GPU_RESOURCE_TYPE::BUFFER && pSrc->type == GPUResource::GPU_RESOURCE_TYPE::BUFFER)
+ else if (pDst->type == GPUResource::Type::BUFFER && pSrc->type == GPUResource::Type::BUFFER)
{
auto internal_state_src = to_internal((const GPUBuffer*)pSrc);
auto internal_state_dst = to_internal((const GPUBuffer*)pDst);
@@ -6760,7 +6760,7 @@ using namespace Vulkan_Internal;
VkBufferCopy copy = {};
copy.srcOffset = 0;
copy.dstOffset = 0;
- copy.size = std::min(src_desc.Size, dst_desc.Size);
+ copy.size = std::min(src_desc.size, dst_desc.size);
vkCmdCopyBuffer(GetCommandList(cmd),
internal_state_src->resource,
@@ -6791,10 +6791,10 @@ using namespace Vulkan_Internal;
switch (heap->desc.type)
{
- case GPU_QUERY_TYPE_OCCLUSION_BINARY:
+ case GpuQueryType::OCCLUSION_BINARY:
vkCmdBeginQuery(GetCommandList(cmd), internal_state->pool, index, 0);
break;
- case GPU_QUERY_TYPE_OCCLUSION:
+ case GpuQueryType::OCCLUSION:
vkCmdBeginQuery(GetCommandList(cmd), internal_state->pool, index, VK_QUERY_CONTROL_PRECISE_BIT);
break;
}
@@ -6805,11 +6805,11 @@ using namespace Vulkan_Internal;
switch (heap->desc.type)
{
- case GPU_QUERY_TYPE_TIMESTAMP:
+ case GpuQueryType::TIMESTAMP:
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:
+ case GpuQueryType::OCCLUSION_BINARY:
+ case GpuQueryType::OCCLUSION:
vkCmdEndQuery(GetCommandList(cmd), internal_state->pool, index);
break;
}
@@ -6826,7 +6826,7 @@ using namespace Vulkan_Internal;
switch (heap->desc.type)
{
- case GPU_QUERY_TYPE_OCCLUSION_BINARY:
+ case GpuQueryType::OCCLUSION_BINARY:
flags |= VK_QUERY_RESULT_PARTIAL_BIT;
break;
default:
@@ -6874,15 +6874,15 @@ using namespace Vulkan_Internal;
{
const GPUBarrier& barrier = barriers[i];
- if (barrier.type == GPUBarrier::IMAGE_BARRIER && (barrier.image.texture == nullptr || !barrier.image.texture->IsValid()))
+ if (barrier.type == GPUBarrier::Type::IMAGE && (barrier.image.texture == nullptr || !barrier.image.texture->IsValid()))
continue;
- if (barrier.type == GPUBarrier::BUFFER_BARRIER && (barrier.buffer.buffer == nullptr || !barrier.buffer.buffer->IsValid()))
+ if (barrier.type == GPUBarrier::Type::BUFFER && (barrier.buffer.buffer == nullptr || !barrier.buffer.buffer->IsValid()))
continue;
switch (barrier.type)
{
default:
- case GPUBarrier::MEMORY_BARRIER:
+ case GPUBarrier::Type::MEMORY:
{
VkMemoryBarrier barrierdesc = {};
barrierdesc.sType = VK_STRUCTURE_TYPE_MEMORY_BARRIER;
@@ -6890,7 +6890,7 @@ using namespace Vulkan_Internal;
barrierdesc.srcAccessMask = VK_ACCESS_MEMORY_WRITE_BIT;
barrierdesc.dstAccessMask = VK_ACCESS_MEMORY_READ_BIT;
- if (CheckCapability(GRAPHICSDEVICE_CAPABILITY_RAYTRACING))
+ if (CheckCapability(GraphicsDeviceCapability::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;
@@ -6898,7 +6898,7 @@ using namespace Vulkan_Internal;
dstStage |= VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR | VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR;
}
- if (CheckCapability(GRAPHICSDEVICE_CAPABILITY_PREDICATION))
+ if (CheckCapability(GraphicsDeviceCapability::PREDICATION))
{
barrierdesc.srcAccessMask |= VK_ACCESS_CONDITIONAL_RENDERING_READ_BIT_EXT;
barrierdesc.dstAccessMask |= VK_ACCESS_CONDITIONAL_RENDERING_READ_BIT_EXT;
@@ -6909,7 +6909,7 @@ using namespace Vulkan_Internal;
memoryBarriers.push_back(barrierdesc);
}
break;
- case GPUBarrier::IMAGE_BARRIER:
+ case GPUBarrier::Type::IMAGE:
{
const TextureDesc& desc = barrier.image.texture->desc;
auto internal_state = to_internal(barrier.image.texture);
@@ -6922,10 +6922,10 @@ using namespace Vulkan_Internal;
barrierdesc.newLayout = _ConvertImageLayout(barrier.image.layout_after);
barrierdesc.srcAccessMask = _ParseResourceState(barrier.image.layout_before);
barrierdesc.dstAccessMask = _ParseResourceState(barrier.image.layout_after);
- if (desc.BindFlags & BIND_DEPTH_STENCIL)
+ if (has_flag(desc.bind_flags, BindFlag::DEPTH_STENCIL))
{
barrierdesc.subresourceRange.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
- if (IsFormatStencilSupport(desc.Format))
+ if (IsFormatStencilSupport(desc.format))
{
barrierdesc.subresourceRange.aspectMask |= VK_IMAGE_ASPECT_STENCIL_BIT;
}
@@ -6954,7 +6954,7 @@ using namespace Vulkan_Internal;
imageBarriers.push_back(barrierdesc);
}
break;
- case GPUBarrier::BUFFER_BARRIER:
+ case GPUBarrier::Type::BUFFER:
{
const GPUBufferDesc& desc = barrier.buffer.buffer->desc;
auto internal_state = to_internal(barrier.buffer.buffer);
@@ -6963,7 +6963,7 @@ using namespace Vulkan_Internal;
barrierdesc.sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER;
barrierdesc.pNext = nullptr;
barrierdesc.buffer = internal_state->resource;
- barrierdesc.size = desc.Size;
+ barrierdesc.size = desc.size;
barrierdesc.offset = 0;
barrierdesc.srcAccessMask = _ParseResourceState(barrier.buffer.state_before);
barrierdesc.dstAccessMask = _ParseResourceState(barrier.buffer.state_after);
@@ -6972,16 +6972,16 @@ using namespace Vulkan_Internal;
bufferBarriers.push_back(barrierdesc);
- if (desc.MiscFlags & RESOURCE_MISC_RAY_TRACING)
+ if (has_flag(desc.misc_flags, ResourceMiscFlag::RAY_TRACING))
{
- assert(CheckCapability(GRAPHICSDEVICE_CAPABILITY_RAYTRACING));
+ assert(CheckCapability(GraphicsDeviceCapability::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;
}
- if (desc.MiscFlags & RESOURCE_MISC_PREDICATION)
+ if (has_flag(desc.misc_flags, ResourceMiscFlag::PREDICATION))
{
- assert(CheckCapability(GRAPHICSDEVICE_CAPABILITY_PREDICATION));
+ assert(CheckCapability(GraphicsDeviceCapability::PREDICATION));
srcStage |= VK_PIPELINE_STAGE_CONDITIONAL_RENDERING_BIT_EXT;
dstStage |= VK_PIPELINE_STAGE_CONDITIONAL_RENDERING_BIT_EXT;
}
@@ -7038,10 +7038,10 @@ using namespace Vulkan_Internal;
switch (dst->desc.type)
{
- case RaytracingAccelerationStructureDesc::BOTTOMLEVEL:
+ case RaytracingAccelerationStructureDesc::Type::BOTTOMLEVEL:
{
size_t i = 0;
- for (auto& x : dst->desc.bottomlevel.geometries)
+ for (auto& x : dst->desc.bottom_level.geometries)
{
auto& geometry = geometries[i];
@@ -7049,35 +7049,35 @@ using namespace Vulkan_Internal;
auto& range = ranges.back();
range = {};
- if (x._flags & RaytracingAccelerationStructureDesc::BottomLevel::Geometry::FLAG_OPAQUE)
+ if (x.flags & RaytracingAccelerationStructureDesc::BottomLevel::Geometry::FLAG_OPAQUE)
{
geometry.flags |= VK_GEOMETRY_OPAQUE_BIT_KHR;
}
- if (x._flags & RaytracingAccelerationStructureDesc::BottomLevel::Geometry::FLAG_NO_DUPLICATE_ANYHIT_INVOCATION)
+ if (x.flags & RaytracingAccelerationStructureDesc::BottomLevel::Geometry::FLAG_NO_DUPLICATE_ANYHIT_INVOCATION)
{
geometry.flags |= VK_GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION_BIT_KHR;
}
- if (x.type == RaytracingAccelerationStructureDesc::BottomLevel::Geometry::TRIANGLES)
+ if (x.type == RaytracingAccelerationStructureDesc::BottomLevel::Geometry::Type::TRIANGLES)
{
- geometry.geometry.triangles.vertexData.deviceAddress = to_internal(&x.triangles.vertexBuffer)->address +
- x.triangles.vertexByteOffset;
+ geometry.geometry.triangles.vertexData.deviceAddress = to_internal(&x.triangles.vertex_buffer)->address +
+ x.triangles.vertex_byte_offset;
- geometry.geometry.triangles.indexData.deviceAddress = to_internal(&x.triangles.indexBuffer)->address +
- x.triangles.indexOffset * (x.triangles.indexFormat == INDEXBUFFER_FORMAT::INDEXFORMAT_16BIT ? sizeof(uint16_t) : sizeof(uint32_t));
+ geometry.geometry.triangles.indexData.deviceAddress = to_internal(&x.triangles.index_buffer)->address +
+ x.triangles.index_offset * (x.triangles.index_format == IndexBufferFormat::UINT16 ? sizeof(uint16_t) : sizeof(uint32_t));
- if (x._flags & RaytracingAccelerationStructureDesc::BottomLevel::Geometry::FLAG_USE_TRANSFORM)
+ if (x.flags & RaytracingAccelerationStructureDesc::BottomLevel::Geometry::FLAG_USE_TRANSFORM)
{
- geometry.geometry.triangles.transformData.deviceAddress = to_internal(&x.triangles.transform3x4Buffer)->address;
- range.transformOffset = x.triangles.transform3x4BufferOffset;
+ geometry.geometry.triangles.transformData.deviceAddress = to_internal(&x.triangles.transform_3x4_buffer)->address;
+ range.transformOffset = x.triangles.transform_3x4_buffer_offset;
}
- range.primitiveCount = x.triangles.indexCount / 3;
+ range.primitiveCount = x.triangles.index_count / 3;
range.primitiveOffset = 0;
}
- else if (x.type == RaytracingAccelerationStructureDesc::BottomLevel::Geometry::PROCEDURAL_AABBS)
+ else if (x.type == RaytracingAccelerationStructureDesc::BottomLevel::Geometry::Type::PROCEDURAL_AABBS)
{
- geometry.geometry.aabbs.data.deviceAddress = to_internal(&x.aabbs.aabbBuffer)->address;
+ geometry.geometry.aabbs.data.deviceAddress = to_internal(&x.aabbs.aabb_buffer)->address;
range.primitiveCount = x.aabbs.count;
range.primitiveOffset = x.aabbs.offset;
@@ -7087,16 +7087,16 @@ using namespace Vulkan_Internal;
}
}
break;
- case RaytracingAccelerationStructureDesc::TOPLEVEL:
+ case RaytracingAccelerationStructureDesc::Type::TOPLEVEL:
{
auto& geometry = geometries.back();
- geometry.geometry.instances.data.deviceAddress = to_internal(&dst->desc.toplevel.instanceBuffer)->address;
+ geometry.geometry.instances.data.deviceAddress = to_internal(&dst->desc.top_level.instance_buffer)->address;
ranges.emplace_back();
auto& range = ranges.back();
range = {};
- range.primitiveCount = dst->desc.toplevel.count;
- range.primitiveOffset = dst->desc.toplevel.offset;
+ range.primitiveCount = dst->desc.top_level.count;
+ range.primitiveOffset = dst->desc.top_level.offset;
}
break;
}
@@ -7117,7 +7117,7 @@ using namespace Vulkan_Internal;
prev_pipeline_hash[cmd] = 0;
active_rt[cmd] = rtpso;
- BindComputeShader(rtpso->desc.shaderlibraries.front().shader, cmd);
+ BindComputeShader(rtpso->desc.shader_libraries.front().shader, cmd);
vkCmdBindPipeline(GetCommandList(cmd), VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR, to_internal(rtpso)->pipeline);
}
@@ -7126,9 +7126,9 @@ using namespace Vulkan_Internal;
predispatch(cmd);
VkStridedDeviceAddressRegionKHR raygen = {};
- raygen.deviceAddress = desc->raygeneration.buffer ? to_internal(desc->raygeneration.buffer)->address : 0;
- raygen.deviceAddress += desc->raygeneration.offset;
- raygen.size = desc->raygeneration.size;
+ raygen.deviceAddress = desc->ray_generation.buffer ? to_internal(desc->ray_generation.buffer)->address : 0;
+ raygen.deviceAddress += desc->ray_generation.offset;
+ raygen.size = desc->ray_generation.size;
raygen.stride = raygen.size; // raygen specifically must be size == stride
VkStridedDeviceAddressRegionKHR miss = {};
@@ -7138,10 +7138,10 @@ using namespace Vulkan_Internal;
miss.stride = desc->miss.stride;
VkStridedDeviceAddressRegionKHR hitgroup = {};
- hitgroup.deviceAddress = desc->hitgroup.buffer ? to_internal(desc->hitgroup.buffer)->address : 0;
- hitgroup.deviceAddress += desc->hitgroup.offset;
- hitgroup.size = desc->hitgroup.size;
- hitgroup.stride = desc->hitgroup.stride;
+ hitgroup.deviceAddress = desc->hit_group.buffer ? to_internal(desc->hit_group.buffer)->address : 0;
+ hitgroup.deviceAddress += desc->hit_group.offset;
+ hitgroup.size = desc->hit_group.size;
+ hitgroup.stride = desc->hit_group.stride;
VkStridedDeviceAddressRegionKHR callable = {};
callable.deviceAddress = desc->callable.buffer ? to_internal(desc->callable.buffer)->address : 0;
@@ -7155,9 +7155,9 @@ using namespace Vulkan_Internal;
&miss,
&hitgroup,
&callable,
- desc->Width,
- desc->Height,
- desc->Depth
+ desc->width,
+ desc->height,
+ desc->depth
);
}
void GraphicsDevice_Vulkan::PushConstants(const void* data, uint32_t size, CommandList cmd)
@@ -7165,15 +7165,15 @@ using namespace Vulkan_Internal;
std::memcpy(pushconstants[cmd].data, data, size);
pushconstants[cmd].size = size;
}
- void GraphicsDevice_Vulkan::PredicationBegin(const GPUBuffer* buffer, uint64_t offset, PREDICATION_OP op, CommandList cmd)
+ void GraphicsDevice_Vulkan::PredicationBegin(const GPUBuffer* buffer, uint64_t offset, PredicationOp op, CommandList cmd)
{
- if (CheckCapability(GRAPHICSDEVICE_CAPABILITY_PREDICATION))
+ if (CheckCapability(GraphicsDeviceCapability::PREDICATION))
{
auto internal_state = to_internal(buffer);
VkConditionalRenderingBeginInfoEXT info = {};
info.sType = VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT;
- if (op == PREDICATION_OP_NOT_EQUAL_ZERO)
+ if (op == PredicationOp::NOT_EQUAL_ZERO)
{
info.flags = VK_CONDITIONAL_RENDERING_INVERTED_BIT_EXT;
}
@@ -7184,7 +7184,7 @@ using namespace Vulkan_Internal;
}
void GraphicsDevice_Vulkan::PredicationEnd(CommandList cmd)
{
- if (CheckCapability(GRAPHICSDEVICE_CAPABILITY_PREDICATION))
+ if (CheckCapability(GraphicsDeviceCapability::PREDICATION))
{
vkCmdEndConditionalRenderingEXT(GetCommandList(cmd));
}
diff --git a/WickedEngine/wiGraphicsDevice_Vulkan.h b/WickedEngine/wiGraphicsDevice_Vulkan.h
index c7d186190..fa7c45629 100644
--- a/WickedEngine/wiGraphicsDevice_Vulkan.h
+++ b/WickedEngine/wiGraphicsDevice_Vulkan.h
@@ -28,7 +28,7 @@
namespace wiGraphics
{
- class GraphicsDevice_Vulkan : public GraphicsDevice
+ class GraphicsDevice_Vulkan final : public GraphicsDevice
{
friend struct CommandQueue;
protected:
@@ -165,7 +165,7 @@ namespace wiGraphics
std::vector waits;
} cmd_meta[COMMANDLIST_COUNT];
- inline VkCommandBuffer GetCommandList(CommandList cmd)
+ inline VkCommandBuffer GetCommandList(CommandList::index_type cmd)
{
return GetFrameResources().commandBuffers[cmd][cmd_meta[cmd].queue];
}
@@ -210,7 +210,7 @@ namespace wiGraphics
const Shader* active_cs[COMMANDLIST_COUNT] = {};
const RaytracingPipelineState* active_rt[COMMANDLIST_COUNT] = {};
const RenderPass* active_renderpass[COMMANDLIST_COUNT] = {};
- SHADING_RATE prev_shadingrate[COMMANDLIST_COUNT] = {};
+ ShadingRate prev_shadingrate[COMMANDLIST_COUNT] = {};
std::vector prev_swapchains[COMMANDLIST_COUNT];
uint32_t vb_strides[COMMANDLIST_COUNT][8] = {};
@@ -230,7 +230,7 @@ namespace wiGraphics
void predispatch(CommandList cmd);
- std::atomic cmd_count{ 0 };
+ std::atomic cmd_count{ 0 };
std::vector common_samplers;
@@ -241,7 +241,7 @@ namespace wiGraphics
bool CreateSwapChain(const SwapChainDesc* pDesc, wiPlatform::window_type window, SwapChain* swapChain) const override;
bool CreateBuffer(const GPUBufferDesc *pDesc, const void* 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 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;
@@ -249,13 +249,13 @@ namespace wiGraphics
bool CreateRaytracingAccelerationStructure(const RaytracingAccelerationStructureDesc* pDesc, RaytracingAccelerationStructure* bvh) const override;
bool CreateRaytracingPipelineState(const RaytracingPipelineStateDesc* pDesc, RaytracingPipelineState* rtpso) 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;
+ int CreateSubresource(Texture* texture, SubresourceType type, uint32_t firstSlice, uint32_t sliceCount, uint32_t firstMip, uint32_t mipCount) const override;
+ int CreateSubresource(GPUBuffer* buffer, SubresourceType type, uint64_t offset, uint64_t size = ~0) const override;
- int GetDescriptorIndex(const GPUResource* resource, SUBRESOURCE_TYPE type, int subresource = -1) const override;
+ int GetDescriptorIndex(const GPUResource* resource, SubresourceType type, int subresource = -1) const override;
int GetDescriptorIndex(const Sampler* sampler) const override;
- void WriteShadingRateValue(SHADING_RATE rate, void* dest) const override;
+ void WriteShadingRateValue(ShadingRate rate, void* dest) const override;
void WriteTopLevelAccelerationStructureInstance(const RaytracingAccelerationStructureDesc::TopLevel::Instance* instance, void* dest) const override;
void WriteShaderIdentifier(const RaytracingPipelineState* rtpso, uint32_t group_index, void* dest) const override;
@@ -268,13 +268,14 @@ namespace wiGraphics
void WaitForGPU() const override;
void ClearPipelineStateCache() override;
+ size_t GetActivePipelineCount() const override { return pipelines_global.size(); }
- SHADERFORMAT GetShaderFormat() const override { return SHADERFORMAT_SPIRV; }
+ ShaderFormat GetShaderFormat() const override { return ShaderFormat::SPIRV; }
Texture GetBackBuffer(const SwapChain* swapchain) const override;
- COLOR_SPACE GetSwapChainColorSpace(const SwapChain* swapchain) const override;
- bool GetSwapChainHDRSupport(const SwapChain* swapchain) const override;
+ ColorSpace GetSwapChainColorSpace(const SwapChain* swapchain) const override;
+ bool IsSwapChainSupportsHDR(const SwapChain* swapchain) const override;
///////////////Thread-sensitive////////////////////////
@@ -291,10 +292,10 @@ namespace wiGraphics
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 uint64_t* offsets, CommandList cmd) override;
- void BindIndexBuffer(const GPUBuffer* indexBuffer, const INDEXBUFFER_FORMAT format, uint64_t offset, CommandList cmd) override;
+ void BindIndexBuffer(const GPUBuffer* indexBuffer, const IndexBufferFormat format, uint64_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 BindShadingRate(SHADING_RATE rate, CommandList cmd) override;
+ void BindShadingRate(ShadingRate rate, 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;
@@ -318,7 +319,7 @@ namespace wiGraphics
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;
- void PredicationBegin(const GPUBuffer* buffer, uint64_t offset, PREDICATION_OP op, CommandList cmd) override;
+ void PredicationBegin(const GPUBuffer* buffer, uint64_t offset, PredicationOp op, CommandList cmd) override;
void PredicationEnd(CommandList cmd) override;
void EventBegin(const char* name, CommandList cmd) override;
diff --git a/WickedEngine/wiHairParticle.cpp b/WickedEngine/wiHairParticle.cpp
index 3d5a9e9f6..4f92633fb 100644
--- a/WickedEngine/wiHairParticle.cpp
+++ b/WickedEngine/wiHairParticle.cpp
@@ -49,53 +49,53 @@ void wiHairParticle::UpdateCPU(const TransformComponent& transform, const MeshCo
aabb = AABB(_min, _max);
aabb = aabb.transform(world);
- GraphicsDevice* device = wiRenderer::GetDevice();
+ GraphicsDevice* device = wiGraphics::GetDevice();
- if (_flags & REBUILD_BUFFERS || !constantBuffer.IsValid() || (strandCount * segmentCount) != simulationBuffer.GetDesc().Size / sizeof(PatchSimulationData))
+ if (_flags & REBUILD_BUFFERS || !constantBuffer.IsValid() || (strandCount * segmentCount) != simulationBuffer.GetDesc().size / sizeof(PatchSimulationData))
{
_flags &= ~REBUILD_BUFFERS;
regenerate_frame = true;
GPUBufferDesc bd;
- bd.Usage = USAGE_DEFAULT;
- bd.BindFlags = BIND_SHADER_RESOURCE | BIND_UNORDERED_ACCESS;
- bd.MiscFlags = RESOURCE_MISC_BUFFER_STRUCTURED;
+ bd.usage = Usage::DEFAULT;
+ bd.bind_flags = BindFlag::SHADER_RESOURCE | BindFlag::UNORDERED_ACCESS;
+ bd.misc_flags = ResourceMiscFlag::BUFFER_STRUCTURED;
const uint32_t particleCount = strandCount * segmentCount;
if (particleCount > 0)
{
- bd.Stride = sizeof(PatchSimulationData);
- bd.Size = bd.Stride * particleCount;
+ bd.stride = sizeof(PatchSimulationData);
+ bd.size = bd.stride * particleCount;
device->CreateBuffer(&bd, nullptr, &simulationBuffer);
device->SetName(&simulationBuffer, "simulationBuffer");
- bd.MiscFlags = RESOURCE_MISC_BUFFER_RAW;
- if (device->CheckCapability(GRAPHICSDEVICE_CAPABILITY_RAYTRACING))
+ bd.misc_flags = ResourceMiscFlag::BUFFER_RAW;
+ if (device->CheckCapability(GraphicsDeviceCapability::RAYTRACING))
{
- bd.MiscFlags |= RESOURCE_MISC_RAY_TRACING;
+ bd.misc_flags |= ResourceMiscFlag::RAY_TRACING;
}
- bd.Stride = sizeof(MeshComponent::Vertex_POS);
- bd.Size = bd.Stride * 4 * particleCount;
+ bd.stride = sizeof(MeshComponent::Vertex_POS);
+ bd.size = bd.stride * 4 * particleCount;
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.MiscFlags = RESOURCE_MISC_BUFFER_RAW;
- bd.Stride = sizeof(MeshComponent::Vertex_TEX);
- bd.Size = bd.Stride * 4 * particleCount;
+ bd.misc_flags = ResourceMiscFlag::BUFFER_RAW;
+ bd.stride = sizeof(MeshComponent::Vertex_TEX);
+ bd.size = bd.stride * 4 * particleCount;
device->CreateBuffer(&bd, nullptr, &vertexBuffer_TEX);
device->SetName(&vertexBuffer_TEX, "vertexBuffer_TEX");
- bd.BindFlags = BIND_SHADER_RESOURCE;
- bd.MiscFlags = RESOURCE_MISC_NONE;
- if (device->CheckCapability(GRAPHICSDEVICE_CAPABILITY_RAYTRACING))
+ bd.bind_flags = BindFlag::SHADER_RESOURCE;
+ bd.misc_flags = ResourceMiscFlag::NONE;
+ if (device->CheckCapability(GraphicsDeviceCapability::RAYTRACING))
{
- bd.MiscFlags |= RESOURCE_MISC_RAY_TRACING;
+ bd.misc_flags |= ResourceMiscFlag::RAY_TRACING;
}
- bd.Format = FORMAT_R32_UINT;
- bd.Stride = sizeof(uint);
- bd.Size = bd.Stride * 6 * particleCount;
+ bd.format = Format::R32_UINT;
+ bd.stride = sizeof(uint);
+ bd.size = bd.stride * 6 * particleCount;
std::vector primitiveData(6 * particleCount);
for (uint particleID = 0; particleID < particleCount; ++particleID)
{
@@ -111,19 +111,19 @@ void wiHairParticle::UpdateCPU(const TransformComponent& transform, const MeshCo
device->CreateBuffer(&bd, primitiveData.data(), &primitiveBuffer);
device->SetName(&primitiveBuffer, "primitiveBuffer");
- bd.BindFlags = BIND_INDEX_BUFFER | BIND_UNORDERED_ACCESS;
- bd.MiscFlags = RESOURCE_MISC_NONE;
- bd.Format = FORMAT_R32_UINT;
- bd.Stride = sizeof(uint);
- bd.Size = bd.Stride * 6 * particleCount;
+ bd.bind_flags = BindFlag::INDEX_BUFFER | BindFlag::UNORDERED_ACCESS;
+ bd.misc_flags = ResourceMiscFlag::NONE;
+ bd.format = Format::R32_UINT;
+ bd.stride = sizeof(uint);
+ bd.size = bd.stride * 6 * particleCount;
device->CreateBuffer(&bd, nullptr, &culledIndexBuffer);
device->SetName(&culledIndexBuffer, "culledIndexBuffer");
}
- bd.Usage = USAGE_DEFAULT;
- bd.Size = sizeof(HairParticleCB);
- bd.BindFlags = BIND_CONSTANT_BUFFER;
- bd.MiscFlags = RESOURCE_MISC_NONE;
+ bd.usage = Usage::DEFAULT;
+ bd.size = sizeof(HairParticleCB);
+ bd.bind_flags = BindFlag::CONSTANT_BUFFER;
+ bd.misc_flags = ResourceMiscFlag::NONE;
device->CreateBuffer(&bd, nullptr, &constantBuffer);
device->SetName(&constantBuffer, "constantBuffer");
@@ -158,41 +158,41 @@ void wiHairParticle::UpdateCPU(const TransformComponent& transform, const MeshCo
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.Stride = sizeof(uint8_t);
- bd.Size = bd.Stride * (uint32_t)ulengths.size();
+ bd.misc_flags = ResourceMiscFlag::NONE;
+ bd.bind_flags = BindFlag::SHADER_RESOURCE;
+ bd.format = Format::R8_UNORM;
+ bd.stride = sizeof(uint8_t);
+ bd.size = bd.stride * (uint32_t)ulengths.size();
device->CreateBuffer(&bd, ulengths.data(), &vertexBuffer_length);
}
if (!indices.empty())
{
- bd.MiscFlags = RESOURCE_MISC_NONE;
- bd.BindFlags = BIND_SHADER_RESOURCE;
- bd.Format = FORMAT_R32_UINT;
- bd.Stride = sizeof(uint32_t);
- bd.Size = bd.Stride * (uint32_t)indices.size();
+ bd.misc_flags = ResourceMiscFlag::NONE;
+ bd.bind_flags = BindFlag::SHADER_RESOURCE;
+ bd.format = Format::R32_UINT;
+ bd.stride = sizeof(uint32_t);
+ bd.size = bd.stride * (uint32_t)indices.size();
device->CreateBuffer(&bd, indices.data(), &indexBuffer);
}
- if (device->CheckCapability(GRAPHICSDEVICE_CAPABILITY_RAYTRACING) && primitiveBuffer.IsValid())
+ if (device->CheckCapability(GraphicsDeviceCapability::RAYTRACING) && primitiveBuffer.IsValid())
{
RaytracingAccelerationStructureDesc desc;
- desc.type = RaytracingAccelerationStructureDesc::BOTTOMLEVEL;
- desc._flags |= RaytracingAccelerationStructureDesc::FLAG_ALLOW_UPDATE;
- desc._flags |= RaytracingAccelerationStructureDesc::FLAG_PREFER_FAST_BUILD;
+ desc.type = RaytracingAccelerationStructureDesc::Type::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 = (uint32_t)(primitiveBuffer.desc.Size / primitiveBuffer.desc.Stride);
- geometry.triangles.indexOffset = 0;
- geometry.triangles.vertexCount = (uint32_t)(vertexBuffer_POS[0].desc.Size / vertexBuffer_POS[0].desc.Stride);
- geometry.triangles.vertexFormat = FORMAT_R32G32B32_FLOAT;
- geometry.triangles.vertexStride = sizeof(MeshComponent::Vertex_POS);
+ desc.bottom_level.geometries.emplace_back();
+ auto& geometry = desc.bottom_level.geometries.back();
+ geometry.type = RaytracingAccelerationStructureDesc::BottomLevel::Geometry::Type::TRIANGLES;
+ geometry.triangles.vertex_buffer = vertexBuffer_POS[0];
+ geometry.triangles.index_buffer = primitiveBuffer;
+ geometry.triangles.index_format = IndexBufferFormat::UINT32;
+ geometry.triangles.index_count = (uint32_t)(primitiveBuffer.desc.size / primitiveBuffer.desc.stride);
+ geometry.triangles.index_offset = 0;
+ geometry.triangles.vertex_count = (uint32_t)(vertexBuffer_POS[0].desc.size / vertexBuffer_POS[0].desc.stride);
+ geometry.triangles.vertex_format = Format::R32G32B32_FLOAT;
+ geometry.triangles.vertex_stride = sizeof(MeshComponent::Vertex_POS);
bool success = device->CreateRaytracingAccelerationStructure(&desc, &BLAS);
assert(success);
@@ -203,27 +203,27 @@ void wiHairParticle::UpdateCPU(const TransformComponent& transform, const MeshCo
if (!indirectBuffer.IsValid())
{
GPUBufferDesc desc;
- desc.Size = sizeof(uint) + sizeof(IndirectDrawArgsIndexedInstanced); // counter + draw args
- desc.MiscFlags = RESOURCE_MISC_BUFFER_RAW | RESOURCE_MISC_INDIRECT_ARGS;
- desc.BindFlags = BIND_UNORDERED_ACCESS;
+ desc.size = sizeof(uint) + sizeof(IndirectDrawArgsIndexedInstanced); // counter + draw args
+ desc.misc_flags = ResourceMiscFlag::BUFFER_RAW | ResourceMiscFlag::INDIRECT_ARGS;
+ desc.bind_flags = BindFlag::UNORDERED_ACCESS;
device->CreateBuffer(&desc, nullptr, &indirectBuffer);
}
if (!subsetBuffer.IsValid())
{
GPUBufferDesc desc;
- desc.Stride = sizeof(ShaderMeshSubset);
- desc.Size = desc.Stride;
- desc.MiscFlags = RESOURCE_MISC_BUFFER_RAW;
- desc.BindFlags = BIND_SHADER_RESOURCE;
+ desc.stride = sizeof(ShaderMeshSubset);
+ desc.size = desc.stride;
+ desc.misc_flags = ResourceMiscFlag::BUFFER_RAW;
+ desc.bind_flags = BindFlag::SHADER_RESOURCE;
device->CreateBuffer(&desc, nullptr, &subsetBuffer);
}
std::swap(vertexBuffer_POS[0], vertexBuffer_POS[1]);
- if (BLAS.IsValid() && !BLAS.desc.bottomlevel.geometries.empty())
+ if (BLAS.IsValid() && !BLAS.desc.bottom_level.geometries.empty())
{
- BLAS.desc.bottomlevel.geometries.back().triangles.vertexBuffer = vertexBuffer_POS[0];
+ BLAS.desc.bottom_level.geometries.back().triangles.vertex_buffer = vertexBuffer_POS[0];
}
}
@@ -234,7 +234,7 @@ void wiHairParticle::UpdateGPU(uint32_t instanceIndex, uint32_t materialIndex, c
return;
}
- GraphicsDevice* device = wiRenderer::GetDevice();
+ GraphicsDevice* device = wiGraphics::GetDevice();
device->EventBegin("HairParticle - UpdateGPU", cmd);
TextureDesc desc;
@@ -261,7 +261,7 @@ void wiHairParticle::UpdateGPU(uint32_t instanceIndex, uint32_t materialIndex, c
hcb.xHairFrameCount = std::max(1u, frameCount);
hcb.xHairFrameStart = frameStart;
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.xHairAspect = (float)std::max(1u, desc.width) / (float)std::max(1u, desc.height);
hcb.xHairLayerMask = layerMask;
hcb.xHairInstanceIndex = instanceIndex;
device->UpdateBuffer(&constantBuffer, &hcb, cmd);
@@ -274,8 +274,8 @@ void wiHairParticle::UpdateGPU(uint32_t instanceIndex, uint32_t materialIndex, c
{
GPUBarrier barriers[] = {
- GPUBarrier::Buffer(&constantBuffer, RESOURCE_STATE_COPY_DST, RESOURCE_STATE_CONSTANT_BUFFER),
- GPUBarrier::Buffer(&subsetBuffer, RESOURCE_STATE_COPY_DST, RESOURCE_STATE_SHADER_RESOURCE),
+ GPUBarrier::Buffer(&constantBuffer, ResourceState::COPY_DST, ResourceState::CONSTANT_BUFFER),
+ GPUBarrier::Buffer(&subsetBuffer, ResourceState::COPY_DST, ResourceState::SHADER_RESOURCE),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
@@ -323,10 +323,10 @@ void wiHairParticle::UpdateGPU(uint32_t instanceIndex, uint32_t materialIndex, c
GPUBarrier barriers[] = {
GPUBarrier::Memory(&indirectBuffer),
- 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(&culledIndexBuffer, RESOURCE_STATE_UNORDERED_ACCESS, RESOURCE_STATE_INDEX_BUFFER),
+ GPUBarrier::Buffer(&indirectBuffer, ResourceState::UNORDERED_ACCESS, ResourceState::INDIRECT_ARGUMENT),
+ GPUBarrier::Buffer(&vertexBuffer_POS[0], ResourceState::UNORDERED_ACCESS, ResourceState::SHADER_RESOURCE),
+ GPUBarrier::Buffer(&vertexBuffer_TEX, ResourceState::UNORDERED_ACCESS, ResourceState::SHADER_RESOURCE),
+ GPUBarrier::Buffer(&culledIndexBuffer, ResourceState::UNORDERED_ACCESS, ResourceState::INDEX_BUFFER),
};
device->Barrier(barriers, arraysize(barriers), cmd);
@@ -344,7 +344,7 @@ void wiHairParticle::Draw(const MaterialComponent& material, RENDERPASS renderPa
return;
}
- GraphicsDevice* device = wiRenderer::GetDevice();
+ GraphicsDevice* device = wiGraphics::GetDevice();
device->EventBegin("HairParticle - Draw", cmd);
device->BindStencilRef(STENCILREF_DEFAULT, cmd);
@@ -371,7 +371,7 @@ void wiHairParticle::Draw(const MaterialComponent& material, RENDERPASS renderPa
device->BindConstantBuffer(&constantBuffer, CB_GETBINDSLOT(HairParticleCB), cmd);
device->BindResource(&primitiveBuffer, 0, cmd);
- device->BindIndexBuffer(&culledIndexBuffer, INDEXFORMAT_32BIT, 0, cmd);
+ device->BindIndexBuffer(&culledIndexBuffer, IndexBufferFormat::UINT32, 0, cmd);
device->DrawIndexedInstancedIndirect(&indirectBuffer, 4, cmd);
@@ -439,18 +439,16 @@ namespace wiHairParticle_Internal
{
void LoadShaders()
{
- std::string path = wiRenderer::GetShaderPath();
+ wiRenderer::LoadShader(ShaderStage::VS, vs, "hairparticleVS.cso");
- wiRenderer::LoadShader(VS, vs, "hairparticleVS.cso");
+ wiRenderer::LoadShader(ShaderStage::PS, ps_simple, "hairparticlePS_simple.cso");
+ wiRenderer::LoadShader(ShaderStage::PS, ps_prepass, "hairparticlePS_prepass.cso");
+ wiRenderer::LoadShader(ShaderStage::PS, ps, "hairparticlePS.cso");
- wiRenderer::LoadShader(PS, ps_simple, "hairparticlePS_simple.cso");
- wiRenderer::LoadShader(PS, ps_prepass, "hairparticlePS_prepass.cso");
- wiRenderer::LoadShader(PS, ps, "hairparticlePS.cso");
+ wiRenderer::LoadShader(ShaderStage::CS, cs_simulate, "hairparticle_simulateCS.cso");
+ wiRenderer::LoadShader(ShaderStage::CS, cs_finishUpdate, "hairparticle_finishUpdateCS.cso");
- wiRenderer::LoadShader(CS, cs_simulate, "hairparticle_simulateCS.cso");
- wiRenderer::LoadShader(CS, cs_finishUpdate, "hairparticle_finishUpdateCS.cso");
-
- GraphicsDevice* device = wiRenderer::GetDevice();
+ GraphicsDevice* device = wiGraphics::GetDevice();
for (int i = 0; i < RENDERPASS_COUNT; ++i)
{
@@ -461,7 +459,7 @@ namespace wiHairParticle_Internal
desc.bs = &bs;
desc.rs = &ncrs;
desc.dss = &dss_default;
- desc.pt = TRIANGLELIST;
+ desc.pt = PrimitiveTopology::TRIANGLELIST;
switch (i)
{
@@ -485,7 +483,7 @@ namespace wiHairParticle_Internal
desc.bs = &bs;
desc.rs = &wirers;
desc.dss = &dss_default;
- desc.pt = TRIANGLELIST;
+ desc.pt = PrimitiveTopology::TRIANGLELIST;
device->CreatePipelineState(&desc, &PSO_wire);
}
@@ -498,67 +496,67 @@ void wiHairParticle::Initialize()
wiTimer timer;
RasterizerState rsd;
- rsd.FillMode = FILL_SOLID;
- rsd.CullMode = CULL_BACK;
- rsd.FrontCounterClockwise = true;
- rsd.DepthBias = 0;
- rsd.DepthBiasClamp = 0;
- rsd.SlopeScaledDepthBias = 0;
- rsd.DepthClipEnable = true;
- rsd.MultisampleEnable = false;
- rsd.AntialiasedLineEnable = false;
+ rsd.fill_mode = FillMode::SOLID;
+ rsd.cull_mode = CullMode::BACK;
+ rsd.front_counter_clockwise = true;
+ rsd.depth_bias = 0;
+ rsd.depth_bias_clamp = 0;
+ rsd.slope_scaled_depth_bias = 0;
+ rsd.depth_clip_enable = true;
+ rsd.multisample_enable = false;
+ rsd.antialiased_line_enable = false;
rs = rsd;
- rsd.FillMode = FILL_SOLID;
- rsd.CullMode = CULL_NONE;
- rsd.FrontCounterClockwise = true;
- rsd.DepthBias = 0;
- rsd.DepthBiasClamp = 0;
- rsd.SlopeScaledDepthBias = 0;
- rsd.DepthClipEnable = true;
- rsd.MultisampleEnable = false;
- rsd.AntialiasedLineEnable = false;
+ rsd.fill_mode = FillMode::SOLID;
+ rsd.cull_mode = CullMode::NONE;
+ rsd.front_counter_clockwise = true;
+ rsd.depth_bias = 0;
+ rsd.depth_bias_clamp = 0;
+ rsd.slope_scaled_depth_bias = 0;
+ rsd.depth_clip_enable = true;
+ rsd.multisample_enable = false;
+ rsd.antialiased_line_enable = false;
ncrs = rsd;
- rsd.FillMode = FILL_WIREFRAME;
- rsd.CullMode = CULL_NONE;
- rsd.FrontCounterClockwise = true;
- rsd.DepthBias = 0;
- rsd.DepthBiasClamp = 0;
- rsd.SlopeScaledDepthBias = 0;
- rsd.DepthClipEnable = true;
- rsd.MultisampleEnable = false;
- rsd.AntialiasedLineEnable = false;
+ rsd.fill_mode = FillMode::WIREFRAME;
+ rsd.cull_mode = CullMode::NONE;
+ rsd.front_counter_clockwise = true;
+ rsd.depth_bias = 0;
+ rsd.depth_bias_clamp = 0;
+ rsd.slope_scaled_depth_bias = 0;
+ rsd.depth_clip_enable = true;
+ rsd.multisample_enable = false;
+ rsd.antialiased_line_enable = false;
wirers = rsd;
DepthStencilState dsd;
- dsd.DepthEnable = true;
- dsd.DepthWriteMask = DEPTH_WRITE_MASK_ALL;
- dsd.DepthFunc = COMPARISON_GREATER;
+ dsd.depth_enable = true;
+ dsd.depth_write_mask = DepthWriteMask::ALL;
+ dsd.depth_func = ComparisonFunc::GREATER;
- dsd.StencilEnable = true;
- dsd.StencilReadMask = 0xFF;
- dsd.StencilWriteMask = 0xFF;
- dsd.FrontFace.StencilFunc = COMPARISON_ALWAYS;
- dsd.FrontFace.StencilPassOp = STENCIL_OP_REPLACE;
- dsd.FrontFace.StencilFailOp = STENCIL_OP_KEEP;
- dsd.FrontFace.StencilDepthFailOp = STENCIL_OP_KEEP;
- dsd.BackFace.StencilFunc = COMPARISON_ALWAYS;
- dsd.BackFace.StencilPassOp = STENCIL_OP_REPLACE;
- dsd.BackFace.StencilFailOp = STENCIL_OP_KEEP;
- dsd.BackFace.StencilDepthFailOp = STENCIL_OP_KEEP;
+ dsd.stencil_enable = true;
+ dsd.stencil_read_mask = 0xFF;
+ dsd.stencil_write_mask = 0xFF;
+ dsd.front_face.stencil_func = ComparisonFunc::ALWAYS;
+ dsd.front_face.stencil_pass_op = StencilOp::REPLACE;
+ dsd.front_face.stencil_fail_op = StencilOp::KEEP;
+ dsd.front_face.stencil_depth_fail_op = StencilOp::KEEP;
+ dsd.back_face.stencil_func = ComparisonFunc::ALWAYS;
+ dsd.back_face.stencil_pass_op = StencilOp::REPLACE;
+ dsd.back_face.stencil_fail_op = StencilOp::KEEP;
+ dsd.back_face.stencil_depth_fail_op = StencilOp::KEEP;
dss_default = dsd;
- dsd.DepthWriteMask = DEPTH_WRITE_MASK_ZERO;
- dsd.DepthFunc = COMPARISON_EQUAL;
- dsd.StencilEnable = false;
+ dsd.depth_write_mask = DepthWriteMask::ZERO;
+ dsd.depth_func = ComparisonFunc::EQUAL;
+ dsd.stencil_enable = false;
dss_equal = dsd;
BlendState bld;
- bld.RenderTarget[0].BlendEnable = false;
- bld.AlphaToCoverageEnable = false; // maybe for msaa
+ bld.render_target[0].blend_enable = false;
+ bld.alpha_to_coverage_enable = false; // maybe for msaa
bs = bld;
static wiEvent::Handle handle = wiEvent::Subscribe(SYSTEM_EVENT_RELOAD_SHADERS, [](uint64_t userdata) { wiHairParticle_Internal::LoadShaders(); });
diff --git a/WickedEngine/wiHelper.cpp b/WickedEngine/wiHelper.cpp
index 99f4e6a9d..c40b01a34 100644
--- a/WickedEngine/wiHelper.cpp
+++ b/WickedEngine/wiHelper.cpp
@@ -1,6 +1,5 @@
#include "wiHelper.h"
#include "wiPlatform.h"
-#include "wiRenderer.h"
#include "wiBackLog.h"
#include "wiEvent.h"
@@ -90,7 +89,7 @@ namespace wiHelper
filename = directory + "/sc_" + getCurrentDateTimeAsString() + ".jpg";
}
- bool result = saveTextureToFile(wiRenderer::GetDevice()->GetBackBuffer(&swapchain), filename);
+ bool result = saveTextureToFile(wiGraphics::GetDevice()->GetBackBuffer(&swapchain), filename);
assert(result);
if (result)
@@ -104,17 +103,17 @@ namespace wiHelper
{
using namespace wiGraphics;
- GraphicsDevice* device = wiRenderer::GetDevice();
+ GraphicsDevice* device = wiGraphics::GetDevice();
TextureDesc desc = texture.GetDesc();
Texture stagingTex;
TextureDesc staging_desc = desc;
- staging_desc.Usage = USAGE_READBACK;
- staging_desc.MipLevels = 1;
- staging_desc.layout = RESOURCE_STATE_COPY_DST;
- staging_desc.BindFlags = BIND_NONE;
- staging_desc.MiscFlags = RESOURCE_MISC_NONE;
+ staging_desc.usage = Usage::READBACK;
+ staging_desc.mip_levels = 1;
+ staging_desc.layout = ResourceState::COPY_DST;
+ staging_desc.bind_flags = BindFlag::NONE;
+ staging_desc.misc_flags = ResourceMiscFlag::NONE;
bool success = device->CreateTexture(&staging_desc, nullptr, &stagingTex);
assert(success);
@@ -122,7 +121,7 @@ namespace wiHelper
{
GPUBarrier barriers[] = {
- GPUBarrier::Image(&texture,texture.desc.layout,RESOURCE_STATE_COPY_SRC),
+ GPUBarrier::Image(&texture,texture.desc.layout,ResourceState::COPY_SRC),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
@@ -131,7 +130,7 @@ namespace wiHelper
{
GPUBarrier barriers[] = {
- GPUBarrier::Image(&texture,RESOURCE_STATE_COPY_SRC,texture.desc.layout),
+ GPUBarrier::Image(&texture,ResourceState::COPY_SRC,texture.desc.layout),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
@@ -139,10 +138,10 @@ namespace wiHelper
device->SubmitCommandLists();
device->WaitForGPU();
- desc.Width /= GetFormatBlockSize(desc.Format);
- desc.Height /= GetFormatBlockSize(desc.Format);
- uint32_t data_count = desc.Width * desc.Height;
- uint32_t data_stride = GetFormatStride(desc.Format);
+ desc.width /= GetFormatBlockSize(desc.format);
+ desc.height /= GetFormatBlockSize(desc.format);
+ uint32_t data_count = desc.width * desc.height;
+ uint32_t data_stride = GetFormatStride(desc.format);
uint32_t data_size = data_count * data_stride;
texturedata.clear();
@@ -150,11 +149,11 @@ namespace wiHelper
if (stagingTex.mapped_data != nullptr)
{
- if (stagingTex.mapped_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)
+ const uint32_t cpysize = desc.width * data_stride;
+ for (uint32_t i = 0; i < desc.height; ++i)
{
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));
@@ -190,14 +189,14 @@ namespace wiHelper
bool saveTextureToMemoryFile(const std::vector& texturedata, const wiGraphics::TextureDesc& desc, const std::string& fileExtension, std::vector& filedata)
{
using namespace wiGraphics;
- uint32_t data_count = desc.Width * desc.Height;
+ uint32_t data_count = desc.width * desc.height;
std::string extension = wiHelper::toUpper(fileExtension);
bool basis = !extension.compare("BASIS");
bool ktx2 = !extension.compare("KTX2");
basisu::image basis_image;
- if (desc.Format == FORMAT_R10G10B10A2_UNORM)
+ if (desc.format == Format::R10G10B10A2_UNORM)
{
// This will be converted first to rgba8 before saving to common format:
uint32_t* data32 = (uint32_t*)texturedata.data();
@@ -219,7 +218,7 @@ namespace wiHelper
data32[i] = rgba8;
}
}
- else if (desc.Format == FORMAT_R32G32B32A32_FLOAT)
+ else if (desc.format == Format::R32G32B32A32_FLOAT)
{
// This will be converted first to rgba8 before saving to common format:
XMFLOAT4* dataSrc = (XMFLOAT4*)texturedata.data();
@@ -242,7 +241,7 @@ namespace wiHelper
data32[i] = rgba8;
}
}
- else if (desc.Format == FORMAT_R16G16B16A16_FLOAT)
+ else if (desc.format == Format::R16G16B16A16_FLOAT)
{
// This will be converted first to rgba8 before saving to common format:
XMHALF4* dataSrc = (XMHALF4*)texturedata.data();
@@ -265,7 +264,7 @@ namespace wiHelper
data32[i] = rgba8;
}
}
- else if (desc.Format == FORMAT_R11G11B10_FLOAT)
+ else if (desc.format == Format::R11G11B10_FLOAT)
{
// This will be converted first to rgba8 before saving to common format:
XMFLOAT3PK* dataSrc = (XMFLOAT3PK*)texturedata.data();
@@ -291,48 +290,48 @@ namespace wiHelper
data32[i] = rgba8;
}
}
- else if (IsFormatBlockCompressed(desc.Format))
+ else if (IsFormatBlockCompressed(desc.format))
{
basisu::texture_format fmt;
- switch (desc.Format)
+ switch (desc.format)
{
default:
assert(0);
return false;
- case FORMAT_BC1_UNORM:
- case FORMAT_BC1_UNORM_SRGB:
+ case Format::BC1_UNORM:
+ case Format::BC1_UNORM_SRGB:
fmt = basisu::texture_format::cBC1;
break;
- case FORMAT_BC3_UNORM:
- case FORMAT_BC3_UNORM_SRGB:
+ case Format::BC3_UNORM:
+ case Format::BC3_UNORM_SRGB:
fmt = basisu::texture_format::cBC3;
break;
- case FORMAT_BC4_UNORM:
+ case Format::BC4_UNORM:
fmt = basisu::texture_format::cBC4;
break;
- case FORMAT_BC5_UNORM:
+ case Format::BC5_UNORM:
fmt = basisu::texture_format::cBC5;
break;
- case FORMAT_BC7_UNORM:
- case FORMAT_BC7_UNORM_SRGB:
+ case Format::BC7_UNORM:
+ case Format::BC7_UNORM_SRGB:
fmt = basisu::texture_format::cBC7;
break;
}
basisu::gpu_image basis_gpu_image;
- basis_gpu_image.init(fmt, desc.Width, desc.Height);
+ basis_gpu_image.init(fmt, desc.width, desc.height);
std::memcpy(basis_gpu_image.get_ptr(), texturedata.data(), std::min(texturedata.size(), (size_t)basis_gpu_image.get_size_in_bytes()));
basis_gpu_image.unpack(basis_image);
}
else
{
- assert(desc.Format == FORMAT_R8G8B8A8_UNORM); // If you need to save other texture format, implement data conversion for it
+ assert(desc.format == Format::R8G8B8A8_UNORM); // If you need to save other texture format, implement data conversion for it
}
if (basis || ktx2)
{
if (basis_image.get_total_pixels() == 0)
{
- basis_image.init(texturedata.data(), desc.Width, desc.Height, 4);
+ basis_image.init(texturedata.data(), desc.width, desc.height, 4);
}
basisu::basis_compressor_params params;
params.m_source_images.push_back(basis_image);
@@ -400,19 +399,19 @@ namespace wiHelper
if (!extension.compare("JPG") || !extension.compare("JPEG"))
{
- write_result = stbi_write_jpg_to_func(func, &filedata, (int)desc.Width, (int)desc.Height, 4, src_data, 100);
+ write_result = stbi_write_jpg_to_func(func, &filedata, (int)desc.width, (int)desc.height, 4, src_data, 100);
}
else if (!extension.compare("PNG"))
{
- write_result = stbi_write_png_to_func(func, &filedata, (int)desc.Width, (int)desc.Height, 4, src_data, 0);
+ write_result = stbi_write_png_to_func(func, &filedata, (int)desc.width, (int)desc.height, 4, src_data, 0);
}
else if (!extension.compare("TGA"))
{
- write_result = stbi_write_tga_to_func(func, &filedata, (int)desc.Width, (int)desc.Height, 4, src_data);
+ write_result = stbi_write_tga_to_func(func, &filedata, (int)desc.width, (int)desc.height, 4, src_data);
}
else if (!extension.compare("BMP"))
{
- write_result = stbi_write_bmp_to_func(func, &filedata, (int)desc.Width, (int)desc.Height, 4, src_data);
+ write_result = stbi_write_bmp_to_func(func, &filedata, (int)desc.width, (int)desc.height, 4, src_data);
}
else
{
diff --git a/WickedEngine/wiImage.cpp b/WickedEngine/wiImage.cpp
index 1203dcf6f..fa512eb16 100644
--- a/WickedEngine/wiImage.cpp
+++ b/WickedEngine/wiImage.cpp
@@ -52,7 +52,7 @@ namespace wiImage
return;
}
- GraphicsDevice* device = wiRenderer::GetDevice();
+ GraphicsDevice* device = wiGraphics::GetDevice();
device->EventBegin("Image", cmd);
uint32_t stencilRef = params.stencilRef;
@@ -93,11 +93,11 @@ namespace wiImage
}
PushConstantsImage push;
- push.texture_base_index = device->GetDescriptorIndex(texture, SRV);
- push.texture_mask_index = device->GetDescriptorIndex(params.maskMap, SRV);
+ push.texture_base_index = device->GetDescriptorIndex(texture, SubresourceType::SRV);
+ push.texture_mask_index = device->GetDescriptorIndex(params.maskMap, SubresourceType::SRV);
if (params.isBackgroundEnabled())
{
- push.texture_background_index = device->GetDescriptorIndex(&backgroundTextures[cmd], SRV);
+ push.texture_background_index = device->GetDescriptorIndex(&backgroundTextures[cmd], SubresourceType::SRV);
}
else
{
@@ -196,8 +196,8 @@ namespace wiImage
}
const TextureDesc& desc = texture->GetDesc();
- const float inv_width = 1.0f / float(desc.Width);
- const float inv_height = 1.0f / float(desc.Height);
+ const float inv_width = 1.0f / float(desc.width);
+ const float inv_height = 1.0f / float(desc.height);
XMFLOAT4 texMulAdd;
if (params.isDrawRectEnabled())
@@ -255,16 +255,14 @@ namespace wiImage
void LoadShaders()
{
- std::string path = wiRenderer::GetShaderPath();
+ wiRenderer::LoadShader(ShaderStage::VS, vertexShader, "imageVS.cso");
+ wiRenderer::LoadShader(ShaderStage::VS, screenVS, "screenVS.cso");
- wiRenderer::LoadShader(VS, vertexShader, "imageVS.cso");
- wiRenderer::LoadShader(VS, screenVS, "screenVS.cso");
-
- wiRenderer::LoadShader(PS, imagePS[IMAGE_SHADER_STANDARD], "imagePS.cso");
- wiRenderer::LoadShader(PS, imagePS[IMAGE_SHADER_FULLSCREEN], "screenPS.cso");
+ wiRenderer::LoadShader(ShaderStage::PS, imagePS[IMAGE_SHADER_STANDARD], "imagePS.cso");
+ wiRenderer::LoadShader(ShaderStage::PS, imagePS[IMAGE_SHADER_FULLSCREEN], "screenPS.cso");
- GraphicsDevice* device = wiRenderer::GetDevice();
+ GraphicsDevice* device = wiGraphics::GetDevice();
for (int i = 0; i < IMAGE_SHADER_COUNT; ++i)
{
@@ -275,7 +273,7 @@ namespace wiImage
desc.vs = &screenVS;
}
desc.rs = &rasterizerState;
- desc.pt = TRIANGLESTRIP;
+ desc.pt = PrimitiveTopology::TRIANGLESTRIP;
desc.ps = &imagePS[i];
@@ -302,18 +300,18 @@ namespace wiImage
{
wiTimer timer;
- GraphicsDevice* device = wiRenderer::GetDevice();
+ GraphicsDevice* device = wiGraphics::GetDevice();
RasterizerState rs;
- rs.FillMode = FILL_SOLID;
- rs.CullMode = CULL_NONE;
- rs.FrontCounterClockwise = false;
- rs.DepthBias = 0;
- rs.DepthBiasClamp = 0;
- rs.SlopeScaledDepthBias = 0;
- rs.DepthClipEnable = true;
- rs.MultisampleEnable = false;
- rs.AntialiasedLineEnable = false;
+ rs.fill_mode = FillMode::SOLID;
+ rs.cull_mode = CullMode::NONE;
+ rs.front_counter_clockwise = false;
+ rs.depth_bias = 0;
+ rs.depth_bias_clamp = 0;
+ rs.slope_scaled_depth_bias = 0;
+ rs.depth_clip_enable = true;
+ rs.multisample_enable = false;
+ rs.antialiased_line_enable = false;
rasterizerState = rs;
@@ -322,109 +320,109 @@ namespace wiImage
for (int i = 0; i < STENCILREFMODE_COUNT; ++i)
{
DepthStencilState dsd;
- dsd.DepthEnable = false;
- dsd.StencilEnable = false;
+ dsd.depth_enable = false;
+ dsd.stencil_enable = false;
depthStencilStates[STENCILMODE_DISABLED][i] = dsd;
- dsd.StencilEnable = true;
+ dsd.stencil_enable = true;
switch (i)
{
case STENCILREFMODE_ENGINE:
- dsd.StencilReadMask = STENCILREF_MASK_ENGINE;
+ dsd.stencil_read_mask = STENCILREF_MASK_ENGINE;
break;
case STENCILREFMODE_USER:
- dsd.StencilReadMask = STENCILREF_MASK_USER;
+ dsd.stencil_read_mask = STENCILREF_MASK_USER;
break;
default:
- dsd.StencilReadMask = STENCILREF_MASK_ALL;
+ dsd.stencil_read_mask = STENCILREF_MASK_ALL;
break;
}
- dsd.StencilWriteMask = 0;
- dsd.FrontFace.StencilPassOp = STENCIL_OP_KEEP;
- dsd.FrontFace.StencilFailOp = STENCIL_OP_KEEP;
- dsd.FrontFace.StencilDepthFailOp = STENCIL_OP_KEEP;
- dsd.BackFace.StencilPassOp = STENCIL_OP_KEEP;
- dsd.BackFace.StencilFailOp = STENCIL_OP_KEEP;
- dsd.BackFace.StencilDepthFailOp = STENCIL_OP_KEEP;
+ dsd.stencil_write_mask = 0;
+ dsd.front_face.stencil_pass_op = StencilOp::KEEP;
+ dsd.front_face.stencil_fail_op = StencilOp::KEEP;
+ dsd.front_face.stencil_depth_fail_op = StencilOp::KEEP;
+ dsd.back_face.stencil_pass_op = StencilOp::KEEP;
+ dsd.back_face.stencil_fail_op = StencilOp::KEEP;
+ dsd.back_face.stencil_depth_fail_op = StencilOp::KEEP;
- dsd.FrontFace.StencilFunc = COMPARISON_EQUAL;
- dsd.BackFace.StencilFunc = COMPARISON_EQUAL;
+ dsd.front_face.stencil_func = ComparisonFunc::EQUAL;
+ dsd.back_face.stencil_func = ComparisonFunc::EQUAL;
depthStencilStates[STENCILMODE_EQUAL][i] = dsd;
- dsd.FrontFace.StencilFunc = COMPARISON_LESS;
- dsd.BackFace.StencilFunc = COMPARISON_LESS;
+ dsd.front_face.stencil_func = ComparisonFunc::LESS;
+ dsd.back_face.stencil_func = ComparisonFunc::LESS;
depthStencilStates[STENCILMODE_LESS][i] = dsd;
- dsd.FrontFace.StencilFunc = COMPARISON_LESS_EQUAL;
- dsd.BackFace.StencilFunc = COMPARISON_LESS_EQUAL;
+ dsd.front_face.stencil_func = ComparisonFunc::LESS_EQUAL;
+ dsd.back_face.stencil_func = ComparisonFunc::LESS_EQUAL;
depthStencilStates[STENCILMODE_LESSEQUAL][i] = dsd;
- dsd.FrontFace.StencilFunc = COMPARISON_GREATER;
- dsd.BackFace.StencilFunc = COMPARISON_GREATER;
+ dsd.front_face.stencil_func = ComparisonFunc::GREATER;
+ dsd.back_face.stencil_func = ComparisonFunc::GREATER;
depthStencilStates[STENCILMODE_GREATER][i] = dsd;
- dsd.FrontFace.StencilFunc = COMPARISON_GREATER_EQUAL;
- dsd.BackFace.StencilFunc = COMPARISON_GREATER_EQUAL;
+ dsd.front_face.stencil_func = ComparisonFunc::GREATER_EQUAL;
+ dsd.back_face.stencil_func = ComparisonFunc::GREATER_EQUAL;
depthStencilStates[STENCILMODE_GREATEREQUAL][i] = dsd;
- dsd.FrontFace.StencilFunc = COMPARISON_NOT_EQUAL;
- dsd.BackFace.StencilFunc = COMPARISON_NOT_EQUAL;
+ dsd.front_face.stencil_func = ComparisonFunc::NOT_EQUAL;
+ dsd.back_face.stencil_func = ComparisonFunc::NOT_EQUAL;
depthStencilStates[STENCILMODE_NOT][i] = dsd;
- dsd.FrontFace.StencilFunc = COMPARISON_ALWAYS;
- dsd.BackFace.StencilFunc = COMPARISON_ALWAYS;
+ dsd.front_face.stencil_func = ComparisonFunc::ALWAYS;
+ dsd.back_face.stencil_func = ComparisonFunc::ALWAYS;
depthStencilStates[STENCILMODE_ALWAYS][i] = dsd;
}
BlendState bd;
- bd.RenderTarget[0].BlendEnable = true;
- bd.RenderTarget[0].SrcBlend = BLEND_SRC_ALPHA;
- bd.RenderTarget[0].DestBlend = BLEND_INV_SRC_ALPHA;
- bd.RenderTarget[0].BlendOp = BLEND_OP_ADD;
- bd.RenderTarget[0].SrcBlendAlpha = BLEND_ONE;
- bd.RenderTarget[0].DestBlendAlpha = BLEND_INV_SRC_ALPHA;
- bd.RenderTarget[0].BlendOpAlpha = BLEND_OP_ADD;
- bd.RenderTarget[0].RenderTargetWriteMask = COLOR_WRITE_ENABLE_ALL;
- bd.IndependentBlendEnable = false;
+ bd.render_target[0].blend_enable = true;
+ bd.render_target[0].src_blend = Blend::SRC_ALPHA;
+ bd.render_target[0].dest_blend = Blend::INV_SRC_ALPHA;
+ bd.render_target[0].blend_op = BlendOp::ADD;
+ bd.render_target[0].src_blend_alpha = Blend::ONE;
+ bd.render_target[0].dest_blend_alpha = Blend::INV_SRC_ALPHA;
+ bd.render_target[0].blend_op_alpha = BlendOp::ADD;
+ bd.render_target[0].render_target_write_mask = ColorWrite::ENABLE_ALL;
+ bd.independent_blend_enable = false;
blendStates[BLENDMODE_ALPHA] = bd;
- bd.RenderTarget[0].BlendEnable = true;
- bd.RenderTarget[0].SrcBlend = BLEND_ONE;
- bd.RenderTarget[0].DestBlend = BLEND_INV_SRC_ALPHA;
- bd.RenderTarget[0].BlendOp = BLEND_OP_ADD;
- bd.RenderTarget[0].SrcBlendAlpha = BLEND_ONE;
- bd.RenderTarget[0].DestBlendAlpha = BLEND_INV_SRC_ALPHA;
- bd.RenderTarget[0].BlendOpAlpha = BLEND_OP_ADD;
- bd.RenderTarget[0].RenderTargetWriteMask = COLOR_WRITE_ENABLE_ALL;
- bd.IndependentBlendEnable = false;
+ bd.render_target[0].blend_enable = true;
+ bd.render_target[0].src_blend = Blend::ONE;
+ bd.render_target[0].dest_blend = Blend::INV_SRC_ALPHA;
+ bd.render_target[0].blend_op = BlendOp::ADD;
+ bd.render_target[0].src_blend_alpha = Blend::ONE;
+ bd.render_target[0].dest_blend_alpha = Blend::INV_SRC_ALPHA;
+ bd.render_target[0].blend_op_alpha = BlendOp::ADD;
+ bd.render_target[0].render_target_write_mask = ColorWrite::ENABLE_ALL;
+ bd.independent_blend_enable = false;
blendStates[BLENDMODE_PREMULTIPLIED] = bd;
- bd.RenderTarget[0].BlendEnable = false;
- bd.RenderTarget[0].RenderTargetWriteMask = COLOR_WRITE_ENABLE_ALL;
- bd.IndependentBlendEnable = false;
+ bd.render_target[0].blend_enable = false;
+ bd.render_target[0].render_target_write_mask = ColorWrite::ENABLE_ALL;
+ bd.independent_blend_enable = false;
blendStates[BLENDMODE_OPAQUE] = bd;
- bd.RenderTarget[0].BlendEnable = true;
- bd.RenderTarget[0].SrcBlend = BLEND_SRC_ALPHA;
- bd.RenderTarget[0].DestBlend = BLEND_ONE;
- bd.RenderTarget[0].BlendOp = BLEND_OP_ADD;
- bd.RenderTarget[0].SrcBlendAlpha = BLEND_ZERO;
- bd.RenderTarget[0].DestBlendAlpha = BLEND_ONE;
- bd.RenderTarget[0].BlendOpAlpha = BLEND_OP_ADD;
- bd.RenderTarget[0].RenderTargetWriteMask = COLOR_WRITE_ENABLE_ALL;
- bd.IndependentBlendEnable = false;
+ bd.render_target[0].blend_enable = true;
+ bd.render_target[0].src_blend = Blend::SRC_ALPHA;
+ bd.render_target[0].dest_blend = Blend::ONE;
+ bd.render_target[0].blend_op = BlendOp::ADD;
+ bd.render_target[0].src_blend_alpha = Blend::ZERO;
+ bd.render_target[0].dest_blend_alpha = Blend::ONE;
+ bd.render_target[0].blend_op_alpha = BlendOp::ADD;
+ bd.render_target[0].render_target_write_mask = ColorWrite::ENABLE_ALL;
+ bd.independent_blend_enable = false;
blendStates[BLENDMODE_ADDITIVE] = bd;
- bd.RenderTarget[0].BlendEnable = true;
- bd.RenderTarget[0].SrcBlend = BLEND_ZERO;
- bd.RenderTarget[0].DestBlend = BLEND_SRC_COLOR;
- bd.RenderTarget[0].BlendOp = BLEND_OP_ADD;
- bd.RenderTarget[0].SrcBlendAlpha = BLEND_ZERO;
- bd.RenderTarget[0].DestBlendAlpha = BLEND_SRC_ALPHA;
- bd.RenderTarget[0].BlendOpAlpha = BLEND_OP_ADD;
- bd.RenderTarget[0].RenderTargetWriteMask = COLOR_WRITE_ENABLE_ALL;
- bd.IndependentBlendEnable = false;
+ bd.render_target[0].blend_enable = true;
+ bd.render_target[0].src_blend = Blend::ZERO;
+ bd.render_target[0].dest_blend = Blend::SRC_COLOR;
+ bd.render_target[0].blend_op = BlendOp::ADD;
+ bd.render_target[0].src_blend_alpha = Blend::ZERO;
+ bd.render_target[0].dest_blend_alpha = Blend::SRC_ALPHA;
+ bd.render_target[0].blend_op_alpha = BlendOp::ADD;
+ bd.render_target[0].render_target_write_mask = ColorWrite::ENABLE_ALL;
+ bd.independent_blend_enable = false;
blendStates[BLENDMODE_MULTIPLY] = bd;
static wiEvent::Handle handle = wiEvent::Subscribe(SYSTEM_EVENT_RELOAD_SHADERS, [](uint64_t userdata) { LoadShaders(); });
diff --git a/WickedEngine/wiOcean.cpp b/WickedEngine/wiOcean.cpp
index 9b75eda43..04b2ebba1 100644
--- a/WickedEngine/wiOcean.cpp
+++ b/WickedEngine/wiOcean.cpp
@@ -34,20 +34,17 @@ namespace wiOcean_Internal
void LoadShaders()
{
+ wiRenderer::LoadShader(ShaderStage::CS, updateSpectrumCS, "oceanSimulatorCS.cso");
+ wiRenderer::LoadShader(ShaderStage::CS, updateDisplacementMapCS, "oceanUpdateDisplacementMapCS.cso");
+ wiRenderer::LoadShader(ShaderStage::CS, updateGradientFoldingCS, "oceanUpdateGradientFoldingCS.cso");
- std::string path = wiRenderer::GetShaderPath();
+ wiRenderer::LoadShader(ShaderStage::VS, oceanSurfVS, "oceanSurfaceVS.cso");
- wiRenderer::LoadShader(CS, updateSpectrumCS, "oceanSimulatorCS.cso");
- wiRenderer::LoadShader(CS, updateDisplacementMapCS, "oceanUpdateDisplacementMapCS.cso");
- wiRenderer::LoadShader(CS, updateGradientFoldingCS, "oceanUpdateGradientFoldingCS.cso");
-
- wiRenderer::LoadShader(VS, oceanSurfVS, "oceanSurfaceVS.cso");
-
- wiRenderer::LoadShader(PS, oceanSurfPS, "oceanSurfacePS.cso");
- wiRenderer::LoadShader(PS, wireframePS, "oceanSurfaceSimplePS.cso");
+ wiRenderer::LoadShader(ShaderStage::PS, oceanSurfPS, "oceanSurfacePS.cso");
+ wiRenderer::LoadShader(ShaderStage::PS, wireframePS, "oceanSurfaceSimplePS.cso");
- GraphicsDevice* device = wiRenderer::GetDevice();
+ GraphicsDevice* device = wiGraphics::GetDevice();
{
PipelineStateDesc desc;
@@ -105,7 +102,7 @@ float Phillips(XMFLOAT2 K, XMFLOAT2 W, float v, float a, float dir_depend)
void wiOcean::Create(const OceanParameters& params)
{
- GraphicsDevice* device = wiRenderer::GetDevice();
+ GraphicsDevice* device = wiGraphics::GetDevice();
// Height map H(0)
int height_map_size = (params.dmap_dim + 4) * (params.dmap_dim + 1);
@@ -124,61 +121,61 @@ void wiOcean::Create(const OceanParameters& params)
std::fill(zero_data.begin(), zero_data.end(), 0);
GPUBufferDesc buf_desc;
- buf_desc.Usage = USAGE_DEFAULT;
- buf_desc.BindFlags = BIND_UNORDERED_ACCESS | BIND_SHADER_RESOURCE;
- buf_desc.MiscFlags = RESOURCE_MISC_BUFFER_STRUCTURED;
+ buf_desc.usage = Usage::DEFAULT;
+ buf_desc.bind_flags = BindFlag::UNORDERED_ACCESS | BindFlag::SHADER_RESOURCE;
+ buf_desc.misc_flags = ResourceMiscFlag::BUFFER_STRUCTURED;
// RW buffer allocations
// H0
- buf_desc.Stride = sizeof(float2);
- buf_desc.Size = buf_desc.Stride * input_full_size;
+ buf_desc.stride = sizeof(float2);
+ buf_desc.size = buf_desc.stride * input_full_size;
device->CreateBuffer(&buf_desc, h0_data.data(), &buffer_Float2_H0);
// Notice: The following 3 buffers should be half sized buffer because of conjugate symmetric input. But
// we use full sized buffers due to the CS4.0 restriction.
// Put H(t), Dx(t) and Dy(t) into one buffer because CS4.0 allows only 1 UAV at a time
- buf_desc.Stride = sizeof(float2);
- buf_desc.Size = buf_desc.Stride * 3 * input_half_size;
+ buf_desc.stride = sizeof(float2);
+ buf_desc.size = buf_desc.stride * 3 * input_half_size;
device->CreateBuffer(&buf_desc, zero_data.data(), &buffer_Float2_Ht);
// omega
- buf_desc.Stride = sizeof(float);
- buf_desc.Size = buf_desc.Stride * input_full_size;
+ buf_desc.stride = sizeof(float);
+ buf_desc.size = buf_desc.stride * input_full_size;
device->CreateBuffer(&buf_desc, omega_data.data(), &buffer_Float_Omega);
// Notice: The following 3 should be real number data. But here we use the complex numbers and C2C FFT
// due to the CS4.0 restriction.
// Put Dz, Dx and Dy into one buffer because CS4.0 allows only 1 UAV at a time
- buf_desc.Stride = sizeof(float2);
- buf_desc.Size = buf_desc.Stride * 3 * output_size;
+ buf_desc.stride = sizeof(float2);
+ buf_desc.size = buf_desc.stride * 3 * output_size;
device->CreateBuffer(&buf_desc, zero_data.data(), &buffer_Float_Dxyz);
TextureDesc tex_desc;
- tex_desc.Width = hmap_dim;
- tex_desc.Height = hmap_dim;
- tex_desc.ArraySize = 1;
- tex_desc.SampleCount = 1;
- tex_desc.Usage = USAGE_DEFAULT;
- tex_desc.BindFlags = BIND_SHADER_RESOURCE | BIND_UNORDERED_ACCESS;
+ tex_desc.width = hmap_dim;
+ tex_desc.height = hmap_dim;
+ tex_desc.array_size = 1;
+ tex_desc.sample_count = 1;
+ tex_desc.usage = Usage::DEFAULT;
+ tex_desc.bind_flags = BindFlag::SHADER_RESOURCE | BindFlag::UNORDERED_ACCESS;
- tex_desc.Format = FORMAT_R16G16B16A16_FLOAT;
- tex_desc.MipLevels = 0;
- tex_desc.layout = RESOURCE_STATE_SHADER_RESOURCE_COMPUTE;
+ tex_desc.format = Format::R16G16B16A16_FLOAT;
+ tex_desc.mip_levels = 0;
+ tex_desc.layout = ResourceState::SHADER_RESOURCE_COMPUTE;
device->CreateTexture(&tex_desc, nullptr, &gradientMap);
device->SetName(&gradientMap, "gradientMap");
- for (uint32_t i = 0; i < gradientMap.GetDesc().MipLevels; ++i)
+ for (uint32_t i = 0; i < gradientMap.GetDesc().mip_levels; ++i)
{
int subresource_index;
- subresource_index = device->CreateSubresource(&gradientMap, SRV, 0, 1, i, 1);
+ subresource_index = device->CreateSubresource(&gradientMap, SubresourceType::SRV, 0, 1, i, 1);
assert(subresource_index == i);
- subresource_index = device->CreateSubresource(&gradientMap, UAV, 0, 1, i, 1);
+ subresource_index = device->CreateSubresource(&gradientMap, SubresourceType::UAV, 0, 1, i, 1);
assert(subresource_index == i);
}
- tex_desc.Format = FORMAT_R32G32B32A32_FLOAT;
- tex_desc.MipLevels = 1;
+ tex_desc.format = Format::R32G32B32A32_FLOAT;
+ tex_desc.mip_levels = 1;
device->CreateTexture(&tex_desc, nullptr, &displacementMap);
device->SetName(&displacementMap, "displacementMap");
@@ -194,13 +191,13 @@ void wiOcean::Create(const OceanParameters& params)
Ocean_Simulation_ImmutableCB immutable_consts = { actual_dim, input_width, output_width, output_height, dtx_offset, dty_offset };
GPUBufferDesc cb_desc;
- cb_desc.BindFlags = BIND_CONSTANT_BUFFER;
- cb_desc.Size = sizeof(Ocean_Simulation_ImmutableCB);
+ cb_desc.bind_flags = BindFlag::CONSTANT_BUFFER;
+ cb_desc.size = sizeof(Ocean_Simulation_ImmutableCB);
device->CreateBuffer(&cb_desc, &immutable_consts, &immutableCB);
- cb_desc.Usage = USAGE_DEFAULT;
- cb_desc.BindFlags = BIND_CONSTANT_BUFFER;
- cb_desc.Size = sizeof(Ocean_Simulation_PerFrameCB);
+ cb_desc.usage = Usage::DEFAULT;
+ cb_desc.bind_flags = BindFlag::CONSTANT_BUFFER;
+ cb_desc.size = sizeof(Ocean_Simulation_PerFrameCB);
device->CreateBuffer(&cb_desc, nullptr, &perFrameCB);
}
@@ -253,7 +250,7 @@ void wiOcean::initHeightMap(const OceanParameters& params, XMFLOAT2* out_h0, flo
void wiOcean::UpdateDisplacementMap(const OceanParameters& params, CommandList cmd) const
{
- GraphicsDevice* device = wiRenderer::GetDevice();
+ GraphicsDevice* device = wiGraphics::GetDevice();
device->EventBegin("Ocean Simulation", cmd);
@@ -278,14 +275,14 @@ void wiOcean::UpdateDisplacementMap(const OceanParameters& params, CommandList c
{
GPUBarrier barriers[] = {
- GPUBarrier::Buffer(&perFrameCB, RESOURCE_STATE_CONSTANT_BUFFER, RESOURCE_STATE_COPY_DST),
+ GPUBarrier::Buffer(&perFrameCB, ResourceState::CONSTANT_BUFFER, ResourceState::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),
+ GPUBarrier::Buffer(&perFrameCB, ResourceState::COPY_DST, ResourceState::CONSTANT_BUFFER),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
@@ -324,14 +321,14 @@ void wiOcean::UpdateDisplacementMap(const OceanParameters& params, CommandList c
device->BindResources(cs_srvs, TEXSLOT_ONDEMAND0, 1, cmd);
{
GPUBarrier barriers[] = {
- GPUBarrier::Image(&displacementMap, displacementMap.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS),
+ GPUBarrier::Image(&displacementMap, displacementMap.desc.layout, ResourceState::UNORDERED_ACCESS),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
device->Dispatch(params.dmap_dim / OCEAN_COMPUTE_TILESIZE, params.dmap_dim / OCEAN_COMPUTE_TILESIZE, 1, cmd);
{
GPUBarrier barriers[] = {
- GPUBarrier::Image(&displacementMap, RESOURCE_STATE_UNORDERED_ACCESS, displacementMap.desc.layout),
+ GPUBarrier::Image(&displacementMap, ResourceState::UNORDERED_ACCESS, displacementMap.desc.layout),
GPUBarrier::Memory(),
};
device->Barrier(barriers, arraysize(barriers), cmd);
@@ -345,14 +342,14 @@ void wiOcean::UpdateDisplacementMap(const OceanParameters& params, CommandList c
device->BindResources(cs_srvs, TEXSLOT_ONDEMAND0, 1, cmd);
{
GPUBarrier barriers[] = {
- GPUBarrier::Image(&gradientMap, gradientMap.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS),
+ GPUBarrier::Image(&gradientMap, gradientMap.desc.layout, ResourceState::UNORDERED_ACCESS),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
device->Dispatch(params.dmap_dim / OCEAN_COMPUTE_TILESIZE, params.dmap_dim / OCEAN_COMPUTE_TILESIZE, 1, cmd);
{
GPUBarrier barriers[] = {
- GPUBarrier::Image(&gradientMap, RESOURCE_STATE_UNORDERED_ACCESS, gradientMap.desc.layout),
+ GPUBarrier::Image(&gradientMap, ResourceState::UNORDERED_ACCESS, gradientMap.desc.layout),
GPUBarrier::Memory(),
};
device->Barrier(barriers, arraysize(barriers), cmd);
@@ -369,7 +366,7 @@ void wiOcean::UpdateDisplacementMap(const OceanParameters& params, CommandList c
void wiOcean::Render(const CameraComponent& camera, const OceanParameters& params, CommandList cmd) const
{
- GraphicsDevice* device = wiRenderer::GetDevice();
+ GraphicsDevice* device = wiGraphics::GetDevice();
device->EventBegin("Ocean Rendering", cmd);
@@ -411,42 +408,42 @@ void wiOcean::Initialize()
{
wiTimer timer;
- GraphicsDevice* device = wiRenderer::GetDevice();
+ GraphicsDevice* device = wiGraphics::GetDevice();
RasterizerState ras_desc;
- ras_desc.FillMode = FILL_SOLID;
- ras_desc.CullMode = CULL_NONE;
- ras_desc.FrontCounterClockwise = false;
- ras_desc.DepthBias = 0;
- ras_desc.SlopeScaledDepthBias = 0.0f;
- ras_desc.DepthBiasClamp = 0.0f;
- ras_desc.DepthClipEnable = true;
- ras_desc.MultisampleEnable = true;
- ras_desc.AntialiasedLineEnable = false;
+ ras_desc.fill_mode = FillMode::SOLID;
+ ras_desc.cull_mode = CullMode::NONE;
+ ras_desc.front_counter_clockwise = false;
+ ras_desc.depth_bias = 0;
+ ras_desc.slope_scaled_depth_bias = 0.0f;
+ ras_desc.depth_bias_clamp = 0.0f;
+ ras_desc.depth_clip_enable = true;
+ ras_desc.multisample_enable = true;
+ ras_desc.antialiased_line_enable = false;
rasterizerState = ras_desc;
- ras_desc.FillMode = FILL_WIREFRAME;
+ ras_desc.fill_mode = FillMode::WIREFRAME;
wireRS = ras_desc;
DepthStencilState depth_desc;
- depth_desc.DepthEnable = true;
- depth_desc.DepthWriteMask = DEPTH_WRITE_MASK_ALL;
- depth_desc.DepthFunc = COMPARISON_GREATER;
- depth_desc.StencilEnable = false;
+ depth_desc.depth_enable = true;
+ depth_desc.depth_write_mask = DepthWriteMask::ALL;
+ depth_desc.depth_func = ComparisonFunc::GREATER;
+ depth_desc.stencil_enable = false;
depthStencilState = depth_desc;
BlendState blend_desc;
- blend_desc.AlphaToCoverageEnable = false;
- blend_desc.IndependentBlendEnable = false;
- blend_desc.RenderTarget[0].BlendEnable = true;
- blend_desc.RenderTarget[0].SrcBlend = BLEND_SRC_ALPHA;
- blend_desc.RenderTarget[0].DestBlend = BLEND_INV_SRC_ALPHA;
- blend_desc.RenderTarget[0].BlendOp = BLEND_OP_ADD;
- blend_desc.RenderTarget[0].SrcBlendAlpha = BLEND_ONE;
- blend_desc.RenderTarget[0].DestBlendAlpha = BLEND_ZERO;
- blend_desc.RenderTarget[0].BlendOpAlpha = BLEND_OP_ADD;
- blend_desc.RenderTarget[0].RenderTargetWriteMask = COLOR_WRITE_ENABLE_ALL;
+ blend_desc.alpha_to_coverage_enable = false;
+ blend_desc.independent_blend_enable = false;
+ blend_desc.render_target[0].blend_enable = true;
+ blend_desc.render_target[0].src_blend = Blend::SRC_ALPHA;
+ blend_desc.render_target[0].dest_blend = Blend::INV_SRC_ALPHA;
+ blend_desc.render_target[0].blend_op = BlendOp::ADD;
+ blend_desc.render_target[0].src_blend_alpha = Blend::ONE;
+ blend_desc.render_target[0].dest_blend_alpha = Blend::ZERO;
+ blend_desc.render_target[0].blend_op_alpha = BlendOp::ADD;
+ blend_desc.render_target[0].render_target_write_mask = ColorWrite::ENABLE_ALL;
blendState = blend_desc;
diff --git a/WickedEngine/wiProfiler.cpp b/WickedEngine/wiProfiler.cpp
index 8211dde93..ada7c8237 100644
--- a/WickedEngine/wiProfiler.cpp
+++ b/WickedEngine/wiProfiler.cpp
@@ -1,6 +1,5 @@
#include "wiProfiler.h"
#include "wiGraphicsDevice.h"
-#include "wiRenderer.h"
#include "wiFont.h"
#include "wiImage.h"
#include "wiTimer.h"
@@ -35,14 +34,14 @@ namespace wiProfiler
float times[20] = {};
int avg_counter = 0;
float time = 0;
- CommandList cmd = COMMANDLIST_COUNT;
+ CommandList cmd = INVALID_COMMANDLIST;
wiTimer cpuTimer;
int gpuBegin[arraysize(queryResultBuffer)];
int gpuEnd[arraysize(queryResultBuffer)];
- bool IsCPURange() const { return cmd == COMMANDLIST_COUNT; }
+ bool IsCPURange() const { return cmd == INVALID_COMMANDLIST; }
};
std::unordered_map ranges;
@@ -57,17 +56,17 @@ namespace wiProfiler
ranges.reserve(100);
- GraphicsDevice* device = wiRenderer::GetDevice();
+ GraphicsDevice* device = wiGraphics::GetDevice();
GPUQueryHeapDesc desc;
- desc.type = GPU_QUERY_TYPE_TIMESTAMP;
- desc.queryCount = 1024;
+ desc.type = GpuQueryType::TIMESTAMP;
+ desc.query_count = 1024;
bool success = device->CreateQueryHeap(&desc, &queryHeap);
assert(success);
GPUBufferDesc bd;
- bd.Usage = USAGE_READBACK;
- bd.Size = desc.queryCount * sizeof(uint64_t);
+ bd.usage = Usage::READBACK;
+ bd.size = desc.query_count * sizeof(uint64_t);
for (int i = 0; i < arraysize(queryResultBuffer); ++i)
{
@@ -78,13 +77,13 @@ namespace wiProfiler
cpu_frame = BeginRangeCPU("CPU Frame");
- GraphicsDevice* device = wiRenderer::GetDevice();
+ GraphicsDevice* device = wiGraphics::GetDevice();
CommandList cmd = device->BeginCommandList();
device->QueryReset(
&queryHeap,
0,
- queryHeap.desc.queryCount,
+ queryHeap.desc.query_count,
cmd
);
@@ -95,7 +94,7 @@ namespace wiProfiler
if (!ENABLED || !initialized)
return;
- GraphicsDevice* device = wiRenderer::GetDevice();
+ GraphicsDevice* device = wiGraphics::GetDevice();
// note: read the GPU Frame end range manually because it will be on a separate command list than start point:
auto& gpu_range = ranges[gpu_frame];
@@ -195,7 +194,7 @@ namespace wiProfiler
ranges[id].cmd = cmd;
ranges[id].gpuBegin[queryheap_idx] = nextQuery.fetch_add(1);
- wiRenderer::GetDevice()->QueryEnd(&queryHeap, ranges[id].gpuBegin[queryheap_idx], cmd);
+ wiGraphics::GetDevice()->QueryEnd(&queryHeap, ranges[id].gpuBegin[queryheap_idx], cmd);
lock.unlock();
@@ -218,7 +217,7 @@ namespace wiProfiler
else
{
ranges[id].gpuEnd[queryheap_idx] = nextQuery.fetch_add(1);
- wiRenderer::GetDevice()->QueryEnd(&queryHeap, it->second.gpuEnd[queryheap_idx], it->second.cmd);
+ wiGraphics::GetDevice()->QueryEnd(&queryHeap, it->second.gpuEnd[queryheap_idx], it->second.cmd);
}
}
else
diff --git a/WickedEngine/wiRenderer.cpp b/WickedEngine/wiRenderer.cpp
index 5a7a53499..b3275dc6e 100644
--- a/WickedEngine/wiRenderer.cpp
+++ b/WickedEngine/wiRenderer.cpp
@@ -38,7 +38,7 @@ using namespace wiAllocators;
namespace wiRenderer
{
-std::shared_ptr device;
+GraphicsDevice*& device = GetDevice();
Shader shaders[SHADERTYPE_COUNT];
Texture textures[TEXTYPE_COUNT];
@@ -149,140 +149,6 @@ Texture texture_detailNoise;
Texture texture_curlNoise;
Texture texture_weatherMap;
-
-void SetDevice(std::shared_ptr newDevice)
-{
- device = newDevice;
-
- SamplerDesc samplerDesc;
- samplerDesc.Filter = FILTER_MIN_MAG_MIP_LINEAR;
- samplerDesc.AddressU = TEXTURE_ADDRESS_MIRROR;
- samplerDesc.AddressV = TEXTURE_ADDRESS_MIRROR;
- samplerDesc.AddressW = TEXTURE_ADDRESS_MIRROR;
- samplerDesc.MipLODBias = 0.0f;
- samplerDesc.MaxAnisotropy = 0;
- samplerDesc.ComparisonFunc = COMPARISON_NEVER;
- samplerDesc.BorderColor = SAMPLER_BORDER_COLOR_TRANSPARENT_BLACK;
- samplerDesc.MinLOD = 0;
- samplerDesc.MaxLOD = FLT_MAX;
- device->CreateSampler(&samplerDesc, &samplers[SSLOT_LINEAR_MIRROR]);
-
- samplerDesc.Filter = FILTER_MIN_MAG_MIP_LINEAR;
- samplerDesc.AddressU = TEXTURE_ADDRESS_CLAMP;
- samplerDesc.AddressV = TEXTURE_ADDRESS_CLAMP;
- samplerDesc.AddressW = TEXTURE_ADDRESS_CLAMP;
- device->CreateSampler(&samplerDesc, &samplers[SSLOT_LINEAR_CLAMP]);
-
- samplerDesc.Filter = FILTER_MIN_MAG_MIP_LINEAR;
- samplerDesc.AddressU = TEXTURE_ADDRESS_WRAP;
- samplerDesc.AddressV = TEXTURE_ADDRESS_WRAP;
- samplerDesc.AddressW = TEXTURE_ADDRESS_WRAP;
- device->CreateSampler(&samplerDesc, &samplers[SSLOT_LINEAR_WRAP]);
-
- samplerDesc.Filter = FILTER_MIN_MAG_MIP_POINT;
- samplerDesc.AddressU = TEXTURE_ADDRESS_MIRROR;
- samplerDesc.AddressV = TEXTURE_ADDRESS_MIRROR;
- samplerDesc.AddressW = TEXTURE_ADDRESS_MIRROR;
- device->CreateSampler(&samplerDesc, &samplers[SSLOT_POINT_MIRROR]);
-
- samplerDesc.Filter = FILTER_MIN_MAG_MIP_POINT;
- samplerDesc.AddressU = TEXTURE_ADDRESS_WRAP;
- samplerDesc.AddressV = TEXTURE_ADDRESS_WRAP;
- samplerDesc.AddressW = TEXTURE_ADDRESS_WRAP;
- device->CreateSampler(&samplerDesc, &samplers[SSLOT_POINT_WRAP]);
-
-
- samplerDesc.Filter = FILTER_MIN_MAG_MIP_POINT;
- samplerDesc.AddressU = TEXTURE_ADDRESS_CLAMP;
- samplerDesc.AddressV = TEXTURE_ADDRESS_CLAMP;
- samplerDesc.AddressW = TEXTURE_ADDRESS_CLAMP;
- device->CreateSampler(&samplerDesc, &samplers[SSLOT_POINT_CLAMP]);
-
- samplerDesc.Filter = FILTER_ANISOTROPIC;
- samplerDesc.AddressU = TEXTURE_ADDRESS_CLAMP;
- samplerDesc.AddressV = TEXTURE_ADDRESS_CLAMP;
- samplerDesc.AddressW = TEXTURE_ADDRESS_CLAMP;
- samplerDesc.MaxAnisotropy = 16;
- device->CreateSampler(&samplerDesc, &samplers[SSLOT_ANISO_CLAMP]);
-
- samplerDesc.Filter = FILTER_ANISOTROPIC;
- samplerDesc.AddressU = TEXTURE_ADDRESS_WRAP;
- samplerDesc.AddressV = TEXTURE_ADDRESS_WRAP;
- samplerDesc.AddressW = TEXTURE_ADDRESS_WRAP;
- samplerDesc.MaxAnisotropy = 16;
- device->CreateSampler(&samplerDesc, &samplers[SSLOT_ANISO_WRAP]);
-
- samplerDesc.Filter = FILTER_ANISOTROPIC;
- samplerDesc.AddressU = TEXTURE_ADDRESS_MIRROR;
- samplerDesc.AddressV = TEXTURE_ADDRESS_MIRROR;
- samplerDesc.AddressW = TEXTURE_ADDRESS_MIRROR;
- samplerDesc.MaxAnisotropy = 16;
- device->CreateSampler(&samplerDesc, &samplers[SSLOT_ANISO_MIRROR]);
-
- samplerDesc.Filter = FILTER_ANISOTROPIC;
- samplerDesc.AddressU = TEXTURE_ADDRESS_WRAP;
- samplerDesc.AddressV = TEXTURE_ADDRESS_WRAP;
- samplerDesc.AddressW = TEXTURE_ADDRESS_WRAP;
- samplerDesc.MaxAnisotropy = 16;
- device->CreateSampler(&samplerDesc, &samplers[SSLOT_OBJECTSHADER]);
-
- samplerDesc.Filter = FILTER_COMPARISON_MIN_MAG_LINEAR_MIP_POINT;
- samplerDesc.AddressU = TEXTURE_ADDRESS_CLAMP;
- samplerDesc.AddressV = TEXTURE_ADDRESS_CLAMP;
- samplerDesc.AddressW = TEXTURE_ADDRESS_CLAMP;
- samplerDesc.MipLODBias = 0.0f;
- samplerDesc.MaxAnisotropy = 0;
- samplerDesc.ComparisonFunc = COMPARISON_GREATER_EQUAL;
- device->CreateSampler(&samplerDesc, &samplers[SSLOT_CMP_DEPTH]);
-
-
- StaticSampler sam;
-
- sam.sampler = samplers[SSLOT_CMP_DEPTH];
- sam.slot = SSLOT_CMP_DEPTH;
- device->SetCommonSampler(&sam);
-
- sam.sampler = samplers[SSLOT_LINEAR_MIRROR];
- sam.slot = SSLOT_LINEAR_MIRROR;
- device->SetCommonSampler(&sam);
-
- sam.sampler = samplers[SSLOT_LINEAR_CLAMP];
- sam.slot = SSLOT_LINEAR_CLAMP;
- device->SetCommonSampler(&sam);
-
- sam.sampler = samplers[SSLOT_LINEAR_WRAP];
- sam.slot = SSLOT_LINEAR_WRAP;
- device->SetCommonSampler(&sam);
-
- sam.sampler = samplers[SSLOT_POINT_MIRROR];
- sam.slot = SSLOT_POINT_MIRROR;
- device->SetCommonSampler(&sam);
-
- sam.sampler = samplers[SSLOT_POINT_WRAP];
- sam.slot = SSLOT_POINT_WRAP;
- device->SetCommonSampler(&sam);
-
- sam.sampler = samplers[SSLOT_POINT_CLAMP];
- sam.slot = SSLOT_POINT_CLAMP;
- device->SetCommonSampler(&sam);
-
- sam.sampler = samplers[SSLOT_ANISO_CLAMP];
- sam.slot = SSLOT_ANISO_CLAMP;
- device->SetCommonSampler(&sam);
-
- sam.sampler = samplers[SSLOT_ANISO_WRAP];
- sam.slot = SSLOT_ANISO_WRAP;
- device->SetCommonSampler(&sam);
-
- sam.sampler = samplers[SSLOT_ANISO_MIRROR];
- sam.slot = SSLOT_ANISO_MIRROR;
- device->SetCommonSampler(&sam);
-}
-GraphicsDevice* GetDevice()
-{
- return device.get();
-}
-
// Direct reference to a renderable instance:
struct RenderBatch
{
@@ -518,12 +384,12 @@ SHADERTYPE GetGSTYPE(RENDERPASS renderPass, bool alphatest, bool transparent)
realGS = GSTYPE_VOXELIZER;
break;
case RENDERPASS_ENVMAPCAPTURE:
- if (device->CheckCapability(GRAPHICSDEVICE_CAPABILITY_RENDERTARGET_AND_VIEWPORT_ARRAYINDEX_WITHOUT_GS))
+ if (device->CheckCapability(GraphicsDeviceCapability::RENDERTARGET_AND_VIEWPORT_ARRAYINDEX_WITHOUT_GS))
break;
realGS = GSTYPE_ENVMAP_EMULATION;
break;
case RENDERPASS_SHADOWCUBE:
- if (device->CheckCapability(GRAPHICSDEVICE_CAPABILITY_RENDERTARGET_AND_VIEWPORT_ARRAYINDEX_WITHOUT_GS))
+ if (device->CheckCapability(GraphicsDeviceCapability::RENDERTARGET_AND_VIEWPORT_ARRAYINDEX_WITHOUT_GS))
break;
if (transparent)
{
@@ -748,7 +614,7 @@ size_t GetShaderDumpCount()
}
#endif // SHADERDUMP
-bool LoadShader(SHADERSTAGE stage, Shader& shader, const std::string& filename, SHADERMODEL minshadermodel)
+bool LoadShader(ShaderStage stage, Shader& shader, const std::string& filename, ShaderModel minshadermodel)
{
std::string shaderbinaryfilename = SHADERPATH + filename;
@@ -818,328 +684,328 @@ void LoadShaders()
wiJobSystem::Execute(ctx, [](wiJobArgs args) {
inputLayouts[ILTYPE_OBJECT_DEBUG].elements =
{
- { "POSITION_NORMAL_WIND", 0, MeshComponent::Vertex_POS::FORMAT, 0, InputLayout::APPEND_ALIGNED_ELEMENT, INPUT_PER_VERTEX_DATA },
+ { "POSITION_NORMAL_WIND", 0, MeshComponent::Vertex_POS::FORMAT, 0, InputLayout::APPEND_ALIGNED_ELEMENT, InputClassification::PER_VERTEX_DATA },
};
- LoadShader(VS, shaders[VSTYPE_OBJECT_DEBUG], "objectVS_debug.cso");
+ LoadShader(ShaderStage::VS, shaders[VSTYPE_OBJECT_DEBUG], "objectVS_debug.cso");
});
wiJobSystem::Execute(ctx, [](wiJobArgs args) {
- LoadShader(VS, shaders[VSTYPE_OBJECT_COMMON], "objectVS_common.cso");
+ LoadShader(ShaderStage::VS, shaders[VSTYPE_OBJECT_COMMON], "objectVS_common.cso");
});
wiJobSystem::Execute(ctx, [](wiJobArgs args) {
- LoadShader(VS, shaders[VSTYPE_OBJECT_PREPASS], "objectVS_prepass.cso");
+ LoadShader(ShaderStage::VS, shaders[VSTYPE_OBJECT_PREPASS], "objectVS_prepass.cso");
});
wiJobSystem::Execute(ctx, [](wiJobArgs args) {
- LoadShader(VS, shaders[VSTYPE_OBJECT_PREPASS_ALPHATEST], "objectVS_prepass_alphatest.cso");
+ LoadShader(ShaderStage::VS, shaders[VSTYPE_OBJECT_PREPASS_ALPHATEST], "objectVS_prepass_alphatest.cso");
});
wiJobSystem::Execute(ctx, [](wiJobArgs args) {
- LoadShader(VS, shaders[VSTYPE_SHADOW], "shadowVS.cso");
+ LoadShader(ShaderStage::VS, shaders[VSTYPE_SHADOW], "shadowVS.cso");
});
wiJobSystem::Execute(ctx, [](wiJobArgs args) {
- 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");
+ LoadShader(ShaderStage::VS, shaders[VSTYPE_OBJECT_SIMPLE], "objectVS_simple.cso");
+ LoadShader(ShaderStage::VS, shaders[VSTYPE_SHADOW_ALPHATEST], "shadowVS_alphatest.cso");
+ LoadShader(ShaderStage::VS, shaders[VSTYPE_SHADOW_TRANSPARENT], "shadowVS_transparent.cso");
});
wiJobSystem::Execute(ctx, [](wiJobArgs args) {
inputLayouts[ILTYPE_VERTEXCOLOR].elements =
{
- { "POSITION", 0, FORMAT_R32G32B32A32_FLOAT, 0, InputLayout::APPEND_ALIGNED_ELEMENT, INPUT_PER_VERTEX_DATA },
- { "TEXCOORD", 0, FORMAT_R32G32B32A32_FLOAT, 0, InputLayout::APPEND_ALIGNED_ELEMENT, INPUT_PER_VERTEX_DATA },
+ { "POSITION", 0, Format::R32G32B32A32_FLOAT, 0, InputLayout::APPEND_ALIGNED_ELEMENT, InputClassification::PER_VERTEX_DATA },
+ { "TEXCOORD", 0, Format::R32G32B32A32_FLOAT, 0, InputLayout::APPEND_ALIGNED_ELEMENT, InputClassification::PER_VERTEX_DATA },
};
- LoadShader(VS, shaders[VSTYPE_VERTEXCOLOR], "vertexcolorVS.cso");
+ LoadShader(ShaderStage::VS, shaders[VSTYPE_VERTEXCOLOR], "vertexcolorVS.cso");
});
wiJobSystem::Execute(ctx, [](wiJobArgs args) {
inputLayouts[ILTYPE_RENDERLIGHTMAP].elements =
{
- { "POSITION_NORMAL_WIND", 0, MeshComponent::Vertex_POS::FORMAT, 0, InputLayout::APPEND_ALIGNED_ELEMENT, INPUT_PER_VERTEX_DATA },
- { "ATLAS", 0, MeshComponent::Vertex_TEX::FORMAT, 1, InputLayout::APPEND_ALIGNED_ELEMENT, INPUT_PER_VERTEX_DATA },
+ { "POSITION_NORMAL_WIND", 0, MeshComponent::Vertex_POS::FORMAT, 0, InputLayout::APPEND_ALIGNED_ELEMENT, InputClassification::PER_VERTEX_DATA },
+ { "ATLAS", 0, MeshComponent::Vertex_TEX::FORMAT, 1, InputLayout::APPEND_ALIGNED_ELEMENT, InputClassification::PER_VERTEX_DATA },
};
- LoadShader(VS, shaders[VSTYPE_RENDERLIGHTMAP], "renderlightmapVS.cso");
+ LoadShader(ShaderStage::VS, shaders[VSTYPE_RENDERLIGHTMAP], "renderlightmapVS.cso");
});
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(VS, shaders[VSTYPE_OBJECT_COMMON_TESSELLATION], "objectVS_common_tessellation.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(VS, shaders[VSTYPE_OBJECT_PREPASS_TESSELLATION], "objectVS_prepass_tessellation.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(VS, shaders[VSTYPE_OBJECT_PREPASS_ALPHATEST_TESSELLATION], "objectVS_prepass_alphatest_tessellation.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(VS, shaders[VSTYPE_OBJECT_SIMPLE_TESSELLATION], "objectVS_simple_tessellation.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(VS, shaders[VSTYPE_IMPOSTOR], "impostorVS.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(VS, shaders[VSTYPE_VOLUMETRICLIGHT_DIRECTIONAL], "volumetriclight_directionalVS.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(VS, shaders[VSTYPE_VOLUMETRICLIGHT_POINT], "volumetriclight_pointVS.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(VS, shaders[VSTYPE_VOLUMETRICLIGHT_SPOT], "volumetriclight_spotVS.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(VS, shaders[VSTYPE_LIGHTVISUALIZER_SPOTLIGHT], "vSpotLightVS.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(VS, shaders[VSTYPE_LIGHTVISUALIZER_POINTLIGHT], "vPointLightVS.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(VS, shaders[VSTYPE_SPHERE], "sphereVS.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(VS, shaders[VSTYPE_CUBE], "cubeVS.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(VS, shaders[VSTYPE_SKY], "skyVS.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(VS, shaders[VSTYPE_VOXELIZER], "objectVS_voxelizer.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(VS, shaders[VSTYPE_VOXEL], "voxelVS.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(VS, shaders[VSTYPE_FORCEFIELDVISUALIZER_POINT], "forceFieldPointVisualizerVS.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(VS, shaders[VSTYPE_FORCEFIELDVISUALIZER_PLANE], "forceFieldPlaneVisualizerVS.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(VS, shaders[VSTYPE_RAYTRACE_SCREEN], "raytrace_screenVS.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(VS, shaders[VSTYPE_SCREEN], "screenVS.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(VS, shaders[VSTYPE_LENSFLARE], "lensFlareVS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::VS, shaders[VSTYPE_OBJECT_COMMON_TESSELLATION], "objectVS_common_tessellation.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::VS, shaders[VSTYPE_OBJECT_PREPASS_TESSELLATION], "objectVS_prepass_tessellation.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::VS, shaders[VSTYPE_OBJECT_PREPASS_ALPHATEST_TESSELLATION], "objectVS_prepass_alphatest_tessellation.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::VS, shaders[VSTYPE_OBJECT_SIMPLE_TESSELLATION], "objectVS_simple_tessellation.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::VS, shaders[VSTYPE_IMPOSTOR], "impostorVS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::VS, shaders[VSTYPE_VOLUMETRICLIGHT_DIRECTIONAL], "volumetriclight_directionalVS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::VS, shaders[VSTYPE_VOLUMETRICLIGHT_POINT], "volumetriclight_pointVS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::VS, shaders[VSTYPE_VOLUMETRICLIGHT_SPOT], "volumetriclight_spotVS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::VS, shaders[VSTYPE_LIGHTVISUALIZER_SPOTLIGHT], "vSpotLightVS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::VS, shaders[VSTYPE_LIGHTVISUALIZER_POINTLIGHT], "vPointLightVS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::VS, shaders[VSTYPE_SPHERE], "sphereVS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::VS, shaders[VSTYPE_CUBE], "cubeVS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::VS, shaders[VSTYPE_SKY], "skyVS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::VS, shaders[VSTYPE_VOXELIZER], "objectVS_voxelizer.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::VS, shaders[VSTYPE_VOXEL], "voxelVS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::VS, shaders[VSTYPE_FORCEFIELDVISUALIZER_POINT], "forceFieldPointVisualizerVS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::VS, shaders[VSTYPE_FORCEFIELDVISUALIZER_PLANE], "forceFieldPlaneVisualizerVS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::VS, shaders[VSTYPE_RAYTRACE_SCREEN], "raytrace_screenVS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::VS, shaders[VSTYPE_SCREEN], "screenVS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::VS, shaders[VSTYPE_LENSFLARE], "lensFlareVS.cso"); });
- if (device->CheckCapability(GRAPHICSDEVICE_CAPABILITY_RENDERTARGET_AND_VIEWPORT_ARRAYINDEX_WITHOUT_GS))
+ if (device->CheckCapability(GraphicsDeviceCapability::RENDERTARGET_AND_VIEWPORT_ARRAYINDEX_WITHOUT_GS))
{
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(VS, shaders[VSTYPE_ENVMAP], "envMapVS.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(VS, shaders[VSTYPE_ENVMAP_SKY], "envMap_skyVS.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(VS, shaders[VSTYPE_SHADOWCUBEMAPRENDER], "cubeShadowVS.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(VS, shaders[VSTYPE_SHADOWCUBEMAPRENDER_ALPHATEST], "cubeShadowVS_alphatest.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(VS, shaders[VSTYPE_SHADOWCUBEMAPRENDER_TRANSPARENT], "cubeShadowVS_transparent.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::VS, shaders[VSTYPE_ENVMAP], "envMapVS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::VS, shaders[VSTYPE_ENVMAP_SKY], "envMap_skyVS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::VS, shaders[VSTYPE_SHADOWCUBEMAPRENDER], "cubeShadowVS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::VS, shaders[VSTYPE_SHADOWCUBEMAPRENDER_ALPHATEST], "cubeShadowVS_alphatest.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::VS, shaders[VSTYPE_SHADOWCUBEMAPRENDER_TRANSPARENT], "cubeShadowVS_transparent.cso"); });
}
else
{
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(VS, shaders[VSTYPE_ENVMAP], "envMapVS_emulation.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(VS, shaders[VSTYPE_ENVMAP_SKY], "envMap_skyVS_emulation.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(VS, shaders[VSTYPE_SHADOWCUBEMAPRENDER], "cubeShadowVS_emulation.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(VS, shaders[VSTYPE_SHADOWCUBEMAPRENDER_ALPHATEST], "cubeShadowVS_alphatest_emulation.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(VS, shaders[VSTYPE_SHADOWCUBEMAPRENDER_TRANSPARENT], "cubeShadowVS_transparent_emulation.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::VS, shaders[VSTYPE_ENVMAP], "envMapVS_emulation.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::VS, shaders[VSTYPE_ENVMAP_SKY], "envMap_skyVS_emulation.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::VS, shaders[VSTYPE_SHADOWCUBEMAPRENDER], "cubeShadowVS_emulation.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::VS, shaders[VSTYPE_SHADOWCUBEMAPRENDER_ALPHATEST], "cubeShadowVS_alphatest_emulation.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::VS, shaders[VSTYPE_SHADOWCUBEMAPRENDER_TRANSPARENT], "cubeShadowVS_transparent_emulation.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(GS, shaders[GSTYPE_ENVMAP_EMULATION], "envMapGS_emulation.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(GS, shaders[GSTYPE_ENVMAP_SKY_EMULATION], "envMap_skyGS_emulation.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(GS, shaders[GSTYPE_SHADOWCUBEMAPRENDER_EMULATION], "cubeShadowGS_emulation.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(GS, shaders[GSTYPE_SHADOWCUBEMAPRENDER_ALPHATEST_EMULATION], "cubeShadowGS_alphatest_emulation.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(GS, shaders[GSTYPE_SHADOWCUBEMAPRENDER_TRANSPARENT_EMULATION], "cubeShadowGS_transparent_emulation.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::GS, shaders[GSTYPE_ENVMAP_EMULATION], "envMapGS_emulation.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::GS, shaders[GSTYPE_ENVMAP_SKY_EMULATION], "envMap_skyGS_emulation.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::GS, shaders[GSTYPE_SHADOWCUBEMAPRENDER_EMULATION], "cubeShadowGS_emulation.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::GS, shaders[GSTYPE_SHADOWCUBEMAPRENDER_ALPHATEST_EMULATION], "cubeShadowGS_alphatest_emulation.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::GS, shaders[GSTYPE_SHADOWCUBEMAPRENDER_TRANSPARENT_EMULATION], "cubeShadowGS_transparent_emulation.cso"); });
}
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(PS, shaders[PSTYPE_OBJECT], "objectPS.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(PS, shaders[PSTYPE_OBJECT_TRANSPARENT], "objectPS_transparent.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(PS, shaders[PSTYPE_OBJECT_PLANARREFLECTION], "objectPS_planarreflection.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(PS, shaders[PSTYPE_OBJECT_TRANSPARENT_PLANARREFLECTION], "objectPS_transparent_planarreflection.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(PS, shaders[PSTYPE_OBJECT_POM], "objectPS_pom.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(PS, shaders[PSTYPE_OBJECT_TRANSPARENT_POM], "objectPS_transparent_pom.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(PS, shaders[PSTYPE_OBJECT_ANISOTROPIC], "objectPS_anisotropic.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(PS, shaders[PSTYPE_OBJECT_TRANSPARENT_ANISOTROPIC], "objectPS_transparent_anisotropic.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(PS, shaders[PSTYPE_OBJECT_CLOTH], "objectPS_cloth.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(PS, shaders[PSTYPE_OBJECT_TRANSPARENT_CLOTH], "objectPS_transparent_cloth.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(PS, shaders[PSTYPE_OBJECT_CLEARCOAT], "objectPS_clearcoat.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(PS, shaders[PSTYPE_OBJECT_TRANSPARENT_CLEARCOAT], "objectPS_transparent_clearcoat.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(PS, shaders[PSTYPE_OBJECT_CLOTH_CLEARCOAT], "objectPS_cloth_clearcoat.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(PS, shaders[PSTYPE_OBJECT_TRANSPARENT_CLOTH_CLEARCOAT], "objectPS_transparent_cloth_clearcoat.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(PS, shaders[PSTYPE_OBJECT_CARTOON], "objectPS_cartoon.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(PS, shaders[PSTYPE_OBJECT_TRANSPARENT_CARTOON], "objectPS_transparent_cartoon.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(PS, shaders[PSTYPE_OBJECT_UNLIT], "objectPS_unlit.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(PS, shaders[PSTYPE_OBJECT_TRANSPARENT_UNLIT], "objectPS_transparent_unlit.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(PS, shaders[PSTYPE_OBJECT_WATER], "objectPS_water.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(PS, shaders[PSTYPE_OBJECT_TERRAIN], "objectPS_terrain.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(PS, shaders[PSTYPE_IMPOSTOR], "impostorPS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::PS, shaders[PSTYPE_OBJECT], "objectPS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::PS, shaders[PSTYPE_OBJECT_TRANSPARENT], "objectPS_transparent.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::PS, shaders[PSTYPE_OBJECT_PLANARREFLECTION], "objectPS_planarreflection.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::PS, shaders[PSTYPE_OBJECT_TRANSPARENT_PLANARREFLECTION], "objectPS_transparent_planarreflection.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::PS, shaders[PSTYPE_OBJECT_POM], "objectPS_pom.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::PS, shaders[PSTYPE_OBJECT_TRANSPARENT_POM], "objectPS_transparent_pom.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::PS, shaders[PSTYPE_OBJECT_ANISOTROPIC], "objectPS_anisotropic.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::PS, shaders[PSTYPE_OBJECT_TRANSPARENT_ANISOTROPIC], "objectPS_transparent_anisotropic.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::PS, shaders[PSTYPE_OBJECT_CLOTH], "objectPS_cloth.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::PS, shaders[PSTYPE_OBJECT_TRANSPARENT_CLOTH], "objectPS_transparent_cloth.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::PS, shaders[PSTYPE_OBJECT_CLEARCOAT], "objectPS_clearcoat.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::PS, shaders[PSTYPE_OBJECT_TRANSPARENT_CLEARCOAT], "objectPS_transparent_clearcoat.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::PS, shaders[PSTYPE_OBJECT_CLOTH_CLEARCOAT], "objectPS_cloth_clearcoat.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::PS, shaders[PSTYPE_OBJECT_TRANSPARENT_CLOTH_CLEARCOAT], "objectPS_transparent_cloth_clearcoat.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::PS, shaders[PSTYPE_OBJECT_CARTOON], "objectPS_cartoon.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::PS, shaders[PSTYPE_OBJECT_TRANSPARENT_CARTOON], "objectPS_transparent_cartoon.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::PS, shaders[PSTYPE_OBJECT_UNLIT], "objectPS_unlit.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::PS, shaders[PSTYPE_OBJECT_TRANSPARENT_UNLIT], "objectPS_transparent_unlit.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::PS, shaders[PSTYPE_OBJECT_WATER], "objectPS_water.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::PS, shaders[PSTYPE_OBJECT_TERRAIN], "objectPS_terrain.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::PS, shaders[PSTYPE_IMPOSTOR], "impostorPS.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(PS, shaders[PSTYPE_OBJECT_HOLOGRAM], "objectPS_hologram.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::PS, shaders[PSTYPE_OBJECT_HOLOGRAM], "objectPS_hologram.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(PS, shaders[PSTYPE_OBJECT_DEBUG], "objectPS_debug.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(PS, shaders[PSTYPE_OBJECT_PAINTRADIUS], "objectPS_paintradius.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(PS, shaders[PSTYPE_OBJECT_SIMPLE], "objectPS_simple.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(PS, shaders[PSTYPE_OBJECT_PREPASS], "objectPS_prepass.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(PS, shaders[PSTYPE_OBJECT_PREPASS_ALPHATEST], "objectPS_prepass_alphatest.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(PS, shaders[PSTYPE_IMPOSTOR_PREPASS], "impostorPS_prepass.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(PS, shaders[PSTYPE_IMPOSTOR_SIMPLE], "impostorPS_simple.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(PS, shaders[PSTYPE_IMPOSTOR_WIRE], "impostorPS_wire.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(PS, shaders[PSTYPE_LIGHTVISUALIZER], "lightVisualizerPS.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(PS, shaders[PSTYPE_VOLUMETRICLIGHT_DIRECTIONAL], "volumetricLight_DirectionalPS.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(PS, shaders[PSTYPE_VOLUMETRICLIGHT_POINT], "volumetricLight_PointPS.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(PS, shaders[PSTYPE_VOLUMETRICLIGHT_SPOT], "volumetricLight_SpotPS.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(PS, shaders[PSTYPE_ENVMAP], "envMapPS.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(PS, shaders[PSTYPE_ENVMAP_TERRAIN], "envMapPS_terrain.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(PS, shaders[PSTYPE_ENVMAP_SKY_STATIC], "envMap_skyPS_static.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(PS, shaders[PSTYPE_ENVMAP_SKY_DYNAMIC], "envMap_skyPS_dynamic.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(PS, shaders[PSTYPE_CAPTUREIMPOSTOR_ALBEDO], "captureImpostorPS_albedo.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(PS, shaders[PSTYPE_CAPTUREIMPOSTOR_NORMAL], "captureImpostorPS_normal.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(PS, shaders[PSTYPE_CAPTUREIMPOSTOR_SURFACE], "captureImpostorPS_surface.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(PS, shaders[PSTYPE_CUBEMAP], "cubeMapPS.cso"); });
- 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_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"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(PS, shaders[PSTYPE_SHADOW_WATER], "shadowPS_water.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(PS, shaders[PSTYPE_VOXELIZER], "objectPS_voxelizer.cso"); });
- 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))
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::PS, shaders[PSTYPE_OBJECT_DEBUG], "objectPS_debug.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::PS, shaders[PSTYPE_OBJECT_PAINTRADIUS], "objectPS_paintradius.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::PS, shaders[PSTYPE_OBJECT_SIMPLE], "objectPS_simple.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::PS, shaders[PSTYPE_OBJECT_PREPASS], "objectPS_prepass.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::PS, shaders[PSTYPE_OBJECT_PREPASS_ALPHATEST], "objectPS_prepass_alphatest.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::PS, shaders[PSTYPE_IMPOSTOR_PREPASS], "impostorPS_prepass.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::PS, shaders[PSTYPE_IMPOSTOR_SIMPLE], "impostorPS_simple.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::PS, shaders[PSTYPE_IMPOSTOR_WIRE], "impostorPS_wire.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::PS, shaders[PSTYPE_LIGHTVISUALIZER], "lightVisualizerPS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::PS, shaders[PSTYPE_VOLUMETRICLIGHT_DIRECTIONAL], "volumetricLight_DirectionalPS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::PS, shaders[PSTYPE_VOLUMETRICLIGHT_POINT], "volumetricLight_PointPS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::PS, shaders[PSTYPE_VOLUMETRICLIGHT_SPOT], "volumetricLight_SpotPS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::PS, shaders[PSTYPE_ENVMAP], "envMapPS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::PS, shaders[PSTYPE_ENVMAP_TERRAIN], "envMapPS_terrain.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::PS, shaders[PSTYPE_ENVMAP_SKY_STATIC], "envMap_skyPS_static.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::PS, shaders[PSTYPE_ENVMAP_SKY_DYNAMIC], "envMap_skyPS_dynamic.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::PS, shaders[PSTYPE_CAPTUREIMPOSTOR_ALBEDO], "captureImpostorPS_albedo.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::PS, shaders[PSTYPE_CAPTUREIMPOSTOR_NORMAL], "captureImpostorPS_normal.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::PS, shaders[PSTYPE_CAPTUREIMPOSTOR_SURFACE], "captureImpostorPS_surface.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::PS, shaders[PSTYPE_CUBEMAP], "cubeMapPS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::PS, shaders[PSTYPE_VERTEXCOLOR], "vertexcolorPS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::PS, shaders[PSTYPE_SKY_STATIC], "skyPS_static.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::PS, shaders[PSTYPE_SKY_DYNAMIC], "skyPS_dynamic.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::PS, shaders[PSTYPE_SUN], "sunPS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::PS, shaders[PSTYPE_SHADOW_ALPHATEST], "shadowPS_alphatest.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::PS, shaders[PSTYPE_SHADOW_TRANSPARENT], "shadowPS_transparent.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::PS, shaders[PSTYPE_SHADOW_WATER], "shadowPS_water.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::PS, shaders[PSTYPE_VOXELIZER], "objectPS_voxelizer.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::PS, shaders[PSTYPE_VOXELIZER_TERRAIN], "objectPS_voxelizer_terrain.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::PS, shaders[PSTYPE_VOXEL], "voxelPS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::PS, shaders[PSTYPE_FORCEFIELDVISUALIZER], "forceFieldVisualizerPS.cso"); });
+ if (device->CheckCapability(GraphicsDeviceCapability::RAYTRACING))
{
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(PS, shaders[PSTYPE_RENDERLIGHTMAP], "renderlightmapPS_rtapi.cso", SHADERMODEL_6_5); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::PS, shaders[PSTYPE_RENDERLIGHTMAP], "renderlightmapPS_rtapi.cso", ShaderModel::SM_6_5); });
}
else
{
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(PS, shaders[PSTYPE_RENDERLIGHTMAP], "renderlightmapPS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::PS, shaders[PSTYPE_RENDERLIGHTMAP], "renderlightmapPS.cso"); });
}
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(PS, shaders[PSTYPE_RAYTRACE_DEBUGBVH], "raytrace_debugbvhPS.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(PS, shaders[PSTYPE_DOWNSAMPLEDEPTHBUFFER], "downsampleDepthBuffer4xPS.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(PS, shaders[PSTYPE_POSTPROCESS_UPSAMPLE_BILATERAL], "upsample_bilateralPS.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(PS, shaders[PSTYPE_POSTPROCESS_OUTLINE], "outlinePS.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(PS, shaders[PSTYPE_LENSFLARE], "lensFlarePS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::PS, shaders[PSTYPE_RAYTRACE_DEBUGBVH], "raytrace_debugbvhPS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::PS, shaders[PSTYPE_DOWNSAMPLEDEPTHBUFFER], "downsampleDepthBuffer4xPS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::PS, shaders[PSTYPE_POSTPROCESS_UPSAMPLE_BILATERAL], "upsample_bilateralPS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::PS, shaders[PSTYPE_POSTPROCESS_OUTLINE], "outlinePS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::PS, shaders[PSTYPE_LENSFLARE], "lensFlarePS.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(GS, shaders[GSTYPE_VOXELIZER], "objectGS_voxelizer.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(GS, shaders[GSTYPE_VOXEL], "voxelGS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::GS, shaders[GSTYPE_VOXELIZER], "objectGS_voxelizer.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::GS, shaders[GSTYPE_VOXEL], "voxelGS.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_LUMINANCE_PASS1], "luminancePass1CS.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_LUMINANCE_PASS2], "luminancePass2CS.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_SHADINGRATECLASSIFICATION], "shadingRateClassificationCS.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_SHADINGRATECLASSIFICATION_DEBUG], "shadingRateClassificationCS_DEBUG.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_TILEFRUSTUMS], "tileFrustumsCS.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_LIGHTCULLING], "lightCullingCS.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_LIGHTCULLING_DEBUG], "lightCullingCS_DEBUG.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_LIGHTCULLING_ADVANCED], "lightCullingCS_ADVANCED.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_LIGHTCULLING_ADVANCED_DEBUG], "lightCullingCS_ADVANCED_DEBUG.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_RESOLVEMSAADEPTHSTENCIL], "resolveMSAADepthStencilCS.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_VOXELSCENECOPYCLEAR], "voxelSceneCopyClearCS.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_VOXELSCENECOPYCLEAR_TEMPORALSMOOTHING], "voxelSceneCopyClearCS_TemporalSmoothing.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_VOXELRADIANCESECONDARYBOUNCE], "voxelRadianceSecondaryBounceCS.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_VOXELCLEARONLYNORMAL], "voxelClearOnlyNormalCS.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_SKYATMOSPHERE_TRANSMITTANCELUT], "skyAtmosphere_transmittanceLutCS.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_SKYATMOSPHERE_MULTISCATTEREDLUMINANCELUT], "skyAtmosphere_multiScatteredLuminanceLutCS.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_SKYATMOSPHERE_SKYVIEWLUT], "skyAtmosphere_skyViewLutCS.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_SKYATMOSPHERE_SKYLUMINANCELUT], "skyAtmosphere_skyLuminanceLutCS.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_GENERATEMIPCHAIN2D_UNORM4], "generateMIPChain2DCS_unorm4.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_GENERATEMIPCHAIN2D_FLOAT4], "generateMIPChain2DCS_float4.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_GENERATEMIPCHAIN3D_UNORM4], "generateMIPChain3DCS_unorm4.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_GENERATEMIPCHAIN3D_FLOAT4], "generateMIPChain3DCS_float4.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_GENERATEMIPCHAINCUBE_UNORM4], "generateMIPChainCubeCS_unorm4.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_GENERATEMIPCHAINCUBE_FLOAT4], "generateMIPChainCubeCS_float4.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_GENERATEMIPCHAINCUBEARRAY_UNORM4], "generateMIPChainCubeArrayCS_unorm4.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_GENERATEMIPCHAINCUBEARRAY_FLOAT4], "generateMIPChainCubeArrayCS_float4.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_FILTERENVMAP], "filterEnvMapCS.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_COPYTEXTURE2D_UNORM4], "copytexture2D_unorm4CS.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_COPYTEXTURE2D_FLOAT4], "copytexture2D_float4CS.cso"); });
- 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"); });
- if (device->CheckCapability(GRAPHICSDEVICE_CAPABILITY_RAYTRACING))
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_LUMINANCE_PASS1], "luminancePass1CS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_LUMINANCE_PASS2], "luminancePass2CS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_SHADINGRATECLASSIFICATION], "shadingRateClassificationCS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_SHADINGRATECLASSIFICATION_DEBUG], "shadingRateClassificationCS_DEBUG.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_TILEFRUSTUMS], "tileFrustumsCS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_LIGHTCULLING], "lightCullingCS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_LIGHTCULLING_DEBUG], "lightCullingCS_DEBUG.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_LIGHTCULLING_ADVANCED], "lightCullingCS_ADVANCED.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_LIGHTCULLING_ADVANCED_DEBUG], "lightCullingCS_ADVANCED_DEBUG.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_RESOLVEMSAADEPTHSTENCIL], "resolveMSAADepthStencilCS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_VOXELSCENECOPYCLEAR], "voxelSceneCopyClearCS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_VOXELSCENECOPYCLEAR_TEMPORALSMOOTHING], "voxelSceneCopyClearCS_TemporalSmoothing.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_VOXELRADIANCESECONDARYBOUNCE], "voxelRadianceSecondaryBounceCS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_VOXELCLEARONLYNORMAL], "voxelClearOnlyNormalCS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_SKYATMOSPHERE_TRANSMITTANCELUT], "skyAtmosphere_transmittanceLutCS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_SKYATMOSPHERE_MULTISCATTEREDLUMINANCELUT], "skyAtmosphere_multiScatteredLuminanceLutCS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_SKYATMOSPHERE_SKYVIEWLUT], "skyAtmosphere_skyViewLutCS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_SKYATMOSPHERE_SKYLUMINANCELUT], "skyAtmosphere_skyLuminanceLutCS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_GENERATEMIPCHAIN2D_UNORM4], "generateMIPChain2DCS_unorm4.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_GENERATEMIPCHAIN2D_FLOAT4], "generateMIPChain2DCS_float4.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_GENERATEMIPCHAIN3D_UNORM4], "generateMIPChain3DCS_unorm4.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_GENERATEMIPCHAIN3D_FLOAT4], "generateMIPChain3DCS_float4.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_GENERATEMIPCHAINCUBE_UNORM4], "generateMIPChainCubeCS_unorm4.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_GENERATEMIPCHAINCUBE_FLOAT4], "generateMIPChainCubeCS_float4.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_GENERATEMIPCHAINCUBEARRAY_UNORM4], "generateMIPChainCubeArrayCS_unorm4.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_GENERATEMIPCHAINCUBEARRAY_FLOAT4], "generateMIPChainCubeArrayCS_float4.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_FILTERENVMAP], "filterEnvMapCS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_COPYTEXTURE2D_UNORM4], "copytexture2D_unorm4CS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_COPYTEXTURE2D_FLOAT4], "copytexture2D_float4CS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_COPYTEXTURE2D_UNORM4_BORDEREXPAND], "copytexture2D_unorm4_borderexpandCS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_COPYTEXTURE2D_FLOAT4_BORDEREXPAND], "copytexture2D_float4_borderexpandCS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_SKINNING], "skinningCS.cso"); });
+ if (device->CheckCapability(GraphicsDeviceCapability::RAYTRACING))
{
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_RAYTRACE], "raytraceCS_rtapi.cso", SHADERMODEL_6_5); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_RAYTRACE], "raytraceCS_rtapi.cso", ShaderModel::SM_6_5); });
}
else
{
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_RAYTRACE], "raytraceCS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_RAYTRACE], "raytraceCS.cso"); });
}
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_PAINT_TEXTURE], "paint_textureCS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_PAINT_TEXTURE], "paint_textureCS.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_POSTPROCESS_BLUR_GAUSSIAN_FLOAT1], "blur_gaussian_float1CS.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_POSTPROCESS_BLUR_GAUSSIAN_FLOAT3], "blur_gaussian_float3CS.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_POSTPROCESS_BLUR_GAUSSIAN_FLOAT4], "blur_gaussian_float4CS.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_POSTPROCESS_BLUR_GAUSSIAN_UNORM1], "blur_gaussian_unorm1CS.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_POSTPROCESS_BLUR_GAUSSIAN_UNORM4], "blur_gaussian_unorm4CS.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_POSTPROCESS_BLUR_GAUSSIAN_WIDE_FLOAT1], "blur_gaussian_wide_float1CS.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_POSTPROCESS_BLUR_GAUSSIAN_WIDE_FLOAT3], "blur_gaussian_wide_float3CS.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_POSTPROCESS_BLUR_GAUSSIAN_WIDE_FLOAT4], "blur_gaussian_wide_float4CS.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_POSTPROCESS_BLUR_GAUSSIAN_WIDE_UNORM1], "blur_gaussian_wide_unorm1CS.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_POSTPROCESS_BLUR_GAUSSIAN_WIDE_UNORM4], "blur_gaussian_wide_unorm4CS.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_POSTPROCESS_BLUR_BILATERAL_FLOAT1], "blur_bilateral_float1CS.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_POSTPROCESS_BLUR_BILATERAL_FLOAT3], "blur_bilateral_float3CS.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_POSTPROCESS_BLUR_BILATERAL_FLOAT4], "blur_bilateral_float4CS.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_POSTPROCESS_BLUR_BILATERAL_UNORM1], "blur_bilateral_unorm1CS.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_POSTPROCESS_BLUR_BILATERAL_UNORM4], "blur_bilateral_unorm4CS.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_POSTPROCESS_BLUR_BILATERAL_WIDE_FLOAT1], "blur_bilateral_wide_float1CS.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_POSTPROCESS_BLUR_BILATERAL_WIDE_FLOAT3], "blur_bilateral_wide_float3CS.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_POSTPROCESS_BLUR_BILATERAL_WIDE_FLOAT4], "blur_bilateral_wide_float4CS.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_POSTPROCESS_BLUR_BILATERAL_WIDE_UNORM1], "blur_bilateral_wide_unorm1CS.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_POSTPROCESS_BLUR_BILATERAL_WIDE_UNORM4], "blur_bilateral_wide_unorm4CS.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_POSTPROCESS_SSAO], "ssaoCS.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_POSTPROCESS_HBAO], "hbaoCS.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_POSTPROCESS_MSAO_PREPAREDEPTHBUFFERS1], "msao_preparedepthbuffers1CS.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_POSTPROCESS_MSAO_PREPAREDEPTHBUFFERS2], "msao_preparedepthbuffers2CS.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_POSTPROCESS_MSAO_INTERLEAVE], "msao_interleaveCS.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_POSTPROCESS_MSAO], "msaoCS.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_POSTPROCESS_MSAO_BLURUPSAMPLE], "msao_blurupsampleCS.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_POSTPROCESS_MSAO_BLURUPSAMPLE_BLENDOUT], "msao_blurupsampleCS_blendout.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_POSTPROCESS_MSAO_BLURUPSAMPLE_PREMIN], "msao_blurupsampleCS_premin.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_POSTPROCESS_MSAO_BLURUPSAMPLE_PREMIN_BLENDOUT], "msao_blurupsampleCS_premin_blendout.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_POSTPROCESS_SSR_RAYTRACE], "ssr_raytraceCS.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_POSTPROCESS_SSR_RESOLVE], "ssr_resolveCS.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_POSTPROCESS_SSR_TEMPORAL], "ssr_temporalCS.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_POSTPROCESS_SSR_MEDIAN], "ssr_medianCS.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_POSTPROCESS_LIGHTSHAFTS], "lightShaftsCS.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_POSTPROCESS_DEPTHOFFIELD_TILEMAXCOC_HORIZONTAL], "depthoffield_tileMaxCOC_horizontalCS.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_POSTPROCESS_DEPTHOFFIELD_TILEMAXCOC_VERTICAL], "depthoffield_tileMaxCOC_verticalCS.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_POSTPROCESS_DEPTHOFFIELD_NEIGHBORHOODMAXCOC], "depthoffield_neighborhoodMaxCOCCS.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_POSTPROCESS_DEPTHOFFIELD_KICKJOBS], "depthoffield_kickjobsCS.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_POSTPROCESS_DEPTHOFFIELD_PREPASS], "depthoffield_prepassCS.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_POSTPROCESS_DEPTHOFFIELD_PREPASS_EARLYEXIT], "depthoffield_prepassCS_earlyexit.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_POSTPROCESS_DEPTHOFFIELD_MAIN], "depthoffield_mainCS.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_POSTPROCESS_DEPTHOFFIELD_MAIN_EARLYEXIT], "depthoffield_mainCS_earlyexit.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_POSTPROCESS_DEPTHOFFIELD_MAIN_CHEAP], "depthoffield_mainCS_cheap.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_POSTPROCESS_DEPTHOFFIELD_POSTFILTER], "depthoffield_postfilterCS.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_POSTPROCESS_DEPTHOFFIELD_UPSAMPLE], "depthoffield_upsampleCS.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_POSTPROCESS_MOTIONBLUR_TILEMAXVELOCITY_HORIZONTAL], "motionblur_tileMaxVelocity_horizontalCS.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_POSTPROCESS_MOTIONBLUR_TILEMAXVELOCITY_VERTICAL], "motionblur_tileMaxVelocity_verticalCS.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_POSTPROCESS_MOTIONBLUR_NEIGHBORHOODMAXVELOCITY], "motionblur_neighborhoodMaxVelocityCS.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_POSTPROCESS_MOTIONBLUR_KICKJOBS], "motionblur_kickjobsCS.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_POSTPROCESS_MOTIONBLUR], "motionblurCS.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_POSTPROCESS_MOTIONBLUR_EARLYEXIT], "motionblurCS_earlyexit.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_POSTPROCESS_MOTIONBLUR_CHEAP], "motionblurCS_cheap.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_POSTPROCESS_BLOOMSEPARATE], "bloomseparateCS.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_POSTPROCESS_VOLUMETRICCLOUDS_SHAPENOISE], "volumetricCloud_shapenoiseCS.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_POSTPROCESS_VOLUMETRICCLOUDS_DETAILNOISE], "volumetricCloud_detailnoiseCS.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_POSTPROCESS_VOLUMETRICCLOUDS_CURLNOISE], "volumetricCloud_curlnoiseCS.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_POSTPROCESS_VOLUMETRICCLOUDS_WEATHERMAP], "volumetricCloud_weathermapCS.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_POSTPROCESS_VOLUMETRICCLOUDS_RENDER], "volumetricCloud_renderCS.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_POSTPROCESS_VOLUMETRICCLOUDS_REPROJECT], "volumetricCloud_reprojectCS.cso"); });
- 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_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"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_POSTPROCESS_FSR_SHARPEN], "fsr_sharpenCS.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_POSTPROCESS_CHROMATIC_ABERRATION], "chromatic_aberrationCS.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_POSTPROCESS_UPSAMPLE_BILATERAL_FLOAT1], "upsample_bilateral_float1CS.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_POSTPROCESS_UPSAMPLE_BILATERAL_UNORM1], "upsample_bilateral_unorm1CS.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_POSTPROCESS_UPSAMPLE_BILATERAL_FLOAT4], "upsample_bilateral_float4CS.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_POSTPROCESS_UPSAMPLE_BILATERAL_UNORM4], "upsample_bilateral_unorm4CS.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_POSTPROCESS_UPSAMPLE_BILATERAL_UINT4], "upsample_bilateral_uint4CS.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_POSTPROCESS_DOWNSAMPLE4X], "downsample4xCS.cso"); });
- 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"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_POSTPROCESS_BLUR_GAUSSIAN_FLOAT1], "blur_gaussian_float1CS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_POSTPROCESS_BLUR_GAUSSIAN_FLOAT3], "blur_gaussian_float3CS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_POSTPROCESS_BLUR_GAUSSIAN_FLOAT4], "blur_gaussian_float4CS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_POSTPROCESS_BLUR_GAUSSIAN_UNORM1], "blur_gaussian_unorm1CS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_POSTPROCESS_BLUR_GAUSSIAN_UNORM4], "blur_gaussian_unorm4CS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_POSTPROCESS_BLUR_GAUSSIAN_WIDE_FLOAT1], "blur_gaussian_wide_float1CS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_POSTPROCESS_BLUR_GAUSSIAN_WIDE_FLOAT3], "blur_gaussian_wide_float3CS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_POSTPROCESS_BLUR_GAUSSIAN_WIDE_FLOAT4], "blur_gaussian_wide_float4CS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_POSTPROCESS_BLUR_GAUSSIAN_WIDE_UNORM1], "blur_gaussian_wide_unorm1CS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_POSTPROCESS_BLUR_GAUSSIAN_WIDE_UNORM4], "blur_gaussian_wide_unorm4CS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_POSTPROCESS_BLUR_BILATERAL_FLOAT1], "blur_bilateral_float1CS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_POSTPROCESS_BLUR_BILATERAL_FLOAT3], "blur_bilateral_float3CS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_POSTPROCESS_BLUR_BILATERAL_FLOAT4], "blur_bilateral_float4CS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_POSTPROCESS_BLUR_BILATERAL_UNORM1], "blur_bilateral_unorm1CS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_POSTPROCESS_BLUR_BILATERAL_UNORM4], "blur_bilateral_unorm4CS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_POSTPROCESS_BLUR_BILATERAL_WIDE_FLOAT1], "blur_bilateral_wide_float1CS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_POSTPROCESS_BLUR_BILATERAL_WIDE_FLOAT3], "blur_bilateral_wide_float3CS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_POSTPROCESS_BLUR_BILATERAL_WIDE_FLOAT4], "blur_bilateral_wide_float4CS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_POSTPROCESS_BLUR_BILATERAL_WIDE_UNORM1], "blur_bilateral_wide_unorm1CS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_POSTPROCESS_BLUR_BILATERAL_WIDE_UNORM4], "blur_bilateral_wide_unorm4CS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_POSTPROCESS_SSAO], "ssaoCS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_POSTPROCESS_HBAO], "hbaoCS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_POSTPROCESS_MSAO_PREPAREDEPTHBUFFERS1], "msao_preparedepthbuffers1CS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_POSTPROCESS_MSAO_PREPAREDEPTHBUFFERS2], "msao_preparedepthbuffers2CS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_POSTPROCESS_MSAO_INTERLEAVE], "msao_interleaveCS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_POSTPROCESS_MSAO], "msaoCS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_POSTPROCESS_MSAO_BLURUPSAMPLE], "msao_blurupsampleCS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_POSTPROCESS_MSAO_BLURUPSAMPLE_BLENDOUT], "msao_blurupsampleCS_blendout.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_POSTPROCESS_MSAO_BLURUPSAMPLE_PREMIN], "msao_blurupsampleCS_premin.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_POSTPROCESS_MSAO_BLURUPSAMPLE_PREMIN_BLENDOUT], "msao_blurupsampleCS_premin_blendout.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_POSTPROCESS_SSR_RAYTRACE], "ssr_raytraceCS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_POSTPROCESS_SSR_RESOLVE], "ssr_resolveCS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_POSTPROCESS_SSR_TEMPORAL], "ssr_temporalCS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_POSTPROCESS_SSR_MEDIAN], "ssr_medianCS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_POSTPROCESS_LIGHTSHAFTS], "lightShaftsCS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_POSTPROCESS_DEPTHOFFIELD_TILEMAXCOC_HORIZONTAL], "depthoffield_tileMaxCOC_horizontalCS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_POSTPROCESS_DEPTHOFFIELD_TILEMAXCOC_VERTICAL], "depthoffield_tileMaxCOC_verticalCS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_POSTPROCESS_DEPTHOFFIELD_NEIGHBORHOODMAXCOC], "depthoffield_neighborhoodMaxCOCCS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_POSTPROCESS_DEPTHOFFIELD_KICKJOBS], "depthoffield_kickjobsCS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_POSTPROCESS_DEPTHOFFIELD_PREPASS], "depthoffield_prepassCS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_POSTPROCESS_DEPTHOFFIELD_PREPASS_EARLYEXIT], "depthoffield_prepassCS_earlyexit.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_POSTPROCESS_DEPTHOFFIELD_MAIN], "depthoffield_mainCS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_POSTPROCESS_DEPTHOFFIELD_MAIN_EARLYEXIT], "depthoffield_mainCS_earlyexit.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_POSTPROCESS_DEPTHOFFIELD_MAIN_CHEAP], "depthoffield_mainCS_cheap.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_POSTPROCESS_DEPTHOFFIELD_POSTFILTER], "depthoffield_postfilterCS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_POSTPROCESS_DEPTHOFFIELD_UPSAMPLE], "depthoffield_upsampleCS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_POSTPROCESS_MOTIONBLUR_TILEMAXVELOCITY_HORIZONTAL], "motionblur_tileMaxVelocity_horizontalCS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_POSTPROCESS_MOTIONBLUR_TILEMAXVELOCITY_VERTICAL], "motionblur_tileMaxVelocity_verticalCS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_POSTPROCESS_MOTIONBLUR_NEIGHBORHOODMAXVELOCITY], "motionblur_neighborhoodMaxVelocityCS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_POSTPROCESS_MOTIONBLUR_KICKJOBS], "motionblur_kickjobsCS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_POSTPROCESS_MOTIONBLUR], "motionblurCS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_POSTPROCESS_MOTIONBLUR_EARLYEXIT], "motionblurCS_earlyexit.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_POSTPROCESS_MOTIONBLUR_CHEAP], "motionblurCS_cheap.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_POSTPROCESS_BLOOMSEPARATE], "bloomseparateCS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_POSTPROCESS_VOLUMETRICCLOUDS_SHAPENOISE], "volumetricCloud_shapenoiseCS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_POSTPROCESS_VOLUMETRICCLOUDS_DETAILNOISE], "volumetricCloud_detailnoiseCS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_POSTPROCESS_VOLUMETRICCLOUDS_CURLNOISE], "volumetricCloud_curlnoiseCS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_POSTPROCESS_VOLUMETRICCLOUDS_WEATHERMAP], "volumetricCloud_weathermapCS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_POSTPROCESS_VOLUMETRICCLOUDS_RENDER], "volumetricCloud_renderCS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_POSTPROCESS_VOLUMETRICCLOUDS_REPROJECT], "volumetricCloud_reprojectCS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_POSTPROCESS_VOLUMETRICCLOUDS_TEMPORAL], "volumetricCloud_temporalCS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_POSTPROCESS_FXAA], "fxaaCS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_POSTPROCESS_TEMPORALAA], "temporalaaCS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_POSTPROCESS_SHARPEN], "sharpenCS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_POSTPROCESS_TONEMAP], "tonemapCS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_POSTPROCESS_FSR_UPSCALING], "fsr_upscalingCS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_POSTPROCESS_FSR_SHARPEN], "fsr_sharpenCS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_POSTPROCESS_CHROMATIC_ABERRATION], "chromatic_aberrationCS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_POSTPROCESS_UPSAMPLE_BILATERAL_FLOAT1], "upsample_bilateral_float1CS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_POSTPROCESS_UPSAMPLE_BILATERAL_UNORM1], "upsample_bilateral_unorm1CS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_POSTPROCESS_UPSAMPLE_BILATERAL_FLOAT4], "upsample_bilateral_float4CS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_POSTPROCESS_UPSAMPLE_BILATERAL_UNORM4], "upsample_bilateral_unorm4CS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_POSTPROCESS_UPSAMPLE_BILATERAL_UINT4], "upsample_bilateral_uint4CS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_POSTPROCESS_DOWNSAMPLE4X], "downsample4xCS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_POSTPROCESS_NORMALSFROMDEPTH], "normalsfromdepthCS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_POSTPROCESS_SCREENSPACESHADOW], "screenspaceshadowCS.cso"); });
- if (device->CheckCapability(GRAPHICSDEVICE_CAPABILITY_RAYTRACING))
+ if (device->CheckCapability(GraphicsDeviceCapability::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"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_POSTPROCESS_RTSHADOW_DENOISE_FILTER], "rtshadow_denoise_filterCS.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_POSTPROCESS_RTSHADOW_DENOISE_TEMPORAL], "rtshadow_denoise_temporalCS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_POSTPROCESS_RTSHADOW], "rtshadowCS.cso", ShaderModel::SM_6_5); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_POSTPROCESS_RTSHADOW_DENOISE_TILECLASSIFICATION], "rtshadow_denoise_tileclassificationCS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_POSTPROCESS_RTSHADOW_DENOISE_FILTER], "rtshadow_denoise_filterCS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_POSTPROCESS_RTSHADOW_DENOISE_TEMPORAL], "rtshadow_denoise_temporalCS.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_POSTPROCESS_RTAO], "rtaoCS.cso", SHADERMODEL_6_5); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_POSTPROCESS_RTAO_DENOISE_TILECLASSIFICATION], "rtao_denoise_tileclassificationCS.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_POSTPROCESS_RTAO_DENOISE_FILTER], "rtao_denoise_filterCS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_POSTPROCESS_RTAO], "rtaoCS.cso", ShaderModel::SM_6_5); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_POSTPROCESS_RTAO_DENOISE_TILECLASSIFICATION], "rtao_denoise_tileclassificationCS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_POSTPROCESS_RTAO_DENOISE_FILTER], "rtao_denoise_filterCS.cso"); });
}
- 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"); });
- if (device->CheckCapability(GRAPHICSDEVICE_CAPABILITY_RAYTRACING))
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_SURFEL_COVERAGE], "surfel_coverageCS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_SURFEL_INDIRECTPREPARE], "surfel_indirectprepareCS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_SURFEL_UPDATE], "surfel_updateCS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_SURFEL_GRIDRESET], "surfel_gridresetCS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_SURFEL_GRIDOFFSETS], "surfel_gridoffsetsCS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_SURFEL_BINNING], "surfel_binningCS.cso"); });
+ if (device->CheckCapability(GraphicsDeviceCapability::RAYTRACING))
{
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_SURFEL_RAYTRACE], "surfel_raytraceCS_rtapi.cso", SHADERMODEL_6_5); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::CS, shaders[CSTYPE_SURFEL_RAYTRACE], "surfel_raytraceCS_rtapi.cso", ShaderModel::SM_6_5); });
}
else
{
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(CS, shaders[CSTYPE_SURFEL_RAYTRACE], "surfel_raytraceCS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::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(ShaderStage::CS, shaders[CSTYPE_VISIBILITY_RESOLVE], "visibility_resolveCS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::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"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(HS, shaders[HSTYPE_OBJECT_SIMPLE], "objectHS_simple.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::HS, shaders[HSTYPE_OBJECT], "objectHS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::HS, shaders[HSTYPE_OBJECT_PREPASS], "objectHS_prepass.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::HS, shaders[HSTYPE_OBJECT_PREPASS_ALPHATEST], "objectHS_prepass_alphatest.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::HS, shaders[HSTYPE_OBJECT_SIMPLE], "objectHS_simple.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(DS, shaders[DSTYPE_OBJECT], "objectDS.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(DS, shaders[DSTYPE_OBJECT_PREPASS], "objectDS_prepass.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(DS, shaders[DSTYPE_OBJECT_PREPASS_ALPHATEST], "objectDS_prepass_alphatest.cso"); });
- wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(DS, shaders[DSTYPE_OBJECT_SIMPLE], "objectDS_simple.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::DS, shaders[DSTYPE_OBJECT], "objectDS.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::DS, shaders[DSTYPE_OBJECT_PREPASS], "objectDS_prepass.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::DS, shaders[DSTYPE_OBJECT_PREPASS_ALPHATEST], "objectDS_prepass_alphatest.cso"); });
+ wiJobSystem::Execute(ctx, [](wiJobArgs args) { LoadShader(ShaderStage::DS, shaders[DSTYPE_OBJECT_SIMPLE], "objectDS_simple.cso"); });
wiJobSystem::Wait(ctx);
@@ -1270,11 +1136,11 @@ void LoadShaders()
if (tessellation)
{
- desc.pt = PATCHLIST;
+ desc.pt = PrimitiveTopology::PATCHLIST;
}
else
{
- desc.pt = TRIANGLELIST;
+ desc.pt = PrimitiveTopology::TRIANGLELIST;
}
device->CreatePipelineState(&desc, &PSO_object[shaderType][renderPass][blendMode][doublesided][tessellation][alphatest]);
@@ -1341,7 +1207,7 @@ void LoadShaders()
desc.bs = &blendStates[BSTYPE_ADDITIVE];
desc.rs = &rasterizers[RSTYPE_FRONT];
desc.dss = &depthStencils[DSSTYPE_HOLOGRAM];
- desc.pt = TRIANGLELIST;
+ desc.pt = PrimitiveTopology::TRIANGLELIST;
PipelineState pso;
device->CreatePipelineState(&desc, &pso);
@@ -1364,7 +1230,7 @@ void LoadShaders()
device->CreatePipelineState(&desc, &PSO_object_wire);
- desc.pt = PATCHLIST;
+ desc.pt = PrimitiveTopology::PATCHLIST;
desc.vs = &shaders[VSTYPE_OBJECT_SIMPLE_TESSELLATION];
desc.hs = &shaders[HSTYPE_OBJECT_SIMPLE];
desc.ds = &shaders[DSTYPE_OBJECT_SIMPLE];
@@ -1376,7 +1242,7 @@ void LoadShaders()
desc.rs = &rasterizers[RSTYPE_OCCLUDEE];
desc.bs = &blendStates[BSTYPE_COLORWRITEDISABLE];
desc.dss = &depthStencils[DSSTYPE_DEPTHREAD];
- desc.pt = TRIANGLESTRIP;
+ desc.pt = PrimitiveTopology::TRIANGLESTRIP;
device->CreatePipelineState(&desc, &PSO_occlusionquery);
});
@@ -1449,7 +1315,7 @@ void LoadShaders()
// deferred lights:
- desc.pt = TRIANGLELIST;
+ desc.pt = PrimitiveTopology::TRIANGLELIST;
// light visualizers:
@@ -1553,7 +1419,7 @@ void LoadShaders()
desc.bs = &blendStates[BSTYPE_ADDITIVE];
desc.rs = &rasterizers[RSTYPE_DOUBLESIDED];
desc.dss = &depthStencils[DSSTYPE_XRAY];
- desc.pt = TRIANGLESTRIP;
+ desc.pt = PrimitiveTopology::TRIANGLESTRIP;
device->CreatePipelineState(&desc, &PSO_lensflare);
});
@@ -1583,7 +1449,7 @@ void LoadShaders()
desc.bs = &blendStates[BSTYPE_OPAQUE];
desc.vs = &shaders[VSTYPE_ENVMAP_SKY];
desc.ps = &shaders[PSTYPE_ENVMAP_SKY_STATIC];
- if (!device->CheckCapability(GRAPHICSDEVICE_CAPABILITY_RENDERTARGET_AND_VIEWPORT_ARRAYINDEX_WITHOUT_GS))
+ if (!device->CheckCapability(GraphicsDeviceCapability::RENDERTARGET_AND_VIEWPORT_ARRAYINDEX_WITHOUT_GS))
{
desc.gs = &shaders[GSTYPE_ENVMAP_SKY_EMULATION];
}
@@ -1592,7 +1458,7 @@ void LoadShaders()
desc.bs = &blendStates[BSTYPE_OPAQUE];
desc.vs = &shaders[VSTYPE_ENVMAP_SKY];
desc.ps = &shaders[PSTYPE_ENVMAP_SKY_DYNAMIC];
- if (!device->CheckCapability(GRAPHICSDEVICE_CAPABILITY_RENDERTARGET_AND_VIEWPORT_ARRAYINDEX_WITHOUT_GS))
+ if (!device->CheckCapability(GraphicsDeviceCapability::RENDERTARGET_AND_VIEWPORT_ARRAYINDEX_WITHOUT_GS))
{
desc.gs = &shaders[GSTYPE_ENVMAP_SKY_EMULATION];
}
@@ -1612,7 +1478,7 @@ void LoadShaders()
desc.dss = &depthStencils[DSSTYPE_DEFAULT];
desc.rs = &rasterizers[RSTYPE_FRONT];
desc.bs = &blendStates[BSTYPE_OPAQUE];
- desc.pt = TRIANGLELIST;
+ desc.pt = PrimitiveTopology::TRIANGLELIST;
break;
case DEBUGRENDERING_GRID:
desc.vs = &shaders[VSTYPE_VERTEXCOLOR];
@@ -1621,7 +1487,7 @@ void LoadShaders()
desc.dss = &depthStencils[DSSTYPE_DEPTHREAD];
desc.rs = &rasterizers[RSTYPE_WIRE_DOUBLESIDED_SMOOTH];
desc.bs = &blendStates[BSTYPE_TRANSPARENT];
- desc.pt = LINELIST;
+ desc.pt = PrimitiveTopology::LINELIST;
break;
case DEBUGRENDERING_CUBE:
desc.vs = &shaders[VSTYPE_VERTEXCOLOR];
@@ -1630,7 +1496,7 @@ void LoadShaders()
desc.dss = &depthStencils[DSSTYPE_DEPTHREAD];
desc.rs = &rasterizers[RSTYPE_WIRE_DOUBLESIDED_SMOOTH];
desc.bs = &blendStates[BSTYPE_TRANSPARENT];
- desc.pt = LINELIST;
+ desc.pt = PrimitiveTopology::LINELIST;
break;
case DEBUGRENDERING_LINES:
desc.vs = &shaders[VSTYPE_VERTEXCOLOR];
@@ -1639,7 +1505,7 @@ void LoadShaders()
desc.dss = &depthStencils[DSSTYPE_XRAY];
desc.rs = &rasterizers[RSTYPE_WIRE_DOUBLESIDED_SMOOTH];
desc.bs = &blendStates[BSTYPE_TRANSPARENT];
- desc.pt = LINELIST;
+ desc.pt = PrimitiveTopology::LINELIST;
break;
case DEBUGRENDERING_TRIANGLE_SOLID:
desc.vs = &shaders[VSTYPE_VERTEXCOLOR];
@@ -1648,7 +1514,7 @@ void LoadShaders()
desc.dss = &depthStencils[DSSTYPE_DEPTHREAD];
desc.rs = &rasterizers[RSTYPE_DOUBLESIDED];
desc.bs = &blendStates[BSTYPE_TRANSPARENT];
- desc.pt = TRIANGLELIST;
+ desc.pt = PrimitiveTopology::TRIANGLELIST;
break;
case DEBUGRENDERING_TRIANGLE_WIREFRAME:
desc.vs = &shaders[VSTYPE_VERTEXCOLOR];
@@ -1657,7 +1523,7 @@ void LoadShaders()
desc.dss = &depthStencils[DSSTYPE_DEPTHREAD];
desc.rs = &rasterizers[RSTYPE_WIRE_DOUBLESIDED_SMOOTH];
desc.bs = &blendStates[BSTYPE_TRANSPARENT];
- desc.pt = TRIANGLELIST;
+ desc.pt = PrimitiveTopology::TRIANGLELIST;
break;
case DEBUGRENDERING_EMITTER:
desc.vs = &shaders[VSTYPE_OBJECT_DEBUG];
@@ -1666,7 +1532,7 @@ void LoadShaders()
desc.dss = &depthStencils[DSSTYPE_DEPTHREAD];
desc.rs = &rasterizers[RSTYPE_WIRE_DOUBLESIDED_SMOOTH];
desc.bs = &blendStates[BSTYPE_OPAQUE];
- desc.pt = TRIANGLELIST;
+ desc.pt = PrimitiveTopology::TRIANGLELIST;
break;
case DEBUGRENDERING_PAINTRADIUS:
desc.vs = &shaders[VSTYPE_OBJECT_SIMPLE];
@@ -1674,7 +1540,7 @@ void LoadShaders()
desc.dss = &depthStencils[DSSTYPE_DEPTHREAD];
desc.rs = &rasterizers[RSTYPE_FRONT];
desc.bs = &blendStates[BSTYPE_TRANSPARENT];
- desc.pt = TRIANGLELIST;
+ desc.pt = PrimitiveTopology::TRIANGLELIST;
break;
case DEBUGRENDERING_VOXEL:
desc.vs = &shaders[VSTYPE_VOXEL];
@@ -1683,7 +1549,7 @@ void LoadShaders()
desc.dss = &depthStencils[DSSTYPE_DEFAULT];
desc.rs = &rasterizers[RSTYPE_BACK];
desc.bs = &blendStates[BSTYPE_OPAQUE];
- desc.pt = POINTLIST;
+ desc.pt = PrimitiveTopology::POINTLIST;
break;
case DEBUGRENDERING_FORCEFIELD_POINT:
desc.vs = &shaders[VSTYPE_FORCEFIELDVISUALIZER_POINT];
@@ -1691,7 +1557,7 @@ void LoadShaders()
desc.dss = &depthStencils[DSSTYPE_XRAY];
desc.rs = &rasterizers[RSTYPE_BACK];
desc.bs = &blendStates[BSTYPE_ADDITIVE];
- desc.pt = TRIANGLELIST;
+ desc.pt = PrimitiveTopology::TRIANGLELIST;
break;
case DEBUGRENDERING_FORCEFIELD_PLANE:
desc.vs = &shaders[VSTYPE_FORCEFIELDVISUALIZER_PLANE];
@@ -1699,7 +1565,7 @@ void LoadShaders()
desc.dss = &depthStencils[DSSTYPE_XRAY];
desc.rs = &rasterizers[RSTYPE_FRONT];
desc.bs = &blendStates[BSTYPE_ADDITIVE];
- desc.pt = TRIANGLESTRIP;
+ desc.pt = PrimitiveTopology::TRIANGLESTRIP;
break;
case DEBUGRENDERING_RAYTRACE_BVH:
desc.vs = &shaders[VSTYPE_RAYTRACE_SCREEN];
@@ -1707,56 +1573,56 @@ void LoadShaders()
desc.dss = &depthStencils[DSSTYPE_XRAY];
desc.rs = &rasterizers[RSTYPE_DOUBLESIDED];
desc.bs = &blendStates[BSTYPE_TRANSPARENT];
- desc.pt = TRIANGLELIST;
+ desc.pt = PrimitiveTopology::TRIANGLELIST;
break;
}
device->CreatePipelineState(&desc, &PSO_debug[args.jobIndex]);
});
- if(device->CheckCapability(GRAPHICSDEVICE_CAPABILITY_RAYTRACING))
+ if(device->CheckCapability(GraphicsDeviceCapability::RAYTRACING))
{
wiJobSystem::Execute(ctx, [](wiJobArgs args) {
- bool success = LoadShader(LIB, shaders[RTTYPE_RTREFLECTION], "rtreflectionLIB.cso");
+ bool success = LoadShader(ShaderStage::LIB, shaders[RTTYPE_RTREFLECTION], "rtreflectionLIB.cso");
assert(success);
RaytracingPipelineStateDesc rtdesc;
- rtdesc.shaderlibraries.emplace_back();
- rtdesc.shaderlibraries.back().shader = &shaders[RTTYPE_RTREFLECTION];
- rtdesc.shaderlibraries.back().function_name = "RTReflection_Raygen";
- rtdesc.shaderlibraries.back().type = ShaderLibrary::RAYGENERATION;
+ rtdesc.shader_libraries.emplace_back();
+ rtdesc.shader_libraries.back().shader = &shaders[RTTYPE_RTREFLECTION];
+ rtdesc.shader_libraries.back().function_name = "RTReflection_Raygen";
+ rtdesc.shader_libraries.back().type = ShaderLibrary::Type::RAYGENERATION;
- rtdesc.shaderlibraries.emplace_back();
- rtdesc.shaderlibraries.back().shader = &shaders[RTTYPE_RTREFLECTION];
- rtdesc.shaderlibraries.back().function_name = "RTReflection_ClosestHit";
- rtdesc.shaderlibraries.back().type = ShaderLibrary::CLOSESTHIT;
+ rtdesc.shader_libraries.emplace_back();
+ rtdesc.shader_libraries.back().shader = &shaders[RTTYPE_RTREFLECTION];
+ rtdesc.shader_libraries.back().function_name = "RTReflection_ClosestHit";
+ rtdesc.shader_libraries.back().type = ShaderLibrary::Type::CLOSESTHIT;
- rtdesc.shaderlibraries.emplace_back();
- rtdesc.shaderlibraries.back().shader = &shaders[RTTYPE_RTREFLECTION];
- rtdesc.shaderlibraries.back().function_name = "RTReflection_AnyHit";
- rtdesc.shaderlibraries.back().type = ShaderLibrary::ANYHIT;
+ rtdesc.shader_libraries.emplace_back();
+ rtdesc.shader_libraries.back().shader = &shaders[RTTYPE_RTREFLECTION];
+ rtdesc.shader_libraries.back().function_name = "RTReflection_AnyHit";
+ rtdesc.shader_libraries.back().type = ShaderLibrary::Type::ANYHIT;
- rtdesc.shaderlibraries.emplace_back();
- rtdesc.shaderlibraries.back().shader = &shaders[RTTYPE_RTREFLECTION];
- rtdesc.shaderlibraries.back().function_name = "RTReflection_Miss";
- rtdesc.shaderlibraries.back().type = ShaderLibrary::MISS;
+ rtdesc.shader_libraries.emplace_back();
+ rtdesc.shader_libraries.back().shader = &shaders[RTTYPE_RTREFLECTION];
+ rtdesc.shader_libraries.back().function_name = "RTReflection_Miss";
+ rtdesc.shader_libraries.back().type = ShaderLibrary::Type::MISS;
- rtdesc.hitgroups.emplace_back();
- rtdesc.hitgroups.back().type = ShaderHitGroup::GENERAL;
- rtdesc.hitgroups.back().name = "RTReflection_Raygen";
- rtdesc.hitgroups.back().general_shader = 0;
+ rtdesc.hit_groups.emplace_back();
+ rtdesc.hit_groups.back().type = ShaderHitGroup::Type::GENERAL;
+ rtdesc.hit_groups.back().name = "RTReflection_Raygen";
+ rtdesc.hit_groups.back().general_shader = 0;
- rtdesc.hitgroups.emplace_back();
- rtdesc.hitgroups.back().type = ShaderHitGroup::GENERAL;
- rtdesc.hitgroups.back().name = "RTReflection_Miss";
- rtdesc.hitgroups.back().general_shader = 3;
+ rtdesc.hit_groups.emplace_back();
+ rtdesc.hit_groups.back().type = ShaderHitGroup::Type::GENERAL;
+ rtdesc.hit_groups.back().name = "RTReflection_Miss";
+ rtdesc.hit_groups.back().general_shader = 3;
- rtdesc.hitgroups.emplace_back();
- rtdesc.hitgroups.back().type = ShaderHitGroup::TRIANGLES;
- rtdesc.hitgroups.back().name = "RTReflection_Hitgroup";
- rtdesc.hitgroups.back().closesthit_shader = 1;
- rtdesc.hitgroups.back().anyhit_shader = 2;
+ rtdesc.hit_groups.emplace_back();
+ rtdesc.hit_groups.back().type = ShaderHitGroup::Type::TRIANGLES;
+ rtdesc.hit_groups.back().name = "RTReflection_Hitgroup";
+ rtdesc.hit_groups.back().closest_hit_shader = 1;
+ rtdesc.hit_groups.back().any_hit_shader = 2;
rtdesc.max_trace_recursion_depth = 1;
rtdesc.max_payload_size_in_bytes = sizeof(float4);
@@ -1775,394 +1641,394 @@ void LoadBuffers()
GPUBufferDesc bd;
// The following buffers will be DEFAULT (long lifetime, slow update, fast read):
- bd.Usage = USAGE_DEFAULT;
+ bd.usage = Usage::DEFAULT;
- bd.Size = sizeof(FrameCB);
- bd.BindFlags = BIND_CONSTANT_BUFFER;
+ bd.size = sizeof(FrameCB);
+ bd.bind_flags = BindFlag::CONSTANT_BUFFER;
device->CreateBuffer(&bd, nullptr, &constantBuffers[CBTYPE_FRAME]);
device->SetName(&constantBuffers[CBTYPE_FRAME], "FrameCB");
- bd.Size = sizeof(ShaderEntity) * SHADER_ENTITY_COUNT;
- bd.BindFlags = BIND_SHADER_RESOURCE;
- bd.MiscFlags = RESOURCE_MISC_BUFFER_RAW;
- bd.Stride = sizeof(ShaderEntity);
+ bd.size = sizeof(ShaderEntity) * SHADER_ENTITY_COUNT;
+ bd.bind_flags = BindFlag::SHADER_RESOURCE;
+ bd.misc_flags = ResourceMiscFlag::BUFFER_RAW;
+ bd.stride = sizeof(ShaderEntity);
device->CreateBuffer(&bd, nullptr, &resourceBuffers[RBTYPE_ENTITYARRAY]);
device->SetName(&resourceBuffers[RBTYPE_ENTITYARRAY], "EntityArray");
- bd.Size = sizeof(XMMATRIX) * MATRIXARRAY_COUNT;
- bd.BindFlags = BIND_SHADER_RESOURCE;
- bd.MiscFlags = RESOURCE_MISC_BUFFER_RAW;
- bd.Stride = sizeof(XMMATRIX);
+ bd.size = sizeof(XMMATRIX) * MATRIXARRAY_COUNT;
+ bd.bind_flags = BindFlag::SHADER_RESOURCE;
+ bd.misc_flags = ResourceMiscFlag::BUFFER_RAW;
+ bd.stride = sizeof(XMMATRIX);
device->CreateBuffer(&bd, nullptr, &resourceBuffers[RBTYPE_MATRIXARRAY]);
device->SetName(&resourceBuffers[RBTYPE_MATRIXARRAY], "MatrixArray");
{
TextureDesc desc;
- desc.BindFlags = BIND_SHADER_RESOURCE;
- desc.Format = FORMAT_R8_UNORM;
- desc.Height = 16;
- desc.Width = 16;
+ desc.bind_flags = BindFlag::SHADER_RESOURCE;
+ desc.format = Format::R8_UNORM;
+ desc.height = 16;
+ desc.width = 16;
SubresourceData InitData;
- InitData.pData = sheenLUTdata;
- InitData.rowPitch = desc.Width;
+ InitData.data_ptr = sheenLUTdata;
+ InitData.row_pitch = desc.width;
device->CreateTexture(&desc, &InitData, &textures[TEXTYPE_2D_SHEENLUT]);
}
{
TextureDesc desc;
- desc.type = TextureDesc::TEXTURE_2D;
- desc.Width = 256;
- desc.Height = 64;
- desc.Format = FORMAT_R16G16B16A16_FLOAT;
- desc.BindFlags = BIND_SHADER_RESOURCE | BIND_UNORDERED_ACCESS;
+ desc.type = TextureDesc::Type::TEXTURE_2D;
+ desc.width = 256;
+ desc.height = 64;
+ desc.format = Format::R16G16B16A16_FLOAT;
+ desc.bind_flags = BindFlag::SHADER_RESOURCE | BindFlag::UNORDERED_ACCESS;
device->CreateTexture(&desc, nullptr, &textures[TEXTYPE_2D_SKYATMOSPHERE_TRANSMITTANCELUT]);
}
{
TextureDesc desc;
- desc.type = TextureDesc::TEXTURE_2D;
- desc.Width = 32;
- desc.Height = 32;
- desc.Format = FORMAT_R16G16B16A16_FLOAT;
- desc.BindFlags = BIND_SHADER_RESOURCE | BIND_UNORDERED_ACCESS;
+ desc.type = TextureDesc::Type::TEXTURE_2D;
+ desc.width = 32;
+ desc.height = 32;
+ desc.format = Format::R16G16B16A16_FLOAT;
+ desc.bind_flags = BindFlag::SHADER_RESOURCE | BindFlag::UNORDERED_ACCESS;
device->CreateTexture(&desc, nullptr, &textures[TEXTYPE_2D_SKYATMOSPHERE_MULTISCATTEREDLUMINANCELUT]);
}
{
TextureDesc desc;
- desc.type = TextureDesc::TEXTURE_2D;
- desc.Width = 192;
- desc.Height = 104;
- desc.Format = FORMAT_R16G16B16A16_FLOAT;
- desc.BindFlags = BIND_SHADER_RESOURCE | BIND_UNORDERED_ACCESS;
+ desc.type = TextureDesc::Type::TEXTURE_2D;
+ desc.width = 192;
+ desc.height = 104;
+ desc.format = Format::R16G16B16A16_FLOAT;
+ desc.bind_flags = BindFlag::SHADER_RESOURCE | BindFlag::UNORDERED_ACCESS;
device->CreateTexture(&desc, nullptr, &textures[TEXTYPE_2D_SKYATMOSPHERE_SKYVIEWLUT]);
}
{
TextureDesc desc;
- desc.type = TextureDesc::TEXTURE_2D;
- desc.Width = 1;
- desc.Height = 1;
- desc.Format = FORMAT_R16G16B16A16_FLOAT;
- desc.BindFlags = BIND_SHADER_RESOURCE | BIND_UNORDERED_ACCESS;
+ desc.type = TextureDesc::Type::TEXTURE_2D;
+ desc.width = 1;
+ desc.height = 1;
+ desc.format = Format::R16G16B16A16_FLOAT;
+ desc.bind_flags = BindFlag::SHADER_RESOURCE | BindFlag::UNORDERED_ACCESS;
device->CreateTexture(&desc, nullptr, &textures[TEXTYPE_2D_SKYATMOSPHERE_SKYLUMINANCELUT]);
}
}
void SetUpStates()
{
RasterizerState rs;
- rs.FillMode = FILL_SOLID;
- rs.CullMode = CULL_BACK;
- rs.FrontCounterClockwise = true;
- rs.DepthBias = 0;
- rs.DepthBiasClamp = 0;
- rs.SlopeScaledDepthBias = 0;
- rs.DepthClipEnable = true;
- rs.MultisampleEnable = false;
- rs.AntialiasedLineEnable = false;
- rs.ConservativeRasterizationEnable = false;
+ rs.fill_mode = FillMode::SOLID;
+ rs.cull_mode = CullMode::BACK;
+ rs.front_counter_clockwise = true;
+ rs.depth_bias = 0;
+ rs.depth_bias_clamp = 0;
+ rs.slope_scaled_depth_bias = 0;
+ rs.depth_clip_enable = true;
+ rs.multisample_enable = false;
+ rs.antialiased_line_enable = false;
+ rs.conservative_rasterization_enable = false;
rasterizers[RSTYPE_FRONT] = rs;
- rs.FillMode = FILL_SOLID;
- rs.CullMode = CULL_BACK;
- rs.FrontCounterClockwise = true;
- rs.DepthBias = -1;
- rs.DepthBiasClamp = 0;
- rs.SlopeScaledDepthBias = -4.0f;
- rs.DepthClipEnable = true;
- rs.MultisampleEnable = false;
- rs.AntialiasedLineEnable = false;
- rs.ConservativeRasterizationEnable = false;
+ rs.fill_mode = FillMode::SOLID;
+ rs.cull_mode = CullMode::BACK;
+ rs.front_counter_clockwise = true;
+ rs.depth_bias = -1;
+ rs.depth_bias_clamp = 0;
+ rs.slope_scaled_depth_bias = -4.0f;
+ rs.depth_clip_enable = true;
+ rs.multisample_enable = false;
+ rs.antialiased_line_enable = false;
+ rs.conservative_rasterization_enable = false;
rasterizers[RSTYPE_SHADOW] = rs;
- rs.CullMode = CULL_NONE;
+ rs.cull_mode = CullMode::NONE;
rasterizers[RSTYPE_SHADOW_DOUBLESIDED] = rs;
- rs.FillMode = FILL_WIREFRAME;
- rs.CullMode = CULL_BACK;
- rs.FrontCounterClockwise = true;
- rs.DepthBias = 0;
- rs.DepthBiasClamp = 0;
- rs.SlopeScaledDepthBias = 0;
- rs.DepthClipEnable = true;
- rs.MultisampleEnable = false;
- rs.AntialiasedLineEnable = false;
- rs.ConservativeRasterizationEnable = false;
+ rs.fill_mode = FillMode::WIREFRAME;
+ rs.cull_mode = CullMode::BACK;
+ rs.front_counter_clockwise = true;
+ rs.depth_bias = 0;
+ rs.depth_bias_clamp = 0;
+ rs.slope_scaled_depth_bias = 0;
+ rs.depth_clip_enable = true;
+ rs.multisample_enable = false;
+ rs.antialiased_line_enable = false;
+ rs.conservative_rasterization_enable = false;
rasterizers[RSTYPE_WIRE] = rs;
- rs.AntialiasedLineEnable = true;
+ rs.antialiased_line_enable = true;
rasterizers[RSTYPE_WIRE_SMOOTH] = rs;
- rs.FillMode = FILL_SOLID;
- rs.CullMode = CULL_NONE;
- rs.FrontCounterClockwise = true;
- rs.DepthBias = 0;
- rs.DepthBiasClamp = 0;
- rs.SlopeScaledDepthBias = 0;
- rs.DepthClipEnable = true;
- rs.MultisampleEnable = false;
- rs.AntialiasedLineEnable = false;
- rs.ConservativeRasterizationEnable = false;
+ rs.fill_mode = FillMode::SOLID;
+ rs.cull_mode = CullMode::NONE;
+ rs.front_counter_clockwise = true;
+ rs.depth_bias = 0;
+ rs.depth_bias_clamp = 0;
+ rs.slope_scaled_depth_bias = 0;
+ rs.depth_clip_enable = true;
+ rs.multisample_enable = false;
+ rs.antialiased_line_enable = false;
+ rs.conservative_rasterization_enable = false;
rasterizers[RSTYPE_DOUBLESIDED] = rs;
- rs.FillMode = FILL_WIREFRAME;
- rs.CullMode = CULL_NONE;
- rs.FrontCounterClockwise = true;
- rs.DepthBias = 0;
- rs.DepthBiasClamp = 0;
- rs.SlopeScaledDepthBias = 0;
- rs.DepthClipEnable = true;
- rs.MultisampleEnable = false;
- rs.AntialiasedLineEnable = false;
- rs.ConservativeRasterizationEnable = false;
+ rs.fill_mode = FillMode::WIREFRAME;
+ rs.cull_mode = CullMode::NONE;
+ rs.front_counter_clockwise = true;
+ rs.depth_bias = 0;
+ rs.depth_bias_clamp = 0;
+ rs.slope_scaled_depth_bias = 0;
+ rs.depth_clip_enable = true;
+ rs.multisample_enable = false;
+ rs.antialiased_line_enable = false;
+ rs.conservative_rasterization_enable = false;
rasterizers[RSTYPE_WIRE_DOUBLESIDED] = rs;
- rs.AntialiasedLineEnable = true;
+ rs.antialiased_line_enable = true;
rasterizers[RSTYPE_WIRE_DOUBLESIDED_SMOOTH] = rs;
- rs.FillMode = FILL_SOLID;
- rs.CullMode = CULL_FRONT;
- rs.FrontCounterClockwise = true;
- rs.DepthBias = 0;
- rs.DepthBiasClamp = 0;
- rs.SlopeScaledDepthBias = 0;
- rs.DepthClipEnable = true;
- rs.MultisampleEnable = false;
- rs.AntialiasedLineEnable = false;
- rs.ConservativeRasterizationEnable = false;
+ rs.fill_mode = FillMode::SOLID;
+ rs.cull_mode = CullMode::FRONT;
+ rs.front_counter_clockwise = true;
+ rs.depth_bias = 0;
+ rs.depth_bias_clamp = 0;
+ rs.slope_scaled_depth_bias = 0;
+ rs.depth_clip_enable = true;
+ rs.multisample_enable = false;
+ rs.antialiased_line_enable = false;
+ rs.conservative_rasterization_enable = false;
rasterizers[RSTYPE_BACK] = rs;
- rs.FillMode = FILL_SOLID;
- rs.CullMode = CULL_NONE;
- rs.FrontCounterClockwise = true;
- rs.DepthBias = 2;
- rs.DepthBiasClamp = 0;
- rs.SlopeScaledDepthBias = 2;
- rs.DepthClipEnable = false;
- rs.MultisampleEnable = false;
- rs.AntialiasedLineEnable = false;
- rs.ConservativeRasterizationEnable = false;
+ rs.fill_mode = FillMode::SOLID;
+ rs.cull_mode = CullMode::NONE;
+ rs.front_counter_clockwise = true;
+ rs.depth_bias = 2;
+ rs.depth_bias_clamp = 0;
+ rs.slope_scaled_depth_bias = 2;
+ rs.depth_clip_enable = false;
+ rs.multisample_enable = false;
+ rs.antialiased_line_enable = false;
+ rs.conservative_rasterization_enable = false;
rasterizers[RSTYPE_OCCLUDEE] = rs;
- rs.FillMode = FILL_SOLID;
- rs.CullMode = CULL_FRONT;
- rs.FrontCounterClockwise = true;
- rs.DepthBias = 0;
- rs.DepthBiasClamp = 0;
- rs.SlopeScaledDepthBias = 0;
- rs.DepthClipEnable = false;
- rs.MultisampleEnable = false;
- rs.AntialiasedLineEnable = false;
- rs.ConservativeRasterizationEnable = false;
+ rs.fill_mode = FillMode::SOLID;
+ rs.cull_mode = CullMode::FRONT;
+ rs.front_counter_clockwise = true;
+ rs.depth_bias = 0;
+ rs.depth_bias_clamp = 0;
+ rs.slope_scaled_depth_bias = 0;
+ rs.depth_clip_enable = false;
+ rs.multisample_enable = false;
+ rs.antialiased_line_enable = false;
+ rs.conservative_rasterization_enable = false;
rasterizers[RSTYPE_SKY] = rs;
- rs.FillMode = FILL_SOLID;
- rs.CullMode = CULL_NONE;
- rs.FrontCounterClockwise = true;
- rs.DepthBias = 0;
- rs.DepthBiasClamp = 0;
- rs.SlopeScaledDepthBias = 0;
- rs.DepthClipEnable = true;
- rs.MultisampleEnable = false;
- rs.AntialiasedLineEnable = false;
- rs.ConservativeRasterizationEnable = false;
- rs.ForcedSampleCount = 8;
+ rs.fill_mode = FillMode::SOLID;
+ rs.cull_mode = CullMode::NONE;
+ rs.front_counter_clockwise = true;
+ rs.depth_bias = 0;
+ rs.depth_bias_clamp = 0;
+ rs.slope_scaled_depth_bias = 0;
+ rs.depth_clip_enable = true;
+ rs.multisample_enable = false;
+ rs.antialiased_line_enable = false;
+ rs.conservative_rasterization_enable = false;
+ rs.forced_sample_count = 8;
rasterizers[RSTYPE_VOXELIZE] = rs;
DepthStencilState dsd;
- dsd.DepthEnable = true;
- dsd.DepthWriteMask = DEPTH_WRITE_MASK_ALL;
- dsd.DepthFunc = COMPARISON_GREATER;
+ dsd.depth_enable = true;
+ dsd.depth_write_mask = DepthWriteMask::ALL;
+ dsd.depth_func = ComparisonFunc::GREATER;
- dsd.StencilEnable = true;
- dsd.StencilReadMask = 0;
- dsd.StencilWriteMask = 0xFF;
- dsd.FrontFace.StencilFunc = COMPARISON_ALWAYS;
- dsd.FrontFace.StencilPassOp = STENCIL_OP_REPLACE;
- dsd.FrontFace.StencilFailOp = STENCIL_OP_KEEP;
- dsd.FrontFace.StencilDepthFailOp = STENCIL_OP_KEEP;
- dsd.BackFace.StencilFunc = COMPARISON_ALWAYS;
- dsd.BackFace.StencilPassOp = STENCIL_OP_REPLACE;
- dsd.BackFace.StencilFailOp = STENCIL_OP_KEEP;
- dsd.BackFace.StencilDepthFailOp = STENCIL_OP_KEEP;
+ dsd.stencil_enable = true;
+ dsd.stencil_read_mask = 0;
+ dsd.stencil_write_mask = 0xFF;
+ dsd.front_face.stencil_func = ComparisonFunc::ALWAYS;
+ dsd.front_face.stencil_pass_op = StencilOp::REPLACE;
+ dsd.front_face.stencil_fail_op = StencilOp::KEEP;
+ dsd.front_face.stencil_depth_fail_op = StencilOp::KEEP;
+ dsd.back_face.stencil_func = ComparisonFunc::ALWAYS;
+ dsd.back_face.stencil_pass_op = StencilOp::REPLACE;
+ dsd.back_face.stencil_fail_op = StencilOp::KEEP;
+ dsd.back_face.stencil_depth_fail_op = StencilOp::KEEP;
depthStencils[DSSTYPE_DEFAULT] = dsd;
- dsd.DepthWriteMask = DEPTH_WRITE_MASK_ZERO;
+ dsd.depth_write_mask = DepthWriteMask::ZERO;
depthStencils[DSSTYPE_HOLOGRAM] = dsd;
- dsd.DepthEnable = true;
- dsd.DepthWriteMask = DEPTH_WRITE_MASK_ALL;
- dsd.DepthFunc = COMPARISON_GREATER;
- dsd.StencilEnable = false;
+ dsd.depth_enable = true;
+ dsd.depth_write_mask = DepthWriteMask::ALL;
+ dsd.depth_func = ComparisonFunc::GREATER;
+ dsd.stencil_enable = false;
depthStencils[DSSTYPE_SHADOW] = dsd;
- dsd.DepthEnable = true;
- dsd.DepthWriteMask = DEPTH_WRITE_MASK_ALL;
- dsd.DepthFunc = COMPARISON_GREATER;
- dsd.StencilEnable = false;
+ dsd.depth_enable = true;
+ dsd.depth_write_mask = DepthWriteMask::ALL;
+ dsd.depth_func = ComparisonFunc::GREATER;
+ dsd.stencil_enable = false;
depthStencils[DSSTYPE_CAPTUREIMPOSTOR] = dsd;
- dsd.DepthEnable = true;
- dsd.StencilEnable = false;
- dsd.DepthWriteMask = DEPTH_WRITE_MASK_ZERO;
- dsd.DepthFunc = COMPARISON_GREATER_EQUAL;
+ dsd.depth_enable = true;
+ dsd.stencil_enable = false;
+ dsd.depth_write_mask = DepthWriteMask::ZERO;
+ dsd.depth_func = ComparisonFunc::GREATER_EQUAL;
depthStencils[DSSTYPE_DEPTHREAD] = dsd;
- dsd.DepthEnable = false;
- dsd.StencilEnable = false;
+ dsd.depth_enable = false;
+ dsd.stencil_enable = false;
depthStencils[DSSTYPE_XRAY] = dsd;
- dsd.DepthEnable = true;
- dsd.DepthWriteMask = DEPTH_WRITE_MASK_ZERO;
- dsd.DepthFunc = COMPARISON_EQUAL;
+ dsd.depth_enable = true;
+ dsd.depth_write_mask = DepthWriteMask::ZERO;
+ dsd.depth_func = ComparisonFunc::EQUAL;
depthStencils[DSSTYPE_DEPTHREADEQUAL] = dsd;
- dsd.DepthEnable = true;
- dsd.DepthWriteMask = DEPTH_WRITE_MASK_ALL;
- dsd.DepthFunc = COMPARISON_GREATER;
+ dsd.depth_enable = true;
+ dsd.depth_write_mask = DepthWriteMask::ALL;
+ dsd.depth_func = ComparisonFunc::GREATER;
depthStencils[DSSTYPE_ENVMAP] = dsd;
- dsd.DepthEnable = true;
- dsd.DepthWriteMask = DEPTH_WRITE_MASK_ALL;
- dsd.DepthFunc = COMPARISON_ALWAYS;
- dsd.StencilEnable = false;
+ dsd.depth_enable = true;
+ dsd.depth_write_mask = DepthWriteMask::ALL;
+ dsd.depth_func = ComparisonFunc::ALWAYS;
+ dsd.stencil_enable = false;
depthStencils[DSSTYPE_WRITEONLY] = dsd;
BlendState bd;
- bd.RenderTarget[0].BlendEnable = false;
- bd.RenderTarget[0].SrcBlend = BLEND_SRC_ALPHA;
- bd.RenderTarget[0].DestBlend = BLEND_INV_SRC_ALPHA;
- bd.RenderTarget[0].BlendOp = BLEND_OP_MAX;
- bd.RenderTarget[0].SrcBlendAlpha = BLEND_ONE;
- bd.RenderTarget[0].DestBlendAlpha = BLEND_ZERO;
- bd.RenderTarget[0].BlendOpAlpha = BLEND_OP_ADD;
- bd.RenderTarget[0].RenderTargetWriteMask = COLOR_WRITE_ENABLE_ALL;
- bd.AlphaToCoverageEnable = false;
- bd.IndependentBlendEnable = false;
+ bd.render_target[0].blend_enable = false;
+ bd.render_target[0].src_blend = Blend::SRC_ALPHA;
+ bd.render_target[0].dest_blend = Blend::INV_SRC_ALPHA;
+ bd.render_target[0].blend_op = BlendOp::MAX;
+ bd.render_target[0].src_blend_alpha = Blend::ONE;
+ bd.render_target[0].dest_blend_alpha = Blend::ZERO;
+ bd.render_target[0].blend_op_alpha = BlendOp::ADD;
+ bd.render_target[0].render_target_write_mask = ColorWrite::ENABLE_ALL;
+ bd.alpha_to_coverage_enable = false;
+ bd.independent_blend_enable = false;
blendStates[BSTYPE_OPAQUE] = bd;
- bd.RenderTarget[0].SrcBlend = BLEND_SRC_ALPHA;
- bd.RenderTarget[0].DestBlend = BLEND_INV_SRC_ALPHA;
- bd.RenderTarget[0].BlendOp = BLEND_OP_ADD;
- bd.RenderTarget[0].SrcBlendAlpha = BLEND_ONE;
- bd.RenderTarget[0].DestBlendAlpha = BLEND_INV_SRC_ALPHA;
- bd.RenderTarget[0].BlendOpAlpha = BLEND_OP_ADD;
- bd.RenderTarget[0].BlendEnable = true;
- bd.RenderTarget[0].RenderTargetWriteMask = COLOR_WRITE_ENABLE_ALL;
- bd.AlphaToCoverageEnable = false;
- bd.IndependentBlendEnable = false;
+ bd.render_target[0].src_blend = Blend::SRC_ALPHA;
+ bd.render_target[0].dest_blend = Blend::INV_SRC_ALPHA;
+ bd.render_target[0].blend_op = BlendOp::ADD;
+ bd.render_target[0].src_blend_alpha = Blend::ONE;
+ bd.render_target[0].dest_blend_alpha = Blend::INV_SRC_ALPHA;
+ bd.render_target[0].blend_op_alpha = BlendOp::ADD;
+ bd.render_target[0].blend_enable = true;
+ bd.render_target[0].render_target_write_mask = ColorWrite::ENABLE_ALL;
+ bd.alpha_to_coverage_enable = false;
+ bd.independent_blend_enable = false;
blendStates[BSTYPE_TRANSPARENT] = bd;
- bd.RenderTarget[0].BlendEnable = true;
- bd.RenderTarget[0].SrcBlend = BLEND_ONE;
- bd.RenderTarget[0].DestBlend = BLEND_INV_SRC_ALPHA;
- bd.RenderTarget[0].BlendOp = BLEND_OP_ADD;
- bd.RenderTarget[0].SrcBlendAlpha = BLEND_ONE;
- bd.RenderTarget[0].DestBlendAlpha = BLEND_INV_SRC_ALPHA;
- bd.RenderTarget[0].BlendOpAlpha = BLEND_OP_ADD;
- bd.RenderTarget[0].RenderTargetWriteMask = COLOR_WRITE_ENABLE_ALL;
- bd.IndependentBlendEnable = false;
- bd.AlphaToCoverageEnable = false;
+ bd.render_target[0].blend_enable = true;
+ bd.render_target[0].src_blend = Blend::ONE;
+ bd.render_target[0].dest_blend = Blend::INV_SRC_ALPHA;
+ bd.render_target[0].blend_op = BlendOp::ADD;
+ bd.render_target[0].src_blend_alpha = Blend::ONE;
+ bd.render_target[0].dest_blend_alpha = Blend::INV_SRC_ALPHA;
+ bd.render_target[0].blend_op_alpha = BlendOp::ADD;
+ bd.render_target[0].render_target_write_mask = ColorWrite::ENABLE_ALL;
+ bd.independent_blend_enable = false;
+ bd.alpha_to_coverage_enable = false;
blendStates[BSTYPE_PREMULTIPLIED] = bd;
- bd.RenderTarget[0].BlendEnable = true;
- bd.RenderTarget[0].SrcBlend = BLEND_SRC_ALPHA;
- bd.RenderTarget[0].DestBlend = BLEND_ONE;
- bd.RenderTarget[0].BlendOp = BLEND_OP_ADD;
- bd.RenderTarget[0].SrcBlendAlpha = BLEND_ZERO;
- bd.RenderTarget[0].DestBlendAlpha = BLEND_ONE;
- bd.RenderTarget[0].BlendOpAlpha = BLEND_OP_ADD;
- bd.RenderTarget[0].RenderTargetWriteMask = COLOR_WRITE_ENABLE_ALL;
- bd.IndependentBlendEnable = false,
- bd.AlphaToCoverageEnable = false;
+ bd.render_target[0].blend_enable = true;
+ bd.render_target[0].src_blend = Blend::SRC_ALPHA;
+ bd.render_target[0].dest_blend = Blend::ONE;
+ bd.render_target[0].blend_op = BlendOp::ADD;
+ bd.render_target[0].src_blend_alpha = Blend::ZERO;
+ bd.render_target[0].dest_blend_alpha = Blend::ONE;
+ bd.render_target[0].blend_op_alpha = BlendOp::ADD;
+ bd.render_target[0].render_target_write_mask = ColorWrite::ENABLE_ALL;
+ bd.independent_blend_enable = false,
+ bd.alpha_to_coverage_enable = false;
blendStates[BSTYPE_ADDITIVE] = bd;
- bd.RenderTarget[0].BlendEnable = false;
- bd.RenderTarget[0].RenderTargetWriteMask = COLOR_WRITE_DISABLE;
- bd.IndependentBlendEnable = false,
- bd.AlphaToCoverageEnable = false;
+ bd.render_target[0].blend_enable = false;
+ bd.render_target[0].render_target_write_mask = ColorWrite::DISABLE;
+ bd.independent_blend_enable = false,
+ bd.alpha_to_coverage_enable = false;
blendStates[BSTYPE_COLORWRITEDISABLE] = bd;
- bd.RenderTarget[0].BlendEnable = true;
- bd.RenderTarget[0].SrcBlend = BLEND_ONE;
- bd.RenderTarget[0].DestBlend = BLEND_ONE;
- bd.RenderTarget[0].BlendOp = BLEND_OP_ADD;
- bd.RenderTarget[0].SrcBlendAlpha = BLEND_ONE;
- bd.RenderTarget[0].DestBlendAlpha = BLEND_ONE;
- bd.RenderTarget[0].BlendOpAlpha = BLEND_OP_ADD;
- bd.RenderTarget[0].RenderTargetWriteMask = COLOR_WRITE_ENABLE_RED | COLOR_WRITE_ENABLE_GREEN | COLOR_WRITE_ENABLE_BLUE; // alpha is not written by deferred lights!
- bd.IndependentBlendEnable = false,
- bd.AlphaToCoverageEnable = false;
+ bd.render_target[0].blend_enable = true;
+ bd.render_target[0].src_blend = Blend::ONE;
+ bd.render_target[0].dest_blend = Blend::ONE;
+ bd.render_target[0].blend_op = BlendOp::ADD;
+ bd.render_target[0].src_blend_alpha = Blend::ONE;
+ bd.render_target[0].dest_blend_alpha = Blend::ONE;
+ bd.render_target[0].blend_op_alpha = BlendOp::ADD;
+ bd.render_target[0].render_target_write_mask = ColorWrite::ENABLE_RED | ColorWrite::ENABLE_GREEN | ColorWrite::ENABLE_BLUE; // alpha is not written by deferred lights!
+ bd.independent_blend_enable = false,
+ bd.alpha_to_coverage_enable = false;
//device->CreateBlendState(&bd, &blendStates[BSTYPE_DEFERREDLIGHT]);
- bd.RenderTarget[0].BlendEnable = true;
- bd.RenderTarget[0].SrcBlend = BLEND_ONE;
- bd.RenderTarget[0].DestBlend = BLEND_INV_SRC_ALPHA; // can overwrite ambient and lightmap
- bd.RenderTarget[0].BlendOp = BLEND_OP_ADD;
- bd.RenderTarget[0].SrcBlendAlpha = BLEND_ONE;
- bd.RenderTarget[0].DestBlendAlpha = BLEND_ONE;
- bd.RenderTarget[0].BlendOpAlpha = BLEND_OP_ADD;
- bd.RenderTarget[0].RenderTargetWriteMask = COLOR_WRITE_ENABLE_RED | COLOR_WRITE_ENABLE_GREEN | COLOR_WRITE_ENABLE_BLUE; // alpha is not written by deferred lights!
- bd.IndependentBlendEnable = false;
- bd.AlphaToCoverageEnable = false;
+ bd.render_target[0].blend_enable = true;
+ bd.render_target[0].src_blend = Blend::ONE;
+ bd.render_target[0].dest_blend = Blend::INV_SRC_ALPHA; // can overwrite ambient and lightmap
+ bd.render_target[0].blend_op = BlendOp::ADD;
+ bd.render_target[0].src_blend_alpha = Blend::ONE;
+ bd.render_target[0].dest_blend_alpha = Blend::ONE;
+ bd.render_target[0].blend_op_alpha = BlendOp::ADD;
+ bd.render_target[0].render_target_write_mask = ColorWrite::ENABLE_RED | ColorWrite::ENABLE_GREEN | ColorWrite::ENABLE_BLUE; // alpha is not written by deferred lights!
+ bd.independent_blend_enable = false;
+ bd.alpha_to_coverage_enable = false;
blendStates[BSTYPE_ENVIRONMENTALLIGHT] = bd;
- bd.RenderTarget[0].SrcBlend = BLEND_INV_SRC_COLOR;
- bd.RenderTarget[0].DestBlend = BLEND_INV_DEST_COLOR;
- bd.RenderTarget[0].BlendOp = BLEND_OP_ADD;
- bd.RenderTarget[0].SrcBlendAlpha = BLEND_ONE;
- bd.RenderTarget[0].DestBlendAlpha = BLEND_ONE;
- bd.RenderTarget[0].BlendOpAlpha = BLEND_OP_ADD;
- bd.RenderTarget[0].BlendEnable = true;
- bd.RenderTarget[0].RenderTargetWriteMask = COLOR_WRITE_ENABLE_ALL;
- bd.AlphaToCoverageEnable = false;
- bd.IndependentBlendEnable = false;
+ bd.render_target[0].src_blend = Blend::INV_SRC_COLOR;
+ bd.render_target[0].dest_blend = Blend::INV_DEST_COLOR;
+ bd.render_target[0].blend_op = BlendOp::ADD;
+ bd.render_target[0].src_blend_alpha = Blend::ONE;
+ bd.render_target[0].dest_blend_alpha = Blend::ONE;
+ bd.render_target[0].blend_op_alpha = BlendOp::ADD;
+ bd.render_target[0].blend_enable = true;
+ bd.render_target[0].render_target_write_mask = ColorWrite::ENABLE_ALL;
+ bd.alpha_to_coverage_enable = false;
+ bd.independent_blend_enable = false;
blendStates[BSTYPE_INVERSE] = bd;
- bd.RenderTarget[0].SrcBlend = BLEND_SRC_ALPHA;
- bd.RenderTarget[0].DestBlend = BLEND_INV_SRC_ALPHA;
- bd.RenderTarget[0].BlendOp = BLEND_OP_ADD;
- bd.RenderTarget[0].SrcBlendAlpha = BLEND_ONE;
- bd.RenderTarget[0].DestBlendAlpha = BLEND_ONE;
- bd.RenderTarget[0].BlendOpAlpha = BLEND_OP_ADD;
- bd.RenderTarget[0].BlendEnable = true;
- bd.RenderTarget[0].RenderTargetWriteMask = COLOR_WRITE_ENABLE_RED | COLOR_WRITE_ENABLE_GREEN | COLOR_WRITE_ENABLE_BLUE;
- bd.RenderTarget[1] = bd.RenderTarget[0];
- bd.RenderTarget[1].RenderTargetWriteMask = COLOR_WRITE_ENABLE_RED | COLOR_WRITE_ENABLE_GREEN;
- bd.AlphaToCoverageEnable = false;
- bd.IndependentBlendEnable = true;
+ bd.render_target[0].src_blend = Blend::SRC_ALPHA;
+ bd.render_target[0].dest_blend = Blend::INV_SRC_ALPHA;
+ bd.render_target[0].blend_op = BlendOp::ADD;
+ bd.render_target[0].src_blend_alpha = Blend::ONE;
+ bd.render_target[0].dest_blend_alpha = Blend::ONE;
+ bd.render_target[0].blend_op_alpha = BlendOp::ADD;
+ bd.render_target[0].blend_enable = true;
+ bd.render_target[0].render_target_write_mask = ColorWrite::ENABLE_RED | ColorWrite::ENABLE_GREEN | ColorWrite::ENABLE_BLUE;
+ bd.render_target[1] = bd.render_target[0];
+ bd.render_target[1].render_target_write_mask = ColorWrite::ENABLE_RED | ColorWrite::ENABLE_GREEN;
+ bd.alpha_to_coverage_enable = false;
+ bd.independent_blend_enable = true;
blendStates[BSTYPE_DECAL] = bd;
- bd.RenderTarget[0].SrcBlend = BLEND_DEST_COLOR;
- bd.RenderTarget[0].DestBlend = BLEND_ZERO;
- bd.RenderTarget[0].BlendOp = BLEND_OP_ADD;
- bd.RenderTarget[0].SrcBlendAlpha = BLEND_DEST_ALPHA;
- bd.RenderTarget[0].DestBlendAlpha = BLEND_ZERO;
- bd.RenderTarget[0].BlendOpAlpha = BLEND_OP_ADD;
- bd.RenderTarget[0].BlendEnable = true;
- bd.RenderTarget[0].RenderTargetWriteMask = COLOR_WRITE_ENABLE_ALL;
- bd.AlphaToCoverageEnable = false;
- bd.IndependentBlendEnable = false;
+ bd.render_target[0].src_blend = Blend::DEST_COLOR;
+ bd.render_target[0].dest_blend = Blend::ZERO;
+ bd.render_target[0].blend_op = BlendOp::ADD;
+ bd.render_target[0].src_blend_alpha = Blend::DEST_ALPHA;
+ bd.render_target[0].dest_blend_alpha = Blend::ZERO;
+ bd.render_target[0].blend_op_alpha = BlendOp::ADD;
+ bd.render_target[0].blend_enable = true;
+ bd.render_target[0].render_target_write_mask = ColorWrite::ENABLE_ALL;
+ bd.alpha_to_coverage_enable = false;
+ bd.independent_blend_enable = false;
blendStates[BSTYPE_MULTIPLY] = bd;
- bd.RenderTarget[0].SrcBlend = BLEND_ZERO;
- bd.RenderTarget[0].DestBlend = BLEND_SRC_COLOR;
- bd.RenderTarget[0].BlendOp = BLEND_OP_ADD;
- bd.RenderTarget[0].SrcBlendAlpha = BLEND_ONE;
- bd.RenderTarget[0].DestBlendAlpha = BLEND_ONE;
- bd.RenderTarget[0].BlendOpAlpha = BLEND_OP_MAX;
- bd.RenderTarget[0].BlendEnable = true;
- bd.RenderTarget[0].RenderTargetWriteMask = COLOR_WRITE_ENABLE_ALL;
- bd.AlphaToCoverageEnable = false;
- bd.IndependentBlendEnable = false;
+ bd.render_target[0].src_blend = Blend::ZERO;
+ bd.render_target[0].dest_blend = Blend::SRC_COLOR;
+ bd.render_target[0].blend_op = BlendOp::ADD;
+ bd.render_target[0].src_blend_alpha = Blend::ONE;
+ bd.render_target[0].dest_blend_alpha = Blend::ONE;
+ bd.render_target[0].blend_op_alpha = BlendOp::MAX;
+ bd.render_target[0].blend_enable = true;
+ bd.render_target[0].render_target_write_mask = ColorWrite::ENABLE_ALL;
+ bd.alpha_to_coverage_enable = false;
+ bd.independent_blend_enable = false;
blendStates[BSTYPE_TRANSPARENTSHADOW] = bd;
}
@@ -2198,6 +2064,130 @@ void Initialize()
{
wiTimer timer;
+ SamplerDesc samplerDesc;
+ samplerDesc.filter = Filter::MIN_MAG_MIP_LINEAR;
+ samplerDesc.address_u = TextureAddressMode::MIRROR;
+ samplerDesc.address_v = TextureAddressMode::MIRROR;
+ samplerDesc.address_w = TextureAddressMode::MIRROR;
+ samplerDesc.mip_lod_bias = 0.0f;
+ samplerDesc.max_anisotropy = 0;
+ samplerDesc.comparison_func = ComparisonFunc::NEVER;
+ samplerDesc.border_color = SamplerBorderColor::TRANSPARENT_BLACK;
+ samplerDesc.min_lod = 0;
+ samplerDesc.max_lod = FLT_MAX;
+ device->CreateSampler(&samplerDesc, &samplers[SSLOT_LINEAR_MIRROR]);
+
+ samplerDesc.filter = Filter::MIN_MAG_MIP_LINEAR;
+ samplerDesc.address_u = TextureAddressMode::CLAMP;
+ samplerDesc.address_v = TextureAddressMode::CLAMP;
+ samplerDesc.address_w = TextureAddressMode::CLAMP;
+ device->CreateSampler(&samplerDesc, &samplers[SSLOT_LINEAR_CLAMP]);
+
+ samplerDesc.filter = Filter::MIN_MAG_MIP_LINEAR;
+ samplerDesc.address_u = TextureAddressMode::WRAP;
+ samplerDesc.address_v = TextureAddressMode::WRAP;
+ samplerDesc.address_w = TextureAddressMode::WRAP;
+ device->CreateSampler(&samplerDesc, &samplers[SSLOT_LINEAR_WRAP]);
+
+ samplerDesc.filter = Filter::MIN_MAG_MIP_POINT;
+ samplerDesc.address_u = TextureAddressMode::MIRROR;
+ samplerDesc.address_v = TextureAddressMode::MIRROR;
+ samplerDesc.address_w = TextureAddressMode::MIRROR;
+ device->CreateSampler(&samplerDesc, &samplers[SSLOT_POINT_MIRROR]);
+
+ samplerDesc.filter = Filter::MIN_MAG_MIP_POINT;
+ samplerDesc.address_u = TextureAddressMode::WRAP;
+ samplerDesc.address_v = TextureAddressMode::WRAP;
+ samplerDesc.address_w = TextureAddressMode::WRAP;
+ device->CreateSampler(&samplerDesc, &samplers[SSLOT_POINT_WRAP]);
+
+
+ samplerDesc.filter = Filter::MIN_MAG_MIP_POINT;
+ samplerDesc.address_u = TextureAddressMode::CLAMP;
+ samplerDesc.address_v = TextureAddressMode::CLAMP;
+ samplerDesc.address_w = TextureAddressMode::CLAMP;
+ device->CreateSampler(&samplerDesc, &samplers[SSLOT_POINT_CLAMP]);
+
+ samplerDesc.filter = Filter::ANISOTROPIC;
+ samplerDesc.address_u = TextureAddressMode::CLAMP;
+ samplerDesc.address_v = TextureAddressMode::CLAMP;
+ samplerDesc.address_w = TextureAddressMode::CLAMP;
+ samplerDesc.max_anisotropy = 16;
+ device->CreateSampler(&samplerDesc, &samplers[SSLOT_ANISO_CLAMP]);
+
+ samplerDesc.filter = Filter::ANISOTROPIC;
+ samplerDesc.address_u = TextureAddressMode::WRAP;
+ samplerDesc.address_v = TextureAddressMode::WRAP;
+ samplerDesc.address_w = TextureAddressMode::WRAP;
+ samplerDesc.max_anisotropy = 16;
+ device->CreateSampler(&samplerDesc, &samplers[SSLOT_ANISO_WRAP]);
+
+ samplerDesc.filter = Filter::ANISOTROPIC;
+ samplerDesc.address_u = TextureAddressMode::MIRROR;
+ samplerDesc.address_v = TextureAddressMode::MIRROR;
+ samplerDesc.address_w = TextureAddressMode::MIRROR;
+ samplerDesc.max_anisotropy = 16;
+ device->CreateSampler(&samplerDesc, &samplers[SSLOT_ANISO_MIRROR]);
+
+ samplerDesc.filter = Filter::ANISOTROPIC;
+ samplerDesc.address_u = TextureAddressMode::WRAP;
+ samplerDesc.address_v = TextureAddressMode::WRAP;
+ samplerDesc.address_w = TextureAddressMode::WRAP;
+ samplerDesc.max_anisotropy = 16;
+ device->CreateSampler(&samplerDesc, &samplers[SSLOT_OBJECTSHADER]);
+
+ samplerDesc.filter = Filter::COMPARISON_MIN_MAG_LINEAR_MIP_POINT;
+ samplerDesc.address_u = TextureAddressMode::CLAMP;
+ samplerDesc.address_v = TextureAddressMode::CLAMP;
+ samplerDesc.address_w = TextureAddressMode::CLAMP;
+ samplerDesc.mip_lod_bias = 0.0f;
+ samplerDesc.max_anisotropy = 0;
+ samplerDesc.comparison_func = ComparisonFunc::GREATER_EQUAL;
+ device->CreateSampler(&samplerDesc, &samplers[SSLOT_CMP_DEPTH]);
+
+
+ StaticSampler sam;
+
+ sam.sampler = samplers[SSLOT_CMP_DEPTH];
+ sam.slot = SSLOT_CMP_DEPTH;
+ device->SetCommonSampler(&sam);
+
+ sam.sampler = samplers[SSLOT_LINEAR_MIRROR];
+ sam.slot = SSLOT_LINEAR_MIRROR;
+ device->SetCommonSampler(&sam);
+
+ sam.sampler = samplers[SSLOT_LINEAR_CLAMP];
+ sam.slot = SSLOT_LINEAR_CLAMP;
+ device->SetCommonSampler(&sam);
+
+ sam.sampler = samplers[SSLOT_LINEAR_WRAP];
+ sam.slot = SSLOT_LINEAR_WRAP;
+ device->SetCommonSampler(&sam);
+
+ sam.sampler = samplers[SSLOT_POINT_MIRROR];
+ sam.slot = SSLOT_POINT_MIRROR;
+ device->SetCommonSampler(&sam);
+
+ sam.sampler = samplers[SSLOT_POINT_WRAP];
+ sam.slot = SSLOT_POINT_WRAP;
+ device->SetCommonSampler(&sam);
+
+ sam.sampler = samplers[SSLOT_POINT_CLAMP];
+ sam.slot = SSLOT_POINT_CLAMP;
+ device->SetCommonSampler(&sam);
+
+ sam.sampler = samplers[SSLOT_ANISO_CLAMP];
+ sam.slot = SSLOT_ANISO_CLAMP;
+ device->SetCommonSampler(&sam);
+
+ sam.sampler = samplers[SSLOT_ANISO_WRAP];
+ sam.slot = SSLOT_ANISO_WRAP;
+ device->SetCommonSampler(&sam);
+
+ sam.sampler = samplers[SSLOT_ANISO_MIRROR];
+ sam.slot = SSLOT_ANISO_MIRROR;
+ device->SetCommonSampler(&sam);
+
SetUpStates();
LoadBuffers();
@@ -2426,7 +2416,7 @@ void RenderMeshes(
device->EventBegin("RenderMeshes", cmd);
- tessellation = tessellation && device->CheckCapability(GRAPHICSDEVICE_CAPABILITY_TESSELLATION);
+ tessellation = tessellation && device->CheckCapability(GraphicsDeviceCapability::TESSELLATION);
// Do we need to compute a light mask for this pass on the CPU?
const bool forwardLightmaskRequest =
@@ -2555,7 +2545,7 @@ void RenderMeshes(
instancedBatch.meshIndex,
(uint)subsetIndex,
subset.materialIndex,
- device->GetDescriptorIndex(&instances.buffer, SRV),
+ device->GetDescriptorIndex(&instances.buffer, SubresourceType::SRV),
instancedBatch.dataOffset
);
device->PushConstants(&push, sizeof(push), cmd);
@@ -3076,7 +3066,7 @@ void UpdatePerFrameData(
frameCB.EnvProbeMipCount_rcp = 1.0f;
if (vis.scene->envmapArray.IsValid())
{
- frameCB.EnvProbeMipCount = vis.scene->envmapArray.GetDesc().MipLevels;
+ frameCB.EnvProbeMipCount = vis.scene->envmapArray.GetDesc().mip_levels;
frameCB.EnvProbeMipCount_rcp = 1.0f / (float)frameCB.EnvProbeMipCount;
}
@@ -3145,7 +3135,7 @@ void UpdatePerFrameData(
{
frameCB.Options |= OPTION_BIT_HEIGHT_FOG;
}
- if (device->CheckCapability(GRAPHICSDEVICE_CAPABILITY_RAYTRACING) && GetRaytracedShadowsEnabled())
+ if (device->CheckCapability(GraphicsDeviceCapability::RAYTRACING) && GetRaytracedShadowsEnabled())
{
frameCB.Options |= OPTION_BIT_RAYTRACED_SHADOWS;
frameCB.Options |= OPTION_BIT_SHADOW_MASK;
@@ -3168,7 +3158,7 @@ void UpdatePerFrameData(
}
if (vis.scene->weather.skyMap != nullptr)
{
- bool hdr = !IsFormatUnorm(vis.scene->weather.skyMap->texture.desc.Format);
+ bool hdr = !IsFormatUnorm(vis.scene->weather.skyMap->texture.desc.format);
if (hdr)
{
frameCB.Options |= OPTION_BIT_STATIC_SKY_HDR;
@@ -3178,80 +3168,80 @@ void UpdatePerFrameData(
frameCB.scene = vis.scene->shaderscene;
frameCB.sampler_objectshader_index = device->GetDescriptorIndex(&samplers[SSLOT_OBJECTSHADER]);
- frameCB.texture_random64x64_index = device->GetDescriptorIndex(wiTextureHelper::getRandom64x64(), SRV);
- frameCB.texture_bluenoise_index = device->GetDescriptorIndex(wiTextureHelper::getBlueNoise(), SRV);
- frameCB.texture_sheenlut_index = device->GetDescriptorIndex(&textures[TEXTYPE_2D_SHEENLUT], SRV);
- frameCB.texture_skyviewlut_index = device->GetDescriptorIndex(&textures[TEXTYPE_2D_SKYATMOSPHERE_SKYVIEWLUT], SRV);
- frameCB.texture_transmittancelut_index = device->GetDescriptorIndex(&textures[TEXTYPE_2D_SKYATMOSPHERE_TRANSMITTANCELUT], SRV);
- frameCB.texture_multiscatteringlut_index = device->GetDescriptorIndex(&textures[TEXTYPE_2D_SKYATMOSPHERE_MULTISCATTEREDLUMINANCELUT], SRV);
- frameCB.texture_skyluminancelut_index = device->GetDescriptorIndex(&textures[TEXTYPE_2D_SKYATMOSPHERE_SKYLUMINANCELUT], SRV);
- frameCB.texture_shadowarray_2d_index = device->GetDescriptorIndex(&shadowMapArray_2D, SRV);
- frameCB.texture_shadowarray_cube_index = device->GetDescriptorIndex(&shadowMapArray_Cube, SRV);
- frameCB.texture_shadowarray_transparent_2d_index = device->GetDescriptorIndex(&shadowMapArray_Transparent_2D, SRV);
- frameCB.texture_shadowarray_transparent_cube_index = device->GetDescriptorIndex(&shadowMapArray_Transparent_Cube, SRV);
- frameCB.texture_voxelgi_index = device->GetDescriptorIndex(GetVoxelRadianceSecondaryBounceEnabled() ? &textures[TEXTYPE_3D_VOXELRADIANCE_HELPER] : &textures[TEXTYPE_3D_VOXELRADIANCE], SRV);
- frameCB.buffer_entityarray_index = device->GetDescriptorIndex(&resourceBuffers[RBTYPE_ENTITYARRAY], SRV);
- frameCB.buffer_entitymatrixarray_index = device->GetDescriptorIndex(&resourceBuffers[RBTYPE_MATRIXARRAY], SRV);
+ frameCB.texture_random64x64_index = device->GetDescriptorIndex(wiTextureHelper::getRandom64x64(), SubresourceType::SRV);
+ frameCB.texture_bluenoise_index = device->GetDescriptorIndex(wiTextureHelper::getBlueNoise(), SubresourceType::SRV);
+ frameCB.texture_sheenlut_index = device->GetDescriptorIndex(&textures[TEXTYPE_2D_SHEENLUT], SubresourceType::SRV);
+ frameCB.texture_skyviewlut_index = device->GetDescriptorIndex(&textures[TEXTYPE_2D_SKYATMOSPHERE_SKYVIEWLUT], SubresourceType::SRV);
+ frameCB.texture_transmittancelut_index = device->GetDescriptorIndex(&textures[TEXTYPE_2D_SKYATMOSPHERE_TRANSMITTANCELUT], SubresourceType::SRV);
+ frameCB.texture_multiscatteringlut_index = device->GetDescriptorIndex(&textures[TEXTYPE_2D_SKYATMOSPHERE_MULTISCATTEREDLUMINANCELUT], SubresourceType::SRV);
+ frameCB.texture_skyluminancelut_index = device->GetDescriptorIndex(&textures[TEXTYPE_2D_SKYATMOSPHERE_SKYLUMINANCELUT], SubresourceType::SRV);
+ frameCB.texture_shadowarray_2d_index = device->GetDescriptorIndex(&shadowMapArray_2D, SubresourceType::SRV);
+ frameCB.texture_shadowarray_cube_index = device->GetDescriptorIndex(&shadowMapArray_Cube, SubresourceType::SRV);
+ frameCB.texture_shadowarray_transparent_2d_index = device->GetDescriptorIndex(&shadowMapArray_Transparent_2D, SubresourceType::SRV);
+ frameCB.texture_shadowarray_transparent_cube_index = device->GetDescriptorIndex(&shadowMapArray_Transparent_Cube, SubresourceType::SRV);
+ frameCB.texture_voxelgi_index = device->GetDescriptorIndex(GetVoxelRadianceSecondaryBounceEnabled() ? &textures[TEXTYPE_3D_VOXELRADIANCE_HELPER] : &textures[TEXTYPE_3D_VOXELRADIANCE], SubresourceType::SRV);
+ frameCB.buffer_entityarray_index = device->GetDescriptorIndex(&resourceBuffers[RBTYPE_ENTITYARRAY], SubresourceType::SRV);
+ frameCB.buffer_entitymatrixarray_index = device->GetDescriptorIndex(&resourceBuffers[RBTYPE_MATRIXARRAY], SubresourceType::SRV);
// Create volumetric cloud static resources if needed:
if (scene.weather.IsVolumetricClouds() && !texture_shapeNoise.IsValid())
{
TextureDesc shape_desc;
- shape_desc.type = TextureDesc::TEXTURE_3D;
- shape_desc.Width = 64;
- shape_desc.Height = 64;
- shape_desc.Depth = 64;
- shape_desc.MipLevels = 6;
- shape_desc.Format = FORMAT_R8G8B8A8_UNORM;
- shape_desc.BindFlags = BIND_SHADER_RESOURCE | BIND_UNORDERED_ACCESS;
- shape_desc.layout = RESOURCE_STATE_SHADER_RESOURCE_COMPUTE;
+ shape_desc.type = TextureDesc::Type::TEXTURE_3D;
+ shape_desc.width = 64;
+ shape_desc.height = 64;
+ shape_desc.depth = 64;
+ shape_desc.mip_levels = 6;
+ shape_desc.format = Format::R8G8B8A8_UNORM;
+ shape_desc.bind_flags = BindFlag::SHADER_RESOURCE | BindFlag::UNORDERED_ACCESS;
+ shape_desc.layout = ResourceState::SHADER_RESOURCE_COMPUTE;
device->CreateTexture(&shape_desc, nullptr, &texture_shapeNoise);
device->SetName(&texture_shapeNoise, "texture_shapeNoise");
- for (uint32_t i = 0; i < texture_shapeNoise.GetDesc().MipLevels; ++i)
+ for (uint32_t i = 0; i < texture_shapeNoise.GetDesc().mip_levels; ++i)
{
int subresource_index;
- subresource_index = device->CreateSubresource(&texture_shapeNoise, SRV, 0, 1, i, 1);
+ subresource_index = device->CreateSubresource(&texture_shapeNoise, SubresourceType::SRV, 0, 1, i, 1);
assert(subresource_index == i);
- subresource_index = device->CreateSubresource(&texture_shapeNoise, UAV, 0, 1, i, 1);
+ subresource_index = device->CreateSubresource(&texture_shapeNoise, SubresourceType::UAV, 0, 1, i, 1);
assert(subresource_index == i);
}
TextureDesc detail_desc;
- detail_desc.type = TextureDesc::TEXTURE_3D;
- detail_desc.Width = 32;
- detail_desc.Height = 32;
- detail_desc.Depth = 32;
- detail_desc.MipLevels = 6;
- detail_desc.Format = FORMAT_R8G8B8A8_UNORM;
- detail_desc.BindFlags = BIND_SHADER_RESOURCE | BIND_UNORDERED_ACCESS;
- detail_desc.layout = RESOURCE_STATE_SHADER_RESOURCE_COMPUTE;
+ detail_desc.type = TextureDesc::Type::TEXTURE_3D;
+ detail_desc.width = 32;
+ detail_desc.height = 32;
+ detail_desc.depth = 32;
+ detail_desc.mip_levels = 6;
+ detail_desc.format = Format::R8G8B8A8_UNORM;
+ detail_desc.bind_flags = BindFlag::SHADER_RESOURCE | BindFlag::UNORDERED_ACCESS;
+ detail_desc.layout = ResourceState::SHADER_RESOURCE_COMPUTE;
device->CreateTexture(&detail_desc, nullptr, &texture_detailNoise);
device->SetName(&texture_detailNoise, "texture_detailNoise");
- for (uint32_t i = 0; i < texture_detailNoise.GetDesc().MipLevels; ++i)
+ for (uint32_t i = 0; i < texture_detailNoise.GetDesc().mip_levels; ++i)
{
int subresource_index;
- subresource_index = device->CreateSubresource(&texture_detailNoise, SRV, 0, 1, i, 1);
+ subresource_index = device->CreateSubresource(&texture_detailNoise, SubresourceType::SRV, 0, 1, i, 1);
assert(subresource_index == i);
- subresource_index = device->CreateSubresource(&texture_detailNoise, UAV, 0, 1, i, 1);
+ subresource_index = device->CreateSubresource(&texture_detailNoise, SubresourceType::UAV, 0, 1, i, 1);
assert(subresource_index == i);
}
TextureDesc texture_desc;
- texture_desc.type = TextureDesc::TEXTURE_2D;
- texture_desc.Width = 128;
- texture_desc.Height = 128;
- texture_desc.Format = FORMAT_R8G8B8A8_UNORM;
- texture_desc.BindFlags = BIND_SHADER_RESOURCE | BIND_UNORDERED_ACCESS;
- texture_desc.layout = RESOURCE_STATE_SHADER_RESOURCE_COMPUTE;
+ texture_desc.type = TextureDesc::Type::TEXTURE_2D;
+ texture_desc.width = 128;
+ texture_desc.height = 128;
+ texture_desc.format = Format::R8G8B8A8_UNORM;
+ texture_desc.bind_flags = BindFlag::SHADER_RESOURCE | BindFlag::UNORDERED_ACCESS;
+ texture_desc.layout = ResourceState::SHADER_RESOURCE_COMPUTE;
device->CreateTexture(&texture_desc, nullptr, &texture_curlNoise);
device->SetName(&texture_curlNoise, "texture_curlNoise");
- texture_desc.Width = 1024;
- texture_desc.Height = 1024;
- texture_desc.Format = FORMAT_R8G8B8A8_UNORM;
+ texture_desc.width = 1024;
+ texture_desc.height = 1024;
+ texture_desc.format = Format::R8G8B8A8_UNORM;
device->CreateTexture(&texture_desc, nullptr, &texture_weatherMap);
device->SetName(&texture_weatherMap, "texture_weatherMap");
}
@@ -3268,7 +3258,7 @@ void UpdateRenderData(
auto prof_updatebuffer_gpu = wiProfiler::BeginRangeGPU("Update Buffers (GPU)", cmd);
device->UpdateBuffer(&constantBuffers[CBTYPE_FRAME], &frameCB, cmd);
- barrier_stack[cmd].push_back(GPUBarrier::Buffer(&constantBuffers[CBTYPE_FRAME], RESOURCE_STATE_COPY_DST, RESOURCE_STATE_CONSTANT_BUFFER));
+ barrier_stack[cmd].push_back(GPUBarrier::Buffer(&constantBuffers[CBTYPE_FRAME], ResourceState::COPY_DST, ResourceState::CONSTANT_BUFFER));
if (vis.scene->instanceBuffer.IsValid() && vis.scene->instanceArraySize > 0)
{
@@ -3280,7 +3270,7 @@ void UpdateRenderData(
vis.scene->instanceArraySize * sizeof(ShaderMeshInstance),
cmd
);
- barrier_stack[cmd].push_back(GPUBarrier::Buffer(&vis.scene->instanceBuffer, RESOURCE_STATE_COPY_DST, RESOURCE_STATE_SHADER_RESOURCE));
+ barrier_stack[cmd].push_back(GPUBarrier::Buffer(&vis.scene->instanceBuffer, ResourceState::COPY_DST, ResourceState::SHADER_RESOURCE));
}
if (vis.scene->meshBuffer.IsValid() && vis.scene->meshArraySize > 0)
@@ -3293,7 +3283,7 @@ void UpdateRenderData(
vis.scene->meshArraySize * sizeof(ShaderMesh),
cmd
);
- barrier_stack[cmd].push_back(GPUBarrier::Buffer(&vis.scene->meshBuffer, RESOURCE_STATE_COPY_DST, RESOURCE_STATE_SHADER_RESOURCE));
+ barrier_stack[cmd].push_back(GPUBarrier::Buffer(&vis.scene->meshBuffer, ResourceState::COPY_DST, ResourceState::SHADER_RESOURCE));
}
if (vis.scene->materialBuffer.IsValid() && vis.scene->materialArraySize > 0)
@@ -3306,7 +3296,7 @@ void UpdateRenderData(
vis.scene->materialArraySize * sizeof(ShaderMaterial),
cmd
);
- barrier_stack[cmd].push_back(GPUBarrier::Buffer(&vis.scene->materialBuffer, RESOURCE_STATE_COPY_DST, RESOURCE_STATE_SHADER_RESOURCE));
+ barrier_stack[cmd].push_back(GPUBarrier::Buffer(&vis.scene->materialBuffer, ResourceState::COPY_DST, ResourceState::SHADER_RESOURCE));
}
// Fill Entity Array with decals + envprobes + lights in the frustum:
@@ -3360,12 +3350,12 @@ void UpdateRenderData(
int texture = -1;
if (decal.texture != nullptr)
{
- texture = device->GetDescriptorIndex(&decal.texture->texture, SRV);
+ texture = device->GetDescriptorIndex(&decal.texture->texture, SubresourceType::SRV);
}
int normal = -1;
if (decal.normal != nullptr)
{
- normal = device->GetDescriptorIndex(&decal.normal->texture, SRV);
+ normal = device->GetDescriptorIndex(&decal.normal->texture, SubresourceType::SRV);
}
matrixArray[matrixCounter].r[0] = XMVectorSetW(matrixArray[matrixCounter].r[0], *(float*)&texture);
matrixArray[matrixCounter].r[1] = XMVectorSetW(matrixArray[matrixCounter].r[1], *(float*)&normal);
@@ -3577,8 +3567,8 @@ void UpdateRenderData(
device->UpdateBuffer(&resourceBuffers[RBTYPE_ENTITYARRAY], entityArray, cmd, sizeof(ShaderEntity)*entityCounter);
device->UpdateBuffer(&resourceBuffers[RBTYPE_MATRIXARRAY], matrixArray, cmd, sizeof(XMMATRIX)*matrixCounter);
- barrier_stack[cmd].push_back(GPUBarrier::Buffer(&resourceBuffers[RBTYPE_ENTITYARRAY], RESOURCE_STATE_COPY_DST, RESOURCE_STATE_SHADER_RESOURCE));
- barrier_stack[cmd].push_back(GPUBarrier::Buffer(&resourceBuffers[RBTYPE_MATRIXARRAY], RESOURCE_STATE_COPY_DST, RESOURCE_STATE_SHADER_RESOURCE));
+ barrier_stack[cmd].push_back(GPUBarrier::Buffer(&resourceBuffers[RBTYPE_ENTITYARRAY], ResourceState::COPY_DST, ResourceState::SHADER_RESOURCE));
+ barrier_stack[cmd].push_back(GPUBarrier::Buffer(&resourceBuffers[RBTYPE_MATRIXARRAY], ResourceState::COPY_DST, ResourceState::SHADER_RESOURCE));
// Temporary array for GPU entities can be freed now:
GetRenderFrameAllocator(cmd).free(sizeof(ShaderEntity)*SHADER_ENTITY_COUNT);
@@ -3591,7 +3581,7 @@ void UpdateRenderData(
const ArmatureComponent& armature = vis.scene->armatures[i];
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[cmd].push_back(GPUBarrier::Buffer(&armature.boneBuffer, ResourceState::COPY_DST, ResourceState::SHADER_RESOURCE));
}
// Soft body updates:
@@ -3606,8 +3596,8 @@ void UpdateRenderData(
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[cmd].push_back(GPUBarrier::Buffer(&mesh->streamoutBuffer_POS, ResourceState::COPY_DST, ResourceState::SHADER_RESOURCE));
+ barrier_stack[cmd].push_back(GPUBarrier::Buffer(&mesh->streamoutBuffer_TAN, ResourceState::COPY_DST, ResourceState::SHADER_RESOURCE));
}
}
@@ -3626,7 +3616,7 @@ void UpdateRenderData(
{
Entity entity = vis.scene->meshes.GetEntity(i);
const MeshComponent& mesh = vis.scene->meshes[i];
- barrier_stack[cmd].push_back(GPUBarrier::Buffer(&mesh.indexBuffer, RESOURCE_STATE_UNDEFINED, RESOURCE_STATE_INDEX_BUFFER | RESOURCE_STATE_SHADER_RESOURCE));
+ barrier_stack[cmd].push_back(GPUBarrier::Buffer(&mesh.indexBuffer, ResourceState::UNDEFINED, ResourceState::INDEX_BUFFER | ResourceState::SHADER_RESOURCE));
if (mesh.dirty_subsets)
{
@@ -3644,14 +3634,14 @@ void UpdateRenderData(
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));
+ barrier_stack[cmd].push_back(GPUBarrier::Buffer(&mesh.subsetBuffer, ResourceState::COPY_DST, ResourceState::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));
+ device->UpdateBuffer(&mesh.vertexBuffer_POS, mesh.vertex_positions_morphed.data(), cmd);
+ barrier_stack[cmd].push_back(GPUBarrier::Buffer(&mesh.vertexBuffer_POS, ResourceState::COPY_DST, ResourceState::SHADER_RESOURCE));
}
if (mesh.IsSkinned() && vis.scene->armatures.Contains(mesh.armatureID))
@@ -3669,18 +3659,18 @@ void UpdateRenderData(
device->BindComputeShader(&shaders[CSTYPE_SKINNING], cmd);
SkinningPushConstants push;
- push.bonebuffer_index = device->GetDescriptorIndex(&armature.boneBuffer, SRV);
- push.vb_pos_nor_wind = device->GetDescriptorIndex(&mesh.vertexBuffer_POS, SRV);
- push.vb_tan = device->GetDescriptorIndex(&mesh.vertexBuffer_TAN, SRV);
- push.vb_bon = device->GetDescriptorIndex(&mesh.vertexBuffer_BON, SRV);
- push.so_pos_nor_wind = device->GetDescriptorIndex(&mesh.streamoutBuffer_POS, UAV);
- push.so_tan = device->GetDescriptorIndex(&mesh.streamoutBuffer_TAN, UAV);
+ push.bonebuffer_index = device->GetDescriptorIndex(&armature.boneBuffer, SubresourceType::SRV);
+ push.vb_pos_nor_wind = device->GetDescriptorIndex(&mesh.vertexBuffer_POS, SubresourceType::SRV);
+ push.vb_tan = device->GetDescriptorIndex(&mesh.vertexBuffer_TAN, SubresourceType::SRV);
+ push.vb_bon = device->GetDescriptorIndex(&mesh.vertexBuffer_BON, SubresourceType::SRV);
+ push.so_pos_nor_wind = device->GetDescriptorIndex(&mesh.streamoutBuffer_POS, SubresourceType::UAV);
+ push.so_tan = device->GetDescriptorIndex(&mesh.streamoutBuffer_TAN, SubresourceType::UAV);
device->PushConstants(&push, sizeof(push), 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));
+ barrier_stack[cmd].push_back(GPUBarrier::Buffer(&mesh.streamoutBuffer_POS, ResourceState::UNORDERED_ACCESS, ResourceState::SHADER_RESOURCE));
+ barrier_stack[cmd].push_back(GPUBarrier::Buffer(&mesh.streamoutBuffer_TAN, ResourceState::UNORDERED_ACCESS, ResourceState::SHADER_RESOURCE));
}
@@ -3735,14 +3725,14 @@ void UpdateRenderData(
{
GPUBarrier barriers[] = {
- GPUBarrier::Image(&texture_shapeNoise, texture_shapeNoise.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS),
+ GPUBarrier::Image(&texture_shapeNoise, texture_shapeNoise.desc.layout, ResourceState::UNORDERED_ACCESS),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
const int threadSize = 8;
- const int noiseThreadXY = static_cast(std::ceil(texture_shapeNoise.GetDesc().Width / threadSize));
- const int noiseThreadZ = static_cast(std::ceil(texture_shapeNoise.GetDesc().Depth / threadSize));
+ const int noiseThreadXY = static_cast(std::ceil(texture_shapeNoise.GetDesc().width / threadSize));
+ const int noiseThreadZ = static_cast(std::ceil(texture_shapeNoise.GetDesc().depth / threadSize));
device->Dispatch(noiseThreadXY, noiseThreadXY, noiseThreadZ, cmd);
@@ -3761,13 +3751,13 @@ void UpdateRenderData(
{
GPUBarrier barriers[] = {
- GPUBarrier::Image(&texture_detailNoise, texture_detailNoise.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS),
+ GPUBarrier::Image(&texture_detailNoise, texture_detailNoise.desc.layout, ResourceState::UNORDERED_ACCESS),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
const int threadSize = 8;
- const int noiseThreadXYZ = static_cast(std::ceil(texture_detailNoise.GetDesc().Width / threadSize));
+ const int noiseThreadXYZ = static_cast(std::ceil(texture_detailNoise.GetDesc().width / threadSize));
device->Dispatch(noiseThreadXYZ, noiseThreadXYZ, noiseThreadXYZ, cmd);
@@ -3776,8 +3766,8 @@ void UpdateRenderData(
{
GPUBarrier barriers[] = {
- GPUBarrier::Image(&texture_shapeNoise, RESOURCE_STATE_UNORDERED_ACCESS, texture_shapeNoise.desc.layout),
- GPUBarrier::Image(&texture_detailNoise, RESOURCE_STATE_UNORDERED_ACCESS, texture_detailNoise.desc.layout),
+ GPUBarrier::Image(&texture_shapeNoise, ResourceState::UNORDERED_ACCESS, texture_shapeNoise.desc.layout),
+ GPUBarrier::Image(&texture_detailNoise, ResourceState::UNORDERED_ACCESS, texture_detailNoise.desc.layout),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
@@ -3798,20 +3788,20 @@ void UpdateRenderData(
{
GPUBarrier barriers[] = {
- GPUBarrier::Image(&texture_curlNoise, texture_curlNoise.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS),
+ GPUBarrier::Image(&texture_curlNoise, texture_curlNoise.desc.layout, ResourceState::UNORDERED_ACCESS),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
const int threadSize = 16;
- const int curlRes = texture_curlNoise.GetDesc().Width;
+ const int curlRes = texture_curlNoise.GetDesc().width;
const int curlThread = static_cast(std::ceil(curlRes / threadSize));
device->Dispatch(curlThread, curlThread, 1, cmd);
{
GPUBarrier barriers[] = {
- GPUBarrier::Image(&texture_curlNoise, RESOURCE_STATE_UNORDERED_ACCESS, texture_curlNoise.desc.layout),
+ GPUBarrier::Image(&texture_curlNoise, ResourceState::UNORDERED_ACCESS, texture_curlNoise.desc.layout),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
@@ -3831,20 +3821,20 @@ void UpdateRenderData(
{
GPUBarrier barriers[] = {
- GPUBarrier::Image(&texture_weatherMap, texture_weatherMap.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS),
+ GPUBarrier::Image(&texture_weatherMap, texture_weatherMap.desc.layout, ResourceState::UNORDERED_ACCESS),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
const int threadSize = 16;
- const int weatherMapRes = texture_weatherMap.GetDesc().Width;
+ const int weatherMapRes = texture_weatherMap.GetDesc().width;
const int weatherThread = static_cast(std::ceil(weatherMapRes / threadSize));
device->Dispatch(weatherThread, weatherThread, 1, cmd);
{
GPUBarrier barriers[] = {
GPUBarrier::Memory(),
- GPUBarrier::Image(&texture_weatherMap, RESOURCE_STATE_UNORDERED_ACCESS, texture_weatherMap.desc.layout),
+ GPUBarrier::Image(&texture_weatherMap, ResourceState::UNORDERED_ACCESS, texture_weatherMap.desc.layout),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
@@ -3900,17 +3890,17 @@ void UpdateRenderDataAsync(
void UpdateRaytracingAccelerationStructures(const Scene& scene, CommandList cmd)
{
- if (device->CheckCapability(GRAPHICSDEVICE_CAPABILITY_RAYTRACING))
+ if (device->CheckCapability(GraphicsDeviceCapability::RAYTRACING))
{
if (!scene.TLAS.IsValid())
return;
device->CopyBuffer(
- &scene.TLAS.desc.toplevel.instanceBuffer,
+ &scene.TLAS.desc.top_level.instance_buffer,
0,
&scene.TLAS_instancesUpload[device->GetBufferIndex()],
0,
- scene.TLAS.desc.toplevel.instanceBuffer.desc.Size,
+ scene.TLAS.desc.top_level.instance_buffer.desc.size,
cmd
);
@@ -3963,7 +3953,7 @@ void UpdateRaytracingAccelerationStructures(const Scene& scene, CommandList cmd)
{
GPUBarrier barriers[] = {
- GPUBarrier::Buffer(&scene.TLAS.desc.toplevel.instanceBuffer, RESOURCE_STATE_COPY_DST, RESOURCE_STATE_SHADER_RESOURCE_COMPUTE),
+ GPUBarrier::Buffer(&scene.TLAS.desc.top_level.instance_buffer, ResourceState::COPY_DST, ResourceState::SHADER_RESOURCE_COMPUTE),
GPUBarrier::Memory(), // sync BLAS
};
device->Barrier(barriers, arraysize(barriers), cmd);
@@ -4021,7 +4011,7 @@ void OcclusionCulling_Reset(const Visibility& vis, CommandList cmd)
device->QueryReset(
&queryHeap,
0,
- queryHeap.desc.queryCount,
+ queryHeap.desc.query_count,
cmd
);
}
@@ -4125,7 +4115,7 @@ void OcclusionCulling_Resolve(const Visibility& vis, CommandList cmd)
cmd
);
- if (device->CheckCapability(GRAPHICSDEVICE_CAPABILITY_PREDICATION))
+ if (device->CheckCapability(GraphicsDeviceCapability::PREDICATION))
{
// Resolve into predication buffer:
device->QueryResolve(
@@ -4139,7 +4129,7 @@ void OcclusionCulling_Resolve(const Visibility& vis, CommandList cmd)
{
GPUBarrier barriers[] = {
- GPUBarrier::Buffer(&vis.scene->queryPredicationBuffer, RESOURCE_STATE_COPY_DST, RESOURCE_STATE_PREDICATION),
+ GPUBarrier::Buffer(&vis.scene->queryPredicationBuffer, ResourceState::COPY_DST, ResourceState::PREDICATION),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
@@ -4219,7 +4209,7 @@ void DrawSoftParticles(
GetRenderFrameAllocator(cmd).free(sizeof(uint32_t) * emitterCount);
- device->BindShadingRate(SHADING_RATE_1X1, cmd);
+ device->BindShadingRate(ShadingRate::RATE_1X1, cmd);
wiProfiler::EndRange(range);
}
@@ -4438,8 +4428,8 @@ void DrawLensFlares(
break;
cb.xLensFlareOffset = mods[i];
- cb.xLensFlareSize.x = (float)x->texture.desc.Width;
- cb.xLensFlareSize.y = (float)x->texture.desc.Height;
+ cb.xLensFlareSize.x = (float)x->texture.desc.width;
+ cb.xLensFlareSize.y = (float)x->texture.desc.height;
device->PushConstants(&cb, sizeof(cb), cmd);
@@ -4472,21 +4462,21 @@ void SetShadowProps2D(int resolution, int count)
if (SHADOWCOUNT_2D > 0 && SHADOWRES_2D > 0)
{
TextureDesc desc;
- desc.Width = SHADOWRES_2D;
- desc.Height = SHADOWRES_2D;
- desc.MipLevels = 1;
- desc.ArraySize = SHADOWCOUNT_2D;
- desc.SampleCount = 1;
- desc.Usage = USAGE_DEFAULT;
+ desc.width = SHADOWRES_2D;
+ desc.height = SHADOWRES_2D;
+ desc.mip_levels = 1;
+ desc.array_size = SHADOWCOUNT_2D;
+ desc.sample_count = 1;
+ desc.usage = Usage::DEFAULT;
- desc.BindFlags = BIND_DEPTH_STENCIL | BIND_SHADER_RESOURCE;
- desc.Format = FORMAT_R16_TYPELESS;
- desc.layout = RESOURCE_STATE_SHADER_RESOURCE;
+ desc.bind_flags = BindFlag::DEPTH_STENCIL | BindFlag::SHADER_RESOURCE;
+ desc.format = Format::R16_TYPELESS;
+ desc.layout = ResourceState::SHADER_RESOURCE;
device->CreateTexture(&desc, nullptr, &shadowMapArray_2D);
- desc.BindFlags = BIND_RENDER_TARGET | BIND_SHADER_RESOURCE;
- desc.Format = FORMAT_R16G16B16A16_FLOAT;
- desc.layout = RESOURCE_STATE_SHADER_RESOURCE;
+ desc.bind_flags = BindFlag::RENDER_TARGET | BindFlag::SHADER_RESOURCE;
+ desc.format = Format::R16G16B16A16_FLOAT;
+ desc.layout = ResourceState::SHADER_RESOURCE;
desc.clear.color[0] = 1;
desc.clear.color[1] = 1;
desc.clear.color[2] = 1;
@@ -4498,9 +4488,9 @@ void SetShadowProps2D(int resolution, int count)
for (uint32_t i = 0; i < SHADOWCOUNT_2D; ++i)
{
int subresource_index;
- subresource_index = device->CreateSubresource(&shadowMapArray_2D, DSV, i, 1, 0, 1);
+ subresource_index = device->CreateSubresource(&shadowMapArray_2D, SubresourceType::DSV, i, 1, 0, 1);
assert(subresource_index == i);
- subresource_index = device->CreateSubresource(&shadowMapArray_Transparent_2D, RTV, i, 1, 0, 1);
+ subresource_index = device->CreateSubresource(&shadowMapArray_Transparent_2D, SubresourceType::RTV, i, 1, 0, 1);
assert(subresource_index == i);
RenderPassDesc renderpassdesc;
@@ -4508,11 +4498,11 @@ void SetShadowProps2D(int resolution, int count)
renderpassdesc.attachments.push_back(
RenderPassAttachment::DepthStencil(
&shadowMapArray_2D,
- RenderPassAttachment::LOADOP_CLEAR,
- RenderPassAttachment::STOREOP_STORE,
- RESOURCE_STATE_SHADER_RESOURCE,
- RESOURCE_STATE_DEPTHSTENCIL,
- RESOURCE_STATE_SHADER_RESOURCE
+ RenderPassAttachment::LoadOp::CLEAR,
+ RenderPassAttachment::StoreOp::STORE,
+ ResourceState::SHADER_RESOURCE,
+ ResourceState::DEPTHSTENCIL,
+ ResourceState::SHADER_RESOURCE
)
);
renderpassdesc.attachments.back().subresource = subresource_index;
@@ -4520,11 +4510,11 @@ void SetShadowProps2D(int resolution, int count)
renderpassdesc.attachments.push_back(
RenderPassAttachment::RenderTarget(
&shadowMapArray_Transparent_2D,
- RenderPassAttachment::LOADOP_CLEAR,
- RenderPassAttachment::STOREOP_STORE,
- RESOURCE_STATE_SHADER_RESOURCE,
- RESOURCE_STATE_RENDERTARGET,
- RESOURCE_STATE_SHADER_RESOURCE
+ RenderPassAttachment::LoadOp::CLEAR,
+ RenderPassAttachment::StoreOp::STORE,
+ ResourceState::SHADER_RESOURCE,
+ ResourceState::RENDERTARGET,
+ ResourceState::SHADER_RESOURCE
)
);
renderpassdesc.attachments.back().subresource = subresource_index;
@@ -4548,22 +4538,22 @@ void SetShadowPropsCube(int resolution, int count)
if (SHADOWCOUNT_CUBE > 0 && SHADOWRES_CUBE > 0)
{
TextureDesc desc;
- desc.Width = SHADOWRES_CUBE;
- desc.Height = SHADOWRES_CUBE;
- desc.MipLevels = 1;
- desc.ArraySize = 6 * SHADOWCOUNT_CUBE;
- desc.SampleCount = 1;
- desc.Usage = USAGE_DEFAULT;
- desc.MiscFlags = RESOURCE_MISC_TEXTURECUBE;
+ desc.width = SHADOWRES_CUBE;
+ desc.height = SHADOWRES_CUBE;
+ desc.mip_levels = 1;
+ desc.array_size = 6 * SHADOWCOUNT_CUBE;
+ desc.sample_count = 1;
+ desc.usage = Usage::DEFAULT;
+ desc.misc_flags = ResourceMiscFlag::TEXTURECUBE;
- desc.BindFlags = BIND_DEPTH_STENCIL | BIND_SHADER_RESOURCE;
- desc.Format = FORMAT_R16_TYPELESS;
- desc.layout = RESOURCE_STATE_SHADER_RESOURCE;
+ desc.bind_flags = BindFlag::DEPTH_STENCIL | BindFlag::SHADER_RESOURCE;
+ desc.format = Format::R16_TYPELESS;
+ desc.layout = ResourceState::SHADER_RESOURCE;
device->CreateTexture(&desc, nullptr, &shadowMapArray_Cube);
- desc.BindFlags = BIND_RENDER_TARGET | BIND_SHADER_RESOURCE;
- desc.Format = FORMAT_R16G16B16A16_FLOAT;
- desc.layout = RESOURCE_STATE_SHADER_RESOURCE;
+ desc.bind_flags = BindFlag::RENDER_TARGET | BindFlag::SHADER_RESOURCE;
+ desc.format = Format::R16G16B16A16_FLOAT;
+ desc.layout = ResourceState::SHADER_RESOURCE;
desc.clear.color[0] = 1;
desc.clear.color[1] = 1;
desc.clear.color[2] = 1;
@@ -4575,20 +4565,20 @@ void SetShadowPropsCube(int resolution, int count)
for (uint32_t i = 0; i < SHADOWCOUNT_CUBE; ++i)
{
int subresource_index;
- subresource_index = device->CreateSubresource(&shadowMapArray_Cube, DSV, i * 6, 6, 0, 1);
+ subresource_index = device->CreateSubresource(&shadowMapArray_Cube, SubresourceType::DSV, i * 6, 6, 0, 1);
assert(subresource_index == i);
- subresource_index = device->CreateSubresource(&shadowMapArray_Transparent_Cube, RTV, i * 6, 6, 0, 1);
+ subresource_index = device->CreateSubresource(&shadowMapArray_Transparent_Cube, SubresourceType::RTV, i * 6, 6, 0, 1);
assert(subresource_index == i);
RenderPassDesc renderpassdesc;
renderpassdesc.attachments.push_back(
RenderPassAttachment::DepthStencil(
&shadowMapArray_Cube,
- RenderPassAttachment::LOADOP_CLEAR,
- RenderPassAttachment::STOREOP_STORE,
- RESOURCE_STATE_SHADER_RESOURCE,
- RESOURCE_STATE_DEPTHSTENCIL,
- RESOURCE_STATE_SHADER_RESOURCE
+ RenderPassAttachment::LoadOp::CLEAR,
+ RenderPassAttachment::StoreOp::STORE,
+ ResourceState::SHADER_RESOURCE,
+ ResourceState::DEPTHSTENCIL,
+ ResourceState::SHADER_RESOURCE
)
);
renderpassdesc.attachments.back().subresource = subresource_index;
@@ -4596,11 +4586,11 @@ void SetShadowPropsCube(int resolution, int count)
renderpassdesc.attachments.push_back(
RenderPassAttachment::RenderTarget(
&shadowMapArray_Transparent_Cube,
- RenderPassAttachment::LOADOP_CLEAR,
- RenderPassAttachment::STOREOP_STORE,
- RESOURCE_STATE_SHADER_RESOURCE,
- RESOURCE_STATE_RENDERTARGET,
- RESOURCE_STATE_SHADER_RESOURCE
+ RenderPassAttachment::LoadOp::CLEAR,
+ RenderPassAttachment::StoreOp::STORE,
+ ResourceState::SHADER_RESOURCE,
+ ResourceState::RENDERTARGET,
+ ResourceState::SHADER_RESOURCE
)
);
renderpassdesc.attachments.back().subresource = subresource_index;
@@ -4624,7 +4614,7 @@ void DrawShadowmaps(
auto range = wiProfiler::BeginRangeGPU("Shadow Rendering", cmd);
const bool predicationRequest =
- device->CheckCapability(GRAPHICSDEVICE_CAPABILITY_PREDICATION) &&
+ device->CheckCapability(GraphicsDeviceCapability::PREDICATION) &&
GetOcclusionCullingEnabled();
BindCommonResources(cmd);
@@ -4702,12 +4692,12 @@ void DrawShadowmaps(
device->BindDynamicConstantBuffer(cb, CBSLOT_RENDERER_CAMERA, cmd);
Viewport vp;
- vp.TopLeftX = 0;
- vp.TopLeftY = 0;
- vp.Width = (float)SHADOWRES_2D;
- vp.Height = (float)SHADOWRES_2D;
- vp.MinDepth = 0.0f;
- vp.MaxDepth = 1.0f;
+ vp.top_left_x = 0;
+ vp.top_left_y = 0;
+ vp.width = (float)SHADOWRES_2D;
+ vp.height = (float)SHADOWRES_2D;
+ vp.min_depth = 0.0f;
+ vp.max_depth = 1.0f;
device->BindViewports(1, &vp, cmd);
RenderMeshes(vis, renderQueue, RENDERPASS_SHADOW, RENDERTYPE_OPAQUE, cmd);
@@ -4765,7 +4755,7 @@ void DrawShadowmaps(
device->PredicationBegin(
&vis.scene->queryPredicationBuffer,
(uint64_t)light.occlusionquery * sizeof(uint64_t),
- PREDICATION_OP_EQUAL_ZERO,
+ PredicationOp::EQUAL_ZERO,
cmd
);
@@ -4774,12 +4764,12 @@ void DrawShadowmaps(
device->BindDynamicConstantBuffer(cb, CBSLOT_RENDERER_CAMERA, cmd);
Viewport vp;
- vp.TopLeftX = 0;
- vp.TopLeftY = 0;
- vp.Width = (float)SHADOWRES_2D;
- vp.Height = (float)SHADOWRES_2D;
- vp.MinDepth = 0.0f;
- vp.MaxDepth = 1.0f;
+ vp.top_left_x = 0;
+ vp.top_left_y = 0;
+ vp.width = (float)SHADOWRES_2D;
+ vp.height = (float)SHADOWRES_2D;
+ vp.min_depth = 0.0f;
+ vp.max_depth = 1.0f;
device->BindViewports(1, &vp, cmd);
device->RenderPassBegin(&renderpasses_shadow2D[slice], cmd);
@@ -4837,14 +4827,10 @@ void DrawShadowmaps(
device->PredicationBegin(
&vis.scene->queryPredicationBuffer,
(uint64_t)light.occlusionquery * sizeof(uint64_t),
- PREDICATION_OP_EQUAL_ZERO,
+ PredicationOp::EQUAL_ZERO,
cmd
);
- MiscCB miscCb;
- miscCb.g_xColor = float4(light.position.x, light.position.y, light.position.z, 0);
- device->BindDynamicConstantBuffer(miscCb, CB_GETBINDSLOT(MiscCB), cmd);
-
const float zNearP = 0.1f;
const float zFarP = std::max(1.0f, light.GetRange());
SHCAM cameras[] = {
@@ -4872,12 +4858,12 @@ void DrawShadowmaps(
device->BindDynamicConstantBuffer(cb, CB_GETBINDSLOT(CubemapRenderCB), cmd);
Viewport vp;
- vp.TopLeftX = 0;
- vp.TopLeftY = 0;
- vp.Width = (float)SHADOWRES_CUBE;
- vp.Height = (float)SHADOWRES_CUBE;
- vp.MinDepth = 0.0f;
- vp.MaxDepth = 1.0f;
+ vp.top_left_x = 0;
+ vp.top_left_y = 0;
+ vp.width = (float)SHADOWRES_CUBE;
+ vp.height = (float)SHADOWRES_CUBE;
+ vp.min_depth = 0.0f;
+ vp.max_depth = 1.0f;
device->BindViewports(1, &vp, cmd);
device->RenderPassBegin(&renderpasses_shadowCube[slice], cmd);
@@ -4918,7 +4904,7 @@ void DrawScene(
const bool occlusion = flags & DRAWSCENE_OCCLUSIONCULLING;
device->EventBegin("DrawScene", cmd);
- device->BindShadingRate(SHADING_RATE_1X1, cmd);
+ device->BindShadingRate(ShadingRate::RATE_1X1, cmd);
BindCommonResources(cmd);
@@ -4992,7 +4978,7 @@ void DrawScene(
GetRenderFrameAllocator(cmd).free(sizeof(RenderBatch) * renderQueue.batchCount);
}
- device->BindShadingRate(SHADING_RATE_1X1, cmd);
+ device->BindShadingRate(ShadingRate::RATE_1X1, cmd);
device->EventEnd(cmd);
}
@@ -5023,9 +5009,9 @@ void DrawDebugWorld(
};
GPUBufferDesc bd;
- bd.Usage = USAGE_DEFAULT;
- bd.Size = sizeof(verts);
- bd.BindFlags = BIND_VERTEX_BUFFER;
+ bd.usage = Usage::DEFAULT;
+ bd.size = sizeof(verts);
+ bd.bind_flags = BindFlag::VERTEX_BUFFER;
device->CreateBuffer(&bd, verts, &wirecubeVB);
uint16_t indices[] = {
@@ -5033,9 +5019,9 @@ void DrawDebugWorld(
5,6,4,7,2,6,3,7,2,3,6,7
};
- bd.Usage = USAGE_DEFAULT;
- bd.Size = sizeof(indices);
- bd.BindFlags = BIND_INDEX_BUFFER;
+ bd.usage = Usage::DEFAULT;
+ bd.size = sizeof(indices);
+ bd.bind_flags = BindFlag::INDEX_BUFFER;
device->CreateBuffer(&bd, indices, &wirecubeIB);
}
@@ -5057,7 +5043,7 @@ void DrawDebugWorld(
sizeof(XMFLOAT4) + sizeof(XMFLOAT4),
};
device->BindVertexBuffers(vbs, 0, arraysize(vbs), strides, nullptr, cmd);
- device->BindIndexBuffer(&wirecubeIB, INDEXFORMAT_16BIT, 0, cmd);
+ device->BindIndexBuffer(&wirecubeIB, IndexBufferFormat::UINT16, 0, cmd);
MiscCB sb;
@@ -5457,7 +5443,7 @@ void DrawDebugWorld(
sizeof(XMFLOAT4) + sizeof(XMFLOAT4),
};
device->BindVertexBuffers(vbs, 0, arraysize(vbs), strides, nullptr, cmd);
- device->BindIndexBuffer(&wirecubeIB, INDEXFORMAT_16BIT, 0, cmd);
+ device->BindIndexBuffer(&wirecubeIB, IndexBufferFormat::UINT16, 0, cmd);
MiscCB sb;
@@ -5517,9 +5503,9 @@ void DrawDebugWorld(
}
GPUBufferDesc bd;
- bd.Usage = USAGE_DEFAULT;
- bd.Size = vertices.size() * sizeof(Vertex);
- bd.BindFlags = BIND_VERTEX_BUFFER;
+ bd.usage = Usage::DEFAULT;
+ bd.size = vertices.size() * sizeof(Vertex);
+ bd.bind_flags = BindFlag::VERTEX_BUFFER;
device->CreateBuffer(&bd, vertices.data(), &wiresphereVB);
std::vector indices;
@@ -5539,9 +5525,9 @@ void DrawDebugWorld(
indices.push_back(uint16_t(i + (segmentcount + 1) * 2 + 1));
}
- bd.Usage = USAGE_DEFAULT;
- bd.Size = indices.size() * sizeof(uint16_t);
- bd.BindFlags = BIND_INDEX_BUFFER;
+ bd.usage = Usage::DEFAULT;
+ bd.size = indices.size() * sizeof(uint16_t);
+ bd.bind_flags = BindFlag::INDEX_BUFFER;
device->CreateBuffer(&bd, indices.data(), &wiresphereIB);
}
@@ -5554,7 +5540,7 @@ void DrawDebugWorld(
sizeof(XMFLOAT4) + sizeof(XMFLOAT4),
};
device->BindVertexBuffers(vbs, 0, arraysize(vbs), strides, nullptr, cmd);
- device->BindIndexBuffer(&wiresphereIB, INDEXFORMAT_16BIT, 0, cmd);
+ device->BindIndexBuffer(&wiresphereIB, IndexBufferFormat::UINT16, 0, cmd);
MiscCB sb;
@@ -5570,7 +5556,7 @@ void DrawDebugWorld(
device->BindDynamicConstantBuffer(sb, CB_GETBINDSLOT(MiscCB), cmd);
- device->DrawIndexed((uint32_t)(wiresphereIB.GetDesc().Size / sizeof(uint16_t)), 0, 0, cmd);
+ device->DrawIndexed((uint32_t)(wiresphereIB.GetDesc().size / sizeof(uint16_t)), 0, 0, cmd);
}
renderableSpheres.clear();
@@ -5695,7 +5681,7 @@ void DrawDebugWorld(
}
else
{
- device->BindResource(&scene.envmapArray, TEXSLOT_ONDEMAND0, cmd, scene.envmapArray.GetDesc().MipLevels + probe.textureIndex);
+ device->BindResource(&scene.envmapArray, TEXSLOT_ONDEMAND0, cmd, scene.envmapArray.GetDesc().mip_levels + probe.textureIndex);
}
device->Draw(2880, 0, cmd); // uv-sphere
@@ -5713,7 +5699,7 @@ void DrawDebugWorld(
sizeof(XMFLOAT4) + sizeof(XMFLOAT4),
};
device->BindVertexBuffers(vbs, 0, arraysize(vbs), strides, nullptr, cmd);
- device->BindIndexBuffer(&wirecubeIB, INDEXFORMAT_16BIT, 0, cmd);
+ device->BindIndexBuffer(&wirecubeIB, IndexBufferFormat::UINT16, 0, cmd);
for (size_t i = 0; i < scene.probes.GetCount(); ++i)
{
@@ -5775,8 +5761,8 @@ void DrawDebugWorld(
gridVertexCount = arraysize(verts) / 2;
GPUBufferDesc bd;
- bd.Size = sizeof(verts);
- bd.BindFlags = BIND_VERTEX_BUFFER;
+ bd.size = sizeof(verts);
+ bd.bind_flags = BindFlag::VERTEX_BUFFER;
device->CreateBuffer(&bd, verts, &grid);
}
@@ -5844,7 +5830,7 @@ void DrawDebugWorld(
sizeof(XMFLOAT4) + sizeof(XMFLOAT4),
};
device->BindVertexBuffers(vbs, 0, arraysize(vbs), strides, nullptr, cmd);
- device->BindIndexBuffer(&wirecubeIB, INDEXFORMAT_16BIT, 0, cmd);
+ device->BindIndexBuffer(&wirecubeIB, IndexBufferFormat::UINT16, 0, cmd);
device->DrawIndexed(24, 0, 0, cmd);
}
else
@@ -5900,7 +5886,7 @@ void DrawDebugWorld(
(uint)scene.meshes.GetIndex(object.meshID),
x.subset,
subset.materialIndex,
- device->GetDescriptorIndex(&mem.buffer, SRV),
+ device->GetDescriptorIndex(&mem.buffer, SubresourceType::SRV),
(uint32_t)mem.offset
);
device->PushConstants(&push, sizeof(push), cmd);
@@ -5967,9 +5953,9 @@ void DrawDebugWorld(
};
GPUBufferDesc bd;
- bd.Usage = USAGE_DEFAULT;
- bd.Size = sizeof(verts);
- bd.BindFlags = BIND_VERTEX_BUFFER;
+ bd.usage = Usage::DEFAULT;
+ bd.size = sizeof(verts);
+ bd.bind_flags = BindFlag::VERTEX_BUFFER;
device->CreateBuffer(&bd, verts, &wirecamVB);
uint16_t indices[] = {
@@ -5979,9 +5965,9 @@ void DrawDebugWorld(
0,2,1,3
};
- bd.Usage = USAGE_DEFAULT;
- bd.Size = sizeof(indices);
- bd.BindFlags = BIND_INDEX_BUFFER;
+ bd.usage = Usage::DEFAULT;
+ bd.size = sizeof(indices);
+ bd.bind_flags = BindFlag::INDEX_BUFFER;
device->CreateBuffer(&bd, indices, &wirecamIB);
}
@@ -5994,7 +5980,7 @@ void DrawDebugWorld(
sizeof(XMFLOAT4) + sizeof(XMFLOAT4),
};
device->BindVertexBuffers(vbs, 0, arraysize(vbs), strides, nullptr, cmd);
- device->BindIndexBuffer(&wirecamIB, INDEXFORMAT_16BIT, 0, cmd);
+ device->BindIndexBuffer(&wirecamIB, IndexBufferFormat::UINT16, 0, cmd);
MiscCB sb;
sb.g_xColor = XMFLOAT4(1, 1, 1, 1);
@@ -6044,14 +6030,14 @@ void RenderAtmosphericScatteringTextures(CommandList cmd)
{
GPUBarrier barriers[] = {
- GPUBarrier::Image(&textures[TEXTYPE_2D_SKYATMOSPHERE_TRANSMITTANCELUT], textures[TEXTYPE_2D_SKYATMOSPHERE_TRANSMITTANCELUT].desc.layout, RESOURCE_STATE_UNORDERED_ACCESS)
+ GPUBarrier::Image(&textures[TEXTYPE_2D_SKYATMOSPHERE_TRANSMITTANCELUT], textures[TEXTYPE_2D_SKYATMOSPHERE_TRANSMITTANCELUT].desc.layout, ResourceState::UNORDERED_ACCESS)
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
const int threadSize = 8;
- const int transmittanceLutWidth = textures[TEXTYPE_2D_SKYATMOSPHERE_TRANSMITTANCELUT].GetDesc().Width;
- const int transmittanceLutHeight = textures[TEXTYPE_2D_SKYATMOSPHERE_TRANSMITTANCELUT].GetDesc().Height;
+ const int transmittanceLutWidth = textures[TEXTYPE_2D_SKYATMOSPHERE_TRANSMITTANCELUT].GetDesc().width;
+ const int transmittanceLutHeight = textures[TEXTYPE_2D_SKYATMOSPHERE_TRANSMITTANCELUT].GetDesc().height;
const int transmittanceLutThreadX = static_cast(std::ceil(transmittanceLutWidth / threadSize));
const int transmittanceLutThreadY = static_cast(std::ceil(transmittanceLutHeight / threadSize));
@@ -6060,7 +6046,7 @@ void RenderAtmosphericScatteringTextures(CommandList cmd)
{
GPUBarrier barriers[] = {
GPUBarrier::Memory(),
- GPUBarrier::Image(&textures[TEXTYPE_2D_SKYATMOSPHERE_TRANSMITTANCELUT], RESOURCE_STATE_UNORDERED_ACCESS, textures[TEXTYPE_2D_SKYATMOSPHERE_TRANSMITTANCELUT].desc.layout)
+ GPUBarrier::Image(&textures[TEXTYPE_2D_SKYATMOSPHERE_TRANSMITTANCELUT], ResourceState::UNORDERED_ACCESS, textures[TEXTYPE_2D_SKYATMOSPHERE_TRANSMITTANCELUT].desc.layout)
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
@@ -6084,20 +6070,20 @@ void RenderAtmosphericScatteringTextures(CommandList cmd)
{
GPUBarrier barriers[] = {
- GPUBarrier::Image(&textures[TEXTYPE_2D_SKYATMOSPHERE_MULTISCATTEREDLUMINANCELUT], textures[TEXTYPE_2D_SKYATMOSPHERE_MULTISCATTEREDLUMINANCELUT].desc.layout, RESOURCE_STATE_UNORDERED_ACCESS)
+ GPUBarrier::Image(&textures[TEXTYPE_2D_SKYATMOSPHERE_MULTISCATTEREDLUMINANCELUT], textures[TEXTYPE_2D_SKYATMOSPHERE_MULTISCATTEREDLUMINANCELUT].desc.layout, ResourceState::UNORDERED_ACCESS)
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
- const int multiScatteredLutWidth = textures[TEXTYPE_2D_SKYATMOSPHERE_MULTISCATTEREDLUMINANCELUT].GetDesc().Width;
- const int multiScatteredLutHeight = textures[TEXTYPE_2D_SKYATMOSPHERE_MULTISCATTEREDLUMINANCELUT].GetDesc().Height;
+ const int multiScatteredLutWidth = textures[TEXTYPE_2D_SKYATMOSPHERE_MULTISCATTEREDLUMINANCELUT].GetDesc().width;
+ const int multiScatteredLutHeight = textures[TEXTYPE_2D_SKYATMOSPHERE_MULTISCATTEREDLUMINANCELUT].GetDesc().height;
device->Dispatch(multiScatteredLutWidth, multiScatteredLutHeight, 1, cmd);
{
GPUBarrier barriers[] = {
GPUBarrier::Memory(),
- GPUBarrier::Image(&textures[TEXTYPE_2D_SKYATMOSPHERE_MULTISCATTEREDLUMINANCELUT], RESOURCE_STATE_UNORDERED_ACCESS, textures[TEXTYPE_2D_SKYATMOSPHERE_MULTISCATTEREDLUMINANCELUT].desc.layout)
+ GPUBarrier::Image(&textures[TEXTYPE_2D_SKYATMOSPHERE_MULTISCATTEREDLUMINANCELUT], ResourceState::UNORDERED_ACCESS, textures[TEXTYPE_2D_SKYATMOSPHERE_MULTISCATTEREDLUMINANCELUT].desc.layout)
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
@@ -6120,20 +6106,20 @@ void RenderAtmosphericScatteringTextures(CommandList cmd)
{
GPUBarrier barriers[] = {
- GPUBarrier::Image(&textures[TEXTYPE_2D_SKYATMOSPHERE_SKYLUMINANCELUT], textures[TEXTYPE_2D_SKYATMOSPHERE_SKYLUMINANCELUT].desc.layout, RESOURCE_STATE_UNORDERED_ACCESS)
+ GPUBarrier::Image(&textures[TEXTYPE_2D_SKYATMOSPHERE_SKYLUMINANCELUT], textures[TEXTYPE_2D_SKYATMOSPHERE_SKYLUMINANCELUT].desc.layout, ResourceState::UNORDERED_ACCESS)
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
- const int environmentLutWidth = textures[TEXTYPE_2D_SKYATMOSPHERE_SKYLUMINANCELUT].GetDesc().Width;
- const int environmentLutHeight = textures[TEXTYPE_2D_SKYATMOSPHERE_SKYLUMINANCELUT].GetDesc().Height;
+ const int environmentLutWidth = textures[TEXTYPE_2D_SKYATMOSPHERE_SKYLUMINANCELUT].GetDesc().width;
+ const int environmentLutHeight = textures[TEXTYPE_2D_SKYATMOSPHERE_SKYLUMINANCELUT].GetDesc().height;
device->Dispatch(environmentLutWidth, environmentLutHeight, 1, cmd);
{
GPUBarrier barriers[] = {
GPUBarrier::Memory(),
- GPUBarrier::Image(&textures[TEXTYPE_2D_SKYATMOSPHERE_SKYLUMINANCELUT], RESOURCE_STATE_UNORDERED_ACCESS, textures[TEXTYPE_2D_SKYATMOSPHERE_SKYLUMINANCELUT].desc.layout)
+ GPUBarrier::Image(&textures[TEXTYPE_2D_SKYATMOSPHERE_SKYLUMINANCELUT], ResourceState::UNORDERED_ACCESS, textures[TEXTYPE_2D_SKYATMOSPHERE_SKYLUMINANCELUT].desc.layout)
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
@@ -6166,14 +6152,14 @@ void RefreshAtmosphericScatteringTextures(CommandList cmd)
{
GPUBarrier barriers[] = {
- GPUBarrier::Image(&textures[TEXTYPE_2D_SKYATMOSPHERE_SKYVIEWLUT], textures[TEXTYPE_2D_SKYATMOSPHERE_SKYVIEWLUT].desc.layout, RESOURCE_STATE_UNORDERED_ACCESS)
+ GPUBarrier::Image(&textures[TEXTYPE_2D_SKYATMOSPHERE_SKYVIEWLUT], textures[TEXTYPE_2D_SKYATMOSPHERE_SKYVIEWLUT].desc.layout, ResourceState::UNORDERED_ACCESS)
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
const int threadSize = 8;
- const int skyViewLutWidth = textures[TEXTYPE_2D_SKYATMOSPHERE_SKYVIEWLUT].GetDesc().Width;
- const int skyViewLutHeight = textures[TEXTYPE_2D_SKYATMOSPHERE_SKYVIEWLUT].GetDesc().Height;
+ const int skyViewLutWidth = textures[TEXTYPE_2D_SKYATMOSPHERE_SKYVIEWLUT].GetDesc().width;
+ const int skyViewLutHeight = textures[TEXTYPE_2D_SKYATMOSPHERE_SKYVIEWLUT].GetDesc().height;
const int skyViewLutThreadX = static_cast(std::ceil(skyViewLutWidth / threadSize));
const int skyViewLutThreadY = static_cast(std::ceil(skyViewLutHeight / threadSize));
@@ -6182,7 +6168,7 @@ void RefreshAtmosphericScatteringTextures(CommandList cmd)
{
GPUBarrier barriers[] = {
GPUBarrier::Memory(),
- GPUBarrier::Image(&textures[TEXTYPE_2D_SKYATMOSPHERE_SKYVIEWLUT], RESOURCE_STATE_UNORDERED_ACCESS, textures[TEXTYPE_2D_SKYATMOSPHERE_SKYVIEWLUT].desc.layout)
+ GPUBarrier::Image(&textures[TEXTYPE_2D_SKYATMOSPHERE_SKYVIEWLUT], ResourceState::UNORDERED_ACCESS, textures[TEXTYPE_2D_SKYATMOSPHERE_SKYVIEWLUT].desc.layout)
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
@@ -6236,7 +6222,7 @@ void RefreshEnvProbes(const Visibility& vis, CommandList cmd)
BindCommonResources(cmd);
Viewport vp;
- vp.Height = vp.Width = (float)vis.scene->envmapArray.desc.Width;
+ vp.height = vp.width = (float)vis.scene->envmapArray.desc.width;
device->BindViewports(1, &vp, cmd);
const float zNearP = vis.camera->zNearP;
@@ -6337,18 +6323,18 @@ void RefreshEnvProbes(const Visibility& vis, CommandList cmd)
device->BindComputeShader(&shaders[CSTYPE_FILTERENVMAP], cmd);
- desc.Width = 1;
- desc.Height = 1;
- for (uint32_t i = desc.MipLevels - 1; i > 0; --i)
+ desc.width = 1;
+ desc.height = 1;
+ for (uint32_t i = desc.mip_levels - 1; i > 0; --i)
{
{
GPUBarrier barriers[] = {
- 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),
+ GPUBarrier::Image(&vis.scene->envmapArray, ResourceState::SHADER_RESOURCE, ResourceState::UNORDERED_ACCESS, i, arrayIndex * 6 + 0),
+ GPUBarrier::Image(&vis.scene->envmapArray, ResourceState::SHADER_RESOURCE, ResourceState::UNORDERED_ACCESS, i, arrayIndex * 6 + 1),
+ GPUBarrier::Image(&vis.scene->envmapArray, ResourceState::SHADER_RESOURCE, ResourceState::UNORDERED_ACCESS, i, arrayIndex * 6 + 2),
+ GPUBarrier::Image(&vis.scene->envmapArray, ResourceState::SHADER_RESOURCE, ResourceState::UNORDERED_ACCESS, i, arrayIndex * 6 + 3),
+ GPUBarrier::Image(&vis.scene->envmapArray, ResourceState::SHADER_RESOURCE, ResourceState::UNORDERED_ACCESS, i, arrayIndex * 6 + 4),
+ GPUBarrier::Image(&vis.scene->envmapArray, ResourceState::SHADER_RESOURCE, ResourceState::UNORDERED_ACCESS, i, arrayIndex * 6 + 5),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
@@ -6357,38 +6343,38 @@ void RefreshEnvProbes(const Visibility& vis, CommandList cmd)
device->BindResource(&vis.scene->envmapArray, TEXSLOT_ONDEMAND0, cmd, std::max(0, (int)i - 2));
FilterEnvmapPushConstants push;
- push.filterResolution.x = desc.Width;
- push.filterResolution.y = desc.Height;
+ push.filterResolution.x = desc.width;
+ push.filterResolution.y = desc.height;
push.filterResolution_rcp.x = 1.0f / push.filterResolution.x;
push.filterResolution_rcp.y = 1.0f / push.filterResolution.y;
push.filterArrayIndex = arrayIndex;
- push.filterRoughness = (float)i / (float)desc.MipLevels;
+ push.filterRoughness = (float)i / (float)desc.mip_levels;
push.filterRayCount = 128;
- push.texture_input = device->GetDescriptorIndex(&vis.scene->envmapArray, SRV, std::max(0, (int)i - 2));
- push.texture_output = device->GetDescriptorIndex(&vis.scene->envmapArray, UAV, i);
+ push.texture_input = device->GetDescriptorIndex(&vis.scene->envmapArray, SubresourceType::SRV, std::max(0, (int)i - 2));
+ push.texture_output = device->GetDescriptorIndex(&vis.scene->envmapArray, SubresourceType::UAV, i);
device->PushConstants(&push, sizeof(push), cmd);
device->Dispatch(
- std::max(1u, (uint32_t)ceilf((float)desc.Width / GENERATEMIPCHAIN_2D_BLOCK_SIZE)),
- std::max(1u, (uint32_t)ceilf((float)desc.Height / GENERATEMIPCHAIN_2D_BLOCK_SIZE)),
+ std::max(1u, (uint32_t)ceilf((float)desc.width / GENERATEMIPCHAIN_2D_BLOCK_SIZE)),
+ std::max(1u, (uint32_t)ceilf((float)desc.height / GENERATEMIPCHAIN_2D_BLOCK_SIZE)),
6,
cmd);
{
GPUBarrier barriers[] = {
GPUBarrier::Memory(),
- 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),
+ GPUBarrier::Image(&vis.scene->envmapArray, ResourceState::UNORDERED_ACCESS, ResourceState::SHADER_RESOURCE, i, arrayIndex * 6 + 0),
+ GPUBarrier::Image(&vis.scene->envmapArray, ResourceState::UNORDERED_ACCESS, ResourceState::SHADER_RESOURCE, i, arrayIndex * 6 + 1),
+ GPUBarrier::Image(&vis.scene->envmapArray, ResourceState::UNORDERED_ACCESS, ResourceState::SHADER_RESOURCE, i, arrayIndex * 6 + 2),
+ GPUBarrier::Image(&vis.scene->envmapArray, ResourceState::UNORDERED_ACCESS, ResourceState::SHADER_RESOURCE, i, arrayIndex * 6 + 3),
+ GPUBarrier::Image(&vis.scene->envmapArray, ResourceState::UNORDERED_ACCESS, ResourceState::SHADER_RESOURCE, i, arrayIndex * 6 + 4),
+ GPUBarrier::Image(&vis.scene->envmapArray, ResourceState::UNORDERED_ACCESS, ResourceState::SHADER_RESOURCE, i, arrayIndex * 6 + 5),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
- desc.Width *= 2;
- desc.Height *= 2;
+ desc.width *= 2;
+ desc.height *= 2;
}
}
device->EventEnd(cmd);
@@ -6488,8 +6474,8 @@ void RefreshImpostors(const Scene& scene, CommandList cmd)
device->RenderPassBegin(&scene.renderpasses_impostor[textureIndex], cmd);
Viewport viewport;
- viewport.Height = (float)scene.impostorTextureDim;
- viewport.Width = (float)scene.impostorTextureDim;
+ viewport.height = (float)scene.impostorTextureDim;
+ viewport.width = (float)scene.impostorTextureDim;
device->BindViewports(1, &viewport, cmd);
for (size_t subsetIndex = 0; subsetIndex < mesh.subsets.size(); ++subsetIndex)
@@ -6537,7 +6523,7 @@ void VoxelRadiance(const Visibility& vis, CommandList cmd)
if (!renderpass_voxelize.IsValid())
{
RenderPassDesc renderpassdesc;
- renderpassdesc._flags = RenderPassDesc::FLAG_ALLOW_UAV_WRITES;
+ renderpassdesc.flags = RenderPassDesc::Flags::ALLOW_UAV_WRITES;
device->CreateRenderPass(&renderpassdesc, &renderpass_voxelize);
}
@@ -6569,8 +6555,8 @@ void VoxelRadiance(const Visibility& vis, CommandList cmd)
if (!renderQueue.empty())
{
Viewport vp;
- vp.Width = (float)voxelSceneData.res;
- vp.Height = (float)voxelSceneData.res;
+ vp.width = (float)voxelSceneData.res;
+ vp.height = (float)voxelSceneData.res;
device->BindViewports(1, &vp, cmd);
GPUResource* UAVs[] = { &resourceBuffers[RBTYPE_VOXELSCENE] };
@@ -6671,22 +6657,22 @@ void CreateTiledLightResources(TiledLightResources& res, XMUINT2 resolution)
{
GPUBufferDesc bd;
- bd.Stride = sizeof(XMFLOAT4) * 4; // storing 4 planes for every tile
- bd.Size = bd.Stride * res.tileCount.x * res.tileCount.y;
- bd.BindFlags = BIND_SHADER_RESOURCE | BIND_UNORDERED_ACCESS;
- bd.MiscFlags = RESOURCE_MISC_BUFFER_STRUCTURED;
- bd.Usage = USAGE_DEFAULT;
+ bd.stride = sizeof(XMFLOAT4) * 4; // storing 4 planes for every tile
+ bd.size = bd.stride * res.tileCount.x * res.tileCount.y;
+ bd.bind_flags = BindFlag::SHADER_RESOURCE | BindFlag::UNORDERED_ACCESS;
+ bd.misc_flags = ResourceMiscFlag::BUFFER_STRUCTURED;
+ bd.usage = Usage::DEFAULT;
device->CreateBuffer(&bd, nullptr, &res.tileFrustums);
device->SetName(&res.tileFrustums, "tileFrustums");
}
{
GPUBufferDesc bd;
- bd.Stride = sizeof(uint);
- bd.Size = res.tileCount.x * res.tileCount.y * bd.Stride * SHADER_ENTITY_TILE_BUCKET_COUNT;
- bd.Usage = USAGE_DEFAULT;
- bd.BindFlags = BIND_UNORDERED_ACCESS | BIND_SHADER_RESOURCE;
- bd.MiscFlags = RESOURCE_MISC_BUFFER_RAW;
+ bd.stride = sizeof(uint);
+ bd.size = res.tileCount.x * res.tileCount.y * bd.stride * SHADER_ENTITY_TILE_BUCKET_COUNT;
+ bd.usage = Usage::DEFAULT;
+ bd.bind_flags = BindFlag::UNORDERED_ACCESS | BindFlag::SHADER_RESOURCE;
+ bd.misc_flags = ResourceMiscFlag::BUFFER_RAW;
device->CreateBuffer(&bd, nullptr, &res.entityTiles_Opaque);
device->CreateBuffer(&bd, nullptr, &res.entityTiles_Transparent);
@@ -6715,7 +6701,7 @@ void ComputeTiledLightCulling(
{
GPUBarrier barriers[] = {
GPUBarrier::Memory(&res.tileFrustums),
- GPUBarrier::Buffer(&res.tileFrustums, RESOURCE_STATE_SHADER_RESOURCE, RESOURCE_STATE_UNORDERED_ACCESS)
+ GPUBarrier::Buffer(&res.tileFrustums, ResourceState::SHADER_RESOURCE, ResourceState::UNORDERED_ACCESS)
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
@@ -6755,9 +6741,9 @@ void ComputeTiledLightCulling(
{
GPUBarrier barriers[] = {
GPUBarrier::Memory(&res.tileFrustums),
- 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),
+ GPUBarrier::Buffer(&res.tileFrustums, ResourceState::UNORDERED_ACCESS, ResourceState::SHADER_RESOURCE),
+ GPUBarrier::Buffer(&res.entityTiles_Transparent, ResourceState::SHADER_RESOURCE, ResourceState::UNORDERED_ACCESS),
+ GPUBarrier::Buffer(&res.entityTiles_Opaque, ResourceState::SHADER_RESOURCE, ResourceState::UNORDERED_ACCESS),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
@@ -6768,8 +6754,8 @@ void ComputeTiledLightCulling(
GPUBarrier barriers[] = {
GPUBarrier::Memory(&res.entityTiles_Opaque),
GPUBarrier::Memory(&res.entityTiles_Transparent),
- 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),
+ GPUBarrier::Buffer(&res.entityTiles_Opaque, ResourceState::UNORDERED_ACCESS, ResourceState::SHADER_RESOURCE),
+ GPUBarrier::Buffer(&res.entityTiles_Transparent, ResourceState::UNORDERED_ACCESS, ResourceState::SHADER_RESOURCE),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
@@ -6790,7 +6776,7 @@ void ResolveMSAADepthBuffer(const Texture& dst, const Texture& src, CommandList
const TextureDesc& desc = src.GetDesc();
device->BindComputeShader(&shaders[CSTYPE_RESOLVEMSAADEPTHSTENCIL], cmd);
- device->Dispatch((desc.Width + 7) / 8, (desc.Height + 7) / 8, 1, cmd);
+ device->Dispatch((desc.width + 7) / 8, (desc.height + 7) / 8, 1, cmd);
@@ -6814,28 +6800,28 @@ void GenerateMipChain(const Texture& texture, MIPGENFILTER filter, CommandList c
{
TextureDesc desc = texture.GetDesc();
- if (desc.MipLevels < 2)
+ if (desc.mip_levels < 2)
{
assert(0);
return;
}
- bool hdr = !IsFormatUnorm(desc.Format);
+ bool hdr = !IsFormatUnorm(desc.format);
MipgenPushConstants mipgen;
- if (desc.type == TextureDesc::TEXTURE_1D)
+ if (desc.type == TextureDesc::Type::TEXTURE_1D)
{
assert(0); // not implemented
}
- else if (desc.type == TextureDesc::TEXTURE_2D)
+ else if (desc.type == TextureDesc::Type::TEXTURE_2D)
{
- if (desc.MiscFlags & RESOURCE_MISC_TEXTURECUBE)
+ if (has_flag(desc.misc_flags, ResourceMiscFlag::TEXTURECUBE))
{
- if (desc.ArraySize > 6)
+ if (desc.array_size > 6)
{
// Cubearray
assert(options.arrayIndex >= 0 && "You should only filter a specific cube in the array for now, so provide its index!");
@@ -6857,27 +6843,27 @@ void GenerateMipChain(const Texture& texture, MIPGENFILTER filter, CommandList c
break;
}
- for (uint32_t i = 0; i < desc.MipLevels - 1; ++i)
+ for (uint32_t i = 0; i < desc.mip_levels - 1; ++i)
{
{
GPUBarrier barriers[] = {
- 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),
+ GPUBarrier::Image(&texture, texture.desc.layout, ResourceState::UNORDERED_ACCESS, i + 1, options.arrayIndex * 6 + 0),
+ GPUBarrier::Image(&texture, texture.desc.layout, ResourceState::UNORDERED_ACCESS, i + 1, options.arrayIndex * 6 + 1),
+ GPUBarrier::Image(&texture, texture.desc.layout, ResourceState::UNORDERED_ACCESS, i + 1, options.arrayIndex * 6 + 2),
+ GPUBarrier::Image(&texture, texture.desc.layout, ResourceState::UNORDERED_ACCESS, i + 1, options.arrayIndex * 6 + 3),
+ GPUBarrier::Image(&texture, texture.desc.layout, ResourceState::UNORDERED_ACCESS, i + 1, options.arrayIndex * 6 + 4),
+ GPUBarrier::Image(&texture, texture.desc.layout, ResourceState::UNORDERED_ACCESS, i + 1, options.arrayIndex * 6 + 5),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
- mipgen.texture_output = device->GetDescriptorIndex(&texture, UAV, i + 1);
- mipgen.texture_input = device->GetDescriptorIndex(&texture, SRV, i);
- desc.Width = std::max(1u, desc.Width / 2);
- desc.Height = std::max(1u, desc.Height / 2);
+ mipgen.texture_output = device->GetDescriptorIndex(&texture, SubresourceType::UAV, i + 1);
+ mipgen.texture_input = device->GetDescriptorIndex(&texture, SubresourceType::SRV, i);
+ desc.width = std::max(1u, desc.width / 2);
+ desc.height = std::max(1u, desc.height / 2);
- mipgen.outputResolution.x = desc.Width;
- mipgen.outputResolution.y = desc.Height;
+ mipgen.outputResolution.x = desc.width;
+ mipgen.outputResolution.y = desc.height;
mipgen.outputResolution_rcp.x = 1.0f / mipgen.outputResolution.x;
mipgen.outputResolution_rcp.y = 1.0f / mipgen.outputResolution.y;
mipgen.arrayIndex = options.arrayIndex;
@@ -6885,20 +6871,20 @@ void GenerateMipChain(const Texture& texture, MIPGENFILTER filter, CommandList c
device->PushConstants(&mipgen, sizeof(mipgen), cmd);
device->Dispatch(
- std::max(1u, (desc.Width + GENERATEMIPCHAIN_2D_BLOCK_SIZE - 1) / GENERATEMIPCHAIN_2D_BLOCK_SIZE),
- std::max(1u, (desc.Height + GENERATEMIPCHAIN_2D_BLOCK_SIZE - 1) / GENERATEMIPCHAIN_2D_BLOCK_SIZE),
+ std::max(1u, (desc.width + GENERATEMIPCHAIN_2D_BLOCK_SIZE - 1) / GENERATEMIPCHAIN_2D_BLOCK_SIZE),
+ std::max(1u, (desc.height + GENERATEMIPCHAIN_2D_BLOCK_SIZE - 1) / GENERATEMIPCHAIN_2D_BLOCK_SIZE),
6,
cmd);
{
GPUBarrier barriers[] = {
GPUBarrier::Memory(),
- 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),
+ GPUBarrier::Image(&texture, ResourceState::UNORDERED_ACCESS, texture.desc.layout, i + 1, options.arrayIndex * 6 + 0),
+ GPUBarrier::Image(&texture, ResourceState::UNORDERED_ACCESS, texture.desc.layout, i + 1, options.arrayIndex * 6 + 1),
+ GPUBarrier::Image(&texture, ResourceState::UNORDERED_ACCESS, texture.desc.layout, i + 1, options.arrayIndex * 6 + 2),
+ GPUBarrier::Image(&texture, ResourceState::UNORDERED_ACCESS, texture.desc.layout, i + 1, options.arrayIndex * 6 + 3),
+ GPUBarrier::Image(&texture, ResourceState::UNORDERED_ACCESS, texture.desc.layout, i + 1, options.arrayIndex * 6 + 4),
+ GPUBarrier::Image(&texture, ResourceState::UNORDERED_ACCESS, texture.desc.layout, i + 1, options.arrayIndex * 6 + 5),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
@@ -6924,15 +6910,15 @@ void GenerateMipChain(const Texture& texture, MIPGENFILTER filter, CommandList c
break;
}
- for (uint32_t i = 0; i < desc.MipLevels - 1; ++i)
+ for (uint32_t i = 0; i < desc.mip_levels - 1; ++i)
{
- mipgen.texture_output = device->GetDescriptorIndex(&texture, UAV, i + 1);
- mipgen.texture_input = device->GetDescriptorIndex(&texture, SRV, i);
- desc.Width = std::max(1u, desc.Width / 2);
- desc.Height = std::max(1u, desc.Height / 2);
+ mipgen.texture_output = device->GetDescriptorIndex(&texture, SubresourceType::UAV, i + 1);
+ mipgen.texture_input = device->GetDescriptorIndex(&texture, SubresourceType::SRV, i);
+ desc.width = std::max(1u, desc.width / 2);
+ desc.height = std::max(1u, desc.height / 2);
- mipgen.outputResolution.x = desc.Width;
- mipgen.outputResolution.y = desc.Height;
+ mipgen.outputResolution.x = desc.width;
+ mipgen.outputResolution.y = desc.height;
mipgen.outputResolution_rcp.x = 1.0f / mipgen.outputResolution.x;
mipgen.outputResolution_rcp.y = 1.0f / mipgen.outputResolution.y;
mipgen.arrayIndex = 0;
@@ -6940,8 +6926,8 @@ void GenerateMipChain(const Texture& texture, MIPGENFILTER filter, CommandList c
device->PushConstants(&mipgen, sizeof(mipgen), cmd);
device->Dispatch(
- std::max(1u, (desc.Width + GENERATEMIPCHAIN_2D_BLOCK_SIZE - 1) / GENERATEMIPCHAIN_2D_BLOCK_SIZE),
- std::max(1u, (desc.Height + GENERATEMIPCHAIN_2D_BLOCK_SIZE - 1) / GENERATEMIPCHAIN_2D_BLOCK_SIZE),
+ std::max(1u, (desc.width + GENERATEMIPCHAIN_2D_BLOCK_SIZE - 1) / GENERATEMIPCHAIN_2D_BLOCK_SIZE),
+ std::max(1u, (desc.height + GENERATEMIPCHAIN_2D_BLOCK_SIZE - 1) / GENERATEMIPCHAIN_2D_BLOCK_SIZE),
6,
cmd);
@@ -6973,7 +6959,7 @@ void GenerateMipChain(const Texture& texture, MIPGENFILTER filter, CommandList c
assert(options.gaussian_temp != nullptr); // needed for separate filter!
device->EventBegin("GenerateMipChain 2D - GaussianFilter", cmd);
// Gaussian filter is a bit different as we do it in a separable way:
- for (uint32_t i = 0; i < desc.MipLevels - 1; ++i)
+ for (uint32_t i = 0; i < desc.mip_levels - 1; ++i)
{
Postprocess_Blur_Gaussian(texture, *options.gaussian_temp, texture, cmd, i, i + 1 , options.wide_gauss);
}
@@ -6986,22 +6972,22 @@ void GenerateMipChain(const Texture& texture, MIPGENFILTER filter, CommandList c
break;
}
- for (uint32_t i = 0; i < desc.MipLevels - 1; ++i)
+ for (uint32_t i = 0; i < desc.mip_levels - 1; ++i)
{
{
GPUBarrier barriers[] = {
- GPUBarrier::Image(&texture,texture.desc.layout,RESOURCE_STATE_UNORDERED_ACCESS,i + 1),
+ GPUBarrier::Image(&texture,texture.desc.layout,ResourceState::UNORDERED_ACCESS,i + 1),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
- mipgen.texture_output = device->GetDescriptorIndex(&texture, UAV, i + 1);
- mipgen.texture_input = device->GetDescriptorIndex(&texture, SRV, i);
- desc.Width = std::max(1u, desc.Width / 2);
- desc.Height = std::max(1u, desc.Height / 2);
+ mipgen.texture_output = device->GetDescriptorIndex(&texture, SubresourceType::UAV, i + 1);
+ mipgen.texture_input = device->GetDescriptorIndex(&texture, SubresourceType::SRV, i);
+ desc.width = std::max(1u, desc.width / 2);
+ desc.height = std::max(1u, desc.height / 2);
- mipgen.outputResolution.x = desc.Width;
- mipgen.outputResolution.y = desc.Height;
+ mipgen.outputResolution.x = desc.width;
+ mipgen.outputResolution.y = desc.height;
mipgen.outputResolution_rcp.x = 1.0f / mipgen.outputResolution.x;
mipgen.outputResolution_rcp.y = 1.0f / mipgen.outputResolution.y;
mipgen.arrayIndex = options.arrayIndex >= 0 ? (uint)options.arrayIndex : 0;
@@ -7013,15 +6999,15 @@ void GenerateMipChain(const Texture& texture, MIPGENFILTER filter, CommandList c
device->PushConstants(&mipgen, sizeof(mipgen), cmd);
device->Dispatch(
- std::max(1u, (desc.Width + GENERATEMIPCHAIN_2D_BLOCK_SIZE - 1) / GENERATEMIPCHAIN_2D_BLOCK_SIZE),
- std::max(1u, (desc.Height + GENERATEMIPCHAIN_2D_BLOCK_SIZE - 1) / GENERATEMIPCHAIN_2D_BLOCK_SIZE),
+ std::max(1u, (desc.width + GENERATEMIPCHAIN_2D_BLOCK_SIZE - 1) / GENERATEMIPCHAIN_2D_BLOCK_SIZE),
+ std::max(1u, (desc.height + GENERATEMIPCHAIN_2D_BLOCK_SIZE - 1) / GENERATEMIPCHAIN_2D_BLOCK_SIZE),
1,
cmd);
{
GPUBarrier barriers[] = {
GPUBarrier::Memory(),
- GPUBarrier::Image(&texture,RESOURCE_STATE_UNORDERED_ACCESS,texture.desc.layout,i + 1),
+ GPUBarrier::Image(&texture,ResourceState::UNORDERED_ACCESS,texture.desc.layout,i + 1),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
@@ -7031,7 +7017,7 @@ void GenerateMipChain(const Texture& texture, MIPGENFILTER filter, CommandList c
device->EventEnd(cmd);
}
- else if (desc.type == TextureDesc::TEXTURE_3D)
+ else if (desc.type == TextureDesc::Type::TEXTURE_3D)
{
switch (filter)
{
@@ -7050,24 +7036,24 @@ void GenerateMipChain(const Texture& texture, MIPGENFILTER filter, CommandList c
break;
}
- for (uint32_t i = 0; i < desc.MipLevels - 1; ++i)
+ for (uint32_t i = 0; i < desc.mip_levels - 1; ++i)
{
- mipgen.texture_output = device->GetDescriptorIndex(&texture, UAV, i + 1);
- mipgen.texture_input = device->GetDescriptorIndex(&texture, SRV, 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);
+ mipgen.texture_output = device->GetDescriptorIndex(&texture, SubresourceType::UAV, i + 1);
+ mipgen.texture_input = device->GetDescriptorIndex(&texture, SubresourceType::SRV, 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);
{
GPUBarrier barriers[] = {
- GPUBarrier::Image(&texture,texture.desc.layout,RESOURCE_STATE_UNORDERED_ACCESS,i + 1),
+ GPUBarrier::Image(&texture,texture.desc.layout,ResourceState::UNORDERED_ACCESS,i + 1),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
- mipgen.outputResolution.x = desc.Width;
- mipgen.outputResolution.y = desc.Height;
- mipgen.outputResolution.z = desc.Depth;
+ mipgen.outputResolution.x = desc.width;
+ mipgen.outputResolution.y = desc.height;
+ mipgen.outputResolution.z = desc.depth;
mipgen.outputResolution_rcp.x = 1.0f / mipgen.outputResolution.x;
mipgen.outputResolution_rcp.y = 1.0f / mipgen.outputResolution.y;
mipgen.outputResolution_rcp.z = 1.0f / mipgen.outputResolution.z;
@@ -7076,15 +7062,15 @@ void GenerateMipChain(const Texture& texture, MIPGENFILTER filter, CommandList c
device->PushConstants(&mipgen, sizeof(mipgen), cmd);
device->Dispatch(
- std::max(1u, (desc.Width + GENERATEMIPCHAIN_3D_BLOCK_SIZE - 1) / GENERATEMIPCHAIN_3D_BLOCK_SIZE),
- std::max(1u, (desc.Height + GENERATEMIPCHAIN_3D_BLOCK_SIZE - 1) / GENERATEMIPCHAIN_3D_BLOCK_SIZE),
- std::max(1u, (desc.Depth + GENERATEMIPCHAIN_3D_BLOCK_SIZE - 1) / GENERATEMIPCHAIN_3D_BLOCK_SIZE),
+ std::max(1u, (desc.width + GENERATEMIPCHAIN_3D_BLOCK_SIZE - 1) / GENERATEMIPCHAIN_3D_BLOCK_SIZE),
+ std::max(1u, (desc.height + GENERATEMIPCHAIN_3D_BLOCK_SIZE - 1) / GENERATEMIPCHAIN_3D_BLOCK_SIZE),
+ std::max(1u, (desc.depth + GENERATEMIPCHAIN_3D_BLOCK_SIZE - 1) / GENERATEMIPCHAIN_3D_BLOCK_SIZE),
cmd);
{
GPUBarrier barriers[] = {
GPUBarrier::Memory(),
- GPUBarrier::Image(&texture,RESOURCE_STATE_UNORDERED_ACCESS,texture.desc.layout,i + 1),
+ GPUBarrier::Image(&texture,ResourceState::UNORDERED_ACCESS,texture.desc.layout,i + 1),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
@@ -7104,10 +7090,10 @@ void CopyTexture2D(const Texture& dst, int DstMIP, int DstX, int DstY, const Tex
const TextureDesc& desc_dst = dst.GetDesc();
const TextureDesc& desc_src = src.GetDesc();
- assert(desc_dst.BindFlags & BIND_UNORDERED_ACCESS);
- assert(desc_src.BindFlags & BIND_SHADER_RESOURCE);
+ assert(has_flag(desc_dst.bind_flags, BindFlag::UNORDERED_ACCESS));
+ assert(has_flag(desc_src.bind_flags, BindFlag::SHADER_RESOURCE));
- bool hdr = !IsFormatUnorm(desc_dst.Format);
+ bool hdr = !IsFormatUnorm(desc_dst.format);
if (borderExpand == BORDEREXPAND_DISABLE)
{
@@ -7139,8 +7125,8 @@ void CopyTexture2D(const Texture& dst, int DstMIP, int DstX, int DstY, const Tex
CopyTextureCB cb;
cb.xCopyDest.x = DstX;
cb.xCopyDest.y = DstY;
- cb.xCopySrcSize.x = desc_src.Width >> SrcMIP;
- cb.xCopySrcSize.y = desc_src.Height >> SrcMIP;
+ cb.xCopySrcSize.x = desc_src.width >> SrcMIP;
+ cb.xCopySrcSize.y = desc_src.height >> SrcMIP;
cb.xCopySrcMIP = SrcMIP;
cb.xCopyBorderExpandStyle = (uint)borderExpand;
device->PushConstants(&cb, sizeof(cb), cmd);
@@ -7151,7 +7137,7 @@ void CopyTexture2D(const Texture& dst, int DstMIP, int DstX, int DstY, const Tex
{
GPUBarrier barriers[] = {
- GPUBarrier::Image(&dst,dst.desc.layout,RESOURCE_STATE_UNORDERED_ACCESS, DstMIP),
+ GPUBarrier::Image(&dst,dst.desc.layout,ResourceState::UNORDERED_ACCESS, DstMIP),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
@@ -7162,7 +7148,7 @@ void CopyTexture2D(const Texture& dst, int DstMIP, int DstX, int DstY, const Tex
{
GPUBarrier barriers[] = {
GPUBarrier::Memory(),
- GPUBarrier::Image(&dst,RESOURCE_STATE_UNORDERED_ACCESS,dst.desc.layout, DstMIP),
+ GPUBarrier::Image(&dst,ResourceState::UNORDERED_ACCESS,dst.desc.layout, DstMIP),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
@@ -7195,8 +7181,8 @@ void RayTraceScene(
RaytracingCB cb;
cb.xTracePixelOffset = XMFLOAT2(halton.x, halton.y);
cb.xTraceAccumulationFactor = 1.0f / ((float)accumulation_sample + 1.0f);
- cb.xTraceResolution.x = desc.Width;
- cb.xTraceResolution.y = desc.Height;
+ 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;
cb.xTraceUserData.x = raytraceBounceCount;
@@ -7212,7 +7198,7 @@ void RayTraceScene(
{
GPUBarrier barriers[] = {
- GPUBarrier::Image(&output, output.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS),
+ GPUBarrier::Image(&output, output.desc.layout, ResourceState::UNORDERED_ACCESS),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
@@ -7227,15 +7213,15 @@ void RayTraceScene(
}
device->Dispatch(
- (desc.Width + RAYTRACING_LAUNCH_BLOCKSIZE - 1) / RAYTRACING_LAUNCH_BLOCKSIZE,
- (desc.Height + RAYTRACING_LAUNCH_BLOCKSIZE - 1) / RAYTRACING_LAUNCH_BLOCKSIZE,
+ (desc.width + RAYTRACING_LAUNCH_BLOCKSIZE - 1) / RAYTRACING_LAUNCH_BLOCKSIZE,
+ (desc.height + RAYTRACING_LAUNCH_BLOCKSIZE - 1) / RAYTRACING_LAUNCH_BLOCKSIZE,
1,
cmd);
{
GPUBarrier barriers[] = {
GPUBarrier::Memory(),
- GPUBarrier::Image(&output, RESOURCE_STATE_UNORDERED_ACCESS, output.desc.layout),
+ GPUBarrier::Image(&output, ResourceState::UNORDERED_ACCESS, output.desc.layout),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
@@ -7290,8 +7276,8 @@ void RefreshLightmaps(const Scene& scene, CommandList cmd)
}
Viewport vp;
- vp.Width = (float)desc.Width;
- vp.Height = (float)desc.Height;
+ vp.width = (float)desc.width;
+ vp.height = (float)desc.height;
device->BindViewports(1, &vp, cmd);
const TransformComponent& transform = scene.transforms[object.transform_index];
@@ -7317,8 +7303,8 @@ void RefreshLightmaps(const Scene& scene, CommandList cmd)
device->BindIndexBuffer(&mesh.indexBuffer, mesh.GetIndexFormat(), 0, cmd);
RaytracingCB cb;
- cb.xTraceResolution.x = desc.Width;
- cb.xTraceResolution.y = desc.Height;
+ 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)
@@ -7429,9 +7415,9 @@ void CreateLuminanceResources(LuminanceResources& res, XMUINT2 resolution)
{
float values[LUMINANCE_NUM_HISTOGRAM_BINS + 1 + 1] = {}; // 1 exposure + 1 luminance value + histogram
GPUBufferDesc desc;
- desc.Size = sizeof(values);
- desc.BindFlags = BIND_SHADER_RESOURCE | BIND_UNORDERED_ACCESS;
- desc.MiscFlags = RESOURCE_MISC_BUFFER_RAW;
+ desc.size = sizeof(values);
+ desc.bind_flags = BindFlag::SHADER_RESOURCE | BindFlag::UNORDERED_ACCESS;
+ desc.misc_flags = ResourceMiscFlag::BUFFER_RAW;
device->CreateBuffer(&desc, values, &res.luminance);
device->SetName(&res.luminance, "luminance");
}
@@ -7447,8 +7433,8 @@ void ComputeLuminance(
auto range = wiProfiler::BeginRangeGPU("Luminance", cmd);
PostProcess postprocess;
- postprocess.resolution.x = sourceImage.desc.Width / 2;
- postprocess.resolution.y = sourceImage.desc.Height / 2;
+ postprocess.resolution.x = sourceImage.desc.width / 2;
+ postprocess.resolution.y = sourceImage.desc.height / 2;
postprocess.resolution_rcp.x = 1.0f / postprocess.resolution.x;
postprocess.resolution_rcp.y = 1.0f / postprocess.resolution.y;
luminance_adaptionrate = adaption_rate;
@@ -7464,7 +7450,7 @@ void ComputeLuminance(
{
GPUBarrier barriers[] = {
- GPUBarrier::Buffer(&res.luminance, RESOURCE_STATE_SHADER_RESOURCE, RESOURCE_STATE_UNORDERED_ACCESS),
+ GPUBarrier::Buffer(&res.luminance, ResourceState::SHADER_RESOURCE, ResourceState::UNORDERED_ACCESS),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
@@ -7499,7 +7485,7 @@ void ComputeLuminance(
{
GPUBarrier barriers[] = {
GPUBarrier::Memory(),
- GPUBarrier::Buffer(&res.luminance, RESOURCE_STATE_UNORDERED_ACCESS, RESOURCE_STATE_SHADER_RESOURCE),
+ GPUBarrier::Buffer(&res.luminance, ResourceState::UNORDERED_ACCESS, ResourceState::SHADER_RESOURCE),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
@@ -7511,26 +7497,26 @@ void ComputeLuminance(
void CreateBloomResources(BloomResources& res, XMUINT2 resolution)
{
TextureDesc desc;
- desc.BindFlags = BIND_RENDER_TARGET | BIND_SHADER_RESOURCE | BIND_UNORDERED_ACCESS;
- desc.Format = FORMAT_R11G11B10_FLOAT;
- desc.Width = resolution.x / 4;
- desc.Height = resolution.y / 4;
- desc.MipLevels = std::min(5u, (uint32_t)std::log2(std::max(desc.Width, desc.Height)));
+ desc.bind_flags = BindFlag::RENDER_TARGET | BindFlag::SHADER_RESOURCE | BindFlag::UNORDERED_ACCESS;
+ desc.format = Format::R11G11B10_FLOAT;
+ desc.width = resolution.x / 4;
+ desc.height = resolution.y / 4;
+ desc.mip_levels = std::min(5u, (uint32_t)std::log2(std::max(desc.width, desc.height)));
device->CreateTexture(&desc, nullptr, &res.texture_bloom);
device->SetName(&res.texture_bloom, "bloom.texture_bloom");
device->CreateTexture(&desc, nullptr, &res.texture_temp);
device->SetName(&res.texture_temp, "bloom.texture_temp");
- for (uint32_t i = 0; i < res.texture_bloom.desc.MipLevels; ++i)
+ for (uint32_t i = 0; i < res.texture_bloom.desc.mip_levels; ++i)
{
int subresource_index;
- subresource_index = device->CreateSubresource(&res.texture_bloom, SRV, 0, 1, i, 1);
+ subresource_index = device->CreateSubresource(&res.texture_bloom, SubresourceType::SRV, 0, 1, i, 1);
assert(subresource_index == i);
- subresource_index = device->CreateSubresource(&res.texture_temp, SRV, 0, 1, i, 1);
+ subresource_index = device->CreateSubresource(&res.texture_temp, SubresourceType::SRV, 0, 1, i, 1);
assert(subresource_index == i);
- subresource_index = device->CreateSubresource(&res.texture_bloom, UAV, 0, 1, i, 1);
+ subresource_index = device->CreateSubresource(&res.texture_bloom, SubresourceType::UAV, 0, 1, i, 1);
assert(subresource_index == i);
- subresource_index = device->CreateSubresource(&res.texture_temp, UAV, 0, 1, i, 1);
+ subresource_index = device->CreateSubresource(&res.texture_temp, SubresourceType::UAV, 0, 1, i, 1);
assert(subresource_index == i);
}
}
@@ -7553,27 +7539,27 @@ void ComputeBloom(
const TextureDesc& desc = res.texture_bloom.GetDesc();
Bloom bloom;
- bloom.resolution_rcp.x = 1.0f / desc.Width;
- bloom.resolution_rcp.y = 1.0f / desc.Height;
+ bloom.resolution_rcp.x = 1.0f / desc.width;
+ bloom.resolution_rcp.y = 1.0f / desc.height;
bloom.threshold = threshold;
bloom.exposure = exposure;
- bloom.texture_input = device->GetDescriptorIndex(&input, SRV);
- bloom.texture_output = device->GetDescriptorIndex(&res.texture_bloom, UAV);
- bloom.buffer_input_luminance = device->GetDescriptorIndex(buffer_luminance, SRV);
+ bloom.texture_input = device->GetDescriptorIndex(&input, SubresourceType::SRV);
+ bloom.texture_output = device->GetDescriptorIndex(&res.texture_bloom, SubresourceType::UAV);
+ bloom.buffer_input_luminance = device->GetDescriptorIndex(buffer_luminance, SubresourceType::SRV);
device->PushConstants(&bloom, sizeof(bloom), cmd);
device->BindComputeShader(&shaders[CSTYPE_POSTPROCESS_BLOOMSEPARATE], cmd);
{
GPUBarrier barriers[] = {
- GPUBarrier::Image(&res.texture_bloom, res.texture_bloom.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS),
+ GPUBarrier::Image(&res.texture_bloom, res.texture_bloom.desc.layout, ResourceState::UNORDERED_ACCESS),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
device->Dispatch(
- (desc.Width + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
- (desc.Height + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
+ (desc.width + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
+ (desc.height + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
1,
cmd
);
@@ -7581,7 +7567,7 @@ void ComputeBloom(
{
GPUBarrier barriers[] = {
GPUBarrier::Memory(),
- GPUBarrier::Image(&res.texture_bloom, RESOURCE_STATE_UNORDERED_ACCESS, res.texture_bloom.desc.layout),
+ GPUBarrier::Image(&res.texture_bloom, ResourceState::UNORDERED_ACCESS, res.texture_bloom.desc.layout),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
@@ -7615,7 +7601,7 @@ void ComputeShadingRateClassification(
{
GPUBarrier barriers[] = {
- GPUBarrier::Image(&debugUAV, debugUAV.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS),
+ GPUBarrier::Image(&debugUAV, debugUAV.desc.layout, ResourceState::UNORDERED_ACCESS),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
@@ -7631,13 +7617,13 @@ void ComputeShadingRateClassification(
ShadingRateClassification shadingrate = {}; // zero init the shading rates!
shadingrate.TileSize = device->GetVariableRateShadingTileSize();
- device->WriteShadingRateValue(SHADING_RATE_1X1, &shadingrate.SHADING_RATE_1X1);
- device->WriteShadingRateValue(SHADING_RATE_1X2, &shadingrate.SHADING_RATE_1X2);
- device->WriteShadingRateValue(SHADING_RATE_2X1, &shadingrate.SHADING_RATE_2X1);
- device->WriteShadingRateValue(SHADING_RATE_2X2, &shadingrate.SHADING_RATE_2X2);
- device->WriteShadingRateValue(SHADING_RATE_2X4, &shadingrate.SHADING_RATE_2X4);
- device->WriteShadingRateValue(SHADING_RATE_4X2, &shadingrate.SHADING_RATE_4X2);
- device->WriteShadingRateValue(SHADING_RATE_4X4, &shadingrate.SHADING_RATE_4X4);
+ device->WriteShadingRateValue(ShadingRate::RATE_1X1, &shadingrate.SHADING_RATE_1X1);
+ device->WriteShadingRateValue(ShadingRate::RATE_1X2, &shadingrate.SHADING_RATE_1X2);
+ device->WriteShadingRateValue(ShadingRate::RATE_2X1, &shadingrate.SHADING_RATE_2X1);
+ device->WriteShadingRateValue(ShadingRate::RATE_2X2, &shadingrate.SHADING_RATE_2X2);
+ device->WriteShadingRateValue(ShadingRate::RATE_2X4, &shadingrate.SHADING_RATE_2X4);
+ device->WriteShadingRateValue(ShadingRate::RATE_4X2, &shadingrate.SHADING_RATE_4X2);
+ device->WriteShadingRateValue(ShadingRate::RATE_4X4, &shadingrate.SHADING_RATE_4X4);
device->PushConstants(&shadingrate, sizeof(shadingrate), cmd);
const GPUResource* uavs[] = {
@@ -7646,13 +7632,13 @@ void ComputeShadingRateClassification(
device->BindUAVs(uavs, 0, arraysize(uavs), cmd);
// Whole threadgroup for each tile:
- device->Dispatch(desc.Width, desc.Height, 1, cmd);
+ device->Dispatch(desc.width, desc.height, 1, cmd);
if (GetVariableRateShadingClassificationDebug())
{
{
GPUBarrier barriers[] = {
- GPUBarrier::Image(&debugUAV, RESOURCE_STATE_UNORDERED_ACCESS, debugUAV.desc.layout),
+ GPUBarrier::Image(&debugUAV, ResourceState::UNORDERED_ACCESS, debugUAV.desc.layout),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
@@ -7677,7 +7663,7 @@ void VisibilityResolve(
BindCommonResources(cmd);
- const bool msaa = texture_primitiveID.desc.SampleCount > 1;
+ const bool msaa = texture_primitiveID.desc.sample_count > 1;
device->BindComputeShader(&shaders[msaa ? CSTYPE_VISIBILITY_RESOLVE_MSAA : CSTYPE_VISIBILITY_RESOLVE], cmd);
@@ -7697,33 +7683,33 @@ void VisibilityResolve(
device->BindUAV(&lineardepth, 9, cmd, 3);
device->BindUAV(&lineardepth, 10, cmd, 4);
- barrier_stack[cmd].push_back(GPUBarrier::Image(&gbuffer[GBUFFER_VELOCITY], gbuffer[GBUFFER_VELOCITY].desc.layout, RESOURCE_STATE_UNORDERED_ACCESS));
- barrier_stack[cmd].push_back(GPUBarrier::Image(&depthbuffer_resolved, depthbuffer_resolved.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS));
- barrier_stack[cmd].push_back(GPUBarrier::Image(&lineardepth, lineardepth.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS));
+ barrier_stack[cmd].push_back(GPUBarrier::Image(&gbuffer[GBUFFER_VELOCITY], gbuffer[GBUFFER_VELOCITY].desc.layout, ResourceState::UNORDERED_ACCESS));
+ barrier_stack[cmd].push_back(GPUBarrier::Image(&depthbuffer_resolved, depthbuffer_resolved.desc.layout, ResourceState::UNORDERED_ACCESS));
+ barrier_stack[cmd].push_back(GPUBarrier::Image(&lineardepth, lineardepth.desc.layout, ResourceState::UNORDERED_ACCESS));
if (msaa)
{
device->BindUAV(&gbuffer[GBUFFER_PRIMITIVEID], 11, cmd);
- barrier_stack[cmd].push_back(GPUBarrier::Image(&gbuffer[GBUFFER_PRIMITIVEID], gbuffer[GBUFFER_PRIMITIVEID].desc.layout, RESOURCE_STATE_UNORDERED_ACCESS));
+ barrier_stack[cmd].push_back(GPUBarrier::Image(&gbuffer[GBUFFER_PRIMITIVEID], gbuffer[GBUFFER_PRIMITIVEID].desc.layout, ResourceState::UNORDERED_ACCESS));
}
barrier_stack_flush(cmd);
device->Dispatch(
- (depthbuffer.desc.Width + 15) / 16,
- (depthbuffer.desc.Height + 15) / 16,
+ (depthbuffer.desc.width + 15) / 16,
+ (depthbuffer.desc.height + 15) / 16,
1,
cmd
);
barrier_stack[cmd].push_back(GPUBarrier::Memory());
- barrier_stack[cmd].push_back(GPUBarrier::Image(&gbuffer[GBUFFER_VELOCITY], RESOURCE_STATE_UNORDERED_ACCESS, gbuffer[GBUFFER_VELOCITY].desc.layout));
- barrier_stack[cmd].push_back(GPUBarrier::Image(&depthbuffer_resolved, RESOURCE_STATE_UNORDERED_ACCESS, depthbuffer_resolved.desc.layout));
- barrier_stack[cmd].push_back(GPUBarrier::Image(&lineardepth, RESOURCE_STATE_UNORDERED_ACCESS, lineardepth.desc.layout));
+ barrier_stack[cmd].push_back(GPUBarrier::Image(&gbuffer[GBUFFER_VELOCITY], ResourceState::UNORDERED_ACCESS, gbuffer[GBUFFER_VELOCITY].desc.layout));
+ barrier_stack[cmd].push_back(GPUBarrier::Image(&depthbuffer_resolved, ResourceState::UNORDERED_ACCESS, depthbuffer_resolved.desc.layout));
+ barrier_stack[cmd].push_back(GPUBarrier::Image(&lineardepth, ResourceState::UNORDERED_ACCESS, lineardepth.desc.layout));
if (msaa)
{
- barrier_stack[cmd].push_back(GPUBarrier::Image(&gbuffer[GBUFFER_PRIMITIVEID], RESOURCE_STATE_UNORDERED_ACCESS, gbuffer[GBUFFER_PRIMITIVEID].desc.layout));
+ barrier_stack[cmd].push_back(GPUBarrier::Image(&gbuffer[GBUFFER_PRIMITIVEID], ResourceState::UNORDERED_ACCESS, gbuffer[GBUFFER_PRIMITIVEID].desc.layout));
}
barrier_stack_flush(cmd);
@@ -7735,11 +7721,11 @@ void VisibilityResolve(
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;
+ desc.width = resolution.x;
+ desc.height = resolution.y;
+ desc.format = Format::R11G11B10_FLOAT;
+ desc.bind_flags = BindFlag::SHADER_RESOURCE | BindFlag::UNORDERED_ACCESS;
+ desc.layout = ResourceState::SHADER_RESOURCE_COMPUTE;
device->CreateTexture(&desc, nullptr, &res.result);
device->SetName(&res.result, "surfelGI.result");
}
@@ -7776,24 +7762,24 @@ void SurfelGI_Coverage(
{
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),
+ GPUBarrier::Buffer(&scene.surfelStatsBuffer, ResourceState::INDIRECT_ARGUMENT, ResourceState::UNORDERED_ACCESS),
+ GPUBarrier::Image(&res.result, res.result.desc.layout, ResourceState::UNORDERED_ACCESS),
+ GPUBarrier::Image(&debugUAV, debugUAV.desc.layout, ResourceState::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,
+ (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,
+ (res.result.desc.width + 15) / 16,
+ (res.result.desc.height + 15) / 16,
1,
cmd
);
@@ -7802,8 +7788,8 @@ void SurfelGI_Coverage(
{
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),
+ GPUBarrier::Image(&res.result, ResourceState::UNORDERED_ACCESS, res.result.desc.layout),
+ GPUBarrier::Image(&debugUAV, ResourceState::UNORDERED_ACCESS, debugUAV.desc.layout),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
@@ -7856,7 +7842,7 @@ void SurfelGI(
{
GPUBarrier barriers[] = {
- GPUBarrier::Buffer(&scene.surfelGridBuffer, RESOURCE_STATE_SHADER_RESOURCE_COMPUTE, RESOURCE_STATE_UNORDERED_ACCESS),
+ GPUBarrier::Buffer(&scene.surfelGridBuffer, ResourceState::SHADER_RESOURCE_COMPUTE, ResourceState::UNORDERED_ACCESS),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
@@ -7892,7 +7878,7 @@ void SurfelGI(
{
GPUBarrier barriers[] = {
- GPUBarrier::Buffer(&scene.surfelBuffer, RESOURCE_STATE_SHADER_RESOURCE_COMPUTE, RESOURCE_STATE_UNORDERED_ACCESS),
+ GPUBarrier::Buffer(&scene.surfelBuffer, ResourceState::SHADER_RESOURCE_COMPUTE, ResourceState::UNORDERED_ACCESS),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
@@ -7902,7 +7888,7 @@ void SurfelGI(
{
GPUBarrier barriers[] = {
GPUBarrier::Memory(),
- GPUBarrier::Buffer(&scene.surfelBuffer, RESOURCE_STATE_UNORDERED_ACCESS, RESOURCE_STATE_SHADER_RESOURCE_COMPUTE),
+ GPUBarrier::Buffer(&scene.surfelBuffer, ResourceState::UNORDERED_ACCESS, ResourceState::SHADER_RESOURCE_COMPUTE),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
@@ -7924,8 +7910,8 @@ void SurfelGI(
{
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),
+ GPUBarrier::Buffer(&scene.surfelCellBuffer, ResourceState::SHADER_RESOURCE_COMPUTE, ResourceState::UNORDERED_ACCESS),
+ GPUBarrier::Buffer(&scene.surfelStatsBuffer, ResourceState::INDIRECT_ARGUMENT, ResourceState::UNORDERED_ACCESS),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
@@ -7940,7 +7926,7 @@ void SurfelGI(
{
GPUBarrier barriers[] = {
GPUBarrier::Memory(),
- GPUBarrier::Buffer(&scene.surfelStatsBuffer, RESOURCE_STATE_UNORDERED_ACCESS, RESOURCE_STATE_INDIRECT_ARGUMENT),
+ GPUBarrier::Buffer(&scene.surfelStatsBuffer, ResourceState::UNORDERED_ACCESS, ResourceState::INDIRECT_ARGUMENT),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
@@ -7968,8 +7954,8 @@ void SurfelGI(
{
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),
+ GPUBarrier::Buffer(&scene.surfelGridBuffer, ResourceState::UNORDERED_ACCESS, ResourceState::SHADER_RESOURCE_COMPUTE),
+ GPUBarrier::Buffer(&scene.surfelCellBuffer, ResourceState::UNORDERED_ACCESS, ResourceState::SHADER_RESOURCE_COMPUTE),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
@@ -8000,8 +7986,8 @@ void SurfelGI(
{
GPUBarrier barriers[] = {
- GPUBarrier::Buffer(&scene.surfelDataBuffer, RESOURCE_STATE_SHADER_RESOURCE_COMPUTE, RESOURCE_STATE_UNORDERED_ACCESS),
- GPUBarrier::Image(&scene.surfelMomentsTexture[1], RESOURCE_STATE_SHADER_RESOURCE_COMPUTE, RESOURCE_STATE_UNORDERED_ACCESS),
+ GPUBarrier::Buffer(&scene.surfelDataBuffer, ResourceState::SHADER_RESOURCE_COMPUTE, ResourceState::UNORDERED_ACCESS),
+ GPUBarrier::Image(&scene.surfelMomentsTexture[1], ResourceState::SHADER_RESOURCE_COMPUTE, ResourceState::UNORDERED_ACCESS),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
@@ -8011,7 +7997,7 @@ void SurfelGI(
{
GPUBarrier barriers[] = {
GPUBarrier::Memory(),
- GPUBarrier::Image(&scene.surfelMomentsTexture[1], RESOURCE_STATE_UNORDERED_ACCESS, RESOURCE_STATE_SHADER_RESOURCE_COMPUTE),
+ GPUBarrier::Image(&scene.surfelMomentsTexture[1], ResourceState::UNORDERED_ACCESS, ResourceState::SHADER_RESOURCE_COMPUTE),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
@@ -8036,27 +8022,27 @@ void Postprocess_Blur_Gaussian(
device->EventBegin("Postprocess_Blur_Gaussian", cmd);
SHADERTYPE cs = CSTYPE_POSTPROCESS_BLUR_GAUSSIAN_FLOAT4;
- switch (output.GetDesc().Format)
+ switch (output.GetDesc().format)
{
- case FORMAT_R16_UNORM:
- case FORMAT_R8_UNORM:
+ case Format::R16_UNORM:
+ case Format::R8_UNORM:
cs = wide ? CSTYPE_POSTPROCESS_BLUR_GAUSSIAN_WIDE_UNORM1 : CSTYPE_POSTPROCESS_BLUR_GAUSSIAN_UNORM1;
break;
- case FORMAT_R16_FLOAT:
- case FORMAT_R32_FLOAT:
+ case Format::R16_FLOAT:
+ case Format::R32_FLOAT:
cs = wide ? CSTYPE_POSTPROCESS_BLUR_GAUSSIAN_WIDE_FLOAT1 : CSTYPE_POSTPROCESS_BLUR_GAUSSIAN_FLOAT1;
break;
- case FORMAT_R16G16B16A16_UNORM:
- case FORMAT_R8G8B8A8_UNORM:
- case FORMAT_B8G8R8A8_UNORM:
- case FORMAT_R10G10B10A2_UNORM:
+ case Format::R16G16B16A16_UNORM:
+ case Format::R8G8B8A8_UNORM:
+ case Format::B8G8R8A8_UNORM:
+ case Format::R10G10B10A2_UNORM:
cs = wide ? CSTYPE_POSTPROCESS_BLUR_GAUSSIAN_WIDE_UNORM4 : CSTYPE_POSTPROCESS_BLUR_GAUSSIAN_UNORM4;
break;
- case FORMAT_R11G11B10_FLOAT:
+ case Format::R11G11B10_FLOAT:
cs = wide ? CSTYPE_POSTPROCESS_BLUR_GAUSSIAN_WIDE_FLOAT3 : CSTYPE_POSTPROCESS_BLUR_GAUSSIAN_FLOAT3;
break;
- case FORMAT_R16G16B16A16_FLOAT:
- case FORMAT_R32G32B32A32_FLOAT:
+ case Format::R16G16B16A16_FLOAT:
+ case Format::R32G32B32A32_FLOAT:
cs = wide ? CSTYPE_POSTPROCESS_BLUR_GAUSSIAN_WIDE_FLOAT4 : CSTYPE_POSTPROCESS_BLUR_GAUSSIAN_FLOAT4;
break;
default:
@@ -8070,8 +8056,8 @@ void Postprocess_Blur_Gaussian(
const TextureDesc& desc = temp.GetDesc();
PostProcess postprocess;
- postprocess.resolution.x = desc.Width;
- postprocess.resolution.y = desc.Height;
+ postprocess.resolution.x = desc.width;
+ postprocess.resolution.y = desc.height;
if (mip_dst > 0)
{
postprocess.resolution.x >>= mip_dst;
@@ -8088,7 +8074,7 @@ void Postprocess_Blur_Gaussian(
{
GPUBarrier barriers[] = {
- GPUBarrier::Image(&temp, temp.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS, mip_dst),
+ GPUBarrier::Image(&temp, temp.desc.layout, ResourceState::UNORDERED_ACCESS, mip_dst),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
@@ -8103,7 +8089,7 @@ void Postprocess_Blur_Gaussian(
{
GPUBarrier barriers[] = {
GPUBarrier::Memory(),
- GPUBarrier::Image(&temp, RESOURCE_STATE_UNORDERED_ACCESS, temp.desc.layout, mip_dst),
+ GPUBarrier::Image(&temp, ResourceState::UNORDERED_ACCESS, temp.desc.layout, mip_dst),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
@@ -8115,8 +8101,8 @@ void Postprocess_Blur_Gaussian(
const TextureDesc& desc = output.GetDesc();
PostProcess postprocess;
- postprocess.resolution.x = desc.Width;
- postprocess.resolution.y = desc.Height;
+ postprocess.resolution.x = desc.width;
+ postprocess.resolution.y = desc.height;
if (mip_dst > 0)
{
postprocess.resolution.x >>= mip_dst;
@@ -8133,7 +8119,7 @@ void Postprocess_Blur_Gaussian(
{
GPUBarrier barriers[] = {
- GPUBarrier::Image(&output, output.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS, mip_dst),
+ GPUBarrier::Image(&output, output.desc.layout, ResourceState::UNORDERED_ACCESS, mip_dst),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
@@ -8148,7 +8134,7 @@ void Postprocess_Blur_Gaussian(
{
GPUBarrier barriers[] = {
GPUBarrier::Memory(),
- GPUBarrier::Image(&output, RESOURCE_STATE_UNORDERED_ACCESS, output.desc.layout, mip_dst),
+ GPUBarrier::Image(&output, ResourceState::UNORDERED_ACCESS, output.desc.layout, mip_dst),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
@@ -8172,27 +8158,27 @@ void Postprocess_Blur_Bilateral(
device->EventBegin("Postprocess_Blur_Bilateral", cmd);
SHADERTYPE cs = CSTYPE_POSTPROCESS_BLUR_BILATERAL_FLOAT4;
- switch (output.GetDesc().Format)
+ switch (output.GetDesc().format)
{
- case FORMAT_R16_UNORM:
- case FORMAT_R8_UNORM:
+ case Format::R16_UNORM:
+ case Format::R8_UNORM:
cs = wide ? CSTYPE_POSTPROCESS_BLUR_BILATERAL_WIDE_UNORM1 : CSTYPE_POSTPROCESS_BLUR_BILATERAL_UNORM1;
break;
- case FORMAT_R16_FLOAT:
- case FORMAT_R32_FLOAT:
+ case Format::R16_FLOAT:
+ case Format::R32_FLOAT:
cs = wide ? CSTYPE_POSTPROCESS_BLUR_BILATERAL_WIDE_FLOAT1 : CSTYPE_POSTPROCESS_BLUR_BILATERAL_FLOAT1;
break;
- case FORMAT_R16G16B16A16_UNORM:
- case FORMAT_R8G8B8A8_UNORM:
- case FORMAT_B8G8R8A8_UNORM:
- case FORMAT_R10G10B10A2_UNORM:
+ case Format::R16G16B16A16_UNORM:
+ case Format::R8G8B8A8_UNORM:
+ case Format::B8G8R8A8_UNORM:
+ case Format::R10G10B10A2_UNORM:
cs = wide ? CSTYPE_POSTPROCESS_BLUR_BILATERAL_WIDE_UNORM4 : CSTYPE_POSTPROCESS_BLUR_BILATERAL_UNORM4;
break;
- case FORMAT_R11G11B10_FLOAT:
+ case Format::R11G11B10_FLOAT:
cs = wide ? CSTYPE_POSTPROCESS_BLUR_BILATERAL_WIDE_FLOAT3 : CSTYPE_POSTPROCESS_BLUR_BILATERAL_FLOAT3;
break;
- case FORMAT_R16G16B16A16_FLOAT:
- case FORMAT_R32G32B32A32_FLOAT:
+ case Format::R16G16B16A16_FLOAT:
+ case Format::R32G32B32A32_FLOAT:
cs = wide ? CSTYPE_POSTPROCESS_BLUR_BILATERAL_WIDE_FLOAT4 : CSTYPE_POSTPROCESS_BLUR_BILATERAL_FLOAT4;
break;
default:
@@ -8206,8 +8192,8 @@ void Postprocess_Blur_Bilateral(
const TextureDesc& desc = temp.GetDesc();
PostProcess postprocess;
- postprocess.resolution.x = desc.Width;
- postprocess.resolution.y = desc.Height;
+ postprocess.resolution.x = desc.width;
+ postprocess.resolution.y = desc.height;
if (mip_dst > 0)
{
postprocess.resolution.x >>= mip_dst;
@@ -8225,7 +8211,7 @@ void Postprocess_Blur_Bilateral(
{
GPUBarrier barriers[] = {
- GPUBarrier::Image(&temp, temp.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS, mip_dst),
+ GPUBarrier::Image(&temp, temp.desc.layout, ResourceState::UNORDERED_ACCESS, mip_dst),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
@@ -8240,7 +8226,7 @@ void Postprocess_Blur_Bilateral(
{
GPUBarrier barriers[] = {
GPUBarrier::Memory(),
- GPUBarrier::Image(&temp, RESOURCE_STATE_UNORDERED_ACCESS, temp.desc.layout, mip_dst),
+ GPUBarrier::Image(&temp, ResourceState::UNORDERED_ACCESS, temp.desc.layout, mip_dst),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
@@ -8252,8 +8238,8 @@ void Postprocess_Blur_Bilateral(
const TextureDesc& desc = output.GetDesc();
PostProcess postprocess;
- postprocess.resolution.x = desc.Width;
- postprocess.resolution.y = desc.Height;
+ postprocess.resolution.x = desc.width;
+ postprocess.resolution.y = desc.height;
if (mip_dst > 0)
{
postprocess.resolution.x >>= mip_dst;
@@ -8271,7 +8257,7 @@ void Postprocess_Blur_Bilateral(
{
GPUBarrier barriers[] = {
- GPUBarrier::Image(&output, output.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS, mip_dst),
+ GPUBarrier::Image(&output, output.desc.layout, ResourceState::UNORDERED_ACCESS, mip_dst),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
@@ -8286,7 +8272,7 @@ void Postprocess_Blur_Bilateral(
{
GPUBarrier barriers[] = {
GPUBarrier::Memory(),
- GPUBarrier::Image(&output, RESOURCE_STATE_UNORDERED_ACCESS, output.desc.layout, mip_dst),
+ GPUBarrier::Image(&output, ResourceState::UNORDERED_ACCESS, output.desc.layout, mip_dst),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
@@ -8298,11 +8284,11 @@ void Postprocess_Blur_Bilateral(
void CreateSSAOResources(SSAOResources& res, XMUINT2 resolution)
{
TextureDesc desc;
- desc.Format = FORMAT_R8_UNORM;
- desc.Width = resolution.x / 2;
- desc.Height = resolution.y / 2;
- desc.BindFlags = BIND_UNORDERED_ACCESS | BIND_SHADER_RESOURCE;
- desc.layout = RESOURCE_STATE_SHADER_RESOURCE_COMPUTE;
+ desc.format = Format::R8_UNORM;
+ desc.width = resolution.x / 2;
+ desc.height = resolution.y / 2;
+ desc.bind_flags = BindFlag::UNORDERED_ACCESS | BindFlag::SHADER_RESOURCE;
+ desc.layout = ResourceState::SHADER_RESOURCE_COMPUTE;
device->CreateTexture(&desc, nullptr, &res.temp);
}
void Postprocess_SSAO(
@@ -8323,8 +8309,8 @@ void Postprocess_SSAO(
const TextureDesc& desc = output.GetDesc();
PostProcess postprocess;
- postprocess.resolution.x = desc.Width;
- postprocess.resolution.y = desc.Height;
+ postprocess.resolution.x = desc.width;
+ postprocess.resolution.y = desc.height;
postprocess.resolution_rcp.x = 1.0f / postprocess.resolution.x;
postprocess.resolution_rcp.y = 1.0f / postprocess.resolution.y;
ssao_range = range;
@@ -8339,14 +8325,14 @@ void Postprocess_SSAO(
{
GPUBarrier barriers[] = {
- GPUBarrier::Image(&output, output.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS),
+ GPUBarrier::Image(&output, output.desc.layout, ResourceState::UNORDERED_ACCESS),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
device->Dispatch(
- (desc.Width + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
- (desc.Height + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
+ (desc.width + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
+ (desc.height + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
1,
cmd
);
@@ -8354,7 +8340,7 @@ void Postprocess_SSAO(
{
GPUBarrier barriers[] = {
GPUBarrier::Memory(),
- GPUBarrier::Image(&output, RESOURCE_STATE_UNORDERED_ACCESS, output.desc.layout),
+ GPUBarrier::Image(&output, ResourceState::UNORDERED_ACCESS, output.desc.layout),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
@@ -8383,8 +8369,8 @@ void Postprocess_HBAO(
const TextureDesc& desc = output.GetDesc();
PostProcess postprocess;
- postprocess.resolution.x = desc.Width;
- postprocess.resolution.y = desc.Height;
+ postprocess.resolution.x = desc.width;
+ postprocess.resolution.y = desc.height;
postprocess.resolution_rcp.x = 1.0f / postprocess.resolution.x;
postprocess.resolution_rcp.y = 1.0f / postprocess.resolution.y;
postprocess.params0.x = 1;
@@ -8418,7 +8404,7 @@ void Postprocess_HBAO(
{
GPUBarrier barriers[] = {
- GPUBarrier::Image(&res.temp, res.temp.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS),
+ GPUBarrier::Image(&res.temp, res.temp.desc.layout, ResourceState::UNORDERED_ACCESS),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
@@ -8433,7 +8419,7 @@ void Postprocess_HBAO(
{
GPUBarrier barriers[] = {
GPUBarrier::Memory(),
- GPUBarrier::Image(&res.temp, RESOURCE_STATE_UNORDERED_ACCESS, res.temp.desc.layout),
+ GPUBarrier::Image(&res.temp, ResourceState::UNORDERED_ACCESS, res.temp.desc.layout),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
@@ -8454,7 +8440,7 @@ void Postprocess_HBAO(
{
GPUBarrier barriers[] = {
- GPUBarrier::Image(&output, output.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS),
+ GPUBarrier::Image(&output, output.desc.layout, ResourceState::UNORDERED_ACCESS),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
@@ -8469,7 +8455,7 @@ void Postprocess_HBAO(
{
GPUBarrier barriers[] = {
GPUBarrier::Memory(),
- GPUBarrier::Image(&output, RESOURCE_STATE_UNORDERED_ACCESS, output.desc.layout),
+ GPUBarrier::Image(&output, ResourceState::UNORDERED_ACCESS, output.desc.layout),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
@@ -8484,20 +8470,20 @@ void Postprocess_HBAO(
void CreateMSAOResources(MSAOResources& res, XMUINT2 resolution)
{
TextureDesc saved_desc;
- saved_desc.Format = FORMAT_R32_FLOAT;
- saved_desc.Width = resolution.x;
- saved_desc.Height = resolution.y;
- saved_desc.BindFlags = BIND_SHADER_RESOURCE | BIND_UNORDERED_ACCESS;
- saved_desc.layout = RESOURCE_STATE_SHADER_RESOURCE_COMPUTE;
+ saved_desc.format = Format::R32_FLOAT;
+ saved_desc.width = resolution.x;
+ saved_desc.height = resolution.y;
+ saved_desc.bind_flags = BindFlag::SHADER_RESOURCE | BindFlag::UNORDERED_ACCESS;
+ saved_desc.layout = ResourceState::SHADER_RESOURCE_COMPUTE;
- const uint32_t bufferWidth = saved_desc.Width;
+ const uint32_t bufferWidth = saved_desc.width;
const uint32_t bufferWidth1 = (bufferWidth + 1) / 2;
const uint32_t bufferWidth2 = (bufferWidth + 3) / 4;
const uint32_t bufferWidth3 = (bufferWidth + 7) / 8;
const uint32_t bufferWidth4 = (bufferWidth + 15) / 16;
const uint32_t bufferWidth5 = (bufferWidth + 31) / 32;
const uint32_t bufferWidth6 = (bufferWidth + 63) / 64;
- const uint32_t bufferHeight = saved_desc.Height;
+ const uint32_t bufferHeight = saved_desc.height;
const uint32_t bufferHeight1 = (bufferHeight + 1) / 2;
const uint32_t bufferHeight2 = (bufferHeight + 3) / 4;
const uint32_t bufferHeight3 = (bufferHeight + 7) / 8;
@@ -8506,64 +8492,64 @@ void CreateMSAOResources(MSAOResources& res, XMUINT2 resolution)
const uint32_t bufferHeight6 = (bufferHeight + 63) / 64;
TextureDesc desc = saved_desc;
- desc.Width = bufferWidth1;
- desc.Height = bufferHeight1;
+ desc.width = bufferWidth1;
+ desc.height = bufferHeight1;
device->CreateTexture(&desc, nullptr, &res.texture_lineardepth_downsize1);
- desc.Width = bufferWidth3;
- desc.Height = bufferHeight3;
- desc.ArraySize = 16;
- desc.Format = FORMAT_R16_FLOAT;
+ desc.width = bufferWidth3;
+ desc.height = bufferHeight3;
+ desc.array_size = 16;
+ desc.format = Format::R16_FLOAT;
device->CreateTexture(&desc, nullptr, &res.texture_lineardepth_tiled1);
desc = saved_desc;
- desc.Width = bufferWidth2;
- desc.Height = bufferHeight2;
+ desc.width = bufferWidth2;
+ desc.height = bufferHeight2;
device->CreateTexture(&desc, nullptr, &res.texture_lineardepth_downsize2);
- desc.Width = bufferWidth4;
- desc.Height = bufferHeight4;
- desc.ArraySize = 16;
- desc.Format = FORMAT_R16_FLOAT;
+ desc.width = bufferWidth4;
+ desc.height = bufferHeight4;
+ desc.array_size = 16;
+ desc.format = Format::R16_FLOAT;
device->CreateTexture(&desc, nullptr, &res.texture_lineardepth_tiled2);
desc = saved_desc;
- desc.Width = bufferWidth3;
- desc.Height = bufferHeight3;
+ desc.width = bufferWidth3;
+ desc.height = bufferHeight3;
device->CreateTexture(&desc, nullptr, &res.texture_lineardepth_downsize3);
- desc.Width = bufferWidth5;
- desc.Height = bufferHeight5;
- desc.ArraySize = 16;
- desc.Format = FORMAT_R16_FLOAT;
+ desc.width = bufferWidth5;
+ desc.height = bufferHeight5;
+ desc.array_size = 16;
+ desc.format = Format::R16_FLOAT;
device->CreateTexture(&desc, nullptr, &res.texture_lineardepth_tiled3);
desc = saved_desc;
- desc.Width = bufferWidth4;
- desc.Height = bufferHeight4;
+ desc.width = bufferWidth4;
+ desc.height = bufferHeight4;
device->CreateTexture(&desc, nullptr, &res.texture_lineardepth_downsize4);
- desc.Width = bufferWidth6;
- desc.Height = bufferHeight6;
- desc.ArraySize = 16;
- desc.Format = FORMAT_R16_FLOAT;
+ desc.width = bufferWidth6;
+ desc.height = bufferHeight6;
+ desc.array_size = 16;
+ desc.format = Format::R16_FLOAT;
device->CreateTexture(&desc, nullptr, &res.texture_lineardepth_tiled4);
desc = saved_desc;
- desc.Format = FORMAT_R8_UNORM;
- desc.Width = bufferWidth1;
- desc.Height = bufferHeight1;
+ desc.format = Format::R8_UNORM;
+ desc.width = bufferWidth1;
+ desc.height = bufferHeight1;
device->CreateTexture(&desc, nullptr, &res.texture_ao_merged1);
device->CreateTexture(&desc, nullptr, &res.texture_ao_hq1);
device->CreateTexture(&desc, nullptr, &res.texture_ao_smooth1);
- desc.Width = bufferWidth2;
- desc.Height = bufferHeight2;
+ desc.width = bufferWidth2;
+ desc.height = bufferHeight2;
device->CreateTexture(&desc, nullptr, &res.texture_ao_merged2);
device->CreateTexture(&desc, nullptr, &res.texture_ao_hq2);
device->CreateTexture(&desc, nullptr, &res.texture_ao_smooth2);
- desc.Width = bufferWidth3;
- desc.Height = bufferHeight3;
+ desc.width = bufferWidth3;
+ desc.height = bufferHeight3;
device->CreateTexture(&desc, nullptr, &res.texture_ao_merged3);
device->CreateTexture(&desc, nullptr, &res.texture_ao_hq3);
device->CreateTexture(&desc, nullptr, &res.texture_ao_smooth3);
- desc.Width = bufferWidth4;
- desc.Height = bufferHeight4;
+ desc.width = bufferWidth4;
+ desc.height = bufferHeight4;
device->CreateTexture(&desc, nullptr, &res.texture_ao_merged4);
device->CreateTexture(&desc, nullptr, &res.texture_ao_hq4);
}
@@ -8593,24 +8579,24 @@ void Postprocess_MSAO(
{
GPUBarrier barriers[] = {
- 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),
+ GPUBarrier::Image(&res.texture_lineardepth_downsize1, res.texture_lineardepth_downsize1.desc.layout, ResourceState::UNORDERED_ACCESS),
+ GPUBarrier::Image(&res.texture_lineardepth_tiled1, res.texture_lineardepth_tiled1.desc.layout, ResourceState::UNORDERED_ACCESS),
+ GPUBarrier::Image(&res.texture_lineardepth_downsize2, res.texture_lineardepth_downsize2.desc.layout, ResourceState::UNORDERED_ACCESS),
+ GPUBarrier::Image(&res.texture_lineardepth_tiled2, res.texture_lineardepth_tiled2.desc.layout, ResourceState::UNORDERED_ACCESS),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
const TextureDesc& desc = res.texture_lineardepth_tiled2.GetDesc();
- device->Dispatch(desc.Width, desc.Height, 1, cmd);
+ device->Dispatch(desc.width, desc.height, 1, cmd);
{
GPUBarrier barriers[] = {
GPUBarrier::Memory(),
- 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),
+ GPUBarrier::Image(&res.texture_lineardepth_downsize1, ResourceState::UNORDERED_ACCESS, res.texture_lineardepth_downsize1.desc.layout),
+ GPUBarrier::Image(&res.texture_lineardepth_tiled1, ResourceState::UNORDERED_ACCESS, res.texture_lineardepth_tiled1.desc.layout),
+ GPUBarrier::Image(&res.texture_lineardepth_downsize2, ResourceState::UNORDERED_ACCESS, res.texture_lineardepth_downsize2.desc.layout),
+ GPUBarrier::Image(&res.texture_lineardepth_tiled2, ResourceState::UNORDERED_ACCESS, res.texture_lineardepth_tiled2.desc.layout),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
@@ -8633,24 +8619,24 @@ void Postprocess_MSAO(
{
GPUBarrier barriers[] = {
- 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),
+ GPUBarrier::Image(&res.texture_lineardepth_downsize3, res.texture_lineardepth_downsize3.desc.layout, ResourceState::UNORDERED_ACCESS),
+ GPUBarrier::Image(&res.texture_lineardepth_tiled3, res.texture_lineardepth_tiled3.desc.layout, ResourceState::UNORDERED_ACCESS),
+ GPUBarrier::Image(&res.texture_lineardepth_downsize4, res.texture_lineardepth_downsize4.desc.layout, ResourceState::UNORDERED_ACCESS),
+ GPUBarrier::Image(&res.texture_lineardepth_tiled4, res.texture_lineardepth_tiled4.desc.layout, ResourceState::UNORDERED_ACCESS),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
const TextureDesc& desc = res.texture_lineardepth_tiled4.GetDesc();
- device->Dispatch(desc.Width, desc.Height, 1, cmd);
+ device->Dispatch(desc.width, desc.height, 1, cmd);
{
GPUBarrier barriers[] = {
GPUBarrier::Memory(),
- 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),
+ GPUBarrier::Image(&res.texture_lineardepth_downsize3, ResourceState::UNORDERED_ACCESS, res.texture_lineardepth_downsize3.desc.layout),
+ GPUBarrier::Image(&res.texture_lineardepth_tiled3, ResourceState::UNORDERED_ACCESS, res.texture_lineardepth_tiled3.desc.layout),
+ GPUBarrier::Image(&res.texture_lineardepth_downsize4, ResourceState::UNORDERED_ACCESS, res.texture_lineardepth_downsize4.desc.layout),
+ GPUBarrier::Image(&res.texture_lineardepth_tiled4, ResourceState::UNORDERED_ACCESS, res.texture_lineardepth_tiled4.desc.layout),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
@@ -8700,8 +8686,8 @@ void Postprocess_MSAO(
// ScreenspaceDiameter: Diameter of sample sphere in pixel units
// ScreenspaceDiameter / BufferWidth: Ratio of the screen width that the sphere actually covers
// Note about the "2.0f * ": Diameter = 2 * Radius
- float ThicknessMultiplier = 2.0f * TanHalfFovH * ScreenspaceDiameter / desc.Width;
- if (desc.ArraySize == 1)
+ float ThicknessMultiplier = 2.0f * TanHalfFovH * ScreenspaceDiameter / desc.width;
+ if (desc.array_size == 1)
{
ThicknessMultiplier *= 2.0f;
}
@@ -8779,8 +8765,8 @@ void Postprocess_MSAO(
msao.xSampleWeightTable[2].z /= totalWeight;
msao.xSampleWeightTable[2].w /= totalWeight;
- msao.xInvSliceDimension.x = 1.0f / desc.Width;
- msao.xInvSliceDimension.y = 1.0f / desc.Height;
+ msao.xInvSliceDimension.x = 1.0f / desc.width;
+ msao.xInvSliceDimension.y = 1.0f / desc.height;
msao.xRejectFadeoff = 1.0f / -RejectionFalloff;
msao.xRcpAccentuation = 1.0f / (1.0f + Accentuation);
@@ -8795,26 +8781,26 @@ void Postprocess_MSAO(
{
GPUBarrier barriers[] = {
- GPUBarrier::Image(&write_result, write_result.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS),
+ GPUBarrier::Image(&write_result, write_result.desc.layout, ResourceState::UNORDERED_ACCESS),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
- if (desc.ArraySize == 1)
+ if (desc.array_size == 1)
{
device->BindComputeShader(&shaders[CSTYPE_POSTPROCESS_MSAO], cmd);
- device->Dispatch((desc.Width + 15) / 16, (desc.Height + 15) / 16, 1, cmd);
+ device->Dispatch((desc.width + 15) / 16, (desc.height + 15) / 16, 1, cmd);
}
else
{
device->BindComputeShader(&shaders[CSTYPE_POSTPROCESS_MSAO_INTERLEAVE], cmd);
- device->Dispatch((desc.Width + 7) / 8, (desc.Height + 7) / 8, desc.ArraySize, cmd);
+ device->Dispatch((desc.width + 7) / 8, (desc.height + 7) / 8, desc.array_size, cmd);
}
{
GPUBarrier barriers[] = {
GPUBarrier::Memory(),
- GPUBarrier::Image(&write_result, RESOURCE_STATE_UNORDERED_ACCESS, write_result.desc.layout),
+ GPUBarrier::Image(&write_result, ResourceState::UNORDERED_ACCESS, write_result.desc.layout),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
@@ -8836,10 +8822,10 @@ void Postprocess_MSAO(
auto blur_and_upsample = [&](const Texture& Destination, const Texture& HiResDepth, const Texture& LoResDepth,
const Texture* InterleavedAO, const Texture* HighQualityAO, const Texture* HiResAO)
{
- const uint32_t LoWidth = LoResDepth.GetDesc().Width;
- const uint32_t LoHeight = LoResDepth.GetDesc().Height;
- const uint32_t HiWidth = HiResDepth.GetDesc().Width;
- const uint32_t HiHeight = HiResDepth.GetDesc().Height;
+ const uint32_t LoWidth = LoResDepth.GetDesc().width;
+ const uint32_t LoHeight = LoResDepth.GetDesc().height;
+ const uint32_t HiWidth = HiResDepth.GetDesc().width;
+ const uint32_t HiHeight = HiResDepth.GetDesc().height;
if (HiResAO == nullptr)
{
@@ -8875,7 +8861,7 @@ void Postprocess_MSAO(
msao_upsample.kBlurTolerance *= msao_upsample.kBlurTolerance;
msao_upsample.kUpsampleTolerance = powf(10.0f, g_UpsampleTolerance);
msao_upsample.NoiseFilterStrength = 1.0f / (powf(10.0f, g_NoiseFilterTolerance) + msao_upsample.kUpsampleTolerance);
- msao_upsample.StepSize = (float)lineardepth.GetDesc().Width / (float)LoWidth;
+ msao_upsample.StepSize = (float)lineardepth.GetDesc().width / (float)LoWidth;
device->PushConstants(&msao_upsample, sizeof(msao_upsample), cmd);
device->BindUAV(&Destination, 0, cmd);
@@ -8896,7 +8882,7 @@ void Postprocess_MSAO(
{
GPUBarrier barriers[] = {
- GPUBarrier::Image(&Destination, Destination.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS),
+ GPUBarrier::Image(&Destination, Destination.desc.layout, ResourceState::UNORDERED_ACCESS),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
@@ -8906,7 +8892,7 @@ void Postprocess_MSAO(
{
GPUBarrier barriers[] = {
GPUBarrier::Memory(),
- GPUBarrier::Image(&Destination, RESOURCE_STATE_UNORDERED_ACCESS, Destination.desc.layout),
+ GPUBarrier::Image(&Destination, ResourceState::UNORDERED_ACCESS, Destination.desc.layout),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
@@ -8954,34 +8940,34 @@ void Postprocess_MSAO(
void CreateRTAOResources(RTAOResources& res, XMUINT2 resolution)
{
TextureDesc desc;
- desc.Width = resolution.x / 2;
- desc.Height = resolution.y / 2;
- desc.BindFlags = BIND_SHADER_RESOURCE | BIND_UNORDERED_ACCESS;
- desc.layout = RESOURCE_STATE_SHADER_RESOURCE_COMPUTE;
+ desc.width = resolution.x / 2;
+ desc.height = resolution.y / 2;
+ desc.bind_flags = BindFlag::SHADER_RESOURCE | BindFlag::UNORDERED_ACCESS;
+ desc.layout = ResourceState::SHADER_RESOURCE_COMPUTE;
- desc.Format = FORMAT_R11G11B10_FLOAT;
+ desc.format = Format::R11G11B10_FLOAT;
device->CreateTexture(&desc, nullptr, &res.normals);
device->SetName(&res.normals, "rtao_normals");
GPUBufferDesc bd;
- bd.Stride = sizeof(uint);
- bd.Size = bd.Stride *
- ((desc.Width + 7) / 8) *
- ((desc.Height + 3) / 4);
- bd.MiscFlags = RESOURCE_MISC_BUFFER_STRUCTURED;
- bd.BindFlags = BIND_SHADER_RESOURCE | BIND_UNORDERED_ACCESS;
+ bd.stride = sizeof(uint);
+ bd.size = bd.stride *
+ ((desc.width + 7) / 8) *
+ ((desc.height + 3) / 4);
+ bd.misc_flags = ResourceMiscFlag::BUFFER_STRUCTURED;
+ bd.bind_flags = BindFlag::SHADER_RESOURCE | BindFlag::UNORDERED_ACCESS;
device->CreateBuffer(&bd, nullptr, &res.tiles);
device->SetName(&res.tiles, "rtshadow_tiles");
device->CreateBuffer(&bd, nullptr, &res.metadata);
device->SetName(&res.metadata, "rtshadow_metadata");
- desc.Format = FORMAT_R16G16_FLOAT;
+ desc.format = Format::R16G16_FLOAT;
device->CreateTexture(&desc, nullptr, &res.scratch[0]);
device->SetName(&res.scratch[0], "rtshadow_scratch[0]");
device->CreateTexture(&desc, nullptr, &res.scratch[1]);
device->SetName(&res.scratch[1], "rtshadow_scratch[1]");
- desc.Format = FORMAT_R11G11B10_FLOAT;
+ desc.format = Format::R11G11B10_FLOAT;
device->CreateTexture(&desc, nullptr, &res.moments[0]);
device->SetName(&res.moments[0], "rtshadow_moments[0]");
device->CreateTexture(&desc, nullptr, &res.moments[1]);
@@ -8996,7 +8982,7 @@ void Postprocess_RTAO(
float power
)
{
- if (!device->CheckCapability(GRAPHICSDEVICE_CAPABILITY_RAYTRACING))
+ if (!device->CheckCapability(GraphicsDeviceCapability::RAYTRACING))
return;
if (!scene.TLAS.IsValid())
@@ -9021,8 +9007,8 @@ void Postprocess_RTAO(
device->BindUAVs(uavs, 0, arraysize(uavs), cmd);
PostProcess postprocess;
- postprocess.resolution.x = desc.Width;
- postprocess.resolution.y = desc.Height;
+ postprocess.resolution.x = desc.width;
+ postprocess.resolution.y = desc.height;
postprocess.resolution_rcp.x = 1.0f / postprocess.resolution.x;
postprocess.resolution_rcp.y = 1.0f / postprocess.resolution.y;
rtao_range = range;
@@ -9032,16 +9018,16 @@ void Postprocess_RTAO(
{
GPUBarrier barriers[] = {
- 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),
+ GPUBarrier::Image(&output, output.desc.layout, ResourceState::UNORDERED_ACCESS),
+ GPUBarrier::Image(&res.normals, res.normals.desc.layout, ResourceState::UNORDERED_ACCESS),
+ GPUBarrier::Buffer(&res.tiles, ResourceState::SHADER_RESOURCE_COMPUTE, ResourceState::UNORDERED_ACCESS),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
device->Dispatch(
- (desc.Width + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
- (desc.Height + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
+ (desc.width + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
+ (desc.height + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
1,
cmd
);
@@ -9049,8 +9035,8 @@ void Postprocess_RTAO(
{
GPUBarrier barriers[] = {
GPUBarrier::Memory(),
- 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),
+ GPUBarrier::Image(&res.normals, ResourceState::UNORDERED_ACCESS, res.normals.desc.layout),
+ GPUBarrier::Buffer(&res.tiles, ResourceState::UNORDERED_ACCESS, ResourceState::SHADER_RESOURCE_COMPUTE),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
@@ -9081,16 +9067,16 @@ void Postprocess_RTAO(
{
GPUBarrier barriers[] = {
- 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)
+ GPUBarrier::Image(&res.scratch[0], res.scratch[0].desc.layout, ResourceState::UNORDERED_ACCESS),
+ GPUBarrier::Image(&res.moments[temporal_output], res.moments[temporal_output].desc.layout, ResourceState::UNORDERED_ACCESS),
+ GPUBarrier::Buffer(&res.metadata, ResourceState::SHADER_RESOURCE_COMPUTE, ResourceState::UNORDERED_ACCESS)
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
device->Dispatch(
- (desc.Width + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
- (desc.Height + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
+ (desc.width + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
+ (desc.height + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
1,
cmd
);
@@ -9098,9 +9084,9 @@ void Postprocess_RTAO(
{
GPUBarrier barriers[] = {
GPUBarrier::Memory(),
- 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)
+ GPUBarrier::Image(&res.scratch[0], ResourceState::UNORDERED_ACCESS, res.scratch[0].desc.layout),
+ GPUBarrier::Image(&res.moments[temporal_output], ResourceState::UNORDERED_ACCESS, res.moments[temporal_output].desc.layout),
+ GPUBarrier::Buffer(&res.metadata, ResourceState::UNORDERED_ACCESS, ResourceState::SHADER_RESOURCE_COMPUTE)
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
@@ -9126,7 +9112,7 @@ void Postprocess_RTAO(
device->BindUAVs(uavs, 0, arraysize(uavs), cmd);
{
GPUBarrier barriers[] = {
- GPUBarrier::Image(&res.scratch[1], res.scratch[1].desc.layout, RESOURCE_STATE_UNORDERED_ACCESS),
+ GPUBarrier::Image(&res.scratch[1], res.scratch[1].desc.layout, ResourceState::UNORDERED_ACCESS),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
@@ -9136,8 +9122,8 @@ void Postprocess_RTAO(
device->PushConstants(&postprocess, sizeof(postprocess), cmd);
device->Dispatch(
- (desc.Width + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
- (desc.Height + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
+ (desc.width + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
+ (desc.height + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
1,
cmd
);
@@ -9154,8 +9140,8 @@ void Postprocess_RTAO(
{
GPUBarrier barriers[] = {
GPUBarrier::Memory(),
- 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),
+ GPUBarrier::Image(&res.scratch[1], ResourceState::UNORDERED_ACCESS, res.scratch[1].desc.layout),
+ GPUBarrier::Image(&res.scratch[0], res.scratch[0].desc.layout, ResourceState::UNORDERED_ACCESS),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
@@ -9165,8 +9151,8 @@ void Postprocess_RTAO(
device->PushConstants(&postprocess, sizeof(postprocess), cmd);
device->Dispatch(
- (desc.Width + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
- (desc.Height + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
+ (desc.width + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
+ (desc.height + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
1,
cmd
);
@@ -9183,8 +9169,8 @@ void Postprocess_RTAO(
{
GPUBarrier barriers[] = {
GPUBarrier::Memory(),
- 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),
+ GPUBarrier::Image(&res.scratch[0], ResourceState::UNORDERED_ACCESS, res.scratch[0].desc.layout),
+ GPUBarrier::Image(&res.scratch[1], res.scratch[0].desc.layout, ResourceState::UNORDERED_ACCESS),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
@@ -9194,8 +9180,8 @@ void Postprocess_RTAO(
device->PushConstants(&postprocess, sizeof(postprocess), cmd);
device->Dispatch(
- (desc.Width + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
- (desc.Height + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
+ (desc.width + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
+ (desc.height + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
1,
cmd
);
@@ -9204,8 +9190,8 @@ void Postprocess_RTAO(
{
GPUBarrier barriers[] = {
GPUBarrier::Memory(),
- GPUBarrier::Image(&res.scratch[1], RESOURCE_STATE_UNORDERED_ACCESS, res.scratch[1].desc.layout),
- GPUBarrier::Image(&output, RESOURCE_STATE_UNORDERED_ACCESS, output.desc.layout),
+ GPUBarrier::Image(&res.scratch[1], ResourceState::UNORDERED_ACCESS, res.scratch[1].desc.layout),
+ GPUBarrier::Image(&output, ResourceState::UNORDERED_ACCESS, output.desc.layout),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
@@ -9220,18 +9206,18 @@ void Postprocess_RTAO(
void CreateRTReflectionResources(RTReflectionResources& res, XMUINT2 resolution)
{
TextureDesc desc;
- desc.Width = resolution.x / 2;
- desc.Height = resolution.y / 2;
- desc.BindFlags = BIND_SHADER_RESOURCE | BIND_UNORDERED_ACCESS;
- desc.layout = RESOURCE_STATE_SHADER_RESOURCE_COMPUTE;
+ desc.width = resolution.x / 2;
+ desc.height = resolution.y / 2;
+ desc.bind_flags = BindFlag::SHADER_RESOURCE | BindFlag::UNORDERED_ACCESS;
+ desc.layout = ResourceState::SHADER_RESOURCE_COMPUTE;
- desc.Format = FORMAT_R11G11B10_FLOAT;
+ desc.format = Format::R11G11B10_FLOAT;
device->CreateTexture(&desc, nullptr, &res.temporal[0]);
device->SetName(&res.temporal[0], "rtreflection_temporal[0]");
device->CreateTexture(&desc, nullptr, &res.temporal[1]);
device->SetName(&res.temporal[1], "rtreflection_temporal[1]");
- desc.Format = FORMAT_R16_FLOAT;
+ desc.format = Format::R16_FLOAT;
device->CreateTexture(&desc, nullptr, &res.rayLengths);
device->SetName(&res.rayLengths, "rtreflection_rayLengths");
}
@@ -9243,7 +9229,7 @@ void Postprocess_RTReflection(
float range
)
{
- if (!device->CheckCapability(GRAPHICSDEVICE_CAPABILITY_RAYTRACING))
+ if (!device->CheckCapability(GraphicsDeviceCapability::RAYTRACING))
return;
if (!scene.TLAS.IsValid() && !scene.BVH.IsValid())
@@ -9259,8 +9245,8 @@ void Postprocess_RTReflection(
BindCommonResources(cmd);
PostProcess postprocess;
- postprocess.resolution.x = desc.Width;
- postprocess.resolution.y = desc.Height;
+ postprocess.resolution.x = desc.width;
+ postprocess.resolution.y = desc.height;
postprocess.resolution_rcp.x = 1.0f / postprocess.resolution.x;
postprocess.resolution_rcp.y = 1.0f / postprocess.resolution.y;
rtreflection_range = range;
@@ -9276,22 +9262,22 @@ void Postprocess_RTReflection(
device->WriteShaderIdentifier(&RTPSO_reflection, 2, shadertable_hitgroup.data);
DispatchRaysDesc dispatchraysdesc;
- dispatchraysdesc.raygeneration.buffer = &shadertable_raygen.buffer;
- dispatchraysdesc.raygeneration.offset = shadertable_raygen.offset;
- dispatchraysdesc.raygeneration.size = shaderIdentifierSize;
+ dispatchraysdesc.ray_generation.buffer = &shadertable_raygen.buffer;
+ dispatchraysdesc.ray_generation.offset = shadertable_raygen.offset;
+ dispatchraysdesc.ray_generation.size = shaderIdentifierSize;
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.offset = shadertable_hitgroup.offset;
- dispatchraysdesc.hitgroup.size = shaderIdentifierSize;
- dispatchraysdesc.hitgroup.stride = shaderIdentifierSize;
+ dispatchraysdesc.hit_group.buffer = &shadertable_hitgroup.buffer;
+ dispatchraysdesc.hit_group.offset = shadertable_hitgroup.offset;
+ dispatchraysdesc.hit_group.size = shaderIdentifierSize;
+ dispatchraysdesc.hit_group.stride = shaderIdentifierSize;
- dispatchraysdesc.Width = desc.Width;
- dispatchraysdesc.Height = desc.Height;
+ dispatchraysdesc.width = desc.width;
+ dispatchraysdesc.height = desc.height;
const GPUResource* uavs[] = {
&output,
@@ -9301,8 +9287,8 @@ void Postprocess_RTReflection(
{
GPUBarrier barriers[] = {
- GPUBarrier::Image(&output, output.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS),
- GPUBarrier::Image(&res.rayLengths, res.rayLengths.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS),
+ GPUBarrier::Image(&output, output.desc.layout, ResourceState::UNORDERED_ACCESS),
+ GPUBarrier::Image(&res.rayLengths, res.rayLengths.desc.layout, ResourceState::UNORDERED_ACCESS),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
@@ -9312,8 +9298,8 @@ void Postprocess_RTReflection(
{
GPUBarrier barriers[] = {
GPUBarrier::Memory(),
- GPUBarrier::Image(&output, RESOURCE_STATE_UNORDERED_ACCESS, output.desc.layout),
- GPUBarrier::Image(&res.rayLengths, RESOURCE_STATE_UNORDERED_ACCESS, res.rayLengths.desc.layout),
+ GPUBarrier::Image(&output, ResourceState::UNORDERED_ACCESS, output.desc.layout),
+ GPUBarrier::Image(&res.rayLengths, ResourceState::UNORDERED_ACCESS, res.rayLengths.desc.layout),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
@@ -9339,14 +9325,14 @@ void Postprocess_RTReflection(
{
GPUBarrier barriers[] = {
- GPUBarrier::Image(&res.temporal[temporal_output], res.temporal[temporal_output].desc.layout, RESOURCE_STATE_UNORDERED_ACCESS),
+ GPUBarrier::Image(&res.temporal[temporal_output], res.temporal[temporal_output].desc.layout, ResourceState::UNORDERED_ACCESS),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
device->Dispatch(
- (desc.Width + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
- (desc.Height + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
+ (desc.width + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
+ (desc.height + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
1,
cmd
);
@@ -9354,7 +9340,7 @@ void Postprocess_RTReflection(
{
GPUBarrier barriers[] = {
GPUBarrier::Memory(),
- GPUBarrier::Image(&res.temporal[temporal_output], RESOURCE_STATE_UNORDERED_ACCESS, res.temporal[temporal_output].desc.layout),
+ GPUBarrier::Image(&res.temporal[temporal_output], ResourceState::UNORDERED_ACCESS, res.temporal[temporal_output].desc.layout),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
@@ -9376,14 +9362,14 @@ void Postprocess_RTReflection(
{
GPUBarrier barriers[] = {
- GPUBarrier::Image(&output, output.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS),
+ GPUBarrier::Image(&output, output.desc.layout, ResourceState::UNORDERED_ACCESS),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
device->Dispatch(
- (output.desc.Width + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
- (output.desc.Height + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
+ (output.desc.width + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
+ (output.desc.height + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
1,
cmd
);
@@ -9391,7 +9377,7 @@ void Postprocess_RTReflection(
{
GPUBarrier barriers[] = {
GPUBarrier::Memory(),
- GPUBarrier::Image(&output, RESOURCE_STATE_UNORDERED_ACCESS, output.desc.layout),
+ GPUBarrier::Image(&output, ResourceState::UNORDERED_ACCESS, output.desc.layout),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
@@ -9405,17 +9391,17 @@ void Postprocess_RTReflection(
void CreateSSRResources(SSRResources& res, XMUINT2 resolution)
{
TextureDesc desc;
- desc.type = TextureDesc::TEXTURE_2D;
- desc.Width = resolution.x / 2;
- desc.Height = resolution.y / 2;
- desc.Format = FORMAT_R16G16B16A16_FLOAT;
- desc.BindFlags = BIND_SHADER_RESOURCE | BIND_UNORDERED_ACCESS;
- desc.layout = RESOURCE_STATE_SHADER_RESOURCE_COMPUTE;
+ desc.type = TextureDesc::Type::TEXTURE_2D;
+ desc.width = resolution.x / 2;
+ desc.height = resolution.y / 2;
+ desc.format = Format::R16G16B16A16_FLOAT;
+ desc.bind_flags = BindFlag::SHADER_RESOURCE | BindFlag::UNORDERED_ACCESS;
+ desc.layout = ResourceState::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]);
- desc.Format = FORMAT_R16_FLOAT;
+ desc.format = Format::R16_FLOAT;
device->CreateTexture(&desc, nullptr, &res.rayLengths);
device->SetName(&res.rayLengths, "ssr_rayLengths");
}
@@ -9436,12 +9422,12 @@ void Postprocess_SSR(
const TextureDesc& desc = output.GetDesc();
PostProcess postprocess;
- postprocess.resolution.x = desc.Width;
- postprocess.resolution.y = desc.Height;
+ postprocess.resolution.x = desc.width;
+ postprocess.resolution.y = desc.height;
postprocess.resolution_rcp.x = 1.0f / postprocess.resolution.x;
postprocess.resolution_rcp.y = 1.0f / postprocess.resolution.y;
- ssr_input_maxmip = float(input_desc.MipLevels - 1);
- ssr_input_resolution_max = (float)std::max(input_desc.Width, input_desc.Height);
+ ssr_input_maxmip = float(input_desc.mip_levels - 1);
+ ssr_input_resolution_max = (float)std::max(input_desc.width, input_desc.height);
device->PushConstants(&postprocess, sizeof(postprocess), cmd);
// Raytrace pass:
@@ -9459,14 +9445,14 @@ void Postprocess_SSR(
{
GPUBarrier barriers[] = {
- GPUBarrier::Image(&res.texture_raytrace, res.texture_raytrace.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS),
+ GPUBarrier::Image(&res.texture_raytrace, res.texture_raytrace.desc.layout, ResourceState::UNORDERED_ACCESS),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
device->Dispatch(
- (desc.Width + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
- (desc.Height + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
+ (desc.width + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
+ (desc.height + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
1,
cmd
);
@@ -9474,7 +9460,7 @@ void Postprocess_SSR(
{
GPUBarrier barriers[] = {
GPUBarrier::Memory(),
- GPUBarrier::Image(&res.texture_raytrace, RESOURCE_STATE_UNORDERED_ACCESS, res.texture_raytrace.desc.layout),
+ GPUBarrier::Image(&res.texture_raytrace, ResourceState::UNORDERED_ACCESS, res.texture_raytrace.desc.layout),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
@@ -9497,14 +9483,14 @@ void Postprocess_SSR(
{
GPUBarrier barriers[] = {
- GPUBarrier::Image(&output, output.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS),
+ GPUBarrier::Image(&output, output.desc.layout, ResourceState::UNORDERED_ACCESS),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
device->Dispatch(
- (desc.Width + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
- (desc.Height + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
+ (desc.width + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
+ (desc.height + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
1,
cmd
);
@@ -9512,7 +9498,7 @@ void Postprocess_SSR(
{
GPUBarrier barriers[] = {
GPUBarrier::Memory(),
- GPUBarrier::Image(&output, RESOURCE_STATE_UNORDERED_ACCESS, output.desc.layout),
+ GPUBarrier::Image(&output, ResourceState::UNORDERED_ACCESS, output.desc.layout),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
@@ -9539,14 +9525,14 @@ void Postprocess_SSR(
{
GPUBarrier barriers[] = {
- GPUBarrier::Image(&res.texture_temporal[temporal_output], res.texture_temporal[temporal_output].desc.layout, RESOURCE_STATE_UNORDERED_ACCESS),
+ GPUBarrier::Image(&res.texture_temporal[temporal_output], res.texture_temporal[temporal_output].desc.layout, ResourceState::UNORDERED_ACCESS),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
device->Dispatch(
- (desc.Width + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
- (desc.Height + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
+ (desc.width + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
+ (desc.height + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
1,
cmd
);
@@ -9554,7 +9540,7 @@ void Postprocess_SSR(
{
GPUBarrier barriers[] = {
GPUBarrier::Memory(),
- GPUBarrier::Image(&res.texture_temporal[temporal_output], RESOURCE_STATE_UNORDERED_ACCESS, res.texture_temporal[temporal_output].desc.layout),
+ GPUBarrier::Image(&res.texture_temporal[temporal_output], ResourceState::UNORDERED_ACCESS, res.texture_temporal[temporal_output].desc.layout),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
@@ -9576,14 +9562,14 @@ void Postprocess_SSR(
{
GPUBarrier barriers[] = {
- GPUBarrier::Image(&output, output.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS),
+ GPUBarrier::Image(&output, output.desc.layout, ResourceState::UNORDERED_ACCESS),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
device->Dispatch(
- (desc.Width + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
- (desc.Height + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
+ (desc.width + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
+ (desc.height + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
1,
cmd
);
@@ -9591,7 +9577,7 @@ void Postprocess_SSR(
{
GPUBarrier barriers[] = {
GPUBarrier::Memory(),
- GPUBarrier::Image(&output, RESOURCE_STATE_UNORDERED_ACCESS, output.desc.layout),
+ GPUBarrier::Image(&output, ResourceState::UNORDERED_ACCESS, output.desc.layout),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
@@ -9605,12 +9591,12 @@ void Postprocess_SSR(
void CreateRTShadowResources(RTShadowResources& res, XMUINT2 resolution)
{
TextureDesc desc;
- desc.Width = resolution.x / 2;
- desc.Height = resolution.y / 2;
- desc.BindFlags = BIND_SHADER_RESOURCE | BIND_UNORDERED_ACCESS;
- desc.layout = RESOURCE_STATE_SHADER_RESOURCE_COMPUTE;
+ desc.width = resolution.x / 2;
+ desc.height = resolution.y / 2;
+ desc.bind_flags = BindFlag::SHADER_RESOURCE | BindFlag::UNORDERED_ACCESS;
+ desc.layout = ResourceState::SHADER_RESOURCE_COMPUTE;
- desc.Format = FORMAT_R32G32B32A32_UINT;
+ desc.format = Format::R32G32B32A32_UINT;
device->CreateTexture(&desc, nullptr, &res.temp);
device->SetName(&res.temp, "rtshadow_temp");
device->CreateTexture(&desc, nullptr, &res.temporal[0]);
@@ -9618,17 +9604,17 @@ void CreateRTShadowResources(RTShadowResources& res, XMUINT2 resolution)
device->CreateTexture(&desc, nullptr, &res.temporal[1]);
device->SetName(&res.temporal[1], "rtshadow_temporal[1]");
- desc.Format = FORMAT_R11G11B10_FLOAT;
+ desc.format = Format::R11G11B10_FLOAT;
device->CreateTexture(&desc, nullptr, &res.normals);
device->SetName(&res.normals, "rtshadow_normals");
GPUBufferDesc bd;
- bd.Stride = sizeof(uint4);
- bd.Size = bd.Stride *
- ((desc.Width + 7) / 8) *
- ((desc.Height + 3) / 4);
- bd.MiscFlags = RESOURCE_MISC_BUFFER_STRUCTURED;
- bd.BindFlags = BIND_SHADER_RESOURCE | BIND_UNORDERED_ACCESS;
+ bd.stride = sizeof(uint4);
+ bd.size = bd.stride *
+ ((desc.width + 7) / 8) *
+ ((desc.height + 3) / 4);
+ bd.misc_flags = ResourceMiscFlag::BUFFER_STRUCTURED;
+ bd.bind_flags = BindFlag::SHADER_RESOURCE | BindFlag::UNORDERED_ACCESS;
device->CreateBuffer(&bd, nullptr, &res.tiles);
device->SetName(&res.tiles, "rtshadow_tiles");
device->CreateBuffer(&bd, nullptr, &res.metadata);
@@ -9636,20 +9622,20 @@ void CreateRTShadowResources(RTShadowResources& res, XMUINT2 resolution)
for (int i = 0; i < 4; ++i)
{
- desc.Format = FORMAT_R16G16_FLOAT;
+ desc.format = Format::R16G16_FLOAT;
device->CreateTexture(&desc, nullptr, &res.scratch[i][0]);
device->SetName(&res.scratch[i][0], "rtshadow_scratch[i][0]");
device->CreateTexture(&desc, nullptr, &res.scratch[i][1]);
device->SetName(&res.scratch[i][1], "rtshadow_scratch[i][1]");
- desc.Format = FORMAT_R11G11B10_FLOAT;
+ desc.format = Format::R11G11B10_FLOAT;
device->CreateTexture(&desc, nullptr, &res.moments[i][0]);
device->SetName(&res.moments[i][0], "rtshadow_moments[i][0]");
device->CreateTexture(&desc, nullptr, &res.moments[i][1]);
device->SetName(&res.moments[i][1], "rtshadow_moments[i][1]");
}
- desc.Format = FORMAT_R8G8B8A8_UNORM;
+ desc.format = Format::R8G8B8A8_UNORM;
device->CreateTexture(&desc, nullptr, &res.denoised);
device->SetName(&res.denoised, "rtshadow_denoised");
}
@@ -9661,7 +9647,7 @@ void Postprocess_RTShadow(
CommandList cmd
)
{
- if (!device->CheckCapability(GRAPHICSDEVICE_CAPABILITY_RAYTRACING))
+ if (!device->CheckCapability(GraphicsDeviceCapability::RAYTRACING))
return;
if (!scene.TLAS.IsValid() && !scene.BVH.IsValid())
@@ -9677,8 +9663,8 @@ void Postprocess_RTShadow(
device->EventBegin("Raytrace", cmd);
PostProcess postprocess;
- postprocess.resolution.x = desc.Width;
- postprocess.resolution.y = desc.Height;
+ postprocess.resolution.x = desc.width;
+ postprocess.resolution.y = desc.height;
postprocess.resolution_rcp.x = 1.0f / postprocess.resolution.x;
postprocess.resolution_rcp.y = 1.0f / postprocess.resolution.y;
postprocess.params0.w = (float)res.frame;
@@ -9695,16 +9681,16 @@ void Postprocess_RTShadow(
{
GPUBarrier barriers[] = {
- 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),
+ GPUBarrier::Image(&res.temp, res.temp.desc.layout, ResourceState::UNORDERED_ACCESS),
+ GPUBarrier::Image(&res.normals, res.normals.desc.layout, ResourceState::UNORDERED_ACCESS),
+ GPUBarrier::Buffer(&res.tiles, ResourceState::SHADER_RESOURCE_COMPUTE, ResourceState::UNORDERED_ACCESS),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
device->Dispatch(
- (desc.Width + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
- (desc.Height + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
+ (desc.width + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
+ (desc.height + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
1,
cmd
);
@@ -9712,8 +9698,8 @@ void Postprocess_RTShadow(
{
GPUBarrier barriers[] = {
GPUBarrier::Memory(),
- 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),
+ GPUBarrier::Image(&res.normals, ResourceState::UNORDERED_ACCESS, res.normals.desc.layout),
+ GPUBarrier::Buffer(&res.tiles, ResourceState::UNORDERED_ACCESS, ResourceState::SHADER_RESOURCE_COMPUTE),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
@@ -9754,22 +9740,22 @@ void Postprocess_RTShadow(
{
GPUBarrier barriers[] = {
- 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),
+ GPUBarrier::Buffer(&res.metadata, ResourceState::SHADER_RESOURCE_COMPUTE, ResourceState::UNORDERED_ACCESS),
+ GPUBarrier::Image(&res.scratch[0][0], res.scratch[0][0].desc.layout, ResourceState::UNORDERED_ACCESS),
+ GPUBarrier::Image(&res.scratch[1][0], res.scratch[1][0].desc.layout, ResourceState::UNORDERED_ACCESS),
+ GPUBarrier::Image(&res.scratch[2][0], res.scratch[2][0].desc.layout, ResourceState::UNORDERED_ACCESS),
+ GPUBarrier::Image(&res.scratch[3][0], res.scratch[3][0].desc.layout, ResourceState::UNORDERED_ACCESS),
+ GPUBarrier::Image(&res.moments[0][temporal_output], res.moments[0][temporal_output].desc.layout, ResourceState::UNORDERED_ACCESS),
+ GPUBarrier::Image(&res.moments[1][temporal_output], res.moments[1][temporal_output].desc.layout, ResourceState::UNORDERED_ACCESS),
+ GPUBarrier::Image(&res.moments[2][temporal_output], res.moments[2][temporal_output].desc.layout, ResourceState::UNORDERED_ACCESS),
+ GPUBarrier::Image(&res.moments[3][temporal_output], res.moments[3][temporal_output].desc.layout, ResourceState::UNORDERED_ACCESS),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
device->Dispatch(
- (desc.Width + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
- (desc.Height + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
+ (desc.width + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
+ (desc.height + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
4, // 4 lights
cmd
);
@@ -9777,15 +9763,15 @@ void Postprocess_RTShadow(
{
GPUBarrier barriers[] = {
GPUBarrier::Memory(),
- 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),
+ GPUBarrier::Buffer(&res.metadata, ResourceState::UNORDERED_ACCESS, ResourceState::SHADER_RESOURCE_COMPUTE),
+ GPUBarrier::Image(&res.scratch[0][0], ResourceState::UNORDERED_ACCESS, res.scratch[0][0].desc.layout),
+ GPUBarrier::Image(&res.scratch[1][0], ResourceState::UNORDERED_ACCESS, res.scratch[1][0].desc.layout),
+ GPUBarrier::Image(&res.scratch[2][0], ResourceState::UNORDERED_ACCESS, res.scratch[2][0].desc.layout),
+ GPUBarrier::Image(&res.scratch[3][0], ResourceState::UNORDERED_ACCESS, res.scratch[3][0].desc.layout),
+ GPUBarrier::Image(&res.moments[0][temporal_output], ResourceState::UNORDERED_ACCESS, res.moments[0][temporal_output].desc.layout),
+ GPUBarrier::Image(&res.moments[1][temporal_output], ResourceState::UNORDERED_ACCESS, res.moments[1][temporal_output].desc.layout),
+ GPUBarrier::Image(&res.moments[2][temporal_output], ResourceState::UNORDERED_ACCESS, res.moments[2][temporal_output].desc.layout),
+ GPUBarrier::Image(&res.moments[3][temporal_output], ResourceState::UNORDERED_ACCESS, res.moments[3][temporal_output].desc.layout),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
@@ -9817,11 +9803,11 @@ void Postprocess_RTShadow(
device->BindUAVs(uavs, 0, arraysize(uavs), cmd);
{
GPUBarrier barriers[] = {
- 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),
+ GPUBarrier::Image(&res.scratch[0][1], res.scratch[0][1].desc.layout, ResourceState::UNORDERED_ACCESS),
+ GPUBarrier::Image(&res.scratch[1][1], res.scratch[1][1].desc.layout, ResourceState::UNORDERED_ACCESS),
+ GPUBarrier::Image(&res.scratch[2][1], res.scratch[2][1].desc.layout, ResourceState::UNORDERED_ACCESS),
+ GPUBarrier::Image(&res.scratch[3][1], res.scratch[3][1].desc.layout, ResourceState::UNORDERED_ACCESS),
+ GPUBarrier::Image(&res.denoised, res.denoised.desc.layout, ResourceState::UNORDERED_ACCESS),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
@@ -9831,8 +9817,8 @@ void Postprocess_RTShadow(
device->PushConstants(&postprocess, sizeof(postprocess), cmd);
device->Dispatch(
- (desc.Width + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
- (desc.Height + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
+ (desc.width + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
+ (desc.height + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
4, // 4 lights
cmd
);
@@ -9855,14 +9841,14 @@ void Postprocess_RTShadow(
{
GPUBarrier barriers[] = {
GPUBarrier::Memory(),
- 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),
+ GPUBarrier::Image(&res.scratch[0][1], ResourceState::UNORDERED_ACCESS, res.scratch[0][1].desc.layout),
+ GPUBarrier::Image(&res.scratch[1][1], ResourceState::UNORDERED_ACCESS, res.scratch[1][1].desc.layout),
+ GPUBarrier::Image(&res.scratch[2][1], ResourceState::UNORDERED_ACCESS, res.scratch[2][1].desc.layout),
+ GPUBarrier::Image(&res.scratch[3][1], ResourceState::UNORDERED_ACCESS, res.scratch[3][1].desc.layout),
+ GPUBarrier::Image(&res.scratch[0][0], res.scratch[0][0].desc.layout, ResourceState::UNORDERED_ACCESS),
+ GPUBarrier::Image(&res.scratch[1][0], res.scratch[1][0].desc.layout, ResourceState::UNORDERED_ACCESS),
+ GPUBarrier::Image(&res.scratch[2][0], res.scratch[2][0].desc.layout, ResourceState::UNORDERED_ACCESS),
+ GPUBarrier::Image(&res.scratch[3][0], res.scratch[3][0].desc.layout, ResourceState::UNORDERED_ACCESS),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
@@ -9872,8 +9858,8 @@ void Postprocess_RTShadow(
device->PushConstants(&postprocess, sizeof(postprocess), cmd);
device->Dispatch(
- (desc.Width + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
- (desc.Height + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
+ (desc.width + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
+ (desc.height + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
4, // 4 lights
cmd
);
@@ -9896,14 +9882,14 @@ void Postprocess_RTShadow(
{
GPUBarrier barriers[] = {
GPUBarrier::Memory(),
- 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),
+ GPUBarrier::Image(&res.scratch[0][0], ResourceState::UNORDERED_ACCESS, res.scratch[0][0].desc.layout),
+ GPUBarrier::Image(&res.scratch[1][0], ResourceState::UNORDERED_ACCESS, res.scratch[1][0].desc.layout),
+ GPUBarrier::Image(&res.scratch[2][0], ResourceState::UNORDERED_ACCESS, res.scratch[2][0].desc.layout),
+ GPUBarrier::Image(&res.scratch[3][0], ResourceState::UNORDERED_ACCESS, res.scratch[3][0].desc.layout),
+ GPUBarrier::Image(&res.scratch[0][1], res.scratch[0][0].desc.layout, ResourceState::UNORDERED_ACCESS),
+ GPUBarrier::Image(&res.scratch[1][1], res.scratch[1][0].desc.layout, ResourceState::UNORDERED_ACCESS),
+ GPUBarrier::Image(&res.scratch[2][1], res.scratch[2][0].desc.layout, ResourceState::UNORDERED_ACCESS),
+ GPUBarrier::Image(&res.scratch[3][1], res.scratch[3][0].desc.layout, ResourceState::UNORDERED_ACCESS),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
@@ -9913,8 +9899,8 @@ void Postprocess_RTShadow(
device->PushConstants(&postprocess, sizeof(postprocess), cmd);
device->Dispatch(
- (desc.Width + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
- (desc.Height + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
+ (desc.width + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
+ (desc.height + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
4, // 4 lights
cmd
);
@@ -9923,11 +9909,11 @@ void Postprocess_RTShadow(
{
GPUBarrier barriers[] = {
GPUBarrier::Memory(),
- 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),
+ GPUBarrier::Image(&res.scratch[0][1], ResourceState::UNORDERED_ACCESS, res.scratch[0][1].desc.layout),
+ GPUBarrier::Image(&res.scratch[1][1], ResourceState::UNORDERED_ACCESS, res.scratch[1][1].desc.layout),
+ GPUBarrier::Image(&res.scratch[2][1], ResourceState::UNORDERED_ACCESS, res.scratch[2][1].desc.layout),
+ GPUBarrier::Image(&res.scratch[3][1], ResourceState::UNORDERED_ACCESS, res.scratch[3][1].desc.layout),
+ GPUBarrier::Image(&res.denoised, ResourceState::UNORDERED_ACCESS, res.denoised.desc.layout),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
@@ -9953,16 +9939,16 @@ void Postprocess_RTShadow(
{
GPUBarrier barriers[] = {
- 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),
+ GPUBarrier::Image(&res.temp, ResourceState::UNORDERED_ACCESS, res.temp.desc.layout),
+ GPUBarrier::Image(&res.temporal[temporal_output], res.temporal[temporal_output].desc.layout, ResourceState::UNORDERED_ACCESS),
+ GPUBarrier::Image(&output, output.desc.layout, ResourceState::UNORDERED_ACCESS),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
device->Dispatch(
- (desc.Width + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
- (desc.Height + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
+ (desc.width + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
+ (desc.height + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
1,
cmd
);
@@ -9970,8 +9956,8 @@ void Postprocess_RTShadow(
{
GPUBarrier barriers[] = {
GPUBarrier::Memory(),
- 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),
+ GPUBarrier::Image(&res.temporal[temporal_output], ResourceState::UNORDERED_ACCESS, res.temporal[temporal_output].desc.layout),
+ GPUBarrier::Image(&output, ResourceState::UNORDERED_ACCESS, output.desc.layout),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
@@ -10000,8 +9986,8 @@ void Postprocess_ScreenSpaceShadow(
const TextureDesc& desc = output.GetDesc();
PostProcess postprocess;
- postprocess.resolution.x = desc.Width;
- postprocess.resolution.y = desc.Height;
+ postprocess.resolution.x = desc.width;
+ postprocess.resolution.y = desc.height;
postprocess.resolution_rcp.x = 1.0f / postprocess.resolution.x;
postprocess.resolution_rcp.y = 1.0f / postprocess.resolution.y;
postprocess.params0.x = range;
@@ -10017,14 +10003,14 @@ void Postprocess_ScreenSpaceShadow(
{
GPUBarrier barriers[] = {
- GPUBarrier::Image(&output, output.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS),
+ GPUBarrier::Image(&output, output.desc.layout, ResourceState::UNORDERED_ACCESS),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
device->Dispatch(
- (desc.Width + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
- (desc.Height + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
+ (desc.width + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
+ (desc.height + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
1,
cmd
);
@@ -10032,7 +10018,7 @@ void Postprocess_ScreenSpaceShadow(
{
GPUBarrier barriers[] = {
GPUBarrier::Memory(),
- GPUBarrier::Image(&output, RESOURCE_STATE_UNORDERED_ACCESS, output.desc.layout),
+ GPUBarrier::Image(&output, ResourceState::UNORDERED_ACCESS, output.desc.layout),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
@@ -10058,8 +10044,8 @@ void Postprocess_LightShafts(
const TextureDesc& desc = output.GetDesc();
PostProcess postprocess;
- postprocess.resolution.x = desc.Width;
- postprocess.resolution.y = desc.Height;
+ postprocess.resolution.x = desc.width;
+ postprocess.resolution.y = desc.height;
postprocess.resolution_rcp.x = 1.0f / postprocess.resolution.x;
postprocess.resolution_rcp.y = 1.0f / postprocess.resolution.y;
postprocess.params0.x = 0.65f; // density
@@ -10077,14 +10063,14 @@ void Postprocess_LightShafts(
{
GPUBarrier barriers[] = {
- GPUBarrier::Image(&output, output.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS),
+ GPUBarrier::Image(&output, output.desc.layout, ResourceState::UNORDERED_ACCESS),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
device->Dispatch(
- (desc.Width + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
- (desc.Height + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
+ (desc.width + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
+ (desc.height + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
1,
cmd
);
@@ -10092,7 +10078,7 @@ void Postprocess_LightShafts(
{
GPUBarrier barriers[] = {
GPUBarrier::Memory(),
- GPUBarrier::Image(&output, RESOURCE_STATE_UNORDERED_ACCESS, output.desc.layout),
+ GPUBarrier::Image(&output, ResourceState::UNORDERED_ACCESS, output.desc.layout),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
@@ -10104,47 +10090,47 @@ void Postprocess_LightShafts(
void CreateDepthOfFieldResources(DepthOfFieldResources& res, XMUINT2 resolution)
{
TextureDesc tile_desc;
- tile_desc.type = TextureDesc::TEXTURE_2D;
- tile_desc.Width = (resolution.x + DEPTHOFFIELD_TILESIZE - 1) / DEPTHOFFIELD_TILESIZE;
- tile_desc.Height = (resolution.y + DEPTHOFFIELD_TILESIZE - 1) / DEPTHOFFIELD_TILESIZE;
- tile_desc.Format = FORMAT_R16G16_FLOAT;
- tile_desc.BindFlags = BIND_SHADER_RESOURCE | BIND_UNORDERED_ACCESS;
+ tile_desc.type = TextureDesc::Type::TEXTURE_2D;
+ tile_desc.width = (resolution.x + DEPTHOFFIELD_TILESIZE - 1) / DEPTHOFFIELD_TILESIZE;
+ tile_desc.height = (resolution.y + DEPTHOFFIELD_TILESIZE - 1) / DEPTHOFFIELD_TILESIZE;
+ tile_desc.format = Format::R16G16_FLOAT;
+ tile_desc.bind_flags = BindFlag::SHADER_RESOURCE | BindFlag::UNORDERED_ACCESS;
device->CreateTexture(&tile_desc, nullptr, &res.texture_tilemax);
device->CreateTexture(&tile_desc, nullptr, &res.texture_neighborhoodmax);
- tile_desc.Format = FORMAT_R16_FLOAT;
+ tile_desc.format = Format::R16_FLOAT;
device->CreateTexture(&tile_desc, nullptr, &res.texture_tilemin);
- tile_desc.Height = resolution.x;
- tile_desc.Format = FORMAT_R16G16_FLOAT;
+ tile_desc.height = resolution.x;
+ tile_desc.format = Format::R16G16_FLOAT;
device->CreateTexture(&tile_desc, nullptr, &res.texture_tilemax_horizontal);
- tile_desc.Format = FORMAT_R16_FLOAT;
+ tile_desc.format = Format::R16_FLOAT;
device->CreateTexture(&tile_desc, nullptr, &res.texture_tilemin_horizontal);
TextureDesc presort_desc;
- presort_desc.type = TextureDesc::TEXTURE_2D;
- presort_desc.Width = resolution.x / 2;
- presort_desc.Height = resolution.y / 2;
- presort_desc.Format = FORMAT_R11G11B10_FLOAT;
- presort_desc.BindFlags = BIND_SHADER_RESOURCE | BIND_UNORDERED_ACCESS;
+ presort_desc.type = TextureDesc::Type::TEXTURE_2D;
+ presort_desc.width = resolution.x / 2;
+ presort_desc.height = resolution.y / 2;
+ presort_desc.format = Format::R11G11B10_FLOAT;
+ presort_desc.bind_flags = BindFlag::SHADER_RESOURCE | BindFlag::UNORDERED_ACCESS;
device->CreateTexture(&presort_desc, nullptr, &res.texture_presort);
device->CreateTexture(&presort_desc, nullptr, &res.texture_prefilter);
device->CreateTexture(&presort_desc, nullptr, &res.texture_main);
device->CreateTexture(&presort_desc, nullptr, &res.texture_postfilter);
- presort_desc.Format = FORMAT_R8_UNORM;
+ presort_desc.format = Format::R8_UNORM;
device->CreateTexture(&presort_desc, nullptr, &res.texture_alpha1);
device->CreateTexture(&presort_desc, nullptr, &res.texture_alpha2);
GPUBufferDesc bufferdesc;
- bufferdesc.BindFlags = BIND_SHADER_RESOURCE | BIND_UNORDERED_ACCESS;
+ bufferdesc.bind_flags = BindFlag::SHADER_RESOURCE | BindFlag::UNORDERED_ACCESS;
- bufferdesc.Size = TILE_STATISTICS_CAPACITY * sizeof(uint);
- bufferdesc.MiscFlags = RESOURCE_MISC_BUFFER_RAW | RESOURCE_MISC_INDIRECT_ARGS;
+ bufferdesc.size = TILE_STATISTICS_CAPACITY * sizeof(uint);
+ bufferdesc.misc_flags = ResourceMiscFlag::BUFFER_RAW | ResourceMiscFlag::INDIRECT_ARGS;
device->CreateBuffer(&bufferdesc, nullptr, &res.buffer_tile_statistics);
- bufferdesc.MiscFlags = RESOURCE_MISC_BUFFER_STRUCTURED;
- bufferdesc.Stride = sizeof(uint);
- bufferdesc.Size = tile_desc.Width * tile_desc.Height * bufferdesc.Stride;
+ bufferdesc.misc_flags = ResourceMiscFlag::BUFFER_STRUCTURED;
+ bufferdesc.stride = sizeof(uint);
+ bufferdesc.size = tile_desc.width * tile_desc.height * bufferdesc.stride;
device->CreateBuffer(&bufferdesc, nullptr, &res.buffer_tiles_earlyexit);
device->CreateBuffer(&bufferdesc, nullptr, &res.buffer_tiles_cheap);
device->CreateBuffer(&bufferdesc, nullptr, &res.buffer_tiles_expensive);
@@ -10164,8 +10150,8 @@ void Postprocess_DepthOfField(
const TextureDesc& desc = output.GetDesc();
PostProcess postprocess;
- postprocess.resolution.x = desc.Width;
- postprocess.resolution.y = desc.Height;
+ postprocess.resolution.x = desc.width;
+ postprocess.resolution.y = desc.height;
postprocess.resolution_rcp.x = 1.0f / postprocess.resolution.x;
postprocess.resolution_rcp.y = 1.0f / postprocess.resolution.y;
dof_cocscale = coc_scale;
@@ -10185,15 +10171,15 @@ void Postprocess_DepthOfField(
{
GPUBarrier barriers[] = {
- 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),
+ GPUBarrier::Image(&res.texture_tilemax_horizontal, res.texture_tilemax_horizontal.desc.layout, ResourceState::UNORDERED_ACCESS),
+ GPUBarrier::Image(&res.texture_tilemin_horizontal, res.texture_tilemin_horizontal.desc.layout, ResourceState::UNORDERED_ACCESS),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
device->Dispatch(
- (res.texture_tilemax_horizontal.GetDesc().Width + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
- (res.texture_tilemax_horizontal.GetDesc().Height + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
+ (res.texture_tilemax_horizontal.GetDesc().width + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
+ (res.texture_tilemax_horizontal.GetDesc().height + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
1,
cmd
);
@@ -10201,8 +10187,8 @@ void Postprocess_DepthOfField(
{
GPUBarrier barriers[] = {
GPUBarrier::Memory(),
- 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),
+ GPUBarrier::Image(&res.texture_tilemax_horizontal, ResourceState::UNORDERED_ACCESS, res.texture_tilemax_horizontal.desc.layout),
+ GPUBarrier::Image(&res.texture_tilemin_horizontal, ResourceState::UNORDERED_ACCESS, res.texture_tilemin_horizontal.desc.layout),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
@@ -10229,15 +10215,15 @@ void Postprocess_DepthOfField(
{
GPUBarrier barriers[] = {
- 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),
+ GPUBarrier::Image(&res.texture_tilemax, res.texture_tilemax.desc.layout, ResourceState::UNORDERED_ACCESS),
+ GPUBarrier::Image(&res.texture_tilemin, res.texture_tilemin.desc.layout, ResourceState::UNORDERED_ACCESS),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
device->Dispatch(
- (res.texture_tilemax.GetDesc().Width + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
- (res.texture_tilemax.GetDesc().Height + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
+ (res.texture_tilemax.GetDesc().width + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
+ (res.texture_tilemax.GetDesc().height + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
1,
cmd
);
@@ -10245,8 +10231,8 @@ void Postprocess_DepthOfField(
{
GPUBarrier barriers[] = {
GPUBarrier::Memory(),
- 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),
+ GPUBarrier::Image(&res.texture_tilemax, ResourceState::UNORDERED_ACCESS, res.texture_tilemax.desc.layout),
+ GPUBarrier::Image(&res.texture_tilemin, ResourceState::UNORDERED_ACCESS, res.texture_tilemin.desc.layout),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
@@ -10276,14 +10262,14 @@ void Postprocess_DepthOfField(
{
GPUBarrier barriers[] = {
- GPUBarrier::Image(&res.texture_neighborhoodmax, res.texture_neighborhoodmax.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS),
+ GPUBarrier::Image(&res.texture_neighborhoodmax, res.texture_neighborhoodmax.desc.layout, ResourceState::UNORDERED_ACCESS),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
device->Dispatch(
- (res.texture_neighborhoodmax.GetDesc().Width + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
- (res.texture_neighborhoodmax.GetDesc().Height + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
+ (res.texture_neighborhoodmax.GetDesc().width + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
+ (res.texture_neighborhoodmax.GetDesc().height + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
1,
cmd
);
@@ -10291,7 +10277,7 @@ void Postprocess_DepthOfField(
{
GPUBarrier barriers[] = {
GPUBarrier::Memory(),
- GPUBarrier::Image(&res.texture_neighborhoodmax, RESOURCE_STATE_UNORDERED_ACCESS, res.texture_neighborhoodmax.desc.layout),
+ GPUBarrier::Image(&res.texture_neighborhoodmax, ResourceState::UNORDERED_ACCESS, res.texture_neighborhoodmax.desc.layout),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
@@ -10318,7 +10304,7 @@ void Postprocess_DepthOfField(
GPUBarrier barriers[] = {
GPUBarrier::Memory(),
- GPUBarrier::Buffer(&res.buffer_tile_statistics, RESOURCE_STATE_UNORDERED_ACCESS, RESOURCE_STATE_INDIRECT_ARGUMENT),
+ GPUBarrier::Buffer(&res.buffer_tile_statistics, ResourceState::UNORDERED_ACCESS, ResourceState::INDIRECT_ARGUMENT),
};
device->Barrier(barriers, arraysize(barriers), cmd);
@@ -10326,8 +10312,8 @@ void Postprocess_DepthOfField(
}
// Switch to half res:
- postprocess.resolution.x = desc.Width / 2;
- postprocess.resolution.y = desc.Height / 2;
+ postprocess.resolution.x = desc.width / 2;
+ postprocess.resolution.y = desc.height / 2;
postprocess.resolution_rcp.x = 1.0f / postprocess.resolution.x;
postprocess.resolution_rcp.y = 1.0f / postprocess.resolution.y;
device->PushConstants(&postprocess, sizeof(postprocess), cmd);
@@ -10350,11 +10336,11 @@ void Postprocess_DepthOfField(
{
GPUBarrier barriers[] = {
- 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),
+ GPUBarrier::Buffer(&res.buffer_tiles_earlyexit, ResourceState::UNORDERED_ACCESS, ResourceState::SHADER_RESOURCE),
+ GPUBarrier::Buffer(&res.buffer_tiles_cheap, ResourceState::UNORDERED_ACCESS, ResourceState::SHADER_RESOURCE),
+ GPUBarrier::Buffer(&res.buffer_tiles_expensive, ResourceState::UNORDERED_ACCESS, ResourceState::SHADER_RESOURCE),
+ GPUBarrier::Image(&res.texture_presort, res.texture_presort.desc.layout, ResourceState::UNORDERED_ACCESS),
+ GPUBarrier::Image(&res.texture_prefilter, res.texture_prefilter.desc.layout, ResourceState::UNORDERED_ACCESS),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
@@ -10374,8 +10360,8 @@ void Postprocess_DepthOfField(
{
GPUBarrier barriers[] = {
GPUBarrier::Memory(),
- 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),
+ GPUBarrier::Image(&res.texture_presort, ResourceState::UNORDERED_ACCESS, res.texture_presort.desc.layout),
+ GPUBarrier::Image(&res.texture_prefilter, ResourceState::UNORDERED_ACCESS, res.texture_prefilter.desc.layout),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
@@ -10405,8 +10391,8 @@ void Postprocess_DepthOfField(
{
GPUBarrier barriers[] = {
- 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),
+ GPUBarrier::Image(&res.texture_main, res.texture_main.desc.layout, ResourceState::UNORDERED_ACCESS),
+ GPUBarrier::Image(&res.texture_alpha1, res.texture_alpha1.desc.layout, ResourceState::UNORDERED_ACCESS),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
@@ -10423,8 +10409,8 @@ void Postprocess_DepthOfField(
{
GPUBarrier barriers[] = {
GPUBarrier::Memory(),
- 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),
+ GPUBarrier::Image(&res.texture_main, ResourceState::UNORDERED_ACCESS, res.texture_main.desc.layout),
+ GPUBarrier::Image(&res.texture_alpha1, ResourceState::UNORDERED_ACCESS, res.texture_alpha1.desc.layout),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
@@ -10451,15 +10437,15 @@ void Postprocess_DepthOfField(
{
GPUBarrier barriers[] = {
- 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),
+ GPUBarrier::Image(&res.texture_postfilter, res.texture_postfilter.desc.layout, ResourceState::UNORDERED_ACCESS),
+ GPUBarrier::Image(&res.texture_alpha2, res.texture_alpha2.desc.layout, ResourceState::UNORDERED_ACCESS),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
device->Dispatch(
- (res.texture_postfilter.GetDesc().Width + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
- (res.texture_postfilter.GetDesc().Height + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
+ (res.texture_postfilter.GetDesc().width + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
+ (res.texture_postfilter.GetDesc().height + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
1,
cmd
);
@@ -10467,8 +10453,8 @@ void Postprocess_DepthOfField(
{
GPUBarrier barriers[] = {
GPUBarrier::Memory(),
- 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),
+ GPUBarrier::Image(&res.texture_postfilter, ResourceState::UNORDERED_ACCESS, res.texture_postfilter.desc.layout),
+ GPUBarrier::Image(&res.texture_alpha2, ResourceState::UNORDERED_ACCESS, res.texture_alpha2.desc.layout),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
@@ -10477,8 +10463,8 @@ void Postprocess_DepthOfField(
}
// Switch to full res:
- postprocess.resolution.x = desc.Width;
- postprocess.resolution.y = desc.Height;
+ postprocess.resolution.x = desc.width;
+ postprocess.resolution.y = desc.height;
postprocess.resolution_rcp.x = 1.0f / postprocess.resolution.x;
postprocess.resolution_rcp.y = 1.0f / postprocess.resolution.y;
device->PushConstants(&postprocess, sizeof(postprocess), cmd);
@@ -10503,14 +10489,14 @@ void Postprocess_DepthOfField(
{
GPUBarrier barriers[] = {
- GPUBarrier::Image(&output, output.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS),
+ GPUBarrier::Image(&output, output.desc.layout, ResourceState::UNORDERED_ACCESS),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
device->Dispatch(
- (desc.Width + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
- (desc.Height + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
+ (desc.width + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
+ (desc.height + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
1,
cmd
);
@@ -10518,7 +10504,7 @@ void Postprocess_DepthOfField(
{
GPUBarrier barriers[] = {
GPUBarrier::Memory(),
- GPUBarrier::Image(&output, RESOURCE_STATE_UNORDERED_ACCESS, output.desc.layout),
+ GPUBarrier::Image(&output, ResourceState::UNORDERED_ACCESS, output.desc.layout),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
@@ -10545,8 +10531,8 @@ void Postprocess_Outline(
device->BindResource(&input, TEXSLOT_ONDEMAND0, cmd);
PostProcess postprocess;
- postprocess.resolution.x = (uint)input.GetDesc().Width;
- postprocess.resolution.y = (uint)input.GetDesc().Height;
+ postprocess.resolution.x = (uint)input.GetDesc().width;
+ postprocess.resolution.y = (uint)input.GetDesc().height;
postprocess.resolution_rcp.x = 1.0f / postprocess.resolution.x;
postprocess.resolution_rcp.y = 1.0f / postprocess.resolution.y;
postprocess.params0.x = threshold;
@@ -10565,30 +10551,30 @@ void Postprocess_Outline(
void CreateMotionBlurResources(MotionBlurResources& res, XMUINT2 resolution)
{
TextureDesc tile_desc;
- tile_desc.type = TextureDesc::TEXTURE_2D;
- tile_desc.Width = (resolution.x + MOTIONBLUR_TILESIZE - 1) / MOTIONBLUR_TILESIZE;
- tile_desc.Height = (resolution.y + MOTIONBLUR_TILESIZE - 1) / MOTIONBLUR_TILESIZE;
- tile_desc.Format = FORMAT_R16G16_FLOAT;
- tile_desc.BindFlags = BIND_SHADER_RESOURCE | BIND_UNORDERED_ACCESS;
+ tile_desc.type = TextureDesc::Type::TEXTURE_2D;
+ tile_desc.width = (resolution.x + MOTIONBLUR_TILESIZE - 1) / MOTIONBLUR_TILESIZE;
+ tile_desc.height = (resolution.y + MOTIONBLUR_TILESIZE - 1) / MOTIONBLUR_TILESIZE;
+ tile_desc.format = Format::R16G16_FLOAT;
+ tile_desc.bind_flags = BindFlag::SHADER_RESOURCE | BindFlag::UNORDERED_ACCESS;
device->CreateTexture(&tile_desc, nullptr, &res.texture_tilemin);
device->CreateTexture(&tile_desc, nullptr, &res.texture_tilemax);
device->CreateTexture(&tile_desc, nullptr, &res.texture_neighborhoodmax);
- tile_desc.Height = resolution.y;
+ tile_desc.height = resolution.y;
device->CreateTexture(&tile_desc, nullptr, &res.texture_tilemax_horizontal);
device->CreateTexture(&tile_desc, nullptr, &res.texture_tilemin_horizontal);
GPUBufferDesc bufferdesc;
- bufferdesc.BindFlags = BIND_SHADER_RESOURCE | BIND_UNORDERED_ACCESS;
+ bufferdesc.bind_flags = BindFlag::SHADER_RESOURCE | BindFlag::UNORDERED_ACCESS;
- bufferdesc.Size = TILE_STATISTICS_CAPACITY * sizeof(uint);
- bufferdesc.MiscFlags = RESOURCE_MISC_BUFFER_RAW | RESOURCE_MISC_INDIRECT_ARGS;
+ bufferdesc.size = TILE_STATISTICS_CAPACITY * sizeof(uint);
+ bufferdesc.misc_flags = ResourceMiscFlag::BUFFER_RAW | ResourceMiscFlag::INDIRECT_ARGS;
device->CreateBuffer(&bufferdesc, nullptr, &res.buffer_tile_statistics);
- bufferdesc.MiscFlags = RESOURCE_MISC_BUFFER_STRUCTURED;
- bufferdesc.Stride = sizeof(uint);
- bufferdesc.Size = tile_desc.Width * tile_desc.Height * bufferdesc.Stride;
+ bufferdesc.misc_flags = ResourceMiscFlag::BUFFER_STRUCTURED;
+ bufferdesc.stride = sizeof(uint);
+ bufferdesc.size = tile_desc.width * tile_desc.height * bufferdesc.stride;
device->CreateBuffer(&bufferdesc, nullptr, &res.buffer_tiles_earlyexit);
device->CreateBuffer(&bufferdesc, nullptr, &res.buffer_tiles_cheap);
device->CreateBuffer(&bufferdesc, nullptr, &res.buffer_tiles_expensive);
@@ -10607,8 +10593,8 @@ void Postprocess_MotionBlur(
const TextureDesc& desc = output.GetDesc();
PostProcess postprocess;
- postprocess.resolution.x = desc.Width;
- postprocess.resolution.y = desc.Height;
+ postprocess.resolution.x = desc.width;
+ postprocess.resolution.y = desc.height;
postprocess.resolution_rcp.x = 1.0f / postprocess.resolution.x;
postprocess.resolution_rcp.y = 1.0f / postprocess.resolution.y;
motionblur_strength = strength;
@@ -10627,15 +10613,15 @@ void Postprocess_MotionBlur(
{
GPUBarrier barriers[] = {
- 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),
+ GPUBarrier::Image(&res.texture_tilemax_horizontal, res.texture_tilemax_horizontal.desc.layout, ResourceState::UNORDERED_ACCESS),
+ GPUBarrier::Image(&res.texture_tilemin_horizontal, res.texture_tilemin_horizontal.desc.layout, ResourceState::UNORDERED_ACCESS),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
device->Dispatch(
- (res.texture_tilemax_horizontal.GetDesc().Width + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
- (res.texture_tilemax_horizontal.GetDesc().Height + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
+ (res.texture_tilemax_horizontal.GetDesc().width + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
+ (res.texture_tilemax_horizontal.GetDesc().height + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
1,
cmd
);
@@ -10643,8 +10629,8 @@ void Postprocess_MotionBlur(
{
GPUBarrier barriers[] = {
GPUBarrier::Memory(),
- 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),
+ GPUBarrier::Image(&res.texture_tilemax_horizontal, ResourceState::UNORDERED_ACCESS, res.texture_tilemax_horizontal.desc.layout),
+ GPUBarrier::Image(&res.texture_tilemin_horizontal, ResourceState::UNORDERED_ACCESS, res.texture_tilemin_horizontal.desc.layout),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
@@ -10667,15 +10653,15 @@ void Postprocess_MotionBlur(
{
GPUBarrier barriers[] = {
- 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),
+ GPUBarrier::Image(&res.texture_tilemax, res.texture_tilemax.desc.layout, ResourceState::UNORDERED_ACCESS),
+ GPUBarrier::Image(&res.texture_tilemin, res.texture_tilemin.desc.layout, ResourceState::UNORDERED_ACCESS),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
device->Dispatch(
- (res.texture_tilemax.GetDesc().Width + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
- (res.texture_tilemax.GetDesc().Height + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
+ (res.texture_tilemax.GetDesc().width + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
+ (res.texture_tilemax.GetDesc().height + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
1,
cmd
);
@@ -10683,8 +10669,8 @@ void Postprocess_MotionBlur(
{
GPUBarrier barriers[] = {
GPUBarrier::Memory(),
- 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),
+ GPUBarrier::Image(&res.texture_tilemax, ResourceState::UNORDERED_ACCESS, res.texture_tilemax.desc.layout),
+ GPUBarrier::Image(&res.texture_tilemin, ResourceState::UNORDERED_ACCESS, res.texture_tilemin.desc.layout),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
@@ -10714,14 +10700,14 @@ void Postprocess_MotionBlur(
{
GPUBarrier barriers[] = {
- GPUBarrier::Image(&res.texture_neighborhoodmax, res.texture_neighborhoodmax.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS),
+ GPUBarrier::Image(&res.texture_neighborhoodmax, res.texture_neighborhoodmax.desc.layout, ResourceState::UNORDERED_ACCESS),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
device->Dispatch(
- (res.texture_neighborhoodmax.GetDesc().Width + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
- (res.texture_neighborhoodmax.GetDesc().Height + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
+ (res.texture_neighborhoodmax.GetDesc().width + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
+ (res.texture_neighborhoodmax.GetDesc().height + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
1,
cmd
);
@@ -10729,7 +10715,7 @@ void Postprocess_MotionBlur(
{
GPUBarrier barriers[] = {
GPUBarrier::Memory(),
- GPUBarrier::Image(&res.texture_neighborhoodmax, RESOURCE_STATE_UNORDERED_ACCESS, res.texture_neighborhoodmax.desc.layout),
+ GPUBarrier::Image(&res.texture_neighborhoodmax, ResourceState::UNORDERED_ACCESS, res.texture_neighborhoodmax.desc.layout),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
@@ -10756,7 +10742,7 @@ void Postprocess_MotionBlur(
GPUBarrier barriers[] = {
GPUBarrier::Memory(),
- GPUBarrier::Buffer(&res.buffer_tile_statistics, RESOURCE_STATE_UNORDERED_ACCESS, RESOURCE_STATE_INDIRECT_ARGUMENT),
+ GPUBarrier::Buffer(&res.buffer_tile_statistics, ResourceState::UNORDERED_ACCESS, ResourceState::INDIRECT_ARGUMENT),
};
device->Barrier(barriers, arraysize(barriers), cmd);
@@ -10783,10 +10769,10 @@ void Postprocess_MotionBlur(
{
GPUBarrier barriers[] = {
- 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),
+ GPUBarrier::Buffer(&res.buffer_tiles_earlyexit, ResourceState::UNORDERED_ACCESS, ResourceState::SHADER_RESOURCE),
+ GPUBarrier::Buffer(&res.buffer_tiles_cheap, ResourceState::UNORDERED_ACCESS, ResourceState::SHADER_RESOURCE),
+ GPUBarrier::Buffer(&res.buffer_tiles_expensive, ResourceState::UNORDERED_ACCESS, ResourceState::SHADER_RESOURCE),
+ GPUBarrier::Image(&output, output.desc.layout, ResourceState::UNORDERED_ACCESS),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
@@ -10803,7 +10789,7 @@ void Postprocess_MotionBlur(
{
GPUBarrier barriers[] = {
GPUBarrier::Memory(),
- GPUBarrier::Image(&output, RESOURCE_STATE_UNORDERED_ACCESS, output.desc.layout),
+ GPUBarrier::Image(&output, ResourceState::UNORDERED_ACCESS, output.desc.layout),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
@@ -10821,39 +10807,39 @@ void CreateVolumetricCloudResources(VolumetricCloudResources& res, XMUINT2 resol
XMUINT2 maskResolution = XMUINT2(resolution.x / 4, resolution.y / 4); // Needs to be half of final cloud output
TextureDesc desc;
- desc.BindFlags = BIND_SHADER_RESOURCE | BIND_UNORDERED_ACCESS;
- desc.Width = renderResolution.x;
- desc.Height = renderResolution.y;
- desc.Format = FORMAT_R16G16B16A16_FLOAT;
- desc.layout = RESOURCE_STATE_SHADER_RESOURCE_COMPUTE;
+ desc.bind_flags = BindFlag::SHADER_RESOURCE | BindFlag::UNORDERED_ACCESS;
+ desc.width = renderResolution.x;
+ desc.height = renderResolution.y;
+ desc.format = Format::R16G16B16A16_FLOAT;
+ desc.layout = ResourceState::SHADER_RESOURCE_COMPUTE;
device->CreateTexture(&desc, nullptr, &res.texture_cloudRender);
device->SetName(&res.texture_cloudRender, "texture_cloudRender");
- desc.Format = FORMAT_R16G16_FLOAT;
+ desc.format = Format::R16G16_FLOAT;
device->CreateTexture(&desc, nullptr, &res.texture_cloudDepth);
device->SetName(&res.texture_cloudDepth, "texture_cloudDepth");
- desc.Width = reprojectionResolution.x;
- desc.Height = reprojectionResolution.y;
- desc.Format = FORMAT_R16G16B16A16_FLOAT;
+ desc.width = reprojectionResolution.x;
+ desc.height = reprojectionResolution.y;
+ desc.format = Format::R16G16B16A16_FLOAT;
device->CreateTexture(&desc, nullptr, &res.texture_reproject[0]);
device->SetName(&res.texture_reproject[0], "texture_reproject[0]");
device->CreateTexture(&desc, nullptr, &res.texture_reproject[1]);
device->SetName(&res.texture_reproject[1], "texture_reproject[1]");
- desc.Format = FORMAT_R16G16_FLOAT;
+ desc.format = Format::R16G16_FLOAT;
device->CreateTexture(&desc, nullptr, &res.texture_reproject_depth[0]);
device->SetName(&res.texture_reproject_depth[0], "texture_reproject_depth[0]");
device->CreateTexture(&desc, nullptr, &res.texture_reproject_depth[1]);
device->SetName(&res.texture_reproject_depth[1], "texture_reproject_depth[1]");
- desc.Format = FORMAT_R16G16B16A16_FLOAT;
+ desc.format = Format::R16G16B16A16_FLOAT;
device->CreateTexture(&desc, nullptr, &res.texture_temporal[0]);
device->SetName(&res.texture_temporal[0], "texture_temporal[0]");
device->CreateTexture(&desc, nullptr, &res.texture_temporal[1]);
device->SetName(&res.texture_temporal[1], "texture_temporal[1]");
- desc.Width = maskResolution.x;
- desc.Height = maskResolution.y;
- desc.Format = FORMAT_R8G8B8A8_UNORM;
+ desc.width = maskResolution.x;
+ desc.height = maskResolution.y;
+ desc.format = Format::R8G8B8A8_UNORM;
device->CreateTexture(&desc, nullptr, &res.texture_cloudMask);
device->SetName(&res.texture_cloudMask, "texture_cloudMask");
}
@@ -10869,12 +10855,12 @@ void Postprocess_VolumetricClouds(
const TextureDesc& desc = res.texture_reproject[0].GetDesc();
PostProcess postprocess;
- postprocess.resolution.x = desc.Width;
- postprocess.resolution.y = desc.Height;
+ postprocess.resolution.x = desc.width;
+ postprocess.resolution.y = desc.height;
postprocess.resolution_rcp.x = 1.0f / postprocess.resolution.x;
postprocess.resolution_rcp.y = 1.0f / postprocess.resolution.y;
- postprocess.params0.x = (float)res.texture_reproject[0].GetDesc().Width;
- postprocess.params0.y = (float)res.texture_reproject[0].GetDesc().Height;
+ postprocess.params0.x = (float)res.texture_reproject[0].GetDesc().width;
+ postprocess.params0.y = (float)res.texture_reproject[0].GetDesc().height;
postprocess.params0.z = 1.0f / postprocess.params0.x;
postprocess.params0.w = 1.0f / postprocess.params0.y;
device->PushConstants(&postprocess, sizeof(postprocess), cmd);
@@ -10897,15 +10883,15 @@ void Postprocess_VolumetricClouds(
{
GPUBarrier barriers[] = {
- 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),
+ GPUBarrier::Image(&res.texture_cloudRender, res.texture_cloudRender.desc.layout, ResourceState::UNORDERED_ACCESS),
+ GPUBarrier::Image(&res.texture_cloudDepth, res.texture_cloudDepth.desc.layout, ResourceState::UNORDERED_ACCESS),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
device->Dispatch(
- (res.texture_cloudRender.GetDesc().Width + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
- (res.texture_cloudRender.GetDesc().Height + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
+ (res.texture_cloudRender.GetDesc().width + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
+ (res.texture_cloudRender.GetDesc().height + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
1,
cmd
);
@@ -10913,8 +10899,8 @@ void Postprocess_VolumetricClouds(
{
GPUBarrier barriers[] = {
GPUBarrier::Memory(),
- 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),
+ GPUBarrier::Image(&res.texture_cloudRender, ResourceState::UNORDERED_ACCESS, res.texture_cloudRender.desc.layout),
+ GPUBarrier::Image(&res.texture_cloudDepth, ResourceState::UNORDERED_ACCESS, res.texture_cloudDepth.desc.layout),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
@@ -10923,8 +10909,8 @@ void Postprocess_VolumetricClouds(
}
const TextureDesc& reprojection_desc = res.texture_reproject[0].GetDesc();
- postprocess.resolution.x = reprojection_desc.Width;
- postprocess.resolution.y = reprojection_desc.Height;
+ postprocess.resolution.x = reprojection_desc.width;
+ postprocess.resolution.y = reprojection_desc.height;
postprocess.resolution_rcp.x = 1.0f / postprocess.resolution.x;
postprocess.resolution_rcp.y = 1.0f / postprocess.resolution.y;
device->PushConstants(&postprocess, sizeof(postprocess), cmd);
@@ -10950,15 +10936,15 @@ void Postprocess_VolumetricClouds(
{
GPUBarrier barriers[] = {
- 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),
+ GPUBarrier::Image(&res.texture_reproject[temporal_output], res.texture_reproject[temporal_output].desc.layout, ResourceState::UNORDERED_ACCESS),
+ GPUBarrier::Image(&res.texture_reproject_depth[temporal_output], res.texture_reproject_depth[temporal_output].desc.layout, ResourceState::UNORDERED_ACCESS),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
device->Dispatch(
- (res.texture_reproject[temporal_output].GetDesc().Width + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
- (res.texture_reproject[temporal_output].GetDesc().Height + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
+ (res.texture_reproject[temporal_output].GetDesc().width + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
+ (res.texture_reproject[temporal_output].GetDesc().height + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
1,
cmd
);
@@ -10966,8 +10952,8 @@ void Postprocess_VolumetricClouds(
{
GPUBarrier barriers[] = {
GPUBarrier::Memory(),
- 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),
+ GPUBarrier::Image(&res.texture_reproject[temporal_output], ResourceState::UNORDERED_ACCESS, res.texture_reproject[temporal_output].desc.layout),
+ GPUBarrier::Image(&res.texture_reproject_depth[temporal_output], ResourceState::UNORDERED_ACCESS, res.texture_reproject_depth[temporal_output].desc.layout),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
@@ -10992,15 +10978,15 @@ void Postprocess_VolumetricClouds(
{
GPUBarrier barriers[] = {
- 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),
+ GPUBarrier::Image(&res.texture_temporal[temporal_output], res.texture_temporal[temporal_output].desc.layout, ResourceState::UNORDERED_ACCESS),
+ GPUBarrier::Image(&res.texture_cloudMask, res.texture_cloudMask.desc.layout, ResourceState::UNORDERED_ACCESS),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
device->Dispatch(
- (res.texture_temporal[temporal_output].GetDesc().Width + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
- (res.texture_temporal[temporal_output].GetDesc().Height + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
+ (res.texture_temporal[temporal_output].GetDesc().width + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
+ (res.texture_temporal[temporal_output].GetDesc().height + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
1,
cmd
);
@@ -11008,8 +10994,8 @@ void Postprocess_VolumetricClouds(
{
GPUBarrier barriers[] = {
GPUBarrier::Memory(),
- 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),
+ GPUBarrier::Image(&res.texture_temporal[temporal_output], ResourceState::UNORDERED_ACCESS, res.texture_temporal[temporal_output].desc.layout),
+ GPUBarrier::Image(&res.texture_cloudMask, ResourceState::UNORDERED_ACCESS, res.texture_cloudMask.desc.layout),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
@@ -11036,8 +11022,8 @@ void Postprocess_FXAA(
const TextureDesc& desc = output.GetDesc();
PostProcess postprocess;
- postprocess.resolution.x = desc.Width;
- postprocess.resolution.y = desc.Height;
+ postprocess.resolution.x = desc.width;
+ postprocess.resolution.y = desc.height;
postprocess.resolution_rcp.x = 1.0f / postprocess.resolution.x;
postprocess.resolution_rcp.y = 1.0f / postprocess.resolution.y;
device->PushConstants(&postprocess, sizeof(postprocess), cmd);
@@ -11049,14 +11035,14 @@ void Postprocess_FXAA(
{
GPUBarrier barriers[] = {
- GPUBarrier::Image(&output, output.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS),
+ GPUBarrier::Image(&output, output.desc.layout, ResourceState::UNORDERED_ACCESS),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
device->Dispatch(
- (desc.Width + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
- (desc.Height + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
+ (desc.width + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
+ (desc.height + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
1,
cmd
);
@@ -11064,7 +11050,7 @@ void Postprocess_FXAA(
{
GPUBarrier barriers[] = {
GPUBarrier::Memory(),
- GPUBarrier::Image(&output, RESOURCE_STATE_UNORDERED_ACCESS, output.desc.layout),
+ GPUBarrier::Image(&output, ResourceState::UNORDERED_ACCESS, output.desc.layout),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
@@ -11091,8 +11077,8 @@ void Postprocess_TemporalAA(
const TextureDesc& desc = output.GetDesc();
PostProcess postprocess;
- postprocess.resolution.x = desc.Width;
- postprocess.resolution.y = desc.Height;
+ postprocess.resolution.x = desc.width;
+ postprocess.resolution.y = desc.height;
postprocess.resolution_rcp.x = 1.0f / postprocess.resolution.x;
postprocess.resolution_rcp.y = 1.0f / postprocess.resolution.y;
device->PushConstants(&postprocess, sizeof(postprocess), cmd);
@@ -11104,14 +11090,14 @@ void Postprocess_TemporalAA(
{
GPUBarrier barriers[] = {
- GPUBarrier::Image(&output, output.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS),
+ GPUBarrier::Image(&output, output.desc.layout, ResourceState::UNORDERED_ACCESS),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
device->Dispatch(
- (desc.Width + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
- (desc.Height + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
+ (desc.width + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
+ (desc.height + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
1,
cmd
);
@@ -11119,7 +11105,7 @@ void Postprocess_TemporalAA(
{
GPUBarrier barriers[] = {
GPUBarrier::Memory(),
- GPUBarrier::Image(&output, RESOURCE_STATE_UNORDERED_ACCESS, output.desc.layout),
+ GPUBarrier::Image(&output, ResourceState::UNORDERED_ACCESS, output.desc.layout),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
@@ -11144,8 +11130,8 @@ void Postprocess_Sharpen(
const TextureDesc& desc = output.GetDesc();
PostProcess postprocess;
- postprocess.resolution.x = desc.Width;
- postprocess.resolution.y = desc.Height;
+ postprocess.resolution.x = desc.width;
+ postprocess.resolution.y = desc.height;
postprocess.resolution_rcp.x = 1.0f / postprocess.resolution.x;
postprocess.resolution_rcp.y = 1.0f / postprocess.resolution.y;
postprocess.params0.x = amount;
@@ -11158,14 +11144,14 @@ void Postprocess_Sharpen(
{
GPUBarrier barriers[] = {
- GPUBarrier::Image(&output, output.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS),
+ GPUBarrier::Image(&output, output.desc.layout, ResourceState::UNORDERED_ACCESS),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
device->Dispatch(
- (desc.Width + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
- (desc.Height + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
+ (desc.width + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
+ (desc.height + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
1,
cmd
);
@@ -11173,7 +11159,7 @@ void Postprocess_Sharpen(
{
GPUBarrier barriers[] = {
GPUBarrier::Memory(),
- GPUBarrier::Image(&output, RESOURCE_STATE_UNORDERED_ACCESS, output.desc.layout),
+ GPUBarrier::Image(&output, ResourceState::UNORDERED_ACCESS, output.desc.layout),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
@@ -11191,7 +11177,7 @@ void Postprocess_Tonemap(
const Texture* texture_distortion,
const GPUBuffer* buffer_luminance,
const Texture* texture_bloom,
- COLOR_SPACE display_colorspace
+ ColorSpace display_colorspace
)
{
device->EventBegin("Postprocess_Tonemap", cmd);
@@ -11200,32 +11186,32 @@ void Postprocess_Tonemap(
const TextureDesc& desc = output.GetDesc();
- assert(texture_colorgradinglut == nullptr || texture_colorgradinglut->desc.type == TextureDesc::TEXTURE_3D); // This must be a 3D lut
+ assert(texture_colorgradinglut == nullptr || texture_colorgradinglut->desc.type == TextureDesc::Type::TEXTURE_3D); // This must be a 3D lut
PushConstantsTonemap tonemap_push = {};
- tonemap_push.resolution_rcp.x = 1.0f / desc.Width;
- tonemap_push.resolution_rcp.y = 1.0f / desc.Height;
+ tonemap_push.resolution_rcp.x = 1.0f / desc.width;
+ tonemap_push.resolution_rcp.y = 1.0f / desc.height;
tonemap_push.exposure = exposure;
tonemap_push.dither = dither ? 1.0f : 0.0f;
- tonemap_push.texture_input = device->GetDescriptorIndex(&input, SRV);
- tonemap_push.buffer_input_luminance = device->GetDescriptorIndex(buffer_luminance, SRV);
- tonemap_push.texture_input_distortion = device->GetDescriptorIndex(texture_distortion, SRV);
- tonemap_push.texture_colorgrade_lookuptable = device->GetDescriptorIndex(texture_colorgradinglut, SRV);
- tonemap_push.texture_bloom = device->GetDescriptorIndex(texture_bloom, SRV);
- tonemap_push.texture_output = device->GetDescriptorIndex(&output, UAV);
- tonemap_push.display_colorspace = display_colorspace;
+ tonemap_push.texture_input = device->GetDescriptorIndex(&input, SubresourceType::SRV);
+ tonemap_push.buffer_input_luminance = device->GetDescriptorIndex(buffer_luminance, SubresourceType::SRV);
+ tonemap_push.texture_input_distortion = device->GetDescriptorIndex(texture_distortion, SubresourceType::SRV);
+ tonemap_push.texture_colorgrade_lookuptable = device->GetDescriptorIndex(texture_colorgradinglut, SubresourceType::SRV);
+ tonemap_push.texture_bloom = device->GetDescriptorIndex(texture_bloom, SubresourceType::SRV);
+ tonemap_push.texture_output = device->GetDescriptorIndex(&output, SubresourceType::UAV);
+ tonemap_push.display_colorspace = static_cast(display_colorspace);
device->PushConstants(&tonemap_push, sizeof(tonemap_push), cmd);
{
GPUBarrier barriers[] = {
- GPUBarrier::Image(&output, output.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS),
+ GPUBarrier::Image(&output, output.desc.layout, ResourceState::UNORDERED_ACCESS),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
device->Dispatch(
- (desc.Width + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
- (desc.Height + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
+ (desc.width + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
+ (desc.height + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
1,
cmd
);
@@ -11233,7 +11219,7 @@ void Postprocess_Tonemap(
{
GPUBarrier barriers[] = {
GPUBarrier::Memory(),
- GPUBarrier::Image(&output, RESOURCE_STATE_UNORDERED_ACCESS, output.desc.layout),
+ GPUBarrier::Image(&output, ResourceState::UNORDERED_ACCESS, output.desc.layout),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
@@ -11277,16 +11263,16 @@ void Postprocess_FSR(
fsr.const3,
// current frame render resolution:
- static_cast(input.desc.Width),
- static_cast(input.desc.Height),
+ static_cast(input.desc.width),
+ static_cast(input.desc.height),
// input container resolution:
- static_cast(input.desc.Width),
- static_cast(input.desc.Height),
+ static_cast(input.desc.width),
+ static_cast(input.desc.height),
// upscaled-to-resolution:
- static_cast(temp.desc.Width),
- static_cast(temp.desc.Height)
+ static_cast(temp.desc.width),
+ static_cast(temp.desc.height)
);
device->PushConstants(&fsr, sizeof(fsr), cmd);
@@ -11300,17 +11286,17 @@ void Postprocess_FSR(
{
GPUBarrier barriers[] = {
- GPUBarrier::Image(&temp, temp.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS),
+ GPUBarrier::Image(&temp, temp.desc.layout, ResourceState::UNORDERED_ACCESS),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
- device->Dispatch((desc.Width + 15) / 16, (desc.Height + 15) / 16, 1, cmd);
+ device->Dispatch((desc.width + 15) / 16, (desc.height + 15) / 16, 1, cmd);
{
GPUBarrier barriers[] = {
GPUBarrier::Memory(),
- GPUBarrier::Image(&temp, RESOURCE_STATE_UNORDERED_ACCESS, temp.desc.layout),
+ GPUBarrier::Image(&temp, ResourceState::UNORDERED_ACCESS, temp.desc.layout),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
@@ -11333,17 +11319,17 @@ void Postprocess_FSR(
{
GPUBarrier barriers[] = {
- GPUBarrier::Image(&output, output.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS),
+ GPUBarrier::Image(&output, output.desc.layout, ResourceState::UNORDERED_ACCESS),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
- device->Dispatch((desc.Width + 15) / 16, (desc.Height + 15) / 16, 1, cmd);
+ device->Dispatch((desc.width + 15) / 16, (desc.height + 15) / 16, 1, cmd);
{
GPUBarrier barriers[] = {
GPUBarrier::Memory(),
- GPUBarrier::Image(&output, RESOURCE_STATE_UNORDERED_ACCESS, output.desc.layout),
+ GPUBarrier::Image(&output, ResourceState::UNORDERED_ACCESS, output.desc.layout),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
@@ -11369,8 +11355,8 @@ void Postprocess_Chromatic_Aberration(
const TextureDesc& desc = output.GetDesc();
PostProcess postprocess;
- postprocess.resolution.x = desc.Width;
- postprocess.resolution.y = desc.Height;
+ postprocess.resolution.x = desc.width;
+ postprocess.resolution.y = desc.height;
postprocess.resolution_rcp.x = 1.0f / postprocess.resolution.x;
postprocess.resolution_rcp.y = 1.0f / postprocess.resolution.y;
postprocess.params0.x = amount;
@@ -11383,14 +11369,14 @@ void Postprocess_Chromatic_Aberration(
{
GPUBarrier barriers[] = {
- GPUBarrier::Image(&output, output.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS),
+ GPUBarrier::Image(&output, output.desc.layout, ResourceState::UNORDERED_ACCESS),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
device->Dispatch(
- (desc.Width + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
- (desc.Height + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
+ (desc.width + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
+ (desc.height + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
1,
cmd
);
@@ -11398,7 +11384,7 @@ void Postprocess_Chromatic_Aberration(
{
GPUBarrier barriers[] = {
GPUBarrier::Memory(),
- GPUBarrier::Image(&output, RESOURCE_STATE_UNORDERED_ACCESS, output.desc.layout),
+ GPUBarrier::Image(&output, ResourceState::UNORDERED_ACCESS, output.desc.layout),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
@@ -11420,17 +11406,17 @@ void Postprocess_Upsample_Bilateral(
const TextureDesc& desc = output.GetDesc();
PostProcess postprocess;
- postprocess.resolution.x = desc.Width;
- postprocess.resolution.y = desc.Height;
+ postprocess.resolution.x = desc.width;
+ postprocess.resolution.y = desc.height;
postprocess.resolution_rcp.x = 1.0f / postprocess.resolution.x;
postprocess.resolution_rcp.y = 1.0f / postprocess.resolution.y;
postprocess.params0.x = threshold;
- postprocess.params0.y = 1.0f / (float)input.GetDesc().Width;
- postprocess.params0.z = 1.0f / (float)input.GetDesc().Height;
+ postprocess.params0.y = 1.0f / (float)input.GetDesc().width;
+ postprocess.params0.z = 1.0f / (float)input.GetDesc().height;
// select mip from lowres depth mipchain:
- postprocess.params0.w = floorf(std::max(1.0f, log2f(std::max((float)desc.Width / (float)input.GetDesc().Width, (float)desc.Height / (float)input.GetDesc().Height))));
- postprocess.params1.x = (float)input.GetDesc().Width;
- postprocess.params1.y = (float)input.GetDesc().Height;
+ postprocess.params0.w = floorf(std::max(1.0f, log2f(std::max((float)desc.width / (float)input.GetDesc().width, (float)desc.height / (float)input.GetDesc().height))));
+ postprocess.params1.x = (float)input.GetDesc().width;
+ postprocess.params1.y = (float)input.GetDesc().height;
postprocess.params1.z = 1.0f / postprocess.params1.x;
postprocess.params1.w = 1.0f / postprocess.params1.y;
device->PushConstants(&postprocess, sizeof(postprocess), cmd);
@@ -11446,28 +11432,28 @@ void Postprocess_Upsample_Bilateral(
else
{
SHADERTYPE cs = CSTYPE_POSTPROCESS_UPSAMPLE_BILATERAL_FLOAT4;
- switch (desc.Format)
+ switch (desc.format)
{
- case FORMAT_R16_UNORM:
- case FORMAT_R8_UNORM:
+ case Format::R16_UNORM:
+ case Format::R8_UNORM:
cs = CSTYPE_POSTPROCESS_UPSAMPLE_BILATERAL_UNORM1;
break;
- case FORMAT_R16_FLOAT:
- case FORMAT_R32_FLOAT:
+ case Format::R16_FLOAT:
+ case Format::R32_FLOAT:
cs = CSTYPE_POSTPROCESS_UPSAMPLE_BILATERAL_FLOAT1;
break;
- case FORMAT_R16G16B16A16_UNORM:
- case FORMAT_R8G8B8A8_UNORM:
- case FORMAT_B8G8R8A8_UNORM:
- case FORMAT_R10G10B10A2_UNORM:
+ case Format::R16G16B16A16_UNORM:
+ case Format::R8G8B8A8_UNORM:
+ case Format::B8G8R8A8_UNORM:
+ case Format::R10G10B10A2_UNORM:
cs = CSTYPE_POSTPROCESS_UPSAMPLE_BILATERAL_UNORM4;
break;
- case FORMAT_R11G11B10_FLOAT:
- case FORMAT_R16G16B16A16_FLOAT:
- case FORMAT_R32G32B32A32_FLOAT:
+ case Format::R11G11B10_FLOAT:
+ case Format::R16G16B16A16_FLOAT:
+ case Format::R32G32B32A32_FLOAT:
cs = CSTYPE_POSTPROCESS_UPSAMPLE_BILATERAL_FLOAT4;
break;
- case FORMAT_R32G32B32A32_UINT:
+ case Format::R32G32B32A32_UINT:
cs = CSTYPE_POSTPROCESS_UPSAMPLE_BILATERAL_UINT4;
break;
default:
@@ -11485,14 +11471,14 @@ void Postprocess_Upsample_Bilateral(
{
GPUBarrier barriers[] = {
- GPUBarrier::Image(&output, output.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS),
+ GPUBarrier::Image(&output, output.desc.layout, ResourceState::UNORDERED_ACCESS),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
device->Dispatch(
- (desc.Width + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
- (desc.Height + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
+ (desc.width + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
+ (desc.height + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
1,
cmd
);
@@ -11500,7 +11486,7 @@ void Postprocess_Upsample_Bilateral(
{
GPUBarrier barriers[] = {
GPUBarrier::Memory(),
- GPUBarrier::Image(&output, RESOURCE_STATE_UNORDERED_ACCESS, output.desc.layout),
+ GPUBarrier::Image(&output, ResourceState::UNORDERED_ACCESS, output.desc.layout),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
@@ -11520,8 +11506,8 @@ void Postprocess_Downsample4x(
const TextureDesc& desc = output.GetDesc();
PostProcess postprocess;
- postprocess.resolution.x = desc.Width;
- postprocess.resolution.y = desc.Height;
+ postprocess.resolution.x = desc.width;
+ postprocess.resolution.y = desc.height;
postprocess.resolution_rcp.x = 1.0f / postprocess.resolution.x;
postprocess.resolution_rcp.y = 1.0f / postprocess.resolution.y;
device->PushConstants(&postprocess, sizeof(postprocess), cmd);
@@ -11537,14 +11523,14 @@ void Postprocess_Downsample4x(
{
GPUBarrier barriers[] = {
- GPUBarrier::Image(&output, output.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS),
+ GPUBarrier::Image(&output, output.desc.layout, ResourceState::UNORDERED_ACCESS),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
device->Dispatch(
- (desc.Width + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
- (desc.Height + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
+ (desc.width + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
+ (desc.height + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
1,
cmd
);
@@ -11552,7 +11538,7 @@ void Postprocess_Downsample4x(
{
GPUBarrier barriers[] = {
GPUBarrier::Memory(),
- GPUBarrier::Image(&output, RESOURCE_STATE_UNORDERED_ACCESS, output.desc.layout),
+ GPUBarrier::Image(&output, ResourceState::UNORDERED_ACCESS, output.desc.layout),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
@@ -11570,11 +11556,11 @@ void Postprocess_NormalsFromDepth(
const TextureDesc& desc = output.GetDesc();
PostProcess postprocess;
- postprocess.resolution.x = desc.Width;
- postprocess.resolution.y = desc.Height;
+ postprocess.resolution.x = desc.width;
+ postprocess.resolution.y = desc.height;
postprocess.resolution_rcp.x = 1.0f / postprocess.resolution.x;
postprocess.resolution_rcp.y = 1.0f / postprocess.resolution.y;
- postprocess.params0.x = floorf(std::max(1.0f, log2f(std::max((float)desc.Width / (float)depthbuffer.GetDesc().Width, (float)desc.Height / (float)depthbuffer.GetDesc().Height))));
+ postprocess.params0.x = floorf(std::max(1.0f, log2f(std::max((float)desc.width / (float)depthbuffer.GetDesc().width, (float)desc.height / (float)depthbuffer.GetDesc().height))));
device->PushConstants(&postprocess, sizeof(postprocess), cmd);
device->BindComputeShader(&shaders[CSTYPE_POSTPROCESS_NORMALSFROMDEPTH], cmd);
@@ -11587,14 +11573,14 @@ void Postprocess_NormalsFromDepth(
{
GPUBarrier barriers[] = {
- GPUBarrier::Image(&output, output.desc.layout, RESOURCE_STATE_UNORDERED_ACCESS),
+ GPUBarrier::Image(&output, output.desc.layout, ResourceState::UNORDERED_ACCESS),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
device->Dispatch(
- (desc.Width + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
- (desc.Height + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
+ (desc.width + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
+ (desc.height + POSTPROCESS_BLOCKSIZE - 1) / POSTPROCESS_BLOCKSIZE,
1,
cmd
);
@@ -11602,7 +11588,7 @@ void Postprocess_NormalsFromDepth(
{
GPUBarrier barriers[] = {
GPUBarrier::Memory(),
- GPUBarrier::Image(&output, RESOURCE_STATE_UNORDERED_ACCESS, output.desc.layout),
+ GPUBarrier::Image(&output, ResourceState::UNORDERED_ACCESS, output.desc.layout),
};
device->Barrier(barriers, arraysize(barriers), cmd);
}
@@ -11721,23 +11707,23 @@ void SetVoxelRadianceEnabled(bool enabled)
if (!textures[TEXTYPE_3D_VOXELRADIANCE].IsValid())
{
TextureDesc desc;
- desc.type = TextureDesc::TEXTURE_3D;
- desc.Width = voxelSceneData.res;
- desc.Height = voxelSceneData.res;
- desc.Depth = voxelSceneData.res;
- desc.MipLevels = 0;
- desc.Format = FORMAT_R16G16B16A16_FLOAT;
- desc.BindFlags = BIND_UNORDERED_ACCESS | BIND_SHADER_RESOURCE;
- desc.Usage = USAGE_DEFAULT;
+ desc.type = TextureDesc::Type::TEXTURE_3D;
+ desc.width = voxelSceneData.res;
+ desc.height = voxelSceneData.res;
+ desc.depth = voxelSceneData.res;
+ desc.mip_levels = 0;
+ desc.format = Format::R16G16B16A16_FLOAT;
+ desc.bind_flags = BindFlag::UNORDERED_ACCESS | BindFlag::SHADER_RESOURCE;
+ desc.usage = Usage::DEFAULT;
device->CreateTexture(&desc, nullptr, &textures[TEXTYPE_3D_VOXELRADIANCE]);
- for (uint32_t i = 0; i < textures[TEXTYPE_3D_VOXELRADIANCE].GetDesc().MipLevels; ++i)
+ for (uint32_t i = 0; i < textures[TEXTYPE_3D_VOXELRADIANCE].GetDesc().mip_levels; ++i)
{
int subresource_index;
- subresource_index = device->CreateSubresource(&textures[TEXTYPE_3D_VOXELRADIANCE], SRV, 0, 1, i, 1);
+ subresource_index = device->CreateSubresource(&textures[TEXTYPE_3D_VOXELRADIANCE], SubresourceType::SRV, 0, 1, i, 1);
assert(subresource_index == i);
- subresource_index = device->CreateSubresource(&textures[TEXTYPE_3D_VOXELRADIANCE], UAV, 0, 1, i, 1);
+ subresource_index = device->CreateSubresource(&textures[TEXTYPE_3D_VOXELRADIANCE], SubresourceType::UAV, 0, 1, i, 1);
assert(subresource_index == i);
}
}
@@ -11746,23 +11732,23 @@ void SetVoxelRadianceEnabled(bool enabled)
const TextureDesc& desc = textures[TEXTYPE_3D_VOXELRADIANCE].GetDesc();
device->CreateTexture(&desc, nullptr, &textures[TEXTYPE_3D_VOXELRADIANCE_HELPER]);
- for (uint32_t i = 0; i < desc.MipLevels; ++i)
+ for (uint32_t i = 0; i < desc.mip_levels; ++i)
{
int subresource_index;
- subresource_index = device->CreateSubresource(&textures[TEXTYPE_3D_VOXELRADIANCE_HELPER], SRV, 0, 1, i, 1);
+ subresource_index = device->CreateSubresource(&textures[TEXTYPE_3D_VOXELRADIANCE_HELPER], SubresourceType::SRV, 0, 1, i, 1);
assert(subresource_index == i);
- subresource_index = device->CreateSubresource(&textures[TEXTYPE_3D_VOXELRADIANCE_HELPER], UAV, 0, 1, i, 1);
+ subresource_index = device->CreateSubresource(&textures[TEXTYPE_3D_VOXELRADIANCE_HELPER], SubresourceType::UAV, 0, 1, i, 1);
assert(subresource_index == i);
}
}
if (!resourceBuffers[RBTYPE_VOXELSCENE].IsValid())
{
GPUBufferDesc desc;
- desc.Stride = sizeof(uint32_t) * 2;
- desc.Size = desc.Stride * voxelSceneData.res * voxelSceneData.res * voxelSceneData.res;
- desc.BindFlags = BIND_UNORDERED_ACCESS | BIND_SHADER_RESOURCE;
- desc.MiscFlags = RESOURCE_MISC_BUFFER_STRUCTURED;
- desc.Usage = USAGE_DEFAULT;
+ desc.stride = sizeof(uint32_t) * 2;
+ desc.size = desc.stride * voxelSceneData.res * voxelSceneData.res * voxelSceneData.res;
+ desc.bind_flags = BindFlag::UNORDERED_ACCESS | BindFlag::SHADER_RESOURCE;
+ desc.misc_flags = ResourceMiscFlag::BUFFER_STRUCTURED;
+ desc.usage = Usage::DEFAULT;
device->CreateBuffer(&desc, nullptr, &resourceBuffers[RBTYPE_VOXELSCENE]);
}
diff --git a/WickedEngine/wiRenderer.h b/WickedEngine/wiRenderer.h
index ff0689e3f..4a183c02a 100644
--- a/WickedEngine/wiRenderer.h
+++ b/WickedEngine/wiRenderer.h
@@ -46,11 +46,6 @@ namespace wiRenderer
// Clears the scene and the associated renderer resources
void ClearWorld(wiScene::Scene& scene);
- // Set the main graphics device globally:
- void SetDevice(std::shared_ptr newDevice);
- // Retrieve the main graphics device:
- wiGraphics::GraphicsDevice* GetDevice();
-
// Returns the shader binary directory
const std::string& GetShaderPath();
// Sets the shader binary directory
@@ -66,10 +61,10 @@ namespace wiRenderer
size_t GetShaderDumpCount();
bool LoadShader(
- wiGraphics::SHADERSTAGE stage,
+ wiGraphics::ShaderStage stage,
wiGraphics::Shader& shader,
const std::string& filename,
- wiGraphics::SHADERMODEL minshadermodel = wiGraphics::SHADERMODEL_6_0
+ wiGraphics::ShaderModel minshadermodel = wiGraphics::ShaderModel::SM_6_0
);
@@ -593,7 +588,7 @@ namespace wiRenderer
const wiGraphics::Texture* texture_distortion = nullptr,
const wiGraphics::GPUBuffer* buffer_luminance = nullptr,
const wiGraphics::Texture* texture_bloom = nullptr,
- wiGraphics::COLOR_SPACE display_colorspace = wiGraphics::COLOR_SPACE_SRGB
+ wiGraphics::ColorSpace display_colorspace = wiGraphics::ColorSpace::SRGB
);
void Postprocess_FSR(
const wiGraphics::Texture& input,
diff --git a/WickedEngine/wiResourceManager.cpp b/WickedEngine/wiResourceManager.cpp
index 8b8e7f0df..c0c159e9a 100644
--- a/WickedEngine/wiResourceManager.cpp
+++ b/WickedEngine/wiResourceManager.cpp
@@ -127,33 +127,33 @@ namespace wiResourceManager
{
case wiResource::IMAGE:
{
- GraphicsDevice* device = wiRenderer::GetDevice();
+ GraphicsDevice* device = wiGraphics::GetDevice();
if (!ext.compare("KTX2"))
{
basist::ktx2_transcoder transcoder(&g_basis_global_codebook);
if (transcoder.init(filedata, (uint32_t)filesize))
{
TextureDesc desc;
- desc.BindFlags = BIND_SHADER_RESOURCE;
- desc.Width = transcoder.get_width();
- desc.Height = transcoder.get_height();
- desc.ArraySize = std::max(desc.ArraySize, transcoder.get_layers() * transcoder.get_faces());
- desc.MipLevels = transcoder.get_levels();
+ desc.bind_flags = BindFlag::SHADER_RESOURCE;
+ desc.width = transcoder.get_width();
+ desc.height = transcoder.get_height();
+ desc.array_size = std::max(desc.array_size, transcoder.get_layers() * transcoder.get_faces());
+ desc.mip_levels = transcoder.get_levels();
if (transcoder.get_faces() == 6)
{
- desc.MiscFlags = RESOURCE_MISC_TEXTURECUBE;
+ desc.misc_flags = ResourceMiscFlag::TEXTURECUBE;
}
basist::transcoder_texture_format fmt;
if (transcoder.get_has_alpha())
{
fmt = basist::transcoder_texture_format::cTFBC3_RGBA;
- desc.Format = FORMAT_BC3_UNORM;
+ desc.format = Format::BC3_UNORM;
}
else
{
fmt = basist::transcoder_texture_format::cTFBC1_RGB;
- desc.Format = FORMAT_BC1_UNORM;
+ desc.format = Format::BC1_UNORM;
}
uint32_t bytes_per_block = basis_get_bytes_per_block_or_pixel(fmt);
@@ -198,9 +198,9 @@ namespace wiResourceManager
))
{
SubresourceData subresourceData;
- subresourceData.pData = data_ptr;
- subresourceData.rowPitch = level_info.m_num_blocks_x * bytes_per_block;
- subresourceData.slicePitch = subresourceData.rowPitch * level_info.m_num_blocks_y;
+ subresourceData.data_ptr = data_ptr;
+ subresourceData.row_pitch = level_info.m_num_blocks_x * bytes_per_block;
+ subresourceData.slice_pitch = subresourceData.row_pitch * level_info.m_num_blocks_y;
InitData.push_back(subresourceData);
}
}
@@ -230,21 +230,21 @@ namespace wiResourceManager
if (transcoder.get_image_info(filedata, (uint32_t)filesize, info, image_index))
{
TextureDesc desc;
- desc.BindFlags = BIND_SHADER_RESOURCE;
- desc.Width = info.m_width;
- desc.Height = info.m_height;
- desc.MipLevels = info.m_total_levels;
+ desc.bind_flags = BindFlag::SHADER_RESOURCE;
+ desc.width = info.m_width;
+ desc.height = info.m_height;
+ desc.mip_levels = info.m_total_levels;
basist::transcoder_texture_format fmt;
if (info.m_alpha_flag)
{
fmt = basist::transcoder_texture_format::cTFBC3_RGBA;
- desc.Format = FORMAT_BC3_UNORM;
+ desc.format = Format::BC3_UNORM;
}
else
{
fmt = basist::transcoder_texture_format::cTFBC1_RGB;
- desc.Format = FORMAT_BC1_UNORM;
+ desc.format = Format::BC1_UNORM;
}
uint32_t bytes_per_block = basis_get_bytes_per_block_or_pixel(fmt);
@@ -252,7 +252,7 @@ namespace wiResourceManager
{
// all subresources will use one allocation for transcoder destination, so compute combined size:
size_t transcoded_data_size = 0;
- for (uint32_t mip = 0; mip < desc.MipLevels; ++mip)
+ for (uint32_t mip = 0; mip < desc.mip_levels; ++mip)
{
basist::basisu_image_level_info level_info;
if (transcoder.get_image_level_info(filedata, (uint32_t)filesize, level_info, image_index, mip))
@@ -264,7 +264,7 @@ namespace wiResourceManager
std::vector InitData;
size_t transcoded_data_offset = 0;
- for (uint32_t mip = 0; mip < desc.MipLevels; ++mip)
+ for (uint32_t mip = 0; mip < desc.mip_levels; ++mip)
{
basist::basisu_image_level_info level_info;
if (transcoder.get_image_level_info(filedata, (uint32_t)filesize, level_info, 0, mip))
@@ -280,9 +280,9 @@ namespace wiResourceManager
))
{
SubresourceData subresourceData;
- subresourceData.pData = data_ptr;
- subresourceData.rowPitch = level_info.m_num_blocks_x * bytes_per_block;
- subresourceData.slicePitch = subresourceData.rowPitch * level_info.m_num_blocks_y;
+ subresourceData.data_ptr = data_ptr;
+ subresourceData.row_pitch = level_info.m_num_blocks_x * bytes_per_block;
+ subresourceData.slice_pitch = subresourceData.row_pitch * level_info.m_num_blocks_y;
InitData.push_back(subresourceData);
}
}
@@ -308,99 +308,99 @@ namespace wiResourceManager
if (result == tinyddsloader::Result::Success)
{
TextureDesc desc;
- desc.ArraySize = 1;
- desc.BindFlags = BIND_SHADER_RESOURCE;
- desc.Width = dds.GetWidth();
- desc.Height = dds.GetHeight();
- desc.Depth = dds.GetDepth();
- desc.MipLevels = dds.GetMipCount();
- desc.ArraySize = dds.GetArraySize();
- desc.Format = FORMAT_R8G8B8A8_UNORM;
- desc.layout = RESOURCE_STATE_SHADER_RESOURCE;
+ desc.array_size = 1;
+ desc.bind_flags = BindFlag::SHADER_RESOURCE;
+ desc.width = dds.GetWidth();
+ desc.height = dds.GetHeight();
+ desc.depth = dds.GetDepth();
+ desc.mip_levels = dds.GetMipCount();
+ desc.array_size = dds.GetArraySize();
+ desc.format = Format::R8G8B8A8_UNORM;
+ desc.layout = ResourceState::SHADER_RESOURCE;
if (dds.IsCubemap())
{
- desc.MiscFlags |= RESOURCE_MISC_TEXTURECUBE;
+ desc.misc_flags |= ResourceMiscFlag::TEXTURECUBE;
}
auto ddsFormat = dds.GetFormat();
switch (ddsFormat)
{
- case tinyddsloader::DDSFile::DXGIFormat::R32G32B32A32_Float: desc.Format = FORMAT_R32G32B32A32_FLOAT; break;
- case tinyddsloader::DDSFile::DXGIFormat::R32G32B32A32_UInt: desc.Format = FORMAT_R32G32B32A32_UINT; break;
- case tinyddsloader::DDSFile::DXGIFormat::R32G32B32A32_SInt: desc.Format = FORMAT_R32G32B32A32_SINT; break;
- case tinyddsloader::DDSFile::DXGIFormat::R32G32B32_Float: desc.Format = FORMAT_R32G32B32_FLOAT; break;
- case tinyddsloader::DDSFile::DXGIFormat::R32G32B32_UInt: desc.Format = FORMAT_R32G32B32_UINT; break;
- case tinyddsloader::DDSFile::DXGIFormat::R32G32B32_SInt: desc.Format = FORMAT_R32G32B32_SINT; break;
- case tinyddsloader::DDSFile::DXGIFormat::R16G16B16A16_Float: desc.Format = FORMAT_R16G16B16A16_FLOAT; break;
- case tinyddsloader::DDSFile::DXGIFormat::R16G16B16A16_UNorm: desc.Format = FORMAT_R16G16B16A16_UNORM; break;
- case tinyddsloader::DDSFile::DXGIFormat::R16G16B16A16_UInt: desc.Format = FORMAT_R16G16B16A16_UINT; break;
- case tinyddsloader::DDSFile::DXGIFormat::R16G16B16A16_SNorm: desc.Format = FORMAT_R16G16B16A16_SNORM; break;
- case tinyddsloader::DDSFile::DXGIFormat::R16G16B16A16_SInt: desc.Format = FORMAT_R16G16B16A16_SINT; break;
- case tinyddsloader::DDSFile::DXGIFormat::R32G32_Float: desc.Format = FORMAT_R32G32_FLOAT; break;
- case tinyddsloader::DDSFile::DXGIFormat::R32G32_UInt: desc.Format = FORMAT_R32G32_UINT; break;
- case tinyddsloader::DDSFile::DXGIFormat::R32G32_SInt: desc.Format = FORMAT_R32G32_SINT; break;
- case tinyddsloader::DDSFile::DXGIFormat::R10G10B10A2_UNorm: desc.Format = FORMAT_R10G10B10A2_UNORM; break;
- case tinyddsloader::DDSFile::DXGIFormat::R10G10B10A2_UInt: desc.Format = FORMAT_R10G10B10A2_UINT; break;
- case tinyddsloader::DDSFile::DXGIFormat::R11G11B10_Float: desc.Format = FORMAT_R11G11B10_FLOAT; break;
- case tinyddsloader::DDSFile::DXGIFormat::B8G8R8A8_UNorm: desc.Format = FORMAT_B8G8R8A8_UNORM; break;
- case tinyddsloader::DDSFile::DXGIFormat::B8G8R8A8_UNorm_SRGB: desc.Format = FORMAT_B8G8R8A8_UNORM_SRGB; break;
- case tinyddsloader::DDSFile::DXGIFormat::R8G8B8A8_UNorm: desc.Format = FORMAT_R8G8B8A8_UNORM; break;
- case tinyddsloader::DDSFile::DXGIFormat::R8G8B8A8_UNorm_SRGB: desc.Format = FORMAT_R8G8B8A8_UNORM_SRGB; break;
- case tinyddsloader::DDSFile::DXGIFormat::R8G8B8A8_UInt: desc.Format = FORMAT_R8G8B8A8_UINT; break;
- case tinyddsloader::DDSFile::DXGIFormat::R8G8B8A8_SNorm: desc.Format = FORMAT_R8G8B8A8_SNORM; break;
- case tinyddsloader::DDSFile::DXGIFormat::R8G8B8A8_SInt: desc.Format = FORMAT_R8G8B8A8_SINT; break;
- case tinyddsloader::DDSFile::DXGIFormat::R16G16_Float: desc.Format = FORMAT_R16G16_FLOAT; break;
- case tinyddsloader::DDSFile::DXGIFormat::R16G16_UNorm: desc.Format = FORMAT_R16G16_UNORM; break;
- case tinyddsloader::DDSFile::DXGIFormat::R16G16_UInt: desc.Format = FORMAT_R16G16_UINT; break;
- case tinyddsloader::DDSFile::DXGIFormat::R16G16_SNorm: desc.Format = FORMAT_R16G16_SNORM; break;
- case tinyddsloader::DDSFile::DXGIFormat::R16G16_SInt: desc.Format = FORMAT_R16G16_SINT; break;
- case tinyddsloader::DDSFile::DXGIFormat::D32_Float: desc.Format = FORMAT_D32_FLOAT; break;
- case tinyddsloader::DDSFile::DXGIFormat::R32_Float: desc.Format = FORMAT_R32_FLOAT; break;
- case tinyddsloader::DDSFile::DXGIFormat::R32_UInt: desc.Format = FORMAT_R32_UINT; break;
- case tinyddsloader::DDSFile::DXGIFormat::R32_SInt: desc.Format = FORMAT_R32_SINT; break;
- case tinyddsloader::DDSFile::DXGIFormat::R8G8_UNorm: desc.Format = FORMAT_R8G8_UNORM; break;
- case tinyddsloader::DDSFile::DXGIFormat::R8G8_UInt: desc.Format = FORMAT_R8G8_UINT; break;
- case tinyddsloader::DDSFile::DXGIFormat::R8G8_SNorm: desc.Format = FORMAT_R8G8_SNORM; break;
- case tinyddsloader::DDSFile::DXGIFormat::R8G8_SInt: desc.Format = FORMAT_R8G8_SINT; break;
- case tinyddsloader::DDSFile::DXGIFormat::R16_Float: desc.Format = FORMAT_R16_FLOAT; break;
- case tinyddsloader::DDSFile::DXGIFormat::D16_UNorm: desc.Format = FORMAT_D16_UNORM; break;
- case tinyddsloader::DDSFile::DXGIFormat::R16_UNorm: desc.Format = FORMAT_R16_UNORM; break;
- case tinyddsloader::DDSFile::DXGIFormat::R16_UInt: desc.Format = FORMAT_R16_UINT; break;
- case tinyddsloader::DDSFile::DXGIFormat::R16_SNorm: desc.Format = FORMAT_R16_SNORM; break;
- case tinyddsloader::DDSFile::DXGIFormat::R16_SInt: desc.Format = FORMAT_R16_SINT; break;
- case tinyddsloader::DDSFile::DXGIFormat::R8_UNorm: desc.Format = FORMAT_R8_UNORM; break;
- case tinyddsloader::DDSFile::DXGIFormat::R8_UInt: desc.Format = FORMAT_R8_UINT; break;
- case tinyddsloader::DDSFile::DXGIFormat::R8_SNorm: desc.Format = FORMAT_R8_SNORM; break;
- case tinyddsloader::DDSFile::DXGIFormat::R8_SInt: desc.Format = FORMAT_R8_SINT; break;
- case tinyddsloader::DDSFile::DXGIFormat::BC1_UNorm: desc.Format = FORMAT_BC1_UNORM; break;
- case tinyddsloader::DDSFile::DXGIFormat::BC1_UNorm_SRGB: desc.Format = FORMAT_BC1_UNORM_SRGB; break;
- case tinyddsloader::DDSFile::DXGIFormat::BC2_UNorm: desc.Format = FORMAT_BC2_UNORM; break;
- case tinyddsloader::DDSFile::DXGIFormat::BC2_UNorm_SRGB: desc.Format = FORMAT_BC2_UNORM_SRGB; break;
- case tinyddsloader::DDSFile::DXGIFormat::BC3_UNorm: desc.Format = FORMAT_BC3_UNORM; break;
- case tinyddsloader::DDSFile::DXGIFormat::BC3_UNorm_SRGB: desc.Format = FORMAT_BC3_UNORM_SRGB; break;
- case tinyddsloader::DDSFile::DXGIFormat::BC4_UNorm: desc.Format = FORMAT_BC4_UNORM; break;
- case tinyddsloader::DDSFile::DXGIFormat::BC4_SNorm: desc.Format = FORMAT_BC4_SNORM; break;
- case tinyddsloader::DDSFile::DXGIFormat::BC5_UNorm: desc.Format = FORMAT_BC5_UNORM; break;
- case tinyddsloader::DDSFile::DXGIFormat::BC5_SNorm: desc.Format = FORMAT_BC5_SNORM; break;
- case tinyddsloader::DDSFile::DXGIFormat::BC7_UNorm: desc.Format = FORMAT_BC7_UNORM; break;
- case tinyddsloader::DDSFile::DXGIFormat::BC7_UNorm_SRGB: desc.Format = FORMAT_BC7_UNORM_SRGB; break;
+ case tinyddsloader::DDSFile::DXGIFormat::R32G32B32A32_Float: desc.format = Format::R32G32B32A32_FLOAT; break;
+ case tinyddsloader::DDSFile::DXGIFormat::R32G32B32A32_UInt: desc.format = Format::R32G32B32A32_UINT; break;
+ case tinyddsloader::DDSFile::DXGIFormat::R32G32B32A32_SInt: desc.format = Format::R32G32B32A32_SINT; break;
+ case tinyddsloader::DDSFile::DXGIFormat::R32G32B32_Float: desc.format = Format::R32G32B32_FLOAT; break;
+ case tinyddsloader::DDSFile::DXGIFormat::R32G32B32_UInt: desc.format = Format::R32G32B32_UINT; break;
+ case tinyddsloader::DDSFile::DXGIFormat::R32G32B32_SInt: desc.format = Format::R32G32B32_SINT; break;
+ case tinyddsloader::DDSFile::DXGIFormat::R16G16B16A16_Float: desc.format = Format::R16G16B16A16_FLOAT; break;
+ case tinyddsloader::DDSFile::DXGIFormat::R16G16B16A16_UNorm: desc.format = Format::R16G16B16A16_UNORM; break;
+ case tinyddsloader::DDSFile::DXGIFormat::R16G16B16A16_UInt: desc.format = Format::R16G16B16A16_UINT; break;
+ case tinyddsloader::DDSFile::DXGIFormat::R16G16B16A16_SNorm: desc.format = Format::R16G16B16A16_SNORM; break;
+ case tinyddsloader::DDSFile::DXGIFormat::R16G16B16A16_SInt: desc.format = Format::R16G16B16A16_SINT; break;
+ case tinyddsloader::DDSFile::DXGIFormat::R32G32_Float: desc.format = Format::R32G32_FLOAT; break;
+ case tinyddsloader::DDSFile::DXGIFormat::R32G32_UInt: desc.format = Format::R32G32_UINT; break;
+ case tinyddsloader::DDSFile::DXGIFormat::R32G32_SInt: desc.format = Format::R32G32_SINT; break;
+ case tinyddsloader::DDSFile::DXGIFormat::R10G10B10A2_UNorm: desc.format = Format::R10G10B10A2_UNORM; break;
+ case tinyddsloader::DDSFile::DXGIFormat::R10G10B10A2_UInt: desc.format = Format::R10G10B10A2_UINT; break;
+ case tinyddsloader::DDSFile::DXGIFormat::R11G11B10_Float: desc.format = Format::R11G11B10_FLOAT; break;
+ case tinyddsloader::DDSFile::DXGIFormat::B8G8R8A8_UNorm: desc.format = Format::B8G8R8A8_UNORM; break;
+ case tinyddsloader::DDSFile::DXGIFormat::B8G8R8A8_UNorm_SRGB: desc.format = Format::B8G8R8A8_UNORM_SRGB; break;
+ case tinyddsloader::DDSFile::DXGIFormat::R8G8B8A8_UNorm: desc.format = Format::R8G8B8A8_UNORM; break;
+ case tinyddsloader::DDSFile::DXGIFormat::R8G8B8A8_UNorm_SRGB: desc.format = Format::R8G8B8A8_UNORM_SRGB; break;
+ case tinyddsloader::DDSFile::DXGIFormat::R8G8B8A8_UInt: desc.format = Format::R8G8B8A8_UINT; break;
+ case tinyddsloader::DDSFile::DXGIFormat::R8G8B8A8_SNorm: desc.format = Format::R8G8B8A8_SNORM; break;
+ case tinyddsloader::DDSFile::DXGIFormat::R8G8B8A8_SInt: desc.format = Format::R8G8B8A8_SINT; break;
+ case tinyddsloader::DDSFile::DXGIFormat::R16G16_Float: desc.format = Format::R16G16_FLOAT; break;
+ case tinyddsloader::DDSFile::DXGIFormat::R16G16_UNorm: desc.format = Format::R16G16_UNORM; break;
+ case tinyddsloader::DDSFile::DXGIFormat::R16G16_UInt: desc.format = Format::R16G16_UINT; break;
+ case tinyddsloader::DDSFile::DXGIFormat::R16G16_SNorm: desc.format = Format::R16G16_SNORM; break;
+ case tinyddsloader::DDSFile::DXGIFormat::R16G16_SInt: desc.format = Format::R16G16_SINT; break;
+ case tinyddsloader::DDSFile::DXGIFormat::D32_Float: desc.format = Format::D32_FLOAT; break;
+ case tinyddsloader::DDSFile::DXGIFormat::R32_Float: desc.format = Format::R32_FLOAT; break;
+ case tinyddsloader::DDSFile::DXGIFormat::R32_UInt: desc.format = Format::R32_UINT; break;
+ case tinyddsloader::DDSFile::DXGIFormat::R32_SInt: desc.format = Format::R32_SINT; break;
+ case tinyddsloader::DDSFile::DXGIFormat::R8G8_UNorm: desc.format = Format::R8G8_UNORM; break;
+ case tinyddsloader::DDSFile::DXGIFormat::R8G8_UInt: desc.format = Format::R8G8_UINT; break;
+ case tinyddsloader::DDSFile::DXGIFormat::R8G8_SNorm: desc.format = Format::R8G8_SNORM; break;
+ case tinyddsloader::DDSFile::DXGIFormat::R8G8_SInt: desc.format = Format::R8G8_SINT; break;
+ case tinyddsloader::DDSFile::DXGIFormat::R16_Float: desc.format = Format::R16_FLOAT; break;
+ case tinyddsloader::DDSFile::DXGIFormat::D16_UNorm: desc.format = Format::D16_UNORM; break;
+ case tinyddsloader::DDSFile::DXGIFormat::R16_UNorm: desc.format = Format::R16_UNORM; break;
+ case tinyddsloader::DDSFile::DXGIFormat::R16_UInt: desc.format = Format::R16_UINT; break;
+ case tinyddsloader::DDSFile::DXGIFormat::R16_SNorm: desc.format = Format::R16_SNORM; break;
+ case tinyddsloader::DDSFile::DXGIFormat::R16_SInt: desc.format = Format::R16_SINT; break;
+ case tinyddsloader::DDSFile::DXGIFormat::R8_UNorm: desc.format = Format::R8_UNORM; break;
+ case tinyddsloader::DDSFile::DXGIFormat::R8_UInt: desc.format = Format::R8_UINT; break;
+ case tinyddsloader::DDSFile::DXGIFormat::R8_SNorm: desc.format = Format::R8_SNORM; break;
+ case tinyddsloader::DDSFile::DXGIFormat::R8_SInt: desc.format = Format::R8_SINT; break;
+ case tinyddsloader::DDSFile::DXGIFormat::BC1_UNorm: desc.format = Format::BC1_UNORM; break;
+ case tinyddsloader::DDSFile::DXGIFormat::BC1_UNorm_SRGB: desc.format = Format::BC1_UNORM_SRGB; break;
+ case tinyddsloader::DDSFile::DXGIFormat::BC2_UNorm: desc.format = Format::BC2_UNORM; break;
+ case tinyddsloader::DDSFile::DXGIFormat::BC2_UNorm_SRGB: desc.format = Format::BC2_UNORM_SRGB; break;
+ case tinyddsloader::DDSFile::DXGIFormat::BC3_UNorm: desc.format = Format::BC3_UNORM; break;
+ case tinyddsloader::DDSFile::DXGIFormat::BC3_UNorm_SRGB: desc.format = Format::BC3_UNORM_SRGB; break;
+ case tinyddsloader::DDSFile::DXGIFormat::BC4_UNorm: desc.format = Format::BC4_UNORM; break;
+ case tinyddsloader::DDSFile::DXGIFormat::BC4_SNorm: desc.format = Format::BC4_SNORM; break;
+ case tinyddsloader::DDSFile::DXGIFormat::BC5_UNorm: desc.format = Format::BC5_UNORM; break;
+ case tinyddsloader::DDSFile::DXGIFormat::BC5_SNorm: desc.format = Format::BC5_SNORM; break;
+ case tinyddsloader::DDSFile::DXGIFormat::BC7_UNorm: desc.format = Format::BC7_UNORM; break;
+ case tinyddsloader::DDSFile::DXGIFormat::BC7_UNorm_SRGB: desc.format = Format::BC7_UNORM_SRGB; break;
default:
assert(0); // incoming format is not supported
break;
}
std::vector InitData;
- for (uint32_t arrayIndex = 0; arrayIndex < desc.ArraySize; ++arrayIndex)
+ for (uint32_t arrayIndex = 0; arrayIndex < desc.array_size; ++arrayIndex)
{
- for (uint32_t mip = 0; mip < desc.MipLevels; ++mip)
+ for (uint32_t mip = 0; mip < desc.mip_levels; ++mip)
{
auto imageData = dds.GetImageData(mip, arrayIndex);
SubresourceData subresourceData;
- subresourceData.pData = imageData->m_mem;
- subresourceData.rowPitch = imageData->m_memPitch;
- subresourceData.slicePitch = imageData->m_memSlicePitch;
+ subresourceData.data_ptr = imageData->m_mem;
+ subresourceData.row_pitch = imageData->m_memPitch;
+ subresourceData.slice_pitch = imageData->m_memSlicePitch;
InitData.push_back(subresourceData);
}
}
@@ -410,17 +410,17 @@ namespace wiResourceManager
{
case tinyddsloader::DDSFile::TextureDimension::Texture1D:
{
- desc.type = TextureDesc::TEXTURE_1D;
+ desc.type = TextureDesc::Type::TEXTURE_1D;
}
break;
case tinyddsloader::DDSFile::TextureDimension::Texture2D:
{
- desc.type = TextureDesc::TEXTURE_2D;
+ desc.type = TextureDesc::Type::TEXTURE_2D;
}
break;
case tinyddsloader::DDSFile::TextureDimension::Texture3D:
{
- desc.type = TextureDesc::TEXTURE_3D;
+ desc.type = TextureDesc::Type::TEXTURE_3D;
}
break;
default:
@@ -428,10 +428,10 @@ namespace wiResourceManager
break;
}
- if (IsFormatBlockCompressed(desc.Format))
+ if (IsFormatBlockCompressed(desc.format))
{
- desc.Width = std::max(GetFormatBlockSize(desc.Format), desc.Width);
- desc.Height = std::max(GetFormatBlockSize(desc.Format), desc.Height);
+ desc.width = std::max(GetFormatBlockSize(desc.format), desc.width);
+ desc.height = std::max(GetFormatBlockSize(desc.format), desc.height);
}
success = device->CreateTexture(&desc, InitData.data(), &resource->texture);
@@ -451,15 +451,15 @@ namespace wiResourceManager
if (rgb != nullptr)
{
TextureDesc desc;
- desc.Height = uint32_t(height);
- desc.Width = uint32_t(width);
- desc.layout = RESOURCE_STATE_SHADER_RESOURCE;
+ desc.height = uint32_t(height);
+ desc.width = uint32_t(width);
+ desc.layout = ResourceState::SHADER_RESOURCE;
if (flags & IMPORT_COLORGRADINGLUT)
{
- if (desc.type != TextureDesc::TEXTURE_2D ||
- desc.Width != 256 ||
- desc.Height != 16)
+ if (desc.type != TextureDesc::Type::TEXTURE_2D ||
+ desc.width != 256 ||
+ desc.height != 16)
{
wiHelper::messageBox("The Dimensions must be 256 x 16 for color grading LUT!", "Error");
}
@@ -479,46 +479,46 @@ namespace wiResourceManager
}
}
- desc.type = TextureDesc::TEXTURE_3D;
- desc.Width = 16;
- desc.Height = 16;
- desc.Depth = 16;
- desc.Format = FORMAT_R8G8B8A8_UNORM;
- desc.BindFlags = BIND_SHADER_RESOURCE;
+ desc.type = TextureDesc::Type::TEXTURE_3D;
+ desc.width = 16;
+ desc.height = 16;
+ desc.depth = 16;
+ desc.format = Format::R8G8B8A8_UNORM;
+ desc.bind_flags = BindFlag::SHADER_RESOURCE;
SubresourceData InitData;
- InitData.pData = data;
- InitData.rowPitch = 16 * sizeof(uint32_t);
- InitData.slicePitch = 16 * InitData.rowPitch;
+ InitData.data_ptr = data;
+ InitData.row_pitch = 16 * sizeof(uint32_t);
+ InitData.slice_pitch = 16 * InitData.row_pitch;
success = device->CreateTexture(&desc, &InitData, &resource->texture);
device->SetName(&resource->texture, name.c_str());
}
}
else
{
- desc.BindFlags = BIND_SHADER_RESOURCE | BIND_UNORDERED_ACCESS;
- desc.Format = FORMAT_R8G8B8A8_UNORM;
- desc.MipLevels = (uint32_t)log2(std::max(width, height)) + 1;
- desc.Usage = USAGE_DEFAULT;
- desc.layout = RESOURCE_STATE_SHADER_RESOURCE;
+ desc.bind_flags = BindFlag::SHADER_RESOURCE | BindFlag::UNORDERED_ACCESS;
+ desc.format = Format::R8G8B8A8_UNORM;
+ desc.mip_levels = (uint32_t)log2(std::max(width, height)) + 1;
+ desc.usage = Usage::DEFAULT;
+ desc.layout = ResourceState::SHADER_RESOURCE;
uint32_t mipwidth = width;
- std::vector InitData(desc.MipLevels);
- for (uint32_t mip = 0; mip < desc.MipLevels; ++mip)
+ std::vector InitData(desc.mip_levels);
+ for (uint32_t mip = 0; mip < desc.mip_levels; ++mip)
{
- InitData[mip].pData = rgb; // attention! we don't fill the mips here correctly, just always point to the mip0 data by default. Mip levels will be created using compute shader when needed!
- InitData[mip].rowPitch = static_cast(mipwidth * channelCount);
+ InitData[mip].data_ptr = rgb; // attention! we don't fill the mips here correctly, just always point to the mip0 data by default. Mip levels will be created using compute shader when needed!
+ InitData[mip].row_pitch = static_cast(mipwidth * channelCount);
mipwidth = std::max(1u, mipwidth / 2);
}
success = device->CreateTexture(&desc, InitData.data(), &resource->texture);
device->SetName(&resource->texture, name.c_str());
- for (uint32_t i = 0; i < resource->texture.desc.MipLevels; ++i)
+ for (uint32_t i = 0; i < resource->texture.desc.mip_levels; ++i)
{
int subresource_index;
- subresource_index = device->CreateSubresource(&resource->texture, SRV, 0, 1, i, 1);
+ subresource_index = device->CreateSubresource(&resource->texture, SubresourceType::SRV, 0, 1, i, 1);
assert(subresource_index == i);
- subresource_index = device->CreateSubresource(&resource->texture, UAV, 0, 1, i, 1);
+ subresource_index = device->CreateSubresource(&resource->texture, SubresourceType::UAV, 0, 1, i, 1);
assert(subresource_index == i);
}
}
@@ -551,7 +551,8 @@ namespace wiResourceManager
resource->filedata.clear();
}
- if (type == wiResource::IMAGE && resource->texture.desc.MipLevels > 1 && resource->texture.desc.BindFlags & BIND_UNORDERED_ACCESS)
+ if (type == wiResource::IMAGE && resource->texture.desc.mip_levels > 1
+ && has_flag(resource->texture.desc.bind_flags, BindFlag::UNORDERED_ACCESS))
{
wiRenderer::AddDeferredMIPGen(resource, true);
}
diff --git a/WickedEngine/wiScene.cpp b/WickedEngine/wiScene.cpp
index 7ba9bbdec..f8dd51d9a 100644
--- a/WickedEngine/wiScene.cpp
+++ b/WickedEngine/wiScene.cpp
@@ -321,20 +321,20 @@ namespace wiScene
}
dest->options = options; // ensure that this memory is not read, so bitwise ORs also not performed with it!
- GraphicsDevice* device = wiRenderer::GetDevice();
- dest->texture_basecolormap_index = device->GetDescriptorIndex(textures[BASECOLORMAP].GetGPUResource(), SRV);
- dest->texture_surfacemap_index = device->GetDescriptorIndex(textures[SURFACEMAP].GetGPUResource(), SRV);
- dest->texture_emissivemap_index = device->GetDescriptorIndex(textures[EMISSIVEMAP].GetGPUResource(), SRV);
- dest->texture_normalmap_index = device->GetDescriptorIndex(textures[NORMALMAP].GetGPUResource(), SRV);
- dest->texture_displacementmap_index = device->GetDescriptorIndex(textures[DISPLACEMENTMAP].GetGPUResource(), SRV);
- dest->texture_occlusionmap_index = device->GetDescriptorIndex(textures[OCCLUSIONMAP].GetGPUResource(), SRV);
- dest->texture_transmissionmap_index = device->GetDescriptorIndex(textures[TRANSMISSIONMAP].GetGPUResource(), SRV);
- dest->texture_sheencolormap_index = device->GetDescriptorIndex(textures[SHEENCOLORMAP].GetGPUResource(), SRV);
- dest->texture_sheenroughnessmap_index = device->GetDescriptorIndex(textures[SHEENROUGHNESSMAP].GetGPUResource(), SRV);
- dest->texture_clearcoatmap_index = device->GetDescriptorIndex(textures[CLEARCOATMAP].GetGPUResource(), SRV);
- dest->texture_clearcoatroughnessmap_index = device->GetDescriptorIndex(textures[CLEARCOATROUGHNESSMAP].GetGPUResource(), SRV);
- dest->texture_clearcoatnormalmap_index = device->GetDescriptorIndex(textures[CLEARCOATNORMALMAP].GetGPUResource(), SRV);
- dest->texture_specularmap_index = device->GetDescriptorIndex(textures[SPECULARMAP].GetGPUResource(), SRV);
+ GraphicsDevice* device = wiGraphics::GetDevice();
+ dest->texture_basecolormap_index = device->GetDescriptorIndex(textures[BASECOLORMAP].GetGPUResource(), SubresourceType::SRV);
+ dest->texture_surfacemap_index = device->GetDescriptorIndex(textures[SURFACEMAP].GetGPUResource(), SubresourceType::SRV);
+ dest->texture_emissivemap_index = device->GetDescriptorIndex(textures[EMISSIVEMAP].GetGPUResource(), SubresourceType::SRV);
+ dest->texture_normalmap_index = device->GetDescriptorIndex(textures[NORMALMAP].GetGPUResource(), SubresourceType::SRV);
+ dest->texture_displacementmap_index = device->GetDescriptorIndex(textures[DISPLACEMENTMAP].GetGPUResource(), SubresourceType::SRV);
+ dest->texture_occlusionmap_index = device->GetDescriptorIndex(textures[OCCLUSIONMAP].GetGPUResource(), SubresourceType::SRV);
+ dest->texture_transmissionmap_index = device->GetDescriptorIndex(textures[TRANSMISSIONMAP].GetGPUResource(), SubresourceType::SRV);
+ dest->texture_sheencolormap_index = device->GetDescriptorIndex(textures[SHEENCOLORMAP].GetGPUResource(), SubresourceType::SRV);
+ dest->texture_sheenroughnessmap_index = device->GetDescriptorIndex(textures[SHEENROUGHNESSMAP].GetGPUResource(), SubresourceType::SRV);
+ dest->texture_clearcoatmap_index = device->GetDescriptorIndex(textures[CLEARCOATMAP].GetGPUResource(), SubresourceType::SRV);
+ dest->texture_clearcoatroughnessmap_index = device->GetDescriptorIndex(textures[CLEARCOATROUGHNESSMAP].GetGPUResource(), SubresourceType::SRV);
+ dest->texture_clearcoatnormalmap_index = device->GetDescriptorIndex(textures[CLEARCOATNORMALMAP].GetGPUResource(), SubresourceType::SRV);
+ dest->texture_specularmap_index = device->GetDescriptorIndex(textures[SPECULARMAP].GetGPUResource(), SubresourceType::SRV);
}
void MaterialComponent::WriteTextures(const wiGraphics::GPUResource** dest, int count) const
@@ -383,7 +383,7 @@ namespace wiScene
void MeshComponent::CreateRenderData()
{
- GraphicsDevice* device = wiRenderer::GetDevice();
+ GraphicsDevice* device = wiGraphics::GetDevice();
vertex_subsets.resize(vertex_positions.size());
uint32_t subsetCounter = 0;
@@ -400,29 +400,29 @@ namespace wiScene
// Create index buffer GPU data:
{
GPUBufferDesc bd;
- bd.BindFlags = BIND_INDEX_BUFFER | BIND_SHADER_RESOURCE;
- if (device->CheckCapability(GRAPHICSDEVICE_CAPABILITY_RAYTRACING))
+ bd.bind_flags = BindFlag::INDEX_BUFFER | BindFlag::SHADER_RESOURCE;
+ if (device->CheckCapability(GraphicsDeviceCapability::RAYTRACING))
{
- bd.MiscFlags |= RESOURCE_MISC_RAY_TRACING;
+ bd.misc_flags |= ResourceMiscFlag::RAY_TRACING;
}
- if (GetIndexFormat() == INDEXFORMAT_32BIT)
+ if (GetIndexFormat() == IndexBufferFormat::UINT32)
{
- bd.Stride = sizeof(uint32_t);
- bd.Format = FORMAT_R32_UINT;
- bd.Size = uint32_t(sizeof(uint32_t) * indices.size());
+ bd.stride = sizeof(uint32_t);
+ bd.format = Format::R32_UINT;
+ bd.size = uint32_t(sizeof(uint32_t) * indices.size());
// Use indices directly since vector is in correct format
- static_assert(std::is_same::value, "indices not in INDEXFORMAT_32BIT");
+ static_assert(std::is_same::value, "indices not in IndexBufferFormat::UINT32");
device->CreateBuffer(&bd, indices.data(), &indexBuffer);
device->SetName(&indexBuffer, "indexBuffer_32bit");
}
else
{
- bd.Stride = sizeof(uint16_t);
- bd.Format = FORMAT_R16_UINT;
- bd.Size = uint32_t(sizeof(uint16_t) * indices.size());
+ bd.stride = sizeof(uint16_t);
+ bd.format = Format::R16_UINT;
+ bd.size = uint32_t(sizeof(uint16_t) * indices.size());
std::vector gpuIndexData(indices.size());
std::copy(indices.begin(), indices.end(), gpuIndexData.begin());
@@ -458,14 +458,14 @@ namespace wiScene
}
GPUBufferDesc bd;
- bd.Usage = USAGE_DEFAULT;
- bd.BindFlags = BIND_VERTEX_BUFFER | BIND_SHADER_RESOURCE;
- bd.MiscFlags = RESOURCE_MISC_BUFFER_RAW;
- if (device->CheckCapability(GRAPHICSDEVICE_CAPABILITY_RAYTRACING))
+ bd.usage = Usage::DEFAULT;
+ bd.bind_flags = BindFlag::VERTEX_BUFFER | BindFlag::SHADER_RESOURCE;
+ bd.misc_flags = ResourceMiscFlag::BUFFER_RAW;
+ if (device->CheckCapability(GraphicsDeviceCapability::RAYTRACING))
{
- bd.MiscFlags |= RESOURCE_MISC_RAY_TRACING;
+ bd.misc_flags |= ResourceMiscFlag::RAY_TRACING;
}
- bd.Size = (uint32_t)(sizeof(Vertex_POS) * vertices.size());
+ bd.size = (uint32_t)(sizeof(Vertex_POS) * vertices.size());
device->CreateBuffer(&bd, vertices.data(), &vertexBuffer_POS);
device->SetName(&vertexBuffer_POS, "vertexBuffer_POS");
@@ -553,11 +553,11 @@ namespace wiScene
}
GPUBufferDesc bd;
- bd.Usage = USAGE_DEFAULT;
- bd.BindFlags = BIND_VERTEX_BUFFER | BIND_SHADER_RESOURCE;
- bd.MiscFlags = RESOURCE_MISC_BUFFER_RAW;
- bd.Stride = sizeof(Vertex_TAN);
- bd.Size = (uint32_t)(bd.Stride * vertices.size());
+ bd.usage = Usage::DEFAULT;
+ bd.bind_flags = BindFlag::VERTEX_BUFFER | BindFlag::SHADER_RESOURCE;
+ bd.misc_flags = ResourceMiscFlag::BUFFER_RAW;
+ bd.stride = sizeof(Vertex_TAN);
+ bd.size = (uint32_t)(bd.stride * vertices.size());
device->CreateBuffer(&bd, vertices.data(), &vertexBuffer_TAN);
device->SetName(&vertexBuffer_TAN, "vertexBuffer_TAN");
@@ -585,27 +585,27 @@ namespace wiScene
}
GPUBufferDesc bd;
- bd.BindFlags = BIND_SHADER_RESOURCE;
- bd.MiscFlags = RESOURCE_MISC_BUFFER_RAW;
- bd.Size = (uint32_t)(sizeof(Vertex_BON) * vertices.size());
+ bd.bind_flags = BindFlag::SHADER_RESOURCE;
+ bd.misc_flags = ResourceMiscFlag::BUFFER_RAW;
+ bd.size = (uint32_t)(sizeof(Vertex_BON) * vertices.size());
device->CreateBuffer(&bd, vertices.data(), &vertexBuffer_BON);
- bd.Usage = USAGE_DEFAULT;
- bd.BindFlags = BIND_VERTEX_BUFFER | BIND_UNORDERED_ACCESS | BIND_SHADER_RESOURCE;
- bd.MiscFlags = RESOURCE_MISC_BUFFER_RAW;
+ bd.usage = Usage::DEFAULT;
+ bd.bind_flags = BindFlag::VERTEX_BUFFER | BindFlag::UNORDERED_ACCESS | BindFlag::SHADER_RESOURCE;
+ bd.misc_flags = ResourceMiscFlag::BUFFER_RAW;
if (!vertex_tangents.empty())
{
- bd.Size = (uint32_t)(sizeof(Vertex_TAN) * vertex_tangents.size());
+ bd.size = (uint32_t)(sizeof(Vertex_TAN) * vertex_tangents.size());
device->CreateBuffer(&bd, nullptr, &streamoutBuffer_TAN);
device->SetName(&streamoutBuffer_TAN, "streamoutBuffer_TAN");
}
- bd.Size = (uint32_t)(sizeof(Vertex_POS) * vertex_positions.size());
- if (device->CheckCapability(GRAPHICSDEVICE_CAPABILITY_RAYTRACING))
+ bd.size = (uint32_t)(sizeof(Vertex_POS) * vertex_positions.size());
+ if (device->CheckCapability(GraphicsDeviceCapability::RAYTRACING))
{
- bd.MiscFlags |= RESOURCE_MISC_RAY_TRACING;
+ bd.misc_flags |= ResourceMiscFlag::RAY_TRACING;
}
device->CreateBuffer(&bd, nullptr, &streamoutBuffer_POS);
device->SetName(&streamoutBuffer_POS, "streamoutBuffer_POS");
@@ -621,10 +621,10 @@ namespace wiScene
}
GPUBufferDesc bd;
- bd.BindFlags = BIND_VERTEX_BUFFER | BIND_SHADER_RESOURCE;
- bd.MiscFlags = RESOURCE_MISC_BUFFER_RAW;
- bd.Stride = sizeof(Vertex_TEX);
- bd.Size = (uint32_t)(bd.Stride * vertices.size());
+ bd.bind_flags = BindFlag::VERTEX_BUFFER | BindFlag::SHADER_RESOURCE;
+ bd.misc_flags = ResourceMiscFlag::BUFFER_RAW;
+ bd.stride = sizeof(Vertex_TEX);
+ bd.size = (uint32_t)(bd.stride * vertices.size());
device->CreateBuffer(&bd, vertices.data(), &vertexBuffer_UV0);
device->SetName(&vertexBuffer_UV0, "vertexBuffer_UV0");
@@ -640,10 +640,10 @@ namespace wiScene
}
GPUBufferDesc bd;
- bd.BindFlags = BIND_VERTEX_BUFFER | BIND_SHADER_RESOURCE;
- bd.MiscFlags = RESOURCE_MISC_BUFFER_RAW;
- bd.Stride = sizeof(Vertex_TEX);
- bd.Size = (uint32_t)(bd.Stride * vertices.size());
+ bd.bind_flags = BindFlag::VERTEX_BUFFER | BindFlag::SHADER_RESOURCE;
+ bd.misc_flags = ResourceMiscFlag::BUFFER_RAW;
+ bd.stride = sizeof(Vertex_TEX);
+ bd.size = (uint32_t)(bd.stride * vertices.size());
device->CreateBuffer(&bd, vertices.data(), &vertexBuffer_UV1);
device->SetName(&vertexBuffer_UV1, "vertexBuffer_UV1");
@@ -653,10 +653,10 @@ namespace wiScene
if (!vertex_colors.empty())
{
GPUBufferDesc bd;
- bd.BindFlags = BIND_VERTEX_BUFFER | BIND_SHADER_RESOURCE;
- bd.MiscFlags = RESOURCE_MISC_BUFFER_RAW;
- bd.Stride = sizeof(Vertex_COL);
- bd.Size = (uint32_t)(bd.Stride * vertex_colors.size());
+ bd.bind_flags = BindFlag::VERTEX_BUFFER | BindFlag::SHADER_RESOURCE;
+ bd.misc_flags = ResourceMiscFlag::BUFFER_RAW;
+ bd.stride = sizeof(Vertex_COL);
+ bd.size = (uint32_t)(bd.stride * vertex_colors.size());
device->CreateBuffer(&bd, vertex_colors.data(), &vertexBuffer_COL);
device->SetName(&vertexBuffer_COL, "vertexBuffer_COL");
@@ -672,10 +672,10 @@ namespace wiScene
}
GPUBufferDesc bd;
- bd.BindFlags = BIND_VERTEX_BUFFER | BIND_SHADER_RESOURCE;
- bd.MiscFlags = RESOURCE_MISC_BUFFER_RAW;
- bd.Stride = sizeof(Vertex_TEX);
- bd.Size = (uint32_t)(bd.Stride * vertices.size());
+ bd.bind_flags = BindFlag::VERTEX_BUFFER | BindFlag::SHADER_RESOURCE;
+ bd.misc_flags = ResourceMiscFlag::BUFFER_RAW;
+ bd.stride = sizeof(Vertex_TEX);
+ bd.size = (uint32_t)(bd.stride * vertices.size());
device->CreateBuffer(&bd, vertices.data(), &vertexBuffer_ATL);
device->SetName(&vertexBuffer_ATL, "vertexBuffer_ATL");
@@ -685,45 +685,45 @@ namespace wiScene
vertexBuffer_PRE = GPUBuffer();
GPUBufferDesc desc;
- desc.BindFlags = BIND_SHADER_RESOURCE;
- desc.MiscFlags = RESOURCE_MISC_BUFFER_RAW;
- desc.Stride = sizeof(ShaderMeshSubset);
- desc.Size = desc.Stride * (uint32_t)subsets.size();
+ desc.bind_flags = BindFlag::SHADER_RESOURCE;
+ desc.misc_flags = ResourceMiscFlag::BUFFER_RAW;
+ desc.stride = sizeof(ShaderMeshSubset);
+ desc.size = desc.stride * (uint32_t)subsets.size();
bool success = device->CreateBuffer(&desc, nullptr, &subsetBuffer);
assert(success);
dirty_subsets = true;
- if (device->CheckCapability(GRAPHICSDEVICE_CAPABILITY_RAYTRACING))
+ if (device->CheckCapability(GraphicsDeviceCapability::RAYTRACING))
{
BLAS_state = MeshComponent::BLAS_STATE_NEEDS_REBUILD;
RaytracingAccelerationStructureDesc desc;
- desc.type = RaytracingAccelerationStructureDesc::BOTTOMLEVEL;
+ desc.type = RaytracingAccelerationStructureDesc::Type::BOTTOMLEVEL;
if (streamoutBuffer_POS.IsValid())
{
- desc._flags |= RaytracingAccelerationStructureDesc::FLAG_ALLOW_UPDATE;
- desc._flags |= RaytracingAccelerationStructureDesc::FLAG_PREFER_FAST_BUILD;
+ desc.flags |= RaytracingAccelerationStructureDesc::FLAG_ALLOW_UPDATE;
+ desc.flags |= RaytracingAccelerationStructureDesc::FLAG_PREFER_FAST_BUILD;
}
else
{
- desc._flags |= RaytracingAccelerationStructureDesc::FLAG_PREFER_FAST_TRACE;
+ desc.flags |= RaytracingAccelerationStructureDesc::FLAG_PREFER_FAST_TRACE;
}
for (auto& subset : subsets)
{
- desc.bottomlevel.geometries.emplace_back();
- auto& geometry = desc.bottomlevel.geometries.back();
- geometry.type = RaytracingAccelerationStructureDesc::BottomLevel::Geometry::TRIANGLES;
- geometry.triangles.vertexBuffer = streamoutBuffer_POS.IsValid() ? streamoutBuffer_POS : vertexBuffer_POS;
- geometry.triangles.indexBuffer = indexBuffer;
- geometry.triangles.indexFormat = GetIndexFormat();
- geometry.triangles.indexCount = subset.indexCount;
- geometry.triangles.indexOffset = subset.indexOffset;
- geometry.triangles.vertexCount = (uint32_t)vertex_positions.size();
- geometry.triangles.vertexFormat = FORMAT_R32G32B32_FLOAT;
- geometry.triangles.vertexStride = sizeof(MeshComponent::Vertex_POS);
+ desc.bottom_level.geometries.emplace_back();
+ auto& geometry = desc.bottom_level.geometries.back();
+ geometry.type = RaytracingAccelerationStructureDesc::BottomLevel::Geometry::Type::TRIANGLES;
+ geometry.triangles.vertex_buffer = streamoutBuffer_POS.IsValid() ? streamoutBuffer_POS : vertexBuffer_POS;
+ geometry.triangles.index_buffer = indexBuffer;
+ geometry.triangles.index_format = GetIndexFormat();
+ geometry.triangles.index_count = subset.indexCount;
+ geometry.triangles.index_offset = subset.indexOffset;
+ geometry.triangles.vertex_count = (uint32_t)vertex_positions.size();
+ geometry.triangles.vertex_format = Format::R32G32B32_FLOAT;
+ geometry.triangles.vertex_stride = sizeof(MeshComponent::Vertex_POS);
}
bool success = device->CreateRaytracingAccelerationStructure(&desc, &BLAS);
@@ -734,33 +734,33 @@ namespace wiScene
void MeshComponent::WriteShaderMesh(ShaderMesh* dest) const
{
dest->init();
- GraphicsDevice* device = wiRenderer::GetDevice();
- dest->ib = device->GetDescriptorIndex(&indexBuffer, SRV);
+ GraphicsDevice* device = wiGraphics::GetDevice();
+ dest->ib = device->GetDescriptorIndex(&indexBuffer, SubresourceType::SRV);
if (streamoutBuffer_POS.IsValid())
{
- dest->vb_pos_nor_wind = device->GetDescriptorIndex(&streamoutBuffer_POS, SRV);
+ dest->vb_pos_nor_wind = device->GetDescriptorIndex(&streamoutBuffer_POS, SubresourceType::SRV);
}
else
{
- dest->vb_pos_nor_wind = device->GetDescriptorIndex(&vertexBuffer_POS, SRV);
+ dest->vb_pos_nor_wind = device->GetDescriptorIndex(&vertexBuffer_POS, SubresourceType::SRV);
}
if (streamoutBuffer_TAN.IsValid())
{
- dest->vb_tan = device->GetDescriptorIndex(&streamoutBuffer_TAN, SRV);
+ dest->vb_tan = device->GetDescriptorIndex(&streamoutBuffer_TAN, SubresourceType::SRV);
}
else
{
- dest->vb_tan = device->GetDescriptorIndex(&vertexBuffer_TAN, SRV);
+ dest->vb_tan = device->GetDescriptorIndex(&vertexBuffer_TAN, SubresourceType::SRV);
}
- dest->vb_col = device->GetDescriptorIndex(&vertexBuffer_COL, SRV);
- dest->vb_uv0 = device->GetDescriptorIndex(&vertexBuffer_UV0, SRV);
- dest->vb_uv1 = device->GetDescriptorIndex(&vertexBuffer_UV1, SRV);
- dest->vb_atl = device->GetDescriptorIndex(&vertexBuffer_ATL, SRV);
- dest->vb_pre = device->GetDescriptorIndex(&vertexBuffer_PRE, SRV);
+ dest->vb_col = device->GetDescriptorIndex(&vertexBuffer_COL, SubresourceType::SRV);
+ dest->vb_uv0 = device->GetDescriptorIndex(&vertexBuffer_UV0, SubresourceType::SRV);
+ dest->vb_uv1 = device->GetDescriptorIndex(&vertexBuffer_UV1, SubresourceType::SRV);
+ dest->vb_atl = device->GetDescriptorIndex(&vertexBuffer_ATL, SubresourceType::SRV);
+ dest->vb_pre = device->GetDescriptorIndex(&vertexBuffer_PRE, SubresourceType::SRV);
dest->blendmaterial1 = terrain_material1_index;
dest->blendmaterial2 = terrain_material2_index;
dest->blendmaterial3 = terrain_material3_index;
- dest->subsetbuffer = device->GetDescriptorIndex(&subsetBuffer, SRV);
+ dest->subsetbuffer = device->GetDescriptorIndex(&subsetBuffer, SubresourceType::SRV);
dest->aabb_min = aabb._min;
dest->aabb_max = aabb._max;
dest->tessellation_factor = tessellationFactor;
@@ -1168,7 +1168,7 @@ namespace wiScene
#endif
void ObjectComponent::SaveLightmap()
{
- if (lightmap.IsValid() && (lightmap.desc.BindFlags & BIND_RENDER_TARGET))
+ if (lightmap.IsValid() && has_flag(lightmap.desc.bind_flags, BindFlag::RENDER_TARGET))
{
SetLightmapRenderRequest(false);
@@ -1218,8 +1218,8 @@ namespace wiScene
CompressLightmap();
- wiTextureHelper::CreateTexture(lightmap, lightmapTextureData.data(), lightmapWidth, lightmapHeight, lightmap.desc.Format);
- wiRenderer::GetDevice()->SetName(&lightmap, "lightmap");
+ wiTextureHelper::CreateTexture(lightmap, lightmapTextureData.data(), lightmapWidth, lightmapHeight, lightmap.desc.format);
+ wiGraphics::GetDevice()->SetName(&lightmap, "lightmap");
}
}
void ObjectComponent::CompressLightmap()
@@ -1231,7 +1231,7 @@ namespace wiScene
wiBackLog::post("compressing lightmap...");
lightmap.desc.Format = lightmap_block_format;
- lightmap.desc.BindFlags = BIND_SHADER_RESOURCE;
+ lightmap.desc.BindFlags = BindFlag::SHADER_RESOURCE;
static constexpr wiGraphics::FORMAT lightmap_block_format = wiGraphics::FORMAT_BC6H_UF16;
static constexpr uint32_t lightmap_blocksize = wiGraphics::GetFormatBlockSize(lightmap_block_format);
@@ -1291,21 +1291,21 @@ namespace wiScene
}
lightmapTextureData = std::move(packed_data);
- lightmap.desc.Format = FORMAT_R11G11B10_FLOAT;
- lightmap.desc.BindFlags = BIND_SHADER_RESOURCE;
+ lightmap.desc.format = Format::R11G11B10_FLOAT;
+ lightmap.desc.bind_flags = BindFlag::SHADER_RESOURCE;
#endif
}
void ArmatureComponent::CreateRenderData()
{
- GraphicsDevice* device = wiRenderer::GetDevice();
+ GraphicsDevice* device = wiGraphics::GetDevice();
GPUBufferDesc bd;
- bd.Size = sizeof(ShaderTransform) * (uint32_t)boneCollection.size();
- bd.BindFlags = BIND_SHADER_RESOURCE;
- bd.MiscFlags = RESOURCE_MISC_BUFFER_RAW;
- bd.Stride = sizeof(ShaderTransform);
+ bd.size = sizeof(ShaderTransform) * (uint32_t)boneCollection.size();
+ bd.bind_flags = BindFlag::SHADER_RESOURCE;
+ bd.misc_flags = ResourceMiscFlag::BUFFER_RAW;
+ bd.stride = sizeof(ShaderTransform);
device->CreateBuffer(&bd, nullptr, &boneBuffer);
}
@@ -1462,22 +1462,22 @@ namespace wiScene
{
this->dt = dt;
- GraphicsDevice* device = wiRenderer::GetDevice();
+ GraphicsDevice* device = wiGraphics::GetDevice();
instanceArraySize = objects.GetCount() + hairs.GetCount() + emitters.GetCount();
- if (instanceBuffer.desc.Size < (instanceArraySize * sizeof(ShaderMeshInstance)))
+ if (instanceBuffer.desc.size < (instanceArraySize * sizeof(ShaderMeshInstance)))
{
GPUBufferDesc desc;
- desc.Stride = sizeof(ShaderMeshInstance);
- desc.Size = desc.Stride * instanceArraySize;
- desc.BindFlags = BIND_SHADER_RESOURCE;
- desc.MiscFlags = RESOURCE_MISC_BUFFER_RAW;
+ desc.stride = sizeof(ShaderMeshInstance);
+ desc.size = desc.stride * instanceArraySize;
+ desc.bind_flags = BindFlag::SHADER_RESOURCE;
+ desc.misc_flags = ResourceMiscFlag::BUFFER_RAW;
device->CreateBuffer(&desc, nullptr, &instanceBuffer);
device->SetName(&instanceBuffer, "instanceBuffer");
- desc.Usage = USAGE_UPLOAD;
- desc.BindFlags = BIND_NONE;
- desc.MiscFlags = RESOURCE_MISC_NONE;
+ desc.usage = Usage::UPLOAD;
+ desc.bind_flags = BindFlag::NONE;
+ desc.misc_flags = ResourceMiscFlag::NONE;
for (int i = 0; i < arraysize(instanceUploadBuffer); ++i)
{
device->CreateBuffer(&desc, nullptr, &instanceUploadBuffer[i]);
@@ -1487,19 +1487,19 @@ namespace wiScene
instanceArrayMapped = (ShaderMeshInstance*)instanceUploadBuffer[device->GetBufferIndex()].mapped_data;
meshArraySize = meshes.GetCount() + hairs.GetCount() + emitters.GetCount();
- if (meshBuffer.desc.Size < (meshArraySize * sizeof(ShaderMesh)))
+ if (meshBuffer.desc.size < (meshArraySize * sizeof(ShaderMesh)))
{
GPUBufferDesc desc;
- desc.Stride = sizeof(ShaderMesh);
- desc.Size = desc.Stride * meshArraySize;
- desc.BindFlags = BIND_SHADER_RESOURCE;
- desc.MiscFlags = RESOURCE_MISC_BUFFER_RAW;
+ desc.stride = sizeof(ShaderMesh);
+ desc.size = desc.stride * meshArraySize;
+ desc.bind_flags = BindFlag::SHADER_RESOURCE;
+ desc.misc_flags = ResourceMiscFlag::BUFFER_RAW;
device->CreateBuffer(&desc, nullptr, &meshBuffer);
device->SetName(&meshBuffer, "meshBuffer");
- desc.Usage = USAGE_UPLOAD;
- desc.BindFlags = BIND_NONE;
- desc.MiscFlags = RESOURCE_MISC_NONE;
+ desc.usage = Usage::UPLOAD;
+ desc.bind_flags = BindFlag::NONE;
+ desc.misc_flags = ResourceMiscFlag::NONE;
for (int i = 0; i < arraysize(meshUploadBuffer); ++i)
{
device->CreateBuffer(&desc, nullptr, &meshUploadBuffer[i]);
@@ -1509,19 +1509,19 @@ namespace wiScene
meshArrayMapped = (ShaderMesh*)meshUploadBuffer[device->GetBufferIndex()].mapped_data;
materialArraySize = materials.GetCount();
- if (materialBuffer.desc.Size < (materialArraySize * sizeof(ShaderMaterial)))
+ if (materialBuffer.desc.size < (materialArraySize * sizeof(ShaderMaterial)))
{
GPUBufferDesc desc;
- desc.Stride = sizeof(ShaderMaterial);
- desc.Size = desc.Stride * materialArraySize;
- desc.BindFlags = BIND_SHADER_RESOURCE;
- desc.MiscFlags = RESOURCE_MISC_BUFFER_RAW;
+ desc.stride = sizeof(ShaderMaterial);
+ desc.size = desc.stride * materialArraySize;
+ desc.bind_flags = BindFlag::SHADER_RESOURCE;
+ desc.misc_flags = ResourceMiscFlag::BUFFER_RAW;
device->CreateBuffer(&desc, nullptr, &materialBuffer);
device->SetName(&materialBuffer, "materialBuffer");
- desc.Usage = USAGE_UPLOAD;
- desc.BindFlags = BIND_NONE;
- desc.MiscFlags = RESOURCE_MISC_NONE;
+ desc.usage = Usage::UPLOAD;
+ desc.bind_flags = BindFlag::NONE;
+ desc.misc_flags = ResourceMiscFlag::NONE;
for (int i = 0; i < arraysize(materialUploadBuffer); ++i)
{
device->CreateBuffer(&desc, nullptr, &materialUploadBuffer[i]);
@@ -1531,13 +1531,13 @@ namespace wiScene
materialArrayMapped = (ShaderMaterial*)materialUploadBuffer[device->GetBufferIndex()].mapped_data;
TLAS_instancesMapped = nullptr;
- if (device->CheckCapability(GRAPHICSDEVICE_CAPABILITY_RAYTRACING))
+ if (device->CheckCapability(GraphicsDeviceCapability::RAYTRACING))
{
GPUBufferDesc desc;
- desc.Stride = (uint32_t)device->GetTopLevelAccelerationStructureInstanceSize();
- desc.Size = desc.Stride * instanceArraySize;
- desc.Usage = USAGE_UPLOAD;
- if (TLAS_instancesUpload->desc.Size < desc.Size)
+ desc.stride = (uint32_t)device->GetTopLevelAccelerationStructureInstanceSize();
+ desc.size = desc.stride * instanceArraySize;
+ desc.usage = Usage::UPLOAD;
+ if (TLAS_instancesUpload->desc.size < desc.size)
{
for (int i = 0; i < arraysize(TLAS_instancesUpload); ++i)
{
@@ -1552,17 +1552,17 @@ namespace wiScene
if(wiRenderer::GetOcclusionCullingEnabled() && !wiRenderer::GetFreezeCullingCameraEnabled())
{
uint32_t minQueryCount = uint32_t(objects.GetCount() + lights.GetCount());
- if (queryHeap.desc.queryCount < minQueryCount)
+ if (queryHeap.desc.query_count < minQueryCount)
{
GPUQueryHeapDesc desc;
- desc.type = GPU_QUERY_TYPE_OCCLUSION_BINARY;
- desc.queryCount = minQueryCount;
+ desc.type = GpuQueryType::OCCLUSION_BINARY;
+ desc.query_count = minQueryCount;
bool success = device->CreateQueryHeap(&desc, &queryHeap);
assert(success);
GPUBufferDesc bd;
- bd.Usage = USAGE_READBACK;
- bd.Size = desc.queryCount * sizeof(uint64_t);
+ bd.usage = Usage::READBACK;
+ bd.size = desc.query_count * sizeof(uint64_t);
for (int i = 0; i < arraysize(queryResultBuffer); ++i)
{
@@ -1570,10 +1570,10 @@ namespace wiScene
assert(success);
}
- if (device->CheckCapability(GRAPHICSDEVICE_CAPABILITY_PREDICATION))
+ if (device->CheckCapability(GraphicsDeviceCapability::PREDICATION))
{
- bd.Usage = USAGE_DEFAULT;
- bd.MiscFlags |= RESOURCE_MISC_PREDICATION;
+ bd.usage = Usage::DEFAULT;
+ bd.misc_flags |= ResourceMiscFlag::PREDICATION;
success = device->CreateBuffer(&bd, nullptr, &queryPredicationBuffer);
assert(success);
}
@@ -1646,29 +1646,29 @@ namespace wiScene
SetAccelerationStructureUpdateRequested(true);
}
- if (device->CheckCapability(GRAPHICSDEVICE_CAPABILITY_RAYTRACING))
+ if (device->CheckCapability(GraphicsDeviceCapability::RAYTRACING))
{
// Recreate top level acceleration structure if the object count changed:
- if (instanceArraySize > 0 && (uint32_t)instanceArraySize != TLAS.desc.toplevel.count)
+ if (instanceArraySize > 0 && (uint32_t)instanceArraySize != TLAS.desc.top_level.count)
{
RaytracingAccelerationStructureDesc desc;
- desc._flags = RaytracingAccelerationStructureDesc::FLAG_PREFER_FAST_BUILD;
- desc.type = RaytracingAccelerationStructureDesc::TOPLEVEL;
- desc.toplevel.count = (uint32_t)instanceArraySize;
+ desc.flags = RaytracingAccelerationStructureDesc::FLAG_PREFER_FAST_BUILD;
+ desc.type = RaytracingAccelerationStructureDesc::Type::TOPLEVEL;
+ desc.top_level.count = (uint32_t)instanceArraySize;
GPUBufferDesc bufdesc;
- bufdesc.MiscFlags |= RESOURCE_MISC_RAY_TRACING;
- bufdesc.Stride = (uint32_t)device->GetTopLevelAccelerationStructureInstanceSize();
- bufdesc.Size = bufdesc.Stride * desc.toplevel.count;
- bool success = device->CreateBuffer(&bufdesc, nullptr, &desc.toplevel.instanceBuffer);
+ bufdesc.misc_flags |= ResourceMiscFlag::RAY_TRACING;
+ bufdesc.stride = (uint32_t)device->GetTopLevelAccelerationStructureInstanceSize();
+ bufdesc.size = bufdesc.stride * desc.top_level.count;
+ bool success = device->CreateBuffer(&bufdesc, nullptr, &desc.top_level.instance_buffer);
assert(success);
- device->SetName(&desc.toplevel.instanceBuffer, "TLAS.instanceBuffer");
+ device->SetName(&desc.top_level.instance_buffer, "TLAS.instanceBuffer");
success = device->CreateRaytracingAccelerationStructure(&desc, &TLAS);
assert(success);
device->SetName(&TLAS, "TLAS");
}
}
- if (!device->CheckCapability(GRAPHICSDEVICE_CAPABILITY_RAYTRACING) && IsAccelerationStructureUpdateRequested())
+ if (!device->CheckCapability(GraphicsDeviceCapability::RAYTRACING) && IsAccelerationStructureUpdateRequested())
{
BVH.Update(*this);
}
@@ -1693,22 +1693,22 @@ namespace wiScene
if (!surfelBuffer.IsValid())
{
GPUBufferDesc desc;
- desc.Stride = sizeof(Surfel);
- desc.Size = desc.Stride * SURFEL_CAPACITY;
- desc.MiscFlags = RESOURCE_MISC_BUFFER_STRUCTURED;
- desc.BindFlags = BIND_SHADER_RESOURCE | BIND_UNORDERED_ACCESS;
+ desc.stride = sizeof(Surfel);
+ desc.size = desc.stride * SURFEL_CAPACITY;
+ desc.misc_flags = ResourceMiscFlag::BUFFER_STRUCTURED;
+ desc.bind_flags = BindFlag::SHADER_RESOURCE | BindFlag::UNORDERED_ACCESS;
device->CreateBuffer(&desc, nullptr, &surfelBuffer);
device->SetName(&surfelBuffer, "surfelBuffer");
- desc.Stride = sizeof(SurfelData);
- desc.Size = desc.Stride * SURFEL_CAPACITY;
- desc.MiscFlags = RESOURCE_MISC_BUFFER_STRUCTURED;
+ desc.stride = sizeof(SurfelData);
+ desc.size = desc.stride * SURFEL_CAPACITY;
+ desc.misc_flags = ResourceMiscFlag::BUFFER_STRUCTURED;
device->CreateBuffer(&desc, nullptr, &surfelDataBuffer);
device->SetName(&surfelDataBuffer, "surfelDataBuffer");
- desc.Stride = sizeof(uint);
- desc.Size = desc.Stride * SURFEL_CAPACITY;
- desc.MiscFlags = RESOURCE_MISC_BUFFER_STRUCTURED;
+ desc.stride = sizeof(uint);
+ desc.size = desc.stride * SURFEL_CAPACITY;
+ desc.misc_flags = ResourceMiscFlag::BUFFER_STRUCTURED;
device->CreateBuffer(&desc, nullptr, &surfelAliveBuffer[0]);
device->SetName(&surfelAliveBuffer[0], "surfelAliveBuffer[0]");
device->CreateBuffer(&desc, nullptr, &surfelAliveBuffer[1]);
@@ -1722,30 +1722,30 @@ namespace wiScene
device->CreateBuffer(&desc, dead_indices.data(), &surfelDeadBuffer);
device->SetName(&surfelDeadBuffer, "surfelDeadBuffer");
- desc.Stride = sizeof(uint);
- desc.Size = desc.Stride * 9; // count (1 uint), nextCount (1 uint), deadCount (1 uint), cellAllocator (1 uint), IndirectDispatchArgs (3 uints), raycount (1 uint), shortage (1 uint)
- desc.MiscFlags = RESOURCE_MISC_BUFFER_RAW | RESOURCE_MISC_INDIRECT_ARGS;
+ desc.stride = sizeof(uint);
+ desc.size = desc.stride * 9; // count (1 uint), nextCount (1 uint), deadCount (1 uint), cellAllocator (1 uint), IndirectDispatchArgs (3 uints), raycount (1 uint), shortage (1 uint)
+ desc.misc_flags = ResourceMiscFlag::BUFFER_RAW | ResourceMiscFlag::INDIRECT_ARGS;
uint stats_data[] = { 0,0,SURFEL_CAPACITY,0,0,0,0,0,0 };
device->CreateBuffer(&desc, &stats_data, &surfelStatsBuffer);
device->SetName(&surfelStatsBuffer, "surfelStatsBuffer");
- desc.Stride = sizeof(SurfelGridCell);
- desc.Size = desc.Stride * SURFEL_TABLE_SIZE;
- desc.MiscFlags = RESOURCE_MISC_BUFFER_STRUCTURED;
+ desc.stride = sizeof(SurfelGridCell);
+ desc.size = desc.stride * SURFEL_TABLE_SIZE;
+ desc.misc_flags = ResourceMiscFlag::BUFFER_STRUCTURED;
device->CreateBuffer(&desc, nullptr, &surfelGridBuffer);
device->SetName(&surfelGridBuffer, "surfelGridBuffer");
- desc.Stride = sizeof(uint);
- desc.Size = desc.Stride * SURFEL_CAPACITY * 27; // each surfel can be in 3x3x3=27 cells
- desc.MiscFlags = RESOURCE_MISC_BUFFER_STRUCTURED;
+ desc.stride = sizeof(uint);
+ desc.size = desc.stride * SURFEL_CAPACITY * 27; // each surfel can be in 3x3x3=27 cells
+ desc.misc_flags = ResourceMiscFlag::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;
+ tex.width = SURFEL_MOMENT_ATLAS_TEXELS;
+ tex.height = SURFEL_MOMENT_ATLAS_TEXELS;
+ tex.format = Format::R16G16_FLOAT;
+ tex.bind_flags = BindFlag::UNORDERED_ACCESS | BindFlag::SHADER_RESOURCE;
device->CreateTexture(&tex, nullptr, &surfelMomentsTexture[0]);
device->SetName(&surfelMomentsTexture[0], "surfelMomentsTexture[0]");
device->CreateTexture(&tex, nullptr, &surfelMomentsTexture[1]);
@@ -1757,22 +1757,22 @@ namespace wiScene
// Shader scene resources:
- shaderscene.instancebuffer = device->GetDescriptorIndex(&instanceBuffer, SRV);
- shaderscene.meshbuffer = device->GetDescriptorIndex(&meshBuffer, SRV);
- shaderscene.materialbuffer = device->GetDescriptorIndex(&materialBuffer, SRV);
- shaderscene.envmaparray = device->GetDescriptorIndex(&envmapArray, SRV);
+ shaderscene.instancebuffer = device->GetDescriptorIndex(&instanceBuffer, SubresourceType::SRV);
+ shaderscene.meshbuffer = device->GetDescriptorIndex(&meshBuffer, SubresourceType::SRV);
+ shaderscene.materialbuffer = device->GetDescriptorIndex(&materialBuffer, SubresourceType::SRV);
+ shaderscene.envmaparray = device->GetDescriptorIndex(&envmapArray, SubresourceType::SRV);
if (weather.skyMap == nullptr)
{
shaderscene.globalenvmap = -1;
}
else
{
- shaderscene.globalenvmap = device->GetDescriptorIndex(&weather.skyMap->texture, SRV);
+ shaderscene.globalenvmap = device->GetDescriptorIndex(&weather.skyMap->texture, SubresourceType::SRV);
}
- shaderscene.TLAS = device->GetDescriptorIndex(&TLAS, SRV);
- shaderscene.BVH_counter = device->GetDescriptorIndex(&BVH.primitiveCounterBuffer, SRV);
- shaderscene.BVH_nodes = device->GetDescriptorIndex(&BVH.bvhNodeBuffer, SRV);
- shaderscene.BVH_primitives = device->GetDescriptorIndex(&BVH.primitiveBuffer, SRV);
+ shaderscene.TLAS = device->GetDescriptorIndex(&TLAS, SubresourceType::SRV);
+ shaderscene.BVH_counter = device->GetDescriptorIndex(&BVH.primitiveCounterBuffer, SubresourceType::SRV);
+ shaderscene.BVH_nodes = device->GetDescriptorIndex(&BVH.bvhNodeBuffer, SubresourceType::SRV);
+ shaderscene.BVH_primitives = device->GetDescriptorIndex(&BVH.primitiveBuffer, SubresourceType::SRV);
shaderscene.aabb_min = bounds.getMin();
shaderscene.aabb_max = bounds.getMax();
@@ -2853,7 +2853,7 @@ namespace wiScene
armature.aabb = AABB(_min, _max);
- if (!armature.boneBuffer.IsValid() || armature.boneBuffer.desc.Size != armature.boneData.size() * sizeof(ShaderTransform))
+ if (!armature.boneBuffer.IsValid() || armature.boneBuffer.desc.size != armature.boneData.size() * sizeof(ShaderTransform))
{
armature.CreateRenderData();
}
@@ -2865,7 +2865,7 @@ namespace wiScene
Entity entity = meshes.GetEntity(args.jobIndex);
MeshComponent& mesh = meshes[args.jobIndex];
- GraphicsDevice* device = wiRenderer::GetDevice();
+ GraphicsDevice* device = wiGraphics::GetDevice();
if (!mesh.vertexBuffer_PRE.IsValid())
{
@@ -2899,24 +2899,24 @@ namespace wiScene
subset.materialIndex = (uint32_t)materials.GetIndex(subset.materialID);
if (mesh.BLAS.IsValid())
{
- auto& geometry = mesh.BLAS.desc.bottomlevel.geometries[subsetIndex];
- uint32_t flags = geometry._flags;
+ auto& geometry = mesh.BLAS.desc.bottom_level.geometries[subsetIndex];
+ uint32_t flags = geometry.flags;
if (material->IsAlphaTestEnabled() || (material->GetRenderTypes() & RENDERTYPE_TRANSPARENT) || !material->IsCastingShadow())
{
- geometry._flags &= ~RaytracingAccelerationStructureDesc::BottomLevel::Geometry::FLAG_OPAQUE;
+ geometry.flags &= ~RaytracingAccelerationStructureDesc::BottomLevel::Geometry::FLAG_OPAQUE;
}
else
{
- geometry._flags = RaytracingAccelerationStructureDesc::BottomLevel::Geometry::FLAG_OPAQUE;
+ geometry.flags = RaytracingAccelerationStructureDesc::BottomLevel::Geometry::FLAG_OPAQUE;
}
- if (flags != geometry._flags)
+ if (flags != geometry.flags)
{
mesh.BLAS_state = MeshComponent::BLAS_STATE_NEEDS_REBUILD;
}
if (mesh.streamoutBuffer_POS.IsValid())
{
mesh.BLAS_state = MeshComponent::BLAS_STATE_NEEDS_REBUILD;
- geometry.triangles.vertexBuffer = mesh.streamoutBuffer_POS;
+ geometry.triangles.vertex_buffer = mesh.streamoutBuffer_POS;
}
if (material->IsDoubleSided())
{
@@ -3024,40 +3024,40 @@ namespace wiScene
{
if (impostors.GetCount() > 0 && !impostorArray.IsValid())
{
- GraphicsDevice* device = wiRenderer::GetDevice();
+ GraphicsDevice* device = wiGraphics::GetDevice();
TextureDesc desc;
- desc.Width = impostorTextureDim;
- desc.Height = impostorTextureDim;
+ desc.width = impostorTextureDim;
+ desc.height = impostorTextureDim;
- desc.BindFlags = BIND_DEPTH_STENCIL;
- desc.ArraySize = 1;
- desc.Format = FORMAT_D16_UNORM;
- desc.layout = RESOURCE_STATE_DEPTHSTENCIL;
+ desc.bind_flags = BindFlag::DEPTH_STENCIL;
+ desc.array_size = 1;
+ desc.format = Format::D16_UNORM;
+ desc.layout = ResourceState::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 = RESOURCE_STATE_SHADER_RESOURCE;
+ desc.bind_flags = BindFlag::RENDER_TARGET | BindFlag::SHADER_RESOURCE | BindFlag::UNORDERED_ACCESS;
+ desc.array_size = maxImpostorCount * impostorCaptureAngles * 3;
+ desc.format = Format::R8G8B8A8_UNORM;
+ desc.layout = ResourceState::SHADER_RESOURCE;
device->CreateTexture(&desc, nullptr, &impostorArray);
device->SetName(&impostorArray, "impostorArray");
- renderpasses_impostor.resize(desc.ArraySize);
+ renderpasses_impostor.resize(desc.array_size);
- for (uint32_t i = 0; i < desc.ArraySize; ++i)
+ for (uint32_t i = 0; i < desc.array_size; ++i)
{
int subresource_index;
- subresource_index = device->CreateSubresource(&impostorArray, RTV, i, 1, 0, 1);
+ subresource_index = device->CreateSubresource(&impostorArray, SubresourceType::RTV, i, 1, 0, 1);
assert(subresource_index == i);
RenderPassDesc renderpassdesc;
renderpassdesc.attachments.push_back(
RenderPassAttachment::RenderTarget(
&impostorArray,
- RenderPassAttachment::LOADOP_CLEAR
+ RenderPassAttachment::LoadOp::CLEAR
)
);
renderpassdesc.attachments.back().subresource = subresource_index;
@@ -3065,8 +3065,8 @@ namespace wiScene
renderpassdesc.attachments.push_back(
RenderPassAttachment::DepthStencil(
&impostorDepthStencil,
- RenderPassAttachment::LOADOP_CLEAR,
- RenderPassAttachment::STOREOP_DONTCARE
+ RenderPassAttachment::LoadOp::CLEAR,
+ RenderPassAttachment::StoreOp::DONTCARE
)
);
@@ -3224,7 +3224,7 @@ namespace wiScene
XMFLOAT4X4 transformIT;
XMStoreFloat4x4(&transformIT, worldMatrixInverseTranspose);
- GraphicsDevice* device = wiRenderer::GetDevice();
+ GraphicsDevice* device = wiGraphics::GetDevice();
ShaderMeshInstance& inst = instanceArrayMapped[args.jobIndex];
inst.init();
inst.transform.Create(worldMatrix);
@@ -3232,7 +3232,7 @@ namespace wiScene
inst.transformPrev.Create(worldMatrixPrev);
if (object.lightmap.IsValid())
{
- inst.lightmap = device->GetDescriptorIndex(&object.lightmap, SRV);
+ inst.lightmap = device->GetDescriptorIndex(&object.lightmap, SubresourceType::SRV);
}
inst.uid = entity;
inst.color = wiMath::CompressColor(object.color);
@@ -3249,20 +3249,20 @@ namespace wiScene
worldMatrix._12, worldMatrix._22, worldMatrix._32, worldMatrix._42,
worldMatrix._13, worldMatrix._23, worldMatrix._33, worldMatrix._43
);
- instance.InstanceID = args.jobIndex;
- instance.InstanceMask = 1;
- instance.bottomlevel = mesh->BLAS;
+ instance.instance_id = args.jobIndex;
+ instance.instance_mask = 1;
+ instance.bottom_level = mesh->BLAS;
if (mesh->IsDoubleSided() || mesh->_flags & MeshComponent::TLAS_FORCE_DOUBLE_SIDED)
{
- instance.Flags |= RaytracingAccelerationStructureDesc::TopLevel::Instance::FLAG_TRIANGLE_CULL_DISABLE;
+ 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_instancesMapped + (size_t)args.jobIndex * device->GetTopLevelAccelerationStructureInstanceSize());
@@ -3278,23 +3278,23 @@ namespace wiScene
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;
+ desc.width = object.lightmapWidth;
+ desc.height = object.lightmapHeight;
+ desc.bind_flags = BindFlag::RENDER_TARGET | BindFlag::SHADER_RESOURCE;
// Note: we need the full precision format to achieve correct accumulative blending!
// But the final lightmap will be compressed into an optimal format when the rendering is finished
- desc.Format = FORMAT_R32G32B32A32_FLOAT;
+ desc.format = Format::R32G32B32A32_FLOAT;
device->CreateTexture(&desc, nullptr, &object.lightmap);
device->SetName(&object.lightmap, "lightmap_renderable");
RenderPassDesc renderpassdesc;
- renderpassdesc.attachments.push_back(RenderPassAttachment::RenderTarget(&object.lightmap, RenderPassAttachment::LOADOP_CLEAR));
+ 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;
+ renderpassdesc.attachments.back().loadop = RenderPassAttachment::LoadOp::LOAD;
device->CreateRenderPass(&renderpassdesc, &object.renderpass_lightmap_accumulate);
object.lightmapIterationCount = 0; // reset accumulation
@@ -3305,8 +3305,8 @@ namespace wiScene
if (!object.lightmapTextureData.empty() && !object.lightmap.IsValid())
{
// Create a GPU-side per object lighmap if there is none yet, but the data exists already:
- object.lightmap.desc.Format = FORMAT_R11G11B10_FLOAT;
- wiTextureHelper::CreateTexture(object.lightmap, object.lightmapTextureData.data(), object.lightmapWidth, object.lightmapHeight, object.lightmap.desc.Format);
+ object.lightmap.desc.format = Format::R11G11B10_FLOAT;
+ wiTextureHelper::CreateTexture(object.lightmap, object.lightmapTextureData.data(), object.lightmapWidth, object.lightmapHeight, object.lightmap.desc.format);
device->SetName(&object.lightmap, "lightmap");
}
}
@@ -3403,31 +3403,31 @@ namespace wiScene
if (!envmapArray.IsValid()) // even when zero probes, this will be created, since sometimes only the sky will be rendered into it
{
- GraphicsDevice* device = wiRenderer::GetDevice();
+ GraphicsDevice* device = wiGraphics::GetDevice();
TextureDesc desc;
- desc.ArraySize = 6;
- desc.BindFlags = BIND_DEPTH_STENCIL;
- 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 = RESOURCE_STATE_DEPTHSTENCIL;
+ desc.array_size = 6;
+ desc.bind_flags = BindFlag::DEPTH_STENCIL;
+ desc.format = Format::D16_UNORM;
+ desc.height = envmapRes;
+ desc.width = envmapRes;
+ desc.mip_levels = 1;
+ desc.misc_flags = ResourceMiscFlag::TEXTURECUBE;
+ desc.usage = Usage::DEFAULT;
+ desc.layout = ResourceState::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.Format = FORMAT_R11G11B10_FLOAT;
- desc.Height = envmapRes;
- desc.Width = envmapRes;
- desc.MipLevels = envmapMIPs;
- desc.MiscFlags = RESOURCE_MISC_TEXTURECUBE;
- desc.Usage = USAGE_DEFAULT;
- desc.layout = RESOURCE_STATE_SHADER_RESOURCE;
+ desc.array_size = envmapCount * 6;
+ desc.bind_flags = BindFlag::SHADER_RESOURCE | BindFlag::RENDER_TARGET | BindFlag::UNORDERED_ACCESS;
+ desc.format = Format::R11G11B10_FLOAT;
+ desc.height = envmapRes;
+ desc.width = envmapRes;
+ desc.mip_levels = envmapMIPs;
+ desc.misc_flags = ResourceMiscFlag::TEXTURECUBE;
+ desc.usage = Usage::DEFAULT;
+ desc.layout = ResourceState::SHADER_RESOURCE;
device->CreateTexture(&desc, nullptr, &envmapArray);
device->SetName(&envmapArray, "envmapArray");
@@ -3437,13 +3437,13 @@ namespace wiScene
for (uint32_t i = 0; i < envmapCount; ++i)
{
int subresource_index;
- subresource_index = device->CreateSubresource(&envmapArray, RTV, i * 6, 6, 0, 1);
+ subresource_index = device->CreateSubresource(&envmapArray, SubresourceType::RTV, i * 6, 6, 0, 1);
assert(subresource_index == i);
RenderPassDesc renderpassdesc;
renderpassdesc.attachments.push_back(
RenderPassAttachment::RenderTarget(&envmapArray,
- RenderPassAttachment::LOADOP_DONTCARE
+ RenderPassAttachment::LoadOp::DONTCARE
)
);
renderpassdesc.attachments.back().subresource = subresource_index;
@@ -3451,19 +3451,19 @@ namespace wiScene
renderpassdesc.attachments.push_back(
RenderPassAttachment::DepthStencil(
&envrenderingDepthBuffer,
- RenderPassAttachment::LOADOP_CLEAR,
- RenderPassAttachment::STOREOP_DONTCARE
+ RenderPassAttachment::LoadOp::CLEAR,
+ RenderPassAttachment::StoreOp::DONTCARE
)
);
device->CreateRenderPass(&renderpassdesc, &renderpasses_envmap[subresource_index]);
}
- for (uint32_t i = 0; i < envmapArray.desc.MipLevels; ++i)
+ for (uint32_t i = 0; i < envmapArray.desc.mip_levels; ++i)
{
int subresource_index;
- subresource_index = device->CreateSubresource(&envmapArray, SRV, 0, desc.ArraySize, i, 1);
+ subresource_index = device->CreateSubresource(&envmapArray, SubresourceType::SRV, 0, desc.array_size, i, 1);
assert(subresource_index == i);
- subresource_index = device->CreateSubresource(&envmapArray, UAV, 0, desc.ArraySize, i, 1);
+ subresource_index = device->CreateSubresource(&envmapArray, SubresourceType::UAV, 0, desc.array_size, i, 1);
assert(subresource_index == i);
}
@@ -3471,8 +3471,8 @@ namespace wiScene
for (uint32_t i = 0; i < envmapCount; ++i)
{
int subresource_index;
- subresource_index = device->CreateSubresource(&envmapArray, SRV, i * 6, 6, 0, -1);
- assert(subresource_index == envmapArray.desc.MipLevels + i);
+ subresource_index = device->CreateSubresource(&envmapArray, SubresourceType::SRV, i * 6, 6, 0, -1);
+ assert(subresource_index == envmapArray.desc.mip_levels + i);
}
}
@@ -3645,16 +3645,16 @@ namespace wiScene
hair.UpdateCPU(transform, *mesh, dt);
- GraphicsDevice* device = wiRenderer::GetDevice();
+ GraphicsDevice* device = wiGraphics::GetDevice();
size_t meshIndex = meshes.GetCount() + args.jobIndex;
ShaderMesh& mesh = meshArrayMapped[meshIndex];
mesh.init();
- 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.ib = device->GetDescriptorIndex(&hair.primitiveBuffer, SubresourceType::SRV);
+ mesh.vb_pos_nor_wind = device->GetDescriptorIndex(&hair.vertexBuffer_POS[0], SubresourceType::SRV);
+ mesh.vb_pre = device->GetDescriptorIndex(&hair.vertexBuffer_POS[1], SubresourceType::SRV);
+ mesh.vb_uv0 = device->GetDescriptorIndex(&hair.vertexBuffer_TEX, SubresourceType::SRV);
+ mesh.subsetbuffer = device->GetDescriptorIndex(&hair.subsetBuffer, SubresourceType::SRV);
mesh.flags = SHADERMESH_FLAG_DOUBLE_SIDED | SHADERMESH_FLAG_HAIRPARTICLE;
size_t instanceIndex = objects.GetCount() + args.jobIndex;
@@ -3676,10 +3676,10 @@ namespace wiScene
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;
+ instance.instance_id = (uint32_t)instanceIndex;
+ instance.instance_mask = 1;
+ instance.bottom_level = hair.BLAS;
+ instance.flags = RaytracingAccelerationStructureDesc::TopLevel::Instance::FLAG_TRIANGLE_CULL_DISABLE;
void* dest = (void*)((size_t)TLAS_instancesMapped + instanceIndex * device->GetTopLevelAccelerationStructureInstanceSize());
device->WriteTopLevelAccelerationStructureInstance(&instance, dest);
@@ -3720,17 +3720,17 @@ namespace wiScene
const TransformComponent& transform = *transforms.GetComponent(entity);
emitter.UpdateCPU(transform, dt);
- GraphicsDevice* device = wiRenderer::GetDevice();
+ GraphicsDevice* device = wiGraphics::GetDevice();
size_t meshIndex = meshes.GetCount() + hairs.GetCount() + args.jobIndex;
ShaderMesh& mesh = meshArrayMapped[meshIndex];
mesh.init();
- mesh.ib = device->GetDescriptorIndex(&emitter.primitiveBuffer, SRV);
- mesh.vb_pos_nor_wind = device->GetDescriptorIndex(&emitter.vertexBuffer_POS, SRV);
- mesh.vb_uv0 = device->GetDescriptorIndex(&emitter.vertexBuffer_TEX, SRV);
- mesh.vb_uv1 = device->GetDescriptorIndex(&emitter.vertexBuffer_TEX2, SRV);
- mesh.vb_col = device->GetDescriptorIndex(&emitter.vertexBuffer_COL, SRV);
- mesh.subsetbuffer = device->GetDescriptorIndex(&emitter.subsetBuffer, SRV);
+ mesh.ib = device->GetDescriptorIndex(&emitter.primitiveBuffer, SubresourceType::SRV);
+ mesh.vb_pos_nor_wind = device->GetDescriptorIndex(&emitter.vertexBuffer_POS, SubresourceType::SRV);
+ mesh.vb_uv0 = device->GetDescriptorIndex(&emitter.vertexBuffer_TEX, SubresourceType::SRV);
+ mesh.vb_uv1 = device->GetDescriptorIndex(&emitter.vertexBuffer_TEX2, SubresourceType::SRV);
+ mesh.vb_col = device->GetDescriptorIndex(&emitter.vertexBuffer_COL, SubresourceType::SRV);
+ mesh.subsetbuffer = device->GetDescriptorIndex(&emitter.subsetBuffer, SubresourceType::SRV);
mesh.flags = SHADERMESH_FLAG_DOUBLE_SIDED | SHADERMESH_FLAG_EMITTEDPARTICLE;
size_t instanceIndex = objects.GetCount() + hairs.GetCount() + args.jobIndex;
@@ -3752,10 +3752,10 @@ namespace wiScene
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 = emitter.BLAS;
- instance.Flags = RaytracingAccelerationStructureDesc::TopLevel::Instance::FLAG_TRIANGLE_CULL_DISABLE;
+ instance.instance_id = (uint32_t)instanceIndex;
+ instance.instance_mask = 1;
+ instance.bottom_level = emitter.BLAS;
+ instance.flags = RaytracingAccelerationStructureDesc::TopLevel::Instance::FLAG_TRIANGLE_CULL_DISABLE;
void* dest = (void*)((size_t)TLAS_instancesMapped + instanceIndex * device->GetTopLevelAccelerationStructureInstanceSize());
device->WriteTopLevelAccelerationStructureInstance(&instance, dest);
diff --git a/WickedEngine/wiScene.h b/WickedEngine/wiScene.h
index 39dc4ea6f..0048af5f3 100644
--- a/WickedEngine/wiScene.h
+++ b/WickedEngine/wiScene.h
@@ -176,7 +176,7 @@ namespace wiScene
float clearcoat = 0;
float clearcoatRoughness = 0;
- wiGraphics::SHADING_RATE shadingRate = wiGraphics::SHADING_RATE_1X1;
+ wiGraphics::ShadingRate shadingRate = wiGraphics::ShadingRate::RATE_1X1;
XMFLOAT2 texAnimDirection = XMFLOAT2(0, 0);
float texAnimFrameRate = 0.0f;
@@ -414,8 +414,8 @@ namespace wiScene
inline bool IsTerrain() const { return _flags & TERRAIN; }
inline float GetTessellationFactor() const { return tessellationFactor; }
- inline wiGraphics::INDEXBUFFER_FORMAT GetIndexFormat() const { return vertex_positions.size() > 65535 ? wiGraphics::INDEXFORMAT_32BIT : wiGraphics::INDEXFORMAT_16BIT; }
- inline size_t GetIndexStride() const { return GetIndexFormat() == wiGraphics::INDEXFORMAT_32BIT ? sizeof(uint32_t) : sizeof(uint16_t); }
+ inline wiGraphics::IndexBufferFormat GetIndexFormat() const { return vertex_positions.size() > 65535 ? wiGraphics::IndexBufferFormat::UINT32 : wiGraphics::IndexBufferFormat::UINT16; }
+ inline size_t GetIndexStride() const { return GetIndexFormat() == wiGraphics::IndexBufferFormat::UINT32 ? sizeof(uint32_t) : sizeof(uint16_t); }
inline bool IsSkinned() const { return armatureID != wiECS::INVALID_ENTITY; }
// Recreates GPU resources for index/vertex buffers
@@ -491,7 +491,7 @@ namespace wiScene
return (normal_wind >> 24) & 0x000000FF;
}
- static const wiGraphics::FORMAT FORMAT = wiGraphics::FORMAT::FORMAT_R32G32B32A32_FLOAT;
+ static const wiGraphics::Format FORMAT = wiGraphics::Format::R32G32B32A32_FLOAT;
};
struct Vertex_TEX
{
@@ -502,7 +502,7 @@ namespace wiScene
tex = XMHALF2(texcoords.x, texcoords.y);
}
- static const wiGraphics::FORMAT FORMAT = wiGraphics::FORMAT::FORMAT_R16G16_FLOAT;
+ static const wiGraphics::Format FORMAT = wiGraphics::Format::R16G16_FLOAT;
};
struct Vertex_BON
{
@@ -550,7 +550,7 @@ namespace wiScene
struct Vertex_COL
{
uint32_t color = 0;
- static const wiGraphics::FORMAT FORMAT = wiGraphics::FORMAT::FORMAT_R8G8B8A8_UNORM;
+ static const wiGraphics::Format FORMAT = wiGraphics::Format::R8G8B8A8_UNORM;
};
struct Vertex_TAN
{
@@ -570,7 +570,7 @@ namespace wiScene
tangent |= (uint)((t.w * 0.5f + 0.5f) * 255.0f) << 24;
}
- static const wiGraphics::FORMAT FORMAT = wiGraphics::FORMAT::FORMAT_R8G8B8A8_UNORM;
+ static const wiGraphics::Format FORMAT = wiGraphics::Format::R8G8B8A8_UNORM;
};
// Non serialized attributes:
diff --git a/WickedEngine/wiShaderCompiler.cpp b/WickedEngine/wiShaderCompiler.cpp
index 64538dbfb..a78c5ed0e 100644
--- a/WickedEngine/wiShaderCompiler.cpp
+++ b/WickedEngine/wiShaderCompiler.cpp
@@ -30,6 +30,10 @@
#include
#endif // SHADERCOMPILER_ENABLED_D3DCOMPILER
+using wiGraphics::ShaderFormat;
+using wiGraphics::ShaderStage;
+using wiGraphics::ShaderModel;
+
namespace wiShaderCompiler
{
#ifdef SHADERCOMPILER_ENABLED_DXCOMPILER
@@ -71,10 +75,10 @@ namespace wiShaderCompiler
switch (input.format)
{
- case wiGraphics::SHADERFORMAT_HLSL6:
+ case ShaderFormat::HLSL6:
args.push_back(L"-D"); args.push_back(L"HLSL6");
break;
- case wiGraphics::SHADERFORMAT_SPIRV:
+ case ShaderFormat::SPIRV:
args.push_back(L"-D"); args.push_back(L"SPIRV");
args.push_back(L"-spirv");
args.push_back(L"-fspv-target-env=vulkan1.2");
@@ -93,218 +97,218 @@ namespace wiShaderCompiler
args.push_back(L"-T");
switch (input.stage)
{
- case wiGraphics::MS:
+ case ShaderStage::MS:
switch (input.minshadermodel)
{
default:
args.push_back(L"ms_6_5");
break;
- case wiGraphics::SHADERMODEL_6_6:
+ case ShaderModel::SM_6_6:
args.push_back(L"ms_6_6");
break;
- case wiGraphics::SHADERMODEL_6_7:
+ case ShaderModel::SM_6_7:
args.push_back(L"ms_6_7");
break;
}
break;
- case wiGraphics::AS:
+ case ShaderStage::AS:
switch (input.minshadermodel)
{
default:
args.push_back(L"as_6_5");
break;
- case wiGraphics::SHADERMODEL_6_6:
+ case ShaderModel::SM_6_6:
args.push_back(L"as_6_6");
break;
- case wiGraphics::SHADERMODEL_6_7:
+ case ShaderModel::SM_6_7:
args.push_back(L"as_6_7");
break;
}
break;
- case wiGraphics::VS:
+ case ShaderStage::VS:
switch (input.minshadermodel)
{
default:
args.push_back(L"vs_6_0");
break;
- case wiGraphics::SHADERMODEL_6_1:
+ case ShaderModel::SM_6_1:
args.push_back(L"vs_6_1");
break;
- case wiGraphics::SHADERMODEL_6_2:
+ case ShaderModel::SM_6_2:
args.push_back(L"vs_6_2");
break;
- case wiGraphics::SHADERMODEL_6_3:
+ case ShaderModel::SM_6_3:
args.push_back(L"vs_6_3");
break;
- case wiGraphics::SHADERMODEL_6_4:
+ case ShaderModel::SM_6_4:
args.push_back(L"vs_6_4");
break;
- case wiGraphics::SHADERMODEL_6_5:
+ case ShaderModel::SM_6_5:
args.push_back(L"vs_6_5");
break;
- case wiGraphics::SHADERMODEL_6_6:
+ case ShaderModel::SM_6_6:
args.push_back(L"vs_6_6");
break;
- case wiGraphics::SHADERMODEL_6_7:
+ case ShaderModel::SM_6_7:
args.push_back(L"vs_6_7");
break;
}
break;
- case wiGraphics::HS:
+ case ShaderStage::HS:
switch (input.minshadermodel)
{
default:
args.push_back(L"hs_6_0");
break;
- case wiGraphics::SHADERMODEL_6_1:
+ case ShaderModel::SM_6_1:
args.push_back(L"hs_6_1");
break;
- case wiGraphics::SHADERMODEL_6_2:
+ case ShaderModel::SM_6_2:
args.push_back(L"hs_6_2");
break;
- case wiGraphics::SHADERMODEL_6_3:
+ case ShaderModel::SM_6_3:
args.push_back(L"hs_6_3");
break;
- case wiGraphics::SHADERMODEL_6_4:
+ case ShaderModel::SM_6_4:
args.push_back(L"hs_6_4");
break;
- case wiGraphics::SHADERMODEL_6_5:
+ case ShaderModel::SM_6_5:
args.push_back(L"hs_6_5");
break;
- case wiGraphics::SHADERMODEL_6_6:
+ case ShaderModel::SM_6_6:
args.push_back(L"hs_6_6");
break;
- case wiGraphics::SHADERMODEL_6_7:
+ case ShaderModel::SM_6_7:
args.push_back(L"hs_6_7");
break;
}
break;
- case wiGraphics::DS:
+ case ShaderStage::DS:
switch (input.minshadermodel)
{
default:
args.push_back(L"ds_6_0");
break;
- case wiGraphics::SHADERMODEL_6_1:
+ case ShaderModel::SM_6_1:
args.push_back(L"ds_6_1");
break;
- case wiGraphics::SHADERMODEL_6_2:
+ case ShaderModel::SM_6_2:
args.push_back(L"ds_6_2");
break;
- case wiGraphics::SHADERMODEL_6_3:
+ case ShaderModel::SM_6_3:
args.push_back(L"ds_6_3");
break;
- case wiGraphics::SHADERMODEL_6_4:
+ case ShaderModel::SM_6_4:
args.push_back(L"ds_6_4");
break;
- case wiGraphics::SHADERMODEL_6_5:
+ case ShaderModel::SM_6_5:
args.push_back(L"ds_6_5");
break;
- case wiGraphics::SHADERMODEL_6_6:
+ case ShaderModel::SM_6_6:
args.push_back(L"ds_6_6");
break;
- case wiGraphics::SHADERMODEL_6_7:
+ case ShaderModel::SM_6_7:
args.push_back(L"ds_6_7");
break;
}
break;
- case wiGraphics::GS:
+ case ShaderStage::GS:
switch (input.minshadermodel)
{
default:
args.push_back(L"gs_6_0");
break;
- case wiGraphics::SHADERMODEL_6_1:
+ case ShaderModel::SM_6_1:
args.push_back(L"gs_6_1");
break;
- case wiGraphics::SHADERMODEL_6_2:
+ case ShaderModel::SM_6_2:
args.push_back(L"gs_6_2");
break;
- case wiGraphics::SHADERMODEL_6_3:
+ case ShaderModel::SM_6_3:
args.push_back(L"gs_6_3");
break;
- case wiGraphics::SHADERMODEL_6_4:
+ case ShaderModel::SM_6_4:
args.push_back(L"gs_6_4");
break;
- case wiGraphics::SHADERMODEL_6_5:
+ case ShaderModel::SM_6_5:
args.push_back(L"gs_6_5");
break;
- case wiGraphics::SHADERMODEL_6_6:
+ case ShaderModel::SM_6_6:
args.push_back(L"gs_6_6");
break;
- case wiGraphics::SHADERMODEL_6_7:
+ case ShaderModel::SM_6_7:
args.push_back(L"gs_6_7");
break;
}
break;
- case wiGraphics::PS:
+ case ShaderStage::PS:
switch (input.minshadermodel)
{
default:
args.push_back(L"ps_6_0");
break;
- case wiGraphics::SHADERMODEL_6_1:
+ case ShaderModel::SM_6_1:
args.push_back(L"ps_6_1");
break;
- case wiGraphics::SHADERMODEL_6_2:
+ case ShaderModel::SM_6_2:
args.push_back(L"ps_6_2");
break;
- case wiGraphics::SHADERMODEL_6_3:
+ case ShaderModel::SM_6_3:
args.push_back(L"ps_6_3");
break;
- case wiGraphics::SHADERMODEL_6_4:
+ case ShaderModel::SM_6_4:
args.push_back(L"ps_6_4");
break;
- case wiGraphics::SHADERMODEL_6_5:
+ case ShaderModel::SM_6_5:
args.push_back(L"ps_6_5");
break;
- case wiGraphics::SHADERMODEL_6_6:
+ case ShaderModel::SM_6_6:
args.push_back(L"ps_6_6");
break;
- case wiGraphics::SHADERMODEL_6_7:
+ case ShaderModel::SM_6_7:
args.push_back(L"ps_6_7");
break;
}
break;
- case wiGraphics::CS:
+ case ShaderStage::CS:
switch (input.minshadermodel)
{
default:
args.push_back(L"cs_6_0");
break;
- case wiGraphics::SHADERMODEL_6_1:
+ case ShaderModel::SM_6_1:
args.push_back(L"cs_6_1");
break;
- case wiGraphics::SHADERMODEL_6_2:
+ case ShaderModel::SM_6_2:
args.push_back(L"cs_6_2");
break;
- case wiGraphics::SHADERMODEL_6_3:
+ case ShaderModel::SM_6_3:
args.push_back(L"cs_6_3");
break;
- case wiGraphics::SHADERMODEL_6_4:
+ case ShaderModel::SM_6_4:
args.push_back(L"cs_6_4");
break;
- case wiGraphics::SHADERMODEL_6_5:
+ case ShaderModel::SM_6_5:
args.push_back(L"cs_6_5");
break;
- case wiGraphics::SHADERMODEL_6_6:
+ case ShaderModel::SM_6_6:
args.push_back(L"cs_6_6");
break;
- case wiGraphics::SHADERMODEL_6_7:
+ case ShaderModel::SM_6_7:
args.push_back(L"cs_6_7");
break;
}
break;
- case wiGraphics::LIB:
+ case ShaderStage::LIB:
switch (input.minshadermodel)
{
default:
args.push_back(L"lib_6_5");
break;
- case wiGraphics::SHADERMODEL_6_6:
+ case ShaderModel::SM_6_6:
args.push_back(L"lib_6_6");
break;
- case wiGraphics::SHADERMODEL_6_7:
+ case ShaderModel::SM_6_7:
args.push_back(L"lib_6_7");
break;
}
@@ -427,7 +431,7 @@ namespace wiShaderCompiler
output.internal_state = internal_state;
}
- if (input.format == wiGraphics::SHADERFORMAT_HLSL6)
+ if (input.format == ShaderFormat::HLSL6)
{
CComPtr pHash = nullptr;
hr = pResults->GetOutput(DXC_OUT_SHADER_HASH, IID_PPV_ARGS(&pHash), nullptr);
@@ -454,7 +458,7 @@ namespace wiShaderCompiler
return;
}
- if (input.minshadermodel > wiGraphics::SHADERMODEL_5_0)
+ if (input.minshadermodel > ShaderModel::SM_5_0)
{
output.error_message = "SHADERFORMAT_HLSL5 cannot support specified minshadermodel!";
return;
@@ -642,8 +646,8 @@ namespace wiShaderCompiler
break;
#ifdef SHADERCOMPILER_ENABLED_DXCOMPILER
- case wiGraphics::SHADERFORMAT_HLSL6:
- case wiGraphics::SHADERFORMAT_SPIRV:
+ case ShaderFormat::HLSL6:
+ case ShaderFormat::SPIRV:
Compile_DXCompiler(input, output);
break;
#endif // SHADERCOMPILER_ENABLED_DXCOMPILER
diff --git a/WickedEngine/wiShaderCompiler.h b/WickedEngine/wiShaderCompiler.h
index 2a6189bee..77ad10013 100644
--- a/WickedEngine/wiShaderCompiler.h
+++ b/WickedEngine/wiShaderCompiler.h
@@ -16,11 +16,11 @@ namespace wiShaderCompiler
struct CompilerInput
{
uint64_t flags = FLAG_NONE;
- wiGraphics::SHADERFORMAT format = wiGraphics::SHADERFORMAT::SHADERFORMAT_NONE;
- wiGraphics::SHADERSTAGE stage = wiGraphics::SHADERSTAGE_COUNT;
+ wiGraphics::ShaderFormat format = wiGraphics::ShaderFormat::NONE;
+ wiGraphics::ShaderStage stage = wiGraphics::ShaderStage::Count;
// if the shader relies on a higher shader model feature, it must be declared here.
// But the compiler can also choose a higher one internally, if needed
- wiGraphics::SHADERMODEL minshadermodel = wiGraphics::SHADERMODEL_5_0;
+ wiGraphics::ShaderModel minshadermodel = wiGraphics::ShaderModel::SM_5_0;
std::string shadersourcefilename;
std::string entrypoint = "main";
std::vector include_directories;
diff --git a/WickedEngine/wiSprite.cpp b/WickedEngine/wiSprite.cpp
index e7246982c..9eae07154 100644
--- a/WickedEngine/wiSprite.cpp
+++ b/WickedEngine/wiSprite.cpp
@@ -1,6 +1,5 @@
#include "wiSprite.h"
#include "wiImage.h"
-#include "wiRenderer.h"
#include "wiRandom.h"
#include "wiTextureHelper.h"
diff --git a/WickedEngine/wiTextureHelper.cpp b/WickedEngine/wiTextureHelper.cpp
index f68ce8041..2ed746b77 100644
--- a/WickedEngine/wiTextureHelper.cpp
+++ b/WickedEngine/wiTextureHelper.cpp
@@ -1,5 +1,4 @@
#include "wiTextureHelper.h"
-#include "wiRenderer.h"
#include "wiRandom.h"
#include "wiColor.h"
#include "wiBackLog.h"
@@ -34,7 +33,7 @@ namespace wiTextureHelper
{
wiTimer timer;
- GraphicsDevice* device = wiRenderer::GetDevice();
+ GraphicsDevice* device = wiGraphics::GetDevice();
// Random64x64
{
@@ -93,15 +92,15 @@ namespace wiTextureHelper
};
TextureDesc texDesc;
- texDesc.Width = width;
- texDesc.Height = height;
- texDesc.MipLevels = 1;
- texDesc.ArraySize = 6;
- texDesc.Format = FORMAT_R8G8B8A8_UNORM;
- texDesc.SampleCount = 1;
- texDesc.Usage = USAGE_DEFAULT;
- texDesc.BindFlags = BIND_SHADER_RESOURCE;
- texDesc.MiscFlags = RESOURCE_MISC_TEXTURECUBE;
+ texDesc.width = width;
+ texDesc.height = height;
+ texDesc.mip_levels = 1;
+ texDesc.array_size = 6;
+ texDesc.format = Format::R8G8B8A8_UNORM;
+ texDesc.sample_count = 1;
+ texDesc.usage = Usage::DEFAULT;
+ texDesc.bind_flags = BindFlag::SHADER_RESOURCE;
+ texDesc.misc_flags = ResourceMiscFlag::TEXTURECUBE;
SubresourceData pData[6];
vector4b d[6][width * height]; // 6 images of type vector4b = 4 * unsigned char
@@ -114,9 +113,9 @@ namespace wiTextureHelper
d[cubeMapFaceIndex][pix] = vector4b(0, 0, 0, 0);
}
- pData[cubeMapFaceIndex].pData = &d[cubeMapFaceIndex][0];// description.data;
- pData[cubeMapFaceIndex].rowPitch = width * 4;
- pData[cubeMapFaceIndex].slicePitch = 0;
+ pData[cubeMapFaceIndex].data_ptr = &d[cubeMapFaceIndex][0];// description.data;
+ pData[cubeMapFaceIndex].row_pitch = width * 4;
+ pData[cubeMapFaceIndex].slice_pitch = 0;
}
device->CreateTexture(&texDesc, &pData[0], &helperTextures[HELPERTEXTURE_BLACKCUBEMAP]);
@@ -126,7 +125,7 @@ namespace wiTextureHelper
// UINT4:
{
uint8_t data[16] = {};
- CreateTexture(helperTextures[HELPERTEXTURE_UINT4], data, 1, 1, FORMAT_R32G32B32A32_UINT);
+ CreateTexture(helperTextures[HELPERTEXTURE_UINT4], data, 1, 1, Format::R32G32B32A32_UINT);
device->SetName(&helperTextures[HELPERTEXTURE_UINT4], "HELPERTEXTURE_UINT4");
}
@@ -150,7 +149,7 @@ namespace wiTextureHelper
}
}
- CreateTexture(helperTextures[HELPERTEXTURE_BLUENOISE], (uint8_t*)blueNoise, 128, 128, FORMAT_R8G8B8A8_UNORM);
+ CreateTexture(helperTextures[HELPERTEXTURE_BLUENOISE], (uint8_t*)blueNoise, 128, 128, Format::R8G8B8A8_UNORM);
device->SetName(&helperTextures[HELPERTEXTURE_BLUENOISE], "HELPERTEXTURE_BLUENOISE");
}
@@ -214,7 +213,7 @@ namespace wiTextureHelper
return &it->second;
}
- GraphicsDevice* device = wiRenderer::GetDevice();
+ GraphicsDevice* device = wiGraphics::GetDevice();
static const int dim = 1;
static const int dataLength = dim * dim * 4;
@@ -242,26 +241,26 @@ namespace wiTextureHelper
}
- bool CreateTexture(wiGraphics::Texture& texture, const uint8_t* data, uint32_t width, uint32_t height, FORMAT format)
+ bool CreateTexture(wiGraphics::Texture& texture, const uint8_t* data, uint32_t width, uint32_t height, Format format)
{
if (data == nullptr)
{
return false;
}
- GraphicsDevice* device = wiRenderer::GetDevice();
+ GraphicsDevice* device = wiGraphics::GetDevice();
TextureDesc textureDesc;
- textureDesc.Width = width;
- textureDesc.Height = height;
- textureDesc.MipLevels = 1;
- textureDesc.ArraySize = 1;
- textureDesc.Format = format;
- textureDesc.SampleCount = 1;
- textureDesc.BindFlags = BIND_SHADER_RESOURCE;
+ textureDesc.width = width;
+ textureDesc.height = height;
+ textureDesc.mip_levels = 1;
+ textureDesc.array_size = 1;
+ textureDesc.format = format;
+ textureDesc.sample_count = 1;
+ textureDesc.bind_flags = BindFlag::SHADER_RESOURCE;
SubresourceData InitData;
- InitData.pData = data;
- InitData.rowPitch = width * GetFormatStride(format) / GetFormatBlockSize(format);
+ InitData.data_ptr = data;
+ InitData.row_pitch = width * GetFormatStride(format) / GetFormatBlockSize(format);
return device->CreateTexture(&textureDesc, &InitData, &texture);
}
diff --git a/WickedEngine/wiTextureHelper.h b/WickedEngine/wiTextureHelper.h
index 6296dfd0f..e5f0c2fe1 100644
--- a/WickedEngine/wiTextureHelper.h
+++ b/WickedEngine/wiTextureHelper.h
@@ -19,6 +19,6 @@ namespace wiTextureHelper
const wiGraphics::Texture* getTransparent();
const wiGraphics::Texture* getColor(wiColor color);
- bool CreateTexture(wiGraphics::Texture& texture, const uint8_t* data, uint32_t width, uint32_t height, wiGraphics::FORMAT format = wiGraphics::FORMAT_R8G8B8A8_UNORM);
+ bool CreateTexture(wiGraphics::Texture& texture, const uint8_t* data, uint32_t width, uint32_t height, wiGraphics::Format format = wiGraphics::Format::R8G8B8A8_UNORM);
};
diff --git a/WickedEngine/wiVersion.cpp b/WickedEngine/wiVersion.cpp
index f616639bd..241f1e6aa 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 = 58;
+ const int minor = 59;
// minor bug fixes, alterations, refactors, updates
- const int revision = 19;
+ 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 346f90f5b..a6d3fddfd 100644
--- a/WickedEngine/wiWidget.cpp
+++ b/WickedEngine/wiWidget.cpp
@@ -323,7 +323,7 @@ void wiWidget::ApplyScissor(const wiCanvas& canvas, const Rect rect, CommandList
scissor.top = scissor.bottom;
}
- GraphicsDevice* device = wiRenderer::GetDevice();
+ GraphicsDevice* device = wiGraphics::GetDevice();
float scale = canvas.GetDPIScaling();
scissor.bottom = int32_t((float)scissor.bottom * scale);
scissor.top = int32_t((float)scissor.top * scale);
@@ -348,8 +348,8 @@ namespace wiWidget_Internal
desc.dss = wiRenderer::GetDepthStencilState(DSSTYPE_XRAY);
desc.bs = wiRenderer::GetBlendState(BSTYPE_TRANSPARENT);
desc.rs = wiRenderer::GetRasterizerState(RSTYPE_DOUBLESIDED);
- desc.pt = TRIANGLESTRIP;
- wiRenderer::GetDevice()->CreatePipelineState(&desc, &PSO_colored);
+ desc.pt = PrimitiveTopology::TRIANGLESTRIP;
+ wiGraphics::GetDevice()->CreatePipelineState(&desc, &PSO_colored);
}
}
@@ -1281,7 +1281,7 @@ void wiComboBox::Render(const wiCanvas& canvas, CommandList cmd) const
{
return;
}
- GraphicsDevice* device = wiRenderer::GetDevice();
+ GraphicsDevice* device = wiGraphics::GetDevice();
wiColor color = GetColor();
if (combostate != COMBOSTATE_INACTIVE)
@@ -1306,8 +1306,8 @@ void wiComboBox::Render(const wiCanvas& canvas, CommandList cmd) const
wiMath::ConstructTriangleEquilateral(1, vertices[0].pos, vertices[1].pos, vertices[2].pos);
GPUBufferDesc desc;
- desc.BindFlags = BIND_VERTEX_BUFFER;
- desc.Size = sizeof(vertices);
+ desc.bind_flags = BindFlag::VERTEX_BUFFER;
+ desc.size = sizeof(vertices);
device->CreateBuffer(&desc, &vertices, &vb_triangle);
}
const XMMATRIX Projection = canvas.GetProjection();
@@ -2245,7 +2245,7 @@ void wiColorPicker::Render(const wiCanvas& canvas, CommandList cmd) const
return;
}
- GraphicsDevice* device = wiRenderer::GetDevice();
+ GraphicsDevice* device = wiGraphics::GetDevice();
struct Vertex
{
@@ -2340,9 +2340,9 @@ void wiColorPicker::Render(const wiCanvas& canvas, CommandList cmd) const
}
GPUBufferDesc desc;
- desc.BindFlags = BIND_VERTEX_BUFFER;
- desc.Size = vertices.size() * sizeof(Vertex);
- desc.Stride = 0;
+ desc.bind_flags = BindFlag::VERTEX_BUFFER;
+ desc.size = vertices.size() * sizeof(Vertex);
+ desc.stride = 0;
device->CreateBuffer(&desc, vertices.data(), &vb_hue);
}
// saturation picker (small circle)
@@ -2362,9 +2362,9 @@ void wiColorPicker::Render(const wiCanvas& canvas, CommandList cmd) const
}
GPUBufferDesc desc;
- desc.BindFlags = BIND_VERTEX_BUFFER;
- desc.Size = vertices.size() * sizeof(Vertex);
- desc.Stride = 0;
+ desc.bind_flags = BindFlag::VERTEX_BUFFER;
+ desc.size = vertices.size() * sizeof(Vertex);
+ desc.stride = 0;
device->CreateBuffer(&desc, vertices.data(), &vb_picker_saturation);
}
// hue picker (rectangle)
@@ -2398,9 +2398,9 @@ void wiColorPicker::Render(const wiCanvas& canvas, CommandList cmd) const
};
GPUBufferDesc desc;
- desc.BindFlags = BIND_VERTEX_BUFFER;
- desc.Size = sizeof(vertices);
- desc.Stride = 0;
+ desc.bind_flags = BindFlag::VERTEX_BUFFER;
+ desc.size = sizeof(vertices);
+ desc.stride = 0;
device->CreateBuffer(&desc, vertices, &vb_picker_hue);
}
// preview
@@ -2414,8 +2414,8 @@ void wiColorPicker::Render(const wiCanvas& canvas, CommandList cmd) const
};
GPUBufferDesc desc;
- desc.BindFlags = BIND_VERTEX_BUFFER;
- desc.Size = sizeof(vertices);
+ desc.bind_flags = BindFlag::VERTEX_BUFFER;
+ desc.size = sizeof(vertices);
device->CreateBuffer(&desc, vertices, &vb_preview);
}
@@ -2496,7 +2496,7 @@ void wiColorPicker::Render(const wiCanvas& canvas, CommandList cmd) const
sizeof(Vertex),
};
device->BindVertexBuffers(vbs, 0, arraysize(vbs), strides, nullptr, cmd);
- device->Draw((uint32_t)(vb_hue.GetDesc().Size / sizeof(Vertex)), 0, cmd);
+ device->Draw((uint32_t)(vb_hue.GetDesc().size / sizeof(Vertex)), 0, cmd);
}
// render hue picker
@@ -2523,7 +2523,7 @@ void wiColorPicker::Render(const wiCanvas& canvas, CommandList cmd) const
sizeof(Vertex),
};
device->BindVertexBuffers(vbs, 0, arraysize(vbs), strides, nullptr, cmd);
- device->Draw((uint32_t)(vb_picker_hue.GetDesc().Size / sizeof(Vertex)), 0, cmd);
+ device->Draw((uint32_t)(vb_picker_hue.GetDesc().size / sizeof(Vertex)), 0, cmd);
}
// render saturation picker
@@ -2574,7 +2574,7 @@ void wiColorPicker::Render(const wiCanvas& canvas, CommandList cmd) const
sizeof(Vertex),
};
device->BindVertexBuffers(vbs, 0, arraysize(vbs), strides, nullptr, cmd);
- device->Draw((uint32_t)(vb_picker_saturation.GetDesc().Size / sizeof(Vertex)), 0, cmd);
+ device->Draw((uint32_t)(vb_picker_saturation.GetDesc().size / sizeof(Vertex)), 0, cmd);
}
// render preview
@@ -2593,7 +2593,7 @@ void wiColorPicker::Render(const wiCanvas& canvas, CommandList cmd) const
sizeof(Vertex),
};
device->BindVertexBuffers(vbs, 0, arraysize(vbs), strides, nullptr, cmd);
- device->Draw((uint32_t)(vb_preview.GetDesc().Size / sizeof(Vertex)), 0, cmd);
+ device->Draw((uint32_t)(vb_preview.GetDesc().size / sizeof(Vertex)), 0, cmd);
}
}
wiColor wiColorPicker::GetPickColor() const
@@ -2865,7 +2865,7 @@ void wiTreeList::Render(const wiCanvas& canvas, CommandList cmd) const
{
return;
}
- GraphicsDevice* device = wiRenderer::GetDevice();
+ GraphicsDevice* device = wiGraphics::GetDevice();
// control-base
sprites[state].Draw(cmd);
@@ -2922,8 +2922,8 @@ void wiTreeList::Render(const wiCanvas& canvas, CommandList cmd) const
wiMath::ConstructTriangleEquilateral(1, vertices[0].pos, vertices[1].pos, vertices[2].pos);
GPUBufferDesc desc;
- desc.BindFlags = BIND_VERTEX_BUFFER;
- desc.Size = sizeof(vertices);
+ desc.bind_flags = BindFlag::VERTEX_BUFFER;
+ desc.size = sizeof(vertices);
device->CreateBuffer(&desc, vertices, &vb_triangle);
}
const XMMATRIX Projection = canvas.GetProjection();