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

(Vulkan) Use flags for vulkan_ctx_data

Browse Source
This commit is contained in:
LibretroAdmin 2022-10-30 23:07:07 +01:00
parent 0159c2f70f
commit 724acc4eb9
9 changed files with 105 additions and 94 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

58
gfx/common/vulkan_common.c
View File

@ -2441,7 +2441,7 @@ static void vulkan_destroy_swapchain(gfx_ctx_vulkan_data_t *vk)
vkDestroySwapchainKHR(vk->context.device, vk->swapchain, NULL);
memset(vk->context.swapchain_images, 0, sizeof(vk->context.swapchain_images));
vk->swapchain = VK_NULL_HANDLE;
vk->context.has_acquired_swapchain = false;
vk->context.flags &= ~VK_CTX_FLAG_HAS_ACQUIRED_SWAPCHAIN;
}
for (i = 0; i < VULKAN_MAX_SWAPCHAIN_IMAGES; i++)
@ -2729,12 +2729,12 @@ retry:
vk->context.current_frame_index = 0;
vulkan_acquire_clear_fences(vk);
vulkan_acquire_wait_fences(vk);
vk->context.invalid_swapchain = true;
vk->context.flags |= VK_CTX_FLAG_INVALID_SWAPCHAIN;
return;
}
}
retro_assert(!vk->context.has_acquired_swapchain);
retro_assert(!(vk->context.flags & VK_CTX_FLAG_HAS_ACQUIRED_SWAPCHAIN));
if (vk->flags & VK_DATA_FLAG_EMULATING_MAILBOX)
{
@ -2771,7 +2771,7 @@ retry:
{
if (fence != VK_NULL_HANDLE)
vkWaitForFences(vk->context.device, 1, &fence, true, UINT64_MAX);
vk->context.has_acquired_swapchain = true;
vk->context.flags |= VK_CTX_FLAG_HAS_ACQUIRED_SWAPCHAIN;
if (vk->context.swapchain_acquire_semaphore)
{
@ -2788,7 +2788,7 @@ retry:
}
else
{
vk->context.has_acquired_swapchain = false;
vk->context.flags &= ~VK_CTX_FLAG_HAS_ACQUIRED_SWAPCHAIN;
if (semaphore)
{
struct vulkan_context *ctx = &vk->context;
@ -2834,7 +2834,7 @@ retry:
if (err == VK_ERROR_SURFACE_LOST_KHR)
RARCH_ERR("[Vulkan]: Got VK_ERROR_SURFACE_LOST_KHR.\n");
/* Force driver to reset swapchain image handles. */
vk->context.invalid_swapchain = true;
vk->context.flags |= VK_CTX_FLAG_INVALID_SWAPCHAIN;
vulkan_acquire_clear_fences(vk);
return;
}
@ -2865,8 +2865,8 @@ bool vulkan_create_swapchain(gfx_ctx_vulkan_data_t *vk,
VkSwapchainCreateInfoKHR info;
VkSurfaceTransformFlagBitsKHR pre_transform;
VkPresentModeKHR swapchain_present_mode = VK_PRESENT_MODE_FIFO_KHR;
settings_t *settings = config_get_ptr();
VkCompositeAlphaFlagBitsKHR composite = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
settings_t *settings = config_get_ptr();
bool vsync = settings->bools.video_vsync;
vkDeviceWaitIdle(vk->context.device);
@ -2890,13 +2890,13 @@ bool vulkan_create_swapchain(gfx_ctx_vulkan_data_t *vk,
else
vk->flags &= ~VK_DATA_FLAG_EMULATING_MAILBOX;
vk->flags |= VK_DATA_FLAG_CREATED_NEW_SWAPCHAIN;
vk->flags |= VK_DATA_FLAG_CREATED_NEW_SWAPCHAIN;
if (vk->swapchain != VK_NULL_HANDLE &&
!vk->context.invalid_swapchain &&
vk->context.swapchain_width == width &&
vk->context.swapchain_height == height &&
vk->context.swap_interval == swap_interval)
if ( (vk->swapchain != VK_NULL_HANDLE)
&& (!(vk->context.flags & VK_CTX_FLAG_INVALID_SWAPCHAIN))
&& (vk->context.swapchain_width == width)
&& (vk->context.swapchain_height == height)
&& (vk->context.swap_interval == swap_interval))
{
/* Do not bother creating a swapchain redundantly. */
#ifdef VULKAN_DEBUG
@ -2920,7 +2920,7 @@ bool vulkan_create_swapchain(gfx_ctx_vulkan_data_t *vk,
/* We are tearing down, and entering a state
* where we are supposed to have
* acquired an image, so block until we have acquired. */
if (!vk->context.has_acquired_swapchain)
if (!(vk->context.flags & VK_CTX_FLAG_HAS_ACQUIRED_SWAPCHAIN))
if (vk->mailbox.swapchain != VK_NULL_HANDLE)
res = vulkan_emulated_mailbox_acquire_next_image_blocking(
&vk->mailbox,
@ -2930,13 +2930,13 @@ bool vulkan_create_swapchain(gfx_ctx_vulkan_data_t *vk,
if (res == VK_SUCCESS)
{
vk->context.has_acquired_swapchain = true;
vk->flags &= ~VK_DATA_FLAG_CREATED_NEW_SWAPCHAIN;
vk->context.flags |= VK_CTX_FLAG_HAS_ACQUIRED_SWAPCHAIN;
vk->flags &= ~VK_DATA_FLAG_CREATED_NEW_SWAPCHAIN;
return true;
}
/* We failed for some reason, so create a new swapchain. */
vk->context.has_acquired_swapchain = false;
vk->context.flags &= ~VK_CTX_FLAG_HAS_ACQUIRED_SWAPCHAIN;
}
else
{
@ -3015,7 +3015,10 @@ bool vulkan_create_swapchain(gfx_ctx_vulkan_data_t *vk,
}
#ifdef VULKAN_HDR_SWAPCHAIN
vk->context.hdr_enable = settings->bools.video_hdr_enable;
if (settings->bools.video_hdr_enable)
vk->context.flags |= VK_CTX_FLAG_HDR_ENABLE;
else
vk->context.flags &= ~VK_CTX_FLAG_HDR_ENABLE;
video_driver_unset_hdr_support();
@ -3028,10 +3031,11 @@ bool vulkan_create_swapchain(gfx_ctx_vulkan_data_t *vk,
}
}
if (!vk->context.hdr_enable || format.format == VK_FORMAT_UNDEFINED)
vk->context.hdr_enable = false;
if ( (!(vk->context.flags & VK_CTX_FLAG_HDR_ENABLE))
|| (format.format == VK_FORMAT_UNDEFINED))
vk->context.flags &= ~VK_CTX_FLAG_HDR_ENABLE;
if (!vk->context.hdr_enable)
if (!(vk->context.flags & VK_CTX_FLAG_HDR_ENABLE))
#endif /* VULKAN_HDR_SWAPCHAIN */
{
for (i = 0; i < format_count; i++)
@ -3180,22 +3184,22 @@ bool vulkan_create_swapchain(gfx_ctx_vulkan_data_t *vk,
{
case VK_FORMAT_B8G8R8A8_SRGB:
vk->context.swapchain_format = VK_FORMAT_B8G8R8A8_UNORM;
vk->context.swapchain_is_srgb = true;
vk->context.flags |= VK_CTX_FLAG_SWAPCHAIN_IS_SRGB;
break;
case VK_FORMAT_R8G8B8A8_SRGB:
vk->context.swapchain_format = VK_FORMAT_R8G8B8A8_UNORM;
vk->context.swapchain_is_srgb = true;
vk->context.flags |= VK_CTX_FLAG_SWAPCHAIN_IS_SRGB;
break;
case VK_FORMAT_R8G8B8_SRGB:
vk->context.swapchain_format = VK_FORMAT_R8G8B8_UNORM;
vk->context.swapchain_is_srgb = true;
vk->context.flags |= VK_CTX_FLAG_SWAPCHAIN_IS_SRGB;
break;
case VK_FORMAT_B8G8R8_SRGB:
vk->context.swapchain_format = VK_FORMAT_B8G8R8_UNORM;
vk->context.swapchain_is_srgb = true;
vk->context.flags |= VK_CTX_FLAG_SWAPCHAIN_IS_SRGB;
break;
default:
@ -3213,8 +3217,8 @@ bool vulkan_create_swapchain(gfx_ctx_vulkan_data_t *vk,
vk->context.num_swapchain_images);
/* Force driver to reset swapchain image handles. */
vk->context.invalid_swapchain = true;
vk->context.has_acquired_swapchain = false;
vk->context.flags |= VK_CTX_FLAG_INVALID_SWAPCHAIN;
vk->context.flags &= ~VK_CTX_FLAG_HAS_ACQUIRED_SWAPCHAIN;
vulkan_create_wait_fences(vk);
if (vk->flags & VK_DATA_FLAG_EMULATING_MAILBOX)

22
gfx/common/vulkan_common.h
View File

@ -114,6 +114,16 @@ typedef struct ALIGN(16)
} vulkan_hdr_uniform_t;
#endif /* VULKAN_HDR_SWAPCHAIN */
enum vulkan_context_flags
{
VK_CTX_FLAG_INVALID_SWAPCHAIN = (1 << 0),
VK_CTX_FLAG_HDR_ENABLE = (1 << 1),
/* Used by screenshot to get blits with correct colorspace. */
VK_CTX_FLAG_SWAPCHAIN_IS_SRGB = (1 << 2),
VK_CTX_FLAG_SWAP_INTERVAL_EMULATION_LOCK = (1 << 3),
VK_CTX_FLAG_HAS_ACQUIRED_SWAPCHAIN = (1 << 4)
};
typedef struct vulkan_context
{
slock_t *queue_lock;
@ -152,17 +162,9 @@ typedef struct vulkan_context
unsigned swap_interval;
unsigned num_recycled_acquire_semaphores;
bool swapchain_fences_signalled[VULKAN_MAX_SWAPCHAIN_IMAGES];
bool invalid_swapchain;
/* Used by screenshot to get blits with correct colorspace. */
bool swapchain_is_srgb;
bool swap_interval_emulation_lock;
bool has_acquired_swapchain;
#ifdef VULKAN_HDR_SWAPCHAIN
bool hdr_enable;
#endif /* VULKAN_HDR_SWAPCHAIN */
uint8_t flags;
bool swapchain_fences_signalled[VULKAN_MAX_SWAPCHAIN_IMAGES];
} vulkan_context_t;
enum vulkan_emulated_mailbox_flags

77
gfx/drivers/vulkan.c
View File

@ -929,7 +929,7 @@ static bool vulkan_init_default_filter_chain(vk_t *vk)
}
#ifdef VULKAN_HDR_SWAPCHAIN
if (vk->context->hdr_enable)
if (vk->context->flags & VK_CTX_FLAG_HDR_ENABLE)
{
struct video_shader* shader_preset = vulkan_filter_chain_get_preset(
vk->filter_chain);
@ -997,7 +997,7 @@ static bool vulkan_init_filter_chain_preset(vk_t *vk, const char *shader_path)
}
#ifdef VULKAN_HDR_SWAPCHAIN
if (vk->context->hdr_enable)
if (vk->context->flags & VK_CTX_FLAG_HDR_ENABLE)
{
struct video_shader* shader_preset = vulkan_filter_chain_get_preset(vk->filter_chain);
VkFormat rt_format = (shader_preset && shader_preset->passes) ? vulkan_filter_chain_get_pass_rt_format(vk->filter_chain, shader_preset->passes - 1) : VK_FORMAT_UNDEFINED;
@ -1656,7 +1656,7 @@ static void vulkan_check_swapchain(vk_t *vk)
&info, &vk->swapchain[i].cmd);
}
}
vk->context->invalid_swapchain = false;
vk->context->flags &= ~VK_CTX_FLAG_INVALID_SWAPCHAIN;
filter_info.viewport = vk->vk_vp;
filter_info.format = vk->context->swapchain_format;
@ -1691,7 +1691,7 @@ static void vulkan_set_nonblock_state(void *data, bool state,
/* Changing vsync might require recreating the swapchain,
* which means new VkImages to render into. */
if (vk->context->invalid_swapchain)
if (vk->context->flags & VK_CTX_FLAG_INVALID_SWAPCHAIN)
vulkan_check_swapchain(vk);
}
@ -2019,15 +2019,16 @@ static void vulkan_inject_black_frame(vk_t *vk, video_frame_info_t *video_info)
submit_info.commandBufferCount = 1;
submit_info.pCommandBuffers = &vk->cmd;
if (
vk->context->has_acquired_swapchain
&& vk->context->swapchain_semaphores[swapchain_index] != VK_NULL_HANDLE)
(vk->context->flags & VK_CTX_FLAG_HAS_ACQUIRED_SWAPCHAIN)
&& (vk->context->swapchain_semaphores[swapchain_index] !=
VK_NULL_HANDLE))
{
submit_info.signalSemaphoreCount = 1;
submit_info.pSignalSemaphores = &vk->context->swapchain_semaphores[swapchain_index];
}
if ( vk->context->has_acquired_swapchain
&& vk->context->swapchain_acquire_semaphore != VK_NULL_HANDLE)
if ( (vk->context->flags & VK_CTX_FLAG_HAS_ACQUIRED_SWAPCHAIN)
&& (vk->context->swapchain_acquire_semaphore != VK_NULL_HANDLE))
{
static const VkPipelineStageFlags wait_stage =
VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
@ -2090,8 +2091,9 @@ static bool vulkan_frame(void *data, const void *frame,
bool overlay_behind_menu = video_info->overlay_behind_menu;
#ifdef VULKAN_HDR_SWAPCHAIN
bool use_main_buffer = vk->context->hdr_enable &&
(!vk->filter_chain || !vulkan_filter_chain_emits_hdr10(vk->filter_chain));
bool use_main_buffer = (vk->context->flags &
VK_CTX_FLAG_HDR_ENABLE)
&& (!vk->filter_chain || !vulkan_filter_chain_emits_hdr10(vk->filter_chain));
#endif /* VULKAN_HDR_SWAPCHAIN */
/* Bookkeeping on start of frame. */
@ -2335,7 +2337,7 @@ static bool vulkan_frame(void *data, const void *frame,
/* Render to backbuffer. */
if ( (backbuffer->image != VK_NULL_HANDLE)
&& vk->context->has_acquired_swapchain)
&& (vk->context->flags & VK_CTX_FLAG_HAS_ACQUIRED_SWAPCHAIN))
{
rp_info.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
rp_info.pNext = NULL;
@ -2579,8 +2581,8 @@ static bool vulkan_frame(void *data, const void *frame,
vulkan_filter_chain_end_frame((vulkan_filter_chain_t*)vk->filter_chain, vk->cmd);
if (
backbuffer->image != VK_NULL_HANDLE
&& vk->context->has_acquired_swapchain
(backbuffer->image != VK_NULL_HANDLE)
&& (vk->context->flags & VK_CTX_FLAG_HAS_ACQUIRED_SWAPCHAIN)
)
{
if (vk->readback.pending || vk->readback.streamed)
@ -2679,8 +2681,8 @@ static bool vulkan_frame(void *data, const void *frame,
vk->hw.valid_semaphore = false;
/* We allocated space for this. */
if (vk->context->has_acquired_swapchain &&
vk->context->swapchain_acquire_semaphore != VK_NULL_HANDLE)
if ( (vk->context->flags & VK_CTX_FLAG_HAS_ACQUIRED_SWAPCHAIN)
&& (vk->context->swapchain_acquire_semaphore != VK_NULL_HANDLE))
{
assert(!vk->context->swapchain_wait_semaphores[frame_index]);
vk->context->swapchain_wait_semaphores[frame_index] =
@ -2692,8 +2694,8 @@ static bool vulkan_frame(void *data, const void *frame,
submit_info.waitSemaphoreCount++;
}
}
else if (vk->context->has_acquired_swapchain &&
vk->context->swapchain_acquire_semaphore != VK_NULL_HANDLE)
else if ((vk->context->flags & VK_CTX_FLAG_HAS_ACQUIRED_SWAPCHAIN)
&& (vk->context->swapchain_acquire_semaphore != VK_NULL_HANDLE))
{
static const VkPipelineStageFlags wait_stage =
VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
@ -2716,9 +2718,9 @@ static bool vulkan_frame(void *data, const void *frame,
submit_info.signalSemaphoreCount = 0;
if (vk->context->swapchain_semaphores[swapchain_index]
!= VK_NULL_HANDLE &&
vk->context->has_acquired_swapchain)
if ((vk->context->swapchain_semaphores[swapchain_index]
!= VK_NULL_HANDLE)
&& (vk->context->flags & VK_CTX_FLAG_HAS_ACQUIRED_SWAPCHAIN))
signal_semaphores[submit_info.signalSemaphoreCount++] = vk->context->swapchain_semaphores[swapchain_index];
if (vk->hw.signal_semaphore != VK_NULL_HANDLE)
@ -2741,7 +2743,7 @@ static bool vulkan_frame(void *data, const void *frame,
if (vk->ctx_driver->swap_buffers)
vk->ctx_driver->swap_buffers(vk->ctx_data);
if (!vk->context->swap_interval_emulation_lock)
if (!(vk->context->flags & VK_CTX_FLAG_SWAP_INTERVAL_EMULATION_LOCK))
{
if (vk->ctx_driver->update_window_title)
vk->ctx_driver->update_window_title(vk->ctx_data);
@ -2751,16 +2753,17 @@ static bool vulkan_frame(void *data, const void *frame,
* i.e. right after swap buffers. */
#ifdef VULKAN_HDR_SWAPCHAIN
bool video_hdr_enable = video_info->hdr_enable;
if (vk->should_resize || (vk->context->hdr_enable != video_hdr_enable))
if ( vk->should_resize
|| (((vk->context->flags & VK_CTX_FLAG_HDR_ENABLE) > 0)
!= video_hdr_enable))
#else
if (vk->should_resize)
#endif /* VULKAN_HDR_SWAPCHAIN */
{
#ifdef VULKAN_HDR_SWAPCHAIN
vk->context->hdr_enable = video_hdr_enable;
if (vk->context->hdr_enable)
if (video_hdr_enable)
{
vk->context->flags |= VK_CTX_FLAG_HDR_ENABLE;
#ifdef HAVE_THREADS
slock_lock(vk->context->queue_lock);
#endif
@ -2768,9 +2771,11 @@ static bool vulkan_frame(void *data, const void *frame,
#ifdef HAVE_THREADS
slock_unlock(vk->context->queue_lock);
#endif
vulkan_destroy_hdr_buffer(vk->context->device, &vk->main_buffer);
}
else
vk->context->flags &= ~VK_CTX_FLAG_HDR_ENABLE;
#endif /* VULKAN_HDR_SWAPCHAIN */
gfx_ctx_mode_t mode;
@ -2782,9 +2787,9 @@ static bool vulkan_frame(void *data, const void *frame,
#ifdef VULKAN_HDR_SWAPCHAIN
if (!(vk->hdr.support = vk->context->swapchain_colour_space == VK_COLOR_SPACE_HDR10_ST2084_EXT))
vk->context->hdr_enable = false;
vk->context->flags &= ~VK_CTX_FLAG_HDR_ENABLE;
if (vk->context->hdr_enable)
if (vk->context->flags & VK_CTX_FLAG_HDR_ENABLE)
{
VkMemoryRequirements mem_reqs;
VkImageCreateInfo image_info;
@ -2869,14 +2874,14 @@ static bool vulkan_frame(void *data, const void *frame,
vk->should_resize = false;
}
if (vk->context->invalid_swapchain)
if (vk->context->flags & VK_CTX_FLAG_INVALID_SWAPCHAIN)
vulkan_check_swapchain(vk);
/* Disable BFI during fast forward, slow-motion,
* and pause to prevent flicker. */
if (
backbuffer->image != VK_NULL_HANDLE
&& vk->context->has_acquired_swapchain
(backbuffer->image != VK_NULL_HANDLE)
&& (vk->context->flags & VK_CTX_FLAG_HAS_ACQUIRED_SWAPCHAIN)
&& black_frame_insertion
&& !input_driver_nonblock_state
&& !runloop_is_slowmotion
@ -2896,21 +2901,21 @@ static bool vulkan_frame(void *data, const void *frame,
/* Vulkan doesn't directly support swap_interval > 1,
* so we fake it by duping out more frames. */
if ( vk->context->swap_interval > 1
&& !vk->context->swap_interval_emulation_lock)
if ( (vk->context->swap_interval > 1)
&& (!(vk->context->flags & VK_CTX_FLAG_SWAP_INTERVAL_EMULATION_LOCK)))
{
unsigned i;
vk->context->swap_interval_emulation_lock = true;
vk->context->flags |= VK_CTX_FLAG_SWAP_INTERVAL_EMULATION_LOCK;
for (i = 1; i < vk->context->swap_interval; i++)
{
if (!vulkan_frame(vk, NULL, 0, 0, frame_count, 0, msg,
video_info))
{
vk->context->swap_interval_emulation_lock = false;
vk->context->flags &= ~VK_CTX_FLAG_SWAP_INTERVAL_EMULATION_LOCK;
return false;
}
}
vk->context->swap_interval_emulation_lock = false;
vk->context->flags &= ~VK_CTX_FLAG_SWAP_INTERVAL_EMULATION_LOCK;
}
return true;

6
gfx/drivers_context/android_vk_ctx.c
View File

@ -145,7 +145,7 @@ static bool android_gfx_ctx_vk_set_resize(void *data,
if (and->vk.flags & VK_DATA_FLAG_CREATED_NEW_SWAPCHAIN)
vulkan_acquire_next_image(&and->vk);
and->vk.context.invalid_swapchain = true;
and->vk.context.flags |= VK_CTX_FLAG_INVALID_SWAPCHAIN;
and->vk.flags &= ~VK_DATA_FLAG_NEED_NEW_SWAPCHAIN;
return true;
@ -254,9 +254,9 @@ static void android_gfx_ctx_vk_swap_buffers(void *data)
{
android_ctx_data_vk_t *and = (android_ctx_data_vk_t*)data;
if (and->vk.context.has_acquired_swapchain)
if (and->vk.context.flags & VK_CTX_FLAG_HAS_ACQUIRED_SWAPCHAIN)
{
and->vk.context.has_acquired_swapchain = false;
and->vk.context.flags &= ~VK_CTX_FLAG_HAS_ACQUIRED_SWAPCHAIN;
if (and->vk.swapchain == VK_NULL_HANDLE)
{
retro_sleep(10);

6
gfx/drivers_context/cocoa_vk_ctx.m
View File

@ -178,9 +178,9 @@ static void cocoa_vk_gfx_ctx_swap_buffers(void *data)
{
cocoa_ctx_data_t *cocoa_ctx = (cocoa_ctx_data_t*)data;
if (cocoa_ctx->vk.context.has_acquired_swapchain)
if (cocoa_ctx->vk.context.flags & VK_CTX_FLAG_HAS_ACQUIRED_SWAPCHAIN)
{
cocoa_ctx->vk.context.has_acquired_swapchain = false;
cocoa_ctx->vk.context.flags &= ~VK_CTX_FLAG_HAS_ACQUIRED_SWAPCHAIN;
if (cocoa_ctx->vk.swapchain == VK_NULL_HANDLE)
{
retro_sleep(10);
@ -320,7 +320,7 @@ static bool cocoa_vk_gfx_ctx_set_resize(void *data, unsigned width, unsigned hei
return false;
}
cocoa_ctx->vk.context.invalid_swapchain = true;
cocoa_ctx->vk.context.flags |= VK_CTX_FLAG_INVALID_SWAPCHAIN;
if (cocoa_ctx->vk.flags & VK_DATA_FLAG_CREATED_NEW_SWAPCHAIN)
vulkan_acquire_next_image(&cocoa_ctx->vk);

8
gfx/drivers_context/khr_display_ctx.c
View File

@ -115,8 +115,8 @@ static bool gfx_ctx_khr_display_set_resize(void *data,
if (khr->vk.flags & VK_DATA_FLAG_CREATED_NEW_SWAPCHAIN)
vulkan_acquire_next_image(&khr->vk);
khr->vk.context.invalid_swapchain = true;
khr->vk.flags &= ~VK_DATA_FLAG_NEED_NEW_SWAPCHAIN;
khr->vk.context.flags |= VK_CTX_FLAG_INVALID_SWAPCHAIN;
khr->vk.flags &= ~VK_DATA_FLAG_NEED_NEW_SWAPCHAIN;
return true;
}
@ -231,9 +231,9 @@ static void gfx_ctx_khr_display_set_swap_interval(void *data,
static void gfx_ctx_khr_display_swap_buffers(void *data)
{
khr_display_ctx_data_t *khr = (khr_display_ctx_data_t*)data;
if (khr->vk.context.has_acquired_swapchain)
if (khr->vk.context.flags & VK_CTX_FLAG_HAS_ACQUIRED_SWAPCHAIN)
{
khr->vk.context.has_acquired_swapchain = false;
khr->vk.context.flags &= ~VK_CTX_FLAG_HAS_ACQUIRED_SWAPCHAIN;
if (khr->vk.swapchain == VK_NULL_HANDLE)
{
retro_sleep(10);

6
gfx/drivers_context/w_vk_ctx.c
View File

@ -125,9 +125,9 @@ static void gfx_ctx_w_vk_check_window(void *data, bool *quit,
static void gfx_ctx_w_vk_swap_buffers(void *data)
{
if (win32_vk.context.has_acquired_swapchain)
if (win32_vk.context.flags & VK_CTX_FLAG_HAS_ACQUIRED_SWAPCHAIN)
{
win32_vk.context.has_acquired_swapchain = false;
win32_vk.context.flags &= ~VK_CTX_FLAG_HAS_ACQUIRED_SWAPCHAIN;
/* We're still waiting for a proper swapchain, so just fake it. */
if (win32_vk.swapchain == VK_NULL_HANDLE)
retro_sleep(10);
@ -144,7 +144,7 @@ static bool gfx_ctx_w_vk_set_resize(void *data,
{
if (win32_vk.flags & VK_DATA_FLAG_CREATED_NEW_SWAPCHAIN)
vulkan_acquire_next_image(&win32_vk);
win32_vk.context.invalid_swapchain = true;
win32_vk.context.flags |= VK_CTX_FLAG_INVALID_SWAPCHAIN;
win32_vk.flags &= ~VK_DATA_FLAG_NEED_NEW_SWAPCHAIN;
return true;

8
gfx/drivers_context/wayland_vk_ctx.c
View File

@ -95,11 +95,11 @@ static bool gfx_ctx_wl_set_resize(void *data, unsigned width, unsigned height)
if (vulkan_create_swapchain(&wl->vk, width, height, wl->swap_interval))
{
wl->vk.context.invalid_swapchain = true;
wl->vk.context.flags |= VK_CTX_FLAG_INVALID_SWAPCHAIN;
if (wl->vk.flags & VK_DATA_FLAG_CREATED_NEW_SWAPCHAIN)
vulkan_acquire_next_image(&wl->vk);
wl->vk.flags &= ~VK_DATA_FLAG_NEED_NEW_SWAPCHAIN;
wl->vk.flags &= ~VK_DATA_FLAG_NEED_NEW_SWAPCHAIN;
wl_surface_set_buffer_scale(wl->surface, wl->buffer_scale);
@ -273,9 +273,9 @@ static void gfx_ctx_wl_swap_buffers(void *data)
{
gfx_ctx_wayland_data_t *wl = (gfx_ctx_wayland_data_t*)data;
if (wl->vk.context.has_acquired_swapchain)
if (wl->vk.context.flags & VK_CTX_FLAG_HAS_ACQUIRED_SWAPCHAIN)
{
wl->vk.context.has_acquired_swapchain = false;
wl->vk.context.flags &= ~VK_CTX_FLAG_HAS_ACQUIRED_SWAPCHAIN;
if (wl->vk.swapchain == VK_NULL_HANDLE)
{
retro_sleep(10);

8
gfx/drivers_context/x_vk_ctx.c
View File

@ -149,9 +149,9 @@ static void gfx_ctx_x_vk_swap_buffers(void *data)
{
gfx_ctx_x_vk_data_t *x = (gfx_ctx_x_vk_data_t*)data;
if (x->vk.context.has_acquired_swapchain)
if (x->vk.context.flags & VK_CTX_FLAG_HAS_ACQUIRED_SWAPCHAIN)
{
x->vk.context.has_acquired_swapchain = false;
x->vk.context.flags &= ~VK_CTX_FLAG_HAS_ACQUIRED_SWAPCHAIN;
if (x->vk.swapchain == VK_NULL_HANDLE)
{
retro_sleep(10);
@ -200,8 +200,8 @@ static bool gfx_ctx_x_vk_set_resize(void *data,
if (x->vk.flags & VK_DATA_FLAG_CREATED_NEW_SWAPCHAIN)
vulkan_acquire_next_image(&x->vk);
x->vk.context.invalid_swapchain = true;
x->vk.flags &= ~VK_DATA_FLAG_NEED_NEW_SWAPCHAIN;
x->vk.context.flags |= VK_CTX_FLAG_INVALID_SWAPCHAIN;
x->vk.flags &= ~VK_DATA_FLAG_NEED_NEW_SWAPCHAIN;
return true;
}