HoviTron Video Pipeline: VulkanRenderPass Class Reference

Class that manage the renderPass containing the synthesis and blending steps. More...

#include <VulkanRenderPass.h>

Inheritance diagram for VulkanRenderPass:

Public Member Functions
	VulkanRenderPass (VulkanContext context, VulkanWrapper wraps)

void	init (InputProvider *inputProvider) override

void	cleanUp () override

void	updateBuffer (uint32_t currentImage, bool initAll, std::span< InputProvider::StreamFrameInfo > infos, int view) override

void	recordCommandBuffer (vk::CommandBuffer &commandBuffer, int i, std::span< InputProvider::StreamFrameInfo > frameInfos, int view) override

bool	isInitialized () override

std::vector< vk::ImageView >	getAttachmentView (int swapIndex, int view)

vk::Image	getImageToBlit (int imageIndex) override

std::vector< vk::Format >	getSupportedDepthFormats () const override

Public Member Functions inherited from VulkanRenderPassAbstract
	VulkanRenderPassAbstract (VulkanContext context, VulkanWrapper wraps)

virtual void	init (InputProvider *inputProvider)

virtual void	cleanUp ()

virtual void	updateBuffer (uint32_t currentImage, bool initAll, std::span< InputProvider::StreamFrameInfo > infos, int view)

virtual void	recordCommandBuffer (vk::CommandBuffer &commandBuffer, int i, std::span< InputProvider::StreamFrameInfo > frameInfos, int view)

virtual bool	isInitialized ()

virtual vk::Image	getImageToBlit (int imageIndex)=0

virtual std::vector< vk::Format >	getSupportedDepthFormats () const =0

Data Fields
std::vector< std::unique_ptr< VulkanPipelineWarping > >	warpingPipelines

std::vector< std::unique_ptr< VulkanPipelineBlending > >	blendingPipelines

vk::RenderPass	renderPass

std::vector< ImageStruct >	attachementColor

std::vector< ImageStruct >	attachementDepthFloat

std::vector< ImageStruct >	attachementQualityFloat

std::vector< ImageStruct >	attachementAccuColor

std::vector< ImageStruct >	attachementAccuQuality

std::vector< ImageStruct >	attachementAccuDepth

std::vector< ImageStruct >	attachementAccuColor2

std::vector< ImageStruct >	attachementAccuQuality2

std::vector< ImageStruct >	attachementAccuDepth2

std::vector< std::vector< vk::Framebuffer > >	swapChainFramebuffers

Data Fields inherited from VulkanRenderPassAbstract
std::vector< ImageStruct >	depthImages

vk::Extent2D	renderingExtent

int	inputImage = 1

vk::CommandPool	commandPoolBuffer = nullptr

vk::Viewport	viewport

vk::Rect2D	scissor

Additional Inherited Members
Protected Member Functions inherited from VulkanRenderPassAbstract
void	createCommandPoolForBuffer ()

void	createDepthResources ()

Protected Attributes inherited from VulkanRenderPassAbstract
bool	initialized = false

InputProvider *	input = nullptr

VulkanContext *	context = nullptr

VulkanWrapper *	wrapper = nullptr

vk::Format	depthFormat

Detailed Description

Class that manage the renderPass containing the synthesis and blending steps.

Class that manage the renderPass containing the synthesis and blending steps It also create additional attachments for the rendering

Definition at line 41 of file VulkanRenderPass.h.

Constructor & Destructor Documentation

◆ VulkanRenderPass()

VulkanRenderPass::VulkanRenderPass	(	VulkanContext *	context,
		VulkanWrapper *	wraps
	)

Constructor

Definition at line 50 of file VulkanRenderPass.cpp.

50 : VulkanRenderPassAbstract(context, wraps)

51{}

VulkanRenderPassAbstract

An abstract class that contains a common base of code for the class that inherit from it.

Definition: VulkanRenderPassAbstract.h:73

VulkanRenderPassAbstract::context

VulkanContext * context

Definition: VulkanRenderPassAbstract.h:114

Member Function Documentation

◆ cleanUp()

void VulkanRenderPass::cleanUp ( )

overridevirtual

Clean up ressources

Reimplemented from VulkanRenderPassAbstract.

Definition at line 136 of file VulkanRenderPass.cpp.

