Vulkan с классами - пишем deferred renderer

Написание отложенного освещения заметно сложнее, чем традиционный рендеринг - необходимо осуществить построение G-буфера (т.е. рендеринг в фреймбуфер с несколькими цветовыми подключениями) и после этого выполнить расчет освещения, т.е. полноэкранный эффект.

Т.е. нам понадобится дополнительный проход рендеринга (объект Renderpass), а также отдельные объекты-конвейеры и командные буфера для обоих проходов.

Кроме того, мы будем использовать два новых класса - Framebuffer и ScreenQuad. Первый из них является оберткой для VkFramebuffer и представляет собой фреймбуфер с рядом подключений. А второй - это набор объектов для осуществления полноэкранного прохода.

class   Framebuffer
{
    struct  Attachment
    {
        Texture                 texture;
        VkAttachmentDescription description;
    };

    Device                    * device      = nullptr;
    VkFramebuffer               framebuffer = VK_NULL_HANDLE;
    uint32_t                    width, height;  
    Renderpass                  renderpass;
    std::vector<Attachment *>   attachments;

public:
    Framebuffer () = default;
    Framebuffer ( Framebuffer&& f )
    {
        std::swap ( device, f.device           );
        std::swap ( framebuffer, f.framebuffer );
        std::swap ( width,       f.width       );
        std::swap ( height,      f.height      );
        std::swap ( attachments, f.attachments );
        //renderpass = f.renderpass;
        //f.renderpass = Renderpass ()
    }
    Framebuffer ( const Framebuffer& ) = delete;
    ~Framebuffer ()
    {
        clean ();
    }

    Framebuffer& operator = ( const Framebuffer& ) = delete;

    VkFramebuffer   getHandle () const
    {
        return framebuffer;
    }
    
    uint32_t    getWidth () const
    {
        return width;
    }
    
    uint32_t    getHeight () const
    {
        return height;
    }
    
    Renderpass& getRenderpass ()
    {
        return renderpass;
    }
    
    const Texture&  getAttachment ( uint32_t index ) const
    {
        return attachments [index]->texture;
    }
    
    Texture&    getAttachment ( uint32_t index )
    {
        return attachments [index]->texture;
    }
    
    void        clean ()
    {
        for ( auto at : attachments )
            delete at;
        
        attachments.clear ();
        
        vkDestroyFramebuffer ( device->getDevice (), framebuffer, nullptr );
        
        framebuffer = VK_NULL_HANDLE;
    }

    Framebuffer&    init ( Device& dev, uint32_t w, uint32_t h )
    {
        device = &dev;
        width  = w;
        height = h;
        
        return *this;
    }
    
    Framebuffer&    addAttachment ( VkFormat format, VkImageUsageFlags usage, VkImageLayout finalLayout = VK_IMAGE_LAYOUT_UNDEFINED )
    {
        //VkImageAspectFlags    aspectMask = 0;
        VkImageLayout       imageLayout = finalLayout;

        if ( finalLayout == VK_IMAGE_LAYOUT_UNDEFINED )
        {
            if ( usage & VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT )
            {
                //aspectMask  = VK_IMAGE_ASPECT_COLOR_BIT;
                imageLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
            }

            if ( usage & VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT ) 
            {
                //aspectMask  = VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT;
                imageLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
            }
        }
    

        //assert ( aspectMask > 0 );

        Attachment * attachment = new Attachment;
        
        attachment->texture.create          ( *device, width, height, 1, 1, format, VK_IMAGE_TILING_OPTIMAL, usage | VK_IMAGE_USAGE_SAMPLED_BIT, 0 );
        //attachment->texture.createImageView ( aspectMask );

        attachment->description                = {};
        attachment->description.samples        = VK_SAMPLE_COUNT_1_BIT;
        attachment->description.loadOp         = VK_ATTACHMENT_LOAD_OP_CLEAR;
        attachment->description.storeOp        = VK_ATTACHMENT_STORE_OP_STORE;
        attachment->description.stencilLoadOp  = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
        attachment->description.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
        attachment->description.initialLayout  = VK_IMAGE_LAYOUT_UNDEFINED;
        attachment->description.finalLayout    = imageLayout;
        attachment->description.format         = format;

        attachments.push_back ( attachment );
        
        return *this;
    }
    
