Tasks, scheduling, systems, services

[voxelias]

Was thinking about, how API could look like for advanced scheduling:

fn main() {
    dotrix::application(EDITOR_TITLE)
        .set_assets_root("assets/")
        .set_fps_request(140)
        .set_window_size_request(1024, 768)
        .set_full_screen(true)
        .set_workers(4)
        .set_clear_color(Color::rgb(0.8, 0.8, 0.8)
        .import(MyGame::default())
        .import(dotrix::pbr::service())
        .run();
}

Following code, was a system in the past. Though it is more a task and actually everything in Dotrix is being done in tasks, and it have a sense to develop this concept further.

fn my_task(
    frame: Ro<dotrix::Frame>,
    mut world: Rw<dotrix::World>
) {
    let delta = frame.delta().as_secs_f32();
    world.execute::<(&mut Position, &Speed)>(
        // this is actually a system, that can be parallelized
        |position, speed| {
            *position = position * speed * delta
        }
    );
}

Game Service, may contain a context

struct MyGame {}

impl Service for MyGame {
    fn install(scheduler: &mut Scheduler) {
        scheduler.add(
            Task::from(my_task)
                .provides::<EntitiesMoved>()
                .depends_on::<dotrix::FrameReady>;
            // could also be something like this:
            // .depends_on_all::<(dotrix::FrameReady, EntitiesSpawned)>()
            // .depends_on_any::<(dotrix::FrameReady, EntitiesSpawned)>()
        );
    }
}

Dependencies and what can be provided by systems are just types:

// Meta-type identifying, that operation is over.
// In theory it can even contain some data
pub struct EntitiesMoved(u32);

Maybe we can also think about input and output in this way:

fn my_task(deps: (&FrameReady, &EntitiesSpawned), assets: Rw<Assets>) -> EntitiesMoved {
  ...
} 

[voxelias]

Another possibility for dependencies without providers:

fn my_task(...) {}
fn my_other_task(...) {}

System::from(my_task)
  .with(Dependency::of::<my_other_task>())