ShuriZma
/
BizHawk
mirror of https://github.com/TASEmulators/BizHawk.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

More consistency, restore layer masks

This commit is contained in:
MrWint 2019-05-28 00:26:59 +02:00
parent 1547d324e7
commit bc2ced1b7f
17 changed files with 129 additions and 155 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
libgambatte/include/gambatte.h
View File

@ -66,7 +66,7 @@ public:
*/ */
LoadRes load(char const *romfiledata, unsigned romfilelength, std::uint32_t now, unsigned flags, unsigned div); LoadRes load(char const *romfiledata, unsigned romfilelength, std::uint32_t now, unsigned flags, unsigned div);
int loadBios(char const* biosfiledata, std::size_t size); int loadBios(char const *biosfiledata, std::size_t size);
/** /**
* Emulates until at least 'samples' audio samples are produced in the * Emulates until at least 'samples' audio samples are produced in the
@ -143,7 +143,7 @@ public:
bool getMemoryArea(int which, unsigned char **data, int *length); bool getMemoryArea(int which, unsigned char **data, int *length);
/** ROM header title of currently loaded ROM image. */ /** ROM header title of currently loaded ROM image. */
const std::string romTitle() const; std::string const romTitle() const;
unsigned char externalRead(unsigned short addr); unsigned char externalRead(unsigned short addr);
void externalWrite(unsigned short addr, unsigned char val); void externalWrite(unsigned short addr, unsigned char val);

146
libgambatte/src/cinterface.cpp
View File

