rendering_engine::VulkanRenderer Class Reference

Vulkan-based implementation of the IRenderer interface. More...

#include <vulkan_renderer.hpp>

Inherits rendering_engine::IRenderer.

Public Member Functions
	VulkanRenderer (IWindowSystem &windowSystem)
	Constructs a VulkanRenderer bound to a specific window system.
void	InitializeRenderer () override
	Initializes all rendering subsystems and GPU resources.
void	DrawFrame () override
	Executes a full frame rendering cycle.
bool	BeginFrame () override
	Begins frame rendering operations.
void	BeginRenderPass () override
	Begins the active render pass for the current frame.
void	EndRenderPass () override
	Ends the active render pass.
void	EndFrame () override
	Completes the current frame rendering and presents the result.
void	WaitIdle () override
	Waits until the GPU has finished all pending rendering operations.
void	ShutdownRenderer () override
	Destroys and cleans up all rendering resources.
void	RegisterObserver (IRendererObserver *notifier) override
	Registers an observer for rendering events.
void	UnregisterObserver (IRendererObserver *notifier) override
	Unregisters a previously registered observer.
IRenderResources *	ProvideRenderResources () const override
	Provides access to the general rendering resource manager.
ITextureRenderResources *	ProvideTextureRenderResources () const override
	Provides access to texture-related GPU resources.
IMaterialRenderResources *	ProvideMaterialRenderResources () const override
	Provides access to material-related GPU resources.
IMeshRenderResources *	ProvideMeshRenderResources () const override
	Provides access to mesh-related GPU resources.
void	SetDefaultColor (float r, float g, float b) override
	Sets the renderer clear color.
void	CreateBuffer (VkDeviceSize size, VkBufferUsageFlags usage, VkMemoryPropertyFlags properties, VkBuffer &buffer, VkDeviceMemory &bufferMemory)
	Creates a new Vulkan buffer with the specified usage and memory properties.
void	CopyBuffer (VkBuffer srcBuffer, VkBuffer dstBuffer, VkDeviceSize size)
	Copies data from one buffer to another using a temporary command buffer.
VkDevice &	GetLogicalDevice ()
	Returns reference to the logical Vulkan device.
void	TransitionImageLayout (VkImage image, VkFormat format, VkImageLayout oldLayout, VkImageLayout newLayout, std::uint32_t mipmapLevels)
	Transitions the image layout for a given Vulkan image.
void	CopyBufferToImage (VkBuffer buffer, VkImage image, uint32_t width, uint32_t height)
	Copies buffer data into an image (used for uploading texture data).
void	GenerateMipmaps (VkImage image, VkFormat imageFormat, int32_t texWidth, int32_t texHeight, uint32_t mipLevels)
	Generates mipmaps for a given image resource.
uint32_t	FindMemoryType (uint32_t typeFilter, VkMemoryPropertyFlags properties)
	Finds a suitable memory type for a given allocation.
VkPhysicalDevice &	GetPhysicalDevice ()
	Returns reference to the physical device.
VkPhysicalDeviceFeatures &	GetPhysDevSupportedFeatures ()
	Returns reference to the physical device�s supported features.
VkDescriptorSetLayout	CreateDescriptorSetLayout (Material *material)
	Creates a descriptor set layout corresponding to a given material.
size_t	GetCurrentFrame () const
	Returns the index of the currently active frame in flight.
std::vector< VkCommandBuffer >	GetComandBuffers ()
	Returns the collection of command buffers used for rendering.
std::pair< VkPipelineLayout, VkPipeline >	CreateGraphicsPipeline (Material *material, VkDescriptorSetLayout &descriptorSetLayout, std::vector< char > &spvVertShaderCode, std::vector< char > &spvFragShaderCode)
	Creates a Vulkan graphics pipeline based on material and shader inputs.
void	AddDeferredDestroy (DeferredItem deferredItem)
Public Member Functions inherited from rendering_engine::IRenderer
virtual	~IRenderer ()=default
	Virtual destructor for safe polymorphic deletion.

Static Public Member Functions
template<typename T >
static VkVertexInputBindingDescription	GetBindingDescription ()
	Returns a vertex input binding description for a specific vertex type.
template<typename T >
static std::vector< VkVertexInputAttributeDescription >	GetAttributeDescriptions ()
	Returns vertex attribute descriptions for a specific vertex type.
template<>
std::vector< VkVertexInputAttributeDescription >	GetAttributeDescriptions ()
template<>
std::vector< VkVertexInputAttributeDescription >	GetAttributeDescriptions ()
template<>
std::vector< VkVertexInputAttributeDescription >	GetAttributeDescriptions ()
template<>
std::vector< VkVertexInputAttributeDescription >	GetAttributeDescriptions ()
template<>
std::vector< VkVertexInputAttributeDescription >	GetAttributeDescriptions ()
template<>
std::vector< VkVertexInputAttributeDescription >	GetAttributeDescriptions ()

Detailed Description

Vulkan-based implementation of the IRenderer interface.

This class encapsulates the initialization and management of Vulkan rendering resources, including device selection, swap chain management, render pass setup, frame synchronization, and command buffer submission. It serves as the core rendering backend for all graphics operations performed by the engine.

Definition at line 89 of file vulkan_renderer.hpp.

Constructor & Destructor Documentation

VulkanRenderer()

rendering_engine::VulkanRenderer::VulkanRenderer

(

IWindowSystem &

windowSystem

)

Constructs a VulkanRenderer bound to a specific window system.

Parameters

windowSystem

Reference to the window system used for surface creation and event handling.

Definition at line 39 of file vulkan_renderer.cpp.

    :
    mWindowSystem{windowSystem},
    mCurrentFrame{0}
{}

Member Function Documentation

AddDeferredDestroy()

void rendering_engine::VulkanRenderer::AddDeferredDestroy

(

DeferredItem

deferredItem

)

Definition at line 598 of file vulkan_renderer.cpp.

{
    switch (deferredItem.type)
    {
        case DeferredType::Buffer:         if (deferredItem.buffer == VK_NULL_HANDLE) return; break;
        case DeferredType::Memory:         if (deferredItem.memory == VK_NULL_HANDLE) return; break;
        case DeferredType::DescriptorPool: if (deferredItem.descriptorPool == VK_NULL_HANDLE) return; break;
    default: break;
    }
    deferredItem.retireFrame = mFrameSerial + MAX_FRAMES_IN_FLIGHT;
    mDeferredQueue.push_back(deferredItem);
}

BeginFrame()

bool rendering_engine::VulkanRenderer::BeginFrame ( )

overridevirtual

Begins frame rendering operations.

Returns

True if the frame can proceed.

Implements rendering_engine::IRenderer.

Definition at line 149 of file vulkan_renderer.cpp.

