|
|
|
|
@ -12,8 +12,6 @@
|
|
|
|
|
|
|
|
|
|
#include <fmt/format.h>
|
|
|
|
|
|
|
|
|
|
#include "common/dynamic_library.h"
|
|
|
|
|
#include "common/file_util.h"
|
|
|
|
|
#include "common/logging/log.h"
|
|
|
|
|
#include "common/telemetry.h"
|
|
|
|
|
#include "core/core.h"
|
|
|
|
|
@ -31,169 +29,14 @@
|
|
|
|
|
#include "video_core/renderer_vulkan/vk_scheduler.h"
|
|
|
|
|
#include "video_core/renderer_vulkan/vk_state_tracker.h"
|
|
|
|
|
#include "video_core/renderer_vulkan/vk_swapchain.h"
|
|
|
|
|
#include "video_core/renderer_vulkan/wrapper.h"
|
|
|
|
|
|
|
|
|
|
// Include these late to avoid polluting previous headers
|
|
|
|
|
#ifdef _WIN32
|
|
|
|
|
#include <windows.h>
|
|
|
|
|
// ensure include order
|
|
|
|
|
#include <vulkan/vulkan_win32.h>
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#if !defined(_WIN32) && !defined(__APPLE__)
|
|
|
|
|
#include <X11/Xlib.h>
|
|
|
|
|
#include <vulkan/vulkan_wayland.h>
|
|
|
|
|
#include <vulkan/vulkan_xlib.h>
|
|
|
|
|
#endif
|
|
|
|
|
#include "video_core/vulkan_common/vulkan_debug_callback.h"
|
|
|
|
|
#include "video_core/vulkan_common/vulkan_instance.h"
|
|
|
|
|
#include "video_core/vulkan_common/vulkan_library.h"
|
|
|
|
|
#include "video_core/vulkan_common/vulkan_surface.h"
|
|
|
|
|
#include "video_core/vulkan_common/vulkan_wrapper.h"
|
|
|
|
|
|
|
|
|
|
namespace Vulkan {
|
|
|
|
|
|
|
|
|
|
namespace {
|
|
|
|
|
|
|
|
|
|
using Core::Frontend::WindowSystemType;
|
|
|
|
|
|
|
|
|
|
VkBool32 DebugCallback(VkDebugUtilsMessageSeverityFlagBitsEXT severity,
|
|
|
|
|
VkDebugUtilsMessageTypeFlagsEXT type,
|
|
|
|
|
const VkDebugUtilsMessengerCallbackDataEXT* data,
|
|
|
|
|
[[maybe_unused]] void* user_data) {
|
|
|
|
|
const char* const message{data->pMessage};
|
|
|
|
|
|
|
|
|
|
if (severity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT) {
|
|
|
|
|
LOG_CRITICAL(Render_Vulkan, "{}", message);
|
|
|
|
|
} else if (severity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT) {
|
|
|
|
|
LOG_WARNING(Render_Vulkan, "{}", message);
|
|
|
|
|
} else if (severity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT) {
|
|
|
|
|
LOG_INFO(Render_Vulkan, "{}", message);
|
|
|
|
|
} else if (severity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT) {
|
|
|
|
|
LOG_DEBUG(Render_Vulkan, "{}", message);
|
|
|
|
|
}
|
|
|
|
|
return VK_FALSE;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
Common::DynamicLibrary OpenVulkanLibrary() {
|
|
|
|
|
Common::DynamicLibrary library;
|
|
|
|
|
#ifdef __APPLE__
|
|
|
|
|
// Check if a path to a specific Vulkan library has been specified.
|
|
|
|
|
char* libvulkan_env = getenv("LIBVULKAN_PATH");
|
|
|
|
|
if (!libvulkan_env || !library.Open(libvulkan_env)) {
|
|
|
|
|
// Use the libvulkan.dylib from the application bundle.
|
|
|
|
|
const std::string filename =
|
|
|
|
|
Common::FS::GetBundleDirectory() + "/Contents/Frameworks/libvulkan.dylib";
|
|
|
|
|
library.Open(filename.c_str());
|
|
|
|
|
}
|
|
|
|
|
#else
|
|
|
|
|
std::string filename = Common::DynamicLibrary::GetVersionedFilename("vulkan", 1);
|
|
|
|
|
if (!library.Open(filename.c_str())) {
|
|
|
|
|
// Android devices may not have libvulkan.so.1, only libvulkan.so.
|
|
|
|
|
filename = Common::DynamicLibrary::GetVersionedFilename("vulkan");
|
|
|
|
|
(void)library.Open(filename.c_str());
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
return library;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
std::pair<vk::Instance, u32> CreateInstance(Common::DynamicLibrary& library,
|
|
|
|
|
vk::InstanceDispatch& dld, WindowSystemType window_type,
|
|
|
|
|
bool enable_debug_utils, bool enable_layers) {
|
|
|
|
|
if (!library.IsOpen()) {
|
|
|
|
|
LOG_ERROR(Render_Vulkan, "Vulkan library not available");
|
|
|
|
|
return {};
|
|
|
|
|
}
|
|
|
|
|
if (!library.GetSymbol("vkGetInstanceProcAddr", &dld.vkGetInstanceProcAddr)) {
|
|
|
|
|
LOG_ERROR(Render_Vulkan, "vkGetInstanceProcAddr not present in Vulkan");
|
|
|
|
|
return {};
|
|
|
|
|
}
|
|
|
|
|
if (!vk::Load(dld)) {
|
|
|
|
|
LOG_ERROR(Render_Vulkan, "Failed to load Vulkan function pointers");
|
|
|
|
|
return {};
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
std::vector<const char*> extensions;
|
|
|
|
|
extensions.reserve(6);
|
|
|
|
|
switch (window_type) {
|
|
|
|
|
case Core::Frontend::WindowSystemType::Headless:
|
|
|
|
|
break;
|
|
|
|
|
#ifdef _WIN32
|
|
|
|
|
case Core::Frontend::WindowSystemType::Windows:
|
|
|
|
|
extensions.push_back(VK_KHR_WIN32_SURFACE_EXTENSION_NAME);
|
|
|
|
|
break;
|
|
|
|
|
#endif
|
|
|
|
|
#if !defined(_WIN32) && !defined(__APPLE__)
|
|
|
|
|
case Core::Frontend::WindowSystemType::X11:
|
|
|
|
|
extensions.push_back(VK_KHR_XLIB_SURFACE_EXTENSION_NAME);
|
|
|
|
|
break;
|
|
|
|
|
case Core::Frontend::WindowSystemType::Wayland:
|
|
|
|
|
extensions.push_back(VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME);
|
|
|
|
|
break;
|
|
|
|
|
#endif
|
|
|
|
|
default:
|
|
|
|
|
LOG_ERROR(Render_Vulkan, "Presentation not supported on this platform");
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
if (window_type != Core::Frontend::WindowSystemType::Headless) {
|
|
|
|
|
extensions.push_back(VK_KHR_SURFACE_EXTENSION_NAME);
|
|
|
|
|
}
|
|
|
|
|
if (enable_debug_utils) {
|
|
|
|
|
extensions.push_back(VK_EXT_DEBUG_UTILS_EXTENSION_NAME);
|
|
|
|
|
}
|
|
|
|
|
extensions.push_back(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME);
|
|
|
|
|
|
|
|
|
|
const std::optional properties = vk::EnumerateInstanceExtensionProperties(dld);
|
|
|
|
|
if (!properties) {
|
|
|
|
|
LOG_ERROR(Render_Vulkan, "Failed to query extension properties");
|
|
|
|
|
return {};
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
for (const char* extension : extensions) {
|
|
|
|
|
const auto it =
|
|
|
|
|
std::find_if(properties->begin(), properties->end(), [extension](const auto& prop) {
|
|
|
|
|
return !std::strcmp(extension, prop.extensionName);
|
|
|
|
|
});
|
|
|
|
|
if (it == properties->end()) {
|
|
|
|
|
LOG_ERROR(Render_Vulkan, "Required instance extension {} is not available", extension);
|
|
|
|
|
return {};
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
std::vector<const char*> layers;
|
|
|
|
|
layers.reserve(1);
|
|
|
|
|
if (enable_layers) {
|
|
|
|
|
layers.push_back("VK_LAYER_KHRONOS_validation");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
const std::optional layer_properties = vk::EnumerateInstanceLayerProperties(dld);
|
|
|
|
|
if (!layer_properties) {
|
|
|
|
|
LOG_ERROR(Render_Vulkan, "Failed to query layer properties, disabling layers");
|
|
|
|
|
layers.clear();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
for (auto layer_it = layers.begin(); layer_it != layers.end();) {
|
|
|
|
|
const char* const layer = *layer_it;
|
|
|
|
|
const auto it = std::find_if(
|
|
|
|
|
layer_properties->begin(), layer_properties->end(),
|
|
|
|
|
[layer](const VkLayerProperties& prop) { return !std::strcmp(layer, prop.layerName); });
|
|
|
|
|
if (it == layer_properties->end()) {
|
|
|
|
|
LOG_ERROR(Render_Vulkan, "Layer {} not available, removing it", layer);
|
|
|
|
|
layer_it = layers.erase(layer_it);
|
|
|
|
|
} else {
|
|
|
|
|
++layer_it;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Limit the maximum version of Vulkan to avoid using untested version.
|
|
|
|
|
const u32 version = std::min(vk::AvailableVersion(dld), static_cast<u32>(VK_API_VERSION_1_1));
|
|
|
|
|
|
|
|
|
|
vk::Instance instance = vk::Instance::Create(version, layers, extensions, dld);
|
|
|
|
|
if (!instance) {
|
|
|
|
|
LOG_ERROR(Render_Vulkan, "Failed to create Vulkan instance");
|
|
|
|
|
return {};
|
|
|
|
|
}
|
|
|
|
|
if (!vk::Load(*instance, dld)) {
|
|
|
|
|
LOG_ERROR(Render_Vulkan, "Failed to load Vulkan instance function pointers");
|
|
|
|
|
}
|
|
|
|
|
return std::make_pair(std::move(instance), version);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
std::string GetReadableVersion(u32 version) {
|
|
|
|
|
return fmt::format("{}.{}.{}", VK_VERSION_MAJOR(version), VK_VERSION_MINOR(version),
|
|
|
|
|
VK_VERSION_PATCH(version));
|
|
|
|
|
@ -216,7 +59,6 @@ std::string GetDriverVersion(const VKDevice& device) {
|
|
|
|
|
const u32 minor = version & 0x3fff;
|
|
|
|
|
return fmt::format("{}.{}", major, minor);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return GetReadableVersion(version);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
@ -255,7 +97,6 @@ void RendererVulkan::SwapBuffers(const Tegra::FramebufferConfig* framebuffer) {
|
|
|
|
|
if (!framebuffer) {
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
const auto& layout = render_window.GetFramebufferLayout();
|
|
|
|
|
if (layout.width > 0 && layout.height > 0 && render_window.IsShown()) {
|
|
|
|
|
const VAddr framebuffer_addr = framebuffer->address + framebuffer->offset;
|
|
|
|
|
@ -284,14 +125,16 @@ void RendererVulkan::SwapBuffers(const Tegra::FramebufferConfig* framebuffer) {
|
|
|
|
|
render_window.OnFrameDisplayed();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bool RendererVulkan::Init() {
|
|
|
|
|
library = OpenVulkanLibrary();
|
|
|
|
|
std::tie(instance, instance_version) = CreateInstance(
|
|
|
|
|
library, dld, render_window.GetWindowInfo().type, true, Settings::values.renderer_debug);
|
|
|
|
|
if (!instance || !CreateDebugCallback() || !CreateSurface() || !PickDevices()) {
|
|
|
|
|
return false;
|
|
|
|
|
bool RendererVulkan::Init() try {
|
|
|
|
|
library = OpenLibrary();
|
|
|
|
|
instance = CreateInstance(library, dld, VK_API_VERSION_1_1, render_window.GetWindowInfo().type,
|
|
|
|
|
true, Settings::values.renderer_debug);
|
|
|
|
|
if (Settings::values.renderer_debug) {
|
|
|
|
|
debug_callback = CreateDebugCallback(instance);
|
|
|
|
|
}
|
|
|
|
|
surface = CreateSurface(instance, render_window);
|
|
|
|
|
|
|
|
|
|
InitializeDevice();
|
|
|
|
|
Report();
|
|
|
|
|
|
|
|
|
|
memory_manager = std::make_unique<VKMemoryManager>(*device);
|
|
|
|
|
@ -311,8 +154,11 @@ bool RendererVulkan::Init() {
|
|
|
|
|
blit_screen =
|
|
|
|
|
std::make_unique<VKBlitScreen>(cpu_memory, render_window, *rasterizer, *device,
|
|
|
|
|
*memory_manager, *swapchain, *scheduler, screen_info);
|
|
|
|
|
|
|
|
|
|
return true;
|
|
|
|
|
|
|
|
|
|
} catch (const vk::Exception& exception) {
|
|
|
|
|
LOG_ERROR(Render_Vulkan, "Vulkan initialization failed with error: {}", exception.what());
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void RendererVulkan::ShutDown() {
|
|
|
|
|
@ -322,7 +168,6 @@ void RendererVulkan::ShutDown() {
|
|
|
|
|
if (const auto& dev = device->GetLogical()) {
|
|
|
|
|
dev.WaitIdle();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
rasterizer.reset();
|
|
|
|
|
blit_screen.reset();
|
|
|
|
|
scheduler.reset();
|
|
|
|
|
@ -331,95 +176,15 @@ void RendererVulkan::ShutDown() {
|
|
|
|
|
device.reset();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bool RendererVulkan::CreateDebugCallback() {
|
|
|
|
|
if (!Settings::values.renderer_debug) {
|
|
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
debug_callback = instance.TryCreateDebugCallback(DebugCallback);
|
|
|
|
|
if (!debug_callback) {
|
|
|
|
|
LOG_ERROR(Render_Vulkan, "Failed to create debug callback");
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bool RendererVulkan::CreateSurface() {
|
|
|
|
|
[[maybe_unused]] const auto& window_info = render_window.GetWindowInfo();
|
|
|
|
|
VkSurfaceKHR unsafe_surface = nullptr;
|
|
|
|
|
|
|
|
|
|
#ifdef _WIN32
|
|
|
|
|
if (window_info.type == Core::Frontend::WindowSystemType::Windows) {
|
|
|
|
|
const HWND hWnd = static_cast<HWND>(window_info.render_surface);
|
|
|
|
|
const VkWin32SurfaceCreateInfoKHR win32_ci{VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR,
|
|
|
|
|
nullptr, 0, nullptr, hWnd};
|
|
|
|
|
const auto vkCreateWin32SurfaceKHR = reinterpret_cast<PFN_vkCreateWin32SurfaceKHR>(
|
|
|
|
|
dld.vkGetInstanceProcAddr(*instance, "vkCreateWin32SurfaceKHR"));
|
|
|
|
|
if (!vkCreateWin32SurfaceKHR ||
|
|
|
|
|
vkCreateWin32SurfaceKHR(*instance, &win32_ci, nullptr, &unsafe_surface) != VK_SUCCESS) {
|
|
|
|
|
LOG_ERROR(Render_Vulkan, "Failed to initialize Win32 surface");
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
#if !defined(_WIN32) && !defined(__APPLE__)
|
|
|
|
|
if (window_info.type == Core::Frontend::WindowSystemType::X11) {
|
|
|
|
|
const VkXlibSurfaceCreateInfoKHR xlib_ci{
|
|
|
|
|
VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR, nullptr, 0,
|
|
|
|
|
static_cast<Display*>(window_info.display_connection),
|
|
|
|
|
reinterpret_cast<Window>(window_info.render_surface)};
|
|
|
|
|
const auto vkCreateXlibSurfaceKHR = reinterpret_cast<PFN_vkCreateXlibSurfaceKHR>(
|
|
|
|
|
dld.vkGetInstanceProcAddr(*instance, "vkCreateXlibSurfaceKHR"));
|
|
|
|
|
if (!vkCreateXlibSurfaceKHR ||
|
|
|
|
|
vkCreateXlibSurfaceKHR(*instance, &xlib_ci, nullptr, &unsafe_surface) != VK_SUCCESS) {
|
|
|
|
|
LOG_ERROR(Render_Vulkan, "Failed to initialize Xlib surface");
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
if (window_info.type == Core::Frontend::WindowSystemType::Wayland) {
|
|
|
|
|
const VkWaylandSurfaceCreateInfoKHR wayland_ci{
|
|
|
|
|
VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR, nullptr, 0,
|
|
|
|
|
static_cast<wl_display*>(window_info.display_connection),
|
|
|
|
|
static_cast<wl_surface*>(window_info.render_surface)};
|
|
|
|
|
const auto vkCreateWaylandSurfaceKHR = reinterpret_cast<PFN_vkCreateWaylandSurfaceKHR>(
|
|
|
|
|
dld.vkGetInstanceProcAddr(*instance, "vkCreateWaylandSurfaceKHR"));
|
|
|
|
|
if (!vkCreateWaylandSurfaceKHR ||
|
|
|
|
|
vkCreateWaylandSurfaceKHR(*instance, &wayland_ci, nullptr, &unsafe_surface) !=
|
|
|
|
|
VK_SUCCESS) {
|
|
|
|
|
LOG_ERROR(Render_Vulkan, "Failed to initialize Wayland surface");
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
if (!unsafe_surface) {
|
|
|
|
|
LOG_ERROR(Render_Vulkan, "Presentation not supported on this platform");
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
surface = vk::SurfaceKHR(unsafe_surface, *instance, dld);
|
|
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bool RendererVulkan::PickDevices() {
|
|
|
|
|
const auto devices = instance.EnumeratePhysicalDevices();
|
|
|
|
|
if (!devices) {
|
|
|
|
|
LOG_ERROR(Render_Vulkan, "Failed to enumerate physical devices");
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void RendererVulkan::InitializeDevice() {
|
|
|
|
|
const std::vector<VkPhysicalDevice> devices = instance.EnumeratePhysicalDevices();
|
|
|
|
|
const s32 device_index = Settings::values.vulkan_device.GetValue();
|
|
|
|
|
if (device_index < 0 || device_index >= static_cast<s32>(devices->size())) {
|
|
|
|
|
if (device_index < 0 || device_index >= static_cast<s32>(devices.size())) {
|
|
|
|
|
LOG_ERROR(Render_Vulkan, "Invalid device index {}!", device_index);
|
|
|
|
|
return false;
|
|
|
|
|
throw vk::Exception(VK_ERROR_INITIALIZATION_FAILED);
|
|
|
|
|
}
|
|
|
|
|
const vk::PhysicalDevice physical_device((*devices)[static_cast<std::size_t>(device_index)],
|
|
|
|
|
dld);
|
|
|
|
|
if (!VKDevice::IsSuitable(physical_device, *surface)) {
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
device =
|
|
|
|
|
std::make_unique<VKDevice>(*instance, instance_version, physical_device, *surface, dld);
|
|
|
|
|
return device->Create();
|
|
|
|
|
const vk::PhysicalDevice physical_device(devices[static_cast<size_t>(device_index)], dld);
|
|
|
|
|
device = std::make_unique<VKDevice>(*instance, physical_device, *surface, dld);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void RendererVulkan::Report() const {
|
|
|
|
|
@ -444,26 +209,21 @@ void RendererVulkan::Report() const {
|
|
|
|
|
telemetry_session.AddField(field, "GPU_Vulkan_Extensions", extensions);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
std::vector<std::string> RendererVulkan::EnumerateDevices() {
|
|
|
|
|
std::vector<std::string> RendererVulkan::EnumerateDevices() try {
|
|
|
|
|
vk::InstanceDispatch dld;
|
|
|
|
|
Common::DynamicLibrary library = OpenVulkanLibrary();
|
|
|
|
|
vk::Instance instance =
|
|
|
|
|
CreateInstance(library, dld, WindowSystemType::Headless, false, false).first;
|
|
|
|
|
if (!instance) {
|
|
|
|
|
return {};
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
const std::optional physical_devices = instance.EnumeratePhysicalDevices();
|
|
|
|
|
if (!physical_devices) {
|
|
|
|
|
return {};
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
const Common::DynamicLibrary library = OpenLibrary();
|
|
|
|
|
const vk::Instance instance = CreateInstance(library, dld, VK_API_VERSION_1_0);
|
|
|
|
|
const std::vector<VkPhysicalDevice> physical_devices = instance.EnumeratePhysicalDevices();
|
|
|
|
|
std::vector<std::string> names;
|
|
|
|
|
names.reserve(physical_devices->size());
|
|
|
|
|
for (const auto& device : *physical_devices) {
|
|
|
|
|
names.reserve(physical_devices.size());
|
|
|
|
|
for (const VkPhysicalDevice device : physical_devices) {
|
|
|
|
|
names.push_back(vk::PhysicalDevice(device, dld).GetProperties().deviceName);
|
|
|
|
|
}
|
|
|
|
|
return names;
|
|
|
|
|
|
|
|
|
|
} catch (const vk::Exception& exception) {
|
|
|
|
|
LOG_ERROR(Render_Vulkan, "Failed to enumerate devices with error: {}", exception.what());
|
|
|
|
|
return {};
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
} // namespace Vulkan
|
|
|
|
|
|
Rodrigo Locatti
GitHub