@ -1,200 +1,183 @@
//
// Copyright (C) 2007 by sinamas <sinamas at users.sourceforge.net>
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License version 2 as
// published by the Free Software Foundation.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License version 2 for more details.
//
// You should have received a copy of the GNU General Public License
// version 2 along with this program; if not, write to the
// Free Software Foundation, Inc.,
// 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
//
#include "cinterface.h" #include "cinterface.h"
#include "gambatte.h" #include "gambatte.h"
#include <cstdlib> #include <cstdlib>
#include <cstring> #include <cstring>
#include "newstate.h" #include "newstate.h"
using namespace gambatte;
// new is actually called in a few different places, so replace all of them for determinism guarantees // new is actually called in a few different places, so replace all of them for determinism guarantees
void *operator new(std::size_t n) void *operator new(std::size_t n) {
{
void *p = std::malloc(n); void *p = std::malloc(n);
std::memset(p, 0, n); std::memset(p, 0, n);
return p; return p;
} }
void operator delete(void *p) void operator delete(void *p) {
{
std::free(p); std::free(p);
} }
GBEXPORT GB *gambatte_create() namespace {
{
using namespace gambatte;
GBEXPORT GB * gambatte_create() {
return new GB(); return new GB();
} }
GBEXPORT void gambatte_destroy(GB *g) GBEXPORT void gambatte_destroy(GB *g) {
{
delete g; delete g;
} }
GBEXPORT int gambatte_load(GB *g, char const *romfiledata, unsigned romfilelength, long long now, unsigned flags, unsigned div) GBEXPORT int gambatte_load(GB *g, char const *romfiledata, unsigned romfilelength, long long now, unsigned flags, unsigned div) {
{ return g->load(romfiledata, romfilelength, now, flags, div);
int ret = g->load(romfiledata, romfilelength, now, flags, div);
return ret;
} }
GBEXPORT int gambatte_loadbios(GB* g, char const* biosfiledata, unsigned size) GBEXPORT int gambatte_loadbios(GB *g, char const *biosfiledata, unsigned size) {
{ return g->loadBios(biosfiledata, size);
int ret = g->loadBios(biosfiledata, size);
return ret;
} }
GBEXPORT int gambatte_runfor(GB *g, short *soundbuf, unsigned *samples) GBEXPORT int gambatte_runfor(GB *g, short *soundbuf, unsigned *samples) {
{
std::size_t sampv = *samples; std::size_t sampv = *samples;
int ret = g->runFor((unsigned int *) soundbuf, sampv); int ret = g->runFor((unsigned int *) soundbuf, sampv);
*samples = sampv; *samples = sampv;
return ret; return ret;
} }
GBEXPORT void gambatte_blitto(GB *g, unsigned int *videobuf, int pitch) GBEXPORT void gambatte_blitto(GB *g, unsigned int *videobuf, int pitch) {
{
g->blitTo((unsigned int *)videobuf, pitch); g->blitTo((unsigned int *)videobuf, pitch);
} }
GBEXPORT void gambatte_setlayers(GB *g, unsigned mask) GBEXPORT void gambatte_setlayers(GB *g, unsigned mask) {
{
g->setLayers(mask); g->setLayers(mask);
} }
GBEXPORT void gambatte_reset(GB *g, long long now, unsigned div) GBEXPORT void gambatte_reset(GB *g, long long now, unsigned div) {
{
g->reset(now, div); g->reset(now, div);
} }
GBEXPORT void gambatte_setdmgpalettecolor(GB *g, unsigned palnum, unsigned colornum, unsigned rgb32) GBEXPORT void gambatte_setdmgpalettecolor(GB *g, unsigned palnum, unsigned colornum, unsigned rgb32) {
{
g->setDmgPaletteColor(palnum, colornum, rgb32); g->setDmgPaletteColor(palnum, colornum, rgb32);
} }
GBEXPORT void gambatte_setcgbpalette(GB *g, unsigned *lut) GBEXPORT void gambatte_setcgbpalette(GB *g, unsigned *lut) {
{
g->setCgbPalette(lut); g->setCgbPalette(lut);
} }
GBEXPORT void gambatte_setinputgetter(GB *g, unsigned (*getinput)(void)) GBEXPORT void gambatte_setinputgetter(GB *g, unsigned (*getinput)(void)) {
{
g->setInputGetter(getinput); g->setInputGetter(getinput);
} }
GBEXPORT void gambatte_setreadcallback(GB *g, MemoryCallback callback) GBEXPORT void gambatte_setreadcallback(GB *g, MemoryCallback callback) {
{
g->setReadCallback(callback); g->setReadCallback(callback);
} }
GBEXPORT void gambatte_setwritecallback(GB *g, MemoryCallback callback) GBEXPORT void gambatte_setwritecallback(GB *g, MemoryCallback callback) {
{
g->setWriteCallback(callback); g->setWriteCallback(callback);
} }
GBEXPORT void gambatte_setexeccallback(GB *g, MemoryCallback callback) GBEXPORT void gambatte_setexeccallback(GB *g, MemoryCallback callback) {
{
g->setExecCallback(callback); g->setExecCallback(callback);
} }
GBEXPORT void gambatte_setcdcallback(GB *g, CDCallback cdc) GBEXPORT void gambatte_setcdcallback(GB *g, CDCallback cdc) {
{
g->setCDCallback(cdc); g->setCDCallback(cdc);
} }
GBEXPORT void gambatte_settracecallback(GB *g, void (*callback)(void *)) GBEXPORT void gambatte_settracecallback(GB *g, void (*callback)(void *)) {
{
g->setTraceCallback(callback); g->setTraceCallback(callback);
} }
GBEXPORT void gambatte_setscanlinecallback(GB *g, void (*callback)(), int sl) GBEXPORT void gambatte_setscanlinecallback(GB *g, void (*callback)(), int sl) {
{
g->setScanlineCallback(callback, sl); g->setScanlineCallback(callback, sl);
} }
GBEXPORT void gambatte_setrtccallback(GB *g, unsigned int (*callback)()) GBEXPORT void gambatte_setrtccallback(GB *g, unsigned int (*callback)()) {
{
g->setRTCCallback(callback); g->setRTCCallback(callback);
} }
GBEXPORT void gambatte_setlinkcallback(GB *g, void(*callback)()) GBEXPORT void gambatte_setlinkcallback(GB *g, void(*callback)()) {
{
g->setLinkCallback(callback); g->setLinkCallback(callback);
} }
GBEXPORT int gambatte_iscgb(GB *g) GBEXPORT int gambatte_iscgb(GB *g) {
{
return g->isCgb(); return g->isCgb();
} }
GBEXPORT int gambatte_isloaded(GB *g) GBEXPORT int gambatte_isloaded(GB *g) {
{
return g->isLoaded(); return g->isLoaded();
} }
GBEXPORT void gambatte_savesavedata(GB *g, char *dest) GBEXPORT void gambatte_savesavedata(GB *g, char *dest) {
{
g->saveSavedata(dest); g->saveSavedata(dest);
} }
GBEXPORT void gambatte_loadsavedata(GB *g, char const *data) GBEXPORT void gambatte_loadsavedata(GB *g, char const *data) {
{
g->loadSavedata(data); g->loadSavedata(data);
} }
GBEXPORT int gambatte_savesavedatalength(GB *g) GBEXPORT int gambatte_savesavedatalength(GB *g) {
{
return g->saveSavedataLength(); return g->saveSavedataLength();
} }
GBEXPORT int gambatte_newstatelen(GB *g) GBEXPORT int gambatte_newstatelen(GB *g) {
{
NewStateDummy dummy; NewStateDummy dummy;
g->SyncState<false>(&dummy); g->SyncState<false>(&dummy);
return dummy.GetLength(); return dummy.GetLength();
} }
GBEXPORT int gambatte_newstatesave(GB *g, char *data, int len) GBEXPORT int gambatte_newstatesave(GB *g, char *data, int len) {
{
NewStateExternalBuffer saver(data, len); NewStateExternalBuffer saver(data, len);
g->SyncState<false>(&saver); g->SyncState<false>(&saver);
return !saver.Overflow() && saver.GetLength() == len; return !saver.Overflow() && saver.GetLength() == len;
} }
GBEXPORT int gambatte_newstateload(GB *g, char const *data, int len) GBEXPORT int gambatte_newstateload(GB *g, char const *data, int len) {
{
NewStateExternalBuffer loader((char *)data, len); NewStateExternalBuffer loader((char *)data, len);
g->SyncState<true>(&loader); g->SyncState<true>(&loader);
return !loader.Overflow() && loader.GetLength() == len; return !loader.Overflow() && loader.GetLength() == len;
} }
GBEXPORT void gambatte_newstatesave_ex(GB *g, FPtrs *ff) GBEXPORT void gambatte_newstatesave_ex(GB *g, FPtrs *ff) {
{
NewStateExternalFunctions saver(ff); NewStateExternalFunctions saver(ff);
g->SyncState<false>(&saver); g->SyncState<false>(&saver);
} }
GBEXPORT void gambatte_newstateload_ex(GB *g, FPtrs *ff) GBEXPORT void gambatte_newstateload_ex(GB *g, FPtrs *ff) {
{
NewStateExternalFunctions loader(ff); NewStateExternalFunctions loader(ff);
g->SyncState<true>(&loader); g->SyncState<true>(&loader);
} }
GBEXPORT void gambatte_romtitle(GB *g, char *dest) GBEXPORT void gambatte_romtitle(GB *g, char *dest) {
{
std::strcpy(dest, g->romTitle().c_str()); std::strcpy(dest, g->romTitle().c_str());
} }
GBEXPORT int gambatte_getmemoryarea(GB *g, int which, unsigned char **data, int *length) GBEXPORT int gambatte_getmemoryarea(GB *g, int which, unsigned char **data, int *length) {
{
return g->getMemoryArea(which, data, length); return g->getMemoryArea(which, data, length);
} }
GBEXPORT unsigned char gambatte_cpuread(GB *g, unsigned short addr) GBEXPORT unsigned char gambatte_cpuread(GB *g, unsigned short addr) {
{
return g->externalRead(addr); return g->externalRead(addr);
} }
GBEXPORT void gambatte_cpuwrite(GB *g, unsigned short addr, unsigned char val) GBEXPORT void gambatte_cpuwrite(GB *g, unsigned short addr, unsigned char val) {
{
g->externalWrite(addr, val); g->externalWrite(addr, val);
} }
@ -203,17 +186,16 @@ GBEXPORT int gambatte_linkstatus(GB *g, int which)
return g->linkStatus(which); return g->linkStatus(which);
} }
GBEXPORT void gambatte_getregs(GB *g, int *dest) GBEXPORT void gambatte_getregs(GB *g, int *dest) {
{
g->getRegs(dest); g->getRegs(dest);
} }
GBEXPORT void gambatte_setinterruptaddresses(GB *g, int *addrs, int numAddrs) GBEXPORT void gambatte_setinterruptaddresses(GB *g, int *addrs, int numAddrs) {
{
g->setInterruptAddresses(addrs, numAddrs); g->setInterruptAddresses(addrs, numAddrs);
} }
GBEXPORT int gambatte_gethitinterruptaddress(GB *g) GBEXPORT int gambatte_gethitinterruptaddress(GB *g) {
{
return g->getHitInterruptAddress(); return g->getHitInterruptAddress();
} }
}

