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

chore: simply some zig fmt builtin changes

This commit is contained in:
Rekai Nyangadzayi Musuka 2023-07-17 01:07:18 -05:00
parent d96c9c01ff
commit d4b7167e29
22 changed files with 587 additions and 589 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
lib/bitfield.zig
View File

@ -26,7 +26,7 @@ fn BitType(comptime FieldType: type, comptime ValueType: type, comptime shamt: u
}
pub fn read(self: anytype) ValueType {
return @as(ValueType, @bitCast(@as(u1, @truncate(self.bits.field().* >> shamt))));
return @bitCast(@as(u1, @truncate(self.bits.field().* >> shamt)));
}
// Since these are mostly used with MMIO, I want to avoid
@ -67,7 +67,7 @@ pub fn Bitfield(comptime FieldType: type, comptime shamt: usize, comptime num_bi
dummy: FieldType,
fn field(self: anytype) PtrCastPreserveCV(@This(), @TypeOf(self), FieldType) {
return @as(PtrCastPreserveCV(@This(), @TypeOf(self), FieldType), @ptrCast(self));
return @ptrCast(self);
}
pub fn write(self: anytype, val: ValueType) void {
@ -77,7 +77,7 @@ pub fn Bitfield(comptime FieldType: type, comptime shamt: usize, comptime num_bi
pub fn read(self: anytype) ValueType {
const val: FieldType = self.field().*;
return @as(ValueType, @intCast((val & self_mask) >> shamt));
return @intCast((val & self_mask) >> shamt);
}
};
}

688
lib/gl.zig
View File

File diff suppressed because it is too large Load Diff

18
src/core/Bus.zig
View File

@ -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 = @as(u32, @intCast(page_size * i));
const addr: 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 = @as(u32, @intCast(page_size * i));
const addr: u32 = @intCast(page_size * i);
ptr.* = switch (addr) {
// General Internal Memory
@ -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 = @as(u8, @truncate(r15 >> 24));
const page: u8 = @truncate(r15 >> 24);
// PC + 2 = stage[0]
// PC + 4 = stage[1]
@ -301,7 +301,7 @@ fn openBus(self: *const Self, comptime T: type, address: u32) T {
}
};
return @as(T, @truncate(word));
return @truncate(word);
}
pub fn read(self: *Self, comptime T: type, unaligned_address: u32) T {
@ -350,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 = @as(u8, @truncate(unaligned_address >> 24));
const page: u8 = @truncate(unaligned_address >> 24);
const address = forceAlign(T, unaligned_address);
return switch (page) {
@ -378,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 = @as(u8, @truncate(unaligned_address >> 24));
const page: u8 = @truncate(unaligned_address >> 24);
const address = forceAlign(T, unaligned_address);
return switch (page) {
@ -471,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 = @as(u8, @truncate(unaligned_address >> 24));
const page: u8 = @truncate(unaligned_address >> 24);
const address = forceAlign(T, unaligned_address);
switch (page) {
@ -488,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, @as(u8, @truncate(rotr(T, value, 8 * rotateBy(T, unaligned_address))))),
0x0E...0x0F => self.pak.backup.write(unaligned_address, @truncate(rotr(T, value, 8 * rotateBy(T, unaligned_address)))),
else => {},
}
}
@ -496,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 = @as(u8, @truncate(unaligned_address >> 24));
const page: u8 = @truncate(unaligned_address >> 24);
const address = forceAlign(T, unaligned_address);
switch (page) {

64
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 = @as(u8, @truncate(addr));
const byte_addr: 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 => @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))),
0x60, 0x61 => @truncate(@as(u16, apu.ch1.sound1CntL()) >> getHalf(byte_addr)),
0x62, 0x63 => @truncate(apu.ch1.sound1CntH() >> getHalf(byte_addr)),
0x64, 0x65 => @truncate(apu.ch1.sound1CntX() >> getHalf(byte_addr)),
0x66, 0x67 => 0x00, // assuming behaviour is identical to that of 16-bit reads
0x68, 0x69 => @as(T, @truncate(apu.ch2.sound2CntL() >> getHalf(byte_addr))),
0x68, 0x69 => @truncate(apu.ch2.sound2CntL() >> getHalf(byte_addr)),
0x6A, 0x6B => 0x00,
0x6C, 0x6D => @as(T, @truncate(apu.ch2.sound2CntH() >> getHalf(byte_addr))),
0x6C, 0x6D => @truncate(apu.ch2.sound2CntH() >> getHalf(byte_addr)),
0x6E, 0x6F => 0x00,
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
0x70, 0x71 => @truncate(@as(u16, apu.ch3.sound3CntL()) >> getHalf(byte_addr)), // SOUND3CNT_L
0x72, 0x73 => @truncate(apu.ch3.sound3CntH() >> getHalf(byte_addr)),
0x74, 0x75 => @truncate(apu.ch3.sound3CntX() >> getHalf(byte_addr)), // SOUND3CNT_L
0x76, 0x77 => 0x00,
0x78, 0x79 => @as(T, @truncate(apu.ch4.sound4CntL() >> getHalf(byte_addr))),
0x78, 0x79 => @truncate(apu.ch4.sound4CntL() >> getHalf(byte_addr)),
0x7A, 0x7B => 0x00,
0x7C, 0x7D => @as(T, @truncate(apu.ch4.sound4CntH() >> getHalf(byte_addr))),
0x7C, 0x7D => @truncate(apu.ch4.sound4CntH() >> getHalf(byte_addr)),
0x7E, 0x7F => 0x00,
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))),
0x80, 0x81 => @truncate(apu.soundCntL() >> getHalf(byte_addr)), // SOUNDCNT_L
0x82, 0x83 => @truncate(apu.soundCntH() >> getHalf(byte_addr)), // SOUNDCNT_H
0x84, 0x85 => @truncate(@as(u16, apu.soundCntX()) >> getHalf(byte_addr)),
0x86, 0x87 => 0x00,
0x88, 0x89 => @as(T, @truncate(apu.bias.raw >> getHalf(byte_addr))), // SOUNDBIAS
0x88, 0x89 => @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 = @as(u8, @truncate(addr));
const byte_addr: 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, @as(u16, @truncate(value))),
0x64 => apu.ch1.setSound1CntX(&apu.fs, @truncate(value)),
0x68 => apu.ch2.setSound2CntL(@as(u16, @truncate(value))),
0x6C => apu.ch2.setSound2CntH(&apu.fs, @as(u16, @truncate(value))),
0x68 => apu.ch2.setSound2CntL(@truncate(value)),
0x6C => apu.ch2.setSound2CntH(&apu.fs, @truncate(value)),
0x70 => apu.ch3.setSound3Cnt(value),
0x74 => apu.ch3.setSound3CntX(&apu.fs, @as(u16, @truncate(value))),
0x74 => apu.ch3.setSound3CntX(&apu.fs, @truncate(value)),
0x78 => apu.ch4.setSound4CntL(@as(u16, @truncate(value))),
0x7C => apu.ch4.setSound4CntH(&apu.fs, @as(u16, @truncate(value))),
0x78 => apu.ch4.setSound4CntL(@truncate(value)),
0x7C => apu.ch4.setSound4CntH(&apu.fs, @truncate(value)),
0x80 => apu.setSoundCnt(value),
0x84 => apu.setSoundCntX(value >> 7 & 1 == 1),
0x88 => apu.bias.raw = @as(u16, @truncate(value)),
0x88 => apu.bias.raw = @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(@as(u8, @truncate(value))), // SOUND1CNT_L
0x60 => apu.ch1.setSound1CntL(@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(@as(u8, @truncate(value))),
0x70 => apu.ch3.setSound3CntL(@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(@as(u16, @truncate(value)));
self.setSoundCntH(@as(u16, @truncate(value >> 16)));
if (self.cnt.apu_enable.read()) self.setSoundCntL(@truncate(value));
self.setSoundCntH(@truncate(value >> 16));
}
/// SOUNDCNT_L
@ -450,8 +450,8 @@ pub const Apu = struct {
left += bias;
right += bias;
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));
const clamped_left = std.math.clamp(@as(u16, @bitCast(left)), 0, std.math.maxInt(u11));
const clamped_right = std.math.clamp(@as(u16, @bitCast(right)), 0, 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, @as(c_int, @intCast(sample_rate)), host_format, 2, host_rate).?;
self.stream = SDL.SDL_NewAudioStream(SDL.AUDIO_U16, 2, @intCast(sample_rate), host_format, 2, host_rate).?;
}
fn interval(self: *const Self) u64 {
@ -578,11 +578,11 @@ pub fn DmaSound(comptime kind: DmaSoundKind) type {
}
pub fn updateSample(self: *Self) void {
if (self.fifo.readItem()) |sample| self.sample = @as(i8, @bitCast(sample));
if (self.fifo.readItem()) |sample| self.sample = @bitCast(sample);
}
pub fn amplitude(self: *const Self) i16 {
return @as(i16, self.sample);
return self.sample;
}
};
}

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(@as(u8, @truncate(value)));
self.setNr42(@as(u8, @truncate(value >> 8)));
self.setNr41(@truncate(value));
self.setNr42(@truncate(value >> 8));
}
/// NR41
pub fn setNr41(self: *Self, len: u8) void {
self.len = @as(u6, @truncate(len));
self.len_dev.timer = @as(u7, 64) - @as(u6, @truncate(len));
self.len = @truncate(len);
self.len_dev.timer = @as(u7, 64) - self.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 = @as(u8, @truncate(value));
self.setNr44(fs, @as(u8, @truncate(value >> 8)));
self.poly.raw = @truncate(value);
self.setNr44(fs, @truncate(value >> 8));
}
/// NR44

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

