How to Vulkan

https://www.howtovulkan.com/
Admin
How to Vulkan is a comprehensive tutorial demonstrating how to write modern Vulkan graphics...
Tokens:20,657
Snippets:218
Trust Score:5.3
Update:5 months ago
Show doc for...
Tokens:
Raw
### Begin Dynamic Rendering Pass

Source: https://www.howtovulkan.com/

Starts a dynamic render pass instance using the provided VkRenderingInfo, which includes render area extent, layer count, and attachment pointers. This prepares the command buffer for subsequent rendering commands.

```c++
VkRenderingInfo renderingInfo{
    .sType = VK_STRUCTURE_TYPE_RENDERING_INFO,
    .renderArea{.extent{.width = static_cast<uint32_t>(windowSize.x), .height = static_cast<uint32_t>(windowSize.y) }},
    .layerCount = 1,
    .colorAttachmentCount = 1,
    .pColorAttachments = &colorAttachmentInfo,
    .pDepthAttachment = &depthAttachmentInfo
};
vkCmdBeginRendering(cb, &renderingInfo);

```

--------------------------------

### Get Platform-Specific Instance Extensions with SDL

Source: https://www.howtovulkan.com/

Retrieves the necessary Vulkan instance extensions for the current platform using SDL. This abstracts away platform-specific code, simplifying extension management.

```c
uint32_t instanceExtensionsCount{ 0 };
char const* const* instanceExtensions{ SDL_Vulkan_GetInstanceExtensions(&instanceExtensionsCount) };

```

--------------------------------

### Configure Rendering Attachments for Dynamic Rendering

Source: https://www.howtovulkan.com/

Sets up VkRenderingAttachmentInfo for color and depth attachments. Use VK_ATTACHMENT_LOAD_OP_CLEAR to clear attachments at the start of a render pass. Ensure imageLayout matches transitions made earlier.

```c++
VkRenderingAttachmentInfo colorAttachmentInfo{
    .sType = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO,
    .imageView = swapchainImageViews[imageIndex],
    .imageLayout = VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL,
    .loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR,
    .storeOp = VK_ATTACHMENT_STORE_OP_STORE,
    .clearValue{.color{ 0.0f, 0.0f, 0.2f, 1.0f }}
};
VkRenderingAttachmentInfo depthAttachmentInfo{
    .sType = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO,
    .imageView = depthImageView,
    .imageLayout = VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL,
    .loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR,
    .storeOp = VK_ATTACHMENT_STORE_OP_DONT_CARE,
    .clearValue = {.depthStencil = {1.0f,  0}}
};

```

--------------------------------

### Get Vulkan Surface Capabilities

Source: https://www.howtovulkan.com/

Query the physical device for surface capabilities, such as supported image formats and extent, which are crucial for swapchain creation.

```c++
VkSurfaceCapabilitiesKHR surfaceCaps{};
chk(vkGetPhysicalDeviceSurfaceCapabilitiesKHR(devices[deviceIndex], surface, &surfaceCaps));
```

--------------------------------

### Get Vulkan Device Queue

Source: https://www.howtovulkan.com/

Retrieve a handle to a specific queue from the newly created logical device for command submission.

```cpp
vkGetDeviceQueue(device, queueFamily, 0, &queue);
```

--------------------------------

### Get Swapchain Images

Source: https://www.howtovulkan.com/

Retrieve the images that are part of the created swapchain. These images will be used for rendering.

```c++
uint32_t imageCount{ 0 };
chk(vkGetSwapchainImagesKHR(device, swapchain, &imageCount, nullptr));
swapchainImages.resize(imageCount);
chk(vkGetSwapchainImagesKHR(device, swapchain, &imageCount, swapchainImages.data()));
swapchainImageViews.resize(imageCount);
```

--------------------------------

### Submit Command Buffer to Graphics Queue

Source: https://www.howtovulkan.com/

Submits a command buffer to the graphics queue for execution. It uses semaphores for synchronization between CPU and GPU operations, ensuring that rendering commands do not start before the swapchain image is acquired and that presentation does not begin until rendering is complete. This is crucial for preventing resource hazards.

```c++
VkPipelineStageFlags waitStages = VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT;
VkSubmitInfo submitInfo{
    .sType = VK_STRUCTURE_TYPE_SUBMIT_INFO,
    .waitSemaphoreCount = 1,
    .pWaitSemaphores = &imageAcquiredSemaphores[frameIndex],
    .pWaitDstStageMask = &waitStages,
    .commandBufferCount = 1,
    .pCommandBuffers = &cb,
    .signalSemaphoreCount = 1,
    .pSignalSemaphores = &renderCompleteSemaphores[imageIndex],
};
chk(vkQueueSubmit(queue, 1, &submitInfo, fences[frameIndex]));

```

--------------------------------

### Get and Display Device Properties

Source: https://www.howtovulkan.com/

Fetches properties of the selected physical Vulkan device, including its name, and prints the name to the console. Uses VkPhysicalDeviceProperties2 for extended property retrieval.

```cpp
VkPhysicalDeviceProperties2 deviceProperties{ .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2 };
vkGetPhysicalDeviceProperties2(devices[deviceIndex], &deviceProperties);
std::cout << "Selected device: " << deviceProperties.properties.deviceName <<  "\n";
```

--------------------------------

### Enumerate Physical Vulkan Devices

Source: https://www.howtovulkan.com/

Retrieves a list of all physical devices that support Vulkan on the system. This involves two calls to vkEnumeratePhysicalDevices: the first to get the count and the second to populate a vector with the devices.

```cpp
uint32_t deviceCount{ 0 };
chk(vkEnumeratePhysicalDevices(instance, &deviceCount, nullptr));
std::vector<VkPhysicalDevice> devices(deviceCount);
chk(vkEnumeratePhysicalDevices(instance, &deviceCount, devices.data()));
```

--------------------------------

### Create Fence and Allocate Command Buffer

