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

all: update to latest Zig APIs (zig fmt)

Browse source 
Signed-off-by: Stephen Gutekanst <stephen@hexops.com>
This commit is contained in:
Stephen Gutekanst 2023-06-29 09:54:32 -07:00
parent d95a453e78
commit 4bc32adeb8
61 changed files with 806 additions and 806 deletions
Download patch file Download diff file Expand all files Collapse all files

4
libs/basisu/src/encoder.zig
View file

@ -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 {

6
libs/basisu/src/transcoder.zig
View file

@ -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;

4
libs/core/src/Timer.zig
View file

@ -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));
}

8
libs/core/src/platform/libmachcore.zig
View file

@ -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;

10
libs/core/src/platform/native/Core.zig
View file

@ -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,

4
libs/core/src/platform/native/util.zig
View file

@ -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);
}

34
libs/core/src/platform/wasm/Core.zig
View file

@ -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 {

2
libs/core/src/platform/wasm/Timer.zig
View file

@ -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;
}

50
libs/freetype/src/Face.zig
View file

@ -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 {

10
libs/freetype/src/GlyphSlot.zig
View file

@ -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 {

2
libs/freetype/src/color.zig
View file

@ -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 {

16
libs/freetype/src/computations.zig
View file

@ -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 {

10
libs/freetype/src/freetype.zig
View file

@ -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));
}

18
libs/freetype/src/glyph.zig
View file

@ -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 {

4
libs/freetype/src/harfbuzz/blob.zig
View file

@ -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).?,
};
}

32
libs/freetype/src/harfbuzz/buffer.zig
View file

@ -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)));
}
};

24
libs/freetype/src/harfbuzz/common.zig
View file

@ -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 {

10
libs/freetype/src/harfbuzz/font.zig
View file

@ -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;
}

16
libs/freetype/src/harfbuzz/shape_plan.zig
View file

@ -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))));
}
};

18
libs/freetype/src/image.zig
View file

@ -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 {

4
libs/glfw/src/Cursor.zig
View file

@ -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;
}

2
libs/glfw/src/GammaRamp.zig
View file

@ -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)),
};
}

8
libs/glfw/src/Image.zig
View file

@ -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],
};
}

30
libs/glfw/src/Joystick.zig
View file

@ -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;
}

22
libs/glfw/src/Monitor.zig
View file

@ -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)),
});
}
};

12
libs/glfw/src/VideoMode.zig
View file

@ -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" {

90
libs/glfw/src/Window.zig
View file

@ -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) {

2
libs/glfw/src/clipboard.zig
View file

@ -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;
}

4
libs/glfw/src/hat.zig
View file

@ -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))));
}
};

6
libs/glfw/src/key.zig
View file

@ -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;
}

8
libs/glfw/src/main.zig
View file

@ -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.

4
libs/glfw/src/mod.zig
View file

@ -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))));
}
};

54
libs/glfw/src/native.zig
View file

@ -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;
}
};

2
libs/glfw/src/opengl.zig
View file

@ -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.

16
libs/glfw/src/vulkan.zig
View file

@ -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))),
);
}

4
libs/gpu/examples/sample_utils.zig
View file

@ -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);
}

2
libs/gpu/src/adapter.zig
View file

@ -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,

8
libs/gpu/src/buffer.zig
View file

@ -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);

4
libs/gpu/src/command_encoder.zig
View file

@ -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))),
);
}

712
libs/gpu/src/dawn_impl.zig
View file

File diff suppressed because it is too large Load diff

12
libs/gpu/src/device.zig
View file

@ -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);

2
libs/gpu/src/instance.zig
View file

@ -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,

2
libs/gpu/src/interface.zig
View file

@ -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);

6
libs/gpu/src/main.zig
View file

@ -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))));
}
};

8
libs/gpu/src/queue.zig
View file

@ -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,
);

2
libs/gpu/src/shader_module.zig
View file

@ -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,
);

2
libs/gpu/src/texture.zig
View file

@ -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))));
}
};

2
libs/model3d/src/main.zig
View file

@ -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]

6
libs/sysaudio/examples/sine-wave.zig
View file

@ -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 {

22
libs/sysaudio/src/alsa.zig
View file

@ -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));
}
};

16
libs/sysaudio/src/coreaudio.zig
View file

@ -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,

26
libs/sysaudio/src/jack.zig
View file

@ -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)));
}
};

18
libs/sysaudio/src/main.zig
View file

@ -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));
}
};

12
libs/sysaudio/src/pipewire.zig
View file

@ -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);
}

34
libs/sysaudio/src/pulseaudio.zig
View file

@ -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;

36
libs/sysaudio/src/wasapi.zig
View file

@ -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,

106
libs/sysaudio/src/wasapi/win32.zig
View file

@ -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);
}
};
}

6
libs/sysaudio/src/webaudio.zig
View file

@ -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)));
}
};

2
shaderexp/main.zig
View file

@ -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});

14
src/gfx2d/Sprite2D.zig
View file

@ -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);

2
src/resource/ResourceManager.zig
View file

@ -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)));
}
};