OgcGlyphRenderer.cpp

/****************************************************************************
 * Platform Abstraction Layer (OGC driver)
 * Daryl Borth 2026
 * OgcGlyphRenderer.cpp
 ***************************************************************************/
#include "OgcVideoDriver.h"
#include <malloc.h>
#include <string.h>
 
#define ALIGN8(x) (((x) + 7) & ~7)
 
OgcGlyphRenderer::OgcGlyphRenderer(uint8_t vtxFmtIndex) : inText(false), textureCacheStale(true)
{
    setVertexFormat(vtxFmtIndex);
}
OgcGlyphRenderer::~OgcGlyphRenderer() {}
 
void OgcGlyphRenderer::setVertexFormat(uint8_t vtxFmtIndex) {
    this->vertexIndex = vtxFmtIndex;
 
    GX_SetVtxAttrFmt(this->vertexIndex, GX_VA_POS, GX_POS_XY, GX_S16, 0);
    GX_SetVtxAttrFmt(this->vertexIndex, GX_VA_TEX0, GX_TEX_ST, GX_F32, 0);
    GX_SetVtxAttrFmt(this->vertexIndex, GX_VA_CLR0, GX_CLR_RGBA, GX_RGBA8, 0);
}
 
void* OgcGlyphRenderer::createTexture(uint16_t width, uint16_t height) {
    width = ALIGN8(width);
    if (width == 0) width = 8;
 
    height = ALIGN8(height);
    if (height == 0) height = 8;
 
    uint32_t glyphSize = (width * height) >> 1;
 
    void* texture = memalign(32, glyphSize);
    if (texture) {
        memset(texture, 0x00, glyphSize);
        textureCacheStale = true;
    }
 
    return texture;
}
 
void OgcGlyphRenderer::loadTextureData(void* texture, FT_Bitmap* bitmap) {
    if (!texture || !bitmap) return;
 
    uint16_t texWidth = ALIGN8(bitmap->width);
    if (texWidth == 0) texWidth = 8;
 
    uint16_t texHeight = ALIGN8(bitmap->rows);
    if (texHeight == 0) texHeight = 8;
 
    uint32_t glyphSize = (texWidth * texHeight) >> 1;
 
    uint8_t* dst = static_cast<uint8_t*>(texture);
    uint8_t* src = static_cast<uint8_t*>(bitmap->buffer);
    // FreeType's row pitch can be larger than the bitmap width (row padding)
    uint32_t srcPitch = bitmap->pitch < 0 ? -bitmap->pitch : bitmap->pitch;
    if (srcPitch == 0) srcPitch = bitmap->width;
    uint32_t pos, x1, y1, x, y;
 
    // 8x8 tiled block processing for GX_TF_I4
    for (y1 = 0; y1 < bitmap->rows; y1 += 8) {
        for (x1 = 0; x1 < bitmap->width; x1 += 8) {
            for (y = y1; y < (y1 + 8); y++) {
                for (x = x1; x < (x1 + 8); x += 2, dst++) {
                    if (x >= bitmap->width || y >= bitmap->rows) {
                        continue;
                    }
 
                    pos = y * srcPitch + x;
 
                    // Extract high bits from current and adjacent pixels
                    *dst = (src[pos] & 0xF0);
                    if (x + 1 < bitmap->width) {
                        *dst |= (src[pos + 1] >> 4);
                    }
                }
            }
        }
    }
 
    // Flush the CPU cache to ensure GPU reads valid data
    DCFlushRange(texture, glyphSize);
    textureCacheStale = true;
}
 
void OgcGlyphRenderer::destroyTexture(void* texture) {
    if (texture) {
        free(texture);
        textureCacheStale = true;
    }
}
 
// State for glyph quads, set once for a whole string rather than around every glyph
void OgcGlyphRenderer::beginText() {
    GX_SetTevOp(GX_TEVSTAGE0, GX_MODULATE);
    GX_SetVtxDesc(GX_VA_TEX0, GX_DIRECT);
    inText = true;
}
 
void OgcGlyphRenderer::endText() {
    GX_SetTevOp(GX_TEVSTAGE0, GX_PASSCLR);
    GX_SetVtxDesc(GX_VA_TEX0, GX_NONE);
    inText = false;
}
 
void OgcGlyphRenderer::drawQuad(void* texture, int16_t screenX, int16_t screenY, uint16_t width, uint16_t height, const PixelColor& color) {
    if (!texture) return;
 
    GXTexObj glyphTexture;
 
    // GX_CLAMP required to avoid wrapping artifacts on small font textures
    GX_InitTexObj(&glyphTexture, texture, width, height, GX_TF_I4, GX_CLAMP, GX_CLAMP, GX_FALSE);
    GX_LoadTexObj(&glyphTexture, GX_TEXMAP0);
 
    // The texture cache is keyed by address, so it only needs emptying when the memory behind a
    // glyph texture has changed (one was made, filled or freed since the last time)
    if (textureCacheStale) {
        GX_InvalidateTexAll();
        textureCacheStale = false;
    }
 
    if (!inText) {
        GX_SetTevOp(GX_TEVSTAGE0, GX_MODULATE);
        GX_SetVtxDesc(GX_VA_TEX0, GX_DIRECT);
    }
 
    GX_Begin(GX_QUADS, this->vertexIndex, 4);
 
    // Top-Left
    GX_Position2s16(screenX, screenY);
    GX_Color4u8(color.r, color.g, color.b, color.a);
    GX_TexCoord2f32(0.0f, 0.0f);
 
    // Top-Right
    GX_Position2s16(width + screenX, screenY);
    GX_Color4u8(color.r, color.g, color.b, color.a);
    GX_TexCoord2f32(1.0f, 0.0f);
 
    // Bottom-Right
    GX_Position2s16(width + screenX, height + screenY);
    GX_Color4u8(color.r, color.g, color.b, color.a);
    GX_TexCoord2f32(1.0f, 1.0f);
 
    // Bottom-Left
    GX_Position2s16(screenX, height + screenY);
    GX_Color4u8(color.r, color.g, color.b, color.a);
    GX_TexCoord2f32(0.0f, 1.0f);
 
    GX_End();
 
    if (!inText) {
        GX_SetTevOp(GX_TEVSTAGE0, GX_PASSCLR);
        GX_SetVtxDesc(GX_VA_TEX0, GX_NONE);
    }
}
 
void OgcGlyphRenderer::drawFeature(int16_t screenX, int16_t screenY, uint16_t width, uint16_t height, const PixelColor& color) {
    // Disable textures to draw flat colored quad
    GX_SetTevOp(GX_TEVSTAGE0, GX_PASSCLR);
    GX_SetVtxDesc(GX_VA_TEX0, GX_NONE);
 
    GX_Begin(GX_QUADS, this->vertexIndex, 4);
 
    GX_Position2s16(screenX, screenY);
    GX_Color4u8(color.r, color.g, color.b, color.a);
 
    GX_Position2s16(width + screenX, screenY);
    GX_Color4u8(color.r, color.g, color.b, color.a);
 
    GX_Position2s16(width + screenX, height + screenY);
    GX_Color4u8(color.r, color.g, color.b, color.a);
 
    GX_Position2s16(screenX, height + screenY);
    GX_Color4u8(color.r, color.g, color.b, color.a);
 
    GX_End();
 
    GX_SetTevOp(GX_TEVSTAGE0, GX_PASSCLR);
    GX_SetVtxDesc(GX_VA_TEX0, GX_NONE);
}