コード例 #1
0
        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);
        }
コード例 #2
0
        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);
        }
コード例 #3
0
        private void SetupMemoryDomains(byte[] romData, byte[] sgbRomData)
        {
            // lets just do this entirely differently for SGB
            if (IsSGB)
            {
                // NOTE: CGB has 32K of wram, and DMG has 8KB of wram. Not sure how to control this right now.. bsnes might not have any ready way of doign that? I couldnt spot it.
                // You wouldnt expect a DMG game to access excess wram, but what if it tried to? maybe an oversight in bsnes?
                MakeMemoryDomain("SGB WRAM", LibsnesApi.SNES_MEMORY.SGB_WRAM, MemoryDomain.Endian.Little);

                var romDomain = new MemoryDomainByteArray("SGB CARTROM", MemoryDomain.Endian.Little, romData, true, 1);
                _memoryDomainList.Add(romDomain);

                // the last 1 byte of this is special.. its an interrupt enable register, instead of ram. weird. maybe its actually ram and just getting specially used?
                MakeMemoryDomain("SGB HRAM", LibsnesApi.SNES_MEMORY.SGB_HRAM, MemoryDomain.Endian.Little);

                MakeMemoryDomain("SGB CARTRAM", LibsnesApi.SNES_MEMORY.SGB_CARTRAM, MemoryDomain.Endian.Little);

                MakeMemoryDomain("WRAM", LibsnesApi.SNES_MEMORY.WRAM, MemoryDomain.Endian.Little);

                var sgbromDomain = new MemoryDomainByteArray("SGB.SFC ROM", MemoryDomain.Endian.Little, sgbRomData, true, 1);
                _memoryDomainList.Add(sgbromDomain);
            }
            else
            {
                MakeMemoryDomain("WRAM", LibsnesApi.SNES_MEMORY.WRAM, MemoryDomain.Endian.Little);

                MakeMemoryDomain("CARTROM", LibsnesApi.SNES_MEMORY.CARTRIDGE_ROM, MemoryDomain.Endian.Little, byteSize: 2);
                MakeMemoryDomain("CARTRAM", LibsnesApi.SNES_MEMORY.CARTRIDGE_RAM, MemoryDomain.Endian.Little, byteSize: 2);
                MakeMemoryDomain("VRAM", LibsnesApi.SNES_MEMORY.VRAM, MemoryDomain.Endian.Little, byteSize: 2);
                MakeMemoryDomain("OAM", LibsnesApi.SNES_MEMORY.OAM, MemoryDomain.Endian.Little, byteSize: 2);
                MakeMemoryDomain("CGRAM", LibsnesApi.SNES_MEMORY.CGRAM, MemoryDomain.Endian.Little, byteSize: 2);
                MakeMemoryDomain("APURAM", LibsnesApi.SNES_MEMORY.APURAM, MemoryDomain.Endian.Little, byteSize: 2);

                if (!DeterministicEmulation)
                {
                    _memoryDomainList.Add(new MemoryDomainDelegate(
                                              "System Bus",
                                              0x1000000,
                                              MemoryDomain.Endian.Little,
                                              addr => Api.QUERY_peek(LibsnesApi.SNES_MEMORY.SYSBUS, (uint)addr),
                                              (addr, val) => Api.QUERY_poke(LibsnesApi.SNES_MEMORY.SYSBUS, (uint)addr, val), wordSize: 2));
                }
                else
                {
                    // limited function bus
                    MakeFakeBus();
                }
            }

            _memoryDomains = new MemoryDomainList(_memoryDomainList);
            (ServiceProvider as BasicServiceProvider).Register <IMemoryDomains>(_memoryDomains);
        }
コード例 #4
0
 private void SyncByteArrayDomain(string name, byte[] data)
 {
     if (_memoryDomainsInit || _byteArrayDomains.ContainsKey(name))
     {
         var m = _byteArrayDomains[name];
         m.Data = data;
     }
     else
     {
         var m = new MemoryDomainByteArray(name, MemoryDomain.Endian.Little, data, true, 1);
         _byteArrayDomains.Add(name, m);
     }
 }
