bevy_fixed_update_task 0.1.2

A fixed update for bevy, unthrottled from bevy's default update loop.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87

//! This is a minimal example to show how synchronized fixed update works.

use bevy::prelude::*;
use bevy_fixed_update_task::{
    BackgroundFixedUpdatePlugin, TaskResults, TaskWorker, TaskWorkerTrait, Timestep,
};

use std::time::Duration;

fn main() {
    let mut app = App::new();

    app.add_plugins((
        MinimalPlugins,
        BackgroundFixedUpdatePlugin::<TaskWorkerTraitImpl>::default(),
    ));
    app.init_resource::<SimulationTime>();
    app.add_systems(Update, print_simulation_time);
    app.add_systems(Startup, setup_worker);

    // Run the app.
    app.run();
}

fn setup_worker(mut commands: Commands) {
    commands.spawn((
        Timestep {
            timestep: Duration::from_secs_f32(1.0 / 60.0),
        },
        TaskResults::<TaskWorkerTraitImpl>::default(),
        TaskWorker {
            worker: TaskWorkerTraitImpl {},
        },
    ));
}

fn print_simulation_time(simulation_time: Res<SimulationTime>, time: Res<Time>) {
    println!(
        "Simulation time: {:?} ; time: {:?}",
        simulation_time.time,
        time.elapsed()
    );
}

#[derive(Resource, Debug, Clone, Default)]
pub struct SimulationTime {
    pub time: Duration,
}

#[derive(Debug, Clone, Default)]
pub struct TaskWorkerTraitImpl;

impl TaskWorkerTrait for TaskWorkerTraitImpl {
    type TaskExtractedData = TaskExtractedData;
    type TaskResultPure = Duration;

    fn work(
        &self,
        _worker: Entity,
        mut input: TaskExtractedData,
        timestep: Duration,
        _substep_count: u32,
    ) -> Self::TaskResultPure {
        std::thread::sleep(Duration::from_secs_f32(0.1));
        input.time += timestep;
        input.time
    }

    fn extract(&self, _worker_entity: Entity, world: &mut World) -> TaskExtractedData {
        let time = world.resource::<SimulationTime>();
        TaskExtractedData { time: time.time }
    }

    fn write_back(
        &self,
        _worker_entity: Entity,
        result: bevy_fixed_update_task::TaskResult<Self>,
        world: &mut World,
    ) {
        world.get_resource_mut::<SimulationTime>().unwrap().time = result.result_raw.result;
    }
}

#[derive(Debug, Component, Clone)]
pub struct TaskExtractedData {
    pub time: Duration,
}