Split render-d3d12.h/cpp into a set of smaller files (#2231)

* Split render-d3d12 into numerous smaller files to make the code easier to parse

* Added all new D3D12 files created from splitting render-d3d12

* Fixed several uses of attachment still floating around; Changed resource-d3d12 and descriptor-heap-d3d12 to match naming conventions of new d3d12 implementation header files

* Readded files with name changes because changing them from inside VS apparently results in them being treated as new files

* Merged in externals changes from master

* Small cleanup changes

* Rerun CI

Co-authored-by: Theresa Foley <10618364+tangent-vector@users.noreply.github.com>

1 files changed, 590 insertions, 0 deletions

diff --git a/tools/gfx/d3d12/d3d12-helper-functions.cpp b/tools/gfx/d3d12/d3d12-helper-functions.cpp
new file mode 100644
index 000000000..76e80b017
--- /dev/null
+++ b/tools/gfx/d3d12/d3d12-helper-functions.cpp
@@ -0,0 +1,590 @@
+// d3d12-helper-functions.cpp
+#include "d3d12-helper-functions.h"
+
+#ifdef GFX_NVAPI
+#    include "../nvapi/nvapi-include.h"
+#endif
+
+#include "../nvapi/nvapi-util.h"
+#include "d3d12-buffer.h"
+#include "d3d12-transient-heap.h"
+#include "d3d12-query.h"
+
+#ifdef _DEBUG
+#    define ENABLE_DEBUG_LAYER 1
+#else
+#    define ENABLE_DEBUG_LAYER 0
+#endif
+
+namespace gfx
+{
+
+using namespace Slang;
+
+namespace d3d12
+{
+
+bool isSupportedNVAPIOp(ID3D12Device* dev, uint32_t op)
+{
+#ifdef GFX_NVAPI
+    {
+        bool isSupported;
+        NvAPI_Status status =
+            NvAPI_D3D12_IsNvShaderExtnOpCodeSupported(dev, NvU32(op), &isSupported);
+        return status == NVAPI_OK && isSupported;
+    }
+#else
+    return false;
+#endif
+}
+
+D3D12_RESOURCE_FLAGS calcResourceFlag(ResourceState state)
+{
+    switch (state)
+    {
+    case ResourceState::RenderTarget:
+        return D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET;
+    case ResourceState::DepthRead:
+    case ResourceState::DepthWrite:
+        return D3D12_RESOURCE_FLAG_ALLOW_DEPTH_STENCIL;
+    case ResourceState::UnorderedAccess:
+    case ResourceState::AccelerationStructure:
+        return D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS;
+    default:
+        return D3D12_RESOURCE_FLAG_NONE;
+    }
+}
+
+D3D12_RESOURCE_FLAGS calcResourceFlags(ResourceStateSet states)
+{
+    int dstFlags = 0;
+    for (uint32_t i = 0; i < (uint32_t)ResourceState::_Count; i++)
+    {
+        auto state = (ResourceState)i;
+        if (states.contains(state))
+            dstFlags |= calcResourceFlag(state);
+    }
+    return (D3D12_RESOURCE_FLAGS)dstFlags;
+}
+
+D3D12_RESOURCE_DIMENSION calcResourceDimension(IResource::Type type)
+{
+    switch (type)
+    {
+    case IResource::Type::Buffer:
+        return D3D12_RESOURCE_DIMENSION_BUFFER;
+    case IResource::Type::Texture1D:
+        return D3D12_RESOURCE_DIMENSION_TEXTURE1D;
+    case IResource::Type::TextureCube:
+    case IResource::Type::Texture2D:
+    {
+        return D3D12_RESOURCE_DIMENSION_TEXTURE2D;
+    }
+    case IResource::Type::Texture3D:
+        return D3D12_RESOURCE_DIMENSION_TEXTURE3D;
+    default:
+        return D3D12_RESOURCE_DIMENSION_UNKNOWN;
+    }
+}
+
+DXGI_FORMAT getTypelessFormatFromDepthFormat(Format format)
+{
+    switch (format)
+    {
+    case Format::D16_UNORM:
+        return DXGI_FORMAT_R16_TYPELESS;
+    case Format::D32_FLOAT:
+        return DXGI_FORMAT_R32_TYPELESS;
+    default:
+        return D3DUtil::getMapFormat(format);
+    }
+}
+
+bool isTypelessDepthFormat(DXGI_FORMAT format)
+{
+    switch (format)
+    {
+    case DXGI_FORMAT_R16_TYPELESS:
+    case DXGI_FORMAT_R32_TYPELESS:
+        return true;
+    default:
+        return false;
+    }
+}
+
+D3D12_FILTER_TYPE translateFilterMode(TextureFilteringMode mode)
+{
+    switch (mode)
+    {
+    default:
+        return D3D12_FILTER_TYPE(0);
+
+#define CASE(SRC, DST)              \
+    case TextureFilteringMode::SRC: \
+        return D3D12_FILTER_TYPE_##DST
+
+        CASE(Point, POINT);
+        CASE(Linear, LINEAR);
+
+#undef CASE
+    }
+}
+
+D3D12_FILTER_REDUCTION_TYPE translateFilterReduction(TextureReductionOp op)
+{
+    switch (op)
+    {
+    default:
+        return D3D12_FILTER_REDUCTION_TYPE(0);
+
+#define CASE(SRC, DST)            \
+    case TextureReductionOp::SRC: \
+        return D3D12_FILTER_REDUCTION_TYPE_##DST
+
+        CASE(Average, STANDARD);
+        CASE(Comparison, COMPARISON);
+        CASE(Minimum, MINIMUM);
+        CASE(Maximum, MAXIMUM);
+
+#undef CASE
+    }
+}
+
+D3D12_TEXTURE_ADDRESS_MODE translateAddressingMode(TextureAddressingMode mode)
+{
+    switch (mode)
+    {
+    default:
+        return D3D12_TEXTURE_ADDRESS_MODE(0);
+
+#define CASE(SRC, DST)               \
+    case TextureAddressingMode::SRC: \
+        return D3D12_TEXTURE_ADDRESS_MODE_##DST
+
+        CASE(Wrap, WRAP);
+        CASE(ClampToEdge, CLAMP);
+        CASE(ClampToBorder, BORDER);
+        CASE(MirrorRepeat, MIRROR);
+        CASE(MirrorOnce, MIRROR_ONCE);
+
+#undef CASE
+    }
+}
+
+D3D12_COMPARISON_FUNC translateComparisonFunc(ComparisonFunc func)
+{
+    switch (func)
+    {
+    default:
+        // TODO: need to report failures
+        return D3D12_COMPARISON_FUNC_ALWAYS;
+
+#define CASE(FROM, TO)         \
+    case ComparisonFunc::FROM: \
+        return D3D12_COMPARISON_FUNC_##TO
+
+        CASE(Never, NEVER);
+        CASE(Less, LESS);
+        CASE(Equal, EQUAL);
+        CASE(LessEqual, LESS_EQUAL);
+        CASE(Greater, GREATER);
+        CASE(NotEqual, NOT_EQUAL);
+        CASE(GreaterEqual, GREATER_EQUAL);
+        CASE(Always, ALWAYS);
+#undef CASE
+    }
+}
+
+uint32_t getViewDescriptorCount(const ITransientResourceHeap::Desc& desc)
+{
+    return Math::Max(
+        Math::Max(
+            desc.srvDescriptorCount,
+            desc.uavDescriptorCount,
+            desc.accelerationStructureDescriptorCount),
+        desc.constantBufferDescriptorCount,
+        2048);
+}
+
+void initSrvDesc(
+    IResource::Type resourceType,
+    const ITextureResource::Desc& textureDesc,
+    const D3D12_RESOURCE_DESC& desc,
+    DXGI_FORMAT pixelFormat,
+    SubresourceRange subresourceRange,
+    D3D12_SHADER_RESOURCE_VIEW_DESC& descOut)
+{
+    // create SRV
+    descOut = D3D12_SHADER_RESOURCE_VIEW_DESC();
+
+    descOut.Format = (pixelFormat == DXGI_FORMAT_UNKNOWN)
+        ? D3DUtil::calcFormat(D3DUtil::USAGE_SRV, desc.Format)
+        : pixelFormat;
+    descOut.Shader4ComponentMapping = D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING;
+    if (desc.DepthOrArraySize == 1)
+    {
+        switch (desc.Dimension)
+        {
+        case D3D12_RESOURCE_DIMENSION_TEXTURE1D:
+            descOut.ViewDimension = D3D12_SRV_DIMENSION_TEXTURE1D;
+            descOut.Texture1D.MipLevels = subresourceRange.mipLevelCount == 0
+                ? desc.MipLevels - subresourceRange.mipLevel
+                : subresourceRange.mipLevelCount;
+            descOut.Texture1D.MostDetailedMip = subresourceRange.mipLevel;
+            break;
+        case D3D12_RESOURCE_DIMENSION_TEXTURE2D:
+            descOut.ViewDimension = D3D12_SRV_DIMENSION_TEXTURE2D;
+            descOut.Texture2D.PlaneSlice =
+                D3DUtil::getPlaneSlice(descOut.Format, subresourceRange.aspectMask);
+            descOut.Texture2D.ResourceMinLODClamp = 0.0f;
+            descOut.Texture2D.MipLevels = subresourceRange.mipLevelCount == 0
+                ? desc.MipLevels - subresourceRange.mipLevel
+                : subresourceRange.mipLevelCount;
+            descOut.Texture2D.MostDetailedMip = subresourceRange.mipLevel;
+            break;
+        case D3D12_RESOURCE_DIMENSION_TEXTURE3D:
+            descOut.ViewDimension = D3D12_SRV_DIMENSION_TEXTURE3D;
+            descOut.Texture3D.MipLevels = subresourceRange.mipLevelCount == 0
+                ? desc.MipLevels - subresourceRange.mipLevel
+                : subresourceRange.mipLevelCount;
+            descOut.Texture3D.MostDetailedMip = subresourceRange.mipLevel;
+            break;
+        default:
+            assert(!"Unknown dimension");
+        }
+    }
+    else if (resourceType == IResource::Type::TextureCube)
+    {
+        if (textureDesc.arraySize > 1)
+        {
+            descOut.ViewDimension = D3D12_SRV_DIMENSION_TEXTURECUBEARRAY;
+
+            descOut.TextureCubeArray.NumCubes = subresourceRange.layerCount == 0
+                ? textureDesc.arraySize
+                : subresourceRange.layerCount / 6;
+            descOut.TextureCubeArray.First2DArrayFace = subresourceRange.baseArrayLayer;
+            descOut.TextureCubeArray.MipLevels = subresourceRange.mipLevelCount == 0
+                ? desc.MipLevels - subresourceRange.mipLevel
+                : subresourceRange.mipLevelCount;
+            descOut.TextureCubeArray.MostDetailedMip = subresourceRange.mipLevel;
+            descOut.TextureCubeArray.ResourceMinLODClamp = 0;
+        }
+        else
+        {
+            descOut.ViewDimension = D3D12_SRV_DIMENSION_TEXTURECUBE;
+
+            descOut.TextureCube.MipLevels = subresourceRange.mipLevelCount == 0
+                ? desc.MipLevels - subresourceRange.mipLevel
+                : subresourceRange.mipLevelCount;
+            descOut.TextureCube.MostDetailedMip = subresourceRange.mipLevel;
+            descOut.TextureCube.ResourceMinLODClamp = 0;
+        }
+    }
+    else
+    {
+        assert(desc.DepthOrArraySize > 1);
+
+        switch (desc.Dimension)
+        {
+        case D3D12_RESOURCE_DIMENSION_TEXTURE1D:
+            descOut.ViewDimension = D3D12_SRV_DIMENSION_TEXTURE1DARRAY;
+            descOut.Texture1D.MostDetailedMip = subresourceRange.mipLevel;
+            descOut.Texture1D.MipLevels = subresourceRange.mipLevelCount == 0
+                ? desc.MipLevels
+                : subresourceRange.mipLevelCount;
+            descOut.Texture1DArray.ArraySize = subresourceRange.layerCount == 0
+                ? desc.DepthOrArraySize
+                : subresourceRange.layerCount;
+            descOut.Texture1DArray.FirstArraySlice = subresourceRange.baseArrayLayer;
+            descOut.Texture1DArray.ResourceMinLODClamp = 0;
+            descOut.Texture1DArray.MostDetailedMip = subresourceRange.mipLevel;
+            descOut.Texture1DArray.MipLevels = subresourceRange.mipLevelCount == 0
+                ? desc.MipLevels - subresourceRange.mipLevel
+                : subresourceRange.mipLevelCount;
+            break;
+        case D3D12_RESOURCE_DIMENSION_TEXTURE2D:
+            descOut.ViewDimension = D3D12_SRV_DIMENSION_TEXTURE2DARRAY;
+            descOut.Texture2DArray.ArraySize = subresourceRange.layerCount == 0
+                ? desc.DepthOrArraySize
+                : subresourceRange.layerCount;
+            descOut.Texture2DArray.FirstArraySlice = subresourceRange.baseArrayLayer;
+            descOut.Texture2DArray.PlaneSlice =
+                D3DUtil::getPlaneSlice(descOut.Format, subresourceRange.aspectMask);
+            descOut.Texture2DArray.ResourceMinLODClamp = 0;
+            descOut.Texture2DArray.MostDetailedMip = subresourceRange.mipLevel;
+            descOut.Texture2DArray.MipLevels = subresourceRange.mipLevelCount == 0
+                ? desc.MipLevels - subresourceRange.mipLevel
+                : subresourceRange.mipLevelCount;
+            break;
+        case D3D12_RESOURCE_DIMENSION_TEXTURE3D:
+            descOut.ViewDimension = D3D12_SRV_DIMENSION_TEXTURE3D;
+            descOut.Texture3D.MostDetailedMip = subresourceRange.mipLevel;
+            descOut.Texture3D.MipLevels = subresourceRange.mipLevelCount == 0
+                ? desc.MipLevels
+                : subresourceRange.mipLevelCount;
+            break;
+
+        default:
+            assert(!"Unknown dimension");
+        }
+    }
+}
+
+Result initTextureResourceDesc(
+    D3D12_RESOURCE_DESC& resourceDesc, const ITextureResource::Desc& srcDesc)
+{
+    const DXGI_FORMAT pixelFormat = D3DUtil::getMapFormat(srcDesc.format);
+    if (pixelFormat == DXGI_FORMAT_UNKNOWN)
+    {
+        return SLANG_FAIL;
+    }
+
+    const int arraySize = calcEffectiveArraySize(srcDesc);
+
+    const D3D12_RESOURCE_DIMENSION dimension = calcResourceDimension(srcDesc.type);
+    if (dimension == D3D12_RESOURCE_DIMENSION_UNKNOWN)
+    {
+        return SLANG_FAIL;
+    }
+
+    const int numMipMaps = srcDesc.numMipLevels;
+    resourceDesc.Dimension = dimension;
+    resourceDesc.Format = pixelFormat;
+    resourceDesc.Width = srcDesc.size.width;
+    resourceDesc.Height = srcDesc.size.height;
+    resourceDesc.DepthOrArraySize = (srcDesc.size.depth > 1) ? srcDesc.size.depth : arraySize;
+
+    resourceDesc.MipLevels = numMipMaps;
+    resourceDesc.SampleDesc.Count = srcDesc.sampleDesc.numSamples;
+    resourceDesc.SampleDesc.Quality = srcDesc.sampleDesc.quality;
+
+    resourceDesc.Flags = D3D12_RESOURCE_FLAG_NONE;
+    resourceDesc.Layout = D3D12_TEXTURE_LAYOUT_UNKNOWN;
+
+    resourceDesc.Flags |= calcResourceFlags(srcDesc.allowedStates);
+
+    resourceDesc.Alignment = 0;
+
+    if (isDepthFormat(srcDesc.format) &&
+        (srcDesc.allowedStates.contains(ResourceState::ShaderResource) ||
+            srcDesc.allowedStates.contains(ResourceState::UnorderedAccess)))
+    {
+        resourceDesc.Format = getTypelessFormatFromDepthFormat(srcDesc.format);
+    }
+
+    return SLANG_OK;
+}
+
+void initBufferResourceDesc(Size bufferSize, D3D12_RESOURCE_DESC& out)
+{
+    out = {};
+
+    out.Dimension = D3D12_RESOURCE_DIMENSION_BUFFER;
+    out.Alignment = 0;
+    out.Width = bufferSize;
+    out.Height = 1;
+    out.DepthOrArraySize = 1;
+    out.MipLevels = 1;
+    out.Format = DXGI_FORMAT_UNKNOWN;
+    out.SampleDesc.Count = 1;
+    out.SampleDesc.Quality = 0;
+    out.Layout = D3D12_TEXTURE_LAYOUT_ROW_MAJOR;
+    out.Flags = D3D12_RESOURCE_FLAG_NONE;
+}
+
+Result uploadBufferDataImpl(
+    ID3D12Device* device,
+    ID3D12GraphicsCommandList* cmdList,
+    TransientResourceHeapImpl* transientHeap,
+    BufferResourceImpl* buffer,
+    Offset offset,
+    Size size,
+    void* data)
+{
+    IBufferResource* uploadResource;
+    Offset uploadResourceOffset = 0;
+    if (buffer->getDesc()->memoryType != MemoryType::Upload)
+    {
+        SLANG_RETURN_ON_FAIL(transientHeap->allocateStagingBuffer(
+            size, uploadResource, uploadResourceOffset, MemoryType::Upload));
+    }
+
+    D3D12Resource& uploadResourceRef =
+        (buffer->getDesc()->memoryType == MemoryType::Upload)
+        ? buffer->m_resource
+        : static_cast<BufferResourceImpl*>(uploadResource)->m_resource;
+
+    D3D12_RANGE readRange = {};
+    readRange.Begin = 0;
+    readRange.End = 0;
+    void* uploadData;
+    SLANG_RETURN_ON_FAIL(
+        uploadResourceRef.getResource()->Map(0, &readRange, reinterpret_cast<void**>(&uploadData)));
+    memcpy((uint8_t*)uploadData + uploadResourceOffset + offset, data, size);
+    D3D12_RANGE writtenRange = {};
+    writtenRange.Begin = uploadResourceOffset + offset;
+    writtenRange.End = uploadResourceOffset + offset + size;
+    uploadResourceRef.getResource()->Unmap(0, &writtenRange);
+
+    if (buffer->getDesc()->memoryType != MemoryType::Upload)
+    {
+        cmdList->CopyBufferRegion(
+            buffer->m_resource.getResource(),
+            offset,
+            uploadResourceRef.getResource(),
+            uploadResourceOffset + offset,
+            size);
+    }
+
+    return SLANG_OK;
+}
+
+Result createNullDescriptor(
+    ID3D12Device* d3dDevice,
+    D3D12_CPU_DESCRIPTOR_HANDLE destDescriptor,
+    const ShaderObjectLayoutImpl::BindingRangeInfo& bindingRange)
+{
+    switch (bindingRange.bindingType)
+    {
+    case slang::BindingType::ConstantBuffer:
+    {
+        D3D12_CONSTANT_BUFFER_VIEW_DESC cbvDesc = {};
+        cbvDesc.BufferLocation = 0;
+        cbvDesc.SizeInBytes = 0;
+        d3dDevice->CreateConstantBufferView(&cbvDesc, destDescriptor);
+    }
+    break;
+    case slang::BindingType::MutableRawBuffer:
+    {
+        D3D12_UNORDERED_ACCESS_VIEW_DESC uavDesc = {};
+        uavDesc.ViewDimension = D3D12_UAV_DIMENSION_BUFFER;
+        uavDesc.Buffer.Flags = D3D12_BUFFER_UAV_FLAG_RAW;
+        uavDesc.Format = DXGI_FORMAT_R32_TYPELESS;
+        d3dDevice->CreateUnorderedAccessView(nullptr, nullptr, &uavDesc, destDescriptor);
+    }
+    break;
+    case slang::BindingType::MutableTypedBuffer:
+    {
+        D3D12_UNORDERED_ACCESS_VIEW_DESC uavDesc = {};
+        uavDesc.ViewDimension = D3D12_UAV_DIMENSION_BUFFER;
+        uavDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
+        d3dDevice->CreateUnorderedAccessView(nullptr, nullptr, &uavDesc, destDescriptor);
+    }
+    break;
+    case slang::BindingType::RawBuffer:
+    {
+        D3D12_SHADER_RESOURCE_VIEW_DESC srvDesc = {};
+        srvDesc.ViewDimension = D3D12_SRV_DIMENSION_BUFFER;
+        srvDesc.Buffer.Flags = D3D12_BUFFER_SRV_FLAG_RAW;
+        srvDesc.Format = DXGI_FORMAT_R32_TYPELESS;
+        srvDesc.Shader4ComponentMapping = D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING;
+        d3dDevice->CreateShaderResourceView(nullptr, &srvDesc, destDescriptor);
+    }
+    break;
+    case slang::BindingType::TypedBuffer:
+    {
+        D3D12_SHADER_RESOURCE_VIEW_DESC srvDesc = {};
+        srvDesc.ViewDimension = D3D12_SRV_DIMENSION_BUFFER;
+        srvDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
+        srvDesc.Shader4ComponentMapping = D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING;
+        d3dDevice->CreateShaderResourceView(nullptr, &srvDesc, destDescriptor);
+    }
+    break;
+    case slang::BindingType::Texture:
+    {
+        D3D12_SHADER_RESOURCE_VIEW_DESC srvDesc = {};
+        srvDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
+        srvDesc.Shader4ComponentMapping = D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING;
+        switch (bindingRange.resourceShape)
+        {
+        case SLANG_TEXTURE_1D:
+            srvDesc.ViewDimension = D3D12_SRV_DIMENSION_TEXTURE1D;
+            break;
+        case SLANG_TEXTURE_1D_ARRAY:
+            srvDesc.ViewDimension = D3D12_SRV_DIMENSION_TEXTURE1DARRAY;
+            break;
+        case SLANG_TEXTURE_2D:
+            srvDesc.ViewDimension = D3D12_SRV_DIMENSION_TEXTURE2D;
+            break;
+        case SLANG_TEXTURE_2D_ARRAY:
+            srvDesc.ViewDimension = D3D12_SRV_DIMENSION_TEXTURE2DARRAY;
+            break;
+        case SLANG_TEXTURE_3D:
+            srvDesc.ViewDimension = D3D12_SRV_DIMENSION_TEXTURE3D;
+            break;
+        case SLANG_TEXTURE_CUBE:
+            srvDesc.ViewDimension = D3D12_SRV_DIMENSION_TEXTURECUBE;
+            break;
+        case SLANG_TEXTURE_CUBE_ARRAY:
+            srvDesc.ViewDimension = D3D12_SRV_DIMENSION_TEXTURECUBEARRAY;
+            break;
+        case SLANG_TEXTURE_2D_MULTISAMPLE:
+            srvDesc.ViewDimension = D3D12_SRV_DIMENSION_TEXTURE2DMS;
+            break;
+        case SLANG_TEXTURE_2D_MULTISAMPLE_ARRAY:
+            srvDesc.ViewDimension = D3D12_SRV_DIMENSION_TEXTURE2DMSARRAY;
+            break;
+        default:
+            return SLANG_OK;
+        }
+        d3dDevice->CreateShaderResourceView(nullptr, &srvDesc, destDescriptor);
+    }
+    break;
+    default:
+        break;
+    }
+    return SLANG_OK;
+}
+
+void translatePostBuildInfoDescs(
+    int propertyQueryCount,
+    AccelerationStructureQueryDesc* queryDescs,
+    List<D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_DESC>& postBuildInfoDescs)
+{
+    postBuildInfoDescs.setCount(propertyQueryCount);
+    for (int i = 0; i < propertyQueryCount; i++)
+    {
+        switch (queryDescs[i].queryType)
+        {
+        case QueryType::AccelerationStructureCompactedSize:
+            postBuildInfoDescs[i].InfoType =
+                D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_COMPACTED_SIZE;
+            postBuildInfoDescs[i].DestBuffer =
+                static_cast<PlainBufferProxyQueryPoolImpl*>(queryDescs[i].queryPool)
+                ->m_bufferResource->getDeviceAddress() +
+                sizeof(D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_COMPACTED_SIZE_DESC) *
+                queryDescs[i].firstQueryIndex;
+            break;
+        case QueryType::AccelerationStructureCurrentSize:
+            postBuildInfoDescs[i].InfoType =
+                D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_CURRENT_SIZE;
+            postBuildInfoDescs[i].DestBuffer =
+                static_cast<PlainBufferProxyQueryPoolImpl*>(queryDescs[i].queryPool)
+                ->m_bufferResource->getDeviceAddress() +
+                sizeof(D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_COMPACTED_SIZE_DESC) *
+                queryDescs[i].firstQueryIndex;
+            break;
+        case QueryType::AccelerationStructureSerializedSize:
+            postBuildInfoDescs[i].InfoType =
+                D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_SERIALIZATION;
+            postBuildInfoDescs[i].DestBuffer =
+                static_cast<PlainBufferProxyQueryPoolImpl*>(queryDescs[i].queryPool)
+                ->m_bufferResource->getDeviceAddress() +
+                sizeof(D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_SERIALIZATION_DESC) *
+                queryDescs[i].firstQueryIndex;
+            break;
+        }
+    }
+}
+
+} // namespace d3d12
+
+Result SLANG_MCALL createD3D12Device(const IDevice::Desc* desc, IDevice** outDevice)
+{
+    RefPtr<d3d12::DeviceImpl> result = new d3d12::DeviceImpl();
+    SLANG_RETURN_ON_FAIL(result->initialize(*desc));
+    returnComPtr(outDevice, result);
+    return SLANG_OK;
+}
+
+} // namespace gfx