micronona/MicrononaRenderer.cs
Hans-Jörg Meyer 45ff3d2ff2 Entkopplung BASIC-Interpreter vom SDL2-Frame-Takt
- InputInterpreter läuft jetzt in eigenem Background-Thread (Vollgas)
- ManualResetEventSlim (_runSignal) blockiert Thread bis RUN aufgerufen wird
- SemaphoreSlim (_inputSignal) ersetzt Busy-Wait bei INPUT
- Stop() und StopThread() entsperren alle Waits sauber vor Join
- _running/_waitingForInput als volatile
- MemoryModel: internes Locking (lock(Lock)) auf allen Read/Write/ReadFlat/WriteFlat
- Lock-Objekt öffentlich für Bulk-Operationen (Renderer)
- MicrononaRenderer: hält Lock für gesamten Frame statt pro ReadFlat-Aufruf

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
2026-04-13 07:58:50 +02:00

127 lines
No EOL
4.5 KiB
C#
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/// <summary>
/// Renders the Micronona screen into an internal RGB24 buffer.
///
/// Reads REG_MODE to determine text or graphics mode.
///
/// Text mode:
/// Reads the text buffer from extended RAM bank 0.
/// Each cell is 3 bytes: character code, foreground RGB332, background RGB332.
/// Looks up the glyph bitmap from font data in bank 255.
/// Each glyph is 8×10 pixels, 1 bit per pixel, 1 byte per row.
/// Expands RGB332 to RGB24 for each pixel.
///
/// Graphics mode:
/// Not yet implemented.
/// </summary>
public class MicrononaRenderer
{
private readonly MemoryModel _mem;
private readonly byte[] _rgb24 = new byte[320 * 180 * 3];
public MicrononaRenderer(MemoryModel mem)
{
_mem = mem;
}
/// <summary>
/// Render one frame into the internal buffer.
/// Returns a ReadOnlySpan over the RGB24 data, ready for SDL_UpdateTexture.
/// </summary>
public ReadOnlySpan<byte> Render()
{
lock (_mem.Lock)
{
byte mode = _mem.Read(MemoryModel.IoBase + MemoryModel.REG_MODE);
if (mode == 0)
RenderText();
else
RenderGraphics();
}
return _rgb24;
}
// -------------------------------------------------------------------------
// Text mode
// -------------------------------------------------------------------------
private void RenderText()
{
int textBase = MemoryModel.TextBankIndex * MemoryModel.BankSize;
int fontBase = MemoryModel.FontBankIndex * MemoryModel.BankSize;
byte cursorCol = _mem.Read(MemoryModel.IoBase + MemoryModel.REG_CURSOR_COL);
byte cursorRow = _mem.Read(MemoryModel.IoBase + MemoryModel.REG_CURSOR_ROW);
for (int row = 0; row < MemoryModel.TextRows; row++)
{
for (int col = 0; col < MemoryModel.TextCols; col++)
{
int cellOffset = (row * MemoryModel.TextCols + col) * MemoryModel.TextCellSize;
byte charCode = _mem.ReadFlat(textBase + cellOffset + 0);
byte fg332 = _mem.ReadFlat(textBase + cellOffset + 1);
byte bg332 = _mem.ReadFlat(textBase + cellOffset + 2);
bool isCursor = col == cursorCol && row == cursorRow;
byte fg = isCursor ? bg332 : fg332;
byte bg = isCursor ? fg332 : bg332;
// Glyph bitmap: FontGlyphHeight bytes, one byte per row (8 pixels)
int glyphOffset = fontBase + charCode * MemoryModel.FontGlyphHeight;
int pixelX = col * MemoryModel.FontGlyphWidth;
int pixelY = row * MemoryModel.FontGlyphHeight;
for (int glyphRow = 0; glyphRow < MemoryModel.FontGlyphHeight; glyphRow++)
{
byte bitmapRow = _mem.ReadFlat(glyphOffset + glyphRow);
for (int glyphCol = 0; glyphCol < MemoryModel.FontGlyphWidth; glyphCol++)
{
// MSB is leftmost pixel
bool lit = (bitmapRow & (0x80 >> glyphCol)) != 0;
byte color332 = lit ? fg : bg;
int screenX = pixelX + glyphCol;
int screenY = pixelY + glyphRow;
int bufOffset = (screenY * 320 + screenX) * 3;
Expand332(_rgb24, bufOffset, color332);
}
}
}
}
}
// -------------------------------------------------------------------------
// Graphics mode (placeholder)
// -------------------------------------------------------------------------
private void RenderGraphics()
{
// TODO: read framebuffer from extended RAM, expand RGB332 → RGB24
}
// -------------------------------------------------------------------------
// RGB332 → RGB24 expansion
//
// RGB332 bit layout: RRRGGGBB
// Red: bits 7–5 (3 bits) → scale to 0–255
// Green: bits 4–2 (3 bits) → scale to 0–255
// Blue: bits 1–0 (2 bits) → scale to 0–255
// -------------------------------------------------------------------------
private static void Expand332(byte[] buf, int offset, byte color)
{
buf[offset + 0] = Scale3to8((color >> 5) & 0x07);
buf[offset + 1] = Scale3to8((color >> 2) & 0x07);
buf[offset + 2] = Scale2to8(color & 0x03);
}
private static byte Scale3to8(int val) => (byte)((val * 255) / 7);
private static byte Scale2to8(int val) => (byte)((val * 255) / 3);
}