Program Listing for File d3d12-resource.h

↰ Return to documentation for file (include\d3d12-state-tracking\d3d12-resource.h)

/******************************************************************************
© Intel Corporation.

This software and the related documents are Intel copyrighted materials,
and your use of them is governed by the express license under which they
were provided to you ("License"). Unless the License provides otherwise,
you may not use, modify, copy, publish, distribute, disclose or transmit
this software or the related documents without Intel's prior written
permission.


 This software and the related documents are provided as is, with no express
or implied warranties, other than those that are expressly stated in the
License.

******************************************************************************/

#pragma once
#include "d3d12-object.h"
#include "concurrent/critical-section.h"

#include <vector>
#include <list>
#include <d3d12.h>
#include <dxgi.h>

namespace gpa {
namespace d3d12_state_tracker {

enum ResourceType : uint32_t {
    kInvalid = 0,
    kCommitted,
    kPlaced,
    kReserved,
    kMaxTypes
};

D3D12_RESOURCE_STATES constexpr kInvalidResourceState = (D3D12_RESOURCE_STATES)UINT32_MAX;

struct PlacedResourceInfo
{
    WeakPtr<ID3D12Heap> pHeap;
    UINT64 heapOffset = 0;
};

struct TileMapInfo
{
    WeakPtr<ID3D12Heap> pHeap;
    uint64_t timestamp = UINT64_MAX;
    UINT offset = 0;
#ifdef _DEBUG
    UINT tileIndexInResource = 0;
#endif
};

struct SubresourceTilingInfo
{
    D3D12_SUBRESOURCE_TILING tiling = {};
    bool isPacked = false;
    std::vector<TileMapInfo> tileMappings;
};

struct MapInfo
{
    D3D12_RANGE pReadRange;
    void* pData;
};

struct SubresourceState
{
    uint32_t index;
    D3D12_RESOURCE_STATES state;
    D3D12_BARRIER_LAYOUT layout;
    SubresourceTilingInfo tilingInfo;
    std::list<MapInfo> mapStack;
};

struct ResourceTilingInfo
{
    UINT numTilesForEntireResource;
    D3D12_PACKED_MIP_INFO packedMipDesc;
    D3D12_TILE_SHAPE standardTileShapeForNonPackedMips;
    std::vector<TileMapInfo> packedMipsTileMappings;
};

struct D3D12_RAYTRACING_ACCELERATION_STRUCTURE_DESC;

//        DX12_RAYTRACING_INSTANCE_DESC without bitfields.
//        bitfields do not work well with offsetof when pulling reflection data.
struct DX12_RAYTRACING_INSTANCE_DESC
{
    FLOAT Transform[3][4];
    UINT InstanceID;
    UINT InstanceMask;
    UINT InstanceContributionToHitGroupIndex;
    UINT Flags;
    D3D12_RAYTRACING_ACCELERATION_STRUCTURE_DESC* AccelerationStructure{};
};

//        raytracing acceleration structure object.
struct D3D12_RAYTRACING_ACCELERATION_STRUCTURE_DESC
{
    D3D12_RAYTRACING_ACCELERATION_STRUCTURE_TYPE Type;
    UINT NumDescs;
    const DX12_RAYTRACING_INSTANCE_DESC* pInstanceDescs;
    const D3D12_RAYTRACING_GEOMETRY_DESC* pGeometryDescs;
    uint64_t Size;
};

class D3D12ResourceState : public D3D12ObjectState
{
public:
    static constexpr GUID sGUID = {0x12d26255, 0x5da6, 0x4795, {0x96, 0xbe, 0xc0, 0xad, 0x2b, 0x5d, 0xe4, 0x80}};

private:
    ResourceType mType = kInvalid;
    union
    {
        PlacedResourceInfo mPlacedResourceInfo;
        ResourceTilingInfo mTiledResourceInfo;
    };
    std::vector<SubresourceState> mSubresources;
    bool mIsBackBuffer = false;
    uint32_t mBackBufferIndex = 0;
    IDXGISwapChain* mParentSwapChain = nullptr;
    bool mIsDirty = true;
    uint32_t mResidencyRefCount = 1;

    D3D12_GPU_VIRTUAL_ADDRESS mGPUVirtualAddress{};
    bool mGPUVirtualAddressObtained = false;

    D3D12_RESOURCE_STATES mInitialResourceState;
    bool mHasOptimizedClearValue = false;
    D3D12_CLEAR_VALUE const mOptimizedClearValue;

