Using only colors that were defined for renderer

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, ...)
+    virtual void drawText(unsigned int x, unsigned int y, float scale, const float color[4], const char *s, ...)
         __attribute__((format(printf, 6, 0))) = 0;
 
     unsigned int mWidth;

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, ...)
+    virtual void drawText(unsigned int x, unsigned int y, float scale, const float color[4], const char *s, ...)
         __attribute__((format(printf, 6, 0)));
 
 private:

include/global.h

 #ifndef _GLOBAL_H_
 #define _GLOBAL_H_
 
+const float BLACK[]       = {  0.0f,  0.0f,  0.0f, 1.0f };
+const float DIM_WHITE[]   = {  0.5f,  0.5f,  0.5f, 1.0f };
+const float WHITE[]       = {  1.0f,  1.0f,  1.0f, 1.0f };
+const float RED[]         = {  1.0f,  0.0f,  0.0f, 1.0f };
+const float GREEN[]       = {  0.0f,  1.0f,  0.0f, 1.0f };
+const float NEXT_PURPLE[] = {  0.3f,  0.3f,  0.5f, 1.0f };
+const float OR_BLUE[]     = {  0.5f,  0.7f,  1.0f, 1.0f };
+const float PINK[]        = {  1.0f,  0.0f,  1.0f, 1.0f };
+const float YELLOW[]      = {  1.0f,  1.0f,  0.0f, 1.0f };
+const float CYAN[]        = {  0.0f,  1.0f,  1.0f, 1.0f };
+
 typedef enum {
     menuAction = 0,
     consoleAction, // menu and console should always be the first two items
     int w;
     int h;
     float scale;
-    unsigned char color[4];
+    float color[4];
 } WindowString;
 
 #endif

src/Console.cpp

 #endif
 
 #include "config.h"
+#include "global.h"
 #include "Console.h"
 #include "main.h"
 #include "utils/strings.h"
 
 void Console::display() {
     Window *window = gOpenRaider->mWindow;
-    unsigned char color[4] = {0xFF, 0xFF, 0xFF, 0xFF};
 
     if (mVisible) {
         // Calculate line drawing geometry
             scrollIndicator = 100;
         }
 
-        gOpenRaider->mWindow->drawText(10, 10, 0.70f, color,
+        gOpenRaider->mWindow->drawText(10, 10, 0.70f, OR_BLUE,
                 "%s uptime %lus scroll %d%%", VERSION, systemTimerGet() / 1000, scrollIndicator);
 
         // Draw output log
         }
         for (int i = 0; i < end; i++) {
             gOpenRaider->mWindow->drawText(10, ((i + drawOffset) * lineSteps) + firstLine,
-                    0.75f, color, "%s", mHistory[i + historyOffset - mLineOffset]);
+                    0.75f, OR_BLUE, "%s", mHistory[i + historyOffset - mLineOffset]);
         }
 
         // Draw current input
         if ((mInputBufferPointer > 0) && (mInputBuffer[0] != '\0')) {
-            gOpenRaider->mWindow->drawText(10, inputLine, 0.75f, color, "> %s", mInputBuffer);
+            gOpenRaider->mWindow->drawText(10, inputLine, 0.75f, OR_BLUE, "> %s", mInputBuffer);
         } else {
-            gOpenRaider->mWindow->drawText(10, inputLine, 0.75f, color, ">");
+            gOpenRaider->mWindow->drawText(10, inputLine, 0.75f, OR_BLUE, ">");
         }
 
         //! \todo display the current mPartialInput. The UTF-8 segfaults SDL-TTF, somehow?

src/Menu.cpp

 #endif
 
 #include "config.h"
+#include "global.h"
 #include "main.h"
 #include "Menu.h"
 #include "utils/strings.h"
 
     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
