switch-examples:

- added full controller support
- added multi-controller support
- added splitscreen support
- added touch screen support
- added full camera-controller support
- updated related examples
This commit is contained in:
Spencer Vaughn 2023-02-26 17:04:01 -06:00
commit 65a4a0092a
4 changed files with 826 additions and 253 deletions

View file

@ -71,6 +71,7 @@
#define NX_SUPPORT_GAMEPAD_EMULATION 1
// Enabling this flag allows debugging by USB, the application will wait for an USB connection to start
//#define NX_USB_DEBUGGER 1
// #define ENABLE_DEV_EXIT 1 // Allows for exit when gamepad kbm emulation is disabled
// rcore: Configuration values
//------------------------------------------------------------------------------------

View file

@ -303,6 +303,7 @@ typedef struct Font {
// Camera, defines position/orientation in 3d space
typedef struct Camera3D {
Vector3 position; // Camera position
Vector2 angle; // Camera angle (Required for splitscreen instead of shared global)
Vector3 target; // Camera target it looks-at
Vector3 up; // Camera up vector (rotation over its axis)
float fovy; // Camera field-of-view aperture in Y (degrees) in perspective, used as near plane width in orthographic
@ -1113,6 +1114,8 @@ RLAPI int GetGamepadButtonPressed(void); // Get the last ga
RLAPI int GetGamepadAxisCount(int gamepad); // Get gamepad axis count for a gamepad
RLAPI float GetGamepadAxisMovement(int gamepad, int axis); // Get axis movement value for a gamepad axis
RLAPI int SetGamepadMappings(const char *mappings); // Set internal gamepad mappings (SDL_GameControllerDB)
RLAPI void SetGamepadYAxisInverted(int gamepad, float yInverted);
RLAPI float GetGamepadYAxisInverted(int gamepad);
// Input-related functions: mouse
RLAPI bool IsMouseButtonPressed(int button); // Check if a mouse button has been pressed once
@ -1154,6 +1157,9 @@ RLAPI float GetGesturePinchAngle(void); // Get gesture pinch ang
//------------------------------------------------------------------------------------
RLAPI void SetCameraMode(Camera camera, int mode); // Set camera mode (multiple camera modes available)
RLAPI void UpdateCamera(Camera *camera); // Update camera position for selected mode
RLAPI void UpdateCameraGamepad(Camera *camera, int Gamepad); // Update camera position for selected mode
RLAPI void SetCameraZoomFactor(Vector2 zoomFactor); // Gamepad equivalent of mousewheel
RLAPI void SetCameraPrevZoomFactor(Vector2 previousZoomFactor); // Gamepad equivalent for automation
RLAPI void SetCameraPanControl(int keyPan); // Set camera pan key to combine with mouse movement (free camera)
RLAPI void SetCameraAltControl(int keyAlt); // Set camera alt key to combine with mouse movement (free camera)

View file

@ -159,8 +159,12 @@ void SetCameraMoveControls(int keyFront, int keyBack,
#define CAMERA_FREE_DISTANCE_MAX_CLAMP 120.0f
#define CAMERA_FREE_MIN_CLAMP 85.0f
#define CAMERA_FREE_MAX_CLAMP -85.0f
#define CAMERA_FREE_SMOOTH_ZOOM_SENSITIVITY 0.05f
#define CAMERA_FREE_PANNING_DIVIDER 5.1f
#if defined(PLATFORM_NX)
#define CAMERA_FREE_SMOOTH_ZOOM_SENSITIVITY -0.5f
#else
#define CAMERA_FREE_SMOOTH_ZOOM_SENSITIVITY 0.05f
#endif
// ORBITAL_CAMERA
#define CAMERA_ORBITAL_SPEED 0.5f // Radians per second
@ -223,7 +227,11 @@ static CameraData CAMERA = { // Global CAMERA state context
.playerEyesPosition = 1.85f,
.angle = { 0 },
.moveControl = { 'W', 'S', 'D', 'A', 'E', 'Q' },
#if defined(PLATFORM_NX)
.smoothZoomControl = GAMEPAD_BUTTON_RIGHT_FACE_RIGHT, // Npad button A
#else
.smoothZoomControl = 341, // raylib: KEY_LEFT_CONTROL
#endif
.altControl = 342, // raylib: KEY_LEFT_ALT
.panControl = 2 // raylib: MOUSE_BUTTON_MIDDLE
};
@ -534,6 +542,285 @@ void UpdateCamera(Camera *camera)
default: break;
}
}
// Update camera depending on selected mode
// NOTE: Camera controls depend on some raylib functions:
// System: EnableCursor(), DisableCursor()
// Mouse: IsMouseButtonDown(), GetMousePosition(), GetMouseWheelMove()
// Keys: IsKeyDown()
void UpdateCameraGamepad(Camera *camera, int gamepad)
{
static float swingCounter[MAX_GAMEPADS] = { 0.0f, 0.0f, 0.0f, 0.0f }; // Used for 1st person swinging movement
// TODO: Compute CAMERA.targetDistance and CAMERA.angle here (?)
// Pan with Left Thumbstick
Vector2 leftStickDelta = {
-GetGamepadAxisMovement(gamepad, GAMEPAD_AXIS_LEFT_X),
GetGamepadAxisMovement(gamepad, GAMEPAD_AXIS_LEFT_Y)
};
// Rotate with Right Thumbstick
Vector2 rightStickDelta = {
-GetGamepadAxisMovement(gamepad, GAMEPAD_AXIS_RIGHT_X),
GetGamepadAxisMovement(gamepad, GAMEPAD_AXIS_RIGHT_Y)
};
float zoomFactor = GetMouseWheelMove();
bool szoomKey = IsGamepadButtonDown(gamepad, CAMERA.smoothZoomControl); // Npad A
bool direction[4] = {
GetGamepadAxisMovement(gamepad, GAMEPAD_AXIS_LEFT_Y) > 0,
GetGamepadAxisMovement(gamepad, GAMEPAD_AXIS_LEFT_Y) < 0,
GetGamepadAxisMovement(gamepad, GAMEPAD_AXIS_LEFT_X) > 0,
GetGamepadAxisMovement(gamepad, GAMEPAD_AXIS_LEFT_X) < 0
};
// Support for multiple automatic camera modes
// NOTE: In case of CAMERA_CUSTOM nothing happens here, user must update it manually
switch (CAMERA.mode)
{
case CAMERA_FREE: // Camera free controls, using standard 3d-content-creation scheme
{
// Camera zoom
if ((CAMERA.targetDistance < CAMERA_FREE_DISTANCE_MAX_CLAMP) && (zoomFactor < 0))
{
CAMERA.targetDistance -= (zoomFactor*CAMERA_MOUSE_SCROLL_SENSITIVITY);
if (CAMERA.targetDistance > CAMERA_FREE_DISTANCE_MAX_CLAMP) CAMERA.targetDistance = CAMERA_FREE_DISTANCE_MAX_CLAMP;
}
// Camera looking down
else if ((camera->position.y > camera->target.y) && (CAMERA.targetDistance == CAMERA_FREE_DISTANCE_MAX_CLAMP) && (zoomFactor < 0))
{
camera->target.x += zoomFactor*(camera->target.x - camera->position.x)*CAMERA_MOUSE_SCROLL_SENSITIVITY/CAMERA.targetDistance;
camera->target.y += zoomFactor*(camera->target.y - camera->position.y)*CAMERA_MOUSE_SCROLL_SENSITIVITY/CAMERA.targetDistance;
camera->target.z += zoomFactor*(camera->target.z - camera->position.z)*CAMERA_MOUSE_SCROLL_SENSITIVITY/CAMERA.targetDistance;
}
else if ((camera->position.y > camera->target.y) && (camera->target.y >= 0))
{
camera->target.x += zoomFactor*(camera->target.x - camera->position.x)*CAMERA_MOUSE_SCROLL_SENSITIVITY/CAMERA.targetDistance;
camera->target.y += zoomFactor*(camera->target.y - camera->position.y)*CAMERA_MOUSE_SCROLL_SENSITIVITY/CAMERA.targetDistance;
camera->target.z += zoomFactor*(camera->target.z - camera->position.z)*CAMERA_MOUSE_SCROLL_SENSITIVITY/CAMERA.targetDistance;
// if (camera->target.y < 0) camera->target.y = -0.001;
}
else if ((camera->position.y > camera->target.y) && (camera->target.y < 0) && (zoomFactor > 0))
{
CAMERA.targetDistance -= (zoomFactor*CAMERA_MOUSE_SCROLL_SENSITIVITY);
if (CAMERA.targetDistance < CAMERA_FREE_DISTANCE_MIN_CLAMP) CAMERA.targetDistance = CAMERA_FREE_DISTANCE_MIN_CLAMP;
}
// Camera looking up
else if ((camera->position.y < camera->target.y) && (CAMERA.targetDistance == CAMERA_FREE_DISTANCE_MAX_CLAMP) && (zoomFactor < 0))
{
camera->target.x += zoomFactor*(camera->target.x - camera->position.x)*CAMERA_MOUSE_SCROLL_SENSITIVITY/CAMERA.targetDistance;
camera->target.y += zoomFactor*(camera->target.y - camera->position.y)*CAMERA_MOUSE_SCROLL_SENSITIVITY/CAMERA.targetDistance;
camera->target.z += zoomFactor*(camera->target.z - camera->position.z)*CAMERA_MOUSE_SCROLL_SENSITIVITY/CAMERA.targetDistance;
}
else if ((camera->position.y < camera->target.y) && (camera->target.y <= 0))
{
camera->target.x += zoomFactor*(camera->target.x - camera->position.x)*CAMERA_MOUSE_SCROLL_SENSITIVITY/CAMERA.targetDistance;
camera->target.y += zoomFactor*(camera->target.y - camera->position.y)*CAMERA_MOUSE_SCROLL_SENSITIVITY/CAMERA.targetDistance;
camera->target.z += zoomFactor*(camera->target.z - camera->position.z)*CAMERA_MOUSE_SCROLL_SENSITIVITY/CAMERA.targetDistance;
// if (camera->target.y > 0) camera->target.y = 0.001;
}
else if ((camera->position.y < camera->target.y) && (camera->target.y > 0) && (zoomFactor > 0))
{
CAMERA.targetDistance -= (zoomFactor*CAMERA_MOUSE_SCROLL_SENSITIVITY);
if (CAMERA.targetDistance < CAMERA_FREE_DISTANCE_MIN_CLAMP) CAMERA.targetDistance = CAMERA_FREE_DISTANCE_MIN_CLAMP;
}
// Camera rotation
CAMERA.angle.x += rightStickDelta.x*CAMERA_FREE_MOUSE_SENSITIVITY;
CAMERA.angle.y += rightStickDelta.y*CAMERA_FREE_MOUSE_SENSITIVITY;
// Angle clamp
if (CAMERA.angle.y > CAMERA_FREE_MIN_CLAMP*DEG2RAD) CAMERA.angle.y = CAMERA_FREE_MIN_CLAMP*DEG2RAD;
else if (CAMERA.angle.y < CAMERA_FREE_MAX_CLAMP*DEG2RAD) CAMERA.angle.y = CAMERA_FREE_MAX_CLAMP*DEG2RAD;
if (szoomKey)
{
// Camera smooth zoom
CAMERA.targetDistance += (leftStickDelta.y*CAMERA_FREE_SMOOTH_ZOOM_SENSITIVITY);
} else {
// Camera panning
camera->target.x += ((leftStickDelta.x*CAMERA_FREE_MOUSE_SENSITIVITY)*cosf(CAMERA.angle.x) + (leftStickDelta.y*-CAMERA_FREE_MOUSE_SENSITIVITY)*sinf(CAMERA.angle.x)*sinf(CAMERA.angle.y))*(CAMERA.targetDistance/CAMERA_FREE_PANNING_DIVIDER);
camera->target.y += ((leftStickDelta.y*CAMERA_FREE_MOUSE_SENSITIVITY)*cosf(CAMERA.angle.y))*(CAMERA.targetDistance/CAMERA_FREE_PANNING_DIVIDER);
camera->target.z += ((leftStickDelta.x*-CAMERA_FREE_MOUSE_SENSITIVITY)*sinf(CAMERA.angle.x) + (leftStickDelta.y*-CAMERA_FREE_MOUSE_SENSITIVITY)*cosf(CAMERA.angle.x)*sinf(CAMERA.angle.y))*(CAMERA.targetDistance/CAMERA_FREE_PANNING_DIVIDER);
}
// Update camera position with changes
camera->position.x = -sinf(CAMERA.angle.x)*CAMERA.targetDistance*cosf(CAMERA.angle.y) + camera->target.x;
camera->position.y = -sinf(CAMERA.angle.y)*CAMERA.targetDistance + camera->target.y;
camera->position.z = -cosf(CAMERA.angle.x)*CAMERA.targetDistance*cosf(CAMERA.angle.y) + camera->target.z;
// L/R Bumpers to zoom out/in
SetCameraPrevZoomFactor((Vector2) { 0.0f, zoomFactor });
if (IsGamepadButtonDown(gamepad, GAMEPAD_BUTTON_RIGHT_TRIGGER_1))
{
SetCameraZoomFactor((Vector2){ 0.0f, 1.0f });
} else if (IsGamepadButtonDown(gamepad, GAMEPAD_BUTTON_LEFT_TRIGGER_1))
{
SetCameraZoomFactor((Vector2){ 0.0f, -1.0f });
} else {
SetCameraZoomFactor((Vector2){ 0.0f, 0.0f });
}
} break;
case CAMERA_ORBITAL: // Camera just orbits around target, only zoom allowed
{
CAMERA.angle.x += CAMERA_ORBITAL_SPEED*GetFrameTime(); // Camera orbit angle
CAMERA.targetDistance -= (zoomFactor*CAMERA_MOUSE_SCROLL_SENSITIVITY); // Camera zoom
// Camera distance clamp
if (CAMERA.targetDistance < CAMERA_THIRD_PERSON_DISTANCE_CLAMP) CAMERA.targetDistance = CAMERA_THIRD_PERSON_DISTANCE_CLAMP;
// Update camera position with changes
camera->position.x = sinf(CAMERA.angle.x)*CAMERA.targetDistance*cosf(CAMERA.angle.y) + camera->target.x;
camera->position.y = ((CAMERA.angle.y <= 0.0f)? 1 : -1)*sinf(CAMERA.angle.y)*CAMERA.targetDistance*sinf(CAMERA.angle.y) + camera->target.y;
camera->position.z = cosf(CAMERA.angle.x)*CAMERA.targetDistance*cosf(CAMERA.angle.y) + camera->target.z;
// L/R Bumpers to zoom out/in
SetCameraPrevZoomFactor((Vector2) { 0.0f, zoomFactor });
if (IsGamepadButtonDown(gamepad, GAMEPAD_BUTTON_RIGHT_TRIGGER_1))
{
SetCameraZoomFactor((Vector2){ 0.0f, 1.0f });
} else if (IsGamepadButtonDown(gamepad, GAMEPAD_BUTTON_LEFT_TRIGGER_1))
{
SetCameraZoomFactor((Vector2){ 0.0f, -1.0f });
} else {
SetCameraZoomFactor((Vector2){ 0.0f, 0.0f });
}
} break;
case CAMERA_FIRST_PERSON: // Camera moves as in a first-person game, controls are configurable
{
camera->position.x += (sinf(camera->angle.x)*direction[MOVE_BACK] -
sinf(camera->angle.x)*direction[MOVE_FRONT] -
cosf(camera->angle.x)*direction[MOVE_LEFT] +
cosf(camera->angle.x)*direction[MOVE_RIGHT])*PLAYER_MOVEMENT_SENSITIVITY*GetFrameTime();
camera->position.y += (sinf(camera->angle.y)*direction[MOVE_FRONT] -
sinf(CAMERA.angle.y)*direction[MOVE_BACK]) *PLAYER_MOVEMENT_SENSITIVITY*GetFrameTime();
// 1.0f*direction[MOVE_UP] - 1.0f*direction[MOVE_DOWN])*PLAYER_MOVEMENT_SENSITIVITY*GetFrameTime();
camera->position.z += (cosf(camera->angle.x)*direction[MOVE_BACK] -
cosf(camera->angle.x)*direction[MOVE_FRONT] +
sinf(camera->angle.x)*direction[MOVE_LEFT] -
sinf(camera->angle.x)*direction[MOVE_RIGHT])*PLAYER_MOVEMENT_SENSITIVITY*GetFrameTime();
// Camera orientation calculation
camera->angle.x += rightStickDelta.x*CAMERA_MOUSE_MOVE_SENSITIVITY*GetFrameTime();
camera->angle.y += GetGamepadYAxisInverted(gamepad)*rightStickDelta.y*CAMERA_MOUSE_MOVE_SENSITIVITY*GetFrameTime();
// Angle clamp
if (camera->angle.y > CAMERA_FIRST_PERSON_MIN_CLAMP*DEG2RAD) camera->angle.y = CAMERA_FIRST_PERSON_MIN_CLAMP*DEG2RAD;
else if (camera->angle.y < CAMERA_FIRST_PERSON_MAX_CLAMP*DEG2RAD) camera->angle.y = CAMERA_FIRST_PERSON_MAX_CLAMP*DEG2RAD;
// Calculate translation matrix
Matrix matTranslation = { 1.0f, 0.0f, 0.0f, 0.0f,
0.0f, 1.0f, 0.0f, 0.0f,
0.0f, 0.0f, 1.0f, (CAMERA.targetDistance/CAMERA_FREE_PANNING_DIVIDER),
0.0f, 0.0f, 0.0f, 1.0f };
// Calculate rotation matrix
Matrix matRotation = { 1.0f, 0.0f, 0.0f, 0.0f,
0.0f, 1.0f, 0.0f, 0.0f,
0.0f, 0.0f, 1.0f, 0.0f,
0.0f, 0.0f, 0.0f, 1.0f };
float cosz = cosf(0.0f);
float sinz = sinf(0.0f);
float cosy = cosf(-(PI*2 - camera->angle.x));
float siny = sinf(-(PI*2 - camera->angle.x));
float cosx = cosf(-(PI*2 - camera->angle.y));
float sinx = sinf(-(PI*2 - camera->angle.y));
matRotation.m0 = cosz*cosy;
matRotation.m4 = (cosz*siny*sinx) - (sinz*cosx);
matRotation.m8 = (cosz*siny*cosx) + (sinz*sinx);
matRotation.m1 = sinz*cosy;
matRotation.m5 = (sinz*siny*sinx) + (cosz*cosx);
matRotation.m9 = (sinz*siny*cosx) - (cosz*sinx);
matRotation.m2 = -siny;
matRotation.m6 = cosy*sinx;
matRotation.m10= cosy*cosx;
// Multiply translation and rotation matrices
Matrix matTransform = { 0 };
matTransform.m0 = matTranslation.m0*matRotation.m0 + matTranslation.m1*matRotation.m4 + matTranslation.m2*matRotation.m8 + matTranslation.m3*matRotation.m12;
matTransform.m1 = matTranslation.m0*matRotation.m1 + matTranslation.m1*matRotation.m5 + matTranslation.m2*matRotation.m9 + matTranslation.m3*matRotation.m13;
matTransform.m2 = matTranslation.m0*matRotation.m2 + matTranslation.m1*matRotation.m6 + matTranslation.m2*matRotation.m10 + matTranslation.m3*matRotation.m14;
matTransform.m3 = matTranslation.m0*matRotation.m3 + matTranslation.m1*matRotation.m7 + matTranslation.m2*matRotation.m11 + matTranslation.m3*matRotation.m15;
matTransform.m4 = matTranslation.m4*matRotation.m0 + matTranslation.m5*matRotation.m4 + matTranslation.m6*matRotation.m8 + matTranslation.m7*matRotation.m12;
matTransform.m5 = matTranslation.m4*matRotation.m1 + matTranslation.m5*matRotation.m5 + matTranslation.m6*matRotation.m9 + matTranslation.m7*matRotation.m13;
matTransform.m6 = matTranslation.m4*matRotation.m2 + matTranslation.m5*matRotation.m6 + matTranslation.m6*matRotation.m10 + matTranslation.m7*matRotation.m14;
matTransform.m7 = matTranslation.m4*matRotation.m3 + matTranslation.m5*matRotation.m7 + matTranslation.m6*matRotation.m11 + matTranslation.m7*matRotation.m15;
matTransform.m8 = matTranslation.m8*matRotation.m0 + matTranslation.m9*matRotation.m4 + matTranslation.m10*matRotation.m8 + matTranslation.m11*matRotation.m12;
matTransform.m9 = matTranslation.m8*matRotation.m1 + matTranslation.m9*matRotation.m5 + matTranslation.m10*matRotation.m9 + matTranslation.m11*matRotation.m13;
matTransform.m10 = matTranslation.m8*matRotation.m2 + matTranslation.m9*matRotation.m6 + matTranslation.m10*matRotation.m10 + matTranslation.m11*matRotation.m14;
matTransform.m11 = matTranslation.m8*matRotation.m3 + matTranslation.m9*matRotation.m7 + matTranslation.m10*matRotation.m11 + matTranslation.m11*matRotation.m15;
matTransform.m12 = matTranslation.m12*matRotation.m0 + matTranslation.m13*matRotation.m4 + matTranslation.m14*matRotation.m8 + matTranslation.m15*matRotation.m12;
matTransform.m13 = matTranslation.m12*matRotation.m1 + matTranslation.m13*matRotation.m5 + matTranslation.m14*matRotation.m9 + matTranslation.m15*matRotation.m13;
matTransform.m14 = matTranslation.m12*matRotation.m2 + matTranslation.m13*matRotation.m6 + matTranslation.m14*matRotation.m10 + matTranslation.m15*matRotation.m14;
matTransform.m15 = matTranslation.m12*matRotation.m3 + matTranslation.m13*matRotation.m7 + matTranslation.m14*matRotation.m11 + matTranslation.m15*matRotation.m15;
camera->target.x = camera->position.x - matTransform.m12;
camera->target.y = camera->position.y - matTransform.m13;
camera->target.z = camera->position.z - matTransform.m14;
// Camera position update
// NOTE: On CAMERA_FIRST_PERSON player Y-movement is limited to player 'eyes position'
camera->position.y = CAMERA.playerEyesPosition;
// Camera swinging (y-movement), only when walking (some key pressed)
for (int i = 0; i < MAX_GAMEPADS; i++) {if (direction[i]){ swingCounter[gamepad] += GetFrameTime(); break; }}
camera->position.y -= sinf(2*PI*CAMERA_FIRST_PERSON_STEP_FREQUENCY*swingCounter[gamepad])*CAMERA_FIRST_PERSON_SWINGING_DELTA;
// Camera waiving (xz-movement), only when walking (some key pressed)
camera->up.x = sinf(2*PI*CAMERA_FIRST_PERSON_STEP_FREQUENCY*swingCounter[gamepad])*CAMERA_FIRST_PERSON_TILTING_DELTA;
camera->up.z = -sinf(2*PI*CAMERA_FIRST_PERSON_STEP_FREQUENCY*swingCounter[gamepad])*CAMERA_FIRST_PERSON_TILTING_DELTA;
} break;
case CAMERA_THIRD_PERSON: // Camera moves as in a third-person game, following target at a distance, controls are configurable
{
camera->position.x += (sinf(CAMERA.angle.x)*direction[MOVE_BACK] -
sinf(CAMERA.angle.x)*direction[MOVE_FRONT] -
cosf(CAMERA.angle.x)*direction[MOVE_LEFT] +
cosf(CAMERA.angle.x)*direction[MOVE_RIGHT])*PLAYER_MOVEMENT_SENSITIVITY*GetFrameTime();
camera->position.y += (sinf(CAMERA.angle.y)*direction[MOVE_FRONT] -
sinf(CAMERA.angle.y)*direction[MOVE_BACK] +
1.0f*direction[MOVE_UP] - 1.0f*direction[MOVE_DOWN])*PLAYER_MOVEMENT_SENSITIVITY*GetFrameTime();
camera->position.z += (cosf(CAMERA.angle.x)*direction[MOVE_BACK] -
cosf(CAMERA.angle.x)*direction[MOVE_FRONT] +
sinf(CAMERA.angle.x)*direction[MOVE_LEFT] -
sinf(CAMERA.angle.x)*direction[MOVE_RIGHT])*PLAYER_MOVEMENT_SENSITIVITY*GetFrameTime();
// Camera orientation calculation
CAMERA.angle.x += (leftStickDelta.x*-CAMERA_MOUSE_MOVE_SENSITIVITY);
CAMERA.angle.y += (leftStickDelta.y*-CAMERA_MOUSE_MOVE_SENSITIVITY);
// Angle clamp
if (CAMERA.angle.y > CAMERA_THIRD_PERSON_MIN_CLAMP*DEG2RAD) CAMERA.angle.y = CAMERA_THIRD_PERSON_MIN_CLAMP*DEG2RAD;
else if (CAMERA.angle.y < CAMERA_THIRD_PERSON_MAX_CLAMP*DEG2RAD) CAMERA.angle.y = CAMERA_THIRD_PERSON_MAX_CLAMP*DEG2RAD;
// Camera zoom
CAMERA.targetDistance -= (zoomFactor*CAMERA_MOUSE_SCROLL_SENSITIVITY);
// Camera distance clamp
if (CAMERA.targetDistance < CAMERA_THIRD_PERSON_DISTANCE_CLAMP) CAMERA.targetDistance = CAMERA_THIRD_PERSON_DISTANCE_CLAMP;
camera->position.x = sinf(CAMERA.angle.x)*CAMERA.targetDistance*cosf(CAMERA.angle.y) + camera->target.x;
if (CAMERA.angle.y <= 0.0f) camera->position.y = sinf(CAMERA.angle.y)*CAMERA.targetDistance*sinf(CAMERA.angle.y) + camera->target.y;
else camera->position.y = -sinf(CAMERA.angle.y)*CAMERA.targetDistance*sinf(CAMERA.angle.y) + camera->target.y;
camera->position.z = cosf(CAMERA.angle.x)*CAMERA.targetDistance*cosf(CAMERA.angle.y) + camera->target.z;
} break;
case CAMERA_CUSTOM: break;
default: break;
}
}
// Set camera pan key to combine with mouse movement (free camera)
void SetCameraPanControl(int keyPan) { CAMERA.panControl = keyPan; }

View file

@ -491,6 +491,8 @@ typedef struct CoreData {
Vector2 position[MAX_TOUCH_POINTS]; // Touch position on screen
char currentTouchState[MAX_TOUCH_POINTS]; // Registers current touch state
char previousTouchState[MAX_TOUCH_POINTS]; // Registers previous touch state
// PLATFORM_NX
long int deltaTime[MAX_TOUCH_POINTS];
} Touch;
struct {
int lastButtonPressed; // Register last gamepad button pressed
@ -506,6 +508,8 @@ typedef struct CoreData {
#endif
#if defined(PLATFORM_NX)
PadState nxPad[MAX_GAMEPADS]; // Gamepad state holder
HidNpadStyleTag nxPadStyle[MAX_GAMEPADS];
float yInverted[MAX_GAMEPADS]; // True -1.f False 1.f
#endif
} Gamepad;
} Input;
@ -540,6 +544,10 @@ static bool gifRecording = false; // GIF recording state
static MsfGifState gifState = { 0 }; // MSGIF context state
#endif
#if defined(PLATFORM_NX)
s32 prev_touchcount = 0;
#endif
#if defined(SUPPORT_EVENTS_AUTOMATION)
#define MAX_CODE_AUTOMATION_EVENTS 16384
@ -917,7 +925,12 @@ void InitWindow(int width, int height, const char *title)
// Configure our supported input layout
padConfigureInput(MAX_GAMEPADS, HidNpadStyleSet_NpadStandard);
// Initialize the gamepads
padInitializeDefault(&CORE.Input.Gamepad.nxPad[0]);
for (int i = 0; i < MAX_GAMEPADS; i++)
{
padInitialize(&CORE.Input.Gamepad.nxPad[i], i);
}
hidInitializeTouchScreen();
#endif
#if defined(PLATFORM_WEB)
@ -3614,6 +3627,25 @@ const char *GetGamepadName(int gamepad)
#endif
#if defined(PLATFORM_WEB)
return CORE.Input.Gamepad.name[gamepad];
#endif
#if defined(PLATFORM_NX)
int type = CORE.Input.Gamepad.nxPadStyle[gamepad];
switch(type) {
case HidNpadStyleTag_NpadFullKey: return "Nintendo Switch Pro Controller";
case HidNpadStyleTag_NpadHandheld: return "Handheld Joy-Con controller";
case HidNpadStyleTag_NpadJoyDual: return "Dual Joy-Con controller";
case HidNpadStyleTag_NpadJoyLeft: return "Single Joy-Con left controller";
case HidNpadStyleTag_NpadJoyRight: return "Single Joy-Con right controller";
case HidNpadStyleTag_NpadGc: return "GameCube controller";
case HidNpadStyleTag_NpadPalma: return "Poké Ball Plus controller";
case HidNpadStyleTag_NpadLark: return "NES/Famicom controller";
case HidNpadStyleTag_NpadHandheldLark: return "Handheld NES/Famicom controller";
case HidNpadStyleTag_NpadLucia: return "SNES controller";
case HidNpadStyleTag_NpadLagon: return "N64 controller";
case HidNpadStyleTag_NpadLager: return "Sega Genesis controller";
case HidNpadStyleTag_NpadSystemExt: return "Generic external controller";
default: return "Generic controller";
}
#endif
return NULL;
}
@ -3641,6 +3673,21 @@ float GetGamepadAxisMovement(int gamepad, int axis)
return value;
}
#if defined(PLATFORM_NX)
void SetGamepadYAxisInverted(int gamepad, float yInverted)
{
if (yInverted == -1.0f || yInverted == 1.0f)
{
CORE.Input.Gamepad.yInverted[gamepad] = yInverted;
}
}
float GetGamepadYAxisInverted(int gamepad)
{
return CORE.Input.Gamepad.yInverted[gamepad];
}
#endif
// Check if a gamepad button has been pressed once
bool IsGamepadButtonPressed(int gamepad, int button)
{
@ -3823,7 +3870,7 @@ float GetMouseWheelMove(void)
{
float result = 0.0f;
#if !defined(PLATFORM_ANDROID)
#if !defined(PLATFORM_ANDROID) || !defined(PLATFORM_NX)
if (fabsf(CORE.Input.Mouse.currentWheelMove.x) > fabsf(CORE.Input.Mouse.currentWheelMove.y)) result = (float)CORE.Input.Mouse.currentWheelMove.x;
else result = (float)CORE.Input.Mouse.currentWheelMove.y;
#endif
@ -3831,6 +3878,17 @@ float GetMouseWheelMove(void)
return result;
}
#if defined(PLATFORM_NX)
void SetCameraZoomFactor(Vector2 zoomFactor)
{
CORE.Input.Mouse.currentWheelMove = zoomFactor;
}
void SetCameraPrevZoomFactor(Vector2 previousZoomFactor)
{
CORE.Input.Mouse.previousWheelMove = previousZoomFactor;
}
#endif
// Get mouse wheel movement X/Y as a vector
Vector2 GetMouseWheelMoveV(void)
{
@ -3859,7 +3917,7 @@ void SetMouseCursor(int cursor)
// Get touch position X for touch point 0 (relative to screen size)
int GetTouchX(void)
{
#if defined(PLATFORM_ANDROID) || defined(PLATFORM_WEB)
#if defined(PLATFORM_ANDROID) || defined(PLATFORM_WEB) || defined(PLATFORM_NX)
return (int)CORE.Input.Touch.position[0].x;
#else // PLATFORM_DESKTOP, PLATFORM_RPI, PLATFORM_DRM
return GetMouseX();
@ -3869,7 +3927,7 @@ int GetTouchX(void)
// Get touch position Y for touch point 0 (relative to screen size)
int GetTouchY(void)
{
#if defined(PLATFORM_ANDROID) || defined(PLATFORM_WEB)
#if defined(PLATFORM_ANDROID) || defined(PLATFORM_WEB) || defined(PLATFORM_NX)
return (int)CORE.Input.Touch.position[0].y;
#else // PLATFORM_DESKTOP, PLATFORM_RPI, PLATFORM_DRM
return GetMouseY();
@ -3888,7 +3946,7 @@ Vector2 GetTouchPosition(int index)
// https://docs.microsoft.com/en-us/windows/win32/wintouch/getting-started-with-multi-touch-messages
if (index == 0) position = GetMousePosition();
#endif
#if defined(PLATFORM_ANDROID) || defined(PLATFORM_WEB) || defined(PLATFORM_RPI) || defined(PLATFORM_DRM)
#if defined(PLATFORM_ANDROID) || defined(PLATFORM_WEB) || defined(PLATFORM_RPI) || defined(PLATFORM_DRM) || defined(PLATFORM_NX)
if (index < MAX_TOUCH_POINTS) position = CORE.Input.Touch.position[index];
else TRACELOG(LOG_WARNING, "INPUT: Required touch point out of range (Max touch points: %i)", MAX_TOUCH_POINTS);
#endif
@ -5158,202 +5216,253 @@ void PollInputEvents(void)
#endif
#if defined(PLATFORM_NX)
int nxGamepadIndex = 0;
// Scan the gamepad. This should be done once for each frame
padUpdate(&CORE.Input.Gamepad.nxPad[nxGamepadIndex]);
CORE.Input.Gamepad.ready[nxGamepadIndex] = padIsConnected(&CORE.Input.Gamepad.nxPad[nxGamepadIndex]);
if (CORE.Input.Gamepad.ready[nxGamepadIndex]) {
// Returns the set of buttons that are currently pressed
u64 kHeld = padGetButtons(&CORE.Input.Gamepad.nxPad[nxGamepadIndex]);
u64 kButton;
for (int k = 0; k < MAX_GAMEPAD_BUTTONS; k++)
/**
* Touch screen
*/
HidTouchScreenState state = {0};
if (hidGetTouchScreenStates(&state, 1)) {
if (state.count != prev_touchcount)
{
// Register previous gamepad states
CORE.Input.Gamepad.previousButtonState[nxGamepadIndex][k] = CORE.Input.Gamepad.currentButtonState[nxGamepadIndex][k];
// Check digital buttons
kButton = 0;
switch (k)
{
case GAMEPAD_BUTTON_LEFT_FACE_UP: kButton = HidNpadButton_Up; break;
case GAMEPAD_BUTTON_LEFT_FACE_RIGHT: kButton = HidNpadButton_Right; break;
case GAMEPAD_BUTTON_LEFT_FACE_DOWN: kButton = HidNpadButton_Down; break;
case GAMEPAD_BUTTON_LEFT_FACE_LEFT: kButton = HidNpadButton_Left; break;
case GAMEPAD_BUTTON_RIGHT_FACE_UP: kButton = HidNpadButton_X; break;
case GAMEPAD_BUTTON_RIGHT_FACE_RIGHT: kButton = HidNpadButton_A; break;
case GAMEPAD_BUTTON_RIGHT_FACE_DOWN: kButton = HidNpadButton_B; break;
case GAMEPAD_BUTTON_RIGHT_FACE_LEFT: kButton = HidNpadButton_Y; break;
case GAMEPAD_BUTTON_LEFT_TRIGGER_1: kButton = HidNpadButton_L; break;
case GAMEPAD_BUTTON_LEFT_TRIGGER_2: kButton = HidNpadButton_ZL; break;
case GAMEPAD_BUTTON_RIGHT_TRIGGER_1: kButton = HidNpadButton_R; break;
case GAMEPAD_BUTTON_RIGHT_TRIGGER_2: kButton = HidNpadButton_ZR; break;
case GAMEPAD_BUTTON_MIDDLE_LEFT: kButton = HidNpadButton_Minus; break;
case GAMEPAD_BUTTON_MIDDLE_RIGHT: kButton = HidNpadButton_Plus; break;
case GAMEPAD_BUTTON_LEFT_THUMB: kButton = HidNpadButton_StickL; break;
case GAMEPAD_BUTTON_RIGHT_THUMB: kButton = HidNpadButton_StickR; break;
}
if (kHeld & kButton) {
CORE.Input.Gamepad.currentButtonState[nxGamepadIndex][k] = 1;
CORE.Input.Gamepad.lastButtonPressed = k;
} else {
CORE.Input.Gamepad.currentButtonState[nxGamepadIndex][k] = 0;
}
prev_touchcount = state.count;
}
for(int i=0; i<state.count; i++)
{
CORE.Input.Touch.position[i].x = state.touches[i].x;
CORE.Input.Touch.position[i].y = state.touches[i].y;
CORE.Input.Touch.pointId[i] = state.touches[i].finger_id;
// Check analogic axis and buttons
HidAnalogStickState kAxisL = padGetStickPos(&CORE.Input.Gamepad.nxPad[nxGamepadIndex], 0);
HidAnalogStickState kAxisR = padGetStickPos(&CORE.Input.Gamepad.nxPad[nxGamepadIndex], 1);
CORE.Input.Touch.deltaTime[i] = state.touches[i].delta_time;
}
CORE.Input.Touch.pointCount = state.count;
}
CORE.Input.Gamepad.axisState[nxGamepadIndex][GAMEPAD_AXIS_LEFT_X] = (float)kAxisL.x / 32767.0f;
CORE.Input.Gamepad.axisState[nxGamepadIndex][GAMEPAD_AXIS_LEFT_Y] = (float)kAxisL.y / 32767.0f;
CORE.Input.Gamepad.axisState[nxGamepadIndex][GAMEPAD_AXIS_RIGHT_X] = (float)kAxisR.x / 32767.0f;
CORE.Input.Gamepad.axisState[nxGamepadIndex][GAMEPAD_AXIS_RIGHT_Y] = (float)kAxisR.y / 32767.0f;
CORE.Input.Gamepad.axisState[nxGamepadIndex][GAMEPAD_AXIS_LEFT_TRIGGER] = (kHeld & HidNpadButton_ZL) ? 1.0f : 0.0f;
CORE.Input.Gamepad.axisState[nxGamepadIndex][GAMEPAD_AXIS_RIGHT_TRIGGER] = (kHeld & HidNpadButton_ZR) ? 1.0f : 0.0f;
/**
* Gamepad
*/
for (int nxGamepadIndex = 0; nxGamepadIndex < MAX_GAMEPADS; nxGamepadIndex++)
{
// Scan the gamepad. This should be done once for each frame
padUpdate(&CORE.Input.Gamepad.nxPad[nxGamepadIndex]);
CORE.Input.Gamepad.ready[nxGamepadIndex] = padIsConnected(&CORE.Input.Gamepad.nxPad[nxGamepadIndex]);
if (CORE.Input.Gamepad.ready[nxGamepadIndex]) {
CORE.Input.Gamepad.nxPadStyle[nxGamepadIndex] = hidGetNpadStyleSet(nxGamepadIndex);
// Returns the set of buttons that are currently pressed
u64 kHeld = padGetButtons(&CORE.Input.Gamepad.nxPad[nxGamepadIndex]);
u64 kButton;
for (int k = 0; k < MAX_GAMEPAD_BUTTONS; k++)
{
// Register previous gamepad states
CORE.Input.Gamepad.previousButtonState[nxGamepadIndex][k] = CORE.Input.Gamepad.currentButtonState[nxGamepadIndex][k];
// Check digital buttons
kButton = 0;
switch (k)
{
case GAMEPAD_BUTTON_LEFT_FACE_UP: kButton = HidNpadButton_Up; break;
case GAMEPAD_BUTTON_LEFT_FACE_RIGHT: kButton = HidNpadButton_Right; break;
case GAMEPAD_BUTTON_LEFT_FACE_DOWN: kButton = HidNpadButton_Down; break;
case GAMEPAD_BUTTON_LEFT_FACE_LEFT: kButton = HidNpadButton_Left; break;
case GAMEPAD_BUTTON_RIGHT_FACE_UP: kButton = HidNpadButton_X; break;
case GAMEPAD_BUTTON_RIGHT_FACE_RIGHT: kButton = HidNpadButton_A; break;
case GAMEPAD_BUTTON_RIGHT_FACE_DOWN: kButton = HidNpadButton_B; break;
case GAMEPAD_BUTTON_RIGHT_FACE_LEFT: kButton = HidNpadButton_Y; break;
case GAMEPAD_BUTTON_LEFT_TRIGGER_1: kButton = HidNpadButton_L; break;
case GAMEPAD_BUTTON_LEFT_TRIGGER_2: kButton = HidNpadButton_ZL; break;
case GAMEPAD_BUTTON_RIGHT_TRIGGER_1: kButton = HidNpadButton_R; break;
case GAMEPAD_BUTTON_RIGHT_TRIGGER_2: kButton = HidNpadButton_ZR; break;
case GAMEPAD_BUTTON_MIDDLE_LEFT: kButton = HidNpadButton_Minus; break;
case GAMEPAD_BUTTON_MIDDLE_RIGHT: kButton = HidNpadButton_Plus; break;
case GAMEPAD_BUTTON_LEFT_THUMB: kButton = HidNpadButton_StickL; break;
case GAMEPAD_BUTTON_RIGHT_THUMB: kButton = HidNpadButton_StickR; break;
}
if (kHeld & kButton) {
CORE.Input.Gamepad.currentButtonState[nxGamepadIndex][k] = 1;
CORE.Input.Gamepad.lastButtonPressed = k;
} else {
CORE.Input.Gamepad.currentButtonState[nxGamepadIndex][k] = 0;
}
}
// Check analogic axis and buttons
HidAnalogStickState kAxisL = padGetStickPos(&CORE.Input.Gamepad.nxPad[nxGamepadIndex], 0);
HidAnalogStickState kAxisR = padGetStickPos(&CORE.Input.Gamepad.nxPad[nxGamepadIndex], 1);
CORE.Input.Gamepad.axisState[nxGamepadIndex][GAMEPAD_AXIS_LEFT_X] = (float)kAxisL.x / 32767.0f;
CORE.Input.Gamepad.axisState[nxGamepadIndex][GAMEPAD_AXIS_LEFT_Y] = (float)kAxisL.y / 32767.0f;
CORE.Input.Gamepad.axisState[nxGamepadIndex][GAMEPAD_AXIS_RIGHT_X] = (float)kAxisR.x / 32767.0f;
CORE.Input.Gamepad.axisState[nxGamepadIndex][GAMEPAD_AXIS_RIGHT_Y] = (float)kAxisR.y / 32767.0f;
CORE.Input.Gamepad.axisState[nxGamepadIndex][GAMEPAD_AXIS_LEFT_TRIGGER] = (kHeld & HidNpadButton_ZL) ? 1.0f : 0.0f;
CORE.Input.Gamepad.axisState[nxGamepadIndex][GAMEPAD_AXIS_RIGHT_TRIGGER] = (kHeld & HidNpadButton_ZR) ? 1.0f : 0.0f;
#if defined(ENABLE_DEV_EXIT)
if (kHeld & HidNpadButton_Plus && kHeld & HidNpadButton_Minus)
{
CORE.Window.shouldClose = true;
}
#endif
#if defined(NX_SUPPORT_GAMEPAD_EMULATION)
CORE.Input.Keyboard.previousKeyState[KEY_RIGHT] = CORE.Input.Keyboard.currentKeyState[KEY_RIGHT];
CORE.Input.Keyboard.previousKeyState[KEY_D] = CORE.Input.Keyboard.currentKeyState[KEY_D];
if (kHeld & HidNpadButton_Right || kHeld & HidNpadButton_StickLRight) {
CORE.Input.Keyboard.currentKeyState[KEY_RIGHT] = 1;
CORE.Input.Keyboard.currentKeyState[KEY_D] = 1;
} else {
CORE.Input.Keyboard.currentKeyState[KEY_RIGHT] = 0;
CORE.Input.Keyboard.currentKeyState[KEY_D] = 0;
}
CORE.Input.Keyboard.previousKeyState[KEY_LEFT] = CORE.Input.Keyboard.currentKeyState[KEY_LEFT];
CORE.Input.Keyboard.previousKeyState[KEY_A] = CORE.Input.Keyboard.currentKeyState[KEY_A];
if (kHeld & HidNpadButton_Left || kHeld & HidNpadButton_StickLLeft) {
CORE.Input.Keyboard.currentKeyState[KEY_LEFT] = 1;
CORE.Input.Keyboard.currentKeyState[KEY_A] = 1;
} else {
CORE.Input.Keyboard.currentKeyState[KEY_LEFT] = 0;
CORE.Input.Keyboard.currentKeyState[KEY_A] = 0;
}
CORE.Input.Keyboard.previousKeyState[KEY_DOWN] = CORE.Input.Keyboard.currentKeyState[KEY_DOWN];
CORE.Input.Keyboard.previousKeyState[KEY_S] = CORE.Input.Keyboard.currentKeyState[KEY_S];
if (kHeld & HidNpadButton_Down || kHeld & HidNpadButton_StickLDown) {
CORE.Input.Keyboard.currentKeyState[KEY_DOWN] = 1;
CORE.Input.Keyboard.currentKeyState[KEY_S] = 1;
} else {
CORE.Input.Keyboard.currentKeyState[KEY_DOWN] = 0;
CORE.Input.Keyboard.currentKeyState[KEY_S] = 0;
}
CORE.Input.Keyboard.previousKeyState[KEY_UP] = CORE.Input.Keyboard.currentKeyState[KEY_UP];
CORE.Input.Keyboard.previousKeyState[KEY_W] = CORE.Input.Keyboard.currentKeyState[KEY_W];
if (kHeld & HidNpadButton_Up || kHeld & HidNpadButton_StickLUp) {
CORE.Input.Keyboard.currentKeyState[KEY_UP] = 1;
CORE.Input.Keyboard.currentKeyState[KEY_W] = 1;
} else {
CORE.Input.Keyboard.currentKeyState[KEY_UP] = 0;
CORE.Input.Keyboard.currentKeyState[KEY_W] = 0;
}
CORE.Input.Keyboard.previousKeyState[KEY_Q] = CORE.Input.Keyboard.currentKeyState[KEY_Q];
if (kHeld & HidNpadButton_Y) {
CORE.Input.Keyboard.currentKeyState[KEY_Q] = 1;
} else {
CORE.Input.Keyboard.currentKeyState[KEY_Q] = 0;
}
CORE.Input.Keyboard.previousKeyState[KEY_E] = CORE.Input.Keyboard.currentKeyState[KEY_E];
if (kHeld & HidNpadButton_A) {
CORE.Input.Keyboard.currentKeyState[KEY_E] = 1;
} else {
CORE.Input.Keyboard.currentKeyState[KEY_E] = 0;
}
CORE.Input.Keyboard.previousKeyState[KEY_R] = CORE.Input.Keyboard.currentKeyState[KEY_R];
if (kHeld & HidNpadButton_X) {
CORE.Input.Keyboard.currentKeyState[KEY_R] = 1;
} else {
CORE.Input.Keyboard.currentKeyState[KEY_R] = 0;
}
CORE.Input.Keyboard.previousKeyState[KEY_F] = CORE.Input.Keyboard.currentKeyState[KEY_F];
if (kHeld & HidNpadButton_B) {
CORE.Input.Keyboard.currentKeyState[KEY_F] = 1;
} else {
CORE.Input.Keyboard.currentKeyState[KEY_F] = 0;
}
CORE.Input.Keyboard.previousKeyState[KEY_ENTER] = CORE.Input.Keyboard.currentKeyState[KEY_ENTER];
CORE.Input.Keyboard.previousKeyState[KEY_SPACE] = CORE.Input.Keyboard.currentKeyState[KEY_SPACE];
CORE.Input.Keyboard.previousKeyState[KEY_ESCAPE] = CORE.Input.Keyboard.currentKeyState[KEY_ESCAPE];
if (kHeld & HidNpadButton_Plus && kHeld & HidNpadButton_Minus) {
CORE.Input.Keyboard.currentKeyState[KEY_ENTER] = 0;
CORE.Input.Keyboard.currentKeyState[KEY_SPACE] = 0;
CORE.Input.Keyboard.currentKeyState[KEY_ESCAPE] = 1;
} else {
if (kHeld & HidNpadButton_Plus) {
CORE.Input.Keyboard.currentKeyState[KEY_ENTER] = 1;
// Move Right (D key or right arrow)
CORE.Input.Keyboard.previousKeyState[KEY_RIGHT] = CORE.Input.Keyboard.currentKeyState[KEY_RIGHT];
CORE.Input.Keyboard.previousKeyState[KEY_D] = CORE.Input.Keyboard.currentKeyState[KEY_D];
if (kHeld & HidNpadButton_Right || kHeld & HidNpadButton_StickLRight) {
CORE.Input.Keyboard.currentKeyState[KEY_RIGHT] = 1;
CORE.Input.Keyboard.currentKeyState[KEY_D] = 1;
} else {
CORE.Input.Keyboard.currentKeyState[KEY_RIGHT] = 0;
CORE.Input.Keyboard.currentKeyState[KEY_D] = 0;
}
// Move Left (A key or left arrow)
CORE.Input.Keyboard.previousKeyState[KEY_LEFT] = CORE.Input.Keyboard.currentKeyState[KEY_LEFT];
CORE.Input.Keyboard.previousKeyState[KEY_A] = CORE.Input.Keyboard.currentKeyState[KEY_A];
if (kHeld & HidNpadButton_Left || kHeld & HidNpadButton_StickLLeft) {
CORE.Input.Keyboard.currentKeyState[KEY_LEFT] = 1;
CORE.Input.Keyboard.currentKeyState[KEY_A] = 1;
} else {
CORE.Input.Keyboard.currentKeyState[KEY_LEFT] = 0;
CORE.Input.Keyboard.currentKeyState[KEY_A] = 0;
}
// Move down (S key or down arrow)
CORE.Input.Keyboard.previousKeyState[KEY_DOWN] = CORE.Input.Keyboard.currentKeyState[KEY_DOWN];
CORE.Input.Keyboard.previousKeyState[KEY_S] = CORE.Input.Keyboard.currentKeyState[KEY_S];
if (kHeld & HidNpadButton_Down || kHeld & HidNpadButton_StickLDown) {
CORE.Input.Keyboard.currentKeyState[KEY_DOWN] = 1;
CORE.Input.Keyboard.currentKeyState[KEY_S] = 1;
} else {
CORE.Input.Keyboard.currentKeyState[KEY_DOWN] = 0;
CORE.Input.Keyboard.currentKeyState[KEY_S] = 0;
}
// Move up (W key or up arrow)
CORE.Input.Keyboard.previousKeyState[KEY_UP] = CORE.Input.Keyboard.currentKeyState[KEY_UP];
CORE.Input.Keyboard.previousKeyState[KEY_W] = CORE.Input.Keyboard.currentKeyState[KEY_W];
if (kHeld & HidNpadButton_Up || kHeld & HidNpadButton_StickLUp) {
CORE.Input.Keyboard.currentKeyState[KEY_UP] = 1;
CORE.Input.Keyboard.currentKeyState[KEY_W] = 1;
} else {
CORE.Input.Keyboard.currentKeyState[KEY_UP] = 0;
CORE.Input.Keyboard.currentKeyState[KEY_W] = 0;
}
// Gamepad Y (Q key)
CORE.Input.Keyboard.previousKeyState[KEY_Q] = CORE.Input.Keyboard.currentKeyState[KEY_Q];
if (kHeld & HidNpadButton_Y) {
CORE.Input.Keyboard.currentKeyState[KEY_Q] = 1;
} else {
CORE.Input.Keyboard.currentKeyState[KEY_Q] = 0;
}
// Gamepad A (E key)
CORE.Input.Keyboard.previousKeyState[KEY_E] = CORE.Input.Keyboard.currentKeyState[KEY_E];
if (kHeld & HidNpadButton_A) {
CORE.Input.Keyboard.currentKeyState[KEY_E] = 1;
} else {
CORE.Input.Keyboard.currentKeyState[KEY_E] = 0;
}
// Gamepad X (R key)
CORE.Input.Keyboard.previousKeyState[KEY_R] = CORE.Input.Keyboard.currentKeyState[KEY_R];
if (kHeld & HidNpadButton_X) {
CORE.Input.Keyboard.currentKeyState[KEY_R] = 1;
} else {
CORE.Input.Keyboard.currentKeyState[KEY_R] = 0;
}
// Gamepad B (F key)
CORE.Input.Keyboard.previousKeyState[KEY_F] = CORE.Input.Keyboard.currentKeyState[KEY_F];
if (kHeld & HidNpadButton_B) {
CORE.Input.Keyboard.currentKeyState[KEY_F] = 1;
} else {
CORE.Input.Keyboard.currentKeyState[KEY_F] = 0;
}
// Gamepad + and - (Escape)
CORE.Input.Keyboard.previousKeyState[KEY_ENTER] = CORE.Input.Keyboard.currentKeyState[KEY_ENTER];
CORE.Input.Keyboard.previousKeyState[KEY_SPACE] = CORE.Input.Keyboard.currentKeyState[KEY_SPACE];
CORE.Input.Keyboard.previousKeyState[KEY_ESCAPE] = CORE.Input.Keyboard.currentKeyState[KEY_ESCAPE];
if (kHeld & HidNpadButton_Plus && kHeld & HidNpadButton_Minus) {
CORE.Input.Keyboard.currentKeyState[KEY_ENTER] = 0;
}
if (kHeld & HidNpadButton_Minus) {
CORE.Input.Keyboard.currentKeyState[KEY_SPACE] = 1;
} else {
CORE.Input.Keyboard.currentKeyState[KEY_SPACE] = 0;
CORE.Input.Keyboard.currentKeyState[KEY_ESCAPE] = 1;
} else {
if (kHeld & HidNpadButton_Plus) {
CORE.Input.Keyboard.currentKeyState[KEY_ENTER] = 1;
} else {
CORE.Input.Keyboard.currentKeyState[KEY_ENTER] = 0;
}
if (kHeld & HidNpadButton_Minus) {
CORE.Input.Keyboard.currentKeyState[KEY_SPACE] = 1;
} else {
CORE.Input.Keyboard.currentKeyState[KEY_SPACE] = 0;
}
}
}
CORE.Input.Keyboard.previousKeyState[KEY_LEFT_SHIFT] = CORE.Input.Keyboard.currentKeyState[KEY_LEFT_SHIFT];
if (kHeld & GAMEPAD_BUTTON_LEFT_THUMB) {
CORE.Input.Keyboard.currentKeyState[KEY_LEFT_SHIFT] = 1;
} else {
CORE.Input.Keyboard.currentKeyState[KEY_LEFT_SHIFT] = 0;
}
// Gamepad Left Thumb (shift)
CORE.Input.Keyboard.previousKeyState[KEY_LEFT_SHIFT] = CORE.Input.Keyboard.currentKeyState[KEY_LEFT_SHIFT];
if (kHeld & GAMEPAD_BUTTON_LEFT_THUMB) {
CORE.Input.Keyboard.currentKeyState[KEY_LEFT_SHIFT] = 1;
} else {
CORE.Input.Keyboard.currentKeyState[KEY_LEFT_SHIFT] = 0;
}
CORE.Input.Mouse.previousButtonState[MOUSE_BUTTON_LEFT] = CORE.Input.Mouse.currentButtonState[MOUSE_BUTTON_LEFT];
if (kHeld & HidNpadButton_ZL) {
CORE.Input.Mouse.currentButtonState[MOUSE_BUTTON_RIGHT] = 1;
} else {
CORE.Input.Mouse.currentButtonState[MOUSE_BUTTON_RIGHT] = 0;
}
// Gamepad ZL (mouse right)
CORE.Input.Mouse.previousButtonState[MOUSE_BUTTON_LEFT] = CORE.Input.Mouse.currentButtonState[MOUSE_BUTTON_LEFT];
if (kHeld & HidNpadButton_ZL) {
CORE.Input.Mouse.currentButtonState[MOUSE_BUTTON_RIGHT] = 1;
} else {
CORE.Input.Mouse.currentButtonState[MOUSE_BUTTON_RIGHT] = 0;
}
CORE.Input.Mouse.previousButtonState[MOUSE_BUTTON_MIDDLE] = CORE.Input.Mouse.currentButtonState[MOUSE_BUTTON_MIDDLE];
if (kHeld & GAMEPAD_BUTTON_RIGHT_THUMB) {
CORE.Input.Mouse.currentButtonState[MOUSE_BUTTON_MIDDLE] = 1;
} else {
CORE.Input.Mouse.currentButtonState[MOUSE_BUTTON_MIDDLE] = 0;
}
// Gamepad Right Thumb (mouse middle)
CORE.Input.Mouse.previousButtonState[MOUSE_BUTTON_MIDDLE] = CORE.Input.Mouse.currentButtonState[MOUSE_BUTTON_MIDDLE];
if (kHeld & GAMEPAD_BUTTON_RIGHT_THUMB) {
CORE.Input.Mouse.currentButtonState[MOUSE_BUTTON_MIDDLE] = 1;
} else {
CORE.Input.Mouse.currentButtonState[MOUSE_BUTTON_MIDDLE] = 0;
}
CORE.Input.Mouse.previousButtonState[MOUSE_BUTTON_RIGHT] = CORE.Input.Mouse.currentButtonState[MOUSE_BUTTON_RIGHT];
if (kHeld & HidNpadButton_ZR) {
CORE.Input.Mouse.currentButtonState[MOUSE_BUTTON_LEFT] = 1;
} else {
CORE.Input.Mouse.currentButtonState[MOUSE_BUTTON_LEFT] = 0;
}
// Gamepad ZR (mouse left)
CORE.Input.Mouse.previousButtonState[MOUSE_BUTTON_RIGHT] = CORE.Input.Mouse.currentButtonState[MOUSE_BUTTON_RIGHT];
if (kHeld & HidNpadButton_ZR) {
CORE.Input.Mouse.currentButtonState[MOUSE_BUTTON_LEFT] = 1;
} else {
CORE.Input.Mouse.currentButtonState[MOUSE_BUTTON_LEFT] = 0;
}
CORE.Input.Mouse.previousWheelMove = CORE.Input.Mouse.currentWheelMove;
if (kHeld & HidNpadButton_L) {
CORE.Input.Mouse.currentWheelMove = (Vector2){ 0.0f, -1.0f };
} else if (kHeld & HidNpadButton_R) {
CORE.Input.Mouse.currentWheelMove = (Vector2){ 0.0f, 1.0f };
} else {
CORE.Input.Mouse.currentWheelMove = (Vector2){ 0.0f, 0.0f };
}
// Gamepad L/R Bumpers (mouse wheel)
CORE.Input.Mouse.previousWheelMove = CORE.Input.Mouse.currentWheelMove;
if (kHeld & HidNpadButton_L) {
CORE.Input.Mouse.currentWheelMove = (Vector2){ 0.0f, -1.0f };
} else if (kHeld & HidNpadButton_R) {
CORE.Input.Mouse.currentWheelMove = (Vector2){ 0.0f, 1.0f };
} else {
CORE.Input.Mouse.currentWheelMove = (Vector2){ 0.0f, 0.0f };
}
CORE.Input.Mouse.previousPosition.x = CORE.Input.Mouse.currentPosition.x;
CORE.Input.Mouse.previousPosition.y = CORE.Input.Mouse.currentPosition.y;
// Gamepad Axis (mouse position)
CORE.Input.Mouse.previousPosition.x = CORE.Input.Mouse.currentPosition.x;
CORE.Input.Mouse.previousPosition.y = CORE.Input.Mouse.currentPosition.y;
CORE.Input.Mouse.currentPosition.x += CORE.Input.Gamepad.axisState[nxGamepadIndex][GAMEPAD_AXIS_RIGHT_X] * 10;
CORE.Input.Mouse.currentPosition.y -= CORE.Input.Gamepad.axisState[nxGamepadIndex][GAMEPAD_AXIS_RIGHT_Y] * 10;
CORE.Input.Mouse.currentPosition.x += CORE.Input.Gamepad.axisState[nxGamepadIndex][GAMEPAD_AXIS_RIGHT_X] * 10;
CORE.Input.Mouse.currentPosition.y -= CORE.Input.Gamepad.axisState[nxGamepadIndex][GAMEPAD_AXIS_RIGHT_Y] * 10;
if (CORE.Input.Mouse.currentPosition.x < 0) CORE.Input.Mouse.currentPosition.x = 0;
else if (CORE.Input.Mouse.currentPosition.x > CORE.Window.screen.width/CORE.Input.Mouse.scale.x) CORE.Input.Mouse.currentPosition.x = CORE.Window.screen.width/CORE.Input.Mouse.scale.x;
// Clamp Mouse X to screen
if (CORE.Input.Mouse.currentPosition.x < 0) CORE.Input.Mouse.currentPosition.x = 0;
else if (CORE.Input.Mouse.currentPosition.x > CORE.Window.screen.width/CORE.Input.Mouse.scale.x) CORE.Input.Mouse.currentPosition.x = CORE.Window.screen.width/CORE.Input.Mouse.scale.x;
if (CORE.Input.Mouse.currentPosition.y < 0) CORE.Input.Mouse.currentPosition.y = 0;
else if (CORE.Input.Mouse.currentPosition.y > CORE.Window.screen.height/CORE.Input.Mouse.scale.y) CORE.Input.Mouse.currentPosition.y = CORE.Window.screen.height/CORE.Input.Mouse.scale.y;
// Clamp Mouse Y to screen
if (CORE.Input.Mouse.currentPosition.y < 0) CORE.Input.Mouse.currentPosition.y = 0;
else if (CORE.Input.Mouse.currentPosition.y > CORE.Window.screen.height/CORE.Input.Mouse.scale.y) CORE.Input.Mouse.currentPosition.y = CORE.Window.screen.height/CORE.Input.Mouse.scale.y;
if (CORE.Input.Keyboard.currentKeyState[CORE.Input.Keyboard.exitKey] == 1) CORE.Window.shouldClose = true;
// Gamepad +/- pressed to exit
if (CORE.Input.Keyboard.currentKeyState[CORE.Input.Keyboard.exitKey] == 1) CORE.Window.shouldClose = true;
#endif
}
}
#endif