adding GLSL std 450 base

example/main.zig

@@ -4,8 +4,8 @@ const spv = @import("spv");
 
 const shader_source = @embedFile("shader.spv");
 
-const screen_width = 1250;
-const screen_height = 720;
+const screen_width = 200;
+const screen_height = 200;
 
 pub fn main() !void {
     {
@@ -36,10 +36,16 @@ pub fn main() !void {
         }
 
         for (0..screen_height) |_| {
+            var rt = try spv.Runtime.init(allocator, &module);
             (try runner_cache.addOne(allocator)).* = .{
                 .allocator = allocator,
                 .surface = surface,
-                .rt = try spv.Runtime.init(allocator, &module),
+                .rt = rt,
+                .entry = try rt.getEntryPointByName("main"),
+                .color = try rt.getResultByName("color"),
+                .time = try rt.getResultByName("time"),
+                .pos = try rt.getResultByName("pos"),
+                .res = try rt.getResultByName("res"),
             };
         }
 
@@ -48,9 +54,11 @@ pub fn main() !void {
             .allocator = allocator,
         });
 
+        var timer = try std.time.Timer.start();
+
         var quit = false;
         while (!quit) {
-            try surface.clear(.{ .r = 0.0, .g = 0.0, .b = 0.0, .a = 0.0 });
+            try surface.clear(.{ .r = 0.0, .g = 0.0, .b = 0.0, .a = 1.0 });
 
             while (sdl3.events.poll()) |event|
                 switch (event) {
@@ -65,17 +73,19 @@ pub fn main() !void {
 
                 const pixel_map: [*]u32 = @as([*]u32, @ptrCast(@alignCast((surface.getPixels() orelse return).ptr)));
 
-                var timer = try std.time.Timer.start();
+                var frame_timer = try std.time.Timer.start();
                 defer {
-                    const ns = timer.lap();
+                    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 });
                 }
 
+                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];
-                    thread_pool.spawnWg(&wait_group, Runner.run, .{ runner, y, pixel_map });
+                    thread_pool.spawnWg(&wait_group, Runner.runWrapper, .{ runner, y, pixel_map, delta });
                 }
                 thread_pool.waitAndWork(&wait_group);
             }
@@ -92,23 +102,33 @@ const Runner = struct {
     allocator: std.mem.Allocator,
     surface: sdl3.surface.Surface,
     rt: spv.Runtime,
+    entry: spv.SpvWord,
+    color: spv.SpvWord,
+    time: spv.SpvWord,
+    pos: spv.SpvWord,
+    res: spv.SpvWord,
 
-    fn run(self: *Self, y: usize, pixel_map: [*]u32) void {
+    fn runWrapper(self: *Self, y: usize, pixel_map: [*]u32, timer: f32) void {
+        @call(.always_inline, Self.run, .{ self, y, pixel_map, timer }) catch |err| {
+            std.log.err("{s}", .{@errorName(err)});
+            if (@errorReturnTrace()) |trace| {
+                std.debug.dumpStackTrace(trace.*);
+            }
+            std.process.abort();
+        };
+    }
+
+    fn run(self: *Self, y: usize, pixel_map: [*]u32, timer: f32) !void {
         var rt = self.rt; // Copy to avoid pointer access of `self` at runtime. Okay as Runtime contains only pointers and trivially copyable fields
 
-        const entry = rt.getEntryPointByName("main") catch |err| std.debug.panic("Catch error {s}", .{@errorName(err)});
-        const color = rt.getResultByName("color") catch |err| std.debug.panic("Catch error {s}", .{@errorName(err)});
-        const time = rt.getResultByName("time") catch |err| std.debug.panic("Catch error {s}", .{@errorName(err)});
-        const pos = rt.getResultByName("pos") catch |err| std.debug.panic("Catch error {s}", .{@errorName(err)});
-        const res = rt.getResultByName("res") catch |err| std.debug.panic("Catch error {s}", .{@errorName(err)});
         var output: [4]f32 = undefined;
 
         for (0..screen_width) |x| {
-            rt.writeInput(f32, &.{@as(f32, @floatFromInt(std.time.milliTimestamp()))}, time) catch |err| std.debug.panic("Catch error {s}", .{@errorName(err)});
-            rt.writeInput(f32, &.{ @floatFromInt(screen_width), @floatFromInt(screen_height) }, res) catch |err| std.debug.panic("Catch error {s}", .{@errorName(err)});
-            rt.writeInput(f32, &.{ @floatFromInt(x), @floatFromInt(y) }, pos) catch |err| std.debug.panic("Catch error {s}", .{@errorName(err)});
-            rt.callEntryPoint(self.allocator, entry) catch |err| std.debug.panic("Catch error {s}", .{@errorName(err)});
-            rt.readOutput(f32, output[0..], color) catch |err| std.debug.panic("Catch error {s}", .{@errorName(err)});
+            try rt.writeInput(f32, &.{timer}, self.time);
+            try rt.writeInput(f32, &.{ @floatFromInt(screen_width), @floatFromInt(screen_height) }, self.res);
+            try rt.writeInput(f32, &.{ @floatFromInt(x), @floatFromInt(y) }, self.pos);
+            try rt.callEntryPoint(self.allocator, self.entry);
+            try rt.readOutput(f32, output[0..], self.color);
 
             const rgba = self.surface.mapRgba(
                 @truncate(@as(u32, @intFromFloat(output[0] * 255.0))),