VulkanWrapper.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 <vector>
 
#include"VulkanContext.h"
#include"VulkanDrawing.h"
 
#include"VulkanRenderPass.h"
 
 
 
 
#ifdef __ANDROID__
#include <android/log.h>
#include <android_native_app_glue.h>
#endif
 
 
#include "commonVulkan.h"
#include "InputProvider.h"
#include "RenderingParameters.h"
 
 
class Window;
class WindowAbstract;
class InputProvider;
 
//Indicate which type of pipeline is used
enum class PipelineMode{
  Raster
};
 
class VulkanWrapper {
public:
#ifdef __ANDROID__
    VulkanWrapper(WindowAbstract* window, android_app* appAndroid);
#else
  VulkanWrapper(WindowAbstract* window, PipelineMode pmode);
#endif
#if USE_OPENXR
    XrGraphicsBindingVulkan2KHR getGraphicsBinding();
    void endCleanUp();
#else
#endif
#ifdef HVT_UDP_CONTROL
    void init(unsigned short portNumber);
#else
    void init();
#endif
    void endInit(InputProvider * input, StartingPosition startingPt = StartingPosition::Average);
    void start();
    void cleanUp();
    void recreateSwapChain();
    void updateSpaceTransform(glm::vec3 translation, glm::vec3 rotation);
    void updateSpaceTransform(glm::vec3 translation, glm::vec3 rotation, glm::vec4 fov, int view);
    void waitIdle();
    void createImageCall(uint32_t width, uint32_t height, vk::Format format, vk::ImageTiling tiling, vk::ImageUsageFlags usage, vk::MemoryPropertyFlags properties, vk::Image& image, vk::DeviceMemory& imageMemory);
    void createBufferCall(vk::DeviceSize size, vk::BufferUsageFlags usage, vk::MemoryPropertyFlags properties, vk::Buffer& buffer, vk::DeviceMemory& bufferMemory);
    void copyMemory(VkDeviceSize& size, vk::DeviceMemory& memory, unsigned char* dataToCopy);
    void destroyImageAndMemory(std::vector<vk::Image> &vectorImage, std::vector<vk::DeviceMemory> &vectorMemory);
    void destroyBufferAndMemory(std::vector<vk::Buffer>& vectorBuffer, std::vector<vk::DeviceMemory>& vectorMemory);
    bool isDepthOutputRecquired();
    void setBlendingFactor(float blendingfactor);
    void setTriangleThreshold(float triangleThreshold);
    bool isUsingDifferentViewSize();
 
    VulkanContext* getContext();
    vk::Extent2D getSwapchainExtend(int view = 0); //size of the swapchainExtend
    vk::Extent2D getRenderOutputExtent();
 
    std::vector<vk::Format> getRenderPassSupportedDepthFormats() const;
    vk::Format getSwapchainFormat(int view = 0);
    vk::Format getDepthSwapchainFormat(int view = 0);
 
    vk::ImageLayout getLayoutAfterRenderpass();
 
    int getAttachmentSize();
    int getViewNumber();
    void setAverageInputPosition(std::vector<InputProvider::StreamFrameInfo>& frameInfo);
 
    void addDeltaToStartingPoint(glm::vec3 dPos, glm::vec3 dRot);
 
    void setCorrectionRotation(int camId, glm::vec3 rotationCorrection);
    void setCorrectionTranslation(int camId, glm::vec3 translationCorrection);
    void setCorrectionFocal(int camId, glm::vec2 focals);
    void setCorrectionPrincipalPt(int camId, glm::vec2 principalPt);
    void setScaleFactor(float scaleFactor);
 
    bool framebufferResized = false;
 
    const vk::Format internalColorAttachmentFormat = vk::Format::eR8G8B8A8Unorm;//vk::Format::eR32G32B32A32Sfloat;
    const vk::Format internal1DAttachmentFormat = vk::Format::eR32Sfloat;
    const vk::Format qualityAttachmentFormat = vk::Format::eR32Sfloat;
    
 
 
    const bool multiviewSetup;
    bool requireAverageInputPosition = true;
 
    VulkanContext context;
 
    RenderingParameters params;
 
    const std::vector<glm::vec3> getCorrectionVectorRotation();
    const std::vector<InputProvider::StreamFrameInfo> getFramesInfo(int view);
    void saveConfigurationsToDisk();
    void loadConfigurationsFromDisk();
    std::vector<bool> getCameraActivation();
    void toggleCamera(int i);
    void setCameraActivation(std::vector<bool> activation);
 
 
 
  using RenderPassType = VulkanRenderpass;
 
private:
#ifdef HVT_UDP_CONTROL
    //mutex used to avoid race condition because of the UDP server running on another thread
    std::mutex mutexAct;
    //port requested for the UDP server
    unsigned short port = 0;
#endif
    //default path where the offset info or the input camera are stored 
    const char* fileN = "./DumpCorrectionsVectors.txt";
#ifdef __ANDROID__
    android_app* appAndroid;
#endif
    //pointer to the window requested by the system
    WindowAbstract* window = nullptr;
 
    //unique_ptr to the renderpass
    std::unique_ptr<VulkanRenderPassAbstract> renderPass;
    //Reference to the VulkanDrawing class
    VulkanDrawing drawing;
    //Pointer to the Input provider that will provide the data
    InputProvider* inputProvider = nullptr;
 
    //store the requested attachment size
    int attachmentSize = 1;
    
    //Contains an offset to be applied to the rotation of the input cameras
    std::vector<glm::vec3> correctionVectorRotation;
    //contains an offset to be applied to the translation of the input cameras
    std::vector<glm::vec3> correctionVectorTranslation;
    //contains an offset to be applied to the focal of the input cameras
    std::vector<glm::vec2> correctionFocal;
    //contains an offset to be applied to the principle pts of the input cameras
    std::vector<glm::vec2> correctionPrincipalPt;
 
    //Vector that contains a boolean that control if an input camera is in use or not
    std::vector<bool> cameraActivation;
    //The number of cameras used as input have changed, some ressources have to be changed
    bool requestChange = false;
 
    //The informations retrieved from the inputProvider each new frame
    std::vector<InputProvider::StreamFrameInfo> streamFrameInfos;
 
};