Add safe casting from one Storage Subset to another

[hubidubi13]

Sometimes I write helper functions that need access to specific components of the ECS storage. These functions might be used from different systems, with different storage subsets. It would be nice, if there was some sort of compile time checked casting between different subsets, maybe like this:

const Storage = ecez.CreateStorage(.{
    Position,
    Velocity,
});

const All = Storage.Subset(.{
    *Position,
    *Velocity,
});

const PosRead = Storage.Subset(.{Position});

var storage = Storage.init(alloc);
var all = All{ .storage = &storage };
var pos_read = PosRead{ .storage = &storage };

// casting
const all_cast = pos_read.cast(All); // -> Not allowed, compile error
const pos_read_cast = all.cast(PosRead); // -> Allowed, returns *PosRead

Currently, I am simply using @ptrCast. It works, but there are no checks. If this could be done automatically by coercion somehow, it would be magical! But I don't think that is currently possible with the zig type system.

[Avokadoen]

Related: #197

Yeah coercion sadly wont work. The explicit cast implementation would be relatively easy to implement however.

Are you using Storage Subsets outside of systems, and if so, for what purpose?

[hubidubi13]

Basically, I am trying to encode a graph in ecez with a quad edge component. Since that is essentially what the tile map in dizc is. I ended up using the same code snippets throughout different systems operating on this graph, so I created some helper functions with storage subsets in their function signature. It looks something like this:

const Edge = struct {
    vertex: ?Entity,
    dual: Entity,
    next: Entity,
};

const Edges = Storage.Subset(.{Edge});

fn dual(id: Entity, storage: *Edges) !Entity {
    const edge = storage.getComponent(id, Edge) orelse error;
    return edge.dual;
}

fn reverse(id: Entity, storage: *Edges) !Entity {
    const dual_ = try dual(id, sotrage);
    return dual_.dual;
}

// or using the values as input
fn dualValue(edge: Edge, storage: *Edges) !Edge {
    const dual = storage.getComponent(id.dual, Edge) orelse error;
    return dual;
}

fn reverseValue(edge: Edge, storage: *Edges) !Edge {
    const dual_ = try dualValue(id, sotrage);
    const rev = storage.getComponent(dual_.dual, Edge) orelse error;
    return rev;
}

fn system(subset: *OtherSubsetContainingEdge) void {
    const edges: *Edges = @ptrCast(subset);
    const rev = reverse(id, edges) catch ...;
}

I am not yet certain, that this is even a good idea. But I think it could also provide something similar to relationships in flecs and other ECS.

[Avokadoen]

That's interesting! I guess a potential issue with this is how often you end up doing sporadic access.

I'm traveling tomorrow and won't be back for 7 days. This feature would basically reuse logic that already exist when creating a subset from storage. I will implement this as soon as i get the chance, but feel free to take a stab at it if you want.

[hubidubi13]

Yeah, the sporadic access might be a bit of a problem. I couldn't come up with an easy solution, even if the graph does not live inside the ecs.

Enjoy your travels!