WindowGLFW.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.
---------------------- */
 
 
 
#include"WindowGLFW.h"
#include "SourcesVulkan/VulkanContext.h"
#include "SourcesVulkan/VulkanWrapper.h"
#include <iostream>
#include <sstream>
#include "SwapchainCommon.h"
 
void WindowGLFW::initWindow()
{
    glfwInit();
    glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API);
    glfwWindowHint(GLFW_RESIZABLE, GLFW_FALSE);
    glfwWindowHint(GLFW_SCALE_TO_MONITOR, GLFW_FALSE);
    glfwWindowHint(GLFW_DECORATED, GLFW_FALSE);
 
    //auto monitor = glfwGetPrimaryMonitor();
    window = glfwCreateWindow(WIDTH, HEIGHT, "Vulkan", nullptr, nullptr);
    separateFromWindowDim = false;
 
    glfwSetWindowUserPointer(window, this);
 
    //glfw is a C API and if we want to redirect the call to a member function some tricks have to be used
    //fore more info check this: https://stackoverflow.com/questions/7676971/pointing-to-a-function-that-is-a-class-member-glfw-setkeycallback
    auto func = [](GLFWwindow* w, int, int)
    {
        static_cast<WindowGLFW*>(glfwGetWindowUserPointer(w))->framebufferResizeCallback();
    };
 
    glfwSetFramebufferSizeCallback(window, func);
 
    auto funKey = [](GLFWwindow* w, int key, int scancode, int action, int mods) {
        static_cast<WindowGLFW*>(glfwGetWindowUserPointer(w))->inputKeyCallback(w, key, scancode, action, mods);
    };
    glfwSetKeyCallback(window, funKey);
 
    currentTranslation = { 0,0,0 };
    currentRotation = { 0,0,0 };
    initialised = true;
 
}
 
void WindowGLFW::continueInit()
{
    createSurface();
    swapchains.resize(1);
    swapchains[0] = std::unique_ptr<SwapchainAbstract>(new SwapchainCommon(surface,this,wrapper));
    renderingFinnishedSemaphore.resize(swapchains[0]->getAttachmentSize());
    vk::SemaphoreCreateInfo semaphoreInfo;
    for (auto& sem : renderingFinnishedSemaphore) {
        sem = wrapper->context.device.createSemaphore(semaphoreInfo);
    }
}
 
void WindowGLFW::cleanUp()
{
    glfwDestroyWindow(window);
    glfwTerminate();
}
 
void WindowGLFW::cleanUpSurface()
{
    for (auto& sem : renderingFinnishedSemaphore) {
        wrapper->context.device.destroySemaphore(sem);
    }
    for (int i = 0; i < swapchains.size(); i++) {
        swapchains[i]->cleanup();
    }
    VkInstance instance = static_cast<VkInstance>(wrapper->context.instance);
    vkDestroySurfaceKHR(instance, surface, nullptr);
}
 
void WindowGLFW::mainLoop(VulkanDrawing* vulkanDrawing)
{
    printInputCommands();
    while (!glfwWindowShouldClose(window)) {
 
        glfwPollEvents();
 
#ifdef HVT_UDP_CONTROL
        mutex.lock();
#endif
        wrapper->updateSpaceTransform(currentTranslation, currentRotation);
#ifdef HVT_UDP_CONTROL
        mutex.unlock();
#endif
 
    
        for (int i = 0; i < swapchains.size(); i++) {
            uint32_t index;
            std::optional<vk::Semaphore> imageAvailableSemaphore;
            try{
            std::tie(index, imageAvailableSemaphore) = swapchains[i]->acquireImage();
            std::tuple <int, uint32_t> idImage(i, index);
            std::vector<vk::Semaphore> semaphores;
            std::vector<vk::Semaphore> signalSemaphore = { renderingFinnishedSemaphore[index] };
            if (imageAvailableSemaphore.has_value()) {
                semaphores.push_back(imageAvailableSemaphore.value());
            }
            vulkanDrawing->submitDrawCall(idImage, semaphores , signalSemaphore);
            swapchains[i]->presentImage(index, renderingFinnishedSemaphore[index]);
            }
            catch (vk::OutOfDateKHRError) {
                std::cout << "test " << "ahhh" << std::endl;
                wrapper->recreateSwapChain();
            }
        }
    }
}
 
