2015-11-14 00:52:51 +00:00
|
|
|
auto ICD2::lcdScanline() -> void {
|
2014-01-28 10:04:58 +00:00
|
|
|
if(GameBoy::ppu.status.ly > 143) return; //Vblank
|
2012-04-26 10:51:13 +00:00
|
|
|
if((GameBoy::ppu.status.ly & 7) == 0) {
|
2016-06-17 13:03:54 +00:00
|
|
|
writeBank = (writeBank + 1) & 3;
|
|
|
|
writeAddress = 0;
|
2011-05-08 13:46:37 +00:00
|
|
|
}
|
2014-01-28 10:04:58 +00:00
|
|
|
}
|
2011-05-08 13:46:37 +00:00
|
|
|
|
2015-11-14 00:52:51 +00:00
|
|
|
auto ICD2::lcdOutput(uint2 color) -> void {
|
2016-06-17 13:03:54 +00:00
|
|
|
uint y = writeAddress / 160;
|
|
|
|
uint x = writeAddress % 160;
|
|
|
|
uint addr = writeBank * 512 + y * 2 + x / 8 * 16;
|
2014-01-28 10:04:58 +00:00
|
|
|
output[addr + 0] = (output[addr + 0] << 1) | (bool)(color & 1);
|
|
|
|
output[addr + 1] = (output[addr + 1] << 1) | (bool)(color & 2);
|
2016-06-17 13:03:54 +00:00
|
|
|
writeAddress = (writeAddress + 1) % 1280;
|
2011-05-08 13:46:37 +00:00
|
|
|
}
|
|
|
|
|
2015-11-14 00:52:51 +00:00
|
|
|
auto ICD2::joypWrite(bool p15, bool p14) -> void {
|
2011-01-08 09:58:41 +00:00
|
|
|
//joypad handling
|
|
|
|
if(p15 == 1 && p14 == 1) {
|
2016-06-17 13:03:54 +00:00
|
|
|
if(joyp15Lock == 0 && joyp14Lock == 0) {
|
|
|
|
joyp15Lock = 1;
|
|
|
|
joyp14Lock = 1;
|
|
|
|
joypID = (joypID + 1) & 3;
|
2011-01-08 09:58:41 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-06-17 13:03:54 +00:00
|
|
|
if(p15 == 0 && p14 == 1) joyp15Lock = 0;
|
|
|
|
if(p15 == 1 && p14 == 0) joyp14Lock = 0;
|
2011-01-08 09:58:41 +00:00
|
|
|
|
|
|
|
//packet handling
|
|
|
|
if(p15 == 0 && p14 == 0) { //pulse
|
2016-06-17 13:03:54 +00:00
|
|
|
pulseLock = false;
|
|
|
|
packetOffset = 0;
|
|
|
|
bitOffset = 0;
|
|
|
|
strobeLock = true;
|
|
|
|
packetLock = false;
|
2011-01-08 09:58:41 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2016-06-17 13:03:54 +00:00
|
|
|
if(pulseLock) return;
|
2011-01-08 09:58:41 +00:00
|
|
|
|
|
|
|
if(p15 == 1 && p14 == 1) {
|
2016-06-17 13:03:54 +00:00
|
|
|
strobeLock = false;
|
2011-01-08 09:58:41 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2016-06-17 13:03:54 +00:00
|
|
|
if(strobeLock) {
|
2011-01-08 09:58:41 +00:00
|
|
|
if(p15 == 1 || p14 == 1) { //malformed packet
|
2016-06-17 13:03:54 +00:00
|
|
|
packetLock = false;
|
|
|
|
pulseLock = true;
|
|
|
|
bitOffset = 0;
|
|
|
|
packetOffset = 0;
|
2011-01-08 09:58:41 +00:00
|
|
|
} else {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//p15:1, p14:0 = 0
|
|
|
|
//p15:0, p14:1 = 1
|
|
|
|
bool bit = (p15 == 0);
|
2016-06-17 13:03:54 +00:00
|
|
|
strobeLock = true;
|
2011-01-08 09:58:41 +00:00
|
|
|
|
2016-06-17 13:03:54 +00:00
|
|
|
if(packetLock) {
|
2011-01-08 09:58:41 +00:00
|
|
|
if(p15 == 1 && p14 == 0) {
|
2016-06-17 13:03:54 +00:00
|
|
|
if((joypPacket[0] >> 3) == 0x11) {
|
|
|
|
mltReq = joypPacket[1] & 3;
|
|
|
|
if(mltReq == 2) mltReq = 3;
|
|
|
|
joypID = 0;
|
2011-01-08 09:58:41 +00:00
|
|
|
}
|
|
|
|
|
2016-06-17 13:03:54 +00:00
|
|
|
if(packetSize < 64) packet[packetSize++] = joypPacket;
|
|
|
|
packetLock = false;
|
|
|
|
pulseLock = true;
|
2011-01-08 09:58:41 +00:00
|
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2016-06-17 13:03:54 +00:00
|
|
|
bitData = (bit << 7) | (bitData >> 1);
|
|
|
|
if(++bitOffset < 8) return;
|
2011-01-08 09:58:41 +00:00
|
|
|
|
2016-06-17 13:03:54 +00:00
|
|
|
bitOffset = 0;
|
|
|
|
joypPacket[packetOffset] = bitData;
|
|
|
|
if(++packetOffset < 16) return;
|
|
|
|
packetLock = true;
|
2011-01-08 09:58:41 +00:00
|
|
|
}
|
|
|
|
|
Update to v099r08 release.
byuu says:
Changelog:
- nall/vfs work 100% completed; even SGB games load now
- emulation cores now call load() for the base cartridges as well
- updated port/device handling; portmask is gone; device ID bug should
be resolved now
- SNES controller port 1 multitap option was removed
- added support for 128KiB SNES PPU VRAM (for now, edit sfc/ppu/ppu.hpp
VRAM::size=0x10000; to enable)
Overall, nall/vfs was a huge success!! We've substantially reduced
the amount of boilerplate code everywhere, while still allowing (even
easier than before) support for RAM-based game loading/saving. All of
nall/stream is dead and buried.
I am considering removing Emulator::Interface::Medium::id and/or
bootable flag. Or at least, doing something different with it. The
values for the non-bootable GB/BS/ST entries duplicate the ID that is
supposed to be unique. They are for GB/GBC and WS/WSC. Maybe I'll use
this as the hardware revision selection ID, and then gut non-bootable
options. There's really no reason for that to be there. I think at one
point I was using it to generate library tabs for non-bootable systems,
but we don't do that anymore anyway.
Emulator::Interface::load() may not need the required flag anymore ... it
doesn't really do anything right now anyway.
I have a few reasons for having the cores load the base cartridge. Most
importantly, it is going to enable a special mode for the WonderSwan /
WonderSwan Color in the future. If we ever get the IPLROMs dumped ... it's
possible to boot these systems with no games inserted to set user profile
information and such. There are also other systems that may accept being
booted without a cartridge. To reach this state, you would load a game and
then cancel the load dialog. Right now, this results in games not loading.
The second reason is this prevents nasty crashes when loading fails. So
if you're missing a required manifest, the emulator won't die a violent
death anymore. It's able to back out at any point.
The third reason is consistency: loading the base cartridge works the
same as the slot cartridges.
The fourth reason is Emulator::Interface::open(uint pathID)
values. Before, the GB, SB, GBC modes were IDs 1,2,3 respectively. This
complicated things because you had to pass the correct ID. But now
instead, Emulator::Interface::load() returns maybe<uint> that is nothing
when no game is selected, and a pathID for a valid game. And now open()
can take this ID to access this game's folder contents.
The downside, which is temporary, is that command-line loading is
currently broken. But I do intend on restoring it. In fact, I want to do
better than before and allow multi-cart booting from the command-line by
specifying the base cartridge and then slot cartridges. The idea should
be pretty simple: keep a queue of pending filenames that we fill from
the command-line and/or drag-and-drop operations on the main window,
and then empty out the queue or prompt for load dialogs from the UI
when booting a system. This also might be a bit more unorthodox compared
to the traditional emulator design of "loadGame(filename)", but ... oh
well. It's easy enough still.
The port/device changes are fun. We simplified things quite a bit. The
portmask stuff is gone entirely. While ports and devices keep IDs,
this is really just sugar-coating so UIs can use for(auto& port :
emulator->ports) and access port.id; rather than having to use for(auto
n : range(emulator->ports)) { auto& port = emulator->ports[n]; ... };
but they should otherwise generally be identical to the order they appear
in their respective ranges. Still, don't rely on that.
Input::id is gone. There was no point since we also got rid of the nasty
Input::order vector. Since I was in here, I went ahead and caved on the
pedantics and renamed Input::guid to Input::userData.
I removed the SNES controller port 1 multitap option. Basically, the only
game that uses this is N-warp Daisakusen and, no offense to d4s, it's
not really a good game anyway. It's just a quick demo to show 8-players
on the SNES. But in the UI, all it does is confuse people into wasting
time mapping a controller they're never going to use, and they're going
to wonder which port to use. If more compelling use cases for 8-players
comes about, we can reconsider this. I left all the code to support this
in place, so all you have to do is uncomment one line to enable it again.
We now have dsnes emulation! :D
If you change PPU::VRAM::size to 0x10000 (words), then you should now
have 128KiB of VRAM. Even better, it serializes the used-VRAM size,
so your save states shouldn't crash on you if you swap between the two
(though if you try this, you're nuts.)
Note that this option does break commercial software. Yoshi's Island in
particular. This game is setting A15 on some PPU register writes, but
not on others. The end result of this is things break horribly in-game.
Also, this option is causing a very tiny speed hit for obvious reasons
with the variable masking value (I'm even using size-1 for now.) Given
how niche this is, I may just leave it a compile-time constant to avoid
the overhead cost. Otherwise, if we keep the option, then it'll go into
Super Famicom.sys/manifest.bml ... I'll flesh that out in the near-future.
----
Finally, some fun for my OCD ... my monitor suddenly cut out on me
in the middle of working on this WIP, about six hours in of non-stop
work. Had to hit a bunch of ctrl+alt+fN commands (among other things)
and trying to log in headless on another TTY to do issue commands,
trying to recover the display. Finally power cycled the monitor and it
came back up. So all my typing ended up going to who knows where.
Usually this sort of thing terrifies me enough that I scrap a WIP and
start over to ensure I didn't screw anything up during the crashed screen
when hitting keys randomly.
Obviously, everything compiles and appears to work fine. And I know
it's extremely paranoid, but OCD isn't logical, so ... I'm going
to go over every line of the 100KiB r07->r08 diff looking for any
corruption/errors/whatever.
----
Review finished.
r08 diff review notes:
- fc/controller/gamepad/gamepad.cpp:
use uint device = ID::Device::Gamepad; not id = ...;
- gb/cartridge/cartridge.hpp:
remove redundant uint _pathID; (in Information::pathID already)
- gb/cartridge/cartridge.hpp:
pull sha256 inside Information
- sfc/cartridge/load/cpp:
add " - Slot (A,B)" to interface->load("Sufami Turbo"); to be more
descriptive
- sfc/controller/gamepad/gamepad.cpp:
use uint device = ID::Device::Gamepad; not id = ...;
- sfc/interface/interface.cpp:
remove n variable from the Multitap device input generation loop
(now unused)
- sfc/interface/interface.hpp:
put struct Port above struct Device like the other classes
- ui-tomoko:
cheats.bml is reading from/writing to mediumPaths(0) [system folder
instead of game folder]
- ui-tomoko:
instead of mediumPaths(1) - call emulator->metadataPathID() or something
like that
2016-06-24 12:16:53 +00:00
|
|
|
auto ICD2::open(uint id, string name, vfs::file::mode mode, bool required) -> vfs::shared::file {
|
|
|
|
//redirect system folder to cartridge folder:
|
|
|
|
//expects "GameBoy.sys"; but this would be "Super Famicom.sys"; redirect to "Super Game Boy.sfc/"
|
|
|
|
if(id == ID::System) id = cartridge.pathID();
|
|
|
|
return interface->open(id, name, mode, required);
|
Update to v097r12 release.
byuu says:
Nothing WS-related this time.
First, I fixed expansion port device mapping. On first load, it was
mapping the expansion port device too late, so it ended up not taking
effect. I had to spin out the logic for that into
Program::connectDevices(). This was proving to be quite annoying while
testing eBoot (SNES-Hook simulation.)
Second, I fixed the audio->set(Frequency, Latency) functions to take
(uint) parameters from the configuration file, so the weird behavior
around changing settings in the audio panel should hopefully be gone
now.
Third, I rewrote the interface->load,unload functions to call into the
(Emulator)::System::load,unload functions. And I have those call out to
Cartridge::load,unload. Before, this was inverted, and Cartridge::load()
was invoking System::load(), which I felt was kind of backward.
The Super Game Boy really didn't like this change, however. And it took
me a few hours to power through it. Before, I had the Game Boy core
dummying out all the interface->(load,save)Request calls, and having the
SNES core make them for it. This is because the folder paths and IDs
will be different between the two cores.
I've redesigned things so that ICD2's Emulator::Interface overloads
loadRequest and saveRequest, and translates the requests into new
requests for the SuperFamicom core. This allows the Game Boy code to do
its own loading for everything without a bunch of Super Game Boy special
casing, and without any awkwardness around powering on with no cartridge
inserted.
This also lets the SNES side of things simply call into higher-level
GameBoy::interface->load,save(id, stream) functions instead of stabbing
at the raw underlying state inside of various Game Boy core emulation
classes. So things are a lot better abstracted now.
2016-02-08 03:17:59 +00:00
|
|
|
}
|
|
|
|
|
2016-06-25 08:53:11 +00:00
|
|
|
auto ICD2::load(uint id, string name, string type) -> maybe<uint> {
|
|
|
|
return interface->load(id, name, type);
|
Update to v088r03 release.
byuu says:
static vector<uint8_t> file::read(const string &filename); replaces:
static bool file::read(const string &filename, uint8_t *&data, unsigned
&size); This allows automatic deletion of the underlying data.
Added vectorstream, which is obviously a vector<uint8_t> wrapper for
a data stream. Plan is for all data accesses inside my emulation cores
to take stream objects, especially MSU1. This lets you feed the core
anything: memorystream, filestream, zipstream, gzipstream, httpstream,
etc. There will still be exceptions for link and serial, those need
actual library files on disk. But those aren't official hardware devices
anyway.
So to help with speed a bit, I'm rethinking the video rendering path.
Previous system:
- core outputs system-native samples (SNES = 19-bit LRGB, NES = 9-bit
emphasis+palette, DMG = 2-bit grayscale, etc.)
- interfaceSystem transforms samples to 30-bit via lookup table inside
the emulation core
- interfaceSystem masks off overscan areas, if enabled
- interfaceUI runs filter to produce new target buffer, if enabled
- interfaceUI transforms 30-bit video to native display depth (24-bit or
30-bit), and applies color-adjustments (gamma, etc) at the same time
New system:
- all cores now generate an internal palette, and call
Interface::videoColor(uint32_t source, uint16_t red, uint16_t green,
uint16_t blue) to get native display color post-adjusted (gamma, etc
applied already.)
- all cores output to uint32_t* buffer now (output video.palette[color]
instead of just color)
- interfaceUI runs filter to produce new target buffer, if enabled
- interfaceUI memcpy()'s buffer to the video card
videoColor() is pretty neat. source is the raw pixel (as per the
old-format, 19-bit SNES, 9-bit NES, etc), and you can create a color
from that if you really want to. Or return that value to get a buffer
just like v088 and below. red, green, blue are 16-bits per channel,
because why the hell not, right? Just lop off all the bits you don't
want. If you have more bits on your display than that, fuck you :P
The last step is extremely difficult to avoid. Video cards can and do
have pitches that differ from the width of the texture. Trying to make
the core account for this would be really awful. And even if we did
that, the emulation routine would need to write directly to a video card
RAM buffer. Some APIs require you to lock the video buffer while
writing, so this would leave the video buffer locked for a long time.
Probably not catastrophic, but still awful. And lastly, if the
emulation core tried writing directly to the display texture, software
filters would no longer be possible (unless you -really- jump through
hooks and divert to a memory buffer when a filter is enabled, but ...
fuck.)
Anyway, the point of all that work was to eliminate an extra video copy,
and the need for a really painful 30-bit to 24-bit conversion (three
shifts, three masks, three array indexes.) So this basically reverts us,
performance-wise, to where we were pre-30 bit support.
[...]
The downside to this is that we're going to need a filter for each
output depth. Since the array type is uint32_t*, and I don't intend to
support higher or lower depths, we really only need 24+30-bit versions
of each filter. Kinda shitty, but oh well.
2012-04-27 12:12:53 +00:00
|
|
|
}
|
|
|
|
|
2015-11-14 00:52:51 +00:00
|
|
|
auto ICD2::videoRefresh(const uint32* data, uint pitch, uint width, uint height) -> void {
|
2011-01-08 09:58:41 +00:00
|
|
|
}
|
|
|
|
|
2016-06-01 11:23:22 +00:00
|
|
|
auto ICD2::audioSample(const double* samples, uint channels) -> void {
|
|
|
|
stream->write(samples);
|
2011-01-08 09:58:41 +00:00
|
|
|
}
|
|
|
|
|
2015-11-14 00:52:51 +00:00
|
|
|
auto ICD2::inputPoll(uint port, uint device, uint id) -> int16 {
|
2016-06-28 10:43:47 +00:00
|
|
|
GameBoy::cpu.status.mltReq = joypID & mltReq;
|
2011-01-08 09:58:41 +00:00
|
|
|
|
2015-11-14 00:52:51 +00:00
|
|
|
uint data = 0x00;
|
2016-06-17 13:03:54 +00:00
|
|
|
switch(joypID & mltReq) {
|
2012-05-06 06:34:46 +00:00
|
|
|
case 0: data = ~r6004; break;
|
|
|
|
case 1: data = ~r6005; break;
|
|
|
|
case 2: data = ~r6006; break;
|
|
|
|
case 3: data = ~r6007; break;
|
2011-01-08 09:58:41 +00:00
|
|
|
}
|
|
|
|
|
2012-04-26 10:51:13 +00:00
|
|
|
switch((GameBoy::Input)id) {
|
2012-05-06 06:34:46 +00:00
|
|
|
case GameBoy::Input::Start: return (bool)(data & 0x80);
|
|
|
|
case GameBoy::Input::Select: return (bool)(data & 0x40);
|
|
|
|
case GameBoy::Input::B: return (bool)(data & 0x20);
|
|
|
|
case GameBoy::Input::A: return (bool)(data & 0x10);
|
|
|
|
case GameBoy::Input::Down: return (bool)(data & 0x08);
|
|
|
|
case GameBoy::Input::Up: return (bool)(data & 0x04);
|
|
|
|
case GameBoy::Input::Left: return (bool)(data & 0x02);
|
|
|
|
case GameBoy::Input::Right: return (bool)(data & 0x01);
|
2011-01-08 09:58:41 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|