+
](https://highbyte.se/dotnet-6502/app)
+
+
+
](https://highbyte.se/dotnet-6502/app) | [
](#highbytedotnet6502appsilknetnative) | [
](#highbytedotnet6502appsadconsole) |
+
+| Run 6502 machine code in your own .NET apps | Machine code monitor |
+| ----------------------------------- | ----------------------------------- |
+|  |  |
+
+## Common libraries
+- [`Highbyte.DotNet6502`](doc/CPU_LIBRARY.md)
+ - Core library for executing 6502 machine code, not bound to any specific emulated system/computer, and does not have any UI or I/O code.
+- [`Highbyte.DotNet6502.Monitor`](doc/MONITOR.md)
+ - Machine code monitor library used as a base for host apps using the `Highbyte.DotNet6502` library.
+- [`Highbyte.DotNet6502.Systems`](doc/SYSTEMS.md)
+ - Library for common interfaces and implementations for running computers ("systems") that uses the `Highbyte.DotNet6502` library.
+
+## System/computer-specific libraries
+Contains core system/computer emulation logic, but with no UI or I/O dependencies.
+Implements abstractions in `Highbyte.DotNet6502.Systems`.
+- [`Highbyte.DotNet6502.Systems.Commodore64`](doc/SYSTEMS_C64.md)
+ - Logic for emulating a Commodore 64 (C64).
+ - Runs C64 ROMs (Kernal, Basic, Chargen).
+ - List of apps/games listed that's been tested to work [here](doc/SYSTEMS_C64_COMPATIBLE_PRG.md) (and how to load them).
+
+- [`Highbyte.DotNet6502.Systems.Generic`](doc/SYSTEMS_GENERIC.md)
+ - Logic for emulating a generic computer based on 6502 CPU.
+
+## System-specific libraries for I/O
+Implements rendering, input handling, and audio using different technologies per emulated system/computer. Implements abstractions in `Highbyte.DotNet6502.Systems`. These libraries are used from relevant UI host apps (see below).
+- [`Highbyte.DotNet6502.Impl.AspNet`](doc/RENDER_INPUT_AUDIO.md#library-highbytedotnet6502implaspnet)
+ - System-specific input and audio code for AspNet Blazor `WASM` app.
+- [`Highbyte.DotNet6502.Impl.NAudio`](doc/RENDER_INPUT_AUDIO.md#library-highbytedotnet6502implnaudio)
+ - System-specific audio code for NAudio for `SilkNetNative` and `SadConsole` apps.
+- [`Highbyte.DotNet6502.Impl.SadConsole`](doc/RENDER_INPUT_AUDIO.md#library-highbytedotnet6502implsadconsole)
+ - System-specific rendering and input code for `SadConsole` app.
+- [`Highbyte.DotNet6502.Impl.SilkNet`](doc/RENDER_INPUT_AUDIO.md#library-highbytedotnet6502implsilknet)
+ - System-specific rendering (OpenGL shaders) and input code for `SilkNetNative` app.
+- [`Highbyte.DotNet6502.Impl.Skia`](doc/RENDER_INPUT_AUDIO.md#library-highbytedotnet6502implskia)
+ - System-specific rendering with SkiaSharp for `SilkNetNative`, and Blazor `WASM` apps.
+
+## UI host apps that runs emulators
+UI host apps for emulating the systems/computers above, using different I/O techniques (rendering, input, audio).
+
+### [`Highbyte.DotNet6502.App.WASM`](doc/APPS_WASM.md)
+
+A [`ASP.NET Blazor`](https://dotnet.microsoft.com/en-us/apps/aspnet/web-apps/blazor) WebAssembly UI.
+ - Rendering: `Highbyte.DotNet6502.Impl.Skia`
+ - Input: `Highbyte.DotNet6502.Impl.AspNet`
+ - Audio: `Highbyte.DotNet6502.Impl.AspNet`
+
+Live version: [https://highbyte.se/dotnet-6502/app](https://highbyte.se/dotnet-6502/app)
+
+[
](https://highbyte.se/dotnet-6502/app) [
](https://highbyte.se/dotnet-6502/app)
+
+### [`Highbyte.DotNet6502.App.SilkNetNative`](doc/APPS_SILKNET_NATIVE.md)
+A [`Silk.NET`](https://github.com/dotnet/Silk.NET) native UI.
+ - Rendering: `Highbyte.DotNet6502.Impl.Skia` or `Highbyte.DotNet6502.Impl.SilkNet`
+ - Input: `Highbyte.DotNet6502.Impl.SilkNet`
+ - Audio: `Highbyte.DotNet6502.Impl.NAudio`
+
+
+
+### [`Highbyte.DotNet6502.App.SadConsole`](doc/APPS_SADCONSOLE.md)
+A [`SadConsole`](https://github.com/Thraka/SadConsole) (a ascii/console/game engine) native UI.
+ - Rendering: `Highbyte.DotNet6502.Impl.SadConsole`
+ - Input: `Highbyte.DotNet6502.Impl.SadConsole`
+ - Audio: `Highbyte.DotNet6502.Impl.NAudio`
+
+ 
+
+### [`Highbyte.DotNet6502.App.ConsoleMonitor`](doc/APPS_CONSOLE_MONITOR.md)
+A console application with a only UI being a machine code monitor.
+ - Rendering: standard .NET console
+ - Input: standard .NET console
+ - Audio: none
+
+
+
+# Limitations
+> [!IMPORTANT]
+> - Correct emulation of all aspects of computers such as Commodore 64 is not likely.
+> - Not the fastest emulator.
+> - A real Commodore 64 uses the _6510_ CPU and not the 6502 CPU. But for the purpose of this emulator the 6502 CPU works fine as they are generally the same (same instruction set).
+> - Code coverage is currently limited to the core [`Highbyte.DotNet6502`](doc/CPU_LIBRARY.md) library.
-- A library [```Highbyte.DotNet6502.Systems```](doc/SYSTEMS.md) containing implementations of specific computers ("Systems") that runs on a 6502 CPU.
-
-- Several libraries [```Highbyte.DotNet6502.Impl.*```](doc/RENDER_INPUT_AUDIO.md) that implements rendering, input handling, and audio using different technologies (such as Skia, Blazor, SadConsole) per emulated System.
-
-- Several UI applications [```Highbyte.DotNet6502.Apps.*```](doc/APPS.md) that are the hosts for emulating the Systems above and their different rendering techniques.
-
-# What's currently missing
Missing features (but not limited to):
- 6502 CPU
- - Support for unofficial opcodes
+ - Support for unofficial opcodes.
- Systems
- - C64: cycle-exact rendering, bitmap graphics mode renderer in Blazor WASM, etc.
-
-# What this isn't (and probably never will be)
-- An emulation of all aspects of computers such as Apple II or Commodore 64.
-- The fastest emulator.
+ - Commodore 64: cycle-exact rendering, disk/tape drive support, accurate/stable audio, etc.
# How to develop
-For requirements and local development setup, see [here](doc/DEVELOP.md)
-
-# Inspiration, references & resources
-
-## 6502 CPU Emulator in C++ video
-- https://www.youtube.com/playlist?list=PLLwK93hM93Z13TRzPx9JqTIn33feefl37
-
-## 6502 CPU references
-- http://www.obelisk.me.uk/6502/index.html
-- https://www.atariarchives.org/alp/appendix_1.php
-- http://www.6502.org/tutorials/compare_beyond.html
-- https://www.c64-wiki.com/wiki/BRK
-- http://www.emulator101.com/6502-addressing-modes.html
-- https://www.pagetable.com/?p=410
-- http://6502.org/tutorials/decimal_mode.html
-
-## C64 specific references
-- https://www.c64-wiki.com/wiki/Reset_(Process)
-- https://www.c64-wiki.com/wiki/Bank_Switching
-- https://www.pagetable.com/c64ref/c64mem/
-- https://sta.c64.org/cbm64mem.html
-- https://github.com/mist64/c64ref/blob/master/Source/c64io/c64io_mapc64.txt
-- https://www.c64-wiki.com/wiki/PETSCII_Codes_in_Listings
-- https://dustlayer.com/c64-architecture/2013/5/7/hardware-basics-part-1-tick-tock-know-your-clock
-- https://dustlayer.com/vic-ii/2013/4/22/when-visibility-matters
-- https://dustlayer.com/vic-ii/2013/4/25/vic-ii-for-beginners-beyond-the-screen-rasters-cycle
-- https://www.zimmers.net/cbmpics/cbm/c64/vic-ii.txt
-- https://www.c64-wiki.com/wiki/Raster_interrupt
-- https://codebase64.org/doku.php?id=base:detect_pal_ntsc
-- https://www.lemon64.com/forum/viewtopic.php?p=667448#p667448
-- https://www.c64-wiki.com/wiki/ADSR
-- https://www.atarimagazines.com/compute/issue49/424_1_Programming_64_Sound.php
-- https://celso.io/retrocomputing/2019/12/23/c64-assembly
-
-
-## WebAudio
-- https://developer.mozilla.org/en-US/docs/Web/API/Web_Audio_API
-- https://developer.mozilla.org/en-US/docs/Web/API/Web_Audio_API/Advanced_techniques
-- https://github.com/pendragon-andyh/WebAudio-PulseOscillator
-- https://github.com/KristofferStrube/Blazor.WebAudio
-- https://ui.dev/web-audio-api
-- https://codepen.io/2kool2/pen/xrLeMq
-- https://dev.opera.com/articles/drum-sounds-webaudio/
-
-## Test programs
-- http://visual6502.org/wiki/index.php?title=6502TestPrograms
-- https://github.com/Klaus2m5/6502_65C02_functional_tests/blob/master/6502_functional_test.a65
-- http://www.csharp4u.com/2017/01/getting-pretty-hex-dump-of-binary-file.html?m=1
-
-## Assemblers
-Was used during development to compile actual 6502 source code to a binary, and then run it through the emulator.
-
-- https://sourceforge.net/projects/acme-crossass/
-- https://marketplace.visualstudio.com/items?itemName=rosc.vs64
-- https://nurpax.github.io/c64jasm-browser/
-- https://skilldrick.github.io/easy6502/#first-program
-
-## Monitors / Emulators
-Was used during development to test how certain instructions worked when in doubt.
-
-### VICE
-Monitor commands: https://vice-emu.sourceforge.io/vice_12.html
-
-How to load and step through a program in the VICE monitor
-```
-l "C:\Source\Repos\dotnet-6502\samples\Assembler\Generic\Build\testprogram.prg" 0 1000
-d 1000
-r PC=1000
-z
-r
-```
-
-## Credits
+See [here](doc/DEVELOP.md)
+
+# References
+See [here](doc/REFERENCES_AND_INSPIRATION.md).
+
+# Credits
- [Kristoffer Strube](https://github.com/KristofferStrube) for the original Blazor WASM async interop code for [WebAudio](https://github.com/KristofferStrube/Blazor.WebAudio), [DOM](https://github.com/KristofferStrube/Blazor.DOM), and [IDL](https://github.com/KristofferStrube/Blazor.WebIDL) that was the basis for a synchronous implementation in this repo. Copyright notice [here](src/libraries/Highbyte.DotNet6502.Impl.AspNet/JSInterop/JSInterop_OriginalLicense.MD).
diff --git a/doc/APPS.md b/doc/APPS.md
index ffc9f1a3..3b9ee9ee 100644
--- a/doc/APPS.md
+++ b/doc/APPS.md
@@ -3,7 +3,7 @@
# Overview
Emulator applications with user interfaces for running different [systems](SYSTEMS.md), using different [rendering input handling, and audio](RENDER_INPUT_AUDIO.md) techniques.
-- [Blazor Web Assembly (WASM) with SkiaSharp renderer](APPS_SKIA_WASM.md)
-- [Native cross-platform window via Silk.NET using with SkiaSharp renderer](APPS_SILKNET_NATIVE.md)
-- [Native cross-platform window via SadConsole, using SadConsole renderer](APPS_SADCONSOLE.md)
+- [Blazor Web Assembly (WASM)](APPS_WASM.md)
+- [Native cross-platform window via Silk.NET](APPS_SILKNET_NATIVE.md)
+- [Native cross-platform window via SadConsole](APPS_SADCONSOLE.md)
- [Native cross-platform console monitor app](APPS_CONSOLE_MONITOR.md)
diff --git a/doc/APPS_CONSOLE_MONITOR.md b/doc/APPS_CONSOLE_MONITOR.md
index 255f2a51..e9eebbff 100644
--- a/doc/APPS_CONSOLE_MONITOR.md
+++ b/doc/APPS_CONSOLE_MONITOR.md
@@ -1,7 +1,7 @@
+
# Features
Stand-alone console monitor app, no other UI.
diff --git a/doc/APPS_SADCONSOLE.md b/doc/APPS_SADCONSOLE.md
index efc02033..9832d18f 100644
--- a/doc/APPS_SADCONSOLE.md
+++ b/doc/APPS_SADCONSOLE.md
@@ -1,18 +1,23 @@
+
# Features
-Native cross-platform app written in .NET with a Window, renderer, and input handler via SadConsole (from ```Highbyte.DotNet6502.Impl.SadConsole```).
-
-Currently the system to emulate is configured in the appsettings.json file.
+Native cross-platform app based on the [`SadConsole`](https://github.com/Thraka/SadConsole) terminal/ascii/console/game engine.
# System: C64
-A directory containing the C64 ROM files (Kernal, Basic, Chargen) is supplied by the user, and set in the appsettings.json file.
+- A directory containing the C64 ROM files (Kernal, Basic, Chargen) is supplied by the user. Defaults are set in the appsettings.json file, and possible to change in the UI.
+- Only video mode that works in C64 character mode (not multicolor) with built-in characters set from ROM is supported.
+- Generation of sound via NAudio with custom OpenAL (Silk.NET) provider (for cross platform compatibility).
# System: Generic computer
TODO
# Monitor
+Press button or toggle with F12.
+TODO
+
+# Stats
+Press button or toggle with F11.
TODO
diff --git a/doc/APPS_SILKNET_NATIVE.md b/doc/APPS_SILKNET_NATIVE.md
index fd1489a3..fd347402 100644
--- a/doc/APPS_SILKNET_NATIVE.md
+++ b/doc/APPS_SILKNET_NATIVE.md
@@ -1,21 +1,26 @@
-
-
+
# Features
-Native cross-platform app written in .NET with a Window from Silk.NET, using a SkiaSharp (from ```Highbyte.DotNet6502.Impl.Skia```) or a OpenGL (from ```Highbyte.DotNet6502.Impl.SilkNet```) renderer, with a Silk.NET input handler (from ```Highbyte.DotNet6502.Impl.SilkNet```).
+Native cross-platform app written in .NET using a [Silk.NET](https://github.com/dotnet/Silk.NET) window.
Uses Silk.NET [ImGui extensions](https://www.nuget.org/packages/Silk.NET.OpenGL.Extensions.ImGui/) to render UI for interactive menu, monitor, and stats window.
# System: C64
-A directory containing the C64 ROM files (Kernal, Basic, Chargen) is supplied by the user, and set in the appsettings.json file.
+- A directory containing the C64 ROM files (Kernal, Basic, Chargen) is supplied by the user. Defaults are set in the appsettings.json file, and possible to change in the UI.
+
+- Renderers using either `SkiaSharp` or `SilkNet` (OpenGl)
+ - Character mode (normal and multi-color) with all renderers
+ - Bitmap mode (normal and bitmap mode) with the SkiaSharp2* and SilkNetOpenGL renderers.
+ - Sprites (normal and multi-color) with all renderers.
+ - Rendering of raster lines for border and background colors with all renderers.
-Rendering of raster lines for border and background colors.
+- Input using `SilkNet`
-Generation of sound via NAudio with custom OpenAL (Silk.NET) provider (for cross platform compatibility).
+- Audio via `NAudio`
+ - [NAudio](https://github.com/naudio/NAudio) + custom OpenAL (Silk.NET) provider for cross platform compatibility.
# System: Generic computer
TODO
@@ -29,7 +34,7 @@ Start and stop of selected system.
Configuration options of selected system.
-## Monitor
+ ## Monitor
A togglebale machine code monitor window by pressing F12.
## Stats
diff --git a/doc/APPS_WASM.md b/doc/APPS_WASM.md
index 017029af..bac9a231 100644
--- a/doc/APPS_WASM.md
+++ b/doc/APPS_WASM.md
@@ -1,21 +1,26 @@
-
-
+
A deployed version can be found here [https://highbyte.se/dotnet-6502/app](https://highbyte.se/dotnet-6502/app)
# Features
-A web app written in Blazor WASM (Web Assembly), using [```SkiaSharp.Views.Blazor```](https://www.nuget.org/packages/SkiaSharp.Views.Blazor) library to provide a Canvas for drawing on with main [```SkiaSharp```](https://www.nuget.org/packages/SkiaSharp) library.
+A web app written in Blazor WASM (Web Assembly), using [`SkiaSharp.Views.Blazor`](https://www.nuget.org/packages/SkiaSharp.Views.Blazor) library to provide a Canvas for drawing on with main [`SkiaSharp`](https://www.nuget.org/packages/SkiaSharp) library.
# System: C64
-Via C64 config UI you have to upload binaries for the ROMs that a C64 uses (Kernal, Basic, Chargen).
+- Via C64 config UI you have to upload binaries for the ROMs that a C64 uses (Kernal, Basic, Chargen).
+
+- Renderers: `SkiaSharp`, `SkiaSharp2`, `SkiaSharp2b`
+ - Character mode (normal and multi-color) with all renderers
+ - Bitmap mode (normal and bitmap mode) only with the `SkiaSharp2*` renderers.
+ - Sprites (normal and multi-color) with all renderers.
+ - Rendering of raster lines for border and background colors with all renderers.
-Rendering of raster lines for border and background colors.
+- Input using `AspNet`
-Generation of sound via WebAudio API.
+- Audio via `AspNet`
+ - Using .NET interop to WebAudio API
# System: Generic computer
The example 6502 machine code that is loaded and run by default for the _Generic_ computer is this a assembled version of [this 6502 assembly code](../samples/Assembler/Generic/hostinteraction_scroll_text_and_cycle_colors.asm)
@@ -40,12 +45,12 @@ For system requirements, see details [here](DEVELOP.md#Requirements)
## Visual Studio 2022 (Windows)
-Open solution ```dotnet-6502.sln```.
-Set project ```Highbyte.DotNet6502.App.WASM``` as startup, and start with F5.
+Open solution `dotnet-6502.sln`.
+Set project `Highbyte.DotNet6502.App.WASM` as startup, and start with F5.
## From command line (Windows, Linux, Mac)
### Run Debug build
-```
+```shell
cd ./src/apps/Highbyte.DotNet6502.App.WASM
dotnet run
```
@@ -53,10 +58,10 @@ Open browser at http://localhost:5000.
### Run optimized Publish build
Requires
-- DotNet workload "wasm-tools" , install with ```dotnet workload install wasm-tools```
-- DotNet global tool "serve", install with ```dotnet tool install --global dotnet-serve```
+- DotNet workload "wasm-tools" , install with `dotnet workload install wasm-tools`
+- DotNet global tool "serve", install with `dotnet tool install --global dotnet-serve`
-```
+```powershell
cd ./src/apps/Highbyte.DotNet6502.App.WASM
if(Test-Path $publishDir) { del ./bin/Publish/ -r -force }
dotnet publish -c Release -o ./bin/Publish/
diff --git a/doc/CPU_LIBRARY.md b/doc/CPU_LIBRARY.md
index dd8b9dd4..d1a92dc2 100644
--- a/doc/CPU_LIBRARY.md
+++ b/doc/CPU_LIBRARY.md
@@ -13,93 +13,197 @@
# Using from a .NET application
## Reference NuGet package
-```
+```shell
dotnet add package Highbyte.DotNet6502 --prerelease
```
## Or compile .dll yourself
-- Clone this repo ```git clone https://github.com/highbyte/dotnet-6502.git```
-- Change dir to library ```cd dotnet-6502/src/libraries/Highbyte.DotNet6502```
-- Build library ```dotnet build```
-- In your app, add .dll reference to ```./bin/Debug/net8.0/Highbyte.DotNet6502.dll```
+- Clone this repo `git clone https://github.com/highbyte/dotnet-6502.git`
+- Change dir to library `cd dotnet-6502/src/libraries/Highbyte.DotNet6502`
+- Build library `dotnet build`
+- In your app, add .dll reference to `./bin/Debug/net8.0/Highbyte.DotNet6502.dll`
## Example of basic usage of Highbyte.DotNet6502 library
-Example #1. Load compiled 6502 binary and execute it.
+## Example #1.
+
+### Step 1 - Write a 6502 program in assembly
+Write a 6502 assembly program to calculate average of two values (from different memory locations) and store result in a third memory location.
+
+> [!NOTE]
+> This example uses the [ACME](https://sourceforge.net/projects/acme-crossass/) cross assembler syntax (builds exists for Windows and macOS, for Linux it requires to download source code and build).
+> There exists other 6502 cross [assemblers](http://www.6502.org/tools/asm/) that can be used (but which may have different syntax requirements).
+
+Use a text editor (or IDE) to create a text file with the contents below and save it to `calc_avg.asm`.
+> [!TIP]
+> `VSCode` has an extension called [`VS64`](https://marketplace.visualstudio.com/items?itemName=rosc.vs64) that provides nice syntax highlighting for 6502 assembly code (.asm).
+
+```
+;Calculates the average of two values stored in memory locations, and store the result in another memory location.
+;Code written in 6502 assembler using ACME cross assembler syntax.
+
+;code start address
+* = $c000
+
+;!to "./calc_avg.prg"
+ lda $d000
+ clc
+ adc $d001
+ ror
+ sta $d002
+;In emulator, setup hitting brk instruction to stop
+ brk
+```
+
+### Step 2 - Assemble program to binary .prg file.
+Example assumes ACME is installed, and acme executable is in path.
+
+PowerShell/Bash
+```shell
+acme -f cbm -o calc_avg.prg calc_avg.asm
+
+# or examples if acme is not in path:
+# & "$($env:USERPROFILE)\c64\acme\acme.exe" -f cbm -o calc_avg.prg calc_avg.asm
+# ~/c64/acme/acme -f cbm -o calc_avg.prg calc_avg.asm
+```
+
+### Step 3 (optional) - Inspect binary .prg file
+
+> [!NOTE]
+> If the binary was assembled with the `-f cbm` parameter (as in the example above), the two first bytes in the .prg file would be the load address specified in the source .asm file (`* = $c000`), in _little endian_ order `00`,`C0`. This is usually the convention for Commodore computers, and convenient in other contexts also.
+> If the binary was assembled with the `-f plain` parameter, the binary file would not have the first two address bytes, and only contain the code (and data) declared in the source file.
+
+`PowerShell` (Windows, Linux, macOS)
+```powershell
+(Format-Hex ./calc_avg.prg).HexBytes
+```
+```
+00 C0 AD 00 D0 18 6D 01 D0 6A 8D 02 D0 00
+```
+
+`Bash` (Linux) and `Zsh` (macOS)
+```bash
+hexdump -ve '1/1 "%.2x "' ./calc_avg.prg
+```
+```
+00 c0 ad 00 d0 18 6d 01 d0 6a 8d 02 d0 00
+```
+
+### Step 4 - Load compiled 6502 binary and execute it.
+
+DotNet C# console program that runs the 6502 program.
+
+`Program.cs`
```c#
- var mem = BinaryLoader.Load(
- "C:\Binaries\MyCompiled6502Program.prg",
- out ushort loadedAtAddress);
-
- var computerBuilder = new ComputerBuilder();
- computerBuilder
- .WithCPU()
- .WithStartAddress(loadedAtAddress)
- .WithMemory(mem);
-
- var computer = computerBuilder.Build();
- computer.Run();
-```
+// ----------------------------------------------------------------------------------------------------
+// A minimal example of how to load and run a 6502 machine code program.
+// This does not involve a complete computer (such as Commodore 64) but only the CPU and memory.
+// ----------------------------------------------------------------------------------------------------
+
+using Highbyte.DotNet6502;
+using Highbyte.DotNet6502.Utils;
-Example #2. 6502 machine code for adding to numbers and dividing by 2
+string programFile = "calc_avg.prg";
+
+// Create memory (default 64KB) and load the machine code program into it. Assume two first bytes in the .prg file is the load address.
+var mem = BinaryLoader.Load(programFile, out ushort loadAddress);
+
+// Init variables in memory locations used by the program.
+mem[0xd000] = 64;
+mem[0xd001] = 20;
+Console.WriteLine($"Input 1 (0xd000) = {mem[0xd000]}");
+Console.WriteLine($"Input 2 (0xd001) = {mem[0xd001]}");
+
+// Create the CPU and set program counter (start address).
+var cpu = new CPU();
+cpu.PC = loadAddress;
+
+// Run program. The 6502 program will run until a BRK instruction is encountered.
+cpu.Execute(mem, LegacyExecEvaluator.UntilBRKExecEvaluator);
+
+// Inspect result of program which is stored in memory location 0xd002.
+Console.WriteLine($"Output (0xd002) = {mem[0xd002]}");
+
+```
+
+Result
+```
+Input 1 (0xd000) = 64
+Input 2 (0xd001) = 20
+Output (0xd002) = 42
+```
+
+
+## Example #2. Enter 6502 machine code directly and show processor status
+
+`Program.cs`
```c#
- // Test program
- // - adds values from two memory location
- // - divides it by 2 (rotate right one bit position)
- // - stores it in another memory location
-
- // Load input data into memory
- byte value1 = 12;
- byte value2 = 30;
- ushort value1Address = 0xd000;
- ushort value2Address = 0xd001;
- ushort resultAddress = 0xd002;
- var mem = new Memory();
- mem[value1Address] = value1;
- mem[value2Address] = value2;
-
- // Load machine code into memory
- ushort codeAddress = 0xc000;
- ushort codeInsAddress = codeAddress;
- mem[codeInsAddress++] = 0xad; // LDA (Load Accumulator)
- mem[codeInsAddress++] = 0x00; // |-Lowbyte of $d000
- mem[codeInsAddress++] = 0xd0; // |-Highbyte of $d000
- mem[codeInsAddress++] = 0x18; // CLC (Clear Carry flag)
- mem[codeInsAddress++] = 0x6d; // ADC (Add with Carry, adds memory to accumulator)
- mem[codeInsAddress++] = 0x01; // |-Lowbyte of $d001
- mem[codeInsAddress++] = 0xd0; // |-Highbyte of $d001
- mem[codeInsAddress++] = 0x6a; // ROR (Rotate Right, rotates accumulator right one bit position)
- mem[codeInsAddress++] = 0x8d; // STA (Store Accumulator, store to accumulator to memory)
- mem[codeInsAddress++] = 0x02; // |-Lowbyte of $d002
- mem[codeInsAddress++] = 0xd0; // |-Highbyte of $d002
- mem[codeInsAddress++] = 0x00; // BRK (Break/Force Interrupt) - emulator configured to stop execution when reaching this instruction
-
- // Initialize emulator with CPU, memory, and execution parameters
- var computerBuilder = new ComputerBuilder();
- computerBuilder
- .WithCPU()
- .WithStartAddress(codeAddress)
- .WithMemory(mem)
- .WithInstructionExecutedEventHandler(
- (s, e) => Console.WriteLine(OutputGen.GetLastInstructionDisassembly(e.CPU, e.Mem)))
- .WithExecOptions(options =>
- {
- options.ExecuteUntilInstruction = OpCodeId.BRK; // Emulator will stop executing when a BRK instruction is reached.
- });
- var computer = computerBuilder.Build();
-
- // Run program
- computer.Run();
- Console.WriteLine($"Execution stopped");
- Console.WriteLine($"CPU state: {OutputGen.GetProcessorState(computer.CPU)}");
- Console.WriteLine($"Stats: {computer.CPU.ExecState.InstructionsExecutionCount} instruction(s) processed, and used {computer.CPU.ExecState.CyclesConsumed} cycles.");
-
- // Print result
- byte result = mem[resultAddress];
- Console.WriteLine($"Result: ({value1} + {value2}) / 2 = {result}");
+// ----------------------------------------------------------------------------------------------------
+// An example of how to enter a machine code program directly into memory,
+// and instanciating the "Generic" computer with logging of executed instructions.
+// ----------------------------------------------------------------------------------------------------
+
+using Highbyte.DotNet6502;
+using Highbyte.DotNet6502.Systems.Generic;
+using Highbyte.DotNet6502.Utils;
+
+// Test program to calculate average of two values
+// - adds values from two memory location
+// - divides it by 2 (rotate right one bit position)
+// - stores it in another memory location
+
+// Load input data into memory
+byte value1 = 64;
+byte value2 = 20;
+ushort value1Address = 0xd000;
+ushort value2Address = 0xd001;
+ushort resultAddress = 0xd002;
+var mem = new Memory();
+mem[value1Address] = value1;
+mem[value2Address] = value2;
+
+// Load machine code into memory
+ushort codeAddress = 0xc000;
+ushort codeInsAddress = codeAddress;
+mem[codeInsAddress++] = 0xad; // LDA (Load Accumulator)
+mem[codeInsAddress++] = 0x00; // |-Lowbyte of $d000
+mem[codeInsAddress++] = 0xd0; // |-Highbyte of $d000
+mem[codeInsAddress++] = 0x18; // CLC (Clear Carry flag)
+mem[codeInsAddress++] = 0x6d; // ADC (Add with Carry, adds memory to accumulator)
+mem[codeInsAddress++] = 0x01; // |-Lowbyte of $d001
+mem[codeInsAddress++] = 0xd0; // |-Highbyte of $d001
+mem[codeInsAddress++] = 0x6a; // ROR (Rotate Right, rotates accumulator right one bit position)
+mem[codeInsAddress++] = 0x8d; // STA (Store Accumulator, store to accumulator to memory)
+mem[codeInsAddress++] = 0x02; // |-Lowbyte of $d002
+mem[codeInsAddress++] = 0xd0; // |-Highbyte of $d002
+mem[codeInsAddress++] = 0x00; // BRK (Break/Force Interrupt) - emulator configured to stop execution when reaching this instruction
+
+// Initialize a "Generic" 6502 computer emulator with CPU, memory, and execution parameters
+var computerBuilder = new GenericComputerBuilder();
+computerBuilder
+ .WithCPU()
+ .WithStartAddress(codeAddress)
+ .WithMemory(mem)
+ .WithInstructionExecutedEventHandler(
+ (s, e) => Console.WriteLine(OutputGen.GetLastInstructionDisassembly(e.CPU, e.Mem)))
+ .WithExecOptions(options =>
+ {
+ options.ExecuteUntilInstruction = OpCodeId.BRK; // Emulator will stop executing when a BRK instruction is reached.
+ });
+var computer = computerBuilder.Build();
+
+// Run program
+computer.Run();
+Console.WriteLine($"Execution stopped");
+Console.WriteLine($"CPU state: {OutputGen.GetProcessorState(computer.CPU)}");
+Console.WriteLine($"Stats: {computer.CPU.ExecState.InstructionsExecutionCount} instruction(s) processed, and used {computer.CPU.ExecState.CyclesConsumed} cycles.");
+
+// Print result
+byte result = mem[resultAddress];
+Console.WriteLine($"Result: ({value1} + {value2}) / 2 = {result}");
```
-generates this output
-``` console
+Result
+```
C000 AD 00 D0 LDA $D000
C003 18 CLC
C004 6D 01 D0 ADC $D001
@@ -109,11 +213,22 @@ C00B 00 BRK
Execution stopped
CPU state: A=15 X=00 Y=00 PS=[-----I--] SP=FD PC=0000
Stats: 6 instruction(s) processed, and used 23 cycles.
-Result: (12 + 30) / 2 = 21
+Result: (64 + 20) / 2 = 41
```
## Model for bank switching
-The 6502 CPU supports max 64KB of total memory (16 bit address space). To enable more memory to be used, a type of "bank switching" is supported in the memory implementation. X number of memory configurations can be created, and each populated with byte[] arrays for separate locations within the 64KB space. Switching between the different memory layouts is as easy as calling ```memory.SetMemoryConfiguration(x)```.
+The 6502 CPU supports max 64KB of total memory (16 bit address space). To enable more memory to be used, a type of "bank switching" is supported in the memory implementation. X number of memory configurations can be created, and each populated with byte[] arrays for separate locations within the 64KB space.
+
+The `Memory` constructor parameter `numberOfConfigurations` (default 1) specifies how many memory configuration to support:
+
+```c#
+var mem = new Memory(numberOfConfigurations: 4);
+```
+Switch between the different memory configurations by calling `SetMemoryConfiguration`:
+
+```c#
+mem.SetMemoryConfiguration(2)
+```
TODO: more details
diff --git a/doc/DEVELOP.md b/doc/DEVELOP.md
index acbb5798..33400d23 100644
--- a/doc/DEVELOP.md
+++ b/doc/DEVELOP.md
@@ -1,4 +1,4 @@
-- A generic 6502 CPU computer, with custom defined memory layout. -
-- Currently configured in the application config and code. - A future update could make it possible to configure such things as - total memory, screen memory addres and IO memory addresses in - the UI. + A generic 6502-based computer, with custom defined memory layout and IO functionallity.
+ The DotNet 6502 emulator!
+ A 6502 CPU emulator written in .NET, rendered with SkiaSharp, compiled to WebAssembly via Blazor, running in a browser. diff --git a/src/apps/Highbyte.DotNet6502.App.WASM/wwwroot/6502binaries/Generic/Assembler/hostinteraction_scroll_text_and_cycle_colors.prg b/src/apps/Highbyte.DotNet6502.App.WASM/wwwroot/6502binaries/Generic/Assembler/hostinteraction_scroll_text_and_cycle_colors.prg index 42ced4fd..f8933b3a 100644 Binary files a/src/apps/Highbyte.DotNet6502.App.WASM/wwwroot/6502binaries/Generic/Assembler/hostinteraction_scroll_text_and_cycle_colors.prg and b/src/apps/Highbyte.DotNet6502.App.WASM/wwwroot/6502binaries/Generic/Assembler/hostinteraction_scroll_text_and_cycle_colors.prg differ diff --git a/src/apps/Highbyte.DotNet6502.App.WASM/wwwroot/favicon.ico b/src/apps/Highbyte.DotNet6502.App.WASM/wwwroot/favicon.ico index 63e859b4..f804586d 100644 Binary files a/src/apps/Highbyte.DotNet6502.App.WASM/wwwroot/favicon.ico and b/src/apps/Highbyte.DotNet6502.App.WASM/wwwroot/favicon.ico differ diff --git a/src/apps/Highbyte.DotNet6502.App.WASM/wwwroot/images/logo.png b/src/apps/Highbyte.DotNet6502.App.WASM/wwwroot/images/logo.png new file mode 100644 index 00000000..daad1737 Binary files /dev/null and b/src/apps/Highbyte.DotNet6502.App.WASM/wwwroot/images/logo.png differ diff --git a/src/apps/Highbyte.DotNet6502.App.WASM/wwwroot/index.html b/src/apps/Highbyte.DotNet6502.App.WASM/wwwroot/index.html index dcaf65a9..e437fea8 100644 --- a/src/apps/Highbyte.DotNet6502.App.WASM/wwwroot/index.html +++ b/src/apps/Highbyte.DotNet6502.App.WASM/wwwroot/index.html @@ -10,6 +10,7 @@ +
diff --git a/src/libraries/Highbyte.DotNet6502.Impl.SadConsole/Commodore64/Video/C64SadConsoleRenderer.cs b/src/libraries/Highbyte.DotNet6502.Impl.SadConsole/Commodore64/Video/C64SadConsoleRenderer.cs index bb55cf0c..cd73726e 100644 --- a/src/libraries/Highbyte.DotNet6502.Impl.SadConsole/Commodore64/Video/C64SadConsoleRenderer.cs +++ b/src/libraries/Highbyte.DotNet6502.Impl.SadConsole/Commodore64/Video/C64SadConsoleRenderer.cs @@ -1,3 +1,4 @@ +using System.Diagnostics; using Highbyte.DotNet6502.Systems; using Highbyte.DotNet6502.Systems.Commodore64; using Highbyte.DotNet6502.Systems.Commodore64.Video; @@ -124,35 +125,97 @@ public void DrawEmulatorCharacterOnScreen(int x, int y, byte emulatorCharacter, } byte sadConsoleCharacter; - // Default to C64 screen codes as source - sadConsoleCharacter = TranslateC64ScreenCodeToSadConsoleC64Font(emulatorCharacter); + sadConsoleCharacter = TranslateC64ScreenCodeToSadConsoleC64ROMFontIndex(emulatorCharacter, out bool inverted); + + Color fgColorTemp = _c64SadConsoleColors.GetSadConsoleColor(ColorMaps.GetSystemColor(emulatorFgColor, c64.ColorMapName)); + Color bgColorTemp = _c64SadConsoleColors.GetSadConsoleColor(ColorMaps.GetSystemColor(emulatorBgColor, c64.ColorMapName)); + + Color fgColor; + Color bgColor; + if (inverted) + { + fgColor = bgColorTemp; + bgColor = fgColorTemp; + } + else + { + fgColor = fgColorTemp; + bgColor = bgColorTemp; + }; DrawCharacter( x, y, sadConsoleCharacter, - _c64SadConsoleColors.GetSadConsoleColor(ColorMaps.GetSystemColor(emulatorFgColor, c64.ColorMapName)), - _c64SadConsoleColors.GetSadConsoleColor(ColorMaps.GetSystemColor(emulatorBgColor, c64.ColorMapName)) - ); + fgColor, + bgColor); } - private byte TranslateC64ScreenCodeToSadConsoleC64Font(byte sourceByte) + private byte TranslateC64ScreenCodeToSadConsoleC64ROMFontIndex(byte sourceByte, out bool inverted) { - switch (sourceByte & 0xff) + // The custom SadConsole font C64_ROM.font: + // - is a combination of the two built-in C64 ROM fonts, the non-inverted parts of "shifted" and "unshifted" ROM fonts. + // - the first 128 characters from the shifted font (non-inverted) are index 0-127. + // - the first 128 characters from the unshufter font (non-inverted) are index 1-255. + // - Other changes: + // - A sad console font must have index 0 as empty (only transparent background). As the C64 font has a @ sign in this position, it has been removed. + // - A sad console font must have one index as a solid block (only forground). As the C64 non-inverted parts of the C64 ROM fons does not contain a solid block, a duplicate of an empty block (160) has been changed to contain a solid block, one of the duplicate empty characters has been replace with a solid block. + // - These differences, as well as detecting inverted characters (and swapping foreground/background color when drawing) are mapped via code. + + + // ---------- + // Mapping general C64 font -> SadConsole C64_ROM.font font translation + // ---------- + byte sadConsoleGlyphIndex; + bool isUnshiftedC64CharRom = _c64.Vic2.CharsetManager.CharacterSetAddressInVIC2BankIsChargenROMUnshifted; + if (isUnshiftedC64CharRom) { - case 0xa0: //160, C64 inverted space - return 219; // Inverted square in SadConsole C64 font - case 0xe0: //224, Also C64 inverted space? - return 219; // Inverted square in SadConsole C64 font - default: - - // Convert C64 screen code to PETSCII - var sadConsoleCharacter = Petscii.C64ScreenCodeToPetscII(sourceByte); - // TODO: Also convert to ASCII? Would depend on the font being used? - //sadConsoleCharacter = CharacterMaps.PETSCIICodeToASCII(sadConsoleCharacter); - - return sadConsoleCharacter; + if (sourceByte < 128) + sadConsoleGlyphIndex = (byte)(sourceByte + 128); + else + sadConsoleGlyphIndex = sourceByte; } + else + { + if (sourceByte >= 128) + sadConsoleGlyphIndex = (byte)(sourceByte - 128); + else + sadConsoleGlyphIndex = sourceByte; + } + + // ---------- + // Mapping exceptions between C64 font -> SadConsole C64_ROM.font font + // ---------- + // The first glyph in a SadConsole font must be empty (where the C64 ROM font has a @ sign). + // The @ sign has been removed from the C64 ROM font. The @ sign has a duplicate in position 128. + if (sourceByte == 0) + { + sadConsoleGlyphIndex = 128; + inverted = false; + } + // One glyph in SadConsole font must contain a solid block. As the combined font from C64 shifted and unshifted (with both inverted removed), + // a duplicate of an empty block (160) has been changed to contain a solid block. + // To avoid Space (32) when using an unshifted C64 Char ROM (that would add 128 to the index of the combined SadConsole font) to + // be the solid block (see below), always use Space (32). + else if (sourceByte == 32) + { + sadConsoleGlyphIndex = 32; + inverted = false; + } + // One glyph in SadConsole font must contain a solid block. As the combined font from C64 shifted and unshifted (with both inverted removed), + // a duplicate of an empty block (160) has been changed to contain a solid block. + // In the original C64 font (both shifted and unshifted) this postion was a solid block. So use it, and tell not to invert it. + else if (sourceByte == 160) + { + sadConsoleGlyphIndex = 160; + inverted = false; + } + else + { + inverted = sourceByte >= 128; + } + + return sadConsoleGlyphIndex; } private int GetBorderCols(C64 c64) diff --git a/src/libraries/Highbyte.DotNet6502.Impl.Skia/Commodore64/Video/v1/C64SkiaRenderer.cs b/src/libraries/Highbyte.DotNet6502.Impl.Skia/Commodore64/Video/v1/C64SkiaRenderer.cs index 9599a702..2f05f652 100644 --- a/src/libraries/Highbyte.DotNet6502.Impl.Skia/Commodore64/Video/v1/C64SkiaRenderer.cs +++ b/src/libraries/Highbyte.DotNet6502.Impl.Skia/Commodore64/Video/v1/C64SkiaRenderer.cs @@ -516,7 +516,9 @@ private void RenderSprites(C64 c64, SKCanvas canvas, bool spritesWithPriorityOve var imageDest = new SKRect(spriteCanvasX, spriteCanvasY, spriteCanvasX + spriteWidth, spriteCanvasY + spriteHeight); if (sprite.Multicolor) + { canvas.DrawImage(spriteImage, imageDest); + } else { var paint = _c64SkiaPaint.GetDrawSpritePaint(sprite.Color); diff --git a/src/libraries/Highbyte.DotNet6502.Impl.Skia/Commodore64/Video/v1/Chargen.cs b/src/libraries/Highbyte.DotNet6502.Impl.Skia/Commodore64/Video/v1/Chargen.cs index d8352327..1550d58e 100644 --- a/src/libraries/Highbyte.DotNet6502.Impl.Skia/Commodore64/Video/v1/Chargen.cs +++ b/src/libraries/Highbyte.DotNet6502.Impl.Skia/Commodore64/Video/v1/Chargen.cs @@ -6,10 +6,9 @@ public class CharGen { // About the CharacterImageDraw* variables: // - They are replaced with a transformation when drawn on screen based on the text mode, and it's configured C64 colors. - // - It doesn't matter which color they are set to, just that they are different, and not a valid C64 color. - public static SKColor CharacterImageDrawColor = SKColors.DarkKhaki; - public static SKColor CharacterImageDrawMultiColorBG1 = SKColors.DarkOrchid; - public static SKColor CharacterImageDrawMultiColorBG2 = SKColors.DarkGoldenrod; + public static SKColor CharacterImageDrawColor = SKColors.White; + public static SKColor CharacterImageDrawMultiColorBG1 = SKColors.DarkOrchid; // This color must not be in C64 color pallette. + public static SKColor CharacterImageDrawMultiColorBG2 = SKColors.DarkGoldenrod; // This color must not be a C64 color pallette. private static readonly SKPaint s_paint; private static readonly SKPaint s_paintMultiColorBG1; diff --git a/src/libraries/Highbyte.DotNet6502.Systems.Commodore64/Config/C64Config.cs b/src/libraries/Highbyte.DotNet6502.Systems.Commodore64/Config/C64Config.cs index 7fe4f040..46dbfbc1 100644 --- a/src/libraries/Highbyte.DotNet6502.Systems.Commodore64/Config/C64Config.cs +++ b/src/libraries/Highbyte.DotNet6502.Systems.Commodore64/Config/C64Config.cs @@ -15,15 +15,47 @@ public void ClearDirty() _isDirty = false; } + // ROM version info from: https://www.commodore.ca/manuals/funet/cbm/firmware/computers/c64/ + // Checksums calculated with SHA1 + public const string KERNAL_ROM_NAME = "kernal"; + public static Dictionary