mirror/RetroArch
1
0
Fork 0
mirror of https://github.com/libretro/RetroArch synced 2025-04-09 21:45:45 +00:00
Code Issues Packages Projects Releases Wiki Activity

(D3D11) Get rid of some inlined functions

Browse Source
This commit is contained in:
libretroadmin 2022-05-17 17:04:43 +02:00
parent 7eb9f6b49b
commit de4bfa0805
5 changed files with 56 additions and 201 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

33
gfx/common/d3d11_common.c
View File

@ -128,7 +128,8 @@ void d3d11_init_texture(D3D11Device device, d3d11_texture_t* texture)
texture->desc.Format = d3d11_get_closest_match(device, texture->desc.Format, format_support); texture->desc.Format = d3d11_get_closest_match(device, texture->desc.Format, format_support);
D3D11CreateTexture2D(device, &texture->desc, NULL, &texture->handle); device->lpVtbl->CreateTexture2D(device, &texture->desc, NULL,
&texture->handle);
{ {
D3D11_SHADER_RESOURCE_VIEW_DESC view_desc; D3D11_SHADER_RESOURCE_VIEW_DESC view_desc;
@ -136,11 +137,13 @@ void d3d11_init_texture(D3D11Device device, d3d11_texture_t* texture)
view_desc.ViewDimension = D3D_SRV_DIMENSION_TEXTURE2D; view_desc.ViewDimension = D3D_SRV_DIMENSION_TEXTURE2D;
view_desc.Texture2D.MostDetailedMip = 0; view_desc.Texture2D.MostDetailedMip = 0;
view_desc.Texture2D.MipLevels = -1; view_desc.Texture2D.MipLevels = -1;
D3D11CreateTexture2DShaderResourceView(device, texture->handle, &view_desc, &texture->view); device->lpVtbl->CreateShaderResourceView(device,
(D3D11Resource)texture->handle, &view_desc, &texture->view);
} }
if (is_render_target) if (is_render_target)
D3D11CreateTexture2DRenderTargetView(device, texture->handle, NULL, &texture->rt_view); device->lpVtbl->CreateRenderTargetView(device,
(D3D11Resource)texture->handle, NULL, &texture->rt_view);
else else
{ {
D3D11_TEXTURE2D_DESC desc = texture->desc; D3D11_TEXTURE2D_DESC desc = texture->desc;
@ -149,7 +152,7 @@ void d3d11_init_texture(D3D11Device device, d3d11_texture_t* texture)
desc.MiscFlags = 0; desc.MiscFlags = 0;
desc.Usage = D3D11_USAGE_STAGING; desc.Usage = D3D11_USAGE_STAGING;
desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE; desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
D3D11CreateTexture2D(device, &desc, NULL, &texture->staging); device->lpVtbl->CreateTexture2D(device, &desc, NULL, &texture->staging);
} }
texture->size_data.x = texture->desc.Width; texture->size_data.x = texture->desc.Width;
@ -195,7 +198,7 @@ void d3d11_update_texture(
(D3D11Resource)texture->staging, 0, &frame_box); (D3D11Resource)texture->staging, 0, &frame_box);
if (texture->desc.MiscFlags & D3D11_RESOURCE_MISC_GENERATE_MIPS) if (texture->desc.MiscFlags & D3D11_RESOURCE_MISC_GENERATE_MIPS)
D3D11GenerateMips(ctx, texture->view); ctx->lpVtbl->GenerateMips(ctx, texture->view);
} }
DXGI_FORMAT DXGI_FORMAT
@ -210,7 +213,8 @@ d3d11_get_closest_match(D3D11Device device, DXGI_FORMAT desired_format, UINT des
while (*format != DXGI_FORMAT_UNKNOWN) while (*format != DXGI_FORMAT_UNKNOWN)
{ {
UINT format_support; UINT format_support;
if (SUCCEEDED(D3D11CheckFormatSupport(device, *format, &format_support)) && if (SUCCEEDED(device->lpVtbl->CheckFormatSupport(device, *format,
&format_support)) &&
((format_support & desired_format_support) == desired_format_support)) ((format_support & desired_format_support) == desired_format_support))
break; break;
format++; format++;
@ -279,19 +283,22 @@ bool d3d11_init_shader(
} }
if (vs_code) if (vs_code)
D3D11CreateVertexShader( device->lpVtbl->CreateVertexShader(
device, D3DGetBufferPointer(vs_code), D3DGetBufferSize(vs_code), NULL, &out->vs); device, D3DGetBufferPointer(vs_code), D3DGetBufferSize(vs_code),
NULL, &out->vs);
if (ps_code) if (ps_code)
D3D11CreatePixelShader( device->lpVtbl->CreatePixelShader(
device, D3DGetBufferPointer(ps_code), D3DGetBufferSize(ps_code), NULL, &out->ps); device, D3DGetBufferPointer(ps_code), D3DGetBufferSize(ps_code),
NULL, &out->ps);
if (gs_code) if (gs_code)
D3D11CreateGeometryShader( device->lpVtbl->CreateGeometryShader(
device, D3DGetBufferPointer(gs_code), D3DGetBufferSize(gs_code), NULL, &out->gs); device, D3DGetBufferPointer(gs_code), D3DGetBufferSize(gs_code),
NULL, &out->gs);
if (vs_code && input_element_descs) if (vs_code && input_element_descs)
D3D11CreateInputLayout( device->lpVtbl->CreateInputLayout(
device, input_element_descs, num_elements, D3DGetBufferPointer(vs_code), device, input_element_descs, num_elements, D3DGetBufferPointer(vs_code),
D3DGetBufferSize(vs_code), &out->layout); D3DGetBufferSize(vs_code), &out->layout);

175
gfx/common/d3d11_common.h
View File

@ -295,171 +295,6 @@ typedef struct
d3d11_texture_t luts[GFX_MAX_TEXTURES]; d3d11_texture_t luts[GFX_MAX_TEXTURES];
} d3d11_video_t; } d3d11_video_t;
#if !defined(__cplusplus) || defined(CINTERFACE)
static INLINE void D3D11GetTexture2DDesc(D3D11Texture2D texture2d, D3D11_TEXTURE2D_DESC* desc)
{
texture2d->lpVtbl->GetDesc(texture2d, desc);
}
static INLINE void D3D11GetShaderResourceViewResource(
D3D11ShaderResourceView shader_resource_view, D3D11Resource* resource)
{
shader_resource_view->lpVtbl->GetResource(shader_resource_view, resource);
}
static INLINE void D3D11GetShaderResourceViewTexture2D(
D3D11ShaderResourceView shader_resource_view, D3D11Texture2D* texture2d)
{
shader_resource_view->lpVtbl->GetResource(shader_resource_view, (D3D11Resource*)texture2d);
}
static INLINE void D3D11GetShaderResourceViewDesc(
D3D11ShaderResourceView shader_resource_view, D3D11_SHADER_RESOURCE_VIEW_DESC* desc)
{
shader_resource_view->lpVtbl->GetDesc(shader_resource_view, desc);
}
static INLINE void D3D11SetPShaderResources(
D3D11DeviceContext device_context,
UINT start_slot,
UINT num_views,
ID3D11ShaderResourceView* const* shader_resource_views)
{
device_context->lpVtbl->PSSetShaderResources(
device_context, start_slot, num_views,
shader_resource_views);
}
static INLINE void
D3D11GenerateMips(D3D11DeviceContext device_context, D3D11ShaderResourceView shader_resource_view)
{
device_context->lpVtbl->GenerateMips(device_context, shader_resource_view);
}
static INLINE void
D3D11GetState(D3D11DeviceContext device_context, D3D11RasterizerState* rasterizer_state)
{
device_context->lpVtbl->RSGetState(device_context, rasterizer_state);
}
static INLINE HRESULT D3D11CreateBuffer(
D3D11Device device,
D3D11_BUFFER_DESC* desc,
D3D11_SUBRESOURCE_DATA* initial_data,
D3D11Buffer* buffer)
{
return device->lpVtbl->CreateBuffer(device, desc, initial_data, buffer);
}
static INLINE HRESULT D3D11CreateTexture2D(
D3D11Device device,
D3D11_TEXTURE2D_DESC* desc,
D3D11_SUBRESOURCE_DATA* initial_data,
D3D11Texture2D* texture2d)
{
return device->lpVtbl->CreateTexture2D(device, desc, initial_data, texture2d);
}
static INLINE HRESULT D3D11CreateShaderResourceView(
D3D11Device device,
D3D11Resource resource,
D3D11_SHADER_RESOURCE_VIEW_DESC* desc,
D3D11ShaderResourceView* srview)
{
return device->lpVtbl->CreateShaderResourceView(device, resource, desc, srview);
}
static INLINE HRESULT D3D11CreateRenderTargetView(
D3D11Device device,
D3D11Resource resource,
D3D11_RENDER_TARGET_VIEW_DESC* desc,
D3D11RenderTargetView* rtview)
{
return device->lpVtbl->CreateRenderTargetView(device, resource, desc, rtview);
}
static INLINE HRESULT D3D11CreateDepthStencilView(
D3D11Device device,
D3D11Resource resource,
D3D11_DEPTH_STENCIL_VIEW_DESC* desc,
D3D11DepthStencilView* depth_stencil_view)
{
return device->lpVtbl->CreateDepthStencilView(device, resource, desc, depth_stencil_view);
}
static INLINE HRESULT D3D11CreateInputLayout(
D3D11Device device,
const D3D11_INPUT_ELEMENT_DESC* input_element_descs,
UINT num_elements,
void* shader_bytecode_with_input_signature,
SIZE_T bytecode_length,
D3D11InputLayout* input_layout)
{
return device->lpVtbl->CreateInputLayout(
device, input_element_descs, num_elements, shader_bytecode_with_input_signature,
bytecode_length, input_layout);
}
static INLINE HRESULT D3D11CreateVertexShader(
D3D11Device device,
void* shader_bytecode,
SIZE_T bytecode_length,
D3D11ClassLinkage class_linkage,
D3D11VertexShader* vertex_shader)
{
return device->lpVtbl->CreateVertexShader(
device, shader_bytecode, bytecode_length, class_linkage, vertex_shader);
}
static INLINE HRESULT D3D11CreateGeometryShader(
D3D11Device device,
void* shader_bytecode,
SIZE_T bytecode_length,
D3D11ClassLinkage class_linkage,
D3D11GeometryShader* geometry_shader)
{
return device->lpVtbl->CreateGeometryShader(
device, shader_bytecode, bytecode_length, class_linkage, geometry_shader);
}
static INLINE HRESULT D3D11CreatePixelShader(
D3D11Device device,
void* shader_bytecode,
SIZE_T bytecode_length,
D3D11ClassLinkage class_linkage,
D3D11PixelShader* pixel_shader)
{
return device->lpVtbl->CreatePixelShader(
device, shader_bytecode, bytecode_length, class_linkage, pixel_shader);
}
static INLINE HRESULT
D3D11CheckFormatSupport(D3D11Device device, DXGI_FORMAT format, UINT* format_support)
{
return device->lpVtbl->CheckFormatSupport(device, format, format_support);
}
static INLINE D3D_FEATURE_LEVEL D3D11GetFeatureLevel(D3D11Device device)
{
return device->lpVtbl->GetFeatureLevel(device);
}
/* end of auto-generated */
static INLINE HRESULT D3D11CreateTexture2DRenderTargetView(
D3D11Device device,
D3D11Texture2D texture,
D3D11_RENDER_TARGET_VIEW_DESC* desc,
D3D11RenderTargetView* rtview)
{
return device->lpVtbl->CreateRenderTargetView(device, (D3D11Resource)texture, desc, rtview);
}
static INLINE HRESULT D3D11CreateTexture2DShaderResourceView(
D3D11Device device,
D3D11Texture2D texture,
D3D11_SHADER_RESOURCE_VIEW_DESC* desc,
D3D11ShaderResourceView* srview)
{
return device->lpVtbl->CreateShaderResourceView(device, (D3D11Resource)texture, desc, srview);
}
#endif
void d3d11_init_texture(D3D11Device device, d3d11_texture_t* texture);
static INLINE void d3d11_release_texture(d3d11_texture_t* texture) static INLINE void d3d11_release_texture(d3d11_texture_t* texture)
{ {
Release(texture->handle); Release(texture->handle);
@ -468,6 +303,8 @@ static INLINE void d3d11_release_texture(d3d11_texture_t* texture)
Release(texture->rt_view); Release(texture->rt_view);
} }
void d3d11_init_texture(D3D11Device device, d3d11_texture_t* texture);
void d3d11_update_texture( void d3d11_update_texture(
D3D11DeviceContext ctx, D3D11DeviceContext ctx,
unsigned width, unsigned width,
@ -492,11 +329,3 @@ bool d3d11_init_shader(
UINT num_elements, UINT num_elements,
d3d11_shader_t* out, d3d11_shader_t* out,
enum d3d11_feature_level_hint hint); enum d3d11_feature_level_hint hint);
static INLINE void d3d11_release_shader(d3d11_shader_t* shader)
{
Release(shader->layout);
Release(shader->vs);
Release(shader->ps);
Release(shader->gs);
}

40
gfx/drivers/d3d11.c
View File

@ -82,6 +82,14 @@ static D3D11Device cached_device_d3d11;
static D3D_FEATURE_LEVEL cached_supportedFeatureLevel; static D3D_FEATURE_LEVEL cached_supportedFeatureLevel;
static D3D11DeviceContext cached_context_d3d11; static D3D11DeviceContext cached_context_d3d11;
static INLINE void d3d11_release_shader(d3d11_shader_t* shader)
{
Release(shader->layout);
Release(shader->vs);
Release(shader->ps);
Release(shader->gs);
}
static uint32_t d3d11_get_flags(void *data) static uint32_t d3d11_get_flags(void *data)
{ {
uint32_t flags = 0; uint32_t flags = 0;
@ -192,7 +200,8 @@ static bool d3d11_overlay_load(void* data, const void* image_data, unsigned num_
desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE; desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
desc.MiscFlags = 0; desc.MiscFlags = 0;
desc.StructureByteStride = 0; desc.StructureByteStride = 0;
D3D11CreateBuffer(d3d11->device, &desc, NULL, &d3d11->overlays.vbo); d3d11->device->lpVtbl->CreateBuffer(d3d11->device, &desc, NULL,
&d3d11->overlays.vbo);
d3d11->context->lpVtbl->Map( d3d11->context->lpVtbl->Map(
d3d11->context, (D3D11Resource)d3d11->overlays.vbo, 0, D3D11_MAP_WRITE_DISCARD, 0, &mapped_vbo); d3d11->context, (D3D11Resource)d3d11->overlays.vbo, 0, D3D11_MAP_WRITE_DISCARD, 0, &mapped_vbo);
@ -665,7 +674,7 @@ static bool d3d11_gfx_set_shader(void* data, enum rarch_shader_type type, const
if (!desc.ByteWidth) if (!desc.ByteWidth)
continue; continue;
D3D11CreateBuffer(d3d11->device, &desc, NULL, &d3d11->pass[i].buffers[j]); d3d11->device->lpVtbl->CreateBuffer(d3d11->device, &desc, NULL, &d3d11->pass[i].buffers[j]);
} }
} }
@ -1223,8 +1232,10 @@ static void *d3d11_gfx_init(const video_info_t* video,
ubo_data.SysMemPitch = 0; ubo_data.SysMemPitch = 0;
ubo_data.SysMemSlicePitch = 0; ubo_data.SysMemSlicePitch = 0;
D3D11CreateBuffer(d3d11->device, &desc, &ubo_data, &d3d11->ubo); d3d11->device->lpVtbl->CreateBuffer(d3d11->device, &desc, &ubo_data,
D3D11CreateBuffer(d3d11->device, &desc, NULL, &d3d11->frame.ubo); &d3d11->ubo);
d3d11->device->lpVtbl->CreateBuffer(d3d11->device, &desc, NULL,
&d3d11->frame.ubo);
} }
d3d11_gfx_set_rotation(d3d11, 0); d3d11_gfx_set_rotation(d3d11, 0);
@ -1260,7 +1271,8 @@ static void *d3d11_gfx_init(const video_info_t* video,
ubo_data.SysMemPitch = 0; ubo_data.SysMemPitch = 0;
ubo_data.SysMemSlicePitch = 0; ubo_data.SysMemSlicePitch = 0;
D3D11CreateBuffer(d3d11->device, &desc, &ubo_data, &d3d11->hdr.ubo); d3d11->device->lpVtbl->CreateBuffer(d3d11->device, &desc, &ubo_data,
&d3d11->hdr.ubo);
} }
#endif #endif
@ -1330,14 +1342,17 @@ static void *d3d11_gfx_init(const video_info_t* video,
desc.MiscFlags = 0; desc.MiscFlags = 0;
desc.StructureByteStride = 0; desc.StructureByteStride = 0;
D3D11CreateBuffer(d3d11->device, &desc, &vertex_data, &d3d11->frame.vbo); d3d11->device->lpVtbl->CreateBuffer(d3d11->device, &desc, &vertex_data,
&d3d11->frame.vbo);
desc.Usage = D3D11_USAGE_DYNAMIC; desc.Usage = D3D11_USAGE_DYNAMIC;
desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE; desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
D3D11CreateBuffer(d3d11->device, &desc, &vertex_data, &d3d11->menu.vbo); d3d11->device->lpVtbl->CreateBuffer(d3d11->device, &desc, &vertex_data,
&d3d11->menu.vbo);
d3d11->sprites.capacity = 16 * 1024; d3d11->sprites.capacity = 16 * 1024;
desc.ByteWidth = sizeof(d3d11_sprite_t) * d3d11->sprites.capacity; desc.ByteWidth = sizeof(d3d11_sprite_t) * d3d11->sprites.capacity;
D3D11CreateBuffer(d3d11->device, &desc, NULL, &d3d11->sprites.vbo); d3d11->device->lpVtbl->CreateBuffer(d3d11->device, &desc, NULL,
&d3d11->sprites.vbo);
} }
#ifdef HAVE_DXGI_HDR #ifdef HAVE_DXGI_HDR
@ -1895,8 +1910,9 @@ static bool d3d11_gfx_frame(
{ {
D3D11Texture2D back_buffer; D3D11Texture2D back_buffer;
d3d11->swapChain->lpVtbl->GetBuffer(d3d11->swapChain, 0, d3d11->swapChain->lpVtbl->GetBuffer(d3d11->swapChain, 0,
uuidof(ID3D11Texture2D), (void**)&back_buffer); uuidof(ID3D11Texture2D), (void**)&back_buffer);
D3D11CreateTexture2DRenderTargetView(d3d11->device, back_buffer, NULL, &rtv); d3d11->device->lpVtbl->CreateRenderTargetView(d3d11->device,
(D3D11Resource)back_buffer, NULL, &rtv);
Release(back_buffer); Release(back_buffer);
} }
@ -1914,8 +1930,8 @@ uuidof(ID3D11Texture2D), (void**)&back_buffer);
D3D11_SHADER_RESOURCE_VIEW_DESC hw_desc; D3D11_SHADER_RESOURCE_VIEW_DESC hw_desc;
D3D11ShaderResourceView hw_view = NULL; D3D11ShaderResourceView hw_view = NULL;
context->lpVtbl->PSGetShaderResources(context, 0, 1, &hw_view); context->lpVtbl->PSGetShaderResources(context, 0, 1, &hw_view);
D3D11GetShaderResourceViewDesc(hw_view, &hw_desc); hw_view->lpVtbl->GetDesc(hw_view, &hw_desc);
D3D11GetShaderResourceViewTexture2D(hw_view, &hw_texture); hw_view->lpVtbl->GetResource(hw_view, (D3D11Resource*)&hw_texture);
if (d3d11->frame.texture[0].desc.Format != hw_desc.Format) if (d3d11->frame.texture[0].desc.Format != hw_desc.Format)
{ {

6
gfx/drivers_display/gfx_display_d3d11.c
View File

@ -173,7 +173,8 @@ static void gfx_display_d3d11_draw(gfx_display_ctx_draw_t *draw,
{ {
d3d11_texture_t *texture = (d3d11_texture_t*)draw->texture; d3d11_texture_t *texture = (d3d11_texture_t*)draw->texture;
D3D11SetPShaderResources(d3d11->context, 0, 1, &texture->view); d3d11->context->lpVtbl->PSSetShaderResources(
d3d11->context, 0, 1, &texture->view);
d3d11->context->lpVtbl->PSSetSamplers( d3d11->context->lpVtbl->PSSetSamplers(
d3d11->context, 0, 1, (D3D11SamplerState*)&texture->sampler); d3d11->context, 0, 1, (D3D11SamplerState*)&texture->sampler);
} }
@ -224,7 +225,8 @@ static void gfx_display_d3d11_draw_pipeline(gfx_display_ctx_draw_t *draw,
vertex_data.pSysMem = ca->coords.vertex; vertex_data.pSysMem = ca->coords.vertex;
vertex_data.SysMemPitch = 0; vertex_data.SysMemPitch = 0;
vertex_data.SysMemSlicePitch = 0; vertex_data.SysMemSlicePitch = 0;
D3D11CreateBuffer(d3d11->device, &desc, &vertex_data, &d3d11->menu_pipeline_vbo); d3d11->device->lpVtbl->CreateBuffer(d3d11->device, &desc, &vertex_data,
&d3d11->menu_pipeline_vbo);
} }
} }
{ {

3
gfx/drivers_font/d3d11_font.c
View File

@ -219,7 +219,8 @@ static void d3d11_font_render_line(
{ {
d3d11_texture_t *texture = (d3d11_texture_t*)&font->texture; d3d11_texture_t *texture = (d3d11_texture_t*)&font->texture;
D3D11SetPShaderResources(d3d11->context, 0, 1, &texture->view); d3d11->context->lpVtbl->PSSetShaderResources(
d3d11->context, 0, 1, &texture->view);
d3d11->context->lpVtbl->PSSetSamplers( d3d11->context->lpVtbl->PSSetSamplers(
d3d11->context, 0, 1, d3d11->context, 0, 1,
(D3D11SamplerState*)&texture->sampler); (D3D11SamplerState*)&texture->sampler);