redstrate/graph
Archived
1
Fork 0
Code Activity

Properly choose swapchain format

Browse source
This commit is contained in:
Joshua Goins 2018-10-16 08:18:19 -04:00
parent c6fd8e49c9
commit 0568c6e5d2
1 changed files with 72 additions and 72 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

144
src/renderer.cpp
View file

@ -18,25 +18,25 @@ Renderer::Renderer() {
createLogicalDevice();
createCommandPool();
createPresentationRenderPass();
worldPass_ = new WorldPass(*this);
}
Renderer::~Renderer() {
vkDeviceWaitIdle(device_);
delete worldPass_;
vkDestroyRenderPass(device_, presentationRenderPass_, nullptr);
vkDestroyCommandPool(device_, commandPool_, nullptr);
#ifdef DEBUG
destroyMessenger_(instance_, messenger_, nullptr);
#endif
vkDestroyDevice(device_, nullptr);
vkDestroyInstance(instance_, nullptr);
}
@ -46,7 +46,7 @@ void Renderer::render(RenderTarget* target) {
vkWaitForFences(device_, 1, &target->fences[imageIndex], true, UINT64_MAX);
vkResetFences(device_, 1, &target->fences[imageIndex]);
const VkCommandBuffer commandBuffer = target->commandBuffers[imageIndex];
VkCommandBufferBeginInfo beginInfo = {};
@ -58,14 +58,14 @@ void Renderer::render(RenderTarget* target) {
viewport.width = target->extent.width;
viewport.height = target->extent.height;
viewport.maxDepth = 1.0f;
vkCmdSetViewport(commandBuffer, 0, 1, &viewport);
VkRect2D scissor = {};
scissor.extent = target->extent;
vkCmdSetScissor(commandBuffer, 0, 1, &scissor);
VkClearValue clearColor = {};
clearColor.color.float32[0] = sin((platform::getTime() / 500.0f) * 0.2f) * 0.5f + 0.5f;
clearColor.color.float32[1] = sin((platform::getTime() / 500.0f) * 0.4f) * 0.5f + 0.5f;
@ -80,15 +80,15 @@ void Renderer::render(RenderTarget* target) {
renderPassBeginInfo.pClearValues = &clearColor;
vkCmdBeginRenderPass(commandBuffer, &renderPassBeginInfo, VK_SUBPASS_CONTENTS_INLINE);
worldPass_->render(commandBuffer);
vkCmdEndRenderPass(commandBuffer);
vkEndCommandBuffer(commandBuffer);
const VkPipelineStageFlags waitStage = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
VkSubmitInfo submitInfo = {};
submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
submitInfo.waitSemaphoreCount = 1;
@ -100,7 +100,7 @@ void Renderer::render(RenderTarget* target) {
submitInfo.pSignalSemaphores = &target->renderFinishedSemaphore;
vkQueueSubmit(graphicsQueue_, 1, &submitInfo, target->fences[imageIndex]);
VkPresentInfoKHR presentInfo = {};
presentInfo.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR;
presentInfo.waitSemaphoreCount = 1;
@ -114,30 +114,30 @@ void Renderer::render(RenderTarget* target) {
RenderTarget* Renderer::createSurfaceRenderTarget(VkSurfaceKHR surface, RenderTarget* oldTarget) {
vkDeviceWaitIdle(device_);
RenderTarget* target = new RenderTarget();
target->surface = surface;
VkSurfaceCapabilitiesKHR surfaceCapabilities = {};
vkGetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice_, surface, &surfaceCapabilities);
target->extent = surfaceCapabilities.currentExtent;
uint32_t surfaceFormatCount = 0;
vkGetPhysicalDeviceSurfaceFormatsKHR(physicalDevice_, surface, &surfaceFormatCount, nullptr);
VkSurfaceFormatKHR* surfaceFormats = new VkSurfaceFormatKHR[surfaceFormatCount];
vkGetPhysicalDeviceSurfaceFormatsKHR(physicalDevice_, surface, &surfaceFormatCount, surfaceFormats);
uint32_t chosenFormat = 0;
for(uint32_t i = 0; i < surfaceFormatCount; i++) {
if(surfaceFormats[i].colorSpace == VK_COLOR_SPACE_SRGB_NONLINEAR_KHR)
if(surfaceFormats[i].format == VK_FORMAT_R8G8B8_SRGB)
chosenFormat = i;
}
VkBool32 supported = false;
vkGetPhysicalDeviceSurfaceSupportKHR(physicalDevice_, queueIndices.presentation, surface, &supported);
VkSwapchainCreateInfoKHR swapchainCreateInfo = {};
swapchainCreateInfo.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR;
swapchainCreateInfo.surface = surface;
@ -156,22 +156,22 @@ RenderTarget* Renderer::createSurfaceRenderTarget(VkSurfaceKHR surface, RenderTa
if(oldTarget)
swapchainCreateInfo.oldSwapchain = oldTarget->swapchain;
vkCreateSwapchainKHR(device_, &swapchainCreateInfo, nullptr, &target->swapchain);
if(oldTarget)
destroyRenderTarget(oldTarget);
delete[] surfaceFormats;
uint32_t swapchainImageCount = 0;
vkGetSwapchainImagesKHR(device_, target->swapchain, &swapchainImageCount, nullptr);
target->numImages = swapchainImageCount;
target->images = new VkImage[swapchainImageCount];
vkGetSwapchainImagesKHR(device_, target->swapchain, &swapchainImageCount, target->images);
target->imageViews = new VkImageView[swapchainImageCount];
for(uint32_t i = 0; i < swapchainImageCount; i++) {
VkImageViewCreateInfo createInfo = {};
@ -205,23 +205,23 @@ RenderTarget* Renderer::createSurfaceRenderTarget(VkSurfaceKHR surface, RenderTa
allocateInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
allocateInfo.commandPool = commandPool_;
allocateInfo.commandBufferCount = swapchainImageCount;
target->commandBuffers = new VkCommandBuffer[swapchainImageCount];
vkAllocateCommandBuffers(device_, &allocateInfo, target->commandBuffers);
VkSemaphoreCreateInfo semaphoreCreateInfo = {};
semaphoreCreateInfo.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
vkCreateSemaphore(device_, &semaphoreCreateInfo, nullptr, &target->imageAvailableSemaphore);
vkCreateSemaphore(device_, &semaphoreCreateInfo, nullptr, &target->renderFinishedSemaphore);
VkFenceCreateInfo fenceCreateInfo = {};
fenceCreateInfo.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
fenceCreateInfo.flags = VK_FENCE_CREATE_SIGNALED_BIT;
target->fences = new VkFence[swapchainImageCount];
for(uint32_t i = 0; i < swapchainImageCount; i++)
vkCreateFence(device_, &fenceCreateInfo, nullptr, &target->fences[i]);
@ -230,36 +230,36 @@ RenderTarget* Renderer::createSurfaceRenderTarget(VkSurfaceKHR surface, RenderTa
void Renderer::destroyRenderTarget(RenderTarget* target) {
vkDeviceWaitIdle(device_);
for(uint32_t i = 0; i < target->numImages; i++)
vkDestroyFence(device_, target->fences[i], nullptr);
delete[] target->fences;
vkDestroySemaphore(device_, target->renderFinishedSemaphore, nullptr);
vkDestroySemaphore(device_, target->imageAvailableSemaphore, nullptr);
vkFreeCommandBuffers(device_, commandPool_, target->numImages, target->commandBuffers);
delete[] target->commandBuffers;
for(uint32_t i = 0; i < target->numImages; i++) {
vkDestroyFramebuffer(device_, target->framebuffers[i], nullptr);
vkDestroyImageView(device_, target->imageViews[i], nullptr);
}
delete[] target->framebuffers;
delete[] target->imageViews;
delete[] target->images;
vkDestroySwapchainKHR(device_, target->swapchain, nullptr);
delete target;
}
VkShaderModule Renderer::createShader(const char* path) {
std::ifstream file(path, std::ios::ate | std::ios::binary);
size_t fileSize = (size_t) file.tellg();
std::vector<char> buffer(fileSize);
file.seekg(0);
@ -280,10 +280,10 @@ VkShaderModule Renderer::createShader(const char* path) {
void Renderer::createInstance() {
uint32_t layerCount = 0;
vkEnumerateInstanceLayerProperties(&layerCount, nullptr);
VkLayerProperties* availableLayers = new VkLayerProperties[layerCount];
vkEnumerateInstanceLayerProperties(&layerCount, availableLayers);
std::vector<const char*> enabledLayers;
#ifdef DEBUG
for(uint32_t i = 0; i < layerCount; i++) {
@ -293,10 +293,10 @@ void Renderer::createInstance() {
#endif
delete[] availableLayers;
uint32_t extensionCount = 0;
vkEnumerateInstanceExtensionProperties(nullptr, &extensionCount, nullptr);
VkExtensionProperties* availableExtensions = new VkExtensionProperties[extensionCount];
vkEnumerateInstanceExtensionProperties(nullptr, &extensionCount, availableExtensions);
@ -311,7 +311,7 @@ void Renderer::createInstance() {
#endif
delete[] availableExtensions;
auto requiredExtensions = platform::getRequiredExtensions();
enabledExtensions.insert(enabledExtensions.end(), requiredExtensions.begin(), requiredExtensions.end());
@ -321,7 +321,7 @@ void Renderer::createInstance() {
instanceCreateInfo.ppEnabledLayerNames = enabledLayers.data();
instanceCreateInfo.enabledExtensionCount = enabledExtensions.size();
instanceCreateInfo.ppEnabledExtensionNames = enabledExtensions.data();
vkCreateInstance(&instanceCreateInfo, nullptr, &instance_);
}
@ -336,10 +336,10 @@ void Renderer::createDebugMessenger() {
messengerCreateInfo.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;
messengerCreateInfo.pfnUserCallback = [](VkDebugUtilsMessageSeverityFlagBitsEXT, unsigned int, const VkDebugUtilsMessengerCallbackDataEXT* callback, void*) -> unsigned int {
std::cout << callback->pMessage << std::endl;
return VK_SUCCESS;
};
createMessenger_(instance_, &messengerCreateInfo, nullptr, &messenger_);
}
#endif
@ -347,59 +347,59 @@ void Renderer::createDebugMessenger() {
void Renderer::createLogicalDevice() {
uint32_t physicalDeviceCount = 0;
vkEnumeratePhysicalDevices(instance_, &physicalDeviceCount, nullptr);
VkPhysicalDevice* physicalDevices = new VkPhysicalDevice[physicalDeviceCount];
vkEnumeratePhysicalDevices(instance_, &physicalDeviceCount, physicalDevices);
for(uint32_t i = 0; i < physicalDeviceCount; i++) {
VkPhysicalDeviceProperties properties = {};
vkGetPhysicalDeviceProperties(physicalDevices[i], &properties);
physicalDevice_ = physicalDevices[i];
}
delete[] physicalDevices;
uint32_t queueFamilyPropertiesCount = 0;
vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice_, &queueFamilyPropertiesCount, nullptr);
VkQueueFamilyProperties* queueFamilyProperties = new VkQueueFamilyProperties[queueFamilyPropertiesCount];
vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice_, &queueFamilyPropertiesCount, queueFamilyProperties);
for(uint32_t i = 0; i < queueFamilyPropertiesCount; i++) {
if(queueFamilyProperties[i].queueFlags & VK_QUEUE_GRAPHICS_BIT)
queueIndices.graphics = i;
}
delete[] queueFamilyProperties;
queueIndices.presentation = queueIndices.graphics; //FIXME: this may not always be true!!
const std::set<uint32_t> queueFamilyIndices = {queueIndices.graphics};
std::vector<VkDeviceQueueCreateInfo> deviceQueueCreateInfos;
for(auto queueFamilyIndex : queueFamilyIndices) {
const float priority = 1.0f;
VkDeviceQueueCreateInfo queueCreateInfo = {};
queueCreateInfo.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
queueCreateInfo.queueFamilyIndex = queueFamilyIndex;
queueCreateInfo.queueCount = 1;
queueCreateInfo.pQueuePriorities = &priority;
deviceQueueCreateInfos.push_back(queueCreateInfo);
}
const std::vector<const char*> enabledExtensions = {"VK_KHR_swapchain"};
VkDeviceCreateInfo deviceCreateInfo = {};
deviceCreateInfo.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
deviceCreateInfo.queueCreateInfoCount = deviceQueueCreateInfos.size();
deviceCreateInfo.pQueueCreateInfos = deviceQueueCreateInfos.data();
deviceCreateInfo.enabledExtensionCount = enabledExtensions.size();
deviceCreateInfo.ppEnabledExtensionNames = enabledExtensions.data();
vkCreateDevice(physicalDevice_, &deviceCreateInfo, nullptr, &device_);
vkGetDeviceQueue(device_, queueIndices.graphics, 0, &graphicsQueue_);
}
@ -408,7 +408,7 @@ void Renderer::createCommandPool() {
poolCreateInfo.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
poolCreateInfo.queueFamilyIndex = queueIndices.graphics;
poolCreateInfo.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT;
vkCreateCommandPool(device_, &poolCreateInfo, nullptr, &commandPool_);
}