Using float for font colors. Better controller mapping.

ChangeLog.md

     [ 20140306 ]
     * Fixed LoaderTR1, can now also open the Unfinished Business levels
     * Walk key can now be used to increase free-camera movement speed
+    * Removed color definitions in global.h
+    * Font interface now using glm::vec4 float colors
+    * Hard-coded controller mapping now supports all available ActionEvents
 
     [ 20140305 ]
     * SoundAL now has more useful error message output.

include/Menu.h

 
     void setVisible(bool v) { visible = v; }
 
+    static const glm::vec4 textColor;
+    static const glm::vec4 selectedColor;
+
   protected:
 
     virtual void showDialog(std::string msg, std::string btn1, std::string btn2,

include/global.h

 
 void renderFrame();
 
-// Colors used where ever needed
-const unsigned char BLACK[]  = {   0,   0,   0, 255 };
-const unsigned char GREY[]   = { 128, 128, 128, 255 };
-const unsigned char WHITE[]  = { 255, 255, 255, 255 };
-const unsigned char RED[]    = { 255,   0,   0, 255 };
-const unsigned char GREEN[]  = {   0, 255,   0, 255 };
-const unsigned char PURPLE[] = {  77,  77, 128, 255 };
-const unsigned char BLUE[]   = { 128, 179, 255, 255 };
-const unsigned char PINK[]   = { 255,   0, 255, 255 };
-const unsigned char YELLOW[] = { 255, 255,   0, 255 };
-const unsigned char CYAN[]   = {   0, 255, 255, 255 };
-
 // Actions that can be bound to a key and sent to the game engine
 typedef enum {
     menuAction = 0,
     pageupKey, pauseKey, dotKey, rightaltKey, rightctrlKey, enterKey,
     rightguiKey, rightbracketKey, rightshiftKey, scrolllockKey,
     semicolonKey, slashKey, spaceKey, tabKey,
+
+    // Mouse
     leftmouseKey, middlemouseKey, rightmouseKey,
     fourthmouseKey, fifthmouseKey,
 

include/system/Font.h

     static unsigned int heightText(float scale, unsigned int maxWidth, std::string s);
 
     static void drawText(unsigned int x, unsigned int y, float scale,
-                         const unsigned char color[4], std::string s);
+                         glm::vec4 color, std::string s);
 
     static void drawTextWrapped(unsigned int x, unsigned int y, float scale,
-                                const unsigned char color[4], unsigned int maxWidth, std::string s);
+                                glm::vec4 color, unsigned int maxWidth, std::string s);
 
     static void drawTextCentered(unsigned int x, unsigned int y, float scale,
-                                 const unsigned char color[4], unsigned int width, std::string s);
+                                 glm::vec4 color, unsigned int width, std::string s);
 
     static void setShowFontBox(bool s) { showFontBox = s; }
     static bool getShowFontBox() { return showFontBox; }

include/system/FontImGui.h

     static unsigned int heightText(float scale, unsigned int maxWidth, std::string s);
 
     static void drawText(unsigned int x, unsigned int y, float scale,
-                         const unsigned char color[4], std::string s);
+                         glm::vec4 color, std::string s);
 
     static void drawTextWrapped(unsigned int x, unsigned int y, float scale,
-                                const unsigned char color[4], unsigned int maxWidth, std::string s);
+                                glm::vec4 color, unsigned int maxWidth, std::string s);
 };
 
 #endif

include/system/FontTRLE.h

     static unsigned int heightText(float scale, unsigned int maxWidth, std::string s);
 
     static void drawText(unsigned int x, unsigned int y, float scale,
-                         const unsigned char color[4], std::string s);
+                         glm::vec4 color, std::string s);
 
     static void drawTextWrapped(unsigned int x, unsigned int y, float scale,
-                                const unsigned char color[4], unsigned int maxWidth, std::string s);
+                                glm::vec4 color, unsigned int maxWidth, std::string s);
 
   private:
     static void setDefaultOffsets();

include/system/FontTTF.h

     static unsigned int heightText(float scale, unsigned int maxWidth, std::string s);
 
     static void drawText(unsigned int x, unsigned int y, float scale,
-                         const unsigned char color[4], std::string s);
+                         glm::vec4 color, std::string s);
     static void drawTextWrapped(unsigned int x, unsigned int y, float scale,
-                                const unsigned char color[4], unsigned int maxWidth, std::string s);
+                                glm::vec4 color, unsigned int maxWidth, std::string s);
 
   private:
     static int charIsMapped(int c);
     static int getQuad(int c, float* xpos, float* ypos, stbtt_aligned_quad* quad);
     static void drawTextInternal(unsigned int x, unsigned int y, float scale,
-                                 const unsigned char color[4], unsigned int maxWidth, std::string s,
+                                 glm::vec4 color, unsigned int maxWidth, std::string s,
                                  bool drawWrapped);
 
     static unsigned char* fontData;

