rendering_engine::VulkanRenderResources Class Reference

Vulkan implementation of IRenderResources for the Rendering Engine. More...

#include <vulkan_render_resources.hpp>

Inherits rendering_engine::IRenderResources, and rendering_engine::IRendererObserver.

Public Member Functions
	VulkanRenderResources (VulkanRenderer *renderer)
	Constructor.
	~VulkanRenderResources ()
	Destructor.
void	Initialize (Material *material, MeshDataGpu *meshData, TextureCache *textureCache) override
	Initializes GPU-side resources using provided material, mesh, and texture cache.
void	SubmitResources (Transformations2D &transformations, const PackedMaterialData &materialParameters) override
	Updates GPU resources and issues a draw call for a 2D object.
void	SubmitResources (Transformations3D &transformations, const PackedMaterialData &materialParameters) override
	Updates GPU resources and issues a draw call for a 3D object.
void	Shutdown () override
	Releases all allocated GPU resources for this object.
Public Member Functions inherited from rendering_engine::IRenderResources
virtual	~IRenderResources ()=default
	Virtual destructor.
Public Member Functions inherited from rendering_engine::IRendererObserver
virtual	~IRendererObserver ()=default
	Virtual destructor.

Protected Member Functions
void	OnRenderResourcesRelease () override
	Renderer callback: release all GPU resources (used during device loss/reset).
void	OnRenderResourcesRebuild () override
	Renderer callback: re-upload or recreate all GPU resources (used after device reset/rebuild).
void	AcquireResources ()
	Allocates and initializes all GPU buffers, descriptor sets, and pipelines for this drawable.
void	CreateUniformBuffers ()
void	CreateDescriptorPool ()
void	CreateDescriptorSet ()
void	UpdateTransformations (Transformations2D &transformations)
void	UpdateTransformations (Transformations3D &transformations)
void	UpdateMaterialParameters (const PackedMaterialData &materialParameters)
void	DrawIndexed ()
	Issues a Vulkan draw command for the currently bound indexed mesh.

Detailed Description

Vulkan implementation of IRenderResources for the Rendering Engine.

Aggregates and manages Vulkan GPU-side resources (buffers, descriptor sets, pipelines) required to render a drawable object. Responds to renderer events (release/rebuild) and can be safely reused with shared caches for materials, meshes, and textures.

Definition at line 28 of file vulkan_render_resources.hpp.

Constructor & Destructor Documentation

VulkanRenderResources()

rendering_engine::VulkanRenderResources::VulkanRenderResources

(

VulkanRenderer *

renderer

)

Constructor.

Parameters

renderer

Pointer to the owning VulkanRenderer instance.

Registers itself as an observer for resource (re)creation events.

Definition at line 16 of file vulkan_render_resources.cpp.

    :
    mRenderer(renderer)
{
    mRenderer->RegisterObserver(this);
}

~VulkanRenderResources()

rendering_engine::VulkanRenderResources::~VulkanRenderResources

(

)

Destructor.

Unregisters from the renderer and calls Shutdown() to release all resources.

Definition at line 23 of file vulkan_render_resources.cpp.

{
    mRenderer->UnregisterObserver(this);
}

Member Function Documentation

AcquireResources()

void rendering_engine::VulkanRenderResources::AcquireResources ( )

protected

Allocates and initializes all GPU buffers, descriptor sets, and pipelines for this drawable.

Definition at line 126 of file vulkan_render_resources.cpp.

{
    if (!mMaterial)
    {
        // Log error message, as without initialized material rendering is not possible.
        return;
    }
    VulkanMaterialResources* materialResources = static_cast<VulkanMaterialResources*>(mMaterial->GetMaterialRenderResources());
    mGraphicsPipeline = materialResources->GetPipeline();
    mPipelineLayout = materialResources->GetPipelineLayout();
 
    VulkanMeshResources* meshResources = static_cast<VulkanMeshResources*>(mMeshData->GetMeshRenderResources());
    mVertexBuffer = meshResources->GetVertexBuffer();
    mIndexBuffer = meshResources->GetIndexBuffer();
 
    CreateUniformBuffers();
    CreateDescriptorPool();
    CreateDescriptorSet();
}

CreateDescriptorPool()

void rendering_engine::VulkanRenderResources::CreateDescriptorPool ( )

protected

Definition at line 192 of file vulkan_render_resources.cpp.

