Now using stb_truetype instead of SDL2-TTF.

ChangeLog.md

@@ -2,6 +2,10 @@
 
 ## OpenRaider (0.1.3) xythobuz <xythobuz@xythobuz.de>
 
+    [ 20150106 ]
+    * Removed SDL2-TTF Font implementation
+    * Added new Font implementation using stb_truetype
+
     [ 20150104 ]
     * FontImGui has started to be useful (larger text, proper size calculation).
 

README.md

@@ -44,12 +44,11 @@ Basically, OpenRaider depends on the following:
 * GLM (>= 0.9.6)
 * zlib
 * SDL2 or GLFW
-* SDL2-TTF (optional, doesn’t work with GLFW, needed if you want to use TTF fonts)
 * OpenAL & ALUT (optional, needed for sound output)
 
 On Mac OS X 10.9 / 10.10 with [XCode](https://developer.apple.com/xcode/) and [MacPorts](http://www.macports.org) installed, the following should be enough to get all dependencies that are available as port:
 
-    sudo port install cmake zlib glm libsdl2 libsdl2_ttf
+    sudo port install cmake zlib glm libsdl2
 
 A similar command for the package manager of your favorite Linux Distribution should do the trick.
 
@@ -175,7 +174,6 @@ There are some included cmake scripts:
 
 * [FindALUT](https://github.com/rpavlik/cmake-modules/blob/master/FindALUT.cmake)
 * [FindSDL2](https://github.com/dhewm/dhewm3/blob/master/neo/sys/cmake/FindSDL2.cmake)
-* [FindSDL2TTF](https://github.com/Deraen/ohj2710/blob/master/cmake_modules/FindSDL2TTF.cmake)
 * [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)

cmake/FindSDL2TTF.cmake

@@ -1,114 +0,0 @@
-# Locate SDL2 library
-# This module defines
-# SDL2_LIBRARY, the name of the library to link against
-# SDL2_FOUND, if false, do not try to link to SDL2
-# SDL2_INCLUDE_DIR, where to find SDL.h
-#
-# This module responds to the the flag:
-# SDL2_BUILDING_LIBRARY
-# If this is defined, then no SDL2main will be linked in because
-# only applications need main().
-# Otherwise, it is assumed you are building an application and this
-# module will attempt to locate and set the the proper link flags
-# as part of the returned SDL2_LIBRARY variable.
-#
-# Don't forget to include SDLmain.h and SDLmain.m your project for the
-# OS X framework based version. (Other versions link to -lSDL2main which
-# this module will try to find on your behalf.) Also for OS X, this
-# module will automatically add the -framework Cocoa on your behalf.
-#
-#
-# Additional Note: If you see an empty SDL2_LIBRARY_TEMP in your configuration
-# and no SDL2_LIBRARY, it means CMake did not find your SDL2 library
-# (SDL2.dll, libsdl2.so, SDL2.framework, etc).
-# Set SDL2_LIBRARY_TEMP to point to your SDL2 library, and configure again.
-# Similarly, if you see an empty SDL2MAIN_LIBRARY, you should set this value
-# as appropriate. These values are used to generate the final SDL2_LIBRARY
-# variable, but when these values are unset, SDL2_LIBRARY does not get created.
-#
-#
-# $SDL2DIR is an environment variable that would
-# correspond to the ./configure --prefix=$SDL2DIR
-# used in building SDL2.
-# l.e.galup  9-20-02
-#
-# Modified by Eric Wing.
-# Added code to assist with automated building by using environmental variables
-# and providing a more controlled/consistent search behavior.
-# Added new modifications to recognize OS X frameworks and
-# additional Unix paths (FreeBSD, etc).
-# Also corrected the header search path to follow "proper" SDL guidelines.
-# Added a search for SDL2main which is needed by some platforms.
-# Added a search for threads which is needed by some platforms.
-# Added needed compile switches for MinGW.
-#
-# On OSX, this will prefer the Framework version (if found) over others.
-# People will have to manually change the cache values of
-# SDL2_LIBRARY to override this selection or set the CMake environment
-# CMAKE_INCLUDE_PATH to modify the search paths.
-#
-# Note that the header path has changed from SDL2/SDL.h to just SDL.h
-# This needed to change because "proper" SDL convention
-# is #include "SDL.h", not <SDL2/SDL.h>. This is done for portability
-# reasons because not all systems place things in SDL2/ (see FreeBSD).
-#
-# =============================================================================
-# Copyright 2003-2009 Kitware, Inc.
-#
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions are met: 
-# 
-# 1. Redistributions of source code must retain the above copyright notice, this
-#    list of conditions and the following disclaimer. 
-# 2. Redistributions in binary form must reproduce the above copyright notice,
-#    this list of conditions and the following disclaimer in the documentation
-#    and/or other materials provided with the distribution. 
-# 
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
-# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-# =============================================================================
-
-SET(SDL2TTF_SEARCH_PATHS
-	~/Library/Frameworks
-	/Library/Frameworks
-	/usr/local
-	/usr
-	/sw # Fink
-	/opt/local # DarwinPorts
-	/opt/csw # Blastwave
-	/opt
-)
-
-FIND_PATH(SDL2TTF_INCLUDE_DIR SDL_ttf.h
-	HINTS
-	$ENV{SDL2TTFDIR}
-	PATH_SUFFIXES include/SDL2 include
-	PATHS ${SDL2TTF_SEARCH_PATHS}
-)
-
-FIND_LIBRARY(SDL2TTF_LIBRARY_TEMP
-	NAMES SDL2_ttf
-	HINTS
-	$ENV{SDL2TTFDIR}
-	PATH_SUFFIXES lib64 lib
-	PATHS ${SDL2TTF_SEARCH_PATHS}
-)
-
-IF(SDL2TTF_LIBRARY_TEMP)
-	# Set the final string here so the GUI reflects the final state.
-	SET(SDL2TTF_LIBRARY ${SDL2TTF_LIBRARY_TEMP} CACHE STRING "Where the SDL2TTF Library can be found")
-	# Set the temp variable to INTERNAL so it is not seen in the CMake GUI
-	SET(SDL2TTF_LIBRARY_TEMP "${SDL2TTF_LIBRARY_TEMP}" CACHE INTERNAL "")
-ENDIF(SDL2TTF_LIBRARY_TEMP)
-
-INCLUDE(FindPackageHandleStandardArgs)
-
-FIND_PACKAGE_HANDLE_STANDARD_ARGS(SDL2TTF REQUIRED_VARS SDL2TTF_LIBRARY SDL2TTF_INCLUDE_DIR)

include/config.h.in

@@ -20,7 +20,6 @@ extern const char* INSTALL_PREFIX;
 
 #cmakedefine USING_AL
 #cmakedefine USING_SDL
-#cmakedefine USING_SDL_FONT
 #cmakedefine USING_GLFW
 
 #cmakedefine HAVE_EXECINFO_H

include/system/FontSDL.h

@@ -1,41 +0,0 @@
-/*!
- * \file include/system/FontSDL.h
- * \brief SDL Font implementation
- *
- * \author xythobuz
- */
-
-#ifndef _FONT_SDL_H_
-#define _FONT_SDL_H_
-
-#include "SDL_ttf.h"
-
-/*!
- * \brief SDL Font implementation
- */
-class FontSDL {
-  public:
-    static void shutdown();
-
-    static int initialize(std::string font);
-
-    static unsigned int widthText(float scale, std::string s);
-
-    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);
-
-    static void drawTextWrapped(unsigned int x, unsigned int y, float scale,
-                                const unsigned char color[4], unsigned int maxWidth, std::string s);
-
-  private:
-    static bool mFontInit;
-    static TTF_Font* mFont;
-    static unsigned int mFontTexture;
-    static ShaderBuffer vertexBuffer;
-    static ShaderBuffer uvBuffer;
-};
-
-#endif
-

include/system/FontTTF.h

@@ -0,0 +1,58 @@
+/*!
+ * \file include/system/FontTTF.h
+ * \brief TrueType Font implementation
+ *
+ * \author xythobuz
+ */
+
+#ifndef _FONT_TTF_H_
+#define _FONT_TTF_H_
+
+#include <string>
+#include <vector>
+
+#include "stb/stb_truetype.h"
+#include "system/Shader.h"
+
+class FontMapTTF {
+  public:
+    FontMapTTF();
+    FontMapTTF(FontMapTTF&& other);
+    ~FontMapTTF();
+
+    int initialize(unsigned char* fontData, int firstChar);
+    bool contains(int c);
+    int getTexture() { return texture; }
+    void getQuad(int c, float* xpos, float* ypos, stbtt_aligned_quad *quad);
+
+  private:
+    int begin;
+    int texture;
+    stbtt_packedchar* charInfo;
+};
+
+class FontTTF {
+  public:
+    static int initialize(std::string f);
+    static void shutdown();
+
+    static unsigned int widthText(float scale, std::string s);
+    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);
+    static void drawTextWrapped(unsigned int x, unsigned int y, float scale,
+                                const unsigned char color[4], 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 unsigned char* fontData;
+    static std::vector<FontMapTTF> maps;
+    static ShaderBuffer vertexBuffer;
+    static ShaderBuffer uvBuffer;
+};
+
+#endif
+

include/utils/pixel.h

@@ -17,6 +17,7 @@ void argb2rgba32(unsigned char* image, unsigned int w, unsigned int h);
 
 // Returns newly allocated buffer
 unsigned char* argb16to32(unsigned char* image, unsigned int w, unsigned int h);
+unsigned char* grayscale2rgba(unsigned char* image, unsigned int w, unsigned int h);
 
 unsigned char* scaleBuffer(unsigned char* image, unsigned int* w, unsigned int* h,
                            unsigned int bpp);

src/CMakeLists.txt

@@ -17,13 +17,6 @@ find_package (SDL2)
 if (SDL2_FOUND AND NOT FORCE_GLFW)
     include_directories (SYSTEM ${SDL2_INCLUDE_DIR})
     set (LIBS ${LIBS} ${SDL2_LIBRARY})
-
-    # Add SDL2_ttf Library
-    find_package (SDL2TTF)
-    if (SDL2TTF_FOUND)
-        include_directories (SYSTEM ${SDL2TTF_INCLUDE_DIR})
-        set (LIBS ${LIBS} ${SDL2TTF_LIBRARY})
-    endif (SDL2TTF_FOUND)
 else (SDL2_FOUND AND NOT FORCE_GLFW)
     find_package (GLFW)
     if (GLFW_FOUND)
@@ -90,14 +83,8 @@ endif (OPENAL_FOUND AND ALUT_FOUND AND ENABLE_AUDIO)
 if (SDL2_FOUND AND NOT FORCE_GLFW)
     set (USING_GLFW FALSE)
     set (USING_SDL TRUE)
-    if (SDL2TTF_FOUND)
-        set (USING_SDL_FONT TRUE)
-    else (SDL2TTF_FOUND)
-        set (USING_SDL_FONT FALSE)
-    endif (SDL2TTF_FOUND)
 else (SDL2_FOUND AND NOT FORCE_GLFW)
     set (USING_SDL FALSE)
-    set (USING_SDL_FONT FALSE)
     if (GLFW_FOUND)
         set (USING_GLFW TRUE)
     else (GLFW_FOUND)

src/TextureManager.cpp

@@ -114,7 +114,7 @@ int TextureManager::loadBufferSlot(unsigned char* image,
            || (mode ==  ColorMode::BGRA));
     assert((bpp == 8) || (bpp == 24) || (bpp == 32));
 
-    if (slot == -1)
+    if (slot < 0)
         slot = getIds(s).size();
 
     while (getIds(s).size() <= slot) {

src/deps/CMakeLists.txt

@@ -1,7 +1,7 @@
 # Source files
 set (DEPS_SRCS ${DEPS_SRCS} "commander/commander.c" "commander/commander.h")
 set (DEPS_SRCS ${DEPS_SRCS} "imgui/imgui.cpp" "imgui/imgui.h" "imgui/imconfig.h" "imgui/stb_textedit.h")
-set (DEPS_SRCS ${DEPS_SRCS} "stb/stb.cpp" "stb/stb_image.h" "stb/stb_image_write.h")
+set (DEPS_SRCS ${DEPS_SRCS} "stb/stb.cpp" "stb/stb_image.h" "stb/stb_image_write.h" "stb/stb_truetype.h")
 
 # Add library
 add_library (OpenRaider_deps OBJECT ${DEPS_SRCS})

src/deps/stb/stb.cpp

@@ -14,3 +14,11 @@
 #define STB_IMAGE_WRITE_IMPLEMENTATION
 #include "stb/stb_image_write.h"
 
+#define STB_RECT_PACK_IMPLEMENTATION
+#define STBRP_ASSERT assert
+#include "stb/stb_rect_pack.h"
+
+#define STB_TRUETYPE_IMPLEMENTATION
+#define STBTT_assert(x) assert(x)
+#include "stb/stb_truetype.h"
+

src/deps/stb/stb_rect_pack.h

@@ -0,0 +1,546 @@
+// stb_rect_pack.h - v0.05 - public domain - rectangle packing
+// Sean Barrett 2014
+//
+// Useful for e.g. packing rectangular textures into an atlas.
+// Does not do rotation.
+//
+// Not necessarily the awesomest packing method, but better than
+// the totally naive one in stb_truetype (which is primarily what
+// this is meant to replace).
+//
+// Has only had a few tests run, may have issues.
+//
+// More docs to come.
+//
+// No memory allocations; uses qsort() and assert() from stdlib.
+//
+// This library currently uses the Skyline Bottom-Left algorithm.
+//
+// Please note: better rectangle packers are welcome! Please
+// implement them to the same API, but with a different init
+// function.
+//
+// Version history:
+//
+//     0.05:  added STBRP_ASSERT to allow replacing assert
+//     0.04:  fixed minor bug in STBRP_LARGE_RECTS support
+//     0.01:  initial release
+
+//////////////////////////////////////////////////////////////////////////////
+//
+//       INCLUDE SECTION
+//
+
+#ifndef STB_INCLUDE_STB_RECT_PACK_H
+#define STB_INCLUDE_STB_RECT_PACK_H
+
+#define STB_RECT_PACK_VERSION  1
+
+#ifdef STBRP_STATIC
+#define STBRP_DEF static
+#else
+#define STBRP_DEF extern
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct stbrp_context stbrp_context;
+typedef struct stbrp_node    stbrp_node;
+typedef struct stbrp_rect    stbrp_rect;
+
+#ifdef STBRP_LARGE_RECTS
+typedef int            stbrp_coord;
+#else
+typedef unsigned short stbrp_coord;
+#endif
+
+STBRP_DEF void stbrp_pack_rects (stbrp_context *context, stbrp_rect *rects, int num_rects);
+// Assign packed locations to rectangles. The rectangles are of type
+// 'stbrp_rect' defined below, stored in the array 'rects', and there
+// are 'num_rects' many of them.
+//
+// Rectangles which are successfully packed have the 'was_packed' flag
+// set to a non-zero value and 'x' and 'y' store the minimum location
+// on each axis (i.e. bottom-left in cartesian coordinates, top-left
+// if you imagine y increasing downwards). Rectangles which do not fit
+// have the 'was_packed' flag set to 0.
+//
+// You should not try to access the 'rects' array from another thread
+// while this function is running, as the function temporarily reorders
+// the array while it executes.
+//
+// To pack into another rectangle, you need to call stbrp_init_target
+// again. To continue packing into the same rectangle, you can call
+// this function again. Calling this multiple times with multiple rect
+// arrays will probably produce worse packing results than calling it
+// a single time with the full rectangle array, but the option is
+// available.
+
+struct stbrp_rect
+{
+   // reserved for your use:
+   int            id;
+
+   // input:
+   stbrp_coord    w, h;
+
+   // output:
+   stbrp_coord    x, y;
+   int            was_packed;  // non-zero if valid packing
+
+}; // 16 bytes, nominally
+
+
+STBRP_DEF void stbrp_init_target (stbrp_context *context, int width, int height, stbrp_node *nodes, int num_nodes);
+// Initialize a rectangle packer to:
+//    pack a rectangle that is 'width' by 'height' in dimensions
+//    using temporary storage provided by the array 'nodes', which is 'num_nodes' long
+//
+// You must call this function every time you start packing into a new target.
+//
+// There is no "shutdown" function. The 'nodes' memory must stay valid for
+// the following stbrp_pack_rects() call (or calls), but can be freed after
+// the call (or calls) finish.
+//
+// Note: to guarantee best results, either:
+//       1. make sure 'num_nodes' >= 'width'
+//   or  2. call stbrp_allow_out_of_mem() defined below with 'allow_out_of_mem = 1'
+//
+// If you don't do either of the above things, widths will be quantized to multiples
+// of small integers to guarantee the algorithm doesn't run out of temporary storage.
+//
+// If you do #2, then the non-quantized algorithm will be used, but the algorithm
+// may run out of temporary storage and be unable to pack some rectangles.
+
+STBRP_DEF void stbrp_setup_allow_out_of_mem (stbrp_context *context, int allow_out_of_mem);
+// Optionally call this function after init but before doing any packing to
+// change the handling of the out-of-temp-memory scenario, described above.
+// If you call init again, this will be reset to the default (false).
+
+
+STBRP_DEF void stbrp_setup_heuristic (stbrp_context *context, int heuristic);
+// Optionally select which packing heuristic the library should use. Different
+// heuristics will produce better/worse results for different data sets.
+// If you call init again, this will be reset to the default.
+
+enum
+{
+   STBRP_HEURISTIC_Skyline_default=0,
+   STBRP_HEURISTIC_Skyline_BL_sortHeight = STBRP_HEURISTIC_Skyline_default,
+   STBRP_HEURISTIC_Skyline_BF_sortHeight,
+};
+
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// the details of the following structures don't matter to you, but they must
+// be visible so you can handle the memory allocations for them
+
+struct stbrp_node
+{
+   stbrp_coord  x,y;
+   stbrp_node  *next;
+};
+
+struct stbrp_context
+{
+   int width;
+   int height;
+   int align;
+   int init_mode;
+   int heuristic;
+   int num_nodes;
+   stbrp_node *active_head;
+   stbrp_node *free_head;
+   stbrp_node extra[2]; // we allocate two extra nodes so optimal user-node-count is 'width' not 'width+2'
+};
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+//////////////////////////////////////////////////////////////////////////////
+//
+//     IMPLEMENTATION SECTION
+//
+
+#ifdef STB_RECT_PACK_IMPLEMENTATION
+#include <stdlib.h>
+
+#ifndef STBRP_ASSERT
+#include <assert.h>
+#define STBRP_ASSERT assert
+#endif
+
+enum
+{
+   STBRP__INIT_skyline = 1,
+};
+
+STBRP_DEF void stbrp_setup_heuristic(stbrp_context *context, int heuristic)
+{
+   switch (context->init_mode) {
+      case STBRP__INIT_skyline:
+         STBRP_ASSERT(heuristic == STBRP_HEURISTIC_Skyline_BL_sortHeight || heuristic == STBRP_HEURISTIC_Skyline_BF_sortHeight);
+         context->heuristic = heuristic;
+         break;
+      default:
+         STBRP_ASSERT(0);
+   }
+}
+
+STBRP_DEF void stbrp_setup_allow_out_of_mem(stbrp_context *context, int allow_out_of_mem)
+{
+   if (allow_out_of_mem)
+      // if it's ok to run out of memory, then don't bother aligning them;
+      // this gives better packing, but may fail due to OOM (even though
+      // the rectangles easily fit). @TODO a smarter approach would be to only
+      // quantize once we've hit OOM, then we could get rid of this parameter.
+      context->align = 1;
+   else {
+      // if it's not ok to run out of memory, then quantize the widths
+      // so that num_nodes is always enough nodes.
+      //
+      // I.e. num_nodes * align >= width
+      //                  align >= width / num_nodes
+      //                  align = ceil(width/num_nodes)
+
+      context->align = (context->width + context->num_nodes-1) / context->num_nodes;
+   }
+}
+
+STBRP_DEF void stbrp_init_target(stbrp_context *context, int width, int height, stbrp_node *nodes, int num_nodes)
+{
+   int i;
+#ifndef STBRP_LARGE_RECTS
+   STBRP_ASSERT(width <= 0xffff && height <= 0xffff);
+#endif
+
+   for (i=0; i < num_nodes-1; ++i)
+      nodes[i].next = &nodes[i+1];
+   nodes[i].next = NULL;
+   context->init_mode = STBRP__INIT_skyline;
+   context->heuristic = STBRP_HEURISTIC_Skyline_default;
+   context->free_head = &nodes[0];
+   context->active_head = &context->extra[0];
+   context->width = width;
+   context->height = height;
+   context->num_nodes = num_nodes;
+   stbrp_setup_allow_out_of_mem(context, 0);
+
+   // node 0 is the full width, node 1 is the sentinel (lets us not store width explicitly)
+   context->extra[0].x = 0;
+   context->extra[0].y = 0;
+   context->extra[0].next = &context->extra[1];
+   context->extra[1].x = (stbrp_coord) width;
+#ifdef STBRP_LARGE_RECTS
+   context->extra[1].y = (1<<30);
+#else
+   context->extra[1].y = 65535;
+#endif
+   context->extra[1].next = NULL;
+}
+
+// find minimum y position if it starts at x1
+static int stbrp__skyline_find_min_y(stbrp_context *c, stbrp_node *first, int x0, int width, int *pwaste)
+{
+   stbrp_node *node = first;
+   int x1 = x0 + width;
+   int min_y, visited_width, waste_area;
+   STBRP_ASSERT(first->x <= x0);
+
+   #if 0
+   // skip in case we're past the node
+   while (node->next->x <= x0)
+      ++node;
+   #else
+   STBRP_ASSERT(node->next->x > x0); // we ended up handling this in the caller for efficiency
+   #endif
+
+   STBRP_ASSERT(node->x <= x0);
+
+   min_y = 0;
+   waste_area = 0;
+   visited_width = 0;
+   while (node->x < x1) {
+      if (node->y > min_y) {
+         // raise min_y higher.
+         // we've accounted for all waste up to min_y,
+         // but we'll now add more waste for everything we've visted
+         waste_area += visited_width * (node->y - min_y);
+         min_y = node->y;
+         // the first time through, visited_width might be reduced
+         if (node->x < x0)
+            visited_width += node->next->x - x0;
+         else
+            visited_width += node->next->x - node->x;
+      } else {
+         // add waste area
+         int under_width = node->next->x - node->x;
+         if (under_width + visited_width > width)
+            under_width = width - visited_width;
+         waste_area += under_width * (min_y - node->y);
+         visited_width += under_width;
+      }
+      node = node->next;
+   }
+
+   *pwaste = waste_area;
+   return min_y;
+}
+
+typedef struct
+{
+   int x,y;
+   stbrp_node **prev_link;
+} stbrp__findresult;
+
+static stbrp__findresult stbrp__skyline_find_best_pos(stbrp_context *c, int width, int height)
+{
+   int best_waste = (1<<30), best_x, best_y = (1 << 30);
+   stbrp__findresult fr;
+   stbrp_node **prev, *node, *tail, **best = NULL;
+
+   // align to multiple of c->align
+   width = (width + c->align - 1);
+   width -= width % c->align;
+   STBRP_ASSERT(width % c->align == 0);
+
+   node = c->active_head;
+   prev = &c->active_head;
+   while (node->x + width <= c->width) {
+      int y,waste;
+      y = stbrp__skyline_find_min_y(c, node, node->x, width, &waste);
+      if (c->heuristic == STBRP_HEURISTIC_Skyline_BL_sortHeight) { // actually just want to test BL
+         // bottom left
+         if (y < best_y) {
+            best_y = y;
+            best = prev;
+         }
+      } else {
+         // best-fit
+         if (y + height <= c->height) {
+            // can only use it if it first vertically
+            if (y < best_y || (y == best_y && waste < best_waste)) {
+               best_y = y;
+               best_waste = waste;
+               best = prev;
+            }
+         }
+      }
+      prev = &node->next;
+      node = node->next;
+   }
+
+   best_x = (best == NULL) ? 0 : (*best)->x;
+
+   // if doing best-fit (BF), we also have to try aligning right edge to each node position
+   //
+   // e.g, if fitting
+   //
+   //     ____________________
+   //    |____________________|
+   //
+   //            into
+   //
+   //   |                         |
+   //   |             ____________|
+   //   |____________|
+   //
+   // then right-aligned reduces waste, but bottom-left BL is always chooses left-aligned
+   //
+   // This makes BF take about 2x the time
+
+   if (c->heuristic == STBRP_HEURISTIC_Skyline_BF_sortHeight) {
+      tail = c->active_head;
+      node = c->active_head;
+      prev = &c->active_head;
+      // find first node that's admissible
+      while (tail->x < width)
+         tail = tail->next;
+      while (tail) {
+         int xpos = tail->x - width;
+         int y,waste;
+         STBRP_ASSERT(xpos >= 0);
+         // find the left position that matches this
+         while (node->next->x <= xpos) {
+            prev = &node->next;
+            node = node->next;
+         }
+         STBRP_ASSERT(node->next->x > xpos && node->x <= xpos);
+         y = stbrp__skyline_find_min_y(c, node, xpos, width, &waste);
+         if (y + height < c->height) {
+            if (y <= best_y) {
+               if (y < best_y || waste < best_waste || (waste==best_waste && xpos < best_x)) {
+                  best_x = xpos;
+                  STBRP_ASSERT(y <= best_y);
+                  best_y = y;
+                  best_waste = waste;
+                  best = prev;
+               }
+            }
+         }
+         tail = tail->next;
+      }
+   }
+
+   fr.prev_link = best;
+   fr.x = best_x;
+   fr.y = best_y;
+   return fr;
+}
+
+static stbrp__findresult stbrp__skyline_pack_rectangle(stbrp_context *context, int width, int height)
+{
+   // find best position according to heuristic
+   stbrp__findresult res = stbrp__skyline_find_best_pos(context, width, height);
+   stbrp_node *node, *cur;
+
+   // bail if:
+   //    1. it failed
+   //    2. the best node doesn't fit (we don't always check this)
+   //    3. we're out of memory
+   if (res.prev_link == NULL || res.y + height > context->height || context->free_head == NULL) {
+      res.prev_link = NULL;
+      return res;
+   }
+
+   // on success, create new node
+   node = context->free_head;
+   node->x = (stbrp_coord) res.x;
+   node->y = (stbrp_coord) (res.y + height);
+
+   context->free_head = node->next;
+
+   // insert the new node into the right starting point, and
+   // let 'cur' point to the remaining nodes needing to be
+   // stiched back in
+
+   cur = *res.prev_link;
+   if (cur->x < res.x) {
+      // preserve the existing one, so start testing with the next one
+      stbrp_node *next = cur->next;
+      cur->next = node;
+      cur = next;
+   } else {
+      *res.prev_link = node;
+   }
+
+   // from here, traverse cur and free the nodes, until we get to one
+   // that shouldn't be freed
+   while (cur->next && cur->next->x <= res.x + width) {
+      stbrp_node *next = cur->next;
+      // move the current node to the free list
+      cur->next = context->free_head;
+      context->free_head = cur;
+      cur = next;
+   }
+
+   // stitch the list back in
+   node->next = cur;
+
+   if (cur->x < res.x + width)
+      cur->x = (stbrp_coord) (res.x + width);
+
+#ifdef _DEBUG
+   cur = context->active_head;
+   while (cur->x < context->width) {
+      STBRP_ASSERT(cur->x < cur->next->x);
+      cur = cur->next;
+   }
+   STBRP_ASSERT(cur->next == NULL);
+
+   {
+      stbrp_node *L1 = NULL, *L2 = NULL;
+      int count=0;
+      cur = context->active_head;
+      while (cur) {
+         L1 = cur;
+         cur = cur->next;
+         ++count;
+      }
+      cur = context->free_head;
+      while (cur) {
+         L2 = cur;
+         cur = cur->next;
+         ++count;
+      }
+      STBRP_ASSERT(count == context->num_nodes+2);
+   }
+#endif
+
+   return res;
+}
+
+static int rect_height_compare(const void *a, const void *b)
+{
+   stbrp_rect *p = (stbrp_rect *) a;
+   stbrp_rect *q = (stbrp_rect *) b;
+   if (p->h > q->h)
+      return -1;
+   if (p->h < q->h)
+      return  1;
+   return (p->w > q->w) ? -1 : (p->w < q->w);
+}
+
+static int rect_width_compare(const void *a, const void *b)
+{
+   stbrp_rect *p = (stbrp_rect *) a;
+   stbrp_rect *q = (stbrp_rect *) b;
+   if (p->w > q->w)
+      return -1;
+   if (p->w < q->w)
+      return  1;
+   return (p->h > q->h) ? -1 : (p->h < q->h);
+}
+
+static int rect_original_order(const void *a, const void *b)
+{
+   stbrp_rect *p = (stbrp_rect *) a;
+   stbrp_rect *q = (stbrp_rect *) b;
+   return (p->was_packed < q->was_packed) ? -1 : (p->was_packed > q->was_packed);
+}
+
+#ifdef STBRP_LARGE_RECTS
+#define STBRP__MAXVAL  0xffffffff
+#else
+#define STBRP__MAXVAL  0xffff
+#endif
+
+STBRP_DEF void stbrp_pack_rects(stbrp_context *context, stbrp_rect *rects, int num_rects)
+{
+   int i;
+
+   // we use the 'was_packed' field internally to allow sorting/unsorting
+   for (i=0; i < num_rects; ++i) {
+      rects[i].was_packed = i;
+      #ifndef STBRP_LARGE_RECTS
+      STBRP_ASSERT(rects[i].w <= 0xffff && rects[i].h <= 0xffff);
+      #endif
+   }
+
+   // sort according to heuristic
+   qsort(rects, num_rects, sizeof(rects[0]), rect_height_compare);
+
+   for (i=0; i < num_rects; ++i) {
+      stbrp__findresult fr = stbrp__skyline_pack_rectangle(context, rects[i].w, rects[i].h);
+      if (fr.prev_link) {
+         rects[i].x = (stbrp_coord) fr.x;
+         rects[i].y = (stbrp_coord) fr.y;
+      } else {
+         rects[i].x = rects[i].y = STBRP__MAXVAL;
+      }
+   }
+
+   // unsort
+   qsort(rects, num_rects, sizeof(rects[0]), rect_original_order);
+
+   // set was_packed flags
+   for (i=0; i < num_rects; ++i)
+      rects[i].was_packed = !(rects[i].x == STBRP__MAXVAL && rects[i].y == STBRP__MAXVAL);
+}
+#endif

src/system/CMakeLists.txt

@@ -2,6 +2,7 @@
 set (SYS_SRCS ${SYS_SRCS} "Font.cpp" "../../include/system/Font.h")
 set (SYS_SRCS ${SYS_SRCS} "FontImGui.cpp" "../../include/system/FontImGui.h")
 set (SYS_SRCS ${SYS_SRCS} "FontTRLE.cpp" "../../include/system/FontTRLE.h")
+set (SYS_SRCS ${SYS_SRCS} "FontTTF.cpp" "../../include/system/FontTTF.h")
 set (SYS_SRCS ${SYS_SRCS} "Shader.cpp" "../../include/system/Shader.h")
 set (SYS_SRCS ${SYS_SRCS} "Sound.cpp" "../../include/system/Sound.h")
 set (SYS_SRCS ${SYS_SRCS} "Window.cpp" "../../include/system/Window.h")
@@ -17,10 +18,6 @@ if (USING_SDL)
     set (SYS_SRCS ${SYS_SRCS} "WindowSDL.cpp" "../../include/system/WindowSDL.h")
 endif (USING_SDL)
 
-if (USING_SDL_FONT)
-    set (SYS_SRCS ${SYS_SRCS} "FontSDL.cpp" "../../include/system/FontSDL.h")
-endif (USING_SDL_FONT)
-
 if (USING_GLFW)
     set (SYS_SRCS ${SYS_SRCS} "WindowGLFW.cpp" "../../include/system/WindowGLFW.h")
 endif (USING_GLFW)

src/system/Font.cpp

@@ -9,32 +9,25 @@
 #include "Log.h"
 #include "utils/strings.h"
 #include "system/Window.h"
-#include "system/Font.h"
 #include "system/FontImGui.h"
 #include "system/FontTRLE.h"
-
-#ifdef USING_SDL_FONT
-#include "system/FontSDL.h"
-#endif
+#include "system/FontTTF.h"
+#include "system/Font.h"
 
 bool Font::isInit = false;
 std::string Font::fontName;
 
 void Font::shutdown() {
     FontTRLE::shutdown();
-#ifdef USING_SDL_FONT
-    FontSDL::shutdown();
-#endif
+    FontTTF::shutdown();
 }
 
 int Font::initialize(std::string font) {
     fontName = font;
     if (stringEndsWith(fontName, ".pc")) {
         return FontTRLE::initialize(fontName);
-#ifdef USING_SDL_FONT
     } else if (stringEndsWith(fontName, ".ttf")) {
-        return FontSDL::initialize(fontName);
-#endif
+        return FontTTF::initialize(fontName);
     }
 
     if (font != "") {
@@ -48,10 +41,8 @@ int Font::initialize(std::string font) {
 unsigned int Font::widthText(float scale, std::string s) {
     if (stringEndsWith(fontName, ".pc")) {
         return FontTRLE::widthText(scale, s);
-#ifdef USING_SDL_FONT
     } else if (stringEndsWith(fontName, ".ttf")) {
-        return FontSDL::widthText(scale, s);
-#endif
+        return FontTTF::widthText(scale, s);
     } else {
         return FontImGui::widthText(scale, s);
     }
@@ -60,10 +51,8 @@ unsigned int Font::widthText(float scale, std::string s) {
 unsigned int Font::heightText(float scale, unsigned int maxWidth, std::string s) {
     if (stringEndsWith(fontName, ".pc")) {
         return FontTRLE::heightText(scale, maxWidth, s);
-#ifdef USING_SDL_FONT
     } else if (stringEndsWith(fontName, ".ttf")) {
-        return FontSDL::heightText(scale, maxWidth, s);
-#endif
+        return FontTTF::heightText(scale, maxWidth, s);
     } else {
         return FontImGui::heightText(scale, maxWidth, s);
     }
@@ -73,10 +62,8 @@ void Font::drawText(unsigned int x, unsigned int y, float scale,
                     const unsigned char color[4], std::string s) {
     if (stringEndsWith(fontName, ".pc")) {
         FontTRLE::drawText(x, y, scale, color, s);
-#ifdef USING_SDL_FONT
     } else if (stringEndsWith(fontName, ".ttf")) {
-        FontSDL::drawText(x, y, scale, color, s);
-#endif
+        FontTTF::drawText(x, y, scale, color, s);
     } else {
         FontImGui::drawText(x, y, scale, color, s);
     }
@@ -86,10 +73,8 @@ void Font::drawTextWrapped(unsigned int x, unsigned int y, float scale,
                            const unsigned char color[4], unsigned int maxWidth, std::string s) {
     if (stringEndsWith(fontName, ".pc")) {
         FontTRLE::drawTextWrapped(x, y, scale, color, maxWidth, s);
-#ifdef USING_SDL_FONT
     } else if (stringEndsWith(fontName, ".ttf")) {
-        FontSDL::drawTextWrapped(x, y, scale, color, maxWidth, s);
-#endif
+        FontTTF::drawTextWrapped(x, y, scale, color, maxWidth, s);
     } else {
         FontImGui::drawTextWrapped(x, y, scale, color, maxWidth, s);
     }

src/system/FontSDL.cpp

@@ -1,222 +0,0 @@
-/*!
- * \file src/system/FontSDL.cpp
- * \brief SDL Font implementation
- *
- * \author xythobuz
- */
-
-#include <iostream>
-
-#include "global.h"
-#include "TextureManager.h"
-#include "system/Shader.h"
-#include "system/FontSDL.h"
-
-bool FontSDL::mFontInit = false;
-TTF_Font* FontSDL::mFont = nullptr;
-unsigned int FontSDL::mFontTexture = -1;
-ShaderBuffer FontSDL::vertexBuffer;
-ShaderBuffer FontSDL::uvBuffer;
-
-void FontSDL::shutdown() {
-    if (mFont != nullptr)
-        TTF_CloseFont(mFont);
-    mFont = nullptr;
-
-    if (mFontInit) {
-        TTF_Quit();
-        mFontInit = false;
-    }
-}
-
-int FontSDL::initialize(std::string font) {
-    if (!mFontInit) {
-        if (TTF_Init() != 0) {
-            std::cout << "Could not initialize SDL-TTF!" << std::endl;
-            return -1;
-        }
-
-        // Reserve slot
-        mFontTexture = TextureManager::loadBufferSlot(nullptr, 256, 256,
-                                                      ColorMode::RGBA, 32,
-                                                      TextureStorage::SYSTEM);
-
-        mFontInit = true;
-    }
-
-    if (mFont != nullptr)
-        TTF_CloseFont(mFont);
-
-    mFont = TTF_OpenFont(font.c_str(), 24);
-    if (mFont == nullptr) {
-        std::cout << "TTF_OpenFont Error: " << TTF_GetError() << std::endl;
-        return -2;
-    }
-
-    return 0;
-}
-
-unsigned int FontSDL::widthText(float scale, std::string s) {
-    assert(mFontInit == true);
-    assert(mFont != nullptr);
-
-    int w;
-    if (TTF_SizeUTF8(mFont, s.c_str(), &w, nullptr) != 0) {
-        std::cout << "TTF_SizeUTF8 Error: " << TTF_GetError() << std::endl;
-        return s.length() * 15 * scale;
-    }
-    return w * scale;
-}
-
-void FontSDL::drawText(unsigned int x, unsigned int y, float scale,
-                       const unsigned char color[4], std::string s) {
-    assert(mFontInit == true);
-    assert(mFont != nullptr);
-    assert(s.length() > 0);
-
-    SDL_Color col;
-    col.r = color[0];
-    col.g = color[1];
-    col.b = color[2];
-    col.a = color[3];
-
-    SDL_Surface* surface = TTF_RenderUTF8_Blended(mFont, s.c_str(), col);
-    if (surface == nullptr) {
-        std::cout << "TTF_RenderUTF8_Blended Error: " << TTF_GetError() << std::endl;
-        return;
-    }
-
-    int w = (int)((float)surface->w * scale);
-    int h = (int)((float)surface->h * scale);
-
-    ColorMode textureFormat;
-    unsigned int bpp = 0;
-    if (surface->format->BytesPerPixel == 4) {
-        if (surface->format->Rmask == 0x000000FF)
-            textureFormat = ColorMode::RGBA;
-        else
-            textureFormat = ColorMode::BGRA;
-        bpp = 32;
-    } else {
-        if (surface->format->Rmask == 0x000000FF)
-            textureFormat = ColorMode::RGB;
-        else
-            textureFormat = ColorMode::BGR;
-        bpp = 24;
-    }
-
-    TextureManager::loadBufferSlot(static_cast<unsigned char*>(surface->pixels),
-                                   surface->w, surface->h, textureFormat, bpp,
-                                   TextureStorage::SYSTEM, mFontTexture);
-    SDL_FreeSurface(surface);
-
-    std::vector<glm::vec2> vertices;
-    std::vector<glm::vec2> uvs;
-
-    vertices.push_back(glm::vec2(x, y + h));
-    vertices.push_back(glm::vec2(x, y));
-    vertices.push_back(glm::vec2(x + w, y + h));
-
-    vertices.push_back(glm::vec2(x + w, y));
-    vertices.push_back(glm::vec2(x + w, y + h));
-    vertices.push_back(glm::vec2(x, y));
-
-    uvs.push_back(glm::vec2(0.0f, 1.0f));
-    uvs.push_back(glm::vec2(0.0f, 0.0f));
-    uvs.push_back(glm::vec2(1.0f, 1.0f));
-
-    uvs.push_back(glm::vec2(1.0f, 0.0f));
-    uvs.push_back(glm::vec2(1.0f, 1.0f));
-    uvs.push_back(glm::vec2(0.0f, 0.0f));
-
-    vertexBuffer.bufferData(vertices);
-    uvBuffer.bufferData(uvs);
-    Shader::drawGL(vertexBuffer, uvBuffer, glm::vec4(1.0f, 1.0f, 1.0f, 1.0f),
-                   mFontTexture, TextureStorage::SYSTEM);
-}
-
-unsigned int FontSDL::heightText(float scale, unsigned int maxWidth, std::string s) {
-    assert(mFontInit == true);
-    assert(mFont != nullptr);
-    assert(s.length() > 0);
-    assert(maxWidth > 0);
-
-    SDL_Color col;
-    SDL_Surface* surface = TTF_RenderUTF8_Blended_Wrapped(mFont, s.c_str(), col, maxWidth);
-    if (surface == nullptr) {
-        std::cout << "TTF_RenderUTF8_Blended_Wrapped Error: " << TTF_GetError() << std::endl;
-        return 0;
-    }
-    int h = surface->h * scale;
-    SDL_FreeSurface(surface);
-    return h;
-}
-
-void FontSDL::drawTextWrapped(unsigned int x, unsigned int y, float scale,
-                              const unsigned char color[4], unsigned int maxWidth, std::string s) {
-    assert(mFontInit == true);
-    assert(mFont != nullptr);
-    assert(s.length() > 0);
-    assert(maxWidth > 0);
-
-    SDL_Color col;
-    col.r = color[0];
-    col.g = color[1];
-    col.b = color[2];
-    col.a = color[3];
-
-    SDL_Surface* surface = TTF_RenderUTF8_Blended_Wrapped(mFont, s.c_str(), col, maxWidth);
-    if (surface == nullptr) {
-        std::cout << "TTF_RenderUTF8_Blended_Wrapped Error: " << TTF_GetError() << std::endl;
-        return;
-    }
-
-    int w = (int)((float)surface->w * scale);
-    int h = (int)((float)surface->h * scale);
-
-    ColorMode textureFormat;
-    unsigned int bpp = 0;
-    if (surface->format->BytesPerPixel == 4) {
-        if (surface->format->Rmask == 0x000000FF)
-            textureFormat = ColorMode::RGBA;
-        else
-            textureFormat = ColorMode::BGRA;
-        bpp = 32;
-    } else {
-        if (surface->format->Rmask == 0x000000FF)
-            textureFormat = ColorMode::RGB;
-        else
-            textureFormat = ColorMode::BGR;
-        bpp = 24;
-    }
-
-    TextureManager::loadBufferSlot(static_cast<unsigned char*>(surface->pixels),
-                                   surface->w, surface->h, textureFormat, bpp,
-                                   TextureStorage::SYSTEM, mFontTexture);
-    SDL_FreeSurface(surface);
-
-    std::vector<glm::vec2> vertices;
-    std::vector<glm::vec2> uvs;
-
-    vertices.push_back(glm::vec2(x, y + h));
-    vertices.push_back(glm::vec2(x, y));
-    vertices.push_back(glm::vec2(x + w, y + h));
-
-    vertices.push_back(glm::vec2(x + w, y));
-    vertices.push_back(glm::vec2(x + w, y + h));
-    vertices.push_back(glm::vec2(x, y));
-
-    uvs.push_back(glm::vec2(0.0f, 1.0f));
-    uvs.push_back(glm::vec2(0.0f, 0.0f));
-    uvs.push_back(glm::vec2(1.0f, 1.0f));
-
-    uvs.push_back(glm::vec2(1.0f, 0.0f));
-    uvs.push_back(glm::vec2(1.0f, 1.0f));
-    uvs.push_back(glm::vec2(0.0f, 0.0f));
-
-    vertexBuffer.bufferData(vertices);
-    uvBuffer.bufferData(uvs);
-    Shader::drawGL(vertexBuffer, uvBuffer, glm::vec4(1.0f, 1.0f, 1.0f, 1.0f),
-                   mFontTexture, TextureStorage::SYSTEM);
-}
-

src/system/FontTRLE.cpp

@@ -1,6 +1,6 @@
 /*!
  * \file src/system/FontTRLE.cpp
- * \brief SDL Font implementation
+ * \brief Tomb Raider Level Editor Font loader
  *
  * \author xythobuz
  */

src/system/FontTTF.cpp

@@ -0,0 +1,327 @@
+/*!
+ * \file src/system/FontTTF.cpp
+ * \brief TrueType Font implementation
+ *
+ * \author xythobuz
+ */
+
+#include <fstream>
+
+#include "global.h"
+#include "Log.h"
+#include "TextureManager.h"
+#include "utils/pixel.h"
+#include "system/FontTTF.h"
+
+#define MAP_WIDTH 512
+#define MAP_HEIGHT 512
+#define FONT_SIZE 30
+#define MAP_NUM_CHARS 50
+
+FontMapTTF::FontMapTTF() : begin(-1), texture(-1), charInfo(nullptr) { }
+
+FontMapTTF::FontMapTTF(FontMapTTF&& other) {
+    begin = other.begin;
+    texture = other.texture;
+    other.begin = other.texture = -1;
+    charInfo = other.charInfo;
+    other.charInfo = nullptr;
+}
+
+FontMapTTF::~FontMapTTF() {
+    if (charInfo != nullptr) {
+        delete [] charInfo;
+    }
+
+    if (texture > -1) {
+        //! \todo _Free_ the TextureManager buffer slot
+    }
+}
+
+int FontMapTTF::initialize(unsigned char* fontData, int firstChar) {
+    stbtt_pack_context context;
+    unsigned char* pixels = new unsigned char[MAP_WIDTH * MAP_HEIGHT];
+    if (!stbtt_PackBegin(&context, pixels, MAP_WIDTH, MAP_HEIGHT, 0, 1, nullptr)) {
+        delete [] pixels;
+        getLog() << "Error initializing font map in stbtt_PackBegin!" << Log::endl;
+        return -1;
+    }
+
+    stbtt_PackSetOversampling(&context, 2, 2);
+
+    if (charInfo != nullptr)
+        delete [] charInfo;
+
+    charInfo = new stbtt_packedchar[MAP_NUM_CHARS];
+    if (!stbtt_PackFontRange(&context, fontData, 0, FONT_SIZE, firstChar, MAP_NUM_CHARS, charInfo)) {
+        stbtt_PackEnd(&context);
+        delete [] pixels;
+        delete [] charInfo;
+        charInfo = nullptr;
+        getLog() << "Error packing font map!" << Log::endl;
+        return -2;
+    }
+
+    stbtt_PackEnd(&context);
+    unsigned char* rgb = grayscale2rgba(pixels, MAP_WIDTH, MAP_HEIGHT);
+    delete [] pixels;
+
+    texture = TextureManager::loadBufferSlot(rgb, MAP_WIDTH, MAP_HEIGHT, ColorMode::RGBA,
+                                             32, TextureStorage::SYSTEM, texture);
+    delete [] rgb;
+    if (texture < 0) {
+        delete [] charInfo;
+        charInfo = nullptr;
+        getLog() << "Error loading new font map texture!" << Log::endl;
+        return -3;
+    }
+
+    begin = firstChar;
+    return 0;
+}
+
+bool FontMapTTF::contains(int c) {
+    assert(begin >= 0);
+    return (begin >= 0) && (c >= begin) && (c < (begin + MAP_NUM_CHARS));
+}
+
+void FontMapTTF::getQuad(int c, float* xpos, float* ypos, stbtt_aligned_quad *quad) {
+    assert(contains(c));
+    stbtt_GetPackedQuad(charInfo, MAP_WIDTH, MAP_HEIGHT, c - begin, xpos, ypos, quad, 0);
+}
+
+// ----------------------------------------------------------------------------
+
+unsigned char* FontTTF::fontData = nullptr;
+std::vector<FontMapTTF> FontTTF::maps;
+ShaderBuffer FontTTF::vertexBuffer;
+ShaderBuffer FontTTF::uvBuffer;
+
+int FontTTF::initialize(std::string f) {
+    assert(f.length() > 0);
+
+    std::ifstream file(f, std::ios::binary);
+    if (!file) {
+        getLog() << "Couldn't open file \"" << f << "\"!" << Log::endl;
+        return -1;
+    }
+
+    file.seekg(0, std::ios::end);
+    auto size = file.tellg();
+    assert(size > 0);
+    file.seekg(0);
+
+    maps.clear();
+    if (fontData != nullptr) {
+        delete [] fontData;
+        fontData = nullptr;
+    }
+
+    fontData = new unsigned char[size];
+    if (!file.read(reinterpret_cast<char*>(fontData), size)) {
+        getLog() << "Couldn't read data in \"" << f << "\"" << Log::endl;
+        delete [] fontData;
+        fontData = nullptr;
+        return -2;
+    }
+
+    maps.emplace_back();
+    if (maps.at(0).initialize(fontData, ' ') < 0) {
+        delete [] fontData;
+        fontData = nullptr;
+        return -3;
+    }
+
+    return 0;
+}
+
+void FontTTF::shutdown() {
+    if (fontData != nullptr) {
+        delete [] fontData;
+        fontData = nullptr;
+    }
+
+    maps.clear();
+}
+
+unsigned int FontTTF::widthText(float scale, std::string s) {
+    float x = 0.0f, y = 0.0f;
+    stbtt_aligned_quad q;
+    for (int i = 0; i < s.length(); i++) {
+        if ((s[i] < 0x20) || (s[i] == 0x7F)) {
+            continue;
+        }
+
+        getQuad(s[i], &x, &y, &q);
+    }
+    return x * scale;
+}
+
+void FontTTF::drawText(unsigned int x, unsigned int y, float scale,
+                       const unsigned char color[4], std::string s) {
+    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;
+    float xpos = x, ypos = y + (FONT_SIZE * scale);
+    for (int i = 0; i < s.length(); i++) {
+        if ((s[i] < 0x20) || (s[i] == 0x7F)) {
+            continue;
+        }
+
+        stbtt_aligned_quad quad;
+        int tex = getQuad(s[i], &xpos, &ypos, &quad);
+
+        if ((texture != tex) && (texture != -1)) {
+            vertexBuffer.bufferData(vertices);
+            uvBuffer.bufferData(uvs);
+            Shader::drawGL(vertexBuffer, uvBuffer, col, texture);
+            vertices.clear();
+            uvs.clear();
+        }
+
+        texture = tex;
+
+        glm::vec2 v1(quad.x0, quad.y0);
+        glm::vec2 v2(quad.x0, quad.y0 + ((quad.y1 - quad.y0) * scale));
+        glm::vec2 v3(quad.x0 + ((quad.x1 - quad.x0) * scale), quad.y0 + ((quad.y1 - quad.y0) * scale));
+        glm::vec2 v4(quad.x0 + ((quad.x1 - quad.x0) * scale), quad.y0);
+        glm::vec2 u1(quad.s0, quad.t0);
+        glm::vec2 u2(quad.s0, quad.t1);
+        glm::vec2 u3(quad.s1, quad.t1);
+        glm::vec2 u4(quad.s1, quad.t0);
+
+        vertices.push_back(v1);
+        vertices.push_back(v2);
+        vertices.push_back(v3);
+        vertices.push_back(v4);
+        vertices.push_back(v1);
+        vertices.push_back(v3);
+
+        uvs.push_back(u1);
+        uvs.push_back(u2);
+        uvs.push_back(u3);
+        uvs.push_back(u4);
+        uvs.push_back(u1);
+        uvs.push_back(u3);
+    }
+
+    vertexBuffer.bufferData(vertices);
+    uvBuffer.bufferData(uvs);
+    Shader::drawGL(vertexBuffer, uvBuffer, col, texture);
+}
+
+unsigned int FontTTF::heightText(float scale, unsigned int maxWidth, std::string s) {
+    float x = 0.0f, y = FONT_SIZE;
+    stbtt_aligned_quad q;
+    for (int i = 0; i < s.length(); i++) {
+        if ((s[i] < 0x20) || (s[i] == 0x7F)) {
+            continue;
+        }
+
+        getQuad(s[i], &x, &y, &q);
+        if (x > maxWidth) {
+            x = 0.0f;
+            y += FONT_SIZE;
+        }
+    }
+    return y * scale;
+}
+
+void FontTTF::drawTextWrapped(unsigned int x, unsigned int y, float scale,
+                              const unsigned char color[4], unsigned int maxWidth, std::string s) {
+    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;
+    float xpos = x, ypos = y + (FONT_SIZE * scale);
+    for (int i = 0; i < s.length(); i++) {
+        if ((s[i] < 0x20) || (s[i] == 0x7F)) {
+            continue;
+        }
+
+        stbtt_aligned_quad quad;
+        int tex = getQuad(s[i], &xpos, &ypos, &quad);
+
+        if (xpos > (x + maxWidth)) {
+            xpos = x;
+            ypos += FONT_SIZE * scale;
+            if (s[i] != ' ')
+                i--;
+            continue;
+        }
+
+        if ((texture != tex) && (texture != -1)) {
+            vertexBuffer.bufferData(vertices);
+            uvBuffer.bufferData(uvs);
+            Shader::drawGL(vertexBuffer, uvBuffer, col, texture);
+            vertices.clear();
+            uvs.clear();
+        }
+
+        texture = tex;
+
+        glm::vec2 v1(quad.x0, quad.y0);
+        glm::vec2 v2(quad.x0, quad.y0 + ((quad.y1 - quad.y0) * scale));
+        glm::vec2 v3(quad.x0 + ((quad.x1 - quad.x0) * scale), quad.y0 + ((quad.y1 - quad.y0) * scale));
+        glm::vec2 v4(quad.x0 + ((quad.x1 - quad.x0) * scale), quad.y0);
+        glm::vec2 u1(quad.s0, quad.t0);
+        glm::vec2 u2(quad.s0, quad.t1);
+        glm::vec2 u3(quad.s1, quad.t1);
+        glm::vec2 u4(quad.s1, quad.t0);
+
+        vertices.push_back(v1);
+        vertices.push_back(v2);
+        vertices.push_back(v3);
+        vertices.push_back(v4);
+        vertices.push_back(v1);
+        vertices.push_back(v3);
+
+        uvs.push_back(u1);
+        uvs.push_back(u2);
+        uvs.push_back(u3);
+        uvs.push_back(u4);
+        uvs.push_back(u1);
+        uvs.push_back(u3);
+    }
+
+    vertexBuffer.bufferData(vertices);
+    uvBuffer.bufferData(uvs);
+    Shader::drawGL(vertexBuffer, uvBuffer, col, texture);
+}
+
+int FontTTF::charIsMapped(int c) {
+    for (int i = 0; i < maps.size(); i++) {
+        if (maps.at(i).contains(c)) {
+            return i;
+        }
+    }
+
+    int begin = c;
+    if (c >= (MAP_NUM_CHARS / 2))
+        begin -= (MAP_NUM_CHARS / 2);
+
+    getLog() << "Unmapped character " << c << ", new map from " << begin << " to "
+             << begin + MAP_NUM_CHARS - 1 << "..." << Log::endl;
+
+    int p = maps.size();
+    maps.emplace_back();
+    if (maps.at(p).initialize(fontData, begin) < 0) {
+        return -1;
+    }
+
+    return p;
+}
+
+int FontTTF::getQuad(int c, float* xpos, float* ypos, stbtt_aligned_quad *quad) {
+    if (c < 0) {
+        //! \todo This has nothing to do with proper UTF8 support...
+        c += 128;
+    }
+
+    int map = charIsMapped(c);
+    assert(map >= 0);
+    maps.at(map).getQuad(c, xpos, ypos, quad);
+    return maps.at(map).getTexture();
+}
+

src/utils/pixel.cpp

@@ -86,6 +86,21 @@ unsigned char* argb16to32(unsigned char* image, unsigned int w, unsigned int h)
     return img;
 }
 
+unsigned char* grayscale2rgba(unsigned char* image, unsigned int w, unsigned int h) {
+    assert(image != nullptr);
+    assert(w > 0);
+    assert(h > 0);
+
+    unsigned char* img = new unsigned char[w * h * 4];
+    for (unsigned int i = 0; i < (w * h); i++) {
+        img[i * 4] = image[i];
+        img[(i * 4) + 1] = image[i];
+        img[(i * 4) + 2] = image[i];
+        img[(i * 4) + 3] = (image[i] == 0) ? 0 : 255;
+    }
+    return img;
+}
+
 #define NEXT_POWER(x) do {        \
     unsigned int i;               \
     for (i = 1; i < (x); i *= 2); \