2016-01-27 11:31:39 +00:00
|
|
|
#include <ws/ws.hpp>
|
|
|
|
|
|
|
|
namespace WonderSwan {
|
|
|
|
|
|
|
|
Settings settings;
|
Update to v102r02 release.
byuu says:
Changelog:
- I caved on the `samples[] = {0.0}` thing, but I'm very unhappy about it
- if it's really invalid C++, then GCC needs to stop accepting it
in strict `-std=c++14` mode
- Emulator::Interface::Information::resettable is gone
- Emulator::Interface::reset() is gone
- FC, SFC, MD cores updated to remove soft reset behavior
- split GameBoy::Interface into GameBoyInterface,
GameBoyColorInterface
- split WonderSwan::Interface into WonderSwanInterface,
WonderSwanColorInterface
- PCE: fixed off-by-one scanline error [hex_usr]
- PCE: temporary hack to prevent crashing when VDS is set to < 2
- hiro: Cocoa: removed (u)int(#) constants; converted (u)int(#)
types to (u)int_(#)t types
- icarus: replaced usage of unique with strip instead (so we don't
mess up frameworks on macOS)
- libco: added macOS-specific section marker [Ryphecha]
So ... the major news this time is the removal of the soft reset
behavior. This is a major!! change that results in a 100KiB diff file,
and it's very prone to accidental mistakes!! If anyone is up for
testing, or even better -- looking over the code changes between v102r01
and v102r02 and looking for any issues, please do so. Ideally we'll want
to test every NES mapper type and every SNES coprocessor type by loading
said games and power cycling to make sure the games are all cleanly
resetting. It's too big of a change for me to cover there not being any
issues on my own, but this is truly critical code, so yeah ... please
help if you can.
We technically lose a bit of hardware documentation here. The soft reset
events do all kinds of interesting things in all kinds of different
chips -- or at least they do on the SNES. This is obviously not ideal.
But in the process of removing these portions of code, I found a few
mistakes I had made previously. It simplifies resetting the system state
a lot when not trying to have all the power() functions call the reset()
functions to share partial functionality.
In the future, the goal will be to come up with a way to add back in the
soft reset behavior via keyboard binding as with the Master System core.
What's going to have to happen is that the key binding will have to send
a "reset pulse" to every emulated chip, and those chips are going to
have to act independently to power() instead of reusing functionality.
We'll get there eventually, but there's many things of vastly greater
importance to work on right now, so it'll be a while. The information
isn't lost ... we'll just have to pull it out of v102 when we are ready.
Note that I left the SNES reset vector simulation code in, even though
it's not possible to trigger, for the time being.
Also ... the Super Game Boy core is still disconnected. To be honest, it
totally slipped my mind when I released v102 that it wasn't connected
again yet. This one's going to be pretty tricky to be honest. I'm
thinking about making a third GameBoy::Interface class just for SGB, and
coming up with some way of bypassing platform-> calls when in this
mode.
2017-01-22 21:04:26 +00:00
|
|
|
#include "wonderswan.cpp"
|
|
|
|
#include "wonderswan-color.cpp"
|
2016-01-27 11:31:39 +00:00
|
|
|
|
Update to v102r04 release.
byuu says:
Changelog:
- Super Game Boy support is functional once again
- new GameBoy::SuperGameBoyInterface class
- system.(dmg,cgb,sgb) is now Model::(Super)GameBoy(Color) ala the PC
Engine
- merged WonderSwanInterface, WonderSwanColorInterface shared
functions to WonderSwan::Interface
- merged GameBoyInterface, GameBoyColorInterface shared functions to
GameBoy::Interface
- Interface::unload() now calls Interface::save() for Master System,
Game Gear, Mega Drive, PC Engine, SuperGrafx
- PCE: emulated PCE-CD backup RAM; stored per-game as save.ram (2KiB
file)
- this means you can now save your progress in games like Neutopia
- the PCE-CD I/O registers like BRAM write protect are not
emulated yet
- PCE: IRQ sources now hold the IRQ line state, instead of the CPU
holding it
- this fixes most SuperGrafx games, which were fighting over the
VDC IRQ line previously
- PCE: CPU I/O $14xx should return the pending IRQ bits even if IRQs
are disabled
- PCE: VCE and the VDCs now synchronize to each other; fixes pixel
widths in all games
- PCE: greatly increased the accuracy of the VPC priority selection
code (windows may be buggy still)
- HuC6280: PLA, PLX, PLY should set Z, N flags; fixes many game bugs
[Jonas Quinn]
The big thing I wanted to do was enslave the VDC(s) to the VCE. But
unfortunately, I forgot about the asynchronous DMA channels that each
VDC supports, so this isn't going to be possible I'm afraid.
In the most demanding case, Daimakaimura in-game, we're looking at 85fps
on my Xeon E3 1276v3. So ... not great, and we don't even have sound
connected yet.
We are going to have to profile and optimize this code once sound
emulation and save states are in.
Basically, think of it like this: the VCE, VDC0, and VDC1 all have the
same overhead, scheduling wise (which is the bulk of the performance
loss) as the dot-renderer for the SNES core. So it's like there's three
bsnes-accuracy PPU threads running just for video.
-----
Oh, just a fair warning ... the hooks for the SGB are a work in
progress.
If anyone is working on higan or a fork and want to do something similar
to it, don't use it as a template, at least not yet.
Right now, higan looks like this:
- Emulator::Video handles the platform→videoRefresh calls
- Emulator::Audio handles the platform→audioSample calls
- each core hard-codes the platform→inputPoll, inputRumble calls
- each core hard-codes calls to path, open, load to process files
- dipSettings and notify are specialty hacks, neither are even hooked
up right now to anything
With the SGB, it's an emulation core inside an emulation core, so
ideally you want to hook all of those functions. Emulator::Video and
Emulator::Audio aren't really abstractions over that, as the GB core
calls them and we have to special case not calling them in SGB mode.
The path, open, load can be implemented without hooks, thanks to the UI
only using one instance of Emulator::Platform for all cores. All we have
to do is override the folder path ID for the "Game Boy.sys" folder, so
that it picks "Super Game Boy.sfc/" and loads its boot ROM instead.
That's just a simple argument to GameBoy::System::load() and we're done.
dipSettings, notify and inputRumble don't matter. But we do also have to
hook inputPoll as well.
The nice idea would be for SuperFamicom::ICD2 to inherit from
Emulator::Platform and provide the desired functions that we need to
overload. After that, we'd just need the GB core to keep an abstraction
over the global Emulator::platform\* handle, to select between the UI
version and the SFC::ICD2 version.
However ... that doesn't work because of Emulator::Video and
Emulator::Audio. They would also have to gain an abstraction over
Emulator::platform\*, and even worse ... you'd have to constantly swap
between the two so that the SFC core uses the UI, and the GB core uses
the ICD2.
And so, for right now, I'm checking Model::SuperGameBoy() -> bool
everywhere, and choosing between the UI and ICD2 targets that way. And
as such, the ICD2 doesn't really need Emulator::Platform inheritance,
although it certainly could do that and just use the functions it needs.
But the SGB is even weirder, because we need additional new signals
beyond just Emulator::Platform, like joypWrite(), etc.
I'd also like to work on the Emulator::Stream for the SGB core. I don't
see why we can't have the GB core create its own stream, and let the
ICD2 just use that instead. We just have to be careful about the ICD2's
CPU soft reset function, to make sure the GB core's Stream object
remains valid. What I think that needs is a way to release an
Emulator::Stream individually, rather than calling
Emulator::Audio::reset() to do it. They are shared\_pointer objects, so
I think if I added a destructor function to remove it from
Emulator::Audio::streams, then that should work.
2017-01-26 01:06:06 +00:00
|
|
|
Interface::Interface() {
|
|
|
|
Port hardwareHorizontalPort{ID::Port::HardwareHorizontal, "Hardware - Horizontal"};
|
|
|
|
Port hardwareVerticalPort{ID::Port::HardwareVertical, "Hardware - Vertical"};
|
|
|
|
|
|
|
|
{ Device device{ID::Device::Controls, "Controls"};
|
|
|
|
device.inputs.append({0, "Y1"});
|
|
|
|
device.inputs.append({0, "Y2"});
|
|
|
|
device.inputs.append({0, "Y3"});
|
|
|
|
device.inputs.append({0, "Y4"});
|
|
|
|
device.inputs.append({0, "X1"});
|
|
|
|
device.inputs.append({0, "X2"});
|
|
|
|
device.inputs.append({0, "X3"});
|
|
|
|
device.inputs.append({0, "X4"});
|
|
|
|
device.inputs.append({0, "B"});
|
|
|
|
device.inputs.append({0, "A"});
|
|
|
|
device.inputs.append({0, "Start"});
|
|
|
|
device.inputs.append({0, "Rotate"});
|
|
|
|
hardwareHorizontalPort.devices.append(device);
|
|
|
|
hardwareVerticalPort.devices.append(device);
|
|
|
|
}
|
|
|
|
|
|
|
|
ports.append(move(hardwareHorizontalPort));
|
|
|
|
ports.append(move(hardwareVerticalPort));
|
|
|
|
}
|
|
|
|
|
|
|
|
auto Interface::manifest() -> string {
|
|
|
|
return cartridge.information.manifest;
|
|
|
|
}
|
|
|
|
|
|
|
|
auto Interface::title() -> string {
|
|
|
|
return cartridge.information.title;
|
|
|
|
}
|
|
|
|
|
|
|
|
auto Interface::videoSize() -> VideoSize {
|
|
|
|
return {224, 224};
|
|
|
|
}
|
|
|
|
|
|
|
|
auto Interface::videoSize(uint width, uint height, bool arc) -> VideoSize {
|
|
|
|
uint w = 224;
|
|
|
|
uint h = 224;
|
|
|
|
uint m = min(width / w, height / h);
|
|
|
|
return {w * m, h * m};
|
|
|
|
}
|
|
|
|
|
|
|
|
auto Interface::loaded() -> bool {
|
|
|
|
return system.loaded();
|
|
|
|
}
|
|
|
|
|
|
|
|
auto Interface::sha256() -> string {
|
|
|
|
return cartridge.information.sha256;
|
|
|
|
}
|
|
|
|
|
|
|
|
auto Interface::save() -> void {
|
|
|
|
system.save();
|
|
|
|
}
|
|
|
|
|
|
|
|
auto Interface::unload() -> void {
|
|
|
|
save();
|
|
|
|
system.unload();
|
|
|
|
}
|
|
|
|
|
|
|
|
auto Interface::power() -> void {
|
|
|
|
system.power();
|
|
|
|
}
|
|
|
|
|
|
|
|
auto Interface::run() -> void {
|
|
|
|
system.run();
|
|
|
|
}
|
|
|
|
|
|
|
|
auto Interface::serialize() -> serializer {
|
|
|
|
system.runToSave();
|
|
|
|
return system.serialize();
|
|
|
|
}
|
|
|
|
|
|
|
|
auto Interface::unserialize(serializer& s) -> bool {
|
|
|
|
return system.unserialize(s);
|
|
|
|
}
|
|
|
|
|
|
|
|
auto Interface::cheatSet(const string_vector& list) -> void {
|
|
|
|
cheat.assign(list);
|
|
|
|
}
|
|
|
|
|
|
|
|
auto Interface::cap(const string& name) -> bool {
|
|
|
|
if(name == "Blur Emulation") return true;
|
|
|
|
if(name == "Color Emulation") return true;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
auto Interface::get(const string& name) -> any {
|
|
|
|
if(name == "Blur Emulation") return settings.blurEmulation;
|
|
|
|
if(name == "Color Emulation") return settings.colorEmulation;
|
|
|
|
return {};
|
|
|
|
}
|
|
|
|
|
|
|
|
auto Interface::set(const string& name, const any& value) -> bool {
|
|
|
|
if(name == "Blur Emulation" && value.is<bool>()) {
|
|
|
|
settings.blurEmulation = value.get<bool>();
|
|
|
|
system.configureVideoEffects();
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
if(name == "Color Emulation" && value.is<bool>()) {
|
|
|
|
settings.colorEmulation = value.get<bool>();
|
|
|
|
system.configureVideoPalette();
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2016-01-27 11:31:39 +00:00
|
|
|
}
|