all: move standalone libraries to libs/ subdirectory

The root dir of our repository has grown quite a lot the past few months.

I'd like to make it more clear where the bulk of the engine lives (`src/`) and
also make it more clear which Mach libraries are consumable as standalone projects.

As for the name of this directory, `libs` was my first choice but there's a bit of
a convention of that being external libraries in Zig projects _today_, while these
are libraries maintained as part of Mach in this repository - not external ones.

We will name this directory `libs`, and if we have a need for external libraries
we will use `external` or `deps` for that directory name. I considered other names
such as `components`, `systems`, `modules` (which are bad as they overlap with
major ECS / engine concepts), and it seems likely the official Zig package manager
will break the convention of using a `libs` dir anyway.

Performed via:

```sh
mkdir libs/
git mv freetype libs/
git mv basisu libs/
git mv gamemode libs/
git mv glfw libs/
git mv gpu libs/
git mv gpu-dawn libs/
git mv sysaudio libs/
git mv sysjs libs/
git mv ecs libs/
```

git-subtree-dir: glfw
git-subtree-mainline: 0d5b853443
git-subtree-split: 572d1144f11b353abdb64fff828b25a4f0fbb7ca

Signed-off-by: Stephen Gutekanst <stephen@hexops.com>

git mv ecs libs/

Signed-off-by: Stephen Gutekanst <stephen@hexops.com>

libs/gpu/src/adapter.zig

@@ -0,0 +1,109 @@
+const std = @import("std");
+const testing = std.testing;
+const ChainedStructOut = @import("types.zig").ChainedStructOut;
+const Device = @import("device.zig").Device;
+const FeatureName = @import("types.zig").FeatureName;
+const SupportedLimits = @import("types.zig").SupportedLimits;
+const RequestDeviceStatus = @import("types.zig").RequestDeviceStatus;
+const BackendType = @import("types.zig").BackendType;
+const RequestDeviceCallback = @import("callbacks.zig").RequestDeviceCallback;
+const Impl = @import("interface.zig").Impl;
+
+pub const Adapter = opaque {
+    pub const Type = enum(u32) {
+        discrete_gpu,
+        integrated_gpu,
+        cpu,
+        unknown,
+
+        pub fn name(t: Type) []const u8 {
+            return switch (t) {
+                .discrete_gpu => "Discrete GPU",
+                .integrated_gpu => "Integrated GPU",
+                .cpu => "CPU",
+                .unknown => "Unknown",
+            };
+        }
+    };
+
+    pub const Properties = extern struct {
+        next_in_chain: ?*ChainedStructOut = null,
+        vendor_id: u32,
+        vendor_name: [*:0]const u8,
+        architecture: [*:0]const u8,
+        device_id: u32,
+        name: [*:0]const u8,
+        driver_description: [*:0]const u8,
+        adapter_type: Type,
+        backend_type: BackendType,
+    };
+
+    pub inline fn createDevice(adapter: *Adapter, descriptor: ?*const Device.Descriptor) ?*Device {
+        return Impl.adapterCreateDevice(adapter, descriptor);
+    }
+
+    /// Call once with null to determine the array length, and again to fetch the feature list.
+    ///
+    /// Consider using the enumerateFeaturesOwned helper.
+    pub inline fn enumerateFeatures(adapter: *Adapter, features: ?[*]FeatureName) usize {
+        return Impl.adapterEnumerateFeatures(adapter, features);
+    }
+
+    /// Enumerates the adapter features, storing the result in an allocated slice which is owned by
+    /// the caller.
+    pub inline fn enumerateFeaturesOwned(adapter: *Adapter, allocator: std.mem.Allocator) ![]FeatureName {
+        const count = adapter.enumerateFeatures(null);
+        var data = try allocator.alloc(FeatureName, count);
+        _ = adapter.enumerateFeatures(data.ptr);
+        return data;
+    }
+
+    pub inline fn getLimits(adapter: *Adapter, limits: *SupportedLimits) bool {
+        return Impl.adapterGetLimits(adapter, limits);
+    }
+
+    pub inline fn getProperties(adapter: *Adapter, properties: *Adapter.Properties) void {
+        Impl.adapterGetProperties(adapter, properties);
+    }
+
+    pub inline fn hasFeature(adapter: *Adapter, feature: FeatureName) bool {
+        return Impl.adapterHasFeature(adapter, feature);
+    }
+
+    pub inline fn requestDevice(
+        adapter: *Adapter,
+        descriptor: ?*const Device.Descriptor,
+        context: anytype,
+        comptime callback: fn (
+            ctx: @TypeOf(context),
+            status: RequestDeviceStatus,
+            device: *Device,
+            message: ?[*:0]const u8,
+        ) callconv(.Inline) void,
+    ) void {
+        const Context = @TypeOf(context);
+        const Helper = struct {
+            pub fn cCallback(status: RequestDeviceStatus, device: *Device, message: ?[*:0]const u8, userdata: ?*anyopaque) callconv(.C) void {
+                callback(
+                    if (Context == void) {} else @ptrCast(Context, @alignCast(@alignOf(Context), userdata)),
+                    status,
+                    device,
+                    message,
+                );
+            }
+        };
+        Impl.adapterRequestDevice(adapter, descriptor, Helper.cCallback, if (Context == void) null else context);
+    }
+
+    pub inline fn reference(adapter: *Adapter) void {
+        Impl.adapterReference(adapter);
+    }
+
+    pub inline fn release(adapter: *Adapter) void {
+        Impl.adapterRelease(adapter);
+    }
+};
+
+test "Adapter.Type name" {
+    try testing.expectEqualStrings("Discrete GPU", Adapter.Type.discrete_gpu.name());
+}