{
    for (int i = 0; i < inputImage; i++) {
        blendingPipelines[i]->cleanUp();
        warpingPipelines[i]->cleanUp();
    }
    blendingPipelines.clear();
    warpingPipelines.clear();
 
    for (auto & im : attachementColor) {
        im.destroy(context->device);
    }
 
    for (auto& im : attachementQualityFloat) {
        im.destroy(context->device);
    }
    for (auto& im : attachementDepthFloat) {
        im.destroy(context->device);
    }
    for (auto& im : attachementAccuColor) {
        im.destroy(context->device);
    }
    for (auto& im : attachementAccuQuality) {
        im.destroy(context->device);
    }
    for (auto& im : attachementAccuDepth) {
        im.destroy(context->device);
    }
    for (auto& im : attachementAccuColor2) {
        im.destroy(context->device);
    }
    for (auto& im : attachementAccuQuality2) {
        im.destroy(context->device);
    }
    for (auto& im : attachementAccuDepth2) {
        im.destroy(context->device);
    }
 
    attachementColor.clear();
    attachementQualityFloat.clear();
    attachementDepthFloat.clear();
    attachementAccuColor.clear();
    attachementAccuQuality.clear();
    attachementAccuDepth.clear();
    attachementAccuColor2.clear();
    attachementAccuQuality2.clear();
    attachementAccuDepth2.clear();
 
    
    for (auto& im : depthImages) {
        im.destroy(context->device);
    }
    depthImages.clear();
 
    context->device.destroyRenderPass(renderPass);
    context->device.destroyCommandPool(commandPoolBuffer);
 
  for (auto framebuffers : swapChainFramebuffers)
    for(auto framebuffer:framebuffers) {
      {
        context->device.destroyFramebuffer(framebuffer);
      }
  }
  swapChainFramebuffers.clear();
}

◆ getAttachmentView()

std::vector< vk::ImageView > VulkanRenderPass::getAttachmentView	(	int	swapIndex,
		int	view
	)

Return the vk::ImageView for the framebuffer at swapIndex for the specified view

Definition at line 848 of file VulkanRenderPass.cpp.

{
    int i = wrapper->multiviewSetup ? view : swapIndex;
    std::vector<vk::ImageView> result = { attachementColor[i].imageView,
                                attachementDepthFloat[i].imageView,
                                attachementQualityFloat[i].imageView,
                                attachementAccuColor[i].imageView,
                                attachementAccuQuality[i].imageView};
 
    
    if (wrapper->isDepthOutputRecquired()) {
        result.push_back(attachementAccuDepth[i].imageView);
    }
 
    result.push_back(attachementAccuColor2[i].imageView);
    result.push_back(attachementAccuQuality2[i].imageView);
 
    if (wrapper->isDepthOutputRecquired()) {
        result.push_back(attachementAccuDepth2[i].imageView);
    }
 
    if (context->isIndepFromWindowDimension() || !wrapper->isDepthOutputRecquired()) {
        result.push_back(depthImages[i].imageView);
    }
 
    return result;
}

◆ getImageToBlit()

vk::Image VulkanRenderPass::getImageToBlit ( int imageIndex )

overridevirtual

Return the image that should be the source for the blit operation

Implements VulkanRenderPassAbstract.

Definition at line 876 of file VulkanRenderPass.cpp.

                                                       {
  if (inputImage % 2 == 1) {
    //copy attachment 6
    return attachementAccuColor2[imageIndex].image;
  } else {
    return attachementAccuColor[imageIndex].image;
  }
}

◆ getSupportedDepthFormats()

std::vector< vk::Format > VulkanRenderPass::getSupportedDepthFormats ( ) const

overridevirtual

Return the depth format supported by the application

Implements VulkanRenderPassAbstract.

Definition at line 53 of file VulkanRenderPass.cpp.

                                                                     {
  return {vk::Format::eD16Unorm, vk::Format::eD32Sfloat, vk::Format::eD24UnormS8Uint};
}

◆ init()

void VulkanRenderPass::init ( InputProvider * inputProvider )

overridevirtual

Init process

Reimplemented from VulkanRenderPassAbstract.

