Resolve WebGPU native assets across deployment layouts

Resolve the DirectX Shader Compiler through the host's native-library
search and recover its location from the loaded module, replacing the
application-directory probe that failed under the NuGet runtimes layout.
Anchor fallback probing to the library's own image so Native AOT shared
libraries hosted by foreign processes resolve wgpu_native and DXC, and
register the Silk.NET window platforms explicitly so trimming cannot
remove platform discovery.

Author: JimBobSquarePants

src/ImageSharp.Drawing.WebGPU/Native/NativeModuleLocator.cs

@@ -0,0 +1,175 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Runtime.InteropServices;
+using FilePath = System.IO.Path;
+
+namespace SixLabors.ImageSharp.Drawing.Processing.Backends.Native;
+
+/// <summary>
+/// Locates this library's own loaded module on disk.
+/// </summary>
+/// <remarks>
+/// <para>
+/// Under Native AOT this code is compiled into a shared library or executable image, and when
+/// that image is a plugin loaded by a foreign host, <see cref="AppContext.BaseDirectory"/>
+/// points at the host process rather than the image. Anchoring native-asset probing to the
+/// image itself keeps resolution correct there. Under JIT hosting managed code does not live
+/// inside a loadable image, so resolution reports failure and callers fall back to standard
+/// probing.
+/// </para>
+/// <para>
+/// The runtime provides no managed API for recovering a loaded image's path; the mechanism
+/// here follows <see href="https://github.com/dotnet/runtime/issues/112290"/> and the
+/// address-anchored approach demonstrated in
+/// <see href="https://github.com/dotnet/runtime/discussions/122457"/>.
+/// </para>
+/// </remarks>
+internal static unsafe partial class NativeModuleLocator
+{
+    /// <summary>
+    /// <c>GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT</c> from <c>libloaderapi.h</c>. The
+    /// returned handle does not take a reference on the module, so it must not be freed.
+    /// </summary>
+    private const uint GetModuleHandleExFlagUnchangedRefCount = 0x00000002;
+
+    /// <summary>
+    /// <c>GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS</c> from <c>libloaderapi.h</c>. The address
+    /// argument is any address inside the target module rather than a module name.
+    /// </summary>
+    private const uint GetModuleHandleExFlagFromAddress = 0x00000004;
+
+    /// <summary>
+    /// Attempts to resolve the directory of the image containing this library's code.
+    /// </summary>
+    /// <param name="directory">Receives the image directory.</param>
+    /// <returns><see langword="true"/> when the image path could be resolved.</returns>
+    public static bool TryGetModuleDirectory(out string directory)
+    {
+        directory = string.Empty;
+        delegate* managed<void> anchor = &Anchor;
+
+        string modulePath;
+        if (OperatingSystem.IsWindows())
+        {
+            if (GetModuleHandleExW(GetModuleHandleExFlagFromAddress | GetModuleHandleExFlagUnchangedRefCount, (nint)anchor, out nint module) == 0)
+            {
+                return false;
+            }
+
+            modulePath = GetModuleFilePath(module);
+        }
+        else
+        {
+            // dladdr reports the image containing an address. Resolving it through the process
+            // exports avoids binding to a platform-specific libdl name.
+            if (!NativeLibrary.TryGetExport(NativeLibrary.GetMainProgramHandle(), "dladdr", out nint export))
+            {
+                return false;
+            }
+
+            delegate* unmanaged<void*, DlInfo*, int> dladdr = (delegate* unmanaged<void*, DlInfo*, int>)export;
+            DlInfo info;
+            if (dladdr(anchor, &info) == 0 || info.FileName is null)
+            {
+                return false;
+            }
+
+            modulePath = Marshal.PtrToStringUTF8((nint)info.FileName) ?? string.Empty;
+        }
+
+        if (modulePath.Length == 0)
+        {
+            return false;
+        }
+
+        string? parent = FilePath.GetDirectoryName(modulePath);
+        if (parent is null || parent.Length == 0)
+        {
+            return false;
+        }
+
+        directory = parent;
+        return true;
+    }
+
+    /// <summary>
+    /// Reads the file path of a loaded native module.
+    /// </summary>
+    /// <param name="module">The loaded module handle.</param>
+    /// <returns>The module's file path, or an empty string when it cannot be read.</returns>
+    public static string GetModuleFilePath(nint module)
+    {
+        Span<char> buffer = stackalloc char[260];
+        fixed (char* bufferPointer = buffer)
+        {
+            uint length = GetModuleFileNameW(module, bufferPointer, (uint)buffer.Length);
+            if (length > 0 && length < buffer.Length)
+            {
+                return new string(buffer[..(int)length]);
+            }
+        }
+
+        // Cold fallback for paths beyond MAX_PATH up to the documented Windows maximum.
+        char[] largeBuffer = new char[short.MaxValue];
+        fixed (char* largePointer = largeBuffer)
+        {
+            uint length = GetModuleFileNameW(module, largePointer, (uint)largeBuffer.Length);
+            return length > 0 && length < largeBuffer.Length ? new string(largeBuffer, 0, (int)length) : string.Empty;
+        }
+    }
+
+    /// <summary>
+    /// Provides an address that lives inside this library's compiled image.
+    /// </summary>
+    private static void Anchor()
+    {
+    }
+
+    /// <summary>
+    /// Reads the file path of a loaded module into the supplied buffer.
+    /// </summary>
+    /// <param name="module">The loaded module handle.</param>
+    /// <param name="filename">The buffer receiving the path.</param>
+    /// <param name="size">The buffer length in characters.</param>
+    /// <returns>The number of characters written, or zero on failure.</returns>
+    [LibraryImport("kernel32", EntryPoint = "GetModuleFileNameW", SetLastError = true)]
+    private static partial uint GetModuleFileNameW(nint module, char* filename, uint size);
+
+    /// <summary>
+    /// Retrieves a module handle for the image containing the supplied address.
+    /// </summary>
+    /// <param name="flags">The handle retrieval flags.</param>
+    /// <param name="address">An address inside the target image.</param>
+    /// <param name="module">Receives the module handle.</param>
+    /// <returns>A non-zero value on success.</returns>
+    [LibraryImport("kernel32", EntryPoint = "GetModuleHandleExW", SetLastError = true)]
+    private static partial int GetModuleHandleExW(uint flags, nint address, out nint module);
+
+    /// <summary>
+    /// Image information reported by <c>dladdr</c>.
+    /// </summary>
+    [StructLayout(LayoutKind.Sequential)]
+    private struct DlInfo
+    {
+        /// <summary>
+        /// The path of the image containing the queried address.
+        /// </summary>
+        public byte* FileName;
+
+        /// <summary>
+        /// The base address of the image.
+        /// </summary>
+        public void* BaseAddress;
+
+        /// <summary>
+        /// The name of the nearest symbol.
+        /// </summary>
+        public byte* SymbolName;
+
+        /// <summary>
+        /// The address of the nearest symbol.
+        /// </summary>
+        public void* SymbolAddress;
+    }
+}

