BuffersControllerWarping.cpp

/* ----------------------
* Copyright 2023 Université Libre de Bruxelles(ULB), Universidad Politécnica de Madrid(UPM), CREAL, Deutsches Zentrum für Luft - und Raumfahrt(DLR)
 
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at < http://www.apache.org/licenses/LICENSE-2.0>
 
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissionsand
* limitations under the License.
---------------------- */
 
 
#define GLM_FORCE_RADIANS
#define GLM_FORCE_DEPTH_ZERO_TO_ONE
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <chrono>
#include <iostream>
 
#include"BuffersControllerWarping.h"
#include"VulkanContext.h"
#include"VulkanPipelineWarping.h"
#include"VulkanHelperFunction.h"
#include"VulkanWrapper.h"
 
 
#include"InputProvider.h"
 
 
 
BuffersControllerWarping::BuffersControllerWarping(VulkanContext* context, VulkanRenderPass* renderpass, VulkanPipelineWarping * pipeline, InputProvider * inputP, VulkanWrapper* wraps, int inputView)
{
    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;
    }
}
 
void BuffersControllerWarping::init()
{
    if(idStep == 0){
        createVertexBuffer();
        createIndexBuffer();
    }
    createUniformBuffer(attachmentSize);
    createDescriptorPool();
    createDescriptorSets();
}
 
 
void BuffersControllerWarping::createVertexBuffer()
{
  auto res = streamParams.depthResolution;
    const int size = res.x * res.y;
 
    std::vector<uint8_t> vertices(size);
 
    vk::DeviceSize bufferSize = sizeof(uint8_t) * vertices.size();
 
    vk::Buffer stagingBuffer;
    vk::DeviceMemory stagingBufferMemory;
 
    createBuffer(bufferSize, vk::BufferUsageFlagBits::eTransferSrc, vk::MemoryPropertyFlagBits::eHostVisible | vk::MemoryPropertyFlagBits::eHostCoherent, stagingBuffer, stagingBufferMemory, context->device, context->physicalDevice);
 
    // copy the vertex and color data into that device memory
    void* data;
    context->device.mapMemory(stagingBufferMemory, 0, bufferSize, {}, &data);
    memcpy(data, vertices.data(), (size_t)bufferSize);
    context->device.unmapMemory(stagingBufferMemory);
 
    createBuffer(bufferSize, vk::BufferUsageFlagBits::eTransferDst | vk::BufferUsageFlagBits::eVertexBuffer, vk::MemoryPropertyFlagBits::eDeviceLocal , vertexBuffer, vertexBufferMemory, context->device, context->physicalDevice);
 
    copyBuffer(stagingBuffer, vertexBuffer, bufferSize);
 
    context->device.destroyBuffer(stagingBuffer, nullptr);
    context->device.freeMemory(stagingBufferMemory, nullptr);
    
}
 
void BuffersControllerWarping::createIndexBuffer()
{
  auto res = streamParams.depthResolution;
    indices = generate_picture_EBO(glm::vec2(res.x,res.y));
    indiceCount = static_cast<uint32_t>(indices.size());
    vk::DeviceSize bufferSize = sizeof(indices[0]) * indices.size();
    vk::Buffer stagingBuffer;
    vk::DeviceMemory stagingBufferMemory;
    createBuffer(bufferSize, vk::BufferUsageFlagBits::eTransferSrc, vk::MemoryPropertyFlagBits::eHostVisible | vk::MemoryPropertyFlagBits::eHostCoherent, stagingBuffer, stagingBufferMemory, context->device, context->physicalDevice);
 
    void* data;
    context->device.mapMemory(stagingBufferMemory, 0, bufferSize, {}, &data);
    memcpy(data, indices.data(), (size_t)bufferSize);
    context->device.unmapMemory(stagingBufferMemory);
 
    createBuffer(bufferSize, vk::BufferUsageFlagBits::eTransferDst | vk::BufferUsageFlagBits::eIndexBuffer, vk::MemoryPropertyFlagBits::eDeviceLocal, indexBuffer, indexBufferMemory, context->device, context->physicalDevice);
 
    copyBuffer(stagingBuffer, indexBuffer, bufferSize);
 
    context->device.destroyBuffer(stagingBuffer, nullptr);
    context->device.freeMemory(stagingBufferMemory, nullptr);
}
 
