GLUT windowing working more or less

ChangeLog.md

@@ -2,6 +2,9 @@
 
 ## 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

@@ -4,12 +4,10 @@
 
 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)
@@ -61,6 +59,8 @@ 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...
+
 ## Building
 
 Do a standard cmake out-of-source build to get a debug configuration and then run the resulting executable:
@@ -168,6 +168,7 @@ 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)
 
 See the respective files in `cmake` for their licensing.
 

cmake/FindFreeGLUT.cmake

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

@@ -32,8 +32,6 @@ public:
 
     virtual bool getTextInput() = 0;
 
-    virtual void delay(unsigned int ms) = 0;
-
     virtual void swapBuffersGL() = 0;
 
     virtual unsigned int getWidth();

include/WindowGLUT.h

@@ -16,16 +16,8 @@
 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);
@@ -42,11 +34,20 @@ public:
 
     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

@@ -44,8 +44,6 @@ public:
 
     virtual bool getTextInput();
 
-    virtual void delay(unsigned int ms);
-
     virtual void swapBuffersGL();
 
 private:

src/CMakeLists.txt

@@ -26,11 +26,11 @@ if (SDL2_FOUND AND NOT FORCE_GLUT)
     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
@@ -106,12 +106,12 @@ if (SDL2_FOUND AND NOT FORCE_GLUT)
         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

@@ -5,8 +5,9 @@
  * \author xythobuz
  */
 
-#include <cstdio>
-#include <ctime>
+#include <cstring>
+
+#include <GL/freeglut.h>
 
 #include "global.h"
 #include "RunTime.h"
@@ -14,6 +15,9 @@
 #include "utils/strings.h"
 #include "WindowGLUT.h"
 
+static int lastMouseX = 0;
+static int lastMouseY = 0;
+
 WindowGLUT::WindowGLUT() {
     mInit = false;
     mWidth = DEFAULT_WIDTH;
@@ -23,11 +27,6 @@ WindowGLUT::WindowGLUT() {
     mTextInput = false;
 }
 
-WindowGLUT::~WindowGLUT() {
-    if (mInit) {
-    }
-}
-
 void WindowGLUT::setSize(unsigned int width, unsigned int height) {
     assert(width > 0);
     assert(height > 0);
@@ -36,7 +35,7 @@ void WindowGLUT::setSize(unsigned int width, unsigned int height) {
     mHeight = height;
 
     if (mInit == true) {
-        resizeGL();
+        glutReshapeWindow(width, height);
     }
 }
 
@@ -44,6 +43,10 @@ void WindowGLUT::setFullscreen(bool fullscreen) {
     mFullscreen = fullscreen;
 
     if (mInit == true) {
+        if (mFullscreen)
+            glutFullScreen();
+        else
+            glutLeaveFullScreen();
     }
 }
 
@@ -51,6 +54,10 @@ void WindowGLUT::setMousegrab(bool grab) {
     mMousegrab = grab;
 
     if (mInit == true) {
+        if (mMousegrab)
+            glutSetCursor(GLUT_CURSOR_NONE);
+        else
+            glutSetCursor(GLUT_CURSOR_INHERIT);
     }
 }
 
@@ -61,24 +68,40 @@ bool WindowGLUT::getMousegrab() {
 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;
 }
 
@@ -87,11 +110,270 @@ bool WindowGLUT::getTextInput() {
     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

@@ -460,12 +460,6 @@ bool WindowSDL::getTextInput() {
     return mTextInput;
 }
 
-void WindowSDL::delay(unsigned int ms) {
-    assert(mInit == true);
-
-    SDL_Delay(ms);
-}
-
 void WindowSDL::swapBuffersGL() {
     assert(mInit == true);