Source: https://www.howtovulkan.com/

Initializes a fence for synchronization and allocates a command buffer for one-time submission. Ensure the device and command pool are valid.

```c++
VkFenceCreateInfo fenceOneTimeCI{
    .sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO
};
VkFence fenceOneTime{};
chk(vkCreateFence(device, &fenceOneTimeCI, nullptr, &fenceOneTime));
VkCommandBuffer cbOneTime{};
VkCommandBufferAllocateInfo cbOneTimeAI{
    .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,
    .commandPool = commandPool,
    .commandBufferCount = 1
};
chk(vkAllocateCommandBuffers(device, &cbOneTimeAI, &cbOneTime));

```

--------------------------------

### Create Device Queue Create Info

Source: https://www.howtovulkan.com/

Defines the information needed to create a logical device queue, specifying the graphics queue family index, the number of queues to create (one in this case), and their priorities.

```cpp
const float qfpriorities{ 1.0f };
VkDeviceQueueCreateInfo queueCI{
    .sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO,
    .queueFamilyIndex = queueFamily,
    .queueCount = 1,
    .pQueuePriorities = &qfpriorities
};
```

--------------------------------

### Get Shader Buffer Device Address

Source: https://www.howtovulkan.com/

Retrieves the device address for a created shader data buffer, enabling direct access from shaders.

```cpp
    VkBufferDeviceAddressInfo uBufferBdaInfo{
        .sType = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO,
        .buffer = shaderDataBuffers[i].buffer
    };
    shaderDataBuffers[i].deviceAddress = vkGetBufferDeviceAddress(device, &uBufferBdaInfo);
}

```

--------------------------------

### Begin Vulkan Command Buffer Recording

Source: https://www.howtovulkan.com/

Begins recording commands into a command buffer. Use VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT for optimization hints if the buffer will only be submitted once.

```cpp
VkCommandBufferBeginInfo cbBI {
    .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
    .flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT
};
chk(vkBeginCommandBuffer(cb, &cbBI));
```

--------------------------------

### Create SDL Window with Vulkan Support

Source: https://www.howtovulkan.com/

Use SDL to create a window that supports Vulkan rendering. This abstracts platform-specific window creation details.

```c++
SDL_Window* window = SDL_CreateWindow("How to Vulkan", 1280u, 720u, SDL_WINDOW_VULKAN | SDL_WINDOW_RESIZABLE);
```

--------------------------------

### Request Vulkan Swapchain Extension

Source: https://www.howtovulkan.com/

Declare the required swapchain extension for presenting to the screen. Use the predefined constant for the extension name to avoid typos.

```cpp
const std::vector<const char*> deviceExtensions{ VK_KHR_SWAPCHAIN_EXTENSION_NAME };
```

--------------------------------

### Transition Swapchain Image for Presentation

Source: https://www.howtovulkan.com/

Transitions the swapchain image layout from color attachment optimal to presentation optimal. This barrier ensures correct synchronization before presenting the image.

```c
VkImageMemoryBarrier2 barrierPresent{
    .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2,
    .srcStageMask = VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT,
    .srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
    .dstStageMask = VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT,
    .dstAccessMask = 0,
    .oldLayout = VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL,
    .newLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR,
    .image = swapchainImages[imageIndex],
    .subresourceRange{.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT, .levelCount = 1, .layerCount = 1 }
};
VkDependencyInfo barrierPresentDependencyInfo{
    .sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO,
    .imageMemoryBarrierCount = 1,
    .pImageMemoryBarriers = &barrierPresent
};
vkCmdPipelineBarrier2(cb, &barrierPresentDependencyInfo);
```

--------------------------------

### Select Device by Index

Source: https://www.howtovulkan.com/

Allows selection of a specific physical Vulkan device from the enumerated list using a command line argument. Asserts that the provided index is within the valid range of available devices.

```cpp
uint32_t deviceIndex{ 0 };
if (argc > 1) {
    deviceIndex = std::stoi(argv[1]);
    assert(deviceIndex < deviceCount);
}
```

--------------------------------

### Enable Vulkan 1.2 and 1.3 Features

Source: https://www.howtovulkan.com/

Configure and enable specific Vulkan 1.2 and 1.3 features, including descriptor indexing and dynamic rendering. These are chained using the `pNext` member.

```cpp
VkPhysicalDeviceVulkan12Features enabledVk12Features{
    .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES,
    .descriptorIndexing = true,
    .shaderSampledImageArrayNonUniformIndexing = true,
    .descriptorBindingVariableDescriptorCount = true,
    .runtimeDescriptorArray = true,
    .bufferDeviceAddress = true
};
VkPhysicalDeviceVulkan13Features enabledVk13Features{
    .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES,
    .pNext = &enabledVk12Features,
    .synchronization2 = true,
    .dynamicRendering = true,
};
```

--------------------------------

### Create Vulkan Swapchain

Source: https://www.howtovulkan.com/

Configure and create a Vulkan swapchain, specifying image format, extent, usage, and presentation mode. Uses `VK_FORMAT_B8G8R8A8_SRGB` and `VK_PRESENT_MODE_FIFO_KHR` for broad compatibility.

```c++
const VkFormat imageFormat{ VK_FORMAT_B8G8R8A8_SRGB };
VkSwapchainCreateInfoKHR swapchainCI{
    .sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR,
    .surface = surface,
    .minImageCount = surfaceCaps.minImageCount,
    .imageFormat = imageFormat,
    .imageColorSpace = VK_COLORSPACE_SRGB_NONLINEAR_KHR,
    .imageExtent{.width = swapchainExtent.width, .height = swapchainExtent.height },
    .imageArrayLayers = 1,
    .imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT,
    .preTransform = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR,
    .compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR,
    .presentMode = VK_PRESENT_MODE_FIFO_KHR
};
chk(vkCreateSwapchainKHR(device, &swapchainCI, nullptr, &swapchain));
```

