0645429df9
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>
109 lines
3.8 KiB
Zig
109 lines
3.8 KiB
Zig
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());
|
|
}
|