Definition at line 57 of file VulkanRenderPass.cpp.

                                                        {
 
  VulkanRenderPassAbstract::init(inputProvider);
 
  resetViewPortAndScissor = wrapper->isUsingDifferentViewSize();
 
 
    for (int i = 0; i < inputImage; i++) {
        warpingPipelines.push_back(std::make_unique<VulkanPipelineWarping>(context, this, input, wrapper, i));
        blendingPipelines.push_back(std::make_unique<VulkanPipelineBlending>(context, this, wrapper, i));
    }
 
    renderingExtent = wrapper->getRenderOutputExtent();
    PRINT("Rendering Size w= %d, h = %d", renderingExtent.width, renderingExtent.height);
 
    
    createAttachementsRessources();
    createDepthResources();
    createRenderPass();
  createFramebuffers();
 
    //resetViewPortAndScissor = wrapper->isUsingDifferentViewSize();
 
    //https://www.saschawillems.de/blog/2019/03/29/flipping-the-vulkan-viewport/
    viewport = vk::Viewport{
        0.0f, //x
        (float)renderingExtent.height,  //y
        (float)renderingExtent.width,   //width
        (float)-1 * renderingExtent.height, //height
        0.0f,   //mindepth
        1.0f }; //maxdepth
 
    scissor = vk::Rect2D{ {0,0} , renderingExtent };
 
    for (int i = 0; i < inputImage; i++) {
        D(std::cout << "Create pipeline: " << i <<std::endl;)
        warpingPipelines[i]->init();
        blendingPipelines[i]->init();
    }
 
 
    initialized = true;
 
    
}

◆ isInitialized()

bool VulkanRenderPass::isInitialized ( )

overridevirtual

Return true if the ressources were initialized for this renderpass

Reimplemented from VulkanRenderPassAbstract.

Definition at line 844 of file VulkanRenderPass.cpp.

                                     {
    return initialized;
}

◆ recordCommandBuffer()

void VulkanRenderPass::recordCommandBuffer	(	vk::CommandBuffer &	commandBuffer,
		int	i,
		std::span< InputProvider::StreamFrameInfo >	frameInfos,
		int	view
	)

overridevirtual

Record the command buffer

D(std::cout << "\n record Command Buffer : " << i << std::endl;)

Reimplemented from VulkanRenderPassAbstract.

Definition at line 221 of file VulkanRenderPass.cpp.