--------------------------------

### Create Vulkan Surface from SDL Window

Source: https://www.howtovulkan.com/

Request a Vulkan surface associated with the created SDL window. This is a necessary step before Vulkan can render to the window.

```c++
chk(SDL_Vulkan_CreateSurface(window, instance, nullptr, &surface));
```

--------------------------------

### Create Vulkan Instance

Source: https://www.howtovulkan.com/

Creates the Vulkan instance using the defined application info and the retrieved platform-specific extensions. The `chk` function is a utility for checking VkResult return codes and exiting on error.

```c
VkInstanceCreateInfo instanceCI{
    .sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,
    .pApplicationInfo = &appInfo,
    .enabledExtensionCount = instanceExtensionsCount,
    .ppEnabledExtensionNames = instanceExtensions,
};
chk(vkCreateInstance(&instanceCI, nullptr, &instance));

```

--------------------------------

### Configure VMA Allocator

Source: https://www.howtovulkan.com/

Set up the Vulkan Memory Allocator (VMA) by providing Vulkan function pointers, the physical and logical devices, and enabling specific flags like buffer device address.

```cpp
VmaVulkanFunctions vkFunctions{
    .vkGetInstanceProcAddr = vkGetInstanceProcAddr,
    .vkGetDeviceProcAddr = vkGetDeviceProcAddr,
    .vkCreateImage = vkCreateImage
};
VmaAllocatorCreateInfo allocatorCI{
    .flags = VMA_ALLOCATOR_CREATE_BUFFER_DEVICE_ADDRESS_BIT, 
    .physicalDevice = devices[deviceIndex],
    .device = device,
    .pVulkanFunctions = &vkFunctions,
    .instance = instance
};
chk(vmaCreateAllocator(&allocatorCI, &allocator));
```

--------------------------------

### Define Application Info for Vulkan Instance

Source: https://www.howtovulkan.com/

This structure holds information about your application, such as its name and the Vulkan API version you intend to use. Ensure the apiVersion is set to a widely supported version like VK_API_VERSION_1_3 for access to core features.

```c
VkApplicationInfo appInfo{
    .sType = VK_STRUCTURE_TYPE_APPLICATION_INFO,
    .pApplicationName = "How to Vulkan",
    .apiVersion = VK_API_VERSION_1_3
};

```

--------------------------------

### Compile Slang Shader to SPIR-V

Source: https://www.howtovulkan.com/

Loads a Slang shader from a file and compiles it into SPIR-V format using the established Slang session. The resulting SPIR-V blob can then be used to create a Vulkan shader module.

```cpp
Slang::ComPtr<slang::IModule> slangModule{
    slangSession->loadModuleFromSource("triangle", "assets/shader.slang", nullptr, nullptr)
};
Slang::ComPtr<ISlangBlob> spirv;
slangModule->getTargetCode(0, spirv.writeRef());

```

--------------------------------

### Create Vulkan Logical Device

Source: https://www.howtovulkan.com/

Create the Vulkan logical device, specifying enabled features, extensions, and queue information. The `pNext` member links the feature structures.

```cpp
VkDeviceCreateInfo deviceCI{
    .sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO,
    .pNext = &enabledVk13Features,
    .queueCreateInfoCount = 1,
    .pQueueCreateInfos = &queueCI,
    .enabledExtensionCount = static_cast<uint32_t>(deviceExtensions.size()),
    .ppEnabledExtensionNames = deviceExtensions.data(),
    .pEnabledFeatures = &enabledVk10Features
};
chk(vkCreateDevice(devices[deviceIndex], &deviceCI, nullptr, &device));
```

--------------------------------

### Create Slang Compilation Session for SPIR-V

Source: https://www.howtovulkan.com/

Sets up a Slang compilation session targeting SPIR-V 1.4 with column-major matrix layout. This session is used to compile Slang shaders into the SPIR-V intermediate format.

```cpp
auto slangTargets{ std::to_array<slang::TargetDesc>({ {
    .format{SLANG_SPIRV},
    .profile{slangGlobalSession->findProfile("spirv_1_4")}
} })};
auto slangOptions{ std::to_array<slang::CompilerOptionEntry>({ {
    slang::CompilerOptionName::EmitSpirvDirectly,
    {slang::CompilerOptionValueKind::Int, 1}
} })};
slang::SessionDesc slangSessionDesc{
    .targets{slangTargets.data()},
    .targetCount{SlangInt(slangTargets.size())},
    .defaultMatrixLayoutMode = SLANG_MATRIX_LAYOUT_COLUMN_MAJOR,
    .compilerOptionEntries{slangOptions.data()},
    .compilerOptionEntryCount{uint32_t(slangOptions.size())}
};
Slang::ComPtr<slang::ISession> slangSession;
slangGlobalSession->createSession(slangSessionDesc, slangSession.writeRef());

```

--------------------------------

### Recreate Vulkan Swapchain

Source: https://www.howtovulkan.com/

Recreate the swapchain and associated resources when the window is resized or the surface becomes out-of-date. Ensure all GPU operations are idle before proceeding. Set the `oldSwapchain` member to allow continued presentation of acquired images.

