Merge pull request #2 from tcsullivan/font-support

Font support

10 files changed, 657 insertions, 97 deletions

diff --git a/src/components/Text.hpp b/src/components/Text.hpp
new file mode 100644
index 0000000..9566499
--- /dev/null
+++ b/src/components/Text.hpp
@@ -0,0 +1,71 @@
+/**
+ * @file Text.hpp
+ * Allows text to be shown with an entity.
+ *
+ * Copyright (C) 2019 Clyne Sullivan
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef COMPONENT_TEXT_HPP_
+#define COMPONENT_TEXT_HPP_
+
+#include "Component.hpp"
+
+struct Text : Component<Text>
+{
+public:
+    std::string font;
+    std::string text;
+    double offsetX, offsetY;
+
+    Text(const std::string& _font, const std::string& _text) :
+        font(_font), text(_text), offsetX(0), offsetY(0) {}
+    Text(const std::string& _font, const std::string& _text,
+         double _x, double _y) :
+        font(_font), text(_text), x(_x), y(_y) {}
+
+    Text FromLua(sol::object ref)
+    {
+        if (ref.get_type() == sol::type::table) {
+            sol::table tab = ref;
+            if (tab["font"] != nullptr)
+                this->font = tab["font"];
+            if (tab["text"] != nullptr)
+                this->text = tab["text"];
+            if (tab["x"] != nullptr)
+                this->x = tab["x"];
+            if (tab["y"] != nullptr)
+                this->y = tab["y"];
+        } else {
+            throw std::string("Text table not formatted properly");
+        }
+        return *this;
+    }
+
+    void serialize(cereal::JSONOutputArchive& ar) final {
+        ar(CEREAL_NVP(font), CEREAL_NVP(text), CEREAL_NVP(x), CEREAL_NVP(y));
+    }
+
+    void serialize(cereal::JSONInputArchive& ar) final {
+        ar(CEREAL_NVP(font), CEREAL_NVP(text), CEREAL_NVP(x), CEREAL_NVP(y));
+    }
+
+    std::string serializeName(void) const final {
+        return "Text";
+    }
+};
+
+#endif // COMPONENT_TEXT_HPP_
+
diff --git a/src/engine.cpp b/src/engine.cpp
index a2d0e9b..a000979 100644
--- a/src/engine.cpp
+++ b/src/engine.cpp
@@ -27,6 +27,7 @@
 #include "script.hpp"
 #include "render.hpp"
 #include "physics.hpp"
+#include "text.hpp"
 
 #include "components/EventListener.hpp"
 #include "components/Script.hpp"
@@ -48,10 +49,22 @@ int Engine::init(void)
     systems.add<RenderSystem>();
     systems.add<ScriptSystem>(entities, *(systems.system<WorldSystem>().get()));
     systems.add<PhysicsSystem>();
+    systems.add<TextSystem>();
     systems.configure();
 
     // Load game script and entity data
-    systems.system<ScriptSystem>()->init();
+    auto* script = systems.system<ScriptSystem>().get();
+    script->addToGameNamespace("loadFont",
+    [this](std::string name, std::string file, int size) {
+        systems.system<TextSystem>().get()->loadFont(name, file, size);
+    });
+    script->addToGameNamespace("puts",
+    [this](std::string name, float x, float y, std::string text) {
+        systems.system<TextSystem>().get()->put(name, x, y, text);
+    });
+    script->init();
+    
+
     if (GameState::load("save.json", entities)) {
         std::cout << "Loaded from save.json. Delete the file if you don't want "
                      "it." << std::endl;
@@ -71,8 +84,15 @@ void Engine::logicLoop(void)
                                     the logic loop is run during our first
                                     loop. */
 
+    auto start = mc::now();
     while (shouldRun()) {
-        auto start = mc::now();
+        auto end = start;
+        start = mc::now();
+        auto diff = start-end;
+        auto micros = cr::duration_cast<cr::microseconds>(diff);
+        auto msc = micros.count();
+        dt = static_cast<double>(msc) / 1000.0;
+        elapsed += dt;
 
         systems.update<InputSystem>(dt);
         //systems.update<ScriptSystem>(dt);
@@ -94,41 +114,34 @@ void Engine::logicLoop(void)
         }
 
         std::this_thread::yield();