{
  vk::ClearColorValue clearColor(std::array<float, 4>({ {0.0f, 0.0f, 0.0f, 1.0f} }));
  /*
  if (g_color_space == ColorSpace::YUV) {
    //better black than green
    vk::ClearColorValue clearColor(std::array<float, 4>({ {0.0f, 0.5f, 0.5f, 1.0f} }));
  }*/
 
 
  std::vector<vk::ClearValue> clearValues;
  if (!wrapper->isDepthOutputRecquired()) {
    clearValues.resize(9);
    clearValues[0].color = clearColor;
    clearValues[1].color = clearColor;
    clearValues[2].color = clearColor;
    clearValues[3].color = clearColor;
    clearValues[4].color = clearColor;
    clearValues[5].color = clearColor;
    clearValues[6].color = clearColor;
    clearValues[7].depthStencil = vk::ClearDepthStencilValue{ 1.0f, 0 }; //{ 1.0f, 0};
    clearValues[8].color = clearColor;
  }
  else {
    clearValues.resize(11);
    clearValues[0].color = clearColor;
    clearValues[1].color = clearColor;
    clearValues[2].color = clearColor;
    clearValues[3].color = clearColor;
    clearValues[4].color = clearColor;
    clearValues[5].color = clearColor;
    clearValues[6].color = clearColor;
    clearValues[7].color = clearColor;
    clearValues[8].color = clearColor;
    clearValues[9].depthStencil = vk::ClearDepthStencilValue{ 1.0f, 0 }; //{ 1.0f, 0};
    clearValues[10].color = clearColor;
  }
 
  auto extend = wrapper->multiviewSetup ? wrapper->getSwapchainExtend(view) : renderingExtent;
 
  vk::RenderPassBeginInfo renderPassBeginInfo(
    renderPass,                                            //renderpass
    swapChainFramebuffers[view][i],                                        //framebuffer
    vk::Rect2D(vk::Offset2D(0, 0),
      extend),//presentation->swapChainExtent), //offset + extent
    static_cast<uint32_t>(clearValues.size()),
    clearValues.data()
  );
 
  if (resetViewPortAndScissor) {
 
    renderPassBeginInfo.renderArea = vk::Rect2D(vk::Offset2D(0, 0),
      wrapper->getSwapchainExtend(view));
  }
 
  commandBuffer.beginRenderPass(renderPassBeginInfo, vk::SubpassContents::eInline);
 
 
    if (wrapper->multiviewSetup) {
        auto ext = wrapper->getSwapchainExtend(view);
        viewport = vk::Viewport{
        0.0f, //x
        (float)ext.height,  //y
        (float)ext.width,   //width
        (float)-1 * ext.height, //height
        0.0f,   //mindepth
        1.0f }; //maxdepth
        scissor = vk::Rect2D{ {0, 0}, ext };
        commandBuffer.setViewport(0, {viewport});
        commandBuffer.setScissor(0, {scissor});
    }
    for (int input = 0; input < inputImage; input++) {
        //D(std::cout << "\n record Command Buffer for input : " << input << std::endl;)
        if (input > 0) {
            //no need to clean the first time
            vk::ClearColorValue clearColor(std::array<float, 4>({ {0.0f, 0.0f, 0.0f, 1.0f} }));
            /*
            if (g_color_space == ColorSpace::YUV) {
                //better black than green
                vk::ClearColorValue clearColor(std::array<float, 4>({ {0.0f, 0.5f, 0.5f, 1.0f} }));
            }*/
            vk::ClearAttachment clear0(vk::ImageAspectFlagBits::eColor, 0, vk::ClearValue(clearColor));
            vk::ClearAttachment clear1(vk::ImageAspectFlagBits::eColor, 1, vk::ClearValue(clearColor));
            vk::ClearAttachment clear2(vk::ImageAspectFlagBits::eColor, 2, vk::ClearValue(clearColor));
            vk::ClearAttachment clear3(vk::ImageAspectFlagBits::eDepth, 0, vk::ClearValue(vk::ClearDepthStencilValue{ 1.0f,0 }));
            /*
            if (input == inputImage - 1) {
                clear3 = vk::ClearAttachment(vk::ImageAspectFlagBits::eDepth, 0, vk::ClearValue(vk::ClearDepthStencilValue{ 0.0f,0 }));
            }*/
            std::array<vk::ClearAttachment, 4> clearAttachments = { clear0,clear1,clear2, clear3};
            vk::ClearRect rect0 = vk::ClearRect(scissor, 0, 1);
            vk::ClearRect rect1 = vk::ClearRect(scissor, 0, 1);
            vk::ClearRect rect2 = vk::ClearRect(scissor, 0, 1);
            std::array<vk::ClearRect, 3> clearRects = { rect0,rect1,rect2};
            commandBuffer.clearAttachments(clearAttachments, clearRects);
        }
        commandBuffer.bindPipeline(vk::PipelineBindPoint::eGraphics, warpingPipelines[input]->pipeline);
        warpingPipelines[input]->cmdBufferBindBuffer(commandBuffer, i, frameInfos[input], view);
        commandBuffer.drawIndexed(warpingPipelines[input]->getIndexNumber(), 1, 0, 0, 0);
 
        //next subPass
        commandBuffer.nextSubpass(vk::SubpassContents::eInline);
        //D(std::cout << "\n next subpass (input: " << input << ")" << std::endl;)
 
        
        if (wrapper->isDepthOutputRecquired() && input == inputImage - 1) {
            //farplane is value 0
            vk::ClearAttachment clearD(vk::ImageAspectFlagBits::eDepth, 0, vk::ClearValue(vk::ClearDepthStencilValue{ 0.0f,0 }));
            std::array<vk::ClearAttachment, 1> clearAttachments = { clearD };
            vk::ClearRect rect0 = vk::ClearRect(scissor , 0, 1);
            std::array<vk::ClearRect, 1> clearRect = { rect0 };
            commandBuffer.clearAttachments(clearAttachments, clearRect);
        }
 
        commandBuffer.bindPipeline(vk::PipelineBindPoint::eGraphics, blendingPipelines[input]->pipeline);
        blendingPipelines[input]->cmdBufferBindBuffer(commandBuffer, i, frameInfos[input], view);
        commandBuffer.drawIndexed(blendingPipelines[input]->getIndexNumber(), 1, 0, 0, 0);
 
        
 
        if(input != inputImage - 1){
            //next subPass
            commandBuffer.nextSubpass(vk::SubpassContents::eInline);
        }
    }
 
  commandBuffer.endRenderPass();
}

◆ updateBuffer()

