blob: c7729d44e444b103699d7c96fe64bc4162a49f3f [file]
/*
* Copyright 2025 Rive
*/
#pragma once
#include "rive/refcnt.hpp"
#include "rive/shapes/paint/image_sampler.hpp"
#include "rive/renderer/d3d12/d3d12.hpp"
#include "rive/renderer/gpu_resource.hpp"
#include <iostream>
namespace rive::gpu
{
class D3D12Resource;
// print the descriptor of the root signature
void print_sig_descriptor(LPCVOID data, SIZE_T size);
#if defined(DEBUG)
// Assign a name to the object to aid with debugging.
void SetName(D3D12Resource* pObject, LPCWSTR name);
#define NAME_D3D12_OBJECT(x) SetName(x.get(), L#x)
#define RNAME_D3D12_OBJECT(x, s) \
std::wstringstream ss; \
ss << L#x; \
ss << " " << s; \
SetName(x, ss.str().c_str())
#define SNAME_D3D12_OBJECT(x, s) SetName(x.get(), L##s)
#define VNAME_D3D12_OBJECT(x) SetName(x->resource(), L#x)
#define SVNAME_D3D12_OBJECT(x, s) SetName(x->resource(), L##s)
#define NAME_RAW_D3D12_OBJECT(x) x->SetName(L#x)
#else
#define NAME_D3D12_OBJECT(x)
#define RNAME_D3D12_OBJECT(x, s)
#define SNAME_D3D12_OBJECT(x, s)
#define VNAME_D3D12_OBJECT(x)
#define SVNAME_D3D12_OBJECT(x, s)
#define NAME_RAW_D3D12_OBJECT(x)
#endif
class D3D12Buffer;
class D3D12Texture;
class D3D12TextureArray;
class D3D12DescriptorHeap : public GPUResource
{
public:
D3D12DescriptorHeap(rcp<GPUResourceManager> manager,
ID3D12Device* device,
UINT numDescriptors,
D3D12_DESCRIPTOR_HEAP_TYPE type,
D3D12_DESCRIPTOR_HEAP_FLAGS flags);
ID3D12DescriptorHeap* heap() const { return m_heap.Get(); }
void markSamplerToIndex(ID3D12Device* device,
const D3D12_SAMPLER_DESC& desc,
UINT index);
void markCbvToIndex(ID3D12Device* device,
D3D12Buffer* resource,
UINT index,
UINT sizeInBytes,
SIZE_T offset = 0);
void markSrvToIndex(ID3D12Device* device,
D3D12Buffer* resource,
UINT index,
UINT numElements,
UINT elementByteStride,
UINT64 firstElement);
void markSrvToIndex(ID3D12Device* device,
D3D12Buffer* resource,
UINT index,
UINT numElements,
UINT elementByteStride,
UINT gpuByteStride,
UINT64 firstElement);
void markUavToIndex(ID3D12Device* device,
D3D12Buffer* resource,
DXGI_FORMAT format,
UINT index,
UINT numElements,
UINT elementByteStride);
void markSrvToIndex(ID3D12Device* device,
D3D12Texture* resource,
UINT index);
void markSrvToIndex(ID3D12Device* device,
D3D12TextureArray* resource,
UINT index);
// Write a null-resource SRV descriptor at `index` so the slot is valid for
// SetGraphicsRootDescriptorTable even when the source resource isn't
// currently allocated. Without this, recycled cpu-heap slots can retain
// descriptors pointing at released resources and trip GPU-Based Validation
// (id=1042) when the SRV table is bound.
void markNullTexture2DSrvToIndex(ID3D12Device* device,
UINT index,
DXGI_FORMAT format);
void markNullStructuredBufferSrvToIndex(ID3D12Device* device,
UINT index,
UINT elementByteStride);
void markUavToIndex(ID3D12Device* device,
D3D12Texture* resource,
DXGI_FORMAT format,
UINT index);
void markRtvToIndex(ID3D12Device* device,
D3D12Texture* resource,
UINT index);
CD3DX12_CPU_DESCRIPTOR_HANDLE cpuHandleForUpload(UINT index) const
{
return CD3DX12_CPU_DESCRIPTOR_HANDLE(
m_heap->GetCPUDescriptorHandleForHeapStart(),
index,
m_heapDescriptorSize);
}
CD3DX12_CPU_DESCRIPTOR_HANDLE cpuHandleForIndex(UINT index) const
{
assert(m_flags == D3D12_DESCRIPTOR_HEAP_FLAG_NONE);
return CD3DX12_CPU_DESCRIPTOR_HANDLE(
m_heap->GetCPUDescriptorHandleForHeapStart(),
index,
m_heapDescriptorSize);
}
CD3DX12_GPU_DESCRIPTOR_HANDLE gpuHandleForIndex(UINT index) const
{
assert(m_flags == D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE);
return CD3DX12_GPU_DESCRIPTOR_HANDLE(
m_heap->GetGPUDescriptorHandleForHeapStart(),
index,
m_heapDescriptorSize);
}
private:
ComPtr<ID3D12DescriptorHeap> m_heap;
#ifndef NDEBUG
const D3D12_DESCRIPTOR_HEAP_TYPE m_type;
const D3D12_DESCRIPTOR_HEAP_FLAGS m_flags;
#endif
const UINT m_heapDescriptorSize;
};
class D3D12Resource : public GPUResource
{
public:
virtual ~D3D12Resource() {}
ID3D12Resource* resource() const { return m_resource.Get(); }
const D3D12_RESOURCE_DESC& desc() const { return m_desc; }
D3D12_RESOURCE_STATES lastState() const { return m_lastState; }
#if DEBUG
LPCWSTR m_name = L"";
void SetName(LPCWSTR name)
{
m_name = name;
m_resource->SetName(name);
}
#endif
protected:
D3D12Resource(rcp<GPUResourceManager> manager,
ComPtr<ID3D12Resource> resource,
D3D12_RESOURCE_STATES initialState);
D3D12Resource(rcp<GPUResourceManager> manager,
ID3D12Device* device,
D3D12_RESOURCE_STATES initialState,
D3D12_HEAP_FLAGS heapFlags,
const D3D12_RESOURCE_DESC& desc,
const D3D12_CLEAR_VALUE* clearValue = nullptr);
D3D12Resource(rcp<GPUResourceManager> manager,
ID3D12Device* device,
D3D12_RESOURCE_STATES initialState,
D3D12_HEAP_FLAGS heapFlags,
CD3DX12_HEAP_PROPERTIES heapPropeties,
const D3D12_RESOURCE_DESC& desc,
const D3D12_CLEAR_VALUE* clearValue = nullptr);
// the gpu side resource
ComPtr<ID3D12Resource> m_resource;
// used for barrier state tracking
D3D12_RESOURCE_STATES m_lastState;
D3D12_RESOURCE_DESC m_desc;
CD3DX12_HEAP_PROPERTIES m_heapPropeties;
D3D12_HEAP_FLAGS m_heapFlags;
friend class D3D12ResourceManager;
};
class D3D12Texture : public D3D12Resource
{
public:
D3D12Texture(
rcp<GPUResourceManager> manager,
ComPtr<ID3D12Resource> resource,
D3D12_RESOURCE_STATES initialState = D3D12_RESOURCE_STATE_COMMON) :
D3D12Resource(manager, resource, initialState)
{}
D3D12Texture(rcp<GPUResourceManager> manager,
ID3D12Device* device,
D3D12_RESOURCE_STATES initialState,
D3D12_HEAP_FLAGS heapFlags,
const D3D12_RESOURCE_DESC& desc,
const D3D12_CLEAR_VALUE* clearValue = nullptr) :
D3D12Resource(manager,
device,
initialState,
heapFlags,
desc,
clearValue)
{}
D3D12Texture(rcp<GPUResourceManager> manager,
ID3D12Device* device,
D3D12_RESOURCE_STATES initialState,
D3D12_HEAP_FLAGS heapFlags,
CD3DX12_HEAP_PROPERTIES heapPropeties,
const D3D12_RESOURCE_DESC& desc,
const D3D12_CLEAR_VALUE* clearValue = nullptr) :
D3D12Resource(manager,
device,
initialState,
heapFlags,
heapPropeties,
desc,
clearValue)
{}
// helpers
UINT64 width() const { return m_desc.Width; }
UINT64 height() const { return m_desc.Height; }
DXGI_FORMAT format() const { return m_desc.Format; }
// Optional SRV format override for externally-adopted textures whose
// typed view is not derivable from desc().Format (e.g. TYPELESS storage
// or picking the sRGB variant). UNKNOWN = auto-infer.
void setSrvViewFormat(DXGI_FORMAT format) { m_srvViewFormat = format; }
DXGI_FORMAT srvViewFormat() const { return m_srvViewFormat; }
private:
DXGI_FORMAT m_srvViewFormat = DXGI_FORMAT_UNKNOWN;
public:
// USE WITH CAUTION !! this force release the ID3D12Resource held by this
// texture. Be sure that it is no longer needed or in any active command
// list
void forceReleaseResource() { m_resource.Reset(); }
};
class D3D12TextureArray : public D3D12Resource
{
public:
D3D12TextureArray(
rcp<GPUResourceManager> manager,
ComPtr<ID3D12Resource> resource,
D3D12_RESOURCE_STATES initialState = D3D12_RESOURCE_STATE_COMMON) :
D3D12Resource(manager, resource, initialState)
{}
D3D12TextureArray(rcp<GPUResourceManager> manager,
ID3D12Device* device,
D3D12_RESOURCE_STATES initialState,
D3D12_HEAP_FLAGS heapFlags,
const D3D12_RESOURCE_DESC& desc) :
D3D12Resource(manager, device, initialState, heapFlags, desc)
{}
D3D12TextureArray(rcp<GPUResourceManager> manager,
ID3D12Device* device,
D3D12_RESOURCE_STATES initialState,
D3D12_HEAP_FLAGS heapFlags,
CD3DX12_HEAP_PROPERTIES heapPropeties,
const D3D12_RESOURCE_DESC& desc) :
D3D12Resource(manager,
device,
initialState,
heapFlags,
heapPropeties,
desc)
{}
// helpers
UINT64 width() const { return m_desc.Width; }
UINT16 length() const { return m_desc.DepthOrArraySize; }
DXGI_FORMAT format() const { return m_desc.Format; }
};
class D3D12Buffer : public D3D12Resource
{
public:
D3D12Buffer(rcp<GPUResourceManager> manager,
ID3D12Device* device,
D3D12_RESOURCE_STATES initialState,
D3D12_HEAP_FLAGS heapFlags,
UINT size,
const D3D12_RESOURCE_DESC& desc) :
D3D12Resource(manager, device, initialState, heapFlags, desc),
m_sizeInBytes(size)
{}
D3D12Buffer(rcp<GPUResourceManager> manager,
ID3D12Device* device,
D3D12_RESOURCE_STATES initialState,
D3D12_HEAP_FLAGS heapFlags,
CD3DX12_HEAP_PROPERTIES heapPropeties,
UINT size,
const D3D12_RESOURCE_DESC& desc) :
D3D12Resource(manager,
device,
initialState,
heapFlags,
heapPropeties,
desc),
m_sizeInBytes(size)
{}
void* map();
void unmap();
UINT sizeInBytes() const { return m_sizeInBytes; }
D3D12_GPU_VIRTUAL_ADDRESS getGPUVirtualAddress() const
{
return m_resource->GetGPUVirtualAddress();
}
D3D12_VERTEX_BUFFER_VIEW vertexBufferView(uint32_t strideInBytes) const
{
return vertexBufferView(0,
m_sizeInBytes / strideInBytes,
strideInBytes);
}
D3D12_VERTEX_BUFFER_VIEW vertexBufferView(uint32_t firstElement,
uint32_t strideInBytes) const
{
return vertexBufferView(firstElement,
(m_sizeInBytes / strideInBytes) - firstElement,
strideInBytes);
}
D3D12_VERTEX_BUFFER_VIEW vertexBufferView(uint32_t firstElement,
uint32_t numElements,
uint32_t strideInBytes) const
{
D3D12_VERTEX_BUFFER_VIEW VBView;
VBView.BufferLocation =
resource()->GetGPUVirtualAddress() + (firstElement * strideInBytes);
VBView.SizeInBytes = numElements * strideInBytes;
VBView.StrideInBytes = strideInBytes;
return VBView;
}
D3D12_INDEX_BUFFER_VIEW indexBufferView() const
{
return indexBufferView(0, m_sizeInBytes);
}
D3D12_INDEX_BUFFER_VIEW indexBufferView(size_t Offset,
uint32_t sizeInBytes) const
{
D3D12_INDEX_BUFFER_VIEW IBView;
IBView.BufferLocation = resource()->GetGPUVirtualAddress() + Offset;
IBView.SizeInBytes = sizeInBytes;
IBView.Format = DXGI_FORMAT_R16_UINT;
return IBView;
}
private:
UINT m_sizeInBytes;
#ifndef NDEBUG
bool m_isMapped = false;
#endif
};
class D3D12ResourceManager;
// A buffer that is intended to be updated every frame
class D3D12VolatileBuffer : public GPUResource
{
public:
// create buffers with intialSize, initialSize must not be 0
D3D12VolatileBuffer(
rcp<D3D12ResourceManager> manager,
UINT initialSize,
D3D12_RESOURCE_FLAGS bindFlags = D3D12_RESOURCE_FLAG_NONE,
D3D12_HEAP_FLAGS heapFlags = D3D12_HEAP_FLAG_NONE);
// maps the upload buffer
void* map(size_t mapSizeInBytes)
{
m_lastMapSize = mapSizeInBytes;
assert(m_uploadBuffer);
return m_uploadBuffer->map();
}
// unmaps the upload buffer
void unmap(size_t unmapSizeInBytes)
{
assert(unmapSizeInBytes == m_lastMapSize);
assert(m_uploadBuffer);
m_uploadBuffer->unmap();
}
// sync the upload buffer to the gpu buffer using m_lastMapSize as
// bytesToSync
void sync(ID3D12GraphicsCommandList* cmdList, UINT64 offsetBytes);
// sync the upload buffer to the gpu buffer
void sync(ID3D12GraphicsCommandList* cmdList,
UINT64 offsetBytes,
UINT64 bytesToSync);
void syncToBuffer(ID3D12GraphicsCommandList* cmdList,
D3D12Buffer* buffer,
UINT64 offsetBytes,
UINT64 bytesToSync) const;
D3D12_GPU_VIRTUAL_ADDRESS GPUVirtualAddress() const
{
return m_gpuBuffer->resource()->GetGPUVirtualAddress();
}
D3D12Buffer* resource() const { return m_gpuBuffer.get(); }
UINT64 sizeInBytes() const
{
assert(m_uploadBuffer->sizeInBytes() == m_gpuBuffer->sizeInBytes());
return m_uploadBuffer->sizeInBytes();
}
// recreates the buffers with given size, there is no way to just inflate or
// deflate a buffer
void resizeBuffers(UINT newSize);
private:
D3D12ResourceManager* d3d() const;
rcp<D3D12Buffer> m_uploadBuffer;
rcp<D3D12Buffer> m_gpuBuffer;
// used for creating gpu buffers
D3D12_RESOURCE_FLAGS m_bindFlags;
D3D12_HEAP_FLAGS m_heapFlags;
UINT64 m_lastMapSize = 0;
};
class D3D12ResourceManager : public GPUResourceManager
{
public:
D3D12ResourceManager(ComPtr<ID3D12Device> device) :
m_device(std::move(device))
{}
rcp<D3D12DescriptorHeap> makeHeap(UINT numDescriptors,
D3D12_DESCRIPTOR_HEAP_TYPE type,
D3D12_DESCRIPTOR_HEAP_FLAGS flags);
rcp<D3D12TextureArray> make1DTextureArray(
UINT width,
UINT16 length,
UINT mipLevelCount,
DXGI_FORMAT format,
D3D12_RESOURCE_FLAGS bindFlags = D3D12_RESOURCE_FLAG_NONE,
D3D12_RESOURCE_STATES initialState = D3D12_RESOURCE_STATE_COMMON,
D3D12_HEAP_FLAGS heapFlags = D3D12_HEAP_FLAG_NONE);
rcp<D3D12Texture> make2DTexture(
UINT width,
UINT height,
UINT mipLevelCount,
DXGI_FORMAT format,
D3D12_RESOURCE_FLAGS bindFlags = D3D12_RESOURCE_FLAG_NONE,
D3D12_RESOURCE_STATES initialState = D3D12_RESOURCE_STATE_COMMON,
D3D12_HEAP_FLAGS heapFlags = D3D12_HEAP_FLAG_NONE,
const D3D12_CLEAR_VALUE* clearValue = nullptr);
rcp<D3D12Buffer> makeBuffer(
UINT size,
D3D12_RESOURCE_FLAGS bindFlags = D3D12_RESOURCE_FLAG_NONE,
D3D12_RESOURCE_STATES initialState = D3D12_RESOURCE_STATE_COMMON,
D3D12_HEAP_FLAGS heapFlags = D3D12_HEAP_FLAG_NONE);
// D3D12 requires buffers on the UPLOAD heap to be created in
// D3D12_RESOURCE_STATE_GENERIC_READ and to remain in that state for their
// lifetime; the runtime returns E_INVALIDARG otherwise.
rcp<D3D12Buffer> makeUploadBuffer(
UINT size,
D3D12_RESOURCE_FLAGS bindFlags = D3D12_RESOURCE_FLAG_NONE,
D3D12_RESOURCE_STATES initialState = D3D12_RESOURCE_STATE_GENERIC_READ,
D3D12_HEAP_FLAGS heapFlags = D3D12_HEAP_FLAG_NONE);
rcp<D3D12VolatileBuffer> makeVolatileBuffer(
UINT size,
D3D12_RESOURCE_FLAGS bindFlags = D3D12_RESOURCE_FLAG_NONE,
D3D12_HEAP_FLAGS heapFlags = D3D12_HEAP_FLAG_NONE);
template <typename DataType, size_t N>
rcp<D3D12Buffer> makeImmutableBuffer(ID3D12GraphicsCommandList* cmdList,
const DataType (&data)[N])
{
constexpr size_t sizeInBytes = N * sizeof(DataType);
rcp<D3D12Buffer> uploadBuffer =
makeUploadBuffer(sizeInBytes,
D3D12_RESOURCE_FLAG_NONE,
D3D12_RESOURCE_STATE_GENERIC_READ);
rcp<D3D12Buffer> constBuffer = makeBuffer(sizeInBytes,
D3D12_RESOURCE_FLAG_NONE,
D3D12_RESOURCE_STATE_COMMON);
void* ptr = uploadBuffer->map();
memcpy(ptr, data, sizeInBytes);
uploadBuffer->unmap();
cmdList->CopyBufferRegion(constBuffer->resource(),
0,
uploadBuffer->resource(),
0,
sizeInBytes);
return constBuffer;
}
rcp<D3D12Texture> makeExternalTexture(
ComPtr<ID3D12Resource> externalTexture,
D3D12_RESOURCE_STATES lastState);
// transition resource to "toState"
void transition(ID3D12GraphicsCommandList* cmdList,
D3D12Resource* resource,
D3D12_RESOURCE_STATES toState);
void clearUAV(ID3D12GraphicsCommandList* cmdList,
ID3D12Resource* resource,
CD3DX12_GPU_DESCRIPTOR_HANDLE&,
CD3DX12_CPU_DESCRIPTOR_HANDLE&,
const UINT clearColor[4],
bool needsBarrier);
void clearUAV(ID3D12GraphicsCommandList* cmdList,
ID3D12Resource* resource,
CD3DX12_GPU_DESCRIPTOR_HANDLE&,
CD3DX12_CPU_DESCRIPTOR_HANDLE&,
const float clearColor[4],
bool needsBarrier);
ID3D12Device* device() const { return m_device.Get(); }
private:
ComPtr<ID3D12Device> m_device;
};
class D3D12VolatileBufferPool : public GPUResourcePool
{
public:
D3D12VolatileBufferPool(rcp<D3D12ResourceManager> manager,
UINT alignment = 1,
UINT size = 0);
size_t size() const { return m_targetSize; }
void setTargetSize(size_t size);
// Returns a Buffer that is guaranteed to exist and be of size
// 'm_targetSize'.
rcp<D3D12VolatileBuffer> acquire();
void recycle(rcp<D3D12VolatileBuffer> resource)
{
GPUResourcePool::recycle(std::move(resource));
}
private:
D3D12ResourceManager* d3d() const;
constexpr static size_t MAX_POOL_SIZE = 8;
UINT m_alignment;
UINT m_targetSize;
};
class D3D12DescriptorHeapPool : public GPUResourcePool
{
public:
D3D12DescriptorHeapPool(rcp<D3D12ResourceManager> manager,
UINT numDescriptors,
D3D12_DESCRIPTOR_HEAP_TYPE type,
D3D12_DESCRIPTOR_HEAP_FLAGS flags);
rcp<D3D12DescriptorHeap> acquire();
void recycle(rcp<D3D12DescriptorHeap> resource)
{
GPUResourcePool::recycle(std::move(resource));
}
private:
D3D12ResourceManager* d3d() const;
constexpr static size_t MAX_POOL_SIZE = 8;
// heap pools do not change over time, they are expected to be initialized
// with the max number of descriptors ever used
const UINT m_numDescriptors;
const D3D12_DESCRIPTOR_HEAP_TYPE m_type;
const D3D12_DESCRIPTOR_HEAP_FLAGS m_flags;
};
} // namespace rive::gpu