2016-02-16 19:24:00 +00:00
|
|
|
/* RetroArch - A frontend for libretro.
|
2017-01-22 12:40:32 +00:00
|
|
|
* Copyright (C) 2016-2017 - Hans-Kristian Arntzen
|
|
|
|
* Copyright (C) 2011-2017 - Daniel De Matteis
|
2016-02-16 19:24:00 +00:00
|
|
|
*
|
|
|
|
* RetroArch is free software: you can redistribute it and/or modify it under the terms
|
|
|
|
* of the GNU General Public License as published by the Free Software Found-
|
|
|
|
* ation, either version 3 of the License, or (at your option) any later version.
|
|
|
|
*
|
|
|
|
* RetroArch is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
|
|
|
|
* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
|
|
|
|
* PURPOSE. See the GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License along with RetroArch.
|
|
|
|
* If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <stdint.h>
|
|
|
|
#include <math.h>
|
|
|
|
#include <string.h>
|
|
|
|
|
|
|
|
#include <compat/strl.h>
|
|
|
|
#include <gfx/scaler/scaler.h>
|
2017-04-16 09:03:29 +00:00
|
|
|
#include <gfx/video_frame.h>
|
2016-02-16 19:24:00 +00:00
|
|
|
#include <formats/image.h>
|
|
|
|
#include <retro_inline.h>
|
|
|
|
#include <retro_miscellaneous.h>
|
2017-09-28 16:53:09 +00:00
|
|
|
#include <retro_math.h>
|
2016-02-16 19:24:00 +00:00
|
|
|
#include <retro_assert.h>
|
2016-05-10 17:03:53 +00:00
|
|
|
#include <libretro.h>
|
|
|
|
|
2016-09-11 12:46:53 +00:00
|
|
|
#ifdef HAVE_CONFIG_H
|
|
|
|
#include "../../config.h"
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef HAVE_MENU
|
|
|
|
#include "../../menu/menu_driver.h"
|
|
|
|
#endif
|
|
|
|
|
2017-01-19 16:20:42 +00:00
|
|
|
#include "../font_driver.h"
|
|
|
|
|
2016-05-10 17:03:53 +00:00
|
|
|
#include "../common/vulkan_common.h"
|
2016-02-16 19:24:00 +00:00
|
|
|
|
|
|
|
#include "../../driver.h"
|
2016-09-05 16:31:32 +00:00
|
|
|
#include "../../configuration.h"
|
2016-02-16 19:24:00 +00:00
|
|
|
#include "../../record/record_driver.h"
|
|
|
|
|
|
|
|
#include "../../retroarch.h"
|
2016-09-01 16:18:55 +00:00
|
|
|
#include "../../verbosity.h"
|
2016-02-16 19:24:00 +00:00
|
|
|
|
2016-03-05 06:27:48 +00:00
|
|
|
#include "../video_coord_array.h"
|
2016-02-16 19:24:00 +00:00
|
|
|
|
|
|
|
static void vulkan_set_viewport(void *data, unsigned viewport_width,
|
|
|
|
unsigned viewport_height, bool force_full, bool allow_rotate);
|
|
|
|
|
|
|
|
#ifdef HAVE_OVERLAY
|
|
|
|
static void vulkan_overlay_free(vk_t *vk);
|
2017-01-18 22:02:24 +00:00
|
|
|
static void vulkan_render_overlay(vk_t *vk, video_frame_info_t *video_info);
|
2016-02-16 19:24:00 +00:00
|
|
|
#endif
|
2016-02-20 13:04:33 +00:00
|
|
|
static void vulkan_viewport_info(void *data, struct video_viewport *vp);
|
2016-02-16 19:24:00 +00:00
|
|
|
|
|
|
|
static const gfx_ctx_driver_t *vulkan_get_context(vk_t *vk)
|
|
|
|
{
|
2016-02-20 19:15:46 +00:00
|
|
|
unsigned major = 1;
|
|
|
|
unsigned minor = 0;
|
2016-02-16 19:24:00 +00:00
|
|
|
settings_t *settings = config_get_ptr();
|
|
|
|
enum gfx_ctx_api api = GFX_CTX_VULKAN_API;
|
|
|
|
|
2016-05-08 18:32:46 +00:00
|
|
|
return video_context_driver_init_first(
|
2017-04-28 20:59:13 +00:00
|
|
|
vk, settings->arrays.video_context_driver,
|
2016-02-16 19:24:00 +00:00
|
|
|
api, major, minor, false);
|
|
|
|
}
|
|
|
|
|
2016-02-29 19:07:11 +00:00
|
|
|
static void vulkan_init_render_pass(
|
|
|
|
vk_t *vk)
|
2016-02-16 19:24:00 +00:00
|
|
|
{
|
2016-03-06 11:33:46 +00:00
|
|
|
VkRenderPassCreateInfo rp_info = {
|
|
|
|
VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO };
|
2016-02-16 19:24:00 +00:00
|
|
|
VkAttachmentDescription attachment = {0};
|
2016-02-29 19:07:11 +00:00
|
|
|
VkSubpassDescription subpass = {0};
|
2016-02-20 19:15:46 +00:00
|
|
|
VkAttachmentReference color_ref = { 0,
|
|
|
|
VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL };
|
2016-02-16 19:24:00 +00:00
|
|
|
|
|
|
|
/* Backbuffer format. */
|
2016-02-20 19:15:46 +00:00
|
|
|
attachment.format = vk->context->swapchain_format;
|
2016-02-16 19:24:00 +00:00
|
|
|
/* Not multisampled. */
|
2016-02-20 19:15:46 +00:00
|
|
|
attachment.samples = VK_SAMPLE_COUNT_1_BIT;
|
2016-02-16 19:24:00 +00:00
|
|
|
/* When starting the frame, we want tiles to be cleared. */
|
2016-02-20 19:15:46 +00:00
|
|
|
attachment.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
|
2016-02-16 19:24:00 +00:00
|
|
|
/* When end the frame, we want tiles to be written out. */
|
2016-02-20 19:15:46 +00:00
|
|
|
attachment.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
|
2016-02-16 19:24:00 +00:00
|
|
|
/* Don't care about stencil since we're not using it. */
|
2016-02-20 19:15:46 +00:00
|
|
|
attachment.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
|
|
|
|
attachment.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
|
2016-02-16 19:24:00 +00:00
|
|
|
|
2016-02-20 19:15:46 +00:00
|
|
|
/* The image layout will be attachment_optimal
|
|
|
|
* when we're executing the renderpass. */
|
|
|
|
attachment.initialLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
|
|
|
|
attachment.finalLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
|
2016-02-16 19:24:00 +00:00
|
|
|
|
|
|
|
/* We have one subpass.
|
|
|
|
* This subpass has 1 color attachment. */
|
2016-02-20 19:15:46 +00:00
|
|
|
subpass.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;
|
2016-02-16 19:24:00 +00:00
|
|
|
subpass.colorAttachmentCount = 1;
|
2016-02-20 19:15:46 +00:00
|
|
|
subpass.pColorAttachments = &color_ref;
|
2016-02-16 19:24:00 +00:00
|
|
|
|
|
|
|
/* Finally, create the renderpass. */
|
2016-02-20 19:15:46 +00:00
|
|
|
rp_info.attachmentCount = 1;
|
|
|
|
rp_info.pAttachments = &attachment;
|
|
|
|
rp_info.subpassCount = 1;
|
|
|
|
rp_info.pSubpasses = &subpass;
|
2016-02-16 19:24:00 +00:00
|
|
|
|
2016-06-26 11:10:19 +00:00
|
|
|
vkCreateRenderPass(vk->context->device,
|
2016-02-20 19:15:46 +00:00
|
|
|
&rp_info, NULL, &vk->render_pass);
|
2016-02-16 19:24:00 +00:00
|
|
|
}
|
|
|
|
|
2016-02-29 18:43:54 +00:00
|
|
|
static void vulkan_init_framebuffers(
|
|
|
|
vk_t *vk)
|
2016-02-16 19:24:00 +00:00
|
|
|
{
|
|
|
|
unsigned i;
|
2016-02-29 16:06:41 +00:00
|
|
|
|
2016-03-01 01:21:53 +00:00
|
|
|
vulkan_init_render_pass(vk);
|
2016-02-16 19:24:00 +00:00
|
|
|
|
|
|
|
for (i = 0; i < vk->num_swapchain_images; i++)
|
|
|
|
{
|
2016-06-25 11:52:33 +00:00
|
|
|
VkImageViewCreateInfo view =
|
|
|
|
{ VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO };
|
|
|
|
VkFramebufferCreateInfo info =
|
|
|
|
{ VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO };
|
2016-02-16 19:24:00 +00:00
|
|
|
|
2016-02-20 19:15:46 +00:00
|
|
|
vk->swapchain[i].backbuffer.image = vk->context->swapchain_images[i];
|
2016-02-16 19:24:00 +00:00
|
|
|
|
|
|
|
/* Create an image view which we can render into. */
|
2016-02-20 19:15:46 +00:00
|
|
|
view.viewType = VK_IMAGE_VIEW_TYPE_2D;
|
|
|
|
view.format = vk->context->swapchain_format;
|
|
|
|
view.image = vk->swapchain[i].backbuffer.image;
|
|
|
|
view.subresourceRange.baseMipLevel = 0;
|
2016-02-16 19:24:00 +00:00
|
|
|
view.subresourceRange.baseArrayLayer = 0;
|
2016-02-20 19:15:46 +00:00
|
|
|
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;
|
2016-02-16 19:24:00 +00:00
|
|
|
|
2016-06-26 11:10:19 +00:00
|
|
|
vkCreateImageView(vk->context->device,
|
2016-02-16 19:24:00 +00:00
|
|
|
&view, NULL, &vk->swapchain[i].backbuffer.view);
|
|
|
|
|
|
|
|
/* Create the framebuffer */
|
2016-02-20 19:15:46 +00:00
|
|
|
info.renderPass = vk->render_pass;
|
2016-02-16 19:24:00 +00:00
|
|
|
info.attachmentCount = 1;
|
2016-02-20 19:15:46 +00:00
|
|
|
info.pAttachments = &vk->swapchain[i].backbuffer.view;
|
|
|
|
info.width = vk->context->swapchain_width;
|
|
|
|
info.height = vk->context->swapchain_height;
|
|
|
|
info.layers = 1;
|
2016-02-16 19:24:00 +00:00
|
|
|
|
2016-06-26 11:10:19 +00:00
|
|
|
vkCreateFramebuffer(vk->context->device,
|
2016-02-16 19:24:00 +00:00
|
|
|
&info, NULL, &vk->swapchain[i].backbuffer.framebuffer);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-02-29 18:43:54 +00:00
|
|
|
static void vulkan_init_pipeline_layout(
|
|
|
|
vk_t *vk)
|
2016-02-16 19:24:00 +00:00
|
|
|
{
|
2016-02-20 19:15:46 +00:00
|
|
|
VkDescriptorSetLayoutCreateInfo set_layout_info = {
|
|
|
|
VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO };
|
|
|
|
VkPipelineLayoutCreateInfo layout_info = {
|
|
|
|
VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO };
|
|
|
|
VkDescriptorSetLayoutBinding bindings[2] = {{0}};
|
2016-02-16 19:24:00 +00:00
|
|
|
|
2016-02-20 19:15:46 +00:00
|
|
|
bindings[0].binding = 0;
|
|
|
|
bindings[0].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
|
|
|
|
bindings[0].descriptorCount = 1;
|
2016-05-08 09:11:28 +00:00
|
|
|
bindings[0].stageFlags = VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT;
|
2016-02-18 17:36:07 +00:00
|
|
|
bindings[0].pImmutableSamplers = NULL;
|
|
|
|
|
2016-02-20 19:15:46 +00:00
|
|
|
bindings[1].binding = 1;
|
|
|
|
bindings[1].descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
|
|
|
|
bindings[1].descriptorCount = 1;
|
|
|
|
bindings[1].stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT;
|
2016-02-18 17:36:07 +00:00
|
|
|
bindings[1].pImmutableSamplers = NULL;
|
2016-02-16 19:24:00 +00:00
|
|
|
|
2016-02-20 19:15:46 +00:00
|
|
|
set_layout_info.bindingCount = 2;
|
|
|
|
set_layout_info.pBindings = bindings;
|
2016-02-16 19:24:00 +00:00
|
|
|
|
2016-06-26 11:10:19 +00:00
|
|
|
vkCreateDescriptorSetLayout(vk->context->device,
|
2016-02-20 19:15:46 +00:00
|
|
|
&set_layout_info, NULL, &vk->pipelines.set_layout);
|
2016-02-16 19:24:00 +00:00
|
|
|
|
2016-02-20 19:15:46 +00:00
|
|
|
layout_info.setLayoutCount = 1;
|
|
|
|
layout_info.pSetLayouts = &vk->pipelines.set_layout;
|
2016-02-16 19:24:00 +00:00
|
|
|
|
2016-06-26 11:10:19 +00:00
|
|
|
vkCreatePipelineLayout(vk->context->device,
|
2016-02-20 19:15:46 +00:00
|
|
|
&layout_info, NULL, &vk->pipelines.layout);
|
2016-02-16 19:24:00 +00:00
|
|
|
}
|
|
|
|
|
2016-02-29 18:44:46 +00:00
|
|
|
static void vulkan_init_pipelines(
|
|
|
|
vk_t *vk)
|
2016-02-16 19:24:00 +00:00
|
|
|
{
|
2016-06-25 12:55:03 +00:00
|
|
|
static const uint32_t alpha_blend_vert[] =
|
|
|
|
#include "vulkan_shaders/alpha_blend.vert.inc"
|
|
|
|
;
|
|
|
|
|
|
|
|
static const uint32_t alpha_blend_frag[] =
|
|
|
|
#include "vulkan_shaders/alpha_blend.frag.inc"
|
|
|
|
;
|
|
|
|
|
|
|
|
static const uint32_t font_frag[] =
|
|
|
|
#include "vulkan_shaders/font.frag.inc"
|
|
|
|
;
|
|
|
|
|
2016-12-12 12:17:20 +00:00
|
|
|
static const uint32_t pipeline_ribbon_vert[] =
|
|
|
|
#include "vulkan_shaders/pipeline_ribbon.vert.inc"
|
2016-06-25 12:55:03 +00:00
|
|
|
;
|
|
|
|
|
2016-12-12 12:17:20 +00:00
|
|
|
static const uint32_t pipeline_ribbon_frag[] =
|
|
|
|
#include "vulkan_shaders/pipeline_ribbon.frag.inc"
|
2016-06-25 12:55:03 +00:00
|
|
|
;
|
|
|
|
|
2016-12-12 12:17:20 +00:00
|
|
|
static const uint32_t pipeline_ribbon_simple_vert[] =
|
|
|
|
#include "vulkan_shaders/pipeline_ribbon_simple.vert.inc"
|
2016-06-25 12:55:03 +00:00
|
|
|
;
|
|
|
|
|
2016-12-12 12:17:20 +00:00
|
|
|
static const uint32_t pipeline_ribbon_simple_frag[] =
|
|
|
|
#include "vulkan_shaders/pipeline_ribbon_simple.frag.inc"
|
2016-06-25 12:55:03 +00:00
|
|
|
;
|
|
|
|
|
2017-02-20 19:51:24 +00:00
|
|
|
static const uint32_t pipeline_snow_simple_frag[] =
|
|
|
|
#include "vulkan_shaders/pipeline_snow_simple.frag.inc"
|
|
|
|
;
|
|
|
|
|
2017-02-20 20:51:58 +00:00
|
|
|
static const uint32_t pipeline_snow_frag[] =
|
|
|
|
#include "vulkan_shaders/pipeline_snow.frag.inc"
|
|
|
|
;
|
|
|
|
|
2017-02-21 04:59:05 +00:00
|
|
|
static const uint32_t pipeline_bokeh_frag[] =
|
|
|
|
#include "vulkan_shaders/pipeline_bokeh.frag.inc"
|
|
|
|
;
|
|
|
|
|
2016-02-16 19:24:00 +00:00
|
|
|
unsigned i;
|
2016-02-20 19:15:46 +00:00
|
|
|
VkPipelineInputAssemblyStateCreateInfo input_assembly = {
|
|
|
|
VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO };
|
|
|
|
VkPipelineVertexInputStateCreateInfo vertex_input = {
|
|
|
|
VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO };
|
|
|
|
VkPipelineRasterizationStateCreateInfo raster = {
|
|
|
|
VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO };
|
|
|
|
VkPipelineColorBlendAttachmentState blend_attachment = {0};
|
|
|
|
VkPipelineColorBlendStateCreateInfo blend = {
|
|
|
|
VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO };
|
|
|
|
VkPipelineViewportStateCreateInfo viewport = {
|
|
|
|
VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO };
|
|
|
|
VkPipelineDepthStencilStateCreateInfo depth_stencil = {
|
|
|
|
VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO };
|
|
|
|
VkPipelineMultisampleStateCreateInfo multisample = {
|
|
|
|
VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO };
|
|
|
|
VkPipelineDynamicStateCreateInfo dynamic = {
|
|
|
|
VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO };
|
|
|
|
|
|
|
|
VkPipelineShaderStageCreateInfo shader_stages[2] = {
|
2016-02-16 19:24:00 +00:00
|
|
|
{ VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO },
|
|
|
|
{ VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO },
|
|
|
|
};
|
|
|
|
|
2016-02-20 19:15:46 +00:00
|
|
|
VkGraphicsPipelineCreateInfo pipe = {
|
|
|
|
VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO };
|
|
|
|
VkShaderModuleCreateInfo module_info = {
|
|
|
|
VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO };
|
|
|
|
VkVertexInputAttributeDescription attributes[3] = {{0}};
|
|
|
|
VkVertexInputBindingDescription binding = {0};
|
2016-02-16 19:24:00 +00:00
|
|
|
|
|
|
|
static const VkDynamicState dynamics[] = {
|
|
|
|
VK_DYNAMIC_STATE_VIEWPORT,
|
|
|
|
VK_DYNAMIC_STATE_SCISSOR,
|
|
|
|
};
|
|
|
|
|
2016-03-01 01:21:53 +00:00
|
|
|
vulkan_init_pipeline_layout(vk);
|
2016-02-16 19:24:00 +00:00
|
|
|
|
|
|
|
/* Input assembly */
|
|
|
|
input_assembly.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
|
|
|
|
|
|
|
|
/* VAO state */
|
2016-02-20 19:15:46 +00:00
|
|
|
attributes[0].location = 0;
|
|
|
|
attributes[0].binding = 0;
|
|
|
|
attributes[0].format = VK_FORMAT_R32G32_SFLOAT;
|
|
|
|
attributes[0].offset = 0;
|
|
|
|
attributes[1].location = 1;
|
|
|
|
attributes[1].binding = 0;
|
|
|
|
attributes[1].format = VK_FORMAT_R32G32_SFLOAT;
|
|
|
|
attributes[1].offset = 2 * sizeof(float);
|
|
|
|
attributes[2].location = 2;
|
|
|
|
attributes[2].binding = 0;
|
|
|
|
attributes[2].format = VK_FORMAT_R32G32B32A32_SFLOAT;
|
|
|
|
attributes[2].offset = 4 * sizeof(float);
|
|
|
|
|
|
|
|
binding.binding = 0;
|
|
|
|
binding.stride = sizeof(struct vk_vertex);
|
|
|
|
binding.inputRate = VK_VERTEX_INPUT_RATE_VERTEX;
|
|
|
|
|
|
|
|
vertex_input.vertexBindingDescriptionCount = 1;
|
|
|
|
vertex_input.pVertexBindingDescriptions = &binding;
|
2016-02-16 19:24:00 +00:00
|
|
|
vertex_input.vertexAttributeDescriptionCount = 3;
|
2016-02-20 19:15:46 +00:00
|
|
|
vertex_input.pVertexAttributeDescriptions = attributes;
|
2016-02-16 19:24:00 +00:00
|
|
|
|
|
|
|
/* Raster state */
|
2016-02-29 05:31:55 +00:00
|
|
|
raster.polygonMode = VK_POLYGON_MODE_FILL;
|
|
|
|
raster.cullMode = VK_CULL_MODE_NONE;
|
|
|
|
raster.frontFace = VK_FRONT_FACE_COUNTER_CLOCKWISE;
|
|
|
|
raster.depthClampEnable = false;
|
|
|
|
raster.rasterizerDiscardEnable = false;
|
|
|
|
raster.depthBiasEnable = false;
|
|
|
|
raster.lineWidth = 1.0f;
|
2016-02-16 19:24:00 +00:00
|
|
|
|
|
|
|
/* Blend state */
|
2016-02-29 05:31:55 +00:00
|
|
|
blend_attachment.blendEnable = false;
|
|
|
|
blend_attachment.colorWriteMask = 0xf;
|
|
|
|
blend.attachmentCount = 1;
|
|
|
|
blend.pAttachments = &blend_attachment;
|
2016-02-16 19:24:00 +00:00
|
|
|
|
|
|
|
/* Viewport state */
|
2016-02-29 05:31:55 +00:00
|
|
|
viewport.viewportCount = 1;
|
|
|
|
viewport.scissorCount = 1;
|
2016-02-16 19:24:00 +00:00
|
|
|
|
|
|
|
/* Depth-stencil state */
|
2016-02-29 05:31:55 +00:00
|
|
|
depth_stencil.depthTestEnable = false;
|
|
|
|
depth_stencil.depthWriteEnable = false;
|
|
|
|
depth_stencil.depthBoundsTestEnable = false;
|
|
|
|
depth_stencil.stencilTestEnable = false;
|
|
|
|
depth_stencil.minDepthBounds = 0.0f;
|
|
|
|
depth_stencil.maxDepthBounds = 1.0f;
|
2016-02-16 19:24:00 +00:00
|
|
|
|
|
|
|
/* Multisample state */
|
2016-02-29 05:31:55 +00:00
|
|
|
multisample.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT;
|
2016-02-16 19:24:00 +00:00
|
|
|
|
|
|
|
/* Dynamic state */
|
2016-02-29 05:31:55 +00:00
|
|
|
dynamic.pDynamicStates = dynamics;
|
|
|
|
dynamic.dynamicStateCount = ARRAY_SIZE(dynamics);
|
|
|
|
|
|
|
|
pipe.stageCount = 2;
|
|
|
|
pipe.pStages = shader_stages;
|
|
|
|
pipe.pVertexInputState = &vertex_input;
|
|
|
|
pipe.pInputAssemblyState = &input_assembly;
|
|
|
|
pipe.pRasterizationState = &raster;
|
|
|
|
pipe.pColorBlendState = &blend;
|
|
|
|
pipe.pMultisampleState = &multisample;
|
|
|
|
pipe.pViewportState = &viewport;
|
|
|
|
pipe.pDepthStencilState = &depth_stencil;
|
|
|
|
pipe.pDynamicState = &dynamic;
|
|
|
|
pipe.renderPass = vk->render_pass;
|
|
|
|
pipe.layout = vk->pipelines.layout;
|
|
|
|
|
2016-06-25 12:55:03 +00:00
|
|
|
module_info.codeSize = sizeof(alpha_blend_vert);
|
|
|
|
module_info.pCode = alpha_blend_vert;
|
2016-02-29 05:31:55 +00:00
|
|
|
shader_stages[0].stage = VK_SHADER_STAGE_VERTEX_BIT;
|
|
|
|
shader_stages[0].pName = "main";
|
2016-06-26 11:10:19 +00:00
|
|
|
vkCreateShaderModule(vk->context->device,
|
2016-02-20 19:15:46 +00:00
|
|
|
&module_info, NULL, &shader_stages[0].module);
|
|
|
|
|
|
|
|
blend_attachment.blendEnable = true;
|
|
|
|
blend_attachment.colorWriteMask = 0xf;
|
2016-02-16 19:24:00 +00:00
|
|
|
blend_attachment.srcColorBlendFactor = VK_BLEND_FACTOR_SRC_ALPHA;
|
|
|
|
blend_attachment.dstColorBlendFactor = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;
|
2016-02-20 19:15:46 +00:00
|
|
|
blend_attachment.colorBlendOp = VK_BLEND_OP_ADD;
|
2016-02-16 19:24:00 +00:00
|
|
|
blend_attachment.srcAlphaBlendFactor = VK_BLEND_FACTOR_SRC_ALPHA;
|
|
|
|
blend_attachment.dstAlphaBlendFactor = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;
|
2016-02-21 12:40:19 +00:00
|
|
|
blend_attachment.alphaBlendOp = VK_BLEND_OP_ADD;
|
2016-02-16 19:24:00 +00:00
|
|
|
|
2016-02-21 12:52:30 +00:00
|
|
|
/* Glyph pipeline */
|
2016-06-25 12:55:03 +00:00
|
|
|
module_info.codeSize = sizeof(font_frag);
|
|
|
|
module_info.pCode = font_frag;
|
2016-02-29 05:31:55 +00:00
|
|
|
shader_stages[1].stage = VK_SHADER_STAGE_FRAGMENT_BIT;
|
|
|
|
shader_stages[1].pName = "main";
|
2016-06-26 11:10:19 +00:00
|
|
|
vkCreateShaderModule(vk->context->device,
|
2016-02-21 12:52:30 +00:00
|
|
|
&module_info, NULL, &shader_stages[1].module);
|
|
|
|
|
2016-06-26 11:10:19 +00:00
|
|
|
vkCreateGraphicsPipelines(vk->context->device, vk->pipelines.cache,
|
2016-02-21 12:52:30 +00:00
|
|
|
1, &pipe, NULL, &vk->pipelines.font);
|
2016-06-26 11:10:19 +00:00
|
|
|
vkDestroyShaderModule(vk->context->device, shader_stages[1].module, NULL);
|
2016-02-21 12:52:30 +00:00
|
|
|
|
|
|
|
/* Alpha-blended pipeline. */
|
2016-06-25 12:55:03 +00:00
|
|
|
module_info.codeSize = sizeof(alpha_blend_frag);
|
|
|
|
module_info.pCode = alpha_blend_frag;
|
2016-02-21 12:52:30 +00:00
|
|
|
shader_stages[1].stage = VK_SHADER_STAGE_FRAGMENT_BIT;
|
|
|
|
shader_stages[1].pName = "main";
|
2016-06-26 11:10:19 +00:00
|
|
|
vkCreateShaderModule(vk->context->device,
|
2016-02-21 12:52:30 +00:00
|
|
|
&module_info, NULL, &shader_stages[1].module);
|
|
|
|
|
2016-06-26 11:10:19 +00:00
|
|
|
vkCreateGraphicsPipelines(vk->context->device, vk->pipelines.cache,
|
2016-02-16 19:24:00 +00:00
|
|
|
1, &pipe, NULL, &vk->pipelines.alpha_blend);
|
|
|
|
|
|
|
|
/* Build display pipelines. */
|
|
|
|
for (i = 0; i < 4; i++)
|
|
|
|
{
|
|
|
|
input_assembly.topology = i & 2 ?
|
|
|
|
VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP :
|
|
|
|
VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
|
|
|
|
blend_attachment.blendEnable = i & 1;
|
2016-06-26 11:10:19 +00:00
|
|
|
vkCreateGraphicsPipelines(vk->context->device, vk->pipelines.cache,
|
2016-02-16 19:24:00 +00:00
|
|
|
1, &pipe, NULL, &vk->display.pipelines[i]);
|
|
|
|
}
|
|
|
|
|
2016-06-26 11:10:19 +00:00
|
|
|
vkDestroyShaderModule(vk->context->device, shader_stages[0].module, NULL);
|
|
|
|
vkDestroyShaderModule(vk->context->device, shader_stages[1].module, NULL);
|
2016-05-08 09:11:28 +00:00
|
|
|
|
|
|
|
/* Other menu pipelines. */
|
2017-02-20 19:51:24 +00:00
|
|
|
for (i = 0; i < ARRAY_SIZE(vk->display.pipelines) - 4; i++)
|
2016-05-08 09:11:28 +00:00
|
|
|
{
|
2017-02-20 19:51:24 +00:00
|
|
|
switch (i >> 1)
|
2016-05-08 09:11:28 +00:00
|
|
|
{
|
2017-02-20 19:51:24 +00:00
|
|
|
case 0:
|
|
|
|
module_info.codeSize = sizeof(pipeline_ribbon_vert);
|
|
|
|
module_info.pCode = pipeline_ribbon_vert;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 1:
|
|
|
|
module_info.codeSize = sizeof(pipeline_ribbon_simple_vert);
|
|
|
|
module_info.pCode = pipeline_ribbon_simple_vert;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 2:
|
|
|
|
module_info.codeSize = sizeof(alpha_blend_vert);
|
|
|
|
module_info.pCode = alpha_blend_vert;
|
|
|
|
break;
|
|
|
|
|
2017-02-20 20:51:58 +00:00
|
|
|
case 3:
|
|
|
|
module_info.codeSize = sizeof(alpha_blend_vert);
|
|
|
|
module_info.pCode = alpha_blend_vert;
|
|
|
|
break;
|
|
|
|
|
2017-02-21 04:59:05 +00:00
|
|
|
case 4:
|
|
|
|
module_info.codeSize = sizeof(alpha_blend_vert);
|
|
|
|
module_info.pCode = alpha_blend_vert;
|
|
|
|
break;
|
|
|
|
|
2017-02-20 19:51:24 +00:00
|
|
|
default:
|
|
|
|
retro_assert(0 && "No shader for menu pipeline.");
|
|
|
|
break;
|
2016-05-08 09:11:28 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
shader_stages[0].stage = VK_SHADER_STAGE_VERTEX_BIT;
|
|
|
|
shader_stages[0].pName = "main";
|
2016-06-26 11:10:19 +00:00
|
|
|
vkCreateShaderModule(vk->context->device,
|
2016-05-08 09:11:28 +00:00
|
|
|
&module_info, NULL, &shader_stages[0].module);
|
|
|
|
|
2017-02-20 19:51:24 +00:00
|
|
|
switch (i >> 1)
|
2016-05-08 09:11:28 +00:00
|
|
|
{
|
2017-02-20 19:51:24 +00:00
|
|
|
case 0:
|
|
|
|
module_info.codeSize = sizeof(pipeline_ribbon_frag);
|
|
|
|
module_info.pCode = pipeline_ribbon_frag;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 1:
|
|
|
|
module_info.codeSize = sizeof(pipeline_ribbon_simple_frag);
|
|
|
|
module_info.pCode = pipeline_ribbon_simple_frag;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 2:
|
|
|
|
module_info.codeSize = sizeof(pipeline_snow_simple_frag);
|
|
|
|
module_info.pCode = pipeline_snow_simple_frag;
|
|
|
|
break;
|
|
|
|
|
2017-02-20 20:51:58 +00:00
|
|
|
case 3:
|
|
|
|
module_info.codeSize = sizeof(pipeline_snow_frag);
|
|
|
|
module_info.pCode = pipeline_snow_frag;
|
|
|
|
break;
|
|
|
|
|
2017-02-21 04:59:05 +00:00
|
|
|
case 4:
|
|
|
|
module_info.codeSize = sizeof(pipeline_bokeh_frag);
|
|
|
|
module_info.pCode = pipeline_bokeh_frag;
|
|
|
|
break;
|
|
|
|
|
2017-02-20 19:51:24 +00:00
|
|
|
default:
|
|
|
|
retro_assert(0 && "No shader for menu pipeline.");
|
|
|
|
break;
|
2016-05-08 09:11:28 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
shader_stages[1].stage = VK_SHADER_STAGE_FRAGMENT_BIT;
|
|
|
|
shader_stages[1].pName = "main";
|
2016-06-26 11:10:19 +00:00
|
|
|
vkCreateShaderModule(vk->context->device,
|
2016-05-08 09:11:28 +00:00
|
|
|
&module_info, NULL, &shader_stages[1].module);
|
|
|
|
|
2017-05-21 23:29:56 +00:00
|
|
|
switch (i >> 1)
|
|
|
|
{
|
|
|
|
case 0:
|
|
|
|
case 1:
|
|
|
|
blend_attachment.srcColorBlendFactor = VK_BLEND_FACTOR_ONE;
|
|
|
|
blend_attachment.dstColorBlendFactor = VK_BLEND_FACTOR_ONE;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
blend_attachment.srcColorBlendFactor = VK_BLEND_FACTOR_SRC_ALPHA;
|
|
|
|
blend_attachment.dstColorBlendFactor = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2016-05-08 09:11:28 +00:00
|
|
|
input_assembly.topology = i & 1 ?
|
|
|
|
VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP :
|
|
|
|
VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
|
|
|
|
|
2016-06-26 11:10:19 +00:00
|
|
|
vkCreateGraphicsPipelines(vk->context->device, vk->pipelines.cache,
|
2016-05-08 09:11:28 +00:00
|
|
|
1, &pipe, NULL, &vk->display.pipelines[4 + i]);
|
2016-06-25 12:06:14 +00:00
|
|
|
|
2016-06-26 11:10:19 +00:00
|
|
|
vkDestroyShaderModule(vk->context->device, shader_stages[0].module, NULL);
|
|
|
|
vkDestroyShaderModule(vk->context->device, shader_stages[1].module, NULL);
|
2016-05-08 09:11:28 +00:00
|
|
|
}
|
2016-02-16 19:24:00 +00:00
|
|
|
}
|
|
|
|
|
2016-03-01 01:21:53 +00:00
|
|
|
static void vulkan_init_command_buffers(vk_t *vk)
|
2016-02-16 19:24:00 +00:00
|
|
|
{
|
|
|
|
/* RESET_COMMAND_BUFFER_BIT allows command buffer to be reset. */
|
|
|
|
unsigned i;
|
2016-02-29 16:06:41 +00:00
|
|
|
|
2016-02-16 19:24:00 +00:00
|
|
|
for (i = 0; i < vk->num_swapchain_images; i++)
|
|
|
|
{
|
2016-02-20 19:15:46 +00:00
|
|
|
VkCommandPoolCreateInfo pool_info = {
|
|
|
|
VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO };
|
|
|
|
VkCommandBufferAllocateInfo info = {
|
|
|
|
VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO };
|
2016-02-16 19:24:00 +00:00
|
|
|
|
|
|
|
pool_info.queueFamilyIndex = vk->context->graphics_queue_index;
|
2016-02-20 19:15:46 +00:00
|
|
|
pool_info.flags =
|
|
|
|
VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT;
|
2016-02-29 15:41:49 +00:00
|
|
|
|
2016-06-26 11:10:19 +00:00
|
|
|
vkCreateCommandPool(vk->context->device,
|
2016-02-20 19:15:46 +00:00
|
|
|
&pool_info, NULL, &vk->swapchain[i].cmd_pool);
|
2016-02-16 19:24:00 +00:00
|
|
|
|
2016-02-29 15:41:49 +00:00
|
|
|
info.commandPool = vk->swapchain[i].cmd_pool;
|
|
|
|
info.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
|
|
|
|
info.commandBufferCount = 1;
|
|
|
|
|
2016-06-26 11:10:19 +00:00
|
|
|
vkAllocateCommandBuffers(vk->context->device,
|
2016-02-20 19:15:46 +00:00
|
|
|
&info, &vk->swapchain[i].cmd);
|
2016-02-16 19:24:00 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-03-01 01:21:53 +00:00
|
|
|
static void vulkan_init_samplers(vk_t *vk)
|
2016-02-16 19:24:00 +00:00
|
|
|
{
|
2016-06-25 11:52:33 +00:00
|
|
|
VkSamplerCreateInfo info =
|
|
|
|
{ VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO };
|
2016-02-29 18:11:09 +00:00
|
|
|
|
2016-02-20 19:15:46 +00:00
|
|
|
info.magFilter = VK_FILTER_NEAREST;
|
|
|
|
info.minFilter = VK_FILTER_NEAREST;
|
|
|
|
info.mipmapMode = VK_SAMPLER_MIPMAP_MODE_NEAREST;
|
|
|
|
info.addressModeU = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
|
|
|
|
info.addressModeV = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
|
|
|
|
info.addressModeW = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
|
|
|
|
info.mipLodBias = 0.0f;
|
|
|
|
info.maxAnisotropy = 1.0f;
|
|
|
|
info.compareEnable = false;
|
|
|
|
info.minLod = 0.0f;
|
|
|
|
info.maxLod = 0.0f;
|
2016-02-16 19:24:00 +00:00
|
|
|
info.unnormalizedCoordinates = false;
|
2016-02-20 19:15:46 +00:00
|
|
|
info.borderColor = VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE;
|
2016-06-26 11:10:19 +00:00
|
|
|
vkCreateSampler(vk->context->device,
|
2016-02-29 18:11:09 +00:00
|
|
|
&info, NULL, &vk->samplers.nearest);
|
2016-02-20 19:15:46 +00:00
|
|
|
|
2016-07-31 11:47:10 +00:00
|
|
|
info.magFilter = VK_FILTER_LINEAR;
|
|
|
|
info.minFilter = VK_FILTER_LINEAR;
|
2016-06-26 11:10:19 +00:00
|
|
|
vkCreateSampler(vk->context->device,
|
2016-02-29 18:11:09 +00:00
|
|
|
&info, NULL, &vk->samplers.linear);
|
2016-07-31 11:47:10 +00:00
|
|
|
|
|
|
|
info.maxLod = VK_LOD_CLAMP_NONE;
|
|
|
|
info.magFilter = VK_FILTER_NEAREST;
|
|
|
|
info.minFilter = VK_FILTER_NEAREST;
|
|
|
|
info.mipmapMode = VK_SAMPLER_MIPMAP_MODE_NEAREST;
|
|
|
|
vkCreateSampler(vk->context->device,
|
|
|
|
&info, NULL, &vk->samplers.mipmap_nearest);
|
|
|
|
|
|
|
|
info.magFilter = VK_FILTER_LINEAR;
|
|
|
|
info.minFilter = VK_FILTER_LINEAR;
|
|
|
|
info.mipmapMode = VK_SAMPLER_MIPMAP_MODE_LINEAR;
|
|
|
|
vkCreateSampler(vk->context->device,
|
|
|
|
&info, NULL, &vk->samplers.mipmap_linear);
|
2016-02-16 19:24:00 +00:00
|
|
|
}
|
|
|
|
|
2016-03-01 01:21:53 +00:00
|
|
|
static void vulkan_deinit_samplers(vk_t *vk)
|
2016-02-16 19:24:00 +00:00
|
|
|
{
|
2016-06-26 11:10:19 +00:00
|
|
|
vkDestroySampler(vk->context->device, vk->samplers.nearest, NULL);
|
|
|
|
vkDestroySampler(vk->context->device, vk->samplers.linear, NULL);
|
2016-07-31 11:47:10 +00:00
|
|
|
vkDestroySampler(vk->context->device, vk->samplers.mipmap_nearest, NULL);
|
|
|
|
vkDestroySampler(vk->context->device, vk->samplers.mipmap_linear, NULL);
|
2016-02-16 19:24:00 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void vulkan_init_buffers(vk_t *vk)
|
|
|
|
{
|
|
|
|
unsigned i;
|
|
|
|
for (i = 0; i < vk->num_swapchain_images; i++)
|
|
|
|
{
|
|
|
|
vk->swapchain[i].vbo = vulkan_buffer_chain_init(
|
|
|
|
VULKAN_BUFFER_BLOCK_SIZE, 16, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT);
|
|
|
|
vk->swapchain[i].ubo = vulkan_buffer_chain_init(
|
|
|
|
VULKAN_BUFFER_BLOCK_SIZE,
|
|
|
|
vk->context->gpu_properties.limits.minUniformBufferOffsetAlignment,
|
|
|
|
VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void vulkan_deinit_buffers(vk_t *vk)
|
|
|
|
{
|
|
|
|
unsigned i;
|
|
|
|
for (i = 0; i < vk->num_swapchain_images; i++)
|
|
|
|
{
|
2016-03-01 01:21:53 +00:00
|
|
|
vulkan_buffer_chain_free(
|
2016-02-29 18:03:18 +00:00
|
|
|
vk->context->device, &vk->swapchain[i].vbo);
|
2016-03-01 01:21:53 +00:00
|
|
|
vulkan_buffer_chain_free(
|
2016-02-29 18:03:18 +00:00
|
|
|
vk->context->device, &vk->swapchain[i].ubo);
|
2016-02-16 19:24:00 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void vulkan_init_descriptor_pool(vk_t *vk)
|
|
|
|
{
|
|
|
|
unsigned i;
|
2016-02-18 17:36:07 +00:00
|
|
|
static const VkDescriptorPoolSize pool_sizes[2] = {
|
2016-03-01 08:44:18 +00:00
|
|
|
{ VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, VULKAN_DESCRIPTOR_MANAGER_BLOCK_SETS },
|
|
|
|
{ VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, VULKAN_DESCRIPTOR_MANAGER_BLOCK_SETS },
|
2016-02-16 19:24:00 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
for (i = 0; i < vk->num_swapchain_images; i++)
|
|
|
|
{
|
2016-02-20 19:15:46 +00:00
|
|
|
vk->swapchain[i].descriptor_manager =
|
2016-02-29 17:40:30 +00:00
|
|
|
vulkan_create_descriptor_manager(
|
|
|
|
vk->context->device,
|
|
|
|
pool_sizes, 2, vk->pipelines.set_layout);
|
2016-02-16 19:24:00 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void vulkan_deinit_descriptor_pool(vk_t *vk)
|
|
|
|
{
|
|
|
|
unsigned i;
|
|
|
|
for (i = 0; i < vk->num_swapchain_images; i++)
|
2016-02-29 22:09:05 +00:00
|
|
|
vulkan_destroy_descriptor_manager(
|
|
|
|
vk->context->device,
|
2016-02-20 19:15:46 +00:00
|
|
|
&vk->swapchain[i].descriptor_manager);
|
2016-02-16 19:24:00 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void vulkan_init_textures(vk_t *vk)
|
|
|
|
{
|
|
|
|
unsigned i;
|
2016-03-01 01:21:53 +00:00
|
|
|
vulkan_init_samplers(vk);
|
2016-02-16 19:24:00 +00:00
|
|
|
|
|
|
|
if (!vk->hw.enable)
|
|
|
|
{
|
|
|
|
for (i = 0; i < vk->num_swapchain_images; i++)
|
|
|
|
{
|
|
|
|
vk->swapchain[i].texture = vulkan_create_texture(vk, NULL,
|
2016-02-20 19:15:46 +00:00
|
|
|
vk->tex_w, vk->tex_h, vk->tex_fmt,
|
|
|
|
NULL, NULL, VULKAN_TEXTURE_STREAMED);
|
2016-02-29 18:03:18 +00:00
|
|
|
|
2016-03-01 01:21:53 +00:00
|
|
|
vulkan_map_persistent_texture(
|
2016-02-29 18:03:18 +00:00
|
|
|
vk->context->device,
|
2016-02-16 19:24:00 +00:00
|
|
|
&vk->swapchain[i].texture);
|
2016-02-21 11:33:16 +00:00
|
|
|
|
|
|
|
if (vk->swapchain[i].texture.type == VULKAN_TEXTURE_STAGING)
|
|
|
|
vk->swapchain[i].texture_optimal = vulkan_create_texture(vk, NULL,
|
|
|
|
vk->tex_w, vk->tex_h, vk->tex_fmt,
|
|
|
|
NULL, NULL, VULKAN_TEXTURE_DYNAMIC);
|
2016-02-16 19:24:00 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void vulkan_deinit_textures(vk_t *vk)
|
|
|
|
{
|
|
|
|
unsigned i;
|
2016-02-29 18:11:09 +00:00
|
|
|
|
2016-03-01 01:21:53 +00:00
|
|
|
vulkan_deinit_samplers(vk);
|
2016-02-29 18:11:09 +00:00
|
|
|
|
2016-02-16 19:24:00 +00:00
|
|
|
for (i = 0; i < vk->num_swapchain_images; i++)
|
2016-02-21 11:33:16 +00:00
|
|
|
{
|
2016-02-16 19:24:00 +00:00
|
|
|
if (vk->swapchain[i].texture.memory != VK_NULL_HANDLE)
|
2016-03-01 01:21:53 +00:00
|
|
|
vulkan_destroy_texture(
|
2016-02-29 18:03:18 +00:00
|
|
|
vk->context->device, &vk->swapchain[i].texture);
|
|
|
|
|
2016-02-21 11:33:16 +00:00
|
|
|
if (vk->swapchain[i].texture_optimal.memory != VK_NULL_HANDLE)
|
2016-03-01 01:21:53 +00:00
|
|
|
vulkan_destroy_texture(
|
2016-02-29 18:03:18 +00:00
|
|
|
vk->context->device, &vk->swapchain[i].texture_optimal);
|
2016-02-21 11:33:16 +00:00
|
|
|
}
|
2016-02-16 19:24:00 +00:00
|
|
|
}
|
|
|
|
|
2016-03-01 01:21:53 +00:00
|
|
|
static void vulkan_deinit_command_buffers(vk_t *vk)
|
2016-02-16 19:24:00 +00:00
|
|
|
{
|
|
|
|
unsigned i;
|
|
|
|
for (i = 0; i < vk->num_swapchain_images; i++)
|
|
|
|
{
|
|
|
|
if (vk->swapchain[i].cmd)
|
2016-06-26 11:10:19 +00:00
|
|
|
vkFreeCommandBuffers(vk->context->device,
|
2016-02-16 19:24:00 +00:00
|
|
|
vk->swapchain[i].cmd_pool, 1, &vk->swapchain[i].cmd);
|
|
|
|
|
2016-06-26 11:10:19 +00:00
|
|
|
vkDestroyCommandPool(vk->context->device,
|
2016-02-20 19:15:46 +00:00
|
|
|
vk->swapchain[i].cmd_pool, NULL);
|
2016-02-16 19:24:00 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-03-01 01:21:53 +00:00
|
|
|
static void vulkan_deinit_pipeline_layout(vk_t *vk)
|
2016-02-16 19:24:00 +00:00
|
|
|
{
|
2016-06-26 11:10:19 +00:00
|
|
|
vkDestroyPipelineLayout(vk->context->device,
|
2016-02-20 19:15:46 +00:00
|
|
|
vk->pipelines.layout, NULL);
|
2016-06-26 11:10:19 +00:00
|
|
|
vkDestroyDescriptorSetLayout(vk->context->device,
|
2016-02-20 19:15:46 +00:00
|
|
|
vk->pipelines.set_layout, NULL);
|
2016-02-16 19:24:00 +00:00
|
|
|
}
|
|
|
|
|
2016-03-01 01:21:53 +00:00
|
|
|
static void vulkan_deinit_pipelines(vk_t *vk)
|
2016-02-16 19:24:00 +00:00
|
|
|
{
|
|
|
|
unsigned i;
|
2016-02-29 18:39:49 +00:00
|
|
|
|
2016-03-01 01:21:53 +00:00
|
|
|
vulkan_deinit_pipeline_layout(vk);
|
2016-06-26 11:10:19 +00:00
|
|
|
vkDestroyPipeline(vk->context->device,
|
2016-02-29 18:41:25 +00:00
|
|
|
vk->pipelines.alpha_blend, NULL);
|
2016-06-26 11:10:19 +00:00
|
|
|
vkDestroyPipeline(vk->context->device,
|
2016-02-29 18:41:25 +00:00
|
|
|
vk->pipelines.font, NULL);
|
|
|
|
|
2017-02-20 19:51:24 +00:00
|
|
|
for (i = 0; i < ARRAY_SIZE(vk->display.pipelines); i++)
|
2016-06-26 11:10:19 +00:00
|
|
|
vkDestroyPipeline(vk->context->device,
|
2016-02-29 18:41:25 +00:00
|
|
|
vk->display.pipelines[i], NULL);
|
2016-02-16 19:24:00 +00:00
|
|
|
}
|
|
|
|
|
2016-03-01 01:21:53 +00:00
|
|
|
static void vulkan_deinit_framebuffers(vk_t *vk)
|
2016-02-16 19:24:00 +00:00
|
|
|
{
|
|
|
|
unsigned i;
|
|
|
|
for (i = 0; i < vk->num_swapchain_images; i++)
|
|
|
|
{
|
2016-06-26 11:10:19 +00:00
|
|
|
vkDestroyFramebuffer(vk->context->device,
|
2016-02-16 19:24:00 +00:00
|
|
|
vk->swapchain[i].backbuffer.framebuffer, NULL);
|
2016-06-26 11:10:19 +00:00
|
|
|
vkDestroyImageView(vk->context->device,
|
2016-02-16 19:24:00 +00:00
|
|
|
vk->swapchain[i].backbuffer.view, NULL);
|
|
|
|
}
|
|
|
|
|
2016-06-26 11:10:19 +00:00
|
|
|
vkDestroyRenderPass(vk->context->device, vk->render_pass, NULL);
|
2016-02-16 19:24:00 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static bool vulkan_init_default_filter_chain(vk_t *vk)
|
|
|
|
{
|
|
|
|
struct vulkan_filter_chain_create_info info;
|
|
|
|
|
|
|
|
memset(&info, 0, sizeof(info));
|
2016-03-01 00:53:48 +00:00
|
|
|
|
2016-02-20 19:15:46 +00:00
|
|
|
info.device = vk->context->device;
|
2016-03-26 18:38:44 +00:00
|
|
|
info.gpu = vk->context->gpu;
|
2016-02-20 19:15:46 +00:00
|
|
|
info.memory_properties = &vk->context->memory_properties;
|
|
|
|
info.pipeline_cache = vk->pipelines.cache;
|
2016-07-31 10:26:14 +00:00
|
|
|
info.queue = vk->context->queue;
|
|
|
|
info.command_pool = vk->swapchain[vk->context->current_swapchain_index].cmd_pool;
|
2016-02-20 19:15:46 +00:00
|
|
|
info.max_input_size.width = vk->tex_w;
|
2016-02-16 19:24:00 +00:00
|
|
|
info.max_input_size.height = vk->tex_h;
|
2016-02-20 19:15:46 +00:00
|
|
|
info.swapchain.viewport = vk->vk_vp;
|
|
|
|
info.swapchain.format = vk->context->swapchain_format;
|
2016-02-16 19:24:00 +00:00
|
|
|
info.swapchain.render_pass = vk->render_pass;
|
|
|
|
info.swapchain.num_indices = vk->context->num_swapchain_images;
|
2016-03-25 13:51:37 +00:00
|
|
|
info.original_format = vk->tex_fmt;
|
2016-02-16 19:24:00 +00:00
|
|
|
|
2016-02-29 21:23:35 +00:00
|
|
|
vk->filter_chain = vulkan_filter_chain_create_default(
|
|
|
|
&info,
|
2016-02-20 19:15:46 +00:00
|
|
|
vk->video.smooth ?
|
|
|
|
VULKAN_FILTER_CHAIN_LINEAR : VULKAN_FILTER_CHAIN_NEAREST);
|
|
|
|
|
2016-02-16 19:24:00 +00:00
|
|
|
if (!vk->filter_chain)
|
|
|
|
{
|
|
|
|
RARCH_ERR("Failed to create filter chain.\n");
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool vulkan_init_filter_chain_preset(vk_t *vk, const char *shader_path)
|
|
|
|
{
|
|
|
|
struct vulkan_filter_chain_create_info info;
|
|
|
|
|
|
|
|
memset(&info, 0, sizeof(info));
|
2016-02-29 05:31:55 +00:00
|
|
|
|
|
|
|
info.device = vk->context->device;
|
2016-03-26 18:38:44 +00:00
|
|
|
info.gpu = vk->context->gpu;
|
2016-02-29 05:31:55 +00:00
|
|
|
info.memory_properties = &vk->context->memory_properties;
|
|
|
|
info.pipeline_cache = vk->pipelines.cache;
|
2016-07-31 10:26:14 +00:00
|
|
|
info.queue = vk->context->queue;
|
|
|
|
info.command_pool = vk->swapchain[vk->context->current_swapchain_index].cmd_pool;
|
2016-02-29 05:31:55 +00:00
|
|
|
info.max_input_size.width = vk->tex_w;
|
2016-02-16 19:24:00 +00:00
|
|
|
info.max_input_size.height = vk->tex_h;
|
2016-02-29 05:31:55 +00:00
|
|
|
info.swapchain.viewport = vk->vk_vp;
|
|
|
|
info.swapchain.format = vk->context->swapchain_format;
|
2016-02-16 19:24:00 +00:00
|
|
|
info.swapchain.render_pass = vk->render_pass;
|
|
|
|
info.swapchain.num_indices = vk->context->num_swapchain_images;
|
2016-03-25 13:51:37 +00:00
|
|
|
info.original_format = vk->tex_fmt;
|
2016-02-16 19:24:00 +00:00
|
|
|
|
2016-02-29 21:23:35 +00:00
|
|
|
vk->filter_chain = vulkan_filter_chain_create_from_preset(
|
|
|
|
&info, shader_path,
|
2016-02-16 19:24:00 +00:00
|
|
|
vk->video.smooth ?
|
|
|
|
VULKAN_FILTER_CHAIN_LINEAR : VULKAN_FILTER_CHAIN_NEAREST);
|
|
|
|
|
|
|
|
if (!vk->filter_chain)
|
|
|
|
{
|
|
|
|
RARCH_ERR("[Vulkan]: Failed to create preset: \"%s\".\n", shader_path);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool vulkan_init_filter_chain(vk_t *vk)
|
|
|
|
{
|
|
|
|
settings_t *settings = config_get_ptr();
|
2017-04-28 22:39:29 +00:00
|
|
|
const char *shader_path = (settings->bools.video_shader_enable && *settings->paths.path_shader) ?
|
|
|
|
settings->paths.path_shader : NULL;
|
2016-02-16 19:24:00 +00:00
|
|
|
|
|
|
|
enum rarch_shader_type type = video_shader_parse_type(shader_path, RARCH_SHADER_NONE);
|
|
|
|
|
|
|
|
if (type == RARCH_SHADER_NONE)
|
|
|
|
{
|
|
|
|
RARCH_LOG("[Vulkan]: Loading stock shader.\n");
|
|
|
|
return vulkan_init_default_filter_chain(vk);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (type != RARCH_SHADER_SLANG)
|
|
|
|
{
|
|
|
|
RARCH_LOG("[Vulkan]: Only SLANG shaders are supported, falling back to stock.\n");
|
|
|
|
return vulkan_init_default_filter_chain(vk);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!shader_path || !vulkan_init_filter_chain_preset(vk, shader_path))
|
|
|
|
vulkan_init_default_filter_chain(vk);
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void vulkan_init_resources(vk_t *vk)
|
|
|
|
{
|
|
|
|
vk->num_swapchain_images = vk->context->num_swapchain_images;
|
2016-03-01 01:21:53 +00:00
|
|
|
vulkan_init_framebuffers(vk);
|
|
|
|
vulkan_init_pipelines(vk);
|
2016-02-16 19:24:00 +00:00
|
|
|
vulkan_init_descriptor_pool(vk);
|
|
|
|
vulkan_init_textures(vk);
|
|
|
|
vulkan_init_buffers(vk);
|
2016-03-01 01:21:53 +00:00
|
|
|
vulkan_init_command_buffers(vk);
|
2016-02-16 19:24:00 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void vulkan_init_static_resources(vk_t *vk)
|
|
|
|
{
|
|
|
|
unsigned i;
|
|
|
|
uint32_t blank[4 * 4];
|
2016-02-20 19:15:46 +00:00
|
|
|
VkCommandPoolCreateInfo pool_info = {
|
|
|
|
VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO };
|
2016-02-16 19:24:00 +00:00
|
|
|
/* Create the pipeline cache. */
|
2016-02-29 16:06:41 +00:00
|
|
|
VkPipelineCacheCreateInfo cache = {
|
2016-02-20 19:15:46 +00:00
|
|
|
VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO };
|
|
|
|
|
2016-06-26 11:10:19 +00:00
|
|
|
vkCreatePipelineCache(vk->context->device,
|
2016-02-20 19:15:46 +00:00
|
|
|
&cache, NULL, &vk->pipelines.cache);
|
2016-02-16 19:24:00 +00:00
|
|
|
|
|
|
|
pool_info.queueFamilyIndex = vk->context->graphics_queue_index;
|
2016-02-29 16:06:41 +00:00
|
|
|
|
2016-06-26 11:10:19 +00:00
|
|
|
vkCreateCommandPool(vk->context->device,
|
2016-02-20 19:15:46 +00:00
|
|
|
&pool_info, NULL, &vk->staging_pool);
|
2016-02-16 19:24:00 +00:00
|
|
|
|
|
|
|
for (i = 0; i < 4 * 4; i++)
|
|
|
|
blank[i] = -1u;
|
|
|
|
|
|
|
|
vk->display.blank_texture = vulkan_create_texture(vk, NULL,
|
2016-02-20 19:15:46 +00:00
|
|
|
4, 4, VK_FORMAT_B8G8R8A8_UNORM,
|
|
|
|
blank, NULL, VULKAN_TEXTURE_STATIC);
|
2016-02-16 19:24:00 +00:00
|
|
|
}
|
|
|
|
|
2016-03-01 01:21:53 +00:00
|
|
|
static void vulkan_deinit_static_resources(vk_t *vk)
|
2016-02-16 19:24:00 +00:00
|
|
|
{
|
|
|
|
unsigned i;
|
2016-06-26 11:10:19 +00:00
|
|
|
vkDestroyPipelineCache(vk->context->device,
|
2016-02-20 19:15:46 +00:00
|
|
|
vk->pipelines.cache, NULL);
|
2016-03-01 01:21:53 +00:00
|
|
|
vulkan_destroy_texture(
|
2016-02-29 18:03:18 +00:00
|
|
|
vk->context->device,
|
2016-02-20 19:15:46 +00:00
|
|
|
&vk->display.blank_texture);
|
2016-02-29 18:03:18 +00:00
|
|
|
|
2016-06-26 11:10:19 +00:00
|
|
|
vkDestroyCommandPool(vk->context->device,
|
2016-02-29 21:23:35 +00:00
|
|
|
vk->staging_pool, NULL);
|
2016-02-16 19:24:00 +00:00
|
|
|
free(vk->hw.cmd);
|
|
|
|
free(vk->hw.wait_dst_stages);
|
|
|
|
|
|
|
|
for (i = 0; i < VULKAN_MAX_SWAPCHAIN_IMAGES; i++)
|
|
|
|
if (vk->readback.staging[i].memory != VK_NULL_HANDLE)
|
2016-03-01 01:21:53 +00:00
|
|
|
vulkan_destroy_texture(
|
2016-02-29 18:03:18 +00:00
|
|
|
vk->context->device,
|
2016-02-20 19:15:46 +00:00
|
|
|
&vk->readback.staging[i]);
|
2016-02-16 19:24:00 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void vulkan_deinit_resources(vk_t *vk)
|
|
|
|
{
|
2016-03-01 01:21:53 +00:00
|
|
|
vulkan_deinit_pipelines(vk);
|
|
|
|
vulkan_deinit_framebuffers(vk);
|
2016-02-16 19:24:00 +00:00
|
|
|
vulkan_deinit_descriptor_pool(vk);
|
|
|
|
vulkan_deinit_textures(vk);
|
|
|
|
vulkan_deinit_buffers(vk);
|
2016-03-01 01:21:53 +00:00
|
|
|
vulkan_deinit_command_buffers(vk);
|
2016-02-16 19:24:00 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void vulkan_deinit_menu(vk_t *vk)
|
|
|
|
{
|
|
|
|
unsigned i;
|
|
|
|
for (i = 0; i < VULKAN_MAX_SWAPCHAIN_IMAGES; i++)
|
2016-02-21 11:33:16 +00:00
|
|
|
{
|
2016-02-16 19:24:00 +00:00
|
|
|
if (vk->menu.textures[i].memory)
|
2016-03-01 01:21:53 +00:00
|
|
|
vulkan_destroy_texture(
|
2016-02-29 18:03:18 +00:00
|
|
|
vk->context->device, &vk->menu.textures[i]);
|
2016-02-21 11:33:16 +00:00
|
|
|
if (vk->menu.textures_optimal[i].memory)
|
2016-03-01 01:21:53 +00:00
|
|
|
vulkan_destroy_texture(
|
2016-02-29 18:03:18 +00:00
|
|
|
vk->context->device, &vk->menu.textures_optimal[i]);
|
2016-02-21 11:33:16 +00:00
|
|
|
}
|
2016-02-16 19:24:00 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void vulkan_free(void *data)
|
|
|
|
{
|
|
|
|
vk_t *vk = (vk_t*)data;
|
|
|
|
if (!vk)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (vk->context && vk->context->device)
|
|
|
|
{
|
2016-06-26 11:10:19 +00:00
|
|
|
vkQueueWaitIdle(vk->context->queue);
|
2016-02-16 19:24:00 +00:00
|
|
|
vulkan_deinit_resources(vk);
|
|
|
|
|
|
|
|
/* No need to init this since textures are create on-demand. */
|
|
|
|
vulkan_deinit_menu(vk);
|
2016-10-19 22:39:33 +00:00
|
|
|
|
|
|
|
font_driver_free_osd();
|
2016-02-16 19:24:00 +00:00
|
|
|
|
2016-03-01 01:21:53 +00:00
|
|
|
vulkan_deinit_static_resources(vk);
|
2016-02-16 19:24:00 +00:00
|
|
|
vulkan_overlay_free(vk);
|
|
|
|
|
|
|
|
if (vk->filter_chain)
|
2016-09-01 16:26:01 +00:00
|
|
|
vulkan_filter_chain_free((vulkan_filter_chain_t*)vk->filter_chain);
|
2016-02-16 19:24:00 +00:00
|
|
|
|
2016-05-08 18:32:46 +00:00
|
|
|
video_context_driver_free();
|
2016-02-16 19:24:00 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
scaler_ctx_gen_reset(&vk->readback.scaler);
|
|
|
|
free(vk);
|
|
|
|
}
|
|
|
|
|
|
|
|
static uint32_t vulkan_get_sync_index(void *handle)
|
|
|
|
{
|
|
|
|
vk_t *vk = (vk_t*)handle;
|
|
|
|
return vk->context->current_swapchain_index;
|
|
|
|
}
|
|
|
|
|
|
|
|
static uint32_t vulkan_get_sync_index_mask(void *handle)
|
|
|
|
{
|
|
|
|
vk_t *vk = (vk_t*)handle;
|
|
|
|
return (1 << vk->context->num_swapchain_images) - 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void vulkan_set_image(void *handle,
|
|
|
|
const struct retro_vulkan_image *image,
|
|
|
|
uint32_t num_semaphores,
|
2016-06-25 09:39:52 +00:00
|
|
|
const VkSemaphore *semaphores,
|
|
|
|
uint32_t src_queue_family)
|
2016-02-16 19:24:00 +00:00
|
|
|
{
|
|
|
|
unsigned i;
|
2016-02-20 19:15:46 +00:00
|
|
|
vk_t *vk = (vk_t*)handle;
|
2016-02-16 19:24:00 +00:00
|
|
|
|
2016-02-20 19:15:46 +00:00
|
|
|
vk->hw.image = image;
|
2016-02-16 19:24:00 +00:00
|
|
|
vk->hw.num_semaphores = num_semaphores;
|
2016-02-20 19:15:46 +00:00
|
|
|
vk->hw.semaphores = semaphores;
|
2016-02-16 19:24:00 +00:00
|
|
|
|
|
|
|
if (num_semaphores > 0)
|
|
|
|
{
|
2016-02-20 19:15:46 +00:00
|
|
|
vk->hw.wait_dst_stages = (VkPipelineStageFlags*)
|
|
|
|
realloc(vk->hw.wait_dst_stages,
|
2016-02-16 19:24:00 +00:00
|
|
|
sizeof(VkPipelineStageFlags) * vk->hw.num_semaphores);
|
2016-02-20 19:15:46 +00:00
|
|
|
|
|
|
|
/* If this fails, we're screwed anyways. */
|
|
|
|
retro_assert(vk->hw.wait_dst_stages);
|
2016-02-16 19:24:00 +00:00
|
|
|
|
|
|
|
for (i = 0; i < vk->hw.num_semaphores; i++)
|
|
|
|
vk->hw.wait_dst_stages[i] = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
|
2016-06-25 09:39:52 +00:00
|
|
|
|
|
|
|
vk->hw.valid_semaphore = true;
|
|
|
|
vk->hw.src_queue_family = src_queue_family;
|
2016-02-16 19:24:00 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void vulkan_wait_sync_index(void *handle)
|
|
|
|
{
|
|
|
|
(void)handle;
|
|
|
|
/* no-op. RetroArch already waits for this
|
|
|
|
* in gfx_ctx_swap_buffers(). */
|
|
|
|
}
|
|
|
|
|
|
|
|
static void vulkan_set_command_buffers(void *handle, uint32_t num_cmd,
|
|
|
|
const VkCommandBuffer *cmd)
|
|
|
|
{
|
2016-02-20 19:15:46 +00:00
|
|
|
vk_t *vk = (vk_t*)handle;
|
2016-02-16 19:24:00 +00:00
|
|
|
unsigned required_capacity = num_cmd + 1;
|
|
|
|
if (required_capacity > vk->hw.capacity_cmd)
|
|
|
|
{
|
|
|
|
vk->hw.cmd = (VkCommandBuffer*)realloc(vk->hw.cmd,
|
|
|
|
sizeof(VkCommandBuffer) * required_capacity);
|
2016-02-20 19:15:46 +00:00
|
|
|
|
|
|
|
/* If this fails, we're just screwed. */
|
|
|
|
retro_assert(vk->hw.cmd);
|
2016-02-16 19:24:00 +00:00
|
|
|
vk->hw.capacity_cmd = required_capacity;
|
|
|
|
}
|
|
|
|
|
|
|
|
vk->hw.num_cmd = num_cmd;
|
|
|
|
memcpy(vk->hw.cmd, cmd, sizeof(VkCommandBuffer) * num_cmd);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void vulkan_lock_queue(void *handle)
|
|
|
|
{
|
|
|
|
vk_t *vk = (vk_t*)handle;
|
2016-05-11 08:10:30 +00:00
|
|
|
#ifdef HAVE_THREADS
|
2016-02-16 19:24:00 +00:00
|
|
|
slock_lock(vk->context->queue_lock);
|
2016-05-11 08:10:30 +00:00
|
|
|
#endif
|
2016-02-16 19:24:00 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void vulkan_unlock_queue(void *handle)
|
|
|
|
{
|
|
|
|
vk_t *vk = (vk_t*)handle;
|
2016-05-11 08:10:30 +00:00
|
|
|
#ifdef HAVE_THREADS
|
2016-02-16 19:24:00 +00:00
|
|
|
slock_unlock(vk->context->queue_lock);
|
2016-05-11 08:10:30 +00:00
|
|
|
#endif
|
2016-02-16 19:24:00 +00:00
|
|
|
}
|
|
|
|
|
2016-06-26 16:58:59 +00:00
|
|
|
static void vulkan_set_signal_semaphore(void *handle, VkSemaphore semaphore)
|
|
|
|
{
|
|
|
|
vk_t *vk = (vk_t*)handle;
|
|
|
|
vk->hw.signal_semaphore = semaphore;
|
|
|
|
}
|
|
|
|
|
2016-02-16 19:24:00 +00:00
|
|
|
static void vulkan_init_hw_render(vk_t *vk)
|
|
|
|
{
|
2016-02-20 19:15:46 +00:00
|
|
|
struct retro_hw_render_interface_vulkan *iface =
|
2016-02-16 19:24:00 +00:00
|
|
|
&vk->hw.iface;
|
2016-05-08 12:00:51 +00:00
|
|
|
struct retro_hw_render_callback *hwr =
|
|
|
|
video_driver_get_hw_context();
|
2016-02-16 19:24:00 +00:00
|
|
|
|
2016-03-04 19:49:55 +00:00
|
|
|
if (hwr->context_type != RETRO_HW_CONTEXT_VULKAN)
|
2016-02-16 19:24:00 +00:00
|
|
|
return;
|
|
|
|
|
2016-06-26 16:58:59 +00:00
|
|
|
vk->hw.enable = true;
|
2016-02-16 19:24:00 +00:00
|
|
|
|
2016-06-26 16:58:59 +00:00
|
|
|
iface->interface_type = RETRO_HW_RENDER_INTERFACE_VULKAN;
|
|
|
|
iface->interface_version = RETRO_HW_RENDER_INTERFACE_VULKAN_VERSION;
|
|
|
|
iface->instance = vk->context->instance;
|
|
|
|
iface->gpu = vk->context->gpu;
|
|
|
|
iface->device = vk->context->device;
|
2016-02-16 19:24:00 +00:00
|
|
|
|
2016-06-26 16:58:59 +00:00
|
|
|
iface->queue = vk->context->queue;
|
|
|
|
iface->queue_index = vk->context->graphics_queue_index;
|
2016-02-16 19:24:00 +00:00
|
|
|
|
2016-06-26 16:58:59 +00:00
|
|
|
iface->handle = vk;
|
|
|
|
iface->set_image = vulkan_set_image;
|
|
|
|
iface->get_sync_index = vulkan_get_sync_index;
|
|
|
|
iface->get_sync_index_mask = vulkan_get_sync_index_mask;
|
|
|
|
iface->wait_sync_index = vulkan_wait_sync_index;
|
|
|
|
iface->set_command_buffers = vulkan_set_command_buffers;
|
|
|
|
iface->lock_queue = vulkan_lock_queue;
|
|
|
|
iface->unlock_queue = vulkan_unlock_queue;
|
|
|
|
iface->set_signal_semaphore = vulkan_set_signal_semaphore;
|
2016-03-29 14:32:16 +00:00
|
|
|
|
2016-06-26 11:10:19 +00:00
|
|
|
iface->get_device_proc_addr = vkGetDeviceProcAddr;
|
|
|
|
iface->get_instance_proc_addr = vulkan_symbol_wrapper_instance_proc_addr();
|
2016-02-16 19:24:00 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void vulkan_init_readback(vk_t *vk)
|
|
|
|
{
|
|
|
|
/* Only bother with this if we're doing GPU recording.
|
|
|
|
* Check recording_is_enabled() and not
|
|
|
|
* driver.recording_data, because recording is
|
|
|
|
* not initialized yet.
|
|
|
|
*/
|
2016-02-20 19:15:46 +00:00
|
|
|
settings_t *settings = config_get_ptr();
|
2016-02-16 19:24:00 +00:00
|
|
|
bool *recording_enabled = recording_is_enabled();
|
2017-04-27 22:53:06 +00:00
|
|
|
vk->readback.streamed = settings->bools.video_gpu_record && *recording_enabled;
|
2016-02-16 19:24:00 +00:00
|
|
|
|
|
|
|
if (!vk->readback.streamed)
|
|
|
|
return;
|
|
|
|
|
2016-02-20 19:15:46 +00:00
|
|
|
vk->readback.scaler.in_width = vk->vp.width;
|
|
|
|
vk->readback.scaler.in_height = vk->vp.height;
|
|
|
|
vk->readback.scaler.out_width = vk->vp.width;
|
|
|
|
vk->readback.scaler.out_height = vk->vp.height;
|
|
|
|
vk->readback.scaler.in_fmt = SCALER_FMT_ARGB8888;
|
|
|
|
vk->readback.scaler.out_fmt = SCALER_FMT_BGR24;
|
2016-02-16 19:24:00 +00:00
|
|
|
vk->readback.scaler.scaler_type = SCALER_TYPE_POINT;
|
|
|
|
|
|
|
|
if (!scaler_ctx_gen_filter(&vk->readback.scaler))
|
|
|
|
{
|
|
|
|
vk->readback.streamed = false;
|
|
|
|
RARCH_ERR("[Vulkan]: Failed to initialize scaler context.\n");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-04-24 10:25:14 +00:00
|
|
|
static void *vulkan_init(const video_info_t *video,
|
2016-02-29 21:23:35 +00:00
|
|
|
const input_driver_t **input,
|
2016-02-16 19:24:00 +00:00
|
|
|
void **input_data)
|
|
|
|
{
|
|
|
|
gfx_ctx_mode_t mode;
|
|
|
|
gfx_ctx_input_t inp;
|
|
|
|
unsigned interval;
|
2016-03-29 13:28:13 +00:00
|
|
|
unsigned full_x, full_y;
|
2016-02-20 19:15:46 +00:00
|
|
|
unsigned win_width;
|
|
|
|
unsigned win_height;
|
|
|
|
unsigned temp_width = 0;
|
|
|
|
unsigned temp_height = 0;
|
|
|
|
const gfx_ctx_driver_t *ctx_driver = NULL;
|
|
|
|
vk_t *vk = (vk_t*)calloc(1, sizeof(*vk));
|
2016-02-16 19:24:00 +00:00
|
|
|
if (!vk)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
vk->video = *video;
|
|
|
|
|
|
|
|
ctx_driver = vulkan_get_context(vk);
|
|
|
|
if (!ctx_driver)
|
2016-03-29 15:36:13 +00:00
|
|
|
{
|
|
|
|
RARCH_ERR("[Vulkan]: Failed to get Vulkan context.\n");
|
2016-02-16 19:24:00 +00:00
|
|
|
goto error;
|
2016-03-29 15:36:13 +00:00
|
|
|
}
|
2016-02-16 19:24:00 +00:00
|
|
|
|
2016-05-09 03:48:47 +00:00
|
|
|
video_context_driver_set((const gfx_ctx_driver_t*)ctx_driver);
|
2016-02-16 19:24:00 +00:00
|
|
|
|
2016-05-08 18:32:46 +00:00
|
|
|
video_context_driver_get_video_size(&mode);
|
2016-03-29 13:28:13 +00:00
|
|
|
full_x = mode.width;
|
|
|
|
full_y = mode.height;
|
2016-03-06 11:18:11 +00:00
|
|
|
mode.width = 0;
|
|
|
|
mode.height = 0;
|
2016-02-16 19:24:00 +00:00
|
|
|
|
2017-03-23 23:28:21 +00:00
|
|
|
RARCH_LOG("[Vulkan]: Detecting screen resolution %ux%u.\n", full_x, full_y);
|
2017-01-10 17:16:22 +00:00
|
|
|
interval = video->vsync ? video->swap_interval : 0;
|
2016-05-08 18:32:46 +00:00
|
|
|
video_context_driver_swap_interval(&interval);
|
2016-02-16 19:24:00 +00:00
|
|
|
|
|
|
|
win_width = video->width;
|
|
|
|
win_height = video->height;
|
|
|
|
|
|
|
|
if (video->fullscreen && (win_width == 0) && (win_height == 0))
|
|
|
|
{
|
2016-03-29 13:28:13 +00:00
|
|
|
win_width = full_x;
|
|
|
|
win_height = full_y;
|
2016-02-16 19:24:00 +00:00
|
|
|
}
|
|
|
|
|
2016-03-06 11:18:11 +00:00
|
|
|
mode.width = win_width;
|
|
|
|
mode.height = win_height;
|
2016-02-16 19:24:00 +00:00
|
|
|
mode.fullscreen = video->fullscreen;
|
2016-05-16 05:51:01 +00:00
|
|
|
|
2016-05-08 18:32:46 +00:00
|
|
|
if (!video_context_driver_set_video_mode(&mode))
|
2016-03-29 15:36:13 +00:00
|
|
|
{
|
|
|
|
RARCH_ERR("[Vulkan]: Failed to set video mode.\n");
|
2016-02-16 19:24:00 +00:00
|
|
|
goto error;
|
2016-03-29 15:36:13 +00:00
|
|
|
}
|
2016-02-16 19:24:00 +00:00
|
|
|
|
2016-05-08 18:32:46 +00:00
|
|
|
video_context_driver_get_video_size(&mode);
|
2017-04-24 10:25:07 +00:00
|
|
|
temp_width = mode.width;
|
|
|
|
temp_height = mode.height;
|
2016-02-16 19:24:00 +00:00
|
|
|
|
2017-04-24 10:25:07 +00:00
|
|
|
if (temp_width != 0 && temp_height != 0)
|
|
|
|
video_driver_set_size(&temp_width, &temp_height);
|
|
|
|
video_driver_get_size(&temp_width, &temp_height);
|
2016-02-16 19:24:00 +00:00
|
|
|
|
2017-04-24 10:25:07 +00:00
|
|
|
RARCH_LOG("[Vulkan]: Using resolution %ux%u\n", temp_width, temp_height);
|
2016-02-16 19:24:00 +00:00
|
|
|
|
2016-05-08 18:32:46 +00:00
|
|
|
video_context_driver_get_context_data(&vk->context);
|
2016-02-16 19:24:00 +00:00
|
|
|
|
2016-02-20 19:15:46 +00:00
|
|
|
vk->vsync = video->vsync;
|
|
|
|
vk->fullscreen = video->fullscreen;
|
|
|
|
vk->tex_w = RARCH_SCALE_BASE * video->input_scale;
|
|
|
|
vk->tex_h = RARCH_SCALE_BASE * video->input_scale;
|
|
|
|
vk->tex_fmt = video->rgb32
|
|
|
|
? VK_FORMAT_B8G8R8A8_UNORM : VK_FORMAT_R5G6B5_UNORM_PACK16;
|
|
|
|
vk->keep_aspect = video->force_aspect;
|
2016-03-21 08:29:41 +00:00
|
|
|
RARCH_LOG("[Vulkan]: Using %s format.\n", video->rgb32 ? "BGRA8888" : "RGB565");
|
2016-02-16 19:24:00 +00:00
|
|
|
|
2016-02-20 12:44:25 +00:00
|
|
|
/* Set the viewport to fix recording, since it needs to know
|
|
|
|
* the viewport sizes before we start running. */
|
|
|
|
vulkan_set_viewport(vk, temp_width, temp_height, false, true);
|
|
|
|
|
2016-02-16 19:24:00 +00:00
|
|
|
vulkan_init_hw_render(vk);
|
|
|
|
vulkan_init_static_resources(vk);
|
|
|
|
vulkan_init_resources(vk);
|
|
|
|
|
|
|
|
if (!vulkan_init_filter_chain(vk))
|
2016-03-29 15:36:13 +00:00
|
|
|
{
|
|
|
|
RARCH_ERR("[Vulkan]: Failed to init filter chain.\n");
|
2016-02-16 19:24:00 +00:00
|
|
|
goto error;
|
2016-03-29 15:36:13 +00:00
|
|
|
}
|
2016-02-16 19:24:00 +00:00
|
|
|
|
2016-02-20 19:15:46 +00:00
|
|
|
inp.input = input;
|
2016-02-16 19:24:00 +00:00
|
|
|
inp.input_data = input_data;
|
2016-05-08 18:32:46 +00:00
|
|
|
video_context_driver_input_driver(&inp);
|
2016-02-16 19:24:00 +00:00
|
|
|
|
2017-01-10 17:16:22 +00:00
|
|
|
if (video->font_enable)
|
2017-04-29 14:52:52 +00:00
|
|
|
font_driver_init_osd(vk, false,
|
|
|
|
video->is_threaded,
|
|
|
|
FONT_DRIVER_RENDER_VULKAN_API);
|
2016-02-16 19:24:00 +00:00
|
|
|
|
|
|
|
vulkan_init_readback(vk);
|
|
|
|
return vk;
|
|
|
|
|
|
|
|
error:
|
|
|
|
vulkan_free(vk);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void vulkan_update_filter_chain(vk_t *vk)
|
|
|
|
{
|
2017-08-12 15:56:30 +00:00
|
|
|
struct vulkan_filter_chain_swapchain_info info;
|
|
|
|
|
|
|
|
info.viewport = vk->vk_vp;
|
|
|
|
info.format = vk->context->swapchain_format;
|
|
|
|
info.render_pass = vk->render_pass;
|
|
|
|
info.num_indices = vk->context->num_swapchain_images;
|
2016-02-16 19:24:00 +00:00
|
|
|
|
2016-09-01 16:26:01 +00:00
|
|
|
if (!vulkan_filter_chain_update_swapchain_info((vulkan_filter_chain_t*)vk->filter_chain, &info))
|
2016-02-16 19:24:00 +00:00
|
|
|
RARCH_ERR("Failed to update filter chain info. This will probably lead to a crash ...\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
static void vulkan_check_swapchain(vk_t *vk)
|
|
|
|
{
|
|
|
|
if (vk->context->invalid_swapchain)
|
|
|
|
{
|
2016-06-26 11:10:19 +00:00
|
|
|
vkQueueWaitIdle(vk->context->queue);
|
2016-02-16 19:24:00 +00:00
|
|
|
|
|
|
|
vulkan_deinit_resources(vk);
|
|
|
|
vulkan_init_resources(vk);
|
|
|
|
vk->context->invalid_swapchain = false;
|
|
|
|
|
|
|
|
vulkan_update_filter_chain(vk);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void vulkan_set_nonblock_state(void *data, bool state)
|
|
|
|
{
|
|
|
|
unsigned interval;
|
2016-02-20 19:15:46 +00:00
|
|
|
vk_t *vk = (vk_t*)data;
|
|
|
|
settings_t *settings = config_get_ptr();
|
2016-02-16 19:24:00 +00:00
|
|
|
|
|
|
|
if (!vk)
|
|
|
|
return;
|
|
|
|
|
|
|
|
RARCH_LOG("[Vulkan]: VSync => %s\n", state ? "off" : "on");
|
|
|
|
|
2017-04-28 19:03:04 +00:00
|
|
|
interval = state ? 0 : settings->uints.video_swap_interval;
|
2016-05-08 18:32:46 +00:00
|
|
|
video_context_driver_swap_interval(&interval);
|
2016-02-16 19:24:00 +00:00
|
|
|
|
|
|
|
/* Changing vsync might require recreating the swapchain, which means new VkImages
|
|
|
|
* to render into. */
|
|
|
|
vulkan_check_swapchain(vk);
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool vulkan_alive(void *data)
|
|
|
|
{
|
|
|
|
gfx_ctx_size_t size_data;
|
2016-02-20 19:15:46 +00:00
|
|
|
unsigned temp_width = 0;
|
|
|
|
unsigned temp_height = 0;
|
|
|
|
bool ret = false;
|
|
|
|
bool quit = false;
|
|
|
|
bool resize = false;
|
|
|
|
vk_t *vk = (vk_t*)data;
|
2016-02-16 19:24:00 +00:00
|
|
|
|
|
|
|
video_driver_get_size(&temp_width, &temp_height);
|
|
|
|
|
2016-02-20 19:15:46 +00:00
|
|
|
size_data.quit = &quit;
|
|
|
|
size_data.resize = &resize;
|
|
|
|
size_data.width = &temp_width;
|
|
|
|
size_data.height = &temp_height;
|
2016-02-16 19:24:00 +00:00
|
|
|
|
2016-05-08 18:32:46 +00:00
|
|
|
if (video_context_driver_check_window(&size_data))
|
2016-02-16 19:24:00 +00:00
|
|
|
{
|
|
|
|
if (quit)
|
2016-02-20 19:15:46 +00:00
|
|
|
vk->quitting = true;
|
2016-02-16 19:24:00 +00:00
|
|
|
else if (resize)
|
|
|
|
vk->should_resize = true;
|
|
|
|
|
|
|
|
ret = !vk->quitting;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (temp_width != 0 && temp_height != 0)
|
|
|
|
video_driver_set_size(&temp_width, &temp_height);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool vulkan_suppress_screensaver(void *data, bool enable)
|
|
|
|
{
|
|
|
|
(void)data;
|
|
|
|
bool enabled = enable;
|
2016-05-08 18:32:46 +00:00
|
|
|
return video_context_driver_suppress_screensaver(&enabled);
|
2016-02-16 19:24:00 +00:00
|
|
|
}
|
|
|
|
|
2016-02-20 19:15:46 +00:00
|
|
|
static bool vulkan_set_shader(void *data,
|
|
|
|
enum rarch_shader_type type, const char *path)
|
2016-02-16 19:24:00 +00:00
|
|
|
{
|
|
|
|
vk_t *vk = (vk_t*)data;
|
|
|
|
if (!vk)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (type != RARCH_SHADER_SLANG && path)
|
|
|
|
{
|
|
|
|
RARCH_WARN("[Vulkan]: Only .slang or .slangp shaders are supported. Falling back to stock.\n");
|
|
|
|
path = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (vk->filter_chain)
|
2016-09-01 16:26:01 +00:00
|
|
|
vulkan_filter_chain_free((vulkan_filter_chain_t*)vk->filter_chain);
|
2016-02-16 19:24:00 +00:00
|
|
|
vk->filter_chain = NULL;
|
|
|
|
|
|
|
|
if (!path)
|
|
|
|
{
|
|
|
|
vulkan_init_default_filter_chain(vk);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!vulkan_init_filter_chain_preset(vk, path))
|
|
|
|
{
|
|
|
|
RARCH_ERR("[Vulkan]: Failed to create filter chain: \"%s\". Falling back to stock.\n", path);
|
|
|
|
vulkan_init_default_filter_chain(vk);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2016-02-20 19:15:46 +00:00
|
|
|
static void vulkan_set_projection(vk_t *vk,
|
2016-05-10 00:39:09 +00:00
|
|
|
struct video_ortho *ortho, bool allow_rotate)
|
2016-02-16 19:24:00 +00:00
|
|
|
{
|
|
|
|
math_matrix_4x4 rot;
|
|
|
|
|
|
|
|
/* Calculate projection. */
|
2017-04-16 02:00:20 +00:00
|
|
|
matrix_4x4_ortho(vk->mvp_no_rot, ortho->left, ortho->right,
|
2016-02-16 19:24:00 +00:00
|
|
|
ortho->bottom, ortho->top, ortho->znear, ortho->zfar);
|
|
|
|
|
|
|
|
if (!allow_rotate)
|
|
|
|
{
|
|
|
|
vk->mvp = vk->mvp_no_rot;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2017-04-16 01:53:07 +00:00
|
|
|
matrix_4x4_rotate_z(rot, M_PI * vk->rotation / 180.0f);
|
2017-04-16 05:55:02 +00:00
|
|
|
matrix_4x4_multiply(vk->mvp, rot, vk->mvp_no_rot);
|
2016-02-16 19:24:00 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void vulkan_set_rotation(void *data, unsigned rotation)
|
|
|
|
{
|
2016-02-20 19:15:46 +00:00
|
|
|
vk_t *vk = (vk_t*)data;
|
2016-05-10 00:39:09 +00:00
|
|
|
struct video_ortho ortho = {0, 1, 0, 1, -1, 1};
|
2016-02-16 19:24:00 +00:00
|
|
|
|
|
|
|
if (!vk)
|
|
|
|
return;
|
|
|
|
|
2016-12-11 09:53:02 +00:00
|
|
|
vk->rotation = 270 * rotation;
|
2016-02-16 19:24:00 +00:00
|
|
|
vulkan_set_projection(vk, &ortho, true);
|
|
|
|
}
|
|
|
|
|
2016-02-20 19:15:46 +00:00
|
|
|
static void vulkan_set_video_mode(void *data,
|
|
|
|
unsigned width, unsigned height,
|
2016-02-16 19:24:00 +00:00
|
|
|
bool fullscreen)
|
|
|
|
{
|
|
|
|
gfx_ctx_mode_t mode;
|
|
|
|
|
2017-08-12 15:56:30 +00:00
|
|
|
(void)data;
|
|
|
|
|
2016-02-16 19:24:00 +00:00
|
|
|
mode.width = width;
|
|
|
|
mode.height = height;
|
|
|
|
mode.fullscreen = fullscreen;
|
|
|
|
|
2016-05-08 18:32:46 +00:00
|
|
|
video_context_driver_set_video_mode(&mode);
|
2016-02-16 19:24:00 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void vulkan_set_viewport(void *data, unsigned viewport_width,
|
|
|
|
unsigned viewport_height, bool force_full, bool allow_rotate)
|
|
|
|
{
|
|
|
|
gfx_ctx_aspect_t aspect_data;
|
|
|
|
unsigned width, height;
|
2016-02-20 19:29:52 +00:00
|
|
|
int x = 0;
|
|
|
|
int y = 0;
|
|
|
|
float device_aspect = (float)viewport_width / viewport_height;
|
2016-05-10 00:39:09 +00:00
|
|
|
struct video_ortho ortho = {0, 1, 0, 1, -1, 1};
|
2016-02-20 19:29:52 +00:00
|
|
|
settings_t *settings = config_get_ptr();
|
|
|
|
vk_t *vk = (vk_t*)data;
|
2016-02-16 19:24:00 +00:00
|
|
|
|
|
|
|
video_driver_get_size(&width, &height);
|
|
|
|
|
2016-02-20 19:29:52 +00:00
|
|
|
aspect_data.aspect = &device_aspect;
|
|
|
|
aspect_data.width = viewport_width;
|
|
|
|
aspect_data.height = viewport_height;
|
2016-02-16 19:24:00 +00:00
|
|
|
|
2016-05-08 18:32:46 +00:00
|
|
|
video_context_driver_translate_aspect(&aspect_data);
|
2016-02-16 19:24:00 +00:00
|
|
|
|
2017-04-27 22:53:06 +00:00
|
|
|
if (settings->bools.video_scale_integer && !force_full)
|
2016-02-16 19:24:00 +00:00
|
|
|
{
|
|
|
|
video_viewport_get_scaled_integer(&vk->vp,
|
|
|
|
viewport_width, viewport_height,
|
|
|
|
video_driver_get_aspect_ratio(), vk->keep_aspect);
|
|
|
|
viewport_width = vk->vp.width;
|
|
|
|
viewport_height = vk->vp.height;
|
|
|
|
}
|
|
|
|
else if (vk->keep_aspect && !force_full)
|
|
|
|
{
|
|
|
|
float desired_aspect = video_driver_get_aspect_ratio();
|
|
|
|
|
|
|
|
#if defined(HAVE_MENU)
|
2017-04-28 19:03:04 +00:00
|
|
|
if (settings->uints.video_aspect_ratio_idx == ASPECT_RATIO_CUSTOM)
|
2016-02-16 19:24:00 +00:00
|
|
|
{
|
|
|
|
const struct video_viewport *custom = video_viewport_get_custom();
|
|
|
|
|
2017-04-29 14:22:07 +00:00
|
|
|
/* Vulkan has top-left origin viewport. */
|
2016-02-16 19:24:00 +00:00
|
|
|
x = custom->x;
|
|
|
|
y = custom->y;
|
|
|
|
viewport_width = custom->width;
|
|
|
|
viewport_height = custom->height;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
#endif
|
|
|
|
{
|
|
|
|
float delta;
|
|
|
|
|
|
|
|
if (fabsf(device_aspect - desired_aspect) < 0.0001f)
|
|
|
|
{
|
|
|
|
/* If the aspect ratios of screen and desired aspect
|
|
|
|
* ratio are sufficiently equal (floating point stuff),
|
|
|
|
* assume they are actually equal.
|
|
|
|
*/
|
|
|
|
}
|
|
|
|
else if (device_aspect > desired_aspect)
|
|
|
|
{
|
2016-02-20 19:29:52 +00:00
|
|
|
delta = (desired_aspect / device_aspect - 1.0f)
|
|
|
|
/ 2.0f + 0.5f;
|
|
|
|
x = (int)roundf(viewport_width * (0.5f - delta));
|
2016-02-16 19:24:00 +00:00
|
|
|
viewport_width = (unsigned)roundf(2.0f * viewport_width * delta);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2016-02-20 19:29:52 +00:00
|
|
|
delta = (device_aspect / desired_aspect - 1.0f)
|
|
|
|
/ 2.0f + 0.5f;
|
|
|
|
y = (int)roundf(viewport_height * (0.5f - delta));
|
2016-02-16 19:24:00 +00:00
|
|
|
viewport_height = (unsigned)roundf(2.0f * viewport_height * delta);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
vk->vp.x = x;
|
|
|
|
vk->vp.y = y;
|
|
|
|
vk->vp.width = viewport_width;
|
|
|
|
vk->vp.height = viewport_height;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2016-02-20 19:29:52 +00:00
|
|
|
vk->vp.x = 0;
|
|
|
|
vk->vp.y = 0;
|
2016-02-16 19:24:00 +00:00
|
|
|
vk->vp.width = viewport_width;
|
|
|
|
vk->vp.height = viewport_height;
|
|
|
|
}
|
|
|
|
|
|
|
|
#if defined(RARCH_MOBILE)
|
|
|
|
/* In portrait mode, we want viewport to gravitate to top of screen. */
|
|
|
|
if (device_aspect < 1.0f)
|
|
|
|
vk->vp.y = 0;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
vulkan_set_projection(vk, &ortho, allow_rotate);
|
|
|
|
|
|
|
|
/* Set last backbuffer viewport. */
|
|
|
|
if (!force_full)
|
|
|
|
{
|
|
|
|
vk->vp_out_width = viewport_width;
|
|
|
|
vk->vp_out_height = viewport_height;
|
|
|
|
}
|
|
|
|
|
2016-02-20 19:29:52 +00:00
|
|
|
vk->vk_vp.x = (float)vk->vp.x;
|
|
|
|
vk->vk_vp.y = (float)vk->vp.y;
|
|
|
|
vk->vk_vp.width = (float)vk->vp.width;
|
|
|
|
vk->vk_vp.height = (float)vk->vp.height;
|
|
|
|
vk->vk_vp.minDepth = 0.0f;
|
|
|
|
vk->vk_vp.maxDepth = 1.0f;
|
2016-02-16 19:24:00 +00:00
|
|
|
|
|
|
|
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)
|
|
|
|
{
|
2016-02-20 10:21:39 +00:00
|
|
|
VkImageCopy region;
|
2016-02-16 19:24:00 +00:00
|
|
|
struct vk_texture *staging;
|
2016-02-20 13:04:33 +00:00
|
|
|
struct video_viewport vp;
|
2016-02-16 19:24:00 +00:00
|
|
|
|
2016-02-20 13:04:33 +00:00
|
|
|
vulkan_viewport_info(vk, &vp);
|
2016-02-20 10:21:39 +00:00
|
|
|
memset(®ion, 0, sizeof(region));
|
|
|
|
region.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
|
|
|
|
region.srcSubresource.layerCount = 1;
|
2016-02-20 19:15:46 +00:00
|
|
|
region.dstSubresource = region.srcSubresource;
|
2016-02-20 13:04:33 +00:00
|
|
|
|
2016-02-20 19:15:46 +00:00
|
|
|
region.srcOffset.x = vp.x;
|
|
|
|
region.srcOffset.y = vp.y;
|
|
|
|
region.extent.width = vp.width;
|
|
|
|
region.extent.height = vp.height;
|
|
|
|
region.extent.depth = 1;
|
2016-02-20 10:21:39 +00:00
|
|
|
|
|
|
|
/* FIXME: We won't actually get format conversion with vkCmdCopyImage, so have to check
|
|
|
|
* properly for this. BGRA seems to be the default for all swapchains. */
|
|
|
|
if (vk->context->swapchain_format != VK_FORMAT_B8G8R8A8_UNORM)
|
|
|
|
RARCH_WARN("[Vulkan]: Backbuffer is not BGRA8888, readbacks might not work properly.\n");
|
2016-02-16 19:24:00 +00:00
|
|
|
|
2016-02-20 19:15:46 +00:00
|
|
|
staging = &vk->readback.staging[vk->context->current_swapchain_index];
|
2016-02-16 19:24:00 +00:00
|
|
|
*staging = vulkan_create_texture(vk,
|
|
|
|
staging->memory != VK_NULL_HANDLE ? staging : NULL,
|
|
|
|
vk->vp.width, vk->vp.height,
|
2016-02-20 10:21:39 +00:00
|
|
|
VK_FORMAT_B8G8R8A8_UNORM,
|
2016-02-16 19:24:00 +00:00
|
|
|
NULL, NULL, VULKAN_TEXTURE_READBACK);
|
|
|
|
|
|
|
|
/* Go through the long-winded dance of remapping image layouts. */
|
|
|
|
vulkan_image_layout_transition(vk, vk->cmd, staging->image,
|
|
|
|
VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_GENERAL,
|
|
|
|
0, VK_ACCESS_TRANSFER_WRITE_BIT,
|
|
|
|
VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
|
2016-03-21 09:02:00 +00:00
|
|
|
VK_PIPELINE_STAGE_TRANSFER_BIT);
|
2016-02-16 19:24:00 +00:00
|
|
|
|
2016-06-26 11:10:19 +00:00
|
|
|
vkCmdCopyImage(vk->cmd, vk->chain->backbuffer.image,
|
2016-02-16 19:24:00 +00:00
|
|
|
VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
|
|
|
|
staging->image,
|
|
|
|
VK_IMAGE_LAYOUT_GENERAL,
|
2016-02-20 10:21:39 +00:00
|
|
|
1, ®ion);
|
2016-02-16 19:24:00 +00:00
|
|
|
|
|
|
|
/* Make the data visible to host. */
|
|
|
|
vulkan_image_layout_transition(vk, vk->cmd, staging->image,
|
|
|
|
VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_GENERAL,
|
|
|
|
VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_HOST_READ_BIT,
|
|
|
|
VK_PIPELINE_STAGE_TRANSFER_BIT,
|
|
|
|
VK_PIPELINE_STAGE_HOST_BIT);
|
|
|
|
}
|
|
|
|
|
2017-01-18 16:41:27 +00:00
|
|
|
static void vulkan_inject_black_frame(vk_t *vk, video_frame_info_t *video_info)
|
2016-07-23 22:07:32 +00:00
|
|
|
{
|
|
|
|
VkCommandBufferBeginInfo begin_info = {
|
|
|
|
VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO };
|
|
|
|
VkSubmitInfo submit_info = {
|
|
|
|
VK_STRUCTURE_TYPE_SUBMIT_INFO };
|
|
|
|
|
|
|
|
const VkClearColorValue clear_color = {{ 0.0f, 0.0f, 0.0f, 1.0f }};
|
|
|
|
const VkImageSubresourceRange range = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1 };
|
|
|
|
unsigned frame_index = vk->context->current_swapchain_index;
|
|
|
|
struct vk_per_frame *chain = &vk->swapchain[frame_index];
|
|
|
|
vk->chain = chain;
|
|
|
|
vk->cmd = chain->cmd;
|
|
|
|
begin_info.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
|
|
|
|
vkResetCommandBuffer(vk->cmd, 0);
|
|
|
|
vkBeginCommandBuffer(vk->cmd, &begin_info);
|
|
|
|
|
|
|
|
vulkan_image_layout_transition(vk, vk->cmd, chain->backbuffer.image,
|
|
|
|
VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
|
|
|
|
0, VK_ACCESS_TRANSFER_WRITE_BIT,
|
|
|
|
VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
|
|
|
|
VK_PIPELINE_STAGE_TRANSFER_BIT);
|
|
|
|
|
|
|
|
vkCmdClearColorImage(vk->cmd, chain->backbuffer.image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
|
|
|
|
&clear_color, 1, &range);
|
|
|
|
|
|
|
|
vulkan_image_layout_transition(vk, vk->cmd, chain->backbuffer.image,
|
|
|
|
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_LAYOUT_PRESENT_SRC_KHR,
|
2016-11-06 15:07:44 +00:00
|
|
|
VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_MEMORY_READ_BIT,
|
2016-07-23 22:07:32 +00:00
|
|
|
VK_PIPELINE_STAGE_TRANSFER_BIT,
|
|
|
|
VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT);
|
|
|
|
|
|
|
|
vkEndCommandBuffer(vk->cmd);
|
|
|
|
|
|
|
|
submit_info.commandBufferCount = 1;
|
|
|
|
submit_info.pCommandBuffers = &vk->cmd;
|
|
|
|
if (vk->context->swapchain_semaphores[frame_index] != VK_NULL_HANDLE)
|
|
|
|
{
|
|
|
|
submit_info.signalSemaphoreCount = 1;
|
|
|
|
submit_info.pSignalSemaphores = &vk->context->swapchain_semaphores[frame_index];
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef HAVE_THREADS
|
|
|
|
slock_lock(vk->context->queue_lock);
|
|
|
|
#endif
|
|
|
|
vkQueueSubmit(vk->context->queue, 1,
|
|
|
|
&submit_info, vk->context->swapchain_fences[frame_index]);
|
|
|
|
#ifdef HAVE_THREADS
|
|
|
|
slock_unlock(vk->context->queue_lock);
|
|
|
|
#endif
|
|
|
|
|
2017-05-18 01:05:07 +00:00
|
|
|
video_info->cb_swap_buffers(video_info->context_data, video_info);
|
2016-07-23 22:07:32 +00:00
|
|
|
}
|
|
|
|
|
2016-02-16 19:24:00 +00:00
|
|
|
static bool vulkan_frame(void *data, const void *frame,
|
|
|
|
unsigned frame_width, unsigned frame_height,
|
|
|
|
uint64_t frame_count,
|
2017-01-18 16:41:27 +00:00
|
|
|
unsigned pitch, const char *msg, video_frame_info_t *video_info)
|
2016-02-16 19:24:00 +00:00
|
|
|
{
|
2017-01-18 22:02:24 +00:00
|
|
|
VkSemaphore signal_semaphores[2];
|
2016-02-20 19:15:46 +00:00
|
|
|
vk_t *vk = (vk_t*)data;
|
2017-01-22 20:42:42 +00:00
|
|
|
struct vk_per_frame *chain = NULL;
|
2016-06-25 09:39:52 +00:00
|
|
|
bool waits_for_semaphores = false;
|
2017-01-18 22:02:24 +00:00
|
|
|
unsigned width = video_info->width;
|
|
|
|
unsigned height = video_info->height;
|
2017-02-20 19:51:24 +00:00
|
|
|
VkClearValue clear_color;
|
2016-03-06 11:11:44 +00:00
|
|
|
|
2016-02-20 19:29:52 +00:00
|
|
|
VkCommandBufferBeginInfo begin_info = {
|
2016-02-20 19:15:46 +00:00
|
|
|
VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO };
|
2016-02-20 19:29:52 +00:00
|
|
|
VkRenderPassBeginInfo rp_info = {
|
2016-02-20 19:15:46 +00:00
|
|
|
VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO };
|
2016-02-20 19:29:52 +00:00
|
|
|
VkSubmitInfo submit_info = {
|
2016-02-20 19:15:46 +00:00
|
|
|
VK_STRUCTURE_TYPE_SUBMIT_INFO };
|
2016-02-20 19:29:52 +00:00
|
|
|
unsigned frame_index =
|
|
|
|
vk->context->current_swapchain_index;
|
2016-02-16 19:24:00 +00:00
|
|
|
|
|
|
|
/* Bookkeeping on start of frame. */
|
2016-02-20 19:15:46 +00:00
|
|
|
chain = &vk->swapchain[frame_index];
|
2016-02-16 19:24:00 +00:00
|
|
|
vk->chain = chain;
|
|
|
|
|
|
|
|
vulkan_descriptor_manager_restart(&chain->descriptor_manager);
|
|
|
|
vulkan_buffer_chain_discard(&chain->vbo);
|
|
|
|
vulkan_buffer_chain_discard(&chain->ubo);
|
|
|
|
|
2016-02-21 11:33:16 +00:00
|
|
|
/* Start recording the command buffer. */
|
2016-02-29 20:37:35 +00:00
|
|
|
vk->cmd = chain->cmd;
|
2016-02-21 11:33:16 +00:00
|
|
|
begin_info.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
|
2016-06-26 11:10:19 +00:00
|
|
|
vkResetCommandBuffer(vk->cmd, 0);
|
2016-02-29 20:37:35 +00:00
|
|
|
|
2016-06-26 11:10:19 +00:00
|
|
|
vkBeginCommandBuffer(vk->cmd, &begin_info);
|
2016-03-06 11:11:44 +00:00
|
|
|
|
2016-02-21 11:33:16 +00:00
|
|
|
memset(&vk->tracker, 0, sizeof(vk->tracker));
|
|
|
|
|
2016-06-25 09:39:52 +00:00
|
|
|
waits_for_semaphores = vk->hw.enable && frame &&
|
|
|
|
!vk->hw.num_cmd && vk->hw.valid_semaphore;
|
|
|
|
|
|
|
|
if (waits_for_semaphores &&
|
|
|
|
vk->hw.src_queue_family != VK_QUEUE_FAMILY_IGNORED &&
|
|
|
|
vk->hw.src_queue_family != vk->context->graphics_queue_index)
|
|
|
|
{
|
|
|
|
retro_assert(vk->hw.image);
|
|
|
|
|
|
|
|
/* Acquire ownership of image from other queue family. */
|
|
|
|
vulkan_transfer_image_ownership(vk->cmd,
|
|
|
|
vk->hw.image->create_info.image,
|
|
|
|
vk->hw.image->image_layout,
|
|
|
|
/* Create a dependency chain from semaphore wait. */
|
|
|
|
VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
|
|
|
|
VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT |
|
|
|
|
VK_PIPELINE_STAGE_TRANSFER_BIT,
|
|
|
|
vk->hw.src_queue_family, vk->context->graphics_queue_index);
|
|
|
|
}
|
|
|
|
|
2016-02-16 19:24:00 +00:00
|
|
|
/* Upload texture */
|
2017-01-22 22:19:35 +00:00
|
|
|
if (frame && !vk->hw.enable)
|
2016-02-16 19:24:00 +00:00
|
|
|
{
|
|
|
|
unsigned y;
|
2016-02-20 19:15:46 +00:00
|
|
|
uint8_t *dst = NULL;
|
|
|
|
const uint8_t *src = (const uint8_t*)frame;
|
|
|
|
unsigned bpp = vk->video.rgb32 ? 4 : 2;
|
2016-02-16 19:24:00 +00:00
|
|
|
|
2016-02-20 19:29:52 +00:00
|
|
|
if ( chain->texture.width != frame_width
|
|
|
|
|| chain->texture.height != frame_height)
|
2016-02-16 19:24:00 +00:00
|
|
|
{
|
|
|
|
chain->texture = vulkan_create_texture(vk, &chain->texture,
|
2016-02-21 11:33:16 +00:00
|
|
|
frame_width, frame_height, chain->texture.format, NULL, NULL,
|
2016-02-29 18:03:18 +00:00
|
|
|
chain->texture_optimal.memory
|
|
|
|
? VULKAN_TEXTURE_STAGING : VULKAN_TEXTURE_STREAMED);
|
|
|
|
|
2016-03-01 01:21:53 +00:00
|
|
|
vulkan_map_persistent_texture(
|
2016-02-29 18:03:18 +00:00
|
|
|
vk->context->device, &chain->texture);
|
2016-02-21 11:33:16 +00:00
|
|
|
|
|
|
|
if (chain->texture.type == VULKAN_TEXTURE_STAGING)
|
|
|
|
{
|
2016-02-29 18:03:18 +00:00
|
|
|
chain->texture_optimal = vulkan_create_texture(
|
|
|
|
vk,
|
|
|
|
&chain->texture_optimal,
|
2016-02-21 11:33:16 +00:00
|
|
|
frame_width, frame_height, chain->texture_optimal.format,
|
|
|
|
NULL, NULL, VULKAN_TEXTURE_DYNAMIC);
|
|
|
|
}
|
2016-02-16 19:24:00 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (frame != chain->texture.mapped)
|
|
|
|
{
|
|
|
|
dst = (uint8_t*)chain->texture.mapped;
|
|
|
|
if (chain->texture.stride == pitch && pitch == frame_width * bpp)
|
|
|
|
memcpy(dst, src, frame_width * frame_height * bpp);
|
|
|
|
else
|
2016-02-20 19:29:52 +00:00
|
|
|
for (y = 0; y < frame_height; y++,
|
|
|
|
dst += chain->texture.stride, src += pitch)
|
2016-02-16 19:24:00 +00:00
|
|
|
memcpy(dst, src, frame_width * bpp);
|
|
|
|
}
|
|
|
|
|
2016-02-21 11:33:16 +00:00
|
|
|
/* If we have an optimal texture, copy to that now. */
|
2016-02-21 11:59:11 +00:00
|
|
|
if (chain->texture_optimal.memory != VK_NULL_HANDLE)
|
2016-02-21 11:33:16 +00:00
|
|
|
{
|
|
|
|
vulkan_copy_staging_to_dynamic(vk, vk->cmd,
|
|
|
|
&chain->texture_optimal, &chain->texture);
|
|
|
|
}
|
2016-07-15 16:10:22 +00:00
|
|
|
else
|
|
|
|
vulkan_sync_texture_to_gpu(vk, &chain->texture);
|
2016-02-21 11:33:16 +00:00
|
|
|
|
2016-02-16 19:24:00 +00:00
|
|
|
vk->last_valid_index = frame_index;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Notify filter chain about the new sync index. */
|
2016-09-01 16:26:01 +00:00
|
|
|
vulkan_filter_chain_notify_sync_index((vulkan_filter_chain_t*)vk->filter_chain, frame_index);
|
|
|
|
vulkan_filter_chain_set_frame_count((vulkan_filter_chain_t*)vk->filter_chain, frame_count);
|
2016-02-16 19:24:00 +00:00
|
|
|
|
|
|
|
/* Render offscreen filter chain passes. */
|
|
|
|
{
|
|
|
|
/* Set the source texture in the filter chain */
|
|
|
|
struct vulkan_filter_chain_texture input;
|
|
|
|
|
|
|
|
if (vk->hw.enable)
|
|
|
|
{
|
|
|
|
/* Does this make that this can happen at all? */
|
|
|
|
if (!vk->hw.image)
|
|
|
|
{
|
|
|
|
RARCH_ERR("[Vulkan]: HW image is not set. Buggy core?\n");
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2016-03-25 13:51:37 +00:00
|
|
|
input.image = vk->hw.image->create_info.image;
|
2016-02-29 05:31:55 +00:00
|
|
|
input.view = vk->hw.image->image_view;
|
|
|
|
input.layout = vk->hw.image->image_layout;
|
2016-02-16 19:24:00 +00:00
|
|
|
|
|
|
|
if (frame)
|
|
|
|
{
|
2016-02-29 05:31:55 +00:00
|
|
|
input.width = frame_width;
|
|
|
|
input.height = frame_height;
|
2016-02-16 19:24:00 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2016-02-29 05:31:55 +00:00
|
|
|
input.width = vk->hw.last_width;
|
|
|
|
input.height = vk->hw.last_height;
|
2016-02-16 19:24:00 +00:00
|
|
|
}
|
|
|
|
|
2016-02-20 19:15:46 +00:00
|
|
|
vk->hw.last_width = input.width;
|
2016-02-16 19:24:00 +00:00
|
|
|
vk->hw.last_height = input.height;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
struct vk_texture *tex = &vk->swapchain[vk->last_valid_index].texture;
|
2016-02-21 11:33:16 +00:00
|
|
|
if (vk->swapchain[vk->last_valid_index].texture_optimal.memory != VK_NULL_HANDLE)
|
|
|
|
tex = &vk->swapchain[vk->last_valid_index].texture_optimal;
|
|
|
|
else
|
2017-05-15 04:35:17 +00:00
|
|
|
vulkan_transition_texture(vk, vk->cmd, tex);
|
2016-02-16 19:24:00 +00:00
|
|
|
|
2016-03-25 13:51:37 +00:00
|
|
|
input.image = tex->image;
|
2016-02-20 19:15:46 +00:00
|
|
|
input.view = tex->view;
|
2016-02-16 19:24:00 +00:00
|
|
|
input.layout = tex->layout;
|
2016-02-20 19:15:46 +00:00
|
|
|
input.width = tex->width;
|
2016-02-16 19:24:00 +00:00
|
|
|
input.height = tex->height;
|
|
|
|
}
|
|
|
|
|
2016-09-01 16:26:01 +00:00
|
|
|
vulkan_filter_chain_set_input_texture((vulkan_filter_chain_t*)vk->filter_chain, &input);
|
2016-02-16 19:24:00 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
vulkan_set_viewport(vk, width, height, false, true);
|
|
|
|
|
2016-02-20 19:15:46 +00:00
|
|
|
vulkan_filter_chain_build_offscreen_passes(
|
2016-09-01 16:26:01 +00:00
|
|
|
(vulkan_filter_chain_t*)vk->filter_chain,
|
|
|
|
vk->cmd, &vk->vk_vp);
|
2016-02-16 19:24:00 +00:00
|
|
|
/* Render to backbuffer. */
|
2016-02-20 19:15:46 +00:00
|
|
|
rp_info.renderPass = vk->render_pass;
|
|
|
|
rp_info.framebuffer = chain->backbuffer.framebuffer;
|
|
|
|
rp_info.renderArea.extent.width = vk->context->swapchain_width;
|
2016-02-16 19:24:00 +00:00
|
|
|
rp_info.renderArea.extent.height = vk->context->swapchain_height;
|
2016-02-20 19:15:46 +00:00
|
|
|
rp_info.clearValueCount = 1;
|
2017-02-20 19:51:24 +00:00
|
|
|
rp_info.pClearValues = &clear_color;
|
|
|
|
|
|
|
|
clear_color.color.float32[0] = 0.0f;
|
|
|
|
clear_color.color.float32[1] = 0.0f;
|
|
|
|
clear_color.color.float32[2] = 0.0f;
|
|
|
|
clear_color.color.float32[3] = 0.0f;
|
2016-02-16 19:24:00 +00:00
|
|
|
|
2016-03-21 09:02:00 +00:00
|
|
|
/* Prepare backbuffer for rendering. We don't use WSI semaphores here. */
|
2016-02-16 19:24:00 +00:00
|
|
|
vulkan_image_layout_transition(vk, vk->cmd, chain->backbuffer.image,
|
|
|
|
VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
|
2016-03-21 09:02:00 +00:00
|
|
|
0, VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT | VK_ACCESS_COLOR_ATTACHMENT_READ_BIT,
|
2016-02-16 19:24:00 +00:00
|
|
|
VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
|
2016-03-21 09:02:00 +00:00
|
|
|
VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT);
|
2016-02-16 19:24:00 +00:00
|
|
|
|
|
|
|
/* Begin render pass and set up viewport */
|
2016-06-26 11:10:19 +00:00
|
|
|
vkCmdBeginRenderPass(vk->cmd, &rp_info, VK_SUBPASS_CONTENTS_INLINE);
|
2016-02-16 19:24:00 +00:00
|
|
|
|
2016-09-01 16:26:01 +00:00
|
|
|
vulkan_filter_chain_build_viewport_pass(
|
|
|
|
(vulkan_filter_chain_t*)vk->filter_chain, vk->cmd,
|
2016-02-16 19:24:00 +00:00
|
|
|
&vk->vk_vp, vk->mvp.data);
|
|
|
|
|
|
|
|
#if defined(HAVE_MENU)
|
|
|
|
if (vk->menu.enable)
|
|
|
|
{
|
2017-01-18 20:23:18 +00:00
|
|
|
menu_driver_frame(video_info);
|
2016-02-16 19:24:00 +00:00
|
|
|
|
|
|
|
if (vk->menu.textures[vk->menu.last_index].image != VK_NULL_HANDLE)
|
|
|
|
{
|
|
|
|
struct vk_draw_quad quad;
|
2016-02-21 11:33:16 +00:00
|
|
|
struct vk_texture *optimal = &vk->menu.textures_optimal[vk->menu.last_index];
|
2016-02-16 19:24:00 +00:00
|
|
|
vulkan_set_viewport(vk, width, height, vk->menu.full_screen, false);
|
|
|
|
|
|
|
|
quad.pipeline = vk->pipelines.alpha_blend;
|
|
|
|
quad.texture = &vk->menu.textures[vk->menu.last_index];
|
2016-02-21 11:33:16 +00:00
|
|
|
|
|
|
|
if (optimal->memory != VK_NULL_HANDLE)
|
|
|
|
{
|
|
|
|
if (vk->menu.dirty[vk->menu.last_index])
|
|
|
|
{
|
|
|
|
vulkan_copy_staging_to_dynamic(vk, vk->cmd,
|
|
|
|
optimal,
|
|
|
|
quad.texture);
|
|
|
|
vk->menu.dirty[vk->menu.last_index] = false;
|
|
|
|
}
|
|
|
|
quad.texture = optimal;
|
|
|
|
}
|
|
|
|
|
2016-07-31 11:47:10 +00:00
|
|
|
quad.sampler = optimal->mipmap ?
|
|
|
|
vk->samplers.mipmap_linear : vk->samplers.linear;
|
|
|
|
|
2016-02-29 21:23:35 +00:00
|
|
|
quad.mvp = &vk->mvp_no_rot;
|
2016-02-16 19:24:00 +00:00
|
|
|
quad.color.r = 1.0f;
|
|
|
|
quad.color.g = 1.0f;
|
|
|
|
quad.color.b = 1.0f;
|
|
|
|
quad.color.a = vk->menu.alpha;
|
|
|
|
vulkan_draw_quad(vk, &quad);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
if (msg)
|
2017-01-19 15:30:40 +00:00
|
|
|
font_driver_render_msg(video_info, NULL, msg, NULL);
|
2016-02-16 19:24:00 +00:00
|
|
|
|
|
|
|
#ifdef HAVE_OVERLAY
|
|
|
|
if (vk->overlay.enable)
|
2017-01-18 22:02:24 +00:00
|
|
|
vulkan_render_overlay(vk, video_info);
|
2016-02-16 19:24:00 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
/* End the render pass. We're done rendering to backbuffer now. */
|
2016-06-26 11:10:19 +00:00
|
|
|
vkCmdEndRenderPass(vk->cmd);
|
2016-02-16 19:24:00 +00:00
|
|
|
|
2016-08-06 23:09:15 +00:00
|
|
|
/* End the filter chain frame.
|
|
|
|
* This must happen outside a render pass.
|
|
|
|
*/
|
2016-09-01 16:26:01 +00:00
|
|
|
vulkan_filter_chain_end_frame((vulkan_filter_chain_t*)vk->filter_chain, vk->cmd);
|
2016-08-06 23:09:15 +00:00
|
|
|
|
2016-02-16 19:24:00 +00:00
|
|
|
if (vk->readback.pending || vk->readback.streamed)
|
|
|
|
{
|
2016-02-20 19:29:52 +00:00
|
|
|
/* We cannot safely read back from an image which
|
|
|
|
* has already been presented as we need to
|
|
|
|
* maintain the PRESENT_SRC_KHR layout.
|
|
|
|
*
|
2016-02-16 19:24:00 +00:00
|
|
|
* If we're reading back, perform the readback before presenting.
|
|
|
|
*/
|
2016-02-20 19:29:52 +00:00
|
|
|
vulkan_image_layout_transition(vk,
|
|
|
|
vk->cmd, chain->backbuffer.image,
|
2016-02-20 19:15:46 +00:00
|
|
|
VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
|
|
|
|
VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
|
|
|
|
VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
|
|
|
|
VK_ACCESS_TRANSFER_READ_BIT,
|
|
|
|
VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT,
|
|
|
|
VK_PIPELINE_STAGE_TRANSFER_BIT);
|
2016-02-16 19:24:00 +00:00
|
|
|
|
|
|
|
vulkan_readback(vk);
|
|
|
|
|
|
|
|
/* Prepare for presentation after transfers are complete. */
|
2016-02-20 19:29:52 +00:00
|
|
|
vulkan_image_layout_transition(vk, vk->cmd,
|
|
|
|
chain->backbuffer.image,
|
2016-02-20 19:15:46 +00:00
|
|
|
VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
|
|
|
|
VK_IMAGE_LAYOUT_PRESENT_SRC_KHR,
|
2016-03-21 09:02:00 +00:00
|
|
|
0,
|
2016-11-06 15:07:44 +00:00
|
|
|
VK_ACCESS_MEMORY_READ_BIT,
|
2016-02-20 19:15:46 +00:00
|
|
|
VK_PIPELINE_STAGE_TRANSFER_BIT,
|
2016-03-21 09:02:00 +00:00
|
|
|
VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT);
|
2016-02-16 19:24:00 +00:00
|
|
|
|
|
|
|
vk->readback.pending = false;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
/* Prepare backbuffer for presentation. */
|
2016-02-20 19:29:52 +00:00
|
|
|
vulkan_image_layout_transition(vk, vk->cmd,
|
|
|
|
chain->backbuffer.image,
|
2016-02-20 19:15:46 +00:00
|
|
|
VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
|
|
|
|
VK_IMAGE_LAYOUT_PRESENT_SRC_KHR,
|
|
|
|
VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
|
2016-11-06 15:07:44 +00:00
|
|
|
VK_ACCESS_MEMORY_READ_BIT,
|
2016-02-20 19:15:46 +00:00
|
|
|
VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT,
|
2016-03-21 09:02:00 +00:00
|
|
|
VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT);
|
2016-02-16 19:24:00 +00:00
|
|
|
}
|
|
|
|
|
2016-06-25 09:39:52 +00:00
|
|
|
if (waits_for_semaphores &&
|
|
|
|
vk->hw.src_queue_family != VK_QUEUE_FAMILY_IGNORED &&
|
|
|
|
vk->hw.src_queue_family != vk->context->graphics_queue_index)
|
|
|
|
{
|
|
|
|
retro_assert(vk->hw.image);
|
|
|
|
|
|
|
|
/* Release ownership of image back to other queue family. */
|
|
|
|
vulkan_transfer_image_ownership(vk->cmd,
|
|
|
|
vk->hw.image->create_info.image,
|
|
|
|
vk->hw.image->image_layout,
|
|
|
|
VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT,
|
|
|
|
VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT,
|
|
|
|
vk->context->graphics_queue_index, vk->hw.src_queue_family);
|
|
|
|
}
|
|
|
|
|
2016-06-26 11:10:19 +00:00
|
|
|
vkEndCommandBuffer(vk->cmd);
|
2016-02-16 19:24:00 +00:00
|
|
|
|
|
|
|
/* Submit command buffers to GPU. */
|
|
|
|
|
|
|
|
if (vk->hw.num_cmd)
|
|
|
|
{
|
|
|
|
/* vk->hw.cmd has already been allocated for this. */
|
2016-02-20 19:15:46 +00:00
|
|
|
vk->hw.cmd[vk->hw.num_cmd] = vk->cmd;
|
2016-02-16 19:24:00 +00:00
|
|
|
|
|
|
|
submit_info.commandBufferCount = vk->hw.num_cmd + 1;
|
2016-02-20 19:15:46 +00:00
|
|
|
submit_info.pCommandBuffers = vk->hw.cmd;
|
2016-02-16 19:24:00 +00:00
|
|
|
|
2016-02-20 19:15:46 +00:00
|
|
|
vk->hw.num_cmd = 0;
|
2016-02-16 19:24:00 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
submit_info.commandBufferCount = 1;
|
2016-02-20 19:15:46 +00:00
|
|
|
submit_info.pCommandBuffers = &vk->cmd;
|
2016-02-16 19:24:00 +00:00
|
|
|
}
|
|
|
|
|
2016-06-25 09:39:52 +00:00
|
|
|
if (waits_for_semaphores)
|
2016-02-16 19:24:00 +00:00
|
|
|
{
|
|
|
|
submit_info.waitSemaphoreCount = vk->hw.num_semaphores;
|
2016-02-20 19:15:46 +00:00
|
|
|
submit_info.pWaitSemaphores = vk->hw.semaphores;
|
|
|
|
submit_info.pWaitDstStageMask = vk->hw.wait_dst_stages;
|
2016-06-25 09:39:52 +00:00
|
|
|
|
|
|
|
/* Consume the semaphores. */
|
|
|
|
vk->hw.valid_semaphore = false;
|
2016-02-16 19:24:00 +00:00
|
|
|
}
|
|
|
|
|
2016-06-26 16:58:59 +00:00
|
|
|
submit_info.signalSemaphoreCount = 0;
|
|
|
|
|
|
|
|
if (vk->context->swapchain_semaphores[frame_index] != VK_NULL_HANDLE)
|
|
|
|
signal_semaphores[submit_info.signalSemaphoreCount++] = vk->context->swapchain_semaphores[frame_index];
|
|
|
|
|
|
|
|
if (vk->hw.signal_semaphore != VK_NULL_HANDLE)
|
|
|
|
{
|
|
|
|
signal_semaphores[submit_info.signalSemaphoreCount++] = vk->hw.signal_semaphore;
|
|
|
|
vk->hw.signal_semaphore = VK_NULL_HANDLE;
|
|
|
|
}
|
|
|
|
submit_info.pSignalSemaphores = submit_info.signalSemaphoreCount ? signal_semaphores : NULL;
|
2016-02-20 19:15:46 +00:00
|
|
|
|
2016-02-16 19:24:00 +00:00
|
|
|
|
2016-05-11 08:10:30 +00:00
|
|
|
#ifdef HAVE_THREADS
|
2016-02-16 19:24:00 +00:00
|
|
|
slock_lock(vk->context->queue_lock);
|
2016-05-11 08:10:30 +00:00
|
|
|
#endif
|
2016-06-26 11:10:19 +00:00
|
|
|
vkQueueSubmit(vk->context->queue, 1,
|
2016-02-20 19:15:46 +00:00
|
|
|
&submit_info, vk->context->swapchain_fences[frame_index]);
|
2016-05-11 08:10:30 +00:00
|
|
|
#ifdef HAVE_THREADS
|
2016-02-16 19:24:00 +00:00
|
|
|
slock_unlock(vk->context->queue_lock);
|
2016-05-11 08:10:30 +00:00
|
|
|
#endif
|
2016-02-16 19:24:00 +00:00
|
|
|
|
2017-05-18 01:05:07 +00:00
|
|
|
video_info->cb_swap_buffers(video_info->context_data, video_info);
|
2017-04-23 09:31:11 +00:00
|
|
|
|
2017-05-18 00:53:12 +00:00
|
|
|
if (!vk->context->swap_interval_emulation_lock)
|
2017-05-18 01:05:07 +00:00
|
|
|
video_info->cb_update_window_title(
|
|
|
|
video_info->context_data, video_info);
|
2017-05-18 00:53:12 +00:00
|
|
|
|
2016-02-16 19:24:00 +00:00
|
|
|
/* Handle spurious swapchain invalidations as soon as we can,
|
|
|
|
* i.e. right after swap buffers. */
|
|
|
|
if (vk->should_resize)
|
|
|
|
{
|
|
|
|
gfx_ctx_mode_t mode;
|
|
|
|
mode.width = width;
|
|
|
|
mode.height = height;
|
2017-05-18 01:37:02 +00:00
|
|
|
|
|
|
|
video_info->cb_set_resize(video_info->context_data, mode.width, mode.height);
|
2016-02-16 19:24:00 +00:00
|
|
|
|
|
|
|
vk->should_resize = false;
|
|
|
|
}
|
|
|
|
vulkan_check_swapchain(vk);
|
|
|
|
|
2016-07-23 22:07:32 +00:00
|
|
|
/* Disable BFI during fast forward, slow-motion,
|
|
|
|
* and pause to prevent flicker. */
|
|
|
|
if (
|
2017-01-18 16:41:27 +00:00
|
|
|
video_info->black_frame_insertion
|
2017-05-08 22:58:01 +00:00
|
|
|
&& !video_info->input_driver_nonblock_state
|
2017-01-22 11:38:20 +00:00
|
|
|
&& !video_info->runloop_is_slowmotion
|
|
|
|
&& !video_info->runloop_is_paused)
|
2016-07-23 22:07:32 +00:00
|
|
|
{
|
2017-01-09 13:59:15 +00:00
|
|
|
vulkan_inject_black_frame(vk, video_info);
|
2016-07-23 22:07:32 +00:00
|
|
|
}
|
|
|
|
|
2016-07-23 22:34:48 +00:00
|
|
|
/* 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)
|
|
|
|
{
|
|
|
|
unsigned i;
|
|
|
|
vk->context->swap_interval_emulation_lock = true;
|
|
|
|
for (i = 1; i < vk->context->swap_interval; i++)
|
|
|
|
{
|
2017-01-09 13:25:59 +00:00
|
|
|
if (!vulkan_frame(vk, NULL, 0, 0, frame_count, 0, msg,
|
|
|
|
video_info))
|
2016-07-23 22:34:48 +00:00
|
|
|
{
|
|
|
|
vk->context->swap_interval_emulation_lock = false;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
vk->context->swap_interval_emulation_lock = false;
|
|
|
|
}
|
|
|
|
|
2016-02-16 19:24:00 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void vulkan_set_aspect_ratio(void *data, unsigned aspect_ratio_idx)
|
|
|
|
{
|
|
|
|
vk_t *vk = (vk_t*)data;
|
|
|
|
|
|
|
|
switch (aspect_ratio_idx)
|
|
|
|
{
|
|
|
|
case ASPECT_RATIO_SQUARE:
|
2016-05-08 12:00:51 +00:00
|
|
|
video_driver_set_viewport_square_pixel();
|
2016-02-16 19:24:00 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case ASPECT_RATIO_CORE:
|
2016-05-08 12:00:51 +00:00
|
|
|
video_driver_set_viewport_core();
|
2016-02-16 19:24:00 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case ASPECT_RATIO_CONFIG:
|
2016-05-08 12:00:51 +00:00
|
|
|
video_driver_set_viewport_config();
|
2016-02-16 19:24:00 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2016-02-20 19:15:46 +00:00
|
|
|
video_driver_set_aspect_ratio_value(
|
|
|
|
aspectratio_lut[aspect_ratio_idx].value);
|
2016-02-16 19:24:00 +00:00
|
|
|
|
|
|
|
if (!vk)
|
|
|
|
return;
|
|
|
|
|
|
|
|
vk->keep_aspect = true;
|
|
|
|
vk->should_resize = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void vulkan_apply_state_changes(void *data)
|
|
|
|
{
|
|
|
|
vk_t *vk = (vk_t*)data;
|
|
|
|
if (vk)
|
|
|
|
vk->should_resize = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void vulkan_show_mouse(void *data, bool state)
|
|
|
|
{
|
|
|
|
(void)data;
|
2016-05-08 18:32:46 +00:00
|
|
|
video_context_driver_show_mouse(&state);
|
2016-02-16 19:24:00 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static struct video_shader *vulkan_get_current_shader(void *data)
|
|
|
|
{
|
|
|
|
vk_t *vk = (vk_t*)data;
|
|
|
|
if (!vk || !vk->filter_chain)
|
|
|
|
return NULL;
|
|
|
|
|
2016-09-01 16:26:01 +00:00
|
|
|
return vulkan_filter_chain_get_preset((vulkan_filter_chain_t*)vk->filter_chain);
|
2016-02-16 19:24:00 +00:00
|
|
|
}
|
|
|
|
|
2016-02-20 19:15:46 +00:00
|
|
|
static bool vulkan_get_current_sw_framebuffer(void *data,
|
|
|
|
struct retro_framebuffer *framebuffer)
|
2016-02-16 19:24:00 +00:00
|
|
|
{
|
2016-02-29 21:55:31 +00:00
|
|
|
struct vk_per_frame *chain = NULL;
|
|
|
|
vk_t *vk = (vk_t*)data;
|
|
|
|
vk->chain =
|
|
|
|
&vk->swapchain[vk->context->current_swapchain_index];
|
|
|
|
chain = vk->chain;
|
2016-02-16 19:24:00 +00:00
|
|
|
|
|
|
|
if (chain->texture.width != framebuffer->width ||
|
|
|
|
chain->texture.height != framebuffer->height)
|
|
|
|
{
|
2016-02-20 19:15:46 +00:00
|
|
|
chain->texture = vulkan_create_texture(vk, &chain->texture,
|
2016-02-16 19:24:00 +00:00
|
|
|
framebuffer->width, framebuffer->height, chain->texture.format,
|
|
|
|
NULL, NULL, VULKAN_TEXTURE_STREAMED);
|
2016-03-01 01:21:53 +00:00
|
|
|
vulkan_map_persistent_texture(
|
2016-02-29 18:03:18 +00:00
|
|
|
vk->context->device, &chain->texture);
|
2016-02-21 11:33:16 +00:00
|
|
|
|
|
|
|
if (chain->texture.type == VULKAN_TEXTURE_STAGING)
|
|
|
|
{
|
2016-02-29 18:16:21 +00:00
|
|
|
chain->texture_optimal = vulkan_create_texture(
|
|
|
|
vk,
|
|
|
|
&chain->texture_optimal,
|
|
|
|
framebuffer->width,
|
|
|
|
framebuffer->height,
|
|
|
|
chain->texture_optimal.format,
|
2016-02-21 11:33:16 +00:00
|
|
|
NULL, NULL, VULKAN_TEXTURE_DYNAMIC);
|
|
|
|
}
|
2016-02-16 19:24:00 +00:00
|
|
|
}
|
|
|
|
|
2016-02-29 18:16:21 +00:00
|
|
|
framebuffer->data = chain->texture.mapped;
|
|
|
|
framebuffer->pitch = chain->texture.stride;
|
|
|
|
framebuffer->format = vk->video.rgb32
|
2016-02-20 19:15:46 +00:00
|
|
|
? RETRO_PIXEL_FORMAT_XRGB8888 : RETRO_PIXEL_FORMAT_RGB565;
|
2016-02-16 19:24:00 +00:00
|
|
|
framebuffer->memory_flags = 0;
|
2016-02-29 18:16:21 +00:00
|
|
|
|
2016-02-20 19:15:46 +00:00
|
|
|
if (vk->context->memory_properties.memoryTypes[
|
|
|
|
chain->texture.memory_type].propertyFlags &
|
2016-02-16 19:24:00 +00:00
|
|
|
VK_MEMORY_PROPERTY_HOST_CACHED_BIT)
|
|
|
|
framebuffer->memory_flags |= RETRO_MEMORY_TYPE_CACHED;
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2016-02-20 19:15:46 +00:00
|
|
|
static bool vulkan_get_hw_render_interface(void *data,
|
|
|
|
const struct retro_hw_render_interface **iface)
|
2016-02-16 19:24:00 +00:00
|
|
|
{
|
|
|
|
vk_t *vk = (vk_t*)data;
|
2016-02-20 19:15:46 +00:00
|
|
|
*iface = (const struct retro_hw_render_interface*)&vk->hw.iface;
|
2016-02-16 19:24:00 +00:00
|
|
|
return vk->hw.enable;
|
|
|
|
}
|
|
|
|
|
|
|
|
#if defined(HAVE_MENU)
|
|
|
|
static void vulkan_set_texture_frame(void *data,
|
|
|
|
const void *frame, bool rgb32, unsigned width, unsigned height,
|
|
|
|
float alpha)
|
|
|
|
{
|
2016-03-01 17:46:40 +00:00
|
|
|
unsigned y, stride;
|
2016-02-29 18:16:21 +00:00
|
|
|
uint8_t *ptr = NULL;
|
|
|
|
uint8_t *dst = NULL;
|
|
|
|
const uint8_t *src = NULL;
|
2016-02-21 11:45:26 +00:00
|
|
|
vk_t *vk = (vk_t*)data;
|
2016-11-26 04:21:25 +00:00
|
|
|
unsigned index = 0;
|
|
|
|
struct vk_texture *texture = NULL;
|
|
|
|
struct vk_texture *texture_optimal = NULL;
|
2016-02-16 19:24:00 +00:00
|
|
|
const VkComponentMapping br_swizzle = {
|
|
|
|
VK_COMPONENT_SWIZZLE_B,
|
|
|
|
VK_COMPONENT_SWIZZLE_G,
|
|
|
|
VK_COMPONENT_SWIZZLE_R,
|
|
|
|
VK_COMPONENT_SWIZZLE_A,
|
|
|
|
};
|
|
|
|
|
|
|
|
if (!vk)
|
|
|
|
return;
|
|
|
|
|
2016-11-26 04:21:25 +00:00
|
|
|
index = vk->context->current_swapchain_index;
|
|
|
|
texture = &vk->menu.textures[index];
|
|
|
|
texture_optimal = &vk->menu.textures_optimal[index];
|
|
|
|
|
2016-02-16 19:24:00 +00:00
|
|
|
/* B4G4R4A4 must be supported, but R4G4B4A4 is optional,
|
|
|
|
* just apply the swizzle in the image view instead. */
|
|
|
|
*texture = vulkan_create_texture(vk,
|
|
|
|
texture->memory ? texture : NULL,
|
|
|
|
width, height,
|
|
|
|
rgb32 ? VK_FORMAT_B8G8R8A8_UNORM : VK_FORMAT_B4G4R4A4_UNORM_PACK16,
|
2016-02-21 11:33:16 +00:00
|
|
|
NULL, rgb32 ? NULL : &br_swizzle,
|
|
|
|
texture_optimal->memory ? VULKAN_TEXTURE_STAGING : VULKAN_TEXTURE_STREAMED);
|
2016-02-16 19:24:00 +00:00
|
|
|
|
2016-06-26 11:10:19 +00:00
|
|
|
vkMapMemory(vk->context->device, texture->memory,
|
2016-02-16 19:24:00 +00:00
|
|
|
texture->offset, texture->size, 0, (void**)&ptr);
|
|
|
|
|
2016-02-29 18:16:21 +00:00
|
|
|
dst = ptr;
|
|
|
|
src = (const uint8_t*)frame;
|
|
|
|
stride = (rgb32 ? sizeof(uint32_t) : sizeof(uint16_t)) * width;
|
|
|
|
|
2016-02-16 19:24:00 +00:00
|
|
|
for (y = 0; y < height; y++, dst += texture->stride, src += stride)
|
|
|
|
memcpy(dst, src, stride);
|
|
|
|
|
2016-07-15 16:10:22 +00:00
|
|
|
vulkan_sync_texture_to_gpu(vk, texture);
|
2016-06-26 11:10:19 +00:00
|
|
|
vkUnmapMemory(vk->context->device, texture->memory);
|
2016-02-29 18:16:21 +00:00
|
|
|
|
2016-02-20 19:15:46 +00:00
|
|
|
vk->menu.alpha = alpha;
|
2016-02-16 19:24:00 +00:00
|
|
|
vk->menu.last_index = index;
|
2016-02-21 11:33:16 +00:00
|
|
|
|
|
|
|
if (texture->type == VULKAN_TEXTURE_STAGING)
|
|
|
|
{
|
|
|
|
*texture_optimal = vulkan_create_texture(vk,
|
|
|
|
texture_optimal->memory ? texture_optimal : NULL,
|
|
|
|
width, height,
|
|
|
|
rgb32 ? VK_FORMAT_B8G8R8A8_UNORM : VK_FORMAT_B4G4R4A4_UNORM_PACK16,
|
|
|
|
NULL, rgb32 ? NULL : &br_swizzle,
|
|
|
|
VULKAN_TEXTURE_DYNAMIC);
|
|
|
|
}
|
|
|
|
|
|
|
|
vk->menu.dirty[index] = true;
|
2016-02-16 19:24:00 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void vulkan_set_texture_enable(void *data, bool state, bool full_screen)
|
|
|
|
{
|
|
|
|
vk_t *vk = (vk_t*)data;
|
|
|
|
if (!vk)
|
|
|
|
return;
|
|
|
|
|
|
|
|
vk->menu.enable = state;
|
|
|
|
vk->menu.full_screen = full_screen;
|
|
|
|
}
|
|
|
|
|
2017-04-23 20:20:11 +00:00
|
|
|
static void vulkan_set_osd_msg(void *data,
|
|
|
|
video_frame_info_t *video_info,
|
|
|
|
const char *msg,
|
2017-01-19 15:30:40 +00:00
|
|
|
const void *params, void *font)
|
2016-02-16 19:24:00 +00:00
|
|
|
{
|
2017-04-23 20:20:11 +00:00
|
|
|
font_driver_render_msg(video_info, font, msg, params);
|
2016-02-16 19:24:00 +00:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
static uintptr_t vulkan_load_texture(void *video_data, void *data,
|
|
|
|
bool threaded, enum texture_filter_type filter_type)
|
|
|
|
{
|
2016-02-20 19:15:46 +00:00
|
|
|
vk_t *vk = (vk_t*)video_data;
|
2016-02-16 19:24:00 +00:00
|
|
|
struct texture_image *image = (struct texture_image*)data;
|
|
|
|
struct vk_texture *texture = (struct vk_texture*)calloc(1, sizeof(*texture));
|
2016-12-03 17:54:34 +00:00
|
|
|
if (!image || !texture)
|
2016-02-16 19:24:00 +00:00
|
|
|
return 0;
|
|
|
|
|
2016-12-03 17:54:34 +00:00
|
|
|
if (!image->pixels || !image->width || !image->height)
|
2016-12-03 16:48:48 +00:00
|
|
|
{
|
|
|
|
/* Create a dummy texture instead. */
|
|
|
|
#define T0 0xff000000u
|
|
|
|
#define T1 0xffffffffu
|
|
|
|
static const uint32_t checkerboard[] = {
|
|
|
|
T0, T1, T0, T1, T0, T1, T0, T1,
|
|
|
|
T1, T0, T1, T0, T1, T0, T1, T0,
|
|
|
|
T0, T1, T0, T1, T0, T1, T0, T1,
|
|
|
|
T1, T0, T1, T0, T1, T0, T1, T0,
|
|
|
|
T0, T1, T0, T1, T0, T1, T0, T1,
|
|
|
|
T1, T0, T1, T0, T1, T0, T1, T0,
|
|
|
|
T0, T1, T0, T1, T0, T1, T0, T1,
|
|
|
|
T1, T0, T1, T0, T1, T0, T1, T0,
|
|
|
|
};
|
|
|
|
#undef T0
|
|
|
|
#undef T1
|
|
|
|
*texture = vulkan_create_texture(vk, NULL,
|
|
|
|
8, 8, VK_FORMAT_B8G8R8A8_UNORM,
|
|
|
|
checkerboard, NULL, VULKAN_TEXTURE_STATIC);
|
|
|
|
texture->default_smooth = false;
|
|
|
|
texture->mipmap = false;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
*texture = vulkan_create_texture(vk, NULL,
|
|
|
|
image->width, image->height, VK_FORMAT_B8G8R8A8_UNORM,
|
|
|
|
image->pixels, NULL, VULKAN_TEXTURE_STATIC);
|
2016-02-16 19:24:00 +00:00
|
|
|
|
2016-12-03 16:48:48 +00:00
|
|
|
texture->default_smooth =
|
|
|
|
filter_type == TEXTURE_FILTER_MIPMAP_LINEAR || filter_type == TEXTURE_FILTER_LINEAR;
|
|
|
|
texture->mipmap = filter_type == TEXTURE_FILTER_MIPMAP_LINEAR;
|
|
|
|
}
|
2016-02-16 19:24:00 +00:00
|
|
|
|
|
|
|
return (uintptr_t)texture;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void vulkan_unload_texture(void *data, uintptr_t handle)
|
|
|
|
{
|
2016-02-29 16:06:41 +00:00
|
|
|
vk_t *vk = (vk_t*)data;
|
|
|
|
struct vk_texture *texture = (struct vk_texture*)handle;
|
2016-02-16 19:24:00 +00:00
|
|
|
if (!texture)
|
|
|
|
return;
|
|
|
|
|
|
|
|
/* TODO: We really want to defer this deletion instead,
|
|
|
|
* but this will do for now. */
|
2016-06-26 11:10:19 +00:00
|
|
|
vkQueueWaitIdle(vk->context->queue);
|
2016-02-29 18:03:18 +00:00
|
|
|
vulkan_destroy_texture(
|
|
|
|
vk->context->device, texture);
|
2016-02-16 19:24:00 +00:00
|
|
|
free(texture);
|
|
|
|
}
|
|
|
|
|
|
|
|
static const video_poke_interface_t vulkan_poke_interface = {
|
|
|
|
vulkan_load_texture,
|
|
|
|
vulkan_unload_texture,
|
|
|
|
vulkan_set_video_mode,
|
|
|
|
NULL,
|
|
|
|
NULL,
|
|
|
|
NULL,
|
|
|
|
NULL,
|
|
|
|
NULL,
|
|
|
|
NULL,
|
|
|
|
vulkan_set_aspect_ratio,
|
|
|
|
vulkan_apply_state_changes,
|
|
|
|
#if defined(HAVE_MENU)
|
|
|
|
vulkan_set_texture_frame,
|
|
|
|
vulkan_set_texture_enable,
|
|
|
|
#else
|
|
|
|
NULL,
|
|
|
|
NULL,
|
|
|
|
#endif
|
2016-05-11 08:06:15 +00:00
|
|
|
#ifdef HAVE_MENU
|
2016-02-16 19:24:00 +00:00
|
|
|
vulkan_set_osd_msg,
|
2016-05-11 08:06:15 +00:00
|
|
|
#endif
|
2016-02-16 19:24:00 +00:00
|
|
|
vulkan_show_mouse,
|
|
|
|
NULL,
|
|
|
|
vulkan_get_current_shader,
|
|
|
|
vulkan_get_current_sw_framebuffer,
|
|
|
|
vulkan_get_hw_render_interface,
|
|
|
|
};
|
|
|
|
|
|
|
|
static void vulkan_get_poke_interface(void *data,
|
|
|
|
const video_poke_interface_t **iface)
|
|
|
|
{
|
|
|
|
(void)data;
|
|
|
|
*iface = &vulkan_poke_interface;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void vulkan_viewport_info(void *data, struct video_viewport *vp)
|
|
|
|
{
|
|
|
|
unsigned width, height;
|
2016-02-20 19:15:46 +00:00
|
|
|
vk_t *vk = (vk_t*)data;
|
2016-02-16 19:24:00 +00:00
|
|
|
|
|
|
|
video_driver_get_size(&width, &height);
|
2016-02-20 13:04:33 +00:00
|
|
|
|
|
|
|
/* Make sure we get the correct viewport. */
|
|
|
|
vulkan_set_viewport(vk, width, height, false, true);
|
|
|
|
|
2016-02-20 19:15:46 +00:00
|
|
|
*vp = vk->vp;
|
|
|
|
vp->full_width = width;
|
2016-02-16 19:24:00 +00:00
|
|
|
vp->full_height = height;
|
|
|
|
}
|
|
|
|
|
2017-01-22 17:17:48 +00:00
|
|
|
static bool vulkan_read_viewport(void *data, uint8_t *buffer, bool is_idle)
|
2016-02-16 19:24:00 +00:00
|
|
|
{
|
2016-02-29 16:06:41 +00:00
|
|
|
struct vk_texture *staging = NULL;
|
|
|
|
vk_t *vk = (vk_t*)data;
|
2016-02-16 19:24:00 +00:00
|
|
|
|
|
|
|
if (!vk)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
staging = &vk->readback.staging[vk->context->current_swapchain_index];
|
|
|
|
|
|
|
|
if (vk->readback.streamed)
|
|
|
|
{
|
2017-04-16 09:03:29 +00:00
|
|
|
const uint8_t *src = NULL;
|
|
|
|
struct scaler_ctx *ctx = NULL;
|
2016-03-01 17:46:40 +00:00
|
|
|
|
2016-02-16 19:24:00 +00:00
|
|
|
if (staging->memory == VK_NULL_HANDLE)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
buffer += 3 * (vk->vp.height - 1) * vk->vp.width;
|
2016-06-26 11:10:19 +00:00
|
|
|
vkMapMemory(vk->context->device, staging->memory,
|
2016-02-16 19:24:00 +00:00
|
|
|
staging->offset, staging->size, 0, (void**)&src);
|
|
|
|
|
2016-07-15 16:10:22 +00:00
|
|
|
vulkan_sync_texture_to_cpu(vk, staging);
|
|
|
|
|
2016-02-20 19:15:46 +00:00
|
|
|
vk->readback.scaler.in_stride = staging->stride;
|
2016-02-16 19:24:00 +00:00
|
|
|
vk->readback.scaler.out_stride = -(int)vk->vp.width * 3;
|
2017-04-16 09:03:29 +00:00
|
|
|
|
|
|
|
ctx = &vk->readback.scaler;
|
|
|
|
|
|
|
|
scaler_ctx_scale_direct(ctx, buffer, src);
|
2016-02-16 19:24:00 +00:00
|
|
|
|
2016-06-26 11:10:19 +00:00
|
|
|
vkUnmapMemory(vk->context->device, staging->memory);
|
2016-02-16 19:24:00 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
/* Synchronous path only for now. */
|
|
|
|
/* TODO: How will we deal with format conversion?
|
|
|
|
* For now, take the simplest route and use image blitting
|
|
|
|
* with conversion. */
|
|
|
|
|
|
|
|
vk->readback.pending = true;
|
2017-01-22 17:17:48 +00:00
|
|
|
|
|
|
|
if (!is_idle)
|
2016-10-24 22:42:14 +00:00
|
|
|
video_driver_cached_frame();
|
|
|
|
|
2016-06-26 11:10:19 +00:00
|
|
|
vkQueueWaitIdle(vk->context->queue);
|
2016-02-16 19:24:00 +00:00
|
|
|
|
|
|
|
if (!staging->mapped)
|
2016-02-29 18:03:18 +00:00
|
|
|
vulkan_map_persistent_texture(
|
|
|
|
vk->context->device, staging);
|
2016-02-16 19:24:00 +00:00
|
|
|
|
2016-07-15 16:10:22 +00:00
|
|
|
vulkan_sync_texture_to_cpu(vk, staging);
|
|
|
|
|
2016-02-16 19:24:00 +00:00
|
|
|
{
|
|
|
|
unsigned x, y;
|
2016-02-20 19:29:52 +00:00
|
|
|
const uint8_t *src = (const uint8_t*)staging->mapped;
|
|
|
|
buffer += 3 * (vk->vp.height - 1)
|
|
|
|
* vk->vp.width;
|
2016-02-16 19:24:00 +00:00
|
|
|
|
|
|
|
for (y = 0; y < vk->vp.height; y++,
|
|
|
|
src += staging->stride, buffer -= 3 * vk->vp.width)
|
|
|
|
{
|
|
|
|
for (x = 0; x < vk->vp.width; x++)
|
|
|
|
{
|
|
|
|
buffer[3 * x + 0] = src[4 * x + 0];
|
|
|
|
buffer[3 * x + 1] = src[4 * x + 1];
|
|
|
|
buffer[3 * x + 2] = src[4 * x + 2];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2016-02-29 18:03:18 +00:00
|
|
|
vulkan_destroy_texture(
|
|
|
|
vk->context->device, staging);
|
2016-02-16 19:24:00 +00:00
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef HAVE_OVERLAY
|
|
|
|
static void vulkan_overlay_enable(void *data, bool enable)
|
|
|
|
{
|
|
|
|
vk_t *vk = (vk_t*)data;
|
|
|
|
if (!vk)
|
|
|
|
return;
|
|
|
|
|
|
|
|
vk->overlay.enable = enable;
|
|
|
|
if (vk->fullscreen)
|
2016-05-08 18:32:46 +00:00
|
|
|
video_context_driver_show_mouse(&enable);
|
2016-02-16 19:24:00 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void vulkan_overlay_full_screen(void *data, bool enable)
|
|
|
|
{
|
|
|
|
vk_t *vk = (vk_t*)data;
|
|
|
|
if (!vk)
|
|
|
|
return;
|
|
|
|
|
|
|
|
vk->overlay.full_screen = enable;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void vulkan_overlay_free(vk_t *vk)
|
|
|
|
{
|
|
|
|
unsigned i;
|
|
|
|
if (!vk)
|
|
|
|
return;
|
|
|
|
|
|
|
|
free(vk->overlay.vertex);
|
|
|
|
for (i = 0; i < vk->overlay.count; i++)
|
|
|
|
if (vk->overlay.images[i].memory != VK_NULL_HANDLE)
|
2016-02-29 18:03:18 +00:00
|
|
|
vulkan_destroy_texture(
|
|
|
|
vk->context->device,
|
2016-02-20 19:29:52 +00:00
|
|
|
&vk->overlay.images[i]);
|
2016-02-16 19:24:00 +00:00
|
|
|
|
|
|
|
memset(&vk->overlay, 0, sizeof(vk->overlay));
|
|
|
|
}
|
|
|
|
|
2016-02-20 19:29:52 +00:00
|
|
|
static void vulkan_overlay_set_alpha(void *data,
|
|
|
|
unsigned image, float mod)
|
2016-02-16 19:24:00 +00:00
|
|
|
{
|
|
|
|
unsigned i;
|
2016-02-20 19:29:52 +00:00
|
|
|
struct vk_vertex *pv;
|
|
|
|
vk_t *vk = (vk_t*)data;
|
2016-02-16 19:24:00 +00:00
|
|
|
|
|
|
|
if (!vk)
|
|
|
|
return;
|
|
|
|
|
|
|
|
pv = &vk->overlay.vertex[image * 4];
|
|
|
|
for (i = 0; i < 4; i++)
|
|
|
|
{
|
|
|
|
pv[i].color.r = 1.0f;
|
|
|
|
pv[i].color.g = 1.0f;
|
|
|
|
pv[i].color.b = 1.0f;
|
|
|
|
pv[i].color.a = mod;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-01-18 22:02:24 +00:00
|
|
|
static void vulkan_render_overlay(vk_t *vk, video_frame_info_t *video_info)
|
2016-02-16 19:24:00 +00:00
|
|
|
{
|
|
|
|
unsigned i;
|
|
|
|
struct video_viewport vp;
|
2017-01-18 22:02:24 +00:00
|
|
|
unsigned width = video_info->width;
|
|
|
|
unsigned height = video_info->height;
|
2016-02-16 19:24:00 +00:00
|
|
|
|
|
|
|
if (!vk)
|
|
|
|
return;
|
|
|
|
|
2017-01-18 22:02:24 +00:00
|
|
|
vp = vk->vp;
|
2016-02-16 19:24:00 +00:00
|
|
|
vulkan_set_viewport(vk, width, height, vk->overlay.full_screen, false);
|
|
|
|
|
|
|
|
for (i = 0; i < vk->overlay.count; i++)
|
|
|
|
{
|
|
|
|
struct vk_draw_triangles call;
|
|
|
|
struct vk_buffer_range range;
|
|
|
|
if (!vulkan_buffer_chain_alloc(vk->context, &vk->chain->vbo,
|
|
|
|
4 * sizeof(struct vk_vertex), &range))
|
|
|
|
break;
|
|
|
|
|
2016-02-20 19:15:46 +00:00
|
|
|
memcpy(range.data, &vk->overlay.vertex[i * 4],
|
|
|
|
4 * sizeof(struct vk_vertex));
|
2016-02-16 19:24:00 +00:00
|
|
|
|
|
|
|
memset(&call, 0, sizeof(call));
|
2016-05-08 09:11:28 +00:00
|
|
|
call.pipeline = vk->display.pipelines[3]; /* Strip with blend */
|
|
|
|
call.texture = &vk->overlay.images[i];
|
2016-07-31 11:47:10 +00:00
|
|
|
call.sampler = call.texture->mipmap ?
|
|
|
|
vk->samplers.mipmap_linear : vk->samplers.linear;
|
2016-05-08 09:11:28 +00:00
|
|
|
call.uniform = &vk->mvp;
|
|
|
|
call.uniform_size = sizeof(vk->mvp);
|
|
|
|
call.vbo = ⦥
|
|
|
|
call.vertices = 4;
|
2016-02-16 19:24:00 +00:00
|
|
|
vulkan_draw_triangles(vk, &call);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Restore the viewport so we don't mess with recording. */
|
|
|
|
vk->vp = vp;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void vulkan_overlay_vertex_geom(void *data, unsigned image,
|
|
|
|
float x, float y,
|
|
|
|
float w, float h)
|
|
|
|
{
|
2016-02-20 19:29:52 +00:00
|
|
|
struct vk_vertex *pv = NULL;
|
|
|
|
vk_t *vk = (vk_t*)data;
|
2016-02-16 19:24:00 +00:00
|
|
|
if (!vk)
|
|
|
|
return;
|
|
|
|
|
2016-02-20 19:29:52 +00:00
|
|
|
pv = &vk->overlay.vertex[4 * image];
|
|
|
|
|
2016-02-16 19:24:00 +00:00
|
|
|
pv[0].x = x;
|
|
|
|
pv[0].y = y;
|
|
|
|
pv[1].x = x;
|
|
|
|
pv[1].y = y + h;
|
|
|
|
pv[2].x = x + w;
|
|
|
|
pv[2].y = y;
|
|
|
|
pv[3].x = x + w;
|
|
|
|
pv[3].y = y + h;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void vulkan_overlay_tex_geom(void *data, unsigned image,
|
|
|
|
float x, float y,
|
|
|
|
float w, float h)
|
|
|
|
{
|
2016-02-20 19:29:52 +00:00
|
|
|
struct vk_vertex *pv = NULL;
|
|
|
|
vk_t *vk = (vk_t*)data;
|
2016-02-16 19:24:00 +00:00
|
|
|
if (!vk)
|
|
|
|
return;
|
|
|
|
|
2016-02-20 19:29:52 +00:00
|
|
|
pv = &vk->overlay.vertex[4 * image];
|
|
|
|
|
2016-02-16 19:24:00 +00:00
|
|
|
pv[0].tex_x = x;
|
|
|
|
pv[0].tex_y = y;
|
|
|
|
pv[1].tex_x = x;
|
|
|
|
pv[1].tex_y = y + h;
|
|
|
|
pv[2].tex_x = x + w;
|
|
|
|
pv[2].tex_y = y;
|
|
|
|
pv[3].tex_x = x + w;
|
|
|
|
pv[3].tex_y = y + h;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool vulkan_overlay_load(void *data,
|
|
|
|
const void *image_data, unsigned num_images)
|
|
|
|
{
|
|
|
|
unsigned i, j;
|
2016-02-20 19:29:52 +00:00
|
|
|
const struct texture_image *images =
|
|
|
|
(const struct texture_image*)image_data;
|
|
|
|
vk_t *vk = (vk_t*)data;
|
2016-02-16 19:24:00 +00:00
|
|
|
static const struct vk_color white = {
|
|
|
|
1.0f, 1.0f, 1.0f, 1.0f,
|
|
|
|
};
|
|
|
|
|
|
|
|
if (!vk)
|
|
|
|
return false;
|
|
|
|
|
2016-05-11 08:10:30 +00:00
|
|
|
#ifdef HAVE_THREADS
|
2016-02-16 19:24:00 +00:00
|
|
|
slock_lock(vk->context->queue_lock);
|
2016-05-11 08:10:30 +00:00
|
|
|
#endif
|
2016-06-26 11:10:19 +00:00
|
|
|
vkQueueWaitIdle(vk->context->queue);
|
2016-05-11 08:10:30 +00:00
|
|
|
#ifdef HAVE_THREADS
|
2016-02-16 19:24:00 +00:00
|
|
|
slock_unlock(vk->context->queue_lock);
|
2016-05-11 08:10:30 +00:00
|
|
|
#endif
|
2016-02-16 19:24:00 +00:00
|
|
|
vulkan_overlay_free(vk);
|
|
|
|
|
2016-02-20 19:29:52 +00:00
|
|
|
vk->overlay.images = (struct vk_texture*)
|
|
|
|
calloc(num_images, sizeof(*vk->overlay.images));
|
|
|
|
|
2016-02-16 19:24:00 +00:00
|
|
|
if (!vk->overlay.images)
|
|
|
|
goto error;
|
2016-02-20 19:15:46 +00:00
|
|
|
vk->overlay.count = num_images;
|
2016-02-16 19:24:00 +00:00
|
|
|
|
2016-02-20 19:29:52 +00:00
|
|
|
vk->overlay.vertex = (struct vk_vertex*)
|
|
|
|
calloc(4 * num_images, sizeof(*vk->overlay.vertex));
|
2016-02-16 19:24:00 +00:00
|
|
|
if (!vk->overlay.vertex)
|
|
|
|
goto error;
|
|
|
|
|
|
|
|
for (i = 0; i < num_images; i++)
|
|
|
|
{
|
|
|
|
vk->overlay.images[i] = vulkan_create_texture(vk, NULL,
|
|
|
|
images[i].width, images[i].height,
|
|
|
|
VK_FORMAT_B8G8R8A8_UNORM, images[i].pixels,
|
|
|
|
NULL, VULKAN_TEXTURE_STATIC);
|
|
|
|
|
|
|
|
vulkan_overlay_tex_geom(vk, i, 0, 0, 1, 1);
|
|
|
|
vulkan_overlay_vertex_geom(vk, i, 0, 0, 1, 1);
|
|
|
|
for (j = 0; j < 4; j++)
|
|
|
|
vk->overlay.vertex[4 * i + j].color = white;
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
|
|
|
|
error:
|
|
|
|
vulkan_overlay_free(vk);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
static const video_overlay_interface_t vulkan_overlay_interface = {
|
|
|
|
vulkan_overlay_enable,
|
|
|
|
vulkan_overlay_load,
|
|
|
|
vulkan_overlay_tex_geom,
|
|
|
|
vulkan_overlay_vertex_geom,
|
|
|
|
vulkan_overlay_full_screen,
|
|
|
|
vulkan_overlay_set_alpha,
|
|
|
|
};
|
|
|
|
|
|
|
|
static void vulkan_get_overlay_interface(void *data,
|
|
|
|
const video_overlay_interface_t **iface)
|
|
|
|
{
|
|
|
|
(void)data;
|
|
|
|
*iface = &vulkan_overlay_interface;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
video_driver_t video_vulkan = {
|
|
|
|
vulkan_init,
|
|
|
|
vulkan_frame,
|
|
|
|
vulkan_set_nonblock_state,
|
|
|
|
vulkan_alive,
|
2017-05-13 17:19:49 +00:00
|
|
|
NULL, /* focus */
|
2016-02-16 19:24:00 +00:00
|
|
|
vulkan_suppress_screensaver,
|
2017-05-13 17:19:49 +00:00
|
|
|
NULL, /* has_windowed */
|
2016-02-16 19:24:00 +00:00
|
|
|
vulkan_set_shader,
|
|
|
|
vulkan_free,
|
|
|
|
"vulkan",
|
|
|
|
vulkan_set_viewport,
|
|
|
|
vulkan_set_rotation,
|
|
|
|
vulkan_viewport_info,
|
|
|
|
vulkan_read_viewport,
|
2017-05-13 17:19:49 +00:00
|
|
|
NULL, /* vulkan_read_frame_raw */
|
2016-02-16 19:24:00 +00:00
|
|
|
|
|
|
|
#ifdef HAVE_OVERLAY
|
|
|
|
vulkan_get_overlay_interface,
|
|
|
|
#else
|
|
|
|
NULL,
|
|
|
|
#endif
|
|
|
|
vulkan_get_poke_interface,
|
2017-05-13 17:19:49 +00:00
|
|
|
NULL, /* vulkan_wrap_type_to_enum */
|
2016-02-16 19:24:00 +00:00
|
|
|
};
|
|
|
|
|