townengine/src/rendering/twn_draw.c

#include "twn_draw_c.h"
#include "twn_draw.h"
#include "twn_engine_context_c.h"
#include "twn_camera_c.h"
#include "twn_types.h"
#include "twn_util_c.h"
#include "twn_vec.h"
#include "twn_deferred_commands.h"

#include <SDL2/SDL.h>
#include <stb_ds.h>

#include <stddef.h>
#include <tgmath.h>


DeferredCommand *deferred_commands;

/* TODO: have a default initialized one */
Matrix4 camera_projection_matrix;
Matrix4 camera_look_at_matrix;


void render_queue_clear(void) {
    text_cache_reset_arena(&ctx.text_cache);
    
    /* since i don't intend to free the queues, */
    /* it's faster and simpler to just "start over" */
    /* and start overwriting the existing data */
    arrsetlen(ctx.render_queue_2d, 0);

    for (size_t i = 0; i < hmlenu(ctx.uncolored_mesh_batches); ++i)
        arrsetlen(ctx.uncolored_mesh_batches[i].value.primitives, 0);
}


void draw_nine_slice(const char *texture, Vec2 corners, Rect rect, float border_thickness, Color color) {
    const float bt = border_thickness;
    const float bt2 = bt * 2; /* combined size of the two borders in an axis */


    Rect top_left = {
        .x = rect.x,
        .y = rect.y,
        .w = bt,
        .h = bt,
    };

    m_sprite(
        m_set(texture, texture),
        m_set(rect, top_left),
        m_opt(texture_region, ((Rect) { 0, 0, bt, bt })),
        m_opt(color, color),
    );


    Rect top_center = {
        .x = rect.x + bt,
        .y = rect.y,
        .w = rect.w - bt2, /* here bt2 represents the top left and right corners */
        .h = bt,
    };

    m_sprite(
        m_set(texture, texture),
        m_set(rect, top_center),
        m_opt(texture_region, ((Rect) { bt, 0, corners.x - bt2, bt })),
        m_opt(color, color),
    );


    Rect top_right = {
        .x = rect.x + (rect.w - bt),
        .y = rect.y,
        .w = bt,
        .h = bt,
    };

    m_sprite(
        m_set(texture, texture),
        m_set(rect, top_right),
        m_opt(texture_region, ((Rect) { corners.x - bt, 0, bt, bt })),
        m_opt(color, color),
    );


    Rect center_left = {
        .x = rect.x,
        .y = rect.y + bt,
        .w = bt,
        .h = rect.h - bt2, /* here bt2 represents the top and bottom left corners */
    };

    m_sprite(
        m_set(texture, texture),
        m_set(rect, center_left),
        m_opt(texture_region, ((Rect) { 0, bt, bt, corners.y - bt2 })),
        m_opt(color, color),
    );


    Rect center_right = {
        .x = rect.x + (rect.w - bt),
        .y = rect.y + bt,
        .w = bt,
        .h = rect.h - bt2, /* here bt2 represents the top and bottom right corners */
    };

    m_sprite(
        m_set(texture, texture),
        m_set(rect, center_right),
        m_opt(texture_region, ((Rect) { corners.x - bt, bt, bt, corners.y - bt2 })),
        m_opt(color, color),
    );


    Rect bottom_left = {
        .x = rect.x,
        .y = rect.y + (rect.h - bt),
        .w = bt,
        .h = bt,
    };

    m_sprite(
        m_set(texture, texture),
        m_set(rect, bottom_left),
        m_opt(texture_region, ((Rect) { 0, corners.y - bt, bt, bt })),
        m_opt(color, color),
    );


    Rect bottom_center = {
        .x = rect.x + bt,
        .y = rect.y + (rect.h - bt),
        .w = rect.w - bt2, /* here bt2 represents the bottom left and right corners */
        .h = bt,
    };

    m_sprite(
        m_set(texture, texture),
        m_set(rect, bottom_center),
        m_opt(texture_region, ((Rect) { bt, corners.y - bt, corners.x - bt2, bt })),
        m_opt(color, color),
    );


    Rect bottom_right = {
        .x = rect.x + (rect.w - bt),
        .y = rect.y + (rect.h - bt),
        .w = bt,
        .h = bt,
    };

    m_sprite(
        m_set(texture, texture),
        m_set(rect, bottom_right),
        m_opt(texture_region, ((Rect) { corners.x - bt, corners.y - bt, bt, bt })),
        m_opt(color, color),
    );


    Rect center = {
        .x = rect.x + bt,
        .y = rect.y + bt,
        .w = rect.w - bt2,
        .h = rect.h - bt2,
    };

    m_sprite(
        m_set(texture, texture),
        m_set(rect, center),
        m_opt(texture_region, ((Rect) { bt, bt, corners.x - bt2, corners.y - bt2 })),
        m_opt(color, color),
    );
}