コード例 #5
0
        public void SetupMemoryDomains()
        {
            var domains = new List <MemoryDomain>
            {
                new MemoryDomainDelegate(
                    "Main RAM",
                    RAM.Length,
                    MemoryDomain.Endian.Little,
                    addr => RAM[addr],
                    (addr, value) => RAM[addr] = value,
                    1),
                new MemoryDomainDelegate(
                    "Zero Page RAM",
                    ZP_RAM.Length,
                    MemoryDomain.Endian.Little,
                    addr => ZP_RAM[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),
                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 => VRAM[addr],
                    (addr, value) => VRAM[addr] = value,
                    1)
            };

            if (cart_RAM != null)
            {
                var CartRam = new MemoryDomainByteArray("Cart RAM", MemoryDomain.Endian.Little, cart_RAM, true, 1);
                domains.Add(CartRam);
            }

            MemoryDomains = new MemoryDomainList(domains);
            (ServiceProvider as BasicServiceProvider).Register <IMemoryDomains>(MemoryDomains);
        }
コード例 #6
0
        public void SetupMemoryDomains()
        {
            var domains = new List <MemoryDomain>
            {
                new MemoryDomainDelegate(
                    "Main RAM",
                    RAM.Length,
                    MemoryDomain.Endian.Little,
                    addr => RAM[addr],
                    (addr, value) => RAM[addr] = value,
                    1),
                new MemoryDomainDelegate(
                    "CPU RAM",
                    64,
                    MemoryDomain.Endian.Little,
                    addr => (byte)cpu.Regs[addr],
                    (addr, value) => cpu.Regs[addr] = value,
                    1),
                new MemoryDomainDelegate(
                    "System Bus",
                    0X1000,
                    MemoryDomain.Endian.Little,
                    addr => PeekSystemBus(addr),
                    (addr, value) => PokeSystemBus(addr, value),
                    1),
                new MemoryDomainDelegate(
                    "ROM",
                    _rom.Length,
                    MemoryDomain.Endian.Little,
                    addr => _rom[addr],
                    (addr, value) => _rom[addr] = value,
                    1),
                new MemoryDomainDelegate(
                    "PPU",
                    256,
                    MemoryDomain.Endian.Little,
                    addr => ppu.PeekReg((int)addr),
                    (addr, value) => ppu.WriteReg((int)addr, value),
                    1)
            };

            if (cart_RAM != null)
            {
                var CartRam = new MemoryDomainByteArray("Cart RAM", MemoryDomain.Endian.Little, cart_RAM, true, 1);
                domains.Add(CartRam);
            }

            MemoryDomains = new MemoryDomainList(domains);
            (ServiceProvider as BasicServiceProvider).Register <IMemoryDomains>(MemoryDomains);
        }
コード例 #7
0
        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);
        }
コード例 #8
0
        private 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 (use_SGM)
            {
                var SGMLRam = new MemoryDomainByteArray("SGM Low RAM", MemoryDomain.Endian.Little, SGM_low_RAM, true, 1);
                domains.Add(SGMLRam);

                var SGMHRam = new MemoryDomainByteArray("SGM High RAM", MemoryDomain.Endian.Little, SGM_high_RAM, true, 1);
                domains.Add(SGMHRam);
            }

            SyncAllByteArrayDomains();

            memoryDomains = new MemoryDomainList(_byteArrayDomains.Values.Concat(domains).ToList());
            (ServiceProvider as BasicServiceProvider).Register <IMemoryDomains>(memoryDomains);

            _memoryDomainsInit = true;
        }