{
    vkWaitForFences(mLogicalDevice, 1, &mInFlightFences[mCurrentFrame], VK_TRUE, UINT64_MAX);
 
    VkResult result = vkAcquireNextImageKHR(mLogicalDevice, mSwapChain, UINT64_MAX, mImageAvailableSemaphores[mCurrentFrame], VK_NULL_HANDLE, &mImageIndex);
 
    if (result == VK_ERROR_OUT_OF_DATE_KHR)
    {
        RecreateSwapChain();
        return false;
    }
    else
    {
        if (result != VK_SUCCESS && result != VK_SUBOPTIMAL_KHR)
        {
            LOG_ERROR("failed to acquire swap chain image!");
            throw std::runtime_error("failed to acquire swap chain image!");
        }
    }
    
    if (mImagesInFlight[mImageIndex] != VK_NULL_HANDLE)
    {
        vkWaitForFences(mLogicalDevice, 1, &mImagesInFlight[mImageIndex], VK_TRUE, UINT64_MAX);
    }
    mImagesInFlight[mImageIndex] = mInFlightFences[mCurrentFrame];
 
    vkResetFences(mLogicalDevice, 1, &mInFlightFences[mCurrentFrame]);
    ++mFrameSerial;  
    ProcessDeferredDestruction();
 
    vkResetCommandBuffer(mCommandBuffers[mCurrentFrame], /*VkCommandBufferResetFlagBits*/ 0);
 
    return true;
}

BeginRenderPass()

void rendering_engine::VulkanRenderer::BeginRenderPass ( )

overridevirtual

Begins the active render pass for the current frame.

Implements rendering_engine::IRenderer.

Definition at line 184 of file vulkan_renderer.cpp.

{
    VkCommandBufferBeginInfo beginInfo{};
    beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
    //beginInfo.flags = 0; // Optional
    //beginInfo.pInheritanceInfo = nullptr; // Optional
 
    if (vkBeginCommandBuffer(mCommandBuffers[mCurrentFrame], &beginInfo) != VK_SUCCESS)
    {
        LOG_ERROR("failed to begin recording command buffer!");
        throw std::runtime_error("failed to begin recording command buffer!");
    }
 
    VkRenderPassBeginInfo renderPassInfo{};
    renderPassInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
    renderPassInfo.renderPass = mRenderPass;
    renderPassInfo.framebuffer = mSwapChainFramebuffers[mImageIndex];
 
    renderPassInfo.renderArea.offset = { 0, 0 };
    renderPassInfo.renderArea.extent = mSwapChainExtent;
 
    std::array<VkClearValue, 2> clearValues{};
    clearValues[0].color = { {mDefaultColor.r, mDefaultColor.g, mDefaultColor.b, 1.0f} };
    clearValues[1].depthStencil = { 1.0f, 0 };
    renderPassInfo.clearValueCount = static_cast<uint32_t>(clearValues.size());
    renderPassInfo.pClearValues = clearValues.data();
 
    vkCmdBeginRenderPass(mCommandBuffers[mCurrentFrame], &renderPassInfo, VK_SUBPASS_CONTENTS_INLINE);
}

CopyBuffer()

void rendering_engine::VulkanRenderer::CopyBuffer	(	VkBuffer	srcBuffer,
		VkBuffer	dstBuffer,
		VkDeviceSize	size
	)

Copies data from one buffer to another using a temporary command buffer.

Parameters

srcBuffer	Source buffer.
dstBuffer	Destination buffer.
size	Size of data to copy in bytes.

Definition at line 383 of file vulkan_renderer.cpp.

{
    auto commandBuffer = BeginSingleTimeCommand();
 
    VkBufferCopy copyRegion{};
    copyRegion.srcOffset = 0; // Optional
    copyRegion.dstOffset = 0; // Optional
    copyRegion.size = size;
    vkCmdCopyBuffer(commandBuffer, srcBuffer, dstBuffer, 1, &copyRegion);
 
    EndSingleTimeCommand(commandBuffer);
}

CopyBufferToImage()

void rendering_engine::VulkanRenderer::CopyBufferToImage	(	VkBuffer	buffer,
		VkImage	image,
		uint32_t	width,
		uint32_t	height
	)

Copies buffer data into an image (used for uploading texture data).

Parameters

buffer	Source buffer containing pixel data.
image	Destination image.
width	Image width in pixels.
height	Image height in pixels.

Definition at line 474 of file vulkan_renderer.cpp.

{
    VkCommandBuffer commandBuffer = BeginSingleTimeCommand();
 
    VkBufferImageCopy region{};
    region.bufferOffset = 0;
    region.bufferRowLength = 0;
    region.bufferImageHeight = 0;
 
    region.imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
    region.imageSubresource.mipLevel = 0;
    region.imageSubresource.baseArrayLayer = 0;
    region.imageSubresource.layerCount = 1;
 
    region.imageOffset = { 0, 0, 0 };
    region.imageExtent = {
        width,
        height,
        1
    };
 
    vkCmdCopyBufferToImage(
        commandBuffer,
        buffer,
        image,
        VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
        1,
        &region
    );
 
    EndSingleTimeCommand(commandBuffer);
}

CreateBuffer()

void rendering_engine::VulkanRenderer::CreateBuffer	(	VkDeviceSize	size,
		VkBufferUsageFlags	usage,
		VkMemoryPropertyFlags	properties,
		VkBuffer &	buffer,
		VkDeviceMemory &	bufferMemory
	)

Creates a new Vulkan buffer with the specified usage and memory properties.

Parameters

size	Size of the buffer in bytes.
usage	Bitmask specifying intended buffer usage.
properties	Memory property flags defining allocation type.
buffer	Output handle to the created buffer.
bufferMemory	Output handle to the allocated buffer memory.

Definition at line 351 of file vulkan_renderer.cpp.

{
    VkBufferCreateInfo bufferInfo{};
    bufferInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
    bufferInfo.size = size;
 
    bufferInfo.usage = usage;
    bufferInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
 
    if (vkCreateBuffer(mLogicalDevice, &bufferInfo, nullptr, &buffer) != VK_SUCCESS)
    {
        LOG_ERROR("failed to create vertex buffer!");
        throw std::runtime_error("failed to create vertex buffer!");
    }
 
    VkMemoryRequirements memRequirements;
    vkGetBufferMemoryRequirements(mLogicalDevice, buffer, &memRequirements);
 
    VkMemoryAllocateInfo allocInfo{};
    allocInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
    allocInfo.allocationSize = memRequirements.size;
    allocInfo.memoryTypeIndex = FindMemoryType(memRequirements.memoryTypeBits, properties);
 
    if (vkAllocateMemory(mLogicalDevice, &allocInfo, nullptr, &bufferMemory) != VK_SUCCESS)
    {
        LOG_ERROR("failed to allocate vertex buffer memory!");
        throw std::runtime_error("failed to allocate vertex buffer memory!");
    }
 
    vkBindBufferMemory(mLogicalDevice, buffer, bufferMemory, 0);
}

