diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 0000000..8ada963 --- /dev/null +++ b/.gitattributes @@ -0,0 +1 @@ +*.db filter=lfs diff=lfs merge=lfs -text diff --git a/CMakeLists.txt b/CMakeLists.txt index cce7326..5ad6704 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -5,9 +5,11 @@ set(CMAKE_CXX_STANDARD 17) add_subdirectory(external/glfw) add_subdirectory(external/glm) +add_subdirectory(external/tinygltf) find_package(Vulkan REQUIRED) add_executable(acg_in_gd_lab src/main.cpp) target_link_libraries(acg_in_gd_lab PRIVATE glfw glm::glm ${Vulkan_LIBRARIES}) +target_link_libraries(acg_in_gd_lab PRIVATE tinygltf) target_include_directories(acg_in_gd_lab PRIVATE ${Vulkan_INCLUDE_DIR}) \ No newline at end of file diff --git a/compile_shaders.sh b/compile_shaders.sh index e1c33a1..11319be 100755 --- a/compile_shaders.sh +++ b/compile_shaders.sh @@ -3,4 +3,5 @@ set -ex glslc shaders/shader.vert -o shaders/vert.spv -glslc shaders/shader.frag -o shaders/frag.spv \ No newline at end of file +glslc shaders/shader.frag -o shaders/frag.spv +glslangValidator -V FilmicAnamorphSharpen.fx -o FilmicAnamorphSharpen.spv \ No newline at end of file diff --git a/shaders/FilmicAnamorphSharpen.fx b/shaders/FilmicAnamorphSharpen.fx new file mode 100644 index 0000000..cca71fe --- /dev/null +++ b/shaders/FilmicAnamorphSharpen.fx @@ -0,0 +1,306 @@ +/*------------------. +| :: Description :: | +'-------------------/ + +Filmic Anamorph Sharpen PS (version 1.5.0) + +Copyright: +This code © 2018-2023 Jakub Maximilian Fober +Some changes by ccritchfield https://github.com/ccritchfield + +License: +This work is licensed under the Creative Commons +Attribution-ShareAlike 4.0 International License. +To view a copy of this license, visit +http://creativecommons.org/licenses/by-sa/4.0/ +*/ + +/*--------------. +| :: Commons :: | +'--------------*/ + +#include "ReShade.fxh" +#include "ReShadeUI.fxh" +#include "ColorConversion.fxh" +#include "LinearGammaWorkflow.fxh" + +/*-----------. +| :: Menu :: | +'-----------*/ + +uniform float Strength +< __UNIFORM_SLIDER_FLOAT1 + ui_label = "Strength"; + ui_min = 0.0; ui_max = 100.0; ui_step = 0.01; +> = 60.0; + +uniform float Offset +< __UNIFORM_SLIDER_FLOAT1 + ui_units = " pixel"; + ui_label = "Radius"; + ui_tooltip = "High-pass cross offset in pixels"; + ui_min = 0.0; ui_max = 2.0; ui_step = 0.01; +> = 0.1; + +uniform float Clamp +< __UNIFORM_SLIDER_FLOAT1 + ui_label = "Clamping"; + ui_min = 0.5; ui_max = 1.0; ui_step = 0.001; +> = 0.65; + +uniform bool UseMask +< __UNIFORM_INPUT_BOOL1 + ui_label = "Sharpen only center"; + ui_tooltip = "Sharpen only in center of the image"; +> = false; + +uniform bool DepthMask +< __UNIFORM_INPUT_BOOL1 + ui_label = "Enable depth rim masking"; + ui_tooltip = "Depth high-pass mask switch"; + ui_category = "Depth mask"; + ui_category_closed = true; +> = false; + +uniform int DepthMaskContrast +< __UNIFORM_DRAG_INT1 + ui_label = "Edges mask strength"; + ui_tooltip = "Depth high-pass mask amount"; + ui_category = "Depth mask"; + ui_min = 0; ui_max = 2000; ui_step = 1; +> = 128; + +uniform bool Preview +< __UNIFORM_INPUT_BOOL1 + ui_label = "Preview sharpen layer"; + ui_tooltip = "Preview sharpen layer and mask for adjustment.\n" + "If you don't see red strokes,\n" + "try changing Preprocessor Definitions in the Settings tab."; + ui_category = "Debug View"; + ui_category_closed = true; +> = false; + +/*---------------. +| :: Textures :: | +'---------------*/ + +// Define screen texture with mirror tiles +sampler BackBuffer +{ + Texture = ReShade::BackBufferTex; + AddressU = MIRROR; + AddressV = MIRROR; +}; + +/*----------------. +| :: Functions :: | +'----------------*/ + +// Overlay blending mode +float Overlay(float LayerA, float LayerB) +{ + float MinA = min(LayerA, 0.5); + float MinB = min(LayerB, 0.5); + float MaxA = max(LayerA, 0.5); + float MaxB = max(LayerB, 0.5); + return 2f*(MinA*MinB+MaxA+MaxB-MaxA*MaxB)-1.5; +} + +// Overlay blending mode for one input +float Overlay(float LayerAB) +{ + float MinAB = min(LayerAB, 0.5); + float MaxAB = max(LayerAB, 0.5); + return 2f*(MinAB*MinAB+MaxAB+MaxAB-MaxAB*MaxAB)-1.5; +} + +/*--------------. +| :: Shaders :: | +'--------------*/ + +// Sharpen pass +float3 FilmicAnamorphSharpenPS( + float4 pos : SV_Position, + float2 UvCoord : TEXCOORD +) : SV_Target +{ + // Sample display image + float3 Source = GammaConvert::to_linear(tex2D(BackBuffer, UvCoord).rgb); + + // Generate radial mask + float Mask; + if (UseMask) + { + // Generate radial mask + Mask = 1f-length(UvCoord*2f-1f); + Mask = Overlay(Mask) * Strength; + // Bypass + if (Mask<=0) return GammaConvert::to_display(Source); + } + else Mask = Strength; + + // Get pixel size + float2 Pixel = BUFFER_PIXEL_SIZE; + + if (DepthMask) + { + /* + // original + float2 DepthPixel = Pixel*Offset+Pixel; + Pixel *= Offset; + */ + + // !!! calc pixel*offset once, use twice + float2 PixelOffset = Pixel * Offset; + float2 DepthPixel = PixelOffset + Pixel; + Pixel = PixelOffset; + + // Sample display depth image + float SourceDepth = ReShade::GetLinearizedDepth(UvCoord); + + float2 NorSouWesEst[4] = { + float2(UvCoord.x, UvCoord.y + Pixel.y), + float2(UvCoord.x, UvCoord.y - Pixel.y), + float2(UvCoord.x + Pixel.x, UvCoord.y), + float2(UvCoord.x - Pixel.x, UvCoord.y) + }; + + float2 DepthNorSouWesEst[4] = { + float2(UvCoord.x, UvCoord.y + DepthPixel.y), + float2(UvCoord.x, UvCoord.y - DepthPixel.y), + float2(UvCoord.x + DepthPixel.x, UvCoord.y), + float2(UvCoord.x - DepthPixel.x, UvCoord.y) + }; + + // Luma high-pass color + // Luma high-pass depth + float HighPassColor = 0f, DepthMask = 0f; + + [unroll]for(int s=0; s<4; s++) + { + HighPassColor += + ColorConvert::RGB_to_Luma( + GammaConvert::to_linear( + tex2D(BackBuffer, NorSouWesEst[s]).rgb + )); + DepthMask += + ReShade::GetLinearizedDepth(NorSouWesEst[s]) + +ReShade::GetLinearizedDepth(DepthNorSouWesEst[s]); + } + + HighPassColor = 0.5-0.5*(HighPassColor*0.25-ColorConvert::RGB_to_Luma(Source)); + + DepthMask = 1f-DepthMask*0.125+SourceDepth; + DepthMask = min(1f, DepthMask)+1f-max(1f, DepthMask); + DepthMask = saturate(DepthMaskContrast*DepthMask+1f-DepthMaskContrast); + + // Sharpen strength + HighPassColor = lerp(0.5, HighPassColor, Mask*DepthMask); + + // Clamping sharpen + /* + // original + HighPassColor = Clamp!=1f ? max(min(HighPassColor, Clamp), 1f-Clamp) : HighPassColor; + */ + + // !!! Clamp in settings above is restricted to 0.5 to 1.0 + // !!! 1.0 - Clamp is the low value, while Clamp is the high value + // !!! so we can literally just use the clamp() func instead of min/max. + // !!! not sure if author was trying to take advantage of some kind of + // !!! compiler "cheat" using min/max instead of clamp to improve + // !!! performance. doesn't make sense to min/max otherwise. + HighPassColor = Clamp!=1f ? clamp(HighPassColor, 1f-Clamp, Clamp ) : HighPassColor; + + float3 Sharpen = float3( + Overlay(Source.r, HighPassColor), + Overlay(Source.g, HighPassColor), + Overlay(Source.b, HighPassColor) + ); + + if(Preview) // Preview mode ON + { + float PreviewChannel = lerp(HighPassColor, HighPassColor*DepthMask, 0.5); + return + GammaConvert::to_display(float3( + 1f-DepthMask * (1f-HighPassColor), + PreviewChannel, + PreviewChannel + )); + } + + return GammaConvert::to_display(Sharpen); + } + else + { + Pixel *= Offset; + + float2 NorSouWesEst[4] = { + float2(UvCoord.x, UvCoord.y + Pixel.y), + float2(UvCoord.x, UvCoord.y - Pixel.y), + float2(UvCoord.x + Pixel.x, UvCoord.y), + float2(UvCoord.x - Pixel.x, UvCoord.y) + }; + + // Luma high-pass color + float HighPassColor = 0f; + [unroll] for(uint s=0u; s<4u; s++) + HighPassColor += + ColorConvert::RGB_to_Luma( + GammaConvert::to_linear( + tex2D(BackBuffer, NorSouWesEst[s]).rgb + )); + + // !!! added space above to make it more obvious + // !!! that loop is now a one-liner in this else branch + // !!! where-as loop in branch above was multi-part + HighPassColor = 0.5-0.5*(HighPassColor*0.25-ColorConvert::RGB_to_Luma(Source)); + + // Sharpen strength + HighPassColor = lerp(0.5, HighPassColor, Mask); + + // Clamping sharpen + /* + // original + HighPassColor = Clamp!=1f ? max(min(HighPassColor, Clamp), 1f-Clamp) : HighPassColor; + */ + + // !!! Clamp in settings above is restricted to 0.5 to 1.0 + // !!! 1.0 - Clamp is the low value, while Clamp is the high value + // !!! so we can literally just use the clamp() func instead of min/max. + // !!! not sure if author was trying to take advantage of some kind of + // !!! compiler "cheat" using min/max instead of clamp to improve + // !!! performance. doesn't make sense to min/max otherwise. + HighPassColor = Clamp!=1f ? clamp(HighPassColor, 1f-Clamp, Clamp) : HighPassColor; + + float3 Sharpen = float3( + Overlay(Source.r, HighPassColor), + Overlay(Source.g, HighPassColor), + Overlay(Source.b, HighPassColor) + ); + + return GammaConvert::to_display( + Preview // preview mode ON + ? HighPassColor + : Sharpen + ); + } +} + +/*-------------. +| :: Output :: | +'-------------*/ + +technique FilmicAnamorphSharpen +< + ui_label = "Filmic Anamorphic Sharpen"; + ui_tooltip = + "This effect © 2018-2023 Jakub Maksymilian Fober\n" + "Licensed under CC BY-SA 4.0"; +> +{ + pass + { + VertexShader = PostProcessVS; + PixelShader = FilmicAnamorphSharpenPS; + } +} diff --git a/src/main.cpp b/src/main.cpp index cb94d33..253cc24 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -1,4 +1,7 @@ #define GLFW_INCLUDE_VULKAN +#define TINYGLTF_IMPLEMENTATION +#define STB_IMAGE_IMPLEMENTATION +#define STB_IMAGE_WRITE_IMPLEMENTATION #include @@ -11,23 +14,52 @@ #include #include #include +#define TINYGLTF_IMPLEMENTATION +#define STB_IMAGE_IMPLEMENTATION +#include "tiny_gltf.h" + +using namespace tinygltf; +bool load_gltf() { + Model model; + TinyGLTF loader; + std::string err; + std::string warn; + + bool ret = loader.LoadASCIIFromFile(&model, &err, &warn, "models/Models/BrainStem/glTF/BrainStem.gltf"); // YOUR GLTF HERE + //bool ret = loader.LoadBinaryFromFile(&model, &err, &warn, argv[1]); // for binary glTF(.glb) + + if (!warn.empty()) { + printf("Warn: %s\n", warn.c_str()); + } + + if (!err.empty()) { + printf("Err: %s\n", err.c_str()); + } + + if (!ret) { + printf("Failed to parse glTF\n"); + return -1; + } -VkResult CreateDebugUtilsMessengerEXT(VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT *pCreateInfo, - const VkAllocationCallbacks *pAllocator, - VkDebugUtilsMessengerEXT *pDebugMessenger) { - auto func = (PFN_vkCreateDebugUtilsMessengerEXT) vkGetInstanceProcAddr(instance, "vkCreateDebugUtilsMessengerEXT"); +} + +VkResult CreateDebugUtilsMessengerEXT(VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDebugUtilsMessengerEXT* pDebugMessenger) { + auto func = (PFN_vkCreateDebugUtilsMessengerEXT)vkGetInstanceProcAddr(instance, "vkCreateDebugUtilsMessengerEXT"); if (func != nullptr) { return func(instance, pCreateInfo, pAllocator, pDebugMessenger); - } else { + } + else { return VK_ERROR_EXTENSION_NOT_PRESENT; } } void DestroyDebugUtilsMessengerEXT(VkInstance instance, VkDebugUtilsMessengerEXT debugMessenger, - const VkAllocationCallbacks *pAllocator) { - auto func = (PFN_vkDestroyDebugUtilsMessengerEXT) vkGetInstanceProcAddr(instance, - "vkDestroyDebugUtilsMessengerEXT"); + const VkAllocationCallbacks* pAllocator) { + auto func = (PFN_vkDestroyDebugUtilsMessengerEXT)vkGetInstanceProcAddr(instance, + "vkDestroyDebugUtilsMessengerEXT"); if (func != nullptr) { func(instance, debugMessenger, pAllocator); } @@ -54,13 +86,13 @@ struct SwapChainSupportDetails { VkSurfaceFormatKHR chooseSwapSurfaceFormat() { for (const auto& format : formats) { if (format.format == VK_FORMAT_B8G8R8A8_SRGB && - format.colorSpace == VK_COLOR_SPACE_SRGB_NONLINEAR_KHR) { + format.colorSpace == VK_COLOR_SPACE_SRGB_NONLINEAR_KHR) { return format; } } if (!formats.empty()) return formats[0]; - return {VK_FORMAT_UNDEFINED, VK_COLOR_SPACE_MAX_ENUM_KHR}; + return { VK_FORMAT_UNDEFINED, VK_COLOR_SPACE_MAX_ENUM_KHR }; } VkPresentModeKHR chooseSwapPresentMode() { @@ -73,23 +105,23 @@ struct SwapChainSupportDetails { return VK_PRESENT_MODE_IMMEDIATE_KHR; } - VkExtent2D chooseSwapExtent(GLFWwindow *window) { + VkExtent2D chooseSwapExtent(GLFWwindow* window) { if (capabilities.currentExtent.width != std::numeric_limits::max()) { return capabilities.currentExtent; } int width, height; glfwGetFramebufferSize(window, &width, &height); - VkExtent2D actualExtent { + VkExtent2D actualExtent{ static_cast(width), static_cast(height) }; actualExtent.width = std::clamp(actualExtent.width, - capabilities.minImageExtent.width, - capabilities.maxImageExtent.width); + capabilities.minImageExtent.width, + capabilities.maxImageExtent.width); actualExtent.height = std::clamp(actualExtent.height, - capabilities.minImageExtent.height, - capabilities.maxImageExtent.height); + capabilities.minImageExtent.height, + capabilities.maxImageExtent.height); return actualExtent; } @@ -103,7 +135,7 @@ struct SwapChainSupportDetails { }; -static std::vector readFile(const std::filesystem::path & filepath) { +static std::vector readFile(const std::filesystem::path& filepath) { std::ifstream file(filepath, std::ios::ate | std::ios::binary); if (!file.is_open()) { throw std::runtime_error(std::string("failed to open a file: ") + filepath.string()); @@ -124,11 +156,11 @@ private: const int HEIGHT = 600; const std::string appName = "Vulkan on MacOS"; const std::string engineName = "The Best Engine"; - const std::vector deviceExtensions = { + const std::vector deviceExtensions = { VK_KHR_SWAPCHAIN_EXTENSION_NAME, "VK_KHR_portability_subset", }; - const std::vector validationLayers = { + const std::vector validationLayers = { "VK_LAYER_KHRONOS_validation" }; @@ -138,7 +170,7 @@ private: const bool enableValidationLayers = true; #endif - GLFWwindow *window = nullptr; + GLFWwindow* window = nullptr; VkInstance instance = VK_NULL_HANDLE; VkDebugUtilsMessengerEXT debugMessenger = VK_NULL_HANDLE; @@ -166,6 +198,7 @@ public: void run() { initWindow(); initVulkan(); + mainLoop(); cleanup(); } @@ -178,9 +211,9 @@ private: glfwWindowHint(GLFW_RESIZABLE, GLFW_FALSE); window = glfwCreateWindow( - WIDTH, HEIGHT, - appName.c_str(), - nullptr, nullptr); + WIDTH, HEIGHT, + appName.c_str(), + nullptr, nullptr); } void initVulkan() { @@ -205,9 +238,9 @@ private: std::vector availableLayers(layerCount); vkEnumerateInstanceLayerProperties(&layerCount, availableLayers.data()); - for (const auto &layerName: validationLayers) { + for (const auto& layerName : validationLayers) { bool layerFound = false; - for (const auto &layerProperties: availableLayers) { + for (const auto& layerProperties : availableLayers) { if (strcmp(layerName, layerProperties.layerName) == 0) { layerFound = true; break; @@ -220,12 +253,12 @@ private: return true; } - std::vector getRequiredExtensions() const { + std::vector getRequiredExtensions() const { uint32_t glfwExtensionCount = 0; - const char **glfwExtensions; + const char** glfwExtensions; glfwExtensions = glfwGetRequiredInstanceExtensions(&glfwExtensionCount); - std::vector extensions(glfwExtensions, glfwExtensions + glfwExtensionCount); + std::vector extensions(glfwExtensions, glfwExtensions + glfwExtensionCount); if (enableValidationLayers) { extensions.push_back(VK_EXT_DEBUG_UTILS_EXTENSION_NAME); @@ -237,15 +270,15 @@ private: return extensions; } - static void populateDebugMessengerCreateInfo(VkDebugUtilsMessengerCreateInfoEXT &createInfo) { + static void populateDebugMessengerCreateInfo(VkDebugUtilsMessengerCreateInfoEXT& createInfo) { createInfo = {}; createInfo.sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT; createInfo.messageSeverity = - VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT | - VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT; + VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT | + VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT; createInfo.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; + VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT | + VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT; createInfo.pfnUserCallback = debugCallback; } @@ -291,17 +324,17 @@ private: vkEnumerateInstanceExtensionProperties(nullptr, &extensionCount, extensions.data()); std::cout << "available extensions:\n"; - for (const auto &extension: extensions) { + for (const auto& extension : extensions) { std::cout << '\t' << extension.extensionName << '\n'; } } static VKAPI_ATTR VkBool32 VKAPI_CALL debugCallback( - VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, - VkDebugUtilsMessageTypeFlagsEXT messageType, - const VkDebugUtilsMessengerCallbackDataEXT *pCallbackData, - void *pUserData) { + VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, + VkDebugUtilsMessageTypeFlagsEXT messageType, + const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData, + void* pUserData) { std::cerr << "validation layer: " << pCallbackData->pMessage << std::endl; @@ -377,10 +410,10 @@ private: bool checkDeviceExtensionSupport(VkPhysicalDevice dev) { uint32_t extensionCount; vkEnumerateDeviceExtensionProperties(dev, nullptr, - &extensionCount, nullptr); + &extensionCount, nullptr); std::vector availableExtensions(extensionCount); vkEnumerateDeviceExtensionProperties(dev, nullptr, - &extensionCount, availableExtensions.data()); + &extensionCount, availableExtensions.data()); std::set requiredExtensions(deviceExtensions.begin(), deviceExtensions.end()); for (const auto& extension : availableExtensions) { @@ -414,9 +447,9 @@ private: } std::cout << ", swapchain is not empty: " << swapChainAdequate << "\n"; return hasQueues && isSupportExtensions && swapChainAdequate; - }; + }; - for (const auto &dev: devices) { + for (const auto& dev : devices) { if (isDeviceSuitable(dev)) { physicalDevice = dev; break; @@ -438,7 +471,7 @@ private: std::vector queueCreateInfos; float queuePriority = 1.0f; - for (uint32_t queueFamily : uniqueQueueFamilies){ + for (uint32_t queueFamily : uniqueQueueFamilies) { VkDeviceQueueCreateInfo queueCreateInfo{}; queueCreateInfo.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO; queueCreateInfo.queueFamilyIndex = queueFamily; @@ -493,7 +526,7 @@ private: createInfo.oldSwapchain = VK_NULL_HANDLE; QueueFamilyIndices indices = findQueueFamilies(physicalDevice); - uint32_t queueFamilyIndices[] = {indices.graphicsFamily.value(), indices.presentFamily.value()}; + uint32_t queueFamilyIndices[] = { indices.graphicsFamily.value(), indices.presentFamily.value() }; if (indices.graphicsFamily != indices.presentFamily) { createInfo.imageSharingMode = VK_SHARING_MODE_CONCURRENT; createInfo.queueFamilyIndexCount = 2; @@ -585,7 +618,7 @@ private: renderPassInfo.dependencyCount = 1; renderPassInfo.pDependencies = &dependency; - if(vkCreateRenderPass(device, &renderPassInfo, nullptr, &renderPass) != VK_SUCCESS) { + if (vkCreateRenderPass(device, &renderPassInfo, nullptr, &renderPass) != VK_SUCCESS) { throw std::runtime_error("failed to create a render pass"); } } @@ -593,7 +626,7 @@ private: void createGraphicsPipeline() { auto vertShaderCode = readFile("shaders/vert.spv"); auto fragShaderCode = readFile("shaders/frag.spv"); - + VkShaderModule vertShaderModule = createShaderModule(vertShaderCode); VkShaderModule fragShaderModule = createShaderModule(fragShaderCode); @@ -610,8 +643,8 @@ private: fragShaderStageInfo.pName = "main"; std::vector shaderStages = { - vertShaderStageInfo, - fragShaderStageInfo + vertShaderStageInfo, + fragShaderStageInfo, }; VkPipelineVertexInputStateCreateInfo vertexInputState{}; @@ -777,9 +810,9 @@ private: renderPassInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO; renderPassInfo.renderPass = renderPass; renderPassInfo.framebuffer = swapChainFramebuffers[imageIndex]; - renderPassInfo.renderArea.offset = {0, 0}; + renderPassInfo.renderArea.offset = { 0, 0 }; renderPassInfo.renderArea.extent = swapChainExtent; - VkClearValue clearColor = {{{0.0f, 0.0f, 0.4f, 1.0f}}}; + VkClearValue clearColor = { {{0.0f, 0.0f, 0.4f, 1.0f}} }; renderPassInfo.clearValueCount = 1; renderPassInfo.pClearValues = &clearColor; @@ -796,7 +829,7 @@ private: vkCmdSetViewport(commandBuffer, 0, 1, &viewport); VkRect2D scissor{}; - scissor.offset = {0, 0}; + scissor.offset = { 0, 0 }; scissor.extent = swapChainExtent; vkCmdSetScissor(commandBuffer, 0, 1, &scissor); @@ -822,10 +855,10 @@ private: VkSubmitInfo submitInfo{}; submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO; - std::vector waitSemaphores = {imageAvailableSemaphore}; - std::vector waitStages = {VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT}; - std::vector commandBuffers = {commandBuffer}; - std::vector signalSemaphores = {renderFinishedSemaphore}; + std::vector waitSemaphores = { imageAvailableSemaphore }; + std::vector waitStages = { VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT }; + std::vector commandBuffers = { commandBuffer }; + std::vector signalSemaphores = { renderFinishedSemaphore }; submitInfo.waitSemaphoreCount = waitSemaphores.size(); submitInfo.pWaitSemaphores = waitSemaphores.data(); submitInfo.pWaitDstStageMask = waitStages.data(); @@ -844,7 +877,7 @@ private: presentInfo.waitSemaphoreCount = signalSemaphores.size(); presentInfo.pWaitSemaphores = signalSemaphores.data(); - std::vector swapChains = {swapChain}; + std::vector swapChains = { swapChain }; presentInfo.swapchainCount = swapChains.size(); presentInfo.pSwapchains = swapChains.data(); presentInfo.pImageIndices = &imageIndex; @@ -895,7 +928,8 @@ int main() { try { app.run(); - } catch (const std::exception &e) { + } + catch (const std::exception& e) { std::cerr << e.what() << std::endl; return EXIT_FAILURE; }