    // enhanced barrier support
    D3D12_BARRIER_LAYOUT mInitialLayout = D3D12_BARRIER_LAYOUT_UNDEFINED;
    ID3D12ProtectedResourceSession* mProtectedSession = nullptr;
    UINT32 mNumCastableFormats = 0;
    std::vector<DXGI_FORMAT> mCastableFormats;
    // Need to track whether we're currently using enhanced barrier: they can interop with old style but only after
    // specific sets of transitions are used. We need to know the type of the most recent barrier.
    bool mUsingEnhancedBarriers = false;
    bool mCreatedWithEnhancedBarriers = false;

    std::vector<std::function<void(ID3D12Resource*)>> mDirtyCallbacks;
    gpa::concurrent::CriticalSection mCriticalSection;

    std::vector<D3D12_RAYTRACING_GEOMETRY_DESC> mRaytracingGeometryDescs;
    std::vector<DX12_RAYTRACING_INSTANCE_DESC> mRaytracingInstanceDescs;

    D3D12_RAYTRACING_ACCELERATION_STRUCTURE_DESC mD3D12RaytracingAccelerationStructure;

public:
    D3D12ResourceState(ID3D12Resource* pResource, ID3D12Heap* pHeap, UINT64 HeapOffset, D3D12_RESOURCE_DESC const* pDesc, D3D12_RESOURCE_STATES initialResourceState, D3D12_CLEAR_VALUE const* pOptimizedClearValue, ResourceType type);
    D3D12ResourceState(ID3D12Resource* pResource, D3D12_RESOURCE_DESC const* pDesc, D3D12_RESOURCE_STATES initialResourceState, D3D12_CLEAR_VALUE const* pOptimizedClearValue, ResourceType type, IDXGISwapChain* parentSwapChain = nullptr, uint32_t backBufferIndex = UINT32_MAX);
#if defined(NTDDI_WIN10_VB) && (NTDDI_VERSION >= NTDDI_WIN10_VB)
    D3D12ResourceState(ID3D12Resource* pResource, ID3D12Heap* pHeap, UINT64 HeapOffset, D3D12_RESOURCE_DESC1 const* pDesc, D3D12_RESOURCE_STATES initialResourceState, D3D12_CLEAR_VALUE const* pOptimizedClearValue, ResourceType type);
    D3D12ResourceState(ID3D12Resource* pResource, D3D12_RESOURCE_DESC1 const* pDesc, D3D12_RESOURCE_STATES initialResourceState, D3D12_CLEAR_VALUE const* pOptimizedClearValue, ResourceType type, IDXGISwapChain* parentSwapChain = nullptr, uint32_t backBufferIndex = UINT32_MAX);
#endif  // NTDDI_WIN10_VB

#if defined(__ID3D12Device10_INTERFACE_DEFINED__)
    // CreateCommittedResource3 support for enhanced barriers
    D3D12ResourceState(ID3D12Resource* pResource, const D3D12_HEAP_PROPERTIES* pheapproperties, D3D12_HEAP_FLAGS HeapFlags, const D3D12_RESOURCE_DESC1* pDesc, D3D12_BARRIER_LAYOUT InitialLayout, const D3D12_CLEAR_VALUE* pOptimizedClearValue, ID3D12ProtectedResourceSession* pProtectedSession, UINT32 NumCastableFormats, DXGI_FORMAT const* pCastableFormats);
    // CreatePlacedResource2 support for enhanced barriers
    D3D12ResourceState(ID3D12Resource* pResource, ID3D12Heap* pHeap, UINT64 HeapOffset, const D3D12_RESOURCE_DESC1* pDesc, D3D12_BARRIER_LAYOUT InitialLayout, const D3D12_CLEAR_VALUE* pOptimizedClearValue, UINT32 NumCastableFormats, DXGI_FORMAT const* pCastableFormats);
    // CreateReservedResource2 support for enhanced barriers
    D3D12ResourceState(ID3D12Resource* pResource, const D3D12_RESOURCE_DESC* pDesc, D3D12_BARRIER_LAYOUT InitialLayout, const D3D12_CLEAR_VALUE* pOptimizedClearValue, ID3D12ProtectedResourceSession* pProtectedSession, UINT32 NumCastableFormats, DXGI_FORMAT const* pCastableFormats);
#endif  // __ID3D12Device10_INTERFACE_DEFINED__

    ~D3D12ResourceState();