CreateDescriptorSetLayout()

VkDescriptorSetLayout rendering_engine::VulkanRenderer::CreateDescriptorSetLayout

(

Material *

material

)

Creates a descriptor set layout corresponding to a given material.

The layout defines how shader resources (uniform buffers, custom parameters, textures) are bound to the pipeline. By the local convention of this engine:

• Binding 0 � Transformation matrices (model, view, projection) depending on material domain (2D or 3D).
• Binding 1 � Custom parameter variable block (if any). All variables are serialized and packed into a single binding.
• Bindings 2..n � Texture samplers, one texture per binding.

This convention ensures consistent descriptor bindings across all shaders and materials.

Parameters

material

Pointer to the material defining binding structure.

Returns

Handle to the created descriptor set layout.

Definition at line 1407 of file vulkan_renderer.cpp.

{
    std::uint32_t bindingNumber = 0;
    std::vector<VkDescriptorSetLayoutBinding> bindings;
 
    // Uniform buffer to transmit transformation matrix
    VkDescriptorSetLayoutBinding uboLayoutBinding{};
    uboLayoutBinding.binding = bindingNumber;
    uboLayoutBinding.descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
    uboLayoutBinding.descriptorCount = 1;
    uboLayoutBinding.stageFlags = VK_SHADER_STAGE_VERTEX_BIT;
    uboLayoutBinding.pImmutableSamplers = nullptr; // Optional
 
    bindings.push_back(uboLayoutBinding);
 
    PackedMaterialData packedMaterialData = material->PackMaterialParameters();
    if (!packedMaterialData.buffer.empty())
    {
        ++bindingNumber;
        // Uniform buffer to transmit custom material variables
        VkDescriptorSetLayoutBinding customMaterialVariables;
        customMaterialVariables.binding = bindingNumber;
        customMaterialVariables.descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
        customMaterialVariables.descriptorCount = 1;
        customMaterialVariables.stageFlags = VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT;
        customMaterialVariables.pImmutableSamplers = nullptr; // Optional
 
        bindings.push_back(customMaterialVariables);
    }
 
    for (const auto& textureName : material->GetTextures())
    {
        (void)textureName;
        ++bindingNumber;
        VkDescriptorSetLayoutBinding samplerLayoutBinding{};
        samplerLayoutBinding.binding = bindingNumber;
        samplerLayoutBinding.descriptorCount = 1;
        samplerLayoutBinding.descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
        samplerLayoutBinding.pImmutableSamplers = nullptr;
        samplerLayoutBinding.stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT;
 
        bindings.push_back(samplerLayoutBinding);
    }
 
    VkDescriptorSetLayoutCreateInfo layoutInfo{};
    layoutInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
    layoutInfo.bindingCount = static_cast<uint32_t>(bindings.size());
    layoutInfo.pBindings = bindings.data();
 
    VkDescriptorSetLayout result;
    if (vkCreateDescriptorSetLayout(mLogicalDevice, &layoutInfo, nullptr, &result) != VK_SUCCESS)
    {
        LOG_ERROR("failed to create descriptor set layout!");
        throw std::runtime_error("failed to create descriptor set layout!");
    }
 
    return result;
}

CreateGraphicsPipeline()

std::pair< VkPipelineLayout, VkPipeline > rendering_engine::VulkanRenderer::CreateGraphicsPipeline	(	Material *	material,
		VkDescriptorSetLayout &	descriptorSetLayout,
		std::vector< char > &	spvVertShaderCode,
		std::vector< char > &	spvFragShaderCode
	)

Creates a Vulkan graphics pipeline based on material and shader inputs.

Parameters

material	Pointer to the material configuration.
descriptorSetLayout	Descriptor set layout used in the pipeline.
spvVertShaderCode	Compiled SPIR-V vertex shader bytecode.
spvFragShaderCode	Compiled SPIR-V fragment shader bytecode.

Returns

A pair containing pipeline layout and pipeline handle.

Definition at line 1471 of file vulkan_renderer.cpp.