-
-        auto end = mc::now();
-        auto diff = end - start;
-        auto micros = cr::duration_cast<cr::microseconds>(diff);
-        auto msc = micros.count();
-        dt = static_cast<double>(msc) / 1000.0;
-        elapsed += dt;
     }
 }
 
 void Engine::physicsLoop(void)
 {
     entityx::TimeDelta dt = 0; /**< Elapsed milliseconds since each loop */
-
+    auto start = mc::now();
     while (shouldRun()) {
-        auto start = mc::now();
+        auto end = start;
+        start = mc::now();
+
+        auto diff = start - end;
+        auto micros = cr::duration_cast<cr::microseconds>(diff);
+        auto msc = micros.count();
+        dt = static_cast<double>(msc) / 1000.0;
 
         // Update the entities physics/position
         systems.update<PhysicsSystem>(dt);
 
         std::this_thread::yield();
-
-        auto end = mc::now();
-        auto diff = end - start;
-        auto micros = cr::duration_cast<cr::microseconds>(diff);
-        auto msc = micros.count();
-        dt = static_cast<double>(msc) / 1000.0;
     }
-    std::cout << std::endl;
 }
 
 void Engine::renderLoop(void)
 {
     entityx::TimeDelta dt = 0; /**< Elapsed milliseconds since each loop */
     while (shouldRun()) {
+        systems.update<TextSystem>(dt);
         systems.update<RenderSystem>(dt);
     }
 }
diff --git a/src/events/render.hpp b/src/events/render.hpp
new file mode 100644
index 0000000..bcecac6
--- /dev/null
+++ b/src/events/render.hpp
@@ -0,0 +1,16 @@
+#ifndef EVENTS_RENDER_HPP_
+#define EVENTS_RENDER_HPP_
+
+struct NewRenderEvent
+{
+    GLuint vbo;
+    GLuint tex;
+    GLuint normal;
+    unsigned int vertex;
+
+    NewRenderEvent(GLuint _vbo, GLuint _tex, GLuint _normal, unsigned int _vertex) :
+        vbo(_vbo), tex(_tex), normal(_normal), vertex(_vertex) {}
+};
+
+#endif // EVENTS_RENDER_HPP_
+
diff --git a/src/render.cpp b/src/render.cpp
index 2b49b2c..9e63a71 100644
--- a/src/render.cpp
+++ b/src/render.cpp
@@ -27,8 +27,10 @@
 void RenderSystem::configure([[maybe_unused]] entityx::EntityManager& entities,
                              [[maybe_unused]] entityx::EventManager& events)
 {
+    events.subscribe<NewRenderEvent>(*this);
     events.subscribe<WorldMeshUpdateEvent>(*this);
     events.subscribe<entityx::ComponentAddedEvent<Player>>(*this);
+
     init();
 }
 
