Text support

assets/shaders/particle.frag → assets/shaders/frag/gradient_circle.frag

@@ -1,3 +1,6 @@
+// A fragment shader that generates a texture for a gradient circle
+// with a given `color`
+
 #version 330 core
 
 precision mediump float;

assets/shaders/hsl.frag → assets/shaders/frag/hsl.frag

@@ -1,8 +1,10 @@
+// A fragment shader that generates a simple KappaPride animation
+// based on `time`.
 #version 330 core
 
 precision mediump float;
 
-uniform sampler2D atlas;
+uniform sampler2D image;
 uniform float time;
 
 in vec4 color;
@@ -15,5 +17,5 @@ vec3 hsl2rgb(vec3 c) {
 }
 
 void main() {
-    output_color = texture(atlas, uv) * vec4(hsl2rgb(vec3((time - uv.x - uv.y) * 0.5, 1.0, 0.80)), color.w);
+    output_color = texture(image, uv) * vec4(hsl2rgb(vec3((time - uv.x - uv.y) * 0.5, 1.0, 0.80)), color.w);
 }

assets/shaders/frag/texture_color.frag

@@ -0,0 +1,16 @@
+// A fragment shader that textures the fragment according to the
+// provided `image` and `uv` coordinates and multiplies it by the
+// `color`
+#version 330 core
+
+precision mediump float;
+
+uniform sampler2D image;
+
+in vec4 color;
+in vec2 uv;
+out vec4 output_color;
+
+void main() {
+    output_color = texture(image, uv) * color;
+}

assets/shaders/rect.vert → assets/shaders/vert/triangle_camera.vert

@@ -1,3 +1,5 @@
+// Vertex shader that renders a triangle with a particular `uv`
+// coordinates and `color` with applied camera_projection
 #version 330 core
 
 precision mediump float;

assets/vars.conf

@@ -1,3 +1,5 @@
+BACKGROUND_COLOR: color = 181830FF
+
 HEALTH_BAR_WIDTH: float = 200.0
 HEALTH_BAR_HEIGHT: float = 25.0
 HEALTH_BAR_PADDING: float = 20.0

src/something.cpp

@@ -52,3 +52,4 @@ struct Index {
 #include "./something_item.cpp"
 #include "./something_renderer.cpp"
 #include "./something_shader.cpp"
+#include "./something_font.cpp"

src/something_atlas.cpp

@@ -66,7 +66,7 @@ Atlas Atlas::from_config(const char *file_path, int margin)
         atlas_row += 2 * margin + textures.data[i].height;
     }
 
-    result.gl_texture = GL_Texture::from_texture(result.texture);
+    result.gl_texture = GL_Texture::from_texture(result.texture, GL_TEXTURE0);
 
     return result;
 }

src/something_font.cpp

@@ -0,0 +1,55 @@
+#include "./something_font.hpp"
+
+Font Font::from_file(const char *file_path)
+{
+    Font self = {};
+    self.texture = Texture::from_file(file_path);
+    for (int y = 0; y < self.texture.height; ++y) {
+        for (int x = 0; x < self.texture.width; ++x) {
+            RGBA32 *pixel = &self.texture.pixels[y * self.texture.width + x];
+            if (*pixel == 0xFF000000) {
+                *pixel = 0;
+            }
+        }
+    }
+
+    self.gl_texture = GL_Texture::from_texture(
+                          self.texture,
+                          GL_TEXTURE0 + 1,
+                          true);
+    self.tex_size_pix = V2(self.texture.width, self.texture.height).cast_to<size_t>();
+    const auto tex_size_cell = V2(COLS, ROWS);
+    self.char_size_pix = self.tex_size_pix / tex_size_cell;
+    self.char_size_uv = self.char_size_pix.cast_to<GLfloat>() / self.tex_size_pix.cast_to<GLfloat>();
+    return self;
+}
+
+AABB<GLfloat> Font::char_uv(char c) const
+{
+    if (32 <= c && c <= 126) {
+        // TODO(#89): Font::char_uv should be implementing entirely in a shader
+        const size_t char_index  = c - 32;
+        const auto char_pos_cell = V2(char_index % COLS, char_index / COLS);
+        const auto char_pos_pix  = char_pos_cell * char_size_pix;
+        const auto char_pos_uv   = char_pos_pix.cast_to<GLfloat>() / tex_size_pix.cast_to<GLfloat>();
+
+        return AABB(char_pos_uv, char_size_uv).flip_vertically();
+    }
+
+    constexpr char INVALID = '?';
+    static_assert(32 <= INVALID && INVALID <= 126);
+    return char_uv(INVALID);
+}
+
+void Font::render_text(Renderer *renderer, const char *text, V2<GLfloat> position, GLfloat scale, RGBA color) const
+{
+    const size_t n = strlen(text);
+    for (size_t i = 0; i < n; ++i) {
+        renderer->fill_aabb(
+            AABB(position + (char_size_pix * V2<size_t>(i, 0)).cast_to<GLfloat>() * scale,
+                 char_size_pix.cast_to<GLfloat>() * scale),
+            color,
+            char_uv(text[i]),
+            FONT_PROGRAM_ASSET);
+    }
+}