void WindowGLFW::createSurface()
{
    if (glfwCreateWindowSurface(wrapper->context.instance, window, nullptr, &surface) != VK_SUCCESS) {
        throw std::runtime_error("failed to create window surface!");
    }
}
 
std::vector<const char*> WindowGLFW::getRequiredExtensions()
{
    uint32_t glfwExtensionCount = 0;
    const char** glfwExtensions;
    glfwExtensions = glfwGetRequiredInstanceExtensions(&glfwExtensionCount);
 
    std::vector<const char*> extensions(glfwExtensions, glfwExtensions + glfwExtensionCount);
 
    if (enableValidationLayers) {
        extensions.push_back(VK_EXT_DEBUG_UTILS_EXTENSION_NAME);
    }
    return extensions;
}
 
VkBool32 WindowGLFW::isDeviceSupportingSufaceKHR(VkPhysicalDevice device, int i)
{
    VkBool32 presentSupport = false;
    vkGetPhysicalDeviceSurfaceSupportKHR(device, i, surface, &presentSupport);
    return presentSupport;
}
 
std::vector<const char*> WindowGLFW::getRequiredDeviceExtensions()
{
    return deviceExtensions;
}
 
SwapChainSupportDetails WindowGLFW::querySwapChainSupport(vk::PhysicalDevice device)
{
    SwapChainSupportDetails details;
    details.capabilities = device.getSurfaceCapabilitiesKHR(surface);
    //LOGI("capabilities: width %u ,height: %u",details.capabilities.currentExtent.width,details.capabilities.currentExtent.height);
    details.formats = device.getSurfaceFormatsKHR(surface);
    //xrEnumerateSwapchainFormats ?
    details.presentModes = device.getSurfacePresentModesKHR(surface);
    return details;
}
 
void WindowGLFW::checkForCorrectSize()
{
    int width = 0, height = 0;
    glfwGetFramebufferSize(window, &width, &height);
    while (width == 0 || height == 0) {
        glfwGetFramebufferSize(window, &width, &height);
        glfwWaitEvents();
    }
}
 
void WindowGLFW::getFrameBufferSize(int* w, int* h, vk::PhysicalDevice& pDevice)
{
    glfwGetFramebufferSize(window, w, h);
}
 
bool WindowGLFW::isSynchroWithSemaphore()
{
    return true;
}
 
 
 
