MrMonopoly/raylib
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

reversions

Browse Source
This commit is contained in:
Nickolas McDonald 2023-08-19 20:52:36 -04:00
parent ae1f0981bd
commit 3001a4adb3
2 changed files with 172 additions and 165 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
src/config.h
View File

@ -76,8 +76,7 @@
#define MAX_FILEPATH_CAPACITY 8192 // Maximum file paths capacity #define MAX_FILEPATH_CAPACITY 8192 // Maximum file paths capacity
#define MAX_FILEPATH_LENGTH 4096 // Maximum length for filepaths (Linux PATH_MAX default value) #define MAX_FILEPATH_LENGTH 4096 // Maximum length for filepaths (Linux PATH_MAX default value)
#define KEYBOARD_KEYS_MASK 511 // Mask for maximum number of keyboard keys #define MAX_KEYBOARD_KEYS 512 // Maximum number of keyboard keys supported
#define MAX_KEYBOARD_KEYS (KEYBOARD_KEYS_MASK+1)// Maximum number of keyboard keys supported
#define MAX_MOUSE_BUTTONS 8 // Maximum number of mouse buttons supported #define MAX_MOUSE_BUTTONS 8 // Maximum number of mouse buttons supported
#define MAX_GAMEPADS 4 // Maximum number of gamepads supported #define MAX_GAMEPADS 4 // Maximum number of gamepads supported
#define MAX_GAMEPAD_AXIS 8 // Maximum number of axis supported (per gamepad) #define MAX_GAMEPAD_AXIS 8 // Maximum number of axis supported (per gamepad)

152
src/rcore.c
View File

