[Dependencies] Update SDL3-CS;

[Rendering] Enable Shader Draw Parameters Vulkan extension;

Author: LittleCodingFox

Dependencies/SDL3-CS/SDL/Audio/audio/PInvoke.cs

@@ -175,6 +175,14 @@ public static partial class SDL
     /// <code>extern SDL_DECLSPEC const char * SDLCALL SDL_GetAudioDeviceName(SDL_AudioDeviceID devid);</code>
     /// <summary>
     /// Get the human-readable name of a specific audio device.
+    /// <para><b>WARNING</b>: this function will work with <see cref="AudioDeviceDefaultPlayback"/>
+    /// and <see cref="AudioDeviceDefaultRecording"/>, returning the current default
+    /// physical devices' names. However, as the default device may change at any
+    /// time, it is likely better to show a generic name to the user, like "System
+    /// default audio device" or perhaps "default [currently %s]". Do not store
+    /// this name to disk to reidentify the device in a later run of the program,
+    /// as the default might change in general, and the string will be the name of
+    /// a specific device and not the abstract system default.</para>
     /// </summary>
     /// <param name="devid">the instance ID of the device to query.</param>
     /// <returns>the name of the audio device, or <c>null</c> on failure; call

Dependencies/SDL3-CS/SDL/Basics/hints/Hints.cs

@@ -641,21 +641,6 @@ public static class Hints
         /// <remarks>This hint should be set before creating a window.</remarks>
         /// <since>This hint is available since SDL 3.2.0</since>
         public const string EmscriptenKeyboardElement = "SDL_EMSCRIPTEN_KEYBOARD_ELEMENT";
-
-
-        /// <summary>
-        /// Dictate that newly-created windows will fill the whole browser window.
-        /// <para>The canvas element fills the entire document. Resize events will be
-        /// generated as the browser window is resized, as that will adjust the canvas
-        /// size as well. The canvas will cover anything else on the page, including
-        /// any controls provided by Emscripten in its generated HTML file. Often times
-        /// this is desirable for a browser-based game, but it means several things
-        /// that we expect of an SDL window on other platforms might not work as
-        /// expected, such as minimum window sizes and aspect ratios.</para>
-        /// <para>This hint overrides <see cref="Props.WindowCreateEMScriptenFillDocumentBoolean"/>
-        /// properties when creating an SDL window.</para>
-        /// </summary>
-        public const string EmscriptenFillDocument = "SDL_EMSCRIPTEN_FILL_DOCUMENT";
 
         /// <summary>
         /// <para>A variable that controls whether the on-screen keyboard should be shown
@@ -2221,6 +2206,21 @@ public static class Hints
         /// <since>This hint is available since SDL 3.2.0</since>
         public const string MouseDefaultSystemCursor = "SDL_MOUSE_DEFAULT_SYSTEM_CURSOR";
 
+        /// <summary>
+        /// <para>A variable setting whether we should scale cursors by the current display
+        /// scale.</para>
+        /// <para>The variable can be set to the following values:</para>
+        /// <list type="bullet">
+        /// <item><c>"0"</c>: Cursors will not change size based on the display content scale.
+        /// (default)</item>
+        /// <item><c>"1"</c>: Cursors will automatically match the display content scale (e.g. a
+        /// 2x sized cursor will be used when the window is on a monitor with 200%
+        /// scale). This is currently implemented on Windows and Wayland.</item>
+        /// </list>
+        /// </summary>
+        /// <remarks>This hint needs to be set before creating cursors.</remarks>
+        /// <since>This hint is available since SDL 3.4.0.</since>
+        public const string MouseDPIScaleCursors = "SDL_MOUSE_DPI_SCALE_CURSORS";
 
         /// <summary>
         /// <para>A variable controlling whether warping a hidden mouse cursor will activate

Dependencies/SDL3-CS/SDL/GPU/gpu/GPUVulkanOptions.cs

@@ -32,7 +32,7 @@ public static partial class SDL
     /// <para>When no such structure is provided, SDL will use Vulkan API version 1.0 and
     /// a minimal set of features. The requested API version influences how the
     /// feature_list is processed by SDL. When requesting API version 1.0, the