コード例 #9
0
        public void SetupMemoryDomains()
        {
            var domains = new List <MemoryDomain>
            {
                new MemoryDomainDelegate(
                    "Main RAM L",
                    L.RAM.Length,
                    MemoryDomain.Endian.Little,
                    addr => L.RAM[addr],
                    (addr, value) => L.RAM[addr] = value,
                    1),
                new MemoryDomainDelegate(
                    "Main RAM C",
                    C.RAM.Length,
                    MemoryDomain.Endian.Little,
                    addr => C.RAM[addr],
                    (addr, value) => C.RAM[addr] = value,
                    1),
                new MemoryDomainDelegate(
                    "Main RAM R",
                    R.RAM.Length,
                    MemoryDomain.Endian.Little,
                    addr => R.RAM[addr],
                    (addr, value) => R.RAM[addr] = value,
                    1),
                new MemoryDomainDelegate(
                    "Zero Page RAM L",
                    L.ZP_RAM.Length,
                    MemoryDomain.Endian.Little,
                    addr => L.ZP_RAM[addr],
                    (addr, value) => L.ZP_RAM[addr] = value,
                    1),
                new MemoryDomainDelegate(
                    "Zero Page RAM C",
                    C.ZP_RAM.Length,
                    MemoryDomain.Endian.Little,
                    addr => C.ZP_RAM[addr],
                    (addr, value) => C.ZP_RAM[addr] = value,
                    1),
                new MemoryDomainDelegate(
                    "Zero Page RAM R",
                    R.ZP_RAM.Length,
                    MemoryDomain.Endian.Little,
                    addr => R.ZP_RAM[addr],
                    (addr, value) => R.ZP_RAM[addr] = value,
                    1),
                new MemoryDomainDelegate(
                    "System Bus L",
                    0X10000,
                    MemoryDomain.Endian.Little,
                    PeekSystemBusL,
                    PokeSystemBusL,
                    1),
                new MemoryDomainDelegate(
                    "System Bus C",
                    0X10000,
                    MemoryDomain.Endian.Little,
                    PeekSystemBusC,
                    PokeSystemBusC,
                    1),
                new MemoryDomainDelegate(
                    "System Bus R",
                    0X10000,
                    MemoryDomain.Endian.Little,
                    PeekSystemBusR,
                    PokeSystemBusR,
                    1),
                new MemoryDomainDelegate(
                    "ROM L",
                    L._rom.Length,
                    MemoryDomain.Endian.Little,
                    addr => L._rom[addr],
                    (addr, value) => L._rom[addr] = value,
                    1),
                new MemoryDomainDelegate(
                    "ROM C",
                    C._rom.Length,
                    MemoryDomain.Endian.Little,
                    addr => C._rom[addr],
                    (addr, value) => C._rom[addr] = value,
                    1),
                new MemoryDomainDelegate(
                    "ROM R",
                    R._rom.Length,
                    MemoryDomain.Endian.Little,
                    addr => R._rom[addr],
                    (addr, value) => R._rom[addr] = value,
                    1),
                new MemoryDomainDelegate(
                    "VRAM L",
                    L.VRAM.Length,
                    MemoryDomain.Endian.Little,
                    addr => L.VRAM[addr],
                    (addr, value) => L.VRAM[addr] = value,
                    1),
                new MemoryDomainDelegate(
                    "VRAM C",
                    C.VRAM.Length,
                    MemoryDomain.Endian.Little,
                    addr => C.VRAM[addr],
                    (addr, value) => C.VRAM[addr] = value,
                    1),
                new MemoryDomainDelegate(
                    "VRAM R",
                    R.VRAM.Length,
                    MemoryDomain.Endian.Little,
                    addr => R.VRAM[addr],
                    (addr, value) => R.VRAM[addr] = value,
                    1)
            };

            if (L.cart_RAM != null)
            {
                var cartRamL = new MemoryDomainByteArray("Cart RAM L", MemoryDomain.Endian.Little, L.cart_RAM, true, 1);
                domains.Add(cartRamL);
            }

            if (C.cart_RAM != null)
            {
                var cartRamC = new MemoryDomainByteArray("Cart RAM C", MemoryDomain.Endian.Little, C.cart_RAM, true, 1);
                domains.Add(cartRamC);
            }

            if (R.cart_RAM != null)
            {
                var cartRamR = new MemoryDomainByteArray("Cart RAM R", MemoryDomain.Endian.Little, R.cart_RAM, true, 1);
                domains.Add(cartRamR);
            }

            MemoryDomains = new MemoryDomainList(domains);
            (ServiceProvider as BasicServiceProvider).Register <IMemoryDomains>(MemoryDomains);
        }
        public void SetupMemoryDomains()
        {
            var domains = new List <MemoryDomain>
            {
                new MemoryDomainDelegate(
                    "Main RAM A",
                    A.RAM.Length,
                    MemoryDomain.Endian.Little,
                    addr => A.RAM[addr],
                    (addr, value) => A.RAM[addr] = value,
                    1),
                new MemoryDomainDelegate(
                    "Main RAM B",
                    B.RAM.Length,
                    MemoryDomain.Endian.Little,
                    addr => B.RAM[addr],
                    (addr, value) => B.RAM[addr] = value,
                    1),
                new MemoryDomainDelegate(
                    "Main RAM C",
                    C.RAM.Length,
                    MemoryDomain.Endian.Little,
                    addr => C.RAM[addr],
                    (addr, value) => C.RAM[addr] = value,
                    1),
                new MemoryDomainDelegate(
                    "Main RAM D",
                    D.RAM.Length,
                    MemoryDomain.Endian.Little,
                    addr => D.RAM[addr],
                    (addr, value) => D.RAM[addr] = value,
                    1),
                new MemoryDomainDelegate(
                    "Zero Page RAM A",
                    A.ZP_RAM.Length,
                    MemoryDomain.Endian.Little,
                    addr => A.ZP_RAM[addr],
                    (addr, value) => A.ZP_RAM[addr] = value,
                    1),
                new MemoryDomainDelegate(
                    "Zero Page RAM B",
                    B.ZP_RAM.Length,
                    MemoryDomain.Endian.Little,
                    addr => B.ZP_RAM[addr],
                    (addr, value) => B.ZP_RAM[addr] = value,
                    1),
                new MemoryDomainDelegate(
                    "Zero Page RAM C",
                    C.ZP_RAM.Length,
                    MemoryDomain.Endian.Little,
                    addr => C.ZP_RAM[addr],
                    (addr, value) => C.ZP_RAM[addr] = value,
                    1),
                new MemoryDomainDelegate(
                    "Zero Page RAM D",
                    D.ZP_RAM.Length,
                    MemoryDomain.Endian.Little,
                    addr => D.ZP_RAM[addr],
                    (addr, value) => D.ZP_RAM[addr] = value,
                    1),
                new MemoryDomainDelegate(
                    "System Bus A",
                    0X10000,
                    MemoryDomain.Endian.Little,
                    PeekSystemBusA,
                    PokeSystemBusA,
                    1),
                new MemoryDomainDelegate(
                    "System Bus B",
                    0X10000,
                    MemoryDomain.Endian.Little,
                    PeekSystemBusB,
                    PokeSystemBusB,
                    1),
                new MemoryDomainDelegate(
                    "System Bus C",
                    0X10000,
                    MemoryDomain.Endian.Little,
                    PeekSystemBusC,
                    PokeSystemBusC,
                    1),
                new MemoryDomainDelegate(
                    "System Bus D",
                    0X10000,
                    MemoryDomain.Endian.Little,
                    PeekSystemBusD,
                    PokeSystemBusD,
                    1),
                new MemoryDomainDelegate(
                    "ROM A",
                    A._rom.Length,
                    MemoryDomain.Endian.Little,
                    addr => A._rom[addr],
                    (addr, value) => A._rom[addr] = value,
                    1),
                new MemoryDomainDelegate(
                    "ROM B",
                    B._rom.Length,
                    MemoryDomain.Endian.Little,
                    addr => B._rom[addr],
                    (addr, value) => B._rom[addr] = value,
                    1),
                new MemoryDomainDelegate(
                    "ROM C",
                    C._rom.Length,
                    MemoryDomain.Endian.Little,
                    addr => C._rom[addr],
                    (addr, value) => C._rom[addr] = value,
                    1),
                new MemoryDomainDelegate(
                    "ROM D",
                    D._rom.Length,
                    MemoryDomain.Endian.Little,
                    addr => D._rom[addr],
                    (addr, value) => D._rom[addr] = value,
                    1),
                new MemoryDomainDelegate(
                    "VRAM A",
                    A.VRAM.Length,
                    MemoryDomain.Endian.Little,
                    addr => A.VRAM[addr],
                    (addr, value) => A.VRAM[addr] = value,
                    1),
                new MemoryDomainDelegate(
                    "VRAM B",
                    B.VRAM.Length,
                    MemoryDomain.Endian.Little,
                    addr => B.VRAM[addr],
                    (addr, value) => B.VRAM[addr] = value,
                    1),
                new MemoryDomainDelegate(
                    "VRAM C",
                    C.VRAM.Length,
                    MemoryDomain.Endian.Little,
                    addr => C.VRAM[addr],
                    (addr, value) => C.VRAM[addr] = value,
                    1),
                new MemoryDomainDelegate(
                    "VRAM D",
                    D.VRAM.Length,
                    MemoryDomain.Endian.Little,
                    addr => D.VRAM[addr],
                    (addr, value) => D.VRAM[addr] = value,
                    1)
            };

            if (A.cart_RAM != null)
            {
                var cartRamA = new MemoryDomainByteArray("Cart RAM L", MemoryDomain.Endian.Little, A.cart_RAM, true, 1);
                domains.Add(cartRamA);
            }

            if (B.cart_RAM != null)
            {
                var cartRamB = new MemoryDomainByteArray("Cart RAM B", MemoryDomain.Endian.Little, B.cart_RAM, true, 1);
                domains.Add(cartRamB);
            }

            if (C.cart_RAM != null)
            {
                var cartRamC = new MemoryDomainByteArray("Cart RAM C", MemoryDomain.Endian.Little, C.cart_RAM, true, 1);
                domains.Add(cartRamC);
            }

            if (D.cart_RAM != null)
            {
                var cartRamD = new MemoryDomainByteArray("Cart RAM D", MemoryDomain.Endian.Little, D.cart_RAM, true, 1);
                domains.Add(cartRamD);
            }

            MemoryDomains = new MemoryDomainList(domains);
            (ServiceProvider as BasicServiceProvider).Register <IMemoryDomains>(MemoryDomains);
        }
