mirror/RetroArch
1
0
Fork 0
mirror of https://github.com/libretro/RetroArch synced 2025-04-15 23:42:30 +00:00
Code Issues Packages Projects Releases Wiki Activity

(D3D) Miscellaneous cleanups

Browse Source
This commit is contained in:
libretroadmin 2022-06-04 19:15:45 +02:00
parent 4226a8311e
commit 4dc08fad5c
8 changed files with 298 additions and 375 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

122
gfx/common/d3d10_common.c
View File

@ -15,8 +15,6 @@
#define CINTERFACE #define CINTERFACE
#include <gfx/scaler/pixconv.h>
#include "d3d10_common.h" #include "d3d10_common.h"
#include "d3dcompiler_common.h" #include "d3dcompiler_common.h"
@ -60,6 +58,29 @@ HRESULT WINAPI D3D10CreateDeviceAndSwapChain(
} }
#endif #endif
static DXGI_FORMAT
d3d10_get_closest_match(D3D10Device device,
DXGI_FORMAT desired_format, UINT desired_format_support)
{
DXGI_FORMAT default_list[] = {desired_format, DXGI_FORMAT_UNKNOWN};
DXGI_FORMAT* format = dxgi_get_format_fallback_list(desired_format);
if(!format)
format = default_list;
while (*format != DXGI_FORMAT_UNKNOWN)
{
UINT format_support;
if (SUCCEEDED(device->lpVtbl->CheckFormatSupport(device, *format,
&format_support)) &&
((format_support & desired_format_support) == desired_format_support))
break;
format++;
}
assert(*format);
return *format;
}
void d3d10_init_texture(D3D10Device device, d3d10_texture_t* texture) void d3d10_init_texture(D3D10Device device, d3d10_texture_t* texture)
{ {
bool is_render_target = texture->desc.BindFlags & D3D10_BIND_RENDER_TARGET; bool is_render_target = texture->desc.BindFlags & D3D10_BIND_RENDER_TARGET;
@ -80,12 +101,12 @@ void d3d10_init_texture(D3D10Device device, d3d10_texture_t* texture)
unsigned width, height; unsigned width, height;
texture->desc.BindFlags |= D3D10_BIND_RENDER_TARGET; texture->desc.BindFlags |= D3D10_BIND_RENDER_TARGET;
width = texture->desc.Width >> 5; width = texture->desc.Width >> 5;
height = texture->desc.Height >> 5; height = texture->desc.Height >> 5;
while (width && height) while (width && height)
{ {
width >>= 1; width >>= 1;
height >>= 1; height >>= 1;
texture->desc.MipLevels++; texture->desc.MipLevels++;
} }
@ -144,15 +165,10 @@ void d3d10_update_texture(
texture->staging->lpVtbl->Map(texture->staging, 0, D3D10_MAP_WRITE, 0, texture->staging->lpVtbl->Map(texture->staging, 0, D3D10_MAP_WRITE, 0,
&mapped_texture); &mapped_texture);
#if 0
conv_rgb565_argb8888(mapped_texture.pData, data, width, height,
mapped_texture.RowPitch, pitch);
#else
dxgi_copy( dxgi_copy(
width, height, format, pitch, data, texture->desc.Format, width, height, format, pitch, data, texture->desc.Format,
mapped_texture.RowPitch, mapped_texture.RowPitch,
mapped_texture.pData); mapped_texture.pData);
#endif
texture->staging->lpVtbl->Unmap(texture->staging, 0); texture->staging->lpVtbl->Unmap(texture->staging, 0);
frame_box.left = 0; frame_box.left = 0;
@ -168,91 +184,3 @@ void d3d10_update_texture(
if (texture->desc.MiscFlags & D3D10_RESOURCE_MISC_GENERATE_MIPS) if (texture->desc.MiscFlags & D3D10_RESOURCE_MISC_GENERATE_MIPS)
ctx->lpVtbl->GenerateMips(ctx, texture->view); ctx->lpVtbl->GenerateMips(ctx, texture->view);
} }
DXGI_FORMAT
d3d10_get_closest_match(D3D10Device device,
DXGI_FORMAT desired_format, UINT desired_format_support)
{
DXGI_FORMAT default_list[] = {desired_format, DXGI_FORMAT_UNKNOWN};
DXGI_FORMAT* format = dxgi_get_format_fallback_list(desired_format);
if(!format)
format = default_list;
while (*format != DXGI_FORMAT_UNKNOWN)
{
UINT format_support;
if (SUCCEEDED(device->lpVtbl->CheckFormatSupport(device, *format,
&format_support)) &&
((format_support & desired_format_support) == desired_format_support))
break;
format++;
}
assert(*format);
return *format;
}
bool d3d10_init_shader(
D3D10Device device,
const char* src,
size_t size,
const void* src_name,
LPCSTR vs_entry,
LPCSTR ps_entry,
LPCSTR gs_entry,
const D3D10_INPUT_ELEMENT_DESC* input_element_descs,
UINT num_elements,
d3d10_shader_t* out)
{
D3DBlob vs_code = NULL;
D3DBlob ps_code = NULL;
D3DBlob gs_code = NULL;
bool success = true;
if (!src) /* LPCWSTR filename */
{
if (vs_entry && !d3d_compile_from_file((LPCWSTR)src_name, vs_entry, "vs_4_0", &vs_code))
success = false;
if (ps_entry && !d3d_compile_from_file((LPCWSTR)src_name, ps_entry, "ps_4_0", &ps_code))
success = false;
if (gs_entry && !d3d_compile_from_file((LPCWSTR)src_name, gs_entry, "gs_4_0", &gs_code))
success = false;
}
else /* char array */
{
if (vs_entry && !d3d_compile(src, size, (LPCSTR)src_name, vs_entry, "vs_4_0", &vs_code))
success = false;
if (ps_entry && !d3d_compile(src, size, (LPCSTR)src_name, ps_entry, "ps_4_0", &ps_code))
success = false;
if (gs_entry && !d3d_compile(src, size, (LPCSTR)src_name, gs_entry, "gs_4_0", &gs_code))
success = false;
}
if (ps_code)
device->lpVtbl->CreatePixelShader(device, D3DGetBufferPointer(ps_code),
D3DGetBufferSize(ps_code), &out->ps);
if (gs_code)
device->lpVtbl->CreateGeometryShader(
device, D3DGetBufferPointer(gs_code), D3DGetBufferSize(gs_code),
&out->gs);
if (vs_code)
{
LPVOID buf_ptr = D3DGetBufferPointer(vs_code);
SIZE_T buf_size = D3DGetBufferSize(vs_code);
device->lpVtbl->CreateVertexShader(device, buf_ptr, buf_size, &out->vs);
if (input_element_descs)
device->lpVtbl->CreateInputLayout(
device, (D3D10_INPUT_ELEMENT_DESC*)input_element_descs,
num_elements, buf_ptr, buf_size, &out->layout);
}
Release(vs_code);
Release(ps_code);
Release(gs_code);
return success;
}

24
gfx/common/d3d10_common.h
View File

@ -250,21 +250,6 @@ void d3d10_update_texture(
const void* data, const void* data,
d3d10_texture_t* texture); d3d10_texture_t* texture);
DXGI_FORMAT d3d10_get_closest_match(
D3D10Device device, DXGI_FORMAT desired_format, UINT desired_format_support);
bool d3d10_init_shader(
D3D10Device device,
const char* src,
size_t size,
const void* src_name,
LPCSTR vs_entry,
LPCSTR ps_entry,
LPCSTR gs_entry,
const D3D10_INPUT_ELEMENT_DESC* input_element_descs,
UINT num_elements,
d3d10_shader_t* out);
static INLINE void d3d10_release_shader(d3d10_shader_t* shader) static INLINE void d3d10_release_shader(d3d10_shader_t* shader)
{ {
Release(shader->layout); Release(shader->layout);
@ -273,15 +258,6 @@ static INLINE void d3d10_release_shader(d3d10_shader_t* shader)
Release(shader->gs); Release(shader->gs);
} }
static INLINE DXGI_FORMAT
d3d10_get_closest_match_texture2D(D3D10Device device, DXGI_FORMAT desired_format)
{
return d3d10_get_closest_match(
device, desired_format,
D3D10_FORMAT_SUPPORT_TEXTURE2D
| D3D10_FORMAT_SUPPORT_SHADER_SAMPLE);
}
static INLINE void d3d10_set_shader(D3D10Device ctx, d3d10_shader_t* shader) static INLINE void d3d10_set_shader(D3D10Device ctx, d3d10_shader_t* shader)
{ {
ctx->lpVtbl->IASetInputLayout(ctx, shader->layout); ctx->lpVtbl->IASetInputLayout(ctx, shader->layout);

171
gfx/common/d3d11_common.c
View File

@ -49,41 +49,35 @@ HRESULT WINAPI D3D11CreateDevice(
pAdapter, DriverType, Software, Flags, pFeatureLevels, FeatureLevels, SDKVersion, pAdapter, DriverType, Software, Flags, pFeatureLevels, FeatureLevels, SDKVersion,
ppDevice, pFeatureLevel, ppImmediateContext); ppDevice, pFeatureLevel, ppImmediateContext);
} }
HRESULT WINAPI D3D11CreateDeviceAndSwapChain(
IDXGIAdapter* pAdapter,
D3D_DRIVER_TYPE DriverType,
HMODULE Software,
UINT Flags,
CONST D3D_FEATURE_LEVEL* pFeatureLevels,
UINT FeatureLevels,
UINT SDKVersion,
CONST DXGI_SWAP_CHAIN_DESC* pSwapChainDesc,
IDXGISwapChain** ppSwapChain,
ID3D11Device** ppDevice,
D3D_FEATURE_LEVEL* pFeatureLevel,
ID3D11DeviceContext** ppImmediateContext)
{
static dylib_t d3d11_dll;
static PFN_D3D11_CREATE_DEVICE_AND_SWAP_CHAIN fp;
if (!d3d11_dll)
if (!(d3d11_dll = dylib_load("d3d11.dll")))
return TYPE_E_CANTLOADLIBRARY;
if (!fp)
if (!(fp = (PFN_D3D11_CREATE_DEVICE_AND_SWAP_CHAIN)dylib_proc(
d3d11_dll, "D3D11CreateDeviceAndSwapChain")))
return TYPE_E_DLLFUNCTIONNOTFOUND;
return fp(
pAdapter, DriverType, Software, Flags, pFeatureLevels, FeatureLevels, SDKVersion,
pSwapChainDesc, ppSwapChain, ppDevice, pFeatureLevel, ppImmediateContext);
}
#endif #endif
static DXGI_FORMAT
d3d11_get_closest_match(D3D11Device device, DXGI_FORMAT desired_format, UINT desired_format_support)
{
DXGI_FORMAT default_list[] = {desired_format, DXGI_FORMAT_UNKNOWN};
DXGI_FORMAT* format = dxgi_get_format_fallback_list(desired_format);
if(!format)
format = default_list;
while (*format != DXGI_FORMAT_UNKNOWN)
{
UINT format_support;
if (SUCCEEDED(device->lpVtbl->CheckFormatSupport(device, *format,
&format_support)) &&
((format_support & desired_format_support) == desired_format_support))
break;
format++;
}
assert(*format);
return *format;
}
void d3d11_init_texture(D3D11Device device, d3d11_texture_t* texture) void d3d11_init_texture(D3D11Device device, d3d11_texture_t* texture)
{ {
bool is_render_target = texture->desc.BindFlags & D3D11_BIND_RENDER_TARGET; bool is_render_target = texture->desc.BindFlags & D3D11_BIND_RENDER_TARGET;
UINT format_support = D3D11_FORMAT_SUPPORT_TEXTURE2D | D3D11_FORMAT_SUPPORT_SHADER_SAMPLE; UINT format_support = D3D11_FORMAT_SUPPORT_TEXTURE2D | D3D11_FORMAT_SUPPORT_SHADER_SAMPLE;
d3d11_release_texture(texture); d3d11_release_texture(texture);
@ -100,7 +94,7 @@ void d3d11_init_texture(D3D11Device device, d3d11_texture_t* texture)
unsigned width, height; unsigned width, height;
texture->desc.BindFlags |= D3D11_BIND_RENDER_TARGET; texture->desc.BindFlags |= D3D11_BIND_RENDER_TARGET;
width = texture->desc.Width >> 5; width = texture->desc.Width >> 5;
height = texture->desc.Height >> 5; height = texture->desc.Height >> 5;
while (width && height) while (width && height)
@ -164,15 +158,10 @@ void d3d11_update_texture(
ctx->lpVtbl->Map( ctx->lpVtbl->Map(
ctx, (D3D11Resource)texture->staging, 0, D3D11_MAP_WRITE, 0, &mapped_texture); ctx, (D3D11Resource)texture->staging, 0, D3D11_MAP_WRITE, 0, &mapped_texture);
#if 0
conv_rgb565_argb8888(mapped_texture.pData, data, width, height,
mapped_texture.RowPitch, pitch);
#else
dxgi_copy( dxgi_copy(
width, height, format, pitch, data, width, height, format, pitch, data,
texture->desc.Format, mapped_texture.RowPitch, texture->desc.Format, mapped_texture.RowPitch,
mapped_texture.pData); mapped_texture.pData);
#endif
frame_box.left = 0; frame_box.left = 0;
frame_box.top = 0; frame_box.top = 0;
@ -188,111 +177,3 @@ void d3d11_update_texture(
if (texture->desc.MiscFlags & D3D11_RESOURCE_MISC_GENERATE_MIPS) if (texture->desc.MiscFlags & D3D11_RESOURCE_MISC_GENERATE_MIPS)
ctx->lpVtbl->GenerateMips(ctx, texture->view); ctx->lpVtbl->GenerateMips(ctx, texture->view);
} }
DXGI_FORMAT
d3d11_get_closest_match(D3D11Device device, DXGI_FORMAT desired_format, UINT desired_format_support)
{
DXGI_FORMAT default_list[] = {desired_format, DXGI_FORMAT_UNKNOWN};
DXGI_FORMAT* format = dxgi_get_format_fallback_list(desired_format);
if(!format)
format = default_list;
while (*format != DXGI_FORMAT_UNKNOWN)
{
UINT format_support;
if (SUCCEEDED(device->lpVtbl->CheckFormatSupport(device, *format,
&format_support)) &&
((format_support & desired_format_support) == desired_format_support))
break;
format++;
}
assert(*format);
return *format;
}
bool d3d11_init_shader(
D3D11Device device,
const char* src,
size_t size,
const void* src_name,
LPCSTR vs_entry,
LPCSTR ps_entry,
LPCSTR gs_entry,
const D3D11_INPUT_ELEMENT_DESC* input_element_descs,
UINT num_elements,
d3d11_shader_t* out,
enum d3d11_feature_level_hint hint)
{
D3DBlob vs_code = NULL;
D3DBlob ps_code = NULL;
D3DBlob gs_code = NULL;
bool success = true;
const char *vs_str = NULL;
const char *ps_str = NULL;
const char *gs_str = NULL;
switch (hint)
{
case D3D11_FEATURE_LEVEL_HINT_11_0:
case D3D11_FEATURE_LEVEL_HINT_11_1:
case D3D11_FEATURE_LEVEL_HINT_12_0:
case D3D11_FEATURE_LEVEL_HINT_12_1:
case D3D11_FEATURE_LEVEL_HINT_12_2:
vs_str = "vs_5_0";
ps_str = "ps_5_0";
gs_str = "gs_5_0";
break;
case D3D11_FEATURE_LEVEL_HINT_DONTCARE:
default:
vs_str = "vs_4_0";
ps_str = "ps_4_0";
gs_str = "gs_4_0";
break;
}
if (!src) /* LPCWSTR filename */
{
if (vs_entry && !d3d_compile_from_file((LPCWSTR)src_name, vs_entry, vs_str, &vs_code))
success = false;
if (ps_entry && !d3d_compile_from_file((LPCWSTR)src_name, ps_entry, ps_str, &ps_code))
success = false;
if (gs_entry && !d3d_compile_from_file((LPCWSTR)src_name, gs_entry, gs_str, &gs_code))
success = false;
}
else /* char array */
{
if (vs_entry && !d3d_compile(src, size, (LPCSTR)src_name, vs_entry, vs_str, &vs_code))
success = false;
if (ps_entry && !d3d_compile(src, size, (LPCSTR)src_name, ps_entry, ps_str, &ps_code))
success = false;
if (gs_entry && !d3d_compile(src, size, (LPCSTR)src_name, gs_entry, gs_str, &gs_code))
success = false;
}
if (ps_code)
device->lpVtbl->CreatePixelShader(
device, D3DGetBufferPointer(ps_code), D3DGetBufferSize(ps_code),
NULL, &out->ps);
if (gs_code)
device->lpVtbl->CreateGeometryShader(
device, D3DGetBufferPointer(gs_code), D3DGetBufferSize(gs_code),
NULL, &out->gs);
if (vs_code)
{
LPVOID buf_ptr = D3DGetBufferPointer(vs_code);
SIZE_T buf_size = D3DGetBufferSize(vs_code);
device->lpVtbl->CreateVertexShader(device, buf_ptr, buf_size, NULL, &out->vs);
if (input_element_descs)
device->lpVtbl->CreateInputLayout(device, input_element_descs, num_elements,
buf_ptr, buf_size, &out->layout);
}
Release(vs_code);
Release(ps_code);
Release(gs_code);
return success;
}

16
gfx/common/d3d11_common.h
View File

@ -313,19 +313,3 @@ void d3d11_update_texture(
DXGI_FORMAT format, DXGI_FORMAT format,
const void* data, const void* data,
d3d11_texture_t* texture); d3d11_texture_t* texture);
DXGI_FORMAT d3d11_get_closest_match(
D3D11Device device, DXGI_FORMAT desired_format, UINT desired_format_support);
bool d3d11_init_shader(
D3D11Device device,
const char* src,
size_t size,
const void* src_name,
LPCSTR vs_entry,
LPCSTR ps_entry,
LPCSTR gs_entry,
const D3D11_INPUT_ELEMENT_DESC* input_element_descs,
UINT num_elements,
d3d11_shader_t* out,
enum d3d11_feature_level_hint hint);

140
gfx/common/d3d12_common.c
View File

@ -155,16 +155,25 @@ d3d12_descriptor_heap_slot_free(d3d12_descriptor_heap_t* heap, D3D12_CPU_DESCRIP
D3D12_GPU_VIRTUAL_ADDRESS D3D12_GPU_VIRTUAL_ADDRESS
d3d12_create_buffer(D3D12Device device, UINT size_in_bytes, D3D12Resource* buffer) d3d12_create_buffer(D3D12Device device, UINT size_in_bytes, D3D12Resource* buffer)
{ {
D3D12_HEAP_PROPERTIES heap_props = { D3D12_HEAP_TYPE_UPLOAD, D3D12_CPU_PAGE_PROPERTY_UNKNOWN, D3D12_RESOURCE_DESC resource_desc;
D3D12_MEMORY_POOL_UNKNOWN, 1, 1 }; D3D12_HEAP_PROPERTIES heap_props;
D3D12_RESOURCE_DESC resource_desc = { D3D12_RESOURCE_DIMENSION_BUFFER };
heap_props.Type = D3D12_HEAP_TYPE_UPLOAD;
heap_props.CPUPageProperty = D3D12_CPU_PAGE_PROPERTY_UNKNOWN;
heap_props.MemoryPoolPreference = D3D12_MEMORY_POOL_UNKNOWN;
heap_props.CreationNodeMask = 1;
heap_props.VisibleNodeMask = 1;
resource_desc.Dimension = D3D12_RESOURCE_DIMENSION_BUFFER;
resource_desc.Width = size_in_bytes; resource_desc.Width = size_in_bytes;
resource_desc.Height = 1; resource_desc.Height = 1;
resource_desc.DepthOrArraySize = 1; resource_desc.DepthOrArraySize = 1;
resource_desc.MipLevels = 1; resource_desc.MipLevels = 1;
resource_desc.Format = DXGI_FORMAT_UNKNOWN;
resource_desc.SampleDesc.Count = 1; resource_desc.SampleDesc.Count = 1;
resource_desc.SampleDesc.Quality = 0;
resource_desc.Layout = D3D12_TEXTURE_LAYOUT_ROW_MAJOR; resource_desc.Layout = D3D12_TEXTURE_LAYOUT_ROW_MAJOR;
resource_desc.Flags = D3D12_RESOURCE_FLAG_NONE;
D3D12CreateCommittedResource( D3D12CreateCommittedResource(
device, (D3D12_HEAP_PROPERTIES*)&heap_props, D3D12_HEAP_FLAG_NONE, &resource_desc, device, (D3D12_HEAP_PROPERTIES*)&heap_props, D3D12_HEAP_FLAG_NONE, &resource_desc,
@ -221,7 +230,7 @@ static DXGI_FORMAT d3d12_get_closest_match(D3D12Device device, D3D12_FEATURE_DAT
DXGI_FORMAT* format = dxgi_get_format_fallback_list(desired->Format); DXGI_FORMAT* format = dxgi_get_format_fallback_list(desired->Format);
if (!format) if (!format)
format = default_list; format = default_list;
while (*format != DXGI_FORMAT_UNKNOWN) while (*format != DXGI_FORMAT_UNKNOWN)
{ {
@ -243,14 +252,14 @@ void d3d12_init_texture(D3D12Device device, d3d12_texture_t* texture)
d3d12_release_texture(texture); d3d12_release_texture(texture);
if (!texture->desc.MipLevels) if (!texture->desc.MipLevels)
texture->desc.MipLevels = 1; texture->desc.MipLevels = 1;
if (!(texture->desc.Width >> (texture->desc.MipLevels - 1)) && if (!(texture->desc.Width >> (texture->desc.MipLevels - 1)) &&
!(texture->desc.Height >> (texture->desc.MipLevels - 1))) !(texture->desc.Height >> (texture->desc.MipLevels - 1)))
{ {
unsigned width = texture->desc.Width >> 5; unsigned width = texture->desc.Width >> 5;
unsigned height = texture->desc.Height >> 5; unsigned height = texture->desc.Height >> 5;
texture->desc.MipLevels = 1; texture->desc.MipLevels = 1;
while (width && height) while (width && height)
{ {
width >>= 1; width >>= 1;
@ -260,26 +269,34 @@ void d3d12_init_texture(D3D12Device device, d3d12_texture_t* texture)
} }
{ {
D3D12_FEATURE_DATA_FORMAT_SUPPORT format_support = { D3D12_HEAP_PROPERTIES heap_props;
texture->desc.Format, D3D12_FORMAT_SUPPORT1_TEXTURE2D | D3D12_FORMAT_SUPPORT1_SHADER_SAMPLE D3D12_FEATURE_DATA_FORMAT_SUPPORT format_support;
};
D3D12_HEAP_PROPERTIES heap_props = { D3D12_HEAP_TYPE_DEFAULT, D3D12_CPU_PAGE_PROPERTY_UNKNOWN, heap_props.Type = D3D12_HEAP_TYPE_DEFAULT;
D3D12_MEMORY_POOL_UNKNOWN, 1, 1 }; heap_props.CPUPageProperty = D3D12_CPU_PAGE_PROPERTY_UNKNOWN;
heap_props.MemoryPoolPreference = D3D12_MEMORY_POOL_UNKNOWN;
heap_props.CreationNodeMask = 1;
heap_props.VisibleNodeMask = 1;
format_support.Format = texture->desc.Format;
format_support.Support1 = D3D12_FORMAT_SUPPORT1_TEXTURE2D | D3D12_FORMAT_SUPPORT1_SHADER_SAMPLE;
if (texture->desc.MipLevels > 1) if (texture->desc.MipLevels > 1)
{ {
texture->desc.Flags |= D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS; texture->desc.Flags |= D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS;
format_support.Support1 |= D3D12_FORMAT_SUPPORT1_MIP; format_support.Support1 |= D3D12_FORMAT_SUPPORT1_MIP;
format_support.Support2 |= D3D12_FORMAT_SUPPORT2_UAV_TYPED_STORE; format_support.Support2 = D3D12_FORMAT_SUPPORT2_UAV_TYPED_STORE;
} }
else
format_support.Support2 = D3D12_FORMAT_SUPPORT2_NONE;
if (texture->desc.Flags & D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET) if (texture->desc.Flags & D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET)
format_support.Support1 |= D3D12_FORMAT_SUPPORT1_RENDER_TARGET; format_support.Support1 |= D3D12_FORMAT_SUPPORT1_RENDER_TARGET;
texture->desc.Dimension = D3D12_RESOURCE_DIMENSION_TEXTURE2D; texture->desc.Dimension = D3D12_RESOURCE_DIMENSION_TEXTURE2D;
texture->desc.DepthOrArraySize = 1; texture->desc.DepthOrArraySize = 1;
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( D3D12CreateCommittedResource(
device, &heap_props, D3D12_HEAP_FLAG_NONE, &texture->desc, device, &heap_props, D3D12_HEAP_FLAG_NONE, &texture->desc,
@ -289,29 +306,31 @@ void d3d12_init_texture(D3D12Device device, d3d12_texture_t* texture)
assert(texture->srv_heap); assert(texture->srv_heap);
{ {
D3D12_SHADER_RESOURCE_VIEW_DESC desc = { texture->desc.Format }; D3D12_SHADER_RESOURCE_VIEW_DESC desc;
desc.Shader4ComponentMapping = D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING; desc.Format = texture->desc.Format;
desc.ViewDimension = D3D12_SRV_DIMENSION_TEXTURE2D; desc.ViewDimension = D3D12_SRV_DIMENSION_TEXTURE2D;
desc.Texture2D.MipLevels = texture->desc.MipLevels; desc.Shader4ComponentMapping = D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING;
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]); D3D12CreateShaderResourceView(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;
} }
for (i = 1; i < texture->desc.MipLevels; i++) for (i = 1; i < texture->desc.MipLevels; i++)
{ {
D3D12_UNORDERED_ACCESS_VIEW_DESC desc = { texture->desc.Format }; D3D12_UNORDERED_ACCESS_VIEW_DESC desc;
desc.ViewDimension = D3D12_UAV_DIMENSION_TEXTURE2D; desc.Format = texture->desc.Format;
desc.Texture2D.MipSlice = i; desc.ViewDimension = D3D12_UAV_DIMENSION_TEXTURE2D;
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( D3D12CreateUnorderedAccessView(
device, texture->handle, NULL, &desc, texture->cpu_descriptor[i]); device, 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;
} }
@ -322,33 +341,38 @@ void d3d12_init_texture(D3D12Device device, d3d12_texture_t* texture)
} }
else else
{ {
D3D12_HEAP_PROPERTIES heap_props = { D3D12_HEAP_TYPE_UPLOAD, D3D12_CPU_PAGE_PROPERTY_UNKNOWN, D3D12_HEAP_PROPERTIES heap_props;
D3D12_MEMORY_POOL_UNKNOWN, 1, 1 }; D3D12_RESOURCE_DESC buffer_desc;
D3D12_RESOURCE_DESC buffer_desc = { D3D12_RESOURCE_DIMENSION_BUFFER };
D3D12GetCopyableFootprints( D3D12GetCopyableFootprints(
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);
buffer_desc.Width = texture->total_bytes; heap_props.Type = D3D12_HEAP_TYPE_UPLOAD;
buffer_desc.Height = 1; heap_props.CPUPageProperty = D3D12_CPU_PAGE_PROPERTY_UNKNOWN;
buffer_desc.DepthOrArraySize = 1; heap_props.MemoryPoolPreference = D3D12_MEMORY_POOL_UNKNOWN;
buffer_desc.MipLevels = 1; heap_props.CreationNodeMask = 1;
buffer_desc.SampleDesc.Count = 1; heap_props.VisibleNodeMask = 1;
buffer_desc.Layout = D3D12_TEXTURE_LAYOUT_ROW_MAJOR;
#if 0 buffer_desc.Dimension = D3D12_RESOURCE_DIMENSION_BUFFER;
buffer_desc.Flags = D3D12_RESOURCE_FLAG_DENY_SHADER_RESOURCE; buffer_desc.Width = texture->total_bytes;
#endif buffer_desc.Height = 1;
buffer_desc.DepthOrArraySize = 1;
buffer_desc.MipLevels = 1;
buffer_desc.SampleDesc.Count = 1;
buffer_desc.SampleDesc.Quality = 0;
buffer_desc.Layout = D3D12_TEXTURE_LAYOUT_ROW_MAJOR;
buffer_desc.Flags = D3D12_RESOURCE_FLAG_NONE;
D3D12CreateCommittedResource( D3D12CreateCommittedResource(
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, &texture->upload_buffer);
} }
texture->size_data.x = texture->desc.Width; texture->size_data.x = texture->desc.Width;
texture->size_data.y = texture->desc.Height; texture->size_data.y = texture->desc.Height;
texture->size_data.z = 1.0f / texture->desc.Width; texture->size_data.z = 1.0f / texture->desc.Width;
texture->size_data.w = 1.0f / texture->desc.Height; texture->size_data.w = 1.0f / texture->desc.Height;
} }
void d3d12_update_texture( void d3d12_update_texture(
@ -413,7 +437,7 @@ void d3d12_upload_texture(D3D12GraphicsCommandList cmd,
for (i = 1; i < texture->desc.MipLevels; i++) for (i = 1; i < texture->desc.MipLevels; i++)
{ {
unsigned width = texture->desc.Width >> i; unsigned width = texture->desc.Width >> i;
unsigned height = texture->desc.Height >> i; unsigned height = texture->desc.Height >> i;
struct struct
{ {
@ -422,11 +446,13 @@ void d3d12_upload_texture(D3D12GraphicsCommandList cmd,
} cbuffer = { i - 1, { 1.0f / width, 1.0f / height } }; } cbuffer = { i - 1, { 1.0f / width, 1.0f / height } };
{ {
D3D12_RESOURCE_BARRIER barrier = { D3D12_RESOURCE_BARRIER_TYPE_TRANSITION }; D3D12_RESOURCE_BARRIER barrier;
barrier.Type = D3D12_RESOURCE_BARRIER_TYPE_TRANSITION;
barrier.Flags = D3D12_RESOURCE_BARRIER_FLAG_NONE;
barrier.Transition.pResource = texture->handle; barrier.Transition.pResource = texture->handle;
barrier.Transition.Subresource = i;
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;
D3D12ResourceBarrier(cmd, 1, &barrier); D3D12ResourceBarrier(cmd, 1, &barrier);
} }
@ -436,17 +462,21 @@ void d3d12_upload_texture(D3D12GraphicsCommandList cmd,
D3D12Dispatch(cmd, (width + 0x7) >> 3, (height + 0x7) >> 3, 1); D3D12Dispatch(cmd, (width + 0x7) >> 3, (height + 0x7) >> 3, 1);
{ {
D3D12_RESOURCE_BARRIER barrier = { D3D12_RESOURCE_BARRIER_TYPE_UAV }; D3D12_RESOURCE_BARRIER barrier;
barrier.Type = D3D12_RESOURCE_BARRIER_TYPE_UAV;
barrier.Flags = D3D12_RESOURCE_BARRIER_FLAG_NONE;
barrier.UAV.pResource = texture->handle; barrier.UAV.pResource = texture->handle;
D3D12ResourceBarrier(cmd, 1, &barrier); D3D12ResourceBarrier(cmd, 1, &barrier);
} }
{ {
D3D12_RESOURCE_BARRIER barrier = { D3D12_RESOURCE_BARRIER_TYPE_TRANSITION }; D3D12_RESOURCE_BARRIER barrier;
barrier.Type = D3D12_RESOURCE_BARRIER_TYPE_TRANSITION;
barrier.Flags = D3D12_RESOURCE_BARRIER_FLAG_NONE;
barrier.Transition.pResource = texture->handle; barrier.Transition.pResource = texture->handle;
barrier.Transition.Subresource = i;
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;
D3D12ResourceBarrier(cmd, 1, &barrier); D3D12ResourceBarrier(cmd, 1, &barrier);
} }
} }

74
gfx/drivers/d3d10.c
View File

@ -168,9 +168,6 @@ static bool d3d10_overlay_load(void* data, const void* image_data, unsigned num_
desc.BindFlags = D3D10_BIND_VERTEX_BUFFER; desc.BindFlags = D3D10_BIND_VERTEX_BUFFER;
desc.CPUAccessFlags = D3D10_CPU_ACCESS_WRITE; desc.CPUAccessFlags = D3D10_CPU_ACCESS_WRITE;
desc.MiscFlags = 0; desc.MiscFlags = 0;
#if 0
desc.StructureByteStride = 0;
#endif
d3d10->device->lpVtbl->CreateBuffer(d3d10->device, &desc, d3d10->device->lpVtbl->CreateBuffer(d3d10->device, &desc,
NULL, &d3d10->overlays.vbo); NULL, &d3d10->overlays.vbo);
d3d10->overlays.vbo->lpVtbl->Map(d3d10->overlays.vbo, d3d10->overlays.vbo->lpVtbl->Map(d3d10->overlays.vbo,
@ -376,6 +373,71 @@ static void d3d10_free_shader_preset(d3d10_video_t* d3d10)
d3d10->resize_render_targets = false; d3d10->resize_render_targets = false;
} }
static bool d3d10_init_shader(
D3D10Device device,
const char* src,
size_t size,
const void* src_name,
LPCSTR vs_entry,
LPCSTR ps_entry,
LPCSTR gs_entry,
const D3D10_INPUT_ELEMENT_DESC* input_element_descs,
UINT num_elements,
d3d10_shader_t* out)
{
D3DBlob vs_code = NULL;
D3DBlob ps_code = NULL;
D3DBlob gs_code = NULL;
bool success = true;
if (!src) /* LPCWSTR filename */
{
if (vs_entry && !d3d_compile_from_file((LPCWSTR)src_name, vs_entry, "vs_4_0", &vs_code))
success = false;
if (ps_entry && !d3d_compile_from_file((LPCWSTR)src_name, ps_entry, "ps_4_0", &ps_code))
success = false;
if (gs_entry && !d3d_compile_from_file((LPCWSTR)src_name, gs_entry, "gs_4_0", &gs_code))
success = false;
}
else /* char array */
{
if (vs_entry && !d3d_compile(src, size, (LPCSTR)src_name, vs_entry, "vs_4_0", &vs_code))
success = false;
if (ps_entry && !d3d_compile(src, size, (LPCSTR)src_name, ps_entry, "ps_4_0", &ps_code))
success = false;
if (gs_entry && !d3d_compile(src, size, (LPCSTR)src_name, gs_entry, "gs_4_0", &gs_code))
success = false;
}
if (ps_code)
device->lpVtbl->CreatePixelShader(device, D3DGetBufferPointer(ps_code),
D3DGetBufferSize(ps_code), &out->ps);
if (gs_code)
device->lpVtbl->CreateGeometryShader(
device, D3DGetBufferPointer(gs_code), D3DGetBufferSize(gs_code),
&out->gs);
if (vs_code)
{
LPVOID buf_ptr = D3DGetBufferPointer(vs_code);
SIZE_T buf_size = D3DGetBufferSize(vs_code);
device->lpVtbl->CreateVertexShader(device, buf_ptr, buf_size, &out->vs);
if (input_element_descs)
device->lpVtbl->CreateInputLayout(
device, (D3D10_INPUT_ELEMENT_DESC*)input_element_descs,
num_elements, buf_ptr, buf_size, &out->layout);
}
Release(vs_code);
Release(ps_code);
Release(gs_code);
return success;
}
static bool d3d10_gfx_set_shader(void* data, enum rarch_shader_type type, const char* path) static bool d3d10_gfx_set_shader(void* data, enum rarch_shader_type type, const char* path)
{ {
#if defined(HAVE_SLANG) && defined(HAVE_SPIRV_CROSS) #if defined(HAVE_SLANG) && defined(HAVE_SPIRV_CROSS)
@ -1234,12 +1296,6 @@ static void d3d10_init_render_targets(d3d10_video_t* d3d10,
} }
d3d10->resize_render_targets = false; d3d10->resize_render_targets = false;
#if 0
error:
d3d10_free_shader_preset(d3d10);
return false;
#endif
} }
static bool d3d10_gfx_frame( static bool d3d10_gfx_frame(

120
gfx/drivers/d3d11.c
View File

@ -519,6 +519,92 @@ static void d3d11_free_shader_preset(d3d11_video_t* d3d11)
d3d11->resize_render_targets = false; d3d11->resize_render_targets = false;
} }
static bool d3d11_init_shader(
D3D11Device device,
const char* src,
size_t size,
const void* src_name,
LPCSTR vs_entry,
LPCSTR ps_entry,
LPCSTR gs_entry,
const D3D11_INPUT_ELEMENT_DESC* input_element_descs,
UINT num_elements,
d3d11_shader_t* out,
enum d3d11_feature_level_hint hint)
{
D3DBlob vs_code = NULL;
D3DBlob ps_code = NULL;
D3DBlob gs_code = NULL;
bool success = true;
const char *vs_str = NULL;
const char *ps_str = NULL;
const char *gs_str = NULL;
switch (hint)
{
case D3D11_FEATURE_LEVEL_HINT_11_0:
case D3D11_FEATURE_LEVEL_HINT_11_1:
case D3D11_FEATURE_LEVEL_HINT_12_0:
case D3D11_FEATURE_LEVEL_HINT_12_1:
case D3D11_FEATURE_LEVEL_HINT_12_2:
vs_str = "vs_5_0";
ps_str = "ps_5_0";
gs_str = "gs_5_0";
break;
case D3D11_FEATURE_LEVEL_HINT_DONTCARE:
default:
vs_str = "vs_4_0";
ps_str = "ps_4_0";
gs_str = "gs_4_0";
break;
}
if (!src) /* LPCWSTR filename */
{
if (vs_entry && !d3d_compile_from_file((LPCWSTR)src_name, vs_entry, vs_str, &vs_code))
success = false;
if (ps_entry && !d3d_compile_from_file((LPCWSTR)src_name, ps_entry, ps_str, &ps_code))
success = false;
if (gs_entry && !d3d_compile_from_file((LPCWSTR)src_name, gs_entry, gs_str, &gs_code))
success = false;
}
else /* char array */
{
if (vs_entry && !d3d_compile(src, size, (LPCSTR)src_name, vs_entry, vs_str, &vs_code))
success = false;
if (ps_entry && !d3d_compile(src, size, (LPCSTR)src_name, ps_entry, ps_str, &ps_code))
success = false;
if (gs_entry && !d3d_compile(src, size, (LPCSTR)src_name, gs_entry, gs_str, &gs_code))
success = false;
}
if (ps_code)
device->lpVtbl->CreatePixelShader(
device, D3DGetBufferPointer(ps_code), D3DGetBufferSize(ps_code),
NULL, &out->ps);
if (gs_code)
device->lpVtbl->CreateGeometryShader(
device, D3DGetBufferPointer(gs_code), D3DGetBufferSize(gs_code),
NULL, &out->gs);
if (vs_code)
{
LPVOID buf_ptr = D3DGetBufferPointer(vs_code);
SIZE_T buf_size = D3DGetBufferSize(vs_code);
device->lpVtbl->CreateVertexShader(device, buf_ptr, buf_size, NULL, &out->vs);
if (input_element_descs)
device->lpVtbl->CreateInputLayout(device, input_element_descs, num_elements,
buf_ptr, buf_size, &out->layout);
}
Release(vs_code);
Release(ps_code);
Release(gs_code);
return success;
}
static bool d3d11_gfx_set_shader(void* data, enum rarch_shader_type type, const char* path) static bool d3d11_gfx_set_shader(void* data, enum rarch_shader_type type, const char* path)
{ {
#if defined(HAVE_SLANG) && defined(HAVE_SPIRV_CROSS) #if defined(HAVE_SLANG) && defined(HAVE_SPIRV_CROSS)
@ -1066,12 +1152,6 @@ static bool d3d11_init_swapchain(d3d11_video_t* d3d11,
/* Check display HDR support and /* Check display HDR support and
initialize ST.2084 support to match initialize ST.2084 support to match
the display's support. */ the display's support. */
#if 0
d3d11->hdr.max_output_nits = 300.0f;
d3d11->hdr.min_output_nits = 0.001f;
d3d11->hdr.max_cll = 0.0f;
d3d11->hdr.max_fall = 0.0f;
#endif
color_space = color_space =
d3d11->hdr.enable d3d11->hdr.enable
? DXGI_COLOR_SPACE_RGB_FULL_G2084_NONE_P2020 ? DXGI_COLOR_SPACE_RGB_FULL_G2084_NONE_P2020
@ -1538,12 +1618,12 @@ static void *d3d11_gfx_init(const video_info_t* video,
blend_desc.RenderTarget[0].RenderTargetWriteMask = D3D11_COLOR_WRITE_ENABLE_ALL; blend_desc.RenderTarget[0].RenderTargetWriteMask = D3D11_COLOR_WRITE_ENABLE_ALL;
d3d11->device->lpVtbl->CreateBlendState(d3d11->device, &blend_desc, &d3d11->blend_enable); d3d11->device->lpVtbl->CreateBlendState(d3d11->device, &blend_desc, &d3d11->blend_enable);
blend_desc.RenderTarget[0].SrcBlend = D3D11_BLEND_ONE; blend_desc.RenderTarget[0].SrcBlend = D3D11_BLEND_ONE;
blend_desc.RenderTarget[0].DestBlend = D3D11_BLEND_ONE; blend_desc.RenderTarget[0].DestBlend = D3D11_BLEND_ONE;
d3d11->device->lpVtbl->CreateBlendState(d3d11->device, &blend_desc, d3d11->device->lpVtbl->CreateBlendState(d3d11->device, &blend_desc,
&d3d11->blend_pipeline); &d3d11->blend_pipeline);
blend_desc.RenderTarget[0].BlendEnable = FALSE; blend_desc.RenderTarget[0].BlendEnable = FALSE;
d3d11->device->lpVtbl->CreateBlendState(d3d11->device, &blend_desc, d3d11->device->lpVtbl->CreateBlendState(d3d11->device, &blend_desc,
&d3d11->blend_disable); &d3d11->blend_disable);
} }
@ -1563,7 +1643,7 @@ static void *d3d11_gfx_init(const video_info_t* video,
desc.ScissorEnable = TRUE; desc.ScissorEnable = TRUE;
d3d11->device->lpVtbl->CreateRasterizerState(d3d11->device, &desc, d3d11->device->lpVtbl->CreateRasterizerState(d3d11->device, &desc,
&d3d11->scissor_enabled); &d3d11->scissor_enabled);
desc.ScissorEnable = FALSE; desc.ScissorEnable = FALSE;
d3d11->device->lpVtbl->CreateRasterizerState(d3d11->device, &desc, d3d11->device->lpVtbl->CreateRasterizerState(d3d11->device, &desc,
&d3d11->scissor_disabled); &d3d11->scissor_disabled);
} }
@ -1583,8 +1663,8 @@ static void *d3d11_gfx_init(const video_info_t* video,
d3d11_gfx_set_shader(d3d11, type, shader_preset); d3d11_gfx_set_shader(d3d11, type, shader_preset);
} }
if (video_driver_get_hw_context()->context_type == RETRO_HW_CONTEXT_DIRECT3D && if ( video_driver_get_hw_context()->context_type == RETRO_HW_CONTEXT_DIRECT3D
video_driver_get_hw_context()->version_major == 11) && video_driver_get_hw_context()->version_major == 11)
{ {
d3d11->hw.enable = true; d3d11->hw.enable = true;
d3d11->hw.iface.interface_type = RETRO_HW_RENDER_INTERFACE_D3D11; d3d11->hw.iface.interface_type = RETRO_HW_RENDER_INTERFACE_D3D11;
@ -1607,10 +1687,11 @@ static void *d3d11_gfx_init(const video_info_t* video,
for (;;) for (;;)
{ {
DXGI_ADAPTER_DESC desc = {0};
char str[128]; char str[128];
union string_list_elem_attr attr = {0}; union string_list_elem_attr attr;
DXGI_ADAPTER_DESC desc = {0};
attr.i = 0;
str[0] = '\0'; str[0] = '\0';
#ifdef __WINRT__ #ifdef __WINRT__
@ -1687,7 +1768,7 @@ static void d3d11_init_history(d3d11_video_t* d3d11, unsigned width, unsigned he
d3d11->frame.texture[i].desc.Format = d3d11->frame.texture[0].desc.Format; d3d11->frame.texture[i].desc.Format = d3d11->frame.texture[0].desc.Format;
d3d11->frame.texture[i].desc.Usage = d3d11->frame.texture[0].desc.Usage; d3d11->frame.texture[i].desc.Usage = d3d11->frame.texture[0].desc.Usage;
d3d11_init_texture(d3d11->device, &d3d11->frame.texture[i]); d3d11_init_texture(d3d11->device, &d3d11->frame.texture[i]);
/* todo: clear texture ? */ /* TODO/FIXME: clear texture ? */
} }
d3d11->init_history = false; d3d11->init_history = false;
} }
@ -1704,7 +1785,6 @@ static void d3d11_init_render_targets(d3d11_video_t* d3d11, unsigned width, unsi
if (pass->fbo.valid) if (pass->fbo.valid)
{ {
switch (pass->fbo.type_x) switch (pass->fbo.type_x)
{ {
case RARCH_SCALE_INPUT: case RARCH_SCALE_INPUT:
@ -1771,7 +1851,7 @@ static void d3d11_init_render_targets(d3d11_video_t* d3d11, unsigned width, unsi
{ {
d3d11->pass[i].feedback.desc = d3d11->pass[i].rt.desc; d3d11->pass[i].feedback.desc = d3d11->pass[i].rt.desc;
d3d11_init_texture(d3d11->device, &d3d11->pass[i].feedback); d3d11_init_texture(d3d11->device, &d3d11->pass[i].feedback);
/* todo: do we need to clear it to black here ? */ /* TODO/FIXME: do we need to clear it to black here ? */
} }
} }
else else
@ -1784,12 +1864,6 @@ static void d3d11_init_render_targets(d3d11_video_t* d3d11, unsigned width, unsi
} }
d3d11->resize_render_targets = false; d3d11->resize_render_targets = false;
#if 0
error:
d3d11_free_shader_preset(d3d11);
return false;
#endif
} }
static bool d3d11_gfx_frame( static bool d3d11_gfx_frame(

6
gfx/drivers/d3d12.c
View File

@ -1995,12 +1995,6 @@ static void d3d12_init_render_targets(d3d12_video_t* d3d12, unsigned width, unsi
} }
d3d12->resize_render_targets = false; d3d12->resize_render_targets = false;
#if 0
error:
d3d12_free_shader_preset(d3d12);
return false;
#endif
} }
static bool d3d12_gfx_frame( static bool d3d12_gfx_frame(