zig/mach
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

glfw: Revert error denormalization

Browse source
This commit is contained in:
InKryption 2021-11-22 00:34:38 +01:00 • committed by Stephen Gutekanst
parent 44fee8f1f1
commit ef7ada052c
10 changed files with 146 additions and 146 deletions
Download patch file Download diff file Expand all files Collapse all files

8
glfw/src/Cursor.zig
View file

@ -60,12 +60,12 @@ pub const Shape = enum(isize) {
/// @thread_safety This function must only be called from the main thread. /// @thread_safety This function must only be called from the main thread.
/// ///
/// see also: cursor_object, glfw.Cursor.destroy, glfw.Cursor.createStandard /// see also: cursor_object, glfw.Cursor.destroy, glfw.Cursor.createStandard
pub inline fn create(image: Image, xhot: isize, yhot: isize) error{ PlatformError }!Cursor { pub inline fn create(image: Image, xhot: isize, yhot: isize) Error!Cursor {
internal_debug.assertInitialized(); internal_debug.assertInitialized();
const img = image.toC(); const img = image.toC();
const cursor = c.glfwCreateCursor(&img, @intCast(c_int, xhot), @intCast(c_int, yhot)); const cursor = c.glfwCreateCursor(&img, @intCast(c_int, xhot), @intCast(c_int, yhot));
getError() catch |err| return switch (err) { getError() catch |err| return switch (err) {
Error.PlatformError => @errSetCast(error{ PlatformError }, err), Error.PlatformError => err,
else => unreachable, else => unreachable,
}; };
return Cursor{ .ptr = cursor.? }; return Cursor{ .ptr = cursor.? };
@ -80,13 +80,13 @@ pub inline fn create(image: Image, xhot: isize, yhot: isize) error{ PlatformErro
/// @thread_safety This function must only be called from the main thread. /// @thread_safety This function must only be called from the main thread.
/// ///
/// see also: cursor_object, glfwCreateCursor /// see also: cursor_object, glfwCreateCursor
pub inline fn createStandard(shape: Shape) error{ InvalidEnum, PlatformError }!Cursor { pub inline fn createStandard(shape: Shape) Error!Cursor {
internal_debug.assertInitialized(); internal_debug.assertInitialized();
const cursor = c.glfwCreateStandardCursor(@intCast(c_int, @enumToInt(shape))); const cursor = c.glfwCreateStandardCursor(@intCast(c_int, @enumToInt(shape)));
getError() catch |err| return switch (err) { getError() catch |err| return switch (err) {
// TODO: should be impossible given that only the values in 'Shape' are available, unless the user explicitly gives us a bad value via casting // TODO: should be impossible given that only the values in 'Shape' are available, unless the user explicitly gives us a bad value via casting
Error.InvalidEnum => unreachable, Error.InvalidEnum => unreachable,
Error.PlatformError => @errSetCast(error{ PlatformError }, err), Error.PlatformError => err,
else => unreachable, else => unreachable,
}; };
return Cursor{ .ptr = cursor.? }; return Cursor{ .ptr = cursor.? };

36
glfw/src/Joystick.zig
View file

@ -86,13 +86,13 @@ const GamepadState = extern struct {
/// @thread_safety This function must only be called from the main thread. /// @thread_safety This function must only be called from the main thread.
/// ///
/// see also: joystick /// see also: joystick
pub inline fn present(self: Joystick) error{ InvalidEnum, PlatformError }!bool { pub inline fn present(self: Joystick) Error!bool {
internal_debug.assertInitialized(); internal_debug.assertInitialized();
const is_present = c.glfwJoystickPresent(self.jid); const is_present = c.glfwJoystickPresent(self.jid);
getError() catch |err| return switch (err) { getError() catch |err| return switch (err) {
Error.InvalidEnum, Error.InvalidEnum,
Error.PlatformError, Error.PlatformError,
=> @errSetCast(error{ InvalidEnum, PlatformError }, err), => err,
else => unreachable, else => unreachable,
}; };
return is_present == c.GLFW_TRUE; return is_present == c.GLFW_TRUE;
@ -118,14 +118,14 @@ pub inline fn present(self: Joystick) error{ InvalidEnum, PlatformError }!bool {
/// ///
/// see also: joystick_axis /// see also: joystick_axis
/// Replaces `glfwGetJoystickPos`. /// Replaces `glfwGetJoystickPos`.
pub inline fn getAxes(self: Joystick) error{ InvalidEnum, PlatformError }!?[]const f32 { pub inline fn getAxes(self: Joystick) Error!?[]const f32 {
internal_debug.assertInitialized(); internal_debug.assertInitialized();
var count: c_int = undefined; var count: c_int = undefined;
const axes = c.glfwGetJoystickAxes(self.jid, &count); const axes = c.glfwGetJoystickAxes(self.jid, &count);
getError() catch |err| return switch (err) { getError() catch |err| return switch (err) {
Error.InvalidEnum, Error.InvalidEnum,
Error.PlatformError, Error.PlatformError,
=> @errSetCast(error{ InvalidEnum, PlatformError }, err), => err,
else => unreachable, else => unreachable,
}; };
if (axes == null) return null; if (axes == null) return null;
@ -156,14 +156,14 @@ pub inline fn getAxes(self: Joystick) error{ InvalidEnum, PlatformError }!?[]con
/// @thread_safety This function must only be called from the main thread. /// @thread_safety This function must only be called from the main thread.
/// ///
/// see also: joystick_button /// see also: joystick_button
pub inline fn getButtons(self: Joystick) error{ InvalidEnum, PlatformError }!?[]const u8 { pub inline fn getButtons(self: Joystick) Error!?[]const u8 {
internal_debug.assertInitialized(); internal_debug.assertInitialized();
var count: c_int = undefined; var count: c_int = undefined;
const buttons = c.glfwGetJoystickButtons(self.jid, &count); const buttons = c.glfwGetJoystickButtons(self.jid, &count);
getError() catch |err| return switch (err) { getError() catch |err| return switch (err) {
Error.InvalidEnum, Error.InvalidEnum,
Error.PlatformError, Error.PlatformError,
=> @errSetCast(error{ InvalidEnum, PlatformError }, err), => err,
else => unreachable, else => unreachable,
}; };
if (buttons == null) return null; if (buttons == null) return null;
@ -210,14 +210,14 @@ pub inline fn getButtons(self: Joystick) error{ InvalidEnum, PlatformError }!?[]
/// @thread_safety This function must only be called from the main thread. /// @thread_safety This function must only be called from the main thread.
/// ///
/// see also: joystick_hat /// see also: joystick_hat
pub inline fn getHats(self: Joystick) error{ InvalidEnum, PlatformError }!?[]const Hat { pub inline fn getHats(self: Joystick) Error!?[]const Hat {
internal_debug.assertInitialized(); internal_debug.assertInitialized();
var count: c_int = undefined; var count: c_int = undefined;
const hats = c.glfwGetJoystickHats(self.jid, &count); const hats = c.glfwGetJoystickHats(self.jid, &count);
getError() catch |err| return switch (err) { getError() catch |err| return switch (err) {
Error.InvalidEnum, Error.InvalidEnum,
Error.PlatformError, Error.PlatformError,
=> @errSetCast(error{ InvalidEnum, PlatformError }, err), => err,
else => unreachable, else => unreachable,
}; };
if (hats == null) return null; if (hats == null) return null;
@ -244,13 +244,13 @@ pub inline fn getHats(self: Joystick) error{ InvalidEnum, PlatformError }!?[]con
/// @thread_safety This function must only be called from the main thread. /// @thread_safety This function must only be called from the main thread.
/// ///
/// see also: joystick_name /// see also: joystick_name
pub inline fn getName(self: Joystick) error{ InvalidEnum, PlatformError }!?[:0]const u8 { pub inline fn getName(self: Joystick) Error!?[:0]const u8 {
internal_debug.assertInitialized(); internal_debug.assertInitialized();
const name_opt = c.glfwGetJoystickName(self.jid); const name_opt = c.glfwGetJoystickName(self.jid);
getError() catch |err| return switch (err) { getError() catch |err| return switch (err) {
Error.InvalidEnum, Error.InvalidEnum,
Error.PlatformError, Error.PlatformError,
=> @errSetCast(error{ InvalidEnum, PlatformError }, err), => err,
else => unreachable, else => unreachable,
}; };
return if (name_opt) |name| return if (name_opt) |name|
@ -286,13 +286,13 @@ pub inline fn getName(self: Joystick) error{ InvalidEnum, PlatformError }!?[:0]c
/// @thread_safety This function must only be called from the main thread. /// @thread_safety This function must only be called from the main thread.
/// ///
/// see also: gamepad /// see also: gamepad
pub inline fn getGUID(self: Joystick) error{ InvalidEnum, PlatformError }!?[:0]const u8 { pub inline fn getGUID(self: Joystick) Error!?[:0]const u8 {
internal_debug.assertInitialized(); internal_debug.assertInitialized();
const guid_opt = c.glfwGetJoystickGUID(self.jid); const guid_opt = c.glfwGetJoystickGUID(self.jid);
getError() catch |err| return switch (err) { getError() catch |err| return switch (err) {
Error.InvalidEnum, Error.InvalidEnum,
Error.PlatformError, Error.PlatformError,
=> @errSetCast(error{ InvalidEnum, PlatformError }, err), => err,
else => unreachable, else => unreachable,
}; };
return if (guid_opt) |guid| return if (guid_opt) |guid|
@ -404,11 +404,11 @@ pub inline fn setCallback(callback: ?fn (joystick: Joystick, event: Event) void)
/// ///
/// ///
/// @ingroup input /// @ingroup input
pub inline fn updateGamepadMappings(gamepad_mappings: [*:0]const u8) error{ InvalidValue }!void { pub inline fn updateGamepadMappings(gamepad_mappings: [*:0]const u8) Error!void {
internal_debug.assertInitialized(); internal_debug.assertInitialized();
_ = c.glfwUpdateGamepadMappings(gamepad_mappings); _ = c.glfwUpdateGamepadMappings(gamepad_mappings);
getError() catch |err| return switch (err) { getError() catch |err| return switch (err) {
Error.InvalidValue => @errSetCast(error{ InvalidValue }, err), Error.InvalidValue => err,
else => unreachable, else => unreachable,
}; };
} }
@ -462,11 +462,11 @@ pub inline fn isGamepad(self: Joystick) bool {
/// see also: gamepad, glfw.Joystick.isGamepad /// see also: gamepad, glfw.Joystick.isGamepad
// TODO: Consider this; GLFW documentation for this function doesn't list any errors, // TODO: Consider this; GLFW documentation for this function doesn't list any errors,
// but source code in 'init.c' only appears to return 'GLFW_INVALID_ENUM' and 'GLFW_NOT_INITIALIZED' on error. // but source code in 'init.c' only appears to return 'GLFW_INVALID_ENUM' and 'GLFW_NOT_INITIALIZED' on error.
pub inline fn getGamepadName(self: Joystick) error{ InvalidEnum }!?[:0]const u8 { pub inline fn getGamepadName(self: Joystick) Error!?[:0]const u8 {
internal_debug.assertInitialized(); internal_debug.assertInitialized();
const name_opt = c.glfwGetGamepadName(self.jid); const name_opt = c.glfwGetGamepadName(self.jid);
getError() catch |err| return switch (err) { getError() catch |err| return switch (err) {
Error.InvalidEnum => @errSetCast(error{ InvalidEnum }, err), Error.InvalidEnum => err,
else => unreachable, else => unreachable,
}; };
return if (name_opt) |name| return if (name_opt) |name|
@ -499,12 +499,12 @@ pub inline fn getGamepadName(self: Joystick) error{ InvalidEnum }!?[:0]const u8
/// @thread_safety This function must only be called from the main thread. /// @thread_safety This function must only be called from the main thread.
/// ///
/// see also: gamepad, glfw.UpdateGamepadMappings, glfw.Joystick.isGamepad /// see also: gamepad, glfw.UpdateGamepadMappings, glfw.Joystick.isGamepad
pub inline fn getGamepadState(self: Joystick) error{ InvalidEnum }!?GamepadState { pub inline fn getGamepadState(self: Joystick) Error!?GamepadState {
internal_debug.assertInitialized(); internal_debug.assertInitialized();
var state: GamepadState = undefined; var state: GamepadState = undefined;
const success = c.glfwGetGamepadState(self.jid, @ptrCast(*c.GLFWgamepadstate, &state)); const success = c.glfwGetGamepadState(self.jid, @ptrCast(*c.GLFWgamepadstate, &state));
getError() catch |err| return switch (err) { getError() catch |err| return switch (err) {
Error.InvalidEnum => @errSetCast(error{ InvalidEnum }, err), Error.InvalidEnum => err,
else => unreachable, else => unreachable,
}; };
return if (success == c.GLFW_TRUE) state else null; return if (success == c.GLFW_TRUE) state else null;

44
glfw/src/Monitor.zig
View file

@ -32,13 +32,13 @@ const Pos = struct {
/// @thread_safety This function must only be called from the main thread. /// @thread_safety This function must only be called from the main thread.
/// ///
/// see also: monitor_properties /// see also: monitor_properties
pub inline fn getPos(self: Monitor) error{ PlatformError }!Pos { pub inline fn getPos(self: Monitor) Error!Pos {
internal_debug.assertInitialized(); internal_debug.assertInitialized();
var xpos: c_int = 0; var xpos: c_int = 0;
var ypos: c_int = 0; var ypos: c_int = 0;
c.glfwGetMonitorPos(self.handle, &xpos, &ypos); c.glfwGetMonitorPos(self.handle, &xpos, &ypos);
getError() catch |err| return switch (err) { getError() catch |err| return switch (err) {
Error.PlatformError => @errSetCast(error{ PlatformError }, err), Error.PlatformError => err,
else => unreachable, else => unreachable,
}; };
return Pos{ .x = @intCast(usize, xpos), .y = @intCast(usize, ypos) }; return Pos{ .x = @intCast(usize, xpos), .y = @intCast(usize, ypos) };
@ -64,7 +64,7 @@ const Workarea = struct {
/// @thread_safety This function must only be called from the main thread. /// @thread_safety This function must only be called from the main thread.
/// ///
/// see also: monitor_workarea /// see also: monitor_workarea
pub inline fn getWorkarea(self: Monitor) error{ PlatformError }!Workarea { pub inline fn getWorkarea(self: Monitor) Error!Workarea {
internal_debug.assertInitialized(); internal_debug.assertInitialized();
var xpos: c_int = 0; var xpos: c_int = 0;
var ypos: c_int = 0; var ypos: c_int = 0;
@ -72,7 +72,7 @@ pub inline fn getWorkarea(self: Monitor) error{ PlatformError }!Workarea {
var height: c_int = 0; var height: c_int = 0;
c.glfwGetMonitorWorkarea(self.handle, &xpos, &ypos, &width, &height); c.glfwGetMonitorWorkarea(self.handle, &xpos, &ypos, &width, &height);
getError() catch |err| return switch (err) { getError() catch |err| return switch (err) {
Error.PlatformError => @errSetCast(error{ PlatformError }, err), Error.PlatformError => err,
else => unreachable, else => unreachable,
}; };
return Workarea{ .x = @intCast(usize, xpos), .y = @intCast(usize, ypos), .width = @intCast(usize, width), .height = @intCast(usize, height) }; return Workarea{ .x = @intCast(usize, xpos), .y = @intCast(usize, ypos), .width = @intCast(usize, width), .height = @intCast(usize, height) };
@ -99,7 +99,7 @@ const PhysicalSize = struct {
/// ///
/// see also: monitor_properties /// see also: monitor_properties
// TODO: Remove error stub // TODO: Remove error stub
pub inline fn getPhysicalSize(self: Monitor) error{}!PhysicalSize { pub inline fn getPhysicalSize(self: Monitor) Error!PhysicalSize {
internal_debug.assertInitialized(); internal_debug.assertInitialized();
var width_mm: c_int = 0; var width_mm: c_int = 0;
var height_mm: c_int = 0; var height_mm: c_int = 0;
@ -131,13 +131,13 @@ const ContentScale = struct {
/// @thread_safety This function must only be called from the main thread. /// @thread_safety This function must only be called from the main thread.
/// ///
/// see also: monitor_scale, glfw.Window.getContentScale /// see also: monitor_scale, glfw.Window.getContentScale
pub inline fn getContentScale(self: Monitor) error{ PlatformError }!ContentScale { pub inline fn getContentScale(self: Monitor) Error!ContentScale {
internal_debug.assertInitialized(); internal_debug.assertInitialized();
var x_scale: f32 = 0; var x_scale: f32 = 0;
var y_scale: f32 = 0; var y_scale: f32 = 0;
c.glfwGetMonitorContentScale(self.handle, &x_scale, &y_scale); c.glfwGetMonitorContentScale(self.handle, &x_scale, &y_scale);
getError() catch |err| return switch (err) { getError() catch |err| return switch (err) {
Error.PlatformError => @errSetCast(error{ PlatformError }, err), Error.PlatformError => err,
else => unreachable, else => unreachable,
}; };
return ContentScale{ .x_scale = @floatCast(f32, x_scale), .y_scale = @floatCast(f32, y_scale) }; return ContentScale{ .x_scale = @floatCast(f32, x_scale), .y_scale = @floatCast(f32, y_scale) };
@ -158,7 +158,7 @@ pub inline fn getContentScale(self: Monitor) error{ PlatformError }!ContentScale
/// ///
/// see also: monitor_properties /// see also: monitor_properties
// TODO: Remove error stub // TODO: Remove error stub
pub inline fn getName(self: Monitor) error{}![*:0]const u8 { pub inline fn getName(self: Monitor) Error![*:0]const u8 {
internal_debug.assertInitialized(); internal_debug.assertInitialized();
const name = c.glfwGetMonitorName(self.handle); const name = c.glfwGetMonitorName(self.handle);
getError() catch unreachable; getError() catch unreachable;
@ -179,7 +179,7 @@ pub inline fn getName(self: Monitor) error{}![*:0]const u8 {
/// ///
/// see also: monitor_userptr, glfw.Monitor.getUserPointer /// see also: monitor_userptr, glfw.Monitor.getUserPointer
// TODO: Remove error stub // TODO: Remove error stub
pub inline fn setUserPointer(self: Monitor, comptime T: type, ptr: *T) error{}!void { pub inline fn setUserPointer(self: Monitor, comptime T: type, ptr: *T) Error!void {
internal_debug.assertInitialized(); internal_debug.assertInitialized();
c.glfwSetMonitorUserPointer(self.handle, ptr); c.glfwSetMonitorUserPointer(self.handle, ptr);
getError() catch unreachable; getError() catch unreachable;
@ -198,7 +198,7 @@ pub inline fn setUserPointer(self: Monitor, comptime T: type, ptr: *T) error{}!v
/// ///
/// see also: monitor_userptr, glfw.Monitor.setUserPointer /// see also: monitor_userptr, glfw.Monitor.setUserPointer
// TODO: Remove error stub // TODO: Remove error stub
pub inline fn getUserPointer(self: Monitor, comptime T: type) error{}!?*T { pub inline fn getUserPointer(self: Monitor, comptime T: type) Error!?*T {
internal_debug.assertInitialized(); internal_debug.assertInitialized();
const ptr = c.glfwGetMonitorUserPointer(self.handle); const ptr = c.glfwGetMonitorUserPointer(self.handle);
getError() catch unreachable; getError() catch unreachable;
@ -219,12 +219,12 @@ pub inline fn getUserPointer(self: Monitor, comptime T: type) error{}!?*T {
/// @thread_safety This function must only be called from the main thread. /// @thread_safety This function must only be called from the main thread.
/// ///
/// see also: monitor_modes, glfw.Monitor.getVideoMode /// see also: monitor_modes, glfw.Monitor.getVideoMode
pub inline fn getVideoModes(self: Monitor, allocator: *mem.Allocator) (mem.Allocator.Error || error{ PlatformError })![]VideoMode { pub inline fn getVideoModes(self: Monitor, allocator: *mem.Allocator) Error![]VideoMode {
internal_debug.assertInitialized(); internal_debug.assertInitialized();
var count: c_int = 0; var count: c_int = 0;
const modes = c.glfwGetVideoModes(self.handle, &count); const modes = c.glfwGetVideoModes(self.handle, &count);
getError() catch |err| return switch (err) { getError() catch |err| return switch (err) {
Error.PlatformError => @errSetCast(error{ PlatformError }, err), Error.PlatformError => err,
else => unreachable, else => unreachable,
}; };
@ -247,11 +247,11 @@ pub inline fn getVideoModes(self: Monitor, allocator: *mem.Allocator) (mem.Alloc
/// @thread_safety This function must only be called from the main thread. /// @thread_safety This function must only be called from the main thread.
/// ///
/// see also: monitor_modes, glfw.Monitor.getVideoModes /// see also: monitor_modes, glfw.Monitor.getVideoModes
pub inline fn getVideoMode(self: Monitor) error{ PlatformError }!VideoMode { pub inline fn getVideoMode(self: Monitor) Error!VideoMode {
internal_debug.assertInitialized(); internal_debug.assertInitialized();
const mode = c.glfwGetVideoMode(self.handle); const mode = c.glfwGetVideoMode(self.handle);
getError() catch |err| return switch (err) { getError() catch |err| return switch (err) {
Error.PlatformError => @errSetCast(error{ PlatformError }, err), Error.PlatformError => err,
else => unreachable, else => unreachable,
}; };
return VideoMode{ .handle = mode.?.* }; return VideoMode{ .handle = mode.?.* };
@ -276,14 +276,14 @@ pub inline fn getVideoMode(self: Monitor) error{ PlatformError }!VideoMode {
/// @thread_safety This function must only be called from the main thread. /// @thread_safety This function must only be called from the main thread.
/// ///
/// see also: monitor_gamma /// see also: monitor_gamma
pub inline fn setGamma(self: Monitor, gamma: f32) error{ InvalidValue, PlatformError }!void { pub inline fn setGamma(self: Monitor, gamma: f32) Error!void {
internal_debug.assertInitialized(); internal_debug.assertInitialized();
c.glfwSetGamma(self.handle, gamma); c.glfwSetGamma(self.handle, gamma);
getError() catch |err| return switch (err) { getError() catch |err| return switch (err) {
// TODO: Consider whether to assert that 'gamma' is a valid value instead of leaving it to GLFW's error handling. // TODO: Consider whether to assert that 'gamma' is a valid value instead of leaving it to GLFW's error handling.
Error.InvalidValue, Error.InvalidValue,
Error.PlatformError, Error.PlatformError,
=> @errSetCast(error{ InvalidValue, PlatformError }, err), => err,
else => unreachable, else => unreachable,
}; };
} }
@ -303,11 +303,11 @@ pub inline fn setGamma(self: Monitor, gamma: f32) error{ InvalidValue, PlatformE
/// @thread_safety This function must only be called from the main thread. /// @thread_safety This function must only be called from the main thread.
/// ///
/// see also: monitor_gamma /// see also: monitor_gamma
pub inline fn getGammaRamp(self: Monitor) error{ PlatformError }!GammaRamp { pub inline fn getGammaRamp(self: Monitor) Error!GammaRamp {
internal_debug.assertInitialized(); internal_debug.assertInitialized();
const ramp = c.glfwGetGammaRamp(self.handle); const ramp = c.glfwGetGammaRamp(self.handle);
getError() catch |err| return switch (err) { getError() catch |err| return switch (err) {
Error.PlatformError => @errSetCast(error{ PlatformError }, err), Error.PlatformError => err,
else => unreachable, else => unreachable,
}; };
return GammaRamp.fromC(ramp.*); return GammaRamp.fromC(ramp.*);
@ -338,11 +338,11 @@ pub inline fn getGammaRamp(self: Monitor) error{ PlatformError }!GammaRamp {
/// @thread_safety This function must only be called from the main thread. /// @thread_safety This function must only be called from the main thread.
/// ///
/// see also: monitor_gamma /// see also: monitor_gamma
pub inline fn setGammaRamp(self: Monitor, ramp: GammaRamp) error{ PlatformError }!void { pub inline fn setGammaRamp(self: Monitor, ramp: GammaRamp) Error!void {
internal_debug.assertInitialized(); internal_debug.assertInitialized();
c.glfwSetGammaRamp(self.handle, &ramp.toC()); c.glfwSetGammaRamp(self.handle, &ramp.toC());
getError() catch |err| return switch (err) { getError() catch |err| return switch (err) {
Error.PlatformError => @errSetCast(error{ PlatformError }, err), Error.PlatformError => err,
else => unreachable, else => unreachable,
}; };
} }
@ -383,7 +383,7 @@ pub inline fn getAll(allocator: *mem.Allocator) (mem.Allocator.Error)![]Monitor
/// ///
/// see also: monitor_monitors, glfw.monitors.getAll /// see also: monitor_monitors, glfw.monitors.getAll
// TODO: Remove error stub // TODO: Remove error stub
pub inline fn getPrimary() error{}!?Monitor { pub inline fn getPrimary() Error!?Monitor {
internal_debug.assertInitialized(); internal_debug.assertInitialized();
const handle = c.glfwGetPrimaryMonitor(); const handle = c.glfwGetPrimaryMonitor();
getError() catch unreachable; getError() catch unreachable;
@ -427,7 +427,7 @@ pub const Event = enum(c_int) {
/// ///
/// see also: monitor_event /// see also: monitor_event
// TODO: Remove error stub // TODO: Remove error stub
pub inline fn setCallback(comptime Data: type, data: *Data, f: ?*const fn (monitor: Monitor, event: Event, data: *Data) void) error{}!void { pub inline fn setCallback(comptime Data: type, data: *Data, f: ?*const fn (monitor: Monitor, event: Event, data: *Data) void) Error!void {
internal_debug.assertInitialized(); internal_debug.assertInitialized();
if (f) |new_callback| { if (f) |new_callback| {
callback_fn_ptr = @ptrToInt(new_callback); callback_fn_ptr = @ptrToInt(new_callback);

136
glfw/src/Window.zig
View file

@ -73,7 +73,7 @@ pub const InternalUserPointer = struct {
/// ///
/// see also: window_hints, glfw.Window.hint, glfw.Window.hintString /// see also: window_hints, glfw.Window.hint, glfw.Window.hintString
// TODO: Remove error stub // TODO: Remove error stub
inline fn defaultHints() error{}!void { inline fn defaultHints() Error!void {
internal_debug.assertInitialized(); internal_debug.assertInitialized();
c.glfwDefaultWindowHints(); c.glfwDefaultWindowHints();
getError() catch unreachable; // Only error 'GLFW_NOT_INITIALIZED' is impossible getError() catch unreachable; // Only error 'GLFW_NOT_INITIALIZED' is impossible
@ -259,7 +259,7 @@ pub const Hints = struct {
}; };
// TODO: Remove error stub // TODO: Remove error stub
fn set(hints: Hints) error{}!void { fn set(hints: Hints) Error!void {
internal_debug.assertInitialized(); internal_debug.assertInitialized();
inline for (comptime std.meta.fieldNames(Hint)) |field_name| { inline for (comptime std.meta.fieldNames(Hint)) |field_name| {
const hint_tag = @enumToInt(@field(Hint, field_name)); const hint_tag = @enumToInt(@field(Hint, field_name));
@ -483,7 +483,7 @@ pub inline fn shouldClose(self: Window) bool {
/// ///
/// see also: window_close /// see also: window_close
// TODO: Remove error stub // TODO: Remove error stub
pub inline fn setShouldClose(self: Window, value: bool) error{}!void { pub inline fn setShouldClose(self: Window, value: bool) Error!void {
internal_debug.assertInitialized(); internal_debug.assertInitialized();
const boolean = if (value) c.GLFW_TRUE else c.GLFW_FALSE; const boolean = if (value) c.GLFW_TRUE else c.GLFW_FALSE;
c.glfwSetWindowShouldClose(self.handle, boolean); c.glfwSetWindowShouldClose(self.handle, boolean);
@ -501,11 +501,11 @@ pub inline fn setShouldClose(self: Window, value: bool) error{}!void {
/// @thread_safety This function must only be called from the main thread. /// @thread_safety This function must only be called from the main thread.
/// ///
/// see also: window_title /// see also: window_title
pub inline fn setTitle(self: Window, title: [*:0]const u8) error{ PlatformError }!void { pub inline fn setTitle(self: Window, title: [*:0]const u8) Error!void {
internal_debug.assertInitialized(); internal_debug.assertInitialized();
c.glfwSetWindowTitle(self.handle, title); c.glfwSetWindowTitle(self.handle, title);
getError() catch |err| return switch (err) { getError() catch |err| return switch (err) {
Error.PlatformError => @errSetCast(error{ PlatformError }, err), Error.PlatformError => err,
else => unreachable, else => unreachable,
}; };
} }
@ -538,7 +538,7 @@ pub inline fn setTitle(self: Window, title: [*:0]const u8) error{ PlatformError
/// @thread_safety This function must only be called from the main thread. /// @thread_safety This function must only be called from the main thread.
/// ///
/// see also: window_icon /// see also: window_icon
pub inline fn setIcon(self: Window, allocator: *mem.Allocator, images: ?[]Image) (mem.Allocator.Error || error{ PlatformError })!void { pub inline fn setIcon(self: Window, allocator: *mem.Allocator, images: ?[]Image) Error!void {
internal_debug.assertInitialized(); internal_debug.assertInitialized();
if (images) |im| { if (images) |im| {
const tmp = try allocator.alloc(c.GLFWimage, im.len); const tmp = try allocator.alloc(c.GLFWimage, im.len);
@ -547,7 +547,7 @@ pub inline fn setIcon(self: Window, allocator: *mem.Allocator, images: ?[]Image)
c.glfwSetWindowIcon(self.handle, @intCast(c_int, im.len), &tmp[0]); c.glfwSetWindowIcon(self.handle, @intCast(c_int, im.len), &tmp[0]);
} else c.glfwSetWindowIcon(self.handle, 0, null); } else c.glfwSetWindowIcon(self.handle, 0, null);
getError() catch |err| return switch (err) { getError() catch |err| return switch (err) {
Error.PlatformError => @errSetCast(error{ PlatformError }, err), Error.PlatformError => err,
else => unreachable, else => unreachable,
}; };
} }
@ -570,13 +570,13 @@ pub const Pos = struct {
/// @thread_safety This function must only be called from the main thread. /// @thread_safety This function must only be called from the main thread.
/// ///
/// see also: window_pos glfw.Window.setPos /// see also: window_pos glfw.Window.setPos
pub inline fn getPos(self: Window) error{ PlatformError }!Pos { pub inline fn getPos(self: Window) Error!Pos {
internal_debug.assertInitialized(); internal_debug.assertInitialized();
var x: c_int = 0; var x: c_int = 0;
var y: c_int = 0; var y: c_int = 0;
c.glfwGetWindowPos(self.handle, &x, &y); c.glfwGetWindowPos(self.handle, &x, &y);
getError() catch |err| return switch (err) { getError() catch |err| return switch (err) {
Error.PlatformError => @errSetCast(error{ PlatformError }, err), Error.PlatformError => err,
else => unreachable, else => unreachable,
}; };
return Pos{ .x = @intCast(usize, x), .y = @intCast(usize, y) }; return Pos{ .x = @intCast(usize, x), .y = @intCast(usize, y) };
@ -602,11 +602,11 @@ pub inline fn getPos(self: Window) error{ PlatformError }!Pos {
/// @thread_safety This function must only be called from the main thread. /// @thread_safety This function must only be called from the main thread.
/// ///
/// see also: window_pos, glfw.Window.getPos /// see also: window_pos, glfw.Window.getPos
pub inline fn setPos(self: Window, pos: Pos) error{ PlatformError }!void { pub inline fn setPos(self: Window, pos: Pos) Error!void {
internal_debug.assertInitialized(); internal_debug.assertInitialized();
c.glfwSetWindowPos(self.handle, @intCast(c_int, pos.x), @intCast(c_int, pos.y)); c.glfwSetWindowPos(self.handle, @intCast(c_int, pos.x), @intCast(c_int, pos.y));
getError() catch |err| return switch (err) { getError() catch |err| return switch (err) {
Error.PlatformError => @errSetCast(error{ PlatformError }, err), Error.PlatformError => err,
else => unreachable, else => unreachable,
}; };
} }
@ -627,13 +627,13 @@ pub const Size = struct {
/// @thread_safety This function must only be called from the main thread. /// @thread_safety This function must only be called from the main thread.
/// ///
/// see also: window_size, glfw.Window.setSize /// see also: window_size, glfw.Window.setSize
pub inline fn getSize(self: Window) error{ PlatformError }!Size { pub inline fn getSize(self: Window) Error!Size {
internal_debug.assertInitialized(); internal_debug.assertInitialized();
var width: c_int = 0; var width: c_int = 0;
var height: c_int = 0; var height: c_int = 0;
c.glfwGetWindowSize(self.handle, &width, &height); c.glfwGetWindowSize(self.handle, &width, &height);
getError() catch |err| return switch (err) { getError() catch |err| return switch (err) {
Error.PlatformError => @errSetCast(error{ PlatformError }, err), Error.PlatformError => err,
else => unreachable, else => unreachable,
}; };
return Size{ .width = @intCast(usize, width), .height = @intCast(usize, height) }; return Size{ .width = @intCast(usize, width), .height = @intCast(usize, height) };
@ -661,11 +661,11 @@ pub inline fn getSize(self: Window) error{ PlatformError }!Size {
/// @thread_safety This function must only be called from the main thread. /// @thread_safety This function must only be called from the main thread.
/// ///
/// see also: window_size, glfw.Window.getSize, glfw.Window.SetMonitor /// see also: window_size, glfw.Window.getSize, glfw.Window.SetMonitor
pub inline fn setSize(self: Window, size: Size) error{ PlatformError }!void { pub inline fn setSize(self: Window, size: Size) Error!void {
internal_debug.assertInitialized(); internal_debug.assertInitialized();
c.glfwSetWindowSize(self.handle, @intCast(c_int, size.width), @intCast(c_int, size.height)); c.glfwSetWindowSize(self.handle, @intCast(c_int, size.width), @intCast(c_int, size.height));
getError() catch |err| return switch (err) { getError() catch |err| return switch (err) {
Error.PlatformError => @errSetCast(error{ PlatformError }, err), Error.PlatformError => err,
else => unreachable, else => unreachable,
}; };
} }
@ -691,7 +691,7 @@ pub inline fn setSize(self: Window, size: Size) error{ PlatformError }!void {
/// @thread_safety This function must only be called from the main thread. /// @thread_safety This function must only be called from the main thread.
/// ///
/// see also: window_sizelimits, glfw.Window.setAspectRatio /// see also: window_sizelimits, glfw.Window.setAspectRatio
pub inline fn setSizeLimits(self: Window, min: Size, max: Size) error{ InvalidValue, PlatformError }!void { pub inline fn setSizeLimits(self: Window, min: Size, max: Size) Error!void {
internal_debug.assertInitialized(); internal_debug.assertInitialized();
c.glfwSetWindowSizeLimits( c.glfwSetWindowSizeLimits(
self.handle, self.handle,
@ -703,7 +703,7 @@ pub inline fn setSizeLimits(self: Window, min: Size, max: Size) error{ InvalidVa
getError() catch |err| return switch (err) { getError() catch |err| return switch (err) {
Error.InvalidValue, Error.InvalidValue,
Error.PlatformError, Error.PlatformError,
=> @errSetCast(error{ InvalidValue, PlatformError }, err), => err,
else => unreachable, else => unreachable,
}; };
} }
@ -734,13 +734,13 @@ pub inline fn setSizeLimits(self: Window, min: Size, max: Size) error{ InvalidVa
/// @thread_safety This function must only be called from the main thread. /// @thread_safety This function must only be called from the main thread.
/// ///
/// see also: window_sizelimits, glfw.Window.setSizeLimits /// see also: window_sizelimits, glfw.Window.setSizeLimits
pub inline fn setAspectRatio(self: Window, numerator: usize, denominator: usize) error{ InvalidValue, PlatformError }!void { pub inline fn setAspectRatio(self: Window, numerator: usize, denominator: usize) Error!void {
internal_debug.assertInitialized(); internal_debug.assertInitialized();
c.glfwSetWindowAspectRatio(self.handle, @intCast(c_int, numerator), @intCast(c_int, denominator)); c.glfwSetWindowAspectRatio(self.handle, @intCast(c_int, numerator), @intCast(c_int, denominator));
getError() catch |err| return switch (err) { getError() catch |err| return switch (err) {
Error.InvalidValue, Error.InvalidValue,
Error.PlatformError, Error.PlatformError,
=> @errSetCast(error{ InvalidValue, PlatformError }, err), => err,
else => unreachable, else => unreachable,
}; };
} }
@ -755,13 +755,13 @@ pub inline fn setAspectRatio(self: Window, numerator: usize, denominator: usize)
/// @thread_safety This function must only be called from the main thread. /// @thread_safety This function must only be called from the main thread.
/// ///
/// see also: window_fbsize, glfwWindow.setFramebufferSizeCallback /// see also: window_fbsize, glfwWindow.setFramebufferSizeCallback
pub inline fn getFramebufferSize(self: Window) error{ PlatformError }!Size { pub inline fn getFramebufferSize(self: Window) Error!Size {
internal_debug.assertInitialized(); internal_debug.assertInitialized();
var width: c_int = 0; var width: c_int = 0;
var height: c_int = 0; var height: c_int = 0;
c.glfwGetFramebufferSize(self.handle, &width, &height); c.glfwGetFramebufferSize(self.handle, &width, &height);
getError() catch |err| return switch (err) { getError() catch |err| return switch (err) {
Error.PlatformError => @errSetCast(error{ PlatformError }, err), Error.PlatformError => err,
else => unreachable, else => unreachable,
}; };
return Size{ .width = @intCast(usize, width), .height = @intCast(usize, height) }; return Size{ .width = @intCast(usize, width), .height = @intCast(usize, height) };
@ -788,7 +788,7 @@ pub const FrameSize = struct {
/// @thread_safety This function must only be called from the main thread. /// @thread_safety This function must only be called from the main thread.
/// ///
/// see also: window_size /// see also: window_size
pub inline fn getFrameSize(self: Window) error{ PlatformError }!FrameSize { pub inline fn getFrameSize(self: Window) Error!FrameSize {
internal_debug.assertInitialized(); internal_debug.assertInitialized();
var left: c_int = 0; var left: c_int = 0;
var top: c_int = 0; var top: c_int = 0;
@ -796,7 +796,7 @@ pub inline fn getFrameSize(self: Window) error{ PlatformError }!FrameSize {
var bottom: c_int = 0; var bottom: c_int = 0;
c.glfwGetWindowFrameSize(self.handle, &left, &top, &right, &bottom); c.glfwGetWindowFrameSize(self.handle, &left, &top, &right, &bottom);
getError() catch |err| return switch (err) { getError() catch |err| return switch (err) {
Error.PlatformError => @errSetCast(error{ PlatformError }, err), Error.PlatformError => err,
else => unreachable, else => unreachable,
}; };
return FrameSize{ return FrameSize{
@ -829,13 +829,13 @@ pub const ContentScale = struct {
/// @thread_safety This function must only be called from the main thread. /// @thread_safety This function must only be called from the main thread.
/// ///
/// see also: window_scale, glfwSetWindowContentScaleCallback, glfwGetMonitorContentScale /// see also: window_scale, glfwSetWindowContentScaleCallback, glfwGetMonitorContentScale
pub inline fn getContentScale(self: Window) error{ PlatformError }!ContentScale { pub inline fn getContentScale(self: Window) Error!ContentScale {
internal_debug.assertInitialized(); internal_debug.assertInitialized();
var x_scale: f32 = 0; var x_scale: f32 = 0;
var y_scale: f32 = 0; var y_scale: f32 = 0;
c.glfwGetWindowContentScale(self.handle, &x_scale, &y_scale); c.glfwGetWindowContentScale(self.handle, &x_scale, &y_scale);
getError() catch |err| return switch (err) { getError() catch |err| return switch (err) {
Error.PlatformError => @errSetCast(error{ PlatformError }, err), Error.PlatformError => err,
else => unreachable, else => unreachable,
}; };
return ContentScale{ .x_scale = x_scale, .y_scale = y_scale }; return ContentScale{ .x_scale = x_scale, .y_scale = y_scale };
@ -856,11 +856,11 @@ pub inline fn getContentScale(self: Window) error{ PlatformError }!ContentScale
/// @thread_safety This function must only be called from the main thread. /// @thread_safety This function must only be called from the main thread.
/// ///
/// see also: window_transparency, glfw.Window.setOpacity /// see also: window_transparency, glfw.Window.setOpacity
pub inline fn getOpacity(self: Window) error{ PlatformError }!f32 { pub inline fn getOpacity(self: Window) Error!f32 {
internal_debug.assertInitialized(); internal_debug.assertInitialized();
const opacity = c.glfwGetWindowOpacity(self.handle); const opacity = c.glfwGetWindowOpacity(self.handle);
getError() catch |err| return switch (err) { getError() catch |err| return switch (err) {
Error.PlatformError => @errSetCast(error{ PlatformError }, err), Error.PlatformError => err,
else => unreachable, else => unreachable,
}; };
return opacity; return opacity;
@ -883,11 +883,11 @@ pub inline fn getOpacity(self: Window) error{ PlatformError }!f32 {
/// @thread_safety This function must only be called from the main thread. /// @thread_safety This function must only be called from the main thread.
/// ///
/// see also: window_transparency, glfw.Window.getOpacity /// see also: window_transparency, glfw.Window.getOpacity
pub inline fn setOpacity(self: Window, opacity: f32) error{ PlatformError }!void { pub inline fn setOpacity(self: Window, opacity: f32) Error!void {
internal_debug.assertInitialized(); internal_debug.assertInitialized();
c.glfwSetWindowOpacity(self.handle, opacity); c.glfwSetWindowOpacity(self.handle, opacity);
getError() catch |err| return switch (err) { getError() catch |err| return switch (err) {
Error.PlatformError => @errSetCast(error{ PlatformError }, err), Error.PlatformError => err,
else => unreachable, else => unreachable,
}; };
} }
@ -908,11 +908,11 @@ pub inline fn setOpacity(self: Window, opacity: f32) error{ PlatformError }!void
/// @thread_safety This function must only be called from the main thread. /// @thread_safety This function must only be called from the main thread.
/// ///
/// see also: window_iconify, glfw.Window.restore, glfw.Window.maximize /// see also: window_iconify, glfw.Window.restore, glfw.Window.maximize
pub inline fn iconify(self: Window) error{ PlatformError }!void { pub inline fn iconify(self: Window) Error!void {
internal_debug.assertInitialized(); internal_debug.assertInitialized();
c.glfwIconifyWindow(self.handle); c.glfwIconifyWindow(self.handle);
getError() catch |err| return switch (err) { getError() catch |err| return switch (err) {
Error.PlatformError => @errSetCast(error{ PlatformError }, err), Error.PlatformError => err,
else => unreachable, else => unreachable,
}; };
} }
@ -930,11 +930,11 @@ pub inline fn iconify(self: Window) error{ PlatformError }!void {
/// @thread_safety This function must only be called from the main thread. /// @thread_safety This function must only be called from the main thread.
/// ///
/// see also: window_iconify, glfw.Window.iconify, glfw.Window.maximize /// see also: window_iconify, glfw.Window.iconify, glfw.Window.maximize
pub inline fn restore(self: Window) error{ PlatformError }!void { pub inline fn restore(self: Window) Error!void {
internal_debug.assertInitialized(); internal_debug.assertInitialized();
c.glfwRestoreWindow(self.handle); c.glfwRestoreWindow(self.handle);
getError() catch |err| return switch (err) { getError() catch |err| return switch (err) {
Error.PlatformError => @errSetCast(error{ PlatformError }, err), Error.PlatformError => err,
else => unreachable, else => unreachable,
}; };
} }
@ -951,11 +951,11 @@ pub inline fn restore(self: Window) error{ PlatformError }!void {
/// @thread_safety This function must only be called from the main thread. /// @thread_safety This function must only be called from the main thread.
/// ///
/// see also: window_iconify, glfw.Window.iconify, glfw.Window.restore /// see also: window_iconify, glfw.Window.iconify, glfw.Window.restore
pub inline fn maximize(self: Window) error{ PlatformError }!void { pub inline fn maximize(self: Window) Error!void {
internal_debug.assertInitialized(); internal_debug.assertInitialized();
c.glfwMaximizeWindow(self.handle); c.glfwMaximizeWindow(self.handle);
getError() catch |err| return switch (err) { getError() catch |err| return switch (err) {
Error.PlatformError => @errSetCast(error{ PlatformError }, err), Error.PlatformError => err,
else => unreachable, else => unreachable,
}; };
} }
@ -974,11 +974,11 @@ pub inline fn maximize(self: Window) error{ PlatformError }!void {
/// @thread_safety This function must only be called from the main thread. /// @thread_safety This function must only be called from the main thread.
/// ///
/// see also: window_hide, glfw.Window.hide /// see also: window_hide, glfw.Window.hide
pub inline fn show(self: Window) error{ PlatformError }!void { pub inline fn show(self: Window) Error!void {
internal_debug.assertInitialized(); internal_debug.assertInitialized();
c.glfwShowWindow(self.handle); c.glfwShowWindow(self.handle);
getError() catch |err| return switch (err) { getError() catch |err| return switch (err) {
Error.PlatformError => @errSetCast(error{ PlatformError }, err), Error.PlatformError => err,
else => unreachable, else => unreachable,
}; };
} }
@ -993,11 +993,11 @@ pub inline fn show(self: Window) error{ PlatformError }!void {
/// @thread_safety This function must only be called from the main thread. /// @thread_safety This function must only be called from the main thread.
/// ///
/// see also: window_hide, glfw.Window.show /// see also: window_hide, glfw.Window.show
pub inline fn hide(self: Window) error{ PlatformError }!void { pub inline fn hide(self: Window) Error!void {
internal_debug.assertInitialized(); internal_debug.assertInitialized();
c.glfwHideWindow(self.handle); c.glfwHideWindow(self.handle);
getError() catch |err| return switch (err) { getError() catch |err| return switch (err) {
Error.PlatformError => @errSetCast(error{ PlatformError }, err), Error.PlatformError => err,
else => unreachable, else => unreachable,
}; };
} }
@ -1026,11 +1026,11 @@ pub inline fn hide(self: Window) error{ PlatformError }!void {
/// @thread_safety This function must only be called from the main thread. /// @thread_safety This function must only be called from the main thread.
/// ///
/// see also: window_focus, window_attention /// see also: window_focus, window_attention
pub inline fn focus(self: Window) error{ PlatformError }!void { pub inline fn focus(self: Window) Error!void {
internal_debug.assertInitialized(); internal_debug.assertInitialized();
c.glfwFocusWindow(self.handle); c.glfwFocusWindow(self.handle);
getError() catch |err| return switch (err) { getError() catch |err| return switch (err) {
Error.PlatformError => @errSetCast(error{ PlatformError }, err), Error.PlatformError => err,
else => unreachable, else => unreachable,
}; };
} }
@ -1050,11 +1050,11 @@ pub inline fn focus(self: Window) error{ PlatformError }!void {
/// @thread_safety This function must only be called from the main thread. /// @thread_safety This function must only be called from the main thread.
/// ///
/// see also: window_attention /// see also: window_attention
pub inline fn requestAttention(self: Window) error{ PlatformError }!void { pub inline fn requestAttention(self: Window) Error!void {
internal_debug.assertInitialized(); internal_debug.assertInitialized();
c.glfwRequestWindowAttention(self.handle); c.glfwRequestWindowAttention(self.handle);
getError() catch |err| return switch (err) { getError() catch |err| return switch (err) {
Error.PlatformError => @errSetCast(error{ PlatformError }, err), Error.PlatformError => err,
else => unreachable, else => unreachable,
}; };
} }
@ -1080,13 +1080,13 @@ pub inline fn requestAttention(self: Window) error{ PlatformError }!void {
/// @thread_safety This function may be called from any thread. /// @thread_safety This function may be called from any thread.
/// ///
/// see also: buffer_swap, glfwSwapInterval /// see also: buffer_swap, glfwSwapInterval
pub inline fn swapBuffers(self: Window) error{ NoWindowContext, PlatformError }!void { pub inline fn swapBuffers(self: Window) Error!void {
internal_debug.assertInitialized(); internal_debug.assertInitialized();
c.glfwSwapBuffers(self.handle); c.glfwSwapBuffers(self.handle);
getError() catch |err| return switch (err) { getError() catch |err| return switch (err) {
Error.NoWindowContext, Error.NoWindowContext,
Error.PlatformError, Error.PlatformError,
=> @errSetCast(error{ NoWindowContext, PlatformError }, err), => err,
else => unreachable, else => unreachable,
}; };
} }
@ -1103,7 +1103,7 @@ pub inline fn swapBuffers(self: Window) error{ NoWindowContext, PlatformError }!
/// ///
/// see also: window_monitor, glfw.Window.setMonitor /// see also: window_monitor, glfw.Window.setMonitor
// TODO: Remove error stub // TODO: Remove error stub
pub inline fn getMonitor(self: Window) error{}!?Monitor { pub inline fn getMonitor(self: Window) Error!?Monitor {
internal_debug.assertInitialized(); internal_debug.assertInitialized();
const monitor = c.glfwGetWindowMonitor(self.handle); const monitor = c.glfwGetWindowMonitor(self.handle);
getError() catch unreachable; // Only error 'GLFW_NOT_INITIALIZED' is impossible getError() catch unreachable; // Only error 'GLFW_NOT_INITIALIZED' is impossible
@ -1153,7 +1153,7 @@ pub inline fn getMonitor(self: Window) error{}!?Monitor {
/// @thread_safety This function must only be called from the main thread. /// @thread_safety This function must only be called from the main thread.
/// ///
/// see also: window_monitor, window_full_screen, glfw.Window.getMonitor, glfw.Window.setSize /// see also: window_monitor, window_full_screen, glfw.Window.getMonitor, glfw.Window.setSize
pub inline fn setMonitor(self: Window, monitor: ?Monitor, xpos: isize, ypos: isize, width: isize, height: isize, refresh_rate: isize) error{ PlatformError }!void { pub inline fn setMonitor(self: Window, monitor: ?Monitor, xpos: isize, ypos: isize, width: isize, height: isize, refresh_rate: isize) Error!void {
internal_debug.assertInitialized(); internal_debug.assertInitialized();
c.glfwSetWindowMonitor( c.glfwSetWindowMonitor(
self.handle, self.handle,
@ -1165,7 +1165,7 @@ pub inline fn setMonitor(self: Window, monitor: ?Monitor, xpos: isize, ypos: isi
@intCast(c_int, refresh_rate), @intCast(c_int, refresh_rate),
); );
getError() catch |err| return switch (err) { getError() catch |err| return switch (err) {
Error.PlatformError => @errSetCast(error{ PlatformError }, err), Error.PlatformError => err,
else => unreachable, else => unreachable,
}; };
} }
@ -1218,13 +1218,13 @@ pub const Attrib = enum(c_int) {
/// @thread_safety This function must only be called from the main thread. /// @thread_safety This function must only be called from the main thread.
/// ///
/// see also: window_attribs, glfw.Window.setAttrib /// see also: window_attribs, glfw.Window.setAttrib
pub inline fn getAttrib(self: Window, attrib: Attrib) error{ InvalidEnum, PlatformError }!isize { pub inline fn getAttrib(self: Window, attrib: Attrib) Error!isize {
internal_debug.assertInitialized(); internal_debug.assertInitialized();
const v = c.glfwGetWindowAttrib(self.handle, @enumToInt(attrib)); const v = c.glfwGetWindowAttrib(self.handle, @enumToInt(attrib));
getError() catch |err| return switch (err) { getError() catch |err| return switch (err) {
Error.InvalidEnum, Error.InvalidEnum,
Error.PlatformError, Error.PlatformError,
=> @errSetCast(error{ InvalidEnum, PlatformError }, err), => err,
else => unreachable, else => unreachable,
}; };
return v; return v;
@ -1255,14 +1255,14 @@ pub inline fn getAttrib(self: Window, attrib: Attrib) error{ InvalidEnum, Platfo
/// see also: window_attribs, glfw.Window.getAttrib /// see also: window_attribs, glfw.Window.getAttrib
/// ///
// TODO: Maybe enhance type-safety here to avoid 'InvalidEnum' and 'InvalidValue' at runtime alltogether? // TODO: Maybe enhance type-safety here to avoid 'InvalidEnum' and 'InvalidValue' at runtime alltogether?
pub inline fn setAttrib(self: Window, attrib: Attrib, value: bool) error{ InvalidEnum, InvalidValue, PlatformError }!void { pub inline fn setAttrib(self: Window, attrib: Attrib, value: bool) Error!void {
internal_debug.assertInitialized(); internal_debug.assertInitialized();
c.glfwSetWindowAttrib(self.handle, @enumToInt(attrib), if (value) c.GLFW_TRUE else c.GLFW_FALSE); c.glfwSetWindowAttrib(self.handle, @enumToInt(attrib), if (value) c.GLFW_TRUE else c.GLFW_FALSE);
getError() catch |err| return switch (err) { getError() catch |err| return switch (err) {
Error.InvalidEnum, Error.InvalidEnum,
Error.InvalidValue, Error.InvalidValue,
Error.PlatformError, Error.PlatformError,
=> @errSetCast(error{ InvalidEnum, InvalidValue, PlatformError }, err), => err,
else => unreachable, else => unreachable,
}; };
} }
@ -1623,7 +1623,7 @@ pub const InputModeCursor = enum(c_int) {
}; };
/// Sets the input mode of the cursor, whether it should behave normally, be hidden, or grabbed. /// Sets the input mode of the cursor, whether it should behave normally, be hidden, or grabbed.
pub inline fn setInputModeCursor(self: Window, value: InputModeCursor) error{ InvalidEnum, PlatformError }!void { pub inline fn setInputModeCursor(self: Window, value: InputModeCursor) Error!void {
return self.setInputMode(InputMode.cursor, value); return self.setInputMode(InputMode.cursor, value);
} }
@ -1637,7 +1637,7 @@ pub inline fn getInputModeCursor(self: Window) InputModeCursor {
/// ///
/// This is useful when you are only interested in whether keys have been pressed but not when or /// This is useful when you are only interested in whether keys have been pressed but not when or
/// in which order. /// in which order.
pub inline fn setInputModeStickyKeys(self: Window, enabled: bool) error{ InvalidEnum, PlatformError }!void { pub inline fn setInputModeStickyKeys(self: Window, enabled: bool) Error!void {
return self.setInputMode(InputMode.sticky_keys, enabled); return self.setInputMode(InputMode.sticky_keys, enabled);
} }
@ -1652,7 +1652,7 @@ pub inline fn getInputModeStickyKeys(self: Window) bool {
/// ///
/// This is useful when you are only interested in whether buttons have been pressed but not when /// This is useful when you are only interested in whether buttons have been pressed but not when
/// or in which order. /// or in which order.
pub inline fn setInputModeStickyMouseButtons(self: Window, enabled: bool) error{ InvalidEnum, PlatformError }!void { pub inline fn setInputModeStickyMouseButtons(self: Window, enabled: bool) Error!void {
return self.setInputMode(InputMode.sticky_mouse_buttons, enabled); return self.setInputMode(InputMode.sticky_mouse_buttons, enabled);
} }
@ -1737,7 +1737,7 @@ pub inline fn getInputMode(self: Window, mode: InputMode) isize {
/// @thread_safety This function must only be called from the main thread. /// @thread_safety This function must only be called from the main thread.
/// ///
/// see also: glfw.Window.getInputMode /// see also: glfw.Window.getInputMode
pub inline fn setInputMode(self: Window, mode: InputMode, value: anytype) error{ InvalidEnum, PlatformError }!void { pub inline fn setInputMode(self: Window, mode: InputMode, value: anytype) Error!void {
internal_debug.assertInitialized(); internal_debug.assertInitialized();
switch (@typeInfo(@TypeOf(value))) { switch (@typeInfo(@TypeOf(value))) {
.Enum => c.glfwSetInputMode(self.handle, @enumToInt(mode), @enumToInt(value)), .Enum => c.glfwSetInputMode(self.handle, @enumToInt(mode), @enumToInt(value)),
@ -1748,7 +1748,7 @@ pub inline fn setInputMode(self: Window, mode: InputMode, value: anytype) error{
getError() catch |err| return switch (err) { getError() catch |err| return switch (err) {
Error.InvalidEnum, Error.InvalidEnum,
Error.PlatformError, Error.PlatformError,
=> @errSetCast(error{ InvalidEnum, PlatformError }, err), => err,
else => unreachable, else => unreachable,
}; };
} }
@ -1779,11 +1779,11 @@ pub inline fn setInputMode(self: Window, mode: InputMode, value: anytype) error{
/// @thread_safety This function must only be called from the main thread. /// @thread_safety This function must only be called from the main thread.
/// ///
/// see also: input_key /// see also: input_key
pub inline fn getKey(self: Window, key: Key) error{ InvalidEnum }!Action { pub inline fn getKey(self: Window, key: Key) Error!Action {
internal_debug.assertInitialized(); internal_debug.assertInitialized();
const state = c.glfwGetKey(self.handle, @enumToInt(key)); const state = c.glfwGetKey(self.handle, @enumToInt(key));
getError() catch |err| return switch (err) { getError() catch |err| return switch (err) {
Error.InvalidEnum => @errSetCast(error{ InvalidEnum }, err), Error.InvalidEnum => err,
else => unreachable, else => unreachable,
}; };
return @intToEnum(Action, state); return @intToEnum(Action, state);
@ -1805,11 +1805,11 @@ pub inline fn getKey(self: Window, key: Key) error{ InvalidEnum }!Action {
/// @thread_safety This function must only be called from the main thread. /// @thread_safety This function must only be called from the main thread.
/// ///
/// see also: input_mouse_button /// see also: input_mouse_button
pub inline fn getMouseButton(self: Window, button: MouseButton) error{ InvalidEnum }!Action { pub inline fn getMouseButton(self: Window, button: MouseButton) Error!Action {
internal_debug.assertInitialized(); internal_debug.assertInitialized();
const state = c.glfwGetMouseButton(self.handle, @enumToInt(button)); const state = c.glfwGetMouseButton(self.handle, @enumToInt(button));
getError() catch |err| return switch (err) { getError() catch |err| return switch (err) {
Error.InvalidEnum => @errSetCast(error{ InvalidEnum }, err), Error.InvalidEnum => err,
else => unreachable, else => unreachable,
}; };
return @intToEnum(Action, state); return @intToEnum(Action, state);
@ -1845,12 +1845,12 @@ pub const CursorPos = struct {
/// @thread_safety This function must only be called from the main thread. /// @thread_safety This function must only be called from the main thread.
/// ///
/// see also: cursor_pos, glfw.Window.setCursorPos /// see also: cursor_pos, glfw.Window.setCursorPos
pub inline fn getCursorPos(self: Window) error{ PlatformError }!CursorPos { pub inline fn getCursorPos(self: Window) Error!CursorPos {
internal_debug.assertInitialized(); internal_debug.assertInitialized();
var pos: CursorPos = undefined; var pos: CursorPos = undefined;
c.glfwGetCursorPos(self.handle, &pos.xpos, &pos.ypos); c.glfwGetCursorPos(self.handle, &pos.xpos, &pos.ypos);
getError() catch |err| return switch (err) { getError() catch |err| return switch (err) {
Error.PlatformError => @errSetCast(error{ PlatformError }, err), Error.PlatformError => err,
else => unreachable, else => unreachable,
}; };
return pos; return pos;
@ -1881,11 +1881,11 @@ pub inline fn getCursorPos(self: Window) error{ PlatformError }!CursorPos {
/// @thread_safety This function must only be called from the main thread. /// @thread_safety This function must only be called from the main thread.
/// ///
/// see also: cursor_pos, glfw.Window.getCursorPos /// see also: cursor_pos, glfw.Window.getCursorPos
pub inline fn setCursorPos(self: Window, xpos: f64, ypos: f64) error{ PlatformError }!void { pub inline fn setCursorPos(self: Window, xpos: f64, ypos: f64) Error!void {
internal_debug.assertInitialized(); internal_debug.assertInitialized();
c.glfwSetCursorPos(self.handle, xpos, ypos); c.glfwSetCursorPos(self.handle, xpos, ypos);
getError() catch |err| return switch (err) { getError() catch |err| return switch (err) {
Error.PlatformError => @errSetCast(error{ PlatformError }, err), Error.PlatformError => err,
else => unreachable, else => unreachable,
}; };
} }
@ -1905,11 +1905,11 @@ pub inline fn setCursorPos(self: Window, xpos: f64, ypos: f64) error{ PlatformEr
/// @thread_safety This function must only be called from the main thread. /// @thread_safety This function must only be called from the main thread.
/// ///
/// see also: cursor_object /// see also: cursor_object
pub inline fn setCursor(self: Window, cursor: Cursor) error{ PlatformError }!void { pub inline fn setCursor(self: Window, cursor: Cursor) Error!void {
internal_debug.assertInitialized(); internal_debug.assertInitialized();
c.glfwSetCursor(self.handle, cursor.ptr); c.glfwSetCursor(self.handle, cursor.ptr);
getError() catch |err| return switch (err) { getError() catch |err| return switch (err) {
Error.PlatformError => @errSetCast(error{ PlatformError }, err), Error.PlatformError => err,
else => unreachable, else => unreachable,
}; };
} }
@ -2159,7 +2159,7 @@ fn setDropCallbackWrapper(handle: ?*c.GLFWwindow, path_count: c_int, paths: [*c]
/// ///
/// see also: path_drop /// see also: path_drop
// TODO: Remove error stub // TODO: Remove error stub
pub inline fn setDropCallback(self: Window, callback: ?fn (window: Window, paths: [][*:0]const u8) void) error{}!void { pub inline fn setDropCallback(self: Window, callback: ?fn (window: Window, paths: [][*:0]const u8) void) Error!void {
internal_debug.assertInitialized(); internal_debug.assertInitialized();
var internal = self.getInternal(); var internal = self.getInternal();
internal.setDropCallback = callback; internal.setDropCallback = callback;

8
glfw/src/clipboard.zig
View file

@ -19,11 +19,11 @@ const internal_debug = @import("internal_debug.zig");
/// @thread_safety This function must only be called from the main thread. /// @thread_safety This function must only be called from the main thread.
/// ///
/// see also: clipboard, glfwGetClipboardString /// see also: clipboard, glfwGetClipboardString
pub inline fn setClipboardString(value: [*:0]const u8) error{ PlatformError }!void { pub inline fn setClipboardString(value: [*:0]const u8) Error!void {
internal_debug.assertInitialized(); internal_debug.assertInitialized();
c.glfwSetClipboardString(null, value); c.glfwSetClipboardString(null, value);
getError() catch |err| return switch (err) { getError() catch |err| return switch (err) {
Error.PlatformError => @errSetCast(error{ PlatformError }, err), Error.PlatformError => err,
else => unreachable, else => unreachable,
}; };
} }
@ -45,11 +45,11 @@ pub inline fn setClipboardString(value: [*:0]const u8) error{ PlatformError }!vo
/// @thread_safety This function must only be called from the main thread. /// @thread_safety This function must only be called from the main thread.
/// ///
/// see also: clipboard, glfwSetClipboardString /// see also: clipboard, glfwSetClipboardString
pub inline fn getClipboardString() error{ PlatformError }![:0]const u8 { pub inline fn getClipboardString() Error![:0]const u8 {
internal_debug.assertInitialized(); internal_debug.assertInitialized();
const value = c.glfwGetClipboardString(null); const value = c.glfwGetClipboardString(null);
getError() catch |err| return switch (err) { getError() catch |err| return switch (err) {
Error.PlatformError => @errSetCast(error{ PlatformError }, err), Error.PlatformError => err,
else => unreachable, else => unreachable,
}; };
return std.mem.span(value); return std.mem.span(value);

8
glfw/src/key.zig
View file

@ -214,11 +214,11 @@ pub const Key = enum(c_int) {
/// @thread_safety This function must only be called from the main thread. /// @thread_safety This function must only be called from the main thread.
/// ///
/// see also: input_key_name /// see also: input_key_name
pub inline fn getName(self: Key, scancode: isize) error{ PlatformError }!?[:0]const u8 { pub inline fn getName(self: Key, scancode: isize) Error!?[:0]const u8 {
internal_debug.assertInitialized(); internal_debug.assertInitialized();
const name_opt = cc.glfwGetKeyName(@enumToInt(self), @intCast(c_int, scancode)); const name_opt = cc.glfwGetKeyName(@enumToInt(self), @intCast(c_int, scancode));
getError() catch |err| return switch (err) { getError() catch |err| return switch (err) {
Error.PlatformError => @errSetCast(error{ PlatformError }, err), Error.PlatformError => err,
else => unreachable, else => unreachable,
}; };
return if (name_opt) |name| return if (name_opt) |name|
@ -239,12 +239,12 @@ pub const Key = enum(c_int) {
/// Possible errors include glfw.Error.NotInitialized, glfw.Error.InvalidEnum and glfw.Error.PlatformError. /// Possible errors include glfw.Error.NotInitialized, glfw.Error.InvalidEnum and glfw.Error.PlatformError.
/// ///
/// @thread_safety This function may be called from any thread. /// @thread_safety This function may be called from any thread.
pub inline fn getScancode(self: Key) error{ PlatformError }!isize { pub inline fn getScancode(self: Key) Error!isize {
internal_debug.assertInitialized(); internal_debug.assertInitialized();
const scancode = cc.glfwGetKeyScancode(@enumToInt(self)); const scancode = cc.glfwGetKeyScancode(@enumToInt(self));
getError() catch |err| return switch (err) { getError() catch |err| return switch (err) {
Error.InvalidEnum => unreachable, // Should be unreachable for any valid 'Key' value. Error.InvalidEnum => unreachable, // Should be unreachable for any valid 'Key' value.
Error.PlatformError => @errSetCast(error{ PlatformError }, err), Error.PlatformError => err,
else => unreachable, else => unreachable,
}; };
return scancode; return scancode;

24
glfw/src/main.zig
View file

@ -57,7 +57,7 @@ const internal_debug = @import("internal_debug.zig");
/// Unicode text input. /// Unicode text input.
/// ///
/// @thread_safety This function must only be called from the main thread. /// @thread_safety This function must only be called from the main thread.
pub inline fn init(hints: InitHints) error{ PlatformError }!void { pub inline fn init(hints: InitHints) Error!void {
internal_debug.toggleInitialized(); internal_debug.toggleInitialized();
internal_debug.assertInitialized(); internal_debug.assertInitialized();
errdefer internal_debug.toggleInitialized(); errdefer internal_debug.toggleInitialized();
@ -76,7 +76,7 @@ pub inline fn init(hints: InitHints) error{ PlatformError }!void {
_ = c.glfwInit(); _ = c.glfwInit();
getError() catch |err| return switch (err) { getError() catch |err| return switch (err) {
Error.PlatformError => @errSetCast(error{ PlatformError }, err), Error.PlatformError => err,
else => unreachable, else => unreachable,
}; };
} }
@ -173,7 +173,7 @@ const InitHint = enum(c_int) {
/// @remarks This function may be called before glfw.init. /// @remarks This function may be called before glfw.init.
/// ///
/// @thread_safety This function must only be called from the main thread. /// @thread_safety This function must only be called from the main thread.
fn initHint(hint: InitHint, value: anytype) error{ InvalidValue }!void { fn initHint(hint: InitHint, value: anytype) Error!void {
switch (@typeInfo(@TypeOf(value))) { switch (@typeInfo(@TypeOf(value))) {
.Int, .ComptimeInt => c.glfwInitHint(@enumToInt(hint), @intCast(c_int, value)), .Int, .ComptimeInt => c.glfwInitHint(@enumToInt(hint), @intCast(c_int, value)),
.Bool => c.glfwInitHint(@enumToInt(hint), @intCast(c_int, @boolToInt(value))), .Bool => c.glfwInitHint(@enumToInt(hint), @intCast(c_int, @boolToInt(value))),
@ -181,7 +181,7 @@ fn initHint(hint: InitHint, value: anytype) error{ InvalidValue }!void {
} }
getError() catch |err| return switch (err) { getError() catch |err| return switch (err) {
Error.InvalidEnum => unreachable, // impossible for any valid 'InitHint' value Error.InvalidEnum => unreachable, // impossible for any valid 'InitHint' value
Error.InvalidValue => @errSetCast(error{ InvalidValue }, err), Error.InvalidValue => err,
else => unreachable, else => unreachable,
}; };
} }
@ -233,11 +233,11 @@ pub inline fn getVersionString() [:0]const u8 {
/// @thread_safety This function must only be called from the main thread. /// @thread_safety This function must only be called from the main thread.
/// ///
/// see also: events, glfw.waitEvents, glfw.waitEventsTimeout /// see also: events, glfw.waitEvents, glfw.waitEventsTimeout
pub inline fn pollEvents() error{ PlatformError }!void { pub inline fn pollEvents() Error!void {
internal_debug.assertInitialized(); internal_debug.assertInitialized();
c.glfwPollEvents(); c.glfwPollEvents();
getError() catch |err| return switch (err) { getError() catch |err| return switch (err) {
Error.PlatformError => @errSetCast(error{ PlatformError }, err), Error.PlatformError => err,
else => unreachable, else => unreachable,
}; };
} }
@ -272,11 +272,11 @@ pub inline fn pollEvents() error{ PlatformError }!void {
/// @thread_safety This function must only be called from the main thread. /// @thread_safety This function must only be called from the main thread.
/// ///
/// see also: events, glfw.pollEvents, glfw.waitEventsTimeout /// see also: events, glfw.pollEvents, glfw.waitEventsTimeout
pub inline fn waitEvents() error{ PlatformError }!void { pub inline fn waitEvents() Error!void {
internal_debug.assertInitialized(); internal_debug.assertInitialized();
c.glfwWaitEvents(); c.glfwWaitEvents();
getError() catch |err| return switch (err) { getError() catch |err| return switch (err) {
Error.PlatformError => @errSetCast(error{ PlatformError }, err), Error.PlatformError => err,
else => unreachable, else => unreachable,
}; };
} }
@ -315,7 +315,7 @@ pub inline fn waitEvents() error{ PlatformError }!void {
/// @thread_safety This function must only be called from the main thread. /// @thread_safety This function must only be called from the main thread.
/// ///
/// see also: events, glfw.pollEvents, glfw.waitEvents /// see also: events, glfw.pollEvents, glfw.waitEvents
pub inline fn waitEventsTimeout(timeout: f64) error{ InvalidValue, PlatformError }!void { pub inline fn waitEventsTimeout(timeout: f64) Error!void {
internal_debug.assertInitialized(); internal_debug.assertInitialized();
c.glfwWaitEventsTimeout(timeout); c.glfwWaitEventsTimeout(timeout);
getError() catch |err| return switch (err) { getError() catch |err| return switch (err) {
@ -323,7 +323,7 @@ pub inline fn waitEventsTimeout(timeout: f64) error{ InvalidValue, PlatformError
// and make its branch unreachable. // and make its branch unreachable.
Error.InvalidValue, Error.InvalidValue,
Error.PlatformError, Error.PlatformError,
=> @errSetCast(error{ InvalidValue, PlatformError }, err), => err,
else => unreachable, else => unreachable,
}; };
} }
@ -338,11 +338,11 @@ pub inline fn waitEventsTimeout(timeout: f64) error{ InvalidValue, PlatformError
/// @thread_safety This function may be called from any thread. /// @thread_safety This function may be called from any thread.
/// ///
/// see also: events, glfw.waitEvents, glfw.waitEventsTimeout /// see also: events, glfw.waitEvents, glfw.waitEventsTimeout
pub inline fn postEmptyEvent() error{ PlatformError }!void { pub inline fn postEmptyEvent() Error!void {
internal_debug.assertInitialized(); internal_debug.assertInitialized();
c.glfwPostEmptyEvent(); c.glfwPostEmptyEvent();
getError() catch |err| return switch (err) { getError() catch |err| return switch (err) {
Error.PlatformError => @errSetCast(error{ PlatformError }, err), Error.PlatformError => err,
else => unreachable, else => unreachable,
}; };
} }

12
glfw/src/opengl.zig
View file

@ -31,13 +31,13 @@ const internal_debug = @import("internal_debug.zig");
/// @thread_safety This function may be called from any thread. /// @thread_safety This function may be called from any thread.
/// ///
/// see also: context_current, glfwGetCurrentContext /// see also: context_current, glfwGetCurrentContext
pub inline fn makeContextCurrent(window: ?Window) error{ NoWindowContext, PlatformError }!void { pub inline fn makeContextCurrent(window: ?Window) Error!void {
internal_debug.assertInitialized(); internal_debug.assertInitialized();
if (window) |w| c.glfwMakeContextCurrent(w.handle) else c.glfwMakeContextCurrent(null); if (window) |w| c.glfwMakeContextCurrent(w.handle) else c.glfwMakeContextCurrent(null);
getError() catch |err| return switch (err) { getError() catch |err| return switch (err) {
Error.NoWindowContext, Error.NoWindowContext,
Error.PlatformError, Error.PlatformError,
=> @errSetCast(error{ NoWindowContext, PlatformError }, err), => err,
else => unreachable, else => unreachable,
}; };
} }
@ -95,13 +95,13 @@ pub inline fn getCurrentContext() std.mem.Allocator.Error!?Window {
/// @thread_safety This function may be called from any thread. /// @thread_safety This function may be called from any thread.
/// ///
/// see also: buffer_swap, glfwSwapBuffers /// see also: buffer_swap, glfwSwapBuffers
pub inline fn swapInterval(interval: isize) error{ NoCurrentContext, PlatformError }!void { pub inline fn swapInterval(interval: isize) Error!void {
internal_debug.assertInitialized(); internal_debug.assertInitialized();
c.glfwSwapInterval(@intCast(c_int, interval)); c.glfwSwapInterval(@intCast(c_int, interval));
getError() catch |err| return switch (err) { getError() catch |err| return switch (err) {
Error.NoCurrentContext, Error.NoCurrentContext,
Error.PlatformError, Error.PlatformError,
=> @errSetCast(error{ NoCurrentContext, PlatformError }, err), => err,
else => unreachable, else => unreachable,
}; };
} }
@ -131,13 +131,13 @@ pub inline fn swapInterval(interval: isize) error{ NoCurrentContext, PlatformErr
/// @thread_safety This function may be called from any thread. /// @thread_safety This function may be called from any thread.
/// ///
/// see also: context_glext, glfw.getProcAddress /// see also: context_glext, glfw.getProcAddress
pub inline fn extensionSupported(extension: [*:0]const u8) error{ NoCurrentContext, InvalidValue }!bool { pub inline fn extensionSupported(extension: [*:0]const u8) Error!bool {
internal_debug.assertInitialized(); internal_debug.assertInitialized();
const supported = c.glfwExtensionSupported(extension); const supported = c.glfwExtensionSupported(extension);
getError() catch |err| return switch (err) { getError() catch |err| return switch (err) {
Error.NoCurrentContext, Error.NoCurrentContext,
Error.InvalidValue, Error.InvalidValue,
=> @errSetCast(error{ NoCurrentContext, InvalidValue }, err), => err,
else => unreachable, else => unreachable,
}; };
return supported == c.GLFW_TRUE; return supported == c.GLFW_TRUE;

4
glfw/src/time.zig
View file

@ -53,12 +53,12 @@ pub inline fn getTime() f64 {
/// base time is not atomic, so it needs to be externally synchronized with calls to glfw.getTime. /// base time is not atomic, so it needs to be externally synchronized with calls to glfw.getTime.
/// ///
/// see also: time /// see also: time
pub inline fn setTime(time: f64) error{ InvalidValue }!void { pub inline fn setTime(time: f64) Error!void {
internal_debug.assertInitialized(); internal_debug.assertInitialized();
c.glfwSetTime(time); c.glfwSetTime(time);
getError() catch |err| return switch (err) { getError() catch |err| return switch (err) {
// TODO: Consider whether to use GLFW error handling, or assert that 'time' is a valid value // TODO: Consider whether to use GLFW error handling, or assert that 'time' is a valid value
Error.InvalidValue => @errSetCast(error{ InvalidValue }, err), Error.InvalidValue => err,
else => unreachable, else => unreachable,
}; };
} }

12
glfw/src/vulkan.zig
View file

@ -25,7 +25,7 @@ const internal_debug = @import("internal_debug.zig");
/// ///
/// @thread_safety This function may be called from any thread. /// @thread_safety This function may be called from any thread.
// TODO: Remove error stub // TODO: Remove error stub
pub inline fn vulkanSupported() error{}!bool { pub inline fn vulkanSupported() Error!bool {
internal_debug.assertInitialized(); internal_debug.assertInitialized();
const supported = c.glfwVulkanSupported(); const supported = c.glfwVulkanSupported();
getError() catch unreachable; // Only error 'GLFW_NOT_INITIALIZED' is impossible getError() catch unreachable; // Only error 'GLFW_NOT_INITIALIZED' is impossible
@ -61,12 +61,12 @@ pub inline fn vulkanSupported() error{}!bool {
/// @thread_safety This function may be called from any thread. /// @thread_safety This function may be called from any thread.
/// ///
/// see also: vulkan_ext, glfwCreateWindowSurface /// see also: vulkan_ext, glfwCreateWindowSurface
pub inline fn getRequiredInstanceExtensions() error{ APIUnavailable }![][*:0]const u8 { pub inline fn getRequiredInstanceExtensions() Error![][*:0]const u8 {
internal_debug.assertInitialized(); internal_debug.assertInitialized();
var count: u32 = 0; var count: u32 = 0;
const extensions = c.glfwGetRequiredInstanceExtensions(&count); const extensions = c.glfwGetRequiredInstanceExtensions(&count);
getError() catch |err| return switch (err) { getError() catch |err| return switch (err) {
Error.APIUnavailable => @errSetCast(error{ APIUnavailable }, err), Error.APIUnavailable => err,
else => unreachable, else => unreachable,
}; };
return @ptrCast([*][*:0]const u8, extensions)[0..count]; return @ptrCast([*][*:0]const u8, extensions)[0..count];
@ -143,7 +143,7 @@ pub fn getInstanceProcAddress(vk_instance: ?*opaque {}, proc_name: [*:0]const u8
/// Vulkan objects, see the Vulkan specification. /// Vulkan objects, see the Vulkan specification.
/// ///
/// see also: vulkan_present /// see also: vulkan_present
pub inline fn getPhysicalDevicePresentationSupport(vk_instance: *opaque {}, vk_physical_device: *opaque {}, queue_family: u32) error{ APIUnavailable, PlatformError }!bool { pub inline fn getPhysicalDevicePresentationSupport(vk_instance: *opaque {}, vk_physical_device: *opaque {}, queue_family: u32) Error!bool {
internal_debug.assertInitialized(); internal_debug.assertInitialized();
const v = c.glfwGetPhysicalDevicePresentationSupport( const v = c.glfwGetPhysicalDevicePresentationSupport(
@ptrCast(c.VkInstance, vk_instance), @ptrCast(c.VkInstance, vk_instance),
@ -153,7 +153,7 @@ pub inline fn getPhysicalDevicePresentationSupport(vk_instance: *opaque {}, vk_p
getError() catch |err| return switch (err) { getError() catch |err| return switch (err) {
Error.APIUnavailable, Error.APIUnavailable,
Error.PlatformError, Error.PlatformError,
=> @errSetCast(error{ APIUnavailable, PlatformError }, err), => err,
else => unreachable, else => unreachable,
}; };
return v == c.GLFW_TRUE; return v == c.GLFW_TRUE;
@ -204,7 +204,7 @@ pub inline fn getPhysicalDevicePresentationSupport(vk_instance: *opaque {}, vk_p
/// Vulkan objects, see the Vulkan specification. /// Vulkan objects, see the Vulkan specification.
/// ///
/// see also: vulkan_surface, glfw.getRequiredInstanceExtensions /// see also: vulkan_surface, glfw.getRequiredInstanceExtensions
pub inline fn createWindowSurface(vk_instance: anytype, window: Window, vk_allocation_callbacks: anytype, vk_surface_khr: anytype) error{ APIUnavailable, PlatformError, InvalidValue }!i32 { pub inline fn createWindowSurface(vk_instance: anytype, window: Window, vk_allocation_callbacks: anytype, vk_surface_khr: anytype) Error!i32 {
internal_debug.assertInitialized(); internal_debug.assertInitialized();
// zig-vulkan uses enums to represent opaque pointers: // zig-vulkan uses enums to represent opaque pointers:
// pub const Instance = enum(usize) { null_handle = 0, _ }; // pub const Instance = enum(usize) { null_handle = 0, _ };