VulkanDrawing Class Reference

The class that manages the drawing operation (manage and record command buffers). More...

#include <VulkanDrawing.h>

Public Member Functions
	VulkanDrawing (VulkanContext *context, VulkanRenderPassAbstract *renderPass, WindowAbstract *window, VulkanWrapper *wraps)
void	init (InputProvider *inputProvider)
void	cleanup ()
bool	isInitialized ()
vk::Fence	submitDrawCall (std::tuple< int, uint32_t > idImage, const std::vector< vk::Semaphore > &imageAvailableSemaphores, std::vector< vk::Semaphore > &signalSemaphore, uint32_t depthIndex=UINT_MAX)

Detailed Description

The class that manages the drawing operation (manage and record command buffers).

The class that manages the drawing operation. It manage, record command buffers and submit command buffer. Command buffer are reset each new frame for each view. It may add some additional operation after a renderpass to copy images if needed.

Definition at line 46 of file VulkanDrawing.h.

Constructor & Destructor Documentation

VulkanDrawing()

VulkanDrawing::VulkanDrawing	(	VulkanContext *	context,
		VulkanRenderPassAbstract *	renderPass,
		WindowAbstract *	window,
		VulkanWrapper *	wraps
	)

COnstructor

Definition at line 34 of file VulkanDrawing.cpp.

{
    this->context = context;
    this->renderPass = renderPass;
    this->window = window;
    this->wrapper = wraps;
    
}

Member Function Documentation

cleanup()

void VulkanDrawing::cleanup

(

)

Clean up ressources

Definition at line 60 of file VulkanDrawing.cpp.

                            {
    for (int view = 0; view < viewNumber; view++) {
        
        /*if (window->useOpenXR()) {
            for (size_t i = 0; i < window->getViewNumber(); i++) {
                //context->device.destroySemaphore(renderFinishedSemaphores[view][i]);
                context->device.destroyFence(inFlightFences[view][i]);
            }
        }
        else {*/ 
            for (size_t i = 0; i < MAX_FRAMES_IN_FLIGHT; i++) {
                if (i < wrapper->getAttachmentSize()) {
                    //context->device.destroySemaphore(renderFinishedSemaphores[view][i]);
                    //context->device.destroySemaphore(imageAvailableSemaphores[view][i]);
                    context->device.destroyFence(inFlightFences[view][i]);
                }
            }
        //}
    }
    //renderFinishedSemaphores.clear();
    //execFences.clear();
    //imageAvailableSemaphores.clear();
    inFlightFences.clear();
    imagesInFlight.clear();
 
 
    
 
    context->device.destroyCommandPool(commandPool); //will automaticly destroy command buffers
    commandBuffers.clear();
}

init()

void VulkanDrawing::init

(

InputProvider *

inputProvider

)

Init the needed ressources

Definition at line 43 of file VulkanDrawing.cpp.

{
    this->inputProvider = inputProvider;
    viewNumber = window->getViewNumber(); //get the nb of sawpchain
    for(int i = 0 ; i < viewNumber; i++){
        currentFrame.push_back(0);
    }
 
  createCommandPool();
    createCommandBuffers();
    createSyncObjects();
    initialized = true;
 
 
    //streamFrameInfos.resize(inputProvider->enumerateStreamsParameters().size());
}

isInitialized()

bool VulkanDrawing::isInitialized

(

)

Return true if ressources were allocated and need to be cleaned up

Definition at line 473 of file VulkanDrawing.cpp.

                                  {
    return initialized;
}

submitDrawCall()

vk::Fence VulkanDrawing::submitDrawCall	(	std::tuple< int, uint32_t >	idImage,
		const std::vector< vk::Semaphore > &	imageAvailableSemaphores,
		std::vector< vk::Semaphore > &	signalSemaphore,
		uint32_t	depthIndex = UINT_MAX
	)

Function that is called each frame by the window to render a new frame. Synchronization can be done with semaphore or fence

Definition at line 94 of file VulkanDrawing.cpp.

                                                                                                                                                                                              {
    
    int view;
    uint32_t imageIndex;
    std::tie(view, imageIndex) = idImage;
    currentFrame[view] = imageIndex;
 
    D(if (wrapper->isDepthOutputRecquired()) { assert(imageIndex == depthIndex); })
 
    context->device.waitForFences(1, &inFlightFences[view][currentFrame[view]], true, UINT64_MAX);
 
 
 
    auto streamFrameInfos = wrapper->getFramesInfo(view);
 
    renderPass->updateBuffer(imageIndex, true, streamFrameInfos,view);
 
    //if (resetCommandBuffer) {
        commandBuffers[view][imageIndex].reset(vk::CommandBufferResetFlagBits::eReleaseResources);
        recordCommandBuffers(commandBuffers[view][imageIndex], view, imageIndex, streamFrameInfos);
    //}
 
    if (imagesInFlight[view][imageIndex].has_value()) {
        context->device.waitForFences(1, &imagesInFlight[view][imageIndex].value(), true, UINT64_MAX);
    }
 
    imagesInFlight[view][imageIndex] = inFlightFences[view][currentFrame[view]];
 
 
    vk::PipelineStageFlags waitDestinationStageMask(vk::PipelineStageFlagBits::eColorAttachmentOutput);
    context->device.resetFences(1, &inFlightFences[view][currentFrame[view]]);
    if (window->isSwapChainNeeded() ) {
        uint32_t semSize = imageAvailableSemaphores.size();
        vk::SubmitInfo         submitInfo(
            semSize,
            semSize > 0 ? imageAvailableSemaphores.data() : nullptr,//&imageAvailableSemaphores[view][currentFrame[view]],
            semSize > 0 ? &waitDestinationStageMask : nullptr,
            1,
            &commandBuffers[view][imageIndex],
            static_cast<uint32_t>(signalSemaphore.size()),
            signalSemaphore.size() == 0 ? nullptr : signalSemaphore.data()//&renderFinishedSemaphores[view][currentFrame[view]]
        );
        context->graphicsQueue.submit(submitInfo, inFlightFences[view][currentFrame[view]]);
     }
    else {
        vk::SubmitInfo         submitInfo(
            0,
            {},
            nullptr,
            1,
            &commandBuffers[view][imageIndex],
            0,
            nullptr
        );
        context->graphicsQueue.submit(submitInfo, inFlightFences[view][currentFrame[view]]);
 
        const uint32_t timeoutNs = 1 * 1000 * 1000 * 1000;
        for (int i = 0; i < 5; ++i) {
            auto res = context->device.waitForFences(1, &inFlightFences[view][currentFrame[view]], VK_TRUE, timeoutNs);
            if (res == vk::Result::eSuccess) {
                // Buffer can be executed multiple times...
                break;
            }
            std::cout << "Waiting for CmdBuffer fence timed out, retrying..." << std::endl;
        }
    }
    
    
    inputProvider->releaseStreamsFrames();
    /*
    std::variant<vk::Semaphore,vk::Fence> res;
    if (!window->useOpenXR()) {
        res = renderFinishedSemaphores[view][currentFrame[view]];
    }
    else {
        res = 
    }*/
    
    //currentFrame[view] = (currentFrame[view] + 1) % MAX_FRAMES_IN_FLIGHT;
    return inFlightFences[view][currentFrame[view]];
}

---

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

• VulkanDrawing.h
• VulkanDrawing.cpp