509 lines
23 KiB
Zig
509 lines
23 KiB
Zig
const std = @import("std");
|
|
|
|
const ModuleDesc = struct {
|
|
name: []const u8,
|
|
desc: []const u8,
|
|
version: []const u8 = "1.0",
|
|
default: bool = true,
|
|
/// Source directory under src/ (defaults to name if null).
|
|
src_dir: ?[]const u8 = null,
|
|
/// WoW addon folder name. Non-null means this module has an addon/ dir.
|
|
addon_name: ?[]const u8 = null,
|
|
/// If true, addon is hidden from the in-game addon list (always loaded).
|
|
addon_hidden: bool = false,
|
|
};
|
|
|
|
/// Single source of truth for all modules. Adding a module here is enough
|
|
/// to wire up the build option, build_options passthrough, and DLL variant.
|
|
/// Versioning: major.minor.bugfix - bump bugfix for core/infra fixes that
|
|
/// affect the module's DLL, minor for feature changes, major for breaking.
|
|
const module_list = [_]ModuleDesc{
|
|
.{ .name = "pngscreenshots", .version = "1.0.1", .desc = "Enable screenshot module", .src_dir = "screenshot" },
|
|
.{ .name = "interact", .version = "1.1.0", .desc = "Enable interact module", .addon_name = "Interact" },
|
|
.{ .name = "outline", .version = "1.0", .desc = "Enable outline module", .default = false, .addon_name = "Outline" },
|
|
.{ .name = "worldmarkers", .version = "1.1", .desc = "Enable world markers module", .addon_name = "WorldMarkers", .addon_hidden = true },
|
|
.{ .name = "framecrash", .version = "1.0", .desc = "Enable framecrash fix", .default = false },
|
|
.{ .name = "logsessions", .version = "1.1.0", .desc = "Enable log session rotation", .addon_name = "LogSessions", .addon_hidden = true },
|
|
.{ .name = "minimapicons", .version = "1.0.1", .desc = "Enable custom minimap icons", .addon_name = "MinimapIcons" },
|
|
.{ .name = "transmogfix", .version = "1.0.1", .desc = "Enable transmog update coalescing" },
|
|
.{ .name = "customassets", .version = "1.0.1", .desc = "Enable loose file loading & permissive patch glob" },
|
|
.{ .name = "healtextfix", .version = "1.0.1", .desc = "Enable SuperWoW heal text fix" },
|
|
.{ .name = "bigcursor", .version = "1.0.1", .desc = "Enable big cursor module" },
|
|
.{ .name = "clickthrough", .version = "1.0.3", .desc = "Enable GO click-through" },
|
|
.{ .name = "dpslog", .version = "0.1", .desc = "Enable structured combat log events for addons", .default = false },
|
|
.{ .name = "transform44", .version = "1.0", .desc = "Enable transform44 profiling/A/B testing (dev only)", .default = false },
|
|
.{ .name = "addonperf", .version = "1.0", .desc = "Enable addon memory/CPU profiling API", .default = false },
|
|
.{ .name = "ssemaths", .version = "1.0", .desc = "Enable UnitXP x87 math polyfill replacements (SSE)", .default = false },
|
|
.{ .name = "silicon", .version = "1.0", .desc = "Enable SSE2 math replacements (ported from libSiliconPatch)", .default = false },
|
|
.{ .name = "weirdperformance", .version = "1.2.1", .desc = "Enable production performance optimizations (SSE, inflate, filecache, timer, luastr, luavm)", .default = true },
|
|
.{ .name = "superweirdo", .version = "0.1", .desc = "Enable GO loot sparkle on interactable objects", .default = false },
|
|
.{ .name = "luagc", .version = "0.1", .desc = "Enable incremental Lua GC (replaces stop-the-world mark+sweep)", .default = false },
|
|
};
|
|
|
|
pub fn build(b: *std.Build) void {
|
|
const target = b.resolveTargetQuery(.{
|
|
.cpu_arch = .x86,
|
|
.os_tag = .windows,
|
|
.abi = .msvc,
|
|
.cpu_features_add = std.Target.x86.featureSet(&.{ .sse, .sse2 }),
|
|
});
|
|
// SSE objects that replace hot game functions use the full feature set.
|
|
// FMA/AVX are only emitted in these separately-compiled units, so the
|
|
// main DLL runs on any CPU with SSE2 (WoW's baseline).
|
|
const sse_target = b.resolveTargetQuery(.{
|
|
.cpu_arch = .x86,
|
|
.os_tag = .windows,
|
|
.abi = .msvc,
|
|
.cpu_features_add = std.Target.x86.featureSet(&.{ .sse, .sse2, .sse3, .sse4_1, .fma, .avx }),
|
|
});
|
|
const optimize = b.option(std.builtin.OptimizeMode, "optimize", "Optimization mode (default: ReleaseFast)") orelse .ReleaseFast;
|
|
|
|
// Resolve module enable flags once (b.option can only be called once per name)
|
|
var module_enabled: [module_list.len]bool = undefined;
|
|
inline for (module_list, 0..) |m, i| {
|
|
module_enabled[i] = b.option(bool, m.name, m.desc) orelse m.default;
|
|
}
|
|
|
|
const build_options = b.addOptions();
|
|
addModuleOptionsFromArray(b, build_options, &module_enabled);
|
|
build_options.addOption(bool, "safe_variant_core", false);
|
|
// transform_capture: records game-x87 transformMatrix4x4 state to disk for
|
|
// offline bench parity. Mutually exclusive with bone_sse64 (capture needs
|
|
// the real game output; bone_sse64 replaces it).
|
|
const transform_capture_enabled = b.option(bool, "transform_capture",
|
|
"Record transformMatrix4x4 inputs/outputs to disk (disables bone_sse64)") orelse false;
|
|
build_options.addOption(bool, "transform_capture", transform_capture_enabled);
|
|
const build_options_module = build_options.createModule();
|
|
|
|
const zhook_dep = b.dependency("zhook", .{
|
|
.target = target,
|
|
.optimize = optimize,
|
|
});
|
|
const zhook_mod = zhook_dep.module("zhook");
|
|
|
|
// REF uses x87-only target to match original game code structure.
|
|
// The global target has SSE/SSE2 which generates movss/mulss;
|
|
// the original at 0x714260 uses pure x87 (FLD/FMUL/FSTP).
|
|
const ref_target = b.resolveTargetQuery(.{
|
|
.cpu_arch = .x86,
|
|
.os_tag = .windows,
|
|
.abi = .msvc,
|
|
.cpu_features_sub = std.Target.x86.featureSet(&.{ .sse, .sse2 }),
|
|
});
|
|
const bone_sse_ref_obj = b.addObject(.{
|
|
.name = "bone_sse_ref",
|
|
.root_module = b.createModule(.{
|
|
.root_source_file = b.path("src/transform44/bone_sse_reference.zig"),
|
|
.target = ref_target,
|
|
.optimize = .ReleaseFast,
|
|
}),
|
|
});
|
|
const math_sse_obj = b.addObject(.{
|
|
.name = "math_sse",
|
|
.root_module = b.createModule(.{
|
|
.root_source_file = b.path("src/ssemaths/math_sse.zig"),
|
|
.target = sse_target,
|
|
.optimize = .ReleaseFast,
|
|
}),
|
|
});
|
|
const particle_ref_obj = b.addObject(.{
|
|
.name = "particle_sse_ref",
|
|
.root_module = b.createModule(.{
|
|
.root_source_file = b.path("src/transform44/particle_sse_reference.zig"),
|
|
.target = sse_target,
|
|
.optimize = .ReleaseFast,
|
|
}),
|
|
});
|
|
|
|
const lib = b.addLibrary(.{
|
|
.name = "weirdutils",
|
|
.linkage = .dynamic,
|
|
.root_module = b.createModule(.{
|
|
.root_source_file = b.path("src/main.zig"),
|
|
.target = target,
|
|
.optimize = optimize,
|
|
.imports = &.{
|
|
.{ .name = "zhook", .module = zhook_mod },
|
|
.{ .name = "build_options", .module = build_options_module },
|
|
},
|
|
}),
|
|
});
|
|
// libdeflate (static C lib for inflate_hook)
|
|
const libdeflate = b.addLibrary(.{
|
|
.linkage = .static,
|
|
.name = "deflate",
|
|
.root_module = b.createModule(.{
|
|
.root_source_file = null,
|
|
.target = target,
|
|
.optimize = .ReleaseFast,
|
|
.link_libc = true,
|
|
}),
|
|
});
|
|
libdeflate.root_module.addCSourceFiles(.{
|
|
.files = &.{
|
|
"src/weirdperformance/libdeflate/lib/deflate_decompress.c",
|
|
"src/weirdperformance/libdeflate/lib/zlib_decompress.c",
|
|
"src/weirdperformance/libdeflate/lib/utils.c",
|
|
"src/weirdperformance/libdeflate/lib/adler32.c",
|
|
"src/weirdperformance/libdeflate/lib/x86/cpu_features.c",
|
|
"src/weirdperformance/libdeflate/stubs/game_alloc.c",
|
|
},
|
|
.flags = &.{"-DLIBDEFLATE_ASSEMBLER_DOES_NOT_SUPPORT_AVX512VNNI"},
|
|
});
|
|
libdeflate.root_module.addIncludePath(b.path("src/weirdperformance/libdeflate/stubs"));
|
|
libdeflate.root_module.addIncludePath(b.path("src/weirdperformance/libdeflate"));
|
|
libdeflate.root_module.addIncludePath(b.path("src/weirdperformance/libdeflate/lib"));
|
|
|
|
// Link module-specific object files into a DLL.
|
|
// Single source of truth for which objects each module needs.
|
|
// Called for both the main weirdutils build and each variant.
|
|
const ModuleObjects = struct {
|
|
bone_sse_ref: *std.Build.Step.Compile,
|
|
math_sse: *std.Build.Step.Compile,
|
|
particle_ref: *std.Build.Step.Compile,
|
|
libdeflate: *std.Build.Step.Compile,
|
|
|
|
fn linkFor(self: @This(), mod: *std.Build.Module, comptime module_name: []const u8) void {
|
|
@setEvalBranchQuota(10000);
|
|
if (comptime std.mem.eql(u8, module_name, "weirdperformance")) {
|
|
mod.addObjectFile(self.libdeflate.getEmittedBin());
|
|
}
|
|
if (comptime std.mem.eql(u8, module_name, "transform44")) {
|
|
mod.addObject(self.bone_sse_ref);
|
|
mod.addObject(self.particle_ref);
|
|
}
|
|
if (comptime std.mem.eql(u8, module_name, "ssemaths")) {
|
|
mod.addObject(self.math_sse);
|
|
}
|
|
}
|
|
};
|
|
const objs = ModuleObjects{
|
|
.bone_sse_ref = bone_sse_ref_obj,
|
|
.math_sse = math_sse_obj,
|
|
.particle_ref = particle_ref_obj,
|
|
.libdeflate = libdeflate,
|
|
};
|
|
|
|
// Main DLL: link module objects only for enabled modules
|
|
inline for (module_list, 0..) |mod, i| {
|
|
if (module_enabled[i]) objs.linkFor(lib.root_module, mod.name);
|
|
}
|
|
|
|
b.installArtifact(lib);
|
|
|
|
// Benchmark harness — native x86 Linux executable for profiling SSE replacements
|
|
{
|
|
const bench_target = b.resolveTargetQuery(.{
|
|
.cpu_arch = .x86,
|
|
.os_tag = .linux,
|
|
.cpu_features_add = std.Target.x86.featureSet(&.{ .sse, .sse2 }),
|
|
});
|
|
const bench_math_sse = b.addObject(.{
|
|
.name = "bench_math_sse",
|
|
.root_module = b.createModule(.{
|
|
.root_source_file = b.path("src/ssemaths/math_sse.zig"),
|
|
.target = bench_target,
|
|
.optimize = .ReleaseFast,
|
|
}),
|
|
});
|
|
const bench_optimize = b.option(std.builtin.OptimizeMode, "bench-opt", "Bench optimization (default: ReleaseFast)") orelse .ReleaseFast;
|
|
const bench = b.addExecutable(.{
|
|
.name = "bench",
|
|
.root_module = b.createModule(.{
|
|
.root_source_file = b.path("src/bench/main.zig"),
|
|
.target = bench_target,
|
|
.optimize = bench_optimize,
|
|
}),
|
|
});
|
|
// Link at high address so WoW PE sections (0x400000-0xD00000) can be
|
|
// mapped at their original virtual addresses for benchmarking.
|
|
bench.image_base = 0x10000000;
|
|
const bench_silicon_sse = b.addObject(.{
|
|
.name = "bench_silicon_sse",
|
|
.root_module = b.createModule(.{
|
|
.root_source_file = b.path("src/weirdperformance/silicon_sse.zig"),
|
|
.target = b.resolveTargetQuery(.{
|
|
.cpu_arch = .x86,
|
|
.os_tag = .linux,
|
|
.cpu_features_add = std.Target.x86.featureSet(&.{ .sse, .sse2, .sse3, .sse4_1, .fma, .avx }),
|
|
}),
|
|
.optimize = .ReleaseFast,
|
|
}),
|
|
});
|
|
const bench_bone_sse = b.addObject(.{
|
|
.name = "bench_bone_sse",
|
|
.root_module = b.createModule(.{
|
|
.root_source_file = b.path("src/weirdperformance/bone_sse.zig"),
|
|
.target = b.resolveTargetQuery(.{
|
|
.cpu_arch = .x86,
|
|
.os_tag = .linux,
|
|
.cpu_features_add = std.Target.x86.featureSet(&.{ .sse, .sse2, .sse3, .sse4_1, .fma, .avx }),
|
|
}),
|
|
.optimize = .ReleaseFast,
|
|
}),
|
|
});
|
|
const bench_bone_sse64 = b.addObject(.{
|
|
.name = "bench_bone_sse64",
|
|
.root_module = b.createModule(.{
|
|
.root_source_file = b.path("src/weirdperformance/bone_sse64.zig"),
|
|
.target = b.resolveTargetQuery(.{
|
|
.cpu_arch = .x86,
|
|
.os_tag = .linux,
|
|
.cpu_features_add = std.Target.x86.featureSet(&.{ .sse, .sse2, .sse3, .sse4_1, .fma, .avx }),
|
|
}),
|
|
.optimize = .ReleaseFast,
|
|
}),
|
|
});
|
|
const bench_bone_baseline = b.addObject(.{
|
|
.name = "bench_bone_baseline",
|
|
.root_module = b.createModule(.{
|
|
.root_source_file = b.path("src/transform44/bone_sse_baseline.zig"),
|
|
.target = b.resolveTargetQuery(.{
|
|
.cpu_arch = .x86,
|
|
.os_tag = .linux,
|
|
.cpu_features_add = std.Target.x86.featureSet(&.{ .sse, .sse2, .sse3, .sse4_1, .fma, .avx }),
|
|
}),
|
|
.optimize = .ReleaseFast,
|
|
}),
|
|
});
|
|
const bench_particle_sse = b.addObject(.{
|
|
.name = "bench_particle_sse",
|
|
.root_module = b.createModule(.{
|
|
.root_source_file = b.path("src/weirdperformance/particle_sse.zig"),
|
|
.target = b.resolveTargetQuery(.{
|
|
.cpu_arch = .x86,
|
|
.os_tag = .linux,
|
|
.cpu_features_add = std.Target.x86.featureSet(&.{ .sse, .sse2, .sse3, .sse4_1, .fma, .avx }),
|
|
}),
|
|
.optimize = .ReleaseFast,
|
|
}),
|
|
});
|
|
const bench_cull_sse = b.addObject(.{
|
|
.name = "bench_cull_sse",
|
|
.root_module = b.createModule(.{
|
|
.root_source_file = b.path("src/weirdperformance/cull_sse.zig"),
|
|
.target = bench_target,
|
|
.optimize = .ReleaseFast,
|
|
}),
|
|
});
|
|
bench.root_module.addObject(bench_math_sse);
|
|
bench.root_module.addObject(bench_silicon_sse);
|
|
// bench_bone_sse64 imports bone_sse, so it provides both transformImpl_SSE
|
|
// and transformImpl_SSE64 symbols. Linking bench_bone_sse too would cause
|
|
// duplicate-symbol errors.
|
|
_ = bench_bone_sse;
|
|
bench.root_module.addObject(bench_bone_sse64);
|
|
bench.root_module.addObject(bench_bone_baseline);
|
|
bench.root_module.addObject(bench_particle_sse);
|
|
bench.root_module.addObject(bench_cull_sse);
|
|
const bench_entity_sse = b.addObject(.{
|
|
.name = "bench_entity_sse",
|
|
.root_module = b.createModule(.{
|
|
.root_source_file = b.path("src/weirdperformance/entity_sse.zig"),
|
|
.target = bench_target,
|
|
.optimize = .ReleaseFast,
|
|
}),
|
|
});
|
|
bench.root_module.addObject(bench_entity_sse);
|
|
bench.root_module.linkSystemLibrary("m", .{});
|
|
const install_bench = b.addInstallArtifact(bench, .{});
|
|
const bench_step = b.step("bench", "Build math_sse benchmark harness (x86 Linux)");
|
|
bench_step.dependOn(&install_bench.step);
|
|
|
|
const run_bench = b.addRunArtifact(bench);
|
|
const run_step = b.step("run-bench", "Build and run math_sse benchmark");
|
|
run_step.dependOn(&run_bench.step);
|
|
}
|
|
|
|
// Build combined DLL without performance module
|
|
const noperf_install = noperf_blk: {
|
|
const noperf_step = b.step("noperf", "Build weirdutils_noperf.dll (no performance module)");
|
|
const noperf_opts = b.addOptions();
|
|
var noperf_enabled = module_enabled;
|
|
// Force weirdperformance off
|
|
inline for (module_list, 0..) |m, i| {
|
|
if (comptime std.mem.eql(u8, m.name, "weirdperformance")) noperf_enabled[i] = false;
|
|
}
|
|
addModuleOptionsFromArray(b, noperf_opts, &noperf_enabled);
|
|
noperf_opts.addOption(bool, "safe_variant_core", false);
|
|
|
|
const noperf_lib = b.addLibrary(.{
|
|
.name = "weirdutils_noperf",
|
|
.linkage = .dynamic,
|
|
.root_module = b.createModule(.{
|
|
.root_source_file = b.path("src/main.zig"),
|
|
.target = target,
|
|
.optimize = optimize,
|
|
.imports = &.{
|
|
.{ .name = "zhook", .module = zhook_mod },
|
|
.{ .name = "build_options", .module = noperf_opts.createModule() },
|
|
},
|
|
}),
|
|
});
|
|
const noperf_install = b.addInstallArtifact(noperf_lib, .{
|
|
.dest_dir = .{ .override = .{ .custom = "variants" } },
|
|
});
|
|
noperf_step.dependOn(&noperf_install.step);
|
|
break :noperf_blk noperf_install;
|
|
};
|
|
|
|
// Convenience step to build all single-module variants
|
|
const build_all_step = b.step("all-variants", "Build all DLL variants");
|
|
build_all_step.dependOn(b.getInstallStep());
|
|
build_all_step.dependOn(&noperf_install.step);
|
|
|
|
inline for (module_list, 0..) |variant_mod, variant_idx| {
|
|
if (module_enabled[variant_idx]) {
|
|
@setEvalBranchQuota(10000);
|
|
const opts = b.addOptions();
|
|
inline for (module_list) |m| {
|
|
opts.addOption(bool, "enable_" ++ m.name, std.mem.eql(u8, m.name, variant_mod.name));
|
|
}
|
|
const safe_variant_core = comptime (
|
|
std.mem.eql(u8, variant_mod.name, "outline") or
|
|
std.mem.eql(u8, variant_mod.name, "customassets") or
|
|
std.mem.eql(u8, variant_mod.name, "transmogfix")
|
|
);
|
|
opts.addOption(bool, "safe_variant_core", safe_variant_core);
|
|
addFileListOptions(b, opts);
|
|
const names: []const []const u8 = comptime blk: {
|
|
var n: [module_list.len][]const u8 = undefined;
|
|
for (module_list, 0..) |m2, mi| n[mi] = m2.name;
|
|
const final = n;
|
|
break :blk &final;
|
|
};
|
|
opts.addOption([]const []const u8, "all_module_names", names);
|
|
const versions: []const []const u8 = comptime blk: {
|
|
var v: [module_list.len][]const u8 = undefined;
|
|
for (module_list, 0..) |m2, mi| v[mi] = m2.version;
|
|
const final = v;
|
|
break :blk &final;
|
|
};
|
|
opts.addOption([]const []const u8, "all_module_versions", versions);
|
|
|
|
const variant_lib = b.addLibrary(.{
|
|
.name = variant_mod.name,
|
|
.linkage = .dynamic,
|
|
.root_module = b.createModule(.{
|
|
.root_source_file = b.path("src/main.zig"),
|
|
.target = target,
|
|
.optimize = optimize,
|
|
.imports = &.{
|
|
.{ .name = "zhook", .module = zhook_mod },
|
|
.{ .name = "build_options", .module = opts.createModule() },
|
|
},
|
|
}),
|
|
});
|
|
|
|
objs.linkFor(variant_lib.root_module, variant_mod.name);
|
|
|
|
const install_variant = b.addInstallArtifact(variant_lib, .{
|
|
.dest_dir = .{ .override = .{ .custom = "variants" } },
|
|
});
|
|
build_all_step.dependOn(&install_variant.step);
|
|
}
|
|
}
|
|
}
|
|
|
|
// =============================================================================
|
|
// Build options: enable flags + scanned file lists for each module
|
|
// =============================================================================
|
|
|
|
fn addModuleOptionsFromArray(b: *std.Build, opts: *std.Build.Step.Options, enabled: *const [module_list.len]bool) void {
|
|
inline for (module_list, 0..) |mod, i| {
|
|
opts.addOption(bool, "enable_" ++ mod.name, enabled[i]);
|
|
}
|
|
// Pass full module name/version lists so main.zig/addons.zig can use them at comptime
|
|
const names: []const []const u8 = comptime blk: {
|
|
var n: [module_list.len][]const u8 = undefined;
|
|
for (module_list, 0..) |mod, i| n[i] = mod.name;
|
|
const final = n;
|
|
break :blk &final;
|
|
};
|
|
opts.addOption([]const []const u8, "all_module_names", names);
|
|
const versions: []const []const u8 = comptime blk: {
|
|
var v: [module_list.len][]const u8 = undefined;
|
|
for (module_list, 0..) |mod, i| v[i] = mod.version;
|
|
const final = v;
|
|
break :blk &final;
|
|
};
|
|
opts.addOption([]const []const u8, "all_module_versions", versions);
|
|
addFileListOptions(b, opts);
|
|
}
|
|
|
|
fn addFileListOptions(b: *std.Build, opts: *std.Build.Step.Options) void {
|
|
const a = b.allocator;
|
|
const io = b.graph.io;
|
|
const root = b.build_root.handle;
|
|
|
|
for (module_list) |mod| {
|
|
const src_dir = mod.src_dir orelse mod.name;
|
|
|
|
// Addon: <module>_addon_name, <module>_addon_hidden, <module>_addon_files
|
|
if (mod.addon_name) |aname| {
|
|
const full_name = std.fmt.allocPrint(a, "WeirdUtils_{s}", .{aname}) catch unreachable;
|
|
opts.addOption([]const u8, std.fmt.allocPrint(a, "{s}_addon_name", .{mod.name}) catch unreachable, full_name);
|
|
opts.addOption(bool, std.fmt.allocPrint(a, "{s}_addon_hidden", .{mod.name}) catch unreachable, mod.addon_hidden);
|
|
const addon_rel = std.fmt.allocPrint(a, "src/{s}/addon", .{src_dir}) catch unreachable;
|
|
const files = listDir(a, io, root, addon_rel);
|
|
var paths: std.ArrayList([]const u8) = .empty;
|
|
for (files) |fname| {
|
|
paths.append(a, std.fmt.allocPrint(a, "{s}/addon/{s}", .{ src_dir, fname }) catch unreachable) catch unreachable;
|
|
}
|
|
opts.addOption([]const []const u8, std.fmt.allocPrint(a, "{s}_addon_files", .{mod.name}) catch unreachable, paths.items);
|
|
}
|
|
|
|
// Asset files: <module>_asset_files = ["markers/assets/Spells/foo.m2", ...]
|
|
const assets_rel = std.fmt.allocPrint(a, "src/{s}/assets", .{src_dir}) catch unreachable;
|
|
const asset_files = listAssets(a, io, root, assets_rel, src_dir);
|
|
if (asset_files.len > 0) {
|
|
opts.addOption([]const []const u8, std.fmt.allocPrint(a, "{s}_asset_files", .{mod.name}) catch unreachable, asset_files);
|
|
}
|
|
}
|
|
}
|
|
|
|
fn listDir(a: std.mem.Allocator, io: std.Io, root: std.Io.Dir, rel_path: []const u8) []const []const u8 {
|
|
var dir = root.openDir(io, rel_path, .{ .iterate = true }) catch return &.{};
|
|
defer dir.close(io);
|
|
|
|
var files: std.ArrayList([]const u8) = .empty;
|
|
var iter = dir.iterate();
|
|
while (iter.next(io) catch null) |entry| {
|
|
if (entry.kind == .file) {
|
|
files.append(a, a.dupe(u8, entry.name) catch unreachable) catch unreachable;
|
|
}
|
|
}
|
|
|
|
std.mem.sort([]const u8, files.items, {}, struct {
|
|
fn lt(_: void, aa: []const u8, bb: []const u8) bool {
|
|
return std.mem.order(u8, aa, bb) == .lt;
|
|
}
|
|
}.lt);
|
|
|
|
return files.items;
|
|
}
|
|
|
|
/// Walk assets/ recursively, return paths like "markers/assets/Spells/foo.m2"
|
|
fn listAssets(a: std.mem.Allocator, io: std.Io, root: std.Io.Dir, rel_path: []const u8, src_dir: []const u8) []const []const u8 {
|
|
var dir = root.openDir(io, rel_path, .{ .iterate = true }) catch return &.{};
|
|
defer dir.close(io);
|
|
|
|
var paths: std.ArrayList([]const u8) = .empty;
|
|
var walker = dir.walk(a) catch return &.{};
|
|
defer walker.deinit();
|
|
while (walker.next(io) catch null) |entry| {
|
|
if (entry.kind != .file) continue;
|
|
// Only include files in subdirectories (not root of assets/)
|
|
if (std.fs.path.dirname(entry.path) == null) continue;
|
|
paths.append(a, std.fmt.allocPrint(a, "{s}/assets/{s}", .{ src_dir, entry.path }) catch unreachable) catch unreachable;
|
|
}
|
|
|
|
std.mem.sort([]const u8, paths.items, {}, struct {
|
|
fn lt(_: void, aa: []const u8, bb: []const u8) bool {
|
|
return std.mem.order(u8, aa, bb) == .lt;
|
|
}
|
|
}.lt);
|
|
|
|
return paths.items;
|
|
}
|