mirror/RetroArch
1
0
Fork 0
mirror of https://github.com/libretro/RetroArch synced 2025-03-29 22:20:21 +00:00
Code Issues Packages Projects Releases Wiki Activity

(D3D/Vulkan) Try to prevent implicit memsets

Browse Source
This commit is contained in:
libretroadmin 2022-05-16 21:37:02 +02:00
parent c8e3ae09e7
commit bfa627737e
5 changed files with 227 additions and 189 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

35
gfx/drivers/d3d10.c
View File

@ -815,25 +815,27 @@ static void *d3d10_gfx_init(const video_info_t* video,
{
D3D10_BUFFER_DESC desc;
d3d10_vertex_t vertices[] = {
D3D10_SUBRESOURCE_DATA vertex_data;
d3d10_vertex_t vertices[] = {
{ { 0.0f, 0.0f }, { 0.0f, 1.0f }, { 1.0f, 1.0f, 1.0f, 1.0f } },
{ { 0.0f, 1.0f }, { 0.0f, 0.0f }, { 1.0f, 1.0f, 1.0f, 1.0f } },
{ { 1.0f, 0.0f }, { 1.0f, 1.0f }, { 1.0f, 1.0f, 1.0f, 1.0f } },
{ { 1.0f, 1.0f }, { 1.0f, 0.0f }, { 1.0f, 1.0f, 1.0f, 1.0f } },
};
D3D10_SUBRESOURCE_DATA
vertexData = { vertices };
vertex_data.pSysMem = vertices;
vertex_data.SysMemPitch = 0;
vertex_data.SysMemSlicePitch = 0;
desc.ByteWidth = sizeof(vertices);
desc.Usage = D3D10_USAGE_IMMUTABLE;
desc.BindFlags = D3D10_BIND_VERTEX_BUFFER;
desc.CPUAccessFlags = 0;
desc.MiscFlags = 0;
desc.ByteWidth = sizeof(vertices);
desc.Usage = D3D10_USAGE_IMMUTABLE;
desc.BindFlags = D3D10_BIND_VERTEX_BUFFER;
desc.CPUAccessFlags = 0;
desc.MiscFlags = 0;
D3D10CreateBuffer(d3d10->device, &desc, &vertexData, &d3d10->frame.vbo);
desc.Usage = D3D10_USAGE_DYNAMIC;
desc.CPUAccessFlags = D3D10_CPU_ACCESS_WRITE;
D3D10CreateBuffer(d3d10->device, &desc, &vertexData, &d3d10->menu.vbo);
D3D10CreateBuffer(d3d10->device, &desc, &vertex_data, &d3d10->frame.vbo);
desc.Usage = D3D10_USAGE_DYNAMIC;
desc.CPUAccessFlags = D3D10_CPU_ACCESS_WRITE;
D3D10CreateBuffer(d3d10->device, &desc, &vertex_data, &d3d10->menu.vbo);
d3d10->sprites.capacity = 16 * 1024;
desc.ByteWidth = sizeof(d3d10_sprite_t) * d3d10->sprites.capacity;
@ -982,11 +984,18 @@ static void *d3d10_gfx_init(const video_info_t* video,
}
{
D3D10_RASTERIZER_DESC desc = { (D3D10_FILL_MODE)0 };
D3D10_RASTERIZER_DESC desc;
desc.FillMode = D3D10_FILL_SOLID;
desc.CullMode = D3D10_CULL_NONE;
desc.FrontCounterClockwise = FALSE;
desc.DepthBias = 0;
desc.DepthBiasClamp = 0.0f;
desc.SlopeScaledDepthBias = 0.0f;
desc.DepthClipEnable = FALSE;
desc.ScissorEnable = TRUE;
desc.MultisampleEnable = FALSE;
desc.AntialiasedLineEnable = FALSE;
D3D10CreateRasterizerState(d3d10->device, &desc, &d3d10->state);
}

52
gfx/drivers/d3d11.c
View File

@ -1315,20 +1315,23 @@ static void *d3d11_gfx_init(const video_info_t* video,
{ { 1.0f, 0.0f }, { 1.0f, 1.0f }, { 1.0f, 1.0f, 1.0f, 1.0f } },
{ { 1.0f, 1.0f }, { 1.0f, 0.0f }, { 1.0f, 1.0f, 1.0f, 1.0f } },
};
D3D11_SUBRESOURCE_DATA
vertexData = { vertices };
D3D11_SUBRESOURCE_DATA vertex_data;
desc.ByteWidth = sizeof(vertices);
desc.Usage = D3D11_USAGE_IMMUTABLE;
desc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
desc.CPUAccessFlags = 0;
desc.MiscFlags = 0;
desc.StructureByteStride = 0;
vertex_data.pSysMem = vertices;
vertex_data.SysMemPitch = 0;
vertex_data.SysMemSlicePitch = 0;
D3D11CreateBuffer(d3d11->device, &desc, &vertexData, &d3d11->frame.vbo);
desc.Usage = D3D11_USAGE_DYNAMIC;
desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
D3D11CreateBuffer(d3d11->device, &desc, &vertexData, &d3d11->menu.vbo);
desc.ByteWidth = sizeof(vertices);
desc.Usage = D3D11_USAGE_IMMUTABLE;
desc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
desc.CPUAccessFlags = 0;
desc.MiscFlags = 0;
desc.StructureByteStride = 0;
D3D11CreateBuffer(d3d11->device, &desc, &vertex_data, &d3d11->frame.vbo);
desc.Usage = D3D11_USAGE_DYNAMIC;
desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
D3D11CreateBuffer(d3d11->device, &desc, &vertex_data, &d3d11->menu.vbo);
d3d11->sprites.capacity = 16 * 1024;
desc.ByteWidth = sizeof(d3d11_sprite_t) * d3d11->sprites.capacity;
@ -1528,15 +1531,21 @@ static void *d3d11_gfx_init(const video_info_t* video,
&d3d11->blend_disable);
}
{
D3D11_RASTERIZER_DESC desc = { (D3D11_FILL_MODE)0 };
D3D11_RASTERIZER_DESC desc;
desc.FillMode = D3D11_FILL_SOLID;
desc.CullMode = D3D11_CULL_NONE;
desc.FillMode = D3D11_FILL_SOLID;
desc.CullMode = D3D11_CULL_NONE;
desc.FrontCounterClockwise = false;
desc.DepthBias = 0;
desc.DepthBiasClamp = 0.0f;
desc.SlopeScaledDepthBias = 0.0f;
desc.DepthClipEnable = FALSE;
desc.MultisampleEnable = FALSE;
desc.AntialiasedLineEnable = FALSE;
desc.ScissorEnable = TRUE;
desc.ScissorEnable = TRUE;
d3d11->device->lpVtbl->CreateRasterizerState(d3d11->device, &desc,
&d3d11->scissor_enabled);
desc.ScissorEnable = FALSE;
d3d11->device->lpVtbl->CreateRasterizerState(d3d11->device, &desc,
&d3d11->scissor_disabled);
@ -1966,13 +1975,18 @@ uuidof(ID3D11Texture2D), (void**)&back_buffer);
if (hw_texture)
{
D3D11_BOX frame_box = { 0, 0, 0, width, height, 1 };
D3D11_BOX frame_box;
frame_box.left = 0;
frame_box.top = 0;
frame_box.front = 0;
frame_box.right = width;
frame_box.bottom = height;
frame_box.back = 1;
context->lpVtbl->CopySubresourceRegion(
context,
(D3D11Resource)d3d11->frame.texture[0].handle,
0, 0, 0, 0,
(D3D11Resource)hw_texture, 0, &frame_box);
Release(hw_texture);
hw_texture = NULL;
}

120
gfx/drivers/d3d12.c
View File

@ -92,34 +92,38 @@ static void d3d12_free_overlays(d3d12_video_t* d3d12)
static void
d3d12_overlay_vertex_geom(void* data, unsigned index, float x, float y, float w, float h)
{
D3D12_RANGE range;
d3d12_sprite_t* sprites = NULL;
D3D12_RANGE range = { 0, 0 };
d3d12_video_t* d3d12 = (d3d12_video_t*)data;
if (!d3d12)
return;
range.Begin = 0;
range.End = 0;
D3D12Map(d3d12->overlays.vbo, 0, &range, (void**)&sprites);
sprites[index].pos.x = x;
sprites[index].pos.y = y;
sprites[index].pos.w = w;
sprites[index].pos.h = h;
sprites[index].pos.x = x;
sprites[index].pos.y = y;
sprites[index].pos.w = w;
sprites[index].pos.h = h;
range.Begin = index * sizeof(*sprites);
range.End = range.Begin + sizeof(*sprites);
range.Begin = index * sizeof(*sprites);
range.End = range.Begin + sizeof(*sprites);
D3D12Unmap(d3d12->overlays.vbo, 0, &range);
}
static void d3d12_overlay_tex_geom(void* data, unsigned index, float u, float v, float w, float h)
{
D3D12_RANGE range;
d3d12_sprite_t* sprites = NULL;
D3D12_RANGE range = { 0, 0 };
d3d12_video_t* d3d12 = (d3d12_video_t*)data;
if (!d3d12)
return;
range.Begin = 0;
range.End = 0;
D3D12Map(d3d12->overlays.vbo, 0, &range, (void**)&sprites);
sprites[index].coords.u = u;
@ -134,13 +138,15 @@ static void d3d12_overlay_tex_geom(void* data, unsigned index, float u, float v,
static void d3d12_overlay_set_alpha(void* data, unsigned index, float mod)
{
d3d12_sprite_t* sprites = NULL;
D3D12_RANGE range = { 0, 0 };
d3d12_video_t* d3d12 = (d3d12_video_t*)data;
D3D12_RANGE range;
d3d12_sprite_t* sprites = NULL;
d3d12_video_t* d3d12 = (d3d12_video_t*)data;
if (!d3d12)
return;
range.Begin = 0;
range.End = 0;
D3D12Map(d3d12->overlays.vbo, 0, &range, (void**)&sprites);
sprites[index].colors[0] = DXGI_COLOR_RGBA(0xFF, 0xFF, 0xFF, mod * 0xFF);
@ -155,9 +161,9 @@ static void d3d12_overlay_set_alpha(void* data, unsigned index, float mod)
static bool d3d12_overlay_load(void* data, const void* image_data, unsigned num_images)
{
D3D12_RANGE range;
unsigned i;
d3d12_sprite_t* sprites = NULL;
D3D12_RANGE range = { 0, 0 };
d3d12_video_t* d3d12 = (d3d12_video_t*)data;
const struct texture_image* images = (const struct texture_image*)image_data;
@ -175,38 +181,40 @@ static bool d3d12_overlay_load(void* data, const void* image_data, unsigned num_
d3d12->overlays.vbo_view.BufferLocation = d3d12_create_buffer(
d3d12->device, d3d12->overlays.vbo_view.SizeInBytes, &d3d12->overlays.vbo);
range.Begin = 0;
range.End = 0;
D3D12Map(d3d12->overlays.vbo, 0, &range, (void**)&sprites);
for (i = 0; i < num_images; i++)
{
d3d12->overlays.textures[i].desc.Width = images[i].width;
d3d12->overlays.textures[i].desc.Height = images[i].height;
d3d12->overlays.textures[i].desc.Format = DXGI_FORMAT_B8G8R8A8_UNORM;
d3d12->overlays.textures[i].srv_heap = &d3d12->desc.srv_heap;
d3d12_init_texture(d3d12->device, &d3d12->overlays.textures[i]);
d3d12_init_texture(d3d12->device, &d3d12->overlays.textures[i]);
d3d12_update_texture(
images[i].width, images[i].height, 0, DXGI_FORMAT_B8G8R8A8_UNORM, images[i].pixels,
images[i].width, images[i].height,
0, DXGI_FORMAT_B8G8R8A8_UNORM, images[i].pixels,
&d3d12->overlays.textures[i]);
sprites[i].pos.x = 0.0f;
sprites[i].pos.y = 0.0f;
sprites[i].pos.w = 1.0f;
sprites[i].pos.h = 1.0f;
sprites[i].pos.x = 0.0f;
sprites[i].pos.y = 0.0f;
sprites[i].pos.w = 1.0f;
sprites[i].pos.h = 1.0f;
sprites[i].coords.u = 0.0f;
sprites[i].coords.v = 0.0f;
sprites[i].coords.w = 1.0f;
sprites[i].coords.h = 1.0f;
sprites[i].coords.u = 0.0f;
sprites[i].coords.v = 0.0f;
sprites[i].coords.w = 1.0f;
sprites[i].coords.h = 1.0f;
sprites[i].params.scaling = 1;
sprites[i].params.rotation = 0;
sprites[i].colors[0] = 0xFFFFFFFF;
sprites[i].colors[1] = sprites[i].colors[0];
sprites[i].colors[2] = sprites[i].colors[0];
sprites[i].colors[3] = sprites[i].colors[0];
sprites[i].colors[0] = 0xFFFFFFFF;
sprites[i].colors[1] = sprites[i].colors[0];
sprites[i].colors[2] = sprites[i].colors[0];
sprites[i].colors[3] = sprites[i].colors[0];
}
D3D12Unmap(d3d12->overlays.vbo, 0, NULL);
@ -289,15 +297,17 @@ static void d3d12_render_overlay(d3d12_video_t *d3d12)
#ifdef HAVE_DXGI_HDR
static void d3d12_set_hdr_max_nits(void* data, float max_nits)
{
D3D12_RANGE read_range;
dxgi_hdr_uniform_t *mapped_ubo = NULL;
D3D12_RANGE read_range = { 0, 0 };
d3d12_video_t *d3d12 = (d3d12_video_t*)data;
d3d12->hdr.max_output_nits = max_nits;
d3d12->hdr.ubo_values.max_nits = max_nits;
read_range.Begin = 0;
read_range.End = 0;
D3D12Map(d3d12->hdr.ubo, 0, &read_range, (void**)&mapped_ubo);
*mapped_ubo = d3d12->hdr.ubo_values;
*mapped_ubo = d3d12->hdr.ubo_values;
D3D12Unmap(d3d12->hdr.ubo, 0, NULL);
dxgi_set_hdr_metadata(
@ -313,12 +323,14 @@ static void d3d12_set_hdr_max_nits(void* data, float max_nits)
static void d3d12_set_hdr_paper_white_nits(void* data, float paper_white_nits)
{
D3D12_RANGE read_range = { 0, 0 };
D3D12_RANGE read_range;
dxgi_hdr_uniform_t *mapped_ubo = NULL;
d3d12_video_t *d3d12 = (d3d12_video_t*)data;
d3d12->hdr.ubo_values.paper_white_nits = paper_white_nits;
read_range.Begin = 0;
read_range.End = 0;
D3D12Map(d3d12->hdr.ubo, 0, &read_range, (void**)&mapped_ubo);
*mapped_ubo = d3d12->hdr.ubo_values;
D3D12Unmap(d3d12->hdr.ubo, 0, NULL);
@ -326,12 +338,14 @@ static void d3d12_set_hdr_paper_white_nits(void* data, float paper_white_nits)
static void d3d12_set_hdr_contrast(void* data, float contrast)
{
D3D12_RANGE read_range = { 0, 0 };
D3D12_RANGE read_range;
d3d12_video_t *d3d12 = (d3d12_video_t*)data;
dxgi_hdr_uniform_t *mapped_ubo = NULL;
d3d12->hdr.ubo_values.contrast = contrast;
read_range.Begin = 0;
read_range.End = 0;
D3D12Map(d3d12->hdr.ubo, 0, &read_range, (void**)&mapped_ubo);
*mapped_ubo = d3d12->hdr.ubo_values;
D3D12Unmap(d3d12->hdr.ubo, 0, NULL);
@ -339,12 +353,14 @@ static void d3d12_set_hdr_contrast(void* data, float contrast)
static void d3d12_set_hdr_expand_gamut(void* data, bool expand_gamut)
{
D3D12_RANGE read_range = { 0, 0 };
D3D12_RANGE read_range;
dxgi_hdr_uniform_t *mapped_ubo = NULL;
d3d12_video_t *d3d12 = (d3d12_video_t*)data;
d3d12->hdr.ubo_values.expand_gamut = expand_gamut ? 1.0f : 0.0f;
read_range.Begin = 0;
read_range.End = 0;
D3D12Map(d3d12->hdr.ubo, 0, &read_range, (void**)&mapped_ubo);
*mapped_ubo = d3d12->hdr.ubo_values;
D3D12Unmap(d3d12->hdr.ubo, 0, NULL);
@ -352,11 +368,13 @@ static void d3d12_set_hdr_expand_gamut(void* data, bool expand_gamut)
static void d3d12_set_hdr_inverse_tonemap(d3d12_video_t* d3d12, bool inverse_tonemap)
{
D3D12_RANGE read_range = { 0, 0 };
D3D12_RANGE read_range;
dxgi_hdr_uniform_t *mapped_ubo = NULL;
d3d12->hdr.ubo_values.inverse_tonemap = inverse_tonemap ? 1.0f : 0.0f;
read_range.Begin = 0;
read_range.End = 0;
D3D12Map(d3d12->hdr.ubo, 0, &read_range, (void**)&mapped_ubo);
*mapped_ubo = d3d12->hdr.ubo_values;
D3D12Unmap(d3d12->hdr.ubo, 0, NULL);
@ -364,11 +382,13 @@ static void d3d12_set_hdr_inverse_tonemap(d3d12_video_t* d3d12, bool inverse_ton
static void d3d12_set_hdr10(d3d12_video_t* d3d12, bool hdr10)
{
D3D12_RANGE read_range = { 0, 0 };
D3D12_RANGE read_range;
dxgi_hdr_uniform_t *mapped_ubo = NULL;
d3d12->hdr.ubo_values.hdr10 = hdr10 ? 1.0f : 0.0f;
read_range.Begin = 0;
read_range.End = 0;
D3D12Map(d3d12->hdr.ubo, 0, &read_range, (void**)&mapped_ubo);
*mapped_ubo = d3d12->hdr.ubo_values;
D3D12Unmap(d3d12->hdr.ubo, 0, NULL);
@ -393,7 +413,7 @@ static void d3d12_gfx_set_rotation(void* data, unsigned rotation)
{
math_matrix_4x4 rot;
math_matrix_4x4* mvp;
D3D12_RANGE read_range = { 0, 0 };
D3D12_RANGE read_range;
d3d12_video_t* d3d12 = (d3d12_video_t*)data;
if (!d3d12)
@ -405,6 +425,8 @@ static void d3d12_gfx_set_rotation(void* data, unsigned rotation)
matrix_4x4_rotate_z(rot, d3d12->frame.rotation * (M_PI / 2.0f));
matrix_4x4_multiply(d3d12->mvp, rot, d3d12->mvp_no_rot);
read_range.Begin = 0;
read_range.End = 0;
D3D12Map(d3d12->frame.ubo, 0, &read_range, (void**)&mvp);
*mvp = d3d12->mvp;
D3D12Unmap(d3d12->frame.ubo, 0, NULL);
@ -1213,7 +1235,9 @@ static void *d3d12_gfx_init(const video_info_t* video,
{
math_matrix_4x4* mvp;
D3D12_RANGE read_range = { 0, 0 };
D3D12_RANGE read_range;
read_range.Begin = 0;
read_range.End = 0;
D3D12Map(d3d12->ubo, 0, &read_range, (void**)&mvp);
*mvp = d3d12->mvp_no_rot;
D3D12Unmap(d3d12->ubo, 0, NULL);
@ -1234,7 +1258,9 @@ static void *d3d12_gfx_init(const video_info_t* video,
{
dxgi_hdr_uniform_t* mapped_ubo;
D3D12_RANGE read_range = { 0, 0 };
D3D12_RANGE read_range;
read_range.Begin = 0;
read_range.End = 0;
D3D12Map(d3d12->hdr.ubo, 0, &read_range, (void**)&mapped_ubo);
*mapped_ubo = d3d12->hdr.ubo_values;
D3D12Unmap(d3d12->hdr.ubo, 0, NULL);
@ -1675,10 +1701,13 @@ static bool d3d12_gfx_frame(
if (buffer_sem->stage_mask && buffer_sem->uniforms)
{
D3D12_RANGE range = { 0, 0 };
D3D12_RANGE range;
uint8_t* mapped_data = NULL;
uniform_sem_t* uniform = buffer_sem->uniforms;
range.Begin = 0;
range.End = 0;
D3D12Map(d3d12->pass[i].buffers[j], 0, &range,
(void**)&mapped_data);
while (uniform->size)
@ -2120,14 +2149,16 @@ static void d3d12_set_menu_texture_frame(
d3d12->menu.alpha = alpha;
{
D3D12_RANGE read_range = { 0, 0 };
D3D12_RANGE read_range;
d3d12_vertex_t* v = NULL;
read_range.Begin = 0;
read_range.End = 0;
D3D12Map(d3d12->menu.vbo, 0, &read_range, (void**)&v);
v[0].color[3] = alpha;
v[1].color[3] = alpha;
v[2].color[3] = alpha;
v[3].color[3] = alpha;
v[0].color[3] = alpha;
v[1].color[3] = alpha;
v[2].color[3] = alpha;
v[3].color[3] = alpha;
D3D12Unmap(d3d12->menu.vbo, 0, NULL);
}
@ -2148,7 +2179,8 @@ static void d3d12_set_menu_texture_enable(void* data,
d3d12->menu.fullscreen = full_screen;
}
static void d3d12_gfx_set_aspect_ratio(void* data, unsigned aspect_ratio_idx)
static void d3d12_gfx_set_aspect_ratio(
void* data, unsigned aspect_ratio_idx)
{
d3d12_video_t* d3d12 = (d3d12_video_t*)data;

179
gfx/drivers/vulkan.c
View File

@ -1777,10 +1777,6 @@ static void vulkan_set_viewport(void *data, unsigned viewport_width,
vk->vk_vp.maxDepth = 1.0f;
vk->tracker.dirty |= VULKAN_DIRTY_DYNAMIC_BIT;
#if 0
RARCH_LOG("Setting viewport @ %ux%u\n", viewport_width, viewport_height);
#endif
}
static void vulkan_readback(vk_t *vk)
@ -1836,12 +1832,13 @@ static void vulkan_readback(vk_t *vk)
1, &barrier, 0, NULL, 0, NULL);
}
static void vulkan_inject_black_frame(vk_t *vk, video_frame_info_t *video_info,
static void vulkan_inject_black_frame(
vk_t *vk, video_frame_info_t *video_info,
void *context_data)
{
VkCommandBufferBeginInfo begin_info = {
VkCommandBufferBeginInfo begin_info = {
VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO };
VkSubmitInfo submit_info = {
VkSubmitInfo submit_info = {
VK_STRUCTURE_TYPE_SUBMIT_INFO };
const VkClearColorValue clear_color = {{ 0.0f, 0.0f, 0.0f, 1.0f }};
@ -2137,24 +2134,12 @@ static bool vulkan_frame(void *data, const void *frame,
}
else
{
struct vk_texture *tex = NULL;
#if 0 /* VULKAN_HDR_SWAPCHAIN */
if(vk->context->hdr_enable)
{
tex = &vk->main_buffer.texture;
vulkan_transition_texture(vk, vk->cmd, tex);
}
struct vk_texture *tex = &vk->swapchain[vk->last_valid_index].texture;
if (vk->swapchain[vk->last_valid_index].texture_optimal.memory
!= VK_NULL_HANDLE)
tex = &vk->swapchain[vk->last_valid_index].texture_optimal;
else
#endif /* VULKAN_HDR_SWAPCHAIN */
{
tex = &vk->swapchain[vk->last_valid_index].texture;
if (vk->swapchain[vk->last_valid_index].texture_optimal.memory
!= VK_NULL_HANDLE)
tex = &vk->swapchain[vk->last_valid_index].texture_optimal;
else
vulkan_transition_texture(vk, vk->cmd, tex);
}
vulkan_transition_texture(vk, vk->cmd, tex);
input.image = tex->image;
input.view = tex->view;
@ -2409,10 +2394,10 @@ static bool vulkan_frame(void *data, const void *frame,
{
VkViewport viewport;
viewport.x = 0.0f;
viewport.y = 0.0f;
viewport.width = vk->context->swapchain_width;
viewport.height = vk->context->swapchain_height;
viewport.x = 0.0f;
viewport.y = 0.0f;
viewport.width = vk->context->swapchain_width;
viewport.height = vk->context->swapchain_height;
const VkRect2D scissor = {
{
@ -2675,87 +2660,81 @@ static bool vulkan_frame(void *data, const void *frame,
if(vk->context->hdr_enable)
{
VkMemoryRequirements mem_reqs;
VkImageCreateInfo image_info;
VkMemoryAllocateInfo alloc;
VkImageViewCreateInfo view;
VkFramebufferCreateInfo info;
memset(&vk->main_buffer, 0, sizeof(vk->main_buffer));
{
/* Create the image */
VkMemoryRequirements mem_reqs;
VkImageCreateInfo image_info = { VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO };
VkMemoryAllocateInfo alloc = { VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO };
/* Create the image */
image_info.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
image_info.pNext = NULL;
image_info.flags = 0;
image_info.imageType = VK_IMAGE_TYPE_2D;
image_info.format = main_buffer_format;
image_info.extent.width = video_width;
image_info.extent.height = video_height;
image_info.extent.depth = 1;
image_info.mipLevels = 1;
image_info.arrayLayers = 1;
image_info.samples = VK_SAMPLE_COUNT_1_BIT;
image_info.tiling = VK_IMAGE_TILING_OPTIMAL;
image_info.usage = VK_IMAGE_USAGE_SAMPLED_BIT |
VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
VK_IMAGE_USAGE_TRANSFER_DST_BIT;
image_info.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
image_info.queueFamilyIndexCount= 0;
image_info.pQueueFamilyIndices = NULL;
image_info.initialLayout = VK_IMAGE_LAYOUT_GENERAL; /* VK_IMAGE_LAYOUT_UNDEFINED; */
image_info.imageType = VK_IMAGE_TYPE_2D;
image_info.format = main_buffer_format;
image_info.extent.width = video_width;
image_info.extent.height = video_height;
image_info.extent.depth = 1;
image_info.mipLevels = 1;
image_info.arrayLayers = 1;
image_info.samples = VK_SAMPLE_COUNT_1_BIT;
image_info.tiling = VK_IMAGE_TILING_OPTIMAL;
image_info.usage = VK_IMAGE_USAGE_SAMPLED_BIT |
VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
VK_IMAGE_USAGE_TRANSFER_DST_BIT;
image_info.initialLayout = VK_IMAGE_LAYOUT_GENERAL; /* VK_IMAGE_LAYOUT_UNDEFINED; */
vkCreateImage(vk->context->device, &image_info, NULL, &vk->main_buffer.image);
vkGetImageMemoryRequirements(vk->context->device, vk->main_buffer.image, &mem_reqs);
alloc.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
alloc.pNext = NULL;
alloc.allocationSize = mem_reqs.size;
alloc.memoryTypeIndex = vulkan_find_memory_type(
&vk->context->memory_properties,
mem_reqs.memoryTypeBits,
VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
vkCreateImage(vk->context->device, &image_info, NULL, &vk->main_buffer.image);
vkGetImageMemoryRequirements(vk->context->device, vk->main_buffer.image, &mem_reqs);
vkAllocateMemory(vk->context->device, &alloc, NULL, &vk->main_buffer.memory);
alloc.allocationSize = mem_reqs.size;
alloc.memoryTypeIndex = vulkan_find_memory_type(
&vk->context->memory_properties,
mem_reqs.memoryTypeBits,
VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
vkBindImageMemory(vk->context->device, vk->main_buffer.image, vk->main_buffer.memory, 0);
vkAllocateMemory(vk->context->device, &alloc, NULL, &vk->main_buffer.memory);
/* Create an image view which we can render into. */
view.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
view.pNext = NULL;
view.flags = 0;
view.image = vk->main_buffer.image;
view.viewType = VK_IMAGE_VIEW_TYPE_2D;
view.format = main_buffer_format;
view.components.r = VK_COMPONENT_SWIZZLE_R;
view.components.g = VK_COMPONENT_SWIZZLE_G;
view.components.b = VK_COMPONENT_SWIZZLE_B;
view.components.a = VK_COMPONENT_SWIZZLE_A;
view.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
view.subresourceRange.baseMipLevel = 0;
view.subresourceRange.levelCount = 1;
view.subresourceRange.baseArrayLayer = 0;
view.subresourceRange.layerCount = 1;
vkBindImageMemory(vk->context->device, vk->main_buffer.image, vk->main_buffer.memory, 0);
}
vkCreateImageView(vk->context->device, &view, NULL, &vk->main_buffer.view);
{
/* Create an image view which we can render into. */
VkImageViewCreateInfo view = { VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO };
/* Create the framebuffer */
info.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
info.pNext = NULL;
info.flags = 0;
info.renderPass = vk->render_pass;
info.attachmentCount = 1;
info.pAttachments = &vk->main_buffer.view;
info.width = vk->context->swapchain_width;
info.height = vk->context->swapchain_height;
info.layers = 1;
view.viewType = VK_IMAGE_VIEW_TYPE_2D;
view.format = main_buffer_format;
view.image = vk->main_buffer.image;
view.subresourceRange.baseMipLevel = 0;
view.subresourceRange.baseArrayLayer = 0;
view.subresourceRange.levelCount = 1;
view.subresourceRange.layerCount = 1;
view.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
view.components.r = VK_COMPONENT_SWIZZLE_R;
view.components.g = VK_COMPONENT_SWIZZLE_G;
view.components.b = VK_COMPONENT_SWIZZLE_B;
view.components.a = VK_COMPONENT_SWIZZLE_A;
vkCreateImageView(vk->context->device, &view, NULL, &vk->main_buffer.view);
}
{
/* Create the framebuffer */
VkFramebufferCreateInfo info = { VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO };
info.renderPass = vk->render_pass;
info.attachmentCount = 1;
info.pAttachments = &vk->main_buffer.view;
info.width = vk->context->swapchain_width;
info.height = vk->context->swapchain_height;
info.layers = 1;
vkCreateFramebuffer(vk->context->device, &info, NULL, &vk->main_buffer.framebuffer);
}
vkCreateFramebuffer(vk->context->device, &info, NULL, &vk->main_buffer.framebuffer);
}
/*
vulkan_set_hdr_metadata(
vk->hdr.support,
vk->context->swapchain_format,
vk->context->swapchain_color_space,
vk->hdr.max_output_nits,
vk->hdr.min_output_nits,
vk->hdr.max_cll,
vk->hdr.max_fall);
*/
#endif /* VULKAN_HDR_SWAPCHAIN */
vk->should_resize = false;
@ -2776,9 +2755,7 @@ static bool vulkan_frame(void *data, const void *frame,
{
unsigned n;
for (n = 0; n < black_frame_insertion; ++n)
{
vulkan_inject_black_frame(vk, video_info, vk->ctx_data);
}
}
/* Vulkan doesn't directly support swap_interval > 1,

30
gfx/drivers_display/gfx_display_d3d11.c
View File

@ -211,19 +211,25 @@ static void gfx_display_d3d11_draw_pipeline(gfx_display_ctx_draw_t *draw,
if (!d3d11->menu_pipeline_vbo)
{
D3D11_BUFFER_DESC desc = { 0 };
desc.Usage = D3D11_USAGE_IMMUTABLE;
desc.ByteWidth = ca->coords.vertices * 2 * sizeof(float);
desc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
D3D11_BUFFER_DESC desc;
D3D11_SUBRESOURCE_DATA vertex_data;
UINT stride = 2 * sizeof(float);
UINT offset = 0;
desc.ByteWidth = ca->coords.vertices
* 2 * sizeof(float);
desc.Usage = D3D11_USAGE_IMMUTABLE;
desc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
desc.CPUAccessFlags = 0;
desc.MiscFlags = 0;
desc.StructureByteStride = 0;
vertex_data.pSysMem = ca->coords.vertex;
vertex_data.SysMemPitch = 0;
vertex_data.SysMemSlicePitch = 0;
D3D11CreateBuffer(d3d11->device, &desc, &vertex_data,
&d3d11->menu_pipeline_vbo);
{
D3D11_SUBRESOURCE_DATA vertexData = { ca->coords.vertex };
D3D11CreateBuffer(d3d11->device, &desc, &vertexData, &d3d11->menu_pipeline_vbo);
}
}
{
UINT stride = 2 * sizeof(float);
UINT offset = 0;
d3d11->context->lpVtbl->IASetVertexBuffers(
d3d11->context, 0, 1,
&d3d11->menu_pipeline_vbo, &stride, &offset);