Dynamic Runtime Systems/Schedules - For bindings to bevy

[ScottKane]

I am creating bindings to bevy for C#, there have been some challenges with C#'s lack of flexibility with generic constraints but I have settled on something that seems reasonable. I was able to get started following this example: https://github.com/bevyengine/bevy/blob/main/examples/ecs/dynamic.rs.

So far the C# code looks like this:

var app = new App();
var world = app.World;

world.RegisterComponent<Example1>();
world.RegisterComponent<Example2>();
world.RegisterComponent<Example3>();

world.SpawnComponents((
    new Example1 { A = 0, B = 1, C = 2 },
    new Example2 { D = 3, E = 4, F = 5, G = 6 }
));
world.SpawnComponents((
    new Example1 { A = 7, B = 8, C = 9 },
    new Example2 { D = 10, E = 11, F = 12, G = 13 }
));
world.SpawnComponents((
    new Example1 { A = 14, B = 15, C = 16 },
    new Example2 { D = 17, E = 18, F = 19, G = 20 },
    new Example3 { H = 21, I = 22, J = 23 }
));

Console.WriteLine("QUERY 1");
Console.WriteLine("----------------------");
var query1 = new Query<Example1>(world);
for (var i = 0; i < query1.Count; i++)
{
    ref var example1 = ref query1.Get<Example1>(i);
    Console.WriteLine($"Example1: A: {example1.A}, B: {example1.B}, C: {example1.C}");
    Console.WriteLine("----------------------");
}

Console.WriteLine();
Console.WriteLine();

var query2 = new Query<Example1, Mut<Example2>>(world);

Console.WriteLine("QUERY 2");
Console.WriteLine("----------------------");
for (var i = 0; i < query2.Count; i++)
{
    ref var example1 = ref query2.Get<Example1>(i);
    ref var example2 = ref query2.Get<Example2>(i);
    Console.WriteLine($"Example1: A: {example1.A}, B: {example1.B}, C: {example1.C}");
    Console.WriteLine($"Example2: D: {example2.D}, E: {example2.E}, F: {example2.F}, G: {example2.G}");
    example2.D = 100;
    Console.WriteLine("----------------------");
}

Console.WriteLine();
Console.WriteLine();

var query3 = new Query<Example1, Mut<Example2>>(world);

Console.WriteLine("QUERY 3");
Console.WriteLine("----------------------");

for (var i = 0; i < query3.Count; i++)
{
    ref var example1 = ref query3.Get<Example1>(i);
    ref var example2 = ref query3.Get<Example2>(i);
    Console.WriteLine($"Example1: A: {example1.A}, B: {example1.B}, C: {example1.C}");
    Console.WriteLine($"Example2: D: {example2.D}, E: {example2.E}, F: {example2.F}, G: {example2.G}");
    Console.WriteLine("----------------------");
}

Console.WriteLine();
Console.WriteLine();

var query4 = new Query<Example3>(world);

Console.WriteLine("QUERY 4");
Console.WriteLine("----------------------");
for (var i = 0; i < query4.Count; i++)
{
    ref var example3 = ref query4.Get<Example3>(i);
    Console.WriteLine($"Example3: A: {example3.H}, B: {example3.I}, C: {example3.J}");
    Console.WriteLine("----------------------");
}

[Component]
public partial record struct Example1(int A, int B, int C);

[Component]
public partial record struct Example2(int D, int E, int F, int G);

[Component]
public partial record struct Example3(int H, int I, int J);

There will likely be some changes to make getting mutable references out more ergonomic but this works for now. I haven't been able to find any information on runtime dynamic systems/schedules so I'm unsure where to go next, would the idea be that I just create a rust system that runs in each schedule to call a function pointer into my library and build out the API on the C# side or is there a runtime API I haven't come across?

For a bit of context on how things are currently working, I register the types in bevy and use their ID's to construct dynamic queries, then just pass the pointers over to C# to interpret as the correct types which gives me a query I can iterate over. With this I could technically build up systems in C# but I would rather not worry about the parallel mutability concerns if possible.

And ideas would be appreciated.

Thanks

[ScottKane]