-            color[1] = 0x42;
-            color[2] = 0x42;
-        }
-        gOpenRaider->mWindow->drawText(25, 100 + (25 * i), 0.75f, color, "%s", map);
+        if ((i + min) == (int)mCursor)
+            gOpenRaider->mWindow->drawText(25, 100 + (25 * i), 0.75f, RED, "%s", map);
+        else
+            gOpenRaider->mWindow->drawText(25, 100 + (25 * i), 0.75f, OR_BLUE, "%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) {
-            gOpenRaider->mWindow->drawText(25, (window->mHeight / 2) - 20, 0.75f, color, "Generating map list...");
+            gOpenRaider->mWindow->drawText(25, (window->mHeight / 2) - 20, 0.75f, OR_BLUE, "Generating map list...");
         } else {
             if (gOpenRaider->mMapList.size() == 0) {
-                gOpenRaider->mWindow->drawText(25, (window->mHeight / 2) - 20, 0.75f, color, "No maps found! See README.md");
+                gOpenRaider->mWindow->drawText(25, (window->mHeight / 2) - 20, 0.75f, RED, "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);
-                color[0] = color[1] = color[2] = 0x00;
-                gOpenRaider->mWindow->drawText(40, 35, 0.75f, color, "Play");
-                color[0] = color[1] = color[2] = 0xFF;
+                gOpenRaider->mWindow->drawText(40, 35, 0.75f, BLACK, "Play");
 
                 displayMapList();
             }

src/Render.cpp

 #include "Emitter.h"
 #endif
 
+#include "global.h"
 #include "main.h"
 #include "Game.h"
 #include "OpenRaider.h"
 #include "Render.h"
 
-//! \fixme Should be changed
-#define LARA gOpenRaider->mGame->mLara
-#define gWorld gOpenRaider->mGame->mWorld
-
-// Colors
-const float BLACK[]       = {  0.0f,  0.0f,  0.0f, 1.0f };
-const float DIM_WHITE[]   = {  0.5f,  0.5f,  0.5f, 1.0f };
-const float WHITE[]       = {  1.0f,  1.0f,  1.0f, 1.0f };
-const float RED[]         = {  1.0f,  0.0f,  0.0f, 1.0f };
-const float GREEN[]       = {  0.0f,  1.0f,  0.0f, 1.0f };
-const float NEXT_PURPLE[] = {  0.3f,  0.3f,  0.5f, 1.0f };
-//const float OR_BLUE[]     = {  0.5f,  0.7f,  1.0f, 1.0f };
-const float PINK[]        = {  1.0f,  0.0f,  1.0f, 1.0f };
-const float YELLOW[]      = {  1.0f,  1.0f,  0.0f, 1.0f };
-const float CYAN[]        = {  0.0f,  1.0f,  1.0f, 1.0f };
-
 ViewVolume gViewVolume; /* View volume for frustum culling */
 
 void Render::drawLoadScreen()
 
 void Render::ClearWorld()
 {
-    LARA = NULL;
+    gOpenRaider->mGame->mLara = NULL;
 
     mRoomRenderList.clear();
 
 
     index = -1;
 
-    if (LARA)
+    if (gOpenRaider->mGame->mLara)
     {
         float yaw;
         int sector;
         float camOffsetH = 0.0f;
 
 
-        switch (LARA->moveType)
+        switch (gOpenRaider->mGame->mLara->moveType)
         {
             case worldMoveType_fly:
             case worldMoveType_noClipping:
                 break;
         }
 
-        curPos[0] = LARA->pos[0];
-        curPos[1] = LARA->pos[1];
-        curPos[2] = LARA->pos[2];
-        yaw = LARA->angles[1];
+        curPos[0] = gOpenRaider->mGame->mLara->pos[0];
+        curPos[1] = gOpenRaider->mGame->mLara->pos[1];
+        curPos[2] = gOpenRaider->mGame->mLara->pos[2];
+        yaw = gOpenRaider->mGame->mLara->angles[1];
 
-        index = LARA->room;
+        index = gOpenRaider->mGame->mLara->room;
 
         // Mongoose 2002.08.24, New 3rd person camera hack
         camPos[0] = curPos[0];
         camPos[0] -= (1024.0f * sinf(yaw));
         camPos[2] -= (1024.0f * cosf(yaw));
 
-        sector = gWorld.getSector(index, camPos[0], camPos[2]);
+        sector = gOpenRaider->mGame->mWorld.getSector(index, camPos[0], camPos[2]);
 
         // Handle camera out of world
-        if (sector < 0 || gWorld.isWall(index, sector))
+        if (sector < 0 || gOpenRaider->mGame->mWorld.isWall(index, sector))
         {
             camPos[0] = curPos[0] + (64.0f * sinf(yaw));
             camPos[1] -= 64.0f;
     updateViewVolume();
 
     // Let's see the LoS -- should be event controled
-    if (LARA)
+    if (gOpenRaider->mGame->mLara)
     {
-        //      SkeletalModel *mdl = (SkeletalModel *)LARA->tmpHook;
+        //      SkeletalModel *mdl = (SkeletalModel *)gOpenRaider->mGame->mLara->tmpHook;
 
         // Draw in solid colors
         glDisable(GL_TEXTURE_2D);
         glDisable(GL_CULL_FACE);
 
-        if (LARA->state == 64) // eWeaponFire
+        if (gOpenRaider->mGame->mLara->state == 64) // eWeaponFire
         {
             vec3_t u, v; //, s, t;
 
-            // Center of LARA
+            // Center of gOpenRaider->mGame->mLara
             u[0] = curPos[0];
             u[1] = curPos[1] - 512.0f;
             u[2] = curPos[2];
 
-            // Location LARA is aiming at?  ( Not finished yet )
-            v[0] = u[0] + (9000.0f * sinf(LARA->angles[1]));
-            v[1] = u[1] + (9000.0f * sinf(LARA->angles[2]));
-            v[2] = u[2] + (9000.0f * cosf(LARA->angles[1]));
+            // Location gOpenRaider->mGame->mLara is aiming at?  ( Not finished yet )
+            v[0] = u[0] + (9000.0f * sinf(gOpenRaider->mGame->mLara->angles[1]));
+            v[1] = u[1] + (9000.0f * sinf(gOpenRaider->mGame->mLara->angles[2]));
+            v[2] = u[2] + (9000.0f * cosf(gOpenRaider->mGame->mLara->angles[1]));
 
             // Test tracing of aim
             renderTrace(0, u, v); // v = target
         }
 
-        entity_t *route = LARA->master;
+        entity_t *route = gOpenRaider->mGame->mLara->master;
 
         while (route)
         {
     {
         entity_t *e;
         std::vector<entity_t *> entityRenderList;
-        std::vector<entity_t *> *entities = gWorld.getEntities();
+        std::vector<entity_t *> *entities = gOpenRaider->mGame->mWorld.getEntities();
 
         for (unsigned int i = 0; i < entities->size(); i++)
         {
             e = entities->at(i);
 
             // Mongoose 2002.03.26, Don't show lara to it's own player
-            if (!e || e == LARA)
+            if (!e || e == gOpenRaider->mGame->mLara)
             {
                 continue;
             }
 
 void Render::drawSkyMesh(float scale)
 {
-    skeletal_model_t *model = gWorld.getModel(mSkyMesh);
+    skeletal_model_t *model = gOpenRaider->mGame->mWorld.getModel(mSkyMesh);
 
 
     if (!model)
     glTranslated(0.0, 1000.0, 0.0);
     glScaled(scale, scale, scale);
     //drawModel(model);
-    //drawModelMesh(gWorld.getMesh(mSkyMesh), );
+    //drawModelMesh(gOpenRaider->mGame->mWorld.getMesh(mSkyMesh), );
     glPopMatrix();
     glEnable(GL_DEPTH_TEST);
 }
 
 
     // Draw lara or other player model ( move to entity rendering method )
-    if (mFlags & Render::fViewModel && LARA && LARA->tmpHook)
+    if (mFlags & Render::fViewModel && gOpenRaider->mGame->mLara && gOpenRaider->mGame->mLara->tmpHook)
     {
-        SkeletalModel *mdl = static_cast<SkeletalModel *>(LARA->tmpHook);
+        SkeletalModel *mdl = static_cast<SkeletalModel *>(gOpenRaider->mGame->mLara->tmpHook);
 
         if (mdl)
         {
 
             // Mongoose 2002.03.22, Test 'idle' aniamtions
-            if (!LARA->moving)
+            if (!gOpenRaider->mGame->mLara->moving)
             {
                 frame = mdl->getIdleAnimation();
 
         glRotated(gOpenRaider->mGame->mCamera->getYaw(), 0, 1, 0);
         glTranslated(0, 500, 1200);
 #else
-        glTranslated(LARA->pos[0], LARA->pos[1], LARA->pos[2]);
+        glTranslated(gOpenRaider->mGame->mLara->pos[0], gOpenRaider->mGame->mLara->pos[1], gOpenRaider->mGame->mLara->pos[2]);
         glRotated(gOpenRaider->mGame->mCamera->getYaw(), 0, 1, 0);
 #endif
 
-        drawModel(static_cast<SkeletalModel *>(LARA->tmpHook));
+        drawModel(static_cast<SkeletalModel *>(gOpenRaider->mGame->mLara->tmpHook));
         glPopMatrix();
     }
 
     {
         std::vector<sprite_seq_t *> *sprites;
 
-        sprites = gWorld.getSprites();
+        sprites = gOpenRaider->mGame->mWorld.getSprites();
 
         for (unsigned int i = 0; i < sprites->size(); i++)
         {
 
                 if (tag2)
                 {
-                    drawModelMesh(gWorld.getMesh(tag2->mesh), Render::skeletalMesh);
+                    drawModelMesh(gOpenRaider->mGame->mWorld.getMesh(tag2->mesh), Render::skeletalMesh);
                 }
             }
         }
                     {
                         glPushMatrix();
                         glTranslatef(mdl->ponyOff2, 0.0, 0.0);
-                        drawModelMesh(gWorld.getMesh(mdl->ponytailMeshId + i),
+                        drawModelMesh(gOpenRaider->mGame->mWorld.getMesh(mdl->ponytailMeshId + i),
                                 Render::skeletalMesh);
                         glPopMatrix();
 
                         glPushMatrix();
                         glTranslatef(-mdl->ponyOff2, 0.0, 0.0);
-                        drawModelMesh(gWorld.getMesh(mdl->ponytailMeshId + i),
+                        drawModelMesh(gOpenRaider->mGame->mWorld.getMesh(mdl->ponytailMeshId + i),
                                 Render::skeletalMesh);
                         glPopMatrix();
                     }
                     else
                     {
-                        drawModelMesh(gWorld.getMesh(mdl->ponytailMeshId + i),
+                        drawModelMesh(gOpenRaider->mGame->mWorld.getMesh(mdl->ponytailMeshId + i),
                                 Render::skeletalMesh);
                     }
                 }
             }
         }
 
-        drawModelMesh(gWorld.getMesh(tag->mesh), Render::skeletalMesh);
+        drawModelMesh(gOpenRaider->mGame->mWorld.getMesh(tag->mesh), Render::skeletalMesh);
     }
 
     // Cycle frames ( cheap hack from old ent state based system )
     if (!mesh)
         return;
 
-    r_mesh = gWorld.getMesh(mesh->index);
+    r_mesh = gOpenRaider->mGame->mWorld.getMesh(mesh->index);
 
     if (!r_mesh)
         return;
         return;
     }
 
-    model = gWorld.getModel(index);
+    model = gOpenRaider->mGame->mWorld.getModel(index);
 
     if (model)
     {

src/WindowSDL.cpp

     assert(mInit == true);
 
     SDL_Color color;
-    color.r = s->color[0];
-    color.g = s->color[1];
-    color.b = s->color[2];
-    color.a = s->color[3];
+    color.r = (unsigned char)(s->color[0] * 255.0f);
+    color.g = (unsigned char)(s->color[1] * 255.0f);
+    color.b = (unsigned char)(s->color[2] * 255.0f);
+    color.a = (unsigned char)(s->color[3] * 255.0f);
 
     SDL_Surface *surface = TTF_RenderUTF8_Blended(mFont, s->text, color);
     if (surface == NULL) {
     SDL_FreeSurface(surface);
 }
 
-void WindowSDL::drawText(unsigned int x, unsigned int y, float scale, unsigned char *color, const char *s, ...) {
+void WindowSDL::drawText(unsigned int x, unsigned int y, float scale, const float color[4], const char *s, ...) {
     va_list args;
     va_start(args, s);
     vsnprintf(tempText.text, 256, s, args);