Adding sokol-zig into the repo instead of a submodule so it can be used with the Zig package manager

Author: Interrupt

.gitmodules

@@ -0,0 +1,11 @@
+root=true
+[**.zig]
+end_of_line=lf
+[**]
+indent_style=space
+indent_size=4
+trim_trailing_whitespace=true
+insert_final_newline=true
+
+
+

3rdparty/sokol-zig

@@ -0,0 +1 @@
+*.zig text eol=lf

3rdparty/sokol-zig/.editorconfig

@@ -0,0 +1,22 @@
+name: Zig
+
+on: [push, pull_request]
+
+jobs:
+  build:
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macos-latest, windows-latest]
+    runs-on: ${{matrix.os}}
+    steps:
+      - uses: actions/checkout@v3
+      - uses: goto-bus-stop/setup-zig@v2
+        with:
+          version: 0.11.0
+      - name: prepare-linux
+        if: runner.os == 'Linux'
+        run: |
+            sudo apt-get update
+            sudo apt-get install libglu1-mesa-dev mesa-common-dev xorg-dev libasound-dev
+      - name: build
+        run: zig build

3rdparty/sokol-zig/.gitattributes

@@ -0,0 +1,3 @@
+.vscode
+zig-*/
+NUL

3rdparty/sokol-zig/.github/workflows/main.yml