```cpp
if (updateSwapchain) {
    updateSwapchain = false;
    vkDeviceWaitIdle(device);
    chk(vkGetPhysicalDeviceSurfaceCapabilitiesKHR(devices[deviceIndex], surface, &surfaceCaps));
    swapchainCI.oldSwapchain = swapchain;
    swapchainCI.imageExtent = { .width = static_cast<uint32_t>(windowSize.x), .height = static_cast<uint32_t>(windowSize.y) };
    chk(vkCreateSwapchainKHR(device, &swapchainCI, nullptr, &swapchain));
    for (auto i = 0; i < imageCount; i++) {
        vkDestroyImageView(device, swapchainImageViews[i], nullptr);
    }
    chk(vkGetSwapchainImagesKHR(device, swapchain, &imageCount, nullptr));
    swapchainImages.resize(imageCount);
    chk(vkGetSwapchainImagesKHR(device, swapchain, &imageCount, swapchainImages.data()));
    swapchainImageViews.resize(imageCount);
    for (auto i = 0; i < imageCount; i++) {
        VkImageViewCreateInfo viewCI{
            .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
            .image = swapchainImages[i],
            .viewType = VK_IMAGE_VIEW_TYPE_2D,
            .format = imageFormat,
            .subresourceRange = {.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT, .levelCount = 1, .layerCount = 1}
        };
        chk(vkCreateImageView(device, &viewCI, nullptr, &swapchainImageViews[i]));
    }
    for (auto& semaphore : renderCompleteSemaphores) {
        vkDestroySemaphore(device, semaphore, nullptr);
    }
    renderCompleteSemaphores.resize(imageCount);
    for (auto& semaphore : renderCompleteSemaphores) {
        chk(vkCreateSemaphore(device, &semaphoreCI, nullptr, &semaphore));
    }   
    vkDestroySwapchainKHR(device, swapchainCI.oldSwapchain, nullptr);
    vmaDestroyImage(allocator, depthImage, depthImageAllocation);
    vkDestroyImageView(device, depthImageView, nullptr);
    depthImageCI.extent = { .width = static_cast<uint32_t>(windowSize.x), .height = static_cast<uint32_t>(windowSize.y), .depth = 1 };
    VmaAllocationCreateInfo allocCI{
        .flags = VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT,
        .usage = VMA_MEMORY_USAGE_AUTO
    };
    chk(vmaCreateImage(allocator, &depthImageCI, &allocCI, &depthImage, &depthImageAllocation, nullptr));
    VkImageViewCreateInfo viewCI{
        .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
        .image = depthImage,
        .viewType = VK_IMAGE_VIEW_TYPE_2D,
        .format = depthFormat,
        .subresourceRange = {.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT, .levelCount = 1, .layerCount = 1 }
    };
    chk(vkCreateImageView(device, &viewCI, nullptr, &depthImageView));
}
```

--------------------------------

### Configure Viewport and Scissor State

Source: https://www.howtovulkan.com/

Sets up the viewport and scissor rectangles for the graphics pipeline. These are configured as dynamic states to allow changes without recreating the pipeline.

```cpp
VkPipelineViewportStateCreateInfo viewportState{
    .sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO,
    .viewportCount = 1,
    .scissorCount = 1
};
std::vector<VkDynamicState> dynamicStates{ VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR };
VkPipelineDynamicStateCreateInfo dynamicState{
    .sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO,
    .dynamicStateCount = 2,
    .pDynamicStates = dynamicStates.data()
};

```

--------------------------------

### Check Presentation Support for Queue Family

Source: https://www.howtovulkan.com/

Verifies if the identified graphics queue family also supports presentation to the screen using SDL.

```cpp
chk(SDL_Vulkan_GetPresentationSupport(instance, devices[deviceIndex], queueFamily));
```

--------------------------------

### Create Global Slang Session

Source: https://www.howtovulkan.com/

Initializes the global Slang session, establishing the connection between the application and the Slang library. This is a prerequisite for other Slang operations.

```cpp
slang::createGlobalSession(slangGlobalSession.writeRef());
```

--------------------------------

### Enable Physical Device Features

Source: https://www.howtovulkan.com/

Enable core Vulkan physical device features, such as anisotropic filtering for improved texture quality.

```cpp
VkPhysicalDeviceFeatures enabledVk10Features{
    .samplerAnisotropy = VK_TRUE
};
```

--------------------------------

### Create Graphics Pipeline

Source: https://www.howtovulkan.com/

Combines all configured state structures to create the final graphics pipeline. Ensure all necessary state structures (e.g., vertexInputState, inputAssemblyState) are properly defined and passed.

```cpp
VkGraphicsPipelineCreateInfo pipelineCI{
    .sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO,
    .pNext = &renderingCI,
    .stageCount = 2,
    .pStages = shaderStages.data(),
    .pVertexInputState = &vertexInputState,
    .pInputAssemblyState = &inputAssemblyState,
    .pViewportState = &viewportState,
    .pRasterizationState = &rasterizationState,
    .pMultisampleState = &multisampleState,
    .pDepthStencilState = &depthStencilState,
    .pColorBlendState = &colorBlendState,
    .pDynamicState = &dynamicState,
    .layout = pipelineLayout
};
chk(vkCreateGraphicsPipelines(device, VK_NULL_HANDLE, 1, &pipelineCI, nullptr, &pipeline));

```

--------------------------------

### Load .obj File with tinyobjloader

Source: https://www.howtovulkan.com/

Uses the tinyobjloader library to parse an .obj file and load its attributes, shapes, and materials.

```cpp
// Mesh data
tinyobj::attrib_t attrib;
std::vector<tinyobj::shape_t> shapes;
std::vector<tinyobj::material_t> materials;
chk(tinyobj::LoadObj(&attrib, &shapes, &materials, nullptr, nullptr, "assets/suzanne.obj"));
```

--------------------------------

### Present Swapchain Image

Source: https://www.howtovulkan.com/

Presents the rendered swapchain image to the screen. This function waits on the render completion semaphore to ensure that all rendering commands have finished before the image is displayed. It enqueues the image for presentation.

```c++
VkPresentInfoKHR presentInfo{
    .sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR,
    .waitSemaphoreCount = 1,
    .pWaitSemaphores = &renderCompleteSemaphores[imageIndex],
    .swapchainCount = 1,
    .pSwapchains = &swapchain,
    .pImageIndices = &imageIndex
};
chkSwapchain(vkQueuePresentKHR(queue, &presentInfo));

```

--------------------------------

### Select Depth Format

Source: https://www.howtovulkan.com/

Iterates through a list of preferred depth formats to find one supported by the GPU for depth stencil attachments.