include/utils/pixel.h

 #ifndef _UTILS_PIXEL_H_
 #define _UTILS_PIXEL_H_
 
-unsigned char* generateColorTexture(const unsigned char* rgba, unsigned int width,
+unsigned char* generateColorTexture(glm::vec4 rgba, unsigned int width,
                                     unsigned int height, unsigned int bpp);
 
 void argb2rgba32(unsigned char* image, unsigned int w, unsigned int h);

src/Menu.cpp

 #include "system/Font.h"
 #include "system/Window.h"
 
+const glm::vec4 Menu::textColor(0.5f, 0.7f, 1.0f, 1.0f);
+const glm::vec4 Menu::selectedColor(1.0f, 0.0f, 0.0f, 1.0f);
+
 void Menu::showDialog(std::string msg, std::string btn1, std::string btn2,
                       std::function<int (bool state)> callback) {
     // Only show one dialog at a time
         glEnable(GL_TEXTURE_2D);
         */
 
-        Font::drawTextWrapped(xOverlay + 10, yOverlay + 5, 1.0f, BLUE, w0, dialogText);
+        Font::drawTextWrapped(xOverlay + 10, yOverlay + 5, 1.0f, textColor, w0, dialogText);
         if (dialogButton2.length() > 0) {
             if ((w1 + w2) <= wMax) {
                 Font::drawTextWrapped(xOverlay + 10, yOverlay + 10 + h0, 1.0f,
-                                      dialogState ? BLUE : RED, w1, dialogButton1);
+                                      dialogState ? textColor : selectedColor, w1, dialogButton1);
                 Font::drawTextWrapped(xOverlay + 10 + w1, yOverlay + 10 + h0,
-                                      1.0f, dialogState ? RED : BLUE, w2, dialogButton2);
+                                      1.0f, dialogState ? selectedColor : textColor, w2, dialogButton2);
             } else {
                 Font::drawTextWrapped((Window::getSize().x - w1) / 2,
-                                      yOverlay + 10 + h0, 1.0f, dialogState ? BLUE : RED, w1, dialogButton1);
+                                      yOverlay + 10 + h0, 1.0f, dialogState ? textColor : selectedColor, w1, dialogButton1);
                 Font::drawTextWrapped((Window::getSize().x - w2) / 2,
-                                      yOverlay + 10 + h0 + h1, 1.0f, dialogState ? RED : BLUE, w2, dialogButton2);
+                                      yOverlay + 10 + h0 + h1, 1.0f, dialogState ? selectedColor : textColor, w2, dialogButton2);
             }
         } else {
             Font::drawTextWrapped((Window::getSize().x - w1) / 2,
-                                  yOverlay + 10 + h0, 1.0f, RED, w1, dialogButton1);
+                                  yOverlay + 10 + h0, 1.0f, selectedColor, w1, dialogButton1);
         }
     }
 }

src/MenuFolder.cpp

     if (!visible)
         return;
 
-    Font::drawTextCentered(0, 10, 1.2f, BLUE, Window::getSize().x, VERSION);
+    Font::drawTextCentered(0, 10, 1.2f, textColor, Window::getSize().x, VERSION);
 
     // Draw half-transparent overlay
     glm::vec4 color(0.0f, 0.0f, 0.0f, 0.75f);
                         color, TEXTURE_WHITE, TextureStorage::SYSTEM);
 
     // Draw heading
