WindowGLFW Class Reference

The class that represents a window created with the GLFW library. More...

#include <WindowGLFW.h>

Inheritance diagram for WindowGLFW:

Public Member Functions
void	initWindow () override
void	continueInit () override
void	cleanUp () override
void	cleanUpSurface () override
void	mainLoop (VulkanDrawing *vulkanDrawing) override
void	createSurface () override
std::vector< const char * >	getRequiredExtensions () override
VkBool32	isDeviceSupportingSufaceKHR (VkPhysicalDevice device, int i) override
std::vector< const char * >	getRequiredDeviceExtensions () override
SwapChainSupportDetails	querySwapChainSupport (vk::PhysicalDevice device) override
void	checkForCorrectSize () override
void	getFrameBufferSize (int *w, int *h, vk::PhysicalDevice &pDevice) override
bool	isSynchroWithSemaphore () override
void	printInputCommands ()
void	inputKeyCallback (GLFWwindow *window, int key, int scancode, int action, int mode)
void	framebufferResizeCallback ()
void	resetOrigin () override
Public Member Functions inherited from WindowAbstract
virtual void	initWindow ()=0
virtual void	continueInit ()=0
virtual void	cleanUp ()=0
virtual void	cleanUpSurface ()=0
virtual void	mainLoop (VulkanDrawing *vulkanDrawing)=0
virtual void	createSurface ()=0
virtual std::vector< const char * >	getRequiredExtensions ()=0
const bool	isValidationLayersEnabled ()
virtual VkBool32	isDeviceSupportingSufaceKHR (VkPhysicalDevice device, int i)=0
virtual std::vector< const char * >	getRequiredDeviceExtensions ()=0
virtual SwapChainSupportDetails	querySwapChainSupport (vk::PhysicalDevice device)=0
bool	isSwapChainNeeded ()
bool	isIndepFromWindowDimension ()
virtual const bool	useOpenXR ()
virtual bool	isDepthRecquired ()
virtual bool	isSynchroWithSemaphore ()=0
virtual void	getFrameBufferSize (int *w, int *h, vk::PhysicalDevice &pDevice)=0
void	setWrapper (VulkanWrapper *wraps)
virtual void	checkForCorrectSize ()=0
virtual vk::Buffer	getRenderingDestination ()
virtual vk::Image	getSwapchainImage (int view, int index)
virtual vk::Image	getDepthSwapchainImage (int view, int index)
glm::vec3	getTranslation ()
void	setRotation (float v0, float v1, float v3)
glm::vec3	getRotation ()
virtual std::vector< vk::Image >	getBlitDestinations (int view, int elem)
virtual std::vector< vk::Extent2D >	getBlitExtentDestinations (int view, int elem)
virtual std::vector< vk::Semaphore >	getSemaphoreWait (int view, int elem)
virtual std::vector< vk::Semaphore >	getSemaphoreSignal (int view, int elem)
vk::ImageView	getSwapchainImageView (int view, int elem)
vk::ImageView	getDepthSwapchainImageView (int view, int elem)
int	getViewNumber ()
int	getAttachmentSize ()
virtual vk::Extent2D	getSwapchainExtent (int view)
virtual vk::Format	getSwapchainFormat (int view)
virtual vk::Format	getDepthSwapchainFormat (int view)
virtual void	resetOrigin ()=0
virtual	~WindowAbstract ()=default

Additional Inherited Members
Protected Attributes inherited from WindowAbstract
std::vector< std::unique_ptr< SwapchainAbstract > >	swapchains
std::vector< std::unique_ptr< SwapchainAbstract > >	depthSwapchains
bool	separateFromWindowDim = false
const std::vector< const char * >	deviceExtensions
VulkanWrapper *	wrapper = nullptr
glm::vec3	currentRotation = {0,0,0}
glm::vec3	currentTranslation = {0,0,0}
bool	needSwapchain = true
bool	initialised = false
const bool	enableValidationLayers = false
bool	qualibrationMode = false
int	selectedCamera = -1

Detailed Description

The class that represents a window created with the GLFW library.

The class encapsulate all the operation linked to the use of the GLFW library that allow us to create a window on the computer screen. Using it we only have one view to render. This class also receive the keyboard input that allow the user to translate and rotate himself in the scene. It is also possible to reset the origin and to adjust the parameters of the input camera using these input keyboard Exact key are printed in the console at the beginning of the application

Definition at line 37 of file WindowGLFW.h.

Member Function Documentation

checkForCorrectSize()

void WindowGLFW::checkForCorrectSize ( )

overridevirtual

Check if the window is of correct size, wait until it is

Implements WindowAbstract.

Definition at line 170 of file WindowGLFW.cpp.

{
    int width = 0, height = 0;
    glfwGetFramebufferSize(window, &width, &height);
    while (width == 0 || height == 0) {
        glfwGetFramebufferSize(window, &width, &height);
        glfwWaitEvents();
    }
}

cleanUp()

void WindowGLFW::cleanUp ( )

