lorenzo/sideros
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Migrated to the new std.ArrayList implementation

Browse source
This commit is contained in:
Lorenzo Torres 2025-08-18 23:23:45 +02:00
parent 8f5c79eb01
commit 330d9b7711
11 changed files with 313 additions and 291 deletions
Download patch file Download diff file Expand all files Collapse all files

16
assets/shaders/shader.frag
View file

@ -35,17 +35,17 @@ layout(push_constant) uniform pc {
int light_count; int light_count;
} pushConstants; } pushConstants;
layout (set = 1, binding = 0) uniform sampler2D diffuseSampler; layout (set = 1, binding = 0) uniform sampler2D diffuseSampler[4];
layout (set = 1, binding = 1) uniform sampler2D specularSampler; layout (set = 1, binding = 1) uniform sampler2D specularSampler[4];
vec3 calc_directional_light(vec3 normal, vec3 viewDir) { vec3 calc_directional_light(vec3 normal, vec3 viewDir) {
vec3 lightDir = normalize(-directional_light.direction); vec3 lightDir = normalize(-directional_light.direction);
float diff = max(dot(normal, lightDir), 0.0); float diff = max(dot(normal, lightDir), 0.0);
vec3 reflectDir = reflect(-lightDir, normal); vec3 reflectDir = reflect(-lightDir, normal);
float spec = pow(max(dot(viewDir, reflectDir), 0.0), 2); float spec = pow(max(dot(viewDir, reflectDir), 0.0), 2);
vec3 ambient = directional_light.ambient * vec3(texture(diffuseSampler, TexCoords)); vec3 ambient = directional_light.ambient * vec3(texture(diffuseSampler[2], TexCoords));
vec3 diffuse = directional_light.diffuse * diff * vec3(texture(diffuseSampler , TexCoords)); vec3 diffuse = directional_light.diffuse * diff * vec3(texture(diffuseSampler[2] , TexCoords));
vec3 specular = directional_light.specular * spec * vec3(texture(specularSampler, TexCoords)); vec3 specular = directional_light.specular * spec * vec3(texture(specularSampler[2], TexCoords));
return (ambient + diffuse + specular); return (ambient + diffuse + specular);
} }
@ -60,9 +60,9 @@ vec3 calc_point_light(int index, vec3 normal, vec3 fragPos, vec3 viewDir) {
float spec = pow(max(dot(viewDir, reflectDir), 0.0), 2); float spec = pow(max(dot(viewDir, reflectDir), 0.0), 2);
float distance = length(point_lights.point_lights[index].position - fragPos); float distance = length(point_lights.point_lights[index].position - fragPos);
float attenuation = 1.0 / (constant + linear * distance + quadratic * (distance * distance)); float attenuation = 1.0 / (constant + linear * distance + quadratic * (distance * distance));
vec3 ambient = point_lights.point_lights[index].ambient * vec3(texture(diffuseSampler, TexCoords)); vec3 ambient = point_lights.point_lights[index].ambient * vec3(texture(diffuseSampler[2], TexCoords));
vec3 diffuse = point_lights.point_lights[index].diffuse * diff * vec3(texture(diffuseSampler, TexCoords)); vec3 diffuse = point_lights.point_lights[index].diffuse * diff * vec3(texture(diffuseSampler[2], TexCoords));
vec3 specular = point_lights.point_lights[index].specular * spec * vec3(texture(specularSampler, TexCoords)); vec3 specular = point_lights.point_lights[index].specular * spec * vec3(texture(specularSampler[2], TexCoords));
ambient *= attenuation; ambient *= attenuation;
diffuse *= attenuation; diffuse *= attenuation;
specular *= attenuation; specular *= attenuation;

10
src/ecs/ecs.zig
View file

@ -20,15 +20,17 @@ pub const hooks = struct {
pub var key: std.ArrayList(Key) = undefined; pub var key: std.ArrayList(Key) = undefined;
pub var scroll: std.ArrayList(Scroll) = undefined; pub var scroll: std.ArrayList(Scroll) = undefined;
var allocator: std.mem.Allocator = undefined;
pub const Layer = enum { pub const Layer = enum {
key, key,
scroll scroll
}; };
pub fn init(allocator: std.mem.Allocator) !void { pub fn init(gpa: std.mem.Allocator) !void {
key = std.ArrayList(Key).init(allocator); key = std.ArrayList(Key).empty;
scroll = std.ArrayList(Scroll).init(allocator); scroll = std.ArrayList(Scroll).empty;
allocator = gpa;
} }
pub fn addHook(comptime layer: Layer, hook: anytype) !void { pub fn addHook(comptime layer: Layer, hook: anytype) !void {
@ -37,7 +39,7 @@ pub const hooks = struct {
.scroll => &scroll, .scroll => &scroll,
}; };
try list.append(hook); try list.append(allocator, hook);
} }
}; };

12
src/ecs/entities.zig
View file

