int main(void) {
PlatformState state;
SDL_Event e;
SDL_Window *window;
SDL_Renderer *renderer;
SDLInputContext sdlIC;
SDLSoundRingBuffer srb;
GameSoundOutput sb;
GameMemory gameMemory;
//controller input state
InputContext inputStates[2]; //contains old and new state
InputContext* newInputState = &inputStates[0];
InputContext* oldInputState = &inputStates[1];
real32_t secsSinceLastFrame = 0;
sb.volume = 2500;
gameMemory.permanentStorageSize = MB(64);
gameMemory.transientStorageSize = MB(64);
state.gameMemorySize = gameMemory.transientStorageSize + gameMemory.permanentStorageSize;
state.memoryBlock = mmap(nullptr, state.gameMemorySize, PROT_READ | PROT_WRITE,
MAP_ANONYMOUS | MAP_PRIVATE ,
-1,
0);
gameMemory.permanentStorage = state.memoryBlock;
gameMemory.transientStorage = (uint8_t*)(gameMemory.transientStorage) + gameMemory.transientStorageSize;
initSDL(&window, &renderer, &gOsb, &sdlIC, &srb);
GameCode gameCode = loadGameCode();
assert(gameCode.guarf);
uint64_t startCount = SDL_GetPerformanceCounter();
real32_t targetFrameSeconds = 1./getRefreshRate(window);
SDL_PauseAudio(0);
while(state.running) {
if(getCreateTimeOfFile(GAME_LIB_PATH) != gameCode.dateLastModified) {
reloadGameCode(&gameCode);
}
//keyboard input
ControllerInput* newKeyInput = getContoller(newInputState, 0);
//TODO: figure out why this is special
ControllerInput* oldKeyInput = getContoller(oldInputState, 0);
*newKeyInput = {};
for(size_t i = 0; i < ARRAY_SIZE(oldKeyInput->buttons); i++) {
newKeyInput->buttons[i] = oldKeyInput->buttons[i];
}
while(SDL_PollEvent(&e)) {
processEvent(&e, newInputState, &state);
}
//controller input
for(int i = 0; i < MAX_SDL_CONTROLLERS; i++) {
if(sdlIC.controllers[i] != nullptr && SDL_GameControllerGetAttached(sdlIC.controllers[i])) {
ControllerInput* newCIState = getContoller(newInputState, i+1);
ControllerInput* oldCIState = getContoller(oldInputState, i+1);
int16_t xVal = SDL_GameControllerGetAxis(sdlIC.controllers[i], SDL_CONTROLLER_AXIS_LEFTX);
int16_t yVal = SDL_GameControllerGetAxis(sdlIC.controllers[i], SDL_CONTROLLER_AXIS_LEFTY);
newCIState->avgX = normalizeStickInput(xVal, LEFT_THUMB_DEADZONE);
newCIState->avgY = normalizeStickInput(yVal, LEFT_THUMB_DEADZONE);
if(newCIState->avgX != 0 || newCIState->avgY != 0) {
newCIState->isAnalog = true;
}
processControllerButtonInput(&newCIState->actionDown, &oldCIState->actionDown, &newCIState->isAnalog, sdlIC.controllers[i], SDL_CONTROLLER_BUTTON_A);
processControllerButtonInput(&newCIState->actionUp, &oldCIState->actionUp, &newCIState->isAnalog, sdlIC.controllers[i], SDL_CONTROLLER_BUTTON_Y);
processControllerButtonInput(&newCIState->actionLeft, &oldCIState->actionLeft, &newCIState->isAnalog, sdlIC.controllers[i], SDL_CONTROLLER_BUTTON_X);
processControllerButtonInput(&newCIState->actionRight, &oldCIState->actionRight, &newCIState->isAnalog, sdlIC.controllers[i], SDL_CONTROLLER_BUTTON_B);
processControllerButtonInput(&newCIState->directionDown, &oldCIState->directionDown, &newCIState->isAnalog, sdlIC.controllers[i], SDL_CONTROLLER_BUTTON_DPAD_DOWN);
processControllerButtonInput(&newCIState->directionUp, &oldCIState->directionUp, &newCIState->isAnalog, sdlIC.controllers[i], SDL_CONTROLLER_BUTTON_DPAD_UP);
processControllerButtonInput(&newCIState->directionLeft, &oldCIState->directionLeft, &newCIState->isAnalog, sdlIC.controllers[i], SDL_CONTROLLER_BUTTON_DPAD_LEFT);
processControllerButtonInput(&newCIState->directionRight, &oldCIState->directionRight, &newCIState->isAnalog, sdlIC.controllers[i], SDL_CONTROLLER_BUTTON_DPAD_RIGHT);
oldCIState->isAnalog = newCIState->isAnalog;
}
else {
//TODO: Logging
}
}
//TODO: Do this instead of processing input, not after
//process recording/playback
assert(!(state.isRecording && state.isPlayingBack));
if(state.isRecording) {
recordInput(newInputState, state.inputRecordFile);
}
if(state.isPlayingBack) {
playInput(newInputState, state.inputRecordFile);
}
//calculate audio buffers' indicies and sizes
SDL_LockAudioDevice(1);
uint32_t startIndex = srb.runningIndex % ARRAY_SIZE(srb.samples);
uint32_t endIndex = (srb.sampleToPlay + SOUND_LATENCY) % ARRAY_SIZE(srb.samples);
uint32_t samplesToGetFromGame = (startIndex <= endIndex) ? endIndex - startIndex : (ARRAY_SIZE(srb.samples) - startIndex) + endIndex;
sb.numSamples = samplesToGetFromGame;
SDL_UnlockAudioDevice(1);
gameCode.guarf(&gameMemory, &gOsb, &sb, newInputState, secsSinceLastFrame);
updateSDLSoundBuffer(&srb, &sb, startIndex, endIndex);
updateWindow(window, gTexture);
InputContext* temp = newInputState;
newInputState = oldInputState;
oldInputState = temp;
//benchmark stuff
real32_t secsElapsed = secondsForCountRange(startCount, SDL_GetPerformanceCounter());
//sleep to lock frame rate
if(secsElapsed < targetFrameSeconds) {
//NOTE: .5 denotes the amount we will spin manually since
// SDL_Delay is not 100% accurate
real32_t timeToSleep = (targetFrameSeconds - secsElapsed)*1000 - .5;
SDL_Delay(timeToSleep);
secsElapsed = secondsForCountRange(startCount, SDL_GetPerformanceCounter());
//This assert will fire if the window is moved
//assert(secondsForCountRange(startCount, SDL_GetPerformanceCounter()) < targetFrameSeconds);
while(secondsForCountRange(startCount, SDL_GetPerformanceCounter()) < targetFrameSeconds) {
//wait
}
secsElapsed = secondsForCountRange(startCount, SDL_GetPerformanceCounter());
}
uint64_t endCount = SDL_GetPerformanceCounter();
real32_t fpsCount = ((1./secsElapsed));
real32_t mcPerFrame = (real32_t)(endCount-startCount) / (1000 * 1000 );
printf("TPF: %.2fms FPS: %.2f MCPF: %.2f\n", secsElapsed*1000, fpsCount, mcPerFrame);
startCount = endCount;
secsSinceLastFrame = secsElapsed;
}
cleanUp(&state, &gameCode);
return 0;
}
ButtonStatus
DecafSDL::getButtonStatus(vpad::Channel channel, vpad::Core button)
{
if (!mVpad0Config) {
return ButtonStatus::ButtonReleased;
}
switch (mVpad0Config->type) {
case config::input::None:
break;
case config::input::Keyboard:
{
int numKeys = 0;
auto scancode = getKeyboardButtonMapping(mVpad0Config, channel, button);
auto state = SDL_GetKeyboardState(&numKeys);
if (scancode >= 0 && scancode < numKeys && state[scancode]) {
return ButtonStatus::ButtonPressed;
}
break;
}
case config::input::Joystick:
if (mVpad0Controller && SDL_GameControllerGetAttached(mVpad0Controller)) {
if (getJoystickButtonState(mVpad0Config, mVpad0Controller, channel, button)) {
return ButtonStatus::ButtonPressed;
}
}
break;
}
return ButtonStatus::ButtonReleased;
}
void GameController::closeSDLDevice()
{
if (controller && SDL_GameControllerGetAttached(controller))
{
SDL_GameControllerClose(controller);
controller = 0;
}
}
bool isControllerButtonPressed(u32 controllerIndex, ControllerButton button)
{
SDL_GameController* gc = g_controllerHandles[controllerIndex];
if (gc && SDL_GameControllerGetAttached(gc))
return SDL_GameControllerGetButton(gc, (SDL_GameControllerButton)button) != 0;
return false;
}
int main(int argc, char* argv[]) {
init(argc, argv, 800, 600);
init_controllers_and_audio();
game = new StateManager();
glutMainLoop();
if (SDL_GameControllerGetAttached(controller)) {
SDL_GameControllerClose(controller);
}
delete game;
return EXIT_SUCCESS;
}
int DEV_Joystick::Connected(void)
{
#ifdef WITH_SDL
if (m_isinit &&
(SDL_CHECK(SDL_GameControllerGetAttached) &&
SDL_GameControllerGetAttached(m_private->m_gamecontroller)))
{
return 1;
}
#endif
return 0;
}
void PIN_GameControllerManager::CheckControllers()
{
for(PIN_ControllerBaseList::iterator it = _controllerList.begin();
it != _controllerList.end();/*it++*/)
{
PIN_GameControllerEntry* ctrl = (PIN_GameControllerEntry*)*it;
if(SDL_GameControllerGetAttached(ctrl->Controller) == SDL_FALSE)
{
RemoveGameController(ctrl->ControllerID);
}
else
{
++it;
}
}
}
float
DecafSDL::getAxisValue(vpad::Channel channel, vpad::CoreAxis axis)
{
if (!mVpad0Config) {
return 0.0f;
}
switch (mVpad0Config->type) {
case config::input::None:
break;
case config::input::Keyboard:
{
auto numKeys = 0;
auto scancodeMinus = getKeyboardAxisMapping(mVpad0Config, channel, axis, true);
auto scancodePlus = getKeyboardAxisMapping(mVpad0Config, channel, axis, false);
auto state = SDL_GetKeyboardState(&numKeys);
auto result = 0.0f;
if (scancodeMinus >= 0 && scancodeMinus < numKeys && state[scancodeMinus]) {
result -= 1.0f;
}
if (scancodePlus >= 0 && scancodePlus < numKeys && state[scancodePlus]) {
result += 1.0f;
}
return result;
}
case config::input::Joystick:
if (mVpad0Controller && SDL_GameControllerGetAttached(mVpad0Controller)) {
auto value = getJoystickAxisState(mVpad0Config, mVpad0Controller, channel, axis);
if (value < 0) {
return value / 32768.0f;
} else {
return value / 32767.0f;
}
}
break;
}
return 0.0f;
}
static SDL_GameController* grab_controller(SDL_GameController* controller)
{
if (!controller || !SDL_GameControllerGetAttached(controller)) {
int32_t i, joystick_count;
controller = NULL;
joystick_count = SDL_NumJoysticks();
for (i = 0; i < joystick_count; ++i) {
if (SDL_IsGameController(i)) {
controller = SDL_GameControllerOpen(i);
break;
}
}
}
return (controller);
}
f32 getControllerAxis(u32 controllerIndex, ControllerAxis axis)
{
SDL_GameController* gc = g_controllerHandles[controllerIndex];
if (gc && SDL_GameControllerGetAttached(gc))
{
s16 value = SDL_GameControllerGetAxis(gc, (SDL_GameControllerAxis)axis);
if (axis == ControllerAxis::LeftY)
value = -value;
if (value >= 0)
return (f32)value / 32767.0f;
return (f32)value / 32768.0f;
}
return 0.0f;
}
/*
* IN_SDL_JoyCommands
*
* SDL game controller code called in IN_Commands.
*/
void IN_SDL_JoyCommands( void )
{
int i, buttons = 0, buttonsDiff;
static int buttonsOld;
const int keys[] =
{
K_A_BUTTON, K_B_BUTTON, K_X_BUTTON, K_Y_BUTTON, K_ESCAPE, 0, 0,
K_LSTICK, K_RSTICK, K_LSHOULDER, K_RSHOULDER,
K_DPAD_UP, K_DPAD_DOWN, K_DPAD_LEFT, K_DPAD_RIGHT,
K_LTRIGGER, K_RTRIGGER
};
if( in_sdl_joyInitialized )
{
SDL_GameControllerUpdate();
if( in_sdl_joyController && !SDL_GameControllerGetAttached( in_sdl_joyController ) )
{
SDL_GameControllerClose( in_sdl_joyController );
in_sdl_joyController = NULL;
}
if( !in_sdl_joyController )
{
int num = SDL_NumJoysticks();
for( i = 0; i < num; i++ )
{
in_sdl_joyController = SDL_GameControllerOpen( i );
if( in_sdl_joyController )
break;
}
}
}
if( in_sdl_joyActive )
{
SDL_GameController *controller = in_sdl_joyController;
if( controller )
{
for( i = 0; i < SDL_CONTROLLER_BUTTON_MAX; i++ )
{
if( keys[i] && SDL_GameControllerGetButton( controller, i ) )
buttons |= 1 << i;
}
if( SDL_GameControllerGetButton( controller, SDL_CONTROLLER_BUTTON_START ) )
buttons |= 1 << SDL_CONTROLLER_BUTTON_BACK;
if( SDL_GameControllerGetAxis( controller, SDL_CONTROLLER_AXIS_TRIGGERLEFT ) > ( 30 * 128 ) )
buttons |= 1 << SDL_CONTROLLER_BUTTON_MAX;
if( SDL_GameControllerGetAxis( controller, SDL_CONTROLLER_AXIS_TRIGGERRIGHT ) > ( 30 * 128 ) )
buttons |= 1 << ( SDL_CONTROLLER_BUTTON_MAX + 1 );
}
}
buttonsDiff = buttons ^ buttonsOld;
if( buttonsDiff )
{
unsigned int time = Sys_Milliseconds();
for( i = 0; i < ( sizeof( keys ) / sizeof( keys[0] ) ); i++ )
{
if( buttonsDiff & ( 1 << i ) )
Key_Event( keys[i], ( buttons & ( 1 << i ) ) ? true : false, time );
}
buttonsOld = buttons;
}
}
internal void process_joysticks(struct sdl_event_context *ctx,
struct human_input *old_input,
struct human_input *new_input)
{
unsigned int i;
struct game_controller_input *old_controller_input,
*new_controller_input;
int stick_x, stick_y;
/* DPAD
unsigned int up, down, left, right, start, back;
*/
for (i = 0; i < MAX_CONTROLLERS; ++i) {
if (!(ctx->players[i].controller)) {
continue;
}
if (!SDL_GameControllerGetAttached(ctx->players[i].controller)) {
continue;
}
old_controller_input = &old_input->controllers[i];
new_controller_input = &new_input->controllers[i];
new_controller_input->is_analog = 1;
/*
up = SDL_GameControllerGetButton(ctx->players[i].controller,
SDL_CONTROLLER_BUTTON_DPAD_UP);
down = SDL_GameControllerGetButton(ctx->players[i].controller,
SDL_CONTROLLER_BUTTON_DPAD_DOWN);
left = SDL_GameControllerGetButton(ctx->players[i].controller,
SDL_CONTROLLER_BUTTON_DPAD_LEFT);
right = SDL_GameControllerGetButton(ctx->players[i].controller,
SDL_CONTROLLER_BUTTON_DPAD_RIGHT);
start = SDL_GameControllerGetButton(ctx->players[i].controller,
SDL_CONTROLLER_BUTTON_START);
back = SDL_GameControllerGetButton(ctx->players[i].controller,
SDL_CONTROLLER_BUTTON_BACK);
*/
process_button(&
(old_controller_input->but_u.
six_buttons.l_shoulder),
&(new_controller_input->but_u.
six_buttons.l_shoulder),
ctx->players[i].controller,
SDL_CONTROLLER_BUTTON_LEFTSHOULDER);
process_button(&
(old_controller_input->but_u.
six_buttons.r_shoulder),
&(new_controller_input->but_u.
six_buttons.r_shoulder),
ctx->players[i].controller,
SDL_CONTROLLER_BUTTON_RIGHTSHOULDER);
process_button(&(old_controller_input->but_u.six_buttons.down),
&(new_controller_input->but_u.six_buttons.down),
ctx->players[i].controller,
SDL_CONTROLLER_BUTTON_A);
process_button(&(old_controller_input->but_u.six_buttons.right),
&(new_controller_input->but_u.six_buttons.right),
ctx->players[i].controller,
SDL_CONTROLLER_BUTTON_B);
process_button(&(old_controller_input->but_u.six_buttons.left),
&(new_controller_input->but_u.six_buttons.left),
ctx->players[i].controller,
SDL_CONTROLLER_BUTTON_X);
process_button(&(old_controller_input->but_u.six_buttons.up),
&(new_controller_input->but_u.six_buttons.up),
ctx->players[i].controller,
SDL_CONTROLLER_BUTTON_Y);
stick_x =
SDL_GameControllerGetAxis(ctx->players[i].controller,
SDL_CONTROLLER_AXIS_LEFTX);
stick_y =
SDL_GameControllerGetAxis(ctx->players[i].controller,
SDL_CONTROLLER_AXIS_LEFTY);
if (stick_x < 0) {
new_controller_input->end_x = stick_x / -32768.0f;
} else {
new_controller_input->end_x = stick_x / -32767.0f;
}
new_controller_input->min_x = new_controller_input->max_x =
new_controller_input->end_x;
if (stick_y < 0) {
new_controller_input->end_y = stick_y / -32768.0f;
} else {
new_controller_input->end_y = stick_y / -32767.0f;
}
new_controller_input->min_y = new_controller_input->max_y =
new_controller_input->end_y;
}
}
SDL_bool
WatchGameController(SDL_GameController * gamecontroller)
{
/* This is indexed by SDL_GameControllerButton. */
static const struct { int x; int y; } button_positions[] = {
{387, 167}, /* A */
{431, 132}, /* B */
{342, 132}, /* X */
{389, 101}, /* Y */
{174, 132}, /* BACK */
{233, 132}, /* GUIDE */
{289, 132}, /* START */
{75, 154}, /* LEFTSTICK */
{305, 230}, /* RIGHTSTICK */
{77, 40}, /* LEFTSHOULDER */
{396, 36}, /* RIGHTSHOULDER */
{154, 188}, /* DPAD_UP */
{154, 249}, /* DPAD_DOWN */
{116, 217}, /* DPAD_LEFT */
{186, 217}, /* DPAD_RIGHT */
};
/* This is indexed by SDL_GameControllerAxis. */
static const struct { int x; int y; double angle; } axis_positions[] = {
{75, 154, 0.0}, /* LEFTX */
{75, 154, 90.0}, /* LEFTY */
{305, 230, 0.0}, /* RIGHTX */
{305, 230, 90.0}, /* RIGHTY */
{91, 0, 90.0}, /* TRIGGERLEFT */
{375, 0, 90.0}, /* TRIGGERRIGHT */
};
const char *name = SDL_GameControllerName(gamecontroller);
const char *basetitle = "Game Controller Test: ";
const size_t titlelen = SDL_strlen(basetitle) + SDL_strlen(name) + 1;
char *title = (char *)SDL_malloc(titlelen);
SDL_Texture *background, *button, *axis;
SDL_Window *window = NULL;
SDL_Renderer *screen = NULL;
SDL_bool retval = SDL_FALSE;
SDL_bool done = SDL_FALSE;
SDL_Event event;
int i;
if (title) {
SDL_snprintf(title, titlelen, "%s%s", basetitle, name);
}
/* Create a window to display controller state */
window = SDL_CreateWindow(title, SDL_WINDOWPOS_CENTERED,
SDL_WINDOWPOS_CENTERED, SCREEN_WIDTH,
SCREEN_HEIGHT, 0);
if (window == NULL) {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't create window: %s\n", SDL_GetError());
return SDL_FALSE;
}
screen = SDL_CreateRenderer(window, -1, 0);
if (screen == NULL) {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't create renderer: %s\n", SDL_GetError());
SDL_DestroyWindow(window);
return SDL_FALSE;
}
SDL_SetRenderDrawColor(screen, 0x00, 0x00, 0x00, SDL_ALPHA_OPAQUE);
SDL_RenderClear(screen);
SDL_RenderPresent(screen);
SDL_RaiseWindow(window);
/* scale for platforms that don't give you the window size you asked for. */
SDL_RenderSetLogicalSize(screen, SCREEN_WIDTH, SCREEN_HEIGHT);
background = LoadTexture(screen, "controllermap.bmp", SDL_FALSE);
button = LoadTexture(screen, "button.bmp", SDL_TRUE);
axis = LoadTexture(screen, "axis.bmp", SDL_TRUE);
if (!background || !button || !axis) {
SDL_DestroyRenderer(screen);
SDL_DestroyWindow(window);
return SDL_FALSE;
}
SDL_SetTextureColorMod(button, 10, 255, 21);
SDL_SetTextureColorMod(axis, 10, 255, 21);
/* !!! FIXME: */
/*SDL_RenderSetLogicalSize(screen, background->w, background->h);*/
/* Print info about the controller we are watching */
SDL_Log("Watching controller %s\n", name ? name : "Unknown Controller");
/* Loop, getting controller events! */
while (!done) {
/* blank screen, set up for drawing this frame. */
SDL_SetRenderDrawColor(screen, 0xFF, 0xFF, 0xFF, SDL_ALPHA_OPAQUE);
SDL_RenderClear(screen);
SDL_RenderCopy(screen, background, NULL, NULL);
while (SDL_PollEvent(&event)) {
switch (event.type) {
case SDL_KEYDOWN:
if (event.key.keysym.sym != SDLK_ESCAPE) {
break;
}
/* Fall through to signal quit */
case SDL_QUIT:
done = SDL_TRUE;
break;
default:
break;
}
}
/* Update visual controller state */
for (i = 0; i < SDL_CONTROLLER_BUTTON_MAX; ++i) {
if (SDL_GameControllerGetButton(gamecontroller, (SDL_GameControllerButton)i) == SDL_PRESSED) {
const SDL_Rect dst = { button_positions[i].x, button_positions[i].y, 50, 50 };
SDL_RenderCopyEx(screen, button, NULL, &dst, 0, NULL, 0);
}
}
for (i = 0; i < SDL_CONTROLLER_AXIS_MAX; ++i) {
const Sint16 deadzone = 8000; /* !!! FIXME: real deadzone */
const Sint16 value = SDL_GameControllerGetAxis(gamecontroller, (SDL_GameControllerAxis)(i));
if (value < -deadzone) {
const SDL_Rect dst = { axis_positions[i].x, axis_positions[i].y, 50, 50 };
const double angle = axis_positions[i].angle;
SDL_RenderCopyEx(screen, axis, NULL, &dst, angle, NULL, 0);
} else if (value > deadzone) {
const SDL_Rect dst = { axis_positions[i].x, axis_positions[i].y, 50, 50 };
const double angle = axis_positions[i].angle + 180.0;
SDL_RenderCopyEx(screen, axis, NULL, &dst, angle, NULL, 0);
}
}
SDL_RenderPresent(screen);
if (!SDL_GameControllerGetAttached(gamecontroller)) {
done = SDL_TRUE;
retval = SDL_TRUE; /* keep going, wait for reattach. */
}
}
SDL_DestroyRenderer(screen);
SDL_DestroyWindow(window);
return retval;
}
void loop(void *arg) {
SDL_Event event;
int i;
SDL_GameController *gamecontroller = (SDL_GameController *)arg;
/* blank screen, set up for drawing this frame. */
SDL_SetRenderDrawColor(screen, 0xFF, 0xFF, 0xFF, SDL_ALPHA_OPAQUE);
SDL_RenderClear(screen);
SDL_RenderCopy(screen, background, NULL, NULL);
while (SDL_PollEvent(&event)) {
switch (event.type) {
case SDL_KEYDOWN:
if (event.key.keysym.sym != SDLK_ESCAPE) {
break;
}
/* Fall through to signal quit */
case SDL_QUIT:
done = SDL_TRUE;
break;
default:
break;
}
}
/* Update visual controller state */
for (i = 0; i < SDL_CONTROLLER_BUTTON_MAX; ++i) {
if (SDL_GameControllerGetButton(
gamecontroller, (SDL_GameControllerButton)i) == SDL_PRESSED) {
const SDL_Rect dst = {button_positions[i].x, button_positions[i].y, 50,
50};
SDL_RenderCopyEx(screen, button, NULL, &dst, 0, NULL, 0);
}
}
for (i = 0; i < SDL_CONTROLLER_AXIS_MAX; ++i) {
const Sint16 deadzone = 8000; /* !!! FIXME: real deadzone */
const Sint16 value =
SDL_GameControllerGetAxis(gamecontroller, (SDL_GameControllerAxis)(i));
if (value < -deadzone) {
const SDL_Rect dst = {axis_positions[i].x, axis_positions[i].y, 50, 50};
const double angle = axis_positions[i].angle;
SDL_RenderCopyEx(screen, axis, NULL, &dst, angle, NULL, 0);
} else if (value > deadzone) {
const SDL_Rect dst = {axis_positions[i].x, axis_positions[i].y, 50, 50};
const double angle = axis_positions[i].angle + 180.0;
SDL_RenderCopyEx(screen, axis, NULL, &dst, angle, NULL, 0);
}
}
SDL_RenderPresent(screen);
if (!SDL_GameControllerGetAttached(gamecontroller)) {
done = SDL_TRUE;
retval = SDL_TRUE; /* keep going, wait for reattach. */
}
#ifdef __EMSCRIPTEN__
if (done) {
emscripten_cancel_main_loop();
}
#endif
}
void
WatchGameController(SDL_GameController * gamecontroller)
{
SDL_Window *window = NULL;
SDL_Renderer *screen = NULL;
const char *name = NULL;
int done = 0;
SDL_Event event;
int i;
/* Create a window to display controller axis position */
window = SDL_CreateWindow("Game Controller Test", SDL_WINDOWPOS_CENTERED,
SDL_WINDOWPOS_CENTERED, SCREEN_WIDTH,
SCREEN_HEIGHT, SDL_WINDOW_SHOWN);
if (window == NULL) {
fprintf(stderr, "Couldn't create window: %s\n", SDL_GetError());
return;
}
screen = SDL_CreateRenderer(window, -1, 0);
if (screen == NULL) {
fprintf(stderr, "Couldn't create renderer: %s\n", SDL_GetError());
SDL_DestroyWindow(window);
return;
}
SDL_SetRenderDrawColor(screen, 0x00, 0x00, 0x00, SDL_ALPHA_OPAQUE);
SDL_RenderClear(screen);
SDL_RenderPresent(screen);
SDL_RaiseWindow(window);
/* Print info about the controller we are watching */
name = SDL_GameControllerName(gamecontroller);
printf("Watching controller %s\n", name ? name : "Unknown Controller");
/* Loop, getting controller events! */
while (!done) {
/* blank screen, set up for drawing this frame. */
SDL_SetRenderDrawColor(screen, 0x00, 0x00, 0x00, SDL_ALPHA_OPAQUE);
SDL_RenderClear(screen);
while (SDL_PollEvent(&event)) {
switch (event.type) {
case SDL_CONTROLLERAXISMOTION:
printf("Controller %d axis %d value: %d\n",
event.caxis.which,
event.caxis.axis, event.caxis.value);
break;
case SDL_CONTROLLERBUTTONDOWN:
printf("Controller %d button %d down\n",
event.cbutton.which, event.cbutton.button);
break;
case SDL_CONTROLLERBUTTONUP:
printf("Controller %d button %d up\n",
event.cbutton.which, event.cbutton.button);
break;
case SDL_KEYDOWN:
if (event.key.keysym.sym != SDLK_ESCAPE) {
break;
}
/* Fall through to signal quit */
case SDL_QUIT:
done = 1;
s_ForceQuit = SDL_TRUE;
break;
default:
break;
}
}
/* Update visual controller state */
SDL_SetRenderDrawColor(screen, 0x00, 0xFF, 0x00, SDL_ALPHA_OPAQUE);
for (i = 0; i <SDL_CONTROLLER_BUTTON_MAX; ++i) {
if (SDL_GameControllerGetButton(gamecontroller, i) == SDL_PRESSED) {
DrawRect(screen, i * 34, SCREEN_HEIGHT - 34, 32, 32);
}
}
SDL_SetRenderDrawColor(screen, 0xFF, 0x00, 0x00, SDL_ALPHA_OPAQUE);
for (i = 0; i < SDL_CONTROLLER_AXIS_MAX / 2; ++i) {
/* Draw the X/Y axis */
int x, y;
x = (((int) SDL_GameControllerGetAxis(gamecontroller, i * 2 + 0)) + 32768);
x *= SCREEN_WIDTH;
x /= 65535;
if (x < 0) {
x = 0;
} else if (x > (SCREEN_WIDTH - 16)) {
x = SCREEN_WIDTH - 16;
}
y = (((int) SDL_GameControllerGetAxis(gamecontroller, i * 2 + 1)) + 32768);
y *= SCREEN_HEIGHT;
y /= 65535;
if (y < 0) {
y = 0;
} else if (y > (SCREEN_HEIGHT - 16)) {
y = SCREEN_HEIGHT - 16;
}
DrawRect(screen, x, y, 16, 16);
}
SDL_SetRenderDrawColor(screen, 0x00, 0x00, 0xFF, SDL_ALPHA_OPAQUE);
SDL_RenderPresent(screen);
if ( !done )
done = SDL_GameControllerGetAttached( gamecontroller ) == 0;
}
SDL_DestroyRenderer(screen);
SDL_DestroyWindow(window);
}
int GameController::isAttached(State & state, SDL_GameController * gamecontroller) {
Stack * stack = state.stack;
stack->push<bool>(SDL_GameControllerGetAttached(gamecontroller) == SDL_TRUE);
return 1;
}
bool C4GamePadOpener::IsAttached()
{
return !!SDL_GameControllerGetAttached(controller);
}
bool is_attached() const noexcept {
return SDL_GameControllerGetAttached(ptr.get());
}
void operator()(SDL_GameController* controller) const noexcept {
if(SDL_GameControllerGetAttached(controller) == SDL_TRUE) {
SDL_GameControllerClose(controller);
}
}
bool isControllerPresent(u32 controllerIndex)
{
SDL_GameController* gc = g_controllerHandles[controllerIndex];
return (gc && SDL_GameControllerGetAttached(gc));
}
SDL_bool
WatchGameController(SDL_GameController * gamecontroller)
{
const char *name = SDL_GameControllerName(gamecontroller);
const char *basetitle = "Game Controller Test: ";
const size_t titlelen = SDL_strlen(basetitle) + SDL_strlen(name) + 1;
char *title = (char *)SDL_malloc(titlelen);
SDL_Window *window = NULL;
SDL_Renderer *screen = NULL;
SDL_bool retval = SDL_FALSE;
SDL_bool done = SDL_FALSE;
SDL_Event event;
int i;
if (title) {
SDL_snprintf(title, titlelen, "%s%s", basetitle, name);
}
/* Create a window to display controller axis position */
window = SDL_CreateWindow(title, SDL_WINDOWPOS_CENTERED,
SDL_WINDOWPOS_CENTERED, SCREEN_WIDTH,
SCREEN_HEIGHT, 0);
if (window == NULL) {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't create window: %s\n", SDL_GetError());
return SDL_FALSE;
}
screen = SDL_CreateRenderer(window, -1, 0);
if (screen == NULL) {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't create renderer: %s\n", SDL_GetError());
SDL_DestroyWindow(window);
return SDL_FALSE;
}
SDL_SetRenderDrawColor(screen, 0x00, 0x00, 0x00, SDL_ALPHA_OPAQUE);
SDL_RenderClear(screen);
SDL_RenderPresent(screen);
SDL_RaiseWindow(window);
/* Print info about the controller we are watching */
SDL_Log("Watching controller %s\n", name ? name : "Unknown Controller");
/* Loop, getting controller events! */
while (!done) {
/* blank screen, set up for drawing this frame. */
SDL_SetRenderDrawColor(screen, 0x00, 0x00, 0x00, SDL_ALPHA_OPAQUE);
SDL_RenderClear(screen);
while (SDL_PollEvent(&event)) {
switch (event.type) {
case SDL_CONTROLLERAXISMOTION:
SDL_Log("Controller %d axis %d ('%s') value: %d\n",
event.caxis.which,
event.caxis.axis,
ControllerAxisName((SDL_GameControllerAxis)event.caxis.axis),
event.caxis.value);
break;
case SDL_CONTROLLERBUTTONDOWN:
SDL_Log("Controller %d button %d ('%s') down\n",
event.cbutton.which, event.cbutton.button,
ControllerButtonName((SDL_GameControllerButton)event.cbutton.button));
break;
case SDL_CONTROLLERBUTTONUP:
SDL_Log("Controller %d button %d ('%s') up\n",
event.cbutton.which, event.cbutton.button,
ControllerButtonName((SDL_GameControllerButton)event.cbutton.button));
break;
case SDL_KEYDOWN:
if (event.key.keysym.sym != SDLK_ESCAPE) {
break;
}
/* Fall through to signal quit */
case SDL_QUIT:
done = SDL_TRUE;
break;
default:
break;
}
}
/* Update visual controller state */
SDL_SetRenderDrawColor(screen, 0x00, 0xFF, 0x00, SDL_ALPHA_OPAQUE);
for (i = 0; i <SDL_CONTROLLER_BUTTON_MAX; ++i) {
if (SDL_GameControllerGetButton(gamecontroller, (SDL_GameControllerButton)i) == SDL_PRESSED) {
DrawRect(screen, i * 34, SCREEN_HEIGHT - 34, 32, 32);
}
}
SDL_SetRenderDrawColor(screen, 0xFF, 0x00, 0x00, SDL_ALPHA_OPAQUE);
for (i = 0; i < SDL_CONTROLLER_AXIS_MAX / 2; ++i) {
/* Draw the X/Y axis */
int x, y;
x = (((int) SDL_GameControllerGetAxis(gamecontroller, (SDL_GameControllerAxis)(i * 2 + 0))) + 32768);
x *= SCREEN_WIDTH;
x /= 65535;
if (x < 0) {
x = 0;
} else if (x > (SCREEN_WIDTH - 16)) {
x = SCREEN_WIDTH - 16;
}
y = (((int) SDL_GameControllerGetAxis(gamecontroller, (SDL_GameControllerAxis)(i * 2 + 1))) + 32768);
y *= SCREEN_HEIGHT;
y /= 65535;
if (y < 0) {
y = 0;
} else if (y > (SCREEN_HEIGHT - 16)) {
y = SCREEN_HEIGHT - 16;
}
DrawRect(screen, x, y, 16, 16);
}
SDL_SetRenderDrawColor(screen, 0x00, 0x00, 0xFF, SDL_ALPHA_OPAQUE);
SDL_RenderPresent(screen);
if (!SDL_GameControllerGetAttached(gamecontroller)) {
done = SDL_TRUE;
retval = SDL_TRUE; /* keep going, wait for reattach. */
}
}
SDL_DestroyRenderer(screen);
SDL_DestroyWindow(window);
return retval;
}
