Update upstream

src/raylib.nim

@@ -428,7 +428,6 @@ type
     LineHorizontal ## Layout is defined by a horizontal line with faces
     CrossThreeByFour ## Layout is defined by a 3x4 cross with cubemap faces
     CrossFourByThree ## Layout is defined by a 4x3 cross with cubemap faces
-    Panorama ## Layout is defined by a panorama image (equirrectangular map)
 
   FontType* {.size: sizeof(int32).} = enum ## Font type, defines generation method
     Default ## Default font generation, anti-aliased
@@ -806,37 +805,37 @@ proc isWindowReady*(): bool {.importc: "IsWindowReady", sideEffect.}
 proc isWindowFullscreen*(): bool {.importc: "IsWindowFullscreen", sideEffect.}
   ## Check if window is currently fullscreen
 proc isWindowHidden*(): bool {.importc: "IsWindowHidden", sideEffect.}
-  ## Check if window is currently hidden (only PLATFORM_DESKTOP)
+  ## Check if window is currently hidden
 proc isWindowMinimized*(): bool {.importc: "IsWindowMinimized", sideEffect.}
-  ## Check if window is currently minimized (only PLATFORM_DESKTOP)
+  ## Check if window is currently minimized
 proc isWindowMaximized*(): bool {.importc: "IsWindowMaximized", sideEffect.}
-  ## Check if window is currently maximized (only PLATFORM_DESKTOP)
+  ## Check if window is currently maximized
 proc isWindowFocused*(): bool {.importc: "IsWindowFocused", sideEffect.}
-  ## Check if window is currently focused (only PLATFORM_DESKTOP)
+  ## Check if window is currently focused
 proc isWindowResized*(): bool {.importc: "IsWindowResized", sideEffect.}
   ## Check if window has been resized last frame
 proc isWindowState*(flag: ConfigFlags): bool {.importc: "IsWindowState", sideEffect.}
   ## Check if one specific window flag is enabled
 proc setWindowState*(flags: Flags[ConfigFlags]) {.importc: "SetWindowState", sideEffect.}
-  ## Set window configuration state using flags (only PLATFORM_DESKTOP)
+  ## Set window configuration state using flags
 proc clearWindowState*(flags: Flags[ConfigFlags]) {.importc: "ClearWindowState", sideEffect.}
   ## Clear window configuration state flags
 proc toggleFullscreen*() {.importc: "ToggleFullscreen", sideEffect.}
-  ## Toggle window state: fullscreen/windowed [resizes monitor to match window resolution] (only PLATFORM_DESKTOP)
+  ## Toggle window state: fullscreen/windowed, resizes monitor to match window resolution
 proc toggleBorderlessWindowed*() {.importc: "ToggleBorderlessWindowed", sideEffect.}
-  ## Toggle window state: borderless windowed [resizes window to match monitor resolution] (only PLATFORM_DESKTOP)
+  ## Toggle window state: borderless windowed, resizes window to match monitor resolution
 proc maximizeWindow*() {.importc: "MaximizeWindow", sideEffect.}
-  ## Set window state: maximized, if resizable (only PLATFORM_DESKTOP)
+  ## Set window state: maximized, if resizable
 proc minimizeWindow*() {.importc: "MinimizeWindow", sideEffect.}
-  ## Set window state: minimized, if resizable (only PLATFORM_DESKTOP)
+  ## Set window state: minimized, if resizable
 proc restoreWindow*() {.importc: "RestoreWindow", sideEffect.}
-  ## Set window state: not minimized/maximized (only PLATFORM_DESKTOP)
+  ## Set window state: not minimized/maximized
 proc setWindowIcon*(image: Image) {.importc: "SetWindowIcon", sideEffect.}
-  ## Set icon for window (single image, RGBA 32bit, only PLATFORM_DESKTOP)
+  ## Set icon for window (single image, RGBA 32bit)
 proc setWindowIconsImpl(images: ptr UncheckedArray[Image], count: int32) {.importc: "SetWindowIcons", sideEffect.}
 proc setWindowTitleImpl(title: cstring) {.importc: "SetWindowTitle", sideEffect.}
 proc setWindowPosition*(x: int32, y: int32) {.importc: "SetWindowPosition", sideEffect.}
