ShuriZma
/
RetroArch
mirror of https://github.com/libretro/RetroArch.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

(D3D12) Get rid of the small inline wrapper functions

This commit is contained in:
libretroadmin 2023-04-24 18:11:26 +02:00
parent 6a97eb91cf
commit dcefb6e028
5 changed files with 236 additions and 591 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

52
gfx/common/d3d12_common.c
View File

@ -163,9 +163,9 @@ d3d12_create_buffer(D3D12Device device, UINT size_in_bytes, D3D12Resource* buffe
resource_desc.SampleDesc.Count = 1; resource_desc.SampleDesc.Count = 1;
resource_desc.Layout = D3D12_TEXTURE_LAYOUT_ROW_MAJOR; resource_desc.Layout = D3D12_TEXTURE_LAYOUT_ROW_MAJOR;
D3D12CreateCommittedResource( device->lpVtbl->CreateCommittedResource(
device, (D3D12_HEAP_PROPERTIES*)&heap_props, D3D12_HEAP_FLAG_NONE, &resource_desc, device, (D3D12_HEAP_PROPERTIES*)&heap_props, D3D12_HEAP_FLAG_NONE, &resource_desc,
D3D12_RESOURCE_STATE_GENERIC_READ, NULL, buffer); D3D12_RESOURCE_STATE_GENERIC_READ, NULL, uuidof(ID3D12Resource), (void**)buffer);
return D3D12GetGPUVirtualAddress(*buffer); return D3D12GetGPUVirtualAddress(*buffer);
} }
@ -221,7 +221,7 @@ static DXGI_FORMAT d3d12_get_closest_match(D3D12Device device, D3D12_FEATURE_DAT
while (*format != DXGI_FORMAT_UNKNOWN) while (*format != DXGI_FORMAT_UNKNOWN)
{ {
D3D12_FEATURE_DATA_FORMAT_SUPPORT format_support = { *format }; D3D12_FEATURE_DATA_FORMAT_SUPPORT format_support = { *format };
if (SUCCEEDED(D3D12CheckFeatureSupport( if (SUCCEEDED(device->lpVtbl->CheckFeatureSupport(
device, D3D12_FEATURE_FORMAT_SUPPORT, &format_support, sizeof(format_support))) && device, D3D12_FEATURE_FORMAT_SUPPORT, &format_support, sizeof(format_support))) &&
((format_support.Support1 & desired->Support1) == desired->Support1) && ((format_support.Support1 & desired->Support1) == desired->Support1) &&
((format_support.Support2 & desired->Support2) == desired->Support2)) ((format_support.Support2 & desired->Support2) == desired->Support2))
@ -274,9 +274,9 @@ void d3d12_init_texture(D3D12Device device, d3d12_texture_t* texture)
texture->desc.SampleDesc.Count = 1; texture->desc.SampleDesc.Count = 1;
texture->desc.Format = d3d12_get_closest_match(device, &format_support); texture->desc.Format = d3d12_get_closest_match(device, &format_support);
D3D12CreateCommittedResource( device->lpVtbl->CreateCommittedResource(
device, &heap_props, D3D12_HEAP_FLAG_NONE, &texture->desc, device, &heap_props, D3D12_HEAP_FLAG_NONE, &texture->desc,
D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE, NULL, &texture->handle); D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE, NULL, uuidof(ID3D12Resource), (void**)&texture->handle);
} }
{ {
@ -287,7 +287,7 @@ void d3d12_init_texture(D3D12Device device, d3d12_texture_t* texture)
desc.Texture2D.MipLevels = texture->desc.MipLevels; desc.Texture2D.MipLevels = texture->desc.MipLevels;
texture->cpu_descriptor[0] = d3d12_descriptor_heap_slot_alloc(texture->srv_heap); texture->cpu_descriptor[0] = d3d12_descriptor_heap_slot_alloc(texture->srv_heap);
D3D12CreateShaderResourceView(device, texture->handle, &desc, texture->cpu_descriptor[0]); device->lpVtbl->CreateShaderResourceView(device, texture->handle, &desc, texture->cpu_descriptor[0]);
texture->gpu_descriptor[0].ptr = texture->cpu_descriptor[0].ptr - texture->srv_heap->cpu.ptr + texture->gpu_descriptor[0].ptr = texture->cpu_descriptor[0].ptr - texture->srv_heap->cpu.ptr +
texture->srv_heap->gpu.ptr; texture->srv_heap->gpu.ptr;
} }
@ -300,23 +300,21 @@ void d3d12_init_texture(D3D12Device device, d3d12_texture_t* texture)
desc.Texture2D.MipSlice = i; desc.Texture2D.MipSlice = i;
texture->cpu_descriptor[i] = d3d12_descriptor_heap_slot_alloc(texture->srv_heap); texture->cpu_descriptor[i] = d3d12_descriptor_heap_slot_alloc(texture->srv_heap);
D3D12CreateUnorderedAccessView( device->lpVtbl->CreateUnorderedAccessView(
device, texture->handle, NULL, &desc, texture->cpu_descriptor[i]); device, (ID3D12Resource*)texture->handle, NULL, &desc, texture->cpu_descriptor[i]);
texture->gpu_descriptor[i].ptr = texture->cpu_descriptor[i].ptr - texture->srv_heap->cpu.ptr + texture->gpu_descriptor[i].ptr = texture->cpu_descriptor[i].ptr - texture->srv_heap->cpu.ptr +
texture->srv_heap->gpu.ptr; texture->srv_heap->gpu.ptr;
} }
if (texture->desc.Flags & D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET) if (texture->desc.Flags & D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET)
{ device->lpVtbl->CreateRenderTargetView(device, (ID3D12Resource*)texture->handle, NULL, texture->rt_view);
D3D12CreateRenderTargetView(device, texture->handle, NULL, texture->rt_view);
}
else else
{ {
D3D12_HEAP_PROPERTIES heap_props = { D3D12_HEAP_TYPE_UPLOAD, D3D12_CPU_PAGE_PROPERTY_UNKNOWN, D3D12_HEAP_PROPERTIES heap_props = { D3D12_HEAP_TYPE_UPLOAD, D3D12_CPU_PAGE_PROPERTY_UNKNOWN,
D3D12_MEMORY_POOL_UNKNOWN, 1, 1 }; D3D12_MEMORY_POOL_UNKNOWN, 1, 1 };
D3D12_RESOURCE_DESC buffer_desc = { D3D12_RESOURCE_DIMENSION_BUFFER }; D3D12_RESOURCE_DESC buffer_desc = { D3D12_RESOURCE_DIMENSION_BUFFER };
D3D12GetCopyableFootprints( device->lpVtbl->GetCopyableFootprints(
device, &texture->desc, 0, 1, 0, &texture->layout, &texture->num_rows, device, &texture->desc, 0, 1, 0, &texture->layout, &texture->num_rows,
&texture->row_size_in_bytes, &texture->total_bytes); &texture->row_size_in_bytes, &texture->total_bytes);
@ -327,9 +325,9 @@ void d3d12_init_texture(D3D12Device device, d3d12_texture_t* texture)
buffer_desc.SampleDesc.Count = 1; buffer_desc.SampleDesc.Count = 1;
buffer_desc.Layout = D3D12_TEXTURE_LAYOUT_ROW_MAJOR; buffer_desc.Layout = D3D12_TEXTURE_LAYOUT_ROW_MAJOR;
D3D12CreateCommittedResource( device->lpVtbl->CreateCommittedResource(
device, &heap_props, D3D12_HEAP_FLAG_NONE, &buffer_desc, device, &heap_props, D3D12_HEAP_FLAG_NONE, &buffer_desc,
D3D12_RESOURCE_STATE_GENERIC_READ, NULL, &texture->upload_buffer); D3D12_RESOURCE_STATE_GENERIC_READ, NULL, uuidof(ID3D12Resource), (void**)&texture->upload_buffer);
} }
texture->size_data.x = texture->desc.Width; texture->size_data.x = texture->desc.Width;
@ -385,7 +383,7 @@ void d3d12_upload_texture(D3D12GraphicsCommandList cmd,
D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE, D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE,
D3D12_RESOURCE_STATE_COPY_DEST); D3D12_RESOURCE_STATE_COPY_DEST);
D3D12CopyTextureRegion(cmd, &dst, 0, 0, 0, &src, NULL); cmd->lpVtbl->CopyTextureRegion(cmd, &dst, 0, 0, 0, &src, NULL);
D3D12_RESOURCE_TRANSITION( D3D12_RESOURCE_TRANSITION(
cmd, cmd,
@ -398,9 +396,9 @@ void d3d12_upload_texture(D3D12GraphicsCommandList cmd,
unsigned i; unsigned i;
d3d12_video_t* d3d12 = (d3d12_video_t*)userdata; d3d12_video_t* d3d12 = (d3d12_video_t*)userdata;
D3D12SetComputeRootSignature(cmd, d3d12->desc.cs_rootSignature); cmd->lpVtbl->SetComputeRootSignature(cmd, d3d12->desc.cs_rootSignature);
D3D12SetPipelineState(cmd, d3d12->mipmapgen_pipe); cmd->lpVtbl->SetPipelineState(cmd, (D3D12PipelineState)d3d12->mipmapgen_pipe);
D3D12SetComputeRootDescriptorTable(cmd, CS_ROOT_ID_TEXTURE_T, texture->gpu_descriptor[0]); cmd->lpVtbl->SetComputeRootDescriptorTable(cmd, CS_ROOT_ID_TEXTURE_T, texture->gpu_descriptor[0]);
for (i = 1; i < texture->desc.MipLevels; i++) for (i = 1; i < texture->desc.MipLevels; i++)
{ {
@ -418,18 +416,22 @@ void d3d12_upload_texture(D3D12GraphicsCommandList cmd,
barrier.Transition.StateBefore = D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE; barrier.Transition.StateBefore = D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE;
barrier.Transition.StateAfter = D3D12_RESOURCE_STATE_UNORDERED_ACCESS; barrier.Transition.StateAfter = D3D12_RESOURCE_STATE_UNORDERED_ACCESS;
barrier.Transition.Subresource = i; barrier.Transition.Subresource = i;
D3D12ResourceBarrier(cmd, 1, &barrier); cmd->lpVtbl->ResourceBarrier(cmd, 1, &barrier);
} }
D3D12SetComputeRootDescriptorTable(cmd, CS_ROOT_ID_UAV_T, texture->gpu_descriptor[i]); {
D3D12SetComputeRoot32BitConstants( UINT thread_group_count_x = (width + 0x7) >> 3;
cmd, CS_ROOT_ID_CONSTANTS, sizeof(cbuffer) / sizeof(uint32_t), &cbuffer, 0); UINT thread_group_count_y = (height + 0x7) >> 3;
D3D12Dispatch(cmd, (width + 0x7) >> 3, (height + 0x7) >> 3, 1); cmd->lpVtbl->SetComputeRootDescriptorTable(cmd, CS_ROOT_ID_UAV_T, texture->gpu_descriptor[i]);
cmd->lpVtbl->SetComputeRoot32BitConstants(
cmd, CS_ROOT_ID_CONSTANTS, sizeof(cbuffer) / sizeof(uint32_t), &cbuffer, 0);
cmd->lpVtbl->Dispatch(cmd, thread_group_count_x, thread_group_count_y, 1);
}
{ {
D3D12_RESOURCE_BARRIER barrier = { D3D12_RESOURCE_BARRIER_TYPE_UAV }; D3D12_RESOURCE_BARRIER barrier = { D3D12_RESOURCE_BARRIER_TYPE_UAV };
barrier.UAV.pResource = texture->handle; barrier.UAV.pResource = texture->handle;
D3D12ResourceBarrier(cmd, 1, &barrier); cmd->lpVtbl->ResourceBarrier(cmd, 1, &barrier);
} }
{ {
@ -438,7 +440,7 @@ void d3d12_upload_texture(D3D12GraphicsCommandList cmd,
barrier.Transition.StateBefore = D3D12_RESOURCE_STATE_UNORDERED_ACCESS; barrier.Transition.StateBefore = D3D12_RESOURCE_STATE_UNORDERED_ACCESS;
barrier.Transition.StateAfter = D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE; barrier.Transition.StateAfter = D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE;
barrier.Transition.Subresource = i; barrier.Transition.Subresource = i;
D3D12ResourceBarrier(cmd, 1, &barrier); cmd->lpVtbl->ResourceBarrier(cmd, 1, &barrier);
} }
} }
} }

389
gfx/common/d3d12_common.h
View File

@ -41,7 +41,7 @@
_barrier.Transition.StateBefore = state_before; \ _barrier.Transition.StateBefore = state_before; \
_barrier.Transition.StateAfter = state_after; \ _barrier.Transition.StateAfter = state_after; \
_barrier.Transition.Subresource = D3D12_RESOURCE_BARRIER_ALL_SUBRESOURCES; \ _barrier.Transition.Subresource = D3D12_RESOURCE_BARRIER_ALL_SUBRESOURCES; \
D3D12ResourceBarrier(cmd, 1, &_barrier); \ cmd->lpVtbl->ResourceBarrier(cmd, 1, &_barrier); \
} }
typedef const ID3D12PipelineState* D3D12PipelineStateRef; typedef const ID3D12PipelineState* D3D12PipelineStateRef;
@ -358,402 +358,19 @@ D3D12Map(void* resource, UINT subresource, D3D12_RANGE* read_range, void** data)
return ((ID3D12Resource*)resource) return ((ID3D12Resource*)resource)
->lpVtbl->Map((ID3D12Resource*)resource, subresource, read_range, data); ->lpVtbl->Map((ID3D12Resource*)resource, subresource, read_range, data);
} }
static INLINE void D3D12Unmap(void* resource, UINT subresource, D3D12_RANGE* written_range) static INLINE void D3D12Unmap(void* resource, UINT subresource, D3D12_RANGE* written_range)
{ {
((ID3D12Resource*)resource) ((ID3D12Resource*)resource)
->lpVtbl->Unmap((ID3D12Resource*)resource, subresource, written_range); ->lpVtbl->Unmap((ID3D12Resource*)resource, subresource, written_range);
} }
static INLINE D3D12_GPU_VIRTUAL_ADDRESS D3D12GetGPUVirtualAddress(void* resource) static INLINE D3D12_GPU_VIRTUAL_ADDRESS D3D12GetGPUVirtualAddress(void* resource)
{ {
return ((ID3D12Resource*)resource)->lpVtbl->GetGPUVirtualAddress((ID3D12Resource*)resource); return ((ID3D12Resource*)resource)->lpVtbl->GetGPUVirtualAddress((ID3D12Resource*)resource);
} }
static INLINE HRESULT D3D12ResetCommandAllocator(D3D12CommandAllocator command_allocator)
{
return command_allocator->lpVtbl->Reset(command_allocator);
}
static INLINE ULONG D3D12ReleaseFence(D3D12Fence fence) { return fence->lpVtbl->Release(fence); }
static INLINE UINT64 D3D12GetCompletedValue(D3D12Fence fence)
{
return fence->lpVtbl->GetCompletedValue(fence);
}
static INLINE HRESULT D3D12SetEventOnCompletion(D3D12Fence fence, UINT64 value, HANDLE h_event)
{
return fence->lpVtbl->SetEventOnCompletion(fence, value, h_event);
}
static INLINE HRESULT D3D12CloseGraphicsCommandList(D3D12GraphicsCommandList graphics_command_list)
{
return graphics_command_list->lpVtbl->Close(graphics_command_list);
}
static INLINE HRESULT D3D12ResetGraphicsCommandList(
D3D12GraphicsCommandList graphics_command_list,
D3D12CommandAllocator allocator,
D3D12PipelineState initial_state)
{
return graphics_command_list->lpVtbl->Reset(graphics_command_list, allocator, initial_state);
}
static INLINE void D3D12DrawInstanced(
D3D12GraphicsCommandList graphics_command_list,
UINT vertex_count_per_instance,
UINT instance_count,
UINT start_vertex_location,
UINT start_instance_location)
{
graphics_command_list->lpVtbl->DrawInstanced(
graphics_command_list, vertex_count_per_instance, instance_count, start_vertex_location,
start_instance_location);
}
static INLINE void D3D12Dispatch(
D3D12GraphicsCommandList graphics_command_list,
UINT thread_group_count_x,
UINT thread_group_count_y,
UINT thread_group_count_z)
{
graphics_command_list->lpVtbl->Dispatch(
graphics_command_list, thread_group_count_x, thread_group_count_y, thread_group_count_z);
}
static INLINE void D3D12CopyTextureRegion(
D3D12GraphicsCommandList graphics_command_list,
D3D12_TEXTURE_COPY_LOCATION* dst,
UINT dst_x,
UINT dst_y,
UINT dst_z,
D3D12_TEXTURE_COPY_LOCATION* src,
D3D12_BOX* src_box)
{
graphics_command_list->lpVtbl->CopyTextureRegion(
graphics_command_list, dst, dst_x, dst_y, dst_z, src, src_box);
}
static INLINE void D3D12IASetPrimitiveTopology(
D3D12GraphicsCommandList graphics_command_list, D3D12_PRIMITIVE_TOPOLOGY primitive_topology)
{
graphics_command_list->lpVtbl->IASetPrimitiveTopology(graphics_command_list, primitive_topology);
}
static INLINE void D3D12RSSetViewports(
D3D12GraphicsCommandList graphics_command_list, UINT num_viewports, D3D12_VIEWPORT* viewports)
{
graphics_command_list->lpVtbl->RSSetViewports(graphics_command_list, num_viewports, viewports);
}
static INLINE void D3D12RSSetScissorRects(
D3D12GraphicsCommandList graphics_command_list, UINT num_rects, D3D12_RECT* rects)
{
graphics_command_list->lpVtbl->RSSetScissorRects(graphics_command_list, num_rects, rects);
}
static INLINE void D3D12SetPipelineState(
D3D12GraphicsCommandList graphics_command_list, D3D12PipelineStateRef pipeline_state)
{
graphics_command_list->lpVtbl->SetPipelineState(graphics_command_list, (D3D12PipelineState)pipeline_state);
}
static INLINE void D3D12ResourceBarrier(
D3D12GraphicsCommandList graphics_command_list,
UINT num_barriers,
D3D12_RESOURCE_BARRIER* barriers)
{
graphics_command_list->lpVtbl->ResourceBarrier(graphics_command_list, num_barriers, barriers);
}
static INLINE void D3D12SetComputeRootSignature(
D3D12GraphicsCommandList graphics_command_list, D3D12RootSignature root_signature)
{
graphics_command_list->lpVtbl->SetComputeRootSignature(graphics_command_list, root_signature);
}
static INLINE void D3D12SetGraphicsRootSignature(
D3D12GraphicsCommandList graphics_command_list, D3D12RootSignature root_signature)
{
graphics_command_list->lpVtbl->SetGraphicsRootSignature(graphics_command_list, root_signature);
}
static INLINE void D3D12SetComputeRootDescriptorTable(
D3D12GraphicsCommandList graphics_command_list,
UINT root_parameter_index,
D3D12_GPU_DESCRIPTOR_HANDLE base_descriptor)
{
graphics_command_list->lpVtbl->SetComputeRootDescriptorTable(
graphics_command_list, root_parameter_index, base_descriptor);
}
static INLINE void D3D12SetGraphicsRootDescriptorTable(
D3D12GraphicsCommandList graphics_command_list,
UINT root_parameter_index,
D3D12_GPU_DESCRIPTOR_HANDLE base_descriptor)
{
graphics_command_list->lpVtbl->SetGraphicsRootDescriptorTable(
graphics_command_list, root_parameter_index, base_descriptor);
}
static INLINE void D3D12SetComputeRoot32BitConstants(
D3D12GraphicsCommandList graphics_command_list,
UINT root_parameter_index,
UINT num32_bit_values_to_set,
void* src_data,
UINT dest_offset_in32_bit_values)
{
graphics_command_list->lpVtbl->SetComputeRoot32BitConstants(
graphics_command_list, root_parameter_index, num32_bit_values_to_set, src_data,
dest_offset_in32_bit_values);
}
static INLINE void D3D12SetComputeRootConstantBufferView(
D3D12GraphicsCommandList graphics_command_list,
UINT root_parameter_index,
D3D12_GPU_VIRTUAL_ADDRESS buffer_location)
{
graphics_command_list->lpVtbl->SetComputeRootConstantBufferView(
graphics_command_list, root_parameter_index, buffer_location);
}
static INLINE void D3D12SetGraphicsRootConstantBufferView(
D3D12GraphicsCommandList graphics_command_list,
UINT root_parameter_index,
D3D12_GPU_VIRTUAL_ADDRESS buffer_location)
{
graphics_command_list->lpVtbl->SetGraphicsRootConstantBufferView(
graphics_command_list, root_parameter_index, buffer_location);
}
static INLINE void D3D12IASetVertexBuffers(
D3D12GraphicsCommandList graphics_command_list,
UINT start_slot,
UINT num_views,
D3D12_VERTEX_BUFFER_VIEW* views)
{
graphics_command_list->lpVtbl->IASetVertexBuffers(
graphics_command_list, start_slot, num_views, views);
}
static INLINE void D3D12OMSetRenderTargets(
D3D12GraphicsCommandList graphics_command_list,
UINT num_render_target_descriptors,
D3D12_CPU_DESCRIPTOR_HANDLE* render_target_descriptors,
BOOL r_ts_single_handle_to_descriptor_range,
D3D12_CPU_DESCRIPTOR_HANDLE* depth_stencil_descriptor)
{
graphics_command_list->lpVtbl->OMSetRenderTargets(
graphics_command_list, num_render_target_descriptors, render_target_descriptors,
r_ts_single_handle_to_descriptor_range, depth_stencil_descriptor);
}
static INLINE HRESULT
D3D12SignalCommandQueue(D3D12CommandQueue command_queue, D3D12Fence fence, UINT64 value)
{
return command_queue->lpVtbl->Signal(command_queue, fence, value);
}
static INLINE HRESULT D3D12CreateCommandQueue(
D3D12Device device, D3D12_COMMAND_QUEUE_DESC* desc, ID3D12CommandQueue** out)
{
return device->lpVtbl->CreateCommandQueue(device, desc, uuidof(ID3D12CommandQueue), (void**)out);
}
static INLINE HRESULT D3D12CreateCommandAllocator(
D3D12Device device, D3D12_COMMAND_LIST_TYPE type, ID3D12CommandAllocator** out)
{
return device->lpVtbl->CreateCommandAllocator(
device, type, uuidof(ID3D12CommandAllocator), (void**)out);
}
static INLINE HRESULT D3D12CreateGraphicsPipelineState(
D3D12Device device, D3D12_GRAPHICS_PIPELINE_STATE_DESC* desc, ID3D12PipelineState** out)
{
return device->lpVtbl->CreateGraphicsPipelineState(
device, desc, uuidof(ID3D12PipelineState), (void**)out);
}
static INLINE HRESULT D3D12CreateComputePipelineState(
D3D12Device device, D3D12_COMPUTE_PIPELINE_STATE_DESC* desc, ID3D12PipelineState** out)
{
return device->lpVtbl->CreateComputePipelineState(
device, desc, uuidof(ID3D12PipelineState), (void**)out);
}
static INLINE HRESULT D3D12CheckFeatureSupport(
D3D12Device device,
D3D12_FEATURE feature,
void* feature_support_data,
UINT feature_support_data_size)
{
return device->lpVtbl->CheckFeatureSupport(
device, feature, feature_support_data, feature_support_data_size);
}
static INLINE HRESULT D3D12CreateDescriptorHeap(
D3D12Device device,
D3D12_DESCRIPTOR_HEAP_DESC* descriptor_heap_desc,
D3D12DescriptorHeap* out)
{
return device->lpVtbl->CreateDescriptorHeap(
device, descriptor_heap_desc, uuidof(ID3D12DescriptorHeap), (void**)out);
}
static INLINE UINT D3D12GetDescriptorHandleIncrementSize(
D3D12Device device, D3D12_DESCRIPTOR_HEAP_TYPE descriptor_heap_type)
{
return device->lpVtbl->GetDescriptorHandleIncrementSize(device, descriptor_heap_type);
}
static INLINE HRESULT D3D12CreateRootSignature(
D3D12Device device,
UINT node_mask,
void* blob_with_root_signature,
SIZE_T blob_length_in_bytes,
ID3D12RootSignature** out)
{
return device->lpVtbl->CreateRootSignature(
device, node_mask, blob_with_root_signature, blob_length_in_bytes,
uuidof(ID3D12RootSignature), (void**)out);
}
static INLINE void D3D12CreateShaderResourceView(
D3D12Device device,
D3D12Resource resource,
D3D12_SHADER_RESOURCE_VIEW_DESC* desc,
D3D12_CPU_DESCRIPTOR_HANDLE dest_descriptor)
{
device->lpVtbl->CreateShaderResourceView(device, resource, desc, dest_descriptor);
}
static INLINE void D3D12CreateUnorderedAccessView(
D3D12Device device,
void* resource,
void* counter_resource,
D3D12_UNORDERED_ACCESS_VIEW_DESC* desc,
D3D12_CPU_DESCRIPTOR_HANDLE dest_descriptor)
{
device->lpVtbl->CreateUnorderedAccessView(
device, (ID3D12Resource*)resource, (ID3D12Resource*)counter_resource, desc,
dest_descriptor);
}
static INLINE void D3D12CreateRenderTargetView(
D3D12Device device,
void* resource,
D3D12_RENDER_TARGET_VIEW_DESC* desc,
D3D12_CPU_DESCRIPTOR_HANDLE dest_descriptor)
{
device->lpVtbl->CreateRenderTargetView(device, (ID3D12Resource*)resource, desc, dest_descriptor);
}
static INLINE void D3D12CreateDepthStencilView(
D3D12Device device,
void* resource,
D3D12_DEPTH_STENCIL_VIEW_DESC* desc,
D3D12_CPU_DESCRIPTOR_HANDLE dest_descriptor)
{
device->lpVtbl->CreateDepthStencilView(device, (ID3D12Resource*)resource, desc, dest_descriptor);
}
static INLINE void D3D12CreateSampler(
D3D12Device device, D3D12_SAMPLER_DESC* desc, D3D12_CPU_DESCRIPTOR_HANDLE dest_descriptor)
{
device->lpVtbl->CreateSampler(device, desc, dest_descriptor);
}
static INLINE HRESULT D3D12CreateCommittedResource(
D3D12Device device,
D3D12_HEAP_PROPERTIES* heap_properties,
D3D12_HEAP_FLAGS heap_flags,
D3D12_RESOURCE_DESC* desc,
D3D12_RESOURCE_STATES initial_resource_state,
D3D12_CLEAR_VALUE* optimized_clear_value,
ID3D12Resource** out)
{
return device->lpVtbl->CreateCommittedResource(
device, heap_properties, heap_flags, desc, initial_resource_state, optimized_clear_value,
uuidof(ID3D12Resource), (void**)out);
}
static INLINE HRESULT D3D12CreateFence(
D3D12Device device, UINT64 initial_value, D3D12_FENCE_FLAGS flags, ID3D12Fence** out)
{
return device->lpVtbl->CreateFence(
device, initial_value, flags, uuidof(ID3D12Fence), (void**)out);
}
static INLINE void D3D12GetCopyableFootprints(
D3D12Device device,
D3D12_RESOURCE_DESC* resource_desc,
UINT first_subresource,
UINT num_subresources,
UINT64 base_offset,
D3D12_PLACED_SUBRESOURCE_FOOTPRINT* layouts,
UINT* num_rows,
UINT64* row_size_in_bytes,
UINT64* total_bytes)
{
device->lpVtbl->GetCopyableFootprints(
device, resource_desc, first_subresource, num_subresources, base_offset, layouts, num_rows,
row_size_in_bytes, total_bytes);
}
/* end of auto-generated */ /* end of auto-generated */
#ifdef DEBUG
static INLINE HRESULT D3D12GetDebugInterface_(D3D12Debug* out)
{
return D3D12GetDebugInterface(uuidof(ID3D12Debug), (void**)out);
}
#endif
static INLINE HRESULT
D3D12CreateDevice_(DXGIAdapter adapter, D3D_FEATURE_LEVEL MinimumFeatureLevel, D3D12Device* out)
{
return D3D12CreateDevice(
(IUnknown*)adapter, MinimumFeatureLevel, uuidof(ID3D12Device), (void**)out);
}
static INLINE HRESULT D3D12CreateGraphicsCommandList(
D3D12Device device,
UINT node_mask,
D3D12_COMMAND_LIST_TYPE type,
D3D12CommandAllocator command_allocator,
D3D12PipelineState initial_state,
D3D12GraphicsCommandList* out)
{
return device->lpVtbl->CreateCommandList(
device, node_mask, type, command_allocator, initial_state,
uuidof(ID3D12GraphicsCommandList), (void**)out);
}
static INLINE void D3D12ClearRenderTargetView(
D3D12GraphicsCommandList command_list,
D3D12_CPU_DESCRIPTOR_HANDLE render_target_view,
const FLOAT colorRGBA[4],
UINT num_rects,
const D3D12_RECT* rects)
{
command_list->lpVtbl->ClearRenderTargetView(
command_list, render_target_view, colorRGBA, num_rects, rects);
}
static INLINE void D3D12ExecuteGraphicsCommandLists(
D3D12CommandQueue command_queue,
UINT num_command_lists,
const D3D12GraphicsCommandList* command_lists)
{
command_queue->lpVtbl->ExecuteCommandLists(
command_queue, num_command_lists, (ID3D12CommandList* const*)command_lists);
}
static INLINE HRESULT
DXGIGetSwapChainBuffer(DXGISwapChain swapchain, UINT buffer, D3D12Resource* surface)
{
return swapchain->lpVtbl->GetBuffer(swapchain, buffer, uuidof(ID3D12Resource), (void**)surface);
}
static INLINE void D3D12SetDescriptorHeaps(
D3D12GraphicsCommandList command_list,
UINT num_descriptor_heaps,
const D3D12DescriptorHeap* descriptor_heaps)
{
command_list->lpVtbl->SetDescriptorHeaps(command_list, num_descriptor_heaps, descriptor_heaps);
}
static INLINE D3D12_CPU_DESCRIPTOR_HANDLE static INLINE D3D12_CPU_DESCRIPTOR_HANDLE
D3D12GetCPUDescriptorHandleForHeapStart(D3D12DescriptorHeap descriptor_heap) D3D12GetCPUDescriptorHandleForHeapStart(D3D12DescriptorHeap descriptor_heap)

