src/Objects/render_texture.c - master - Zamar_Terrier/TigorEngine

src/Objects/render_texture.c
552 строки22 KB
Zamar_Terrier
Запрос на слияние 'feature-12032026' (#9) из feature-12032026 в master
08 июн 2026, 11:31
08 июн 2026, 11:312200f38
#include "Objects/render_texture.h"

#include "TigorEngine.h"

#include "Core/e_camera.h"
#include "Core/e_memory.h"
#include "Core/e_device.h"
#include "Core/e_buffer.h"
#include "Core/e_texture.h"
#include "Core/swapchain.h"

#include <vulkan/vulkan.h>

#include "Tools/e_math.h"
#include "Tools/e_tools.h"

#include "Data/e_resource_data.h"
#include "Data/e_resource_engine.h"

extern TEngine engine;

void RenderTextureCreateDepthResource(RenderTexture *render, RenderFrame *frame)
{

    VkFormat depthFormat = findDepthFormat();

    TextureCreateImage(render->width, render->height, 1,depthFormat, VK_IMAGE_TILING_OPTIMAL, VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, 0, &frame->depth_texture);
    frame->depth_texture.image_view = TextureCreateImageView(frame->depth_texture.image, VK_IMAGE_VIEW_TYPE_2D, depthFormat, VK_IMAGE_ASPECT_DEPTH_BIT, 1);

    //ToolsTransitionImageLayout((void *)frame->depth_texture.image, depthFormat, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, 1);

}

void RenderTextureCreateRenderPass(RenderTexture *render, VkRenderPass *render_pass)
{

    if(render->m_format == 0)
    {
        VkSubpassDescription subpassDescription = {0};
        subpassDescription.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;

        // Geometry render pass doesn't need any output attachment.
        VkRenderPassCreateInfo renderPassInfo = {0};
        renderPassInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
        renderPassInfo.attachmentCount = 0;
        renderPassInfo.subpassCount = 1;
        renderPassInfo.pSubpasses = &subpassDescription;

        if(vkCreateRenderPass(engine.device.e_device, &renderPassInfo, NULL, (VkRenderPass *)render_pass) != VK_SUCCESS)
        {
            printf("Error create render pass for render texture.");
            exit(1);
        }

        return;
    }

    VkAttachmentDescription colorAttachment = {0};
    colorAttachment.format = render->m_format;
    colorAttachment.samples = VK_SAMPLE_COUNT_1_BIT;
    colorAttachment.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
    colorAttachment.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
    colorAttachment.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
    colorAttachment.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
    colorAttachment.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
    colorAttachment.finalLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;

    VkAttachmentDescription depthAttachment = {0};
    depthAttachment.format = findDepthFormat();
    depthAttachment.samples = VK_SAMPLE_COUNT_1_BIT;
    depthAttachment.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
    depthAttachment.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
    depthAttachment.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
    depthAttachment.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
    depthAttachment.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
    depthAttachment.finalLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL;

    if(render->type == TIGOR_RENDER_TYPE_IMAGE || render->type == TIGOR_RENDER_TYPE_CUBEMAP)
    {
        colorAttachment.initialLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
        colorAttachment.finalLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
    }else if( render->type == TIGOR_RENDER_TYPE_DEPTH || (render->flags & TIGOR_RENDER_FLAG_DEPTH))
    {
        depthAttachment.initialLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
        depthAttachment.finalLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
    }else if(render->type == TIGOR_RENDER_TYPE_COLORED_IMAGE){
        colorAttachment.finalLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
        depthAttachment.finalLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
    }

    VkAttachmentReference colorAttachmentRef ={0};
    colorAttachmentRef.attachment = 0;//Номер атачмента
    colorAttachmentRef.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;

    VkAttachmentReference depthAttachmentRef = {0};
    depthAttachmentRef.attachment = render->type  == TIGOR_RENDER_TYPE_DEPTH || (render->flags & TIGOR_RENDER_FLAG_DEPTH) ? 0 : 1;//Номер атачмента
    depthAttachmentRef.layout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;

    VkSubpassDescription subpass = {0};
    subpass.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;

    if(render->type != TIGOR_RENDER_TYPE_IMAGE)
        subpass.pDepthStencilAttachment = &depthAttachmentRef;

    if(render->type != TIGOR_RENDER_TYPE_DEPTH && !(render->flags & TIGOR_RENDER_FLAG_DEPTH)){
        subpass.colorAttachmentCount = 1;
        subpass.pColorAttachments = &colorAttachmentRef;
    }

    VkSubpassDependency depency[2] = {0};
    VkRenderPassCreateInfo renderPassInfo = {0};
    VkAttachmentDescription attachments[] = {colorAttachment, depthAttachment};

    if(render->type == TIGOR_RENDER_TYPE_CUBEMAP)
    {
        if(render->flags & TIGOR_RENDER_FLAG_DEPTH)
        {
            renderPassInfo.attachmentCount = 1;
            renderPassInfo.pAttachments = &depthAttachment;
        }else{

            renderPassInfo.attachmentCount = 2;
            renderPassInfo.pAttachments = attachments;
        }


    }else if(render->type != TIGOR_RENDER_TYPE_DEPTH){
        depency[0].srcSubpass = VK_SUBPASS_EXTERNAL;
        depency[0].dstSubpass = 0;
        depency[0].srcStageMask = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
        depency[0].dstStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT | VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT | VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT;
        depency[0].srcAccessMask = VK_ACCESS_SHADER_READ_BIT;
        depency[0].dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;

        depency[1].srcSubpass = 0;
        depency[1].dstSubpass = VK_SUBPASS_EXTERNAL;
        depency[1].srcStageMask = VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT;
        depency[1].dstStageMask = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
        depency[1].srcAccessMask = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
        depency[1].dstAccessMask = VK_ACCESS_SHADER_READ_BIT;

        if(render->type == TIGOR_RENDER_TYPE_COLORED_IMAGE){
            depency[0].srcSubpass = VK_SUBPASS_EXTERNAL;
            depency[0].dstSubpass = 0;
            depency[0].srcStageMask = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
            depency[0].dstStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT | VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT | VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT;
            depency[0].srcAccessMask = VK_ACCESS_NONE_KHR;
            depency[0].dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
            depency[0].dependencyFlags = VK_DEPENDENCY_BY_REGION_BIT;

            depency[1].srcSubpass = 0;
            depency[1].dstSubpass = VK_SUBPASS_EXTERNAL;
            depency[1].srcStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT | VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT | VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT;
            depency[1].dstStageMask = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
            depency[1].srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
            depency[1].dstAccessMask = VK_ACCESS_MEMORY_READ_BIT;
            depency[1].dependencyFlags = VK_DEPENDENCY_BY_REGION_BIT;
        }

        if(render->type == TIGOR_RENDER_TYPE_WINDOW || render->type == TIGOR_RENDER_TYPE_COLORED_IMAGE)
        {
            renderPassInfo.attachmentCount = 2;
            renderPassInfo.pDependencies = depency;
            renderPassInfo.pAttachments = attachments;
        }else{
            renderPassInfo.attachmentCount = 1;
            renderPassInfo.pDependencies = depency;
            renderPassInfo.pAttachments = &colorAttachment;
        }

    }else{

        depency->srcSubpass = VK_SUBPASS_EXTERNAL;
        depency->dstSubpass = 0;
        depency->srcStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
        depency->srcAccessMask = 0;
        depency->dstStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
        depency->dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;

        renderPassInfo.attachmentCount = 1;
        renderPassInfo.pDependencies = depency;
        renderPassInfo.pAttachments = &depthAttachment;
    }

    renderPassInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
    renderPassInfo.subpassCount = 1;
    renderPassInfo.pSubpasses = &subpass;
    renderPassInfo.dependencyCount = render->type == TIGOR_RENDER_TYPE_CUBEMAP ? 0 : 2;

    if(vkCreateRenderPass(engine.device.e_device, &renderPassInfo, NULL, (VkRenderPass *)render_pass) != VK_SUCCESS)
    {
        printf("Error create render pass for render texture.");
        exit(1);
    }
    
}

void RenderTextureTransitionLayer(RenderFrame *frame, uint32_t render_type, uint32_t type_layout, uint32_t aspect_mask)
{
    VkImageMemoryBarrier imgBar = {0};

    imgBar.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
    imgBar.pNext = NULL;
    imgBar.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
    imgBar.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
    imgBar.srcAccessMask = 0;
    imgBar.dstAccessMask = 0;
    imgBar.oldLayout = frame->m_currentLayout;
    imgBar.newLayout = type_layout;
    imgBar.image = frame->render_texture.image;

    imgBar.subresourceRange.aspectMask = aspect_mask;//render_type == TIGOR_RENDER_TYPE_DEPTH ? VK_IMAGE_ASPECT_DEPTH_BIT : VK_IMAGE_ASPECT_COLOR_BIT;
    imgBar.subresourceRange.baseMipLevel = 0;
    imgBar.subresourceRange.levelCount = 1;
    imgBar.subresourceRange.baseArrayLayer = 0;

    imgBar.subresourceRange.layerCount = render_type == TIGOR_RENDER_TYPE_CUBEMAP ? 6 : 1;

    void *cmd_buff = beginSingleTimeCommands();

    vkCmdPipelineBarrier(cmd_buff, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, 0, 0, NULL, 0, NULL, 1, &imgBar);

    endSingleTimeCommands(cmd_buff);
}

void RenderTextureCreateFrames(RenderTexture *render, uint32_t flags)
{
    uint32_t usage = 0;

    for (int i=0;i < render->num_frames;i++) {

        RenderFrame *frame = &render->frames[i];

        memset(frame->framebufers, 0, sizeof(frame->framebufers));

        if(render->m_format != 0)
        {
            frame->m_currentLayout = VK_IMAGE_LAYOUT_UNDEFINED;

            if(render->type != TIGOR_RENDER_TYPE_WINDOW)
            {
                if(render->type == TIGOR_RENDER_TYPE_DEPTH || (render->flags & TIGOR_RENDER_FLAG_DEPTH))
                    usage = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT;
                else
                    usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT;

                frame->render_texture.flags |= TIGOR_TEXTURE2D_NO_INITIAL;

                TextureCreateImage(render->width, render->height, 1, render->m_format, VK_IMAGE_TILING_OPTIMAL, usage, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, flags, &frame->render_texture);

                if(render->type & TIGOR_RENDER_TYPE_CUBEMAP)
                {
                    frame->shadowCubeMapFaceImageViews = AllocateMemoryP(6, sizeof(VkImageView), render);
                    frame->render_texture.image_view = (VkImageView)TextureCreateImageViewCube((void *)frame->render_texture.image, frame->shadowCubeMapFaceImageViews, render->m_format, render->flags & TIGOR_RENDER_FLAG_DEPTH ? VK_IMAGE_ASPECT_DEPTH_BIT : VK_IMAGE_ASPECT_COLOR_BIT);
                    
                }else{
                    frame->render_texture.image_view = TextureCreateImageView(frame->render_texture.image, VK_IMAGE_VIEW_TYPE_2D, render->m_format, render->type == TIGOR_RENDER_TYPE_DEPTH || (render->flags & TIGOR_RENDER_FLAG_DEPTH) ? VK_IMAGE_ASPECT_DEPTH_BIT : VK_IMAGE_ASPECT_COLOR_BIT, 1);
                }

                TextureCreateSampler(&frame->render_texture.sampler, render->m_format, 1);

                RenderTextureCreateDepthResource(render, frame);

                frame->render_texture.imageLayout = 0;

                //RenderTextureTransitionLayer(frame, render->type, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, render->type == TIGOR_RENDER_TYPE_DEPTH || (render->flags & TIGOR_RENDER_FLAG_DEPTH) ? VK_IMAGE_ASPECT_DEPTH_BIT : VK_IMAGE_ASPECT_COLOR_BIT);

            }else{
                frame->render_texture.image_view = engine.swapchain.swapChainImageViews[i];
            }
        }else{
            frame->m_currentLayout = VK_IMAGE_LAYOUT_GENERAL;
        }

        VkFramebufferCreateInfo framebufferInfo = {0};
        framebufferInfo.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
        framebufferInfo.renderPass = (VkRenderPass)render->render_pass;
        framebufferInfo.width = render->width;
        framebufferInfo.height = render->height;
        framebufferInfo.layers = 1;

        if(render->type == TIGOR_RENDER_TYPE_GEOMETRY)
        {
            if(vkCreateFramebuffer(engine.device.e_device, &framebufferInfo, NULL, (VkFramebuffer *)&frame->framebufers[0]) != VK_SUCCESS)
            {
                printf("Error create framebuffer for render texture.");
                exit(1);
            }
        }else if(render->type == TIGOR_RENDER_TYPE_WINDOW)
        {
            VkImageView attachments[2];
            attachments[0] = frame->render_texture.image_view;
            attachments[1] = engine.swapchain.depth_texture.image_view;

            framebufferInfo.attachmentCount = 2;
            framebufferInfo.pAttachments = attachments;

            if(vkCreateFramebuffer(engine.device.e_device, &framebufferInfo, NULL, (VkFramebuffer *)&frame->framebufers[0]) != VK_SUCCESS)
            {
                printf("Error create framebuffer for render texture.");
                exit(1);
            }
        }else if(render->type == TIGOR_RENDER_TYPE_COLORED_IMAGE)
        {
            VkImageView attachments[2];
            attachments[0] = frame->render_texture.image_view;
            attachments[1] = frame->depth_texture.image_view;

            framebufferInfo.attachmentCount = 2;
            framebufferInfo.pAttachments = attachments;

            if(vkCreateFramebuffer(engine.device.e_device, &framebufferInfo, NULL, (VkFramebuffer *)&frame->framebufers[0]) != VK_SUCCESS)
            {
                printf("Error create framebuffer for render texture.");
                exit(1);
            }

        }else if(render->type == TIGOR_RENDER_TYPE_CUBEMAP){


            if(render->flags & TIGOR_RENDER_FLAG_DEPTH)
            {
                for(int j=0;j < 6;j++)
                {
                    VkImageView attachments[] = { (VkImageView)frame->shadowCubeMapFaceImageViews[j] };

                    framebufferInfo.attachmentCount = 1;
                    framebufferInfo.pAttachments = attachments;

                    if(vkCreateFramebuffer(engine.device.e_device, &framebufferInfo, NULL, (VkFramebuffer *)&frame->framebufers[j]) != VK_SUCCESS)
                    {
                        printf("Error create framebuffer for render texture.");
                        exit(1);
                    }
                }
            }else{
                VkImageView attachments[2];
                attachments[1] = frame->depth_texture.image_view;

                for(int j=0;j < 6;j++)
                {
                    attachments[0] = (VkImageView)frame->shadowCubeMapFaceImageViews[j];

                    framebufferInfo.attachmentCount = 2;
                    framebufferInfo.pAttachments = attachments;

                    if(vkCreateFramebuffer(engine.device.e_device, &framebufferInfo, NULL, (VkFramebuffer *)&frame->framebufers[j]) != VK_SUCCESS)
                    {
                        printf("Error create framebuffer for render texture.");
                        exit(1);
                    }
                }
            }

        }else{
            VkImageView attachment[] = { frame->depth_texture.image_view };

            framebufferInfo.attachmentCount = 1;
            framebufferInfo.pAttachments = attachment;

            if(vkCreateFramebuffer(engine.device.e_device, &framebufferInfo, NULL, (VkFramebuffer *)&frame->framebufers[0]) != VK_SUCCESS)
            {
                printf("Error create framebuffer for render texture.");
                exit(1);
            }
        }

    }
}

void RenderTextureInit(RenderTexture *render, uint32_t type, uint32_t width, uint32_t height, uint32_t flags)
{

    memset(render, 0, sizeof(RenderTexture));

    switch(type)
    {
        case TIGOR_RENDER_TYPE_DEPTH:
            render->m_format = findDepthFormat();
            break;
        case TIGOR_RENDER_TYPE_CUBEMAP:
            render->m_format = VK_FORMAT_R32_SFLOAT;
            break;
        case TIGOR_RENDER_TYPE_WINDOW:
            render->m_format = engine.swapchain.swapChainImageFormat;
            break;
        case TIGOR_RENDER_TYPE_IMAGE:
            render->m_format = engine.swapchain.swapChainImageFormat;
            break;
        case TIGOR_RENDER_TYPE_COLORED_IMAGE:
            render->m_format = VK_FORMAT_R8G8B8A8_UNORM;
            break;
        default:
            render->m_format = 0;
            break;
    }

    render->type = type;
    render->mip_levels = floor(log2(e_max(width, height))) + 1;

    if(flags & TIGOR_RENDER_FLAG_DEPTH)
        render->m_format = findDepthFormat();

    render->flags = flags;

    render->currFrame = 0;

    if(type != TIGOR_RENDER_TYPE_WINDOW && type != TIGOR_RENDER_TYPE_GEOMETRY)
    {
        render->height = height;
        render->width = width;
    }else{
        render->height = engine.swapchain.swapChainExtent.height;
        render->width = engine.swapchain.swapChainExtent.width;
    }

    Camera2DInit(&render->cam2D);
    Camera3DInit(&render->cam3D);

    render->cam3D.ortg_view_distance = 100;
    render->cam3D.ortg_view_size = 0.01;

    render->cam3D.frust_far = 100;
    render->cam3D.frust_near = 0.1;
    render->cam3D.frust_side = 0.1;

    render->cam3D.cascadeSplit = 0;

    render->clear_color = type == TIGOR_RENDER_TYPE_COLORED_IMAGE ? vec3_f(0,0,0) : vec3_f( 0.3, 0.01f, 0.01f);
    render->up_vector = vec3_f( 0, 1, 0);

    if(render->type == TIGOR_RENDER_TYPE_IMAGE)
    {
        render->flags |= TIGOR_RENDER_FLAG_ONE_SHOT;
        render->num_frames = 1;
    }else if(render->type == TIGOR_RENDER_TYPE_COLORED_IMAGE)
    {
        render->num_frames = 1;
    }else{
        render->num_frames = engine.imagesCount;
    }

    RenderTextureCreateRenderPass(render, &render->render_pass);

    if(type & TIGOR_RENDER_TYPE_CUBEMAP)
        RenderTextureCreateFrames(render, VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT);
    else
        RenderTextureCreateFrames(render, 0);

    return;
}

void RenderTextureReload(RenderTexture *render, uint32_t indx_surf)
{
    if(render->flags & TIGOR_RENDER_FLAG_ONE_SHOT)
        render->flags &= ~(TIGOR_RENDER_FLAG_SHOOTED);
}

void RenderTextureRecreate(RenderTexture *render)
{
    RenderTextureDestroy(render);

    if(render->type == TIGOR_RENDER_TYPE_WINDOW)
        RenderTextureInit(render, render->type, engine.width, engine.height, render->flags);
    else
        RenderTextureInit(render, render->type, render->width, render->height, render->flags);
}

void RenderTextureBeginRendering(RenderTexture *render, void *cmd_buff)
{
    RenderFrame *frame;

    if(render->num_frames > 1)
        frame = &render->frames[engine.imageIndex];
    else
        frame = &render->frames[0];

    VkRenderPassBeginInfo renderBeginInfo = {0};
    renderBeginInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
    renderBeginInfo.renderPass = (VkRenderPass)render->render_pass;

    if(render->type & TIGOR_RENDER_TYPE_CUBEMAP)
        renderBeginInfo.framebuffer = (VkFramebuffer)frame->framebufers[render->currFrame];
    else{
        renderBeginInfo.framebuffer = (VkFramebuffer)frame->framebufers[0];
    }
    renderBeginInfo.renderArea.offset.x = 0;
    renderBeginInfo.renderArea.offset.y = 0;
    renderBeginInfo.renderArea.extent.width = render->width;
    renderBeginInfo.renderArea.extent.height = render->height;

    if(render->m_format != 0)
    {
        if(render->type == TIGOR_RENDER_TYPE_DEPTH || (render->flags & TIGOR_RENDER_FLAG_DEPTH))
        {

            render->clearValues[0].depthStencil.depth = 1.0f;
            render->clearValues[0].depthStencil.stencil = 0.0;

            renderBeginInfo.clearValueCount = 1;
            renderBeginInfo.pClearValues = render->clearValues;
        }else{

            render->clearValues[0].color.float32[0] = render->clear_color.x;
            render->clearValues[0].color.float32[1] = render->clear_color.y;
            render->clearValues[0].color.float32[2] = render->clear_color.z;
            render->clearValues[0].color.float32[3] = 1.0f;
            render->clearValues[1].depthStencil.depth = 1.0f;
            render->clearValues[1].depthStencil.stencil = 0;

            renderBeginInfo.clearValueCount = 2;
            renderBeginInfo.pClearValues = render->clearValues;
        }
    }

    vkCmdBeginRenderPass(cmd_buff, &renderBeginInfo, VK_SUBPASS_CONTENTS_INLINE);
}

void RenderTextureSetCurrentFrame(RenderTexture *render, uint32_t indx_frame)
{
    render->currFrame = indx_frame;
}

void RenderTextureEndRendering(RenderTexture *render, void *cmd_buff)
{
    vkCmdEndRenderPass(cmd_buff);
}

void RenderTextureDestroy(RenderTexture *render)
{

    for (int j=0;j< render->num_frames;j++) {

        if(render->type != TIGOR_RENDER_TYPE_WINDOW)
        {

            ImageDestroyTexture(&render->frames[j].render_texture);
            ImageDestroyTexture(&render->frames[j].depth_texture);
        }

        if(render->type & TIGOR_RENDER_TYPE_CUBEMAP)
        {
            for(int i=0;i < 6;i++){
                vkDestroyFramebuffer(engine.device.e_device, (VkFramebuffer)render->frames[j].framebufers[i], NULL);
                vkDestroyImageView(engine.device.e_device, (VkImageView)render->frames[j].shadowCubeMapFaceImageViews[i], NULL);
            }
        }else
            vkDestroyFramebuffer(engine.device.e_device, (VkFramebuffer)render->frames[j].framebufers[0], NULL);
    }

    vkDestroyRenderPass(engine.device.e_device, (VkRenderPass)render->render_pass, NULL);
}