static void render_2d(void) {
    use_2d_pipeline();

    const size_t render_queue_len = arrlenu(ctx.render_queue_2d);

    struct Render2DInvocation {
        Primitive2D const *primitive;
        double layer;
        union {
            struct QuadBatch quad_batch;
        };
    };

    /* first, collect all invocations, while merging into batches where applicable */
    /* we separate into opaque and transparent ones, as it presents optimization opportunities */
    struct Render2DInvocation *opaque_invocations = NULL;
    struct Render2DInvocation *ghostly_invocations = NULL;

    arrsetcap(opaque_invocations, render_queue_len);
    arrsetcap(ghostly_invocations, render_queue_len);

    for (size_t i = 0; i < render_queue_len; ++i) {
        const Primitive2D *current = &ctx.render_queue_2d[i];

        // TODO: https://gamedev.stackexchange.com/questions/101136/using-full-resolution-of-depth-buffer-for-2d-rendering
        double const layer = ((double)((render_queue_len + 1) - i) / (double)(render_queue_len + 1)) * 0.75;

        switch (current->type) {
            case PRIMITIVE_2D_SPRITE: {
                const struct QuadBatch batch =
                    collect_sprite_batch(current, render_queue_len - i);

                struct Render2DInvocation const invocation = {
                    .primitive = current,
                    .quad_batch = batch,
                    .layer = layer,
                };

                if (batch.mode == TEXTURE_MODE_GHOSTLY)
                    arrput(ghostly_invocations, invocation);
                else
                    arrput(opaque_invocations, invocation);

                i += batch.size - 1;
                break;
            }

            case PRIMITIVE_2D_RECT: {
                const struct QuadBatch batch =
                    collect_rect_batch(current, render_queue_len - i);

                struct Render2DInvocation const invocation = {
                    .primitive = current,
                    .quad_batch = batch,
                    .layer = layer,
                };

                if (batch.mode == TEXTURE_MODE_GHOSTLY)
                    arrput(ghostly_invocations, invocation);
                else
                    arrput(opaque_invocations, invocation);

                i += batch.size - 1;
                break;
            }

            case PRIMITIVE_2D_CIRCLE: {
                struct Render2DInvocation const invocation = {
                    .primitive = current,
                    .layer = layer,
                };

                if (current->circle.color.a != 255)
                    arrput(ghostly_invocations, invocation);
                else
                    arrput(opaque_invocations, invocation);
                break;
            }

            case PRIMITIVE_2D_TEXT: {
                struct Render2DInvocation const invocation = {
                    .primitive = current,
                    .layer = layer,
                };
                arrput(ghostly_invocations, invocation);
                break;
            }

            default:
                SDL_assert(false);
        }
    }

    /* first issue all opaque primitives, front-to-back */
    for (size_t i = 0; i < arrlenu(opaque_invocations); ++i) {
        struct Render2DInvocation const invocation = opaque_invocations[arrlenu(opaque_invocations) - 1 - i];

        /* idea here is to set constant z write that moves further and further along */
        /* with that every batch can early z reject against the previous */
        /* additionally, it will also apply for future transparent passes, sandwitching in-between */
        set_depth_range(invocation.layer, 1.0);

        switch (invocation.primitive->type) {
            case PRIMITIVE_2D_SPRITE: {
                render_sprite_batch(invocation.primitive, invocation.quad_batch);
                break;
            }
            case PRIMITIVE_2D_RECT: {
                render_rect_batch(invocation.primitive, invocation.quad_batch);
                break;
            }
            /* TODO: circle batching */
            case PRIMITIVE_2D_CIRCLE:
                render_circle(&invocation.primitive->circle);
                break;
            case PRIMITIVE_2D_TEXT:
            default:
                SDL_assert(false);
        }
    }

    /* then issue all transparent primitives, back-to-front */
    for (size_t i = 0; i < arrlenu(ghostly_invocations); ++i) {
        struct Render2DInvocation const invocation = ghostly_invocations[i];

        /* now we use it not for writing layers, but inferring ordering */
        set_depth_range(invocation.layer, 1.0);

        switch (invocation.primitive->type) {
            case PRIMITIVE_2D_SPRITE: {
                render_sprite_batch(invocation.primitive, invocation.quad_batch);
                break;
            }
            case PRIMITIVE_2D_RECT: {
                render_rect_batch(invocation.primitive, invocation.quad_batch);
                break;
            }
            /* TODO: circle batching */
            case PRIMITIVE_2D_CIRCLE:
                render_circle(&invocation.primitive->circle);
                break;
            case PRIMITIVE_2D_TEXT:
                render_text(&invocation.primitive->text);
                break;
            default:
                SDL_assert(false);
        }
    }

    arrfree(opaque_invocations);
    arrfree(ghostly_invocations);
}