    Framebuffer&    create ()
    {
        VkFramebufferCreateInfo     createInfo = {};
        std::vector<VkImageView>    views;

        for ( size_t i = 0; i < attachments.size (); i++ )
        {
            auto&   desc = attachments [i]->description;
            
            if ( attachments [i]->texture.getImage ().hasDepth () )
            {
                renderpass.addAttachment   ( desc.format, desc.initialLayout, desc.finalLayout );   //VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL );
                renderpass.addDepthSubpass ( (uint32_t) i );
            }
            else
            {
                renderpass.addAttachment ( desc.format, desc.initialLayout, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL );
                renderpass.addSubpass    ( (uint32_t) i );
            }
            
            views.push_back ( attachments [i]->texture.getImageView () );
        }
        
        renderpass.create ( *device );              // 2 dependencices ???
        
        createInfo.sType           = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
        createInfo.renderPass      = renderpass.getHandle ();
        createInfo.pAttachments    = views.data();
        createInfo.attachmentCount = (uint32_t) views.size ();
        createInfo.width           = width;
        createInfo.height          = height;
        createInfo.layers          = 1;
        
        if ( vkCreateFramebuffer ( device->getDevice (), &createInfo, nullptr, &framebuffer ) != VK_SUCCESS )
            fatal () << "Framebuffer: error creating framebuffer" << Log::endl;
        
        return *this;
    }
};

class   ScreenQuad
{
    Buffer  buffer;
    
public:
    ScreenQuad () = default;
    ScreenQuad ( const ScreenQuad& ) = delete;  

    ScreenQuad& operator = ( const ScreenQuad& ) = delete;

    bool    isOk () const
    {
        return buffer.isOk ();
    }

    CommandBuffer&  render ( CommandBuffer& commandBuffer ) 
    {
        assert ( buffer.getHandle () != VK_NULL_HANDLE );

        return commandBuffer.bindVertexBuffers ( { {buffer, 0} } ).draw ( 6 );
    }

            // register vertex attributes in pipeline
    GraphicsPipeline&   setVertexAttrs ( GraphicsPipeline& pipeline )
    {
        pipeline.addVertexAttr ( 0, 0, VK_FORMAT_R32G32B32A32_SFLOAT, 0 );
                
        return pipeline;
    }
            // create buffer
    void    create ( Device& device )
    {
        static const float vertices [] = 
        {
            -1, -1, 0, 0,
            -1,  1, 0, 1,
             1,  1, 1, 1,

            -1, -1, 0, 0,
             1,  1, 1, 1,
             1, -1, 1, 0
        };

        uint32_t            size = sizeof ( vertices );
        Buffer              stagingBuffer;
        SingleTimeCommand   cmd ( device );

                    // use staging buffer to copy data to GPU-local memory
        stagingBuffer.create ( device, size, VK_BUFFER_USAGE_TRANSFER_SRC_BIT, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT );
        stagingBuffer.copy   ( vertices, size );
        buffer.create        ( device, size, VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT );
        buffer.copyBuffer    ( cmd, stagingBuffer, size );
    }
};

Исходя из того, что у нас будет два прохода рендеринга (построение G-буфера и расчет освещения по нему), то класс нашего приложения будет содержать следующие поля:

struct UniformBufferObject 
{
    glm::mat4 mv;
    glm::mat4 proj;
    glm::mat4 nm;
    glm::vec4 light;
};

class   DeferredWindow : public VulkanWindow
{
    std::vector<CommandBuffer>      commandBuffers;
    std::vector<Buffer>             uniformBuffers;
    std::vector<DescriptorSet>      descriptorSets;
    GraphicsPipeline                pipeline;
    Renderpass                      renderPass;
    Sampler                         sampler;
    Framebuffer                     fb;                 // G-buffer 
    CommandBuffer                   offscreenCmd;
    DescriptorSet                   offscreenDescriptorSet;
    Semaphore                       offscreenSemaphore;
    GraphicsPipeline                offscreenPipeline;
    ScreenQuad                      screen;             // class used to do screen processing
    float                           zMin = 0.1f;
    float                           zMax = 100.0f;  
    double                          time = 0;

    DescriptorSet                   offscreenDescriptorSet1, offscreenDescriptorSet2, offscreenDescriptorSet3;

    Mesh * box1 = nullptr;      // decalMap, bump1 -> DS1
    Mesh * box2 = nullptr;      // stoneMap. bump2 -> DS2
    Mesh * box3 = nullptr;
    Mesh * box4 = nullptr;
    Mesh * box5 = nullptr;
    Mesh * knot = nullptr;      // knotMap, bump2 -> DS3

