BuffersControllerWarping Class Reference

Control the data to be transmitted to the warping pipeline. More...

#include <BuffersControllerWarping.h>

Inheritance diagram for BuffersControllerWarping:

Public Member Functions
	BuffersControllerWarping (VulkanContext *context, VulkanRenderPass *renderpass, VulkanPipelineWarping *pipeline, InputProvider *input, VulkanWrapper *wraps, int inputView)
void	init () override
void	cleanUp () override
void	bindBuffers (vk::CommandBuffer &commandBuffer, int index, InputProvider::StreamFrameInfo &frameInfos, int view) override
void	updateUniformBuffer (uint32_t currentImage, int view) override
void	updateAllUniformBuffer (uint32_t currentImage, int view) override
vk::VertexInputBindingDescription	getBindingDescription () override
std::vector< vk::VertexInputAttributeDescription >	getAttributeDescription () override
uint32_t	getIndiceCount () override
void	update (std::span< InputProvider::StreamFrameInfo > infos, int view) override
virtual void	init ()=0
virtual void	cleanUp ()=0
virtual void	bindBuffers (vk::CommandBuffer &commandBuffer, int index, InputProvider::StreamFrameInfo &frameInfos, int view)=0
virtual void	updateAllUniformBuffer (uint32_t currentImage, int view)=0
virtual void	updateUniformBuffer (uint32_t currentImage, int view)=0
virtual void	update (std::span< InputProvider::StreamFrameInfo > infos, int inputView)=0
virtual vk::VertexInputBindingDescription	getBindingDescription ()=0
virtual std::vector< vk::VertexInputAttributeDescription >	getAttributeDescription ()=0
virtual uint32_t	getIndiceCount ()=0

Static Public Member Functions
static void	updateSettings (const InputProvider::StreamFrameInfo &infos, int view, const InputProvider::StreamParameters &streamParams, VulkanWrapper *wrapper, RVScamExtrinsics &extrinsics, RvsSynParam &params)

Static Public Attributes
static std::vector< uint32_t >	indices

Additional Inherited Members
Protected Member Functions inherited from BuffersController
virtual void	createVertexBuffer ()=0
virtual void	createIndexBuffer ()=0
virtual void	createUniformBuffer (int size)=0
virtual void	createDescriptorPool ()=0
virtual void	createDescriptorSets ()=0
void	copyBuffer (vk::Buffer srcBuffer, vk::Buffer dstBuffer, vk::DeviceSize size)
Protected Attributes inherited from BuffersController
int	inputView = 0
VulkanContext *	context = nullptr
VulkanRenderPass *	renderpass = nullptr

Detailed Description

Control the data to be transmitted to the warping pipeline.

Class that manages ressources for the warping pipeline. From vertex+indices buffers to samplers and uniforms buffers. It is also in charge of the descriptor set.

Definition at line 145 of file BuffersControllerWarping.h.

Constructor & Destructor Documentation

BuffersControllerWarping()

BuffersControllerWarping::BuffersControllerWarping	(	VulkanContext *	context,
		VulkanRenderPass *	renderpass,
		VulkanPipelineWarping *	pipeline,
		InputProvider *	input,
		VulkanWrapper *	wraps,
		int	inputView
	)

Constructor

Definition at line 34 of file BuffersControllerWarping.cpp.

{
    this->context = context;
    this->pipeline = pipeline;
    this->inputView = inputView;
    this->wrapper = wraps;
    this->renderpass = renderpass;
    this->input = inputP;
 
    this->idStep = inputView;
    auto activation = wrapper->getCameraActivation();
    for (int i = 0; i <= inputView; i++) {
        if (!activation[i]) {
            this->inputView++;
            inputView++;
        }
    }
 
    streamParams = input->enumerateStreamsParameters()[inputView];
    
    textureStreamImages = input->enumerateStreamImages(inputView, false);
    depthStreamImages = input->enumerateStreamImages(inputView, true);
    attachmentSize = wrapper->multiviewSetup ? wrapper->getViewNumber() : wrapper->getAttachmentSize();
 
    assert(textureStreamImages.size() == depthStreamImages.size());
 
    memset(&rvsSynParam, 0, sizeof(rvsSynParam));
    memset(&rvsSynGeom, 0, sizeof(rvsSynGeom));
    memset(&rvsSynFrag, 0, sizeof(rvsSynFrag));
 
    if (streamParams.depthFormat == vk::Format::eR32Sfloat) {
        rvsSynParam.lin_depth = 1; //do like exr format
    }
    else {
        rvsSynParam.lin_depth = 0;
    }
}

