zig-chess/build.zig

const std = @import("std");

pub fn build(b: *std.Build) void {
    const target = b.standardTargetOptions(.{});
    const optimize = b.standardOptimizeOption(.{});

    const exe = b.addExecutable(.{
        .name = "zig-chess",
        .root_module = b.createModule(.{
            .root_source_file = b.path("src/main.zig"),
            .target = target,
            .optimize = optimize,
            .link_libc = true,
        }),
    });

    const vulkan_headers = b.dependency("vulkan_headers", .{});

    const vulkan = b.dependency("vulkan", .{
        .registry = vulkan_headers.path("registry/vk.xml"),
    }).module("vulkan-zig");

    exe.root_module.addImport("vulkan", vulkan);

    const zglfw = b.dependency("zglfw", .{
        .target = target,
        .optimize = optimize,
        .import_vulkan = true,
    });

    const zglfw_mod = zglfw.module("root");
    zglfw_mod.addImport("vulkan", vulkan);

    exe.root_module.addImport("zglfw", zglfw_mod);

    if (target.result.os.tag != .emscripten) {
        exe.root_module.linkLibrary(zglfw.artifact("glfw"));
    }

    const vert_cmd = b.addSystemCommand(&.{
        "glslc",
        "--target-env=vulkan1.2",
        "-o",
    });
    const vert_spv = vert_cmd.addOutputFileArg("square.vert.spv");
    vert_cmd.addFileArg(b.path("shaders/square.vert"));

    const frag_cmd = b.addSystemCommand(&.{
        "glslc",
        "--target-env=vulkan1.2",
        "-o",
    });
    const frag_spv = frag_cmd.addOutputFileArg("square.frag.spv");
    frag_cmd.addFileArg(b.path("shaders/square.frag"));

    const piece_vert_cmd = b.addSystemCommand(&.{
        "glslc",
        "--target-env=vulkan1.2",
        "-o",
    });
    const piece_vert_spv = piece_vert_cmd.addOutputFileArg("piece.vert.spv");
    piece_vert_cmd.addFileArg(b.path("shaders/piece.vert"));

    const piece_frag_cmd = b.addSystemCommand(&.{
        "glslc",
        "--target-env=vulkan1.2",
        "-o",
    });
    const piece_frag_spv = piece_frag_cmd.addOutputFileArg("piece.frag.spv");
    piece_frag_cmd.addFileArg(b.path("shaders/piece.frag"));

    exe.root_module.addAnonymousImport("square_vertex_shader", .{
        .root_source_file = vert_spv,
    });

    exe.root_module.addAnonymousImport("square_fragment_shader", .{
        .root_source_file = frag_spv,
    });

    exe.root_module.addAnonymousImport("piece_vertex_shader", .{
        .root_source_file = piece_vert_spv,
    });

    exe.root_module.addAnonymousImport("piece_fragment_shader", .{
        .root_source_file = piece_frag_spv,
    });

    const piece_assets = [_]struct { name: []const u8, path: []const u8 }{
        .{ .name = "white_pawn_rgba", .path = "assets/pieces/raw/Chess_plt45.rgba" },
        .{ .name = "white_knight_rgba", .path = "assets/pieces/raw/Chess_nlt45.rgba" },
        .{ .name = "white_bishop_rgba", .path = "assets/pieces/raw/Chess_blt45.rgba" },
        .{ .name = "white_rook_rgba", .path = "assets/pieces/raw/Chess_rlt45.rgba" },
        .{ .name = "white_queen_rgba", .path = "assets/pieces/raw/Chess_qlt45.rgba" },
        .{ .name = "white_king_rgba", .path = "assets/pieces/raw/Chess_klt45.rgba" },
        .{ .name = "black_pawn_rgba", .path = "assets/pieces/raw/Chess_pdt45.rgba" },
        .{ .name = "black_knight_rgba", .path = "assets/pieces/raw/Chess_ndt45.rgba" },
        .{ .name = "black_bishop_rgba", .path = "assets/pieces/raw/Chess_bdt45.rgba" },
        .{ .name = "black_rook_rgba", .path = "assets/pieces/raw/Chess_rdt45.rgba" },
        .{ .name = "black_queen_rgba", .path = "assets/pieces/raw/Chess_qdt45.rgba" },
        .{ .name = "black_king_rgba", .path = "assets/pieces/raw/Chess_kdt45.rgba" },
    };

    for (piece_assets) |asset| {
        exe.root_module.addAnonymousImport(asset.name, .{
            .root_source_file = b.path(asset.path),
        });
    }

    b.installArtifact(exe);

    const run_cmd = b.addRunArtifact(exe);
    run_cmd.step.dependOn(b.getInstallStep());
    if (b.args) |args| {
        run_cmd.addArgs(args);
    }

    const run_step = b.step("run", "Run zig-chess");
    run_step.dependOn(&run_cmd.step);

    const magic_numbers_exe = b.addExecutable(.{
        .name = "magic-numbers",
        .root_module = b.createModule(.{
            .root_source_file = b.path("tools/magic_numbers.zig"),
            .target = target,
            .optimize = optimize,
        }),
    });

    const install_magic_numbers = b.addInstallArtifact(magic_numbers_exe, .{});

    const magic_numbers_step = b.step("magic-numbers", "Build the magic bitboard number utility");
    magic_numbers_step.dependOn(&install_magic_numbers.step);

    const run_magic_numbers_cmd = b.addRunArtifact(magic_numbers_exe);
    if (b.args) |args| {
        run_magic_numbers_cmd.addArgs(args);
    }

    const run_magic_numbers_step = b.step("run-magic-numbers", "Run the magic bitboard number utility");
    run_magic_numbers_step.dependOn(&run_magic_numbers_cmd.step);
}