void Red3dPrintFPS(float font_size, int x, int y, u32 fg_color, u32 bg_color) { if(FPS_Setup == 0) { sceRtcGetCurrentTick(&last_tick); tick_res = sceRtcGetTickResolution(); FPS_Setup = 1; } frame_count++; u64 curr_tick; sceRtcGetCurrentTick(&curr_tick); if((curr_tick-last_tick) >= tick_res) { curr_fps = 1.0f / curr_ms; sprintf(fps_buf, "Framerate: %d.%03d",(int)curr_fps,(int)((curr_fps-(int)curr_fps) * 1000.0f)); // debug Red3dPrintf(fps_buf, font_size, x, y, fg_color, bg_color); curr_ms = (((curr_tick-last_tick)) / (float)tick_res) / frame_count; frame_count = 0; sceRtcGetCurrentTick(&last_tick); } else { sprintf(fps_buf, "Framerate: %d.%03d",(int)curr_fps,(int)((curr_fps-(int)curr_fps) * 1000.0f)); // debug Red3dPrintf(fps_buf, font_size, x, y, fg_color, bg_color); } }
void pspCtrlSetPollingMode(int mode) { /* If autorepeat is being shut off, wait until it's "safe" */ if (PollingMode == PSP_CTRL_AUTOREPEAT) { int i; SceCtrlData p; u64 tick; int wait; do { wait = 0; if (!sceCtrlPeekBufferPositive(&p, 1)) break; /* Get current tick count */ sceRtcGetCurrentTick(&tick); /* If at least one button is being held, wait until */ /* next autorepeat interval, or until it's released */ for (i = 0; i < PSP_CTRL_BUTTONS; i++) if (tick < PushTime[i] && (p.Buttons & ButtonMap[i])) { wait = 1; break; } } while (wait); } PollingMode = mode; /* If autorepeat is being turned on, initialize autorepeat data */ if (mode == PSP_CTRL_AUTOREPEAT) { SceCtrlData p; int i; u64 tick; u32 tick_res; /* Poll the controls */ if (sceCtrlPeekBufferPositive(&p, 1)) { /* Get current tick count */ sceRtcGetCurrentTick(&tick); tick_res = sceRtcGetTickResolution(); /* Check each button */ for (i = 0; i < PSP_CTRL_BUTTONS; i++) PushTime[i] = (p.Buttons & ButtonMap[i]) ? tick + PSP_CTRL_DELAY * (tick_res / 1000) : 0; } } }
/** * Check that getCurrentTick works fine. * * @TODO: Currently sceKernelDelayThread only work with ms. * It should check that work with microseconds precission. */ void checkGetCurrentTick() { u64 tick0, tick1; int microseconds = 2 * 1000; // 2ms printf("Checking sceRtcGetCurrentTick\n"); sceRtcGetCurrentTick(&tick0); { sceKernelDelayThread(microseconds); } sceRtcGetCurrentTick(&tick1); printf("%d\n", (tick1 - tick0) >= microseconds); }
void timer_update() { u64 tcurr; sceRtcGetCurrentTick(&tcurr); int curr = (int)((tcurr-timer_t0)/10000); while(timer_curr<curr) timer_tick(); }
void updateDrawFPS() { u64 fpsTickNow; u64 TickDelta; frames++; totalfps++; sceRtcGetCurrentTick( &fpsTickNow ); TickDelta = fpsTickNow - fpsTickLast; if (TickDelta >= tickResolution) { fpsTickLast = fpsTickNow; totalseconds++; // fps from last "second" lastfps = frames; // average for entire program running time averagefps = totalfps / totalseconds; // fps from last second, or from last call to this function, which ever gives the lower fps lastfpskip = (u64)(frames * tickResolution) / TickDelta; pspDebugScreenSetOffset( (int)fbp0 ); pspDebugScreenSetXY( 0, 32 ); printf("FPS last:%05d/%05d ave:%05d \n", lastfps, lastfpskip, averagefps); printf("delta ticks: %lld", TickDelta); frames = 0; } }
double CTimer::GetDeltaTime( void ) { sceRtcGetCurrentTick( &timeNow ); double dt = ( timeNow - timeLastAsk ) / ((float) tickResolution ); timeLastAsk = timeNow; return dt; }
uint32 PspRtc::getMicros() { uint32 ticks[2]; sceRtcGetCurrentTick((u64 *)ticks); ticks[0] -= _startMicros; return ticks[0]; }
// returns number of milliseconds since game started int JGE::GetTime(void) { u64 curr; sceRtcGetCurrentTick(&curr); return (int)(curr / mTickFrequency); }
void PspRtc::init() { // init our starting ticks uint32 ticks[2]; sceRtcGetCurrentTick((u64 *)ticks); _startMillis = ticks[0]/1000; _startMicros = ticks[0]; //_lastMillis = ticks[0]/1000; //debug - only when we don't subtract startMillis }
//#Gets the time since the last call measured in seconds float getDeltaTime() { sceRtcGetCurrentTick( &timeNow ); float dt = ( timeNow - timeLastAsk ) / ((float) tickResolution ); timeLastAsk = timeNow; return dt; }
int Sys_Milliseconds (void) { u64 ticks = 0; u64 ms; sceRtcGetCurrentTick(&ticks); ms = (ticks - first_ticks) / ticks_per_ms; return ms; }
UInt64 SystemInfo::GetCpuCycles() { UInt64 ticks; int res = sceRtcGetCurrentTick(&ticks); GD_ASSERT(res == 0); res = sceRtcTickAddYears (&ticks,&ticks,-2000); GD_ASSERT(res == 0); return ticks; }
void testControllerTimmings() { u64 tick0, tick1; int n; SceCtrlData pad_data; SceCtrlLatch latch; // Test sceCtrlReadBufferPositive sceRtcGetCurrentTick(&tick0); for (n = 0; n < 5; n++) sceCtrlReadBufferPositive(&pad_data, 1); sceRtcGetCurrentTick(&tick1); printf("%d\n", (tick1 - tick0 > 5000)); // Test sceCtrlReadLatch sceRtcGetCurrentTick(&tick0); for (n = 0; n < 5; n++) sceCtrlReadLatch(&latch); sceRtcGetCurrentTick(&tick1); printf("%d\n", (tick1 - tick0 > 5000)); // Test sceCtrlPeekBufferPositive sceRtcGetCurrentTick(&tick0); for (n = 0; n < 5; n++) sceCtrlPeekBufferPositive(&pad_data, 1); sceRtcGetCurrentTick(&tick1); printf("%d\n", (tick1 - tick0 < 5000)); // Test sceCtrlPeekLatch /* sceRtcGetCurrentTick(&tick0); for (n = 0; n < 5; n++) sceCtrlPeekLatch(&pad_data, 1); sceRtcGetCurrentTick(&tick1); printf("%d\n", (tick1 - tick0 < 5000)); */ }
/* psp_timer_thread: * This PSP thread measures the elapsed time. */ static int psp_timer_thread() { uint64_t old_tick, new_tick; int interval; long delay; sceRtcGetCurrentTick(&old_tick); while (psp_timer_on) { /* Calculate actual time elapsed. */ sceRtcGetCurrentTick(&new_tick); interval = PSPTIMER_TO_TIMER(new_tick - old_tick); old_tick = new_tick; /* Handle a tick and rest. */ delay = _handle_timer_tick(interval); sceKernelDelayThreadCB(TIMER_TO_USEC(delay)); } sceKernelExitThread(0); return 0; }
void PspSpeedTests::tickSpeed() { uint32 ticksPerSecond = sceRtcGetTickResolution(); PSP_INFO_PRINT("ticksPerSecond[%d]\n", ticksPerSecond); uint32 currentTicks1[2]; uint32 currentTicks2[2]; sceRtcGetCurrentTick((u64 *)currentTicks1); sceRtcGetCurrentTick((u64 *)currentTicks2); PSP_INFO_PRINT("current tick[%x %x][%u %u]\n", currentTicks1[0], currentTicks1[1], currentTicks1[0], currentTicks1[1]); PSP_INFO_PRINT("current tick[%x %x][%u %u]\n", currentTicks2[0], currentTicks2[1], currentTicks2[0], currentTicks2[1]); pspTime time; sceRtcSetTick(&time, (u64 *)currentTicks2); PSP_INFO_PRINT("current tick in time, year[%d] month[%d] day[%d] hour[%d] minutes[%d] seconds[%d] us[%d]\n", time.year, time.month, time.day, time.hour, time.minutes, time.seconds, time.microseconds); pspTime time1; pspTime time2; sceRtcGetCurrentClockLocalTime(&time1); sceRtcGetCurrentClockLocalTime(&time2); PSP_INFO_PRINT("time1, year[%d] month[%d] day[%d] hour[%d] minutes[%d] seconds[%d] us[%d]\n", time1.year, time1.month, time1.day, time1.hour, time1.minutes, time1.seconds, time1.microseconds); PSP_INFO_PRINT("time2, year[%d] month[%d] day[%d] hour[%d] minutes[%d] seconds[%d] us[%d]\n", time2.year, time2.month, time2.day, time2.hour, time2.minutes, time2.seconds, time2.microseconds); }
void FPS( void ) { fps++; sceRtcGetCurrentTick( &fpsTickNow ); if( ((fpsTickNow - fpsTickLast)/((float)tickResolution)) >= 1.0f ) { fpsTickLast = fpsTickNow; sprintf( fpsDisplay, "FPS: %i", fps ); fps = 0; } pspDebugScreenSetOffset( (int)fbp0 ); pspDebugScreenSetXY( 0, 0 ); pspDebugScreenPrintf( fpsDisplay ); }
void pspVideoInit() { vita2d_init_advanced(10*1024*1024); vita2d_set_vblank_wait(0); /* Compute VBlank frequency */ uint64_t t[2]; int i; for (i = 0; i < 2; i++) { sceDisplayWaitVblankStart(); sceRtcGetCurrentTick(&t[i]); } VBlankFreq = round(1.00 / ((double)(t[1] - t[0]) * (1.00 / (double)sceRtcGetTickResolution()))); }
static int lua_showFPS(lua_State *L) { int argc = lua_gettop(L); if (argc > 0) { return luaL_error(L, "System.getFPS() takes no arguments"); } fps +=1; sceRtcGetCurrentTick( &timeNowFPS ); if( ((timeNowFPS - timeLastFPS)/((float)tickResolution)) >= 1.0f ) { timeLastFPS = timeNowFPS; } lua_pushnumber(L,fps); fps = 0; return 0; }
void JGE::Init() { #ifdef DEBUG_PRINT mDebug = true; #else mDebug = false; #endif if (mDebug) pspDebugScreenInit(); // do this so that we can use pspDebugScreenPrintf strcpy(mDebuggingMsg, ""); sceCtrlSetSamplingCycle(0); sceCtrlSetSamplingMode(PSP_CTRL_MODE_ANALOG); JRenderer::GetInstance(); JFileSystem::GetInstance(); JSoundSystem::GetInstance(); mDone = false; mPaused = false; mCriticalAssert = false; mClicked = false; //InitSfx(); //Create(); // mCurrMS = 1.0f; // mFPSSlice = 0; //struct timeval tp; //gettimeofday(&tp, NULL); //mTimeBase = tp.tv_sec; //mLastTime = GetTime(); mTickFrequency = sceRtcGetTickResolution(); sceRtcGetCurrentTick(&mLastTime); }
void JGE::Run() { u64 curr; while (!mDone) { if (!mPaused) { sceRtcGetCurrentTick(&curr); mDelta = (curr-mLastTime) / (float)mTickFrequency;// * 1000.0f; mLastTime = curr; sceCtrlPeekBufferPositive(&mCtrlPad, 1); // using sceCtrlPeekBufferPositive is faster than sceCtrlReadBufferPositive // because sceCtrlReadBufferPositive waits for vsync internally Update(); mClicked = false; Render(); if (mDebug) { if (strlen(mDebuggingMsg)>0) { pspDebugScreenSetXY(0, 0); pspDebugScreenPrintf(mDebuggingMsg); } } mOldButtons = mCtrlPad.Buttons; } } }
void DebugScreen( void ) { fps++; sceRtcGetCurrentTick( &fpsTickNow ); if( ((fpsTickNow - fpsTickLast)/((float)tickResolution)) >= 1.0f ) { fpsTickLast = fpsTickNow; sprintf( fpsDisplay, "FPS: %i", fps ); fps = 0; } pspDebugScreenSetOffset( (int)fbp0 ); pspDebugScreenSetXY( 0, 0 ); pspDebugScreenPrintf( fpsDisplay ); pspDebugScreenSetXY( 0, 1 ); pspDebugScreenPrintf( "%f", timerTest.getSeconds() ); pspDebugScreenSetXY( 0, 2 ); pspDebugScreenPrintf( "%f %f %f %d", myScene.cam->position.x, myScene.cam->position.y, myScene.cam->position.z, myScene.cam->type); }
// Note that after we fill up 32 bits ie 50 days we'll loop back to 0, which may cause // unpredictable results uint32 PspRtc::getMillis(bool skipRecord) { uint32 ticks[2]; sceRtcGetCurrentTick((u64 *)ticks); // can introduce weird thread delays uint32 millis = ticks[0]/1000; millis -= _startMillis; // get ms since start of program if ((int)_lastMillis - (int)millis > MS_LOOP_CHECK) { // we must have looped around if (_looped == false) { // check to make sure threads do this once _looped = true; _milliOffset += MS_LOOP_AROUND; // add the needed offset PSP_DEBUG_PRINT("looping around. last ms[%d], curr ms[%d]\n", _lastMillis, millis); } } else { _looped = false; } _lastMillis = millis; return millis + _milliOffset; }
static void filter_repeats(SceCtrlData *pad) { SceCtrlData p = *pad; int i; uint64_t tick; uint32_t tick_res; /* Get current tick count */ sceRtcGetCurrentTick(&tick); tick_res = sceRtcGetTickResolution(); /* Check each button */ for (i = 0; i < _button_map[i]; i++) { if (p.buttons & _button_map[i]) { if (!_push_time[i] || tick >= _push_time[i]) { /* Button was pushed for the first time, or time to repeat */ pad->buttons |= _button_map[i]; /* Compute next press time */ _push_time[i] = tick + ((_push_time[i]) ? PL_VK_THRESHOLD : PL_VK_DELAY) * (tick_res / 1000); } else { /* No need to repeat yet */ pad->buttons &= ~_button_map[i]; } } else { /* Button was released */ pad->buttons &= ~_button_map[i]; _push_time[i] = 0; } } }
void DisplayFPS() { uint64_t currentTick = 0; int result = sceRtcGetCurrentTick(¤tTick); if (result != 0) { printf("sceRtcGetCurrentTick : 0x%x\n", currentTick); } uint64_t difference = currentTick - lastTick; lastTick = currentTick; int fps = sceRtcGetTickResolution() / (int) difference; fpsTimes[fpsIndex] = fps; if (++fpsIndex == FPS_TIMES_COUNT) { fpsIndex = 0; } fps = 0; int i; for (i = 0; i < FPS_TIMES_COUNT; ++i) { fps += fpsTimes[i]; } fps /= FPS_TIMES_COUNT; PSP2_Video_FillScreen(SCREEN_W * 200); sprintf(fpstext, "FPS: %d", fps); mh_print(5, 5, fpstext, RGBA8(0, 255, 0, 255), 0, 0); }
static bool psp_frame(void *data, const void *frame, unsigned width, unsigned height, unsigned pitch, const char *msg) { static char fps_txt[128], fps_text_buf[128]; psp1_video_t *psp = (psp1_video_t*)data; #ifdef DISPLAY_FPS static uint64_t currentTick,lastTick; static float fps=0.0; static int frames; #endif if (!width || !height) return false; if (((uint32_t)frame&0x04000000) || (frame == RETRO_HW_FRAME_BUFFER_VALID)) psp->hw_render = true; else if (frame) psp->hw_render = false; if (!psp->hw_render) sceGuSync(0, 0); /* let the core decide when to sync when HW_RENDER */ pspDebugScreenSetBase(psp->draw_buffer); pspDebugScreenSetXY(0,0); video_monitor_get_fps(fps_txt, sizeof(fps_txt), g_settings.fps_show ? fps_text_buf : NULL, g_settings.fps_show ? sizeof(fps_text_buf) : 0); if(g_settings.fps_show) { pspDebugScreenSetXY(68 - strlen(fps_text_buf) - 1,0); pspDebugScreenPuts(fps_text_buf); pspDebugScreenSetXY(0,1); } if (msg) pspDebugScreenPuts(msg); if ((psp->vsync)&&(psp->vblank_not_reached)) sceDisplayWaitVblankStart(); psp->vblank_not_reached = true; #ifdef DISPLAY_FPS frames++; sceRtcGetCurrentTick(¤tTick); uint32_t diff = currentTick - lastTick; if(diff > 1000000) { fps = (float)frames * 1000000.0 / diff; lastTick = currentTick; frames = 0; } pspDebugScreenSetXY(0,0); pspDebugScreenPrintf("%f", fps); #endif psp->draw_buffer = FROM_GU_POINTER(sceGuSwapBuffers()); g_extern.frame_count++; RARCH_PERFORMANCE_INIT(psp_frame_run); RARCH_PERFORMANCE_START(psp_frame_run); if (psp->should_resize) psp_update_viewport(psp); psp_set_tex_coords(psp->frame_coords, width, height); sceGuStart(GU_DIRECT, psp->main_dList); sceGuTexFilter(psp->tex_filter, psp->tex_filter); sceGuClear(GU_COLOR_BUFFER_BIT); /* frame in VRAM ? texture/palette was * set in core so draw directly */ if (psp->hw_render) sceGuDrawArray(GU_SPRITES, GU_TEXTURE_32BITF | GU_VERTEX_32BITF | GU_TRANSFORM_2D, PSP_FRAME_VERTEX_COUNT, NULL, (void*)(psp->frame_coords)); else { if (frame) { sceKernelDcacheWritebackRange(frame,pitch * height); sceGuCopyImage(GU_PSM_5650, ((u32)frame & 0xF) >> psp->bpp_log2, 0, width, height, pitch >> psp->bpp_log2, (void*)((u32)frame & ~0xF), 0, 0, width, psp->texture); } sceGuTexImage(0, next_pow2(width), next_pow2(height), width, psp->texture); sceGuCallList(psp->frame_dList); } sceGuFinish(); RARCH_PERFORMANCE_STOP(psp_frame_run); if(psp->menu.active) { sceGuSendList(GU_TAIL, psp->menu.dList, &(psp->menu.context_storage)); sceGuSync(0, 0); } return true; }
// Main function int main(int argc, char **argv) { int battimeout = 0; char fpstxt[16]; // Open debug files PokeDebugFOut = fopen("dbg_stdout.txt", "w"); PokeDebugFErr = fopen("dbg_stderr.txt", "w"); // Init video PokeDPrint(POKEMSG_OUT, "%s\n\n", AppName); PokeMini_InitDirs(argv[0], NULL); CommandLineInit(); CommandLine.low_battery = 2; // PSP can report battery status CommandLineConfFile("pokemini.cfg", "pokemini_psp.cfg", CustomConf); JoystickSetup("PSP", 0, 30000, PSP_KeysNames, 16, PSP_KeysMapping); // PSP Init and set screen PSP_Init(); setup_screen(); // Create emulator and load test roms PokeDPrint(POKEMSG_OUT, "Starting emulator...\n"); PokeMini_Create(POKEMINI_GENSOUND | POKEMINI_AUTOBATT, 0); // Setup palette and LCD mode PokeMini_VideoPalette_Init(PokeMini_RGB16, 1); PokeMini_VideoPalette_Index(CommandLine.palette, CommandLine.custompal, CommandLine.lcdcontrast, CommandLine.lcdbright); PokeMini_ApplyChanges(); // Load stuff PokeMini_UseDefaultCallbacks(); if (!PokeMini_LoadFromCommandLines("Using FreeBIOS", "EEPROM data will be discarded!")) { UI_Status = UI_STATUS_MENU; } // Enable sound & init UI PokeDPrint(POKEMSG_OUT, "Running emulator...\n"); UIMenu_Init(); enablesound(CommandLine.sound); sceCtrlSetSamplingCycle(0); sceCtrlSetSamplingMode(PSP_CTRL_MODE_ANALOG); // Emulator's loop u64 tickcurr; u64 fpsticknext,fpstickres = (u64)sceRtcGetTickResolution(); u64 frmticknext, frmtickres = (u64)sceRtcGetTickResolution() / 36; sceRtcGetCurrentTick(&tickcurr); fpsticknext = tickcurr + fpstickres; frmticknext = tickcurr + frmtickres; int fps = 72, fpscnt = 0; strcpy(fpstxt, ""); while (emurunning) { // Emulate 2 frames PokeMini_EmulateFrame(); PokeMini_EmulateFrame(); if (RequireSoundSync) { while (MinxAudio_SyncWithAudio()) sceKernelDelayThread(1000); } else { do { sceRtcGetCurrentTick(&tickcurr); sceKernelDelayThread(1000); } while (tickcurr < frmticknext); frmticknext = tickcurr + frmtickres; // Aprox 36 times per sec } // Screen rendering PSP_ClearDraw(); if (PokeMini_Rumbling) { PokeMini_VideoBlit((uint16_t *)PSP_DrawVideo + pm_offset + PokeMini_GenRumbleOffset(512), 512); } else { PokeMini_VideoBlit((uint16_t *)PSP_DrawVideo + pm_offset, 512); } LCDDirty = 0; // Display FPS counter if (clc_displayfps) { sceRtcGetCurrentTick(&tickcurr); if (tickcurr >= fpsticknext) { fpsticknext = tickcurr + fpstickres; fps = fpscnt; fpscnt = 0; sprintf(fpstxt, "%i FPS", fps); } else fpscnt++; UIDraw_String_16((uint16_t *)PSP_DrawVideo, 512, 4, 4, 10, fpstxt, UI_Font1_Pal16); } // Handle keys HandleKeys(); // Menu if (UI_Status == UI_STATUS_MENU) menuloop(); // Wait VSync & Render (72 Hz) PSP_Flip(); // Check battery if (battimeout <= 0) { PokeMini_LowPower(scePowerIsLowBattery()); battimeout = 600; } else battimeout--; } // Stop sound & free UI enablesound(0); UIMenu_Destroy(); // Save Stuff PokeMini_SaveFromCommandLines(1); // Terminate... PokeDPrint(POKEMSG_OUT, "Shutdown emulator...\n"); PokeMini_VideoPalette_Free(); PokeMini_Destroy(); // Close debug files fclose(PokeDebugFOut); fclose(PokeDebugFErr); // PSP Quit PSP_Quit(); return 0; }
u64 GetNowHiPerformanceCount() { u64 tick; if(sceRtcGetCurrentTick(&tick) != 0)return 0; return tick; }
static u64 psp_ticker(void) { u64 current_ticks; sceRtcGetCurrentTick(¤t_ticks); return (current_ticks); }
int main(int argc, char** argv) { sceRtcGetCurrentTick( &fpsTickLast ); tickResolution = sceRtcGetTickResolution(); Gamepad gamepad; App_Initialize(); timerTest.start(); float nextUpdate = 0; while(1) { timerTest.update(); (*mySceneMotion).evaluate(timerTest.getSeconds()); App_Render(); if(gamepad.Poll()) { if(gamepad.ButtonDown(PSP_CTRL_TRIANGLE)) { timerTest.paused(true); } if(gamepad.ButtonDown(PSP_CTRL_SQUARE)) { timerTest.paused(false); } if(timerTest.paused()) { if(fabs(gamepad.AnalogX()) > 0.1) { if(gamepad.ButtonDown(PSP_CTRL_RTRIGGER)) { if(timerTest.getSeconds() - 0.5f > 0 || gamepad.AnalogX() > 0) timerTest.setSeconds(timerTest.getSeconds() + (gamepad.AnalogX() * 0.5)); } else { if(timerTest.getSeconds() - 0.1f > 0 || gamepad.AnalogX() > 0) timerTest.setSeconds(timerTest.getSeconds() + (gamepad.AnalogX() * 0.1)); } } } if(gamepad.ButtonDown(PSP_CTRL_LEFT)) { if(gamepad.ButtonDown(PSP_CTRL_RTRIGGER)) { if(timerTest.getSeconds() - 0.1f > 0) timerTest.setSeconds(timerTest.getSeconds() - 0.1); } else { if(timerTest.getSeconds() - 0.01f > 0) timerTest.setSeconds(timerTest.getSeconds() - 0.01); } } if(gamepad.ButtonDown(PSP_CTRL_RIGHT)) { if(gamepad.ButtonDown(PSP_CTRL_RTRIGGER)) { timerTest.setSeconds(timerTest.getSeconds() + 0.1); } else { timerTest.setSeconds(timerTest.getSeconds() + 0.01); } } } } App_Shutdown(); return 0; }
int main(int argc, char **argv) { SceCtrlData pad; int oldButtons = 0; int useVblank = 1; pspDebugScreenInit(); if (argc > 0) { printf("Bootpath: %s\n", argv[0]); } printf("Triangle - Exit\n"); printf("Square - Toggle vblank (60 fps limit)\n"); printf("\n"); SetupCallbacks(); sceCtrlSetSamplingCycle(0); sceCtrlSetSamplingMode(PSP_CTRL_MODE_ANALOG); sceRtcGetCurrentTick( &fpsTickLast ); tickResolution = sceRtcGetTickResolution(); printGetDayOfWeek(); printf("\n"); printGetDaysInMonth(); printf("\n"); printSetTick(); printf("\n"); printGetTick(); printf("\n"); printf("sceRtcGetTickResolution: %d", (int)tickResolution); while(!done) { sceCtrlPeekBufferPositive(&pad, 1); int buttonDown = (oldButtons ^ pad.Buttons) & pad.Buttons; if (buttonDown & PSP_CTRL_SQUARE) { useVblank ^= 1; } if (buttonDown & PSP_CTRL_TRIANGLE) done = 1; oldButtons = pad.Buttons; updateDrawFPS(); if (useVblank) sceDisplayWaitVblankStart(); fbp0 = sceGuSwapBuffers(); } sceKernelExitGame(); // Quits Application return 0; }