{
    const uint32_t maxFramesInFlight = static_cast<uint32_t>(MAX_FRAMES_IN_FLIGHT);
    std::vector<VkDescriptorPoolSize> poolSizes;
 
    VkDescriptorPoolSize tranformationPool;
    tranformationPool.type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
    tranformationPool.descriptorCount = maxFramesInFlight;
 
    poolSizes.push_back(tranformationPool);
 
    auto materialParameters = mMaterial->PackMaterialParameters();
    if (!materialParameters.buffer.empty())
    {
        VkDescriptorPoolSize materialParameterPool;
        materialParameterPool.type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
        materialParameterPool.descriptorCount = maxFramesInFlight;
 
        poolSizes.push_back(materialParameterPool);
    }
 
    for (const auto& texture : mMaterial->GetTextures())
    {
        (void)texture;
        VkDescriptorPoolSize textureSamplerPool;
        textureSamplerPool.type = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
        textureSamplerPool.descriptorCount = maxFramesInFlight;
 
        poolSizes.push_back(textureSamplerPool);
    }
 
    VkDescriptorPoolCreateInfo poolInfo{};
    poolInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
    poolInfo.poolSizeCount = static_cast<uint32_t>(poolSizes.size());
    poolInfo.pPoolSizes = poolSizes.data();
    poolInfo.maxSets = maxFramesInFlight;
 
    if (vkCreateDescriptorPool(mRenderer->GetLogicalDevice(), &poolInfo, nullptr, &mDescriptorPool) != VK_SUCCESS)
    {
        throw std::runtime_error("failed to create descriptor pool!");
    }
}

CreateDescriptorSet()

void rendering_engine::VulkanRenderResources::CreateDescriptorSet ( )

protected

Definition at line 235 of file vulkan_render_resources.cpp.

{
    // By local convention of this engine, bindings will be numbered:
    // Bindings i = 0, i < n, there n - total number of bindings
    // Binding i - transformations matrices of types according to material domain (2D or 3D)
    // Binding i++ - cunstom parameter variable of material, if any. All variables will be 
    //               serialized and packed in a single binding
    // Binding i++ - textures sampler, if any. One texture per binding.
 
    const uint32_t maxFramesInFlight = static_cast<uint32_t>(MAX_FRAMES_IN_FLIGHT);
 
    VulkanMaterialResources* materialResources = static_cast<VulkanMaterialResources*>(mMaterial->GetMaterialRenderResources());
    auto descriptorSetLayout = materialResources->GetDescriptorSetLayout();
    std::vector<VkDescriptorSetLayout> layouts(maxFramesInFlight, descriptorSetLayout);
    VkDescriptorSetAllocateInfo allocInfo{};
    allocInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO;
    allocInfo.descriptorPool = mDescriptorPool;
    allocInfo.descriptorSetCount = maxFramesInFlight;
    allocInfo.pSetLayouts = layouts.data();
 
    mDescriptorSets.resize(MAX_FRAMES_IN_FLIGHT);
    VkResult result = vkAllocateDescriptorSets(mRenderer->GetLogicalDevice(), &allocInfo, mDescriptorSets.data());
    if (result != VK_SUCCESS)
    {
        throw std::runtime_error("failed to allocate descriptor sets! Error: " + std::to_string(result));
    }
 
    for (size_t i = 0; i < MAX_FRAMES_IN_FLIGHT; i++)
    {
        unsigned int dstBinding = 0;
 
        VkDescriptorBufferInfo matVarBufferInfo{};
        VkWriteDescriptorSet matVarDescSet;
 
        std::vector<VkWriteDescriptorSet> descriptorWrites;
 
        // Transfotmations descriptor set
        VkDescriptorBufferInfo transformationBufferInfo{};
        transformationBufferInfo.buffer = mTransformationBuffers[i];
        transformationBufferInfo.offset = 0;
        if (mMaterial->GetMaterialSettings().materialDomain == MaterialDomain::Sprite2D)
        {
            transformationBufferInfo.range = sizeof(Transformations2D);
        }
        if (mMaterial->GetMaterialSettings().materialDomain == MaterialDomain::Surface3D)
        {
            transformationBufferInfo.range = sizeof(Transformations3D);
        }
        VkWriteDescriptorSet transformationsDescSet;
        transformationsDescSet.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
        transformationsDescSet.pNext = nullptr;
        transformationsDescSet.dstSet = mDescriptorSets[i];
        transformationsDescSet.dstBinding = dstBinding;
        transformationsDescSet.dstArrayElement = 0;
        transformationsDescSet.descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
        transformationsDescSet.descriptorCount = 1;
        transformationsDescSet.pBufferInfo = &transformationBufferInfo;
        descriptorWrites.push_back(transformationsDescSet);
 
        // Custom material parameters descriptor set
        auto materialParameters = mMaterial->PackMaterialParameters();
        if (!materialParameters.buffer.empty())
        {
            ++dstBinding;
 
            matVarBufferInfo.buffer = mMaterialParametersBuffers[i];
            matVarBufferInfo.offset = 0;
            matVarBufferInfo.range = materialParameters.buffer.size();
 
            matVarDescSet.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
            matVarDescSet.pNext = nullptr;
            matVarDescSet.dstSet = mDescriptorSets[i];
            matVarDescSet.dstBinding = dstBinding;
            matVarDescSet.dstArrayElement = 0;
            matVarDescSet.descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
            matVarDescSet.descriptorCount = 1;
            matVarDescSet.pBufferInfo = &matVarBufferInfo;
            descriptorWrites.push_back(matVarDescSet);
        }
 
        // Custom texture image data descriptor set
        for (const auto& texture : mMaterial->GetTextures())
        {
            ++dstBinding;
            auto imageData = mTextureCache->GetTextureResources(texture);
            VulkanTextureResources* textureResources = static_cast<VulkanTextureResources*>(imageData->GetTextureRenderResources());
            VkDescriptorImageInfo imageInfo{};
            imageInfo.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
            imageInfo.imageView = textureResources->GetVkImageView();
            imageInfo.sampler = textureResources->GetVkSampler();
 
            VkWriteDescriptorSet imageDescSet;
            imageDescSet.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
            imageDescSet.pNext = nullptr;
            imageDescSet.dstSet = mDescriptorSets[i];
            imageDescSet.dstBinding = dstBinding;
            imageDescSet.dstArrayElement = 0;
            imageDescSet.descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
            imageDescSet.descriptorCount = 1;
            imageDescSet.pImageInfo = &imageInfo;
 
            descriptorWrites.push_back(imageDescSet);
        }
 
        vkUpdateDescriptorSets(mRenderer->GetLogicalDevice(), static_cast<uint32_t>(descriptorWrites.size()), descriptorWrites.data(), 0, nullptr);
    }
}