@@ -37,24 +39,34 @@ void RenderSystem::update([[maybe_unused]] entityx::EntityManager& entities,
                           [[maybe_unused]] entityx::TimeDelta dt)
 {
     // TODO move these to only happen once to speed up rendering
-    GLuint s = worldShader.getProgram();
-    GLuint v = worldShader.getUniform("view");
-    GLuint p = worldShader.getUniform("projection");
-    GLuint m = worldShader.getUniform("model");
-    GLuint a = worldShader.getAttribute("vertex");
-    GLuint t = worldShader.getAttribute("texc");
-
-    GLuint q = worldShader.getUniform("textu");
-    GLuint n = worldShader.getUniform("normu");
-    GLuint b = worldShader.getUniform("AmbientLight");
-    GLuint f = worldShader.getUniform("Flipped");
+    static GLuint s = worldShader.getProgram();
+    static GLuint v = worldShader.getUniform("view");
+    static GLuint p = worldShader.getUniform("projection");
+    static GLuint m = worldShader.getUniform("model");
+    static GLuint a = worldShader.getAttribute("vertex");
+    static GLuint t = worldShader.getAttribute("texc");
+    static GLuint r = worldShader.getAttribute("trans");
+
+    static GLuint q = worldShader.getUniform("textu");
+    static GLuint n = worldShader.getUniform("normu");
+    static GLuint b = worldShader.getUniform("AmbientLight");
+    static GLuint f = worldShader.getUniform("Flipped");
+
+    static glm::vec3 rot = glm::vec3(0.0f, 0.0f, -1.0f);
+    camPos.z = 15.0f;
 
     /***********
     *  SETUP  *
     ***********/
+
+    glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
+    glEnable(GL_DEPTH_TEST);
+    glEnable(GL_CULL_FACE);
+    glEnable(GL_POLYGON_OFFSET_FILL);
+
     
     glm::mat4 view = glm::lookAt(camPos,                       // Pos
-                                 glm::vec3(camPos.x, camPos.y, 0.0f),  // Facing
+                                 camPos + rot,                       // Facing
                                  glm::vec3(0.0f, 1.0f, 0.0f)); // Up
 
     //glm::mat4 projection = glm::perspective(45.0f, 
@@ -66,30 +78,32 @@ void RenderSystem::update([[maybe_unused]] entityx::EntityManager& entities,
     float scaleWidth = static_cast<float>(width) / scale;
     float scaleHeight = static_cast<float>(height) / scale;
 
-    glm::mat4 projection = glm::ortho(-(scaleWidth/2),    // Left
-                                       (scaleWidth/2),    // Right
-                                      -(scaleHeight/2),   // Bottom
-                                       (scaleHeight/2),   // Top
-                                       10.0f,               // zFar
-                                      -10.0f                // zNear
-                                     );
+    //glm::mat4 projection = glm::ortho(-(scaleWidth/2),    // Left
+    //                                   (scaleWidth/2),    // Right
+    //                                  -(scaleHeight/2),   // Bottom
+    //                                   (scaleHeight/2),   // Top
+    //                                   100.0f,               // zFar
+    //                                  -100.0f                // zNear
+    //                                 );
+
+    glm::mat4 projection = glm::perspective(45.0f, 
+                                            ((float)width/(float)height), 
+                                            0.01f, 
+                                            2048.0f);
 
     glm::mat4 model = glm::mat4(1.0f);
+    model = glm::scale(model, glm::vec3(1.0f, 1.0f, -1.0f));
 
     glUseProgram(s);
 
-    glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
-    glEnable(GL_DEPTH_TEST);
 
     glUniformMatrix4fv(v, 1, GL_FALSE, glm::value_ptr(view));
     glUniformMatrix4fv(p, 1, GL_FALSE, glm::value_ptr(projection));
     glUniformMatrix4fv(m, 1, GL_FALSE, glm::value_ptr(model));
 
-    glEnable(GL_CULL_FACE);
-    glEnable(GL_POLYGON_OFFSET_FILL);
-
     glEnableVertexAttribArray(a);
     glEnableVertexAttribArray(t);
+    glEnableVertexAttribArray(r);
 
     // Ambient light, for now this is static
     GLfloat amb[4] = {1.0f, 1.0f, 1.0f, 0.0f};
@@ -138,9 +152,9 @@ void RenderSystem::update([[maybe_unused]] entityx::EntityManager& entities,
     *************/
 
     entities.each<Render, Position>(
-        [this, a, q, t, n, f](entityx::Entity, Render &r, Position &p) {
+        [this](entityx::Entity, Render &rend, Position &p) {
 
-        if (!r.visible)
+        if (!rend.visible)
             return;
 
         // If our component was created via script, call the entity's
@@ -150,28 +164,28 @@ void RenderSystem::update([[maybe_unused]] entityx::EntityManager& entities,
         //}
 
         float w = 0.5f;
-        float h = (float)r.texture.height/r.texture.width;
+        float h = (float)rend.texture.height/rend.texture.width;
 
         GLuint tri_vbo;
         GLfloat tri_data[] = {
-                (float)p.x-w, (float)p.y  , 00.0f, 0.0f, 1.0f,
-                (float)p.x+w, (float)p.y  , 00.0f, 1.0f, 1.0f,
-                (float)p.x-w, (float)p.y+h, 00.0f, 0.0f, 0.0f,
-
-                (float)p.x+w, (float)p.y  , 00.0f, 1.0f, 1.0f,
-                (float)p.x+w, (float)p.y+h, 00.0f, 1.0f, 0.0f,
-                (float)p.x-w, (float)p.y+h, 00.0f, 0.0f, 0.0f,
+                (float)p.x-w, (float)p.y  , 0.0f, 0.0f, 1.0f, 1.0f,
+                (float)p.x+w, (float)p.y  , 0.0f, 1.0f, 1.0f, 1.0f,
+                (float)p.x-w, (float)p.y+h, 0.0f, 0.0f, 0.0f, 1.0f,
+                                                             
+                (float)p.x+w, (float)p.y  , 0.0f, 1.0f, 1.0f, 1.0f,
+                (float)p.x+w, (float)p.y+h, 0.0f, 1.0f, 0.0f, 1.0f,
+                (float)p.x-w, (float)p.y+h, 0.0f, 0.0f, 0.0f, 1.0f,
         };
 
         bool flipped = false;
 
         // TODO flip nicely (aka model transformations)
-        if (r.flipX) {
-            std::swap(tri_data[3], tri_data[8]);
-            tri_data[13] = tri_data[3];
+        if (rend.flipX) {
+            std::swap(tri_data[3], tri_data[9]);
+            tri_data[15] = tri_data[3];
 
-            std::swap(tri_data[23], tri_data[28]);
-            tri_data[18] = tri_data[23];
+            std::swap(tri_data[27], tri_data[33]);
+            tri_data[21] = tri_data[27];
 
             flipped = true;
         }
@@ -179,11 +193,11 @@ void RenderSystem::update([[maybe_unused]] entityx::EntityManager& entities,
         glUniform1i(f, flipped ? 1 : 0);
 
         glActiveTexture(GL_TEXTURE0);
-        glBindTexture(GL_TEXTURE_2D, r.texture.tex);
+        glBindTexture(GL_TEXTURE_2D, rend.texture.tex);
         glUniform1i(q, 0);
 
         glActiveTexture(GL_TEXTURE1);
-        glBindTexture(GL_TEXTURE_2D, r.normal.tex);
+        glBindTexture(GL_TEXTURE_2D, rend.normal.tex);
         glUniform1i(n, 1);
 
         glGenBuffers(1, &tri_vbo);
@@ -191,9 +205,11 @@ void RenderSystem::update([[maybe_unused]] entityx::EntityManager& entities,
         glBufferData(GL_ARRAY_BUFFER, sizeof(tri_data), tri_data, GL_STREAM_DRAW);
 
         glVertexAttribPointer(a, 3, GL_FLOAT, GL_FALSE,
-                              5*sizeof(float), 0);
-        glVertexAttribPointer(t, 2, GL_FLOAT, GL_FALSE, 
-                              5*sizeof(float), (void*)(3*sizeof(float)));
+                              6*sizeof(float), 0);
+        glVertexAttribPointer(t, 2, GL_FLOAT, GL_FALSE,
+                              6*sizeof(float), (void*)(3*sizeof(float)));
+        glVertexAttribPointer(r, 1, GL_FLOAT, GL_FALSE,
+                              6*sizeof(float), (void*)(5*sizeof(float)));
         glDrawArrays(GL_TRIANGLES, 0, 6);
     });
     glUniform1i(f, 0);
@@ -209,37 +225,91 @@ void RenderSystem::update([[maybe_unused]] entityx::EntityManager& entities,
         glUniform1i(n, 1);
 
         glBindBuffer(GL_ARRAY_BUFFER, worldVBO);
-        //glBufferData(GL_ARRAY_BUFFER, 
-        //             wm.size() * sizeof(WorldMeshData), 
-        //             &wm.front(), 
-        //             GL_STREAM_DRAW);
-
         glVertexAttribPointer(a, 3, GL_FLOAT, GL_FALSE,
                               6*sizeof(float), 0);
         glVertexAttribPointer(t, 2, GL_FLOAT, GL_FALSE, 
                               6*sizeof(float), (void*)(3*sizeof(float)));
+        glVertexAttribPointer(r, 1, GL_FLOAT, GL_FALSE, 
+                              6*sizeof(float), (void*)(5*sizeof(float)));
         glDrawArrays(GL_TRIANGLES, 0, worldVertex);
     }
 
+    glDisableVertexAttribArray(a);
+    glDisableVertexAttribArray(t);
+
+    glUseProgram(0);
+
+    /******************
+    *  UI RENDERING  *
+    ******************/
+
+    static GLuint uiS   = uiShader.getProgram();
+    static GLuint uiS_v = uiShader.getUniform("view");
+    static GLuint uiS_p = uiShader.getUniform("projection");
+    static GLuint uiS_m = uiShader.getUniform("model");
+    static GLuint uiS_a = uiShader.getAttribute("coord2d");
+    static GLuint uiS_t = uiShader.getAttribute("tex_coord");
+    static GLuint uiS_q = uiShader.getUniform("sampler");
+
+    glUseProgram(uiS);
+
+    view = glm::lookAt(glm::vec3(0.0f, 0.0f, 10.0f),  // Pos
+                       glm::vec3(0.0f, 0.0f, 1.0f),  // Facing
+                       glm::vec3(0.0f, 1.0f, 0.0f)); // Up
+
+    scale = 1.0f;
+    scaleWidth = static_cast<float>(width) / scale;
+    scaleHeight = static_cast<float>(height) / scale;
+
+    projection = glm::ortho(-scaleWidth/2.0f, // Left
+                             scaleWidth/2,    // Right
+                            -scaleHeight/2,   // Bottom
+                             scaleHeight/2,   // Top
+                             100.0f,          // zFar
+                            -100.0f);         // zNear
+
+    model = glm::mat4(1.0f);
+
+    glUniformMatrix4fv(uiS_v, 1, GL_FALSE, glm::value_ptr(view));
+    glUniformMatrix4fv(uiS_p, 1, GL_FALSE, glm::value_ptr(projection));
+    glUniformMatrix4fv(uiS_m, 1, GL_FALSE, glm::value_ptr(model));
+
+    glEnableVertexAttribArray(uiS_a);
+    glEnableVertexAttribArray(uiS_t);
+
+    // Update all UI VBOs
+    for (auto& r : uiRenders) {
+        auto& render = r.second;
+
+        glActiveTexture(GL_TEXTURE9);
+        glBindTexture(GL_TEXTURE_2D, render.tex);
+        glUniform1i(uiS_q, 9);
+
+        glBindBuffer(GL_ARRAY_BUFFER, r.first);
+        glVertexAttribPointer(uiS_a, 3, GL_FLOAT, GL_FALSE,
+                              6*sizeof(float), 0);
+        glVertexAttribPointer(uiS_t, 2, GL_FLOAT, GL_FALSE, 
+                              6*sizeof(float), (void*)(3*sizeof(float)));
+        glDrawArrays(GL_TRIANGLES, 0, render.vertex);
+    }
+
+    glDisableVertexAttribArray(uiS_a);
+    glDisableVertexAttribArray(uiS_t);
+
     /*************
     *  CLEANUP  *
     *************/
-    glDisableVertexAttribArray(a);
-    glDisableVertexAttribArray(t);
+
+    glUseProgram(0);
 
     glDisable(GL_POLYGON_OFFSET_FILL);
     glDisable(GL_CULL_FACE);
 
-    glUseProgram(0);
-
     SDL_GL_SwapWindow(window.get());
 }
 
 int RenderSystem::init(void)
 {
-    // Select an OpenGL 4.3 profile.
-    SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 4);
-    SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 3);
 
     if (SDL_InitSubSystem(SDL_INIT_VIDEO) != 0) {
         std::cerr << "SDL video failed to initialize: "
@@ -259,6 +329,13 @@ int RenderSystem::init(void)
         return -1;
     }
 
+    // Select an OpenGL 4.3 profile.
+    SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK,
+                        SDL_GL_CONTEXT_PROFILE_CORE);
+    SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
+    SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 0);
+    SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, 8);
+
     context = SDL_GL_CreateContext(window.get());
 
     GLenum err;
@@ -284,6 +361,7 @@ int RenderSystem::init(void)
 
     worldShader.addAttribute("vertex");
     worldShader.addAttribute("texc");
+    worldShader.addAttribute("trans");
 
     worldShader.addUniform("textu");
     worldShader.addUniform("normu");
@@ -294,10 +372,20 @@ int RenderSystem::init(void)
     worldShader.addUniform("AmbientLight");
     worldShader.addUniform("Flipped");
 
+    uiShader.createProgram("Shaders/ui.vert", "Shaders/ui.frag");
+
+    uiShader.addUniform("projection");
+    uiShader.addUniform("view");
+    uiShader.addUniform("model");
+
+    uiShader.addAttribute("coord2d");
+    uiShader.addAttribute("tex_coord");
+
+    uiShader.addUniform("sampler");
+
     glEnableVertexAttribArray(worldShader.getAttribute("vertex"));
-    glUseProgram(worldShader.getProgram());
+    glEnableVertexAttribArray(uiShader.getAttribute("coord2d"));
 
-    // TODO
     //glPolygonOffset(1.0, 1.0);
 
     //glClearColor(0.6, 0.8, 1.0, 0.0);
@@ -310,6 +398,13 @@ int RenderSystem::init(void)
 /************
 *  EVENTS  *
 ************/
+
+void RenderSystem::receive(const NewRenderEvent &nre)
+{
+    uiRenders.insert_or_assign(nre.vbo,
+                               UIRenderData(nre.tex, nre.normal, nre.vertex));
+}
+
 void RenderSystem::receive(const WorldMeshUpdateEvent &wmu)
 {
     worldVBO = wmu.worldVBO;
@@ -322,3 +417,4 @@ void RenderSystem::receive(const entityx::ComponentAddedEvent<Player> &cae)
 {
     player = cae.entity;
 }
+
diff --git a/src/render.hpp b/src/render.hpp
index f3064d1..88668cc 100644
--- a/src/render.hpp
+++ b/src/render.hpp
@@ -36,9 +36,21 @@
 
 #include "shader.hpp"
 #include "world.hpp"
+#include "components/Player.hpp"
+#include "events/render.hpp"
 #include "events/world.hpp"
 
-#include "components/Player.hpp"
+#include <map>
+
+struct UIRenderData
+{
+    GLuint tex;
+    GLuint normal;
+    unsigned int vertex;
+
+    UIRenderData(GLuint _tex, GLuint _normal, unsigned int _vertex) :
+        tex(_tex), normal(_normal), vertex(_vertex) {}
+};
 
 class RenderSystem : public entityx::System<RenderSystem>,
                      public entityx::Receiver<RenderSystem>
@@ -52,8 +64,12 @@ private:
     SDL_GLContext context;
 
     Shader worldShader;
+    Shader uiShader;
     glm::vec3 camPos;
 
+    // Map of VBOs and their render data
+    std::map<GLuint, UIRenderData> uiRenders;
+
     GLuint worldVBO = 0;
     unsigned int worldVertex = 0;
     GLuint worldTexture = 0;
@@ -92,8 +108,8 @@ public:
     *  EVENTS  *
     ************/
     void receive(const WorldMeshUpdateEvent &wmu);
+    void receive(const NewRenderEvent &nre);
     void receive(const entityx::ComponentAddedEvent<Player> &cae);
-    
 };
 
 #endif // SYSTEM_RENDER_HPP_
diff --git a/src/script.cpp b/src/script.cpp
index fd99228..6cda627 100644
--- a/src/script.cpp
+++ b/src/script.cpp
@@ -31,6 +31,9 @@ void ScriptSystem::configure([[maybe_unused]] entityx::EntityManager& entities,
 
     // Init after systems.configure() in engine.cpp
     //init();
+    lua.open_libraries(sol::lib::base, sol::lib::math, sol::lib::string);
+
+    scriptExport();
 }
 
 #include <components/Script.hpp>
@@ -54,9 +57,6 @@ void ScriptSystem::receive([[maybe_unused]] const EntitySpawnEvent &toSpawn)
 
 int ScriptSystem::init(void)
 {
-    lua.open_libraries(sol::lib::base, sol::lib::math, sol::lib::string);
-
-    scriptExport();
     doFile();
 
     return 0;
@@ -136,10 +136,9 @@ void ScriptSystem::scriptExport(void)
             "setSize", &World::setSize,
             "getSize", &World::getSize);
 
-
-    auto gamespace = lua["game"].get_or_create<sol::table>();
-    gamespace.set_function("spawn", entitySpawn);
-    gamespace.set_function("worldRegister", worldRegister);
+    game = lua["game"].get_or_create<sol::table>();
+    game.set_function("spawn", entitySpawn);
+    game.set_function("worldRegister", worldRegister);
 }
 
 sol::table ScriptSystem::spawn(sol::object param)
diff --git a/src/script.hpp b/src/script.hpp
index 87027d5..0ac9e63 100644
--- a/src/script.hpp
+++ b/src/script.hpp
@@ -47,6 +47,7 @@ private:
      * interactions between C and Lua
      */
     sol::state lua;
+    sol::table game;
 
     entityx::EntityManager& manager;
     
@@ -102,6 +103,11 @@ public:
      * Contains all calls that export components/functions to lua.
      */
     void scriptExport(void);
+
+    template<typename F>
+    void addToGameNamespace(const std::string& name, F func) {
+        game.set_function(name, func);
+    }
 };
 
 #endif // SYSTEM_SCRIPT_HPP_
