Removed WindowGLUT, added WindowGLFW

ChangeLog.md

     [ 20141217 ]
     * Introduced texel-offset in getUV() in an attempt to fix the texture-bleeding
     * Mesh is now called RoomMesh
+    * Removed non-functional GLUT windowing implementation
+    * Created new windowing implementation using GLFW3
 
     [ 20141216 ]
     * Allow navigation with a free-floating Camera

README.md

 
 Sound support is optional, however. If cmake can’t find OpenAL and ALUT, Audio will be deactivated. If you want to explicitly deactivate it, call cmake with `-DENABLE_AUDIO=NO`.
 
-There is also a rudimentary windowing implementation using freeGLUT. It will be used if GLUT is found instead of SDL2, or if you call cmake with `-DFORCE_GLUT=YES`. Be aware that your experience will not be as nice as with SDL2...
+There is also a windowing implementation using GLFW. It will be used if GLFW is found instead of SDL2, or if you call cmake with `-DFORCE_GLFW=YES`. Be aware that your experience will not be as nice as with SDL2...
 
 ## Building
 
 * [FindSSE](https://gitorious.org/vc/vc/source/a1d8b9fc31060d870386613cc72319546c850b87:cmake/FindSSE.cmake)
 * [GetGitRevisionDescription.cmake](https://github.com/rpavlik/cmake-modules/blob/master/GetGitRevisionDescription.cmake)
 * [GetGitRevisionDescription.cmake.in](https://github.com/rpavlik/cmake-modules/blob/master/GetGitRevisionDescription.cmake.in)
-* [FindFreeGLUT](https://github.com/PDAL/PDAL/blob/master/cmake/modules/FindFreeGLUT.cmake)
 * [FindGLM] (https://github.com/g-truc/glm/blob/master/util/FindGLM.cmake)
+* [FindGLFW] (https://github.com/PixarAnimationStudios/OpenSubdiv/blob/master/cmake/FindGLFW.cmake)
 
 See the respective files in `cmake` for their licensing.
 

cmake/FindFreeGLUT.cmake

-# Copyright (C) 2007-2009 LuaDist.
-# Created by Peter Kapec <kapecp@gmail.com>
-# Redistribution and use of this file is allowed according to the terms of the MIT license.
-# For details see the COPYRIGHT file distributed with LuaDist.
-#	Note:
-#		Searching headers and libraries is very simple and is NOT as powerful as scripts
-#		distributed with CMake, because LuaDist defines directories to search for.
-#		Everyone is encouraged to contact the author with improvements. Maybe this file
-#		becomes part of CMake distribution sometimes.
-
-# - Find FreeGLUT
-# Find the native FreeGLUT headers and libraries.
-#
-#  FREEGLUT_INCLUDE_DIRS - where to find freeglut.h, etc.
-#  FREEGLUT_LIBRARIES    - List of libraries when using FreeGLUT.
-#  FREEGLUT_FOUND        - True if FreeGLUT found.
-
-# 2014-10-08 Thomas Buck <xythobuz@xythobuz.de>:
-#   Fix to work on Mac OS X
-
-# Look for the header file.
-FIND_PATH(FREEGLUT_INCLUDE_DIR NAMES GL/freeglut.h
-    PATHS /opt/local/include
-)
-
-# Look for the library.
-IF(APPLE)
-    # We don't want to use the GLUT shipping with OS X
-    FIND_LIBRARY(FREEGLUT_LIBRARY NAMES freeglut glut
-        PATHS /opt/local/lib
-        NO_DEFAULT_PATH
-    )
-ELSE(APPLE)
-    FIND_LIBRARY(FREEGLUT_LIBRARY NAMES freeglut)
-ENDIF(APPLE)
-
-# Handle the QUIETLY and REQUIRED arguments and set FREEGLUT_FOUND to TRUE if all listed variables are TRUE.
-INCLUDE(FindPackageHandleStandardArgs)
-FIND_PACKAGE_HANDLE_STANDARD_ARGS(FREEGLUT DEFAULT_MSG FREEGLUT_LIBRARY FREEGLUT_INCLUDE_DIR)
-
-# Copy the results to the output variables.
-IF(FREEGLUT_FOUND)
-	SET(FREEGLUT_LIBRARIES ${FREEGLUT_LIBRARY})
-	SET(FREEGLUT_INCLUDE_DIRS ${FREEGLUT_INCLUDE_DIR})
-ELSE(FREEGLUT_FOUND)
-	SET(FREEGLUT_LIBRARIES)
-	SET(FREEGLUT_INCLUDE_DIRS)
-ENDIF(FREEGLUT_FOUND)
-
-MARK_AS_ADVANCED(FREEGLUT_INCLUDE_DIRS FREEGLUT_LIBRARIES)

cmake/FindGLFW.cmake

+#
+#   Copyright 2013 Pixar
+#
+#   Licensed under the Apache License, Version 2.0 (the "Apache License")
+#   with the following modification; you may not use this file except in
+#   compliance with the Apache License and the following modification to it:
+#   Section 6. Trademarks. is deleted and replaced with:
+#
+#   6. Trademarks. This License does not grant permission to use the trade
+#      names, trademarks, service marks, or product names of the Licensor
+#      and its affiliates, except as required to comply with Section 4(c) of
+#      the License and to reproduce the content of the NOTICE file.
+#
+#   You may obtain a copy of the Apache License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the Apache License with the above modification is
+#   distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+#   KIND, either express or implied. See the Apache License for the specific
+#   language governing permissions and limitations under the Apache License.
+#
+
+# Try to find GLFW library and include path.
+# Once done this will define
+#
+# GLFW_FOUND
+# GLFW_INCLUDE_DIR
+# GLFW_LIBRARIES
+#
+
+find_path( GLFW_INCLUDE_DIR 
+    NAMES
+        GL/glfw.h
+        GLFW/glfw3.h
+    PATHS
+        "${GLFW_LOCATION}/include"
+        "$ENV{GLFW_LOCATION}/include"
+        "$ENV{PROGRAMFILES}/GLFW/include"
+        "${OPENGL_INCLUDE_DIR}"
+        /usr/openwin/share/include
+        /usr/openwin/include
+        /usr/X11R6/include
+        /usr/include/X11
+        /opt/graphics/OpenGL/include
+        /opt/graphics/OpenGL/contrib/libglfw
+        /usr/local/include
+        /usr/include/GL
+        /usr/include
+    DOC 
+        "The directory where GL/glfw.h resides"
+)
+
+if (WIN32)
+    if(CYGWIN)
+        find_library( GLFW_glfw_LIBRARY 
+            NAMES
+                glfw32
+            PATHS
+                "${GLFW_LOCATION}/lib"
+                "${GLFW_LOCATION}/lib/x64"
+                "$ENV{GLFW_LOCATION}/lib"
+                "${OPENGL_LIBRARY_DIR}"
+                /usr/lib
+                /usr/lib/w32api
+                /usr/local/lib
+                /usr/X11R6/lib
+            DOC 
+                "The GLFW library"
+        )
+    else()
+        find_library( GLFW_glfw_LIBRARY
+            NAMES 
+                glfw32 
+                glfw32s 
+                glfw
+                glfw3
+            PATHS
+                "${GLFW_LOCATION}/lib"
+                "${GLFW_LOCATION}/lib/x64"
+                "${GLFW_LOCATION}/lib-msvc110"
+                "$ENV{GLFW_LOCATION}/lib"
+                "$ENV{GLFW_LOCATION}/lib/x64"
+                "$ENV{GLFW_LOCATION}/lib-msvc110"
+                "${PROJECT_SOURCE_DIR}/extern/glfw/bin"
+                "${PROJECT_SOURCE_DIR}/extern/glfw/lib"
+                "$ENV{PROGRAMFILES}/GLFW/lib"
+                "${OPENGL_LIBRARY_DIR}"
+            DOC 
+                "The GLFW library"
+        )
+    endif()
+else ()
+    if (APPLE)
+        find_library( GLFW_glfw_LIBRARY glfw
+            NAMES 
+                glfw
+                glfw3
+            PATHS
+                "${GLFW_LOCATION}/lib"
+                "${GLFW_LOCATION}/lib/cocoa"
+                "$ENV{GLFW_LOCATION}/lib"
+                "$ENV{GLFW_LOCATION}/lib/cocoa"
+                /usr/local/lib
+        )
+        set(GLFW_cocoa_LIBRARY "-framework Cocoa" CACHE STRING "Cocoa framework for OSX")
+        set(GLFW_corevideo_LIBRARY "-framework CoreVideo" CACHE STRING "CoreVideo framework for OSX")
+        set(GLFW_iokit_LIBRARY "-framework IOKit" CACHE STRING "IOKit framework for OSX")
+    else ()
+        # (*)NIX
+        
+        find_package(X11 REQUIRED)
+        
+        if(NOT X11_Xrandr_FOUND)
+            message(FATAL_ERROR "Xrandr library not found - required for GLFW")
+        endif()
+
+        if(NOT X11_xf86vmode_FOUND)
+            message(FATAL_ERROR "xf86vmode library not found - required for GLFW")
+        endif()
+
+        if(NOT X11_Xcursor_FOUND)
+            message(FATAL_ERROR "Xcursor library not found - required for GLFW")
+        endif()
+
+        list(APPEND GLFW_x11_LIBRARY "${X11_Xrandr_LIB}" "${X11_Xxf86vm_LIB}" "${X11_Xcursor_LIB}" -lrt)
+
+        find_library( GLFW_glfw_LIBRARY
+            NAMES 
+                glfw
+                glfw3
+            PATHS
+                "${GLFW_LOCATION}/lib"
+                "$ENV{GLFW_LOCATION}/lib"
+                "${GLFW_LOCATION}/lib/x11"
+                "$ENV{GLFW_LOCATION}/lib/x11"
+                /usr/lib64
+                /usr/lib
+                /usr/lib/${CMAKE_LIBRARY_ARCHITECTURE}
+                /usr/local/lib64
+                /usr/local/lib
+                /usr/local/lib/${CMAKE_LIBRARY_ARCHITECTURE}
+                /usr/openwin/lib
+                /usr/X11R6/lib
+            DOC 
+                "The GLFW library"
+        )
+    endif (APPLE)
+endif (WIN32)
+
+set( GLFW_FOUND "NO" )
+
+if(GLFW_INCLUDE_DIR)
+
+    if(GLFW_glfw_LIBRARY)
+        set( GLFW_LIBRARIES "${GLFW_glfw_LIBRARY}"
+                            "${GLFW_x11_LIBRARY}"
+                            "${GLFW_cocoa_LIBRARY}"
+                            "${GLFW_iokit_LIBRARY}"
+                            "${GLFW_corevideo_LIBRARY}" )
+        set( GLFW_FOUND "YES" )
+        set (GLFW_LIBRARY "${GLFW_LIBRARIES}")
+        set (GLFW_INCLUDE_PATH "${GLFW_INCLUDE_DIR}")
+    endif(GLFW_glfw_LIBRARY)
+
+
+    # Tease the GLFW_VERSION numbers from the lib headers
+    function(parseVersion FILENAME VARNAME)
+            
+        set(PATTERN "^#define ${VARNAME}.*$")
+        
+        file(STRINGS "${GLFW_INCLUDE_DIR}/${FILENAME}" TMP REGEX ${PATTERN})
+        
+        string(REGEX MATCHALL "[0-9]+" TMP ${TMP})
+        
+        set(${VARNAME} ${TMP} PARENT_SCOPE)
+        
+    endfunction()
+
+
+    if(EXISTS "${GLFW_INCLUDE_DIR}/GL/glfw.h")
+
+        parseVersion(GL/glfw.h GLFW_VERSION_MAJOR)
+        parseVersion(GL/glfw.h GLFW_VERSION_MINOR)
+        parseVersion(GL/glfw.h GLFW_VERSION_REVISION)
+
+    elseif(EXISTS "${GLFW_INCLUDE_DIR}/GLFW/glfw3.h")
+
+        parseVersion(GLFW/glfw3.h GLFW_VERSION_MAJOR)
+        parseVersion(GLFW/glfw3.h GLFW_VERSION_MINOR)
+        parseVersion(GLFW/glfw3.h GLFW_VERSION_REVISION)
+ 
+    endif()
+
+    if(${GLFW_VERSION_MAJOR} OR ${GLFW_VERSION_MINOR} OR ${GLFW_VERSION_REVISION})
+        set(GLFW_VERSION "${GLFW_VERSION_MAJOR}.${GLFW_VERSION_MINOR}.${GLFW_VERSION_REVISION}")
+        set(GLFW_VERSION_STRING "${GLFW_VERSION}")
+        mark_as_advanced(GLFW_VERSION)
+    endif()
+    
+endif(GLFW_INCLUDE_DIR)
+
+include(FindPackageHandleStandardArgs)
+
+find_package_handle_standard_args(GLFW 
+    REQUIRED_VARS
+        GLFW_INCLUDE_DIR
+        GLFW_LIBRARIES
+    VERSION_VAR
+        GLFW_VERSION
+)
+
+mark_as_advanced(
+  GLFW_INCLUDE_DIR
+  GLFW_LIBRARIES
+  GLFW_glfw_LIBRARY
+  GLFW_cocoa_LIBRARY
+)
+
+

include/config.h.in

 
 #cmakedefine USING_AL
 #cmakedefine USING_PNG
+#cmakedefine USING_SDL
+#cmakedefine USING_SDL_FONT
+#cmakedefine USING_GLFW
 
 #cmakedefine HAVE_EXECINFO_H
 #cmakedefine HAVE_BACKTRACE

include/global.h

 // Globally include OpenGL header
 #ifdef __APPLE__
 #include <OpenGL/gl3.h>
-#else
+#else // __APPLE__
 #ifdef _WIN32
 #include <windows.h>
-#endif
+#endif // _WIN32
+//! \todo gl3 header?
 #include <GL/gl.h>
 #include <GL/glext.h>
-#endif
+#endif // __APPLE__
 
 // If available, use our own assert that prints the call stack
 #if defined(HAVE_EXECINFO_H) && defined(HAVE_BACKTRACE) && defined(HAVE_BACKTRACE_SYMBOLS)

include/system/WindowGLFW.h

+/*!
+ * \file include/WindowGLFW.h
+ * \brief GLFW windowing implementation
+ *
+ * \author xythobuz
+ */
+
+#ifndef _WINDOW_GLFW_H_
+#define _WINDOW_GLFW_H_
+
+#include <GLFW/glfw3.h>
+
+#include "system/Window.h"
+
+class WindowGLFW : public Window {
+  public:
+
+    WindowGLFW();
+    virtual ~WindowGLFW();
+
+    virtual void setSize(unsigned int width, unsigned int height);
+
+    virtual void setFullscreen(bool fullscreen);
+
+    virtual void setMousegrab(bool grab);
+
+    virtual int initialize();
+
+    virtual void eventHandling();
+
+    virtual void setTextInput(bool on);
+
+    virtual void swapBuffersGL();
+
+  private:
+    static void errorCallback(int error, const char* desc);
+    static void sizeCallback(GLFWwindow* w, int width, int height);
+    static void cursorCallback(GLFWwindow* w, double xpos, double ypos);
+    static void keyCallback(GLFWwindow* w, int key, int scancode, int action, int mods);
+    static void buttonCallback(GLFWwindow* w, int button, int action, int mods);
+    static void scrollCallback(GLFWwindow* w, double xoffset, double yoffset);
+
+    static KeyboardButton convertAsciiButton(int key);
+
+    GLFWwindow* mWindow;
+};
+
+#endif
+

include/system/WindowGLUT.h

-/*!
- * \file include/WindowGLUT.h
- * \brief GLUT windowing implementation
- *
- * \author xythobuz
- */
-
-#ifndef _WINDOW_GLUT_H_
-#define _WINDOW_GLUT_H_
-
-#include "system/Window.h"
-
-/*!
- * \brief GLUT windowing implementation
- */
-class WindowGLUT : public Window {
-  public:
-
-    WindowGLUT();
-
-    virtual void setSize(unsigned int width, unsigned int height);
-
-    virtual void setFullscreen(bool fullscreen);
-
-    virtual void setMousegrab(bool grab);
-
-    virtual int initialize();
-
-    virtual void eventHandling();
-
-    virtual void setTextInput(bool on);
-
-    virtual void swapBuffersGL();
-
-  private:
-    static void reshapeCallback(int width, int height);
-    static void keyboardCallback(unsigned char key, int x, int y);
-    static void keyboardUpCallback(unsigned char key, int x, int y);
-    static void specialCallback(int key, int x, int y);
-    static void specialUpCallback(int key, int x, int y);
-    static void mouseCallback(int button, int state, int x, int y);
-    static void motionCallback(int x, int y);
-    static void mouseWheelCallback(int wheel, int direction, int x, int y);
-
-    static KeyboardButton convertAsciiButton(unsigned char key);
-    static KeyboardButton convertKeyCode(int key);
-};
-
-#endif
-

src/CMakeLists.txt

 # Options
 option (ENABLE_AUDIO "Enable Sound Output" YES)
-option (FORCE_GLUT "Use freeGLUT even if SDL2 was found" NO)
+option (FORCE_GLFW "Use GLFW even if SDL2 was found" NO)
 
 # Add OpenGL Library
 find_package (OpenGL REQUIRED)
 
 # Add SDL2 Library
 find_package (SDL2)
-if (SDL2_FOUND AND NOT FORCE_GLUT)
+if (SDL2_FOUND AND NOT FORCE_GLFW)
     include_directories (SYSTEM ${SDL2_INCLUDE_DIR})
     set (LIBS ${LIBS} ${SDL2_LIBRARY})
 
         include_directories (SYSTEM ${SDL2TTF_INCLUDE_DIR})
         set (LIBS ${LIBS} ${SDL2TTF_LIBRARY})
     endif (SDL2TTF_FOUND)
-else (SDL2_FOUND AND NOT FORCE_GLUT)
-    # Add freeglut Library
-    find_package (FREEGLUT)
-    if (FREEGLUT_FOUND)
-        include_directories (SYSTEM ${FREEGLUT_INCLUDE_DIRS})
-        set (LIBS ${LIBS} ${FREEGLUT_LIBRARIES})
-    endif (FREEGLUT_FOUND)
-endif (SDL2_FOUND AND NOT FORCE_GLUT)
+else (SDL2_FOUND AND NOT FORCE_GLFW)
+    find_package (GLFW)
+    if (GLFW_FOUND)
+        include_directories (SYSTEM ${GLFW_INCLUDE_DIRS})
+        set (LIBS ${LIBS} ${GLFW_LIBRARIES})
+    endif (GLFW_FOUND)
+endif (SDL2_FOUND AND NOT FORCE_GLFW)
 
 # Add OpenAL Library
 find_package (OpenAL)
 endif (OPENAL_FOUND AND ALUT_FOUND AND ENABLE_AUDIO)
 
 # Select available Windowing library
-if (SDL2_FOUND AND NOT FORCE_GLUT)
-    set (OpenRaider_CXX_FLAGS "${OpenRaider_CXX_FLAGS} -DUSING_SDL")
+if (SDL2_FOUND AND NOT FORCE_GLFW)
+    set (USING_GLFW FALSE)
+    set (USING_SDL TRUE)
     if (SDL2TTF_FOUND)
-        set (OpenRaider_CXX_FLAGS "${OpenRaider_CXX_FLAGS} -DUSING_SDL_FONT")
+        set (USING_SDL_FONT TRUE)
+    else (SDL2TTF_FOUND)
+        set (USING_SDL_FONT FALSE)
     endif (SDL2TTF_FOUND)
-else (SDL2_FOUND AND NOT FORCE_GLUT)
-    if (FREEGLUT_FOUND)
-        set (OpenRaider_CXX_FLAGS "${OpenRaider_CXX_FLAGS} -DUSING_GLUT")
-    else (FREEGLUT_FOUND)
-        message (FATAL_ERROR "SDL2 or freeGLUT are required!")
-    endif (FREEGLUT_FOUND)
-endif (SDL2_FOUND AND NOT FORCE_GLUT)
+else (SDL2_FOUND AND NOT FORCE_GLFW)
+    set (USING_SDL FALSE)
+    set (USING_SDL_FONT FALSE)
+    if (GLFW_FOUND)
+        set (USING_GLFW TRUE)
+    else (GLFW_FOUND)
+        set (USING_GLFW FALSE)
+        message (FATAL_ERROR "SDL2 or GLFW are required!")
+    endif (GLFW_FOUND)
+endif (SDL2_FOUND AND NOT FORCE_GLFW)
 
 if (PNG_FOUND)
     set (USING_PNG TRUE)

src/main.cpp

 
 #ifdef USING_SDL
 #include "system/WindowSDL.h"
-#elif defined(USING_GLUT)
-#include "system/WindowGLUT.h"
+#elif defined(USING_GLFW)
+#include "system/WindowGLFW.h"
 #else
 #error No Windowing Library selected!
 #endif
 
 #ifdef USING_SDL
     gWindow.reset(new WindowSDL());
-#elif defined(USING_GLUT)
-    gWindow.reset(new WindowGLUT());
+#elif defined(USING_GLFW)
+    gWindow.reset(new WindowGLFW());
 #endif
 
     Command::fillCommandList();

src/system/CMakeLists.txt

 set (SYS_SRCS ${SYS_SRCS} "Window.cpp" "../../include/system/Window.h")
 
 # Select available Sound library
-if (OPENAL_FOUND AND ALUT_FOUND AND ENABLE_AUDIO)
+if (USING_AL AND ENABLE_AUDIO)
     set (SYS_SRCS ${SYS_SRCS} "SoundAL.cpp" "../../include/system/SoundAL.h")
-else (OPENAL_FOUND AND ALUT_FOUND AND ENABLE_AUDIO)
+else (USING_AL AND ENABLE_AUDIO)
     message (STATUS "Disabled Sound support (no OpenAL and ALUT)!")
-endif (OPENAL_FOUND AND ALUT_FOUND AND ENABLE_AUDIO)
+endif (USING_AL AND ENABLE_AUDIO)
 
-# Select available Windowing library
-if (SDL2_FOUND AND NOT FORCE_GLUT)
+if (USING_SDL)
     set (SYS_SRCS ${SYS_SRCS} "WindowSDL.cpp" "../../include/system/WindowSDL.h")
-    if (SDL2TTF_FOUND)
-        set (SYS_SRCS ${SYS_SRCS} "FontSDL.cpp" "../../include/system/FontSDL.h")
-    endif (SDL2TTF_FOUND)
-else (SDL2_FOUND AND NOT FORCE_GLUT)
-    if (FREEGLUT_FOUND)
-        set (SYS_SRCS ${SYS_SRCS} "WindowGLUT.cpp" "../../include/system/WindowGLUT.h")
-    else (FREEGLUT_FOUND)
-        message (FATAL_ERROR "SDL2 or freeGLUT are required!")
-    endif (FREEGLUT_FOUND)
-endif (SDL2_FOUND AND NOT FORCE_GLUT)
+endif (USING_SDL)
+
+if (USING_SDL_FONT)
+    set (SYS_SRCS ${SYS_SRCS} "FontSDL.cpp" "../../include/system/FontSDL.h")
+endif (USING_SDL_FONT)
+
+if (USING_GLFW)
+    set (SYS_SRCS ${SYS_SRCS} "WindowGLFW.cpp" "../../include/system/WindowGLFW.h")
+endif (USING_GLFW)
 
 # Add library
 add_library (OpenRaider_system OBJECT ${SYS_SRCS})

src/system/WindowGLFW.cpp

+/*!
+ * \file src/WindowGLFW.cpp
+ * \brief GLFW windowing implementation
+ *
+ * \author xythobuz
+ */
+
+#include <cstring>
+
+#include "global.h"
+#include "Log.h"
+#include "RunTime.h"
+#include "UI.h"
+#include "utils/strings.h"
+#include "system/WindowGLFW.h"
+
+static int lastMouseX = 0;
+static int lastMouseY = 0;
+
+WindowGLFW::WindowGLFW() {
+    mInit = false;
+    mWidth = DEFAULT_WIDTH;
+    mHeight = DEFAULT_HEIGHT;
+    mFullscreen = false;
+    mMousegrab = false;
+    mTextInput = false;
+    mWindow = nullptr;
+}
+
+WindowGLFW::~WindowGLFW() {
+    if (mInit) {
+        if (mWindow) {
+            glfwDestroyWindow(mWindow);
+        }
+
+        glfwTerminate();
+    }
+}
+
+int WindowGLFW::initialize() {
+    assert(mInit == false);
+
+    glfwSetErrorCallback(WindowGLFW::errorCallback);
+    if (!glfwInit()) {
+        return -1;
+    }
+
+    glfwWindowHint(GLFW_SAMPLES, 4);
+    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
+    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
+    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
+    glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
+
+    mWindow = glfwCreateWindow(mWidth, mHeight, VERSION,
+                               mFullscreen ? glfwGetPrimaryMonitor() : nullptr, nullptr);
+    if (!mWindow) {
+        glfwTerminate();
+        return -2;
+    }
+
+    glfwMakeContextCurrent(mWindow);
+
+    glfwSetWindowSizeCallback(mWindow, WindowGLFW::sizeCallback);
+    glfwSetCursorPosCallback(mWindow, WindowGLFW::cursorCallback);
+    glfwSetKeyCallback(mWindow, WindowGLFW::keyCallback);
+    glfwSetMouseButtonCallback(mWindow, WindowGLFW::buttonCallback);
+    glfwSetScrollCallback(mWindow, WindowGLFW::scrollCallback);
+
+    mInit = true;
+    return 0;
+}
+
+void WindowGLFW::eventHandling() {
+    assert(mInit == true);
+
+    glfwPollEvents();
+
+    if (glfwWindowShouldClose(mWindow)) {
+        getRunTime().setRunning(false);
+    }
+
+    UI::eventsFinished();
+}
+
+void WindowGLFW::setSize(unsigned int width, unsigned int height) {
+    assert(width > 0);
+    assert(height > 0);
+
+    if (mInit) {
+        if ((mWidth != width) || (mHeight != height)) {
+            glfwSetWindowSize(mWindow, width, height);
+            getWindow().resizeGL();
+        }
+    }
+
+    mWidth = width;
+    mHeight = height;
+}
+
+void WindowGLFW::setFullscreen(bool fullscreen) {
+    mFullscreen = fullscreen;
+
+    //! \todo GLFW does not support toggling fullscreen?!
+}
+
+void WindowGLFW::setMousegrab(bool grab) {
+    mMousegrab = grab;
+
+    if (mInit == true) {
+        if (mMousegrab)
+            glfwSetInputMode(mWindow, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
+        else
+            glfwSetInputMode(mWindow, GLFW_CURSOR, GLFW_CURSOR_NORMAL);
+    }
+}
+
+void WindowGLFW::setTextInput(bool on) {
+    assert(mInit == true);
+    mTextInput = on;
+}
+
+void WindowGLFW::swapBuffersGL() {
+    assert(mInit == true);
+    glfwSwapBuffers(mWindow);
+}
+
+void WindowGLFW::errorCallback(int error, const char* desc) {
+    getLog() << "GLFW Error (" << error << "): " << desc << Log::endl;
+}
+
+void WindowGLFW::sizeCallback(GLFWwindow* w, int width, int height) {
+    getWindow().setSize(width, height);
+}
+
+void WindowGLFW::cursorCallback(GLFWwindow* w, double xpos, double ypos) {
+    int xrel = xpos - lastMouseX;
+    int yrel = ypos - lastMouseY;
+    UI::handleMouseMotion(xrel, yrel, xpos, ypos);
+    lastMouseX = xpos;
+    lastMouseY = ypos;
+}
+
+static bool modShift = false;
+static bool modControl = false;
+static bool modAlt = false;
+static bool modSuper = false;
+
+void WindowGLFW::keyCallback(GLFWwindow* w, int key, int scancode, int action, int mods) {
+    if (((mods & GLFW_MOD_SHIFT) != 0) != modShift) {
+        modShift = (mods & GLFW_MOD_SHIFT) != 0;
+        UI::handleKeyboard(leftshiftKey, modShift);
+    }
+
+    if (((mods & GLFW_MOD_CONTROL) != 0) != modControl) {
+        modControl = (mods & GLFW_MOD_CONTROL) != 0;
+        UI::handleKeyboard(leftctrlKey, modControl);
+    }
+
+    if (((mods & GLFW_MOD_ALT) != 0) != modAlt) {
+        modAlt = (mods & GLFW_MOD_ALT) != 0;
+        UI::handleKeyboard(leftaltKey, modAlt);
+    }
+
+    if (((mods & GLFW_MOD_SUPER) != 0) != modSuper) {
+        modSuper = (mods & GLFW_MOD_SUPER) != 0;
+        UI::handleKeyboard(leftguiKey, modSuper);
+    }
+
+    if (getWindow().getTextInput() && (action != GLFW_RELEASE)) {
+        //! \todo Handle text input properly!
+        if ((key >= '0') && (key <= '9')) {
+            char s[2] = { (char)key, '\0' };
+            UI::handleText(s, false);
+        } else if ((key >= 'A') && (key <= 'Z')) {
+            key = key - 'A' + 'a';
+            char s[2] = { (char)key, '\0' };
+            UI::handleText(s, false);
+            key = key - 'a' + 'A';
+        }
+    }
+
+    KeyboardButton b = convertAsciiButton(key);
+    UI::handleKeyboard(b, (action != GLFW_RELEASE));
+}
+
+void WindowGLFW::buttonCallback(GLFWwindow* w, int button, int action, int mods) {
+    if (((mods & GLFW_MOD_SHIFT) != 0) != modShift) {
+        modShift = (mods & GLFW_MOD_SHIFT) != 0;
+        UI::handleKeyboard(leftshiftKey, modShift);
+    }
+
+    if (((mods & GLFW_MOD_CONTROL) != 0) != modControl) {
+        modControl = (mods & GLFW_MOD_CONTROL) != 0;
+        UI::handleKeyboard(leftctrlKey, modControl);
+    }
+
+    if (((mods & GLFW_MOD_ALT) != 0) != modAlt) {
+        modAlt = (mods & GLFW_MOD_ALT) != 0;
+        UI::handleKeyboard(leftaltKey, modAlt);
+    }
+
+    if (((mods & GLFW_MOD_SUPER) != 0) != modSuper) {
+        modSuper = (mods & GLFW_MOD_SUPER) != 0;
+        UI::handleKeyboard(leftguiKey, modSuper);
+    }
+
+    KeyboardButton b;
+    switch (button) {
+        case GLFW_MOUSE_BUTTON_LEFT:
+            b = leftmouseKey;
+            break;
+
+        case GLFW_MOUSE_BUTTON_RIGHT:
+            b = rightmouseKey;
+            break;
+
+        case GLFW_MOUSE_BUTTON_MIDDLE:
+            b = middlemouseKey;
+            break;
+
+        default:
+            b = unknownKey;
+            break;
+    }
+
+    UI::handleMouseClick(lastMouseX, lastMouseY, b, (action == GLFW_RELEASE));
+}
+
+void WindowGLFW::scrollCallback(GLFWwindow* w, double xoffset, double yoffset) {
+    UI::handleMouseScroll(xoffset, yoffset);
+}
+
+KeyboardButton WindowGLFW::convertAsciiButton(int key) {
+    // Alphanumerics can be returned as is
+    if ((key >= '0') && (key <= '9')) {
+        return static_cast<KeyboardButton>(key);
+    } else if ((key >= 'A') && (key <= 'Z')) {
+        key = key - 'A' + 'a';
+        return static_cast<KeyboardButton>(key);
+    }
+
+    //! \fixme GLFW requires keyboard layout? Currently US is hard coded
+    switch (key) {
+        case ' ':
+            return spaceKey;
+
+        case '!':
+            return oneKey;
+
+        case '@':
+            return twoKey;
+
+        case '#':
+            return threeKey;
+
+        case '$':
+            return fourKey;
+
+        case '%':
+            return fiveKey;
+
+        case '^':
+            return sixKey;
+
+        case '&':
+            return sevenKey;
+
+        case '*':
+            return eightKey;
+
+        case '(':
+            return nineKey;
+
+        case ')':
+            return zeroKey;
+
+        case '"':
+        case '\'':
+            return quoteKey;
+
+        case '+':
+        case '=':
+            return equalsKey;
+
+        case ',':
+        case '<':
+            return commaKey;
+
+        case '-':
+        case '_':
+            return minusKey;
+
+        case '.':
+        case '>':
+            return dotKey;
+
+        case '/':
+        case '?':
+            return slashKey;
+
+        case ':':
+        case ';':
+            return semicolonKey;
+
+        case '[':
+        case '{':
+            return leftbracketKey;
+
+        case ']':
+        case '}':
+            return rightbracketKey;
+
+        case '\\':
+        case '|':
+            return backslashKey;
+
+        case '`':
+        case '~':
+            return backquoteKey;
+
+        case GLFW_KEY_TAB:
+            return tabKey;
+
+        case GLFW_KEY_BACKSPACE:
+            return backspaceKey;
+
+        case GLFW_KEY_ENTER:
+            return enterKey;
+
+        case GLFW_KEY_ESCAPE:
+            return escapeKey;
+
+        case GLFW_KEY_F1:
+            return f1Key;
+
+        case GLFW_KEY_F2:
+            return f2Key;
+
+        case GLFW_KEY_F3:
+            return f3Key;
+
+        case GLFW_KEY_F4:
+            return f4Key;
+
+        case GLFW_KEY_F5:
+            return f5Key;
+
+        case GLFW_KEY_F6:
+            return f6Key;
+
+        case GLFW_KEY_F7:
+            return f7Key;
+
+        case GLFW_KEY_F8:
+            return f8Key;
+
+        case GLFW_KEY_F9:
+            return f9Key;
+
+        case GLFW_KEY_F10:
+            return f10Key;
+
+        case GLFW_KEY_F11:
+            return f11Key;
+
+        case GLFW_KEY_F12:
+            return f12Key;
+
+        case GLFW_KEY_LEFT:
+            return leftKey;
+
+        case GLFW_KEY_UP:
+            return upKey;
+
+        case GLFW_KEY_RIGHT:
+            return rightKey;
+
+        case GLFW_KEY_DOWN:
+            return downKey;
+
+        case GLFW_KEY_PAGE_UP:
+            return pageupKey;
+
+        case GLFW_KEY_PAGE_DOWN:
+            return pagedownKey;
+
+        case GLFW_KEY_HOME:
+            return homeKey;
+
+        case GLFW_KEY_END:
+            return endKey;
+
+        case GLFW_KEY_INSERT:
+            return insertKey;
+
+        default:
+            return unknownKey;
+    }
+}
+

src/system/WindowGLUT.cpp

-/*!
- * \file src/WindowGLUT.cpp
- * \brief GLUT windowing implementation
- *
- * \author xythobuz
- */
-
-#include <cstring>
-
-#include <GL/freeglut.h>
-
-#include "global.h"
-#include "RunTime.h"
-#include "UI.h"
-#include "utils/strings.h"
-#include "system/WindowGLUT.h"
-
-//! \todo Modifier keys currently don't create keyboard events...
-
-static int lastMouseX = 0;
-static int lastMouseY = 0;
-
-WindowGLUT::WindowGLUT() {
-    mInit = false;
-    mWidth = DEFAULT_WIDTH;
-    mHeight = DEFAULT_HEIGHT;
-    mFullscreen = false;
-    mMousegrab = false;
-    mTextInput = false;
-}
-
-void WindowGLUT::setSize(unsigned int width, unsigned int height) {
-    assert(width > 0);
-    assert(height > 0);
-
-    mWidth = width;
-    mHeight = height;
-
-    if (mInit == true) {
-        glutReshapeWindow(width, height);
-    }
-}
-
-void WindowGLUT::setFullscreen(bool fullscreen) {
-    mFullscreen = fullscreen;
-
-    if (mInit == true) {
-        if (mFullscreen)
-            glutFullScreen();
-        else
-            glutLeaveFullScreen();
-    }
-}
-
-void WindowGLUT::setMousegrab(bool grab) {
-    mMousegrab = grab;
-
-    if (mInit == true) {
-        if (mMousegrab)
-            glutSetCursor(GLUT_CURSOR_NONE);
-        else
-            glutSetCursor(GLUT_CURSOR_INHERIT);
-    }
-}
-
-int WindowGLUT::initialize() {
-    assert(mInit == false);
-
-    int argc = 1;
-    char* argv[] = { new char[11], nullptr };
-    strcpy(argv[0], "OpenRaider");
-    glutInitWindowSize(mWidth, mHeight);
-    glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_ALPHA | GLUT_DEPTH | GLUT_MULTISAMPLE);
-    glutInitContextVersion(3, 3);
-    glutInitContextProfile(GLUT_CORE_PROFILE);
-    glutInit(&argc, argv);
-    glutCreateWindow(VERSION);
-
-    glutReshapeFunc(WindowGLUT::reshapeCallback);
-    glutKeyboardFunc(WindowGLUT::keyboardCallback);
-    glutKeyboardUpFunc(WindowGLUT::keyboardUpCallback);
-    glutSpecialFunc(WindowGLUT::specialCallback);
-    glutSpecialUpFunc(WindowGLUT::specialUpCallback);
-    glutMouseFunc(WindowGLUT::mouseCallback);
-    glutMotionFunc(WindowGLUT::motionCallback);
-    glutPassiveMotionFunc(WindowGLUT::motionCallback);
-    glutMouseWheelFunc(WindowGLUT::mouseWheelCallback);
-
-    delete [] argv[0];
-
-    mInit = true;
-    return 0;
-}
-
-void WindowGLUT::eventHandling() {
-    assert(mInit == true);
-
-    glutMainLoopEvent();
-
-    UI::eventsFinished();
-}
-
-void WindowGLUT::setTextInput(bool on) {
-    assert(mInit == true);
-    mTextInput = on;
-}
-
-void WindowGLUT::swapBuffersGL() {
-    assert(mInit == true);
-    glutSwapBuffers();
-}
-
-void WindowGLUT::reshapeCallback(int width, int height) {
-    getWindow().resizeGL();
-}
-
-// Note that the escape, backspace, and delete keys are generated as an ASCII character.
-void WindowGLUT::keyboardCallback(unsigned char key, int x, int y) {
-    if (getWindow().getTextInput()) {
-        if ((key >= ' ') && (key <= '~')) {
-            char s[2] = { static_cast<char>(key), '\0' };
-            UI::handleText(s, false);
-        }
-    }
-
-    KeyboardButton b = convertAsciiButton(key);
-    UI::handleKeyboard(b, true);
-}
-
-void WindowGLUT::keyboardUpCallback(unsigned char key, int x, int y) {
-    KeyboardButton b = convertAsciiButton(key);
-    UI::handleKeyboard(b, false);
-}
-
-void WindowGLUT::specialCallback(int key, int x, int y) {
-    KeyboardButton b = convertKeyCode(key);
-    UI::handleKeyboard(b, true);
-}
-
-void WindowGLUT::specialUpCallback(int key, int x, int y) {
-    KeyboardButton b = convertKeyCode(key);
-    UI::handleKeyboard(b, false);
-}
-
-void WindowGLUT::mouseCallback(int button, int state, int x, int y) {
-    KeyboardButton b;
-
-    switch (button) {
-        case GLUT_LEFT_BUTTON:
-            b = leftmouseKey;
-            break;
-
-        case GLUT_RIGHT_BUTTON:
-            b = rightmouseKey;
-            break;
-
-        case GLUT_MIDDLE_BUTTON:
-            b = middlemouseKey;
-            break;
-
-        default:
-            b = unknownKey;
-            break;
-    }
-
-    UI::handleMouseClick(x, y, b, (state == GLUT_UP));
-}
-
-// The x and y callback parameters indicate the mouse location in window relative coordinates.
-void WindowGLUT::motionCallback(int x, int y) {
-    int xrel = x - lastMouseX;
-    int yrel = y - lastMouseY;
-    UI::handleMouseMotion(xrel, yrel, x, y);
-    lastMouseX = x;
-    lastMouseY = y;
-
-    if (getWindow().getMousegrab()) {
-        lastMouseX = getWindow().getWidth() / 2;
-        lastMouseY = getWindow().getHeight() / 2;
-        glutWarpPointer(lastMouseX, lastMouseY);
-    }
-}
-
-void WindowGLUT::mouseWheelCallback(int wheel, int direction, int x, int y) {
-    int xrel = 0, yrel = 0;
-
-    if (wheel == 0)
-        yrel = direction;
-    else
-        xrel = direction;
-
-    UI::handleMouseScroll(xrel, yrel);
-}
-
-KeyboardButton WindowGLUT::convertAsciiButton(unsigned char key) {
-    // Convert Uppercase to Lowercase
-    if ((key >= 'A') && (key <= 'Z'))
-        key = key - 'A' + 'a';
-
-    // Alphanumerics can be returned as is
-    if (((key >= '0') && (key <= '9'))
-        || ((key >= 'a') && (key <= 'z'))) {
-        return static_cast<KeyboardButton>(key);
-    }
-
-    //! \fixme GLUT requires keyboard layout? Currently US is hard coded
-    switch (key) {
-        case ' ':
-            return spaceKey;
-
-        case '!':
-            return oneKey;
-
-        case '@':
-            return twoKey;
-
-        case '#':
-            return threeKey;
-
-        case '$':
-            return fourKey;
-
-        case '%':
-            return fiveKey;
-
-        case '^':
-            return sixKey;
-
-        case '&':
-            return sevenKey;
-
-        case '*':
-            return eightKey;
-
-        case '(':
-            return nineKey;
-
-        case ')':
-            return zeroKey;
-
-        case '"':
-        case '\'':
-            return quoteKey;
-
-        case '+':
-        case '=':
-            return equalsKey;
-
-        case ',':
-        case '<':
-            return commaKey;
-
-        case '-':
-        case '_':
-            return minusKey;
-
-        case '.':
-        case '>':
-            return dotKey;
-
-        case '/':
-        case '?':
-            return slashKey;
-
-        case ':':
-        case ';':
-            return semicolonKey;
-
-        case '[':
-        case '{':
-            return leftbracketKey;
-
-        case ']':
-        case '}':
-            return rightbracketKey;
-
-        case '\\':
-        case '|':
-            return backslashKey;
-
-        case '`':
-        case '~':
-            return backquoteKey;
-
-        case '\t':
-            return tabKey;
-
-        case 8: // Backspace
-            return backspaceKey;
-
-        case '\r':
-        case '\n':
-            return enterKey;
-
-        case 27: // Escape
-            return escapeKey;
-
-        default:
-            return unknownKey;
-    }
-}
-
-KeyboardButton WindowGLUT::convertKeyCode(int key) {
-    switch (key) {
-        case GLUT_KEY_F1:
-            return f1Key;
-
-        case GLUT_KEY_F2:
-            return f2Key;
-
-        case GLUT_KEY_F3:
-            return f3Key;
-
-        case GLUT_KEY_F4:
-            return f4Key;
-
-        case GLUT_KEY_F5:
-            return f5Key;
-
-        case GLUT_KEY_F6:
-            return f6Key;
-
-        case GLUT_KEY_F7:
-            return f7Key;
-
-        case GLUT_KEY_F8:
-            return f8Key;
-
-        case GLUT_KEY_F9:
-            return f9Key;
-
-        case GLUT_KEY_F10:
-            return f10Key;
-
-        case GLUT_KEY_F11:
-            return f11Key;
-
-        case GLUT_KEY_F12:
-            return f12Key;
-
-        case GLUT_KEY_LEFT:
-            return leftKey;
-
-        case GLUT_KEY_UP:
-            return upKey;
-
-        case GLUT_KEY_RIGHT:
-            return rightKey;
-
-        case GLUT_KEY_DOWN:
-            return downKey;
-
-        case GLUT_KEY_PAGE_UP:
-            return pageupKey;
-
-        case GLUT_KEY_PAGE_DOWN:
-            return pagedownKey;
-
-        case GLUT_KEY_HOME:
-            return homeKey;
-
-        case GLUT_KEY_END:
-            return endKey;
-
-        case GLUT_KEY_INSERT:
-            return insertKey;
-
-        default:
-            return unknownKey;
-    }
-}
-