| /* |
| Simple DirectMedia Layer |
| Copyright (C) 1997-2021 Sam Lantinga <slouken@libsdl.org> |
| |
| This software is provided 'as-is', without any express or implied |
| warranty. In no event will the authors be held liable for any damages |
| arising from the use of this software. |
| |
| Permission is granted to anyone to use this software for any purpose, |
| including commercial applications, and to alter it and redistribute it |
| freely, subject to the following restrictions: |
| |
| 1. The origin of this software must not be misrepresented; you must not |
| claim that you wrote the original software. If you use this software |
| in a product, an acknowledgment in the product documentation would be |
| appreciated but is not required. |
| 2. Altered source versions must be plainly marked as such, and must not be |
| misrepresented as being the original software. |
| 3. This notice may not be removed or altered from any source distribution. |
| */ |
| #include "../../SDL_internal.h" |
| |
| #if SDL_JOYSTICK_PSP |
| |
| /* This is the PSP implementation of the SDL joystick API */ |
| #include <pspctrl.h> |
| #include <pspkernel.h> |
| |
| #include <stdio.h> /* For the definition of NULL */ |
| #include <stdlib.h> |
| |
| #include "../SDL_sysjoystick.h" |
| #include "../SDL_joystick_c.h" |
| |
| #include "SDL_events.h" |
| #include "SDL_error.h" |
| #include "SDL_mutex.h" |
| #include "SDL_timer.h" |
| #include "../../thread/SDL_systhread.h" |
| |
| /* Current pad state */ |
| static SceCtrlData pad = { .Lx = 0, .Ly = 0, .Buttons = 0 }; |
| static SDL_sem *pad_sem = NULL; |
| static SDL_Thread *thread = NULL; |
| static int running = 0; |
| static const enum PspCtrlButtons button_map[] = { |
| PSP_CTRL_TRIANGLE, PSP_CTRL_CIRCLE, PSP_CTRL_CROSS, PSP_CTRL_SQUARE, |
| PSP_CTRL_LTRIGGER, PSP_CTRL_RTRIGGER, |
| PSP_CTRL_DOWN, PSP_CTRL_LEFT, PSP_CTRL_UP, PSP_CTRL_RIGHT, |
| PSP_CTRL_SELECT, PSP_CTRL_START, PSP_CTRL_HOME, PSP_CTRL_HOLD }; |
| static int analog_map[256]; /* Map analog inputs to -32768 -> 32767 */ |
| |
| typedef struct |
| { |
| int x; |
| int y; |
| } point; |
| |
| /* 4 points define the bezier-curve. */ |
| static point a = { 0, 0 }; |
| static point b = { 50, 0 }; |
| static point c = { 78, 32767 }; |
| static point d = { 128, 32767 }; |
| |
| /* simple linear interpolation between two points */ |
| static SDL_INLINE void lerp (point *dest, point *a, point *b, float t) |
| { |
| dest->x = a->x + (b->x - a->x)*t; |
| dest->y = a->y + (b->y - a->y)*t; |
| } |
| |
| /* evaluate a point on a bezier-curve. t goes from 0 to 1.0 */ |
| static int calc_bezier_y(float t) |
| { |
| point ab, bc, cd, abbc, bccd, dest; |
| lerp (&ab, &a, &b, t); /* point between a and b */ |
| lerp (&bc, &b, &c, t); /* point between b and c */ |
| lerp (&cd, &c, &d, t); /* point between c and d */ |
| lerp (&abbc, &ab, &bc, t); /* point between ab and bc */ |
| lerp (&bccd, &bc, &cd, t); /* point between bc and cd */ |
| lerp (&dest, &abbc, &bccd, t); /* point on the bezier-curve */ |
| return dest.y; |
| } |
| |
| /* |
| * Collect pad data about once per frame |
| */ |
| int JoystickUpdate(void *data) |
| { |
| while (running) { |
| SDL_SemWait(pad_sem); |
| sceCtrlPeekBufferPositive(&pad, 1); |
| SDL_SemPost(pad_sem); |
| /* Delay 1/60th of a second */ |
| sceKernelDelayThread(1000000 / 60); |
| } |
| return 0; |
| } |
| |
| |
| |
| /* Function to scan the system for joysticks. |
| * Joystick 0 should be the system default joystick. |
| * It should return number of joysticks, or -1 on an unrecoverable fatal error. |
| */ |
| static int PSP_JoystickInit(void) |
| { |
| int i; |
| |
| /* 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_CreateThreadInternal(JoystickUpdate, "JoystickThread", 4096, 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; |
| } |
| |
| static int PSP_NumJoysticks(void) |
| { |
| return 1; |
| } |
| |
| static void PSP_JoystickDetect(void) |
| { |
| } |
| |
| #if 0 |
| /* Function to get the device-dependent name of a joystick */ |
| static const char *PSP_JoystickName(int idx) |
| { |
| if (idx == 0) return "PSP controller"; |
| SDL_SetError("No joystick available with that index"); |
| return NULL; |
| } |
| #endif |
| |
| /* Function to get the device-dependent name of a joystick */ |
| static const char *PSP_JoystickGetDeviceName(int device_index) |
| { |
| return "PSP builtin joypad"; |
| } |
| |
| static int PSP_JoystickGetDevicePlayerIndex(int device_index) |
| { |
| return -1; |
| } |
| |
| static void |
| PSP_JoystickSetDevicePlayerIndex(int device_index, int player_index) |
| { |
| } |
| |
| static SDL_JoystickGUID PSP_JoystickGetDeviceGUID(int device_index) |
| { |
| SDL_JoystickGUID guid; |
| /* the GUID is just the first 16 chars of the name for now */ |
| const char *name = PSP_JoystickGetDeviceName(device_index); |
| SDL_zero(guid); |
| SDL_memcpy(&guid, name, SDL_min(sizeof(guid), SDL_strlen(name))); |
| return guid; |
| } |
| |
| /* Function to perform the mapping from device index to the instance id for this index */ |
| static SDL_JoystickID PSP_JoystickGetDeviceInstanceID(int device_index) |
| { |
| return device_index; |
| } |
| |
| /* Function to open a joystick for use. |
| The joystick to open is specified by the device index. |
| This should fill the nbuttons and naxes fields of the joystick structure. |
| It returns 0, or -1 if there is an error. |
| */ |
| static int PSP_JoystickOpen(SDL_Joystick *joystick, int device_index) |
| { |
| joystick->nbuttons = 14; |
| joystick->naxes = 2; |
| joystick->nhats = 0; |
| |
| return 0; |
| } |
| |
| static int |
| PSP_JoystickRumble(SDL_Joystick *joystick, Uint16 low_frequency_rumble, Uint16 high_frequency_rumble) |
| { |
| return SDL_Unsupported(); |
| } |
| |
| static int |
| PSP_JoystickRumbleTriggers(SDL_Joystick *joystick, Uint16 left_rumble, Uint16 right_rumble) |
| { |
| return SDL_Unsupported(); |
| } |
| |
| static SDL_bool PSP_JoystickHasLED(SDL_Joystick *joystick) |
| { |
| return SDL_FALSE; |
| } |
| |
| static int |
| PSP_JoystickSetLED(SDL_Joystick *joystick, Uint8 red, Uint8 green, Uint8 blue) |
| { |
| return SDL_Unsupported(); |
| } |
| |
| static int PSP_JoystickSetSensorsEnabled(SDL_Joystick *joystick, SDL_bool enabled) |
| { |
| return SDL_Unsupported(); |
| } |
| |
| /* Function to update the state of a joystick - called as a device poll. |
| * This function shouldn't update the joystick structure directly, |
| * but instead should call SDL_PrivateJoystick*() to deliver events |
| * and update joystick device state. |
| */ |
| static void PSP_JoystickUpdate(SDL_Joystick *joystick) |
| { |
| int i; |
| enum PspCtrlButtons buttons; |
| enum PspCtrlButtons changed; |
| unsigned char x, y; |
| static enum PspCtrlButtons old_buttons = 0; |
| static unsigned char old_x = 0, old_y = 0; |
| |
| SDL_SemWait(pad_sem); |
| buttons = pad.Buttons; |
| x = pad.Lx; |
| y = pad.Ly; |
| SDL_SemPost(pad_sem); |
| |
| /* Axes */ |
| if(old_x != x) { |
| SDL_PrivateJoystickAxis(joystick, 0, analog_map[x]); |
| old_x = x; |
| } |
| if(old_y != y) { |
| SDL_PrivateJoystickAxis(joystick, 1, analog_map[y]); |
| old_y = y; |
| } |
| |
| /* Buttons */ |
| changed = old_buttons ^ buttons; |
| old_buttons = buttons; |
| if(changed) { |
| for(i=0; i<sizeof(button_map)/sizeof(button_map[0]); i++) { |
| if(changed & button_map[i]) { |
| SDL_PrivateJoystickButton( |
| joystick, i, |
| (buttons & button_map[i]) ? |
| SDL_PRESSED : SDL_RELEASED); |
| } |
| } |
| } |
| |
| sceKernelDelayThread(0); |
| } |
| |
| /* Function to close a joystick after use */ |
| static void PSP_JoystickClose(SDL_Joystick *joystick) |
| { |
| } |
| |
| /* Function to perform any system-specific joystick related cleanup */ |
| static void PSP_JoystickQuit(void) |
| { |
| /* Cleanup Threads and Semaphore. */ |
| running = 0; |
| SDL_WaitThread(thread, NULL); |
| SDL_DestroySemaphore(pad_sem); |
| } |
| |
| static SDL_bool |
| PSP_JoystickGetGamepadMapping(int device_index, SDL_GamepadMapping *out) |
| { |
| return SDL_FALSE; |
| } |
| |
| SDL_JoystickDriver SDL_PSP_JoystickDriver = |
| { |
| PSP_JoystickInit, |
| PSP_NumJoysticks, |
| PSP_JoystickDetect, |
| PSP_JoystickGetDeviceName, |
| PSP_JoystickGetDevicePlayerIndex, |
| PSP_JoystickSetDevicePlayerIndex, |
| PSP_JoystickGetDeviceGUID, |
| PSP_JoystickGetDeviceInstanceID, |
| PSP_JoystickOpen, |
| PSP_JoystickRumble, |
| PSP_JoystickRumbleTriggers, |
| PSP_JoystickHasLED, |
| PSP_JoystickSetLED, |
| PSP_JoystickSetSensorsEnabled, |
| PSP_JoystickUpdate, |
| PSP_JoystickClose, |
| PSP_JoystickQuit, |
| PSP_JoystickGetGamepadMapping |
| }; |
| |
| #endif /* SDL_JOYSTICK_PSP */ |
| |
| /* vim: ts=4 sw=4 |
| */ |