diff --git a/src/text.cpp b/src/text.cpp
new file mode 100644
index 0000000..e0eb158
--- /dev/null
+++ b/src/text.cpp
@@ -0,0 +1,223 @@
+#include "text.hpp"
+
+#include "events/render.hpp"
+
+#include <iostream>
+
+void TextSystem::configure([[maybe_unused]] entityx::EntityManager& entities,
+                           [[maybe_unused]] entityx::EventManager& events)
+{
+    if (FT_Init_FreeType(&freetype) != 0) {
+        // TODO handle error
+    }
+
+    shouldUpdateVBOs = false;
+}
+    
+/**
+ * Draws the text for all entities.
+ */
+void TextSystem::update([[maybe_unused]] entityx::EntityManager& entites,
+                        entityx::EventManager& events,
+                        [[maybe_unused]] entityx::TimeDelta dt)
+{
+    if (shouldUpdateVBOs) {
+        shouldUpdateVBOs = false;
+        updateVBOs();
+
+        for (auto& data : fontData) {
+            auto& d = data.second;
+            if (d.text.size() == 0)
+                continue;
+
+            // TODO make normal
+            events.emit<NewRenderEvent>(d.vbo, d.tex, 0, d.buffer.size());
+        }
+    }
+}
+
+void TextSystem::loadFont(const std::string& name,
+                          const std::string& file,
+                          int size)
+{
+    // Find or load font at given size
+    //
+
+    if (fonts.find(file) == fonts.end()) {
+        FT_Face face;
+        if (FT_New_Face(freetype, file.c_str(), 0, &face)) {
+            // TODO handle this error
+        }
+        fonts.emplace(file, face);
+    }
+
+    auto& face = fonts[file];
+    FT_Set_Pixel_Sizes(face, 0, size);
+    fontData.try_emplace(name);
+
+    // Calculate dimensions of final texture
+    //
+
+    float width = 0, height = 0;
+    for (int c = 32; c < 128; c++) {
+        FT_Load_Char(face, c, FT_LOAD_RENDER);
+        width += face->glyph->bitmap.width + 1;
+        height = std::max(height, static_cast<float>(face->glyph->bitmap.rows));
+    }
+
+    // Generate texture to hold entire font
+    //
+
+    auto& font = fontData[name];
+    glGenBuffers(1, &font.vbo);
+
+    glGenTextures(1, &font.tex);
+    glBindTexture(GL_TEXTURE_2D, font.tex);
+    glTexImage2D(GL_TEXTURE_2D, 0, GL_RED, width, height,
+                 0, GL_RED, GL_UNSIGNED_BYTE, 0);
+
+    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
+
+    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+
+    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+
+    //    // convert red-on-black to RGBA
+    //    auto& g = face->glyph;
+    //    std::vector<uint32_t> buf (g->bitmap.width * g->bitmap.rows, 0xFFFFFF);
+    //    for (auto j = buf.size(); j--;)
+    //        buf[j] |= g->bitmap.buffer[j] << 24;
+
+    // Load each character and add it to the texture
+    //
+
+    font.width = width;
+    font.height = height;
+
+    float offsetX = 0, offsetY = 0;
+    for (int c = 32; c < 128; c++) {
+        if (FT_Load_Char(face, c, FT_LOAD_RENDER)) {
+            std::cerr << "Unrecognized character: " << c << std::endl;
+            continue;
+        }
+
+        auto* g = face->glyph;
+        glTexSubImage2D(GL_TEXTURE_2D, 0, offsetX, offsetY,
+                        g->bitmap.width, g->bitmap.rows,
+                        GL_RED, GL_UNSIGNED_BYTE,
+                        g->bitmap.buffer);
+
+        auto& d = font.data[c-32];
+        d.dim = { g->bitmap.width, g->bitmap.rows };
+        d.bitmap = { g->bitmap_left, g->bitmap_top };
+        d.advance = { g->advance.x >> 6, g->advance.y >> 6 };
+
+        d.offset = { offsetX / width, offsetY / height };
+        offsetX += g->bitmap.width;// + 1.0f;
+        // Keep offsetY at zero?
+    }
+
+    std::cout << "Loaded font: " << file << " (size: " << size << ", tex: "
+              << font.tex << ")" << std::endl;
+}
+
+void TextSystem::put(const std::string& font,
+                     float x,
+                     float y,
+                     const std::string& text)
+{
+    if (fontData.find(font) == fontData.end())
+        return;
+
+    fontData[font].text.emplace_back(text, x, y, -9.0f);
+    shouldUpdateVBOs = true;
+}
+
+void TextSystem::updateVBOs(void)
+{
+    for (auto& data : fontData) {
+        auto& d = data.second;
+        d.buffer.clear();
+        for (auto& text : d.text) {
+            float tx = text.x;
+            float ty = text.y;
+            for (char c : text.text) {
+                if (c < 32)
+                    continue;
+
+                c -= 32;
+
+                float x = tx + d.data[c].bitmap.first;
+                float y = ty - (d.data[c].dim.second - d.data[c].bitmap.second);
+                float z = text.z;
+
+                float w = d.data[c].dim.first;
+                float h = d.data[c].dim.second;
+
+                tx += d.data[c].advance.first;
+                ty += d.data[c].advance.second;
+
+                if (w == 0.0f || h == 0.0f)
+                    continue;
+
+                d.buffer += {
+                    x,
+                    y,
+                    z,
+                    d.data[c].offset.first,
+                    d.data[c].offset.second+d.data[c].dim.second/d.height,
+                    1.0f
+                };
+                d.buffer += {
+                    x+w,
+                    y,
+                    z,
+                    d.data[c].offset.first+d.data[c].dim.first/d.width, 
+                    d.data[c].offset.second+d.data[c].dim.second/d.height,
+                    1.0f
+                };
+                d.buffer += {
+                    x,
+                    y+h,
+                    z,
+                    d.data[c].offset.first, 
+                    d.data[c].offset.second,
+                    1.0f
+                };
+
+                d.buffer += {
+                    x+w,
+                    y,
+                    z,
+                    d.data[c].offset.first+d.data[c].dim.first/d.width,
+                    d.data[c].offset.second+d.data[c].dim.second/d.height,
+                    1.0f
+                };
+                d.buffer += {
+                    x+w,
+                    y+h,
+                    z,
+                    d.data[c].offset.first+d.data[c].dim.first/d.width,
+                    d.data[c].offset.second,
+                    1.0f
+                };
+                d.buffer += {
+                    x,
+                    y+h,
+                    z,
+                    d.data[c].offset.first,
+                    d.data[c].offset.second,
+                    1.0f
+                };
+            }
+        }
+
+        glBindBuffer(GL_ARRAY_BUFFER, d.vbo);
+        glBufferData(GL_ARRAY_BUFFER,
+                     d.buffer.size() * sizeof(TextMeshData), d.buffer.data(),
+                     GL_DYNAMIC_DRAW);
+    }
+}
+
diff --git a/src/text.hpp b/src/text.hpp
new file mode 100644
index 0000000..d68613d
--- /dev/null
+++ b/src/text.hpp
@@ -0,0 +1,105 @@
+/**
+ * @file text.hpp
+ * Manages entity text.
+ *
+ * Copyright (C) 2019 Clyne Sullivan
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+// hello
+
+#ifndef SYSTEM_TEXT_HPP_
+#define SYSTEM_TEXT_HPP_
+
+#include <entityx/entityx.h>
+#include <ft2build.h>
+#include <freetype/freetype.h>
+#include <GL/glew.h>
+#include <SDL2/SDL_opengl.h>
+
+#include <map>
+#include <string>
+#include <tuple>
+#include <vector>
+
+struct TextMeshData
+{
+    float posX, posY, posZ;
+    float texX, texY;
+    float transparency;
+} __attribute__ ((packed));
+
+struct FT_Info {
+    std::pair<float, float> offset;
+    std::pair<float, float> dim;
+    std::pair<float, float> bitmap;
+    std::pair<float, float> advance;
+};
+
+struct Text {
+    std::string text;
+    float x;
+    float y;
+    float z;
+
+    Text(std::string _text, float _x, float _y, float _z = 0.0f) :
+        text(_text), x(_x), y(_y), z(_z) {}
+};
+
+// Stores texture and placement data for a font at a size.
+struct Font {
+    GLuint tex;
+    GLuint vbo;
+
+    float width;
+    float height;
+
+    std::array<FT_Info, 96> data;
+    // Stores currently shown text at given index into VBO?
+    std::vector<Text> text;
+    std::basic_string<TextMeshData> buffer;
+};
+
+class TextSystem : public entityx::System<TextSystem>
+{
+public:
+    /**
+     * Prepares the system for running.
+     */
+    void configure(entityx::EntityManager& entities,
+                   entityx::EventManager& events) final;
+    
+    /**
+     * Draws the text for all entities.
+     */
+    void update(entityx::EntityManager& entites,
+                entityx::EventManager& events,
+                entityx::TimeDelta dt) final;
+
+    void put(const std::string& font, float x, float y, const std::string& text);
+
+    void loadFont(const std::string& name, const std::string& file, int size);
+
+private:
+    FT_Library freetype;
+    std::map<std::string, FT_Face> fonts;
+    std::map<std::string, Font> fontData;
+    bool shouldUpdateVBOs;
+
+    void updateVBOs(void);
+};
+
+#endif // SYSTEM_TEXT_HPP_
+
diff --git a/src/world.cpp b/src/world.cpp
index c20ce17..cd89a22 100644
--- a/src/world.cpp
+++ b/src/world.cpp
@@ -18,6 +18,7 @@
  */
 
 #include "world.hpp"