src/ImageSharp.Drawing.WebGPU/Native/WebGPUNative.cs

@@ -29,6 +29,16 @@ static WebGPUNative()
             // This prevents an older same-named dependency from satisfying our generated v29 ABI.
             LibraryHandle = NativeLibrary.Load(libraryPath);
         }
+        else if (NativeModuleLocator.TryGetModuleDirectory(out string moduleDirectory))
+        {
+            // A Native AOT shared library hosted by a foreign process probes relative to that
+            // host, so also look beside this library's own image.
+            string anchoredPath = System.IO.Path.Combine(moduleDirectory, fileName);
+            if (File.Exists(anchoredPath))
+            {
+                LibraryHandle = NativeLibrary.Load(anchoredPath);
+            }
+        }
 
         NativeLibrary.SetDllImportResolver(typeof(WebGPUNative).Assembly, ResolveLibrary);
     }

src/ImageSharp.Drawing.WebGPU/WebGPURuntime.cs

@@ -608,9 +608,54 @@ private static void EnsureInitialized()
     /// <returns><see langword="true"/> when both files are available, or on non-Windows platforms.</returns>
     private static bool TryGetDxcPaths(out string dxcPath, out string dxilPath)
     {
-        dxcPath = FilePath.Combine(AppContext.BaseDirectory, "dxcompiler.dll");
-        dxilPath = FilePath.Combine(AppContext.BaseDirectory, "dxil.dll");
-        return !OperatingSystem.IsWindows() || (File.Exists(dxcPath) && File.Exists(dxilPath));
+        dxcPath = string.Empty;
+        dxilPath = string.Empty;
+        if (!OperatingSystem.IsWindows())
+        {
+            return true;
+        }
+
+        // wgpu receives the compiler as a file location rather than binding it as an import,
+        // so resolve it through the host's native-library search. That search already honors
+        // every deployment layout: flat outputs, the NuGet runtimes layout, and
+        // self-contained publishes.
+        if (!NativeLibrary.TryLoad("dxcompiler.dll", typeof(WebGPURuntime).Assembly, null, out IntPtr module))
+        {
+            // A Native AOT shared library hosted by a foreign process probes relative to that
+            // host, so fall back to the directory of this library's own image.
+            if (NativeModuleLocator.TryGetModuleDirectory(out string moduleDirectory))
+            {
+                dxcPath = FilePath.Combine(moduleDirectory, "dxcompiler.dll");
+                dxilPath = FilePath.Combine(moduleDirectory, "dxil.dll");
+                if (File.Exists(dxcPath) && File.Exists(dxilPath))
+                {
+                    return true;
+                }
+            }
+
+            dxcPath = string.Empty;
+            dxilPath = string.Empty;
+            return false;
+        }
+
+        try
+        {
+            dxcPath = NativeModuleLocator.GetModuleFilePath(module);
+        }
+        finally
+        {
+            NativeLibrary.Free(module);
+        }
+
+        if (dxcPath.Length == 0)
+        {
+            return false;
+        }
+
+        // The compiler loads dxil.dll from its own directory to sign shaders, so both files
+        // ship side by side in every layout.
+        dxilPath = FilePath.Combine(FilePath.GetDirectoryName(dxcPath)!, "dxil.dll");
+        return File.Exists(dxilPath);
     }
 
     /// <summary>

src/ImageSharp.Drawing.WebGPU/WebGPUWindow.cs

@@ -4,6 +4,8 @@
 using System.Diagnostics.CodeAnalysis;
 using Silk.NET.Maths;
 using Silk.NET.Windowing;
+using Silk.NET.Windowing.Glfw;
+using Silk.NET.Windowing.Sdl;
 using NativeWindowBorder = Silk.NET.Windowing.WindowBorder;
 using NativeWindowState = Silk.NET.Windowing.WindowState;
 
@@ -26,6 +28,15 @@ public sealed class WebGPUWindow : IDisposable
     private readonly WebGPUSurfaceResources resources;
     private bool isDisposed;
 
+    static WebGPUWindow()
+    {
+        // Silk.NET discovers window platforms by scanning assemblies with reflection, which
+        // trimming removes under Native AOT. Registering the shipped platforms explicitly keeps
+        // window creation working in every deployment model.
+        GlfwWindowing.RegisterPlatform();
+        SdlWindowing.RegisterPlatform();
+    }
+
     /// <summary>
     /// Initializes a new instance of the <see cref="WebGPUWindow"/> class.
     /// </summary>