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/glfw/src/Image.zig

@@ -0,0 +1,82 @@
+//! Image data
+//!
+//!
+//! This describes a single 2D image. See the documentation for each related function what the
+//! expected pixel format is.
+//!
+//! see also: cursor_custom, window_icon
+//!
+//! It may be .owned (e.g. in the case of an image initialized by you for passing into glfw) or not
+//! .owned (e.g. in the case of one gotten via glfw) If it is .owned, deinit should be called to
+//! free the memory. It is safe to call deinit even if not .owned.
+
+const std = @import("std");
+const testing = std.testing;
+const mem = std.mem;
+const c = @import("c.zig").c;
+
+const Image = @This();
+
+/// The width of this image, in pixels.
+width: u32,
+
+/// The height of this image, in pixels.
+height: u32,
+
+/// The pixel data of this image, arranged left-to-right, top-to-bottom.
+pixels: []u8,
+
+/// Whether or not the pixels data is owned by you (true) or GLFW (false).
+owned: bool,
+
+/// Initializes a new owned image with the given size and pixel_data_len of undefined .pixel values.
+pub inline fn init(allocator: mem.Allocator, width: u32, height: u32, pixel_data_len: usize) !Image {
+    const buf = try allocator.alloc(u8, pixel_data_len);
+    return Image{
+        .width = width,
+        .height = height,
+        .pixels = buf,
+        .owned = true,
+    };
+}
+
+/// Turns a GLFW / C image into the nicer Zig type, and sets `.owned = false`.
+///
+/// The length of pixel data must be supplied, as GLFW's image type does not itself describe the
+/// number of bytes required per pixel / the length of the pixel data array.
+///
+/// The returned memory is valid for as long as the GLFW C memory is valid.
+pub inline fn fromC(native: c.GLFWimage, pixel_data_len: usize) Image {
+    return Image{
+        .width = @intCast(u32, native.width),
+        .height = @intCast(u32, native.height),
+        .pixels = native.pixels[0..pixel_data_len],
+        .owned = false,
+    };
+}
+
+/// Turns the nicer Zig type into a GLFW / C image, for passing into GLFW C functions.
+///
+/// The returned memory is valid for as long as the Zig memory is valid.
+pub inline fn toC(self: Image) c.GLFWimage {
+    return c.GLFWimage{
+        .width = @intCast(c_int, self.width),
+        .height = @intCast(c_int, self.height),
+        .pixels = &self.pixels[0],
+    };
+}
+
+/// Deinitializes the memory using the allocator iff `.owned = true`.
+pub inline fn deinit(self: Image, allocator: mem.Allocator) void {
+    if (self.owned) allocator.free(self.pixels);
+}
+
+test "conversion" {
+    const allocator = testing.allocator;
+
+    const image = try Image.init(allocator, 256, 256, 256 * 256 * 4);
+    defer image.deinit(allocator);
+
+    const glfw = image.toC();
+    _ = Image.fromC(glfw, image.width * image.height * 4);
+}