static void psp_joypad_poll(void)
{
int32_t ret;
SceCtrlData state_tmp;
global_t *global = global_get_ptr();
uint64_t *lifecycle_state = (uint64_t*)&global->lifecycle_state;
#ifdef PSP
sceCtrlSetSamplingCycle(0);
#endif
sceCtrlSetSamplingMode(DEFAULT_SAMPLING_MODE);
ret = CtrlPeekBufferPositive(0, &state_tmp, 1);
#ifdef HAVE_KERNEL_PRX
state_tmp.Buttons = (state_tmp.Buttons&0x0000FFFF)|(read_system_buttons()&0xFFFF0000);
#endif
(void)ret;
analog_state[0][0][0] = analog_state[0][0][1] =
analog_state[0][1][0] = analog_state[0][1][1] = 0;
pad_state = 0;
pad_state |= (STATE_BUTTON(state_tmp) & PSP_CTRL_LEFT) ? (1ULL << RETRO_DEVICE_ID_JOYPAD_LEFT) : 0;
pad_state |= (STATE_BUTTON(state_tmp) & PSP_CTRL_DOWN) ? (1ULL << RETRO_DEVICE_ID_JOYPAD_DOWN) : 0;
pad_state |= (STATE_BUTTON(state_tmp) & PSP_CTRL_RIGHT) ? (1ULL << RETRO_DEVICE_ID_JOYPAD_RIGHT) : 0;
pad_state |= (STATE_BUTTON(state_tmp) & PSP_CTRL_UP) ? (1ULL << RETRO_DEVICE_ID_JOYPAD_UP) : 0;
pad_state |= (STATE_BUTTON(state_tmp) & PSP_CTRL_START) ? (1ULL << RETRO_DEVICE_ID_JOYPAD_START) : 0;
pad_state |= (STATE_BUTTON(state_tmp) & PSP_CTRL_SELECT) ? (1ULL << RETRO_DEVICE_ID_JOYPAD_SELECT) : 0;
pad_state |= (STATE_BUTTON(state_tmp) & PSP_CTRL_TRIANGLE) ? (1ULL << RETRO_DEVICE_ID_JOYPAD_X) : 0;
pad_state |= (STATE_BUTTON(state_tmp) & PSP_CTRL_SQUARE) ? (1ULL << RETRO_DEVICE_ID_JOYPAD_Y) : 0;
pad_state |= (STATE_BUTTON(state_tmp) & PSP_CTRL_CROSS) ? (1ULL << RETRO_DEVICE_ID_JOYPAD_B) : 0;
pad_state |= (STATE_BUTTON(state_tmp) & PSP_CTRL_CIRCLE) ? (1ULL << RETRO_DEVICE_ID_JOYPAD_A) : 0;
pad_state |= (STATE_BUTTON(state_tmp) & PSP_CTRL_R) ? (1ULL << RETRO_DEVICE_ID_JOYPAD_R) : 0;
pad_state |= (STATE_BUTTON(state_tmp) & PSP_CTRL_L) ? (1ULL << RETRO_DEVICE_ID_JOYPAD_L) : 0;
analog_state[0][RETRO_DEVICE_INDEX_ANALOG_LEFT] [RETRO_DEVICE_ID_ANALOG_X] = (int16_t)(STATE_ANALOGLX(state_tmp)-128) * 256;
analog_state[0][RETRO_DEVICE_INDEX_ANALOG_LEFT] [RETRO_DEVICE_ID_ANALOG_Y] = (int16_t)(STATE_ANALOGLY(state_tmp)-128) * 256;
#ifdef SN_TARGET_PSP2
analog_state[0][RETRO_DEVICE_INDEX_ANALOG_RIGHT][RETRO_DEVICE_ID_ANALOG_X] = (int16_t)(STATE_ANALOGRX(state_tmp)-128) * 256;
analog_state[0][RETRO_DEVICE_INDEX_ANALOG_RIGHT][RETRO_DEVICE_ID_ANALOG_Y] = (int16_t)(STATE_ANALOGRY(state_tmp)-128) * 256;
#endif
for (int i = 0; i < 2; i++)
for (int j = 0; j < 2; j++)
if (analog_state[0][i][j] == -0x8000)
analog_state[0][i][j] = -0x7fff;
*lifecycle_state &= ~((1ULL << RARCH_MENU_TOGGLE));
#ifdef HAVE_KERNEL_PRX
if (STATE_BUTTON(state_tmp) & PSP_CTRL_NOTE)
#else
if (
(pad_state & (1ULL << RETRO_DEVICE_ID_JOYPAD_L))
&& (pad_state & (1ULL << RETRO_DEVICE_ID_JOYPAD_R))
&& (pad_state & (1ULL << RETRO_DEVICE_ID_JOYPAD_SELECT))
&& (pad_state & (1ULL << RETRO_DEVICE_ID_JOYPAD_START))
)
#endif
*lifecycle_state |= (1ULL << RARCH_MENU_TOGGLE);
}
/**
* control_init: Initialize the controller input management code.
*
* [Parameters]
* None
* [Return value]
* Nonzero on success, zero on error
*/
int control_init(void)
{
sceCtrlSetSamplingCycle(0);
sceCtrlSetSamplingMode(PSP_CTRL_MODE_ANALOG);
buttons = last_buttons = 0;
return 1;
}
void pspCtrlInit()
{
/* Init PSP controller */
sceCtrlSetSamplingCycle(0);
sceCtrlSetSamplingMode(PSP_CTRL_MODE_ANALOG);
PollingMode = PSP_CTRL_NORMAL;
}
void init_input(void)
{
sceCtrlSetSamplingCycle(0);
sceCtrlSetSamplingMode(PSP_CTRL_MODE_ANALOG);
__sceCtrlPeekBufferPositive = sceCtrlPeekBufferPositive;
__sceCtrlReadBufferPositive = sceCtrlReadBufferPositive;
}
static void psp_joypad_poll(void)
{
int32_t ret;
unsigned i, j, k;
SceCtrlData state_tmp;
unsigned players_count = 1;
#ifdef PSP
sceCtrlSetSamplingCycle(0);
#endif
sceCtrlSetSamplingMode(DEFAULT_SAMPLING_MODE);
ret = CtrlPeekBufferPositive(0, &state_tmp, 1);
for (i = 0; i < players_count; i++)
{
#ifdef HAVE_KERNEL_PRX
state_tmp.Buttons = (state_tmp.Buttons & 0x0000FFFF)
| (read_system_buttons() & 0xFFFF0000);
#endif
(void)ret;
analog_state[i][0][0] = analog_state[i][0][1] =
analog_state[i][1][0] = analog_state[i][1][1] = 0;
pad_state[i] = 0;
pad_state[i] |= (STATE_BUTTON(state_tmp) & PSP_CTRL_LEFT) ? (UINT64_C(1) << RETRO_DEVICE_ID_JOYPAD_LEFT) : 0;
pad_state[i] |= (STATE_BUTTON(state_tmp) & PSP_CTRL_DOWN) ? (UINT64_C(1) << RETRO_DEVICE_ID_JOYPAD_DOWN) : 0;
pad_state[i] |= (STATE_BUTTON(state_tmp) & PSP_CTRL_RIGHT) ? (UINT64_C(1) << RETRO_DEVICE_ID_JOYPAD_RIGHT) : 0;
pad_state[i] |= (STATE_BUTTON(state_tmp) & PSP_CTRL_UP) ? (UINT64_C(1) << RETRO_DEVICE_ID_JOYPAD_UP) : 0;
pad_state[i] |= (STATE_BUTTON(state_tmp) & PSP_CTRL_START) ? (UINT64_C(1) << RETRO_DEVICE_ID_JOYPAD_START) : 0;
pad_state[i] |= (STATE_BUTTON(state_tmp) & PSP_CTRL_SELECT) ? (UINT64_C(1) << RETRO_DEVICE_ID_JOYPAD_SELECT) : 0;
pad_state[i] |= (STATE_BUTTON(state_tmp) & PSP_CTRL_TRIANGLE) ? (UINT64_C(1) << RETRO_DEVICE_ID_JOYPAD_X) : 0;
pad_state[i] |= (STATE_BUTTON(state_tmp) & PSP_CTRL_SQUARE) ? (UINT64_C(1) << RETRO_DEVICE_ID_JOYPAD_Y) : 0;
pad_state[i] |= (STATE_BUTTON(state_tmp) & PSP_CTRL_CROSS) ? (UINT64_C(1) << RETRO_DEVICE_ID_JOYPAD_B) : 0;
pad_state[i] |= (STATE_BUTTON(state_tmp) & PSP_CTRL_CIRCLE) ? (UINT64_C(1) << RETRO_DEVICE_ID_JOYPAD_A) : 0;
pad_state[i] |= (STATE_BUTTON(state_tmp) & PSP_CTRL_R) ? (UINT64_C(1) << RETRO_DEVICE_ID_JOYPAD_R) : 0;
pad_state[i] |= (STATE_BUTTON(state_tmp) & PSP_CTRL_L) ? (UINT64_C(1) << RETRO_DEVICE_ID_JOYPAD_L) : 0;
analog_state[i][RETRO_DEVICE_INDEX_ANALOG_LEFT] [RETRO_DEVICE_ID_ANALOG_X] = (int16_t)(STATE_ANALOGLX(state_tmp)-128) * 256;
analog_state[i][RETRO_DEVICE_INDEX_ANALOG_LEFT] [RETRO_DEVICE_ID_ANALOG_Y] = (int16_t)(STATE_ANALOGLY(state_tmp)-128) * 256;
#if defined(SN_TARGET_PSP2) || defined(VITA)
analog_state[i][RETRO_DEVICE_INDEX_ANALOG_RIGHT][RETRO_DEVICE_ID_ANALOG_X] = (int16_t)(STATE_ANALOGRX(state_tmp)-128) * 256;
analog_state[i][RETRO_DEVICE_INDEX_ANALOG_RIGHT][RETRO_DEVICE_ID_ANALOG_Y] = (int16_t)(STATE_ANALOGRY(state_tmp)-128) * 256;
#endif
for (j = 0; j < 2; j++)
for (k = 0; k < 2; k++)
if (analog_state[i][j][k] == -0x8000)
analog_state[i][j][k] = -0x7fff;
}
BIT64_CLEAR(lifecycle_state, RARCH_MENU_TOGGLE);
#ifdef HAVE_KERNEL_PRX
if (STATE_BUTTON(state_tmp) & PSP_CTRL_NOTE)
BIT64_SET(lifecycle_state, RARCH_MENU_TOGGLE);
#endif
}
static void psp_input_poll(void *data)
{
int32_t ret;
uint64_t *lifecycle_state = (uint64_t*)&g_extern.lifecycle_state;
SceCtrlData state_tmp;
psp_input_t *psp = (psp_input_t*)data;
#ifdef PSP
sceCtrlSetSamplingCycle(0);
#endif
sceCtrlSetSamplingMode(DEFAULT_SAMPLING_MODE);
ret = CtrlPeekBufferPositive(0, &state_tmp, 1);
(void)ret;
psp->analog_state[0][0][0] = psp->analog_state[0][0][1] = psp->analog_state[0][1][0] = psp->analog_state[0][1][1] = 0;
psp->pad_state = 0;
psp->pad_state |= (STATE_BUTTON(state_tmp) & PSP_CTRL_LEFT) ? (1ULL << RETRO_DEVICE_ID_JOYPAD_LEFT) : 0;
psp->pad_state |= (STATE_BUTTON(state_tmp) & PSP_CTRL_DOWN) ? (1ULL << RETRO_DEVICE_ID_JOYPAD_DOWN) : 0;
psp->pad_state |= (STATE_BUTTON(state_tmp) & PSP_CTRL_RIGHT) ? (1ULL << RETRO_DEVICE_ID_JOYPAD_RIGHT) : 0;
psp->pad_state |= (STATE_BUTTON(state_tmp) & PSP_CTRL_UP) ? (1ULL << RETRO_DEVICE_ID_JOYPAD_UP) : 0;
psp->pad_state |= (STATE_BUTTON(state_tmp) & PSP_CTRL_START) ? (1ULL << RETRO_DEVICE_ID_JOYPAD_START) : 0;
psp->pad_state |= (STATE_BUTTON(state_tmp) & PSP_CTRL_SELECT) ? (1ULL << RETRO_DEVICE_ID_JOYPAD_SELECT) : 0;
psp->pad_state |= (STATE_BUTTON(state_tmp) & PSP_CTRL_TRIANGLE) ? (1ULL << RETRO_DEVICE_ID_JOYPAD_X) : 0;
psp->pad_state |= (STATE_BUTTON(state_tmp) & PSP_CTRL_SQUARE) ? (1ULL << RETRO_DEVICE_ID_JOYPAD_Y) : 0;
psp->pad_state |= (STATE_BUTTON(state_tmp) & PSP_CTRL_CROSS) ? (1ULL << RETRO_DEVICE_ID_JOYPAD_B) : 0;
psp->pad_state |= (STATE_BUTTON(state_tmp) & PSP_CTRL_CIRCLE) ? (1ULL << RETRO_DEVICE_ID_JOYPAD_A) : 0;
psp->pad_state |= (STATE_BUTTON(state_tmp) & PSP_CTRL_R) ? (1ULL << RETRO_DEVICE_ID_JOYPAD_R) : 0;
psp->pad_state |= (STATE_BUTTON(state_tmp) & PSP_CTRL_L) ? (1ULL << RETRO_DEVICE_ID_JOYPAD_L) : 0;
psp->analog_state[0][RETRO_DEVICE_INDEX_ANALOG_LEFT] [RETRO_DEVICE_ID_ANALOG_X] = (int16_t)(STATE_ANALOGLX(state_tmp)-128) * 256;
psp->analog_state[0][RETRO_DEVICE_INDEX_ANALOG_LEFT] [RETRO_DEVICE_ID_ANALOG_Y] = (int16_t)(STATE_ANALOGLY(state_tmp)-128) * 256;
#ifdef SN_TARGET_PSP2
psp->analog_state[0][RETRO_DEVICE_INDEX_ANALOG_RIGHT][RETRO_DEVICE_ID_ANALOG_X] = (int16_t)(STATE_ANALOGRX(state_tmp)-128) * 256;
psp->analog_state[0][RETRO_DEVICE_INDEX_ANALOG_RIGHT][RETRO_DEVICE_ID_ANALOG_Y] = (int16_t)(STATE_ANALOGRY(state_tmp)-128) * 256;
#endif
for (int i = 0; i < 2; i++)
for (int j = 0; j < 2; j++)
if (psp->analog_state[0][i][j] == -0x8000)
psp->analog_state[0][i][j] = -0x7fff;
*lifecycle_state &= ~((1ULL << RARCH_MENU_TOGGLE));
if (
(psp->pad_state & (1ULL << RETRO_DEVICE_ID_JOYPAD_L))
&& (psp->pad_state & (1ULL << RETRO_DEVICE_ID_JOYPAD_R))
&& (psp->pad_state & (1ULL << RETRO_DEVICE_ID_JOYPAD_SELECT))
&& (psp->pad_state & (1ULL << RETRO_DEVICE_ID_JOYPAD_START))
)
*lifecycle_state |= (1ULL << RARCH_MENU_TOGGLE);
if (g_settings.input.autodetect_enable)
{
if (strcmp(g_settings.input.device_names[0], "PSP") != 0)
psp_input_set_keybinds(NULL, DEVICE_PSP, 0, 0, (1ULL << KEYBINDS_ACTION_SET_DEFAULT_BINDS));
}
}
int Ctrl_init(lua_State *L)
{
sceCtrlSetSamplingCycle(0);
sceCtrlSetSamplingMode(PSP_CTRL_MODE_ANALOG);
UserdataRegister("Ctrl", Ctrl_methods, Ctrl_metamethods)
return 1;
}
void MFInput_InitModulePlatformSpecific()
{
MFCALLSTACK;
MFZeroMemory(gKeyState, 256);
sceCtrlSetSamplingCycle(0);
sceCtrlSetSamplingMode(PSP_CTRL_MODE_ANALOG);
}
static void* psp_input_initialize(void)
{
#ifdef PSP
sceCtrlSetSamplingCycle(0);
#endif
sceCtrlSetSamplingMode(DEFAULT_SAMPLING_MODE);
return (void*)-1;
}
int joy_Init() {
sceCtrlSetSamplingCycle(0);
sceCtrlSetSamplingMode(PSP_CTRL_MODE_DIGITAL);
memset(&sticks[0],0,sizeof(stick));
joy_initd = true;
return 1;
}
/*
============
triInputInit
============
*/
triBool triInputInit (void)
{
triLogPrint ("Initializing triInput\r\n");
memset (&Input, 0, sizeof(triInput));
sceCtrlSetSamplingCycle (0);
sceCtrlSetSamplingMode (PSP_CTRL_MODE_ANALOG);
return TRUE;
}
Cursor::Cursor()
{
sceCtrlSetSamplingCycle(0);
sceCtrlSetSamplingMode(PSP_CTRL_MODE_ANALOG);
cursor = new CursorInfo();
cursor->X = 480/2;
cursor->Y = 280/2;
Core::Cfg->GetIntValue("cursorspeed", cursor->CursorSpeed);
cursor->Display = Core::Gui->LoadPNG(Core::CfgTheme->GetPathValue("c_cursor").c_str());
Core::Dbg->Log(Init, "Cursor Loaded...");
}
void Init()
{
sceCtrlSetSamplingCycle(0);
sceCtrlSetSamplingMode(PSP_CTRL_MODE_ANALOG);
memset(&sPad, 0, sizeof(sPad));
memset(&sStatus, 0, sizeof(sStatus));
memset(&sRepeat, 0, sizeof(sRepeat));
sRepeat.startFrame = DOD_DEFAULT_START_FRAME;
sRepeat.intervalFrame = DOD_DEFAULT_INTERVAL_FRAME;
}
void GWInput_InitializeDevice( GW_RENDER_WINDOW* rw )
{
sceCtrlSetSamplingCycle(0);
sceCtrlSetSamplingMode(PSP_CTRL_MODE_ANALOG);
memset(psp_btn_down, 0, sizeof(psp_btn_down));
memset(psp_btn_state, 0, sizeof(psp_btn_state));
for (int i=0; i<GW_PSPAXIS_COUNT; i++)
{
psp_axis[i] = 0.f;
}
}
VOID
PAL_InitInput(
VOID
)
/*++
Purpose:
Initialize the input subsystem.
Parameters:
None.
Return value:
None.
--*/
{
memset(&g_InputState, 0, sizeof(g_InputState));
g_InputState.dir = kDirUnknown;
g_InputState.prevdir = kDirUnknown;
#if SDL_MAJOR_VERSION == 1 && SDL_MINOR_VERSION <= 2
SDL_SetEventFilter(PAL_EventFilter);
#else
SDL_SetEventFilter(PAL_EventFilter, NULL);
#endif
//
// Setup input
//
sceCtrlSetSamplingCycle(0);
sceCtrlSetSamplingMode(PSP_CTRL_MODE_ANALOG);
pad.Buttons = 0;
//
// Start thread to read data
//
if((pad_sem = SDL_CreateSemaphore(1)) == NULL)
{
TerminateOnError("Can't create input semaphore\n");
return;
}
running = 1;
if((bthread = SDL_CreateThread(PSP_JoystickUpdate, NULL)) == NULL)
{
TerminateOnError("Can't create input thread\n");
return;
}
}
void Cursor::Init()
{
sceCtrlSetSamplingCycle(0);
sceCtrlSetSamplingMode(PSP_CTRL_MODE_ANALOG);
Config* cfg = new Config("ms0:/MbShell/config/main.cfg");
cursor = new CursorInfo();
cursor->X = 480/2;
cursor->Y = 280/2;
cfg->GetIntValue("cursorspeed", cursor->CursorSpeed);
cursor->Display = Graphics::LoadPNG(Core::CfgTheme->GetPathValue("c_cursor").c_str());
delete(cfg);
}
void glutMainLoop (void)
{
if (glut_reshape_func)
glut_reshape_func(width, height);
sceCtrlSetSamplingCycle(0);
sceCtrlSetSamplingMode(PSP_CTRL_MODE_ANALOG);
do {
static unsigned int oldbuttons = 0;
SceCtrlData pad;
int i;
if (glut_joystick_func) {
struct SceCtrlData pad;
sceCtrlReadBufferPositive(&pad, 1);
glut_joystick_func(pad.Buttons,
(pad.Lx * 2000L) / 256 - 1000,
(pad.Ly * 2000L) / 256 - 1000, 0);
}
sceCtrlReadBufferPositive(&pad, 1);
for (i=0; i<sizeof(keycode)/sizeof(keycode[0]); i++) {
if (pad.Buttons & (1 << i)) {
if (KEY_REPEAT(keycode[i])) {
key(keycode[i], 1);
} else {
if (!(oldbuttons & (1 << i)))
key(keycode[i], 1);
}
} else {
if (oldbuttons & (1 << i))
key(keycode[i], 0);
}
}
oldbuttons = pad.Buttons;
if (glut_display_func && glut_redisplay_posted) {
glut_redisplay_posted = 0;
glut_display_func();
}
if (glut_idle_func)
glut_idle_func();
} while (1);
}
void testCycleLatch(int cycle) {
SceCtrlLatch latch;
// Ignore it this time, to reset it.
sceCtrlReadLatch(&latch);
sceDisplayWaitVblank();
sceCtrlSetSamplingCycle(cycle);
int vcountBefore = sceDisplayGetVcount();
sceKernelDelayThread(166666);
int vcountAfter = sceDisplayGetVcount();
int after = sceCtrlReadLatch(&latch);
// Keeping it approximate because timing is hard to get millisecond accurate.
schedf("%d cycle: %dx\n", cycle, (after + 5) / (vcountAfter - vcountBefore));
}
int main(int argc, char *argv[])
{
int i, ret;
pspDebugScreenInit();
sceCtrlSetSamplingCycle(0);
sceCtrlSetSamplingMode(PSP_CTRL_MODE_DIGITAL);
printf("Save Encrypt Sample\n");
printf("by Jim Paris and psp123\n\n");
printf(" Will encrypt: %s\n", plaintext);
printf(" Using key:");
if(gamekey) {
for (i = 0; i < 0x10; i++)
printf(" %02x", gamekey[i]);
} else {
printf(" none");
}
printf("\n\n");
printf(" Output file: %s\n", encrypted);
printf("Update hashes: %s\n\n", paramsfo);
printf("Press X to continue, or O to quit.\n\n");
if (waitbutton(PSP_CTRL_CROSS | PSP_CTRL_CIRCLE) & PSP_CTRL_CIRCLE)
goto out;
printf("Working...\n\n");
ret = encrypt_file(plaintext, encrypted, datafile, paramsfo, gamekey);
if(ret < 0) {
printf("Error: encrypt_file() returned %d\n\n", ret);
} else {
printf("Successfully wrote %d bytes to\n", ret);
printf(" %s\n", encrypted);
printf("and updated hashes in\n");
printf(" %s\n\n", paramsfo);
}
printf("Press any button to quit\n");
waitbutton(-1);
out:
sceKernelExitGame();
return 0;
}
int kstuffGetKCtrl( void )
{
int btn;
SceCtrlData pad;
int k;
k = pspSdkSetK1(0);
sceCtrlSetSamplingCycle(0);
sceCtrlSetSamplingMode(PSP_CTRL_MODE_DIGITAL);
sceCtrlReadBufferPositive( &pad, 1 );
btn = pad.Buttons;
pspSdkSetK1(k);
return btn;
}
void testSetCycle(const char *title, int cycle) {
sceDisplayWaitVblank();
int result = sceCtrlSetSamplingCycle(cycle);
schedf("%s: %08X (%d)", title, result, cycle);
int verify = 0xDEADBEEF;
if (result >= 0) {
sceCtrlGetSamplingCycle(&verify);
if (cycle == verify) {
schedf(" - OK\n");
} else {
schedf(" - mismatch %d vs %d\n", cycle, verify);
}
} else {
sceCtrlGetSamplingCycle(&verify);
schedf(" - still %d\n", verify);
}
}
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);
}
int main(void)
{
SceCtrlData pad;
pspDebugScreenInit();
SetupCallbacks();
/* Install our custom exception handler. If this was NULL then the default would be used */
pspDebugInstallErrorHandler(MyExceptionHandler);
sceCtrlSetSamplingCycle(0);
sceCtrlSetSamplingMode(PSP_CTRL_MODE_DIGITAL);
pspDebugScreenPrintf("Exception Sample\n\n");
pspDebugScreenPrintf("You have two choices, press O for a bus error or X for a breakpoint\n\n");
while(1)
{
sceCtrlReadBufferPositive(&pad, 1);
if(pad.Buttons & PSP_CTRL_CIRCLE)
{
/* Cause a bus error */
_sw(0, 0);
}
if(pad.Buttons & PSP_CTRL_CROSS)
{
/* Cause a break exception */
asm(
"break\r\n"
);
}
sceDisplayWaitVblankStart();
}
/* We will never end up here, hopefully */
printf("End\n");
sceKernelExitDeleteThread(0);
return 0;
}
void hcMiscWaitForAnyButton( void )
{
int btn;
SceCtrlData pad;
sceCtrlSetSamplingCycle(0);
sceCtrlSetSamplingMode(PSP_CTRL_MODE_DIGITAL);
btn=1;
while( btn != 0 )
{
sceCtrlReadBufferPositive( &pad, 1 );
btn = pad.Buttons & 0xFFFF;
}
btn=0;
while( btn == 0 )
{
sceCtrlReadBufferPositive( &pad, 1 );
btn = pad.Buttons & 0xFFFF;
}
}
static void psp_input_poll(void *data)
{
SceCtrlData state_tmp;
psp_input_t *psp = (psp_input_t*)data;
#ifdef PSP
sceCtrlSetSamplingCycle(0);
#endif
sceCtrlSetSamplingMode(DEFAULT_SAMPLING_MODE);
int ret = CtrlReadBufferPositive(0, &state_tmp, 1);
psp->analog_state[0][0][0] = psp->analog_state[0][0][1] = psp->analog_state[0][1][0] = psp->analog_state[0][1][1] = 0;
psp->pad_state = 0;
psp->pad_state |= (STATE_BUTTON(state_tmp) & PSP_CTRL_LEFT) ? (1ULL << RETRO_DEVICE_ID_JOYPAD_LEFT) : 0;
psp->pad_state |= (STATE_BUTTON(state_tmp) & PSP_CTRL_DOWN) ? (1ULL << RETRO_DEVICE_ID_JOYPAD_DOWN) : 0;
psp->pad_state |= (STATE_BUTTON(state_tmp) & PSP_CTRL_RIGHT) ? (1ULL << RETRO_DEVICE_ID_JOYPAD_RIGHT) : 0;
psp->pad_state |= (STATE_BUTTON(state_tmp) & PSP_CTRL_UP) ? (1ULL << RETRO_DEVICE_ID_JOYPAD_UP) : 0;
psp->pad_state |= (STATE_BUTTON(state_tmp) & PSP_CTRL_START) ? (1ULL << RETRO_DEVICE_ID_JOYPAD_START) : 0;
psp->pad_state |= (STATE_BUTTON(state_tmp) & PSP_CTRL_SELECT) ? (1ULL << RETRO_DEVICE_ID_JOYPAD_SELECT) : 0;
psp->pad_state |= (STATE_BUTTON(state_tmp) & PSP_CTRL_TRIANGLE) ? (1ULL << RETRO_DEVICE_ID_JOYPAD_X) : 0;
psp->pad_state |= (STATE_BUTTON(state_tmp) & PSP_CTRL_SQUARE) ? (1ULL << RETRO_DEVICE_ID_JOYPAD_Y) : 0;
psp->pad_state |= (STATE_BUTTON(state_tmp) & PSP_CTRL_CROSS) ? (1ULL << RETRO_DEVICE_ID_JOYPAD_B) : 0;
psp->pad_state |= (STATE_BUTTON(state_tmp) & PSP_CTRL_CIRCLE) ? (1ULL << RETRO_DEVICE_ID_JOYPAD_A) : 0;
psp->pad_state |= (STATE_BUTTON(state_tmp) & PSP_CTRL_R) ? (1ULL << RETRO_DEVICE_ID_JOYPAD_R) : 0;
psp->pad_state |= (STATE_BUTTON(state_tmp) & PSP_CTRL_L) ? (1ULL << RETRO_DEVICE_ID_JOYPAD_L) : 0;
#if 0
psp->pad_state |= (STATE_ANALOGLX(state_tmp) < ANALOGSTICK_DEADZONE_LOW) ? PSP_GAMEPAD_LSTICK_LEFT_MASK : 0;
psp->pad_state |= (STATE_ANALOGLX(state_tmp) > ANALOGSTICK_DEADZONE_HIGH) ? PSP_GAMEPAD_LSTICK_RIGHT_MASK : 0;
psp->pad_state |= (STATE_ANALOGLY(state_tmp) < ANALOGSTICK_DEADZONE_LOW) ? PSP_GAMEPAD_LSTICK_UP_MASK : 0;
psp->pad_state |= (STATE_ANALOGLY(state_tmp) > ANALOGSTICK_DEADZONE_HIGH) ? PSP_GAMEPAD_LSTICK_DOWN_MASK : 0;
#ifdef SN_TARGET_PSP2
psp->pad_state |= (STATE_ANALOGRX(state_tmp) < ANALOGSTICK_DEADZONE_LOW) ? PSP_GAMEPAD_RSTICK_LEFT_MASK : 0;
psp->pad_state |= (STATE_ANALOGRX(state_tmp) > ANALOGSTICK_DEADZONE_HIGH) ? PSP_GAMEPAD_RSTICK_RIGHT_MASK : 0;
psp->pad_state |= (STATE_ANALOGRY(state_tmp) < ANALOGSTICK_DEADZONE_LOW) ? PSP_GAMEPAD_RSTICK_UP_MASK : 0;
psp->pad_state |= (STATE_ANALOGRY(state_tmp) > ANALOGSTICK_DEADZONE_HIGH) ? PSP_GAMEPAD_RSTICK_DOWN_MASK : 0;
#endif
#endif
}
int main(int argc, char * argv[])
{
srand(time(0));
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_ALPHA | GLUT_DEPTH);
glutInitWindowSize(480, 272);
glutInitWindowPosition(0, 0);
wnd = glutCreateWindow("MasterPiece 3D");
glutDisplayFunc(&render);
//glutFullScreen();
glutIdleFunc(&render);
glutReshapeFunc(&resize);
glutKeyboardFunc(&keydown);
glutSpecialFunc(&specialkey);
initgl(640, 480);
releaseblock();
#ifdef FOR_PSP
sceCtrlSetSamplingCycle(0);
sceCtrlSetSamplingMode(PSP_CTRL_MODE_ANALOG);
#endif
glutMainLoop();
return (0);
}
int
ui_init (UI * ui, int width, int height)
{
ui->screen = NULL;
ui->font = NULL;
ui->screen = SDL_SetVideoMode (width, height, 32,
SDL_HWSURFACE | SDL_DOUBLEBUF);
if (ui->screen == NULL)
goto no_screen;
SDL_ShowCursor (SDL_DISABLE);
ui->font = TTF_OpenFont ("DejaVuSans.ttf", 16);
if (ui->font == NULL)
goto no_font;
/* initialize controller */
sceCtrlSetSamplingCycle (0); /* in ms: 0=VSYNC */
sceCtrlSetSamplingMode (PSP_CTRL_MODE_ANALOG);
ui->setting_yaw = 50;
ui->setting_pitch = 50;
ui->setting_roll = 50;
ui->setting_gaz = 75;
ui->setting_select_binding = SELECT_BIND_TAKE_PICTURE;
return 0;
no_screen:
PSPLOG_ERROR ("failed to set screen video mode");
return -1;
no_font:
PSPLOG_ERROR ("failed to open font");
return -1;
}
int main(int argc, char *argv[])
{
SceCtrlData ctl;
pspDebugScreenInit();
sceCtrlSetSamplingCycle(0);
sceCtrlSetSamplingMode(PSP_CTRL_MODE_DIGITAL);
/* Copy our small program into the ME reset vector */
memcpy((void *)0xbfc00040, me_run, (int)(me_end - me_run));
sceKernelDcacheWritebackInvalidateAll();
sceSysregMeResetEnable();
sceSysregMeBusClockEnable();
sceSysregMeResetDisable();
sceSysregVmeResetDisable();
while(1)
{
volatile u32 *count = (u32*) 0xBFC00060;
pspDebugScreenSetXY(0, 0);
pspDebugScreenPrintf("ME Basic Example, press Home to exit\n");
sceKernelDcacheWritebackInvalidateAll();
pspDebugScreenPrintf("ME Counter: %08x\n", *count);
sceCtrlReadBufferPositive(&ctl, 1);
if(ctl.Buttons & PSP_CTRL_HOME)
{
sceKernelExitGame();
}
sceDisplayWaitVblankStart();
}
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(); Lazy loading
//JFileSystem::GetInstance(); Lazy loading
//JSoundSystem::GetInstance(); let's do lazy loading
mDone = false;
mPaused = false;
mCriticalAssert = false;
}
int main(int argc, char *argv[]) {
int result, data;
SceCtrlData pad_data[128];
SceCtrlLatch latch;
schedulingLogPos = schedulingLog;
SceUID thread = sceKernelCreateThread("preempt", &testThread, sceKernelGetThreadCurrentPriority() - 1, 0x500, 0, NULL);
sceKernelStartThread(thread, 0, 0);
schedulingLogPos += sprintf(schedulingLogPos, "BEFORE sceCtrlSetSamplingMode 1\n");
didPreempt = 0;
result = sceCtrlSetSamplingMode(1);
schedulingLogPos += sprintf(schedulingLogPos, "AFTER sceCtrlSetSamplingMode 1: %08x preempt:%d\n", result, didPreempt);
sceKernelDelayThread(300);
schedulingLogPos += sprintf(schedulingLogPos, "BEFORE sceCtrlSetSamplingMode 0\n");
didPreempt = 0;
result = sceCtrlSetSamplingMode(0);
schedulingLogPos += sprintf(schedulingLogPos, "AFTER sceCtrlSetSamplingMode 0: %08x preempt:%d\n", result, didPreempt);
sceKernelDelayThread(300);
schedulingLogPos += sprintf(schedulingLogPos, "BEFORE sceCtrlSetSamplingCycle 0\n");
didPreempt = 0;
result = sceCtrlSetSamplingCycle(0);
schedulingLogPos += sprintf(schedulingLogPos, "AFTER sceCtrlSetSamplingCycle 0: %08x preempt:%d\n", result, didPreempt);
sceKernelDelayThread(300);
schedulingLogPos += sprintf(schedulingLogPos, "BEFORE sceCtrlGetSamplingMode\n");
didPreempt = 0;
result = sceCtrlGetSamplingMode(&data);
schedulingLogPos += sprintf(schedulingLogPos, "VALUE: %08x\n", data);
schedulingLogPos += sprintf(schedulingLogPos, "AFTER sceCtrlGetSamplingMode: %08x preempt:%d\n", result, didPreempt);
sceKernelDelayThread(300);
schedulingLogPos += sprintf(schedulingLogPos, "BEFORE sceCtrlReadBufferPositive 1\n");
didPreempt = 0;
result = sceCtrlReadBufferPositive(&pad_data[0], 1);
outputPadData(result, &pad_data[0]);
schedulingLogPos += sprintf(schedulingLogPos, "AFTER sceCtrlReadBufferPositive 1: %08x preempt:%d\n", result, didPreempt);
sceKernelDelayThread(300);
schedulingLogPos += sprintf(schedulingLogPos, "BEFORE sceCtrlReadBufferPositive 64\n");
didPreempt = 0;
result = sceCtrlReadBufferPositive(&pad_data[0], 64);
outputPadData(result, &pad_data[0]);
schedulingLogPos += sprintf(schedulingLogPos, "AFTER sceCtrlReadBufferPositive 64: %08x preempt:%d\n", result, didPreempt);
sceKernelDelayThread(300);
schedulingLogPos += sprintf(schedulingLogPos, "BEFORE sceCtrlPeekBufferPositive 64\n");
didPreempt = 0;
result = sceCtrlPeekBufferPositive(&pad_data[0], 64);
outputPadData(result, &pad_data[0]);
schedulingLogPos += sprintf(schedulingLogPos, "AFTER sceCtrlPeekBufferPositive 64: %08x preempt:%d\n", result, didPreempt);
sceKernelDelayThread(300);
schedulingLogPos += sprintf(schedulingLogPos, "BEFORE sceCtrlReadBufferPositive 96\n");
didPreempt = 0;
result = sceCtrlReadBufferPositive(&pad_data[0], 96);
outputPadData(result, &pad_data[0]);
schedulingLogPos += sprintf(schedulingLogPos, "AFTER sceCtrlReadBufferPositive 96: %08x preempt:%d\n", result, didPreempt);
sceKernelDelayThread(300);
schedulingLogPos += sprintf(schedulingLogPos, "BEFORE sceCtrlPeekLatch\n");
didPreempt = 0;
result = sceCtrlPeekLatch(&latch);
// Result is # of reads, which won't match headless.
result = result >= 1 ? 1 : 0;
outputLatchData(result, &latch);
schedulingLogPos += sprintf(schedulingLogPos, "AFTER sceCtrlPeekLatch: %08x preempt:%d\n", result, didPreempt);
sceKernelDelayThread(300);
schedulingLogPos += sprintf(schedulingLogPos, "BEFORE sceCtrlReadLatch\n");
didPreempt = 0;
result = sceCtrlReadLatch(&latch);
// Result is # of reads, which won't match headless.
result = result >= 1 ? 1 : 0;
outputLatchData(result, &latch);
schedulingLogPos += sprintf(schedulingLogPos, "AFTER sceCtrlReadLatch: %08x preempt:%d\n", result, didPreempt);
sceKernelDelayThread(300);
schedulingLogPos += sprintf(schedulingLogPos, "BEFORE sceCtrlPeekLatch\n");
didPreempt = 0;
result = sceCtrlPeekLatch(&latch);
outputLatchData(result, &latch);
schedulingLogPos += sprintf(schedulingLogPos, "AFTER sceCtrlPeekLatch: %08x preempt:%d\n", result, didPreempt);
sceKernelDelayThread(300);
sceKernelTerminateDeleteThread(thread);
sceKernelDelayThread(300);
printf("%s", schedulingLog);
return 0;
}
