From 4bc32adeb8cc16598b3c0566a37cd9d3c13fbdc0 Mon Sep 17 00:00:00 2001 From: Stephen Gutekanst Date: Thu, 29 Jun 2023 09:54:32 -0700 Subject: [PATCH] all: update to latest Zig APIs (zig fmt) Signed-off-by: Stephen Gutekanst --- libs/basisu/src/encoder.zig | 4 +- libs/basisu/src/transcoder.zig | 6 +- libs/core/src/Timer.zig | 4 +- libs/core/src/platform/libmachcore.zig | 8 +- libs/core/src/platform/native/Core.zig | 10 +- libs/core/src/platform/native/util.zig | 4 +- libs/core/src/platform/wasm/Core.zig | 34 +- libs/core/src/platform/wasm/Timer.zig | 2 +- libs/freetype/src/Face.zig | 50 +- libs/freetype/src/GlyphSlot.zig | 10 +- libs/freetype/src/color.zig | 2 +- libs/freetype/src/computations.zig | 16 +- libs/freetype/src/freetype.zig | 10 +- libs/freetype/src/glyph.zig | 18 +- libs/freetype/src/harfbuzz/blob.zig | 4 +- libs/freetype/src/harfbuzz/buffer.zig | 32 +- libs/freetype/src/harfbuzz/common.zig | 24 +- libs/freetype/src/harfbuzz/font.zig | 10 +- libs/freetype/src/harfbuzz/shape_plan.zig | 16 +- libs/freetype/src/image.zig | 18 +- libs/glfw/src/Cursor.zig | 4 +- libs/glfw/src/GammaRamp.zig | 2 +- libs/glfw/src/Image.zig | 8 +- libs/glfw/src/Joystick.zig | 30 +- libs/glfw/src/Monitor.zig | 22 +- libs/glfw/src/VideoMode.zig | 12 +- libs/glfw/src/Window.zig | 90 +-- libs/glfw/src/clipboard.zig | 2 +- libs/glfw/src/hat.zig | 4 +- libs/glfw/src/key.zig | 6 +- libs/glfw/src/main.zig | 8 +- libs/glfw/src/mod.zig | 4 +- libs/glfw/src/native.zig | 54 +- libs/glfw/src/opengl.zig | 2 +- libs/glfw/src/vulkan.zig | 16 +- libs/gpu/examples/sample_utils.zig | 4 +- libs/gpu/src/adapter.zig | 2 +- libs/gpu/src/buffer.zig | 8 +- libs/gpu/src/command_encoder.zig | 4 +- libs/gpu/src/dawn_impl.zig | 712 +++++++++++----------- libs/gpu/src/device.zig | 12 +- libs/gpu/src/instance.zig | 2 +- libs/gpu/src/interface.zig | 2 +- libs/gpu/src/main.zig | 6 +- libs/gpu/src/queue.zig | 8 +- libs/gpu/src/shader_module.zig | 2 +- libs/gpu/src/texture.zig | 2 +- libs/model3d/src/main.zig | 2 +- libs/sysaudio/examples/sine-wave.zig | 6 +- libs/sysaudio/src/alsa.zig | 22 +- libs/sysaudio/src/coreaudio.zig | 16 +- libs/sysaudio/src/jack.zig | 26 +- libs/sysaudio/src/main.zig | 18 +- libs/sysaudio/src/pipewire.zig | 12 +- libs/sysaudio/src/pulseaudio.zig | 34 +- libs/sysaudio/src/wasapi.zig | 36 +- libs/sysaudio/src/wasapi/win32.zig | 106 ++-- libs/sysaudio/src/webaudio.zig | 6 +- shaderexp/main.zig | 2 +- src/gfx2d/Sprite2D.zig | 14 +- src/resource/ResourceManager.zig | 2 +- 61 files changed, 806 insertions(+), 806 deletions(-) diff --git a/libs/basisu/src/encoder.zig b/libs/basisu/src/encoder.zig index 8550d7f2..d58bd10d 100644 --- a/libs/basisu/src/encoder.zig +++ b/libs/basisu/src/encoder.zig @@ -94,11 +94,11 @@ pub const CompressorParams = struct { } pub fn getPackUASTCFlags(self: CompressorParams) PackUASTCFlags { - return @bitCast(PackUASTCFlags, b.compressor_params_get_pack_uastc_flags(self.handle)); + return @as(PackUASTCFlags, @bitCast(b.compressor_params_get_pack_uastc_flags(self.handle))); } pub fn setPackUASTCFlags(self: CompressorParams, flags: PackUASTCFlags) void { - b.compressor_params_set_pack_uastc_flags(self.handle, @bitCast(u32, flags)); + b.compressor_params_set_pack_uastc_flags(self.handle, @as(u32, @bitCast(flags))); } pub fn setBasisFormat(self: CompressorParams, format: BasisTextureFormat) void { diff --git a/libs/basisu/src/transcoder.zig b/libs/basisu/src/transcoder.zig index 75d4cd0b..5fcd5fa6 100644 --- a/libs/basisu/src/transcoder.zig +++ b/libs/basisu/src/transcoder.zig @@ -18,7 +18,7 @@ pub const Transcoder = struct { handle: *b.BasisFile, pub fn init(src: []const u8) error{Unknown}!Transcoder { - const h = b.transcoder_init(src.ptr, @intCast(u32, src.len)); + const h = b.transcoder_init(src.ptr, @as(u32, @intCast(src.len))); return if (!b.transcoder_start_transcoding(h)) error.Unknown else @@ -101,11 +101,11 @@ pub const Transcoder = struct { if (!b.transcoder_transcode( self.handle, out_buf.ptr, - @intCast(u32, out_buf.len), + @as(u32, @intCast(out_buf.len)), image_index, level_index, @intFromEnum(format), - @bitCast(u32, params.decode_flags), + @as(u32, @bitCast(params.decode_flags)), params.output_row_pitch orelse 0, params.output_rows orelse 0, )) return error.Unknown; diff --git a/libs/core/src/Timer.zig b/libs/core/src/Timer.zig index ccecf9f9..c84b9f30 100644 --- a/libs/core/src/Timer.zig +++ b/libs/core/src/Timer.zig @@ -19,7 +19,7 @@ pub inline fn readPrecise(timer: *Timer) u64 { /// Reads the timer value since start or the last reset in seconds. pub inline fn read(timer: *Timer) f32 { - return @floatFromInt(f32, timer.readPrecise()) / @floatFromInt(f32, std.time.ns_per_s); + return @as(f32, @floatFromInt(timer.readPrecise())) / @as(f32, @floatFromInt(std.time.ns_per_s)); } /// Resets the timer value to 0/now. @@ -34,5 +34,5 @@ pub inline fn lapPrecise(timer: *Timer) u64 { /// Returns the current value of the timer in seconds, then resets it. pub inline fn lap(timer: *Timer) f32 { - return @floatFromInt(f32, timer.lapPrecise()) / @floatFromInt(f32, std.time.ns_per_s); + return @as(f32, @floatFromInt(timer.lapPrecise())) / @as(f32, @floatFromInt(std.time.ns_per_s)); } diff --git a/libs/core/src/platform/libmachcore.zig b/libs/core/src/platform/libmachcore.zig index 2852f73d..4494492d 100644 --- a/libs/core/src/platform/libmachcore.zig +++ b/libs/core/src/platform/libmachcore.zig @@ -39,7 +39,7 @@ pub export fn mach_core_init() ?*MachCoreInstance { } pub export fn mach_core_deinit(_core: *MachCoreInstance) void { - var core = @ptrCast(*native.Core, @alignCast(@alignOf(@TypeOf(_core)), _core)); + var core = @as(*native.Core, @ptrCast(@alignCast(@alignOf(@TypeOf(_core)), _core))); native.Core.deinit(core); } @@ -50,13 +50,13 @@ pub const MachCoreEventIterator = extern struct { pub const MachCoreEvent = Core.Event; pub export fn mach_core_poll_events(_core: *MachCoreInstance) MachCoreEventIterator { - var core = @ptrCast(*native.Core, @alignCast(@alignOf(@TypeOf(_core)), _core)); + var core = @as(*native.Core, @ptrCast(@alignCast(@alignOf(@TypeOf(_core)), _core))); var iter = native.Core.pollEvents(core); - return @ptrCast(*MachCoreEventIterator, &iter).*; + return @as(*MachCoreEventIterator, @ptrCast(&iter)).*; } pub export fn mach_core_event_iterator_next(_iter: *MachCoreEventIterator, event: *MachCoreEvent) bool { - var iter = @ptrCast(*native.Core.EventIterator, @alignCast(@alignOf(@TypeOf(_iter)), _iter)); + var iter = @as(*native.Core.EventIterator, @ptrCast(@alignCast(@alignOf(@TypeOf(_iter)), _iter))); var value = iter.next() orelse return false; event.* = value; return true; diff --git a/libs/core/src/platform/native/Core.zig b/libs/core/src/platform/native/Core.zig index f4ae40af..ab90d4ca 100644 --- a/libs/core/src/platform/native/Core.zig +++ b/libs/core/src/platform/native/Core.zig @@ -155,7 +155,7 @@ pub fn init(core: *Core, allocator: std.mem.Allocator, options: Options) !void { // Create a device with default limits/features. const gpu_device = response.adapter.createDevice(&.{ - .required_features_count = if (options.required_features) |v| @intCast(u32, v.len) else 0, + .required_features_count = if (options.required_features) |v| @as(u32, @intCast(v.len)) else 0, .required_features = if (options.required_features) |v| @as(?[*]const gpu.FeatureName, v.ptr) else null, .required_limits = if (options.required_limits) |limits| @as(?*const gpu.RequiredLimits, &gpu.RequiredLimits{ .limits = limits, @@ -302,8 +302,8 @@ fn initCallbacks(self: *Core) void { const pf = (window.getUserPointer(UserPtr) orelse unreachable).self; pf.pushEvent(.{ .mouse_scroll = .{ - .xoffset = @floatCast(f32, xoffset), - .yoffset = @floatCast(f32, yoffset), + .xoffset = @as(f32, @floatCast(xoffset)), + .yoffset = @as(f32, @floatCast(yoffset)), }, }); } @@ -419,8 +419,8 @@ pub fn setDisplayMode(self: *Core, mode: DisplayMode, monitor_index: ?usize) voi self.window.setAttrib(.floating, false); self.window.setMonitor( null, - @intCast(i32, self.last_pos.x), - @intCast(i32, self.last_pos.y), + @as(i32, @intCast(self.last_pos.x)), + @as(i32, @intCast(self.last_pos.y)), self.last_size.width, self.last_size.height, null, diff --git a/libs/core/src/platform/native/util.zig b/libs/core/src/platform/native/util.zig index 423151e2..314f26ad 100644 --- a/libs/core/src/platform/native/util.zig +++ b/libs/core/src/platform/native/util.zig @@ -180,8 +180,8 @@ pub fn msgSend(obj: anytype, sel_name: [:0]const u8, args: anytype, comptime Ret }; // NOTE: func is a var because making it const causes a compile error which I believe is a compiler bug - var func = @ptrCast(FnType, &objc.objc_msgSend); - const sel = objc.sel_getUid(@ptrCast([*c]const u8, sel_name)); + var func = @as(FnType, @ptrCast(&objc.objc_msgSend)); + const sel = objc.sel_getUid(@as([*c]const u8, @ptrCast(sel_name))); return @call(.auto, func, .{ obj, sel } ++ args); } diff --git a/libs/core/src/platform/wasm/Core.zig b/libs/core/src/platform/wasm/Core.zig index c7fa790b..ccc4f67a 100644 --- a/libs/core/src/platform/wasm/Core.zig +++ b/libs/core/src/platform/wasm/Core.zig @@ -31,10 +31,10 @@ pub const EventIterator = struct { const event_int = js.machEventShift(); if (event_int == -1) return null; - const event_type = @enumFromInt(std.meta.Tag(Event), event_int); + const event_type = @as(std.meta.Tag(Event), @enumFromInt(event_int)); return switch (event_type) { .key_press, .key_repeat => blk: { - const key = @enumFromInt(Key, js.machEventShift()); + const key = @as(Key, @enumFromInt(js.machEventShift())); switch (key) { .left_shift, .right_shift => self.key_mods.shift = true, .left_control, .right_control => self.key_mods.control = true, @@ -63,7 +63,7 @@ pub const EventIterator = struct { continue; }, .key_release => blk: { - const key = @enumFromInt(Key, js.machEventShift()); + const key = @as(Key, @enumFromInt(js.machEventShift())); switch (key) { .left_shift, .right_shift => self.key_mods.shift = false, .left_control, .right_control => self.key_mods.control = false, @@ -83,8 +83,8 @@ pub const EventIterator = struct { continue; }, .mouse_motion => blk: { - const x = @floatFromInt(f64, js.machEventShift()); - const y = @floatFromInt(f64, js.machEventShift()); + const x = @as(f64, @floatFromInt(js.machEventShift())); + const y = @as(f64, @floatFromInt(js.machEventShift())); self.last_cursor_position = .{ .x = x, .y = y, @@ -114,14 +114,14 @@ pub const EventIterator = struct { }, .mouse_scroll => Event{ .mouse_scroll = .{ - .xoffset = @floatCast(f32, std.math.sign(js.machEventShiftFloat())), - .yoffset = @floatCast(f32, std.math.sign(js.machEventShiftFloat())), + .xoffset = @as(f32, @floatCast(std.math.sign(js.machEventShiftFloat()))), + .yoffset = @as(f32, @floatCast(std.math.sign(js.machEventShiftFloat()))), }, }, .framebuffer_resize => blk: { - const width = @intCast(u32, js.machEventShift()); - const height = @intCast(u32, js.machEventShift()); - const pixel_ratio = @intCast(u32, js.machEventShift()); + const width = @as(u32, @intCast(js.machEventShift())); + const height = @as(u32, @intCast(js.machEventShift())); + const pixel_ratio = @as(u32, @intCast(js.machEventShift())); break :blk Event{ .framebuffer_resize = .{ .width = width * pixel_ratio, @@ -195,7 +195,7 @@ pub fn setDisplayMode(self: *Core, mode: DisplayMode, monitor: ?usize) void { } pub fn displayMode(self: *Core) DisplayMode { - return @enumFromInt(DisplayMode, js.machDisplayMode(self.id)); + return @as(DisplayMode, @enumFromInt(js.machDisplayMode(self.id))); } pub fn setBorder(self: *Core, value: bool) void { @@ -243,10 +243,10 @@ pub fn size(self: *Core) Size { pub fn setSizeLimit(self: *Core, limit: SizeLimit) void { js.machCanvasSetSizeLimit( self.id, - if (limit.min.width) |val| @intCast(i32, val) else -1, - if (limit.min.height) |val| @intCast(i32, val) else -1, - if (limit.max.width) |val| @intCast(i32, val) else -1, - if (limit.max.height) |val| @intCast(i32, val) else -1, + if (limit.min.width) |val| @as(i32, @intCast(val)) else -1, + if (limit.min.height) |val| @as(i32, @intCast(val)) else -1, + if (limit.max.width) |val| @as(i32, @intCast(val)) else -1, + if (limit.max.height) |val| @as(i32, @intCast(val)) else -1, ); } @@ -268,7 +268,7 @@ pub fn setCursorMode(self: *Core, mode: CursorMode) void { } pub fn cursorMode(self: *Core) CursorMode { - return @enumFromInt(CursorMode, js.machCursorMode(self.id)); + return @as(CursorMode, @enumFromInt(js.machCursorMode(self.id))); } pub fn setCursorShape(self: *Core, shape: CursorShape) void { @@ -276,7 +276,7 @@ pub fn setCursorShape(self: *Core, shape: CursorShape) void { } pub fn cursorShape(self: *Core) CursorShape { - return @enumFromInt(CursorShape, js.machCursorShape(self.id)); + return @as(CursorShape, @enumFromInt(js.machCursorShape(self.id))); } pub fn adapter(_: *Core) *gpu.Adapter { diff --git a/libs/core/src/platform/wasm/Timer.zig b/libs/core/src/platform/wasm/Timer.zig index aa6e933e..dd9e293e 100644 --- a/libs/core/src/platform/wasm/Timer.zig +++ b/libs/core/src/platform/wasm/Timer.zig @@ -21,5 +21,5 @@ pub fn lap(timer: *Timer) u64 { const now = js.machPerfNow(); const initial = timer.initial; timer.initial = now; - return @intFromFloat(u64, now - initial) * std.time.ns_per_ms; + return @as(u64, @intFromFloat(now - initial)) * std.time.ns_per_ms; } diff --git a/libs/freetype/src/Face.zig b/libs/freetype/src/Face.zig index 60f8a4f2..a2003875 100644 --- a/libs/freetype/src/Face.zig +++ b/libs/freetype/src/Face.zig @@ -37,12 +37,12 @@ pub const CharmapIterator = struct { return .{ .face = face, .index = i, - .charcode = @intCast(u32, cc), + .charcode = @as(u32, @intCast(cc)), }; } pub fn next(self: *CharmapIterator) ?u32 { - self.charcode = @intCast(u32, c.FT_Get_Next_Char(self.face.handle, self.charcode, &self.index)); + self.charcode = @as(u32, @intCast(c.FT_Get_Next_Char(self.face.handle, self.charcode, &self.index))); return if (self.index != 0) self.charcode else @@ -77,11 +77,11 @@ pub fn attachStream(self: Face, args: OpenArgs) Error!void { } pub fn loadGlyph(self: Face, index: u32, flags: LoadFlags) Error!void { - return intToError(c.FT_Load_Glyph(self.handle, index, @bitCast(i32, flags))); + return intToError(c.FT_Load_Glyph(self.handle, index, @as(i32, @bitCast(flags)))); } pub fn loadChar(self: Face, char: u32, flags: LoadFlags) Error!void { - return intToError(c.FT_Load_Char(self.handle, char, @bitCast(i32, flags))); + return intToError(c.FT_Load_Char(self.handle, char, @as(i32, @bitCast(flags)))); } pub fn setCharSize(self: Face, pt_width: i32, pt_height: i32, horz_resolution: u16, vert_resolution: u16) Error!void { @@ -133,16 +133,16 @@ pub fn getKerning(self: Face, left_char_index: u32, right_char_index: u32, mode: pub fn getTrackKerning(self: Face, point_size: i32, degree: i32) Error!i32 { var kerning: c_long = 0; try intToError(c.FT_Get_Track_Kerning(self.handle, point_size, degree, kerning)); - return @intCast(i32, kerning); + return @as(i32, @intCast(kerning)); } pub fn getGlyphName(self: Face, index: u32, buf: []u8) Error!void { - try intToError(c.FT_Get_Glyph_Name(self.handle, index, buf.ptr, @intCast(c_uint, buf.len))); + try intToError(c.FT_Get_Glyph_Name(self.handle, index, buf.ptr, @as(c_uint, @intCast(buf.len)))); } pub fn getPostscriptName(self: Face) ?[:0]const u8 { return if (c.FT_Get_Postscript_Name(self.handle)) |face_name| - std.mem.span(@ptrCast([*:0]const u8, face_name)) + std.mem.span(@as([*:0]const u8, @ptrCast(face_name))) else null; } @@ -160,7 +160,7 @@ pub fn setCharmap(self: Face, char_map: *CharMap) Error!void { } pub fn getFSTypeFlags(self: Face) FSType { - return @bitCast(FSType, c.FT_Get_FSType_Flags(self.handle)); + return @as(FSType, @bitCast(c.FT_Get_FSType_Flags(self.handle))); } pub fn getCharVariantIndex(self: Face, char: u32, variant_selector: u32) ?u32 { @@ -181,21 +181,21 @@ pub fn getCharVariantIsDefault(self: Face, char: u32, variant_selector: u32) ?bo pub fn getVariantSelectors(self: Face) ?[]u32 { return if (c.FT_Face_GetVariantSelectors(self.handle)) |chars| - @ptrCast([]u32, std.mem.sliceTo(@ptrCast([*:0]u32, chars), 0)) + @as([]u32, @ptrCast(std.mem.sliceTo(@as([*:0]u32, @ptrCast(chars)), 0))) else null; } pub fn getVariantsOfChar(self: Face, char: u32) ?[]u32 { return if (c.FT_Face_GetVariantsOfChar(self.handle, char)) |variants| - @ptrCast([]u32, std.mem.sliceTo(@ptrCast([*:0]u32, variants), 0)) + @as([]u32, @ptrCast(std.mem.sliceTo(@as([*:0]u32, @ptrCast(variants)), 0))) else null; } pub fn getCharsOfVariant(self: Face, variant_selector: u32) ?[]u32 { return if (c.FT_Face_GetCharsOfVariant(self.handle, variant_selector)) |chars| - @ptrCast([]u32, std.mem.sliceTo(@ptrCast([*:0]u32, chars), 0)) + @as([]u32, @ptrCast(std.mem.sliceTo(@as([*:0]u32, @ptrCast(chars)), 0))) else null; } @@ -239,7 +239,7 @@ pub fn getPaint(self: Face, opaque_paint: OpaquePaint) ?Paint { var p: c.FT_COLR_Paint = undefined; if (c.FT_Get_Paint(self.handle, opaque_paint, &p) == 0) return null; - return switch (@enumFromInt(PaintFormat, p.format)) { + return switch (@as(PaintFormat, @enumFromInt(p.format))) { .color_layers => Paint{ .color_layers = p.u.colr_layers }, .glyph => Paint{ .glyph = p.u.glyph }, .solid => Paint{ .solid = p.u.solid }, @@ -263,41 +263,41 @@ pub fn newSize(self: Face) Error!Size { } pub fn numFaces(self: Face) u32 { - return @intCast(u32, self.handle.*.num_faces); + return @as(u32, @intCast(self.handle.*.num_faces)); } pub fn faceIndex(self: Face) u32 { - return @intCast(u32, self.handle.*.face_index); + return @as(u32, @intCast(self.handle.*.face_index)); } pub fn faceFlags(self: Face) FaceFlags { - return @bitCast(FaceFlags, self.handle.*.face_flags); + return @as(FaceFlags, @bitCast(self.handle.*.face_flags)); } pub fn styleFlags(self: Face) StyleFlags { - return @bitCast(StyleFlags, self.handle.*.style_flags); + return @as(StyleFlags, @bitCast(self.handle.*.style_flags)); } pub fn numGlyphs(self: Face) u32 { - return @intCast(u32, self.handle.*.num_glyphs); + return @as(u32, @intCast(self.handle.*.num_glyphs)); } pub fn familyName(self: Face) ?[:0]const u8 { return if (self.handle.*.family_name) |family| - std.mem.span(@ptrCast([*:0]const u8, family)) + std.mem.span(@as([*:0]const u8, @ptrCast(family))) else null; } pub fn styleName(self: Face) ?[:0]const u8 { return if (self.handle.*.style_name) |style_name| - std.mem.span(@ptrCast([*:0]const u8, style_name)) + std.mem.span(@as([*:0]const u8, @ptrCast(style_name))) else null; } pub fn numFixedSizes(self: Face) u32 { - return @intCast(u32, self.handle.*.num_fixed_sizes); + return @as(u32, @intCast(self.handle.*.num_fixed_sizes)); } pub fn availableSizes(self: Face) []BitmapSize { @@ -309,20 +309,20 @@ pub fn availableSizes(self: Face) []BitmapSize { pub fn getAdvance(self: Face, glyph_index: u32, load_flags: LoadFlags) Error!i32 { var a: c_long = 0; - try intToError(c.FT_Get_Advance(self.handle, glyph_index, @bitCast(i32, load_flags), &a)); - return @intCast(i32, a); + try intToError(c.FT_Get_Advance(self.handle, glyph_index, @as(i32, @bitCast(load_flags)), &a)); + return @as(i32, @intCast(a)); } pub fn getAdvances(self: Face, start: u32, advances_out: []c_long, load_flags: LoadFlags) Error!void { - try intToError(c.FT_Get_Advances(self.handle, start, @intCast(u32, advances_out.len), @bitCast(i32, load_flags), advances_out.ptr)); + try intToError(c.FT_Get_Advances(self.handle, start, @as(u32, @intCast(advances_out.len)), @as(i32, @bitCast(load_flags)), advances_out.ptr)); } pub fn numCharmaps(self: Face) u32 { - return @intCast(u32, self.handle.*.num_charmaps); + return @as(u32, @intCast(self.handle.*.num_charmaps)); } pub fn charmaps(self: Face) []const CharMap { - return @ptrCast([*]const CharMap, self.handle.*.charmaps)[0..self.numCharmaps()]; + return @as([*]const CharMap, @ptrCast(self.handle.*.charmaps))[0..self.numCharmaps()]; } pub fn bbox(self: Face) BBox { diff --git a/libs/freetype/src/GlyphSlot.zig b/libs/freetype/src/GlyphSlot.zig index a19cfe03..094f489d 100644 --- a/libs/freetype/src/GlyphSlot.zig +++ b/libs/freetype/src/GlyphSlot.zig @@ -45,11 +45,11 @@ pub fn metrics(self: GlyphSlot) GlyphMetrics { } pub fn linearHoriAdvance(self: GlyphSlot) i32 { - return @intCast(i32, self.handle.*.linearHoriAdvance); + return @as(i32, @intCast(self.handle.*.linearHoriAdvance)); } pub fn linearVertAdvance(self: GlyphSlot) i32 { - return @intCast(i32, self.handle.*.linearVertAdvance); + return @as(i32, @intCast(self.handle.*.linearVertAdvance)); } pub fn advance(self: GlyphSlot) Vector { @@ -57,7 +57,7 @@ pub fn advance(self: GlyphSlot) Vector { } pub fn format(self: GlyphSlot) GlyphFormat { - return @enumFromInt(GlyphFormat, self.handle.*.format); + return @as(GlyphFormat, @enumFromInt(self.handle.*.format)); } pub fn ownBitmap(self: GlyphSlot) Error!void { @@ -81,11 +81,11 @@ pub fn outline(self: GlyphSlot) ?Outline { } pub fn lsbDelta(self: GlyphSlot) i32 { - return @intCast(i32, self.handle.*.lsb_delta); + return @as(i32, @intCast(self.handle.*.lsb_delta)); } pub fn rsbDelta(self: GlyphSlot) i32 { - return @intCast(i32, self.handle.*.rsb_delta); + return @as(i32, @intCast(self.handle.*.rsb_delta)); } pub fn render(self: GlyphSlot, render_mode: RenderMode) Error!void { diff --git a/libs/freetype/src/color.zig b/libs/freetype/src/color.zig index 36f4d1e3..820beca0 100644 --- a/libs/freetype/src/color.zig +++ b/libs/freetype/src/color.zig @@ -116,7 +116,7 @@ pub const PaletteData = struct { } pub fn paletteFlag(self: PaletteData, index: u32) PaletteFlags { - return @bitCast(PaletteFlags, self.handle.palette_flags[index]); + return @as(PaletteFlags, @bitCast(self.handle.palette_flags[index])); } pub fn numPaletteEntries(self: PaletteData) u16 { diff --git a/libs/freetype/src/computations.zig b/libs/freetype/src/computations.zig index dfb096f3..71eb7b63 100644 --- a/libs/freetype/src/computations.zig +++ b/libs/freetype/src/computations.zig @@ -11,27 +11,27 @@ pub const angel_pi2 = _c.FT_ANGLE_PI2; pub const angel_pi4 = _c.FT_ANGLE_PI4; pub fn mulDiv(a: i32, b: i32, c: i32) i32 { - return @intCast(i32, _c.FT_MulDiv(a, b, c)); + return @as(i32, @intCast(_c.FT_MulDiv(a, b, c))); } pub fn mulFix(a: i32, b: i32) i32 { - return @intCast(i32, _c.FT_MulFix(a, b)); + return @as(i32, @intCast(_c.FT_MulFix(a, b))); } pub fn divFix(a: i32, b: i32) i32 { - return @intCast(i32, _c.FT_DivFix(a, b)); + return @as(i32, @intCast(_c.FT_DivFix(a, b))); } pub fn roundFix(a: i32) i32 { - return @intCast(i32, _c.FT_RoundFix(a)); + return @as(i32, @intCast(_c.FT_RoundFix(a))); } pub fn ceilFix(a: i32) i32 { - return @intCast(i32, _c.FT_CeilFix(a)); + return @as(i32, @intCast(_c.FT_CeilFix(a))); } pub fn floorFix(a: i32) i32 { - return @intCast(i32, _c.FT_FloorFix(a)); + return @as(i32, @intCast(_c.FT_FloorFix(a))); } pub fn vectorTransform(vec: *Vector, matrix: Matrix) void { @@ -47,7 +47,7 @@ pub fn matrixInvert(m: *Matrix) Error!void { } pub fn angleDiff(a: i32, b: i32) i32 { - return @intCast(i32, _c.FT_Angle_Diff(a, b)); + return @as(i32, @intCast(_c.FT_Angle_Diff(a, b))); } pub fn vectorUnit(vec: *Vector, angle: i32) void { @@ -59,7 +59,7 @@ pub fn vectorRotate(vec: *Vector, angle: i32) void { } pub fn vectorLength(vec: *Vector) i32 { - return @intCast(i32, _c.FT_Vector_Length(vec)); + return @as(i32, @intCast(_c.FT_Vector_Length(vec))); } pub fn vectorPolarize(vec: *Vector, length: *c_long, angle: *c_long) void { diff --git a/libs/freetype/src/freetype.zig b/libs/freetype/src/freetype.zig index f04f892f..bea18c65 100644 --- a/libs/freetype/src/freetype.zig +++ b/libs/freetype/src/freetype.zig @@ -167,11 +167,11 @@ pub const OpenArgs = struct { pub fn cast(self: OpenArgs) c.FT_Open_Args { var oa: c.FT_Open_Args = undefined; - oa.flags = @bitCast(u32, self.flags); + oa.flags = @as(u32, @bitCast(self.flags)); switch (self.data) { .memory => |d| { oa.memory_base = d.ptr; - oa.memory_size = @intCast(u31, d.len); + oa.memory_size = @as(u31, @intCast(d.len)); }, // The Freetype API requires a mutable string. // This is an oversight, Freetype actually never writes to this string. @@ -179,8 +179,8 @@ pub const OpenArgs = struct { .stream => |d| oa.stream = d, .driver => |d| oa.driver = d, .params => |*d| { - oa.params = @ptrFromInt(*c.FT_Parameter, @intFromPtr(d.ptr)); - oa.num_params = @intCast(u31, d.len); + oa.params = @as(*c.FT_Parameter, @ptrFromInt(@intFromPtr(d.ptr))); + oa.num_params = @as(u31, @intCast(d.len)); }, } return oa; @@ -189,5 +189,5 @@ pub const OpenArgs = struct { pub fn getCharmapIndex(self: [*c]CharMap) ?u32 { const i = c.FT_Get_Charmap_Index(self); - return if (i == -1) null else @intCast(u32, i); + return if (i == -1) null else @as(u32, @intCast(i)); } diff --git a/libs/freetype/src/glyph.zig b/libs/freetype/src/glyph.zig index 83c8dd01..deb3dfc0 100644 --- a/libs/freetype/src/glyph.zig +++ b/libs/freetype/src/glyph.zig @@ -54,24 +54,24 @@ pub const Glyph = struct { pub fn toBitmapGlyph(self: *Glyph, render_mode: RenderMode, origin: ?Vector) Error!BitmapGlyph { try intToError(c.FT_Glyph_To_Bitmap(&self.handle, @intFromEnum(render_mode), if (origin) |o| &o else null, 1)); - return BitmapGlyph{ .handle = @ptrCast(c.FT_BitmapGlyph, self.handle) }; + return BitmapGlyph{ .handle = @as(c.FT_BitmapGlyph, @ptrCast(self.handle)) }; } pub fn copyBitmapGlyph(self: *Glyph, render_mode: RenderMode, origin: ?Vector) Error!BitmapGlyph { try intToError(c.FT_Glyph_To_Bitmap(&self.handle, @intFromEnum(render_mode), if (origin) |o| &o else null, 0)); - return BitmapGlyph{ .handle = @ptrCast(c.FT_BitmapGlyph, self.handle) }; + return BitmapGlyph{ .handle = @as(c.FT_BitmapGlyph, @ptrCast(self.handle)) }; } pub fn castBitmapGlyph(self: Glyph) Error!BitmapGlyph { - return BitmapGlyph{ .handle = @ptrCast(c.FT_BitmapGlyph, self.handle) }; + return BitmapGlyph{ .handle = @as(c.FT_BitmapGlyph, @ptrCast(self.handle)) }; } pub fn castOutlineGlyph(self: Glyph) Error!OutlineGlyph { - return OutlineGlyph{ .handle = @ptrCast(c.FT_OutlineGlyph, self.handle) }; + return OutlineGlyph{ .handle = @as(c.FT_OutlineGlyph, @ptrCast(self.handle)) }; } pub fn castSvgGlyph(self: Glyph) Error!SvgGlyph { - return SvgGlyph{ .handle = @ptrCast(c.FT_SvgGlyph, self.handle) }; + return SvgGlyph{ .handle = @as(c.FT_SvgGlyph, @ptrCast(self.handle)) }; } pub fn stroke(self: *Glyph, stroker: Stroker) Error!void { @@ -83,7 +83,7 @@ pub const Glyph = struct { } pub fn format(self: Glyph) GlyphFormat { - return @enumFromInt(GlyphFormat, self.handle.*.format); + return @as(GlyphFormat, @enumFromInt(self.handle.*.format)); } pub fn advanceX(self: Glyph) isize { @@ -99,7 +99,7 @@ const SvgGlyph = struct { handle: c.FT_SvgGlyph, pub fn deinit(self: SvgGlyph) void { - c.FT_Done_Glyph(@ptrCast(c.FT_Glyph, self.handle)); + c.FT_Done_Glyph(@as(c.FT_Glyph, @ptrCast(self.handle))); } pub fn svgBuffer(self: SvgGlyph) []const u8 { @@ -143,7 +143,7 @@ pub const BitmapGlyph = struct { handle: c.FT_BitmapGlyph, pub fn deinit(self: BitmapGlyph) void { - c.FT_Done_Glyph(@ptrCast(c.FT_Glyph, self.handle)); + c.FT_Done_Glyph(@as(c.FT_Glyph, @ptrCast(self.handle))); } pub fn left(self: BitmapGlyph) i32 { @@ -163,7 +163,7 @@ pub const OutlineGlyph = struct { handle: c.FT_OutlineGlyph, pub fn deinit(self: OutlineGlyph) void { - c.FT_Done_Glyph(@ptrCast(c.FT_Glyph, self.handle)); + c.FT_Done_Glyph(@as(c.FT_Glyph, @ptrCast(self.handle))); } pub fn outline(self: OutlineGlyph) Outline { diff --git a/libs/freetype/src/harfbuzz/blob.zig b/libs/freetype/src/harfbuzz/blob.zig index 7c2c7ebd..57373a51 100644 --- a/libs/freetype/src/harfbuzz/blob.zig +++ b/libs/freetype/src/harfbuzz/blob.zig @@ -13,13 +13,13 @@ pub const Blob = struct { pub fn init(data: []u8, mode: MemoryMode) ?Blob { return Blob{ - .handle = c.hb_blob_create_or_fail(&data[0], @intCast(c_uint, data.len), @intFromEnum(mode), null, null) orelse return null, + .handle = c.hb_blob_create_or_fail(&data[0], @as(c_uint, @intCast(data.len)), @intFromEnum(mode), null, null) orelse return null, }; } pub fn initOrEmpty(data: []u8, mode: MemoryMode) Blob { return .{ - .handle = c.hb_blob_create(&data[0], @intCast(c_uint, data.len), @intFromEnum(mode), null, null).?, + .handle = c.hb_blob_create(&data[0], @as(c_uint, @intCast(data.len)), @intFromEnum(mode), null, null).?, }; } diff --git a/libs/freetype/src/harfbuzz/buffer.zig b/libs/freetype/src/harfbuzz/buffer.zig index f1ccfb5e..8edf67e3 100644 --- a/libs/freetype/src/harfbuzz/buffer.zig +++ b/libs/freetype/src/harfbuzz/buffer.zig @@ -31,7 +31,7 @@ pub const GlyphInfo = extern struct { var2: u32, pub fn getFlags(self: GlyphInfo) GlyphFlags { - return @bitCast(GlyphFlags, hb_glyph_info_get_glyph_flags(&self)); + return @as(GlyphFlags, @bitCast(hb_glyph_info_get_glyph_flags(&self))); } }; @@ -56,8 +56,8 @@ pub const SegmentProps = struct { pub fn from(c_struct: c.hb_segment_properties_t) SegmentProps { return .{ - .direction = @enumFromInt(Direction, c_struct.direction), - .script = @enumFromInt(Script, c_struct.script), + .direction = @as(Direction, @enumFromInt(c_struct.direction)), + .script = @as(Script, @enumFromInt(c_struct.script)), .language = Language{ .handle = c_struct.language }, }; } @@ -173,23 +173,23 @@ pub const Buffer = struct { } pub fn addCodepoints(self: Buffer, text: []const u32, item_offset: u32, item_length: ?u31) void { - c.hb_buffer_add_codepoints(self.handle, &text[0], @intCast(c_int, text.len), item_offset, if (item_length) |l| l else @intCast(c_int, text.len)); + c.hb_buffer_add_codepoints(self.handle, &text[0], @as(c_int, @intCast(text.len)), item_offset, if (item_length) |l| l else @as(c_int, @intCast(text.len))); } pub fn addUTF32(self: Buffer, text: []const u32, item_offset: u32, item_length: ?u31) void { - c.hb_buffer_add_utf32(self.handle, &text[0], @intCast(c_int, text.len), item_offset, if (item_length) |l| l else @intCast(c_int, text.len)); + c.hb_buffer_add_utf32(self.handle, &text[0], @as(c_int, @intCast(text.len)), item_offset, if (item_length) |l| l else @as(c_int, @intCast(text.len))); } pub fn addUTF16(self: Buffer, text: []const u16, item_offset: u32, item_length: ?u31) void { - c.hb_buffer_add_utf16(self.handle, &text[0], @intCast(c_int, text.len), item_offset, if (item_length) |l| l else @intCast(c_int, text.len)); + c.hb_buffer_add_utf16(self.handle, &text[0], @as(c_int, @intCast(text.len)), item_offset, if (item_length) |l| l else @as(c_int, @intCast(text.len))); } pub fn addUTF8(self: Buffer, text: []const u8, item_offset: u32, item_length: ?u31) void { - c.hb_buffer_add_utf8(self.handle, &text[0], @intCast(c_int, text.len), item_offset, if (item_length) |l| l else @intCast(c_int, text.len)); + c.hb_buffer_add_utf8(self.handle, &text[0], @as(c_int, @intCast(text.len)), item_offset, if (item_length) |l| l else @as(c_int, @intCast(text.len))); } pub fn addLatin1(self: Buffer, text: []const u8, item_offset: u32, item_length: ?u31) void { - c.hb_buffer_add_latin1(self.handle, &text[0], @intCast(c_int, text.len), item_offset, if (item_length) |l| l else @intCast(c_int, text.len)); + c.hb_buffer_add_latin1(self.handle, &text[0], @as(c_int, @intCast(text.len)), item_offset, if (item_length) |l| l else @as(c_int, @intCast(text.len))); } pub fn append(self: Buffer, source: Buffer, start: u32, end: u32) void { @@ -197,7 +197,7 @@ pub const Buffer = struct { } pub fn getContentType(self: Buffer) ContentType { - return @enumFromInt(ContentType, c.hb_buffer_get_content_type(self.handle)); + return @as(ContentType, @enumFromInt(c.hb_buffer_get_content_type(self.handle))); } pub fn setContentType(self: Buffer, content_type: ContentType) void { @@ -205,7 +205,7 @@ pub const Buffer = struct { } pub fn getDirection(self: Buffer) Direction { - return @enumFromInt(Direction, c.hb_buffer_get_direction(self.handle)); + return @as(Direction, @enumFromInt(c.hb_buffer_get_direction(self.handle))); } pub fn setDirection(self: Buffer, direction: Direction) void { @@ -213,7 +213,7 @@ pub const Buffer = struct { } pub fn getScript(self: Buffer) Script { - return @enumFromInt(Script, c.hb_buffer_get_script(self.handle)); + return @as(Script, @enumFromInt(c.hb_buffer_get_script(self.handle))); } pub fn setScript(self: Buffer, script: Script) void { @@ -229,15 +229,15 @@ pub const Buffer = struct { } pub fn getFlags(self: Buffer) Flags { - return @bitCast(Flags, c.hb_buffer_get_flags(self.handle)); + return @as(Flags, @bitCast(c.hb_buffer_get_flags(self.handle))); } pub fn setFlags(self: Buffer, flags: Flags) void { - c.hb_buffer_set_flags(self.handle, @bitCast(u32, flags)); + c.hb_buffer_set_flags(self.handle, @as(u32, @bitCast(flags))); } pub fn getClusterLevel(self: Buffer) ClusterLevel { - return @enumFromInt(ClusterLevel, c.hb_buffer_get_cluster_level(self.handle)); + return @as(ClusterLevel, @enumFromInt(c.hb_buffer_get_cluster_level(self.handle))); } pub fn setClusterLevel(self: Buffer, level: ClusterLevel) void { @@ -275,7 +275,7 @@ pub const Buffer = struct { pub fn getGlyphPositions(self: Buffer) ?[]Position { var length: u32 = 0; return if (hb_buffer_get_glyph_positions(self.handle, &length)) |positions| - @ptrCast([*]Position, positions)[0..length] + @as([*]Position, @ptrCast(positions))[0..length] else null; } @@ -325,7 +325,7 @@ pub const Buffer = struct { } pub fn diff(self: Buffer, ref: Buffer, dottedcircle_glyph: u32, position_fuzz: u32) DiffFlags { - return @bitCast(DiffFlags, c.hb_buffer_diff(self.handle, ref.handle, dottedcircle_glyph, position_fuzz)); + return @as(DiffFlags, @bitCast(c.hb_buffer_diff(self.handle, ref.handle, dottedcircle_glyph, position_fuzz))); } }; diff --git a/libs/freetype/src/harfbuzz/common.zig b/libs/freetype/src/harfbuzz/common.zig index 6fd6b6bc..147d1b05 100644 --- a/libs/freetype/src/harfbuzz/common.zig +++ b/libs/freetype/src/harfbuzz/common.zig @@ -9,11 +9,11 @@ pub const Direction = enum(u3) { bit = c.HB_DIRECTION_BTT, pub fn fromString(str: []const u8) Direction { - return @enumFromInt(Direction, c.hb_direction_from_string(str.ptr, @intCast(c_int, str.len))); + return @as(Direction, @enumFromInt(c.hb_direction_from_string(str.ptr, @as(c_int, @intCast(str.len))))); } pub fn toString(self: Direction) [:0]const u8 { - return std.mem.span(@ptrCast([*:0]const u8, c.hb_direction_to_string(@intFromEnum(self)))); + return std.mem.span(@as([*:0]const u8, @ptrCast(c.hb_direction_to_string(@intFromEnum(self))))); } }; @@ -184,11 +184,11 @@ pub const Script = enum(u31) { invalid = c.HB_SCRIPT_INVALID, pub fn fromISO15924Tag(tag: Tag) Script { - return @enumFromInt(Script, c.hb_script_from_iso15924_tag(tag.handle)); + return @as(Script, @enumFromInt(c.hb_script_from_iso15924_tag(tag.handle))); } pub fn fromString(str: []const u8) Script { - return @enumFromInt(Script, c.hb_script_from_string(str.ptr, @intCast(c_int, str.len))); + return @as(Script, @enumFromInt(c.hb_script_from_string(str.ptr, @as(c_int, @intCast(str.len))))); } pub fn toISO15924Tag(self: Script) Tag { @@ -196,7 +196,7 @@ pub const Script = enum(u31) { } pub fn getHorizontalDirection(self: Script) Direction { - return @enumFromInt(Direction, c.hb_script_get_horizontal_direction(@intFromEnum(self))); + return @as(Direction, @enumFromInt(c.hb_script_get_horizontal_direction(@intFromEnum(self)))); } }; @@ -205,12 +205,12 @@ pub const Language = struct { pub fn fromString(name: []const u8) Language { return .{ - .handle = c.hb_language_from_string(name.ptr, @intCast(c_int, name.len)), + .handle = c.hb_language_from_string(name.ptr, @as(c_int, @intCast(name.len))), }; } pub fn toString(self: Language) [:0]const u8 { - return std.mem.span(@ptrCast([*:0]const u8, c.hb_language_to_string(self.handle))); + return std.mem.span(@as([*:0]const u8, @ptrCast(c.hb_language_to_string(self.handle)))); } pub fn getDefault() Language { @@ -226,14 +226,14 @@ pub const Feature = extern struct { pub fn fromString(str: []const u8) ?Feature { var f: Feature = undefined; - return if (hb_feature_from_string(str.ptr, @intCast(c_int, str.len), &f) > 1) + return if (hb_feature_from_string(str.ptr, @as(c_int, @intCast(str.len)), &f) > 1) f else null; } pub fn toString(self: *Feature, buf: []u8) void { - hb_feature_to_string(self, buf.ptr, @intCast(c_uint, buf.len)); + hb_feature_to_string(self, buf.ptr, @as(c_uint, @intCast(buf.len))); } }; @@ -243,14 +243,14 @@ pub const Variation = extern struct { pub fn fromString(str: []const u8) ?Variation { var v: Variation = undefined; - return if (hb_variation_from_string(str.ptr, @intCast(c_int, str.len), &v) > 1) + return if (hb_variation_from_string(str.ptr, @as(c_int, @intCast(str.len)), &v) > 1) v else null; } pub fn toString(self: *Variation, buf: []u8) void { - hb_variation_to_string(self, buf.ptr, @intCast(c_uint, buf.len)); + hb_variation_to_string(self, buf.ptr, @as(c_uint, @intCast(buf.len))); } pub fn tag(self: Variation) Tag { @@ -266,7 +266,7 @@ pub const Tag = struct { handle: u32, pub fn fromString(str: []const u8) Tag { - return .{ .handle = c.hb_tag_from_string(str.ptr, @intCast(c_int, str.len)) }; + return .{ .handle = c.hb_tag_from_string(str.ptr, @as(c_int, @intCast(str.len))) }; } pub fn toString(self: Tag) []const u8 { diff --git a/libs/freetype/src/harfbuzz/font.zig b/libs/freetype/src/harfbuzz/font.zig index 829af644..2456c4dc 100644 --- a/libs/freetype/src/harfbuzz/font.zig +++ b/libs/freetype/src/harfbuzz/font.zig @@ -33,7 +33,7 @@ pub const Font = struct { } pub fn setFreetypeLoadFlags(self: Font, flags: freetype.LoadFlags) void { - c.hb_ft_font_set_load_flags(self.handle, @bitCast(i32, flags)); + c.hb_ft_font_set_load_flags(self.handle, @as(i32, @bitCast(flags))); } pub fn getFace(self: Font) Face { @@ -60,7 +60,7 @@ pub const Font = struct { var x: c_uint = 0; var y: c_uint = 0; c.hb_font_get_ppem(self.handle, &x, &y); - return @Vector(2, u32){ @intCast(u32, x), @intCast(u32, y) }; + return @Vector(2, u32){ @as(u32, @intCast(x)), @as(u32, @intCast(y)) }; } pub fn getPTEM(self: Font) f32 { @@ -71,7 +71,7 @@ pub const Font = struct { var x: c_int = 0; var y: c_int = 0; c.hb_font_get_scale(self.handle, &x, &y); - return @Vector(2, i32){ @intCast(i32, x), @intCast(i32, y) }; + return @Vector(2, i32){ @as(i32, @intCast(x)), @as(i32, @intCast(y)) }; } pub fn setFace(self: Font, face: Face) void { @@ -83,7 +83,7 @@ pub const Font = struct { self.handle, buf.handle, if (features) |f| f.ptr else null, - if (features) |f| @intCast(c_uint, f.len) else 0, + if (features) |f| @as(c_uint, @intCast(f.len)) else 0, ); } @@ -92,7 +92,7 @@ pub const Font = struct { self.handle, buf.handle, if (features) |f| f.ptr else null, - if (features) |f| @intCast(c_uint, f.len) else 0, + if (features) |f| @as(c_uint, @intCast(f.len)) else 0, shapers, ) < 1) return error.ShapingFailed; } diff --git a/libs/freetype/src/harfbuzz/shape_plan.zig b/libs/freetype/src/harfbuzz/shape_plan.zig index 66ec69c0..dadba3c1 100644 --- a/libs/freetype/src/harfbuzz/shape_plan.zig +++ b/libs/freetype/src/harfbuzz/shape_plan.zig @@ -15,7 +15,7 @@ pub const ShapePlan = struct { face.handle, &props.cast(), if (features) |f| f.ptr else null, - if (features) |f| @intCast(c_uint, f.len) else 0, + if (features) |f| @as(c_uint, @intCast(f.len)) else 0, shapers, ).? }; } @@ -25,7 +25,7 @@ pub const ShapePlan = struct { face.handle, &props.cast(), if (features) |f| f.ptr else null, - if (features) |f| @intCast(c_uint, f.len) else 0, + if (features) |f| @as(c_uint, @intCast(f.len)) else 0, shapers, ).? }; } @@ -35,9 +35,9 @@ pub const ShapePlan = struct { face.handle, &props.cast(), if (features) |f| f.ptr else null, - if (features) |f| @intCast(c_uint, f.len) else 0, + if (features) |f| @as(c_uint, @intCast(f.len)) else 0, cords.ptr, - @intCast(c_uint, cords.len), + @as(c_uint, @intCast(cords.len)), shapers, ).? }; } @@ -47,9 +47,9 @@ pub const ShapePlan = struct { face.handle, &props.cast(), if (features) |f| f.ptr else null, - if (features) |f| @intCast(c_uint, f.len) else 0, + if (features) |f| @as(c_uint, @intCast(f.len)) else 0, cords.ptr, - @intCast(c_uint, cords.len), + @as(c_uint, @intCast(cords.len)), shapers, ).? }; } @@ -64,12 +64,12 @@ pub const ShapePlan = struct { font.handle, buffer.handle, if (features) |f| f.ptr else null, - if (features) |f| @intCast(c_uint, f.len) else 0, + if (features) |f| @as(c_uint, @intCast(f.len)) else 0, ) < 1) return error.ShapingFailed; } pub fn getShaper(self: ShapePlan) [:0]const u8 { - return std.mem.span(@ptrCast([*:0]const u8, c.hb_shape_plan_get_shaper(self.handle))); + return std.mem.span(@as([*:0]const u8, @ptrCast(c.hb_shape_plan_get_shaper(self.handle)))); } }; diff --git a/libs/freetype/src/image.zig b/libs/freetype/src/image.zig index 34968c9d..cf85d20e 100644 --- a/libs/freetype/src/image.zig +++ b/libs/freetype/src/image.zig @@ -84,7 +84,7 @@ pub const Bitmap = struct { } pub fn pixelMode(self: Bitmap) PixelMode { - return @enumFromInt(PixelMode, self.handle.pixel_mode); + return @as(PixelMode, @enumFromInt(self.handle.pixel_mode)); } pub fn buffer(self: Bitmap) ?[]const u8 { @@ -122,11 +122,11 @@ pub const Outline = struct { handle: *c.FT_Outline, pub fn numPoints(self: Outline) u15 { - return @intCast(u15, self.handle.*.n_points); + return @as(u15, @intCast(self.handle.*.n_points)); } pub fn numContours(self: Outline) u15 { - return @intCast(u15, self.handle.*.n_contours); + return @as(u15, @intCast(self.handle.*.n_contours)); } pub fn points(self: Outline) []const Vector { @@ -134,7 +134,7 @@ pub const Outline = struct { } pub fn tags(self: Outline) []const u8 { - return self.handle.tags[0..@intCast(u15, self.handle.n_points)]; + return self.handle.tags[0..@as(u15, @intCast(self.handle.n_points))]; } pub fn contours(self: Outline) []const i16 { @@ -142,7 +142,7 @@ pub const Outline = struct { } pub fn flags(self: Outline) Flags { - return @bitCast(Flags, self.handle.*.flags); + return @as(Flags, @bitCast(self.handle.*.flags)); } pub fn copy(self: Outline) Error!Outline { @@ -188,15 +188,15 @@ pub const Outline = struct { } pub fn orientation(self: Outline) Orientation { - return @enumFromInt(Orientation, c.FT_Outline_Get_Orientation(self.handle)); + return @as(Orientation, @enumFromInt(c.FT_Outline_Get_Orientation(self.handle))); } pub fn getInsideBorder(self: Outline) Stroker.Border { - return @enumFromInt(Stroker.Border, c.FT_Outline_GetInsideBorder(self.handle)); + return @as(Stroker.Border, @enumFromInt(c.FT_Outline_GetInsideBorder(self.handle))); } pub fn getOutsideBorder(self: Outline) Stroker.Border { - return @enumFromInt(Stroker.Border, c.FT_Outline_GetOutsideBorder(self.handle)); + return @as(Stroker.Border, @enumFromInt(c.FT_Outline_GetOutsideBorder(self.handle))); } pub fn Funcs(comptime Context: type) type { @@ -217,7 +217,7 @@ pub const Outline = struct { callbacks: Funcs(Context), fn getSelf(ptr: ?*anyopaque) *Self { - return @ptrCast(*Self, @alignCast(@alignOf(Self), ptr)); + return @as(*Self, @ptrCast(@alignCast(@alignOf(Self), ptr))); } pub fn move_to(to: [*c]const c.FT_Vector, ctx: ?*anyopaque) callconv(.C) c_int { diff --git a/libs/glfw/src/Cursor.zig b/libs/glfw/src/Cursor.zig index 259c9724..cd79e884 100644 --- a/libs/glfw/src/Cursor.zig +++ b/libs/glfw/src/Cursor.zig @@ -115,7 +115,7 @@ pub const Shape = enum(i32) { pub inline fn create(image: Image, xhot: i32, yhot: i32) ?Cursor { internal_debug.assertInitialized(); const img = image.toC(); - if (c.glfwCreateCursor(&img, @intCast(c_int, xhot), @intCast(c_int, yhot))) |cursor| return Cursor{ .ptr = cursor }; + if (c.glfwCreateCursor(&img, @as(c_int, @intCast(xhot)), @as(c_int, @intCast(yhot)))) |cursor| return Cursor{ .ptr = cursor }; return null; } @@ -153,7 +153,7 @@ pub inline fn create(image: Image, xhot: i32, yhot: i32) ?Cursor { /// see also: cursor_object, glfwCreateCursor pub inline fn createStandard(shape: Shape) ?Cursor { internal_debug.assertInitialized(); - if (c.glfwCreateStandardCursor(@intCast(c_int, @intFromEnum(shape)))) |cursor| return Cursor{ .ptr = cursor }; + if (c.glfwCreateStandardCursor(@as(c_int, @intCast(@intFromEnum(shape))))) |cursor| return Cursor{ .ptr = cursor }; return null; } diff --git a/libs/glfw/src/GammaRamp.zig b/libs/glfw/src/GammaRamp.zig index bc33d0f8..7b5a1c3f 100644 --- a/libs/glfw/src/GammaRamp.zig +++ b/libs/glfw/src/GammaRamp.zig @@ -54,7 +54,7 @@ pub inline fn toC(self: GammaRamp) c.GLFWgammaramp { .red = &self.red[0], .green = &self.green[0], .blue = &self.blue[0], - .size = @intCast(c_uint, self.red.len), + .size = @as(c_uint, @intCast(self.red.len)), }; } diff --git a/libs/glfw/src/Image.zig b/libs/glfw/src/Image.zig index 01542972..d32e5c31 100644 --- a/libs/glfw/src/Image.zig +++ b/libs/glfw/src/Image.zig @@ -48,8 +48,8 @@ pub inline fn init(allocator: mem.Allocator, width: u32, height: u32, pixel_data /// 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), + .width = @as(u32, @intCast(native.width)), + .height = @as(u32, @intCast(native.height)), .pixels = native.pixels[0..pixel_data_len], .owned = false, }; @@ -60,8 +60,8 @@ pub inline fn fromC(native: c.GLFWimage, pixel_data_len: usize) Image { /// 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), + .width = @as(c_int, @intCast(self.width)), + .height = @as(c_int, @intCast(self.height)), .pixels = &self.pixels[0], }; } diff --git a/libs/glfw/src/Joystick.zig b/libs/glfw/src/Joystick.zig index 279ef864..fba46fd3 100644 --- a/libs/glfw/src/Joystick.zig +++ b/libs/glfw/src/Joystick.zig @@ -39,7 +39,7 @@ pub const Id = enum(c_int) { fourteen = c.GLFW_JOYSTICK_14, fifteen = c.GLFW_JOYSTICK_15, sixteen = c.GLFW_JOYSTICK_16, - pub const last = @enumFromInt(@This(), c.GLFW_JOYSTICK_LAST); + pub const last = @as(@This(), @enumFromInt(c.GLFW_JOYSTICK_LAST)); }; /// Gamepad input state @@ -60,12 +60,12 @@ const GamepadState = extern struct { /// Returns the state of the specified gamepad button. pub fn getButton(self: @This(), which: GamepadButton) Action { - return @enumFromInt(Action, self.buttons[@intCast(u32, @intFromEnum(which))]); + return @as(Action, @enumFromInt(self.buttons[@as(u32, @intCast(@intFromEnum(which)))])); } /// Returns the status of the specified gamepad axis, in the range -1.0 to 1.0 inclusive. pub fn getAxis(self: @This(), which: GamepadAxis) f32 { - return self.axes[@intCast(u32, @intFromEnum(which))]; + return self.axes[@as(u32, @intCast(@intFromEnum(which)))]; } }; @@ -115,7 +115,7 @@ pub inline fn getAxes(self: Joystick) ?[]const f32 { var count: c_int = undefined; const axes = c.glfwGetJoystickAxes(@intFromEnum(self.jid), &count); if (axes == null) return null; - return axes[0..@intCast(u32, count)]; + return axes[0..@as(u32, @intCast(count))]; } /// Returns the state of all buttons of the specified joystick. @@ -148,7 +148,7 @@ pub inline fn getButtons(self: Joystick) ?[]const u8 { var count: c_int = undefined; const buttons = c.glfwGetJoystickButtons(@intFromEnum(self.jid), &count); if (buttons == null) return null; - return buttons[0..@intCast(u32, count)]; + return buttons[0..@as(u32, @intCast(count))]; } /// Returns the state of all hats of the specified joystick. @@ -197,8 +197,8 @@ pub inline fn getHats(self: Joystick) ?[]const Hat { var count: c_int = undefined; const hats = c.glfwGetJoystickHats(@intFromEnum(self.jid), &count); if (hats == null) return null; - const slice = hats[0..@intCast(u32, count)]; - return @ptrCast(*const []const Hat, &slice).*; + const slice = hats[0..@as(u32, @intCast(count))]; + return @as(*const []const Hat, @ptrCast(&slice)).*; } /// Returns the name of the specified joystick. @@ -225,7 +225,7 @@ pub inline fn getName(self: Joystick) ?[:0]const u8 { internal_debug.assertInitialized(); const name_opt = c.glfwGetJoystickName(@intFromEnum(self.jid)); return if (name_opt) |name| - std.mem.span(@ptrCast([*:0]const u8, name)) + std.mem.span(@as([*:0]const u8, @ptrCast(name))) else null; } @@ -262,7 +262,7 @@ pub inline fn getGUID(self: Joystick) ?[:0]const u8 { internal_debug.assertInitialized(); const guid_opt = c.glfwGetJoystickGUID(@intFromEnum(self.jid)); return if (guid_opt) |guid| - std.mem.span(@ptrCast([*:0]const u8, guid)) + std.mem.span(@as([*:0]const u8, @ptrCast(guid))) else null; } @@ -279,7 +279,7 @@ pub inline fn getGUID(self: Joystick) ?[:0]const u8 { /// see also: joystick_userptr, glfw.Joystick.getUserPointer pub inline fn setUserPointer(self: Joystick, comptime T: type, pointer: *T) void { internal_debug.assertInitialized(); - c.glfwSetJoystickUserPointer(@intFromEnum(self.jid), @ptrCast(*anyopaque, pointer)); + c.glfwSetJoystickUserPointer(@intFromEnum(self.jid), @as(*anyopaque, @ptrCast(pointer))); } /// Returns the user pointer of the specified joystick. @@ -296,7 +296,7 @@ pub inline fn setUserPointer(self: Joystick, comptime T: type, pointer: *T) void pub inline fn getUserPointer(self: Joystick, comptime PointerType: type) ?PointerType { internal_debug.assertInitialized(); const ptr = c.glfwGetJoystickUserPointer(@intFromEnum(self.jid)); - if (ptr) |p| return @ptrCast(PointerType, @alignCast(@alignOf(std.meta.Child(PointerType)), p)); + if (ptr) |p| return @as(PointerType, @ptrCast(@alignCast(@alignOf(std.meta.Child(PointerType)), p))); return null; } @@ -335,8 +335,8 @@ pub inline fn setCallback(comptime callback: ?fn (joystick: Joystick, event: Eve const CWrapper = struct { pub fn joystickCallbackWrapper(jid: c_int, event: c_int) callconv(.C) void { @call(.always_inline, user_callback, .{ - Joystick{ .jid = @enumFromInt(Joystick.Id, jid) }, - @enumFromInt(Event, event), + Joystick{ .jid = @as(Joystick.Id, @enumFromInt(jid)) }, + @as(Event, @enumFromInt(event)), }); } }; @@ -424,7 +424,7 @@ pub inline fn getGamepadName(self: Joystick) ?[:0]const u8 { internal_debug.assertInitialized(); const name_opt = c.glfwGetGamepadName(@intFromEnum(self.jid)); return if (name_opt) |name| - std.mem.span(@ptrCast([*:0]const u8, name)) + std.mem.span(@as([*:0]const u8, @ptrCast(name))) else null; } @@ -457,7 +457,7 @@ pub inline fn getGamepadName(self: Joystick) ?[:0]const u8 { pub inline fn getGamepadState(self: Joystick) ?GamepadState { internal_debug.assertInitialized(); var state: GamepadState = undefined; - const success = c.glfwGetGamepadState(@intFromEnum(self.jid), @ptrCast(*c.GLFWgamepadstate, &state)); + const success = c.glfwGetGamepadState(@intFromEnum(self.jid), @as(*c.GLFWgamepadstate, @ptrCast(&state))); return if (success == c.GLFW_TRUE) state else null; } diff --git a/libs/glfw/src/Monitor.zig b/libs/glfw/src/Monitor.zig index 275e9218..56beca93 100644 --- a/libs/glfw/src/Monitor.zig +++ b/libs/glfw/src/Monitor.zig @@ -35,7 +35,7 @@ pub inline fn getPos(self: Monitor) Pos { var xpos: c_int = 0; var ypos: c_int = 0; c.glfwGetMonitorPos(self.handle, &xpos, &ypos); - return Pos{ .x = @intCast(u32, xpos), .y = @intCast(u32, ypos) }; + return Pos{ .x = @as(u32, @intCast(xpos)), .y = @as(u32, @intCast(ypos)) }; } /// The monitor workarea, in screen coordinates. @@ -66,7 +66,7 @@ pub inline fn getWorkarea(self: Monitor) Workarea { var width: c_int = 0; var height: c_int = 0; c.glfwGetMonitorWorkarea(self.handle, &xpos, &ypos, &width, &height); - return Workarea{ .x = @intCast(u32, xpos), .y = @intCast(u32, ypos), .width = @intCast(u32, width), .height = @intCast(u32, height) }; + return Workarea{ .x = @as(u32, @intCast(xpos)), .y = @as(u32, @intCast(ypos)), .width = @as(u32, @intCast(width)), .height = @as(u32, @intCast(height)) }; } /// The physical size, in millimetres, of the display area of a monitor. @@ -91,7 +91,7 @@ pub inline fn getPhysicalSize(self: Monitor) PhysicalSize { var width_mm: c_int = 0; var height_mm: c_int = 0; c.glfwGetMonitorPhysicalSize(self.handle, &width_mm, &height_mm); - return PhysicalSize{ .width_mm = @intCast(u32, width_mm), .height_mm = @intCast(u32, height_mm) }; + return PhysicalSize{ .width_mm = @as(u32, @intCast(width_mm)), .height_mm = @as(u32, @intCast(height_mm)) }; } /// The content scale for a monitor. @@ -123,7 +123,7 @@ pub inline fn getContentScale(self: Monitor) ContentScale { var x_scale: f32 = 0; var y_scale: f32 = 0; c.glfwGetMonitorContentScale(self.handle, &x_scale, &y_scale); - return ContentScale{ .x_scale = @floatCast(f32, x_scale), .y_scale = @floatCast(f32, y_scale) }; + return ContentScale{ .x_scale = @as(f32, @floatCast(x_scale)), .y_scale = @as(f32, @floatCast(y_scale)) }; } /// Returns the name of the specified monitor. @@ -140,7 +140,7 @@ pub inline fn getContentScale(self: Monitor) ContentScale { /// see also: monitor_properties pub inline fn getName(self: Monitor) [*:0]const u8 { internal_debug.assertInitialized(); - if (c.glfwGetMonitorName(self.handle)) |name| return @ptrCast([*:0]const u8, name); + if (c.glfwGetMonitorName(self.handle)) |name| return @as([*:0]const u8, @ptrCast(name)); // `glfwGetMonitorName` returns `null` only for errors, but the only error is unreachable // (NotInitialized) unreachable; @@ -176,7 +176,7 @@ pub inline fn getUserPointer(self: Monitor, comptime T: type) ?*T { internal_debug.assertInitialized(); const ptr = c.glfwGetMonitorUserPointer(self.handle); if (ptr == null) return null; - return @ptrCast(*T, @alignCast(@alignOf(T), ptr.?)); + return @as(*T, @ptrCast(@alignCast(@alignOf(T), ptr.?))); } /// Returns the available video modes for the specified monitor. @@ -200,10 +200,10 @@ pub inline fn getVideoModes(self: Monitor, allocator: mem.Allocator) mem.Allocat internal_debug.assertInitialized(); var count: c_int = 0; if (c.glfwGetVideoModes(self.handle, &count)) |modes| { - const slice = try allocator.alloc(VideoMode, @intCast(u32, count)); + const slice = try allocator.alloc(VideoMode, @as(u32, @intCast(count))); var i: u32 = 0; while (i < count) : (i += 1) { - slice[i] = VideoMode{ .handle = @ptrCast([*c]const c.GLFWvidmode, modes)[i] }; + slice[i] = VideoMode{ .handle = @as([*c]const c.GLFWvidmode, @ptrCast(modes))[i] }; } return slice; } @@ -325,10 +325,10 @@ pub inline fn getAll(allocator: mem.Allocator) mem.Allocator.Error![]Monitor { internal_debug.assertInitialized(); var count: c_int = 0; if (c.glfwGetMonitors(&count)) |monitors| { - const slice = try allocator.alloc(Monitor, @intCast(u32, count)); + const slice = try allocator.alloc(Monitor, @as(u32, @intCast(count))); var i: u32 = 0; while (i < count) : (i += 1) { - slice[i] = Monitor{ .handle = @ptrCast([*c]const ?*c.GLFWmonitor, monitors)[i].? }; + slice[i] = Monitor{ .handle = @as([*c]const ?*c.GLFWmonitor, @ptrCast(monitors))[i].? }; } return slice; } @@ -387,7 +387,7 @@ pub inline fn setCallback(comptime callback: ?fn (monitor: Monitor, event: Event pub fn monitorCallbackWrapper(monitor: ?*c.GLFWmonitor, event: c_int) callconv(.C) void { @call(.always_inline, user_callback, .{ Monitor{ .handle = monitor.? }, - @enumFromInt(Event, event), + @as(Event, @enumFromInt(event)), }); } }; diff --git a/libs/glfw/src/VideoMode.zig b/libs/glfw/src/VideoMode.zig index 054d515d..f433b8d0 100644 --- a/libs/glfw/src/VideoMode.zig +++ b/libs/glfw/src/VideoMode.zig @@ -11,32 +11,32 @@ handle: c.GLFWvidmode, /// Returns the width of the video mode, in screen coordinates. pub inline fn getWidth(self: VideoMode) u32 { - return @intCast(u32, self.handle.width); + return @as(u32, @intCast(self.handle.width)); } /// Returns the height of the video mode, in screen coordinates. pub inline fn getHeight(self: VideoMode) u32 { - return @intCast(u32, self.handle.height); + return @as(u32, @intCast(self.handle.height)); } /// Returns the bit depth of the red channel of the video mode. pub inline fn getRedBits(self: VideoMode) u32 { - return @intCast(u32, self.handle.redBits); + return @as(u32, @intCast(self.handle.redBits)); } /// Returns the bit depth of the green channel of the video mode. pub inline fn getGreenBits(self: VideoMode) u32 { - return @intCast(u32, self.handle.greenBits); + return @as(u32, @intCast(self.handle.greenBits)); } /// Returns the bit depth of the blue channel of the video mode. pub inline fn getBlueBits(self: VideoMode) u32 { - return @intCast(u32, self.handle.blueBits); + return @as(u32, @intCast(self.handle.blueBits)); } /// Returns the refresh rate of the video mode, in Hz. pub inline fn getRefreshRate(self: VideoMode) u32 { - return @intCast(u32, self.handle.refreshRate); + return @as(u32, @intCast(self.handle.refreshRate)); } test "getters" { diff --git a/libs/glfw/src/Window.zig b/libs/glfw/src/Window.zig index 0e7c5650..c6b4dce5 100644 --- a/libs/glfw/src/Window.zig +++ b/libs/glfw/src/Window.zig @@ -22,7 +22,7 @@ handle: *c.GLFWwindow, /// Returns a Zig GLFW window from an underlying C GLFW window handle. pub inline fn from(handle: *anyopaque) Window { - return Window{ .handle = @ptrCast(*c.GLFWwindow, @alignCast(@alignOf(*c.GLFWwindow), handle)) }; + return Window{ .handle = @as(*c.GLFWwindow, @ptrCast(@alignCast(@alignOf(*c.GLFWwindow), handle))) }; } /// Resets all window hints to their default values. @@ -378,8 +378,8 @@ pub inline fn create( if (!ignore_hints_struct) hints.set(); if (c.glfwCreateWindow( - @intCast(c_int, width), - @intCast(c_int, height), + @as(c_int, @intCast(width)), + @as(c_int, @intCast(height)), &title[0], if (monitor) |m| m.handle else null, if (share) |w| w.handle else null, @@ -489,7 +489,7 @@ pub inline fn setIcon(self: Window, allocator: mem.Allocator, images: ?[]const I const tmp = try allocator.alloc(c.GLFWimage, im.len); defer allocator.free(tmp); for (im, 0..) |img, index| tmp[index] = img.toC(); - c.glfwSetWindowIcon(self.handle, @intCast(c_int, im.len), &tmp[0]); + c.glfwSetWindowIcon(self.handle, @as(c_int, @intCast(im.len)), &tmp[0]); } else c.glfwSetWindowIcon(self.handle, 0, null); } @@ -517,7 +517,7 @@ pub inline fn getPos(self: Window) Pos { var x: c_int = 0; var y: c_int = 0; c.glfwGetWindowPos(self.handle, &x, &y); - return Pos{ .x = @intCast(i64, x), .y = @intCast(i64, y) }; + return Pos{ .x = @as(i64, @intCast(x)), .y = @as(i64, @intCast(y)) }; } /// Sets the position of the content area of the specified window. @@ -542,7 +542,7 @@ pub inline fn getPos(self: Window) Pos { /// see also: window_pos, glfw.Window.getPos pub inline fn setPos(self: Window, pos: Pos) void { internal_debug.assertInitialized(); - c.glfwSetWindowPos(self.handle, @intCast(c_int, pos.x), @intCast(c_int, pos.y)); + c.glfwSetWindowPos(self.handle, @as(c_int, @intCast(pos.x)), @as(c_int, @intCast(pos.y))); } pub const Size = struct { @@ -567,7 +567,7 @@ pub inline fn getSize(self: Window) Size { var width: c_int = 0; var height: c_int = 0; c.glfwGetWindowSize(self.handle, &width, &height); - return Size{ .width = @intCast(u32, width), .height = @intCast(u32, height) }; + return Size{ .width = @as(u32, @intCast(width)), .height = @as(u32, @intCast(height)) }; } /// Sets the size of the content area of the specified window. @@ -594,7 +594,7 @@ pub inline fn getSize(self: Window) Size { /// see also: window_size, glfw.Window.getSize, glfw.Window.SetMonitor pub inline fn setSize(self: Window, size: Size) void { internal_debug.assertInitialized(); - c.glfwSetWindowSize(self.handle, @intCast(c_int, size.width), @intCast(c_int, size.height)); + c.glfwSetWindowSize(self.handle, @as(c_int, @intCast(size.width)), @as(c_int, @intCast(size.height))); } /// A size with option width/height, used to represent e.g. constraints on a windows size while @@ -637,10 +637,10 @@ pub inline fn setSizeLimits(self: Window, min: SizeOptional, max: SizeOptional) c.glfwSetWindowSizeLimits( self.handle, - if (min.width) |min_width| @intCast(c_int, min_width) else glfw.dont_care, - if (min.height) |min_height| @intCast(c_int, min_height) else glfw.dont_care, - if (max.width) |max_width| @intCast(c_int, max_width) else glfw.dont_care, - if (max.height) |max_height| @intCast(c_int, max_height) else glfw.dont_care, + if (min.width) |min_width| @as(c_int, @intCast(min_width)) else glfw.dont_care, + if (min.height) |min_height| @as(c_int, @intCast(min_height)) else glfw.dont_care, + if (max.width) |max_width| @as(c_int, @intCast(max_width)) else glfw.dont_care, + if (max.height) |max_height| @as(c_int, @intCast(max_height)) else glfw.dont_care, ); } @@ -681,8 +681,8 @@ pub inline fn setAspectRatio(self: Window, numerator: ?u32, denominator: ?u32) v c.glfwSetWindowAspectRatio( self.handle, - if (numerator) |numerator_unwrapped| @intCast(c_int, numerator_unwrapped) else glfw.dont_care, - if (denominator) |denominator_unwrapped| @intCast(c_int, denominator_unwrapped) else glfw.dont_care, + if (numerator) |numerator_unwrapped| @as(c_int, @intCast(numerator_unwrapped)) else glfw.dont_care, + if (denominator) |denominator_unwrapped| @as(c_int, @intCast(denominator_unwrapped)) else glfw.dont_care, ); } @@ -702,7 +702,7 @@ pub inline fn getFramebufferSize(self: Window) Size { var width: c_int = 0; var height: c_int = 0; c.glfwGetFramebufferSize(self.handle, &width, &height); - return Size{ .width = @intCast(u32, width), .height = @intCast(u32, height) }; + return Size{ .width = @as(u32, @intCast(width)), .height = @as(u32, @intCast(height)) }; } pub const FrameSize = struct { @@ -735,10 +735,10 @@ pub inline fn getFrameSize(self: Window) FrameSize { var bottom: c_int = 0; c.glfwGetWindowFrameSize(self.handle, &left, &top, &right, &bottom); return FrameSize{ - .left = @intCast(u32, left), - .top = @intCast(u32, top), - .right = @intCast(u32, right), - .bottom = @intCast(u32, bottom), + .left = @as(u32, @intCast(left)), + .top = @as(u32, @intCast(top)), + .right = @as(u32, @intCast(right)), + .bottom = @as(u32, @intCast(bottom)), }; } @@ -1046,11 +1046,11 @@ pub inline fn setMonitor(self: Window, monitor: ?Monitor, xpos: i32, ypos: i32, c.glfwSetWindowMonitor( self.handle, if (monitor) |m| m.handle else null, - @intCast(c_int, xpos), - @intCast(c_int, ypos), - @intCast(c_int, width), - @intCast(c_int, height), - if (refresh_rate) |refresh_rate_unwrapped| @intCast(c_int, refresh_rate_unwrapped) else glfw.dont_care, + @as(c_int, @intCast(xpos)), + @as(c_int, @intCast(ypos)), + @as(c_int, @intCast(width)), + @as(c_int, @intCast(height)), + if (refresh_rate) |refresh_rate_unwrapped| @as(c_int, @intCast(refresh_rate_unwrapped)) else glfw.dont_care, ); } @@ -1174,7 +1174,7 @@ pub inline fn setUserPointer(self: Window, pointer: ?*anyopaque) void { /// see also: window_userptr, glfw.Window.setUserPointer pub inline fn getUserPointer(self: Window, comptime T: type) ?*T { internal_debug.assertInitialized(); - if (c.glfwGetWindowUserPointer(self.handle)) |user_pointer| return @ptrCast(?*T, @alignCast(@alignOf(T), user_pointer)); + if (c.glfwGetWindowUserPointer(self.handle)) |user_pointer| return @as(?*T, @ptrCast(@alignCast(@alignOf(T), user_pointer))); return null; } @@ -1206,8 +1206,8 @@ pub inline fn setPosCallback(self: Window, comptime callback: ?fn (window: Windo pub fn posCallbackWrapper(handle: ?*c.GLFWwindow, xpos: c_int, ypos: c_int) callconv(.C) void { @call(.always_inline, user_callback, .{ from(handle.?), - @intCast(i32, xpos), - @intCast(i32, ypos), + @as(i32, @intCast(xpos)), + @as(i32, @intCast(ypos)), }); } }; @@ -1239,8 +1239,8 @@ pub inline fn setSizeCallback(self: Window, comptime callback: ?fn (window: Wind pub fn sizeCallbackWrapper(handle: ?*c.GLFWwindow, width: c_int, height: c_int) callconv(.C) void { @call(.always_inline, user_callback, .{ from(handle.?), - @intCast(i32, width), - @intCast(i32, height), + @as(i32, @intCast(width)), + @as(i32, @intCast(height)), }); } }; @@ -1459,8 +1459,8 @@ pub inline fn setFramebufferSizeCallback(self: Window, comptime callback: ?fn (w pub fn framebufferSizeCallbackWrapper(handle: ?*c.GLFWwindow, width: c_int, height: c_int) callconv(.C) void { @call(.always_inline, user_callback, .{ from(handle.?), - @intCast(u32, width), - @intCast(u32, height), + @as(u32, @intCast(width)), + @as(u32, @intCast(height)), }); } }; @@ -1541,7 +1541,7 @@ pub inline fn setInputModeCursor(self: Window, value: InputModeCursor) void { /// Gets the current input mode of the cursor. pub inline fn getInputModeCursor(self: Window) InputModeCursor { - return @enumFromInt(InputModeCursor, self.getInputMode(InputMode.cursor)); + return @as(InputModeCursor, @enumFromInt(self.getInputMode(InputMode.cursor))); } /// Sets the input mode of sticky keys, if enabled a key press will ensure that `glfw.Window.getKey` @@ -1623,7 +1623,7 @@ pub inline fn getInputModeRawMouseMotion(self: Window) bool { pub inline fn getInputMode(self: Window, mode: InputMode) i32 { internal_debug.assertInitialized(); const value = c.glfwGetInputMode(self.handle, @intFromEnum(mode)); - return @intCast(i32, value); + return @as(i32, @intCast(value)); } /// Sets an input option for the specified window. @@ -1693,7 +1693,7 @@ pub inline fn setInputMode(self: Window, mode: InputMode, value: anytype) void { pub inline fn getKey(self: Window, key: Key) Action { internal_debug.assertInitialized(); const state = c.glfwGetKey(self.handle, @intFromEnum(key)); - return @enumFromInt(Action, state); + return @as(Action, @enumFromInt(state)); } /// Returns the last reported state of a mouse button for the specified window. @@ -1715,7 +1715,7 @@ pub inline fn getKey(self: Window, key: Key) Action { pub inline fn getMouseButton(self: Window, button: MouseButton) Action { internal_debug.assertInitialized(); const state = c.glfwGetMouseButton(self.handle, @intFromEnum(button)); - return @enumFromInt(Action, state); + return @as(Action, @enumFromInt(state)); } pub const CursorPos = struct { @@ -1848,9 +1848,9 @@ pub inline fn setKeyCallback(self: Window, comptime callback: ?fn (window: Windo pub fn keyCallbackWrapper(handle: ?*c.GLFWwindow, key: c_int, scancode: c_int, action: c_int, mods: c_int) callconv(.C) void { @call(.always_inline, user_callback, .{ from(handle.?), - @enumFromInt(Key, key), - @intCast(i32, scancode), - @enumFromInt(Action, action), + @as(Key, @enumFromInt(key)), + @as(i32, @intCast(scancode)), + @as(Action, @enumFromInt(action)), Mods.fromInt(mods), }); } @@ -1894,7 +1894,7 @@ pub inline fn setCharCallback(self: Window, comptime callback: ?fn (window: Wind pub fn charCallbackWrapper(handle: ?*c.GLFWwindow, codepoint: c_uint) callconv(.C) void { @call(.always_inline, user_callback, .{ from(handle.?), - @intCast(u21, codepoint), + @as(u21, @intCast(codepoint)), }); } }; @@ -1935,8 +1935,8 @@ pub inline fn setMouseButtonCallback(self: Window, comptime callback: ?fn (windo pub fn mouseButtonCallbackWrapper(handle: ?*c.GLFWwindow, button: c_int, action: c_int, mods: c_int) callconv(.C) void { @call(.always_inline, user_callback, .{ from(handle.?), - @enumFromInt(MouseButton, button), - @enumFromInt(Action, action), + @as(MouseButton, @enumFromInt(button)), + @as(Action, @enumFromInt(action)), Mods.fromInt(mods), }); } @@ -2087,7 +2087,7 @@ pub inline fn setDropCallback(self: Window, comptime callback: ?fn (window: Wind pub fn dropCallbackWrapper(handle: ?*c.GLFWwindow, path_count: c_int, paths: [*c][*c]const u8) callconv(.C) void { @call(.always_inline, user_callback, .{ from(handle.?), - @ptrCast([*][*:0]const u8, paths)[0..@intCast(u32, path_count)], + @as([*][*:0]const u8, @ptrCast(paths))[0..@as(u32, @intCast(path_count))], }); } }; @@ -2125,15 +2125,15 @@ inline fn hint(h: Hint, value: anytype) void { switch (value_type_info) { .Int, .ComptimeInt => { - c.glfwWindowHint(@intFromEnum(h), @intCast(c_int, value)); + c.glfwWindowHint(@intFromEnum(h), @as(c_int, @intCast(value))); }, .Bool => { const int_value = @intFromBool(value); - c.glfwWindowHint(@intFromEnum(h), @intCast(c_int, int_value)); + c.glfwWindowHint(@intFromEnum(h), @as(c_int, @intCast(int_value))); }, .Enum => { const int_value = @intFromEnum(value); - c.glfwWindowHint(@intFromEnum(h), @intCast(c_int, int_value)); + c.glfwWindowHint(@intFromEnum(h), @as(c_int, @intCast(int_value))); }, .Array => |arr_type| { if (arr_type.child != u8) { diff --git a/libs/glfw/src/clipboard.zig b/libs/glfw/src/clipboard.zig index 1c2ac532..a7e2d0e2 100644 --- a/libs/glfw/src/clipboard.zig +++ b/libs/glfw/src/clipboard.zig @@ -42,7 +42,7 @@ pub inline fn setClipboardString(value: [*:0]const u8) void { /// see also: clipboard, glfwSetClipboardString pub inline fn getClipboardString() ?[:0]const u8 { internal_debug.assertInitialized(); - if (c.glfwGetClipboardString(null)) |c_str| return std.mem.span(@ptrCast([*:0]const u8, c_str)); + if (c.glfwGetClipboardString(null)) |c_str| return std.mem.span(@as([*:0]const u8, @ptrCast(c_str))); return null; } diff --git a/libs/glfw/src/hat.zig b/libs/glfw/src/hat.zig index 270aeb0a..dd45e509 100644 --- a/libs/glfw/src/hat.zig +++ b/libs/glfw/src/hat.zig @@ -26,12 +26,12 @@ pub const Hat = packed struct(u8) { pub inline fn toInt(self: Hat, comptime IntType: type) IntType { verifyIntType(IntType); - return @intCast(IntType, @bitCast(u8, self)); + return @as(IntType, @intCast(@as(u8, @bitCast(self)))); } pub inline fn fromInt(flags: anytype) Hat { verifyIntType(@TypeOf(flags)); - return @bitCast(Hat, @intCast(u8, flags)); + return @as(Hat, @bitCast(@as(u8, @intCast(flags)))); } }; diff --git a/libs/glfw/src/key.zig b/libs/glfw/src/key.zig index f00f4426..27b13119 100644 --- a/libs/glfw/src/key.zig +++ b/libs/glfw/src/key.zig @@ -150,7 +150,7 @@ pub const Key = enum(c_int) { menu = cc.GLFW_KEY_MENU, pub inline fn last() Key { - return @enumFromInt(Key, cc.GLFW_KEY_LAST); + return @as(Key, @enumFromInt(cc.GLFW_KEY_LAST)); } /// Returns the layout-specific name of the specified printable key. @@ -215,9 +215,9 @@ pub const Key = enum(c_int) { /// see also: input_key_name pub inline fn getName(self: Key, scancode: i32) ?[:0]const u8 { internal_debug.assertInitialized(); - const name_opt = cc.glfwGetKeyName(@intFromEnum(self), @intCast(c_int, scancode)); + const name_opt = cc.glfwGetKeyName(@intFromEnum(self), @as(c_int, @intCast(scancode))); return if (name_opt) |name| - std.mem.span(@ptrCast([*:0]const u8, name)) + std.mem.span(@as([*:0]const u8, @ptrCast(name))) else null; } diff --git a/libs/glfw/src/main.zig b/libs/glfw/src/main.zig index 3cee7cce..b94e4e35 100644 --- a/libs/glfw/src/main.zig +++ b/libs/glfw/src/main.zig @@ -273,9 +273,9 @@ pub const PlatformType = enum(c_int) { fn initHint(hint: InitHint, value: anytype) void { switch (@typeInfo(@TypeOf(value))) { .Int, .ComptimeInt => { - c.glfwInitHint(@intFromEnum(hint), @intCast(c_int, value)); + c.glfwInitHint(@intFromEnum(hint), @as(c_int, @intCast(value))); }, - .Bool => c.glfwInitHint(@intFromEnum(hint), @intCast(c_int, @intFromBool(value))), + .Bool => c.glfwInitHint(@intFromEnum(hint), @as(c_int, @intCast(@intFromBool(value)))), else => @compileError("expected a int or bool, got " ++ @typeName(@TypeOf(value))), } } @@ -301,7 +301,7 @@ fn initHint(hint: InitHint, value: anytype) void { /// /// thread_safety: This function may be called from any thread. pub inline fn getVersionString() [:0]const u8 { - return std.mem.span(@ptrCast([*:0]const u8, c.glfwGetVersionString())); + return std.mem.span(@as([*:0]const u8, @ptrCast(c.glfwGetVersionString()))); } /// Returns the currently selected platform. @@ -313,7 +313,7 @@ pub inline fn getVersionString() [:0]const u8 { /// thread_safety: This function may be called from any thread. pub fn getPlatform() PlatformType { internal_debug.assertInitialized(); - return @enumFromInt(PlatformType, c.glfwGetPlatform()); + return @as(PlatformType, @enumFromInt(c.glfwGetPlatform())); } /// Returns whether the library includes support for the specified platform. diff --git a/libs/glfw/src/mod.zig b/libs/glfw/src/mod.zig index 4d7711c8..800f9575 100644 --- a/libs/glfw/src/mod.zig +++ b/libs/glfw/src/mod.zig @@ -26,12 +26,12 @@ pub const Mods = packed struct(u8) { pub inline fn toInt(self: Mods, comptime IntType: type) IntType { verifyIntType(IntType); - return @intCast(IntType, @bitCast(u8, self)); + return @as(IntType, @intCast(@as(u8, @bitCast(self)))); } pub inline fn fromInt(flags: anytype) Mods { verifyIntType(@TypeOf(flags)); - return @bitCast(Mods, @intCast(u8, flags)); + return @as(Mods, @bitCast(@as(u8, @intCast(flags)))); } }; diff --git a/libs/glfw/src/native.zig b/libs/glfw/src/native.zig index 51e1fb99..6abdf828 100644 --- a/libs/glfw/src/native.zig +++ b/libs/glfw/src/native.zig @@ -61,7 +61,7 @@ pub fn Native(comptime options: BackendOptions) type { /// thread_safety: This function may be called from any thread. Access is not synchronized. pub fn getWin32Adapter(monitor: Monitor) [*:0]const u8 { internal_debug.assertInitialized(); - if (native.glfwGetWin32Adapter(@ptrCast(*native.GLFWmonitor, monitor.handle))) |adapter| return adapter; + if (native.glfwGetWin32Adapter(@as(*native.GLFWmonitor, @ptrCast(monitor.handle)))) |adapter| return adapter; // `glfwGetWin32Adapter` returns `null` only for errors // but the only potential error is unreachable (NotInitialized) unreachable; @@ -75,7 +75,7 @@ pub fn Native(comptime options: BackendOptions) type { /// thread_safety: This function may be called from any thread. Access is not synchronized. pub fn getWin32Monitor(monitor: Monitor) [*:0]const u8 { internal_debug.assertInitialized(); - if (native.glfwGetWin32Monitor(@ptrCast(*native.GLFWmonitor, monitor.handle))) |mon| return mon; + if (native.glfwGetWin32Monitor(@as(*native.GLFWmonitor, @ptrCast(monitor.handle)))) |mon| return mon; // `glfwGetWin32Monitor` returns `null` only for errors // but the only potential error is unreachable (NotInitialized) unreachable; @@ -94,8 +94,8 @@ pub fn Native(comptime options: BackendOptions) type { /// thread_safety: This function may be called from any thread. Access is not synchronized. pub fn getWin32Window(window: Window) std.os.windows.HWND { internal_debug.assertInitialized(); - if (native.glfwGetWin32Window(@ptrCast(*native.GLFWwindow, window.handle))) |win| - return @ptrCast(std.os.windows.HWND, win); + if (native.glfwGetWin32Window(@as(*native.GLFWwindow, @ptrCast(window.handle)))) |win| + return @as(std.os.windows.HWND, @ptrCast(win)); // `glfwGetWin32Window` returns `null` only for errors // but the only potential error is unreachable (NotInitialized) unreachable; @@ -117,7 +117,7 @@ pub fn Native(comptime options: BackendOptions) type { /// thread_safety: This function may be called from any thread. Access is not synchronized. pub fn getWGLContext(window: Window) ?std.os.windows.HGLRC { internal_debug.assertInitialized(); - if (native.glfwGetWGLContext(@ptrCast(*native.GLFWwindow, window.handle))) |context| return context; + if (native.glfwGetWGLContext(@as(*native.GLFWwindow, @ptrCast(window.handle)))) |context| return context; return null; } @@ -126,7 +126,7 @@ pub fn Native(comptime options: BackendOptions) type { /// thread_safety: This function may be called from any thread. Access is not synchronized. pub fn getCocoaMonitor(monitor: Monitor) u32 { internal_debug.assertInitialized(); - const mon = native.glfwGetCocoaMonitor(@ptrCast(*native.GLFWmonitor, monitor.handle)); + const mon = native.glfwGetCocoaMonitor(@as(*native.GLFWmonitor, @ptrCast(monitor.handle))); if (mon != native.kCGNullDirectDisplay) return mon; // `glfwGetCocoaMonitor` returns `kCGNullDirectDisplay` only for errors // but the only potential error is unreachable (NotInitialized) @@ -138,7 +138,7 @@ pub fn Native(comptime options: BackendOptions) type { /// thread_safety: This function may be called from any thread. Access is not synchronized. pub fn getCocoaWindow(window: Window) ?*anyopaque { internal_debug.assertInitialized(); - return native.glfwGetCocoaWindow(@ptrCast(*native.GLFWwindow, window.handle)); + return native.glfwGetCocoaWindow(@as(*native.GLFWwindow, @ptrCast(window.handle))); } /// Returns the `NSWindow` of the specified window. @@ -148,7 +148,7 @@ pub fn Native(comptime options: BackendOptions) type { /// thread_safety: This function may be called from any thread. Access is not synchronized. pub fn getNSGLContext(window: Window) u32 { internal_debug.assertInitialized(); - return native.glfwGetNSGLContext(@ptrCast(*native.GLFWwindow, window.handle)); + return native.glfwGetNSGLContext(@as(*native.GLFWwindow, @ptrCast(window.handle))); } /// Returns the `Display` used by GLFW. @@ -156,7 +156,7 @@ pub fn Native(comptime options: BackendOptions) type { /// thread_safety: This function may be called from any thread. Access is not synchronized. pub fn getX11Display() *anyopaque { internal_debug.assertInitialized(); - if (native.glfwGetX11Display()) |display| return @ptrCast(*anyopaque, display); + if (native.glfwGetX11Display()) |display| return @as(*anyopaque, @ptrCast(display)); // `glfwGetX11Display` returns `null` only for errors // but the only potential error is unreachable (NotInitialized) unreachable; @@ -167,7 +167,7 @@ pub fn Native(comptime options: BackendOptions) type { /// thread_safety: This function may be called from any thread. Access is not synchronized. pub fn getX11Adapter(monitor: Monitor) u32 { internal_debug.assertInitialized(); - const adapter = native.glfwGetX11Adapter(@ptrCast(*native.GLFWMonitor, monitor.handle)); + const adapter = native.glfwGetX11Adapter(@as(*native.GLFWMonitor, @ptrCast(monitor.handle))); if (adapter != 0) return adapter; // `glfwGetX11Adapter` returns `0` only for errors // but the only potential error is unreachable (NotInitialized) @@ -179,7 +179,7 @@ pub fn Native(comptime options: BackendOptions) type { /// thread_safety: This function may be called from any thread. Access is not synchronized. pub fn getX11Monitor(monitor: Monitor) u32 { internal_debug.assertInitialized(); - const mon = native.glfwGetX11Monitor(@ptrCast(*native.GLFWmonitor, monitor.handle)); + const mon = native.glfwGetX11Monitor(@as(*native.GLFWmonitor, @ptrCast(monitor.handle))); if (mon != 0) return mon; // `glfwGetX11Monitor` returns `0` only for errors // but the only potential error is unreachable (NotInitialized) @@ -191,8 +191,8 @@ pub fn Native(comptime options: BackendOptions) type { /// thread_safety: This function may be called from any thread. Access is not synchronized. pub fn getX11Window(window: Window) u32 { internal_debug.assertInitialized(); - const win = native.glfwGetX11Window(@ptrCast(*native.GLFWwindow, window.handle)); - if (win != 0) return @intCast(u32, win); + const win = native.glfwGetX11Window(@as(*native.GLFWwindow, @ptrCast(window.handle))); + if (win != 0) return @as(u32, @intCast(win)); // `glfwGetX11Window` returns `0` only for errors // but the only potential error is unreachable (NotInitialized) unreachable; @@ -234,7 +234,7 @@ pub fn Native(comptime options: BackendOptions) type { /// thread_safety: This function may be called from any thread. Access is not synchronized. pub fn getGLXContext(window: Window) ?*anyopaque { internal_debug.assertInitialized(); - if (native.glfwGetGLXContext(@ptrCast(*native.GLFWwindow, window.handle))) |context| return @ptrCast(*anyopaque, context); + if (native.glfwGetGLXContext(@as(*native.GLFWwindow, @ptrCast(window.handle)))) |context| return @as(*anyopaque, @ptrCast(context)); return null; } @@ -246,8 +246,8 @@ pub fn Native(comptime options: BackendOptions) type { /// thread_safety: This function may be called from any thread. Access is not synchronized. pub fn getGLXWindow(window: Window) ?*anyopaque { internal_debug.assertInitialized(); - const win = native.glfwGetGLXWindow(@ptrCast(*native.GLFWwindow, window.handle)); - if (win != 0) return @ptrCast(*anyopaque, win); + const win = native.glfwGetGLXWindow(@as(*native.GLFWwindow, @ptrCast(window.handle))); + if (win != 0) return @as(*anyopaque, @ptrCast(win)); return null; } @@ -256,7 +256,7 @@ pub fn Native(comptime options: BackendOptions) type { /// thread_safety: This function may be called from any thread. Access is not synchronized. pub fn getWaylandDisplay() *anyopaque { internal_debug.assertInitialized(); - if (native.glfwGetWaylandDisplay()) |display| return @ptrCast(*anyopaque, display); + if (native.glfwGetWaylandDisplay()) |display| return @as(*anyopaque, @ptrCast(display)); // `glfwGetWaylandDisplay` returns `null` only for errors // but the only potential error is unreachable (NotInitialized) unreachable; @@ -267,7 +267,7 @@ pub fn Native(comptime options: BackendOptions) type { /// thread_safety: This function may be called from any thread. Access is not synchronized. pub fn getWaylandMonitor(monitor: Monitor) *anyopaque { internal_debug.assertInitialized(); - if (native.glfwGetWaylandMonitor(@ptrCast(*native.GLFWmonitor, monitor.handle))) |mon| return @ptrCast(*anyopaque, mon); + if (native.glfwGetWaylandMonitor(@as(*native.GLFWmonitor, @ptrCast(monitor.handle)))) |mon| return @as(*anyopaque, @ptrCast(mon)); // `glfwGetWaylandMonitor` returns `null` only for errors // but the only potential error is unreachable (NotInitialized) unreachable; @@ -278,7 +278,7 @@ pub fn Native(comptime options: BackendOptions) type { /// thread_safety: This function may be called from any thread. Access is not synchronized. pub fn getWaylandWindow(window: Window) *anyopaque { internal_debug.assertInitialized(); - if (native.glfwGetWaylandWindow(@ptrCast(*native.GLFWwindow, window.handle))) |win| return @ptrCast(*anyopaque, win); + if (native.glfwGetWaylandWindow(@as(*native.GLFWwindow, @ptrCast(window.handle)))) |win| return @as(*anyopaque, @ptrCast(win)); // `glfwGetWaylandWindow` returns `null` only for errors // but the only potential error is unreachable (NotInitialized) unreachable; @@ -293,7 +293,7 @@ pub fn Native(comptime options: BackendOptions) type { pub fn getEGLDisplay() *anyopaque { internal_debug.assertInitialized(); const display = native.glfwGetEGLDisplay(); - if (display != native.EGL_NO_DISPLAY) return @ptrCast(*anyopaque, display); + if (display != native.EGL_NO_DISPLAY) return @as(*anyopaque, @ptrCast(display)); // `glfwGetEGLDisplay` returns `EGL_NO_DISPLAY` only for errors // but the only potential error is unreachable (NotInitialized) unreachable; @@ -307,8 +307,8 @@ pub fn Native(comptime options: BackendOptions) type { /// thread_safety This function may be called from any thread. Access is not synchronized. pub fn getEGLContext(window: Window) ?*anyopaque { internal_debug.assertInitialized(); - const context = native.glfwGetEGLContext(@ptrCast(*native.GLFWwindow, window.handle)); - if (context != native.EGL_NO_CONTEXT) return @ptrCast(*anyopaque, context); + const context = native.glfwGetEGLContext(@as(*native.GLFWwindow, @ptrCast(window.handle))); + if (context != native.EGL_NO_CONTEXT) return @as(*anyopaque, @ptrCast(context)); return null; } @@ -319,8 +319,8 @@ pub fn Native(comptime options: BackendOptions) type { /// thread_safety This function may be called from any thread. Access is not synchronized. pub fn getEGLSurface(window: Window) ?*anyopaque { internal_debug.assertInitialized(); - const surface = native.glfwGetEGLSurface(@ptrCast(*native.GLFWwindow, window.handle)); - if (surface != native.EGL_NO_SURFACE) return @ptrCast(*anyopaque, surface); + const surface = native.glfwGetEGLSurface(@as(*native.GLFWwindow, @ptrCast(window.handle))); + if (surface != native.EGL_NO_SURFACE) return @as(*anyopaque, @ptrCast(surface)); return null; } @@ -341,7 +341,7 @@ pub fn Native(comptime options: BackendOptions) type { internal_debug.assertInitialized(); var buf: OSMesaColorBuffer = undefined; if (native.glfwGetOSMesaColorBuffer( - @ptrCast(*native.GLFWwindow, window.handle), + @as(*native.GLFWwindow, @ptrCast(window.handle)), &buf.width, &buf.height, &buf.format, @@ -367,7 +367,7 @@ pub fn Native(comptime options: BackendOptions) type { internal_debug.assertInitialized(); var buf: OSMesaDepthBuffer = undefined; if (native.glfwGetOSMesaDepthBuffer( - @ptrCast(*native.GLFWwindow, window.handle), + @as(*native.GLFWwindow, @ptrCast(window.handle)), &buf.width, &buf.height, &buf.bytes_per_value, @@ -383,7 +383,7 @@ pub fn Native(comptime options: BackendOptions) type { /// thread_safety: This function may be called from any thread. Access is not synchronized. pub fn getOSMesaContext(window: Window) ?*anyopaque { internal_debug.assertInitialized(); - if (native.glfwGetOSMesaContext(@ptrCast(*native.GLFWwindow, window.handle))) |context| return @ptrCast(*anyopaque, context); + if (native.glfwGetOSMesaContext(@as(*native.GLFWwindow, @ptrCast(window.handle)))) |context| return @as(*anyopaque, @ptrCast(context)); return null; } }; diff --git a/libs/glfw/src/opengl.zig b/libs/glfw/src/opengl.zig index 49995291..0ff1c8c6 100644 --- a/libs/glfw/src/opengl.zig +++ b/libs/glfw/src/opengl.zig @@ -85,7 +85,7 @@ pub inline fn getCurrentContext() ?Window { /// see also: buffer_swap, glfwSwapBuffers pub inline fn swapInterval(interval: i32) void { internal_debug.assertInitialized(); - c.glfwSwapInterval(@intCast(c_int, interval)); + c.glfwSwapInterval(@as(c_int, @intCast(interval))); } /// Returns whether the specified extension is available. diff --git a/libs/glfw/src/vulkan.zig b/libs/glfw/src/vulkan.zig index 3fb174d9..21d756e8 100644 --- a/libs/glfw/src/vulkan.zig +++ b/libs/glfw/src/vulkan.zig @@ -84,7 +84,7 @@ pub inline fn vulkanSupported() bool { pub inline fn getRequiredInstanceExtensions() ?[][*:0]const u8 { internal_debug.assertInitialized(); var count: u32 = 0; - if (c.glfwGetRequiredInstanceExtensions(&count)) |extensions| return @ptrCast([*][*:0]const u8, extensions)[0..count]; + if (c.glfwGetRequiredInstanceExtensions(&count)) |extensions| return @as([*][*:0]const u8, @ptrCast(extensions))[0..count]; return null; } @@ -128,7 +128,7 @@ pub const VKProc = *const fn () callconv(.C) void; /// @thread_safety This function may be called from any thread. pub fn getInstanceProcAddress(vk_instance: ?*anyopaque, proc_name: [*:0]const u8) callconv(.C) ?VKProc { internal_debug.assertInitialized(); - if (c.glfwGetInstanceProcAddress(if (vk_instance) |v| @ptrCast(c.VkInstance, v) else null, proc_name)) |proc_address| return proc_address; + if (c.glfwGetInstanceProcAddress(if (vk_instance) |v| @as(c.VkInstance, @ptrCast(v)) else null, proc_name)) |proc_address| return proc_address; return null; } @@ -165,8 +165,8 @@ pub inline fn getPhysicalDevicePresentationSupport( ) bool { internal_debug.assertInitialized(); return c.glfwGetPhysicalDevicePresentationSupport( - @ptrCast(c.VkInstance, vk_instance), - @ptrCast(c.VkPhysicalDevice, vk_physical_device), + @as(c.VkInstance, @ptrCast(vk_instance)), + @as(c.VkPhysicalDevice, @ptrCast(vk_physical_device)), queue_family, ) == c.GLFW_TRUE; } @@ -231,15 +231,15 @@ pub inline fn createWindowSurface(vk_instance: anytype, window: Window, vk_alloc // zig-vulkan uses enums to represent opaque pointers: // pub const Instance = enum(usize) { null_handle = 0, _ }; const instance: c.VkInstance = switch (@typeInfo(@TypeOf(vk_instance))) { - .Enum => @ptrFromInt(c.VkInstance, @intFromEnum(vk_instance)), - else => @ptrCast(c.VkInstance, vk_instance), + .Enum => @as(c.VkInstance, @ptrFromInt(@intFromEnum(vk_instance))), + else => @as(c.VkInstance, @ptrCast(vk_instance)), }; return c.glfwCreateWindowSurface( instance, window.handle, - if (vk_allocation_callbacks == null) null else @ptrCast(*const c.VkAllocationCallbacks, @alignCast(@alignOf(c.VkAllocationCallbacks), vk_allocation_callbacks)), - @ptrCast(*c.VkSurfaceKHR, @alignCast(@alignOf(c.VkSurfaceKHR), vk_surface_khr)), + if (vk_allocation_callbacks == null) null else @as(*const c.VkAllocationCallbacks, @ptrCast(@alignCast(@alignOf(c.VkAllocationCallbacks), vk_allocation_callbacks))), + @as(*c.VkSurfaceKHR, @ptrCast(@alignCast(@alignOf(c.VkSurfaceKHR), vk_surface_khr))), ); } diff --git a/libs/gpu/examples/sample_utils.zig b/libs/gpu/examples/sample_utils.zig index e9112d1c..43721052 100644 --- a/libs/gpu/examples/sample_utils.zig +++ b/libs/gpu/examples/sample_utils.zig @@ -256,8 +256,8 @@ pub fn msgSend(obj: anytype, sel_name: [:0]const u8, args: anytype, comptime Ret }; // NOTE: func is a var because making it const causes a compile error which I believe is a compiler bug - var func = @ptrCast(FnType, &objc.objc_msgSend); - const sel = objc.sel_getUid(@ptrCast([*c]const u8, sel_name)); + var func = @as(FnType, @ptrCast(&objc.objc_msgSend)); + const sel = objc.sel_getUid(@as([*c]const u8, @ptrCast(sel_name))); return @call(.auto, func, .{ obj, sel } ++ args); } diff --git a/libs/gpu/src/adapter.zig b/libs/gpu/src/adapter.zig index a9dec050..4371a42a 100644 --- a/libs/gpu/src/adapter.zig +++ b/libs/gpu/src/adapter.zig @@ -97,7 +97,7 @@ pub const Adapter = opaque { 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)), + if (Context == void) {} else @as(Context, @ptrCast(@alignCast(@alignOf(Context), userdata))), status, device, message, diff --git a/libs/gpu/src/buffer.zig b/libs/gpu/src/buffer.zig index d7bf676f..705ec6bf 100644 --- a/libs/gpu/src/buffer.zig +++ b/libs/gpu/src/buffer.zig @@ -56,7 +56,7 @@ pub const Buffer = opaque { pub const none = UsageFlags{}; pub fn equal(a: UsageFlags, b: UsageFlags) bool { - return @truncate(u10, @bitCast(u32, a)) == @truncate(u10, @bitCast(u32, b)); + return @as(u10, @truncate(@as(u32, @bitCast(a)))) == @as(u10, @truncate(@as(u32, @bitCast(b)))); } }; @@ -102,7 +102,7 @@ pub const Buffer = opaque { offset_bytes, size + size % 4, ); - return if (data) |d| @ptrCast([*]const T, @alignCast(@alignOf(T), d))[0..len] else null; + return if (data) |d| @as([*]const T, @ptrCast(@alignCast(@alignOf(T), d)))[0..len] else null; } /// Default `offset_bytes`: 0 @@ -119,7 +119,7 @@ pub const Buffer = opaque { offset_bytes, size + size % 4, ); - return if (data) |d| @ptrCast([*]T, @alignCast(@alignOf(T), d))[0..len] else null; + return if (data) |d| @as([*]T, @ptrCast(@alignCast(@alignOf(T), d)))[0..len] else null; } pub inline fn getSize(buffer: *Buffer) u64 { @@ -141,7 +141,7 @@ pub const Buffer = opaque { const Context = @TypeOf(context); const Helper = struct { pub fn cCallback(status: MapAsyncStatus, userdata: ?*anyopaque) callconv(.C) void { - callback(if (Context == void) {} else @ptrCast(Context, @alignCast(@alignOf(std.meta.Child(Context)), userdata)), status); + callback(if (Context == void) {} else @as(Context, @ptrCast(@alignCast(@alignOf(std.meta.Child(Context)), userdata))), status); } }; Impl.bufferMapAsync(buffer, mode, offset, size, Helper.cCallback, if (Context == void) null else context); diff --git a/libs/gpu/src/command_encoder.zig b/libs/gpu/src/command_encoder.zig index 6650e608..006e399d 100644 --- a/libs/gpu/src/command_encoder.zig +++ b/libs/gpu/src/command_encoder.zig @@ -98,8 +98,8 @@ pub const CommandEncoder = opaque { command_encoder, buffer, buffer_offset_bytes, - @ptrCast([*]const u8, std.mem.sliceAsBytes(data_slice).ptr), - @intCast(u64, data_slice.len) * @sizeOf(std.meta.Elem(@TypeOf(data_slice))), + @as([*]const u8, @ptrCast(std.mem.sliceAsBytes(data_slice).ptr)), + @as(u64, @intCast(data_slice.len)) * @sizeOf(std.meta.Elem(@TypeOf(data_slice))), ); } diff --git a/libs/gpu/src/dawn_impl.zig b/libs/gpu/src/dawn_impl.zig index 8a88d02a..9b1ba4eb 100644 --- a/libs/gpu/src/dawn_impl.zig +++ b/libs/gpu/src/dawn_impl.zig @@ -20,112 +20,112 @@ pub const Interface = struct { pub inline fn createInstance(descriptor: ?*const gpu.Instance.Descriptor) ?*gpu.Instance { if (builtin.mode == .Debug and !didInit) @panic("dawn: not initialized; did you forget to call gpu.Impl.init()?"); - return @ptrCast(?*gpu.Instance, procs.createInstance.?( - @ptrCast(?*const c.WGPUInstanceDescriptor, descriptor), - )); + return @as(?*gpu.Instance, @ptrCast(procs.createInstance.?( + @as(?*const c.WGPUInstanceDescriptor, @ptrCast(descriptor)), + ))); } pub inline fn getProcAddress(device: *gpu.Device, proc_name: [*:0]const u8) ?gpu.Proc { return procs.getProcAddress.?( - @ptrCast(c.WGPUDevice, device), + @as(c.WGPUDevice, @ptrCast(device)), proc_name, ); } pub inline fn adapterCreateDevice(adapter: *gpu.Adapter, descriptor: ?*const gpu.Device.Descriptor) ?*gpu.Device { - return @ptrCast(?*gpu.Device, procs.adapterCreateDevice.?( - @ptrCast(c.WGPUAdapter, adapter), - @ptrCast(?*const c.WGPUDeviceDescriptor, descriptor), - )); + return @as(?*gpu.Device, @ptrCast(procs.adapterCreateDevice.?( + @as(c.WGPUAdapter, @ptrCast(adapter)), + @as(?*const c.WGPUDeviceDescriptor, @ptrCast(descriptor)), + ))); } pub inline fn adapterEnumerateFeatures(adapter: *gpu.Adapter, features: ?[*]gpu.FeatureName) usize { return procs.adapterEnumerateFeatures.?( - @ptrCast(c.WGPUAdapter, adapter), - @ptrCast(?[*]c.WGPUFeatureName, features), + @as(c.WGPUAdapter, @ptrCast(adapter)), + @as(?[*]c.WGPUFeatureName, @ptrCast(features)), ); } pub inline fn adapterGetInstance(adapter: *gpu.Adapter) *gpu.Instance { - return @ptrCast(*gpu.Instance, procs.adapterGetInstance.?( - @ptrCast(c.WGPUAdapter, adapter), - )); + return @as(*gpu.Instance, @ptrCast(procs.adapterGetInstance.?( + @as(c.WGPUAdapter, @ptrCast(adapter)), + ))); } pub inline fn adapterGetLimits(adapter: *gpu.Adapter, limits: *gpu.SupportedLimits) bool { return procs.adapterGetLimits.?( - @ptrCast(c.WGPUAdapter, adapter), - @ptrCast(*c.WGPUSupportedLimits, limits), + @as(c.WGPUAdapter, @ptrCast(adapter)), + @as(*c.WGPUSupportedLimits, @ptrCast(limits)), ); } pub inline fn adapterGetProperties(adapter: *gpu.Adapter, properties: *gpu.Adapter.Properties) void { return procs.adapterGetProperties.?( - @ptrCast(c.WGPUAdapter, adapter), - @ptrCast(*c.WGPUAdapterProperties, properties), + @as(c.WGPUAdapter, @ptrCast(adapter)), + @as(*c.WGPUAdapterProperties, @ptrCast(properties)), ); } pub inline fn adapterHasFeature(adapter: *gpu.Adapter, feature: gpu.FeatureName) bool { return procs.adapterHasFeature.?( - @ptrCast(c.WGPUAdapter, adapter), + @as(c.WGPUAdapter, @ptrCast(adapter)), @intFromEnum(feature), ); } pub inline fn adapterRequestDevice(adapter: *gpu.Adapter, descriptor: ?*const gpu.Device.Descriptor, callback: gpu.RequestDeviceCallback, userdata: ?*anyopaque) void { return procs.adapterRequestDevice.?( - @ptrCast(c.WGPUAdapter, adapter), - @ptrCast(?*const c.WGPUDeviceDescriptor, descriptor), - @ptrCast(c.WGPURequestDeviceCallback, callback), + @as(c.WGPUAdapter, @ptrCast(adapter)), + @as(?*const c.WGPUDeviceDescriptor, @ptrCast(descriptor)), + @as(c.WGPURequestDeviceCallback, @ptrCast(callback)), userdata, ); } pub inline fn adapterReference(adapter: *gpu.Adapter) void { - procs.adapterReference.?(@ptrCast(c.WGPUAdapter, adapter)); + procs.adapterReference.?(@as(c.WGPUAdapter, @ptrCast(adapter))); } pub inline fn adapterRelease(adapter: *gpu.Adapter) void { - procs.adapterRelease.?(@ptrCast(c.WGPUAdapter, adapter)); + procs.adapterRelease.?(@as(c.WGPUAdapter, @ptrCast(adapter))); } pub inline fn bindGroupSetLabel(bind_group: *gpu.BindGroup, label: [*:0]const u8) void { - procs.bindGroupSetLabel.?(@ptrCast(c.WGPUBindGroup, bind_group), label); + procs.bindGroupSetLabel.?(@as(c.WGPUBindGroup, @ptrCast(bind_group)), label); } pub inline fn bindGroupReference(bind_group: *gpu.BindGroup) void { - procs.bindGroupReference.?(@ptrCast(c.WGPUBindGroup, bind_group)); + procs.bindGroupReference.?(@as(c.WGPUBindGroup, @ptrCast(bind_group))); } pub inline fn bindGroupRelease(bind_group: *gpu.BindGroup) void { - procs.bindGroupRelease.?(@ptrCast(c.WGPUBindGroup, bind_group)); + procs.bindGroupRelease.?(@as(c.WGPUBindGroup, @ptrCast(bind_group))); } pub inline fn bindGroupLayoutSetLabel(bind_group_layout: *gpu.BindGroupLayout, label: [*:0]const u8) void { - procs.bindGroupLayoutSetLabel.?(@ptrCast(c.WGPUBindGroupLayout, bind_group_layout), label); + procs.bindGroupLayoutSetLabel.?(@as(c.WGPUBindGroupLayout, @ptrCast(bind_group_layout)), label); } pub inline fn bindGroupLayoutReference(bind_group_layout: *gpu.BindGroupLayout) void { - procs.bindGroupLayoutReference.?(@ptrCast(c.WGPUBindGroupLayout, bind_group_layout)); + procs.bindGroupLayoutReference.?(@as(c.WGPUBindGroupLayout, @ptrCast(bind_group_layout))); } pub inline fn bindGroupLayoutRelease(bind_group_layout: *gpu.BindGroupLayout) void { - procs.bindGroupLayoutRelease.?(@ptrCast(c.WGPUBindGroupLayout, bind_group_layout)); + procs.bindGroupLayoutRelease.?(@as(c.WGPUBindGroupLayout, @ptrCast(bind_group_layout))); } pub inline fn bufferDestroy(buffer: *gpu.Buffer) void { - procs.bufferDestroy.?(@ptrCast(c.WGPUBuffer, buffer)); + procs.bufferDestroy.?(@as(c.WGPUBuffer, @ptrCast(buffer))); } pub inline fn bufferGetMapState(buffer: *gpu.Buffer) gpu.Buffer.MapState { - return procs.bufferGetMapState.?(@ptrCast(c.WGPUBuffer, buffer)); + return procs.bufferGetMapState.?(@as(c.WGPUBuffer, @ptrCast(buffer))); } // TODO: dawn: return value not marked as nullable in dawn.json but in fact is. pub inline fn bufferGetConstMappedRange(buffer: *gpu.Buffer, offset: usize, size: usize) ?*const anyopaque { return procs.bufferGetConstMappedRange.?( - @ptrCast(c.WGPUBuffer, buffer), + @as(c.WGPUBuffer, @ptrCast(buffer)), offset, size, ); @@ -134,77 +134,77 @@ pub const Interface = struct { // TODO: dawn: return value not marked as nullable in dawn.json but in fact is. pub inline fn bufferGetMappedRange(buffer: *gpu.Buffer, offset: usize, size: usize) ?*anyopaque { return procs.bufferGetMappedRange.?( - @ptrCast(c.WGPUBuffer, buffer), + @as(c.WGPUBuffer, @ptrCast(buffer)), offset, size, ); } pub inline fn bufferGetSize(buffer: *gpu.Buffer) u64 { - return procs.bufferGetSize.?(@ptrCast(c.WGPUBuffer, buffer)); + return procs.bufferGetSize.?(@as(c.WGPUBuffer, @ptrCast(buffer))); } pub inline fn bufferGetUsage(buffer: *gpu.Buffer) gpu.Buffer.UsageFlags { - return @bitCast(gpu.Buffer.UsageFlags, procs.bufferGetUsage.?(@ptrCast(c.WGPUBuffer, buffer))); + return @as(gpu.Buffer.UsageFlags, @bitCast(procs.bufferGetUsage.?(@as(c.WGPUBuffer, @ptrCast(buffer))))); } pub inline fn bufferMapAsync(buffer: *gpu.Buffer, mode: gpu.MapModeFlags, offset: usize, size: usize, callback: gpu.Buffer.MapCallback, userdata: ?*anyopaque) void { procs.bufferMapAsync.?( - @ptrCast(c.WGPUBuffer, buffer), - @bitCast(c.WGPUMapModeFlags, mode), + @as(c.WGPUBuffer, @ptrCast(buffer)), + @as(c.WGPUMapModeFlags, @bitCast(mode)), offset, size, - @ptrCast(c.WGPUBufferMapCallback, callback), + @as(c.WGPUBufferMapCallback, @ptrCast(callback)), userdata, ); } pub inline fn bufferSetLabel(buffer: *gpu.Buffer, label: [*:0]const u8) void { - procs.bufferSetLabel.?(@ptrCast(c.WGPUBuffer, buffer), label); + procs.bufferSetLabel.?(@as(c.WGPUBuffer, @ptrCast(buffer)), label); } pub inline fn bufferUnmap(buffer: *gpu.Buffer) void { - procs.bufferUnmap.?(@ptrCast(c.WGPUBuffer, buffer)); + procs.bufferUnmap.?(@as(c.WGPUBuffer, @ptrCast(buffer))); } pub inline fn bufferReference(buffer: *gpu.Buffer) void { - procs.bufferReference.?(@ptrCast(c.WGPUBuffer, buffer)); + procs.bufferReference.?(@as(c.WGPUBuffer, @ptrCast(buffer))); } pub inline fn bufferRelease(buffer: *gpu.Buffer) void { - procs.bufferRelease.?(@ptrCast(c.WGPUBuffer, buffer)); + procs.bufferRelease.?(@as(c.WGPUBuffer, @ptrCast(buffer))); } pub inline fn commandBufferSetLabel(command_buffer: *gpu.CommandBuffer, label: [*:0]const u8) void { - procs.commandBufferSetLabel.?(@ptrCast(c.WGPUCommandBuffer, command_buffer), label); + procs.commandBufferSetLabel.?(@as(c.WGPUCommandBuffer, @ptrCast(command_buffer)), label); } pub inline fn commandBufferReference(command_buffer: *gpu.CommandBuffer) void { - procs.commandBufferReference.?(@ptrCast(c.WGPUCommandBuffer, command_buffer)); + procs.commandBufferReference.?(@as(c.WGPUCommandBuffer, @ptrCast(command_buffer))); } pub inline fn commandBufferRelease(command_buffer: *gpu.CommandBuffer) void { - procs.commandBufferRelease.?(@ptrCast(c.WGPUCommandBuffer, command_buffer)); + procs.commandBufferRelease.?(@as(c.WGPUCommandBuffer, @ptrCast(command_buffer))); } pub inline fn commandEncoderBeginComputePass(command_encoder: *gpu.CommandEncoder, descriptor: ?*const gpu.ComputePassDescriptor) *gpu.ComputePassEncoder { - return @ptrCast(*gpu.ComputePassEncoder, procs.commandEncoderBeginComputePass.?( - @ptrCast(c.WGPUCommandEncoder, command_encoder), - @ptrCast(?*const c.WGPUComputePassDescriptor, descriptor), - )); + return @as(*gpu.ComputePassEncoder, @ptrCast(procs.commandEncoderBeginComputePass.?( + @as(c.WGPUCommandEncoder, @ptrCast(command_encoder)), + @as(?*const c.WGPUComputePassDescriptor, @ptrCast(descriptor)), + ))); } pub inline fn commandEncoderBeginRenderPass(command_encoder: *gpu.CommandEncoder, descriptor: *const gpu.RenderPassDescriptor) *gpu.RenderPassEncoder { - return @ptrCast(*gpu.RenderPassEncoder, procs.commandEncoderBeginRenderPass.?( - @ptrCast(c.WGPUCommandEncoder, command_encoder), - @ptrCast(?*const c.WGPURenderPassDescriptor, descriptor), - )); + return @as(*gpu.RenderPassEncoder, @ptrCast(procs.commandEncoderBeginRenderPass.?( + @as(c.WGPUCommandEncoder, @ptrCast(command_encoder)), + @as(?*const c.WGPURenderPassDescriptor, @ptrCast(descriptor)), + ))); } pub inline fn commandEncoderClearBuffer(command_encoder: *gpu.CommandEncoder, buffer: *gpu.Buffer, offset: u64, size: u64) void { procs.commandEncoderClearBuffer.?( - @ptrCast(c.WGPUCommandEncoder, command_encoder), - @ptrCast(c.WGPUBuffer, buffer), + @as(c.WGPUCommandEncoder, @ptrCast(command_encoder)), + @as(c.WGPUBuffer, @ptrCast(buffer)), offset, size, ); @@ -212,10 +212,10 @@ pub const Interface = struct { pub inline fn commandEncoderCopyBufferToBuffer(command_encoder: *gpu.CommandEncoder, source: *gpu.Buffer, source_offset: u64, destination: *gpu.Buffer, destination_offset: u64, size: u64) void { procs.commandEncoderCopyBufferToBuffer.?( - @ptrCast(c.WGPUCommandEncoder, command_encoder), - @ptrCast(c.WGPUBuffer, source), + @as(c.WGPUCommandEncoder, @ptrCast(command_encoder)), + @as(c.WGPUBuffer, @ptrCast(source)), source_offset, - @ptrCast(c.WGPUBuffer, destination), + @as(c.WGPUBuffer, @ptrCast(destination)), destination_offset, size, ); @@ -223,91 +223,91 @@ pub const Interface = struct { pub inline fn commandEncoderCopyBufferToTexture(command_encoder: *gpu.CommandEncoder, source: *const gpu.ImageCopyBuffer, destination: *const gpu.ImageCopyTexture, copy_size: *const gpu.Extent3D) void { procs.commandEncoderCopyBufferToTexture.?( - @ptrCast(c.WGPUCommandEncoder, command_encoder), - @ptrCast(*const c.WGPUImageCopyBuffer, source), - @ptrCast(*const c.WGPUImageCopyTexture, destination), - @ptrCast(*const c.WGPUExtent3D, copy_size), + @as(c.WGPUCommandEncoder, @ptrCast(command_encoder)), + @as(*const c.WGPUImageCopyBuffer, @ptrCast(source)), + @as(*const c.WGPUImageCopyTexture, @ptrCast(destination)), + @as(*const c.WGPUExtent3D, @ptrCast(copy_size)), ); } pub inline fn commandEncoderCopyTextureToBuffer(command_encoder: *gpu.CommandEncoder, source: *const gpu.ImageCopyTexture, destination: *const gpu.ImageCopyBuffer, copy_size: *const gpu.Extent3D) void { procs.commandEncoderCopyTextureToBuffer.?( - @ptrCast(c.WGPUCommandEncoder, command_encoder), - @ptrCast(*const c.WGPUImageCopyTexture, source), - @ptrCast(*const c.WGPUImageCopyBuffer, destination), - @ptrCast(*const c.WGPUExtent3D, copy_size), + @as(c.WGPUCommandEncoder, @ptrCast(command_encoder)), + @as(*const c.WGPUImageCopyTexture, @ptrCast(source)), + @as(*const c.WGPUImageCopyBuffer, @ptrCast(destination)), + @as(*const c.WGPUExtent3D, @ptrCast(copy_size)), ); } pub inline fn commandEncoderCopyTextureToTexture(command_encoder: *gpu.CommandEncoder, source: *const gpu.ImageCopyTexture, destination: *const gpu.ImageCopyTexture, copy_size: *const gpu.Extent3D) void { procs.commandEncoderCopyTextureToTexture.?( - @ptrCast(c.WGPUCommandEncoder, command_encoder), - @ptrCast(*const c.WGPUImageCopyTexture, source), - @ptrCast(*const c.WGPUImageCopyTexture, destination), - @ptrCast(*const c.WGPUExtent3D, copy_size), + @as(c.WGPUCommandEncoder, @ptrCast(command_encoder)), + @as(*const c.WGPUImageCopyTexture, @ptrCast(source)), + @as(*const c.WGPUImageCopyTexture, @ptrCast(destination)), + @as(*const c.WGPUExtent3D, @ptrCast(copy_size)), ); } pub inline fn commandEncoderCopyTextureToTextureInternal(command_encoder: *gpu.CommandEncoder, source: *const gpu.ImageCopyTexture, destination: *const gpu.ImageCopyTexture, copy_size: *const gpu.Extent3D) void { procs.commandEncoderCopyTextureToTextureInternal.?( - @ptrCast(c.WGPUCommandEncoder, command_encoder), - @ptrCast(*const c.WGPUImageCopyTexture, source), - @ptrCast(*const c.WGPUImageCopyTexture, destination), - @ptrCast(*const c.WGPUExtent3D, copy_size), + @as(c.WGPUCommandEncoder, @ptrCast(command_encoder)), + @as(*const c.WGPUImageCopyTexture, @ptrCast(source)), + @as(*const c.WGPUImageCopyTexture, @ptrCast(destination)), + @as(*const c.WGPUExtent3D, @ptrCast(copy_size)), ); } pub inline fn commandEncoderFinish(command_encoder: *gpu.CommandEncoder, descriptor: ?*const gpu.CommandBuffer.Descriptor) *gpu.CommandBuffer { - return @ptrCast(*gpu.CommandBuffer, procs.commandEncoderFinish.?( - @ptrCast(c.WGPUCommandEncoder, command_encoder), - @ptrCast(?*const c.WGPUCommandBufferDescriptor, descriptor), - )); + return @as(*gpu.CommandBuffer, @ptrCast(procs.commandEncoderFinish.?( + @as(c.WGPUCommandEncoder, @ptrCast(command_encoder)), + @as(?*const c.WGPUCommandBufferDescriptor, @ptrCast(descriptor)), + ))); } pub inline fn commandEncoderInjectValidationError(command_encoder: *gpu.CommandEncoder, message: [*:0]const u8) void { procs.commandEncoderInjectValidationError.?( - @ptrCast(c.WGPUCommandEncoder, command_encoder), + @as(c.WGPUCommandEncoder, @ptrCast(command_encoder)), message, ); } pub inline fn commandEncoderInsertDebugMarker(command_encoder: *gpu.CommandEncoder, marker_label: [*:0]const u8) void { procs.commandEncoderInsertDebugMarker.?( - @ptrCast(c.WGPUCommandEncoder, command_encoder), + @as(c.WGPUCommandEncoder, @ptrCast(command_encoder)), marker_label, ); } pub inline fn commandEncoderPopDebugGroup(command_encoder: *gpu.CommandEncoder) void { - procs.commandEncoderPopDebugGroup.?(@ptrCast(c.WGPUCommandEncoder, command_encoder)); + procs.commandEncoderPopDebugGroup.?(@as(c.WGPUCommandEncoder, @ptrCast(command_encoder))); } pub inline fn commandEncoderPushDebugGroup(command_encoder: *gpu.CommandEncoder, group_label: [*:0]const u8) void { procs.commandEncoderPushDebugGroup.?( - @ptrCast(c.WGPUCommandEncoder, command_encoder), + @as(c.WGPUCommandEncoder, @ptrCast(command_encoder)), group_label, ); } pub inline fn commandEncoderResolveQuerySet(command_encoder: *gpu.CommandEncoder, query_set: *gpu.QuerySet, first_query: u32, query_count: u32, destination: *gpu.Buffer, destination_offset: u64) void { procs.commandEncoderResolveQuerySet.?( - @ptrCast(c.WGPUCommandEncoder, command_encoder), - @ptrCast(c.WGPUQuerySet, query_set), + @as(c.WGPUCommandEncoder, @ptrCast(command_encoder)), + @as(c.WGPUQuerySet, @ptrCast(query_set)), first_query, query_count, - @ptrCast(c.WGPUBuffer, destination), + @as(c.WGPUBuffer, @ptrCast(destination)), destination_offset, ); } pub inline fn commandEncoderSetLabel(command_encoder: *gpu.CommandEncoder, label: [*:0]const u8) void { - procs.commandEncoderSetLabel.?(@ptrCast(c.WGPUCommandEncoder, command_encoder), label); + procs.commandEncoderSetLabel.?(@as(c.WGPUCommandEncoder, @ptrCast(command_encoder)), label); } pub inline fn commandEncoderWriteBuffer(command_encoder: *gpu.CommandEncoder, buffer: *gpu.Buffer, buffer_offset: u64, data: [*]const u8, size: u64) void { procs.commandEncoderWriteBuffer.?( - @ptrCast(c.WGPUCommandEncoder, command_encoder), - @ptrCast(c.WGPUBuffer, buffer), + @as(c.WGPUCommandEncoder, @ptrCast(command_encoder)), + @as(c.WGPUBuffer, @ptrCast(buffer)), buffer_offset, data, size, @@ -316,23 +316,23 @@ pub const Interface = struct { pub inline fn commandEncoderWriteTimestamp(command_encoder: *gpu.CommandEncoder, query_set: *gpu.QuerySet, query_index: u32) void { procs.commandEncoderWriteTimestamp.?( - @ptrCast(c.WGPUCommandEncoder, command_encoder), - @ptrCast(c.WGPUQuerySet, query_set), + @as(c.WGPUCommandEncoder, @ptrCast(command_encoder)), + @as(c.WGPUQuerySet, @ptrCast(query_set)), query_index, ); } pub inline fn commandEncoderReference(command_encoder: *gpu.CommandEncoder) void { - procs.commandEncoderReference.?(@ptrCast(c.WGPUCommandEncoder, command_encoder)); + procs.commandEncoderReference.?(@as(c.WGPUCommandEncoder, @ptrCast(command_encoder))); } pub inline fn commandEncoderRelease(command_encoder: *gpu.CommandEncoder) void { - procs.commandEncoderRelease.?(@ptrCast(c.WGPUCommandEncoder, command_encoder)); + procs.commandEncoderRelease.?(@as(c.WGPUCommandEncoder, @ptrCast(command_encoder))); } pub inline fn computePassEncoderDispatchWorkgroups(compute_pass_encoder: *gpu.ComputePassEncoder, workgroup_count_x: u32, workgroup_count_y: u32, workgroup_count_z: u32) void { procs.computePassEncoderDispatchWorkgroups.?( - @ptrCast(c.WGPUComputePassEncoder, compute_pass_encoder), + @as(c.WGPUComputePassEncoder, @ptrCast(compute_pass_encoder)), workgroup_count_x, workgroup_count_y, workgroup_count_z, @@ -341,192 +341,192 @@ pub const Interface = struct { pub inline fn computePassEncoderDispatchWorkgroupsIndirect(compute_pass_encoder: *gpu.ComputePassEncoder, indirect_buffer: *gpu.Buffer, indirect_offset: u64) void { procs.computePassEncoderDispatchWorkgroupsIndirect.?( - @ptrCast(c.WGPUComputePassEncoder, compute_pass_encoder), - @ptrCast(c.WGPUBuffer, indirect_buffer), + @as(c.WGPUComputePassEncoder, @ptrCast(compute_pass_encoder)), + @as(c.WGPUBuffer, @ptrCast(indirect_buffer)), indirect_offset, ); } pub inline fn computePassEncoderEnd(compute_pass_encoder: *gpu.ComputePassEncoder) void { - procs.computePassEncoderEnd.?(@ptrCast(c.WGPUComputePassEncoder, compute_pass_encoder)); + procs.computePassEncoderEnd.?(@as(c.WGPUComputePassEncoder, @ptrCast(compute_pass_encoder))); } pub inline fn computePassEncoderInsertDebugMarker(compute_pass_encoder: *gpu.ComputePassEncoder, marker_label: [*:0]const u8) void { procs.computePassEncoderInsertDebugMarker.?( - @ptrCast(c.WGPUComputePassEncoder, compute_pass_encoder), + @as(c.WGPUComputePassEncoder, @ptrCast(compute_pass_encoder)), marker_label, ); } pub inline fn computePassEncoderPopDebugGroup(compute_pass_encoder: *gpu.ComputePassEncoder) void { - procs.computePassEncoderPopDebugGroup.?(@ptrCast(c.WGPUComputePassEncoder, compute_pass_encoder)); + procs.computePassEncoderPopDebugGroup.?(@as(c.WGPUComputePassEncoder, @ptrCast(compute_pass_encoder))); } pub inline fn computePassEncoderPushDebugGroup(compute_pass_encoder: *gpu.ComputePassEncoder, group_label: [*:0]const u8) void { procs.computePassEncoderPushDebugGroup.?( - @ptrCast(c.WGPUComputePassEncoder, compute_pass_encoder), + @as(c.WGPUComputePassEncoder, @ptrCast(compute_pass_encoder)), group_label, ); } pub inline fn computePassEncoderSetBindGroup(compute_pass_encoder: *gpu.ComputePassEncoder, group_index: u32, group: *gpu.BindGroup, dynamic_offset_count: usize, dynamic_offsets: ?[*]const u32) void { procs.computePassEncoderSetBindGroup.?( - @ptrCast(c.WGPUComputePassEncoder, compute_pass_encoder), + @as(c.WGPUComputePassEncoder, @ptrCast(compute_pass_encoder)), group_index, - @ptrCast(c.WGPUBindGroup, group), + @as(c.WGPUBindGroup, @ptrCast(group)), dynamic_offset_count, dynamic_offsets, ); } pub inline fn computePassEncoderSetLabel(compute_pass_encoder: *gpu.ComputePassEncoder, label: [*:0]const u8) void { - procs.computePassEncoderSetLabel.?(@ptrCast(c.WGPUComputePassEncoder, compute_pass_encoder), label); + procs.computePassEncoderSetLabel.?(@as(c.WGPUComputePassEncoder, @ptrCast(compute_pass_encoder)), label); } pub inline fn computePassEncoderSetPipeline(compute_pass_encoder: *gpu.ComputePassEncoder, pipeline: *gpu.ComputePipeline) void { procs.computePassEncoderSetPipeline.?( - @ptrCast(c.WGPUComputePassEncoder, compute_pass_encoder), - @ptrCast(c.WGPUComputePipeline, pipeline), + @as(c.WGPUComputePassEncoder, @ptrCast(compute_pass_encoder)), + @as(c.WGPUComputePipeline, @ptrCast(pipeline)), ); } pub inline fn computePassEncoderWriteTimestamp(compute_pass_encoder: *gpu.ComputePassEncoder, query_set: *gpu.QuerySet, query_index: u32) void { procs.computePassEncoderWriteTimestamp.?( - @ptrCast(c.WGPUComputePassEncoder, compute_pass_encoder), - @ptrCast(c.WGPUQuerySet, query_set), + @as(c.WGPUComputePassEncoder, @ptrCast(compute_pass_encoder)), + @as(c.WGPUQuerySet, @ptrCast(query_set)), query_index, ); } pub inline fn computePassEncoderReference(compute_pass_encoder: *gpu.ComputePassEncoder) void { - procs.computePassEncoderReference.?(@ptrCast(c.WGPUComputePassEncoder, compute_pass_encoder)); + procs.computePassEncoderReference.?(@as(c.WGPUComputePassEncoder, @ptrCast(compute_pass_encoder))); } pub inline fn computePassEncoderRelease(compute_pass_encoder: *gpu.ComputePassEncoder) void { - procs.computePassEncoderRelease.?(@ptrCast(c.WGPUComputePassEncoder, compute_pass_encoder)); + procs.computePassEncoderRelease.?(@as(c.WGPUComputePassEncoder, @ptrCast(compute_pass_encoder))); } pub inline fn computePipelineGetBindGroupLayout(compute_pipeline: *gpu.ComputePipeline, group_index: u32) *gpu.BindGroupLayout { - return @ptrCast(*gpu.BindGroupLayout, procs.computePipelineGetBindGroupLayout.?( - @ptrCast(c.WGPUComputePipeline, compute_pipeline), + return @as(*gpu.BindGroupLayout, @ptrCast(procs.computePipelineGetBindGroupLayout.?( + @as(c.WGPUComputePipeline, @ptrCast(compute_pipeline)), group_index, - )); + ))); } pub inline fn computePipelineSetLabel(compute_pipeline: *gpu.ComputePipeline, label: [*:0]const u8) void { - procs.computePipelineSetLabel.?(@ptrCast(c.WGPUComputePipeline, compute_pipeline), label); + procs.computePipelineSetLabel.?(@as(c.WGPUComputePipeline, @ptrCast(compute_pipeline)), label); } pub inline fn computePipelineReference(compute_pipeline: *gpu.ComputePipeline) void { - procs.computePipelineReference.?(@ptrCast(c.WGPUComputePipeline, compute_pipeline)); + procs.computePipelineReference.?(@as(c.WGPUComputePipeline, @ptrCast(compute_pipeline))); } pub inline fn computePipelineRelease(compute_pipeline: *gpu.ComputePipeline) void { - procs.computePipelineRelease.?(@ptrCast(c.WGPUComputePipeline, compute_pipeline)); + procs.computePipelineRelease.?(@as(c.WGPUComputePipeline, @ptrCast(compute_pipeline))); } pub inline fn deviceCreateBindGroup(device: *gpu.Device, descriptor: *const gpu.BindGroup.Descriptor) *gpu.BindGroup { - return @ptrCast(*gpu.BindGroup, procs.deviceCreateBindGroup.?( - @ptrCast(c.WGPUDevice, device), - @ptrCast(*const c.WGPUBindGroupDescriptor, descriptor), - )); + return @as(*gpu.BindGroup, @ptrCast(procs.deviceCreateBindGroup.?( + @as(c.WGPUDevice, @ptrCast(device)), + @as(*const c.WGPUBindGroupDescriptor, @ptrCast(descriptor)), + ))); } pub inline fn deviceCreateBindGroupLayout(device: *gpu.Device, descriptor: *const gpu.BindGroupLayout.Descriptor) *gpu.BindGroupLayout { - return @ptrCast(*gpu.BindGroupLayout, procs.deviceCreateBindGroupLayout.?( - @ptrCast(c.WGPUDevice, device), - @ptrCast(*const c.WGPUBindGroupLayoutDescriptor, descriptor), - )); + return @as(*gpu.BindGroupLayout, @ptrCast(procs.deviceCreateBindGroupLayout.?( + @as(c.WGPUDevice, @ptrCast(device)), + @as(*const c.WGPUBindGroupLayoutDescriptor, @ptrCast(descriptor)), + ))); } pub inline fn deviceCreateBuffer(device: *gpu.Device, descriptor: *const gpu.Buffer.Descriptor) *gpu.Buffer { - return @ptrCast(*gpu.Buffer, procs.deviceCreateBuffer.?( - @ptrCast(c.WGPUDevice, device), - @ptrCast(*const c.WGPUBufferDescriptor, descriptor), - )); + return @as(*gpu.Buffer, @ptrCast(procs.deviceCreateBuffer.?( + @as(c.WGPUDevice, @ptrCast(device)), + @as(*const c.WGPUBufferDescriptor, @ptrCast(descriptor)), + ))); } pub inline fn deviceCreateCommandEncoder(device: *gpu.Device, descriptor: ?*const gpu.CommandEncoder.Descriptor) *gpu.CommandEncoder { - return @ptrCast(*gpu.CommandEncoder, procs.deviceCreateCommandEncoder.?( - @ptrCast(c.WGPUDevice, device), - @ptrCast(?*const c.WGPUCommandEncoderDescriptor, descriptor), - )); + return @as(*gpu.CommandEncoder, @ptrCast(procs.deviceCreateCommandEncoder.?( + @as(c.WGPUDevice, @ptrCast(device)), + @as(?*const c.WGPUCommandEncoderDescriptor, @ptrCast(descriptor)), + ))); } pub inline fn deviceCreateComputePipeline(device: *gpu.Device, descriptor: *const gpu.ComputePipeline.Descriptor) *gpu.ComputePipeline { - return @ptrCast(*gpu.ComputePipeline, procs.deviceCreateComputePipeline.?( - @ptrCast(c.WGPUDevice, device), - @ptrCast(*const c.WGPUComputePipelineDescriptor, descriptor), - )); + return @as(*gpu.ComputePipeline, @ptrCast(procs.deviceCreateComputePipeline.?( + @as(c.WGPUDevice, @ptrCast(device)), + @as(*const c.WGPUComputePipelineDescriptor, @ptrCast(descriptor)), + ))); } pub inline fn deviceCreateComputePipelineAsync(device: *gpu.Device, descriptor: *const gpu.ComputePipeline.Descriptor, callback: gpu.CreateComputePipelineAsyncCallback, userdata: ?*anyopaque) void { procs.deviceCreateComputePipelineAsync.?( - @ptrCast(c.WGPUDevice, device), - @ptrCast(*const c.WGPUComputePipelineDescriptor, descriptor), - @ptrCast(c.WGPUCreateComputePipelineAsyncCallback, callback), + @as(c.WGPUDevice, @ptrCast(device)), + @as(*const c.WGPUComputePipelineDescriptor, @ptrCast(descriptor)), + @as(c.WGPUCreateComputePipelineAsyncCallback, @ptrCast(callback)), userdata, ); } pub inline fn deviceCreateErrorBuffer(device: *gpu.Device, descriptor: *const gpu.Buffer.Descriptor) *gpu.Buffer { - return @ptrCast(*gpu.Buffer, procs.deviceCreateErrorBuffer.?( - @ptrCast(c.WGPUDevice, device), - @ptrCast(*const c.WGPUBufferDescriptor, descriptor), - )); + return @as(*gpu.Buffer, @ptrCast(procs.deviceCreateErrorBuffer.?( + @as(c.WGPUDevice, @ptrCast(device)), + @as(*const c.WGPUBufferDescriptor, @ptrCast(descriptor)), + ))); } pub inline fn deviceCreateErrorExternalTexture(device: *gpu.Device) *gpu.ExternalTexture { - return @ptrCast(*gpu.ExternalTexture, procs.deviceCreateErrorExternalTexture.?(@ptrCast(c.WGPUDevice, device))); + return @as(*gpu.ExternalTexture, @ptrCast(procs.deviceCreateErrorExternalTexture.?(@as(c.WGPUDevice, @ptrCast(device))))); } pub inline fn deviceCreateErrorTexture(device: *gpu.Device, descriptor: *const gpu.Texture.Descriptor) *gpu.Texture { - return @ptrCast(*gpu.Texture, procs.deviceCreateErrorTexture.?( - @ptrCast(c.WGPUDevice, device), - @ptrCast(*const c.WGPUTextureDescriptor, descriptor), - )); + return @as(*gpu.Texture, @ptrCast(procs.deviceCreateErrorTexture.?( + @as(c.WGPUDevice, @ptrCast(device)), + @as(*const c.WGPUTextureDescriptor, @ptrCast(descriptor)), + ))); } pub inline fn deviceCreateExternalTexture(device: *gpu.Device, external_texture_descriptor: *const gpu.ExternalTexture.Descriptor) *gpu.ExternalTexture { - return @ptrCast(*gpu.ExternalTexture, procs.deviceCreateExternalTexture.?( - @ptrCast(c.WGPUDevice, device), - @ptrCast(*const c.WGPUExternalTextureDescriptor, external_texture_descriptor), - )); + return @as(*gpu.ExternalTexture, @ptrCast(procs.deviceCreateExternalTexture.?( + @as(c.WGPUDevice, @ptrCast(device)), + @as(*const c.WGPUExternalTextureDescriptor, @ptrCast(external_texture_descriptor)), + ))); } pub inline fn deviceCreatePipelineLayout(device: *gpu.Device, pipeline_layout_descriptor: *const gpu.PipelineLayout.Descriptor) *gpu.PipelineLayout { - return @ptrCast(*gpu.PipelineLayout, procs.deviceCreatePipelineLayout.?( - @ptrCast(c.WGPUDevice, device), - @ptrCast(*const c.WGPUPipelineLayoutDescriptor, pipeline_layout_descriptor), - )); + return @as(*gpu.PipelineLayout, @ptrCast(procs.deviceCreatePipelineLayout.?( + @as(c.WGPUDevice, @ptrCast(device)), + @as(*const c.WGPUPipelineLayoutDescriptor, @ptrCast(pipeline_layout_descriptor)), + ))); } pub inline fn deviceCreateQuerySet(device: *gpu.Device, descriptor: *const gpu.QuerySet.Descriptor) *gpu.QuerySet { - return @ptrCast(*gpu.QuerySet, procs.deviceCreateQuerySet.?( - @ptrCast(c.WGPUDevice, device), - @ptrCast(*const c.WGPUQuerySetDescriptor, descriptor), - )); + return @as(*gpu.QuerySet, @ptrCast(procs.deviceCreateQuerySet.?( + @as(c.WGPUDevice, @ptrCast(device)), + @as(*const c.WGPUQuerySetDescriptor, @ptrCast(descriptor)), + ))); } pub inline fn deviceCreateRenderBundleEncoder(device: *gpu.Device, descriptor: *const gpu.RenderBundleEncoder.Descriptor) *gpu.RenderBundleEncoder { - return @ptrCast(*gpu.RenderBundleEncoder, procs.deviceCreateRenderBundleEncoder.?( - @ptrCast(c.WGPUDevice, device), - @ptrCast(*const c.WGPURenderBundleEncoderDescriptor, descriptor), - )); + return @as(*gpu.RenderBundleEncoder, @ptrCast(procs.deviceCreateRenderBundleEncoder.?( + @as(c.WGPUDevice, @ptrCast(device)), + @as(*const c.WGPURenderBundleEncoderDescriptor, @ptrCast(descriptor)), + ))); } pub inline fn deviceCreateRenderPipeline(device: *gpu.Device, descriptor: *const gpu.RenderPipeline.Descriptor) *gpu.RenderPipeline { - return @ptrCast(*gpu.RenderPipeline, procs.deviceCreateRenderPipeline.?( - @ptrCast(c.WGPUDevice, device), - @ptrCast(*const c.WGPURenderPipelineDescriptor, descriptor), - )); + return @as(*gpu.RenderPipeline, @ptrCast(procs.deviceCreateRenderPipeline.?( + @as(c.WGPUDevice, @ptrCast(device)), + @as(*const c.WGPURenderPipelineDescriptor, @ptrCast(descriptor)), + ))); } pub inline fn deviceCreateRenderPipelineAsync(device: *gpu.Device, descriptor: *const gpu.RenderPipeline.Descriptor, callback: gpu.CreateRenderPipelineAsyncCallback, userdata: ?*anyopaque) void { procs.deviceCreateRenderPipelineAsync.?( - @ptrCast(c.WGPUDevice, device), - @ptrCast(*const c.WGPURenderPipelineDescriptor, descriptor), - @ptrCast(c.WGPUCreateRenderPipelineAsyncCallback, callback), + @as(c.WGPUDevice, @ptrCast(device)), + @as(*const c.WGPURenderPipelineDescriptor, @ptrCast(descriptor)), + @as(c.WGPUCreateRenderPipelineAsyncCallback, @ptrCast(callback)), userdata, ); } @@ -534,78 +534,78 @@ pub const Interface = struct { // TODO(self-hosted): this cannot be marked as inline for some reason. // https://github.com/ziglang/zig/issues/12545 pub fn deviceCreateSampler(device: *gpu.Device, descriptor: ?*const gpu.Sampler.Descriptor) *gpu.Sampler { - return @ptrCast(*gpu.Sampler, procs.deviceCreateSampler.?( - @ptrCast(c.WGPUDevice, device), - @ptrCast(?*const c.WGPUSamplerDescriptor, descriptor), - )); + return @as(*gpu.Sampler, @ptrCast(procs.deviceCreateSampler.?( + @as(c.WGPUDevice, @ptrCast(device)), + @as(?*const c.WGPUSamplerDescriptor, @ptrCast(descriptor)), + ))); } pub inline fn deviceCreateShaderModule(device: *gpu.Device, descriptor: *const gpu.ShaderModule.Descriptor) *gpu.ShaderModule { - return @ptrCast(*gpu.ShaderModule, procs.deviceCreateShaderModule.?( - @ptrCast(c.WGPUDevice, device), - @ptrCast(*const c.WGPUShaderModuleDescriptor, descriptor), - )); + return @as(*gpu.ShaderModule, @ptrCast(procs.deviceCreateShaderModule.?( + @as(c.WGPUDevice, @ptrCast(device)), + @as(*const c.WGPUShaderModuleDescriptor, @ptrCast(descriptor)), + ))); } pub inline fn deviceCreateSwapChain(device: *gpu.Device, surface: ?*gpu.Surface, descriptor: *const gpu.SwapChain.Descriptor) *gpu.SwapChain { - return @ptrCast(*gpu.SwapChain, procs.deviceCreateSwapChain.?( - @ptrCast(c.WGPUDevice, device), - @ptrCast(c.WGPUSurface, surface), - @ptrCast(*const c.WGPUSwapChainDescriptor, descriptor), - )); + return @as(*gpu.SwapChain, @ptrCast(procs.deviceCreateSwapChain.?( + @as(c.WGPUDevice, @ptrCast(device)), + @as(c.WGPUSurface, @ptrCast(surface)), + @as(*const c.WGPUSwapChainDescriptor, @ptrCast(descriptor)), + ))); } pub inline fn deviceCreateTexture(device: *gpu.Device, descriptor: *const gpu.Texture.Descriptor) *gpu.Texture { - return @ptrCast(*gpu.Texture, procs.deviceCreateTexture.?( - @ptrCast(c.WGPUDevice, device), - @ptrCast(*const c.WGPUTextureDescriptor, descriptor), - )); + return @as(*gpu.Texture, @ptrCast(procs.deviceCreateTexture.?( + @as(c.WGPUDevice, @ptrCast(device)), + @as(*const c.WGPUTextureDescriptor, @ptrCast(descriptor)), + ))); } pub inline fn deviceDestroy(device: *gpu.Device) void { - procs.deviceDestroy.?(@ptrCast(c.WGPUDevice, device)); + procs.deviceDestroy.?(@as(c.WGPUDevice, @ptrCast(device))); } pub inline fn deviceEnumerateFeatures(device: *gpu.Device, features: ?[*]gpu.FeatureName) usize { return procs.deviceEnumerateFeatures.?( - @ptrCast(c.WGPUDevice, device), - @ptrCast(?[*]c.WGPUFeatureName, features), + @as(c.WGPUDevice, @ptrCast(device)), + @as(?[*]c.WGPUFeatureName, @ptrCast(features)), ); } pub inline fn forceLoss(device: *gpu.Device, reason: gpu.Device.LostReason, message: [*:0]const u8) void { return procs.deviceForceLoss.?( - @ptrCast(c.WGPUDevice, device), + @as(c.WGPUDevice, @ptrCast(device)), reason, message, ); } pub inline fn deviceGetAdapter(device: *gpu.Device) *gpu.Adapter { - return procs.deviceGetAdapter.?(@ptrCast(c.WGPUDevice, device)); + return procs.deviceGetAdapter.?(@as(c.WGPUDevice, @ptrCast(device))); } pub inline fn deviceGetLimits(device: *gpu.Device, limits: *gpu.SupportedLimits) bool { return procs.deviceGetLimits.?( - @ptrCast(c.WGPUDevice, device), - @ptrCast(*c.WGPUSupportedLimits, limits), + @as(c.WGPUDevice, @ptrCast(device)), + @as(*c.WGPUSupportedLimits, @ptrCast(limits)), ); } pub inline fn deviceGetQueue(device: *gpu.Device) *gpu.Queue { - return @ptrCast(*gpu.Queue, procs.deviceGetQueue.?(@ptrCast(c.WGPUDevice, device))); + return @as(*gpu.Queue, @ptrCast(procs.deviceGetQueue.?(@as(c.WGPUDevice, @ptrCast(device))))); } pub inline fn deviceHasFeature(device: *gpu.Device, feature: gpu.FeatureName) bool { return procs.deviceHasFeature.?( - @ptrCast(c.WGPUDevice, device), + @as(c.WGPUDevice, @ptrCast(device)), @intFromEnum(feature), ); } pub inline fn deviceInjectError(device: *gpu.Device, typ: gpu.ErrorType, message: [*:0]const u8) void { procs.deviceInjectError.?( - @ptrCast(c.WGPUDevice, device), + @as(c.WGPUDevice, @ptrCast(device)), @intFromEnum(typ), message, ); @@ -613,49 +613,49 @@ pub const Interface = struct { pub inline fn devicePopErrorScope(device: *gpu.Device, callback: gpu.ErrorCallback, userdata: ?*anyopaque) void { procs.devicePopErrorScope.?( - @ptrCast(c.WGPUDevice, device), - @ptrCast(c.WGPUErrorCallback, callback), + @as(c.WGPUDevice, @ptrCast(device)), + @as(c.WGPUErrorCallback, @ptrCast(callback)), userdata, ); } pub inline fn devicePushErrorScope(device: *gpu.Device, filter: gpu.ErrorFilter) void { procs.devicePushErrorScope.?( - @ptrCast(c.WGPUDevice, device), + @as(c.WGPUDevice, @ptrCast(device)), @intFromEnum(filter), ); } pub inline fn deviceSetDeviceLostCallback(device: *gpu.Device, callback: ?gpu.Device.LostCallback, userdata: ?*anyopaque) void { procs.deviceSetDeviceLostCallback.?( - @ptrCast(c.WGPUDevice, device), - @ptrCast(c.WGPUDeviceLostCallback, callback), + @as(c.WGPUDevice, @ptrCast(device)), + @as(c.WGPUDeviceLostCallback, @ptrCast(callback)), userdata, ); } pub inline fn deviceSetLabel(device: *gpu.Device, label: [*:0]const u8) void { - procs.deviceSetLabel.?(@ptrCast(c.WGPUDevice, device), label); + procs.deviceSetLabel.?(@as(c.WGPUDevice, @ptrCast(device)), label); } pub inline fn deviceSetLoggingCallback(device: *gpu.Device, callback: ?gpu.LoggingCallback, userdata: ?*anyopaque) void { procs.deviceSetLoggingCallback.?( - @ptrCast(c.WGPUDevice, device), - @ptrCast(c.WGPULoggingCallback, callback), + @as(c.WGPUDevice, @ptrCast(device)), + @as(c.WGPULoggingCallback, @ptrCast(callback)), userdata, ); } pub inline fn deviceSetUncapturedErrorCallback(device: *gpu.Device, callback: ?gpu.ErrorCallback, userdata: ?*anyopaque) void { procs.deviceSetUncapturedErrorCallback.?( - @ptrCast(c.WGPUDevice, device), - @ptrCast(c.WGPUErrorCallback, callback), + @as(c.WGPUDevice, @ptrCast(device)), + @as(c.WGPUErrorCallback, @ptrCast(callback)), userdata, ); } pub inline fn deviceTick(device: *gpu.Device) void { - procs.deviceTick.?(@ptrCast(c.WGPUDevice, device)); + procs.deviceTick.?(@as(c.WGPUDevice, @ptrCast(device))); } pub inline fn deviceValidateTextureDescriptor(device: *gpu.Device, descriptor: *const gpu.Texture.Descriptor) void { @@ -663,140 +663,140 @@ pub const Interface = struct { } pub inline fn deviceReference(device: *gpu.Device) void { - procs.deviceReference.?(@ptrCast(c.WGPUDevice, device)); + procs.deviceReference.?(@as(c.WGPUDevice, @ptrCast(device))); } pub inline fn deviceRelease(device: *gpu.Device) void { - procs.deviceRelease.?(@ptrCast(c.WGPUDevice, device)); + procs.deviceRelease.?(@as(c.WGPUDevice, @ptrCast(device))); } pub inline fn externalTextureDestroy(external_texture: *gpu.ExternalTexture) void { - procs.externalTextureDestroy.?(@ptrCast(c.WGPUExternalTexture, external_texture)); + procs.externalTextureDestroy.?(@as(c.WGPUExternalTexture, @ptrCast(external_texture))); } pub inline fn externalTextureSetLabel(external_texture: *gpu.ExternalTexture, label: [*:0]const u8) void { - procs.externalTextureSetLabel.?(@ptrCast(c.WGPUExternalTexture, external_texture), label); + procs.externalTextureSetLabel.?(@as(c.WGPUExternalTexture, @ptrCast(external_texture)), label); } pub inline fn externalTextureReference(external_texture: *gpu.ExternalTexture) void { - procs.externalTextureReference.?(@ptrCast(c.WGPUExternalTexture, external_texture)); + procs.externalTextureReference.?(@as(c.WGPUExternalTexture, @ptrCast(external_texture))); } pub inline fn externalTextureRelease(external_texture: *gpu.ExternalTexture) void { - procs.externalTextureRelease.?(@ptrCast(c.WGPUExternalTexture, external_texture)); + procs.externalTextureRelease.?(@as(c.WGPUExternalTexture, @ptrCast(external_texture))); } pub inline fn instanceCreateSurface(instance: *gpu.Instance, descriptor: *const gpu.Surface.Descriptor) *gpu.Surface { - return @ptrCast(*gpu.Surface, procs.instanceCreateSurface.?( - @ptrCast(c.WGPUInstance, instance), - @ptrCast(*const c.WGPUSurfaceDescriptor, descriptor), - )); + return @as(*gpu.Surface, @ptrCast(procs.instanceCreateSurface.?( + @as(c.WGPUInstance, @ptrCast(instance)), + @as(*const c.WGPUSurfaceDescriptor, @ptrCast(descriptor)), + ))); } pub inline fn instanceProcessEvents(instance: *gpu.Instance) void { procs.instanceProcessEvents.?( - @ptrCast(c.WGPUInstance, instance), + @as(c.WGPUInstance, @ptrCast(instance)), ); } pub inline fn instanceRequestAdapter(instance: *gpu.Instance, options: ?*const gpu.RequestAdapterOptions, callback: gpu.RequestAdapterCallback, userdata: ?*anyopaque) void { procs.instanceRequestAdapter.?( - @ptrCast(c.WGPUInstance, instance), - @ptrCast(?*const c.WGPURequestAdapterOptions, options), - @ptrCast(c.WGPURequestAdapterCallback, callback), + @as(c.WGPUInstance, @ptrCast(instance)), + @as(?*const c.WGPURequestAdapterOptions, @ptrCast(options)), + @as(c.WGPURequestAdapterCallback, @ptrCast(callback)), userdata, ); } pub inline fn instanceReference(instance: *gpu.Instance) void { - procs.instanceReference.?(@ptrCast(c.WGPUInstance, instance)); + procs.instanceReference.?(@as(c.WGPUInstance, @ptrCast(instance))); } pub inline fn instanceRelease(instance: *gpu.Instance) void { - procs.instanceRelease.?(@ptrCast(c.WGPUInstance, instance)); + procs.instanceRelease.?(@as(c.WGPUInstance, @ptrCast(instance))); } pub inline fn pipelineLayoutSetLabel(pipeline_layout: *gpu.PipelineLayout, label: [*:0]const u8) void { - procs.pipelineLayoutSetLabel.?(@ptrCast(c.WGPUPipelineLayout, pipeline_layout), label); + procs.pipelineLayoutSetLabel.?(@as(c.WGPUPipelineLayout, @ptrCast(pipeline_layout)), label); } pub inline fn pipelineLayoutReference(pipeline_layout: *gpu.PipelineLayout) void { - procs.pipelineLayoutReference.?(@ptrCast(c.WGPUPipelineLayout, pipeline_layout)); + procs.pipelineLayoutReference.?(@as(c.WGPUPipelineLayout, @ptrCast(pipeline_layout))); } pub inline fn pipelineLayoutRelease(pipeline_layout: *gpu.PipelineLayout) void { - procs.pipelineLayoutRelease.?(@ptrCast(c.WGPUPipelineLayout, pipeline_layout)); + procs.pipelineLayoutRelease.?(@as(c.WGPUPipelineLayout, @ptrCast(pipeline_layout))); } pub inline fn querySetDestroy(query_set: *gpu.QuerySet) void { - procs.querySetDestroy.?(@ptrCast(c.WGPUQuerySet, query_set)); + procs.querySetDestroy.?(@as(c.WGPUQuerySet, @ptrCast(query_set))); } pub inline fn querySetGetCount(query_set: *gpu.QuerySet) u32 { - return procs.querySetGetCount.?(@ptrCast(c.WGPUQuerySet, query_set)); + return procs.querySetGetCount.?(@as(c.WGPUQuerySet, @ptrCast(query_set))); } pub inline fn querySetGetType(query_set: *gpu.QuerySet) gpu.QueryType { - return @enumFromInt(gpu.QueryType, procs.querySetGetType.?(@ptrCast(c.WGPUQuerySet, query_set))); + return @as(gpu.QueryType, @enumFromInt(procs.querySetGetType.?(@as(c.WGPUQuerySet, @ptrCast(query_set))))); } pub inline fn querySetSetLabel(query_set: *gpu.QuerySet, label: [*:0]const u8) void { - procs.querySetSetLabel.?(@ptrCast(c.WGPUQuerySet, query_set), label); + procs.querySetSetLabel.?(@as(c.WGPUQuerySet, @ptrCast(query_set)), label); } pub inline fn querySetReference(query_set: *gpu.QuerySet) void { - procs.querySetReference.?(@ptrCast(c.WGPUQuerySet, query_set)); + procs.querySetReference.?(@as(c.WGPUQuerySet, @ptrCast(query_set))); } pub inline fn querySetRelease(query_set: *gpu.QuerySet) void { - procs.querySetRelease.?(@ptrCast(c.WGPUQuerySet, query_set)); + procs.querySetRelease.?(@as(c.WGPUQuerySet, @ptrCast(query_set))); } pub inline fn queueCopyExternalTextureForBrowser(queue: *gpu.Queue, source: *const gpu.ImageCopyExternalTexture, destination: *const gpu.ImageCopyTexture, copy_size: *const gpu.Extent3D, options: *const gpu.CopyTextureForBrowserOptions) void { procs.queueCopyExternalTextureForBrowser.?( - @ptrCast(c.WGPUQueue, queue), - @ptrCast(*const c.ImageCopyExternalTexture, source), - @ptrCast(*const c.WGPUImageCopyTexture, destination), - @ptrCast(*const c.WGPUExtent3D, copy_size), - @ptrCast(*const c.WGPUCopyTextureForBrowserOptions, options), + @as(c.WGPUQueue, @ptrCast(queue)), + @as(*const c.ImageCopyExternalTexture, @ptrCast(source)), + @as(*const c.WGPUImageCopyTexture, @ptrCast(destination)), + @as(*const c.WGPUExtent3D, @ptrCast(copy_size)), + @as(*const c.WGPUCopyTextureForBrowserOptions, @ptrCast(options)), ); } pub inline fn queueCopyTextureForBrowser(queue: *gpu.Queue, source: *const gpu.ImageCopyTexture, destination: *const gpu.ImageCopyTexture, copy_size: *const gpu.Extent3D, options: *const gpu.CopyTextureForBrowserOptions) void { procs.queueCopyTextureForBrowser.?( - @ptrCast(c.WGPUQueue, queue), - @ptrCast(*const c.WGPUImageCopyTexture, source), - @ptrCast(*const c.WGPUImageCopyTexture, destination), - @ptrCast(*const c.WGPUExtent3D, copy_size), - @ptrCast(*const c.WGPUCopyTextureForBrowserOptions, options), + @as(c.WGPUQueue, @ptrCast(queue)), + @as(*const c.WGPUImageCopyTexture, @ptrCast(source)), + @as(*const c.WGPUImageCopyTexture, @ptrCast(destination)), + @as(*const c.WGPUExtent3D, @ptrCast(copy_size)), + @as(*const c.WGPUCopyTextureForBrowserOptions, @ptrCast(options)), ); } pub inline fn queueOnSubmittedWorkDone(queue: *gpu.Queue, signal_value: u64, callback: gpu.Queue.WorkDoneCallback, userdata: ?*anyopaque) void { procs.queueOnSubmittedWorkDone.?( - @ptrCast(c.WGPUQueue, queue), + @as(c.WGPUQueue, @ptrCast(queue)), signal_value, - @ptrCast(c.WGPUQueueWorkDoneCallback, callback), + @as(c.WGPUQueueWorkDoneCallback, @ptrCast(callback)), userdata, ); } pub inline fn queueSetLabel(queue: *gpu.Queue, label: [*:0]const u8) void { - procs.queueSetLabel.?(@ptrCast(c.WGPUQueue, queue), label); + procs.queueSetLabel.?(@as(c.WGPUQueue, @ptrCast(queue)), label); } pub inline fn queueSubmit(queue: *gpu.Queue, command_count: usize, commands: [*]const *const gpu.CommandBuffer) void { procs.queueSubmit.?( - @ptrCast(c.WGPUQueue, queue), + @as(c.WGPUQueue, @ptrCast(queue)), command_count, - @ptrCast([*]const c.WGPUCommandBuffer, commands), + @as([*]const c.WGPUCommandBuffer, @ptrCast(commands)), ); } pub inline fn queueWriteBuffer(queue: *gpu.Queue, buffer: *gpu.Buffer, buffer_offset: u64, data: *const anyopaque, size: usize) void { procs.queueWriteBuffer.?( - @ptrCast(c.WGPUQueue, queue), - @ptrCast(c.WGPUBuffer, buffer), + @as(c.WGPUQueue, @ptrCast(queue)), + @as(c.WGPUBuffer, @ptrCast(buffer)), buffer_offset, data, size, @@ -805,42 +805,42 @@ pub const Interface = struct { pub inline fn queueWriteTexture(queue: *gpu.Queue, destination: *const gpu.ImageCopyTexture, data: *const anyopaque, data_size: usize, data_layout: *const gpu.Texture.DataLayout, write_size: *const gpu.Extent3D) void { procs.queueWriteTexture.?( - @ptrCast(c.WGPUQueue, queue), - @ptrCast(*const c.WGPUImageCopyTexture, destination), + @as(c.WGPUQueue, @ptrCast(queue)), + @as(*const c.WGPUImageCopyTexture, @ptrCast(destination)), data, data_size, - @ptrCast(*const c.WGPUTextureDataLayout, data_layout), - @ptrCast(*const c.WGPUExtent3D, write_size), + @as(*const c.WGPUTextureDataLayout, @ptrCast(data_layout)), + @as(*const c.WGPUExtent3D, @ptrCast(write_size)), ); } pub inline fn queueReference(queue: *gpu.Queue) void { - procs.queueReference.?(@ptrCast(c.WGPUQueue, queue)); + procs.queueReference.?(@as(c.WGPUQueue, @ptrCast(queue))); } pub inline fn queueRelease(queue: *gpu.Queue) void { - procs.queueRelease.?(@ptrCast(c.WGPUQueue, queue)); + procs.queueRelease.?(@as(c.WGPUQueue, @ptrCast(queue))); } pub inline fn renderBundleSetLabel(render_bundle: *gpu.RenderBundle, label: [*:0]const u8) void { - procs.renderBundleSetLabel.?(@ptrCast(c.WGPURenderBundle, render_bundle), label); + procs.renderBundleSetLabel.?(@as(c.WGPURenderBundle, @ptrCast(render_bundle)), label); } pub inline fn renderBundleReference(render_bundle: *gpu.RenderBundle) void { - procs.renderBundleReference.?(@ptrCast(c.WGPURenderBundle, render_bundle)); + procs.renderBundleReference.?(@as(c.WGPURenderBundle, @ptrCast(render_bundle))); } pub inline fn renderBundleRelease(render_bundle: *gpu.RenderBundle) void { - procs.renderBundleRelease.?(@ptrCast(c.WGPURenderBundle, render_bundle)); + procs.renderBundleRelease.?(@as(c.WGPURenderBundle, @ptrCast(render_bundle))); } pub inline fn renderBundleEncoderDraw(render_bundle_encoder: *gpu.RenderBundleEncoder, vertex_count: u32, instance_count: u32, first_vertex: u32, first_instance: u32) void { - procs.renderBundleEncoderDraw.?(@ptrCast(c.WGPURenderBundleEncoder, render_bundle_encoder), vertex_count, instance_count, first_vertex, first_instance); + procs.renderBundleEncoderDraw.?(@as(c.WGPURenderBundleEncoder, @ptrCast(render_bundle_encoder)), vertex_count, instance_count, first_vertex, first_instance); } pub inline fn renderBundleEncoderDrawIndexed(render_bundle_encoder: *gpu.RenderBundleEncoder, index_count: u32, instance_count: u32, first_index: u32, base_vertex: i32, first_instance: u32) void { procs.renderBundleEncoderDrawIndexed.?( - @ptrCast(c.WGPURenderBundleEncoder, render_bundle_encoder), + @as(c.WGPURenderBundleEncoder, @ptrCast(render_bundle_encoder)), index_count, instance_count, first_index, @@ -851,47 +851,47 @@ pub const Interface = struct { pub inline fn renderBundleEncoderDrawIndexedIndirect(render_bundle_encoder: *gpu.RenderBundleEncoder, indirect_buffer: *gpu.Buffer, indirect_offset: u64) void { procs.renderBundleEncoderDrawIndexedIndirect.?( - @ptrCast(c.WGPURenderBundleEncoder, render_bundle_encoder), - @ptrCast(c.WGPUBuffer, indirect_buffer), + @as(c.WGPURenderBundleEncoder, @ptrCast(render_bundle_encoder)), + @as(c.WGPUBuffer, @ptrCast(indirect_buffer)), indirect_offset, ); } pub inline fn renderBundleEncoderDrawIndirect(render_bundle_encoder: *gpu.RenderBundleEncoder, indirect_buffer: *gpu.Buffer, indirect_offset: u64) void { procs.renderBundleEncoderDrawIndirect.?( - @ptrCast(c.WGPURenderBundleEncoder, render_bundle_encoder), - @ptrCast(c.WGPUBuffer, indirect_buffer), + @as(c.WGPURenderBundleEncoder, @ptrCast(render_bundle_encoder)), + @as(c.WGPUBuffer, @ptrCast(indirect_buffer)), indirect_offset, ); } pub inline fn renderBundleEncoderFinish(render_bundle_encoder: *gpu.RenderBundleEncoder, descriptor: ?*const gpu.RenderBundle.Descriptor) *gpu.RenderBundle { - return @ptrCast(*gpu.RenderBundle, procs.renderBundleEncoderFinish.?( - @ptrCast(c.WGPURenderBundleEncoder, render_bundle_encoder), - @ptrCast(?*const c.WGPURenderBundleDescriptor, descriptor), - )); + return @as(*gpu.RenderBundle, @ptrCast(procs.renderBundleEncoderFinish.?( + @as(c.WGPURenderBundleEncoder, @ptrCast(render_bundle_encoder)), + @as(?*const c.WGPURenderBundleDescriptor, @ptrCast(descriptor)), + ))); } pub inline fn renderBundleEncoderInsertDebugMarker(render_bundle_encoder: *gpu.RenderBundleEncoder, marker_label: [*:0]const u8) void { procs.renderBundleEncoderInsertDebugMarker.?( - @ptrCast(c.WGPURenderBundleEncoder, render_bundle_encoder), + @as(c.WGPURenderBundleEncoder, @ptrCast(render_bundle_encoder)), marker_label, ); } pub inline fn renderBundleEncoderPopDebugGroup(render_bundle_encoder: *gpu.RenderBundleEncoder) void { - procs.renderBundleEncoderPopDebugGroup.?(@ptrCast(c.WGPURenderBundleEncoder, render_bundle_encoder)); + procs.renderBundleEncoderPopDebugGroup.?(@as(c.WGPURenderBundleEncoder, @ptrCast(render_bundle_encoder))); } pub inline fn renderBundleEncoderPushDebugGroup(render_bundle_encoder: *gpu.RenderBundleEncoder, group_label: [*:0]const u8) void { - procs.renderBundleEncoderPushDebugGroup.?(@ptrCast(c.WGPURenderBundleEncoder, render_bundle_encoder), group_label); + procs.renderBundleEncoderPushDebugGroup.?(@as(c.WGPURenderBundleEncoder, @ptrCast(render_bundle_encoder)), group_label); } pub inline fn renderBundleEncoderSetBindGroup(render_bundle_encoder: *gpu.RenderBundleEncoder, group_index: u32, group: *gpu.BindGroup, dynamic_offset_count: usize, dynamic_offsets: ?[*]const u32) void { procs.renderBundleEncoderSetBindGroup.?( - @ptrCast(c.WGPURenderBundleEncoder, render_bundle_encoder), + @as(c.WGPURenderBundleEncoder, @ptrCast(render_bundle_encoder)), group_index, - @ptrCast(c.WGPUBindGroup, group), + @as(c.WGPUBindGroup, @ptrCast(group)), dynamic_offset_count, dynamic_offsets, ); @@ -899,8 +899,8 @@ pub const Interface = struct { pub inline fn renderBundleEncoderSetIndexBuffer(render_bundle_encoder: *gpu.RenderBundleEncoder, buffer: *gpu.Buffer, format: gpu.IndexFormat, offset: u64, size: u64) void { procs.renderBundleEncoderSetIndexBuffer.?( - @ptrCast(c.WGPURenderBundleEncoder, render_bundle_encoder), - @ptrCast(c.WGPUBuffer, buffer), + @as(c.WGPURenderBundleEncoder, @ptrCast(render_bundle_encoder)), + @as(c.WGPUBuffer, @ptrCast(buffer)), @intFromEnum(format), offset, size, @@ -908,44 +908,44 @@ pub const Interface = struct { } pub inline fn renderBundleEncoderSetLabel(render_bundle_encoder: *gpu.RenderBundleEncoder, label: [*:0]const u8) void { - procs.renderBundleEncoderSetLabel.?(@ptrCast(c.WGPURenderBundleEncoder, render_bundle_encoder), label); + procs.renderBundleEncoderSetLabel.?(@as(c.WGPURenderBundleEncoder, @ptrCast(render_bundle_encoder)), label); } pub inline fn renderBundleEncoderSetPipeline(render_bundle_encoder: *gpu.RenderBundleEncoder, pipeline: *gpu.RenderPipeline) void { procs.renderBundleEncoderSetPipeline.?( - @ptrCast(c.WGPURenderBundleEncoder, render_bundle_encoder), - @ptrCast(c.WGPURenderPipeline, pipeline), + @as(c.WGPURenderBundleEncoder, @ptrCast(render_bundle_encoder)), + @as(c.WGPURenderPipeline, @ptrCast(pipeline)), ); } pub inline fn renderBundleEncoderSetVertexBuffer(render_bundle_encoder: *gpu.RenderBundleEncoder, slot: u32, buffer: *gpu.Buffer, offset: u64, size: u64) void { procs.renderBundleEncoderSetVertexBuffer.?( - @ptrCast(c.WGPURenderBundleEncoder, render_bundle_encoder), + @as(c.WGPURenderBundleEncoder, @ptrCast(render_bundle_encoder)), slot, - @ptrCast(c.WGPUBuffer, buffer), + @as(c.WGPUBuffer, @ptrCast(buffer)), offset, size, ); } pub inline fn renderBundleEncoderReference(render_bundle_encoder: *gpu.RenderBundleEncoder) void { - procs.renderBundleEncoderReference.?(@ptrCast(c.WGPURenderBundleEncoder, render_bundle_encoder)); + procs.renderBundleEncoderReference.?(@as(c.WGPURenderBundleEncoder, @ptrCast(render_bundle_encoder))); } pub inline fn renderBundleEncoderRelease(render_bundle_encoder: *gpu.RenderBundleEncoder) void { - procs.renderBundleEncoderRelease.?(@ptrCast(c.WGPURenderBundleEncoder, render_bundle_encoder)); + procs.renderBundleEncoderRelease.?(@as(c.WGPURenderBundleEncoder, @ptrCast(render_bundle_encoder))); } pub inline fn renderPassEncoderBeginOcclusionQuery(render_pass_encoder: *gpu.RenderPassEncoder, query_index: u32) void { procs.renderPassEncoderBeginOcclusionQuery.?( - @ptrCast(c.WGPURenderPassEncoder, render_pass_encoder), + @as(c.WGPURenderPassEncoder, @ptrCast(render_pass_encoder)), query_index, ); } pub inline fn renderPassEncoderDraw(render_pass_encoder: *gpu.RenderPassEncoder, vertex_count: u32, instance_count: u32, first_vertex: u32, first_instance: u32) void { procs.renderPassEncoderDraw.?( - @ptrCast(c.WGPURenderPassEncoder, render_pass_encoder), + @as(c.WGPURenderPassEncoder, @ptrCast(render_pass_encoder)), vertex_count, instance_count, first_vertex, @@ -955,7 +955,7 @@ pub const Interface = struct { pub inline fn renderPassEncoderDrawIndexed(render_pass_encoder: *gpu.RenderPassEncoder, index_count: u32, instance_count: u32, first_index: u32, base_vertex: i32, first_instance: u32) void { procs.renderPassEncoderDrawIndexed.?( - @ptrCast(c.WGPURenderPassEncoder, render_pass_encoder), + @as(c.WGPURenderPassEncoder, @ptrCast(render_pass_encoder)), index_count, instance_count, first_index, @@ -966,56 +966,56 @@ pub const Interface = struct { pub inline fn renderPassEncoderDrawIndexedIndirect(render_pass_encoder: *gpu.RenderPassEncoder, indirect_buffer: *gpu.Buffer, indirect_offset: u64) void { procs.renderPassEncoderDrawIndexedIndirect.?( - @ptrCast(c.WGPURenderPassEncoder, render_pass_encoder), - @ptrCast(c.WGPUBuffer, indirect_buffer), + @as(c.WGPURenderPassEncoder, @ptrCast(render_pass_encoder)), + @as(c.WGPUBuffer, @ptrCast(indirect_buffer)), indirect_offset, ); } pub inline fn renderPassEncoderDrawIndirect(render_pass_encoder: *gpu.RenderPassEncoder, indirect_buffer: *gpu.Buffer, indirect_offset: u64) void { procs.renderPassEncoderDrawIndirect.?( - @ptrCast(c.WGPURenderPassEncoder, render_pass_encoder), - @ptrCast(c.WGPUBuffer, indirect_buffer), + @as(c.WGPURenderPassEncoder, @ptrCast(render_pass_encoder)), + @as(c.WGPUBuffer, @ptrCast(indirect_buffer)), indirect_offset, ); } pub inline fn renderPassEncoderEnd(render_pass_encoder: *gpu.RenderPassEncoder) void { - procs.renderPassEncoderEnd.?(@ptrCast(c.WGPURenderPassEncoder, render_pass_encoder)); + procs.renderPassEncoderEnd.?(@as(c.WGPURenderPassEncoder, @ptrCast(render_pass_encoder))); } pub inline fn renderPassEncoderEndOcclusionQuery(render_pass_encoder: *gpu.RenderPassEncoder) void { - procs.renderPassEncoderEndOcclusionQuery.?(@ptrCast(c.WGPURenderPassEncoder, render_pass_encoder)); + procs.renderPassEncoderEndOcclusionQuery.?(@as(c.WGPURenderPassEncoder, @ptrCast(render_pass_encoder))); } pub inline fn renderPassEncoderExecuteBundles(render_pass_encoder: *gpu.RenderPassEncoder, bundles_count: usize, bundles: [*]const *const gpu.RenderBundle) void { procs.renderPassEncoderExecuteBundles.?( - @ptrCast(c.WGPURenderPassEncoder, render_pass_encoder), + @as(c.WGPURenderPassEncoder, @ptrCast(render_pass_encoder)), bundles_count, - @ptrCast([*]const c.WGPURenderBundle, bundles), + @as([*]const c.WGPURenderBundle, @ptrCast(bundles)), ); } pub inline fn renderPassEncoderInsertDebugMarker(render_pass_encoder: *gpu.RenderPassEncoder, marker_label: [*:0]const u8) void { - procs.renderPassEncoderInsertDebugMarker.?(@ptrCast(c.WGPURenderPassEncoder, render_pass_encoder), marker_label); + procs.renderPassEncoderInsertDebugMarker.?(@as(c.WGPURenderPassEncoder, @ptrCast(render_pass_encoder)), marker_label); } pub inline fn renderPassEncoderPopDebugGroup(render_pass_encoder: *gpu.RenderPassEncoder) void { - procs.renderPassEncoderPopDebugGroup.?(@ptrCast(c.WGPURenderPassEncoder, render_pass_encoder)); + procs.renderPassEncoderPopDebugGroup.?(@as(c.WGPURenderPassEncoder, @ptrCast(render_pass_encoder))); } pub inline fn renderPassEncoderPushDebugGroup(render_pass_encoder: *gpu.RenderPassEncoder, group_label: [*:0]const u8) void { procs.renderPassEncoderPushDebugGroup.?( - @ptrCast(c.WGPURenderPassEncoder, render_pass_encoder), + @as(c.WGPURenderPassEncoder, @ptrCast(render_pass_encoder)), group_label, ); } pub inline fn renderPassEncoderSetBindGroup(render_pass_encoder: *gpu.RenderPassEncoder, group_index: u32, group: *gpu.BindGroup, dynamic_offset_count: usize, dynamic_offsets: ?[*]const u32) void { procs.renderPassEncoderSetBindGroup.?( - @ptrCast(c.WGPURenderPassEncoder, render_pass_encoder), + @as(c.WGPURenderPassEncoder, @ptrCast(render_pass_encoder)), group_index, - @ptrCast(c.WGPUBindGroup, group), + @as(c.WGPUBindGroup, @ptrCast(group)), dynamic_offset_count, dynamic_offsets, ); @@ -1023,15 +1023,15 @@ pub const Interface = struct { pub inline fn renderPassEncoderSetBlendConstant(render_pass_encoder: *gpu.RenderPassEncoder, color: *const gpu.Color) void { procs.renderPassEncoderSetBlendConstant.?( - @ptrCast(c.WGPURenderPassEncoder, render_pass_encoder), - @ptrCast(*const c.WGPUColor, color), + @as(c.WGPURenderPassEncoder, @ptrCast(render_pass_encoder)), + @as(*const c.WGPUColor, @ptrCast(color)), ); } pub inline fn renderPassEncoderSetIndexBuffer(render_pass_encoder: *gpu.RenderPassEncoder, buffer: *gpu.Buffer, format: gpu.IndexFormat, offset: u64, size: u64) void { procs.renderPassEncoderSetIndexBuffer.?( - @ptrCast(c.WGPURenderPassEncoder, render_pass_encoder), - @ptrCast(c.WGPUBuffer, buffer), + @as(c.WGPURenderPassEncoder, @ptrCast(render_pass_encoder)), + @as(c.WGPUBuffer, @ptrCast(buffer)), @intFromEnum(format), offset, size, @@ -1039,19 +1039,19 @@ pub const Interface = struct { } pub inline fn renderPassEncoderSetLabel(render_pass_encoder: *gpu.RenderPassEncoder, label: [*:0]const u8) void { - procs.renderPassEncoderSetLabel.?(@ptrCast(c.WGPURenderPassEncoder, render_pass_encoder), label); + procs.renderPassEncoderSetLabel.?(@as(c.WGPURenderPassEncoder, @ptrCast(render_pass_encoder)), label); } pub inline fn renderPassEncoderSetPipeline(render_pass_encoder: *gpu.RenderPassEncoder, pipeline: *gpu.RenderPipeline) void { procs.renderPassEncoderSetPipeline.?( - @ptrCast(c.WGPURenderPassEncoder, render_pass_encoder), - @ptrCast(c.WGPURenderPipeline, pipeline), + @as(c.WGPURenderPassEncoder, @ptrCast(render_pass_encoder)), + @as(c.WGPURenderPipeline, @ptrCast(pipeline)), ); } pub inline fn renderPassEncoderSetScissorRect(render_pass_encoder: *gpu.RenderPassEncoder, x: u32, y: u32, width: u32, height: u32) void { procs.renderPassEncoderSetScissorRect.?( - @ptrCast(c.WGPURenderPassEncoder, render_pass_encoder), + @as(c.WGPURenderPassEncoder, @ptrCast(render_pass_encoder)), x, y, width, @@ -1061,16 +1061,16 @@ pub const Interface = struct { pub inline fn renderPassEncoderSetStencilReference(render_pass_encoder: *gpu.RenderPassEncoder, reference: u32) void { procs.renderPassEncoderSetStencilReference.?( - @ptrCast(c.WGPURenderPassEncoder, render_pass_encoder), + @as(c.WGPURenderPassEncoder, @ptrCast(render_pass_encoder)), reference, ); } pub inline fn renderPassEncoderSetVertexBuffer(render_pass_encoder: *gpu.RenderPassEncoder, slot: u32, buffer: *gpu.Buffer, offset: u64, size: u64) void { procs.renderPassEncoderSetVertexBuffer.?( - @ptrCast(c.WGPURenderPassEncoder, render_pass_encoder), + @as(c.WGPURenderPassEncoder, @ptrCast(render_pass_encoder)), slot, - @ptrCast(c.WGPUBuffer, buffer), + @as(c.WGPUBuffer, @ptrCast(buffer)), offset, size, ); @@ -1078,7 +1078,7 @@ pub const Interface = struct { pub inline fn renderPassEncoderSetViewport(render_pass_encoder: *gpu.RenderPassEncoder, x: f32, y: f32, width: f32, height: f32, min_depth: f32, max_depth: f32) void { procs.renderPassEncoderSetViewport.?( - @ptrCast(c.WGPURenderPassEncoder, render_pass_encoder), + @as(c.WGPURenderPassEncoder, @ptrCast(render_pass_encoder)), x, y, width, @@ -1090,166 +1090,166 @@ pub const Interface = struct { pub inline fn renderPassEncoderWriteTimestamp(render_pass_encoder: *gpu.RenderPassEncoder, query_set: *gpu.QuerySet, query_index: u32) void { procs.renderPassEncoderWriteTimestamp.?( - @ptrCast(c.WGPURenderPassEncoder, render_pass_encoder), - @ptrCast(c.WGPUQuerySet, query_set), + @as(c.WGPURenderPassEncoder, @ptrCast(render_pass_encoder)), + @as(c.WGPUQuerySet, @ptrCast(query_set)), query_index, ); } pub inline fn renderPassEncoderReference(render_pass_encoder: *gpu.RenderPassEncoder) void { - procs.renderPassEncoderReference.?(@ptrCast(c.WGPURenderPassEncoder, render_pass_encoder)); + procs.renderPassEncoderReference.?(@as(c.WGPURenderPassEncoder, @ptrCast(render_pass_encoder))); } pub inline fn renderPassEncoderRelease(render_pass_encoder: *gpu.RenderPassEncoder) void { - procs.renderPassEncoderRelease.?(@ptrCast(c.WGPURenderPassEncoder, render_pass_encoder)); + procs.renderPassEncoderRelease.?(@as(c.WGPURenderPassEncoder, @ptrCast(render_pass_encoder))); } pub inline fn renderPipelineGetBindGroupLayout(render_pipeline: *gpu.RenderPipeline, group_index: u32) *gpu.BindGroupLayout { - return @ptrCast(*gpu.BindGroupLayout, procs.renderPipelineGetBindGroupLayout.?( - @ptrCast(c.WGPURenderPipeline, render_pipeline), + return @as(*gpu.BindGroupLayout, @ptrCast(procs.renderPipelineGetBindGroupLayout.?( + @as(c.WGPURenderPipeline, @ptrCast(render_pipeline)), group_index, - )); + ))); } pub inline fn renderPipelineSetLabel(render_pipeline: *gpu.RenderPipeline, label: [*:0]const u8) void { - procs.renderPipelineSetLabel.?(@ptrCast(c.WGPURenderPipeline, render_pipeline), label); + procs.renderPipelineSetLabel.?(@as(c.WGPURenderPipeline, @ptrCast(render_pipeline)), label); } pub inline fn renderPipelineReference(render_pipeline: *gpu.RenderPipeline) void { - procs.renderPipelineReference.?(@ptrCast(c.WGPURenderPipeline, render_pipeline)); + procs.renderPipelineReference.?(@as(c.WGPURenderPipeline, @ptrCast(render_pipeline))); } pub inline fn renderPipelineRelease(render_pipeline: *gpu.RenderPipeline) void { - procs.renderPipelineRelease.?(@ptrCast(c.WGPURenderPipeline, render_pipeline)); + procs.renderPipelineRelease.?(@as(c.WGPURenderPipeline, @ptrCast(render_pipeline))); } pub inline fn samplerSetLabel(sampler: *gpu.Sampler, label: [*:0]const u8) void { - procs.samplerSetLabel.?(@ptrCast(c.WGPUSampler, sampler), label); + procs.samplerSetLabel.?(@as(c.WGPUSampler, @ptrCast(sampler)), label); } pub inline fn samplerReference(sampler: *gpu.Sampler) void { - procs.samplerReference.?(@ptrCast(c.WGPUSampler, sampler)); + procs.samplerReference.?(@as(c.WGPUSampler, @ptrCast(sampler))); } pub inline fn samplerRelease(sampler: *gpu.Sampler) void { - procs.samplerRelease.?(@ptrCast(c.WGPUSampler, sampler)); + procs.samplerRelease.?(@as(c.WGPUSampler, @ptrCast(sampler))); } pub inline fn shaderModuleGetCompilationInfo(shader_module: *gpu.ShaderModule, callback: gpu.CompilationInfoCallback, userdata: ?*anyopaque) void { procs.shaderModuleGetCompilationInfo.?( - @ptrCast(c.WGPUShaderModule, shader_module), - @ptrCast(c.WGPUCompilationInfoCallback, callback), + @as(c.WGPUShaderModule, @ptrCast(shader_module)), + @as(c.WGPUCompilationInfoCallback, @ptrCast(callback)), userdata, ); } pub inline fn shaderModuleSetLabel(shader_module: *gpu.ShaderModule, label: [*:0]const u8) void { - procs.shaderModuleSetLabel.?(@ptrCast(c.WGPUShaderModule, shader_module), label); + procs.shaderModuleSetLabel.?(@as(c.WGPUShaderModule, @ptrCast(shader_module)), label); } pub inline fn shaderModuleReference(shader_module: *gpu.ShaderModule) void { - procs.shaderModuleReference.?(@ptrCast(c.WGPUShaderModule, shader_module)); + procs.shaderModuleReference.?(@as(c.WGPUShaderModule, @ptrCast(shader_module))); } pub inline fn shaderModuleRelease(shader_module: *gpu.ShaderModule) void { - procs.shaderModuleRelease.?(@ptrCast(c.WGPUShaderModule, shader_module)); + procs.shaderModuleRelease.?(@as(c.WGPUShaderModule, @ptrCast(shader_module))); } pub inline fn surfaceReference(surface: *gpu.Surface) void { - procs.surfaceReference.?(@ptrCast(c.WGPUSurface, surface)); + procs.surfaceReference.?(@as(c.WGPUSurface, @ptrCast(surface))); } pub inline fn surfaceRelease(surface: *gpu.Surface) void { - procs.surfaceRelease.?(@ptrCast(c.WGPUSurface, surface)); + procs.surfaceRelease.?(@as(c.WGPUSurface, @ptrCast(surface))); } pub inline fn swapChainGetCurrentTexture(swap_chain: *gpu.SwapChain) ?*gpu.Texture { - return @ptrCast(?*gpu.Texture, procs.swapChainGetCurrentTexture.?(@ptrCast(c.WGPUSwapChain, swap_chain))); + return @as(?*gpu.Texture, @ptrCast(procs.swapChainGetCurrentTexture.?(@as(c.WGPUSwapChain, @ptrCast(swap_chain))))); } pub inline fn swapChainGetCurrentTextureView(swap_chain: *gpu.SwapChain) ?*gpu.TextureView { - return @ptrCast(?*gpu.TextureView, procs.swapChainGetCurrentTextureView.?(@ptrCast(c.WGPUSwapChain, swap_chain))); + return @as(?*gpu.TextureView, @ptrCast(procs.swapChainGetCurrentTextureView.?(@as(c.WGPUSwapChain, @ptrCast(swap_chain))))); } pub inline fn swapChainPresent(swap_chain: *gpu.SwapChain) void { - procs.swapChainPresent.?(@ptrCast(c.WGPUSwapChain, swap_chain)); + procs.swapChainPresent.?(@as(c.WGPUSwapChain, @ptrCast(swap_chain))); } pub inline fn swapChainReference(swap_chain: *gpu.SwapChain) void { - procs.swapChainReference.?(@ptrCast(c.WGPUSwapChain, swap_chain)); + procs.swapChainReference.?(@as(c.WGPUSwapChain, @ptrCast(swap_chain))); } pub inline fn swapChainRelease(swap_chain: *gpu.SwapChain) void { - procs.swapChainRelease.?(@ptrCast(c.WGPUSwapChain, swap_chain)); + procs.swapChainRelease.?(@as(c.WGPUSwapChain, @ptrCast(swap_chain))); } pub inline fn textureCreateView(texture: *gpu.Texture, descriptor: ?*const gpu.TextureView.Descriptor) *gpu.TextureView { - return @ptrCast(*gpu.TextureView, procs.textureCreateView.?( - @ptrCast(c.WGPUTexture, texture), - @ptrCast(?*const c.WGPUTextureViewDescriptor, descriptor), - )); + return @as(*gpu.TextureView, @ptrCast(procs.textureCreateView.?( + @as(c.WGPUTexture, @ptrCast(texture)), + @as(?*const c.WGPUTextureViewDescriptor, @ptrCast(descriptor)), + ))); } pub inline fn textureDestroy(texture: *gpu.Texture) void { - procs.textureDestroy.?(@ptrCast(c.WGPUTexture, texture)); + procs.textureDestroy.?(@as(c.WGPUTexture, @ptrCast(texture))); } pub inline fn textureGetDepthOrArrayLayers(texture: *gpu.Texture) u32 { - return procs.textureGetDepthOrArrayLayers.?(@ptrCast(c.WGPUTexture, texture)); + return procs.textureGetDepthOrArrayLayers.?(@as(c.WGPUTexture, @ptrCast(texture))); } pub inline fn textureGetDimension(texture: *gpu.Texture) gpu.Texture.Dimension { - return @enumFromInt(gpu.Texture.Dimension, procs.textureGetDimension.?(@ptrCast(c.WGPUTexture, texture))); + return @as(gpu.Texture.Dimension, @enumFromInt(procs.textureGetDimension.?(@as(c.WGPUTexture, @ptrCast(texture))))); } pub inline fn textureGetFormat(texture: *gpu.Texture) gpu.Texture.Format { - return @enumFromInt(gpu.Texture.Format, procs.textureGetFormat.?(@ptrCast(c.WGPUTexture, texture))); + return @as(gpu.Texture.Format, @enumFromInt(procs.textureGetFormat.?(@as(c.WGPUTexture, @ptrCast(texture))))); } pub inline fn textureGetHeight(texture: *gpu.Texture) u32 { - return procs.textureGetHeight.?(@ptrCast(c.WGPUTexture, texture)); + return procs.textureGetHeight.?(@as(c.WGPUTexture, @ptrCast(texture))); } pub inline fn textureGetMipLevelCount(texture: *gpu.Texture) u32 { - return procs.textureGetMipLevelCount.?(@ptrCast(c.WGPUTexture, texture)); + return procs.textureGetMipLevelCount.?(@as(c.WGPUTexture, @ptrCast(texture))); } pub inline fn textureGetSampleCount(texture: *gpu.Texture) u32 { - return procs.textureGetSampleCount.?(@ptrCast(c.WGPUTexture, texture)); + return procs.textureGetSampleCount.?(@as(c.WGPUTexture, @ptrCast(texture))); } pub inline fn textureGetUsage(texture: *gpu.Texture) gpu.Texture.UsageFlags { - return @bitCast(gpu.Texture.UsageFlags, procs.textureGetUsage.?( - @ptrCast(c.WGPUTexture, texture), - )); + return @as(gpu.Texture.UsageFlags, @bitCast(procs.textureGetUsage.?( + @as(c.WGPUTexture, @ptrCast(texture)), + ))); } pub inline fn textureGetWidth(texture: *gpu.Texture) u32 { - return procs.textureGetWidth.?(@ptrCast(c.WGPUTexture, texture)); + return procs.textureGetWidth.?(@as(c.WGPUTexture, @ptrCast(texture))); } pub inline fn textureSetLabel(texture: *gpu.Texture, label: [*:0]const u8) void { - procs.textureSetLabel.?(@ptrCast(c.WGPUTexture, texture), label); + procs.textureSetLabel.?(@as(c.WGPUTexture, @ptrCast(texture)), label); } pub inline fn textureReference(texture: *gpu.Texture) void { - procs.textureReference.?(@ptrCast(c.WGPUTexture, texture)); + procs.textureReference.?(@as(c.WGPUTexture, @ptrCast(texture))); } pub inline fn textureRelease(texture: *gpu.Texture) void { - procs.textureRelease.?(@ptrCast(c.WGPUTexture, texture)); + procs.textureRelease.?(@as(c.WGPUTexture, @ptrCast(texture))); } pub inline fn textureViewSetLabel(texture_view: *gpu.TextureView, label: [*:0]const u8) void { - procs.textureViewSetLabel.?(@ptrCast(c.WGPUTextureView, texture_view), label); + procs.textureViewSetLabel.?(@as(c.WGPUTextureView, @ptrCast(texture_view)), label); } pub inline fn textureViewReference(texture_view: *gpu.TextureView) void { - procs.textureViewReference.?(@ptrCast(c.WGPUTextureView, texture_view)); + procs.textureViewReference.?(@as(c.WGPUTextureView, @ptrCast(texture_view))); } pub inline fn textureViewRelease(texture_view: *gpu.TextureView) void { - procs.textureViewRelease.?(@ptrCast(c.WGPUTextureView, texture_view)); + procs.textureViewRelease.?(@as(c.WGPUTextureView, @ptrCast(texture_view))); } }; diff --git a/libs/gpu/src/device.zig b/libs/gpu/src/device.zig index eb7e58cc..06a00d71 100644 --- a/libs/gpu/src/device.zig +++ b/libs/gpu/src/device.zig @@ -120,7 +120,7 @@ pub const Device = opaque { status, compute_pipeline, message, - if (Context == void) {} else @ptrCast(Context, @alignCast(@alignOf(Context), userdata)), + if (Context == void) {} else @as(Context, @ptrCast(@alignCast(@alignOf(Context), userdata))), ); } }; @@ -179,7 +179,7 @@ pub const Device = opaque { userdata: ?*anyopaque, ) callconv(.C) void { callback( - if (Context == void) {} else @ptrCast(Context, @alignCast(@alignOf(Context), userdata)), + if (Context == void) {} else @as(Context, @ptrCast(@alignCast(@alignOf(Context), userdata))), status, pipeline, message, @@ -271,7 +271,7 @@ pub const Device = opaque { const Context = @TypeOf(context); const Helper = struct { pub fn cCallback(typ: ErrorType, message: [*:0]const u8, userdata: ?*anyopaque) callconv(.C) void { - callback(if (Context == void) {} else @ptrCast(Context, @alignCast(@alignOf(std.meta.Child(Context)), userdata)), typ, message); + callback(if (Context == void) {} else @as(Context, @ptrCast(@alignCast(@alignOf(std.meta.Child(Context)), userdata))), typ, message); } }; Impl.devicePopErrorScope(device, Helper.cCallback, if (Context == void) null else context); @@ -290,7 +290,7 @@ pub const Device = opaque { const Context = @TypeOf(context); const Helper = struct { pub fn cCallback(reason: LostReason, message: [*:0]const u8, userdata: ?*anyopaque) callconv(.C) void { - cb(if (Context == void) {} else @ptrCast(Context, @alignCast(@alignOf(std.meta.Child(Context)), userdata)), reason, message); + cb(if (Context == void) {} else @as(Context, @ptrCast(@alignCast(@alignOf(std.meta.Child(Context)), userdata))), reason, message); } }; Impl.deviceSetDeviceLostCallback(device, Helper.cCallback, if (Context == void) null else context); @@ -312,7 +312,7 @@ pub const Device = opaque { const Context = @TypeOf(context); const Helper = struct { pub fn cCallback(typ: LoggingType, message: [*:0]const u8, userdata: ?*anyopaque) callconv(.C) void { - cb(if (Context == void) {} else @ptrCast(Context, @alignCast(@alignOf(std.meta.Child(Context)), userdata)), typ, message); + cb(if (Context == void) {} else @as(Context, @ptrCast(@alignCast(@alignOf(std.meta.Child(Context)), userdata))), typ, message); } }; Impl.deviceSetLoggingCallback(device, Helper.cCallback, if (Context == void) null else context); @@ -330,7 +330,7 @@ pub const Device = opaque { const Context = @TypeOf(context); const Helper = struct { pub fn cCallback(typ: ErrorType, message: [*:0]const u8, userdata: ?*anyopaque) callconv(.C) void { - cb(if (Context == void) {} else @ptrCast(Context, @alignCast(@alignOf(std.meta.Child(Context)), userdata)), typ, message); + cb(if (Context == void) {} else @as(Context, @ptrCast(@alignCast(@alignOf(std.meta.Child(Context)), userdata))), typ, message); } }; Impl.deviceSetUncapturedErrorCallback(device, Helper.cCallback, if (Context == void) null else context); diff --git a/libs/gpu/src/instance.zig b/libs/gpu/src/instance.zig index a9396725..aca679fb 100644 --- a/libs/gpu/src/instance.zig +++ b/libs/gpu/src/instance.zig @@ -45,7 +45,7 @@ pub const Instance = opaque { userdata: ?*anyopaque, ) callconv(.C) void { callback( - if (Context == void) {} else @ptrCast(Context, @alignCast(@alignOf(Context), userdata)), + if (Context == void) {} else @as(Context, @ptrCast(@alignCast(@alignOf(Context), userdata))), status, adapter, message, diff --git a/libs/gpu/src/interface.zig b/libs/gpu/src/interface.zig index 5ba96f40..bf714caa 100644 --- a/libs/gpu/src/interface.zig +++ b/libs/gpu/src/interface.zig @@ -344,7 +344,7 @@ pub fn Export(comptime T: type) type { // WGPU_EXPORT void wgpuBufferMapAsync(WGPUBuffer buffer, WGPUMapModeFlags mode, size_t offset, size_t size, WGPUBufferMapCallback callback, void * userdata); export fn wgpuBufferMapAsync(buffer: *gpu.Buffer, mode: u32, offset: usize, size: usize, callback: gpu.Buffer.MapCallback, userdata: ?*anyopaque) void { - T.bufferMapAsync(buffer, @bitCast(gpu.MapModeFlags, mode), offset, size, callback, userdata); + T.bufferMapAsync(buffer, @as(gpu.MapModeFlags, @bitCast(mode)), offset, size, callback, userdata); } // WGPU_EXPORT void wgpuBufferSetLabel(WGPUBuffer buffer, char const * label); diff --git a/libs/gpu/src/main.zig b/libs/gpu/src/main.zig index b562d482..9b9ac8bb 100644 --- a/libs/gpu/src/main.zig +++ b/libs/gpu/src/main.zig @@ -478,7 +478,7 @@ pub const ColorWriteMaskFlags = packed struct(u32) { }; pub fn equal(a: ColorWriteMaskFlags, b: ColorWriteMaskFlags) bool { - return @truncate(u4, @bitCast(u32, a)) == @truncate(u4, @bitCast(u32, b)); + return @as(u4, @truncate(@as(u32, @bitCast(a)))) == @as(u4, @truncate(@as(u32, @bitCast(b)))); } }; @@ -498,7 +498,7 @@ pub const MapModeFlags = packed struct(u32) { pub const undef = MapModeFlags{}; pub fn equal(a: MapModeFlags, b: MapModeFlags) bool { - return @truncate(u2, @bitCast(u32, a)) == @truncate(u2, @bitCast(u32, b)); + return @as(u2, @truncate(@as(u32, @bitCast(a)))) == @as(u2, @truncate(@as(u32, @bitCast(b)))); } }; @@ -519,7 +519,7 @@ pub const ShaderStageFlags = packed struct(u32) { pub const none = ShaderStageFlags{}; pub fn equal(a: ShaderStageFlags, b: ShaderStageFlags) bool { - return @truncate(u3, @bitCast(u32, a)) == @truncate(u3, @bitCast(u32, b)); + return @as(u3, @truncate(@as(u32, @bitCast(a)))) == @as(u3, @truncate(@as(u32, @bitCast(b)))); } }; diff --git a/libs/gpu/src/queue.zig b/libs/gpu/src/queue.zig index 3da7d39d..5bf45f9e 100644 --- a/libs/gpu/src/queue.zig +++ b/libs/gpu/src/queue.zig @@ -45,7 +45,7 @@ pub const Queue = opaque { const Context = @TypeOf(context); const Helper = struct { pub fn cCallback(status: WorkDoneStatus, userdata: ?*anyopaque) callconv(.C) void { - callback(if (Context == void) {} else @ptrCast(Context, @alignCast(@alignOf(std.meta.Child(Context)), userdata)), status); + callback(if (Context == void) {} else @as(Context, @ptrCast(@alignCast(@alignOf(std.meta.Child(Context)), userdata))), status); } }; Impl.queueOnSubmittedWorkDone(queue, signal_value, Helper.cCallback, if (Context == void) null else context); @@ -69,7 +69,7 @@ pub const Queue = opaque { queue, buffer, buffer_offset_bytes, - @ptrCast(*const anyopaque, std.mem.sliceAsBytes(data_slice).ptr), + @as(*const anyopaque, @ptrCast(std.mem.sliceAsBytes(data_slice).ptr)), data_slice.len * @sizeOf(std.meta.Elem(@TypeOf(data_slice))), ); } @@ -84,8 +84,8 @@ pub const Queue = opaque { Impl.queueWriteTexture( queue, destination, - @ptrCast(*const anyopaque, std.mem.sliceAsBytes(data_slice).ptr), - @intCast(usize, data_slice.len) * @sizeOf(std.meta.Elem(@TypeOf(data_slice))), + @as(*const anyopaque, @ptrCast(std.mem.sliceAsBytes(data_slice).ptr)), + @as(usize, @intCast(data_slice.len)) * @sizeOf(std.meta.Elem(@TypeOf(data_slice))), data_layout, write_size, ); diff --git a/libs/gpu/src/shader_module.zig b/libs/gpu/src/shader_module.zig index 81982a9d..9f3a363f 100644 --- a/libs/gpu/src/shader_module.zig +++ b/libs/gpu/src/shader_module.zig @@ -46,7 +46,7 @@ pub const ShaderModule = opaque { userdata: ?*anyopaque, ) callconv(.C) void { callback( - if (Context == void) {} else @ptrCast(Context, @alignCast(@alignOf(Context), userdata)), + if (Context == void) {} else @as(Context, @ptrCast(@alignCast(@alignOf(Context), userdata))), status, compilation_info, ); diff --git a/libs/gpu/src/texture.zig b/libs/gpu/src/texture.zig index 3f17567d..15c233dc 100644 --- a/libs/gpu/src/texture.zig +++ b/libs/gpu/src/texture.zig @@ -149,7 +149,7 @@ pub const Texture = opaque { pub const none = UsageFlags{}; pub fn equal(a: UsageFlags, b: UsageFlags) bool { - return @truncate(u6, @bitCast(u32, a)) == @truncate(u6, @bitCast(u32, b)); + return @as(u6, @truncate(@as(u32, @bitCast(a)))) == @as(u6, @truncate(@as(u32, @bitCast(b)))); } }; diff --git a/libs/model3d/src/main.zig b/libs/model3d/src/main.zig index f367f823..d27f0a3e 100644 --- a/libs/model3d/src/main.zig +++ b/libs/model3d/src/main.zig @@ -64,7 +64,7 @@ pub fn save(self: M3d, quality: Quality, flags: Flags) Error![]u8 { return if (c.m3d_save( self.handle, @intFromEnum(quality), - @bitCast(c_int, flags), + @as(c_int, @bitCast(flags)), &size, )) |res| res[0..size] diff --git a/libs/sysaudio/examples/sine-wave.zig b/libs/sysaudio/examples/sine-wave.zig index 6a4b74a8..b791fb3b 100644 --- a/libs/sysaudio/examples/sine-wave.zig +++ b/libs/sysaudio/examples/sine-wave.zig @@ -53,12 +53,12 @@ const pitch = 440.0; const radians_per_second = pitch * 2.0 * std.math.pi; var seconds_offset: f32 = 0.0; fn writeCallback(_: ?*anyopaque, frames: usize) void { - const seconds_per_frame = 1.0 / @floatFromInt(f32, player.sampleRate()); + const seconds_per_frame = 1.0 / @as(f32, @floatFromInt(player.sampleRate())); for (0..frames) |fi| { - const sample = std.math.sin((seconds_offset + @floatFromInt(f32, fi) * seconds_per_frame) * radians_per_second); + const sample = std.math.sin((seconds_offset + @as(f32, @floatFromInt(fi)) * seconds_per_frame) * radians_per_second); player.writeAll(fi, sample); } - seconds_offset = @mod(seconds_offset + seconds_per_frame * @floatFromInt(f32, frames), 1.0); + seconds_offset = @mod(seconds_offset + seconds_per_frame * @as(f32, @floatFromInt(frames)), 1.0); } fn deviceChange(_: ?*anyopaque) void { diff --git a/libs/sysaudio/src/alsa.zig b/libs/sysaudio/src/alsa.zig index 679726eb..8897f787 100644 --- a/libs/sysaudio/src/alsa.zig +++ b/libs/sysaudio/src/alsa.zig @@ -134,7 +134,7 @@ pub const Context = struct { pub fn init(allocator: std.mem.Allocator, options: main.Context.Options) !backends.BackendContext { try lib.load(); - _ = lib.snd_lib_error_set_handler(@ptrCast(c.snd_lib_error_handler_t, &util.doNothing)); + _ = lib.snd_lib_error_set_handler(@as(c.snd_lib_error_handler_t, @ptrCast(&util.doNothing))); var self = try allocator.create(Context); errdefer allocator.destroy(self); @@ -273,8 +273,8 @@ pub const Context = struct { var i: usize = 0; var evt: *inotify_event = undefined; while (i < buf.len) : (i += @sizeOf(inotify_event) + evt.len) { - evt = @ptrCast(*inotify_event, @alignCast(4, buf[i..])); - const evt_name = @ptrCast([*]u8, buf[i..])[@sizeOf(inotify_event) .. @sizeOf(inotify_event) + 8]; + evt = @as(*inotify_event, @ptrCast(@alignCast(4, buf[i..]))); + const evt_name = @as([*]u8, @ptrCast(buf[i..]))[@sizeOf(inotify_event) .. @sizeOf(inotify_event) + 8]; if (evt.mask & std.os.linux.IN.ISDIR != 0 or !std.mem.startsWith(u8, evt_name, "pcm")) continue; @@ -320,7 +320,7 @@ pub const Context = struct { if (lib.snd_ctl_pcm_next_device(ctl, &dev_idx) < 0) return error.SystemResources; - lib.snd_pcm_info_set_device(pcm_info, @intCast(c_uint, dev_idx)); + lib.snd_pcm_info_set_device(pcm_info, @as(c_uint, @intCast(dev_idx))); lib.snd_pcm_info_set_subdevice(pcm_info, 0); const name = std.mem.span(lib.snd_pcm_info_get_name(pcm_info) orelse continue); @@ -328,7 +328,7 @@ pub const Context = struct { const snd_stream = modeToStream(mode); lib.snd_pcm_info_set_stream(pcm_info, snd_stream); const err = lib.snd_ctl_pcm_info(ctl, pcm_info); - switch (@enumFromInt(std.os.E, -err)) { + switch (@as(std.os.E, @enumFromInt(-err))) { .SUCCESS => {}, .NOENT, .NXIO, @@ -417,8 +417,8 @@ pub const Context = struct { if (lib.snd_pcm_hw_params_get_rate_max(params, &rate_max, null) < 0) continue; break :blk .{ - .min = @intCast(u24, rate_min), - .max = @intCast(u24, rate_max), + .min = @as(u24, @intCast(rate_min)), + .max = @as(u24, @intCast(rate_max)), }; }, .id = try self.allocator.dupeZ(u8, id), @@ -464,7 +464,7 @@ pub const Context = struct { pcm, toAlsaFormat(format), c.SND_PCM_ACCESS_RW_INTERLEAVED, - @intCast(c_uint, device.channels.len), + @as(c_uint, @intCast(device.channels.len)), sample_rate, 1, main.default_latency, @@ -622,10 +622,10 @@ pub const Player = struct { if (lib.snd_mixer_selem_get_playback_volume_range(self.mixer_elm, &min_vol, &max_vol) < 0) return error.CannotSetVolume; - const dist = @floatFromInt(f32, max_vol - min_vol); + const dist = @as(f32, @floatFromInt(max_vol - min_vol)); if (lib.snd_mixer_selem_set_playback_volume_all( self.mixer_elm, - @intFromFloat(c_long, dist * vol) + min_vol, + @as(c_long, @intFromFloat(dist * vol)) + min_vol, ) < 0) return error.CannotSetVolume; } @@ -652,7 +652,7 @@ pub const Player = struct { if (lib.snd_mixer_selem_get_playback_volume_range(self.mixer_elm, &min_vol, &max_vol) < 0) return error.CannotGetVolume; - return @floatFromInt(f32, vol) / @floatFromInt(f32, max_vol - min_vol); + return @as(f32, @floatFromInt(vol)) / @as(f32, @floatFromInt(max_vol - min_vol)); } }; diff --git a/libs/sysaudio/src/coreaudio.zig b/libs/sysaudio/src/coreaudio.zig index 60ff8d49..96f98dca 100644 --- a/libs/sysaudio/src/coreaudio.zig +++ b/libs/sysaudio/src/coreaudio.zig @@ -72,7 +72,7 @@ pub const Context = struct { 0, null, &io_size, - @ptrCast(*anyopaque, devs), + @as(*anyopaque, @ptrCast(devs)), ) != c.noErr) { return error.OpeningDevice; } @@ -128,7 +128,7 @@ pub const Context = struct { 0, null, &io_size, - @ptrCast(*anyopaque, buf_list), + @as(*anyopaque, @ptrCast(buf_list)), ) != c.noErr) { return error.OpeningDevice; } @@ -210,8 +210,8 @@ pub const Context = struct { .channels = channels, .formats = &.{ .i16, .i32, .f32 }, .sample_rate = .{ - .min = @intFromFloat(u24, @floor(sample_rate)), - .max = @intFromFloat(u24, @floor(sample_rate)), + .min = @as(u24, @intFromFloat(@floor(sample_rate))), + .max = @as(u24, @intFromFloat(@floor(sample_rate))), }, }; @@ -334,10 +334,10 @@ pub const Player = struct { _ = bus_number; _ = frames_left; - const self = @ptrCast(*Player, @alignCast(@alignOf(*Player), self_opaque.?)); + const self = @as(*Player, @ptrCast(@alignCast(@alignOf(*Player), self_opaque.?))); for (self.channels, 0..) |*ch, i| { - ch.ptr = @ptrCast([*]u8, buf.*.mBuffers[0].mData.?) + self.format.frameSize(i); + ch.ptr = @as([*]u8, @ptrCast(buf.*.mBuffers[0].mData.?)) + self.format.frameSize(i); } const frames = buf.*.mBuffers[0].mDataByteSize / self.format.frameSize(self.channels.len); self.writeFn(self.user_data, frames); @@ -412,7 +412,7 @@ fn freeDevice(allocator: std.mem.Allocator, device: main.Device) void { fn createStreamDesc(format: main.Format, sample_rate: u24, ch_count: usize) !c.AudioStreamBasicDescription { var desc = c.AudioStreamBasicDescription{ - .mSampleRate = @floatFromInt(f64, sample_rate), + .mSampleRate = @as(f64, @floatFromInt(sample_rate)), .mFormatID = c.kAudioFormatLinearPCM, .mFormatFlags = switch (format) { .i16 => c.kAudioFormatFlagIsSignedInteger, @@ -425,7 +425,7 @@ fn createStreamDesc(format: main.Format, sample_rate: u24, ch_count: usize) !c.A .mBytesPerPacket = format.frameSize(ch_count), .mFramesPerPacket = 1, .mBytesPerFrame = format.frameSize(ch_count), - .mChannelsPerFrame = @intCast(c_uint, ch_count), + .mChannelsPerFrame = @as(c_uint, @intCast(ch_count)), .mBitsPerChannel = switch (format) { .i16 => 16, .i24 => 24, diff --git a/libs/sysaudio/src/jack.zig b/libs/sysaudio/src/jack.zig index 346979d5..d23911fc 100644 --- a/libs/sysaudio/src/jack.zig +++ b/libs/sysaudio/src/jack.zig @@ -74,8 +74,8 @@ pub const Context = struct { pub fn init(allocator: std.mem.Allocator, options: main.Context.Options) !backends.BackendContext { try lib.load(); - lib.jack_set_error_function(@ptrCast(?*const fn ([*c]const u8) callconv(.C) void, &util.doNothing)); - lib.jack_set_info_function(@ptrCast(?*const fn ([*c]const u8) callconv(.C) void, &util.doNothing)); + lib.jack_set_error_function(@as(?*const fn ([*c]const u8) callconv(.C) void, @ptrCast(&util.doNothing))); + lib.jack_set_info_function(@as(?*const fn ([*c]const u8) callconv(.C) void, @ptrCast(&util.doNothing))); var status: c.jack_status_t = 0; var self = try allocator.create(Context); @@ -120,16 +120,16 @@ pub const Context = struct { freeDevice(self.allocator, d); self.devices_info.clear(self.allocator); - const sample_rate = @intCast(u24, lib.jack_get_sample_rate(self.client)); + const sample_rate = @as(u24, @intCast(lib.jack_get_sample_rate(self.client))); const port_names = lib.jack_get_ports(self.client, null, null, 0) orelse return error.OutOfMemory; - defer lib.jack_free(@ptrCast(?*anyopaque, port_names)); + defer lib.jack_free(@as(?*anyopaque, @ptrCast(port_names))); var i: usize = 0; outer: while (port_names[i] != null) : (i += 1) { const port = lib.jack_port_by_name(self.client, port_names[i]) orelse break; - const port_type = lib.jack_port_type(port)[0..@intCast(usize, lib.jack_port_type_size())]; + const port_type = lib.jack_port_type(port)[0..@as(usize, @intCast(lib.jack_port_type_size()))]; if (!std.mem.startsWith(u8, port_type, c.JACK_DEFAULT_AUDIO_TYPE)) continue; @@ -142,7 +142,7 @@ pub const Context = struct { for (self.devices_info.list.items) |*dev| { if (std.mem.eql(u8, dev.id, id) and mode == dev.mode) { const new_ch = main.Channel{ - .id = @enumFromInt(main.Channel.Id, dev.channels.len), + .id = @as(main.Channel.Id, @enumFromInt(dev.channels.len)), }; dev.channels = try self.allocator.realloc(dev.channels, dev.channels.len + 1); dev.channels[dev.channels.len - 1] = new_ch; @@ -156,7 +156,7 @@ pub const Context = struct { .mode = mode, .channels = blk: { var channels = try self.allocator.alloc(main.Channel, 1); - channels[0] = .{ .id = @enumFromInt(main.Channel.Id, 0) }; + channels[0] = .{ .id = @as(main.Channel.Id, @enumFromInt(0)) }; break :blk channels; }, .formats = &.{.f32}, @@ -174,18 +174,18 @@ pub const Context = struct { } fn sampleRateCallback(_: c.jack_nframes_t, arg: ?*anyopaque) callconv(.C) c_int { - var self = @ptrCast(*Context, @alignCast(@alignOf(*Context), arg.?)); + var self = @as(*Context, @ptrCast(@alignCast(@alignOf(*Context), arg.?))); self.watcher.?.deviceChangeFn(self.watcher.?.user_data); return 0; } fn portRegistrationCallback(_: c.jack_port_id_t, _: c_int, arg: ?*anyopaque) callconv(.C) void { - var self = @ptrCast(*Context, @alignCast(@alignOf(*Context), arg.?)); + var self = @as(*Context, @ptrCast(@alignCast(@alignOf(*Context), arg.?))); self.watcher.?.deviceChangeFn(self.watcher.?.user_data); } fn portRenameCalllback(_: c.jack_port_id_t, _: [*c]const u8, _: [*c]const u8, arg: ?*anyopaque) callconv(.C) void { - var self = @ptrCast(*Context, @alignCast(@alignOf(*Context), arg.?)); + var self = @as(*Context, @ptrCast(@alignCast(@alignOf(*Context), arg.?))); self.watcher.?.deviceChangeFn(self.watcher.?.user_data); } @@ -266,10 +266,10 @@ pub const Player = struct { } fn processCallback(n_frames: c.jack_nframes_t, self_opaque: ?*anyopaque) callconv(.C) c_int { - const self = @ptrCast(*Player, @alignCast(@alignOf(*Player), self_opaque.?)); + const self = @as(*Player, @ptrCast(@alignCast(@alignOf(*Player), self_opaque.?))); for (self.channels, 0..) |*ch, i| { - ch.*.ptr = @ptrCast([*]u8, lib.jack_port_get_buffer(self.ports[i], n_frames)); + ch.*.ptr = @as([*]u8, @ptrCast(lib.jack_port_get_buffer(self.ports[i], n_frames))); } self.writeFn(self.user_data, n_frames); @@ -313,7 +313,7 @@ pub const Player = struct { } pub fn sampleRate(self: Player) u24 { - return @intCast(u24, lib.jack_get_sample_rate(self.client)); + return @as(u24, @intCast(lib.jack_get_sample_rate(self.client))); } }; diff --git a/libs/sysaudio/src/main.zig b/libs/sysaudio/src/main.zig index 83051dbf..edace7c6 100644 --- a/libs/sysaudio/src/main.zig +++ b/libs/sysaudio/src/main.zig @@ -37,7 +37,7 @@ pub const Context = struct { } else { inline for (std.meta.fields(Backend), 0..) |b, i| { if (@typeInfo( - std.meta.fieldInfo(backends.BackendContext, @enumFromInt(Backend, b.value)).type, + std.meta.fieldInfo(backends.BackendContext, @as(Backend, @enumFromInt(b.value))).type, ).Pointer.child.init(allocator, options)) |d| { break :blk d; } else |err| { @@ -275,37 +275,37 @@ pub const Player = struct { fn unsignedToSigned(comptime T: type, sample: anytype) T { const half = 1 << (@bitSizeOf(@TypeOf(sample)) - 1); const trunc = @bitSizeOf(T) - @bitSizeOf(@TypeOf(sample)); - return @intCast(T, sample -% half) << trunc; + return @as(T, @intCast(sample -% half)) << trunc; } fn unsignedToFloat(comptime T: type, sample: anytype) T { const max_int = std.math.maxInt(@TypeOf(sample)) + 1.0; - return (@floatFromInt(T, sample) - max_int) * 1.0 / max_int; + return (@as(T, @floatFromInt(sample)) - max_int) * 1.0 / max_int; } fn signedToSigned(comptime T: type, sample: anytype) T { const trunc = @bitSizeOf(@TypeOf(sample)) - @bitSizeOf(T); - return @intCast(T, sample >> trunc); + return @as(T, @intCast(sample >> trunc)); } fn signedToUnsigned(comptime T: type, sample: anytype) T { const half = 1 << (@bitSizeOf(T) - 1); const trunc = @bitSizeOf(@TypeOf(sample)) - @bitSizeOf(T); - return @intCast(T, (sample >> trunc) + half); + return @as(T, @intCast((sample >> trunc) + half)); } fn signedToFloat(comptime T: type, sample: anytype) T { const max_int = std.math.maxInt(@TypeOf(sample)) + 1.0; - return @floatFromInt(T, sample) * 1.0 / max_int; + return @as(T, @floatFromInt(sample)) * 1.0 / max_int; } fn floatToSigned(comptime T: type, sample: f64) T { - return @intFromFloat(T, sample * std.math.maxInt(T)); + return @as(T, @intFromFloat(sample * std.math.maxInt(T))); } fn floatToUnsigned(comptime T: type, sample: f64) T { const half = 1 << @bitSizeOf(T) - 1; - return @intFromFloat(T, sample * (half - 1) + half); + return @as(T, @intFromFloat(sample * (half - 1) + half)); } pub const Device = struct { @@ -404,7 +404,7 @@ pub const Format = enum { } pub fn frameSize(self: Format, ch_count: usize) u8 { - return self.size() * @intCast(u5, ch_count); + return self.size() * @as(u5, @intCast(ch_count)); } }; diff --git a/libs/sysaudio/src/pipewire.zig b/libs/sysaudio/src/pipewire.zig index 75935e21..0c841cb0 100644 --- a/libs/sysaudio/src/pipewire.zig +++ b/libs/sysaudio/src/pipewire.zig @@ -208,7 +208,7 @@ pub const Context = struct { c.PW_KEY_AUDIO_RATE, audio_rate.ptr, - @ptrFromInt(*allowzero u0, 0), + @as(*allowzero u0, @ptrFromInt(0)), ); var player = try self.allocator.create(Player); @@ -236,7 +236,7 @@ pub const Context = struct { }; var info = c.spa_audio_info_raw{ .format = c.SPA_AUDIO_FORMAT_F32, - .channels = @intCast(u32, device.channels.len), + .channels = @as(u32, @intCast(device.channels.len)), .rate = options.sample_rate, .flags = 0, .position = undefined, @@ -289,7 +289,7 @@ pub const Player = struct { _ = old_state; _ = err; - var self = @ptrCast(*Player, @alignCast(@alignOf(*Player), self_opaque.?)); + var self = @as(*Player, @ptrCast(@alignCast(@alignOf(*Player), self_opaque.?))); if (state == c.PW_STREAM_STATE_STREAMING or state == c.PW_STREAM_STATE_ERROR) { lib.pw_thread_loop_signal(self.thread, false); @@ -297,7 +297,7 @@ pub const Player = struct { } pub fn processCb(self_opaque: ?*anyopaque) callconv(.C) void { - var self = @ptrCast(*Player, @alignCast(@alignOf(*Player), self_opaque.?)); + var self = @as(*Player, @ptrCast(@alignCast(@alignOf(*Player), self_opaque.?))); const buf = lib.pw_stream_dequeue_buffer(self.stream) orelse unreachable; if (buf.*.buffer.*.datas[0].data == null) return; @@ -313,10 +313,10 @@ pub const Player = struct { const stride = self.format.frameSize(self.channels.len); const n_frames = @min(buf.*.requested, buf.*.buffer.*.datas[0].maxsize / stride); buf.*.buffer.*.datas[0].chunk.*.stride = stride; - buf.*.buffer.*.datas[0].chunk.*.size = @intCast(u32, n_frames * stride); + buf.*.buffer.*.datas[0].chunk.*.size = @as(u32, @intCast(n_frames * stride)); for (self.channels, 0..) |*ch, i| { - ch.ptr = @ptrCast([*]u8, buf.*.buffer.*.datas[0].data.?) + self.format.frameSize(i); + ch.ptr = @as([*]u8, @ptrCast(buf.*.buffer.*.datas[0].data.?)) + self.format.frameSize(i); } self.writeFn(self.user_data, n_frames); } diff --git a/libs/sysaudio/src/pulseaudio.zig b/libs/sysaudio/src/pulseaudio.zig index ea133f01..8aee2e14 100644 --- a/libs/sysaudio/src/pulseaudio.zig +++ b/libs/sysaudio/src/pulseaudio.zig @@ -192,12 +192,12 @@ pub const Context = struct { } fn subscribeOp(_: ?*c.pa_context, _: c.pa_subscription_event_type_t, _: u32, user_data: ?*anyopaque) callconv(.C) void { - var self = @ptrCast(*Context, @alignCast(@alignOf(*Context), user_data.?)); + var self = @as(*Context, @ptrCast(@alignCast(@alignOf(*Context), user_data.?))); self.watcher.?.deviceChangeFn(self.watcher.?.user_data); } fn contextStateOp(ctx: ?*c.pa_context, user_data: ?*anyopaque) callconv(.C) void { - var self = @ptrCast(*Context, @alignCast(@alignOf(*Context), user_data.?)); + var self = @as(*Context, @ptrCast(@alignCast(@alignOf(*Context), user_data.?))); self.ctx_state = lib.pa_context_get_state(ctx); lib.pa_threaded_mainloop_signal(self.main_loop, 0); @@ -255,7 +255,7 @@ pub const Context = struct { } fn serverInfoOp(_: ?*c.pa_context, info: [*c]const c.pa_server_info, user_data: ?*anyopaque) callconv(.C) void { - var self = @ptrCast(*Context, @alignCast(@alignOf(*Context), user_data.?)); + var self = @as(*Context, @ptrCast(@alignCast(@alignOf(*Context), user_data.?))); defer lib.pa_threaded_mainloop_signal(self.main_loop, 0); self.default_sink = self.allocator.dupeZ(u8, std.mem.span(info.*.default_sink_name)) catch return; @@ -266,7 +266,7 @@ pub const Context = struct { } fn sinkInfoOp(_: ?*c.pa_context, info: [*c]const c.pa_sink_info, eol: c_int, user_data: ?*anyopaque) callconv(.C) void { - var self = @ptrCast(*Context, @alignCast(@alignOf(*Context), user_data.?)); + var self = @as(*Context, @ptrCast(@alignCast(@alignOf(*Context), user_data.?))); if (eol != 0) { lib.pa_threaded_mainloop_signal(self.main_loop, 0); return; @@ -276,7 +276,7 @@ pub const Context = struct { } fn sourceInfoOp(_: ?*c.pa_context, info: [*c]const c.pa_source_info, eol: c_int, user_data: ?*anyopaque) callconv(.C) void { - var self = @ptrCast(*Context, @alignCast(@alignOf(*Context), user_data.?)); + var self = @as(*Context, @ptrCast(@alignCast(@alignOf(*Context), user_data.?))); if (eol != 0) { lib.pa_threaded_mainloop_signal(self.main_loop, 0); return; @@ -301,8 +301,8 @@ pub const Context = struct { }, .formats = available_formats, .sample_rate = .{ - .min = @intCast(u24, info.*.sample_spec.rate), - .max = @intCast(u24, info.*.sample_spec.rate), + .min = @as(u24, @intCast(info.*.sample_spec.rate)), + .max = @as(u24, @intCast(info.*.sample_spec.rate)), }, .id = id, .name = name, @@ -329,7 +329,7 @@ pub const Context = struct { const sample_spec = c.pa_sample_spec{ .format = toPAFormat(format), .rate = sample_rate, - .channels = @intCast(u5, device.channels.len), + .channels = @as(u5, @intCast(device.channels.len)), }; const channel_map = try toPAChannelMap(device.channels); @@ -397,7 +397,7 @@ pub const Context = struct { }; fn streamStateOp(stream: ?*c.pa_stream, user_data: ?*anyopaque) callconv(.C) void { - var self = @ptrCast(*StreamStatus, @alignCast(@alignOf(*StreamStatus), user_data.?)); + var self = @as(*StreamStatus, @ptrCast(@alignCast(@alignOf(*StreamStatus), user_data.?))); switch (lib.pa_stream_get_state(stream)) { c.PA_STREAM_UNCONNECTED, @@ -456,14 +456,14 @@ pub const Player = struct { } fn playbackStreamWriteOp(_: ?*c.pa_stream, nbytes: usize, user_data: ?*anyopaque) callconv(.C) void { - var self = @ptrCast(*Player, @alignCast(@alignOf(*Player), user_data.?)); + var self = @as(*Player, @ptrCast(@alignCast(@alignOf(*Player), user_data.?))); var frames_left = nbytes; if (lib.pa_stream_begin_write( self.stream, - @ptrCast( + @as( [*c]?*anyopaque, - @alignCast(@alignOf([*c]?*anyopaque), &self.write_ptr), + @ptrCast(@alignCast(@alignOf([*c]?*anyopaque), &self.write_ptr)), ), &frames_left, ) != 0) { @@ -519,7 +519,7 @@ pub const Player = struct { var cvolume: c.pa_cvolume = undefined; _ = lib.pa_cvolume_init(&cvolume); - _ = lib.pa_cvolume_set(&cvolume, @intCast(c_uint, self.channels.len), lib.pa_sw_volume_from_linear(vol)); + _ = lib.pa_cvolume_set(&cvolume, @as(c_uint, @intCast(self.channels.len)), lib.pa_sw_volume_from_linear(vol)); performOperation( self.main_loop, @@ -534,7 +534,7 @@ pub const Player = struct { } fn successOp(_: ?*c.pa_context, success: c_int, user_data: ?*anyopaque) callconv(.C) void { - var self = @ptrCast(*Player, @alignCast(@alignOf(*Player), user_data.?)); + var self = @as(*Player, @ptrCast(@alignCast(@alignOf(*Player), user_data.?))); if (success == 1) lib.pa_threaded_mainloop_signal(self.main_loop, 0); } @@ -557,14 +557,14 @@ pub const Player = struct { } fn sinkInputInfoOp(_: ?*c.pa_context, info: [*c]const c.pa_sink_input_info, eol: c_int, user_data: ?*anyopaque) callconv(.C) void { - var self = @ptrCast(*Player, @alignCast(@alignOf(*Player), user_data.?)); + var self = @as(*Player, @ptrCast(@alignCast(@alignOf(*Player), user_data.?))); if (eol != 0) { lib.pa_threaded_mainloop_signal(self.main_loop, 0); return; } - self.vol = @floatFromInt(f32, info.*.volume.values[0]) / @floatFromInt(f32, c.PA_VOLUME_NORM); + self.vol = @as(f32, @floatFromInt(info.*.volume.values[0])) / @as(f32, @floatFromInt(c.PA_VOLUME_NORM)); } }; @@ -638,7 +638,7 @@ pub fn toPAFormat(format: main.Format) c.pa_sample_format_t { pub fn toPAChannelMap(channels: []const main.Channel) !c.pa_channel_map { var channel_map: c.pa_channel_map = undefined; - channel_map.channels = @intCast(u5, channels.len); + channel_map.channels = @as(u5, @intCast(channels.len)); for (channels, 0..) |ch, i| channel_map.map[i] = try toPAChannelPos(ch.id); return channel_map; diff --git a/libs/sysaudio/src/wasapi.zig b/libs/sysaudio/src/wasapi.zig index 02da0d13..590acd7f 100644 --- a/libs/sysaudio/src/wasapi.zig +++ b/libs/sysaudio/src/wasapi.zig @@ -43,7 +43,7 @@ pub const Context = struct { null, win32.CLSCTX_ALL, win32.IID_IMMDeviceEnumerator, - @ptrCast(*?*anyopaque, &enumerator), + @as(*?*anyopaque, @ptrCast(&enumerator)), ); switch (hr) { win32.S_OK => {}, @@ -99,7 +99,7 @@ pub const Context = struct { fn queryInterfaceCB(self: *const win32.IUnknown, riid: ?*const win32.Guid, ppv: ?*?*anyopaque) callconv(std.os.windows.WINAPI) win32.HRESULT { if (riid.?.eql(win32.IID_IUnknown.*) or riid.?.eql(win32.IID_IMMNotificationClient.*)) { - ppv.?.* = @ptrFromInt(?*anyopaque, @intFromPtr(self)); + ppv.?.* = @as(?*anyopaque, @ptrFromInt(@intFromPtr(self))); _ = self.AddRef(); return win32.S_OK; } else { @@ -266,16 +266,16 @@ pub const Context = struct { win32.S_OK, win32.INPLACE_S_TRUNCATED => {}, else => return error.OpeningDevice, } - var wf = @ptrCast( + var wf = @as( *win32.WAVEFORMATEXTENSIBLE, - variant.anon.anon.anon.blob.pBlobData, + @ptrCast(variant.anon.anon.anon.blob.pBlobData), ); defer win32.CoTaskMemFree(variant.anon.anon.anon.blob.pBlobData); var device = main.Device{ .mode = blk: { var endpoint: ?*win32.IMMEndpoint = null; - hr = imm_device.?.QueryInterface(win32.IID_IMMEndpoint, @ptrCast(?*?*anyopaque, &endpoint)); + hr = imm_device.?.QueryInterface(win32.IID_IMMEndpoint, @as(?*?*anyopaque, @ptrCast(&endpoint))); switch (hr) { win32.S_OK => {}, win32.E_POINTER => unreachable, @@ -308,12 +308,12 @@ pub const Context = struct { break :blk try chn_arr.toOwnedSlice(); }, .sample_rate = .{ - .min = @intCast(u24, wf.Format.nSamplesPerSec), - .max = @intCast(u24, wf.Format.nSamplesPerSec), + .min = @as(u24, @intCast(wf.Format.nSamplesPerSec)), + .max = @as(u24, @intCast(wf.Format.nSamplesPerSec)), }, .formats = blk: { var audio_client: ?*win32.IAudioClient = null; - hr = imm_device.?.Activate(win32.IID_IAudioClient, win32.CLSCTX_ALL, null, @ptrCast(?*?*anyopaque, &audio_client)); + hr = imm_device.?.Activate(win32.IID_IAudioClient, win32.CLSCTX_ALL, null, @as(?*?*anyopaque, @ptrCast(&audio_client))); switch (hr) { win32.S_OK => {}, win32.E_POINTER => unreachable, @@ -330,7 +330,7 @@ pub const Context = struct { setWaveFormatFormat(wf, format); if (audio_client.?.IsFormatSupported( .SHARED, - @ptrCast(?*const win32.WAVEFORMATEX, @alignCast(@alignOf(*win32.WAVEFORMATEX), wf)), + @as(?*const win32.WAVEFORMATEX, @ptrCast(@alignCast(@alignOf(*win32.WAVEFORMATEX), wf))), &closest_match, ) == win32.S_OK) { try fmt_arr.append(format); @@ -448,9 +448,9 @@ pub const Context = struct { var audio_client: ?*win32.IAudioClient = null; var audio_client3: ?*win32.IAudioClient3 = null; - hr = imm_device.?.Activate(win32.IID_IAudioClient3, win32.CLSCTX_ALL, null, @ptrCast(?*?*anyopaque, &audio_client3)); + hr = imm_device.?.Activate(win32.IID_IAudioClient3, win32.CLSCTX_ALL, null, @as(?*?*anyopaque, @ptrCast(&audio_client3))); if (hr == win32.S_OK) { - hr = audio_client3.?.QueryInterface(win32.IID_IAudioClient, @ptrCast(?*?*anyopaque, &audio_client)); + hr = audio_client3.?.QueryInterface(win32.IID_IAudioClient, @as(?*?*anyopaque, @ptrCast(&audio_client))); switch (hr) { win32.S_OK => {}, win32.E_NOINTERFACE => unreachable, @@ -458,7 +458,7 @@ pub const Context = struct { else => return error.OpeningDevice, } } else { - hr = imm_device.?.Activate(win32.IID_IAudioClient, win32.CLSCTX_ALL, null, @ptrCast(?*?*anyopaque, &audio_client)); + hr = imm_device.?.Activate(win32.IID_IAudioClient, win32.CLSCTX_ALL, null, @as(?*?*anyopaque, @ptrCast(&audio_client))); switch (hr) { win32.S_OK => {}, win32.E_POINTER => unreachable, @@ -476,7 +476,7 @@ pub const Context = struct { const wave_format = win32.WAVEFORMATEXTENSIBLE{ .Format = .{ .wFormatTag = win32.WAVE_FORMAT_EXTENSIBLE, - .nChannels = @intCast(u16, device.channels.len), + .nChannels = @as(u16, @intCast(device.channels.len)), .nSamplesPerSec = sample_rate, .nAvgBytesPerSec = sample_rate * format.frameSize(device.channels.len), .nBlockAlign = format.frameSize(device.channels.len), @@ -494,7 +494,7 @@ pub const Context = struct { hr = audio_client3.?.InitializeSharedAudioStream( win32.AUDCLNT_STREAMFLAGS_EVENTCALLBACK, 0, // TODO: use the advantage of AudioClient3 - @ptrCast(?*const win32.WAVEFORMATEX, @alignCast(@alignOf(*win32.WAVEFORMATEX), &wave_format)), + @as(?*const win32.WAVEFORMATEX, @ptrCast(@alignCast(@alignOf(*win32.WAVEFORMATEX), &wave_format))), null, ); switch (hr) { @@ -521,7 +521,7 @@ pub const Context = struct { win32.AUDCLNT_STREAMFLAGS_EVENTCALLBACK, 0, 0, - @ptrCast(?*const win32.WAVEFORMATEX, @alignCast(@alignOf(*win32.WAVEFORMATEX), &wave_format)), + @as(?*const win32.WAVEFORMATEX, @ptrCast(@alignCast(@alignOf(*win32.WAVEFORMATEX), &wave_format))), null, ); switch (hr) { @@ -547,7 +547,7 @@ pub const Context = struct { } var render_client: ?*win32.IAudioRenderClient = null; - hr = audio_client.?.GetService(win32.IID_IAudioRenderClient, @ptrCast(?*?*anyopaque, &render_client)); + hr = audio_client.?.GetService(win32.IID_IAudioRenderClient, @as(?*?*anyopaque, @ptrCast(&render_client))); switch (hr) { win32.S_OK => {}, win32.E_POINTER => unreachable, @@ -560,7 +560,7 @@ pub const Context = struct { } var simple_volume: ?*win32.ISimpleAudioVolume = null; - hr = audio_client.?.GetService(win32.IID_ISimpleAudioVolume, @ptrCast(?*?*anyopaque, &simple_volume)); + hr = audio_client.?.GetService(win32.IID_ISimpleAudioVolume, @as(?*?*anyopaque, @ptrCast(&simple_volume))); switch (hr) { win32.S_OK => {}, win32.E_POINTER => unreachable, @@ -728,7 +728,7 @@ pub const Player = struct { const frames = buf_frames - padding_frames; if (frames > 0) { var data: [*]u8 = undefined; - hr = self.render_client.?.GetBuffer(frames, @ptrCast(?*?*u8, &data)); + hr = self.render_client.?.GetBuffer(frames, @as(?*?*u8, @ptrCast(&data))); switch (hr) { win32.S_OK => {}, win32.E_POINTER => unreachable, diff --git a/libs/sysaudio/src/wasapi/win32.zig b/libs/sysaudio/src/wasapi/win32.zig index 6116dcb8..3a1f576b 100644 --- a/libs/sysaudio/src/wasapi/win32.zig +++ b/libs/sysaudio/src/wasapi/win32.zig @@ -19,12 +19,12 @@ pub const Guid = extern union { return guid; } fn hexVal(c: u8) u4 { - if (c <= '9') return @intCast(u4, c - '0'); - if (c >= 'a') return @intCast(u4, c + 10 - 'a'); - return @intCast(u4, c + 10 - 'A'); + if (c <= '9') return @as(u4, @intCast(c - '0')); + if (c >= 'a') return @as(u4, @intCast(c + 10 - 'a')); + return @as(u4, @intCast(c + 10 - 'A')); } fn decodeHexByte(hex: [2]u8) u8 { - return @intCast(u8, hexVal(hex[0])) << 4 | hexVal(hex[1]); + return @as(u8, @intCast(hexVal(hex[0]))) << 4 | hexVal(hex[1]); } pub fn eql(riid1: Guid, riid2: Guid) bool { return riid1.Ints.a == riid2.Ints.a and @@ -259,13 +259,13 @@ pub const IUnknown = extern struct { pub fn MethodMixin(comptime T: type) type { return struct { pub inline fn QueryInterface(self: *const T, riid: ?*const Guid, ppvObject: ?*?*anyopaque) HRESULT { - return @ptrCast(*const IUnknown.VTable, self.vtable).QueryInterface(@ptrCast(*const IUnknown, self), riid, ppvObject); + return @as(*const IUnknown.VTable, @ptrCast(self.vtable)).QueryInterface(@as(*const IUnknown, @ptrCast(self)), riid, ppvObject); } pub inline fn AddRef(self: *const T) u32 { - return @ptrCast(*const IUnknown.VTable, self.vtable).AddRef(@ptrCast(*const IUnknown, self)); + return @as(*const IUnknown.VTable, @ptrCast(self.vtable)).AddRef(@as(*const IUnknown, @ptrCast(self))); } pub inline fn Release(self: *const T) u32 { - return @ptrCast(*const IUnknown.VTable, self.vtable).Release(@ptrCast(*const IUnknown, self)); + return @as(*const IUnknown.VTable, @ptrCast(self.vtable)).Release(@as(*const IUnknown, @ptrCast(self))); } }; } @@ -1239,40 +1239,40 @@ pub const IAudioClient = extern struct { return struct { pub usingnamespace IUnknown.MethodMixin(T); pub inline fn Initialize(self: *const T, ShareMode: AUDCLNT_SHAREMODE, StreamFlags: u32, hnsBufferDuration: i64, hnsPeriodicity: i64, pFormat: ?*const WAVEFORMATEX, AudioSessionGuid: ?*const Guid) HRESULT { - return @ptrCast(*const IAudioClient.VTable, self.vtable).Initialize(@ptrCast(*const IAudioClient, self), ShareMode, StreamFlags, hnsBufferDuration, hnsPeriodicity, pFormat, AudioSessionGuid); + return @as(*const IAudioClient.VTable, @ptrCast(self.vtable)).Initialize(@as(*const IAudioClient, @ptrCast(self)), ShareMode, StreamFlags, hnsBufferDuration, hnsPeriodicity, pFormat, AudioSessionGuid); } pub inline fn GetBufferSize(self: *const T, pNumBufferFrames: ?*u32) HRESULT { - return @ptrCast(*const IAudioClient.VTable, self.vtable).GetBufferSize(@ptrCast(*const IAudioClient, self), pNumBufferFrames); + return @as(*const IAudioClient.VTable, @ptrCast(self.vtable)).GetBufferSize(@as(*const IAudioClient, @ptrCast(self)), pNumBufferFrames); } pub inline fn GetStreamLatency(self: *const T, phnsLatency: ?*i64) HRESULT { - return @ptrCast(*const IAudioClient.VTable, self.vtable).GetStreamLatency(@ptrCast(*const IAudioClient, self), phnsLatency); + return @as(*const IAudioClient.VTable, @ptrCast(self.vtable)).GetStreamLatency(@as(*const IAudioClient, @ptrCast(self)), phnsLatency); } pub inline fn GetCurrentPadding(self: *const T, pNumPaddingFrames: ?*u32) HRESULT { - return @ptrCast(*const IAudioClient.VTable, self.vtable).GetCurrentPadding(@ptrCast(*const IAudioClient, self), pNumPaddingFrames); + return @as(*const IAudioClient.VTable, @ptrCast(self.vtable)).GetCurrentPadding(@as(*const IAudioClient, @ptrCast(self)), pNumPaddingFrames); } pub inline fn IsFormatSupported(self: *const T, ShareMode: AUDCLNT_SHAREMODE, pFormat: ?*const WAVEFORMATEX, ppClosestMatch: ?*?*WAVEFORMATEX) HRESULT { - return @ptrCast(*const IAudioClient.VTable, self.vtable).IsFormatSupported(@ptrCast(*const IAudioClient, self), ShareMode, pFormat, ppClosestMatch); + return @as(*const IAudioClient.VTable, @ptrCast(self.vtable)).IsFormatSupported(@as(*const IAudioClient, @ptrCast(self)), ShareMode, pFormat, ppClosestMatch); } pub inline fn GetMixFormat(self: *const T, ppDeviceFormat: ?*?*WAVEFORMATEX) HRESULT { - return @ptrCast(*const IAudioClient.VTable, self.vtable).GetMixFormat(@ptrCast(*const IAudioClient, self), ppDeviceFormat); + return @as(*const IAudioClient.VTable, @ptrCast(self.vtable)).GetMixFormat(@as(*const IAudioClient, @ptrCast(self)), ppDeviceFormat); } pub inline fn GetDevicePeriod(self: *const T, phnsDefaultDevicePeriod: ?*i64, phnsMinimumDevicePeriod: ?*i64) HRESULT { - return @ptrCast(*const IAudioClient.VTable, self.vtable).GetDevicePeriod(@ptrCast(*const IAudioClient, self), phnsDefaultDevicePeriod, phnsMinimumDevicePeriod); + return @as(*const IAudioClient.VTable, @ptrCast(self.vtable)).GetDevicePeriod(@as(*const IAudioClient, @ptrCast(self)), phnsDefaultDevicePeriod, phnsMinimumDevicePeriod); } pub inline fn Start(self: *const T) HRESULT { - return @ptrCast(*const IAudioClient.VTable, self.vtable).Start(@ptrCast(*const IAudioClient, self)); + return @as(*const IAudioClient.VTable, @ptrCast(self.vtable)).Start(@as(*const IAudioClient, @ptrCast(self))); } pub inline fn Stop(self: *const T) HRESULT { - return @ptrCast(*const IAudioClient.VTable, self.vtable).Stop(@ptrCast(*const IAudioClient, self)); + return @as(*const IAudioClient.VTable, @ptrCast(self.vtable)).Stop(@as(*const IAudioClient, @ptrCast(self))); } pub inline fn Reset(self: *const T) HRESULT { - return @ptrCast(*const IAudioClient.VTable, self.vtable).Reset(@ptrCast(*const IAudioClient, self)); + return @as(*const IAudioClient.VTable, @ptrCast(self.vtable)).Reset(@as(*const IAudioClient, @ptrCast(self))); } pub inline fn SetEventHandle(self: *const T, eventHandle: ?*anyopaque) HRESULT { - return @ptrCast(*const IAudioClient.VTable, self.vtable).SetEventHandle(@ptrCast(*const IAudioClient, self), eventHandle); + return @as(*const IAudioClient.VTable, @ptrCast(self.vtable)).SetEventHandle(@as(*const IAudioClient, @ptrCast(self)), eventHandle); } pub inline fn GetService(self: *const T, riid: ?*const Guid, ppv: ?*?*anyopaque) HRESULT { - return @ptrCast(*const IAudioClient.VTable, self.vtable).GetService(@ptrCast(*const IAudioClient, self), riid, ppv); + return @as(*const IAudioClient.VTable, @ptrCast(self.vtable)).GetService(@as(*const IAudioClient, @ptrCast(self)), riid, ppv); } }; } @@ -1354,13 +1354,13 @@ pub const IAudioClient2 = extern struct { return struct { pub usingnamespace IAudioClient.MethodMixin(T); pub inline fn IsOffloadCapable(self: *const T, Category: AUDIO_STREAM_CATEGORY, pbOffloadCapable: ?*BOOL) HRESULT { - return @ptrCast(*const IAudioClient2.VTable, self.vtable).IsOffloadCapable(@ptrCast(*const IAudioClient2, self), Category, pbOffloadCapable); + return @as(*const IAudioClient2.VTable, @ptrCast(self.vtable)).IsOffloadCapable(@as(*const IAudioClient2, @ptrCast(self)), Category, pbOffloadCapable); } pub inline fn SetClientProperties(self: *const T, pProperties: ?*const AudioClientProperties) HRESULT { - return @ptrCast(*const IAudioClient2.VTable, self.vtable).SetClientProperties(@ptrCast(*const IAudioClient2, self), pProperties); + return @as(*const IAudioClient2.VTable, @ptrCast(self.vtable)).SetClientProperties(@as(*const IAudioClient2, @ptrCast(self)), pProperties); } pub inline fn GetBufferSizeLimits(self: *const T, pFormat: ?*const WAVEFORMATEX, bEventDriven: BOOL, phnsMinBufferDuration: ?*i64, phnsMaxBufferDuration: ?*i64) HRESULT { - return @ptrCast(*const IAudioClient2.VTable, self.vtable).GetBufferSizeLimits(@ptrCast(*const IAudioClient2, self), pFormat, bEventDriven, phnsMinBufferDuration, phnsMaxBufferDuration); + return @as(*const IAudioClient2.VTable, @ptrCast(self.vtable)).GetBufferSizeLimits(@as(*const IAudioClient2, @ptrCast(self)), pFormat, bEventDriven, phnsMinBufferDuration, phnsMaxBufferDuration); } }; } @@ -1422,13 +1422,13 @@ pub const IAudioClient3 = extern struct { return struct { pub usingnamespace IAudioClient2.MethodMixin(T); pub inline fn GetSharedModeEnginePeriod(self: *const T, pFormat: ?*const WAVEFORMATEX, pDefaultPeriodInFrames: ?*u32, pFundamentalPeriodInFrames: ?*u32, pMinPeriodInFrames: ?*u32, pMaxPeriodInFrames: ?*u32) HRESULT { - return @ptrCast(*const IAudioClient3.VTable, self.vtable).GetSharedModeEnginePeriod(@ptrCast(*const IAudioClient3, self), pFormat, pDefaultPeriodInFrames, pFundamentalPeriodInFrames, pMinPeriodInFrames, pMaxPeriodInFrames); + return @as(*const IAudioClient3.VTable, @ptrCast(self.vtable)).GetSharedModeEnginePeriod(@as(*const IAudioClient3, @ptrCast(self)), pFormat, pDefaultPeriodInFrames, pFundamentalPeriodInFrames, pMinPeriodInFrames, pMaxPeriodInFrames); } pub inline fn GetCurrentSharedModeEnginePeriod(self: *const T, ppFormat: ?*?*WAVEFORMATEX, pCurrentPeriodInFrames: ?*u32) HRESULT { - return @ptrCast(*const IAudioClient3.VTable, self.vtable).GetCurrentSharedModeEnginePeriod(@ptrCast(*const IAudioClient3, self), ppFormat, pCurrentPeriodInFrames); + return @as(*const IAudioClient3.VTable, @ptrCast(self.vtable)).GetCurrentSharedModeEnginePeriod(@as(*const IAudioClient3, @ptrCast(self)), ppFormat, pCurrentPeriodInFrames); } pub inline fn InitializeSharedAudioStream(self: *const T, StreamFlags: u32, PeriodInFrames: u32, pFormat: ?*const WAVEFORMATEX, AudioSessionGuid: ?*const Guid) HRESULT { - return @ptrCast(*const IAudioClient3.VTable, self.vtable).InitializeSharedAudioStream(@ptrCast(*const IAudioClient3, self), StreamFlags, PeriodInFrames, pFormat, AudioSessionGuid); + return @as(*const IAudioClient3.VTable, @ptrCast(self.vtable)).InitializeSharedAudioStream(@as(*const IAudioClient3, @ptrCast(self)), StreamFlags, PeriodInFrames, pFormat, AudioSessionGuid); } }; } @@ -1455,10 +1455,10 @@ pub const IAudioRenderClient = extern struct { return struct { pub usingnamespace IUnknown.MethodMixin(T); pub inline fn GetBuffer(self: *const T, NumFramesRequested: u32, ppData: ?*?*u8) HRESULT { - return @ptrCast(*const IAudioRenderClient.VTable, self.vtable).GetBuffer(@ptrCast(*const IAudioRenderClient, self), NumFramesRequested, ppData); + return @as(*const IAudioRenderClient.VTable, @ptrCast(self.vtable)).GetBuffer(@as(*const IAudioRenderClient, @ptrCast(self)), NumFramesRequested, ppData); } pub inline fn ReleaseBuffer(self: *const T, NumFramesWritten: u32, dwFlags: u32) HRESULT { - return @ptrCast(*const IAudioRenderClient.VTable, self.vtable).ReleaseBuffer(@ptrCast(*const IAudioRenderClient, self), NumFramesWritten, dwFlags); + return @as(*const IAudioRenderClient.VTable, @ptrCast(self.vtable)).ReleaseBuffer(@as(*const IAudioRenderClient, @ptrCast(self)), NumFramesWritten, dwFlags); } }; } @@ -1492,16 +1492,16 @@ pub const ISimpleAudioVolume = extern struct { return struct { pub usingnamespace IUnknown.MethodMixin(T); pub inline fn SetMasterVolume(self: *const T, fLevel: f32, EventContext: ?*const Guid) HRESULT { - return @ptrCast(*const ISimpleAudioVolume.VTable, self.vtable).SetMasterVolume(@ptrCast(*const ISimpleAudioVolume, self), fLevel, EventContext); + return @as(*const ISimpleAudioVolume.VTable, @ptrCast(self.vtable)).SetMasterVolume(@as(*const ISimpleAudioVolume, @ptrCast(self)), fLevel, EventContext); } pub inline fn GetMasterVolume(self: *const T, pfLevel: ?*f32) HRESULT { - return @ptrCast(*const ISimpleAudioVolume.VTable, self.vtable).GetMasterVolume(@ptrCast(*const ISimpleAudioVolume, self), pfLevel); + return @as(*const ISimpleAudioVolume.VTable, @ptrCast(self.vtable)).GetMasterVolume(@as(*const ISimpleAudioVolume, @ptrCast(self)), pfLevel); } pub inline fn SetMute(self: *const T, bMute: BOOL, EventContext: ?*const Guid) HRESULT { - return @ptrCast(*const ISimpleAudioVolume.VTable, self.vtable).SetMute(@ptrCast(*const ISimpleAudioVolume, self), bMute, EventContext); + return @as(*const ISimpleAudioVolume.VTable, @ptrCast(self.vtable)).SetMute(@as(*const ISimpleAudioVolume, @ptrCast(self)), bMute, EventContext); } pub inline fn GetMute(self: *const T, pbMute: ?*BOOL) HRESULT { - return @ptrCast(*const ISimpleAudioVolume.VTable, self.vtable).GetMute(@ptrCast(*const ISimpleAudioVolume, self), pbMute); + return @as(*const ISimpleAudioVolume.VTable, @ptrCast(self.vtable)).GetMute(@as(*const ISimpleAudioVolume, @ptrCast(self)), pbMute); } }; } @@ -1538,19 +1538,19 @@ pub const IPropertyStore = extern struct { return struct { pub usingnamespace IUnknown.MethodMixin(T); pub inline fn GetCount(self: *const T, cProps: ?*u32) HRESULT { - return @ptrCast(*const IPropertyStore.VTable, self.vtable).GetCount(@ptrCast(*const IPropertyStore, self), cProps); + return @as(*const IPropertyStore.VTable, @ptrCast(self.vtable)).GetCount(@as(*const IPropertyStore, @ptrCast(self)), cProps); } pub inline fn GetAt(self: *const T, iProp: u32, pkey: ?*PROPERTYKEY) HRESULT { - return @ptrCast(*const IPropertyStore.VTable, self.vtable).GetAt(@ptrCast(*const IPropertyStore, self), iProp, pkey); + return @as(*const IPropertyStore.VTable, @ptrCast(self.vtable)).GetAt(@as(*const IPropertyStore, @ptrCast(self)), iProp, pkey); } pub inline fn GetValue(self: *const T, key: ?*const PROPERTYKEY, pv: ?*PROPVARIANT) HRESULT { - return @ptrCast(*const IPropertyStore.VTable, self.vtable).GetValue(@ptrCast(*const IPropertyStore, self), key, pv); + return @as(*const IPropertyStore.VTable, @ptrCast(self.vtable)).GetValue(@as(*const IPropertyStore, @ptrCast(self)), key, pv); } pub inline fn SetValue(self: *const T, key: ?*const PROPERTYKEY, propvar: ?*const PROPVARIANT) HRESULT { - return @ptrCast(*const IPropertyStore.VTable, self.vtable).SetValue(@ptrCast(*const IPropertyStore, self), key, propvar); + return @as(*const IPropertyStore.VTable, @ptrCast(self.vtable)).SetValue(@as(*const IPropertyStore, @ptrCast(self)), key, propvar); } pub inline fn Commit(self: *const T) HRESULT { - return @ptrCast(*const IPropertyStore.VTable, self.vtable).Commit(@ptrCast(*const IPropertyStore, self)); + return @as(*const IPropertyStore.VTable, @ptrCast(self.vtable)).Commit(@as(*const IPropertyStore, @ptrCast(self))); } }; } @@ -1586,16 +1586,16 @@ pub const IMMDevice = extern struct { return struct { pub usingnamespace IUnknown.MethodMixin(T); pub inline fn Activate(self: *const T, iid: ?*const Guid, dwClsCtx: u32, pActivationParams: ?*PROPVARIANT, ppInterface: ?*?*anyopaque) HRESULT { - return @ptrCast(*const IMMDevice.VTable, self.vtable).Activate(@ptrCast(*const IMMDevice, self), iid, dwClsCtx, pActivationParams, ppInterface); + return @as(*const IMMDevice.VTable, @ptrCast(self.vtable)).Activate(@as(*const IMMDevice, @ptrCast(self)), iid, dwClsCtx, pActivationParams, ppInterface); } pub inline fn OpenPropertyStore(self: *const T, stgmAccess: u32, ppProperties: ?*?*IPropertyStore) HRESULT { - return @ptrCast(*const IMMDevice.VTable, self.vtable).OpenPropertyStore(@ptrCast(*const IMMDevice, self), stgmAccess, ppProperties); + return @as(*const IMMDevice.VTable, @ptrCast(self.vtable)).OpenPropertyStore(@as(*const IMMDevice, @ptrCast(self)), stgmAccess, ppProperties); } pub inline fn GetId(self: *const T, ppstrId: ?*?PWSTR) HRESULT { - return @ptrCast(*const IMMDevice.VTable, self.vtable).GetId(@ptrCast(*const IMMDevice, self), ppstrId); + return @as(*const IMMDevice.VTable, @ptrCast(self.vtable)).GetId(@as(*const IMMDevice, @ptrCast(self)), ppstrId); } pub inline fn GetState(self: *const T, pdwState: ?*u32) HRESULT { - return @ptrCast(*const IMMDevice.VTable, self.vtable).GetState(@ptrCast(*const IMMDevice, self), pdwState); + return @as(*const IMMDevice.VTable, @ptrCast(self.vtable)).GetState(@as(*const IMMDevice, @ptrCast(self)), pdwState); } }; } @@ -1635,19 +1635,19 @@ pub const IMMNotificationClient = extern struct { return struct { pub usingnamespace IUnknown.MethodMixin(T); pub inline fn OnDeviceStateChanged(self: *const T, pwstrDeviceId: ?[*:0]const u16, dwNewState: u32) HRESULT { - return @ptrCast(*const IMMNotificationClient.VTable, self.vtable).OnDeviceStateChanged(@ptrCast(*const IMMNotificationClient, self), pwstrDeviceId, dwNewState); + return @as(*const IMMNotificationClient.VTable, @ptrCast(self.vtable)).OnDeviceStateChanged(@as(*const IMMNotificationClient, @ptrCast(self)), pwstrDeviceId, dwNewState); } pub inline fn OnDeviceAdded(self: *const T, pwstrDeviceId: ?[*:0]const u16) HRESULT { - return @ptrCast(*const IMMNotificationClient.VTable, self.vtable).OnDeviceAdded(@ptrCast(*const IMMNotificationClient, self), pwstrDeviceId); + return @as(*const IMMNotificationClient.VTable, @ptrCast(self.vtable)).OnDeviceAdded(@as(*const IMMNotificationClient, @ptrCast(self)), pwstrDeviceId); } pub inline fn OnDeviceRemoved(self: *const T, pwstrDeviceId: ?[*:0]const u16) HRESULT { - return @ptrCast(*const IMMNotificationClient.VTable, self.vtable).OnDeviceRemoved(@ptrCast(*const IMMNotificationClient, self), pwstrDeviceId); + return @as(*const IMMNotificationClient.VTable, @ptrCast(self.vtable)).OnDeviceRemoved(@as(*const IMMNotificationClient, @ptrCast(self)), pwstrDeviceId); } pub inline fn OnDefaultDeviceChanged(self: *const T, flow: DataFlow, role: Role, pwstrDefaultDeviceId: ?[*:0]const u16) HRESULT { - return @ptrCast(*const IMMNotificationClient.VTable, self.vtable).OnDefaultDeviceChanged(@ptrCast(*const IMMNotificationClient, self), flow, role, pwstrDefaultDeviceId); + return @as(*const IMMNotificationClient.VTable, @ptrCast(self.vtable)).OnDefaultDeviceChanged(@as(*const IMMNotificationClient, @ptrCast(self)), flow, role, pwstrDefaultDeviceId); } pub inline fn OnPropertyValueChanged(self: *const T, pwstrDeviceId: ?[*:0]const u16, key: PROPERTYKEY) HRESULT { - return @ptrCast(*const IMMNotificationClient.VTable, self.vtable).OnPropertyValueChanged(@ptrCast(*const IMMNotificationClient, self), pwstrDeviceId, key); + return @as(*const IMMNotificationClient.VTable, @ptrCast(self.vtable)).OnPropertyValueChanged(@as(*const IMMNotificationClient, @ptrCast(self)), pwstrDeviceId, key); } }; } @@ -1672,10 +1672,10 @@ pub const IMMDeviceCollection = extern struct { return struct { pub usingnamespace IUnknown.MethodMixin(T); pub inline fn GetCount(self: *const T, pcDevices: ?*u32) HRESULT { - return @ptrCast(*const IMMDeviceCollection.VTable, self.vtable).GetCount(@ptrCast(*const IMMDeviceCollection, self), pcDevices); + return @as(*const IMMDeviceCollection.VTable, @ptrCast(self.vtable)).GetCount(@as(*const IMMDeviceCollection, @ptrCast(self)), pcDevices); } pub inline fn Item(self: *const T, nDevice: u32, ppDevice: ?*?*IMMDevice) HRESULT { - return @ptrCast(*const IMMDeviceCollection.VTable, self.vtable).Item(@ptrCast(*const IMMDeviceCollection, self), nDevice, ppDevice); + return @as(*const IMMDeviceCollection.VTable, @ptrCast(self.vtable)).Item(@as(*const IMMDeviceCollection, @ptrCast(self)), nDevice, ppDevice); } }; } @@ -1716,19 +1716,19 @@ pub const IMMDeviceEnumerator = extern struct { return struct { pub usingnamespace IUnknown.MethodMixin(T); pub inline fn EnumAudioEndpoints(self: *const T, dataFlow: DataFlow, dwStateMask: u32, ppDevices: ?*?*IMMDeviceCollection) HRESULT { - return @ptrCast(*const IMMDeviceEnumerator.VTable, self.vtable).EnumAudioEndpoints(@ptrCast(*const IMMDeviceEnumerator, self), dataFlow, dwStateMask, ppDevices); + return @as(*const IMMDeviceEnumerator.VTable, @ptrCast(self.vtable)).EnumAudioEndpoints(@as(*const IMMDeviceEnumerator, @ptrCast(self)), dataFlow, dwStateMask, ppDevices); } pub inline fn GetDefaultAudioEndpoint(self: *const T, dataFlow: DataFlow, role: Role, ppEndpoint: ?*?*IMMDevice) HRESULT { - return @ptrCast(*const IMMDeviceEnumerator.VTable, self.vtable).GetDefaultAudioEndpoint(@ptrCast(*const IMMDeviceEnumerator, self), dataFlow, role, ppEndpoint); + return @as(*const IMMDeviceEnumerator.VTable, @ptrCast(self.vtable)).GetDefaultAudioEndpoint(@as(*const IMMDeviceEnumerator, @ptrCast(self)), dataFlow, role, ppEndpoint); } pub inline fn GetDevice(self: *const T, pwstrId: ?[*:0]const u16, ppDevice: ?*?*IMMDevice) HRESULT { - return @ptrCast(*const IMMDeviceEnumerator.VTable, self.vtable).GetDevice(@ptrCast(*const IMMDeviceEnumerator, self), pwstrId, ppDevice); + return @as(*const IMMDeviceEnumerator.VTable, @ptrCast(self.vtable)).GetDevice(@as(*const IMMDeviceEnumerator, @ptrCast(self)), pwstrId, ppDevice); } pub inline fn RegisterEndpointNotificationCallback(self: *const T, pClient: ?*IMMNotificationClient) HRESULT { - return @ptrCast(*const IMMDeviceEnumerator.VTable, self.vtable).RegisterEndpointNotificationCallback(@ptrCast(*const IMMDeviceEnumerator, self), pClient); + return @as(*const IMMDeviceEnumerator.VTable, @ptrCast(self.vtable)).RegisterEndpointNotificationCallback(@as(*const IMMDeviceEnumerator, @ptrCast(self)), pClient); } pub inline fn UnregisterEndpointNotificationCallback(self: *const T, pClient: ?*IMMNotificationClient) HRESULT { - return @ptrCast(*const IMMDeviceEnumerator.VTable, self.vtable).UnregisterEndpointNotificationCallback(@ptrCast(*const IMMDeviceEnumerator, self), pClient); + return @as(*const IMMDeviceEnumerator.VTable, @ptrCast(self.vtable)).UnregisterEndpointNotificationCallback(@as(*const IMMDeviceEnumerator, @ptrCast(self)), pClient); } }; } @@ -1748,7 +1748,7 @@ pub const IMMEndpoint = extern struct { return struct { pub usingnamespace IUnknown.MethodMixin(T); pub inline fn GetDataFlow(self: *const T, pDataFlow: ?*DataFlow) HRESULT { - return @ptrCast(*const IMMEndpoint.VTable, self.vtable).GetDataFlow(@ptrCast(*const IMMEndpoint, self), pDataFlow); + return @as(*const IMMEndpoint.VTable, @ptrCast(self.vtable)).GetDataFlow(@as(*const IMMEndpoint, @ptrCast(self)), pDataFlow); } }; } diff --git a/libs/sysaudio/src/webaudio.zig b/libs/sysaudio/src/webaudio.zig index 4269b90c..dc408eed 100644 --- a/libs/sysaudio/src/webaudio.zig +++ b/libs/sysaudio/src/webaudio.zig @@ -163,7 +163,7 @@ pub const Player = struct { } fn resumeOnClick(args: js.Object, _: usize, captures: []js.Value) js.Value { - const self = @ptrFromInt(*Player, @intFromFloat(usize, captures[0].view(.num))); + const self = @as(*Player, @ptrFromInt(@as(usize, @intFromFloat(captures[0].view(.num))))); self.play() catch {}; const document = js.global().get("document").view(.object); @@ -177,7 +177,7 @@ pub const Player = struct { } fn audioProcessEvent(args: js.Object, _: usize, captures: []js.Value) js.Value { - const self = @ptrFromInt(*Player, @intFromFloat(usize, captures[0].view(.num))); + const self = @as(*Player, @ptrFromInt(@as(usize, @intFromFloat(captures[0].view(.num))))); const event = args.getIndex(0).view(.object); defer event.deinit(); @@ -219,7 +219,7 @@ pub const Player = struct { pub fn volume(self: Player) !f32 { const gain = self.gain_node.get("gain").view(.object); defer gain.deinit(); - return @floatCast(f32, gain.get("value").view(.num)); + return @as(f32, @floatCast(gain.get("value").view(.num))); } }; diff --git a/shaderexp/main.zig b/shaderexp/main.zig index 80991e27..b0229085 100755 --- a/shaderexp/main.zig +++ b/shaderexp/main.zig @@ -132,7 +132,7 @@ pub fn update(app: *App) !bool { const time = app.timer.read() / @as(f32, std.time.ns_per_s); const ubo = UniformBufferObject{ - .resolution = .{ @floatFromInt(f32, app.core.descriptor().width), @floatFromInt(f32, app.core.descriptor().height) }, + .resolution = .{ @as(f32, @floatFromInt(app.core.descriptor().width)), @as(f32, @floatFromInt(app.core.descriptor().height)) }, .time = time, }; encoder.writeBuffer(app.uniform_buffer, 0, &[_]UniformBufferObject{ubo}); diff --git a/src/gfx2d/Sprite2D.zig b/src/gfx2d/Sprite2D.zig index cb533c28..278233e0 100644 --- a/src/gfx2d/Sprite2D.zig +++ b/src/gfx2d/Sprite2D.zig @@ -152,8 +152,8 @@ pub fn machSprite2DInit(adapter: anytype) !void { .sprite_uv_transforms = sprite_uv_transforms, .sprite_sizes = sprite_sizes, .texture_size = Vec2{ - @floatFromInt(f32, sprite2d.state().texture.getWidth()), - @floatFromInt(f32, sprite2d.state().texture.getHeight()), + @as(f32, @floatFromInt(sprite2d.state().texture.getWidth())), + @as(f32, @floatFromInt(sprite2d.state().texture.getHeight())), }, .texture = sprite2d.state().texture, }); @@ -195,10 +195,10 @@ pub fn tick(adapter: anytype) !void { // Update uniform buffer const ortho = mat.ortho( - -@floatFromInt(f32, core.size().width) / 2, - @floatFromInt(f32, core.size().width) / 2, - -@floatFromInt(f32, core.size().height) / 2, - @floatFromInt(f32, core.size().height) / 2, + -@as(f32, @floatFromInt(core.size().width)) / 2, + @as(f32, @floatFromInt(core.size().width)) / 2, + -@as(f32, @floatFromInt(core.size().height)) / 2, + @as(f32, @floatFromInt(core.size().height)) / 2, -0.1, 100000, ); @@ -234,7 +234,7 @@ pub fn tick(adapter: anytype) !void { try sprite_sizes.append(adapter.allocator, size); } } - const total_vertices = @intCast(u32, sprite_sizes.items.len * 6); + const total_vertices = @as(u32, @intCast(sprite_sizes.items.len * 6)); if (sprite_transforms.items.len > 0) { encoder.writeBuffer(sprite2d.state().sprite_transforms, 0, sprite_transforms.items); encoder.writeBuffer(sprite2d.state().sprite_uv_transforms, 0, sprite_uv_transforms.items); diff --git a/src/resource/ResourceManager.zig b/src/resource/ResourceManager.zig index 94e8d738..7dcd484b 100644 --- a/src/resource/ResourceManager.zig +++ b/src/resource/ResourceManager.zig @@ -97,6 +97,6 @@ pub const Resource = struct { // Returns the raw data, which you can use in any ways. Internally it is stored // as an *anyopaque pub fn getData(res: *const Resource, comptime T: type) *T { - return @ptrCast(*T, @alignCast(std.meta.alignment(*T), res.resource)); + return @as(*T, @ptrCast(@alignCast(std.meta.alignment(*T), res.resource))); } };