mirror of
https://github.com/SourMesen/Mesen2.git
synced 2025-04-02 10:21:44 -04:00
1761 lines
41 KiB
C#
1761 lines
41 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.ComponentModel;
|
|
using System.Data;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using System.Threading.Tasks;
|
|
using System.Runtime.InteropServices;
|
|
|
|
namespace Mesen.Interop
|
|
{
|
|
public interface BaseState
|
|
{
|
|
}
|
|
|
|
public enum SnesCpuStopState : byte
|
|
{
|
|
Running = 0,
|
|
Stopped = 1,
|
|
WaitingForIrq = 2
|
|
}
|
|
|
|
[Flags]
|
|
public enum SnesCpuFlags : byte
|
|
{
|
|
Carry = 0x01,
|
|
Zero = 0x02,
|
|
IrqDisable = 0x04,
|
|
Decimal = 0x08,
|
|
IndexMode8 = 0x10,
|
|
MemoryMode8 = 0x20,
|
|
Overflow = 0x40,
|
|
Negative = 0x80
|
|
}
|
|
|
|
[Flags]
|
|
public enum SpcFlags : byte
|
|
{
|
|
Carry = 0x01,
|
|
Zero = 0x02,
|
|
IrqEnable = 0x04,
|
|
HalfCarry = 0x08,
|
|
Break = 0x10,
|
|
DirectPage = 0x20,
|
|
Overflow = 0x40,
|
|
Negative = 0x80
|
|
}
|
|
|
|
public enum SnesIrqSource
|
|
{
|
|
None = 0,
|
|
Ppu = 1,
|
|
Coprocessor = 2
|
|
}
|
|
|
|
public struct SnesCpuState : BaseState
|
|
{
|
|
public UInt64 CycleCount;
|
|
|
|
public UInt16 A;
|
|
public UInt16 X;
|
|
public UInt16 Y;
|
|
|
|
public UInt16 SP;
|
|
public UInt16 D;
|
|
public UInt16 PC;
|
|
|
|
public byte K;
|
|
public byte DBR;
|
|
public SnesCpuFlags PS;
|
|
[MarshalAs(UnmanagedType.I1)] public bool EmulationMode;
|
|
|
|
[MarshalAs(UnmanagedType.I1)] public bool NmiFlag;
|
|
[MarshalAs(UnmanagedType.I1)] public bool PrevNmiFlag;
|
|
|
|
[MarshalAs(UnmanagedType.I1)] public bool IrqLock;
|
|
[MarshalAs(UnmanagedType.I1)] public bool PrevNeedNmi;
|
|
[MarshalAs(UnmanagedType.I1)] public bool NeedNmi;
|
|
|
|
public byte IrqSource;
|
|
public byte PrevIrqSource;
|
|
public SnesCpuStopState StopState;
|
|
}
|
|
|
|
public struct SnesPpuState : BaseState
|
|
{
|
|
public UInt16 Cycle;
|
|
public UInt16 Scanline;
|
|
public UInt16 HClock;
|
|
public UInt32 FrameCount;
|
|
|
|
[MarshalAs(UnmanagedType.I1)] public bool ForcedBlank;
|
|
public byte ScreenBrightness;
|
|
|
|
public Mode7Config Mode7;
|
|
|
|
public byte BgMode;
|
|
[MarshalAs(UnmanagedType.I1)] public bool Mode1Bg3Priority;
|
|
|
|
public byte MainScreenLayers;
|
|
public byte SubScreenLayers;
|
|
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)]
|
|
public LayerConfig[] Layers;
|
|
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 2)]
|
|
public WindowConfig[] Window;
|
|
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 6)]
|
|
public WindowMaskLogic[] MaskLogic;
|
|
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 5)]
|
|
public byte[] WindowMaskMain;
|
|
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 5)]
|
|
public byte[] WindowMaskSub;
|
|
|
|
public UInt16 VramAddress;
|
|
public byte VramIncrementValue;
|
|
public byte VramAddressRemapping;
|
|
[MarshalAs(UnmanagedType.I1)] public bool VramAddrIncrementOnSecondReg;
|
|
public UInt16 VramReadBuffer;
|
|
|
|
public byte Ppu1OpenBus;
|
|
public byte Ppu2OpenBus;
|
|
|
|
public byte CgramAddress;
|
|
public byte CgramWriteBuffer;
|
|
[MarshalAs(UnmanagedType.I1)] public bool CgramAddressLatch;
|
|
|
|
public byte MosaicSize;
|
|
public byte MosaicEnabled;
|
|
|
|
public UInt16 OamRamAddress;
|
|
public UInt16 InternalOamRamAddress;
|
|
|
|
public byte OamMode;
|
|
public UInt16 OamBaseAddress;
|
|
public UInt16 OamAddressOffset;
|
|
[MarshalAs(UnmanagedType.I1)] public bool EnableOamPriority;
|
|
|
|
[MarshalAs(UnmanagedType.I1)] public bool ExtBgEnabled;
|
|
[MarshalAs(UnmanagedType.I1)] public bool HiResMode;
|
|
[MarshalAs(UnmanagedType.I1)] public bool ScreenInterlace;
|
|
[MarshalAs(UnmanagedType.I1)] public bool ObjInterlace;
|
|
[MarshalAs(UnmanagedType.I1)] public bool OverscanMode;
|
|
[MarshalAs(UnmanagedType.I1)] public bool DirectColorMode;
|
|
|
|
public ColorWindowMode ColorMathClipMode;
|
|
public ColorWindowMode ColorMathPreventMode;
|
|
|
|
[MarshalAs(UnmanagedType.I1)] public bool ColorMathAddSubscreen;
|
|
public byte ColorMathEnabled;
|
|
[MarshalAs(UnmanagedType.I1)] public bool ColorMathSubtractMode;
|
|
[MarshalAs(UnmanagedType.I1)] public bool ColorMathHalveResult;
|
|
public UInt16 FixedColor;
|
|
}
|
|
|
|
public struct LayerConfig
|
|
{
|
|
public UInt16 TilemapAddress;
|
|
public UInt16 ChrAddress;
|
|
|
|
public UInt16 HScroll;
|
|
public UInt16 VScroll;
|
|
|
|
[MarshalAs(UnmanagedType.I1)] public bool DoubleWidth;
|
|
[MarshalAs(UnmanagedType.I1)] public bool DoubleHeight;
|
|
|
|
[MarshalAs(UnmanagedType.I1)] public bool LargeTiles;
|
|
}
|
|
|
|
public struct WindowConfig
|
|
{
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 6)]
|
|
public byte[] ActiveLayers;
|
|
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 6)]
|
|
public byte[] InvertedLayers;
|
|
|
|
public Byte Left;
|
|
public Byte Right;
|
|
}
|
|
|
|
public struct Mode7Config
|
|
{
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)]
|
|
public Int16[] Matrix;
|
|
|
|
public Int16 HScroll;
|
|
public Int16 VScroll;
|
|
public Int16 CenterX;
|
|
public Int16 CenterY;
|
|
|
|
public Byte ValueLatch;
|
|
|
|
[MarshalAs(UnmanagedType.I1)] public bool LargeMap;
|
|
[MarshalAs(UnmanagedType.I1)] public bool FillWithTile0;
|
|
[MarshalAs(UnmanagedType.I1)] public bool HorizontalMirroring;
|
|
[MarshalAs(UnmanagedType.I1)] public bool VerticalMirroring;
|
|
|
|
public Int16 HScrollLatch;
|
|
public Int16 VScrollLatch;
|
|
}
|
|
|
|
public enum WindowMaskLogic
|
|
{
|
|
Or = 0,
|
|
And = 1,
|
|
Xor = 2,
|
|
Xnor = 3
|
|
}
|
|
|
|
public enum ColorWindowMode
|
|
{
|
|
Never = 0,
|
|
OutsideWindow = 1,
|
|
InsideWindow = 2,
|
|
Always = 3
|
|
}
|
|
|
|
public struct SpcTimer
|
|
{
|
|
[MarshalAs(UnmanagedType.I1)] public bool Enabled;
|
|
[MarshalAs(UnmanagedType.I1)] public bool TimersEnabled;
|
|
public byte Output;
|
|
public byte Stage0;
|
|
public byte Stage1;
|
|
public byte PrevStage1;
|
|
public byte Stage2;
|
|
public byte Target;
|
|
}
|
|
|
|
public struct SpcState : BaseState
|
|
{
|
|
public UInt64 Cycle;
|
|
public UInt16 PC;
|
|
public byte A;
|
|
public byte X;
|
|
public byte Y;
|
|
public byte SP;
|
|
public SpcFlags PS;
|
|
|
|
[MarshalAs(UnmanagedType.I1)] public bool WriteEnabled;
|
|
[MarshalAs(UnmanagedType.I1)] public bool RomEnabled;
|
|
public byte InternalSpeed;
|
|
public byte ExternalSpeed;
|
|
[MarshalAs(UnmanagedType.I1)] public bool TimersEnabled;
|
|
[MarshalAs(UnmanagedType.I1)] public bool TimersDisabled;
|
|
public SnesCpuStopState StopState;
|
|
|
|
public byte DspReg;
|
|
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)]
|
|
public byte[] OutputReg;
|
|
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 2)]
|
|
public byte[] RamReg;
|
|
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)]
|
|
public byte[] CpuRegs;
|
|
|
|
public SpcTimer Timer0;
|
|
public SpcTimer Timer1;
|
|
public SpcTimer Timer2;
|
|
}
|
|
|
|
public struct DspState
|
|
{
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 128)]
|
|
public byte[] Regs;
|
|
|
|
public Int32 NoiseLfsr;
|
|
public UInt16 Counter;
|
|
public byte Step;
|
|
public byte OutRegBuffer;
|
|
public byte EnvRegBuffer;
|
|
public byte VoiceEndBuffer;
|
|
|
|
public Int32 VoiceOutput;
|
|
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 2)]
|
|
public Int32[] OutSamples;
|
|
|
|
public Int32 Pitch;
|
|
public UInt16 SampleAddress;
|
|
public UInt16 BrrNextAddress;
|
|
public byte DirSampleTableAddress;
|
|
public byte NoiseOn;
|
|
public byte PitchModulationOn;
|
|
public byte KeyOn;
|
|
public byte NewKeyOn;
|
|
public byte KeyOff;
|
|
public byte EveryOtherSample;
|
|
public byte SourceNumber;
|
|
public byte BrrHeader;
|
|
public byte BrrData;
|
|
public byte Looped;
|
|
public byte Adsr1;
|
|
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 2)]
|
|
public Int32[] EchoIn;
|
|
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 2)]
|
|
public Int32[] EchoOut;
|
|
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 8*2)]
|
|
public UInt16[] EchoHistory;
|
|
|
|
public UInt16 EchoPointer;
|
|
public UInt16 EchoLength;
|
|
public UInt16 EchoOffset;
|
|
public byte EchoHistoryPos;
|
|
public byte EchoRingBufferAddress;
|
|
public byte EchoOn;
|
|
[MarshalAs(UnmanagedType.I1)] public bool EchoEnabled;
|
|
}
|
|
|
|
public struct NecDspAccFlags
|
|
{
|
|
[MarshalAs(UnmanagedType.I1)] public bool Carry;
|
|
[MarshalAs(UnmanagedType.I1)] public bool Zero;
|
|
[MarshalAs(UnmanagedType.I1)] public bool Overflow0;
|
|
[MarshalAs(UnmanagedType.I1)] public bool Overflow1;
|
|
[MarshalAs(UnmanagedType.I1)] public bool Sign0;
|
|
[MarshalAs(UnmanagedType.I1)] public bool Sign1;
|
|
}
|
|
|
|
public struct NecDspState : BaseState
|
|
{
|
|
public UInt64 CycleCount;
|
|
public UInt16 A;
|
|
public NecDspAccFlags FlagsA;
|
|
public UInt16 B;
|
|
public NecDspAccFlags FlagsB;
|
|
public UInt16 TR;
|
|
public UInt16 TRB;
|
|
public UInt16 PC;
|
|
public UInt16 RP;
|
|
public UInt16 DP;
|
|
public UInt16 DR;
|
|
public UInt16 SR;
|
|
public UInt16 K;
|
|
public UInt16 L;
|
|
public UInt16 M;
|
|
public UInt16 N;
|
|
public UInt16 SerialOut;
|
|
public UInt16 SerialIn;
|
|
public byte SP;
|
|
}
|
|
|
|
public struct GsuFlags
|
|
{
|
|
[MarshalAs(UnmanagedType.I1)] public bool Zero;
|
|
[MarshalAs(UnmanagedType.I1)] public bool Carry;
|
|
[MarshalAs(UnmanagedType.I1)] public bool Sign;
|
|
[MarshalAs(UnmanagedType.I1)] public bool Overflow;
|
|
[MarshalAs(UnmanagedType.I1)] public bool Running;
|
|
[MarshalAs(UnmanagedType.I1)] public bool RomReadPending;
|
|
[MarshalAs(UnmanagedType.I1)] public bool Alt1;
|
|
[MarshalAs(UnmanagedType.I1)] public bool Alt2;
|
|
[MarshalAs(UnmanagedType.I1)] public bool ImmLow;
|
|
[MarshalAs(UnmanagedType.I1)] public bool ImmHigh;
|
|
[MarshalAs(UnmanagedType.I1)] public bool Prefix;
|
|
[MarshalAs(UnmanagedType.I1)] public bool Irq;
|
|
}
|
|
|
|
public struct GsuPixelCache
|
|
{
|
|
public byte X;
|
|
public byte Y;
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 8)]
|
|
public byte[] Pixels;
|
|
public byte ValidBits;
|
|
}
|
|
|
|
public struct GsuState : BaseState
|
|
{
|
|
public UInt64 CycleCount;
|
|
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 16)]
|
|
public UInt16[] R;
|
|
|
|
public GsuFlags SFR;
|
|
|
|
public byte RegisterLatch;
|
|
|
|
public byte ProgramBank;
|
|
public byte RomBank;
|
|
public byte RamBank;
|
|
|
|
[MarshalAs(UnmanagedType.I1)] public bool IrqDisabled;
|
|
[MarshalAs(UnmanagedType.I1)] public bool HighSpeedMode;
|
|
[MarshalAs(UnmanagedType.I1)] public bool ClockSelect;
|
|
[MarshalAs(UnmanagedType.I1)] public bool BackupRamEnabled;
|
|
public byte ScreenBase;
|
|
|
|
public byte ColorGradient;
|
|
public byte PlotBpp;
|
|
public byte ScreenHeight;
|
|
[MarshalAs(UnmanagedType.I1)] public bool GsuRamAccess;
|
|
[MarshalAs(UnmanagedType.I1)] public bool GsuRomAccess;
|
|
|
|
public UInt16 CacheBase;
|
|
|
|
[MarshalAs(UnmanagedType.I1)] public bool PlotTransparent;
|
|
[MarshalAs(UnmanagedType.I1)] public bool PlotDither;
|
|
[MarshalAs(UnmanagedType.I1)] public bool ColorHighNibble;
|
|
[MarshalAs(UnmanagedType.I1)] public bool ColorFreezeHigh;
|
|
[MarshalAs(UnmanagedType.I1)] public bool ObjMode;
|
|
|
|
public byte ColorReg;
|
|
public byte SrcReg;
|
|
public byte DestReg;
|
|
|
|
public byte RomReadBuffer;
|
|
public byte RomDelay;
|
|
|
|
public byte ProgramReadBuffer;
|
|
|
|
public UInt16 RamWriteAddress;
|
|
public byte RamWriteValue;
|
|
public byte RamDelay;
|
|
|
|
public UInt16 RamAddress;
|
|
|
|
public GsuPixelCache PrimaryCache;
|
|
public GsuPixelCache SecondaryCache;
|
|
}
|
|
|
|
public struct Cx4Dma
|
|
{
|
|
public UInt32 Source;
|
|
public UInt32 Dest;
|
|
public UInt16 Length;
|
|
public UInt32 Pos;
|
|
[MarshalAs(UnmanagedType.I1)] public bool Enabled;
|
|
}
|
|
|
|
public struct Cx4Suspend
|
|
{
|
|
public UInt32 Duration;
|
|
[MarshalAs(UnmanagedType.I1)] public bool Enabled;
|
|
}
|
|
|
|
public struct Cx4Cache
|
|
{
|
|
[MarshalAs(UnmanagedType.I1)] public bool Enabled;
|
|
public byte Page;
|
|
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 2)]
|
|
public byte[] Lock;
|
|
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 2)]
|
|
public UInt32[] Address;
|
|
|
|
public UInt32 Base;
|
|
public UInt16 ProgramBank;
|
|
public byte ProgramCounter;
|
|
public UInt16 Pos;
|
|
}
|
|
|
|
public struct Cx4Bus
|
|
{
|
|
[MarshalAs(UnmanagedType.I1)] public bool Enabled;
|
|
[MarshalAs(UnmanagedType.I1)] public bool Reading;
|
|
[MarshalAs(UnmanagedType.I1)] public bool Writing;
|
|
public byte DelayCycles;
|
|
public UInt32 Address;
|
|
}
|
|
|
|
public struct Cx4State : BaseState
|
|
{
|
|
public UInt64 CycleCount;
|
|
public UInt16 PB;
|
|
public byte PC;
|
|
public UInt32 A;
|
|
public UInt16 P;
|
|
|
|
public byte SP;
|
|
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 8)]
|
|
public UInt32[] Stack;
|
|
|
|
public UInt64 Mult;
|
|
|
|
public UInt32 RomBuffer;
|
|
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 3)]
|
|
public byte[] RamBuffer;
|
|
|
|
public UInt32 MemoryDataReg;
|
|
public UInt32 MemoryAddressReg;
|
|
public UInt32 DataPointerReg;
|
|
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 16)]
|
|
public UInt32[] Regs;
|
|
|
|
[MarshalAs(UnmanagedType.I1)] public bool Negative;
|
|
[MarshalAs(UnmanagedType.I1)] public bool Zero;
|
|
[MarshalAs(UnmanagedType.I1)] public bool Carry;
|
|
[MarshalAs(UnmanagedType.I1)] public bool Overflow;
|
|
[MarshalAs(UnmanagedType.I1)] public bool IrqFlag;
|
|
|
|
[MarshalAs(UnmanagedType.I1)] public bool Stopped;
|
|
[MarshalAs(UnmanagedType.I1)] public bool Locked;
|
|
[MarshalAs(UnmanagedType.I1)] public bool IrqDisabled;
|
|
|
|
[MarshalAs(UnmanagedType.I1)] public bool SingleRom;
|
|
|
|
public byte RomAccessDelay;
|
|
public byte RamAccessDelay;
|
|
|
|
public Cx4Bus Bus;
|
|
public Cx4Dma Dma;
|
|
public Cx4Cache Cache;
|
|
public Cx4Suspend Suspend;
|
|
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 0x20)]
|
|
public byte[] Vectors;
|
|
}
|
|
|
|
public struct Sa1State
|
|
{
|
|
public UInt16 Sa1ResetVector;
|
|
public UInt16 Sa1IrqVector;
|
|
public UInt16 Sa1NmiVector;
|
|
|
|
[MarshalAs(UnmanagedType.I1)] public bool Sa1IrqRequested;
|
|
[MarshalAs(UnmanagedType.I1)] public bool Sa1IrqEnabled;
|
|
|
|
[MarshalAs(UnmanagedType.I1)] public bool Sa1NmiRequested;
|
|
[MarshalAs(UnmanagedType.I1)] public bool Sa1NmiEnabled;
|
|
[MarshalAs(UnmanagedType.I1)] public bool Sa1Wait;
|
|
[MarshalAs(UnmanagedType.I1)] public bool Sa1Reset;
|
|
|
|
[MarshalAs(UnmanagedType.I1)] public bool DmaIrqEnabled;
|
|
[MarshalAs(UnmanagedType.I1)] public bool TimerIrqEnabled;
|
|
|
|
public byte Sa1MessageReceived;
|
|
public byte CpuMessageReceived;
|
|
|
|
public UInt16 CpuIrqVector;
|
|
public UInt16 CpuNmiVector;
|
|
[MarshalAs(UnmanagedType.I1)] public bool UseCpuIrqVector;
|
|
[MarshalAs(UnmanagedType.I1)] public bool UseCpuNmiVector;
|
|
|
|
[MarshalAs(UnmanagedType.I1)] public bool CpuIrqRequested;
|
|
[MarshalAs(UnmanagedType.I1)] public bool CpuIrqEnabled;
|
|
|
|
[MarshalAs(UnmanagedType.I1)] public bool CharConvIrqFlag;
|
|
[MarshalAs(UnmanagedType.I1)] public bool CharConvIrqEnabled;
|
|
[MarshalAs(UnmanagedType.I1)] public bool CharConvDmaActive;
|
|
public byte CharConvBpp;
|
|
public byte CharConvFormat;
|
|
public byte CharConvWidth;
|
|
public byte CharConvCounter;
|
|
|
|
public byte CpuBwBank;
|
|
[MarshalAs(UnmanagedType.I1)] public bool CpuBwWriteEnabled;
|
|
|
|
public byte Sa1BwBank;
|
|
public byte Sa1BwMode;
|
|
[MarshalAs(UnmanagedType.I1)] public bool Sa1BwWriteEnabled;
|
|
public byte BwWriteProtectedArea;
|
|
[MarshalAs(UnmanagedType.I1)] public bool BwRam2BppMode;
|
|
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 8)]
|
|
public byte[] BitmapRegister1;
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 8)]
|
|
public byte[] BitmapRegister2;
|
|
|
|
public byte CpuIRamWriteProtect;
|
|
public byte Sa1IRamWriteProtect;
|
|
|
|
public UInt32 DmaSrcAddr;
|
|
public UInt32 DmaDestAddr;
|
|
public UInt16 DmaSize;
|
|
[MarshalAs(UnmanagedType.I1)] public bool DmaEnabled;
|
|
[MarshalAs(UnmanagedType.I1)] public bool DmaPriority;
|
|
[MarshalAs(UnmanagedType.I1)] public bool DmaCharConv;
|
|
[MarshalAs(UnmanagedType.I1)] public bool DmaCharConvAuto;
|
|
public Sa1DmaDestDevice DmaDestDevice;
|
|
public Sa1DmaSrcDevice DmaSrcDevice;
|
|
[MarshalAs(UnmanagedType.I1)] public bool DmaRunning;
|
|
[MarshalAs(UnmanagedType.I1)] public bool DmaIrqFlag;
|
|
|
|
[MarshalAs(UnmanagedType.I1)] public bool HorizontalTimerEnabled;
|
|
[MarshalAs(UnmanagedType.I1)] public bool VerticalTimerEnabled;
|
|
[MarshalAs(UnmanagedType.I1)] public bool UseLinearTimer;
|
|
|
|
public UInt16 HTimer;
|
|
public UInt16 VTimer;
|
|
public UInt32 LinearTimerValue;
|
|
|
|
public Sa1MathOp MathOp;
|
|
public UInt16 MultiplicandDividend;
|
|
public UInt16 MultiplierDivisor;
|
|
public UInt64 MathOpResult;
|
|
public byte MathOverflow;
|
|
|
|
[MarshalAs(UnmanagedType.I1)] public bool VarLenAutoInc;
|
|
public byte VarLenBitCount;
|
|
public UInt32 VarLenAddress;
|
|
public byte VarLenCurrentBit;
|
|
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)]
|
|
public byte[] Banks;
|
|
}
|
|
|
|
public struct DebugSa1State
|
|
{
|
|
public SnesCpuState Cpu;
|
|
public Sa1State Sa1;
|
|
}
|
|
|
|
public enum Sa1MathOp
|
|
{
|
|
Mul = 0,
|
|
Div = 1,
|
|
Sum = 2
|
|
}
|
|
|
|
public enum Sa1DmaSrcDevice
|
|
{
|
|
PrgRom = 0,
|
|
BwRam = 1,
|
|
InternalRam = 2,
|
|
Reserved = 3
|
|
}
|
|
|
|
public enum Sa1DmaDestDevice
|
|
{
|
|
InternalRam = 0,
|
|
BwRam = 1
|
|
}
|
|
|
|
public struct AluState
|
|
{
|
|
public byte MultOperand1;
|
|
public byte MultOperand2;
|
|
public UInt16 MultOrRemainderResult;
|
|
|
|
public UInt16 Dividend;
|
|
public byte Divisor;
|
|
public UInt16 DivResult;
|
|
}
|
|
|
|
public struct InternalRegisterState
|
|
{
|
|
[MarshalAs(UnmanagedType.I1)] public bool EnableAutoJoypadRead;
|
|
[MarshalAs(UnmanagedType.I1)] public bool EnableFastRom;
|
|
|
|
[MarshalAs(UnmanagedType.I1)] public bool EnableNmi;
|
|
[MarshalAs(UnmanagedType.I1)] public bool EnableHorizontalIrq;
|
|
[MarshalAs(UnmanagedType.I1)] public bool EnableVerticalIrq;
|
|
public UInt16 HorizontalTimer;
|
|
public UInt16 VerticalTimer;
|
|
|
|
public byte IoPortOutput;
|
|
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)]
|
|
public UInt16[] ControllerData;
|
|
}
|
|
|
|
public enum GbMemoryType
|
|
{
|
|
None = 0,
|
|
PrgRom = (int)MemoryType.GbPrgRom,
|
|
WorkRam = (int)MemoryType.GbWorkRam,
|
|
CartRam = (int)MemoryType.GbCartRam,
|
|
BootRom = (int)MemoryType.GbBootRom,
|
|
}
|
|
|
|
public enum GbRegisterAccess
|
|
{
|
|
None = 0,
|
|
Read = 1,
|
|
Write = 2,
|
|
ReadWrite = 3
|
|
}
|
|
|
|
public struct GbMemoryManagerState
|
|
{
|
|
public UInt64 ApuCycleCount;
|
|
|
|
public byte CgbWorkRamBank;
|
|
[MarshalAs(UnmanagedType.I1)] public bool CgbSwitchSpeedRequest;
|
|
[MarshalAs(UnmanagedType.I1)] public bool CgbHighSpeed;
|
|
|
|
public byte CgbRegFF72;
|
|
public byte CgbRegFF73;
|
|
public byte CgbRegFF74;
|
|
public byte CgbRegFF75;
|
|
|
|
[MarshalAs(UnmanagedType.I1)] public bool DisableBootRom;
|
|
public byte IrqRequests;
|
|
public byte IrqEnabled;
|
|
|
|
public byte SerialData;
|
|
public byte SerialControl;
|
|
public byte SerialBitCount;
|
|
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 0x100)]
|
|
public byte[] IsReadRegister;
|
|
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 0x100)]
|
|
public byte[] IsWriteRegister;
|
|
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 0x100)]
|
|
public GbMemoryType[] MemoryType;
|
|
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 0x100)]
|
|
public UInt32[] MemoryOffset;
|
|
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 0x100)]
|
|
public GbRegisterAccess[] MemoryAccessType;
|
|
}
|
|
|
|
public struct GbControlManagerState
|
|
{
|
|
public byte InputSelect;
|
|
}
|
|
|
|
public struct GbDmaControllerState
|
|
{
|
|
public byte OamDmaSource;
|
|
public byte DmaStartDelay;
|
|
public byte InternalDest;
|
|
public byte DmaCounter;
|
|
public byte DmaReadBuffer;
|
|
|
|
public UInt16 CgbDmaSource;
|
|
public UInt16 CgbDmaDest;
|
|
public byte CgbDmaLength;
|
|
[MarshalAs(UnmanagedType.I1)] public bool CgbHdmaDone;
|
|
[MarshalAs(UnmanagedType.I1)] public bool CgbHdmaRunning;
|
|
};
|
|
|
|
public struct GbTimerState
|
|
{
|
|
public UInt16 Divider;
|
|
|
|
[MarshalAs(UnmanagedType.I1)] public bool NeedReload;
|
|
[MarshalAs(UnmanagedType.I1)] public bool Reloaded;
|
|
public byte Counter;
|
|
public byte Modulo;
|
|
|
|
public byte Control;
|
|
[MarshalAs(UnmanagedType.I1)] public bool TimerEnabled;
|
|
public UInt16 TimerDivider;
|
|
};
|
|
|
|
public enum GbType
|
|
{
|
|
Gb = 0,
|
|
Cgb = 1,
|
|
}
|
|
|
|
public struct GbState : BaseState
|
|
{
|
|
public GbType Type;
|
|
public GbCpuState Cpu;
|
|
public GbPpuState Ppu;
|
|
public GbApuDebugState Apu;
|
|
public GbMemoryManagerState MemoryManager;
|
|
public GbTimerState Timer;
|
|
public GbDmaControllerState Dma;
|
|
public GbControlManagerState ControlManager;
|
|
[MarshalAs(UnmanagedType.I1)] public bool HasBattery;
|
|
}
|
|
|
|
[Flags]
|
|
public enum GameboyFlags : byte
|
|
{
|
|
Carry = 0x10,
|
|
HalfCarry = 0x20,
|
|
AddSub = 0x40,
|
|
Zero = 0x80
|
|
}
|
|
|
|
public struct GbCpuState : BaseState
|
|
{
|
|
public UInt64 CycleCount;
|
|
public UInt16 PC;
|
|
public UInt16 SP;
|
|
|
|
public byte A;
|
|
public byte Flags;
|
|
|
|
public byte B;
|
|
public byte C;
|
|
public byte D;
|
|
public byte E;
|
|
|
|
public byte H;
|
|
public byte L;
|
|
|
|
[MarshalAs(UnmanagedType.I1)] public bool EiPending;
|
|
[MarshalAs(UnmanagedType.I1)] public bool IME;
|
|
[MarshalAs(UnmanagedType.I1)] public bool Halted;
|
|
}
|
|
|
|
public enum PpuMode
|
|
{
|
|
HBlank,
|
|
VBlank,
|
|
OamEvaluation,
|
|
Drawing,
|
|
NoIrq
|
|
}
|
|
|
|
public struct GbPpuState : BaseState
|
|
{
|
|
public byte Scanline;
|
|
public UInt16 Cycle;
|
|
public UInt16 IdleCycles;
|
|
public PpuMode Mode;
|
|
public PpuMode IrqMode;
|
|
[MarshalAs(UnmanagedType.I1)] public bool StatIrqFlag;
|
|
|
|
public byte Ly;
|
|
public Int16 LyForCompare;
|
|
|
|
public byte LyCompare;
|
|
[MarshalAs(UnmanagedType.I1)] public bool LyCoincidenceFlag;
|
|
public byte BgPalette;
|
|
public byte ObjPalette0;
|
|
public byte ObjPalette1;
|
|
public byte ScrollX;
|
|
public byte ScrollY;
|
|
public byte WindowX;
|
|
public byte WindowY;
|
|
|
|
public byte Control;
|
|
[MarshalAs(UnmanagedType.I1)] public bool LcdEnabled;
|
|
[MarshalAs(UnmanagedType.I1)] public bool WindowTilemapSelect;
|
|
[MarshalAs(UnmanagedType.I1)] public bool WindowEnabled;
|
|
[MarshalAs(UnmanagedType.I1)] public bool BgTileSelect;
|
|
[MarshalAs(UnmanagedType.I1)] public bool BgTilemapSelect;
|
|
[MarshalAs(UnmanagedType.I1)] public bool LargeSprites;
|
|
[MarshalAs(UnmanagedType.I1)] public bool SpritesEnabled;
|
|
[MarshalAs(UnmanagedType.I1)] public bool BgEnabled;
|
|
|
|
public byte Status;
|
|
public UInt32 FrameCount;
|
|
|
|
[MarshalAs(UnmanagedType.I1)] public bool CgbEnabled;
|
|
public byte CgbVramBank;
|
|
|
|
public byte CgbBgPalPosition;
|
|
[MarshalAs(UnmanagedType.I1)] public bool CgbBgPalAutoInc;
|
|
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 4*8)]
|
|
public UInt16[] CgbBgPalettes;
|
|
|
|
public byte CgbObjPalPosition;
|
|
[MarshalAs(UnmanagedType.I1)] public bool CgbObjPalAutoInc;
|
|
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 4 * 8)]
|
|
public UInt16[] CgbObjPalettes;
|
|
}
|
|
|
|
public struct GbSquareState
|
|
{
|
|
public UInt16 SweepPeriod;
|
|
[MarshalAs(UnmanagedType.I1)] public bool SweepNegate;
|
|
public byte SweepShift;
|
|
|
|
public UInt16 SweepTimer;
|
|
[MarshalAs(UnmanagedType.I1)] public bool SweepEnabled;
|
|
public UInt16 SweepFreq;
|
|
|
|
public byte Volume;
|
|
public byte EnvVolume;
|
|
[MarshalAs(UnmanagedType.I1)] public bool EnvRaiseVolume;
|
|
public byte EnvPeriod;
|
|
public byte EnvTimer;
|
|
[MarshalAs(UnmanagedType.I1)] public bool EnvStopped;
|
|
|
|
public byte Duty;
|
|
public UInt16 Frequency;
|
|
|
|
public byte Length;
|
|
[MarshalAs(UnmanagedType.I1)] public bool LengthEnabled;
|
|
|
|
[MarshalAs(UnmanagedType.I1)] public bool Enabled;
|
|
public UInt16 Timer;
|
|
public byte DutyPos;
|
|
public byte Output;
|
|
}
|
|
|
|
public struct GbNoiseState
|
|
{
|
|
public byte Volume;
|
|
public byte EnvVolume;
|
|
[MarshalAs(UnmanagedType.I1)] public bool EnvRaiseVolume;
|
|
public byte EnvPeriod;
|
|
public byte EnvTimer;
|
|
|
|
public byte Length;
|
|
[MarshalAs(UnmanagedType.I1)] public bool LengthEnabled;
|
|
|
|
public UInt16 ShiftRegister;
|
|
|
|
public byte PeriodShift;
|
|
public byte Divisor;
|
|
[MarshalAs(UnmanagedType.I1)] public bool ShortWidthMode;
|
|
|
|
[MarshalAs(UnmanagedType.I1)] public bool Enabled;
|
|
public UInt32 Timer;
|
|
public byte Output;
|
|
}
|
|
|
|
public struct GbWaveState
|
|
{
|
|
[MarshalAs(UnmanagedType.I1)] public bool DacEnabled;
|
|
|
|
public byte SampleBuffer;
|
|
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 16)]
|
|
public byte[] Ram;
|
|
|
|
public byte Position;
|
|
|
|
public byte Volume;
|
|
public UInt16 Frequency;
|
|
|
|
public UInt16 Length;
|
|
[MarshalAs(UnmanagedType.I1)] public bool LengthEnabled;
|
|
|
|
[MarshalAs(UnmanagedType.I1)] public bool Enabled;
|
|
public UInt16 Timer;
|
|
public byte Output;
|
|
}
|
|
|
|
public struct GbApuState
|
|
{
|
|
[MarshalAs(UnmanagedType.I1)] public bool ApuEnabled;
|
|
|
|
public byte EnableLeftSq1;
|
|
public byte EnableLeftSq2;
|
|
public byte EnableLeftWave;
|
|
public byte EnableLeftNoise;
|
|
|
|
public byte EnableRightSq1;
|
|
public byte EnableRightSq2;
|
|
public byte EnableRightWave;
|
|
public byte EnableRightNoise;
|
|
|
|
public byte LeftVolume;
|
|
public byte RightVolume;
|
|
|
|
[MarshalAs(UnmanagedType.I1)] public bool ExtAudioLeftEnabled;
|
|
[MarshalAs(UnmanagedType.I1)] public bool ExtAudioRightEnabled;
|
|
|
|
public byte FrameSequenceStep;
|
|
}
|
|
|
|
public struct GbApuDebugState
|
|
{
|
|
public GbApuState Common;
|
|
public GbSquareState Square1;
|
|
public GbSquareState Square2;
|
|
public GbWaveState Wave;
|
|
public GbNoiseState Noise;
|
|
}
|
|
|
|
public struct NesCpuState : BaseState
|
|
{
|
|
public UInt64 CycleCount;
|
|
public UInt16 PC;
|
|
public byte SP;
|
|
public byte A;
|
|
public byte X;
|
|
public byte Y;
|
|
public byte PS;
|
|
public byte IRQFlag;
|
|
[MarshalAs(UnmanagedType.I1)] public bool NMIFlag;
|
|
};
|
|
|
|
public struct SnesDmaControllerState
|
|
{
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 8)]
|
|
public DmaChannelConfig[] Channels;
|
|
|
|
public byte HdmaChannels;
|
|
}
|
|
|
|
public struct SnesState : BaseState
|
|
{
|
|
public UInt64 MasterClock;
|
|
public SnesCpuState Cpu;
|
|
public SnesPpuState Ppu;
|
|
public SpcState Spc;
|
|
public DspState Dsp;
|
|
public NecDspState NecDsp;
|
|
public DebugSa1State Sa1;
|
|
public GsuState Gsu;
|
|
public Cx4State Cx4;
|
|
|
|
public SnesDmaControllerState Dma;
|
|
public InternalRegisterState InternalRegs;
|
|
public AluState Alu;
|
|
}
|
|
|
|
public struct EmptyPpuToolsState : BaseState
|
|
{
|
|
}
|
|
|
|
public struct SnesPpuToolsState : BaseState
|
|
{
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 239)]
|
|
public byte[] ScanlineBgMode;
|
|
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 239)]
|
|
public Int32[] Mode7StartX;
|
|
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 239)]
|
|
public Int32[] Mode7StartY;
|
|
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 239)]
|
|
public Int32[] Mode7EndX;
|
|
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 239)]
|
|
public Int32[] Mode7EndY;
|
|
}
|
|
|
|
public struct NesPpuStatusFlags
|
|
{
|
|
[MarshalAs(UnmanagedType.I1)] public bool SpriteOverflow;
|
|
[MarshalAs(UnmanagedType.I1)] public bool Sprite0Hit;
|
|
[MarshalAs(UnmanagedType.I1)] public bool VerticalBlank;
|
|
}
|
|
|
|
public struct NesPpuMaskFlags
|
|
{
|
|
[MarshalAs(UnmanagedType.I1)] public bool Grayscale;
|
|
[MarshalAs(UnmanagedType.I1)] public bool BackgroundMask;
|
|
[MarshalAs(UnmanagedType.I1)] public bool SpriteMask;
|
|
[MarshalAs(UnmanagedType.I1)] public bool BackgroundEnabled;
|
|
[MarshalAs(UnmanagedType.I1)] public bool SpritesEnabled;
|
|
[MarshalAs(UnmanagedType.I1)] public bool IntensifyRed;
|
|
[MarshalAs(UnmanagedType.I1)] public bool IntensifyGreen;
|
|
[MarshalAs(UnmanagedType.I1)] public bool IntensifyBlue;
|
|
}
|
|
|
|
public struct NesPpuControlFlags
|
|
{
|
|
public UInt16 BackgroundPatternAddr;
|
|
public UInt16 SpritePatternAddr;
|
|
[MarshalAs(UnmanagedType.I1)] public bool VerticalWrite;
|
|
[MarshalAs(UnmanagedType.I1)] public bool LargeSprites;
|
|
[MarshalAs(UnmanagedType.I1)] public bool SecondaryPpu;
|
|
[MarshalAs(UnmanagedType.I1)] public bool NmiOnVerticalBlank;
|
|
}
|
|
|
|
public struct NesPpuState : BaseState
|
|
{
|
|
public NesPpuStatusFlags StatusFlags;
|
|
public NesPpuMaskFlags Mask;
|
|
public NesPpuControlFlags Control;
|
|
public Int32 Scanline;
|
|
public UInt32 Cycle;
|
|
public UInt32 FrameCount;
|
|
public UInt32 NmiScanline;
|
|
public UInt32 ScanlineCount;
|
|
public UInt32 SafeOamScanline;
|
|
public UInt16 BusAddress;
|
|
public byte MemoryReadBuffer;
|
|
|
|
public UInt16 VideoRamAddr;
|
|
public UInt16 TmpVideoRamAddr;
|
|
public byte ScrollX;
|
|
[MarshalAs(UnmanagedType.I1)] public bool WriteToggle;
|
|
public byte SpriteRamAddr;
|
|
};
|
|
|
|
[Flags]
|
|
public enum NesCpuFlags
|
|
{
|
|
Carry = 0x01,
|
|
Zero = 0x02,
|
|
IrqDisable = 0x04,
|
|
Decimal = 0x08,
|
|
Overflow = 0x40,
|
|
Negative = 0x80
|
|
}
|
|
|
|
[Flags]
|
|
public enum NesIrqSources
|
|
{
|
|
External = 1,
|
|
FrameCounter = 2,
|
|
DMC = 4,
|
|
FdsDisk = 8,
|
|
}
|
|
|
|
public struct NesState : BaseState
|
|
{
|
|
public NesCpuState Cpu;
|
|
public NesPpuState Ppu;
|
|
public NesCartridgeState Cartridge;
|
|
public NesApuState Apu;
|
|
public UInt32 ClockRate;
|
|
}
|
|
|
|
public enum NesPrgMemoryType
|
|
{
|
|
PrgRom,
|
|
SaveRam,
|
|
WorkRam,
|
|
}
|
|
|
|
public enum NesChrMemoryType
|
|
{
|
|
Default,
|
|
ChrRom,
|
|
ChrRam,
|
|
NametableRam
|
|
}
|
|
|
|
public enum NesMemoryAccessType
|
|
{
|
|
Unspecified = -1,
|
|
NoAccess = 0x00,
|
|
Read = 0x01,
|
|
Write = 0x02,
|
|
ReadWrite = 0x03
|
|
}
|
|
|
|
public enum MapperStateValueType
|
|
{
|
|
None,
|
|
String,
|
|
Bool,
|
|
Number8,
|
|
Number16,
|
|
Number32
|
|
}
|
|
|
|
public struct MapperStateEntry
|
|
{
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 40)] public byte[] Address;
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 40)] public byte[] Name;
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 40)] public byte[] Value;
|
|
public MapperStateValueType Type;
|
|
|
|
public string GetAddress() { return ConvertString(Address); }
|
|
public string GetName() { return ConvertString(Name); }
|
|
|
|
public object? GetValue()
|
|
{
|
|
switch(Type) {
|
|
case MapperStateValueType.None: return null;
|
|
|
|
case MapperStateValueType.String: return ConvertString(Value);
|
|
case MapperStateValueType.Bool: return Value[0] != 0;
|
|
|
|
case MapperStateValueType.Number8:
|
|
case MapperStateValueType.Number16:
|
|
case MapperStateValueType.Number32:
|
|
Int64 value = 0;
|
|
for(int i = 0; i < 8; i++) {
|
|
value |= (Int64)Value[i] << (i * 8);
|
|
}
|
|
return value;
|
|
}
|
|
|
|
throw new Exception("Invalid value type");
|
|
}
|
|
|
|
private string ConvertString(byte[] stringArray)
|
|
{
|
|
int length = 0;
|
|
for(int i = 0; i < 40; i++) {
|
|
if(stringArray[i] == 0) {
|
|
length = i;
|
|
break;
|
|
}
|
|
}
|
|
return Encoding.UTF8.GetString(stringArray, 0, length);
|
|
}
|
|
}
|
|
|
|
public struct NesCartridgeState
|
|
{
|
|
public UInt32 PrgRomSize;
|
|
public UInt32 ChrRomSize;
|
|
public UInt32 ChrRamSize;
|
|
|
|
public UInt32 PrgPageCount;
|
|
public UInt32 PrgPageSize;
|
|
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 0x100)]
|
|
public Int32[] PrgMemoryOffset;
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 0x100)]
|
|
public NesPrgMemoryType[] PrgMemoryType;
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 0x100)]
|
|
public NesMemoryAccessType[] PrgMemoryAccess;
|
|
|
|
public UInt32 ChrPageCount;
|
|
public UInt32 ChrPageSize;
|
|
public UInt32 ChrRamPageSize;
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 0x40)]
|
|
public Int32[] ChrMemoryOffset;
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 0x40)]
|
|
public NesChrMemoryType[] ChrMemoryType;
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 0x40)]
|
|
public NesMemoryAccessType[] ChrMemoryAccess;
|
|
|
|
public UInt32 WorkRamPageSize;
|
|
public UInt32 SaveRamPageSize;
|
|
|
|
public NesMirroringType Mirroring;
|
|
|
|
[MarshalAs(UnmanagedType.I1)]
|
|
public bool HasBattery;
|
|
|
|
public UInt32 CustomEntryCount;
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 100)]
|
|
public MapperStateEntry[] CustomEntries;
|
|
}
|
|
|
|
public enum NesMirroringType
|
|
{
|
|
Horizontal,
|
|
Vertical,
|
|
ScreenAOnly,
|
|
ScreenBOnly,
|
|
FourScreens
|
|
}
|
|
|
|
public struct NesApuLengthCounterState
|
|
{
|
|
[MarshalAs(UnmanagedType.I1)]
|
|
public bool Halt;
|
|
public byte Counter;
|
|
public byte ReloadValue;
|
|
}
|
|
|
|
public struct NesApuEnvelopeState
|
|
{
|
|
[MarshalAs(UnmanagedType.I1)]
|
|
public bool StartFlag;
|
|
[MarshalAs(UnmanagedType.I1)]
|
|
public bool Loop;
|
|
[MarshalAs(UnmanagedType.I1)]
|
|
public bool ConstantVolume;
|
|
public byte Divider;
|
|
public byte Counter;
|
|
public byte Volume;
|
|
}
|
|
|
|
public struct NesApuSquareState
|
|
{
|
|
public byte Duty;
|
|
public byte DutyPosition;
|
|
public UInt16 Period;
|
|
public UInt16 Timer;
|
|
|
|
[MarshalAs(UnmanagedType.I1)]
|
|
public bool SweepEnabled;
|
|
[MarshalAs(UnmanagedType.I1)]
|
|
public bool SweepNegate;
|
|
public byte SweepPeriod;
|
|
public byte SweepShift;
|
|
|
|
[MarshalAs(UnmanagedType.I1)]
|
|
public bool Enabled;
|
|
public byte OutputVolume;
|
|
public double Frequency;
|
|
|
|
public NesApuLengthCounterState LengthCounter;
|
|
public NesApuEnvelopeState Envelope;
|
|
}
|
|
|
|
public struct NesApuTriangleState
|
|
{
|
|
public UInt16 Period;
|
|
public UInt16 Timer;
|
|
public byte SequencePosition;
|
|
|
|
[MarshalAs(UnmanagedType.I1)] public bool Enabled;
|
|
public double Frequency;
|
|
public byte OutputVolume;
|
|
|
|
public byte LinearCounter;
|
|
public byte LinearCounterReload;
|
|
[MarshalAs(UnmanagedType.I1)] public bool LinearReloadFlag;
|
|
|
|
public NesApuLengthCounterState LengthCounter;
|
|
}
|
|
|
|
public struct NesApuNoiseState
|
|
{
|
|
public UInt16 Period;
|
|
public UInt16 Timer;
|
|
public UInt16 ShiftRegister;
|
|
[MarshalAs(UnmanagedType.I1)]
|
|
public bool ModeFlag;
|
|
|
|
[MarshalAs(UnmanagedType.I1)]
|
|
public bool Enabled;
|
|
public double Frequency;
|
|
public byte OutputVolume;
|
|
|
|
public NesApuLengthCounterState LengthCounter;
|
|
public NesApuEnvelopeState Envelope;
|
|
}
|
|
|
|
public struct NesApuDmcState
|
|
{
|
|
public double SampleRate;
|
|
public UInt16 SampleAddr;
|
|
public UInt16 SampleLength;
|
|
|
|
[MarshalAs(UnmanagedType.I1)]
|
|
public bool Loop;
|
|
[MarshalAs(UnmanagedType.I1)]
|
|
public bool IrqEnabled;
|
|
public UInt16 Period;
|
|
public UInt16 Timer;
|
|
public UInt16 BytesRemaining;
|
|
|
|
public byte OutputVolume;
|
|
}
|
|
|
|
public struct NesApuFrameCounterState
|
|
{
|
|
[MarshalAs(UnmanagedType.I1)]
|
|
public bool FiveStepMode;
|
|
public byte SequencePosition;
|
|
[MarshalAs(UnmanagedType.I1)]
|
|
public bool IrqEnabled;
|
|
}
|
|
|
|
public struct NesApuState
|
|
{
|
|
public NesApuSquareState Square1;
|
|
public NesApuSquareState Square2;
|
|
public NesApuTriangleState Triangle;
|
|
public NesApuNoiseState Noise;
|
|
public NesApuDmcState Dmc;
|
|
public NesApuFrameCounterState FrameCounter;
|
|
}
|
|
|
|
public struct PceCpuState : BaseState
|
|
{
|
|
public UInt64 CycleCount;
|
|
public UInt16 PC;
|
|
public byte SP;
|
|
public byte A;
|
|
public byte X;
|
|
public byte Y;
|
|
public byte PS;
|
|
}
|
|
|
|
public enum PceCpuFlags
|
|
{
|
|
Carry = 0x01,
|
|
Zero = 0x02,
|
|
IrqDisable = 0x04,
|
|
Decimal = 0x08,
|
|
Memory = 0x20,
|
|
Overflow = 0x40,
|
|
Negative = 0x80
|
|
}
|
|
|
|
public struct PceVdcState : BaseState
|
|
{
|
|
public UInt32 FrameCount;
|
|
|
|
public UInt16 HClock;
|
|
public UInt16 Scanline;
|
|
public UInt16 RcrCounter;
|
|
|
|
public byte CurrentReg;
|
|
|
|
//R00 - MAWR
|
|
public UInt16 MemAddrWrite;
|
|
|
|
//R01 - MARR
|
|
public UInt16 MemAddrRead;
|
|
public UInt16 ReadBuffer;
|
|
|
|
//R02 - VWR
|
|
public UInt16 VramData;
|
|
|
|
//R05 - CR - Control
|
|
[MarshalAs(UnmanagedType.I1)] public bool EnableCollisionIrq;
|
|
[MarshalAs(UnmanagedType.I1)] public bool EnableOverflowIrq;
|
|
[MarshalAs(UnmanagedType.I1)] public bool EnableScanlineIrq;
|
|
[MarshalAs(UnmanagedType.I1)] public bool EnableVerticalBlankIrq;
|
|
[MarshalAs(UnmanagedType.I1)] public bool OutputVerticalSync;
|
|
[MarshalAs(UnmanagedType.I1)] public bool OutputHorizontalSync;
|
|
[MarshalAs(UnmanagedType.I1)] public bool SpritesEnabled;
|
|
[MarshalAs(UnmanagedType.I1)] public bool BackgroundEnabled;
|
|
public byte VramAddrIncrement;
|
|
|
|
//R06 - RCR
|
|
public UInt16 RasterCompareRegister;
|
|
|
|
//R09 - MWR - Memory Width
|
|
public byte ColumnCount;
|
|
public byte RowCount;
|
|
public byte SpriteAccessMode;
|
|
public byte VramAccessMode;
|
|
[MarshalAs(UnmanagedType.I1)] public bool CgMode;
|
|
|
|
[MarshalAs(UnmanagedType.I1)] public bool BgScrollYUpdatePending;
|
|
|
|
public PceVdcHvLatches HvLatch;
|
|
public PceVdcHvLatches HvReg;
|
|
|
|
//R0F - DCR
|
|
[MarshalAs(UnmanagedType.I1)] public bool VramSatbIrqEnabled;
|
|
[MarshalAs(UnmanagedType.I1)] public bool VramVramIrqEnabled;
|
|
[MarshalAs(UnmanagedType.I1)] public bool DecrementSrc;
|
|
[MarshalAs(UnmanagedType.I1)] public bool DecrementDst;
|
|
[MarshalAs(UnmanagedType.I1)] public bool RepeatSatbTransfer;
|
|
|
|
//R10 - SOUR
|
|
public UInt16 BlockSrc;
|
|
|
|
//R11 - DESR
|
|
public UInt16 BlockDst;
|
|
|
|
//R12 - LENR
|
|
public UInt16 BlockLen;
|
|
|
|
//R13 - DVSSR
|
|
public UInt16 SatbBlockSrc;
|
|
[MarshalAs(UnmanagedType.I1)] public bool SatbTransferPending;
|
|
[MarshalAs(UnmanagedType.I1)] public bool SatbTransferRunning;
|
|
public UInt16 SatbTransferNextWordCounter;
|
|
public byte SatbTransferOffset;
|
|
|
|
//Status flags
|
|
[MarshalAs(UnmanagedType.I1)] public bool VerticalBlank;
|
|
[MarshalAs(UnmanagedType.I1)] public bool VramTransferDone;
|
|
[MarshalAs(UnmanagedType.I1)] public bool SatbTransferDone;
|
|
[MarshalAs(UnmanagedType.I1)] public bool ScanlineDetected;
|
|
[MarshalAs(UnmanagedType.I1)] public bool SpriteOverflow;
|
|
[MarshalAs(UnmanagedType.I1)] public bool Sprite0Hit;
|
|
|
|
[MarshalAs(UnmanagedType.I1)] public bool BurstModeEnabled;
|
|
[MarshalAs(UnmanagedType.I1)] public bool NextSpritesEnabled;
|
|
[MarshalAs(UnmanagedType.I1)] public bool NextBackgroundEnabled;
|
|
}
|
|
|
|
public struct PceVceState : BaseState
|
|
{
|
|
public UInt16 ScanlineCount;
|
|
public UInt16 PalAddr;
|
|
public byte ClockDivider;
|
|
[MarshalAs(UnmanagedType.I1)] public bool Grayscale;
|
|
}
|
|
|
|
public struct PceVdcHvLatches
|
|
{
|
|
//R07 - BXR
|
|
public UInt16 BgScrollX;
|
|
|
|
//R08 - BYR
|
|
public UInt16 BgScrollY;
|
|
|
|
//R0A - HSR
|
|
public byte HorizDisplayStart;
|
|
public byte HorizSyncWidth;
|
|
|
|
//R0B - HDR
|
|
public byte HorizDisplayWidth;
|
|
public byte HorizDisplayEnd;
|
|
|
|
//R0C - VPR
|
|
public byte VertDisplayStart;
|
|
public byte VertSyncWidth;
|
|
|
|
//R0D - VDW
|
|
public UInt16 VertDisplayWidth;
|
|
|
|
//R0E - VCR
|
|
public byte VertEndPosVcr;
|
|
}
|
|
|
|
public struct PceMemoryManagerState : BaseState
|
|
{
|
|
public UInt64 CycleCount;
|
|
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 8)]
|
|
public byte[] Mpr;
|
|
|
|
public byte ActiveIrqs;
|
|
public byte DisabledIrqs;
|
|
[MarshalAs(UnmanagedType.I1)] public bool FastCpuSpeed;
|
|
public byte MprReadBuffer;
|
|
public byte IoBuffer;
|
|
}
|
|
|
|
public struct PceTimerState
|
|
{
|
|
public byte ReloadValue;
|
|
public byte Counter;
|
|
public UInt16 Scaler;
|
|
[MarshalAs(UnmanagedType.I1)] public bool Enabled;
|
|
}
|
|
|
|
public struct PcePsgState
|
|
{
|
|
public byte ChannelSelect;
|
|
public byte LeftVolume;
|
|
public byte RightVolume;
|
|
public byte LfoFrequency;
|
|
public byte LfoControl;
|
|
};
|
|
|
|
public struct PcePsgChannelState
|
|
{
|
|
public UInt16 Frequency;
|
|
public byte Amplitude;
|
|
[MarshalAs(UnmanagedType.I1)] public bool Enabled;
|
|
public byte LeftVolume;
|
|
public byte RightVolume;
|
|
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 0x20)]
|
|
public byte[] WaveData;
|
|
|
|
[MarshalAs(UnmanagedType.I1)] public bool DdaEnabled;
|
|
public byte DdaOutputValue;
|
|
|
|
public byte WriteAddr;
|
|
public byte ReadAddr;
|
|
public UInt32 Timer;
|
|
public byte CurrentOutput;
|
|
|
|
//Channel 5 & 6 only
|
|
public UInt32 NoiseLfsr;
|
|
public UInt32 NoiseTimer;
|
|
[MarshalAs(UnmanagedType.I1)] public bool NoiseEnabled;
|
|
public sbyte NoiseOutput;
|
|
public byte NoiseFrequency;
|
|
}
|
|
|
|
public enum PceVpcPriorityMode
|
|
{
|
|
Default = 0,
|
|
Vdc1SpritesBelowVdc2Bg = 1,
|
|
Vdc2SpritesAboveVdc1Bg = 2,
|
|
}
|
|
|
|
public enum PceVpcPixelWindow
|
|
{
|
|
NoWindow,
|
|
Window1,
|
|
Window2,
|
|
Both
|
|
}
|
|
|
|
public struct PceVpcPriorityConfig
|
|
{
|
|
public PceVpcPriorityMode PriorityMode;
|
|
[MarshalAs(UnmanagedType.I1)] public bool Vdc1Enabled;
|
|
[MarshalAs(UnmanagedType.I1)] public bool Vdc2Enabled;
|
|
}
|
|
|
|
public struct PceVpcState
|
|
{
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)]
|
|
public PceVpcPriorityConfig[] WindowCfg;
|
|
public byte Priority1;
|
|
public byte Priority2;
|
|
public UInt16 Window1;
|
|
public UInt16 Window2;
|
|
[MarshalAs(UnmanagedType.I1)] public bool StToVdc2Mode;
|
|
[MarshalAs(UnmanagedType.I1)] public bool HasIrqVdc1;
|
|
[MarshalAs(UnmanagedType.I1)] public bool HasIrqVdc2;
|
|
}
|
|
|
|
public struct PceVideoState : BaseState
|
|
{
|
|
public PceVdcState Vdc;
|
|
public PceVceState Vce;
|
|
public PceVpcState Vpc;
|
|
public PceVdcState Vdc2;
|
|
}
|
|
|
|
public enum PceArcadePortOffsetTrigger
|
|
{
|
|
None = 0,
|
|
AddOnLowWrite = 1,
|
|
AddOnHighWrite = 2,
|
|
AddOnReg0AWrite = 3,
|
|
}
|
|
|
|
public struct PceArcadeCardPortConfig
|
|
{
|
|
public UInt32 BaseAddress;
|
|
public UInt16 Offset;
|
|
public UInt16 IncValue;
|
|
|
|
public byte Control;
|
|
[MarshalAs(UnmanagedType.I1)] public bool AutoIncrement;
|
|
[MarshalAs(UnmanagedType.I1)] public bool AddOffset;
|
|
[MarshalAs(UnmanagedType.I1)] public bool SignedIncrement; //unused?
|
|
[MarshalAs(UnmanagedType.I1)] public bool SignedOffset;
|
|
[MarshalAs(UnmanagedType.I1)] public bool AddIncrementToBase;
|
|
public PceArcadePortOffsetTrigger AddOffsetTrigger;
|
|
}
|
|
|
|
public struct PceArcadeCardState
|
|
{
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)]
|
|
public PceArcadeCardPortConfig[] Port;
|
|
public UInt32 ValueReg;
|
|
public byte ShiftReg;
|
|
public byte RotateReg;
|
|
}
|
|
|
|
public enum PceCdRomIrqSource
|
|
{
|
|
Adpcm = 0x04,
|
|
Stop = 0x08,
|
|
SubChannel = 0x10,
|
|
DataTransferDone = 0x20,
|
|
DataTransferReady = 0x40
|
|
}
|
|
|
|
public struct PceCdRomState
|
|
{
|
|
public byte ActiveIrqs;
|
|
public byte EnabledIrqs;
|
|
[MarshalAs(UnmanagedType.I1)] public bool ReadRightChannel;
|
|
[MarshalAs(UnmanagedType.I1)] public bool BramLocked;
|
|
}
|
|
|
|
public struct PceAdpcmState
|
|
{
|
|
[MarshalAs(UnmanagedType.I1)] public bool Nibble;
|
|
public UInt16 ReadAddress;
|
|
public UInt16 WriteAddress;
|
|
|
|
public UInt16 AddressPort;
|
|
|
|
public byte DmaControl;
|
|
public byte Control;
|
|
public byte PlaybackRate;
|
|
|
|
public UInt16 AdpcmLength;
|
|
[MarshalAs(UnmanagedType.I1)] public bool EndReached;
|
|
[MarshalAs(UnmanagedType.I1)] public bool HalfReached;
|
|
|
|
[MarshalAs(UnmanagedType.I1)] public bool Playing;
|
|
|
|
public byte ReadBuffer;
|
|
public byte ReadClockCounter;
|
|
|
|
public byte WriteBuffer;
|
|
public byte WriteClockCounter;
|
|
}
|
|
|
|
public enum CdPlayEndBehavior
|
|
{
|
|
Stop,
|
|
Loop,
|
|
Irq
|
|
}
|
|
|
|
public enum CdAudioStatus : byte
|
|
{
|
|
Playing = 0,
|
|
Inactive = 1,
|
|
Paused = 2,
|
|
Stopped = 3
|
|
}
|
|
|
|
public struct PceCdAudioPlayerState
|
|
{
|
|
public CdAudioStatus Status;
|
|
|
|
public UInt32 StartSector;
|
|
public UInt32 EndSector;
|
|
public CdPlayEndBehavior EndBehavior;
|
|
|
|
public UInt32 CurrentSector;
|
|
public UInt32 CurrentSample;
|
|
|
|
public Int16 LeftSample;
|
|
public Int16 RightSample;
|
|
}
|
|
|
|
public enum ScsiPhase
|
|
{
|
|
BusFree,
|
|
Command,
|
|
DataIn,
|
|
DataOut,
|
|
MessageIn,
|
|
MessageOut,
|
|
Status
|
|
}
|
|
|
|
public struct PceScsiBusState
|
|
{
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 9)]
|
|
public byte[] Signals;
|
|
|
|
public ScsiPhase Phase;
|
|
|
|
[MarshalAs(UnmanagedType.I1)] public bool StatusDone;
|
|
[MarshalAs(UnmanagedType.I1)] public bool MessageDone;
|
|
public byte MessageData;
|
|
public byte DataPort;
|
|
|
|
[MarshalAs(UnmanagedType.I1)] public bool DiscReading;
|
|
[MarshalAs(UnmanagedType.I1)] public bool DataTransfer;
|
|
[MarshalAs(UnmanagedType.I1)] public bool DataTransferDone;
|
|
|
|
public UInt32 Sector;
|
|
public byte SectorsToRead;
|
|
}
|
|
|
|
public enum PceAudioFaderTarget
|
|
{
|
|
Adpcm,
|
|
CdAudio,
|
|
}
|
|
|
|
public struct PceAudioFaderState
|
|
{
|
|
public UInt64 StartClock;
|
|
public PceAudioFaderTarget Target;
|
|
[MarshalAs(UnmanagedType.I1)] public bool FastFade;
|
|
[MarshalAs(UnmanagedType.I1)] public bool Enabled;
|
|
}
|
|
|
|
public struct PceState : BaseState
|
|
{
|
|
public PceCpuState Cpu;
|
|
public PceVideoState Video;
|
|
|
|
public PceMemoryManagerState MemoryManager;
|
|
public PceTimerState Timer;
|
|
|
|
public PcePsgState Psg;
|
|
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 6)]
|
|
public PcePsgChannelState[] PsgChannels;
|
|
|
|
public PceCdRomState CdRom;
|
|
public PceCdAudioPlayerState CdPlayer;
|
|
public PceAdpcmState Adpcm;
|
|
public PceAudioFaderState AudioFader;
|
|
public PceScsiBusState ScsiDrive;
|
|
public PceArcadeCardState ArcadeCard;
|
|
|
|
[MarshalAs(UnmanagedType.I1)] public bool IsSuperGrafx;
|
|
[MarshalAs(UnmanagedType.I1)] public bool HasArcadeCard;
|
|
[MarshalAs(UnmanagedType.I1)] public bool HasCdRom;
|
|
}
|
|
}
|