コード例 #11
0
        public void SetupMemoryDomains()
        {
            var domains = new List <MemoryDomain>
            {
                new MemoryDomainDelegate(
                    "Main RAM L",
                    L.SystemRam.Length,
                    MemoryDomain.Endian.Little,
                    addr => L.SystemRam[addr],
                    (addr, value) => L.SystemRam[addr] = value,
                    1),
                new MemoryDomainDelegate(
                    "Main RAM R",
                    R.SystemRam.Length,
                    MemoryDomain.Endian.Little,
                    addr => R.SystemRam[addr],
                    (addr, value) => R.SystemRam[addr] = value,
                    1),
                new MemoryDomainDelegate(
                    "System Bus L",
                    0X10000,
                    MemoryDomain.Endian.Little,
                    addr => PeekSystemBusL(addr),
                    (addr, value) => PokeSystemBusL(addr, value),
                    1),
                new MemoryDomainDelegate(
                    "System Bus R",
                    0X10000,
                    MemoryDomain.Endian.Little,
                    addr => PeekSystemBusR(addr),
                    (addr, value) => PokeSystemBusR(addr, value),
                    1),
                new MemoryDomainDelegate(
                    "ROM L",
                    L.RomData.Length,
                    MemoryDomain.Endian.Little,
                    addr => L.RomData[addr],
                    (addr, value) => L.RomData[addr] = value,
                    1),
                new MemoryDomainDelegate(
                    "ROM R",
                    R.RomData.Length,
                    MemoryDomain.Endian.Little,
                    addr => R.RomData[addr],
                    (addr, value) => R.RomData[addr] = value,
                    1),
                new MemoryDomainDelegate(
                    "VRAM L",
                    L.Vdp.VRAM.Length,
                    MemoryDomain.Endian.Little,
                    addr => L.Vdp.VRAM[addr],
                    (addr, value) => L.Vdp.VRAM[addr] = value,
                    1),
                new MemoryDomainDelegate(
                    "VRAM R",
                    R.Vdp.VRAM.Length,
                    MemoryDomain.Endian.Little,
                    addr => R.Vdp.VRAM[addr],
                    (addr, value) => R.Vdp.VRAM[addr] = value,
                    1)
            };

            if (L.SaveRAM != null)
            {
                var CartRamL = new MemoryDomainByteArray("Cart RAM L", MemoryDomain.Endian.Little, L.SaveRAM, true, 1);
                domains.Add(CartRamL);
            }

            if (R.SaveRAM != null)
            {
                var CartRamR = new MemoryDomainByteArray("Cart RAM R", MemoryDomain.Endian.Little, R.SaveRAM, true, 1);
                domains.Add(CartRamR);
            }

            MemoryDomains = new MemoryDomainList(domains);
            (ServiceProvider as BasicServiceProvider).Register <IMemoryDomains>(MemoryDomains);
        }
コード例 #12
0
ファイル: PCEngine.cs プロジェクト: ben-eirich/BizHawk
        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);
        }