First Commit
This commit is contained in:
commit
e422b5b561
9 changed files with 872 additions and 0 deletions
10
.claude/settings.local.json
Normal file
10
.claude/settings.local.json
Normal file
|
|
@ -0,0 +1,10 @@
|
|||
{
|
||||
"permissions": {
|
||||
"allow": [
|
||||
"Bash(dotnet remove:*)",
|
||||
"Bash(dotnet add:*)",
|
||||
"Bash(dotnet build:*)",
|
||||
"Bash(dotnet run:*)"
|
||||
]
|
||||
}
|
||||
}
|
||||
4
.gitignore
vendored
Normal file
4
.gitignore
vendored
Normal file
|
|
@ -0,0 +1,4 @@
|
|||
bin/
|
||||
obj/
|
||||
*.user
|
||||
.vs/
|
||||
39
CLAUDE.md
Normal file
39
CLAUDE.md
Normal file
|
|
@ -0,0 +1,39 @@
|
|||
# CLAUDE.md
|
||||
|
||||
This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
|
||||
|
||||
## Project Overview
|
||||
|
||||
**Mironona** is a retro computer emulator (targeting a 6809-based system) built with C# (.NET 10) and SDL2 via the `SDL2-CS` binding. The window renders at 320x180 (upscaled 3x to 960x540) using a CPU-side RGB24 framebuffer that is blitted each frame to an SDL streaming texture.
|
||||
|
||||
## Commands
|
||||
|
||||
```bash
|
||||
# Build
|
||||
dotnet build
|
||||
|
||||
# Run
|
||||
dotnet run
|
||||
|
||||
# Build release
|
||||
dotnet build -c Release
|
||||
```
|
||||
|
||||
## Architecture
|
||||
|
||||
The project is currently a single-file bootstrap (`Program.cs`) with:
|
||||
|
||||
- **SDL2 init** — video subsystem, window (960x540 display), accelerated renderer with VSync
|
||||
- **Framebuffer** — `byte[320*180*3]` in RAM (RGB24), uploaded each frame via `SDL_UpdateTexture` to a streaming texture
|
||||
- **Main loop** — polls SDL events (Quit / Escape to exit), then uploads framebuffer and presents
|
||||
|
||||
The comment `// Hier später: 6809-Schritt, VSync-Flag setzen, etc.` marks where the 6809 CPU step and VSync logic will be inserted.
|
||||
|
||||
## Key Constants
|
||||
|
||||
| Name | Value | Notes |
|
||||
|---|---|---|
|
||||
| `ScreenWidth` | 320 | Native framebuffer width |
|
||||
| `ScreenHeight` | 180 | Native framebuffer height |
|
||||
| Display scale | 3x | Window is 960x540 |
|
||||
| Pixel format | `SDL_PIXELFORMAT_RGB24` | 3 bytes/pixel |
|
||||
131
ConsoleHelper.cs
Normal file
131
ConsoleHelper.cs
Normal file
|
|
@ -0,0 +1,131 @@
|
|||
public class ConsoleHelper
|
||||
{
|
||||
private readonly MemoryModel _mem;
|
||||
|
||||
public ConsoleHelper(MemoryModel mem)
|
||||
{
|
||||
_mem = mem;
|
||||
}
|
||||
|
||||
public void Delete()
|
||||
{
|
||||
int col = _mem.Read(MemoryModel.IoBase + MemoryModel.REG_CURSOR_COL);
|
||||
int row = _mem.Read(MemoryModel.IoBase + MemoryModel.REG_CURSOR_ROW);
|
||||
|
||||
int textBase = MemoryModel.TextBankIndex * MemoryModel.BankSize;
|
||||
int rowEnd = (row * MemoryModel.TextCols + MemoryModel.TextCols - 1) * MemoryModel.TextCellSize;
|
||||
int startOffset = (row * MemoryModel.TextCols + col) * MemoryModel.TextCellSize;
|
||||
|
||||
for (int i = startOffset; i < rowEnd; i += MemoryModel.TextCellSize)
|
||||
{
|
||||
_mem.WriteFlat(textBase + i,
|
||||
_mem.ReadFlat(textBase + i + MemoryModel.TextCellSize),
|
||||
_mem.ReadFlat(textBase + i + MemoryModel.TextCellSize + 1),
|
||||
_mem.ReadFlat(textBase + i + MemoryModel.TextCellSize + 2));
|
||||
}
|
||||
|
||||
_mem.WriteFlat(textBase + rowEnd, 0x20, MemoryModel.DefaultFg, MemoryModel.DefaultBg);
|
||||
}
|
||||
|
||||
|
||||
public void Backspace()
|
||||
{
|
||||
int col = _mem.Read(MemoryModel.IoBase + MemoryModel.REG_CURSOR_COL);
|
||||
int row = _mem.Read(MemoryModel.IoBase + MemoryModel.REG_CURSOR_ROW);
|
||||
if (col == 0 && row == 0) return;
|
||||
if (col == 0) { col = MemoryModel.TextCols - 1; row--; }
|
||||
else col--;
|
||||
|
||||
// Rest der Zeile nach links ziehen
|
||||
int textBase = MemoryModel.TextBankIndex * MemoryModel.BankSize;
|
||||
int rowEnd = (row * MemoryModel.TextCols + MemoryModel.TextCols - 1) * MemoryModel.TextCellSize;
|
||||
int startOffset = (row * MemoryModel.TextCols + col) * MemoryModel.TextCellSize;
|
||||
|
||||
for (int i = startOffset; i < rowEnd; i += MemoryModel.TextCellSize)
|
||||
{
|
||||
_mem.WriteFlat(textBase + i,
|
||||
_mem.ReadFlat(textBase + i + MemoryModel.TextCellSize),
|
||||
_mem.ReadFlat(textBase + i + MemoryModel.TextCellSize + 1),
|
||||
_mem.ReadFlat(textBase + i + MemoryModel.TextCellSize + 2));
|
||||
}
|
||||
|
||||
// Letztes Zeichen der Zeile löschen
|
||||
_mem.WriteFlat(textBase + rowEnd, 0x20, MemoryModel.DefaultFg, MemoryModel.DefaultBg);
|
||||
|
||||
_mem.Write(MemoryModel.IoBase + MemoryModel.REG_CURSOR_COL, (byte)col);
|
||||
_mem.Write(MemoryModel.IoBase + MemoryModel.REG_CURSOR_ROW, (byte)row);
|
||||
}
|
||||
|
||||
public void NewLine()
|
||||
{
|
||||
int row = _mem.Read(MemoryModel.IoBase + MemoryModel.REG_CURSOR_ROW);
|
||||
if (row + 1 >= MemoryModel.TextRows)
|
||||
{
|
||||
ScrollUp();
|
||||
}
|
||||
else
|
||||
{
|
||||
row++;
|
||||
}
|
||||
SetCursor(0, (byte)row);
|
||||
}
|
||||
public void MoveCursor(int dx, int dy)
|
||||
{
|
||||
int col = _mem.Read(MemoryModel.IoBase + MemoryModel.REG_CURSOR_COL);
|
||||
int row = _mem.Read(MemoryModel.IoBase + MemoryModel.REG_CURSOR_ROW);
|
||||
col = Math.Clamp(col + dx, 0, MemoryModel.TextCols - 1);
|
||||
row = Math.Clamp(row + dy, 0, MemoryModel.TextRows - 1);
|
||||
_mem.Write(MemoryModel.IoBase + MemoryModel.REG_CURSOR_COL, (byte)col);
|
||||
_mem.Write(MemoryModel.IoBase + MemoryModel.REG_CURSOR_ROW, (byte)row);
|
||||
}
|
||||
|
||||
public void ScrollUp()
|
||||
{
|
||||
int textBase = MemoryModel.TextBankIndex * MemoryModel.BankSize;
|
||||
int rowSize = MemoryModel.TextCols * MemoryModel.TextCellSize;
|
||||
|
||||
// Zeilen 1–17 nach oben kopieren
|
||||
for (int row = 0; row < MemoryModel.TextRows - 1; row++)
|
||||
{
|
||||
for (int i = 0; i < rowSize; i++)
|
||||
{
|
||||
_mem.WriteFlat(textBase + row * rowSize + i,
|
||||
_mem.ReadFlat(textBase + (row + 1) * rowSize + i));
|
||||
}
|
||||
}
|
||||
|
||||
// Letzte Zeile mit Leerzeichen und Defaultfarben füllen
|
||||
int lastRow = (MemoryModel.TextRows - 1) * rowSize;
|
||||
for (int col = 0; col < MemoryModel.TextCols; col++)
|
||||
{
|
||||
_mem.WriteFlat(textBase + lastRow + col * MemoryModel.TextCellSize, 0x20, MemoryModel.DefaultFg, MemoryModel.DefaultBg);
|
||||
}
|
||||
}
|
||||
public void SetCursor(byte x, byte y)
|
||||
{
|
||||
_mem.Write(MemoryModel.IoBase + MemoryModel.REG_CURSOR_COL, x);
|
||||
_mem.Write(MemoryModel.IoBase + MemoryModel.REG_CURSOR_ROW, y);
|
||||
}
|
||||
public void WriteText(string text)
|
||||
{
|
||||
if (_mem.Read(MemoryModel.IoBase + MemoryModel.REG_MODE) != 0) return;
|
||||
var x = _mem.Read(MemoryModel.IoBase + MemoryModel.REG_CURSOR_COL);
|
||||
var y = _mem.Read(MemoryModel.IoBase + MemoryModel.REG_CURSOR_ROW);
|
||||
|
||||
var offset = (y * MemoryModel.TextCols + x) * MemoryModel.TextCellSize;
|
||||
foreach (char c in text.ToArray())
|
||||
{
|
||||
var ascii = (byte)c;
|
||||
_mem.WriteFlat(MemoryModel.TextBankIndex * MemoryModel.BankSize + offset, ascii, MemoryModel.DefaultFg, MemoryModel.DefaultBg);
|
||||
offset += MemoryModel.TextCellSize;
|
||||
while (offset >= MemoryModel.TextCellSize * MemoryModel.TextCols * MemoryModel.TextRows)
|
||||
{
|
||||
ScrollUp();
|
||||
offset -= (MemoryModel.TextCellSize * MemoryModel.TextCols);
|
||||
}
|
||||
}
|
||||
offset /= MemoryModel.TextCellSize;
|
||||
_mem.Write(MemoryModel.IoBase + MemoryModel.REG_CURSOR_COL, (byte)(offset % MemoryModel.TextCols));
|
||||
_mem.Write(MemoryModel.IoBase + MemoryModel.REG_CURSOR_ROW, (byte)(offset / MemoryModel.TextCols));
|
||||
}
|
||||
}
|
||||
212
MemoryModel.cs
Normal file
212
MemoryModel.cs
Normal file
|
|
@ -0,0 +1,212 @@
|
|||
/// <summary>
|
||||
/// Memory model for Micronona 256.
|
||||
///
|
||||
/// Address space as seen by the CPU and all high-level layers (Lua, TinyBasic, host):
|
||||
///
|
||||
/// 0x0000 – 0xDEFF Fixed RAM (56,832 bytes, general purpose)
|
||||
/// 0xDF00 – 0xDFFF Hardware registers (256 bytes, I/O)
|
||||
/// 0xE000 – 0xFFFF Bank window (8KB, switchable via REG_BANK)
|
||||
///
|
||||
/// Extended RAM: 256 banks × 8KB = 2MB total.
|
||||
/// The bank window at 0xE000 maps to one 8KB slice of extended RAM at a time.
|
||||
/// Bank switching is done by writing the desired bank number to REG_BANK (0xDF01).
|
||||
///
|
||||
/// Bank layout conventions:
|
||||
/// Bank 0 Text buffer (40×18×3 bytes: char, fg, bg) starts at offset 0
|
||||
/// Bank 255 Font bitmaps (256 glyphs × 8×10 bytes) at end of extended RAM
|
||||
///
|
||||
/// The CPU and all high-level layers use Read(address)/Write(address) exclusively.
|
||||
/// Bank switching is transparent — callers set REG_BANK and then access 0xE000–0xFFFF.
|
||||
///
|
||||
/// The host (renderer, font loader, etc.) uses ReadFlat/WriteFlat to access extended
|
||||
/// RAM directly by absolute byte offset, without affecting the bank register.
|
||||
/// </summary>
|
||||
public class MemoryModel
|
||||
{
|
||||
// -------------------------------------------------------------------------
|
||||
// Layout constants
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
public const int BankCount = 25;
|
||||
public const int BankSize = 8192; // 8KB per bank
|
||||
public const int FixedRamSize = 0xE000; // 56KB fixed RAM (0x0000–0xDFFF)
|
||||
public const int IoBase = 0xDF00; // I/O register block start
|
||||
public const int IoSize = 256; // 256 I/O registers
|
||||
public const int BankWindowBase = 0xE000; // Bank window start address
|
||||
|
||||
// -------------------------------------------------------------------------
|
||||
// I/O register offsets (relative to IoBase = 0xDF00)
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
public const int REG_MODE = 0x00; // Display mode: 0 = text, 1 = graphics
|
||||
public const int REG_BANK = 0x01; // Active bank in the 0xE000 window (0–255)
|
||||
public const int REG_KEY_CHAR = 0x02; // Next keypress character (0 = none)
|
||||
public const int REG_KEY_FLAGS = 0x03; // Modifier flags (Shift, Ctrl, …)
|
||||
public const int REG_TIMER = 0x04; // Auto-incrementing timer; saturates at 255; resets on read
|
||||
public const int REG_VSYNC = 0x05; // VSync flag; set by host each frame
|
||||
public const int REG_CURSOR_COL = 0x06; // Text cursor position horizontally
|
||||
public const int REG_CURSOR_ROW = 0x07; // Text cursor position vertically
|
||||
|
||||
// -------------------------------------------------------------------------
|
||||
// Text mode layout (Bank 0, starting at offset 0)
|
||||
// Each cell is 3 bytes: character code, foreground RGB332, background RGB332
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
public const byte TextCols = 40;
|
||||
public const int TextRows = 18;
|
||||
public const int TextCellSize = 3;
|
||||
public const int TextBankIndex = 0; // Text buffer lives in bank 0
|
||||
public const int TextBufferSize = TextCols * TextRows * TextCellSize; // 2160 bytes
|
||||
|
||||
// Default terminal colors (RGB332)
|
||||
public const byte DefaultFg = 0x1C; // Bright green: R=0, G=224, B=0
|
||||
public const byte DefaultBg = 0x08; // Dark green: R=0, G=64, B=0
|
||||
|
||||
// -------------------------------------------------------------------------
|
||||
// Font layout (Bank 255, starting at offset 0)
|
||||
// 256 glyphs, each 8 pixels wide × 10 pixels tall, 1 bit per pixel packed
|
||||
// into 2 bytes per row (only 8 bits used), so 10 bytes per glyph.
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
public const int FontGlyphWidth = 8;
|
||||
public const int FontGlyphHeight = 10;
|
||||
public const int FontBankIndex = BankCount-1;
|
||||
public const int FontSize = 256 * FontGlyphWidth * FontGlyphHeight; // 20480 bytes
|
||||
|
||||
// -------------------------------------------------------------------------
|
||||
// Internal storage
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
// Fixed RAM: 0x0000–0xDEFF (excludes I/O block)
|
||||
private readonly byte[] _fixedRam = new byte[FixedRamSize];
|
||||
|
||||
// I/O registers: 0xDF00–0xDFFF
|
||||
private readonly byte[] _io = new byte[IoSize];
|
||||
|
||||
// Extended RAM: 256 × 8KB = 2MB, bank-switched into 0xE000–0xFFFF
|
||||
private readonly byte[] _extendedRam = new byte[BankCount * BankSize];
|
||||
|
||||
// -------------------------------------------------------------------------
|
||||
// Constructor
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
public MemoryModel()
|
||||
{
|
||||
// Bank 0 active by default
|
||||
_io[REG_BANK] = TextBankIndex;
|
||||
|
||||
// Fill text buffer with spaces in default colors
|
||||
int textBase = TextBankIndex * BankSize;
|
||||
for (int i = 0; i < TextCols * TextRows; i++)
|
||||
{
|
||||
_extendedRam[textBase + i * TextCellSize + 0] = 0x20; // Space
|
||||
_extendedRam[textBase + i * TextCellSize + 1] = DefaultFg;
|
||||
_extendedRam[textBase + i * TextCellSize + 2] = DefaultBg;
|
||||
}
|
||||
}
|
||||
|
||||
// -------------------------------------------------------------------------
|
||||
// CPU / high-level interface (Read/Write by 16-bit address)
|
||||
// This is the only interface the CPU emulator, Lua, and TinyBasic use.
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
/// <summary>
|
||||
/// Read a single byte from the 16-bit address space.
|
||||
/// </summary>
|
||||
public byte Read(ushort address)
|
||||
{
|
||||
if (address >= IoBase && address < IoBase + IoSize)
|
||||
return ReadIo(address - IoBase);
|
||||
if (address >= BankWindowBase)
|
||||
return ReadBank(address - BankWindowBase);
|
||||
return _fixedRam[address];
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Write a single byte to the 16-bit address space.
|
||||
/// </summary>
|
||||
public void Write(ushort address, byte value)
|
||||
{
|
||||
if (address >= IoBase && address < IoBase + IoSize)
|
||||
WriteIo(address - IoBase, value);
|
||||
else if (address >= BankWindowBase)
|
||||
WriteBank(address - BankWindowBase, value);
|
||||
else
|
||||
_fixedRam[address] = value;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Write multiple bytes sequentially starting at address.
|
||||
/// Convenient for loading font glyphs, tile data, strings, etc.
|
||||
/// Example: mem.Write(0xE000, 0x48, 0x1C, 0x08);
|
||||
/// </summary>
|
||||
public void Write(ushort address, params byte[] data)
|
||||
{
|
||||
for (int i = 0; i < data.Length; i++)
|
||||
Write((ushort)(address + i), data[i]);
|
||||
}
|
||||
|
||||
// -------------------------------------------------------------------------
|
||||
// Host interface (flat access to extended RAM)
|
||||
// Used by the renderer, font loader, and other host-side components.
|
||||
// Does not affect the bank register; does not go through the bank window.
|
||||
// Address is an absolute byte offset into the 2MB extended RAM (0–2097151).
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
/// <summary>
|
||||
/// Read a single byte from extended RAM by absolute offset.
|
||||
/// </summary>
|
||||
public byte ReadFlat(int address)
|
||||
=> _extendedRam[address];
|
||||
|
||||
/// <summary>
|
||||
/// Write one or more bytes to extended RAM starting at absolute offset.
|
||||
/// Example: mem.WriteFlat(255 * BankSize, 0x00, 0x18, 0x3C, 0x66, ...);
|
||||
/// </summary>
|
||||
public void WriteFlat(int address, params byte[] data)
|
||||
{
|
||||
for (int i = 0; i < data.Length; i++)
|
||||
_extendedRam[address + i] = data[i];
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Return a Span over one full bank in extended RAM.
|
||||
/// Useful for bulk operations like SDL texture uploads.
|
||||
/// </summary>
|
||||
public Span<byte> GetBankSpan(int bank)
|
||||
=> _extendedRam.AsSpan(bank * BankSize, BankSize);
|
||||
|
||||
// -------------------------------------------------------------------------
|
||||
// Internal helpers
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
private byte ReadIo(int reg)
|
||||
{
|
||||
if (reg == REG_TIMER)
|
||||
{
|
||||
// Timer resets to 0 on read (after returning current value)
|
||||
byte val = _io[REG_TIMER];
|
||||
_io[REG_TIMER] = 0;
|
||||
return val;
|
||||
}
|
||||
return _io[reg];
|
||||
}
|
||||
|
||||
private void WriteIo(int reg, byte value)
|
||||
{
|
||||
// All register writes are simple stores; bank switch takes effect immediately
|
||||
_io[reg] = value;
|
||||
}
|
||||
|
||||
private byte ReadBank(int offset)
|
||||
{
|
||||
int bank = _io[REG_BANK];
|
||||
return _extendedRam[bank * BankSize + offset];
|
||||
}
|
||||
|
||||
private void WriteBank(int offset, byte value)
|
||||
{
|
||||
int bank = _io[REG_BANK];
|
||||
_extendedRam[bank * BankSize + offset] = value;
|
||||
}
|
||||
}
|
||||
124
MicrononaRenderer.cs
Normal file
124
MicrononaRenderer.cs
Normal file
|
|
@ -0,0 +1,124 @@
|
|||
/// <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()
|
||||
{
|
||||
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);
|
||||
}
|
||||
15
Mironona.csproj
Normal file
15
Mironona.csproj
Normal file
|
|
@ -0,0 +1,15 @@
|
|||
<Project Sdk="Microsoft.NET.Sdk">
|
||||
|
||||
<PropertyGroup>
|
||||
<OutputType>Exe</OutputType>
|
||||
<TargetFramework>net10.0</TargetFramework>
|
||||
<ImplicitUsings>enable</ImplicitUsings>
|
||||
<Nullable>enable</Nullable>
|
||||
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
|
||||
</PropertyGroup>
|
||||
|
||||
<ItemGroup>
|
||||
<PackageReference Include="ppy.SDL2-CS" Version="1.0.82" />
|
||||
</ItemGroup>
|
||||
|
||||
</Project>
|
||||
24
Mironona.sln
Normal file
24
Mironona.sln
Normal file
|
|
@ -0,0 +1,24 @@
|
|||
Microsoft Visual Studio Solution File, Format Version 12.00
|
||||
# Visual Studio Version 17
|
||||
VisualStudioVersion = 17.5.2.0
|
||||
MinimumVisualStudioVersion = 10.0.40219.1
|
||||
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Mironona", "Mironona.csproj", "{FAA5F1D8-9867-FE93-EB3A-67848F811D6E}"
|
||||
EndProject
|
||||
Global
|
||||
GlobalSection(SolutionConfigurationPlatforms) = preSolution
|
||||
Debug|Any CPU = Debug|Any CPU
|
||||
Release|Any CPU = Release|Any CPU
|
||||
EndGlobalSection
|
||||
GlobalSection(ProjectConfigurationPlatforms) = postSolution
|
||||
{FAA5F1D8-9867-FE93-EB3A-67848F811D6E}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
|
||||
{FAA5F1D8-9867-FE93-EB3A-67848F811D6E}.Debug|Any CPU.Build.0 = Debug|Any CPU
|
||||
{FAA5F1D8-9867-FE93-EB3A-67848F811D6E}.Release|Any CPU.ActiveCfg = Release|Any CPU
|
||||
{FAA5F1D8-9867-FE93-EB3A-67848F811D6E}.Release|Any CPU.Build.0 = Release|Any CPU
|
||||
EndGlobalSection
|
||||
GlobalSection(SolutionProperties) = preSolution
|
||||
HideSolutionNode = FALSE
|
||||
EndGlobalSection
|
||||
GlobalSection(ExtensibilityGlobals) = postSolution
|
||||
SolutionGuid = {777F0882-23AC-419E-B040-920E6893B7F9}
|
||||
EndGlobalSection
|
||||
EndGlobal
|
||||
313
Program.cs
Normal file
313
Program.cs
Normal file
|
|
@ -0,0 +1,313 @@
|
|||
using SDL2;
|
||||
|
||||
const int ScreenWidth = 320;
|
||||
const int ScreenHeight = 180;
|
||||
const string Title = "Micronona";
|
||||
const int Scale = 3;
|
||||
|
||||
// -------------------------------------------------------------------------
|
||||
// Memory
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
var mem = new MemoryModel();
|
||||
var micrononaRenderer = new MicrononaRenderer(mem);
|
||||
|
||||
var consoleHelper = new ConsoleHelper(mem);
|
||||
|
||||
// "
|
||||
mem.WriteFlat(MemoryModel.FontBankIndex * MemoryModel.BankSize + 34 * MemoryModel.FontGlyphHeight,
|
||||
0x00, 0x36, 0x66, 0x6C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
|
||||
);
|
||||
|
||||
// *
|
||||
mem.WriteFlat(MemoryModel.FontBankIndex * MemoryModel.BankSize + 42 * MemoryModel.FontGlyphHeight,
|
||||
0x00, 0x00, 0x34, 0x18, 0x7E, 0x18, 0x2C, 0x00, 0x00, 0x00
|
||||
);
|
||||
|
||||
// 0
|
||||
mem.WriteFlat(MemoryModel.FontBankIndex * MemoryModel.BankSize + 48 * MemoryModel.FontGlyphHeight,
|
||||
// 0x00, 0x18, 0x3C, 0x66, 0x66, 0x66, 0x3C, 0x18, 0x00, 0x00
|
||||
0x00, 0x3C, 0x66, 0x6E, 0x7E, 0x76, 0x66, 0x3C, 0x00, 0x00
|
||||
);
|
||||
|
||||
// 1
|
||||
mem.WriteFlat(MemoryModel.FontBankIndex * MemoryModel.BankSize + 49 * MemoryModel.FontGlyphHeight,
|
||||
0x00, 0x0C, 0x1C, 0x3C, 0x0C, 0x0C, 0x0C, 0x1E, 0x00, 0x00
|
||||
);
|
||||
|
||||
// 2
|
||||
mem.WriteFlat(MemoryModel.FontBankIndex * MemoryModel.BankSize + 50 * MemoryModel.FontGlyphHeight,
|
||||
// 0x00, 0x3C, 0x66, 0x0C, 0x18, 0x30, 0x60, 0x7F, 0x00, 0x00
|
||||
0x00, 0x3C, 0x66, 0x06, 0x0C, 0x18, 0x30, 0x7E, 0x00, 0x00
|
||||
);
|
||||
|
||||
// 3
|
||||
mem.WriteFlat(MemoryModel.FontBankIndex * MemoryModel.BankSize + 51 * MemoryModel.FontGlyphHeight,
|
||||
0x00, 0x3C, 0x66, 0x06, 0x1C, 0x06, 0x66, 0x3C, 0x00, 0x00
|
||||
);
|
||||
|
||||
// 4
|
||||
mem.WriteFlat(MemoryModel.FontBankIndex * MemoryModel.BankSize + 52 * MemoryModel.FontGlyphHeight,
|
||||
0x00, 0x1C, 0x3C, 0x6C, 0x7E, 0x0C, 0x0C, 0x0C, 0x00, 0x00
|
||||
);
|
||||
|
||||
// 5
|
||||
mem.WriteFlat(MemoryModel.FontBankIndex * MemoryModel.BankSize + 53 * MemoryModel.FontGlyphHeight,
|
||||
// 0x00, 0x7E, 0x60, 0x7C, 0x06, 0x06, 0x06, 0x7C, 0x00, 0x00
|
||||
// 0x00, 0x7E, 0x60, 0x60, 0x7C, 0x06, 0x06, 0x7C, 0x00, 0x00
|
||||
0x00, 0x7E, 0x60, 0x60, 0x7C, 0x06, 0x66, 0x3C, 0x00, 0x00
|
||||
);
|
||||
|
||||
// 6
|
||||
mem.WriteFlat(MemoryModel.FontBankIndex * MemoryModel.BankSize + 54 * MemoryModel.FontGlyphHeight,
|
||||
0x00, 0x3C, 0x60, 0x60, 0x7C, 0x66, 0x66, 0x3C, 0x00, 0x00
|
||||
);
|
||||
|
||||
// 7
|
||||
mem.WriteFlat(MemoryModel.FontBankIndex * MemoryModel.BankSize + 55 * MemoryModel.FontGlyphHeight,
|
||||
0x00, 0x7E, 0x06, 0x0E, 0x0C, 0x1C, 0x18, 0x18, 0x00, 0x00
|
||||
);
|
||||
|
||||
// 8
|
||||
mem.WriteFlat(MemoryModel.FontBankIndex * MemoryModel.BankSize + 56 * MemoryModel.FontGlyphHeight,
|
||||
0x00, 0x3C, 0x66, 0x66, 0x3C, 0x66, 0x66, 0x3C, 0x00, 0x00
|
||||
);
|
||||
|
||||
// 9
|
||||
mem.WriteFlat(MemoryModel.FontBankIndex * MemoryModel.BankSize + 57 * MemoryModel.FontGlyphHeight,
|
||||
0x00, 0x3C, 0x66, 0x66, 0x3E, 0x06, 0x06, 0x3C, 0x00, 0x00
|
||||
);
|
||||
|
||||
// A
|
||||
mem.WriteFlat(MemoryModel.FontBankIndex * MemoryModel.BankSize + 65 * MemoryModel.FontGlyphHeight,
|
||||
0x00, 0x18, 0x3C, 0x66, 0x7E, 0x66, 0x66, 0x66, 0x00, 0x00
|
||||
);
|
||||
|
||||
// C
|
||||
mem.WriteFlat(MemoryModel.FontBankIndex * MemoryModel.BankSize + 67 * MemoryModel.FontGlyphHeight,
|
||||
// 0x00, 0x3A, 0x66, 0x60,0x60, 0x60,0x66,0x3A,0x00,0x00
|
||||
0x00, 0x3C, 0x66, 0x60, 0x60, 0x60, 0x66, 0x3C, 0x00, 0x00
|
||||
);
|
||||
|
||||
// D
|
||||
mem.WriteFlat(MemoryModel.FontBankIndex * MemoryModel.BankSize + 68 * MemoryModel.FontGlyphHeight,
|
||||
0x00, 0x7C, 0x66, 0x66, 0x66, 0x66, 0x66, 0x7C, 0x00, 0x00
|
||||
);
|
||||
|
||||
// E
|
||||
mem.WriteFlat(MemoryModel.FontBankIndex * MemoryModel.BankSize + 69 * MemoryModel.FontGlyphHeight,
|
||||
0x00, 0x7E, 0x60, 0x60, 0x7C, 0x60, 0x60, 0x7E, 0x00, 0x00
|
||||
);
|
||||
|
||||
// G
|
||||
mem.WriteFlat(MemoryModel.FontBankIndex * MemoryModel.BankSize + 71 * MemoryModel.FontGlyphHeight,
|
||||
0x00, 0x3C, 0x66, 0x60, 0x6E, 0x66, 0x66, 0x3C, 0x00, 0x00
|
||||
);
|
||||
|
||||
// H
|
||||
mem.WriteFlat(MemoryModel.FontBankIndex * MemoryModel.BankSize + 72 * MemoryModel.FontGlyphHeight,
|
||||
0x00, 0x66, 0x66, 0x66, 0x7E, 0x66, 0x66, 0x66, 0x00, 0x00
|
||||
);
|
||||
|
||||
// I
|
||||
mem.WriteFlat(MemoryModel.FontBankIndex * MemoryModel.BankSize + 73 * MemoryModel.FontGlyphHeight,
|
||||
0x00, 0x3C, 0x18, 0x18, 0x18, 0x18, 0x18, 0x3C, 0x00, 0x00
|
||||
);
|
||||
|
||||
// L
|
||||
mem.WriteFlat(MemoryModel.FontBankIndex * MemoryModel.BankSize + 76 * MemoryModel.FontGlyphHeight,
|
||||
0x00, 0x60, 0x60, 0x60, 0x60, 0x60, 0x60, 0x7E, 0x00, 0x00
|
||||
);
|
||||
|
||||
// M
|
||||
mem.WriteFlat(MemoryModel.FontBankIndex * MemoryModel.BankSize + 77 * MemoryModel.FontGlyphHeight,
|
||||
// 0x00, 0x62, 0x76, 0x7E,0x6A, 0x62,0x62,0x62,0x00,0x00
|
||||
// 0x00, 0x42, 0x66, 0x7e, 0x5a, 0x42, 0x66, 0x66
|
||||
0x00, 0x42, 0x66, 0x7e, 0x7E, 0x66, 0x66, 0x66
|
||||
// 0x00, 0x62, 0x76, 0x7E, 0x6A, 0x62, 0x62, 0x66, 0x00, 0x00
|
||||
);
|
||||
|
||||
// N
|
||||
mem.WriteFlat(MemoryModel.FontBankIndex * MemoryModel.BankSize + 78 * MemoryModel.FontGlyphHeight,
|
||||
0x00, 0x66, 0x66, 0x76, 0x7E, 0x6E, 0x66, 0x66, 0x00, 0x00
|
||||
);
|
||||
|
||||
// O
|
||||
mem.WriteFlat(MemoryModel.FontBankIndex * MemoryModel.BankSize + 79 * MemoryModel.FontGlyphHeight,
|
||||
0x00, 0x3C, 0x66, 0x66, 0x66, 0x66, 0x66, 0x3C, 0x00, 0x00
|
||||
);
|
||||
|
||||
// P
|
||||
mem.WriteFlat(MemoryModel.FontBankIndex * MemoryModel.BankSize + 80 * MemoryModel.FontGlyphHeight,
|
||||
0x00, 0x7C, 0x66, 0x66, 0x7C, 0x60, 0x60, 0x60, 0x00, 0x00
|
||||
// 0x00, 0x62, 0x76, 0x7E, 0x6A, 0x62, 0x62, 0x66, 0x00, 0x00
|
||||
);
|
||||
|
||||
// R
|
||||
mem.WriteFlat(MemoryModel.FontBankIndex * MemoryModel.BankSize + 82 * MemoryModel.FontGlyphHeight,
|
||||
0x00, 0x7C, 0x66, 0x66, 0x7C, 0x78, 0x6C, 0x66, 0x00, 0x00
|
||||
// 0x00, 0x62, 0x76, 0x7E, 0x6A, 0x62, 0x62, 0x66, 0x00, 0x00
|
||||
);
|
||||
|
||||
// T
|
||||
mem.WriteFlat(MemoryModel.FontBankIndex * MemoryModel.BankSize + 84 * MemoryModel.FontGlyphHeight,
|
||||
// 0x00, 0x7E, 0x18, 0x18, 0x18, 0x18, 0x18, 0x3C, 0x00, 0x00
|
||||
0x00, 0x7E, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x00, 0x00
|
||||
);
|
||||
|
||||
// Y
|
||||
mem.WriteFlat(MemoryModel.FontBankIndex * MemoryModel.BankSize + 89 * MemoryModel.FontGlyphHeight,
|
||||
0x00, 0x66, 0x66, 0x3C, 0x18, 0x18, 0x18, 0x18, 0x00, 0x00
|
||||
);
|
||||
|
||||
// c
|
||||
mem.WriteFlat(MemoryModel.FontBankIndex * MemoryModel.BankSize + 99 * MemoryModel.FontGlyphHeight,
|
||||
0x00, 0x00, 0x3C, 0x66, 0x60, 0x60, 0x66, 0x3C, 0x00, 0x00
|
||||
);
|
||||
|
||||
// i
|
||||
mem.WriteFlat(MemoryModel.FontBankIndex * MemoryModel.BankSize + 105 * MemoryModel.FontGlyphHeight,
|
||||
// 0x00, 0x00, 0x10, 0x00, 0x10, 0x10, 0x10, 0x18, 0x00, 0x00
|
||||
// 0x00, 0x00, 0x18, 0x00, 0x18, 0x18, 0x18, 0x3C, 0x00, 0x00
|
||||
0x00, 0x18, 0x00, 0x18, 0x18, 0x18, 0x18, 0x3C, 0x00, 0x00
|
||||
);
|
||||
|
||||
// t
|
||||
mem.WriteFlat(MemoryModel.FontBankIndex * MemoryModel.BankSize + 116 * MemoryModel.FontGlyphHeight,
|
||||
0x00, 0x00, 0x18, 0x18, 0x3C, 0x18, 0x18, 0x0C, 0x00, 0x00
|
||||
);
|
||||
|
||||
// -------------------------------------------------------------------------
|
||||
// SDL init
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
if (SDL.SDL_Init(SDL.SDL_INIT_VIDEO) < 0)
|
||||
{
|
||||
Console.Error.WriteLine($"SDL_Init failed: {SDL.SDL_GetError()}");
|
||||
return 1;
|
||||
}
|
||||
|
||||
SDL.SDL_StartTextInput();
|
||||
|
||||
var window = SDL.SDL_CreateWindow(
|
||||
Title,
|
||||
SDL.SDL_WINDOWPOS_CENTERED,
|
||||
SDL.SDL_WINDOWPOS_CENTERED,
|
||||
ScreenWidth * Scale,
|
||||
ScreenHeight * Scale,
|
||||
SDL.SDL_WindowFlags.SDL_WINDOW_SHOWN
|
||||
);
|
||||
|
||||
if (window == IntPtr.Zero)
|
||||
{
|
||||
Console.Error.WriteLine($"SDL_CreateWindow failed: {SDL.SDL_GetError()}");
|
||||
SDL.SDL_Quit();
|
||||
return 1;
|
||||
}
|
||||
|
||||
var renderer = SDL.SDL_CreateRenderer(
|
||||
window, -1,
|
||||
SDL.SDL_RendererFlags.SDL_RENDERER_ACCELERATED |
|
||||
SDL.SDL_RendererFlags.SDL_RENDERER_PRESENTVSYNC
|
||||
);
|
||||
|
||||
if (renderer == IntPtr.Zero)
|
||||
{
|
||||
Console.Error.WriteLine($"SDL_CreateRenderer failed: {SDL.SDL_GetError()}");
|
||||
SDL.SDL_DestroyWindow(window);
|
||||
SDL.SDL_Quit();
|
||||
return 1;
|
||||
}
|
||||
|
||||
// Framebuffer texture: 320×180, RGB24 (expanded from RGB332 each frame)
|
||||
var texture = SDL.SDL_CreateTexture(
|
||||
renderer,
|
||||
SDL.SDL_PIXELFORMAT_RGB24,
|
||||
(int)SDL.SDL_TextureAccess.SDL_TEXTUREACCESS_STREAMING,
|
||||
ScreenWidth, ScreenHeight
|
||||
);
|
||||
|
||||
// RGB24 output buffer for SDL (expanded from memory each frame)
|
||||
byte[] rgb24 = new byte[ScreenWidth * ScreenHeight * 3];
|
||||
|
||||
|
||||
var top = "*** MICRONONA 256 ***";
|
||||
var tab = (byte)((MemoryModel.TextCols - top.Length) / 2);
|
||||
consoleHelper.SetCursor(tab, 0);
|
||||
consoleHelper.WriteText(top);
|
||||
|
||||
consoleHelper.SetCursor(35, 16);
|
||||
consoleHelper.WriteText("MICRONONA");
|
||||
|
||||
consoleHelper.SetCursor(5, 1);
|
||||
|
||||
SDL.SDL_SetWindowFullscreen(window, (uint)SDL.SDL_WindowFlags.SDL_WINDOW_FULLSCREEN_DESKTOP);
|
||||
// -------------------------------------------------------------------------
|
||||
// Main loop
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
bool running = true;
|
||||
SDL.SDL_Event e;
|
||||
|
||||
while (running)
|
||||
{
|
||||
// --- Events ---
|
||||
while (SDL.SDL_PollEvent(out e) != 0)
|
||||
{
|
||||
if (e.type == SDL.SDL_EventType.SDL_QUIT)
|
||||
running = false;
|
||||
|
||||
if (e.type == SDL.SDL_EventType.SDL_KEYDOWN)
|
||||
{
|
||||
switch (e.key.keysym.sym)
|
||||
{
|
||||
case SDL.SDL_Keycode.SDLK_ESCAPE:
|
||||
running = false;
|
||||
break;
|
||||
case SDL.SDL_Keycode.SDLK_LEFT: consoleHelper.MoveCursor(-1, 0); break;
|
||||
case SDL.SDL_Keycode.SDLK_RIGHT: consoleHelper.MoveCursor(1, 0); break;
|
||||
case SDL.SDL_Keycode.SDLK_UP: consoleHelper.MoveCursor(0, -1); break;
|
||||
case SDL.SDL_Keycode.SDLK_DOWN: consoleHelper.MoveCursor(0, 1); break;
|
||||
case SDL.SDL_Keycode.SDLK_RETURN: consoleHelper.NewLine(); break;
|
||||
case SDL.SDL_Keycode.SDLK_BACKSPACE: consoleHelper.Backspace(); break;
|
||||
case SDL.SDL_Keycode.SDLK_DELETE: consoleHelper.Delete(); break;
|
||||
}
|
||||
|
||||
}
|
||||
if (e.type == SDL.SDL_EventType.SDL_TEXTINPUT)
|
||||
{
|
||||
unsafe
|
||||
{
|
||||
byte ascii = e.text.text[0];
|
||||
if (ascii >= 32 && ascii < 127)
|
||||
consoleHelper.WriteText(((char)ascii).ToString());
|
||||
}
|
||||
}
|
||||
}
|
||||
// --- VSync flag setzen (wird später vom 6809-Emulator gelesen) ---
|
||||
mem.Write(MemoryModel.IoBase + MemoryModel.REG_VSYNC, 1);
|
||||
|
||||
// --- Render ---
|
||||
var span = micrononaRenderer.Render();
|
||||
unsafe
|
||||
{
|
||||
fixed (byte* ptr = span)
|
||||
{
|
||||
SDL.SDL_UpdateTexture(texture, IntPtr.Zero, (IntPtr)ptr, 320 * 3);
|
||||
}
|
||||
}
|
||||
|
||||
SDL.SDL_RenderClear(renderer);
|
||||
SDL.SDL_RenderCopy(renderer, texture, IntPtr.Zero, IntPtr.Zero);
|
||||
SDL.SDL_RenderPresent(renderer);
|
||||
}
|
||||
|
||||
// -------------------------------------------------------------------------
|
||||
// Cleanup
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
SDL.SDL_DestroyTexture(texture);
|
||||
SDL.SDL_DestroyRenderer(renderer);
|
||||
SDL.SDL_DestroyWindow(window);
|
||||
SDL.SDL_Quit();
|
||||
return 0;
|
||||
Loading…
Add table
Reference in a new issue