+#include "events/render.hpp"
 #include "events/world.hpp"
 
 /*****************
@@ -136,7 +137,7 @@ void World::generateMesh()
 
     // Preallocate size of vertexes
     mesh = std::basic_string<WorldMeshData>();
-    for (float Z = 0; Z < data.size(); Z++) {
+    for (float Z = data.size() - 1; Z >= 0; Z--) {
         for (float X = 0; X < data.at(Z).size(); X++) {
             for (float Y = 0; Y < data.at(Z).at(X).size(); Y++) {
                 int d = data.at(Z).at(X).at(Y);
@@ -148,22 +149,35 @@ void World::generateMesh()
                 glm::vec2& to = t.offset;
                 glm::vec2& ts = t.size;
 
-                mesh += {X  , Y  , Z, to.x     , to.y+ts.y, 1.0};
-                mesh += {X+1, Y  , Z, to.x+ts.x, to.y+ts.y, 1.0};
-                mesh += {X  , Y+1, Z, to.x     , to.y     , 1.0};
+                float tr = 1.0f;
+
+                // TODO play with this a bit so it only goes trans
+                //  if player is behind the front layer
+                try {
+                    if (Z < data.size() - 1 && Z >= 0) {
+                        if (data.at(Z+1).at(X).at(Y) == -1)
+                            tr = 1.0f;
+                    }
+                } catch (...) {
+                    tr = 1.0f;
+                }
+
+                mesh += {X  , Y  , Z, to.x     , to.y+ts.y, tr};
+                mesh += {X+1, Y  , Z, to.x+ts.x, to.y+ts.y, tr};
+                mesh += {X  , Y+1, Z, to.x     , to.y     , tr};
 
-                mesh += {X+1, Y  , Z, to.x+ts.x, to.y+ts.y, 1.0};
-                mesh += {X+1, Y+1, Z, to.x+ts.x, to.y     , 1.0};
-                mesh += {X  , Y+1, Z, to.x     , to.y     , 1.0};
+                mesh += {X+1, Y  , Z, to.x+ts.x, to.y+ts.y, tr};
+                mesh += {X+1, Y+1, Z, to.x+ts.x, to.y     , tr};
+                mesh += {X  , Y+1, Z, to.x     , to.y     , tr};
             }
         }
     }
 
     glBindBuffer(GL_ARRAY_BUFFER, worldVBO);
     glBufferData(GL_ARRAY_BUFFER, 
-                 mesh.size() * sizeof(mesh), 
-                 &mesh.front(), 
-                 GL_STREAM_DRAW);
+                 mesh.size() * sizeof(WorldMeshData), 
+                 mesh.data(), 
+                 GL_STATIC_DRAW);
 
     meshUpdated = true;
 }
@@ -199,7 +213,9 @@ double World::getHeight(double x, double y, double z)
             }
         }
     } catch (...) { // If we get any errors, just let the character 
-        return y;
+        //return y;
+        (void)y;
+        return 0.0;
     }
 
     return Y;
@@ -229,7 +245,6 @@ void WorldSystem::update([[maybe_unused]]entityx::EntityManager& entities,
     if (currentWorld == nullptr) {
         currentWorld = &(worlds.front());
         events.emit<WorldChangeEvent>(currentWorld);
-        std::cout << "Emitted" << std::endl;
     }
 
     if (currentWorld->meshUpdated) {