paoda
/
zba
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

chore: update to latest builtin syntax

This commit is contained in:
Rekai Nyangadzayi Musuka 2023-07-10 21:20:07 -05:00
parent 954fb279ad
commit d96c9c01ff
25 changed files with 679 additions and 684 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
lib/bitfield.zig
View File

@ -26,13 +26,13 @@ fn BitType(comptime FieldType: type, comptime ValueType: type, comptime shamt: u
}
pub fn read(self: anytype) ValueType {
return @bitCast(ValueType, @truncate(u1, self.bits.field().* >> shamt));
return @as(ValueType, @bitCast(@as(u1, @truncate(self.bits.field().* >> shamt))));
}
// Since these are mostly used with MMIO, I want to avoid
// reading the memory just to write it again, also races
pub fn write(self: anytype, val: ValueType) void {
if (@bitCast(bool, val)) {
if (@as(bool, @bitCast(val))) {
self.set();
} else {
self.unset();
@ -67,17 +67,17 @@ pub fn Bitfield(comptime FieldType: type, comptime shamt: usize, comptime num_bi
dummy: FieldType,
fn field(self: anytype) PtrCastPreserveCV(@This(), @TypeOf(self), FieldType) {
return @ptrCast(PtrCastPreserveCV(@This(), @TypeOf(self), FieldType), self);
return @as(PtrCastPreserveCV(@This(), @TypeOf(self), FieldType), @ptrCast(self));
}
pub fn write(self: anytype, val: ValueType) void {
self.field().* &= ~self_mask;
self.field().* |= @intCast(FieldType, val) << shamt;
self.field().* |= @as(FieldType, @intCast(val)) << shamt;
}
pub fn read(self: anytype) ValueType {
const val: FieldType = self.field().*;
return @intCast(ValueType, (val & self_mask) >> shamt);
return @as(ValueType, @intCast((val & self_mask) >> shamt));
}
};
}

688
lib/gl.zig
View File

File diff suppressed because it is too large Load Diff

56
src/core/Bus.zig
View File

@ -98,7 +98,7 @@ pub fn deinit(self: *Self) void {
// This is so I can deallocate the original `allocator.alloc`. I have to re-make the type
// since I'm not keeping it around, This is very jank and bad though
// FIXME: please figure out another way
self.allocator.free(@ptrCast([*]const ?*anyopaque, self.read_table[0..])[0 .. 3 * table_len]);
self.allocator.free(@as([*]const ?*anyopaque, @ptrCast(self.read_table[0..]))[0 .. 3 * table_len]);
self.* = undefined;
}
@ -147,7 +147,7 @@ fn fillReadTable(self: *Self, table: *[table_len]?*const anyopaque) void {
const vramMirror = @import("ppu/Vram.zig").mirror;
for (table, 0..) |*ptr, i| {
const addr = @intCast(u32, page_size * i);
const addr = @as(u32, @intCast(page_size * i));
ptr.* = switch (addr) {
// General Internal Memory
@ -174,7 +174,7 @@ fn fillWriteTable(self: *Self, comptime T: type, table: *[table_len]?*const anyo
const vramMirror = @import("ppu/Vram.zig").mirror;
for (table, 0..) |*ptr, i| {
const addr = @intCast(u32, page_size * i);
const addr = @as(u32, @intCast(page_size * i));
ptr.* = switch (addr) {
// General Internal Memory
@ -227,7 +227,7 @@ fn fillReadTableExternal(self: *Self, addr: u32) ?*anyopaque {
// We are using a "small" EEPROM which means that if the below check is true
// (that is, we're in the 0xD address page) then we must handle at least one
// address in this page in slowmem
if (@truncate(u4, addr >> 24) == 0xD) return null;
if (@as(u4, @truncate(addr >> 24)) == 0xD) return null;
}
}
@ -257,7 +257,7 @@ fn openBus(self: *const Self, comptime T: type, address: u32) T {
// the most recently fetched instruction by the pipeline
if (!self.cpu.cpsr.t.read()) break :blk self.cpu.pipe.stage[1].?;
const page = @truncate(u8, r15 >> 24);
const page = @as(u8, @truncate(r15 >> 24));
// PC + 2 = stage[0]
// PC + 4 = stage[1]
@ -266,7 +266,7 @@ fn openBus(self: *const Self, comptime T: type, address: u32) T {
switch (page) {
// EWRAM, PALRAM, VRAM, and Game ROM (16-bit)
0x02, 0x05, 0x06, 0x08...0x0D => {
const halfword: u32 = @truncate(u16, self.cpu.pipe.stage[1].?);
const halfword: u32 = @as(u16, @truncate(self.cpu.pipe.stage[1].?));
break :blk halfword << 16 | halfword;
},
@ -277,8 +277,8 @@ fn openBus(self: *const Self, comptime T: type, address: u32) T {
const aligned = address & 3 == 0b00;
// TODO: What to do on PC + 6?
const high: u32 = if (aligned) self.dbgRead(u16, r15 + 4) else @truncate(u16, self.cpu.pipe.stage[1].?);
const low: u32 = @truncate(u16, self.cpu.pipe.stage[@boolToInt(aligned)].?);
const high: u32 = if (aligned) self.dbgRead(u16, r15 + 4) else @as(u16, @truncate(self.cpu.pipe.stage[1].?));
const low: u32 = @as(u16, @truncate(self.cpu.pipe.stage[@intFromBool(aligned)].?));
break :blk high << 16 | low;
},
@ -289,8 +289,8 @@ fn openBus(self: *const Self, comptime T: type, address: u32) T {
// Unaligned: (PC + 4) | (PC + 2)
const aligned = address & 3 == 0b00;
const high: u32 = @truncate(u16, self.cpu.pipe.stage[1 - @boolToInt(aligned)].?);
const low: u32 = @truncate(u16, self.cpu.pipe.stage[@boolToInt(aligned)].?);
const high: u32 = @as(u16, @truncate(self.cpu.pipe.stage[1 - @intFromBool(aligned)].?));
const low: u32 = @as(u16, @truncate(self.cpu.pipe.stage[@intFromBool(aligned)].?));
break :blk high << 16 | low;
},
@ -301,7 +301,7 @@ fn openBus(self: *const Self, comptime T: type, address: u32) T {
}
};
return @truncate(T, word);
return @as(T, @truncate(word));
}
pub fn read(self: *Self, comptime T: type, unaligned_address: u32) T {
@ -310,15 +310,14 @@ pub fn read(self: *Self, comptime T: type, unaligned_address: u32) T {
const offset = unaligned_address & (page_size - 1);
// whether or not we do this in slowmem or fastmem, we should advance the scheduler
self.sched.tick += timings[@boolToInt(T == u32)][@truncate(u4, unaligned_address >> 24)];
self.sched.tick += timings[@intFromBool(T == u32)][@as(u4, @truncate(unaligned_address >> 24))];
// We're doing some serious out-of-bounds open-bus reads
if (page >= table_len) return self.openBus(T, unaligned_address);
if (self.read_table[page]) |some_ptr| {
// We have a pointer to a page, cast the pointer to it's underlying type
const Ptr = [*]const T;
const ptr = @ptrCast(Ptr, @alignCast(@alignOf(std.meta.Child(Ptr)), some_ptr));
const ptr: [*]const T = @ptrCast(@alignCast(some_ptr));
// Note: We don't check array length, since we force align the
// lower bits of the address as the GBA would
@ -338,8 +337,7 @@ pub fn dbgRead(self: *const Self, comptime T: type, unaligned_address: u32) T {
if (self.read_table[page]) |some_ptr| {
// We have a pointer to a page, cast the pointer to it's underlying type
const Ptr = [*]const T;
const ptr = @ptrCast(Ptr, @alignCast(@alignOf(std.meta.Child(Ptr)), some_ptr));
const ptr: [*]const T = @ptrCast(@alignCast(some_ptr));
// Note: We don't check array length, since we force align the
// lower bits of the address as the GBA would
@ -352,7 +350,7 @@ pub fn dbgRead(self: *const Self, comptime T: type, unaligned_address: u32) T {
fn slowRead(self: *Self, comptime T: type, unaligned_address: u32) T {
@setCold(true);
const page = @truncate(u8, unaligned_address >> 24);
const page = @as(u8, @truncate(unaligned_address >> 24));
const address = forceAlign(T, unaligned_address);
return switch (page) {
@ -380,7 +378,7 @@ fn slowRead(self: *Self, comptime T: type, unaligned_address: u32) T {
}
fn dbgSlowRead(self: *const Self, comptime T: type, unaligned_address: u32) T {
const page = @truncate(u8, unaligned_address >> 24);
const page = @as(u8, @truncate(unaligned_address >> 24));
const address = forceAlign(T, unaligned_address);
return switch (page) {
@ -426,22 +424,21 @@ pub fn write(self: *Self, comptime T: type, unaligned_address: u32, value: T) vo
const offset = unaligned_address & (page_size - 1);
// whether or not we do this in slowmem or fastmem, we should advance the scheduler
self.sched.tick += timings[@boolToInt(T == u32)][@truncate(u4, unaligned_address >> 24)];
self.sched.tick += timings[@intFromBool(T == u32)][@as(u4, @truncate(unaligned_address >> 24))];
// We're doing some serious out-of-bounds open-bus writes, they do nothing though
if (page >= table_len) return;
if (self.write_tables[@boolToInt(T == u8)][page]) |some_ptr| {
if (self.write_tables[@intFromBool(T == u8)][page]) |some_ptr| {
// We have a pointer to a page, cast the pointer to it's underlying type
const Ptr = [*]T;
const ptr = @ptrCast(Ptr, @alignCast(@alignOf(std.meta.Child(Ptr)), some_ptr));
const ptr: [*]T = @ptrCast(@alignCast(some_ptr));
// Note: We don't check array length, since we force align the
// lower bits of the address as the GBA would
ptr[forceAlign(T, offset) / @sizeOf(T)] = value;
} else {
// we can return early if this is an 8-bit OAM write
if (T == u8 and @truncate(u8, unaligned_address >> 24) == 0x07) return;
if (T == u8 and @as(u8, @truncate(unaligned_address >> 24)) == 0x07) return;
self.slowWrite(T, unaligned_address, value);
}
@ -456,17 +453,16 @@ pub fn dbgWrite(self: *Self, comptime T: type, unaligned_address: u32, value: T)
// We're doing some serious out-of-bounds open-bus writes, they do nothing though
if (page >= table_len) return;
if (self.write_tables[@boolToInt(T == u8)][page]) |some_ptr| {
if (self.write_tables[@intFromBool(T == u8)][page]) |some_ptr| {
// We have a pointer to a page, cast the pointer to it's underlying type
const Ptr = [*]T;
const ptr = @ptrCast(Ptr, @alignCast(@alignOf(std.meta.Child(Ptr)), some_ptr));
const ptr: [*]T = @ptrCast(@alignCast(some_ptr));
// Note: We don't check array length, since we force align the
// lower bits of the address as the GBA would
ptr[forceAlign(T, offset) / @sizeOf(T)] = value;
} else {
// we can return early if this is an 8-bit OAM write
if (T == u8 and @truncate(u8, unaligned_address >> 24) == 0x07) return;
if (T == u8 and @as(u8, @truncate(unaligned_address >> 24)) == 0x07) return;
self.dbgSlowWrite(T, unaligned_address, value);
}
@ -475,7 +471,7 @@ pub fn dbgWrite(self: *Self, comptime T: type, unaligned_address: u32, value: T)
fn slowWrite(self: *Self, comptime T: type, unaligned_address: u32, value: T) void {
@setCold(true);
const page = @truncate(u8, unaligned_address >> 24);
const page = @as(u8, @truncate(unaligned_address >> 24));
const address = forceAlign(T, unaligned_address);
switch (page) {
@ -492,7 +488,7 @@ fn slowWrite(self: *Self, comptime T: type, unaligned_address: u32, value: T) vo
// External Memory (Game Pak)
0x08...0x0D => self.pak.write(T, self.dma[3].word_count, address, value),
0x0E...0x0F => self.pak.backup.write(unaligned_address, @truncate(u8, rotr(T, value, 8 * rotateBy(T, unaligned_address)))),
0x0E...0x0F => self.pak.backup.write(unaligned_address, @as(u8, @truncate(rotr(T, value, 8 * rotateBy(T, unaligned_address))))),
else => {},
}
}
@ -500,7 +496,7 @@ fn slowWrite(self: *Self, comptime T: type, unaligned_address: u32, value: T) vo
fn dbgSlowWrite(self: *Self, comptime T: type, unaligned_address: u32, value: T) void {
@setCold(true);
const page = @truncate(u8, unaligned_address >> 24);
const page = @as(u8, @truncate(unaligned_address >> 24));
const address = forceAlign(T, unaligned_address);
switch (page) {

78
src/core/apu.zig
View File

@ -22,7 +22,7 @@ pub const host_rate = @import("../platform.zig").sample_rate;
pub const host_format = @import("../platform.zig").sample_format;
pub fn read(comptime T: type, apu: *const Apu, addr: u32) ?T {
const byte_addr = @truncate(u8, addr);
const byte_addr = @as(u8, @truncate(addr));
return switch (T) {
u32 => switch (byte_addr) {
@ -73,27 +73,27 @@ pub fn read(comptime T: type, apu: *const Apu, addr: u32) ?T {
else => util.io.read.err(T, log, "unaligned {} read from 0x{X:0>8}", .{ T, addr }),
},
u8 => switch (byte_addr) {
0x60, 0x61 => @truncate(T, @as(u16, apu.ch1.sound1CntL()) >> getHalf(byte_addr)),
0x62, 0x63 => @truncate(T, apu.ch1.sound1CntH() >> getHalf(byte_addr)),
0x64, 0x65 => @truncate(T, apu.ch1.sound1CntX() >> getHalf(byte_addr)),
0x60, 0x61 => @as(T, @truncate(@as(u16, apu.ch1.sound1CntL()) >> getHalf(byte_addr))),
0x62, 0x63 => @as(T, @truncate(apu.ch1.sound1CntH() >> getHalf(byte_addr))),
0x64, 0x65 => @as(T, @truncate(apu.ch1.sound1CntX() >> getHalf(byte_addr))),
0x66, 0x67 => 0x00, // assuming behaviour is identical to that of 16-bit reads
0x68, 0x69 => @truncate(T, apu.ch2.sound2CntL() >> getHalf(byte_addr)),
0x68, 0x69 => @as(T, @truncate(apu.ch2.sound2CntL() >> getHalf(byte_addr))),
0x6A, 0x6B => 0x00,
0x6C, 0x6D => @truncate(T, apu.ch2.sound2CntH() >> getHalf(byte_addr)),
0x6C, 0x6D => @as(T, @truncate(apu.ch2.sound2CntH() >> getHalf(byte_addr))),
0x6E, 0x6F => 0x00,
0x70, 0x71 => @truncate(T, @as(u16, apu.ch3.sound3CntL()) >> getHalf(byte_addr)), // SOUND3CNT_L
0x72, 0x73 => @truncate(T, apu.ch3.sound3CntH() >> getHalf(byte_addr)),
0x74, 0x75 => @truncate(T, apu.ch3.sound3CntX() >> getHalf(byte_addr)), // SOUND3CNT_L
0x70, 0x71 => @as(T, @truncate(@as(u16, apu.ch3.sound3CntL()) >> getHalf(byte_addr))), // SOUND3CNT_L
0x72, 0x73 => @as(T, @truncate(apu.ch3.sound3CntH() >> getHalf(byte_addr))),
0x74, 0x75 => @as(T, @truncate(apu.ch3.sound3CntX() >> getHalf(byte_addr))), // SOUND3CNT_L
0x76, 0x77 => 0x00,
0x78, 0x79 => @truncate(T, apu.ch4.sound4CntL() >> getHalf(byte_addr)),
0x78, 0x79 => @as(T, @truncate(apu.ch4.sound4CntL() >> getHalf(byte_addr))),
0x7A, 0x7B => 0x00,
0x7C, 0x7D => @truncate(T, apu.ch4.sound4CntH() >> getHalf(byte_addr)),
0x7C, 0x7D => @as(T, @truncate(apu.ch4.sound4CntH() >> getHalf(byte_addr))),
0x7E, 0x7F => 0x00,
0x80, 0x81 => @truncate(T, apu.soundCntL() >> getHalf(byte_addr)), // SOUNDCNT_L
0x82, 0x83 => @truncate(T, apu.soundCntH() >> getHalf(byte_addr)), // SOUNDCNT_H
0x84, 0x85 => @truncate(T, @as(u16, apu.soundCntX()) >> getHalf(byte_addr)),
0x80, 0x81 => @as(T, @truncate(apu.soundCntL() >> getHalf(byte_addr))), // SOUNDCNT_L
0x82, 0x83 => @as(T, @truncate(apu.soundCntH() >> getHalf(byte_addr))), // SOUNDCNT_H
0x84, 0x85 => @as(T, @truncate(@as(u16, apu.soundCntX()) >> getHalf(byte_addr))),
0x86, 0x87 => 0x00,
0x88, 0x89 => @truncate(T, apu.bias.raw >> getHalf(byte_addr)), // SOUNDBIAS
0x88, 0x89 => @as(T, @truncate(apu.bias.raw >> getHalf(byte_addr))), // SOUNDBIAS
0x8A, 0x8B => 0x00,
0x8C...0x8F => null,
0x90...0x9F => apu.ch3.wave_dev.read(T, apu.ch3.select, addr),
@ -106,7 +106,7 @@ pub fn read(comptime T: type, apu: *const Apu, addr: u32) ?T {
}
pub fn write(comptime T: type, apu: *Apu, addr: u32, value: T) void {
const byte_addr = @truncate(u8, addr);
const byte_addr = @as(u8, @truncate(addr));
if (byte_addr <= 0x81 and !apu.cnt.apu_enable.read()) return;
@ -117,20 +117,20 @@ pub fn write(comptime T: type, apu: *Apu, addr: u32, value: T) void {
switch (byte_addr) {
0x60 => apu.ch1.setSound1Cnt(value),
0x64 => apu.ch1.setSound1CntX(&apu.fs, @truncate(u16, value)),
0x64 => apu.ch1.setSound1CntX(&apu.fs, @as(u16, @truncate(value))),
0x68 => apu.ch2.setSound2CntL(@truncate(u16, value)),
0x6C => apu.ch2.setSound2CntH(&apu.fs, @truncate(u16, value)),
0x68 => apu.ch2.setSound2CntL(@as(u16, @truncate(value))),
0x6C => apu.ch2.setSound2CntH(&apu.fs, @as(u16, @truncate(value))),
0x70 => apu.ch3.setSound3Cnt(value),
0x74 => apu.ch3.setSound3CntX(&apu.fs, @truncate(u16, value)),
0x74 => apu.ch3.setSound3CntX(&apu.fs, @as(u16, @truncate(value))),
0x78 => apu.ch4.setSound4CntL(@truncate(u16, value)),
0x7C => apu.ch4.setSound4CntH(&apu.fs, @truncate(u16, value)),
0x78 => apu.ch4.setSound4CntL(@as(u16, @truncate(value))),
0x7C => apu.ch4.setSound4CntH(&apu.fs, @as(u16, @truncate(value))),
0x80 => apu.setSoundCnt(value),
0x84 => apu.setSoundCntX(value >> 7 & 1 == 1),
0x88 => apu.bias.raw = @truncate(u16, value),
0x88 => apu.bias.raw = @as(u16, @truncate(value)),
0x8C => {},
0x90, 0x94, 0x98, 0x9C => apu.ch3.wave_dev.write(T, apu.ch3.select, addr, value),
@ -143,7 +143,7 @@ pub fn write(comptime T: type, apu: *Apu, addr: u32, value: T) void {
if (byte_addr <= 0x81 and !apu.cnt.apu_enable.read()) return;
switch (byte_addr) {
0x60 => apu.ch1.setSound1CntL(@truncate(u8, value)), // SOUND1CNT_L
0x60 => apu.ch1.setSound1CntL(@as(u8, @truncate(value))), // SOUND1CNT_L
0x62 => apu.ch1.setSound1CntH(value),
0x64 => apu.ch1.setSound1CntX(&apu.fs, value),
0x66 => {},
@ -153,7 +153,7 @@ pub fn write(comptime T: type, apu: *Apu, addr: u32, value: T) void {
0x6C => apu.ch2.setSound2CntH(&apu.fs, value),
0x6E => {},
0x70 => apu.ch3.setSound3CntL(@truncate(u8, value)),
0x70 => apu.ch3.setSound3CntL(@as(u8, @truncate(value))),
0x72 => apu.ch3.setSound3CntH(value),
0x74 => apu.ch3.setSound3CntX(&apu.fs, value),
0x76 => {},
@ -330,8 +330,8 @@ pub const Apu = struct {
/// SOUNDCNT
fn setSoundCnt(self: *Self, value: u32) void {
if (self.cnt.apu_enable.read()) self.setSoundCntL(@truncate(u16, value));
self.setSoundCntH(@truncate(u16, value >> 16));
if (self.cnt.apu_enable.read()) self.setSoundCntL(@as(u16, @truncate(value)));
self.setSoundCntH(@as(u16, @truncate(value >> 16)));
}
/// SOUNDCNT_L
@ -384,12 +384,12 @@ pub const Apu = struct {
/// NR52
pub fn soundCntX(self: *const Self) u8 {
const apu_enable: u8 = @boolToInt(self.cnt.apu_enable.read());
const apu_enable: u8 = @intFromBool(self.cnt.apu_enable.read());
const ch1_enable: u8 = @boolToInt(self.ch1.enabled);
const ch2_enable: u8 = @boolToInt(self.ch2.enabled);
const ch3_enable: u8 = @boolToInt(self.ch3.enabled);
const ch4_enable: u8 = @boolToInt(self.ch4.enabled);
const ch1_enable: u8 = @intFromBool(self.ch1.enabled);
const ch2_enable: u8 = @intFromBool(self.ch2.enabled);
const ch3_enable: u8 = @intFromBool(self.ch3.enabled);
const ch4_enable: u8 = @intFromBool(self.ch4.enabled);
return apu_enable << 7 | ch4_enable << 3 | ch3_enable << 2 | ch2_enable << 1 | ch1_enable;
}
@ -450,8 +450,8 @@ pub const Apu = struct {
left += bias;
right += bias;
const clamped_left = std.math.clamp(@bitCast(u16, left), std.math.minInt(u11), std.math.maxInt(u11));
const clamped_right = std.math.clamp(@bitCast(u16, right), std.math.minInt(u11), std.math.maxInt(u11));
const clamped_left = std.math.clamp(@as(u16, @bitCast(left)), std.math.minInt(u11), std.math.maxInt(u11));
const clamped_right = std.math.clamp(@as(u16, @bitCast(right)), std.math.minInt(u11), std.math.maxInt(u11));
// Extend to 16-bit signed audio samples
const ext_left = (clamped_left << 5) | (clamped_left >> 6);
@ -473,7 +473,7 @@ pub const Apu = struct {
defer SDL.SDL_FreeAudioStream(old_stream);
self.sampling_cycle = self.bias.sampling_cycle.read();
self.stream = SDL.SDL_NewAudioStream(SDL.AUDIO_U16, 2, @intCast(c_int, sample_rate), host_format, 2, host_rate).?;
self.stream = SDL.SDL_NewAudioStream(SDL.AUDIO_U16, 2, @as(c_int, @intCast(sample_rate)), host_format, 2, host_rate).?;
}
fn interval(self: *const Self) u64 {
@ -521,16 +521,16 @@ pub const Apu = struct {
pub fn onDmaAudioSampleRequest(self: *Self, cpu: *Arm7tdmi, tim_id: u3) void {
if (!self.cnt.apu_enable.read()) return;
const bus_ptr = @ptrCast(*Bus, @alignCast(@alignOf(Bus), cpu.bus.ptr));
const bus_ptr: *Bus = @ptrCast(@alignCast(cpu.bus.ptr));
if (@boolToInt(self.dma_cnt.chA_timer.read()) == tim_id) {
if (@intFromBool(self.dma_cnt.chA_timer.read()) == tim_id) {
if (!self.chA.enabled) return;
self.chA.updateSample();
if (self.chA.len() <= 15) bus_ptr.dma[1].requestAudio(0x0400_00A0);
}
if (@boolToInt(self.dma_cnt.chB_timer.read()) == tim_id) {
if (@intFromBool(self.dma_cnt.chB_timer.read()) == tim_id) {
if (!self.chB.enabled) return;
self.chB.updateSample();
@ -578,7 +578,7 @@ pub fn DmaSound(comptime kind: DmaSoundKind) type {
}
pub fn updateSample(self: *Self) void {
if (self.fifo.readItem()) |sample| self.sample = @bitCast(i8, sample);
if (self.fifo.readItem()) |sample| self.sample = @as(i8, @bitCast(sample));
}
pub fn amplitude(self: *const Self) i16 {

12
src/core/apu/Noise.zig
View File

@ -76,14 +76,14 @@ pub fn sound4CntL(self: *const Self) u16 {
/// NR41, NR42
pub fn setSound4CntL(self: *Self, value: u16) void {
self.setNr41(@truncate(u8, value));
self.setNr42(@truncate(u8, value >> 8));
self.setNr41(@as(u8, @truncate(value)));
self.setNr42(@as(u8, @truncate(value >> 8)));
}
/// NR41
pub fn setNr41(self: *Self, len: u8) void {
self.len = @truncate(u6, len);
self.len_dev.timer = @as(u7, 64) - @truncate(u6, len);
self.len = @as(u6, @truncate(len));
self.len_dev.timer = @as(u7, 64) - @as(u6, @truncate(len));
}
/// NR42
@ -99,8 +99,8 @@ pub fn sound4CntH(self: *const Self) u16 {
/// NR43, NR44
pub fn setSound4CntH(self: *Self, fs: *const FrameSequencer, value: u16) void {
self.poly.raw = @truncate(u8, value);
self.setNr44(fs, @truncate(u8, value >> 8));
self.poly.raw = @as(u8, @truncate(value));
self.setNr44(fs, @as(u8, @truncate(value >> 8)));
}
/// NR44

10
src/core/apu/Tone.zig
View File

@ -77,14 +77,14 @@ pub fn sound2CntL(self: *const Self) u16 {
/// NR21, NR22
pub fn setSound2CntL(self: *Self, value: u16) void {
self.setNr21(@truncate(u8, value));
self.setNr22(@truncate(u8, value >> 8));
self.setNr21(@as(u8, @truncate(value)));
self.setNr22(@as(u8, @truncate(value >> 8)));
}
/// NR21
pub fn setNr21(self: *Self, value: u8) void {
self.duty.raw = value;
self.len_dev.timer = @as(u7, 64) - @truncate(u6, value);
self.len_dev.timer = @as(u7, 64) - @as(u6, @truncate(value));
}
/// NR22
@ -100,8 +100,8 @@ pub fn sound2CntH(self: *const Self) u16 {
/// NR23, NR24
pub fn setSound2CntH(self: *Self, fs: *const FrameSequencer, value: u16) void {
self.setNr23(@truncate(u8, value));
self.setNr24(fs, @truncate(u8, value >> 8));
self.setNr23(@as(u8, @truncate(value)));
self.setNr24(fs, @as(u8, @truncate(value >> 8)));
}
/// NR23

14
src/core/apu/ToneSweep.zig
View File

@ -81,8 +81,8 @@ pub fn onToneSweepEvent(self: *Self, late: u64) void {
/// NR10, NR11, NR12
pub fn setSound1Cnt(self: *Self, value: u32) void {
self.setSound1CntL(@truncate(u8, value));
self.setSound1CntH(@truncate(u16, value >> 16));
self.setSound1CntL(@as(u8, @truncate(value)));
self.setSound1CntH(@as(u16, @truncate(value >> 16)));
}
/// NR10
@ -111,14 +111,14 @@ pub fn sound1CntH(self: *const Self) u16 {
/// NR11, NR12
pub fn setSound1CntH(self: *Self, value: u16) void {
self.setNr11(@truncate(u8, value));
self.setNr12(@truncate(u8, value >> 8));
self.setNr11(@as(u8, @truncate(value)));
self.setNr12(@as(u8, @truncate(value >> 8)));
}
/// NR11
pub fn setNr11(self: *Self, value: u8) void {
self.duty.raw = value;
self.len_dev.timer = @as(u7, 64) - @truncate(u6, value);
self.len_dev.timer = @as(u7, 64) - @as(u6, @truncate(value));
}
/// NR12
@ -134,8 +134,8 @@ pub fn sound1CntX(self: *const Self) u16 {
/// NR13, NR14
pub fn setSound1CntX(self: *Self, fs: *const FrameSequencer, value: u16) void {
self.setNr13(@truncate(u8, value));
self.setNr14(fs, @truncate(u8, value >> 8));
self.setNr13(@as(u8, @truncate(value)));
self.setNr14(fs, @as(u8, @truncate(value >> 8)));
}
/// NR13

12
src/core/apu/Wave.zig
View File

@ -64,8 +64,8 @@ pub fn tick(self: *Self, comptime kind: Tick) void {
/// NR30, NR31, NR32
pub fn setSound3Cnt(self: *Self, value: u32) void {
self.setSound3CntL(@truncate(u8, value));
self.setSound3CntH(@truncate(u16, value >> 16));
self.setSound3CntL(@as(u8, @truncate(value)));
self.setSound3CntH(@as(u16, @truncate(value >> 16)));
}
/// NR30
@ -86,8 +86,8 @@ pub fn sound3CntH(self: *const Self) u16 {
/// NR31, NR32
pub fn setSound3CntH(self: *Self, value: u16) void {
self.setNr31(@truncate(u8, value));
self.vol.raw = (@truncate(u8, value >> 8));
self.setNr31(@as(u8, @truncate(value)));
self.vol.raw = (@as(u8, @truncate(value >> 8)));
}
/// NR31
@ -98,8 +98,8 @@ pub fn setNr31(self: *Self, len: u8) void {
/// NR33, NR34
pub fn setSound3CntX(self: *Self, fs: *const FrameSequencer, value: u16) void {
self.setNr33(@truncate(u8, value));
self.setNr34(fs, @truncate(u8, value >> 8));
self.setNr33(@as(u8, @truncate(value)));
self.setNr34(fs, @as(u8, @truncate(value >> 8)));
}
/// NR33, NR34

4
src/core/apu/device/Sweep.zig
View File

@ -28,8 +28,8 @@ pub fn tick(self: *Self, ch1: *ToneSweep) void {
const new_freq = self.calculate(ch1.sweep, &ch1.enabled);
if (new_freq <= 0x7FF and ch1.sweep.shift.read() != 0) {
ch1.freq.frequency.write(@truncate(u11, new_freq));
self.shadow = @truncate(u11, new_freq);
ch1.freq.frequency.write(@as(u11, @truncate(new_freq)));
self.shadow = @as(u11, @truncate(new_freq));
_ = self.calculate(ch1.sweep, &ch1.enabled);
}

2
src/core/apu/signal/Wave.zig
View File

@ -70,7 +70,7 @@ pub fn sample(self: *const Self, nr30: io.WaveSelect) u4 {
const base = if (nr30.bank.read()) @as(u32, 0x10) else 0;
const value = self.buf[base + self.offset / 2];
return if (self.offset & 1 == 0) @truncate(u4, value >> 4) else @truncate(u4, value);
return if (self.offset & 1 == 0) @as(u4, @truncate(value >> 4)) else @as(u4, @truncate(value));
}
/// TODO: Write comment

4
src/core/bus/Bios.zig
View File

@ -27,7 +27,7 @@ pub fn read(self: *Self, comptime T: type, r15: u32, address: u32) T {
log.warn("Open Bus! Read from 0x{X:0>8}, but PC was 0x{X:0>8}", .{ address, r15 });
const value = self._read(u32, self.addr_latch);
return @truncate(T, rotr(u32, value, 8 * rotateBy(T, address)));
return @as(T, @truncate(rotr(u32, value, 8 * rotateBy(T, address))));
}
fn rotateBy(comptime T: type, address: u32) u32 {
@ -43,7 +43,7 @@ pub fn dbgRead(self: *const Self, comptime T: type, r15: u32, address: u32) T {
if (r15 < Self.size) return self._read(T, forceAlign(T, address));
const value = self._read(u32, self.addr_latch);
return @truncate(T, rotr(u32, value, 8 * rotateBy(T, address)));
return @as(T, @truncate(rotr(u32, value, 8 * rotateBy(T, address))));
}
/// Read without the GBA safety checks

24
src/core/bus/GamePak.zig
View File

@ -30,7 +30,7 @@ pub fn read(self: *Self, comptime T: type, address: u32) T {
// Addresses 0x0D00_0000 to 0x0DFF_FFFF are reserved for EEPROM accesses if
// * Backup type is EEPROM
// * Small ROM (less than 16MB)
if (@truncate(u8, address >> 24) == 0x0D)
if (@as(u8, @truncate(address >> 24)) == 0x0D)
return self.backup.eeprom.read();
}
}
@ -77,7 +77,7 @@ inline fn get(self: *const Self, i: u32) u8 {
if (i < self.buf.len) return self.buf[i];
const lhs = i >> 1 & 0xFFFF;
return @truncate(u8, lhs >> 8 * @truncate(u5, i & 1));
return @as(u8, @truncate(lhs >> 8 * @as(u5, @truncate(i & 1))));
}
pub fn dbgRead(self: *const Self, comptime T: type, address: u32) T {
@ -94,7 +94,7 @@ pub fn dbgRead(self: *const Self, comptime T: type, address: u32) T {
// Addresses 0x0D00_0000 to 0x0DFF_FFFF are reserved for EEPROM accesses if
// * Backup type is EEPROM
// * Small ROM (less than 16MB)
if (@truncate(u8, address >> 24) == 0x0D)
if (@as(u8, @truncate(address >> 24)) == 0x0D)
return self.backup.eeprom.dbgRead();
}
}
@ -139,7 +139,7 @@ pub fn write(self: *Self, comptime T: type, word_count: u16, address: u32, value
const addr = address & 0x1FF_FFFF;
if (self.backup.kind == .Eeprom) {
const bit = @truncate(u1, value);
const bit = @as(u1, @truncate(value));
if (self.buf.len > 0x100_0000) { // Large
// Addresses 0x1FF_FF00 to 0x1FF_FFFF are reserved from EEPROM accesses if
@ -151,7 +151,7 @@ pub fn write(self: *Self, comptime T: type, word_count: u16, address: u32, value
// Addresses 0x0D00_0000 to 0x0DFF_FFFF are reserved for EEPROM accesses if
// * Backup type is EEPROM
// * Small ROM (less than 16MB)
if (@truncate(u8, address >> 24) == 0x0D)
if (@as(u8, @truncate(address >> 24)) == 0x0D)
return self.backup.eeprom.write(word_count, &self.backup.buf, bit);
}
}
@ -159,19 +159,19 @@ pub fn write(self: *Self, comptime T: type, word_count: u16, address: u32, value
switch (T) {
u32 => switch (address) {
0x0800_00C4 => {
self.gpio.write(.Data, @truncate(u4, value));
self.gpio.write(.Direction, @truncate(u4, value >> 16));
self.gpio.write(.Data, @as(u4, @truncate(value)));
self.gpio.write(.Direction, @as(u4, @truncate(value >> 16)));
},
0x0800_00C6 => {
self.gpio.write(.Direction, @truncate(u4, value));
self.gpio.write(.Control, @truncate(u1, value >> 16));
self.gpio.write(.Direction, @as(u4, @truncate(value)));
self.gpio.write(.Control, @as(u1, @truncate(value >> 16)));
},
else => log.err("Wrote {} 0x{X:0>8} to 0x{X:0>8}, Unhandled", .{ T, value, address }),
},
u16 => switch (address) {
0x0800_00C4 => self.gpio.write(.Data, @truncate(u4, value)),
0x0800_00C6 => self.gpio.write(.Direction, @truncate(u4, value)),
0x0800_00C8 => self.gpio.write(.Control, @truncate(u1, value)),
0x0800_00C4 => self.gpio.write(.Data, @as(u4, @truncate(value))),
0x0800_00C6 => self.gpio.write(.Direction, @as(u4, @truncate(value))),
0x0800_00C8 => self.gpio.write(.Control, @as(u1, @truncate(value))),
else => log.err("Wrote {} 0x{X:0>4} to 0x{X:0>8}, Unhandled", .{ T, value, address }),
},
u8 => log.debug("Wrote {} 0x{X:0>2} to 0x{X:0>8}, Ignored.", .{ T, value, address }),

2
src/core/bus/backup.zig
View File

@ -77,7 +77,7 @@ pub const Backup = struct {
switch (addr) {
0x0000 => if (self.kind == .Flash1M and self.flash.set_bank) {
self.flash.bank = @truncate(u1, byte);
self.flash.bank = @as(u1, @truncate(byte));
},
0x5555 => {
if (self.flash.state == .Command) {

24
src/core/bus/backup/eeprom.zig
View File

@ -108,7 +108,7 @@ pub const Eeprom = struct {
switch (self.state) {
.Ready => {
if (self.writer.len() == 2) {
const req = @intCast(u2, self.writer.finish());
const req = @as(u2, @intCast(self.writer.finish()));
switch (req) {
0b11 => self.state = .Read,
0b10 => self.state = .Write,
@ -120,7 +120,7 @@ pub const Eeprom = struct {
switch (self.kind) {
.Large => {
if (self.writer.len() == 14) {
const addr = @intCast(u10, self.writer.finish());
const addr = @as(u10, @intCast(self.writer.finish()));
const value = std.mem.readIntSliceLittle(u64, buf[@as(u13, addr) * 8 ..][0..8]);
self.reader.configure(value);
@ -130,7 +130,7 @@ pub const Eeprom = struct {
.Small => {
if (self.writer.len() == 6) {
// FIXME: Duplicated code from above
const addr = @intCast(u6, self.writer.finish());
const addr = @as(u6, @intCast(self.writer.finish()));
const value = std.mem.readIntSliceLittle(u64, buf[@as(u13, addr) * 8 ..][0..8]);
self.reader.configure(value);
@ -144,13 +144,13 @@ pub const Eeprom = struct {
switch (self.kind) {
.Large => {
if (self.writer.len() == 14) {
self.addr = @intCast(u10, self.writer.finish());
self.addr = @as(u10, @intCast(self.writer.finish()));
self.state = .WriteTransfer;
}
},
.Small => {
if (self.writer.len() == 6) {
self.addr = @intCast(u6, self.writer.finish());
self.addr = @as(u6, @intCast(self.writer.finish()));
self.state = .WriteTransfer;
}
},
@ -189,8 +189,8 @@ const Reader = struct {
const bit = if (self.i < 4) blk: {
break :blk 0;
} else blk: {
const idx = @intCast(u6, 63 - (self.i - 4));
break :blk @truncate(u1, self.data >> idx);
const idx = @as(u6, @intCast(63 - (self.i - 4)));
break :blk @as(u1, @truncate(self.data >> idx));
};
self.i = (self.i + 1) % (64 + 4);
@ -205,8 +205,8 @@ const Reader = struct {
const bit = if (self.i < 4) blk: {
break :blk 0;
} else blk: {
const idx = @intCast(u6, 63 - (self.i - 4));
break :blk @truncate(u1, self.data >> idx);
const idx = @as(u6, @intCast(63 - (self.i - 4)));
break :blk @as(u1, @truncate(self.data >> idx));
};
return bit;
@ -230,7 +230,7 @@ const Writer = struct {
}
fn requestWrite(self: *Self, bit: u1) void {
const idx = @intCast(u1, 1 - self.i);
const idx = @as(u1, @intCast(1 - self.i));
self.data = (self.data & ~(@as(u64, 1) << idx)) | (@as(u64, bit) << idx);
self.i += 1;
}
@ -244,13 +244,13 @@ const Writer = struct {
.Unknown => unreachable,
};
const idx = @intCast(u4, size - self.i);
const idx = @as(u4, @intCast(size - self.i));
self.data = (self.data & ~(@as(u64, 1) << idx)) | (@as(u64, bit) << idx);
self.i += 1;
}
fn dataWrite(self: *Self, bit: u1) void {
const idx = @intCast(u6, 63 - self.i);
const idx = @as(u6, @intCast(63 - self.i));
self.data = (self.data & ~(@as(u64, 1) << idx)) | (@as(u64, bit) << idx);
self.i += 1;
}

30
src/core/bus/dma.zig
View File

@ -20,7 +20,7 @@ pub fn create() DmaTuple {
}
pub fn read(comptime T: type, dma: *const DmaTuple, addr: u32) ?T {
const byte_addr = @truncate(u8, addr);
const byte_addr = @as(u8, @truncate(addr));
return switch (T) {
u32 => switch (byte_addr) {
@ -55,19 +55,19 @@ pub fn read(comptime T: type, dma: *const DmaTuple, addr: u32) ?T {
u8 => switch (byte_addr) {
0xB0...0xB7 => null, // DMA0SAD, DMA0DAD
0xB8, 0xB9 => 0x00, // DMA0CNT_L
0xBA, 0xBB => @truncate(T, dma.*[0].dmacntH() >> getHalf(byte_addr)),
0xBA, 0xBB => @as(T, @truncate(dma.*[0].dmacntH() >> getHalf(byte_addr))),
0xBC...0xC3 => null, // DMA1SAD, DMA1DAD
0xC4, 0xC5 => 0x00, // DMA1CNT_L
0xC6, 0xC7 => @truncate(T, dma.*[1].dmacntH() >> getHalf(byte_addr)),
0xC6, 0xC7 => @as(T, @truncate(dma.*[1].dmacntH() >> getHalf(byte_addr))),
0xC8...0xCF => null, // DMA2SAD, DMA2DAD
0xD0, 0xD1 => 0x00, // DMA2CNT_L
0xD2, 0xD3 => @truncate(T, dma.*[2].dmacntH() >> getHalf(byte_addr)),
0xD2, 0xD3 => @as(T, @truncate(dma.*[2].dmacntH() >> getHalf(byte_addr))),
0xD4...0xDB => null, // DMA3SAD, DMA3DAD
0xDC, 0xDD => 0x00, // DMA3CNT_L
0xDE, 0xDF => @truncate(T, dma.*[3].dmacntH() >> getHalf(byte_addr)),
0xDE, 0xDF => @as(T, @truncate(dma.*[3].dmacntH() >> getHalf(byte_addr))),
else => util.io.read.err(T, log, "unexpected {} read from 0x{X:0>8}", .{ T, addr }),
},
else => @compileError("DMA: Unsupported read width"),
@ -75,7 +75,7 @@ pub fn read(comptime T: type, dma: *const DmaTuple, addr: u32) ?T {
}
pub fn write(comptime T: type, dma: *DmaTuple, addr: u32, value: T) void {
const byte_addr = @truncate(u8, addr);
const byte_addr = @as(u8, @truncate(addr));
switch (T) {
u32 => switch (byte_addr) {
@ -209,7 +209,7 @@ fn DmaController(comptime id: u2) type {
}
pub fn setDmacntL(self: *Self, halfword: u16) void {
self.word_count = @truncate(@TypeOf(self.word_count), halfword);
self.word_count = @as(@TypeOf(self.word_count), @truncate(halfword));
}
pub fn dmacntH(self: *const Self) u16 {
@ -233,16 +233,16 @@ fn DmaController(comptime id: u2) type {
}
pub fn setDmacnt(self: *Self, word: u32) void {
self.setDmacntL(@truncate(u16, word));
self.setDmacntH(@truncate(u16, word >> 16));
self.setDmacntL(@as(u16, @truncate(word)));
self.setDmacntH(@as(u16, @truncate(word >> 16)));
}
pub fn step(self: *Self, cpu: *Arm7tdmi) void {
const bus_ptr = @ptrCast(*Bus, @alignCast(@alignOf(Bus), cpu.bus.ptr));
const bus_ptr: *Bus = @ptrCast(@alignCast(cpu.bus.ptr));
const is_fifo = (id == 1 or id == 2) and self.cnt.start_timing.read() == 0b11;
const sad_adj = @intToEnum(Adjustment, self.cnt.sad_adj.read());
const dad_adj = if (is_fifo) .Fixed else @intToEnum(Adjustment, self.cnt.dad_adj.read());
const sad_adj = @as(Adjustment, @enumFromInt(self.cnt.sad_adj.read()));
const dad_adj = if (is_fifo) .Fixed else @as(Adjustment, @enumFromInt(self.cnt.dad_adj.read()));
const transfer_type = is_fifo or self.cnt.transfer_type.read();
const offset: u32 = if (transfer_type) @sizeOf(u32) else @sizeOf(u16);
@ -260,10 +260,10 @@ fn DmaController(comptime id: u2) type {
self.data_latch = value << 16 | value;
}
cpu.bus.write(u16, dad_addr, @truncate(u16, rotr(u32, self.data_latch, 8 * (dad_addr & 3))));
cpu.bus.write(u16, dad_addr, @as(u16, @truncate(rotr(u32, self.data_latch, 8 * (dad_addr & 3)))));
}
switch (@truncate(u8, sad_addr >> 24)) {
switch (@as(u8, @truncate(sad_addr >> 24))) {
// according to fleroviux, DMAs with a source address in ROM misbehave
// the resultant behaviour is that the source address will increment despite what DMAXCNT says
0x08...0x0D => self.sad_latch +%= offset, // obscure behaviour
@ -321,7 +321,7 @@ fn DmaController(comptime id: u2) type {
// Reload internal DAD latch if we are in IncrementRelaod
if (self.in_progress) {
self._word_count = if (self.word_count == 0) std.math.maxInt(@TypeOf(self._word_count)) else self.word_count;
if (@intToEnum(Adjustment, self.cnt.dad_adj.read()) == .IncrementReload) self.dad_latch = self.dad;
if (@as(Adjustment, @enumFromInt(self.cnt.dad_adj.read())) == .IncrementReload) self.dad_latch = self.dad;
}
}

54
src/core/bus/gpio.zig
View File

@ -31,7 +31,7 @@ pub const Gpio = struct {
fn step(self: *Device, value: u4) u4 {
return switch (self.kind) {
.Rtc => blk: {
const clock = @ptrCast(*Clock, @alignCast(@alignOf(*Clock), self.ptr.?));
const clock: *Clock = @ptrCast(@alignCast(self.ptr.?));
break :blk clock.step(Clock.Data{ .raw = value });
},
.None => value,
@ -94,7 +94,7 @@ pub const Gpio = struct {
pub fn deinit(self: *Self, allocator: Allocator) void {
switch (self.device.kind) {
.Rtc => allocator.destroy(@ptrCast(*Clock, @alignCast(@alignOf(*Clock), self.device.ptr.?))),
.Rtc => allocator.destroy(@as(*Clock, @ptrCast(@alignCast(self.device.ptr.?)))),
.None => {},
}
@ -146,16 +146,16 @@ pub const Clock = struct {
/// 2. A `count`, which keeps track of which byte is currently being read
/// 3. An index, which keeps track of which bit of the byte determined by `count` is being read
fn read(self: *Reader, clock: *const Clock, register: Register) u1 {
const idx = @intCast(u3, self.i);
const idx = @as(u3, @intCast(self.i));
defer self.i += 1;
// FIXME: What do I do about the unused bits?
return switch (register) {
.Control => @truncate(u1, switch (self.count) {
.Control => @as(u1, @truncate(switch (self.count) {
0 => clock.cnt.raw >> idx,
else => std.debug.panic("Tried to read from byte #{} of {} (hint: there's only 1 byte)", .{ self.count, register }),
}),
.DateTime => @truncate(u1, switch (self.count) {
})),
.DateTime => @as(u1, @truncate(switch (self.count) {
// Date
0 => clock.year >> idx,
1 => @as(u8, clock.month) >> idx,
@ -167,13 +167,13 @@ pub const Clock = struct {
5 => @as(u8, clock.minute) >> idx,
6 => @as(u8, clock.second) >> idx,
else => std.debug.panic("Tried to read from byte #{} of {} (hint: there's only 7 bytes)", .{ self.count, register }),
}),
.Time => @truncate(u1, switch (self.count) {
})),
.Time => @as(u1, @truncate(switch (self.count) {
0 => @as(u8, clock.hour) >> idx,
1 => @as(u8, clock.minute) >> idx,
2 => @as(u8, clock.second) >> idx,
else => std.debug.panic("Tried to read from byte #{} of {} (hint: there's only 3 bytes)", .{ self.count, register }),
}),
})),
};
}
@ -207,7 +207,7 @@ pub const Clock = struct {
/// Append a bit to the internal bit buffer (aka an integer)
fn push(self: *Writer, value: u1) void {
const idx = @intCast(u3, self.i);
const idx = @as(u3, @intCast(self.i));
self.buf = (self.buf & ~(@as(u8, 1) << idx)) | @as(u8, value) << idx;
self.i += 1;
}
@ -290,22 +290,22 @@ pub const Clock = struct {
.gpio = gpio, // Can't use Arm7tdmi ptr b/c not initialized yet
};
const sched_ptr = @ptrCast(*Scheduler, @alignCast(@alignOf(Scheduler), cpu.sched.ptr));
const sched_ptr: *Scheduler = @ptrCast(@alignCast(cpu.sched.ptr));
sched_ptr.push(.RealTimeClock, 1 << 24); // Every Second
}
pub fn onClockUpdate(self: *Self, late: u64) void {
const sched_ptr = @ptrCast(*Scheduler, @alignCast(@alignOf(Scheduler), self.cpu.sched.ptr));
const sched_ptr: *Scheduler = @ptrCast(@alignCast(self.cpu.sched.ptr));
sched_ptr.push(.RealTimeClock, (1 << 24) -| late); // Reschedule
const now = DateTime.now();
self.year = bcd(@intCast(u8, now.date.year - 2000));
self.month = @truncate(u5, bcd(now.date.month));
self.day = @truncate(u6, bcd(now.date.day));
self.weekday = @truncate(u3, bcd((now.date.weekday() + 1) % 7)); // API is Monday = 0, Sunday = 6. We want Sunday = 0, Saturday = 6
self.hour = @truncate(u6, bcd(now.time.hour));
self.minute = @truncate(u7, bcd(now.time.minute));
self.second = @truncate(u7, bcd(now.time.second));
self.year = bcd(@as(u8, @intCast(now.date.year - 2000)));
self.month = @as(u5, @truncate(bcd(now.date.month)));
self.day = @as(u6, @truncate(bcd(now.date.day)));
self.weekday = @as(u3, @truncate(bcd((now.date.weekday() + 1) % 7))); // API is Monday = 0, Sunday = 6. We want Sunday = 0, Saturday = 6
self.hour = @as(u6, @truncate(bcd(now.time.hour)));
self.minute = @as(u7, @truncate(bcd(now.time.minute)));
self.second = @as(u7, @truncate(bcd(now.time.second)));
}
fn step(self: *Self, value: Data) u4 {
@ -321,14 +321,14 @@ pub const Clock = struct {
}
}
break :blk @truncate(u4, value.raw);
break :blk @as(u4, @truncate(value.raw));
},
.Command => blk: {
if (!value.cs.read()) log.err("Expected CS to be set during {}, however CS was cleared", .{self.state});
// If SCK rises, sample SIO
if (!cache.sck.read() and value.sck.read()) {
self.writer.push(@boolToInt(value.sio.read()));
self.writer.push(@intFromBool(value.sio.read()));
if (self.writer.finished()) {
self.state = self.processCommand(self.writer.buf);
@ -338,14 +338,14 @@ pub const Clock = struct {
}
}
break :blk @truncate(u4, value.raw);
break :blk @as(u4, @truncate(value.raw));
},
.Write => |register| blk: {
if (!value.cs.read()) log.err("Expected CS to be set during {}, however CS was cleared", .{self.state});
// If SCK rises, sample SIO
if (!cache.sck.read() and value.sck.read()) {
self.writer.push(@boolToInt(value.sio.read()));
self.writer.push(@intFromBool(value.sio.read()));
const register_width: u32 = switch (register) {
.Control => 1,
@ -364,7 +364,7 @@ pub const Clock = struct {
}
}
break :blk @truncate(u4, value.raw);
break :blk @as(u4, @truncate(value.raw));
},
.Read => |register| blk: {
if (!value.cs.read()) log.err("Expected CS to be set during {}, however CS was cleared", .{self.state});
@ -390,7 +390,7 @@ pub const Clock = struct {
}
}
break :blk @truncate(u4, ret.raw);
break :blk @as(u4, @truncate(ret.raw));
},
};
}
@ -403,7 +403,7 @@ pub const Clock = struct {
}
fn irq(self: *Self) void {
const bus_ptr = @ptrCast(*Bus, @alignCast(@alignOf(Bus), self.cpu.bus.ptr));
const bus_ptr: *Bus = @ptrCast(@alignCast(self.cpu.bus.ptr));
// TODO: Confirm that this is the right behaviour
log.debug("Force GamePak IRQ", .{});
@ -429,7 +429,7 @@ pub const Clock = struct {
log.debug("Handling Command 0x{X:0>2} [0b{b:0>8}]", .{ command, command });
const is_write = command & 1 == 0;
const rtc_register = @truncate(u3, command >> 1 & 0x7);
const rtc_register = @as(u3, @truncate(command >> 1 & 0x7));
if (is_write) {
return switch (rtc_register) {

34
src/core/bus/io.zig
View File

@ -43,8 +43,8 @@ pub const Io = struct {
}
fn setIrqs(self: *Io, word: u32) void {
self.ie.raw = @truncate(u16, word);
self.irq.raw &= ~@truncate(u16, word >> 16);
self.ie.raw = @as(u16, @truncate(word));
self.irq.raw &= ~@as(u16, @truncate(word >> 16));
}
};
@ -75,8 +75,8 @@ pub fn read(bus: *const Bus, comptime T: type, address: u32) ?T {
// Interrupts
0x0400_0200 => @as(u32, bus.io.irq.raw) << 16 | bus.io.ie.raw,
0x0400_0204 => bus.io.waitcnt.raw,
0x0400_0208 => @boolToInt(bus.io.ime),
0x0400_0300 => @enumToInt(bus.io.postflg),
0x0400_0208 => @intFromBool(bus.io.ime),
0x0400_0300 => @intFromEnum(bus.io.postflg),
else => util.io.read.undef(T, log, "Tried to perform a {} read to 0x{X:0>8}", .{ T, address }),
},
u16 => switch (address) {
@ -109,9 +109,9 @@ pub fn read(bus: *const Bus, comptime T: type, address: u32) ?T {
0x0400_0202 => bus.io.irq.raw,
0x0400_0204 => bus.io.waitcnt.raw,
0x0400_0206 => 0x0000,
0x0400_0208 => @boolToInt(bus.io.ime),
0x0400_0208 => @intFromBool(bus.io.ime),
0x0400_020A => 0x0000,
0x0400_0300 => @enumToInt(bus.io.postflg),
0x0400_0300 => @intFromEnum(bus.io.postflg),
0x0400_0302 => 0x0000,
else => util.io.read.undef(T, log, "Tried to perform a {} read to 0x{X:0>8}", .{ T, address }),
},
@ -141,13 +141,13 @@ pub fn read(bus: *const Bus, comptime T: type, address: u32) ?T {
0x0400_015A, 0x0400_015B => 0x00,
// Interrupts
0x0400_0200, 0x0400_0201 => @truncate(T, bus.io.ie.raw >> getHalf(@truncate(u8, address))),
0x0400_0202, 0x0400_0203 => @truncate(T, bus.io.irq.raw >> getHalf(@truncate(u8, address))),
0x0400_0204, 0x0400_0205 => @truncate(T, bus.io.waitcnt.raw >> getHalf(@truncate(u8, address))),
0x0400_0200, 0x0400_0201 => @as(T, @truncate(bus.io.ie.raw >> getHalf(@as(u8, @truncate(address))))),
0x0400_0202, 0x0400_0203 => @as(T, @truncate(bus.io.irq.raw >> getHalf(@as(u8, @truncate(address))))),
0x0400_0204, 0x0400_0205 => @as(T, @truncate(bus.io.waitcnt.raw >> getHalf(@as(u8, @truncate(address))))),
0x0400_0206, 0x0400_0207 => 0x00,
0x0400_0208, 0x0400_0209 => @truncate(T, @as(u16, @boolToInt(bus.io.ime)) >> getHalf(@truncate(u8, address))),
0x0400_0208, 0x0400_0209 => @as(T, @truncate(@as(u16, @intFromBool(bus.io.ime)) >> getHalf(@as(u8, @truncate(address))))),
0x0400_020A, 0x0400_020B => 0x00,
0x0400_0300 => @enumToInt(bus.io.postflg),
0x0400_0300 => @intFromEnum(bus.io.postflg),
0x0400_0301 => null,
0x0400_0302, 0x0400_0303 => 0x00,
else => util.io.read.undef(T, log, "Tried to perform a {} read to 0x{X:0>8}", .{ T, address }),
@ -196,10 +196,10 @@ pub fn write(bus: *Bus, comptime T: type, address: u32, value: T) void {
// Interrupts
0x0400_0200 => bus.io.setIrqs(value),
0x0400_0204 => bus.io.waitcnt.set(@truncate(u16, value)),
0x0400_0204 => bus.io.waitcnt.set(@as(u16, @truncate(value))),
0x0400_0208 => bus.io.ime = value & 1 == 1,
0x0400_0300 => {
bus.io.postflg = @intToEnum(PostFlag, value & 1);
bus.io.postflg = @as(PostFlag, @enumFromInt(value & 1));
bus.io.haltcnt = if (value >> 15 & 1 == 0) .Halt else @panic("TODO: Implement STOP");
},
else => util.io.write.undef(log, "Tried to write 0x{X:0>8}{} to 0x{X:0>8}", .{ value, T, address }),
@ -246,7 +246,7 @@ pub fn write(bus: *Bus, comptime T: type, address: u32, value: T) void {
0x0400_0208 => bus.io.ime = value & 1 == 1,
0x0400_020A => {},
0x0400_0300 => {
bus.io.postflg = @intToEnum(PostFlag, value & 1);
bus.io.postflg = @as(PostFlag, @enumFromInt(value & 1));
bus.io.haltcnt = if (value >> 15 & 1 == 0) .Halt else @panic("TODO: Implement STOP");
},
else => util.io.write.undef(log, "Tried to write 0x{X:0>4}{} to 0x{X:0>8}", .{ value, T, address }),
@ -273,16 +273,16 @@ pub fn write(bus: *Bus, comptime T: type, address: u32, value: T) void {
0x0400_0140 => log.debug("Wrote 0x{X:0>2} to JOYCNT_L", .{value}),
// Interrupts
0x0400_0200, 0x0400_0201 => bus.io.ie.raw = setHalf(u16, bus.io.ie.raw, @truncate(u8, address), value),
0x0400_0200, 0x0400_0201 => bus.io.ie.raw = setHalf(u16, bus.io.ie.raw, @as(u8, @truncate(address)), value),
0x0400_0202 => bus.io.irq.raw &= ~@as(u16, value),
0x0400_0203 => bus.io.irq.raw &= ~@as(u16, value) << 8, // TODO: Is this good?
0x0400_0204, 0x0400_0205 => bus.io.waitcnt.set(setHalf(u16, @truncate(u16, bus.io.waitcnt.raw), @truncate(u8, address), value)),
0x0400_0204, 0x0400_0205 => bus.io.waitcnt.set(setHalf(u16, @as(u16, @truncate(bus.io.waitcnt.raw)), @as(u8, @truncate(address)), value)),
0x0400_0206, 0x0400_0207 => {},
0x0400_0208 => bus.io.ime = value & 1 == 1,
0x0400_0209 => {},
0x0400_020A, 0x0400_020B => {},
0x0400_0300 => bus.io.postflg = @intToEnum(PostFlag, value & 1),
0x0400_0300 => bus.io.postflg = @as(PostFlag, @enumFromInt(value & 1)),
0x0400_0301 => bus.io.haltcnt = if (value >> 7 & 1 == 0) .Halt else std.debug.panic("TODO: Implement STOP", .{}),
0x0400_0410 => log.debug("Wrote 0x{X:0>2} to the common yet undocumented 0x{X:0>8}", .{ value, address }),

30
src/core/bus/timer.zig
View File

@ -19,7 +19,7 @@ pub fn create(sched: *Scheduler) TimerTuple {
}
pub fn read(comptime T: type, tim: *const TimerTuple, addr: u32) ?T {
const nybble_addr = @truncate(u4, addr);
const nybble_addr = @as(u4, @truncate(addr));
return switch (T) {
u32 => switch (nybble_addr) {
@ -44,24 +44,24 @@ pub fn read(comptime T: type, tim: *const TimerTuple, addr: u32) ?T {
else => util.io.read.err(T, log, "unaligned {} read from 0x{X:0>8}", .{ T, addr }),
},
u8 => switch (nybble_addr) {
0x0, 0x1 => @truncate(T, tim.*[0].timcntL() >> getHalf(nybble_addr)),
0x2, 0x3 => @truncate(T, tim.*[0].cnt.raw >> getHalf(nybble_addr)),
0x0, 0x1 => @as(T, @truncate(tim.*[0].timcntL() >> getHalf(nybble_addr))),
0x2, 0x3 => @as(T, @truncate(tim.*[0].cnt.raw >> getHalf(nybble_addr))),
0x4, 0x5 => @truncate(T, tim.*[1].timcntL() >> getHalf(nybble_addr)),
0x6, 0x7 => @truncate(T, tim.*[1].cnt.raw >> getHalf(nybble_addr)),
0x4, 0x5 => @as(T, @truncate(tim.*[1].timcntL() >> getHalf(nybble_addr))),
0x6, 0x7 => @as(T, @truncate(tim.*[1].cnt.raw >> getHalf(nybble_addr))),
0x8, 0x9 => @truncate(T, tim.*[2].timcntL() >> getHalf(nybble_addr)),
0xA, 0xB => @truncate(T, tim.*[2].cnt.raw >> getHalf(nybble_addr)),
0x8, 0x9 => @as(T, @truncate(tim.*[2].timcntL() >> getHalf(nybble_addr))),
0xA, 0xB => @as(T, @truncate(tim.*[2].cnt.raw >> getHalf(nybble_addr))),
0xC, 0xD => @truncate(T, tim.*[3].timcntL() >> getHalf(nybble_addr)),
0xE, 0xF => @truncate(T, tim.*[3].cnt.raw >> getHalf(nybble_addr)),
0xC, 0xD => @as(T, @truncate(tim.*[3].timcntL() >> getHalf(nybble_addr))),
0xE, 0xF => @as(T, @truncate(tim.*[3].cnt.raw >> getHalf(nybble_addr))),
},
else => @compileError("TIM: Unsupported read width"),
};
}
pub fn write(comptime T: type, tim: *TimerTuple, addr: u32, value: T) void {
const nybble_addr = @truncate(u4, addr);
const nybble_addr = @as(u4, @truncate(addr));
return switch (T) {
u32 => switch (nybble_addr) {
@ -141,7 +141,7 @@ fn Timer(comptime id: u2) type {
pub fn timcntL(self: *const Self) u16 {
if (self.cnt.cascade.read() or !self.cnt.enabled.read()) return self._counter;
return self._counter +% @truncate(u16, (self.sched.now() - self._start_timestamp) / self.frequency());
return self._counter +% @as(u16, @truncate((self.sched.now() - self._start_timestamp) / self.frequency()));
}
/// TIMCNT_L Setter
@ -151,8 +151,8 @@ fn Timer(comptime id: u2) type {
/// TIMCNT_L & TIMCNT_H
pub fn setTimcnt(self: *Self, word: u32) void {
self.setTimcntL(@truncate(u16, word));
self.setTimcntH(@truncate(u16, word >> 16));
self.setTimcntL(@as(u16, @truncate(word)));
self.setTimcntH(@as(u16, @truncate(word >> 16)));
}
/// TIMCNT_H
@ -167,7 +167,7 @@ fn Timer(comptime id: u2) type {
self.sched.removeScheduledEvent(.{ .TimerOverflow = id });
// Counter should hold the value it stopped at meaning we have to calculate it now
self._counter +%= @truncate(u16, (self.sched.now() - self._start_timestamp) / self.frequency());
self._counter +%= @as(u16, @truncate((self.sched.now() - self._start_timestamp) / self.frequency()));
}
// the timer has always been enabled, but the cascade bit which was blocking the timer has been unset
@ -194,7 +194,7 @@ fn Timer(comptime id: u2) type {
pub fn onTimerExpire(self: *Self, cpu: *Arm7tdmi, late: u64) void {
// Fire IRQ if enabled
const bus_ptr = @ptrCast(*Bus, @alignCast(@alignOf(Bus), cpu.bus.ptr));
const bus_ptr: *Bus = @ptrCast(@alignCast(cpu.bus.ptr));
const io = &bus_ptr.io;

8
src/core/cpu_util.zig
View File

@ -5,13 +5,13 @@ const Bank = @import("arm32").Arm7tdmi.Bank;
const Bus = @import("Bus.zig");
pub inline fn isHalted(cpu: *const Arm7tdmi) bool {
const bus_ptr = @ptrCast(*Bus, @alignCast(@alignOf(Bus), cpu.bus.ptr));
const bus_ptr: *Bus = @ptrCast(@alignCast(cpu.bus.ptr));
return bus_ptr.io.haltcnt == .Halt;
}
pub fn stepDmaTransfer(cpu: *Arm7tdmi) bool {
const bus_ptr = @ptrCast(*Bus, @alignCast(@alignOf(Bus), cpu.bus.ptr));
const bus_ptr: *Bus = @ptrCast(@alignCast(cpu.bus.ptr));
inline for (0..4) |i| {
if (bus_ptr.dma[i].in_progress) {
@ -24,7 +24,7 @@ pub fn stepDmaTransfer(cpu: *Arm7tdmi) bool {
}
pub fn handleInterrupt(cpu: *Arm7tdmi) void {
const bus_ptr = @ptrCast(*Bus, @alignCast(@alignOf(Bus), cpu.bus.ptr));
const bus_ptr: *Bus = @ptrCast(@alignCast(cpu.bus.ptr));
const should_handle = bus_ptr.io.ie.raw & bus_ptr.io.irq.raw;
// Return if IME is disabled, CPSR I is set or there is nothing to handle
@ -57,7 +57,7 @@ pub fn handleInterrupt(cpu: *Arm7tdmi) void {
///
/// TODO: Make above notice impossible to do in code
pub fn fastBoot(cpu: *Arm7tdmi) void {
const bus_ptr = @ptrCast(*Bus, @alignCast(@alignOf(Bus), cpu.bus.ptr));
const bus_ptr: *Bus = @ptrCast(@alignCast(cpu.bus.ptr));
cpu.r = std.mem.zeroes([16]u32);
// cpu.r[0] = 0x08000000;

8
src/core/emu.zig
View File

@ -30,7 +30,7 @@ const frame_period = (std.time.ns_per_s * cycles_per_frame) / clock_rate;
/// Exact Value: 59.7275005696Hz
/// The inverse of the frame period
pub const frame_rate: f64 = @intToFloat(f64, clock_rate) / cycles_per_frame;
pub const frame_rate: f64 = @as(f64, @floatFromInt(clock_rate)) / cycles_per_frame;
const log = std.log.scoped(.Emulation);
@ -58,7 +58,7 @@ fn inner(comptime kind: RunKind, audio_sync: bool, cpu: *Arm7tdmi, scheduler: *S
log.info("FPS tracking enabled", .{});
}
const bus_ptr = @ptrCast(*Bus, @alignCast(@alignOf(Bus), cpu.bus.ptr));
const bus_ptr: *Bus = @ptrCast(@alignCast(cpu.bus.ptr));
var paused: bool = false;
@ -256,14 +256,14 @@ pub fn reset(cpu: *Arm7tdmi) void {
}
pub fn replaceGamepak(cpu: *Arm7tdmi, file_path: []const u8) !void {
const bus_ptr = @ptrCast(*Bus, @alignCast(@alignOf(Bus), cpu.bus.ptr));
const bus_ptr: *Bus = @ptrCast(@alignCast(cpu.bus.ptr));
try bus_ptr.replaceGamepak(file_path);
reset(cpu);
}
pub fn replaceBios(cpu: *Arm7tdmi, file_path: []const u8) !void {
const bus_ptr = @ptrCast(*Bus, @alignCast(@alignOf(Bus), cpu.bus.ptr));
const bus_ptr: *Bus = @ptrCast(@alignCast(cpu.bus.ptr));
const allocator = bus_ptr.bios.allocator;
const bios_len = 0x4000;

204
src/core/ppu.zig
View File

@ -28,7 +28,7 @@ pub const height = 160;
pub const framebuf_pitch = width * @sizeOf(u32);
pub fn read(comptime T: type, ppu: *const Ppu, addr: u32) ?T {
const byte_addr = @truncate(u8, addr);
const byte_addr = @as(u8, @truncate(addr));
return switch (T) {
u32 => switch (byte_addr) {
@ -69,24 +69,24 @@ pub fn read(comptime T: type, ppu: *const Ppu, addr: u32) ?T {
else => util.io.read.err(T, log, "unaligned {} read from 0x{X:0>8}", .{ T, addr }),
},
u8 => switch (byte_addr) {
0x00, 0x01 => @truncate(T, ppu.dispcnt.raw >> getHalf(byte_addr)),
0x00, 0x01 => @as(T, @truncate(ppu.dispcnt.raw >> getHalf(byte_addr))),
0x02, 0x03 => null,
0x04, 0x05 => @truncate(T, ppu.dispstat.raw >> getHalf(byte_addr)),
0x06, 0x07 => @truncate(T, ppu.vcount.raw >> getHalf(byte_addr)),
0x08, 0x09 => @truncate(T, ppu.bg[0].bg0Cnt() >> getHalf(byte_addr)),
0x0A, 0x0B => @truncate(T, ppu.bg[1].bg1Cnt() >> getHalf(byte_addr)),
0x0C, 0x0D => @truncate(T, ppu.bg[2].cnt.raw >> getHalf(byte_addr)),
0x0E, 0x0F => @truncate(T, ppu.bg[3].cnt.raw >> getHalf(byte_addr)),
0x04, 0x05 => @as(T, @truncate(ppu.dispstat.raw >> getHalf(byte_addr))),
0x06, 0x07 => @as(T, @truncate(ppu.vcount.raw >> getHalf(byte_addr))),
0x08, 0x09 => @as(T, @truncate(ppu.bg[0].bg0Cnt() >> getHalf(byte_addr))),
0x0A, 0x0B => @as(T, @truncate(ppu.bg[1].bg1Cnt() >> getHalf(byte_addr))),
0x0C, 0x0D => @as(T, @truncate(ppu.bg[2].cnt.raw >> getHalf(byte_addr))),
0x0E, 0x0F => @as(T, @truncate(ppu.bg[3].cnt.raw >> getHalf(byte_addr))),
0x10...0x1F => null, // BGXHOFS/VOFS
0x20...0x2F => null, // BG2 Rot/Scaling
0x30...0x3F => null, // BG3 Rot/Scaling
0x40...0x47 => null, // WINXH/V Registers
0x48, 0x49 => @truncate(T, ppu.win.getIn() >> getHalf(byte_addr)),
0x4A, 0x4B => @truncate(T, ppu.win.getOut() >> getHalf(byte_addr)),
0x48, 0x49 => @as(T, @truncate(ppu.win.getIn() >> getHalf(byte_addr))),
0x4A, 0x4B => @as(T, @truncate(ppu.win.getOut() >> getHalf(byte_addr))),
0x4C, 0x4D => null, // MOSAIC
0x4E, 0x4F => null,
0x50, 0x51 => @truncate(T, ppu.bld.getCnt() >> getHalf(byte_addr)),
0x52, 0x53 => @truncate(T, ppu.bld.getAlpha() >> getHalf(byte_addr)),
0x50, 0x51 => @as(T, @truncate(ppu.bld.getCnt() >> getHalf(byte_addr))),
0x52, 0x53 => @as(T, @truncate(ppu.bld.getAlpha() >> getHalf(byte_addr))),
0x54, 0x55 => null, // BLDY
else => util.io.read.err(T, log, "unexpected {} read from 0x{X:0>8}", .{ T, addr }),
},
@ -95,14 +95,14 @@ pub fn read(comptime T: type, ppu: *const Ppu, addr: u32) ?T {
}
pub fn write(comptime T: type, ppu: *Ppu, addr: u32, value: T) void {
const byte_addr = @truncate(u8, addr); // prefixed with 0x0400_00
const byte_addr = @as(u8, @truncate(addr)); // prefixed with 0x0400_00
switch (T) {
u32 => switch (byte_addr) {
0x00 => ppu.dispcnt.raw = @truncate(u16, value),
0x00 => ppu.dispcnt.raw = @as(u16, @truncate(value)),
0x04 => {
ppu.dispstat.set(@truncate(u16, value));
ppu.vcount.raw = @truncate(u16, value >> 16);
ppu.dispstat.set(@as(u16, @truncate(value)));
ppu.vcount.raw = @as(u16, @truncate(value >> 16));
},
0x08 => ppu.setAdjCnts(0, value),
0x0C => ppu.setAdjCnts(2, value),
@ -128,10 +128,10 @@ pub fn write(comptime T: type, ppu: *Ppu, addr: u32, value: T) void {
0x4C => log.debug("Wrote 0x{X:0>8} to MOSAIC", .{value}),
0x50 => {
ppu.bld.cnt.raw = @truncate(u16, value);
ppu.bld.alpha.raw = @truncate(u16, value >> 16);
ppu.bld.cnt.raw = @as(u16, @truncate(value));
ppu.bld.alpha.raw = @as(u16, @truncate(value >> 16));
},
0x54 => ppu.bld.y.raw = @truncate(u16, value),
0x54 => ppu.bld.y.raw = @as(u16, @truncate(value)),
else => util.io.write.undef(log, "Tried to write 0x{X:0>8}{} to 0x{X:0>8}", .{ value, T, addr }),
},
u16 => switch (byte_addr) {
@ -154,19 +154,19 @@ pub fn write(comptime T: type, ppu: *Ppu, addr: u32, value: T) void {
0x1C => ppu.bg[3].hofs.raw = value,
0x1E => ppu.bg[3].vofs.raw = value,
0x20 => ppu.aff_bg[0].pa = @bitCast(i16, value),
0x22 => ppu.aff_bg[0].pb = @bitCast(i16, value),
0x24 => ppu.aff_bg[0].pc = @bitCast(i16, value),
0x26 => ppu.aff_bg[0].pd = @bitCast(i16, value),
0x28, 0x2A => ppu.aff_bg[0].x = @bitCast(i32, setHalf(u32, @bitCast(u32, ppu.aff_bg[0].x), byte_addr, value)),
0x2C, 0x2E => ppu.aff_bg[0].y = @bitCast(i32, setHalf(u32, @bitCast(u32, ppu.aff_bg[0].y), byte_addr, value)),
0x20 => ppu.aff_bg[0].pa = @as(i16, @bitCast(value)),
0x22 => ppu.aff_bg[0].pb = @as(i16, @bitCast(value)),
0x24 => ppu.aff_bg[0].pc = @as(i16, @bitCast(value)),
0x26 => ppu.aff_bg[0].pd = @as(i16, @bitCast(value)),
0x28, 0x2A => ppu.aff_bg[0].x = @as(i32, @bitCast(setHalf(u32, @as(u32, @bitCast(ppu.aff_bg[0].x)), byte_addr, value))),
0x2C, 0x2E => ppu.aff_bg[0].y = @as(i32, @bitCast(setHalf(u32, @as(u32, @bitCast(ppu.aff_bg[0].y)), byte_addr, value))),
0x30 => ppu.aff_bg[1].pa = @bitCast(i16, value),
0x32 => ppu.aff_bg[1].pb = @bitCast(i16, value),
0x34 => ppu.aff_bg[1].pc = @bitCast(i16, value),
0x36 => ppu.aff_bg[1].pd = @bitCast(i16, value),
0x38, 0x3A => ppu.aff_bg[1].x = @bitCast(i32, setHalf(u32, @bitCast(u32, ppu.aff_bg[1].x), byte_addr, value)),
0x3C, 0x3E => ppu.aff_bg[1].y = @bitCast(i32, setHalf(u32, @bitCast(u32, ppu.aff_bg[1].y), byte_addr, value)),
0x30 => ppu.aff_bg[1].pa = @as(i16, @bitCast(value)),
0x32 => ppu.aff_bg[1].pb = @as(i16, @bitCast(value)),
0x34 => ppu.aff_bg[1].pc = @as(i16, @bitCast(value)),
0x36 => ppu.aff_bg[1].pd = @as(i16, @bitCast(value)),
0x38, 0x3A => ppu.aff_bg[1].x = @as(i32, @bitCast(setHalf(u32, @as(u32, @bitCast(ppu.aff_bg[1].x)), byte_addr, value))),
0x3C, 0x3E => ppu.aff_bg[1].y = @as(i32, @bitCast(setHalf(u32, @as(u32, @bitCast(ppu.aff_bg[1].y)), byte_addr, value))),
0x40 => ppu.win.h[0].raw = value,
0x42 => ppu.win.h[1].raw = value,
@ -205,20 +205,20 @@ pub fn write(comptime T: type, ppu: *Ppu, addr: u32, value: T) void {
0x1E, 0x1F => ppu.bg[3].vofs.raw = setHalf(u16, ppu.bg[3].vofs.raw, byte_addr, value),
// BG2 Rot/Scaling
0x20, 0x21 => ppu.aff_bg[0].pa = @bitCast(i16, setHalf(u16, @bitCast(u16, ppu.aff_bg[0].pa), byte_addr, value)),
0x22, 0x23 => ppu.aff_bg[0].pb = @bitCast(i16, setHalf(u16, @bitCast(u16, ppu.aff_bg[0].pb), byte_addr, value)),
0x24, 0x25 => ppu.aff_bg[0].pc = @bitCast(i16, setHalf(u16, @bitCast(u16, ppu.aff_bg[0].pc), byte_addr, value)),
0x26, 0x27 => ppu.aff_bg[0].pd = @bitCast(i16, setHalf(u16, @bitCast(u16, ppu.aff_bg[0].pd), byte_addr, value)),
0x28, 0x29, 0x2A, 0x2B => ppu.aff_bg[0].x = @bitCast(i32, setQuart(@bitCast(u32, ppu.aff_bg[0].x), byte_addr, value)),
0x2C, 0x2D, 0x2E, 0x2F => ppu.aff_bg[0].y = @bitCast(i32, setQuart(@bitCast(u32, ppu.aff_bg[0].y), byte_addr, value)),
0x20, 0x21 => ppu.aff_bg[0].pa = @as(i16, @bitCast(setHalf(u16, @as(u16, @bitCast(ppu.aff_bg[0].pa)), byte_addr, value))),
0x22, 0x23 => ppu.aff_bg[0].pb = @as(i16, @bitCast(setHalf(u16, @as(u16, @bitCast(ppu.aff_bg[0].pb)), byte_addr, value))),
0x24, 0x25 => ppu.aff_bg[0].pc = @as(i16, @bitCast(setHalf(u16, @as(u16, @bitCast(ppu.aff_bg[0].pc)), byte_addr, value))),
0x26, 0x27 => ppu.aff_bg[0].pd = @as(i16, @bitCast(setHalf(u16, @as(u16, @bitCast(ppu.aff_bg[0].pd)), byte_addr, value))),
0x28, 0x29, 0x2A, 0x2B => ppu.aff_bg[0].x = @as(i32, @bitCast(setQuart(@as(u32, @bitCast(ppu.aff_bg[0].x)), byte_addr, value))),
0x2C, 0x2D, 0x2E, 0x2F => ppu.aff_bg[0].y = @as(i32, @bitCast(setQuart(@as(u32, @bitCast(ppu.aff_bg[0].y)), byte_addr, value))),
// BG3 Rot/Scaling
0x30, 0x31 => ppu.aff_bg[1].pa = @bitCast(i16, setHalf(u16, @bitCast(u16, ppu.aff_bg[1].pa), byte_addr, value)),
0x32, 0x33 => ppu.aff_bg[1].pb = @bitCast(i16, setHalf(u16, @bitCast(u16, ppu.aff_bg[1].pb), byte_addr, value)),
0x34, 0x35 => ppu.aff_bg[1].pc = @bitCast(i16, setHalf(u16, @bitCast(u16, ppu.aff_bg[1].pc), byte_addr, value)),
0x36, 0x37 => ppu.aff_bg[1].pd = @bitCast(i16, setHalf(u16, @bitCast(u16, ppu.aff_bg[1].pd), byte_addr, value)),
0x38, 0x39, 0x3A, 0x3B => ppu.aff_bg[1].x = @bitCast(i32, setQuart(@bitCast(u32, ppu.aff_bg[1].x), byte_addr, value)),
0x3C, 0x3D, 0x3E, 0x3F => ppu.aff_bg[1].y = @bitCast(i32, setQuart(@bitCast(u32, ppu.aff_bg[1].y), byte_addr, value)),
0x30, 0x31 => ppu.aff_bg[1].pa = @as(i16, @bitCast(setHalf(u16, @as(u16, @bitCast(ppu.aff_bg[1].pa)), byte_addr, value))),
0x32, 0x33 => ppu.aff_bg[1].pb = @as(i16, @bitCast(setHalf(u16, @as(u16, @bitCast(ppu.aff_bg[1].pb)), byte_addr, value))),
0x34, 0x35 => ppu.aff_bg[1].pc = @as(i16, @bitCast(setHalf(u16, @as(u16, @bitCast(ppu.aff_bg[1].pc)), byte_addr, value))),
0x36, 0x37 => ppu.aff_bg[1].pd = @as(i16, @bitCast(setHalf(u16, @as(u16, @bitCast(ppu.aff_bg[1].pd)), byte_addr, value))),
0x38, 0x39, 0x3A, 0x3B => ppu.aff_bg[1].x = @as(i32, @bitCast(setQuart(@as(u32, @bitCast(ppu.aff_bg[1].x)), byte_addr, value))),
0x3C, 0x3D, 0x3E, 0x3F => ppu.aff_bg[1].y = @as(i32, @bitCast(setQuart(@as(u32, @bitCast(ppu.aff_bg[1].y)), byte_addr, value))),
// Window
0x40, 0x41 => ppu.win.h[0].raw = setHalf(u16, ppu.win.h[0].raw, byte_addr, value),
@ -324,13 +324,13 @@ pub const Ppu = struct {
}
pub fn setBgOffsets(self: *Self, comptime n: u2, word: u32) void {
self.bg[n].hofs.raw = @truncate(u16, word);
self.bg[n].vofs.raw = @truncate(u16, word >> 16);
self.bg[n].hofs.raw = @as(u16, @truncate(word));
self.bg[n].vofs.raw = @as(u16, @truncate(word >> 16));
}
pub fn setAdjCnts(self: *Self, comptime n: u2, word: u32) void {
self.bg[n].cnt.raw = @truncate(u16, word);
self.bg[n + 1].cnt.raw = @truncate(u16, word >> 16);
self.bg[n].cnt.raw = @as(u16, @truncate(word));
self.bg[n + 1].cnt.raw = @as(u16, @truncate(word >> 16));
}
/// Search OAM for Sprites that might be rendered on this scanline
@ -341,11 +341,11 @@ pub const Ppu = struct {
search: while (i < self.oam.buf.len) : (i += 8) {
// Attributes in OAM are 6 bytes long, with 2 bytes of padding
// Grab Attributes from OAM
const attr0 = @bitCast(Attr0, self.oam.read(u16, i));
const attr0 = @as(Attr0, @bitCast(self.oam.read(u16, i)));
// Only consider enabled Sprites
if (attr0.is_affine.read() or !attr0.disabled.read()) {
const attr1 = @bitCast(Attr1, self.oam.read(u16, i + 2));
const attr1 = @as(Attr1, @bitCast(self.oam.read(u16, i + 2)));
const d = spriteDimensions(attr0.shape.read(), attr1.size.read());
// Account for double-size affine sprites
@ -368,7 +368,7 @@ pub const Ppu = struct {
if (y_pos <= y and y < (y_pos + sprite_height)) {
for (self.scanline_sprites) |*maybe_sprite| {
if (maybe_sprite.* == null) {
maybe_sprite.* = Sprite.init(attr0, attr1, @bitCast(Attr2, self.oam.read(u16, i + 4)));
maybe_sprite.* = Sprite.init(attr0, attr1, @as(Attr2, @bitCast(self.oam.read(u16, i + 4))));
continue :search;
}
}
@ -414,7 +414,7 @@ pub const Ppu = struct {
const pc = self.oam.read(u16, base + 11 * @sizeOf(u16));
const pd = self.oam.read(u16, base + 15 * @sizeOf(u16));
const matrix = @bitCast([4]i16, [_]u16{ pa, pb, pc, pd });
const matrix = @as([4]i16, @bitCast([_]u16{ pa, pb, pc, pd }));
const sprite_width = sprite.width << if (double_size) 1 else 0;
const sprite_height = sprite.height << if (double_size) 1 else 0;
@ -425,7 +425,7 @@ pub const Ppu = struct {
var i: u9 = 0;
while (i < sprite_width) : (i += 1) {
// TODO: Something is wrong here
const x = @truncate(u9, @bitCast(u16, sprite_x + i));
const x = @as(u9, @truncate(@as(u16, @bitCast(sprite_x + i))));
if (x >= width) continue;
if (!shouldDrawSprite(self.bld.cnt, &self.scanline, x)) continue;
@ -447,11 +447,11 @@ pub const Ppu = struct {
// Maybe this is the necessary check?
if (rot_x >= sprite.width or rot_y >= sprite.height or rot_x < 0 or rot_y < 0) continue;
const tile_x = @bitCast(u16, rot_x);
const tile_y = @bitCast(u16, rot_y);
const tile_x = @as(u16, @bitCast(rot_x));
const tile_y = @as(u16, @bitCast(rot_y));
const col = @truncate(u3, tile_x);
const row = @truncate(u3, tile_y);
const col = @as(u3, @truncate(tile_x));
const row = @as(u3, @truncate(tile_y));
// TODO: Finish that 2D Sprites Test ROM
const tile_base = char_base + (tile_id * 0x20) + (row * tile_row_offset) + if (is_8bpp) col else col >> 1;
@ -461,12 +461,12 @@ pub const Ppu = struct {
const tile = self.vram.buf[tile_base + tile_offset];
const pal_id: u16 = if (!is_8bpp) get4bppTilePalette(sprite.palBank(), col, tile) else tile;
const global_x = @truncate(u9, @bitCast(u16, local_x + sprite_x));
const global_x = @as(u9, @truncate(@as(u16, @bitCast(local_x + sprite_x))));
// Sprite Palette starts at 0x0500_0200
if (pal_id != 0) {
const bgr555 = self.palette.read(u16, 0x200 + pal_id * 2);
drawSpritePixel(self.bld.cnt, &self.scanline, @bitCast(Attr0, sprite.attr0), global_x, bgr555);
drawSpritePixel(self.bld.cnt, &self.scanline, @as(Attr0, @bitCast(sprite.attr0)), global_x, bgr555);
}
}
}
@ -490,7 +490,7 @@ pub const Ppu = struct {
var i: u9 = 0;
while (i < sprite.width) : (i += 1) {
// TODO: Something is Wrong Here
const x = @truncate(u9, @bitCast(u16, sprite_x + i));
const x = @as(u9, @truncate(@as(u16, @bitCast(sprite_x + i))));
if (x >= width) continue;
if (!shouldDrawSprite(self.bld.cnt, &self.scanline, x)) continue;
@ -504,11 +504,11 @@ pub const Ppu = struct {
// Note that we flip the tile_pos not the (tile_pos % 8) like we do for
// Background Tiles. By doing this we mirror the entire sprite instead of
// just a specific tile (see how sprite.width and sprite.height are involved)
const tile_x = @intCast(u9, local_x) ^ if (sprite.hFlip()) (sprite.width - 1) else 0;
const tile_y = @intCast(u8, local_y) ^ if (sprite.vFlip()) (sprite.height - 1) else 0;
const tile_x = @as(u9, @intCast(local_x)) ^ if (sprite.hFlip()) (sprite.width - 1) else 0;
const tile_y = @as(u8, @intCast(local_y)) ^ if (sprite.vFlip()) (sprite.height - 1) else 0;
const col = @truncate(u3, tile_x);
const row = @truncate(u3, tile_y);
const col = @as(u3, @truncate(tile_x));
const row = @as(u3, @truncate(tile_y));
// TODO: Finish that 2D Sprites Test ROM
const tile_base = char_base + (tile_id * 0x20) + (row * tile_row_offset) + if (is_8bpp) col else col >> 1;
@ -518,7 +518,7 @@ pub const Ppu = struct {
const tile = self.vram.buf[tile_base + tile_offset];
const pal_id: u16 = if (!is_8bpp) get4bppTilePalette(sprite.palBank(), col, tile) else tile;
const global_x = @truncate(u9, @bitCast(u16, local_x + sprite_x));
const global_x = @as(u9, @truncate(@as(u16, @bitCast(local_x + sprite_x))));
// Sprite Palette starts at 0x0500_0200
if (pal_id != 0) {
@ -550,8 +550,8 @@ pub const Ppu = struct {
aff_x += self.aff_bg[n - 2].pa;
aff_y += self.aff_bg[n - 2].pc;
const _x = @truncate(u9, @bitCast(u32, ix));
const _y = @truncate(u8, @bitCast(u32, iy));
const _x = @as(u9, @truncate(@as(u32, @bitCast(ix))));
const _y = @as(u8, @truncate(@as(u32, @bitCast(iy))));
const win_bounds = self.windowBounds(_x, _y);
if (!shouldDrawBackground(self, n, win_bounds, i)) continue;
@ -561,10 +561,10 @@ pub const Ppu = struct {
iy = if (iy > px_height) @rem(iy, px_height) else if (iy < 0) px_height + @rem(iy, px_height) else iy;
} else if (ix > px_width or iy > px_height or ix < 0 or iy < 0) continue;
const x = @bitCast(u32, ix);
const y = @bitCast(u32, iy);
const x = @as(u32, @bitCast(ix));
const y = @as(u32, @bitCast(iy));
const tile_id: u32 = self.vram.read(u8, screen_base + ((y / 8) * @bitCast(u32, tile_width) + (x / 8)));
const tile_id: u32 = self.vram.read(u8, screen_base + ((y / 8) * @as(u32, @bitCast(tile_width)) + (x / 8)));
const row = y & 7;
const col = x & 7;
@ -601,12 +601,12 @@ pub const Ppu = struct {
while (i < width) : (i += 1) {
const x = hofs + i;
const win_bounds = self.windowBounds(@truncate(u9, x), @truncate(u8, y));
const win_bounds = self.windowBounds(@as(u9, @truncate(x)), @as(u8, @truncate(y)));
if (!shouldDrawBackground(self, n, win_bounds, i)) continue;
// Grab the Screen Entry from VRAM
const entry_addr = screen_base + tilemapOffset(size, x, y);
const entry = @bitCast(ScreenEntry, self.vram.read(u16, entry_addr));
const entry = @as(ScreenEntry, @bitCast(self.vram.read(u16, entry_addr)));
// Calculate the Address of the Tile in the designated Charblock
// We also take this opportunity to flip tiles if necessary
@ -615,8 +615,8 @@ pub const Ppu = struct {
// Calculate row and column offsets. Understand that
// `tile_len`, `tile_row_offset` and `col` are subject to different
// values depending on whether we are in 4bpp or 8bpp mode.
const row = @truncate(u3, y) ^ if (entry.v_flip.read()) 7 else @as(u3, 0);
const col = @truncate(u3, x) ^ if (entry.h_flip.read()) 7 else @as(u3, 0);
const row = @as(u3, @truncate(y)) ^ if (entry.v_flip.read()) 7 else @as(u3, 0);
const col = @as(u3, @truncate(x)) ^ if (entry.h_flip.read()) 7 else @as(u3, 0);
const tile_addr = char_base + (tile_id * tile_len) + (row * tile_row_offset) + if (is_8bpp) col else col >> 1;
const tile = self.vram.buf[tile_addr];
@ -649,7 +649,7 @@ pub const Ppu = struct {
if (obj_enable) self.fetchSprites();
for (0..4) |layer| {
self.drawSprites(@truncate(u2, layer));
self.drawSprites(@as(u2, @truncate(layer)));
if (layer == self.bg[0].cnt.priority.read() and bg_enable & 1 == 1) self.drawBackground(0);
if (layer == self.bg[1].cnt.priority.read() and bg_enable >> 1 & 1 == 1) self.drawBackground(1);
if (layer == self.bg[2].cnt.priority.read() and bg_enable >> 2 & 1 == 1) self.drawBackground(2);
@ -663,7 +663,7 @@ pub const Ppu = struct {
if (obj_enable) self.fetchSprites();
for (0..4) |layer| {
self.drawSprites(@truncate(u2, layer));
self.drawSprites(@as(u2, @truncate(layer)));
if (layer == self.bg[0].cnt.priority.read() and bg_enable & 1 == 1) self.drawBackground(0);
if (layer == self.bg[1].cnt.priority.read() and bg_enable >> 1 & 1 == 1) self.drawBackground(1);
if (layer == self.bg[2].cnt.priority.read() and bg_enable >> 2 & 1 == 1) self.drawAffineBackground(2);
@ -676,7 +676,7 @@ pub const Ppu = struct {
if (obj_enable) self.fetchSprites();
for (0..4) |layer| {
self.drawSprites(@truncate(u2, layer));
self.drawSprites(@as(u2, @truncate(layer)));
if (layer == self.bg[2].cnt.priority.read() and bg_enable >> 2 & 1 == 1) self.drawAffineBackground(2);
if (layer == self.bg[3].cnt.priority.read() and bg_enable >> 3 & 1 == 1) self.drawAffineBackground(3);
}
@ -688,8 +688,8 @@ pub const Ppu = struct {
const framebuf_base = width * @as(usize, scanline);
// FIXME: @ptrCast between slices changing the length isn't implemented yet
const vram_buf = @ptrCast([*]const u16, @alignCast(@alignOf(u16), self.vram.buf));
const framebuf = @ptrCast([*]u32, @alignCast(@alignOf(u32), self.framebuf.get(.Emulator)));
const vram_buf: [*]const u16 = @ptrCast(@alignCast(self.vram.buf));
const framebuf: [*]u32 = @ptrCast(@alignCast(self.framebuf.get(.Emulator)));
for (vram_buf[vram_base .. vram_base + width], 0..) |bgr555, i| {
framebuf[framebuf_base + i] = rgba888(bgr555);
@ -702,8 +702,8 @@ pub const Ppu = struct {
const framebuf_base = width * @as(usize, scanline);
// FIXME: @ptrCast between slices changing the length isn't implemented yet
const pal_buf = @ptrCast([*]const u16, @alignCast(@alignOf(u16), self.palette.buf));
const framebuf = @ptrCast([*]u32, @alignCast(@alignOf(u32), self.framebuf.get(.Emulator)));
const pal_buf: [*]const u16 = @ptrCast(@alignCast(self.palette.buf));
const framebuf: [*]u32 = @ptrCast(@alignCast(self.framebuf.get(.Emulator)));
for (self.vram.buf[vram_base .. vram_base + width], 0..) |pal_id, i| {
framebuf[framebuf_base + i] = rgba888(pal_buf[pal_id]);
@ -718,8 +718,8 @@ pub const Ppu = struct {
const framebuf_base = width * @as(usize, scanline);
// FIXME: @ptrCast between slices changing the length isn't implemented yet
const vram_buf = @ptrCast([*]const u16, @alignCast(@alignOf(u16), self.vram.buf));
const framebuf = @ptrCast([*]u32, @alignCast(@alignOf(u32), self.framebuf.get(.Emulator)));
const vram_buf: [*]const u16 = @ptrCast(@alignCast(self.vram.buf));
const framebuf: [*]u32 = @ptrCast(@alignCast(self.framebuf.get(.Emulator)));
for (0..width) |i| {
const bgr555 = if (scanline < m5_height and i < m5_width) vram_buf[vram_base + i] else self.palette.backdrop();
@ -735,7 +735,7 @@ pub const Ppu = struct {
// If there are any nulls present in self.scanline.top() it means that no background drew a pixel there, so draw backdrop
// FIXME: @ptrCast between slices changing the length isn't implemented yet
const framebuf = @ptrCast([*]u32, @alignCast(@alignOf(u32), self.framebuf.get(.Emulator)));
const framebuf: [*]u32 = @ptrCast(@alignCast(self.framebuf.get(.Emulator)));
for (self.scanline.top(), 0..) |maybe_top, i| {
const maybe_btm = self.scanline.btm()[i];
@ -1003,7 +1003,7 @@ pub const Ppu = struct {
}
pub fn onHdrawEnd(self: *Self, cpu: *Arm7tdmi, late: u64) void {
const bus_ptr = @ptrCast(*Bus, @alignCast(@alignOf(Bus), cpu.bus.ptr));
const bus_ptr: *Bus = @ptrCast(@alignCast(cpu.bus.ptr));
// Transitioning to a Hblank
if (self.dispstat.hblank_irq.read()) {
@ -1020,7 +1020,7 @@ pub const Ppu = struct {
}
pub fn onHblankEnd(self: *Self, cpu: *Arm7tdmi, late: u64) void {
const bus_ptr = @ptrCast(*Bus, @alignCast(@alignOf(Bus), cpu.bus.ptr));
const bus_ptr: *Bus = @ptrCast(@alignCast(cpu.bus.ptr));
// The End of a Hblank (During Draw or Vblank)
const old_scanline = self.vcount.scanline.read();
@ -1148,18 +1148,18 @@ const Window = struct {
}
pub fn setH(self: *Self, value: u32) void {
self.h[0].raw = @truncate(u16, value);
self.h[1].raw = @truncate(u16, value >> 16);
self.h[0].raw = @as(u16, @truncate(value));
self.h[1].raw = @as(u16, @truncate(value >> 16));
}
pub fn setV(self: *Self, value: u32) void {
self.v[0].raw = @truncate(u16, value);
self.v[1].raw = @truncate(u16, value >> 16);
self.v[0].raw = @as(u16, @truncate(value));
self.v[1].raw = @as(u16, @truncate(value >> 16));
}
pub fn setIo(self: *Self, value: u32) void {
self.in.raw = @truncate(u16, value);
self.out.raw = @truncate(u16, value >> 16);
self.in.raw = @as(u16, @truncate(value));
self.out.raw = @as(u16, @truncate(value >> 16));
}
};
@ -1222,23 +1222,23 @@ const AffineBackground = struct {
}
pub fn setX(self: *Self, is_vblank: bool, value: u32) void {
self.x = @bitCast(i32, value);
if (!is_vblank) self.x_latch = @bitCast(i32, value);
self.x = @as(i32, @bitCast(value));
if (!is_vblank) self.x_latch = @as(i32, @bitCast(value));
}
pub fn setY(self: *Self, is_vblank: bool, value: u32) void {
self.y = @bitCast(i32, value);
if (!is_vblank) self.y_latch = @bitCast(i32, value);
self.y = @as(i32, @bitCast(value));
if (!is_vblank) self.y_latch = @as(i32, @bitCast(value));
}
pub fn writePaPb(self: *Self, value: u32) void {
self.pa = @bitCast(i16, @truncate(u16, value));
self.pb = @bitCast(i16, @truncate(u16, value >> 16));
self.pa = @as(i16, @bitCast(@as(u16, @truncate(value))));
self.pb = @as(i16, @bitCast(@as(u16, @truncate(value >> 16))));
}
pub fn writePcPd(self: *Self, value: u32) void {
self.pc = @bitCast(i16, @truncate(u16, value));
self.pd = @bitCast(i16, @truncate(u16, value >> 16));
self.pc = @as(i16, @bitCast(@as(u16, @truncate(value))));
self.pd = @as(i16, @bitCast(@as(u16, @truncate(value >> 16))));
}
// Every Vblank BG?X/Y registers are latched
@ -1447,9 +1447,9 @@ fn alphaBlend(top: u16, btm: u16, bldalpha: io.BldAlpha) u16 {
const btm_g = (btm >> 5) & 0x1F;
const btm_b = (btm >> 10) & 0x1F;
const bld_r = std.math.min(31, (top_r * eva + btm_r * evb) >> 4);
const bld_g = std.math.min(31, (top_g * eva + btm_g * evb) >> 4);
const bld_b = std.math.min(31, (top_b * eva + btm_b * evb) >> 4);
const bld_r: u16 = @min(31, (top_r * eva + btm_r * evb) >> 4);
const bld_g: u16 = @min(31, (top_g * eva + btm_g * evb) >> 4);
const bld_b: u16 = @min(31, (top_b * eva + btm_b * evb) >> 4);
return (bld_b << 10) | (bld_g << 5) | bld_r;
}

4
src/core/scheduler.zig
View File

@ -46,7 +46,7 @@ pub const Scheduler = struct {
const event = self.queue.remove();
const late = self.tick - event.tick;
const bus_ptr = @ptrCast(*Bus, @alignCast(@alignOf(Bus), cpu.bus.ptr));
const bus_ptr: *Bus = @ptrCast(@alignCast(cpu.bus.ptr));
switch (event.kind) {
.HeatDeath => {
@ -75,7 +75,7 @@ pub const Scheduler = struct {
const device = &bus_ptr.pak.gpio.device;
if (device.kind != .Rtc or device.ptr == null) return;
const clock = @ptrCast(*Clock, @alignCast(@alignOf(*Clock), device.ptr.?));
const clock: *Clock = @ptrCast(@alignCast(device.ptr.?));
clock.onClockUpdate(late);
},
.FrameSequencer => bus_ptr.apu.onSequencerTick(late),

28
src/imgui.zig
View File

@ -72,9 +72,9 @@ pub const State = struct {
pub fn draw(state: *State, win_dim: Dimensions, tex_id: GLuint, cpu: *Arm7tdmi) bool {
const scn_scale = config.config().host.win_scale;
const bus_ptr = @ptrCast(*Bus, @alignCast(@alignOf(Bus), cpu.bus.ptr));
const bus_ptr: *Bus = @ptrCast(@alignCast(cpu.bus.ptr));
zgui.backend.newFrame(@intToFloat(f32, win_dim.width), @intToFloat(f32, win_dim.height));
zgui.backend.newFrame(@as(f32, @floatFromInt(win_dim.width)), @as(f32, @floatFromInt(win_dim.height)));
{
_ = zgui.beginMainMenuBar();
@ -168,14 +168,14 @@ pub fn draw(state: *State, win_dim: Dimensions, tex_id: GLuint, cpu: *Arm7tdmi)
}
{
const w = @intToFloat(f32, gba_width * scn_scale);
const h = @intToFloat(f32, gba_height * scn_scale);
const w = @as(f32, @floatFromInt(gba_width * scn_scale));
const h = @as(f32, @floatFromInt(gba_height * scn_scale));
const window_title = std.mem.sliceTo(&state.title, 0);
_ = zgui.begin(window_title, .{ .flags = .{ .no_resize = true, .always_auto_resize = true } });
defer zgui.end();
zgui.image(@intToPtr(*anyopaque, tex_id), .{ .w = w, .h = h, .uv0 = .{ 0, 1 }, .uv1 = .{ 1, 0 } });
zgui.image(@as(*anyopaque, @ptrFromInt(tex_id)), .{ .w = w, .h = h, .uv0 = .{ 0, 1 }, .uv1 = .{ 1, 0 } });
}
// TODO: Any other steps to respect the copyright of the libraries I use?
@ -272,8 +272,8 @@ pub fn draw(state: *State, win_dim: Dimensions, tex_id: GLuint, cpu: *Arm7tdmi)
break :blk buf;
};
const y_max = 2 * if (len != 0) @intToFloat(f64, sorted[len - 1]) else emu.frame_rate;
const x_max = @intToFloat(f64, values.len);
const y_max = 2 * if (len != 0) @as(f64, @floatFromInt(sorted[len - 1])) else emu.frame_rate;
const x_max = @as(f64, @floatFromInt(values.len));
const y_args = .{ .flags = .{ .no_grid_lines = true } };
const x_args = .{ .flags = .{ .no_grid_lines = true, .no_tick_labels = true, .no_tick_marks = true } };
@ -298,7 +298,7 @@ pub fn draw(state: *State, win_dim: Dimensions, tex_id: GLuint, cpu: *Arm7tdmi)
var sum: u32 = 0;
for (sorted[0..len]) |value| sum += value;
break :average @intCast(u32, sum / len);
break :average @as(u32, @intCast(sum / len));
};
const median = sorted[len / 2];
const low = sorted[len / 100]; // 1% Low
@ -320,7 +320,7 @@ pub fn draw(state: *State, win_dim: Dimensions, tex_id: GLuint, cpu: *Arm7tdmi)
zgui.text("tick: {X:0>16}", .{scheduler.now()});
zgui.separator();
const sched_ptr = @ptrCast(*Scheduler, @alignCast(@alignOf(Scheduler), cpu.sched.ptr));
const sched_ptr: *Scheduler = @ptrCast(@alignCast(cpu.sched.ptr));
const Event = std.meta.Child(@TypeOf(sched_ptr.queue.items));
var items: [20]Event = undefined;
@ -365,7 +365,7 @@ const widgets = struct {
};
for (0..0x100) |i| {
const offset = @truncate(u32, i);
const offset = @as(u32, @truncate(i));
const bgr555 = cpu.bus.dbgRead(u16, address + offset * @sizeOf(u16));
widgets.colourSquare(bgr555);
@ -378,11 +378,11 @@ const widgets = struct {
// FIXME: working with the packed struct enum is currently broken :pensive:
const ImguiColorEditFlags_NoInputs: u32 = 1 << 5;
const ImguiColorEditFlags_NoPicker: u32 = 1 << 2;
const flags = @bitCast(zgui.ColorEditFlags, ImguiColorEditFlags_NoInputs | ImguiColorEditFlags_NoPicker);
const flags = @as(zgui.ColorEditFlags, @bitCast(ImguiColorEditFlags_NoInputs | ImguiColorEditFlags_NoPicker));
const b = @intToFloat(f32, bgr555 >> 10 & 0x1f);
const g = @intToFloat(f32, bgr555 >> 5 & 0x1F);
const r = @intToFloat(f32, bgr555 & 0x1F);
const b = @as(f32, @floatFromInt(bgr555 >> 10 & 0x1f));
const g = @as(f32, @floatFromInt(bgr555 >> 5 & 0x1F));
const r = @as(f32, @floatFromInt(bgr555 & 0x1F));
var col = [_]f32{ r / 31.0, g / 31.0, b / 31.0 };

17
src/platform.zig
View File

@ -61,7 +61,7 @@ pub const Gui = struct {
if (SDL.SDL_GL_MakeCurrent(window, ctx) < 0) panic();
gl.load(ctx, Self.glGetProcAddress) catch {};
if (SDL.SDL_GL_SetSwapInterval(@boolToInt(config.config().host.vsync)) < 0) panic();
if (SDL.SDL_GL_SetSwapInterval(@intFromBool(config.config().host.vsync)) < 0) panic();
zgui.init(allocator);
zgui.plot.init();
@ -108,7 +108,7 @@ pub const Gui = struct {
const tracker = opt.tracker;
const ch = opt.ch;
const bus_ptr = @ptrCast(*Bus, @alignCast(@alignOf(Bus), cpu.bus.ptr));
const bus_ptr: *Bus = @ptrCast(@alignCast(cpu.bus.ptr));
const objects = opengl_impl.createObjects();
defer gl.deleteBuffers(3, @as(*const [3]GLuint, &.{ objects.vao, objects.vbo, objects.ebo }));
@ -183,8 +183,8 @@ pub const Gui = struct {
if (event.window.event == SDL.SDL_WINDOWEVENT_RESIZED) {
log.debug("window resized to: {}x{}", .{ event.window.data1, event.window.data2 });
win_dim.width = @intCast(u32, event.window.data1);
win_dim.height = @intCast(u32, event.window.data2);
win_dim.width = @as(u32, @intCast(event.window.data1));
win_dim.height = @as(u32, @intCast(event.window.data2));
}
},
else => {},
@ -268,7 +268,7 @@ pub const Gui = struct {
if (zgui_redraw) {
// Background Colour
const size = zgui.io.getDisplaySize();
gl.viewport(0, 0, @floatToInt(GLsizei, size[0]), @floatToInt(GLsizei, size[1]));
gl.viewport(0, 0, @as(GLsizei, @intFromFloat(size[0])), @as(GLsizei, @intFromFloat(size[1])));
gl.clearColor(0, 0, 0, 1.0);
gl.clear(gl.COLOR_BUFFER_BIT);
@ -318,8 +318,7 @@ const Audio = struct {
}
export fn callback(userdata: ?*anyopaque, stream: [*c]u8, len: c_int) void {
const T = *Apu;
const apu = @ptrCast(T, @alignCast(@alignOf(T), userdata));
const apu: *Apu = @ptrCast(@alignCast(userdata));
_ = SDL.SDL_AudioStreamGet(apu.stream, stream, len);
}
@ -422,10 +421,10 @@ const opengl_impl = struct {
gl.vertexAttribPointer(0, 3, gl.FLOAT, gl.FALSE, 8 * @sizeOf(f32), null); // lmao
gl.enableVertexAttribArray(0);
// Colour
gl.vertexAttribPointer(1, 3, gl.FLOAT, gl.FALSE, 8 * @sizeOf(f32), @intToPtr(?*anyopaque, (3 * @sizeOf(f32))));
gl.vertexAttribPointer(1, 3, gl.FLOAT, gl.FALSE, 8 * @sizeOf(f32), @as(?*anyopaque, @ptrFromInt((3 * @sizeOf(f32)))));
gl.enableVertexAttribArray(1);
// Texture Coord
gl.vertexAttribPointer(2, 2, gl.FLOAT, gl.FALSE, 8 * @sizeOf(f32), @intToPtr(?*anyopaque, (6 * @sizeOf(f32))));
gl.vertexAttribPointer(2, 2, gl.FLOAT, gl.FALSE, 8 * @sizeOf(f32), @as(?*anyopaque, @ptrFromInt((6 * @sizeOf(f32)))));
gl.enableVertexAttribArray(2);
return .{ .vao = vao_id, .vbo = vbo_id, .ebo = ebo_id };

6
src/util.zig
View File

@ -203,7 +203,7 @@ pub const audio = struct {
/// Sets a quarter (8) of the bits of the u32 `left` to the value of u8 `right`
pub inline fn setQuart(left: u32, addr: u8, right: u8) u32 {
const offset = @truncate(u2, addr);
const offset = @as(u2, @truncate(addr));
return switch (offset) {
0b00 => (left & 0xFFFF_FF00) | right,
@ -217,11 +217,11 @@ pub inline fn setQuart(left: u32, addr: u8, right: u8) u32 {
///
/// TODO: Support u16 reads of u32 values?
pub inline fn getHalf(byte: u8) u4 {
return @truncate(u4, byte & 1) << 3;
return @as(u4, @truncate(byte & 1)) << 3;
}
pub inline fn setHalf(comptime T: type, left: T, addr: u8, right: HalfInt(T)) T {
const offset = @truncate(u1, addr >> if (T == u32) 1 else 0);
const offset = @as(u1, @truncate(addr >> if (T == u32) 1 else 0));
return switch (T) {
u32 => switch (offset) {