void BuffersControllerWarping::createUniformBuffer(int size)
{
    VkDeviceSize bufferSizeCam = sizeof(RVScamExtrinsics);
 
    uniformBuffersCam.resize(size);
    uniformBuffersCamMemory.resize(size);
 
    for (size_t i = 0; i < size; i++) {
        createBuffer(bufferSizeCam, vk::BufferUsageFlagBits::eUniformBuffer, vk::MemoryPropertyFlagBits::eHostVisible | vk::MemoryPropertyFlagBits::eHostCoherent, uniformBuffersCam[i], uniformBuffersCamMemory[i], context->device, context->physicalDevice);
    }
    
    VkDeviceSize bufferSize = sizeof(RvsSynParam);
 
    uniformBuffers.resize(size);
    uniformBuffersMemory.resize(size);
 
    for (size_t i = 0; i < size; i++) {
        createBuffer(bufferSize, vk::BufferUsageFlagBits::eUniformBuffer, vk::MemoryPropertyFlagBits::eHostVisible | vk::MemoryPropertyFlagBits::eHostCoherent, uniformBuffers[i], uniformBuffersMemory[i], context->device, context->physicalDevice);
    }
 
    VkDeviceSize bufferSizeGeom = sizeof(RvsSynGeom);
 
    uniformBuffersGeom.resize(size);
    uniformBuffersGeomMemory.resize(size);
 
    for (size_t i = 0; i < size; i++) {
        createBuffer(bufferSizeGeom, vk::BufferUsageFlagBits::eUniformBuffer, vk::MemoryPropertyFlagBits::eHostVisible | vk::MemoryPropertyFlagBits::eHostCoherent, uniformBuffersGeom[i], uniformBuffersGeomMemory[i], context->device, context->physicalDevice);
    }
 
    VkDeviceSize bufferSizeFrag = sizeof(RvsSynFrag);
    uniformBuffersFrag.resize(size);
    uniformBuffersFragMemory.resize(size);
 
    for (size_t i = 0; i < size; i++) {
        createBuffer(bufferSizeFrag, vk::BufferUsageFlagBits::eUniformBuffer, vk::MemoryPropertyFlagBits::eHostVisible | vk::MemoryPropertyFlagBits::eHostCoherent, uniformBuffersFrag[i], uniformBuffersFragMemory[i], context->device, context->physicalDevice);
    }
}
 
void BuffersControllerWarping::createDescriptorPool()
{
    std::array<vk::DescriptorPoolSize, 6> poolSizes{};
    poolSizes[0] = vk::DescriptorPoolSize(vk::DescriptorType::eUniformBuffer, static_cast<uint32_t> (attachmentSize));
    poolSizes[1] = vk::DescriptorPoolSize(vk::DescriptorType::eUniformBuffer, static_cast<uint32_t> (attachmentSize));
    poolSizes[2] = vk::DescriptorPoolSize(vk::DescriptorType::eUniformBuffer, static_cast<uint32_t> (attachmentSize));
    poolSizes[3] = vk::DescriptorPoolSize(vk::DescriptorType::eUniformBuffer, static_cast<uint32_t> (attachmentSize));
    poolSizes[4] = vk::DescriptorPoolSize(vk::DescriptorType::eCombinedImageSampler, static_cast<uint32_t> (textureStreamImages.size()));
    poolSizes[5] = vk::DescriptorPoolSize(vk::DescriptorType::eCombinedImageSampler, static_cast<uint32_t> (depthStreamImages.size()));
 
 
    auto slotSize = textureStreamImages.size();
 
    vk::DescriptorPoolCreateInfo poolInfo(
        vk::DescriptorPoolCreateFlags(),    //flags
        static_cast<uint32_t>((attachmentSize)*slotSize), // max sets
        static_cast<uint32_t>(poolSizes.size()),    //pool size
        poolSizes.data()        //pPoolSize
    );
 
    descriptorPool = context->device.createDescriptorPool(poolInfo);
}
 