src/something_font.hpp

@@ -0,0 +1,24 @@
+#ifndef SOMETHING_FONT_HPP_
+#define SOMETHING_FONT_HPP_
+
+struct Font {
+    constexpr static size_t ROWS = 7;
+    constexpr static size_t COLS = 18;
+
+    Texture texture;
+    GL_Texture gl_texture;
+    V2<size_t> tex_size_pix;
+    V2<size_t> char_size_pix;
+    V2<GLfloat> char_size_uv;
+
+    static Font from_file(const char *file_path);
+    AABB<GLfloat> char_uv(char c) const;
+
+    void render_text(Renderer *renderer,
+                     const char *text,
+                     V2<GLfloat> position,
+                     GLfloat scale,
+                     RGBA color) const;
+};
+
+#endif // SOMETHING_FONT_HPP_

src/something_game.cpp

@@ -1,6 +1,5 @@
 #include "./something_game.hpp"
 
-const RGBA BACKGROUND_COLOR = RGBA::from_abgr32(0x181818FF);
 const RGBA FAILED_BACKGROUND_COLOR = RGBA::from_abgr32(0xAA1818FF);
 
 void Game::init(SDL_Window *window)
@@ -26,6 +25,8 @@ void Game::init(SDL_Window *window)
     }
 
     this->atlas = Atlas::from_config("./assets/textures/atlas.conf", 10);
+    this->font = Font::from_file("./assets/textures/charmap-cellphone_white.png");
+
     this->keyboard = SDL_GetKeyboardState(NULL);
     this->window = window;
 

src/something_game.hpp

@@ -12,6 +12,7 @@
 #include "./something_aabb_body.hpp"
 #include "./something_enemy.hpp"
 #include "./something_item.hpp"
+#include "./something_font.hpp"
 
 struct Game {
     static const size_t AABB_BODIES_CAPACITY = 1024;
@@ -23,8 +24,9 @@ struct Game {
     const Uint8 *keyboard;
     SDL_Window *window;
 
-    // Game Entities
     Atlas atlas;
+    Font font;
+
     Player player;
     Camera camera;
     Tile_Grid tile_grid;

src/something_math.hpp

@@ -125,6 +125,12 @@ V2<T> operator/(T s, V2<T> a)
     return V2<T>(a.x / s, a.y / s);
 }
 
+template <typename T>
+V2<T> operator/(V2<T> a, V2<T> b)
+{
+    return V2<T>(a.x / b.x, a.y / b.y);
+}
+
 template <typename T>
 void print1(FILE *stream, V2<T> v2)
 {

src/something_player.cpp

@@ -32,7 +32,7 @@ void Player::render(const Game *game, Renderer *renderer) const
         }
 
         const auto player_hitbox = aabb_stretch(body.hitbox, stretch);
-        renderer->fill_aabb(player_hitbox, RGBA(1.0f), uv, PRIDE_PROGRAM_ASSET);
+        renderer->fill_aabb(player_hitbox, RGBA(1.0f), uv, REGULAR_PROGRAM_ASSET);
     }
 
     // Player gun