    GUID GetGUID() override;

    void OnStateTransition(uint32_t subresource, D3D12_RESOURCE_STATES stateAfter);
    void OnLayoutTransition(const D3D12_BARRIER_SUBRESOURCE_RANGE& subresource, D3D12_BARRIER_LAYOUT layoutAfter);
    void OnMap(uint32_t subresource, D3D12_RANGE const* pReadRange, void** ppData);
    void OnUnmap(uint32_t subresource, D3D12_RANGE const* pWrittenRange);
    void OnEvict();
    void OnMakeResident();
    void OnUpdateTileMappings(UINT NumResourceRegions, D3D12_TILED_RESOURCE_COORDINATE const* pResourceRegionStartCoordinates, D3D12_TILE_REGION_SIZE const* pResourceRegionSizes, ID3D12Heap* pHeap, UINT NumRanges, D3D12_TILE_RANGE_FLAGS const* pRangeFlags, UINT const* pHeapRangeStartOffsets, UINT const* pRangeTileCounts, D3D12_TILE_MAPPING_FLAGS Flags);
    void OnCopyTileMappings(D3D12_TILED_RESOURCE_COORDINATE const* pDstRegionStartCoordinate, ID3D12Resource* pSrcResource, D3D12_TILED_RESOURCE_COORDINATE const* pSrcRegionStartCoordinate, D3D12_TILE_REGION_SIZE const* pRegionSize, D3D12_TILE_MAPPING_FLAGS Flags);

    D3D12_RESOURCE_STATES GetSubresourceState(uint32_t index) const;

    std::vector<D3D12_RESOURCE_STATES> GetStateOfAllSubresources(bool* allSubresourcesStateEqual) const;

    std::vector<D3D12_BARRIER_LAYOUT> GetLayoutOfAllSubresources(bool* allSubresourcesLayoutEqual) const;

    std::vector<D3D12_RESOURCE_STATES> D3D12ResourceState::GetLayoutOfAllSubresourcesAsState(bool* pAllSubresourcesLayoutEqual) const;

    std::vector<D3D12_RESOURCE_BARRIER> PrepareSetOfBarriersForWholeResource();

    ResourceType GetType() const;

    PlacedResourceInfo GetHeapPlacementInfo() const;

    ResourceTilingInfo GetTilingInfo() const;

    std::vector<SubresourceState> const& GetSubresources() const;

    uint32_t GetSubresourceCount() const;

    bool IsBackbuffer() const;

    bool IsAccelerationStructure() const;

    uint32_t GetBackbufferIndex() const;

    IDXGISwapChain* GetParentSwapChain() const;

    void SetDirty(bool value);
    bool IsDirty();
    void RegisterDirtyCallback(std::function<void(ID3D12Resource* dirtyResource)> callback);
    void UnregisterAllDirtyCallbacks();

    bool IsMapped();

    bool IsResident();

    bool IsTexture() const;

    bool IsCompressed() const;

    D3D12_RESOURCE_STATES GetInitialResourceState();

    D3D12_CLEAR_VALUE const* GetOptimizedClearValue();

    D3D12_GPU_VIRTUAL_ADDRESS GetGPUVirtualAddress();

    void SetRaytracingGeometryDescs(std::vector<D3D12_RAYTRACING_GEOMETRY_DESC> const& descs);

    void SetRaytracingInstanceDescs(std::vector<D3D12_RAYTRACING_INSTANCE_DESC> const& descs);

    void SetRaytracingAccelerationStructureType(D3D12_RAYTRACING_ACCELERATION_STRUCTURE_TYPE accelerationStructureType);

    D3D12_RAYTRACING_ACCELERATION_STRUCTURE_DESC* GetRaytracingAccelerationStructure();

    void SetAccelerationStructureSize(uint64_t size);
    uint64_t GetAccelerationStructureSize();

    bool GPUVirtualAddressObtained() const;
    void GPUVirtualAddressObtained(bool val);

    void SetUsingEnhancedBarriers(bool enhancedBarrier);
    bool UsingEnhancedBarriers() const;
    bool CreatedWithEnhancedBarriers() const;
    D3D12_BARRIER_LAYOUT GetInitialBarrierLayout() const;
    UINT32 GetCastableFormatCount() const;
    DXGI_FORMAT* GetCastableFormats();
    ID3D12ProtectedResourceSession* GetProtectedResourceSession() const;
};

}  // namespace d3d12_state_tracker
}  // namespace gpa