void psp_init(void)
{
SceUID thid;
char buff[128], *r;
/* fw 1.5 sometimes returns 8002032c, although getcwd works */
r = getcwd(buff, sizeof(buff));
if (r) sceIoChdir(buff);
main_thread_id = sceKernelGetThreadId();
lprintf("running on %08x kernel\n", sceKernelDevkitVersion()),
lprintf("entered psp_init, threadId %08x, priority %i\n", main_thread_id,
sceKernelGetThreadCurrentPriority());
thid = sceKernelCreateThread("update_thread", callback_thread, 0x11, 0xFA0, 0, NULL);
if (thid >= 0)
{
sceKernelStartThread(thid, 0, 0);
}
/* video */
sceDisplaySetMode(0, 480, 272);
sceDisplaySetFrameBuf(VRAM_FB1, 512, PSP_DISPLAY_PIXEL_FORMAT_565, PSP_DISPLAY_SETBUF_NEXTFRAME);
current_screen = 1;
psp_screen = VRAM_FB0;
/* gu */
sceGuInit();
sceGuStart(GU_DIRECT, guCmdList);
sceGuDrawBuffer(GU_PSM_5650, (void *)VRAMOFFS_FB0, 512);
sceGuDispBuffer(480, 272, (void *)VRAMOFFS_FB1, 512); // don't care
sceGuClear(GU_COLOR_BUFFER_BIT | GU_DEPTH_BUFFER_BIT);
sceGuDepthBuffer((void *)VRAMOFFS_DEPTH, 512);
sceGuOffset(2048 - (480 / 2), 2048 - (272 / 2));
sceGuViewport(2048, 2048, 480, 272);
sceGuDepthRange(0xc350, 0x2710);
sceGuScissor(0, 0, 480, 272);
sceGuEnable(GU_SCISSOR_TEST);
sceGuDepthMask(0xffff);
sceGuDisable(GU_DEPTH_TEST);
sceGuFrontFace(GU_CW);
sceGuEnable(GU_TEXTURE_2D);
sceGuTexFunc(GU_TFX_REPLACE, GU_TCC_RGB);
sceGuAmbientColor(0xffffffff);
sceGuColor(0xffffffff);
sceGuFinish();
sceGuSync(0, 0);
sceDisplayWaitVblankStart();
sceGuDisplay(GU_TRUE);
/* input */
sceCtrlSetSamplingCycle(0);
sceCtrlSetSamplingMode(PSP_CTRL_MODE_ANALOG);
}
/* Function to scan the system for joysticks.
* This function should set SDL_numjoysticks to the number of available
* joysticks. Joystick 0 should be the system default joystick.
* It should return number of joysticks, or -1 on an unrecoverable fatal error.
*/
int SDL_SYS_JoystickInit(void)
{
int i;
/* SDL_numjoysticks = 1; */
/* Setup input */
sceCtrlSetSamplingCycle(0);
sceCtrlSetSamplingMode(PSP_CTRL_MODE_ANALOG);
/* Start thread to read data */
if((pad_sem = SDL_CreateSemaphore(1)) == NULL) {
return SDL_SetError("Can't create input semaphore");
}
running = 1;
if((thread = SDL_CreateThread(JoystickUpdate, "JoySitckThread",NULL)) == NULL) {
return SDL_SetError("Can't create input thread");
}
/* Create an accurate map from analog inputs (0 to 255)
to SDL joystick positions (-32768 to 32767) */
for (i = 0; i < 128; i++)
{
float t = (float)i/127.0f;
analog_map[i+128] = calc_bezier_y(t);
analog_map[127-i] = -1 * analog_map[i+128];
}
return 1;
}
int playerStart(char *path,pMalloc extern_malloc,pFree extern_free, int(*callback)(int)){
int ret,ch;MODFILE mod;
if(!extern_malloc || !extern_free)return -1;
if((ch=sceAudioChReserve(PSP_AUDIO_NEXT_CHANNEL,PSP_AUDIO_SAMPLE_ALIGN(768),PSP_AUDIO_FORMAT_STEREO))<0)return ch;
myMalloc=extern_malloc;
myFree =extern_free;
MODFILE_Init(&mod);
if((ret=MODFILE_Load(path, &mod))<0)return ret;
mod.musicvolume = 255;
mod.sfxvolume = 255;
mod.callback = NULL;//callback;
MODFILE_Start(&mod);
MODFILE_SetFormat(&mod, 44100, 2,16,1/*unsigned*/);
SceCtrlData pad;
sceCtrlSetSamplingCycle(0);
sceCtrlSetSamplingMode(1);
for(int i=0;;i++){
sceCtrlReadBufferPositive(&pad,1);
if(pad.Buttons&PSP_CTRL_START)break;
mod.mixingbuf =(void*)out[i%2];
mod.mixingbuflen = 768*2*2;
MODFILE_Player(&mod);
sceAudioOutputBlocking(ch, PSP_AUDIO_VOLUME_MAX,out[i%2]);
}
MODFILE_Stop(&mod);
MODFILE_Free(&mod);
sceAudioChRelease(ch);
return 0;
}
Psp2Ui::Psp2Ui(int width, int height) :
BaseUi() {
starttick = sceKernelGetProcessTimeWide() / 1000;
frame = 0;
zoom_state = 0;
trigger_state = false;
vita2d_init();
vita2d_texture_set_alloc_memblock_type(SCE_KERNEL_MEMBLOCK_TYPE_USER_RW);
current_display_mode.width = width;
current_display_mode.height = height;
current_display_mode.bpp = 32;
const DynamicFormat format(
32,
0x000000FF,
0x0000FF00,
0x00FF0000,
0xFF000000,
PF::Alpha);
main_texture = vita2d_create_empty_texture_format(
width, height,
SCE_GXM_TEXTURE_FORMAT_A8B8G8R8);
Bitmap::SetFormat(Bitmap::ChooseFormat(format));
main_surface = Bitmap::Create(vita2d_texture_get_datap(main_texture),width, height, vita2d_texture_get_stride(main_texture), format);
#ifdef SUPPORT_AUDIO
audio_.reset(new Psp2Audio());
#endif
scePowerSetArmClockFrequency(444);
sceCtrlSetSamplingMode(SCE_CTRL_MODE_ANALOG);
}
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
}
int Ctrl_init(lua_State *L)
{
sceCtrlSetSamplingCycle(0);
sceCtrlSetSamplingMode(PSP_CTRL_MODE_ANALOG);
UserdataRegister("Ctrl", Ctrl_methods, Ctrl_metamethods)
return 1;
}
Psp2Ui::Psp2Ui(int width, int height) :
BaseUi() {
starttick = sceKernelGetProcessTimeWide() / 1000;
frame = 0;
zoom_state = 0;
in_use_shader = 0;
touch_x_start = -1;
trigger_state = false;
set_shader = true;
vita2d_init();
vita2d_set_vblank_wait(0);
shaders[0] = vita2d_create_shader((SceGxmProgram*) opaque_v, (SceGxmProgram*) texture_f);
shaders[1] = vita2d_create_shader((SceGxmProgram*) sharp_bilinear_v, (SceGxmProgram*) sharp_bilinear_f);
shaders[2] = vita2d_create_shader((SceGxmProgram*) lcd3x_v, (SceGxmProgram*) lcd3x_f);
shaders[3] = vita2d_create_shader((SceGxmProgram*) xbr_2x_fast_v, (SceGxmProgram*) xbr_2x_fast_f);
gpu_texture = vita2d_create_empty_texture_format(
width, height,
SCE_GXM_TEXTURE_FORMAT_A8B8G8R8);
vita2d_texture_set_alloc_memblock_type(SCE_KERNEL_MEMBLOCK_TYPE_USER_RW);
current_display_mode.width = width;
current_display_mode.height = height;
current_display_mode.bpp = 32;
const DynamicFormat format(
32,
0x000000FF,
0x0000FF00,
0x00FF0000,
0xFF000000,
PF::Alpha);
main_texture = vita2d_create_empty_texture_format(
width, height,
SCE_GXM_TEXTURE_FORMAT_A8B8G8R8);
next_texture = vita2d_create_empty_texture_format(
width, height,
SCE_GXM_TEXTURE_FORMAT_A8B8G8R8);
Bitmap::SetFormat(Bitmap::ChooseFormat(format));
main_surface = Bitmap::Create(vita2d_texture_get_datap(main_texture),width, height, vita2d_texture_get_stride(main_texture), format);
#ifdef SUPPORT_AUDIO
audio_.reset(new Psp2Audio());
#endif
scePowerSetArmClockFrequency(444);
scePowerSetBusClockFrequency(222);
scePowerSetGpuClockFrequency(222);
scePowerSetGpuXbarClockFrequency(222);
sceCtrlSetSamplingMode(SCE_CTRL_MODE_ANALOG);
sceTouchSetSamplingState(SCE_TOUCH_PORT_FRONT, SCE_TOUCH_SAMPLING_STATE_START);
GPU_Mutex = sceKernelCreateSema("GPU Mutex", 0, 1, 1, NULL);
GPU_Cleanup_Mutex = sceKernelCreateSema("GPU Cleanup Mutex", 0, 1, 1, NULL);
GPU_Thread = sceKernelCreateThread("GPU Thread", &renderThread, 0x10000100, 0x10000, 0, 0, NULL);
sceKernelStartThread(GPU_Thread, sizeof(GPU_Thread), &GPU_Thread);
}
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;
}
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 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;
}
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;
}
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 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;
}
}
/***
* Initializes our keybinding to handle input later on.
*/
void setup_input()
{
pad = (SceCtrlData*)malloc(sizeof(SceCtrlData));
keymap = (uint32_t*)malloc(sizeof(uint32_t) * 12);
sceCtrlSetSamplingMode(SCE_CTRL_MODE_ANALOG);
if (!pad || !keymap)
{
printf("Unable to allocate memory for input data. Bailing.");
sceKernelExitProcess(0);
}
}
int main()
{
char rom_path[PATH_MAX];
printf("\nRealBoy %s\n", "0.2.2");
sceCtrlSetSamplingMode(SCE_CTRL_MODE_ANALOG);
vita2d_init();
vita2d_set_clear_color(RGBA8(0x40, 0x40, 0x40, 0xFF));
while (1) {
strcpy(current_dir, "ux0:");
int ret = file_choose(
current_dir,
rom_path,
"Choose a GB/GB Color/Super GB ROM:",
supported_ext
);
if (ret == -1)
break;
if ( (rom_file = fopen(rom_path, "r")) == NULL) {
printf("\nError opening %s\n", rom_path);
continue;
}
file_path = strndup(rom_path, 256);
if (rom_file != NULL) {
init_conf();
int ret_val; // value returned from emulation
/* Start Virtual Machine */
ret_val = start_vm();
/* Error returned if file not valid */
if (ret_val == -1) {
printf("File %s not a gb binary\n\n", rom_path);
}
}
free(file_path);
}
vita2d_fini();
sceKernelExitProcess(0);
return 0;
}
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
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 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);
}
ge_Keys* geCreateKeys(){
sceCtrlSetSamplingMode(PSP_CTRL_MODE_ANALOG);
ge_Keys* keys = (ge_Keys*)geMalloc(sizeof(ge_Keys));
geKeysAssign(keys, GEK_CROSS, GEVK_ENTER);
geKeysAssign(keys, GEK_CIRCLE, GEVK_BACK);
geKeysAssign(keys, GEK_UP, GEVK_UP);
geKeysAssign(keys, GEK_DOWN, GEVK_DOWN);
geKeysAssign(keys, GEK_LEFT, GEVK_LEFT);
geKeysAssign(keys, GEK_RIGHT, GEVK_RIGHT);
geKeysAssign(keys, GEK_SQUARE, GEVK_ACTION1);
geKeysAssign(keys, GEK_TRIANGLE, GEVK_ACTION2);
geKeysAssign(keys, GEK_LTRIGGER, GEVK_ACTION3);
geKeysAssign(keys, GEK_RTRIGGER, GEVK_ACTION4);
geKeysAssign(keys, GEK_START, GEVK_ACTION5);
geKeysAssign(keys, GEK_SELECT, GEVK_ACTION6);
return keys;
}
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;
}
static void init(void)
{
vita2d_init();
vita2d_set_clear_color(RGBA8(0x40, 0x40, 0x40, 0xFF));
sceCtrlSetSamplingMode(SCE_CTRL_MODE_ANALOG);
fullscreen_scale_x = SCREEN_W / (float)GAMEBOY_WIDTH;
fullscreen_scale_y = SCREEN_H / (float)GAMEBOY_HEIGHT;
gb_texture = vita2d_create_empty_texture(GAMEBOY_WIDTH, GAMEBOY_HEIGHT);
gb_texture_pixels = vita2d_texture_get_datap(gb_texture);
set_scale(3);
theGearboyCore = new GearboyCore();
theGearboyCore->Init();
}
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 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;
}