```cpp
std::vector<VkFormat> depthFormatList{ VK_FORMAT_D32_SFLOAT_S8_UINT, VK_FORMAT_D24_UNORM_S8_UINT };
VkFormat depthFormat{ VK_FORMAT_UNDEFINED };
for (VkFormat& format : depthFormatList) {
    VkFormatProperties2 formatProperties{ .sType = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2 };
    vkGetPhysicalDeviceFormatProperties2(devices[deviceIndex], format, &formatProperties);
    if (formatProperties.formatProperties.optimalTilingFeatures & VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT) {
        depthFormat = format;
        break;
    }
}

```

--------------------------------

### Vulkan Image Layout Transitions with Pipeline Barrier

Source: https://www.howtovulkan.com/

Issues image memory barriers to transition layouts and enforce pipeline stage synchronization. This ensures correct access to images like swapchain and depth images during rendering.

```cpp
std::array<VkImageMemoryBarrier2, 2> outputBarriers{
    VkImageMemoryBarrier2{
        .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2,
        .srcStageMask = VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT,
        .srcAccessMask = 0,
        .dstStageMask = VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT,
        .dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
        .oldLayout = VK_IMAGE_LAYOUT_UNDEFINED,
        .newLayout = VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL,
        .image = swapchainImages[imageIndex],
        .subresourceRange{.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT, .levelCount = 1, .layerCount = 1 }
    },
    VkImageMemoryBarrier2{
        .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2,
        .srcStageMask = VK_PIPELINE_STAGE_2_LATE_FRAGMENT_TESTS_BIT,
        .srcAccessMask = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT,
        .dstStageMask = VK_PIPELINE_STAGE_2_EARLY_FRAGMENT_TESTS_BIT,
        .dstAccessMask = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT,
        .oldLayout = VK_IMAGE_LAYOUT_UNDEFINED,
        .newLayout = VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL,
        .image = depthImage,
        .subresourceRange{.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT, .levelCount = 1, .layerCount = 1 }
    }
        };
VkDependencyInfo barrierDependencyInfo{
    .sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO,
    .imageMemoryBarrierCount = 2,
    .pImageMemoryBarriers = outputBarriers.data()
};
vkCmdPipelineBarrier2(cb, &barrierDependencyInfo);
```

--------------------------------

### Configure Vertex Input State

Source: https://www.howtovulkan.com/

Sets up the vertex input state for the graphics pipeline using the defined binding descriptions and attribute descriptions. This structure is essential for the pipeline to correctly interpret vertex data.

```cpp
VkPipelineVertexInputStateCreateInfo vertexInputState{
    .sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO,
    .vertexBindingDescriptionCount = 1,
    .pVertexBindingDescriptions = &vertexBinding,
    .vertexAttributeDescriptionCount = static_cast<uint32_t>(vertexAttributes.size()),
    .pVertexAttributeDescriptions = vertexAttributes.data(),
};

```

--------------------------------

### Configure Default Pipeline States

Source: https://www.howtovulkan.com/

Sets default values for color blending, rasterization, and multisampling states. These are required even if not explicitly used, ensuring sane defaults.

```cpp
VkPipelineColorBlendAttachmentState blendAttachment{
    .colorWriteMask = 0xF
};
VkPipelineColorBlendStateCreateInfo colorBlendState{
    .sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO,
    .attachmentCount = 1,
    .pAttachments = &blendAttachment
};
VkPipelineRasterizationStateCreateInfo rasterizationState{
     .sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO,
     .lineWidth = 1.0f
};
VkPipelineMultisampleStateCreateInfo multisampleState{
    .sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO,
    .rasterizationSamples = VK_SAMPLE_COUNT_1_BIT
};

```

--------------------------------

### Create Vulkan Fences and Semaphores

Source: https://www.howtovulkan.com/

Creates Vulkan fences and semaphores. Fences are signaled when GPU work is complete, useful for CPU-GPU synchronization. Semaphores control GPU-side resource access, particularly for presentation.

```cpp
VkSemaphoreCreateInfo semaphoreCI{
    .sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO
};
VkFenceCreateInfo fenceCI{
    .sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,
    .flags = VK_FENCE_CREATE_SIGNALED_BIT
};
for (auto i = 0; i < maxFramesInFlight; i++) {
    chk(vkCreateFence(device, &fenceCI, nullptr, &fences[i]));
    chk(vkCreateSemaphore(device, &semaphoreCI, nullptr, &imageAcquiredSemaphores[i]));
}
renderCompleteSemaphores.resize(swapchainImages.size());
for (auto& semaphore : renderCompleteSemaphores) {
    chk(vkCreateSemaphore(device, &semaphoreCI, nullptr, &semaphore));
}

```

--------------------------------

### Configure Input Assembly State

Source: https://www.howtovulkan.com/

Defines how primitives are assembled from vertex data. Use `VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST` for rendering separate triangles.

```cpp
VkPipelineInputAssemblyStateCreateInfo inputAssemblyState{
    .sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO,
    .topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST
};

```

--------------------------------

### Load KTX Texture File

Source: https://www.howtovulkan.com/

Loads a KTX texture file from disk using libktx. Ensure the KTX_TEXTURE_CREATE_LOAD_IMAGE_DATA_BIT is set to load the image data.

```cpp
for (auto i = 0; i < textures.size(); i++) {
    ktxTexture* ktxTexture{ nullptr };
    std::string filename = "assets/suzanne" + std::to_string(i) + ".ktx";
    ktxTexture_CreateFromNamedFile(filename.c_str(), KTX_TEXTURE_CREATE_LOAD_IMAGE_DATA_BIT, &ktxTexture);
    ...


```

--------------------------------

### Configure Shader Stages for Graphics Pipeline

Source: https://www.howtovulkan.com/

Defines the vertex and fragment shader stages for the graphics pipeline. Ensure shaderModule is a valid VkShaderModule and 'main' is the entry point.