As far as I can tell, we need a QueryData or QueryFilter (don't know enough about the inner workings of bevy to make an informed descision here) to implement SystemParam, that way on a per dynamic query basis we can register a system that uses it. Maybe something like:

fn system(query: QueryState<FilteredEntityMut>) {

}

Where we can manually register the system, passing in the dynamic query so that the scheduler knows what it can/can't run in parallel.

let mut system = IntoSystem::into_system(system);
system.bind_query(QueryBuilder::<FilteredEntityMut>::new(&mut (*world)).ref_id(ComponentId::new(some non rust component 
system.initialize(&mut (*world));

It would be good if I can just register this same function as a system multiple times binding differen't queries so that I have a SystemId I can pass back to C# to know which function pointer we are invoking.

I have also refined the C# API to look much more like the Rust API, still need to swap query params to tuples so that the query syntax is exactly the same but it's getting there:

var app = new App();
var world = app.World;

world.RegisterType<Example1>();
world.RegisterType<Example2>();
world.RegisterType<Example3>();

world.Spawn((
    new Example1 { A = 0, B = 1, C = 2 },
    new Example2 { D = 3, E = 4, F = 5, G = 6 }
));
world.Spawn((
    new Example1 { A = 7, B = 8, C = 9 },
    new Example2 { D = 10, E = 11, F = 12, G = 13 }
));
world.Spawn((
    new Example1 { A = 14, B = 15, C = 16 },
    new Example2 { D = 17, E = 18, F = 19, G = 20 },
    new Example3 { H = 21, I = 22, J = 23 }
));

TestSystem1.Run(new Query<Example1, Mut<Example2>>(world));
TestSystem2.Run(new Query<Example1, Example2>(world));


[Component]
public partial record struct Example1(int A, int B, int C);

[Component]
public partial record struct Example3(int H, int I, int J);


[Component]
public partial record struct Example2(int D, int E, int F, int G);


[System]
public struct TestSystem1
{
    public static void Run(Query<Example1, Mut<Example2>> query)
    {
        query.ForEach((Example1 example1, ref Example2 example2) =>
        {
            Console.WriteLine($"Example1: A: {example1.A}, B: {example1.B}, C: {example1.C}");
            Console.WriteLine($"Example2: D: {example2.D}, E: {example2.E}, F: {example2.F}, G: {example2.G}");
            example2.D = 100;
            Console.WriteLine("----------------------");
        });
        
        // Iterating a 2nd time to show mutation works
        query.ForEach((Example1 example1, ref Example2 example2) =>
        {
            Console.WriteLine($"Example1: A: {example1.A}, B: {example1.B}, C: {example1.C}");
            Console.WriteLine($"Example2: D: {example2.D}, E: {example2.E}, F: {example2.F}, G: {example2.G}");
            Console.WriteLine("----------------------");
        });
    }
}

[System]
public struct TestSystem2
{
    public static void Run(Query<Example1, Example2> query)
    {
        query.ForEach((example1, example2) =>
        {
            Console.WriteLine($"Example1: A: {example1.A}, B: {example1.B}, C: {example1.C}");
            Console.WriteLine($"Example2: D: {example2.D}, E: {example2.E}, F: {example2.F}, G: {example2.G}");
            Console.WriteLine("----------------------");
        });
    }
}

There is a lot of code gen magic to make this work, namely the Query needs some way to define that the access you want to a component is mutable, to do this I have a Mut<T> interface that uses some of C#'s newer features to allow me to get the inner component properly:

public interface Mut<T> : IComponent<T>
{
    static nuint IComponent.GetId(Dictionary<string, nuint> components) => components[typeof(T).Name];
    static unsafe ref T IComponent<T>.Get(nuint** components, int index, int step, int offset) => ref Unsafe.AsRef<T>(components[index * step + offset]);
}

This allows me to take some T that implements IComponent (both user components and Mut do) and just statically call T.GetId() and ref T.Get() respectively.

Per system I generate extensions for the Query type with a custom delegate that allows me to define which generic params are mutable. The generated code for the above example looks like this:

For everything with the [Component] attribute:

[StructLayout(LayoutKind.Sequential)]
public partial record struct Example1 : IComponent<Example1>
{
    public static nuint GetId(Dictionary<string, nuint> components)
    {
        return components[nameof(Example1)];
    }
    
    public static unsafe ref Example1 Get(nuint** components, int index, int step, int offset)
    {
        return ref Unsafe.AsRef<Example1>(components[index * step + offset]);
    }
}

For everything with the [System] attribute:

public static partial class TestSystem1Extensions
{
    public delegate void QueryExample1MutExample2Action<T1, T2>(T1 t1, ref T2 t2);
    
    public static void ForEach(this Query<Example1, Mut<Example2>> query, QueryExample1MutExample2Action<Example1, Example2> action)
    {
        for (var i = 0; i < query.Count; i++)
            action(query.Get<Example1>(i, 0), ref query.Get<Example2>(i, 1));
    }
}

There are also questions around passing data to the asset server, obviously in rust you have the assets directory that gets packaged up with the binary. The same is possible in C# so is it possible for me to pass the bytes encoded into the C# binary over FFI to rust to load at runtime? If so, what might that look like?

[ScottKane]

@james-j-obrien When I was digging through your PR I had seen TermQuery but seems that got flattened, is there currently a way to use a dynamically built query as a SystemParam or is there further work that needs to be done to support this for systems?

[james-j-obrien]

Using a dynamic query in a system will be unblocked by this PR: #13123

[ScottKane]

Awesome thanks!

[Fidius-jko]

Can you post this code on github? This may be useful for me.

[ScottKane]

I will be open sourcing the project once it becomes stable. What I currently have allows me to pass data between rust and C# safely and I have managed to get the API pretty close to the rust API.

I will need the work mentioned above to support systems and scheduling. One that is done I will need to add support for resources and I will feel comfortable about an initial public version