private void SetupMemoryDomains()
{
var domains = new List <MemoryDomain>(3);
var MainMemoryDomain = new MemoryDomainByteArray("Main RAM", MemoryDomain.Endian.Little, Ram, true, 1);
var VRamDomain = new MemoryDomainByteArray("Video RAM", MemoryDomain.Endian.Little, VDP.VRAM, true, 1);
var SystemBusDomain = new MemoryDomainDelegate("System Bus", 0x10000, MemoryDomain.Endian.Little,
(addr) =>
{
if (addr < 0 || addr >= 65536)
{
throw new ArgumentOutOfRangeException();
}
return(Cpu.ReadMemory((ushort)addr));
},
(addr, value) =>
{
if (addr < 0 || addr >= 65536)
{
throw new ArgumentOutOfRangeException();
}
Cpu.WriteMemory((ushort)addr, value);
}, 1);
domains.Add(MainMemoryDomain);
domains.Add(VRamDomain);
domains.Add(SystemBusDomain);
memoryDomains = new MemoryDomainList(domains);
(ServiceProvider as BasicServiceProvider).Register <IMemoryDomains>(memoryDomains);
}
private void SetupMemoryDomains()
{
var domains = new List <MemoryDomain>();
var systemBusDomain = new MemoryDomainDelegate("System Bus", 0x10000, MemoryDomain.Endian.Little,
(addr) =>
{
if (addr < 0 || addr >= 65536)
{
throw new ArgumentOutOfRangeException();
}
return(_cpu.ReadMemory((ushort)addr));
},
(addr, value) =>
{
if (addr < 0 || addr >= 65536)
{
throw new ArgumentOutOfRangeException();
}
_cpu.WriteMemory((ushort)addr, value);
}, 1);
domains.Add(systemBusDomain);
SyncAllByteArrayDomains();
_memoryDomains = new MemoryDomainList(_byteArrayDomains.Values.Concat(domains).ToList());
((BasicServiceProvider)ServiceProvider).Register(_memoryDomains);
_memoryDomainsInit = true;
}
private unsafe void MakeFakeBus()
{
int size = Api.QUERY_get_memory_size(LibsnesApi.SNES_MEMORY.WRAM);
if (size != 0x20000)
{
throw new InvalidOperationException();
}
byte *blockptr = Api.QUERY_get_memory_data(LibsnesApi.SNES_MEMORY.WRAM);
var md = new MemoryDomainDelegate("System Bus", 0x1000000, MemoryDomain.Endian.Little,
addr =>
{
var a = FakeBusMap((int)addr);
if (a.HasValue)
{
return(blockptr[a.Value]);
}
return(FakeBusRead((int)addr));
},
(addr, val) =>
{
var a = FakeBusMap((int)addr);
if (a.HasValue)
{
blockptr[a.Value] = val;
}
}, wordSize: 2);
_memoryDomainList.Add(md);
}
private void SetupMemoryDomains()
{
var domains = new List <MemoryDomain>
{
MemoryDomain.FromByteArray("Main RAM", MemoryDomain.Endian.Little, _ram)
};
var systemBusDomain = new MemoryDomainDelegate("System Bus", 0x10000, MemoryDomain.Endian.Little,
(addr) =>
{
if (addr < 0 || addr >= 65536)
{
throw new ArgumentOutOfRangeException();
}
return(Cpu.ReadMemory((ushort)addr));
},
(addr, value) =>
{
if (addr < 0 || addr >= 65536)
{
throw new ArgumentOutOfRangeException();
}
Cpu.WriteMemory((ushort)addr, value);
}, 1);
domains.Add(systemBusDomain);
_memoryDomains = new MemoryDomainList(domains);
(ServiceProvider as BasicServiceProvider).Register <IMemoryDomains>(_memoryDomains);
}
private void SetupMemoryDomains()
{
var domains = new List <MemoryDomain>();
var RAM = new MemoryDomainByteArray("RAM", MemoryDomain.Endian.Little, ram, true, 1);
var SystemBus = new MemoryDomainDelegate("System Bus", 0x10000, MemoryDomain.Endian.Little,
addr => PeekMemory((ushort)addr), (addr, value) => ApplySystemBusPoke((int)addr, value), 1);
var PPUBus = new MemoryDomainDelegate("PPU Bus", 0x4000, MemoryDomain.Endian.Little,
addr => ppu.ppubus_peek((int)addr), (addr, value) => ppu.ppubus_write((int)addr, value), 1);
var CIRAMdomain = new MemoryDomainByteArray("CIRAM (nametables)", MemoryDomain.Endian.Little, CIRAM, true, 1);
var OAMdoman = new MemoryDomainByteArray("OAM", MemoryDomain.Endian.Unknown, ppu.OAM, true, 1);
domains.Add(RAM);
domains.Add(SystemBus);
domains.Add(PPUBus);
domains.Add(CIRAMdomain);
domains.Add(OAMdoman);
if (!(Board is FDS) && Board.SaveRam != null)
{
var BatteryRam = new MemoryDomainByteArray("Battery RAM", MemoryDomain.Endian.Little, Board.SaveRam, true, 1);
domains.Add(BatteryRam);
}
if (Board.ROM != null)
{
var PRGROM = new MemoryDomainByteArray("PRG ROM", MemoryDomain.Endian.Little, Board.ROM, true, 1);
domains.Add(PRGROM);
}
if (Board.VROM != null)
{
var CHRROM = new MemoryDomainByteArray("CHR VROM", MemoryDomain.Endian.Little, Board.VROM, true, 1);
domains.Add(CHRROM);
}
if (Board.VRAM != null)
{
var VRAM = new MemoryDomainByteArray("VRAM", MemoryDomain.Endian.Little, Board.VRAM, true, 1);
domains.Add(VRAM);
}
if (Board.WRAM != null)
{
var WRAM = new MemoryDomainByteArray("WRAM", MemoryDomain.Endian.Little, Board.WRAM, true, 1);
domains.Add(WRAM);
}
// if there were more boards with special ram sets, we'd want to do something more general
if (Board is FDS)
{
domains.Add((Board as FDS).GetDiskPeeker());
}
else if (Board is ExROM)
{
domains.Add((Board as ExROM).GetExRAM());
}
_memoryDomains = new MemoryDomainList(domains);
(ServiceProvider as BasicServiceProvider).Register <IMemoryDomains>(_memoryDomains);
}
void SetupMemoryDomains()
{
var domains = new List <MemoryDomain>
{
new MemoryDomainDelegate(
"System Bus",
0x10000,
MemoryDomain.Endian.Little,
(addr) => LibMSX.MSX_getsysbus(MSX_Pntr, (int)(addr & 0xFFFF)),
(addr, value) => { },
1),
new MemoryDomainDelegate(
"VRAM",
0x4000,
MemoryDomain.Endian.Little,
(addr) => LibMSX.MSX_getvram(MSX_Pntr, (int)(addr & 0x3FFF)),
(addr, value) => { },
1),
};
if (SaveRAM != null)
{
var saveRamDomain = new MemoryDomainDelegate("Save RAM", SaveRAM.Length, MemoryDomain.Endian.Little,
addr => SaveRAM[addr],
(addr, value) => { SaveRAM[addr] = value; SaveRamModified = true; }, 1);
domains.Add(saveRamDomain);
}
SyncAllByteArrayDomains();
MemoryDomains = new MemoryDomainList(_byteArrayDomains.Values.Concat(domains).ToList());
(ServiceProvider as BasicServiceProvider).Register <IMemoryDomains>(MemoryDomains);
_memoryDomainsInit = true;
}
private void SetupMemoryDomains()
{
var domains = new List <MemoryDomain>();
var systemBusDomain = new MemoryDomainDelegate("System Bus (21 bit)", 0x200000, MemoryDomain.Endian.Little,
(addr) =>
{
if (addr < 0 || addr >= 0x200000)
{
throw new ArgumentOutOfRangeException();
}
return(Cpu.ReadMemory21((int)addr));
},
(addr, value) =>
{
if (addr < 0 || addr >= 0x200000)
{
throw new ArgumentOutOfRangeException();
}
Cpu.WriteMemory21((int)addr, value);
},
wordSize: 2);
domains.Add(systemBusDomain);
var cpuBusDomain = new MemoryDomainDelegate("System Bus", 0x10000, MemoryDomain.Endian.Little,
(addr) =>
{
if (addr < 0 || addr >= 0x10000)
{
throw new ArgumentOutOfRangeException();
}
return(Cpu.PeekMemory((ushort)addr));
},
(addr, value) =>
{
if (addr < 0 || addr >= 0x10000)
{
throw new ArgumentOutOfRangeException();
}
Cpu.PokeMemory((ushort)addr, value);
},
wordSize: 2);
domains.Add(cpuBusDomain);
SyncAllByteArrayDomains();
domains.AddRange(_byteArrayDomains.Values);
domains.AddRange(_ushortArrayDomains.Values);
_memoryDomains = new MemoryDomainList(domains);
_memoryDomains.SystemBus = cpuBusDomain;
_memoryDomains.MainMemory = _byteArrayDomains["Main Memory"];
((BasicServiceProvider)ServiceProvider).Register <IMemoryDomains>(_memoryDomains);
_memoryDomainsInit = true;
}
private void SetupMemoryDomains()
{
var domains = new List <MemoryDomain>();
var mainRamDomain = new MemoryDomainDelegate("Main Ram", 0xC000, MemoryDomain.Endian.Little,
addr =>
{
if (addr < 0 || addr >= 0xC000)
{
throw new ArgumentOutOfRangeException();
}
return((byte)_machine.Memory.Peek((int)addr));
},
(addr, value) =>
{
if (addr < 0 || addr >= 0xC000)
{
throw new ArgumentOutOfRangeException();
}
_machine.Memory.Write((int)addr, value);
}, 1);
domains.Add(mainRamDomain);
var systemBusDomain = new MemoryDomainDelegate("System Bus", 0x10000, MemoryDomain.Endian.Little,
addr =>
{
if (addr < 0 || addr >= 65536)
{
throw new ArgumentOutOfRangeException();
}
return((byte)_machine.Memory.Peek((int)addr));
},
(addr, value) =>
{
if (addr < 0 || addr >= 65536)
{
throw new ArgumentOutOfRangeException();
}
_machine.Memory.Write((int)addr, value);
}, 1);
domains.Add(systemBusDomain);
_memoryDomains = new MemoryDomainList(domains);
((BasicServiceProvider)ServiceProvider).Register(_memoryDomains);
}
void SetupMemoryDomains()
{
var domains = new List <MemoryDomain>(3);
var MainMemoryDomain = new MemoryDomainByteArray("Main RAM", MemoryDomain.Endian.Little, SystemRam, true, 1);
var VRamDomain = new MemoryDomainByteArray("Video RAM", MemoryDomain.Endian.Little, Vdp.VRAM, true, 1);
var ROMDomain = new MemoryDomainByteArray("ROM", MemoryDomain.Endian.Little, RomData, true, 1);
var SystemBusDomain = new MemoryDomainDelegate("System Bus", 0x10000, MemoryDomain.Endian.Little,
(addr) =>
{
if (addr < 0 || addr >= 65536)
{
throw new ArgumentOutOfRangeException();
}
return(Cpu.ReadMemory((ushort)addr));
},
(addr, value) =>
{
if (addr < 0 || addr >= 65536)
{
throw new ArgumentOutOfRangeException();
}
Cpu.WriteMemory((ushort)addr, value);
}, 1);
domains.Add(MainMemoryDomain);
domains.Add(VRamDomain);
domains.Add(ROMDomain);
domains.Add(SystemBusDomain);
if (SaveRAM != null)
{
var SaveRamDomain = new MemoryDomainDelegate("Save RAM", SaveRAM.Length, MemoryDomain.Endian.Little,
addr => SaveRAM[addr],
(addr, value) => { SaveRAM[addr] = value; SaveRamModified = true; }, 1);
domains.Add(SaveRamDomain);
}
if (ExtRam != null)
{
var ExtRamDomain = new MemoryDomainByteArray("Cart (Volatile) RAM", MemoryDomain.Endian.Little, ExtRam, true, 1);
domains.Add(ExtRamDomain);
}
MemoryDomains = new MemoryDomainList(domains);
(ServiceProvider as BasicServiceProvider).Register <IMemoryDomains>(MemoryDomains);
}
private void CreateMemoryDomains(int romsize)
{
var LE = MemoryDomain.Endian.Little;
var mm = new List <MemoryDomain>();
mm.Add(_iwram = new MemoryDomainIntPtr("IWRAM", LE, IntPtr.Zero, 32 * 1024, true, 4));
mm.Add(_ewram = new MemoryDomainIntPtr("EWRAM", LE, IntPtr.Zero, 256 * 1024, true, 4));
mm.Add(_bios = new MemoryDomainIntPtr("BIOS", LE, IntPtr.Zero, 16 * 1024, false, 4));
mm.Add(_palram = new MemoryDomainIntPtr("PALRAM", LE, IntPtr.Zero, 1024, true, 4));
mm.Add(_vram = new MemoryDomainIntPtr("VRAM", LE, IntPtr.Zero, 96 * 1024, true, 4));
mm.Add(_oam = new MemoryDomainIntPtr("OAM", LE, IntPtr.Zero, 1024, true, 4));
mm.Add(_rom = new MemoryDomainIntPtr("ROM", LE, IntPtr.Zero, romsize, false, 4));
mm.Add(_cwram = new MemoryDomainDelegate("Combined WRAM", (256 + 32) * 1024, LE, null, null, 4));
MemoryDomains = new MemoryDomainList(mm);
WireMemoryDomainPointers();
}
private void CreateMemoryDomains(int romsize)
{
var le = MemoryDomain.Endian.Little;
var mm = new List <MemoryDomain>();
mm.Add(_iwram = new MemoryDomainIntPtr("IWRAM", le, IntPtr.Zero, 32 * 1024, true, 4));
mm.Add(_ewram = new MemoryDomainIntPtr("EWRAM", le, IntPtr.Zero, 256 * 1024, true, 4));
mm.Add(_bios = new MemoryDomainIntPtr("BIOS", le, IntPtr.Zero, 16 * 1024, false, 4));
mm.Add(_palram = new MemoryDomainIntPtr("PALRAM", le, IntPtr.Zero, 1024, true, 4));
mm.Add(_vram = new MemoryDomainIntPtr("VRAM", le, IntPtr.Zero, 96 * 1024, true, 4));
mm.Add(_oam = new MemoryDomainIntPtr("OAM", le, IntPtr.Zero, 1024, true, 4));
mm.Add(_rom = new MemoryDomainIntPtr("ROM", le, IntPtr.Zero, romsize, true, 4));
// 128 KB is the max size for GBA savedata
// mGBA does not know a game's save type (and as a result actual savedata size) on startup.
// Instead, BizHawk's savedata buffer will be accessed directly for a consistent interface.
mm.Add(_sram = new MemoryDomainIntPtr("SRAM", le, IntPtr.Zero, 128 * 1024, true, 4));
mm.Add(_cwram = new MemoryDomainDelegate("Combined WRAM", (256 + 32) * 1024, le, null, null, 4));
mm.Add(new MemoryDomainDelegate("System Bus", 0x10000000, le,
delegate(long addr)
{
var a = (uint)addr;
if (a >= 0x10000000)
{
throw new ArgumentOutOfRangeException();
}
return(LibmGBA.BizReadBus(Core, a));
},
delegate(long addr, byte val)
{
var a = (uint)addr;
if (a >= 0x10000000)
{
throw new ArgumentOutOfRangeException();
}
LibmGBA.BizWriteBus(Core, a, val);
}, 4));
_memoryDomains = new MemoryDomainList(mm);
WireMemoryDomainPointers();
}
private void CreateMemoryDomains(int romsize)
{
var le = MemoryDomain.Endian.Little;
var mm = new List <MemoryDomain>();
mm.Add(_iwram = new MemoryDomainIntPtr("IWRAM", le, IntPtr.Zero, 32 * 1024, true, 4));
mm.Add(_ewram = new MemoryDomainIntPtr("EWRAM", le, IntPtr.Zero, 256 * 1024, true, 4));
mm.Add(_bios = new MemoryDomainIntPtr("BIOS", le, IntPtr.Zero, 16 * 1024, false, 4));
mm.Add(_palram = new MemoryDomainIntPtr("PALRAM", le, IntPtr.Zero, 1024, true, 4));
mm.Add(_vram = new MemoryDomainIntPtr("VRAM", le, IntPtr.Zero, 96 * 1024, true, 4));
mm.Add(_oam = new MemoryDomainIntPtr("OAM", le, IntPtr.Zero, 1024, true, 4));
mm.Add(_rom = new MemoryDomainIntPtr("ROM", le, IntPtr.Zero, romsize, false, 4));
mm.Add(_sram = new MemoryDomainIntPtr("SRAM", le, IntPtr.Zero, 0, true, 4)); // size will be fixed in wireup
mm.Add(_cwram = new MemoryDomainDelegate("Combined WRAM", (256 + 32) * 1024, le, null, null, 4));
mm.Add(new MemoryDomainDelegate("System Bus", 0x10000000, le,
delegate(long addr)
{
var a = (uint)addr;
if (a >= 0x10000000)
{
throw new ArgumentOutOfRangeException();
}
return(LibmGBA.BizReadBus(_core, a));
},
delegate(long addr, byte val)
{
var a = (uint)addr;
if (a >= 0x10000000)
{
throw new ArgumentOutOfRangeException();
}
LibmGBA.BizWriteBus(_core, a, val);
}, 4));
_memoryDomains = new MemoryDomainList(mm);
WireMemoryDomainPointers();
}
void SetupMemoryDomains()
{
var domains = new List <MemoryDomain>
{
new MemoryDomainDelegate("System Bus", 0x10000, MemoryDomain.Endian.Little,
(addr) =>
{
if (addr < 0 || addr >= 65536)
{
throw new ArgumentOutOfRangeException();
}
return(Cpu.ReadMemory((ushort)addr));
},
(addr, value) =>
{
if (addr < 0 || addr >= 65536)
{
throw new ArgumentOutOfRangeException();
}
Cpu.WriteMemory((ushort)addr, value);
}, 1)
};
if (SaveRAM != null)
{
var saveRamDomain = new MemoryDomainDelegate("Save RAM", SaveRAM.Length, MemoryDomain.Endian.Little,
addr => SaveRAM[addr],
(addr, value) => { SaveRAM[addr] = value; SaveRamModified = true; }, 1);
domains.Add(saveRamDomain);
}
SyncAllByteArrayDomains();
MemoryDomains = new MemoryDomainList(_byteArrayDomains.Values.Concat(domains).ToList());
(ServiceProvider as BasicServiceProvider).Register <IMemoryDomains>(MemoryDomains);
_memoryDomainsInit = true;
}
private unsafe void SetMemoryDomains()
{
using (_elf.EnterExit())
{
var mm = new List <MemoryDomain>();
for (int i = LibGPGX.MIN_MEM_DOMAIN; i <= LibGPGX.MAX_MEM_DOMAIN; i++)
{
IntPtr area = IntPtr.Zero;
int size = 0;
IntPtr pName = Core.gpgx_get_memdom(i, ref area, ref size);
if (area == IntPtr.Zero || pName == IntPtr.Zero || size == 0)
{
continue;
}
string name = Marshal.PtrToStringAnsi(pName);
var endian = name == "Z80 RAM"
? MemoryDomain.Endian.Little
: MemoryDomain.Endian.Big;
if (name == "VRAM")
{
// vram pokes need to go through hook which invalidates cached tiles
byte *p = (byte *)area;
mm.Add(new MemoryDomainDelegate(name, size, MemoryDomain.Endian.Unknown,
delegate(long addr)
{
if (addr < 0 || addr >= 65536)
{
throw new ArgumentOutOfRangeException();
}
using (_elf.EnterExit())
return(p[addr ^ 1]);
},
delegate(long addr, byte val)
{
if (addr < 0 || addr >= 65536)
{
throw new ArgumentOutOfRangeException();
}
Core.gpgx_poke_vram(((int)addr) ^ 1, val);
},
wordSize: 2));
}
else
{
// TODO: are the Z80 domains really Swap16 in the core? Check this
mm.Add(new MemoryDomainIntPtrSwap16Monitor(name, endian, area, size, name != "MD CART" && name != "CD BOOT ROM", _elf));
}
}
var m68Bus = new MemoryDomainDelegate("M68K BUS", 0x1000000, MemoryDomain.Endian.Big,
delegate(long addr)
{
var a = (uint)addr;
if (a >= 0x1000000)
{
throw new ArgumentOutOfRangeException();
}
return(Core.gpgx_peek_m68k_bus(a));
},
delegate(long addr, byte val)
{
var a = (uint)addr;
if (a >= 0x1000000)
{
throw new ArgumentOutOfRangeException();
}
Core.gpgx_write_m68k_bus(a, val);
}, 2);
mm.Add(m68Bus);
if (IsMegaCD)
{
var s68Bus = new MemoryDomainDelegate("S68K BUS", 0x1000000, MemoryDomain.Endian.Big,
delegate(long addr)
{
var a = (uint)addr;
if (a >= 0x1000000)
{
throw new ArgumentOutOfRangeException();
}
return(Core.gpgx_peek_s68k_bus(a));
},
delegate(long addr, byte val)
{
var a = (uint)addr;
if (a >= 0x1000000)
{
throw new ArgumentOutOfRangeException();
}
Core.gpgx_write_s68k_bus(a, val);
}, 2);
mm.Add(s68Bus);
}
mm.Add(_elf.GetPagesDomain());
_memoryDomains = new MemoryDomainList(mm)
{
SystemBus = m68Bus
};
((BasicServiceProvider)ServiceProvider).Register(_memoryDomains);
}
}
private void SetUpMemoryDomains()
{
_domainList.Clear();
// this must be first to coincide with "main memory"
// note that ewram could also be considered main memory depending on which hairs you split
AddMemoryDomain(LibMeteor.MemoryArea.iwram, 32 * 1024, "IWRAM");
AddMemoryDomain(LibMeteor.MemoryArea.ewram, 256 * 1024, "EWRAM");
AddMemoryDomain(LibMeteor.MemoryArea.bios, 16 * 1024, "BIOS");
AddMemoryDomain(LibMeteor.MemoryArea.palram, 1024, "PALRAM");
AddMemoryDomain(LibMeteor.MemoryArea.vram, 96 * 1024, "VRAM");
AddMemoryDomain(LibMeteor.MemoryArea.oam, 1024, "OAM");
// even if the rom is less than 32MB, the whole is still valid in meteor
AddMemoryDomain(LibMeteor.MemoryArea.rom, 32 * 1024 * 1024, "ROM");
// special domain for system bus
{
MemoryDomain sb = new MemoryDomainDelegate("System Bus", 1 << 28, MemoryDomain.Endian.Little,
delegate(long addr)
{
if (addr < 0 || addr >= 0x10000000)
{
throw new IndexOutOfRangeException();
}
return(LibMeteor.libmeteor_peekbus((uint)addr));
},
delegate(long addr, byte val)
{
if (addr < 0 || addr >= 0x10000000)
{
throw new IndexOutOfRangeException();
}
LibMeteor.libmeteor_writebus((uint)addr, val);
}, 4);
_domainList.Add(sb);
}
// special combined ram memory domain
{
var ew = _domainList[1];
var iw = _domainList[0];
MemoryDomain cr = new MemoryDomainDelegate("Combined WRAM", (256 + 32) * 1024, MemoryDomain.Endian.Little,
delegate(long addr)
{
if (addr < 0 || addr >= (256 + 32) * 1024)
{
throw new IndexOutOfRangeException();
}
if (addr >= 256 * 1024)
{
return(iw.PeekByte(addr & 32767));
}
else
{
return(ew.PeekByte(addr));
}
},
delegate(long addr, byte val)
{
if (addr < 0 || addr >= (256 + 32) * 1024)
{
throw new IndexOutOfRangeException();
}
if (addr >= 256 * 1024)
{
iw.PokeByte(addr & 32767, val);
}
else
{
ew.PokeByte(addr, val);
}
}, 4);
_domainList.Add(cr);
}
_memoryDomains = new MemoryDomainList(_domainList);
(ServiceProvider as BasicServiceProvider).Register <IMemoryDomains>(_memoryDomains);
}
private unsafe void SetMemoryDomains()
{
var mm = new List <MemoryDomain>();
for (int i = LibGPGX.MIN_MEM_DOMAIN; i <= LibGPGX.MAX_MEM_DOMAIN; i++)
{
IntPtr area = IntPtr.Zero;
int size = 0;
IntPtr pname = LibGPGX.gpgx_get_memdom(i, ref area, ref size);
if (area == IntPtr.Zero || pname == IntPtr.Zero || size == 0)
{
continue;
}
string name = Marshal.PtrToStringAnsi(pname);
if (name == "VRAM")
{
// vram pokes need to go through hook which invalidates cached tiles
byte *p = (byte *)area;
mm.Add(new MemoryDomainDelegate(name, size, MemoryDomain.Endian.Unknown,
delegate(long addr)
{
if (addr < 0 || addr >= 65536)
{
throw new ArgumentOutOfRangeException();
}
return(p[addr ^ 1]);
},
delegate(long addr, byte val)
{
if (addr < 0 || addr >= 65536)
{
throw new ArgumentOutOfRangeException();
}
LibGPGX.gpgx_poke_vram(((int)addr) ^ 1, val);
},
wordSize: 2));
}
else
{
// TODO: are the Z80 domains really Swap16 in the core? Check this
//var byteSize = name.Contains("Z80") ? 1 : 2;
mm.Add(MemoryDomain.FromIntPtrSwap16(name, size,
MemoryDomain.Endian.Big, area, name != "MD CART" && name != "CD BOOT ROM"));
}
}
var m68Bus = new MemoryDomainDelegate("M68K BUS", 0x1000000, MemoryDomain.Endian.Big,
delegate(long addr)
{
var a = (uint)addr;
if (a >= 0x1000000)
{
throw new ArgumentOutOfRangeException();
}
return(LibGPGX.gpgx_peek_m68k_bus(a));
},
delegate(long addr, byte val)
{
var a = (uint)addr;
if (a >= 0x1000000)
{
throw new ArgumentOutOfRangeException();
}
LibGPGX.gpgx_write_m68k_bus(a, val);
}, 2);
mm.Add(m68Bus);
var s68Bus = new MemoryDomainDelegate("S68K BUS", 0x1000000, MemoryDomain.Endian.Big,
delegate(long addr)
{
var a = (uint)addr;
if (a >= 0x1000000)
{
throw new ArgumentOutOfRangeException();
}
return(LibGPGX.gpgx_peek_s68k_bus(a));
},
delegate(long addr, byte val)
{
var a = (uint)addr;
if (a >= 0x1000000)
{
throw new ArgumentOutOfRangeException();
}
LibGPGX.gpgx_write_s68k_bus(a, val);
}, 2);
if (IsSegaCD)
{
mm.Add(s68Bus);
}
MemoryDomains = new MemoryDomainList(mm);
MemoryDomains.SystemBus = m68Bus;
(ServiceProvider as BasicServiceProvider).Register <IMemoryDomains>(MemoryDomains);
}
private void MakeMemoryDomain(string name, mupen64plusApi.N64_MEMORY id, MemoryDomain.Endian endian, bool swizzled = false)
{
int size = api.get_memory_size(id);
//if this type of memory isnt available, don't make the memory domain
if (size == 0)
{
return;
}
IntPtr memPtr = api.get_memory_ptr(id);
Func <long, byte> peekByte;
Action <long, byte> pokeByte;
if (swizzled)
{
peekByte = addr =>
{
if (addr < 0 || addr >= size)
{
throw new ArgumentOutOfRangeException();
}
return(Marshal.ReadByte(memPtr, (int)(addr ^ 3)));
};
pokeByte = (addr, val) =>
{
if (addr < 0 || addr >= size)
{
throw new ArgumentOutOfRangeException();
}
Marshal.WriteByte(memPtr, (int)(addr ^ 3), val);
};
}
else
{
peekByte = addr =>
{
if (addr < 0 || addr >= size)
{
throw new ArgumentOutOfRangeException();
}
return(Marshal.ReadByte(memPtr, (int)(addr)));
};
pokeByte = (addr, val) =>
{
if (addr < 0 || addr >= size)
{
throw new ArgumentOutOfRangeException();
}
Marshal.WriteByte(memPtr, (int)(addr), val);
};
}
var md = new MemoryDomainDelegate(name, size, endian, peekByte, pokeByte, 4);
_memoryDomains.Add(md);
}
private unsafe void MakeMemoryDomain(string name, LibsnesApi.SNES_MEMORY id, MemoryDomain.Endian endian, int byteSize = 1)
{
int size = Api.QUERY_get_memory_size(id);
int mask = size - 1;
bool pow2 = Util.IsPowerOfTwo(size);
// if this type of memory isnt available, dont make the memory domain (most commonly save ram)
if (size == 0)
{
return;
}
byte *blockptr = Api.QUERY_get_memory_data(id);
MemoryDomain md;
if (id == LibsnesApi.SNES_MEMORY.OAM)
{
// OAM is actually two differently sized banks of memory which arent truly considered adjacent.
// maybe a better way to visualize it is with an empty bus and adjacent banks
// so, we just throw away everything above its size of 544 bytes
if (size != 544)
{
throw new InvalidOperationException("oam size isnt 544 bytes.. wtf?");
}
md = new MemoryDomainDelegate(
name,
size,
endian,
addr => addr < 544 ? blockptr[addr] : (byte)0x00,
(addr, value) => { if (addr < 544)
{
blockptr[addr] = value;
}
},
byteSize);
}
else if (pow2)
{
md = new MemoryDomainDelegate(
name,
size,
endian,
addr => blockptr[addr & mask],
(addr, value) => blockptr[addr & mask] = value,
byteSize);
}
else
{
md = new MemoryDomainDelegate(
name,
size,
endian,
addr => blockptr[addr % size],
(addr, value) => blockptr[addr % size] = value,
byteSize);
}
_memoryDomainList.Add(md);
}
private void InitMemoryDomains()
{
var mm = new List <MemoryDomain>();
var s = new LibVBANext.MemoryAreas();
var l = MemoryDomain.Endian.Little;
LibVBANext.GetMemoryAreas(Core, s);
mm.Add(MemoryDomain.FromIntPtr("IWRAM", 32 * 1024, l, s.iwram, true, 4));
mm.Add(MemoryDomain.FromIntPtr("EWRAM", 256 * 1024, l, s.ewram, true, 4));
mm.Add(MemoryDomain.FromIntPtr("BIOS", 16 * 1024, l, s.bios, false, 4));
mm.Add(MemoryDomain.FromIntPtr("PALRAM", 1024, l, s.palram, false, 4));
mm.Add(MemoryDomain.FromIntPtr("VRAM", 96 * 1024, l, s.vram, true, 4));
mm.Add(MemoryDomain.FromIntPtr("OAM", 1024, l, s.oam, true, 4));
mm.Add(MemoryDomain.FromIntPtr("ROM", 32 * 1024 * 1024, l, s.rom, true, 4));
mm.Add(MemoryDomain.FromIntPtr("SRAM", s.sram_size, l, s.sram, true, 4));
mm.Add(new MemoryDomainDelegate("System Bus", 0x10000000, l,
delegate(long addr)
{
if (addr < 0 || addr >= 0x10000000)
{
throw new ArgumentOutOfRangeException();
}
return(LibVBANext.SystemBusRead(Core, (int)addr));
},
delegate(long addr, byte val)
{
if (addr < 0 || addr >= 0x10000000)
{
throw new ArgumentOutOfRangeException();
}
LibVBANext.SystemBusWrite(Core, (int)addr, val);
}, 4));
// special combined ram memory domain
{
var ew = mm[1];
var iw = mm[0];
MemoryDomain cr = new MemoryDomainDelegate("Combined WRAM", (256 + 32) * 1024, MemoryDomain.Endian.Little,
delegate(long addr)
{
if (addr < 0 || addr >= (256 + 32) * 1024)
{
throw new IndexOutOfRangeException();
}
if (addr >= 256 * 1024)
{
return(iw.PeekByte(addr & 32767));
}
else
{
return(ew.PeekByte(addr));
}
},
delegate(long addr, byte val)
{
if (addr < 0 || addr >= (256 + 32) * 1024)
{
throw new IndexOutOfRangeException();
}
if (addr >= 256 * 1024)
{
iw.PokeByte(addr & 32767, val);
}
else
{
ew.PokeByte(addr, val);
}
}, 4);
mm.Add(cr);
}
_memoryDomains = new MemoryDomainList(mm);
(ServiceProvider as BasicServiceProvider).Register <IMemoryDomains>(_memoryDomains);
}
private unsafe void SetMemoryDomains()
{
var mm = new List <MemoryDomain>();
for (int i = LibGPGX.MIN_MEM_DOMAIN; i <= LibGPGX.MAX_MEM_DOMAIN; i++)
{
IntPtr area = IntPtr.Zero;
int size = 0;
IntPtr pname = LibGPGX.gpgx_get_memdom(i, ref area, ref size);
if (area == IntPtr.Zero || pname == IntPtr.Zero || size == 0)
{
continue;
}
string name = Marshal.PtrToStringAnsi(pname);
if (name == "VRAM")
{
// vram pokes need to go through hook which invalidates cached tiles
byte *p = (byte *)area;
mm.Add(new MemoryDomainDelegate(name, size, MemoryDomain.Endian.Unknown,
delegate(long addr)
{
if (addr < 0 || addr >= 65536)
{
throw new ArgumentOutOfRangeException();
}
return(p[addr ^ 1]);
},
delegate(long addr, byte val)
{
if (addr < 0 || addr >= 65536)
{
throw new ArgumentOutOfRangeException();
}
LibGPGX.gpgx_poke_vram(((int)addr) ^ 1, val);
},
wordSize: 2));
}
else
{
// TODO: are the Z80 domains really Swap16 in the core? Check this
//var byteSize = name.Contains("Z80") ? 1 : 2;
mm.Add(new MemoryDomainIntPtrSwap16(name, MemoryDomain.Endian.Big, area, size, name != "MD CART" && name != "CD BOOT ROM"));
}
}
//it's gross for this not to be the full 32bits.
//Uhh I mean, I guess the bus is physically smaller.. but the cpu's view of it is larger...
//So... I guess no matter what we do, some badness will propagate. This is probably least bad.
//Anyway, the disassembler, for instance, must have been masked down to size, since code can run from FFxxxxxxxx...
var m68Bus = new MemoryDomainDelegate("M68K BUS", 0x1000000, MemoryDomain.Endian.Big,
delegate(long addr)
{
var a = (uint)addr;
if (a >= 0x1000000)
{
throw new ArgumentOutOfRangeException();
}
return(LibGPGX.gpgx_peek_m68k_bus(a));
},
delegate(long addr, byte val)
{
var a = (uint)addr;
if (a >= 0x1000000)
{
throw new ArgumentOutOfRangeException();
}
LibGPGX.gpgx_write_m68k_bus(a, val);
}, 2);
mm.Add(m68Bus);
var s68Bus = new MemoryDomainDelegate("S68K BUS", 0x1000000, MemoryDomain.Endian.Big,
delegate(long addr)
{
var a = (uint)addr;
if (a >= 0x1000000)
{
throw new ArgumentOutOfRangeException();
}
return(LibGPGX.gpgx_peek_s68k_bus(a));
},
delegate(long addr, byte val)
{
var a = (uint)addr;
if (a >= 0x1000000)
{
throw new ArgumentOutOfRangeException();
}
LibGPGX.gpgx_write_s68k_bus(a, val);
}, 2);
if (IsSegaCD)
{
mm.Add(s68Bus);
}
MemoryDomains = new MemoryDomainList(mm);
MemoryDomains.SystemBus = m68Bus;
(ServiceProvider as BasicServiceProvider).Register <IMemoryDomains>(MemoryDomains);
}
void SetupMemoryDomains()
{
var domains = new List <MemoryDomain>(10);
int mainmemorymask = Ram.Length - 1;
var MainMemoryDomain = new MemoryDomainByteArray("Main Memory", MemoryDomain.Endian.Little, Ram, true, 1);
domains.Add(MainMemoryDomain);
var SystemBusDomain = new MemoryDomainDelegate("System Bus (21 bit)", 0x200000, MemoryDomain.Endian.Little,
(addr) =>
{
if (addr < 0 || addr >= 0x200000)
{
throw new ArgumentOutOfRangeException();
}
return(Cpu.ReadMemory21((int)addr));
},
(addr, value) =>
{
if (addr < 0 || addr >= 0x200000)
{
throw new ArgumentOutOfRangeException();
}
Cpu.WriteMemory21((int)addr, value);
},
wordSize: 2);
domains.Add(SystemBusDomain);
var CpuBusDomain = new MemoryDomainDelegate("System Bus", 0x10000, MemoryDomain.Endian.Little,
(addr) =>
{
if (addr < 0 || addr >= 0x10000)
{
throw new ArgumentOutOfRangeException();
}
return(Cpu.ReadMemory((ushort)addr));
},
(addr, value) =>
{
if (addr < 0 || addr >= 0x10000)
{
throw new ArgumentOutOfRangeException();
}
Cpu.WriteMemory((ushort)addr, value);
},
wordSize: 2);
domains.Add(CpuBusDomain);
var RomDomain = new MemoryDomainByteArray("ROM", MemoryDomain.Endian.Little, RomData, true, 1);
domains.Add(RomDomain);
if (BRAM != null)
{
var BRAMMemoryDomain = new MemoryDomainByteArray("Battery RAM", MemoryDomain.Endian.Little, BRAM, true, 1);
domains.Add(BRAMMemoryDomain);
}
if (TurboCD)
{
var CDRamMemoryDomain = new MemoryDomainByteArray("TurboCD RAM", MemoryDomain.Endian.Little, CDRam, true, 1);
domains.Add(CDRamMemoryDomain);
var AdpcmMemoryDomain = new MemoryDomainByteArray("ADPCM RAM", MemoryDomain.Endian.Little, ADPCM.RAM, true, 1);
domains.Add(AdpcmMemoryDomain);
if (SuperRam != null)
{
var SuperRamMemoryDomain = new MemoryDomainByteArray("Super System Card RAM", MemoryDomain.Endian.Little, SuperRam, true, 1);
domains.Add(SuperRamMemoryDomain);
}
}
if (ArcadeCard)
{
var ArcadeRamMemoryDomain = new MemoryDomainByteArray("Arcade Card RAM", MemoryDomain.Endian.Little, ArcadeRam, true, 1);
}
if (PopulousRAM != null)
{
var PopulusRAMDomain = new MemoryDomainByteArray("Cart Battery RAM", MemoryDomain.Endian.Little, PopulousRAM, true, 1);
domains.Add(PopulusRAMDomain);
}
memoryDomains = new MemoryDomainList(domains);
(ServiceProvider as BasicServiceProvider).Register <IMemoryDomains>(memoryDomains);
}
public void SetupMemoryDomains()
{
var domains = new List <MemoryDomain>
{
new MemoryDomainDelegate(
"WRAM",
RAM.Length,
MemoryDomain.Endian.Little,
addr => PeekRAM(addr),
(addr, value) => RAM[addr] = value,
1),
new MemoryDomainDelegate(
"ROM",
_rom.Length,
MemoryDomain.Endian.Little,
addr => _rom[addr],
(addr, value) => _rom[addr] = value,
1),
new MemoryDomainDelegate(
"VRAM",
VRAM.Length,
MemoryDomain.Endian.Little,
addr => PeekVRAM(addr),
(addr, value) => VRAM[addr] = value,
1),
new MemoryDomainDelegate(
"OAM",
OAM.Length,
MemoryDomain.Endian.Little,
addr => PeekOAM(addr),
(addr, value) => OAM[addr] = value,
1),
new MemoryDomainDelegate(
"HRAM",
ZP_RAM.Length,
MemoryDomain.Endian.Little,
addr => PeekHRAM(addr),
(addr, value) => ZP_RAM[addr] = value,
1),
new MemoryDomainDelegate(
"System Bus",
0X10000,
MemoryDomain.Endian.Little,
addr => PeekSystemBus(addr),
(addr, value) => PokeSystemBus(addr, value),
1),
};
if (cart_RAM != null)
{
var CartRam = new MemoryDomainDelegate(
"CartRAM",
cart_RAM.Length,
MemoryDomain.Endian.Little,
addr => PeekCART(addr),
(addr, value) => cart_RAM[addr] = value,
1);
domains.Add(CartRam);
}
MemoryDomains = new MemoryDomainList(domains);
(ServiceProvider as BasicServiceProvider).Register <IMemoryDomains>(MemoryDomains);
}