```cpp
std::vector<VkPipelineShaderStageCreateInfo> shaderStages{
    { .sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
      .stage = VK_SHADER_STAGE_VERTEX_BIT,
      .module = shaderModule, .pName = "main"},
    { .sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
      .stage = VK_SHADER_STAGE_FRAGMENT_BIT,
      .module = shaderModule, .pName = "main" }
};

```

--------------------------------

### Acquire Next Swapchain Image in Vulkan

Source: https://www.howtovulkan.com/

Acquires the next available swapchain image index for rendering. Uses a semaphore to signal completion and handles potential swapchain re-creation errors.

```cpp
chkSwapchain(vkAcquireNextImageKHR(device, swapchain, UINT64_MAX, imageAcquiredSemaphores[frameIndex], VK_NULL_HANDLE, &imageIndex));

```

--------------------------------

### Create Depth Image View

Source: https://www.howtovulkan.com/

Creates a Vulkan image view for the depth image, specifying the format and the subresource range to access the depth aspect.

```cpp
VkImageViewCreateInfo depthViewCI{ 
    .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
    .image = depthImage,
    .viewType = VK_IMAGE_VIEW_TYPE_2D,
    .format = depthFormat,
    .subresourceRange{ .aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT, .levelCount = 1, .layerCount = 1 }
};
chk(vkCreateImageView(device, &depthViewCI, nullptr, &depthImageView));

```

--------------------------------

### Bind Graphics Pipeline and Resources

Source: https://www.howtovulkan.com/

Binds the graphics pipeline, descriptor sets for textures, vertex buffers, and index buffers to the command buffer. This prepares the rendering state for drawing 3D objects.

```c++
vkCmdBindPipeline(cb, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline);
VkDeviceSize vOffset{ 0 };
vkCmdBindDescriptorSets(cb, VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayout, 0, 1, &descriptorSetTex, 0, nullptr);
vkCmdBindVertexBuffers(cb, 0, 1, &vBuffer, &vOffset);
vkCmdBindIndexBuffer(cb, vBuffer, vBufSize, VK_INDEX_TYPE_UINT16);

```

--------------------------------

### Create Vulkan Sampler

Source: https://www.howtovulkan.com/

Configures a VkSamplerCreateInfo for linear filtering and anisotropic sampling. Use this to define how textures are sampled in shaders. The maxLod is set to use all mip levels.

```cpp
VkSamplerCreateInfo samplerCI{
    .sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO,
    .magFilter = VK_FILTER_LINEAR,
    .minFilter = VK_FILTER_LINEAR,
    .mipmapMode = VK_SAMPLER_MIPMAP_MODE_LINEAR,
    .anisotropyEnable = VK_TRUE,
    .maxAnisotropy = 8.0f, // 8 is a widely supported value for max anisotropy
    .maxLod = (float)ktxTexture->numLevels,
};
chk(vkCreateSampler(device, &samplerCI, nullptr, &textures[i].sampler));


```

--------------------------------

### Create Shader Data Buffers

Source: https://www.howtovulkan.com/

Creates uniform buffers for shader data, one for each frame in flight. Uses VMA for allocation with host-visible and mapped memory.

```cpp
for (auto i = 0; i < maxFramesInFlight; i++) {
    VkBufferCreateInfo uBufferCI{
        .sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
        .size = sizeof(ShaderData),
        .usage = VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT
    };
    VmaAllocationCreateInfo uBufferAllocCI{
        .flags = VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT | VMA_ALLOCATION_CREATE_HOST_ACCESS_ALLOW_TRANSFER_INSTEAD_BIT | VMA_ALLOCATION_CREATE_MAPPED_BIT,
        .usage = VMA_MEMORY_USAGE_AUTO
    };
    chk(vmaCreateBuffer(allocator, &uBufferCI, &uBufferAllocCI, &shaderDataBuffers[i].buffer, &shaderDataBuffers[i].allocation, &shaderDataBuffers[i].allocationInfo));


```

--------------------------------

### Record Texture Transfer Commands

Source: https://www.howtovulkan.com/

Records commands to transition the texture image layout, copy buffer data to the image, and transition back to a readable layout. This sequence is essential for preparing textures for GPU access.

```c++
VkCommandBufferBeginInfo cbOneTimeBI{
    .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
    .flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT
};
chk(vkBeginCommandBuffer(cbOneTime, &cbOneTimeBI));
VkImageMemoryBarrier2 barrierTexImage{
    .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2,
    .srcStageMask = VK_PIPELINE_STAGE_2_NONE,
    .srcAccessMask = VK_ACCESS_2_NONE,
    .dstStageMask = VK_PIPELINE_STAGE_2_TRANSFER_BIT,
    .dstAccessMask = VK_ACCESS_2_TRANSFER_WRITE_BIT,
    .oldLayout = VK_IMAGE_LAYOUT_UNDEFINED,
    .newLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
    .image = textures[i].image,
    .subresourceRange = { .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT, .levelCount = ktxTexture->numLevels, .layerCount = 1 }
};
VkDependencyInfo barrierTexInfo{
    .sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO,
    .imageMemoryBarrierCount = 1,
    .pImageMemoryBarriers = &barrierTexImage
};
vkCmdPipelineBarrier2(cbOneTime, &barrierTexInfo);
std::vector<VkBufferImageCopy> copyRegions{};
for (auto j = 0; j < ktxTexture->numLevels; j++) {
    ktx_size_t mipOffset{0};
    KTX_error_code ret = ktxTexture_GetImageOffset(ktxTexture, j, 0, 0, &mipOffset);
    copyRegions.push_back({
        .bufferOffset = mipOffset,
        .imageSubresource{.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT, .mipLevel = (uint32_t)j, .layerCount = 1},
        .imageExtent{.width = ktxTexture->baseWidth >> j, .height = ktxTexture->baseHeight >> j, .depth = 1 },
    });
}
vkCmdCopyBufferToImage(cbOneTime, imgSrcBuffer, textures[i].image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, static_cast<uint32_t>(copyRegions.size()), copyRegions.data());
VkImageMemoryBarrier2 barrierTexRead{
    .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2,
    .srcStageMask = VK_PIPELINE_STAGE_TRANSFER_BIT,
    .srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT,
    .dstStageMask = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
    .dstAccessMask = VK_ACCESS_SHADER_READ_BIT,
    .oldLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
    .newLayout = VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL,
    .image = textures[i].image,
    .subresourceRange = {.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT, .levelCount = ktxTexture->numLevels, .layerCount = 1 }
};
barrierTexInfo.pImageMemoryBarriers = &barrierTexRead;
vkCmdPipelineBarrier2(cbOneTime, &barrierTexInfo);
chk(vkEndCommandBuffer(cbOneTime));
VkSubmitInfo oneTimeSI{
    .sType = VK_STRUCTURE_TYPE_SUBMIT_INFO,
    .commandBufferCount = 1,
    .pCommandBuffers = &cbOneTime
};
chk(vkQueueSubmit(queue, 1, &oneTimeSI, fenceOneTime));
chk(vkWaitForFences(device, 1, &fenceOneTime, VK_TRUE, UINT64_MAX));

```