-    /// feature_list is ignored. Only the vulkan_10_phyisical_device_features and
+    /// feature_list is ignored. Only the vulkan_10_physical_device_features and
     /// the extension lists are used. When requesting API version 1.1, the
     /// feature_list is scanned for feature structures introduced in Vulkan 1.1.
     /// When requesting Vulkan 1.2 or higher, the feature_list is additionally
@@ -42,6 +42,8 @@ public static partial class SDL
     /// </summary>
     /// <since>This struct is available since SDL 3.4.0.</since>
     /// <seealso cref="SetGPUViewport"/>
+    /// <seealso cref="SDL.PointerToStringArray(System.IntPtr)"/>
+    /// <seealso cref="SDL.StringArrayToPointer"/>
     [StructLayout(LayoutKind.Sequential)]
     public struct GPUVulkanOptions
     {
@@ -65,23 +67,19 @@ public struct GPUVulkanOptions
         /// </summary>
         public uint DeviceExtensionCount;
 
-        private IntPtr device_extension_names;
-        
         /// <summary>
-        /// Number of additional instance extensions to require.
+        /// Pointer to a list of additional device extensions to require.
         /// </summary>
-        public uint InstanceExtensionCount;
+        public IntPtr DeviceExtensionNames;
 
-        private IntPtr instance_extension_names;
-
         /// <summary>
-        /// Pointer to a list of additional device extensions to require.
+        /// Number of additional instance extensions to require.
         /// </summary>
-        public string[] DeviceExtensionNames => PointerToStringArray(device_extension_names)!;
+        public uint InstanceExtensionCount;
 
         /// <summary>
         /// Pointer to a list of additional instance extensions to require.
         /// </summary>
-        public string[] InstanceExtensionNames => PointerToStringArray(instance_extension_names)!;
+        public IntPtr InstanceExtensionNames;
     }
 }

Dependencies/SDL3-CS/SDL/GPU/gpu/PInvoke.cs

@@ -157,7 +157,7 @@ public partial class SDL
     /// provide your own fallback renderer (for example, an OpenGL renderer) this
     /// property can be set to true. Defaults to false.</item>
     /// <item><see cref="Props.GPUDeviceCreateVulkanOptionsPointer"/>: a pointer to an
-    /// SDL_GPUVulkanOptions structure to be processed during device creation.
+    /// <see cref="GPUVulkanOptions"/> structure to be processed during device creation.
     /// This allows configuring a variety of Vulkan-specific options such as
     /// increasing the API version and opting into extensions aside from the
     /// minimal set SDL requires.</item>
@@ -647,8 +647,9 @@ public static string GetGPUDriver(int index)
     /// <summary>
     /// <para>Inserts an arbitrary string label into the command buffer callstream.</para>
     /// <para>Useful for debugging.</para>
-    /// <para>On Direct3D 12, using <see cref="InsertGPUDebugLabel"/> will cause validation errors
-    /// unless you have WinPixEventRuntime.dll in your PATH. See
+    /// <para>On Direct3D 12, using <see cref="InsertGPUDebugLabel"/> requires
+    /// WinPixEventRuntime.dll to be in your PATH or in the same directory as your
+    /// executable. See
     /// [here](https://devblogs.microsoft.com/pix/winpixeventruntime/)
     /// for instructions on how to obtain it.</para>
     /// </summary>
@@ -666,8 +667,8 @@ public static string GetGPUDriver(int index)
     /// callstream in a graphics debugging tool.</para>
     /// <para>Each call to <see cref="PushGPUDebugGroup"/> must have a corresponding call to
     /// <see cref="PopGPUDebugGroup"/>.</para>
-    /// <para>On Direct3D 12, using <see cref="PushGPUDebugGroup"/> will cause validation errors
-    /// unless you have WinPixEventRuntime.dll in your PATH. See
+    /// <para>On Direct3D 12, using <see cref="PushGPUDebugGroup"/> requires WinPixEventRuntime.dll
+    /// to be in your PATH or in the same directory as your executable. See
     /// [here](https://devblogs.microsoft.com/pix/winpixeventruntime/)
     /// for instructions on how to obtain it.</para>
     /// <para>On some backends (e.g. Metal), pushing a debug group during a
