RenderingParameters.h

/* ----------------------
* 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 "InputProvider.h"
 
#ifdef HVT_UDP_CONTROL
#include <thread>  
#ifdef WIN32
#include <winsock2.h>
#include <thread>  
#include <mutex>
#else
//TODO
#endif
#endif // 
 
 
 
class WindowAbstract;
class VulkanWrapper;
enum class StartingPosition {
    Zero,
    Average
};
 
enum class VirtualMode{ Tracking, Static1, Static2};
 
 
#ifdef HVT_UDP_CONTROL
struct UDPMessage {
    alignas(4) float magic;
    alignas(4) float mode;
    alignas(4) float viewTransx;
    alignas(4) float viewTransy;
    alignas(4) float viewTransz;
    alignas(4) float viewRotx;
    alignas(4) float viewRoty;
    alignas(4) float viewRotz;
    alignas(4) float viewRotw;
    alignas(4) float cameras;
    alignas(4) float reset;
    alignas(4) float initTransx;
    alignas(4) float initTransy;
    alignas(4) float initTransz;
    alignas(4) float initRotx;
    alignas(4) float initRoty;
    alignas(4) float initRotz;
    alignas(4) float initRotw;
};
#endif
 
class RenderingParameters {
public:
#ifdef  HVT_UDP_CONTROL
    void init(int view, WindowAbstract* window, VulkanWrapper* wraps, unsigned short portNumber);
#else
    void init(int view, WindowAbstract* window, VulkanWrapper * wraps);
#endif //  HVT_UDP_CONTROL
 
    ~RenderingParameters();
 
    float blendingFactor = 5.0; 
    float pixelThreshold = 30;
    const glm::mat3x3 conversionToOMAF = { 0,-1,0, 0,0,1, -1,0,0 }; //column major representation of glm
 
    float maxMult = 10;
    float scaleFactor = 1.0;
    /*
    * //version for opencv below (because opencv use row major representation and glm use column-major
    { 0,0,-1,
    -1,0,0,
    0,1,0 }; */// conversion matrice when the space for the virtual camera isn't OMAF
 
 
    std::vector<glm::vec2> virtualViewDef; //glm::vec2 or vk::Extent2D
    InputProvider::ProjectionType projectionType = InputProvider::ProjectionType::PROJECTION_INVALID; //init at invalid
 
    float max_depth = 0.0;
    float min_depth = FLT_MAX;
 
    float farPlaneHeadset = 10;
    float nearPlaneHeadset = 0.1;
 
    
    void updateSpaceTransform(glm::vec3 translation, glm::vec3 rotation);
    void updateSpaceTransform(glm::vec3 translation, glm::vec3 rotation, glm::vec4 fov, int view);
 
    const InputProvider::Extrinsics getVirtualExtrinsics(int view);
    const InputProvider::Intrinsics getVirtualIntrinsics(int view);
 
    void setStartingPt(glm::vec3 startPos, glm::vec3 startRot);
 
    const glm::vec3 getStartingPosition();
    const glm::vec3 getStartingRotation();
 
private:
    WindowAbstract* window = nullptr;
    VulkanWrapper* wrapper = nullptr;
 
    glm::vec3 startingPosition = { 0,0,0 };
    glm::vec3 startingRotation = { 0,0,0 };
 
    const int staticPoses = 2;
    std::vector<glm::vec3> staticPosition;
    std::vector<glm::quat> staticQuaternion;
 
    std::vector<InputProvider::Extrinsics> virtualExtrinsics;
    std::vector<InputProvider::Intrinsics> virtualIntrasics;
 
    VirtualMode virtualMode = VirtualMode::Tracking;
 
#ifdef HVT_UDP_CONTROL
    //--- Related to the UDP server
    
    unsigned short portNumber = 0;
    const float magicNb = 456123;
    
    void setupUDPServer();
    void mainLoop();
 
    std::thread serverThread;
    int s;
    int namelen;
    int client_address_size;
    sockaddr_in client;
    sockaddr_in server;
    UDPMessage udpMsg;
 
    bool serverIsActive = true;
 
    std::mutex mutex;
    std::mutex startPosMut;
#endif
    
};