RVSVulkan.cpp

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.
---------------------- */
 
 
 
/*****************************************************************/
#include <iostream>
 
#include "WindowGLFW.h"
#ifdef USE_OPENXR
#include "WindowOpenXR.h"
#endif
#include "SourcesVulkan/VulkanWrapper.h"
#include <filesystem>
#include "SourcesVulkan/DynamicInputProvider.h"
 
#include"SourcesVulkan/DynamicInputProvider.h"
 
using namespace std;
 
 
WindowAbstract  * window;
VulkanWrapper * wraps;
 
enum class WindowMode
{
  Headless, GLFW, OpenXR, Undefined
};
 
void printUsage() {
  std::cout
      << "\n" //TODO chose what to do about that
      << " - -------------------------------------------------------------------------------------- -\n"
      << "|    Original authors:                                                                     |\n"
      << "|                                                                                          |\n"
      << "|    Universite Libre de Bruxelles, Brussels, Belgium:                                     |\n"
      << "|      Sarah Fachada, Sarah.Fernandes.Pinto.Fachada@ulb.ac.be                              |\n"
      << "|      Daniele Bonatto, Daniele.Bonatto@ulb.ac.be                                          |\n"
      << "|      Arnaud Schenkel, arnaud.schenkel@ulb.ac.be                                          |\n"
      << "|                                                                                          |\n"
      << "|    Koninklijke Philips N.V., Eindhoven, The Netherlands:                                 |\n"
      << "|      Bart Kroon, bart.kroon@philips.com                                                  |\n"
      << "|      Bart Sonneveldt, bart.sonneveldt@philips.com                                        |\n"
      << " - -------------------------------------------------------------------------------------- -\n\n";
 
  std::cout << "Hovitron version " << std::endl;
 
  std::cout << "Usage: RVS PathToDLL [ --glfw "
             #ifdef USE_OPENXR
            << "|| --openxr][--mirror]"
             #else
            << " ]"
             #endif
            << "[--blendingFactor value] [--start value] [--triangleThreshold value] [--scaleFactor value]"
            << std::endl;
  std::cout << "--headless is currently not supported" << std::endl;
#ifndef USE_OPENXR
  std::cout << "--openxr is not available since the code was not compiled with openxr flag" << std::endl;
#endif
 
 
};
 