326
gfx/drivers/d3d12.c
View File

@ -94,16 +94,6 @@ static D3D12_RENDER_TARGET_BLEND_DESC d3d12_blend_disable_desc = {
/* Temporary workaround for d3d12 not being able to poll flags during init */ /* Temporary workaround for d3d12 not being able to poll flags during init */
static gfx_ctx_driver_t d3d12_fake_context; static gfx_ctx_driver_t d3d12_fake_context;
static void d3d12_gfx_sync(d3d12_video_t* d3d12)
{
if (D3D12GetCompletedValue(d3d12->queue.fence) < d3d12->queue.fenceValue)
{
D3D12SetEventOnCompletion(
d3d12->queue.fence, d3d12->queue.fenceValue, d3d12->queue.fenceEvent);
WaitForSingleObject(d3d12->queue.fenceEvent, INFINITE);
}
}
static uint32_t d3d12_get_flags(void *data) static uint32_t d3d12_get_flags(void *data)
{ {
uint32_t flags = 0; uint32_t flags = 0;
@ -209,7 +199,12 @@ static bool d3d12_overlay_load(void* data, const void* image_data, unsigned num_
if (!d3d12) if (!d3d12)
return false; return false;
d3d12_gfx_sync(d3d12); if (d3d12->queue.fence->lpVtbl->GetCompletedValue(d3d12->queue.fence) < d3d12->queue.fenceValue)
{
d3d12->queue.fence->lpVtbl->SetEventOnCompletion(
d3d12->queue.fence, d3d12->queue.fenceValue, d3d12->queue.fenceEvent);
WaitForSingleObject(d3d12->queue.fenceEvent, INFINITE);
}
d3d12_free_overlays(d3d12); d3d12_free_overlays(d3d12);
d3d12->overlays.count = num_images; d3d12->overlays.count = num_images;
d3d12->overlays.textures = (d3d12_texture_t*)calloc(num_images, sizeof(d3d12_texture_t)); d3d12->overlays.textures = (d3d12_texture_t*)calloc(num_images, sizeof(d3d12_texture_t));
@ -304,24 +299,24 @@ static void d3d12_render_overlay(d3d12_video_t *d3d12)
if (d3d12->flags & D3D12_ST_FLAG_OVERLAYS_FULLSCREEN) if (d3d12->flags & D3D12_ST_FLAG_OVERLAYS_FULLSCREEN)
{ {
D3D12RSSetViewports(d3d12->queue.cmd, 1, d3d12->queue.cmd->lpVtbl->RSSetViewports(d3d12->queue.cmd, 1,
&d3d12->chain.viewport); &d3d12->chain.viewport);
D3D12RSSetScissorRects(d3d12->queue.cmd, 1, d3d12->queue.cmd->lpVtbl->RSSetScissorRects(d3d12->queue.cmd, 1,
&d3d12->chain.scissorRect); &d3d12->chain.scissorRect);
} }
else else
{ {
D3D12RSSetViewports(d3d12->queue.cmd, 1, d3d12->queue.cmd->lpVtbl->RSSetViewports(d3d12->queue.cmd, 1,
&d3d12->frame.viewport); &d3d12->frame.viewport);
D3D12RSSetScissorRects(d3d12->queue.cmd, 1, d3d12->queue.cmd->lpVtbl->RSSetScissorRects(d3d12->queue.cmd, 1,
&d3d12->frame.scissorRect); &d3d12->frame.scissorRect);
} }
D3D12IASetVertexBuffers(d3d12->queue.cmd, 0, 1, d3d12->queue.cmd->lpVtbl->IASetVertexBuffers(d3d12->queue.cmd, 0, 1,
&d3d12->overlays.vbo_view); &d3d12->overlays.vbo_view);
D3D12SetPipelineState(d3d12->queue.cmd, d3d12->sprites.pipe_blend); d3d12->queue.cmd->lpVtbl->SetPipelineState(d3d12->queue.cmd, d3d12->sprites.pipe_blend);
D3D12SetGraphicsRootDescriptorTable( d3d12->queue.cmd->lpVtbl->SetGraphicsRootDescriptorTable(
d3d12->queue.cmd, ROOT_ID_SAMPLER_T, d3d12->queue.cmd, ROOT_ID_SAMPLER_T,
d3d12->samplers[RARCH_FILTER_UNSPEC][RARCH_WRAP_DEFAULT]); d3d12->samplers[RARCH_FILTER_UNSPEC][RARCH_WRAP_DEFAULT]);
@ -332,10 +327,10 @@ static void d3d12_render_overlay(d3d12_video_t *d3d12)
&d3d12->overlays.textures[i], &d3d12->overlays.textures[i],
d3d12); d3d12);
D3D12SetGraphicsRootDescriptorTable( d3d12->queue.cmd->lpVtbl->SetGraphicsRootDescriptorTable(
d3d12->queue.cmd, ROOT_ID_TEXTURE_T, d3d12->queue.cmd, ROOT_ID_TEXTURE_T,
d3d12->overlays.textures[i].gpu_descriptor[0]); d3d12->overlays.textures[i].gpu_descriptor[0]);
D3D12DrawInstanced(d3d12->queue.cmd, 1, 1, i, 0); d3d12->queue.cmd->lpVtbl->DrawInstanced(d3d12->queue.cmd, 1, 1, i, 0);
} }
} }
#endif #endif
@ -471,7 +466,12 @@ static void d3d12_gfx_set_rotation(void* data, unsigned rotation)
if (!d3d12) if (!d3d12)
return; return;
d3d12_gfx_sync(d3d12); if (d3d12->queue.fence->lpVtbl->GetCompletedValue(d3d12->queue.fence) < d3d12->queue.fenceValue)
{
d3d12->queue.fence->lpVtbl->SetEventOnCompletion(
d3d12->queue.fence, d3d12->queue.fenceValue, d3d12->queue.fenceEvent);
WaitForSingleObject(d3d12->queue.fenceEvent, INFINITE);
}
d3d12->frame.rotation = rotation; d3d12->frame.rotation = rotation;
radians = d3d12->frame.rotation * (M_PI / 2.0f); radians = d3d12->frame.rotation * (M_PI / 2.0f);
@ -620,7 +620,7 @@ static void d3d12_init_pipeline(
desc->NumRenderTargets = 1; desc->NumRenderTargets = 1;
desc->SampleDesc.Count = 1; desc->SampleDesc.Count = 1;
D3D12CreateGraphicsPipelineState(device, desc, out); device->lpVtbl->CreateGraphicsPipelineState(device, desc, uuidof(ID3D12PipelineState), (void**)out);
} }
static bool d3d12_gfx_set_shader(void* data, enum rarch_shader_type type, const char* path) static bool d3d12_gfx_set_shader(void* data, enum rarch_shader_type type, const char* path)
@ -633,7 +633,12 @@ static bool d3d12_gfx_set_shader(void* data, enum rarch_shader_type type, const
if (!d3d12) if (!d3d12)
return false; return false;
d3d12_gfx_sync(d3d12); if (d3d12->queue.fence->lpVtbl->GetCompletedValue(d3d12->queue.fence) < d3d12->queue.fenceValue)
{
d3d12->queue.fence->lpVtbl->SetEventOnCompletion(
d3d12->queue.fence, d3d12->queue.fenceValue, d3d12->queue.fenceEvent);
WaitForSingleObject(d3d12->queue.fenceEvent, INFINITE);
}
d3d12_free_shader_preset(d3d12); d3d12_free_shader_preset(d3d12);
if (string_is_empty(path)) if (string_is_empty(path))
@ -1122,7 +1127,8 @@ static bool d3d12_gfx_init_pipelines(d3d12_video_t* d3d12)
desc.CS.pShaderBytecode = cs_code->lpVtbl->GetBufferPointer(cs_code); desc.CS.pShaderBytecode = cs_code->lpVtbl->GetBufferPointer(cs_code);
desc.CS.BytecodeLength = cs_code->lpVtbl->GetBufferSize(cs_code); desc.CS.BytecodeLength = cs_code->lpVtbl->GetBufferSize(cs_code);
if (FAILED(D3D12CreateComputePipelineState(d3d12->device, &desc, &d3d12->mipmapgen_pipe))) if (FAILED(d3d12->device->lpVtbl->CreateComputePipelineState(d3d12->device, &desc,
uuidof(ID3D12PipelineState), (void**)&d3d12->mipmapgen_pipe)))
Release(cs_code); Release(cs_code);
cs_code = NULL; cs_code = NULL;
} }
@ -1145,7 +1151,12 @@ static void d3d12_gfx_free(void* data)
if (!d3d12) if (!d3d12)
return; return;
d3d12_gfx_sync(d3d12); if (d3d12->queue.fence->lpVtbl->GetCompletedValue(d3d12->queue.fence) < d3d12->queue.fenceValue)
{
d3d12->queue.fence->lpVtbl->SetEventOnCompletion(
d3d12->queue.fence, d3d12->queue.fenceValue, d3d12->queue.fenceEvent);
WaitForSingleObject(d3d12->queue.fenceEvent, INFINITE);
}
if (d3d12->flags & D3D12_ST_FLAG_WAITABLE_SWAPCHAINS) if (d3d12->flags & D3D12_ST_FLAG_WAITABLE_SWAPCHAINS)
CloseHandle(d3d12->chain.frameLatencyWaitableObject); CloseHandle(d3d12->chain.frameLatencyWaitableObject);
@ -1259,14 +1270,14 @@ static bool d3d12_init_swapchain(d3d12_video_t* d3d12,
d3d12->chain.formats[DXGI_SWAPCHAIN_BIT_DEPTH_16] = DXGI_FORMAT_R16G16B16A16_UNORM; d3d12->chain.formats[DXGI_SWAPCHAIN_BIT_DEPTH_16] = DXGI_FORMAT_R16G16B16A16_UNORM;
if (dxgi_check_display_hdr_support(d3d12->factory, hwnd)) if (dxgi_check_display_hdr_support(d3d12->factory, hwnd))
d3d12->flags |= D3D12_ST_FLAG_HDR_SUPPORT; d3d12->flags |= D3D12_ST_FLAG_HDR_SUPPORT;
else else
d3d12->flags &= ~D3D12_ST_FLAG_HDR_SUPPORT; d3d12->flags &= ~D3D12_ST_FLAG_HDR_SUPPORT;
if (!(d3d12->flags & D3D12_ST_FLAG_HDR_SUPPORT)) if (!(d3d12->flags & D3D12_ST_FLAG_HDR_SUPPORT))
d3d12->flags &= ~D3D12_ST_FLAG_HDR_ENABLE; d3d12->flags &= ~D3D12_ST_FLAG_HDR_ENABLE;
d3d12->chain.bit_depth = (d3d12->flags & D3D12_ST_FLAG_HDR_ENABLE) d3d12->chain.bit_depth = (d3d12->flags & D3D12_ST_FLAG_HDR_ENABLE)
? DXGI_SWAPCHAIN_BIT_DEPTH_10 : DXGI_SWAPCHAIN_BIT_DEPTH_8; ? DXGI_SWAPCHAIN_BIT_DEPTH_10 : DXGI_SWAPCHAIN_BIT_DEPTH_8;
#endif #endif
@ -1368,9 +1379,9 @@ static bool d3d12_init_swapchain(d3d12_video_t* d3d12,
for (i = 0; i < countof(d3d12->chain.renderTargets); i++) for (i = 0; i < countof(d3d12->chain.renderTargets); i++)
{ {
DXGIGetSwapChainBuffer(d3d12->chain.handle, i, &d3d12->chain.renderTargets[i]); d3d12->chain.handle->lpVtbl->GetBuffer(d3d12->chain.handle, i, uuidof(ID3D12Resource), (void**)&d3d12->chain.renderTargets[i]);
D3D12CreateRenderTargetView( d3d12->device->lpVtbl->CreateRenderTargetView(
d3d12->device, d3d12->chain.renderTargets[i], NULL, d3d12->chain.desc_handles[i]); d3d12->device, (ID3D12Resource*)d3d12->chain.renderTargets[i], NULL, d3d12->chain.desc_handles[i]);
} }
#ifdef HAVE_DXGI_HDR #ifdef HAVE_DXGI_HDR
@ -1409,10 +1420,10 @@ static void d3d12_init_base(d3d12_video_t* d3d12)
DXGIAdapter adapter = NULL; DXGIAdapter adapter = NULL;
#ifdef DEBUG #ifdef DEBUG
#ifdef __WINRT__ #ifdef __WINRT__
if (SUCCEEDED(D3D12GetDebugInterface_(&d3d12->debugController))) if (SUCCEEDED(D3D12GetDebugInterface(uuidof(ID3D12Debug), (void**)&d3d12->debugController)))
d3d12->debugController->lpVtbl->EnableDebugLayer(&d3d12->debugController); d3d12->debugController->lpVtbl->EnableDebugLayer(&d3d12->debugController);
#else #else
if (SUCCEEDED(D3D12GetDebugInterface_(&d3d12->debugController))) if (SUCCEEDED(D3D12GetDebugInterface(uuidof(ID3D12Debug), (void**)&d3d12->debugController)))
d3d12->debugController->lpVtbl->EnableDebugLayer(d3d12->debugController); d3d12->debugController->lpVtbl->EnableDebugLayer(d3d12->debugController);
#endif #endif
#endif #endif
@ -1485,7 +1496,7 @@ static void d3d12_init_base(d3d12_video_t* d3d12)
AddRef(d3d12->adapter); AddRef(d3d12->adapter);
} }
if (!SUCCEEDED(D3D12CreateDevice_(d3d12->adapter, D3D_FEATURE_LEVEL_11_0, &d3d12->device))) if (!SUCCEEDED(D3D12CreateDevice((IUnknown*)d3d12->adapter, D3D_FEATURE_LEVEL_11_0, uuidof(ID3D12Device), (void**)&d3d12->device)))
RARCH_WARN("[D3D12]: Could not create D3D12 device.\n"); RARCH_WARN("[D3D12]: Could not create D3D12 device.\n");
} }
@ -1527,10 +1538,10 @@ static inline void d3d12_release_descriptor_heap(d3d12_descriptor_heap_t* heap)
static void d3d12_init_descriptor_heap(D3D12Device device, d3d12_descriptor_heap_t* out) static void d3d12_init_descriptor_heap(D3D12Device device, d3d12_descriptor_heap_t* out)
{ {
D3D12CreateDescriptorHeap(device, &out->desc, &out->handle); device->lpVtbl->CreateDescriptorHeap(device, &out->desc, uuidof(ID3D12DescriptorHeap), (void**)&out->handle);
out->cpu = D3D12GetCPUDescriptorHandleForHeapStart(out->handle); out->cpu = D3D12GetCPUDescriptorHandleForHeapStart(out->handle);
out->gpu = D3D12GetGPUDescriptorHandleForHeapStart(out->handle); out->gpu = D3D12GetGPUDescriptorHandleForHeapStart(out->handle);
out->stride = D3D12GetDescriptorHandleIncrementSize(device, out->desc.Type); out->stride = device->lpVtbl->GetDescriptorHandleIncrementSize(device, out->desc.Type);
out->map = (bool*)calloc(out->desc.NumDescriptors, sizeof(bool)); out->map = (bool*)calloc(out->desc.NumDescriptors, sizeof(bool));
} }
@ -1548,11 +1559,12 @@ static bool d3d12_create_root_signature(
return false; return false;
} }
D3D12CreateRootSignature( device->lpVtbl->CreateRootSignature(
device, 0, device, 0,
signature->lpVtbl->GetBufferPointer(signature), signature->lpVtbl->GetBufferPointer(signature),
signature->lpVtbl->GetBufferSize(signature), signature->lpVtbl->GetBufferSize(signature),
out); uuidof(ID3D12RootSignature),
(void**)out);
Release(signature); Release(signature);
return true; return true;
@ -1563,14 +1575,14 @@ static void d3d12_init_descriptors(d3d12_video_t* d3d12)
{ {
int i, j; int i, j;
D3D12_ROOT_SIGNATURE_DESC desc; D3D12_ROOT_SIGNATURE_DESC desc;
D3D12_DESCRIPTOR_RANGE srv_tbl[1] = { { D3D12_DESCRIPTOR_RANGE_TYPE_SRV, 1 } };
D3D12_DESCRIPTOR_RANGE uav_tbl[1] = { { D3D12_DESCRIPTOR_RANGE_TYPE_UAV, 1 } };
D3D12_DESCRIPTOR_RANGE sampler_tbl[1] = { { D3D12_DESCRIPTOR_RANGE_TYPE_SAMPLER, 1 } };
D3D12_STATIC_SAMPLER_DESC static_sampler = { D3D12_FILTER_MIN_MAG_MIP_POINT };
D3D12_ROOT_PARAMETER root_params[ROOT_ID_MAX]; D3D12_ROOT_PARAMETER root_params[ROOT_ID_MAX];
D3D12_ROOT_PARAMETER cs_root_params[CS_ROOT_ID_MAX]; D3D12_ROOT_PARAMETER cs_root_params[CS_ROOT_ID_MAX];
D3D12_DESCRIPTOR_RANGE srv_tbl[1] = { { D3D12_DESCRIPTOR_RANGE_TYPE_SRV, 1 } };
D3D12_DESCRIPTOR_RANGE uav_tbl[1] = { { D3D12_DESCRIPTOR_RANGE_TYPE_UAV, 1 } };
D3D12_DESCRIPTOR_RANGE sampler_tbl[1] = { { D3D12_DESCRIPTOR_RANGE_TYPE_SAMPLER, 1 } };
D3D12_STATIC_SAMPLER_DESC static_sampler = { D3D12_FILTER_MIN_MAG_MIP_POINT };
root_params[ROOT_ID_TEXTURE_T].ParameterType = D3D12_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE; root_params[ROOT_ID_TEXTURE_T].ParameterType = D3D12_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE;
root_params[ROOT_ID_TEXTURE_T].DescriptorTable.NumDescriptorRanges = countof(srv_tbl); root_params[ROOT_ID_TEXTURE_T].DescriptorTable.NumDescriptorRanges = countof(srv_tbl);
root_params[ROOT_ID_TEXTURE_T].DescriptorTable.pDescriptorRanges = srv_tbl; root_params[ROOT_ID_TEXTURE_T].DescriptorTable.pDescriptorRanges = srv_tbl;
root_params[ROOT_ID_TEXTURE_T].ShaderVisibility = D3D12_SHADER_VISIBILITY_PIXEL; root_params[ROOT_ID_TEXTURE_T].ShaderVisibility = D3D12_SHADER_VISIBILITY_PIXEL;
@ -1585,10 +1597,10 @@ static void d3d12_init_descriptors(d3d12_video_t* d3d12)
root_params[ROOT_ID_UBO].Descriptor.ShaderRegister = 0; root_params[ROOT_ID_UBO].Descriptor.ShaderRegister = 0;
root_params[ROOT_ID_UBO].ShaderVisibility = D3D12_SHADER_VISIBILITY_ALL; root_params[ROOT_ID_UBO].ShaderVisibility = D3D12_SHADER_VISIBILITY_ALL;
root_params[ROOT_ID_PC].ParameterType = D3D12_ROOT_PARAMETER_TYPE_CBV; root_params[ROOT_ID_PC].ParameterType = D3D12_ROOT_PARAMETER_TYPE_CBV;
root_params[ROOT_ID_PC].Descriptor.RegisterSpace = 0; root_params[ROOT_ID_PC].Descriptor.RegisterSpace = 0;
root_params[ROOT_ID_PC].Descriptor.ShaderRegister = 1; root_params[ROOT_ID_PC].Descriptor.ShaderRegister = 1;
root_params[ROOT_ID_PC].ShaderVisibility = D3D12_SHADER_VISIBILITY_ALL; root_params[ROOT_ID_PC].ShaderVisibility = D3D12_SHADER_VISIBILITY_ALL;
desc.NumParameters = countof(root_params); desc.NumParameters = countof(root_params);
desc.pParameters = root_params; desc.pParameters = root_params;
@ -1626,11 +1638,12 @@ static void d3d12_init_descriptors(d3d12_video_t* d3d12)
desc.pParameters = cs_root_params; desc.pParameters = cs_root_params;
desc.NumStaticSamplers = 1; desc.NumStaticSamplers = 1;
desc.pStaticSamplers = &static_sampler; desc.pStaticSamplers = &static_sampler;
desc.Flags = D3D12_ROOT_SIGNATURE_FLAG_DENY_VERTEX_SHADER_ROOT_ACCESS | desc.Flags =
D3D12_ROOT_SIGNATURE_FLAG_DENY_HULL_SHADER_ROOT_ACCESS | D3D12_ROOT_SIGNATURE_FLAG_DENY_VERTEX_SHADER_ROOT_ACCESS
D3D12_ROOT_SIGNATURE_FLAG_DENY_DOMAIN_SHADER_ROOT_ACCESS | | D3D12_ROOT_SIGNATURE_FLAG_DENY_HULL_SHADER_ROOT_ACCESS
D3D12_ROOT_SIGNATURE_FLAG_DENY_GEOMETRY_SHADER_ROOT_ACCESS | | D3D12_ROOT_SIGNATURE_FLAG_DENY_DOMAIN_SHADER_ROOT_ACCESS
D3D12_ROOT_SIGNATURE_FLAG_DENY_PIXEL_SHADER_ROOT_ACCESS; | D3D12_ROOT_SIGNATURE_FLAG_DENY_GEOMETRY_SHADER_ROOT_ACCESS
| D3D12_ROOT_SIGNATURE_FLAG_DENY_PIXEL_SHADER_ROOT_ACCESS;
d3d12_create_root_signature(d3d12->device, &desc, &d3d12->desc.cs_rootSignature); d3d12_create_root_signature(d3d12->device, &desc, &d3d12->desc.cs_rootSignature);
@ -1644,28 +1657,26 @@ static void d3d12_init_descriptors(d3d12_video_t* d3d12)
d3d12->desc.srv_heap.desc.Flags = D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE; d3d12->desc.srv_heap.desc.Flags = D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE;
d3d12_init_descriptor_heap(d3d12->device, &d3d12->desc.srv_heap); d3d12_init_descriptor_heap(d3d12->device, &d3d12->desc.srv_heap);
d3d12->desc.sampler_heap.desc.Type = D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER; d3d12->desc.sampler_heap.desc.Type = D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER;
d3d12->desc.sampler_heap.desc.NumDescriptors = d3d12->desc.sampler_heap.desc.NumDescriptors =
SLANG_NUM_BINDINGS * GFX_MAX_SHADERS + 2 * RARCH_WRAP_MAX; SLANG_NUM_BINDINGS * GFX_MAX_SHADERS + 2 * RARCH_WRAP_MAX;
d3d12->desc.sampler_heap.desc.Flags = D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE; d3d12->desc.sampler_heap.desc.Flags = D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE;
d3d12_init_descriptor_heap(d3d12->device, &d3d12->desc.sampler_heap); d3d12_init_descriptor_heap(d3d12->device, &d3d12->desc.sampler_heap);
for (i = 0; i < countof(d3d12->chain.renderTargets); i++) for (i = 0; i < countof(d3d12->chain.renderTargets); i++)
{
d3d12->chain.desc_handles[i].ptr = d3d12->chain.desc_handles[i].ptr =
d3d12->desc.rtv_heap.cpu.ptr + i * d3d12->desc.rtv_heap.stride; d3d12->desc.rtv_heap.cpu.ptr + i * d3d12->desc.rtv_heap.stride;
}
for (i = 0; i < GFX_MAX_SHADERS; i++) for (i = 0; i < GFX_MAX_SHADERS; i++)
{ {
d3d12->pass[i].rt.rt_view.ptr = d3d12->pass[i].rt.rt_view.ptr =
d3d12->desc.rtv_heap.cpu.ptr + d3d12->desc.rtv_heap.cpu.ptr +
(countof(d3d12->chain.renderTargets) + (2 * i)) * d3d12->desc.rtv_heap.stride; (countof(d3d12->chain.renderTargets) + (2 * i)) * d3d12->desc.rtv_heap.stride;
d3d12->pass[i].feedback.rt_view.ptr = d3d12->pass[i].rt.rt_view.ptr + d3d12->desc.rtv_heap.stride; d3d12->pass[i].feedback.rt_view.ptr = d3d12->pass[i].rt.rt_view.ptr + d3d12->desc.rtv_heap.stride;
d3d12->pass[i].textures.ptr = d3d12_descriptor_heap_slot_alloc(&d3d12->desc.srv_heap).ptr - d3d12->pass[i].textures.ptr = d3d12_descriptor_heap_slot_alloc(&d3d12->desc.srv_heap).ptr -
d3d12->desc.srv_heap.cpu.ptr + d3d12->desc.srv_heap.gpu.ptr; d3d12->desc.srv_heap.cpu.ptr + d3d12->desc.srv_heap.gpu.ptr;
d3d12->pass[i].samplers.ptr = d3d12->pass[i].samplers.ptr =
d3d12_descriptor_heap_slot_alloc(&d3d12->desc.sampler_heap).ptr - d3d12_descriptor_heap_slot_alloc(&d3d12->desc.sampler_heap).ptr -
d3d12->desc.sampler_heap.cpu.ptr + d3d12->desc.sampler_heap.gpu.ptr; d3d12->desc.sampler_heap.cpu.ptr + d3d12->desc.sampler_heap.gpu.ptr;
@ -1684,7 +1695,7 @@ static INLINE D3D12_GPU_DESCRIPTOR_HANDLE
D3D12_CPU_DESCRIPTOR_HANDLE cpu_handle = d3d12_descriptor_heap_slot_alloc(heap); D3D12_CPU_DESCRIPTOR_HANDLE cpu_handle = d3d12_descriptor_heap_slot_alloc(heap);
gpu_handle.ptr = cpu_handle.ptr - heap->cpu.ptr + heap->gpu.ptr; gpu_handle.ptr = cpu_handle.ptr - heap->cpu.ptr + heap->gpu.ptr;
D3D12CreateSampler(device, desc, cpu_handle); device->lpVtbl->CreateSampler(device, desc, cpu_handle);
return gpu_handle; return gpu_handle;
} }
@ -1747,24 +1758,28 @@ static void d3d12_init_queue(d3d12_video_t* d3d12)
D3D12_COMMAND_QUEUE_FLAG_NONE, D3D12_COMMAND_QUEUE_FLAG_NONE,
0 0
}; };
D3D12CreateCommandQueue( d3d12->device->lpVtbl->CreateCommandQueue(
d3d12->device, d3d12->device,
(D3D12_COMMAND_QUEUE_DESC*)&desc, (D3D12_COMMAND_QUEUE_DESC*)&desc,
&d3d12->queue.handle); uuidof(ID3D12CommandQueue),
(void**)&d3d12->queue.handle);
} }
D3D12CreateCommandAllocator( d3d12->device->lpVtbl->CreateCommandAllocator(
d3d12->device, d3d12->device,
D3D12_COMMAND_LIST_TYPE_DIRECT, D3D12_COMMAND_LIST_TYPE_DIRECT,
&d3d12->queue.allocator); uuidof(ID3D12CommandAllocator),
(void**)&d3d12->queue.allocator);
D3D12CreateGraphicsCommandList( d3d12->device->lpVtbl->CreateCommandList(
d3d12->device, 0, D3D12_COMMAND_LIST_TYPE_DIRECT, d3d12->queue.allocator, d3d12->device, 0, D3D12_COMMAND_LIST_TYPE_DIRECT, d3d12->queue.allocator,
d3d12->pipes[VIDEO_SHADER_STOCK_BLEND], &d3d12->queue.cmd); d3d12->pipes[VIDEO_SHADER_STOCK_BLEND],
uuidof(ID3D12GraphicsCommandList),
(void**)&d3d12->queue.cmd);
D3D12CloseGraphicsCommandList(d3d12->queue.cmd); d3d12->queue.cmd->lpVtbl->Close(d3d12->queue.cmd);
d3d12->device->lpVtbl->CreateFence(d3d12->device, 0,
D3D12CreateFence(d3d12->device, 0, D3D12_FENCE_FLAG_NONE, &d3d12->queue.fence); D3D12_FENCE_FLAG_NONE, uuidof(ID3D12Fence), (void**)&d3d12->queue.fence);
d3d12->queue.fenceValue = 0; d3d12->queue.fenceValue = 0;
d3d12->queue.fenceEvent = CreateEvent(NULL, FALSE, FALSE, NULL); d3d12->queue.fenceEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
} }
@ -2200,7 +2215,12 @@ static bool d3d12_gfx_frame(
1000, 1000,
true); true);
d3d12_gfx_sync(d3d12); if (d3d12->queue.fence->lpVtbl->GetCompletedValue(d3d12->queue.fence) < d3d12->queue.fenceValue)
{
d3d12->queue.fence->lpVtbl->SetEventOnCompletion(
d3d12->queue.fence, d3d12->queue.fenceValue, d3d12->queue.fenceEvent);
WaitForSingleObject(d3d12->queue.fenceEvent, INFINITE);
}
#ifdef HAVE_DXGI_HDR #ifdef HAVE_DXGI_HDR
d3d12_hdr_enable = d3d12->flags & D3D12_ST_FLAG_HDR_ENABLE; d3d12_hdr_enable = d3d12->flags & D3D12_ST_FLAG_HDR_ENABLE;
@ -2249,10 +2269,10 @@ static bool d3d12_gfx_frame(
for (i = 0; i < countof(d3d12->chain.renderTargets); i++) for (i = 0; i < countof(d3d12->chain.renderTargets); i++)
{ {
DXGIGetSwapChainBuffer(d3d12->chain.handle, i, d3d12->chain.handle->lpVtbl->GetBuffer(d3d12->chain.handle, i,
&d3d12->chain.renderTargets[i]); uuidof(ID3D12Resource), (void**)&d3d12->chain.renderTargets[i]);
D3D12CreateRenderTargetView( d3d12->device->lpVtbl->CreateRenderTargetView(
d3d12->device, d3d12->chain.renderTargets[i], d3d12->device, (ID3D12Resource*)d3d12->chain.renderTargets[i],
NULL, d3d12->chain.desc_handles[i]); NULL, d3d12->chain.desc_handles[i]);
} }
@ -2333,16 +2353,17 @@ static bool d3d12_gfx_frame(
#endif #endif
} }
D3D12ResetCommandAllocator(d3d12->queue.allocator); d3d12->queue.allocator->lpVtbl->Reset(d3d12->queue.allocator);
D3D12ResetGraphicsCommandList( d3d12->queue.cmd->lpVtbl->Reset(
d3d12->queue.cmd, d3d12->queue.allocator, d3d12->queue.cmd, d3d12->queue.allocator,
d3d12->pipes[VIDEO_SHADER_STOCK_BLEND]); d3d12->pipes[VIDEO_SHADER_STOCK_BLEND]);
{ {
D3D12DescriptorHeap desc_heaps[] = { d3d12->desc.srv_heap.handle, D3D12DescriptorHeap desc_heaps[] = { d3d12->desc.srv_heap.handle,
d3d12->desc.sampler_heap.handle }; d3d12->desc.sampler_heap.handle };
D3D12SetDescriptorHeaps(d3d12->queue.cmd,
d3d12->queue.cmd->lpVtbl->SetDescriptorHeaps(d3d12->queue.cmd,
countof(desc_heaps), desc_heaps); countof(desc_heaps), desc_heaps);
} }
@ -2352,7 +2373,7 @@ static bool d3d12_gfx_frame(
#endif #endif
d3d12_update_viewport(d3d12, false); d3d12_update_viewport(d3d12, false);
D3D12IASetPrimitiveTopology(d3d12->queue.cmd, d3d12->queue.cmd->lpVtbl->IASetPrimitiveTopology(d3d12->queue.cmd,
D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP); D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP);
if (frame && width && height) if (frame && width && height)
@ -2452,7 +2473,8 @@ static bool d3d12_gfx_frame(
D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE, D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE,
D3D12_RESOURCE_STATE_COPY_DEST); D3D12_RESOURCE_STATE_COPY_DEST);
D3D12CopyTextureRegion(d3d12->queue.cmd, &dst, 0, 0, 0, &src, &src_box); d3d12->queue.cmd->lpVtbl->CopyTextureRegion(
d3d12->queue.cmd, &dst, 0, 0, 0, &src, &src_box);
D3D12_RESOURCE_TRANSITION( D3D12_RESOURCE_TRANSITION(
d3d12->queue.cmd, d3d12->queue.cmd,
@ -2472,13 +2494,13 @@ static bool d3d12_gfx_frame(
} }
} }
D3D12IASetVertexBuffers(d3d12->queue.cmd, 0, 1, &d3d12->frame.vbo_view); d3d12->queue.cmd->lpVtbl->IASetVertexBuffers(d3d12->queue.cmd, 0, 1, &d3d12->frame.vbo_view);
texture = d3d12->frame.texture; texture = d3d12->frame.texture;
if (d3d12->shader_preset) if (d3d12->shader_preset)
{ {
D3D12SetGraphicsRootSignature(d3d12->queue.cmd, d3d12->queue.cmd->lpVtbl->SetGraphicsRootSignature(d3d12->queue.cmd,
d3d12->desc.sl_rootSignature); d3d12->desc.sl_rootSignature);
for (i = 0; i < d3d12->shader_preset->passes; i++) for (i = 0; i < d3d12->shader_preset->passes; i++)
@ -2495,7 +2517,7 @@ static bool d3d12_gfx_frame(
{ {
unsigned j; unsigned j;
D3D12SetPipelineState(d3d12->queue.cmd, d3d12->pass[i].pipe); d3d12->queue.cmd->lpVtbl->SetPipelineState(d3d12->queue.cmd, d3d12->pass[i].pipe);
if (d3d12->shader_preset->pass[i].frame_count_mod) if (d3d12->shader_preset->pass[i].frame_count_mod)
d3d12->pass[i].frame_count = frame_count d3d12->pass[i].frame_count = frame_count
@ -2536,7 +2558,7 @@ static bool d3d12_gfx_frame(
} }
D3D12Unmap(d3d12->pass[i].buffers[j], 0, NULL); D3D12Unmap(d3d12->pass[i].buffers[j], 0, NULL);
D3D12SetGraphicsRootConstantBufferView( d3d12->queue.cmd->lpVtbl->SetGraphicsRootConstantBufferView(
d3d12->queue.cmd, j == SLANG_CBUFFER_UBO d3d12->queue.cmd, j == SLANG_CBUFFER_UBO
? ROOT_ID_UBO ? ROOT_ID_UBO
: ROOT_ID_PC, : ROOT_ID_PC,
@ -2544,7 +2566,7 @@ static bool d3d12_gfx_frame(
} }
} }
#if 0 #if 0
D3D12OMSetRenderTargets(d3d12->queue.cmd, 1, NULL, FALSE, NULL); d3d12->queue.cmd->lpVtbl->OMSetRenderTargets(d3d12->queue.cmd, 1, NULL, FALSE, NULL);
#endif #endif
{ {
@ -2568,7 +2590,7 @@ static bool d3d12_gfx_frame(
D3D12_SRV_DIMENSION_TEXTURE2D; D3D12_SRV_DIMENSION_TEXTURE2D;
desc.Texture2D.MipLevels = tex->desc.MipLevels; desc.Texture2D.MipLevels = tex->desc.MipLevels;
D3D12CreateShaderResourceView(d3d12->device, d3d12->device->lpVtbl->CreateShaderResourceView(d3d12->device,
tex->handle, &desc, handle); tex->handle, &desc, handle);
} }
@ -2612,45 +2634,45 @@ static bool d3d12_gfx_frame(
desc.MinLOD = -D3D12_FLOAT32_MAX; desc.MinLOD = -D3D12_FLOAT32_MAX;
desc.MaxLOD = D3D12_FLOAT32_MAX; desc.MaxLOD = D3D12_FLOAT32_MAX;
D3D12CreateSampler(d3d12->device, &desc, handle); d3d12->device->lpVtbl->CreateSampler(d3d12->device, &desc, handle);
} }
texture_sem++; texture_sem++;
} }
D3D12SetGraphicsRootDescriptorTable( d3d12->queue.cmd->lpVtbl->SetGraphicsRootDescriptorTable(
d3d12->queue.cmd, ROOT_ID_TEXTURE_T, d3d12->queue.cmd, ROOT_ID_TEXTURE_T,
d3d12->pass[i].textures); d3d12->pass[i].textures);
D3D12SetGraphicsRootDescriptorTable( d3d12->queue.cmd->lpVtbl->SetGraphicsRootDescriptorTable(
d3d12->queue.cmd, ROOT_ID_SAMPLER_T, d3d12->queue.cmd, ROOT_ID_SAMPLER_T,
d3d12->pass[i].samplers); d3d12->pass[i].samplers);
} }
if (d3d12->pass[i].rt.handle) if (d3d12->pass[i].rt.handle)
{ {
UINT start_vertex_location = 4;
D3D12_RESOURCE_TRANSITION( D3D12_RESOURCE_TRANSITION(
d3d12->queue.cmd, d3d12->queue.cmd,
d3d12->pass[i].rt.handle, d3d12->pass[i].rt.handle,
D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE, D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE,
D3D12_RESOURCE_STATE_RENDER_TARGET); D3D12_RESOURCE_STATE_RENDER_TARGET);
D3D12OMSetRenderTargets(d3d12->queue.cmd, 1, d3d12->queue.cmd->lpVtbl->OMSetRenderTargets(d3d12->queue.cmd, 1,
&d3d12->pass[i].rt.rt_view, FALSE, NULL); &d3d12->pass[i].rt.rt_view, FALSE, NULL);
#if 0 #if 0
D3D12ClearRenderTargetView( d3d12->queue.cmd->lpVtbl->ClearRenderTargetView(
d3d12->queue.cmd, d3d12->pass[i].rt.rt_view, d3d12->queue.cmd, d3d12->pass[i].rt.rt_view,
d3d12->chain.clearcolor, 0, NULL); d3d12->chain.clearcolor, 0, NULL);
#endif #endif
D3D12RSSetViewports(d3d12->queue.cmd, 1, d3d12->queue.cmd->lpVtbl->RSSetViewports(d3d12->queue.cmd, 1,
&d3d12->pass[i].viewport); &d3d12->pass[i].viewport);
D3D12RSSetScissorRects(d3d12->queue.cmd, 1, d3d12->queue.cmd->lpVtbl->RSSetScissorRects(d3d12->queue.cmd, 1,
&d3d12->pass[i].scissorRect); &d3d12->pass[i].scissorRect);
if (i == d3d12->shader_preset->passes - 1) if (i == d3d12->shader_preset->passes - 1)
D3D12DrawInstanced(d3d12->queue.cmd, 4, 1, 0, 0); start_vertex_location = 0;
else
D3D12DrawInstanced(d3d12->queue.cmd, 4, 1, 4, 0);
d3d12->queue.cmd->lpVtbl->DrawInstanced(d3d12->queue.cmd, 4, 1, start_vertex_location, 0);
D3D12_RESOURCE_TRANSITION( D3D12_RESOURCE_TRANSITION(
d3d12->queue.cmd, d3d12->queue.cmd,
d3d12->pass[i].rt.handle, d3d12->pass[i].rt.handle,
@ -2668,17 +2690,17 @@ static bool d3d12_gfx_frame(
if (texture) if (texture)
{ {
D3D12SetPipelineState(d3d12->queue.cmd, d3d12->queue.cmd->lpVtbl->SetPipelineState(d3d12->queue.cmd,
d3d12->pipes[VIDEO_SHADER_STOCK_NOBLEND]); d3d12->pipes[VIDEO_SHADER_STOCK_NOBLEND]);
D3D12SetGraphicsRootSignature(d3d12->queue.cmd, d3d12->queue.cmd->lpVtbl->SetGraphicsRootSignature(d3d12->queue.cmd,
d3d12->desc.rootSignature); d3d12->desc.rootSignature);
D3D12SetGraphicsRootDescriptorTable(d3d12->queue.cmd, d3d12->queue.cmd->lpVtbl->SetGraphicsRootDescriptorTable(d3d12->queue.cmd,
ROOT_ID_TEXTURE_T, ROOT_ID_TEXTURE_T,
d3d12->frame.texture[0].gpu_descriptor[0]); d3d12->frame.texture[0].gpu_descriptor[0]);
D3D12SetGraphicsRootDescriptorTable(d3d12->queue.cmd, d3d12->queue.cmd->lpVtbl->SetGraphicsRootDescriptorTable(d3d12->queue.cmd,
ROOT_ID_SAMPLER_T, ROOT_ID_SAMPLER_T,
d3d12->samplers[RARCH_FILTER_UNSPEC][RARCH_WRAP_DEFAULT]); d3d12->samplers[RARCH_FILTER_UNSPEC][RARCH_WRAP_DEFAULT]);
D3D12SetGraphicsRootConstantBufferView( d3d12->queue.cmd->lpVtbl->SetGraphicsRootConstantBufferView(
d3d12->queue.cmd, ROOT_ID_UBO, d3d12->queue.cmd, ROOT_ID_UBO,
d3d12->frame.ubo_view.BufferLocation); d3d12->frame.ubo_view.BufferLocation);
} }
@ -2695,7 +2717,7 @@ static bool d3d12_gfx_frame(
D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE, D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE,
D3D12_RESOURCE_STATE_RENDER_TARGET); D3D12_RESOURCE_STATE_RENDER_TARGET);
D3D12OMSetRenderTargets( d3d12->queue.cmd->lpVtbl->OMSetRenderTargets(
d3d12->queue.cmd, 1, d3d12->queue.cmd, 1,
&d3d12->chain.back_buffer.rt_view, &d3d12->chain.back_buffer.rt_view,
FALSE, NULL); FALSE, NULL);
@ -2705,7 +2727,7 @@ static bool d3d12_gfx_frame(
* D3D12_RESOURCE_DIMENSION_BUFFER, yet we get spammed with this * D3D12_RESOURCE_DIMENSION_BUFFER, yet we get spammed with this
* warning * warning
*/ */
D3D12ClearRenderTargetView( d3d12->queue.cmd->lpVtbl->ClearRenderTargetView(
d3d12->queue.cmd, d3d12->queue.cmd,
d3d12->chain.back_buffer.rt_view, d3d12->chain.back_buffer.rt_view,
d3d12->chain.clearcolor, d3d12->chain.clearcolor,
@ -2720,25 +2742,25 @@ static bool d3d12_gfx_frame(
D3D12_RESOURCE_STATE_PRESENT, D3D12_RESOURCE_STATE_PRESENT,
D3D12_RESOURCE_STATE_RENDER_TARGET); D3D12_RESOURCE_STATE_RENDER_TARGET);
D3D12OMSetRenderTargets( d3d12->queue.cmd->lpVtbl->OMSetRenderTargets(
d3d12->queue.cmd, 1, d3d12->queue.cmd, 1,
&d3d12->chain.desc_handles[d3d12->chain.frame_index], &d3d12->chain.desc_handles[d3d12->chain.frame_index],
FALSE, NULL); FALSE, NULL);
D3D12ClearRenderTargetView( d3d12->queue.cmd->lpVtbl->ClearRenderTargetView(
d3d12->queue.cmd, d3d12->queue.cmd,
d3d12->chain.desc_handles[d3d12->chain.frame_index], d3d12->chain.desc_handles[d3d12->chain.frame_index],
d3d12->chain.clearcolor, d3d12->chain.clearcolor,
0, NULL); 0, NULL);
} }
D3D12RSSetViewports(d3d12->queue.cmd, 1, &d3d12->frame.viewport); d3d12->queue.cmd->lpVtbl->RSSetViewports(d3d12->queue.cmd, 1, &d3d12->frame.viewport);
D3D12RSSetScissorRects(d3d12->queue.cmd, 1, &d3d12->frame.scissorRect); d3d12->queue.cmd->lpVtbl->RSSetScissorRects(d3d12->queue.cmd, 1, &d3d12->frame.scissorRect);
D3D12DrawInstanced(d3d12->queue.cmd, 4, 1, 0, 0); d3d12->queue.cmd->lpVtbl->DrawInstanced(d3d12->queue.cmd, 4, 1, 0, 0);
D3D12SetPipelineState(d3d12->queue.cmd, d3d12->queue.cmd->lpVtbl->SetPipelineState(d3d12->queue.cmd,
d3d12->pipes[VIDEO_SHADER_STOCK_BLEND]); d3d12->pipes[VIDEO_SHADER_STOCK_BLEND]);
D3D12SetGraphicsRootSignature(d3d12->queue.cmd, d3d12->desc.rootSignature); d3d12->queue.cmd->lpVtbl->SetGraphicsRootSignature(d3d12->queue.cmd, d3d12->desc.rootSignature);
if ( (d3d12->flags & D3D12_ST_FLAG_MENU_ENABLE) if ( (d3d12->flags & D3D12_ST_FLAG_MENU_ENABLE)
&& d3d12->menu.texture.handle) && d3d12->menu.texture.handle)
@ -2747,28 +2769,28 @@ static bool d3d12_gfx_frame(
d3d12_upload_texture(d3d12->queue.cmd, &d3d12->menu.texture, d3d12_upload_texture(d3d12->queue.cmd, &d3d12->menu.texture,
d3d12); d3d12);
D3D12SetGraphicsRootConstantBufferView( d3d12->queue.cmd->lpVtbl->SetGraphicsRootConstantBufferView(
d3d12->queue.cmd, ROOT_ID_UBO, d3d12->ubo_view.BufferLocation); d3d12->queue.cmd, ROOT_ID_UBO, d3d12->ubo_view.BufferLocation);
if (d3d12->flags & D3D12_ST_FLAG_MENU_FULLSCREEN) if (d3d12->flags & D3D12_ST_FLAG_MENU_FULLSCREEN)
{ {
D3D12RSSetViewports(d3d12->queue.cmd, 1, &d3d12->chain.viewport); d3d12->queue.cmd->lpVtbl->RSSetViewports(d3d12->queue.cmd, 1, &d3d12->chain.viewport);
D3D12RSSetScissorRects(d3d12->queue.cmd, 1, &d3d12->chain.scissorRect); d3d12->queue.cmd->lpVtbl->RSSetScissorRects(d3d12->queue.cmd, 1, &d3d12->chain.scissorRect);
} }
D3D12SetGraphicsRootDescriptorTable(d3d12->queue.cmd, d3d12->queue.cmd->lpVtbl->SetGraphicsRootDescriptorTable(d3d12->queue.cmd,
ROOT_ID_TEXTURE_T, ROOT_ID_TEXTURE_T,
d3d12->menu.texture.gpu_descriptor[0]); d3d12->menu.texture.gpu_descriptor[0]);
D3D12SetGraphicsRootDescriptorTable(d3d12->queue.cmd, d3d12->queue.cmd->lpVtbl->SetGraphicsRootDescriptorTable(d3d12->queue.cmd,
ROOT_ID_SAMPLER_T, ROOT_ID_SAMPLER_T,
d3d12->menu.texture.sampler); d3d12->menu.texture.sampler);
D3D12IASetVertexBuffers(d3d12->queue.cmd, 0, 1, &d3d12->menu.vbo_view); d3d12->queue.cmd->lpVtbl->IASetVertexBuffers(d3d12->queue.cmd, 0, 1, &d3d12->menu.vbo_view);
D3D12DrawInstanced(d3d12->queue.cmd, 4, 1, 0, 0); d3d12->queue.cmd->lpVtbl->DrawInstanced(d3d12->queue.cmd, 4, 1, 0, 0);
} }
d3d12->sprites.pipe = d3d12->sprites.pipe_noblend; d3d12->sprites.pipe = d3d12->sprites.pipe_noblend;
D3D12SetPipelineState(d3d12->queue.cmd, d3d12->sprites.pipe); d3d12->queue.cmd->lpVtbl->SetPipelineState(d3d12->queue.cmd, (D3D12PipelineState)d3d12->sprites.pipe);
D3D12IASetPrimitiveTopology(d3d12->queue.cmd, d3d12->queue.cmd->lpVtbl->IASetPrimitiveTopology(d3d12->queue.cmd,
D3D_PRIMITIVE_TOPOLOGY_POINTLIST); D3D_PRIMITIVE_TOPOLOGY_POINTLIST);
d3d12->flags |= D3D12_ST_FLAG_SPRITES_ENABLE; d3d12->flags |= D3D12_ST_FLAG_SPRITES_ENABLE;
@ -2783,11 +2805,11 @@ static bool d3d12_gfx_frame(
if (d3d12->flags & D3D12_ST_FLAG_MENU_ENABLE) if (d3d12->flags & D3D12_ST_FLAG_MENU_ENABLE)
#endif #endif
{ {
D3D12RSSetViewports(d3d12->queue.cmd, 1, d3d12->queue.cmd->lpVtbl->RSSetViewports(d3d12->queue.cmd, 1,
&d3d12->chain.viewport); &d3d12->chain.viewport);
D3D12RSSetScissorRects(d3d12->queue.cmd, 1, d3d12->queue.cmd->lpVtbl->RSSetScissorRects(d3d12->queue.cmd, 1,
&d3d12->chain.scissorRect); &d3d12->chain.scissorRect);
D3D12IASetVertexBuffers(d3d12->queue.cmd, 0, 1, d3d12->queue.cmd->lpVtbl->IASetVertexBuffers(d3d12->queue.cmd, 0, 1,
&d3d12->sprites.vbo_view); &d3d12->sprites.vbo_view);
} }
#endif #endif
@ -2801,13 +2823,13 @@ static bool d3d12_gfx_frame(
{ {
if (osd_params) if (osd_params)
{ {
D3D12SetPipelineState(d3d12->queue.cmd, d3d12->queue.cmd->lpVtbl->SetPipelineState(d3d12->queue.cmd,
d3d12->sprites.pipe_blend); d3d12->sprites.pipe_blend);
D3D12RSSetViewports(d3d12->queue.cmd, 1, d3d12->queue.cmd->lpVtbl->RSSetViewports(d3d12->queue.cmd, 1,
&d3d12->chain.viewport); &d3d12->chain.viewport);
D3D12RSSetScissorRects(d3d12->queue.cmd, 1, d3d12->queue.cmd->lpVtbl->RSSetScissorRects(d3d12->queue.cmd, 1,
&d3d12->chain.scissorRect); &d3d12->chain.scissorRect);
D3D12IASetVertexBuffers(d3d12->queue.cmd, 0, 1, d3d12->queue.cmd->lpVtbl->IASetVertexBuffers(d3d12->queue.cmd, 0, 1,
&d3d12->sprites.vbo_view); &d3d12->sprites.vbo_view);
font_driver_render_msg(d3d12, stat_text, font_driver_render_msg(d3d12, stat_text,
(const struct font_params*)osd_params, NULL); (const struct font_params*)osd_params, NULL);
@ -2825,13 +2847,13 @@ static bool d3d12_gfx_frame(
if (msg && *msg) if (msg && *msg)
{ {
D3D12SetPipelineState(d3d12->queue.cmd, d3d12->queue.cmd->lpVtbl->SetPipelineState(d3d12->queue.cmd,
d3d12->sprites.pipe_blend); d3d12->sprites.pipe_blend);
D3D12RSSetViewports(d3d12->queue.cmd, 1, d3d12->queue.cmd->lpVtbl->RSSetViewports(d3d12->queue.cmd, 1,
&d3d12->chain.viewport); &d3d12->chain.viewport);
D3D12RSSetScissorRects(d3d12->queue.cmd, 1, d3d12->queue.cmd->lpVtbl->RSSetScissorRects(d3d12->queue.cmd, 1,
&d3d12->chain.scissorRect); &d3d12->chain.scissorRect);
D3D12IASetVertexBuffers(d3d12->queue.cmd, 0, 1, d3d12->queue.cmd->lpVtbl->IASetVertexBuffers(d3d12->queue.cmd, 0, 1,
&d3d12->sprites.vbo_view); &d3d12->sprites.vbo_view);
font_driver_render_msg(d3d12, msg, NULL, NULL); font_driver_render_msg(d3d12, msg, NULL, NULL);
@ -2857,41 +2879,41 @@ static bool d3d12_gfx_frame(
d3d12->chain.back_buffer.handle, d3d12->chain.back_buffer.handle,
D3D12_RESOURCE_STATE_RENDER_TARGET, D3D12_RESOURCE_STATE_RENDER_TARGET,
D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE); D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE);
D3D12SetPipelineState(d3d12->queue.cmd, d3d12->queue.cmd->lpVtbl->SetPipelineState(d3d12->queue.cmd,
d3d12->pipes[VIDEO_SHADER_STOCK_HDR]); d3d12->pipes[VIDEO_SHADER_STOCK_HDR]);
D3D12OMSetRenderTargets( d3d12->queue.cmd->lpVtbl->OMSetRenderTargets(
d3d12->queue.cmd, 1, d3d12->queue.cmd, 1,
&d3d12->chain.desc_handles[d3d12->chain.frame_index], &d3d12->chain.desc_handles[d3d12->chain.frame_index],
FALSE, NULL); FALSE, NULL);
D3D12ClearRenderTargetView( d3d12->queue.cmd->lpVtbl->ClearRenderTargetView(
d3d12->queue.cmd, d3d12->queue.cmd,
d3d12->chain.desc_handles[d3d12->chain.frame_index], d3d12->chain.desc_handles[d3d12->chain.frame_index],
d3d12->chain.clearcolor, 0, NULL); d3d12->chain.clearcolor, 0, NULL);
D3D12SetGraphicsRootSignature(d3d12->queue.cmd, d3d12->queue.cmd->lpVtbl->SetGraphicsRootSignature(d3d12->queue.cmd,
d3d12->desc.rootSignature); d3d12->desc.rootSignature);
D3D12SetGraphicsRootDescriptorTable(d3d12->queue.cmd, d3d12->queue.cmd->lpVtbl->SetGraphicsRootDescriptorTable(d3d12->queue.cmd,
ROOT_ID_TEXTURE_T, ROOT_ID_TEXTURE_T,
d3d12->chain.back_buffer.gpu_descriptor[0]); d3d12->chain.back_buffer.gpu_descriptor[0]);
D3D12SetGraphicsRootDescriptorTable(d3d12->queue.cmd, d3d12->queue.cmd->lpVtbl->SetGraphicsRootDescriptorTable(d3d12->queue.cmd,
ROOT_ID_SAMPLER_T, ROOT_ID_SAMPLER_T,
d3d12->samplers[RARCH_FILTER_UNSPEC][RARCH_WRAP_DEFAULT]); d3d12->samplers[RARCH_FILTER_UNSPEC][RARCH_WRAP_DEFAULT]);
D3D12SetGraphicsRootConstantBufferView( d3d12->queue.cmd->lpVtbl->SetGraphicsRootConstantBufferView(
d3d12->queue.cmd, ROOT_ID_UBO, d3d12->queue.cmd, ROOT_ID_UBO,
d3d12->hdr.ubo_view.BufferLocation); d3d12->hdr.ubo_view.BufferLocation);
D3D12IASetVertexBuffers(d3d12->queue.cmd, 0, 1, d3d12->queue.cmd->lpVtbl->IASetVertexBuffers(d3d12->queue.cmd, 0, 1,
&d3d12->frame.vbo_view); &d3d12->frame.vbo_view);
D3D12IASetPrimitiveTopology(d3d12->queue.cmd, d3d12->queue.cmd->lpVtbl->IASetPrimitiveTopology(d3d12->queue.cmd,
D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP); D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP);
D3D12RSSetViewports(d3d12->queue.cmd, 1, d3d12->queue.cmd->lpVtbl->RSSetViewports(d3d12->queue.cmd, 1,
&d3d12->chain.viewport); &d3d12->chain.viewport);
D3D12RSSetScissorRects(d3d12->queue.cmd, 1, d3d12->queue.cmd->lpVtbl->RSSetScissorRects(d3d12->queue.cmd, 1,
&d3d12->chain.scissorRect); &d3d12->chain.scissorRect);
D3D12DrawInstanced(d3d12->queue.cmd, 4, 1, 0, 0); d3d12->queue.cmd->lpVtbl->DrawInstanced(d3d12->queue.cmd, 4, 1, 0, 0);
} }
#endif #endif
@ -2901,13 +2923,11 @@ static bool d3d12_gfx_frame(
D3D12_RESOURCE_STATE_RENDER_TARGET, D3D12_RESOURCE_STATE_RENDER_TARGET,
D3D12_RESOURCE_STATE_PRESENT); D3D12_RESOURCE_STATE_PRESENT);
D3D12CloseGraphicsCommandList(d3d12->queue.cmd); d3d12->queue.cmd->lpVtbl->Close(d3d12->queue.cmd);
d3d12->queue.handle->lpVtbl->ExecuteCommandLists(d3d12->queue.handle, 1,
D3D12ExecuteGraphicsCommandLists(d3d12->queue.handle, 1, (ID3D12CommandList* const*)&d3d12->queue.cmd);
&d3d12->queue.cmd); d3d12->queue.handle->lpVtbl->Signal(d3d12->queue.handle,
d3d12->queue.fence, ++d3d12->queue.fenceValue);
D3D12SignalCommandQueue(d3d12->queue.handle, d3d12->queue.fence, ++d3d12->queue.fenceValue);
DXGIPresent(d3d12->chain.handle, d3d12->chain.swap_interval, present_flags); DXGIPresent(d3d12->chain.handle, d3d12->chain.swap_interval, present_flags);
if (vsync && wait_for_vblank) if (vsync && wait_for_vblank)
@ -3130,11 +3150,17 @@ static void d3d12_gfx_unload_texture(void* data,
bool threaded, uintptr_t handle) bool threaded, uintptr_t handle)
{ {
d3d12_texture_t* texture = (d3d12_texture_t*)handle; d3d12_texture_t* texture = (d3d12_texture_t*)handle;
d3d12_video_t* d3d12 = (d3d12_video_t*)data;
if (!texture) if (!texture)
return; return;
d3d12_gfx_sync((d3d12_video_t*)data); if (d3d12->queue.fence->lpVtbl->GetCompletedValue(d3d12->queue.fence) < d3d12->queue.fenceValue)
{
d3d12->queue.fence->lpVtbl->SetEventOnCompletion(
d3d12->queue.fence, d3d12->queue.fenceValue, d3d12->queue.fenceEvent);
WaitForSingleObject(d3d12->queue.fenceEvent, INFINITE);
}
d3d12_release_texture(texture); d3d12_release_texture(texture);
free(texture); free(texture);
} }

50
gfx/drivers_display/gfx_display_d3d12.c
View File

@ -30,7 +30,7 @@ static void gfx_display_d3d12_blend_begin(void *data)
d3d12_video_t* d3d12 = (d3d12_video_t*)data; d3d12_video_t* d3d12 = (d3d12_video_t*)data;
d3d12->sprites.pipe = d3d12->sprites.pipe_blend; d3d12->sprites.pipe = d3d12->sprites.pipe_blend;
D3D12SetPipelineState(d3d12->queue.cmd, d3d12->sprites.pipe); d3d12->queue.cmd->lpVtbl->SetPipelineState(d3d12->queue.cmd, (D3D12PipelineState)d3d12->sprites.pipe);
} }
static void gfx_display_d3d12_blend_end(void *data) static void gfx_display_d3d12_blend_end(void *data)
@ -38,7 +38,7 @@ static void gfx_display_d3d12_blend_end(void *data)
d3d12_video_t* d3d12 = (d3d12_video_t*)data; d3d12_video_t* d3d12 = (d3d12_video_t*)data;
d3d12->sprites.pipe = d3d12->sprites.pipe_noblend; d3d12->sprites.pipe = d3d12->sprites.pipe_noblend;
D3D12SetPipelineState(d3d12->queue.cmd, d3d12->sprites.pipe); d3d12->queue.cmd->lpVtbl->SetPipelineState(d3d12->queue.cmd, (D3D12PipelineState)d3d12->sprites.pipe);
} }
static void gfx_display_d3d12_draw(gfx_display_ctx_draw_t *draw, static void gfx_display_d3d12_draw(gfx_display_ctx_draw_t *draw,
@ -58,11 +58,11 @@ static void gfx_display_d3d12_draw(gfx_display_ctx_draw_t *draw,
case VIDEO_SHADER_MENU_4: case VIDEO_SHADER_MENU_4:
case VIDEO_SHADER_MENU_5: case VIDEO_SHADER_MENU_5:
case VIDEO_SHADER_MENU_6: case VIDEO_SHADER_MENU_6:
D3D12SetPipelineState(d3d12->queue.cmd, d3d12->pipes[draw->pipeline_id]); d3d12->queue.cmd->lpVtbl->SetPipelineState(d3d12->queue.cmd, (D3D12PipelineState)d3d12->pipes[draw->pipeline_id]);
D3D12DrawInstanced(d3d12->queue.cmd, draw->coords->vertices, 1, 0, 0); d3d12->queue.cmd->lpVtbl->DrawInstanced(d3d12->queue.cmd, draw->coords->vertices, 1, 0, 0);
D3D12SetPipelineState(d3d12->queue.cmd, d3d12->sprites.pipe); d3d12->queue.cmd->lpVtbl->SetPipelineState(d3d12->queue.cmd, (D3D12PipelineState)d3d12->sprites.pipe);
D3D12IASetPrimitiveTopology(d3d12->queue.cmd, D3D_PRIMITIVE_TOPOLOGY_POINTLIST); d3d12->queue.cmd->lpVtbl->IASetPrimitiveTopology(d3d12->queue.cmd, D3D_PRIMITIVE_TOPOLOGY_POINTLIST);
D3D12IASetVertexBuffers(d3d12->queue.cmd, 0, 1, &d3d12->sprites.vbo_view); d3d12->queue.cmd->lpVtbl->IASetVertexBuffers(d3d12->queue.cmd, 0, 1, &d3d12->sprites.vbo_view);
return; return;
} }
@ -140,9 +140,9 @@ static void gfx_display_d3d12_draw(gfx_display_ctx_draw_t *draw,
sprite++; sprite++;
} }
D3D12SetPipelineState(d3d12->queue.cmd, d3d12->queue.cmd->lpVtbl->SetPipelineState(d3d12->queue.cmd,
d3d12->pipes[VIDEO_SHADER_STOCK_BLEND]); (D3D12PipelineState)d3d12->pipes[VIDEO_SHADER_STOCK_BLEND]);
D3D12IASetPrimitiveTopology(d3d12->queue.cmd, d3d12->queue.cmd->lpVtbl->IASetPrimitiveTopology(d3d12->queue.cmd,
D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP); D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP);
} }
@ -159,23 +159,23 @@ static void gfx_display_d3d12_draw(gfx_display_ctx_draw_t *draw,
texture, d3d12); texture, d3d12);
if (vertex_count > 1) if (vertex_count > 1)
D3D12SetPipelineState(d3d12->queue.cmd, d3d12->queue.cmd->lpVtbl->SetPipelineState(d3d12->queue.cmd,
d3d12->pipes[VIDEO_SHADER_STOCK_BLEND]); (D3D12PipelineState)d3d12->pipes[VIDEO_SHADER_STOCK_BLEND]);
else else
D3D12SetPipelineState(d3d12->queue.cmd, d3d12->queue.cmd->lpVtbl->SetPipelineState(d3d12->queue.cmd,
d3d12->sprites.pipe); (D3D12PipelineState)d3d12->sprites.pipe);
} }
D3D12SetGraphicsRootDescriptorTable(d3d12->queue.cmd, ROOT_ID_TEXTURE_T, texture->gpu_descriptor[0]); d3d12->queue.cmd->lpVtbl->SetGraphicsRootDescriptorTable(d3d12->queue.cmd, ROOT_ID_TEXTURE_T, texture->gpu_descriptor[0]);
D3D12SetGraphicsRootDescriptorTable(d3d12->queue.cmd, ROOT_ID_SAMPLER_T, texture->sampler); d3d12->queue.cmd->lpVtbl->SetGraphicsRootDescriptorTable(d3d12->queue.cmd, ROOT_ID_SAMPLER_T, texture->sampler);
} }
D3D12DrawInstanced(d3d12->queue.cmd, vertex_count, 1, d3d12->sprites.offset, 0); d3d12->queue.cmd->lpVtbl->DrawInstanced(d3d12->queue.cmd, vertex_count, 1, d3d12->sprites.offset, 0);
d3d12->sprites.offset += vertex_count; d3d12->sprites.offset += vertex_count;
if (vertex_count > 1) if (vertex_count > 1)
{ {
D3D12SetPipelineState(d3d12->queue.cmd, d3d12->sprites.pipe); d3d12->queue.cmd->lpVtbl->SetPipelineState(d3d12->queue.cmd, (D3D12PipelineState)d3d12->sprites.pipe);
D3D12IASetPrimitiveTopology(d3d12->queue.cmd, D3D_PRIMITIVE_TOPOLOGY_POINTLIST); d3d12->queue.cmd->lpVtbl->IASetPrimitiveTopology(d3d12->queue.cmd, D3D_PRIMITIVE_TOPOLOGY_POINTLIST);
} }
return; return;
@ -217,7 +217,7 @@ static void gfx_display_d3d12_draw_pipeline(gfx_display_ctx_draw_t *draw,
d3d12->menu_pipeline_vbo_view.SizeInBytes); d3d12->menu_pipeline_vbo_view.SizeInBytes);
D3D12Unmap(d3d12->menu_pipeline_vbo, 0, NULL); D3D12Unmap(d3d12->menu_pipeline_vbo, 0, NULL);
} }
D3D12IASetVertexBuffers(d3d12->queue.cmd, 0, 1, d3d12->queue.cmd->lpVtbl->IASetVertexBuffers(d3d12->queue.cmd, 0, 1,
&d3d12->menu_pipeline_vbo_view); &d3d12->menu_pipeline_vbo_view);
draw->coords->vertices = ca->coords.vertices; draw->coords->vertices = ca->coords.vertices;
break; break;
@ -227,14 +227,14 @@ static void gfx_display_d3d12_draw_pipeline(gfx_display_ctx_draw_t *draw,
case VIDEO_SHADER_MENU_4: case VIDEO_SHADER_MENU_4:
case VIDEO_SHADER_MENU_5: case VIDEO_SHADER_MENU_5:
case VIDEO_SHADER_MENU_6: case VIDEO_SHADER_MENU_6:
D3D12IASetVertexBuffers(d3d12->queue.cmd, 0, 1, d3d12->queue.cmd->lpVtbl->IASetVertexBuffers(d3d12->queue.cmd, 0, 1,
&d3d12->frame.vbo_view); &d3d12->frame.vbo_view);
draw->coords->vertices = 4; draw->coords->vertices = 4;
break; break;
default: default:
return; return;
} }
D3D12IASetPrimitiveTopology(d3d12->queue.cmd, d3d12->queue.cmd->lpVtbl->IASetPrimitiveTopology(d3d12->queue.cmd,
D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP); D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP);
d3d12->ubo_values.time += 0.01f; d3d12->ubo_values.time += 0.01f;
@ -249,7 +249,7 @@ static void gfx_display_d3d12_draw_pipeline(gfx_display_ctx_draw_t *draw,
*mapped_ubo = d3d12->ubo_values; *mapped_ubo = d3d12->ubo_values;
D3D12Unmap(d3d12->ubo, 0, NULL); D3D12Unmap(d3d12->ubo, 0, NULL);
} }
D3D12SetGraphicsRootConstantBufferView( d3d12->queue.cmd->lpVtbl->SetGraphicsRootConstantBufferView(
d3d12->queue.cmd, ROOT_ID_UBO, d3d12->queue.cmd, ROOT_ID_UBO,
d3d12->ubo_view.BufferLocation); d3d12->ubo_view.BufferLocation);
} }
@ -269,7 +269,7 @@ void gfx_display_d3d12_scissor_begin(void *data,
rect.right = width + x; rect.right = width + x;
rect.bottom = height + y; rect.bottom = height + y;
D3D12RSSetScissorRects(d3d12->queue.cmd, 1, &rect); d3d12->queue.cmd->lpVtbl->RSSetScissorRects(d3d12->queue.cmd, 1, &rect);
} }
void gfx_display_d3d12_scissor_end(void *data, void gfx_display_d3d12_scissor_end(void *data,
@ -287,7 +287,7 @@ void gfx_display_d3d12_scissor_end(void *data,
rect.right = video_width; rect.right = video_width;
rect.bottom = video_height; rect.bottom = video_height;
D3D12RSSetScissorRects(d3d12->queue.cmd, 1, &rect); d3d12->queue.cmd->lpVtbl->RSSetScissorRects(d3d12->queue.cmd, 1, &rect);
} }
gfx_display_ctx_driver_t gfx_display_ctx_d3d12 = { gfx_display_ctx_driver_t gfx_display_ctx_d3d12 = {

10
gfx/drivers_font/d3d12_font.c
View File

@ -220,14 +220,14 @@ static void d3d12_font_render_line(
d3d12_upload_texture(d3d12->queue.cmd, &font->texture, d3d12_upload_texture(d3d12->queue.cmd, &font->texture,
d3d12); d3d12);
D3D12SetPipelineState(d3d12->queue.cmd, d3d12->sprites.pipe_font); d3d12->queue.cmd->lpVtbl->SetPipelineState(d3d12->queue.cmd, (D3D12PipelineState)d3d12->sprites.pipe_font);
D3D12SetGraphicsRootDescriptorTable(d3d12->queue.cmd, d3d12->queue.cmd->lpVtbl->SetGraphicsRootDescriptorTable(d3d12->queue.cmd,
ROOT_ID_TEXTURE_T, font->texture.gpu_descriptor[0]); ROOT_ID_TEXTURE_T, font->texture.gpu_descriptor[0]);
D3D12SetGraphicsRootDescriptorTable(d3d12->queue.cmd, d3d12->queue.cmd->lpVtbl->SetGraphicsRootDescriptorTable(d3d12->queue.cmd,
ROOT_ID_SAMPLER_T, font->texture.sampler); ROOT_ID_SAMPLER_T, font->texture.sampler);
D3D12DrawInstanced(d3d12->queue.cmd, count, 1, d3d12->sprites.offset, 0); d3d12->queue.cmd->lpVtbl->DrawInstanced(d3d12->queue.cmd, count, 1, d3d12->sprites.offset, 0);
D3D12SetPipelineState(d3d12->queue.cmd, d3d12->sprites.pipe); d3d12->queue.cmd->lpVtbl->SetPipelineState(d3d12->queue.cmd, (D3D12PipelineState)d3d12->sprites.pipe);
d3d12->sprites.offset += count; d3d12->sprites.offset += count;
} }