--------------------------------

### Create Depth Image Info

Source: https://www.howtovulkan.com/

Defines the properties for the depth image, including its dimensions, format, tiling, and usage.

```cpp
VkImageCreateInfo depthImageCI{
    .sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
    .imageType = VK_IMAGE_TYPE_2D,
    .format = depthFormat,
    .extent{.width = static_cast<uint32_t>(windowSize.x), .height = static_cast<uint32_t>(windowSize.y), .depth = 1 },
    .mipLevels = 1,
    .arrayLayers = 1,
    .samples = VK_SAMPLE_COUNT_1_BIT,
    .tiling = VK_IMAGE_TILING_OPTIMAL,
    .usage = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT,
    .initialLayout = VK_IMAGE_LAYOUT_UNDEFINED,
};

```

--------------------------------

### Create Vulkan Image View for Texture

Source: https://www.howtovulkan.com/

Creates a VkImageView for accessing the texture image. This view is configured to access the entire image, including all mip levels, for sampling in shaders.

```cpp
VkImageViewCreateInfo texVewCI{
    .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
    .image = textures[i].image,
    .viewType = VK_IMAGE_VIEW_TYPE_2D,
    .format = texImgCI.format,
    .subresourceRange = {.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT, .levelCount = ktxTexture->numLevels, .layerCount = 1 }
};
chk(vkCreateImageView(device, &texVewCI, nullptr, &textures[i].view));


```

--------------------------------

### Create Vulkan Pipeline Layout

Source: https://www.howtovulkan.com/

Defines the interface between the pipeline and shaders, including descriptor set layouts and push constant ranges. Use this when setting up a new graphics pipeline.

```cpp
VkPushConstantRange pushConstantRange{
    .stageFlags = VK_SHADER_STAGE_VERTEX_BIT,
    .size = sizeof(VkDeviceAddress)
};
VkPipelineLayoutCreateInfo pipelineLayoutCI{
    .sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,
    .setLayoutCount = 1,
    .pSetLayouts = &descriptorSetLayoutTex,
    .pushConstantRangeCount = 1,
    .pPushConstantRanges = &pushConstantRange
};
chk(vkCreatePipelineLayout(device, &pipelineLayoutCI, nullptr, &pipelineLayout));

```

--------------------------------

### Wait on Fence in Vulkan

Source: https://www.howtovulkan.com/

Synchronizes CPU and GPU work by waiting for the previous frame's command buffer to complete execution on the GPU. Resets the fence for the next submission.

```cpp
chk(vkWaitForFences(device, 1, &fences[frameIndex], true, UINT64_MAX));
chk(vkResetFences(device, 1, &fences[frameIndex]));

```

--------------------------------

### Configure Dynamic Rendering State

Source: https://www.howtovulkan.com/

Specifies parameters for dynamic rendering, including the number and formats of color and depth attachments. This is passed via the pNext chain as it's not a core member of the pipeline create info.

```cpp
VkPipelineRenderingCreateInfo renderingCI{
    .sType = VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO,
    .colorAttachmentCount = 1,
    .pColorAttachmentFormats = &imageFormat,
    .depthAttachmentFormat = depthFormat
};

```

--------------------------------

### Configure Depth/Stencil State

Source: https://www.howtovulkan.com/

Enables depth testing and writing, and sets the depth comparison operation to 'less or equal'. This ensures fragments closer to the viewer pass the depth test.

```cpp
VkPipelineDepthStencilStateCreateInfo depthStencilState{
    .sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO,
    .depthTestEnable = VK_TRUE,
    .depthWriteEnable = VK_TRUE,
    .depthCompareOp = VK_COMPARE_OP_LESS_OR_EQUAL
};

```

--------------------------------

### Create Vulkan Image for Texture

Source: https://www.howtovulkan.com/

Creates a VkImage object for storing texture data. The image format, dimensions, mip levels, and usage flags are derived from the loaded KTX texture. VMA is used for automatic memory allocation.

```cpp
VkImageCreateInfo texImgCI{
    .sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
    .imageType = VK_IMAGE_TYPE_2D,
    .format = ktxTexture_GetVkFormat(ktxTexture),
    .extent = {.width = ktxTexture->baseWidth, .height = ktxTexture->baseHeight, .depth = 1 },
    .mipLevels = ktxTexture->numLevels,
    .arrayLayers = 1,
    .samples = VK_SAMPLE_COUNT_1_BIT,
    .tiling = VK_IMAGE_TILING_OPTIMAL,
    .usage = VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_SAMPLED_BIT,
    .initialLayout = VK_IMAGE_LAYOUT_UNDEFINED
};
VmaAllocationCreateInfo texImageAllocCI{ .usage = VMA_MEMORY_USAGE_AUTO };
chk(vmaCreateImage(allocator, &texImgCI, &texImageAllocCI, &textures[i].image, &textures[i].allocation, nullptr));


```

