Moved drawText into WindowSDL. Added Console.

include/Console.h

+/*!
+ * \file include/Console.h
+ * \brief Console 'overlay'
+ *
+ * \author xythobuz
+ */
+
+#ifndef _CONSOLE_H_
+#define _CONSOLE_H_
+
+#include "Window.h"
+
+/*!
+ * \brief Console 'overlay'
+ */
+class Console {
+public:
+
+    /*!
+     * \brief Constructs an object of Console
+     */
+    Console();
+
+    /*!
+     * \brief Deconstructs an object of Console
+     */
+    ~Console();
+
+    void setVisible(bool visible);
+
+    bool isVisible();
+
+    void display();
+
+    void handleKeyboard(KeyboardButton key, bool pressed);
+
+    void handleText(char *text, bool notFinished);
+
+private:
+
+    bool mVisible;
+};
+
+#endif

include/Menu.h

 
     void displayMapList();
 
-    void drawText(unsigned int x, unsigned int y, float scale, const char *s, ...) __attribute__((format(printf, 5, 0)));
-
     bool mVisible;
     unsigned int mCursor;
     unsigned int mMin;
 
     WindowString mainText;
-    WindowString tempText;
 };
 
 #endif

include/OpenRaider.h

 
 #include <vector>
 
+#include "Console.h"
 #include "Menu.h"
 #include "Sound.h"
 #include "Window.h"
     Window *mWindow;
     Sound *mSound;
     Menu *mMenu;
+    Console *mConsole;
 
     bool mMapListFilled;
     std::vector<char *> mMapList;

include/Window.h

 
     virtual void writeString(WindowString *s) = 0;
 
+    virtual void drawText(unsigned int x, unsigned int y, float scale, unsigned char *color, const char *s, ...)
+        __attribute__((format(printf, 6, 0))) = 0;
+
     unsigned int mWidth;
     unsigned int mHeight;
 

include/WindowSDL.h

 
     virtual void writeString(WindowString *s);
 
+    virtual void drawText(unsigned int x, unsigned int y, float scale, unsigned char *color, const char *s, ...)
+        __attribute__((format(printf, 6, 0)));
+
 private:
 
     SDL_Window *mWindow;      //!< This is the pointer to the SDL surface
     GLuint mFontTexture;
 
     bool mTextInput;
+
+    WindowString tempText;
 };
 
 #endif

src/CMakeLists.txt

 #################################################################
 
 # Set Source files
+set (SRCS ${SRCS} "Console.cpp")
 set (SRCS ${SRCS} "main.cpp")
 set (SRCS ${SRCS} "Menu.cpp")
 set (SRCS ${SRCS} "OpenRaider.cpp")

src/Console.cpp

+/*!
+ * \file src/Console.cpp
+ * \brief Console 'overlay'
+ *
+ * \author xythobuz
+ */
+
+#ifdef __APPLE__
+#include <OpenGL/gl.h>
+#include <OpenGL/glu.h>
+#else
+#include <GL/gl.h>
+#include <GL/glu.h>
+#endif
+
+#include "config.h"
+#include "main.h"
+#include "Console.h"
+#include "utils/strings.h"
+
+Console::Console() {
+    mVisible = false;
+}
+
+Console::~Console() {
+}
+
+void Console::setVisible(bool visible) {
+    mVisible = visible;
+    gOpenRaider->mWindow->setTextInput(mVisible);
+}
+
+bool Console::isVisible() {
+    return mVisible;
+}
+
+void Console::display() {
+    Window *window = gOpenRaider->mWindow;
+    unsigned char color[4] = {0xFF, 0xFF, 0xFF, 0xFF};
+
+    if (mVisible) {
+        // Draw half-transparent *overlay*
+        glColor4f(0.0f, 0.0f, 0.0f, 0.5f);
+        glDisable(GL_TEXTURE_2D);
+        glRecti(0, 0, window->mWidth, window->mHeight / 2);
+        glEnable(GL_TEXTURE_2D);
+
+        gOpenRaider->mWindow->drawText(25, (window->mHeight / 4) - 20, 0.75f, color, "Console");
+    }
+}
+
+void Console::handleKeyboard(KeyboardButton key, bool pressed) {
+
+}
+
+void Console::handleText(char *text, bool notFinished) {
+    printf("Got %s (%s)\n", (notFinished ? "not finished" : "finished"));
+}
+

