GLUT windowing working more or less

ChangeLog.md

 
 ## OpenRaider (0.1.3) xythobuz <xythobuz@xythobuz.de>
 
+    [ 20141008 ]
+    * Added freeGLUT windowing system to use if SDL2 is not available. Not yet working 100%.
+
     [ 20141007 ]
     * Set all RunTime vars to sensible defaults, so OpenRaider can try to start
       without a config file (a font is still required!)

README.md

 
 This is a fork of the [OpenRaider](http://openraider.sourceforge.net) Open Source implementation of the classic Tomb Raider Game Engine. The original project was abandoned in 2003.
 
-This fork aims to get OpenRaider in a more usable state, maybe one day even being able to play the old Tomb Raider games flawlessly...
+This fork aims to get OpenRaider in a more usable state, maybe one day even being able to play the old Tomb Raider games flawlessly, while bringing the code to modern standards.
 
 Visit the IRC Channel `#OpenRaider` on `chat.freenode.net`. [Webchat](http://webchat.freenode.net/?channels=%23OpenRaider).
 
-If you just want to see OpenRaider doing something on your Mac, without installing any of the dependencies needed to build OpenRaider, grab the Mac App Bundle from the [most recent release](https://github.com/xythobuz/OpenRaider/releases).
-
 It seems as if OpenRaider will currently only work on Little-Endian platforms. This is not nice and will hopefully be fixed in the future!
 
 [![Flattr this git repo](http://api.flattr.com/button/flattr-badge-large.png)](https://flattr.com/submit/auto?user_id=xythobuz&url=https://github.com/xythobuz/OpenRaider&title=OpenRaider&language=&tags=github&category=software)
 
 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...
+
 ## Building
 
 Do a standard cmake out-of-source build to get a debug configuration and then run the resulting executable:
 * [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)
 
 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)

include/Window.h

 
     virtual bool getTextInput() = 0;
 
-    virtual void delay(unsigned int ms) = 0;
-
     virtual void swapBuffersGL() = 0;
 
     virtual unsigned int getWidth();

include/WindowGLUT.h

 class WindowGLUT : public Window {
 public:
 
-    /*!
-     * \brief Constructs an object of WindowGLUT
-     */
     WindowGLUT();
 
-    /*!
-     * \brief Deconstructs an object of WindowGLUT
-     */
-    virtual ~WindowGLUT();
-
     virtual void setSize(unsigned int width, unsigned int height);
 
     virtual void setFullscreen(bool fullscreen);
 
     virtual bool getTextInput();
 
-    virtual void delay(unsigned int ms);
-
     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

include/WindowSDL.h

 
     virtual bool getTextInput();
 
-    virtual void delay(unsigned int ms);
-
     virtual void swapBuffersGL();
 
 private:

src/CMakeLists.txt

     endif (SDL2TTF_FOUND)
 else (SDL2_FOUND AND NOT FORCE_GLUT)
     # Add freeglut Library
-    find_package (GLUT)
-    if (GLUT_FOUND)
-        include_directories (SYSTEM ${GLUT_INCLUDE_DIR})
-        set (LIBS ${LIBS} ${GLUT_LIBRARY})
-    endif (GLUT_FOUND)
+    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)
 
 # Add OpenAL Library
         set (OpenRaider_CXX_FLAGS "${OpenRaider_CXX_FLAGS} -DUSING_SDL_FONT")
     endif (SDL2TTF_FOUND)
 else (SDL2_FOUND AND NOT FORCE_GLUT)
-    if (GLUT_FOUND)
+    if (FREEGLUT_FOUND)
         set (SRCS ${SRCS} "WindowGLUT.cpp")
         set (OpenRaider_CXX_FLAGS "${OpenRaider_CXX_FLAGS} -DUSING_GLUT")
-    else (GLUT_FOUND)
+    else (FREEGLUT_FOUND)
         message (FATAL_ERROR "SDL2 or freeGLUT are required!")
-    endif (GLUT_FOUND)
+    endif (FREEGLUT_FOUND)
 endif (SDL2_FOUND AND NOT FORCE_GLUT)
 
 if (PNG_FOUND)

src/WindowGLUT.cpp

  * \author xythobuz
  */
 
-#include <cstdio>
-#include <ctime>
+#include <cstring>
+
+#include <GL/freeglut.h>
 
 #include "global.h"
 #include "RunTime.h"
 #include "utils/strings.h"
 #include "WindowGLUT.h"
 
+static int lastMouseX = 0;
+static int lastMouseY = 0;
+
 WindowGLUT::WindowGLUT() {
     mInit = false;
     mWidth = DEFAULT_WIDTH;
     mTextInput = false;
 }
 
-WindowGLUT::~WindowGLUT() {
-    if (mInit) {
-    }
-}
-
 void WindowGLUT::setSize(unsigned int width, unsigned int height) {
     assert(width > 0);
     assert(height > 0);
     mHeight = height;
 
     if (mInit == true) {
-        resizeGL();
+        glutReshapeWindow(width, height);
     }
 }
 
     mFullscreen = fullscreen;
 
     if (mInit == true) {
+        if (mFullscreen)
+            glutFullScreen();
+        else
+            glutLeaveFullScreen();
     }
 }
 
     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");
+    glutInit(&argc, argv);
+    glutInitWindowSize(mWidth, mHeight);
+    glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH);
+    glutCreateWindow(VERSION);
 
-    mInit = true;
+    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;
 }
 
     return mTextInput;
 }
 
-void WindowGLUT::delay(unsigned int ms) {
+void WindowGLUT::swapBuffersGL() {
     assert(mInit == true);
+    glutSwapBuffers();
 }
 
-void WindowGLUT::swapBuffersGL() {
-    assert(mInit == true);
+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);
+        }
+    } else {
+        KeyboardButton b = convertAsciiButton(key);
+        UI::handleKeyboard(b, true);
+    }
+}
+
+void WindowGLUT::keyboardUpCallback(unsigned char key, int x, int y) {
+    if (!getWindow().getTextInput()) {
+        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;
+    }
 }
 

src/WindowSDL.cpp

     return mTextInput;
 }
 
-void WindowSDL::delay(unsigned int ms) {
-    assert(mInit == true);
-
-    SDL_Delay(ms);
-}
-
 void WindowSDL::swapBuffersGL() {
     assert(mInit == true);