@ -77,8 +77,8 @@ pub fn sound2CntL(self: *const Self) u16 {
/// NR21, NR22
pub fn setSound2CntL(self: *Self, value: u16) void {
self.setNr21(@as(u8, @truncate(value)));
self.setNr22(@as(u8, @truncate(value >> 8)));
self.setNr21(@truncate(value));
self.setNr22(@truncate(value >> 8));
}
/// NR21
@ -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(@as(u8, @truncate(value)));
self.setNr24(fs, @as(u8, @truncate(value >> 8)));
self.setNr23(@truncate(value));
self.setNr24(fs, @truncate(value >> 8));
}
/// NR23

12
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(@as(u8, @truncate(value)));
self.setSound1CntH(@as(u16, @truncate(value >> 16)));
self.setSound1CntL(@truncate(value));
self.setSound1CntH(@truncate(value >> 16));
}
/// NR10
@ -111,8 +111,8 @@ pub fn sound1CntH(self: *const Self) u16 {
/// NR11, NR12
pub fn setSound1CntH(self: *Self, value: u16) void {
self.setNr11(@as(u8, @truncate(value)));
self.setNr12(@as(u8, @truncate(value >> 8)));
self.setNr11(@truncate(value));
self.setNr12(@truncate(value >> 8));
}
/// NR11
@ -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(@as(u8, @truncate(value)));
self.setNr14(fs, @as(u8, @truncate(value >> 8)));
self.setNr13(@truncate(value));
self.setNr14(fs, @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(@as(u8, @truncate(value)));
self.setSound3CntH(@as(u16, @truncate(value >> 16)));
self.setSound3CntL(@truncate(value));
self.setSound3CntH(@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(@as(u8, @truncate(value)));
self.vol.raw = (@as(u8, @truncate(value >> 8)));
self.setNr31(@truncate(value));
self.vol.raw = @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(@as(u8, @truncate(value)));
self.setNr34(fs, @as(u8, @truncate(value >> 8)));
self.setNr33(@truncate(value));
self.setNr34(fs, @truncate(value >> 8));
}
/// NR33, NR34

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

@ -29,7 +29,7 @@ pub fn tick(self: *Self, ch1: *ToneSweep) void {
if (new_freq <= 0x7FF and ch1.sweep.shift.read() != 0) {
ch1.freq.frequency.write(@as(u11, @truncate(new_freq)));
self.shadow = @as(u11, @truncate(new_freq));
self.shadow = @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) @as(u4, @truncate(value >> 4)) else @as(u4, @truncate(value));
return if (self.offset & 1 == 0) @truncate(value >> 4) else @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 @as(T, @truncate(rotr(u32, value, 8 * rotateBy(T, address))));
return @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 @as(T, @truncate(rotr(u32, value, 8 * rotateBy(T, address))));
return @truncate(rotr(u32, value, 8 * rotateBy(T, address)));
}
/// Read without the GBA safety checks

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

@ -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 @as(u8, @truncate(lhs >> 8 * @as(u5, @truncate(i & 1))));
return @truncate(lhs >> 8 * @as(u5, @truncate(i & 1)));
}
pub fn dbgRead(self: *const Self, comptime T: type, address: u32) T {
@ -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 = @as(u1, @truncate(value));
const bit: u1 = @truncate(value);
if (self.buf.len > 0x100_0000) { // Large
// Addresses 0x1FF_FF00 to 0x1FF_FFFF are reserved from EEPROM accesses if

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 = @as(u1, @truncate(byte));
self.flash.bank = @truncate(byte);
},
0x5555 => {
if (self.flash.state == .Command) {

26
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 = @as(u2, @intCast(self.writer.finish()));
const req: 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 = @as(u10, @intCast(self.writer.finish()));
const addr: 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 = @as(u6, @intCast(self.writer.finish()));
const addr: u6 = @intCast(self.writer.finish());
const value = std.mem.readIntSliceLittle(u64, buf[@as(u13, addr) * 8 ..][0..8]);
self.reader.configure(value);
@ -186,11 +186,9 @@ const Reader = struct {
fn read(self: *Self) u1 {
if (!self.enabled) return 1;
const bit = if (self.i < 4) blk: {
break :blk 0;
} else blk: {
const idx = @as(u6, @intCast(63 - (self.i - 4)));
break :blk @as(u1, @truncate(self.data >> idx));
const bit: u1 = if (self.i < 4) 0 else blk: {
const idx: u6 = @intCast(63 - (self.i - 4));
break :blk @truncate(self.data >> idx);
};
self.i = (self.i + 1) % (64 + 4);
@ -202,11 +200,11 @@ const Reader = struct {
fn dbgRead(self: *const Self) u1 {
if (!self.enabled) return 1;
const bit = if (self.i < 4) blk: {
const bit: u1 = if (self.i < 4) blk: {
break :blk 0;
} else blk: {
const idx = @as(u6, @intCast(63 - (self.i - 4)));
break :blk @as(u1, @truncate(self.data >> idx));
const idx: u6 = @intCast(63 - (self.i - 4));
break :blk @truncate(self.data >> idx);
};
return bit;
@ -230,7 +228,7 @@ const Writer = struct {
}
fn requestWrite(self: *Self, bit: u1) void {
const idx = @as(u1, @intCast(1 - self.i));
const idx: u1 = @intCast(1 - self.i);
self.data = (self.data & ~(@as(u64, 1) << idx)) | (@as(u64, bit) << idx);
self.i += 1;
}
@ -244,13 +242,13 @@ const Writer = struct {
.Unknown => unreachable,
};
const idx = @as(u4, @intCast(size - self.i));
const idx: 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 = @as(u6, @intCast(63 - self.i));
const idx: u6 = @intCast(63 - self.i);
self.data = (self.data & ~(@as(u64, 1) << idx)) | (@as(u64, bit) << idx);
self.i += 1;
}

22
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 = @as(u8, @truncate(addr));
const byte_addr: 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 => @as(T, @truncate(dma.*[0].dmacntH() >> getHalf(byte_addr))),
0xBA, 0xBB => @truncate(dma.*[0].dmacntH() >> getHalf(byte_addr)),
0xBC...0xC3 => null, // DMA1SAD, DMA1DAD
0xC4, 0xC5 => 0x00, // DMA1CNT_L
0xC6, 0xC7 => @as(T, @truncate(dma.*[1].dmacntH() >> getHalf(byte_addr))),
0xC6, 0xC7 => @truncate(dma.*[1].dmacntH() >> getHalf(byte_addr)),
0xC8...0xCF => null, // DMA2SAD, DMA2DAD
0xD0, 0xD1 => 0x00, // DMA2CNT_L
0xD2, 0xD3 => @as(T, @truncate(dma.*[2].dmacntH() >> getHalf(byte_addr))),
0xD2, 0xD3 => @truncate(dma.*[2].dmacntH() >> getHalf(byte_addr)),
0xD4...0xDB => null, // DMA3SAD, DMA3DAD
0xDC, 0xDD => 0x00, // DMA3CNT_L
0xDE, 0xDF => @as(T, @truncate(dma.*[3].dmacntH() >> getHalf(byte_addr))),
0xDE, 0xDF => @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 = @as(u8, @truncate(addr));
const byte_addr: 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 = @as(@TypeOf(self.word_count), @truncate(halfword));
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(@as(u16, @truncate(word)));
self.setDmacntH(@as(u16, @truncate(word >> 16)));
self.setDmacntL(@truncate(word));
self.setDmacntH(@truncate(word >> 16));
}
pub fn step(self: *Self, cpu: *Arm7tdmi) void {
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 = @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 sad_adj: Adjustment = @enumFromInt(self.cnt.sad_adj.read());
const dad_adj: Adjustment = if (is_fifo) .Fixed else @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);

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

@ -32,7 +32,7 @@ pub const Gpio = struct {
return switch (self.kind) {
.Rtc => blk: {
const clock: *Clock = @ptrCast(@alignCast(self.ptr.?));
break :blk clock.step(Clock.Data{ .raw = value });
break :blk clock.step(.{ .raw = value });
},
.None => value,
};
@ -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 = @as(u3, @intCast(self.i));
const idx: u3 = @intCast(self.i);
defer self.i += 1;
// FIXME: What do I do about the unused bits?
return switch (register) {
.Control => @as(u1, @truncate(switch (self.count) {
.Control => @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 => @as(u1, @truncate(switch (self.count) {
}),
.DateTime => @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 => @as(u1, @truncate(switch (self.count) {
}),
.Time => @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 = @as(u3, @intCast(self.i));
const idx: u3 = @intCast(self.i);
self.buf = (self.buf & ~(@as(u8, 1) << idx)) | @as(u8, value) << idx;
self.i += 1;
}
@ -299,13 +299,13 @@ pub const Clock = struct {
sched_ptr.push(.RealTimeClock, (1 << 24) -| late); // Reschedule
const now = DateTime.now();
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)));
self.year = bcd(@intCast(now.date.year - 2000));
self.month = @truncate(bcd(now.date.month));
self.day = @truncate(bcd(now.date.day));
self.weekday = @truncate(bcd((now.date.weekday() + 1) % 7)); // API is Monday = 0, Sunday = 6. We want Sunday = 0, Saturday = 6
self.hour = @truncate(bcd(now.time.hour));
self.minute = @truncate(bcd(now.time.minute));
self.second = @truncate(bcd(now.time.second));
}
fn step(self: *Self, value: Data) u4 {
@ -321,7 +321,7 @@ pub const Clock = struct {
}
}
break :blk @as(u4, @truncate(value.raw));
break :blk @truncate(value.raw);
},
.Command => blk: {
if (!value.cs.read()) log.err("Expected CS to be set during {}, however CS was cleared", .{self.state});
@ -338,7 +338,7 @@ pub const Clock = struct {
}
}
break :blk @as(u4, @truncate(value.raw));
break :blk @truncate(value.raw);
},
.Write => |register| blk: {
if (!value.cs.read()) log.err("Expected CS to be set during {}, however CS was cleared", .{self.state});
@ -364,7 +364,7 @@ pub const Clock = struct {
}
}
break :blk @as(u4, @truncate(value.raw));
break :blk @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 @as(u4, @truncate(ret.raw));
break :blk @truncate(ret.raw);
},
};
}
@ -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 = @as(u3, @truncate(command >> 1 & 0x7));
const rtc_register: u3 = @truncate(command >> 1 & 0x7);
if (is_write) {
return switch (rtc_register) {

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

@ -43,7 +43,7 @@ pub const Io = struct {
}
fn setIrqs(self: *Io, word: u32) void {
self.ie.raw = @as(u16, @truncate(word));
self.ie.raw = @truncate(word);
self.irq.raw &= ~@as(u16, @truncate(word >> 16));
}
};
@ -141,11 +141,11 @@ pub fn read(bus: *const Bus, comptime T: type, address: u32) ?T {
0x0400_015A, 0x0400_015B => 0x00,
// Interrupts
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_0200, 0x0400_0201 => @truncate(bus.io.ie.raw >> getHalf(@truncate(address))),
0x0400_0202, 0x0400_0203 => @truncate(bus.io.irq.raw >> getHalf(@truncate(address))),
0x0400_0204, 0x0400_0205 => @truncate(bus.io.waitcnt.raw >> getHalf(@truncate(address))),
0x0400_0206, 0x0400_0207 => 0x00,
0x0400_0208, 0x0400_0209 => @as(T, @truncate(@as(u16, @intFromBool(bus.io.ime)) >> getHalf(@as(u8, @truncate(address))))),
0x0400_0208, 0x0400_0209 => @truncate(@as(u16, @intFromBool(bus.io.ime)) >> getHalf(@truncate(address))),
0x0400_020A, 0x0400_020B => 0x00,
0x0400_0300 => @intFromEnum(bus.io.postflg),
0x0400_0301 => null,
@ -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(@as(u16, @truncate(value))),
0x0400_0204 => bus.io.waitcnt.set(@truncate(value)),
0x0400_0208 => bus.io.ime = value & 1 == 1,
0x0400_0300 => {
bus.io.postflg = @as(PostFlag, @enumFromInt(value & 1));
bus.io.postflg = @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 = @as(PostFlag, @enumFromInt(value & 1));
bus.io.postflg = @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, @as(u8, @truncate(address)), value),
0x0400_0200, 0x0400_0201 => bus.io.ie.raw = setHalf(u16, bus.io.ie.raw, @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, @as(u16, @truncate(bus.io.waitcnt.raw)), @as(u8, @truncate(address)), value)),
0x0400_0204, 0x0400_0205 => bus.io.waitcnt.set(setHalf(u16, bus.io.waitcnt.raw, @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 = @as(PostFlag, @enumFromInt(value & 1)),
0x0400_0300 => bus.io.postflg = @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 }),

26
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 = @as(u4, @truncate(addr));
const nybble_addr: 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 => @as(T, @truncate(tim.*[0].timcntL() >> getHalf(nybble_addr))),
0x2, 0x3 => @as(T, @truncate(tim.*[0].cnt.raw >> getHalf(nybble_addr))),
0x0, 0x1 => @truncate(tim.*[0].timcntL() >> getHalf(nybble_addr)),
0x2, 0x3 => @truncate(tim.*[0].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))),
0x4, 0x5 => @truncate(tim.*[1].timcntL() >> getHalf(nybble_addr)),
0x6, 0x7 => @truncate(tim.*[1].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))),
0x8, 0x9 => @truncate(tim.*[2].timcntL() >> getHalf(nybble_addr)),
0xA, 0xB => @truncate(tim.*[2].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))),
0xC, 0xD => @truncate(tim.*[3].timcntL() >> getHalf(nybble_addr)),
0xE, 0xF => @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 = @as(u4, @truncate(addr));
const nybble_addr: u4 = @truncate(addr);
return switch (T) {
u32 => switch (nybble_addr) {
@ -151,8 +151,8 @@ fn Timer(comptime id: u2) type {
/// TIMCNT_L & TIMCNT_H
pub fn setTimcnt(self: *Self, word: u32) void {
self.setTimcntL(@as(u16, @truncate(word)));
self.setTimcntH(@as(u16, @truncate(word >> 16)));
self.setTimcntL(@truncate(word));
self.setTimcntH(@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 +%= @as(u16, @truncate((self.sched.now() - self._start_timestamp) / self.frequency()));
self._counter +%= @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

164
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 = @as(u8, @truncate(addr));
const byte_addr: 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 => @as(T, @truncate(ppu.dispcnt.raw >> getHalf(byte_addr))),
0x00, 0x01 => @truncate(ppu.dispcnt.raw >> getHalf(byte_addr)),
0x02, 0x03 => null,
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))),
0x04, 0x05 => @truncate(ppu.dispstat.raw >> getHalf(byte_addr)),
0x06, 0x07 => @truncate(ppu.vcount.raw >> getHalf(byte_addr)),
0x08, 0x09 => @truncate(ppu.bg[0].bg0Cnt() >> getHalf(byte_addr)),
0x0A, 0x0B => @truncate(ppu.bg[1].bg1Cnt() >> getHalf(byte_addr)),
0x0C, 0x0D => @truncate(ppu.bg[2].cnt.raw >> getHalf(byte_addr)),
0x0E, 0x0F => @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 => @as(T, @truncate(ppu.win.getIn() >> getHalf(byte_addr))),
0x4A, 0x4B => @as(T, @truncate(ppu.win.getOut() >> getHalf(byte_addr))),
0x48, 0x49 => @truncate(ppu.win.getIn() >> getHalf(byte_addr)),
0x4A, 0x4B => @truncate(ppu.win.getOut() >> getHalf(byte_addr)),
0x4C, 0x4D => null, // MOSAIC
0x4E, 0x4F => null,
0x50, 0x51 => @as(T, @truncate(ppu.bld.getCnt() >> getHalf(byte_addr))),
0x52, 0x53 => @as(T, @truncate(ppu.bld.getAlpha() >> getHalf(byte_addr))),
0x50, 0x51 => @truncate(ppu.bld.getCnt() >> getHalf(byte_addr)),
0x52, 0x53 => @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 = @as(u8, @truncate(addr)); // prefixed with 0x0400_00
const byte_addr: u8 = @truncate(addr); // prefixed with 0x0400_00
switch (T) {
u32 => switch (byte_addr) {
0x00 => ppu.dispcnt.raw = @as(u16, @truncate(value)),
0x00 => ppu.dispcnt.raw = @truncate(value),
0x04 => {
ppu.dispstat.set(@as(u16, @truncate(value)));
ppu.vcount.raw = @as(u16, @truncate(value >> 16));
ppu.dispstat.set(@truncate(value));
ppu.vcount.raw = @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 = @as(u16, @truncate(value));
ppu.bld.alpha.raw = @as(u16, @truncate(value >> 16));
ppu.bld.cnt.raw = @truncate(value);
ppu.bld.alpha.raw = @truncate(value >> 16);
},
0x54 => ppu.bld.y.raw = @as(u16, @truncate(value)),
0x54 => ppu.bld.y.raw = @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 = @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))),
0x20 => ppu.aff_bg[0].pa = @bitCast(value),
0x22 => ppu.aff_bg[0].pb = @bitCast(value),
0x24 => ppu.aff_bg[0].pc = @bitCast(value),
0x26 => ppu.aff_bg[0].pd = @bitCast(value),
0x28, 0x2A => ppu.aff_bg[0].x = @bitCast(setHalf(u32, @as(u32, @bitCast(ppu.aff_bg[0].x)), byte_addr, value)),
0x2C, 0x2E => ppu.aff_bg[0].y = @bitCast(setHalf(u32, @as(u32, @bitCast(ppu.aff_bg[0].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))),
0x30 => ppu.aff_bg[1].pa = @bitCast(value),
0x32 => ppu.aff_bg[1].pb = @bitCast(value),
0x34 => ppu.aff_bg[1].pc = @bitCast(value),
0x36 => ppu.aff_bg[1].pd = @bitCast(value),
0x38, 0x3A => ppu.aff_bg[1].x = @bitCast(setHalf(u32, @as(u32, @bitCast(ppu.aff_bg[1].x)), byte_addr, value)),
0x3C, 0x3E => ppu.aff_bg[1].y = @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 = @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))),
0x20, 0x21 => ppu.aff_bg[0].pa = @bitCast(setHalf(u16, @as(u16, @bitCast(ppu.aff_bg[0].pa)), byte_addr, value)),
0x22, 0x23 => ppu.aff_bg[0].pb = @bitCast(setHalf(u16, @as(u16, @bitCast(ppu.aff_bg[0].pb)), byte_addr, value)),
0x24, 0x25 => ppu.aff_bg[0].pc = @bitCast(setHalf(u16, @as(u16, @bitCast(ppu.aff_bg[0].pc)), byte_addr, value)),
0x26, 0x27 => ppu.aff_bg[0].pd = @bitCast(setHalf(u16, @as(u16, @bitCast(ppu.aff_bg[0].pd)), byte_addr, value)),
0x28, 0x29, 0x2A, 0x2B => ppu.aff_bg[0].x = @bitCast(setQuart(@bitCast(ppu.aff_bg[0].x), byte_addr, value)),
0x2C, 0x2D, 0x2E, 0x2F => ppu.aff_bg[0].y = @bitCast(setQuart(@bitCast(ppu.aff_bg[0].y), byte_addr, value)),
// BG3 Rot/Scaling
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))),
0x30, 0x31 => ppu.aff_bg[1].pa = @bitCast(setHalf(u16, @as(u16, @bitCast(ppu.aff_bg[1].pa)), byte_addr, value)),
0x32, 0x33 => ppu.aff_bg[1].pb = @bitCast(setHalf(u16, @as(u16, @bitCast(ppu.aff_bg[1].pb)), byte_addr, value)),
0x34, 0x35 => ppu.aff_bg[1].pc = @bitCast(setHalf(u16, @as(u16, @bitCast(ppu.aff_bg[1].pc)), byte_addr, value)),
0x36, 0x37 => ppu.aff_bg[1].pd = @bitCast(setHalf(u16, @as(u16, @bitCast(ppu.aff_bg[1].pd)), byte_addr, value)),
0x38, 0x39, 0x3A, 0x3B => ppu.aff_bg[1].x = @bitCast(setQuart(@bitCast(ppu.aff_bg[1].x), byte_addr, value)),
0x3C, 0x3D, 0x3E, 0x3F => ppu.aff_bg[1].y = @bitCast(setQuart(@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 = @as(u16, @truncate(word));
self.bg[n].vofs.raw = @as(u16, @truncate(word >> 16));
self.bg[n].hofs.raw = @truncate(word);
self.bg[n].vofs.raw = @truncate(word >> 16);
}
pub fn setAdjCnts(self: *Self, comptime n: u2, word: u32) void {
self.bg[n].cnt.raw = @as(u16, @truncate(word));
self.bg[n + 1].cnt.raw = @as(u16, @truncate(word >> 16));
self.bg[n].cnt.raw = @truncate(word);
self.bg[n + 1].cnt.raw = @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 = @as(Attr0, @bitCast(self.oam.read(u16, i)));
const attr0: Attr0 = @bitCast(self.oam.read(u16, i));
// Only consider enabled Sprites
if (attr0.is_affine.read() or !attr0.disabled.read()) {
const attr1 = @as(Attr1, @bitCast(self.oam.read(u16, i + 2)));
const attr1: 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, @as(Attr2, @bitCast(self.oam.read(u16, i + 4))));
maybe_sprite.* = Sprite.init(attr0, attr1, @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 = @as([4]i16, @bitCast([_]u16{ pa, pb, pc, pd }));
const matrix: [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 = @as(u9, @truncate(@as(u16, @bitCast(sprite_x + i))));
const x: 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 = @as(u16, @bitCast(rot_x));
const tile_y = @as(u16, @bitCast(rot_y));
const tile_x: u16 = @bitCast(rot_x);
const tile_y: u16 = @bitCast(rot_y);
const col = @as(u3, @truncate(tile_x));
const row = @as(u3, @truncate(tile_y));
const col: u3 = @truncate(tile_x);
const row: 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,7 +461,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 = @as(u9, @truncate(@as(u16, @bitCast(local_x + sprite_x))));
const global_x: u9 = @truncate(@as(u16, @bitCast(local_x + sprite_x)));
// Sprite Palette starts at 0x0500_0200
if (pal_id != 0) {
@ -507,8 +507,8 @@ pub const Ppu = struct {
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 = @as(u3, @truncate(tile_x));
const row = @as(u3, @truncate(tile_y));
const col: u3 = @truncate(tile_x);
const row: 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 = @as(u9, @truncate(@as(u16, @bitCast(local_x + sprite_x))));
const global_x: 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 = @as(u9, @truncate(@as(u32, @bitCast(ix))));
const _y = @as(u8, @truncate(@as(u32, @bitCast(iy))));
const _x: u9 = @truncate(@as(u32, @bitCast(ix)));
const _y: u8 = @truncate(@as(u32, @bitCast(iy)));
const win_bounds = self.windowBounds(_x, _y);
if (!shouldDrawBackground(self, n, win_bounds, i)) continue;
@ -561,8 +561,8 @@ 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 = @as(u32, @bitCast(ix));
const y = @as(u32, @bitCast(iy));
const x: u32 = @bitCast(ix);
const y: u32 = @bitCast(iy);
const tile_id: u32 = self.vram.read(u8, screen_base + ((y / 8) * @as(u32, @bitCast(tile_width)) + (x / 8)));
const row = y & 7;
@ -601,12 +601,12 @@ pub const Ppu = struct {
while (i < width) : (i += 1) {
const x = hofs + i;
const win_bounds = self.windowBounds(@as(u9, @truncate(x)), @as(u8, @truncate(y)));
const win_bounds = self.windowBounds(@truncate(x), @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 = @as(ScreenEntry, @bitCast(self.vram.read(u16, entry_addr)));
const entry: 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
@ -649,7 +649,7 @@ pub const Ppu = struct {
if (obj_enable) self.fetchSprites();
for (0..4) |layer| {
self.drawSprites(@as(u2, @truncate(layer)));
self.drawSprites(@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);
@ -676,7 +676,7 @@ pub const Ppu = struct {
if (obj_enable) self.fetchSprites();
for (0..4) |layer| {
self.drawSprites(@as(u2, @truncate(layer)));
self.drawSprites(@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);
}
@ -1148,18 +1148,18 @@ const Window = struct {
}
pub fn setH(self: *Self, value: u32) void {
self.h[0].raw = @as(u16, @truncate(value));
self.h[1].raw = @as(u16, @truncate(value >> 16));
self.h[0].raw = @truncate(value);
self.h[1].raw = @truncate(value >> 16);
}
pub fn setV(self: *Self, value: u32) void {
self.v[0].raw = @as(u16, @truncate(value));
self.v[1].raw = @as(u16, @truncate(value >> 16));
self.v[0].raw = @truncate(value);
self.v[1].raw = @truncate(value >> 16);
}
pub fn setIo(self: *Self, value: u32) void {
self.in.raw = @as(u16, @truncate(value));
self.out.raw = @as(u16, @truncate(value >> 16));
self.in.raw = @truncate(value);
self.out.raw = @truncate(value >> 16);
}
};
@ -1222,23 +1222,23 @@ const AffineBackground = struct {
}
pub fn setX(self: *Self, is_vblank: bool, value: u32) void {
self.x = @as(i32, @bitCast(value));
if (!is_vblank) self.x_latch = @as(i32, @bitCast(value));
self.x = @bitCast(value);
if (!is_vblank) self.x_latch = @bitCast(value);
}
pub fn setY(self: *Self, is_vblank: bool, value: u32) void {
self.y = @as(i32, @bitCast(value));
if (!is_vblank) self.y_latch = @as(i32, @bitCast(value));
self.y = @bitCast(value);
if (!is_vblank) self.y_latch = @bitCast(value);
}
pub fn writePaPb(self: *Self, value: u32) void {
self.pa = @as(i16, @bitCast(@as(u16, @truncate(value))));
self.pb = @as(i16, @bitCast(@as(u16, @truncate(value >> 16))));
self.pa = @bitCast(@as(u16, @truncate(value)));
self.pb = @bitCast(@as(u16, @truncate(value >> 16)));
}
pub fn writePcPd(self: *Self, value: u32) void {
self.pc = @as(i16, @bitCast(@as(u16, @truncate(value))));
self.pd = @as(i16, @bitCast(@as(u16, @truncate(value >> 16))));
self.pc = @bitCast(@as(u16, @truncate(value)));
self.pd = @bitCast(@as(u16, @truncate(value >> 16)));
}
// Every Vblank BG?X/Y registers are latched

26
src/imgui.zig
View File

@ -74,7 +74,7 @@ pub fn draw(state: *State, win_dim: Dimensions, tex_id: GLuint, cpu: *Arm7tdmi)
const scn_scale = config.config().host.win_scale;
const bus_ptr: *Bus = @ptrCast(@alignCast(cpu.bus.ptr));
zgui.backend.newFrame(@as(f32, @floatFromInt(win_dim.width)), @as(f32, @floatFromInt(win_dim.height)));
zgui.backend.newFrame(@floatFromInt(win_dim.width), @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 = @as(f32, @floatFromInt(gba_width * scn_scale));
const h = @as(f32, @floatFromInt(gba_height * scn_scale));
const w: f32 = @floatFromInt(gba_width * scn_scale);
const h: 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(@as(*anyopaque, @ptrFromInt(tex_id)), .{ .w = w, .h = h, .uv0 = .{ 0, 1 }, .uv1 = .{ 1, 0 } });
zgui.image(@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) @as(f64, @floatFromInt(sorted[len - 1])) else emu.frame_rate;
const x_max = @as(f64, @floatFromInt(values.len));
const y_max: f64 = 2 * if (len != 0) @as(f64, @floatFromInt(sorted[len - 1])) else emu.frame_rate;
const x_max: 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 } };
@ -294,11 +294,11 @@ pub fn draw(state: *State, win_dim: Dimensions, tex_id: GLuint, cpu: *Arm7tdmi)
const stats: struct { u32, u32, u32 } = blk: {
if (len == 0) break :blk .{ 0, 0, 0 };
const average = average: {
const average: u32 = average: {
var sum: u32 = 0;
for (sorted[0..len]) |value| sum += value;
break :average @as(u32, @intCast(sum / len));
break :average @intCast(sum / len);
};
const median = sorted[len / 2];
const low = sorted[len / 100]; // 1% Low
@ -365,7 +365,7 @@ const widgets = struct {
};
for (0..0x100) |i| {
const offset = @as(u32, @truncate(i));
const offset: 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 = @as(zgui.ColorEditFlags, @bitCast(ImguiColorEditFlags_NoInputs | ImguiColorEditFlags_NoPicker));
const flags: zgui.ColorEditFlags = @bitCast(ImguiColorEditFlags_NoInputs | ImguiColorEditFlags_NoPicker);
const b = @as(f32, @floatFromInt(bgr555 >> 10 & 0x1f));
const g = @as(f32, @floatFromInt(bgr555 >> 5 & 0x1F));
const r = @as(f32, @floatFromInt(bgr555 & 0x1F));
const b: f32 = @floatFromInt(bgr555 >> 10 & 0x1f);
const g: f32 = @floatFromInt(bgr555 >> 5 & 0x1F);
const r: f32 = @floatFromInt(bgr555 & 0x1F);
var col = [_]f32{ r / 31.0, g / 31.0, b / 31.0 };

10
src/platform.zig
View File

@ -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 = @as(u32, @intCast(event.window.data1));
win_dim.height = @as(u32, @intCast(event.window.data2));
win_dim.width = @intCast(event.window.data1);
win_dim.height = @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, @as(GLsizei, @intFromFloat(size[0])), @as(GLsizei, @intFromFloat(size[1])));
gl.viewport(0, 0, @intFromFloat(size[0]), @intFromFloat(size[1]));
gl.clearColor(0, 0, 0, 1.0);
gl.clear(gl.COLOR_BUFFER_BIT);
@ -421,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), @as(?*anyopaque, @ptrFromInt((3 * @sizeOf(f32)))));
gl.vertexAttribPointer(1, 3, gl.FLOAT, gl.FALSE, 8 * @sizeOf(f32), @ptrFromInt((3 * @sizeOf(f32))));
gl.enableVertexAttribArray(1);
// Texture Coord
gl.vertexAttribPointer(2, 2, gl.FLOAT, gl.FALSE, 8 * @sizeOf(f32), @as(?*anyopaque, @ptrFromInt((6 * @sizeOf(f32)))));
gl.vertexAttribPointer(2, 2, gl.FLOAT, gl.FALSE, 8 * @sizeOf(f32), @ptrFromInt((6 * @sizeOf(f32))));
gl.enableVertexAttribArray(2);
return .{ .vao = vao_id, .vbo = vbo_id, .ebo = ebo_id };

4
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 = @as(u2, @truncate(addr));
const offset: u2 = @truncate(addr);
return switch (offset) {
0b00 => (left & 0xFFFF_FF00) | right,
@ -221,7 +221,7 @@ pub inline fn getHalf(byte: u8) u4 {
}
pub inline fn setHalf(comptime T: type, left: T, addr: u8, right: HalfInt(T)) T {
const offset = @as(u1, @truncate(addr >> if (T == u32) 1 else 0));
const offset: u1 = @truncate(addr >> if (T == u32) 1 else 0);
return switch (T) {
u32 => switch (offset) {