Removed WindowGLUT, added WindowGLFW

ChangeLog.md

@@ -5,6 +5,8 @@
     [ 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

@@ -68,7 +68,7 @@ Linux Distributions will probably provide an ALUT library ready to install with
 
 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
 
@@ -180,8 +180,8 @@ There are some included cmake scripts:
 * [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

@@ -1,50 +0,0 @@
-# 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

@@ -0,0 +1,221 @@
+#
+#   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

@@ -20,6 +20,9 @@ extern const char* INSTALL_PREFIX;
 
 #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

@@ -70,13 +70,14 @@ typedef enum {
 // 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

@@ -0,0 +1,49 @@
+/*!
+ * \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

@@ -1,50 +0,0 @@
-/*!
- * \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

@@ -1,6 +1,6 @@
 # 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)
@@ -14,7 +14,7 @@ set (LIBS ${LIBS} ${ZLIB_LIBRARIES})
 
 # 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})
 
@@ -24,14 +24,13 @@ if (SDL2_FOUND AND NOT FORCE_GLUT)
         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)
@@ -97,18 +96,24 @@ else (OPENAL_FOUND AND ALUT_FOUND AND ENABLE_AUDIO)
 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

@@ -30,8 +30,8 @@
 
 #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
@@ -95,8 +95,8 @@ int main(int argc, char* argv[]) {
 
 #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

@@ -6,25 +6,23 @@ set (SYS_SRCS ${SYS_SRCS} "Sound.cpp" "../../include/system/Sound.h")
 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

@@ -0,0 +1,400 @@
+/*!
+ * \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

@@ -1,372 +0,0 @@
-/*!
- * \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;
-    }
-}
-