CreateUniformBuffers()

void rendering_engine::VulkanRenderResources::CreateUniformBuffers ( )

protected

Definition at line 146 of file vulkan_render_resources.cpp.

{
    VkDeviceSize transformationBufferSize = 0;
 
    switch (mMaterial->GetMaterialSettings().materialDomain)
    {
        case MaterialDomain::Sprite2D:
            transformationBufferSize = sizeof(Transformations2D);
            break;
 
        case MaterialDomain::Surface3D:
            transformationBufferSize = sizeof(Transformations3D);
            break;
 
        default:
            throw std::runtime_error("Unsupported material domain.");
    }
 
    mTransformationBuffers.resize(MAX_FRAMES_IN_FLIGHT);
    mTransformationBuffersMemory.resize(MAX_FRAMES_IN_FLIGHT);
 
    for (size_t i = 0; i < MAX_FRAMES_IN_FLIGHT; i++)
    {
        mRenderer->CreateBuffer(transformationBufferSize, VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT,
            VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, 
            mTransformationBuffers[i], mTransformationBuffersMemory[i]);
    }
 
    auto materialParameters = mMaterial->PackMaterialParameters();
    if (materialParameters.buffer.empty())
    {
        return;
    }
 
    VkDeviceSize matVarBufferSize = materialParameters.buffer.size();
    mMaterialParametersBuffers.resize(MAX_FRAMES_IN_FLIGHT);
    mMaterialParametersMemory.resize(MAX_FRAMES_IN_FLIGHT);
 
    for (size_t i = 0; i < MAX_FRAMES_IN_FLIGHT; i++)
    {
        mRenderer->CreateBuffer(matVarBufferSize, VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT,
            VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
            mMaterialParametersBuffers[i], mMaterialParametersMemory[i]);
    }
}

DrawIndexed()

void rendering_engine::VulkanRenderResources::DrawIndexed ( )

protected

Issues a Vulkan draw command for the currently bound indexed mesh.

Definition at line 384 of file vulkan_render_resources.cpp.

