Template WIP

Author: Gota7

gpu_template/build.zig

@@ -1,17 +1,30 @@
 const std = @import("std");
 
-fn shadercross(b: *std.Build, sdl_dep_lib: *std.Build.Step.Compile) *std.Build.Step.Compile {
-    const upstream = b.lazyDependency("sdl_shadercross", .{}) orelse return;
+const ShaderFormat = enum {
+    vertex,
+    fragment,
+    compute,
+};
 
+const OutputFormat = enum {
+    dxbc,
+    dxil,
+    msl,
+    spirv,
+    hlsl,
+};
+
+fn shadercross(b: *std.Build, sdl3: *std.Build.Dependency) *std.Build.Step.Compile {
     const exe = b.addExecutable(.{
         .name = "shadercross",
         .root_module = b.createModule(.{
             .target = b.graph.host,
             .link_libc = true,
         }),
     });
-    exe.root_module.linkLibrary(sdl_dep_lib);
+    exe.root_module.linkLibrary(sdl3.builder.dependency("sdl", .{ .target = b.graph.host }).artifact("SDL3"));
 
+    const upstream = sdl3.builder.dependency("sdl_shadercross", .{ .target = b.graph.host });
     exe.root_module.addIncludePath(upstream.path("include"));
     exe.root_module.addIncludePath(upstream.path("src"));
 
@@ -25,8 +38,10 @@ fn shadercross(b: *std.Build, sdl_dep_lib: *std.Build.Step.Compile) *std.Build.S
 
     exe.installHeadersDirectory(upstream.path("include"), "", .{});
 
-    const spirv_headers = b.dependency("spirv_headers", .{});
-    const spirv_cross = b.dependency("spirv_cross", .{
+    const spirv_headers = sdl3.builder.dependency("spirv_headers", .{
+        .target = b.graph.host,
+    });
+    const spirv_cross = sdl3.builder.dependency("spirv_cross", .{
         .target = b.graph.host,
         .optimize = .ReleaseFast, // There is a C bug in spirv-cross upstream! Ignore undefined behavior for now.
         .spv_cross_reflect = true,
@@ -42,12 +57,35 @@ fn setupShader(
     b: *std.Build,
     module: *std.Build.Module,
     name: []const u8,
-) !void {}
+    shadercross_exe: *std.Build.Step.Compile,
+    debug: bool,
+    output_format: OutputFormat,
+) !void {
+    const name_ext = name[std.mem.indexOf(u8, name, ".").?..];
+    const format: ShaderFormat = if (std.mem.eql(u8, name_ext, ".vert"))
+        .vertex
+    else if (std.mem.eql(u8, name_ext, ".frag"))
+        .fragment
+    else
+        .compute;
+    const run_shadercross = b.addRunArtifact(shadercross_exe);
+    const upper = try std.ascii.allocUpperString(b.allocator, @tagName(output_format));
+    run_shadercross.addFileArg(b.path(b.fmt("{s}/{s}.hlsl", .{ "shaders", name })));
+    run_shadercross.addArgs(&.{ "--source", "HLSL", "--entrypoint", "main", "--stage", @tagName(format), "--dest", upper });
+    if (debug)
+        run_shadercross.addArg("--debug");
+    run_shadercross.addArg("--output");
+    const output = run_shadercross.addOutputFileArg(b.fmt("{s}.{s}", .{ name, @tagName(output_format) }));
+    module.addAnonymousImport(name, .{ .root_source_file = output });
+}
 
 fn buildShaders(
     b: *std.Build,
     exe: *std.Build.Step.Compile,
-) void {
+    shadercross_exe: *std.Build.Step.Compile,
+    debug: bool,
+    output_format: OutputFormat,
+) !void {
     var dir = (try std.fs.openDirAbsolute(b.path("shaders").getPath(b), .{ .iterate = true }));
     defer dir.close();
     var dir_iterator = try dir.walk(b.allocator);
@@ -57,12 +95,19 @@ fn buildShaders(
             const extension = ".hlsl";
             if (!std.mem.endsWith(u8, file.basename, extension))
                 continue;
-            try setupShader(b, exe.root_module, file.basename[0..(file.basename.len - extension.len)], format);
+            try setupShader(
+                b,
+                exe.root_module,
+                file.basename[0..(file.basename.len - extension.len)],
+                shadercross_exe,
+                debug,
+                output_format,
+            );
         }
     }
 }
 
-pub fn build(b: *std.Build) void {
+pub fn build(b: *std.Build) !void {
     const target = b.standardTargetOptions(.{});
     const optimize = b.standardOptimizeOption(.{});
 
@@ -83,6 +128,17 @@ pub fn build(b: *std.Build) void {
         .ext_image = true,
     });
     exe.root_module.addImport("sdl3", sdl3.module("sdl3"));
+    const shadercross_exe = shadercross(
+        b,
+        sdl3,
+    );
+    try buildShaders(
+        b,
+        exe,
+        shadercross_exe,
+        b.option(bool, "shader_debug", "If have debug info in the shaders") orelse false,
+        b.option(OutputFormat, "shader_format", "Output shader format") orelse .spirv,
+    );
     b.installArtifact(exe);
 
     const run_cmd = b.addRunArtifact(exe);

gpu_template/shaders/positionColor.vert.hlsl

@@ -0,0 +1,19 @@
+struct Input
+{
+    float3 Position : TEXCOORD0;
+    float4 Color : TEXCOORD1;
+};
+
+struct Output
+{
+    float4 Color : TEXCOORD0;
+    float4 Position : SV_Position;
+};
+
+Output main(Input input)
+{
+    Output output;
+    output.Color = input.Color;
+    output.Position = float4(input.Position, 1.0f);
+    return output;
+}

gpu_template/shaders/solidColor.frag.hlsl

@@ -0,0 +1,4 @@
+float4 main(float4 Color : TEXCOORD0) : SV_Target0
+{
+    return Color;
+}

gpu_template/src/main.zig

@@ -28,7 +28,7 @@ fn importShader(shader: anytype) Shader {
     };
 }
 const vert_shader = importShader(@import("positionColor.vert.zig"));
-const frag_shader = importShader(@import("SolidColor.frag.zig"));
+const frag_shader = importShader(@import("solidColor.frag.zig"));
 
 const window_width = 640;
 const window_height = 480;