@ -41,8 +41,8 @@ pub const Pool = struct {
var pool = @This(){ var pool = @This(){
.humans = .{}, .humans = .{},
.resources = resources, .resources = resources,
.system_groups = std.ArrayList(SystemGroup).init(allocator), .system_groups = std.ArrayList(SystemGroup).empty,
.sync_groups = std.ArrayList(SystemGroup).init(allocator), .sync_groups = std.ArrayList(SystemGroup).empty,
.thread_pool = try allocator.create(std.Thread.Pool), .thread_pool = try allocator.create(std.Thread.Pool),
.wait_group = .{}, .wait_group = .{},
.mutex = .{}, .mutex = .{},
@ -59,17 +59,17 @@ pub const Pool = struct {
pub fn addSystemGroup(self: *@This(), group: SystemGroup, sync: bool) !void { pub fn addSystemGroup(self: *@This(), group: SystemGroup, sync: bool) !void {
if (sync) { if (sync) {
try self.sync_groups.append(group); try self.sync_groups.append(self.allocator, group);
} else { } else {
try self.system_groups.append(group); try self.system_groups.append(self.allocator, group);
} }
} }
pub fn deinit(self: *@This()) void { pub fn deinit(self: *@This()) void {
self.humans.deinit(self.allocator); self.humans.deinit(self.allocator);
self.system_groups.deinit(); self.system_groups.deinit(self.allocator);
self.sync_groups.deinit(); self.sync_groups.deinit(self.allocator);
self.thread_pool.deinit(); self.thread_pool.deinit();
self.allocator.destroy(self.thread_pool); self.allocator.destroy(self.thread_pool);
} }

346
src/mods/vm.zig
View file

@ -143,7 +143,7 @@ pub const Runtime = struct {
} }
pub fn deinit(self: *Runtime, allocator: Allocator) void { pub fn deinit(self: *Runtime, allocator: Allocator) void {
self.stack.deinit(); self.stack.deinit(allocator);
self.global_runtime.deinit(); self.global_runtime.deinit();
self.module.deinit(allocator); self.module.deinit(allocator);
self.externalFuncs.deinit(allocator); self.externalFuncs.deinit(allocator);
@ -181,10 +181,10 @@ pub const Runtime = struct {
}, },
.@"return" => break :loop, .@"return" => break :loop,
.call => { .call => {
var parameters = std.ArrayList(Value).init(allocator); var parameters = std.ArrayList(Value).empty;
defer parameters.deinit(); defer parameters.deinit(allocator);
for (self.module.functions[index.u32].func_type.parameters) |_| { for (self.module.functions[index.u32].func_type.parameters) |_| {
try parameters.append(self.stack.pop().?); try parameters.append(allocator, self.stack.pop().?);
} }
try self.call(allocator, index.u32, parameters.items); try self.call(allocator, index.u32, parameters.items);
}, },
@ -194,22 +194,22 @@ pub const Runtime = struct {
} }
const j: u32 = @intCast(self.stack.pop().?.i32); const j: u32 = @intCast(self.stack.pop().?.i32);
const funcIdx = self.module.elems[index.indirect.x][j]; const funcIdx = self.module.elems[index.indirect.x][j];
var parameters = std.ArrayList(Value).init(allocator); var parameters = std.ArrayList(Value).empty;
defer parameters.deinit(); defer parameters.deinit(allocator);
for (self.module.functions[funcIdx].func_type.parameters) |_| { for (self.module.functions[funcIdx].func_type.parameters) |_| {
try parameters.append(self.stack.pop().?); try parameters.append(allocator, self.stack.pop().?);
} }
try self.call(allocator, funcIdx, parameters.items); try self.call(allocator, funcIdx, parameters.items);
}, },
.refnull => { .refnull => {
try self.stack.append(.{.ref = .{.type = null, .val = 0}}); try self.stack.append(allocator, .{.ref = .{.type = null, .val = 0}});
}, },
.refisnull => { .refisnull => {
try self.stack.append(.{ .i32 = @intCast(@as(i1, @bitCast(self.stack.pop().?.ref.type == null))) }); try self.stack.append(allocator, .{ .i32 = @intCast(@as(i1, @bitCast(self.stack.pop().?.ref.type == null))) });
}, },
.reffunc => { .reffunc => {
try self.stack.append(.{.ref = .{.type = std.wasm.RefType.funcref, .val = index.u32}}); try self.stack.append(allocator, .{.ref = .{.type = std.wasm.RefType.funcref, .val = index.u32}});
}, },
.drop => { .drop => {
@ -220,17 +220,17 @@ pub const Runtime = struct {
const val2 = self.stack.pop().?; const val2 = self.stack.pop().?;
const val1 = self.stack.pop().?; const val1 = self.stack.pop().?;
if (c != 0) { if (c != 0) {
try self.stack.append(val1); try self.stack.append(allocator, val1);
} else { } else {
try self.stack.append(val2); try self.stack.append(allocator, val2);
} }
}, },
.select_with_values => @panic("UNIMPLEMENTED"), .select_with_values => @panic("UNIMPLEMENTED"),
.localget => try self.stack.append(frame.locals[index.u32]), .localget => try self.stack.append(allocator, frame.locals[index.u32]),
.localset => frame.locals[index.u32] = self.stack.pop().?, .localset => frame.locals[index.u32] = self.stack.pop().?,
.localtee => frame.locals[index.u32] = self.stack.items[self.stack.items.len - 1], .localtee => frame.locals[index.u32] = self.stack.items[self.stack.items.len - 1],
.globalget => try self.stack.append(self.global_runtime.getGlobal(index.u32)), .globalget => try self.stack.append(allocator, self.global_runtime.getGlobal(index.u32)),
.globalset => try self.global_runtime.updateGlobal(index.u32, self.stack.pop().?), .globalset => try self.global_runtime.updateGlobal(index.u32, self.stack.pop().?),
.tableget => @panic("UNIMPLEMENTED"), .tableget => @panic("UNIMPLEMENTED"),
@ -246,82 +246,82 @@ pub const Runtime = struct {
.i32_load => { .i32_load => {
const start = index.memarg.offset + @as(u32, @intCast(self.stack.pop().?.i32)); const start = index.memarg.offset + @as(u32, @intCast(self.stack.pop().?.i32));
const end = start + @sizeOf(i32); const end = start + @sizeOf(i32);
try self.stack.append(.{ .i32 = std.mem.littleToNative(i32, std.mem.bytesAsValue(i32, self.memory[start..end]).*) }); try self.stack.append(allocator, .{ .i32 = std.mem.littleToNative(i32, std.mem.bytesAsValue(i32, self.memory[start..end]).*) });
}, },
.i64_load => { .i64_load => {
const start = index.memarg.offset + @as(u32, @intCast(self.stack.pop().?.i32)); const start = index.memarg.offset + @as(u32, @intCast(self.stack.pop().?.i32));
const end = start + @sizeOf(i64); const end = start + @sizeOf(i64);
try self.stack.append(.{ .i64 = std.mem.littleToNative(i64, std.mem.bytesAsValue(i64, self.memory[start..end]).*) }); try self.stack.append(allocator, .{ .i64 = std.mem.littleToNative(i64, std.mem.bytesAsValue(i64, self.memory[start..end]).*) });
}, },
.f32_load => { .f32_load => {
const start = index.memarg.offset + @as(u32, @intCast(self.stack.pop().?.i32)); const start = index.memarg.offset + @as(u32, @intCast(self.stack.pop().?.i32));
const end = start + @sizeOf(f32); const end = start + @sizeOf(f32);
try self.stack.append(.{ .f32 = std.mem.littleToNative(f32, std.mem.bytesAsValue(f32, self.memory[start..end]).*) }); try self.stack.append(allocator, .{ .f32 = std.mem.littleToNative(f32, std.mem.bytesAsValue(f32, self.memory[start..end]).*) });
}, },
.f64_load => { .f64_load => {
const start = index.memarg.offset + @as(u32, @intCast(self.stack.pop().?.i32)); const start = index.memarg.offset + @as(u32, @intCast(self.stack.pop().?.i32));
const end = start + @sizeOf(f64); const end = start + @sizeOf(f64);
try self.stack.append(.{ .f64 = std.mem.littleToNative(f64, std.mem.bytesAsValue(f64, self.memory[start..end]).*) }); try self.stack.append(allocator, .{ .f64 = std.mem.littleToNative(f64, std.mem.bytesAsValue(f64, self.memory[start..end]).*) });
}, },
.i32_load8_s => { .i32_load8_s => {
const start = index.memarg.offset + @as(u32, @intCast(self.stack.pop().?.i32)); const start = index.memarg.offset + @as(u32, @intCast(self.stack.pop().?.i32));
const end = start + @sizeOf(i8); const end = start + @sizeOf(i8);
const raw_value = std.mem.readInt(i8, @as(*const [1]u8, @ptrCast(self.memory[start..end])), std.builtin.Endian.little); const raw_value = std.mem.readInt(i8, @as(*const [1]u8, @ptrCast(self.memory[start..end])), std.builtin.Endian.little);
try self.stack.append(.{ .i32 = @intCast(@as(i32, raw_value)) }); try self.stack.append(allocator, .{ .i32 = @intCast(@as(i32, raw_value)) });
}, },
.i32_load8_u => { .i32_load8_u => {
const start = index.memarg.offset + @as(u32, @intCast(self.stack.pop().?.i32)); const start = index.memarg.offset + @as(u32, @intCast(self.stack.pop().?.i32));
const end = start + @sizeOf(u8); const end = start + @sizeOf(u8);
const raw_value = std.mem.readInt(u8, @as(*const [1]u8, @ptrCast(self.memory[start..end])), std.builtin.Endian.little); const raw_value = std.mem.readInt(u8, @as(*const [1]u8, @ptrCast(self.memory[start..end])), std.builtin.Endian.little);
try self.stack.append(.{ .i32 = @intCast(@as(u32, raw_value)) }); try self.stack.append(allocator, .{ .i32 = @intCast(@as(u32, raw_value)) });
}, },
.i32_load16_s => { .i32_load16_s => {
const start = index.memarg.offset + @as(u32, @intCast(self.stack.pop().?.i32)); const start = index.memarg.offset + @as(u32, @intCast(self.stack.pop().?.i32));
const end = start + @sizeOf(i16); const end = start + @sizeOf(i16);
const raw_value = std.mem.readInt(i16, @as(*const [2]u8, @ptrCast(self.memory[start..end])), std.builtin.Endian.little); const raw_value = std.mem.readInt(i16, @as(*const [2]u8, @ptrCast(self.memory[start..end])), std.builtin.Endian.little);
try self.stack.append(.{ .i32 = @intCast(@as(i32, raw_value)) }); try self.stack.append(allocator, .{ .i32 = @intCast(@as(i32, raw_value)) });
}, },
.i32_load16_u => { .i32_load16_u => {
const start = index.memarg.offset + @as(u32, @intCast(self.stack.pop().?.i32)); const start = index.memarg.offset + @as(u32, @intCast(self.stack.pop().?.i32));
const end = start + @sizeOf(u16); const end = start + @sizeOf(u16);
const raw_value = std.mem.readInt(u16, @as(*const [2]u8, @ptrCast(self.memory[start..end])), std.builtin.Endian.little); const raw_value = std.mem.readInt(u16, @as(*const [2]u8, @ptrCast(self.memory[start..end])), std.builtin.Endian.little);
try self.stack.append(.{ .i32 = @intCast(@as(u32, raw_value)) }); try self.stack.append(allocator, .{ .i32 = @intCast(@as(u32, raw_value)) });
}, },
.i64_load8_s => { .i64_load8_s => {
const start = index.memarg.offset + @as(u32, @intCast(self.stack.pop().?.i32)); const start = index.memarg.offset + @as(u32, @intCast(self.stack.pop().?.i32));
const end = start + @sizeOf(i8); const end = start + @sizeOf(i8);
const raw_value = std.mem.readInt(i8, @as(*const [1]u8, @ptrCast(self.memory[start..end])), std.builtin.Endian.little); const raw_value = std.mem.readInt(i8, @as(*const [1]u8, @ptrCast(self.memory[start..end])), std.builtin.Endian.little);
try self.stack.append(.{ .i64 = @intCast(@as(i64, raw_value)) }); try self.stack.append(allocator, .{ .i64 = @intCast(@as(i64, raw_value)) });
}, },
.i64_load8_u => { .i64_load8_u => {
const start = index.memarg.offset + @as(u32, @intCast(self.stack.pop().?.i32)); const start = index.memarg.offset + @as(u32, @intCast(self.stack.pop().?.i32));
const end = start + @sizeOf(u8); const end = start + @sizeOf(u8);
const raw_value = std.mem.readInt(u8, @as(*const [1]u8, @ptrCast(self.memory[start..end])), std.builtin.Endian.little); const raw_value = std.mem.readInt(u8, @as(*const [1]u8, @ptrCast(self.memory[start..end])), std.builtin.Endian.little);
try self.stack.append(.{ .i64 = @intCast(@as(u64, raw_value)) }); try self.stack.append(allocator, .{ .i64 = @intCast(@as(u64, raw_value)) });
}, },
.i64_load16_s => { .i64_load16_s => {
const start = index.memarg.offset + @as(u32, @intCast(self.stack.pop().?.i32)); const start = index.memarg.offset + @as(u32, @intCast(self.stack.pop().?.i32));
const end = start + @sizeOf(i16); const end = start + @sizeOf(i16);
const raw_value = std.mem.readInt(i16, @as(*const [2]u8, @ptrCast(self.memory[start..end])), std.builtin.Endian.little); const raw_value = std.mem.readInt(i16, @as(*const [2]u8, @ptrCast(self.memory[start..end])), std.builtin.Endian.little);
try self.stack.append(.{ .i64 = @intCast(@as(i64, raw_value)) }); try self.stack.append(allocator, .{ .i64 = @intCast(@as(i64, raw_value)) });
}, },
.i64_load16_u => { .i64_load16_u => {
const start = index.memarg.offset + @as(u32, @intCast(self.stack.pop().?.i32)); const start = index.memarg.offset + @as(u32, @intCast(self.stack.pop().?.i32));
const end = start + @sizeOf(u16); const end = start + @sizeOf(u16);
const raw_value = std.mem.readInt(u16, @as(*const [2]u8, @ptrCast(self.memory[start..end])), std.builtin.Endian.little); const raw_value = std.mem.readInt(u16, @as(*const [2]u8, @ptrCast(self.memory[start..end])), std.builtin.Endian.little);
try self.stack.append(.{ .i64 = @intCast(@as(u64, raw_value)) }); try self.stack.append(allocator, .{ .i64 = @intCast(@as(u64, raw_value)) });
}, },
.i64_load32_s => { .i64_load32_s => {
const start = index.memarg.offset + @as(u32, @intCast(self.stack.pop().?.i32)); const start = index.memarg.offset + @as(u32, @intCast(self.stack.pop().?.i32));
const end = start + @sizeOf(i32); const end = start + @sizeOf(i32);
const raw_value = std.mem.readInt(i32, @as(*const [4]u8, @ptrCast(self.memory[start..end])), std.builtin.Endian.little); const raw_value = std.mem.readInt(i32, @as(*const [4]u8, @ptrCast(self.memory[start..end])), std.builtin.Endian.little);
try self.stack.append(.{ .i64 = @intCast(@as(i64, raw_value)) }); try self.stack.append(allocator, .{ .i64 = @intCast(@as(i64, raw_value)) });
}, },
.i64_load32_u => { .i64_load32_u => {
const start = index.memarg.offset + @as(u32, @intCast(self.stack.pop().?.i32)); const start = index.memarg.offset + @as(u32, @intCast(self.stack.pop().?.i32));
const end = start + @sizeOf(u32); const end = start + @sizeOf(u32);
const raw_value = std.mem.readInt(u32, @as(*const [4]u8, @ptrCast(self.memory[start..end])), std.builtin.Endian.little); const raw_value = std.mem.readInt(u32, @as(*const [4]u8, @ptrCast(self.memory[start..end])), std.builtin.Endian.little);
try self.stack.append(.{ .i64 = @intCast(@as(u64, raw_value)) }); try self.stack.append(allocator, .{ .i64 = @intCast(@as(u64, raw_value)) });
}, },
.i32_store => { .i32_store => {
const val = std.mem.nativeToLittle(i32, self.stack.pop().?.i32); const val = std.mem.nativeToLittle(i32, self.stack.pop().?.i32);
@ -424,7 +424,7 @@ pub const Runtime = struct {
}, },
.memorysize => { .memorysize => {
try self.stack.append(.{ .i32 = @intCast(self.memory.len / Parser.PAGE_SIZE) }); try self.stack.append(allocator, .{ .i32 = @intCast(self.memory.len / Parser.PAGE_SIZE) });
}, },
.memorygrow => { .memorygrow => {
const newPages = self.stack.pop().?.i32; const newPages = self.stack.pop().?.i32;
@ -434,7 +434,7 @@ pub const Runtime = struct {
} }
const oldPages: i32 = @intCast(self.memory.len / Parser.PAGE_SIZE); const oldPages: i32 = @intCast(self.memory.len / Parser.PAGE_SIZE);
self.memory = try allocator.realloc(self.memory, newSize * Parser.PAGE_SIZE); self.memory = try allocator.realloc(self.memory, newSize * Parser.PAGE_SIZE);
try self.stack.append(.{ .i32 = oldPages }); try self.stack.append(allocator, .{ .i32 = oldPages });
}, },
// TODO(luccie): We need passive memory for this // TODO(luccie): We need passive memory for this
.memoryinit => @panic("UNIMPLEMENTED"), .memoryinit => @panic("UNIMPLEMENTED"),
@ -453,218 +453,218 @@ pub const Runtime = struct {
}, },
.i32_const => { .i32_const => {
try self.stack.append(.{ .i32 = frame.code.indices[frame.program_counter].i32 }); try self.stack.append(allocator, .{ .i32 = frame.code.indices[frame.program_counter].i32 });
}, },
.i64_const => { .i64_const => {
try self.stack.append(.{ .i64 = frame.code.indices[frame.program_counter].i64 }); try self.stack.append(allocator, .{ .i64 = frame.code.indices[frame.program_counter].i64 });
}, },
.f32_const => { .f32_const => {
try self.stack.append(.{ .f32 = frame.code.indices[frame.program_counter].f32 }); try self.stack.append(allocator, .{ .f32 = frame.code.indices[frame.program_counter].f32 });
}, },
.f64_const => { .f64_const => {
try self.stack.append(.{ .f64 = frame.code.indices[frame.program_counter].f64 }); try self.stack.append(allocator, .{ .f64 = frame.code.indices[frame.program_counter].f64 });
}, },
.i32_eqz => { .i32_eqz => {
const val = self.stack.pop().?.i32; const val = self.stack.pop().?.i32;
try self.stack.append(.{ .i32 = @intFromBool(val == 0) }); try self.stack.append(allocator, .{ .i32 = @intFromBool(val == 0) });
}, },
.i32_eq => { .i32_eq => {
const a = self.stack.pop().?.i32; const a = self.stack.pop().?.i32;
const b = self.stack.pop().?.i32; const b = self.stack.pop().?.i32;
try self.stack.append(.{ .i32 = @intFromBool(a == b) }); try self.stack.append(allocator, .{ .i32 = @intFromBool(a == b) });
}, },
.i32_ne => { .i32_ne => {
const a = self.stack.pop().?.i32; const a = self.stack.pop().?.i32;
const b = self.stack.pop().?.i32; const b = self.stack.pop().?.i32;
try self.stack.append(.{ .i32 = @intFromBool(a != b) }); try self.stack.append(allocator, .{ .i32 = @intFromBool(a != b) });
}, },
.i32_lt_s => { .i32_lt_s => {
const a = self.stack.pop().?.i32; const a = self.stack.pop().?.i32;
const b = self.stack.pop().?.i32; const b = self.stack.pop().?.i32;
try self.stack.append(.{ .i32 = @intFromBool(b < a) }); try self.stack.append(allocator, .{ .i32 = @intFromBool(b < a) });
}, },
.i32_lt_u => { .i32_lt_u => {
const a = @as(u32, @bitCast(self.stack.pop().?.i32)); const a = @as(u32, @bitCast(self.stack.pop().?.i32));
const b = @as(u32, @bitCast(self.stack.pop().?.i32)); const b = @as(u32, @bitCast(self.stack.pop().?.i32));
try self.stack.append(.{ .i32 = @intFromBool(b < a) }); try self.stack.append(allocator, .{ .i32 = @intFromBool(b < a) });
}, },
.i32_gt_s => { .i32_gt_s => {
const a = self.stack.pop().?.i32; const a = self.stack.pop().?.i32;
const b = self.stack.pop().?.i32; const b = self.stack.pop().?.i32;
try self.stack.append(.{ .i32 = @intFromBool(b > a) }); try self.stack.append(allocator, .{ .i32 = @intFromBool(b > a) });
}, },
.i32_gt_u => { .i32_gt_u => {
const a = @as(u32, @bitCast(self.stack.pop().?.i32)); const a = @as(u32, @bitCast(self.stack.pop().?.i32));
const b = @as(u32, @bitCast(self.stack.pop().?.i32)); const b = @as(u32, @bitCast(self.stack.pop().?.i32));
try self.stack.append(.{ .i32 = @intFromBool(b > a) }); try self.stack.append(allocator, .{ .i32 = @intFromBool(b > a) });
}, },
.i32_le_s => { .i32_le_s => {
const a = self.stack.pop().?.i32; const a = self.stack.pop().?.i32;
const b = self.stack.pop().?.i32; const b = self.stack.pop().?.i32;
try self.stack.append(.{ .i32 = @intFromBool(b <= a) }); try self.stack.append(allocator, .{ .i32 = @intFromBool(b <= a) });
}, },
.i32_le_u => { .i32_le_u => {
const a = @as(u32, @bitCast(self.stack.pop().?.i32)); const a = @as(u32, @bitCast(self.stack.pop().?.i32));
const b = @as(u32, @bitCast(self.stack.pop().?.i32)); const b = @as(u32, @bitCast(self.stack.pop().?.i32));
try self.stack.append(.{ .i32 = @intFromBool(b <= a) }); try self.stack.append(allocator, .{ .i32 = @intFromBool(b <= a) });
}, },
.i32_ge_s => { .i32_ge_s => {
const a = self.stack.pop().?.i32; const a = self.stack.pop().?.i32;
const b = self.stack.pop().?.i32; const b = self.stack.pop().?.i32;
try self.stack.append(.{ .i32 = @intFromBool(b >= a) }); try self.stack.append(allocator, .{ .i32 = @intFromBool(b >= a) });
}, },
.i32_ge_u => { .i32_ge_u => {
const a = @as(u32, @bitCast(self.stack.pop().?.i32)); const a = @as(u32, @bitCast(self.stack.pop().?.i32));
const b = @as(u32, @bitCast(self.stack.pop().?.i32)); const b = @as(u32, @bitCast(self.stack.pop().?.i32));
try self.stack.append(.{ .i32 = @intFromBool(b >= a) }); try self.stack.append(allocator, .{ .i32 = @intFromBool(b >= a) });
}, },
.i64_eqz => { .i64_eqz => {
const val = self.stack.pop().?.i64; const val = self.stack.pop().?.i64;
try self.stack.append(.{ .i32 = @intFromBool(val == 0) }); try self.stack.append(allocator, .{ .i32 = @intFromBool(val == 0) });
}, },
.i64_eq => { .i64_eq => {
const a = self.stack.pop().?.i64; const a = self.stack.pop().?.i64;
const b = self.stack.pop().?.i64; const b = self.stack.pop().?.i64;
try self.stack.append(.{ .i32 = @intFromBool(a == b) }); try self.stack.append(allocator, .{ .i32 = @intFromBool(a == b) });
}, },
.i64_ne => { .i64_ne => {
const a = self.stack.pop().?.i64; const a = self.stack.pop().?.i64;
const b = self.stack.pop().?.i64; const b = self.stack.pop().?.i64;
try self.stack.append(.{ .i32 = @intFromBool(a != b) }); try self.stack.append(allocator, .{ .i32 = @intFromBool(a != b) });
}, },
.i64_lt_s => { .i64_lt_s => {
const a = self.stack.pop().?.i64; const a = self.stack.pop().?.i64;
const b = self.stack.pop().?.i64; const b = self.stack.pop().?.i64;
try self.stack.append(.{ .i32 = @intFromBool(b < a) }); try self.stack.append(allocator, .{ .i32 = @intFromBool(b < a) });
}, },
.i64_lt_u => { .i64_lt_u => {
const a = @as(u64, @bitCast(self.stack.pop().?.i64)); const a = @as(u64, @bitCast(self.stack.pop().?.i64));
const b = @as(u64, @bitCast(self.stack.pop().?.i64)); const b = @as(u64, @bitCast(self.stack.pop().?.i64));
try self.stack.append(.{ .i32 = @intFromBool(b < a) }); try self.stack.append(allocator, .{ .i32 = @intFromBool(b < a) });
}, },
.i64_gt_s => { .i64_gt_s => {
const a = self.stack.pop().?.i64; const a = self.stack.pop().?.i64;
const b = self.stack.pop().?.i64; const b = self.stack.pop().?.i64;
try self.stack.append(.{ .i32 = @intFromBool(b > a) }); try self.stack.append(allocator, .{ .i32 = @intFromBool(b > a) });
}, },
.i64_gt_u => { .i64_gt_u => {
const a = @as(u64, @bitCast(self.stack.pop().?.i64)); const a = @as(u64, @bitCast(self.stack.pop().?.i64));
const b = @as(u64, @bitCast(self.stack.pop().?.i64)); const b = @as(u64, @bitCast(self.stack.pop().?.i64));
try self.stack.append(.{ .i32 = @intFromBool(b > a) }); try self.stack.append(allocator, .{ .i32 = @intFromBool(b > a) });
}, },
.i64_le_s => { .i64_le_s => {
const a = self.stack.pop().?.i64; const a = self.stack.pop().?.i64;
const b = self.stack.pop().?.i64; const b = self.stack.pop().?.i64;
try self.stack.append(.{ .i32 = @intFromBool(b <= a) }); try self.stack.append(allocator, .{ .i32 = @intFromBool(b <= a) });
}, },
.i64_le_u => { .i64_le_u => {
const a = @as(u64, @bitCast(self.stack.pop().?.i64)); const a = @as(u64, @bitCast(self.stack.pop().?.i64));
const b = @as(u64, @bitCast(self.stack.pop().?.i64)); const b = @as(u64, @bitCast(self.stack.pop().?.i64));
try self.stack.append(.{ .i32 = @intFromBool(b <= a) }); try self.stack.append(allocator, .{ .i32 = @intFromBool(b <= a) });
}, },
.i64_ge_s => { .i64_ge_s => {
const a = self.stack.pop().?.i64; const a = self.stack.pop().?.i64;
const b = self.stack.pop().?.i64; const b = self.stack.pop().?.i64;
try self.stack.append(.{ .i32 = @intFromBool(b >= a) }); try self.stack.append(allocator, .{ .i32 = @intFromBool(b >= a) });
}, },
.i64_ge_u => { .i64_ge_u => {
const a = @as(u64, @bitCast(self.stack.pop().?.i64)); const a = @as(u64, @bitCast(self.stack.pop().?.i64));
const b = @as(u64, @bitCast(self.stack.pop().?.i64)); const b = @as(u64, @bitCast(self.stack.pop().?.i64));
try self.stack.append(.{ .i32 = @intFromBool(b >= a) }); try self.stack.append(allocator, .{ .i32 = @intFromBool(b >= a) });
}, },
.f32_eq => { .f32_eq => {
const a = self.stack.pop().?.f32; const a = self.stack.pop().?.f32;
const b = self.stack.pop().?.f32; const b = self.stack.pop().?.f32;
try self.stack.append(.{ .i32 = @intFromBool(a == b) }); try self.stack.append(allocator, .{ .i32 = @intFromBool(a == b) });
}, },
.f32_ne => { .f32_ne => {
const a = self.stack.pop().?.f32; const a = self.stack.pop().?.f32;
const b = self.stack.pop().?.f32; const b = self.stack.pop().?.f32;
try self.stack.append(.{ .i32 = @intFromBool(a != b) }); try self.stack.append(allocator, .{ .i32 = @intFromBool(a != b) });
}, },
.f32_lt => { .f32_lt => {
const a = self.stack.pop().?.f32; const a = self.stack.pop().?.f32;
const b = self.stack.pop().?.f32; const b = self.stack.pop().?.f32;
try self.stack.append(.{ .i32 = @intFromBool(b < a) }); try self.stack.append(allocator, .{ .i32 = @intFromBool(b < a) });
}, },
.f32_gt => { .f32_gt => {
const a = self.stack.pop().?.f32; const a = self.stack.pop().?.f32;
const b = self.stack.pop().?.f32; const b = self.stack.pop().?.f32;
try self.stack.append(.{ .i32 = @intFromBool(b > a) }); try self.stack.append(allocator, .{ .i32 = @intFromBool(b > a) });
}, },
.f32_le => { .f32_le => {
const a = self.stack.pop().?.f32; const a = self.stack.pop().?.f32;
const b = self.stack.pop().?.f32; const b = self.stack.pop().?.f32;
try self.stack.append(.{ .i32 = @intFromBool(b <= a) }); try self.stack.append(allocator, .{ .i32 = @intFromBool(b <= a) });
}, },
.f32_ge => { .f32_ge => {
const a = self.stack.pop().?.f32; const a = self.stack.pop().?.f32;
const b = self.stack.pop().?.f32; const b = self.stack.pop().?.f32;
try self.stack.append(.{ .i32 = @intFromBool(b >= a) }); try self.stack.append(allocator, .{ .i32 = @intFromBool(b >= a) });
}, },
.f64_eq => { .f64_eq => {
const a = self.stack.pop().?.f64; const a = self.stack.pop().?.f64;
const b = self.stack.pop().?.f64; const b = self.stack.pop().?.f64;
try self.stack.append(.{ .i32 = @intFromBool(a == b) }); try self.stack.append(allocator, .{ .i32 = @intFromBool(a == b) });
}, },
.f64_ne => { .f64_ne => {
const a = self.stack.pop().?.f64; const a = self.stack.pop().?.f64;
const b = self.stack.pop().?.f64; const b = self.stack.pop().?.f64;
try self.stack.append(.{ .i32 = @intFromBool(a != b) }); try self.stack.append(allocator, .{ .i32 = @intFromBool(a != b) });
}, },
.f64_lt => { .f64_lt => {
const a = self.stack.pop().?.f64; const a = self.stack.pop().?.f64;
const b = self.stack.pop().?.f64; const b = self.stack.pop().?.f64;
try self.stack.append(.{ .i32 = @intFromBool(b < a) }); try self.stack.append(allocator, .{ .i32 = @intFromBool(b < a) });
}, },
.f64_gt => { .f64_gt => {
const a = self.stack.pop().?.f64; const a = self.stack.pop().?.f64;
const b = self.stack.pop().?.f64; const b = self.stack.pop().?.f64;
try self.stack.append(.{ .i32 = @intFromBool(b > a) }); try self.stack.append(allocator, .{ .i32 = @intFromBool(b > a) });
}, },
.f64_le => { .f64_le => {
const a = self.stack.pop().?.f64; const a = self.stack.pop().?.f64;
const b = self.stack.pop().?.f64; const b = self.stack.pop().?.f64;
try self.stack.append(.{ .i32 = @intFromBool(b <= a) }); try self.stack.append(allocator, .{ .i32 = @intFromBool(b <= a) });
}, },
.f64_ge => { .f64_ge => {
const a = self.stack.pop().?.f64; const a = self.stack.pop().?.f64;
const b = self.stack.pop().?.f64; const b = self.stack.pop().?.f64;
try self.stack.append(.{ .i32 = @intFromBool(b >= a) }); try self.stack.append(allocator, .{ .i32 = @intFromBool(b >= a) });
}, },
.i32_clz => { .i32_clz => {
try self.stack.append(.{ .i32 = @clz(self.stack.pop().?.i32) }); try self.stack.append(allocator, .{ .i32 = @clz(self.stack.pop().?.i32) });
}, },
.i32_ctz => { .i32_ctz => {
try self.stack.append(.{ .i32 = @ctz(self.stack.pop().?.i32) }); try self.stack.append(allocator, .{ .i32 = @ctz(self.stack.pop().?.i32) });
}, },
.i32_popcnt => { .i32_popcnt => {
try self.stack.append(.{ .i32 = @popCount(self.stack.pop().?.i32) }); try self.stack.append(allocator, .{ .i32 = @popCount(self.stack.pop().?.i32) });
}, },
.i32_add => { .i32_add => {
const a = self.stack.pop().?.i32; const a = self.stack.pop().?.i32;
const b = self.stack.pop().?.i32; const b = self.stack.pop().?.i32;
try self.stack.append(.{ .i32 = a + b }); try self.stack.append(allocator, .{ .i32 = a + b });
}, },
.i32_sub => { .i32_sub => {
const a = self.stack.pop().?.i32; const a = self.stack.pop().?.i32;
const b = self.stack.pop().?.i32; const b = self.stack.pop().?.i32;
try self.stack.append(.{ .i32 = b - a }); try self.stack.append(allocator, .{ .i32 = b - a });
}, },
.i32_and => { .i32_and => {
const a = self.stack.pop().?.i32; const a = self.stack.pop().?.i32;
const b = self.stack.pop().?.i32; const b = self.stack.pop().?.i32;
try self.stack.append(.{ .i32 = a & b }); try self.stack.append(allocator, .{ .i32 = a & b });
}, },
.i32_mul => { .i32_mul => {
const a = self.stack.pop().?.i32; const a = self.stack.pop().?.i32;
const b = self.stack.pop().?.i32; const b = self.stack.pop().?.i32;
try self.stack.append(.{ .i32 = a * b }); try self.stack.append(allocator, .{ .i32 = a * b });
}, },
.i32_div_s => { .i32_div_s => {
const a_signed = self.stack.pop().?.i32; const a_signed = self.stack.pop().?.i32;
@ -672,7 +672,7 @@ pub const Runtime = struct {
if (a_signed == 0){ if (a_signed == 0){
std.debug.panic("Division by 0 error!\n", .{}); std.debug.panic("Division by 0 error!\n", .{});
} }
try self.stack.append(.{ .i32 = @divTrunc(b_signed, a_signed) }); try self.stack.append(allocator, .{ .i32 = @divTrunc(b_signed, a_signed) });
}, },
.i32_div_u => { .i32_div_u => {
const a_unsigned = @as(u32, @bitCast(self.stack.pop().?.i32)); const a_unsigned = @as(u32, @bitCast(self.stack.pop().?.i32));
@ -680,7 +680,7 @@ pub const Runtime = struct {
if (a_unsigned == 0){ if (a_unsigned == 0){
std.debug.panic("Division by 0 error!\n", .{}); std.debug.panic("Division by 0 error!\n", .{});
} }
try self.stack.append(.{ .i32 = @bitCast(b_unsigned / a_unsigned) }); try self.stack.append(allocator, .{ .i32 = @bitCast(b_unsigned / a_unsigned) });
}, },
.i32_rem_s => { .i32_rem_s => {
const divisor = self.stack.pop().?.i32; const divisor = self.stack.pop().?.i32;
@ -688,7 +688,7 @@ pub const Runtime = struct {
if (divisor == 0) { if (divisor == 0) {
std.debug.panic("Divide by 0\n", .{}); std.debug.panic("Divide by 0\n", .{});
} }
try self.stack.append(.{ .i32 = @intCast(dividend - divisor * @divTrunc(dividend, divisor)) }); try self.stack.append(allocator, .{ .i32 = @intCast(dividend - divisor * @divTrunc(dividend, divisor)) });
}, },
.i32_rem_u => { .i32_rem_u => {
const divisor = @as(u32, @bitCast(self.stack.pop().?.i32)); const divisor = @as(u32, @bitCast(self.stack.pop().?.i32));
@ -696,67 +696,67 @@ pub const Runtime = struct {
if (divisor == 0) { if (divisor == 0) {
std.debug.panic("Divide by 0\n", .{}); std.debug.panic("Divide by 0\n", .{});
} }
try self.stack.append(.{ .i32 = @intCast(dividend - divisor * @divTrunc(dividend, divisor)) }); try self.stack.append(allocator, .{ .i32 = @intCast(dividend - divisor * @divTrunc(dividend, divisor)) });
}, },
.i32_or => { .i32_or => {
const a = self.stack.pop().?.i32; const a = self.stack.pop().?.i32;
const b = self.stack.pop().?.i32; const b = self.stack.pop().?.i32;
try self.stack.append(.{ .i32 = a | b }); try self.stack.append(allocator, .{ .i32 = a | b });
}, },
.i32_xor => { .i32_xor => {
const a = self.stack.pop().?.i32; const a = self.stack.pop().?.i32;
const b = self.stack.pop().?.i32; const b = self.stack.pop().?.i32;
try self.stack.append(.{ .i32 = a ^ b }); try self.stack.append(allocator, .{ .i32 = a ^ b });
}, },
.i32_shl => { .i32_shl => {
const a = self.stack.pop().?.i32; const a = self.stack.pop().?.i32;
const b = self.stack.pop().?.i32; const b = self.stack.pop().?.i32;
try self.stack.append(.{ .i32 = (b << @as(u5, @intCast(a))) }); try self.stack.append(allocator, .{ .i32 = (b << @as(u5, @intCast(a))) });
}, },
.i32_shr_s => { .i32_shr_s => {
const a = self.stack.pop().?.i32; const a = self.stack.pop().?.i32;
const b = self.stack.pop().?.i32; const b = self.stack.pop().?.i32;
try self.stack.append(.{ .i32 = (b >> @as(u5, @intCast(a))) }); try self.stack.append(allocator, .{ .i32 = (b >> @as(u5, @intCast(a))) });
}, },
.i32_shr_u => { .i32_shr_u => {
const a = @as(u32, @bitCast(self.stack.pop().?.i32)); const a = @as(u32, @bitCast(self.stack.pop().?.i32));
const b = @as(u32, @bitCast(self.stack.pop().?.i32)); const b = @as(u32, @bitCast(self.stack.pop().?.i32));
try self.stack.append(.{ .i32 = @bitCast(b >> @as(u5, @intCast(a))) }); try self.stack.append(allocator, .{ .i32 = @bitCast(b >> @as(u5, @intCast(a))) });
}, },
.i32_rotl => { .i32_rotl => {
const a = @as(u32, @bitCast(self.stack.pop().?.i32)); const a = @as(u32, @bitCast(self.stack.pop().?.i32));
const b = @as(u32, @bitCast(self.stack.pop().?.i32)); const b = @as(u32, @bitCast(self.stack.pop().?.i32));
try self.stack.append(.{ .i32 = @intCast(std.math.rotl(u32, b, a)) }); try self.stack.append(allocator, .{ .i32 = @intCast(std.math.rotl(u32, b, a)) });
}, },
.i32_rotr => { .i32_rotr => {
const a = @as(u32, @bitCast(self.stack.pop().?.i32)); const a = @as(u32, @bitCast(self.stack.pop().?.i32));
const b = @as(u32, @bitCast(self.stack.pop().?.i32)); const b = @as(u32, @bitCast(self.stack.pop().?.i32));
try self.stack.append(.{ .i32 = @intCast(std.math.rotr(u32, b, a)) }); try self.stack.append(allocator, .{ .i32 = @intCast(std.math.rotr(u32, b, a)) });
}, },
.i64_clz => { .i64_clz => {
try self.stack.append(.{ .i64 = @clz(self.stack.pop().?.i64) }); try self.stack.append(allocator, .{ .i64 = @clz(self.stack.pop().?.i64) });
}, },
.i64_ctz => { .i64_ctz => {
try self.stack.append(.{ .i64 = @ctz(self.stack.pop().?.i64) }); try self.stack.append(allocator, .{ .i64 = @ctz(self.stack.pop().?.i64) });
}, },
.i64_popcnt => { .i64_popcnt => {
try self.stack.append(.{ .i64 = @popCount(self.stack.pop().?.i64) }); try self.stack.append(allocator, .{ .i64 = @popCount(self.stack.pop().?.i64) });
}, },
.i64_add => { .i64_add => {
const a = self.stack.pop().?.i64; const a = self.stack.pop().?.i64;
const b = self.stack.pop().?.i64; const b = self.stack.pop().?.i64;
try self.stack.append(.{ .i64 = a + b }); try self.stack.append(allocator, .{ .i64 = a + b });
}, },
.i64_sub => { .i64_sub => {
const a = self.stack.pop().?.i64; const a = self.stack.pop().?.i64;
const b = self.stack.pop().?.i64; const b = self.stack.pop().?.i64;
try self.stack.append(.{ .i64 = b - a }); try self.stack.append(allocator, .{ .i64 = b - a });
}, },
.i64_mul => { .i64_mul => {
const a = self.stack.pop().?.i64; const a = self.stack.pop().?.i64;
const b = self.stack.pop().?.i64; const b = self.stack.pop().?.i64;
try self.stack.append(.{ .i64 = a * b }); try self.stack.append(allocator, .{ .i64 = a * b });
}, },
.i64_div_s => { .i64_div_s => {
const a_signed = self.stack.pop().?.i64; const a_signed = self.stack.pop().?.i64;
@ -764,7 +764,7 @@ pub const Runtime = struct {
if (a_signed == 0){ if (a_signed == 0){
std.debug.panic("Division by 0 error!\n", .{}); std.debug.panic("Division by 0 error!\n", .{});
} }
try self.stack.append(.{ .i64 = @divTrunc(b_signed, a_signed) }); try self.stack.append(allocator, .{ .i64 = @divTrunc(b_signed, a_signed) });
}, },
.i64_div_u => { .i64_div_u => {
const a_unsigned = @as(u64, @bitCast(self.stack.pop().?.i64)); const a_unsigned = @as(u64, @bitCast(self.stack.pop().?.i64));
@ -772,7 +772,7 @@ pub const Runtime = struct {
if (a_unsigned == 0){ if (a_unsigned == 0){
std.debug.panic("Division by 0 error!\n", .{}); std.debug.panic("Division by 0 error!\n", .{});
} }
try self.stack.append(.{ .i64 = @bitCast(b_unsigned / a_unsigned) }); try self.stack.append(allocator, .{ .i64 = @bitCast(b_unsigned / a_unsigned) });
}, },
.i64_rem_s => { .i64_rem_s => {
const divisor = self.stack.pop().?.i64; const divisor = self.stack.pop().?.i64;
@ -780,7 +780,7 @@ pub const Runtime = struct {
if (divisor == 0) { if (divisor == 0) {
std.debug.panic("Divide by 0\n", .{}); std.debug.panic("Divide by 0\n", .{});
} }
try self.stack.append(.{ .i64 = @intCast(dividend - divisor * @divTrunc(dividend, divisor)) }); try self.stack.append(allocator, .{ .i64 = @intCast(dividend - divisor * @divTrunc(dividend, divisor)) });
}, },
.i64_rem_u => { .i64_rem_u => {
const divisor = @as(u64, @bitCast(self.stack.pop().?.i64)); const divisor = @as(u64, @bitCast(self.stack.pop().?.i64));
@ -788,86 +788,86 @@ pub const Runtime = struct {
if (divisor == 0) { if (divisor == 0) {
std.debug.panic("Divide by 0\n", .{}); std.debug.panic("Divide by 0\n", .{});
} }
try self.stack.append(.{ .i64 = @bitCast(dividend - divisor * @divTrunc(dividend, divisor)) }); try self.stack.append(allocator, .{ .i64 = @bitCast(dividend - divisor * @divTrunc(dividend, divisor)) });
}, },
.i64_and => { .i64_and => {
const a = self.stack.pop().?.i64; const a = self.stack.pop().?.i64;
const b = self.stack.pop().?.i64; const b = self.stack.pop().?.i64;
try self.stack.append(.{ .i64 = a & b }); try self.stack.append(allocator, .{ .i64 = a & b });
}, },
.i64_or => { .i64_or => {
const a = self.stack.pop().?.i64; const a = self.stack.pop().?.i64;
const b = self.stack.pop().?.i64; const b = self.stack.pop().?.i64;
try self.stack.append(.{ .i64 = a | b }); try self.stack.append(allocator, .{ .i64 = a | b });
}, },
.i64_xor => { .i64_xor => {
const a = self.stack.pop().?.i64; const a = self.stack.pop().?.i64;
const b = self.stack.pop().?.i64; const b = self.stack.pop().?.i64;
try self.stack.append(.{ .i64 = a ^ b }); try self.stack.append(allocator, .{ .i64 = a ^ b });
}, },
.i64_shl => { .i64_shl => {
const a = self.stack.pop().?.i64; const a = self.stack.pop().?.i64;
const b = self.stack.pop().?.i64; const b = self.stack.pop().?.i64;
try self.stack.append(.{ .i64 = @intCast(b << @as(u6, @intCast(a))) }); try self.stack.append(allocator, .{ .i64 = @intCast(b << @as(u6, @intCast(a))) });
}, },
.i64_shr_s => { .i64_shr_s => {
const a = self.stack.pop().?.i64; const a = self.stack.pop().?.i64;
const b = self.stack.pop().?.i64; const b = self.stack.pop().?.i64;
try self.stack.append(.{ .i64 = @intCast(b >> @as(u6, @intCast(a))) }); try self.stack.append(allocator, .{ .i64 = @intCast(b >> @as(u6, @intCast(a))) });
}, },
.i64_shr_u => { .i64_shr_u => {
const a = @as(u64, @bitCast(self.stack.pop().?.i64)); const a = @as(u64, @bitCast(self.stack.pop().?.i64));
const b = @as(u64, @bitCast(self.stack.pop().?.i64)); const b = @as(u64, @bitCast(self.stack.pop().?.i64));
try self.stack.append(.{ .i64 = @bitCast(b >> @as(u6, @intCast(a))) }); try self.stack.append(allocator, .{ .i64 = @bitCast(b >> @as(u6, @intCast(a))) });
}, },
.i64_rotl => { .i64_rotl => {
const a = @as(u64, @bitCast(self.stack.pop().?.i64)); const a = @as(u64, @bitCast(self.stack.pop().?.i64));
const b = @as(u64, @bitCast(self.stack.pop().?.i64)); const b = @as(u64, @bitCast(self.stack.pop().?.i64));
try self.stack.append(.{ .i64 = @intCast(std.math.rotl(u64, b, a)) }); try self.stack.append(allocator, .{ .i64 = @intCast(std.math.rotl(u64, b, a)) });
}, },
.i64_rotr => { .i64_rotr => {
const a = @as(u64, @bitCast(self.stack.pop().?.i64)); const a = @as(u64, @bitCast(self.stack.pop().?.i64));
const b = @as(u64, @bitCast(self.stack.pop().?.i64)); const b = @as(u64, @bitCast(self.stack.pop().?.i64));
try self.stack.append(.{ .i64 = @intCast(std.math.rotr(u64, b, a)) }); try self.stack.append(allocator, .{ .i64 = @intCast(std.math.rotr(u64, b, a)) });
}, },
// The value 0x7FFFFFFF here represents the bitmask that masks everything except for the IEEE754 32 bit precision sign bit // The value 0x7FFFFFFF here represents the bitmask that masks everything except for the IEEE754 32 bit precision sign bit
.f32_abs => { .f32_abs => {
try self.stack.append(.{ .f32 = @bitCast(@as(u32, @bitCast(self.stack.pop().?.f32)) & 0x7FFFFFFF) }); try self.stack.append(allocator, .{ .f32 = @bitCast(@as(u32, @bitCast(self.stack.pop().?.f32)) & 0x7FFFFFFF) });
}, },
// The value 0x80000000 here represents the bitmask that only masks the IEEE754 32 bit precision sign bit // The value 0x80000000 here represents the bitmask that only masks the IEEE754 32 bit precision sign bit
.f32_neg => { .f32_neg => {
try self.stack.append(.{ .f32 = @bitCast(@as(u32, @bitCast(self.stack.pop().?.f32)) ^ 0x80000000) }); try self.stack.append(allocator, .{ .f32 = @bitCast(@as(u32, @bitCast(self.stack.pop().?.f32)) ^ 0x80000000) });
}, },
.f32_ceil => { .f32_ceil => {
try self.stack.append(.{ .f32 = @ceil(self.stack.pop().?.f32) }); try self.stack.append(allocator, .{ .f32 = @ceil(self.stack.pop().?.f32) });
}, },
.f32_floor => { .f32_floor => {
try self.stack.append(.{ .f32 = @floor(self.stack.pop().?.f32) }); try self.stack.append(allocator, .{ .f32 = @floor(self.stack.pop().?.f32) });
}, },
.f32_trunc => { .f32_trunc => {
try self.stack.append(.{ .f32 = @trunc(self.stack.pop().?.f32) }); try self.stack.append(allocator, .{ .f32 = @trunc(self.stack.pop().?.f32) });
}, },
.f32_nearest => { .f32_nearest => {
try self.stack.append(.{ .f32 = @round(self.stack.pop().?.f32) }); try self.stack.append(allocator, .{ .f32 = @round(self.stack.pop().?.f32) });
}, },
.f32_sqrt => { .f32_sqrt => {
try self.stack.append(.{ .f32 = @sqrt(self.stack.pop().?.f32) }); try self.stack.append(allocator, .{ .f32 = @sqrt(self.stack.pop().?.f32) });
}, },
.f32_add => { .f32_add => {
const a = self.stack.pop().?.f32; const a = self.stack.pop().?.f32;
const b = self.stack.pop().?.f32; const b = self.stack.pop().?.f32;
try self.stack.append(.{ .f32 = a + b }); try self.stack.append(allocator, .{ .f32 = a + b });
}, },
.f32_sub => { .f32_sub => {
const a = self.stack.pop().?.f32; const a = self.stack.pop().?.f32;
const b = self.stack.pop().?.f32; const b = self.stack.pop().?.f32;
try self.stack.append(.{ .f32 = b - a }); try self.stack.append(allocator, .{ .f32 = b - a });
}, },
.f32_mul => { .f32_mul => {
const a = self.stack.pop().?.f32; const a = self.stack.pop().?.f32;
const b = self.stack.pop().?.f32; const b = self.stack.pop().?.f32;
try self.stack.append(.{ .f32 = a * b }); try self.stack.append(allocator, .{ .f32 = a * b });
}, },
.f32_div => { .f32_div => {
const a = self.stack.pop().?.f32; const a = self.stack.pop().?.f32;
@ -875,205 +875,205 @@ pub const Runtime = struct {
if (a == 0){ if (a == 0){
std.debug.panic("[ERROR]: Division by 0\n", .{}); std.debug.panic("[ERROR]: Division by 0\n", .{});
} }
try self.stack.append(.{ .f32 = b / a }); try self.stack.append(allocator, .{ .f32 = b / a });
}, },
.f32_min => { .f32_min => {
const a = self.stack.pop().?.f32; const a = self.stack.pop().?.f32;
const b = self.stack.pop().?.f32; const b = self.stack.pop().?.f32;
try self.stack.append(.{ .f32 = @min(a, b) }); try self.stack.append(allocator, .{ .f32 = @min(a, b) });
}, },
.f32_max => { .f32_max => {
const a = self.stack.pop().?.f32; const a = self.stack.pop().?.f32;
const b = self.stack.pop().?.f32; const b = self.stack.pop().?.f32;
try self.stack.append(.{ .f32 = @max(a, b) }); try self.stack.append(allocator, .{ .f32 = @max(a, b) });
}, },
// See f32_abs and f32_neg for explainations behind these magic values // See f32_abs and f32_neg for explainations behind these magic values
.f32_copysign => { .f32_copysign => {
const a = self.stack.pop().?.f32; const a = self.stack.pop().?.f32;
const b = self.stack.pop().?.f32; const b = self.stack.pop().?.f32;
try self.stack.append(.{ .f32 = @bitCast((@as(u32, @bitCast(b)) & 0x7FFFFFFF) | (@as(u32, @bitCast(a)) & 0x80000000)) }); try self.stack.append(allocator, .{ .f32 = @bitCast((@as(u32, @bitCast(b)) & 0x7FFFFFFF) | (@as(u32, @bitCast(a)) & 0x80000000)) });
}, },
// The value 0x7FFFFFFFFFFFFFFF here represents the bitmask that masks everything except for the IEEE754 64 bit precision sign bit // The value 0x7FFFFFFFFFFFFFFF here represents the bitmask that masks everything except for the IEEE754 64 bit precision sign bit
.f64_abs => { .f64_abs => {
try self.stack.append(.{ .f64 = @bitCast(@as(u64, @bitCast(self.stack.pop().?.f64)) & 0x7FFFFFFFFFFFFFFF) }); try self.stack.append(allocator, .{ .f64 = @bitCast(@as(u64, @bitCast(self.stack.pop().?.f64)) & 0x7FFFFFFFFFFFFFFF) });
}, },
// The value 0x8000000000000000 here represents the bitmask that only masks the IEEE754 64 bit precision sign bit // The value 0x8000000000000000 here represents the bitmask that only masks the IEEE754 64 bit precision sign bit
.f64_neg => { .f64_neg => {
try self.stack.append(.{ .f64 = @bitCast(@as(u64, @bitCast(self.stack.pop().?.f64)) ^ 0x8000000000000000) }); try self.stack.append(allocator, .{ .f64 = @bitCast(@as(u64, @bitCast(self.stack.pop().?.f64)) ^ 0x8000000000000000) });
}, },
.f64_ceil => { .f64_ceil => {
try self.stack.append(.{ .f64 = @ceil(self.stack.pop().?.f64) }); try self.stack.append(allocator, .{ .f64 = @ceil(self.stack.pop().?.f64) });
}, },
.f64_floor => { .f64_floor => {
try self.stack.append(.{ .f64 = @floor(self.stack.pop().?.f64) }); try self.stack.append(allocator, .{ .f64 = @floor(self.stack.pop().?.f64) });
}, },
.f64_trunc => { .f64_trunc => {
try self.stack.append(.{ .f64 = @trunc(self.stack.pop().?.f64) }); try self.stack.append(allocator, .{ .f64 = @trunc(self.stack.pop().?.f64) });
}, },
.f64_nearest => { .f64_nearest => {
try self.stack.append(.{ .f64 = @round(self.stack.pop().?.f64) }); try self.stack.append(allocator, .{ .f64 = @round(self.stack.pop().?.f64) });
}, },
.f64_sqrt => { .f64_sqrt => {
try self.stack.append(.{ .f64 = @sqrt(self.stack.pop().?.f64) }); try self.stack.append(allocator, .{ .f64 = @sqrt(self.stack.pop().?.f64) });
}, },
.f64_add => { .f64_add => {
const a = self.stack.pop().?.f64; const a = self.stack.pop().?.f64;
const b = self.stack.pop().?.f64; const b = self.stack.pop().?.f64;
try self.stack.append(.{ .f64 = a + b }); try self.stack.append(allocator, .{ .f64 = a + b });
}, },
.f64_sub => { .f64_sub => {
const a = self.stack.pop().?.f64; const a = self.stack.pop().?.f64;
const b = self.stack.pop().?.f64; const b = self.stack.pop().?.f64;
try self.stack.append(.{ .f64 = b - a }); try self.stack.append(allocator, .{ .f64 = b - a });
}, },
.f64_mul => { .f64_mul => {
const a = self.stack.pop().?.f64; const a = self.stack.pop().?.f64;
const b = self.stack.pop().?.f64; const b = self.stack.pop().?.f64;
try self.stack.append(.{ .f64 = a * b }); try self.stack.append(allocator, .{ .f64 = a * b });
}, },
.f64_div => { .f64_div => {
const a = self.stack.pop().?.f64; const a = self.stack.pop().?.f64;
const b = self.stack.pop().?.f64; const b = self.stack.pop().?.f64;
try self.stack.append(.{ .f64 = b / a }); try self.stack.append(allocator, .{ .f64 = b / a });
}, },
.f64_min => { .f64_min => {
const a = self.stack.pop().?.f64; const a = self.stack.pop().?.f64;
const b = self.stack.pop().?.f64; const b = self.stack.pop().?.f64;
try self.stack.append(.{ .f64 = @min(a, b) }); try self.stack.append(allocator, .{ .f64 = @min(a, b) });
}, },
.f64_max => { .f64_max => {
const a = self.stack.pop().?.f64; const a = self.stack.pop().?.f64;
const b = self.stack.pop().?.f64; const b = self.stack.pop().?.f64;
try self.stack.append(.{ .f64 = @max(a, b) }); try self.stack.append(allocator, .{ .f64 = @max(a, b) });
}, },
// See f64_abs and f64_neg for explainations behind these magic values // See f64_abs and f64_neg for explainations behind these magic values
.f64_copysign => { .f64_copysign => {
const a = self.stack.pop().?.f64; const a = self.stack.pop().?.f64;
const b = self.stack.pop().?.f64; const b = self.stack.pop().?.f64;
try self.stack.append(.{ .f64 = @bitCast((@as(u64, @bitCast(b)) & 0x7FFFFFFFFFFFFFFF) | (@as(u64, @bitCast(a)) & 0x8000000000000000)) }); try self.stack.append(allocator, .{ .f64 = @bitCast((@as(u64, @bitCast(b)) & 0x7FFFFFFFFFFFFFFF) | (@as(u64, @bitCast(a)) & 0x8000000000000000)) });
}, },
.i32_wrap_i64 => { .i32_wrap_i64 => {
try self.stack.append(.{ .i32 = @truncate(self.stack.pop().?.i64) }); try self.stack.append(allocator, .{ .i32 = @truncate(self.stack.pop().?.i64) });
}, },
.i32_trunc_f32_s => { .i32_trunc_f32_s => {
try self.stack.append(.{ .i32 = @intFromFloat(self.stack.pop().?.f32) }); try self.stack.append(allocator, .{ .i32 = @intFromFloat(self.stack.pop().?.f32) });
}, },
.i32_trunc_f32_u => { .i32_trunc_f32_u => {
try self.stack.append(.{ .i32 = @bitCast(@as(u32, @intFromFloat(self.stack.pop().?.f32))) }); try self.stack.append(allocator, .{ .i32 = @bitCast(@as(u32, @intFromFloat(self.stack.pop().?.f32))) });
}, },
.i32_trunc_f64_s => { .i32_trunc_f64_s => {
try self.stack.append(.{ .i32 = @intFromFloat(self.stack.pop().?.f64) }); try self.stack.append(allocator, .{ .i32 = @intFromFloat(self.stack.pop().?.f64) });
}, },
.i32_trunc_f64_u => { .i32_trunc_f64_u => {
try self.stack.append(.{ .i32 = @bitCast(@as(u32, @intFromFloat(self.stack.pop().?.f64))) }); try self.stack.append(allocator, .{ .i32 = @bitCast(@as(u32, @intFromFloat(self.stack.pop().?.f64))) });
}, },
.i64_extend_i32_s => { .i64_extend_i32_s => {
try self.stack.append(.{ .i64 = @as(i64, self.stack.pop().?.i32) }); try self.stack.append(allocator, .{ .i64 = @as(i64, self.stack.pop().?.i32) });
}, },
.i64_extend_i32_u => { .i64_extend_i32_u => {
try self.stack.append(.{ .i64 = @as(i64, @as(u32, @bitCast(self.stack.pop().?.i32))) }); try self.stack.append(allocator, .{ .i64 = @as(i64, @as(u32, @bitCast(self.stack.pop().?.i32))) });
}, },
.i64_trunc_f32_s => { .i64_trunc_f32_s => {
try self.stack.append(.{ .i64 = @intFromFloat(self.stack.pop().?.f32) }); try self.stack.append(allocator, .{ .i64 = @intFromFloat(self.stack.pop().?.f32) });
}, },
.i64_trunc_f32_u => { .i64_trunc_f32_u => {
try self.stack.append(.{ .i64 = @bitCast(@as(u64, @intFromFloat(self.stack.pop().?.f32))) }); try self.stack.append(allocator, .{ .i64 = @bitCast(@as(u64, @intFromFloat(self.stack.pop().?.f32))) });
}, },
.i64_trunc_f64_s => { .i64_trunc_f64_s => {
try self.stack.append(.{ .i64 = @intFromFloat(self.stack.pop().?.f64) }); try self.stack.append(allocator, .{ .i64 = @intFromFloat(self.stack.pop().?.f64) });
}, },
.i64_trunc_f64_u => { .i64_trunc_f64_u => {
try self.stack.append(.{ .i64 = @bitCast(@as(u64, @intFromFloat(self.stack.pop().?.f64))) }); try self.stack.append(allocator, .{ .i64 = @bitCast(@as(u64, @intFromFloat(self.stack.pop().?.f64))) });
}, },
.f32_convert_i32_s => { .f32_convert_i32_s => {
try self.stack.append(.{ .f32 = @floatFromInt(self.stack.pop().?.i32) }); try self.stack.append(allocator, .{ .f32 = @floatFromInt(self.stack.pop().?.i32) });
}, },
.f32_convert_i32_u => { .f32_convert_i32_u => {
try self.stack.append(.{ .f32 = @floatFromInt(@as(u32, @bitCast(self.stack.pop().?.i32))) }); try self.stack.append(allocator, .{ .f32 = @floatFromInt(@as(u32, @bitCast(self.stack.pop().?.i32))) });
}, },
.f32_convert_i64_s => { .f32_convert_i64_s => {
try self.stack.append(.{ .f32 = @floatFromInt(self.stack.pop().?.i64) }); try self.stack.append(allocator, .{ .f32 = @floatFromInt(self.stack.pop().?.i64) });
}, },
.f32_convert_i64_u => { .f32_convert_i64_u => {
try self.stack.append(.{ .f32 = @floatFromInt(@as(u64, @bitCast(self.stack.pop().?.i64))) }); try self.stack.append(allocator, .{ .f32 = @floatFromInt(@as(u64, @bitCast(self.stack.pop().?.i64))) });
}, },
.f32_demote_f64 => { .f32_demote_f64 => {
try self.stack.append(.{ .f32 = @floatCast(self.stack.pop().?.f64) }); try self.stack.append(allocator, .{ .f32 = @floatCast(self.stack.pop().?.f64) });
}, },
.f64_convert_i32_s => { .f64_convert_i32_s => {
try self.stack.append(.{ .f64 = @floatFromInt(self.stack.pop().?.i32) }); try self.stack.append(allocator, .{ .f64 = @floatFromInt(self.stack.pop().?.i32) });
}, },
.f64_convert_i32_u => { .f64_convert_i32_u => {
try self.stack.append(.{ .f64 = @floatFromInt(@as(u32, @bitCast(self.stack.pop().?.i32))) }); try self.stack.append(allocator, .{ .f64 = @floatFromInt(@as(u32, @bitCast(self.stack.pop().?.i32))) });
}, },
.f64_convert_i64_s => { .f64_convert_i64_s => {
try self.stack.append(.{ .f64 = @floatFromInt(self.stack.pop().?.i64) }); try self.stack.append(allocator, .{ .f64 = @floatFromInt(self.stack.pop().?.i64) });
}, },
.f64_convert_i64_u => { .f64_convert_i64_u => {
try self.stack.append(.{ .f64 = @floatFromInt(@as(u64, @bitCast(self.stack.pop().?.i64))) }); try self.stack.append(allocator, .{ .f64 = @floatFromInt(@as(u64, @bitCast(self.stack.pop().?.i64))) });
}, },
.f64_promote_f32 => { .f64_promote_f32 => {
try self.stack.append(.{ .f64 = @floatCast(self.stack.pop().?.f32) }); try self.stack.append(allocator, .{ .f64 = @floatCast(self.stack.pop().?.f32) });
}, },
.i32_reinterpret_f32 => { .i32_reinterpret_f32 => {
try self.stack.append(.{ .i32 = @bitCast(self.stack.pop().?.f32) }); try self.stack.append(allocator, .{ .i32 = @bitCast(self.stack.pop().?.f32) });
}, },
.i64_reinterpret_f64 => { .i64_reinterpret_f64 => {
try self.stack.append(.{ .i64 = @bitCast(self.stack.pop().?.f64) }); try self.stack.append(allocator, .{ .i64 = @bitCast(self.stack.pop().?.f64) });
}, },
.f32_reinterpret_i32 => { .f32_reinterpret_i32 => {
try self.stack.append(.{ .f32 = @bitCast(self.stack.pop().?.i32) }); try self.stack.append(allocator, .{ .f32 = @bitCast(self.stack.pop().?.i32) });
}, },
.f64_reinterpret_i64 => { .f64_reinterpret_i64 => {
try self.stack.append(.{ .f64 = @bitCast(self.stack.pop().?.i64) }); try self.stack.append(allocator, .{ .f64 = @bitCast(self.stack.pop().?.i64) });
}, },
.i32_extend8_s => { .i32_extend8_s => {
const val = self.stack.pop().?.i32; const val = self.stack.pop().?.i32;
try self.stack.append(.{ .i32 = @as(i32, @as(i8, @truncate(val))) }); try self.stack.append(allocator, .{ .i32 = @as(i32, @as(i8, @truncate(val))) });
}, },
.i32_extend16_s => { .i32_extend16_s => {
const val = self.stack.pop().?.i32; const val = self.stack.pop().?.i32;
try self.stack.append(.{ .i32 = @as(i32, @as(i16, @truncate(val))) }); try self.stack.append(allocator, .{ .i32 = @as(i32, @as(i16, @truncate(val))) });
}, },
.i64_extend8_s => { .i64_extend8_s => {
const val = self.stack.pop().?.i64; const val = self.stack.pop().?.i64;
try self.stack.append(.{ .i64 = @as(i64, @as(i8, @truncate(val))) }); try self.stack.append(allocator, .{ .i64 = @as(i64, @as(i8, @truncate(val))) });
}, },
.i64_extend16_s => { .i64_extend16_s => {
const val = self.stack.pop().?.i64; const val = self.stack.pop().?.i64;
try self.stack.append(.{ .i64 = @as(i64, @as(i16, @truncate(val))) }); try self.stack.append(allocator, .{ .i64 = @as(i64, @as(i16, @truncate(val))) });
}, },
.i64_extend32_s => { .i64_extend32_s => {
const val = self.stack.pop().?.i64; const val = self.stack.pop().?.i64;
try self.stack.append(.{ .i64 = @as(i64, @as(i32, @truncate(val))) }); try self.stack.append(allocator, .{ .i64 = @as(i64, @as(i32, @truncate(val))) });
}, },
.i32_trunc_sat_f32_s => { .i32_trunc_sat_f32_s => {
try self.stack.append(.{ .i32 = @intFromFloat(self.stack.pop().?.f32) }); try self.stack.append(allocator, .{ .i32 = @intFromFloat(self.stack.pop().?.f32) });
}, },
.i32_trunc_sat_f32_u => { .i32_trunc_sat_f32_u => {
try self.stack.append(.{ .i32 = @bitCast(@as(u32, @intFromFloat(self.stack.pop().?.f32))) }); try self.stack.append(allocator, .{ .i32 = @bitCast(@as(u32, @intFromFloat(self.stack.pop().?.f32))) });
}, },
.i32_trunc_sat_f64_s => { .i32_trunc_sat_f64_s => {
try self.stack.append(.{ .i32 = @intFromFloat(self.stack.pop().?.f64) }); try self.stack.append(allocator, .{ .i32 = @intFromFloat(self.stack.pop().?.f64) });
}, },
.i32_trunc_sat_f64_u => { .i32_trunc_sat_f64_u => {
try self.stack.append(.{ .i32 = @bitCast(@as(u32, @intFromFloat(self.stack.pop().?.f64))) }); try self.stack.append(allocator, .{ .i32 = @bitCast(@as(u32, @intFromFloat(self.stack.pop().?.f64))) });
}, },
.i64_trunc_sat_f32_s => { .i64_trunc_sat_f32_s => {
try self.stack.append(.{ .i64 = @intFromFloat(self.stack.pop().?.f32) }); try self.stack.append(allocator, .{ .i64 = @intFromFloat(self.stack.pop().?.f32) });
}, },
.i64_trunc_sat_f32_u => { .i64_trunc_sat_f32_u => {
try self.stack.append(.{ .i64 = @bitCast(@as(u64, @intFromFloat(self.stack.pop().?.f32))) }); try self.stack.append(allocator, .{ .i64 = @bitCast(@as(u64, @intFromFloat(self.stack.pop().?.f32))) });
}, },
.i64_trunc_sat_f64_s => { .i64_trunc_sat_f64_s => {
try self.stack.append(.{ .i64 = @intFromFloat(self.stack.pop().?.f64) }); try self.stack.append(allocator, .{ .i64 = @intFromFloat(self.stack.pop().?.f64) });
}, },
.i64_trunc_sat_f64_u => { .i64_trunc_sat_f64_u => {
try self.stack.append(.{ .i64 = @bitCast(@as(u64, @intFromFloat(self.stack.pop().?.f64))) }); try self.stack.append(allocator, .{ .i64 = @bitCast(@as(u64, @intFromFloat(self.stack.pop().?.f64))) });
}, },
.vecinst => @panic("UNIMPLEMENTED"), .vecinst => @panic("UNIMPLEMENTED"),
@ -1166,7 +1166,7 @@ pub const Runtime = struct {
} }
const ret = func.?.func(self, parameters); const ret = func.?.func(self, parameters);
if (ret != null){ if (ret != null){
try self.stack.append(ret.?); try self.stack.append(allocator, ret.?);
} }
}, },
} }
@ -1176,12 +1176,12 @@ pub const Runtime = struct {
pub fn handleGlobalInit(allocator: Allocator, ir: IR) !Value { pub fn handleGlobalInit(allocator: Allocator, ir: IR) !Value {
var instruction_pointer: usize = 0; var instruction_pointer: usize = 0;
var stack = try std.ArrayList(Value).initCapacity(allocator, 10); var stack = try std.ArrayList(Value).initCapacity(allocator, 10);
defer stack.deinit(); defer stack.deinit(allocator);
while (instruction_pointer < ir.opcodes.len) { while (instruction_pointer < ir.opcodes.len) {
const opcode: IR.Opcode = ir.opcodes[instruction_pointer]; const opcode: IR.Opcode = ir.opcodes[instruction_pointer];
const index = ir.indices[instruction_pointer]; const index = ir.indices[instruction_pointer];
switch (opcode) { switch (opcode) {
.i32_const => try stack.append(Value{ .i32 = index.i32 }), .i32_const => try stack.append(allocator, Value{ .i32 = index.i32 }),
else => { else => {
std.debug.panic("TODO: Handle opcode {any}\n", .{opcode}); std.debug.panic("TODO: Handle opcode {any}\n", .{opcode});
}, },

4
src/rendering/Device.zig
View file

@ -210,8 +210,8 @@ pub fn bindVertexBuffer(self: Self, buffer: vk.Buffer, frame: usize) void {
c.vkCmdBindVertexBuffers(self.command_buffers[frame], 0, 1, &buffer.handle, &offset); c.vkCmdBindVertexBuffers(self.command_buffers[frame], 0, 1, &buffer.handle, &offset);
} }
pub fn bindDescriptorSets(self: Self, pipeline: vk.GraphicsPipeline, frame: usize, texture: usize) void { pub fn bindDescriptorSets(self: Self, pipeline: vk.GraphicsPipeline, frame: usize) void {
const sets = [_]c.VkDescriptorSet {pipeline.descriptor_set, pipeline.textures.items[texture]}; const sets = [_]c.VkDescriptorSet {pipeline.descriptor_set, pipeline.textures};
c.vkCmdBindDescriptorSets(self.command_buffers[frame], c.VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline.layout, 0, 2, sets[0..].ptr, 0, null); c.vkCmdBindDescriptorSets(self.command_buffers[frame], c.VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline.layout, 0, 2, sets[0..].ptr, 0, null);
} }

157
src/rendering/GraphicsPipeline.zig
View file

@ -28,7 +28,7 @@ view_pos_memory: [*c]u8,
view_pos_buffer: vk.Buffer, view_pos_buffer: vk.Buffer,
diffuse_sampler: vk.Sampler, diffuse_sampler: vk.Sampler,
specular_sampler: vk.Sampler, specular_sampler: vk.Sampler,
textures: std.ArrayList(c.VkDescriptorSet), textures: c.VkDescriptorSet,
directional_light: *lights.DirectionalLight, directional_light: *lights.DirectionalLight,
directional_light_buffer: vk.Buffer, directional_light_buffer: vk.Buffer,
point_lights: []lights.PointLight, point_lights: []lights.PointLight,
@ -45,13 +45,17 @@ pub const Builder = struct {
current_index: u32 = 0, current_index: u32 = 0,
vertex_buffers: std.ArrayList(vk.Buffer), vertex_buffers: std.ArrayList(vk.Buffer),
index_buffers: std.ArrayList(vk.Buffer), index_buffers: std.ArrayList(vk.Buffer),
diffuse_textures: std.ArrayList(vk.Texture),
specular_textures: std.ArrayList(vk.Texture),
device: vk.Device, device: vk.Device,
allocator: Allocator, allocator: Allocator,
pub fn init(allocator: Allocator, device: vk.Device) Builder { pub fn init(allocator: Allocator, device: vk.Device) Builder {
return .{ return .{
.vertex_buffers = std.ArrayList(vk.Buffer).init(allocator), .vertex_buffers = std.ArrayList(vk.Buffer).empty,
.index_buffers = std.ArrayList(vk.Buffer).init(allocator), .index_buffers = std.ArrayList(vk.Buffer).empty,
.diffuse_textures = std.ArrayList(vk.Texture).empty,
.specular_textures = std.ArrayList(vk.Texture).empty,
.device = device, .device = device,
.allocator = allocator, .allocator = allocator,
}; };
@ -66,8 +70,8 @@ pub const Builder = struct {
const index_cursor = self.current_index; const index_cursor = self.current_index;
self.current_vertex += @intCast(vertex_buffer.size); self.current_vertex += @intCast(vertex_buffer.size);
self.current_index += @intCast(index_buffer.size); self.current_index += @intCast(index_buffer.size);
try self.vertex_buffers.append(vertex_buffer); try self.vertex_buffers.append(self.allocator, vertex_buffer);
try self.index_buffers.append(index_buffer); try self.index_buffers.append(self.allocator, index_buffer);
return .{ return .{
.vertex_buffer = vertex_cursor, .vertex_buffer = vertex_cursor,
@ -76,9 +80,21 @@ pub const Builder = struct {
}; };
} }
pub fn addTexture(self: *Builder, diffuse: Texture, specular: Texture) !usize {
const index = self.diffuse_textures.items.len;
try self.diffuse_textures.append(self.allocator, diffuse);
try self.specular_textures.append(self.allocator, specular);
return index;
}
pub fn build(self: *Builder, swapchain: vk.Swapchain, render_pass: vk.RenderPass, vertex_shader: c.VkShaderModule, fragment_shader: c.VkShaderModule) !Self { pub fn build(self: *Builder, swapchain: vk.Swapchain, render_pass: vk.RenderPass, vertex_shader: c.VkShaderModule, fragment_shader: c.VkShaderModule) !Self {
const vertex_buffer, const index_buffer = try self.createBuffers(); const vertex_buffer, const index_buffer = try self.createBuffers();
return Self.init(self.allocator, self.device, swapchain, render_pass, vertex_shader, fragment_shader, vertex_buffer, index_buffer); const pipeline = try Self.init(self.allocator, self.device, swapchain, render_pass, vertex_shader, fragment_shader, vertex_buffer, index_buffer, self.diffuse_textures, self.specular_textures);
self.diffuse_textures.deinit(self.allocator);
self.specular_textures.deinit(self.allocator);
return pipeline;
} }
pub fn createBuffers(self: *Builder) !struct { vk.Buffer, vk.Buffer } { pub fn createBuffers(self: *Builder) !struct { vk.Buffer, vk.Buffer } {
@ -100,8 +116,8 @@ pub const Builder = struct {
buffer.deinit(self.device.handle); buffer.deinit(self.device.handle);
} }
self.vertex_buffers.deinit(); self.vertex_buffers.deinit(self.allocator);
self.index_buffers.deinit(); self.index_buffers.deinit(self.allocator);
return .{ return .{
vertex_buffer, vertex_buffer,
@ -197,7 +213,7 @@ pub const Builder = struct {
}; };
pub fn init(allocator: Allocator, device: vk.Device, swapchain: vk.Swapchain, render_pass: vk.RenderPass, vertex_shader: c.VkShaderModule, fragment_shader: c.VkShaderModule, vertex_buffer: vk.Buffer, index_buffer: vk.Buffer) !Self { pub fn init(allocator: Allocator, device: vk.Device, swapchain: vk.Swapchain, render_pass: vk.RenderPass, vertex_shader: c.VkShaderModule, fragment_shader: c.VkShaderModule, vertex_buffer: vk.Buffer, index_buffer: vk.Buffer, diffuse_textures: std.ArrayList(vk.Texture), specular_textures: std.ArrayList(vk.Texture)) !Self {
const vertex_shader_stage_info: c.VkPipelineShaderStageCreateInfo = .{ const vertex_shader_stage_info: c.VkPipelineShaderStageCreateInfo = .{
.sType = c.VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, .sType = c.VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
.stage = c.VK_SHADER_STAGE_VERTEX_BIT, .stage = c.VK_SHADER_STAGE_VERTEX_BIT,
@ -339,14 +355,14 @@ pub fn init(allocator: Allocator, device: vk.Device, swapchain: vk.Swapchain, re
const diffuse_sampler_binding = c.VkDescriptorSetLayoutBinding{ const diffuse_sampler_binding = c.VkDescriptorSetLayoutBinding{
.binding = 0, .binding = 0,
.descriptorType = c.VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, .descriptorType = c.VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
.descriptorCount = 1, .descriptorCount = @intCast(diffuse_textures.items.len),
.stageFlags = c.VK_SHADER_STAGE_FRAGMENT_BIT, .stageFlags = c.VK_SHADER_STAGE_FRAGMENT_BIT,
}; };
const specular_sampler_binding = c.VkDescriptorSetLayoutBinding{ const specular_sampler_binding = c.VkDescriptorSetLayoutBinding{
.binding = 1, .binding = 1,
.descriptorType = c.VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, .descriptorType = c.VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
.descriptorCount = 1, .descriptorCount = @intCast(specular_textures.items.len),
.stageFlags = c.VK_SHADER_STAGE_FRAGMENT_BIT, .stageFlags = c.VK_SHADER_STAGE_FRAGMENT_BIT,
}; };
@ -440,7 +456,7 @@ pub fn init(allocator: Allocator, device: vk.Device, swapchain: vk.Swapchain, re
const sampler_size = c.VkDescriptorPoolSize{ const sampler_size = c.VkDescriptorPoolSize{
.type = c.VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, .type = c.VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
.descriptorCount = 2, .descriptorCount = @intCast(diffuse_textures.items.len + specular_textures.items.len),
}; };
const transforms_size = c.VkDescriptorPoolSize{ const transforms_size = c.VkDescriptorPoolSize{
@ -634,6 +650,61 @@ pub fn init(allocator: Allocator, device: vk.Device, swapchain: vk.Swapchain, re
c.vkUpdateDescriptorSets(device.handle, 1, &write_view_pos_descriptor_set, 0, null); c.vkUpdateDescriptorSets(device.handle, 1, &write_view_pos_descriptor_set, 0, null);
const diffuse_sampler = try vk.Sampler.init(device, .linear);
const specular_sampler = try vk.Sampler.init(device, .linear);
const texture_descriptor_allocate_info = c.VkDescriptorSetAllocateInfo{
.sType = c.VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO,
.descriptorPool = descriptor_pool,
.descriptorSetCount = 1,
.pSetLayouts = &texture_descriptor_set_layout,
};
var texture_descriptor_set: c.VkDescriptorSet = undefined;
try vk.mapError(c.vkAllocateDescriptorSets(device.handle, &texture_descriptor_allocate_info, &texture_descriptor_set));
var diffuse_infos = std.ArrayList(c.VkDescriptorImageInfo).empty;
defer diffuse_infos.deinit(allocator);
var specular_infos = std.ArrayList(c.VkDescriptorImageInfo).empty;
defer specular_infos.deinit(allocator);
for (diffuse_textures.items, specular_textures.items) |diffuse, specular| {
try diffuse_infos.append(allocator, .{
.imageLayout = c.VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
.imageView = diffuse.image_view,
.sampler = diffuse_sampler.handle,
});
try specular_infos.append(allocator, .{
.imageLayout = c.VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
.imageView = specular.image_view,
.sampler = specular_sampler.handle,
});
}
const write_diffuse_descriptor_set = c.VkWriteDescriptorSet{
.sType = c.VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
.dstSet = texture_descriptor_set,
.dstBinding = 0,
.dstArrayElement = 0,
.descriptorCount = @intCast(diffuse_infos.items.len),
.descriptorType = c.VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
.pImageInfo = diffuse_infos.items[0..].ptr,
};
const write_specular_descriptor_set = c.VkWriteDescriptorSet{
.sType = c.VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
.dstSet = texture_descriptor_set,
.dstBinding = 1,
.dstArrayElement = 0,
.descriptorCount = @intCast(specular_infos.items.len),
.descriptorType = c.VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
.pImageInfo = specular_infos.items[0..].ptr,
};
const writes = [_]c.VkWriteDescriptorSet {write_diffuse_descriptor_set, write_specular_descriptor_set};
c.vkUpdateDescriptorSets(device.handle, 2, writes[0..].ptr, 0, null);
return Self{ return Self{
.layout = layout, .layout = layout,
.handle = pipeline, .handle = pipeline,
@ -647,83 +718,27 @@ pub fn init(allocator: Allocator, device: vk.Device, swapchain: vk.Swapchain, re
.view_pos_memory = view_pos_data, .view_pos_memory = view_pos_data,
.view_pos_buffer = view_pos_buffer, .view_pos_buffer = view_pos_buffer,
.transform_buffer = transform_buffer, .transform_buffer = transform_buffer,
.diffuse_sampler = try vk.Sampler.init(device, .linear), .textures = texture_descriptor_set,
.specular_sampler = try vk.Sampler.init(device, .linear),
.textures = std.ArrayList(c.VkDescriptorSet).init(allocator),
.vertex_buffer = vertex_buffer, .vertex_buffer = vertex_buffer,
.index_buffer = index_buffer, .index_buffer = index_buffer,
.directional_light = directional_light, .directional_light = directional_light,
.directional_light_buffer = directional_light_buffer, .directional_light_buffer = directional_light_buffer,
.point_lights = point_lights, .point_lights = point_lights,
.point_lights_buffer = point_lights_buffer, .point_lights_buffer = point_lights_buffer,
.diffuse_sampler = diffuse_sampler,
.specular_sampler = specular_sampler,
.device = device, .device = device,
.swapchain = swapchain, .swapchain = swapchain,
.render_pass = render_pass, .render_pass = render_pass,
}; };
} }
pub fn addTexture(self: *Self, device: anytype, texture: Texture, diffuse: Texture) !usize {
var set_layouts = [_]c.VkDescriptorSetLayout{self.texture_set_layout};
const descriptor_allocate_info = c.VkDescriptorSetAllocateInfo{
.sType = c.VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO,
.descriptorPool = self.descriptor_pool,
.descriptorSetCount = 1,
.pSetLayouts = set_layouts[0..].ptr,
};
var descriptor_set: c.VkDescriptorSet = undefined;
try vk.mapError(c.vkAllocateDescriptorSets(device.handle, &descriptor_allocate_info, &descriptor_set));
const texture_info: c.VkDescriptorImageInfo = .{
.imageLayout = c.VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
.imageView = texture.image_view,
.sampler = self.diffuse_sampler.handle,
};
const diffuse_info: c.VkDescriptorImageInfo = .{
.imageLayout = c.VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
.imageView = diffuse.image_view,
.sampler = self.specular_sampler.handle,
};
const write_texture_descriptor_set = c.VkWriteDescriptorSet{
.sType = c.VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
.dstSet = descriptor_set,
.dstBinding = 0,
.dstArrayElement = 0,
.descriptorCount = 1,
.descriptorType = c.VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
.pImageInfo = &texture_info,
};
const write_diffuse_descriptor_set = c.VkWriteDescriptorSet{
.sType = c.VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
.dstSet = descriptor_set,
.dstBinding = 1,
.dstArrayElement = 0,
.descriptorCount = 1,
.descriptorType = c.VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
.pImageInfo = &diffuse_info,
};
const writes = [_]c.VkWriteDescriptorSet {write_texture_descriptor_set, write_diffuse_descriptor_set};
c.vkUpdateDescriptorSets(device.handle, 2, writes[0..].ptr, 0, null);
const index = self.textures.items.len;
try self.textures.append(descriptor_set);
return index;
}
pub fn bind(self: Self, device: vk.Device, frame: usize) void { pub fn bind(self: Self, device: vk.Device, frame: usize) void {
std.debug.assert(frame < 2); std.debug.assert(frame < 2);
c.vkCmdBindPipeline(device.command_buffers[frame], c.VK_PIPELINE_BIND_POINT_GRAPHICS, self.handle); c.vkCmdBindPipeline(device.command_buffers[frame], c.VK_PIPELINE_BIND_POINT_GRAPHICS, self.handle);
} }
pub fn deinit(self: Self, device: vk.Device) void { pub fn deinit(self: Self, device: vk.Device) void {
self.textures.deinit();
self.diffuse_sampler.deinit(device); self.diffuse_sampler.deinit(device);
self.specular_sampler.deinit(device); self.specular_sampler.deinit(device);
self.projection_buffer.deinit(device.handle); self.projection_buffer.deinit(device.handle);

22
src/rendering/Mesh.zig
View file

@ -163,10 +163,10 @@ fn createIndexBuffer(device: vk.Device, indices: std.ArrayList(u32)) !vk.Buffer
} }
pub fn terrain(allocator: std.mem.Allocator, device: vk.Device, width: usize, height: usize, resolution: usize) !struct { vk.Buffer, vk.Buffer } { pub fn terrain(allocator: std.mem.Allocator, device: vk.Device, width: usize, height: usize, resolution: usize) !struct { vk.Buffer, vk.Buffer } {
var vertices = std.ArrayList([6]f32).init(allocator); var vertices = std.ArrayList([6]f32).empty;
defer vertices.deinit(); defer vertices.deinit(allocator);
var indices = std.ArrayList(u32).init(allocator); var indices = std.ArrayList(u32).empty;
defer indices.deinit(); defer indices.deinit(allocator);
for (0..width*resolution) |x| { for (0..width*resolution) |x| {
for (0..height*resolution) |z| { for (0..height*resolution) |z| {
@ -176,7 +176,7 @@ pub fn terrain(allocator: std.mem.Allocator, device: vk.Device, width: usize, he
const v = @as(f32, @floatFromInt(z)) / @as(f32, @floatFromInt(width*resolution - 1)); const v = @as(f32, @floatFromInt(z)) / @as(f32, @floatFromInt(width*resolution - 1));
const vertex: [6]f32 = .{offset_x, offset_z, u, v, offset_x, offset_z }; const vertex: [6]f32 = .{offset_x, offset_z, u, v, offset_x, offset_z };
try vertices.append(vertex); try vertices.append(allocator, vertex);
} }
} }
@ -188,13 +188,13 @@ pub fn terrain(allocator: std.mem.Allocator, device: vk.Device, width: usize, he
const bottom_left = @as(u32, @intCast((z+1) * width*resolution + x)); const bottom_left = @as(u32, @intCast((z+1) * width*resolution + x));
const bottom_right = @as(u32, @intCast((z+1) * width*resolution + (x + 1))); const bottom_right = @as(u32, @intCast((z+1) * width*resolution + (x + 1)));
try indices.append(top_left); try indices.append(allocator, top_left);
try indices.append(top_right); try indices.append(allocator, top_right);
try indices.append(bottom_left); try indices.append(allocator, bottom_left);
try indices.append(top_right); try indices.append(allocator, top_right);
try indices.append(bottom_right); try indices.append(allocator, bottom_right);
try indices.append(bottom_left); try indices.append(allocator, bottom_left);
} }
} }

21
src/rendering/Renderer.zig
View file

@ -39,6 +39,15 @@ pub fn init(allocator: Allocator, instance_handle: vk.c.VkInstance, surface_hand
const swapchain = try vk.Swapchain.init(allocator, surface, device, physical_device, render_pass); const swapchain = try vk.Swapchain.init(allocator, surface, device, physical_device, render_pass);
var pipeline_builder = vk.GraphicsPipeline.Builder.init(allocator, device); var pipeline_builder = vk.GraphicsPipeline.Builder.init(allocator, device);
const texture = try Texture.init("assets/textures/container.png", device);
const diffuse = try Texture.init("assets/textures/container_specular.png", device);
_ = try pipeline_builder.addTexture(texture, diffuse);
_ = try pipeline_builder.addTexture(texture, diffuse);
_ = try pipeline_builder.addTexture(texture, diffuse);
_ = try pipeline_builder.addTexture(texture, diffuse);
const mesh = try pipeline_builder.addMesh("assets/models/cube.glb"); const mesh = try pipeline_builder.addMesh("assets/models/cube.glb");
var graphics_pipeline = try pipeline_builder.build(swapchain, render_pass, vertex_shader, fragment_shader); var graphics_pipeline = try pipeline_builder.build(swapchain, render_pass, vertex_shader, fragment_shader);
@ -48,10 +57,7 @@ pub fn init(allocator: Allocator, instance_handle: vk.c.VkInstance, surface_hand
defer device.deinitShader(terrain_fragment_shader); defer device.deinitShader(terrain_fragment_shader);
const terrain_pipeline = try vk.TerrainPipeline.init(graphics_pipeline, terrain_vertex_shader, terrain_fragment_shader); const terrain_pipeline = try vk.TerrainPipeline.init(graphics_pipeline, terrain_vertex_shader, terrain_fragment_shader);
const texture = try Texture.init("assets/textures/container.png", device);
const diffuse = try Texture.init("assets/textures/container_specular.png", device);
_ = try graphics_pipeline.addTexture(device, texture, diffuse);
graphics_pipeline.directional_light.direction = .{-0.2, -1.0, -0.3}; graphics_pipeline.directional_light.direction = .{-0.2, -1.0, -0.3};
graphics_pipeline.directional_light.ambient = .{0.5, 0.5, 0.5}; graphics_pipeline.directional_light.ambient = .{0.5, 0.5, 0.5};
@ -74,11 +80,10 @@ pub fn init(allocator: Allocator, instance_handle: vk.c.VkInstance, surface_hand
graphics_pipeline.point_lights[1].diffuse = .{0.5, 0.5, 0.5}; graphics_pipeline.point_lights[1].diffuse = .{0.5, 0.5, 0.5};
graphics_pipeline.point_lights[1].specular = .{1.0, 1.0, 1.0}; graphics_pipeline.point_lights[1].specular = .{1.0, 1.0, 1.0};
var transforms = std.ArrayList(math.Transform).init(allocator); var transforms = std.ArrayList(math.Transform).empty;
try transforms.append(math.Transform.init(.{0.0, 0.5, 1.0}, .{0.5, 0.5, 0.5}, .{0.0, 0.0, 0.0}));
try transforms.append(math.Transform.init(.{0.0, 0.0, 0.0}, .{0.5, 0.5, 0.5}, .{0.0, 0.0, 0.0}));
try transforms.append(allocator, math.Transform.init(.{0.0, 0.0, 0.0}, .{0.5, 0.5, 0.5}, .{0.0, 0.0, 0.0}));
try transforms.append(allocator, math.Transform.init(.{0.0, 0.5, 1.0}, .{0.5, 0.5, 0.5}, .{0.0, 0.0, 0.0}));
return .{ return .{
.instance = instance, .instance = instance,
@ -130,7 +135,7 @@ pub fn beginGraphics(self: *Self) !void {
self.graphics_pipeline.bind(self.device, self.current_frame); self.graphics_pipeline.bind(self.device, self.current_frame);
self.device.bindVertexBuffer(self.graphics_pipeline.vertex_buffer, self.current_frame); self.device.bindVertexBuffer(self.graphics_pipeline.vertex_buffer, self.current_frame);
self.device.bindIndexBuffer(self.graphics_pipeline.index_buffer, self.current_frame); self.device.bindIndexBuffer(self.graphics_pipeline.index_buffer, self.current_frame);
self.device.bindDescriptorSets(self.graphics_pipeline, self.current_frame, 0); self.device.bindDescriptorSets(self.graphics_pipeline, self.current_frame);
} }
pub fn beginTerrain(self: *Self) !void { pub fn beginTerrain(self: *Self) !void {

4
src/rendering/dynamic_buffer.zig
View file

@ -84,9 +84,9 @@ pub fn DynamicBuffer(comptime T: type) type {
c.vkUpdateDescriptorSets(device.handle, 1, &write_descriptor_set, 0, null); c.vkUpdateDescriptorSets(device.handle, 1, &write_descriptor_set, 0, null);
var free_indices = std.ArrayList(usize).init(allocator); var free_indices = std.ArrayList(usize).empty;
for (0..10) |i| { for (0..10) |i| {
try free_indices.append(i); try free_indices.append(allocator, i);
} }
return .{ return .{

6
src/sideros.zig
View file

@ -143,12 +143,12 @@ export fn sideros_init(init: api.GameInit) callconv(.c) void {
ecs.hooks.addHook(.scroll, systems.zoomCamera) catch @panic("TODO handle this"); ecs.hooks.addHook(.scroll, systems.zoomCamera) catch @panic("TODO handle this");
pool = ecs.Pool.init(allocator, &resources) catch @panic("TODO: Gracefully handle error"); pool = ecs.Pool.init(allocator, &resources) catch @panic("TODO: Gracefully handle error");
// TODO(ernesto): I think this @ptrCast are unavoidable but maybe not? // TODO(ernesto): I think this @ptrCast are unavoidable but maybe not?
renderer = Renderer.init(allocator, @ptrCast(init.instance), @ptrCast(init.surface)) catch @panic("TODO: Gracefully handle error"); renderer = Renderer.init(allocator, @ptrCast(init.instance), @ptrCast(init.surface)) catch |err| std.debug.panic("TODO: Gracefully handle error: {}\n", .{err});
resources.terrain = rendering.Terrain.init(allocator, renderer.device, .{ resources.terrain = rendering.Terrain.init(allocator, renderer.device, .{
.octaves = 4, .octaves = 8,
.lacunarity = 2.0, .lacunarity = 2.0,
.gain = 0.5, .gain = 0.6,
.scale = 30, .scale = 30,
.multiplier = 1.0, .multiplier = 1.0,
.exponent = 1.0, .exponent = 1.0,

6
src/xorg.zig
View file

@ -78,8 +78,8 @@ fn vulkan_init_instance(allocator: std.mem.Allocator, handle: *c.VkInstance) !vo
_ = c.vkEnumerateInstanceLayerProperties(&avaliableLayersCount, availableLayers.ptr); _ = c.vkEnumerateInstanceLayerProperties(&avaliableLayersCount, availableLayers.ptr);
// Every layer we do have we add to this list, if we don't have it no worries just print a message and continue // Every layer we do have we add to this list, if we don't have it no worries just print a message and continue
var newLayers = std.ArrayList([*c]const u8).init(allocator); var newLayers = std.ArrayList([*c]const u8).empty;
defer newLayers.deinit(); defer newLayers.deinit(allocator);
// Loop over layers we want // Loop over layers we want
for (validation_layers) |want_layer| { for (validation_layers) |want_layer| {
var found = false; var found = false;
@ -94,7 +94,7 @@ fn vulkan_init_instance(allocator: std.mem.Allocator, handle: *c.VkInstance) !vo
std.debug.print("WARNING: Compiled in debug mode, but wanted validation layer {s} not found.\n", .{want_layer}); std.debug.print("WARNING: Compiled in debug mode, but wanted validation layer {s} not found.\n", .{want_layer});
std.debug.print("NOTE: Validation layer will be removed from the wanted validation layers\n", .{}); std.debug.print("NOTE: Validation layer will be removed from the wanted validation layers\n", .{});
} else { } else {
try newLayers.append(want_layer); try newLayers.append(allocator, want_layer);
} }
} }