diff --git a/src/opcodes.zig b/src/opcodes.zig index 0644011..5c2813a 100644 --- a/src/opcodes.zig +++ b/src/opcodes.zig @@ -13,6 +13,12 @@ const SpvByte = spv.SpvByte; const SpvWord = spv.SpvWord; const SpvBool = spv.SpvBool; +const MathType = enum { + Float, + SInt, + UInt, +}; + pub const OpCodeFunc = *const fn (std.mem.Allocator, SpvWord, *Runtime) RuntimeError!void; pub const SetupDispatcher = block: { @@ -55,8 +61,8 @@ pub const RuntimeDispatcher = block: { .AccessChain = opAccessChain, .CompositeConstruct = opCompositeConstruct, .CompositeExtract = opCompositeExtract, - .FMul = opFMul, - .IMul = opIMul, + .FMul = maths(.Float).opMul, + .IMul = maths(.SInt).opMul, .Load = opLoad, .Return = opReturn, .Store = opStore, @@ -592,65 +598,56 @@ fn opReturn(_: std.mem.Allocator, _: SpvWord, rt: *Runtime) RuntimeError!void { } } -fn opFMul(_: std.mem.Allocator, _: SpvWord, rt: *Runtime) RuntimeError!void { - const target_type = (rt.results[try rt.it.next()].variant orelse return RuntimeError.InvalidSpirV).Type; - const value = try rt.results[try rt.it.next()].getValue(); - const op1_value = try rt.results[try rt.it.next()].getValue(); - const op2_value = try rt.results[try rt.it.next()].getValue(); +fn maths(comptime T: MathType) type { + return struct { + fn opMul(_: std.mem.Allocator, _: SpvWord, rt: *Runtime) RuntimeError!void { + const target_type = (rt.results[try rt.it.next()].variant orelse return RuntimeError.InvalidSpirV).Type; + const value = try rt.results[try rt.it.next()].getValue(); + const op1_value = try rt.results[try rt.it.next()].getValue(); + const op2_value = try rt.results[try rt.it.next()].getValue(); - const size = sw: switch (target_type) { - .Vector => |v| continue :sw (rt.results[v.components_type_word].variant orelse return RuntimeError.InvalidSpirV).Type, - .Float => |f| f.bit_length, - else => return RuntimeError.InvalidSpirV, - }; + const size = sw: switch (target_type) { + .Vector => |v| continue :sw (rt.results[v.components_type_word].variant orelse return RuntimeError.InvalidSpirV).Type, + .Float => |f| if (T == .Float) f.bit_length else return RuntimeError.InvalidSpirV, + .Int => |i| if (T == .SInt or T == .UInt) i.bit_length else return RuntimeError.InvalidSpirV, + else => return RuntimeError.InvalidSpirV, + }; - const operator = struct { - fn process(bit_count: SpvWord, v: *Result.Value, op1_v: *const Result.Value, op2_v: *const Result.Value) RuntimeError!void { - switch (bit_count) { - 16 => v.Float.float16 = op1_v.Float.float16 * op2_v.Float.float16, - 32 => v.Float.float32 = op1_v.Float.float32 * op2_v.Float.float32, - 64 => v.Float.float64 = op1_v.Float.float64 * op2_v.Float.float64, + const operator = struct { + fn process(bit_count: SpvWord, v: *Result.Value, op1_v: *const Result.Value, op2_v: *const Result.Value) RuntimeError!void { + switch (T) { + .Float => switch (bit_count) { + 16 => v.Float.float16 = op1_v.Float.float16 * op2_v.Float.float16, + 32 => v.Float.float32 = op1_v.Float.float32 * op2_v.Float.float32, + 64 => v.Float.float64 = op1_v.Float.float64 * op2_v.Float.float64, + else => return RuntimeError.InvalidSpirV, + }, + .SInt => switch (bit_count) { + 8 => v.Int.sint8 = @mulWithOverflow(op1_v.Int.sint8, op2_v.Int.sint8)[0], + 16 => v.Int.sint16 = @mulWithOverflow(op1_v.Int.sint16, op2_v.Int.sint16)[0], + 32 => v.Int.sint32 = @mulWithOverflow(op1_v.Int.sint32, op2_v.Int.sint32)[0], + 64 => v.Int.sint64 = @mulWithOverflow(op1_v.Int.sint64, op2_v.Int.sint64)[0], + else => return RuntimeError.InvalidSpirV, + }, + .UInt => switch (bit_count) { + 8 => v.Int.uint8 = @mulWithOverflow(op1_v.Int.uint8, op2_v.Int.uint8)[0], + 16 => v.Int.uint16 = @mulWithOverflow(op1_v.Int.uint16, op2_v.Int.uint16)[0], + 32 => v.Int.uint32 = @mulWithOverflow(op1_v.Int.uint32, op2_v.Int.uint32)[0], + 64 => v.Int.uint64 = @mulWithOverflow(op1_v.Int.uint64, op2_v.Int.uint64)[0], + else => return RuntimeError.InvalidSpirV, + }, + } + } + }; + + switch (value.*) { + .Float => if (T == .Float) try operator.process(size, value, op1_value, op2_value) else return RuntimeError.InvalidSpirV, + .Int => if (T == .SInt or T == .UInt) try operator.process(size, value, op1_value, op2_value) else return RuntimeError.InvalidSpirV, + .Vector => |vec| for (vec, op1_value.Vector, op2_value.Vector) |*val, op1_v, op2_v| try operator.process(size, val, &op1_v, &op2_v), else => return RuntimeError.InvalidSpirV, } } }; - - switch (value.*) { - .Float => try operator.process(size, value, op1_value, op2_value), - .Vector => |vec| for (vec, op1_value.Vector, op2_value.Vector) |*val, op1_v, op2_v| try operator.process(size, val, &op1_v, &op2_v), - else => return RuntimeError.InvalidSpirV, - } -} - -fn opIMul(_: std.mem.Allocator, _: SpvWord, rt: *Runtime) RuntimeError!void { - const target_type = (rt.results[try rt.it.next()].variant orelse return RuntimeError.InvalidSpirV).Type; - const value = try rt.results[try rt.it.next()].getValue(); - const op1_value = try rt.results[try rt.it.next()].getValue(); - const op2_value = try rt.results[try rt.it.next()].getValue(); - - const size = sw: switch (target_type) { - .Vector => |v| continue :sw (rt.results[v.components_type_word].variant orelse return RuntimeError.InvalidSpirV).Type, - .Int => |i| i.bit_length, - else => return RuntimeError.InvalidSpirV, - }; - - const operator = struct { - fn process(bit_count: SpvWord, v: *Result.Value, op1_v: *const Result.Value, op2_v: *const Result.Value) RuntimeError!void { - switch (bit_count) { - 8 => v.Int.sint8 = op1_v.Int.sint8 * op2_v.Int.sint8, - 16 => v.Int.sint16 = op1_v.Int.sint16 * op2_v.Int.sint16, - 32 => v.Int.sint32 = op1_v.Int.sint32 * op2_v.Int.sint32, - 64 => v.Int.sint64 = op1_v.Int.sint64 * op2_v.Int.sint64, - else => return RuntimeError.InvalidSpirV, - } - } - }; - - switch (value.*) { - .Int => try operator.process(size, value, op1_value, op2_value), - .Vector => |vec| for (vec, op1_value.Vector, op2_value.Vector) |*val, op1_v, op2_v| try operator.process(size, val, &op1_v, &op2_v), - else => return RuntimeError.InvalidSpirV, - } } fn setupConstant(allocator: std.mem.Allocator, rt: *Runtime) RuntimeError!*Result { diff --git a/test/basics.zig b/test/basics.zig index 5e1b76f..ff74aae 100644 --- a/test/basics.zig +++ b/test/basics.zig @@ -25,5 +25,5 @@ test "FMul vec4[f32]" { const code = try compileNzsl(allocator, shader); defer allocator.free(code); - try case.expectOutput(f32, code, "color", &.{ 4, 3, 2, 1 }); + try case.expectOutput(f32, 4, code, "color", &.{ 4, 3, 2, 1 }); } diff --git a/test/maths.zig b/test/maths.zig index 80e42ff..f0c0853 100644 --- a/test/maths.zig +++ b/test/maths.zig @@ -5,25 +5,26 @@ const case = root.case; test "Mul vec4" { const allocator = std.testing.allocator; - const types = [_]type{ f32, i32 }; + const types = [_]type{ + f32, + //f64, + i32, + u32, + }; + inline for (types) |T| { - const prng: std.Random.DefaultPrng = .init(@intCast(std.time.microTimestamp())); - - const base_color: [4]T = undefined; - std.Random.shuffle(prng, T, base_color); - const ratio: [4]T = undefined; - std.Random.shuffle(prng, T, ratio); - - const expected = [4]T{ - base_color[0] * ratio[0], - base_color[1] * ratio[1], - base_color[2] * ratio[2], - base_color[3] * ratio[3], + const base_color = case.random(@Vector(4, T)); + const ratio = case.random(@Vector(4, T)); + const expected = switch (@typeInfo(T)) { + .float => base_color * ratio, + .int => @mulWithOverflow(base_color, ratio)[0], + else => unreachable, }; const shader = try std.fmt.allocPrint( allocator, \\ [nzsl_version("1.1")] + \\ [feature(float64)] \\ module; \\ \\ struct FragOut @@ -41,21 +42,23 @@ test "Mul vec4" { \\ return output; \\ }} , - @typeName(T), - @typeName(T), - ratio[0], - ratio[1], - ratio[2], - ratio[3], - @typeName(T), - base_color[0], - base_color[1], - base_color[2], - base_color[3], + .{ + @typeName(T), + @typeName(T), + ratio[0], + ratio[1], + ratio[2], + ratio[3], + @typeName(T), + base_color[0], + base_color[1], + base_color[2], + base_color[3], + }, ); + defer allocator.free(shader); const code = try compileNzsl(allocator, shader); defer allocator.free(code); - - try case.expectOutput(f32, code, "color", &expected); + try case.expectOutput(T, 4, code, "color", &@as([4]T, expected)); } } diff --git a/test/root.zig b/test/root.zig index d82c19e..2f3266d 100644 --- a/test/root.zig +++ b/test/root.zig @@ -20,7 +20,7 @@ pub fn compileNzsl(allocator: std.mem.Allocator, source: []const u8) ![]const u3 } pub const case = struct { - pub fn expectOutput(comptime T: type, source: []const u32, output_name: []const u8, comptime expected: []const T) !void { + pub fn expectOutput(comptime T: type, comptime len: usize, source: []const u32, output_name: []const u8, expected: []const T) !void { const allocator = std.testing.allocator; var module = try spv.Module.init(allocator, source); @@ -30,11 +30,29 @@ pub const case = struct { defer rt.deinit(allocator); try rt.callEntryPoint(allocator, try rt.getEntryPointByName("main")); - var output: [expected.len]T = undefined; - try rt.readOutput(T, output[0..output.len], try rt.getResultByName(output_name)); + var output: [len]T = undefined; + try rt.readOutput(T, output[0..len], try rt.getResultByName(output_name)); try std.testing.expectEqualSlices(T, expected, &output); } + + pub fn random(comptime T: type) T { + var prng: std.Random.DefaultPrng = .init(@intCast(std.time.microTimestamp())); + const rand = prng.random(); + + return switch (@typeInfo(T)) { + .int => rand.int(T), + .float => rand.float(T), + .vector => |v| blk: { + var vec: @Vector(v.len, v.child) = undefined; + for (0..v.len) |i| { + vec[i] = random(v.child); + } + break :blk vec; + }, + inline else => unreachable, + }; + } }; test {