@@ -686,6 +687,10 @@ public static string GetGPUDriver(int index)
     /// <code>extern SDL_DECLSPEC void SDLCALL SDL_PopGPUDebugGroup(SDL_GPUCommandBuffer *command_buffer);</code>
     /// <summary>
     /// Ends the most-recently pushed debug group.
+    /// <para>On Direct3D 12, using <see cref="PopGPUDebugGroup"/> requires WinPixEventRuntime.dll
+    /// to be in your PATH or in the same directory as your executable. See
+    /// [here](https://devblogs.microsoft.com/pix/winpixeventruntime/)
+    /// for instructions on how to obtain it.</para>
     /// </summary>
     /// <param name="commandBuffer">a command buffer.</param>
     /// <since>This function is available since SDL 3.2.0</since>

Dependencies/SDL3-CS/SDL/Input Events/mouse/PInvoke.cs

@@ -386,9 +386,10 @@ public static partial class SDL
     /// <para>If this function is passed a surface with alternate representations added
     /// with <see cref="AddSurfaceAlternateImage"/>, the surface will be interpreted as the
     /// content to be used for 100% display scale, and the alternate
-    /// representations will be used for high DPI situations. For example, if the
-    /// original surface is 32x32, then on a 2x macOS display or 200% display scale
-    /// on Windows, a 64x64 version of the image will be used, if available. If a
+    /// representations will be used for high DPI situations if 
+    /// <see cref="Hints.MouseDPIScaleCursors"/> is enabled. For example, if the original
+    /// surface is 32x32, then on a 2x macOS display or 200% display scale on
+    /// Windows, a 64x64 version of the image will be used, if available. If a
     /// matching version of the image isn't available, the closest larger size
     /// image will be downscaled to the appropriate size and be used instead, if
     /// available. Otherwise, the closest smaller image will be upscaled and be

Dependencies/SDL3-CS/SDL/SDL.cs

@@ -22,6 +22,7 @@
 #endregion
 
 using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
 using System.Runtime.InteropServices;
 
 namespace SDL3;
@@ -55,7 +56,7 @@ public static partial class SDL
     /// <seealso cref="PointerToStringArray(nint)"/>
     /// <seealso cref="PointerToStringArray(nint, int)"/>
     /// <seealso cref="PointerToStructureArray{T}"/>
-    public static T? PointerToStructure<T>(IntPtr pointer) where T : struct
+    public static T? PointerToStructure<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors)] T>(IntPtr pointer) where T : struct
     {
         return pointer == IntPtr.Zero ? null : Marshal.PtrToStructure<T>(pointer);
     }
@@ -145,7 +146,7 @@ public static IntPtr StructureToPointer<T>(T? structure) where T : struct
     /// <seealso cref="PointerToStructureArray{T}"/>
     public static IntPtr StructureArrayToPointer<T>(T[] array) where T : struct
     {
-        if (array == null || array.Length == 0) return IntPtr.Zero;
+        if (array.Length == 0) return IntPtr.Zero;
 
         var sizeOfT = Marshal.SizeOf<T>();
         var unmanagedPointer = Marshal.AllocHGlobal(sizeOfT * array.Length);
@@ -351,6 +352,15 @@ public static IntPtr StringToPointer(string? str)
         Marshal.Copy(utf8Bytes, 0, unmanagedPointer, utf8Bytes.Length);
         return unmanagedPointer;
     }
+
+
+    /// <summary>
+    /// Converts a unmanaged pointer to an UTF-8 string
+    /// </summary>
+    public static string? PointerToString(IntPtr pointer)
+    {
+        return Marshal.PtrToStringUTF8(pointer);
+    }
 
 
     /// <summary>
@@ -387,7 +397,7 @@ public static IntPtr StringToPointer(string? str)
     /// <seealso cref="PointerToPointerArray"/>
     /// <seealso cref="PointerToStringArray(nint)"/>
     /// <seealso cref="PointerToStringArray(nint, int)"/>