static void render_space(void) {
    /* nothing to do, abort */
    /* as space pipeline isn't used we can have fewer changes and initialization costs */
    if (hmlenu(ctx.uncolored_mesh_batches) == 0)
        return;

    use_space_pipeline();
    apply_fog();

    for (size_t i = 0; i < hmlenu(ctx.uncolored_mesh_batches); ++i) {
        draw_uncolored_space_traingle_batch(&ctx.uncolored_mesh_batches[i].value,
                                            ctx.uncolored_mesh_batches[i].key);
    }

    pop_fog();
}


void render(void) {
    textures_update_atlas(&ctx.texture_cache);

    /* fit rendering context onto the resizable screen */
    if (ctx.window_size_has_changed) {
        setup_viewport((int)ctx.viewport_rect.x, (int)ctx.viewport_rect.y, (int)ctx.viewport_rect.w, (int)ctx.viewport_rect.h);
    }

    start_render_frame(); {
        render_space();
        render_skybox(); /* after space, as to use depth buffer for early z rejection */
        render_2d();
    } end_render_frame();
}


void draw_camera(Vec3 position, float fov, Vec3 up, Vec3 direction) {
    Camera const camera = {
        .fov = fov,
        .pos = position,
        .target = direction,
        .up = up,
    };
    camera_projection_matrix = camera_perspective(&camera);
    camera_look_at_matrix    = camera_look_at(&camera);
}


/* TODO: https://stackoverflow.com/questions/62493770/how-to-add-roll-in-camera-class */
DrawCameraFromPrincipalAxesResult draw_camera_from_principal_axes(Vec3 position, float fov, float roll, float pitch, float yaw) {
    (void)roll;
    float yawc, yaws, pitchc, pitchs;
    sincosf(yaw, &yaws, &yawc);
    sincosf(pitch, &pitchs, &pitchc);
    Camera const camera = {
        .fov = fov,
        .pos = position,
        .target = m_vec_norm(((Vec3){
            yawc * pitchc,
            pitchs,
            yaws * pitchc,
        })),
        .up = (Vec3){0, 1, 0},
    };
    camera_projection_matrix = camera_perspective(&camera);
    camera_look_at_matrix    = camera_look_at(&camera);

    return (DrawCameraFromPrincipalAxesResult) {
        .direction = camera.target,
        .up = camera.up,
    };
}