-  ## Set window position on screen (only PLATFORM_DESKTOP)
+  ## Set window position on screen
 proc setWindowMonitor*(monitor: int32) {.importc: "SetWindowMonitor", sideEffect.}
   ## Set monitor for the current window
 proc setWindowMinSize*(width: int32, height: int32) {.importc: "SetWindowMinSize", sideEffect.}
@@ -846,9 +845,9 @@ proc setWindowMaxSize*(width: int32, height: int32) {.importc: "SetWindowMaxSize
 proc setWindowSize*(width: int32, height: int32) {.importc: "SetWindowSize", sideEffect.}
   ## Set window dimensions
 proc setWindowOpacity*(opacity: float32) {.importc: "SetWindowOpacity", sideEffect.}
-  ## Set window opacity [0.0f..1.0f] (only PLATFORM_DESKTOP)
+  ## Set window opacity [0.0f..1.0f]
 proc setWindowFocused*() {.importc: "SetWindowFocused", sideEffect.}
-  ## Set window focused (only PLATFORM_DESKTOP)
+  ## Set window focused
 proc getWindowHandle*(): pointer {.importc: "GetWindowHandle", sideEffect.}
   ## Get native window handle
 proc getScreenWidth*(): int32 {.importc: "GetScreenWidth", sideEffect.}
@@ -862,7 +861,7 @@ proc getRenderHeight*(): int32 {.importc: "GetRenderHeight", sideEffect.}
 proc getMonitorCount*(): int32 {.importc: "GetMonitorCount", sideEffect.}
   ## Get number of connected monitors
 proc getCurrentMonitor*(): int32 {.importc: "GetCurrentMonitor", sideEffect.}
-  ## Get current connected monitor
+  ## Get current monitor where window is placed
 proc getMonitorPosition*(monitor: int32): Vector2 {.importc: "GetMonitorPosition", sideEffect.}
   ## Get specified monitor position
 proc getMonitorWidth*(monitor: int32): int32 {.importc: "GetMonitorWidth", sideEffect.}
@@ -1018,7 +1017,7 @@ proc playAutomationEvent*(event: AutomationEvent) {.importc: "PlayAutomationEven
 proc isKeyPressed*(key: KeyboardKey): bool {.importc: "IsKeyPressed", sideEffect.}
   ## Check if a key has been pressed once
 proc isKeyPressedRepeat*(key: KeyboardKey): bool {.importc: "IsKeyPressedRepeat", sideEffect.}
-  ## Check if a key has been pressed again (Only PLATFORM_DESKTOP)
+  ## Check if a key has been pressed again
 proc isKeyDown*(key: KeyboardKey): bool {.importc: "IsKeyDown", sideEffect.}
   ## Check if a key is being pressed
 proc isKeyReleased*(key: KeyboardKey): bool {.importc: "IsKeyReleased", sideEffect.}
@@ -1049,8 +1048,8 @@ proc getGamepadAxisCount*(gamepad: int32): int32 {.importc: "GetGamepadAxisCount
 proc getGamepadAxisMovement*(gamepad: int32, axis: GamepadAxis): float32 {.importc: "GetGamepadAxisMovement", sideEffect.}
   ## Get axis movement value for a gamepad axis
 proc setGamepadMappingsImpl(mappings: cstring): int32 {.importc: "SetGamepadMappings", sideEffect.}
-proc setGamepadVibration*(gamepad: int32, leftMotor: float32, rightMotor: float32) {.importc: "SetGamepadVibration", sideEffect.}
-  ## Set gamepad vibration for both motors
+proc setGamepadVibration*(gamepad: int32, leftMotor: float32, rightMotor: float32, duration: float32) {.importc: "SetGamepadVibration", sideEffect.}
+  ## Set gamepad vibration for both motors (duration in seconds)
 proc isMouseButtonPressed*(button: MouseButton): bool {.importc: "IsMouseButtonPressed", sideEffect.}
   ## Check if a mouse button has been pressed once
 proc isMouseButtonDown*(button: MouseButton): bool {.importc: "IsMouseButtonDown", sideEffect.}
@@ -1096,7 +1095,7 @@ proc isGestureDetected*(gesture: Gesture): bool {.importc: "IsGestureDetected",
 proc getGestureDetected*(): Gesture {.importc: "GetGestureDetected", sideEffect.}
   ## Get latest detected gesture
 proc getGestureHoldDuration*(): float32 {.importc: "GetGestureHoldDuration", sideEffect.}
-  ## Get gesture hold time in milliseconds
+  ## Get gesture hold time in seconds
 proc getGestureDragVector*(): Vector2 {.importc: "GetGestureDragVector", sideEffect.}
   ## Get gesture drag vector
 proc getGestureDragAngle*(): float32 {.importc: "GetGestureDragAngle", sideEffect.}
@@ -1217,19 +1216,19 @@ func checkCollisionCircles*(center1: Vector2, radius1: float32, center2: Vector2
   ## Check collision between two circles
 func checkCollisionCircleRec*(center: Vector2, radius: float32, rec: Rectangle): bool {.importc: "CheckCollisionCircleRec".}
   ## Check collision between circle and rectangle
+func checkCollisionCircleLine*(center: Vector2, radius: float32, p1: Vector2, p2: Vector2): bool {.importc: "CheckCollisionCircleLine".}
+  ## Check if circle collides with a line created betweeen two points [p1] and [p2]
 func checkCollisionPointRec*(point: Vector2, rec: Rectangle): bool {.importc: "CheckCollisionPointRec".}
   ## Check if point is inside rectangle
 func checkCollisionPointCircle*(point: Vector2, center: Vector2, radius: float32): bool {.importc: "CheckCollisionPointCircle".}
   ## Check if point is inside circle
 func checkCollisionPointTriangle*(point: Vector2, p1: Vector2, p2: Vector2, p3: Vector2): bool {.importc: "CheckCollisionPointTriangle".}
   ## Check if point is inside a triangle
+func checkCollisionPointLine*(point: Vector2, p1: Vector2, p2: Vector2, threshold: int32): bool {.importc: "CheckCollisionPointLine".}
+  ## Check if point belongs to line created between two points [p1] and [p2] with defined margin in pixels [threshold]
 func checkCollisionPointPolyImpl(point: Vector2, points: ptr UncheckedArray[Vector2], pointCount: int32): bool {.importc: "CheckCollisionPointPoly".}
 func checkCollisionLines*(startPos1: Vector2, endPos1: Vector2, startPos2: Vector2, endPos2: Vector2, collisionPoint: out Vector2): bool {.importc: "CheckCollisionLines".}
   ## Check the collision between two lines defined by two points each, returns collision point by reference
-func checkCollisionPointLine*(point: Vector2, p1: Vector2, p2: Vector2, threshold: int32): bool {.importc: "CheckCollisionPointLine".}
-  ## Check if point belongs to line created between two points [p1] and [p2] with defined margin in pixels [threshold]
-func checkCollisionCircleLine*(center: Vector2, radius: float32, p1: Vector2, p2: Vector2): bool {.importc: "CheckCollisionCircleLine".}
-  ## Check if circle collides with a line created betweeen two points [p1] and [p2]
 func getCollisionRec*(rec1: Rectangle, rec2: Rectangle): Rectangle {.importc: "GetCollisionRec".}
   ## Get collision rectangle for two rectangles collision
 proc loadImageImpl(fileName: cstring): Image {.importc: "rlLoadImage", sideEffect.}
@@ -1561,12 +1560,12 @@ func isMaterialValid*(material: Material): bool {.importc: "IsMaterialValid".}
 proc unloadMaterial(material: Material) {.importc: "UnloadMaterial", sideEffect.}
 proc loadModelAnimationsImpl(fileName: cstring, animCount: ptr int32): ptr UncheckedArray[ModelAnimation] {.importc: "LoadModelAnimations", sideEffect.}
 proc updateModelAnimation*(model: Model, anim: ModelAnimation, frame: int32) {.importc: "UpdateModelAnimation", sideEffect.}
-  ## Update model animation pose
+  ## Update model animation pose (CPU)
+func updateModelAnimationBoneMatrices*(model: Model, anim: ModelAnimation, frame: int32) {.importc: "UpdateModelAnimationBoneMatrices".}
+  ## Update model animation mesh bone matrices (GPU skinning)
 proc unloadModelAnimation(anim: ModelAnimation) {.importc: "UnloadModelAnimation", sideEffect.}
 func isModelAnimationValid*(model: Model, anim: ModelAnimation): bool {.importc: "IsModelAnimationValid".}
   ## Check model animation skeleton match
-func updateModelAnimationBoneMatrices*(model: Model, anim: ModelAnimation, frame: int32) {.importc: "UpdateModelAnimationBoneMatrices".}
-  ## Update model animation mesh bone matrices (Note GPU skinning does not work on Mac)
 func checkCollisionSpheres*(center1: Vector3, radius1: float32, center2: Vector3, radius2: float32): bool {.importc: "CheckCollisionSpheres".}
   ## Check collision between two spheres
 func checkCollisionBoxes*(box1: BoundingBox, box2: BoundingBox): bool {.importc: "CheckCollisionBoxes".}
@@ -2276,11 +2275,11 @@ proc boneCount*(x: ModelAnimation): int32 {.inline.} = x.boneCount
 proc frameCount*(x: ModelAnimation): int32 {.inline.} = x.frameCount
 
 proc setWindowIcons*(images: openArray[Image]) =
-  ## Set icon for window (multiple images, RGBA 32bit, only PLATFORM_DESKTOP)
+  ## Set icon for window (multiple images, RGBA 32bit)
   setWindowIconsImpl(cast[ptr UncheckedArray[Image]](images), images.len.int32)
 
 proc setWindowTitle*(title: string) =
-  ## Set title for window (only PLATFORM_DESKTOP and PLATFORM_WEB)
+  ## Set title for window
   setWindowTitleImpl(title.cstring)
 
 proc getMonitorName*(monitor: int32): string =

src/raylib/Makefile

@@ -184,8 +184,8 @@ ifeq ($(TARGET_PLATFORM),PLATFORM_WEB)
         EMSDK_PATH         ?= C:/emsdk
         EMSCRIPTEN_PATH    ?= $(EMSDK_PATH)/upstream/emscripten
         CLANG_PATH         := $(EMSDK_PATH)/upstream/bin
-        PYTHON_PATH        := $(EMSDK_PATH)/python/3.9.2-1_64bit
-        NODE_PATH          := $(EMSDK_PATH)/node/14.15.5_64bit/bin
+        PYTHON_PATH        := $(EMSDK_PATH)/python/3.9.2-nuget_64bit
+        NODE_PATH          := $(EMSDK_PATH)/node/20.18.0_64bit/bin
         export PATH        := $(EMSDK_PATH);$(EMSCRIPTEN_PATH);$(CLANG_PATH);$(NODE_PATH);$(PYTHON_PATH);C:/raylib/MinGW/bin;$(PATH)
     endif
 endif
@@ -230,20 +230,18 @@ ifeq ($(TARGET_PLATFORM),PLATFORM_ANDROID)
 endif
 
 # Define raylib graphics api depending on selected platform
+# NOTE: By default use OpenGL 3.3 on desktop platforms
 ifeq ($(TARGET_PLATFORM),PLATFORM_DESKTOP_GLFW)
-    # By default use OpenGL 3.3 on desktop platforms
     GRAPHICS ?= GRAPHICS_API_OPENGL_33
     #GRAPHICS = GRAPHICS_API_OPENGL_11      # Uncomment to use OpenGL 1.1
     #GRAPHICS = GRAPHICS_API_OPENGL_21      # Uncomment to use OpenGL 2.1
     #GRAPHICS = GRAPHICS_API_OPENGL_43      # Uncomment to use OpenGL 4.3
     #GRAPHICS = GRAPHICS_API_OPENGL_ES2     # Uncomment to use OpenGL ES 2.0 (ANGLE)
 endif
 ifeq ($(TARGET_PLATFORM),PLATFORM_DESKTOP_SDL)
-    # By default use OpenGL 3.3 on desktop platform with SDL backend
     GRAPHICS ?= GRAPHICS_API_OPENGL_33
 endif
 ifeq ($(TARGET_PLATFORM),PLATFORM_DESKTOP_RGFW)
-    # By default use OpenGL 3.3 on desktop platforms
     GRAPHICS ?= GRAPHICS_API_OPENGL_33
     #GRAPHICS = GRAPHICS_API_OPENGL_11      # Uncomment to use OpenGL 1.1
     #GRAPHICS = GRAPHICS_API_OPENGL_21      # Uncomment to use OpenGL 2.1
@@ -257,7 +255,7 @@ endif
 ifeq ($(TARGET_PLATFORM),PLATFORM_WEB)
     # On HTML5 OpenGL ES 2.0 is used, emscripten translates it to WebGL 1.0
     GRAPHICS = GRAPHICS_API_OPENGL_ES2
-    #GRAPHICS = GRAPHICS_API_OPENGL_ES3      # Uncomment to use ES3/WebGL2 (preliminary support).
+    #GRAPHICS = GRAPHICS_API_OPENGL_ES3      # Uncomment to use ES3/WebGL2 (preliminary support)
 endif
 ifeq ($(TARGET_PLATFORM),PLATFORM_ANDROID)
     # By default use OpenGL ES 2.0 on Android

src/raylib/config.h

@@ -100,6 +100,8 @@
 // Show OpenGL extensions and capabilities detailed logs on init
 //#define RLGL_SHOW_GL_DETAILS_INFO              1
 
+#define RL_SUPPORT_MESH_GPU_SKINNING           1      // GPU skinning, comment if your GPU does not support more than 8 VBOs
+
 //#define RL_DEFAULT_BATCH_BUFFER_ELEMENTS    4096    // Default internal render batch elements limits
 #define RL_DEFAULT_BATCH_BUFFERS               1      // Default number of batch buffers (multi-buffering)
 #define RL_DEFAULT_BATCH_DRAWCALLS           256      // Default number of batch draw calls (by state changes: mode, texture)
@@ -120,16 +122,11 @@
 #define RL_DEFAULT_SHADER_ATTRIB_LOCATION_TANGENT     4
 #define RL_DEFAULT_SHADER_ATTRIB_LOCATION_TEXCOORD2   5
 #define RL_DEFAULT_SHADER_ATTRIB_LOCATION_INDICES     6
-
-
-#define RL_SUPPORT_MESH_GPU_SKINNING                   // Remove this if your GPU does not support more than 8 VBOs
-
-#ifdef RL_SUPPORT_MESH_GPU_SKINNING
-#define RL_DEFAULT_SHADER_ATTRIB_LOCATION_BONEIDS     7
-#define RL_DEFAULT_SHADER_ATTRIB_LOCATION_BONEWEIGHTS 8
+#if defined(RL_SUPPORT_MESH_GPU_SKINNING)
+    #define RL_DEFAULT_SHADER_ATTRIB_LOCATION_BONEIDS     7
+    #define RL_DEFAULT_SHADER_ATTRIB_LOCATION_BONEWEIGHTS 8
 #endif
 
-
 // Default shader vertex attribute names to set location points
 // NOTE: When a new shader is loaded, the following locations are tried to be set for convenience
 #define RL_DEFAULT_SHADER_ATTRIB_NAME_POSITION     "vertexPosition"    // Bound by default to shader location: RL_DEFAULT_SHADER_ATTRIB_LOCATION_POSITION

src/raylib/platforms/rcore_android.c

@@ -615,7 +615,7 @@ int SetGamepadMappings(const char *mappings)
 }
 
 // Set gamepad vibration
-void SetGamepadVibration(int gamepad, float leftMotor, float rightMotor)
+void SetGamepadVibration(int gamepad, float leftMotor, float rightMotor, float duration)
 {
     TRACELOG(LOG_WARNING, "GamepadSetVibration() not implemented on target platform");
 }

src/raylib/platforms/rcore_desktop_glfw.c

@@ -149,7 +149,7 @@ void ToggleFullscreen(void)
     {
         // Store previous window position (in case we exit fullscreen)
         CORE.Window.previousPosition = CORE.Window.position;
-        
+
         int monitorCount = 0;
         int monitorIndex = GetCurrentMonitor();
         GLFWmonitor **monitors = glfwGetMonitors(&monitorCount);
@@ -1060,7 +1060,7 @@ int SetGamepadMappings(const char *mappings)
 }
 
 // Set gamepad vibration
-void SetGamepadVibration(int gamepad, float leftMotor, float rightMotor)
+void SetGamepadVibration(int gamepad, float leftMotor, float rightMotor, float duration)
 {
     TRACELOG(LOG_WARNING, "GamepadSetVibration() not available on target platform");
 }
@@ -1289,7 +1289,7 @@ int InitPlatform(void)
     // Disable GlFW auto iconify behaviour
     // Auto Iconify automatically minimizes (iconifies) the window if the window loses focus
     // additionally auto iconify restores the hardware resolution of the monitor if the window that loses focus is a fullscreen window
-    glfwWindowHint(GLFW_AUTO_ICONIFY, 0); 
+    glfwWindowHint(GLFW_AUTO_ICONIFY, 0);
 
     // Check window creation flags
     if ((CORE.Window.flags & FLAG_FULLSCREEN_MODE) > 0) CORE.Window.fullscreen = true;
@@ -1579,7 +1579,7 @@ int InitPlatform(void)
         int monitorWidth = 0;
         int monitorHeight = 0;
         glfwGetMonitorWorkarea(monitor, &monitorX, &monitorY, &monitorWidth, &monitorHeight);
-        
+
         // Here CORE.Window.render.width/height should be used instead of CORE.Window.screen.width/height to center the window correctly when the high dpi flag is enabled.
         int posX = monitorX + (monitorWidth - (int)CORE.Window.render.width)/2;
         int posY = monitorY + (monitorHeight - (int)CORE.Window.render.height)/2;

src/raylib/platforms/rcore_desktop_sdl.c

@@ -953,17 +953,17 @@ int SetGamepadMappings(const char *mappings)
 }
 
 // Set gamepad vibration
-void SetGamepadVibration(int gamepad, float leftMotor, float rightMotor)
+void SetGamepadVibration(int gamepad, float leftMotor, float rightMotor, float duration)
 {
-    // Limit input values to between 0.0f and 1.0f
-    leftMotor  = (0.0f > leftMotor)? 0.0f : leftMotor;
-    rightMotor = (0.0f > rightMotor)? 0.0f : rightMotor;
-    leftMotor  = (1.0f < leftMotor)? 1.0f : leftMotor;
-    rightMotor = (1.0f < rightMotor)? 1.0f : rightMotor;
-
-    if (IsGamepadAvailable(gamepad))
+    if ((gamepad < MAX_GAMEPADS) && CORE.Input.Gamepad.ready[gamepad] && (duration > 0.0f))
     {
-        SDL_GameControllerRumble(platform.gamepad[gamepad], (Uint16)(leftMotor*65535.0f), (Uint16)(rightMotor*65535.0f), (Uint32)(MAX_GAMEPAD_VIBRATION_TIME*1000.0f));
+        if (leftMotor < 0.0f) leftMotor = 0.0f;
+        if (leftMotor > 1.0f) leftMotor = 1.0f;
+        if (rightMotor < 0.0f) rightMotor = 0.0f;
+        if (rightMotor > 1.0f) rightMotor = 1.0f;
+        if (duration > MAX_GAMEPAD_VIBRATION_TIME) duration = MAX_GAMEPAD_VIBRATION_TIME;
+
+        SDL_GameControllerRumble(platform.gamepad[gamepad], (Uint16)(leftMotor*65535.0f), (Uint16)(rightMotor*65535.0f), (Uint32)(duration*1000.0f));
     }
 }
 

src/raylib/platforms/rcore_drm.c

@@ -610,7 +610,7 @@ int SetGamepadMappings(const char *mappings)
 }
 
 // Set gamepad vibration
-void SetGamepadVibration(int gamepad, float leftMotor, float rightMotor)
+void SetGamepadVibration(int gamepad, float leftMotor, float rightMotor, float duration)
 {
     TRACELOG(LOG_WARNING, "GamepadSetVibration() not implemented on target platform");
 }
@@ -763,7 +763,7 @@ int InitPlatform(void)
 
         drmModeConnector *con = drmModeGetConnector(platform.fd, res->connectors[i]);
         TRACELOG(LOG_TRACE, "DISPLAY: Connector modes detected: %i", con->count_modes);
-        
+
         // In certain cases the status of the conneciton is reported as UKNOWN, but it is still connected.
         // This might be a hardware or software limitation like on Raspberry Pi Zero with composite output.
         if (((con->connection == DRM_MODE_CONNECTED) || (con->connection == DRM_MODE_UNKNOWNCONNECTION)) && (con->encoder_id))