void BuffersControllerWarping::createDescriptorSets()
{
    auto slotSize = textureStreamImages.size();
    std::vector<vk::DescriptorSetLayout> layouts(attachmentSize* slotSize, pipeline->descriptorSetLayout);
    
 
    vk::DescriptorSetAllocateInfo allocInfo(descriptorPool, static_cast<uint32_t>(attachmentSize * slotSize), layouts.data());
 
 
    descriptorSets = context->device.allocateDescriptorSets(allocInfo);
 
    for (int slot = 0; slot < slotSize; slot++) {
        for (size_t i = 0; i < attachmentSize; i++) {
 
            updateDescriptorSets(i,slot);
        }
    }
 
 
}
 
void BuffersControllerWarping::updateDescriptorSets(int attachment,int slot)
{
    vk::DescriptorBufferInfo bufferInfoCam(uniformBuffersCam[attachment], 0, sizeof(RVScamExtrinsics));
    vk::DescriptorBufferInfo bufferInfoVert(uniformBuffers[attachment], 0, sizeof(RvsSynParam));
    vk::DescriptorBufferInfo bufferInfoGeom(uniformBuffersGeom[attachment], 0, sizeof(RvsSynGeom)); 
    vk::DescriptorBufferInfo bufferInfoFrag(uniformBuffersFrag[attachment], 0, sizeof(RvsSynFrag)); 
 
    vk::DescriptorImageInfo imageInfo(streamParams.colorSampler, textureStreamImages[slot].view, vk::ImageLayout::eShaderReadOnlyOptimal);
    vk::DescriptorImageInfo depthInfo(streamParams.depthSampler, depthStreamImages[slot].view, vk::ImageLayout::eShaderReadOnlyOptimal);
 
    auto idDescriptorSet = attachment + slot * attachmentSize;
    std::array<vk::WriteDescriptorSet, 6> descriptorWrites{};
    descriptorWrites[0] = vk::WriteDescriptorSet(
        descriptorSets[idDescriptorSet],
        2, //dstBinding
        0, //dstArrayElement
        1, //descriptorCount
        vk::DescriptorType::eUniformBuffer, //descriptorType
        nullptr,        //pImageInfo
        &bufferInfoCam, // pBufferInfo
        nullptr         //pTexelBufferView
    );
    descriptorWrites[1] = vk::WriteDescriptorSet(
        descriptorSets[idDescriptorSet],
        1, //dstBinding
        0, //dstArrayElement
        1, //descriptorCount
        vk::DescriptorType::eCombinedImageSampler, //descriptorType
        &depthInfo,     //pImageInfo
        nullptr, // pBufferInfo
        nullptr         //pTexelBufferView
    );
    descriptorWrites[2] = vk::WriteDescriptorSet(
        descriptorSets[idDescriptorSet],
        3, //dstBinding
        0, //dstArrayElement
        1, //descriptorCount
        vk::DescriptorType::eUniformBuffer, //descriptorType
        nullptr,        //pImageInfo
        &bufferInfoVert, // pBufferInfo
        nullptr         //pTexelBufferView
    );
    descriptorWrites[3] = vk::WriteDescriptorSet(
        descriptorSets[idDescriptorSet],
        6, //dstBinding
        0, //dstArrayElement
        1, //descriptorCount
        vk::DescriptorType::eCombinedImageSampler, //descriptorType
        &imageInfo,     //pImageInfo
        nullptr, // pBufferInfo
        nullptr         //pTexelBufferView
    );
    descriptorWrites[4] = vk::WriteDescriptorSet(
        descriptorSets[idDescriptorSet],
        4, //dstBinding
        0, //dstArrayElement
        1, //descriptorCount
        vk::DescriptorType::eUniformBuffer, //descriptorType
        nullptr,        //pImageInfo
        &bufferInfoGeom, // pBufferInfo
        nullptr         //pTexelBufferView
    );
    descriptorWrites[5] = vk::WriteDescriptorSet(
        descriptorSets[idDescriptorSet],
        5, //dstBinding
        0, //dstArrayElement
        1, //descriptorCount
        vk::DescriptorType::eUniformBuffer, //descriptorType
        nullptr,        //pImageInfo
        &bufferInfoFrag, // pBufferInfo
        nullptr         //pTexelBufferView
    );
 
 
    context->device.updateDescriptorSets(static_cast<uint32_t>(descriptorWrites.size()), descriptorWrites.data(), 0, nullptr);
}
 