Member Function Documentation

bindBuffers()

void BuffersControllerWarping::bindBuffers ( vk::CommandBuffer &  commandBuffer, int  index, InputProvider::StreamFrameInfo &  frameInfos, int  view  )

overridevirtual

Bind buffers

Implements BuffersController.

Definition at line 343 of file BuffersControllerWarping.cpp.

{
    int index = wrapper->multiviewSetup ? view : currentSwapIndex;
    vk::Buffer vertexBuffers[] = { vertexBuffer };
    vk::DeviceSize offsets[] = { 0 };
    commandBuffer.bindVertexBuffers( 0, 1, vertexBuffers, offsets);
    commandBuffer.bindIndexBuffer(indexBuffer, 0, vk::IndexType::eUint32);
 
    auto idDescriptorSet = index + frameInfos.imageIndex * attachmentSize;
    commandBuffer.bindDescriptorSets(vk::PipelineBindPoint::eGraphics, pipeline->pipelineLayout, 0, 1, &descriptorSets[idDescriptorSet], 0, nullptr);
}

cleanUp()

void BuffersControllerWarping::cleanUp ( )

overridevirtual

Clean up ressources for the warping pipeline

Implements BuffersController.

Definition at line 295 of file BuffersControllerWarping.cpp.

{
 
    if (idStep == 0) {
        context->device.destroyBuffer(vertexBuffer);
        context->device.freeMemory(vertexBufferMemory, nullptr);
 
        context->device.destroyBuffer(indexBuffer);
        context->device.freeMemory(indexBufferMemory, nullptr);
    }
 
    for (size_t i = 0; i < uniformBuffersFrag.size(); i++) {
        context->device.destroyBuffer(uniformBuffersFrag[i], nullptr);
        context->device.freeMemory(uniformBuffersFragMemory[i], nullptr);
    }
 
    for (size_t i = 0; i < uniformBuffersGeom.size(); i++) {
        context->device.destroyBuffer(uniformBuffersGeom[i], nullptr);
        context->device.freeMemory(uniformBuffersGeomMemory[i], nullptr);
    }
 
    for (size_t i = 0; i < uniformBuffers.size(); i++) {
        context->device.destroyBuffer(uniformBuffers[i], nullptr);
        context->device.freeMemory(uniformBuffersMemory[i], nullptr);
    }
 
    for (size_t i = 0; i < uniformBuffersCam.size(); i++) {
        context->device.destroyBuffer(uniformBuffersCam[i], nullptr);
        context->device.freeMemory(uniformBuffersCamMemory[i], nullptr);
    }
 
    uniformBuffers.clear();
    uniformBuffersMemory.clear();
 
    uniformBuffersCam.clear();
    uniformBuffersCamMemory.clear();
 
    uniformBuffersGeom.clear();
    uniformBuffersGeomMemory.clear();
 
    uniformBuffersFrag.clear();
    uniformBuffersFragMemory.clear();
 
    context->device.destroyDescriptorPool(descriptorPool);
}

getAttributeDescription()

std::vector< vk::VertexInputAttributeDescription > BuffersControllerWarping::getAttributeDescription ( )

overridevirtual

Return the vk::VertexInputAttributeDescription of the warping pipeline

Implements BuffersController.

Definition at line 411 of file BuffersControllerWarping.cpp.