{
    VkPipelineLayout pipelineLayout;
    VkPipeline pipeline;
 
    VkShaderModule vertShaderModule = CreateShaderModule(spvVertShaderCode);
    VkShaderModule fragShaderModule = CreateShaderModule(spvFragShaderCode);
 
    VkPipelineShaderStageCreateInfo vertShaderStageInfo{};
    vertShaderStageInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
    vertShaderStageInfo.stage = VK_SHADER_STAGE_VERTEX_BIT;
 
    vertShaderStageInfo.module = vertShaderModule;
    vertShaderStageInfo.pName = "main";
 
    VkPipelineShaderStageCreateInfo fragShaderStageInfo{};
    fragShaderStageInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
    fragShaderStageInfo.stage = VK_SHADER_STAGE_FRAGMENT_BIT;
    fragShaderStageInfo.module = fragShaderModule;
    fragShaderStageInfo.pName = "main";
 
    VkPipelineShaderStageCreateInfo shaderStages[] = { vertShaderStageInfo, fragShaderStageInfo };
 
    VkPipelineVertexInputStateCreateInfo vertexInputInfo{};
    vertexInputInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO;
 
    VkVertexInputBindingDescription bindingDescription;
    std::vector<VkVertexInputAttributeDescription> attributeDescriptions{};
 
    if (material->GetMaterialSettings().materialDomain == MaterialDomain::Sprite2D)
    {
        bindingDescription = GetBindingDescription<Vertex2D>();
        attributeDescriptions = GetAttributeDescriptions<Vertex2D>();
    }
    if (material->GetMaterialSettings().materialDomain == MaterialDomain::Surface3D)
    {
        bindingDescription = GetBindingDescription<VertexPositionColorTextureNormalTangent>();
        attributeDescriptions = GetAttributeDescriptions<VertexPositionColorTextureNormalTangent>();
    }
 
    vertexInputInfo.vertexBindingDescriptionCount = 1;
    vertexInputInfo.vertexAttributeDescriptionCount = static_cast<uint32_t>(attributeDescriptions.size());
 
    vertexInputInfo.pVertexBindingDescriptions = &bindingDescription;
    vertexInputInfo.pVertexAttributeDescriptions = attributeDescriptions.data();
 
    VkPipelineInputAssemblyStateCreateInfo inputAssembly{};
    inputAssembly.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO;
    inputAssembly.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
    inputAssembly.primitiveRestartEnable = VK_FALSE;
 
    VkViewport viewport{};
    viewport.x = 0.0f;
    viewport.y = 0.0f;
    viewport.width = (float)mSwapChainExtent.width;
    viewport.height = (float)mSwapChainExtent.height;
    viewport.minDepth = 0.0f;
    viewport.maxDepth = 1.0f;
 
    VkRect2D scissor{};
    scissor.offset = { 0, 0 };
    scissor.extent = mSwapChainExtent;
 
    VkPipelineViewportStateCreateInfo viewportState{};
    viewportState.sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO;
    viewportState.viewportCount = 1;
    viewportState.pViewports = &viewport;
    viewportState.scissorCount = 1;
    viewportState.pScissors = &scissor;
 
    VkPipelineRasterizationStateCreateInfo rasterizer{};
    rasterizer.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO;
    rasterizer.depthClampEnable = VK_FALSE;
    rasterizer.rasterizerDiscardEnable = VK_FALSE;
    rasterizer.polygonMode = VK_POLYGON_MODE_FILL;
    rasterizer.lineWidth = 1.0f;
    if (material->GetMaterialSettings().materialDomain == MaterialDomain::Sprite2D)
    {
        rasterizer.cullMode = VK_CULL_MODE_NONE;
    }
    else
    {
        rasterizer.cullMode = VK_CULL_MODE_BACK_BIT;
    }
    rasterizer.frontFace = VK_FRONT_FACE_COUNTER_CLOCKWISE;
    rasterizer.depthBiasEnable = VK_FALSE;
    rasterizer.depthBiasConstantFactor = 0.0f; // Optional
    rasterizer.depthBiasClamp = 0.0f; // Optional
    rasterizer.depthBiasSlopeFactor = 0.0f; // Optional
 
    VkPipelineMultisampleStateCreateInfo multisampling{};
    multisampling.sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO;
    multisampling.sampleShadingEnable = VK_FALSE;
    multisampling.rasterizationSamples = mMSAASamples;
    multisampling.minSampleShading = 1.0f; // Optional
    multisampling.pSampleMask = nullptr; // Optional
    multisampling.alphaToCoverageEnable = VK_FALSE; // Optional
    multisampling.alphaToOneEnable = VK_FALSE; // Optional
 
    VkPipelineColorBlendAttachmentState colorBlendAttachment{};
    colorBlendAttachment.colorWriteMask = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT;
    colorBlendAttachment.blendEnable = (material->GetMaterialSettings().blendMode == BlendMode::Translucent) ? VK_TRUE : VK_FALSE;
    colorBlendAttachment.srcColorBlendFactor = VK_BLEND_FACTOR_SRC_ALPHA;
    colorBlendAttachment.dstColorBlendFactor = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;
    colorBlendAttachment.colorBlendOp = VK_BLEND_OP_ADD; // Optional
    colorBlendAttachment.srcAlphaBlendFactor = VK_BLEND_FACTOR_ONE;
    colorBlendAttachment.dstAlphaBlendFactor = VK_BLEND_FACTOR_ZERO;
    colorBlendAttachment.alphaBlendOp = VK_BLEND_OP_ADD; // Optional
 
    VkPipelineColorBlendStateCreateInfo colorBlending{};
    colorBlending.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;
    colorBlending.logicOpEnable = VK_FALSE;
    colorBlending.logicOp = VK_LOGIC_OP_COPY; // Optional
    colorBlending.attachmentCount = 1;
    colorBlending.pAttachments = &colorBlendAttachment;
    colorBlending.blendConstants[0] = 0.0f; // Optional
    colorBlending.blendConstants[1] = 0.0f; // Optional
    colorBlending.blendConstants[2] = 0.0f; // Optional
    colorBlending.blendConstants[3] = 0.0f; // Optional
 
    VkPipelineLayoutCreateInfo pipelineLayoutInfo{};
    pipelineLayoutInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
    pipelineLayoutInfo.setLayoutCount = 1;
    pipelineLayoutInfo.pSetLayouts = &descriptorSetLayout;
 
    if (vkCreatePipelineLayout(mLogicalDevice, &pipelineLayoutInfo, nullptr, &pipelineLayout) != VK_SUCCESS)
    {
        LOG_ERROR("failed to create pipeline layout!");
        throw std::runtime_error("failed to create pipeline layout!");
    }
 
    VkPipelineDepthStencilStateCreateInfo depthStencil{};
    depthStencil.sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO;
    if (material->GetMaterialSettings().materialDomain == MaterialDomain::Sprite2D)
    {
        depthStencil.depthTestEnable = VK_FALSE;
        depthStencil.depthWriteEnable = VK_FALSE;
    }
    else
    {
        depthStencil.depthTestEnable = VK_TRUE;
        depthStencil.depthWriteEnable = (material->GetMaterialSettings().blendMode == BlendMode::Opaque) ? VK_TRUE : VK_FALSE;
    }
    depthStencil.depthCompareOp = VK_COMPARE_OP_LESS;
    depthStencil.depthBoundsTestEnable = VK_FALSE;
    //depthStencil.minDepthBounds = 0.0f; // Optional
    //depthStencil.maxDepthBounds = 1.0f; // Optional
    depthStencil.stencilTestEnable = VK_FALSE;
    //depthStencil.front = {}; // Optional
    depthStencil.back = {}; // Optional
 
    VkGraphicsPipelineCreateInfo pipelineInfo{};
    pipelineInfo.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
    pipelineInfo.stageCount = 2;
    pipelineInfo.pStages = shaderStages;
    pipelineInfo.pVertexInputState = &vertexInputInfo;
    pipelineInfo.pInputAssemblyState = &inputAssembly;
    pipelineInfo.pViewportState = &viewportState;
    pipelineInfo.pRasterizationState = &rasterizer;
    pipelineInfo.pMultisampleState = &multisampling;
    pipelineInfo.pDepthStencilState = &depthStencil;
    pipelineInfo.pColorBlendState = &colorBlending;
 
    // To enable dynamic viewport/scissor state:
    // const std::vector<VkDynamicState> dynamicStates = {
    //     VK_DYNAMIC_STATE_VIEWPORT,
    //     VK_DYNAMIC_STATE_SCISSOR
    // };
    // VkPipelineDynamicStateCreateInfo dynamicState{};
    // dynamicState.sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO;
    // dynamicState.dynamicStateCount = static_cast<uint32_t>(dynamicStates.size());
    // dynamicState.pDynamicStates = dynamicStates.data();
    // Then set: pipelineInfo.pDynamicState = &dynamicState;
    pipelineInfo.pDynamicState = nullptr;
 
    pipelineInfo.layout = pipelineLayout;
    pipelineInfo.renderPass = mRenderPass;
    pipelineInfo.subpass = 0;
    pipelineInfo.basePipelineHandle = VK_NULL_HANDLE; // Optional
    pipelineInfo.basePipelineIndex = -1; // Optional
 
 
    if (vkCreateGraphicsPipelines(mLogicalDevice, VK_NULL_HANDLE, 1, &pipelineInfo, nullptr, &pipeline) != VK_SUCCESS)
    {
        LOG_ERROR("failed to create graphics pipeline!");
        throw std::runtime_error("failed to create graphics pipeline!");
    }
    vkDestroyShaderModule(mLogicalDevice, fragShaderModule, nullptr);
    vkDestroyShaderModule(mLogicalDevice, vertShaderModule, nullptr);
    
    return std::pair<VkPipelineLayout, VkPipeline>(pipelineLayout, pipeline);
}