@@ -0,0 +1,87 @@
+[![build](https://github.com/floooh/sokol-zig/actions/workflows/main.yml/badge.svg)](https://github.com/floooh/sokol-zig/actions/workflows/main.yml)
+
+Auto-generated Zig bindings for the [sokol headers](https://github.com/floooh/sokol).
+
+For Zig version 0.11.0
+
+Related projects:
+
+- [pacman.zig](https://github.com/floooh/pacman.zig)
+- [kc85.zig](https://github.com/floooh/kc85.zig)
+
+> NOTE: for experimental package manager support see the branch [package](https://github.com/floooh/sokol-zig/tree/package),
+> and as example for how to integrate sokol-zig as package the [pacman.zig branch sokol-package](https://github.com/floooh/pacman.zig/tree/sokol-package)
+
+## BUILD
+
+Supported platforms are: Windows, macOS, Linux (with X11)
+
+On Linux install the following packages: libglu1-mesa-dev, mesa-common-dev, xorg-dev, libasound-dev
+(or generally: the dev packages required for X11, GL and ALSA development)
+
+```sh
+# just build:
+> zig build
+# build and run samples:
+> zig build run-clear
+> zig build run-triangle
+> zig build run-quad
+> zig build run-bufferoffsets
+> zig build run-cube
+> zig build run-noninterleaved
+> zig build run-texcube
+> zig build run-offscreen
+> zig build run-instancing
+> zig build run-mrt
+> zig build run-saudio
+> zig build run-sgl
+> zig build run-sgl-context
+> zig build run-sgl-points
+> zig build run-debugtext
+> zig build run-debugtext-print
+> zig build run-debugtext-userfont
+> zig build run-shapes
+```
+
+(also run ```zig build --help``` to inspect the build targets)
+
+By default, the backend 3D API will be selected based on the target platform:
+
+- macOS: Metal
+- Windows: D3D11
+- Linux: GL
+
+To force the GL backend on macOS or Windows, build with ```-Dgl=true```:
+
+```
+> zig build -Dgl=true run-clear
+```
+
+The ```clear``` sample prints the selected backend to the terminal:
+
+```
+sokol-zig ➤ zig build -Dgl=true run-clear
+Backend: .sokol.gfx.Backend.GLCORE33
+```
+
+## Use as Library
+
+Clone this repo into your project via ``git submodule add https://github.com/floooh/sokol-zig.git`` (for this example into a folder called ``lib`` within your project).
+
+Add to your ``build.zig``:
+```zig
+const sokol = @import("lib/sokol-zig/build.zig");
+
+// ...
+// pub fn build(b: *std.build.Builder) void {
+// ...
+
+const sokol_build = sokol.buildSokol(b, target, optimize, .{}, "lib/sokol-zig/");
+
+// ...
+// const exe = b.addExecutable("demo", "src/main.zig");
+// ...
+
+exe.addAnonymousModule("sokol", .{ .source_file = .{ .path = "lib/sokol-zig/src/sokol/sokol.zig" } });
+exe.linkLibrary(sokol_build);
+```

3rdparty/sokol-zig/.gitignore

@@ -0,0 +1,244 @@
+const std = @import("std");
+const builtin = @import("builtin");
+const Builder = std.build.Builder;
+const CompileStep = std.build.CompileStep;
+const CrossTarget = std.zig.CrossTarget;
+const OptimizeMode = std.builtin.OptimizeMode;
+
+pub const Backend = enum {
+    auto, // Windows: D3D11, macOS/iOS: Metal, otherwise: GL
+    d3d11,
+    metal,
+    gl,
+    gles2,
+    gles3,
+    wgpu,
+};
+
+pub const Config = struct {
+    backend: Backend = .auto,
+    force_egl: bool = false,
+    enable_x11: bool = true,
+    enable_wayland: bool = false,
+};
+
+// build sokol into a static library
+pub fn buildSokol(b: *Builder, target: CrossTarget, optimize: OptimizeMode, config: Config, comptime prefix_path: []const u8) *CompileStep {
+    const lib = b.addStaticLibrary(.{
+        .name = "sokol",
+        .target = target,
+        .optimize = optimize,
+    });
+    lib.linkLibC();
+    const sokol_path = prefix_path ++ "src/sokol/c/";
+    const csources = [_][]const u8{
+        "sokol_log.c",
+        "sokol_app.c",
+        "sokol_gfx.c",
+        "sokol_time.c",
+        "sokol_audio.c",
+        "sokol_gl.c",
+        "sokol_debugtext.c",
+        "sokol_shape.c",
+    };
+    var _backend = config.backend;
+    if (_backend == .auto) {
+        if (lib.target.isDarwin()) {
+            _backend = .metal;
+        } else if (lib.target.isWindows()) {
+            _backend = .d3d11;
+        } else {
+            _backend = .gl;
+        }
+    }
+    const backend_option = switch (_backend) {
+        .d3d11 => "-DSOKOL_D3D11",
+        .metal => "-DSOKOL_METAL",
+        .gl => "-DSOKOL_GLCORE33",
+        .gles2 => "-DSOKOL_GLES2",
+        .gles3 => "-DSOKOL_GLES3",
+        .wgpu => "-DSOKOL_WGPU",
+        else => unreachable,
+    };
+
+    if (lib.target.isDarwin()) {
+        inline for (csources) |csrc| {
+            lib.addCSourceFile(.{
+                .file = .{ .path = sokol_path ++ csrc },
+                .flags = &[_][]const u8{ "-ObjC", "-DIMPL", backend_option },
+            });
+        }
+        lib.linkFramework("Foundation");
+        lib.linkFramework("AudioToolbox");
+        if (.metal == _backend) {
+            lib.linkFramework("MetalKit");
+            lib.linkFramework("Metal");
+        }
+        if (lib.target.getOsTag() == .ios) {
+            lib.linkFramework("UIKit");
+            lib.linkFramework("AVFoundation");
+            if (.gl == _backend) {
+                lib.linkFramework("OpenGLES");
+                lib.linkFramework("GLKit");
+            }
+        } else if (lib.target.getOsTag() == .macos) {
+            lib.linkFramework("Cocoa");
+            lib.linkFramework("QuartzCore");
+            if (.gl == _backend) {
+                lib.linkFramework("OpenGL");
+            }
+        }
+    } else {
+        var egl_flag = if (config.force_egl) "-DSOKOL_FORCE_EGL " else "";
+        var x11_flag = if (!config.enable_x11) "-DSOKOL_DISABLE_X11 " else "";
+        var wayland_flag = if (!config.enable_wayland) "-DSOKOL_DISABLE_WAYLAND" else "";
+
+        inline for (csources) |csrc| {
+            lib.addCSourceFile(.{
+                .file = .{ .path = sokol_path ++ csrc },
+                .flags = &[_][]const u8{ "-DIMPL", backend_option, egl_flag, x11_flag, wayland_flag },
+            });
+        }
+
+        if (lib.target.isLinux()) {
+            var link_egl = config.force_egl or config.enable_wayland;
+            var egl_ensured = (config.force_egl and config.enable_x11) or config.enable_wayland;
+
+            lib.linkSystemLibrary("asound");
+
+            if (.gles2 == _backend) {
+                lib.linkSystemLibrary("glesv2");
+                if (!egl_ensured) {
+                    @panic("GLES2 in Linux only available with Config.force_egl and/or Wayland");
+                }
+            } else {
+                lib.linkSystemLibrary("GL");
+            }
+            if (config.enable_x11) {
+                lib.linkSystemLibrary("X11");
+                lib.linkSystemLibrary("Xi");
+                lib.linkSystemLibrary("Xcursor");
+            }
+            if (config.enable_wayland) {
+                lib.linkSystemLibrary("wayland-client");
+                lib.linkSystemLibrary("wayland-cursor");
+                lib.linkSystemLibrary("wayland-egl");
+                lib.linkSystemLibrary("xkbcommon");
+            }
+            if (link_egl) {
+                lib.linkSystemLibrary("egl");
+            }
+        } else if (lib.target.isWindows()) {
+            lib.linkSystemLibraryName("kernel32");
+            lib.linkSystemLibraryName("user32");
+            lib.linkSystemLibraryName("gdi32");
+            lib.linkSystemLibraryName("ole32");
+            if (.d3d11 == _backend) {
+                lib.linkSystemLibraryName("d3d11");
+                lib.linkSystemLibraryName("dxgi");
+            }
+        }
+    }
+    return lib;
+}
+
+// build one of the example exes
+fn buildExample(b: *Builder, target: CrossTarget, optimize: OptimizeMode, sokol: *CompileStep, comptime name: []const u8) void {
+    const e = b.addExecutable(.{
+        .name = name,
+        .root_source_file = .{ .path = "src/examples/" ++ name ++ ".zig" },
+        .target = target,
+        .optimize = optimize,
+    });
+    e.linkLibrary(sokol);
+    e.addAnonymousModule("sokol", .{ .source_file = .{ .path = "src/sokol/sokol.zig" } });
+    b.installArtifact(e);
+    const run = b.addRunArtifact(e);
+    b.step("run-" ++ name, "Run " ++ name).dependOn(&run.step);
+}
+
+pub fn build(b: *Builder) void {
+    var config: Config = .{};
+
+    const force_gl = b.option(bool, "gl", "Force GL backend") orelse false;
+    config.backend = if (force_gl) .gl else .auto;
+
+    // NOTE: Wayland support is *not* currently supported in the standard sokol-zig bindings,
+    // you need to generate your own bindings using this PR: https://github.com/floooh/sokol/pull/425
+    config.enable_wayland = b.option(bool, "wayland", "Compile with wayland-support (default: false)") orelse false;
+    config.enable_x11 = b.option(bool, "x11", "Compile with x11-support (default: true)") orelse true;
+    config.force_egl = b.option(bool, "egl", "Use EGL instead of GLX if possible (default: false)") orelse false;
+
+    const target = b.standardTargetOptions(.{});
+    const optimize = b.standardOptimizeOption(.{});
+    const sokol = buildSokol(b, target, optimize, config, "");
+    const examples = .{
+        "clear",
+        "triangle",
+        "quad",
+        "bufferoffsets",
+        "cube",
+        "noninterleaved",
+        "texcube",
+        "blend",
+        "offscreen",
+        "instancing",
+        "mrt",
+        "saudio",
+        "sgl",
+        "sgl-context",
+        "sgl-points",
+        "debugtext",
+        "debugtext-print",
+        "debugtext-userfont",
+        "shapes",
+    };
+    inline for (examples) |example| {
+        buildExample(b, target, optimize, sokol, example);
+    }
+    buildShaders(b);
+}
+
+// a separate step to compile shaders, expects the shader compiler in ../sokol-tools-bin/
+fn buildShaders(b: *Builder) void {
+    const sokol_tools_bin_dir = "../sokol-tools-bin/bin/";
+    const shaders_dir = "src/examples/shaders/";
+    const shaders = .{
+        "bufferoffsets.glsl",
+        "cube.glsl",
+        "instancing.glsl",
+        "mrt.glsl",
+        "noninterleaved.glsl",
+        "offscreen.glsl",
+        "quad.glsl",
+        "shapes.glsl",
+        "texcube.glsl",
+        "blend.glsl",
+    };
+    const optional_shdc: ?[:0]const u8 = comptime switch (builtin.os.tag) {
+        .windows => "win32/sokol-shdc.exe",
+        .linux => "linux/sokol-shdc",
+        .macos => if (builtin.cpu.arch.isX86()) "osx/sokol-shdc" else "osx_arm64/sokol-shdc",
+        else => null,
+    };
+    if (optional_shdc == null) {
+        std.log.warn("unsupported host platform, skipping shader compiler step", .{});
+        return;
+    }
+    const shdc_path = sokol_tools_bin_dir ++ optional_shdc.?;
+    const shdc_step = b.step("shaders", "Compile shaders (needs ../sokol-tools-bin)");
+    inline for (shaders) |shader| {
+        const cmd = b.addSystemCommand(&.{
+            shdc_path,
+            "-i",
+            shaders_dir ++ shader,
+            "-o",
+            shaders_dir ++ shader ++ ".zig",
+            "-l",
+            "glsl330:metal_macos:hlsl4",
+            "-f",
+            "sokol_zig",
+        });
+        shdc_step.dependOn(&cmd.step);
+    }
+}