diff --git a/CMakeLists.txt b/CMakeLists.txt
index 9619768c8941..5c65fe381a06 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,4 +1,13 @@
cmake_minimum_required(VERSION 3.0)
+
+# Directory for easier includes
+# Anywhere you see include(...) you can check <root>/cmake for that file
+set(CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake)
+
+include(CustomPlatform)
+
+custom_platform_include_if_exists("raylibPlatformCustomProjectConfig")
+
project(raylib)
# Avoid excessive expansion of variables in conditionals. In particular, if
@@ -18,9 +27,6 @@ cmake_policy(SET CMP0054 NEW)
# See https://cmake.org/cmake/help/latest/policy/CMP0063.html
cmake_policy(SET CMP0063 NEW)
-# Directory for easier includes
-# Anywhere you see include(...) you can check <root>/cmake for that file
-set(CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake)
# RAYLIB_IS_MAIN determines whether the project is being used from root
# or if it is added as a dependency (through add_subdirectory for example).
diff --git a/CMakeOptions.txt b/CMakeOptions.txt
index db0a1a1025de..80fa96889d12 100644
--- a/CMakeOptions.txt
+++ b/CMakeOptions.txt
@@ -2,7 +2,7 @@
include(CMakeDependentOption)
include(EnumOption)
-enum_option(PLATFORM "Desktop;Web;Android;Raspberry Pi;DRM" "Platform to build for.")
+enum_option(PLATFORM "Desktop;Web;Android;Raspberry Pi;DRM;Custom" "Platform to build for.")
enum_option(OPENGL_VERSION "OFF;4.3;3.3;2.1;1.1;ES 2.0;ES 3.0" "Force a specific OpenGL Version?")
diff --git a/cmake/BuildOptions.cmake b/cmake/BuildOptions.cmake
index 0fce642922f0..75fac68a22b9 100644
--- a/cmake/BuildOptions.cmake
+++ b/cmake/BuildOptions.cmake
@@ -11,7 +11,7 @@ endif()
# This helps support the case where emsdk toolchain file is used
# either by setting it with -DCMAKE_TOOLCHAIN_FILE=<path_to_emsdk>/upstream/emscripten/cmake/Modules/Platform/Emscripten.cmake
# or by using "emcmake cmake -B build -S ." as described in https://emscripten.org/docs/compiling/Building-Projects.html
-if(EMSCRIPTEN)
+if(EMSCRIPTEN AND NOT ${PLATFORM} MATCHES "Custom")
SET(PLATFORM Web CACHE STRING "Forcing PLATFORM_WEB because EMSCRIPTEN was detected")
endif()
diff --git a/cmake/CustomPlatform.cmake b/cmake/CustomPlatform.cmake
new file mode 100644
index 000000000000..edfcb39db8e1
--- /dev/null
+++ b/cmake/CustomPlatform.cmake
@@ -0,0 +1,9 @@
+macro(custom_platform_include_if_exists file)
+ if("${PLATFORM}" MATCHES "Custom")
+ if (EXISTS "${PLATFORM_CUSTOM_ROOT_DIR}/cmake/${file}.cmake")
+ include("${PLATFORM_CUSTOM_ROOT_DIR}/cmake/${file}.cmake")
+ else ()
+ message(STATUS "No file ${PLATFORM_CUSTOM_ROOT_DIR}/cmake/${file}.cmake detected... skipped")
+ endif ()
+ endif()
+endmacro()
diff --git a/cmake/LibraryConfigurations.cmake b/cmake/LibraryConfigurations.cmake
index d4bf45a08f0d..f04be6231447 100644
--- a/cmake/LibraryConfigurations.cmake
+++ b/cmake/LibraryConfigurations.cmake
@@ -91,6 +91,8 @@ elseif ("${PLATFORM}" MATCHES "DRM")
endif ()
set(LIBS_PRIVATE ${GLESV2} ${EGL} ${DRM} ${GBM} atomic pthread m dl)
+elseif ("${PLATFORM}" MATCHES "Custom")
+ set(PLATFORM_CPP "PLATFORM_CUSTOM")
endif ()
if (NOT ${OPENGL_VERSION} MATCHES "OFF")
diff --git a/external/README.md b/external/README.md
new file mode 100644
index 000000000000..ca5c62b40d2b
--- /dev/null
+++ b/external/README.md
@@ -0,0 +1,26 @@
+For the sake of this PR, this folder was added to demonstrate what a custom platform look like as well
+as how to use a custom platform
+
+* `custom_platforms/custom_platform_1`: clone of the web platform
+* `custom_platforms/custom_platform_2`: clone of the desktop platform
+
+
+* `examples/example_for_custom_platform_1`: example using the custom_platform_1
+
+ How to build (use emscripten since it is a web platform: make sure you use the proper locations)
+ ```text
+ mkdir build
+ cd build
+ cmake -DCMAKE_TOOLCHAIN_FILE=/usr/local/emsdk/upstream/emscripten/cmake/Modules/Platform/Emscripten.cmake -DEMSDK=/usr/local/emsdk -DPLATFORM=Custom -DCMAKE_BUILD_TYPE=Debug ..
+ cmake --build . --target example_for_custom_platform_1
+ ```
+
+* `examples/example_for_custom_platform_2`: example using the custom_platform_2
+
+ How to build:
+ ```text
+ mkdir build
+ cd build
+ cmake -DPLATFORM=Custom -DCMAKE_BUILD_TYPE=Debug ..
+ cmake --build . --target example_for_custom_platform_2
+ ```
diff --git a/external/custom_platforms/custom_platform_1/cmake/raylibPlatformCustomLibraryConfig.cmake b/external/custom_platforms/custom_platform_1/cmake/raylibPlatformCustomLibraryConfig.cmake
new file mode 100644
index 000000000000..3cac93e2787e
--- /dev/null
+++ b/external/custom_platforms/custom_platform_1/cmake/raylibPlatformCustomLibraryConfig.cmake
@@ -0,0 +1,5 @@
+message(STATUS "From raylibPlatformCustomLibraryConfig (Custom platform 1 (Web)")
+
+set(GRAPHICS "GRAPHICS_API_OPENGL_ES2")
+set(CMAKE_LD_FLAGS "${CMAKE_LD_FLAGS} -s USE_GLFW=3 -s ASSERTIONS=1 --profiling")
+set(CMAKE_STATIC_LIBRARY_SUFFIX ".a")
diff --git a/external/custom_platforms/custom_platform_1/cmake/raylibPlatformCustomTargetConfig.cmake b/external/custom_platforms/custom_platform_1/cmake/raylibPlatformCustomTargetConfig.cmake
new file mode 100644
index 000000000000..d1494b1d3895
--- /dev/null
+++ b/external/custom_platforms/custom_platform_1/cmake/raylibPlatformCustomTargetConfig.cmake
@@ -0,0 +1,3 @@
+message(STATUS "From raylibPlatformCustomTargetConfig (Custom platform 1 (Web)")
+
+target_link_options(raylib PRIVATE "-sUSE_GLFW=3")
diff --git a/external/custom_platforms/custom_platform_1/src/raylib_platform_custom.c b/external/custom_platforms/custom_platform_1/src/raylib_platform_custom.c
new file mode 100644
index 000000000000..f8c67a8a4b6a
--- /dev/null
+++ b/external/custom_platforms/custom_platform_1/src/raylib_platform_custom.c
@@ -0,0 +1,1319 @@
+/**********************************************************************************************
+*
+* raylib_platform_custom.c
+* rcore_web - Functions to manage window, graphics device and inputs
+*
+* PLATFORM: WEB
+* - HTML5 (WebAssembly)
+*
+* LIMITATIONS:
+* - Limitation 01
+* - Limitation 02
+*
+* POSSIBLE IMPROVEMENTS:
+* - Replace glfw3 dependency by direct browser API calls (same as library_glfw3.js)
+*
+* 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:
+* - emscripten: Allow interaction between browser API and C
+* - gestures: Gestures system for touch-ready devices (or simulated from mouse inputs)
+*
+*
+* 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.
+*
+**********************************************************************************************/
+
+#define GLFW_INCLUDE_NONE // Disable the standard OpenGL header inclusion on GLFW3
+ // NOTE: Already provided by rlgl implementation (on glad.h)
+#include "GLFW/glfw3.h" // GLFW3: Windows, OpenGL context and Input management
+
+#include <emscripten/emscripten.h> // Emscripten functionality for C
+#include <emscripten/html5.h> // Emscripten HTML5 library
+
+#include <sys/time.h> // Required for: timespec, nanosleep(), select() - POSIX
+
+//----------------------------------------------------------------------------------
+// Defines and Macros
+//----------------------------------------------------------------------------------
+// TODO: HACK: Added flag if not provided by GLFW when using external library
+// Latest GLFW release (GLFW 3.3.8) does not implement this flag, it was added for 3.4.0-dev
+#if !defined(GLFW_MOUSE_PASSTHROUGH)
+ #define GLFW_MOUSE_PASSTHROUGH 0x0002000D
+#endif
+
+#if (_POSIX_C_SOURCE < 199309L)
+ #undef _POSIX_C_SOURCE
+ #define _POSIX_C_SOURCE 199309L // Required for: CLOCK_MONOTONIC if compiled with c99 without gnu ext.
+#endif
+
+//----------------------------------------------------------------------------------
+// Types and Structures Definition
+//----------------------------------------------------------------------------------
+typedef struct {
+ GLFWwindow *handle; // GLFW window handle (graphic device)
+} PlatformData;
+
+//----------------------------------------------------------------------------------
+// Global Variables Definition
+//----------------------------------------------------------------------------------
+extern CoreData CORE; // Global CORE state context
+
+static PlatformData platform = { 0 }; // Platform specific data
+
+//----------------------------------------------------------------------------------
+// Module Internal Functions Declaration
+//----------------------------------------------------------------------------------
+int InitPlatform(void); // Initialize platform (graphics, inputs and more)
+void ClosePlatform(void); // Close platform
+
+// Error callback event
+static void ErrorCallback(int error, const char *description); // GLFW3 Error Callback, runs on GLFW3 error
+
+// Window callbacks events
+static void WindowSizeCallback(GLFWwindow *window, int width, int height); // GLFW3 WindowSize Callback, runs when window is resized
+static void WindowIconifyCallback(GLFWwindow *window, int iconified); // GLFW3 WindowIconify Callback, runs when window is minimized/restored
+//static void WindowMaximizeCallback(GLFWwindow *window, int maximized); // GLFW3 Window Maximize Callback, runs when window is maximized
+static void WindowFocusCallback(GLFWwindow *window, int focused); // GLFW3 WindowFocus Callback, runs when window get/lose focus
+static void WindowDropCallback(GLFWwindow *window, int count, const char **paths); // GLFW3 Window Drop Callback, runs when drop files into window
+
+// Input callbacks events
+static void KeyCallback(GLFWwindow *window, int key, int scancode, int action, int mods); // GLFW3 Keyboard Callback, runs on key pressed
+static void CharCallback(GLFWwindow *window, unsigned int key); // GLFW3 Char Key Callback, runs on key pressed (get char value)
+static void MouseButtonCallback(GLFWwindow *window, int button, int action, int mods); // GLFW3 Mouse Button Callback, runs on mouse button pressed
+static void MouseCursorPosCallback(GLFWwindow *window, double x, double y); // GLFW3 Cursor Position Callback, runs on mouse move
+static void MouseScrollCallback(GLFWwindow *window, double xoffset, double yoffset); // GLFW3 Srolling Callback, runs on mouse wheel
+static void CursorEnterCallback(GLFWwindow *window, int enter); // GLFW3 Cursor Enter Callback, cursor enters client area
+
+// Emscripten window callback events
+static EM_BOOL EmscriptenFullscreenChangeCallback(int eventType, const EmscriptenFullscreenChangeEvent *event, void *userData);
+static EM_BOOL EmscriptenWindowResizedCallback(int eventType, const EmscriptenUiEvent *event, void *userData);
+static EM_BOOL EmscriptenResizeCallback(int eventType, const EmscriptenUiEvent *event, void *userData);
+
+// Emscripten input callback events
+static EM_BOOL EmscriptenMouseCallback(int eventType, const EmscriptenMouseEvent *mouseEvent, void *userData);
+static EM_BOOL EmscriptenTouchCallback(int eventType, const EmscriptenTouchEvent *touchEvent, void *userData);
+static EM_BOOL EmscriptenGamepadCallback(int eventType, const EmscriptenGamepadEvent *gamepadEvent, void *userData);
+
+//----------------------------------------------------------------------------------
+// Module Functions Declaration
+//----------------------------------------------------------------------------------
+// NOTE: Functions declaration is provided by raylib.h
+
+//----------------------------------------------------------------------------------
+// Module Functions Definition: Window and Graphics Device
+//----------------------------------------------------------------------------------
+
+// Check if application should close
+bool WindowShouldClose(void)
+{
+ // Emterpreter-Async required to run sync code
+ // https://github.com/emscripten-core/emscripten/wiki/Emterpreter#emterpreter-async-run-synchronous-code
+ // By default, this function is never called on a web-ready raylib example because we encapsulate
+ // frame code in a UpdateDrawFrame() function, to allow browser manage execution asynchronously
+ // but now emscripten allows sync code to be executed in an interpreted way, using emterpreter!
+ emscripten_sleep(16);
+ return false;
+}
+
+// Toggle fullscreen mode
+void ToggleFullscreen(void)
+{
+ /*
+ EM_ASM
+ (
+ // This strategy works well while using raylib minimal web shell for emscripten,
+ // it re-scales the canvas to fullscreen using monitor resolution, for tools this
+ // is a good strategy but maybe games prefer to keep current canvas resolution and
+ // display it in fullscreen, adjusting monitor resolution if possible
+ if (document.fullscreenElement) document.exitFullscreen();
+ else Module.requestFullscreen(true, true); //false, true);
+ );
+ */
+ // EM_ASM(Module.requestFullscreen(false, false););
+ /*
+ if (!CORE.Window.fullscreen)
+ {
+ // Option 1: Request fullscreen for the canvas element
+ // This option does not seem to work at all:
+ // emscripten_request_pointerlock() and emscripten_request_fullscreen() are affected by web security,
+ // the user must click once on the canvas to hide the pointer or transition to full screen
+ //emscripten_request_fullscreen("#canvas", false);
+
+ // Option 2: Request fullscreen for the canvas element with strategy
+ // This option does not seem to work at all
+ // Ref: https://github.com/emscripten-core/emscripten/issues/5124
+ // EmscriptenFullscreenStrategy strategy = {
+ // .scaleMode = EMSCRIPTEN_FULLSCREEN_SCALE_STRETCH, //EMSCRIPTEN_FULLSCREEN_SCALE_ASPECT,
+ // .canvasResolutionScaleMode = EMSCRIPTEN_FULLSCREEN_CANVAS_SCALE_STDDEF,
+ // .filteringMode = EMSCRIPTEN_FULLSCREEN_FILTERING_DEFAULT,
+ // .canvasResizedCallback = EmscriptenWindowResizedCallback,
+ // .canvasResizedCallbackUserData = NULL
+ // };
+ //emscripten_request_fullscreen_strategy("#canvas", EM_FALSE, &strategy);
+
+ // Option 3: Request fullscreen for the canvas element with strategy
+ // It works as expected but only inside the browser (client area)
+ EmscriptenFullscreenStrategy strategy = {
+ .scaleMode = EMSCRIPTEN_FULLSCREEN_SCALE_ASPECT,
+ .canvasResolutionScaleMode = EMSCRIPTEN_FULLSCREEN_CANVAS_SCALE_STDDEF,
+ .filteringMode = EMSCRIPTEN_FULLSCREEN_FILTERING_DEFAULT,
+ .canvasResizedCallback = EmscriptenWindowResizedCallback,
+ .canvasResizedCallbackUserData = NULL
+ };
+ emscripten_enter_soft_fullscreen("#canvas", &strategy);
+
+ int width, height;
+ emscripten_get_canvas_element_size("#canvas", &width, &height);
+ TRACELOG(LOG_WARNING, "Emscripten: Enter fullscreen: Canvas size: %i x %i", width, height);
+
+ CORE.Window.fullscreen = true; // Toggle fullscreen flag
+ CORE.Window.flags |= FLAG_FULLSCREEN_MODE;
+ }
+ else
+ {
+ //emscripten_exit_fullscreen();
+ //emscripten_exit_soft_fullscreen();
+
+ int width, height;
+ emscripten_get_canvas_element_size("#canvas", &width, &height);
+ TRACELOG(LOG_WARNING, "Emscripten: Exit fullscreen: Canvas size: %i x %i", width, height);
+
+ CORE.Window.fullscreen = false; // Toggle fullscreen flag
+ CORE.Window.flags &= ~FLAG_FULLSCREEN_MODE;
+ }
+ */
+
+ CORE.Window.fullscreen = !CORE.Window.fullscreen; // Toggle fullscreen flag
+}
+
+// Toggle borderless windowed mode
+void ToggleBorderlessWindowed(void)
+{
+ TRACELOG(LOG_WARNING, "ToggleBorderlessWindowed() not available on target platform");
+}
+
+// Set window state: maximized, if resizable
+void MaximizeWindow(void)
+{
+ TRACELOG(LOG_WARNING, "MaximizeWindow() not available on target platform");
+}
+
+// Set window state: minimized
+void MinimizeWindow(void)
+{
+ TRACELOG(LOG_WARNING, "MinimizeWindow() not available on target platform");
+}
+
+// Set window state: not minimized/maximized
+void RestoreWindow(void)
+{
+ TRACELOG(LOG_WARNING, "RestoreWindow() not available on target platform");
+}
+
+// Set window configuration state using flags
+void SetWindowState(unsigned int flags)
+{
+ TRACELOG(LOG_WARNING, "SetWindowState() not available on target platform");
+}
+
+// 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, multiple images
+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;
+ emscripten_set_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;
+
+ // Trigger the resize event once to update the window minimum width and height
+ if ((CORE.Window.flags & FLAG_WINDOW_RESIZABLE) != 0) EmscriptenResizeCallback(EMSCRIPTEN_EVENT_RESIZE, NULL, NULL);
+}
+
+// Set window maximum dimensions (FLAG_WINDOW_RESIZABLE)
+void SetWindowMaxSize(int width, int height)
+{
+ CORE.Window.screenMax.width = width;
+ CORE.Window.screenMax.height = height;
+
+ // Trigger the resize event once to update the window maximum width and height
+ if ((CORE.Window.flags & FLAG_WINDOW_RESIZABLE) != 0) EmscriptenResizeCallback(EMSCRIPTEN_EVENT_RESIZE, NULL, NULL);
+}
+
+// Set window dimensions
+void SetWindowSize(int width, int height)
+{
+ glfwSetWindowSize(platform.handle, width, height);
+}
+
+// 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)
+{
+ // Security check to (partially) avoid malicious code
+ if (strchr(text, '\'') != NULL) TRACELOG(LOG_WARNING, "SYSTEM: Provided Clipboard could be potentially malicious, avoid [\'] character");
+ else EM_ASM({ navigator.clipboard.writeText(UTF8ToString($0)); }, text);
+}
+
+// Get clipboard text content
+// NOTE: returned string is allocated and freed by GLFW
+const char *GetClipboardText(void)
+{
+/*
+ // Accessing clipboard data from browser is tricky due to security reasons
+ // The method to use is navigator.clipboard.readText() but this is an asynchronous method
+ // that will return at some moment after the function is called with the required data
+ emscripten_run_script_string("navigator.clipboard.readText() \
+ .then(text => { document.getElementById('clipboard').innerText = text; console.log('Pasted content: ', text); }) \
+ .catch(err => { console.error('Failed to read clipboard contents: ', err); });"
+ );
+
+ // The main issue is getting that data, one approach could be using ASYNCIFY and wait
+ // for the data but it requires adding Asyncify emscripten library on compilation
+
+ // Another approach could be just copy the data in a HTML text field and try to retrieve it
+ // later on if available... and clean it for future accesses
+*/
+ 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)
+{
+ emscripten_exit_pointerlock();
+
+ // 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)
+{
+ // TODO: figure out how not to hard code the canvas ID here.
+ emscripten_request_pointerlock("#canvas", 1);
+
+ // 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)
+{
+ glfwSwapBuffers(platform.handle);
+}
+
+//----------------------------------------------------------------------------------
+// Module Functions Definition: Misc
+//----------------------------------------------------------------------------------
+
+// Get elapsed time measure in seconds since InitTimer()
+double GetTime(void)
+{
+ double time = glfwGetTime(); // Elapsed time since glfwInit()
+ return time;
+}
+
+// Open URL with default system browser (if available)
+// NOTE: This function is only safe to use if you control the URL given.
+// A user could craft a malicious string performing another action.
+// Only call this function yourself not with user input or make sure to check the string yourself.
+// Ref: https://github.com/raysan5/raylib/issues/686
+void OpenURL(const char *url)
+{
+ // Security check to (partially) avoid malicious code on target platform
+ if (strchr(url, '\'') != NULL) TRACELOG(LOG_WARNING, "SYSTEM: Provided URL could be potentially malicious, avoid [\'] character");
+ else emscripten_run_script(TextFormat("window.open('%s', '_blank')", url));
+}
+
+//----------------------------------------------------------------------------------
+// Module Functions Definition: Inputs
+//----------------------------------------------------------------------------------
+
+// Set internal gamepad mappings
+int SetGamepadMappings(const char *mappings)
+{
+ TRACELOG(LOG_INFO, "SetGamepadMappings not implemented in rcore_web.c");
+
+ 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;
+
+ // NOTE: emscripten not implemented
+ glfwSetCursorPos(platform.handle, CORE.Input.Mouse.currentPosition.x, CORE.Input.Mouse.currentPosition.y);
+}
+
+// Set mouse cursor
+void SetMouseCursor(int cursor)
+{
+ if (CORE.Input.Mouse.cursor != cursor)
+ {
+ const char *cursorName = NULL;
+ CORE.Input.Mouse.cursor = cursor;
+
+ switch (cursor)
+ {
+ case MOUSE_CURSOR_IBEAM: cursorName = "text"; break;
+ case MOUSE_CURSOR_CROSSHAIR: cursorName = "crosshair"; break;
+ case MOUSE_CURSOR_POINTING_HAND: cursorName = "pointer"; break;
+ case MOUSE_CURSOR_RESIZE_EW: cursorName = "ew-resize"; break;
+ case MOUSE_CURSOR_RESIZE_NS: cursorName = "ns-resize"; break;
+ case MOUSE_CURSOR_RESIZE_NWSE: cursorName = "nwse-resize"; break;
+ case MOUSE_CURSOR_RESIZE_NESW: cursorName = "nesw-resize"; break;
+ case MOUSE_CURSOR_RESIZE_ALL: cursorName = "move"; break;
+ case MOUSE_CURSOR_NOT_ALLOWED: cursorName = "not-allowed"; break;
+ case MOUSE_CURSOR_ARROW: // WARNING: It does not seem t be a specific cursor for arrow
+ case MOUSE_CURSOR_DEFAULT: cursorName = "default"; break;
+ default:
+ {
+ cursorName = "default";
+ CORE.Input.Mouse.cursor = MOUSE_CURSOR_DEFAULT;
+ } break;
+ }
+
+ // Set the cursor element on the canvas CSS
+ // The canvas is coded to the Id "canvas" on init
+ EM_ASM({document.getElementById("canvas").style.cursor = UTF8ToString($0);}, cursorName);
+ }
+}
+
+// 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 last gamepad button/axis registered state
+ CORE.Input.Gamepad.lastButtonPressed = 0; // GAMEPAD_BUTTON_UNKNOWN
+ //CORE.Input.Gamepad.axisCount = 0;
+
+ // Keyboard/Mouse input polling (automatically managed by GLFW3 through callback)
+
+ // 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.keyRepeatInFrame[i] = 0;
+ }
+
+ // Register previous mouse states
+ for (int i = 0; i < MAX_MOUSE_BUTTONS; i++) CORE.Input.Mouse.previousButtonState[i] = CORE.Input.Mouse.currentButtonState[i];
+
+ // Register previous mouse wheel state
+ CORE.Input.Mouse.previousWheelMove = CORE.Input.Mouse.currentWheelMove;
+ CORE.Input.Mouse.currentWheelMove = (Vector2){ 0.0f, 0.0f };
+
+ // Register previous mouse position
+ CORE.Input.Mouse.previousPosition = CORE.Input.Mouse.currentPosition;
+
+ // 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 };
+
+
+ // Gamepad support using emscripten API
+ // NOTE: GLFW3 joystick functionality not available in web
+
+ // Get number of gamepads connected
+ int numGamepads = 0;
+ if (emscripten_sample_gamepad_data() == EMSCRIPTEN_RESULT_SUCCESS) numGamepads = emscripten_get_num_gamepads();
+
+ for (int i = 0; (i < numGamepads) && (i < MAX_GAMEPADS); i++)
+ {
+ // Register previous gamepad button states
+ for (int k = 0; k < MAX_GAMEPAD_BUTTONS; k++) CORE.Input.Gamepad.previousButtonState[i][k] = CORE.Input.Gamepad.currentButtonState[i][k];
+
+ EmscriptenGamepadEvent gamepadState;
+
+ int result = emscripten_get_gamepad_status(i, &gamepadState);
+
+ if (result == EMSCRIPTEN_RESULT_SUCCESS)
+ {
+ // Register buttons data for every connected gamepad
+ for (int j = 0; (j < gamepadState.numButtons) && (j < MAX_GAMEPAD_BUTTONS); j++)
+ {
+ GamepadButton button = -1;
+
+ // Gamepad Buttons reference: https://www.w3.org/TR/gamepad/#gamepad-interface
+ switch (j)
+ {
+ case 0: button = GAMEPAD_BUTTON_RIGHT_FACE_DOWN; break;
+ case 1: button = GAMEPAD_BUTTON_RIGHT_FACE_RIGHT; break;
+ case 2: button = GAMEPAD_BUTTON_RIGHT_FACE_LEFT; break;
+ case 3: button = GAMEPAD_BUTTON_RIGHT_FACE_UP; break;
+ case 4: button = GAMEPAD_BUTTON_LEFT_TRIGGER_1; break;
+ case 5: button = GAMEPAD_BUTTON_RIGHT_TRIGGER_1; break;
+ case 6: button = GAMEPAD_BUTTON_LEFT_TRIGGER_2; break;
+ case 7: button = GAMEPAD_BUTTON_RIGHT_TRIGGER_2; break;
+ case 8: button = GAMEPAD_BUTTON_MIDDLE_LEFT; break;
+ case 9: button = GAMEPAD_BUTTON_MIDDLE_RIGHT; break;
+ case 10: button = GAMEPAD_BUTTON_LEFT_THUMB; break;
+ case 11: button = GAMEPAD_BUTTON_RIGHT_THUMB; break;
+ case 12: button = GAMEPAD_BUTTON_LEFT_FACE_UP; break;
+ case 13: button = GAMEPAD_BUTTON_LEFT_FACE_DOWN; break;
+ case 14: button = GAMEPAD_BUTTON_LEFT_FACE_LEFT; break;
+ case 15: button = GAMEPAD_BUTTON_LEFT_FACE_RIGHT; break;
+ default: break;
+ }
+
+ if (button != -1) // Check for valid button
+ {
+ if (gamepadState.digitalButton[j] == 1)
+ {
+ CORE.Input.Gamepad.currentButtonState[i][button] = 1;
+ CORE.Input.Gamepad.lastButtonPressed = button;
+ }
+ else CORE.Input.Gamepad.currentButtonState[i][button] = 0;
+ }
+
+ //TRACELOGD("INPUT: Gamepad %d, button %d: Digital: %d, Analog: %g", gamepadState.index, j, gamepadState.digitalButton[j], gamepadState.analogButton[j]);
+ }
+
+ // Register axis data for every connected gamepad
+ for (int j = 0; (j < gamepadState.numAxes) && (j < MAX_GAMEPAD_AXIS); j++)
+ {
+ CORE.Input.Gamepad.axisState[i][j] = gamepadState.axis[j];
+ }
+
+ CORE.Input.Gamepad.axisCount[i] = gamepadState.numAxes;
+ }
+ }
+
+ CORE.Window.resizedLastFrame = false;
+
+ // TODO: This code does not seem to do anything??
+ //if (CORE.Window.eventWaiting) glfwWaitEvents(); // Wait for in input events before continue (drawing is paused)
+ //else glfwPollEvents(); // Poll input events: keyboard/mouse/window events (callbacks) --> WARNING: Where is key input reset?
+}
+
+//----------------------------------------------------------------------------------
+// Module Internal Functions Definition
+//----------------------------------------------------------------------------------
+
+// Initialize platform: graphics, inputs and more
+int InitPlatform(void)
+{
+ TRACELOG(LOG_INFO, "InitPlatform: Custom Platform 1 (Web clone)");
+
+ glfwSetErrorCallback(ErrorCallback);
+
+ // Initialize GLFW internal global state
+ int result = glfwInit();
+ if (result == GLFW_FALSE) { TRACELOG(LOG_WARNING, "GLFW: Failed to initialize GLFW"); return -1; }
+
+ // Initialize graphic device: display/window and graphic context
+ //----------------------------------------------------------------------------
+ glfwDefaultWindowHints(); // Set default windows hints
+ // glfwWindowHint(GLFW_RED_BITS, 8); // Framebuffer red color component bits
+ // glfwWindowHint(GLFW_GREEN_BITS, 8); // Framebuffer green color component bits
+ // glfwWindowHint(GLFW_BLUE_BITS, 8); // Framebuffer blue color component bits
+ // glfwWindowHint(GLFW_ALPHA_BITS, 8); // Framebuffer alpha color component bits
+ // glfwWindowHint(GLFW_DEPTH_BITS, 24); // Depthbuffer bits
+ // glfwWindowHint(GLFW_REFRESH_RATE, 0); // Refresh rate for fullscreen window
+ // glfwWindowHint(GLFW_CLIENT_API, GLFW_OPENGL_API); // OpenGL API to use. Alternative: GLFW_OPENGL_ES_API
+ // glfwWindowHint(GLFW_AUX_BUFFERS, 0); // Number of auxiliar buffers
+
+ // Check window creation flags
+ if ((CORE.Window.flags & FLAG_FULLSCREEN_MODE) > 0) CORE.Window.fullscreen = true;
+
+ if ((CORE.Window.flags & FLAG_WINDOW_HIDDEN) > 0) glfwWindowHint(GLFW_VISIBLE, GLFW_FALSE); // Visible window
+ else glfwWindowHint(GLFW_VISIBLE, GLFW_TRUE); // Window initially hidden
+
+ if ((CORE.Window.flags & FLAG_WINDOW_UNDECORATED) > 0) glfwWindowHint(GLFW_DECORATED, GLFW_FALSE); // Border and buttons on Window
+ else glfwWindowHint(GLFW_DECORATED, GLFW_TRUE); // Decorated window
+
+ if ((CORE.Window.flags & FLAG_WINDOW_RESIZABLE) > 0) glfwWindowHint(GLFW_RESIZABLE, GLFW_TRUE); // Resizable window
+ else glfwWindowHint(GLFW_RESIZABLE, GLFW_FALSE); // Avoid window being resizable
+
+ // Disable FLAG_WINDOW_MINIMIZED, not supported on initialization
+ if ((CORE.Window.flags & FLAG_WINDOW_MINIMIZED) > 0) CORE.Window.flags &= ~FLAG_WINDOW_MINIMIZED;
+
+ // Disable FLAG_WINDOW_MAXIMIZED, not supported on initialization
+ if ((CORE.Window.flags & FLAG_WINDOW_MAXIMIZED) > 0) CORE.Window.flags &= ~FLAG_WINDOW_MAXIMIZED;
+
+ if ((CORE.Window.flags & FLAG_WINDOW_UNFOCUSED) > 0) glfwWindowHint(GLFW_FOCUSED, GLFW_FALSE);
+ else glfwWindowHint(GLFW_FOCUSED, GLFW_TRUE);
+
+ if ((CORE.Window.flags & FLAG_WINDOW_TOPMOST) > 0) glfwWindowHint(GLFW_FLOATING, GLFW_TRUE);
+ else glfwWindowHint(GLFW_FLOATING, GLFW_FALSE);
+
+ // NOTE: Some GLFW flags are not supported on HTML5
+ // e.g.: GLFW_TRANSPARENT_FRAMEBUFFER, GLFW_SCALE_TO_MONITOR, GLFW_COCOA_RETINA_FRAMEBUFFER, GLFW_MOUSE_PASSTHROUGH
+
+ if (CORE.Window.flags & FLAG_MSAA_4X_HINT)
+ {
+ // NOTE: MSAA is only enabled for main framebuffer, not user-created FBOs
+ TRACELOG(LOG_INFO, "DISPLAY: Trying to enable MSAA x4");
+ glfwWindowHint(GLFW_SAMPLES, 4); // Tries to enable multisampling x4 (MSAA), default is 0
+ }
+
+ // NOTE: When asking for an OpenGL context version, most drivers provide the highest supported version
+ // with backward compatibility to older OpenGL versions.
+ // For example, if using OpenGL 1.1, driver can provide a 4.3 backwards compatible context.
+
+ // Check selection OpenGL version
+ if (rlGetVersion() == RL_OPENGL_21)
+ {
+ glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 2); // Choose OpenGL major version (just hint)
+ glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 1); // Choose OpenGL minor version (just hint)
+ }
+ else if (rlGetVersion() == RL_OPENGL_33)
+ {
+ glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3); // Choose OpenGL major version (just hint)
+ glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3); // Choose OpenGL minor version (just hint)
+ glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); // Profiles Hint: Only 3.3 and above!
+ // Values: GLFW_OPENGL_CORE_PROFILE, GLFW_OPENGL_ANY_PROFILE, GLFW_OPENGL_COMPAT_PROFILE
+ glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GLFW_FALSE); // Forward Compatibility Hint: Only 3.3 and above!
+ // glfwWindowHint(GLFW_OPENGL_DEBUG_CONTEXT, GLFW_TRUE); // Request OpenGL DEBUG context
+ }
+ else if (rlGetVersion() == RL_OPENGL_43)
+ {
+ glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4); // Choose OpenGL major version (just hint)
+ glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3); // Choose OpenGL minor version (just hint)
+ glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
+ glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GLFW_FALSE);
+#if defined(RLGL_ENABLE_OPENGL_DEBUG_CONTEXT)
+ glfwWindowHint(GLFW_OPENGL_DEBUG_CONTEXT, GLFW_TRUE); // Enable OpenGL Debug Context
+#endif
+ }
+ else if (rlGetVersion() == RL_OPENGL_ES_20) // Request OpenGL ES 2.0 context
+ {
+ glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 2);
+ glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 0);
+ glfwWindowHint(GLFW_CLIENT_API, GLFW_OPENGL_ES_API);
+ glfwWindowHint(GLFW_CONTEXT_CREATION_API, GLFW_NATIVE_CONTEXT_API);
+ }
+ else if (rlGetVersion() == RL_OPENGL_ES_30) // Request OpenGL ES 3.0 context
+ {
+ // TODO: It seems WebGL 2.0 context is not set despite being requested
+ glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
+ glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 0);
+ glfwWindowHint(GLFW_CLIENT_API, GLFW_OPENGL_ES_API);
+ glfwWindowHint(GLFW_CONTEXT_CREATION_API, GLFW_NATIVE_CONTEXT_API);
+ }
+
+ // NOTE: Getting video modes is not implemented in emscripten GLFW3 version
+ CORE.Window.display.width = CORE.Window.screen.width;
+ CORE.Window.display.height = CORE.Window.screen.height;
+
+ if (CORE.Window.fullscreen)
+ {
+ // remember center for switchinging from fullscreen to window
+ if ((CORE.Window.screen.height == CORE.Window.display.height) && (CORE.Window.screen.width == CORE.Window.display.width))
+ {
+ // If screen width/height equal to the display, we can't calculate the window pos for toggling full-screened/windowed.
+ // Toggling full-screened/windowed with pos(0, 0) can cause problems in some platforms, such as X11.
+ CORE.Window.position.x = CORE.Window.display.width/4;
+ CORE.Window.position.y = CORE.Window.display.height/4;
+ }
+ else
+ {
+ CORE.Window.position.x = CORE.Window.display.width/2 - CORE.Window.screen.width/2;
+ CORE.Window.position.y = CORE.Window.display.height/2 - CORE.Window.screen.height/2;
+ }
+
+ if (CORE.Window.position.x < 0) CORE.Window.position.x = 0;
+ if (CORE.Window.position.y < 0) CORE.Window.position.y = 0;
+
+ // Obtain recommended CORE.Window.display.width/CORE.Window.display.height from a valid videomode for the monitor
+ int count = 0;
+ const GLFWvidmode *modes = glfwGetVideoModes(glfwGetPrimaryMonitor(), &count);
+
+ // Get closest video mode to desired CORE.Window.screen.width/CORE.Window.screen.height
+ for (int i = 0; i < count; i++)
+ {
+ if ((unsigned int)modes[i].width >= CORE.Window.screen.width)
+ {
+ if ((unsigned int)modes[i].height >= CORE.Window.screen.height)
+ {
+ CORE.Window.display.width = modes[i].width;
+ CORE.Window.display.height = modes[i].height;
+ break;
+ }
+ }
+ }
+
+ TRACELOG(LOG_WARNING, "SYSTEM: Closest fullscreen videomode: %i x %i", CORE.Window.display.width, CORE.Window.display.height);
+
+ // NOTE: ISSUE: Closest videomode could not match monitor aspect-ratio, for example,
+ // for a desired screen size of 800x450 (16:9), closest supported videomode is 800x600 (4:3),
+ // framebuffer is rendered correctly but once displayed on a 16:9 monitor, it gets stretched
+ // by the sides to fit all monitor space...
+
+ // Try to setup the most appropriate fullscreen framebuffer for the requested screenWidth/screenHeight
+ // It considers device display resolution mode and setups a framebuffer with black bars if required (render size/offset)
+ // Modified global variables: CORE.Window.screen.width/CORE.Window.screen.height - CORE.Window.render.width/CORE.Window.render.height - CORE.Window.renderOffset.x/CORE.Window.renderOffset.y - CORE.Window.screenScale
+ // TODO: It is a quite cumbersome solution to display size vs requested size, it should be reviewed or removed...
+ // HighDPI monitors are properly considered in a following similar function: SetupViewport()
+ SetupFramebuffer(CORE.Window.display.width, CORE.Window.display.height);
+
+ platform.handle = glfwCreateWindow(CORE.Window.display.width, CORE.Window.display.height, (CORE.Window.title != 0)? CORE.Window.title : " ", glfwGetPrimaryMonitor(), NULL);
+
+ // NOTE: Full-screen change, not working properly...
+ // glfwSetWindowMonitor(platform.handle, glfwGetPrimaryMonitor(), 0, 0, CORE.Window.screen.width, CORE.Window.screen.height, GLFW_DONT_CARE);
+ }
+ else
+ {
+ // No-fullscreen window creation
+ platform.handle = glfwCreateWindow(CORE.Window.screen.width, CORE.Window.screen.height, (CORE.Window.title != 0)? CORE.Window.title : " ", NULL, NULL);
+
+ if (platform.handle)
+ {
+ CORE.Window.render.width = CORE.Window.screen.width;
+ CORE.Window.render.height = CORE.Window.screen.height;
+ }
+ }
+
+ if (!platform.handle)
+ {
+ glfwTerminate();
+ TRACELOG(LOG_WARNING, "GLFW: Failed to initialize Window");
+ return -1;
+ }
+
+ // WARNING: glfwCreateWindow() title doesn't work with emscripten
+ emscripten_set_window_title((CORE.Window.title != 0)? CORE.Window.title : " ");
+
+ // Set window callback events
+ glfwSetWindowSizeCallback(platform.handle, WindowSizeCallback); // NOTE: Resizing not allowed by default!
+ glfwSetWindowIconifyCallback(platform.handle, WindowIconifyCallback);
+ glfwSetWindowFocusCallback(platform.handle, WindowFocusCallback);
+ glfwSetDropCallback(platform.handle, WindowDropCallback);
+
+ // Set input callback events
+ glfwSetKeyCallback(platform.handle, KeyCallback);
+ glfwSetCharCallback(platform.handle, CharCallback);
+ glfwSetMouseButtonCallback(platform.handle, MouseButtonCallback);
+ glfwSetCursorPosCallback(platform.handle, MouseCursorPosCallback); // Track mouse position changes
+ glfwSetScrollCallback(platform.handle, MouseScrollCallback);
+ glfwSetCursorEnterCallback(platform.handle, CursorEnterCallback);
+
+ glfwMakeContextCurrent(platform.handle);
+ result = true; // TODO: WARNING: glfwGetError(NULL); symbol can not be found in Web
+
+ // Check context activation
+ if (result == true) //(result != GLFW_NO_WINDOW_CONTEXT) && (result != GLFW_PLATFORM_ERROR))
+ {
+ CORE.Window.ready = true;
+
+ int fbWidth = CORE.Window.screen.width;
+ int fbHeight = CORE.Window.screen.height;
+
+ CORE.Window.render.width = fbWidth;
+ CORE.Window.render.height = fbHeight;
+ CORE.Window.currentFbo.width = fbWidth;
+ CORE.Window.currentFbo.height = fbHeight;
+
+ 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 graphics device");
+ return -1;
+ }
+
+ if ((CORE.Window.flags & FLAG_WINDOW_MINIMIZED) > 0) MinimizeWindow();
+
+ // If graphic device is no properly initialized, we end program
+ if (!CORE.Window.ready) { 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(glfwGetProcAddress);
+ //----------------------------------------------------------------------------
+
+ // Initialize input events callbacks
+ //----------------------------------------------------------------------------
+ // Setup callback functions for the DOM events
+ emscripten_set_fullscreenchange_callback("#canvas", NULL, 1, EmscriptenFullscreenChangeCallback);
+
+ // WARNING: Below resize code was breaking fullscreen mode for sample games and examples, it needs review
+ // Check fullscreen change events(note this is done on the window since most browsers don't support this on #canvas)
+ // emscripten_set_fullscreenchange_callback(EMSCRIPTEN_EVENT_TARGET_WINDOW, NULL, 1, EmscriptenResizeCallback);
+ // Check Resize event (note this is done on the window since most browsers don't support this on #canvas)
+ emscripten_set_resize_callback(EMSCRIPTEN_EVENT_TARGET_WINDOW, NULL, 1, EmscriptenResizeCallback);
+
+ // Trigger this once to get initial window sizing
+ EmscriptenResizeCallback(EMSCRIPTEN_EVENT_RESIZE, NULL, NULL);
+
+ // Support keyboard events -> Not used, GLFW.JS takes care of that
+ // emscripten_set_keypress_callback("#canvas", NULL, 1, EmscriptenKeyboardCallback);
+ // emscripten_set_keydown_callback("#canvas", NULL, 1, EmscriptenKeyboardCallback);
+
+ // Support mouse events
+ emscripten_set_click_callback("#canvas", NULL, 1, EmscriptenMouseCallback);
+
+ // Support touch events
+ emscripten_set_touchstart_callback("#canvas", NULL, 1, EmscriptenTouchCallback);
+ emscripten_set_touchend_callback("#canvas", NULL, 1, EmscriptenTouchCallback);
+ emscripten_set_touchmove_callback("#canvas", NULL, 1, EmscriptenTouchCallback);
+ emscripten_set_touchcancel_callback("#canvas", NULL, 1, EmscriptenTouchCallback);
+
+ // Support gamepad events (not provided by GLFW3 on emscripten)
+ emscripten_set_gamepadconnected_callback(NULL, 1, EmscriptenGamepadCallback);
+ emscripten_set_gamepaddisconnected_callback(NULL, 1, EmscriptenGamepadCallback);
+ //----------------------------------------------------------------------------
+
+ // Initialize timing system
+ //----------------------------------------------------------------------------
+ InitTimer();
+ //----------------------------------------------------------------------------
+
+ // Initialize storage system
+ //----------------------------------------------------------------------------
+ CORE.Storage.basePath = GetWorkingDirectory();
+ //----------------------------------------------------------------------------
+
+ TRACELOG(LOG_INFO, "PLATFORM: Custom 1 (Web)!!!: Initialized successfully");
+
+ return 0;
+}
+
+// Close platform
+void ClosePlatform(void)
+{
+ glfwDestroyWindow(platform.handle);
+ glfwTerminate();
+}
+
+// GLFW3 Error Callback, runs on GLFW3 error
+static void ErrorCallback(int error, const char *description)
+{
+ TRACELOG(LOG_WARNING, "GLFW: Error: %i Description: %s", error, description);
+}
+
+// GLFW3 WindowSize Callback, runs when window is resizedLastFrame
+// NOTE: Window resizing not allowed by default
+static void WindowSizeCallback(GLFWwindow *window, int width, int height)
+{
+ // Reset viewport and projection matrix for new size
+ SetupViewport(width, height);
+
+ CORE.Window.currentFbo.width = width;
+ CORE.Window.currentFbo.height = height;
+ CORE.Window.resizedLastFrame = true;
+
+ if (IsWindowFullscreen()) return;
+
+ // Set current screen size
+ if ((CORE.Window.flags & FLAG_WINDOW_HIGHDPI) > 0)
+ {
+ Vector2 windowScaleDPI = GetWindowScaleDPI();
+
+ CORE.Window.screen.width = (unsigned int)(width/windowScaleDPI.x);
+ CORE.Window.screen.height = (unsigned int)(height/windowScaleDPI.y);
+ }
+ else
+ {
+ CORE.Window.screen.width = width;
+ CORE.Window.screen.height = height;
+ }
+
+ // NOTE: Postprocessing texture is not scaled to new size
+}
+
+// GLFW3 WindowIconify Callback, runs when window is minimized/restored
+static void WindowIconifyCallback(GLFWwindow *window, int iconified)
+{
+ if (iconified) CORE.Window.flags |= FLAG_WINDOW_MINIMIZED; // The window was iconified
+ else CORE.Window.flags &= ~FLAG_WINDOW_MINIMIZED; // The window was restored
+}
+
+/*
+// GLFW3 Window Maximize Callback, runs when window is maximized
+static void WindowMaximizeCallback(GLFWwindow *window, int maximized)
+{
+ // TODO.
+}
+*/
+
+// GLFW3 WindowFocus Callback, runs when window get/lose focus
+static void WindowFocusCallback(GLFWwindow *window, int focused)
+{
+ if (focused) CORE.Window.flags &= ~FLAG_WINDOW_UNFOCUSED; // The window was focused
+ else CORE.Window.flags |= FLAG_WINDOW_UNFOCUSED; // The window lost focus
+}
+
+// GLFW3 Window Drop Callback, runs when drop files into window
+static void WindowDropCallback(GLFWwindow *window, int count, const char **paths)
+{
+ if (count > 0)
+ {
+ // In case previous dropped filepaths have not been freed, we free them
+ if (CORE.Window.dropFileCount > 0)
+ {
+ for (unsigned int i = 0; i < CORE.Window.dropFileCount; i++) RL_FREE(CORE.Window.dropFilepaths[i]);
+
+ RL_FREE(CORE.Window.dropFilepaths);
+
+ CORE.Window.dropFileCount = 0;
+ CORE.Window.dropFilepaths = NULL;
+ }
+
+ // WARNING: Paths are freed by GLFW when the callback returns, we must keep an internal copy
+ CORE.Window.dropFileCount = count;
+ CORE.Window.dropFilepaths = (char **)RL_CALLOC(CORE.Window.dropFileCount, sizeof(char *));
+
+ for (unsigned int i = 0; i < CORE.Window.dropFileCount; i++)
+ {
+ CORE.Window.dropFilepaths[i] = (char *)RL_CALLOC(MAX_FILEPATH_LENGTH, sizeof(char));
+ strcpy(CORE.Window.dropFilepaths[i], paths[i]);
+ }
+ }
+}
+
+// GLFW3 Keyboard Callback, runs on key pressed
+static void KeyCallback(GLFWwindow *window, int key, int scancode, int action, int mods)
+{
+ if (key < 0) return; // Security check, macOS fn key generates -1
+
+ // WARNING: GLFW could return GLFW_REPEAT, we need to consider it as 1
+ // to work properly with our implementation (IsKeyDown/IsKeyUp checks)
+ if (action == GLFW_RELEASE) CORE.Input.Keyboard.currentKeyState[key] = 0;
+ else if(action == GLFW_PRESS) CORE.Input.Keyboard.currentKeyState[key] = 1;
+ else if(action == GLFW_REPEAT) CORE.Input.Keyboard.keyRepeatInFrame[key] = 1;
+
+ // Check if there is space available in the key queue
+ if ((CORE.Input.Keyboard.keyPressedQueueCount < MAX_KEY_PRESSED_QUEUE) && (action == GLFW_PRESS))
+ {
+ // Add character to the queue
+ CORE.Input.Keyboard.keyPressedQueue[CORE.Input.Keyboard.keyPressedQueueCount] = key;
+ CORE.Input.Keyboard.keyPressedQueueCount++;
+ }
+
+ // Check the exit key to set close window
+ if ((key == CORE.Input.Keyboard.exitKey) && (action == GLFW_PRESS)) glfwSetWindowShouldClose(platform.handle, GLFW_TRUE);
+}
+
+// GLFW3 Char Key Callback, runs on key down (gets equivalent unicode char value)
+static void CharCallback(GLFWwindow *window, unsigned int key)
+{
+ //TRACELOG(LOG_DEBUG, "Char Callback: KEY:%i(%c)", key, key);
+
+ // NOTE: Registers any key down considering OS keyboard layout but
+ // does not detect action events, those should be managed by user...
+ // Ref: https://github.com/glfw/glfw/issues/668#issuecomment-166794907
+ // Ref: https://www.glfw.org/docs/latest/input_guide.html#input_char
+
+ // Check if there is space available in the queue
+ if (CORE.Input.Keyboard.charPressedQueueCount < MAX_CHAR_PRESSED_QUEUE)
+ {
+ // Add character to the queue
+ CORE.Input.Keyboard.charPressedQueue[CORE.Input.Keyboard.charPressedQueueCount] = key;
+ CORE.Input.Keyboard.charPressedQueueCount++;
+ }
+}
+
+// GLFW3 Mouse Button Callback, runs on mouse button pressed
+static void MouseButtonCallback(GLFWwindow *window, int button, int action, int mods)
+{
+ // WARNING: GLFW could only return GLFW_PRESS (1) or GLFW_RELEASE (0) for now,
+ // but future releases may add more actions (i.e. GLFW_REPEAT)
+ CORE.Input.Mouse.currentButtonState[button] = action;
+
+#if defined(SUPPORT_GESTURES_SYSTEM) && defined(SUPPORT_MOUSE_GESTURES)
+ // Process mouse events as touches to be able to use mouse-gestures
+ GestureEvent gestureEvent = { 0 };
+
+ // Register touch actions
+ if ((CORE.Input.Mouse.currentButtonState[button] == 1) && (CORE.Input.Mouse.previousButtonState[button] == 0)) gestureEvent.touchAction = TOUCH_ACTION_DOWN;
+ else if ((CORE.Input.Mouse.currentButtonState[button] == 0) && (CORE.Input.Mouse.previousButtonState[button] == 1)) gestureEvent.touchAction = TOUCH_ACTION_UP;
+
+ // NOTE: TOUCH_ACTION_MOVE event is registered in MouseCursorPosCallback()
+
+ // Assign a pointer ID
+ gestureEvent.pointId[0] = 0;
+
+ // Register touch points count
+ gestureEvent.pointCount = 1;
+
+ // Register touch points position, only one point registered
+ gestureEvent.position[0] = GetMousePosition();
+
+ // Normalize gestureEvent.position[0] for CORE.Window.screen.width and CORE.Window.screen.height
+ gestureEvent.position[0].x /= (float)GetScreenWidth();
+ gestureEvent.position[0].y /= (float)GetScreenHeight();
+
+ // Gesture data is sent to gestures-system for processing
+ // Prevent calling ProcessGestureEvent() when Emscripten is present and there's a touch gesture, so EmscriptenTouchCallback() can handle it itself
+ if (GetMouseX() != 0 || GetMouseY() != 0) ProcessGestureEvent(gestureEvent);
+
+#endif
+}
+
+// GLFW3 Cursor Position Callback, runs on mouse move
+static void MouseCursorPosCallback(GLFWwindow *window, double x, double y)
+{
+ CORE.Input.Mouse.currentPosition.x = (float)x;
+ CORE.Input.Mouse.currentPosition.y = (float)y;
+ CORE.Input.Touch.position[0] = CORE.Input.Mouse.currentPosition;
+
+#if defined(SUPPORT_GESTURES_SYSTEM) && defined(SUPPORT_MOUSE_GESTURES)
+ // Process mouse events as touches to be able to use mouse-gestures
+ GestureEvent gestureEvent = { 0 };
+
+ gestureEvent.touchAction = TOUCH_ACTION_MOVE;
+
+ // Assign a pointer ID
+ gestureEvent.pointId[0] = 0;
+
+ // Register touch points count
+ gestureEvent.pointCount = 1;
+
+ // Register touch points position, only one point registered
+ gestureEvent.position[0] = CORE.Input.Touch.position[0];
+
+ // Normalize gestureEvent.position[0] for CORE.Window.screen.width and CORE.Window.screen.height
+ gestureEvent.position[0].x /= (float)GetScreenWidth();
+ gestureEvent.position[0].y /= (float)GetScreenHeight();
+
+ // Gesture data is sent to gestures-system for processing
+ ProcessGestureEvent(gestureEvent);
+#endif
+}
+
+// GLFW3 Scrolling Callback, runs on mouse wheel
+static void MouseScrollCallback(GLFWwindow *window, double xoffset, double yoffset)
+{
+ CORE.Input.Mouse.currentWheelMove = (Vector2){ (float)xoffset, (float)yoffset };
+}
+
+// GLFW3 CursorEnter Callback, when cursor enters the window
+static void CursorEnterCallback(GLFWwindow *window, int enter)
+{
+ if (enter) CORE.Input.Mouse.cursorOnScreen = true;
+ else CORE.Input.Mouse.cursorOnScreen = false;
+}
+
+// Register fullscreen change events
+static EM_BOOL EmscriptenFullscreenChangeCallback(int eventType, const EmscriptenFullscreenChangeEvent *event, void *userData)
+{
+ // TODO: Implement EmscriptenFullscreenChangeCallback()?
+
+ return 1; // The event was consumed by the callback handler
+}
+
+// Register window resize event
+static EM_BOOL EmscriptenWindowResizedCallback(int eventType, const EmscriptenUiEvent *event, void *userData)
+{
+ // TODO: Implement EmscriptenWindowResizedCallback()?
+
+ return 1; // The event was consumed by the callback handler
+}
+
+EM_JS(int, GetWindowInnerWidth, (), { return window.innerWidth; });
+EM_JS(int, GetWindowInnerHeight, (), { return window.innerHeight; });
+
+// Register DOM element resize event
+static EM_BOOL EmscriptenResizeCallback(int eventType, const EmscriptenUiEvent *event, void *userData)
+{
+ // Don't resize non-resizeable windows
+ if ((CORE.Window.flags & FLAG_WINDOW_RESIZABLE) == 0) return 1;
+
+ // This event is called whenever the window changes sizes,
+ // so the size of the canvas object is explicitly retrieved below
+ int width = GetWindowInnerWidth();
+ int height = GetWindowInnerHeight();
+
+ if (width < CORE.Window.screenMin.width) width = CORE.Window.screenMin.width;
+ else if (width > CORE.Window.screenMax.width && CORE.Window.screenMax.width > 0) width = CORE.Window.screenMax.width;
+
+ if (height < CORE.Window.screenMin.height) height = CORE.Window.screenMin.height;
+ else if (height > CORE.Window.screenMax.height && CORE.Window.screenMax.height > 0) height = CORE.Window.screenMax.height;
+
+ emscripten_set_canvas_element_size("#canvas", width, height);
+
+ SetupViewport(width, height); // Reset viewport and projection matrix for new size
+
+ CORE.Window.currentFbo.width = width;
+ CORE.Window.currentFbo.height = height;
+ CORE.Window.resizedLastFrame = true;
+
+ if (IsWindowFullscreen()) return 1;
+
+ // Set current screen size
+ CORE.Window.screen.width = width;
+ CORE.Window.screen.height = height;
+
+ // NOTE: Postprocessing texture is not scaled to new size
+
+ return 0;
+}
+
+// Register mouse input events
+static EM_BOOL EmscriptenMouseCallback(int eventType, const EmscriptenMouseEvent *mouseEvent, void *userData)
+{
+ // This is only for registering mouse click events with emscripten and doesn't need to do anything
+
+ return 1; // The event was consumed by the callback handler
+}
+
+// Register connected/disconnected gamepads events
+static EM_BOOL EmscriptenGamepadCallback(int eventType, const EmscriptenGamepadEvent *gamepadEvent, void *userData)
+{
+ /*
+ TRACELOGD("%s: timeStamp: %g, connected: %d, index: %ld, numAxes: %d, numButtons: %d, id: \"%s\", mapping: \"%s\"",
+ eventType != 0? emscripten_event_type_to_string(eventType) : "Gamepad state",
+ gamepadEvent->timestamp, gamepadEvent->connected, gamepadEvent->index, gamepadEvent->numAxes, gamepadEvent->numButtons, gamepadEvent->id, gamepadEvent->mapping);
+
+ for (int i = 0; i < gamepadEvent->numAxes; ++i) TRACELOGD("Axis %d: %g", i, gamepadEvent->axis[i]);
+ for (int i = 0; i < gamepadEvent->numButtons; ++i) TRACELOGD("Button %d: Digital: %d, Analog: %g", i, gamepadEvent->digitalButton[i], gamepadEvent->analogButton[i]);
+ */
+
+ if ((gamepadEvent->connected) && (gamepadEvent->index < MAX_GAMEPADS))
+ {
+ CORE.Input.Gamepad.ready[gamepadEvent->index] = true;
+ sprintf(CORE.Input.Gamepad.name[gamepadEvent->index], "%s", gamepadEvent->id);
+ }
+ else CORE.Input.Gamepad.ready[gamepadEvent->index] = false;
+
+ return 1; // The event was consumed by the callback handler
+}
+
+// Register touch input events
+static EM_BOOL EmscriptenTouchCallback(int eventType, const EmscriptenTouchEvent *touchEvent, void *userData)
+{
+ // Register touch points count
+ CORE.Input.Touch.pointCount = touchEvent->numTouches;
+
+ double canvasWidth = 0.0;
+ double canvasHeight = 0.0;
+ // NOTE: emscripten_get_canvas_element_size() returns canvas.width and canvas.height but
+ // we are looking for actual CSS size: canvas.style.width and canvas.style.height
+ // EMSCRIPTEN_RESULT res = emscripten_get_canvas_element_size("#canvas", &canvasWidth, &canvasHeight);
+ emscripten_get_element_css_size("#canvas", &canvasWidth, &canvasHeight);
+
+ for (int i = 0; (i < CORE.Input.Touch.pointCount) && (i < MAX_TOUCH_POINTS); i++)
+ {
+ // Register touch points id
+ CORE.Input.Touch.pointId[i] = touchEvent->touches[i].identifier;
+
+ // Register touch points position
+ CORE.Input.Touch.position[i] = (Vector2){touchEvent->touches[i].targetX, touchEvent->touches[i].targetY};
+
+ // Normalize gestureEvent.position[x] for CORE.Window.screen.width and CORE.Window.screen.height
+ CORE.Input.Touch.position[i].x *= ((float)GetScreenWidth()/(float)canvasWidth);
+ CORE.Input.Touch.position[i].y *= ((float)GetScreenHeight()/(float)canvasHeight);
+
+ if (eventType == EMSCRIPTEN_EVENT_TOUCHSTART) CORE.Input.Touch.currentTouchState[i] = 1;
+ else if (eventType == EMSCRIPTEN_EVENT_TOUCHEND) CORE.Input.Touch.currentTouchState[i] = 0;
+ }
+
+#if defined(SUPPORT_GESTURES_SYSTEM)
+ GestureEvent gestureEvent = {0};
+
+ gestureEvent.pointCount = CORE.Input.Touch.pointCount;
+
+ // Register touch actions
+ if (eventType == EMSCRIPTEN_EVENT_TOUCHSTART) gestureEvent.touchAction = TOUCH_ACTION_DOWN;
+ else if (eventType == EMSCRIPTEN_EVENT_TOUCHEND) gestureEvent.touchAction = TOUCH_ACTION_UP;
+ else if (eventType == EMSCRIPTEN_EVENT_TOUCHMOVE) gestureEvent.touchAction = TOUCH_ACTION_MOVE;
+ else if (eventType == EMSCRIPTEN_EVENT_TOUCHCANCEL) gestureEvent.touchAction = TOUCH_ACTION_CANCEL;
+
+ for (int i = 0; (i < gestureEvent.pointCount) && (i < MAX_TOUCH_POINTS); i++)
+ {
+ gestureEvent.pointId[i] = CORE.Input.Touch.pointId[i];
+ gestureEvent.position[i] = CORE.Input.Touch.position[i];
+
+ // Normalize gestureEvent.position[i]
+ gestureEvent.position[i].x /= (float)GetScreenWidth();
+ gestureEvent.position[i].y /= (float)GetScreenHeight();
+ }
+
+ // Gesture data is sent to gestures system for processing
+ ProcessGestureEvent(gestureEvent);
+
+ // Reset the pointCount for web, if it was the last Touch End event
+ if (eventType == EMSCRIPTEN_EVENT_TOUCHEND && CORE.Input.Touch.pointCount == 1) CORE.Input.Touch.pointCount = 0;
+#endif
+
+ return 1; // The event was consumed by the callback handler
+}
+
+// EOF
diff --git a/external/custom_platforms/custom_platform_1/src/raylib_platform_custom.h b/external/custom_platforms/custom_platform_1/src/raylib_platform_custom.h
new file mode 100644
index 000000000000..2fe97dd78d05
--- /dev/null
+++ b/external/custom_platforms/custom_platform_1/src/raylib_platform_custom.h
@@ -0,0 +1,36 @@
+/*******************************************************************************************
+* raylib_platform_custom.h
+*
+* Custom Platform definition file
+*
+* LICENSE: zlib/libpng
+*
+* Copyright (c) 2023 Yan Pujante
+*
+* 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.
+*
+**********************************************************************************************/
+
+#ifndef RAYLIB_PLATFORM_CUSTOM_H
+#define RAYLIB_PLATFORM_CUSTOM_H
+
+#define PLATFORM_CUSTOM_ID "platform_custom_1"
+#define PLATFORM_CUSTOM_BACKEND "Platform backend: Custom Platform 1 (Web clone)"
+#define PLATFORM_CUSTOM_CLOCK_MONOTONIC
+// #define PLATFORM_CUSTOM_DISABLE_HI_RES_TIMER
+// #define PLATFORM_CUSTOM_ENABLE_OPENGL_ES2
+
+#endif //RAYLIB_PLATFORM_CUSTOM_H
diff --git a/external/custom_platforms/custom_platform_2/cmake/raylibPlatformCustomLibraryConfig.cmake b/external/custom_platforms/custom_platform_2/cmake/raylibPlatformCustomLibraryConfig.cmake
new file mode 100644
index 000000000000..c69d24ad544e
--- /dev/null
+++ b/external/custom_platforms/custom_platform_2/cmake/raylibPlatformCustomLibraryConfig.cmake
@@ -0,0 +1,70 @@
+message(STATUS "From aylibPlatformCustomLibraryConfig (Custom platform 2 (Desktop)")
+
+if (APPLE)
+ # Need to force OpenGL 3.3 on OS X
+ # See: https://github.com/raysan5/raylib/issues/341
+ set(GRAPHICS "GRAPHICS_API_OPENGL_33")
+ find_library(OPENGL_LIBRARY OpenGL)
+ set(LIBS_PRIVATE ${OPENGL_LIBRARY})
+ link_libraries("${LIBS_PRIVATE}")
+ if (NOT CMAKE_SYSTEM STRLESS "Darwin-18.0.0")
+ add_definitions(-DGL_SILENCE_DEPRECATION)
+ MESSAGE(AUTHOR_WARNING "OpenGL is deprecated starting with macOS 10.14 (Mojave)!")
+ endif ()
+elseif (WIN32)
+ add_definitions(-D_CRT_SECURE_NO_WARNINGS)
+ find_package(OpenGL QUIET)
+ set(LIBS_PRIVATE ${OPENGL_LIBRARIES} winmm)
+elseif (UNIX)
+ find_library(pthread NAMES pthread)
+ find_package(OpenGL QUIET)
+ if ("${OPENGL_LIBRARIES}" STREQUAL "")
+ set(OPENGL_LIBRARIES "GL")
+ endif ()
+
+ if ("${CMAKE_SYSTEM_NAME}" MATCHES "(Net|Open)BSD")
+ find_library(OSS_LIBRARY ossaudio)
+ endif ()
+
+ set(LIBS_PRIVATE m pthread ${OPENGL_LIBRARIES} ${OSS_LIBRARY})
+else ()
+ find_library(pthread NAMES pthread)
+ find_package(OpenGL QUIET)
+ if ("${OPENGL_LIBRARIES}" STREQUAL "")
+ set(OPENGL_LIBRARIES "GL")
+ endif ()
+
+ set(LIBS_PRIVATE m atomic pthread ${OPENGL_LIBRARIES} ${OSS_LIBRARY})
+
+ if ("${CMAKE_SYSTEM_NAME}" MATCHES "(Net|Open)BSD")
+ find_library(OSS_LIBRARY ossaudio)
+ set(LIBS_PRIVATE m pthread ${OPENGL_LIBRARIES} ${OSS_LIBRARY})
+ endif ()
+
+ if (NOT "${CMAKE_SYSTEM_NAME}" MATCHES "(Net|Open)BSD" AND USE_AUDIO)
+ set(LIBS_PRIVATE ${LIBS_PRIVATE} dl)
+ endif ()
+endif ()
+
+if("${GLFW_ROOT_DIR}" STREQUAL "")
+ message(FATAL_ERROR "This platform requires glfw. Provide its location via GLFW_ROOT_DIR")
+endif()
+
+message(STATUS "Using glfw from ${GLFW_ROOT_DIR}")
+set(GLFW_BUILD_DOCS OFF CACHE BOOL "" FORCE)
+set(GLFW_BUILD_TESTS OFF CACHE BOOL "" FORCE)
+set(GLFW_BUILD_EXAMPLES OFF CACHE BOOL "" FORCE)
+set(GLFW_INSTALL OFF CACHE BOOL "" FORCE)
+set(GLFW_USE_WAYLAND ${USE_WAYLAND} CACHE BOOL "" FORCE)
+set(GLFW_LIBRARY_TYPE "STATIC" CACHE STRING "" FORCE)
+
+add_subdirectory("${GLFW_ROOT_DIR}")
+
+# Hide glfw's symbols when building a shared lib
+if (BUILD_SHARED_LIBS)
+ set_property(TARGET glfw PROPERTY C_VISIBILITY_PRESET hidden)
+endif()
+
+include_directories(BEFORE SYSTEM "${GLFW_ROOT_DIR}/include")
+
+set(LIBS_PRIVATE ${LIBS_PRIVATE} glfw)
diff --git a/external/custom_platforms/custom_platform_2/cmake/raylibPlatformCustomProjectConfig.cmake b/external/custom_platforms/custom_platform_2/cmake/raylibPlatformCustomProjectConfig.cmake
new file mode 100644
index 000000000000..3506bceac359
--- /dev/null
+++ b/external/custom_platforms/custom_platform_2/cmake/raylibPlatformCustomProjectConfig.cmake
@@ -0,0 +1,12 @@
+message(STATUS "From raylibPlatformCustomProjectConfig (Custom platform 2 (Desktop)")
+
+# Note that changing CMAKE_OSX_ARCHITECTURES should be done BEFORE project()
+if(APPLE)
+ if(MACOS_FATLIB)
+ if (CMAKE_OSX_ARCHITECTURES)
+ message(FATAL_ERROR "User supplied -DCMAKE_OSX_ARCHITECTURES overrides -DMACOS_FATLIB=ON")
+ else()
+ set(CMAKE_OSX_ARCHITECTURES "x86_64;i386")
+ endif()
+ endif()
+endif()
diff --git a/external/custom_platforms/custom_platform_2/src/raylib_platform_custom.c b/external/custom_platforms/custom_platform_2/src/raylib_platform_custom.c
new file mode 100644
index 000000000000..db95fbd3bf98
--- /dev/null
+++ b/external/custom_platforms/custom_platform_2/src/raylib_platform_custom.c
@@ -0,0 +1,1830 @@
+/**********************************************************************************************
+*
+* raylib_platform_custom.c
+*
+* PLATFORM: DESKTOP: GLFW
+* - 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:
+* - rglfw: Manage graphic device, OpenGL context and inputs (Windows, Linux, OSX, FreeBSD...)
+* - gestures: Gestures system for touch-ready devices (or simulated from mouse inputs)
+*
+*
+* 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.
+*
+**********************************************************************************************/
+
+#define GLFW_INCLUDE_NONE // Disable the standard OpenGL header inclusion on GLFW3
+// NOTE: Already provided by rlgl implementation (on glad.h)
+#include "GLFW/glfw3.h" // GLFW3 library: Windows, OpenGL context and Input management
+// NOTE: GLFW3 already includes gl.h (OpenGL) headers
+
+// Support retrieving native window handlers
+#if defined(_WIN32)
+typedef void *PVOID;
+ typedef PVOID HANDLE;
+ typedef HANDLE HWND;
+ #define GLFW_EXPOSE_NATIVE_WIN32
+ #define GLFW_NATIVE_INCLUDE_NONE // To avoid some symbols re-definition in windows.h
+ #include "GLFW/glfw3native.h"
+
+ #if defined(SUPPORT_WINMM_HIGHRES_TIMER) && !defined(SUPPORT_BUSY_WAIT_LOOP)
+ // NOTE: Those functions require linking with winmm library
+ unsigned int __stdcall timeBeginPeriod(unsigned int uPeriod);
+ unsigned int __stdcall timeEndPeriod(unsigned int uPeriod);
+ #endif
+#endif
+#if defined(__linux__) || defined(__FreeBSD__) || defined(__OpenBSD__)
+#include <sys/time.h> // Required for: timespec, nanosleep(), select() - POSIX
+
+ //#define GLFW_EXPOSE_NATIVE_X11 // WARNING: Exposing Xlib.h > X.h results in dup symbols for Font type
+ //#define GLFW_EXPOSE_NATIVE_WAYLAND
+ //#define GLFW_EXPOSE_NATIVE_MIR
+ #include "GLFW/glfw3native.h" // Required for: glfwGetX11Window()
+#endif
+#if defined(__APPLE__)
+#include <unistd.h> // Required for: usleep()
+
+ //#define GLFW_EXPOSE_NATIVE_COCOA // WARNING: Fails due to type redefinition
+ void *glfwGetCocoaWindow(GLFWwindow* handle);
+ #include "GLFW/glfw3native.h" // Required for: glfwGetCocoaWindow()
+#endif
+
+//----------------------------------------------------------------------------------
+// Defines and Macros
+//----------------------------------------------------------------------------------
+// TODO: HACK: Added flag if not provided by GLFW when using external library
+// Latest GLFW release (GLFW 3.3.8) does not implement this flag, it was added for 3.4.0-dev
+#if !defined(GLFW_MOUSE_PASSTHROUGH)
+#define GLFW_MOUSE_PASSTHROUGH 0x0002000D
+#endif
+
+//----------------------------------------------------------------------------------
+// Types and Structures Definition
+//----------------------------------------------------------------------------------
+typedef struct {
+ GLFWwindow *handle; // GLFW window handle (graphic device)
+} PlatformData;
+
+//----------------------------------------------------------------------------------
+// Global Variables Definition
+//----------------------------------------------------------------------------------
+extern CoreData CORE; // Global CORE state context
+
+static PlatformData platform = { 0 }; // Platform specific data
+
+//----------------------------------------------------------------------------------
+// Module Internal Functions Declaration
+//----------------------------------------------------------------------------------
+int InitPlatform(void); // Initialize platform (graphics, inputs and more)
+void ClosePlatform(void); // Close platform
+
+// Error callback event
+static void ErrorCallback(int error, const char *description); // GLFW3 Error Callback, runs on GLFW3 error
+
+// Window callbacks events
+static void WindowSizeCallback(GLFWwindow *window, int width, int height); // GLFW3 WindowSize Callback, runs when window is resized
+static void WindowIconifyCallback(GLFWwindow *window, int iconified); // GLFW3 WindowIconify Callback, runs when window is minimized/restored
+static void WindowMaximizeCallback(GLFWwindow* window, int maximized); // GLFW3 Window Maximize Callback, runs when window is maximized
+static void WindowFocusCallback(GLFWwindow *window, int focused); // GLFW3 WindowFocus Callback, runs when window get/lose focus
+static void WindowDropCallback(GLFWwindow *window, int count, const char **paths); // GLFW3 Window Drop Callback, runs when drop files into window
+
+// Input callbacks events
+static void KeyCallback(GLFWwindow *window, int key, int scancode, int action, int mods); // GLFW3 Keyboard Callback, runs on key pressed
+static void CharCallback(GLFWwindow *window, unsigned int key); // GLFW3 Char Key Callback, runs on key pressed (get char value)
+static void MouseButtonCallback(GLFWwindow *window, int button, int action, int mods); // GLFW3 Mouse Button Callback, runs on mouse button pressed
+static void MouseCursorPosCallback(GLFWwindow *window, double x, double y); // GLFW3 Cursor Position Callback, runs on mouse move
+static void MouseScrollCallback(GLFWwindow *window, double xoffset, double yoffset); // GLFW3 Scrolling Callback, runs on mouse wheel
+static void CursorEnterCallback(GLFWwindow *window, int enter); // GLFW3 Cursor Enter Callback, cursor enters client area
+static void JoystickCallback(int jid, int event); // GLFW3 Joystick Connected/Disconnected Callback
+
+//----------------------------------------------------------------------------------
+// Module Functions Declaration
+//----------------------------------------------------------------------------------
+// NOTE: Functions declaration is provided by raylib.h
+
+//----------------------------------------------------------------------------------
+// Module Functions Definition: Window and Graphics Device
+//----------------------------------------------------------------------------------
+
+// Check if application should close
+// NOTE: By default, if KEY_ESCAPE pressed or window close icon clicked
+bool WindowShouldClose(void)
+{
+ if (CORE.Window.ready) return CORE.Window.shouldClose;
+ else return true;
+}
+
+// Toggle fullscreen mode
+void ToggleFullscreen(void)
+{
+ if (!CORE.Window.fullscreen)
+ {
+ // Store previous window position (in case we exit fullscreen)
+ glfwGetWindowPos(platform.handle, &CORE.Window.position.x, &CORE.Window.position.y);
+
+ int monitorCount = 0;
+ int monitorIndex = GetCurrentMonitor();
+ GLFWmonitor **monitors = glfwGetMonitors(&monitorCount);
+
+ // Use current monitor, so we correctly get the display the window is on
+ GLFWmonitor *monitor = (monitorIndex < monitorCount)? monitors[monitorIndex] : NULL;
+
+ if (monitor == NULL)
+ {
+ TRACELOG(LOG_WARNING, "GLFW: Failed to get monitor");
+
+ CORE.Window.fullscreen = false;
+ CORE.Window.flags &= ~FLAG_FULLSCREEN_MODE;
+
+ glfwSetWindowMonitor(platform.handle, NULL, 0, 0, CORE.Window.screen.width, CORE.Window.screen.height, GLFW_DONT_CARE);
+ }
+ else
+ {
+ CORE.Window.fullscreen = true;
+ CORE.Window.flags |= FLAG_FULLSCREEN_MODE;
+
+ glfwSetWindowMonitor(platform.handle, monitor, 0, 0, CORE.Window.screen.width, CORE.Window.screen.height, GLFW_DONT_CARE);
+ }
+
+ }
+ else
+ {
+ CORE.Window.fullscreen = false;
+ CORE.Window.flags &= ~FLAG_FULLSCREEN_MODE;
+
+ glfwSetWindowMonitor(platform.handle, NULL, CORE.Window.position.x, CORE.Window.position.y, CORE.Window.screen.width, CORE.Window.screen.height, GLFW_DONT_CARE);
+ }
+
+ // Try to enable GPU V-Sync, so frames are limited to screen refresh rate (60Hz -> 60 FPS)
+ // NOTE: V-Sync can be enabled by graphic driver configuration
+ if (CORE.Window.flags & FLAG_VSYNC_HINT) glfwSwapInterval(1);
+}
+
+// Toggle borderless windowed mode
+void ToggleBorderlessWindowed(void)
+{
+ // Leave fullscreen before attempting to set borderless windowed mode and get screen position from it
+ bool wasOnFullscreen = false;
+ if (CORE.Window.fullscreen)
+ {
+ CORE.Window.previousPosition = CORE.Window.position;
+ ToggleFullscreen();
+ wasOnFullscreen = true;
+ }
+
+ const int monitor = GetCurrentMonitor();
+ int monitorCount;
+ GLFWmonitor **monitors = glfwGetMonitors(&monitorCount);
+
+ if ((monitor >= 0) && (monitor < monitorCount))
+ {
+ const GLFWvidmode *mode = glfwGetVideoMode(monitors[monitor]);
+
+ if (mode)
+ {
+ if (!IsWindowState(FLAG_BORDERLESS_WINDOWED_MODE))
+ {
+ // Store screen position and size
+ // NOTE: If it was on fullscreen, screen position was already stored, so skip setting it here
+ if (!wasOnFullscreen) glfwGetWindowPos(platform.handle, &CORE.Window.previousPosition.x, &CORE.Window.previousPosition.y);
+ CORE.Window.previousScreen = CORE.Window.screen;
+
+ // Set undecorated and topmost modes and flags
+ glfwSetWindowAttrib(platform.handle, GLFW_DECORATED, GLFW_FALSE);
+ CORE.Window.flags |= FLAG_WINDOW_UNDECORATED;
+ glfwSetWindowAttrib(platform.handle, GLFW_FLOATING, GLFW_TRUE);
+ CORE.Window.flags |= FLAG_WINDOW_TOPMOST;
+
+ // Get monitor position and size
+ int monitorPosX = 0;
+ int monitorPosY = 0;
+ glfwGetMonitorPos(monitors[monitor], &monitorPosX, &monitorPosY);
+ const int monitorWidth = mode->width;
+ const int monitorHeight = mode->height;
+
+ // Set screen position and size
+ glfwSetWindowPos(platform.handle, monitorPosX, monitorPosY);
+ glfwSetWindowSize(platform.handle, monitorWidth, monitorHeight);
+
+ // Refocus window
+ glfwFocusWindow(platform.handle);
+
+ CORE.Window.flags |= FLAG_BORDERLESS_WINDOWED_MODE;
+ }
+ else
+ {
+ // Remove topmost and undecorated modes and flags
+ glfwSetWindowAttrib(platform.handle, GLFW_FLOATING, GLFW_FALSE);
+ CORE.Window.flags &= ~FLAG_WINDOW_TOPMOST;
+ glfwSetWindowAttrib(platform.handle, GLFW_DECORATED, GLFW_TRUE);
+ CORE.Window.flags &= ~FLAG_WINDOW_UNDECORATED;
+
+ // Return previous screen size and position
+ // NOTE: The order matters here, it must set size first, then set position, otherwise the screen will be positioned incorrectly
+ glfwSetWindowSize(platform.handle, CORE.Window.previousScreen.width, CORE.Window.previousScreen.height);
+ glfwSetWindowPos(platform.handle, CORE.Window.previousPosition.x, CORE.Window.previousPosition.y);
+
+ // Refocus window
+ glfwFocusWindow(platform.handle);
+
+ CORE.Window.flags &= ~FLAG_BORDERLESS_WINDOWED_MODE;
+ }
+ }
+ else TRACELOG(LOG_WARNING, "GLFW: Failed to find video mode for selected monitor");
+ }
+ else TRACELOG(LOG_WARNING, "GLFW: Failed to find selected monitor");
+}
+
+// Set window state: maximized, if resizable
+void MaximizeWindow(void)
+{
+ if (glfwGetWindowAttrib(platform.handle, GLFW_RESIZABLE) == GLFW_TRUE)
+ {
+ glfwMaximizeWindow(platform.handle);
+ CORE.Window.flags |= FLAG_WINDOW_MAXIMIZED;
+ }
+}
+
+// Set window state: minimized
+void MinimizeWindow(void)
+{
+ // NOTE: Following function launches callback that sets appropriate flag!
+ glfwIconifyWindow(platform.handle);
+}
+
+// Set window state: not minimized/maximized
+void RestoreWindow(void)
+{
+ if (glfwGetWindowAttrib(platform.handle, GLFW_RESIZABLE) == GLFW_TRUE)
+ {
+ // Restores the specified window if it was previously iconified (minimized) or maximized
+ glfwRestoreWindow(platform.handle);
+ CORE.Window.flags &= ~FLAG_WINDOW_MINIMIZED;
+ CORE.Window.flags &= ~FLAG_WINDOW_MAXIMIZED;
+ }
+}
+
+// Set window configuration state using flags
+void SetWindowState(unsigned int flags)
+{
+ // Check previous state and requested state to apply required changes
+ // NOTE: In most cases the functions already change the flags internally
+
+ // State change: FLAG_VSYNC_HINT
+ if (((CORE.Window.flags & FLAG_VSYNC_HINT) != (flags & FLAG_VSYNC_HINT)) && ((flags & FLAG_VSYNC_HINT) > 0))
+ {
+ glfwSwapInterval(1);
+ CORE.Window.flags |= FLAG_VSYNC_HINT;
+ }
+
+ // State change: FLAG_BORDERLESS_WINDOWED_MODE
+ // NOTE: This must be handled before FLAG_FULLSCREEN_MODE because ToggleBorderlessWindowed() needs to get some fullscreen values if fullscreen is running
+ if (((CORE.Window.flags & FLAG_BORDERLESS_WINDOWED_MODE) != (flags & FLAG_BORDERLESS_WINDOWED_MODE)) && ((flags & FLAG_BORDERLESS_WINDOWED_MODE) > 0))
+ {
+ ToggleBorderlessWindowed(); // NOTE: Window state flag updated inside function
+ }
+
+ // State change: FLAG_FULLSCREEN_MODE
+ if ((CORE.Window.flags & FLAG_FULLSCREEN_MODE) != (flags & FLAG_FULLSCREEN_MODE))
+ {
+ ToggleFullscreen(); // NOTE: Window state flag updated inside function
+ }
+
+ // State change: FLAG_WINDOW_RESIZABLE
+ if (((CORE.Window.flags & FLAG_WINDOW_RESIZABLE) != (flags & FLAG_WINDOW_RESIZABLE)) && ((flags & FLAG_WINDOW_RESIZABLE) > 0))
+ {
+ glfwSetWindowAttrib(platform.handle, GLFW_RESIZABLE, GLFW_TRUE);
+ CORE.Window.flags |= FLAG_WINDOW_RESIZABLE;
+ }
+
+ // State change: FLAG_WINDOW_UNDECORATED
+ if (((CORE.Window.flags & FLAG_WINDOW_UNDECORATED) != (flags & FLAG_WINDOW_UNDECORATED)) && (flags & FLAG_WINDOW_UNDECORATED))
+ {
+ glfwSetWindowAttrib(platform.handle, GLFW_DECORATED, GLFW_FALSE);
+ CORE.Window.flags |= FLAG_WINDOW_UNDECORATED;
+ }
+
+ // State change: FLAG_WINDOW_HIDDEN
+ if (((CORE.Window.flags & FLAG_WINDOW_HIDDEN) != (flags & FLAG_WINDOW_HIDDEN)) && ((flags & FLAG_WINDOW_HIDDEN) > 0))
+ {
+ glfwHideWindow(platform.handle);
+ CORE.Window.flags |= FLAG_WINDOW_HIDDEN;
+ }
+
+ // State change: FLAG_WINDOW_MINIMIZED
+ if (((CORE.Window.flags & FLAG_WINDOW_MINIMIZED) != (flags & FLAG_WINDOW_MINIMIZED)) && ((flags & FLAG_WINDOW_MINIMIZED) > 0))
+ {
+ //GLFW_ICONIFIED
+ MinimizeWindow(); // NOTE: Window state flag updated inside function
+ }
+
+ // State change: FLAG_WINDOW_MAXIMIZED
+ if (((CORE.Window.flags & FLAG_WINDOW_MAXIMIZED) != (flags & FLAG_WINDOW_MAXIMIZED)) && ((flags & FLAG_WINDOW_MAXIMIZED) > 0))
+ {
+ //GLFW_MAXIMIZED
+ MaximizeWindow(); // NOTE: Window state flag updated inside function
+ }
+
+ // State change: FLAG_WINDOW_UNFOCUSED
+ if (((CORE.Window.flags & FLAG_WINDOW_UNFOCUSED) != (flags & FLAG_WINDOW_UNFOCUSED)) && ((flags & FLAG_WINDOW_UNFOCUSED) > 0))
+ {
+ glfwSetWindowAttrib(platform.handle, GLFW_FOCUS_ON_SHOW, GLFW_FALSE);
+ CORE.Window.flags |= FLAG_WINDOW_UNFOCUSED;
+ }
+
+ // State change: FLAG_WINDOW_TOPMOST
+ if (((CORE.Window.flags & FLAG_WINDOW_TOPMOST) != (flags & FLAG_WINDOW_TOPMOST)) && ((flags & FLAG_WINDOW_TOPMOST) > 0))
+ {
+ glfwSetWindowAttrib(platform.handle, GLFW_FLOATING, GLFW_TRUE);
+ CORE.Window.flags |= FLAG_WINDOW_TOPMOST;
+ }
+
+ // State change: FLAG_WINDOW_ALWAYS_RUN
+ if (((CORE.Window.flags & FLAG_WINDOW_ALWAYS_RUN) != (flags & FLAG_WINDOW_ALWAYS_RUN)) && ((flags & FLAG_WINDOW_ALWAYS_RUN) > 0))
+ {
+ CORE.Window.flags |= FLAG_WINDOW_ALWAYS_RUN;
+ }
+
+ // The following states can not be changed after window creation
+
+ // State change: FLAG_WINDOW_TRANSPARENT
+ if (((CORE.Window.flags & FLAG_WINDOW_TRANSPARENT) != (flags & FLAG_WINDOW_TRANSPARENT)) && ((flags & FLAG_WINDOW_TRANSPARENT) > 0))
+ {
+ TRACELOG(LOG_WARNING, "WINDOW: Framebuffer transparency can only be configured before window initialization");
+ }
+
+ // State change: FLAG_WINDOW_HIGHDPI
+ if (((CORE.Window.flags & FLAG_WINDOW_HIGHDPI) != (flags & FLAG_WINDOW_HIGHDPI)) && ((flags & FLAG_WINDOW_HIGHDPI) > 0))
+ {
+ TRACELOG(LOG_WARNING, "WINDOW: High DPI can only be configured before window initialization");
+ }
+
+ // State change: FLAG_WINDOW_MOUSE_PASSTHROUGH
+ if (((CORE.Window.flags & FLAG_WINDOW_MOUSE_PASSTHROUGH) != (flags & FLAG_WINDOW_MOUSE_PASSTHROUGH)) && ((flags & FLAG_WINDOW_MOUSE_PASSTHROUGH) > 0))
+ {
+ glfwSetWindowAttrib(platform.handle, GLFW_MOUSE_PASSTHROUGH, GLFW_TRUE);
+ CORE.Window.flags |= FLAG_WINDOW_MOUSE_PASSTHROUGH;
+ }
+
+ // State change: FLAG_MSAA_4X_HINT
+ if (((CORE.Window.flags & FLAG_MSAA_4X_HINT) != (flags & FLAG_MSAA_4X_HINT)) && ((flags & FLAG_MSAA_4X_HINT) > 0))
+ {
+ TRACELOG(LOG_WARNING, "WINDOW: MSAA can only be configured before window initialization");
+ }
+
+ // State change: FLAG_INTERLACED_HINT
+ if (((CORE.Window.flags & FLAG_INTERLACED_HINT) != (flags & FLAG_INTERLACED_HINT)) && ((flags & FLAG_INTERLACED_HINT) > 0))
+ {
+ TRACELOG(LOG_WARNING, "RPI: Interlaced mode can only be configured before window initialization");
+ }
+}
+
+// Clear window configuration state flags
+void ClearWindowState(unsigned int flags)
+{
+ // Check previous state and requested state to apply required changes
+ // NOTE: In most cases the functions already change the flags internally
+
+ // State change: FLAG_VSYNC_HINT
+ if (((CORE.Window.flags & FLAG_VSYNC_HINT) > 0) && ((flags & FLAG_VSYNC_HINT) > 0))
+ {
+ glfwSwapInterval(0);
+ CORE.Window.flags &= ~FLAG_VSYNC_HINT;
+ }
+
+ // State change: FLAG_BORDERLESS_WINDOWED_MODE
+ // NOTE: This must be handled before FLAG_FULLSCREEN_MODE because ToggleBorderlessWindowed() needs to get some fullscreen values if fullscreen is running
+ if (((CORE.Window.flags & FLAG_BORDERLESS_WINDOWED_MODE) > 0) && ((flags & FLAG_BORDERLESS_WINDOWED_MODE) > 0))
+ {
+ ToggleBorderlessWindowed(); // NOTE: Window state flag updated inside function
+ }
+
+ // State change: FLAG_FULLSCREEN_MODE
+ if (((CORE.Window.flags & FLAG_FULLSCREEN_MODE) > 0) && ((flags & FLAG_FULLSCREEN_MODE) > 0))
+ {
+ ToggleFullscreen(); // NOTE: Window state flag updated inside function
+ }
+
+ // State change: FLAG_WINDOW_RESIZABLE
+ if (((CORE.Window.flags & FLAG_WINDOW_RESIZABLE) > 0) && ((flags & FLAG_WINDOW_RESIZABLE) > 0))
+ {
+ glfwSetWindowAttrib(platform.handle, GLFW_RESIZABLE, GLFW_FALSE);
+ CORE.Window.flags &= ~FLAG_WINDOW_RESIZABLE;
+ }
+
+ // State change: FLAG_WINDOW_HIDDEN
+ if (((CORE.Window.flags & FLAG_WINDOW_HIDDEN) > 0) && ((flags & FLAG_WINDOW_HIDDEN) > 0))
+ {
+ glfwShowWindow(platform.handle);
+ CORE.Window.flags &= ~FLAG_WINDOW_HIDDEN;
+ }
+
+ // State change: FLAG_WINDOW_MINIMIZED
+ if (((CORE.Window.flags & FLAG_WINDOW_MINIMIZED) > 0) && ((flags & FLAG_WINDOW_MINIMIZED) > 0))
+ {
+ RestoreWindow(); // NOTE: Window state flag updated inside function
+ }
+
+ // State change: FLAG_WINDOW_MAXIMIZED
+ if (((CORE.Window.flags & FLAG_WINDOW_MAXIMIZED) > 0) && ((flags & FLAG_WINDOW_MAXIMIZED) > 0))
+ {
+ RestoreWindow(); // NOTE: Window state flag updated inside function
+ }
+
+ // State change: FLAG_WINDOW_UNDECORATED
+ if (((CORE.Window.flags & FLAG_WINDOW_UNDECORATED) > 0) && ((flags & FLAG_WINDOW_UNDECORATED) > 0))
+ {
+ glfwSetWindowAttrib(platform.handle, GLFW_DECORATED, GLFW_TRUE);
+ CORE.Window.flags &= ~FLAG_WINDOW_UNDECORATED;
+ }
+
+ // State change: FLAG_WINDOW_UNFOCUSED
+ if (((CORE.Window.flags & FLAG_WINDOW_UNFOCUSED) > 0) && ((flags & FLAG_WINDOW_UNFOCUSED) > 0))
+ {
+ glfwSetWindowAttrib(platform.handle, GLFW_FOCUS_ON_SHOW, GLFW_TRUE);
+ CORE.Window.flags &= ~FLAG_WINDOW_UNFOCUSED;
+ }
+
+ // State change: FLAG_WINDOW_TOPMOST
+ if (((CORE.Window.flags & FLAG_WINDOW_TOPMOST) > 0) && ((flags & FLAG_WINDOW_TOPMOST) > 0))
+ {
+ glfwSetWindowAttrib(platform.handle, GLFW_FLOATING, GLFW_FALSE);
+ CORE.Window.flags &= ~FLAG_WINDOW_TOPMOST;
+ }
+
+ // State change: FLAG_WINDOW_ALWAYS_RUN
+ if (((CORE.Window.flags & FLAG_WINDOW_ALWAYS_RUN) > 0) && ((flags & FLAG_WINDOW_ALWAYS_RUN) > 0))
+ {
+ CORE.Window.flags &= ~FLAG_WINDOW_ALWAYS_RUN;
+ }
+
+ // The following states can not be changed after window creation
+
+ // State change: FLAG_WINDOW_TRANSPARENT
+ if (((CORE.Window.flags & FLAG_WINDOW_TRANSPARENT) > 0) && ((flags & FLAG_WINDOW_TRANSPARENT) > 0))
+ {
+ TRACELOG(LOG_WARNING, "WINDOW: Framebuffer transparency can only be configured before window initialization");
+ }
+
+ // State change: FLAG_WINDOW_HIGHDPI
+ if (((CORE.Window.flags & FLAG_WINDOW_HIGHDPI) > 0) && ((flags & FLAG_WINDOW_HIGHDPI) > 0))
+ {
+ TRACELOG(LOG_WARNING, "WINDOW: High DPI can only be configured before window initialization");
+ }
+
+ // State change: FLAG_WINDOW_MOUSE_PASSTHROUGH
+ if (((CORE.Window.flags & FLAG_WINDOW_MOUSE_PASSTHROUGH) > 0) && ((flags & FLAG_WINDOW_MOUSE_PASSTHROUGH) > 0))
+ {
+ glfwSetWindowAttrib(platform.handle, GLFW_MOUSE_PASSTHROUGH, GLFW_FALSE);
+ CORE.Window.flags &= ~FLAG_WINDOW_MOUSE_PASSTHROUGH;
+ }
+
+ // State change: FLAG_MSAA_4X_HINT
+ if (((CORE.Window.flags & FLAG_MSAA_4X_HINT) > 0) && ((flags & FLAG_MSAA_4X_HINT) > 0))
+ {
+ TRACELOG(LOG_WARNING, "WINDOW: MSAA can only be configured before window initialization");
+ }
+
+ // State change: FLAG_INTERLACED_HINT
+ if (((CORE.Window.flags & FLAG_INTERLACED_HINT) > 0) && ((flags & FLAG_INTERLACED_HINT) > 0))
+ {
+ TRACELOG(LOG_WARNING, "RPI: Interlaced mode can only be configured before window initialization");
+ }
+}
+
+// Set icon for window
+// NOTE 1: Image must be in RGBA format, 8bit per channel
+// NOTE 2: Image is scaled by the OS for all required sizes
+void SetWindowIcon(Image image)
+{
+ if (image.data == NULL)
+ {
+ // Revert to the default window icon, pass in an empty image array
+ glfwSetWindowIcon(platform.handle, 0, NULL);
+ }
+ else
+ {
+ if (image.format == PIXELFORMAT_UNCOMPRESSED_R8G8B8A8)
+ {
+ GLFWimage icon[1] = { 0 };
+
+ icon[0].width = image.width;
+ icon[0].height = image.height;
+ icon[0].pixels = (unsigned char *)image.data;
+
+ // NOTE 1: We only support one image icon
+ // NOTE 2: The specified image data is copied before this function returns
+ glfwSetWindowIcon(platform.handle, 1, icon);
+ }
+ else TRACELOG(LOG_WARNING, "GLFW: Window icon image must be in R8G8B8A8 pixel format");
+ }
+}
+
+// Set icon for window, multiple images
+// NOTE 1: Images must be in RGBA format, 8bit per channel
+// NOTE 2: The multiple images are used depending on provided sizes
+// Standard Windows icon sizes: 256, 128, 96, 64, 48, 32, 24, 16
+void SetWindowIcons(Image *images, int count)
+{
+ if ((images == NULL) || (count <= 0))
+ {
+ // Revert to the default window icon, pass in an empty image array
+ glfwSetWindowIcon(platform.handle, 0, NULL);
+ }
+ else
+ {
+ int valid = 0;
+ GLFWimage *icons = RL_CALLOC(count, sizeof(GLFWimage));
+
+ for (int i = 0; i < count; i++)
+ {
+ if (images[i].format == PIXELFORMAT_UNCOMPRESSED_R8G8B8A8)
+ {
+ icons[valid].width = images[i].width;
+ icons[valid].height = images[i].height;
+ icons[valid].pixels = (unsigned char *)images[i].data;
+
+ valid++;
+ }
+ else TRACELOG(LOG_WARNING, "GLFW: Window icon image must be in R8G8B8A8 pixel format");
+ }
+ // NOTE: Images data is copied internally before this function returns
+ glfwSetWindowIcon(platform.handle, valid, icons);
+
+ RL_FREE(icons);
+ }
+}
+
+// Set title for window
+void SetWindowTitle(const char *title)
+{
+ CORE.Window.title = title;
+ glfwSetWindowTitle(platform.handle, title);
+}
+
+// Set window position on screen (windowed mode)
+void SetWindowPosition(int x, int y)
+{
+ glfwSetWindowPos(platform.handle, x, y);
+}
+
+// Set monitor for the current window
+void SetWindowMonitor(int monitor)
+{
+ int monitorCount = 0;
+ GLFWmonitor **monitors = glfwGetMonitors(&monitorCount);
+
+ if ((monitor >= 0) && (monitor < monitorCount))
+ {
+ if (CORE.Window.fullscreen)
+ {
+ TRACELOG(LOG_INFO, "GLFW: Selected fullscreen monitor: [%i] %s", monitor, glfwGetMonitorName(monitors[monitor]));
+
+ const GLFWvidmode *mode = glfwGetVideoMode(monitors[monitor]);
+ glfwSetWindowMonitor(platform.handle, monitors[monitor], 0, 0, mode->width, mode->height, mode->refreshRate);
+ }
+ else
+ {
+ TRACELOG(LOG_INFO, "GLFW: Selected monitor: [%i] %s", monitor, glfwGetMonitorName(monitors[monitor]));
+
+ const int screenWidth = CORE.Window.screen.width;
+ const int screenHeight = CORE.Window.screen.height;
+ int monitorWorkareaX = 0;
+ int monitorWorkareaY = 0;
+ int monitorWorkareaWidth = 0;
+ int monitorWorkareaHeight = 0;
+ glfwGetMonitorWorkarea(monitors[monitor], &monitorWorkareaX, &monitorWorkareaY, &monitorWorkareaWidth, &monitorWorkareaHeight);
+
+ // If the screen size is larger than the monitor workarea, anchor it on the top left corner, otherwise, center it
+ if ((screenWidth >= monitorWorkareaWidth) || (screenHeight >= monitorWorkareaHeight)) glfwSetWindowPos(platform.handle, monitorWorkareaX, monitorWorkareaY);
+ else
+ {
+ const int x = monitorWorkareaX + (monitorWorkareaWidth/2) - (screenWidth/2);
+ const int y = monitorWorkareaY + (monitorWorkareaHeight/2) - (screenHeight/2);
+ glfwSetWindowPos(platform.handle, x, y);
+ }
+ }
+ }
+ else TRACELOG(LOG_WARNING, "GLFW: Failed to find selected monitor");
+}
+
+// Set window minimum dimensions (FLAG_WINDOW_RESIZABLE)
+void SetWindowMinSize(int width, int height)
+{
+ CORE.Window.screenMin.width = width;
+ CORE.Window.screenMin.height = height;
+
+ int minWidth = (CORE.Window.screenMin.width == 0)? GLFW_DONT_CARE : (int)CORE.Window.screenMin.width;
+ int minHeight = (CORE.Window.screenMin.height == 0)? GLFW_DONT_CARE : (int)CORE.Window.screenMin.height;
+ int maxWidth = (CORE.Window.screenMax.width == 0)? GLFW_DONT_CARE : (int)CORE.Window.screenMax.width;
+ int maxHeight = (CORE.Window.screenMax.height == 0)? GLFW_DONT_CARE : (int)CORE.Window.screenMax.height;
+
+ glfwSetWindowSizeLimits(platform.handle, minWidth, minHeight, maxWidth, maxHeight);
+}
+
+// Set window maximum dimensions (FLAG_WINDOW_RESIZABLE)
+void SetWindowMaxSize(int width, int height)
+{
+ CORE.Window.screenMax.width = width;
+ CORE.Window.screenMax.height = height;
+
+ int minWidth = (CORE.Window.screenMin.width == 0)? GLFW_DONT_CARE : (int)CORE.Window.screenMin.width;
+ int minHeight = (CORE.Window.screenMin.height == 0)? GLFW_DONT_CARE : (int)CORE.Window.screenMin.height;
+ int maxWidth = (CORE.Window.screenMax.width == 0)? GLFW_DONT_CARE : (int)CORE.Window.screenMax.width;
+ int maxHeight = (CORE.Window.screenMax.height == 0)? GLFW_DONT_CARE : (int)CORE.Window.screenMax.height;
+
+ glfwSetWindowSizeLimits(platform.handle, minWidth, minHeight, maxWidth, maxHeight);
+}
+
+// Set window dimensions
+void SetWindowSize(int width, int height)
+{
+ glfwSetWindowSize(platform.handle, width, height);
+}
+
+// Set window opacity, value opacity is between 0.0 and 1.0
+void SetWindowOpacity(float opacity)
+{
+ if (opacity >= 1.0f) opacity = 1.0f;
+ else if (opacity <= 0.0f) opacity = 0.0f;
+ glfwSetWindowOpacity(platform.handle, opacity);
+}
+
+// Set window focused
+void SetWindowFocused(void)
+{
+ glfwFocusWindow(platform.handle);
+}
+
+// Get native window handle
+void *GetWindowHandle(void)
+{
+#if defined(_WIN32)
+ // NOTE: Returned handle is: void *HWND (windows.h)
+ return glfwGetWin32Window(platform.handle);
+#endif
+#if defined(__linux__)
+ // NOTE: Returned handle is: unsigned long Window (X.h)
+ // typedef unsigned long XID;
+ // typedef XID Window;
+ //unsigned long id = (unsigned long)glfwGetX11Window(platform.handle);
+ //return NULL; // TODO: Find a way to return value... cast to void *?
+ return (void *)platform.handle;
+#endif
+#if defined(__APPLE__)
+ // NOTE: Returned handle is: (objc_object *)
+ return (void *)glfwGetCocoaWindow(platform.handle);
+#endif
+
+ return NULL;
+}
+
+// Get number of monitors
+int GetMonitorCount(void)
+{
+ int monitorCount = 0;
+
+ glfwGetMonitors(&monitorCount);
+
+ return monitorCount;
+}
+
+// Get number of monitors
+int GetCurrentMonitor(void)
+{
+ int index = 0;
+ int monitorCount = 0;
+ GLFWmonitor **monitors = glfwGetMonitors(&monitorCount);
+ GLFWmonitor *monitor = NULL;
+
+ if (monitorCount >= 1)
+ {
+ if (IsWindowFullscreen())
+ {
+ // Get the handle of the monitor that the specified window is in full screen on
+ monitor = glfwGetWindowMonitor(platform.handle);
+
+ for (int i = 0; i < monitorCount; i++)
+ {
+ if (monitors[i] == monitor)
+ {
+ index = i;
+ break;
+ }
+ }
+ }
+ else
+ {
+ // In case the window is between two monitors, we use below logic
+ // to try to detect the "current monitor" for that window, note that
+ // this is probably an overengineered solution for a very side case
+ // trying to match SDL behaviour
+
+ int closestDist = 0x7FFFFFFF;
+
+ // Window center position
+ int wcx = 0;
+ int wcy = 0;
+
+ glfwGetWindowPos(platform.handle, &wcx, &wcy);
+ wcx += (int)CORE.Window.screen.width/2;
+ wcy += (int)CORE.Window.screen.height/2;
+
+ for (int i = 0; i < monitorCount; i++)
+ {
+ // Monitor top-left position
+ int mx = 0;
+ int my = 0;
+
+ monitor = monitors[i];
+ glfwGetMonitorPos(monitor, &mx, &my);
+ const GLFWvidmode *mode = glfwGetVideoMode(monitor);
+
+ if (mode)
+ {
+ const int right = mx + mode->width - 1;
+ const int bottom = my + mode->height - 1;
+
+ if ((wcx >= mx) &&
+ (wcx <= right) &&
+ (wcy >= my) &&
+ (wcy <= bottom))
+ {
+ index = i;
+ break;
+ }
+
+ int xclosest = wcx;
+ if (wcx < mx) xclosest = mx;
+ else if (wcx > right) xclosest = right;
+
+ int yclosest = wcy;
+ if (wcy < my) yclosest = my;
+ else if (wcy > bottom) yclosest = bottom;
+
+ int dx = wcx - xclosest;
+ int dy = wcy - yclosest;
+ int dist = (dx*dx) + (dy*dy);
+ if (dist < closestDist)
+ {
+ index = i;
+ closestDist = dist;
+ }
+ }
+ else TRACELOG(LOG_WARNING, "GLFW: Failed to find video mode for selected monitor");
+ }
+ }
+ }
+
+ return index;
+}
+
+// Get selected monitor position
+Vector2 GetMonitorPosition(int monitor)
+{
+ int monitorCount = 0;
+ GLFWmonitor **monitors = glfwGetMonitors(&monitorCount);
+
+ if ((monitor >= 0) && (monitor < monitorCount))
+ {
+ int x, y;
+ glfwGetMonitorPos(monitors[monitor], &x, &y);
+
+ return (Vector2){ (float)x, (float)y };
+ }
+ else TRACELOG(LOG_WARNING, "GLFW: Failed to find selected monitor");
+ return (Vector2){ 0, 0 };
+}
+
+// Get selected monitor width (currently used by monitor)
+int GetMonitorWidth(int monitor)
+{
+ int width = 0;
+ int monitorCount = 0;
+ GLFWmonitor **monitors = glfwGetMonitors(&monitorCount);
+
+ if ((monitor >= 0) && (monitor < monitorCount))
+ {
+ const GLFWvidmode *mode = glfwGetVideoMode(monitors[monitor]);
+
+ if (mode) width = mode->width;
+ else TRACELOG(LOG_WARNING, "GLFW: Failed to find video mode for selected monitor");
+ }
+ else TRACELOG(LOG_WARNING, "GLFW: Failed to find selected monitor");
+
+ return width;
+}
+
+// Get selected monitor height (currently used by monitor)
+int GetMonitorHeight(int monitor)
+{
+ int height = 0;
+ int monitorCount = 0;
+ GLFWmonitor **monitors = glfwGetMonitors(&monitorCount);
+
+ if ((monitor >= 0) && (monitor < monitorCount))
+ {
+ const GLFWvidmode *mode = glfwGetVideoMode(monitors[monitor]);
+
+ if (mode) height = mode->height;
+ else TRACELOG(LOG_WARNING, "GLFW: Failed to find video mode for selected monitor");
+ }
+ else TRACELOG(LOG_WARNING, "GLFW: Failed to find selected monitor");
+
+ return height;
+}
+
+// Get selected monitor physical width in millimetres
+int GetMonitorPhysicalWidth(int monitor)
+{
+ int width = 0;
+ int monitorCount = 0;
+ GLFWmonitor **monitors = glfwGetMonitors(&monitorCount);
+
+ if ((monitor >= 0) && (monitor < monitorCount)) glfwGetMonitorPhysicalSize(monitors[monitor], &width, NULL);
+ else TRACELOG(LOG_WARNING, "GLFW: Failed to find selected monitor");
+
+ return width;
+}
+
+// Get selected monitor physical height in millimetres
+int GetMonitorPhysicalHeight(int monitor)
+{
+ int height = 0;
+ int monitorCount = 0;
+ GLFWmonitor **monitors = glfwGetMonitors(&monitorCount);
+
+ if ((monitor >= 0) && (monitor < monitorCount)) glfwGetMonitorPhysicalSize(monitors[monitor], NULL, &height);
+ else TRACELOG(LOG_WARNING, "GLFW: Failed to find selected monitor");
+
+ return height;
+}
+
+// Get selected monitor refresh rate
+int GetMonitorRefreshRate(int monitor)
+{
+ int refresh = 0;
+ int monitorCount = 0;
+ GLFWmonitor **monitors = glfwGetMonitors(&monitorCount);
+
+ if ((monitor >= 0) && (monitor < monitorCount))
+ {
+ const GLFWvidmode *vidmode = glfwGetVideoMode(monitors[monitor]);
+ refresh = vidmode->refreshRate;
+ }
+ else TRACELOG(LOG_WARNING, "GLFW: Failed to find selected monitor");
+
+ return refresh;
+}
+
+// Get the human-readable, UTF-8 encoded name of the selected monitor
+const char *GetMonitorName(int monitor)
+{
+ int monitorCount = 0;
+ GLFWmonitor **monitors = glfwGetMonitors(&monitorCount);
+
+ if ((monitor >= 0) && (monitor < monitorCount))
+ {
+ return glfwGetMonitorName(monitors[monitor]);
+ }
+ else TRACELOG(LOG_WARNING, "GLFW: Failed to find selected monitor");
+ return "";
+}
+
+// Get window position XY on monitor
+Vector2 GetWindowPosition(void)
+{
+ int x = 0;
+ int y = 0;
+
+ glfwGetWindowPos(platform.handle, &x, &y);
+
+ return (Vector2){ (float)x, (float)y };
+}
+
+// Get window scale DPI factor for current monitor
+Vector2 GetWindowScaleDPI(void)
+{
+ float xdpi = 1.0;
+ float ydpi = 1.0;
+ Vector2 scale = { 1.0f, 1.0f };
+ Vector2 windowPos = GetWindowPosition();
+
+ int monitorCount = 0;
+ GLFWmonitor **monitors = glfwGetMonitors(&monitorCount);
+
+ // Check window monitor
+ for (int i = 0; i < monitorCount; i++)
+ {
+ glfwGetMonitorContentScale(monitors[i], &xdpi, &ydpi);
+
+ int xpos, ypos, width, height;
+ glfwGetMonitorWorkarea(monitors[i], &xpos, &ypos, &width, &height);
+
+ if ((windowPos.x >= xpos) && (windowPos.x < xpos + width) &&
+ (windowPos.y >= ypos) && (windowPos.y < ypos + height))
+ {
+ scale.x = xdpi;
+ scale.y = ydpi;
+ break;
+ }
+ }
+
+ return scale;
+}
+
+// Set clipboard text content
+void SetClipboardText(const char *text)
+{
+ glfwSetClipboardString(platform.handle, text);
+}
+
+// Get clipboard text content
+// NOTE: returned string is allocated and freed by GLFW
+const char *GetClipboardText(void)
+{
+ return glfwGetClipboardString(platform.handle);
+}
+
+// Show mouse cursor
+void ShowCursor(void)
+{
+ glfwSetInputMode(platform.handle, GLFW_CURSOR, GLFW_CURSOR_NORMAL);
+ CORE.Input.Mouse.cursorHidden = false;
+}
+
+// Hides mouse cursor
+void HideCursor(void)
+{
+ glfwSetInputMode(platform.handle, GLFW_CURSOR, GLFW_CURSOR_HIDDEN);
+ CORE.Input.Mouse.cursorHidden = true;
+}
+
+// Enables cursor (unlock cursor)
+void EnableCursor(void)
+{
+ glfwSetInputMode(platform.handle, GLFW_CURSOR, GLFW_CURSOR_NORMAL);
+
+ // 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)
+{
+ glfwSetInputMode(platform.handle, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
+
+ // 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)
+{
+ glfwSwapBuffers(platform.handle);
+}
+
+//----------------------------------------------------------------------------------
+// Module Functions Definition: Misc
+//----------------------------------------------------------------------------------
+
+// Get elapsed time measure in seconds since InitTimer()
+double GetTime(void)
+{
+ double time = glfwGetTime(); // Elapsed time since glfwInit()
+ return time;
+}
+
+// Open URL with default system browser (if available)
+// NOTE: This function is only safe to use if you control the URL given.
+// A user could craft a malicious string performing another action.
+// Only call this function yourself not with user input or make sure to check the string yourself.
+// Ref: https://github.com/raysan5/raylib/issues/686
+void OpenURL(const char *url)
+{
+ // Security check to (partially) avoid malicious code
+ if (strchr(url, '\'') != NULL) TRACELOG(LOG_WARNING, "SYSTEM: Provided URL could be potentially malicious, avoid [\'] character");
+ else
+ {
+ char *cmd = (char *)RL_CALLOC(strlen(url) + 32, sizeof(char));
+#if defined(_WIN32)
+ sprintf(cmd, "explorer \"%s\"", url);
+#endif
+#if defined(__linux__) || defined(__FreeBSD__) || defined(__OpenBSD__)
+ sprintf(cmd, "xdg-open '%s'", url); // Alternatives: firefox, x-www-browser
+#endif
+#if defined(__APPLE__)
+ sprintf(cmd, "open '%s'", url);
+#endif
+ int result = system(cmd);
+ if (result == -1) TRACELOG(LOG_WARNING, "OpenURL() child process could not be created");
+ RL_FREE(cmd);
+ }
+}
+
+//----------------------------------------------------------------------------------
+// Module Functions Definition: Inputs
+//----------------------------------------------------------------------------------
+
+// Set internal gamepad mappings
+int SetGamepadMappings(const char *mappings)
+{
+ return glfwUpdateGamepadMappings(mappings);
+}
+
+// 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;
+
+ // NOTE: emscripten not implemented
+ glfwSetCursorPos(platform.handle, CORE.Input.Mouse.currentPosition.x, CORE.Input.Mouse.currentPosition.y);
+}
+
+// Set mouse cursor
+void SetMouseCursor(int cursor)
+{
+ CORE.Input.Mouse.cursor = cursor;
+ if (cursor == MOUSE_CURSOR_DEFAULT) glfwSetCursor(platform.handle, NULL);
+ else
+ {
+ // NOTE: We are relating internal GLFW enum values to our MouseCursor enum values
+ glfwSetCursor(platform.handle, glfwCreateStandardCursor(0x00036000 + cursor));
+ }
+}
+
+// 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 last gamepad button/axis registered state
+ CORE.Input.Gamepad.lastButtonPressed = 0; // GAMEPAD_BUTTON_UNKNOWN
+ //CORE.Input.Gamepad.axisCount = 0;
+
+ // Keyboard/Mouse input polling (automatically managed by GLFW3 through callback)
+
+ // 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.keyRepeatInFrame[i] = 0;
+ }
+
+ // Register previous mouse states
+ for (int i = 0; i < MAX_MOUSE_BUTTONS; i++) CORE.Input.Mouse.previousButtonState[i] = CORE.Input.Mouse.currentButtonState[i];
+
+ // Register previous mouse wheel state
+ CORE.Input.Mouse.previousWheelMove = CORE.Input.Mouse.currentWheelMove;
+ CORE.Input.Mouse.currentWheelMove = (Vector2){ 0.0f, 0.0f };
+
+ // Register previous mouse position
+ CORE.Input.Mouse.previousPosition = CORE.Input.Mouse.currentPosition;
+
+ // 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
+ //for (int i = 0; i < MAX_TOUCH_POINTS; i++) CORE.Input.Touch.position[i] = (Vector2){ 0, 0 };
+
+ // Map touch position to mouse position for convenience
+ // WARNING: If the target desktop device supports touch screen, this behaviour should be reviewed!
+ // TODO: GLFW does not support multi-touch input just yet
+ // https://www.codeproject.com/Articles/668404/Programming-for-Multi-Touch
+ // https://docs.microsoft.com/en-us/windows/win32/wintouch/getting-started-with-multi-touch-messages
+ CORE.Input.Touch.position[0] = CORE.Input.Mouse.currentPosition;
+
+ // Check if gamepads are ready
+ // NOTE: We do it here in case of disconnection
+ for (int i = 0; i < MAX_GAMEPADS; i++)
+ {
+ if (glfwJoystickPresent(i)) CORE.Input.Gamepad.ready[i] = true;
+ else CORE.Input.Gamepad.ready[i] = false;
+ }
+
+ // Register gamepads buttons events
+ for (int i = 0; i < MAX_GAMEPADS; i++)
+ {
+ if (CORE.Input.Gamepad.ready[i]) // Check if gamepad is available
+ {
+ // Register previous gamepad states
+ for (int k = 0; k < MAX_GAMEPAD_BUTTONS; k++) CORE.Input.Gamepad.previousButtonState[i][k] = CORE.Input.Gamepad.currentButtonState[i][k];
+
+ // Get current gamepad state
+ // NOTE: There is no callback available, so we get it manually
+ GLFWgamepadstate state = { 0 };
+ glfwGetGamepadState(i, &state); // This remapps all gamepads so they have their buttons mapped like an xbox controller
+
+ const unsigned char *buttons = state.buttons;
+
+ for (int k = 0; (buttons != NULL) && (k < GLFW_GAMEPAD_BUTTON_DPAD_LEFT + 1) && (k < MAX_GAMEPAD_BUTTONS); k++)
+ {
+ int button = -1; // GamepadButton enum values assigned
+
+ switch (k)
+ {
+ case GLFW_GAMEPAD_BUTTON_Y: button = GAMEPAD_BUTTON_RIGHT_FACE_UP; break;
+ case GLFW_GAMEPAD_BUTTON_B: button = GAMEPAD_BUTTON_RIGHT_FACE_RIGHT; break;
+ case GLFW_GAMEPAD_BUTTON_A: button = GAMEPAD_BUTTON_RIGHT_FACE_DOWN; break;
+ case GLFW_GAMEPAD_BUTTON_X: button = GAMEPAD_BUTTON_RIGHT_FACE_LEFT; break;
+
+ case GLFW_GAMEPAD_BUTTON_LEFT_BUMPER: button = GAMEPAD_BUTTON_LEFT_TRIGGER_1; break;
+ case GLFW_GAMEPAD_BUTTON_RIGHT_BUMPER: button = GAMEPAD_BUTTON_RIGHT_TRIGGER_1; break;
+
+ case GLFW_GAMEPAD_BUTTON_BACK: button = GAMEPAD_BUTTON_MIDDLE_LEFT; break;
+ case GLFW_GAMEPAD_BUTTON_GUIDE: button = GAMEPAD_BUTTON_MIDDLE; break;
+ case GLFW_GAMEPAD_BUTTON_START: button = GAMEPAD_BUTTON_MIDDLE_RIGHT; break;
+
+ case GLFW_GAMEPAD_BUTTON_DPAD_UP: button = GAMEPAD_BUTTON_LEFT_FACE_UP; break;
+ case GLFW_GAMEPAD_BUTTON_DPAD_RIGHT: button = GAMEPAD_BUTTON_LEFT_FACE_RIGHT; break;
+ case GLFW_GAMEPAD_BUTTON_DPAD_DOWN: button = GAMEPAD_BUTTON_LEFT_FACE_DOWN; break;
+ case GLFW_GAMEPAD_BUTTON_DPAD_LEFT: button = GAMEPAD_BUTTON_LEFT_FACE_LEFT; break;
+
+ case GLFW_GAMEPAD_BUTTON_LEFT_THUMB: button = GAMEPAD_BUTTON_LEFT_THUMB; break;
+ case GLFW_GAMEPAD_BUTTON_RIGHT_THUMB: button = GAMEPAD_BUTTON_RIGHT_THUMB; break;
+ default: break;
+ }
+
+ if (button != -1) // Check for valid button
+ {
+ if (buttons[k] == GLFW_PRESS)
+ {
+ CORE.Input.Gamepad.currentButtonState[i][button] = 1;
+ CORE.Input.Gamepad.lastButtonPressed = button;
+ }
+ else CORE.Input.Gamepad.currentButtonState[i][button] = 0;
+ }
+ }
+
+ // Get current axis state
+ const float *axes = state.axes;
+
+ for (int k = 0; (axes != NULL) && (k < GLFW_GAMEPAD_AXIS_LAST + 1) && (k < MAX_GAMEPAD_AXIS); k++)
+ {
+ CORE.Input.Gamepad.axisState[i][k] = axes[k];
+ }
+
+ // Register buttons for 2nd triggers (because GLFW doesn't count these as buttons but rather axis)
+ CORE.Input.Gamepad.currentButtonState[i][GAMEPAD_BUTTON_LEFT_TRIGGER_2] = (char)(CORE.Input.Gamepad.axisState[i][GAMEPAD_AXIS_LEFT_TRIGGER] > 0.1f);
+ CORE.Input.Gamepad.currentButtonState[i][GAMEPAD_BUTTON_RIGHT_TRIGGER_2] = (char)(CORE.Input.Gamepad.axisState[i][GAMEPAD_AXIS_RIGHT_TRIGGER] > 0.1f);
+
+ CORE.Input.Gamepad.axisCount[i] = GLFW_GAMEPAD_AXIS_LAST + 1;
+ }
+ }
+
+ CORE.Window.resizedLastFrame = false;
+
+ if (CORE.Window.eventWaiting) glfwWaitEvents(); // Wait for in input events before continue (drawing is paused)
+ else glfwPollEvents(); // Poll input events: keyboard/mouse/window events (callbacks) -> Update keys state
+
+ // While window minimized, stop loop execution
+ while (IsWindowState(FLAG_WINDOW_MINIMIZED) && !IsWindowState(FLAG_WINDOW_ALWAYS_RUN)) glfwWaitEvents();
+
+ CORE.Window.shouldClose = glfwWindowShouldClose(platform.handle);
+
+ // Reset close status for next frame
+ glfwSetWindowShouldClose(platform.handle, GLFW_FALSE);
+}
+
+
+//----------------------------------------------------------------------------------
+// Module Internal Functions Definition
+//----------------------------------------------------------------------------------
+
+// Initialize platform: graphics, inputs and more
+int InitPlatform(void)
+{
+ TRACELOG(LOG_INFO, "InitPlatform: Custom Platform 2 (Desktop clone)");
+
+ glfwSetErrorCallback(ErrorCallback);
+/*
+ // TODO: Setup GLFW custom allocators to match raylib ones
+ const GLFWallocator allocator = {
+ .allocate = MemAlloc,
+ .deallocate = MemFree,
+ .reallocate = MemRealloc,
+ .user = NULL
+ };
+
+ glfwInitAllocator(&allocator);
+*/
+
+#if defined(__APPLE__)
+ glfwInitHint(GLFW_COCOA_CHDIR_RESOURCES, GLFW_FALSE);
+#endif
+ // Initialize GLFW internal global state
+ int result = glfwInit();
+ if (result == GLFW_FALSE) { TRACELOG(LOG_WARNING, "GLFW: Failed to initialize GLFW"); return -1; }
+
+ // Initialize graphic device: display/window and graphic context
+ //----------------------------------------------------------------------------
+ glfwDefaultWindowHints(); // Set default windows hints
+ //glfwWindowHint(GLFW_RED_BITS, 8); // Framebuffer red color component bits
+ //glfwWindowHint(GLFW_GREEN_BITS, 8); // Framebuffer green color component bits
+ //glfwWindowHint(GLFW_BLUE_BITS, 8); // Framebuffer blue color component bits
+ //glfwWindowHint(GLFW_ALPHA_BITS, 8); // Framebuffer alpha color component bits
+ //glfwWindowHint(GLFW_DEPTH_BITS, 24); // Depthbuffer bits
+ //glfwWindowHint(GLFW_REFRESH_RATE, 0); // Refresh rate for fullscreen window
+ //glfwWindowHint(GLFW_CLIENT_API, GLFW_OPENGL_API); // OpenGL API to use. Alternative: GLFW_OPENGL_ES_API
+ //glfwWindowHint(GLFW_AUX_BUFFERS, 0); // Number of auxiliar buffers
+
+ // Check window creation flags
+ if ((CORE.Window.flags & FLAG_FULLSCREEN_MODE) > 0) CORE.Window.fullscreen = true;
+
+ if ((CORE.Window.flags & FLAG_WINDOW_HIDDEN) > 0) glfwWindowHint(GLFW_VISIBLE, GLFW_FALSE); // Visible window
+ else glfwWindowHint(GLFW_VISIBLE, GLFW_TRUE); // Window initially hidden
+
+ if ((CORE.Window.flags & FLAG_WINDOW_UNDECORATED) > 0) glfwWindowHint(GLFW_DECORATED, GLFW_FALSE); // Border and buttons on Window
+ else glfwWindowHint(GLFW_DECORATED, GLFW_TRUE); // Decorated window
+
+ if ((CORE.Window.flags & FLAG_WINDOW_RESIZABLE) > 0) glfwWindowHint(GLFW_RESIZABLE, GLFW_TRUE); // Resizable window
+ else glfwWindowHint(GLFW_RESIZABLE, GLFW_FALSE); // Avoid window being resizable
+
+ // Disable FLAG_WINDOW_MINIMIZED, not supported on initialization
+ if ((CORE.Window.flags & FLAG_WINDOW_MINIMIZED) > 0) CORE.Window.flags &= ~FLAG_WINDOW_MINIMIZED;
+
+ // Disable FLAG_WINDOW_MAXIMIZED, not supported on initialization
+ if ((CORE.Window.flags & FLAG_WINDOW_MAXIMIZED) > 0) CORE.Window.flags &= ~FLAG_WINDOW_MAXIMIZED;
+
+ if ((CORE.Window.flags & FLAG_WINDOW_UNFOCUSED) > 0) glfwWindowHint(GLFW_FOCUSED, GLFW_FALSE);
+ else glfwWindowHint(GLFW_FOCUSED, GLFW_TRUE);
+
+ if ((CORE.Window.flags & FLAG_WINDOW_TOPMOST) > 0) glfwWindowHint(GLFW_FLOATING, GLFW_TRUE);
+ else glfwWindowHint(GLFW_FLOATING, GLFW_FALSE);
+
+ // NOTE: Some GLFW flags are not supported on HTML5
+ if ((CORE.Window.flags & FLAG_WINDOW_TRANSPARENT) > 0) glfwWindowHint(GLFW_TRANSPARENT_FRAMEBUFFER, GLFW_TRUE); // Transparent framebuffer
+ else glfwWindowHint(GLFW_TRANSPARENT_FRAMEBUFFER, GLFW_FALSE); // Opaque framebuffer
+
+ if ((CORE.Window.flags & FLAG_WINDOW_HIGHDPI) > 0)
+ {
+ // Resize window content area based on the monitor content scale.
+ // NOTE: This hint only has an effect on platforms where screen coordinates and pixels always map 1:1 such as Windows and X11.
+ // On platforms like macOS the resolution of the framebuffer is changed independently of the window size.
+ glfwWindowHint(GLFW_SCALE_TO_MONITOR, GLFW_TRUE); // Scale content area based on the monitor content scale where window is placed on
+#if defined(__APPLE__)
+ glfwWindowHint(GLFW_COCOA_RETINA_FRAMEBUFFER, GLFW_TRUE);
+#endif
+ }
+ else glfwWindowHint(GLFW_SCALE_TO_MONITOR, GLFW_FALSE);
+
+ // Mouse passthrough
+ if ((CORE.Window.flags & FLAG_WINDOW_MOUSE_PASSTHROUGH) > 0) glfwWindowHint(GLFW_MOUSE_PASSTHROUGH, GLFW_TRUE);
+ else glfwWindowHint(GLFW_MOUSE_PASSTHROUGH, GLFW_FALSE);
+
+ if (CORE.Window.flags & FLAG_MSAA_4X_HINT)
+ {
+ // NOTE: MSAA is only enabled for main framebuffer, not user-created FBOs
+ TRACELOG(LOG_INFO, "DISPLAY: Trying to enable MSAA x4");
+ glfwWindowHint(GLFW_SAMPLES, 4); // Tries to enable multisampling x4 (MSAA), default is 0
+ }
+
+ // NOTE: When asking for an OpenGL context version, most drivers provide the highest supported version
+ // with backward compatibility to older OpenGL versions.
+ // For example, if using OpenGL 1.1, driver can provide a 4.3 backwards compatible context.
+
+ // Check selection OpenGL version
+ if (rlGetVersion() == RL_OPENGL_21)
+ {
+ glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 2); // Choose OpenGL major version (just hint)
+ glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 1); // Choose OpenGL minor version (just hint)
+ }
+ else if (rlGetVersion() == RL_OPENGL_33)
+ {
+ glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3); // Choose OpenGL major version (just hint)
+ glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3); // Choose OpenGL minor version (just hint)
+ glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); // Profiles Hint: Only 3.3 and above!
+ // Values: GLFW_OPENGL_CORE_PROFILE, GLFW_OPENGL_ANY_PROFILE, GLFW_OPENGL_COMPAT_PROFILE
+#if defined(__APPLE__)
+ glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GLFW_TRUE); // OSX Requires forward compatibility
+#else
+ glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GLFW_FALSE); // Forward Compatibility Hint: Only 3.3 and above!
+#endif
+ //glfwWindowHint(GLFW_OPENGL_DEBUG_CONTEXT, GLFW_TRUE); // Request OpenGL DEBUG context
+ }
+ else if (rlGetVersion() == RL_OPENGL_43)
+ {
+ glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4); // Choose OpenGL major version (just hint)
+ glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3); // Choose OpenGL minor version (just hint)
+ glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
+ glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GLFW_FALSE);
+#if defined(RLGL_ENABLE_OPENGL_DEBUG_CONTEXT)
+ glfwWindowHint(GLFW_OPENGL_DEBUG_CONTEXT, GLFW_TRUE); // Enable OpenGL Debug Context
+#endif
+ }
+ else if (rlGetVersion() == RL_OPENGL_ES_20) // Request OpenGL ES 2.0 context
+ {
+ glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 2);
+ glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 0);
+ glfwWindowHint(GLFW_CLIENT_API, GLFW_OPENGL_ES_API);
+ glfwWindowHint(GLFW_CONTEXT_CREATION_API, GLFW_EGL_CONTEXT_API);
+ }
+ else if (rlGetVersion() == RL_OPENGL_ES_30) // Request OpenGL ES 3.0 context
+ {
+ glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
+ glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 0);
+ glfwWindowHint(GLFW_CLIENT_API, GLFW_OPENGL_ES_API);
+ glfwWindowHint(GLFW_CONTEXT_CREATION_API, GLFW_EGL_CONTEXT_API);
+ }
+
+ // NOTE: GLFW 3.4+ defers initialization of the Joystick subsystem on the first call to any Joystick related functions.
+ // Forcing this initialization here avoids doing it on PollInputEvents() called by EndDrawing() after first frame has been just drawn.
+ // The initialization will still happen and possible delays still occur, but before the window is shown, which is a nicer experience.
+ // REF: https://github.com/raysan5/raylib/issues/1554
+ glfwSetJoystickCallback(NULL);
+
+ // Find monitor resolution
+ GLFWmonitor *monitor = glfwGetPrimaryMonitor();
+ if (!monitor)
+ {
+ TRACELOG(LOG_WARNING, "GLFW: Failed to get primary monitor");
+ return -1;
+ }
+
+ const GLFWvidmode *mode = glfwGetVideoMode(monitor);
+
+ CORE.Window.display.width = mode->width;
+ CORE.Window.display.height = mode->height;
+
+ // Set screen width/height to the display width/height if they are 0
+ if (CORE.Window.screen.width == 0) CORE.Window.screen.width = CORE.Window.display.width;
+ if (CORE.Window.screen.height == 0) CORE.Window.screen.height = CORE.Window.display.height;
+
+ if (CORE.Window.fullscreen)
+ {
+ // remember center for switchinging from fullscreen to window
+ if ((CORE.Window.screen.height == CORE.Window.display.height) && (CORE.Window.screen.width == CORE.Window.display.width))
+ {
+ // If screen width/height equal to the display, we can't calculate the window pos for toggling full-screened/windowed.
+ // Toggling full-screened/windowed with pos(0, 0) can cause problems in some platforms, such as X11.
+ CORE.Window.position.x = CORE.Window.display.width/4;
+ CORE.Window.position.y = CORE.Window.display.height/4;
+ }
+ else
+ {
+ CORE.Window.position.x = CORE.Window.display.width/2 - CORE.Window.screen.width/2;
+ CORE.Window.position.y = CORE.Window.display.height/2 - CORE.Window.screen.height/2;
+ }
+
+ if (CORE.Window.position.x < 0) CORE.Window.position.x = 0;
+ if (CORE.Window.position.y < 0) CORE.Window.position.y = 0;
+
+ // Obtain recommended CORE.Window.display.width/CORE.Window.display.height from a valid videomode for the monitor
+ int count = 0;
+ const GLFWvidmode *modes = glfwGetVideoModes(glfwGetPrimaryMonitor(), &count);
+
+ // Get closest video mode to desired CORE.Window.screen.width/CORE.Window.screen.height
+ for (int i = 0; i < count; i++)
+ {
+ if ((unsigned int)modes[i].width >= CORE.Window.screen.width)
+ {
+ if ((unsigned int)modes[i].height >= CORE.Window.screen.height)
+ {
+ CORE.Window.display.width = modes[i].width;
+ CORE.Window.display.height = modes[i].height;
+ break;
+ }
+ }
+ }
+
+ TRACELOG(LOG_WARNING, "SYSTEM: Closest fullscreen videomode: %i x %i", CORE.Window.display.width, CORE.Window.display.height);
+
+ // NOTE: ISSUE: Closest videomode could not match monitor aspect-ratio, for example,
+ // for a desired screen size of 800x450 (16:9), closest supported videomode is 800x600 (4:3),
+ // framebuffer is rendered correctly but once displayed on a 16:9 monitor, it gets stretched
+ // by the sides to fit all monitor space...
+
+ // Try to setup the most appropriate fullscreen framebuffer for the requested screenWidth/screenHeight
+ // It considers device display resolution mode and setups a framebuffer with black bars if required (render size/offset)
+ // Modified global variables: CORE.Window.screen.width/CORE.Window.screen.height - CORE.Window.render.width/CORE.Window.render.height - CORE.Window.renderOffset.x/CORE.Window.renderOffset.y - CORE.Window.screenScale
+ // TODO: It is a quite cumbersome solution to display size vs requested size, it should be reviewed or removed...
+ // HighDPI monitors are properly considered in a following similar function: SetupViewport()
+ SetupFramebuffer(CORE.Window.display.width, CORE.Window.display.height);
+
+ platform.handle = glfwCreateWindow(CORE.Window.display.width, CORE.Window.display.height, (CORE.Window.title != 0)? CORE.Window.title : " ", glfwGetPrimaryMonitor(), NULL);
+
+ // NOTE: Full-screen change, not working properly...
+ //glfwSetWindowMonitor(platform.handle, glfwGetPrimaryMonitor(), 0, 0, CORE.Window.screen.width, CORE.Window.screen.height, GLFW_DONT_CARE);
+ }
+ else
+ {
+ // If we are windowed fullscreen, ensures that window does not minimize when focus is lost
+ if ((CORE.Window.screen.height == CORE.Window.display.height) && (CORE.Window.screen.width == CORE.Window.display.width))
+ {
+ glfwWindowHint(GLFW_AUTO_ICONIFY, 0);
+ }
+
+ // No-fullscreen window creation
+ platform.handle = glfwCreateWindow(CORE.Window.screen.width, CORE.Window.screen.height, (CORE.Window.title != 0)? CORE.Window.title : " ", NULL, NULL);
+
+ if (platform.handle)
+ {
+ CORE.Window.render.width = CORE.Window.screen.width;
+ CORE.Window.render.height = CORE.Window.screen.height;
+ }
+ }
+
+ if (!platform.handle)
+ {
+ glfwTerminate();
+ TRACELOG(LOG_WARNING, "GLFW: Failed to initialize Window");
+ return -1;
+ }
+
+ glfwMakeContextCurrent(platform.handle);
+ result = glfwGetError(NULL);
+
+ // Check context activation
+ if ((result != GLFW_NO_WINDOW_CONTEXT) && (result != GLFW_PLATFORM_ERROR))
+ {
+ CORE.Window.ready = true;
+
+ glfwSwapInterval(0); // No V-Sync by default
+
+ // Try to enable GPU V-Sync, so frames are limited to screen refresh rate (60Hz -> 60 FPS)
+ // NOTE: V-Sync can be enabled by graphic driver configuration, it doesn't need
+ // to be activated on web platforms since VSync is enforced there.
+ if (CORE.Window.flags & FLAG_VSYNC_HINT)
+ {
+ // WARNING: It seems to hit a critical render path in Intel HD Graphics
+ glfwSwapInterval(1);
+ TRACELOG(LOG_INFO, "DISPLAY: Trying to enable VSYNC");
+ }
+
+ int fbWidth = CORE.Window.screen.width;
+ int fbHeight = CORE.Window.screen.height;
+
+ if ((CORE.Window.flags & FLAG_WINDOW_HIGHDPI) > 0)
+ {
+ // NOTE: On APPLE platforms system should manage window/input scaling and also framebuffer scaling.
+ // Framebuffer scaling should be activated with: glfwWindowHint(GLFW_COCOA_RETINA_FRAMEBUFFER, GLFW_TRUE);
+#if !defined(__APPLE__)
+ glfwGetFramebufferSize(platform.handle, &fbWidth, &fbHeight);
+
+ // Screen scaling matrix is required in case desired screen area is different from display area
+ CORE.Window.screenScale = MatrixScale((float)fbWidth/CORE.Window.screen.width, (float)fbHeight/CORE.Window.screen.height, 1.0f);
+
+ // Mouse input scaling for the new screen size
+ SetMouseScale((float)CORE.Window.screen.width/fbWidth, (float)CORE.Window.screen.height/fbHeight);
+#endif
+ }
+
+ CORE.Window.render.width = fbWidth;
+ CORE.Window.render.height = fbHeight;
+ CORE.Window.currentFbo.width = fbWidth;
+ CORE.Window.currentFbo.height = fbHeight;
+
+ 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 graphics device");
+ return -1;
+ }
+
+ if ((CORE.Window.flags & FLAG_WINDOW_MINIMIZED) > 0) MinimizeWindow();
+
+ // If graphic device is no properly initialized, we end program
+ if (!CORE.Window.ready) { TRACELOG(LOG_FATAL, "PLATFORM: Failed to initialize graphic device"); return -1; }
+ else SetWindowPosition(GetMonitorWidth(GetCurrentMonitor())/2 - CORE.Window.screen.width/2, GetMonitorHeight(GetCurrentMonitor())/2 - CORE.Window.screen.height/2);
+
+ // Load OpenGL extensions
+ // NOTE: GL procedures address loader is required to load extensions
+ rlLoadExtensions(glfwGetProcAddress);
+ //----------------------------------------------------------------------------
+
+ // Initialize input events callbacks
+ //----------------------------------------------------------------------------
+ // Set window callback events
+ glfwSetWindowSizeCallback(platform.handle, WindowSizeCallback); // NOTE: Resizing not allowed by default!
+ glfwSetWindowMaximizeCallback(platform.handle, WindowMaximizeCallback);
+ glfwSetWindowIconifyCallback(platform.handle, WindowIconifyCallback);
+ glfwSetWindowFocusCallback(platform.handle, WindowFocusCallback);
+ glfwSetDropCallback(platform.handle, WindowDropCallback);
+
+ // Set input callback events
+ glfwSetKeyCallback(platform.handle, KeyCallback);
+ glfwSetCharCallback(platform.handle, CharCallback);
+ glfwSetMouseButtonCallback(platform.handle, MouseButtonCallback);
+ glfwSetCursorPosCallback(platform.handle, MouseCursorPosCallback); // Track mouse position changes
+ glfwSetScrollCallback(platform.handle, MouseScrollCallback);
+ glfwSetCursorEnterCallback(platform.handle, CursorEnterCallback);
+ glfwSetJoystickCallback(JoystickCallback);
+
+ glfwSetInputMode(platform.handle, GLFW_LOCK_KEY_MODS, GLFW_TRUE); // Enable lock keys modifiers (CAPS, NUM)
+
+ // Retrieve gamepad names
+ for (int i = 0; i < MAX_GAMEPADS; i++)
+ {
+ if (glfwJoystickPresent(i)) strcpy(CORE.Input.Gamepad.name[i], glfwGetJoystickName(i));
+ }
+ //----------------------------------------------------------------------------
+
+ // Initialize timming system
+ //----------------------------------------------------------------------------
+ InitTimer();
+ //----------------------------------------------------------------------------
+
+ // Initialize storage system
+ //----------------------------------------------------------------------------
+ CORE.Storage.basePath = GetWorkingDirectory();
+ //----------------------------------------------------------------------------
+
+ TRACELOG(LOG_INFO, "PLATFORM: Custom platform 2 (DESKTOP clone) (GLFW): Initialized successfully");
+
+ return 0;
+}
+
+// Close platform
+void ClosePlatform(void)
+{
+ glfwDestroyWindow(platform.handle);
+ glfwTerminate();
+
+#if defined(_WIN32) && defined(SUPPORT_WINMM_HIGHRES_TIMER) && !defined(SUPPORT_BUSY_WAIT_LOOP)
+ timeEndPeriod(1); // Restore time period
+#endif
+}
+
+// GLFW3 Error Callback, runs on GLFW3 error
+static void ErrorCallback(int error, const char *description)
+{
+ TRACELOG(LOG_WARNING, "GLFW: Error: %i Description: %s", error, description);
+}
+
+// GLFW3 WindowSize Callback, runs when window is resizedLastFrame
+// NOTE: Window resizing not allowed by default
+static void WindowSizeCallback(GLFWwindow *window, int width, int height)
+{
+ // Reset viewport and projection matrix for new size
+ SetupViewport(width, height);
+
+ CORE.Window.currentFbo.width = width;
+ CORE.Window.currentFbo.height = height;
+ CORE.Window.resizedLastFrame = true;
+
+ if (IsWindowFullscreen()) return;
+
+ // Set current screen size
+#if defined(__APPLE__)
+ CORE.Window.screen.width = width;
+ CORE.Window.screen.height = height;
+#else
+ if ((CORE.Window.flags & FLAG_WINDOW_HIGHDPI) > 0)
+ {
+ Vector2 windowScaleDPI = GetWindowScaleDPI();
+
+ CORE.Window.screen.width = (unsigned int)(width/windowScaleDPI.x);
+ CORE.Window.screen.height = (unsigned int)(height/windowScaleDPI.y);
+ }
+ else
+ {
+ CORE.Window.screen.width = width;
+ CORE.Window.screen.height = height;
+ }
+#endif
+
+ // NOTE: Postprocessing texture is not scaled to new size
+}
+
+// GLFW3 WindowIconify Callback, runs when window is minimized/restored
+static void WindowIconifyCallback(GLFWwindow *window, int iconified)
+{
+ if (iconified) CORE.Window.flags |= FLAG_WINDOW_MINIMIZED; // The window was iconified
+ else CORE.Window.flags &= ~FLAG_WINDOW_MINIMIZED; // The window was restored
+}
+
+// GLFW3 WindowMaximize Callback, runs when window is maximized/restored
+static void WindowMaximizeCallback(GLFWwindow *window, int maximized)
+{
+ if (maximized) CORE.Window.flags |= FLAG_WINDOW_MAXIMIZED; // The window was maximized
+ else CORE.Window.flags &= ~FLAG_WINDOW_MAXIMIZED; // The window was restored
+}
+
+// GLFW3 WindowFocus Callback, runs when window get/lose focus
+static void WindowFocusCallback(GLFWwindow *window, int focused)
+{
+ if (focused) CORE.Window.flags &= ~FLAG_WINDOW_UNFOCUSED; // The window was focused
+ else CORE.Window.flags |= FLAG_WINDOW_UNFOCUSED; // The window lost focus
+}
+
+// GLFW3 Window Drop Callback, runs when drop files into window
+static void WindowDropCallback(GLFWwindow *window, int count, const char **paths)
+{
+ if (count > 0)
+ {
+ // In case previous dropped filepaths have not been freed, we free them
+ if (CORE.Window.dropFileCount > 0)
+ {
+ for (unsigned int i = 0; i < CORE.Window.dropFileCount; i++) RL_FREE(CORE.Window.dropFilepaths[i]);
+
+ RL_FREE(CORE.Window.dropFilepaths);
+
+ CORE.Window.dropFileCount = 0;
+ CORE.Window.dropFilepaths = NULL;
+ }
+
+ // WARNING: Paths are freed by GLFW when the callback returns, we must keep an internal copy
+ CORE.Window.dropFileCount = count;
+ CORE.Window.dropFilepaths = (char **)RL_CALLOC(CORE.Window.dropFileCount, sizeof(char *));
+
+ for (unsigned int i = 0; i < CORE.Window.dropFileCount; i++)
+ {
+ CORE.Window.dropFilepaths[i] = (char *)RL_CALLOC(MAX_FILEPATH_LENGTH, sizeof(char));
+ strcpy(CORE.Window.dropFilepaths[i], paths[i]);
+ }
+ }
+}
+
+// GLFW3 Keyboard Callback, runs on key pressed
+static void KeyCallback(GLFWwindow *window, int key, int scancode, int action, int mods)
+{
+ if (key < 0) return; // Security check, macOS fn key generates -1
+
+ // WARNING: GLFW could return GLFW_REPEAT, we need to consider it as 1
+ // to work properly with our implementation (IsKeyDown/IsKeyUp checks)
+ if (action == GLFW_RELEASE) CORE.Input.Keyboard.currentKeyState[key] = 0;
+ else if(action == GLFW_PRESS) CORE.Input.Keyboard.currentKeyState[key] = 1;
+ else if(action == GLFW_REPEAT) CORE.Input.Keyboard.keyRepeatInFrame[key] = 1;
+
+ // 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;
+
+ // Check if there is space available in the key queue
+ if ((CORE.Input.Keyboard.keyPressedQueueCount < MAX_KEY_PRESSED_QUEUE) && (action == GLFW_PRESS))
+ {
+ // Add character to the queue
+ CORE.Input.Keyboard.keyPressedQueue[CORE.Input.Keyboard.keyPressedQueueCount] = key;
+ CORE.Input.Keyboard.keyPressedQueueCount++;
+ }
+
+ // Check the exit key to set close window
+ if ((key == CORE.Input.Keyboard.exitKey) && (action == GLFW_PRESS)) glfwSetWindowShouldClose(platform.handle, GLFW_TRUE);
+}
+
+// GLFW3 Char Key Callback, runs on key down (gets equivalent unicode char value)
+static void CharCallback(GLFWwindow *window, unsigned int key)
+{
+ //TRACELOG(LOG_DEBUG, "Char Callback: KEY:%i(%c)", key, key);
+
+ // NOTE: Registers any key down considering OS keyboard layout but
+ // does not detect action events, those should be managed by user...
+ // Ref: https://github.com/glfw/glfw/issues/668#issuecomment-166794907
+ // Ref: https://www.glfw.org/docs/latest/input_guide.html#input_char
+
+ // Check if there is space available in the queue
+ if (CORE.Input.Keyboard.charPressedQueueCount < MAX_CHAR_PRESSED_QUEUE)
+ {
+ // Add character to the queue
+ CORE.Input.Keyboard.charPressedQueue[CORE.Input.Keyboard.charPressedQueueCount] = key;
+ CORE.Input.Keyboard.charPressedQueueCount++;
+ }
+}
+
+// GLFW3 Mouse Button Callback, runs on mouse button pressed
+static void MouseButtonCallback(GLFWwindow *window, int button, int action, int mods)
+{
+ // WARNING: GLFW could only return GLFW_PRESS (1) or GLFW_RELEASE (0) for now,
+ // but future releases may add more actions (i.e. GLFW_REPEAT)
+ CORE.Input.Mouse.currentButtonState[button] = action;
+
+#if defined(SUPPORT_GESTURES_SYSTEM) && defined(SUPPORT_MOUSE_GESTURES)
+ // Process mouse events as touches to be able to use mouse-gestures
+ GestureEvent gestureEvent = { 0 };
+
+ // Register touch actions
+ if ((CORE.Input.Mouse.currentButtonState[button] == 1) && (CORE.Input.Mouse.previousButtonState[button] == 0)) gestureEvent.touchAction = TOUCH_ACTION_DOWN;
+ else if ((CORE.Input.Mouse.currentButtonState[button] == 0) && (CORE.Input.Mouse.previousButtonState[button] == 1)) gestureEvent.touchAction = TOUCH_ACTION_UP;
+
+ // NOTE: TOUCH_ACTION_MOVE event is registered in MouseCursorPosCallback()
+
+ // Assign a pointer ID
+ gestureEvent.pointId[0] = 0;
+
+ // Register touch points count
+ gestureEvent.pointCount = 1;
+
+ // Register touch points position, only one point registered
+ gestureEvent.position[0] = GetMousePosition();
+
+ // Normalize gestureEvent.position[0] for CORE.Window.screen.width and CORE.Window.screen.height
+ gestureEvent.position[0].x /= (float)GetScreenWidth();
+ gestureEvent.position[0].y /= (float)GetScreenHeight();
+
+ // Gesture data is sent to gestures-system for processing
+ ProcessGestureEvent(gestureEvent);
+#endif
+}
+
+// GLFW3 Cursor Position Callback, runs on mouse move
+static void MouseCursorPosCallback(GLFWwindow *window, double x, double y)
+{
+ CORE.Input.Mouse.currentPosition.x = (float)x;
+ CORE.Input.Mouse.currentPosition.y = (float)y;
+ CORE.Input.Touch.position[0] = CORE.Input.Mouse.currentPosition;
+
+#if defined(SUPPORT_GESTURES_SYSTEM) && defined(SUPPORT_MOUSE_GESTURES)
+ // Process mouse events as touches to be able to use mouse-gestures
+ GestureEvent gestureEvent = { 0 };
+
+ gestureEvent.touchAction = TOUCH_ACTION_MOVE;
+
+ // Assign a pointer ID
+ gestureEvent.pointId[0] = 0;
+
+ // Register touch points count
+ gestureEvent.pointCount = 1;
+
+ // Register touch points position, only one point registered
+ gestureEvent.position[0] = CORE.Input.Touch.position[0];
+
+ // Normalize gestureEvent.position[0] for CORE.Window.screen.width and CORE.Window.screen.height
+ gestureEvent.position[0].x /= (float)GetScreenWidth();
+ gestureEvent.position[0].y /= (float)GetScreenHeight();
+
+ // Gesture data is sent to gestures-system for processing
+ ProcessGestureEvent(gestureEvent);
+#endif
+}
+
+// GLFW3 Scrolling Callback, runs on mouse wheel
+static void MouseScrollCallback(GLFWwindow *window, double xoffset, double yoffset)
+{
+ CORE.Input.Mouse.currentWheelMove = (Vector2){ (float)xoffset, (float)yoffset };
+}
+
+// GLFW3 CursorEnter Callback, when cursor enters the window
+static void CursorEnterCallback(GLFWwindow *window, int enter)
+{
+ if (enter) CORE.Input.Mouse.cursorOnScreen = true;
+ else CORE.Input.Mouse.cursorOnScreen = false;
+}
+
+// GLFW3 Joystick Connected/Disconnected Callback
+static void JoystickCallback(int jid, int event)
+{
+ if (event == GLFW_CONNECTED)
+ {
+ strcpy(CORE.Input.Gamepad.name[jid], glfwGetJoystickName(jid));
+ }
+ else if (event == GLFW_DISCONNECTED)
+ {
+ memset(CORE.Input.Gamepad.name[jid], 0, 64);
+ }
+}
+
+// EOF
diff --git a/external/custom_platforms/custom_platform_2/src/raylib_platform_custom.h b/external/custom_platforms/custom_platform_2/src/raylib_platform_custom.h
new file mode 100644
index 000000000000..b2061436da96
--- /dev/null
+++ b/external/custom_platforms/custom_platform_2/src/raylib_platform_custom.h
@@ -0,0 +1,36 @@
+/*******************************************************************************************
+* raylib_platform_custom.h
+*
+* Custom Platform definition file
+*
+* LICENSE: zlib/libpng
+*
+* Copyright (c) 2023 Yan Pujante
+*
+* 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.
+*
+**********************************************************************************************/
+
+#ifndef RAYLIB_PLATFORM_CUSTOM_H
+#define RAYLIB_PLATFORM_CUSTOM_H
+
+#define PLATFORM_CUSTOM_ID "platform_custom_2"
+#define PLATFORM_CUSTOM_BACKEND "Platform backend: Custom Platform 2 (Desktop clone)"
+// #define PLATFORM_CUSTOM_CLOCK_MONOTONIC
+// #define PLATFORM_CUSTOM_DISABLE_HI_RES_TIMER
+#define PLATFORM_CUSTOM_ENABLE_OPENGL_ES2
+
+#endif //RAYLIB_PLATFORM_CUSTOM_H
diff --git a/external/examples/example_for_custom_platform_1/CMakeLists.txt b/external/examples/example_for_custom_platform_1/CMakeLists.txt
new file mode 100644
index 000000000000..39d98907a180
--- /dev/null
+++ b/external/examples/example_for_custom_platform_1/CMakeLists.txt
@@ -0,0 +1,38 @@
+cmake_minimum_required(VERSION 3.0)
+
+# This should be absolute to where raylib lives
+set(RAYLIB_ROOT_DIR "${CMAKE_CURRENT_LIST_DIR}/../../..")
+
+if(PLATFORM STREQUAL "Custom")
+ set(PLATFORM_CUSTOM_ROOT_DIR "${CMAKE_CURRENT_LIST_DIR}/../../custom_platforms/custom_platform_1")
+
+ set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} --profiling-funcs -s USE_GLFW=3 -s ASSERTIONS=1 -s WASM=1 -s ASYNCIFY -s SAFE_HEAP=1")
+endif()
+
+project(example_for_custom_platform_1 LANGUAGES CXX)
+
+set(target "example_for_custom_platform_1")
+
+set(CMAKE_CXX_STANDARD 17)
+
+#######################################################
+# adding raylib
+# Note: raylib is bundled in this project but could
+# easily be fetched instead
+#######################################################
+add_subdirectory("${RAYLIB_ROOT_DIR}" raylib EXCLUDE_FROM_ALL)
+
+#######################################################
+# Main executable
+#######################################################
+add_executable(${target} main.cpp)
+target_link_libraries(${target} PUBLIC raylib)
+
+if(PLATFORM STREQUAL "Custom")
+ set(CMAKE_EXECUTABLE_SUFFIX ".html")
+ set(EMSDK "$ENV{EMSDK}" CACHE PATH "Location of the emscript sdk")
+ if("${EMSDK}" STREQUAL "")
+ message(FATAL_ERROR "Make sure you define the variable EMSDK (either as an environment variable or as a CMake -DEMSDK=... option).")
+ endif()
+ target_include_directories(${target} PUBLIC "${EMSDK}/emscripten/main/cache/sysroot/include")
+endif()
diff --git a/external/examples/example_for_custom_platform_1/main.cpp b/external/examples/example_for_custom_platform_1/main.cpp
new file mode 100644
index 000000000000..52d791216cad
--- /dev/null
+++ b/external/examples/example_for_custom_platform_1/main.cpp
@@ -0,0 +1,28 @@
+#include "raylib.h"
+
+static char BUF[1024];
+
+int main()
+{
+ double width = 850;
+ double height = 450;
+
+ SetConfigFlags(FLAG_WINDOW_RESIZABLE);
+ InitWindow((int) width, (int) height, "raylib custom platform 1 (web)");
+
+ SetTargetFPS(60);
+
+ while (!WindowShouldClose())
+ {
+ BeginDrawing();
+ ClearBackground(RAYWHITE);
+ DrawText("Congrats! You created your first window!", 10, 40, 20, LIGHTGRAY);
+ DrawLine(0, 0, GetScreenWidth(), GetScreenHeight(), RED);
+ DrawFPS(10, 70);
+ EndDrawing();
+ }
+
+ CloseWindow();
+
+ return 0;
+}
diff --git a/external/examples/example_for_custom_platform_2/CMakeLists.txt b/external/examples/example_for_custom_platform_2/CMakeLists.txt
new file mode 100644
index 000000000000..17920fc27f81
--- /dev/null
+++ b/external/examples/example_for_custom_platform_2/CMakeLists.txt
@@ -0,0 +1,30 @@
+cmake_minimum_required(VERSION 3.0)
+
+# This should be absolute to where raylib lives
+set(RAYLIB_ROOT_DIR "${CMAKE_CURRENT_LIST_DIR}/../../..")
+
+if(PLATFORM STREQUAL "Custom")
+ # custom_platform_2 requires GLFW_ROOT_DIR to be set
+ set(GLFW_ROOT_DIR "${RAYLIB_ROOT_DIR}/src/external/glfw")
+ set(PLATFORM_CUSTOM_ROOT_DIR "${CMAKE_CURRENT_LIST_DIR}/../../custom_platforms/custom_platform_2")
+endif()
+
+project(example_for_custom_platform_2 LANGUAGES CXX)
+
+set(target "example_for_custom_platform_2")
+
+set(CMAKE_CXX_STANDARD 17)
+
+#######################################################
+# adding raylib
+# Note: raylib is bundled in this project but could
+# easily be fetched instead
+#######################################################
+add_subdirectory("${RAYLIB_ROOT_DIR}" raylib EXCLUDE_FROM_ALL)
+
+#######################################################
+# Main executable
+#######################################################
+add_executable(${target} main.cpp)
+target_link_libraries(${target} PUBLIC raylib)
+
diff --git a/external/examples/example_for_custom_platform_2/main.cpp b/external/examples/example_for_custom_platform_2/main.cpp
new file mode 100644
index 000000000000..52d791216cad
--- /dev/null
+++ b/external/examples/example_for_custom_platform_2/main.cpp
@@ -0,0 +1,28 @@
+#include "raylib.h"
+
+static char BUF[1024];
+
+int main()
+{
+ double width = 850;
+ double height = 450;
+
+ SetConfigFlags(FLAG_WINDOW_RESIZABLE);
+ InitWindow((int) width, (int) height, "raylib custom platform 1 (web)");
+
+ SetTargetFPS(60);
+
+ while (!WindowShouldClose())
+ {
+ BeginDrawing();
+ ClearBackground(RAYWHITE);
+ DrawText("Congrats! You created your first window!", 10, 40, 20, LIGHTGRAY);
+ DrawLine(0, 0, GetScreenWidth(), GetScreenHeight(), RED);
+ DrawFPS(10, 70);
+ EndDrawing();
+ }
+
+ CloseWindow();
+
+ return 0;
+}
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 4335bda5cd39..27acedf86e0c 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -5,6 +5,7 @@ set(API_VERSION 450)
include(GNUInstallDirs)
include(JoinPaths)
+include(CustomPlatform)
# Sets build type if not set by now
if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
@@ -38,7 +39,7 @@ set(raylib_sources
)
# <root>/cmake/GlfwImport.cmake handles the details around the inclusion of glfw
-if (NOT ${PLATFORM} MATCHES "Web")
+if (NOT ${PLATFORM} MATCHES "Web" AND NOT ${PLATFORM} MATCHES "Custom")
include(GlfwImport)
endif ()
@@ -47,6 +48,8 @@ endif ()
# Produces a variable LIBS_PRIVATE that will be used later
include(LibraryConfigurations)
+custom_platform_include_if_exists("raylibPlatformCustomLibraryConfig")
+
if (USE_AUDIO)
MESSAGE(STATUS "Audio Backend: miniaudio")
list(APPEND raylib_sources raudio.c)
@@ -105,6 +108,12 @@ target_include_directories(raylib
${OPENAL_INCLUDE_DIR}
)
+if("${PLATFORM}" MATCHES "Custom")
+ target_include_directories(raylib PUBLIC "${PLATFORM_CUSTOM_ROOT_DIR}/src")
+endif()
+
+custom_platform_include_if_exists("raylibPlatformCustomTargetConfig")
+
# Copy the header files to the build directory for convenience
file(COPY ${raylib_public_headers} DESTINATION "include")
diff --git a/src/rcore.c b/src/rcore.c
index a85b0971f066..4efabda9a666 100644
--- a/src/rcore.c
+++ b/src/rcore.c
@@ -235,7 +235,11 @@ __declspec(dllimport) int __stdcall WideCharToMultiByte(unsigned int cp, unsigne
#define FLAG_TOGGLE(n, f) ((n) ^= (f))
#define FLAG_CHECK(n, f) ((n) & (f))
-#if (defined(__linux__) || defined(PLATFORM_WEB)) && (_POSIX_C_SOURCE < 199309L)
+#if defined(PLATFORM_CUSTOM)
+#include "raylib_platform_custom.h"
+#endif
+
+#if (defined(__linux__) || defined(PLATFORM_WEB) || defined(PLATFORM_CUSTOM_CLOCK_MONOTONIC)) && (_POSIX_C_SOURCE < 199309L)
#undef _POSIX_C_SOURCE
#define _POSIX_C_SOURCE 199309L // Required for: CLOCK_MONOTONIC if compiled with c99 without gnu ext.
#endif
@@ -491,6 +495,8 @@ const char *TextFormat(const char *text, ...); // Formatting of tex
#include "platforms/rcore_drm.c"
#elif defined(PLATFORM_ANDROID)
#include "platforms/rcore_android.c"
+#elif defined(PLATFORM_CUSTOM)
+ #include "raylib_platform_custom.c"
#else
// TODO: Include your custom platform backend!
// i.e software rendering backend or console backend!
@@ -559,6 +565,8 @@ void InitWindow(int width, int height, const char *title)
TRACELOG(LOG_INFO, "Platform backend: NATIVE DRM");
#elif defined(PLATFORM_ANDROID)
TRACELOG(LOG_INFO, "Platform backend: ANDROID");
+#elif defined(PLATFORM_CUSTOM)
+ TRACELOG(LOG_INFO, PLATFORM_CUSTOM_BACKEND);
#else
// TODO: Include your custom platform backend!
// i.e software rendering backend or console backend!
@@ -3046,7 +3054,7 @@ void InitTimer(void)
// However, it can also reduce overall system performance, because the thread scheduler switches tasks more often.
// High resolutions can also prevent the CPU power management system from entering power-saving modes.
// Setting a higher resolution does not improve the accuracy of the high-resolution performance counter.
-#if defined(_WIN32) && defined(SUPPORT_WINMM_HIGHRES_TIMER) && !defined(SUPPORT_BUSY_WAIT_LOOP) && !defined(PLATFORM_DESKTOP_SDL)
+#if defined(_WIN32) && defined(SUPPORT_WINMM_HIGHRES_TIMER) && !defined(SUPPORT_BUSY_WAIT_LOOP) && !defined(PLATFORM_DESKTOP_SDL) && !defined(PLATFORM_CUSTOM_DISABLE_HI_RES_TIMER)
timeBeginPeriod(1); // Setup high-resolution timer to 1ms (granularity of 1-2 ms)
#endif
diff --git a/src/rlgl.h b/src/rlgl.h
index 4b318498603b..ef3f8e8abe71 100644
--- a/src/rlgl.h
+++ b/src/rlgl.h
@@ -324,6 +324,10 @@
//----------------------------------------------------------------------------------
// Types and Structures Definition
//----------------------------------------------------------------------------------
+#if defined(PLATFORM_CUSTOM)
+#include "raylib_platform_custom.h"
+#endif
+
#if (defined(__STDC__) && __STDC_VERSION__ >= 199901L) || (defined(_MSC_VER) && _MSC_VER >= 1800)
#include <stdbool.h>
#elif !defined(__cplusplus) && !defined(bool) && !defined(RL_BOOL_TYPE)
@@ -818,7 +822,7 @@ RLAPI void rlLoadDrawQuad(void); // Load and draw a quad
#elif defined(GRAPHICS_API_OPENGL_ES2)
// NOTE: OpenGL ES 2.0 can be enabled on PLATFORM_DESKTOP,
// in that case, functions are loaded from a custom glad for OpenGL ES 2.0
- #if defined(PLATFORM_DESKTOP) || defined(PLATFORM_DESKTOP_SDL)
+ #if defined(PLATFORM_DESKTOP) || defined(PLATFORM_DESKTOP_SDL) || defined(PLATFORM_CUSTOM_ENABLE_OPENGL_ES2)
#define GLAD_GLES2_IMPLEMENTATION
#include "external/glad_gles2.h"
#else
@@ -2281,7 +2285,7 @@ void rlLoadExtensions(void *loader)
#elif defined(GRAPHICS_API_OPENGL_ES2)
- #if defined(PLATFORM_DESKTOP) || defined(PLATFORM_DESKTOP_SDL)
+ #if defined(PLATFORM_DESKTOP) || defined(PLATFORM_DESKTOP_SDL) || defined(PLATFORM_CUSTOM_ENABLE_OPENGL_ES2)
// TODO: Support GLAD loader for OpenGL ES 3.0
if (gladLoadGLES2((GLADloadfunc)loader) == 0) TRACELOG(RL_LOG_WARNING, "GLAD: Cannot load OpenGL ES2.0 functions");
else TRACELOG(RL_LOG_INFO, "GLAD: OpenGL ES 2.0 loaded successfully");