DrawFrame()

void rendering_engine::VulkanRenderer::DrawFrame ( )

overridevirtual

Executes a full frame rendering cycle.

Implements rendering_engine::IRenderer.

Definition at line 69 of file vulkan_renderer.cpp.

{
    vkWaitForFences(mLogicalDevice, 1, &mInFlightFences[mCurrentFrame], VK_TRUE, UINT64_MAX);
 
    uint32_t imageIndex;
    VkResult result = vkAcquireNextImageKHR(mLogicalDevice, mSwapChain, UINT64_MAX, mImageAvailableSemaphores[mCurrentFrame], VK_NULL_HANDLE, &imageIndex);
 
    if (result == VK_ERROR_OUT_OF_DATE_KHR)
    {
        LOG_WARNING("Swapchain out of date. Triggering recreation.");
        RecreateSwapChain();
        return;
    }
    else
    {
        if (result != VK_SUCCESS && result != VK_SUBOPTIMAL_KHR)
        {
            LOG_ERROR("failed to acquire swap chain image!");
            throw std::runtime_error("failed to acquire swap chain image!");
        }
    }
 
    vkResetFences(mLogicalDevice, 1, &mInFlightFences[mCurrentFrame]);
 
    vkResetCommandBuffer(mCommandBuffers[mCurrentFrame], /*VkCommandBufferResetFlagBits*/ 0);
    RecordCommandBuffer(mCommandBuffers[mCurrentFrame], imageIndex);
 
    VkSubmitInfo submitInfo{};
    submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
 
    VkSemaphore waitSemaphores[] = { mImageAvailableSemaphores[mCurrentFrame] };
    VkPipelineStageFlags waitStages[] = { VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT };
    submitInfo.waitSemaphoreCount = 1;
    submitInfo.pWaitSemaphores = waitSemaphores;
    submitInfo.pWaitDstStageMask = waitStages;
 
    submitInfo.commandBufferCount = 1;
    submitInfo.pCommandBuffers = &mCommandBuffers[mCurrentFrame];
 
    VkSemaphore signalSemaphores[] = { mRenderFinishedSemaphores[imageIndex] };
    submitInfo.signalSemaphoreCount = 1;
    submitInfo.pSignalSemaphores = signalSemaphores;
 
    if (vkQueueSubmit(mGraphicsQueue, 1, &submitInfo, mInFlightFences[mCurrentFrame]) != VK_SUCCESS)
    {
        LOG_ERROR("failed to submit draw command buffer!");
        throw std::runtime_error("failed to submit draw command buffer!");
    }
 
    VkPresentInfoKHR presentInfo{};
    presentInfo.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR;
 
    presentInfo.waitSemaphoreCount = 1;
    presentInfo.pWaitSemaphores = signalSemaphores;
 
    VkSwapchainKHR swapChains[] = { mSwapChain };
    presentInfo.swapchainCount = 1;
    presentInfo.pSwapchains = swapChains;
 
    presentInfo.pImageIndices = &imageIndex;
 
    result = vkQueuePresentKHR(mPresentQueue, &presentInfo);
 
    if (result == VK_ERROR_OUT_OF_DATE_KHR || result == VK_SUBOPTIMAL_KHR || mWindowSystem.IsFramebufferResized())
    {
        mWindowSystem.ResetFramebufferResizedFlag();
        RecreateSwapChain();
    }
    else
    {
        if (result != VK_SUCCESS)
        {
            LOG_ERROR("failed to present swap chain image!");
            throw std::runtime_error("failed to present swap chain image!");
        }
    }
 
    mCurrentFrame = (mCurrentFrame + 1) % MAX_FRAMES_IN_FLIGHT;
}

EndFrame()

void rendering_engine::VulkanRenderer::EndFrame ( )

overridevirtual

Completes the current frame rendering and presents the result.

Implements rendering_engine::IRenderer.

Definition at line 219 of file vulkan_renderer.cpp.

{
    if (vkEndCommandBuffer(mCommandBuffers[mCurrentFrame]) != VK_SUCCESS)
    {
        LOG_ERROR("failed to record command buffer!");
        throw std::runtime_error("failed to record command buffer!");
    }
 
    VkSubmitInfo submitInfo{};
    submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
 
    VkSemaphore waitSemaphores[] = { mImageAvailableSemaphores[mCurrentFrame] };
    VkPipelineStageFlags waitStages[] = { VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT };
    submitInfo.waitSemaphoreCount = 1;
    submitInfo.pWaitSemaphores = waitSemaphores;
    submitInfo.pWaitDstStageMask = waitStages;
 
    submitInfo.commandBufferCount = 1;
    submitInfo.pCommandBuffers = &mCommandBuffers[mCurrentFrame];
 
    VkSemaphore signalSemaphores[] = { mRenderFinishedSemaphores[mImageIndex] };
    submitInfo.signalSemaphoreCount = 1;
    submitInfo.pSignalSemaphores = signalSemaphores;
 
    if (vkQueueSubmit(mGraphicsQueue, 1, &submitInfo, mInFlightFences[mCurrentFrame]) != VK_SUCCESS)
    {
        LOG_ERROR("failed to submit draw command buffer!");
        throw std::runtime_error("failed to submit draw command buffer!");
    }
 
    VkPresentInfoKHR presentInfo{};
    presentInfo.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR;
 
    presentInfo.waitSemaphoreCount = 1;
    presentInfo.pWaitSemaphores = signalSemaphores;
 
    VkSwapchainKHR swapChains[] = { mSwapChain };
    presentInfo.swapchainCount = 1;
    presentInfo.pSwapchains = swapChains;
 
    presentInfo.pImageIndices = &mImageIndex;
 
    VkResult result = vkQueuePresentKHR(mPresentQueue, &presentInfo);
 
    if (result == VK_ERROR_OUT_OF_DATE_KHR || result == VK_SUBOPTIMAL_KHR || mWindowSystem.IsFramebufferResized())
    {
        mWindowSystem.ResetFramebufferResizedFlag();
        RecreateSwapChain();
    }
    else
    {
        if (result != VK_SUCCESS)
        {
            LOG_ERROR("failed to present swap chain image!");
            throw std::runtime_error("failed to present swap chain image!");
        }
    }
 
    mCurrentFrame = (mCurrentFrame + 1) % MAX_FRAMES_IN_FLIGHT;
}

EndRenderPass()

void rendering_engine::VulkanRenderer::EndRenderPass ( )

overridevirtual

Ends the active render pass.

Implements rendering_engine::IRenderer.

