libretro/libretro-3dengine
1
0 Fork 0
mirror of https://github.com/libretro/libretro-3dengine.git synced 2026-11-07 11:06:04 -10:00
Code Issues Packages Projects Releases Wiki Activity
Files
b3aee0fe6e55ad5dc7916a6c3c372965424162e5
libretro-3dengine/engine/vk_renderer.cpp
T
Craig Carnell b3aee0fe6e Add vulkan renderer
2026-10-06 09:12:16 +01:00

1490 lines
55 KiB
C++
Raw Blame History

/*
* Libretro 3DEngine
* Copyright (C) 2013-2014 - Hans-Kristian Arntzen
* Copyright (C) 2013-2014 - Daniel De Matteis
*
* Libretro 3DEngine 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.
*
* Libretro 3DEngine 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 Libretro 3DEngine.
* If not, see <http://www.gnu.org/licenses/>.
*/
#ifdef HAVE_VULKAN
#include <vulkan/vulkan_symbol_wrapper.h>
#include <libretro_vulkan.h>
#include "vk_renderer.hpp"
#include "vk_shaders.inc"
#include "rpng.h"
#include "rtga.h"
#include "util.hpp"
#include "shared.hpp"
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <stddef.h>
#include <map>
#include <string>
#include <algorithm>
#define VKR_LOG(level, ...) do { if (log_cb) log_cb(level, __VA_ARGS__); } while (0)
#define VKR_MAX_SLOTS 16u
#define VKR_UNDEF32 ((uint32_t)-1)
namespace VKR
{
namespace
{
struct Buffer
{
Buffer() : buf(VK_NULL_HANDLE), mem(VK_NULL_HANDLE), map(NULL), size(0) {}
VkBuffer buf;
VkDeviceMemory mem;
uint8_t *map;
VkDeviceSize size;
};
struct Tex
{
Tex() : image(VK_NULL_HANDLE), mem(VK_NULL_HANDLE), view(VK_NULL_HANDLE) {}
VkImage image;
VkDeviceMemory mem;
VkImageView view;
};
struct MeshGPU
{
MeshGPU() : count(0), tex_set(VK_NULL_HANDLE), spec_power(60.0f), alpha(1.0f) {}
Buffer vbo;
uint32_t count;
VkDescriptorSet tex_set;
glm::vec3 ambient, diffuse, specular;
float spec_power;
float alpha;
};
/* std140: all vec4 so no padding surprises. Matches mesh.frag. */
struct DrawUBO
{
float light[4];
float light_ambient[4];
float eye[4];
float mtl_ambient[4];
float mtl_diffuse[4];
float mtl_specular[4];
float mtl_params[4]; /* x = specular power, y = alpha mod */
};
struct PushConstants
{
float model[16];
float mvp[16];
};
/* Color image that is handed to the frontend + its depth buffer. */
struct Target
{
Target() : color(VK_NULL_HANDLE), depth(VK_NULL_HANDLE),
color_mem(VK_NULL_HANDLE), depth_mem(VK_NULL_HANDLE),
color_view(VK_NULL_HANDLE), depth_view(VK_NULL_HANDLE),
fb(VK_NULL_HANDLE), w(0), h(0)
{ memset(&desc, 0, sizeof(desc)); }
VkImage color, depth;
VkDeviceMemory color_mem, depth_mem;
VkImageView color_view, depth_view;
VkFramebuffer fb;
unsigned w, h;
struct retro_vulkan_image desc; /* must outlive video_cb() */
};
/* One per frontend sync index. Everything the frontend may still be
* reading (the Target) is only touched again after wait_sync_index()
* for this index has returned. */
struct Slot
{
Slot() : pool(VK_NULL_HANDLE), cmd(VK_NULL_HANDLE), fence(VK_NULL_HANDLE),
ubo_set(VK_NULL_HANDLE) {}
Target target;
VkCommandPool pool;
VkCommandBuffer cmd;
VkFence fence;
Buffer ubo;
VkDescriptorSet ubo_set;
};
struct Globals
{
Globals() : iface(NULL), dev(VK_NULL_HANDLE), gpu(VK_NULL_HANDLE),
queue(VK_NULL_HANDLE), qfamily(0), inited(false),
depth_format(VK_FORMAT_UNDEFINED), render_pass(VK_NULL_HANDLE),
ubo_layout(VK_NULL_HANDLE), tex_layout(VK_NULL_HANDLE),
pipe_layout(VK_NULL_HANDLE), pipeline(VK_NULL_HANDLE),
sampler(VK_NULL_HANDLE), ubo_pool(VK_NULL_HANDLE),
tex_pool(VK_NULL_HANDLE), upload_pool(VK_NULL_HANDLE),
ubo_stride(0), last_mask(0), scene_ready(false) {}
const struct retro_hw_render_interface_vulkan *iface;
VkDevice dev;
VkPhysicalDevice gpu;
VkQueue queue;
uint32_t qfamily;
bool inited;
VkFormat depth_format;
VkRenderPass render_pass;
VkDescriptorSetLayout ubo_layout;
VkDescriptorSetLayout tex_layout;
VkPipelineLayout pipe_layout;
VkPipeline pipeline;
VkSampler sampler;
VkDescriptorPool ubo_pool;
VkDescriptorPool tex_pool;
VkCommandPool upload_pool;
VkDeviceSize ubo_stride;
uint32_t last_mask;
std::vector<Slot> slots;
Tex blank;
std::map<std::string, Tex> textures;
std::vector<MeshGPU> meshes;
bool scene_ready;
};
Globals g;
const VkFormat COLOR_FORMAT = VK_FORMAT_R8G8B8A8_UNORM;
/* ---- negotiation ---------------------------------------------- */
const VkApplicationInfo *get_application_info(void)
{
static VkApplicationInfo info;
memset(&info, 0, sizeof(info));
info.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
info.pApplicationName = "Libretro 3DEngine";
info.applicationVersion = 1;
info.pEngineName = "Libretro 3DEngine";
info.engineVersion = 1;
/* 1.1 as recommended in libretro_vulkan.h (old Android loaders). We
* only use 1.0 functionality. */
info.apiVersion = VK_API_VERSION_1_1;
return &info;
}
/* ---- small helpers -------------------------------------------- */
uint32_t find_memory_type(uint32_t type_bits, VkMemoryPropertyFlags props)
{
uint32_t i;
VkPhysicalDeviceMemoryProperties mp;
vkGetPhysicalDeviceMemoryProperties(g.gpu, &mp);
for (i = 0; i < mp.memoryTypeCount; i++)
if ((type_bits & (1u << i)) && (mp.memoryTypes[i].propertyFlags & props) == props)
return i;
return VKR_UNDEF32;
}
bool alloc_memory(const VkMemoryRequirements& req, VkMemoryPropertyFlags props,
VkDeviceMemory *mem)
{
VkMemoryAllocateInfo ai;
memset(&ai, 0, sizeof(ai));
ai.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
ai.allocationSize = req.size;
ai.memoryTypeIndex = find_memory_type(req.memoryTypeBits, props);
if (ai.memoryTypeIndex == VKR_UNDEF32)
return false;
return vkAllocateMemory(g.dev, &ai, NULL, mem) == VK_SUCCESS;
}
void destroy_buffer(Buffer& b)
{
if (b.map)
vkUnmapMemory(g.dev, b.mem);
if (b.buf)
vkDestroyBuffer(g.dev, b.buf, NULL);
if (b.mem)
vkFreeMemory(g.dev, b.mem, NULL);
b = Buffer();
}
/* Host visible + coherent. */
bool create_buffer(VkDeviceSize size, VkBufferUsageFlags usage, Buffer& out)
{
VkMemoryRequirements req;
VkBufferCreateInfo bi;
memset(&bi, 0, sizeof(bi));
bi.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
bi.size = size;
bi.usage = usage;
bi.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
out = Buffer();
out.size = size;
if (vkCreateBuffer(g.dev, &bi, NULL, &out.buf) != VK_SUCCESS)
return false;
vkGetBufferMemoryRequirements(g.dev, out.buf, &req);
if (!alloc_memory(req, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, &out.mem))
goto fail;
if (vkBindBufferMemory(g.dev, out.buf, out.mem, 0) != VK_SUCCESS)
goto fail;
{
void *p = NULL;
if (vkMapMemory(g.dev, out.mem, 0, VK_WHOLE_SIZE, 0, &p) != VK_SUCCESS)
goto fail;
out.map = (uint8_t*)p;
}
return true;
fail:
destroy_buffer(out);
return false;
}
bool create_image(unsigned w, unsigned h, unsigned mips, VkFormat format,
VkImageUsageFlags usage, VkImageCreateFlags flags,
VkImage *image, VkDeviceMemory *mem)
{
VkMemoryRequirements req;
VkImageCreateInfo ii;
memset(&ii, 0, sizeof(ii));
ii.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
ii.flags = flags;
ii.imageType = VK_IMAGE_TYPE_2D;
ii.format = format;
ii.extent.width = w;
ii.extent.height = h;
ii.extent.depth = 1;
ii.mipLevels = mips;
ii.arrayLayers = 1;
ii.samples = VK_SAMPLE_COUNT_1_BIT;
ii.tiling = VK_IMAGE_TILING_OPTIMAL;
ii.usage = usage;
ii.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
ii.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
*image = VK_NULL_HANDLE;
*mem = VK_NULL_HANDLE;
if (vkCreateImage(g.dev, &ii, NULL, image) != VK_SUCCESS)
return false;
vkGetImageMemoryRequirements(g.dev, *image, &req);
if (!alloc_memory(req, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, mem) ||
vkBindImageMemory(g.dev, *image, *mem, 0) != VK_SUCCESS)
{
if (*mem)
vkFreeMemory(g.dev, *mem, NULL);
vkDestroyImage(g.dev, *image, NULL);
*image = VK_NULL_HANDLE;
*mem = VK_NULL_HANDLE;
return false;
}
return true;
}
void fill_view_info(VkImageViewCreateInfo& vi, VkImage image, VkFormat format,
VkImageAspectFlags aspect, unsigned mips)
{
memset(&vi, 0, sizeof(vi));
vi.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
vi.image = image;
vi.viewType = VK_IMAGE_VIEW_TYPE_2D;
vi.format = format;
vi.components.r = VK_COMPONENT_SWIZZLE_R;
vi.components.g = VK_COMPONENT_SWIZZLE_G;
vi.components.b = VK_COMPONENT_SWIZZLE_B;
vi.components.a = VK_COMPONENT_SWIZZLE_A;
vi.subresourceRange.aspectMask = aspect;
vi.subresourceRange.baseMipLevel = 0;
vi.subresourceRange.levelCount = mips;
vi.subresourceRange.baseArrayLayer = 0;
vi.subresourceRange.layerCount = 1;
}
void image_barrier(VkCommandBuffer cmd, VkImage image, unsigned base_mip,
unsigned levels, VkImageLayout from, VkImageLayout to,
VkAccessFlags src_access, VkAccessFlags dst_access,
VkPipelineStageFlags src_stage, VkPipelineStageFlags dst_stage)
{
VkImageMemoryBarrier b;
memset(&b, 0, sizeof(b));
b.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
b.srcAccessMask = src_access;
b.dstAccessMask = dst_access;
b.oldLayout = from;
b.newLayout = to;
b.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
b.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
b.image = image;
b.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
b.subresourceRange.baseMipLevel = base_mip;
b.subresourceRange.levelCount = levels;
b.subresourceRange.baseArrayLayer = 0;
b.subresourceRange.layerCount = 1;
vkCmdPipelineBarrier(cmd, src_stage, dst_stage, 0, 0, NULL, 0, NULL, 1, &b);
}
/* ---- one-shot uploads (init / scene load only) ---------------- */
VkCommandBuffer begin_oneshot(void)
{
VkCommandBuffer cmd = VK_NULL_HANDLE;
VkCommandBufferAllocateInfo ai;
VkCommandBufferBeginInfo bi;
memset(&ai, 0, sizeof(ai));
ai.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
ai.commandPool = g.upload_pool;
ai.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
ai.commandBufferCount = 1;
if (vkAllocateCommandBuffers(g.dev, &ai, &cmd) != VK_SUCCESS)
return VK_NULL_HANDLE;
memset(&bi, 0, sizeof(bi));
bi.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
bi.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
vkBeginCommandBuffer(cmd, &bi);
return cmd;
}
bool end_oneshot(VkCommandBuffer cmd)
{
VkSubmitInfo si;
VkResult res;
vkEndCommandBuffer(cmd);
memset(&si, 0, sizeof(si));
si.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
si.commandBufferCount = 1;
si.pCommandBuffers = &cmd;
/* The frontend shares this queue; every submit must be locked. */
g.iface->lock_queue(g.iface->handle);
res = vkQueueSubmit(g.queue, 1, &si, VK_NULL_HANDLE);
if (res == VK_SUCCESS)
res = vkQueueWaitIdle(g.queue);
g.iface->unlock_queue(g.iface->handle);
vkFreeCommandBuffers(g.dev, g.upload_pool, 1, &cmd);
return res == VK_SUCCESS;
}
void destroy_texture(Tex& t)
{
if (t.view)
vkDestroyImageView(g.dev, t.view, NULL);
if (t.image)
vkDestroyImage(g.dev, t.image, NULL);
if (t.mem)
vkFreeMemory(g.dev, t.mem, NULL);
t = Tex();
}
/* RGBA8 -> sampled, mip-mapped texture. Mirrors GL::Texture::upload_data
* (linear + mipmaps, repeat). The loaders hand us bottom-left-origin
* rows. */
bool create_texture(const uint8_t *rgba, unsigned w, unsigned h, Tex& t)
{
unsigned i, mips = 1;
Buffer staging;
VkCommandBuffer cmd;
VkBufferImageCopy copy;
VkFormatProperties fp;
VkImageViewCreateInfo vi;
int32_t mw = (int32_t)w, mh = (int32_t)h;
const VkDeviceSize size = (VkDeviceSize)w * h * 4;
vkGetPhysicalDeviceFormatProperties(g.gpu, VK_FORMAT_R8G8B8A8_UNORM, &fp);
if (fp.optimalTilingFeatures & VK_FORMAT_FEATURE_BLIT_SRC_BIT &&
fp.optimalTilingFeatures & VK_FORMAT_FEATURE_BLIT_DST_BIT &&
fp.optimalTilingFeatures & VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT)
{
unsigned m = std::max(w, h);
mips = 1;
while (m > 1) { m >>= 1; mips++; }
}
t = Tex();
if (!create_buffer(size, VK_BUFFER_USAGE_TRANSFER_SRC_BIT, staging))
return false;
memcpy(staging.map, rgba, (size_t)size);
if (!create_image(w, h, mips, VK_FORMAT_R8G8B8A8_UNORM,
VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT |
VK_IMAGE_USAGE_SAMPLED_BIT, 0, &t.image, &t.mem))
{
destroy_buffer(staging);
return false;
}
cmd = begin_oneshot();
if (!cmd)
{
destroy_buffer(staging);
destroy_texture(t);
return false;
}
image_barrier(cmd, t.image, 0, mips, 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);
memset(&copy, 0, sizeof(copy));
copy.imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
copy.imageSubresource.layerCount = 1;
copy.imageExtent.width = w;
copy.imageExtent.height = h;
copy.imageExtent.depth = 1;
vkCmdCopyBufferToImage(cmd, staging.buf, t.image,
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &copy);
for (i = 1; i < mips; i++)
{
VkImageBlit blit;
int32_t nw = mw > 1 ? mw / 2 : 1;
int32_t nh = mh > 1 ? mh / 2 : 1;
image_barrier(cmd, t.image, i - 1, 1,
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_TRANSFER_READ_BIT,
VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT);
memset(&blit, 0, sizeof(blit));
blit.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
blit.srcSubresource.mipLevel = i - 1;
blit.srcSubresource.layerCount = 1;
blit.srcOffsets[1].x = mw;
blit.srcOffsets[1].y = mh;
blit.srcOffsets[1].z = 1;
blit.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
blit.dstSubresource.mipLevel = i;
blit.dstSubresource.layerCount = 1;
blit.dstOffsets[1].x = nw;
blit.dstOffsets[1].y = nh;
blit.dstOffsets[1].z = 1;
vkCmdBlitImage(cmd, t.image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
t.image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &blit, VK_FILTER_LINEAR);
image_barrier(cmd, t.image, i - 1, 1,
VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
VK_ACCESS_TRANSFER_READ_BIT, VK_ACCESS_SHADER_READ_BIT,
VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT);
mw = nw;
mh = nh;
}
image_barrier(cmd, t.image, mips - 1, 1,
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_SHADER_READ_BIT,
VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT);
if (!end_oneshot(cmd))
{
destroy_buffer(staging);
destroy_texture(t);
return false;
}
destroy_buffer(staging);
fill_view_info(vi, t.image, VK_FORMAT_R8G8B8A8_UNORM, VK_IMAGE_ASPECT_COLOR_BIT, mips);
if (vkCreateImageView(g.dev, &vi, NULL, &t.view) != VK_SUCCESS)
{
destroy_texture(t);
return false;
}
return true;
}
/* Returns NULL on failure; the caller then falls back to the blank texture. */
const Tex *get_texture(const std::string& path)
{
unsigned w = 0, h = 0;
uint8_t *data = NULL;
bool ok = false;
Tex t;
std::string ext;
std::map<std::string, Tex>::iterator it;
if (!path.size())
return NULL;
it = g.textures.find(path);
if (it != g.textures.end())
return it->second.view ? &it->second : NULL;
ext = Path::ext(path);
if (ext == "png")
ok = rpng_load_image_rgba(path.c_str(), &data, &w, &h);
else if (ext == "tga")
ok = texture_image_load_tga(path.c_str(), data, w, h);
else
VKR_LOG(RETRO_LOG_ERROR, "[Vulkan] Unsupported texture extension: \"%s\"\n", ext.c_str());
if (ok && data && create_texture(data, w, h, t))
{
free(data);
return &(g.textures[path] = t);
}
if (ok)
free(data);
VKR_LOG(RETRO_LOG_ERROR, "[Vulkan] Failed to load texture: %s\n", path.c_str());
g.textures[path] = Tex();
return NULL;
}
/* ---- render targets / per-sync-index slots -------------------- */
void destroy_target(Target& t)
{
if (t.fb)
vkDestroyFramebuffer(g.dev, t.fb, NULL);
if (t.color_view)
vkDestroyImageView(g.dev, t.color_view, NULL);
if (t.depth_view)
vkDestroyImageView(g.dev, t.depth_view, NULL);
if (t.color)
vkDestroyImage(g.dev, t.color, NULL);
if (t.depth)
vkDestroyImage(g.dev, t.depth, NULL);
if (t.color_mem)
vkFreeMemory(g.dev, t.color_mem, NULL);
if (t.depth_mem)
vkFreeMemory(g.dev, t.depth_mem, NULL);
t = Target();
}
bool create_target(Target& t, unsigned w, unsigned h)
{
VkImageViewCreateInfo vi;
VkFramebufferCreateInfo fi;
VkImageView atts[2];
t = Target();
/* MUTABLE_FORMAT: the frontend may reinterpret the 8-bit image as
* sRGB. */
if (!create_image(w, h, 1, COLOR_FORMAT,
VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT |
VK_IMAGE_USAGE_TRANSFER_SRC_BIT,
VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT, &t.color, &t.color_mem))
goto fail;
if (!create_image(w, h, 1, g.depth_format,
VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, 0, &t.depth, &t.depth_mem))
goto fail;
fill_view_info(vi, t.color, COLOR_FORMAT, VK_IMAGE_ASPECT_COLOR_BIT, 1);
if (vkCreateImageView(g.dev, &vi, NULL, &t.color_view) != VK_SUCCESS)
goto fail;
{
VkImageAspectFlags da = VK_IMAGE_ASPECT_DEPTH_BIT;
if (g.depth_format == VK_FORMAT_D24_UNORM_S8_UINT)
da |= VK_IMAGE_ASPECT_STENCIL_BIT;
fill_view_info(vi, t.depth, g.depth_format, da, 1);
}
if (vkCreateImageView(g.dev, &vi, NULL, &t.depth_view) != VK_SUCCESS)
goto fail;
atts[0] = t.color_view;
atts[1] = t.depth_view;
memset(&fi, 0, sizeof(fi));
fi.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
fi.renderPass = g.render_pass;
fi.attachmentCount = 2;
fi.pAttachments = atts;
fi.width = w;
fi.height = h;
fi.layers = 1;
if (vkCreateFramebuffer(g.dev, &fi, NULL, &t.fb) != VK_SUCCESS)
goto fail;
t.w = w;
t.h = h;
/* What we give the frontend. The render pass leaves the image in
* SHADER_READ_ONLY_OPTIMAL, and the view carries the create info so
* the frontend can re-view it (e.g. as sRGB). */
t.desc.image_view = t.color_view;
t.desc.image_layout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
t.desc.create_info = vi;
fill_view_info(t.desc.create_info, t.color, COLOR_FORMAT, VK_IMAGE_ASPECT_COLOR_BIT, 1);
return true;
fail:
destroy_target(t);
return false;
}
void destroy_slot(Slot& s)
{
destroy_target(s.target);
destroy_buffer(s.ubo);
if (s.fence)
vkDestroyFence(g.dev, s.fence, NULL);
if (s.pool)
vkDestroyCommandPool(g.dev, s.pool, NULL); /* frees s.cmd */
s = Slot();
}
/* Waits only for *our* submissions. */
void wait_own_work(void)
{
size_t i;
for (i = 0; i < g.slots.size(); i++)
if (g.slots[i].fence)
vkWaitForFences(g.dev, 1, &g.slots[i].fence, VK_TRUE, (uint64_t)-1);
}
void destroy_slots(void)
{
size_t i;
wait_own_work();
for (i = 0; i < g.slots.size(); i++)
destroy_slot(g.slots[i]);
g.slots.clear();
if (g.ubo_pool)
vkResetDescriptorPool(g.dev, g.ubo_pool, 0);
}
bool create_slots(uint32_t mask)
{
unsigned i, n = 0;
while ((mask >> n) != 0 && n < 32)
n++;
if (!n || n > VKR_MAX_SLOTS)
{
VKR_LOG(RETRO_LOG_ERROR, "[Vulkan] Unsupported sync index mask 0x%x\n", mask);
return false;
}
g.slots.resize(n);
for (i = 0; i < n; i++)
{
Slot& s = g.slots[i];
VkCommandPoolCreateInfo pi;
VkCommandBufferAllocateInfo ai;
VkFenceCreateInfo fi;
VkDescriptorSetAllocateInfo di;
memset(&pi, 0, sizeof(pi));
pi.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
pi.flags = VK_COMMAND_POOL_CREATE_TRANSIENT_BIT;
pi.queueFamilyIndex = g.qfamily;
if (vkCreateCommandPool(g.dev, &pi, NULL, &s.pool) != VK_SUCCESS)
return false;
memset(&ai, 0, sizeof(ai));
ai.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
ai.commandPool = s.pool;
ai.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
ai.commandBufferCount = 1;
if (vkAllocateCommandBuffers(g.dev, &ai, &s.cmd) != VK_SUCCESS)
return false;
memset(&fi, 0, sizeof(fi));
fi.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
fi.flags = VK_FENCE_CREATE_SIGNALED_BIT;
if (vkCreateFence(g.dev, &fi, NULL, &s.fence) != VK_SUCCESS)
return false;
memset(&di, 0, sizeof(di));
di.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO;
di.descriptorPool = g.ubo_pool;
di.descriptorSetCount = 1;
di.pSetLayouts = &g.ubo_layout;
if (vkAllocateDescriptorSets(g.dev, &di, &s.ubo_set) != VK_SUCCESS)
return false;
}
g.last_mask = mask;
return true;
}
/* Needs: GPU done with s.ubo (we waited s.fence). */
bool ensure_ubo(Slot& s, VkDeviceSize needed)
{
VkDescriptorBufferInfo bi;
VkWriteDescriptorSet w;
if (s.ubo.buf && s.ubo.size >= needed)
return true;
destroy_buffer(s.ubo);
if (!create_buffer(needed, VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, s.ubo))
return false;
memset(&bi, 0, sizeof(bi));
bi.buffer = s.ubo.buf;
bi.offset = 0;
bi.range = sizeof(DrawUBO);
memset(&w, 0, sizeof(w));
w.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
w.dstSet = s.ubo_set;
w.dstBinding = 0;
w.descriptorCount = 1;
w.descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC;
w.pBufferInfo = &bi;
vkUpdateDescriptorSets(g.dev, 1, &w, 0, NULL);
return true;
}
/* ---- pipeline ------------------------------------------------- */
VkShaderModule make_module(const uint32_t *code, size_t bytes)
{
VkShaderModule m = VK_NULL_HANDLE;
VkShaderModuleCreateInfo mi;
memset(&mi, 0, sizeof(mi));
mi.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
mi.codeSize = bytes;
mi.pCode = code;
if (vkCreateShaderModule(g.dev, &mi, NULL, &m) != VK_SUCCESS)
return VK_NULL_HANDLE;
return m;
}
bool create_pipeline(ShaderMode mode)
{
VkShaderModule vs, fs;
VkPipelineShaderStageCreateInfo stages[2];
VkSpecializationMapEntry spec_entry;
VkSpecializationInfo spec;
int32_t spec_value = (int32_t)mode;
VkVertexInputBindingDescription bind;
VkVertexInputAttributeDescription attrs[3];
VkPipelineVertexInputStateCreateInfo vin;
VkPipelineInputAssemblyStateCreateInfo ia;
VkPipelineViewportStateCreateInfo vp;
VkPipelineRasterizationStateCreateInfo rs;
VkPipelineMultisampleStateCreateInfo ms;
VkPipelineDepthStencilStateCreateInfo ds;
VkPipelineColorBlendAttachmentState cba;
VkPipelineColorBlendStateCreateInfo cb;
VkDynamicState dyn_states[2] = { VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR };
VkPipelineDynamicStateCreateInfo dyn;
VkGraphicsPipelineCreateInfo pi;
VkResult res;
vs = make_module(vk_mesh_vert_spv, sizeof(vk_mesh_vert_spv));
fs = make_module(vk_mesh_frag_spv, sizeof(vk_mesh_frag_spv));
if (!vs || !fs)
{
if (vs) vkDestroyShaderModule(g.dev, vs, NULL);
if (fs) vkDestroyShaderModule(g.dev, fs, NULL);
return false;
}
spec_entry.constantID = 0;
spec_entry.offset = 0;
spec_entry.size = sizeof(spec_value);
spec.mapEntryCount = 1;
spec.pMapEntries = &spec_entry;
spec.dataSize = sizeof(spec_value);
spec.pData = &spec_value;
memset(stages, 0, sizeof(stages));
stages[0].sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
stages[0].stage = VK_SHADER_STAGE_VERTEX_BIT;
stages[0].module = vs;
stages[0].pName = "main";
stages[1].sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
stages[1].stage = VK_SHADER_STAGE_FRAGMENT_BIT;
stages[1].module = fs;
stages[1].pName = "main";
stages[1].pSpecializationInfo = &spec;
bind.binding = 0;
bind.stride = sizeof(GL::Vertex);
bind.inputRate = VK_VERTEX_INPUT_RATE_VERTEX;
attrs[0].location = 0; attrs[0].binding = 0;
attrs[0].format = VK_FORMAT_R32G32B32_SFLOAT; attrs[0].offset = offsetof(GL::Vertex, vert);
attrs[1].location = 1; attrs[1].binding = 0;
attrs[1].format = VK_FORMAT_R32G32B32_SFLOAT; attrs[1].offset = offsetof(GL::Vertex, normal);
attrs[2].location = 2; attrs[2].binding = 0;
attrs[2].format = VK_FORMAT_R32G32_SFLOAT; attrs[2].offset = offsetof(GL::Vertex, tex);
memset(&vin, 0, sizeof(vin));
vin.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO;
vin.vertexBindingDescriptionCount = 1;
vin.pVertexBindingDescriptions = &bind;
vin.vertexAttributeDescriptionCount = 3;
vin.pVertexAttributeDescriptions = attrs;
memset(&ia, 0, sizeof(ia));
ia.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO;
ia.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
memset(&vp, 0, sizeof(vp));
vp.sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO;
vp.viewportCount = 1;
vp.scissorCount = 1;
/* The clip-space fix (Y flip) makes front faces counter-clockwise in
* Vulkan's framebuffer space, */
memset(&rs, 0, sizeof(rs));
rs.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO;
rs.polygonMode = VK_POLYGON_MODE_FILL;
rs.cullMode = VK_CULL_MODE_BACK_BIT;
rs.frontFace = VK_FRONT_FACE_COUNTER_CLOCKWISE;
rs.lineWidth = 1.0f;
memset(&ms, 0, sizeof(ms));
ms.sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO;
ms.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT;
memset(&ds, 0, sizeof(ds));
ds.sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO;
ds.depthTestEnable = VK_TRUE;
ds.depthWriteEnable = VK_TRUE;
ds.depthCompareOp = VK_COMPARE_OP_LESS;
memset(&cba, 0, sizeof(cba));
cba.colorWriteMask = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT |
VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT;
memset(&cb, 0, sizeof(cb));
cb.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;
cb.attachmentCount = 1;
cb.pAttachments = &cba;
memset(&dyn, 0, sizeof(dyn));
dyn.sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO;
dyn.dynamicStateCount = 2;
dyn.pDynamicStates = dyn_states;
memset(&pi, 0, sizeof(pi));
pi.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
pi.stageCount = 2;
pi.pStages = stages;
pi.pVertexInputState = &vin;
pi.pInputAssemblyState = &ia;
pi.pViewportState = &vp;
pi.pRasterizationState = &rs;
pi.pMultisampleState = &ms;
pi.pDepthStencilState = &ds;
pi.pColorBlendState = &cb;
pi.pDynamicState = &dyn;
pi.layout = g.pipe_layout;
pi.renderPass = g.render_pass;
pi.subpass = 0;
res = vkCreateGraphicsPipelines(g.dev, VK_NULL_HANDLE, 1, &pi, NULL, &g.pipeline);
vkDestroyShaderModule(g.dev, vs, NULL);
vkDestroyShaderModule(g.dev, fs, NULL);
if (res != VK_SUCCESS)
{
g.pipeline = VK_NULL_HANDLE;
return false;
}
return true;
}
bool pick_depth_format(void)
{
static const VkFormat candidates[] = {
VK_FORMAT_D32_SFLOAT, VK_FORMAT_D24_UNORM_S8_UINT, VK_FORMAT_D16_UNORM
};
unsigned i;
for (i = 0; i < sizeof(candidates) / sizeof(candidates[0]); i++)
{
VkFormatProperties fp;
vkGetPhysicalDeviceFormatProperties(g.gpu, candidates[i], &fp);
if (fp.optimalTilingFeatures & VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT)
{
g.depth_format = candidates[i];
return true;
}
}
return false;
}
bool create_render_pass(void)
{
VkAttachmentDescription att[2];
VkAttachmentReference cref, dref;
VkSubpassDescription sub;
VkSubpassDependency deps[2];
VkRenderPassCreateInfo ri;
memset(att, 0, sizeof(att));
att[0].format = COLOR_FORMAT;
att[0].samples = VK_SAMPLE_COUNT_1_BIT;
att[0].loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
att[0].storeOp = VK_ATTACHMENT_STORE_OP_STORE;
att[0].stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
att[0].stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
att[0].initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; /* we clear; frontend may have moved it */
att[0].finalLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
att[1].format = g.depth_format;
att[1].samples = VK_SAMPLE_COUNT_1_BIT;
att[1].loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
att[1].storeOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
att[1].stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
att[1].stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
att[1].initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
att[1].finalLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
cref.attachment = 0; cref.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
dref.attachment = 1; dref.layout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
memset(&sub, 0, sizeof(sub));
sub.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;
sub.colorAttachmentCount = 1;
sub.pColorAttachments = &cref;
sub.pDepthStencilAttachment = &dref;
/* In: do not write the image until earlier users (the frontend's
* reads of the previous frame of this sync index) are done. */
memset(deps, 0, sizeof(deps));
deps[0].srcSubpass = VK_SUBPASS_EXTERNAL;
deps[0].dstSubpass = 0;
deps[0].srcStageMask = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT |
VK_PIPELINE_STAGE_TRANSFER_BIT | VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
deps[0].dstStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT |
VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT;
deps[0].srcAccessMask = VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_TRANSFER_READ_BIT;
deps[0].dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT |
VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
/* Out: this is the barrier the frontend relies on when we pass no
* semaphores to set_image(). */
deps[1].srcSubpass = 0;
deps[1].dstSubpass = VK_SUBPASS_EXTERNAL;
deps[1].srcStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
deps[1].dstStageMask = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT |
VK_PIPELINE_STAGE_TRANSFER_BIT;
deps[1].srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
deps[1].dstAccessMask = VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_TRANSFER_READ_BIT;
memset(&ri, 0, sizeof(ri));
ri.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
ri.attachmentCount = 2;
ri.pAttachments = att;
ri.subpassCount = 1;
ri.pSubpasses = &sub;
ri.dependencyCount = 2;
ri.pDependencies = deps;
return vkCreateRenderPass(g.dev, &ri, NULL, &g.render_pass) == VK_SUCCESS;
}
bool create_static_objects(void)
{
VkPhysicalDeviceProperties props;
VkDescriptorSetLayoutBinding b[2];
VkDescriptorSetLayoutCreateInfo li;
VkPushConstantRange pcr;
VkPipelineLayoutCreateInfo pli;
VkSamplerCreateInfo si;
VkDescriptorPoolSize ps;
VkDescriptorPoolCreateInfo dpi;
VkCommandPoolCreateInfo cpi;
VkDescriptorSetLayout layouts[2];
static const uint8_t white[4] = { 255, 255, 255, 255 };
vkGetPhysicalDeviceProperties(g.gpu, &props);
g.ubo_stride = props.limits.minUniformBufferOffsetAlignment;
if (g.ubo_stride < sizeof(DrawUBO))
{
VkDeviceSize a = g.ubo_stride ? g.ubo_stride : 1;
g.ubo_stride = ((sizeof(DrawUBO) + a - 1) / a) * a;
}
if (!pick_depth_format() || !create_render_pass())
return false;
/* set 0: per-draw dynamic UBO (fragment). */
memset(b, 0, sizeof(b));
b[0].binding = 0;
b[0].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC;
b[0].descriptorCount = 1;
b[0].stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT;
memset(&li, 0, sizeof(li));
li.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
li.bindingCount = 1;
li.pBindings = b;
if (vkCreateDescriptorSetLayout(g.dev, &li, NULL, &g.ubo_layout) != VK_SUCCESS)
return false;
/* set 1: diffuse + ambient maps. */
memset(b, 0, sizeof(b));
b[0].binding = 0;
b[0].descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
b[0].descriptorCount = 1;
b[0].stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT;
b[1] = b[0];
b[1].binding = 1;
li.bindingCount = 2;
if (vkCreateDescriptorSetLayout(g.dev, &li, NULL, &g.tex_layout) != VK_SUCCESS)
return false;
pcr.stageFlags = VK_SHADER_STAGE_VERTEX_BIT;
pcr.offset = 0;
pcr.size = sizeof(PushConstants); /* 128 B = guaranteed minimum */
layouts[0] = g.ubo_layout;
layouts[1] = g.tex_layout;
memset(&pli, 0, sizeof(pli));
pli.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
pli.setLayoutCount = 2;
pli.pSetLayouts = layouts;
pli.pushConstantRangeCount = 1;
pli.pPushConstantRanges = &pcr;
if (vkCreatePipelineLayout(g.dev, &pli, NULL, &g.pipe_layout) != VK_SUCCESS)
return false;
memset(&si, 0, sizeof(si));
si.sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO;
si.magFilter = VK_FILTER_LINEAR;
si.minFilter = VK_FILTER_LINEAR;
si.mipmapMode = VK_SAMPLER_MIPMAP_MODE_LINEAR;
si.addressModeU = VK_SAMPLER_ADDRESS_MODE_REPEAT;
si.addressModeV = VK_SAMPLER_ADDRESS_MODE_REPEAT;
si.addressModeW = VK_SAMPLER_ADDRESS_MODE_REPEAT;
si.maxLod = VK_LOD_CLAMP_NONE;
if (vkCreateSampler(g.dev, &si, NULL, &g.sampler) != VK_SUCCESS)
return false;
ps.type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC;
ps.descriptorCount = VKR_MAX_SLOTS;
memset(&dpi, 0, sizeof(dpi));
dpi.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
dpi.maxSets = VKR_MAX_SLOTS;
dpi.poolSizeCount = 1;
dpi.pPoolSizes = &ps;
if (vkCreateDescriptorPool(g.dev, &dpi, NULL, &g.ubo_pool) != VK_SUCCESS)
return false;
memset(&cpi, 0, sizeof(cpi));
cpi.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
cpi.flags = VK_COMMAND_POOL_CREATE_TRANSIENT_BIT |
VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT;
cpi.queueFamilyIndex = g.qfamily;
if (vkCreateCommandPool(g.dev, &cpi, NULL, &g.upload_pool) != VK_SUCCESS)
return false;
return create_texture(white, 1, 1, g.blank);
}
void write_mesh_descriptors(MeshGPU& m, const Tex *diffuse, const Tex *ambient)
{
VkDescriptorImageInfo ii[2];
VkWriteDescriptorSet w[2];
unsigned i;
if (!diffuse) diffuse = &g.blank;
if (!ambient) ambient = diffuse; /* GL path: ambient falls back to diffuse, then blank */
memset(ii, 0, sizeof(ii));
ii[0].sampler = g.sampler;
ii[0].imageView = diffuse->view;
ii[0].imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
ii[1] = ii[0];
ii[1].imageView = ambient->view;
memset(w, 0, sizeof(w));
for (i = 0; i < 2; i++)
{
w[i].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
w[i].dstSet = m.tex_set;
w[i].dstBinding = i;
w[i].descriptorCount = 1;
w[i].descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
w[i].pImageInfo = &ii[i];
}
vkUpdateDescriptorSets(g.dev, 2, w, 0, NULL);
}
void copy_vec4(float *dst, const glm::vec3& v, float w)
{
dst[0] = v.x; dst[1] = v.y; dst[2] = v.z; dst[3] = w;
}
void destroy_everything_but_state(void)
{
if (g.dev == VK_NULL_HANDLE)
return;
unload_scene();
destroy_slots();
destroy_texture(g.blank);
if (g.upload_pool) vkDestroyCommandPool(g.dev, g.upload_pool, NULL);
if (g.ubo_pool) vkDestroyDescriptorPool(g.dev, g.ubo_pool, NULL);
if (g.sampler) vkDestroySampler(g.dev, g.sampler, NULL);
if (g.pipe_layout) vkDestroyPipelineLayout(g.dev, g.pipe_layout, NULL);
if (g.tex_layout) vkDestroyDescriptorSetLayout(g.dev, g.tex_layout, NULL);
if (g.ubo_layout) vkDestroyDescriptorSetLayout(g.dev, g.ubo_layout, NULL);
if (g.render_pass) vkDestroyRenderPass(g.dev, g.render_pass, NULL);
}
} /* anonymous namespace */
/* ====================== public API ================================ */
bool set_negotiation_interface(retro_environment_t env)
{
static struct retro_hw_render_context_negotiation_interface_vulkan neg;
struct retro_hw_render_context_negotiation_interface query;
unsigned version = 1; /* frontends without the SUPPORT query only know v1 */
memset(&query, 0, sizeof(query));
query.interface_type = RETRO_HW_RENDER_CONTEXT_NEGOTIATION_INTERFACE_VULKAN;
if (env(RETRO_ENVIRONMENT_GET_HW_RENDER_CONTEXT_NEGOTIATION_INTERFACE_SUPPORT, &query))
{
if (query.interface_version == 0)
return false; /* frontend has no Vulkan negotiation at all */
version = query.interface_version < 2 ? query.interface_version : 2;
}
/* We only provide application info. Device/instance creation is left
* to the frontend on purpose: an OpenXR frontend has to create them
* through xrCreateVulkan{Instance,Device}KHR so the runtime can add
* its required extensions and pick the physical device. */
memset(&neg, 0, sizeof(neg));
neg.interface_type = RETRO_HW_RENDER_CONTEXT_NEGOTIATION_INTERFACE_VULKAN;
neg.interface_version = version;
neg.get_application_info = get_application_info;
neg.create_device = NULL;
neg.destroy_device = NULL;
neg.create_instance = NULL;
neg.create_device2 = NULL;
return env(RETRO_ENVIRONMENT_SET_HW_RENDER_CONTEXT_NEGOTIATION_INTERFACE, &neg);
}
bool init(retro_environment_t env)
{
const struct retro_hw_render_interface_vulkan *iface = NULL;
if (g.inited)
{
/* context_reset without context_destroy: the device was lost/replaced. */
VKR_LOG(RETRO_LOG_WARN, "[Vulkan] Context reset without destroy, dropping old state.\n");
g = Globals();
}
if (!env(RETRO_ENVIRONMENT_GET_HW_RENDER_INTERFACE, (void*)&iface) || !iface)
{
VKR_LOG(RETRO_LOG_ERROR, "[Vulkan] Frontend gave no HW render interface.\n");
return false;
}
if (iface->interface_type != RETRO_HW_RENDER_INTERFACE_VULKAN ||
iface->interface_version < RETRO_HW_RENDER_INTERFACE_VULKAN_VERSION)
{
VKR_LOG(RETRO_LOG_ERROR, "[Vulkan] Need HW render interface version %d, frontend has %u.\n",
RETRO_HW_RENDER_INTERFACE_VULKAN_VERSION, iface->interface_version);
return false;
}
vulkan_symbol_wrapper_init(iface->get_instance_proc_addr);
if (!vulkan_symbol_wrapper_load_core_instance_symbols(iface->instance) ||
!vulkan_symbol_wrapper_load_core_device_symbols(iface->device))
{
VKR_LOG(RETRO_LOG_ERROR, "[Vulkan] Failed to load Vulkan entry points.\n");
return false;
}
g.iface = iface;
g.dev = iface->device;
g.gpu = iface->gpu;
g.queue = iface->queue;
g.qfamily = iface->queue_index; /* despite the name this is the queue *family* */
if (!create_static_objects())
{
VKR_LOG(RETRO_LOG_ERROR, "[Vulkan] Failed to create renderer objects.\n");
destroy_everything_but_state();
g = Globals();
return false;
}
g.inited = true;
return true;
}
bool initialized(void)
{
return g.inited;
}
void destroy(void)
{
if (!g.inited)
return;
destroy_everything_but_state();
g = Globals();
}
void unload_scene(void)
{
size_t i;
std::map<std::string, Tex>::iterator it;
if (g.dev == VK_NULL_HANDLE)
return;
wait_own_work(); /* in-flight frames may still read these */
for (i = 0; i < g.meshes.size(); i++)
destroy_buffer(g.meshes[i].vbo);
g.meshes.clear();
for (it = g.textures.begin(); it != g.textures.end(); ++it)
destroy_texture(it->second);
g.textures.clear();
if (g.tex_pool)
vkDestroyDescriptorPool(g.dev, g.tex_pool, NULL);
g.tex_pool = VK_NULL_HANDLE;
if (g.pipeline)
vkDestroyPipeline(g.dev, g.pipeline, NULL);
g.pipeline = VK_NULL_HANDLE;
g.scene_ready = false;
}
bool load_scene(const std::vector<OBJ::Part>& parts, ShaderMode mode)
{
size_t i;
VkDescriptorPoolSize ps;
VkDescriptorPoolCreateInfo dpi;
if (!g.inited)
return false;
unload_scene();
if (!create_pipeline(mode))
{
VKR_LOG(RETRO_LOG_ERROR, "[Vulkan] Pipeline creation failed.\n");
return false;
}
ps.type = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
ps.descriptorCount = (uint32_t)(parts.size() * 2 + 2);
memset(&dpi, 0, sizeof(dpi));
dpi.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
dpi.maxSets = (uint32_t)parts.size() + 1;
dpi.poolSizeCount = 1;
dpi.pPoolSizes = &ps;
if (vkCreateDescriptorPool(g.dev, &dpi, NULL, &g.tex_pool) != VK_SUCCESS)
return false;
g.meshes.resize(parts.size());
for (i = 0; i < parts.size(); i++)
{
const OBJ::Part& p = parts[i];
MeshGPU& m = g.meshes[i];
VkDescriptorSetAllocateInfo ai;
const Tex *diffuse, *ambient;
m.count = (uint32_t)p.vertices.size();
m.ambient = p.material.ambient;
m.diffuse = p.material.diffuse;
m.specular = p.material.specular;
m.spec_power = p.material.specular_power;
m.alpha = p.material.alpha_mod;
if (m.count)
{
if (!create_buffer(m.count * sizeof(GL::Vertex), VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, m.vbo))
return false;
memcpy(m.vbo.map, &p.vertices[0], m.count * sizeof(GL::Vertex));
}
memset(&ai, 0, sizeof(ai));
ai.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO;
ai.descriptorPool = g.tex_pool;
ai.descriptorSetCount = 1;
ai.pSetLayouts = &g.tex_layout;
if (vkAllocateDescriptorSets(g.dev, &ai, &m.tex_set) != VK_SUCCESS)
return false;
diffuse = get_texture(p.material.diffuse_map);
ambient = p.material.ambient_map == p.material.diffuse_map ?
diffuse : get_texture(p.material.ambient_map);
write_mesh_descriptors(m, diffuse, ambient);
}
g.scene_ready = true;
return true;
}
bool render(const Frame& fr, retro_video_refresh_t video_cb)
{
const struct retro_hw_render_interface_vulkan *I = g.iface;
uint32_t mask, idx;
unsigned p;
size_t mi;
VkDeviceSize draws, needed, draw_index = 0;
VkCommandBufferBeginInfo bi;
VkRenderPassBeginInfo rp;
VkClearValue clears[2];
VkSubmitInfo si;
VkResult res;
glm::mat4 clip(1.0f);
if (!g.inited || !g.scene_ready || !fr.num_passes || fr.num_passes > 2 ||
!fr.width || !fr.height)
return false;
mask = I->get_sync_index_mask(I->handle);
if (mask != g.last_mask || g.slots.empty())
{
/* Documented as "device is idle when the mask changes". */
destroy_slots();
if (!create_slots(mask))
return false;
}
idx = I->get_sync_index(I->handle);
if (idx >= g.slots.size())
return false;
/* Frontend is done with everything it was given for this index... */
I->wait_sync_index(I->handle);
Slot& s = g.slots[idx];
/* ...and so are our own earlier submissions for it. */
vkWaitForFences(g.dev, 1, &s.fence, VK_TRUE, (uint64_t)-1);
if (s.target.w != fr.width || s.target.h != fr.height)
{
destroy_target(s.target);
if (!create_target(s.target, fr.width, fr.height))
{
VKR_LOG(RETRO_LOG_ERROR, "[Vulkan] Failed to create %ux%u target.\n", fr.width, fr.height);
return false;
}
}
draws = (VkDeviceSize)g.meshes.size() * fr.num_passes;
needed = (draws ? draws : 1) * g.ubo_stride;
if (!ensure_ubo(s, needed))
return false;
/* GL clip space (Y up, z -1..1) -> Vulkan (Y down, z 0..1). */
clip[1][1] = -1.0f;
clip[2][2] = 0.5f;
clip[3][2] = 0.5f;
vkResetCommandPool(g.dev, s.pool, 0);
memset(&bi, 0, sizeof(bi));
bi.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
bi.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
vkBeginCommandBuffer(s.cmd, &bi);
memset(clears, 0, sizeof(clears));
clears[0].color.float32[0] = 0.2f;
clears[0].color.float32[1] = 0.2f;
clears[0].color.float32[2] = 0.2f;
clears[0].color.float32[3] = 1.0f;
clears[1].depthStencil.depth = 1.0f;
memset(&rp, 0, sizeof(rp));
rp.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
rp.renderPass = g.render_pass;
rp.framebuffer = s.target.fb;
rp.renderArea.extent.width = fr.width;
rp.renderArea.extent.height = fr.height;
rp.clearValueCount = 2;
rp.pClearValues = clears;
vkCmdBeginRenderPass(s.cmd, &rp, VK_SUBPASS_CONTENTS_INLINE);
vkCmdBindPipeline(s.cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, g.pipeline);
for (p = 0; p < fr.num_passes; p++)
{
const Pass& ps = fr.passes[p];
VkViewport vp;
VkRect2D sc;
glm::mat4 vp_mat = clip * ps.proj * ps.view;
unsigned pw = ps.width;
if (ps.x >= fr.width)
continue;
if (ps.x + pw > fr.width)
pw = fr.width - ps.x;
vp.x = (float)ps.x; vp.y = 0.0f;
vp.width = (float)pw; vp.height = (float)ps.height;
vp.minDepth = 0.0f; vp.maxDepth = 1.0f;
sc.offset.x = (int32_t)ps.x; sc.offset.y = 0;
sc.extent.width = pw; sc.extent.height = ps.height;
vkCmdSetViewport(s.cmd, 0, 1, &vp);
vkCmdSetScissor(s.cmd, 0, 1, &sc);
for (mi = 0; mi < g.meshes.size(); mi++)
{
const MeshGPU& m = g.meshes[mi];
DrawUBO *u;
PushConstants pc;
glm::mat4 mvp = vp_mat * fr.model;
uint32_t dyn_offset = (uint32_t)(draw_index * g.ubo_stride);
VkDeviceSize zero = 0;
if (!m.count)
continue;
u = (DrawUBO*)(s.ubo.map + draw_index * g.ubo_stride);
draw_index++;
copy_vec4(u->light, fr.light, 0.0f);
copy_vec4(u->light_ambient, fr.ambient, 0.0f);
copy_vec4(u->eye, ps.eye_pos, 0.0f);
copy_vec4(u->mtl_ambient, m.ambient, 0.0f);
copy_vec4(u->mtl_diffuse, m.diffuse, 0.0f);
copy_vec4(u->mtl_specular, m.specular, 0.0f);
u->mtl_params[0] = m.spec_power;
u->mtl_params[1] = m.alpha;
u->mtl_params[2] = 0.0f;
u->mtl_params[3] = 0.0f;
memcpy(pc.model, &fr.model[0][0], sizeof(pc.model));
memcpy(pc.mvp, &mvp[0][0], sizeof(pc.mvp));
vkCmdBindDescriptorSets(s.cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, g.pipe_layout,
0, 1, &s.ubo_set, 1, &dyn_offset);
vkCmdBindDescriptorSets(s.cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, g.pipe_layout,
1, 1, &m.tex_set, 0, NULL);
vkCmdPushConstants(s.cmd, g.pipe_layout, VK_SHADER_STAGE_VERTEX_BIT,
0, sizeof(pc), &pc);
vkCmdBindVertexBuffers(s.cmd, 0, 1, &m.vbo.buf, &zero);
vkCmdDraw(s.cmd, m.count, 1, 0, 0);
}
}
vkCmdEndRenderPass(s.cmd);
vkEndCommandBuffer(s.cmd);
memset(&si, 0, sizeof(si));
si.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
si.commandBufferCount = 1;
si.pCommandBuffers = &s.cmd;
vkResetFences(g.dev, 1, &s.fence);
I->lock_queue(I->handle);
res = vkQueueSubmit(g.queue, 1, &si, s.fence);
I->unlock_queue(I->handle);
if (res != VK_SUCCESS)
{
/* Keep the fence signalled so the next wait cannot deadlock. */
VkSubmitInfo empty;
memset(&empty, 0, sizeof(empty));
empty.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
I->lock_queue(I->handle);
vkQueueSubmit(g.queue, 0, &empty, s.fence);
I->unlock_queue(I->handle);
VKR_LOG(RETRO_LOG_ERROR, "[Vulkan] vkQueueSubmit failed (%d).\n", (int)res);
return false;
}
/* No semaphores: the render pass' external dependency is the barrier. */
I->set_image(I->handle, &s.target.desc, 0, NULL, VK_QUEUE_FAMILY_IGNORED);
video_cb(RETRO_HW_FRAME_BUFFER_VALID, fr.width, fr.height, 0);
return true;
}
}
#endif /* HAVE_VULKAN */
Reference in new issue View Git Blame Copy Permalink