@ -346,10 +346,10 @@
#endif #endif
// Flags operation macros // Flags operation macros
#define FLAGS_SET(n, f) ( (n) |= (f) ) #define FLAG_SET(n, f) ((n) |= (f))
#define FLAGS_CLEAR(n, f) ( (n) &= ~(f) ) #define FLAG_CLEAR(n, f) ((n) &= ~(f))
#define FLAGS_TOGGLE(n, f) ( (n) ^= (f) ) #define FLAG_TOGGLE(n, f) ((n) ^= (f))
#define FLAGS_CHECK(n, f) (( (n) & (f)) == (f) ) #define FLAG_CHECK(n, f) ((n) & (f))
//---------------------------------------------------------------------------------- //----------------------------------------------------------------------------------
// Types and Structures Definition // Types and Structures Definition
@ -436,7 +436,9 @@ typedef struct CoreData {
#endif #endif
struct { struct {
int exitKey; // Default exit key int exitKey; // Default exit key
char keyState[MAX_KEYBOARD_KEYS]; // Registers frame key state char currentKeyState[MAX_KEYBOARD_KEYS]; // Registers current frame key state
char previousKeyState[MAX_KEYBOARD_KEYS]; // Registers previous frame key state
char repeatKeyState[MAX_KEYBOARD_KEYS]; // Registers repeat frame key state
int keyPressedQueue[MAX_KEY_PRESSED_QUEUE]; // Input keys queue int keyPressedQueue[MAX_KEY_PRESSED_QUEUE]; // Input keys queue
int keyPressedQueueCount; // Input keys queue count int keyPressedQueueCount; // Input keys queue count
@ -3744,40 +3746,36 @@ void OpenURL(const char *url)
//---------------------------------------------------------------------------------- //----------------------------------------------------------------------------------
// Module Functions Definition - Input (Keyboard, Mouse, Gamepad) Functions // Module Functions Definition - Input (Keyboard, Mouse, Gamepad) Functions
//---------------------------------------------------------------------------------- //----------------------------------------------------------------------------------
#define KEY_STATE_DOWN 1 // Flag for key held down #define KEY_SAFE(key) (((key) >= 0) && ((key) < sizeof(CORE.Input.Keyboard.currentKeyState)))
#define KEY_STATE_PRESSED ( 2 | KEY_STATE_DOWN) // Flag for key pressed down on frame
#define KEY_STATE_RELEASED 4 // Flag for key released on frame
#define KEY_STATE_REPEATED ( 8 | KEY_STATE_DOWN) // Flag for key text repeat
#define KEY_STATE(key) CORE.Input.Keyboard.keyState[key & KEYBOARD_KEYS_MASK] // Safely accesses key state
// Check if a key has been pressed once // Check if a key has been pressed once
bool IsKeyPressed(int key) bool IsKeyPressed(int key)
{ {
return FLAGS_CHECK(KEY_STATE(key), KEY_STATE_PRESSED); return IsKeyDown(key) && (CORE.Input.Keyboard.previousKeyState[key] == 0);
} }
// Check if a key is being pressed (key held down) // Check if a key is being pressed (key held down)
bool IsKeyDown(int key) bool IsKeyDown(int key)
{ {
return FLAGS_CHECK(KEY_STATE(key), KEY_STATE_DOWN); return KEY_SAFE(key) && (CORE.Input.Keyboard.currentKeyState[key] == 1);
} }
// Check if a key has been released once // Check if a key has been released once
bool IsKeyReleased(int key) bool IsKeyReleased(int key)
{ {
return FLAGS_CHECK(KEY_STATE(key), KEY_STATE_RELEASED); return IsKeyUp(key) && (CORE.Input.Keyboard.previousKeyState[key] == 1);
} }
// Check if a key is NOT being pressed (key not held down) // Check if a key is NOT being pressed (key not held down)
bool IsKeyUp(int key) bool IsKeyUp(int key)
{ {
return !IsKeyDown(key); return KEY_SAFE(key) && (CORE.Input.Keyboard.currentKeyState[key] == 0);
} }
// Check if a key is being repeated (when held down) // Check if a key is being repeated (when held down)
bool IsKeyRepeated(int key) bool IsKeyRepeated(int key)
{ {
return FLAGS_CHECK(KEY_STATE(key), KEY_STATE_REPEATED); return KEY_SAFE(key) && (CORE.Input.Keyboard.repeatKeyState[key] == 1);
} }
// Get the last key pressed // Get the last key pressed
@ -5159,15 +5157,6 @@ void SwapScreenBuffer(void)
#endif // PLATFORM_ANDROID || PLATFORM_RPI || PLATFORM_DRM #endif // PLATFORM_ANDROID || PLATFORM_RPI || PLATFORM_DRM
} }
// Clear frame only key states
static void ClearKeyStates(int count)
{
for (int key = 0; key < count; key++)
{
FLAGS_CLEAR(KEY_STATE(key), ~KEY_STATE_DOWN);
}
}
// Register all input events // Register all input events
void PollInputEvents(void) void PollInputEvents(void)
{ {
@ -5188,7 +5177,13 @@ void PollInputEvents(void)
#endif #endif
#if defined(PLATFORM_RPI) || defined(PLATFORM_DRM) #if defined(PLATFORM_RPI) || defined(PLATFORM_DRM)
ClearKeyStates(MAX_KEYBOARD_KEYS); // Register previous keys states
for (int i = 0; i < MAX_KEYBOARD_KEYS; i++)
{
CORE.Input.Keyboard.previousKeyState[i] = CORE.Input.Keyboard.currentKeyState[i];
CORE.Input.Keyboard.repeatKeyState[i] = 0;
}
PollKeyboardEvents(); PollKeyboardEvents();
// Register previous mouse states // Register previous mouse states
@ -5215,7 +5210,12 @@ void PollInputEvents(void)
#if defined(PLATFORM_DESKTOP) || defined(PLATFORM_WEB) #if defined(PLATFORM_DESKTOP) || defined(PLATFORM_WEB)
// Keyboard/Mouse input polling (automatically managed by GLFW3 through callback) // Keyboard/Mouse input polling (automatically managed by GLFW3 through callback)
ClearKeyStates(MAX_KEYBOARD_KEYS); // Register previous keys states
for (int i = 0; i < MAX_KEYBOARD_KEYS; i++)
{
CORE.Input.Keyboard.previousKeyState[i] = CORE.Input.Keyboard.currentKeyState[i];
CORE.Input.Keyboard.repeatKeyState[i] = 0;
}
// Register previous mouse states // Register previous mouse states
for (int i = 0; i < MAX_MOUSE_BUTTONS; i++) CORE.Input.Mouse.previousButtonState[i] = CORE.Input.Mouse.currentButtonState[i]; for (int i = 0; i < MAX_MOUSE_BUTTONS; i++) CORE.Input.Mouse.previousButtonState[i] = CORE.Input.Mouse.currentButtonState[i];
@ -5397,7 +5397,11 @@ void PollInputEvents(void)
#if defined(PLATFORM_ANDROID) #if defined(PLATFORM_ANDROID)
// Register previous keys states // Register previous keys states
// NOTE: Android supports up to 260 keys // NOTE: Android supports up to 260 keys
ClearKeyStates(260); for (int i = 0; i < 260; i++)
{
CORE.Input.Keyboard.previousKeyState[i] = CORE.Input.Keyboard.currentKeyState[i];
CORE.Input.Keyboard.repeatKeyState[i] = 0;
}
// Android ALooper_pollAll() variables // Android ALooper_pollAll() variables
int pollResult = 0; int pollResult = 0;
@ -5590,14 +5594,18 @@ static void KeyCallback(GLFWwindow *window, int key, int scancode, int action, i
{ {
if (key < 0) return; // Security check, macOS fn key generates -1 if (key < 0) return; // Security check, macOS fn key generates -1
if ((action == GLFW_RELEASE) // WARNING: GLFW could return GLFW_REPEAT, we need to consider it as 1
#if !defined(PLATFORM_WEB) // WARNING: Check if CAPS/NUM key modifiers are not enabled // to work properly with our implementation (IsKeyDown/IsKeyUp checks)
&& !((key == KEY_CAPS_LOCK) && FLAGS_CHECK(mods, GLFW_MOD_CAPS_LOCK)) if (action == GLFW_RELEASE) CORE.Input.Keyboard.currentKeyState[key] = 0;
&& !((key == KEY_NUM_LOCK) && FLAGS_CHECK(mods, GLFW_MOD_NUM_LOCK)) else CORE.Input.Keyboard.currentKeyState[key] = 1;
if (action == GLFW_REPEAT) CORE.Input.Keyboard.repeatKeyState[key] = 1;
#if !defined(PLATFORM_WEB)
// WARNING: Check if CAPS/NUM key modifiers are enabled and force down state for those keys
if (((key == KEY_CAPS_LOCK) && ((mods & GLFW_MOD_CAPS_LOCK) > 0)) ||
((key == KEY_NUM_LOCK) && ((mods & GLFW_MOD_NUM_LOCK) > 0))) CORE.Input.Keyboard.currentKeyState[key] = 1;
#endif #endif
) KEY_STATE(key) = KEY_STATE_RELEASED;
else if (action == GLFW_PRESS) KEY_STATE(key) = KEY_STATE_PRESSED;
else if (action == GLFW_REPEAT) KEY_STATE(key) = KEY_STATE_REPEATED;
// Check if there is space available in the key queue // Check if there is space available in the key queue
if ((CORE.Input.Keyboard.keyPressedQueueCount < MAX_KEY_PRESSED_QUEUE) && (action == GLFW_PRESS)) if ((CORE.Input.Keyboard.keyPressedQueueCount < MAX_KEY_PRESSED_QUEUE) && (action == GLFW_PRESS))
@ -6054,13 +6062,13 @@ static int32_t AndroidInputCallback(struct android_app *app, AInputEvent *event)
// NOTE: Android key action is 0 for down and 1 for up // NOTE: Android key action is 0 for down and 1 for up
if (AKeyEvent_getAction(event) == AKEY_EVENT_ACTION_DOWN) if (AKeyEvent_getAction(event) == AKEY_EVENT_ACTION_DOWN)
{ {
KEY_STATE(keycode) = KEY_STATE_PRESSED; CORE.Input.Keyboard.currentKeyState[keycode] = 1; // Key down
CORE.Input.Keyboard.keyPressedQueue[CORE.Input.Keyboard.keyPressedQueueCount] = keycode; CORE.Input.Keyboard.keyPressedQueue[CORE.Input.Keyboard.keyPressedQueueCount] = keycode;
CORE.Input.Keyboard.keyPressedQueueCount++; CORE.Input.Keyboard.keyPressedQueueCount++;
} }
else if (AKeyEvent_getAction(event) == AKEY_EVENT_ACTION_UP) KEY_STATE(keycode) = KEY_STATE_RELEASED; else if (AKeyEvent_getAction(event) == AKEY_EVENT_ACTION_MULTIPLE) CORE.Input.Keyboard.repeatKeyState[keycode] = 1;
else if (AKeyEvent_getAction(event) == AKEY_EVENT_ACTION_MULTIPLE) KEY_STATE(keycode) = KEY_STATE_REPEATED; else CORE.Input.Keyboard.currentKeyState[keycode] = 0; // Key up
if (keycode == AKEYCODE_POWER) if (keycode == AKEYCODE_POWER)
{ {
@ -6363,7 +6371,7 @@ static void ProcessKeyboard(void)
bufferByteCount = read(STDIN_FILENO, keysBuffer, MAX_KEYBUFFER_SIZE); // POSIX system call bufferByteCount = read(STDIN_FILENO, keysBuffer, MAX_KEYBUFFER_SIZE); // POSIX system call
// Reset pressed keys array (it will be filled below) // Reset pressed keys array (it will be filled below)
for (int i = 0; i < MAX_KEYBOARD_KEYS; i++) KEY_STATE(i) = 0; for (int i = 0; i < MAX_KEYBOARD_KEYS; i++) CORE.Input.Keyboard.currentKeyState[i] = 0;
// Fill all read bytes (looking for keys) // Fill all read bytes (looking for keys)
for (int i = 0; i < bufferByteCount; i++) for (int i = 0; i < bufferByteCount; i++)
@ -6373,7 +6381,7 @@ static void ProcessKeyboard(void)
if (keysBuffer[i] == 0x1b) if (keysBuffer[i] == 0x1b)
{ {
// Check if ESCAPE key has been pressed to stop program // Check if ESCAPE key has been pressed to stop program
if (bufferByteCount == 1) KEY_STATE(CORE.Input.Keyboard.exitKey) = KEY_STATE_PRESSED; if (bufferByteCount == 1) CORE.Input.Keyboard.currentKeyState[CORE.Input.Keyboard.exitKey] = 1;
else else
{ {
if (keysBuffer[i + 1] == 0x5b) // Special function key if (keysBuffer[i + 1] == 0x5b) // Special function key
@ -6383,18 +6391,18 @@ static void ProcessKeyboard(void)
// Process special function keys (F1 - F12) // Process special function keys (F1 - F12)
switch (keysBuffer[i + 3]) switch (keysBuffer[i + 3])
{ {
case 0x41: KEY_STATE(290) = KEY_STATE_PRESSED; break; // raylib KEY_F1 case 0x41: CORE.Input.Keyboard.currentKeyState[290] = 1; break; // raylib KEY_F1
case 0x42: KEY_STATE(291) = KEY_STATE_PRESSED; break; // raylib KEY_F2 case 0x42: CORE.Input.Keyboard.currentKeyState[291] = 1; break; // raylib KEY_F2
case 0x43: KEY_STATE(292) = KEY_STATE_PRESSED; break; // raylib KEY_F3 case 0x43: CORE.Input.Keyboard.currentKeyState[292] = 1; break; // raylib KEY_F3
case 0x44: KEY_STATE(293) = KEY_STATE_PRESSED; break; // raylib KEY_F4 case 0x44: CORE.Input.Keyboard.currentKeyState[293] = 1; break; // raylib KEY_F4
case 0x45: KEY_STATE(294) = KEY_STATE_PRESSED; break; // raylib KEY_F5 case 0x45: CORE.Input.Keyboard.currentKeyState[294] = 1; break; // raylib KEY_F5
case 0x37: KEY_STATE(295) = KEY_STATE_PRESSED; break; // raylib KEY_F6 case 0x37: CORE.Input.Keyboard.currentKeyState[295] = 1; break; // raylib KEY_F6
case 0x38: KEY_STATE(296) = KEY_STATE_PRESSED; break; // raylib KEY_F7 case 0x38: CORE.Input.Keyboard.currentKeyState[296] = 1; break; // raylib KEY_F7
case 0x39: KEY_STATE(297) = KEY_STATE_PRESSED; break; // raylib KEY_F8 case 0x39: CORE.Input.Keyboard.currentKeyState[297] = 1; break; // raylib KEY_F8
case 0x30: KEY_STATE(298) = KEY_STATE_PRESSED; break; // raylib KEY_F9 case 0x30: CORE.Input.Keyboard.currentKeyState[298] = 1; break; // raylib KEY_F9
case 0x31: KEY_STATE(299) = KEY_STATE_PRESSED; break; // raylib KEY_F10 case 0x31: CORE.Input.Keyboard.currentKeyState[299] = 1; break; // raylib KEY_F10
case 0x33: KEY_STATE(300) = KEY_STATE_PRESSED; break; // raylib KEY_F11 case 0x33: CORE.Input.Keyboard.currentKeyState[300] = 1; break; // raylib KEY_F11
case 0x34: KEY_STATE(301) = KEY_STATE_PRESSED; break; // raylib KEY_F12 case 0x34: CORE.Input.Keyboard.currentKeyState[301] = 1; break; // raylib KEY_F12
default: break; default: break;
} }
@ -6405,10 +6413,10 @@ static void ProcessKeyboard(void)
{ {
switch (keysBuffer[i + 2]) switch (keysBuffer[i + 2])
{ {
case 0x41: KEY_STATE(265) = KEY_STATE_PRESSED; break; // raylib KEY_UP case 0x41: CORE.Input.Keyboard.currentKeyState[265] = 1; break; // raylib KEY_UP
case 0x42: KEY_STATE(264) = KEY_STATE_PRESSED; break; // raylib KEY_DOWN case 0x42: CORE.Input.Keyboard.currentKeyState[264] = 1; break; // raylib KEY_DOWN
case 0x43: KEY_STATE(262) = KEY_STATE_PRESSED; break; // raylib KEY_RIGHT case 0x43: CORE.Input.Keyboard.currentKeyState[262] = 1; break; // raylib KEY_RIGHT
case 0x44: KEY_STATE(263) = KEY_STATE_PRESSED; break; // raylib KEY_LEFT case 0x44: CORE.Input.Keyboard.currentKeyState[263] = 1; break; // raylib KEY_LEFT
default: break; default: break;
} }
@ -6421,14 +6429,14 @@ static void ProcessKeyboard(void)
} }
else if (keysBuffer[i] == 0x0a) // raylib KEY_ENTER (don't mix with <linux/input.h> KEY_*) else if (keysBuffer[i] == 0x0a) // raylib KEY_ENTER (don't mix with <linux/input.h> KEY_*)
{ {
KEY_STATE(257) = KEY_STATE_PRESSED; CORE.Input.Keyboard.currentKeyState[257] = 1;
CORE.Input.Keyboard.keyPressedQueue[CORE.Input.Keyboard.keyPressedQueueCount] = 257; // Add keys pressed into queue CORE.Input.Keyboard.keyPressedQueue[CORE.Input.Keyboard.keyPressedQueueCount] = 257; // Add keys pressed into queue
CORE.Input.Keyboard.keyPressedQueueCount++; CORE.Input.Keyboard.keyPressedQueueCount++;
} }
else if (keysBuffer[i] == 0x7f) // raylib KEY_BACKSPACE else if (keysBuffer[i] == 0x7f) // raylib KEY_BACKSPACE
{ {
KEY_STATE(259) = KEY_STATE_PRESSED; CORE.Input.Keyboard.currentKeyState[259] = 1;
CORE.Input.Keyboard.keyPressedQueue[CORE.Input.Keyboard.keyPressedQueueCount] = 257; // Add keys pressed into queue CORE.Input.Keyboard.keyPressedQueue[CORE.Input.Keyboard.keyPressedQueueCount] = 257; // Add keys pressed into queue
CORE.Input.Keyboard.keyPressedQueueCount++; CORE.Input.Keyboard.keyPressedQueueCount++;
@ -6438,9 +6446,9 @@ static void ProcessKeyboard(void)
// Translate lowercase a-z letters to A-Z // Translate lowercase a-z letters to A-Z
if ((keysBuffer[i] >= 97) && (keysBuffer[i] <= 122)) if ((keysBuffer[i] >= 97) && (keysBuffer[i] <= 122))
{ {
KEY_STATE((int)keysBuffer[i] - 32) = KEY_STATE_PRESSED; CORE.Input.Keyboard.currentKeyState[(int)keysBuffer[i] - 32] = 1;
} }
else KEY_STATE((int)keysBuffer[i]) = KEY_STATE_PRESSED; else CORE.Input.Keyboard.currentKeyState[(int)keysBuffer[i]] = 1;
CORE.Input.Keyboard.keyPressedQueue[CORE.Input.Keyboard.keyPressedQueueCount] = keysBuffer[i]; // Add keys pressed into queue CORE.Input.Keyboard.keyPressedQueue[CORE.Input.Keyboard.keyPressedQueueCount] = keysBuffer[i]; // Add keys pressed into queue
CORE.Input.Keyboard.keyPressedQueueCount++; CORE.Input.Keyboard.keyPressedQueueCount++;
@ -6448,11 +6456,11 @@ static void ProcessKeyboard(void)
} }
// Check exit key (same functionality as GLFW3 KeyCallback()) // Check exit key (same functionality as GLFW3 KeyCallback())
if (IsKeyDown(CORE.Input.Keyboard.exitKey)) CORE.Window.shouldClose = true; if (CORE.Input.Keyboard.currentKeyState[CORE.Input.Keyboard.exitKey] == 1) CORE.Window.shouldClose = true;
#if defined(SUPPORT_SCREEN_CAPTURE) #if defined(SUPPORT_SCREEN_CAPTURE)
// Check screen capture key (raylib key: KEY_F12) // Check screen capture key (raylib key: KEY_F12)
if (IsKeyDown(301)) if (CORE.Input.Keyboard.currentKeyState[301] == 1)
{ {
TakeScreenshot(TextFormat("screenshot%03i.png", screenshotCounter)); TakeScreenshot(TextFormat("screenshot%03i.png", screenshotCounter));
screenshotCounter++; screenshotCounter++;
@ -6479,7 +6487,7 @@ static void InitEvdevInput(void)
} }
// Reset keyboard key state // Reset keyboard key state
for (int i = 0; i < MAX_KEYBOARD_KEYS; i++) KEY_STATE(i) = 0; for (int i = 0; i < MAX_KEYBOARD_KEYS; i++) CORE.Input.Keyboard.currentKeyState[i] = 0;
// Open the linux directory of "/dev/input" // Open the linux directory of "/dev/input"
directory = opendir(DEFAULT_EVDEV_PATH); directory = opendir(DEFAULT_EVDEV_PATH);
@ -6749,12 +6757,12 @@ static void PollKeyboardEvents(void)
keycode = keymapUS[event.code & 0xFF]; // The code we get is a scancode so we look up the appropriate keycode keycode = keymapUS[event.code & 0xFF]; // The code we get is a scancode so we look up the appropriate keycode
// Make sure we got a valid keycode // Make sure we got a valid keycode
if ((keycode > 0) && (keycode < MAX_KEYBOARD_KEYS)) if ((keycode > 0) && (keycode < sizeof(CORE.Input.Keyboard.currentKeyState)))
{ {
// WARNING: https://www.kernel.org/doc/Documentation/input/input.txt // WARNING: https://www.kernel.org/doc/Documentation/input/input.txt
// Event interface: 'value' is the value the event carries. Either a relative change for EV_REL, // Event interface: 'value' is the value the event carries. Either a relative change for EV_REL,
// absolute new value for EV_ABS (joysticks ...), or 0 for EV_KEY for release, 1 for keypress and 2 for autorepeat // absolute new value for EV_ABS (joysticks ...), or 0 for EV_KEY for release, 1 for keypress and 2 for autorepeat
KEY_STATE(keycode) = (event.value >= 1) ? KEY_STATE_PRESSED : KEY_STATE_RELEASED; CORE.Input.Keyboard.currentKeyState[keycode] = (event.value >= 1) ? 1 : 0;
if (event.value >= 1) if (event.value >= 1)
{ {
CORE.Input.Keyboard.keyPressedQueue[CORE.Input.Keyboard.keyPressedQueueCount] = keycode; // Register last key pressed CORE.Input.Keyboard.keyPressedQueue[CORE.Input.Keyboard.keyPressedQueueCount] = keycode; // Register last key pressed
@ -6763,14 +6771,14 @@ static void PollKeyboardEvents(void)
#if defined(SUPPORT_SCREEN_CAPTURE) #if defined(SUPPORT_SCREEN_CAPTURE)
// Check screen capture key (raylib key: KEY_F12) // Check screen capture key (raylib key: KEY_F12)
if (IsKeyDown(301)) if (CORE.Input.Keyboard.currentKeyState[301] == 1)
{ {
TakeScreenshot(TextFormat("screenshot%03i.png", screenshotCounter)); TakeScreenshot(TextFormat("screenshot%03i.png", screenshotCounter));
screenshotCounter++; screenshotCounter++;
} }
#endif #endif
if (IsKeyDown(CORE.Input.Keyboard.exitKey) CORE.Window.shouldClose = true; if (CORE.Input.Keyboard.currentKeyState[CORE.Input.Keyboard.exitKey] == 1) CORE.Window.shouldClose = true;
TRACELOGD("RPI: KEY_%s ScanCode: %4i KeyCode: %4i", event.value == 0 ? "UP" : "DOWN", event.code, keycode); TRACELOGD("RPI: KEY_%s ScanCode: %4i KeyCode: %4i", event.value == 0 ? "UP" : "DOWN", event.code, keycode);
} }
@ -7233,7 +7241,7 @@ static void RecordAutomationEvent(unsigned int frame)
for (int key = 0; key < MAX_KEYBOARD_KEYS; key++) for (int key = 0; key < MAX_KEYBOARD_KEYS; key++)
{ {
// INPUT_KEY_UP (only saved once) // INPUT_KEY_UP (only saved once)
if (IsKeyReleased(key)) if (CORE.Input.Keyboard.previousKeyState[key] && !CORE.Input.Keyboard.currentKeyState[key])
{ {
events[eventCount].frame = frame; events[eventCount].frame = frame;
events[eventCount].type = INPUT_KEY_UP; events[eventCount].type = INPUT_KEY_UP;
@ -7246,7 +7254,7 @@ static void RecordAutomationEvent(unsigned int frame)
} }
// INPUT_KEY_DOWN // INPUT_KEY_DOWN
if (IsKeyDown(key)) if (CORE.Input.Keyboard.currentKeyState[key])
{ {
events[eventCount].frame = frame; events[eventCount].frame = frame;
events[eventCount].type = INPUT_KEY_DOWN; events[eventCount].type = INPUT_KEY_DOWN;
@ -7452,10 +7460,10 @@ static void PlayAutomationEvent(unsigned int frame)
switch (events[i].type) switch (events[i].type)
{ {
// Input events // Input events
case INPUT_KEY_UP: KEY_STATE(events[i].params[0]) = KEY_STATE_RELEASED; break; // param[0]: key case INPUT_KEY_UP: CORE.Input.Keyboard.currentKeyState[events[i].params[0]] = false; break; // param[0]: key
case INPUT_KEY_DOWN: KEY_STATE(events[i].params[0]) = KEY_STATE_PRESSED; break; // param[0]: key case INPUT_KEY_DOWN: CORE.Input.Keyboard.currentKeyState[events[i].params[0]] = true; break; // param[0]: key
case INPUT_MOUSE_BUTTON_UP: KEY_STATE(events[i].params[0]) = KEY_STATE_RELEASED; break; // param[0]: key case INPUT_MOUSE_BUTTON_UP: CORE.Input.Mouse.currentButtonState[events[i].params[0]] = false; break; // param[0]: key
case INPUT_MOUSE_BUTTON_DOWN: KEY_STATE(events[i].params[0]) = KEY_STATE_PRESSED; break; // param[0]: key case INPUT_MOUSE_BUTTON_DOWN: CORE.Input.Mouse.currentButtonState[events[i].params[0]] = true; break; // param[0]: key
case INPUT_MOUSE_POSITION: // param[0]: x, param[1]: y case INPUT_MOUSE_POSITION: // param[0]: x, param[1]: y
{ {
CORE.Input.Mouse.currentPosition.x = (float)events[i].params[0]; CORE.Input.Mouse.currentPosition.x = (float)events[i].params[0];