void BuffersControllerWarping::cleanUp()
{
 
    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);
}
 
 
 
void BuffersControllerWarping::bindBuffers(vk::CommandBuffer & commandBuffer, int currentSwapIndex, InputProvider::StreamFrameInfo & frameInfos, int view)
{
    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);
}
 
void BuffersControllerWarping:: updateCameraBuffer(uint32_t bufferId)
{
    RVScamExtrinsics uboCam = rvsCamExtrinsics;
    void* data;
    context->device.mapMemory(uniformBuffersCamMemory[bufferId], 0, sizeof(uboCam), {}, &data);
    memcpy(data, &uboCam, sizeof(uboCam));
    context->device.unmapMemory(uniformBuffersCamMemory[bufferId]);
}
void BuffersControllerWarping::updateUniformBuffer(uint32_t currentImage, int view)
{
    int index = wrapper->multiviewSetup ? view : currentImage;
    updateCameraBuffer(currentImage);
};
void BuffersControllerWarping::updateAllUniformBuffer(uint32_t currentImage, int view)
{
 
    //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]);
 
}
 
 
 
 
vk::VertexInputBindingDescription BuffersControllerWarping::getBindingDescription()
{
    vk::VertexInputBindingDescription bindingDescription{
            0,  //binding
            sizeof(glm::vec1), // stride
            vk::VertexInputRate::eVertex //inputRate
    };
    return bindingDescription;
}
 
std::vector<vk::VertexInputAttributeDescription> BuffersControllerWarping::getAttributeDescription()
{
    std::vector<vk::VertexInputAttributeDescription> attributeDescriptions{
    vk::VertexInputAttributeDescription(
        0,  //location
        0,  //binding
        vk::Format::eR32Sfloat,     //format
        0   //offset
    )};
    return attributeDescriptions;
}
 
uint32_t BuffersControllerWarping::getIndiceCount()
{
    return indiceCount;
}
 
 
void BuffersControllerWarping::copyBufferToImage(vk::Buffer buffer, vk::Image image, uint32_t width, uint32_t height)
{
    vk::CommandBuffer commandBuffer = beginSingleTimeCommands(context, renderpass->commandPoolBuffer);
 
    vk::ImageSubresourceLayers subRessources(
        vk::ImageAspectFlagBits::eColor, //aspectMask
        0,  //mipLevel
        0, //baseArrayLayer
        1   //layerCount
    );
    vk::BufferImageCopy region(
        0,  //bufferOffset
        0,  //bufferRowLength
        0,  //bufferImageHeight
        subRessources,  //imageSubresource
        { 0,0,0 },  //imageOffset
        { width,height,1 }  //imageextent
    );  
    commandBuffer.copyBufferToImage(buffer,image,vk::ImageLayout::eTransferDstOptimal, 1, &region);
 
    endSingleTimeCommands(context, renderpass->commandPoolBuffer,commandBuffer);
}
 
void BuffersControllerWarping::updateSettings(
    const InputProvider::StreamFrameInfo& frameInfo,
    int view,
    const InputProvider::StreamParameters& streamParams,
    VulkanWrapper* wrapper,
    RVScamExtrinsics& rvsCamExtrinsics,
    RvsSynParam& rvsSynParam) {
  //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;
}
 
void BuffersControllerWarping::update(std::span<InputProvider::StreamFrameInfo> infos, int view) {
 
    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;
}