void set_depth_range(double low, double high) {
    DeferredCommand const command = {
        .type = DEFERRED_COMMAND_TYPE_DEPTH_RANGE,
        .depth_range = {
            .low = low,
            .high = high
        }
    };

    arrpush(deferred_commands, command);
}


void clear_draw_buffer(void) {
    /* TODO: we can optimize a rectangle drawn over whole window to a clear color call*/

    DeferredCommand command = {
        .type = DEFERRED_COMMAND_TYPE_CLEAR,
        .clear = (DeferredCommandClear) {
            .clear_color = true,
            .clear_depth = true,
            .clear_stencil = true,
            .color = (Color) { 230, 230, 230, 1 }
        }
    };

    arrpush(deferred_commands, command);
}


void use_texture_mode(TextureMode mode) {
    DeferredCommand const command = {
        .type = DEFERRED_COMMAND_TYPE_USE_TEXTURE_MODE,
        .use_texture_mode = { mode }
    };

    arrpush(deferred_commands, command);
}


void use_2d_pipeline(void) {
    DeferredCommand const command = {
        .type = DEFERRED_COMMAND_TYPE_USE_PIPIELINE,
        .use_pipeline = { PIPELINE_2D }
    };

    arrpush(deferred_commands, command);
}


void use_space_pipeline(void) {
    DeferredCommand const command = {
        .type = DEFERRED_COMMAND_TYPE_USE_PIPIELINE,
        .use_pipeline = { PIPELINE_SPACE }
    };

    arrpush(deferred_commands, command);
}


void issue_deferred_draw_commands(void) {
    for (size_t i = 0; i < arrlenu(deferred_commands); ++i) {
        switch (deferred_commands[i].type) {
            case DEFERRED_COMMAND_TYPE_DEPTH_RANGE: {
                finally_set_depth_range(deferred_commands[i].depth_range);
                break;
            }

            case DEFERRED_COMMAND_TYPE_CLEAR: {
                finally_clear_draw_buffer(deferred_commands[i].clear);
                break;
            }

            case DEFERRED_COMMAND_TYPE_DRAW: {
                finally_draw_command(deferred_commands[i].draw);
                break;
            }

            case DEFERRED_COMMAND_TYPE_DRAW_SKYBOX: {
                finally_render_skybox(deferred_commands[i].draw_skybox);
                break;
            }

            case DEFERRED_COMMAND_TYPE_USE_PIPIELINE: {
                switch (deferred_commands[i].use_pipeline.pipeline) {
                    case PIPELINE_2D:
                        finally_use_2d_pipeline();
                        break;
                    case PIPELINE_SPACE:
                        finally_use_space_pipeline();
                        break;
                    case PIPELINE_NO:
                    default:
                        SDL_assert(false);
                }

                break;
            }

            case DEFERRED_COMMAND_TYPE_USE_TEXTURE_MODE: {
                finally_use_texture_mode(deferred_commands[i].use_texture_mode.mode);
                break;
            }

            case DEFERRED_COMMAND_TYPE_APPLY_FOG: {
                finally_apply_fog(deferred_commands[i].apply_fog);
                break;
            }

            case DEFERRED_COMMAND_TYPE_POP_FOG: {
                finally_pop_fog();
                break;
            }

            default:
                SDL_assert(false);
        }
    }
}


