Merge branch 'libsdl-org:main' into main

Author: Temdog007

CMakeLists.txt

@@ -1104,6 +1104,8 @@ if(SDL_LIBC)
     check_symbol_exists(poll "poll.h" HAVE_POLL)
     check_symbol_exists(memfd_create "sys/mman.h" HAVE_MEMFD_CREATE)
     check_symbol_exists(posix_fallocate "fcntl.h" HAVE_POSIX_FALLOCATE)
+    check_symbol_exists(posix_spawn_file_actions_addchdir "spawn.h" HAVE_POSIX_SPAWN_FILE_ACTIONS_ADDCHDIR)
+    check_symbol_exists(posix_spawn_file_actions_addchdir_np "spawn.h" HAVE_POSIX_SPAWN_FILE_ACTIONS_ADDCHDIR_NP)
 
     if(SDL_SYSTEM_ICONV)
       check_c_source_compiles("
@@ -1979,6 +1981,7 @@ elseif(WINDOWS)
   check_include_file(audioclient.h HAVE_AUDIOCLIENT_H)
   check_include_file(sensorsapi.h HAVE_SENSORSAPI_H)
   check_include_file(shellscalingapi.h HAVE_SHELLSCALINGAPI_H)
+  check_include_file(shobjidl_core.h HAVE_SHOBJIDL_CORE_H)
   check_c_source_compiles("
     #include <windows.h>
     #include <mfapi.h>

android-project/app/proguard-rules.pro

@@ -36,7 +36,6 @@
     int messageboxShowMessageBox(int, java.lang.String, java.lang.String, int[], int[], java.lang.String[], int[]);
     void minimizeWindow();
     boolean openURL(java.lang.String);
-    void onNativePen(int, int, int , float , float , float);
     void requestPermission(java.lang.String, int);
     boolean showToast(java.lang.String, int, int, int, int);
     boolean sendMessage(int, int);

android-project/app/src/main/java/org/libsdl/app/SDLAudioManager.java

@@ -26,14 +26,14 @@ static void initialize() {
                 @Override
                 public void onAudioDevicesAdded(AudioDeviceInfo[] addedDevices) {
                     for (AudioDeviceInfo deviceInfo : addedDevices) {
-                        addAudioDevice(deviceInfo.isSink(), deviceInfo.getProductName().toString(), deviceInfo.getId());
+                        nativeAddAudioDevice(deviceInfo.isSink(), deviceInfo.getProductName().toString(), deviceInfo.getId());
                     }
                 }
 
                 @Override
                 public void onAudioDevicesRemoved(AudioDeviceInfo[] removedDevices) {
                     for (AudioDeviceInfo deviceInfo : removedDevices) {
-                        removeAudioDevice(deviceInfo.isSink(), deviceInfo.getId());
+                        nativeRemoveAudioDevice(deviceInfo.isSink(), deviceInfo.getId());
                     }
                 }
             };
@@ -82,10 +82,10 @@ static void registerAudioDeviceCallback() {
                 if (dev.getType() == AudioDeviceInfo.TYPE_TELEPHONY) {
                     continue;  // Device cannot be opened
                 }
-                addAudioDevice(dev.isSink(), dev.getProductName().toString(), dev.getId());
+                nativeAddAudioDevice(dev.isSink(), dev.getProductName().toString(), dev.getId());
             }
             for (AudioDeviceInfo dev : audioManager.getDevices(AudioManager.GET_DEVICES_INPUTS)) {
-                addAudioDevice(dev.isSink(), dev.getProductName().toString(), dev.getId());
+                nativeAddAudioDevice(dev.isSink(), dev.getProductName().toString(), dev.getId());
             }
             audioManager.registerAudioDeviceCallback(mAudioDeviceCallback, null);
         }
@@ -119,8 +119,8 @@ static void audioSetThreadPriority(boolean recording, int device_id) {
 
     static native int nativeSetupJNI();
 
-    static native void removeAudioDevice(boolean recording, int deviceId);
+    static native void nativeRemoveAudioDevice(boolean recording, int deviceId);
 
-    static native void addAudioDevice(boolean recording, String name, int deviceId);
+    static native void nativeAddAudioDevice(boolean recording, String name, int deviceId);
 
 }

cmake/PreseedMSVCCache.cmake

@@ -15,6 +15,7 @@ if(MSVC)
     set(HAVE_MMDEVICEAPI_H                               "1"   CACHE INTERNAL "Have include mmdeviceapi.h")
     set(HAVE_SENSORSAPI_H                                "1"   CACHE INTERNAL "Have include sensorsapi.h")
     set(HAVE_SHELLSCALINGAPI_H                           "1"   CACHE INTERNAL "Have include shellscalingapi.h")
+    set(HAVE_SHOBJIDL_CORE_H                             "1"   CACHE INTERNAL "Have include shobjidl_core.h")
     set(HAVE_TPCSHRD_H                                   "1"   CACHE INTERNAL "Have include tpcshrd.h")
     set(HAVE_WIN32_CC                                    "1"   CACHE INTERNAL "Test HAVE_WIN32_CC")
     set(HAVE_XINPUT_H                                    "1"   CACHE INTERNAL "Test HAVE_XINPUT_H")

docs/README-psp.md

@@ -29,7 +29,7 @@ cmake --install build
 
 
 ## Compiling a HelloWorld
-[PSP Hello World](https://psp-dev.org/doku.php?id=tutorial:hello_world)
+[PSP Hello World](https://pspdev.github.io/basic_programs.html#hello-world)
 
 ## To Do
 - PSP Screen Keyboard

docs/README-wayland.md

@@ -59,6 +59,10 @@ encounter limitations or behavior that is different from other windowing systems
   `SDL_APP_ID` hint string, the desktop entry file name should match the application ID. For example, if your
   application ID is set to `org.my_org.sdl_app`, the desktop entry file should be named `org.my_org.sdl_app.desktop`.
 
+### Keyboard grabs don't work when running under XWayland
+
+- On GNOME based desktops, the dconf setting `org/gnome/mutter/wayland/xwayland-allow-grabs` must be enabled.
+
 ## Using custom Wayland windowing protocols with SDL windows
 
 Under normal operation, an `SDL_Window` corresponds to an XDG toplevel window, which provides a standard desktop window.

docs/release_checklist.md

@@ -15,6 +15,8 @@
 
 * Create a GitHub release and attach the archives you just generated.
 
+* If this is a feature release, also tag the sdlwiki with the same tag.
+
 ## New feature release
 
 * Update `WhatsNew.txt`

examples/CMakeLists.txt

@@ -136,6 +136,7 @@ add_sdl_example_executable(renderer-viewport SOURCES renderer/14-viewport/viewpo
 add_sdl_example_executable(renderer-cliprect SOURCES renderer/15-cliprect/cliprect.c DATAFILES ${CMAKE_CURRENT_SOURCE_DIR}/../test/sample.bmp)
 add_sdl_example_executable(renderer-read-pixels SOURCES renderer/17-read-pixels/read-pixels.c DATAFILES ${CMAKE_CURRENT_SOURCE_DIR}/../test/sample.bmp)
 add_sdl_example_executable(renderer-debug-text SOURCES renderer/18-debug-text/debug-text.c)
+add_sdl_example_executable(renderer-affine-textures SOURCES renderer/19-affine-textures/affine-textures.c DATAFILES ${CMAKE_CURRENT_SOURCE_DIR}/../test/sample.bmp)
 add_sdl_example_executable(audio-simple-playback SOURCES audio/01-simple-playback/simple-playback.c)
 add_sdl_example_executable(audio-simple-playback-callback SOURCES audio/02-simple-playback-callback/simple-playback-callback.c)
 add_sdl_example_executable(audio-load-wav SOURCES audio/03-load-wav/load-wav.c DATAFILES ${CMAKE_CURRENT_SOURCE_DIR}/../test/sample.wav)

examples/renderer/19-affine-textures/README.txt

@@ -0,0 +1,3 @@
+This example creates an SDL window and renderer, and uses
+SDL_RenderTextureAffine to draw a 3D cube using only 2D rendering operations.
+

examples/renderer/19-affine-textures/affine-textures.c

@@ -0,0 +1,145 @@
+/* affine-textures.c ... */
+
+/*
+* This example creates an SDL window and renderer, and then draws a cube
+* using affine-transformed textures every frame.
+*
+* This code is public domain. Feel free to use it for any purpose!
+*/
+
+#define SDL_MAIN_USE_CALLBACKS 1  /* use the callbacks instead of main() */
+#include <SDL3/SDL.h>
+#include <SDL3/SDL_main.h>
+
+/* We will use this renderer to draw into this window every frame. */
+static SDL_Window *window = NULL;
+static SDL_Renderer *renderer = NULL;
+static SDL_Texture *texture = NULL;
+static int texture_width = 0;
+static int texture_height = 0;
+
+#define WINDOW_WIDTH 640
+#define WINDOW_HEIGHT 480
+
+/* This function runs once at startup. */
+SDL_AppResult SDL_AppInit(void **appstate, int argc, char *argv[])
+{
+    SDL_Surface *surface = NULL;
+    char *bmp_path = NULL;
+
+    SDL_SetAppMetadata("Example Renderer Affine Textures", "1.0", "com.example.renderer-affine-textures");
+
+    if (!SDL_Init(SDL_INIT_VIDEO)) {
+        SDL_Log("Couldn't initialize SDL: %s", SDL_GetError());
+        return SDL_APP_FAILURE;
+    }
+
+    if (!SDL_CreateWindowAndRenderer("examples/renderer/affine-textures", WINDOW_WIDTH, WINDOW_HEIGHT, 0, &window, &renderer)) {
+        SDL_Log("Couldn't create window/renderer: %s", SDL_GetError());
+        return SDL_APP_FAILURE;
+    }
+
+    /* Textures are pixel data that we upload to the video hardware for fast drawing. Lots of 2D
+       engines refer to these as "sprites." We'll do a static texture (upload once, draw many
+       times) with data from a bitmap file. */
+
+    /* SDL_Surface is pixel data the CPU can access. SDL_Texture is pixel data the GPU can access.
+       Load a .bmp into a surface, move it to a texture from there. */
+    SDL_asprintf(&bmp_path, "%ssample.bmp", SDL_GetBasePath());  /* allocate a string of the full file path */
+    surface = SDL_LoadBMP(bmp_path);
+    if (!surface) {
+        SDL_Log("Couldn't load bitmap: %s", SDL_GetError());
+        return SDL_APP_FAILURE;
+    }
+
+    SDL_free(bmp_path);  /* done with this, the file is loaded. */
+
+    texture_width = surface->w;
+    texture_height = surface->h;
+
+    texture = SDL_CreateTextureFromSurface(renderer, surface);
+    if (!texture) {
+        SDL_Log("Couldn't create static texture: %s", SDL_GetError());
+        return SDL_APP_FAILURE;
+    }
+
+    SDL_DestroySurface(surface);  /* done with this, the texture has a copy of the pixels now. */
+
+    return SDL_APP_CONTINUE;  /* carry on with the program! */
+}
+
+/* This function runs when a new event (mouse input, keypresses, etc) occurs. */
+SDL_AppResult SDL_AppEvent(void *appstate, SDL_Event *event)
+{
+    if (event->type == SDL_EVENT_QUIT) {
+        return SDL_APP_SUCCESS;  /* end the program, reporting success to the OS. */
+    }
+    return SDL_APP_CONTINUE;  /* carry on with the program! */
+}
+
+/* This function runs once per frame, and is the heart of the program. */
+SDL_AppResult SDL_AppIterate(void *appstate)
+{
+    const float x0 = 0.5f * WINDOW_WIDTH;
+    const float y0 = 0.5f * WINDOW_HEIGHT;
+    const float px = SDL_min(WINDOW_WIDTH, WINDOW_HEIGHT) / SDL_sqrtf(3.0f);
+
+    const Uint64 now = SDL_GetTicks();
+    const float rad = (((float) ((int) (now % 2000))) / 2000.0f) * SDL_PI_F * 2;
+    const float cos = SDL_cosf(rad);
+    const float sin = SDL_sinf(rad);
+    const float k[3] = { 3.0f / SDL_sqrtf(50.0f), 4.0f / SDL_sqrtf(50.0f), 5.0f / SDL_sqrtf(50.0f)};
+    float mat[9] = { 
+         cos      + (1.0f-cos)*k[0]*k[0], -sin*k[2] + (1.0f-cos)*k[0]*k[1],  sin*k[1] + (1.0f-cos)*k[0]*k[2], 
+         sin*k[2] + (1.0f-cos)*k[0]*k[1],  cos      + (1.0f-cos)*k[1]*k[1], -sin*k[0] + (1.0f-cos)*k[1]*k[2], 
+        -sin*k[1] + (1.0f-cos)*k[0]*k[2],  sin*k[0] + (1.0f-cos)*k[1]*k[2],  cos      + (1.0f-cos)*k[2]*k[2],
+    };
+
+    float corners[16];
+    int i;
+
+    for (i = 0; i < 8; i++) {
+        const float x = (i & 1) ? -0.5f : 0.5f;
+        const float y = (i & 2) ? -0.5f : 0.5f;
+        const float z = (i & 4) ? -0.5f : 0.5f;
+        corners[0 + 2*i] = mat[0]*x + mat[1]*y + mat[2]*z;
+        corners[1 + 2*i] = mat[3]*x + mat[4]*y + mat[5]*z;
+    }
+
+    SDL_SetRenderDrawColor(renderer, 0x42, 0x87, 0xf5, SDL_ALPHA_OPAQUE);  // light blue background.
+    SDL_RenderClear(renderer);
+
+    for (i = 1; i < 7; i++) {
+        const int dir = 3 & ((i & 4) ? ~i : i);
+        const int odd = (i & 1) ^ ((i & 2) >> 1) ^ ((i & 4) >> 2);
+        if (0 < (odd ? 1.0f : -1.0f) * mat[5 + dir]) continue;
+        int origin_index = (1 << ((dir - 1) % 3));
+        int right_index = (1 << ((dir + odd) % 3)) | origin_index;
+        int down_index = (1 << ((dir + (odd^1)) % 3)) | origin_index;
+        if (!odd) {
+            origin_index ^= 7;
+            right_index ^= 7;
+            down_index ^= 7;
+        }
+        SDL_FPoint origin, right, down;
+        origin.x = x0 + px*corners[0 + 2*origin_index];
+        origin.y = y0 + px*corners[1 + 2*origin_index];
+        right.x  = x0 + px*corners[0 + 2*right_index];
+        right.y  = y0 + px*corners[1 + 2*right_index];
+        down.x   = x0 + px*corners[0 + 2*down_index];
+        down.y   = y0 + px*corners[1 + 2*down_index];
+        SDL_RenderTextureAffine(renderer, texture, NULL, &origin, &right, &down);
+    }
+
+    SDL_RenderPresent(renderer);
+
+    return SDL_APP_CONTINUE;
+}
+
+/* This function runs once at shutdown. */
+void SDL_AppQuit(void *appstate, SDL_AppResult result)
+{
+    SDL_DestroyTexture(texture);
+    /* SDL will clean up the window/renderer for us. */
+}
+

examples/renderer/19-affine-textures/onmouseover.webp

@@ -166,6 +166,9 @@ typedef enum SDL_ProcessIO
  * - `SDL_PROP_PROCESS_CREATE_ENVIRONMENT_POINTER`: an SDL_Environment
  *   pointer. If this property is set, it will be the entire environment for
  *   the process, otherwise the current environment is used.
+ * - `SDL_PROP_PROCESS_CREATE_WORKING_DIRECTORY_STRING`: a UTF-8 encoded
+ *   string representing the working directory for the process, defaults to
+ *   the current working directory.
  * - `SDL_PROP_PROCESS_CREATE_STDIN_NUMBER`: an SDL_ProcessIO value describing
  *   where standard input for the process comes from, defaults to
  *   `SDL_PROCESS_STDIO_NULL`.
@@ -219,6 +222,7 @@ extern SDL_DECLSPEC SDL_Process * SDLCALL SDL_CreateProcessWithProperties(SDL_Pr
 
 #define SDL_PROP_PROCESS_CREATE_ARGS_POINTER                "SDL.process.create.args"
 #define SDL_PROP_PROCESS_CREATE_ENVIRONMENT_POINTER         "SDL.process.create.environment"
+#define SDL_PROP_PROCESS_CREATE_WORKING_DIRECTORY_STRING    "SDL.process.create.working_directory"
 #define SDL_PROP_PROCESS_CREATE_STDIN_NUMBER                "SDL.process.create.stdin_option"
 #define SDL_PROP_PROCESS_CREATE_STDIN_POINTER               "SDL.process.create.stdin_source"
 #define SDL_PROP_PROCESS_CREATE_STDOUT_NUMBER               "SDL.process.create.stdout_option"

examples/renderer/19-affine-textures/thumbnail.png

@@ -98,6 +98,21 @@ typedef enum SDL_TextureAccess
     SDL_TEXTUREACCESS_TARGET     /**< Texture can be used as a render target */
 } SDL_TextureAccess;
 
+/**
+ * The addressing mode for a texture when used in SDL_RenderGeometry().
+ *
+ * This affects how texture coordinates are interpreted outside of [0, 1]
+ *
+ * \since This enum is available since SDL 3.4.0.
+ */
+typedef enum SDL_TextureAddressMode
+{
+    SDL_TEXTURE_ADDRESS_INVALID = -1,
+    SDL_TEXTURE_ADDRESS_AUTO,   /**< Wrapping is enabled if texture coordinates are outside [0, 1], this is the default */
+    SDL_TEXTURE_ADDRESS_CLAMP,  /**< Texture coordinates are clamped to the [0, 1] range */
+    SDL_TEXTURE_ADDRESS_WRAP,   /**< The texture is repeated (tiled) */
+} SDL_TextureAddressMode;
+
 /**
  * How the logical size is mapped to the output.
  *
@@ -2294,6 +2309,7 @@ extern SDL_DECLSPEC bool SDLCALL SDL_RenderTexture9GridTiled(SDL_Renderer *rende
  * \since This function is available since SDL 3.2.0.
  *
  * \sa SDL_RenderGeometryRaw
+ * \sa SDL_SetRenderTextureAddressMode
  */
 extern SDL_DECLSPEC bool SDLCALL SDL_RenderGeometry(SDL_Renderer *renderer,
                                                SDL_Texture *texture,
@@ -2326,6 +2342,7 @@ extern SDL_DECLSPEC bool SDLCALL SDL_RenderGeometry(SDL_Renderer *renderer,
  * \since This function is available since SDL 3.2.0.
  *
  * \sa SDL_RenderGeometry
+ * \sa SDL_SetRenderTextureAddressMode
  */
 extern SDL_DECLSPEC bool SDLCALL SDL_RenderGeometryRaw(SDL_Renderer *renderer,
                                                SDL_Texture *texture,
@@ -2335,6 +2352,44 @@ extern SDL_DECLSPEC bool SDLCALL SDL_RenderGeometryRaw(SDL_Renderer *renderer,
                                                int num_vertices,
                                                const void *indices, int num_indices, int size_indices);
 
+/**
+ * Set the texture addressing mode used in SDL_RenderGeometry().
+ *
+ * \param renderer the rendering context.
+ * \param u_mode the SDL_TextureAddressMode to use for horizontal texture
+ *               coordinates in SDL_RenderGeometry().
+ * \param v_mode the SDL_TextureAddressMode to use for vertical texture
+ *               coordinates in SDL_RenderGeometry().
+ * \returns true on success or false on failure; call SDL_GetError() for more
+ *          information.
+ *
+ * \since This function is available since SDL 3.4.0.
+ *
+ * \sa SDL_RenderGeometry
+ * \sa SDL_RenderGeometryRaw
+ * \sa SDL_GetRenderTextureAddressMode
+ */
+extern SDL_DECLSPEC bool SDLCALL SDL_SetRenderTextureAddressMode(SDL_Renderer *renderer, SDL_TextureAddressMode u_mode, SDL_TextureAddressMode v_mode);
+
+/**
+ * Get the texture addressing mode used in SDL_RenderGeometry().
+ *
+ * \param renderer the rendering context.
+ * \param u_mode a pointer filled in with the SDL_TextureAddressMode to use
+ *               for horizontal texture coordinates in SDL_RenderGeometry(),
+ *               may be NULL.
+ * \param v_mode a pointer filled in with the SDL_TextureAddressMode to use
+ *               for vertical texture coordinates in SDL_RenderGeometry(), may
+ *               be NULL.
+ * \returns true on success or false on failure; call SDL_GetError() for more
+ *          information.
+ *
+ * \since This function is available since SDL 3.4.0.
+ *
+ * \sa SDL_SetRenderTextureAddressMode
+ */
+extern SDL_DECLSPEC bool SDLCALL SDL_GetRenderTextureAddressMode(SDL_Renderer *renderer, SDL_TextureAddressMode *u_mode, SDL_TextureAddressMode *v_mode);
+
 /**
  * Read pixels from the current rendering target.
  *

include/SDL3/SDL_process.h

@@ -1299,8 +1299,11 @@ extern "C" {
  *
  * If `size` is 0, it will be set to 1.
  *
- * If you want to allocate memory aligned to a specific alignment, consider
- * using SDL_aligned_alloc().
+ * If the allocation is successful, the returned pointer is guaranteed to be
+ * aligned to either the *fundamental alignment* (`alignof(max_align_t)` in
+ * C11 and later) or `2 * sizeof(void *)`, whichever is smaller. Use
+ * SDL_aligned_alloc() if you need to allocate memory aligned to an alignment
+ * greater than this guarantee.
  *
  * \param size the size to allocate.
  * \returns a pointer to the allocated memory, or NULL if allocation failed.
@@ -1323,6 +1326,10 @@ extern SDL_DECLSPEC SDL_MALLOC void * SDLCALL SDL_malloc(size_t size);
  *
  * If either of `nmemb` or `size` is 0, they will both be set to 1.
  *
+ * If the allocation is successful, the returned pointer is guaranteed to be
+ * aligned to either the *fundamental alignment* (`alignof(max_align_t)` in
+ * C11 and later) or `2 * sizeof(void *)`, whichever is smaller.
+ *
  * \param nmemb the number of elements in the array.
  * \param size the size of each element of the array.
  * \returns a pointer to the allocated array, or NULL if allocation failed.
@@ -1357,6 +1364,11 @@ extern SDL_DECLSPEC SDL_MALLOC SDL_ALLOC_SIZE2(1, 2) void * SDLCALL SDL_calloc(s
  * - If it returns NULL (indicating failure), then `mem` will remain valid and
  *   must still be freed with SDL_free().
  *
+ * If the allocation is successfully resized, the returned pointer is
+ * guaranteed to be aligned to either the *fundamental alignment*
+ * (`alignof(max_align_t)` in C11 and later) or `2 * sizeof(void *)`,
+ * whichever is smaller.
+ *
  * \param mem a pointer to allocated memory to reallocate, or NULL.
  * \param size the new size of the memory.
  * \returns a pointer to the newly allocated memory, or NULL if allocation