18
libgambatte/src/cinterface.h
View File

@ -1,3 +1,21 @@
//
// Copyright (C) 2007 by sinamas <sinamas at users.sourceforge.net>
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License version 2 as
// published by the Free Software Foundation.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License version 2 for more details.
//
// You should have received a copy of the GNU General Public License
// version 2 along with this program; if not, write to the
// Free Software Foundation, Inc.,
// 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
//
#ifndef CINTERFACE_H #ifndef CINTERFACE_H
#define CINTERFACE_H #define CINTERFACE_H

2
libgambatte/src/cpu.cpp
View File

@ -116,7 +116,7 @@ void CPU::loadState(SaveState const &state) {
#define hl() ( h << 8 | l ) #define hl() ( h << 8 | l )
#define READ(dest, addr) do { (dest) = mem_.read(addr, cycleCounter); cycleCounter += 4; } while (0) #define READ(dest, addr) do { (dest) = mem_.read(addr, cycleCounter); cycleCounter += 4; } while (0)
#define PEEK(dest, addr) do { (dest) = mem_.read(addr, cycleCounter); } while(0) #define PEEK(dest, addr) do { (dest) = mem_.read(addr, cycleCounter); } while (0)
#define PC_READ(dest) do { (dest) = mem_.read_excb(pc, cycleCounter, false); pc = (pc + 1) & 0xFFFF; cycleCounter += 4; } while (0) #define PC_READ(dest) do { (dest) = mem_.read_excb(pc, cycleCounter, false); pc = (pc + 1) & 0xFFFF; cycleCounter += 4; } while (0)
#define PC_READ_FIRST(dest) do { (dest) = mem_.read_excb(pc, cycleCounter, true); pc = (pc + 1) & 0xFFFF; cycleCounter += 4; } while (0) #define PC_READ_FIRST(dest) do { (dest) = mem_.read_excb(pc, cycleCounter, true); pc = (pc + 1) & 0xFFFF; cycleCounter += 4; } while (0)
#define FF_READ(dest, addr) do { (dest) = mem_.ff_read(addr, cycleCounter); cycleCounter += 4; } while (0) #define FF_READ(dest, addr) do { (dest) = mem_.ff_read(addr, cycleCounter); cycleCounter += 4; } while (0)

8
libgambatte/src/gambatte.cpp
View File

@ -32,7 +32,7 @@ struct GB::Priv {
uint_least32_t vbuff[160*144]; uint_least32_t vbuff[160*144];
Priv() : loadflags(0), layersMask(LAYER_MASK_BG | LAYER_MASK_OBJ) Priv() : loadflags(0), layersMask(layer_mask_bg | layer_mask_window | layer_mask_obj)
{ {
} }
}; };
@ -223,13 +223,11 @@ void GB::getRegs(int *dest) {
p_->cpu.getRegs(dest); p_->cpu.getRegs(dest);
} }
void GB::setInterruptAddresses(int *addrs, int numAddrs) void GB::setInterruptAddresses(int *addrs, int numAddrs) {
{
p_->cpu.setInterruptAddresses(addrs, numAddrs); p_->cpu.setInterruptAddresses(addrs, numAddrs);
} }
int GB::getHitInterruptAddress() int GB::getHitInterruptAddress() {
{
return p_->cpu.getHitInterruptAddress(); return p_->cpu.getHitInterruptAddress();
} }