-    public static unsafe T[]? PointerToStructureArray<T>(IntPtr pointer, int count) where T : struct
+    public static unsafe T[]? PointerToStructureArray<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors)] T>(IntPtr pointer, int count) where T : struct
     {
         if (pointer == IntPtr.Zero || count < 0) return null;
 
@@ -405,14 +415,61 @@ public static IntPtr StringToPointer(string? str)
             for (var i = 0; i < count; i++)
             {
                 var elementPtr = Marshal.ReadIntPtr(pointer, i * sizePtr);
-                array[i] = Marshal.PtrToStructure<T>(elementPtr)!;
+                array[i] = Marshal.PtrToStructure<T>(elementPtr);
             }
         }
 
         return array;
     }
 
 
+    /// <summary>
+    /// Allocates unmanaged memory for an array of UTF-8 string pointers (char*).
+    /// Each string is converted via <see cref="StringToPointer(string?)"/>.
+    /// — The array is terminated with a trailing <see cref="IntPtr.Zero"/>.
+    /// </summary>
+    /// <param name="array">
+    /// — The managed array of strings. Can be <c>null</c> or empty.
+    /// </param>
+    /// <returns>
+    /// — A pointer to unmanaged memory containing an array of <see cref="IntPtr"/> pointers,
+    /// — each pointing to a UTF-8 null-terminated string.  
+    /// — Returns <see cref="IntPtr.Zero"/> for <c>null</c> or empty arrays.
+    /// </returns>
+    /// <remarks>
+    /// The caller is responsible for freeing all allocated memory:
+    /// 1. Free each individual string pointer using <see cref="Marshal.FreeHGlobal"/>.
+    /// 2. Free the returned array pointer using <see cref="Marshal.FreeHGlobal"/>.
+    /// Failure to do so will cause memory leaks.
+    /// </remarks>
+    public static IntPtr StringArrayToPointer(string[]? array)
+    {
+        unsafe
+        {
+            if (array == null || array.Length == 0)
+                return IntPtr.Zero;
+        
+            var total = array.Length + 1;
+            var size = IntPtr.Size * total;
+
+            var blockPtr = Marshal.AllocHGlobal(size);
+        
+            var zeroInit = new Span<byte>((void*)blockPtr, size);
+            zeroInit.Clear();
+
+            for (var i = 0; i < array.Length; i++)
+            {
+                var strPtr = StringToPointer(array[i]);
+                Marshal.WriteIntPtr(blockPtr, i * IntPtr.Size, strPtr);
+            }
+        
+            Marshal.WriteIntPtr(blockPtr, array.Length * IntPtr.Size, IntPtr.Zero);
+
+            return blockPtr;
+        }
+    }
+    
+    
     /// <summary>
     /// Indicates that a method is a <c>#define</c> macro.
     /// </summary>

Dependencies/SDL3-CS/SDL/Video/surface/PInvoke.cs

@@ -113,6 +113,12 @@ public static partial class SDL
     /// left edge of the image, if this surface is being used as a cursor.</item>
     /// <item><see cref="Props.SurfaceHotspotYNumber"/>: the hotspot pixel offset from the
     /// top edge of the image, if this surface is being used as a cursor.</item>
+    /// <item><see cref="Props.SurfaceRotationFloat"/>: the number of degrees a surface's data
+    /// is meant to be rotated clockwise to make the image right-side up. Default
+    /// 0. This is used by the camera API, if a mobile device is oriented
+    /// differently than what its camera provides (i.e. - the camera always
+    /// provides portrait images but the phone is being held in landscape
+    /// orientation). Since SDL 3.4.0.</item>
     /// </list>
     /// </summary>
     /// <param name="surface">the <see cref="Surface"/> structure to query.</param>
@@ -863,6 +869,13 @@ public static partial class SDL
     /// <para>When the rotation isn't a multiple of 90 degrees, the resulting surface is
     /// larger than the original, with the background filled in with the colorkey,
     /// if available, or RGBA 255/255/255/0 if not.</para>
+    /// <para>If <c>surface</c> has the <see cref="Props.SurfaceRotationFloat"/> property set on it,
+    /// the new copy will have the adjusted value set: if the rotation property is
+    /// 90 and <c>angle</c> was 30, the new surface will have a property value of 60
+    /// (that is: to be upright vs gravity, this surface needs to rotate 60 more
+    /// degrees). However, note that further rotations on the new surface in this
+    /// example will produce unexpected results, since the image will have resized
+    /// and padded to accommodate the not-90 degree angle.</para>
     /// </summary>
     /// <param name="surface">the surface to rotate.</param>
     /// <param name="angle">the rotation angle, in degrees.</param>

