chain/before/after/run_if with system builder API

[ScottKane]

Sorry for the code dump but cant really convey the scenario without. I'm currently building bindings for Bevy, so far I am able to register components and systems with system params from C#. That looks like this:

using Bevy;

new App()
    .Default()
    .AddPlugin<TestPlugin>()
    .AddSystem<Startup, Setup>()
    .AddSystem<Update, Rotate>()
    .Run();

[Component]
partial record struct Rotatable(float Speed = 0.3f);

[System]
public partial struct Setup
{
    static void Run(Commands commands, ResMut<Assets<Mesh>> meshes, ResMut<Assets<StandardMaterial>> materials)
    {
        commands.Spawn((
            new Mesh3d(meshes.Value.Add(Cuboid.Default)),
            new MeshMaterial3d<StandardMaterial>(materials.Value.Add(Color.White)),
            Transform.Identity,
            new Rotatable(0.5f)
        ));
    
        commands.Spawn((
            new Camera3d(),
            Transform.FromTranslation(0, 10, 20).LookingAt(Vec3.Zero, Vec3.UnitY)
        ));
        
        commands.Spawn((
            new DirectionalLight(),
            Transform.FromTranslation(3, 3, 3).LookingAt(Vec3.Zero, Vec3.UnitY)
        ));
    }
}

[System]
public partial struct Assets
{
    static void Run(Res<AssetServer> assets)
    {
        var handle = assets.Value.Load<Scene>("Models/Weapons.glb#Scene0");
        var state = assets.Value.LoadState(handle.Id);
        Console.WriteLine($"Weapons scene load state: {state}");
    }
}

[System]
public partial struct Rotate
{
    static void Run(Query<Mut<Transform>, Rotatable> cubes, Res<Time> timer)
    {
        cubes.ForEach((ref Transform transform, Rotatable rotatable) =>
        {
            transform.RotateY(rotatable.Speed * MathF.Tau * timer.Value.DeltaSecs);
        });
    }
}

public partial struct TestPlugin : IPlugin
{
    public static void Build(App app) => app.AddSystem<Startup, Assets>();
}

This is how I do system registration:

#[repr(C)]
pub struct SystemData {
    pub queries: *const QueryData,
    pub query_count: usize,
    pub resources: *const ResourceData,
    pub resource_count: usize,
    pub use_commands: bool,
    pub callback: unsafe extern "cdecl" fn(SystemResult),
    pub schedule: ScheduleKind,
}

#[repr(C)]
pub struct QueryData {
    pub data: *const ComponentData,
    pub count: usize,
}

#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ComponentData {
    pub id: usize,
    pub kind: ComponentKind,
}

#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub enum ComponentKind {
    Reference,
    Mutable,
    With,
    Without,
}

#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ResourceData {
    pub id: usize,
    pub kind: ResourceKind,
}

#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub enum ResourceKind {
    Immutable,
    Mutable,
}