Definition at line 214 of file vulkan_renderer.cpp.

{
    vkCmdEndRenderPass(mCommandBuffers[mCurrentFrame]);
}

FindMemoryType()

uint32_t rendering_engine::VulkanRenderer::FindMemoryType	(	uint32_t	typeFilter,
		VkMemoryPropertyFlags	properties
	)

Finds a suitable memory type for a given allocation.

Parameters

typeFilter	Bitmask of compatible memory types.
properties	Desired memory property flags.

Returns

Index of the selected memory type.

Definition at line 1381 of file vulkan_renderer.cpp.

{
    VkPhysicalDeviceMemoryProperties memProperties;
    vkGetPhysicalDeviceMemoryProperties(mPhysicalDevice, &memProperties);
 
    for (uint32_t i = 0; i < memProperties.memoryTypeCount; i++)
    {
        if (typeFilter & (1 << i) && (memProperties.memoryTypes[i].propertyFlags & properties) == properties)
        {
            return i;
        }
    }
    LOG_ERROR("failed to find suitable memory type!");
    throw std::runtime_error("failed to find suitable memory type!");
}

GenerateMipmaps()

void rendering_engine::VulkanRenderer::GenerateMipmaps	(	VkImage	image,
		VkFormat	imageFormat,
		int32_t	texWidth,
		int32_t	texHeight,
		uint32_t	mipLevels
	)

Generates mipmaps for a given image resource.

Parameters

image	Vulkan image handle.
imageFormat	Image format (must support linear blitting).
texWidth	Texture width in pixels.
texHeight	Texture height in pixels.
mipLevels	Number of mipmap levels to generate.

Definition at line 507 of file vulkan_renderer.cpp.

{
    // Check if image format supports linear blitting
    VkFormatProperties formatProperties;
    vkGetPhysicalDeviceFormatProperties(mPhysicalDevice, imageFormat, &formatProperties);
 
    if (!(formatProperties.optimalTilingFeatures & VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT))
    {
        LOG_ERROR("texture image format does not support linear blitting!");
        throw std::runtime_error("texture image format does not support linear blitting!");
    }
 
    VkCommandBuffer commandBuffer = BeginSingleTimeCommand();
 
    VkImageMemoryBarrier barrier{};
    barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
    barrier.image = image;
    barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
    barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
    barrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
    barrier.subresourceRange.baseArrayLayer = 0;
    barrier.subresourceRange.layerCount = 1;
    barrier.subresourceRange.levelCount = 1;
 
    int32_t mipWidth = texWidth;
    int32_t mipHeight = texHeight;
 
    for (uint32_t i = 1; i < mipLevels; i++)
    {
        barrier.subresourceRange.baseMipLevel = i - 1;
        barrier.oldLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
        barrier.newLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL;
        barrier.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
        barrier.dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT;
 
        vkCmdPipelineBarrier(commandBuffer,
            VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0,
            0, nullptr,
            0, nullptr,
            1, &barrier);
 
        VkImageBlit blit{};
        blit.srcOffsets[0] = { 0, 0, 0 };
        blit.srcOffsets[1] = { mipWidth, mipHeight, 1 };
        blit.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
        blit.srcSubresource.mipLevel = i - 1;
        blit.srcSubresource.baseArrayLayer = 0;
        blit.srcSubresource.layerCount = 1;
        blit.dstOffsets[0] = { 0, 0, 0 };
        blit.dstOffsets[1] = { mipWidth > 1 ? mipWidth / 2 : 1, mipHeight > 1 ? mipHeight / 2 : 1, 1 };
        blit.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
        blit.dstSubresource.mipLevel = i;
        blit.dstSubresource.baseArrayLayer = 0;
        blit.dstSubresource.layerCount = 1;
 
        vkCmdBlitImage(commandBuffer,
            image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
            image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
            1, &blit,
            VK_FILTER_LINEAR);
 
        barrier.oldLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL;
        barrier.newLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
        barrier.srcAccessMask = VK_ACCESS_TRANSFER_READ_BIT;
        barrier.dstAccessMask = VK_ACCESS_SHADER_READ_BIT;
 
        vkCmdPipelineBarrier(commandBuffer,
            VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, 0,
            0, nullptr,
            0, nullptr,
            1, &barrier);
 
        if (mipWidth > 1) mipWidth /= 2;
        if (mipHeight > 1) mipHeight /= 2;
    }
 
    barrier.subresourceRange.baseMipLevel = mipLevels - 1;
    barrier.oldLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
    barrier.newLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
    barrier.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
    barrier.dstAccessMask = VK_ACCESS_SHADER_READ_BIT;
 
    vkCmdPipelineBarrier(commandBuffer,
        VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, 0,
        0, nullptr,
        0, nullptr,
        1, &barrier);
 
    EndSingleTimeCommand(commandBuffer);
}

GetAttributeDescriptions() [1/7]

template<typename T >

static std::vector< VkVertexInputAttributeDescription > rendering_engine::VulkanRenderer::GetAttributeDescriptions ( )

static

Returns vertex attribute descriptions for a specific vertex type.

Template Parameters

T	Vertex type (e.g., Vertex2D, VertexPositionColorTexture, etc.).

GetAttributeDescriptions() [2/7]

template<>

std::vector< VkVertexInputAttributeDescription > rendering_engine::VulkanRenderer::GetAttributeDescriptions ( )

static

GetAttributeDescriptions() [3/7]

template<>

std::vector< VkVertexInputAttributeDescription > rendering_engine::VulkanRenderer::GetAttributeDescriptions ( )

static

GetAttributeDescriptions() [4/7]

template<>

std::vector< VkVertexInputAttributeDescription > rendering_engine::VulkanRenderer::GetAttributeDescriptions ( )

static

GetAttributeDescriptions() [5/7]

template<>

std::vector< VkVertexInputAttributeDescription > rendering_engine::VulkanRenderer::GetAttributeDescriptions ( )

static

Definition at line 1922 of file vulkan_renderer.cpp.

{
    std::vector<VkVertexInputAttributeDescription> attributeDescriptions{};
    attributeDescriptions.resize(3);
 
    attributeDescriptions[0].binding = 0;
    attributeDescriptions[0].location = 0;
    attributeDescriptions[0].format = VK_FORMAT_R32G32_SFLOAT;
    attributeDescriptions[0].offset = offsetof(Vertex2D, position);
 
    attributeDescriptions[1].binding = 0;
    attributeDescriptions[1].location = 1;
    attributeDescriptions[1].format = VK_FORMAT_R32G32B32A32_SFLOAT;
    attributeDescriptions[1].offset = offsetof(Vertex2D, color);
 
    attributeDescriptions[2].binding = 0;
    attributeDescriptions[2].location = 2;
    attributeDescriptions[2].format = VK_FORMAT_R32G32_SFLOAT;
    attributeDescriptions[2].offset = offsetof(Vertex2D, textureCoordinates);
 
    return attributeDescriptions;
}