src/something_program.cpp

@@ -36,7 +36,7 @@ bool Program::relink(Renderer *renderer)
 
     glUseProgram(this->id);
 
-    u_atlas           = glGetUniformLocation(this->id, "atlas");
+    u_image           = glGetUniformLocation(this->id, "image");
     u_resolution      = glGetUniformLocation(this->id, "resolution");
     u_camera_position = glGetUniformLocation(this->id, "camera_position");
     u_camera_zoom     = glGetUniformLocation(this->id, "camera_zoom");
@@ -57,5 +57,6 @@ void Program::sync_uniforms(const Game *game)
     glUniform2f(u_camera_position, game->camera.pos.x, game->camera.pos.y);
     glUniform1f(u_camera_zoom, game->camera.zoom);
     glUniform1f(u_time, game->time());
-    glUniform1f(u_time, game->time());
+    glUniform1i(u_image, image_unit);
 }
+

src/something_program.hpp

@@ -14,18 +14,22 @@ struct Program {
     Index<Shader> vert_shader_index;
     Index<Shader> frag_shader_index;
 
-    GLuint u_atlas;
+    GLuint u_image;
     GLuint u_resolution;
     GLuint u_time;
     GLuint u_camera_position;
     GLuint u_camera_zoom;
 
+    int image_unit;
+
     constexpr static Program make(Index<Shader> vert_shader_index,
-                                  Index<Shader> frag_shader_index)
+                                  Index<Shader> frag_shader_index,
+                                  int image_unit = 0)
     {
         Program self = {};
         self.vert_shader_index = vert_shader_index;
         self.frag_shader_index = frag_shader_index;
+        self.image_unit = image_unit;
         return self;
     }
 

src/something_renderer.cpp

@@ -4,23 +4,25 @@ void Renderer::init()
 {
     triangle_vao.init();
 
-    shaders[PARTICLE_FRAG_SHADER_ASSET] =
-        Shader::make(GL_FRAGMENT_SHADER, "./assets/shaders/particle.frag");
-    shaders[RECT_FRAG_SHADER_ASSET] =
-        Shader::make(GL_FRAGMENT_SHADER, "./assets/shaders/rect.frag");
-    shaders[RECT_VERT_SHADER_ASSET] =
-        Shader::make(GL_VERTEX_SHADER, "./assets/shaders/rect.vert");
+    shaders[GRADIENT_CIRCLE_FRAG_SHADER_ASSET] =
+        Shader::make(GL_FRAGMENT_SHADER, "./assets/shaders/frag/gradient_circle.frag");
+    shaders[TEXTURE_COLOR_FRAG_SHADER_ASSET] =
+        Shader::make(GL_FRAGMENT_SHADER, "./assets/shaders/frag/texture_color.frag");
+    shaders[TRIANGLE_CAMERA_VERT_SHADER_ASSET] =
+        Shader::make(GL_VERTEX_SHADER, "./assets/shaders/vert/triangle_camera.vert");
     shaders[HSL_FRAG_SHADER_ASSET] =
-        Shader::make(GL_FRAGMENT_SHADER, "./assets/shaders/hsl.frag");
-    static_assert(COUNT_SHADER_ASSETS == 4);
+        Shader::make(GL_FRAGMENT_SHADER, "./assets/shaders/frag/hsl.frag");
+    static_assert(COUNT_SHADER_ASSETS == 4, "The amount of shader assets have changed");
 
     programs[REGULAR_PROGRAM_ASSET] =
-        Program::make({RECT_VERT_SHADER_ASSET}, {RECT_FRAG_SHADER_ASSET});
+        Program::make({TRIANGLE_CAMERA_VERT_SHADER_ASSET}, {TEXTURE_COLOR_FRAG_SHADER_ASSET});
     programs[PARTICLE_PROGRAM_ASSET] =
-        Program::make({RECT_VERT_SHADER_ASSET}, {PARTICLE_FRAG_SHADER_ASSET});
+        Program::make({TRIANGLE_CAMERA_VERT_SHADER_ASSET}, {GRADIENT_CIRCLE_FRAG_SHADER_ASSET});
     programs[PRIDE_PROGRAM_ASSET] =
-        Program::make({RECT_VERT_SHADER_ASSET}, {HSL_FRAG_SHADER_ASSET});
-    static_assert(COUNT_PROGRAM_ASSETS == 3);
+        Program::make({TRIANGLE_CAMERA_VERT_SHADER_ASSET}, {HSL_FRAG_SHADER_ASSET});
+    programs[FONT_PROGRAM_ASSET] =
+        Program::make({TRIANGLE_CAMERA_VERT_SHADER_ASSET}, {TEXTURE_COLOR_FRAG_SHADER_ASSET}, 1);
+    static_assert(COUNT_PROGRAM_ASSETS == 4, "The amount of program assets have changed");
 }
 
 void Renderer::clear()