void render_circle(const CirclePrimitive *circle) {
    static Vec2 vertices[CIRCLE_VERTICES_MAX];
    static int prev_num_vertices = 0;
    static Vec2 prev_position = {0};

    int const num_vertices = MIN((int)circle->radius, CIRCLE_VERTICES_MAX);

    if (prev_num_vertices != num_vertices) {
        create_circle_geometry(circle->position,
                               circle->radius,
                               num_vertices,
                               vertices);
        prev_num_vertices = num_vertices;
        prev_position = circle->position;
    } else {
        /* reuse the data, but offset it by difference with previously generated position */
        /* no evil cos sin ops this way, if radius is shared in sequential calls */
        Vec2 const d = { prev_position.x - circle->position.x, prev_position.y - circle->position.y };
        for (int i = 0; i < num_vertices; ++i)
            vertices[i] = (Vec2){ vertices[i].x - d.x, vertices[i].y - d.y };
        prev_position = circle->position;
    }

    VertexBuffer buffer = get_scratch_vertex_array();
    specify_vertex_buffer(buffer, vertices, sizeof (Vec2) * num_vertices);

    DeferredCommandDraw command = {0};

    command.vertices = (AttributeArrayPointer) {
        .arity = 2,
        .type = GL_FLOAT,
        .stride = sizeof (Vec2),
        .offset = 0,
        .buffer = buffer
    };

    command.constant_colored = true;
    command.color = circle->color;

    command.element_buffer = get_circle_element_buffer();
    command.element_count = (num_vertices - 2) * 3;
    command.range_end = (num_vertices - 2) * 3;

    use_texture_mode(circle->color.a == 255 ? TEXTURE_MODE_OPAQUE : TEXTURE_MODE_GHOSTLY);

    DeferredCommand final_command = {
        .type = DEFERRED_COMMAND_TYPE_DRAW,
        .draw = command
    };

    arrpush(deferred_commands, final_command);
}


void finally_render_quads(const Primitive2D primitives[],
                          const struct QuadBatch batch,
                          const VertexBuffer buffer)
{
    DeferredCommandDraw command = {0};

    GLsizei off = 0, voff = 0, uvoff = 0, coff = 0;

    if (!batch.constant_colored && batch.textured) {
        off   = offsetof(ElementIndexedQuad, v1);
        voff  = offsetof(ElementIndexedQuad, v0);
        uvoff = offsetof(ElementIndexedQuad, uv0);
        coff  = offsetof(ElementIndexedQuad, c0);
    } else if (batch.constant_colored && batch.textured) {
        off   = offsetof(ElementIndexedQuadWithoutColor, v1);
        voff  = offsetof(ElementIndexedQuadWithoutColor, v0);
        uvoff = offsetof(ElementIndexedQuadWithoutColor, uv0);
    } else if (!batch.constant_colored && !batch.textured) {
        off   = offsetof(ElementIndexedQuadWithoutTexture, v1);
        voff  = offsetof(ElementIndexedQuadWithoutTexture, v0);
        coff  = offsetof(ElementIndexedQuad, c0);
    } else if (batch.constant_colored && !batch.textured) {
        off   = offsetof(ElementIndexedQuadWithoutColorWithoutTexture, v1);
        voff  = offsetof(ElementIndexedQuadWithoutColorWithoutTexture, v0);
    }

    command.vertices = (AttributeArrayPointer) {
        .arity = 2,
        .type = GL_FLOAT,
        .stride = off,
        .offset = voff,
        .buffer = buffer
    };

    if (batch.textured)
        command.texcoords = (AttributeArrayPointer) {
            .arity = 2,
            .type = GL_FLOAT,
            .stride = off,
            .offset = uvoff,
            .buffer = buffer
        };

    if (!batch.constant_colored) {
        command.colors = (AttributeArrayPointer) {
            .arity = 4,
            .type = GL_UNSIGNED_BYTE,
            .stride = off,
            .offset = coff,
            .buffer = buffer
        };
    } else {
        command.constant_colored = true;
        command.color = primitives[0].sprite.color;
    }

    if (batch.textured) {
        command.textured = true;
        command.texture_key = batch.texture_key;
        command.texture_repeat = batch.repeat;
    }

    command.element_buffer = get_quad_element_buffer();
    command.element_count = 6 * (GLsizei)batch.size;
    command.range_end = 6 * (GLsizei)batch.size;

    use_texture_mode(batch.mode);

    DeferredCommand final_command = {
        .type = DEFERRED_COMMAND_TYPE_DRAW,
        .draw = command
    };

    arrpush(deferred_commands, final_command);
}