GetAttributeDescriptions() [6/7]

template<>

std::vector< VkVertexInputAttributeDescription > rendering_engine::VulkanRenderer::GetAttributeDescriptions ( )

static

Definition at line 1922 of file vulkan_renderer.cpp.

{
    std::vector<VkVertexInputAttributeDescription> attributeDescriptions{};
    attributeDescriptions.resize(3);
 
    attributeDescriptions[0].binding = 0;
    attributeDescriptions[0].location = 0;
    attributeDescriptions[0].format = VK_FORMAT_R32G32B32_SFLOAT;
    attributeDescriptions[0].offset = offsetof(VertexPositionColorTexture, position);
 
    attributeDescriptions[1].binding = 0;
    attributeDescriptions[1].location = 1;
    attributeDescriptions[1].format = VK_FORMAT_R32G32B32A32_SFLOAT;
    attributeDescriptions[1].offset = offsetof(VertexPositionColorTexture, color);
 
    attributeDescriptions[2].binding = 0;
    attributeDescriptions[2].location = 2;
    attributeDescriptions[2].format = VK_FORMAT_R32G32_SFLOAT;
    attributeDescriptions[2].offset = offsetof(VertexPositionColorTexture, textureCoordinates);
 
    return attributeDescriptions;
}

GetAttributeDescriptions() [7/7]

template<>

std::vector< VkVertexInputAttributeDescription > rendering_engine::VulkanRenderer::GetAttributeDescriptions ( )

static

Definition at line 1922 of file vulkan_renderer.cpp.

{
    std::vector<VkVertexInputAttributeDescription> attributeDescriptions{};
    attributeDescriptions.resize(5);
 
    attributeDescriptions[0].binding = 0;
    attributeDescriptions[0].location = 0;
    attributeDescriptions[0].format = VK_FORMAT_R32G32B32_SFLOAT;
    attributeDescriptions[0].offset = offsetof(VertexPositionColorTextureNormalTangent, position);
 
    attributeDescriptions[1].binding = 0;
    attributeDescriptions[1].location = 1;
    attributeDescriptions[1].format = VK_FORMAT_R32G32B32A32_SFLOAT;
    attributeDescriptions[1].offset = offsetof(VertexPositionColorTextureNormalTangent, color);
 
    attributeDescriptions[2].binding = 0;
    attributeDescriptions[2].location = 2;
    attributeDescriptions[2].format = VK_FORMAT_R32G32_SFLOAT;
    attributeDescriptions[2].offset = offsetof(VertexPositionColorTextureNormalTangent, textureCoordinates);
 
    attributeDescriptions[3].binding = 0;
    attributeDescriptions[3].location = 3;
    attributeDescriptions[3].format = VK_FORMAT_R32G32B32_SFLOAT;
    attributeDescriptions[3].offset = offsetof(VertexPositionColorTextureNormalTangent, normal);
 
    attributeDescriptions[4].binding = 0;
    attributeDescriptions[4].location = 4;
    attributeDescriptions[4].format = VK_FORMAT_R32G32B32_SFLOAT;
    attributeDescriptions[4].offset = offsetof(VertexPositionColorTextureNormalTangent, tangent);
 
    return attributeDescriptions;
}

GetBindingDescription()

template<typename T >

VkVertexInputBindingDescription rendering_engine::VulkanRenderer::GetBindingDescription ( )

static

Returns a vertex input binding description for a specific vertex type.

Template Parameters

T	Vertex type (e.g., Vertex2D, VertexPositionColorTexture, etc.).

Definition at line 1922 of file vulkan_renderer.cpp.

{
    VkVertexInputBindingDescription binding{};
    binding.binding = 0;
    binding.stride = sizeof(T);
    binding.inputRate = VK_VERTEX_INPUT_RATE_VERTEX;
    return binding;
}

GetComandBuffers()

std::vector< VkCommandBuffer > rendering_engine::VulkanRenderer::GetComandBuffers

(

)

Returns the collection of command buffers used for rendering.

Definition at line 1466 of file vulkan_renderer.cpp.

{
    return mCommandBuffers;
}

GetCurrentFrame()

size_t rendering_engine::VulkanRenderer::GetCurrentFrame ( ) const

inline

Returns the index of the currently active frame in flight.

Definition at line 213 of file vulkan_renderer.hpp.

    {
        return mCurrentFrame;
    }

GetLogicalDevice()

VkDevice & rendering_engine::VulkanRenderer::GetLogicalDevice

(

)

Returns reference to the logical Vulkan device.

Definition at line 396 of file vulkan_renderer.cpp.

{
    return mLogicalDevice;
}

GetPhysDevSupportedFeatures()

VkPhysicalDeviceFeatures & rendering_engine::VulkanRenderer::GetPhysDevSupportedFeatures

(

)

Returns reference to the physical device�s supported features.

Definition at line 1402 of file vulkan_renderer.cpp.

{
    return mPhysDevSupportedFeatures;
}

GetPhysicalDevice()

VkPhysicalDevice & rendering_engine::VulkanRenderer::GetPhysicalDevice

(

)

Returns reference to the physical device.

Definition at line 1397 of file vulkan_renderer.cpp.

{
    return mPhysicalDevice;
}

InitializeRenderer()

void rendering_engine::VulkanRenderer::InitializeRenderer ( )

overridevirtual

Initializes all rendering subsystems and GPU resources.

Implements rendering_engine::IRenderer.

Definition at line 45 of file vulkan_renderer.cpp.

{
    CreateInstance();
    SetupDebugMessenger();
    CreateSurface();
    PickPhysicalDevice();
    CreateLogicalDevice();
 
    CreateSwapChain();
    CreateImageViews();
    CreateRenderPass();
 
    CreateCommandPool();
 
    CreateColorResources();
    CreateDepthResources();
 
    CreateFramebuffers();
 
    CreateCommandBuffers();
    CreateFrameSyncObjects();
    CreateSwapchainSyncObjects();
}

ProvideMaterialRenderResources()

IMaterialRenderResources * rendering_engine::VulkanRenderer::ProvideMaterialRenderResources ( ) const

overridevirtual

Provides access to material-related GPU resources.

Returns

Pointer to the IMaterialRenderResources interface.

Implements rendering_engine::IRenderer.

Definition at line 331 of file vulkan_renderer.cpp.

{
    return new VulkanMaterialResources(const_cast<VulkanRenderer*>(this));
}

ProvideMeshRenderResources()

IMeshRenderResources * rendering_engine::VulkanRenderer::ProvideMeshRenderResources ( ) const

overridevirtual

Provides access to mesh-related GPU resources.

Returns

Pointer to the IMeshRenderResources interface.

Implements rendering_engine::IRenderer.

Definition at line 336 of file vulkan_renderer.cpp.