@@ -122,9 +124,9 @@ void Renderer::fill_circle(V2<GLfloat> center, GLfloat radius, RGBA color,
                            Program_Asset program_asset)
 {
     fill_aabb(AABB(center - V2(radius), V2(radius) * 2.0f),
-             color,
-             AABB(V2(0.0f), V2(1.0f)),
-             program_asset);
+              color,
+              AABB(V2(0.0f), V2(1.0f)),
+              program_asset);
 }
 
 Shader &Renderer::get_shader(Index<Shader> index)

src/something_renderer.hpp

@@ -7,9 +7,9 @@
 struct Game;
 
 enum Shader_Asset: size_t {
-    PARTICLE_FRAG_SHADER_ASSET = 0,
-    RECT_FRAG_SHADER_ASSET,
-    RECT_VERT_SHADER_ASSET,
+    GRADIENT_CIRCLE_FRAG_SHADER_ASSET = 0,
+    TEXTURE_COLOR_FRAG_SHADER_ASSET,
+    TRIANGLE_CAMERA_VERT_SHADER_ASSET,
     HSL_FRAG_SHADER_ASSET,
     COUNT_SHADER_ASSETS,
 };
@@ -18,6 +18,7 @@ enum Program_Asset: size_t {
     REGULAR_PROGRAM_ASSET = 0,
     PARTICLE_PROGRAM_ASSET,
     PRIDE_PROGRAM_ASSET,
+    FONT_PROGRAM_ASSET,
     COUNT_PROGRAM_ASSETS
 };
 
@@ -55,7 +56,10 @@ struct Renderer {
                        Program_Asset program_asset);
     void fill_aabb(AABB<float> aabb, RGBA shade, AABB<float> uv_aabb,
                    Program_Asset program_asset);
-    void fill_circle(V2<GLfloat> center, GLfloat radius, RGBA rgba, Program_Asset program_asset);
+    void fill_circle(V2<GLfloat> center,
+                     GLfloat radius,
+                     RGBA rgba,
+                     Program_Asset program_asset);
 };
 
 #endif // SOMETHING_RENDERER_HPP_

src/something_texture.cpp

@@ -206,15 +206,22 @@ void Texture::save_to_png_file(const char *file_path)
     }
 }
 
-GL_Texture GL_Texture::from_texture(Texture texture)
+GL_Texture GL_Texture::from_texture(Texture texture, GLenum unit, bool nearest)
 {
     GL_Texture result = {};
 
+    glActiveTexture(unit);
+
     glGenTextures(1, &result.id);
     glBindTexture(GL_TEXTURE_2D, result.id);
 
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
+    if (nearest) {
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_LINEAR);
+    } else {
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
+    }
 
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);

src/something_texture.hpp

@@ -30,7 +30,7 @@ struct Texture {
 struct GL_Texture {
     GLuint id;
 
-    static GL_Texture from_texture(Texture texture);
+    static GL_Texture from_texture(Texture texture, GLenum unit, bool nearest = false);
 };
 
 #endif  // SOMETHING_TEXTURE_HPP_