#[unsafe(no_mangle)]
pub unsafe extern "cdecl" fn system_new(app: *mut App, request: SystemData) {
    let query_params = create_query_params(&request);
    let resource_params = create_resource_params(&request);

    match (query_params, resource_params, request.use_commands) {
        (Some((components, query_builders)), Some((resources, resource_builders)), true) => {
            let system = (
                ParamSetBuilder(query_builders),
                ParamSetBuilder(resource_builders),
                ParamBuilder::of::<Commands>(),
            )
                .build_state((*app).world_mut())
                .build_system(
                    move |query_param_set, resource_param_set, mut commands| -> () {
                        let (query_results_ptr, query_count) =
                            get_components(&components, query_param_set);
                        let (resource_results_ptr, resource_count) =
                            get_resources(&resources, resource_param_set);

                        let commands_ptr = &mut commands as *mut Commands;

                        (request.callback)(SystemResult {
                            query_results: query_results_ptr,
                            query_count,
                            resource_results: resource_results_ptr,
                            resource_count,
                            commands: transmute(commands_ptr),
                        });
                    },
                );
            add_system(&mut *app, request.schedule, system);
        }
        (Some((components, query_builders)), None, true) => {
            let system = (
                ParamSetBuilder(query_builders),
                ParamBuilder::of::<Commands>(),
            )
                .build_state((*app).world_mut())
                .build_system(move |query_param_set, mut commands| -> () {
                    let (query_results_ptr, query_count) =
                        get_components(&components, query_param_set);
                    let commands_ptr = &mut commands as *mut Commands;

                    (request.callback)(SystemResult {
                        query_results: query_results_ptr,
                        query_count,
                        resource_results: null(),
                        resource_count: 0,
                        commands: transmute(commands_ptr),
                    });
                });
            add_system(&mut *app, request.schedule, system);
        }
        (None, Some((resources, resource_builders)), true) => {
            let system = (
                ParamSetBuilder(resource_builders),
                ParamBuilder::of::<Commands>(),
            )
                .build_state((*app).world_mut())
                .build_system(move |resource_param_set, mut commands| -> () {
                    let (resource_results_ptr, resource_count) =
                        get_resources(&resources, resource_param_set);
                    let commands_ptr = &mut commands as *mut Commands;

                    (request.callback)(SystemResult {
                        query_results: null(),
                        query_count: 0,
                        resource_results: resource_results_ptr,
                        resource_count,
                        commands: transmute(commands_ptr),
                    });
                });
            add_system(&mut *app, request.schedule, system);
        }
        (None, None, true) => {
            let system = (ParamBuilder::of::<Commands>(),)
                .build_state((*app).world_mut())
                .build_system(move |mut commands| -> () {
                    let commands_ptr = &mut commands as *mut Commands;

                    (request.callback)(SystemResult {
                        query_results: null(),
                        query_count: 0,
                        resource_results: null(),
                        resource_count: 0,
                        commands: transmute(commands_ptr),
                    });
                });
            add_system(&mut *app, request.schedule, system);
        }
        (Some((components, query_builders)), Some((resources, resource_builders)), false) => {
            let system = (
                ParamSetBuilder(query_builders),
                ParamSetBuilder(resource_builders),
            )
                .build_state((*app).world_mut())
                .build_system(move |query_param_set, resource_param_set| -> () {
                    let (query_results_ptr, query_count) =
                        get_components(&components, query_param_set);
                    let (resource_results_ptr, resource_count) =
                        get_resources(&resources, resource_param_set);

                    (request.callback)(SystemResult {
                        query_results: query_results_ptr,
                        query_count,
                        resource_results: resource_results_ptr,
                        resource_count,
                        commands: null_mut(),
                    });
                });
            add_system(&mut *app, request.schedule, system);
        }
        (Some((components, query_builders)), None, false) => {
            let system = (ParamSetBuilder(query_builders),)
                .build_state((*app).world_mut())
                .build_system(move |query_param_set| -> () {
                    let (query_results_ptr, query_count) =
                        get_components(&components, query_param_set);

                    (request.callback)(SystemResult {
                        query_results: query_results_ptr,
                        query_count,
                        resource_results: null(),
                        resource_count: 0,
                        commands: null_mut(),
                    });
                });
            add_system(&mut *app, request.schedule, system);
        }
        (None, Some((resources, resource_builders)), false) => {
            let system = (ParamSetBuilder(resource_builders),)
                .build_state((*app).world_mut())
                .build_system(move |resource_param_set| -> () {
                    let (resource_results_ptr, resource_count) =
                        get_resources(&resources, resource_param_set);

                    (request.callback)(SystemResult {
                        query_results: null(),
                        query_count: 0,
                        resource_results: resource_results_ptr,
                        resource_count,
                        commands: null_mut(),
                    });
                });
            add_system(&mut *app, request.schedule, system);
        }
        _ => return,
    };
}

I want to be able to support the normal bevy system scheduling stuff like chain/before/after/run_if.

What would be the best way to approach this given the way I currently register systems? Is it possible?

I appreciate this is a fair amount of code that requires people with a deeper understanding of bevy so thanks in advanced.

[ScottKane]

Assuming I need some form of SystemSetBuilder which doesn't yet exist that I can see

[ScottKane]

It seems like IntoSystemSet<()> isn't implemented for FunctionSystem<fn(...), fn(...)> which the system builder returns. This means they can't be used in system1.before(system2) system sets.