aboutsummaryrefslogtreecommitdiffstats
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/components/Text.hpp71
-rw-r--r--src/engine.cpp16
-rw-r--r--src/events/render.hpp16
-rw-r--r--src/render.cpp31
-rw-r--r--src/render.hpp20
-rw-r--r--src/script.cpp13
-rw-r--r--src/script.hpp6
-rw-r--r--src/text.cpp152
-rw-r--r--src/text.hpp100
-rw-r--r--src/world.cpp7
10 files changed, 419 insertions, 13 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..703b45e 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;
@@ -129,6 +142,7 @@ 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..3eea57b 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();
}
@@ -221,6 +223,27 @@ void RenderSystem::update([[maybe_unused]] entityx::EntityManager& entities,
glDrawArrays(GL_TRIANGLES, 0, worldVertex);
}
+ // Update all UI VBOs
+ for (auto& r : uiRenders) {
+ auto& render = r.second;
+
+ glActiveTexture(GL_TEXTURE0);
+ glBindTexture(GL_TEXTURE_2D, render.tex);
+ glUniform1i(q, 0);
+
+ glActiveTexture(GL_TEXTURE1);
+ glBindTexture(GL_TEXTURE_2D, render.normal);
+ glUniform1i(n, 1);
+
+ glBindBuffer(GL_ARRAY_BUFFER, r.first);
+
+ 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)));
+ glDrawArrays(GL_TRIANGLES, 0, render.vertex);
+ }
+
/*************
* CLEANUP *
*************/
@@ -310,6 +333,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 +352,4 @@ void RenderSystem::receive(const entityx::ComponentAddedEvent<Player> &cae)
{
player = cae.entity;
}
+
diff --git a/src/render.hpp b/src/render.hpp
index f3064d1..eabf4be 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>
@@ -54,11 +66,15 @@ private:
Shader worldShader;
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;
GLuint worldNormal = 0;
entityx::Entity player; // Save the player so we can track the camera
+
public:
RenderSystem() :
window(nullptr, SDL_DestroyWindow) {}
@@ -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..1381eb2
--- /dev/null
+++ b/src/text.cpp
@@ -0,0 +1,152 @@
+#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];
+ glGenTextures(1, &font.tex);
+ glGenBuffers(1, &font.vbo);
+ 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
+ //
+
+ float offsetX = 0, offsetY = 0;
+ for (int c = 32; c < 128; c++) {
+ FT_Load_Char(face, c, FT_LOAD_RENDER);
+
+ 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;
+ // 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) {
+ for (char c : text.text) {
+ if (c < 32)
+ continue;
+
+ d.buffer += {
+ text.x, text.y, text.z,
+ d.data[c].offset.first, d.data[c].offset.second,
+ 1.0f
+ };
+ }
+ }
+
+ glBindBuffer(GL_ARRAY_BUFFER, d.vbo);
+ glBufferData(GL_ARRAY_BUFFER,
+ d.text.size() * sizeof(TextMeshData), d.text.data(),
+ GL_STREAM_DRAW);
+ }
+}
+
diff --git a/src/text.hpp b/src/text.hpp
new file mode 100644
index 0000000..c3479ca
--- /dev/null
+++ b/src/text.hpp
@@ -0,0 +1,100 @@
+/**
+ * @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/>.
+ */
+
+#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;
+
+ 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..93cf511 100644
--- a/src/world.cpp
+++ b/src/world.cpp
@@ -18,6 +18,7 @@
*/
#include "world.hpp"
+#include "events/render.hpp"
#include "events/world.hpp"
/*****************
@@ -233,11 +234,11 @@ void WorldSystem::update([[maybe_unused]]entityx::EntityManager& entities,
}
if (currentWorld->meshUpdated) {
- events.emit<WorldMeshUpdateEvent>(
+ events.emit<NewRenderEvent>(
currentWorld->worldVBO,
- currentWorld->mesh.size(),
currentWorld->getTexture(),
- currentWorld->getNormal()
+ currentWorld->getNormal(),
+ currentWorld->mesh.size()
);
}
}
generated by cgit v1.2.3 (git 2.39.1) at 2025-04-05 20:38:48 +0000