{
    std::vector<vk::VertexInputAttributeDescription> attributeDescriptions{
    vk::VertexInputAttributeDescription(
        0,  //location
        0,  //binding
        vk::Format::eR32Sfloat,     //format
        0   //offset
    )};
    return attributeDescriptions;
}

getBindingDescription()

vk::VertexInputBindingDescription BuffersControllerWarping::getBindingDescription ( )

overridevirtual

Return the vk::VertexInputBindingDescription of the warping pipeline

Implements BuffersController.

Definition at line 401 of file BuffersControllerWarping.cpp.

{
    vk::VertexInputBindingDescription bindingDescription{
            0,  //binding
            sizeof(glm::vec1), // stride
            vk::VertexInputRate::eVertex //inputRate
    };
    return bindingDescription;
}

getIndiceCount()

uint32_t BuffersControllerWarping::getIndiceCount ( )

overridevirtual

Return the number of indices that need to be draw

Implements BuffersController.

Definition at line 423 of file BuffersControllerWarping.cpp.

{
    return indiceCount;
}

init()

void BuffersControllerWarping::init ( )

overridevirtual

Init the required ressources for the warping pipeline

Implements BuffersController.

Definition at line 72 of file BuffersControllerWarping.cpp.

{
    if(idStep == 0){
        createVertexBuffer();
        createIndexBuffer();
    }
    createUniformBuffer(attachmentSize);
    createDescriptorPool();
    createDescriptorSets();
}

update()

void BuffersControllerWarping::update ( std::span< InputProvider::StreamFrameInfo >  infos, int  view  )

overridevirtual

Update the content of the structs with the informations givent by the input provider

Implements BuffersController.

Definition at line 549 of file BuffersControllerWarping.cpp.

                                                                                           {
 
    auto frameInfo = infos[inputView];
 
  // Do common update
  updateSettings(frameInfo, view, streamParams, wrapper, rvsCamExtrinsics, rvsSynParam);
 
 
  // Patch remaining structs
  rvsSynGeom.w = streamParams.depthResolution.x; //float(inputView->get_depth().cols);//float(m_space_transformer->getInputParameters().getSize().width);
  rvsSynGeom.h = streamParams.depthResolution.y;
 
  rvsSynFrag.max_depth = streamParams.farDepth;
  rvsSynFrag.pixelThresh = wrapper->params.pixelThreshold;
  rvsSynGeom.pixelThresh = wrapper->params.pixelThreshold;
  rvsSynFrag.maxMul = wrapper->params.maxMult;
 
 
    //scaleFactor
    rvsSynParam.scaleFactor = wrapper->params.scaleFactor;
    rvsSynGeom.scaleFactor = wrapper->params.scaleFactor;
    rvsSynFrag.scaleFactor = wrapper->params.scaleFactor;
 
 
    if (wrapper->getViewNumber() == 4 && view % 2 == 1 && wrapper->params.projectionType == InputProvider::ProjectionType::PROJECTION_PERSPECTIVE) {
        rvsSynGeom.pixelThresh *= std::get<InputProvider::PerspectiveIntrinsics>(wrapper->params.getVirtualIntrinsics(view - 1)).focals.x / rvsSynParam.n_f.x;
    }
 
    rvsSynFrag.maxMul = wrapper->params.maxMult;
}

updateAllUniformBuffer()

void BuffersControllerWarping::updateAllUniformBuffer ( uint32_t  currentImage, int  view  )

overridevirtual

Update the content of all buffers

Implements BuffersController.

Definition at line 368 of file BuffersControllerWarping.cpp.

