127 lines
3.6 KiB
Zig
127 lines
3.6 KiB
Zig
allocator: std.mem.Allocator,
|
|
gltfs: std.StringHashMapUnmanaged(GltfData) = .{},
|
|
stringArena: std.heap.ArenaAllocator,
|
|
|
|
filesToProcess: std.ArrayListUnmanaged(FileToProcess) = .{},
|
|
|
|
pub const FileToProcess = struct {
|
|
path: []const u8,
|
|
};
|
|
|
|
pub const GltfAnimationData = struct {
|
|
name: []const u8,
|
|
};
|
|
|
|
pub const GltfData = struct {
|
|
filePath: []u8,
|
|
animations: std.ArrayListUnmanaged(GltfAnimationData) = .{},
|
|
};
|
|
|
|
pub fn create(allocator: std.mem.Allocator) !*@This() {
|
|
const self = try allocator.create(@This());
|
|
|
|
self.* = .{
|
|
.allocator = allocator,
|
|
.stringArena = std.heap.ArenaAllocator.init(allocator),
|
|
};
|
|
|
|
try self.setupCallbacks();
|
|
try self.initialLoad();
|
|
|
|
return self;
|
|
}
|
|
|
|
pub fn setupCallbacks(self: *@This()) !void {
|
|
core.fs().watchPath("content/");
|
|
try core.fs().addAnyWatchCallback(fileChangedCallback, self);
|
|
}
|
|
|
|
pub fn scanAll(self: *@This(), dir_path: []const u8) !void {
|
|
var dir = try std.fs.cwd().openDir(dir_path, .{ .iterate = true });
|
|
defer dir.close();
|
|
|
|
var it = dir.iterate();
|
|
while (try it.next()) |entry| {
|
|
const full_path = try std.fs.path.join(self.allocator, &.{ dir_path, entry.name });
|
|
defer self.allocator.free(full_path);
|
|
|
|
if (entry.kind == .directory) {
|
|
if (std.mem.eql(u8, entry.name, "_shaders")) {
|
|
continue;
|
|
}
|
|
try self.scanAll(full_path); // Recursive call for subdirectories
|
|
} else if (entry.kind == .file) {
|
|
// core.engine_log("processing file: {s}", .{entry.name});
|
|
try self.filesToProcess.append(self.allocator, .{ .path = entry.name });
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn initialLoad(self: *@This()) !void {
|
|
try self.scanAll("content/");
|
|
}
|
|
|
|
pub fn fileChangedCallback(path: []const u8, ctx: ?*anyopaque) void {
|
|
const self: *@This() = @ptrCast(@alignCast(ctx.?));
|
|
// core.engine_log("file change seen {s}", .{path});
|
|
//
|
|
self.filesToProcess.append(self.allocator, .{ .path = path }) catch {};
|
|
// self.updatePath(path) catch return;
|
|
}
|
|
|
|
fn salloc(self: *@This()) std.mem.Allocator {
|
|
return self.stringArena.allocator();
|
|
}
|
|
|
|
pub fn updatePath(self: *@This(), path: []const u8) !void {
|
|
core.engine_log("updating Path: {s}", .{path});
|
|
if (std.mem.endsWith(u8, path, ".ozz")) {}
|
|
|
|
if (std.mem.endsWith(u8, path, ".gltf")) {
|
|
// 1. check if there is a .cook file
|
|
// if there is a .cook file
|
|
// then dont load, no further actions needed
|
|
|
|
const pathstr = try std.fmt.allocPrint(self.salloc(), "{s}.cook", .{path[0 .. path.len - 5]});
|
|
defer self.salloc().free(pathstr);
|
|
|
|
core.engine_log("checking path: {s}", pathstr);
|
|
|
|
if (!core.fs().fileExists(pathstr)) {
|
|
// create a cook file under the pathstr, the file watcher should see it..
|
|
core.engine_log("creating cooker {s}", .{pathstr});
|
|
}
|
|
|
|
//var name = core.MakeName(pathstr);
|
|
// if there is a cook file
|
|
// var mapping = try core.fs().loadFile(path);
|
|
// zgltf.init(self.allocator);
|
|
// core.fs().unmap(mapping);
|
|
}
|
|
}
|
|
|
|
pub fn tick(self: *@This()) void {
|
|
const start = core.getEngineTime();
|
|
|
|
while (self.filesToProcess.pop()) |pop| {
|
|
const now = core.getEngineTime();
|
|
if (now - start > 0.050) {
|
|
break;
|
|
}
|
|
|
|
self.updatePath(pop.path) catch {};
|
|
}
|
|
}
|
|
|
|
pub fn destroy(self: *@This()) void {
|
|
self.allocator.destroy(self);
|
|
}
|
|
|
|
const std = @import("std");
|
|
const api = @import("backlog");
|
|
const imgui = api.imgui;
|
|
const ig = api.imgui.api;
|
|
const core = api.core;
|
|
const sys = api.sys;
|
|
const zgltf = core.zgltf;
|