String Drawing System

• Variable-width bitmap fonts
• Alpha transparency support
• Automatic line wrapping
• Newline character support
• Text measurement before rendering

internal class IFont {
    private readonly Image image;        // PNG font texture
    private readonly string charset;     // Character mapping
    public int FontSize;                 // Size of each character (e.g., 16px)
    
    public IFont(Image _img, string _charset, int size) {
        image = _img;
        charset = _charset;
        FontSize = size;
    }
}

// Load a 128px font from PNG
IFont font = new IFont(
    new PNG(File.ReadAllBytes("Images/Yahei128.png")),
    @"!""#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~",
    128  // Font size
);

// Used globally via WindowManager
WindowManager.font = font;

public void DrawString(int X, int Y, string Str, 
                       int LineLimit = -1, int HeightLimit = -1) {
    int w = 0, h = 0;  // Current cursor position
    
    for (int i = 0; i < Str.Length; i++) {
        // Skip leading spaces on new lines
        if (h != 0 && w == 0 && Str[i] == ' ') 
            continue;
        
        // Draw character and advance cursor
        w += DrawChar(Framebuffer.Graphics, X + w, Y + h, Str[i]);
        
        // Handle line wrapping
        if (w + FontSize > LineLimit && LineLimit != -1 || Str[i] == '\n') {
            w = 0;              // Reset to start of line
            h += FontSize;      // Move down one line
            
            if (HeightLimit != -1 && h >= HeightLimit)
                return;  // Stop if height exceeded
        }
    }
}

public int DrawChar(Graphics g, int X, int Y, char Chr) {
    // Step 1: Find character in charset
    int index = charset.IndexOf(Chr);
    if (index == -1) {
        if (Chr == ' ') return FontSize / 2;  // Space is half width
        return 0;  // Unknown char = skip
    }
    
    // Step 2: Calculate position in font texture
    int baseX = 0, baseY = 0;
    for (int i = 0; i <= index; i++) {
        if ((i % NumRow) == 0 && i != 0) {
            baseX = 0;
            baseY += FontSize;
        }
        if (i != index)
            baseX += FontSize;
    }
    
    // Step 3: Draw character pixel-by-pixel
    for (int w = 0; w < FontSize; w++) {
        int counter = 0;
        for (int h = 0; h < FontSize; h++) {
            uint color = image.GetPixel(baseX + w, baseY + h);
            
            if (X != -1 && Y != -1)
                g.DrawPoint(X + w, Y + h, color, true);  // Alpha blend
            
            if ((color & 0xFF000000) == 0) counter++;
        }
        
        // Step 4: Variable-width - stop at empty column
        if (w > (FontSize / 3) && counter == FontSize) 
            return w;  // Return actual width used
    }
    
    return FontSize;  // Full width if no empty column
}

DrawString("Hello")
    ?
For each character 'H', 'e', 'l', 'l', 'o':
    ?
    1. Find character index in charset
    2. Calculate texture coordinates (baseX, baseY)
    3. Extract character bitmap from font image
    4. Draw pixel-by-pixel to framebuffer
    5. Apply alpha transparency
    6. Detect actual character width
    7. Advance cursor position
    ?
Return total width used

// Draw text at position (100, 50)
WindowManager.font.DrawString(100, 50, "Hello World");

// Wrap text at 300px width, limit to 2 lines
WindowManager.font.DrawString(
    100,                        // X position
    50,                         // Y position
    "This is a long text that will wrap",
    300,                        // Line width limit
    WindowManager.font.FontSize * 2  // Height limit (2 lines)
);

// Measure text width first
string text = "Centered Text";
int textWidth = WindowManager.font.MeasureString(text);

// Calculate center position
int x = (screenWidth / 2) - (textWidth / 2);
int y = (screenHeight / 2) - (WindowManager.font.FontSize / 2);

// Draw centered
WindowManager.font.DrawString(x, y, text);

// Calculate width without rendering
int width = WindowManager.font.MeasureString("Sample Text");

// Useful for:
// - Layout calculations
// - Button sizing
// - Text centering
// - Clipping detection

// Newlines are automatically handled
WindowManager.font.DrawString(100, 50, 
    "Line 1\nLine 2\nLine 3");

Text rendering is CPU-intensive. A 16px font character requires ~256 pixel operations. Drawing a full screen of text (1920×1080) can take several milliseconds. Use StringPool to avoid repeated string allocations in render loops.

// ? BAD: Allocates new string every frame
void OnDraw() {
    int cpuUsage = 42;
    string text = cpuUsage.ToString() + "%";  // New allocation
    WindowManager.font.DrawString(100, 50, text);
    // Memory leak: 'text' is never freed
}

// Result: ~8 MB/minute leaked in Task Manager alone!

// ? GOOD: Reuses cached string
void OnDraw() {
    int cpuUsage = 42;
    string text = StringPool.GetPercentage(cpuUsage);  // Cached "42%"
    WindowManager.font.DrawString(100, 50, text);
    // No memory leak: string is reused, never disposed
}

// Result: Zero allocations after warm-up

Using StringPool in TaskManager, Monitor, and PerformanceWidget reduced memory leak from 8.3 MB/minute to near zero. Free/Alloc ratio improved from 72% to 95%+.