{
 
    //camera extrinsics !!
    int index = wrapper->multiviewSetup ? view : currentImage;
    updateCameraBuffer(index);
 
 
    RvsSynParam ubo = rvsSynParam;//rvs::SynthesizedView::getInstance().rvsSynParam;
 
 
    void* data;
    context->device.mapMemory(uniformBuffersMemory[index], 0, sizeof(ubo), {}, &data);
    memcpy(data, &ubo, sizeof(ubo));
    context->device.unmapMemory(uniformBuffersMemory[index]);
 
    RvsSynGeom uboGeom = rvsSynGeom;//rvs::SynthesizedView::getInstance().rvsSynGeom;
    void* dataGeom;
    context->device.mapMemory(uniformBuffersGeomMemory[index], 0, sizeof(uboGeom), {}, &dataGeom);
    memcpy(dataGeom, &uboGeom, sizeof(uboGeom));
    context->device.unmapMemory(uniformBuffersGeomMemory[index]);
 
    RvsSynFrag uboFrag = rvsSynFrag;//rvs::SynthesizedView::getInstance().rvsSynFrag;
    void* dataFrag;
    context->device.mapMemory(uniformBuffersFragMemory[index], 0, sizeof(uboFrag), {}, &dataFrag);
    memcpy(dataFrag, &uboFrag, sizeof(uboFrag));
    context->device.unmapMemory(uniformBuffersFragMemory[index]);
 
}

updateSettings()

void BuffersControllerWarping::updateSettings ( const InputProvider::StreamFrameInfo &  infos, int  view, const InputProvider::StreamParameters &  streamParams, VulkanWrapper *  wrapper, RVScamExtrinsics &  extrinsics, RvsSynParam &  params  )

static

Update the requested structrures with the provided information

