259 lines
7.1 KiB
Zig
259 lines
7.1 KiB
Zig
const std = @import("std");
|
|
const utils = @import("utils.zig");
|
|
|
|
const Registry = @import("registry.zig").Registry;
|
|
const Storage = @import("registry.zig").Storage;
|
|
const Entity = @import("registry.zig").Entity;
|
|
|
|
/// single item view. Iterating raw() directly is the fastest way to get at the data.
|
|
pub fn BasicView(comptime T: type) type {
|
|
return struct {
|
|
const Self = @This();
|
|
|
|
storage: *Storage(T),
|
|
|
|
pub fn init(storage: *Storage(T)) Self {
|
|
return Self{
|
|
.storage = storage,
|
|
};
|
|
}
|
|
|
|
pub fn len(self: Self) usize {
|
|
return self.storage.len();
|
|
}
|
|
|
|
/// Direct access to the array of components
|
|
pub fn raw(self: Self) []T {
|
|
return self.storage.raw();
|
|
}
|
|
|
|
/// Direct access to the array of entities
|
|
pub fn data(self: Self) *const []Entity {
|
|
return self.storage.data();
|
|
}
|
|
|
|
/// Returns the object associated with an entity
|
|
pub fn get(self: Self, entity: Entity) *T {
|
|
return self.storage.get(entity);
|
|
}
|
|
|
|
pub fn getConst(self: *Self, comptime T: type, entity: Entity) T {
|
|
return self.storage.getConst(entity);
|
|
}
|
|
};
|
|
}
|
|
|
|
pub fn BasicMultiView(comptime n_includes: usize, comptime n_excludes: usize) type {
|
|
return struct {
|
|
const Self = @This();
|
|
|
|
registry: *Registry,
|
|
type_ids: [n_includes]u32,
|
|
exclude_type_ids: [n_excludes]u32,
|
|
|
|
pub const Iterator = struct {
|
|
view: *Self,
|
|
index: usize = 0,
|
|
entities: *const []Entity,
|
|
|
|
pub fn init(view: *Self) Iterator {
|
|
const ptr = view.registry.components.getValue(@intCast(u8, view.type_ids[0])).?;
|
|
return .{
|
|
.view = view,
|
|
.entities = @intToPtr(*Storage(u8), ptr).data(),
|
|
};
|
|
}
|
|
|
|
pub fn next(it: *Iterator) ?Entity {
|
|
if (it.index >= it.entities.len) return null;
|
|
|
|
blk: while (it.index < it.entities.len) : (it.index += 1) {
|
|
const entity = it.entities.*[it.index];
|
|
|
|
// entity must be in all other Storages
|
|
for (it.view.type_ids) |tid| {
|
|
const ptr = it.view.registry.components.getValue(@intCast(u8, tid)).?;
|
|
if (!@intToPtr(*Storage(u1), ptr).contains(entity)) {
|
|
break :blk;
|
|
}
|
|
}
|
|
|
|
// entity must not be in all other excluded Storages
|
|
for (it.view.exclude_type_ids) |tid| {
|
|
const ptr = it.view.registry.components.getValue(@intCast(u8, tid)).?;
|
|
if (@intToPtr(*Storage(u1), ptr).contains(entity)) {
|
|
break :blk;
|
|
}
|
|
}
|
|
|
|
it.index += 1;
|
|
return entity;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
// Reset the iterator to the initial index
|
|
pub fn reset(it: *Iterator) void {
|
|
it.index = 0;
|
|
}
|
|
};
|
|
|
|
pub fn init(registry: *Registry, type_ids: [n_includes]u32, exclude_type_ids: [n_excludes]u32) Self {
|
|
return Self{
|
|
.registry = registry,
|
|
.type_ids = type_ids,
|
|
.exclude_type_ids = exclude_type_ids,
|
|
};
|
|
}
|
|
|
|
pub fn get(self: *Self, comptime T: type, entity: Entity) *T {
|
|
return self.registry.assure(T).get(entity);
|
|
}
|
|
|
|
pub fn getConst(self: *Self, comptime T: type, entity: Entity) T {
|
|
return self.registry.assure(T).getConst(entity);
|
|
}
|
|
|
|
fn sort(self: *Self) void {
|
|
// get our component counts in an array so we can sort the type_ids based on how many entities are in each
|
|
var sub_items: [n_includes]usize = undefined;
|
|
for (self.type_ids) |tid, i| {
|
|
const ptr = self.registry.components.getValue(@intCast(u8, tid)).?;
|
|
const store = @intToPtr(*Storage(u8), ptr);
|
|
sub_items[i] = store.len();
|
|
}
|
|
|
|
utils.sortSub(usize, u32, sub_items[0..], self.type_ids[0..], std.sort.asc(usize));
|
|
}
|
|
|
|
pub fn iterator(self: *Self) Iterator {
|
|
self.sort();
|
|
return Iterator.init(self);
|
|
}
|
|
};
|
|
}
|
|
|
|
test "single basic view" {
|
|
var store = Storage(f32).init(std.testing.allocator);
|
|
defer store.deinit();
|
|
|
|
store.add(3, 30);
|
|
store.add(5, 50);
|
|
store.add(7, 70);
|
|
|
|
var view = BasicView(f32).init(&store);
|
|
std.testing.expectEqual(view.len(), 3);
|
|
|
|
store.remove(7);
|
|
std.testing.expectEqual(view.len(), 2);
|
|
}
|
|
|
|
test "single basic view data" {
|
|
var store = Storage(f32).init(std.testing.allocator);
|
|
defer store.deinit();
|
|
|
|
store.add(3, 30);
|
|
store.add(5, 50);
|
|
store.add(7, 70);
|
|
|
|
var view = BasicView(f32).init(&store);
|
|
|
|
std.testing.expectEqual(view.get(3).*, 30);
|
|
|
|
for (view.data().*) |entity, i| {
|
|
if (i == 0)
|
|
std.testing.expectEqual(entity, 3);
|
|
if (i == 1)
|
|
std.testing.expectEqual(entity, 5);
|
|
if (i == 2)
|
|
std.testing.expectEqual(entity, 7);
|
|
}
|
|
|
|
for (view.raw()) |data, i| {
|
|
if (i == 0)
|
|
std.testing.expectEqual(data, 30);
|
|
if (i == 1)
|
|
std.testing.expectEqual(data, 50);
|
|
if (i == 2)
|
|
std.testing.expectEqual(data, 70);
|
|
}
|
|
|
|
std.testing.expectEqual(view.len(), 3);
|
|
}
|
|
|
|
test "basic multi view" {
|
|
var reg = Registry.init(std.testing.allocator);
|
|
defer reg.deinit();
|
|
|
|
var e0 = reg.create();
|
|
var e1 = reg.create();
|
|
var e2 = reg.create();
|
|
|
|
reg.add(e0, @as(i32, -0));
|
|
reg.add(e1, @as(i32, -1));
|
|
reg.add(e2, @as(i32, -2));
|
|
|
|
reg.add(e0, @as(u32, 0));
|
|
reg.add(e2, @as(u32, 2));
|
|
|
|
var single_view = reg.view(.{u32}, .{});
|
|
var view = reg.view(.{ i32, u32 }, .{});
|
|
|
|
var iterated_entities: usize = 0;
|
|
var iter = view.iterator();
|
|
while (iter.next()) |entity| {
|
|
iterated_entities += 1;
|
|
}
|
|
|
|
std.testing.expectEqual(iterated_entities, 2);
|
|
iterated_entities = 0;
|
|
|
|
reg.remove(u32, e0);
|
|
|
|
iter.reset();
|
|
while (iter.next()) |entity| {
|
|
iterated_entities += 1;
|
|
}
|
|
|
|
std.testing.expectEqual(iterated_entities, 1);
|
|
}
|
|
|
|
test "basic multi view with excludes" {
|
|
var reg = Registry.init(std.testing.allocator);
|
|
defer reg.deinit();
|
|
|
|
var e0 = reg.create();
|
|
var e1 = reg.create();
|
|
var e2 = reg.create();
|
|
|
|
reg.add(e0, @as(i32, -0));
|
|
reg.add(e1, @as(i32, -1));
|
|
reg.add(e2, @as(i32, -2));
|
|
|
|
reg.add(e0, @as(u32, 0));
|
|
reg.add(e2, @as(u32, 2));
|
|
|
|
reg.add(e2, @as(u8, 255));
|
|
|
|
var view = reg.view(.{ i32, u32 }, .{u8});
|
|
|
|
var iterated_entities: usize = 0;
|
|
var iter = view.iterator();
|
|
while (iter.next()) |entity| {
|
|
iterated_entities += 1;
|
|
}
|
|
|
|
std.testing.expectEqual(iterated_entities, 1);
|
|
iterated_entities = 0;
|
|
|
|
reg.remove(u8, e2);
|
|
|
|
iter.reset();
|
|
while (iter.next()) |entity| {
|
|
iterated_entities += 1;
|
|
}
|
|
|
|
std.testing.expectEqual(iterated_entities, 2);
|
|
}
|