{
    auto commandBuffers = mRenderer->GetComandBuffers();
    auto frame = mRenderer->GetCurrentFrame();
 
    VkBuffer vertexBuffer[] = { mVertexBuffer };
    VkDeviceSize offsets[] = { 0 };
 
    vkCmdBindPipeline(commandBuffers[frame], VK_PIPELINE_BIND_POINT_GRAPHICS, mGraphicsPipeline);
    
    /*If dynamicState in pipeline is used then vkCmdSetViewport and vkCmdSetScissor per draw call*/
    //VkViewport viewport{};
    //viewport.x = 0.0f;
    //viewport.y = 0.0f;
    //viewport.width = static_cast<float>(mRenderer->GetSwapChainExtent().width);
    //viewport.height = static_cast<float>(mRenderer->GetSwapChainExtent().height);
    //viewport.minDepth = 0.0f;
    //viewport.maxDepth = 1.0f;
    //vkCmdSetViewport(commandBuffers[frame], 0, 1, &viewport);
 
    //VkRect2D scissor{};
    //scissor.offset = { 0, 0 };
    //scissor.extent = mRenderer->GetSwapChainExtent();
    //vkCmdSetScissor(commandBuffers[frame], 0, 1, &scissor);
    
    vkCmdBindVertexBuffers(commandBuffers[frame], 0, 1, vertexBuffer, offsets);
    vkCmdBindIndexBuffer(commandBuffers[frame], mIndexBuffer, 0, VK_INDEX_TYPE_UINT32);
    vkCmdBindDescriptorSets(commandBuffers[frame], VK_PIPELINE_BIND_POINT_GRAPHICS,
        mPipelineLayout, 0, 1, &mDescriptorSets[frame], 0, nullptr);
    vkCmdDrawIndexed(commandBuffers[frame], static_cast<uint32_t>(mMeshData->GetIndices().size()), 1, 0, 0, 0);
}

Initialize()

void rendering_engine::VulkanRenderResources::Initialize ( Material *  material, MeshDataGpu *  meshData, TextureCache *  textureCache  )

overridevirtual

Initializes GPU-side resources using provided material, mesh, and texture cache.

Parameters

material	Pointer to the Material describing the shader and its parameters.
meshData	Pointer to MeshDataGpu containing vertex and index buffers.
textureCache	Pointer to the TextureCache containing all loaded textures.

Note

Ownership of parameters is not transferred; caller must ensure they remain valid.

Implements rendering_engine::IRenderResources.

Definition at line 28 of file vulkan_render_resources.cpp.

{
    mMaterial = material;
    mMeshData = meshData;
    mTextureCache = textureCache;
 
    AcquireResources();
}

OnRenderResourcesRebuild()

void rendering_engine::VulkanRenderResources::OnRenderResourcesRebuild ( )

overrideprotectedvirtual

Renderer callback: re-upload or recreate all GPU resources (used after device reset/rebuild).

This method will be called after the device or swapchain is recreated, allowing the observer to re-upload or recreate all necessary resources for rendering.

Implements rendering_engine::IRendererObserver.

Definition at line 121 of file vulkan_render_resources.cpp.

{
    AcquireResources();
}

OnRenderResourcesRelease()

void rendering_engine::VulkanRenderResources::OnRenderResourcesRelease ( )

overrideprotectedvirtual

Renderer callback: release all GPU resources (used during device loss/reset).

This method will be called before any device or swapchain is destroyed, allowing the observer to safely release all handles and deallocate any GPU memory.

Implements rendering_engine::IRendererObserver.

Definition at line 116 of file vulkan_render_resources.cpp.

{
    Shutdown();
}

Shutdown()

void rendering_engine::VulkanRenderResources::Shutdown ( )

overridevirtual

Releases all allocated GPU resources for this object.

Implements rendering_engine::IRenderResources.

Definition at line 51 of file vulkan_render_resources.cpp.

{
    if (mDescriptorPool != VK_NULL_HANDLE)
    {
        DeferredItem descriptorPool;
        descriptorPool.type = DeferredType::DescriptorPool;
        descriptorPool.descriptorPool = mDescriptorPool;
        mRenderer->AddDeferredDestroy(descriptorPool);
        mDescriptorPool = VK_NULL_HANDLE;
 
    }
 
    for (size_t i = 0; i < mTransformationBuffers.size(); i++)
    {
        if (mTransformationBuffers[i] != VK_NULL_HANDLE)
        {
            DeferredItem tBuffer;
            tBuffer.type = DeferredType::Buffer;
            tBuffer.buffer = mTransformationBuffers[i];
            mRenderer->AddDeferredDestroy(tBuffer);
        }
 
        if (i < mTransformationBuffersMemory.size() &&
            mTransformationBuffersMemory[i] != VK_NULL_HANDLE)
        {
 
            DeferredItem tMem;
            tMem.type = DeferredType::Memory;
            tMem.memory = mTransformationBuffersMemory[i];
            mRenderer->AddDeferredDestroy(tMem);
 
            mTransformationBuffers[i] = VK_NULL_HANDLE;
            mTransformationBuffersMemory[i] = VK_NULL_HANDLE;
        }
    }
 
    for(size_t i = 0; i < mMaterialParametersBuffers.size(); ++i)
    {
        if (mMaterialParametersBuffers[i] != VK_NULL_HANDLE)
        {
            DeferredItem matBuffer;
            matBuffer.type = DeferredType::Buffer;
            matBuffer.buffer = mMaterialParametersBuffers[i];
            mRenderer->AddDeferredDestroy(matBuffer);
        }
 
        if(i < mMaterialParametersMemory.size() &&
            mMaterialParametersMemory[i] != VK_NULL_HANDLE)
        {
            DeferredItem matMem;
            matMem.type = DeferredType::Memory;
            matMem.memory = mMaterialParametersMemory[i];
            mRenderer->AddDeferredDestroy(matMem);
 
            mMaterialParametersBuffers[i] = VK_NULL_HANDLE;
            mMaterialParametersMemory[i] = VK_NULL_HANDLE;
        }
    }
 
    mTransformationBuffers.clear();
    mTransformationBuffersMemory.clear();
    mMaterialParametersBuffers.clear();
    mMaterialParametersMemory.clear();
}