Definition at line 452 of file BuffersControllerWarping.cpp.

                              {
  //translation to glm ?
  //Input coordinate are in OMAF system
  //in OMAF rotation vector is rotation against z axis, y axis, and x axis
  auto R_from = glmEulerAnglesDegreeToRotationMatrix(frameInfo.extrinsics.rotation);
  //------------ Virtual camera parameter may not be in OMAF but can be converted to it using the conversion at wrapper->params.conversionToOMAF
  // (in general it would be openxr coordinate system)
  // and the rotation is defined as rotation against x axis, y axis, z axis
  auto R_start = glmEulerAnglesDegreeToRotationMatrixNotOMAF(wrapper->params.getStartingRotation());
  auto R_to = glmEulerAnglesDegreeToRotationMatrixNotOMAF(wrapper->params.getVirtualExtrinsics(view).rotation);
  R_to = (R_start * R_to *  glm::transpose(R_start)) * R_start ;
  R_to = wrapper->params.conversionToOMAF * R_to * glm::transpose(wrapper->params.conversionToOMAF);
 
  auto R = glm::transpose(R_to) * R_from;
 
  rvsCamExtrinsics.R = glm::mat4(R);
 
  auto t_from = frameInfo.extrinsics.position;
  auto t_start = wrapper->params.getStartingPosition();
  auto t_to = wrapper->params.getVirtualExtrinsics(view).position;
  t_to = t_start + R_start * t_to;// *glm::transpose(R_start); // 
 
  t_to = wrapper->params.conversionToOMAF * t_to;
  auto T = -glm::transpose(R_to) * (t_to - t_from);
 
  rvsCamExtrinsics.t = glm::vec4(T,1);
 
  // 
  rvsSynParam.w = streamParams.depthResolution.x; //float(inputView->get_depth().cols);//float(m_space_transformer->getInputParameters().getSize().width);
  //rvsSynGeom.w = streamParams.depthResolution.x; //float(inputView->get_depth().cols);//float(m_space_transformer->getInputParameters().getSize().width);
  rvsSynParam.h = streamParams.depthResolution.y; //float(inputView->get_depth().rows);//float(m_space_transformer->getInputParameters().getSize().height);
  //rvsSynGeom.h = streamParams.depthResolution.y;
  rvsSynParam.n_h = wrapper->params.virtualViewDef[view].y;
  rvsSynParam.n_w = wrapper->params.virtualViewDef[view].x;
 
  switch (streamParams.projectionType) {
  case InputProvider::ProjectionType::PROJECTION_PERSPECTIVE: {
    rvsSynParam.erp_in = false;
    rvsSynParam.f = std::get<InputProvider::PerspectiveIntrinsics>(frameInfo.intrinsics).focals / (float(streamParams.colorResolution.x)/ streamParams.depthResolution.x);
    rvsSynParam.p = std::get<InputProvider::PerspectiveIntrinsics>(frameInfo.intrinsics).principle / (float(streamParams.colorResolution.x) / streamParams.depthResolution.x);
    break;
  }
 
  case InputProvider::ProjectionType::PROJECTION_EQUIRECTANGULAR: {
    rvsSynParam.erp_in = true;
    auto hor_range = std::get<InputProvider::EquirectangularIntrinsics>(frameInfo.intrinsics).horizontalRange;
    auto ver_range = std::get<InputProvider::EquirectangularIntrinsics>(frameInfo.intrinsics).verticalRange;
    auto constexpr radperdeg = 0.01745329252f;
    rvsSynParam.phi0 = radperdeg * hor_range[1];
    rvsSynParam.theta0 = radperdeg * ver_range[1];
    rvsSynParam.dphi_du = -radperdeg * (hor_range[1] - hor_range[0]) / rvsSynParam.w;
    rvsSynParam.dtheta_dv = -radperdeg * (ver_range[1] - ver_range[0]) / rvsSynParam.h;
    break;
  }
  default:
    throw std::runtime_error("Unsupported projection type for input");
    break;
  }
 
 
  //for virtual camera
  switch (wrapper->params.projectionType) {
  case InputProvider::ProjectionType::PROJECTION_PERSPECTIVE: {
    rvsSynParam.erp_out = false;
    rvsSynParam.n_p = std::get<InputProvider::PerspectiveIntrinsics>(wrapper->params.getVirtualIntrinsics(view)).principle;
    rvsSynParam.n_f = std::get<InputProvider::PerspectiveIntrinsics>(wrapper->params.getVirtualIntrinsics(view)).focals;
    break;
  }
  case InputProvider::ProjectionType::PROJECTION_EQUIRECTANGULAR: {
    rvsSynParam.erp_out = true;
    auto ver_range = std::get < InputProvider::EquirectangularIntrinsics>(wrapper->params.getVirtualIntrinsics(view)).verticalRange;
    auto hor_range = std::get < InputProvider::EquirectangularIntrinsics>(wrapper->params.getVirtualIntrinsics(view)).horizontalRange;
    auto constexpr degperrad = 57.295779513f;
    rvsSynParam.u0 = (hor_range[0] + hor_range[1]) / (hor_range[1] - hor_range[0]);
    rvsSynParam.v0 = -(ver_range[0] + ver_range[1]) / (ver_range[1] - ver_range[0]);
    rvsSynParam.du_dphi = -2.f * degperrad / (hor_range[1] - hor_range[0]);
    rvsSynParam.dv_dtheta = +2.f * degperrad / (ver_range[1] - ver_range[0]);
    break;
  }
  default: {
    throw std::runtime_error("Unsupported projection type for input");
    break; }
  }
  //rvsSynFrag.max_depth = streamParams.farDepth;
  //rvsSynFrag.pixelThresh = wrapper->params.pixelThreshold;
  rvsSynParam.min_depth = streamParams.nearDepth;
  rvsSynParam.max_depth = streamParams.farDepth;
  //rvsSynGeom.pixelThresh = wrapper->params.pixelThreshold;
  //rvsSynFrag.maxMul = wrapper->params.maxMult;
}

updateUniformBuffer()

void BuffersControllerWarping::updateUniformBuffer ( uint32_t  currentImage, int  view  )

overridevirtual

Update the content of the buffers that were changed

Implements BuffersController.

Definition at line 363 of file BuffersControllerWarping.cpp.

{
    int index = wrapper->multiviewSetup ? view : currentImage;
    updateCameraBuffer(currentImage);
};

Field Documentation

indices

std::vector<uint32_t> BuffersControllerWarping::indices

inlinestatic

list of the indices

Definition at line 167 of file BuffersControllerWarping.h.

---

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

• BuffersControllerWarping.h
• BuffersControllerWarping.cpp