mirror of https://github.com/AxioDL/metaforce.git
974 lines
25 KiB
C++
974 lines
25 KiB
C++
#include "CNESEmulator.hpp"
|
|
#include "CNESShader.hpp"
|
|
#include "CGameState.hpp"
|
|
#include "Input/CFinalInput.hpp"
|
|
#include "logvisor/logvisor.hpp"
|
|
#include <cstring>
|
|
#include <cstdio>
|
|
#include <cstdlib>
|
|
#include <cstdbool>
|
|
#include <cstring>
|
|
#include "malloc.h"
|
|
#include <cinttypes>
|
|
#include <cctype>
|
|
#include <ctime>
|
|
#include <cmath>
|
|
|
|
static urde::MP1::CNESEmulator* EmulatorInst = nullptr;
|
|
|
|
extern "C"
|
|
{
|
|
|
|
#include "fixNES/mapper.h"
|
|
#include "fixNES/cpu.h"
|
|
#include "fixNES/ppu.h"
|
|
#include "fixNES/mem.h"
|
|
#include "fixNES/input.h"
|
|
#include "fixNES/fm2play.h"
|
|
#include "fixNES/apu.h"
|
|
#include "fixNES/audio_fds.h"
|
|
#include "fixNES/audio_vrc7.h"
|
|
#include "fixNES/mapper_h/nsf.h"
|
|
|
|
/*
|
|
* Portions Copyright (C) 2017 FIX94
|
|
*
|
|
* This software may be modified and distributed under the terms
|
|
* of the MIT license. See the LICENSE file for details.
|
|
*/
|
|
|
|
#define DEBUG_HZ 0
|
|
#define DEBUG_MAIN_CALLS 0
|
|
#define DEBUG_KEY 0
|
|
#define DEBUG_LOAD_INFO 1
|
|
|
|
#ifndef _WIN32
|
|
std::chrono::steady_clock::time_point s_tp = std::chrono::steady_clock::now();
|
|
static std::chrono::milliseconds::rep GetTickCount()
|
|
{
|
|
return std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::steady_clock::now() - s_tp).count();
|
|
}
|
|
#endif
|
|
|
|
static const char *VERSION_STRING = "fixNES Alpha v1.0.5";
|
|
static char window_title[256];
|
|
static char window_title_pause[256];
|
|
|
|
enum {
|
|
FTYPE_UNK = 0,
|
|
FTYPE_NES,
|
|
FTYPE_NSF,
|
|
FTYPE_FDS,
|
|
FTYPE_QD,
|
|
#if ZIPSUPPORT
|
|
FTYPE_ZIP,
|
|
#endif
|
|
};
|
|
|
|
static void nesEmuFdsSetup(uint8_t *src, uint8_t *dst);
|
|
|
|
static int emuFileType = FTYPE_UNK;
|
|
static char emuFileName[1024];
|
|
static uint8_t *emuNesROM = NULL;
|
|
static uint32_t emuNesROMsize = 0;
|
|
static char emuSaveName[1024];
|
|
static uint8_t *emuPrgRAM = NULL;
|
|
static uint32_t emuPrgRAMsize = 0;
|
|
//used externally
|
|
uint32_t textureImage[0xF000];
|
|
bool nesPause = false;
|
|
bool ppuDebugPauseFrame = false;
|
|
bool doOverscan = false;
|
|
bool nesPAL = false;
|
|
bool nesEmuNSFPlayback = false;
|
|
|
|
static bool inPause = false;
|
|
static bool inOverscanToggle = false;
|
|
static bool inResize = false;
|
|
static bool inDiskSwitch = false;
|
|
static bool inReset = false;
|
|
|
|
#if DEBUG_HZ
|
|
static int emuFrameStart = 0;
|
|
static int emuTimesCalled = 0;
|
|
static int emuTotalElapsed = 0;
|
|
#endif
|
|
#if DEBUG_MAIN_CALLS
|
|
static int emuMainFrameStart = 0;
|
|
static int emuMainTimesCalled = 0;
|
|
static int emuMainTimesSkipped = 0;
|
|
static int emuMainTotalElapsed = 0;
|
|
#endif
|
|
|
|
#define DOTS 341
|
|
|
|
#define VISIBLE_DOTS 256
|
|
#define VISIBLE_LINES 240
|
|
|
|
static uint32_t linesToDraw = VISIBLE_LINES;
|
|
static const uint32_t visibleImg = VISIBLE_DOTS*VISIBLE_LINES*4;
|
|
static uint8_t scaleFactor = 2;
|
|
static bool emuSaveEnabled = false;
|
|
static bool emuFdsHasSideB = false;
|
|
static uint32_t mainLoopRuns;
|
|
static uint32_t mainLoopPos;
|
|
static uint16_t ppuCycleTimer;
|
|
static uint16_t cpuCycleTimer;
|
|
//from input.c
|
|
extern uint8_t inValReads[8];
|
|
//from mapper.c
|
|
extern bool mapperUse78A;
|
|
//from m32.c
|
|
extern bool m32_singlescreen;
|
|
|
|
static volatile bool emuRenderFrame = false;
|
|
|
|
//used externally
|
|
bool emuSkipVsync = false;
|
|
bool emuSkipFrame = false;
|
|
|
|
//static uint32_t mCycles = 0;
|
|
static uint16_t mainClock = 1;
|
|
static uint16_t apuClock = 1;
|
|
static uint16_t ppuClock = 1;
|
|
static uint16_t vrc7Clock = 1;
|
|
|
|
extern bool fdsSwitch;
|
|
|
|
bool apuCycleURDE();
|
|
uint8_t* ppuGetVRAM();
|
|
|
|
int audioUpdate()
|
|
{
|
|
if (!EmulatorInst)
|
|
return 0;
|
|
return EmulatorInst->audioUpdate();
|
|
}
|
|
|
|
}
|
|
|
|
namespace urde::MP1
|
|
{
|
|
|
|
bool CNESEmulator::EmulatorConstructed = false;
|
|
static logvisor::Module Log("CNESEmulator");
|
|
|
|
#define NESEMUP_ROM_OFFSET 0xa3f8
|
|
|
|
#define METROID_PAL false
|
|
#define METROID_MAPPER 1
|
|
#define METROID_SAVE_ENABLED false
|
|
#define METROID_TRAINER false
|
|
#define METROID_PRG_SIZE (8 * 0x4000)
|
|
#define METROID_CHR_SIZE (0 * 0x2000)
|
|
#define METROID_PRG_RAM_SIZE 0x2000
|
|
|
|
CNESEmulator::CNESEmulator()
|
|
{
|
|
if (EmulatorConstructed)
|
|
Log.report(logvisor::Fatal, "Attempted constructing more than 1 CNESEmulator");
|
|
EmulatorConstructed = true;
|
|
|
|
CDvdFile NESEmuFile("NESemuP.rel");
|
|
if (NESEmuFile)
|
|
{
|
|
m_nesEmuPBuf.reset(new u8[0x20000]);
|
|
m_dvdReq = NESEmuFile.AsyncSeekRead(m_nesEmuPBuf.get(), 0x20000, ESeekOrigin::Begin, NESEMUP_ROM_OFFSET);
|
|
}
|
|
else
|
|
{
|
|
Log.report(logvisor::Fatal, "Unable to open NESemuP.rel");
|
|
}
|
|
}
|
|
|
|
void CNESEmulator::InitializeEmulator()
|
|
{
|
|
nesPause = false;
|
|
ppuDebugPauseFrame = false;
|
|
mainClock = 1;
|
|
apuClock = 1;
|
|
ppuClock = 1;
|
|
vrc7Clock = 1;
|
|
|
|
puts(VERSION_STRING);
|
|
strcpy(window_title, VERSION_STRING);
|
|
memset(textureImage,0,visibleImg);
|
|
emuFileType = FTYPE_UNK;
|
|
memset(emuFileName,0,1024);
|
|
memset(emuSaveName,0,1024);
|
|
|
|
nesPAL = METROID_PAL;
|
|
uint8_t mapper = METROID_MAPPER;
|
|
emuSaveEnabled = METROID_SAVE_ENABLED;
|
|
bool trainer = METROID_TRAINER;
|
|
uint32_t prgROMsize = METROID_PRG_SIZE;
|
|
uint32_t chrROMsize = METROID_CHR_SIZE;
|
|
emuPrgRAMsize = METROID_PRG_RAM_SIZE;
|
|
emuPrgRAM = (uint8_t*)malloc(emuPrgRAMsize);
|
|
uint8_t *prgROM = emuNesROM;
|
|
if(trainer)
|
|
{
|
|
memcpy(emuPrgRAM+0x1000,prgROM,0x200);
|
|
prgROM += 512;
|
|
}
|
|
uint8_t *chrROM = NULL;
|
|
if(chrROMsize)
|
|
{
|
|
chrROM = emuNesROM+prgROMsize;
|
|
if(trainer) chrROM += 512;
|
|
}
|
|
apuInitBufs();
|
|
cpuInit();
|
|
ppuInit();
|
|
memInit();
|
|
apuInit();
|
|
inputInit();
|
|
ppuSetNameTblVertical();
|
|
#if DEBUG_LOAD_INFO
|
|
printf("Used Mapper: %i\n", mapper);
|
|
printf("PRG: 0x%x bytes PRG RAM: 0x%x bytes CHR: 0x%x bytes\n", prgROMsize, emuPrgRAMsize, chrROMsize);
|
|
#endif
|
|
if(!mapperInit(mapper, prgROM, prgROMsize, emuPrgRAM, emuPrgRAMsize, chrROM, chrROMsize))
|
|
{
|
|
printf("Mapper init failed!\n");
|
|
return;
|
|
}
|
|
#if DEBUG_LOAD_INFO
|
|
printf("Trainer: %i Saving: %i VRAM Mode: Vertical\n", trainer, emuSaveEnabled);
|
|
#endif
|
|
sprintf(window_title, "%s NES - %s\n", nesPAL ? "PAL" : "NTSC", VERSION_STRING);
|
|
|
|
sprintf(window_title_pause, "%s (Pause)", window_title);
|
|
#if DEBUG_HZ
|
|
emuFrameStart = GetTickCount();
|
|
#endif
|
|
#if DEBUG_MAIN_CALLS
|
|
emuMainFrameStart = GetTickCount();
|
|
#endif
|
|
cpuCycleTimer = nesPAL ? 16 : 12;
|
|
//do full frame per update loop
|
|
ppuCycleTimer = nesPAL ? 5 : 4;
|
|
mainLoopRuns = nesPAL ? DOTS*ppuCycleTimer : DOTS*ppuCycleTimer;
|
|
//mainLoopRuns *= ppuLinesTotal;
|
|
mainLoopPos = mainLoopRuns;
|
|
|
|
CGraphicsCommitResources([this](boo::IGraphicsDataFactory::Context& ctx)
|
|
{
|
|
// Nearest-neighbor FTW!
|
|
m_texture = ctx.newDynamicTexture(VISIBLE_DOTS, linesToDraw,
|
|
boo::TextureFormat::RGBA8,
|
|
boo::TextureClampMode::ClampToEdgeNearest);
|
|
Vert verts[4] =
|
|
{
|
|
{{-1.f, -1.f, 0.f}, {0.f, 1.f}},
|
|
{{-1.f, 1.f, 0.f}, {0.f, 0.f}},
|
|
{{ 1.f, -1.f, 0.f}, {1.f, 1.f}},
|
|
{{ 1.f, 1.f, 0.f}, {1.f, 0.f}},
|
|
};
|
|
m_vbo = ctx.newStaticBuffer(boo::BufferUse::Vertex, verts, sizeof(Vert), 4);
|
|
m_uniBuf = ctx.newDynamicBuffer(boo::BufferUse::Uniform, sizeof(Uniform), 1);
|
|
m_shadBind = CNESShader::BuildShaderDataBinding(ctx, m_vbo, m_uniBuf, m_texture);
|
|
return true;
|
|
});
|
|
|
|
//double useFreq = 223740;
|
|
double useFreq = apuGetFrequency();
|
|
m_booVoice = CAudioSys::GetVoiceEngine()->allocateNewStereoVoice(useFreq, this);
|
|
m_booVoice->start();
|
|
uint32_t apuBufSz = apuGetBufSize();
|
|
m_audioBufBlock.reset(new u8[apuBufSz * NUM_AUDIO_BUFFERS]);
|
|
for (int i=0 ; i<NUM_AUDIO_BUFFERS ; ++i)
|
|
m_audioBufs[i] = m_audioBufBlock.get() + apuBufSz * i;
|
|
|
|
EmulatorInst = this;
|
|
}
|
|
|
|
void CNESEmulator::DeinitializeEmulator()
|
|
{
|
|
//printf("\n");
|
|
emuRenderFrame = false;
|
|
m_booVoice->stop();
|
|
m_booVoice.reset();
|
|
apuDeinitBufs();
|
|
if(emuNesROM != NULL)
|
|
{
|
|
if(!nesEmuNSFPlayback && fdsEnabled)
|
|
{
|
|
FILE *save = fopen(emuSaveName, "wb");
|
|
if(save)
|
|
{
|
|
if(emuFdsHasSideB)
|
|
fwrite(emuNesROM,1,0x20000,save);
|
|
else
|
|
fwrite(emuNesROM,1,0x10000,save);
|
|
fclose(save);
|
|
}
|
|
}
|
|
}
|
|
if(emuPrgRAM != NULL)
|
|
{
|
|
if(emuSaveEnabled)
|
|
{
|
|
FILE *save = fopen(emuSaveName, "wb");
|
|
if(save)
|
|
{
|
|
fwrite(emuPrgRAM,1,emuPrgRAMsize,save);
|
|
fclose(save);
|
|
}
|
|
}
|
|
free(emuPrgRAM);
|
|
}
|
|
emuPrgRAM = NULL;
|
|
//printf("Bye!\n");
|
|
|
|
EmulatorInst = nullptr;
|
|
}
|
|
|
|
CNESEmulator::~CNESEmulator()
|
|
{
|
|
if (m_dvdReq)
|
|
m_dvdReq->PostCancelRequest();
|
|
if (EmulatorInst)
|
|
DeinitializeEmulator();
|
|
if (emuNesROM)
|
|
{
|
|
free(emuNesROM);
|
|
emuNesROM = nullptr;
|
|
}
|
|
EmulatorConstructed = false;
|
|
}
|
|
|
|
int CNESEmulator::audioUpdate()
|
|
{
|
|
int origProcBufs = m_procBufs;
|
|
|
|
uint8_t *data = apuGetBuf();
|
|
if(data != NULL && m_procBufs)
|
|
{
|
|
--m_procBufs;
|
|
memmove(m_audioBufs[m_headBuf], data, apuGetBufSize());
|
|
//printf("PUSH\n");
|
|
++m_headBuf;
|
|
if (m_headBuf == NUM_AUDIO_BUFFERS)
|
|
m_headBuf = 0;
|
|
}
|
|
|
|
//if (!origProcBufs)
|
|
//printf("OVERRUN\n");
|
|
|
|
return origProcBufs;
|
|
}
|
|
|
|
static constexpr size_t AudioFrameSz = 2 * sizeof(int16_t);
|
|
|
|
size_t CNESEmulator::supplyAudio(boo::IAudioVoice& voice, size_t frames, int16_t* data)
|
|
{
|
|
size_t remFrames = frames;
|
|
while (remFrames)
|
|
{
|
|
if (m_posInBuf == apuGetBufSize())
|
|
{
|
|
++m_tailBuf;
|
|
if (m_tailBuf == NUM_AUDIO_BUFFERS)
|
|
m_tailBuf = 0;
|
|
m_posInBuf = 0;
|
|
++m_procBufs;
|
|
//printf("POP\n");
|
|
}
|
|
|
|
if (m_procBufs == NUM_AUDIO_BUFFERS)
|
|
{
|
|
memset(data, 0, remFrames * AudioFrameSz);
|
|
//printf("UNDERRUN\n");
|
|
return frames;
|
|
}
|
|
|
|
size_t copySz = std::min(apuGetBufSize() - m_posInBuf, remFrames * AudioFrameSz);
|
|
memmove(data, m_audioBufs[m_tailBuf] + m_posInBuf, copySz);
|
|
data += copySz / sizeof(int16_t);
|
|
m_posInBuf += copySz;
|
|
remFrames -= copySz / AudioFrameSz;
|
|
}
|
|
return frames;
|
|
}
|
|
|
|
#define CATCHUP_SKIP 1
|
|
#if CATCHUP_SKIP
|
|
static int catchupFrames = 0;
|
|
#endif
|
|
|
|
void CNESEmulator::NesEmuMainLoop(bool forceDraw)
|
|
{
|
|
int start = GetTickCount();
|
|
int loopCount = 0;
|
|
do
|
|
{
|
|
if(emuRenderFrame || nesPause)
|
|
{
|
|
#if DEBUG_MAIN_CALLS
|
|
emuMainTimesSkipped++;
|
|
#endif
|
|
//printf("LC RENDER: %d\n", loopCount);
|
|
m_texture->load(textureImage, visibleImg);
|
|
emuRenderFrame = false;
|
|
#if CATCHUP_SKIP
|
|
if (catchupFrames)
|
|
--catchupFrames;
|
|
else
|
|
#endif
|
|
break;
|
|
}
|
|
++loopCount;
|
|
if(mainClock == cpuCycleTimer)
|
|
{
|
|
//URDE uses this loop to pre-fill audio buffers,
|
|
//rather than executing multiple frame loops
|
|
bool breakout = false;
|
|
do
|
|
{
|
|
//runs every 8th cpu clock
|
|
if(apuClock == 8)
|
|
{
|
|
if(!apuCycleURDE() && !forceDraw)
|
|
{
|
|
#if DEBUG_MAIN_CALLS
|
|
emuMainTimesSkipped++;
|
|
#endif
|
|
#if CATCHUP_SKIP
|
|
catchupFrames = 0;
|
|
#endif
|
|
//printf("LC SKIP\n");
|
|
breakout = true;
|
|
break;
|
|
}
|
|
apuClock = 1;
|
|
}
|
|
else
|
|
apuClock++;
|
|
//runs every cpu cycle
|
|
apuClockTimers();
|
|
} while (emuSkipVsync);
|
|
if (breakout)
|
|
break;
|
|
|
|
//main CPU clock
|
|
if(!cpuCycle())
|
|
exit(EXIT_SUCCESS);
|
|
//mapper related irqs
|
|
if(mapperCycle != NULL)
|
|
mapperCycle();
|
|
//mCycles++;
|
|
//channel timer updates
|
|
apuLenCycle();
|
|
mainClock = 1;
|
|
}
|
|
else
|
|
mainClock++;
|
|
if(ppuClock == ppuCycleTimer)
|
|
{
|
|
if(!ppuCycle())
|
|
exit(EXIT_SUCCESS);
|
|
if(ppuDrawDone())
|
|
{
|
|
//printf("%i\n",mCycles);
|
|
//mCycles = 0;
|
|
emuRenderFrame = true;
|
|
if(fm2playRunning())
|
|
fm2playUpdate();
|
|
#if DEBUG_HZ
|
|
emuTimesCalled++;
|
|
int end = GetTickCount();
|
|
emuTotalElapsed += end - emuFrameStart;
|
|
if(emuTotalElapsed >= 1000)
|
|
{
|
|
printf("\r%iHz ", emuTimesCalled);
|
|
emuTimesCalled = 0;
|
|
emuTotalElapsed = 0;
|
|
}
|
|
emuFrameStart = end;
|
|
#endif
|
|
if(ppuDebugPauseFrame)
|
|
{
|
|
ppuDebugPauseFrame = false;
|
|
nesPause = true;
|
|
}
|
|
if(nesEmuNSFPlayback)
|
|
nsfVsync();
|
|
}
|
|
ppuClock = 1;
|
|
}
|
|
else
|
|
ppuClock++;
|
|
if(fdsEnabled)
|
|
fdsAudioMasterUpdate();
|
|
if(vrc7enabled)
|
|
{
|
|
if(vrc7Clock == 432)
|
|
{
|
|
vrc7AudioCycle();
|
|
vrc7Clock = 1;
|
|
}
|
|
else
|
|
vrc7Clock++;
|
|
}
|
|
|
|
#if 1
|
|
if (!forceDraw && (loopCount % 10000) == 0 && GetTickCount() - start >= 14)
|
|
{
|
|
#if CATCHUP_SKIP
|
|
if (catchupFrames < 50)
|
|
++catchupFrames;
|
|
#endif
|
|
break;
|
|
}
|
|
#endif
|
|
}
|
|
while(true);
|
|
|
|
#if 0
|
|
int end = GetTickCount();
|
|
printf("%dms %d %d\n", end - start, loopCount, m_procBufs);
|
|
#endif
|
|
|
|
#if DEBUG_MAIN_CALLS
|
|
emuMainTimesCalled++;
|
|
int end = GetTickCount();
|
|
//printf("%dms\n", end - start);
|
|
emuMainTotalElapsed += end - emuMainFrameStart;
|
|
if(emuMainTotalElapsed >= 1000)
|
|
{
|
|
printf("\r%i calls, %i skips ", emuMainTimesCalled, emuMainTimesSkipped);
|
|
fflush(stdout);
|
|
emuMainTimesCalled = 0;
|
|
emuMainTimesSkipped = 0;
|
|
emuMainTotalElapsed = 0;
|
|
}
|
|
emuMainFrameStart = end;
|
|
#endif
|
|
}
|
|
|
|
static void nesEmuFdsSetup(uint8_t *src, uint8_t *dst)
|
|
{
|
|
memcpy(dst, src, 0x38);
|
|
memcpy(dst+0x3A, src+0x38, 2);
|
|
uint16_t cDiskPos = 0x3E;
|
|
uint16_t cROMPos = 0x3A;
|
|
do
|
|
{
|
|
if(src[cROMPos] != 0x03)
|
|
break;
|
|
memcpy(dst+cDiskPos, src+cROMPos, 0x10);
|
|
uint16_t copySize = (*(uint16_t*)(src+cROMPos+0xD))+1;
|
|
cDiskPos+=0x12;
|
|
cROMPos+=0x10;
|
|
memcpy(dst+cDiskPos, src+cROMPos, copySize);
|
|
cDiskPos+=copySize+2;
|
|
cROMPos+=copySize;
|
|
} while(cROMPos < 0xFFDC && cDiskPos < 0xFFFF);
|
|
printf("%04x -> %04x\n", cROMPos, cDiskPos);
|
|
}
|
|
|
|
void CNESEmulator::DecompressROM(u8* dataIn, u8* dataOut, u32 dataOutLen, u8 descrambleSeed,
|
|
u32 checkDataLen, u32 checksumMagic)
|
|
{
|
|
for (int i=0 ; i<256 ; ++i)
|
|
{
|
|
descrambleSeed += dataIn[i];
|
|
dataIn[i] = descrambleSeed;
|
|
}
|
|
|
|
for (int i=0 ; i<128 ; ++i)
|
|
std::swap(dataIn[255 - i], dataIn[i]);
|
|
|
|
struct BitstreamState
|
|
{
|
|
u32 x0_remBits = 0;
|
|
u32 x4_lastByte;
|
|
u8* x8_ptr;
|
|
BitstreamState(u8* ptr) : x8_ptr(ptr) {}
|
|
} bState = {dataIn + 256};
|
|
|
|
u8* dataOutAlpha = dataOut;
|
|
while (dataOutLen != 0)
|
|
{
|
|
u32 r12 = 0;
|
|
|
|
if (bState.x0_remBits == 0)
|
|
{
|
|
bState.x4_lastByte = *bState.x8_ptr;
|
|
bState.x8_ptr += 1;
|
|
bState.x0_remBits = 8;
|
|
}
|
|
|
|
u32 r11 = r12 << 1;
|
|
if (bState.x4_lastByte & 0x80)
|
|
r11 |= 1;
|
|
|
|
bState.x4_lastByte <<= 1;
|
|
bState.x0_remBits -= 1;
|
|
|
|
if (r11 == 1)
|
|
{
|
|
r12 = 0;
|
|
|
|
for (int i=0 ; i<4 ; ++i)
|
|
{
|
|
if (bState.x0_remBits == 0)
|
|
{
|
|
bState.x4_lastByte = *bState.x8_ptr;
|
|
bState.x8_ptr += 1;
|
|
bState.x0_remBits = 8;
|
|
}
|
|
|
|
r12 <<= 1;
|
|
if (bState.x4_lastByte & 0x80)
|
|
r12 |= 1;
|
|
|
|
bState.x4_lastByte <<= 1;
|
|
bState.x0_remBits -= 1;
|
|
|
|
if (bState.x0_remBits == 0)
|
|
{
|
|
bState.x4_lastByte = *bState.x8_ptr;
|
|
bState.x8_ptr += 1;
|
|
bState.x0_remBits = 8;
|
|
}
|
|
|
|
r12 <<= 1;
|
|
if (bState.x4_lastByte & 0x80)
|
|
r12 |= 1;
|
|
|
|
bState.x4_lastByte <<= 1;
|
|
bState.x0_remBits -= 1;
|
|
}
|
|
|
|
*dataOutAlpha++ = dataIn[r12 + 73];
|
|
}
|
|
else
|
|
{
|
|
r12 = 0;
|
|
|
|
if (bState.x0_remBits == 0)
|
|
{
|
|
bState.x4_lastByte = *bState.x8_ptr;
|
|
bState.x8_ptr += 1;
|
|
bState.x0_remBits = 8;
|
|
}
|
|
|
|
r11 = r12 << 1;
|
|
if (bState.x4_lastByte & 0x80)
|
|
r11 |= 1;
|
|
|
|
bState.x4_lastByte <<= 1;
|
|
bState.x0_remBits -= 1;
|
|
|
|
if (r11 == 1)
|
|
{
|
|
r12 = 0;
|
|
|
|
for (int i=0 ; i<3 ; ++i)
|
|
{
|
|
if (bState.x0_remBits == 0)
|
|
{
|
|
bState.x4_lastByte = *bState.x8_ptr;
|
|
bState.x8_ptr += 1;
|
|
bState.x0_remBits = 8;
|
|
}
|
|
|
|
r12 <<= 1;
|
|
if (bState.x4_lastByte & 0x80)
|
|
r12 |= 1;
|
|
|
|
bState.x4_lastByte <<= 1;
|
|
bState.x0_remBits -= 1;
|
|
|
|
if (bState.x0_remBits == 0)
|
|
{
|
|
bState.x4_lastByte = *bState.x8_ptr;
|
|
bState.x8_ptr += 1;
|
|
bState.x0_remBits = 8;
|
|
}
|
|
|
|
r12 <<= 1;
|
|
if (bState.x4_lastByte & 0x80)
|
|
r12 |= 1;
|
|
|
|
bState.x4_lastByte <<= 1;
|
|
bState.x0_remBits -= 1;
|
|
}
|
|
|
|
*dataOutAlpha++ = dataIn[r12 + 9];
|
|
}
|
|
else
|
|
{
|
|
r12 = 0;
|
|
|
|
if (bState.x0_remBits == 0)
|
|
{
|
|
bState.x4_lastByte = *bState.x8_ptr;
|
|
bState.x8_ptr += 1;
|
|
bState.x0_remBits = 8;
|
|
}
|
|
|
|
r11 = r12 << 1;
|
|
if (bState.x4_lastByte & 0x80)
|
|
r11 |= 1;
|
|
|
|
bState.x4_lastByte <<= 1;
|
|
bState.x0_remBits -= 1;
|
|
|
|
if (r11 == 1)
|
|
{
|
|
r12 = 0;
|
|
|
|
for (int i=0 ; i<3 ; ++i)
|
|
{
|
|
if (bState.x0_remBits == 0)
|
|
{
|
|
bState.x4_lastByte = *bState.x8_ptr;
|
|
bState.x8_ptr += 1;
|
|
bState.x0_remBits = 8;
|
|
}
|
|
|
|
r12 <<= 1;
|
|
if (bState.x4_lastByte & 0x80)
|
|
r12 |= 1;
|
|
|
|
bState.x4_lastByte <<= 1;
|
|
bState.x0_remBits -= 1;
|
|
}
|
|
|
|
*dataOutAlpha++ = dataIn[r12 + 1];
|
|
}
|
|
else
|
|
{
|
|
*dataOutAlpha++ = dataIn[0];
|
|
}
|
|
}
|
|
}
|
|
|
|
--dataOutLen;
|
|
}
|
|
|
|
u32 tmpWord = 0;
|
|
for (int i=0 ; i<checkDataLen ; ++i)
|
|
{
|
|
tmpWord ^= dataOut[i];
|
|
for (int j=0 ; j<8 ; ++j)
|
|
{
|
|
if (tmpWord & 0x1)
|
|
tmpWord = (tmpWord >> 1) ^ checksumMagic;
|
|
else
|
|
tmpWord = (tmpWord >> 1);
|
|
}
|
|
}
|
|
|
|
dataOut[checkDataLen - 1] = (tmpWord >> 8) & 0xff;
|
|
dataOut[checkDataLen - 2] = tmpWord & 0xff;
|
|
}
|
|
|
|
void CNESEmulator::ProcessUserInput(const CFinalInput& input, int)
|
|
{
|
|
if (input.ControllerIdx() != 0)
|
|
return;
|
|
|
|
if (GetPasswordEntryState() != EPasswordEntryState::NotPasswordScreen)
|
|
{
|
|
// Don't swap A/B
|
|
inValReads[BUTTON_A] = input.DA();
|
|
inValReads[BUTTON_B] = input.DB();
|
|
}
|
|
else
|
|
{
|
|
// Prime controls (B jumps, A shoots)
|
|
inValReads[BUTTON_B] = input.DA() | input.DY();
|
|
inValReads[BUTTON_A] = input.DB() | input.DX();
|
|
}
|
|
|
|
inValReads[BUTTON_UP] = input.DDPUp() | input.DLAUp();
|
|
inValReads[BUTTON_DOWN] = input.DDPDown() | input.DLADown();
|
|
inValReads[BUTTON_LEFT] = input.DDPLeft() | input.DLALeft();
|
|
inValReads[BUTTON_RIGHT] = input.DDPRight() | input.DLARight();
|
|
inValReads[BUTTON_SELECT] = input.DZ();
|
|
inValReads[BUTTON_START] = input.DStart();
|
|
}
|
|
|
|
bool CNESEmulator::CheckForGameOver(const u8* vram, u8* passwordOut)
|
|
{
|
|
// "PASS WORD"
|
|
if (memcmp(vram + 0x14B, "\x19\xa\x1c\x1c\xff\x20\x18\x1b\xd", 9))
|
|
return false;
|
|
|
|
int chOff = 0;
|
|
int encOff = 0;
|
|
u8 pwOut[18];
|
|
for (int i=0 ; i<24 ; ++i)
|
|
{
|
|
u8 chName = vram[0x1A9 + chOff];
|
|
++chOff;
|
|
if (chOff == 0x6 || chOff == 0x46)
|
|
++chOff; // mid-line space
|
|
else if (chOff == 0xd)
|
|
chOff = 64; // 2nd line
|
|
|
|
if (chName > 0x3f)
|
|
return false;
|
|
|
|
switch (i & 0x3)
|
|
{
|
|
case 0:
|
|
pwOut[encOff] = chName;
|
|
break;
|
|
case 1:
|
|
pwOut[encOff] |= chName << 6;
|
|
++encOff;
|
|
pwOut[encOff] = chName >> 2;
|
|
break;
|
|
case 2:
|
|
pwOut[encOff] |= chName << 4;
|
|
++encOff;
|
|
pwOut[encOff] = chName >> 4;
|
|
break;
|
|
case 3:
|
|
pwOut[encOff] |= chName << 2;
|
|
++encOff;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (passwordOut)
|
|
memmove(passwordOut, pwOut, 18);
|
|
return true;
|
|
}
|
|
|
|
CNESEmulator::EPasswordEntryState CNESEmulator::CheckForPasswordEntryScreen(const u8* vram)
|
|
{
|
|
// "PASS WORD PLEASE"
|
|
if (memcmp(vram + 0x88, "\x19\xa\x1c\x1c\xff\x20\x18\x1b\xd\xff\x19\x15\xe\xa\x1c\xe", 16))
|
|
return EPasswordEntryState::NotPasswordScreen;
|
|
|
|
for (int i=0 ; i<13 ; ++i)
|
|
if (vram[0x109 + i] < 0x40 || vram[0x149 + i] < 0x40)
|
|
return EPasswordEntryState::Entered;
|
|
|
|
return EPasswordEntryState::NotEntered;
|
|
}
|
|
|
|
bool CNESEmulator::SetPasswordIntoEntryScreen(u8* vram, u8* wram, const u8* password)
|
|
{
|
|
if (CheckForPasswordEntryScreen(vram) != EPasswordEntryState::NotEntered)
|
|
return false;
|
|
|
|
int i;
|
|
for (i=0 ; i<18 ; ++i)
|
|
if (password[i])
|
|
break;
|
|
if (i == 18)
|
|
return false;
|
|
|
|
int encOff = 0;
|
|
int chOff = 0;
|
|
u32 lastWord = 0;
|
|
for (i=0 ; i<24 ; ++i)
|
|
{
|
|
switch (i & 0x3)
|
|
{
|
|
case 0:
|
|
lastWord = password[encOff];
|
|
++encOff;
|
|
break;
|
|
case 1:
|
|
lastWord = (lastWord >> 6) | (u32(password[encOff]) << 2);
|
|
++encOff;
|
|
break;
|
|
case 2:
|
|
lastWord = (lastWord >> 6) | (u32(password[encOff]) << 4);
|
|
++encOff;
|
|
break;
|
|
case 3:
|
|
lastWord = (lastWord >> 6);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
u8 chName = u8(lastWord & 0x3f);
|
|
wram[0x99a + i] = chName;
|
|
vram[0x109 + chOff] = chName;
|
|
++chOff;
|
|
if (chOff == 0x6 || chOff == 0x46)
|
|
++chOff; // mid-line space
|
|
else if (chOff == 0xd)
|
|
chOff = 64; // 2nd line
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void CNESEmulator::Update()
|
|
{
|
|
if (!EmulatorInst)
|
|
{
|
|
if (m_dvdReq && m_dvdReq->IsComplete())
|
|
{
|
|
m_dvdReq.reset();
|
|
emuNesROMsize = 0x20000;
|
|
emuNesROM = (uint8_t*)malloc(emuNesROMsize);
|
|
DecompressROM(m_nesEmuPBuf.get(), emuNesROM);
|
|
m_nesEmuPBuf.reset();
|
|
InitializeEmulator();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (nesPause)
|
|
{
|
|
DeinitializeEmulator();
|
|
InitializeEmulator();
|
|
return;
|
|
}
|
|
|
|
bool gameOver = CheckForGameOver(ppuGetVRAM(), x21_passwordFromNES);
|
|
x34_passwordEntryState = CheckForPasswordEntryScreen(ppuGetVRAM());
|
|
if (x34_passwordEntryState == EPasswordEntryState::NotEntered && x38_passwordPending)
|
|
{
|
|
SetPasswordIntoEntryScreen(ppuGetVRAM(), emuPrgRAM, x39_passwordToNES);
|
|
x38_passwordPending = false;
|
|
}
|
|
if (gameOver && !x20_gameOver)
|
|
for (int i=0 ; i<3 ; ++i) // Three draw loops to ensure password display
|
|
NesEmuMainLoop(true);
|
|
else
|
|
NesEmuMainLoop();
|
|
x20_gameOver = gameOver;
|
|
}
|
|
}
|
|
|
|
static const float NESAspect = VISIBLE_DOTS / float(VISIBLE_LINES);
|
|
|
|
void CNESEmulator::Draw(const zeus::CColor& mulColor, bool filtering)
|
|
{
|
|
if (!EmulatorInst)
|
|
return;
|
|
|
|
float aspect = g_Viewport.x8_width / float(g_Viewport.xc_height);
|
|
float widthFac = NESAspect / aspect;
|
|
|
|
Uniform uniform = {zeus::CMatrix4f{}, mulColor};
|
|
uniform.m_matrix[0][0] = widthFac;
|
|
m_uniBuf->load(&uniform, sizeof(Uniform));
|
|
|
|
CGraphics::SetShaderDataBinding(m_shadBind);
|
|
CGraphics::DrawArray(0, 4);
|
|
}
|
|
|
|
void CNESEmulator::LoadPassword(const u8* state)
|
|
{
|
|
memmove(x39_passwordToNES, state, 18);
|
|
x38_passwordPending = true;
|
|
}
|
|
|
|
}
|