void WindowGLFW::printInputCommands()
{
    PRINT("\n \n----------------------------------------------");
    std::cout << "To navigate in the scene use:" << std::endl;
    std::cout << "----Translation----" << std::endl;
    std::cout << "Up: " << "Up arrow" << "\t" << "Down: " << "Down arrow" << std::endl;
    std::cout << "Left: " << "Left arrow" << "\t" << "Right: " << "Right arrow" << std::endl;
    std::cout << "Forward: " << "Page Up" << "\t" << "Backward:" << "Page Down" << std::endl;
    std::cout << "----Rotation-------" << std::endl;
    const char* upRotKey = glfwGetKeyName(GLFW_KEY_W, 0);
    const char* downRotKey = glfwGetKeyName(GLFW_KEY_S, 0);
    std::cout << "Pitch Up: " << upRotKey << "\t" << "Pitch Down: " << downRotKey << std::endl;
    const char* leftRotKey = glfwGetKeyName(GLFW_KEY_A, 0);
    const char* rightRotKey = glfwGetKeyName(GLFW_KEY_D, 0);
    std::cout << "Yaw Left: " << leftRotKey << "\t" << "Yaw Right: " << rightRotKey << std::endl;
    const char* rollKey = glfwGetKeyName(GLFW_KEY_Q, 0);
    const char* rollClockKey = glfwGetKeyName(GLFW_KEY_E, 0);
    std::cout << "Roll conterclockwise: " << rollKey << "\t" << "roll clockwise: " << rollClockKey << std::endl;
    const char* reset = glfwGetKeyName(GLFW_KEY_0, 0);
    PRINT("Reset the view: %s (0)", reset);
    std::cout << "-------------\n" << std::endl;
    std::cout << "To exit press: ESC" << std::endl;
    std::cout << "-------------\n" << std::endl;
    std::cout << "To enter/exit manual calibration mode: F1" << std::endl;
    std::cout << "Save correction calibration to disk: F2" << std::endl;
    std::cout << "Load correction calibration to disk: F3" << std::endl;
    const char* oneCam = glfwGetKeyName(GLFW_KEY_1, 0);
    const char* twoCam = glfwGetKeyName(GLFW_KEY_2, 0);
    const char* threeCam = glfwGetKeyName(GLFW_KEY_3, 0);
    PRINT("---Select a camera---\n camera 1, 2, 3 : %s (1), %s (2), %s (3) ", oneCam, twoCam, threeCam);
    const char* refCam = glfwGetKeyName(GLFW_KEY_GRAVE_ACCENT, 0);
    PRINT("Reference camera (camera 0): %s",refCam);
    PRINT("--Adjust rotation--\n %s %s (roll), %s %s (yaw), %s %s (pitch)",
        rollKey,rollClockKey,leftRotKey,rightRotKey,upRotKey,downRotKey);
 
    const char* t1 = glfwGetKeyName(GLFW_KEY_I, 0);
    const char* t1b = glfwGetKeyName(GLFW_KEY_K, 0);
    const char* t2 = glfwGetKeyName(GLFW_KEY_J, 0);
    const char* t2b = glfwGetKeyName(GLFW_KEY_L, 0);
    const char* t3 = glfwGetKeyName(GLFW_KEY_U, 0);
    const char* t3b = glfwGetKeyName(GLFW_KEY_O, 0);
    PRINT("--Adjust translation--\n %s %s (left/right), %s %s (up/down), %s %s (forward/backward)", t2,t2b,t1,t1b,t3,t3b);
 
    const char* p1 = glfwGetKeyName(GLFW_KEY_T, 0);
    const char* p1b = glfwGetKeyName(GLFW_KEY_G, 0);
    const char* p2 = glfwGetKeyName(GLFW_KEY_Y, 0);
    const char* p2b = glfwGetKeyName(GLFW_KEY_H, 0);
    PRINT("--Adjust principal pt--\n %s %s (x axis), %s %s (y axis)", p1, p1b, p2, p2b);
 
    const char* f1 = glfwGetKeyName(GLFW_KEY_Z, 0);
    const char* f1b = glfwGetKeyName(GLFW_KEY_X, 0);
    const char* f2 = glfwGetKeyName(GLFW_KEY_C, 0);
    const char* f2b = glfwGetKeyName(GLFW_KEY_V, 0);
    PRINT("--Adjust focal--\n %s %s (x axis), %s %s (y axis)", f1, f1b, f2, f2b);
 
 
    const char* plusStep = glfwGetKeyName(GLFW_KEY_EQUAL, 0);
    const char* minusStep = glfwGetKeyName(GLFW_KEY_MINUS, 0);
    PRINT("---To adjust the step---\n multiply by 2: %s \t divide by 2: %s ",plusStep,minusStep);
    PRINT("Print current correction: space bar");
    PRINT("Enable/Disable selected camera: F4");
    PRINT("----------------------------------------------\n\n");
}
 
