1325 lines
53 KiB
C++
1325 lines
53 KiB
C++
// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
|
|
// SPDX-FileCopyrightText: 2024 Jorrit Rouwe
|
|
// SPDX-License-Identifier: MIT
|
|
|
|
#include <TestFramework.h>
|
|
|
|
#include <Renderer/VK/RendererVK.h>
|
|
#include <Renderer/VK/RenderPrimitiveVK.h>
|
|
#include <Renderer/VK/RenderInstancesVK.h>
|
|
#include <Renderer/VK/PipelineStateVK.h>
|
|
#include <Renderer/VK/VertexShaderVK.h>
|
|
#include <Renderer/VK/PixelShaderVK.h>
|
|
#include <Renderer/VK/TextureVK.h>
|
|
#include <Renderer/VK/FatalErrorIfFailedVK.h>
|
|
#include <Utils/Log.h>
|
|
#include <Utils/ReadData.h>
|
|
#include <Jolt/Core/Profiler.h>
|
|
#include <Jolt/Core/QuickSort.h>
|
|
#include <Jolt/Core/RTTI.h>
|
|
|
|
JPH_SUPPRESS_WARNINGS_STD_BEGIN
|
|
#ifdef JPH_PLATFORM_WINDOWS
|
|
#include <vulkan/vulkan_win32.h>
|
|
#include <Window/ApplicationWindowWin.h>
|
|
#elif defined(JPH_PLATFORM_LINUX)
|
|
#include <vulkan/vulkan_xlib.h>
|
|
#include <Window/ApplicationWindowLinux.h>
|
|
#elif defined(JPH_PLATFORM_MACOS)
|
|
#include <vulkan/vulkan_metal.h>
|
|
#include <Window/ApplicationWindowMacOS.h>
|
|
#endif
|
|
JPH_SUPPRESS_WARNINGS_STD_END
|
|
|
|
#ifdef JPH_DEBUG
|
|
|
|
static VKAPI_ATTR VkBool32 VKAPI_CALL sVulkanDebugCallback(VkDebugUtilsMessageSeverityFlagBitsEXT inSeverity, [[maybe_unused]] VkDebugUtilsMessageTypeFlagsEXT inType, const VkDebugUtilsMessengerCallbackDataEXT *inCallbackData, [[maybe_unused]] void *inUserData)
|
|
{
|
|
Trace("VK: %s", inCallbackData->pMessage);
|
|
JPH_ASSERT((inSeverity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT) == 0);
|
|
return VK_FALSE;
|
|
}
|
|
|
|
#endif // JPH_DEBUG
|
|
|
|
RendererVK::~RendererVK()
|
|
{
|
|
vkDeviceWaitIdle(mDevice);
|
|
|
|
// Trace allocation stats
|
|
Trace("VK: Max allocations: %u, max size: %u MB", mMaxNumAllocations, uint32(mMaxTotalAllocated >> 20));
|
|
|
|
// Destroy the shadow map
|
|
mShadowMap = nullptr;
|
|
vkDestroyFramebuffer(mDevice, mShadowFrameBuffer, nullptr);
|
|
|
|
// Release constant buffers
|
|
for (unique_ptr<ConstantBufferVK> &cb : mVertexShaderConstantBufferProjection)
|
|
cb = nullptr;
|
|
for (unique_ptr<ConstantBufferVK> &cb : mVertexShaderConstantBufferOrtho)
|
|
cb = nullptr;
|
|
for (unique_ptr<ConstantBufferVK> &cb : mPixelShaderConstantBuffer)
|
|
cb = nullptr;
|
|
|
|
// Free all buffers
|
|
for (BufferCache &bc : mFreedBuffers)
|
|
for (BufferCache::value_type &vt : bc)
|
|
for (BufferVK &bvk : vt.second)
|
|
FreeBufferInternal(bvk);
|
|
for (BufferCache::value_type &vt : mBufferCache)
|
|
for (BufferVK &bvk : vt.second)
|
|
FreeBufferInternal(bvk);
|
|
|
|
// Free all blocks in the memory cache
|
|
for (MemoryCache::value_type &mc : mMemoryCache)
|
|
for (Memory &m : mc.second)
|
|
if (m.mOffset == 0)
|
|
vkFreeMemory(mDevice, m.mMemory, nullptr); // Don't care about memory tracking anymore
|
|
|
|
for (VkFence fence : mInFlightFences)
|
|
vkDestroyFence(mDevice, fence, nullptr);
|
|
|
|
vkDestroyCommandPool(mDevice, mCommandPool, nullptr);
|
|
|
|
vkDestroyPipelineLayout(mDevice, mPipelineLayout, nullptr);
|
|
|
|
vkDestroyRenderPass(mDevice, mRenderPassShadow, nullptr);
|
|
vkDestroyRenderPass(mDevice, mRenderPass, nullptr);
|
|
|
|
vkDestroyDescriptorPool(mDevice, mDescriptorPool, nullptr);
|
|
|
|
vkDestroySampler(mDevice, mTextureSamplerShadow, nullptr);
|
|
vkDestroySampler(mDevice, mTextureSamplerRepeat, nullptr);
|
|
|
|
vkDestroyDescriptorSetLayout(mDevice, mDescriptorSetLayoutUBO, nullptr);
|
|
vkDestroyDescriptorSetLayout(mDevice, mDescriptorSetLayoutTexture, nullptr);
|
|
|
|
DestroySwapChain();
|
|
|
|
vkDestroySurfaceKHR(mInstance, mSurface, nullptr);
|
|
|
|
vkDestroyDevice(mDevice, nullptr);
|
|
|
|
#ifdef JPH_DEBUG
|
|
PFN_vkDestroyDebugUtilsMessengerEXT vkDestroyDebugUtilsMessengerEXT = (PFN_vkDestroyDebugUtilsMessengerEXT)(void *)vkGetInstanceProcAddr(mInstance, "vkDestroyDebugUtilsMessengerEXT");
|
|
if (vkDestroyDebugUtilsMessengerEXT != nullptr)
|
|
vkDestroyDebugUtilsMessengerEXT(mInstance, mDebugMessenger, nullptr);
|
|
#endif
|
|
|
|
vkDestroyInstance(mInstance, nullptr);
|
|
}
|
|
|
|
void RendererVK::Initialize(ApplicationWindow *inWindow)
|
|
{
|
|
Renderer::Initialize(inWindow);
|
|
|
|
// Flip the sign of the projection matrix
|
|
mPerspectiveYSign = -1.0f;
|
|
|
|
// Required instance extensions
|
|
Array<const char *> required_instance_extensions;
|
|
required_instance_extensions.push_back(VK_KHR_SURFACE_EXTENSION_NAME);
|
|
#ifdef JPH_PLATFORM_WINDOWS
|
|
required_instance_extensions.push_back(VK_KHR_WIN32_SURFACE_EXTENSION_NAME);
|
|
#elif defined(JPH_PLATFORM_LINUX)
|
|
required_instance_extensions.push_back(VK_KHR_XLIB_SURFACE_EXTENSION_NAME);
|
|
#elif defined(JPH_PLATFORM_MACOS)
|
|
required_instance_extensions.push_back(VK_EXT_METAL_SURFACE_EXTENSION_NAME);
|
|
required_instance_extensions.push_back("VK_KHR_portability_enumeration");
|
|
required_instance_extensions.push_back("VK_KHR_get_physical_device_properties2");
|
|
#endif
|
|
|
|
// Required device extensions
|
|
Array<const char *> required_device_extensions;
|
|
required_device_extensions.push_back(VK_KHR_SWAPCHAIN_EXTENSION_NAME);
|
|
#ifdef JPH_PLATFORM_MACOS
|
|
required_device_extensions.push_back("VK_KHR_portability_subset"); // VK_KHR_PORTABILITY_SUBSET_EXTENSION_NAME
|
|
#endif
|
|
|
|
// Query supported instance extensions
|
|
uint32 instance_extension_count = 0;
|
|
FatalErrorIfFailed(vkEnumerateInstanceExtensionProperties(nullptr, &instance_extension_count, nullptr));
|
|
Array<VkExtensionProperties> instance_extensions;
|
|
instance_extensions.resize(instance_extension_count);
|
|
FatalErrorIfFailed(vkEnumerateInstanceExtensionProperties(nullptr, &instance_extension_count, instance_extensions.data()));
|
|
|
|
// Query supported validation layers
|
|
uint32 validation_layer_count;
|
|
vkEnumerateInstanceLayerProperties(&validation_layer_count, nullptr);
|
|
Array<VkLayerProperties> validation_layers(validation_layer_count);
|
|
vkEnumerateInstanceLayerProperties(&validation_layer_count, validation_layers.data());
|
|
|
|
// Create Vulkan instance
|
|
VkInstanceCreateInfo instance_create_info = {};
|
|
instance_create_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
|
|
#ifdef JPH_PLATFORM_MACOS
|
|
instance_create_info.flags = VK_INSTANCE_CREATE_ENUMERATE_PORTABILITY_BIT_KHR;
|
|
#endif
|
|
|
|
#ifdef JPH_DEBUG
|
|
// Enable validation layer if supported
|
|
const char *desired_validation_layers[] = { "VK_LAYER_KHRONOS_validation" };
|
|
for (const VkLayerProperties &p : validation_layers)
|
|
if (strcmp(desired_validation_layers[0], p.layerName) == 0)
|
|
{
|
|
instance_create_info.enabledLayerCount = 1;
|
|
instance_create_info.ppEnabledLayerNames = desired_validation_layers;
|
|
break;
|
|
}
|
|
|
|
// Setup debug messenger callback if the extension is supported
|
|
VkDebugUtilsMessengerCreateInfoEXT messenger_create_info = {};
|
|
for (const VkExtensionProperties &ext : instance_extensions)
|
|
if (strcmp(VK_EXT_DEBUG_UTILS_EXTENSION_NAME, ext.extensionName) == 0)
|
|
{
|
|
messenger_create_info.sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT;
|
|
messenger_create_info.messageSeverity = VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT;
|
|
messenger_create_info.messageType = VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT;
|
|
messenger_create_info.pfnUserCallback = sVulkanDebugCallback;
|
|
instance_create_info.pNext = &messenger_create_info;
|
|
required_instance_extensions.push_back(VK_EXT_DEBUG_UTILS_EXTENSION_NAME);
|
|
break;
|
|
}
|
|
#endif
|
|
|
|
instance_create_info.enabledExtensionCount = (uint32)required_instance_extensions.size();
|
|
instance_create_info.ppEnabledExtensionNames = required_instance_extensions.data();
|
|
FatalErrorIfFailed(vkCreateInstance(&instance_create_info, nullptr, &mInstance));
|
|
|
|
#ifdef JPH_DEBUG
|
|
// Finalize debug messenger callback
|
|
PFN_vkCreateDebugUtilsMessengerEXT vkCreateDebugUtilsMessengerEXT = (PFN_vkCreateDebugUtilsMessengerEXT)(std::uintptr_t)vkGetInstanceProcAddr(mInstance, "vkCreateDebugUtilsMessengerEXT");
|
|
if (vkCreateDebugUtilsMessengerEXT != nullptr)
|
|
FatalErrorIfFailed(vkCreateDebugUtilsMessengerEXT(mInstance, &messenger_create_info, nullptr, &mDebugMessenger));
|
|
#endif
|
|
|
|
// Create surface
|
|
#ifdef JPH_PLATFORM_WINDOWS
|
|
VkWin32SurfaceCreateInfoKHR surface_create_info = {};
|
|
surface_create_info.sType = VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR;
|
|
surface_create_info.hwnd = static_cast<ApplicationWindowWin *>(mWindow)->GetWindowHandle();
|
|
surface_create_info.hinstance = GetModuleHandle(nullptr);
|
|
FatalErrorIfFailed(vkCreateWin32SurfaceKHR(mInstance, &surface_create_info, nullptr, &mSurface));
|
|
#elif defined(JPH_PLATFORM_LINUX)
|
|
VkXlibSurfaceCreateInfoKHR surface_create_info = {};
|
|
surface_create_info.sType = VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR;
|
|
surface_create_info.dpy = static_cast<ApplicationWindowLinux *>(mWindow)->GetDisplay();
|
|
surface_create_info.window = static_cast<ApplicationWindowLinux *>(mWindow)->GetWindow();
|
|
FatalErrorIfFailed(vkCreateXlibSurfaceKHR(mInstance, &surface_create_info, nullptr, &mSurface));
|
|
#elif defined(JPH_PLATFORM_MACOS)
|
|
VkMetalSurfaceCreateInfoEXT surface_create_info = {};
|
|
surface_create_info.sType = VK_STRUCTURE_TYPE_METAL_SURFACE_CREATE_INFO_EXT;
|
|
surface_create_info.pNext = nullptr;
|
|
surface_create_info.pLayer = static_cast<ApplicationWindowMacOS *>(mWindow)->GetMetalLayer();
|
|
FatalErrorIfFailed(vkCreateMetalSurfaceEXT(mInstance, &surface_create_info, nullptr, &mSurface));
|
|
#endif
|
|
|
|
// Select device
|
|
uint32 device_count = 0;
|
|
FatalErrorIfFailed(vkEnumeratePhysicalDevices(mInstance, &device_count, nullptr));
|
|
Array<VkPhysicalDevice> devices;
|
|
devices.resize(device_count);
|
|
FatalErrorIfFailed(vkEnumeratePhysicalDevices(mInstance, &device_count, devices.data()));
|
|
struct Device
|
|
{
|
|
VkPhysicalDevice mPhysicalDevice;
|
|
String mName;
|
|
VkSurfaceFormatKHR mFormat;
|
|
uint32 mGraphicsQueueIndex;
|
|
uint32 mPresentQueueIndex;
|
|
int mScore;
|
|
};
|
|
Array<Device> available_devices;
|
|
for (VkPhysicalDevice device : devices)
|
|
{
|
|
// Get device properties
|
|
VkPhysicalDeviceProperties properties;
|
|
vkGetPhysicalDeviceProperties(device, &properties);
|
|
|
|
// Test if it is an appropriate type
|
|
int score = 0;
|
|
switch (properties.deviceType)
|
|
{
|
|
case VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU:
|
|
score = 30;
|
|
break;
|
|
case VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU:
|
|
score = 20;
|
|
break;
|
|
case VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU:
|
|
score = 10;
|
|
break;
|
|
case VK_PHYSICAL_DEVICE_TYPE_CPU:
|
|
score = 5;
|
|
break;
|
|
case VK_PHYSICAL_DEVICE_TYPE_OTHER:
|
|
case VK_PHYSICAL_DEVICE_TYPE_MAX_ENUM:
|
|
continue;
|
|
}
|
|
|
|
// Check if the device supports all our required extensions
|
|
uint32 device_extension_count;
|
|
vkEnumerateDeviceExtensionProperties(device, nullptr, &device_extension_count, nullptr);
|
|
Array<VkExtensionProperties> available_extensions;
|
|
available_extensions.resize(device_extension_count);
|
|
vkEnumerateDeviceExtensionProperties(device, nullptr, &device_extension_count, available_extensions.data());
|
|
int found_extensions = 0;
|
|
for (const char *required_device_extension : required_device_extensions)
|
|
for (const VkExtensionProperties &ext : available_extensions)
|
|
if (strcmp(required_device_extension, ext.extensionName) == 0)
|
|
{
|
|
found_extensions++;
|
|
break;
|
|
}
|
|
if (found_extensions != int(required_device_extensions.size()))
|
|
continue;
|
|
|
|
// Find the right queues
|
|
uint32 queue_family_count = 0;
|
|
vkGetPhysicalDeviceQueueFamilyProperties(device, &queue_family_count, nullptr);
|
|
Array<VkQueueFamilyProperties> queue_families;
|
|
queue_families.resize(queue_family_count);
|
|
vkGetPhysicalDeviceQueueFamilyProperties(device, &queue_family_count, queue_families.data());
|
|
uint32 graphics_queue = ~uint32(0);
|
|
uint32 present_queue = ~uint32(0);
|
|
for (uint32 i = 0; i < uint32(queue_families.size()); ++i)
|
|
{
|
|
if (queue_families[i].queueFlags & VK_QUEUE_GRAPHICS_BIT)
|
|
graphics_queue = i;
|
|
|
|
VkBool32 present_support = false;
|
|
vkGetPhysicalDeviceSurfaceSupportKHR(device, i, mSurface, &present_support);
|
|
if (present_support)
|
|
present_queue = i;
|
|
|
|
if (graphics_queue != ~uint32(0) && present_queue != ~uint32(0))
|
|
break;
|
|
}
|
|
if (graphics_queue == ~uint32(0) || present_queue == ~uint32(0))
|
|
continue;
|
|
|
|
// Select surface format
|
|
VkSurfaceFormatKHR selected_format = SelectFormat(device);
|
|
if (selected_format.format == VK_FORMAT_UNDEFINED)
|
|
continue;
|
|
|
|
// Add the device
|
|
available_devices.push_back({ device, properties.deviceName, selected_format, graphics_queue, present_queue, score });
|
|
}
|
|
if (available_devices.empty())
|
|
FatalError("No Vulkan device found!");
|
|
QuickSort(available_devices.begin(), available_devices.end(), [](const Device &inLHS, const Device &inRHS) {
|
|
return inLHS.mScore > inRHS.mScore;
|
|
});
|
|
const Device &selected_device = available_devices[0];
|
|
Trace("Selected device: %s", selected_device.mName.c_str());
|
|
mPhysicalDevice = selected_device.mPhysicalDevice;
|
|
|
|
// Get memory properties
|
|
vkGetPhysicalDeviceMemoryProperties(mPhysicalDevice, &mMemoryProperties);
|
|
|
|
// Get features
|
|
VkPhysicalDeviceFeatures physical_device_features = {};
|
|
vkGetPhysicalDeviceFeatures(mPhysicalDevice, &physical_device_features);
|
|
|
|
// Create device
|
|
float queue_priority = 1.0f;
|
|
VkDeviceQueueCreateInfo queue_create_info[2] = {};
|
|
for (size_t i = 0; i < std::size(queue_create_info); ++i)
|
|
{
|
|
queue_create_info[i].sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
|
|
queue_create_info[i].queueCount = 1;
|
|
queue_create_info[i].pQueuePriorities = &queue_priority;
|
|
}
|
|
queue_create_info[0].queueFamilyIndex = selected_device.mGraphicsQueueIndex;
|
|
queue_create_info[1].queueFamilyIndex = selected_device.mPresentQueueIndex;
|
|
|
|
VkPhysicalDeviceFeatures device_features = {};
|
|
|
|
if (!physical_device_features.fillModeNonSolid)
|
|
FatalError("fillModeNonSolid not supported!");
|
|
device_features.fillModeNonSolid = VK_TRUE;
|
|
|
|
VkDeviceCreateInfo device_create_info = {};
|
|
device_create_info.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
|
|
device_create_info.queueCreateInfoCount = selected_device.mGraphicsQueueIndex != selected_device.mPresentQueueIndex? 2 : 1;
|
|
device_create_info.pQueueCreateInfos = queue_create_info;
|
|
device_create_info.enabledLayerCount = instance_create_info.enabledLayerCount;
|
|
device_create_info.ppEnabledLayerNames = instance_create_info.ppEnabledLayerNames;
|
|
device_create_info.enabledExtensionCount = uint32(required_device_extensions.size());
|
|
device_create_info.ppEnabledExtensionNames = required_device_extensions.data();
|
|
device_create_info.pEnabledFeatures = &device_features;
|
|
FatalErrorIfFailed(vkCreateDevice(selected_device.mPhysicalDevice, &device_create_info, nullptr, &mDevice));
|
|
|
|
// Get the queues
|
|
mGraphicsQueueIndex = selected_device.mGraphicsQueueIndex;
|
|
mPresentQueueIndex = selected_device.mPresentQueueIndex;
|
|
vkGetDeviceQueue(mDevice, mGraphicsQueueIndex, 0, &mGraphicsQueue);
|
|
vkGetDeviceQueue(mDevice, mPresentQueueIndex, 0, &mPresentQueue);
|
|
|
|
VkCommandPoolCreateInfo pool_info = {};
|
|
pool_info.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
|
|
pool_info.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT;
|
|
pool_info.queueFamilyIndex = selected_device.mGraphicsQueueIndex;
|
|
FatalErrorIfFailed(vkCreateCommandPool(mDevice, &pool_info, nullptr, &mCommandPool));
|
|
|
|
VkCommandBufferAllocateInfo command_buffer_info = {};
|
|
command_buffer_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
|
|
command_buffer_info.commandPool = mCommandPool;
|
|
command_buffer_info.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
|
|
command_buffer_info.commandBufferCount = 1;
|
|
for (uint32 i = 0; i < cFrameCount; ++i)
|
|
FatalErrorIfFailed(vkAllocateCommandBuffers(mDevice, &command_buffer_info, &mCommandBuffers[i]));
|
|
|
|
VkFenceCreateInfo fence_info = {};
|
|
fence_info.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
|
|
fence_info.flags = VK_FENCE_CREATE_SIGNALED_BIT;
|
|
for (uint32 i = 0; i < cFrameCount; ++i)
|
|
FatalErrorIfFailed(vkCreateFence(mDevice, &fence_info, nullptr, &mInFlightFences[i]));
|
|
|
|
// Create constant buffer. One per frame to avoid overwriting the constant buffer while the GPU is still using it.
|
|
for (uint n = 0; n < cFrameCount; ++n)
|
|
{
|
|
mVertexShaderConstantBufferProjection[n] = CreateConstantBuffer(sizeof(VertexShaderConstantBuffer));
|
|
mVertexShaderConstantBufferOrtho[n] = CreateConstantBuffer(sizeof(VertexShaderConstantBuffer));
|
|
mPixelShaderConstantBuffer[n] = CreateConstantBuffer(sizeof(PixelShaderConstantBuffer));
|
|
}
|
|
|
|
// Create descriptor set layout for the uniform buffers
|
|
VkDescriptorSetLayoutBinding ubo_layout_binding[2] = {};
|
|
ubo_layout_binding[0].binding = 0;
|
|
ubo_layout_binding[0].descriptorCount = 1;
|
|
ubo_layout_binding[0].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
|
|
ubo_layout_binding[0].stageFlags = VK_SHADER_STAGE_VERTEX_BIT;
|
|
ubo_layout_binding[1].binding = 1;
|
|
ubo_layout_binding[1].descriptorCount = 1;
|
|
ubo_layout_binding[1].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
|
|
ubo_layout_binding[1].stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT;
|
|
VkDescriptorSetLayoutCreateInfo ubo_dsl = {};
|
|
ubo_dsl.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
|
|
ubo_dsl.bindingCount = std::size(ubo_layout_binding);
|
|
ubo_dsl.pBindings = ubo_layout_binding;
|
|
FatalErrorIfFailed(vkCreateDescriptorSetLayout(mDevice, &ubo_dsl, nullptr, &mDescriptorSetLayoutUBO));
|
|
|
|
// Create descriptor set layout for the texture binding
|
|
VkDescriptorSetLayoutBinding texture_layout_binding = {};
|
|
texture_layout_binding.binding = 0;
|
|
texture_layout_binding.descriptorCount = 1;
|
|
texture_layout_binding.descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
|
|
texture_layout_binding.stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT;
|
|
VkDescriptorSetLayoutCreateInfo texture_dsl = {};
|
|
texture_dsl.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
|
|
texture_dsl.bindingCount = 1;
|
|
texture_dsl.pBindings = &texture_layout_binding;
|
|
FatalErrorIfFailed(vkCreateDescriptorSetLayout(mDevice, &texture_dsl, nullptr, &mDescriptorSetLayoutTexture));
|
|
|
|
// Create pipeline layout
|
|
VkPipelineLayoutCreateInfo pipeline_layout = {};
|
|
VkDescriptorSetLayout layout_handles[] = { mDescriptorSetLayoutUBO, mDescriptorSetLayoutTexture };
|
|
pipeline_layout.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
|
|
pipeline_layout.setLayoutCount = std::size(layout_handles);
|
|
pipeline_layout.pSetLayouts = layout_handles;
|
|
pipeline_layout.pushConstantRangeCount = 0;
|
|
FatalErrorIfFailed(vkCreatePipelineLayout(mDevice, &pipeline_layout, nullptr, &mPipelineLayout));
|
|
|
|
// Create descriptor pool
|
|
VkDescriptorPoolSize descriptor_pool_sizes[] = {
|
|
{ VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 128 },
|
|
{ VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 128 },
|
|
};
|
|
VkDescriptorPoolCreateInfo descriptor_info = {};
|
|
descriptor_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
|
|
descriptor_info.poolSizeCount = std::size(descriptor_pool_sizes);
|
|
descriptor_info.pPoolSizes = descriptor_pool_sizes;
|
|
descriptor_info.maxSets = 256;
|
|
FatalErrorIfFailed(vkCreateDescriptorPool(mDevice, &descriptor_info, nullptr, &mDescriptorPool));
|
|
|
|
// Allocate descriptor sets for 3d rendering
|
|
Array<VkDescriptorSetLayout> layouts(cFrameCount, mDescriptorSetLayoutUBO);
|
|
VkDescriptorSetAllocateInfo descriptor_set_alloc_info = {};
|
|
descriptor_set_alloc_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO;
|
|
descriptor_set_alloc_info.descriptorPool = mDescriptorPool;
|
|
descriptor_set_alloc_info.descriptorSetCount = cFrameCount;
|
|
descriptor_set_alloc_info.pSetLayouts = layouts.data();
|
|
FatalErrorIfFailed(vkAllocateDescriptorSets(mDevice, &descriptor_set_alloc_info, mDescriptorSets));
|
|
for (uint i = 0; i < cFrameCount; i++)
|
|
{
|
|
VkDescriptorBufferInfo vs_buffer_info = {};
|
|
vs_buffer_info.buffer = mVertexShaderConstantBufferProjection[i]->GetBuffer();
|
|
vs_buffer_info.range = sizeof(VertexShaderConstantBuffer);
|
|
|
|
VkDescriptorBufferInfo ps_buffer_info = {};
|
|
ps_buffer_info.buffer = mPixelShaderConstantBuffer[i]->GetBuffer();
|
|
ps_buffer_info.range = sizeof(PixelShaderConstantBuffer);
|
|
|
|
VkWriteDescriptorSet descriptor_write[2] = {};
|
|
descriptor_write[0].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
|
|
descriptor_write[0].dstSet = mDescriptorSets[i];
|
|
descriptor_write[0].dstBinding = 0;
|
|
descriptor_write[0].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
|
|
descriptor_write[0].descriptorCount = 1;
|
|
descriptor_write[0].pBufferInfo = &vs_buffer_info;
|
|
descriptor_write[1].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
|
|
descriptor_write[1].dstSet = mDescriptorSets[i];
|
|
descriptor_write[1].dstBinding = 1;
|
|
descriptor_write[1].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
|
|
descriptor_write[1].descriptorCount = 1;
|
|
descriptor_write[1].pBufferInfo = &ps_buffer_info;
|
|
vkUpdateDescriptorSets(mDevice, 2, descriptor_write, 0, nullptr);
|
|
}
|
|
|
|
// Allocate descriptor sets for 2d rendering
|
|
FatalErrorIfFailed(vkAllocateDescriptorSets(mDevice, &descriptor_set_alloc_info, mDescriptorSetsOrtho));
|
|
for (uint i = 0; i < cFrameCount; i++)
|
|
{
|
|
VkDescriptorBufferInfo vs_buffer_info = {};
|
|
vs_buffer_info.buffer = mVertexShaderConstantBufferOrtho[i]->GetBuffer();
|
|
vs_buffer_info.range = sizeof(VertexShaderConstantBuffer);
|
|
|
|
VkWriteDescriptorSet descriptor_write = {};
|
|
descriptor_write.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
|
|
descriptor_write.dstSet = mDescriptorSetsOrtho[i];
|
|
descriptor_write.dstBinding = 0;
|
|
descriptor_write.descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
|
|
descriptor_write.descriptorCount = 1;
|
|
descriptor_write.pBufferInfo = &vs_buffer_info;
|
|
vkUpdateDescriptorSets(mDevice, 1, &descriptor_write, 0, nullptr);
|
|
}
|
|
|
|
// Create regular texture sampler
|
|
VkSamplerCreateInfo sampler_info = {};
|
|
sampler_info.sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO;
|
|
sampler_info.magFilter = VK_FILTER_LINEAR;
|
|
sampler_info.minFilter = VK_FILTER_LINEAR;
|
|
sampler_info.addressModeU = VK_SAMPLER_ADDRESS_MODE_REPEAT;
|
|
sampler_info.addressModeV = VK_SAMPLER_ADDRESS_MODE_REPEAT;
|
|
sampler_info.addressModeW = VK_SAMPLER_ADDRESS_MODE_REPEAT;
|
|
sampler_info.borderColor = VK_BORDER_COLOR_INT_OPAQUE_BLACK;
|
|
sampler_info.unnormalizedCoordinates = VK_FALSE;
|
|
sampler_info.minLod = 0.0f;
|
|
sampler_info.maxLod = VK_LOD_CLAMP_NONE;
|
|
sampler_info.mipmapMode = VK_SAMPLER_MIPMAP_MODE_NEAREST;
|
|
FatalErrorIfFailed(vkCreateSampler(mDevice, &sampler_info, nullptr, &mTextureSamplerRepeat));
|
|
|
|
// Create sampler for shadow maps
|
|
sampler_info.addressModeU = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
|
|
sampler_info.addressModeV = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
|
|
sampler_info.addressModeW = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
|
|
FatalErrorIfFailed(vkCreateSampler(mDevice, &sampler_info, nullptr, &mTextureSamplerShadow));
|
|
|
|
{
|
|
// Create shadow render pass
|
|
VkAttachmentDescription shadowmap_attachment = {};
|
|
shadowmap_attachment.format = FindDepthFormat();
|
|
shadowmap_attachment.samples = VK_SAMPLE_COUNT_1_BIT;
|
|
shadowmap_attachment.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
|
|
shadowmap_attachment.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
|
|
shadowmap_attachment.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
|
|
shadowmap_attachment.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
|
|
shadowmap_attachment.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
|
|
shadowmap_attachment.finalLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
|
|
VkAttachmentReference shadowmap_attachment_ref = {};
|
|
shadowmap_attachment_ref.attachment = 0;
|
|
shadowmap_attachment_ref.layout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
|
|
VkSubpassDescription subpass_shadow = {};
|
|
subpass_shadow.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;
|
|
subpass_shadow.pDepthStencilAttachment = &shadowmap_attachment_ref;
|
|
VkSubpassDependency dependencies_shadow = {};
|
|
dependencies_shadow.srcSubpass = VK_SUBPASS_EXTERNAL;
|
|
dependencies_shadow.dstSubpass = 0;
|
|
dependencies_shadow.srcStageMask = VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT;
|
|
dependencies_shadow.srcAccessMask = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
|
|
dependencies_shadow.dstStageMask = VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT;
|
|
dependencies_shadow.dstAccessMask = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
|
|
VkRenderPassCreateInfo render_pass_shadow = {};
|
|
render_pass_shadow.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
|
|
render_pass_shadow.attachmentCount = 1;
|
|
render_pass_shadow.pAttachments = &shadowmap_attachment;
|
|
render_pass_shadow.subpassCount = 1;
|
|
render_pass_shadow.pSubpasses = &subpass_shadow;
|
|
render_pass_shadow.dependencyCount = 1;
|
|
render_pass_shadow.pDependencies = &dependencies_shadow;
|
|
FatalErrorIfFailed(vkCreateRenderPass(mDevice, &render_pass_shadow, nullptr, &mRenderPassShadow));
|
|
}
|
|
|
|
// Create depth only texture (no color buffer, as seen from light)
|
|
mShadowMap = new TextureVK(this, cShadowMapSize, cShadowMapSize);
|
|
|
|
// Create frame buffer for the shadow pass
|
|
VkImageView attachments[] = { mShadowMap->GetImageView() };
|
|
VkFramebufferCreateInfo frame_buffer_info = {};
|
|
frame_buffer_info.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
|
|
frame_buffer_info.renderPass = mRenderPassShadow;
|
|
frame_buffer_info.attachmentCount = std::size(attachments);
|
|
frame_buffer_info.pAttachments = attachments;
|
|
frame_buffer_info.width = cShadowMapSize;
|
|
frame_buffer_info.height = cShadowMapSize;
|
|
frame_buffer_info.layers = 1;
|
|
FatalErrorIfFailed(vkCreateFramebuffer(mDevice, &frame_buffer_info, nullptr, &mShadowFrameBuffer));
|
|
|
|
{
|
|
// Create normal render pass
|
|
VkAttachmentDescription attachments_normal[2] = {};
|
|
VkAttachmentDescription &color_attachment = attachments_normal[0];
|
|
color_attachment.format = selected_device.mFormat.format;
|
|
color_attachment.samples = VK_SAMPLE_COUNT_1_BIT;
|
|
color_attachment.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
|
|
color_attachment.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
|
|
color_attachment.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
|
|
color_attachment.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
|
|
color_attachment.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
|
|
color_attachment.finalLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
|
|
VkAttachmentReference color_attachment_ref = {};
|
|
color_attachment_ref.attachment = 0;
|
|
color_attachment_ref.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
|
|
VkAttachmentDescription &depth_attachment = attachments_normal[1];
|
|
depth_attachment.format = FindDepthFormat();
|
|
depth_attachment.samples = VK_SAMPLE_COUNT_1_BIT;
|
|
depth_attachment.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
|
|
depth_attachment.storeOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
|
|
depth_attachment.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
|
|
depth_attachment.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
|
|
depth_attachment.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
|
|
depth_attachment.finalLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
|
|
VkAttachmentReference depth_attachment_ref = {};
|
|
depth_attachment_ref.attachment = 1;
|
|
depth_attachment_ref.layout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
|
|
VkSubpassDescription subpass_normal = {};
|
|
subpass_normal.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;
|
|
subpass_normal.colorAttachmentCount = 1;
|
|
subpass_normal.pColorAttachments = &color_attachment_ref;
|
|
subpass_normal.pDepthStencilAttachment = &depth_attachment_ref;
|
|
VkSubpassDependency dependencies_normal = {};
|
|
dependencies_normal.srcSubpass = VK_SUBPASS_EXTERNAL;
|
|
dependencies_normal.dstSubpass = 0;
|
|
dependencies_normal.srcStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT | VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT;
|
|
dependencies_normal.srcAccessMask = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
|
|
dependencies_normal.dstStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT | VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
|
|
dependencies_normal.dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT | VK_ACCESS_SHADER_READ_BIT;
|
|
VkRenderPassCreateInfo render_pass_normal = {};
|
|
render_pass_normal.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
|
|
render_pass_normal.attachmentCount = std::size(attachments_normal);
|
|
render_pass_normal.pAttachments = attachments_normal;
|
|
render_pass_normal.subpassCount = 1;
|
|
render_pass_normal.pSubpasses = &subpass_normal;
|
|
render_pass_normal.dependencyCount = 1;
|
|
render_pass_normal.pDependencies = &dependencies_normal;
|
|
FatalErrorIfFailed(vkCreateRenderPass(mDevice, &render_pass_normal, nullptr, &mRenderPass));
|
|
}
|
|
|
|
// Create the swap chain
|
|
CreateSwapChain(mPhysicalDevice);
|
|
}
|
|
|
|
VkSurfaceFormatKHR RendererVK::SelectFormat(VkPhysicalDevice inDevice)
|
|
{
|
|
uint32 format_count;
|
|
vkGetPhysicalDeviceSurfaceFormatsKHR(inDevice, mSurface, &format_count, nullptr);
|
|
if (format_count == 0)
|
|
return { VK_FORMAT_UNDEFINED, VK_COLOR_SPACE_SRGB_NONLINEAR_KHR };
|
|
Array<VkSurfaceFormatKHR> formats;
|
|
formats.resize(format_count);
|
|
vkGetPhysicalDeviceSurfaceFormatsKHR(inDevice, mSurface, &format_count, formats.data());
|
|
|
|
// Select BGRA8 UNORM format if available, otherwise the 1st format
|
|
for (const VkSurfaceFormatKHR &format : formats)
|
|
if (format.format == VK_FORMAT_B8G8R8A8_UNORM && format.colorSpace == VK_COLOR_SPACE_SRGB_NONLINEAR_KHR)
|
|
return format;
|
|
return formats[0];
|
|
}
|
|
|
|
VkFormat RendererVK::FindDepthFormat()
|
|
{
|
|
VkFormat candidates[] = { VK_FORMAT_D32_SFLOAT, VK_FORMAT_D32_SFLOAT_S8_UINT, VK_FORMAT_D24_UNORM_S8_UINT };
|
|
for (VkFormat format : candidates)
|
|
{
|
|
VkFormatProperties props;
|
|
vkGetPhysicalDeviceFormatProperties(mPhysicalDevice, format, &props);
|
|
|
|
if ((props.optimalTilingFeatures & VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT) == VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT)
|
|
return format;
|
|
}
|
|
|
|
FatalError("Failed to find format!");
|
|
}
|
|
|
|
void RendererVK::CreateSwapChain(VkPhysicalDevice inDevice)
|
|
{
|
|
// Select the format
|
|
VkSurfaceFormatKHR format = SelectFormat(inDevice);
|
|
mSwapChainImageFormat = format.format;
|
|
|
|
// Determine swap chain extent
|
|
VkSurfaceCapabilitiesKHR capabilities;
|
|
vkGetPhysicalDeviceSurfaceCapabilitiesKHR(inDevice, mSurface, &capabilities);
|
|
mSwapChainExtent = capabilities.currentExtent;
|
|
if (mSwapChainExtent.width == UINT32_MAX || mSwapChainExtent.height == UINT32_MAX)
|
|
mSwapChainExtent = { uint32(mWindow->GetWindowWidth()), uint32(mWindow->GetWindowHeight()) };
|
|
mSwapChainExtent.width = Clamp(mSwapChainExtent.width, capabilities.minImageExtent.width, capabilities.maxImageExtent.width);
|
|
mSwapChainExtent.height = Clamp(mSwapChainExtent.height, capabilities.minImageExtent.height, capabilities.maxImageExtent.height);
|
|
Trace("VK: Create swap chain %ux%u", mSwapChainExtent.width, mSwapChainExtent.height);
|
|
|
|
// Early out if our window has been minimized
|
|
if (mSwapChainExtent.width == 0 || mSwapChainExtent.height == 0)
|
|
return;
|
|
|
|
// Create the swap chain
|
|
uint32 desired_image_count = max(min(cFrameCount, capabilities.maxImageCount), capabilities.minImageCount);
|
|
VkSwapchainCreateInfoKHR swapchain_create_info = {};
|
|
swapchain_create_info.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR;
|
|
swapchain_create_info.surface = mSurface;
|
|
swapchain_create_info.minImageCount = desired_image_count;
|
|
swapchain_create_info.imageFormat = format.format;
|
|
swapchain_create_info.imageColorSpace = format.colorSpace;
|
|
swapchain_create_info.imageExtent = mSwapChainExtent;
|
|
swapchain_create_info.imageArrayLayers = 1;
|
|
swapchain_create_info.imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
|
|
uint32 queue_family_indices[] = { mGraphicsQueueIndex, mPresentQueueIndex };
|
|
if (mGraphicsQueueIndex != mPresentQueueIndex)
|
|
{
|
|
swapchain_create_info.imageSharingMode = VK_SHARING_MODE_CONCURRENT;
|
|
swapchain_create_info.queueFamilyIndexCount = 2;
|
|
swapchain_create_info.pQueueFamilyIndices = queue_family_indices;
|
|
}
|
|
else
|
|
{
|
|
swapchain_create_info.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE;
|
|
}
|
|
swapchain_create_info.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE;
|
|
swapchain_create_info.preTransform = capabilities.currentTransform;
|
|
swapchain_create_info.compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
|
|
swapchain_create_info.presentMode = VK_PRESENT_MODE_FIFO_KHR;
|
|
swapchain_create_info.clipped = VK_TRUE;
|
|
FatalErrorIfFailed(vkCreateSwapchainKHR(mDevice, &swapchain_create_info, nullptr, &mSwapChain));
|
|
|
|
// Get the actual swap chain image count
|
|
uint32 image_count;
|
|
FatalErrorIfFailed(vkGetSwapchainImagesKHR(mDevice, mSwapChain, &image_count, nullptr));
|
|
|
|
// Get the swap chain images
|
|
mSwapChainImages.resize(image_count);
|
|
FatalErrorIfFailed(vkGetSwapchainImagesKHR(mDevice, mSwapChain, &image_count, mSwapChainImages.data()));
|
|
|
|
// Create image views
|
|
mSwapChainImageViews.resize(image_count);
|
|
for (uint32 i = 0; i < image_count; ++i)
|
|
mSwapChainImageViews[i] = CreateImageView(mSwapChainImages[i], mSwapChainImageFormat, VK_IMAGE_ASPECT_COLOR_BIT);
|
|
|
|
// Create depth buffer
|
|
VkFormat depth_format = FindDepthFormat();
|
|
VkImageUsageFlags depth_usage = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
|
|
VkMemoryPropertyFlags depth_memory_properties = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
|
|
|
|
// Test and utilize support for transient memory for the depth buffer
|
|
VkImageFormatProperties depth_transient_properties = {};
|
|
VkResult depth_transient_support = vkGetPhysicalDeviceImageFormatProperties(mPhysicalDevice, depth_format, VK_IMAGE_TYPE_2D, VK_IMAGE_TILING_OPTIMAL, depth_usage | VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT, 0, &depth_transient_properties);
|
|
if (depth_transient_support == VK_SUCCESS)
|
|
{
|
|
depth_usage |= VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT;
|
|
|
|
// Test and utilize lazily allocated memory for the depth buffer
|
|
for (size_t i = 0; i < mMemoryProperties.memoryTypeCount; i++)
|
|
if (mMemoryProperties.memoryTypes[i].propertyFlags & VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT)
|
|
{
|
|
depth_memory_properties = VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT;
|
|
break;
|
|
}
|
|
}
|
|
|
|
CreateImage(mSwapChainExtent.width, mSwapChainExtent.height, depth_format, VK_IMAGE_TILING_OPTIMAL, depth_usage, depth_memory_properties, mDepthImage, mDepthImageMemory);
|
|
mDepthImageView = CreateImageView(mDepthImage, depth_format, VK_IMAGE_ASPECT_DEPTH_BIT);
|
|
|
|
// Create frame buffers for the normal pass
|
|
mSwapChainFramebuffers.resize(image_count);
|
|
for (size_t i = 0; i < mSwapChainFramebuffers.size(); i++)
|
|
{
|
|
VkImageView attachments[] = { mSwapChainImageViews[i], mDepthImageView };
|
|
VkFramebufferCreateInfo frame_buffer_info = {};
|
|
frame_buffer_info.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
|
|
frame_buffer_info.renderPass = mRenderPass;
|
|
frame_buffer_info.attachmentCount = std::size(attachments);
|
|
frame_buffer_info.pAttachments = attachments;
|
|
frame_buffer_info.width = mSwapChainExtent.width;
|
|
frame_buffer_info.height = mSwapChainExtent.height;
|
|
frame_buffer_info.layers = 1;
|
|
FatalErrorIfFailed(vkCreateFramebuffer(mDevice, &frame_buffer_info, nullptr, &mSwapChainFramebuffers[i]));
|
|
}
|
|
|
|
// Allocate space to remember the image available semaphores
|
|
mImageAvailableSemaphores.resize(image_count, VK_NULL_HANDLE);
|
|
|
|
// Allocate the render finished semaphores
|
|
mRenderFinishedSemaphores.resize(image_count, VK_NULL_HANDLE);
|
|
for (uint32 i = 0; i < image_count; ++i)
|
|
mRenderFinishedSemaphores[i] = AllocateSemaphore();
|
|
}
|
|
|
|
void RendererVK::DestroySwapChain()
|
|
{
|
|
// Destroy semaphores
|
|
for (VkSemaphore semaphore : mImageAvailableSemaphores)
|
|
vkDestroySemaphore(mDevice, semaphore, nullptr);
|
|
mImageAvailableSemaphores.clear();
|
|
|
|
for (VkSemaphore semaphore : mRenderFinishedSemaphores)
|
|
vkDestroySemaphore(mDevice, semaphore, nullptr);
|
|
mRenderFinishedSemaphores.clear();
|
|
|
|
for (VkSemaphore semaphore : mAvailableSemaphores)
|
|
vkDestroySemaphore(mDevice, semaphore, nullptr);
|
|
mAvailableSemaphores.clear();
|
|
|
|
// Destroy depth buffer
|
|
if (mDepthImageView != VK_NULL_HANDLE)
|
|
{
|
|
vkDestroyImageView(mDevice, mDepthImageView, nullptr);
|
|
mDepthImageView = VK_NULL_HANDLE;
|
|
|
|
DestroyImage(mDepthImage, mDepthImageMemory);
|
|
mDepthImage = VK_NULL_HANDLE;
|
|
mDepthImageMemory = VK_NULL_HANDLE;
|
|
}
|
|
|
|
for (VkFramebuffer frame_buffer : mSwapChainFramebuffers)
|
|
vkDestroyFramebuffer(mDevice, frame_buffer, nullptr);
|
|
mSwapChainFramebuffers.clear();
|
|
|
|
for (VkImageView view : mSwapChainImageViews)
|
|
vkDestroyImageView(mDevice, view, nullptr);
|
|
mSwapChainImageViews.clear();
|
|
|
|
mSwapChainImages.clear();
|
|
|
|
if (mSwapChain != VK_NULL_HANDLE)
|
|
{
|
|
vkDestroySwapchainKHR(mDevice, mSwapChain, nullptr);
|
|
mSwapChain = VK_NULL_HANDLE;
|
|
}
|
|
}
|
|
|
|
void RendererVK::OnWindowResize()
|
|
{
|
|
vkDeviceWaitIdle(mDevice);
|
|
DestroySwapChain();
|
|
CreateSwapChain(mPhysicalDevice);
|
|
}
|
|
|
|
VkSemaphore RendererVK::AllocateSemaphore()
|
|
{
|
|
VkSemaphore semaphore;
|
|
|
|
if (mAvailableSemaphores.empty())
|
|
{
|
|
VkSemaphoreCreateInfo semaphore_info = {};
|
|
semaphore_info.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
|
|
FatalErrorIfFailed(vkCreateSemaphore(mDevice, &semaphore_info, nullptr, &semaphore));
|
|
}
|
|
else
|
|
{
|
|
semaphore = mAvailableSemaphores.back();
|
|
mAvailableSemaphores.pop_back();
|
|
}
|
|
|
|
return semaphore;
|
|
}
|
|
|
|
void RendererVK::FreeSemaphore(VkSemaphore inSemaphore)
|
|
{
|
|
if (inSemaphore != VK_NULL_HANDLE)
|
|
mAvailableSemaphores.push_back(inSemaphore);
|
|
}
|
|
|
|
bool RendererVK::BeginFrame(const CameraState &inCamera, float inWorldScale)
|
|
{
|
|
JPH_PROFILE_FUNCTION();
|
|
|
|
Renderer::BeginFrame(inCamera, inWorldScale);
|
|
|
|
// If we have no swap chain, bail out
|
|
if (mSwapChain == VK_NULL_HANDLE)
|
|
{
|
|
Renderer::EndFrame();
|
|
return false;
|
|
}
|
|
|
|
// Update frame index
|
|
mFrameIndex = (mFrameIndex + 1) % cFrameCount;
|
|
|
|
// Wait for this frame to complete
|
|
vkWaitForFences(mDevice, 1, &mInFlightFences[mFrameIndex], VK_TRUE, UINT64_MAX);
|
|
|
|
VkSemaphore semaphore = AllocateSemaphore();
|
|
VkResult result = mSubOptimalSwapChain? VK_ERROR_OUT_OF_DATE_KHR : vkAcquireNextImageKHR(mDevice, mSwapChain, UINT64_MAX, semaphore, VK_NULL_HANDLE, &mImageIndex);
|
|
if (result == VK_ERROR_OUT_OF_DATE_KHR)
|
|
{
|
|
vkDeviceWaitIdle(mDevice);
|
|
DestroySwapChain();
|
|
CreateSwapChain(mPhysicalDevice);
|
|
if (mSwapChain == VK_NULL_HANDLE)
|
|
{
|
|
FreeSemaphore(semaphore);
|
|
Renderer::EndFrame();
|
|
return false;
|
|
}
|
|
result = vkAcquireNextImageKHR(mDevice, mSwapChain, UINT64_MAX, semaphore, VK_NULL_HANDLE, &mImageIndex);
|
|
mSubOptimalSwapChain = false;
|
|
}
|
|
else if (result == VK_SUBOPTIMAL_KHR)
|
|
{
|
|
// Render this frame with the suboptimal swap chain as we've already acquired an image
|
|
mSubOptimalSwapChain = true;
|
|
result = VK_SUCCESS;
|
|
}
|
|
FatalErrorIfFailed(result);
|
|
|
|
// The previous semaphore is now no longer in use, associate the new semaphore with the image
|
|
FreeSemaphore(mImageAvailableSemaphores[mImageIndex]);
|
|
mImageAvailableSemaphores[mImageIndex] = semaphore;
|
|
|
|
// Free buffers that weren't used this frame
|
|
for (BufferCache::value_type &vt : mBufferCache)
|
|
for (BufferVK &bvk : vt.second)
|
|
FreeBufferInternal(bvk);
|
|
mBufferCache.clear();
|
|
|
|
// Recycle the buffers that were freed
|
|
mBufferCache.swap(mFreedBuffers[mFrameIndex]);
|
|
|
|
vkResetFences(mDevice, 1, &mInFlightFences[mFrameIndex]);
|
|
|
|
VkCommandBuffer command_buffer = GetCommandBuffer();
|
|
FatalErrorIfFailed(vkResetCommandBuffer(command_buffer, 0));
|
|
|
|
VkCommandBufferBeginInfo command_buffer_begin_info = {};
|
|
command_buffer_begin_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
|
|
command_buffer_begin_info.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
|
|
FatalErrorIfFailed(vkBeginCommandBuffer(command_buffer, &command_buffer_begin_info));
|
|
|
|
// Begin the shadow pass
|
|
VkClearValue clear_value;
|
|
clear_value.depthStencil = { 0.0f, 0 };
|
|
VkRenderPassBeginInfo render_pass_begin_info = {};
|
|
render_pass_begin_info.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
|
|
render_pass_begin_info.renderPass = mRenderPassShadow;
|
|
render_pass_begin_info.framebuffer = mShadowFrameBuffer;
|
|
render_pass_begin_info.renderArea.extent = { cShadowMapSize, cShadowMapSize };
|
|
render_pass_begin_info.clearValueCount = 1;
|
|
render_pass_begin_info.pClearValues = &clear_value;
|
|
vkCmdBeginRenderPass(command_buffer, &render_pass_begin_info, VK_SUBPASS_CONTENTS_INLINE);
|
|
|
|
// Set constants for vertex shader in projection mode
|
|
VertexShaderConstantBuffer *vs = mVertexShaderConstantBufferProjection[mFrameIndex]->Map<VertexShaderConstantBuffer>();
|
|
*vs = mVSBuffer;
|
|
mVertexShaderConstantBufferProjection[mFrameIndex]->Unmap();
|
|
|
|
// Set constants for vertex shader in ortho mode
|
|
vs = mVertexShaderConstantBufferOrtho[mFrameIndex]->Map<VertexShaderConstantBuffer>();
|
|
*vs = mVSBufferOrtho;
|
|
mVertexShaderConstantBufferOrtho[mFrameIndex]->Unmap();
|
|
|
|
// Set constants for pixel shader
|
|
PixelShaderConstantBuffer *ps = mPixelShaderConstantBuffer[mFrameIndex]->Map<PixelShaderConstantBuffer>();
|
|
*ps = mPSBuffer;
|
|
mPixelShaderConstantBuffer[mFrameIndex]->Unmap();
|
|
|
|
// Set the view port and scissor rect to the shadow map size
|
|
UpdateViewPortAndScissorRect(cShadowMapSize, cShadowMapSize);
|
|
|
|
// Switch to 3d projection mode
|
|
SetProjectionMode();
|
|
|
|
return true;
|
|
}
|
|
|
|
void RendererVK::EndShadowPass()
|
|
{
|
|
VkCommandBuffer command_buffer = GetCommandBuffer();
|
|
|
|
// End the shadow pass
|
|
vkCmdEndRenderPass(command_buffer);
|
|
|
|
// Begin the normal render pass
|
|
VkClearValue clear_values[2];
|
|
clear_values[0].color = {{ 0.098f, 0.098f, 0.439f, 1.000f }};
|
|
clear_values[1].depthStencil = { 0.0f, 0 }; // Reverse-Z clears to 0
|
|
VkRenderPassBeginInfo render_pass_begin_info = {};
|
|
render_pass_begin_info.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
|
|
render_pass_begin_info.renderPass = mRenderPass;
|
|
JPH_ASSERT(mImageIndex < mSwapChainFramebuffers.size());
|
|
render_pass_begin_info.framebuffer = mSwapChainFramebuffers[mImageIndex];
|
|
render_pass_begin_info.renderArea.extent = mSwapChainExtent;
|
|
render_pass_begin_info.clearValueCount = std::size(clear_values);
|
|
render_pass_begin_info.pClearValues = clear_values;
|
|
vkCmdBeginRenderPass(command_buffer, &render_pass_begin_info, VK_SUBPASS_CONTENTS_INLINE);
|
|
|
|
// Set the view port and scissor rect to the screen size
|
|
UpdateViewPortAndScissorRect(mSwapChainExtent.width, mSwapChainExtent.height);
|
|
}
|
|
|
|
void RendererVK::EndFrame()
|
|
{
|
|
JPH_PROFILE_FUNCTION();
|
|
|
|
VkCommandBuffer command_buffer = GetCommandBuffer();
|
|
vkCmdEndRenderPass(command_buffer);
|
|
|
|
FatalErrorIfFailed(vkEndCommandBuffer(command_buffer));
|
|
|
|
VkSemaphore wait_semaphores[] = { mImageAvailableSemaphores[mImageIndex] };
|
|
VkSemaphore signal_semaphores[] = { mRenderFinishedSemaphores[mImageIndex] };
|
|
VkPipelineStageFlags wait_stages[] = { VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT };
|
|
VkSubmitInfo submit_info = {};
|
|
submit_info.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
|
|
submit_info.waitSemaphoreCount = 1;
|
|
submit_info.pWaitSemaphores = wait_semaphores;
|
|
submit_info.pWaitDstStageMask = wait_stages;
|
|
submit_info.commandBufferCount = 1;
|
|
submit_info.pCommandBuffers = &command_buffer;
|
|
submit_info.signalSemaphoreCount = 1;
|
|
submit_info.pSignalSemaphores = signal_semaphores;
|
|
FatalErrorIfFailed(vkQueueSubmit(mGraphicsQueue, 1, &submit_info, mInFlightFences[mFrameIndex]));
|
|
|
|
VkSwapchainKHR swap_chains[] = { mSwapChain };
|
|
VkPresentInfoKHR present_info = {};
|
|
present_info.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR;
|
|
present_info.waitSemaphoreCount = 1;
|
|
present_info.pWaitSemaphores = signal_semaphores;
|
|
present_info.swapchainCount = 1;
|
|
present_info.pSwapchains = swap_chains;
|
|
present_info.pImageIndices = &mImageIndex;
|
|
vkQueuePresentKHR(mPresentQueue, &present_info);
|
|
|
|
Renderer::EndFrame();
|
|
}
|
|
|
|
void RendererVK::SetProjectionMode()
|
|
{
|
|
JPH_ASSERT(mInFrame);
|
|
|
|
// Bind descriptor set for 3d rendering
|
|
vkCmdBindDescriptorSets(GetCommandBuffer(), VK_PIPELINE_BIND_POINT_GRAPHICS, mPipelineLayout, 0, 1, &mDescriptorSets[mFrameIndex], 0, nullptr);
|
|
}
|
|
|
|
void RendererVK::SetOrthoMode()
|
|
{
|
|
JPH_ASSERT(mInFrame);
|
|
|
|
// Bind descriptor set for 2d rendering
|
|
vkCmdBindDescriptorSets(GetCommandBuffer(), VK_PIPELINE_BIND_POINT_GRAPHICS, mPipelineLayout, 0, 1, &mDescriptorSetsOrtho[mFrameIndex], 0, nullptr);
|
|
}
|
|
|
|
Ref<Texture> RendererVK::CreateTexture(const Surface *inSurface)
|
|
{
|
|
return new TextureVK(this, inSurface);
|
|
}
|
|
|
|
Ref<VertexShader> RendererVK::CreateVertexShader(const char *inName)
|
|
{
|
|
Array<uint8> data = ReadData((String("Shaders/VK/") + inName + ".vert.spv").c_str());
|
|
|
|
VkShaderModuleCreateInfo create_info = {};
|
|
create_info.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
|
|
create_info.codeSize = data.size();
|
|
create_info.pCode = reinterpret_cast<const uint32 *>(data.data());
|
|
VkShaderModule shader_module;
|
|
FatalErrorIfFailed(vkCreateShaderModule(mDevice, &create_info, nullptr, &shader_module));
|
|
|
|
return new VertexShaderVK(mDevice, shader_module);
|
|
}
|
|
|
|
Ref<PixelShader> RendererVK::CreatePixelShader(const char *inName)
|
|
{
|
|
Array<uint8> data = ReadData((String("Shaders/VK/") + inName + ".frag.spv").c_str());
|
|
|
|
VkShaderModuleCreateInfo create_info = {};
|
|
create_info.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
|
|
create_info.codeSize = data.size();
|
|
create_info.pCode = reinterpret_cast<const uint32 *>(data.data());
|
|
VkShaderModule shader_module;
|
|
FatalErrorIfFailed(vkCreateShaderModule(mDevice, &create_info, nullptr, &shader_module));
|
|
|
|
return new PixelShaderVK(mDevice, shader_module);
|
|
}
|
|
|
|
unique_ptr<PipelineState> RendererVK::CreatePipelineState(const VertexShader *inVertexShader, const PipelineState::EInputDescription *inInputDescription, uint inInputDescriptionCount, const PixelShader *inPixelShader, PipelineState::EDrawPass inDrawPass, PipelineState::EFillMode inFillMode, PipelineState::ETopology inTopology, PipelineState::EDepthTest inDepthTest, PipelineState::EBlendMode inBlendMode, PipelineState::ECullMode inCullMode)
|
|
{
|
|
return make_unique<PipelineStateVK>(this, static_cast<const VertexShaderVK *>(inVertexShader), inInputDescription, inInputDescriptionCount, static_cast<const PixelShaderVK *>(inPixelShader), inDrawPass, inFillMode, inTopology, inDepthTest, inBlendMode, inCullMode);
|
|
}
|
|
|
|
RenderPrimitive *RendererVK::CreateRenderPrimitive(PipelineState::ETopology inType)
|
|
{
|
|
return new RenderPrimitiveVK(this);
|
|
}
|
|
|
|
RenderInstances *RendererVK::CreateRenderInstances()
|
|
{
|
|
return new RenderInstancesVK(this);
|
|
}
|
|
|
|
uint32 RendererVK::FindMemoryType(uint32 inTypeFilter, VkMemoryPropertyFlags inProperties)
|
|
{
|
|
for (uint32 i = 0; i < mMemoryProperties.memoryTypeCount; i++)
|
|
if ((inTypeFilter & (1 << i))
|
|
&& (mMemoryProperties.memoryTypes[i].propertyFlags & inProperties) == inProperties)
|
|
return i;
|
|
|
|
FatalError("Failed to find memory type!");
|
|
}
|
|
|
|
void RendererVK::AllocateMemory(VkDeviceSize inSize, uint32 inMemoryTypeBits, VkMemoryPropertyFlags inProperties, VkDeviceMemory &outMemory)
|
|
{
|
|
VkMemoryAllocateInfo alloc_info = {};
|
|
alloc_info.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
|
|
alloc_info.allocationSize = inSize;
|
|
alloc_info.memoryTypeIndex = FindMemoryType(inMemoryTypeBits, inProperties);
|
|
FatalErrorIfFailed(vkAllocateMemory(mDevice, &alloc_info, nullptr, &outMemory));
|
|
|
|
// Track allocation
|
|
++mNumAllocations;
|
|
mTotalAllocated += inSize;
|
|
|
|
// Track max usage
|
|
mMaxTotalAllocated = max(mMaxTotalAllocated, mTotalAllocated);
|
|
mMaxNumAllocations = max(mMaxNumAllocations, mNumAllocations);
|
|
}
|
|
|
|
void RendererVK::FreeMemory(VkDeviceMemory inMemory, VkDeviceSize inSize)
|
|
{
|
|
vkFreeMemory(mDevice, inMemory, nullptr);
|
|
|
|
// Track free
|
|
--mNumAllocations;
|
|
mTotalAllocated -= inSize;
|
|
}
|
|
|
|
void RendererVK::CreateBuffer(VkDeviceSize inSize, VkBufferUsageFlags inUsage, VkMemoryPropertyFlags inProperties, BufferVK &outBuffer)
|
|
{
|
|
// Check the cache
|
|
BufferCache::iterator i = mBufferCache.find({ inSize, inUsage, inProperties });
|
|
if (i != mBufferCache.end() && !i->second.empty())
|
|
{
|
|
outBuffer = i->second.back();
|
|
i->second.pop_back();
|
|
return;
|
|
}
|
|
|
|
// Create a new buffer
|
|
outBuffer.mSize = inSize;
|
|
outBuffer.mUsage = inUsage;
|
|
outBuffer.mProperties = inProperties;
|
|
|
|
VkBufferCreateInfo create_info = {};
|
|
create_info.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
|
|
create_info.size = inSize;
|
|
create_info.usage = inUsage;
|
|
create_info.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
|
|
FatalErrorIfFailed(vkCreateBuffer(mDevice, &create_info, nullptr, &outBuffer.mBuffer));
|
|
|
|
VkMemoryRequirements mem_requirements;
|
|
vkGetBufferMemoryRequirements(mDevice, outBuffer.mBuffer, &mem_requirements);
|
|
|
|
if (mem_requirements.size > cMaxAllocSize)
|
|
{
|
|
// Allocate block directly
|
|
AllocateMemory(mem_requirements.size, mem_requirements.memoryTypeBits, inProperties, outBuffer.mMemory);
|
|
outBuffer.mAllocatedSize = mem_requirements.size;
|
|
outBuffer.mOffset = 0;
|
|
}
|
|
else
|
|
{
|
|
// Round allocation to the next power of 2 so that we can use a simple block based allocator
|
|
outBuffer.mAllocatedSize = max(VkDeviceSize(GetNextPowerOf2(uint32(mem_requirements.size))), cMinAllocSize);
|
|
|
|
// Ensure that we have memory available from the right pool
|
|
Array<Memory> &mem_array = mMemoryCache[{ outBuffer.mAllocatedSize, outBuffer.mUsage, outBuffer.mProperties }];
|
|
if (mem_array.empty())
|
|
{
|
|
// Allocate a bigger block
|
|
VkDeviceMemory device_memory;
|
|
AllocateMemory(cBlockSize, mem_requirements.memoryTypeBits, inProperties, device_memory);
|
|
|
|
// Divide into sub blocks
|
|
for (VkDeviceSize offset = 0; offset < cBlockSize; offset += outBuffer.mAllocatedSize)
|
|
mem_array.push_back({ device_memory, offset });
|
|
}
|
|
|
|
// Claim memory from the pool
|
|
Memory &memory = mem_array.back();
|
|
outBuffer.mMemory = memory.mMemory;
|
|
outBuffer.mOffset = memory.mOffset;
|
|
mem_array.pop_back();
|
|
}
|
|
|
|
// Bind the memory to the buffer
|
|
vkBindBufferMemory(mDevice, outBuffer.mBuffer, outBuffer.mMemory, outBuffer.mOffset);
|
|
}
|
|
|
|
VkCommandBuffer RendererVK::StartTempCommandBuffer()
|
|
{
|
|
VkCommandBufferAllocateInfo alloc_info = {};
|
|
alloc_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
|
|
alloc_info.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
|
|
alloc_info.commandPool = mCommandPool;
|
|
alloc_info.commandBufferCount = 1;
|
|
|
|
VkCommandBuffer command_buffer;
|
|
vkAllocateCommandBuffers(mDevice, &alloc_info, &command_buffer);
|
|
|
|
VkCommandBufferBeginInfo begin_info = {};
|
|
begin_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
|
|
begin_info.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
|
|
vkBeginCommandBuffer(command_buffer, &begin_info);
|
|
|
|
return command_buffer;
|
|
}
|
|
|
|
void RendererVK::EndTempCommandBuffer(VkCommandBuffer inCommandBuffer)
|
|
{
|
|
vkEndCommandBuffer(inCommandBuffer);
|
|
|
|
VkSubmitInfo submit_info = {};
|
|
submit_info.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
|
|
submit_info.commandBufferCount = 1;
|
|
submit_info.pCommandBuffers = &inCommandBuffer;
|
|
|
|
vkQueueSubmit(mGraphicsQueue, 1, &submit_info, VK_NULL_HANDLE);
|
|
vkQueueWaitIdle(mGraphicsQueue); // Inefficient, but we only use this during initialization
|
|
|
|
vkFreeCommandBuffers(mDevice, mCommandPool, 1, &inCommandBuffer);
|
|
}
|
|
|
|
void RendererVK::CopyBuffer(VkBuffer inSrc, VkBuffer inDst, VkDeviceSize inSize)
|
|
{
|
|
VkCommandBuffer command_buffer = StartTempCommandBuffer();
|
|
|
|
VkBufferCopy region = {};
|
|
region.size = inSize;
|
|
vkCmdCopyBuffer(command_buffer, inSrc, inDst, 1, ®ion);
|
|
|
|
EndTempCommandBuffer(command_buffer);
|
|
}
|
|
|
|
void RendererVK::CreateDeviceLocalBuffer(const void *inData, VkDeviceSize inSize, VkBufferUsageFlags inUsage, BufferVK &outBuffer)
|
|
{
|
|
BufferVK staging_buffer;
|
|
CreateBuffer(inSize, VK_BUFFER_USAGE_TRANSFER_SRC_BIT, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, staging_buffer);
|
|
|
|
void *data;
|
|
vkMapMemory(mDevice, staging_buffer.mMemory, staging_buffer.mOffset, inSize, 0, &data);
|
|
memcpy(data, inData, (size_t)inSize);
|
|
vkUnmapMemory(mDevice, staging_buffer.mMemory);
|
|
|
|
CreateBuffer(inSize, inUsage | VK_BUFFER_USAGE_TRANSFER_DST_BIT, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, outBuffer);
|
|
|
|
CopyBuffer(staging_buffer.mBuffer, outBuffer.mBuffer, inSize);
|
|
|
|
FreeBuffer(staging_buffer);
|
|
}
|
|
|
|
void RendererVK::FreeBuffer(BufferVK &ioBuffer)
|
|
{
|
|
if (ioBuffer.mBuffer != VK_NULL_HANDLE)
|
|
{
|
|
JPH_ASSERT(mFrameIndex < cFrameCount);
|
|
mFreedBuffers[mFrameIndex][{ ioBuffer.mSize, ioBuffer.mUsage, ioBuffer.mProperties }].push_back(ioBuffer);
|
|
}
|
|
}
|
|
|
|
void RendererVK::FreeBufferInternal(BufferVK &ioBuffer)
|
|
{
|
|
// Destroy the buffer
|
|
vkDestroyBuffer(mDevice, ioBuffer.mBuffer, nullptr);
|
|
ioBuffer.mBuffer = VK_NULL_HANDLE;
|
|
|
|
if (ioBuffer.mAllocatedSize > cMaxAllocSize)
|
|
FreeMemory(ioBuffer.mMemory, ioBuffer.mAllocatedSize);
|
|
else
|
|
mMemoryCache[{ ioBuffer.mAllocatedSize, ioBuffer.mUsage, ioBuffer.mProperties }].push_back({ ioBuffer.mMemory, ioBuffer.mOffset });
|
|
ioBuffer.mMemory = VK_NULL_HANDLE;
|
|
}
|
|
|
|
unique_ptr<ConstantBufferVK> RendererVK::CreateConstantBuffer(VkDeviceSize inBufferSize)
|
|
{
|
|
return make_unique<ConstantBufferVK>(this, inBufferSize);
|
|
}
|
|
|
|
VkImageView RendererVK::CreateImageView(VkImage inImage, VkFormat inFormat, VkImageAspectFlags inAspectFlags)
|
|
{
|
|
VkImageViewCreateInfo view_info = {};
|
|
view_info.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
|
|
view_info.image = inImage;
|
|
view_info.viewType = VK_IMAGE_VIEW_TYPE_2D;
|
|
view_info.format = inFormat;
|
|
view_info.subresourceRange.aspectMask = inAspectFlags;
|
|
view_info.subresourceRange.levelCount = 1;
|
|
view_info.subresourceRange.layerCount = 1;
|
|
|
|
VkImageView image_view;
|
|
FatalErrorIfFailed(vkCreateImageView(mDevice, &view_info, nullptr, &image_view));
|
|
|
|
return image_view;
|
|
}
|
|
|
|
void RendererVK::CreateImage(uint32 inWidth, uint32 inHeight, VkFormat inFormat, VkImageTiling inTiling, VkImageUsageFlags inUsage, VkMemoryPropertyFlags inProperties, VkImage &outImage, VkDeviceMemory &outMemory)
|
|
{
|
|
VkImageCreateInfo image_info = {};
|
|
image_info.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
|
|
image_info.imageType = VK_IMAGE_TYPE_2D;
|
|
image_info.extent.width = inWidth;
|
|
image_info.extent.height = inHeight;
|
|
image_info.extent.depth = 1;
|
|
image_info.mipLevels = 1;
|
|
image_info.arrayLayers = 1;
|
|
image_info.format = inFormat;
|
|
image_info.tiling = inTiling;
|
|
image_info.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
|
|
image_info.usage = inUsage;
|
|
image_info.samples = VK_SAMPLE_COUNT_1_BIT;
|
|
image_info.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
|
|
FatalErrorIfFailed(vkCreateImage(mDevice, &image_info, nullptr, &outImage));
|
|
|
|
VkMemoryRequirements mem_requirements;
|
|
vkGetImageMemoryRequirements(mDevice, outImage, &mem_requirements);
|
|
|
|
AllocateMemory(mem_requirements.size, mem_requirements.memoryTypeBits, inProperties, outMemory);
|
|
|
|
vkBindImageMemory(mDevice, outImage, outMemory, 0);
|
|
}
|
|
|
|
void RendererVK::DestroyImage(VkImage inImage, VkDeviceMemory inMemory)
|
|
{
|
|
VkMemoryRequirements mem_requirements;
|
|
vkGetImageMemoryRequirements(mDevice, inImage, &mem_requirements);
|
|
|
|
vkDestroyImage(mDevice, inImage, nullptr);
|
|
|
|
FreeMemory(inMemory, mem_requirements.size);
|
|
}
|
|
|
|
void RendererVK::UpdateViewPortAndScissorRect(uint32 inWidth, uint32 inHeight)
|
|
{
|
|
VkCommandBuffer command_buffer = GetCommandBuffer();
|
|
|
|
// Update the view port rect
|
|
VkViewport viewport = {};
|
|
viewport.x = 0.0f;
|
|
viewport.y = 0.0f;
|
|
viewport.width = (float)inWidth;
|
|
viewport.height = (float)inHeight;
|
|
viewport.minDepth = 0.0f;
|
|
viewport.maxDepth = 1.0f;
|
|
vkCmdSetViewport(command_buffer, 0, 1, &viewport);
|
|
|
|
// Update the scissor rect
|
|
VkRect2D scissor = {};
|
|
scissor.extent = { inWidth, inHeight };
|
|
vkCmdSetScissor(command_buffer, 0, 1, &scissor);
|
|
}
|
|
|
|
#ifdef JPH_ENABLE_VULKAN
|
|
Renderer *Renderer::sCreate()
|
|
{
|
|
return new RendererVK;
|
|
}
|
|
#endif
|