-    Font::drawTextCentered(0, 10, 1.2f, BLUE, Window::getSize().x, VERSION);
+    Font::drawTextCentered(0, 10, 1.2f, textColor, Window::getSize().x, VERSION);
 
     // Estimate displayable number of items
     int items = (Window::getSize().y - 60) / 25;
     for (long i = mMin; (i < (mMin + items))
          && (i < (mapFolder->folderCount() + mapFolder->fileCount() + 1)); i++) {
         if (i == 0) {
-            Font::drawText(25, 50, 0.75f, (mCursor == i) ? RED : BLUE, "..");
+            Font::drawText(25, 50, 0.75f, (mCursor == i) ? selectedColor : textColor, "..");
         } else {
             Font::drawText(25, (unsigned int)(50 + (25 * (i - mMin))), 0.75f,
-                           (mCursor == i) ? RED : BLUE,
+                           (mCursor == i) ? selectedColor : textColor,
                            ((i - 1) < mapFolder->folderCount()) ?
                            (mapFolder->getFolder(i - 1).getName() + "/")
                            : mapFolder->getFile(i - 1 - mapFolder->folderCount()).getName());

src/TextureManager.cpp

         mTextureIdsSystem.push_back(id);
     }
 
-    unsigned char* image = generateColorTexture(WHITE, 32, 32, 32);
+    unsigned char* image = generateColorTexture(glm::vec4(1.0f, 1.0f, 1.0f, 1.0f), 32, 32, 32);
     int res = loadBufferSlot(image, 32, 32, ColorMode::RGBA, 32, TextureStorage::SYSTEM, TEXTURE_WHITE,
                              false);
     delete [] image;

src/UI.cpp

             Game::handleAction(jumpAction, released);
         } else if (button == bButton) {
             Game::handleAction(crouchAction, released);
+        } else if (button == xButton) {
+            Game::handleAction(useAction, released);
+        } else if (button == yButton) {
+            Game::handleAction(holsterAction, released);
         } else if (button == padUp) {
             Game::handleAction(forwardAction, released);
         } else if (button == padDown) {
             Game::handleAction(leftAction, released);
         } else if (button == padRight) {
             Game::handleAction(rightAction, released);
+        } else if (button == leftShoulder) {
+            Game::handleAction(walkAction, released);
         } else if (button == startButton) {
             if (!released)
                 getMenu().setVisible(true);

src/system/Font.cpp

 }
 
 void Font::drawText(unsigned int x, unsigned int y, float scale,
-                    const unsigned char color[4], std::string s) {
+                    glm::vec4 color, std::string s) {
     if (stringEndsWith(fontName, ".pc")) {
         FontTRLE::drawText(x, y, scale, color, s);
     } else if (stringEndsWith(fontName, ".ttf")) {
 }
 
 void Font::drawTextWrapped(unsigned int x, unsigned int y, float scale,
-                           const unsigned char color[4], unsigned int maxWidth, std::string s) {
+                           glm::vec4 color, unsigned int maxWidth, std::string s) {
     if (stringEndsWith(fontName, ".pc")) {
         FontTRLE::drawTextWrapped(x, y, scale, color, maxWidth, s);
     } else if (stringEndsWith(fontName, ".ttf")) {
 }
 
 void Font::drawTextCentered(unsigned int x, unsigned int y, float scale,
-                            const unsigned char color[4], unsigned int width, std::string s) {
+                            glm::vec4 color, unsigned int width, std::string s) {
     drawText(x + ((width / 2) - (widthText(scale, s) / 2)), y, scale, color, s);
 }
 

src/system/FontImGui.cpp

 }
 
 void FontImGui::drawText(unsigned int x, unsigned int y, float scale,
-                         const unsigned char color[4], std::string s) {
+                         glm::vec4 color, std::string s) {
     ImGuiIO& io = ImGui::GetIO();
     ImFont* font = io.Fonts->Fonts.at(0);
     ImVec2 pos = ImVec2(x, y);
-    ImU32 col = color[0] | (color[1] << 8) | (color[2] << 16) | (color[3] << 24);
+    ImU32 col = (ImU32(color.r * 255)) | (ImU32(color.g * 255) << 8) | (ImU32(color.b * 255) << 16) |
+                (ImU32(color.a * 255) << 24);
 
     ImDrawList dl;
     dl.PushTextureID(font->ContainerAtlas->TexID);
 }
 
 void FontImGui::drawTextWrapped(unsigned int x, unsigned int y, float scale,
-                                const unsigned char color[4], unsigned int maxWidth, std::string s) {
+                                glm::vec4 color, unsigned int maxWidth, std::string s) {
     ImGuiIO& io = ImGui::GetIO();
     ImFont* font = io.Fonts->Fonts.at(0);
     ImVec2 pos = ImVec2(x, y);
-    ImU32 col = color[0] | (color[1] << 8) | (color[2] << 16) | (color[3] << 24);
+    ImU32 col = (ImU32(color.r * 255)) | (ImU32(color.g * 255) << 8) | (ImU32(color.b * 255) << 16) |
+                (ImU32(color.a * 255) << 24);
 
     ImDrawList dl;
     dl.PushTextureID(font->ContainerAtlas->TexID);

src/system/FontTRLE.cpp

 }
 
 void FontTRLE::drawText(unsigned int x, unsigned int y, float scale,
-                        const unsigned char color[4], std::string s) {
+                        glm::vec4 color, std::string s) {
     assert(mFontInit == true);
     assert(s.length() > 0);
 
 
     vertexBuffer.bufferData(vertices);
     uvBuffer.bufferData(uvs);
-    glm::vec4 col(color[0] / 256.0f, color[1] / 256.0f, color[2] / 256.0f, color[3] / 256.0f);
-    Shader::drawGL(vertexBuffer, uvBuffer, col, mFontTexture);
+    Shader::drawGL(vertexBuffer, uvBuffer, color, mFontTexture);
 }
 
 unsigned int FontTRLE::heightText(float scale, unsigned int maxWidth, std::string s) {
 }
 
 void FontTRLE::drawTextWrapped(unsigned int x, unsigned int y, float scale,
-                               const unsigned char color[4], unsigned int maxWidth, std::string s) {
+                               glm::vec4 color, unsigned int maxWidth, std::string s) {
     assert(mFontInit == true);
     assert(s.length() > 0);
 
 
     vertexBuffer.bufferData(vertices);
     uvBuffer.bufferData(uvs);
-    glm::vec4 col(color[0] / 256.0f, color[1] / 256.0f, color[2] / 256.0f, color[3] / 256.0f);
-    Shader::drawGL(vertexBuffer, uvBuffer, col, mFontTexture);
+    Shader::drawGL(vertexBuffer, uvBuffer, color, mFontTexture);
 }
 
 int FontTRLE::defaultOffsets[106][5] = {

src/system/FontTTF.cpp

 }
 
 void FontTTF::drawText(unsigned int x, unsigned int y, float scale,
-                       const unsigned char color[4], std::string s) {
+                       glm::vec4 color, std::string s) {
     drawTextInternal(x, y, scale, color, 0, s, false);
 }
 
 }
 
 void FontTTF::drawTextWrapped(unsigned int x, unsigned int y, float scale,
-                              const unsigned char color[4], unsigned int maxWidth, std::string s) {
+                              glm::vec4 color, unsigned int maxWidth, std::string s) {
     drawTextInternal(x, y, scale, color, maxWidth, s, true);
 }
 
 void FontTTF::drawTextInternal(unsigned int x, unsigned int y, float scale,
-                               const unsigned char color[4], unsigned int maxWidth, std::string s,
+                               glm::vec4 color, unsigned int maxWidth, std::string s,
                                bool drawWrapped) {
-    glm::vec4 col(color[0] / 256.0f, color[1] / 256.0f, color[2] / 256.0f, color[3] / 256.0f);
     std::vector<glm::vec2> vertices;
     std::vector<glm::vec2> uvs;
     int texture = -1;
         if ((texture != tex) && (texture != -1)) {
             vertexBuffer.bufferData(vertices);
             uvBuffer.bufferData(uvs);
-            Shader::drawGL(vertexBuffer, uvBuffer, col, texture);
+            Shader::drawGL(vertexBuffer, uvBuffer, color, texture);
             vertices.clear();
             uvs.clear();
         }
 
     vertexBuffer.bufferData(vertices);
     uvBuffer.bufferData(uvs);
-    Shader::drawGL(vertexBuffer, uvBuffer, col, texture);
+    Shader::drawGL(vertexBuffer, uvBuffer, color, texture);
 }
 
 int FontTTF::charIsMapped(int c) {

src/system/Shader.cpp

     glGenVertexArrays(1, &vertexArrayID);
     glBindVertexArray(vertexArrayID);
 
-    // Set background to black
-    //glClearColor(BLACK[0] / 256.0f, BLACK[1] / 256.0f, BLACK[2] / 256.0f, BLACK[3] / 256.0f);
+    // Set background color
     glClearColor(0.0f, 0.0f, 0.4f, 1.0f);
 
     set2DState(false);

src/utils/pixel.cpp

 #include "global.h"
 #include "utils/pixel.h"
 
-unsigned char* generateColorTexture(const unsigned char* rgba, unsigned int width,
+unsigned char* generateColorTexture(glm::vec4 rgba, unsigned int width,
                                     unsigned int height, unsigned int bpp) {
-    assert(rgba != nullptr);
     assert(width > 0);
     assert(height > 0);
-    assert((bpp % 8) == 0);
+    assert((bpp == 24) || (bpp == 32));
 
     unsigned char* image = new unsigned char[height * width * (bpp / 8)];
     for (unsigned int i = 0; i < (width * height); i++) {
-        for (unsigned int a = 0; a < (bpp / 8); a++) {
-            image[(i * (bpp / 8)) + a] = rgba[a];
+        image[i * (bpp / 8)] = (unsigned char)(rgba.r * 255);
+        image[(i * (bpp / 8)) + 1] = (unsigned char)(rgba.g * 255);
+        image[(i * (bpp / 8)) + 2] = (unsigned char)(rgba.b * 255);
+        if (bpp == 32) {
+            image[(i * (bpp / 8)) + 3] = (unsigned char)(rgba.a * 255);
         }
     }
     return image;