522 lines
15 KiB
Zig
522 lines
15 KiB
Zig
pub var NeonObjectTable = core.EngineObjectVTable.from(@This(), "main");
|
|
|
|
const GameContext = @This();
|
|
|
|
allocator: std.mem.Allocator,
|
|
pathBuffer: [8192]u8,
|
|
projectNameBuffer: [8192]u8,
|
|
|
|
commandQueue: core.RingQueue(Task),
|
|
|
|
activeCommand: ?*sys.SubprocessTask = null,
|
|
|
|
targetName: ?[]u8 = null,
|
|
targetDir: ?[]u8 = null,
|
|
engineRelative: ?[]u8 = null,
|
|
fingerprint: ?[]const u8 = null,
|
|
|
|
showInstructions: bool = false,
|
|
|
|
const Task = union(enum(u8)) {
|
|
subprocess: *sys.SubprocessTask,
|
|
func: *const fn (*GameContext) void,
|
|
};
|
|
|
|
pub fn init(allocator: std.mem.Allocator) !*@This() {
|
|
const self = try allocator.create(@This());
|
|
self.* = .{
|
|
.allocator = allocator,
|
|
.pathBuffer = std.mem.zeroes([8192]u8),
|
|
.projectNameBuffer = std.mem.zeroes([8192]u8),
|
|
.commandQueue = try core.RingQueue(Task).init(self.allocator, 4096),
|
|
.targetName = try allocator.dupe(u8, "sample"),
|
|
.engineRelative = try allocator.dupe(u8, "Backlog"),
|
|
};
|
|
|
|
std.mem.copyForwards(u8, &self.projectNameBuffer, "newProject");
|
|
return self;
|
|
}
|
|
|
|
pub fn prepare(self: *@This()) !void {
|
|
_ = self;
|
|
core.engine_log("program ready", .{});
|
|
}
|
|
|
|
pub fn tick(self: *@This(), dt: f64) void {
|
|
_ = dt;
|
|
|
|
self.tickTasks() catch {};
|
|
|
|
if (self.activeCommand != null or self.commandQueue.count() > 0) {
|
|
ig.setNextWindowPos(.{ .x = 20, .y = 20 }, .{}, .{});
|
|
|
|
if (ig.begin("tasks", null, .{
|
|
.always_auto_resize = true,
|
|
.no_title_bar = true,
|
|
.no_move = true,
|
|
.no_resize = true,
|
|
.no_collapse = true,
|
|
})) {
|
|
ig.textf("outstanding tasks: {d}", .{self.commandQueue.count() + 1});
|
|
|
|
if (self.activeCommand) |cmd| {
|
|
ig.textf("current command: ", .{});
|
|
|
|
for (cmd.argsOwned.items) |arg| {
|
|
ig.textf("{s}", .{arg});
|
|
ig.sameLine(0, 4);
|
|
}
|
|
}
|
|
}
|
|
|
|
ig.end();
|
|
|
|
return;
|
|
}
|
|
|
|
ig.setNextWindowPos(.{ .x = 200, .y = 200 }, .{}, .{});
|
|
|
|
if (ig.begin("New Project...", null, .{
|
|
.always_auto_resize = true,
|
|
.no_move = true,
|
|
.no_resize = true,
|
|
.no_collapse = true,
|
|
})) {
|
|
if (ig.inputText(
|
|
"##ProjectName",
|
|
&self.projectNameBuffer,
|
|
self.projectNameBuffer.len,
|
|
.{},
|
|
null,
|
|
null,
|
|
)) {
|
|
// core.engine_log("huh", .{});
|
|
}
|
|
|
|
ig.setNextItemWidth(600);
|
|
if (ig.inputText(
|
|
"##Path",
|
|
&self.pathBuffer,
|
|
self.pathBuffer.len,
|
|
.{},
|
|
null,
|
|
null,
|
|
)) {
|
|
// core.engine_log("huh", .{});
|
|
}
|
|
|
|
ig.sameLine(0, 3);
|
|
|
|
if (ig.button("...", .{})) {
|
|
core.engine_log("opening NFD", .{});
|
|
platform.file_dialogue.asyncOpenFolder(.{
|
|
.callback = onFolderSelected,
|
|
.callbackContext = self,
|
|
}) catch @panic(" unable to open dialog");
|
|
}
|
|
|
|
if (ig.button("Create", .{})) {
|
|
const asSlice = std.mem.span(@as([*c]const u8, @ptrCast(&self.pathBuffer)));
|
|
core.engine_log("creating project: {s}", .{self.pathBuffer});
|
|
self.createProject(asSlice) catch {};
|
|
}
|
|
}
|
|
ig.end();
|
|
|
|
if (self.showInstructions) {
|
|
ig.setNextWindowPos(.{ .x = 100, .y = 100 }, .{}, .{});
|
|
ig.setNextWindowSize(.{ .x = 800, .y = 500 }, .{});
|
|
if (ig.begin("Instructions", null, .{
|
|
.always_auto_resize = true,
|
|
.no_move = true,
|
|
.no_resize = true,
|
|
.no_collapse = true,
|
|
})) {
|
|
ig.textf("project generated and git repo cloned, run zig build install and you might need to update the fingerprint", .{});
|
|
|
|
if (ig.button("close..", .{})) {
|
|
self.showInstructions = false;
|
|
}
|
|
}
|
|
ig.end();
|
|
}
|
|
}
|
|
|
|
fn tickTasks(self: *@This()) !void {
|
|
if (self.activeCommand == null) {
|
|
if (self.commandQueue.popFromLocked()) |task| {
|
|
switch (task) {
|
|
.subprocess => |t| {
|
|
self.activeCommand = t;
|
|
// core.engine_log("starting task {any}", .{t.args});
|
|
try t.run();
|
|
},
|
|
.func => |f| {
|
|
f(self);
|
|
},
|
|
}
|
|
}
|
|
}
|
|
|
|
if (self.activeCommand) |active| {
|
|
if (active.checkComplete()) {
|
|
active.destroy();
|
|
core.engine_logs("task complete");
|
|
self.activeCommand = null;
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn createProject(self: *@This(), targetDir: []const u8) !void {
|
|
self.targetDir = try self.allocator.dupe(u8, targetDir);
|
|
|
|
{
|
|
const asSlice = std.mem.span(@as([*c]const u8, @ptrCast(&self.projectNameBuffer)));
|
|
self.targetName = try self.allocator.dupe(u8, asSlice);
|
|
}
|
|
|
|
try self.commandQueue.pushLocked(.{ .subprocess = try sys.runCommand(
|
|
self.allocator,
|
|
&.{ "zig", "init" },
|
|
targetDir,
|
|
) });
|
|
|
|
// const deployShaderDir = try std.fmt.allocPrint(self.allocator, "{s}/content/_shaders", .{self.targetDir.?});
|
|
|
|
if (builtin.os.tag == .windows) {
|
|
// os copy over the entire directory
|
|
} else {}
|
|
|
|
try self.commandQueue.pushLocked(.{ .func = updateBuildZig });
|
|
|
|
try self.commandQueue.pushLocked(.{ .subprocess = try sys.runCommand(
|
|
self.allocator,
|
|
&.{ "git", "clone", "git@github.com:peterino2/BacklogEngine.git", "Backlog" },
|
|
targetDir,
|
|
) });
|
|
|
|
try self.commandQueue.pushLocked(.{ .func = copyShaders });
|
|
try self.commandQueue.pushLocked(.{ .func = displayInstructions });
|
|
}
|
|
|
|
fn copyShaders(self: *@This()) void {
|
|
self.copyShadersWrap() catch {};
|
|
}
|
|
|
|
fn copyShadersWrap(self: *@This()) !void {
|
|
var srcDir = try std.fs.cwd().openDir("content/_shaders", .{ .iterate = true });
|
|
defer srcDir.close();
|
|
|
|
var targetDir = try std.fs.cwd().openDir(self.targetDir.?, .{});
|
|
defer targetDir.close();
|
|
|
|
try targetDir.makeDir("content");
|
|
try targetDir.makeDir("content/_shaders");
|
|
|
|
var dstDir = try targetDir.openDir("content/_shaders", .{});
|
|
defer dstDir.close();
|
|
|
|
try copyRecursiveDir(self.allocator, &srcDir, &dstDir);
|
|
}
|
|
|
|
fn loadFileAllocFromCwd(allocator: std.mem.Allocator, dir: std.fs.Dir, path: []const u8) ![]u8 {
|
|
var file = try dir.openFile(path, .{});
|
|
defer file.close();
|
|
const filesize = (try file.stat()).size + 1; // add null byte
|
|
const buffer: []u8 = try allocator.alloc(u8, filesize);
|
|
errdefer allocator.free(buffer);
|
|
_ = try file.read(buffer[0 .. buffer.len - 1]);
|
|
buffer[buffer.len - 1] = 0;
|
|
return buffer;
|
|
}
|
|
|
|
fn displayInstructions(self: *@This()) void {
|
|
self.showInstructions = true;
|
|
}
|
|
|
|
fn updateBuildZig(self: *@This()) void {
|
|
core.engine_logs("updating build.zig.zon");
|
|
|
|
var workingDir = std.fs.cwd().openDir(self.targetDir.?, .{}) catch return;
|
|
defer workingDir.close();
|
|
|
|
const buildZigZonPath = std.fmt.allocPrint(self.allocator, "{s}/build.zig.zon", .{self.targetDir.?}) catch return;
|
|
defer self.allocator.free(buildZigZonPath);
|
|
|
|
const buildZigContents = loadFileAllocFromCwd(self.allocator, workingDir, buildZigZonPath) catch return;
|
|
defer self.allocator.free(buildZigContents);
|
|
core.engine_log("{s}", .{buildZigContents});
|
|
|
|
// walk forward until we find the fingerprint value
|
|
var window: []const u8 = buildZigContents[0..];
|
|
var offset: usize = 0;
|
|
|
|
while (offset < buildZigContents.len) : (offset += 1) {
|
|
window = buildZigContents[offset..buildZigContents.len];
|
|
if (std.mem.startsWith(u8, window, ".fingerprint")) {
|
|
// walk forward until i find the comma
|
|
var windowEnd: usize = offset;
|
|
while (windowEnd < buildZigContents.len) : (windowEnd += 1) {
|
|
if (buildZigContents[windowEnd] == ',') {
|
|
self.updateFingerPrint(buildZigContents[offset..windowEnd]);
|
|
|
|
self.writeBuildZigFiles() catch {};
|
|
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
core.engine_logs("unable to update window");
|
|
}
|
|
|
|
fn writeBuildZigFiles(self: *@This()) !void {
|
|
// copy over the entire templates directory.
|
|
// 1. make a content folder
|
|
// 2. create src/main.zig
|
|
// 3. build.zig
|
|
// 4. build.zig.zon
|
|
var workingDir = try std.fs.cwd().openDir(self.targetDir.?, .{ .iterate = true });
|
|
defer workingDir.close();
|
|
|
|
core.engine_logs("deleting files...");
|
|
try workingDir.deleteFile("src/root.zig");
|
|
try workingDir.deleteFile("src/main.zig");
|
|
try workingDir.deleteFile("build.zig");
|
|
try workingDir.deleteFile("build.zig.zon");
|
|
|
|
// 1. write src/main.zig
|
|
try self.writeMainZig(&workingDir);
|
|
try self.writeBuildZig(&workingDir);
|
|
try self.writeBuildZigZon(&workingDir);
|
|
}
|
|
|
|
fn writeBuildZig(self: *@This(), workingDir: *std.fs.Dir) !void {
|
|
const out_path = "build.zig";
|
|
|
|
var content = std.ArrayList(u8){};
|
|
defer content.deinit(self.allocator);
|
|
const template =
|
|
\\ const std = @import("std");
|
|
\\ const Backlog = @import("Backlog");
|
|
\\
|
|
\\ pub fn build(b: *std.Build) void {{
|
|
\\ const target = b.standardTargetOptions(.{{}});
|
|
\\ const optimize = b.standardOptimizeOption(.{{}});
|
|
\\
|
|
\\ var blbuild = Backlog.init(b, .{{
|
|
\\ .target = target,
|
|
\\ .optimize = optimize,
|
|
\\ .backlogRoot = "{s}",
|
|
\\ }});
|
|
;
|
|
|
|
try content.print(self.allocator, template, .{self.engineRelative.?});
|
|
|
|
const template2 =
|
|
\\ const program = blbuild.program(.{{
|
|
\\ .name = "{s}",
|
|
\\ .desc = "simple program built with backlog",
|
|
\\ .root_source_file = b.path("src/main.zig"),
|
|
\\ }});
|
|
\\
|
|
\\ program.setModuleEnabled("imgui", true);
|
|
\\
|
|
\\ _ = program.compileInstall();
|
|
\\ }}
|
|
;
|
|
|
|
try content.print(self.allocator, template2, .{self.targetName.?});
|
|
|
|
try content.append(self.allocator, 0);
|
|
|
|
try self.writeZigFile(workingDir, out_path, content.items);
|
|
}
|
|
|
|
const entries: []const struct { name: []const u8, path: []const u8 } = &.{
|
|
.{ .name = "SpirvReflect", .path = "lib/spirv-reflect-zig" },
|
|
.{ .name = "zphysics", .path = "lib/zphysics" },
|
|
.{ .name = "spng", .path = "lib/spng" },
|
|
.{ .name = "ozz", .path = "lib/ozz" },
|
|
.{ .name = "sdl3", .path = "lib/sdl3" },
|
|
.{ .name = "miniaudio", .path = "lib/miniaudio" },
|
|
.{ .name = "lua", .path = "lib/lua" },
|
|
};
|
|
|
|
fn writeBuildZigZon(self: *@This(), workingDir: *std.fs.Dir) !void {
|
|
var content = std.ArrayList(u8){};
|
|
defer content.deinit(self.allocator);
|
|
|
|
try content.print(self.allocator, ".{{\n", .{});
|
|
|
|
try content.print(self.allocator,
|
|
\\ .name = .{s},
|
|
\\ .version = "0.0.0",
|
|
\\ .dependencies = .{{
|
|
\\ .Backlog = .{{ .path = "{s}" }},
|
|
, .{ std.fs.path.basename(self.targetDir.?), self.engineRelative.? });
|
|
|
|
for (entries) |entry| {
|
|
try content.print(self.allocator, " .{s} = .{{ .path = \"{s}/{s}\" }},\n", .{ entry.name, self.engineRelative.?, entry.path });
|
|
}
|
|
|
|
try content.print(self.allocator,
|
|
\\ }},
|
|
\\
|
|
, .{});
|
|
|
|
try content.print(self.allocator,
|
|
\\ .paths = .{{ "" }},
|
|
\\
|
|
, .{});
|
|
|
|
try content.print(self.allocator,
|
|
\\ .fingerprint = {s},
|
|
\\
|
|
, .{self.fingerprint.?});
|
|
|
|
try content.print(self.allocator, "}}", .{});
|
|
|
|
const file = try workingDir.createFile("build.zig.zon", .{});
|
|
defer file.close();
|
|
var writer = file.writer(&wbuf);
|
|
try writer.interface.writeAll(content.items);
|
|
}
|
|
|
|
fn writeMainZig(self: *@This(), workingDir: *std.fs.Dir) !void {
|
|
var content = std.ArrayList(u8){};
|
|
defer content.deinit(self.allocator);
|
|
|
|
const template =
|
|
\\ pub var NeonObjectTable = core.EngineObjectVTable.from(@This(), "main");
|
|
\\
|
|
\\ allocator: std.mem.Allocator,
|
|
\\
|
|
\\ pub fn init(allocator: std.mem.Allocator) !*@This() {
|
|
\\ const self = try allocator.create(@This());
|
|
\\ self.* = .{
|
|
\\ .allocator = allocator,
|
|
\\ };
|
|
\\ return self;
|
|
\\ }
|
|
\\
|
|
\\ pub fn prepare(self: *@This()) !void {
|
|
\\ _ = self;
|
|
\\ core.engine_log("program ready", .{});
|
|
\\ }
|
|
\\
|
|
\\ pub fn tick(self: *@This(), dt: f64) void {
|
|
\\ _ = self;
|
|
\\ _ = dt;
|
|
\\ ig.showDemoWindow(null);
|
|
\\ }
|
|
\\
|
|
\\ pub fn deinit(self: *@This()) void {
|
|
\\ self.allocator.destroy(self);
|
|
\\ }
|
|
\\
|
|
\\ pub fn main() anyerror!void {
|
|
\\ var spec = try api.getSpec("
|
|
;
|
|
|
|
const template2 =
|
|
\\");
|
|
\\ _ = api.startEngine(&NeonObjectTable, &spec);
|
|
\\ }
|
|
\\
|
|
\\ const std = @import("std");
|
|
\\ const api = @import("backlog");
|
|
\\ const ig = api.imgui.api;
|
|
\\ const core = api.core;
|
|
\\
|
|
;
|
|
|
|
const allocator = self.allocator;
|
|
try content.appendSlice(allocator, template);
|
|
try content.appendSlice(allocator, self.targetName.?);
|
|
try content.appendSlice(allocator, template2);
|
|
try content.append(allocator, 0);
|
|
|
|
const out_path = "src/main.zig";
|
|
|
|
std.debug.print("{s}", .{content.items});
|
|
|
|
try self.writeZigFile(workingDir, out_path, content.items);
|
|
}
|
|
|
|
var wbuf: [4096]u8 = undefined;
|
|
fn writeZigFile(self: *@This(), workingDir: *std.fs.Dir, out_path: []const u8, contents: []const u8) !void {
|
|
var ast = try std.zig.Ast.parse(self.allocator, @as([:0]const u8, @ptrCast(contents[0 .. contents.len - 1])), .zig);
|
|
|
|
defer ast.deinit(self.allocator);
|
|
const out = try ast.renderAlloc(self.allocator);
|
|
|
|
const file = try workingDir.createFile(out_path, .{});
|
|
defer file.close();
|
|
var fw = file.writer(&wbuf);
|
|
try fw.interface.writeAll(out);
|
|
}
|
|
|
|
fn updateFingerPrint(self: *@This(), zonEntry: []const u8) void {
|
|
// find the first number
|
|
var left: usize = 0;
|
|
while (zonEntry[left] != '0') : (left += 1) {}
|
|
|
|
core.engine_log(">> FINGERPRINT '{s}'", .{zonEntry[left..zonEntry.len]});
|
|
self.fingerprint = zonEntry[left..zonEntry.len];
|
|
}
|
|
|
|
pub fn onFolderSelected(
|
|
ctx: ?*anyopaque,
|
|
path: ?[]const u8,
|
|
) void {
|
|
const self: *@This() = @ptrCast(@alignCast(ctx));
|
|
if (path) |p| {
|
|
std.mem.copyForwards(u8, &self.pathBuffer, p);
|
|
self.pathBuffer[p.len] = 0;
|
|
}
|
|
}
|
|
|
|
pub fn deinit(self: *@This()) void {
|
|
if (self.targetDir) |t| {
|
|
self.allocator.free(t);
|
|
}
|
|
self.allocator.destroy(self);
|
|
}
|
|
|
|
fn copyRecursiveDir(
|
|
allocator: std.mem.Allocator,
|
|
src_dir: *std.fs.Dir,
|
|
dest_dir: *std.fs.Dir,
|
|
) !void {
|
|
var walker = try src_dir.walk(allocator);
|
|
defer walker.deinit();
|
|
|
|
while (try walker.next()) |entry| {
|
|
switch (entry.kind) {
|
|
.file => {
|
|
try entry.dir.copyFile(entry.basename, dest_dir.*, entry.path, .{});
|
|
},
|
|
.directory => {
|
|
try dest_dir.makeDir(entry.path);
|
|
},
|
|
else => {},
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn main() anyerror!void {
|
|
var spec = try api.getSpec("New Project Dialogue");
|
|
try spec.put("useGPA", .{ .boolean = false });
|
|
_ = api.startEngine(&NeonObjectTable, &spec);
|
|
}
|
|
|
|
const builtin = @import("builtin");
|
|
const std = @import("std");
|
|
const api = @import("backlog");
|
|
const ig = api.imgui.api;
|
|
const platform = api.platform;
|
|
const core = api.core;
|
|
const sys = api.sys;
|