size_t get_quad_payload_size(struct QuadBatch batch) {
    if (batch.constant_colored && batch.textured)
        return sizeof (ElementIndexedQuadWithoutColor);
    else if (!batch.constant_colored && batch.textured)
        return sizeof (ElementIndexedQuad);
    else if (batch.constant_colored && !batch.textured)
        return sizeof (ElementIndexedQuadWithoutColorWithoutTexture);
    else if (!batch.constant_colored && !batch.textured)
        return sizeof (ElementIndexedQuadWithoutTexture);

    SDL_assert(false);
    return 0;
}


bool push_quad_payload_to_vertex_buffer_builder(struct QuadBatch batch,
                                                VertexBufferBuilder *builder,
                                                Vec2 v0, Vec2 v1, Vec2 v2, Vec2 v3,
                                                Vec2 uv0, Vec2 uv1, Vec2 uv2, Vec2 uv3,
                                                Color color)
{
    if (!batch.constant_colored && batch.textured) {
        ElementIndexedQuad const buffer_element = {
            .v0 = v0,
            .v1 = v1,
            .v2 = v2,
            .v3 = v3,

            .uv0 = uv0,
            .uv1 = uv1,
            .uv2 = uv2,
            .uv3 = uv3,

            /* equal for all (flat shaded) */
            .c0 = color,
            // .c1 = color,
            .c2 = color,
            // .c3 = color,
        };

        return push_to_vertex_buffer_builder(builder, &buffer_element, sizeof buffer_element);

    } else if (batch.constant_colored && batch.textured) {
        ElementIndexedQuadWithoutColor const buffer_element = {
            .v0 = v0,
            .v1 = v1,
            .v2 = v2,
            .v3 = v3,

            .uv0 = uv0,
            .uv1 = uv1,
            .uv2 = uv2,
            .uv3 = uv3,
        };

        return push_to_vertex_buffer_builder(builder, &buffer_element, sizeof buffer_element);

    } else if (!batch.constant_colored && !batch.textured) {
        ElementIndexedQuadWithoutTexture const buffer_element = {
            .v0 = v0,
            .v1 = v1,
            .v2 = v2,
            .v3 = v3,

            /* equal for all (flat shaded) */
            .c0 = color,
            // .c1 = color,
            .c2 = color,
            // .c3 = color,
        };

        return push_to_vertex_buffer_builder(builder, &buffer_element, sizeof buffer_element);

    } else if (batch.constant_colored && !batch.textured) {
        ElementIndexedQuadWithoutColorWithoutTexture const buffer_element = {
            .v0 = v0,
            .v1 = v1,
            .v2 = v2,
            .v3 = v3,
        };

        return push_to_vertex_buffer_builder(builder, &buffer_element, sizeof buffer_element);
    }

    SDL_assert(false);
    return false;
}