src/Menu.cpp

  * \author xythobuz
  */
 
-#include <cstdarg>
-
 #ifdef __APPLE__
 #include <OpenGL/gl.h>
 #include <OpenGL/glu.h>
     mainText.y = 10;
     mainText.w = 0;
     mainText.h = 0;
-
-    tempText.text = new char[256];
-    tempText.color[0] = 0xFF;
-    tempText.color[1] = 0xFF;
-    tempText.color[2] = 0xFF;
-    tempText.color[3] = 0xFF;
-    tempText.scale = 1.2f;
-    tempText.w = 0;
-    tempText.h = 0;
 }
 
 Menu::~Menu() {
     delete [] mainText.text;
-    delete [] tempText.text;
 }
 
 void Menu::setVisible(bool visible) {
     return mVisible;
 }
 
-void Menu::drawText(unsigned int x, unsigned int y, float scale, const char *s, ...) {
-    va_list args;
-    va_start(args, s);
-    vsnprintf(tempText.text, 256, s, args);
-    tempText.text[255] = '\0';
-    va_end(args);
-
-    tempText.scale = scale;
-    tempText.x = x;
-    tempText.y = y;
-    gOpenRaider->mWindow->writeString(&tempText);
-}
-
 void Menu::displayMapList() {
     // Estimate displayable number of items
     int items = (gOpenRaider->mWindow->mHeight - 110) / 25;
 
     for (int i = 0; i < (max - min); i++) {
         char *map = gOpenRaider->mMapList[i + min];
+        unsigned char color[4] = {0xFF, 0xFF, 0xFF, 0xFF};
         if ((i + min) == (int)mCursor) {
             // Less greem & red --> highlight in red
-            tempText.color[1] = 0x42;
-            tempText.color[2] = 0x42;
-        } else {
-            tempText.color[1] = 0xFF;
-            tempText.color[2] = 0xFF;
+            color[1] = 0x42;
+            color[2] = 0x42;
         }
-        drawText(25, 100 + (25 * i), 0.75f, "%s", map);
+        gOpenRaider->mWindow->drawText(25, 100 + (25 * i), 0.75f, color, "%s", map);
     }
 }
 
 void Menu::display() {
     Window *window = gOpenRaider->mWindow;
+    unsigned char color[4] = {0xFF, 0xFF, 0xFF, 0xFF};
 
     if (mVisible) {
         // Draw half-transparent *overlay*
         window->writeString(&mainText);
 
         if (!gOpenRaider->mMapListFilled) {
-            drawText(25, (window->mHeight / 2) - 20, 0.75f, "Generating map list...");
+            gOpenRaider->mWindow->drawText(25, (window->mHeight / 2) - 20, 0.75f, color, "Generating map list...");
         } else {
             if (gOpenRaider->mMapList.size() == 0) {
-                drawText(25, (window->mHeight / 2) - 20, 0.75f, "No maps found! See README.md");
+                gOpenRaider->mWindow->drawText(25, (window->mHeight / 2) - 20, 0.75f, color, "No maps found! See README.md");
             } else {
                 // draw *play button* above list
                 glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
                 glDisable(GL_TEXTURE_2D);
                 glRecti(25, 25, 100, 75);
                 glEnable(GL_TEXTURE_2D);
-                tempText.color[0] = 0x00;
-                tempText.color[1] = 0x00;
-                tempText.color[2] = 0x00;
-                drawText(40, 35, 0.75f, "Play");
-                tempText.color[0] = 0xFF;
-                tempText.color[1] = 0xFF;
-                tempText.color[2] = 0xFF;
+                color[0] = color[1] = color[2] = 0x00;
+                gOpenRaider->mWindow->drawText(40, 35, 0.75f, color, "Play");
+                color[0] = color[1] = color[2] = 0xFF;
 
                 displayMapList();
             }

src/OpenRaider.cpp

     mMapListFilled = false;
 
     mMenu = new Menu();
+    mConsole = new Console();
     mSound = new Sound();
     mWindow = new WindowSDL();
 
     if (mMenu)
         delete mMenu;
 
+    if (mConsole)
+        delete mConsole;
+
     if (mSound)
         delete mSound;
 
         glClear(GL_COLOR_BUFFER_BIT);
 
         mWindow->glEnter2D();
-
+        mConsole->display();
         mMenu->display();
-
         mWindow->glExit2D();
 
+        // Put on screen
         mWindow->swapBuffersGL();
 
         // Fill map list after first render pass,
     if ((keyBindings[menu] == key) && pressed) {
         mMenu->setVisible(!mMenu->isVisible());
     } else if (!mMenu->isVisible()) {
-        if (keyBindings[console] == key) {
-
-        } else if (keyBindings[forward] == key) {
+        if ((keyBindings[console] == key) && pressed) {
+            mConsole->setVisible(!mConsole->isVisible());
+        } else if (!mConsole->isVisible()) {
+            if (keyBindings[forward] == key) {
 
-        } else if (keyBindings[backward] == key) {
+            } else if (keyBindings[backward] == key) {
 
-        } else if (keyBindings[left] == key) {
+            } else if (keyBindings[left] == key) {
 
-        } else if (keyBindings[right] == key) {
+            } else if (keyBindings[right] == key) {
 
-        } else if (keyBindings[jump] == key) {
+            } else if (keyBindings[jump] == key) {
 
-        } else if (keyBindings[crouch] == key) {
+            } else if (keyBindings[crouch] == key) {
 
-        } else if (keyBindings[use] == key) {
+            } else if (keyBindings[use] == key) {
 
-        } else if (keyBindings[holster] == key) {
+            } else if (keyBindings[holster] == key) {
 
+            }
+        } else {
+            mConsole->handleKeyboard(key, pressed);
         }
     } else {
         mMenu->handleKeyboard(key, pressed);
 }
 
 void OpenRaider::handleText(char *text, bool notFinished) {
-
+    if ((mConsole->isVisible()) && (!mMenu->isVisible())) {
+        mConsole->handleText(text, notFinished);
+    }
 }
 
 void OpenRaider::handleMouseClick(unsigned int x, unsigned int y, MouseButton button, bool released) {

src/Window.cpp

 
 #include <cstdio>
 #include <cstring>
+#include <cstdarg>
 #include <assert.h>
 
 #ifdef __APPLE__

src/WindowSDL.cpp

 #elif !defined(__APPLE__)
     setDriver("/usr/lib/libGL.so.1");
 #endif
+
+    tempText.text = new char[256];
+    tempText.color[0] = 0xFF;
+    tempText.color[1] = 0xFF;
+    tempText.color[2] = 0xFF;
+    tempText.color[3] = 0xFF;
+    tempText.scale = 1.2f;
+    tempText.w = 0;
+    tempText.h = 0;
 }
 
 WindowSDL::~WindowSDL() {
 
     if (mFontName)
         delete [] mFontName;
+
+    if (tempText.text)
+        delete [] tempText.text;
 }
 
 void WindowSDL::setDriver(const char *driver) {
     SDL_FreeSurface(surface);
 }
 
+void WindowSDL::drawText(unsigned int x, unsigned int y, float scale, unsigned char *color, const char *s, ...) {
+    va_list args;
+    va_start(args, s);
+    vsnprintf(tempText.text, 256, s, args);
+    tempText.text[255] = '\0';
+    va_end(args);
+
+    tempText.scale = scale;
+    tempText.x = x;
+    tempText.y = y;
+    if (color) {
+        tempText.color[0] = color[0];
+        tempText.color[1] = color[1];
+        tempText.color[2] = color[2];
+        tempText.color[3] = color[3];
+    }
+    writeString(&tempText);
+}
+