{
    return new VulkanMeshResources(const_cast<VulkanRenderer*>(this));
}

ProvideRenderResources()

IRenderResources * rendering_engine::VulkanRenderer::ProvideRenderResources ( ) const

overridevirtual

Provides access to the general rendering resource manager.

Returns

Pointer to the IRenderResources interface.

Implements rendering_engine::IRenderer.

Definition at line 346 of file vulkan_renderer.cpp.

{
    return new VulkanRenderResources(const_cast<VulkanRenderer*>(this));
}

ProvideTextureRenderResources()

ITextureRenderResources * rendering_engine::VulkanRenderer::ProvideTextureRenderResources ( ) const

overridevirtual

Provides access to texture-related GPU resources.

Returns

Pointer to the ITextureRenderResources interface.

Implements rendering_engine::IRenderer.

Definition at line 326 of file vulkan_renderer.cpp.

{
    return new VulkanTextureResources(const_cast<VulkanRenderer*>(this));
}

RegisterObserver()

void rendering_engine::VulkanRenderer::RegisterObserver ( IRendererObserver *  notifier )

overridevirtual

Registers an observer for rendering events.

Parameters

notifier

Pointer to the observer to register.

Implements rendering_engine::IRenderer.

Definition at line 313 of file vulkan_renderer.cpp.

{
    if (std::find(mObservers.begin(), mObservers.end(), notifier) == mObservers.end())
    {
        mObservers.push_back(notifier);
    }
}

SetDefaultColor()

void rendering_engine::VulkanRenderer::SetDefaultColor ( float  r, float  g, float  b  )

overridevirtual

Sets the renderer clear color.

Parameters

r	Red channel (linear space, [0.0, 1.0])
g	Green channel (linear space, [0.0, 1.0])
b	Blue channel (linear space, [0.0, 1.0])

Implements rendering_engine::IRenderer.

Definition at line 341 of file vulkan_renderer.cpp.

{
    mDefaultColor = glm::vec3(r, g, b);
}

ShutdownRenderer()

void rendering_engine::VulkanRenderer::ShutdownRenderer ( )

overridevirtual

Destroys and cleans up all rendering resources.

Implements rendering_engine::IRenderer.

Definition at line 285 of file vulkan_renderer.cpp.

{
    LOG_INFO("Shutting down Vulkan renderer...");
    vkDeviceWaitIdle(mLogicalDevice);
 
    mFrameSerial = std::numeric_limits<uint64_t>::max();
    ProcessDeferredDestruction();
 
    CleanupSwapChain();
 
    for (size_t i = 0; i < MAX_FRAMES_IN_FLIGHT; i++)
    {
        vkDestroySemaphore(mLogicalDevice, mImageAvailableSemaphores[i], nullptr);
        vkDestroyFence(mLogicalDevice, mInFlightFences[i], nullptr);
    }
 
    vkDestroyCommandPool(mLogicalDevice, mCommandPool, nullptr);
 
    vkDestroyDevice(mLogicalDevice, nullptr);
    if (enableValidationLayers)
    {
        DestroyDebugUtilsMessengerEXT(mInstance, mDebugMessenger, nullptr);
    }
    vkDestroySurfaceKHR(mInstance, mSurface, nullptr);
    vkDestroyInstance(mInstance, nullptr);
    LOG_INFO("Vulkan renderer shutdown complete.");
}

TransitionImageLayout()

void rendering_engine::VulkanRenderer::TransitionImageLayout	(	VkImage	image,
		VkFormat	format,
		VkImageLayout	oldLayout,
		VkImageLayout	newLayout,
		std::uint32_t	mipmapLevels
	)

Transitions the image layout for a given Vulkan image.

Parameters

image	Image handle.
format	Image format.
oldLayout	Current image layout.
newLayout	Desired image layout.
mipmapLevels	Number of mipmap levels to transition.

Definition at line 401 of file vulkan_renderer.cpp.

{
    VkCommandBuffer commandBuffer = BeginSingleTimeCommand();
 
    VkImageMemoryBarrier barrier{};
    barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
    barrier.oldLayout = oldLayout;
    barrier.newLayout = newLayout;
 
    barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
    barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
 
    barrier.image = image;
    barrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
    barrier.subresourceRange.baseMipLevel = 0;
    barrier.subresourceRange.levelCount = mipmapLevels;
    barrier.subresourceRange.baseArrayLayer = 0;
    barrier.subresourceRange.layerCount = 1;
 
    VkPipelineStageFlags sourceStage;
    VkPipelineStageFlags destinationStage;
 
    if (newLayout == VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL)
    {
        barrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
 
        if (HasStencilComponent(format))
        {
            barrier.subresourceRange.aspectMask |= VK_IMAGE_ASPECT_STENCIL_BIT;
        }
    }
    else
    {
        barrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
    }
 
    if (oldLayout == VK_IMAGE_LAYOUT_UNDEFINED && newLayout == VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL) {
        barrier.srcAccessMask = 0;
        barrier.dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
 
        sourceStage = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT;
        destinationStage = VK_PIPELINE_STAGE_TRANSFER_BIT;
    }
    else if (oldLayout == VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL && newLayout == VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL) {
        barrier.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
        barrier.dstAccessMask = VK_ACCESS_SHADER_READ_BIT;
 
        sourceStage = VK_PIPELINE_STAGE_TRANSFER_BIT;
        destinationStage = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
    }
    else if (oldLayout == VK_IMAGE_LAYOUT_UNDEFINED && newLayout == VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL) {
        barrier.srcAccessMask = 0;
        barrier.dstAccessMask = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
 
        sourceStage = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT;
        destinationStage = VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT;
    }
    else {
        throw std::invalid_argument("unsupported layout transition!");
    }
 
    vkCmdPipelineBarrier(
        commandBuffer,
        sourceStage, destinationStage,
        0,
        0, nullptr,
        0, nullptr,
        1, &barrier
    );
 
    EndSingleTimeCommand(commandBuffer);
}

UnregisterObserver()

void rendering_engine::VulkanRenderer::UnregisterObserver ( IRendererObserver *  notifier )

overridevirtual

Unregisters a previously registered observer.

Parameters

notifier

Pointer to the observer to remove.

Implements rendering_engine::IRenderer.

Definition at line 321 of file vulkan_renderer.cpp.

{
    mObservers.erase(std::remove(mObservers.begin(), mObservers.end(), notifier), mObservers.end());
}

WaitIdle()

void rendering_engine::VulkanRenderer::WaitIdle ( )

overridevirtual

Waits until the GPU has finished all pending rendering operations.

Implements rendering_engine::IRenderer.

Definition at line 280 of file vulkan_renderer.cpp.

{
    vkDeviceWaitIdle(mLogicalDevice);
}

---

The documentation for this class was generated from the following files:

• vulkan_renderer.hpp
• vulkan_renderer.cpp