overridevirtual

Clean up the ressources

Implements WindowAbstract.

Definition at line 70 of file WindowGLFW.cpp.

{
    glfwDestroyWindow(window);
    glfwTerminate();
}

cleanUpSurface()

void WindowGLFW::cleanUpSurface ( )

overridevirtual

Clean up the surface

Implements WindowAbstract.

Definition at line 76 of file WindowGLFW.cpp.

{
    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);
}

continueInit()

void WindowGLFW::continueInit ( )

overridevirtual

Continue the initialization process

Implements WindowAbstract.

Definition at line 58 of file WindowGLFW.cpp.

{
    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);
    }
}

createSurface()

void WindowGLFW::createSurface ( )

overridevirtual

Create the surface

Implements WindowAbstract.

Definition at line 126 of file WindowGLFW.cpp.

{
    if (glfwCreateWindowSurface(wrapper->context.instance, window, nullptr, &surface) != VK_SUCCESS) {
        throw std::runtime_error("failed to create window surface!");
    }
}

framebufferResizeCallback()

void WindowGLFW::framebufferResizeCallback

(

)

Callback function called when the window is resize. May trigger some recreation of the swapchain when it is the case

Definition at line 498 of file WindowGLFW.cpp.

{
    wrapper->framebufferResized = true;
}

getFrameBufferSize()

void WindowGLFW::getFrameBufferSize ( int *  w, int *  h, vk::PhysicalDevice &  pDevice  )

overridevirtual

Return the current size of the framebuffer

Implements WindowAbstract.

Definition at line 180 of file WindowGLFW.cpp.

{
    glfwGetFramebufferSize(window, w, h);
}

getRequiredDeviceExtensions()

std::vector< const char * > WindowGLFW::getRequiredDeviceExtensions ( )

overridevirtual

Return the list ofdevice extensions required by the GLFW library

Implements WindowAbstract.

Definition at line 154 of file WindowGLFW.cpp.

{
    return deviceExtensions;
}

getRequiredExtensions()

std::vector< const char * > WindowGLFW::getRequiredExtensions ( )

overridevirtual

Return the list of instance extensions required by the GLFW library

Implements WindowAbstract.

Definition at line 133 of file WindowGLFW.cpp.

{
    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;
}

initWindow()

void WindowGLFW::initWindow ( )

overridevirtual

Start the initialization of the GLFW window

Implements WindowAbstract.

Definition at line 24 of file WindowGLFW.cpp.

{
    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;
 
}

inputKeyCallback()

void WindowGLFW::inputKeyCallback	(	GLFWwindow *	window,
		int	key,
		int	scancode,
		int	action,
		int	mode
	)

Callback function that is activated when a key receive an action

Definition at line 256 of file WindowGLFW.cpp.

{
    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);
                }
            }
        }
    }
}

isDeviceSupportingSufaceKHR()

VkBool32 WindowGLFW::isDeviceSupportingSufaceKHR ( VkPhysicalDevice  device, int  i  )

overridevirtual

Test if the device support the surface that have been created

Implements WindowAbstract.

Definition at line 147 of file WindowGLFW.cpp.

{
    VkBool32 presentSupport = false;
    vkGetPhysicalDeviceSurfaceSupportKHR(device, i, surface, &presentSupport);
    return presentSupport;
}

isSynchroWithSemaphore()

bool WindowGLFW::isSynchroWithSemaphore ( )

overridevirtual

Return because synchronization is done with semaphore in this mode

Implements WindowAbstract.

Definition at line 185 of file WindowGLFW.cpp.

{
    return true;
}

mainLoop()

void WindowGLFW::mainLoop ( VulkanDrawing *  vulkanDrawing )

overridevirtual

Main rendering loop

Implements WindowAbstract.

Definition at line 88 of file WindowGLFW.cpp.

{
    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();
            }
        }
    }
}

printInputCommands()

void WindowGLFW::printInputCommands

(

)

Print the key used by the system and their effect. The exact keys printed will change depending of the layout

Definition at line 192 of file WindowGLFW.cpp.

{
    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");
}

querySwapChainSupport()

SwapChainSupportDetails WindowGLFW::querySwapChainSupport ( vk::PhysicalDevice  device )

overridevirtual

Query what type of swapchain the surface support

Implements WindowAbstract.

Definition at line 159 of file WindowGLFW.cpp.

{
    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;
}

resetOrigin()

void WindowGLFW::resetOrigin ( )

overridevirtual

Reset the origin by putting current rotation and translation to 0

Implements WindowAbstract.

Definition at line 503 of file WindowGLFW.cpp.

{
#ifdef HVT_UDP_CONTROL
    mutex.lock();
#endif
    currentTranslation = { 0,0,0 };
    currentRotation = { 0,0,0 };
#ifdef HVT_UDP_CONTROL
    mutex.unlock();
#endif
}

---

The documentation for this class was generated from the following files:

• WindowGLFW.h
• WindowGLFW.cpp