--------------------------------

### Create Vertex and Index Buffer

Source: https://www.howtovulkan.com/

Creates a Vulkan buffer to hold both interleaved vertex and index data, specifying usage flags for vertex and index buffers.

```cpp
VkDeviceSize vBufSize{ sizeof(Vertex) * vertices.size() };
VkDeviceSize iBufSize{ sizeof(uint16_t) * indices.size() };
VkBufferCreateInfo bufferCI{
    .sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
    .size = vBufSize + iBufSize,
    .usage = VK_BUFFER_USAGE_VERTEX_BUFFER_BIT | VK_BUFFER_USAGE_INDEX_BUFFER_BIT
};
```

--------------------------------

### Determine Swapchain Extent

Source: https://www.howtovulkan.com/

Calculate the swapchain's extent (width and height), accounting for Wayland's special case where the extent is determined by the window size.

```c++
VkExtent2D swapchainExtent{ surfaceCaps.currentExtent };
if (surfaceCaps.currentExtent.width == 0xFFFFFFFF) {
    swapchainExtent = { .width = static_cast<uint32_t>(windowSize.x), .height = static_cast<uint32_t>(windowSize.y) };
}
```

--------------------------------

### Allocate Vertex and Index Buffer with VMA

Source: https://www.howtovulkan.com/

Allocates GPU memory for the vertex and index buffer using VMA, configured for sequential host writes and allowing transfers.

```cpp
VmaAllocationCreateInfo vBufferAllocCI{
    .flags = VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT | VMA_ALLOCATION_CREATE_HOST_ACCESS_ALLOW_TRANSFER_INSTEAD_BIT | VMA_ALLOCATION_CREATE_MAPPED_BIT,
    .usage = VMA_MEMORY_USAGE_AUTO
};
VmaAllocationInfo vBufferAllocInfo{};
chk(vmaCreateBuffer(allocator, &bufferCI, &vBufferAllocCI, &vBuffer, &vBufferAllocation, &vBufferAllocInfo));
```

--------------------------------

### Create Vulkan Command Pool

Source: https://www.howtovulkan.com/

Creates a Vulkan command pool with the capability to reset command buffers. This pool is used for allocating command buffers that will be submitted to a specific queue family.

```cpp
VkCommandPoolCreateInfo commandPoolCI{
    .sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,
    .flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT,
    .queueFamilyIndex = queueFamily
};
chk(vkCreateCommandPool(device, &commandPoolCI, nullptr, &commandPool));

```

--------------------------------

### Create Vulkan Descriptor Pool

Source: https://www.howtovulkan.com/

Allocates a VkDescriptorPool for combined image samplers. This pool is configured to hold a number of descriptors equal to the number of textures loaded, with a maximum of one set.

```cpp
VkDescriptorPoolSize poolSize{
    .type = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
    .descriptorCount = static_cast<uint32_t>(textures.size())
};
VkDescriptorPoolCreateInfo descPoolCI{
    .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO,
    .maxSets = 1,
    .poolSizeCount = 1,
    .pPoolSizes = &poolSize
};
chk(vkCreateDescriptorPool(device, &descPoolCI, nullptr, &descriptorPool));


```

--------------------------------

### Vulkan Vertex and Fragment Shader

Source: https://www.howtovulkan.com/

This shader combines vertex and fragment stages. The vertex shader processes input vertices, applies model transformations, and calculates lighting vectors. The fragment shader performs Phong lighting and samples textures based on the instance index. Use this for rendering 3D models with per-instance transformations and lighting.

```slang
struct VSInput {
    float3 Pos;
    float3 Normal;
    float2 UV;
};

Sampler2D textures[];

struct ShaderData {
    float4x4 projection;
    float4x4 view;
    float4x4 model[3];
    float4 lightPos;
    uint32_t selected;
};

struct VSOutput {
    float4 Pos : SV_POSITION;
    float3 Normal;
    float2 UV;
    float3 Factor;
    float3 LightVec;
    float3 ViewVec;
    uint32_t InstanceIndex;
};

[shader("vertex")]
VSOutput main(VSInput input, uniform ShaderData *shaderData, uint instanceIndex : SV_VulkanInstanceID) {
    VSOutput output;
    float4x4 modelMat = shaderData->model[instanceIndex];
    output.Normal = mul((float3x3)mul(shaderData->view, modelMat), input.Normal);
    output.UV = input.UV;
    output.Pos = mul(shaderData->projection, mul(shaderData->view, mul(modelMat, float4(input.Pos.xyz, 1.0))));
    output.Factor = (shaderData->selected == instanceIndex ? 3.0f : 1.0f);
    output.InstanceIndex = instanceIndex;
    // Calculate view vectors required for lighting
    float4 fragPos = mul(mul(shaderData->view, modelMat), float4(input.Pos.xyz, 1.0));
    output.LightVec = shaderData->lightPos.xyz - fragPos.xyz;
    output.ViewVec = -fragPos.xyz;
    return output;
}

[shader("fragment")]
float4 main(VSOutput input) {
    // Phong lighting
    float3 N = normalize(input.Normal);
    float3 L = normalize(input.LightVec);
    float3 V = normalize(input.ViewVec);
    float3 R = reflect(-L, N);
    float3 diffuse = max(dot(N, L), 0.0025);
    float3 specular = pow(max(dot(R, V), 0.0), 16.0) * 0.75;
    // Sample from texture
    float3 color = textures[NonUniformResourceIndex(input.InstanceIndex)].Sample(input.UV).rgb * input.Factor;
    return float4(diffuse * color.rgb + specular, 1.0);
}

```
Tokens:
Raw