Set up pass-through implementations for D3D12 device/command list

2026-08-28 01:16:31 +00:00 · 2016-07-10 18:09:32 +02:00
parent b387f8e7f1
commit 6ce0ea37dc
2 changed files with 103 additions and 22 deletions
@@ -26,23 +26,26 @@

 HRESULT WrappedID3D12GraphicsCommandList::Close()
 {
-  return S_OK;
+  return m_pReal->Close();
 }

 HRESULT WrappedID3D12GraphicsCommandList::Reset(ID3D12CommandAllocator *pAllocator,
                                                ID3D12PipelineState *pInitialState)
 {
-  return S_OK;
+  return m_pReal->Reset(pAllocator, pInitialState);
 }

 void WrappedID3D12GraphicsCommandList::ClearState(ID3D12PipelineState *pPipelineState)
 {
+  return m_pReal->ClearState(pPipelineState);
 }

 void WrappedID3D12GraphicsCommandList::DrawInstanced(UINT VertexCountPerInstance,
                                                     UINT InstanceCount, UINT StartVertexLocation,
                                                     UINT StartInstanceLocation)
 {
+  return m_pReal->DrawInstanced(VertexCountPerInstance, InstanceCount, StartVertexLocation,
+                                StartInstanceLocation);
 }

 void WrappedID3D12GraphicsCommandList::DrawIndexedInstanced(UINT IndexCountPerInstance,
@@ -51,17 +54,21 @@ void WrappedID3D12GraphicsCommandList::DrawIndexedInstanced(UINT IndexCountPerIn
                                                            INT BaseVertexLocation,
                                                            UINT StartInstanceLocation)
 {
+  return m_pReal->DrawIndexedInstanced(IndexCountPerInstance, InstanceCount, StartIndexLocation,
+                                       BaseVertexLocation, StartInstanceLocation);
 }

 void WrappedID3D12GraphicsCommandList::Dispatch(UINT ThreadGroupCountX, UINT ThreadGroupCountY,
                                                UINT ThreadGroupCountZ)
 {
+  return m_pReal->Dispatch(ThreadGroupCountX, ThreadGroupCountY, ThreadGroupCountZ);
 }

 void WrappedID3D12GraphicsCommandList::CopyBufferRegion(ID3D12Resource *pDstBuffer,
                                                        UINT64 DstOffset, ID3D12Resource *pSrcBuffer,
                                                        UINT64 SrcOffset, UINT64 NumBytes)
 {
+  return m_pReal->CopyBufferRegion(pDstBuffer, DstOffset, pSrcBuffer, SrcOffset, NumBytes);
 }

 void WrappedID3D12GraphicsCommandList::CopyTextureRegion(const D3D12_TEXTURE_COPY_LOCATION *pDst,
@@ -69,11 +76,13 @@ void WrappedID3D12GraphicsCommandList::CopyTextureRegion(const D3D12_TEXTURE_COP
                                                         const D3D12_TEXTURE_COPY_LOCATION *pSrc,
                                                         const D3D12_BOX *pSrcBox)
 {
+  return m_pReal->CopyTextureRegion(pDst, DstX, DstY, DstZ, pSrc, pSrcBox);
 }

 void WrappedID3D12GraphicsCommandList::CopyResource(ID3D12Resource *pDstResource,
                                                    ID3D12Resource *pSrcResource)
 {
+  return m_pReal->CopyResource(pDstResource, pSrcResource);
 }

 void WrappedID3D12GraphicsCommandList::CopyTiles(
@@ -81,6 +90,8 @@ void WrappedID3D12GraphicsCommandList::CopyTiles(
    const D3D12_TILE_REGION_SIZE *pTileRegionSize, ID3D12Resource *pBuffer,
    UINT64 BufferStartOffsetInBytes, D3D12_TILE_COPY_FLAGS Flags)
 {
+  return m_pReal->CopyTiles(pTiledResource, pTileRegionStartCoordinate, pTileRegionSize, pBuffer,
+                            BufferStartOffsetInBytes, Flags);
 }

 void WrappedID3D12GraphicsCommandList::ResolveSubresource(ID3D12Resource *pDstResource,
@@ -88,75 +99,92 @@ void WrappedID3D12GraphicsCommandList::ResolveSubresource(ID3D12Resource *pDstRe
                                                          ID3D12Resource *pSrcResource,
                                                          UINT SrcSubresource, DXGI_FORMAT Format)
 {
+  return m_pReal->ResolveSubresource(pDstResource, DstSubresource, pSrcResource, SrcSubresource,
+                                     Format);
 }

 void WrappedID3D12GraphicsCommandList::IASetPrimitiveTopology(D3D12_PRIMITIVE_TOPOLOGY PrimitiveTopology)
 {
+  return m_pReal->IASetPrimitiveTopology(PrimitiveTopology);
 }

 void WrappedID3D12GraphicsCommandList::RSSetViewports(UINT NumViewports,
                                                      const D3D12_VIEWPORT *pViewports)
 {
+  return m_pReal->RSSetViewports(NumViewports, pViewports);
 }

 void WrappedID3D12GraphicsCommandList::RSSetScissorRects(UINT NumRects, const D3D12_RECT *pRects)
 {
+  return m_pReal->RSSetScissorRects(NumRects, pRects);
 }

 void WrappedID3D12GraphicsCommandList::OMSetBlendFactor(const FLOAT BlendFactor[4])
 {
+  return m_pReal->OMSetBlendFactor(BlendFactor);
 }

 void WrappedID3D12GraphicsCommandList::OMSetStencilRef(UINT StencilRef)
 {
+  return m_pReal->OMSetStencilRef(StencilRef);
 }

 void WrappedID3D12GraphicsCommandList::SetPipelineState(ID3D12PipelineState *pPipelineState)
 {
+  return m_pReal->SetPipelineState(pPipelineState);
 }

 void WrappedID3D12GraphicsCommandList::ResourceBarrier(UINT NumBarriers,
                                                       const D3D12_RESOURCE_BARRIER *pBarriers)
 {
+  return m_pReal->ResourceBarrier(NumBarriers, pBarriers);
 }

 void WrappedID3D12GraphicsCommandList::ExecuteBundle(ID3D12GraphicsCommandList *pCommandList)
 {
+  return m_pReal->ExecuteBundle(pCommandList);
 }

 void WrappedID3D12GraphicsCommandList::SetDescriptorHeaps(UINT NumDescriptorHeaps,
                                                          ID3D12DescriptorHeap *const *ppDescriptorHeaps)
 {
+  return m_pReal->SetDescriptorHeaps(NumDescriptorHeaps, ppDescriptorHeaps);
 }

 void WrappedID3D12GraphicsCommandList::SetComputeRootSignature(ID3D12RootSignature *pRootSignature)
 {
+  return m_pReal->SetComputeRootSignature(pRootSignature);
 }

 void WrappedID3D12GraphicsCommandList::SetGraphicsRootSignature(ID3D12RootSignature *pRootSignature)
 {
+  return m_pReal->SetGraphicsRootSignature(pRootSignature);
 }

 void WrappedID3D12GraphicsCommandList::SetComputeRootDescriptorTable(
    UINT RootParameterIndex, D3D12_GPU_DESCRIPTOR_HANDLE BaseDescriptor)
 {
+  return m_pReal->SetComputeRootDescriptorTable(RootParameterIndex, BaseDescriptor);
 }

 void WrappedID3D12GraphicsCommandList::SetGraphicsRootDescriptorTable(
    UINT RootParameterIndex, D3D12_GPU_DESCRIPTOR_HANDLE BaseDescriptor)
 {
+  return m_pReal->SetGraphicsRootDescriptorTable(RootParameterIndex, BaseDescriptor);
 }

 void WrappedID3D12GraphicsCommandList::SetComputeRoot32BitConstant(UINT RootParameterIndex,
                                                                   UINT SrcData,
                                                                   UINT DestOffsetIn32BitValues)
 {
+  return m_pReal->SetComputeRoot32BitConstant(RootParameterIndex, SrcData, DestOffsetIn32BitValues);
 }

 void WrappedID3D12GraphicsCommandList::SetGraphicsRoot32BitConstant(UINT RootParameterIndex,
                                                                    UINT SrcData,
                                                                    UINT DestOffsetIn32BitValues)
 {
+  return m_pReal->SetGraphicsRoot32BitConstant(RootParameterIndex, SrcData, DestOffsetIn32BitValues);
 }

 void WrappedID3D12GraphicsCommandList::SetComputeRoot32BitConstants(UINT RootParameterIndex,
@@ -164,6 +192,8 @@ void WrappedID3D12GraphicsCommandList::SetComputeRoot32BitConstants(UINT RootPar
                                                                    const void *pSrcData,
                                                                    UINT DestOffsetIn32BitValues)
 {
+  return m_pReal->SetComputeRoot32BitConstants(RootParameterIndex, Num32BitValuesToSet, pSrcData,
+                                               DestOffsetIn32BitValues);
 }

 void WrappedID3D12GraphicsCommandList::SetGraphicsRoot32BitConstants(UINT RootParameterIndex,
@@ -171,95 +201,118 @@ void WrappedID3D12GraphicsCommandList::SetGraphicsRoot32BitConstants(UINT RootPa
                                                                     const void *pSrcData,
                                                                     UINT DestOffsetIn32BitValues)
 {
+  return m_pReal->SetGraphicsRoot32BitConstants(RootParameterIndex, Num32BitValuesToSet, pSrcData,
+                                                DestOffsetIn32BitValues);
 }

 void WrappedID3D12GraphicsCommandList::SetComputeRootConstantBufferView(
    UINT RootParameterIndex, D3D12_GPU_VIRTUAL_ADDRESS BufferLocation)
 {
+  return m_pReal->SetComputeRootConstantBufferView(RootParameterIndex, BufferLocation);
 }

 void WrappedID3D12GraphicsCommandList::SetGraphicsRootConstantBufferView(
    UINT RootParameterIndex, D3D12_GPU_VIRTUAL_ADDRESS BufferLocation)
 {
+  return m_pReal->SetGraphicsRootConstantBufferView(RootParameterIndex, BufferLocation);
 }

 void WrappedID3D12GraphicsCommandList::SetComputeRootShaderResourceView(
    UINT RootParameterIndex, D3D12_GPU_VIRTUAL_ADDRESS BufferLocation)
 {
+  return m_pReal->SetComputeRootShaderResourceView(RootParameterIndex, BufferLocation);
 }

 void WrappedID3D12GraphicsCommandList::SetGraphicsRootShaderResourceView(
    UINT RootParameterIndex, D3D12_GPU_VIRTUAL_ADDRESS BufferLocation)
 {
+  return m_pReal->SetGraphicsRootShaderResourceView(RootParameterIndex, BufferLocation);
 }

 void WrappedID3D12GraphicsCommandList::SetComputeRootUnorderedAccessView(
    UINT RootParameterIndex, D3D12_GPU_VIRTUAL_ADDRESS BufferLocation)
 {
+  return m_pReal->SetComputeRootUnorderedAccessView(RootParameterIndex, BufferLocation);
 }

 void WrappedID3D12GraphicsCommandList::SetGraphicsRootUnorderedAccessView(
    UINT RootParameterIndex, D3D12_GPU_VIRTUAL_ADDRESS BufferLocation)
 {
+  return m_pReal->SetGraphicsRootUnorderedAccessView(RootParameterIndex, BufferLocation);
 }

 void WrappedID3D12GraphicsCommandList::IASetIndexBuffer(const D3D12_INDEX_BUFFER_VIEW *pView)
 {
+  return m_pReal->IASetIndexBuffer(pView);
 }

 void WrappedID3D12GraphicsCommandList::IASetVertexBuffers(UINT StartSlot, UINT NumViews,
                                                          const D3D12_VERTEX_BUFFER_VIEW *pViews)
 {
+  return m_pReal->IASetVertexBuffers(StartSlot, NumViews, pViews);
 }

 void WrappedID3D12GraphicsCommandList::SOSetTargets(UINT StartSlot, UINT NumViews,
                                                    const D3D12_STREAM_OUTPUT_BUFFER_VIEW *pViews)
 {
+  return m_pReal->SOSetTargets(StartSlot, NumViews, pViews);
 }

 void WrappedID3D12GraphicsCommandList::OMSetRenderTargets(
    UINT NumRenderTargetDescriptors, const D3D12_CPU_DESCRIPTOR_HANDLE *pRenderTargetDescriptors,
    BOOL RTsSingleHandleToDescriptorRange, const D3D12_CPU_DESCRIPTOR_HANDLE *pDepthStencilDescriptor)
 {
+  return m_pReal->OMSetRenderTargets(NumRenderTargetDescriptors, pRenderTargetDescriptors,
+                                     RTsSingleHandleToDescriptorRange, pDepthStencilDescriptor);
 }

 void WrappedID3D12GraphicsCommandList::ClearDepthStencilView(
    D3D12_CPU_DESCRIPTOR_HANDLE DepthStencilView, D3D12_CLEAR_FLAGS ClearFlags, FLOAT Depth,
    UINT8 Stencil, UINT NumRects, const D3D12_RECT *pRects)
 {
+  return m_pReal->ClearDepthStencilView(DepthStencilView, ClearFlags, Depth, Stencil, NumRects,
+                                        pRects);
 }

 void WrappedID3D12GraphicsCommandList::ClearRenderTargetView(
    D3D12_CPU_DESCRIPTOR_HANDLE RenderTargetView, const FLOAT ColorRGBA[4], UINT NumRects,
    const D3D12_RECT *pRects)
 {
+  return m_pReal->ClearRenderTargetView(RenderTargetView, ColorRGBA, NumRects, pRects);
 }

 void WrappedID3D12GraphicsCommandList::ClearUnorderedAccessViewUint(
    D3D12_GPU_DESCRIPTOR_HANDLE ViewGPUHandleInCurrentHeap, D3D12_CPU_DESCRIPTOR_HANDLE ViewCPUHandle,
    ID3D12Resource *pResource, const UINT Values[4], UINT NumRects, const D3D12_RECT *pRects)
 {
+  return m_pReal->ClearUnorderedAccessViewUint(ViewGPUHandleInCurrentHeap, ViewCPUHandle, pResource,
+                                               Values, NumRects, pRects);
 }

 void WrappedID3D12GraphicsCommandList::ClearUnorderedAccessViewFloat(
    D3D12_GPU_DESCRIPTOR_HANDLE ViewGPUHandleInCurrentHeap, D3D12_CPU_DESCRIPTOR_HANDLE ViewCPUHandle,
    ID3D12Resource *pResource, const FLOAT Values[4], UINT NumRects, const D3D12_RECT *pRects)
 {
+  return m_pReal->ClearUnorderedAccessViewFloat(ViewGPUHandleInCurrentHeap, ViewCPUHandle,
+                                                pResource, Values, NumRects, pRects);
 }

 void WrappedID3D12GraphicsCommandList::DiscardResource(ID3D12Resource *pResource,
                                                       const D3D12_DISCARD_REGION *pRegion)
 {
+  return m_pReal->DiscardResource(pResource, pRegion);
 }

 void WrappedID3D12GraphicsCommandList::BeginQuery(ID3D12QueryHeap *pQueryHeap,
                                                  D3D12_QUERY_TYPE Type, UINT Index)
 {
+  return m_pReal->BeginQuery(pQueryHeap, Type, Index);
 }

 void WrappedID3D12GraphicsCommandList::EndQuery(ID3D12QueryHeap *pQueryHeap, D3D12_QUERY_TYPE Type,
                                                UINT Index)
 {
+  return m_pReal->EndQuery(pQueryHeap, Type, Index);
 }

 void WrappedID3D12GraphicsCommandList::ResolveQueryData(ID3D12QueryHeap *pQueryHeap,
@@ -268,24 +321,30 @@ void WrappedID3D12GraphicsCommandList::ResolveQueryData(ID3D12QueryHeap *pQueryH
                                                        ID3D12Resource *pDestinationBuffer,
                                                        UINT64 AlignedDestinationBufferOffset)
 {
+  return m_pReal->ResolveQueryData(pQueryHeap, Type, StartIndex, NumQueries, pDestinationBuffer,
+                                   AlignedDestinationBufferOffset);
 }

 void WrappedID3D12GraphicsCommandList::SetPredication(ID3D12Resource *pBuffer,
                                                      UINT64 AlignedBufferOffset,
                                                      D3D12_PREDICATION_OP Operation)
 {
+  return m_pReal->SetPredication(pBuffer, AlignedBufferOffset, Operation);
 }

 void WrappedID3D12GraphicsCommandList::SetMarker(UINT Metadata, const void *pData, UINT Size)
 {
+  return m_pReal->SetMarker(Metadata, pData, Size);
 }

 void WrappedID3D12GraphicsCommandList::BeginEvent(UINT Metadata, const void *pData, UINT Size)
 {
+  return m_pReal->BeginEvent(Metadata, pData, Size);
 }

 void WrappedID3D12GraphicsCommandList::EndEvent()
 {
+  return m_pReal->EndEvent();
 }

 void WrappedID3D12GraphicsCommandList::ExecuteIndirect(ID3D12CommandSignature *pCommandSignature,
@@ -295,4 +354,6 @@ void WrappedID3D12GraphicsCommandList::ExecuteIndirect(ID3D12CommandSignature *p
                                                       ID3D12Resource *pCountBuffer,
                                                       UINT64 CountBufferOffset)
 {
+  return m_pReal->ExecuteIndirect(pCommandSignature, MaxCommandCount, pArgumentBuffer,
+                                  ArgumentBufferOffset, pCountBuffer, CountBufferOffset);
 }
@@ -28,25 +28,25 @@
 HRESULT WrappedID3D12Device::CreateCommandQueue(const D3D12_COMMAND_QUEUE_DESC *pDesc, REFIID riid,
                                                void **ppCommandQueue)
 {
-  return E_NOTIMPL;
+  return m_pDevice->CreateCommandQueue(pDesc, riid, ppCommandQueue);
 }

 HRESULT WrappedID3D12Device::CreateCommandAllocator(D3D12_COMMAND_LIST_TYPE type, REFIID riid,
                                                    void **ppCommandAllocator)
 {
-  return E_NOTIMPL;
+  return m_pDevice->CreateCommandAllocator(type, riid, ppCommandAllocator);
 }

 HRESULT WrappedID3D12Device::CreateGraphicsPipelineState(const D3D12_GRAPHICS_PIPELINE_STATE_DESC *pDesc,
                                                         REFIID riid, void **ppPipelineState)
 {
-  return E_NOTIMPL;
+  return m_pDevice->CreateGraphicsPipelineState(pDesc, riid, ppPipelineState);
 }

 HRESULT WrappedID3D12Device::CreateComputePipelineState(const D3D12_COMPUTE_PIPELINE_STATE_DESC *pDesc,
                                                        REFIID riid, void **ppPipelineState)
 {
-  return E_NOTIMPL;
+  return m_pDevice->CreateComputePipelineState(pDesc, riid, ppPipelineState);
 }

 HRESULT WrappedID3D12Device::CreateCommandList(UINT nodeMask, D3D12_COMMAND_LIST_TYPE type,
@@ -54,31 +54,35 @@ HRESULT WrappedID3D12Device::CreateCommandList(UINT nodeMask, D3D12_COMMAND_LIST
                                               ID3D12PipelineState *pInitialState, REFIID riid,
                                               void **ppCommandList)
 {
-  return E_NOTIMPL;
+  return m_pDevice->CreateCommandList(nodeMask, type, pCommandAllocator, pInitialState, riid,
+                                      ppCommandList);
 }

 HRESULT WrappedID3D12Device::CreateDescriptorHeap(const D3D12_DESCRIPTOR_HEAP_DESC *pDescriptorHeapDesc,
                                                  REFIID riid, void **ppvHeap)
 {
-  return E_NOTIMPL;
+  return m_pDevice->CreateDescriptorHeap(pDescriptorHeapDesc, riid, ppvHeap);
 }

 HRESULT WrappedID3D12Device::CreateRootSignature(UINT nodeMask, const void *pBlobWithRootSignature,
                                                 SIZE_T blobLengthInBytes, REFIID riid,
                                                 void **ppvRootSignature)
 {
-  return E_NOTIMPL;
+  return m_pDevice->CreateRootSignature(nodeMask, pBlobWithRootSignature, blobLengthInBytes, riid,
+                                        ppvRootSignature);
 }

 void WrappedID3D12Device::CreateConstantBufferView(const D3D12_CONSTANT_BUFFER_VIEW_DESC *pDesc,
                                                   D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor)
 {
+  return m_pDevice->CreateConstantBufferView(pDesc, DestDescriptor);
 }

 void WrappedID3D12Device::CreateShaderResourceView(ID3D12Resource *pResource,
                                                   const D3D12_SHADER_RESOURCE_VIEW_DESC *pDesc,
                                                   D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor)
 {
+  return m_pDevice->CreateShaderResourceView(pResource, pDesc, DestDescriptor);
 }

 void WrappedID3D12Device::CreateUnorderedAccessView(ID3D12Resource *pResource,
@@ -86,23 +90,27 @@ void WrappedID3D12Device::CreateUnorderedAccessView(ID3D12Resource *pResource,
                                                    const D3D12_UNORDERED_ACCESS_VIEW_DESC *pDesc,
                                                    D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor)
 {
+  return m_pDevice->CreateUnorderedAccessView(pResource, pCounterResource, pDesc, DestDescriptor);
 }

 void WrappedID3D12Device::CreateRenderTargetView(ID3D12Resource *pResource,
                                                 const D3D12_RENDER_TARGET_VIEW_DESC *pDesc,
                                                 D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor)
 {
+  return m_pDevice->CreateRenderTargetView(pResource, pDesc, DestDescriptor);
 }

 void WrappedID3D12Device::CreateDepthStencilView(ID3D12Resource *pResource,
                                                 const D3D12_DEPTH_STENCIL_VIEW_DESC *pDesc,
                                                 D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor)
 {
+  return m_pDevice->CreateDepthStencilView(pResource, pDesc, DestDescriptor);
 }

 void WrappedID3D12Device::CreateSampler(const D3D12_SAMPLER_DESC *pDesc,
                                        D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor)
 {
+  return m_pDevice->CreateSampler(pDesc, DestDescriptor);
 }

 HRESULT WrappedID3D12Device::CreateCommittedResource(const D3D12_HEAP_PROPERTIES *pHeapProperties,
@@ -112,12 +120,14 @@ HRESULT WrappedID3D12Device::CreateCommittedResource(const D3D12_HEAP_PROPERTIES
                                                     const D3D12_CLEAR_VALUE *pOptimizedClearValue,
                                                     REFIID riidResource, void **ppvResource)
 {
-  return E_NOTIMPL;
+  return m_pDevice->CreateCommittedResource(pHeapProperties, HeapFlags, pResourceDesc,
+                                            InitialResourceState, pOptimizedClearValue,
+                                            riidResource, ppvResource);
 }

 HRESULT WrappedID3D12Device::CreateHeap(const D3D12_HEAP_DESC *pDesc, REFIID riid, void **ppvHeap)
 {
-  return E_NOTIMPL;
+  return m_pDevice->CreateHeap(pDesc, riid, ppvHeap);
 }

 HRESULT WrappedID3D12Device::CreatePlacedResource(ID3D12Heap *pHeap, UINT64 HeapOffset,
@@ -126,7 +136,8 @@ HRESULT WrappedID3D12Device::CreatePlacedResource(ID3D12Heap *pHeap, UINT64 Heap
                                                  const D3D12_CLEAR_VALUE *pOptimizedClearValue,
                                                  REFIID riid, void **ppvResource)
 {
-  return E_NOTIMPL;
+  return m_pDevice->CreatePlacedResource(pHeap, HeapOffset, pDesc, InitialState,
+                                         pOptimizedClearValue, riid, ppvResource);
 }

 HRESULT WrappedID3D12Device::CreateReservedResource(const D3D12_RESOURCE_DESC *pDesc,
@@ -134,33 +145,34 @@ HRESULT WrappedID3D12Device::CreateReservedResource(const D3D12_RESOURCE_DESC *p
                                                    const D3D12_CLEAR_VALUE *pOptimizedClearValue,
                                                    REFIID riid, void **ppvResource)
 {
-  return E_NOTIMPL;
+  return m_pDevice->CreateReservedResource(pDesc, InitialState, pOptimizedClearValue, riid,
+                                           ppvResource);
 }

 HRESULT WrappedID3D12Device::CreateFence(UINT64 InitialValue, D3D12_FENCE_FLAGS Flags, REFIID riid,
                                         void **ppFence)
 {
-  return E_NOTIMPL;
+  return m_pDevice->CreateFence(InitialValue, Flags, riid, ppFence);
 }

 HRESULT WrappedID3D12Device::CreateQueryHeap(const D3D12_QUERY_HEAP_DESC *pDesc, REFIID riid,
                                             void **ppvHeap)
 {
-  return E_NOTIMPL;
+  return m_pDevice->CreateQueryHeap(pDesc, riid, ppvHeap);
 }

 HRESULT WrappedID3D12Device::CreateCommandSignature(const D3D12_COMMAND_SIGNATURE_DESC *pDesc,
                                                    ID3D12RootSignature *pRootSignature,
                                                    REFIID riid, void **ppvCommandSignature)
 {
-  return E_NOTIMPL;
+  return m_pDevice->CreateCommandSignature(pDesc, pRootSignature, riid, ppvCommandSignature);
 }

 HRESULT WrappedID3D12Device::CreateSharedHandle(ID3D12DeviceChild *pObject,
                                                const SECURITY_ATTRIBUTES *pAttributes,
                                                DWORD Access, LPCWSTR Name, HANDLE *pHandle)
 {
-  return E_NOTIMPL;
+  return m_pDevice->CreateSharedHandle(pObject, pAttributes, Access, Name, pHandle);
 }

 void WrappedID3D12Device::CopyDescriptors(
@@ -169,6 +181,10 @@ void WrappedID3D12Device::CopyDescriptors(
    const D3D12_CPU_DESCRIPTOR_HANDLE *pSrcDescriptorRangeStarts,
    const UINT *pSrcDescriptorRangeSizes, D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapsType)
 {
+  return m_pDevice->CopyDescriptors(NumDestDescriptorRanges, pDestDescriptorRangeStarts,
+                                    pDestDescriptorRangeSizes, NumSrcDescriptorRanges,
+                                    pSrcDescriptorRangeStarts, pSrcDescriptorRangeSizes,
+                                    DescriptorHeapsType);
 }

 void WrappedID3D12Device::CopyDescriptorsSimple(UINT NumDescriptors,
@@ -176,29 +192,33 @@ void WrappedID3D12Device::CopyDescriptorsSimple(UINT NumDescriptors,
                                                D3D12_CPU_DESCRIPTOR_HANDLE SrcDescriptorRangeStart,
                                                D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapsType)
 {
+  return m_pDevice->CopyDescriptorsSimple(NumDescriptors, DestDescriptorRangeStart,
+                                          SrcDescriptorRangeStart, DescriptorHeapsType);
 }

 HRESULT WrappedID3D12Device::OpenSharedHandle(HANDLE NTHandle, REFIID riid, void **ppvObj)
 {
-  return E_NOTIMPL;
+  return m_pDevice->OpenSharedHandle(NTHandle, riid, ppvObj);
 }

 HRESULT WrappedID3D12Device::OpenSharedHandleByName(LPCWSTR Name, DWORD Access, HANDLE *pNTHandle)
 {
-  return E_NOTIMPL;
+  return m_pDevice->OpenSharedHandleByName(Name, Access, pNTHandle);
 }

 HRESULT WrappedID3D12Device::MakeResident(UINT NumObjects, ID3D12Pageable *const *ppObjects)
 {
-  return E_NOTIMPL;
+  return m_pDevice->MakeResident(NumObjects, ppObjects);
 }

 HRESULT WrappedID3D12Device::Evict(UINT NumObjects, ID3D12Pageable *const *ppObjects)
 {
-  return E_NOTIMPL;
+  return m_pDevice->Evict(NumObjects, ppObjects);
 }

-// we don't need to wrap any of these
+//////////////////////////////////////////////////////////////////////
+// we don't need to wrap any of these functions below
+
 HRESULT WrappedID3D12Device::GetPrivateData(REFGUID guid, UINT *pDataSize, void *pData)
 {
  return m_pDevice->GetPrivateData(guid, pDataSize, pData);