Dependencies/SDL3-CS/SDL/Video/surface/Props.cs

@@ -32,5 +32,6 @@ public static partial class Props
         public const string SurfaceTonemapOperatorString = "SDL.surface.tonemap";
         public const string SurfaceHotspotXNumber = "SDL.surface.hotspot.x";
         public const string SurfaceHotspotYNumber = "SDL.surface.hotspot.y";
+        public const string SurfaceRotationFloat = "SDL.surface.rotation";
     }
 }

Dependencies/SDL3-CS/SDL/Video/video/PInvoke.cs

@@ -1075,9 +1075,6 @@ public static partial bool GetClosestFullscreenDisplayMode(uint displayID, int w
     /// <list type="bullet">
     /// <item><see cref="Props.WindowEMScriptenCanvasIdString"/>: the id the canvas element
     /// will have</item>
-    /// <item><see cref="Props.WindowEMScriptenFillDocumentBoolean"/>: true if the canvas is
-    /// set to consume the entire browser window, bypassing some SDL window 
-    /// functionality.</item>
     /// <item><see cref="Props.WindowEMScriptenKeyboardElementString"/>: the keyboard
     /// element that associates keyboard events to this window</item>
     /// </list>
@@ -1105,6 +1102,7 @@ public static partial bool GetClosestFullscreenDisplayMode(uint displayID, int w
     /// <seealso cref="MinimizeWindow"/>
     /// <seealso cref="SetWindowFullscreen"/>
     /// <seealso cref="SetWindowMouseGrab"/>
+    /// <seealso cref="SetWindowFillDocument"/>
     /// <seealso cref="ShowWindow"/>
     [LibraryImport(SDLLibrary, EntryPoint = "SDL_GetWindowFlags"), UnmanagedCallConv(CallConvs = [typeof(CallConvCdecl)])]
     public static partial WindowFlags GetWindowFlags(IntPtr window);
@@ -1554,6 +1552,32 @@ public static string GetWindowTitle(IntPtr window)
     public static partial bool SetWindowAlwaysOnTop(IntPtr window, [MarshalAs(UnmanagedType.I1)] bool onTop);
 
 
+    /// <code>extern SDL_DECLSPEC bool SDLCALL SDL_SetWindowFillDocument(SDL_Window *window, bool fill);</code>
+    /// <summary>
+    /// <para>Set the window to fill the current document space (Emscripten only).</para>
+    /// <para>This will add or remove the window's <see cref="WindowFlags.WindowFillDocument"/> flag.</para>
+    /// <para>Currently this flag only applies to the Emscripten target.</para>
+    /// <para>When enabled, the canvas element fills the entire document. Resize events 
+    /// will be generated as the browser window is resized, as that will adjust the
+    /// canvas size as well. The canvas will cover anything else on the page,
+    /// including any controls provided by Emscripten in its generated HTML file
+    /// (in fact, any elements on the page that aren't the canvas will be moved
+    /// into a hidden <c>div</c> element).</para>
+    /// /// <para>Often times this is desirable for a browser-based game, but it means
+    /// several things that we expect of an SDL window on other platforms might not
+    /// work as expected, such as minimum window sizes and aspect ratios.</para>
+    /// </summary>
+    /// <param name="window">the window of which to change the fill-document state.</param>
+    /// <param name="fill">true to set the window to fill the document, false to disable.</param>
+    /// <returns>true on success or false on failure; call <see cref="GetError"/> for more
+    /// information.</returns>
+    /// <threadsafety>This function should only be called on the main thread.</threadsafety>
+    /// <since>This function is available since SDL 3.4.0.</since>
+    [LibraryImport(SDLLibrary, EntryPoint = "SDL_SetWindowFillDocument"), UnmanagedCallConv(CallConvs = [typeof(CallConvCdecl)])]
+    [return: MarshalAs(UnmanagedType.I1)]
+    public static partial bool SetWindowFillDocument(IntPtr window, [MarshalAs(UnmanagedType.I1)] bool fill);
+    
+    
     /// <code>extern SDL_DECLSPEC bool SDLCALL SDL_ShowWindow(SDL_Window *window);</code>
     /// <summary>
     /// Show a window.