fix: rework build.zig to use raylib build and add back wasm

Signed-off-by: Tomas Slusny <slusnucky@gmail.com>

Author: deathbeam

.github/workflows/build-natives.yml

@@ -17,7 +17,7 @@ jobs:
           - linux-x64
           - linux-x86
           - linux-arm64
-          # - browser-wasm
+          - browser-wasm
           - osx-x64
           - osx-arm64
           - win-x64

lib/raygui

@@ -1,77 +1,132 @@
 const std = @import("std");
-const builtin = @import("builtin");
+const rl = @import("raylib");
 
-pub fn compileRaylib(b: *std.Build, target: std.Build.ResolvedTarget, optimize: std.builtin.OptimizeMode, shared: bool) !*std.Build.Step.Compile {
-    const raylib = b.dependency("raylib", .{ .target = target, .optimize = optimize, .linkage = if (shared) std.builtin.LinkMode.dynamic else std.builtin.LinkMode.static, .linux_display_backend = .X11, .opengl_version = .gl_4_3 });
-    const raygui = b.dependency("raygui", .{ .target = target, .optimize = optimize });
-    const lib = raylib.artifact("raylib");
+pub fn build(b: *std.Build) !void {
+    const target = b.standardTargetOptions(.{});
+    const optimize = b.standardOptimizeOption(.{});
+
+    // Determine linkage based on target
+    const linkage = if (target.result.os.tag == .emscripten)
+        std.builtin.LinkMode.static
+    else
+        std.builtin.LinkMode.dynamic;
+
+    // Get raylib options for configuring the build
+    const options = rl.Options{
+        .linkage = linkage,
+        .linux_display_backend = .X11,
+        .opengl_version = .gl_4_3,
+    };
+
+    // Build raylib using raylib's build system
+    const raylib_dep = b.dependency("raylib", .{
+        .target = target,
+        .optimize = optimize,
+        .raudio = options.raudio,
+        .rmodels = options.rmodels,
+        .rshapes = options.rshapes,
+        .rtext = options.rtext,
+        .rtextures = options.rtextures,
+        .platform = options.platform,
+        .linkage = options.linkage,
+        .linux_display_backend = options.linux_display_backend,
+        .opengl_version = options.opengl_version,
+        .android_api_version = options.android_api_version,
+        .android_ndk = options.android_ndk,
+    });
+    const raylib = raylib_dep.artifact("raylib");
 
+    // Add platform-specific include/library paths for cross-compiling
+    // Note: On Ubuntu/Debian, cross-compilation libraries are installed in multiarch paths.
+    // On other distros (like Arch), these paths don't exist and Zig will warn but continue.
+    // The warnings are cosmetic and don't affect the build - standard paths are added first.
     switch (target.result.os.tag) {
-        // Due to *terrible* zig default behaviour for include paths when cross-compiling I have to do this
-        // The includes are resolved properly only when -Dtarget=native (or omitted) is passed
         .linux => {
+            // Add standard paths that work on all distros
+            raylib.addLibraryPath(.{ .cwd_relative = "/usr/lib" });
+            raylib.addSystemIncludePath(.{ .cwd_relative = "/usr/include" });
+
+            // Add Ubuntu/Debian multiarch paths for cross-compilation
+            // These are needed for CI builds on Ubuntu when cross-compiling to different architectures
             if (target.result.cpu.arch == .aarch64) {
-                lib.addLibraryPath(.{ .cwd_relative = "/usr/lib/aarch64-linux-gnu/" });
-                lib.addIncludePath(.{ .cwd_relative = "/usr/include/aarch64-linux-gnu/" });
-                lib.addSystemIncludePath(.{ .cwd_relative = "/usr/include" });
+                raylib.addLibraryPath(.{ .cwd_relative = "/usr/lib/aarch64-linux-gnu/" });
+                raylib.addIncludePath(.{ .cwd_relative = "/usr/include/aarch64-linux-gnu/" });
             } else if (target.result.cpu.arch == .x86) {
-                lib.addLibraryPath(.{ .cwd_relative = "/usr/lib/i386-linux-gnu/" });
-                lib.addIncludePath(.{ .cwd_relative = "/usr/include/i386-linux-gnu/" });
-                lib.addSystemIncludePath(.{ .cwd_relative = "/usr/include" });
+                raylib.addLibraryPath(.{ .cwd_relative = "/usr/lib/i386-linux-gnu/" });
+                raylib.addIncludePath(.{ .cwd_relative = "/usr/include/i386-linux-gnu/" });
                 // https://github.com/ziglang/zig/issues/7935
-                lib.link_z_notext = true;
+                raylib.link_z_notext = true;
             } else if (target.result.cpu.arch == .x86_64) {
-                lib.addLibraryPath(.{ .cwd_relative = "/usr/lib/x86_64-linux-gnu/" });
-                lib.addIncludePath(.{ .cwd_relative = "/usr/include/x86_64-linux-gnu/" });
-                lib.addIncludePath(.{ .cwd_relative = "/usr/include" });
-            } else {
-                lib.addSystemIncludePath(.{ .cwd_relative = "/usr/include" });
+                raylib.addLibraryPath(.{ .cwd_relative = "/usr/lib/x86_64-linux-gnu/" });
+                raylib.addIncludePath(.{ .cwd_relative = "/usr/include/x86_64-linux-gnu/" });
             }
-
-            lib.addLibraryPath(.{ .cwd_relative = "/usr/lib" });
         },
-        else => {}
+        else => {},
     }
 
-    var gen_step = b.addWriteFiles();
-    lib.step.dependOn(&gen_step.step);
-
-    var cflags = std.ArrayList([]const u8){};
-    defer cflags.deinit(b.allocator);
-
-    try cflags.appendSlice(b.allocator, &[_][]const u8{
-        "-std=gnu99",
-        "-D_GNU_SOURCE",
-        "-DGL_SILENCE_DEPRECATION=199309L",
-        "-fno-sanitize=undefined",
+    // Add raygui using raylib's helper function
+    const raygui_dep = b.dependency("raygui", .{
+        .target = target,
+        .optimize = optimize,
     });
+    rl.addRaygui(b, raylib, raygui_dep, options);
 
-    if (shared) {
-        try cflags.appendSlice(b.allocator, &[_][]const u8{
-            "-fPIC",
-            "-DBUILD_LIBTYPE_SHARED",
-        });
-    }
+    // Install the library
+    // For non-emscripten targets, also build a static library version
+    if (target.result.os.tag != .emscripten) {
+        // Install the shared library
+        b.installArtifact(raylib);
 
-    lib.addCSourceFile(.{
-        .file = gen_step.add("raygui.c", "#define RAYGUI_IMPLEMENTATION\n#include \"raygui.h\"\n"),
-        .flags = cflags.items,
-    });
+        // Also build and install a static version
+        const raylib_static_dep = b.dependency("raylib", .{
+            .target = target,
+            .optimize = optimize,
+            .raudio = options.raudio,
+            .rmodels = options.rmodels,
+            .rshapes = options.rshapes,
+            .rtext = options.rtext,
+            .rtextures = options.rtextures,
+            .platform = options.platform,
+            .linkage = .static,
+            .linux_display_backend = options.linux_display_backend,
+            .opengl_version = options.opengl_version,
+            .android_api_version = options.android_api_version,
+            .android_ndk = options.android_ndk,
+        });
+        const raylib_static = raylib_static_dep.artifact("raylib");
 
-    lib.addIncludePath(raylib.path("src"));
-    lib.addIncludePath(raygui.path("src"));
-    lib.installHeader(raygui.path("src/raygui.h"), "raygui.h");
+        // Add same platform-specific paths for static lib
+        switch (target.result.os.tag) {
+            .linux => {
+                raylib_static.addLibraryPath(.{ .cwd_relative = "/usr/lib" });
+                raylib_static.addSystemIncludePath(.{ .cwd_relative = "/usr/include" });
 
-    return lib;
-}
+                // Add multiarch paths for cross-compilation
+                if (target.result.cpu.arch == .aarch64) {
+                    raylib_static.addLibraryPath(.{ .cwd_relative = "/usr/lib/aarch64-linux-gnu/" });
+                    raylib_static.addIncludePath(.{ .cwd_relative = "/usr/include/aarch64-linux-gnu/" });
+                } else if (target.result.cpu.arch == .x86) {
+                    raylib_static.addLibraryPath(.{ .cwd_relative = "/usr/lib/i386-linux-gnu/" });
+                    raylib_static.addIncludePath(.{ .cwd_relative = "/usr/include/i386-linux-gnu/" });
+                    raylib_static.link_z_notext = true;
+                } else if (target.result.cpu.arch == .x86_64) {
+                    raylib_static.addLibraryPath(.{ .cwd_relative = "/usr/lib/x86_64-linux-gnu/" });
+                    raylib_static.addIncludePath(.{ .cwd_relative = "/usr/include/x86_64-linux-gnu/" });
+                }
+            },
+            else => {},
+        }
 
-pub fn build(b: *std.Build) !void {
-    const target = b.standardTargetOptions(.{});
-    const optimize = b.standardOptimizeOption(.{});
+        // Add raygui to static library too
+        rl.addRaygui(b, raylib_static, raygui_dep, .{
+            .linkage = .static,
+            .linux_display_backend = options.linux_display_backend,
+            .opengl_version = options.opengl_version,
+        });
 
-    if (target.result.os.tag != .emscripten) {
-        b.installArtifact(try compileRaylib(b, target, optimize, true));
+        b.installArtifact(raylib_static);
+    } else {
+        // For emscripten, just install the static library
+        b.installArtifact(raylib);
     }
-
-    b.installArtifact(try compileRaylib(b, target, optimize, false));
 }

lib/raylib

@@ -766,6 +766,13 @@ public static unsafe partial class Raylib
     [UnmanagedCallConv(CallConvs = [typeof(CallConvCdecl)])]
     public static partial void OpenURL(string url);
 
+    /// <summary>
+    /// Set the current threshold (minimum) log level
+    /// </summary>
+    [LibraryImport(LIBRARY, StringMarshalling = StringMarshalling.Utf8)]
+    [UnmanagedCallConv(CallConvs = [typeof(CallConvCdecl)])]
+    public static partial void SetTraceLogLevel(int logLevel);
+
     /// <summary>
     /// Show trace log messages (LOG_DEBUG, LOG_INFO, LOG_WARNING, LOG_ERROR...)
     /// </summary>
@@ -774,11 +781,11 @@ public static unsafe partial class Raylib
     public static partial void TraceLog(int logLevel, string text, IntPtr args);
 
     /// <summary>
-    /// Set the current threshold (minimum) log level
+    /// Set custom trace log
     /// </summary>
     [LibraryImport(LIBRARY, StringMarshalling = StringMarshalling.Utf8)]
     [UnmanagedCallConv(CallConvs = [typeof(CallConvCdecl)])]
-    public static partial void SetTraceLogLevel(int logLevel);
+    public static unsafe partial void SetTraceLogCallback(delegate* unmanaged[Cdecl]<int, sbyte*, sbyte*, void> callback);
 
     /// <summary>
     /// Internal memory allocator
@@ -802,88 +809,81 @@ public static unsafe partial class Raylib
     public static unsafe partial void MemFree(void* ptr);
 
     /// <summary>
-    /// Set custom trace log
-    /// </summary>
-    [LibraryImport(LIBRARY, StringMarshalling = StringMarshalling.Utf8)]
-    [UnmanagedCallConv(CallConvs = [typeof(CallConvCdecl)])]
-    public static unsafe partial void SetTraceLogCallback(delegate* unmanaged[Cdecl]<int, sbyte*, sbyte*, void> callback);
-
-    /// <summary>
-    /// Set custom file binary data loader
+    /// Load file data as byte array (read)
     /// </summary>
     [LibraryImport(LIBRARY, StringMarshalling = StringMarshalling.Utf8)]
     [UnmanagedCallConv(CallConvs = [typeof(CallConvCdecl)])]
-    public static unsafe partial void SetLoadFileDataCallback(delegate* unmanaged[Cdecl]<sbyte*, int*, byte*> callback);
+    public static unsafe partial byte* LoadFileData(string fileName, ref int dataSize);
 
     /// <summary>
-    /// Set custom file binary data saver
+    /// Unload file data allocated by LoadFileData()
     /// </summary>
     [LibraryImport(LIBRARY, StringMarshalling = StringMarshalling.Utf8)]
     [UnmanagedCallConv(CallConvs = [typeof(CallConvCdecl)])]
-    public static unsafe partial void SetSaveFileDataCallback(delegate* unmanaged[Cdecl]<sbyte*, void*, int, sbyte> callback);
+    public static unsafe partial void UnloadFileData(byte* data);
 
     /// <summary>
-    /// Set custom file text data loader
+    /// Save data to file from byte array (write), returns true on success
     /// </summary>
     [LibraryImport(LIBRARY, StringMarshalling = StringMarshalling.Utf8)]
     [UnmanagedCallConv(CallConvs = [typeof(CallConvCdecl)])]
-    public static unsafe partial void SetLoadFileTextCallback(delegate* unmanaged[Cdecl]<sbyte*, sbyte*> callback);
+    public static unsafe partial NativeBool SaveFileData(string fileName, void* data, int dataSize);
 
     /// <summary>
-    /// Set custom file text data saver
+    /// Export data to code (.h), returns true on success
     /// </summary>
     [LibraryImport(LIBRARY, StringMarshalling = StringMarshalling.Utf8)]
     [UnmanagedCallConv(CallConvs = [typeof(CallConvCdecl)])]
-    public static unsafe partial void SetSaveFileTextCallback(delegate* unmanaged[Cdecl]<sbyte*, sbyte*, sbyte> callback);
+    public static unsafe partial NativeBool ExportDataAsCode(byte* data, int dataSize, string fileName);
 
     /// <summary>
-    /// Load file data as byte array (read)
+    /// Load text data from file (read), returns a '\0' terminated string
     /// </summary>
     [LibraryImport(LIBRARY, StringMarshalling = StringMarshalling.Utf8)]
     [UnmanagedCallConv(CallConvs = [typeof(CallConvCdecl)])]
-    public static unsafe partial byte* LoadFileData(string fileName, ref int dataSize);
+    public static partial string LoadFileText(string fileName);
 
     /// <summary>
-    /// Unload file data allocated by LoadFileData()
+    /// Unload file text data allocated by LoadFileText()
     /// </summary>
     [LibraryImport(LIBRARY, StringMarshalling = StringMarshalling.Utf8)]
     [UnmanagedCallConv(CallConvs = [typeof(CallConvCdecl)])]
-    public static unsafe partial void UnloadFileData(byte* data);
+    public static partial void UnloadFileText(string text);
 
     /// <summary>
-    /// Save data to file from byte array (write), returns true on success
+    /// Save text data to file (write), string must be '\0' terminated, returns true on success
     /// </summary>
     [LibraryImport(LIBRARY, StringMarshalling = StringMarshalling.Utf8)]
     [UnmanagedCallConv(CallConvs = [typeof(CallConvCdecl)])]
-    public static unsafe partial NativeBool SaveFileData(string fileName, void* data, int dataSize);
+    public static partial NativeBool SaveFileText(string fileName, string text);
 
     /// <summary>
-    /// Export data to code (.h), returns true on success
+    /// Set custom file binary data loader
     /// </summary>
     [LibraryImport(LIBRARY, StringMarshalling = StringMarshalling.Utf8)]
     [UnmanagedCallConv(CallConvs = [typeof(CallConvCdecl)])]
-    public static unsafe partial NativeBool ExportDataAsCode(byte* data, int dataSize, string fileName);
+    public static unsafe partial void SetLoadFileDataCallback(delegate* unmanaged[Cdecl]<sbyte*, int*, byte*> callback);
 
     /// <summary>
-    /// Load text data from file (read), returns a '\0' terminated string
+    /// Set custom file binary data saver
     /// </summary>
     [LibraryImport(LIBRARY, StringMarshalling = StringMarshalling.Utf8)]
     [UnmanagedCallConv(CallConvs = [typeof(CallConvCdecl)])]
-    public static partial string LoadFileText(string fileName);
+    public static unsafe partial void SetSaveFileDataCallback(delegate* unmanaged[Cdecl]<sbyte*, void*, int, sbyte> callback);
 
     /// <summary>
-    /// Unload file text data allocated by LoadFileText()
+    /// Set custom file text data loader
     /// </summary>
     [LibraryImport(LIBRARY, StringMarshalling = StringMarshalling.Utf8)]
     [UnmanagedCallConv(CallConvs = [typeof(CallConvCdecl)])]
-    public static partial void UnloadFileText(string text);
+    public static unsafe partial void SetLoadFileTextCallback(delegate* unmanaged[Cdecl]<sbyte*, sbyte*> callback);
 
     /// <summary>
-    /// Save text data to file (write), string must be '\0' terminated, returns true on success
+    /// Set custom file text data saver
     /// </summary>
     [LibraryImport(LIBRARY, StringMarshalling = StringMarshalling.Utf8)]
     [UnmanagedCallConv(CallConvs = [typeof(CallConvCdecl)])]
-    public static partial NativeBool SaveFileText(string fileName, string text);
+    public static unsafe partial void SetSaveFileTextCallback(delegate* unmanaged[Cdecl]<sbyte*, sbyte*, sbyte> callback);
 
     /// <summary>
     /// Rename file (if exists)
@@ -1081,6 +1081,20 @@ public static unsafe partial class Raylib
     [UnmanagedCallConv(CallConvs = [typeof(CallConvCdecl)])]
     public static partial void UnloadDroppedFiles(FilePathList files);
 
+    /// <summary>
+    /// Get the file count in a directory
+    /// </summary>
+    [LibraryImport(LIBRARY, StringMarshalling = StringMarshalling.Utf8)]
+    [UnmanagedCallConv(CallConvs = [typeof(CallConvCdecl)])]
+    public static partial uint GetDirectoryFileCount(string dirPath);
+
+    /// <summary>
+    /// Get the file count in a directory with extension filtering and recursive directory scan. Use 'DIR' in the filter string to include directories in the result
+    /// </summary>
+    [LibraryImport(LIBRARY, StringMarshalling = StringMarshalling.Utf8)]
+    [UnmanagedCallConv(CallConvs = [typeof(CallConvCdecl)])]
+    public static partial uint GetDirectoryFileCountEx(string basePath, string filter, NativeBool scanSubdirs);
+
     /// <summary>
     /// Compress data (DEFLATE algorithm), memory must be MemFree()
     /// </summary>

src/Raylib.NET.Native/build.zig

@@ -516,7 +516,7 @@ public static unsafe partial class Raymath
 
     /// <summary>
     /// Projects a Vector3 from screen space into object space
-    /// NOTE: We are avoiding calling other raymath functions despite available
+    /// NOTE: Self-contained function, no other raymath functions are called
     /// </summary>
     [LibraryImport(LIBRARY, StringMarshalling = StringMarshalling.Utf8)]
     [UnmanagedCallConv(CallConvs = [typeof(CallConvCdecl)])]

src/Raylib.NET/Raylib.cs

@@ -8,10 +8,6 @@ namespace RaylibNET;
 [StructLayout(LayoutKind.Sequential)]
 public partial struct FilePathList
 {
-    /// <summary>
-    /// Filepaths max entries
-    /// </summary>
-    public uint Capacity;
     /// <summary>
     /// Filepaths entries count
     /// </summary>
@@ -21,9 +17,8 @@ public partial struct FilePathList
     /// </summary>
     public unsafe sbyte** Paths;
 
-    public unsafe FilePathList(uint capacity, uint count, sbyte** paths)
+    public unsafe FilePathList(uint count, sbyte** paths)
     {
-        this.Capacity = capacity;
         this.Count = count;
         this.Paths = paths;
     }