|
|
@ -0,0 +1,755 @@ |
|
|
|
/********************************************************************************************** |
|
|
|
* |
|
|
|
* rcore_desktop_sdl - Functions to manage window, graphics device and inputs |
|
|
|
* |
|
|
|
* PLATFORM: DESKTOP: SDL |
|
|
|
* - Windows (Win32, Win64) |
|
|
|
* - Linux (X11/Wayland desktop mode) |
|
|
|
* - FreeBSD, OpenBSD, NetBSD, DragonFly (X11 desktop) |
|
|
|
* - OSX/macOS (x64, arm64) |
|
|
|
* |
|
|
|
* LIMITATIONS: |
|
|
|
* - Limitation 01 |
|
|
|
* - Limitation 02 |
|
|
|
* |
|
|
|
* POSSIBLE IMPROVEMENTS: |
|
|
|
* - Improvement 01 |
|
|
|
* - Improvement 02 |
|
|
|
* |
|
|
|
* ADDITIONAL NOTES: |
|
|
|
* - TRACELOG() function is located in raylib [utils] module |
|
|
|
* |
|
|
|
* CONFIGURATION: |
|
|
|
* #define RCORE_PLATFORM_CUSTOM_FLAG |
|
|
|
* Custom flag for rcore on target platform -not used- |
|
|
|
* |
|
|
|
* DEPENDENCIES: |
|
|
|
* - SDL 2 (main library) |
|
|
|
* - Dependency 02 |
|
|
|
* |
|
|
|
* |
|
|
|
* LICENSE: zlib/libpng |
|
|
|
* |
|
|
|
* Copyright (c) 2013-2023 Ramon Santamaria (@raysan5) and contributors |
|
|
|
* |
|
|
|
* This software is provided "as-is", without any express or implied warranty. In no event |
|
|
|
* will the authors be held liable for any damages arising from the use of this software. |
|
|
|
* |
|
|
|
* Permission is granted to anyone to use this software for any purpose, including commercial |
|
|
|
* applications, and to alter it and redistribute it freely, subject to the following restrictions: |
|
|
|
* |
|
|
|
* 1. The origin of this software must not be misrepresented; you must not claim that you |
|
|
|
* wrote the original software. If you use this software in a product, an acknowledgment |
|
|
|
* in the product documentation would be appreciated but is not required. |
|
|
|
* |
|
|
|
* 2. Altered source versions must be plainly marked as such, and must not be misrepresented |
|
|
|
* as being the original software. |
|
|
|
* |
|
|
|
* 3. This notice may not be removed or altered from any source distribution. |
|
|
|
* |
|
|
|
**********************************************************************************************/ |
|
|
|
|
|
|
|
#include "rcore.h" |
|
|
|
|
|
|
|
#include "SDL.h" // SDL base library (window/rendered, input, timming... functionality) |
|
|
|
#include "SDL_opengl.h" // SDL OpenGL functionality (if required, instead of internal renderer) |
|
|
|
|
|
|
|
//---------------------------------------------------------------------------------- |
|
|
|
// Types and Structures Definition |
|
|
|
//---------------------------------------------------------------------------------- |
|
|
|
typedef struct { |
|
|
|
SDL_Window *window; |
|
|
|
SDL_GLContext glContext; |
|
|
|
|
|
|
|
SDL_Joystick *gamepad; |
|
|
|
} PlatformData; |
|
|
|
|
|
|
|
//---------------------------------------------------------------------------------- |
|
|
|
// Global Variables Definition |
|
|
|
//---------------------------------------------------------------------------------- |
|
|
|
extern CoreData CORE; // Global CORE state context |
|
|
|
|
|
|
|
static PlatformData platform = { 0 }; // Platform specific data |
|
|
|
|
|
|
|
//---------------------------------------------------------------------------------- |
|
|
|
// Module Internal Functions Declaration |
|
|
|
//---------------------------------------------------------------------------------- |
|
|
|
static int InitPlatform(void); // Initialize platform (graphics, inputs and more) |
|
|
|
static void ClosePlatform(void); // Close platform |
|
|
|
|
|
|
|
//---------------------------------------------------------------------------------- |
|
|
|
// Module Functions Declaration |
|
|
|
//---------------------------------------------------------------------------------- |
|
|
|
// NOTE: Functions declaration is provided by raylib.h |
|
|
|
|
|
|
|
//---------------------------------------------------------------------------------- |
|
|
|
// Module Functions Definition: Window and Graphics Device |
|
|
|
//---------------------------------------------------------------------------------- |
|
|
|
|
|
|
|
// Initialize window and OpenGL context |
|
|
|
// NOTE: data parameter could be used to pass any kind of required data to the initialization |
|
|
|
void InitWindow(int width, int height, const char *title) |
|
|
|
{ |
|
|
|
TRACELOG(LOG_INFO, "Initializing raylib %s", RAYLIB_VERSION); |
|
|
|
|
|
|
|
TRACELOG(LOG_INFO, "Supported raylib modules:"); |
|
|
|
TRACELOG(LOG_INFO, " > rcore:..... loaded (mandatory)"); |
|
|
|
TRACELOG(LOG_INFO, " > rlgl:...... loaded (mandatory)"); |
|
|
|
#if defined(SUPPORT_MODULE_RSHAPES) |
|
|
|
TRACELOG(LOG_INFO, " > rshapes:... loaded (optional)"); |
|
|
|
#else |
|
|
|
TRACELOG(LOG_INFO, " > rshapes:... not loaded (optional)"); |
|
|
|
#endif |
|
|
|
#if defined(SUPPORT_MODULE_RTEXTURES) |
|
|
|
TRACELOG(LOG_INFO, " > rtextures:. loaded (optional)"); |
|
|
|
#else |
|
|
|
TRACELOG(LOG_INFO, " > rtextures:. not loaded (optional)"); |
|
|
|
#endif |
|
|
|
#if defined(SUPPORT_MODULE_RTEXT) |
|
|
|
TRACELOG(LOG_INFO, " > rtext:..... loaded (optional)"); |
|
|
|
#else |
|
|
|
TRACELOG(LOG_INFO, " > rtext:..... not loaded (optional)"); |
|
|
|
#endif |
|
|
|
#if defined(SUPPORT_MODULE_RMODELS) |
|
|
|
TRACELOG(LOG_INFO, " > rmodels:... loaded (optional)"); |
|
|
|
#else |
|
|
|
TRACELOG(LOG_INFO, " > rmodels:... not loaded (optional)"); |
|
|
|
#endif |
|
|
|
#if defined(SUPPORT_MODULE_RAUDIO) |
|
|
|
TRACELOG(LOG_INFO, " > raudio:.... loaded (optional)"); |
|
|
|
#else |
|
|
|
TRACELOG(LOG_INFO, " > raudio:.... not loaded (optional)"); |
|
|
|
#endif |
|
|
|
|
|
|
|
// Initialize window data |
|
|
|
CORE.Window.screen.width = width; |
|
|
|
CORE.Window.screen.height = height; |
|
|
|
CORE.Window.eventWaiting = false; |
|
|
|
CORE.Window.screenScale = MatrixIdentity(); // No draw scaling required by default |
|
|
|
if ((title != NULL) && (title[0] != 0)) CORE.Window.title = title; |
|
|
|
|
|
|
|
// Initialize global input state |
|
|
|
memset(&CORE.Input, 0, sizeof(CORE.Input)); // Reset CORE.Input structure to 0 |
|
|
|
CORE.Input.Keyboard.exitKey = KEY_ESCAPE; |
|
|
|
CORE.Input.Mouse.scale = (Vector2){ 1.0f, 1.0f }; |
|
|
|
CORE.Input.Mouse.cursor = MOUSE_CURSOR_ARROW; |
|
|
|
CORE.Input.Gamepad.lastButtonPressed = GAMEPAD_BUTTON_UNKNOWN; |
|
|
|
|
|
|
|
// Initialize platform |
|
|
|
//-------------------------------------------------------------- |
|
|
|
InitPlatform(); |
|
|
|
//-------------------------------------------------------------- |
|
|
|
|
|
|
|
// Initialize rlgl default data (buffers and shaders) |
|
|
|
// NOTE: CORE.Window.currentFbo.width and CORE.Window.currentFbo.height not used, just stored as globals in rlgl |
|
|
|
rlglInit(CORE.Window.currentFbo.width, CORE.Window.currentFbo.height); |
|
|
|
|
|
|
|
// Setup default viewport |
|
|
|
SetupViewport(CORE.Window.currentFbo.width, CORE.Window.currentFbo.height); |
|
|
|
|
|
|
|
#if defined(SUPPORT_MODULE_RTEXT) && defined(SUPPORT_DEFAULT_FONT) |
|
|
|
// Load default font |
|
|
|
// WARNING: External function: Module required: rtext |
|
|
|
LoadFontDefault(); |
|
|
|
#if defined(SUPPORT_MODULE_RSHAPES) |
|
|
|
// Set font white rectangle for shapes drawing, so shapes and text can be batched together |
|
|
|
// WARNING: rshapes module is required, if not available, default internal white rectangle is used |
|
|
|
Rectangle rec = GetFontDefault().recs[95]; |
|
|
|
if (CORE.Window.flags & FLAG_MSAA_4X_HINT) |
|
|
|
{ |
|
|
|
// NOTE: We try to maxime rec padding to avoid pixel bleeding on MSAA filtering |
|
|
|
SetShapesTexture(GetFontDefault().texture, (Rectangle){ rec.x + 2, rec.y + 2, 1, 1 }); |
|
|
|
} |
|
|
|
else |
|
|
|
{ |
|
|
|
// NOTE: We set up a 1px padding on char rectangle to avoid pixel bleeding |
|
|
|
SetShapesTexture(GetFontDefault().texture, (Rectangle){ rec.x + 1, rec.y + 1, rec.width - 2, rec.height - 2 }); |
|
|
|
} |
|
|
|
#endif |
|
|
|
#else |
|
|
|
#if defined(SUPPORT_MODULE_RSHAPES) |
|
|
|
// Set default texture and rectangle to be used for shapes drawing |
|
|
|
// NOTE: rlgl default texture is a 1x1 pixel UNCOMPRESSED_R8G8B8A8 |
|
|
|
Texture2D texture = { rlGetTextureIdDefault(), 1, 1, 1, PIXELFORMAT_UNCOMPRESSED_R8G8B8A8 }; |
|
|
|
SetShapesTexture(texture, (Rectangle){ 0.0f, 0.0f, 1.0f, 1.0f }); // WARNING: Module required: rshapes |
|
|
|
#endif |
|
|
|
#endif |
|
|
|
#if defined(SUPPORT_MODULE_RTEXT) && defined(SUPPORT_DEFAULT_FONT) |
|
|
|
if ((CORE.Window.flags & FLAG_WINDOW_HIGHDPI) > 0) |
|
|
|
{ |
|
|
|
// Set default font texture filter for HighDPI (blurry) |
|
|
|
// RL_TEXTURE_FILTER_LINEAR - tex filter: BILINEAR, no mipmaps |
|
|
|
rlTextureParameters(GetFontDefault().texture.id, RL_TEXTURE_MIN_FILTER, RL_TEXTURE_FILTER_LINEAR); |
|
|
|
rlTextureParameters(GetFontDefault().texture.id, RL_TEXTURE_MAG_FILTER, RL_TEXTURE_FILTER_LINEAR); |
|
|
|
} |
|
|
|
#endif |
|
|
|
|
|
|
|
// Initialize random seed |
|
|
|
SetRandomSeed((unsigned int)time(NULL)); |
|
|
|
|
|
|
|
#if defined(SUPPORT_EVENTS_AUTOMATION) |
|
|
|
events = (AutomationEvent *)RL_CALLOC(MAX_CODE_AUTOMATION_EVENTS, sizeof(AutomationEvent)); |
|
|
|
CORE.Time.frameCounter = 0; |
|
|
|
#endif |
|
|
|
|
|
|
|
TRACELOG(LOG_INFO, "PLATFORM: CUSTOM: Application initialized successfully"); |
|
|
|
} |
|
|
|
|
|
|
|
// Close window and unload OpenGL context |
|
|
|
void CloseWindow(void) |
|
|
|
{ |
|
|
|
#if defined(SUPPORT_GIF_RECORDING) |
|
|
|
if (gifRecording) |
|
|
|
{ |
|
|
|
MsfGifResult result = msf_gif_end(&gifState); |
|
|
|
msf_gif_free(result); |
|
|
|
gifRecording = false; |
|
|
|
} |
|
|
|
#endif |
|
|
|
|
|
|
|
#if defined(SUPPORT_MODULE_RTEXT) && defined(SUPPORT_DEFAULT_FONT) |
|
|
|
UnloadFontDefault(); // WARNING: Module required: rtext |
|
|
|
#endif |
|
|
|
|
|
|
|
rlglClose(); // De-init rlgl |
|
|
|
|
|
|
|
// De-initialize platform |
|
|
|
//-------------------------------------------------------------- |
|
|
|
ClosePlatform(); |
|
|
|
//-------------------------------------------------------------- |
|
|
|
|
|
|
|
#if defined(SUPPORT_EVENTS_AUTOMATION) |
|
|
|
RL_FREE(events); |
|
|
|
#endif |
|
|
|
|
|
|
|
CORE.Window.ready = false; |
|
|
|
TRACELOG(LOG_INFO, "Window closed successfully"); |
|
|
|
} |
|
|
|
|
|
|
|
// Check if application should close |
|
|
|
bool WindowShouldClose(void) |
|
|
|
{ |
|
|
|
if (CORE.Window.ready) return CORE.Window.shouldClose; |
|
|
|
else return true; |
|
|
|
} |
|
|
|
|
|
|
|
// Toggle fullscreen mode |
|
|
|
void ToggleFullscreen(void) |
|
|
|
{ |
|
|
|
//SDL_SetWindowFullscreen |
|
|
|
} |
|
|
|
|
|
|
|
// Toggle borderless windowed mode |
|
|
|
void ToggleBorderlessWindowed(void) |
|
|
|
{ |
|
|
|
//SDL_SetWindowFullscreen |
|
|
|
} |
|
|
|
|
|
|
|
// Set window state: maximized, if resizable |
|
|
|
void MaximizeWindow(void) |
|
|
|
{ |
|
|
|
SDL_MaximizeWindow(platform.window); |
|
|
|
CORE.Window.flags |= FLAG_WINDOW_MAXIMIZED; |
|
|
|
} |
|
|
|
|
|
|
|
// Set window state: minimized |
|
|
|
void MinimizeWindow(void) |
|
|
|
{ |
|
|
|
SDL_MinimizeWindow(platform.window); |
|
|
|
CORE.Window.flags |= FLAG_WINDOW_MINIMIZED; |
|
|
|
} |
|
|
|
|
|
|
|
// Set window state: not minimized/maximized |
|
|
|
void RestoreWindow(void) |
|
|
|
{ |
|
|
|
SDL_ShowWindow(platform.window); |
|
|
|
} |
|
|
|
|
|
|
|
// Set window configuration state using flags |
|
|
|
void SetWindowState(unsigned int flags) |
|
|
|
{ |
|
|
|
//SDL_HideWindow(platform.window); |
|
|
|
} |
|
|
|
|
|
|
|
// Clear window configuration state flags |
|
|
|
void ClearWindowState(unsigned int flags) |
|
|
|
{ |
|
|
|
TRACELOG(LOG_WARNING, "ClearWindowState() not available on target platform"); |
|
|
|
} |
|
|
|
|
|
|
|
// Set icon for window |
|
|
|
void SetWindowIcon(Image image) |
|
|
|
{ |
|
|
|
TRACELOG(LOG_WARNING, "SetWindowIcon() not available on target platform"); |
|
|
|
} |
|
|
|
|
|
|
|
// Set icon for window |
|
|
|
void SetWindowIcons(Image *images, int count) |
|
|
|
{ |
|
|
|
TRACELOG(LOG_WARNING, "SetWindowIcons() not available on target platform"); |
|
|
|
} |
|
|
|
|
|
|
|
// Set title for window |
|
|
|
void SetWindowTitle(const char *title) |
|
|
|
{ |
|
|
|
CORE.Window.title = title; |
|
|
|
} |
|
|
|
|
|
|
|
// Set window position on screen (windowed mode) |
|
|
|
void SetWindowPosition(int x, int y) |
|
|
|
{ |
|
|
|
TRACELOG(LOG_WARNING, "SetWindowPosition() not available on target platform"); |
|
|
|
} |
|
|
|
|
|
|
|
// Set monitor for the current window |
|
|
|
void SetWindowMonitor(int monitor) |
|
|
|
{ |
|
|
|
TRACELOG(LOG_WARNING, "SetWindowMonitor() not available on target platform"); |
|
|
|
} |
|
|
|
|
|
|
|
// Set window minimum dimensions (FLAG_WINDOW_RESIZABLE) |
|
|
|
void SetWindowMinSize(int width, int height) |
|
|
|
{ |
|
|
|
CORE.Window.screenMin.width = width; |
|
|
|
CORE.Window.screenMin.height = height; |
|
|
|
} |
|
|
|
|
|
|
|
// Set window maximum dimensions (FLAG_WINDOW_RESIZABLE) |
|
|
|
void SetWindowMaxSize(int width, int height) |
|
|
|
{ |
|
|
|
CORE.Window.screenMax.width = width; |
|
|
|
CORE.Window.screenMax.height = height; |
|
|
|
} |
|
|
|
|
|
|
|
// Set window dimensions |
|
|
|
void SetWindowSize(int width, int height) |
|
|
|
{ |
|
|
|
TRACELOG(LOG_WARNING, "SetWindowSize() not available on target platform"); |
|
|
|
} |
|
|
|
|
|
|
|
// Set window opacity, value opacity is between 0.0 and 1.0 |
|
|
|
void SetWindowOpacity(float opacity) |
|
|
|
{ |
|
|
|
TRACELOG(LOG_WARNING, "SetWindowOpacity() not available on target platform"); |
|
|
|
} |
|
|
|
|
|
|
|
// Set window focused |
|
|
|
void SetWindowFocused(void) |
|
|
|
{ |
|
|
|
TRACELOG(LOG_WARNING, "SetWindowFocused() not available on target platform"); |
|
|
|
} |
|
|
|
|
|
|
|
// Get native window handle |
|
|
|
void *GetWindowHandle(void) |
|
|
|
{ |
|
|
|
TRACELOG(LOG_WARNING, "GetWindowHandle() not implemented on target platform"); |
|
|
|
return NULL; |
|
|
|
} |
|
|
|
|
|
|
|
// Get number of monitors |
|
|
|
int GetMonitorCount(void) |
|
|
|
{ |
|
|
|
TRACELOG(LOG_WARNING, "GetMonitorCount() not implemented on target platform"); |
|
|
|
return 1; |
|
|
|
} |
|
|
|
|
|
|
|
// Get number of monitors |
|
|
|
int GetCurrentMonitor(void) |
|
|
|
{ |
|
|
|
TRACELOG(LOG_WARNING, "GetCurrentMonitor() not implemented on target platform"); |
|
|
|
return 0; |
|
|
|
} |
|
|
|
|
|
|
|
// Get selected monitor position |
|
|
|
Vector2 GetMonitorPosition(int monitor) |
|
|
|
{ |
|
|
|
TRACELOG(LOG_WARNING, "GetMonitorPosition() not implemented on target platform"); |
|
|
|
return (Vector2){ 0, 0 }; |
|
|
|
} |
|
|
|
|
|
|
|
// Get selected monitor width (currently used by monitor) |
|
|
|
int GetMonitorWidth(int monitor) |
|
|
|
{ |
|
|
|
TRACELOG(LOG_WARNING, "GetMonitorWidth() not implemented on target platform"); |
|
|
|
return 0; |
|
|
|
} |
|
|
|
|
|
|
|
// Get selected monitor height (currently used by monitor) |
|
|
|
int GetMonitorHeight(int monitor) |
|
|
|
{ |
|
|
|
TRACELOG(LOG_WARNING, "GetMonitorHeight() not implemented on target platform"); |
|
|
|
return 0; |
|
|
|
} |
|
|
|
|
|
|
|
// Get selected monitor physical width in millimetres |
|
|
|
int GetMonitorPhysicalWidth(int monitor) |
|
|
|
{ |
|
|
|
TRACELOG(LOG_WARNING, "GetMonitorPhysicalWidth() not implemented on target platform"); |
|
|
|
return 0; |
|
|
|
} |
|
|
|
|
|
|
|
// Get selected monitor physical height in millimetres |
|
|
|
int GetMonitorPhysicalHeight(int monitor) |
|
|
|
{ |
|
|
|
TRACELOG(LOG_WARNING, "GetMonitorPhysicalHeight() not implemented on target platform"); |
|
|
|
return 0; |
|
|
|
} |
|
|
|
|
|
|
|
// Get selected monitor refresh rate |
|
|
|
int GetMonitorRefreshRate(int monitor) |
|
|
|
{ |
|
|
|
TRACELOG(LOG_WARNING, "GetMonitorRefreshRate() not implemented on target platform"); |
|
|
|
return 0; |
|
|
|
} |
|
|
|
|
|
|
|
// Get the human-readable, UTF-8 encoded name of the selected monitor |
|
|
|
const char *GetMonitorName(int monitor) |
|
|
|
{ |
|
|
|
TRACELOG(LOG_WARNING, "GetMonitorName() not implemented on target platform"); |
|
|
|
return ""; |
|
|
|
} |
|
|
|
|
|
|
|
// Get window position XY on monitor |
|
|
|
Vector2 GetWindowPosition(void) |
|
|
|
{ |
|
|
|
TRACELOG(LOG_WARNING, "GetWindowPosition() not implemented on target platform"); |
|
|
|
return (Vector2){ 0, 0 }; |
|
|
|
} |
|
|
|
|
|
|
|
// Get window scale DPI factor for current monitor |
|
|
|
Vector2 GetWindowScaleDPI(void) |
|
|
|
{ |
|
|
|
TRACELOG(LOG_WARNING, "GetWindowScaleDPI() not implemented on target platform"); |
|
|
|
return (Vector2){ 1.0f, 1.0f }; |
|
|
|
} |
|
|
|
|
|
|
|
// Set clipboard text content |
|
|
|
void SetClipboardText(const char *text) |
|
|
|
{ |
|
|
|
TRACELOG(LOG_WARNING, "SetClipboardText() not implemented on target platform"); |
|
|
|
} |
|
|
|
|
|
|
|
// Get clipboard text content |
|
|
|
// NOTE: returned string is allocated and freed by GLFW |
|
|
|
const char *GetClipboardText(void) |
|
|
|
{ |
|
|
|
TRACELOG(LOG_WARNING, "GetClipboardText() not implemented on target platform"); |
|
|
|
return NULL; |
|
|
|
} |
|
|
|
|
|
|
|
// Show mouse cursor |
|
|
|
void ShowCursor(void) |
|
|
|
{ |
|
|
|
CORE.Input.Mouse.cursorHidden = false; |
|
|
|
} |
|
|
|
|
|
|
|
// Hides mouse cursor |
|
|
|
void HideCursor(void) |
|
|
|
{ |
|
|
|
CORE.Input.Mouse.cursorHidden = true; |
|
|
|
} |
|
|
|
|
|
|
|
// Enables cursor (unlock cursor) |
|
|
|
void EnableCursor(void) |
|
|
|
{ |
|
|
|
// Set cursor position in the middle |
|
|
|
SetMousePosition(CORE.Window.screen.width/2, CORE.Window.screen.height/2); |
|
|
|
|
|
|
|
CORE.Input.Mouse.cursorHidden = false; |
|
|
|
} |
|
|
|
|
|
|
|
// Disables cursor (lock cursor) |
|
|
|
void DisableCursor(void) |
|
|
|
{ |
|
|
|
// Set cursor position in the middle |
|
|
|
SetMousePosition(CORE.Window.screen.width/2, CORE.Window.screen.height/2); |
|
|
|
|
|
|
|
CORE.Input.Mouse.cursorHidden = true; |
|
|
|
} |
|
|
|
|
|
|
|
// Swap back buffer with front buffer (screen drawing) |
|
|
|
void SwapScreenBuffer(void) |
|
|
|
{ |
|
|
|
SDL_GL_SwapWindow(platform.window); |
|
|
|
} |
|
|
|
|
|
|
|
//---------------------------------------------------------------------------------- |
|
|
|
// Module Functions Definition: Misc |
|
|
|
//---------------------------------------------------------------------------------- |
|
|
|
|
|
|
|
// Get elapsed time measure in seconds |
|
|
|
double GetTime(void) |
|
|
|
{ |
|
|
|
unsigned int ms = SDL_GetTicks(); // Elapsed time in milliseconds since SDL_Init() |
|
|
|
double time = (double)ms/1000; |
|
|
|
return time; |
|
|
|
} |
|
|
|
|
|
|
|
// Open URL with default system browser (if available) |
|
|
|
void OpenURL(const char *url) |
|
|
|
{ |
|
|
|
SDL_OpenURL(url); |
|
|
|
} |
|
|
|
|
|
|
|
//---------------------------------------------------------------------------------- |
|
|
|
// Module Functions Definition: Inputs |
|
|
|
//---------------------------------------------------------------------------------- |
|
|
|
|
|
|
|
// Set internal gamepad mappings |
|
|
|
int SetGamepadMappings(const char *mappings) |
|
|
|
{ |
|
|
|
TRACELOG(LOG_WARNING, "SetGamepadMappings() not implemented on target platform"); |
|
|
|
return 0; |
|
|
|
} |
|
|
|
|
|
|
|
// Set mouse position XY |
|
|
|
void SetMousePosition(int x, int y) |
|
|
|
{ |
|
|
|
CORE.Input.Mouse.currentPosition = (Vector2){ (float)x, (float)y }; |
|
|
|
CORE.Input.Mouse.previousPosition = CORE.Input.Mouse.currentPosition; |
|
|
|
} |
|
|
|
|
|
|
|
// Set mouse cursor |
|
|
|
void SetMouseCursor(int cursor) |
|
|
|
{ |
|
|
|
TRACELOG(LOG_WARNING, "SetMouseCursor() not implemented on target platform"); |
|
|
|
} |
|
|
|
|
|
|
|
// Register all input events |
|
|
|
void PollInputEvents(void) |
|
|
|
{ |
|
|
|
#if defined(SUPPORT_GESTURES_SYSTEM) |
|
|
|
// NOTE: Gestures update must be called every frame to reset gestures correctly |
|
|
|
// because ProcessGestureEvent() is just called on an event, not every frame |
|
|
|
UpdateGestures(); |
|
|
|
#endif |
|
|
|
|
|
|
|
// Reset keys/chars pressed registered |
|
|
|
CORE.Input.Keyboard.keyPressedQueueCount = 0; |
|
|
|
CORE.Input.Keyboard.charPressedQueueCount = 0; |
|
|
|
|
|
|
|
// Reset key repeats |
|
|
|
for (int i = 0; i < MAX_KEYBOARD_KEYS; i++) CORE.Input.Keyboard.keyRepeatInFrame[i] = 0; |
|
|
|
|
|
|
|
// Reset last gamepad button/axis registered state |
|
|
|
CORE.Input.Gamepad.lastButtonPressed = GAMEPAD_BUTTON_UNKNOWN; |
|
|
|
for (int i = 0; i < MAX_GAMEPADS; i++) CORE.Input.Gamepad.axisCount[i] = 0; |
|
|
|
|
|
|
|
// Register previous touch states |
|
|
|
for (int i = 0; i < MAX_TOUCH_POINTS; i++) CORE.Input.Touch.previousTouchState[i] = CORE.Input.Touch.currentTouchState[i]; |
|
|
|
|
|
|
|
// Reset touch positions |
|
|
|
// TODO: It resets on target platform the mouse position and not filled again until a move-event, |
|
|
|
// so, if mouse is not moved it returns a (0, 0) position... this behaviour should be reviewed! |
|
|
|
//for (int i = 0; i < MAX_TOUCH_POINTS; i++) CORE.Input.Touch.position[i] = (Vector2){ 0, 0 }; |
|
|
|
|
|
|
|
// Register previous keys states |
|
|
|
// NOTE: Android supports up to 260 keys |
|
|
|
for (int i = 0; i < 260; i++) |
|
|
|
{ |
|
|
|
CORE.Input.Keyboard.previousKeyState[i] = CORE.Input.Keyboard.currentKeyState[i]; |
|
|
|
CORE.Input.Keyboard.keyRepeatInFrame[i] = 0; |
|
|
|
} |
|
|
|
|
|
|
|
// Poll input events for current plaform |
|
|
|
//----------------------------------------------------------------------------- |
|
|
|
/* |
|
|
|
// WARNING: Indexes into this array are obtained by using SDL_Scancode values, not SDL_Keycode values |
|
|
|
const Uint8 *keys = SDL_GetKeyboardState(NULL); |
|
|
|
for (int i = 0; i < 256; ++i) |
|
|
|
{ |
|
|
|
CORE.Input.Keyboard.currentKeyState[i] = keys[i]; |
|
|
|
//if (keys[i]) TRACELOG(LOG_WARNING, "Pressed key: %i", i); |
|
|
|
} |
|
|
|
*/ |
|
|
|
|
|
|
|
SDL_Event event = { 0 }; |
|
|
|
while (SDL_PollEvent(&event) != 0) |
|
|
|
{ |
|
|
|
// All input events can be processed after polling |
|
|
|
switch (event.type) |
|
|
|
{ |
|
|
|
case SDL_QUIT: CORE.Window.shouldClose = true; break; |
|
|
|
|
|
|
|
// Window events are also polled (Minimized, maximized, close...) |
|
|
|
case SDL_WINDOWEVENT: |
|
|
|
{ |
|
|
|
switch (event.window.event) |
|
|
|
{ |
|
|
|
case SDL_WINDOWEVENT_LEAVE: |
|
|
|
case SDL_WINDOWEVENT_HIDDEN: |
|
|
|
case SDL_WINDOWEVENT_MINIMIZED: |
|
|
|
case SDL_WINDOWEVENT_FOCUS_LOST: |
|
|
|
case SDL_WINDOWEVENT_ENTER: |
|
|
|
case SDL_WINDOWEVENT_SHOWN: |
|
|
|
case SDL_WINDOWEVENT_FOCUS_GAINED: |
|
|
|
case SDL_WINDOWEVENT_MAXIMIZED: |
|
|
|
case SDL_WINDOWEVENT_RESTORED: |
|
|
|
default: break; |
|
|
|
} |
|
|
|
} break; |
|
|
|
|
|
|
|
// Keyboard events |
|
|
|
case SDL_KEYDOWN: |
|
|
|
{ |
|
|
|
CORE.Input.Keyboard.currentKeyState[event.key.keysym.sym] = 1; |
|
|
|
|
|
|
|
if (event.key.keysym.sym == SDLK_ESCAPE) |
|
|
|
{ |
|
|
|
CORE.Window.shouldClose = true; |
|
|
|
} |
|
|
|
} break; |
|
|
|
case SDL_KEYUP: break; |
|
|
|
|
|
|
|
// Check mouse events |
|
|
|
case SDL_MOUSEBUTTONDOWN: |
|
|
|
{ |
|
|
|
CORE.Input.Mouse.currentButtonState[event.button.button - 1] = 1; |
|
|
|
} break; |
|
|
|
case SDL_MOUSEBUTTONUP: break; |
|
|
|
case SDL_MOUSEWHEEL: |
|
|
|
{ |
|
|
|
CORE.Input.Mouse.currentWheelMove.x = (float)event.wheel.x; |
|
|
|
CORE.Input.Mouse.currentWheelMove.y = (float)event.wheel.y; |
|
|
|
} break; |
|
|
|
case SDL_MOUSEMOTION: |
|
|
|
{ |
|
|
|
CORE.Input.Mouse.currentPosition.x = (float)event.motion.x; |
|
|
|
CORE.Input.Mouse.currentPosition.y = (float)event.motion.y; |
|
|
|
} break; |
|
|
|
|
|
|
|
// Check gamepad events |
|
|
|
case SDL_JOYAXISMOTION: |
|
|
|
{ |
|
|
|
// Motion on gamepad 0 |
|
|
|
if (event.jaxis.which == 0) |
|
|
|
{ |
|
|
|
// X axis motion |
|
|
|
if (event.jaxis.axis == 0) |
|
|
|
{ |
|
|
|
//... |
|
|
|
} |
|
|
|
// Y axis motion |
|
|
|
else if (event.jaxis.axis == 1) |
|
|
|
{ |
|
|
|
//... |
|
|
|
} |
|
|
|
} |
|
|
|
} break; |
|
|
|
default: break; |
|
|
|
} |
|
|
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
//---------------------------------------------------------------------------------- |
|
|
|
// Module Internal Functions Definition |
|
|
|
//---------------------------------------------------------------------------------- |
|
|
|
|
|
|
|
// Initialize platform: graphics, inputs and more |
|
|
|
static int InitPlatform(void) |
|
|
|
{ |
|
|
|
// Initialize SDL internal global state |
|
|
|
int result = SDL_Init(SDL_INIT_EVERYTHING); |
|
|
|
if (result < 0) { TRACELOG(LOG_WARNING, "SDL: Failed to initialize SDL"); return -1; } |
|
|
|
|
|
|
|
unsigned int flags = 0; |
|
|
|
flags |= SDL_WINDOW_SHOWN; |
|
|
|
flags |= SDL_WINDOW_OPENGL; |
|
|
|
flags |= SDL_WINDOW_INPUT_FOCUS; |
|
|
|
flags |= SDL_WINDOW_MOUSE_FOCUS; |
|
|
|
flags |= SDL_WINDOW_MOUSE_CAPTURE; // Window has mouse captured |
|
|
|
|
|
|
|
// Check window creation flags |
|
|
|
if ((CORE.Window.flags & FLAG_FULLSCREEN_MODE) > 0) |
|
|
|
{ |
|
|
|
CORE.Window.fullscreen = true; |
|
|
|
flags |= SDL_WINDOW_FULLSCREEN; |
|
|
|
} |
|
|
|
|
|
|
|
//if ((CORE.Window.flags & FLAG_WINDOW_HIDDEN) == 0) flags |= SDL_WINDOW_HIDDEN; |
|
|
|
if ((CORE.Window.flags & FLAG_WINDOW_UNDECORATED) > 0) flags |= SDL_WINDOW_BORDERLESS; |
|
|
|
if ((CORE.Window.flags & FLAG_WINDOW_RESIZABLE) > 0) flags |= SDL_WINDOW_RESIZABLE; |
|
|
|
if ((CORE.Window.flags & FLAG_WINDOW_MINIMIZED) > 0) flags |= SDL_WINDOW_MINIMIZED; |
|
|
|
if ((CORE.Window.flags & FLAG_WINDOW_MAXIMIZED) > 0) flags |= SDL_WINDOW_MAXIMIZED; |
|
|
|
|
|
|
|
if ((CORE.Window.flags & FLAG_WINDOW_UNFOCUSED) > 0) |
|
|
|
{ |
|
|
|
flags &= ~SDL_WINDOW_INPUT_FOCUS; |
|
|
|
flags &= ~SDL_WINDOW_MOUSE_FOCUS; |
|
|
|
} |
|
|
|
|
|
|
|
if ((CORE.Window.flags & FLAG_WINDOW_TOPMOST) > 0) flags |= SDL_WINDOW_ALWAYS_ON_TOP; |
|
|
|
if ((CORE.Window.flags & FLAG_WINDOW_MOUSE_PASSTHROUGH) > 0) flags &= ~SDL_WINDOW_MOUSE_CAPTURE; |
|
|
|
|
|
|
|
if ((CORE.Window.flags & FLAG_WINDOW_HIGHDPI) > 0) flags |= SDL_WINDOW_ALLOW_HIGHDPI; |
|
|
|
|
|
|
|
//if ((CORE.Window.flags & FLAG_WINDOW_TRANSPARENT) > 0) flags |= SDL_WINDOW_TRANSPARENT; // Alternative: SDL_GL_ALPHA_SIZE = 8 |
|
|
|
|
|
|
|
//if ((CORE.Window.flags & FLAG_FULLSCREEN_DESKTOP) > 0) flags |= SDL_WINDOW_FULLSCREEN_DESKTOP; |
|
|
|
|
|
|
|
// NOTE: Some OpenGL context attributes must be set before window creation |
|
|
|
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3); |
|
|
|
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 3); |
|
|
|
SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE); |
|
|
|
//SDL_GL_SetAttribute(SDL_GL_CONTEXT_FLAGS, SDL_GL_CONTEXT_DEBUG_FLAG | SDL_GL_CONTEXT_FORWARD_COMPATIBLE_FLAG); |
|
|
|
if (CORE.Window.flags & FLAG_MSAA_4X_HINT) |
|
|
|
{ |
|
|
|
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 1); |
|
|
|
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, 4); |
|
|
|
} |
|
|
|
|
|
|
|
// Init window |
|
|
|
platform.window = SDL_CreateWindow(CORE.Window.title, SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, CORE.Window.screen.width, CORE.Window.screen.height, flags); |
|
|
|
|
|
|
|
// Init OpenGL context |
|
|
|
platform.glContext = SDL_GL_CreateContext(platform.window); |
|
|
|
|
|
|
|
// Check window and glContext have been initialized succesfully |
|
|
|
if ((platform.window != NULL) && (platform.glContext != NULL)) |
|
|
|
{ |
|
|
|
CORE.Window.ready = true; |
|
|
|
|
|
|
|
CORE.Window.render.width = CORE.Window.screen.width; |
|
|
|
CORE.Window.render.height = CORE.Window.screen.height; |
|
|
|
CORE.Window.currentFbo.width = CORE.Window.render.width; |
|
|
|
CORE.Window.currentFbo.height = CORE.Window.render.height; |
|
|
|
|
|
|
|
TRACELOG(LOG_INFO, "DISPLAY: Device initialized successfully"); |
|
|
|
TRACELOG(LOG_INFO, " > Display size: %i x %i", CORE.Window.display.width, CORE.Window.display.height); |
|
|
|
TRACELOG(LOG_INFO, " > Screen size: %i x %i", CORE.Window.screen.width, CORE.Window.screen.height); |
|
|
|
TRACELOG(LOG_INFO, " > Render size: %i x %i", CORE.Window.render.width, CORE.Window.render.height); |
|
|
|
TRACELOG(LOG_INFO, " > Viewport offsets: %i, %i", CORE.Window.renderOffset.x, CORE.Window.renderOffset.y); |
|
|
|
} |
|
|
|
else { TRACELOG(LOG_FATAL, "PLATFORM: Failed to initialize graphic device"); return -1; } |
|
|
|
|
|
|
|
// Load OpenGL extensions |
|
|
|
// NOTE: GL procedures address loader is required to load extensions |
|
|
|
rlLoadExtensions(SDL_GL_GetProcAddress); |
|
|
|
|
|
|
|
|
|
|
|
// Init input gamepad |
|
|
|
if (SDL_NumJoysticks() >= 1) |
|
|
|
{ |
|
|
|
SDL_Joystick *gamepad = SDL_JoystickOpen(0); |
|
|
|
//if (SDL_Joystick *gamepad == NULL) SDL_Log("WARNING: Unable to open game controller! SDL Error: %s\n", SDL_GetError()); |
|
|
|
} |
|
|
|
|
|
|
|
// Initialize hi-res timer |
|
|
|
//InitTimer(); |
|
|
|
CORE.Time.previous = GetTime(); // Get time as double |
|
|
|
|
|
|
|
// Initialize base path for storage |
|
|
|
CORE.Storage.basePath = GetWorkingDirectory(); |
|
|
|
|
|
|
|
return 0; |
|
|
|
} |
|
|
|
|
|
|
|
static void ClosePlatform(void) |
|
|
|
{ |
|
|
|
SDL_GL_DeleteContext(platform.glContext); // Deinitialize OpenGL context |
|
|
|
SDL_DestroyWindow(platform.window); |
|
|
|
SDL_Quit(); // Deinitialize SDL internal global state |
|
|
|
} |
|
|
|
// EOF |