247 lines
7.9 KiB
Zig
247 lines
7.9 KiB
Zig
// MVK_CONFIG_USE_METAL_ARGUMENT_BUFFERS=1 -- use this if you're getting that odd crash on mac
|
|
b: *std.Build,
|
|
nw_builder: *std.Build,
|
|
target: std.Build.ResolvedTarget,
|
|
optimize: std.builtin.Mode,
|
|
nw_mod: *std.Build.Module,
|
|
spirvReflect: SpirvReflect.SpirvGenerator2,
|
|
gltf2ozz: ozz.GltfToOzz,
|
|
options: *std.Build.Step.Options,
|
|
cookShaders: bool,
|
|
|
|
backlogRoot: []const u8,
|
|
// list of all shaders discovered under
|
|
// content/_shaders/def
|
|
reflectShaderPathList: [][]u8 = undefined,
|
|
|
|
const engineDepList = [_][]const u8{
|
|
"assets",
|
|
"audio",
|
|
"core",
|
|
"papyrus",
|
|
"platform",
|
|
"rend",
|
|
"imgui",
|
|
"physics",
|
|
"ui",
|
|
};
|
|
|
|
const BuildSystem = @This();
|
|
const std = @import("std");
|
|
const Build = std.Build;
|
|
const LazyPath = Build.LazyPath;
|
|
|
|
const SpirvReflect = @import("SpirvReflect");
|
|
const ozz = @import("ozz");
|
|
|
|
pub const InitOptions = struct {
|
|
import_name: []const u8 = "Backlog",
|
|
backlogRoot: []const u8 = "./BacklogEngine",
|
|
target: Build.ResolvedTarget,
|
|
optimize: std.builtin.OptimizeMode,
|
|
};
|
|
|
|
pub fn init(b: *std.Build, opts: InitOptions) BuildSystem {
|
|
const nwdep = b.dependency(opts.import_name, .{
|
|
.target = opts.target,
|
|
.optimize = opts.optimize,
|
|
});
|
|
|
|
const self = BuildSystem{
|
|
.b = b,
|
|
.nw_builder = nwdep.builder,
|
|
.target = opts.target,
|
|
.optimize = opts.optimize,
|
|
.nw_mod = nwdep.module("Backlog"),
|
|
.backlogRoot = opts.backlogRoot,
|
|
.spirvReflect = SpirvReflect.SpirvGenerator2.init(nwdep.builder, .{}),
|
|
.options = createGameOptions(b),
|
|
.gltf2ozz = ozz.GltfToOzz.init(nwdep.builder, .{}),
|
|
.cookShaders = b.option(bool, "cookShaders", "generates shaders and updates .json files before running the build. (needs to be done whenever shaders are updated, this just runs tools/scripts/cook-shaders.py)") orelse false,
|
|
};
|
|
|
|
const exeList = [2]*std.Build.Step.Compile{ self.gltf2ozz.exe, self.spirvReflect.reflect };
|
|
const install_tools = b.step("tools", "installs tools needed to generate outputs for the engine");
|
|
for (exeList) |exe| {
|
|
const toolsInstall = b.addInstallArtifact(exe, .{
|
|
.dest_dir = .{ .override = .{ .custom = "tools" } },
|
|
});
|
|
|
|
install_tools.dependOn(&toolsInstall.step);
|
|
}
|
|
|
|
{
|
|
const runArtifact = b.addRunArtifact(self.gltf2ozz.exe);
|
|
if (b.args) |args| {
|
|
runArtifact.addArgs(args);
|
|
}
|
|
|
|
const run_exe = b.step("gltf2ozz", "runs the gltf animation converter.");
|
|
run_exe.dependOn(&runArtifact.step);
|
|
}
|
|
|
|
{
|
|
const runArtifact = b.addRunArtifact(self.spirvReflect.reflect);
|
|
if (b.args) |args| {
|
|
runArtifact.addArgs(args);
|
|
}
|
|
|
|
const run_exe = b.step("spv-reflect", "runs the gltf animation converter.");
|
|
run_exe.dependOn(&runArtifact.step);
|
|
}
|
|
|
|
return self;
|
|
}
|
|
|
|
pub const AddProgramOptions = struct {
|
|
name: []const u8,
|
|
desc: []const u8,
|
|
root_source_file: LazyPath,
|
|
imports: []const Build.Module.Import = &.{},
|
|
staticBuild: bool = false, // ugh.... why is this so hard...
|
|
};
|
|
|
|
pub fn addProgram(self: *BuildSystem, opts: AddProgramOptions) *std.Build.Module {
|
|
const b = self.b;
|
|
|
|
const exe = self.nw_builder.addExecutable(.{
|
|
.name = opts.name,
|
|
.target = self.target,
|
|
.optimize = self.optimize,
|
|
.root_source_file = self.nw_builder.path("engine/main.zig"),
|
|
});
|
|
|
|
b.installArtifact(exe);
|
|
const runArtifact = b.addRunArtifact(exe);
|
|
if (b.args) |args| {
|
|
runArtifact.addArgs(args);
|
|
}
|
|
const run_exe = b.step(self.b.fmt("run-{s}", .{opts.name}), opts.desc);
|
|
run_exe.dependOn(&runArtifact.step);
|
|
|
|
// main path = name/main.zig
|
|
const mod = b.addModule(opts.name, .{
|
|
.target = self.target,
|
|
.optimize = self.optimize,
|
|
.root_source_file = opts.root_source_file,
|
|
.imports = opts.imports,
|
|
});
|
|
|
|
exe.root_module.addImport("main", mod);
|
|
exe.root_module.addImport("Backlog", self.nw_mod);
|
|
mod.addImport("Backlog", self.nw_mod);
|
|
exe.root_module.addOptions("BacklogOptions", self.options);
|
|
|
|
if (self.cookShaders) {
|
|
const cookShadersScript = b.fmt("{s}/tools/scripts/cookShaders.py", .{self.backlogRoot});
|
|
const cookShadersCommand = b.addSystemCommand(&[_][]const u8{"python"});
|
|
cookShadersCommand.addArg(cookShadersScript);
|
|
|
|
run_exe.dependOn(&cookShadersCommand.step);
|
|
}
|
|
|
|
b.getInstallStep().dependOn(self.nw_builder.getInstallStep());
|
|
|
|
// run_exe.dependOn(b.getInstallStep());
|
|
|
|
return mod;
|
|
}
|
|
|
|
pub fn createGameOptions(b: *std.Build) *std.Build.Step.Options {
|
|
const opts = b.addOptions();
|
|
|
|
// build options for core.zig
|
|
opts.addOption(
|
|
bool,
|
|
"mutex_job_queue",
|
|
b.option(bool, "mutex_job_queue", "temporary test, reverts to old mutex based queue behaviour in jobs.zig:JobManager") orelse false,
|
|
);
|
|
opts.addOption(
|
|
bool,
|
|
"zero_logging",
|
|
b.option(bool, "zero_logging", "disables all logging, only intended for use on job dispatch testing") orelse false,
|
|
);
|
|
opts.addOption(
|
|
bool,
|
|
"slow_logging",
|
|
b.option(bool, "slow_logging", "Disables buffered logging, takes a hit to performance but gain timing information on logging") orelse false,
|
|
);
|
|
opts.addOption(
|
|
bool,
|
|
"force_mailbox",
|
|
b.option(bool, "force_mailbox", "forces mailbox mode for present mode. unlocks framerate to irresponsible levels") orelse false,
|
|
);
|
|
opts.addOption(
|
|
bool,
|
|
"use_renderthread",
|
|
true,
|
|
);
|
|
|
|
return opts;
|
|
}
|
|
|
|
pub fn addExtraModule(self: *BuildSystem, mod: *std.Build.Module, moduleName: []const u8) void {
|
|
const dep = self.b.dependency(moduleName, .{ .target = self.target, .optimize = self.optimize });
|
|
mod.addImport(moduleName, dep.module(moduleName));
|
|
}
|
|
|
|
pub fn addDependencyInstalls(self: *BuildSystem, b: *std.Build, optimize: std.builtin.OptimizeMode) void {
|
|
// b.installArtifact(b.dependency("sdl3_lib", .{ .target = self.target, .optimize = optimize }).artifact("SDL3"));
|
|
|
|
for (cDependencyList) |d| {
|
|
b.installArtifact(b.dependency(
|
|
d.dep,
|
|
.{ .target = self.target, .optimize = optimize },
|
|
).artifact(d.artifact));
|
|
}
|
|
}
|
|
|
|
const cDependencyList: []const struct { dep: []const u8, artifact: []const u8 } = &.{
|
|
.{ .dep = "sdl3_lib", .artifact = "SDL3" },
|
|
.{ .dep = "spng", .artifact = "spng_c" },
|
|
.{ .dep = "lua", .artifact = "luac" },
|
|
.{ .dep = "miniaudio", .artifact = "miniaudio_c" },
|
|
.{ .dep = "zphysics", .artifact = "joltc" },
|
|
.{ .dep = "ozz", .artifact = "ozz_cpp" },
|
|
};
|
|
|
|
// ========= standalone build instance =======
|
|
// maybe it should be an engine launcher or something..
|
|
pub fn build(b: *std.Build) void {
|
|
const target = b.standardTargetOptions(.{});
|
|
const optimize = b.standardOptimizeOption(.{});
|
|
|
|
const spirvDep = b.dependency("SpirvReflect", .{
|
|
.target = target,
|
|
.optimize = optimize,
|
|
});
|
|
_ = spirvDep;
|
|
|
|
{
|
|
const mod = b.addModule("Backlog", .{
|
|
.target = target,
|
|
.optimize = optimize,
|
|
.root_source_file = b.path("engine/backlog.zig"),
|
|
});
|
|
|
|
for (engineDepList) |depName| {
|
|
const dep = b.dependency(
|
|
depName,
|
|
.{
|
|
.target = target,
|
|
.optimize = optimize,
|
|
},
|
|
);
|
|
mod.addImport(depName, dep.module(depName));
|
|
}
|
|
|
|
// link in large platform support functions
|
|
{
|
|
const dep = b.dependency("sdl3", .{ .target = target, .optimize = optimize });
|
|
const lib = dep.module("sdl3_lib");
|
|
|
|
mod.addImport("sdl3_fwd", lib);
|
|
}
|
|
}
|
|
}
|