kbz_8/SPIRV-Interpreter
1
0
Fork 0
Code Issues 1 Pull Requests actions.actions Packages Projects Releases Wiki Activity

fixing shader execution
All checks were successful
Build / build (push) Successful in 1m6s
Details
Test / build (push) Successful in 6m15s
Details

Browse Source
This commit is contained in:
kbz_8
2026-01-24 15:18:57 +01:00
parent 96ad7f12f9
commit dbf963a3c9
12 changed files with 118 additions and 91 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
README.md
View File

@@ -1,6 +1,6 @@
# SPIR-V Interpreter <a href="https://git.kbz8.me/kbz_8/SPIRV-Interpreter/actions?workflows=build.yml"><img src="https://git.kbz8.me/kbz_8/SPIRV-Interpreter/actions/workflows/build.yml/badge.svg"></a> <a href="https://git.kbz8.me/kbz_8/SPIRV-Interpreter/actions?workflows=test.yml"><img src="https://git.kbz8.me/kbz_8/SPIRV-Interpreter/actions/workflows/test.yml/badge.svg"></a>
A small footprint SPIR-V interpreter with zero dependencies to execute SPIR-V shaders on the CPU. It is designed to be used with multiple runtimes concurrently.
A small footprint SPIR-V interpreter to execute SPIR-V shaders on the CPU. It is designed to be used with multiple runtimes concurrently.
```zig
const std = @import("std");

3
build.zig
View File

@@ -12,6 +12,9 @@ pub fn build(b: *std.Build) void {
.optimize = optimize,
});
const zmath = b.dependency("zmath", .{});
mod.addImport("zmath", zmath.module("root"));
const pretty = b.dependency("pretty", .{ .target = target, .optimize = optimize });
mod.addImport("pretty", pretty.module("pretty"));

4
build.zig.zon
View File

@@ -2,6 +2,10 @@
.name = .SPIRV_Interpreter,
.version = "0.0.1",
.dependencies = .{
.zmath = .{
.url = "git+https://github.com/zig-gamedev/zmath.git#3a5955b2b72cd081563fbb084eff05bffd1e3fbb",
.hash = "zmath-0.11.0-dev-wjwivdMsAwD-xaLj76YHUq3t9JDH-X16xuMTmnDzqbu2",
},
.pretty = .{ // For debugging purposes
.url = "git+https://github.com/Kbz-8/pretty#117674465efd4d07d5ae9d9d8ca59c2c323a65ba",
.hash = "pretty-0.10.6-Tm65r99UAQDEJMgZysD10qE8dinBHr064fPM6YkxVPfB",

22
example/main.zig
View File

@@ -4,8 +4,8 @@ const spv = @import("spv");
const shader_source = @embedFile("shader.spv");
const screen_width = 200;
const screen_height = 200;
const screen_width = 480;
const screen_height = 240;
pub fn main() !void {
{
@@ -50,9 +50,7 @@ pub fn main() !void {
}
var thread_pool: std.Thread.Pool = undefined;
try thread_pool.init(.{
.allocator = allocator,
});
try thread_pool.init(.{ .allocator = allocator });
var timer = try std.time.Timer.start();
@@ -73,15 +71,15 @@ pub fn main() !void {
const pixel_map: [*]u32 = @as([*]u32, @ptrCast(@alignCast((surface.getPixels() orelse return).ptr)));
const delta: f32 = @as(f32, @floatFromInt(timer.read())) / std.time.ns_per_s;
var frame_timer = try std.time.Timer.start();
defer {
const ns = frame_timer.lap();
const ms = @as(f32, @floatFromInt(ns)) / std.time.ns_per_s;
std.log.info("Took {d:.3}s - {d:.3}fps to render", .{ ms, 1.0 / ms });
std.log.info("Took {d:.3}s - {d:.3}fps to render {d:.2}", .{ ms, 1.0 / ms, delta });
}
const delta: f32 = @as(f32, @floatFromInt(timer.read())) / std.time.ns_per_s;
var wait_group: std.Thread.WaitGroup = .{};
for (0..screen_height) |y| {
const runner = &runner_cache.items[y];
@@ -131,10 +129,10 @@ const Runner = struct {
try rt.readOutput(f32, output[0..], self.color);
const rgba = self.surface.mapRgba(
@truncate(@as(u32, @intFromFloat(output[0] * 255.0))),
@truncate(@as(u32, @intFromFloat(output[1] * 255.0))),
@truncate(@as(u32, @intFromFloat(output[2] * 255.0))),
@truncate(@as(u32, @intFromFloat(output[3] * 255.0))),
@intCast(@max(@min(@as(i32, @intFromFloat(output[0] * 255.0)), 255), 0)),
@intCast(@max(@min(@as(i32, @intFromFloat(output[1] * 255.0)), 255), 0)),
@intCast(@max(@min(@as(i32, @intFromFloat(output[2] * 255.0)), 255), 0)),
@intCast(@max(@min(@as(i32, @intFromFloat(output[3] * 255.0)), 255), 0)),
);
pixel_map[(y * self.surface.getWidth()) + x] = rgba.value;

6
example/mangohud.conf git.filemode.normal_file
View File

@@ -0,0 +1,6 @@
gpu_stats=0
font_size=16
resolution
hud_compact
background_alpha=0
width=140

8
example/shader.nzsl
View File

@@ -16,16 +16,16 @@ struct FragOut
[entry(frag)]
fn main(input: FragIn) -> FragOut
{
const I: i32 = 32;
const I: i32 = 128;
const A: f32 = 7.5;
const MA: f32 = 20.0;
const MA: f32 = 100.0;
const MI: f32 = 0.001;
let uv0 = input.pos / input.res * 2.0 - vec2[f32](1.0, 1.0);
let uv = vec2[f32](uv0.x * (input.res.x / input.res.y), uv0.y);
let col = vec3[f32](0.0, 0.0, 0.0);
let ro = vec3[f32](0.0, 0.0, -2.0);
let col = vec3[f32](0.0, 0.0, 0.0);
let ro = vec3[f32](0.0, 0.0, -2.0);
let rd = vec3[f32](uv.x, uv.y, 1.0);
let dt = 0.0;
let ds = 0.0;

BIN
example/shader.spv
View File

Binary file not shown.

4
example/shader.spv.txt
View File

@@ -55,11 +55,11 @@ Schema: 0
%29 = OpConstant %3 f32(0.2)
%30 = OpConstant %3 f32(4)
%31 = OpTypePointer StorageClass(Function) %6
%32 = OpConstant %6 i32(32)
%32 = OpConstant %6 i32(128)
%33 = OpTypeBool
%34 = OpConstant %3 f32(0.001)
%35 = OpConstant %3 f32(0.35)
%36 = OpConstant %3 f32(20)
%36 = OpConstant %3 f32(100)
%37 = OpConstant %3 f32(0.15)
%38 = OpConstant %3 f32(0.05)
%39 = OpConstant %3 f32(1.15)

29
sandbox/shader.nzsl
View File

@@ -16,24 +16,24 @@ struct FragOut
[entry(frag)]
fn main(input: FragIn) -> FragOut
{
const I: i32 = 128;
const I: i32 = 32;
const A: f32 = 7.5;
const MA: f32 = 100.0;
const MA: f32 = 2.0;
const MI: f32 = 0.001;
let uv0 = input.pos / input.res * 2.0 - vec2[f32](1.0, 1.0);
let uv = vec2[f32](uv0.x * (input.res.x / input.res.y), uv0.y);
let col = vec3[f32](0.0, 0.0, 0.0);
let ro = vec3[f32](0.0, 0.0, -2.0);
let rd = vec3[f32](uv.x, uv.y, 1.0);
let col = vec4[f32](0.0, 0.0, 0.0, 0.0);
let ro = vec4[f32](0.0, 0.0, -2.0, 0.0);
let rd = vec4[f32](uv.x, uv.y, 1.0, 0.0);
let dt = 0.0;
let ds = 0.0;
let dm = -1.0;
let p = ro;
let c = vec3[f32](0.0, 0.0, 0.0);
let c = vec4[f32](0.0, 0.0, 0.0, 0.0);
let l = vec3[f32](0.0, sin(input.time * 0.2) * 4.0, cos(input.time * 0.2) * 4.0);
let l = vec4[f32](0.0, sin(input.time * 0.2) * 4.0, cos(input.time * 0.2) * 4.0, 0.0);
for i in 0 -> I
{
@@ -46,26 +46,23 @@ fn main(input: FragIn) -> FragOut
if (ds <= MI)
{
let value = max(dot(normalize(c - p), normalize(p - l)) - 0.35, 0.0);
col = vec3[f32](value, value, value);
let value = max(dot(normalize(c - p), normalize(p - l)), 0.0);
col = vec4[f32](value, value, value, 1.0);
break;
}
if (ds >= MA)
{
if (dot(normalize(rd), normalize(l - ro)) <= 1.0)
if (dot(normalize(rd), normalize(l - ro)) < 1.0)
{
let value = max(dot(normalize(rd), normalize(l - ro)) + 0.15, 0.05)/ 1.15 * (1.0 - dm * A);
col = vec3[f32](value, value, value);
let value = max(dot(normalize(rd), normalize(l - ro)) + 0.15, 0.0) / 1.15 * max(1.0 - dm * A, 0.0);
col = vec4[f32](value, value, value, 1.0);
}
break;
}
}
//if (col == vec3[f32](0.0, 0.0, 0.0))
// discard;
let output: FragOut;
output.color = vec4[f32](col.x, col.y, col.z, 1.0);
output.color = col;
return output;
}

114
src/GLSL_std_450/opcodes.zig
View File

@@ -2,6 +2,7 @@ const std = @import("std");
const spv = @import("../spv.zig");
const ext = @import("GLSL_std_450.zig");
const opc = @import("../opcodes.zig");
const zm = @import("zmath");
const Module = @import("../Module.zig");
const Runtime = @import("../Runtime.zig");
@@ -72,11 +73,23 @@ pub var runtime_dispatcher = [_]?OpCodeExtFunc{null} ** ext.GLSLOpMaxValue;
pub fn initRuntimeDispatcher() void {
// zig fmt: off
runtime_dispatcher[@intFromEnum(ext.GLSLOp.Ceil)] = MathEngine(.Float, .Ceil).opSingleOperator;
runtime_dispatcher[@intFromEnum(ext.GLSLOp.Cos)] = MathEngine(.Float, .Cos).opSingleOperator;
runtime_dispatcher[@intFromEnum(ext.GLSLOp.Exp)] = MathEngine(.Float, .Exp).opSingleOperator;
runtime_dispatcher[@intFromEnum(ext.GLSLOp.Exp2)] = MathEngine(.Float, .Exp2).opSingleOperator;
runtime_dispatcher[@intFromEnum(ext.GLSLOp.FAbs)] = MathEngine(.Float, .FAbs).opSingleOperator;
runtime_dispatcher[@intFromEnum(ext.GLSLOp.FMax)] = MathEngine(.Float, .FMax).opDoubleOperators;
runtime_dispatcher[@intFromEnum(ext.GLSLOp.Floor)] = MathEngine(.Float, .Floor).opSingleOperator;
runtime_dispatcher[@intFromEnum(ext.GLSLOp.Length)] = opLength;
runtime_dispatcher[@intFromEnum(ext.GLSLOp.Log)] = MathEngine(.Float, .Log).opSingleOperator;
runtime_dispatcher[@intFromEnum(ext.GLSLOp.Log2)] = MathEngine(.Float, .Log2).opSingleOperator;
runtime_dispatcher[@intFromEnum(ext.GLSLOp.Normalize)] = opNormalize;
runtime_dispatcher[@intFromEnum(ext.GLSLOp.Round)] = MathEngine(.Float, .Round).opSingleOperator;
runtime_dispatcher[@intFromEnum(ext.GLSLOp.SAbs)] = MathEngine(.SInt, .SAbs).opSingleOperator;
runtime_dispatcher[@intFromEnum(ext.GLSLOp.Sin)] = MathEngine(.Float, .Sin).opSingleOperator;
runtime_dispatcher[@intFromEnum(ext.GLSLOp.Sqrt)] = MathEngine(.Float, .Sqrt).opSingleOperator;
runtime_dispatcher[@intFromEnum(ext.GLSLOp.Tan)] = MathEngine(.Float, .Tan).opSingleOperator;
runtime_dispatcher[@intFromEnum(ext.GLSLOp.Trunc)] = MathEngine(.Float, .Trunc).opSingleOperator;
// zig fmt: on
}
@@ -92,8 +105,20 @@ fn MathEngine(comptime T: ValueType, comptime Op: MathOp) type {
const operator = struct {
fn operation(comptime TT: type, x: TT) RuntimeError!TT {
return switch (Op) {
.Sin => @sin(x),
.Ceil => @ceil(x),
.Cos => @cos(x),
.Exp => @exp(x),
.Exp2 => @exp2(x),
.FAbs => @abs(x),
.Floor => @floor(x),
.Log => @log(x),
.Log2 => @log2(x),
.Round => @round(x),
.SAbs => if (comptime @typeInfo(TT) == .int) @intCast(@abs(x)) else return RuntimeError.InvalidSpirV,
.Sin => @sin(x),
.Sqrt => @sqrt(x),
.Tan => @tan(x),
.Trunc => @trunc(x),
else => RuntimeError.InvalidSpirV,
};
}
@@ -166,12 +191,6 @@ fn MathEngine(comptime T: ValueType, comptime Op: MathOp) type {
else => return RuntimeError.InvalidSpirV,
}
}
inline fn applySIMDVector(comptime ElemT: type, comptime N: usize, d: *@Vector(N, ElemT), l: *const @Vector(N, ElemT), r: *const @Vector(N, ElemT)) RuntimeError!void {
inline for (0..N) |i| {
d[i] = try operation(ElemT, l[i], r[i]);
}
}
};
switch (dst.*) {
@@ -181,17 +200,17 @@ fn MathEngine(comptime T: ValueType, comptime Op: MathOp) type {
try operator.applyScalar(lane_bits, d_lane, &l_lane, &r_lane);
},
.Vector4f32 => |*d| try operator.applySIMDVector(f32, 4, d, &lhs.Vector4f32, &rhs.Vector4f32),
.Vector3f32 => |*d| try operator.applySIMDVector(f32, 3, d, &lhs.Vector3f32, &rhs.Vector3f32),
.Vector2f32 => |*d| try operator.applySIMDVector(f32, 2, d, &lhs.Vector2f32, &rhs.Vector2f32),
.Vector4f32 => |*d| d.* = try operator.operation(@Vector(4, f32), lhs.Vector4f32, rhs.Vector4f32),
.Vector3f32 => |*d| d.* = try operator.operation(@Vector(3, f32), lhs.Vector3f32, rhs.Vector3f32),
.Vector2f32 => |*d| d.* = try operator.operation(@Vector(2, f32), lhs.Vector2f32, rhs.Vector2f32),
.Vector4i32 => |*d| try operator.applySIMDVector(i32, 4, d, &lhs.Vector4i32, &rhs.Vector4i32),
.Vector3i32 => |*d| try operator.applySIMDVector(i32, 3, d, &lhs.Vector3i32, &rhs.Vector3i32),
.Vector2i32 => |*d| try operator.applySIMDVector(i32, 2, d, &lhs.Vector2i32, &rhs.Vector2i32),
.Vector4i32 => |*d| d.* = try operator.operation(@Vector(4, i32), lhs.Vector4i32, rhs.Vector4i32),
.Vector3i32 => |*d| d.* = try operator.operation(@Vector(3, i32), lhs.Vector3i32, rhs.Vector3i32),
.Vector2i32 => |*d| d.* = try operator.operation(@Vector(2, i32), lhs.Vector2i32, rhs.Vector2i32),
.Vector4u32 => |*d| try operator.applySIMDVector(u32, 4, d, &lhs.Vector4u32, &rhs.Vector4u32),
.Vector3u32 => |*d| try operator.applySIMDVector(u32, 3, d, &lhs.Vector3u32, &rhs.Vector3u32),
.Vector2u32 => |*d| try operator.applySIMDVector(u32, 2, d, &lhs.Vector2u32, &rhs.Vector2u32),
.Vector4u32 => |*d| d.* = try operator.operation(@Vector(4, u32), lhs.Vector4u32, rhs.Vector4u32),
.Vector3u32 => |*d| d.* = try operator.operation(@Vector(3, u32), lhs.Vector3u32, rhs.Vector3u32),
.Vector2u32 => |*d| d.* = try operator.operation(@Vector(2, u32), lhs.Vector2u32, rhs.Vector2u32),
else => return RuntimeError.InvalidSpirV,
}
@@ -199,12 +218,6 @@ fn MathEngine(comptime T: ValueType, comptime Op: MathOp) type {
};
}
inline fn sumSIMDVector(comptime ElemT: type, comptime N: usize, d: *ElemT, v: *const @Vector(N, ElemT)) void {
inline for (0..N) |i| {
d.* += v[i];
}
}
fn opLength(_: std.mem.Allocator, target_type_id: SpvWord, id: SpvWord, _: SpvWord, rt: *Runtime) RuntimeError!void {
const target_type = (try rt.results[target_type_id].getVariant()).Type;
const dst = try rt.results[id].getValue();
@@ -219,9 +232,18 @@ fn opLength(_: std.mem.Allocator, target_type_id: SpvWord, id: SpvWord, _: SpvWo
if (bits == 32) { // More likely to be SIMD if f32
switch (src.*) {
.Vector4f32 => |src_vec| sumSIMDVector(f32, 4, &sum, &src_vec),
.Vector3f32 => |src_vec| sumSIMDVector(f32, 3, &sum, &src_vec),
.Vector2f32 => |src_vec| sumSIMDVector(f32, 2, &sum, &src_vec),
.Vector4f32 => |src_vec| {
d_field.* = zm.length4(src_vec)[0];
return;
},
.Vector3f32 => |src_vec| {
d_field.* = zm.length3(zm.f32x4(src_vec[0], src_vec[1], src_vec[2], 0.0))[0];
return;
},
.Vector2f32 => |src_vec| {
d_field.* = zm.length2(zm.f32x4(src_vec[0], src_vec[1], 0.0, 0.0))[0];
return;
},
else => {},
}
}
@@ -237,7 +259,6 @@ fn opLength(_: std.mem.Allocator, target_type_id: SpvWord, id: SpvWord, _: SpvWo
const s_field = try getValuePrimitiveField(.Float, bits, s_lane);
sum += s_field.*;
},
.Vector4f32, .Vector3f32, .Vector2f32 => {},
else => return RuntimeError.InvalidSpirV,
}
@@ -256,17 +277,31 @@ fn opNormalize(_: std.mem.Allocator, target_type_id: SpvWord, id: SpvWord, _: Sp
switch (lane_bits) {
inline 16, 32, 64 => |bits| {
var sum: std.meta.Float(bits) = 0.0;
if (bits == 32) { // More likely to be SIMD if f32
switch (src.*) {
.Vector4f32 => |src_vec| sumSIMDVector(f32, 4, &sum, &src_vec),
.Vector3f32 => |src_vec| sumSIMDVector(f32, 3, &sum, &src_vec),
.Vector2f32 => |src_vec| sumSIMDVector(f32, 2, &sum, &src_vec),
.Vector4f32 => |src_vec| {
dst.Vector4f32 = zm.normalize4(src_vec);
return;
},
.Vector3f32 => |src_vec| {
const normed = zm.normalize3(zm.f32x4(src_vec[0], src_vec[1], src_vec[2], 0.0));
dst.Vector3f32[0] = normed[0];
dst.Vector3f32[1] = normed[1];
dst.Vector3f32[2] = normed[2];
return;
},
.Vector2f32 => |src_vec| {
const normed = zm.normalize2(zm.f32x4(src_vec[0], src_vec[1], 0.0, 0.0));
dst.Vector2f32[0] = normed[0];
dst.Vector2f32[1] = normed[1];
return;
},
else => {},
}
}
var sum: std.meta.Float(bits) = 0.0;
switch (src.*) {
.Float => {
const s_field = try getValuePrimitiveField(.Float, bits, src);
@@ -276,34 +311,17 @@ fn opNormalize(_: std.mem.Allocator, target_type_id: SpvWord, id: SpvWord, _: Sp
const s_field = try getValuePrimitiveField(.Float, bits, s_lane);
sum += s_field.*;
},
.Vector4f32, .Vector3f32, .Vector2f32 => {},
else => return RuntimeError.InvalidSpirV,
}
sum = @sqrt(sum);
if (bits == 32) {
switch (dst.*) {
.Vector4f32 => |*dst_vec| inline for (0..4) |i| {
dst_vec[i] = src.Vector4f32[i] / sum;
},
.Vector3f32 => |*dst_vec| inline for (0..3) |i| {
dst_vec[i] = src.Vector3f32[i] / sum;
},
.Vector2f32 => |*dst_vec| inline for (0..2) |i| {
dst_vec[i] = src.Vector2f32[i] / sum;
},
else => {},
}
}
switch (dst.*) {
.Vector => |dst_vec| for (dst_vec, src.Vector) |*d_lane, *s_lane| {
const d_field = try getValuePrimitiveField(.Float, bits, d_lane);
const s_field = try getValuePrimitiveField(.Float, bits, s_lane);
d_field.* = s_field.* / sum;
},
.Vector4f32, .Vector3f32, .Vector2f32 => {},
else => return RuntimeError.InvalidSpirV,
}
},

2
src/lib.zig
View File

@@ -1,4 +1,4 @@
//! A small footprint SPIR-V interpreter with zero dependencies to execute SPIR-V shaders on the CPU. It is designed to be used with multiple runtimes concurrently.
//! A small footprint SPIR-V interpreter to execute SPIR-V shaders on the CPU. It is designed to be used with multiple runtimes concurrently.
//!
//! ```zig
//! const std = @import("std");

