all: update to latest Zig APIs (zig fmt)
Signed-off-by: Stephen Gutekanst <stephen@hexops.com>
This commit is contained in:
Stephen Gutekanst
parent
d95a453e78
commit
4bc32adeb8
61 changed files with 806 additions and 806 deletions
|
|
@ -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 {
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
|
|
|
|||
|
|
@ -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));
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
|
|
|
|||
|
|
@ -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,
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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 {
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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 {
|
||||
|
|
|
|||
|
|
@ -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 {
|
||||
|
|
|
|||
|
|
@ -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 {
|
||||
|
|
|
|||
|
|
@ -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 {
|
||||
|
|
|
|||
|
|
@ -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));
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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 {
|
||||
|
|
|
|||
|
|
@ -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).?,
|
||||
};
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -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)));
|
||||
}
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -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 {
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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))));
|
||||
}
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -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 {
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -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)),
|
||||
};
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -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],
|
||||
};
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -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)),
|
||||
});
|
||||
}
|
||||
};
|
||||
|
|
|
|||
|
|
@ -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" {
|
||||
|
|
|
|||
|
|
@ -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) {
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -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))));
|
||||
}
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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.
|
||||
|
|
|
|||
|
|
@ -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))));
|
||||
}
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
}
|
||||
};
|
||||
|
|
|
|||
|
|
@ -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.
|
||||
|
|
|
|||
|
|
@ -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))),
|
||||
);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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,
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
|
|
|
|||
|
|
@ -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))),
|
||||
);
|
||||
}
|
||||
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load diff
|
|
@ -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);
|
||||
|
|
|
|||
|
|
@ -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,
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
|
|
|
|||
|
|
@ -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))));
|
||||
}
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -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,
|
||||
);
|
||||
|
|
|
|||
|
|
@ -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,
|
||||
);
|
||||
|
|
|
|||
|
|
@ -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))));
|
||||
}
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -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]
|
||||
|
|
|
|||
|
|
@ -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 {
|
||||
|
|
|
|||
|
|
@ -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));
|
||||
}
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -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,
|
||||
|
|
|
|||
|
|
@ -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)));
|
||||
}
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -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));
|
||||
}
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
|
|
|
|||
|
|
@ -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,
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
}
|
||||
};
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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)));
|
||||
}
|
||||
};
|
||||
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue