mirror of
https://github.com/RaySollium99/picodrive.git
synced 2025-09-05 15:27:46 -04:00
1183 lines
38 KiB
C++
1183 lines
38 KiB
C++
// mainloop with window server event handling
|
|
// event polling mechnism was taken from
|
|
// Peter van Sebille's projects
|
|
|
|
// (c) Copyright 2006, notaz
|
|
// All Rights Reserved
|
|
|
|
#include <hal.h>
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <sys/time.h>
|
|
|
|
#include "debug.h"
|
|
|
|
#include "pico/picoInt.h"
|
|
#include "vid.h"
|
|
#include "SimpleServer.h"
|
|
#include "ClientServer.h"
|
|
//#include "polledAS.h"
|
|
#include "audio.h"
|
|
|
|
#include <EZlib.h>
|
|
#include "zlib/gzio_symb.h"
|
|
|
|
|
|
#define BENCHMARK
|
|
//#define TEST_FRAMEBUFF
|
|
|
|
// keycodes we care about
|
|
enum TPxxxKeyCodes {
|
|
EKeyPxxxPower = EKeyDevice0, //0xF842
|
|
EKeyPxxxBrowser = EKeyApplication0,
|
|
EKeyPxxxCamera = EKeyApplication1,
|
|
EKeyPxxxJogUp = EKeyDevice1,
|
|
EKeyPxxxJogDown = EKeyDevice2,
|
|
EKeyPxxxJogLeft = EKeyDevice3,
|
|
EKeyPxxxJogRight = EKeyDevice9,
|
|
EKeyPxxxJogInward= EKeyDevice8,
|
|
// FC keys
|
|
//EKeyPxxxFcOk = EKeyDevice8, // don't care about FC keycodes
|
|
};
|
|
// EKeyScreenDimension1 ~ EStdKeyF24 is sent when flip is closed,
|
|
// EKeyScreenDimension0 ~ EStdKeyF23 when opened
|
|
|
|
enum TMotAKeyCodes {
|
|
EKeyMotAUp = EKeyDevice4, //0xF846
|
|
EKeyMotADown = EKeyDevice5,
|
|
EKeyMotALeft = EKeyDevice6,
|
|
EKeyMotARight = EKeyDevice7,
|
|
EKeyMotASelect = EKeyDevice8,
|
|
EKeyMotAButton1 = EKeyApplicationA,
|
|
EKeyMotAButton2 = EKeyApplicationB,
|
|
EKeyMotAHome = EKeyApplication0,
|
|
EKeyMotAShortcut = EKeyApplication1,
|
|
EKeyMotAVoice = EKeyDeviceA,
|
|
EKeyMotACamera = EKeyDeviceB,
|
|
EKeyMotAVolUp = EKeyIncVolume,
|
|
EKeyMotAVolDn = EKeyDecVolume,
|
|
EKeyMotASend = EKeyYes,
|
|
EKeyMotAEnd = EKeyNo,
|
|
};
|
|
|
|
// scancodes we care about
|
|
enum TPxxxScanCodes {
|
|
EScanPxxxPower = EStdKeyDevice0, // 0xa4
|
|
EScanPxxxBrowser = EStdKeyApplication0,
|
|
EScanPxxxCamera = EStdKeyApplication1,
|
|
EScanPxxxJogUp = EStdKeyDevice1,
|
|
EScanPxxxJogDown = EStdKeyDevice2,
|
|
EScanPxxxJogLeft = EStdKeyDeviceE, // not consistent
|
|
EScanPxxxJogRight = EStdKeyDeviceD,
|
|
EScanPxxxJogInward= EStdKeyDevice8,
|
|
// FC keys
|
|
EScanPxxxFcOk = EStdKeyDeviceF,
|
|
EScanPxxxFcBack = EStdKeyDevice3,
|
|
EScanPxxxFcC = EStdKeyDeviceA,
|
|
EScanPxxxFcMenu = EStdKeyDevice9,
|
|
EScanPxxxFc0 = '0',
|
|
EScanPxxxFc1 = '1',
|
|
EScanPxxxFc2 = '2',
|
|
EScanPxxxFc3 = '3',
|
|
EScanPxxxFc4 = '4',
|
|
EScanPxxxFc5 = '5',
|
|
EScanPxxxFc6 = '6',
|
|
EScanPxxxFc7 = '7',
|
|
EScanPxxxFc8 = '8',
|
|
EScanPxxxFc9 = '9',
|
|
EScanPxxxFcHash = EStdKeyHash,
|
|
EScanPxxxFcAsterisk= EStdKeyNkpAsterisk,
|
|
};
|
|
|
|
enum TMotAScanCodes {
|
|
EScanMotAUp = EStdKeyDevice4,
|
|
EScanMotADown = EStdKeyDevice5,
|
|
EScanMotALeft = EStdKeyDevice6,
|
|
EScanMotARight = EStdKeyDevice7,
|
|
EScanMotASelect = EStdKeyDevice8,
|
|
EScanMotAButton1 = EStdKeyApplicationA,
|
|
EScanMotAButton2 = EStdKeyApplicationB,
|
|
EScanMotAHome = EStdKeyApplication0,
|
|
EScanMotAShortcut = EStdKeyApplication1,
|
|
EScanMotAVoice = EStdKeyDeviceA,
|
|
EScanMotACamera = EStdKeyDeviceB,
|
|
EScanMotAVolUp = EStdKeyIncVolume,
|
|
EScanMotAVolDn = EStdKeyDecVolume,
|
|
EScanMotASend = EStdKeyYes,
|
|
EScanMotAEnd = EStdKeyNo,
|
|
// some extra codes, don't know if these are actually used
|
|
EScanMotAExtra = EStdKeyApplicationC,
|
|
EScanMotAEsc = EStdKeyApplicationD,
|
|
EScanMotAStart = EStdKeyApplicationE,
|
|
EScanMotASelect2 = EStdKeyApplicationF,
|
|
};
|
|
|
|
|
|
// list of key names and codes
|
|
TPicoKeyConfigEntry keyConfigPXXX[] = {
|
|
{ EKeyPxxxPower, EScanPxxxPower, 0, -1, -1, "POWER" }, // 0
|
|
{ EKeyPxxxBrowser, EScanPxxxBrowser, 0, -1, -1, "BROWSER" },
|
|
{ EKeyPxxxCamera, EScanPxxxCamera, 0, -1, -1, "CAMERA" },
|
|
{ EKeyPxxxJogUp, EScanPxxxJogUp, 2, -1, -1, "JOG@UP" },
|
|
{ EKeyPxxxJogDown, EScanPxxxJogDown, 2, -1, -1, "JOG@DOWN" },
|
|
{ EKeyPxxxJogLeft, EScanPxxxJogLeft, 0, -1, -1, "JOG@LEFT" }, // 5
|
|
{ EKeyPxxxJogRight, EScanPxxxJogRight, 0, -1, -1, "JOG@RIGHT" },
|
|
{ 0, EScanPxxxJogInward, 0, -1, -1, "JOG@INWARD" },
|
|
{ 0, EScanPxxxFcOk, 0, -1, -1, "FC@OK" },
|
|
{ 0, EScanPxxxFcBack, 0, -1, -1, "FC@BACK" },
|
|
{ 0, EScanPxxxFcC, 0, -1, -1, "FC@C" }, // 10
|
|
{ 0, EScanPxxxFcMenu, 0, -1, -1, "FC@MENU" },
|
|
{ 0, EScanPxxxFc0, 0, -1, -1, "FC@0" },
|
|
{ 0, EScanPxxxFc1, 0, -1, -1, "FC@1" },
|
|
{ 0, EScanPxxxFc2, 0, -1, -1, "FC@2" },
|
|
{ 0, EScanPxxxFc3, 0, -1, -1, "FC@3" },
|
|
{ 0, EScanPxxxFc4, 0, -1, -1, "FC@4" },
|
|
{ 0, EScanPxxxFc5, 0, -1, -1, "FC@5" },
|
|
{ 0, EScanPxxxFc6, 0, -1, -1, "FC@6" },
|
|
{ 0, EScanPxxxFc7, 0, -1, -1, "FC@7" },
|
|
{ 0, EScanPxxxFc8, 0, -1, -1, "FC@8" },
|
|
{ 0, EScanPxxxFc9, 0, -1, -1, "FC@9" },
|
|
{ 0, EScanPxxxFcHash, 0, -1, -1, "FC@HASH" },
|
|
{ 0, EScanPxxxFcAsterisk,0, -1, -1, "FC@AST" },
|
|
{ 0, 0, 0, 0, 0, 0 }
|
|
};
|
|
|
|
// Motorola A92x & A1000 support
|
|
TPicoKeyConfigEntry keyConfigMotA[] = {
|
|
{ EKeyMotAUp, EScanMotAUp, 0, -1, -1, "UP" }, // 0
|
|
{ EKeyMotADown, EScanMotADown, 0, -1, -1, "DOWN" },
|
|
{ EKeyMotALeft, EScanMotALeft, 0, -1, -1, "LEFT" },
|
|
{ EKeyMotARight, EScanMotARight, 0, -1, -1, "RIGHT" },
|
|
{ EKeyMotASelect, EScanMotASelect, 0, -1, -1, "SELECT" },
|
|
{ EKeyMotAButton1, EScanMotAButton1, 0, -1, -1, "BUTTON1" }, // 5
|
|
{ EKeyMotAButton2, EScanMotAButton2, 0, -1, -1, "BUTTON2" },
|
|
{ EKeyMotAHome, EScanMotAHome, 0, -1, -1, "HOME" },
|
|
{ EKeyMotAShortcut, EScanMotAShortcut, 0, -1, -1, "SHORTCUT" },
|
|
{ EKeyMotAVoice, EScanMotAVoice, 0, -1, -1, "VOICE" },
|
|
{ EKeyMotACamera, EScanMotACamera, 0, -1, -1, "CAMERA" }, // 10
|
|
{ EKeyMotAVolUp, EScanMotAVolUp, 0, -1, -1, "VOL@UP" },
|
|
{ EKeyMotAVolDn, EScanMotAVolDn, 0, -1, -1, "VOL@DOWN" },
|
|
{ EKeyMotASend, EScanMotASend, 0, -1, -1, "SEND" },
|
|
{ EKeyMotAEnd, EScanMotAEnd, 0, -1, -1, "END" },
|
|
{ 0, EScanMotAExtra, 0, -1, -1, "EXTRA" },
|
|
{ 0, EScanMotAEsc, 0, -1, -1, "ESC" },
|
|
{ 0, EScanMotAStart, 0, -1, -1, "START" },
|
|
{ 0, EScanMotASelect2, 0, -1, -1, "SELECT" },
|
|
{ 0, 0, 0, 0, 0, 0 }
|
|
};
|
|
|
|
|
|
// list of areas
|
|
TPicoAreaConfigEntry areaConfig[] = {
|
|
{ TRect( 0, 0, 0, 0) },
|
|
// small corner bottons
|
|
{ TRect( 0, 0, 15, 15) },
|
|
{ TRect(192, 0, 207, 15) },
|
|
{ TRect( 0, 304, 15, 319) },
|
|
{ TRect(192, 304, 207, 319) },
|
|
// normal buttons
|
|
{ TRect( 0, 0, 68, 63) },
|
|
{ TRect( 69, 0, 138, 63) },
|
|
{ TRect(139, 0, 207, 63) },
|
|
{ TRect( 0, 64, 68, 127) },
|
|
{ TRect( 69, 64, 138, 127) },
|
|
{ TRect(139, 64, 207, 127) },
|
|
{ TRect( 0, 128, 68, 191) },
|
|
{ TRect( 69, 128, 138, 191) },
|
|
{ TRect(139, 128, 207, 191) },
|
|
{ TRect( 0, 192, 68, 255) },
|
|
{ TRect( 69, 192, 138, 255) },
|
|
{ TRect(139, 192, 207, 255) },
|
|
{ TRect( 0, 256, 68, 319) },
|
|
{ TRect( 69, 256, 138, 319) },
|
|
{ TRect(139, 256, 207, 319) },
|
|
{ TRect( 0, 0, 0, 0) }
|
|
};
|
|
|
|
// PicoPad[] format: SACB RLDU
|
|
const char *actionNames[] = {
|
|
"UP", "DOWN", "LEFT", "RIGHT", "B", "C", "A", "START",
|
|
0, 0, 0, 0, 0, 0, 0, 0, // Z, Y, X, MODE (enabled only when needed), ?, ?, ?, ?
|
|
0, 0, 0, 0, 0, 0, "NEXT@SAVE@SLOT", "PREV@SAVE@SLOT", // ?, ?, ?, ?, mot_vol_up, mot_vol_down, next_slot, prev_slot
|
|
0, 0, "PAUSE@EMU", "SAVE@STATE", "LOAD@STATE", "FRAMESKIP@8", "AUTO@FRAMESKIP", "DONE" // ?, switch_renderer
|
|
};
|
|
|
|
|
|
// globals are allowed, so why not to (ab)use them?
|
|
TInt machineUid = 0;
|
|
int gamestate = PGS_Paused, gamestate_prev = PGS_Paused;
|
|
TPicoConfig currentConfig;
|
|
TPicoKeyConfigEntry *keyConfig = 0; // currently used keys
|
|
static char noticeMsg[64]; // notice msg to draw
|
|
static timeval noticeMsgTime = { 0, 0 }; // when started showing
|
|
static RLibrary gameAudioLib; // audio object library
|
|
static _gameAudioNew gameAudioNew; // audio object maker
|
|
static IGameAudio *gameAudio = 0; // the audio object itself
|
|
static TProcessId launcherProcessId;
|
|
static int reset_timing, state_slot = 0;
|
|
extern const char *RomFileName;
|
|
extern int pico_was_reset;
|
|
#ifdef TEST_FRAMEBUFF
|
|
static TUint8 *iFrameBuffer = 0;
|
|
#endif
|
|
|
|
// some forward declarations
|
|
static void MainInit();
|
|
static void MainExit();
|
|
static void CheckForLauncher();
|
|
static void DumpMemInfo();
|
|
|
|
// just for a nicer grouping of WS related stuff
|
|
class CGameWindow
|
|
{
|
|
public:
|
|
static void ConstructResourcesL();
|
|
static void FreeResources();
|
|
static void DoKeys(timeval &time);
|
|
static void DoKeysConfig(TUint &which);
|
|
static void RunEvents(TUint32 which);
|
|
static void SendClientWsEvent(TInt type);
|
|
|
|
static RWsSession iWsSession;
|
|
static RWindowGroup iWsWindowGroup;
|
|
static RWindow iWsWindow;
|
|
static CWsScreenDevice* iWsScreen;
|
|
static CWindowGc* iWindowGc;
|
|
static TRequestStatus iWsEventStatus;
|
|
static TThreadId iLauncherThreadId;
|
|
static RDirectScreenAccess* iDSA;
|
|
static TRequestStatus iDSAstatus;
|
|
};
|
|
|
|
|
|
void SkipFrame(int do_sound)
|
|
{
|
|
PicoSkipFrame=1;
|
|
PicoFrame();
|
|
PicoSkipFrame=0;
|
|
|
|
if(do_sound && PsndOut) {
|
|
PsndOut = gameAudio->NextFrameL();
|
|
if(!PsndOut) { // sound output problems?
|
|
strcpy(noticeMsg, "SOUND@OUTPUT@ERROR;@SOUND@DISABLED");
|
|
gettimeofday(¬iceMsgTime, 0);
|
|
}
|
|
}
|
|
|
|
/*
|
|
int total=0;
|
|
|
|
// V-Blanking period:
|
|
if (Pico.video.reg[1]&0x20) SekInterrupt(6); // Set IRQ
|
|
Pico.video.status|=0x88; // V-Int happened / go into vblank
|
|
total+=SekRun(18560);
|
|
|
|
// Active Scan:
|
|
if (Pico.video.reg[1]&0x40) Pico.video.status&=~8; // Come out of vblank if display is enabled
|
|
SekInterrupt(0); // Clear IRQ
|
|
total+=SekRun(127969-total);
|
|
*/
|
|
}
|
|
|
|
|
|
void TargetEpocGameL()
|
|
{
|
|
char buff[24]; // fps count c string
|
|
struct timeval tval; // timing
|
|
int thissec = 0, frames_done = 0, frames_shown = 0;
|
|
int target_fps, target_frametime, too_fast, too_fast_time;
|
|
int i, underflow;
|
|
TRawEvent blevent;
|
|
|
|
MainInit();
|
|
buff[0] = 0;
|
|
|
|
// just to keep the backlight on..
|
|
blevent.Set(TRawEvent::EActive);
|
|
|
|
// loop?
|
|
for(;;) {
|
|
if(gamestate == PGS_Running) {
|
|
// prepare window and stuff
|
|
CGameWindow::ConstructResourcesL();
|
|
|
|
// if the system has something to do, it should better do it now
|
|
User::After(50000);
|
|
//CPolledActiveScheduler::Instance()->Schedule();
|
|
|
|
// pal/ntsc might have changed, reset related stuff
|
|
if(Pico.m.pal) {
|
|
target_fps = 50;
|
|
if(!noticeMsgTime.tv_sec) strcpy(noticeMsg, "PAL@SYSTEM@/@50@FPS");
|
|
} else {
|
|
target_fps = 60;
|
|
if(!noticeMsgTime.tv_sec) strcpy(noticeMsg, "NTSC@SYSTEM@/@60@FPS");
|
|
}
|
|
target_frametime = 1000000/target_fps;
|
|
if(!noticeMsgTime.tv_sec && pico_was_reset)
|
|
gettimeofday(¬iceMsgTime, 0);
|
|
|
|
pico_was_reset = too_fast = 0;
|
|
reset_timing = 1;
|
|
|
|
while(gamestate == PGS_Running) {
|
|
gettimeofday(&tval, 0);
|
|
if(reset_timing) {
|
|
reset_timing = 0;
|
|
thissec = tval.tv_sec;
|
|
frames_done = tval.tv_usec/target_frametime;
|
|
}
|
|
|
|
// show notice message?
|
|
char *notice = 0;
|
|
if(noticeMsgTime.tv_sec) {
|
|
if((tval.tv_sec*1000000+tval.tv_usec) - (noticeMsgTime.tv_sec*1000000+noticeMsgTime.tv_usec) > 2000000) // > 2.0 sec
|
|
noticeMsgTime.tv_sec = noticeMsgTime.tv_usec = 0;
|
|
else notice = noticeMsg;
|
|
}
|
|
|
|
// second changed?
|
|
if(thissec != tval.tv_sec) {
|
|
#ifdef BENCHMARK
|
|
static int bench = 0, bench_fps = 0, bench_fps_s = 0, bfp = 0, bf[4];
|
|
if(++bench == 10) {
|
|
bench = 0;
|
|
bench_fps_s = bench_fps;
|
|
bf[bfp++ & 3] = bench_fps;
|
|
bench_fps = 0;
|
|
}
|
|
bench_fps += frames_shown;
|
|
sprintf(buff, "%02i/%02i/%02i", frames_shown, bench_fps_s, (bf[0]+bf[1]+bf[2]+bf[3])>>2);
|
|
#else
|
|
if(currentConfig.iFlags & 2)
|
|
sprintf(buff, "%02i/%02i", frames_shown, frames_done);
|
|
#endif
|
|
thissec = tval.tv_sec;
|
|
if((thissec & 7) == 7) UserSvr::AddEvent(blevent);
|
|
// in is quite common for this implementation to leave 1 fame unfinished
|
|
// when second changes. This creates sound clicks, so it's probably better to
|
|
// skip that frame and render sound
|
|
if(PsndOut && frames_done < target_fps && frames_done > target_fps-5) {
|
|
SkipFrame(1); frames_done++;
|
|
}
|
|
// try to prevent sound buffer underflows by making sure we did _exactly_
|
|
// target_fps sound updates and copying last samples over and over again
|
|
if(PsndOut && frames_done < target_fps)
|
|
for(; frames_done < target_fps; frames_done++) {
|
|
PsndOut = gameAudio->DupeFrameL(underflow);
|
|
if(!PsndOut) { // sound output problems?
|
|
strcpy(noticeMsg, "SOUND@OUTPUT@ERROR;@SOUND@DISABLED");
|
|
gettimeofday(¬iceMsgTime, 0);
|
|
break;
|
|
}
|
|
if(underflow) break;
|
|
}
|
|
frames_done = frames_shown = 0;
|
|
}
|
|
|
|
if(currentConfig.iFrameskip >= 0) { // frameskip enabled
|
|
for(i = 0; i < currentConfig.iFrameskip; i++) {
|
|
SkipFrame(frames_done < target_fps); frames_done++;
|
|
CGameWindow::DoKeys(tval);
|
|
}
|
|
} else if(tval.tv_usec > (frames_done+1)*target_frametime) { // auto frameskip
|
|
// no time left for this frame - skip
|
|
SkipFrame(1); frames_done++;
|
|
CGameWindow::DoKeys(tval);
|
|
too_fast = 0;
|
|
continue;
|
|
} else if(tval.tv_usec < (too_fast_time=frames_done*target_frametime)) { // we are too fast
|
|
if(++too_fast > 2) { User::After(too_fast_time-tval.tv_usec); too_fast = 0; }// sleep, but only if we are _really_ fast
|
|
}
|
|
|
|
// draw
|
|
vidDrawFrame(notice, buff, frames_shown);
|
|
if(PsndOut && frames_done < target_fps) {
|
|
PsndOut = gameAudio->NextFrameL();
|
|
if(!PsndOut) { // sound output problems?
|
|
strcpy(noticeMsg, "SOUND@OUTPUT@ERROR;@SOUND@DISABLED");
|
|
gettimeofday(¬iceMsgTime, 0);
|
|
}
|
|
}
|
|
frames_done++; frames_shown++;
|
|
CGameWindow::DoKeys(tval);
|
|
}
|
|
|
|
// save SRAM
|
|
if((currentConfig.iFlags & 1) && SRam.changed) {
|
|
saveLoadGame(0, 1);
|
|
SRam.changed = 0;
|
|
}
|
|
CGameWindow::SendClientWsEvent(EEventGamePaused);
|
|
CGameWindow::FreeResources();
|
|
} else if(gamestate == PGS_Paused) {
|
|
for(i = 0; gamestate == PGS_Paused; i++) {
|
|
User::After(250000);
|
|
if(!(i & 0x7F)) CheckForLauncher(); // every 32 secs
|
|
}
|
|
} else if(gamestate == PGS_KeyConfig) {
|
|
// prepare window and stuff
|
|
CGameWindow::ConstructResourcesL();
|
|
|
|
TUint whichAction = 0;
|
|
while(gamestate == PGS_KeyConfig) {
|
|
vidKeyConfigFrame(whichAction, CGameWindow::iWsScreen->CurrentScreenMode());
|
|
CGameWindow::DoKeysConfig(whichAction);
|
|
User::After(200000);
|
|
}
|
|
|
|
CGameWindow::SendClientWsEvent(EEventKeyCfgDone);
|
|
CGameWindow::SendClientWsEvent(EEventGamePaused);
|
|
CGameWindow::FreeResources();
|
|
} else if(gamestate == PGS_DebugHeap) {
|
|
#ifdef __DEBUG_PRINT
|
|
TInt cells = User::CountAllocCells();
|
|
TInt mem;
|
|
User::AllocSize(mem);
|
|
DEBUGPRINT(_L("worker: cels=%d, size=%d KB"), cells, mem/1024);
|
|
gamestate = gamestate_prev;
|
|
#endif
|
|
} else if(gamestate == PGS_Quit) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
MainExit();
|
|
}
|
|
|
|
|
|
// gameAudio default "maker", which simply leaves
|
|
IGameAudio *gameAudioNew_failer(TInt aRate, TBool aStereo, TInt aPcmFrames, TInt aBufferedFrames)
|
|
{
|
|
User::Leave(1);
|
|
return 0; // shouldn't happen
|
|
}
|
|
|
|
|
|
// main initialization
|
|
static void MainInit()
|
|
{
|
|
RProcess thisProcess, launcherProcess;
|
|
TInt err = KErrGeneral;
|
|
|
|
DEBUGPRINT(_L("\r\n\r\nstarting.."));
|
|
|
|
//CPolledActiveScheduler::NewL(); // create Polled AS for the sound engine
|
|
|
|
// get launcher id
|
|
if(thisProcess.Owner(launcherProcess) == KErrNone) {
|
|
launcherProcessId = launcherProcess.Id();
|
|
launcherProcess.Close(); // messing with launcherProcess too much strangely reboots my phone
|
|
} else {
|
|
DEBUGPRINT(_L("%i: couldn't find owner, terminating.."), thisProcess.Id());
|
|
thisProcess.Terminate(1);
|
|
}
|
|
|
|
// also get launcher thread id (for sending events, nasty way)
|
|
TFindThread findThread;
|
|
TFullName dummy1;
|
|
RThread tmpThread;
|
|
RProcess tmpProcess;
|
|
|
|
while(findThread.Next(dummy1) == KErrNone)
|
|
{
|
|
tmpThread.Open(findThread);
|
|
tmpThread.Process(tmpProcess);
|
|
if(tmpProcess.Id() == launcherProcessId) {
|
|
CGameWindow::iLauncherThreadId = tmpThread.Id();
|
|
break;
|
|
}
|
|
tmpThread.Close();
|
|
tmpProcess.Close();
|
|
}
|
|
|
|
// start event listening thread, which waits for GUI commands
|
|
if(StartThread() < 0) {
|
|
// communication thread failed to start, we serve no purpose now, so suicide
|
|
DEBUGPRINT(_L("%i: StartThread() failed, terminating.."), thisProcess.Id());
|
|
thisProcess.Terminate(1);
|
|
}
|
|
|
|
HAL::Get(HALData::EMachineUid, machineUid); // find out the machine UID
|
|
|
|
// get current dir
|
|
TFileName pfName = thisProcess.FileName();
|
|
TParse parse;
|
|
parse.Set(pfName, 0, 0);
|
|
TPtrC currDir = parse.DriveAndPath();
|
|
DEBUGPRINT(_L("current dir: %S"), &currDir);
|
|
|
|
static TPtrC audio_dlls[] = { _L("audio_motorola.dll"), _L("audio_mediaserver.dll") };
|
|
|
|
// find our audio object maker
|
|
for(TInt i=0; i < 2; i++) {
|
|
DEBUGPRINT(_L("trying audio DLL: %S"), &audio_dlls[i]);
|
|
err = gameAudioLib.Load(audio_dlls[i], currDir);
|
|
if(err == KErrNone) { // great, we loaded a dll!
|
|
gameAudioNew = (_gameAudioNew) gameAudioLib.Lookup(1);
|
|
if(!gameAudioNew) {
|
|
gameAudioLib.Close();
|
|
err = KErrGeneral;
|
|
DEBUGPRINT(_L(" loaded, but Lookup(1) failed."));
|
|
} else
|
|
break; // done
|
|
} else
|
|
DEBUGPRINT(_L(" load failed! (%i)"), err);;
|
|
}
|
|
|
|
if(err != KErrNone)
|
|
gameAudioNew = gameAudioNew_failer;
|
|
else DEBUGPRINT(_L(" audio dll loaded!"));;
|
|
|
|
DumpMemInfo();
|
|
|
|
// try to start pico
|
|
DEBUGPRINT(_L("PicoInit();"));
|
|
PicoInit();
|
|
|
|
#ifdef TEST_FRAMEBUFF
|
|
iFrameBuffer = (TUint8 *) malloc(208*320*4);
|
|
#endif
|
|
}
|
|
|
|
|
|
// does not return
|
|
static void MainExit()
|
|
{
|
|
RProcess thisProcess;
|
|
|
|
DEBUGPRINT(_L("%i: cleaning up.."), thisProcess.Id());
|
|
|
|
// save SRAM
|
|
if((currentConfig.iFlags & 1) && SRam.changed) {
|
|
saveLoadGame(0, 1);
|
|
SRam.changed = 0;
|
|
}
|
|
|
|
PicoExit();
|
|
|
|
if(gameAudio) delete gameAudio;
|
|
|
|
if(gameAudioLib.Handle()) gameAudioLib.Close();
|
|
|
|
// Polled AS
|
|
//delete CPolledActiveScheduler::Instance();
|
|
|
|
DEBUGPRINT(_L("%i: terminating.."), thisProcess.Id());
|
|
thisProcess.Terminate(0);
|
|
}
|
|
|
|
|
|
static void CheckForLauncher()
|
|
{
|
|
RProcess launcherProcess;
|
|
|
|
// check for launcher, we are useless without it
|
|
if(launcherProcess.Open(launcherProcessId) != KErrNone || launcherProcess.ExitCategory().Length() != 0) {
|
|
#ifdef __DEBUG_PRINT
|
|
RProcess thisProcess;
|
|
DEBUGPRINT(_L("%i: launcher process is gone, terminating.."), thisProcess.Id());
|
|
if(launcherProcess.Handle()) {
|
|
TExitCategoryName ecn = launcherProcess.ExitCategory();
|
|
DEBUGPRINT(_L("%i: launcher exit category: %S"), thisProcess.Id(), &ecn);
|
|
launcherProcess.Close();
|
|
}
|
|
#endif
|
|
MainExit();
|
|
}
|
|
launcherProcess.Close();
|
|
}
|
|
|
|
|
|
void DumpMemInfo()
|
|
{
|
|
TInt ramSize, ramSizeFree, romSize;
|
|
|
|
HAL::Get(HALData::EMemoryRAM, ramSize);
|
|
HAL::Get(HALData::EMemoryRAMFree, ramSizeFree);
|
|
HAL::Get(HALData::EMemoryROM, romSize);
|
|
|
|
DEBUGPRINT(_L("ram=%dKB, ram_free=%dKB, rom=%dKB"), ramSize/1024, ramSizeFree/1024, romSize/1024);
|
|
}
|
|
|
|
|
|
|
|
TInt E32Main()
|
|
{
|
|
// first thing's first
|
|
RThread().SetExceptionHandler(&ExceptionHandler, -1);
|
|
|
|
//TInt pc, sp;
|
|
//asm volatile ("str pc, %0" : "=m" (pc) );
|
|
//asm volatile ("str sp, %0" : "=m" (sp) );
|
|
//RDebug::Print(_L("executing @ 0x%08x, sp=0x%08x"), pc, sp);
|
|
|
|
/*
|
|
RDebug::Print(_L("Base Bottom Top Size RW Name"));
|
|
TBuf<4> l_r(_L("R")), l_w(_L("W")), l_d(_L("-"));
|
|
RChunk chunk;
|
|
TFullName chunkname;
|
|
TFindChunk findChunk(_L("*"));
|
|
while( findChunk.Next(chunkname) != KErrNotFound ) {
|
|
chunk.Open(findChunk);
|
|
RDebug::Print(_L("%08x %08x %08x %08x %S%S %S"), chunk.Base(), chunk.Base()+chunk.Bottom(), chunk.Base()+chunk.Top(), chunk.Size(), chunk.IsReadable() ? &l_r : &l_d, chunk.IsWritable() ? &l_w : &l_d, &chunkname);
|
|
chunk.Close();
|
|
}
|
|
*/
|
|
|
|
CTrapCleanup* cleanup=CTrapCleanup::New();
|
|
|
|
TRAPD(error, TargetEpocGameL());
|
|
|
|
__ASSERT_ALWAYS(!error, User::Panic(_L("Picosmall"), error));
|
|
delete cleanup;
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
void CGameWindow::ConstructResourcesL()
|
|
{
|
|
|
|
// connect to window server
|
|
// tried to create it globally and not re-connect everytime,
|
|
// but my window started to lose focus strangely
|
|
User::LeaveIfError(iWsSession.Connect());
|
|
|
|
// * Tell the Window Server not to mess about with our process priority
|
|
// * Also, because of the way legacy games are written, they never sleep
|
|
// * and thus never voluntarily yield the CPU. We set our process priority
|
|
// * to EPriorityForeground and hope that a Telephony application on
|
|
// * this device runs at EPriorityForeground as well. If not, tough! ;-)
|
|
|
|
CGameWindow::iWsSession.ComputeMode(RWsSession::EPriorityControlDisabled);
|
|
RProcess me;
|
|
me.SetPriority(EPriorityForeground);
|
|
|
|
iWsScreen=new(ELeave) CWsScreenDevice(iWsSession);
|
|
User::LeaveIfError(iWsScreen->Construct());
|
|
// User::LeaveIfError(iWsScreen->CreateContext(iWindowGc));
|
|
|
|
iWsWindowGroup=RWindowGroup(iWsSession);
|
|
User::LeaveIfError(iWsWindowGroup.Construct((TUint32)&iWsWindowGroup));
|
|
//iWsWindowGroup.SetOrdinalPosition(0);
|
|
//iWsWindowGroup.SetName(KServerWGName);
|
|
iWsWindowGroup.EnableScreenChangeEvents(); // flip events (EEventScreenDeviceChanged)
|
|
iWsWindowGroup.EnableFocusChangeEvents(); // EEventFocusGroupChanged
|
|
iWsWindowGroup.SetOrdinalPosition(0, 1); // TInt aPos, TInt aOrdinalPriority
|
|
|
|
iWsWindow=RWindow(iWsSession);
|
|
User::LeaveIfError(iWsWindow.Construct(iWsWindowGroup, (TUint32)&iWsWindow));
|
|
iWsWindow.SetSize(iWsScreen->SizeInPixels());
|
|
iWsWindow.PointerFilter(EPointerFilterDrag, 0);
|
|
iWsWindow.SetPointerGrab(ETrue);
|
|
iWsWindow.SetVisible(ETrue);
|
|
iWsWindow.Activate();
|
|
|
|
// request access through RDirectScreenAccess api, but don't care about the result
|
|
RRegion *dsa_region = 0;
|
|
iDSA = new(ELeave) RDirectScreenAccess(iWsSession);
|
|
if(iDSA->Construct() == KErrNone)
|
|
iDSA->Request(dsa_region, iDSAstatus, iWsWindow);
|
|
DEBUGPRINT(_L("DSA: %i"), dsa_region ? dsa_region->Count() : -1);
|
|
|
|
// now get the screenbuffer
|
|
TScreenInfoV01 screenInfo;
|
|
TPckg<TScreenInfoV01> sI(screenInfo);
|
|
UserSvr::ScreenInfo(sI);
|
|
|
|
if(!screenInfo.iScreenAddressValid)
|
|
User::Leave(KErrNotSupported);
|
|
|
|
#ifndef TEST_FRAMEBUFF
|
|
TUint8 *iFrameBuffer = (TUint8*) screenInfo.iScreenAddress;
|
|
#endif
|
|
TInt p800 = 0;
|
|
|
|
switch(machineUid)
|
|
{
|
|
case 0x101f6b26: // A9xx & A10xx
|
|
case 0x101f6b27: // Chinese A10xx
|
|
case 0x101fd279: // P3x
|
|
iFrameBuffer += 32;
|
|
keyConfig = keyConfigMotA;
|
|
break;
|
|
case 0x101f408b: // P800
|
|
p800 = 1;
|
|
//case 0x101fb2ae: // P900
|
|
//case 0x10200ac6: // P910
|
|
default:
|
|
keyConfig = keyConfigPXXX;
|
|
break;
|
|
}
|
|
DEBUGPRINT(_L("framebuffer=0x%08x (%dx%d)"), iFrameBuffer,
|
|
screenInfo.iScreenSize.iWidth, screenInfo.iScreenSize.iHeight);
|
|
|
|
// vidInit
|
|
User::LeaveIfError(vidInit(iWsScreen->DisplayMode(), iFrameBuffer, p800));
|
|
|
|
// register for keyevents
|
|
for(TPicoKeyConfigEntry *e = keyConfig; e->name; e++) {
|
|
// release all keys
|
|
e->flags &= ~1;
|
|
if(e->flags & 0x80) {
|
|
// key disabled
|
|
e->handle1 = e->handle2 = -1;
|
|
continue;
|
|
}
|
|
e->handle1 = iWsWindowGroup.CaptureKeyUpAndDowns(e->scanCode, 0, 0, 2);
|
|
// although we only use UpAndDown events, register simple events too,
|
|
// just to prevent fireing their default actions.
|
|
if(e->keyCode) e->handle2 = iWsWindowGroup.CaptureKey(e->keyCode, 0, 0, 2); // priority of 1 is not enough on my phone
|
|
}
|
|
|
|
// try to start the audio engine
|
|
static int PsndRate_old = 0, PicoOpt_old = 0, pal_old = 0;
|
|
|
|
if(gamestate == PGS_Running && (currentConfig.iFlags & 4)) {
|
|
TInt err = 0;
|
|
if(PsndRate != PsndRate_old || (PicoOpt&11) != (PicoOpt_old&11) || Pico.m.pal != pal_old) {
|
|
// if rate changed, reset all enabled chips, else reset only those chips, which were recently enabled
|
|
//sound_reset(PsndRate != PsndRate_old ? PicoOpt : (PicoOpt&(PicoOpt^PicoOpt_old)));
|
|
sound_rerate();
|
|
}
|
|
if(!gameAudio || PsndRate != PsndRate_old || ((PicoOpt&8) ^ (PicoOpt_old&8)) || Pico.m.pal != pal_old) { // rate or stereo or pal/ntsc changed
|
|
if(gameAudio) delete gameAudio; gameAudio = 0;
|
|
DEBUGPRINT(_L("starting audio: %i len: %i stereo: %i, pal: %i"), PsndRate, PsndLen, PicoOpt&8, Pico.m.pal);
|
|
TRAP(err, gameAudio = gameAudioNew(PsndRate, (PicoOpt&8) ? 1 : 0, PsndLen, Pico.m.pal ? 10 : 12));
|
|
}
|
|
if( gameAudio)
|
|
TRAP(err, PsndOut = gameAudio->ResumeL());
|
|
if(err) {
|
|
if(gameAudio) delete gameAudio;
|
|
gameAudio = 0;
|
|
PsndOut = 0;
|
|
strcpy(noticeMsg, "SOUND@STARTUP@FAILED");
|
|
gettimeofday(¬iceMsgTime, 0);
|
|
}
|
|
PsndRate_old = PsndRate;
|
|
PicoOpt_old = PicoOpt;
|
|
pal_old = Pico.m.pal;
|
|
} else {
|
|
if(gameAudio) delete gameAudio;
|
|
gameAudio = 0;
|
|
PsndOut = 0;
|
|
}
|
|
|
|
// start key WS event polling
|
|
iWsSession.EventReady(&iWsEventStatus);
|
|
DEBUGPRINT(_L("CGameWindow::ConstructResourcesL() finished."));
|
|
}
|
|
|
|
|
|
void CGameWindow::FreeResources()
|
|
{
|
|
if(gameAudio) gameAudio->Pause();
|
|
|
|
// free RDirectScreenAccess stuff
|
|
iDSA->Cancel();
|
|
iDSA->Close();
|
|
delete iDSA;
|
|
iDSA = NULL;
|
|
|
|
iWsSession.EventReadyCancel();
|
|
|
|
for(TPicoKeyConfigEntry *e = keyConfig; e->name; e++) {
|
|
if(e->handle2 >= 0) iWsWindowGroup.CancelCaptureKey(e->handle2);
|
|
if(e->handle1 >= 0) iWsWindowGroup.CancelCaptureKeyUpAndDowns(e->handle1);
|
|
}
|
|
|
|
if(iWsWindow.WsHandle())
|
|
iWsWindow.Close();
|
|
|
|
if(iWsWindowGroup.WsHandle())
|
|
iWsWindowGroup.Close();
|
|
|
|
// these must be deleted before calling iWsSession.Close()
|
|
// delete iWindowGc;
|
|
// iWindowGc = NULL;
|
|
|
|
delete iWsScreen;
|
|
iWsScreen = NULL;
|
|
|
|
// emu might change renderer by itself, so we may need to sync config
|
|
if(PicoOpt != currentConfig.iPicoOpt) {
|
|
currentConfig.iFlags |= 0x80;
|
|
CGameWindow::SendClientWsEvent(EEventKeyCfgDone);
|
|
}
|
|
|
|
if(iWsSession.WsHandle())
|
|
iWsSession.Close();
|
|
|
|
vidFree();
|
|
|
|
#ifdef TEST_FRAMEBUFF
|
|
FILE *tmp = fopen("d:\\temp\\screen.raw", "wb");
|
|
fwrite(iFrameBuffer, 1, 208*320*4, tmp);
|
|
fclose(tmp);
|
|
#endif
|
|
}
|
|
|
|
|
|
void CGameWindow::DoKeys(timeval &time)
|
|
{
|
|
TWsEvent iWsEvent;
|
|
TInt iWsEventType;
|
|
unsigned long allActions = 0;
|
|
static unsigned long areaActions = 0, forceUpdate = 0;
|
|
int i, nEvents;
|
|
|
|
// detect if user is holding power button
|
|
static timeval powerPushed = { 0, 0 };
|
|
if(powerPushed.tv_sec) {
|
|
if((time.tv_sec*1000000+time.tv_usec) - (powerPushed.tv_sec*1000000+powerPushed.tv_usec) > 1000000) { // > 1 sec
|
|
gamestate = PGS_Paused;
|
|
powerPushed.tv_sec = powerPushed.tv_usec = 0;
|
|
}
|
|
}
|
|
|
|
for(nEvents = 0; iWsEventStatus != KRequestPending; nEvents++)
|
|
{
|
|
iWsSession.GetEvent(iWsEvent);
|
|
iWsEventType = iWsEvent.Type();
|
|
|
|
// pointer events?
|
|
if(iWsEventType == EEventPointer) {
|
|
if(iWsEvent.Pointer()->iType == TPointerEvent::EButton1Up) {
|
|
areaActions = 0; // remove all directionals
|
|
} else { // if(iWsEvent.Pointer()->iType == TPointerEvent::EButton1Down) {
|
|
TPoint p = iWsEvent.Pointer()->iPosition;
|
|
const TPicoAreaConfigEntry *e = areaConfig + 1;
|
|
for(i = 0; !e->rect.IsEmpty(); e++, i++)
|
|
if(e->rect.Contains(p)) {
|
|
areaActions = currentConfig.iAreaBinds[i];
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else if(iWsEventType == EEventKeyDown || iWsEventType == EEventKeyUp) {
|
|
TInt iScanCode = iWsEvent.Key()->iScanCode;
|
|
|
|
for(TPicoKeyConfigEntry *e = keyConfig; e->name; e++)
|
|
if(iScanCode == e->scanCode) {
|
|
if(iWsEventType == EEventKeyDown) e->flags |= 1;
|
|
else if((e->flags & 2) == 0) e->flags &= ~1;
|
|
break;
|
|
}
|
|
|
|
// power?
|
|
if(iScanCode == EScanPxxxPower || iScanCode == EScanMotAEnd) {
|
|
if(iWsEventType == EEventKeyDown)
|
|
powerPushed = time;
|
|
else powerPushed.tv_sec = powerPushed.tv_usec = 0;
|
|
}
|
|
}
|
|
else if(iWsEventType == EEventScreenDeviceChanged) {
|
|
// we have the priority, so the launcher will not be able to process this, but it has to
|
|
User::After(500000);
|
|
reset_timing = 1;
|
|
}
|
|
else if(iWsEventType == EEventFocusGroupChanged) {
|
|
TInt launcherGrpId = iWsSession.FindWindowGroupIdentifier(0, iLauncherThreadId);
|
|
TInt focusGrpId = iWsSession.GetFocusWindowGroup();
|
|
DEBUGPRINT(_L("EEventFocusGroupChanged: %i, our: %i, launcher: %i"),
|
|
focusGrpId, iWsWindowGroup.Identifier(), launcherGrpId);
|
|
// if it is not us and not launcher that got focus, pause emu
|
|
if(focusGrpId != iWsWindowGroup.Identifier() && focusGrpId != launcherGrpId)
|
|
gamestate = PGS_Paused;
|
|
}
|
|
|
|
iWsEventStatus = KRequestPending;
|
|
iWsSession.EventReady(&iWsEventStatus);
|
|
}
|
|
|
|
if(nEvents || forceUpdate) {
|
|
allActions = areaActions;
|
|
forceUpdate = 0;
|
|
|
|
// add all pushed button actions
|
|
i = 0;
|
|
for(TPicoKeyConfigEntry *e = keyConfig; e->name; e++, i++) {
|
|
if(e->flags & 1) allActions |= currentConfig.iKeyBinds[i];
|
|
if((e->flags& 3) == 3) forceUpdate = 1;
|
|
if(e->flags & 2) e->flags &= ~1;
|
|
}
|
|
|
|
PicoPad[0] = (unsigned short) allActions;
|
|
if(allActions & 0xFFFF0000) {
|
|
RunEvents(allActions >> 16);
|
|
areaActions = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void CGameWindow::DoKeysConfig(TUint &which)
|
|
{
|
|
TWsEvent iWsEvent;
|
|
int i;
|
|
|
|
// to detect if user is holding power button
|
|
static int powerIters = 0;
|
|
|
|
while(iWsEventStatus != KRequestPending)
|
|
{
|
|
TUint currentActCode = 1 << which;
|
|
|
|
iWsSession.GetEvent(iWsEvent);
|
|
|
|
// pointer events?
|
|
if(iWsEvent.Type() == EEventPointer) {
|
|
TPoint p = iWsEvent.Pointer()->iPosition;
|
|
TRect prev(190, 112, 208, 126);
|
|
TRect next(190, 194, 208, 208);
|
|
|
|
if(iWsEvent.Pointer()->iType == TPointerEvent::EButton1Down) {
|
|
if(prev.Contains(p)) do { which = (which-1) & 0x1F; } while(!actionNames[which]);
|
|
else if(next.Contains(p)) do { which = (which+1) & 0x1F; } while(!actionNames[which]);
|
|
else if(which == 31) gamestate = PGS_Paused; // done
|
|
else {
|
|
const TPicoAreaConfigEntry *e = areaConfig + 1;
|
|
for(i = 0; e->rect != TRect(0,0,0,0); e++, i++)
|
|
if(e->rect.Contains(p)) {
|
|
currentConfig.iAreaBinds[i] ^= currentActCode;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if(iWsEvent.Type() == EEventKeyDown || iWsEvent.Type() == EEventKeyUp)
|
|
{
|
|
//if(iWsEvent.Type() == EEventKey)
|
|
// DEBUGPRINT(_L("iWsEvent.Key()->iCode=0x%08x"), iWsEvent.Key()->iCode);
|
|
|
|
//if(iWsEvent.Type() == EEventKeyDown)
|
|
// DEBUGPRINT(_L("EEventKeyDown iScanCode=0x%08x"), iWsEvent.Key()->iScanCode);
|
|
|
|
//if(iWsEvent.Type() == EEventKeyUp)
|
|
// DEBUGPRINT(_L("EEventKeyUp iScanCode=0x%08x"), iWsEvent.Key()->iScanCode);
|
|
|
|
// key events?
|
|
if(iWsEvent.Type() == EEventKeyDown) {
|
|
if(iWsScreen->CurrentScreenMode() == 1 && iWsEvent.Key()->iScanCode == EScanPxxxJogUp) {
|
|
do { which = (which-1) & 0x1F; } while(!actionNames[which]);
|
|
} else if(iWsScreen->CurrentScreenMode() == 1 && iWsEvent.Key()->iScanCode == EScanPxxxJogDown) {
|
|
do { which = (which+1) & 0x1F; } while(!actionNames[which]);
|
|
} else if(which == 31) {
|
|
gamestate = PGS_Paused;
|
|
if(iWsScreen->CurrentScreenMode()) // flip closed
|
|
vidDrawFCconfigDone();
|
|
} else {
|
|
i = 0;
|
|
for(TPicoKeyConfigEntry *e = keyConfig; e->name; e++, i++)
|
|
if(iWsEvent.Key()->iScanCode == e->scanCode)
|
|
if(!(e->flags&0x40)) currentConfig.iKeyBinds[i] ^= currentActCode;
|
|
}
|
|
}
|
|
|
|
// power?
|
|
if(iWsEvent.Key()->iScanCode == EScanPxxxPower || iWsEvent.Key()->iScanCode == EScanMotAEnd)
|
|
{
|
|
if(iWsEvent.Type() == EEventKeyDown) powerIters = 1;
|
|
else if(iWsEvent.Type() == EEventKeyUp) powerIters = 0;
|
|
}
|
|
}
|
|
else if(iWsEvent.Type() == EEventScreenDeviceChanged) {
|
|
// trying to fix the P910 problem when something steals focus (and returns it after a while?)
|
|
User::After(300000);
|
|
}
|
|
else if(iWsEvent.Type() == EEventFocusGroupChanged) {
|
|
TInt launcherGrpId = iWsSession.FindWindowGroupIdentifier(0, iLauncherThreadId);
|
|
TInt focusGrpId = iWsSession.GetFocusWindowGroup();
|
|
DEBUGPRINT(_L("EEventFocusGroupChanged: %i, our: %i, launcher: %i"),
|
|
focusGrpId, iWsWindowGroup.Identifier(), launcherGrpId);
|
|
// if it is not us and not launcher that got focus, exit config mode
|
|
if(focusGrpId != iWsWindowGroup.Identifier() && focusGrpId != launcherGrpId) {
|
|
// don't give up that easily. May be the focus will be given back.
|
|
for (int i = 0; i < 4; i++) {
|
|
User::After(200000);
|
|
focusGrpId = iWsSession.GetFocusWindowGroup();
|
|
if(focusGrpId == iWsWindowGroup.Identifier() || focusGrpId == launcherGrpId) break;
|
|
}
|
|
if(focusGrpId != iWsWindowGroup.Identifier() && focusGrpId != launcherGrpId)
|
|
// we probably should give up now
|
|
gamestate = PGS_Paused;
|
|
}
|
|
}
|
|
|
|
iWsEventStatus = KRequestPending;
|
|
iWsSession.EventReady(&iWsEventStatus);
|
|
}
|
|
|
|
if(powerIters) { // iterations when power was down
|
|
powerIters++;
|
|
if(powerIters > 5) {
|
|
gamestate = PGS_Paused;
|
|
powerIters = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void CGameWindow::RunEvents(TUint32 which)
|
|
{
|
|
if(which & 0x4000) currentConfig.iFrameskip = -1;
|
|
if(which & 0x2000) currentConfig.iFrameskip = 8;
|
|
if(which & 0x1800) { // save or load (but not both)
|
|
if(PsndOut) gameAudio->Pause(); // this may take a while, so we pause sound output
|
|
|
|
vidDrawNotice((which & 0x1000) ? "LOADING@GAME" : "SAVING@GAME");
|
|
saveLoadGame(which & 0x1000);
|
|
|
|
if(PsndOut) PsndOut = gameAudio->ResumeL();
|
|
reset_timing = 1;
|
|
}
|
|
if(which & 0x0400) gamestate = PGS_Paused;
|
|
if(which & 0x0200) { // switch renderer
|
|
if(currentConfig.iScreenMode == TPicoConfig::PMCenter && !noticeMsgTime.tv_sec &&
|
|
(currentConfig.iScreenRotation == TPicoConfig::PRot90 || currentConfig.iScreenRotation == TPicoConfig::PRot270)) {
|
|
|
|
PicoOpt^=0x10;
|
|
vidInit(iWsScreen->DisplayMode(), 0, 0, 1);
|
|
|
|
strcpy(noticeMsg, (PicoOpt&0x10) ? "ALT@RENDERER" : "DEFAULT@RENDERER");
|
|
gettimeofday(¬iceMsgTime, 0);
|
|
}
|
|
}
|
|
if(which & 0x00c0) {
|
|
if(which&0x0080) {
|
|
state_slot -= 1;
|
|
if(state_slot < 0) state_slot = 9;
|
|
} else {
|
|
state_slot += 1;
|
|
if(state_slot > 9) state_slot = 0;
|
|
}
|
|
sprintf(noticeMsg, "SAVE@SLOT@%i@SELECTED", state_slot);
|
|
gettimeofday(¬iceMsgTime, 0);
|
|
}
|
|
if(which & 0x0020) if(gameAudio) gameAudio->ChangeVolume(0); // for Motorolas (broken?)
|
|
if(which & 0x0010) if(gameAudio) gameAudio->ChangeVolume(1);
|
|
}
|
|
|
|
|
|
// send event to launcher windowgroup (WS session MUST be alive)
|
|
void CGameWindow::SendClientWsEvent(TInt type)
|
|
{
|
|
if(!iWsSession.Handle()) {
|
|
DEBUGPRINT(_L("SendClientWsEvent(%i) called on dead iWsSession."), type);
|
|
return;
|
|
}
|
|
|
|
TWsEvent event;
|
|
event.SetType(type);
|
|
event.SetTimeNow();
|
|
|
|
TInt launcherGrpId = iWsSession.FindWindowGroupIdentifier(0, iLauncherThreadId);
|
|
if(launcherGrpId != KErrNotFound)
|
|
iWsSession.SendEventToWindowGroup(launcherGrpId, event);
|
|
else DEBUGPRINT(_L("failed to send event %i to launcher."), event.Type());
|
|
}
|
|
|
|
|
|
size_t gzRead2(void *p, size_t _size, size_t _n, void *file)
|
|
{
|
|
return gzread(file, p, _n);
|
|
}
|
|
|
|
|
|
size_t gzWrite2(void *p, size_t _size, size_t _n, void *file)
|
|
{
|
|
return gzwrite(file, p, _n);
|
|
}
|
|
|
|
|
|
// this function is shared between both threads
|
|
int saveLoadGame(int load, int sram)
|
|
{
|
|
int res = 0;
|
|
|
|
if(!RomFileName) return -1;
|
|
|
|
// make save filename
|
|
char saveFname[KMaxFileName];
|
|
strcpy(saveFname, RomFileName);
|
|
saveFname[KMaxFileName-8] = 0;
|
|
if(saveFname[strlen(saveFname)-4] == '.') saveFname[strlen(saveFname)-4] = 0;
|
|
if(sram) strcat(saveFname, ".srm");
|
|
else {
|
|
if(state_slot > 0 && state_slot < 10) sprintf(saveFname, "%s.%i", saveFname, state_slot);
|
|
strcat(saveFname, ".mds");
|
|
}
|
|
|
|
DEBUGPRINT(_L("saveLoad (%i, %i): %S"), load, sram, DO_CONV(saveFname));
|
|
|
|
if(sram) {
|
|
FILE *sramFile;
|
|
int sram_size = SRam.end-SRam.start+1;
|
|
if(SRam.reg_back & 4) sram_size=0x2000;
|
|
if(!SRam.data) return 0; // SRam forcefully disabled for this game
|
|
if(load) {
|
|
sramFile = fopen(saveFname, "rb");
|
|
if(!sramFile) return -1;
|
|
fread(SRam.data, 1, sram_size, sramFile);
|
|
fclose(sramFile);
|
|
} else {
|
|
// sram save needs some special processing
|
|
// see if we have anything to save
|
|
for(; sram_size > 0; sram_size--)
|
|
if(SRam.data[sram_size-1]) break;
|
|
|
|
if(sram_size) {
|
|
sramFile = fopen(saveFname, "wb");
|
|
res = fwrite(SRam.data, 1, sram_size, sramFile);
|
|
res = (res != sram_size) ? -1 : 0;
|
|
fclose((FILE *) sramFile);
|
|
}
|
|
}
|
|
return res;
|
|
} else {
|
|
void *PmovFile = NULL;
|
|
// try gzip first
|
|
if(currentConfig.iFlags & 0x80) {
|
|
strcat(saveFname, ".gz");
|
|
if( (PmovFile = gzopen(saveFname, load ? "rb" : "wb")) ) {
|
|
areaRead = gzRead2;
|
|
areaWrite = gzWrite2;
|
|
if(!load) gzsetparams(PmovFile, 9, Z_DEFAULT_STRATEGY);
|
|
} else
|
|
saveFname[strlen(saveFname)-3] = 0;
|
|
}
|
|
if(!PmovFile) { // gzip failed or was disabled
|
|
if( (PmovFile = fopen(saveFname, load ? "rb" : "wb")) ) {
|
|
areaRead = fread;
|
|
areaWrite = fwrite;
|
|
}
|
|
}
|
|
if(PmovFile) {
|
|
PmovState(load ? 6 : 5, PmovFile);
|
|
strcpy(noticeMsg, load ? "GAME@LOADED" : "GAME@SAVED");
|
|
if(areaRead == gzRead2)
|
|
gzclose(PmovFile);
|
|
else fclose ((FILE *) PmovFile);
|
|
PmovFile = 0;
|
|
} else {
|
|
strcpy(noticeMsg, load ? "LOAD@FAILED" : "SAVE@FAILED");
|
|
res = -1;
|
|
}
|
|
|
|
gettimeofday(¬iceMsgTime, 0);
|
|
return res;
|
|
}
|
|
}
|
|
|
|
// static class members
|
|
RWsSession CGameWindow::iWsSession;
|
|
RWindowGroup CGameWindow::iWsWindowGroup;
|
|
RWindow CGameWindow::iWsWindow;
|
|
CWsScreenDevice* CGameWindow::iWsScreen = NULL;
|
|
CWindowGc* CGameWindow::iWindowGc = NULL;
|
|
TRequestStatus CGameWindow::iWsEventStatus = KRequestPending;
|
|
TThreadId CGameWindow::iLauncherThreadId = 0;
|
|
RDirectScreenAccess* CGameWindow::iDSA;
|
|
TRequestStatus CGameWindow::iDSAstatus = KRequestPending;
|