15
src/opcodes.zig
View File

@@ -1,5 +1,6 @@
const std = @import("std");
const spv = @import("spv.zig");
const zm = @import("zmath");
const GLSL_std_450 = @import("GLSL_std_450/opcodes.zig");
@@ -1141,14 +1142,14 @@ fn opDot(_: std.mem.Allocator, _: SpvWord, rt: *Runtime) RuntimeError!void {
else => return RuntimeError.InvalidSpirV,
}
},
.Vector4f32 => |*vec| inline for (0..4) |i| {
value.Float.float32 += vec[i] * op2_value.Vector4f32[i];
.Vector4f32 => |vec| value.Float.float32 = zm.dot4(vec, op2_value.Vector4f32)[0],
.Vector3f32 => |vec| {
const op2_vec = op2_value.Vector3f32;
value.Float.float32 = zm.dot3(zm.f32x4(vec[0], vec[1], vec[2], 0.0), zm.f32x4(op2_vec[0], op2_vec[1], op2_vec[2], 0.0))[0];
},
.Vector3f32 => |*vec| inline for (0..3) |i| {
value.Float.float32 += vec[i] * op2_value.Vector3f32[i];
},
.Vector2f32 => |*vec| inline for (0..2) |i| {
value.Float.float32 += vec[i] * op2_value.Vector2f32[i];
.Vector2f32 => |vec| {
const op2_vec = op2_value.Vector2f32;
value.Float.float32 = zm.dot2(zm.f32x4(vec[0], vec[1], 0.0, 0.0), zm.f32x4(op2_vec[0], op2_vec[1], 0.0, 0.0))[0];
},
else => return RuntimeError.InvalidSpirV,
}