133 lines
3.7 KiB
Zig
133 lines
3.7 KiB
Zig
const std = @import("std");
|
|
const assert = std.debug.assert;
|
|
|
|
const UUID = @import("../common/uuid.zig").UUID;
|
|
|
|
const mat = @import("../math/mat.zig");
|
|
const Mat4f = mat.Mat4f;
|
|
const Mat3f = mat.Mat3f;
|
|
const vec = @import("../math/vec.zig");
|
|
const Vec4f = vec.Vec4f;
|
|
const Quat = @import("../math/quat.zig").Quat;
|
|
const Box3d = @import("../math/box.zig").Box3d;
|
|
const Mesh = @import("meshes.zig").Mesh;
|
|
const Material = @import("materials.zig").Material;
|
|
|
|
// TODO memory
|
|
var gpa = std.heap.GeneralPurposeAllocator(.{}){};
|
|
const allocator = gpa.allocator();
|
|
|
|
const Entities = @This();
|
|
|
|
var s_entities: Entities = undefined;
|
|
|
|
names: std.ArrayList(UUID),
|
|
meshes: std.ArrayList(Mesh.Id),
|
|
bounds: std.ArrayList(Box3d),
|
|
materials: std.ArrayList(Material),
|
|
matrices: std.ArrayList(Mat4f),
|
|
inv_matrices: std.ArrayList(Mat3f),
|
|
translations: std.ArrayList(Vec4f),
|
|
rotations: std.ArrayList(Quat),
|
|
scales: std.ArrayList(Vec4f),
|
|
mod_time: std.time.Instant,
|
|
|
|
pub fn init() void {
|
|
s_entities.names = std.ArrayList(UUID).init(allocator);
|
|
s_entities.meshes = std.ArrayList(Mesh.Id).init(allocator);
|
|
s_entities.bounds = std.ArrayList(Box3d).init(allocator);
|
|
s_entities.materials = std.ArrayList(Material).init(allocator);
|
|
s_entities.matrices = std.ArrayList(Mat4f).init(allocator);
|
|
s_entities.inv_matrices = std.ArrayList(Mat3f).init(allocator);
|
|
s_entities.translations = std.ArrayList(Vec4f).init(allocator);
|
|
s_entities.rotations = std.ArrayList(Quat).init(allocator);
|
|
s_entities.scales = std.ArrayList(Vec4f).init(allocator);
|
|
s_entities.mod_time = std.time.Instant.now();
|
|
}
|
|
|
|
pub fn update() void {}
|
|
|
|
pub fn get() *const Entities {
|
|
return &s_entities;
|
|
}
|
|
|
|
pub fn deinit() void {
|
|
delete(get());
|
|
s_entities.names.deinit();
|
|
s_entities.meshes.deinit();
|
|
s_entities.bounds.deinit();
|
|
s_entities.materials.deinit();
|
|
s_entities.matrices.deinit();
|
|
s_entities.inv_matrices.deinit();
|
|
s_entities.translations.deinit();
|
|
s_entities.rotations.deinit();
|
|
s_entities.scales.deinit();
|
|
}
|
|
|
|
pub fn add(self: *const Entities, name: UUID) !i32 {
|
|
self.names.append(name);
|
|
self.translations.append(Vec4f.zero);
|
|
self.scales.append(Vec4f.one);
|
|
self.rotations.append(Quat.id);
|
|
self.matrices.append(Mat4f.id);
|
|
self.inv_matrices.append(Mat3f.id);
|
|
self.mod_time = std.time.Instant.now();
|
|
}
|
|
|
|
pub fn destroyAtIndex(ents: *const Entities, i: i32) void {
|
|
assert(i >= 0);
|
|
assert(i < ents.names.len);
|
|
ents.meshes[i].release();
|
|
ents.materials[i].albedo.release();
|
|
ents.materials[i].rome.release();
|
|
ents.materials[i].normal.release();
|
|
}
|
|
|
|
pub fn removeAtIndex(ents: *const Entities, i: i32) void {
|
|
ents.destroyAtIndex(i);
|
|
|
|
ents.names.swapRemove(i);
|
|
ents.meshes.swapRemove(i);
|
|
ents.bounds.swapRemove(i);
|
|
ents.materials.swapRemove(i);
|
|
ents.matrices.swapRemove(i);
|
|
ents.inv_matrices.swapRemove(i);
|
|
ents.translations.swapRemove(i);
|
|
ents.rotations.swapRemove(i);
|
|
ents.scales.swapRemove(i);
|
|
}
|
|
|
|
pub fn rm(ents: *const Entities, name: UUID) bool {
|
|
if (ents.find(name)) |i| {
|
|
ents.removeAtIndex(i);
|
|
ents.mod_time = std.time.Instant.now();
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
pub fn find(ents: *const Entities, name: UUID) ?i32 {
|
|
return ents.names.find(name);
|
|
}
|
|
|
|
pub fn clear(ents: *const Entities) void {
|
|
for (ents.names) |_, i| {
|
|
ents.destroyAtIndex(i);
|
|
}
|
|
ents.mod_time = std.time.Instant.now();
|
|
}
|
|
|
|
pub fn delete(ents: *const Entities) void {
|
|
ents.clear();
|
|
ents.names.clearAndFree();
|
|
ents.meshes.clearAndFree();
|
|
ents.bounds.clearAndFree();
|
|
ents.materials.clearAndFree();
|
|
ents.matrices.clearAndFree();
|
|
ents.inv_matrices.clearAndFree();
|
|
ents.translations.clearAndFree();
|
|
ents.rotations.clearAndFree();
|
|
ents.scales.clearAndFree();
|
|
}
|