366 lines
13 KiB
C#
366 lines
13 KiB
C#
using System.Diagnostics;
|
|
using System.Drawing.Imaging;
|
|
using System.Reflection;
|
|
using System.Reflection.PortableExecutable;
|
|
using System.Runtime.InteropServices;
|
|
using System.Threading.Tasks;
|
|
using System.Windows.Forms;
|
|
using Core;
|
|
using Desktop.Audio;
|
|
|
|
namespace Desktop
|
|
{
|
|
public partial class ParsonsForm1 : Form
|
|
{
|
|
public SmsMachine _machine = null!;
|
|
private DebuggerForm _debugger;
|
|
private VramViewerForm _vramViewer;
|
|
private Bitmap _screenBitmap = new Bitmap(256, 192, PixelFormat.Format32bppArgb);
|
|
private NAudioPlayer _audioPlayer;
|
|
private Task _emulatorTask;
|
|
private double TargetFrameTime = 16.667f;
|
|
public int TotalFrameCount = 0;
|
|
public double FrameTime { get; private set; } = 0;
|
|
public double FramesPerSecond { get; private set; } = 0;
|
|
private string _currentRomName = "No ROM";
|
|
private string _currentRomPath = "";
|
|
private Stopwatch _stopwatch = new System.Diagnostics.Stopwatch();
|
|
public bool IsRunning { get; private set; } = false;
|
|
|
|
public ushort? Breakpoint
|
|
{
|
|
get => _machine?.Breakpoint;
|
|
set { if (_machine != null) _machine.Breakpoint = value; }
|
|
}
|
|
|
|
public ParsonsForm1()
|
|
{
|
|
InitializeComponent();
|
|
this.Text = $"Parsons Master System 2026 - {_currentRomName}";
|
|
_machine = new SmsMachine();
|
|
_audioPlayer = new NAudioPlayer();
|
|
_machine.AudioProcessor.AudioDevice = _audioPlayer;
|
|
|
|
PopulateIncludedRomsMenu();
|
|
|
|
this.KeyPreview = true;
|
|
this.KeyDown += Form1_KeyDown;
|
|
this.KeyUp += Form1_KeyUp;
|
|
this.DoubleBuffered = true;
|
|
this.ResizeRedraw = true;
|
|
}
|
|
|
|
private void DrawScreen()
|
|
{
|
|
// Rapidly copy our VDP FrameBuffer into the Windows Bitmap
|
|
var data = _screenBitmap.LockBits(new Rectangle(0, 0, 256, 192), ImageLockMode.WriteOnly, PixelFormat.Format32bppArgb);
|
|
Marshal.Copy(_machine.VideoProcessor.FrameBuffer, 0, data.Scan0, _machine.VideoProcessor.FrameBuffer.Length);
|
|
_screenBitmap.UnlockBits(data);
|
|
this.Invalidate();
|
|
TotalFrameCount++;
|
|
}
|
|
protected override void OnPaint(PaintEventArgs e)
|
|
{
|
|
// Always call the base method so Windows can draw your MenuStrip!
|
|
base.OnPaint(e);
|
|
|
|
if (_screenBitmap != null)
|
|
{
|
|
// 1. Set the rendering mode for perfect, chunky retro pixels!
|
|
e.Graphics.InterpolationMode = System.Drawing.Drawing2D.InterpolationMode.NearestNeighbor;
|
|
e.Graphics.PixelOffsetMode = System.Drawing.Drawing2D.PixelOffsetMode.Half;
|
|
|
|
// 2. Calculate the drawing area.
|
|
// We start drawing BELOW the MenuStrip so it doesn't get covered up.
|
|
int topOffset = menuStrip1.Height; // Change 'menuStrip1' if your menu has a different (Name)
|
|
Rectangle renderArea = new Rectangle(
|
|
0,
|
|
topOffset,
|
|
this.ClientSize.Width,
|
|
this.ClientSize.Height - topOffset
|
|
);
|
|
|
|
// 3. Blast the bitmap directly onto the graphics card buffer!
|
|
e.Graphics.DrawImage(_screenBitmap, renderArea);
|
|
}
|
|
}
|
|
|
|
public void StartEmulator()
|
|
{
|
|
if (IsRunning) return;
|
|
IsRunning = true;
|
|
TotalFrameCount = 0;
|
|
|
|
double TargetFrameTime = 1000.0 / 59.92274;
|
|
|
|
_emulatorTask = Task.Run(() =>
|
|
{
|
|
_stopwatch.Restart();
|
|
|
|
double nextFrameTargetTime = _stopwatch.Elapsed.TotalMilliseconds + TargetFrameTime;
|
|
double lastFpsUpdate = _stopwatch.Elapsed.TotalMilliseconds;
|
|
int framesThisSecond = 0;
|
|
|
|
while (IsRunning)
|
|
{
|
|
// Mark exactly when the emulator starts thinking
|
|
double frameStartTime = _stopwatch.Elapsed.TotalMilliseconds;
|
|
|
|
// --- POLL PHYSICAL CONTROLLER ---
|
|
if (XInput.XInputGetState(0, out XInput.XINPUT_STATE state) == 0)
|
|
{
|
|
ushort btns = state.Gamepad.wButtons;
|
|
byte padState = 0xFF;
|
|
|
|
if ((btns & 0x0001) != 0) padState &= 0xFE; // Up
|
|
if ((btns & 0x0002) != 0) padState &= 0xFD; // Down
|
|
if ((btns & 0x0004) != 0) padState &= 0xFB; // Left
|
|
if ((btns & 0x0008) != 0) padState &= 0xF7; // Right
|
|
if ((btns & 0x1000) != 0) padState &= 0xEF; // Button 1
|
|
if ((btns & 0x2000) != 0) padState &= 0xDF; // Button 2
|
|
|
|
// THE FIX: Constantly update the gamepad state, even when it's 0xFF!
|
|
_machine.IoBus.Joypad1Gamepad = padState;
|
|
}
|
|
// --------------------------------
|
|
_machine.RunFrame();
|
|
|
|
// 2. FIRE AND FORGET! Tell Windows to draw, but DO NOT WAIT for it to finish!
|
|
BeginInvoke((System.Windows.Forms.MethodInvoker)delegate { DrawScreen(); });
|
|
|
|
// 3. Safety catch
|
|
if (_machine.Breakpoint.HasValue && _machine.Cpu.PC == _machine.Breakpoint.Value)
|
|
{
|
|
IsRunning = false;
|
|
BeginInvoke((System.Windows.Forms.MethodInvoker)delegate { _debugger?.uiUpdateTimer_Tick(null, EventArgs.Empty); });
|
|
break;
|
|
}
|
|
|
|
// 4. Calculate TRUE Frame Time (Compute Time) BEFORE we go to sleep!
|
|
FrameTime = _stopwatch.Elapsed.TotalMilliseconds - frameStartTime;
|
|
|
|
// --- HIGH PRECISION THROTTLE ---
|
|
while (_stopwatch.Elapsed.TotalMilliseconds < nextFrameTargetTime)
|
|
{
|
|
if (nextFrameTargetTime - _stopwatch.Elapsed.TotalMilliseconds > 2.0)
|
|
{
|
|
Thread.Sleep(1);
|
|
}
|
|
else
|
|
{
|
|
Thread.SpinWait(10);
|
|
}
|
|
}
|
|
|
|
// --- METRICS MATH ---
|
|
double currentTime = _stopwatch.Elapsed.TotalMilliseconds;
|
|
TotalFrameCount++;
|
|
framesThisSecond++;
|
|
|
|
if (currentTime - lastFpsUpdate >= 1000.0)
|
|
{
|
|
FramesPerSecond = framesThisSecond / ((currentTime - lastFpsUpdate) / 1000.0);
|
|
framesThisSecond = 0;
|
|
lastFpsUpdate = currentTime;
|
|
|
|
BeginInvoke((System.Windows.Forms.MethodInvoker)delegate
|
|
{
|
|
this.Text = $"Parsons Master System - {_currentRomName} [FPS/FT: {FramesPerSecond:F0}/{FrameTime:F1}]";
|
|
});
|
|
}
|
|
|
|
nextFrameTargetTime += TargetFrameTime;
|
|
|
|
if (currentTime > nextFrameTargetTime + TargetFrameTime)
|
|
{
|
|
nextFrameTargetTime = currentTime + TargetFrameTime;
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
public void StopEmulator()
|
|
{
|
|
IsRunning = false;
|
|
}
|
|
private async void LoadRomAndStart(string filePath)
|
|
{
|
|
StopEmulator();
|
|
if (_emulatorTask != null)
|
|
{
|
|
await _emulatorTask;
|
|
}
|
|
|
|
// 1. SAVE THE PREVIOUS GAME!
|
|
SaveCurrentSram();
|
|
|
|
// 2. Load the file
|
|
byte[] rom = File.ReadAllBytes(filePath);
|
|
|
|
// 3. Jam it into the Sega Mapper
|
|
_machine.LoadCartridge(rom);
|
|
|
|
// 4. Update the path tracking
|
|
_currentRomPath = filePath;
|
|
_currentRomName = Path.GetFileNameWithoutExtension(filePath);
|
|
this.Text = $"Parsons Master System - {_currentRomName}";
|
|
|
|
// 5. LOAD THE NEW SAVE DATA!
|
|
string savPath = Path.ChangeExtension(_currentRomPath, ".sav");
|
|
_machine.MemoryBus.LoadSaveData(savPath);
|
|
|
|
// 6. Turn the power on!
|
|
StartEmulator();
|
|
}
|
|
|
|
//private async void LoadRomAndStart(string filePath)
|
|
//{
|
|
// StopEmulator();
|
|
// if (_emulatorTask != null)
|
|
// {
|
|
// await _emulatorTask;
|
|
// }
|
|
|
|
// // 2. Load the file
|
|
// byte[] rom = File.ReadAllBytes(filePath);
|
|
|
|
// // 3. Jam it into the Sega Mapper
|
|
// _machine.LoadCartridge(rom);
|
|
|
|
// _currentRomName = Path.GetFileNameWithoutExtension(filePath);
|
|
// this.Text = $"Parsons Master System - {_currentRomName}";
|
|
|
|
// // 5. Turn the power on!
|
|
|
|
// StartEmulator();
|
|
//}
|
|
private void SaveCurrentSram()
|
|
{
|
|
if (!string.IsNullOrEmpty(_currentRomPath) && _machine != null)
|
|
{
|
|
// Swaps ".sms" for ".sav"
|
|
string savPath = Path.ChangeExtension(_currentRomPath, ".sav");
|
|
_machine.MemoryBus.SaveSaveData(savPath);
|
|
}
|
|
}
|
|
|
|
private void PopulateIncludedRomsMenu()
|
|
{
|
|
// The folder you used for Golden Axe Warrior
|
|
string romsDirectory = @"C:\Parsons\Local Code Projects\ParsonsMasterSystem2026\Desktop\ROMS\";
|
|
|
|
if (Directory.Exists(romsDirectory))
|
|
{
|
|
string[] romFiles = Directory.GetFiles(romsDirectory, "*.sms");
|
|
|
|
foreach (string file in romFiles)
|
|
{
|
|
// Create a new dropdown item for each .sms file it finds
|
|
string romName = Path.GetFileNameWithoutExtension(file);
|
|
ToolStripMenuItem romMenuItem = new ToolStripMenuItem(romName);
|
|
|
|
// When clicked, pass the file path to our helper method
|
|
romMenuItem.Click += (sender, e) => LoadRomAndStart(file);
|
|
|
|
// Add it to the "Included" submenu (make sure the name matches your designer element!)
|
|
includedToolStripMenuItem.DropDownItems.Add(romMenuItem);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void selectROMToolStripMenuItem_Click(object sender, EventArgs e)
|
|
{
|
|
using (OpenFileDialog ofd = new OpenFileDialog())
|
|
{
|
|
ofd.Title = "Select Master System ROM";
|
|
ofd.Filter = "SMS ROMs (*.sms)|*.sms|All Files (*.*)|*.*";
|
|
|
|
if (ofd.ShowDialog() == DialogResult.OK)
|
|
{
|
|
LoadRomAndStart(ofd.FileName);
|
|
_machine.Reset();
|
|
}
|
|
}
|
|
}
|
|
|
|
private void resetToolStripMenuItem_Click(object sender, EventArgs e)
|
|
{
|
|
_machine.Reset();
|
|
}
|
|
|
|
private void debuggerToolStripMenuItem_Click(object sender, EventArgs e)
|
|
{
|
|
if (_debugger == null || _debugger.IsDisposed)
|
|
{
|
|
_debugger = new DebuggerForm(_machine.Cpu, _machine.MemoryBus, this);
|
|
}
|
|
_debugger.Show();
|
|
}
|
|
|
|
private void vramViewerToolStripMenuItem_Click(object sender, EventArgs e)
|
|
{
|
|
if (_vramViewer == null || _vramViewer.IsDisposed)
|
|
{
|
|
// Pass the VDP directly to the viewer!
|
|
_vramViewer = new VramViewerForm(_machine.VideoProcessor);
|
|
}
|
|
_vramViewer.Show();
|
|
}
|
|
|
|
private void includedToolStripMenuItem_Click(object sender, EventArgs e)
|
|
{
|
|
|
|
}
|
|
|
|
private void exitToolStripMenuItem_Click(object sender, EventArgs e)
|
|
{
|
|
this.Close();
|
|
}
|
|
|
|
private void Form1_KeyDown(object sender, KeyEventArgs e)
|
|
{
|
|
UpdateJoypad(e.KeyCode, true);
|
|
}
|
|
|
|
private void Form1_KeyUp(object sender, KeyEventArgs e)
|
|
{
|
|
UpdateJoypad(e.KeyCode, false);
|
|
}
|
|
|
|
private void UpdateJoypad(Keys key, bool isPressed)
|
|
{
|
|
if (_machine == null) return;
|
|
|
|
byte bitMask = 0;
|
|
|
|
// Map your keys to the Sega hardware bits
|
|
switch (key)
|
|
{
|
|
case Keys.W: bitMask = 0x01; break; // Bit 0: Up
|
|
case Keys.S: bitMask = 0x02; break; // Bit 1: Down
|
|
case Keys.A: bitMask = 0x04; break; // Bit 2: Left
|
|
case Keys.D: bitMask = 0x08; break; // Bit 3: Right
|
|
case Keys.O: bitMask = 0x10; break; // Bit 4: Button 1 (Start/Action)
|
|
case Keys.P: bitMask = 0x20; break; // Bit 5: Button 2
|
|
default: return; // Ignore any other keys
|
|
}
|
|
|
|
if (isPressed)
|
|
{
|
|
_machine.IoBus.Joypad1Keyboard &= (byte)~bitMask; // Target Keyboard!
|
|
}
|
|
else
|
|
{
|
|
_machine.IoBus.Joypad1Keyboard |= bitMask; // Target Keyboard!
|
|
}
|
|
}
|
|
|
|
private void ParsonsForm1_FormClosing(object sender, FormClosingEventArgs e)
|
|
{
|
|
IsRunning = false;
|
|
SaveCurrentSram();
|
|
_audioPlayer?.Stop();
|
|
}
|
|
}
|
|
}
|