BuffersControllerWarping.h

Go to the documentation of this file.

/* ----------------------
* 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.
---------------------- */
 
 
/*****************************************************************/
#pragma once
 
#include "commonVulkan.h"
 
#include"BuffersControllerAbstract.h"
#include "InputProvider.h"
 
 
class VulkanContext;
class VulkanRenderpass;
class VulkanPipelineWarping;
class VulkanWrapper;
 
struct RVScamExtrinsics {
    alignas(16) glm::mat4x4 R;
    alignas(16) glm::vec4 t;
};
struct RvsSynParam {
    alignas(4) float max_depth;
    alignas(4) float min_depth;
 
    //sizes
    alignas(4) float w;
    alignas(4) float h;
    alignas(4) float n_w;
    alignas(4) float n_h;
    // Input/output projection types
    alignas(4) int erp_in;
    alignas(4) int erp_out;
    // Perspective unprojection
    alignas(8) glm::vec2 f;
    alignas(8) glm::vec2 p;
    // Perspective projection
    alignas(8) glm::vec2 n_f;
    alignas(8) glm::vec2 n_p;
    // Equirectangular unprojection
    alignas(4) float phi0;
    alignas(4) float theta0;
    alignas(4) float dphi_du;
    alignas(4) float dtheta_dv;
    // Equirectangular projection
    alignas(4) float u0;
    alignas(4) float v0;
    alignas(4) float du_dphi;
    alignas(4) float dv_dtheta;
 
    alignas(4) int lin_depth = 0;
    alignas(4) float scaleFactor = 1.0;
};
 
struct RvsSynGeom {
    alignas(4) float w;
    alignas(4) float h;
    alignas(4) float pixelThresh;
    alignas(4) float scaleFactor = 1.0;
};
struct RvsSynFrag {
    float max_depth;
    float pixelThresh;
    float maxMul;
    alignas(4) float scaleFactor = 1.0;
};
 
 
class BuffersControllerWarping: public BuffersController {
public:
    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;
 
    static inline std::vector<uint32_t> indices;
 
    uint32_t getIndiceCount() override;
    void update(std::span<InputProvider::StreamFrameInfo> infos, int view) override;
 
    static void updateSettings(const InputProvider::StreamFrameInfo& infos, int view, const InputProvider::StreamParameters& streamParams, VulkanWrapper* wrapper, RVScamExtrinsics& extrinsics, RvsSynParam& params);
private:
    int idStep = 0;
    
    RVScamExtrinsics rvsCamExtrinsics;
    RvsSynParam rvsSynParam;
    RvsSynGeom rvsSynGeom;
    RvsSynFrag rvsSynFrag;
    
    VulkanPipelineWarping* pipeline = nullptr;
    VulkanWrapper* wrapper = nullptr;
    InputProvider* input = nullptr;
    InputProvider::StreamParameters streamParams;
 
    inline static uint32_t indiceCount = 0;
    void createVertexBuffer()  override;
    void createIndexBuffer()  override;
 
    void createUniformBuffer(int size)  override;
    void createDescriptorPool()  override;
    void createDescriptorSets()  override;
    void updateDescriptorSets(int attachment, int slot);
    void updateCameraBuffer(uint32_t currentImage);
    void copyBufferToImage(vk::Buffer buffer, vk::Image image, uint32_t width, uint32_t height);
 
    vk::DescriptorPool descriptorPool;
    std::vector<vk::DescriptorSet> descriptorSets;
 
    //-----------------Images from the stream
    std::vector<InputProvider::StreamImage> textureStreamImages;
    std::vector<InputProvider::StreamImage> depthStreamImages;
 
 
    //uniforms
    std::vector<vk::Buffer> uniformBuffersCam;
    std::vector<vk::DeviceMemory> uniformBuffersCamMemory;
 
    std::vector<vk::Buffer> uniformBuffers;
    std::vector<vk::DeviceMemory> uniformBuffersMemory;
 
    std::vector<vk::Buffer> uniformBuffersGeom;
    std::vector<vk::DeviceMemory> uniformBuffersGeomMemory;
 
    std::vector<vk::Buffer> uniformBuffersFrag;
    std::vector<vk::DeviceMemory> uniformBuffersFragMemory;
 
    int attachmentSize = 0;
 
    //vertex and index
    inline static vk::Buffer vertexBuffer;
    inline static vk::DeviceMemory vertexBufferMemory;
    inline static vk::Buffer indexBuffer ;
    inline static vk::DeviceMemory indexBufferMemory ;
};