void VulkanRenderPass::updateBuffer	(	uint32_t	currentImage,
		bool	initAll,
		std::span< InputProvider::StreamFrameInfo >	infos,
		int	view
	)

overridevirtual

Update buffer

Reimplemented from VulkanRenderPassAbstract.

Definition at line 202 of file VulkanRenderPass.cpp.

{
    if (initAll) {
        for (int i = 0; i < inputImage; i++) {
            warpingPipelines[i]->update(infos,view);
            warpingPipelines[i]->updateAllBuffer(currentImage,view);
            blendingPipelines[i]->updateAllBuffer(currentImage, view);
            
        }
    }
    else {
        for (int i = 0; i < inputImage; i++) {
            warpingPipelines[i]->update(infos, view);
            warpingPipelines[i]->updateBuffer(currentImage, view);
            blendingPipelines[i]->updateBuffer(currentImage, view);
        }
    }
}

Field Documentation

◆ attachementAccuColor

std::vector<ImageStruct> VulkanRenderPass::attachementAccuColor

Color attachments (for blending)

Definition at line 84 of file VulkanRenderPass.h.

◆ attachementAccuColor2

std::vector<ImageStruct> VulkanRenderPass::attachementAccuColor2

Color attachments 2 (for blending)

Definition at line 90 of file VulkanRenderPass.h.

◆ attachementAccuDepth

std::vector<ImageStruct> VulkanRenderPass::attachementAccuDepth

Depth attachment (for blending)

Definition at line 88 of file VulkanRenderPass.h.

◆ attachementAccuDepth2

std::vector<ImageStruct> VulkanRenderPass::attachementAccuDepth2

Depth attachments 2 (for blending)

Definition at line 94 of file VulkanRenderPass.h.

◆ attachementAccuQuality

std::vector<ImageStruct> VulkanRenderPass::attachementAccuQuality

Quality attachments (for blending)

Definition at line 86 of file VulkanRenderPass.h.

◆ attachementAccuQuality2

std::vector<ImageStruct> VulkanRenderPass::attachementAccuQuality2

Quality attachments 2 (for blending)

Definition at line 92 of file VulkanRenderPass.h.

◆ attachementColor

std::vector<ImageStruct> VulkanRenderPass::attachementColor

Color attachments (warping output)

Definition at line 74 of file VulkanRenderPass.h.

◆ attachementDepthFloat

std::vector<ImageStruct> VulkanRenderPass::attachementDepthFloat

depth datas (warping output)

Definition at line 76 of file VulkanRenderPass.h.

◆ attachementQualityFloat

std::vector<ImageStruct> VulkanRenderPass::attachementQualityFloat

quality attachments (warping output)

Definition at line 78 of file VulkanRenderPass.h.

◆ blendingPipelines

std::vector<std::unique_ptr<VulkanPipelineBlending> > VulkanRenderPass::blendingPipelines

Blending pipeline

Definition at line 66 of file VulkanRenderPass.h.

◆ renderPass

vk::RenderPass VulkanRenderPass::renderPass

vk::renderpass object

Definition at line 69 of file VulkanRenderPass.h.

◆ swapChainFramebuffers

std::vector<std::vector<vk::Framebuffer> > VulkanRenderPass::swapChainFramebuffers

Framebuffers for the differents swapchain. There is one vector of Framebuffer by view

Definition at line 97 of file VulkanRenderPass.h.

◆ warpingPipelines

std::vector<std::unique_ptr<VulkanPipelineWarping> > VulkanRenderPass::warpingPipelines

Warping pipeline

Definition at line 64 of file VulkanRenderPass.h.

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

Public Member Functions

Data Fields

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ VulkanRenderPass()

Member Function Documentation

◆ cleanUp()

◆ getAttachmentView()

◆ getImageToBlit()

◆ getSupportedDepthFormats()

◆ init()

◆ isInitialized()

◆ recordCommandBuffer()

◆ updateBuffer()

Field Documentation

◆ attachementAccuColor

◆ attachementAccuColor2

◆ attachementAccuDepth

◆ attachementAccuDepth2

◆ attachementAccuQuality

◆ attachementAccuQuality2

◆ attachementColor

◆ attachementDepthFloat

◆ attachementQualityFloat

◆ blendingPipelines

◆ renderPass

◆ swapChainFramebuffers

◆ warpingPipelines