void finally_draw_uncolored_space_traingle_batch(const MeshBatch *batch,
                                                 const TextureKey texture_key,
                                                 const VertexBuffer buffer)
{
    const size_t primitives_len = arrlenu(batch->primitives);

    /* nothing to do */
    if (primitives_len == 0)
        return;

    const Rect srcrect = textures_get_srcrect(&ctx.texture_cache, texture_key);
    const Rect dims    = textures_get_dims(&ctx.texture_cache, texture_key);

    const float wr = srcrect.w / dims.w;
    const float hr = srcrect.h / dims.h;
    const float xr = srcrect.x / dims.w;
    const float yr = srcrect.y / dims.h;

    /* update pixel-based uvs to correspond with texture atlases */
    for (size_t i = 0; i < primitives_len; ++i) {
        UncoloredSpaceTriangle *payload =
            &((UncoloredSpaceTriangle *)(void *)batch->primitives)[i];

        payload->uv0.x = xr + ((float)payload->uv0.x / srcrect.w) * wr;
        payload->uv0.y = yr + ((float)payload->uv0.y / srcrect.h) * hr;
        payload->uv1.x = xr + ((float)payload->uv1.x / srcrect.w) * wr;
        payload->uv1.y = yr + ((float)payload->uv1.y / srcrect.h) * hr;
        payload->uv2.x = xr + ((float)payload->uv2.x / srcrect.w) * wr;
        payload->uv2.y = yr + ((float)payload->uv2.y / srcrect.h) * hr;
    }

    specify_vertex_buffer(buffer, batch->primitives, primitives_len * sizeof (UncoloredSpaceTriangle));

    DeferredCommandDraw command = {0};

    command.vertices = (AttributeArrayPointer) {
        .arity = 3,
        .type = GL_FLOAT,
        .stride = offsetof(UncoloredSpaceTriangle, v1),
        .offset = offsetof(UncoloredSpaceTriangle, v0),
        .buffer = buffer
    };

    command.texcoords = (AttributeArrayPointer) {
        .arity = 2,
        .type = GL_FLOAT,
        .stride = offsetof(UncoloredSpaceTriangle, v1),
        .offset = offsetof(UncoloredSpaceTriangle, uv0),
        .buffer = buffer
    };

    command.textured = true;
    command.texture_key = texture_key;

    command.primitive_count = (GLsizei)(3 * primitives_len);

    DeferredCommand final_command = {
        .type = DEFERRED_COMMAND_TYPE_DRAW,
        .draw = command
    };

    arrpush(deferred_commands, final_command);
}



bool push_text_payload_to_vertex_buffer_builder(FontData const *font_data,
                                                VertexBufferBuilder *builder,
                                                stbtt_aligned_quad quad)
{
    (void)font_data;

    ElementIndexedQuadWithoutColor buffer_element = {
        .v0 = (Vec2){ quad.x0, quad.y0 },
        .v1 = (Vec2){ quad.x1, quad.y0 },
        .v2 = (Vec2){ quad.x1, quad.y1 },
        .v3 = (Vec2){ quad.x0, quad.y1 },

        .uv0 = (Vec2){ quad.s0, quad.t0 },
        .uv1 = (Vec2){ quad.s1, quad.t0 },
        .uv2 = (Vec2){ quad.s1, quad.t1 },
        .uv3 = (Vec2){ quad.s0, quad.t1 },
    };

    return push_to_vertex_buffer_builder(builder, &buffer_element, sizeof buffer_element);
}


void finally_draw_text(FontData const *font_data,
                       size_t len,
                       Color color,
                       VertexBuffer buffer)
{
    DeferredCommandDraw command = {0};

    command.vertices = (AttributeArrayPointer) {
        .arity = 2,
        .type = GL_FLOAT,
        .stride = offsetof(ElementIndexedQuadWithoutColor, v1),
        .offset = offsetof(ElementIndexedQuadWithoutColor, v0),
        .buffer = buffer
    };

    command.texcoords = (AttributeArrayPointer) {
        .arity = 2,
        .type = GL_FLOAT,
        .stride = offsetof(ElementIndexedQuadWithoutColor, v1),
        .offset = offsetof(ElementIndexedQuadWithoutColor, uv0),
        .buffer = buffer
    };

    command.constant_colored = true;
    command.color = color;

    command.gpu_texture = font_data->texture;
    command.uses_gpu_key = true;
    command.textured = true;

    command.element_buffer = get_quad_element_buffer();
    command.element_count = 6 * (GLsizei)len;
    command.range_end = 6 * (GLsizei)len;

    use_texture_mode(TEXTURE_MODE_GHOSTLY);

    DeferredCommand final_command = {
        .type = DEFERRED_COMMAND_TYPE_DRAW,
        .draw = command
    };

    arrpush(deferred_commands, final_command);

    /* TODO: why doesn't it get restored if not placed here? */
    // glDepthMask(GL_TRUE);
}


size_t get_text_payload_size(void) {
    return sizeof (ElementIndexedQuadWithoutColor);
}