    Texture                         decalMap, stoneMap, knotMap;
    Texture                         bump1, bump2;

Задачей конструктора, как и ранее, является создание и инициализация всех используемых классов, в том числе и создание/загрузка геометрии.

DeferredWindow ( int w, int h, const std::string& t ) : VulkanWindow ( w, h, t, true )
{
    sampler.setMinFilter ( VK_FILTER_LINEAR ).setMagFilter ( VK_FILTER_LINEAR ).create ( device );
    screen.create  ( device );

    decalMap.load ( device, "../../Textures/oak.jpg"         );
    stoneMap.load ( device, "../../Textures/block.jpg"       );
    knotMap.load  ( device, "../../Textures/Oxidated.jpg"    );
    bump1.load    ( device, "../../Textures/wood_normal.png" );
    bump2.load    ( device, "../../Textures/brick_nm.bmp"    );

        // create G-buffer with 2 RGBA16F color attachments and depth attachment
    fb.init ( device, getWidth (), getHeight () )
        .addAttachment ( VK_FORMAT_D24_UNORM_S8_UINT,  VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL  )
        .create ();
          
        // create meshes
    box1 = createBox  ( device, glm::vec3 ( -6, -0.1, -6 ),   glm::vec3 ( 12, 3, 12 ), nullptr, true );
    box2 = createBox  ( device, glm::vec3 ( -1.5, 0, -0.5 ),  glm::vec3 ( 1,  2,  2 ) );
    box3 = createBox  ( device, glm::vec3 ( 1.5, 0, -0.5 ),   glm::vec3 ( 1,  1,  1 ) );
    box4 = createBox  ( device, glm::vec3 ( -4, 0, -0.5 ),    glm::vec3 ( 1,  1,  1 ) );
    box5 = createBox  ( device, glm::vec3 ( -4, 0, -4 ),      glm::vec3 ( 1,  1,  1 ) ); 
    knot = createKnot ( device, 1, 4, 120, 30 );
                
        // create all pipelines
    createPipelines ();
    setController   ( new CameraController ( this ) );
}

~DeferredWindow ()
{
    delete box1;
    delete box2;
    delete box3;
    delete box4;
    delete box5;
    delete knot;
}

Для создания и уничтожения uniform-буферов будем использовать те же методы, что и ранее - createUniformBuffers и freeUniformBuffers.

void    createUniformBuffers ()
{
    VkDeviceSize bufferSize = sizeof ( UniformBufferObject );

    uniformBuffers.resize ( swapChain.imageCount() );
        
    for ( size_t i = 0; i < swapChain.imageCount (); i++ )
        uniformBuffers [i].create ( device, bufferSize, VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT );
}

void    freeUniformBuffers ()
{
    for ( size_t i = 0; i < swapChain.imageCount (); i++ )
        uniformBuffers [i].clean ();
}

Метод createDescriptorSets более сложен, чем ранее, поскольку у нас будет большее число множеств дескрипторов.

void    createDescriptorSets ()
{
    descriptorSets.resize ( swapChain.imageCount () );

        // create descriptors for last pass
    for ( uint32_t i = 0; i < swapChain.imageCount (); i++ )
    {
        descriptorSets  [i]
            .setLayout ( device, descAllocator, pipeline.getDescLayout () )
            .addBuffer ( 0, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, uniformBuffers [i], 0, sizeof ( UniformBufferObject ) )
            .addImage  ( 1, fb.getAttachment ( 0 ), sampler )
            .create    ();
    }       
        // create descriptors for rendering boxes 
    offscreenDescriptorSet1
        .setLayout ( device, descAllocator, offscreenPipeline.getDescLayout () )
        .addBuffer ( 0, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, uniformBuffers [0], 0, sizeof ( UniformBufferObject ) )
        .addImage  ( 1, decalMap, sampler )
        .addImage  ( 2, bump1,    sampler )
        .create    ();
        
    offscreenDescriptorSet2
        .setLayout ( device, descAllocator, offscreenPipeline.getDescLayout () )
        .addBuffer ( 0, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, uniformBuffers [0], 0, sizeof ( UniformBufferObject ) )
        .addImage  ( 1, stoneMap, sampler )
        .addImage  ( 2, bump2,    sampler )
        .create    ();
        
    offscreenDescriptorSet3
        .setLayout ( device, descAllocator, offscreenPipeline.getDescLayout () )
        .addBuffer ( 0, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, uniformBuffers [0], 0, sizeof ( UniformBufferObject ) )
        .addImage  ( 1, knotMap, sampler )
        .addImage  ( 2, bump2,   sampler )
        .create    ();
}

Так как у нас два прохода, то и создание конвейеров рендеринга также станет сложнее.

void    createPipelines () override 
{
    createUniformBuffers    ();
    createDefaultRenderPass ( renderPass );

    screen.setVertexAttrs ( pipeline )
        .setDevice         ( device )
        .setVertexShader   ( "shaders/ds-3-3.vert.spv" )
        .setFragmentShader ( "shaders/ds-3-3.frag.spv" )
        .setSize           ( swapChain.getExtent ().width, swapChain.getExtent ().height )
        .addVertexBinding  ( sizeof ( float ) * 4, 0, VK_VERTEX_INPUT_RATE_VERTEX )
        .addDescLayout     ( 0, DescSetLayout ()
            .add ( 0, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,         VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT )
            .add ( 1, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, VK_SHADER_STAGE_FRAGMENT_BIT ) )       // color attachment 0
        .setCullMode       ( VK_CULL_MODE_NONE )
        .setFrontFace      ( VK_FRONT_FACE_COUNTER_CLOCKWISE )
        .setDepthTest      ( true )
        .setDepthWrite     ( true )
        .create            ( renderPass );
            
    offscreenPipeline
        .setDevice         ( device )
        .setVertexShader   ( "shaders/depthpass.vert.spv" )
        .setFragmentShader ( "shaders/depthpass.frag.spv" )
        .setSize           ( swapChain.getExtent ().width, swapChain.getExtent ().height )
        .addVertexBinding  ( sizeof ( BasicVertex ) )
        .addVertexAttributes<BasicVertex> ()
        .addDescLayout     ( 0, DescSetLayout ()
            .add ( 0, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,         VK_SHADER_STAGE_VERTEX_BIT )
            .add ( 1, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, VK_SHADER_STAGE_FRAGMENT_BIT )         // decal
            .add ( 2, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, VK_SHADER_STAGE_FRAGMENT_BIT ) )       // bump
        .setCullMode       ( VK_CULL_MODE_NONE )
        .setFrontFace      ( VK_FRONT_FACE_COUNTER_CLOCKWISE )
        .setDepthTest      ( true )
        .setDepthWrite     ( true )
        .create            ( fb.getRenderpass () );

            // create before command buffers
    swapChain.createFramebuffers ( renderPass, depthTexture.getImageView () );

    createDescriptorSets         ();
    createCommandBuffers         ( renderPass );
    createOffscreenCommandBuffer ();
}

void    freePipelines () override
{
    commandBuffers.clear ();    
    pipeline.clean       ();
    renderPass.clean     ();
    freeUniformBuffers   ();
    descriptorSets.clear ();
    descAllocator.clean  ();
}

Кроме того у нас будет два метода для создания командных буферов - createCommandBuffers и createOffscreenCommandBuffer.

void    createCommandBuffers ( Renderpass& renderPass )
{
    auto    framebuffers = swapChain.getFramebuffers ();

    commandBuffers = device.allocCommandBuffers ( (uint32_t)framebuffers.size ());

    for ( size_t i = 0; i < commandBuffers.size(); i++ )
    {
        commandBuffers [i].begin ().beginRenderPass ( RenderPassInfo ( renderPass ).framebuffer ( framebuffers [i] ).extent ( swapChain.getExtent ().width, swapChain.getExtent ().height ).clearColor().clearDepthStencil() )
            .pipeline ( pipeline )
            .addDescriptorSets ( { descriptorSets[i] } )
            .render ( &screen )
            .end ();
    }
}

void    createOffscreenCommandBuffer ()
{
    offscreenSemaphore.create ( device );
    offscreenCmd.create       ( device );

    offscreenCmd.begin ( true ).beginRenderPass ( RenderPassInfo ( fb.getRenderpass() ).clearDepthStencil ().framebuffer ( fb ).extent ( fb.getWidth (), fb.getHeight () ) )
    .pipeline          ( offscreenPipeline )
    .addDescriptorSets ( { offscreenDescriptorSet1 } ).render ( box1 )
    .addDescriptorSets ( { offscreenDescriptorSet2 } ).render ( box2 ).render ( box3 ).render ( box4 ).render ( box5 )
    .addDescriptorSets ( { offscreenDescriptorSet3 } ).render ( knot )
    .end               ();
}

И небольшие изменения претерпевает и метод submit в связи с наличием двух проходов рендеринга.

void    submit ( uint32_t imageIndex ) override 
{
    updateUniformBuffer ( imageIndex );

    VkFence                 currentFence  = swapChain.currentInFlightFence ();

    vkResetFences ( device.getDevice (), 1, &currentFence );

    SubmitInfo ()
        .wait    ( { { swapChain.currentAvailableSemaphore (), VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT } } )
        .buffers ( { offscreenCmd } )
        .signal  ( { offscreenSemaphore.getHandle () } )
        .submit  ( device.getGraphicsQueue (), swapChain.currentInFlightFence () );


    SubmitInfo ()
        .wait    ( { { offscreenSemaphore.getHandle (), VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT } } )
        .buffers ( { commandBuffers [imageIndex] } )
        .signal  ( { swapChain.currentRenderFinishedSemaphore () } )
        .submit  ( device.getGraphicsQueue () );
}

Весь исходный код к этому примеру можно скачать из репозитория проекта - https://github.com/steps3d/vulkan-with-classes.