SubmitResources() [1/2]

void rendering_engine::VulkanRenderResources::SubmitResources ( Transformations2D &  transformations, const PackedMaterialData &  materialParameters  )

overridevirtual

Updates GPU resources and issues a draw call for a 2D object.

Parameters

transformations	Transformation data (2D).
materialParameters	Packed structure with material parameters for the draw call.

Implements rendering_engine::IRenderResources.

Definition at line 37 of file vulkan_render_resources.cpp.

{
    UpdateTransformations(transformations);
    UpdateMaterialParameters(materialParameters);
    DrawIndexed();
}

SubmitResources() [2/2]

void rendering_engine::VulkanRenderResources::SubmitResources ( Transformations3D &  transformations, const PackedMaterialData &  materialParameters  )

overridevirtual

Updates GPU resources and issues a draw call for a 3D object.

Parameters

transformations	Transformation data (3D).
materialParameters	Packed structure with material parameters for the draw call.

Implements rendering_engine::IRenderResources.

Definition at line 44 of file vulkan_render_resources.cpp.

{
    UpdateTransformations(transformations);
    UpdateMaterialParameters(materialParameters);
    DrawIndexed();
}

UpdateMaterialParameters()

void rendering_engine::VulkanRenderResources::UpdateMaterialParameters ( const PackedMaterialData &  materialParameters )

protected

Definition at line 369 of file vulkan_render_resources.cpp.

{
    auto device = mRenderer->GetLogicalDevice();
    auto frame = mRenderer->GetCurrentFrame();
 
    // Update custom variables
    if (!materialParameters.buffer.empty())
    {
        void* dataCustom;
        vkMapMemory(device, mMaterialParametersMemory[frame], 0, materialParameters.buffer.size(), 0, &dataCustom);
        memcpy(dataCustom, materialParameters.buffer.data(), materialParameters.buffer.size());
        vkUnmapMemory(device, mMaterialParametersMemory[frame]);
    }
}

UpdateTransformations() [1/2]

void rendering_engine::VulkanRenderResources::UpdateTransformations ( Transformations2D &  transformations )

protected

Definition at line 343 of file vulkan_render_resources.cpp.

{
    auto device = mRenderer->GetLogicalDevice();
    auto frame = mRenderer->GetCurrentFrame();
 
    // Update transformations
    void* dataTransform;
    vkMapMemory(device, mTransformationBuffersMemory[frame], 0, sizeof(Transformations2D), 0, &dataTransform);
    memcpy(dataTransform, &transformations, sizeof(transformations));
    vkUnmapMemory(device, mTransformationBuffersMemory[frame]);
}

UpdateTransformations() [2/2]

void rendering_engine::VulkanRenderResources::UpdateTransformations ( Transformations3D &  transformations )

protected

Definition at line 355 of file vulkan_render_resources.cpp.

{
    auto device = mRenderer->GetLogicalDevice();
    auto frame = mRenderer->GetCurrentFrame();
 
    // Flip Y-axis for Vulkan clip space
    transformations.proj[1][1] *= -1;
    // Update transformations
    void* dataTransform;
    vkMapMemory(device, mTransformationBuffersMemory[frame], 0, sizeof(Transformations3D), 0, &dataTransform);
    memcpy(dataTransform, &transformations, sizeof(transformations));
    vkUnmapMemory(device, mTransformationBuffersMemory[frame]);
}

---

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

• vulkan_render_resources.hpp
• vulkan_render_resources.cpp