init
This commit is contained in:
@@ -0,0 +1,968 @@
|
||||
/* Copyright (c) 2021-2025, NVIDIA CORPORATION. All rights reserved.
|
||||
* Copyright (c) 2024-2025, Arm Limited and Contributors
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 the "License";
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
#include "hpp_hello_triangle.h"
|
||||
|
||||
#include <common/hpp_error.h>
|
||||
#include <common/hpp_vk_common.h>
|
||||
#include <core/util/logging.hpp>
|
||||
#include <filesystem/legacy.h>
|
||||
#include <platform/window.h>
|
||||
|
||||
// Note: the default dispatcher is instantiated in hpp_api_vulkan_sample.cpp.
|
||||
// Even though, that file is not part of this sample, it's part of the sample-project!
|
||||
|
||||
#if defined(VKB_DEBUG) || defined(VKB_VALIDATION_LAYERS)
|
||||
/// @brief A debug callback called from Vulkan validation layers.
|
||||
VKAPI_ATTR vk::Bool32 VKAPI_CALL debug_utils_messenger_callback(vk::DebugUtilsMessageSeverityFlagBitsEXT message_severity,
|
||||
vk::DebugUtilsMessageTypeFlagsEXT message_type,
|
||||
const vk::DebugUtilsMessengerCallbackDataEXT *callback_data,
|
||||
void *user_data)
|
||||
{
|
||||
// Log debug message
|
||||
if (message_severity & vk::DebugUtilsMessageSeverityFlagBitsEXT::eWarning)
|
||||
{
|
||||
LOGW("{} - {}: {}", callback_data->messageIdNumber, callback_data->pMessageIdName, callback_data->pMessage);
|
||||
}
|
||||
else if (message_severity & vk::DebugUtilsMessageSeverityFlagBitsEXT::eError)
|
||||
{
|
||||
LOGE("{} - {}: {}", callback_data->messageIdNumber, callback_data->pMessageIdName, callback_data->pMessage);
|
||||
}
|
||||
return VK_FALSE;
|
||||
}
|
||||
#endif
|
||||
|
||||
/**
|
||||
* @brief Validates a list of required extensions, comparing it with the available ones.
|
||||
*
|
||||
* @param required A vector containing required extension names.
|
||||
* @param available A vk::ExtensionProperties object containing available extensions.
|
||||
* @return true if all required extensions are available
|
||||
* @return false otherwise
|
||||
*/
|
||||
bool validate_extensions(const std::vector<const char *> &required,
|
||||
const std::vector<vk::ExtensionProperties> &available)
|
||||
{
|
||||
// inner find_if gives true if the extension was not found
|
||||
// outer find_if gives true if none of the extensions were not found, that is if all extensions were found
|
||||
return std::ranges::find_if(required,
|
||||
[&available](auto extension) {
|
||||
return std::ranges::find_if(available,
|
||||
[&extension](auto const &ep) {
|
||||
return strcmp(ep.extensionName, extension) == 0;
|
||||
}) == available.end();
|
||||
}) == required.end();
|
||||
}
|
||||
|
||||
HPPHelloTriangle::HPPHelloTriangle()
|
||||
{
|
||||
}
|
||||
|
||||
HPPHelloTriangle::~HPPHelloTriangle()
|
||||
{
|
||||
// Don't release anything until the GPU is completely idle.
|
||||
device.waitIdle();
|
||||
|
||||
teardown_framebuffers();
|
||||
|
||||
for (auto &pfd : per_frame_data)
|
||||
{
|
||||
teardown_per_frame(pfd);
|
||||
}
|
||||
|
||||
per_frame_data.clear();
|
||||
|
||||
for (auto semaphore : recycled_semaphores)
|
||||
{
|
||||
device.destroySemaphore(semaphore);
|
||||
}
|
||||
|
||||
if (pipeline)
|
||||
{
|
||||
device.destroyPipeline(pipeline);
|
||||
}
|
||||
|
||||
if (pipeline_layout)
|
||||
{
|
||||
device.destroyPipelineLayout(pipeline_layout);
|
||||
}
|
||||
|
||||
if (render_pass)
|
||||
{
|
||||
device.destroyRenderPass(render_pass);
|
||||
}
|
||||
|
||||
for (auto image_view : swapchain_data.image_views)
|
||||
{
|
||||
device.destroyImageView(image_view);
|
||||
}
|
||||
|
||||
if (swapchain_data.swapchain)
|
||||
{
|
||||
device.destroySwapchainKHR(swapchain_data.swapchain);
|
||||
}
|
||||
|
||||
if (surface)
|
||||
{
|
||||
instance.destroySurfaceKHR(surface);
|
||||
}
|
||||
|
||||
if (vertex_buffer_allocation != VK_NULL_HANDLE)
|
||||
{
|
||||
vmaDestroyBuffer(vma_allocator, vertex_buffer, vertex_buffer_allocation);
|
||||
}
|
||||
|
||||
if (vma_allocator != VK_NULL_HANDLE)
|
||||
{
|
||||
vmaDestroyAllocator(vma_allocator);
|
||||
}
|
||||
|
||||
if (device)
|
||||
{
|
||||
device.destroy();
|
||||
}
|
||||
|
||||
if (debug_utils_messenger)
|
||||
{
|
||||
instance.destroyDebugUtilsMessengerEXT(debug_utils_messenger);
|
||||
}
|
||||
|
||||
instance.destroy();
|
||||
}
|
||||
|
||||
bool HPPHelloTriangle::prepare(const vkb::ApplicationOptions &options)
|
||||
{
|
||||
// Headless is not supported to keep this sample as simple as possible
|
||||
assert(options.window != nullptr);
|
||||
assert(options.window->get_window_mode() != vkb::Window::Mode::Headless);
|
||||
|
||||
if (Application::prepare(options))
|
||||
{
|
||||
instance = create_instance({VK_KHR_SURFACE_EXTENSION_NAME}, {});
|
||||
#if defined(VKB_DEBUG) || defined(VKB_VALIDATION_LAYERS)
|
||||
debug_utils_messenger = instance.createDebugUtilsMessengerEXT(debug_utils_create_info);
|
||||
#endif
|
||||
|
||||
select_physical_device_and_surface();
|
||||
|
||||
const vkb::Window::Extent &extent = options.window->get_extent();
|
||||
swapchain_data.extent.width = extent.width;
|
||||
swapchain_data.extent.height = extent.height;
|
||||
|
||||
// create a device
|
||||
device = create_device({VK_KHR_SWAPCHAIN_EXTENSION_NAME});
|
||||
|
||||
// get the (graphics) queue
|
||||
queue = device.getQueue(graphics_queue_index, 0);
|
||||
|
||||
vma_allocator = create_vma_allocator();
|
||||
std::tie(vertex_buffer, vertex_buffer_allocation) = create_vertex_buffer();
|
||||
|
||||
init_swapchain();
|
||||
|
||||
// Create the necessary objects for rendering.
|
||||
render_pass = create_render_pass();
|
||||
|
||||
// Create a blank pipeline layout.
|
||||
// We are not binding any resources to the pipeline in this first sample.
|
||||
pipeline_layout = device.createPipelineLayout({});
|
||||
|
||||
pipeline = create_graphics_pipeline();
|
||||
|
||||
init_framebuffers();
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
void HPPHelloTriangle::update(float delta_time)
|
||||
{
|
||||
vk::Result res;
|
||||
uint32_t index;
|
||||
std::tie(res, index) = acquire_next_image();
|
||||
|
||||
// Handle outdated error in acquire.
|
||||
if (res == vk::Result::eSuboptimalKHR || res == vk::Result::eErrorOutOfDateKHR)
|
||||
{
|
||||
resize(swapchain_data.extent.width, swapchain_data.extent.height);
|
||||
std::tie(res, index) = acquire_next_image();
|
||||
}
|
||||
|
||||
if (res != vk::Result::eSuccess)
|
||||
{
|
||||
queue.waitIdle();
|
||||
return;
|
||||
}
|
||||
|
||||
render_triangle(index);
|
||||
|
||||
// Present swapchain image
|
||||
vk::PresentInfoKHR present_info{.waitSemaphoreCount = 1,
|
||||
.pWaitSemaphores = &per_frame_data[index].swapchain_release_semaphore,
|
||||
.swapchainCount = 1,
|
||||
.pSwapchains = &swapchain_data.swapchain,
|
||||
.pImageIndices = &index};
|
||||
res = queue.presentKHR(present_info);
|
||||
|
||||
// Handle Outdated error in present.
|
||||
if (res == vk::Result::eSuboptimalKHR || res == vk::Result::eErrorOutOfDateKHR)
|
||||
{
|
||||
resize(swapchain_data.extent.width, swapchain_data.extent.height);
|
||||
}
|
||||
else if (res != vk::Result::eSuccess)
|
||||
{
|
||||
LOGE("Failed to present swapchain image.");
|
||||
}
|
||||
}
|
||||
|
||||
bool HPPHelloTriangle::resize(const uint32_t, const uint32_t)
|
||||
{
|
||||
if (!device)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
vk::SurfaceCapabilitiesKHR surface_properties = gpu.getSurfaceCapabilitiesKHR(surface);
|
||||
|
||||
// Only rebuild the swapchain if the dimensions have changed
|
||||
if (surface_properties.currentExtent == swapchain_data.extent)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
device.waitIdle();
|
||||
teardown_framebuffers();
|
||||
|
||||
init_swapchain();
|
||||
init_framebuffers();
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Acquires an image from the swapchain.
|
||||
* @param[out] image The swapchain index for the acquired image.
|
||||
* @returns Vulkan result code
|
||||
*/
|
||||
std::pair<vk::Result, uint32_t> HPPHelloTriangle::acquire_next_image()
|
||||
{
|
||||
vk::Semaphore acquire_semaphore;
|
||||
if (recycled_semaphores.empty())
|
||||
{
|
||||
acquire_semaphore = device.createSemaphore({});
|
||||
}
|
||||
else
|
||||
{
|
||||
acquire_semaphore = recycled_semaphores.back();
|
||||
recycled_semaphores.pop_back();
|
||||
}
|
||||
|
||||
vk::Result res;
|
||||
uint32_t image;
|
||||
std::tie(res, image) = device.acquireNextImageKHR(swapchain_data.swapchain, UINT64_MAX, acquire_semaphore);
|
||||
|
||||
if (res != vk::Result::eSuccess)
|
||||
{
|
||||
recycled_semaphores.push_back(acquire_semaphore);
|
||||
return {res, image};
|
||||
}
|
||||
|
||||
// If we have outstanding fences for this swapchain image, wait for them to complete first.
|
||||
// After begin frame returns, it is safe to reuse or delete resources which
|
||||
// were used previously.
|
||||
//
|
||||
// We wait for fences which completes N frames earlier, so we do not stall,
|
||||
// waiting for all GPU work to complete before this returns.
|
||||
// Normally, this doesn't really block at all,
|
||||
// since we're waiting for old frames to have been completed, but just in case.
|
||||
if (per_frame_data[image].queue_submit_fence)
|
||||
{
|
||||
(void) device.waitForFences(per_frame_data[image].queue_submit_fence, true, UINT64_MAX);
|
||||
device.resetFences(per_frame_data[image].queue_submit_fence);
|
||||
}
|
||||
|
||||
if (per_frame_data[image].primary_command_pool)
|
||||
{
|
||||
device.resetCommandPool(per_frame_data[image].primary_command_pool);
|
||||
}
|
||||
|
||||
// Recycle the old semaphore back into the semaphore manager.
|
||||
vk::Semaphore old_semaphore = per_frame_data[image].swapchain_acquire_semaphore;
|
||||
|
||||
if (old_semaphore)
|
||||
{
|
||||
recycled_semaphores.push_back(old_semaphore);
|
||||
}
|
||||
|
||||
per_frame_data[image].swapchain_acquire_semaphore = acquire_semaphore;
|
||||
|
||||
return {vk::Result::eSuccess, image};
|
||||
}
|
||||
|
||||
vk::Device HPPHelloTriangle::create_device(const std::vector<const char *> &required_device_extensions)
|
||||
{
|
||||
std::vector<vk::ExtensionProperties> device_extensions = gpu.enumerateDeviceExtensionProperties();
|
||||
|
||||
if (!validate_extensions(required_device_extensions, device_extensions))
|
||||
{
|
||||
throw std::runtime_error("Required device extensions are missing, will try without.");
|
||||
}
|
||||
|
||||
std::vector<const char *> active_device_extensions(required_device_extensions);
|
||||
|
||||
#if (defined(VKB_ENABLE_PORTABILITY))
|
||||
// VK_KHR_portability_subset must be enabled if present in the implementation (e.g on macOS/iOS with beta extensions enabled)
|
||||
if (std::ranges::any_of(device_extensions,
|
||||
[](vk::ExtensionProperties const &extension) { return strcmp(extension.extensionName, VK_KHR_PORTABILITY_SUBSET_EXTENSION_NAME) == 0; }))
|
||||
{
|
||||
active_device_extensions.push_back(VK_KHR_PORTABILITY_SUBSET_EXTENSION_NAME);
|
||||
}
|
||||
#endif
|
||||
|
||||
// Create a device with one queue
|
||||
float queue_priority = 1.0f;
|
||||
vk::DeviceQueueCreateInfo queue_info{.queueFamilyIndex = graphics_queue_index, .queueCount = 1, .pQueuePriorities = &queue_priority};
|
||||
vk::DeviceCreateInfo device_info{.queueCreateInfoCount = 1,
|
||||
.pQueueCreateInfos = &queue_info,
|
||||
.enabledExtensionCount = static_cast<uint32_t>(active_device_extensions.size()),
|
||||
.ppEnabledExtensionNames = active_device_extensions.data()};
|
||||
vk::Device device = gpu.createDevice(device_info);
|
||||
|
||||
// initialize function pointers for device
|
||||
VULKAN_HPP_DEFAULT_DISPATCHER.init(device);
|
||||
|
||||
return device;
|
||||
}
|
||||
|
||||
vk::Pipeline HPPHelloTriangle::create_graphics_pipeline()
|
||||
{
|
||||
// Load our SPIR-V shaders.
|
||||
|
||||
// Samples support different shading languages, all of which are offline compiled to SPIR-V, the shader format that Vulkan uses.
|
||||
// The shading language to load for can be selected via command line
|
||||
std::string shader_folder{""};
|
||||
switch (get_shading_language())
|
||||
{
|
||||
case vkb::ShadingLanguage::HLSL:
|
||||
shader_folder = "hlsl";
|
||||
break;
|
||||
case vkb::ShadingLanguage::SLANG:
|
||||
shader_folder = "slang";
|
||||
break;
|
||||
default:
|
||||
shader_folder = "glsl";
|
||||
}
|
||||
|
||||
std::vector<vk::PipelineShaderStageCreateInfo> shader_stages{
|
||||
{.stage = vk::ShaderStageFlagBits::eVertex, .module = create_shader_module("hello_triangle/" + shader_folder + "/triangle.vert.spv"), .pName = "main"},
|
||||
{.stage = vk::ShaderStageFlagBits::eFragment, .module = create_shader_module("hello_triangle/" + shader_folder + "/triangle.frag.spv"), .pName = "main"}};
|
||||
|
||||
// Define the vertex input binding.
|
||||
vk::VertexInputBindingDescription binding_description{.binding = 0, .stride = sizeof(Vertex), .inputRate = vk::VertexInputRate::eVertex};
|
||||
|
||||
// Define the vertex input attribute.
|
||||
std::array<vk::VertexInputAttributeDescription, 2> attribute_descriptions{
|
||||
{{.location = 0, .binding = 0, .format = vk::Format::eR32G32B32Sfloat, .offset = offsetof(Vertex, position)},
|
||||
{.location = 1, .binding = 0, .format = vk::Format::eR32G32B32Sfloat, .offset = offsetof(Vertex, color)}}};
|
||||
|
||||
// Define the pipeline vertex input.
|
||||
vk::PipelineVertexInputStateCreateInfo vertex_input{
|
||||
.vertexBindingDescriptionCount = 1,
|
||||
.pVertexBindingDescriptions = &binding_description,
|
||||
.vertexAttributeDescriptionCount = static_cast<uint32_t>(attribute_descriptions.size()),
|
||||
.pVertexAttributeDescriptions = attribute_descriptions.data()};
|
||||
|
||||
// Our attachment will write to all color channels, but no blending is enabled.
|
||||
vk::PipelineColorBlendAttachmentState blend_attachment{.colorWriteMask = vk::ColorComponentFlagBits::eR | vk::ColorComponentFlagBits::eG |
|
||||
vk::ColorComponentFlagBits::eB | vk::ColorComponentFlagBits::eA};
|
||||
|
||||
// Disable all depth testing.
|
||||
vk::PipelineDepthStencilStateCreateInfo depth_stencil;
|
||||
|
||||
vk::Pipeline pipeline = vkb::common::create_graphics_pipeline(device,
|
||||
nullptr,
|
||||
shader_stages,
|
||||
vertex_input,
|
||||
vk::PrimitiveTopology::eTriangleList, // We will use triangle lists to draw geometry.
|
||||
0,
|
||||
vk::PolygonMode::eFill,
|
||||
vk::CullModeFlagBits::eBack,
|
||||
vk::FrontFace::eClockwise,
|
||||
{blend_attachment},
|
||||
depth_stencil,
|
||||
pipeline_layout, // We need to specify the pipeline layout
|
||||
render_pass); // and the render pass up front as well
|
||||
|
||||
// Pipeline is baked, we can delete the shader modules now.
|
||||
device.destroyShaderModule(shader_stages[0].module);
|
||||
device.destroyShaderModule(shader_stages[1].module);
|
||||
|
||||
return pipeline;
|
||||
}
|
||||
|
||||
vk::ImageView HPPHelloTriangle::create_image_view(vk::Image image)
|
||||
{
|
||||
vk::ImageViewCreateInfo image_view_create_info{
|
||||
.image = image,
|
||||
.viewType = vk::ImageViewType::e2D,
|
||||
.format = swapchain_data.format,
|
||||
.components = {.r = vk::ComponentSwizzle::eR, .g = vk::ComponentSwizzle::eG, .b = vk::ComponentSwizzle::eB, .a = vk::ComponentSwizzle::eA},
|
||||
.subresourceRange = {.aspectMask = vk::ImageAspectFlagBits::eColor, .baseMipLevel = 0, .levelCount = 1, .baseArrayLayer = 0, .layerCount = 1}};
|
||||
return device.createImageView(image_view_create_info);
|
||||
}
|
||||
|
||||
vk::Instance HPPHelloTriangle::create_instance(std::vector<const char *> const &required_instance_extensions, std::vector<const char *> const &required_validation_layers)
|
||||
{
|
||||
#if defined(_HPP_VULKAN_LIBRARY)
|
||||
static vk::detail::DynamicLoader dl(_HPP_VULKAN_LIBRARY);
|
||||
#else
|
||||
static vk::detail::DynamicLoader dl;
|
||||
#endif
|
||||
PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr = dl.getProcAddress<PFN_vkGetInstanceProcAddr>("vkGetInstanceProcAddr");
|
||||
VULKAN_HPP_DEFAULT_DISPATCHER.init(vkGetInstanceProcAddr);
|
||||
|
||||
std::vector<vk::ExtensionProperties> available_instance_extensions = vk::enumerateInstanceExtensionProperties();
|
||||
|
||||
std::vector<const char *> active_instance_extensions(required_instance_extensions);
|
||||
|
||||
#if defined(VKB_DEBUG) || defined(VKB_VALIDATION_LAYERS)
|
||||
active_instance_extensions.push_back(VK_EXT_DEBUG_UTILS_EXTENSION_NAME);
|
||||
#endif
|
||||
|
||||
#if (defined(VKB_ENABLE_PORTABILITY))
|
||||
active_instance_extensions.push_back(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME);
|
||||
bool portability_enumeration_available = false;
|
||||
if (std::ranges::any_of(available_instance_extensions,
|
||||
[](vk::ExtensionProperties const &extension) { return strcmp(extension.extensionName, VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME) == 0; }))
|
||||
{
|
||||
active_instance_extensions.push_back(VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME);
|
||||
portability_enumeration_available = true;
|
||||
}
|
||||
#endif
|
||||
|
||||
#if defined(VK_USE_PLATFORM_ANDROID_KHR)
|
||||
active_instance_extensions.push_back(VK_KHR_ANDROID_SURFACE_EXTENSION_NAME);
|
||||
#elif defined(VK_USE_PLATFORM_WIN32_KHR)
|
||||
active_instance_extensions.push_back(VK_KHR_WIN32_SURFACE_EXTENSION_NAME);
|
||||
#elif defined(VK_USE_PLATFORM_METAL_EXT)
|
||||
active_instance_extensions.push_back(VK_EXT_METAL_SURFACE_EXTENSION_NAME);
|
||||
#elif defined(VK_USE_PLATFORM_XCB_KHR)
|
||||
active_instance_extensions.push_back(VK_KHR_XCB_SURFACE_EXTENSION_NAME);
|
||||
#elif defined(VK_USE_PLATFORM_XLIB_KHR)
|
||||
active_instance_extensions.push_back(VK_KHR_XLIB_SURFACE_EXTENSION_NAME);
|
||||
#elif defined(VK_USE_PLATFORM_WAYLAND_KHR)
|
||||
active_instance_extensions.push_back(VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME);
|
||||
#elif defined(VK_USE_PLATFORM_DISPLAY_KHR)
|
||||
active_instance_extensions.push_back(VK_KHR_DISPLAY_EXTENSION_NAME);
|
||||
#else
|
||||
# pragma error Platform not supported
|
||||
#endif
|
||||
|
||||
if (!validate_extensions(active_instance_extensions, available_instance_extensions))
|
||||
{
|
||||
throw std::runtime_error("Required instance extensions are missing.");
|
||||
}
|
||||
|
||||
std::vector<const char *> requested_instance_layers(required_validation_layers);
|
||||
|
||||
#if defined(VKB_DEBUG) || defined(VKB_VALIDATION_LAYERS)
|
||||
char const *validationLayer = "VK_LAYER_KHRONOS_validation";
|
||||
|
||||
std::vector<vk::LayerProperties> supported_instance_layers = vk::enumerateInstanceLayerProperties();
|
||||
|
||||
if (std::ranges::any_of(supported_instance_layers, [&validationLayer](auto const &lp) { return strcmp(lp.layerName, validationLayer) == 0; }))
|
||||
{
|
||||
requested_instance_layers.push_back(validationLayer);
|
||||
LOGI("Enabled Validation Layer {}", validationLayer);
|
||||
}
|
||||
else
|
||||
{
|
||||
LOGW("Validation Layer {} is not available", validationLayer);
|
||||
}
|
||||
#endif
|
||||
|
||||
vk::ApplicationInfo app{.pApplicationName = "HPP Hello Triangle", .pEngineName = "Vulkan Samples", .apiVersion = VK_API_VERSION_1_1};
|
||||
|
||||
vk::InstanceCreateInfo instance_info{.pApplicationInfo = &app,
|
||||
.enabledLayerCount = static_cast<uint32_t>(requested_instance_layers.size()),
|
||||
.ppEnabledLayerNames = requested_instance_layers.data(),
|
||||
.enabledExtensionCount = static_cast<uint32_t>(active_instance_extensions.size()),
|
||||
.ppEnabledExtensionNames = active_instance_extensions.data()};
|
||||
|
||||
#if defined(VKB_DEBUG) || defined(VKB_VALIDATION_LAYERS)
|
||||
debug_utils_create_info =
|
||||
vk::DebugUtilsMessengerCreateInfoEXT{.messageSeverity =
|
||||
vk::DebugUtilsMessageSeverityFlagBitsEXT::eError | vk::DebugUtilsMessageSeverityFlagBitsEXT::eWarning,
|
||||
.messageType = vk::DebugUtilsMessageTypeFlagBitsEXT::eValidation | vk::DebugUtilsMessageTypeFlagBitsEXT::ePerformance,
|
||||
.pfnUserCallback = debug_utils_messenger_callback};
|
||||
|
||||
instance_info.pNext = &debug_utils_create_info;
|
||||
#endif
|
||||
|
||||
#if (defined(VKB_ENABLE_PORTABILITY))
|
||||
if (portability_enumeration_available)
|
||||
{
|
||||
instance_info.flags |= vk::InstanceCreateFlagBits::eEnumeratePortabilityKHR;
|
||||
}
|
||||
#endif
|
||||
|
||||
// Create the Vulkan instance
|
||||
vk::Instance instance = vk::createInstance(instance_info);
|
||||
|
||||
// initialize function pointers for instance
|
||||
VULKAN_HPP_DEFAULT_DISPATCHER.init(instance);
|
||||
|
||||
#if defined(VK_USE_PLATFORM_DISPLAY_KHR) || defined(VK_USE_PLATFORM_ANDROID_KHR) || defined(VK_USE_PLATFORM_METAL_EXT)
|
||||
// we need some additional initializing for this platform!
|
||||
if (volkInitialize())
|
||||
{
|
||||
throw std::runtime_error("Failed to initialize volk.");
|
||||
}
|
||||
volkLoadInstance(instance);
|
||||
#endif
|
||||
|
||||
return instance;
|
||||
}
|
||||
|
||||
vk::RenderPass HPPHelloTriangle::create_render_pass()
|
||||
{
|
||||
vk::AttachmentDescription attachment{
|
||||
.format = swapchain_data.format, // Backbuffer format.
|
||||
.samples = vk::SampleCountFlagBits::e1, // Not multisampled.
|
||||
.loadOp = vk::AttachmentLoadOp::eClear, // When starting the frame, we want tiles to be cleared.
|
||||
.storeOp = vk::AttachmentStoreOp::eStore, // When ending the frame, we want tiles to be written out.
|
||||
.stencilLoadOp = vk::AttachmentLoadOp::eDontCare, // Don't care about stencil since we're not using it.
|
||||
.stencilStoreOp = vk::AttachmentStoreOp::eDontCare, // Don't care about stencil since we're not using it.
|
||||
.initialLayout = vk::ImageLayout::eUndefined, // The image layout will be undefined when the render pass begins.
|
||||
.finalLayout = vk::ImageLayout::ePresentSrcKHR // After the render pass is complete, we will transition to PRESENT_SRC_KHR layout.
|
||||
};
|
||||
|
||||
// We have one subpass. This subpass has one color attachment.
|
||||
// While executing this subpass, the attachment will be in attachment optimal layout.
|
||||
vk::AttachmentReference color_ref{.attachment = 0, .layout = vk::ImageLayout::eColorAttachmentOptimal};
|
||||
|
||||
// We will end up with two transitions.
|
||||
// The first one happens right before we start subpass #0, where
|
||||
// eUndefined is transitioned into eColorAttachmentOptimal.
|
||||
// The final layout in the render pass attachment states ePresentSrcKHR, so we
|
||||
// will get a final transition from eColorAttachmentOptimal to ePresetSrcKHR.
|
||||
vk::SubpassDescription subpass{.pipelineBindPoint = vk::PipelineBindPoint::eGraphics, .colorAttachmentCount = 1, .pColorAttachments = &color_ref};
|
||||
|
||||
// Create a dependency to external events.
|
||||
// We need to wait for the WSI semaphore to signal.
|
||||
// Only pipeline stages which depend on eColorAttachmentOutput will
|
||||
// actually wait for the semaphore, so we must also wait for that pipeline stage.
|
||||
vk::SubpassDependency dependency{.srcSubpass = vk::SubpassExternal,
|
||||
.dstSubpass = 0,
|
||||
.srcStageMask = vk::PipelineStageFlagBits::eColorAttachmentOutput,
|
||||
.dstStageMask = vk::PipelineStageFlagBits::eColorAttachmentOutput,
|
||||
// Since we changed the image layout, we need to make the memory visible to color attachment to modify.
|
||||
.srcAccessMask = {},
|
||||
.dstAccessMask = vk::AccessFlagBits::eColorAttachmentRead | vk::AccessFlagBits::eColorAttachmentWrite};
|
||||
|
||||
// Finally, create the renderpass.
|
||||
vk::RenderPassCreateInfo rp_info{
|
||||
.attachmentCount = 1, .pAttachments = &attachment, .subpassCount = 1, .pSubpasses = &subpass, .dependencyCount = 1, .pDependencies = &dependency};
|
||||
return device.createRenderPass(rp_info);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Helper function to load a shader module from an offline-compiled SPIR-V file.
|
||||
* @param path The path for the shader (relative to the assets directory).
|
||||
* @returns A vk::ShaderModule handle. Aborts execution if shader creation fails.
|
||||
*/
|
||||
vk::ShaderModule HPPHelloTriangle::create_shader_module(std::string const &path)
|
||||
{
|
||||
auto spirv = vkb::fs::read_shader_binary_u32(path);
|
||||
|
||||
vk::ShaderModuleCreateInfo shader_module_create_info{.codeSize = spirv.size() * sizeof(uint32_t), .pCode = spirv.data()};
|
||||
|
||||
return device.createShaderModule(shader_module_create_info);
|
||||
}
|
||||
|
||||
vk::SwapchainKHR
|
||||
HPPHelloTriangle::create_swapchain(vk::Extent2D const &swapchain_extent, vk::SurfaceFormatKHR surface_format, vk::SwapchainKHR old_swapchain)
|
||||
{
|
||||
vk::SurfaceCapabilitiesKHR surface_properties = gpu.getSurfaceCapabilitiesKHR(surface);
|
||||
|
||||
// Determine the number of vk::Image's to use in the swapchain.
|
||||
// Ideally, we desire to own 1 image at a time, the rest of the images can
|
||||
// either be rendered to and/or being queued up for display.
|
||||
uint32_t desired_swapchain_images = surface_properties.minImageCount + 1;
|
||||
if ((surface_properties.maxImageCount > 0) && (desired_swapchain_images > surface_properties.maxImageCount))
|
||||
{
|
||||
// Application must settle for fewer images than desired.
|
||||
desired_swapchain_images = surface_properties.maxImageCount;
|
||||
}
|
||||
|
||||
// Figure out a suitable surface transform.
|
||||
vk::SurfaceTransformFlagBitsKHR pre_transform =
|
||||
(surface_properties.supportedTransforms & vk::SurfaceTransformFlagBitsKHR::eIdentity) ? vk::SurfaceTransformFlagBitsKHR::eIdentity : surface_properties.currentTransform;
|
||||
|
||||
// Find a supported composite type.
|
||||
vk::CompositeAlphaFlagBitsKHR composite = vk::CompositeAlphaFlagBitsKHR::eOpaque;
|
||||
if (surface_properties.supportedCompositeAlpha & vk::CompositeAlphaFlagBitsKHR::eOpaque)
|
||||
{
|
||||
composite = vk::CompositeAlphaFlagBitsKHR::eOpaque;
|
||||
}
|
||||
else if (surface_properties.supportedCompositeAlpha & vk::CompositeAlphaFlagBitsKHR::eInherit)
|
||||
{
|
||||
composite = vk::CompositeAlphaFlagBitsKHR::eInherit;
|
||||
}
|
||||
else if (surface_properties.supportedCompositeAlpha & vk::CompositeAlphaFlagBitsKHR::ePreMultiplied)
|
||||
{
|
||||
composite = vk::CompositeAlphaFlagBitsKHR::ePreMultiplied;
|
||||
}
|
||||
else if (surface_properties.supportedCompositeAlpha & vk::CompositeAlphaFlagBitsKHR::ePostMultiplied)
|
||||
{
|
||||
composite = vk::CompositeAlphaFlagBitsKHR::ePostMultiplied;
|
||||
}
|
||||
|
||||
// FIFO must be supported by all implementations.
|
||||
vk::PresentModeKHR swapchain_present_mode = vk::PresentModeKHR::eFifo;
|
||||
|
||||
vk::SwapchainCreateInfoKHR swapchain_create_info{
|
||||
.surface = surface,
|
||||
.minImageCount = desired_swapchain_images,
|
||||
.imageFormat = surface_format.format,
|
||||
.imageColorSpace = surface_format.colorSpace,
|
||||
.imageExtent = swapchain_extent,
|
||||
.imageArrayLayers = 1,
|
||||
.imageUsage = vk::ImageUsageFlagBits::eColorAttachment,
|
||||
.imageSharingMode = vk::SharingMode::eExclusive,
|
||||
.preTransform = pre_transform,
|
||||
.compositeAlpha = composite,
|
||||
.presentMode = swapchain_present_mode,
|
||||
.clipped = true,
|
||||
.oldSwapchain = old_swapchain};
|
||||
|
||||
return device.createSwapchainKHR(swapchain_create_info);
|
||||
}
|
||||
|
||||
std::pair<vk::Buffer, VmaAllocation> HPPHelloTriangle::create_vertex_buffer()
|
||||
{
|
||||
// Vertex data for a single colored triangle
|
||||
const std::vector<Vertex> vertices = {
|
||||
{{0.5f, -0.5f, 0.5f}, {1.0f, 0.0f, 0.0f}},
|
||||
{{0.5f, 0.5f, 0.5f}, {0.0f, 1.0f, 0.0f}},
|
||||
{{-0.5f, 0.5f, 0.5f}, {0.0f, 0.0f, 1.0f}}};
|
||||
|
||||
const vk::DeviceSize buffer_size = sizeof(vertices[0]) * vertices.size();
|
||||
|
||||
// Copy Vertex data to a buffer accessible by the device
|
||||
|
||||
vk::BufferCreateInfo buffer_create_info{.size = buffer_size, .usage = vk::BufferUsageFlagBits::eVertexBuffer};
|
||||
|
||||
// We use the Vulkan Memory Allocator to find a memory type that can be written and mapped from the host
|
||||
// On most setups this will return a memory type that resides in VRAM and is accessible from the host
|
||||
VmaAllocationCreateInfo allocation_create_info{
|
||||
.flags = VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT | VMA_ALLOCATION_CREATE_MAPPED_BIT,
|
||||
.usage = VMA_MEMORY_USAGE_AUTO,
|
||||
.requiredFlags = VK_MEMORY_PROPERTY_HOST_COHERENT_BIT};
|
||||
|
||||
vk::Buffer vertex_buffer;
|
||||
VmaAllocation vertex_buffer_allocation;
|
||||
VmaAllocationInfo allocation_info{};
|
||||
vmaCreateBuffer(vma_allocator, reinterpret_cast<VkBufferCreateInfo *>(&buffer_create_info), &allocation_create_info, reinterpret_cast<VkBuffer *>(&vertex_buffer), &vertex_buffer_allocation, &allocation_info);
|
||||
if (allocation_info.pMappedData)
|
||||
{
|
||||
memcpy(allocation_info.pMappedData, vertices.data(), buffer_size);
|
||||
}
|
||||
else
|
||||
{
|
||||
throw std::runtime_error("Could not map vertex buffer.");
|
||||
}
|
||||
|
||||
return {vertex_buffer, vertex_buffer_allocation};
|
||||
}
|
||||
|
||||
VmaAllocator HPPHelloTriangle::create_vma_allocator()
|
||||
{
|
||||
// This sample uses the Vulkan Memory Alloctor (VMA), which needs to be set up
|
||||
VmaVulkanFunctions vma_vulkan_functions{
|
||||
.vkGetInstanceProcAddr = VULKAN_HPP_DEFAULT_DISPATCHER.vkGetInstanceProcAddr,
|
||||
.vkGetDeviceProcAddr = VULKAN_HPP_DEFAULT_DISPATCHER.vkGetDeviceProcAddr};
|
||||
|
||||
VmaAllocatorCreateInfo allocator_info{.physicalDevice = gpu, .device = device, .pVulkanFunctions = &vma_vulkan_functions, .instance = instance};
|
||||
|
||||
VmaAllocator allocator;
|
||||
VkResult result = vmaCreateAllocator(&allocator_info, &allocator);
|
||||
if (result != VK_SUCCESS)
|
||||
{
|
||||
throw std::runtime_error("Could not create allocator for VMA allocator");
|
||||
}
|
||||
|
||||
return allocator;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Initializes the Vulkan framebuffers.
|
||||
*/
|
||||
void HPPHelloTriangle::init_framebuffers()
|
||||
{
|
||||
assert(swapchain_data.framebuffers.empty());
|
||||
|
||||
// Create framebuffer for each swapchain image view
|
||||
for (auto &image_view : swapchain_data.image_views)
|
||||
{
|
||||
// create the framebuffer.
|
||||
swapchain_data.framebuffers.push_back(vkb::common::create_framebuffer(device, render_pass, {image_view}, swapchain_data.extent));
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Initializes the Vulkan swapchain.
|
||||
*/
|
||||
void HPPHelloTriangle::init_swapchain()
|
||||
{
|
||||
vk::SurfaceCapabilitiesKHR surface_properties = gpu.getSurfaceCapabilitiesKHR(surface);
|
||||
|
||||
vk::Extent2D swapchain_extent = (surface_properties.currentExtent.width == 0xFFFFFFFF) ? swapchain_data.extent : surface_properties.currentExtent;
|
||||
|
||||
vk::SurfaceFormatKHR surface_format = vkb::common::select_surface_format(gpu, surface);
|
||||
|
||||
vk::SwapchainKHR old_swapchain = swapchain_data.swapchain;
|
||||
|
||||
swapchain_data.swapchain = create_swapchain(swapchain_extent, surface_format, old_swapchain);
|
||||
|
||||
if (old_swapchain)
|
||||
{
|
||||
for (vk::ImageView image_view : swapchain_data.image_views)
|
||||
{
|
||||
device.destroyImageView(image_view);
|
||||
}
|
||||
|
||||
size_t image_count = device.getSwapchainImagesKHR(old_swapchain).size();
|
||||
|
||||
for (size_t i = 0; i < image_count; i++)
|
||||
{
|
||||
teardown_per_frame(per_frame_data[i]);
|
||||
}
|
||||
|
||||
swapchain_data.image_views.clear();
|
||||
|
||||
device.destroySwapchainKHR(old_swapchain);
|
||||
}
|
||||
|
||||
swapchain_data.extent = swapchain_extent;
|
||||
swapchain_data.format = surface_format.format;
|
||||
|
||||
/// The swapchain images.
|
||||
std::vector<vk::Image> swapchain_images = device.getSwapchainImagesKHR(swapchain_data.swapchain);
|
||||
size_t image_count = swapchain_images.size();
|
||||
|
||||
// Initialize per-frame resources.
|
||||
// Every swapchain image has its own command pool and fence manager.
|
||||
// This makes it very easy to keep track of when we can reset command buffers and such.
|
||||
per_frame_data.clear();
|
||||
per_frame_data.resize(image_count);
|
||||
|
||||
for (size_t frame = 0; frame < image_count; frame++)
|
||||
{
|
||||
auto &pfd = per_frame_data[frame];
|
||||
pfd.queue_submit_fence = device.createFence({.flags = vk::FenceCreateFlagBits::eSignaled});
|
||||
pfd.primary_command_pool = device.createCommandPool({.flags = vk::CommandPoolCreateFlagBits::eTransient, .queueFamilyIndex = graphics_queue_index});
|
||||
pfd.primary_command_buffer = vkb::common::allocate_command_buffer(device, pfd.primary_command_pool);
|
||||
}
|
||||
|
||||
for (size_t i = 0; i < image_count; i++)
|
||||
{
|
||||
// Create an image view which we can render into.
|
||||
swapchain_data.image_views.push_back(create_image_view(swapchain_images[i]));
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Renders a triangle to the specified swapchain image.
|
||||
* @param swapchain_index The swapchain index for the image being rendered.
|
||||
*/
|
||||
void HPPHelloTriangle::render_triangle(uint32_t swapchain_index)
|
||||
{
|
||||
// Render to this framebuffer.
|
||||
vk::Framebuffer framebuffer = swapchain_data.framebuffers[swapchain_index];
|
||||
|
||||
// Allocate or re-use a primary command buffer.
|
||||
vk::CommandBuffer cmd = per_frame_data[swapchain_index].primary_command_buffer;
|
||||
|
||||
// We will only submit this once before it's recycled.
|
||||
vk::CommandBufferBeginInfo begin_info{.flags = vk::CommandBufferUsageFlagBits::eOneTimeSubmit};
|
||||
// Begin command recording
|
||||
cmd.begin(begin_info);
|
||||
|
||||
// Set clear color values.
|
||||
vk::ClearValue clear_value;
|
||||
clear_value.color = vk::ClearColorValue(std::array<float, 4>({{0.01f, 0.01f, 0.033f, 1.0f}}));
|
||||
|
||||
// Begin the render pass.
|
||||
vk::RenderPassBeginInfo rp_begin{.renderPass = render_pass,
|
||||
.framebuffer = framebuffer,
|
||||
.renderArea = {{0, 0}, {swapchain_data.extent.width, swapchain_data.extent.height}},
|
||||
.clearValueCount = 1,
|
||||
.pClearValues = &clear_value};
|
||||
// We will add draw commands in the same command buffer.
|
||||
cmd.beginRenderPass(rp_begin, vk::SubpassContents::eInline);
|
||||
|
||||
// Bind the graphics pipeline.
|
||||
cmd.bindPipeline(vk::PipelineBindPoint::eGraphics, pipeline);
|
||||
|
||||
vk::Viewport vp{0.0f, 0.0f, static_cast<float>(swapchain_data.extent.width), static_cast<float>(swapchain_data.extent.height), 0.0f, 1.0f};
|
||||
// Set viewport dynamically
|
||||
cmd.setViewport(0, vp);
|
||||
|
||||
vk::Rect2D scissor{{0, 0}, {swapchain_data.extent.width, swapchain_data.extent.height}};
|
||||
// Set scissor dynamically
|
||||
cmd.setScissor(0, scissor);
|
||||
|
||||
// Bind the vertex buffer to source the draw calls from.
|
||||
vk::DeviceSize offset = {0};
|
||||
cmd.bindVertexBuffers(0, vertex_buffer, offset);
|
||||
|
||||
// Draw three vertices with one instance.
|
||||
cmd.draw(3, 1, 0, 0);
|
||||
|
||||
// Complete render pass.
|
||||
cmd.endRenderPass();
|
||||
|
||||
// Complete the command buffer.
|
||||
cmd.end();
|
||||
|
||||
// Submit it to the queue with a release semaphore.
|
||||
if (!per_frame_data[swapchain_index].swapchain_release_semaphore)
|
||||
{
|
||||
per_frame_data[swapchain_index].swapchain_release_semaphore = device.createSemaphore({});
|
||||
}
|
||||
|
||||
vk::PipelineStageFlags wait_stage{VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT};
|
||||
|
||||
vk::SubmitInfo info{.waitSemaphoreCount = 1,
|
||||
.pWaitSemaphores = &per_frame_data[swapchain_index].swapchain_acquire_semaphore,
|
||||
.pWaitDstStageMask = &wait_stage,
|
||||
.commandBufferCount = 1,
|
||||
.pCommandBuffers = &cmd,
|
||||
.signalSemaphoreCount = 1,
|
||||
.pSignalSemaphores = &per_frame_data[swapchain_index].swapchain_release_semaphore};
|
||||
// Submit command buffer to graphics queue
|
||||
queue.submit(info, per_frame_data[swapchain_index].queue_submit_fence);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Select a physical device.
|
||||
*/
|
||||
void HPPHelloTriangle::select_physical_device_and_surface()
|
||||
{
|
||||
std::vector<vk::PhysicalDevice> gpus = instance.enumeratePhysicalDevices();
|
||||
|
||||
bool found_graphics_queue_index = false;
|
||||
for (size_t i = 0; i < gpus.size() && !found_graphics_queue_index; i++)
|
||||
{
|
||||
gpu = gpus[i];
|
||||
|
||||
std::vector<vk::QueueFamilyProperties> queue_family_properties = gpu.getQueueFamilyProperties();
|
||||
|
||||
if (queue_family_properties.empty())
|
||||
{
|
||||
throw std::runtime_error("No queue family found.");
|
||||
}
|
||||
|
||||
if (surface)
|
||||
{
|
||||
instance.destroySurfaceKHR(surface);
|
||||
}
|
||||
|
||||
surface = static_cast<vk::SurfaceKHR>(window->create_surface(static_cast<VkInstance>(instance), static_cast<VkPhysicalDevice>(gpu)));
|
||||
if (!surface)
|
||||
{
|
||||
throw std::runtime_error("Failed to create window surface.");
|
||||
}
|
||||
|
||||
for (uint32_t j = 0; j < vkb::to_u32(queue_family_properties.size()); j++)
|
||||
{
|
||||
vk::Bool32 supports_present = gpu.getSurfaceSupportKHR(j, surface);
|
||||
|
||||
// Find a queue family which supports graphics and presentation.
|
||||
if ((queue_family_properties[j].queueFlags & vk::QueueFlagBits::eGraphics) && supports_present)
|
||||
{
|
||||
graphics_queue_index = j;
|
||||
found_graphics_queue_index = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (!found_graphics_queue_index)
|
||||
{
|
||||
LOGE("Did not find suitable queue which supports graphics and presentation.");
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Tears down the framebuffers. If our swapchain changes, we will call this, and create a new swapchain.
|
||||
*/
|
||||
void HPPHelloTriangle::teardown_framebuffers()
|
||||
{
|
||||
// Wait until device is idle before teardown.
|
||||
queue.waitIdle();
|
||||
|
||||
for (auto &framebuffer : swapchain_data.framebuffers)
|
||||
{
|
||||
device.destroyFramebuffer(framebuffer);
|
||||
}
|
||||
|
||||
swapchain_data.framebuffers.clear();
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Tears down the frame data.
|
||||
* @param per_frame_data The data of a frame.
|
||||
*/
|
||||
void HPPHelloTriangle::teardown_per_frame(FrameData &per_frame_data)
|
||||
{
|
||||
if (per_frame_data.queue_submit_fence)
|
||||
{
|
||||
device.destroyFence(per_frame_data.queue_submit_fence);
|
||||
per_frame_data.queue_submit_fence = nullptr;
|
||||
}
|
||||
|
||||
if (per_frame_data.primary_command_buffer)
|
||||
{
|
||||
device.freeCommandBuffers(per_frame_data.primary_command_pool, per_frame_data.primary_command_buffer);
|
||||
per_frame_data.primary_command_buffer = nullptr;
|
||||
}
|
||||
|
||||
if (per_frame_data.primary_command_pool)
|
||||
{
|
||||
device.destroyCommandPool(per_frame_data.primary_command_pool);
|
||||
per_frame_data.primary_command_pool = nullptr;
|
||||
}
|
||||
|
||||
if (per_frame_data.swapchain_acquire_semaphore)
|
||||
{
|
||||
device.destroySemaphore(per_frame_data.swapchain_acquire_semaphore);
|
||||
per_frame_data.swapchain_acquire_semaphore = nullptr;
|
||||
}
|
||||
|
||||
if (per_frame_data.swapchain_release_semaphore)
|
||||
{
|
||||
device.destroySemaphore(per_frame_data.swapchain_release_semaphore);
|
||||
per_frame_data.swapchain_release_semaphore = nullptr;
|
||||
}
|
||||
}
|
||||
|
||||
std::unique_ptr<vkb::Application> create_hpp_hello_triangle()
|
||||
{
|
||||
return std::make_unique<HPPHelloTriangle>();
|
||||
}
|
||||
Reference in New Issue
Block a user