1828 lines
66 KiB
C++
1828 lines
66 KiB
C++
#include "D3D12UiRenderer.h"
|
|
|
|
#include <XCEngine/Rendering/RenderSurfacePipelineUtils.h>
|
|
#include <XCEngine/RHI/D3D12/D3D12CommandList.h>
|
|
#include <XCEngine/RHI/D3D12/D3D12DescriptorHeap.h>
|
|
#include <XCEngine/RHI/D3D12/D3D12DescriptorSet.h>
|
|
#include <XCEngine/RHI/D3D12/D3D12PipelineLayout.h>
|
|
#include <XCEngine/RHI/RHICommandList.h>
|
|
#include <XCEngine/RHI/RHIEnums.h>
|
|
#include <XCEngine/RHI/RHITypes.h>
|
|
|
|
#include <algorithm>
|
|
#include <cmath>
|
|
#include <cstdio>
|
|
#include <cstring>
|
|
#include <utility>
|
|
|
|
namespace XCEngine::UI::Editor::Host {
|
|
|
|
namespace {
|
|
|
|
using ::XCEngine::RHI::BlendFactor;
|
|
using ::XCEngine::RHI::BlendOp;
|
|
using ::XCEngine::RHI::BufferDesc;
|
|
using ::XCEngine::RHI::BufferType;
|
|
using ::XCEngine::RHI::ColorWriteMask;
|
|
using ::XCEngine::RHI::ComparisonFunc;
|
|
using ::XCEngine::RHI::CullMode;
|
|
using ::XCEngine::RHI::DescriptorHeapType;
|
|
using ::XCEngine::RHI::DescriptorPoolDesc;
|
|
using ::XCEngine::RHI::DescriptorSetLayoutBinding;
|
|
using ::XCEngine::RHI::DescriptorSetLayoutDesc;
|
|
using ::XCEngine::RHI::DescriptorType;
|
|
using ::XCEngine::RHI::D3D12CommandList;
|
|
using ::XCEngine::RHI::D3D12DescriptorSet;
|
|
using ::XCEngine::RHI::D3D12DescriptorHeap;
|
|
using ::XCEngine::RHI::FilterMode;
|
|
using ::XCEngine::RHI::FillMode;
|
|
using ::XCEngine::RHI::Format;
|
|
using ::XCEngine::RHI::FrontFace;
|
|
using ::XCEngine::RHI::GraphicsPipelineDesc;
|
|
using ::XCEngine::RHI::PrimitiveTopology;
|
|
using ::XCEngine::RHI::PrimitiveTopologyType;
|
|
using ::XCEngine::RHI::RHICommandList;
|
|
using ::XCEngine::RHI::Rect;
|
|
using ::XCEngine::RHI::ResourceViewDesc;
|
|
using ::XCEngine::RHI::ResourceViewDimension;
|
|
using ::XCEngine::RHI::RHIPipelineLayoutDesc;
|
|
using ::XCEngine::RHI::SamplerDesc;
|
|
using ::XCEngine::RHI::ShaderVisibility;
|
|
using ::XCEngine::RHI::TextureAddressMode;
|
|
using ::XCEngine::RHI::Viewport;
|
|
using ::XCEngine::Rendering::RenderContext;
|
|
using ::XCEngine::Rendering::RenderSurface;
|
|
using ::XCEngine::UI::UIColor;
|
|
using ::XCEngine::UI::UIDrawCommand;
|
|
using ::XCEngine::UI::UIDrawCommandType;
|
|
using ::XCEngine::UI::UIDrawData;
|
|
using ::XCEngine::UI::UIDrawList;
|
|
using ::XCEngine::UI::UILinearGradientDirection;
|
|
using ::XCEngine::UI::UIPoint;
|
|
using ::XCEngine::UI::UIRect;
|
|
using ::XCEngine::UI::UITextureHandle;
|
|
|
|
constexpr std::uint64_t kMinDynamicVertexBufferBytes = 16u * 1024u;
|
|
constexpr std::uint64_t kMinDynamicInstanceBufferBytes = 16u * 1024u;
|
|
|
|
enum class UiPrimitiveKind : int {
|
|
Textured = 0,
|
|
RectFill = 1,
|
|
RectOutline = 2,
|
|
CircleFill = 3,
|
|
CircleOutline = 4,
|
|
TriangleFill = 5
|
|
};
|
|
|
|
struct UiQuadVertex {
|
|
float corner[2] = {};
|
|
float uv[2] = {};
|
|
};
|
|
|
|
const UiQuadVertex kUnitQuadVertices[] = {
|
|
{ { 0.0f, 0.0f }, { 0.0f, 0.0f } },
|
|
{ { 1.0f, 0.0f }, { 1.0f, 0.0f } },
|
|
{ { 1.0f, 1.0f }, { 1.0f, 1.0f } },
|
|
{ { 0.0f, 1.0f }, { 0.0f, 1.0f } }
|
|
};
|
|
|
|
const std::uint32_t kUnitQuadIndices[] = { 0u, 1u, 2u, 0u, 2u, 3u };
|
|
|
|
const char kPrimitiveUiPassHlsl[] = R"(
|
|
cbuffer UiConstants : register(b0) {
|
|
float2 gInvViewportSize;
|
|
float2 gPadding;
|
|
};
|
|
|
|
struct VSInput {
|
|
float2 corner : POSITION0;
|
|
float2 unitUv : TEXCOORD0;
|
|
float2 origin : POSITION1;
|
|
float2 axisX : TEXCOORD1;
|
|
float2 axisY : TEXCOORD2;
|
|
float2 uvMin : TEXCOORD3;
|
|
float2 uvMax : TEXCOORD4;
|
|
float4 color : COLOR0;
|
|
float4 secondaryColor : COLOR1;
|
|
float4 params : TEXCOORD5;
|
|
float4 aux0 : TEXCOORD6;
|
|
float4 aux1 : TEXCOORD7;
|
|
};
|
|
|
|
struct VSOutput {
|
|
float4 position : SV_POSITION;
|
|
float2 unitUv : TEXCOORD0;
|
|
float2 localPos : TEXCOORD1;
|
|
float2 size : TEXCOORD2;
|
|
float2 sampleUv : TEXCOORD3;
|
|
float4 color : COLOR0;
|
|
float4 secondaryColor : COLOR1;
|
|
float4 params : TEXCOORD4;
|
|
float4 aux0 : TEXCOORD5;
|
|
float4 aux1 : TEXCOORD6;
|
|
};
|
|
|
|
Texture2D gTexture : register(t0);
|
|
SamplerState gSampler : register(s0);
|
|
|
|
float2 ToNdc(float2 pixelPos) {
|
|
float2 ndc;
|
|
ndc.x = pixelPos.x * gInvViewportSize.x * 2.0f - 1.0f;
|
|
ndc.y = 1.0f - pixelPos.y * gInvViewportSize.y * 2.0f;
|
|
return ndc;
|
|
}
|
|
|
|
VSOutput MainVS(VSInput input) {
|
|
VSOutput output;
|
|
const float2 pixelPos =
|
|
input.origin +
|
|
input.axisX * input.corner.x +
|
|
input.axisY * input.corner.y;
|
|
const float2 axisLength = float2(length(input.axisX), length(input.axisY));
|
|
output.position = float4(ToNdc(pixelPos), 0.0f, 1.0f);
|
|
output.unitUv = input.corner;
|
|
output.localPos = axisLength * input.corner;
|
|
output.size = axisLength;
|
|
output.sampleUv = lerp(input.uvMin, input.uvMax, input.corner);
|
|
output.color = input.color;
|
|
output.secondaryColor = input.secondaryColor;
|
|
output.params = input.params;
|
|
output.aux0 = input.aux0;
|
|
output.aux1 = input.aux1;
|
|
return output;
|
|
}
|
|
|
|
float CoverageFromSignedDistance(float distance) {
|
|
const float aa = max(fwidth(distance), 1.0f);
|
|
return saturate(0.5f - distance / aa);
|
|
}
|
|
|
|
float RoundedRectSignedDistance(float2 localPos, float2 size, float radius) {
|
|
const float2 halfSize = max(size * 0.5f, float2(0.0f, 0.0f));
|
|
const float resolvedRadius = min(radius, min(halfSize.x, halfSize.y));
|
|
const float2 centered = localPos - halfSize;
|
|
const float2 radiusVector = float2(resolvedRadius, resolvedRadius);
|
|
const float2 q = abs(centered) - (halfSize - radiusVector);
|
|
return length(max(q, float2(0.0f, 0.0f))) + min(max(q.x, q.y), 0.0f) - resolvedRadius;
|
|
}
|
|
|
|
float CircleSignedDistance(float2 localPos, float2 center, float radius) {
|
|
return length(localPos - center) - radius;
|
|
}
|
|
|
|
float Cross2(float2 lhs, float2 rhs) {
|
|
return lhs.x * rhs.y - lhs.y * rhs.x;
|
|
}
|
|
|
|
float TriangleSignedDistance(float2 localPos, float2 p0, float2 p1, float2 p2) {
|
|
const float orientation = Cross2(p1 - p0, p2 - p0);
|
|
if (abs(orientation) <= 1.0e-5f) {
|
|
return 1.0e6f;
|
|
}
|
|
|
|
const float sign = orientation >= 0.0f ? 1.0f : -1.0f;
|
|
const float2 edge0 = p1 - p0;
|
|
const float2 edge1 = p2 - p1;
|
|
const float2 edge2 = p0 - p2;
|
|
const float distance0 =
|
|
sign * Cross2(edge0, localPos - p0) / max(length(edge0), 1.0e-5f);
|
|
const float distance1 =
|
|
sign * Cross2(edge1, localPos - p1) / max(length(edge1), 1.0e-5f);
|
|
const float distance2 =
|
|
sign * Cross2(edge2, localPos - p2) / max(length(edge2), 1.0e-5f);
|
|
return -min(distance0, min(distance1, distance2));
|
|
}
|
|
|
|
float4 ResolveGradientColor(VSOutput input) {
|
|
const bool verticalGradient = input.params.w > 0.5f;
|
|
const float span = verticalGradient ? input.size.y : input.size.x;
|
|
const float axisValue = verticalGradient ? input.localPos.y : input.localPos.x;
|
|
const float t = span > 0.0f ? saturate(axisValue / span) : 0.0f;
|
|
return lerp(input.color, input.secondaryColor, t);
|
|
}
|
|
|
|
float4 MainPS(VSOutput input) : SV_TARGET0 {
|
|
const int quadKind = (int)round(input.params.x);
|
|
if (quadKind == 0) {
|
|
return gTexture.Sample(gSampler, input.sampleUv) * input.color;
|
|
}
|
|
|
|
float4 baseColor = ResolveGradientColor(input);
|
|
float coverage = 1.0f;
|
|
|
|
if (quadKind == 1) {
|
|
const float distance = RoundedRectSignedDistance(input.localPos, input.size, input.params.y);
|
|
coverage = CoverageFromSignedDistance(distance);
|
|
} else if (quadKind == 2) {
|
|
const float outerDistance =
|
|
RoundedRectSignedDistance(input.localPos, input.size, input.params.y);
|
|
const float innerRadius = max(0.0f, input.params.y - input.params.z);
|
|
const float2 insetVector = float2(input.params.z, input.params.z);
|
|
const float2 innerSize = max(input.size - insetVector * 2.0f, float2(0.0f, 0.0f));
|
|
const float2 innerLocalPos = input.localPos - insetVector;
|
|
const float innerDistance =
|
|
RoundedRectSignedDistance(innerLocalPos, innerSize, innerRadius);
|
|
coverage =
|
|
CoverageFromSignedDistance(outerDistance) *
|
|
(1.0f - CoverageFromSignedDistance(innerDistance));
|
|
} else if (quadKind == 3) {
|
|
const float2 center = input.size * 0.5f;
|
|
const float distance = CircleSignedDistance(input.localPos, center, input.params.y);
|
|
coverage = CoverageFromSignedDistance(distance);
|
|
} else if (quadKind == 4) {
|
|
const float2 center = input.size * 0.5f;
|
|
const float distance =
|
|
abs(length(input.localPos - center) - input.params.y) -
|
|
input.params.z * 0.5f;
|
|
coverage = CoverageFromSignedDistance(distance);
|
|
} else if (quadKind == 5) {
|
|
const float2 p0 = input.aux0.xy;
|
|
const float2 p1 = input.aux0.zw;
|
|
const float2 p2 = input.aux1.xy;
|
|
const float distance = TriangleSignedDistance(input.localPos, p0, p1, p2);
|
|
coverage = CoverageFromSignedDistance(distance);
|
|
}
|
|
|
|
return float4(baseColor.rgb, baseColor.a * coverage);
|
|
}
|
|
)";
|
|
|
|
struct FloatPoint {
|
|
float x = 0.0f;
|
|
float y = 0.0f;
|
|
};
|
|
|
|
struct FloatRect {
|
|
float left = 0.0f;
|
|
float top = 0.0f;
|
|
float right = 0.0f;
|
|
float bottom = 0.0f;
|
|
};
|
|
|
|
struct ClipState {
|
|
Rect scissor = {};
|
|
FloatRect rect = {};
|
|
};
|
|
|
|
struct UiConstants {
|
|
float invViewportSize[2] = {};
|
|
float padding[2] = {};
|
|
};
|
|
|
|
std::string HrToString(const char* operation, HRESULT hr) {
|
|
char buffer[128] = {};
|
|
sprintf_s(buffer, "%s failed with hr=0x%08X.", operation, static_cast<unsigned int>(hr));
|
|
return buffer;
|
|
}
|
|
|
|
float ClampDpiScale(float dpiScale) {
|
|
return dpiScale > 0.0f ? dpiScale : 1.0f;
|
|
}
|
|
|
|
float ResolveFontSize(float fontSize) {
|
|
return fontSize > 0.0f ? fontSize : 16.0f;
|
|
}
|
|
|
|
float SnapToPixel(float value, float dpiScale) {
|
|
return std::round(value * ClampDpiScale(dpiScale));
|
|
}
|
|
|
|
FloatRect ToPixelRect(const UIRect& rect, float dpiScale) {
|
|
return FloatRect{
|
|
SnapToPixel(rect.x, dpiScale),
|
|
SnapToPixel(rect.y, dpiScale),
|
|
SnapToPixel(rect.x + rect.width, dpiScale),
|
|
SnapToPixel(rect.y + rect.height, dpiScale)
|
|
};
|
|
}
|
|
|
|
FloatPoint ToPixelPoint(const UIPoint& point, float dpiScale) {
|
|
return FloatPoint{
|
|
SnapToPixel(point.x, dpiScale),
|
|
SnapToPixel(point.y, dpiScale)
|
|
};
|
|
}
|
|
|
|
FloatRect IntersectFloatRect(const FloatRect& lhs, const FloatRect& rhs) {
|
|
return FloatRect{
|
|
(std::max)(lhs.left, rhs.left),
|
|
(std::max)(lhs.top, rhs.top),
|
|
(std::min)(lhs.right, rhs.right),
|
|
(std::min)(lhs.bottom, rhs.bottom)
|
|
};
|
|
}
|
|
|
|
bool IsEmptyRect(const FloatRect& rect) {
|
|
return rect.right <= rect.left || rect.bottom <= rect.top;
|
|
}
|
|
|
|
Rect ClampScissor(const FloatRect& rect, const Rect& renderArea) {
|
|
Rect clamped = {};
|
|
clamped.left = (std::max)(renderArea.left, static_cast<int>(std::floor(rect.left)));
|
|
clamped.top = (std::max)(renderArea.top, static_cast<int>(std::floor(rect.top)));
|
|
clamped.right = (std::min)(renderArea.right, static_cast<int>(std::ceil(rect.right)));
|
|
clamped.bottom = (std::min)(renderArea.bottom, static_cast<int>(std::ceil(rect.bottom)));
|
|
if (clamped.right < clamped.left) {
|
|
clamped.right = clamped.left;
|
|
}
|
|
if (clamped.bottom < clamped.top) {
|
|
clamped.bottom = clamped.top;
|
|
}
|
|
return clamped;
|
|
}
|
|
|
|
bool IsEmptyScissor(const Rect& rect) {
|
|
return rect.right <= rect.left || rect.bottom <= rect.top;
|
|
}
|
|
|
|
constexpr std::uint64_t kFnvOffsetBasis = 14695981039346656037ull;
|
|
constexpr std::uint64_t kFnvPrime = 1099511628211ull;
|
|
|
|
void HashBytes(
|
|
std::uint64_t& hash,
|
|
const void* data,
|
|
std::size_t size) {
|
|
const auto* bytes = static_cast<const unsigned char*>(data);
|
|
for (std::size_t index = 0u; index < size; ++index) {
|
|
hash ^= static_cast<std::uint64_t>(bytes[index]);
|
|
hash *= kFnvPrime;
|
|
}
|
|
}
|
|
|
|
void HashFloat(std::uint64_t& hash, float value) {
|
|
std::uint32_t bits = 0u;
|
|
static_assert(sizeof(bits) == sizeof(value));
|
|
std::memcpy(&bits, &value, sizeof(bits));
|
|
HashBytes(hash, &bits, sizeof(bits));
|
|
}
|
|
|
|
void HashBool(std::uint64_t& hash, bool value) {
|
|
const std::uint8_t encoded = value ? 1u : 0u;
|
|
HashBytes(hash, &encoded, sizeof(encoded));
|
|
}
|
|
|
|
void HashString(std::uint64_t& hash, std::string_view value) {
|
|
const std::size_t size = value.size();
|
|
HashBytes(hash, &size, sizeof(size));
|
|
if (!value.empty()) {
|
|
HashBytes(hash, value.data(), value.size());
|
|
}
|
|
}
|
|
|
|
void HashTextureHandle(std::uint64_t& hash, const UITextureHandle& texture) {
|
|
HashBytes(hash, &texture.nativeHandle, sizeof(texture.nativeHandle));
|
|
HashBytes(hash, &texture.width, sizeof(texture.width));
|
|
HashBytes(hash, &texture.height, sizeof(texture.height));
|
|
HashBytes(hash, &texture.kind, sizeof(texture.kind));
|
|
HashBytes(hash, &texture.resourceHandle, sizeof(texture.resourceHandle));
|
|
}
|
|
|
|
void HashPoint(std::uint64_t& hash, const UIPoint& point) {
|
|
HashFloat(hash, point.x);
|
|
HashFloat(hash, point.y);
|
|
}
|
|
|
|
void HashRect(std::uint64_t& hash, const UIRect& rect) {
|
|
HashFloat(hash, rect.x);
|
|
HashFloat(hash, rect.y);
|
|
HashFloat(hash, rect.width);
|
|
HashFloat(hash, rect.height);
|
|
}
|
|
|
|
std::uint64_t BuildDrawListContentHash(const UIDrawList& drawList) {
|
|
std::uint64_t hash = kFnvOffsetBasis;
|
|
HashString(hash, drawList.GetDebugName());
|
|
|
|
const std::size_t commandCount = drawList.GetCommandCount();
|
|
HashBytes(hash, &commandCount, sizeof(commandCount));
|
|
|
|
for (const UIDrawCommand& command : drawList.GetCommands()) {
|
|
HashBytes(hash, &command.type, sizeof(command.type));
|
|
HashRect(hash, command.rect);
|
|
HashPoint(hash, command.position);
|
|
HashPoint(hash, command.uvMin);
|
|
HashPoint(hash, command.uvMax);
|
|
HashFloat(hash, command.color.r);
|
|
HashFloat(hash, command.color.g);
|
|
HashFloat(hash, command.color.b);
|
|
HashFloat(hash, command.color.a);
|
|
HashFloat(hash, command.secondaryColor.r);
|
|
HashFloat(hash, command.secondaryColor.g);
|
|
HashFloat(hash, command.secondaryColor.b);
|
|
HashFloat(hash, command.secondaryColor.a);
|
|
HashFloat(hash, command.thickness);
|
|
HashFloat(hash, command.rounding);
|
|
HashFloat(hash, command.radius);
|
|
HashFloat(hash, command.fontSize);
|
|
HashBool(hash, command.intersectWithCurrentClip);
|
|
HashBytes(hash, &command.gradientDirection, sizeof(command.gradientDirection));
|
|
HashTextureHandle(hash, command.texture);
|
|
HashString(hash, command.text);
|
|
}
|
|
|
|
return hash;
|
|
}
|
|
|
|
void WriteColor(float outColor[4], const UIColor& color) {
|
|
outColor[0] = color.r;
|
|
outColor[1] = color.g;
|
|
outColor[2] = color.b;
|
|
outColor[3] = color.a;
|
|
}
|
|
|
|
void AppendBatch(
|
|
std::vector<D3D12UiRenderer::UiBatch>& batches,
|
|
std::uint32_t firstInstance,
|
|
std::uint32_t instanceCount,
|
|
D3D12_GPU_DESCRIPTOR_HANDLE textureHandle,
|
|
const Rect& scissor) {
|
|
if (instanceCount == 0u || textureHandle.ptr == 0u || IsEmptyScissor(scissor)) {
|
|
return;
|
|
}
|
|
|
|
if (!batches.empty()) {
|
|
D3D12UiRenderer::UiBatch& lastBatch = batches.back();
|
|
if (lastBatch.textureHandle.ptr == textureHandle.ptr &&
|
|
lastBatch.scissorRect.left == scissor.left &&
|
|
lastBatch.scissorRect.top == scissor.top &&
|
|
lastBatch.scissorRect.right == scissor.right &&
|
|
lastBatch.scissorRect.bottom == scissor.bottom &&
|
|
lastBatch.firstInstance + lastBatch.instanceCount == firstInstance) {
|
|
lastBatch.instanceCount += instanceCount;
|
|
return;
|
|
}
|
|
}
|
|
|
|
D3D12UiRenderer::UiBatch batch = {};
|
|
batch.firstInstance = firstInstance;
|
|
batch.instanceCount = instanceCount;
|
|
batch.textureHandle = textureHandle;
|
|
batch.scissorRect = scissor;
|
|
batches.push_back(batch);
|
|
}
|
|
|
|
void AppendPrimitiveInstance(
|
|
std::vector<D3D12UiRenderer::UiPrimitiveInstance>& instances,
|
|
std::vector<D3D12UiRenderer::UiBatch>& batches,
|
|
const FloatPoint& origin,
|
|
const FloatPoint& axisX,
|
|
const FloatPoint& axisY,
|
|
const UIPoint& uvMin,
|
|
const UIPoint& uvMax,
|
|
const UIColor& color,
|
|
const UIColor& secondaryColor,
|
|
UiPrimitiveKind primitiveKind,
|
|
float radius,
|
|
float thickness,
|
|
float gradientDirection,
|
|
const float aux0[4],
|
|
const float aux1[4],
|
|
D3D12_GPU_DESCRIPTOR_HANDLE textureHandle,
|
|
const Rect& scissor) {
|
|
if (textureHandle.ptr == 0u || IsEmptyScissor(scissor)) {
|
|
return;
|
|
}
|
|
|
|
D3D12UiRenderer::UiPrimitiveInstance instance = {};
|
|
instance.origin[0] = origin.x;
|
|
instance.origin[1] = origin.y;
|
|
instance.axisX[0] = axisX.x;
|
|
instance.axisX[1] = axisX.y;
|
|
instance.axisY[0] = axisY.x;
|
|
instance.axisY[1] = axisY.y;
|
|
instance.uvMin[0] = uvMin.x;
|
|
instance.uvMin[1] = uvMin.y;
|
|
instance.uvMax[0] = uvMax.x;
|
|
instance.uvMax[1] = uvMax.y;
|
|
WriteColor(instance.color, color);
|
|
WriteColor(instance.secondaryColor, secondaryColor);
|
|
instance.params[0] = static_cast<float>(static_cast<int>(primitiveKind));
|
|
instance.params[1] = radius;
|
|
instance.params[2] = thickness;
|
|
instance.params[3] = gradientDirection;
|
|
std::memcpy(instance.aux0, aux0, sizeof(instance.aux0));
|
|
std::memcpy(instance.aux1, aux1, sizeof(instance.aux1));
|
|
const std::uint32_t firstInstance = static_cast<std::uint32_t>(instances.size());
|
|
instances.push_back(instance);
|
|
AppendBatch(batches, firstInstance, 1u, textureHandle, scissor);
|
|
}
|
|
|
|
GraphicsPipelineDesc BuildBaseUiPipelineDesc(
|
|
::XCEngine::RHI::RHIPipelineLayout* pipelineLayout,
|
|
const RenderSurface& surface) {
|
|
GraphicsPipelineDesc pipelineDesc = {};
|
|
pipelineDesc.pipelineLayout = pipelineLayout;
|
|
pipelineDesc.topologyType =
|
|
static_cast<std::uint32_t>(PrimitiveTopologyType::Triangle);
|
|
::XCEngine::Rendering::ApplySingleColorAttachmentPropertiesToGraphicsPipelineDesc(
|
|
surface,
|
|
pipelineDesc);
|
|
|
|
pipelineDesc.inputLayout.elements = {
|
|
{ "POSITION", 0, static_cast<std::uint32_t>(Format::R32G32_Float), 0, 0, 0, 0 },
|
|
{ "TEXCOORD", 0, static_cast<std::uint32_t>(Format::R32G32_Float), 0, 8, 0, 0 },
|
|
{ "COLOR", 0, static_cast<std::uint32_t>(Format::R32G32B32A32_Float), 0, 16, 0, 0 }
|
|
};
|
|
|
|
pipelineDesc.rasterizerState.fillMode =
|
|
static_cast<std::uint32_t>(FillMode::Solid);
|
|
pipelineDesc.rasterizerState.cullMode =
|
|
static_cast<std::uint32_t>(CullMode::None);
|
|
pipelineDesc.rasterizerState.frontFace =
|
|
static_cast<std::uint32_t>(FrontFace::CounterClockwise);
|
|
pipelineDesc.rasterizerState.depthClipEnable = true;
|
|
pipelineDesc.rasterizerState.scissorTestEnable = true;
|
|
|
|
pipelineDesc.blendState.blendEnable = true;
|
|
pipelineDesc.blendState.srcBlend =
|
|
static_cast<std::uint32_t>(BlendFactor::SrcAlpha);
|
|
pipelineDesc.blendState.dstBlend =
|
|
static_cast<std::uint32_t>(BlendFactor::InvSrcAlpha);
|
|
pipelineDesc.blendState.srcBlendAlpha =
|
|
static_cast<std::uint32_t>(BlendFactor::One);
|
|
pipelineDesc.blendState.dstBlendAlpha =
|
|
static_cast<std::uint32_t>(BlendFactor::InvSrcAlpha);
|
|
pipelineDesc.blendState.blendOp =
|
|
static_cast<std::uint32_t>(BlendOp::Add);
|
|
pipelineDesc.blendState.blendOpAlpha =
|
|
static_cast<std::uint32_t>(BlendOp::Add);
|
|
pipelineDesc.blendState.colorWriteMask =
|
|
static_cast<std::uint8_t>(ColorWriteMask::All);
|
|
|
|
pipelineDesc.depthStencilState.depthTestEnable = false;
|
|
pipelineDesc.depthStencilState.depthWriteEnable = false;
|
|
pipelineDesc.depthStencilState.depthFunc =
|
|
static_cast<std::uint32_t>(ComparisonFunc::Always);
|
|
return pipelineDesc;
|
|
}
|
|
|
|
GraphicsPipelineDesc BuildPrimitiveUiPipelineDesc(
|
|
::XCEngine::RHI::RHIPipelineLayout* pipelineLayout,
|
|
const RenderSurface& surface) {
|
|
GraphicsPipelineDesc pipelineDesc = BuildBaseUiPipelineDesc(pipelineLayout, surface);
|
|
pipelineDesc.inputLayout.elements = {
|
|
{ "POSITION", 0, static_cast<std::uint32_t>(Format::R32G32_Float), 0, 0, 0, 0 },
|
|
{ "TEXCOORD", 0, static_cast<std::uint32_t>(Format::R32G32_Float), 0, 8, 0, 0 },
|
|
{ "POSITION", 1, static_cast<std::uint32_t>(Format::R32G32_Float), 1, 0, 1, 1 },
|
|
{ "TEXCOORD", 1, static_cast<std::uint32_t>(Format::R32G32_Float), 1, 8, 1, 1 },
|
|
{ "TEXCOORD", 2, static_cast<std::uint32_t>(Format::R32G32_Float), 1, 16, 1, 1 },
|
|
{ "TEXCOORD", 3, static_cast<std::uint32_t>(Format::R32G32_Float), 1, 24, 1, 1 },
|
|
{ "TEXCOORD", 4, static_cast<std::uint32_t>(Format::R32G32_Float), 1, 32, 1, 1 },
|
|
{ "COLOR", 0, static_cast<std::uint32_t>(Format::R32G32B32A32_Float), 1, 40, 1, 1 },
|
|
{ "COLOR", 1, static_cast<std::uint32_t>(Format::R32G32B32A32_Float), 1, 56, 1, 1 },
|
|
{ "TEXCOORD", 5, static_cast<std::uint32_t>(Format::R32G32B32A32_Float), 1, 72, 1, 1 },
|
|
{ "TEXCOORD", 6, static_cast<std::uint32_t>(Format::R32G32B32A32_Float), 1, 88, 1, 1 },
|
|
{ "TEXCOORD", 7, static_cast<std::uint32_t>(Format::R32G32B32A32_Float), 1, 104, 1, 1 }
|
|
};
|
|
|
|
pipelineDesc.vertexShader.source.assign(
|
|
kPrimitiveUiPassHlsl,
|
|
kPrimitiveUiPassHlsl + std::strlen(kPrimitiveUiPassHlsl));
|
|
pipelineDesc.vertexShader.sourceLanguage = ::XCEngine::RHI::ShaderLanguage::HLSL;
|
|
pipelineDesc.vertexShader.entryPoint = L"MainVS";
|
|
pipelineDesc.vertexShader.profile = L"vs_5_0";
|
|
|
|
pipelineDesc.fragmentShader.source.assign(
|
|
kPrimitiveUiPassHlsl,
|
|
kPrimitiveUiPassHlsl + std::strlen(kPrimitiveUiPassHlsl));
|
|
pipelineDesc.fragmentShader.sourceLanguage = ::XCEngine::RHI::ShaderLanguage::HLSL;
|
|
pipelineDesc.fragmentShader.entryPoint = L"MainPS";
|
|
pipelineDesc.fragmentShader.profile = L"ps_5_0";
|
|
return pipelineDesc;
|
|
}
|
|
|
|
} // namespace
|
|
|
|
bool D3D12UiRenderer::TextRunCacheKey::operator==(const TextRunCacheKey& other) const {
|
|
return text == other.text &&
|
|
fontSizeTenths == other.fontSizeTenths &&
|
|
dpiScaleMilli == other.dpiScaleMilli;
|
|
}
|
|
|
|
std::size_t D3D12UiRenderer::TextRunCacheKeyHash::operator()(
|
|
const TextRunCacheKey& key) const {
|
|
const std::size_t textHash = std::hash<std::string>{}(key.text);
|
|
const std::size_t fontHash = std::hash<int>{}(key.fontSizeTenths);
|
|
const std::size_t dpiHash = std::hash<int>{}(key.dpiScaleMilli);
|
|
return textHash ^ (fontHash << 1u) ^ (dpiHash << 2u);
|
|
}
|
|
|
|
bool D3D12UiRenderer::CompiledDrawListKey::operator==(
|
|
const CompiledDrawListKey& other) const {
|
|
return contentHash == other.contentHash &&
|
|
renderWidth == other.renderWidth &&
|
|
renderHeight == other.renderHeight &&
|
|
dpiScaleMilli == other.dpiScaleMilli;
|
|
}
|
|
|
|
std::size_t D3D12UiRenderer::CompiledDrawListKeyHash::operator()(
|
|
const CompiledDrawListKey& key) const {
|
|
const std::size_t contentHashValue = std::hash<std::uint64_t>{}(key.contentHash);
|
|
const std::size_t widthHash = std::hash<std::uint32_t>{}(key.renderWidth);
|
|
const std::size_t heightHash = std::hash<std::uint32_t>{}(key.renderHeight);
|
|
const std::size_t dpiHash = std::hash<int>{}(key.dpiScaleMilli);
|
|
return contentHashValue ^
|
|
(widthHash << 1u) ^
|
|
(heightHash << 2u) ^
|
|
(dpiHash << 3u);
|
|
}
|
|
|
|
bool D3D12UiRenderer::Initialize(
|
|
D3D12WindowRenderer& windowRenderer,
|
|
D3D12UiTextureHost& textureHost,
|
|
D3D12UiTextSystem& textSystem) {
|
|
const float dpiScale = m_dpiScale;
|
|
Shutdown();
|
|
|
|
m_windowRenderer = &windowRenderer;
|
|
m_textureHost = &textureHost;
|
|
m_textSystem = &textSystem;
|
|
m_dpiScale = ClampDpiScale(dpiScale);
|
|
m_lastError.clear();
|
|
return true;
|
|
}
|
|
|
|
void D3D12UiRenderer::Shutdown() {
|
|
ReleaseTextRunCache();
|
|
ReleaseCompiledDrawListCache();
|
|
if (m_textureHost != nullptr) {
|
|
m_textureHost->ReleaseTexture(m_whiteTexture);
|
|
} else {
|
|
m_whiteTexture = {};
|
|
}
|
|
|
|
DestroyResources();
|
|
m_windowRenderer = nullptr;
|
|
m_textureHost = nullptr;
|
|
m_textSystem = nullptr;
|
|
m_dpiScale = 1.0f;
|
|
m_compiledDrawListFrameCounter = 0u;
|
|
m_lastError.clear();
|
|
}
|
|
|
|
void D3D12UiRenderer::SetDpiScale(float dpiScale) {
|
|
const float resolvedScale = ClampDpiScale(dpiScale);
|
|
if (std::abs(m_dpiScale - resolvedScale) > 0.0001f) {
|
|
ReleaseTextRunCache();
|
|
ReleaseCompiledDrawListCache();
|
|
}
|
|
m_dpiScale = resolvedScale;
|
|
}
|
|
|
|
float D3D12UiRenderer::GetDpiScale() const {
|
|
return m_dpiScale;
|
|
}
|
|
|
|
const std::string& D3D12UiRenderer::GetLastError() const {
|
|
return m_lastError;
|
|
}
|
|
|
|
bool D3D12UiRenderer::EnsureWhiteTexture() {
|
|
if (m_whiteTexture.IsValid()) {
|
|
return true;
|
|
}
|
|
|
|
if (m_textureHost == nullptr) {
|
|
m_lastError = "EnsureWhiteTexture requires an initialized texture host.";
|
|
return false;
|
|
}
|
|
|
|
const std::uint8_t whitePixel[4] = { 255u, 255u, 255u, 255u };
|
|
std::string error = {};
|
|
if (!m_textureHost->LoadTextureFromRgba(
|
|
whitePixel,
|
|
1u,
|
|
1u,
|
|
m_whiteTexture,
|
|
error)) {
|
|
m_lastError = error.empty()
|
|
? "Failed to create the UI white texture."
|
|
: error;
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
const D3D12UiRenderer::CachedTextRun* D3D12UiRenderer::ResolveTextRun(
|
|
std::string_view text,
|
|
float fontSize,
|
|
std::uint64_t currentFrameId) {
|
|
if (m_textureHost == nullptr || m_textSystem == nullptr) {
|
|
return nullptr;
|
|
}
|
|
|
|
TextRunCacheKey cacheKey = {};
|
|
cacheKey.text.assign(text);
|
|
cacheKey.fontSizeTenths =
|
|
static_cast<int>(std::lround(ResolveFontSize(fontSize) * 10.0f));
|
|
cacheKey.dpiScaleMilli =
|
|
static_cast<int>(std::lround(ClampDpiScale(m_dpiScale) * 1000.0f));
|
|
|
|
const auto found = m_textRunCache.find(cacheKey);
|
|
if (found != m_textRunCache.end()) {
|
|
found->second.lastUsedFrame = currentFrameId;
|
|
return &found->second;
|
|
}
|
|
|
|
std::string error = {};
|
|
D3D12UiTextSystem::RasterizedTextRun rasterizedText = {};
|
|
if (!m_textSystem->RasterizeTextMask(text, fontSize, rasterizedText, error)) {
|
|
m_lastError = error.empty()
|
|
? "Failed to rasterize the UI text run."
|
|
: error;
|
|
return nullptr;
|
|
}
|
|
|
|
CachedTextRun cachedText = {};
|
|
cachedText.offsetX = rasterizedText.offsetX;
|
|
cachedText.offsetY = rasterizedText.offsetY;
|
|
cachedText.width = static_cast<float>(rasterizedText.width);
|
|
cachedText.height = static_cast<float>(rasterizedText.height);
|
|
cachedText.lastUsedFrame = currentFrameId;
|
|
cachedText.hasPixels =
|
|
rasterizedText.width > 0u &&
|
|
rasterizedText.height > 0u &&
|
|
!rasterizedText.rgbaPixels.empty();
|
|
|
|
if (cachedText.hasPixels) {
|
|
if (!m_textureHost->LoadTextureFromRgba(
|
|
rasterizedText.rgbaPixels.data(),
|
|
rasterizedText.width,
|
|
rasterizedText.height,
|
|
cachedText.texture,
|
|
error)) {
|
|
m_lastError = error.empty()
|
|
? "Failed to upload the UI text run texture."
|
|
: error;
|
|
return nullptr;
|
|
}
|
|
cachedText.textureHandle.ptr = static_cast<UINT64>(cachedText.texture.nativeHandle);
|
|
}
|
|
|
|
const auto [insertedIt, inserted] =
|
|
m_textRunCache.emplace(std::move(cacheKey), std::move(cachedText));
|
|
(void)inserted;
|
|
return &insertedIt->second;
|
|
}
|
|
|
|
void D3D12UiRenderer::ReleaseTextRunCache() {
|
|
if (m_textureHost != nullptr) {
|
|
for (auto& [key, cachedText] : m_textRunCache) {
|
|
m_textureHost->ReleaseTexture(cachedText.texture);
|
|
cachedText.textureHandle = {};
|
|
}
|
|
}
|
|
m_textRunCache.clear();
|
|
}
|
|
|
|
void D3D12UiRenderer::PruneTextRunCache(std::uint64_t currentFrameId) {
|
|
constexpr std::size_t kTextRunCacheMaxEntries = 512u;
|
|
constexpr std::uint64_t kTextRunCacheRetentionFrames = 240u;
|
|
if (m_textRunCache.size() <= kTextRunCacheMaxEntries) {
|
|
return;
|
|
}
|
|
|
|
const std::uint64_t pruneBeforeFrame =
|
|
currentFrameId > kTextRunCacheRetentionFrames
|
|
? currentFrameId - kTextRunCacheRetentionFrames
|
|
: 0u;
|
|
|
|
bool evictedAny = false;
|
|
for (auto it = m_textRunCache.begin(); it != m_textRunCache.end();) {
|
|
if (it->second.lastUsedFrame <= pruneBeforeFrame) {
|
|
if (m_textureHost != nullptr) {
|
|
m_textureHost->ReleaseTexture(it->second.texture);
|
|
}
|
|
it = m_textRunCache.erase(it);
|
|
evictedAny = true;
|
|
} else {
|
|
++it;
|
|
}
|
|
}
|
|
|
|
if (evictedAny) {
|
|
ReleaseCompiledDrawListCache();
|
|
}
|
|
}
|
|
|
|
void D3D12UiRenderer::ReleaseCompiledDrawListCache() {
|
|
m_compiledDrawListCache.clear();
|
|
}
|
|
|
|
bool D3D12UiRenderer::EnsureInitialized(
|
|
const RenderContext& renderContext,
|
|
const RenderSurface& surface) {
|
|
const Format renderTargetFormat =
|
|
::XCEngine::Rendering::ResolveSurfaceColorFormat(surface, 0u);
|
|
const std::uint32_t sampleCount =
|
|
::XCEngine::Rendering::ResolveSurfaceSampleCount(surface);
|
|
const std::uint32_t sampleQuality =
|
|
::XCEngine::Rendering::ResolveSurfaceSampleQuality(surface);
|
|
|
|
if (m_device == renderContext.device &&
|
|
m_backendType == renderContext.backendType &&
|
|
m_pipelineLayout != nullptr &&
|
|
m_primitivePipelineState != nullptr &&
|
|
m_constantPool != nullptr &&
|
|
m_constantSet != nullptr &&
|
|
m_samplerPool != nullptr &&
|
|
m_samplerSet != nullptr &&
|
|
m_sampler != nullptr &&
|
|
m_quadVertexBuffer != nullptr &&
|
|
m_quadVertexBufferView != nullptr &&
|
|
m_quadIndexBuffer != nullptr &&
|
|
m_quadIndexBufferView != nullptr &&
|
|
m_renderTargetFormat == renderTargetFormat &&
|
|
m_renderTargetSampleCount == sampleCount &&
|
|
m_renderTargetSampleQuality == sampleQuality) {
|
|
return true;
|
|
}
|
|
|
|
DestroyResources();
|
|
return CreateResources(renderContext, surface);
|
|
}
|
|
|
|
bool D3D12UiRenderer::CreateResources(
|
|
const RenderContext& renderContext,
|
|
const RenderSurface& surface) {
|
|
if (!renderContext.IsValid() ||
|
|
renderContext.device == nullptr ||
|
|
!::XCEngine::Rendering::HasSingleColorAttachment(surface) ||
|
|
::XCEngine::Rendering::ResolveSurfaceColorFormat(surface, 0u) == Format::Unknown) {
|
|
m_lastError = "CreateResources requires a valid single-color render surface.";
|
|
return false;
|
|
}
|
|
|
|
m_device = renderContext.device;
|
|
m_backendType = renderContext.backendType;
|
|
m_renderTargetFormat =
|
|
::XCEngine::Rendering::ResolveSurfaceColorFormat(surface, 0u);
|
|
m_renderTargetSampleCount =
|
|
::XCEngine::Rendering::ResolveSurfaceSampleCount(surface);
|
|
m_renderTargetSampleQuality =
|
|
::XCEngine::Rendering::ResolveSurfaceSampleQuality(surface);
|
|
|
|
DescriptorSetLayoutBinding constantBinding = {};
|
|
constantBinding.binding = 0u;
|
|
constantBinding.type = static_cast<std::uint32_t>(DescriptorType::CBV);
|
|
constantBinding.count = 1u;
|
|
constantBinding.visibility = static_cast<std::uint32_t>(ShaderVisibility::All);
|
|
|
|
DescriptorSetLayoutBinding textureBinding = {};
|
|
textureBinding.binding = 0u;
|
|
textureBinding.type = static_cast<std::uint32_t>(DescriptorType::SRV);
|
|
textureBinding.count = 1u;
|
|
textureBinding.visibility = static_cast<std::uint32_t>(ShaderVisibility::All);
|
|
|
|
DescriptorSetLayoutBinding samplerBinding = {};
|
|
samplerBinding.binding = 0u;
|
|
samplerBinding.type = static_cast<std::uint32_t>(DescriptorType::Sampler);
|
|
samplerBinding.count = 1u;
|
|
samplerBinding.visibility = static_cast<std::uint32_t>(ShaderVisibility::All);
|
|
|
|
DescriptorSetLayoutDesc setLayouts[3] = {};
|
|
setLayouts[0].bindings = &constantBinding;
|
|
setLayouts[0].bindingCount = 1u;
|
|
setLayouts[1].bindings = &textureBinding;
|
|
setLayouts[1].bindingCount = 1u;
|
|
setLayouts[2].bindings = &samplerBinding;
|
|
setLayouts[2].bindingCount = 1u;
|
|
|
|
RHIPipelineLayoutDesc pipelineLayoutDesc = {};
|
|
pipelineLayoutDesc.setLayouts = setLayouts;
|
|
pipelineLayoutDesc.setLayoutCount = 3u;
|
|
m_pipelineLayout = m_device->CreatePipelineLayout(pipelineLayoutDesc);
|
|
if (m_pipelineLayout == nullptr) {
|
|
m_lastError = "Failed to create the D3D12 UI pipeline layout.";
|
|
DestroyResources();
|
|
return false;
|
|
}
|
|
|
|
DescriptorPoolDesc constantPoolDesc = {};
|
|
constantPoolDesc.type = DescriptorHeapType::CBV_SRV_UAV;
|
|
constantPoolDesc.descriptorCount = 1u;
|
|
constantPoolDesc.shaderVisible = false;
|
|
m_constantPool = m_device->CreateDescriptorPool(constantPoolDesc);
|
|
if (m_constantPool == nullptr) {
|
|
m_lastError = "Failed to create the D3D12 UI constant descriptor pool.";
|
|
DestroyResources();
|
|
return false;
|
|
}
|
|
|
|
m_constantSet = m_constantPool->AllocateSet(setLayouts[0]);
|
|
if (m_constantSet == nullptr) {
|
|
m_lastError = "Failed to allocate the D3D12 UI constant descriptor set.";
|
|
DestroyResources();
|
|
return false;
|
|
}
|
|
|
|
SamplerDesc samplerDesc = {};
|
|
samplerDesc.filter = static_cast<std::uint32_t>(FilterMode::Linear);
|
|
samplerDesc.addressU = static_cast<std::uint32_t>(TextureAddressMode::Clamp);
|
|
samplerDesc.addressV = static_cast<std::uint32_t>(TextureAddressMode::Clamp);
|
|
samplerDesc.addressW = static_cast<std::uint32_t>(TextureAddressMode::Clamp);
|
|
samplerDesc.maxAnisotropy = 1u;
|
|
samplerDesc.comparisonFunc = static_cast<std::uint32_t>(ComparisonFunc::Always);
|
|
samplerDesc.minLod = 0.0f;
|
|
samplerDesc.maxLod = 16.0f;
|
|
m_sampler = m_device->CreateSampler(samplerDesc);
|
|
if (m_sampler == nullptr) {
|
|
m_lastError = "Failed to create the D3D12 UI sampler.";
|
|
DestroyResources();
|
|
return false;
|
|
}
|
|
|
|
DescriptorPoolDesc samplerPoolDesc = {};
|
|
samplerPoolDesc.type = DescriptorHeapType::Sampler;
|
|
samplerPoolDesc.descriptorCount = 1u;
|
|
samplerPoolDesc.shaderVisible = true;
|
|
m_samplerPool = m_device->CreateDescriptorPool(samplerPoolDesc);
|
|
if (m_samplerPool == nullptr) {
|
|
m_lastError = "Failed to create the D3D12 UI sampler descriptor pool.";
|
|
DestroyResources();
|
|
return false;
|
|
}
|
|
|
|
m_samplerSet = m_samplerPool->AllocateSet(setLayouts[2]);
|
|
if (m_samplerSet == nullptr) {
|
|
m_lastError = "Failed to allocate the D3D12 UI sampler descriptor set.";
|
|
DestroyResources();
|
|
return false;
|
|
}
|
|
|
|
m_samplerSet->UpdateSampler(0u, m_sampler);
|
|
auto* samplerDescriptorSet = static_cast<D3D12DescriptorSet*>(m_samplerSet);
|
|
m_samplerGpuHandle = samplerDescriptorSet->GetGPUHandleForBinding(0u);
|
|
if (m_samplerGpuHandle.ptr == 0u) {
|
|
m_lastError = "Failed to resolve the D3D12 UI sampler GPU descriptor handle.";
|
|
DestroyResources();
|
|
return false;
|
|
}
|
|
|
|
m_primitivePipelineState = m_device->CreatePipelineState(
|
|
BuildPrimitiveUiPipelineDesc(m_pipelineLayout, surface));
|
|
if (m_primitivePipelineState == nullptr || !m_primitivePipelineState->IsValid()) {
|
|
m_lastError = "Failed to create the D3D12 UI primitive pipeline state.";
|
|
DestroyResources();
|
|
return false;
|
|
}
|
|
|
|
BufferDesc quadVertexBufferDesc = {};
|
|
quadVertexBufferDesc.size = sizeof(kUnitQuadVertices);
|
|
quadVertexBufferDesc.stride = static_cast<std::uint32_t>(sizeof(UiQuadVertex));
|
|
quadVertexBufferDesc.bufferType = static_cast<std::uint32_t>(BufferType::Vertex);
|
|
m_quadVertexBuffer =
|
|
m_device->CreateBuffer(quadVertexBufferDesc, kUnitQuadVertices, sizeof(kUnitQuadVertices));
|
|
if (m_quadVertexBuffer == nullptr) {
|
|
m_lastError = "Failed to create the D3D12 UI unit-quad vertex buffer.";
|
|
DestroyResources();
|
|
return false;
|
|
}
|
|
m_quadVertexBuffer->SetStride(quadVertexBufferDesc.stride);
|
|
m_quadVertexBuffer->SetBufferType(BufferType::Vertex);
|
|
|
|
ResourceViewDesc quadVertexViewDesc = {};
|
|
quadVertexViewDesc.dimension = ResourceViewDimension::Buffer;
|
|
quadVertexViewDesc.structureByteStride = quadVertexBufferDesc.stride;
|
|
m_quadVertexBufferView =
|
|
m_device->CreateVertexBufferView(m_quadVertexBuffer, quadVertexViewDesc);
|
|
if (m_quadVertexBufferView == nullptr) {
|
|
m_lastError = "Failed to create the D3D12 UI unit-quad vertex view.";
|
|
DestroyResources();
|
|
return false;
|
|
}
|
|
|
|
BufferDesc quadIndexBufferDesc = {};
|
|
quadIndexBufferDesc.size = sizeof(kUnitQuadIndices);
|
|
quadIndexBufferDesc.stride = static_cast<std::uint32_t>(sizeof(std::uint32_t));
|
|
quadIndexBufferDesc.bufferType = static_cast<std::uint32_t>(BufferType::Index);
|
|
m_quadIndexBuffer =
|
|
m_device->CreateBuffer(quadIndexBufferDesc, kUnitQuadIndices, sizeof(kUnitQuadIndices));
|
|
if (m_quadIndexBuffer == nullptr) {
|
|
m_lastError = "Failed to create the D3D12 UI unit-quad index buffer.";
|
|
DestroyResources();
|
|
return false;
|
|
}
|
|
m_quadIndexBuffer->SetStride(quadIndexBufferDesc.stride);
|
|
m_quadIndexBuffer->SetBufferType(BufferType::Index);
|
|
|
|
ResourceViewDesc quadIndexViewDesc = {};
|
|
quadIndexViewDesc.dimension = ResourceViewDimension::Buffer;
|
|
quadIndexViewDesc.format = static_cast<std::uint32_t>(Format::R32_UInt);
|
|
m_quadIndexBufferView =
|
|
m_device->CreateIndexBufferView(m_quadIndexBuffer, quadIndexViewDesc);
|
|
if (m_quadIndexBufferView == nullptr) {
|
|
m_lastError = "Failed to create the D3D12 UI unit-quad index view.";
|
|
DestroyResources();
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void D3D12UiRenderer::DestroyFrameResources(FrameResources& frameResources) {
|
|
if (frameResources.primitiveInstanceBufferView != nullptr) {
|
|
frameResources.primitiveInstanceBufferView->Shutdown();
|
|
delete frameResources.primitiveInstanceBufferView;
|
|
frameResources.primitiveInstanceBufferView = nullptr;
|
|
}
|
|
if (frameResources.primitiveInstanceBuffer != nullptr) {
|
|
frameResources.primitiveInstanceBuffer->Shutdown();
|
|
delete frameResources.primitiveInstanceBuffer;
|
|
frameResources.primitiveInstanceBuffer = nullptr;
|
|
}
|
|
frameResources.primitiveInstanceCapacityBytes = 0u;
|
|
}
|
|
|
|
void D3D12UiRenderer::DestroyResources() {
|
|
for (FrameResources& frameResources : m_frameResources) {
|
|
DestroyFrameResources(frameResources);
|
|
}
|
|
|
|
if (m_quadIndexBufferView != nullptr) {
|
|
m_quadIndexBufferView->Shutdown();
|
|
delete m_quadIndexBufferView;
|
|
m_quadIndexBufferView = nullptr;
|
|
}
|
|
if (m_quadIndexBuffer != nullptr) {
|
|
m_quadIndexBuffer->Shutdown();
|
|
delete m_quadIndexBuffer;
|
|
m_quadIndexBuffer = nullptr;
|
|
}
|
|
if (m_quadVertexBufferView != nullptr) {
|
|
m_quadVertexBufferView->Shutdown();
|
|
delete m_quadVertexBufferView;
|
|
m_quadVertexBufferView = nullptr;
|
|
}
|
|
if (m_quadVertexBuffer != nullptr) {
|
|
m_quadVertexBuffer->Shutdown();
|
|
delete m_quadVertexBuffer;
|
|
m_quadVertexBuffer = nullptr;
|
|
}
|
|
if (m_primitivePipelineState != nullptr) {
|
|
m_primitivePipelineState->Shutdown();
|
|
delete m_primitivePipelineState;
|
|
m_primitivePipelineState = nullptr;
|
|
}
|
|
if (m_samplerSet != nullptr) {
|
|
m_samplerSet->Shutdown();
|
|
delete m_samplerSet;
|
|
m_samplerSet = nullptr;
|
|
}
|
|
if (m_samplerPool != nullptr) {
|
|
m_samplerPool->Shutdown();
|
|
delete m_samplerPool;
|
|
m_samplerPool = nullptr;
|
|
}
|
|
if (m_sampler != nullptr) {
|
|
m_sampler->Shutdown();
|
|
delete m_sampler;
|
|
m_sampler = nullptr;
|
|
}
|
|
if (m_constantSet != nullptr) {
|
|
m_constantSet->Shutdown();
|
|
delete m_constantSet;
|
|
m_constantSet = nullptr;
|
|
}
|
|
if (m_constantPool != nullptr) {
|
|
m_constantPool->Shutdown();
|
|
delete m_constantPool;
|
|
m_constantPool = nullptr;
|
|
}
|
|
if (m_pipelineLayout != nullptr) {
|
|
m_pipelineLayout->Shutdown();
|
|
delete m_pipelineLayout;
|
|
m_pipelineLayout = nullptr;
|
|
}
|
|
|
|
m_samplerGpuHandle = {};
|
|
m_device = nullptr;
|
|
m_backendType = ::XCEngine::RHI::RHIType::D3D12;
|
|
m_renderTargetFormat = Format::Unknown;
|
|
m_renderTargetSampleCount = 1u;
|
|
m_renderTargetSampleQuality = 0u;
|
|
}
|
|
|
|
bool D3D12UiRenderer::EnsureFrameBufferCapacity(
|
|
std::uint32_t frameSlot,
|
|
std::size_t primitiveInstanceBytes) {
|
|
if (m_device == nullptr || frameSlot >= m_frameResources.size()) {
|
|
return false;
|
|
}
|
|
|
|
FrameResources& frameResources = m_frameResources[frameSlot];
|
|
auto ensureVertexBuffer =
|
|
[&](std::size_t requiredBytes,
|
|
std::uint64_t minimumBytes,
|
|
std::uint32_t stride,
|
|
::XCEngine::RHI::RHIBuffer*& buffer,
|
|
::XCEngine::RHI::RHIResourceView*& bufferView,
|
|
std::uint64_t& capacityBytes) -> bool {
|
|
if (requiredBytes == 0u) {
|
|
return true;
|
|
}
|
|
|
|
const std::uint64_t resolvedRequiredBytes =
|
|
(std::max<std::uint64_t>)(static_cast<std::uint64_t>(requiredBytes), minimumBytes);
|
|
if (buffer != nullptr && capacityBytes >= resolvedRequiredBytes) {
|
|
return true;
|
|
}
|
|
|
|
if (bufferView != nullptr) {
|
|
bufferView->Shutdown();
|
|
delete bufferView;
|
|
bufferView = nullptr;
|
|
}
|
|
if (buffer != nullptr) {
|
|
buffer->Shutdown();
|
|
delete buffer;
|
|
buffer = nullptr;
|
|
}
|
|
|
|
capacityBytes = resolvedRequiredBytes;
|
|
BufferDesc bufferDesc = {};
|
|
bufferDesc.size = capacityBytes;
|
|
bufferDesc.stride = stride;
|
|
bufferDesc.bufferType = static_cast<std::uint32_t>(BufferType::Vertex);
|
|
buffer = m_device->CreateBuffer(bufferDesc);
|
|
if (buffer == nullptr) {
|
|
capacityBytes = 0u;
|
|
return false;
|
|
}
|
|
buffer->SetStride(bufferDesc.stride);
|
|
buffer->SetBufferType(BufferType::Vertex);
|
|
|
|
ResourceViewDesc viewDesc = {};
|
|
viewDesc.dimension = ResourceViewDimension::Buffer;
|
|
viewDesc.structureByteStride = bufferDesc.stride;
|
|
bufferView = m_device->CreateVertexBufferView(buffer, viewDesc);
|
|
if (bufferView == nullptr) {
|
|
buffer->Shutdown();
|
|
delete buffer;
|
|
buffer = nullptr;
|
|
capacityBytes = 0u;
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
};
|
|
|
|
return ensureVertexBuffer(
|
|
primitiveInstanceBytes,
|
|
kMinDynamicInstanceBufferBytes,
|
|
static_cast<std::uint32_t>(sizeof(UiPrimitiveInstance)),
|
|
frameResources.primitiveInstanceBuffer,
|
|
frameResources.primitiveInstanceBufferView,
|
|
frameResources.primitiveInstanceCapacityBytes);
|
|
}
|
|
|
|
bool D3D12UiRenderer::BuildDrawBatches(
|
|
const UIDrawData& drawData,
|
|
const RenderSurface& surface,
|
|
std::vector<UiPrimitiveInstance>& outPrimitiveInstances,
|
|
std::vector<UiBatch>& outBatches) {
|
|
outPrimitiveInstances.clear();
|
|
outBatches.clear();
|
|
|
|
if (!EnsureWhiteTexture()) {
|
|
return false;
|
|
}
|
|
|
|
const auto renderArea = surface.GetRenderArea();
|
|
const Rect fullScissor = {
|
|
renderArea.x,
|
|
renderArea.y,
|
|
renderArea.x + renderArea.width,
|
|
renderArea.y + renderArea.height
|
|
};
|
|
const FloatRect fullRect = {
|
|
static_cast<float>(fullScissor.left),
|
|
static_cast<float>(fullScissor.top),
|
|
static_cast<float>(fullScissor.right),
|
|
static_cast<float>(fullScissor.bottom)
|
|
};
|
|
|
|
const float dpiScale = ClampDpiScale(m_dpiScale);
|
|
const std::uint64_t currentFrameId = ++m_compiledDrawListFrameCounter;
|
|
const D3D12_GPU_DESCRIPTOR_HANDLE whiteTextureHandle = {
|
|
static_cast<UINT64>(m_whiteTexture.nativeHandle)
|
|
};
|
|
const float zeroAux[4] = { 0.0f, 0.0f, 0.0f, 0.0f };
|
|
|
|
auto buildCompiledDrawList =
|
|
[&](const UIDrawList& drawList,
|
|
std::vector<UiPrimitiveInstance>& compiledInstances,
|
|
std::vector<UiBatch>& compiledBatches) {
|
|
compiledInstances.clear();
|
|
compiledBatches.clear();
|
|
|
|
std::vector<ClipState> localClipStack = {};
|
|
localClipStack.push_back({ fullScissor, fullRect });
|
|
|
|
auto appendAxisAlignedPrimitive =
|
|
[&](const FloatRect& rect,
|
|
const UIPoint& uvMin,
|
|
const UIPoint& uvMax,
|
|
const UIColor& color,
|
|
const UIColor& secondaryColor,
|
|
UiPrimitiveKind primitiveKind,
|
|
float radius,
|
|
float thickness,
|
|
float gradientDirection,
|
|
D3D12_GPU_DESCRIPTOR_HANDLE textureHandle,
|
|
const Rect& scissor) {
|
|
if (IsEmptyRect(rect) || textureHandle.ptr == 0u || IsEmptyScissor(scissor)) {
|
|
return;
|
|
}
|
|
|
|
AppendPrimitiveInstance(
|
|
compiledInstances,
|
|
compiledBatches,
|
|
FloatPoint{ rect.left, rect.top },
|
|
FloatPoint{ rect.right - rect.left, 0.0f },
|
|
FloatPoint{ 0.0f, rect.bottom - rect.top },
|
|
uvMin,
|
|
uvMax,
|
|
color,
|
|
secondaryColor,
|
|
primitiveKind,
|
|
radius,
|
|
thickness,
|
|
gradientDirection,
|
|
zeroAux,
|
|
zeroAux,
|
|
textureHandle,
|
|
scissor);
|
|
};
|
|
|
|
auto appendOrientedPrimitive =
|
|
[&](const FloatPoint& origin,
|
|
const FloatPoint& axisX,
|
|
const FloatPoint& axisY,
|
|
const UIColor& color,
|
|
UiPrimitiveKind primitiveKind,
|
|
float radius,
|
|
float thickness,
|
|
D3D12_GPU_DESCRIPTOR_HANDLE textureHandle,
|
|
const Rect& scissor) {
|
|
if (textureHandle.ptr == 0u || IsEmptyScissor(scissor)) {
|
|
return;
|
|
}
|
|
|
|
AppendPrimitiveInstance(
|
|
compiledInstances,
|
|
compiledBatches,
|
|
origin,
|
|
axisX,
|
|
axisY,
|
|
UIPoint(0.0f, 0.0f),
|
|
UIPoint(1.0f, 1.0f),
|
|
color,
|
|
color,
|
|
primitiveKind,
|
|
radius,
|
|
thickness,
|
|
0.0f,
|
|
zeroAux,
|
|
zeroAux,
|
|
textureHandle,
|
|
scissor);
|
|
};
|
|
|
|
auto appendTrianglePrimitive =
|
|
[&](const FloatPoint& p0,
|
|
const FloatPoint& p1,
|
|
const FloatPoint& p2,
|
|
const UIColor& color,
|
|
D3D12_GPU_DESCRIPTOR_HANDLE textureHandle,
|
|
const Rect& scissor) {
|
|
if (textureHandle.ptr == 0u || IsEmptyScissor(scissor)) {
|
|
return;
|
|
}
|
|
|
|
const float minX = (std::min)({ p0.x, p1.x, p2.x });
|
|
const float minY = (std::min)({ p0.y, p1.y, p2.y });
|
|
const float maxX = (std::max)({ p0.x, p1.x, p2.x });
|
|
const float maxY = (std::max)({ p0.y, p1.y, p2.y });
|
|
if (maxX <= minX || maxY <= minY) {
|
|
return;
|
|
}
|
|
|
|
const FloatPoint origin = { minX, minY };
|
|
const FloatPoint axisX = { maxX - minX, 0.0f };
|
|
const FloatPoint axisY = { 0.0f, maxY - minY };
|
|
const float triangleAux0[4] = {
|
|
p0.x - origin.x,
|
|
p0.y - origin.y,
|
|
p1.x - origin.x,
|
|
p1.y - origin.y
|
|
};
|
|
const float triangleAux1[4] = {
|
|
p2.x - origin.x,
|
|
p2.y - origin.y,
|
|
0.0f,
|
|
0.0f
|
|
};
|
|
|
|
AppendPrimitiveInstance(
|
|
compiledInstances,
|
|
compiledBatches,
|
|
origin,
|
|
axisX,
|
|
axisY,
|
|
UIPoint(0.0f, 0.0f),
|
|
UIPoint(1.0f, 1.0f),
|
|
color,
|
|
color,
|
|
UiPrimitiveKind::TriangleFill,
|
|
0.0f,
|
|
0.0f,
|
|
0.0f,
|
|
triangleAux0,
|
|
triangleAux1,
|
|
textureHandle,
|
|
scissor);
|
|
};
|
|
|
|
for (const UIDrawCommand& command : drawList.GetCommands()) {
|
|
if (localClipStack.empty()) {
|
|
localClipStack.push_back({ fullScissor, fullRect });
|
|
}
|
|
|
|
if (command.type == UIDrawCommandType::PushClipRect) {
|
|
FloatRect clipRect = ToPixelRect(command.rect, dpiScale);
|
|
clipRect = command.intersectWithCurrentClip
|
|
? IntersectFloatRect(localClipStack.back().rect, clipRect)
|
|
: IntersectFloatRect(fullRect, clipRect);
|
|
ClipState clipState = {};
|
|
clipState.rect = clipRect;
|
|
clipState.scissor = ClampScissor(clipRect, fullScissor);
|
|
localClipStack.push_back(clipState);
|
|
continue;
|
|
}
|
|
|
|
if (command.type == UIDrawCommandType::PopClipRect) {
|
|
if (localClipStack.size() > 1u) {
|
|
localClipStack.pop_back();
|
|
}
|
|
continue;
|
|
}
|
|
|
|
const ClipState currentClip = localClipStack.back();
|
|
if (IsEmptyScissor(currentClip.scissor)) {
|
|
continue;
|
|
}
|
|
|
|
switch (command.type) {
|
|
case UIDrawCommandType::FilledRect: {
|
|
appendAxisAlignedPrimitive(
|
|
ToPixelRect(command.rect, dpiScale),
|
|
UIPoint(0.0f, 0.0f),
|
|
UIPoint(1.0f, 1.0f),
|
|
command.color,
|
|
command.color,
|
|
UiPrimitiveKind::RectFill,
|
|
command.rounding * dpiScale,
|
|
0.0f,
|
|
0.0f,
|
|
whiteTextureHandle,
|
|
currentClip.scissor);
|
|
break;
|
|
}
|
|
case UIDrawCommandType::FilledRectLinearGradient: {
|
|
appendAxisAlignedPrimitive(
|
|
ToPixelRect(command.rect, dpiScale),
|
|
UIPoint(0.0f, 0.0f),
|
|
UIPoint(1.0f, 1.0f),
|
|
command.color,
|
|
command.secondaryColor,
|
|
UiPrimitiveKind::RectFill,
|
|
command.rounding * dpiScale,
|
|
0.0f,
|
|
command.gradientDirection == UILinearGradientDirection::Vertical
|
|
? 1.0f
|
|
: 0.0f,
|
|
whiteTextureHandle,
|
|
currentClip.scissor);
|
|
break;
|
|
}
|
|
case UIDrawCommandType::RectOutline: {
|
|
const FloatRect rect = ToPixelRect(command.rect, dpiScale);
|
|
const float thickness =
|
|
(command.thickness > 0.0f ? command.thickness : 1.0f) * dpiScale;
|
|
const float halfThickness = thickness * 0.5f;
|
|
appendAxisAlignedPrimitive(
|
|
FloatRect{
|
|
rect.left - halfThickness,
|
|
rect.top - halfThickness,
|
|
rect.right + halfThickness,
|
|
rect.bottom + halfThickness
|
|
},
|
|
UIPoint(0.0f, 0.0f),
|
|
UIPoint(1.0f, 1.0f),
|
|
command.color,
|
|
command.color,
|
|
UiPrimitiveKind::RectOutline,
|
|
command.rounding * dpiScale + halfThickness,
|
|
thickness,
|
|
0.0f,
|
|
whiteTextureHandle,
|
|
currentClip.scissor);
|
|
break;
|
|
}
|
|
case UIDrawCommandType::Line: {
|
|
const FloatPoint start = ToPixelPoint(command.position, dpiScale);
|
|
const FloatPoint end = ToPixelPoint(command.uvMin, dpiScale);
|
|
const float dx = end.x - start.x;
|
|
const float dy = end.y - start.y;
|
|
const float length = std::sqrt(dx * dx + dy * dy);
|
|
if (length <= 0.0f) {
|
|
break;
|
|
}
|
|
|
|
const float thickness =
|
|
(command.thickness > 0.0f ? command.thickness : 1.0f) * dpiScale;
|
|
const float halfThickness = thickness * 0.5f;
|
|
const float nx = -dy / length;
|
|
const float ny = dx / length;
|
|
appendOrientedPrimitive(
|
|
FloatPoint{ start.x + nx * halfThickness, start.y + ny * halfThickness },
|
|
FloatPoint{ dx, dy },
|
|
FloatPoint{ -nx * thickness, -ny * thickness },
|
|
command.color,
|
|
UiPrimitiveKind::RectFill,
|
|
0.0f,
|
|
0.0f,
|
|
whiteTextureHandle,
|
|
currentClip.scissor);
|
|
break;
|
|
}
|
|
case UIDrawCommandType::FilledTriangle: {
|
|
appendTrianglePrimitive(
|
|
ToPixelPoint(command.position, dpiScale),
|
|
ToPixelPoint(command.uvMin, dpiScale),
|
|
ToPixelPoint(command.uvMax, dpiScale),
|
|
command.color,
|
|
whiteTextureHandle,
|
|
currentClip.scissor);
|
|
break;
|
|
}
|
|
case UIDrawCommandType::FilledCircle: {
|
|
const FloatPoint center = ToPixelPoint(command.position, dpiScale);
|
|
const float radius = command.radius * dpiScale;
|
|
if (radius <= 0.0f) {
|
|
break;
|
|
}
|
|
|
|
appendAxisAlignedPrimitive(
|
|
FloatRect{
|
|
center.x - radius,
|
|
center.y - radius,
|
|
center.x + radius,
|
|
center.y + radius
|
|
},
|
|
UIPoint(0.0f, 0.0f),
|
|
UIPoint(1.0f, 1.0f),
|
|
command.color,
|
|
command.color,
|
|
UiPrimitiveKind::CircleFill,
|
|
radius,
|
|
0.0f,
|
|
0.0f,
|
|
whiteTextureHandle,
|
|
currentClip.scissor);
|
|
break;
|
|
}
|
|
case UIDrawCommandType::CircleOutline: {
|
|
const FloatPoint center = ToPixelPoint(command.position, dpiScale);
|
|
const float thickness =
|
|
(command.thickness > 0.0f ? command.thickness : 1.0f) * dpiScale;
|
|
const float radius = command.radius * dpiScale;
|
|
const float outerRadius = radius + thickness * 0.5f;
|
|
if (outerRadius <= 0.0f) {
|
|
break;
|
|
}
|
|
|
|
appendAxisAlignedPrimitive(
|
|
FloatRect{
|
|
center.x - outerRadius,
|
|
center.y - outerRadius,
|
|
center.x + outerRadius,
|
|
center.y + outerRadius
|
|
},
|
|
UIPoint(0.0f, 0.0f),
|
|
UIPoint(1.0f, 1.0f),
|
|
command.color,
|
|
command.color,
|
|
UiPrimitiveKind::CircleOutline,
|
|
radius,
|
|
thickness,
|
|
0.0f,
|
|
whiteTextureHandle,
|
|
currentClip.scissor);
|
|
break;
|
|
}
|
|
case UIDrawCommandType::Text: {
|
|
if (command.text.empty()) {
|
|
break;
|
|
}
|
|
|
|
const CachedTextRun* textRun =
|
|
ResolveTextRun(command.text, command.fontSize, currentFrameId);
|
|
if (textRun == nullptr ||
|
|
!textRun->hasPixels ||
|
|
textRun->textureHandle.ptr == 0u ||
|
|
textRun->width <= 0.0f ||
|
|
textRun->height <= 0.0f) {
|
|
break;
|
|
}
|
|
|
|
const FloatPoint position = ToPixelPoint(command.position, dpiScale);
|
|
appendAxisAlignedPrimitive(
|
|
FloatRect{
|
|
position.x + textRun->offsetX,
|
|
position.y + textRun->offsetY,
|
|
position.x + textRun->offsetX + textRun->width,
|
|
position.y + textRun->offsetY + textRun->height
|
|
},
|
|
UIPoint(0.0f, 0.0f),
|
|
UIPoint(1.0f, 1.0f),
|
|
command.color,
|
|
command.color,
|
|
UiPrimitiveKind::Textured,
|
|
0.0f,
|
|
0.0f,
|
|
0.0f,
|
|
textRun->textureHandle,
|
|
currentClip.scissor);
|
|
break;
|
|
}
|
|
case UIDrawCommandType::Image: {
|
|
if (!command.texture.IsValid()) {
|
|
break;
|
|
}
|
|
|
|
appendAxisAlignedPrimitive(
|
|
ToPixelRect(command.rect, dpiScale),
|
|
command.uvMin,
|
|
command.uvMax,
|
|
command.color,
|
|
command.color,
|
|
UiPrimitiveKind::Textured,
|
|
0.0f,
|
|
0.0f,
|
|
0.0f,
|
|
D3D12_GPU_DESCRIPTOR_HANDLE{
|
|
static_cast<UINT64>(command.texture.nativeHandle)
|
|
},
|
|
currentClip.scissor);
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
};
|
|
|
|
auto appendCompiledDrawList =
|
|
[&](const CompiledDrawList& compiled) {
|
|
if (compiled.batches.empty()) {
|
|
return;
|
|
}
|
|
|
|
const std::uint32_t baseInstance =
|
|
static_cast<std::uint32_t>(outPrimitiveInstances.size());
|
|
|
|
if (!compiled.instances.empty()) {
|
|
outPrimitiveInstances.insert(
|
|
outPrimitiveInstances.end(),
|
|
compiled.instances.begin(),
|
|
compiled.instances.end());
|
|
}
|
|
|
|
for (const UiBatch& batch : compiled.batches) {
|
|
AppendBatch(
|
|
outBatches,
|
|
baseInstance + batch.firstInstance,
|
|
batch.instanceCount,
|
|
batch.textureHandle,
|
|
batch.scissorRect);
|
|
}
|
|
};
|
|
|
|
const std::uint32_t renderWidth = renderArea.width > 0 ? renderArea.width : 0u;
|
|
const std::uint32_t renderHeight = renderArea.height > 0 ? renderArea.height : 0u;
|
|
const int dpiScaleMilli =
|
|
static_cast<int>(std::lround(dpiScale * 1000.0f));
|
|
|
|
for (const UIDrawList& drawList : drawData.GetDrawLists()) {
|
|
if (drawList.Empty()) {
|
|
continue;
|
|
}
|
|
|
|
CompiledDrawListKey key = {};
|
|
key.contentHash = BuildDrawListContentHash(drawList);
|
|
key.renderWidth = renderWidth;
|
|
key.renderHeight = renderHeight;
|
|
key.dpiScaleMilli = dpiScaleMilli;
|
|
|
|
auto found = m_compiledDrawListCache.find(key);
|
|
if (found == m_compiledDrawListCache.end()) {
|
|
CompiledDrawList compiled = {};
|
|
if (!buildCompiledDrawList(
|
|
drawList,
|
|
compiled.instances,
|
|
compiled.batches)) {
|
|
return false;
|
|
}
|
|
|
|
compiled.lastUsedFrame = currentFrameId;
|
|
const auto [insertedIt, inserted] =
|
|
m_compiledDrawListCache.emplace(key, std::move(compiled));
|
|
(void)inserted;
|
|
found = insertedIt;
|
|
} else {
|
|
found->second.lastUsedFrame = currentFrameId;
|
|
}
|
|
|
|
appendCompiledDrawList(found->second);
|
|
}
|
|
|
|
constexpr std::size_t kCompiledDrawListCacheMaxEntries = 256u;
|
|
constexpr std::uint64_t kCompiledDrawListCacheRetentionFrames = 240u;
|
|
if (m_compiledDrawListCache.size() > kCompiledDrawListCacheMaxEntries) {
|
|
const std::uint64_t pruneBeforeFrame =
|
|
currentFrameId > kCompiledDrawListCacheRetentionFrames
|
|
? currentFrameId - kCompiledDrawListCacheRetentionFrames
|
|
: 0u;
|
|
for (auto it = m_compiledDrawListCache.begin();
|
|
it != m_compiledDrawListCache.end();) {
|
|
if (it->second.lastUsedFrame <= pruneBeforeFrame) {
|
|
it = m_compiledDrawListCache.erase(it);
|
|
} else {
|
|
++it;
|
|
}
|
|
}
|
|
}
|
|
|
|
PruneTextRunCache(currentFrameId);
|
|
|
|
return true;
|
|
}
|
|
|
|
bool D3D12UiRenderer::Render(
|
|
const UIDrawData& drawData,
|
|
const RenderContext& renderContext,
|
|
const RenderSurface& surface) {
|
|
if (m_windowRenderer == nullptr ||
|
|
m_textureHost == nullptr ||
|
|
m_textSystem == nullptr) {
|
|
m_lastError = "Render requires an initialized D3D12 UI renderer.";
|
|
return false;
|
|
}
|
|
|
|
if (!renderContext.IsValid() || renderContext.commandList == nullptr) {
|
|
m_lastError = "Render requires a valid D3D12 render context.";
|
|
return false;
|
|
}
|
|
|
|
if (!::XCEngine::Rendering::HasSingleColorAttachment(surface) ||
|
|
surface.GetColorAttachments().empty() ||
|
|
surface.GetColorAttachments()[0] == nullptr) {
|
|
m_lastError = "Render requires a valid single-color render surface.";
|
|
return false;
|
|
}
|
|
|
|
if (!EnsureInitialized(renderContext, surface)) {
|
|
if (m_lastError.empty()) {
|
|
m_lastError = "Failed to initialize the D3D12 UI renderer resources.";
|
|
}
|
|
return false;
|
|
}
|
|
|
|
m_textureHost->BeginFrame(m_windowRenderer->GetActiveFrameSlot());
|
|
|
|
std::vector<UiPrimitiveInstance> primitiveInstances = {};
|
|
std::vector<UiBatch> batches = {};
|
|
if (!BuildDrawBatches(drawData, surface, primitiveInstances, batches)) {
|
|
if (m_lastError.empty()) {
|
|
m_lastError = "Failed to build the D3D12 UI draw batches.";
|
|
}
|
|
return false;
|
|
}
|
|
|
|
if (batches.empty()) {
|
|
m_lastError.clear();
|
|
return true;
|
|
}
|
|
|
|
const std::uint32_t frameSlot = m_windowRenderer->GetActiveFrameSlot();
|
|
if (!EnsureFrameBufferCapacity(
|
|
frameSlot,
|
|
primitiveInstances.size() * sizeof(UiPrimitiveInstance))) {
|
|
m_lastError = "Failed to allocate the D3D12 UI dynamic buffers.";
|
|
return false;
|
|
}
|
|
|
|
FrameResources& frameResources = m_frameResources[frameSlot];
|
|
if (!primitiveInstances.empty() && frameResources.primitiveInstanceBuffer != nullptr) {
|
|
frameResources.primitiveInstanceBuffer->SetData(
|
|
primitiveInstances.data(),
|
|
primitiveInstances.size() * sizeof(UiPrimitiveInstance));
|
|
}
|
|
|
|
const auto renderArea = surface.GetRenderArea();
|
|
UiConstants constants = {};
|
|
constants.invViewportSize[0] =
|
|
renderArea.width > 0 ? 1.0f / static_cast<float>(renderArea.width) : 0.0f;
|
|
constants.invViewportSize[1] =
|
|
renderArea.height > 0 ? 1.0f / static_cast<float>(renderArea.height) : 0.0f;
|
|
m_constantSet->WriteConstant(0u, &constants, sizeof(constants));
|
|
|
|
auto* d3d12CommandList =
|
|
static_cast<D3D12CommandList*>(renderContext.commandList);
|
|
auto* renderTarget = surface.GetColorAttachments()[0];
|
|
RHICommandList* commandList = renderContext.commandList;
|
|
commandList->SetRenderTargets(1u, &renderTarget, nullptr);
|
|
commandList->SetViewport(Viewport{
|
|
static_cast<float>(renderArea.x),
|
|
static_cast<float>(renderArea.y),
|
|
static_cast<float>(renderArea.width),
|
|
static_cast<float>(renderArea.height),
|
|
0.0f,
|
|
1.0f
|
|
});
|
|
commandList->SetScissorRect(Rect{
|
|
renderArea.x,
|
|
renderArea.y,
|
|
renderArea.x + renderArea.width,
|
|
renderArea.y + renderArea.height
|
|
});
|
|
commandList->SetPrimitiveTopology(PrimitiveTopology::TriangleList);
|
|
|
|
::XCEngine::RHI::RHIDescriptorSet* constantSets[] = { m_constantSet };
|
|
commandList->SetGraphicsDescriptorSets(0u, 1u, constantSets, m_pipelineLayout);
|
|
|
|
auto* textureHeap = m_windowRenderer->GetTextureDescriptorAllocator().GetDescriptorHeap();
|
|
auto* samplerHeap = static_cast<D3D12DescriptorHeap*>(m_samplerPool)->GetDescriptorHeap();
|
|
ID3D12DescriptorHeap* descriptorHeaps[] = { textureHeap, samplerHeap };
|
|
d3d12CommandList->SetDescriptorHeaps(2u, descriptorHeaps);
|
|
|
|
const auto* pipelineLayout =
|
|
static_cast<const ::XCEngine::RHI::D3D12PipelineLayout*>(m_pipelineLayout);
|
|
const std::uint32_t textureRootIndex =
|
|
pipelineLayout->GetShaderResourceTableRootParameterIndex(1u);
|
|
const std::uint32_t samplerRootIndex =
|
|
pipelineLayout->GetSamplerTableRootParameterIndex(2u);
|
|
|
|
if (m_primitivePipelineState == nullptr ||
|
|
m_quadVertexBufferView == nullptr ||
|
|
m_quadIndexBufferView == nullptr ||
|
|
frameResources.primitiveInstanceBufferView == nullptr) {
|
|
m_lastError = "D3D12 UI primitive rendering resources are unavailable.";
|
|
return false;
|
|
}
|
|
|
|
commandList->SetPipelineState(m_primitivePipelineState);
|
|
const std::uint64_t primitiveVertexOffsets[] = { 0u, 0u };
|
|
const std::uint32_t primitiveVertexStrides[] = {
|
|
static_cast<std::uint32_t>(sizeof(UiQuadVertex)),
|
|
static_cast<std::uint32_t>(sizeof(UiPrimitiveInstance))
|
|
};
|
|
::XCEngine::RHI::RHIResourceView* primitiveVertexViews[] = {
|
|
m_quadVertexBufferView,
|
|
frameResources.primitiveInstanceBufferView
|
|
};
|
|
commandList->SetVertexBuffers(
|
|
0u,
|
|
2u,
|
|
primitiveVertexViews,
|
|
primitiveVertexOffsets,
|
|
primitiveVertexStrides);
|
|
commandList->SetIndexBuffer(m_quadIndexBufferView, 0u);
|
|
|
|
for (const UiBatch& batch : batches) {
|
|
commandList->SetScissorRect(batch.scissorRect);
|
|
d3d12CommandList->SetGraphicsRootDescriptorTable(
|
|
textureRootIndex,
|
|
batch.textureHandle);
|
|
d3d12CommandList->SetGraphicsRootDescriptorTable(
|
|
samplerRootIndex,
|
|
m_samplerGpuHandle);
|
|
commandList->DrawIndexed(
|
|
static_cast<std::uint32_t>(sizeof(kUnitQuadIndices) / sizeof(kUnitQuadIndices[0])),
|
|
batch.instanceCount,
|
|
0u,
|
|
0,
|
|
batch.firstInstance);
|
|
}
|
|
|
|
m_lastError.clear();
|
|
return true;
|
|
}
|
|
|
|
} // namespace XCEngine::UI::Editor::Host
|