void WindowGLFW::inputKeyCallback(GLFWwindow* window, int key, int scancode, int action, int mode)
{
    const float delta = 0.004;
    const float deltaRot = 0.2;
    const int inputAction = GLFW_REPEAT;
 
    if (key == GLFW_KEY_ESCAPE && action == GLFW_PRESS) {
        glfwSetWindowShouldClose(window, GL_TRUE);
    }
 
    if (key == GLFW_KEY_F1 && action == GLFW_PRESS) {
        qualibrationMode = !qualibrationMode;
        if (qualibrationMode) {
            std::cout << "Qualibration Mode is turn ON" << std::endl;
        }
        else {
            std::cout << "Qualibration Mode is turn OFF" << std::endl;
        }
    }
 
    if (key == GLFW_KEY_F2 && action == GLFW_PRESS) {
        wrapper->saveConfigurationsToDisk();
    }
    if (key == GLFW_KEY_F3 && action == GLFW_PRESS) {
        wrapper->loadConfigurationsFromDisk();
    }
 
    if (!qualibrationMode) {
        if (key == GLFW_KEY_LEFT && action == inputAction) {
            //std::cout << "input Left" << std::endl;
            currentTranslation[0] -= delta;
        }
        else if (key == GLFW_KEY_RIGHT && action == inputAction) {
            //std::cout << "input Right" << std::endl;
            currentTranslation[0] += delta;
        }
        else if (key == GLFW_KEY_UP && action == inputAction) {
            //std::cout << "input Up" << std::endl;
            currentTranslation[1] += delta;
        }
        else if (key == GLFW_KEY_DOWN && action == inputAction) {
            //std::cout << "input Down" << std::endl;
            currentTranslation[1] -= delta;
        }
        else if (key == GLFW_KEY_PAGE_UP && action == inputAction) {
            //std::cout << "input Down" << std::endl;
            currentTranslation[2] -= delta;
        }
        else if (key == GLFW_KEY_PAGE_DOWN && action == inputAction) {
            //std::cout << "input Down" << std::endl;
            currentTranslation[2] += delta;
        }
        else if (key == GLFW_KEY_Q && action == inputAction) {
            //Roll
            currentRotation[2] -= deltaRot;
        }
        else if (key == GLFW_KEY_E && action == inputAction) {
            //Roll
            currentRotation[2] += deltaRot;
        }
        else if (key == GLFW_KEY_W && action == inputAction) {
            //Pitch
            currentRotation[0] += deltaRot;
        }
        else if (key == GLFW_KEY_S && action == inputAction) {
            //Pitch
            currentRotation[0] -= deltaRot;
        }
        else if (key == GLFW_KEY_A && action == inputAction) {
            //Yall
            currentRotation[1] += deltaRot;
        }
        else if (key == GLFW_KEY_D && action == inputAction) {
            //Yall
            currentRotation[1] -= deltaRot;
        }
        else if (key == GLFW_KEY_SPACE && action == GLFW_PRESS)
        {
            std::cout << "current rotation (Openxr Space): " << glm::to_string(currentRotation) << std::endl;
            std::cout << "current translation (Openxr Space): " << glm::to_string(currentTranslation) << std::endl << std::endl;
        }
        else if ((key == GLFW_KEY_0 || key == GLFW_KEY_KP_0) && action == GLFW_PRESS) {
            resetOrigin();
        }
    }
 
    else  {
        glm::vec3 deltaQualR = {0,0,0};
        glm::vec3 deltaQualT = { 0,0,0 };
        glm::vec2 deltaQualF = { 0,0 };
        glm::vec2 deltaQualP = { 0,0 };
 
        if (key == GLFW_KEY_F4 && action == GLFW_PRESS) {
            if (selectedCamera == -1) {
                std::cout << "No camera selected" << std::endl;
            }
            else {
                wrapper->toggleCamera(selectedCamera);
                std::cout << "Camera " << selectedCamera << " is now " << (wrapper->getCameraActivation()[selectedCamera] ? "enabled" : "disabled") << std::endl;
            }
        }
        else if (key == GLFW_KEY_GRAVE_ACCENT && action == GLFW_PRESS) {
            std::cout << "select Camera 0" << std::endl;
            selectedCamera = 0;
        }
        else if (key == GLFW_KEY_1 && action == GLFW_PRESS) {
            std::cout << "select Camera 1" << std::endl;
            selectedCamera = 1;
        }
        else if (key == GLFW_KEY_2 && action == GLFW_PRESS) {
            std::cout << "select Camera 2" << std::endl;
            selectedCamera = 2;
        }
        else if (key == GLFW_KEY_3 && action == GLFW_PRESS) {
            std::cout << "select Camera 3" << std::endl;
            selectedCamera = 3;
        }
        else if (key == GLFW_KEY_EQUAL && action == GLFW_PRESS) {
            deltaValueCalibration *= 2;
        }
        else if (key == GLFW_KEY_MINUS && action == GLFW_PRESS) {
            deltaValueCalibration /= 2;
        }
        else if (key == GLFW_KEY_SPACE && action == GLFW_PRESS){
            PRINT("Current step %f", deltaValueCalibration);
            auto corrections = wrapper->getCorrectionVectorRotation();
            for (int i = 0; i < corrections.size(); i++) {
                std::cout << "Correction for camera " << i << " (OMAF space) : " << glm::to_string(corrections[i]) << std::endl;
            }
            std::cout << std::endl;
        }
        else if (action == GLFW_PRESS) {
            switch (key) {
            case GLFW_KEY_Q:
                //Roll
                deltaQualR[2] -= deltaValueCalibration;
                break;
            case GLFW_KEY_E:
                //Roll
                deltaQualR[2] += deltaValueCalibration;
                break;
            case GLFW_KEY_W:
                //Pitch
                deltaQualR[1] -= deltaValueCalibration;
                break;
            case GLFW_KEY_S:
                //Pitch
                deltaQualR[1] += deltaValueCalibration;
                break;
            case GLFW_KEY_A:
                //Yall
                deltaQualR[0] += deltaValueCalibration;
                break;
            case GLFW_KEY_D:
                //Yall
                deltaQualR[0] -= deltaValueCalibration;
                break;
            //Translation -------------
            case GLFW_KEY_K:
                //down
                deltaQualT[2] -= 0.1 * deltaValueCalibration;
                break;
            case GLFW_KEY_I:
                //up
                deltaQualT[2] += 0.1 * deltaValueCalibration;
                break;
            case GLFW_KEY_J:
                //left
                deltaQualT[1] += 0.1 * deltaValueCalibration;
                break;
            case GLFW_KEY_L:
                //right
                deltaQualT[1] -= 0.1 * deltaValueCalibration;
                break;
            case GLFW_KEY_U:
                //
                deltaQualT[0] += 0.1 * deltaValueCalibration;
                break;
            case GLFW_KEY_O:
                //
                deltaQualT[0] -=  0.1 *deltaValueCalibration;
                break;
 
            //principalPt
            case GLFW_KEY_T:
                //x
                deltaQualP[0] += 10 * deltaValueCalibration;
                break;
            case GLFW_KEY_G:
                //x
                deltaQualP[0] -= 10 * deltaValueCalibration;
                break;
            case GLFW_KEY_Y:
                //y
                deltaQualP[1] +=  10 * deltaValueCalibration;
                break;
            case GLFW_KEY_H:
                //y
                deltaQualP[1] -=  10 * deltaValueCalibration;
                break;
 
            //focals
 
            case GLFW_KEY_Z :
                //x
                deltaQualF[0] += 20 * deltaValueCalibration;
                break;
            case GLFW_KEY_X:
                //x
                deltaQualF[0] -= 20 * deltaValueCalibration;
                break;
            case GLFW_KEY_C:
                //y
                deltaQualF[1] += 20 * deltaValueCalibration;
                break;
            case GLFW_KEY_V:
                //y
                deltaQualF[1] -= 20 * deltaValueCalibration;
                break;
            }
 
            auto acti = wrapper->getCameraActivation();
            if (selectedCamera != -1 && selectedCamera < acti.size() && acti[selectedCamera]) {
                if (deltaQualR.x != 0 || deltaQualR.y != 0 || deltaQualR.z != 0) {
                    wrapper->setCorrectionRotation(selectedCamera, deltaQualR);
                }
                else if (deltaQualT.x != 0 || deltaQualT.y != 0 || deltaQualT.z != 0) {
                    wrapper->setCorrectionTranslation(selectedCamera, deltaQualT);
                }
                else if (deltaQualP.x != 0 || deltaQualP.y != 0 ) {
                    wrapper->setCorrectionPrincipalPt(selectedCamera, deltaQualP);
                }
                else if (deltaQualF.x != 0 || deltaQualF.y != 0) {
                    wrapper->setCorrectionFocal(selectedCamera, deltaQualF);
                }
            }
        }
    }
}
 
 
 
void WindowGLFW::framebufferResizeCallback()
{
    wrapper->framebufferResized = true;
}
 
void WindowGLFW::resetOrigin()
{
#ifdef HVT_UDP_CONTROL
    mutex.lock();
#endif
    currentTranslation = { 0,0,0 };
    currentRotation = { 0,0,0 };
#ifdef HVT_UDP_CONTROL
    mutex.unlock();
#endif
}