5
libgambatte/src/mem/cartridge.cpp
View File

@ -532,11 +532,6 @@ static bool presumedMulti64Mbc1(unsigned char const header[], unsigned rombanks)
} }
LoadRes Cartridge::loadROM(char const *romfiledata, unsigned romfilelength, bool const forceDmg, bool const multicartCompat) { LoadRes Cartridge::loadROM(char const *romfiledata, unsigned romfilelength, bool const forceDmg, bool const multicartCompat) {
//const std::auto_ptr<File> rom(newFileInstance(romfile));
//if (rom->fail())
// return -1;
enum Cartridgetype { type_plain, enum Cartridgetype { type_plain,
type_mbc1, type_mbc1,
type_mbc2, type_mbc2,

27
libgambatte/src/mem/memptrs.cpp
View File

@ -45,7 +45,13 @@ MemPtrs::~MemPtrs() {
void MemPtrs::reset(unsigned const rombanks, unsigned const rambanks, unsigned const wrambanks) { void MemPtrs::reset(unsigned const rombanks, unsigned const rambanks, unsigned const wrambanks) {
delete []memchunk_; delete []memchunk_;
memchunk_len = 0x4000 + rombanks * 0x4000ul + 0x4000 + rambanks * 0x2000ul + wrambanks * 0x1000ul + 0x4000; memchunk_len =
0x4000
+ rombanks * 0x4000ul
+ 0x4000
+ rambanks * 0x2000ul
+ wrambanks * 0x1000ul
+ 0x4000;
memchunk_ = new unsigned char[memchunk_len]; memchunk_ = new unsigned char[memchunk_len];
romdata_[0] = romdata(); romdata_[0] = romdata();
@ -163,24 +169,10 @@ void MemPtrs::disconnectOamDmaAreas() {
SYNCFUNC(MemPtrs) SYNCFUNC(MemPtrs)
{ {
/*
int memchunk_len_old = memchunk_len;
int memchunk_saveoffs_old = memchunk_saveoffs;
int memchunk_savelen_old = memchunk_savelen;
*/
NSS(memchunk_len); NSS(memchunk_len);
NSS(memchunk_saveoffs); NSS(memchunk_saveoffs);
NSS(memchunk_savelen); NSS(memchunk_savelen);
/*
if (isReader)
{
if (memchunk_len != memchunk_len_old || memchunk_saveoffs != memchunk_saveoffs_old || memchunk_savelen != memchunk_savelen_old)
__debugbreak();
}
*/
PSS(memchunk_ + memchunk_saveoffs, memchunk_savelen); PSS(memchunk_ + memchunk_saveoffs, memchunk_savelen);
MSS(rmem_[0x0]); MSS(rmem_[0x0]);
@ -215,11 +207,6 @@ SYNCFUNC(MemPtrs)
MSS(wmem_[0xe]); MSS(wmem_[0xe]);
MSS(rmem_[0xf]); MSS(rmem_[0xf]);
MSS(wmem_[0xf]); MSS(wmem_[0xf]);
//for (int i = 0; i < 0x10; i++)
//{
// MSS(rmem_[i]);
// MSS(wmem_[i]);
//}
MSS(romdata_[0]); MSS(romdata_[0]);
MSS(romdata_[1]); MSS(romdata_[1]);
MSS(wramdata_[0]); MSS(wramdata_[0]);

15
libgambatte/src/memory.cpp
View File

@ -1203,24 +1203,21 @@ SYNCFUNC(Memory)
NSS(ioamhram_); NSS(ioamhram_);
NSS(divLastUpdate_); NSS(divLastUpdate_);
NSS(lastOamDmaUpdate_); NSS(lastOamDmaUpdate_);
NSS(biosMode_);
NSS(cgbSwitching_);
NSS(agbMode_);
NSS(gbIsCgb_);
NSS(stopped_);
NSS(halttime_);
SSS(intreq_); SSS(intreq_);
SSS(tima_); SSS(tima_);
SSS(lcd_); SSS(lcd_);
SSS(psg_); SSS(psg_);
NSS(dmaSource_); NSS(dmaSource_);
NSS(dmaDestination_); NSS(dmaDestination_);
NSS(oamDmaPos_); NSS(oamDmaPos_);
NSS(serialCnt_); NSS(serialCnt_);
NSS(blanklcd_); NSS(blanklcd_);
NSS(biosMode_);
NSS(cgbSwitching_);
NSS(agbMode_);
NSS(gbIsCgb_);
NSS(halttime_);
NSS(stopped_);
NSS(LINKCABLE_); NSS(LINKCABLE_);
NSS(linkClockTrigger_); NSS(linkClockTrigger_);
} }

4
libgambatte/src/memory.h
View File

@ -37,7 +37,7 @@ public:
~Memory(); ~Memory();
bool loaded() const { return cart_.loaded(); } bool loaded() const { return cart_.loaded(); }
unsigned char curRomBank() const { return cart_.curRomBank(); } unsigned curRomBank() const { return cart_.curRomBank(); }
char const * romTitle() const { return cart_.romTitle(); } char const * romTitle() const { return cart_.romTitle(); }
int debugGetLY() const { return lcd_.debugGetLY(); } int debugGetLY() const { return lcd_.debugGetLY(); }
void setStatePtrs(SaveState &state); void setStatePtrs(SaveState &state);
@ -55,7 +55,7 @@ public:
} }
bool gbIsCgb() { return gbIsCgb_; } bool gbIsCgb() { return gbIsCgb_; }
bool getMemoryArea(int which, unsigned char **data, int *length); // { return cart.getMemoryArea(which, data, length); } bool getMemoryArea(int which, unsigned char **data, int *length);
unsigned long stop(unsigned long cycleCounter); unsigned long stop(unsigned long cycleCounter);
bool isCgb() const { return lcd_.isCgb(); } bool isCgb() const { return lcd_.isCgb(); }

6
libgambatte/src/newstate.cpp
View File

@ -8,7 +8,7 @@ NewStateDummy::NewStateDummy()
:length(0) :length(0)
{ {
} }
void NewStateDummy::Save(const void *ptr, size_t size, char const *name) void NewStateDummy::Save(void const *ptr, size_t size, char const *name)
{ {
length += size; length += size;
} }
@ -21,7 +21,7 @@ NewStateExternalBuffer::NewStateExternalBuffer(char *buffer, long maxlength)
{ {
} }
void NewStateExternalBuffer::Save(const void *ptr, size_t size, char const *name) void NewStateExternalBuffer::Save(void const *ptr, size_t size, char const *name)
{ {
if (maxlength - length >= (long)size) if (maxlength - length >= (long)size)
{ {
@ -48,7 +48,7 @@ NewStateExternalFunctions::NewStateExternalFunctions(const FPtrs *ff)
{ {
} }
void NewStateExternalFunctions::Save(const void *ptr, size_t size, char const *name) void NewStateExternalFunctions::Save(void const *ptr, size_t size, char const *name)
{ {
Save_(ptr, size, name); Save_(ptr, size, name);
} }

28
libgambatte/src/newstate.h
View File

@ -9,8 +9,8 @@ namespace gambatte {
class NewState class NewState
{ {
public: public:
virtual void Save(const void *ptr, size_t size, char const *name) = 0; virtual void Save(void const *ptr, std::size_t size, char const *name) = 0;
virtual void Load(void *ptr, size_t size, char const *name) = 0; virtual void Load(void *ptr, std::size_t size, char const *name) = 0;
virtual void EnterSection(char const *name) { } virtual void EnterSection(char const *name) { }
virtual void ExitSection(char const *name) { } virtual void ExitSection(char const *name) { }
}; };
@ -23,8 +23,8 @@ public:
NewStateDummy(); NewStateDummy();
long GetLength() { return length; } long GetLength() { return length; }
void Rewind() { length = 0; } void Rewind() { length = 0; }
virtual void Save(const void *ptr, size_t size, char const *name); virtual void Save(void const *ptr, std::size_t size, char const *name);
virtual void Load(void *ptr, size_t size, char const *name); virtual void Load(void *ptr, std::size_t size, char const *name);
}; };
class NewStateExternalBuffer : public NewState class NewStateExternalBuffer : public NewState
@ -38,14 +38,14 @@ public:
long GetLength() { return length; } long GetLength() { return length; }
void Rewind() { length = 0; } void Rewind() { length = 0; }
bool Overflow() { return length > maxlength; } bool Overflow() { return length > maxlength; }
virtual void Save(const void *ptr, size_t size, char const *name); virtual void Save(void const *ptr, std::size_t size, char const *name);
virtual void Load(void *ptr, size_t size, char const *name); virtual void Load(void *ptr, std::size_t size, char const *name);
}; };
struct FPtrs struct FPtrs
{ {
void (*Save_)(const void *ptr, size_t size, char const *name); void (*Save_)(void const *ptr, std::size_t size, char const *name);
void (*Load_)(void *ptr, size_t size, char const *name); void (*Load_)(void *ptr, std::size_t size, char const *name);
void (*EnterSection_)(char const *name); void (*EnterSection_)(char const *name);
void (*ExitSection_)(char const *name); void (*ExitSection_)(char const *name);
}; };
@ -53,14 +53,14 @@ struct FPtrs
class NewStateExternalFunctions : public NewState class NewStateExternalFunctions : public NewState
{ {
private: private:
void (*Save_)(const void *ptr, size_t size, char const *name); void (*Save_)(void const *ptr, std::size_t size, char const *name);
void (*Load_)(void *ptr, size_t size, char const *name); void (*Load_)(void *ptr, std::size_t size, char const *name);
void (*EnterSection_)(char const *name); void (*EnterSection_)(char const *name);
void (*ExitSection_)(char const *name); void (*ExitSection_)(char const *name);
public: public:
NewStateExternalFunctions(const FPtrs *ff); NewStateExternalFunctions(const FPtrs *ff);
virtual void Save(const void *ptr, size_t size, char const *name); virtual void Save(void const *ptr, std::size_t size, char const *name);
virtual void Load(void *ptr, size_t size, char const *name); virtual void Load(void *ptr, std::size_t size, char const *name);
virtual void EnterSection(char const *name); virtual void EnterSection(char const *name);
virtual void ExitSection(char const *name); virtual void ExitSection(char const *name);
}; };
@ -85,9 +85,9 @@ public:
#define EES(x,d) else if (isReader) (x) = (d); if (!isReader) ns->Save(&_ttmp, sizeof _ttmp, #x); } while (0) #define EES(x,d) else if (isReader) (x) = (d); if (!isReader) ns->Save(&_ttmp, sizeof _ttmp, #x); } while (0)
#define RSS(x,b) do { if (isReader)\ #define RSS(x,b) do { if (isReader)\
{ ptrdiff_t _ttmp; ns->Load(&_ttmp, sizeof _ttmp, #x); (x) = (_ttmp == (ptrdiff_t)0xdeadbeef ? 0 : (b) + _ttmp); }\ { std::ptrdiff_t _ttmp; ns->Load(&_ttmp, sizeof _ttmp, #x); (x) = (_ttmp == (std::ptrdiff_t)0xdeadbeef ? 0 : (b) + _ttmp); }\
else\ else\
{ ptrdiff_t _ttmp = (x) == 0 ? 0xdeadbeef : (x) - (b); ns->Save(&_ttmp, sizeof _ttmp, #x); } } while (0) { std::ptrdiff_t _ttmp = (x) == 0 ? 0xdeadbeef : (x) - (b); ns->Save(&_ttmp, sizeof _ttmp, #x); } } while (0)
#define PSS(x,s) do { if (isReader) ns->Load((x), (s), #x); else ns->Save((x), (s), #x); } while (0) #define PSS(x,s) do { if (isReader) ns->Load((x), (s), #x); else ns->Save((x), (s), #x); } while (0)

3
libgambatte/src/video.cpp
View File

@ -863,14 +863,13 @@ void LCD::setDmgPaletteColor(unsigned palNum, unsigned colorNum, unsigned long r
SYNCFUNC(LCD) SYNCFUNC(LCD)
{ {
SSS(ppu_); SSS(ppu_);
NSS(dmgColorsRgb32_);
NSS(bgpData_); NSS(bgpData_);
NSS(objpData_); NSS(objpData_);
NSS(dmgColorsRgb32_);
SSS(eventTimes_); SSS(eventTimes_);
SSS(m0Irq_); SSS(m0Irq_);
SSS(lycIrq_); SSS(lycIrq_);
SSS(nextM0Time_); SSS(nextM0Time_);
NSS(statReg_); NSS(statReg_);
NSS(m2IrqStatReg_); NSS(m2IrqStatReg_);
NSS(m1IrqStatReg_); NSS(m1IrqStatReg_);

1
libgambatte/src/video.h
View File

@ -208,7 +208,6 @@ public:
{ {
SSS(eventMin_); SSS(eventMin_);
SSS(memEventMin_); SSS(memEventMin_);
//SSS(memEventRequester_); // not needed
} }
}; };

14
libgambatte/src/video/ppu.cpp
View File

@ -102,10 +102,10 @@ enum { max_m3start_cycles = 80 };
enum { attr_yflip = 0x40, attr_bgpriority = 0x80 }; enum { attr_yflip = 0x40, attr_bgpriority = 0x80 };
static inline int lcdcEn( PPUPriv const &p) { return p.lcdc & lcdc_en; } static inline int lcdcEn( PPUPriv const &p) { return p.lcdc & lcdc_en; }
static inline int lcdcWinEn(PPUPriv const &p) { return p.lcdc & lcdc_we; } static inline int lcdcWinEn(PPUPriv const &p) { return (p.lcdc & lcdc_we) && (p.layersMask & layer_mask_window); }
static inline int lcdcObj2x(PPUPriv const &p) { return p.lcdc & lcdc_obj2x; } static inline int lcdcObj2x(PPUPriv const &p) { return p.lcdc & lcdc_obj2x; }
static inline int lcdcObjEn(PPUPriv const &p) { return p.lcdc & lcdc_objen; } static inline int lcdcObjEn(PPUPriv const &p) { return (p.lcdc & lcdc_objen) && (p.layersMask & layer_mask_obj); }
static inline int lcdcBgEn( PPUPriv const &p) { return p.lcdc & lcdc_bgen; } static inline int lcdcBgEn( PPUPriv const &p) { return (p.lcdc & lcdc_bgen) && (p.layersMask & layer_mask_bg); }
static inline int weMasterCheckPriorToLyIncLineCycle(bool cgb) { return 450 - cgb; } static inline int weMasterCheckPriorToLyIncLineCycle(bool cgb) { return 450 - cgb; }
static inline int weMasterCheckAfterLyIncLineCycle(bool cgb) { return 454 - cgb; } static inline int weMasterCheckAfterLyIncLineCycle(bool cgb) { return 454 - cgb; }
@ -418,7 +418,7 @@ static void doFullTilesUnrolledDmg(PPUPriv &p, int const xend, uint_least32_t *c
{ {
uint_least32_t *const dst = dbufline + (xpos - 8); uint_least32_t *const dst = dbufline + (xpos - 8);
unsigned const tileword = -(p.lcdc & 1U) & p.ntileword; unsigned const tileword = -(p.lcdc & 1U & p.layersMask) & p.ntileword;
dst[0] = p.bgPalette[ tileword & 0x0003 ]; dst[0] = p.bgPalette[ tileword & 0x0003 ];
dst[1] = p.bgPalette[(tileword & 0x000C) >> 2]; dst[1] = p.bgPalette[(tileword & 0x000C) >> 2];
@ -624,7 +624,7 @@ static void doFullTilesUnrolledCgb(PPUPriv &p, int const xend, uint_least32_t *c
} while (i >= 0 && int(p.spriteList[i].spx) > xpos - 8); } while (i >= 0 && int(p.spriteList[i].spx) > xpos - 8);
} else { } else {
unsigned char idtab[8] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }; unsigned char idtab[8] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
unsigned const bgprioritymask = p.lcdc << 7; unsigned const bgprioritymask = (p.lcdc & p.layersMask & layer_mask_bg) << 7;
do { do {
int n; int n;
@ -804,7 +804,7 @@ static void plotPixel(PPUPriv &p) {
p.winDrawState |= win_draw_start; p.winDrawState |= win_draw_start;
} }
unsigned const twdata = tileword & ((p.lcdc & 1) | p.cgb) * 3; unsigned const twdata = tileword & ((p.lcdc & 1 & p.layersMask) | p.cgb) * 3;
unsigned long pixel = p.bgPalette[twdata + (p.attrib & 7) * 4]; unsigned long pixel = p.bgPalette[twdata + (p.attrib & 7) * 4];
int i = static_cast<int>(p.nextSprite) - 1; int i = static_cast<int>(p.nextSprite) - 1;
@ -1488,6 +1488,7 @@ namespace gambatte {
PPUPriv::PPUPriv(NextM0Time &nextM0Time, unsigned char const *const oamram, unsigned char const *const vram) PPUPriv::PPUPriv(NextM0Time &nextM0Time, unsigned char const *const oamram, unsigned char const *const vram)
: nextSprite(0) : nextSprite(0)
, currentSprite(0xFF) , currentSprite(0xFF)
, layersMask(layer_mask_bg | layer_mask_window | layer_mask_obj)
, vram(vram) , vram(vram)
, nextCallPtr(&M2_Ly0::f0_) , nextCallPtr(&M2_Ly0::f0_)
, now(0) , now(0)
@ -1812,7 +1813,6 @@ SYNCFUNC(PPU)
SSS(p_.spriteMapper); SSS(p_.spriteMapper);
SSS(p_.lyCounter); SSS(p_.lyCounter);
//SSS(p_.framebuf); // no state
NSS(p_.lcdc); NSS(p_.lcdc);
NSS(p_.scy); NSS(p_.scy);

2
libgambatte/src/video/ppu.h
View File

@ -29,7 +29,7 @@
namespace gambatte { namespace gambatte {
enum { LAYER_MASK_BG = 1, LAYER_MASK_OBJ = 2, LAYER_MASK_WINDOW = 4 }; enum { layer_mask_bg = 1, layer_mask_obj = 2, layer_mask_window = 4 };
class PPUFrameBuf { class PPUFrameBuf {
public: public:

1
libgambatte/src/video/sprite_mapper.cpp
View File

@ -212,7 +212,6 @@ SYNCFUNC(SpriteMapper)
NSS(spritemap_); NSS(spritemap_);
NSS(num_); NSS(num_);
SSS(nextM0Time_);
SSS(oamReader_); SSS(oamReader_);
} }

BIN
output/dll/libgambatte.dll
View File

Binary file not shown.