int main(int argc, char* argv[])
{
#ifdef WIN32
  SetConsoleOutputCP(CP_UTF8);
#endif // 
 
  WindowMode mode = WindowMode::Undefined;
  PipelineMode pipelineMode = PipelineMode::Raster;
  std::string pathDLL;
  bool openXRmirror = false;
  bool skip = false;
  float blendingFactor = 5.0;
  float triangleThreshold = -1;
  float scaleFactor = -1;
  auto startingPoint = StartingPosition::Average;
  float nearPlaneHeadset = -1;
  float farPlaneHeadset = -1;
  int32_t portNumber = 60392;
  for (int i = 1; i < argc; ++i) {
    if (skip) {
      skip = false;
      continue;
    }
    if (strcmp(argv[i], "--help") == 0) {
      pathDLL.clear();
      break;
    }
    else if (strcmp(argv[i], "--headless") == 0) {
      std::cout << "mode without window have been activated" << std::endl;
      if (mode == WindowMode::Undefined) {
        //mode = WindowMode::Headless;
        printUsage();
        throw std::runtime_error("Currently the headless mode is unsupported");
        return EXIT_FAILURE;
      }
      else {
        printUsage();
        throw std::runtime_error("Only one flag is accepted for chosing the window mode");
        return EXIT_FAILURE;
      }
    }
    else if (strcmp(argv[i], "--glfw") == 0) {
      std::cout << "mode with a glfw window" << std::endl;
      if (mode == WindowMode::Undefined) {
        mode = WindowMode::GLFW;
      }
      else {
        printUsage();
        throw std::runtime_error("Only one flag is accepted for chosing the window mode");
        return EXIT_FAILURE;
      }
    }else if (strcmp(argv[i], "--openxr") == 0) {
      std::cout << "mode with OpenXR" << std::endl;
      if (mode == WindowMode::Undefined) {
#ifdef USE_OPENXR
        mode = WindowMode::OpenXR;
#else
        throw std::runtime_error("Not compiled with OpenXr, OpenXR mode unsupported");
        return EXIT_FAILURE;
#endif // OPENXR
      }
      else {
        printUsage();
        throw std::runtime_error("Only one flag is accepted for chosing the window mode");
        return EXIT_FAILURE;
      }
    }
    else if (strcmp(argv[i], "--mirror") == 0) {
      openXRmirror = true;
      std::cout << "Mirror for openXR requested" << std::endl;
    }
    else if (strcmp(argv[i], "--blendingFactor") == 0  || strcmp(argv[i], "-b") == 0) {
      if (i + 1 < argc) {
        skip = true;
        auto factor = argv[i+1];
        blendingFactor = std::stof(factor);
        std::cout << "Blending factor set to: " << blendingFactor << std::endl;
      }
      else {
        printUsage();
        throw std::runtime_error("blending factor missing");
        return EXIT_FAILURE;
      }
    }
    else if (strcmp(argv[i], "--triangleTreshold") == 0 || strcmp(argv[i], "-t") == 0) {
      if (i + 1 < argc) {
        skip = true;
        auto factor = argv[i + 1];
        triangleThreshold = std::stof(factor);
        std::cout << "triangleThreshold set to: " << triangleThreshold << std::endl;
      }
      else {
        printUsage();
        throw std::runtime_error("value for thriangleThreshold missing");
        return EXIT_FAILURE;
      }
    }
    else if (strcmp(argv[i], "--start") == 0 ) {
      if (i + 1 < argc) {
        skip = true;
        auto start = argv[i + 1];
        if (strcmp(start, "zero") == 0) {
          startingPoint = StartingPosition::Zero;
          PRINT("Starting point set to zero");
        }else if (strcmp(start, "average") == 0) {
          startingPoint = StartingPosition::Average;
          PRINT("Starting point set to the average of the pose of the input cameras");
        }
        else {
          printUsage();
          throw std::runtime_error((" %s is not a supported mode for starting point", start));
          return EXIT_FAILURE;
        }
      }
      else {
        printUsage();
        throw std::runtime_error("Argument for starting position is missing ");
        return EXIT_FAILURE;
      }
    }
    else if (strcmp(argv[i], "--port") == 0 || strcmp(argv[i], "-p") == 0) {
#ifdef HVT_UDP_CONTROL
        if (i + 1 < argc) {
            skip = true;
            portNumber = stoi(argv[i + 1]);
            PRINT("Port set to %d", portNumber);
        }
        else {
            printUsage();
            throw std::runtime_error("Argument for port is missing ");
            return EXIT_FAILURE;
        }
#else
        printUsage();
        throw std::runtime_error("Not compiled with UDP control, --port argument is unavailable");
        return EXIT_FAILURE;
#endif // HVT_UDP_CONTROL
    }
    else if (pathDLL.empty()) {
      pathDLL = argv[i];
    }
    else {
      printUsage();
      throw std::runtime_error("Too many parameters (try --help)");
      return EXIT_FAILURE;
    }
  }
 
  std::cout
      << " - -------------------------------------------------------------------------------------- -\n"
      << "|    Reference View Synthesizer (RVS) version Vulkan, based on (branch: v3.1)              |\n"
      << "|                                                                                          |\n"
      << "|    MPEG2018/N18068 Reference View Synthesizer (RVS) manual                               |\n"
      << " - -------------------------------------------------------------------------------------- -" << std::endl;
 
  if (pathDLL.empty()) {
    printUsage();
 
    throw std::runtime_error("Please specify at least a valid path to the dynamic library (.dll) that provide the input");
    
  }
 
  if (mode == WindowMode::Undefined) {
    std::cout << "No mode for the window specidied --> fall back to GLFW window";
    mode = WindowMode::GLFW;
  }
 
  if (openXRmirror && mode != WindowMode::OpenXR) {
    std::cout << "Mirror for OpenXR mode is requested but the mode chosen isn't OpenXR, --mirror flag will be ignored" << std::endl;
    openXRmirror = false;
  }
 
  std::filesystem::path p = pathDLL;
  auto dir = p.parent_path();
  auto ex = std::filesystem::exists(p);
 
 
  try {
    switch (mode)
    {
      case WindowMode::GLFW:
        window = new WindowGLFW();
        break;
#ifdef USE_OPENXR
      case WindowMode::OpenXR:
        window = new WindowOpenXR();
        static_cast<WindowOpenXR *>(window)->setMirror(openXRmirror);
        break;
#endif
      default:
        window = new WindowGLFW();
        break;
    }
 
 
 
    wraps = new VulkanWrapper(window, pipelineMode);
#ifdef HVT_UDP_CONTROL
    wraps->init(portNumber);
#else
    wraps->init();
#endif
    wraps->setBlendingFactor(blendingFactor);
    if (triangleThreshold != -1) {
      wraps->setTriangleThreshold(triangleThreshold);
    }
    if (scaleFactor != -1) {
      wraps->setScaleFactor(scaleFactor);
    }
    InputProvider * inputDLL = new DynamicInputProvider(pathDLL.c_str(), *wraps);
    wraps->endInit(inputDLL, startingPoint);
    wraps->start();
    wraps->cleanUp();
    delete wraps;
    delete window;
  }
  catch (const std::exception& e) {
    std::cerr << e.what() << std::endl;
    return EXIT_FAILURE;
  }
 
  return EXIT_SUCCESS;
}