tnaps 0.1.0

tnaps provides an entity-component-system framework in Rust.
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
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116

//! An example ECS system using tnaps.

use std::sync::Arc;

use tnaps::{
    system, system_parallel, ComponentChange, ComponentCollection, ComponentRef,
    CopyOnWriteComponentCollection, CopyOnWriteComponentRef, Entity as EntityTrait,
    MutableComponentCollection, MutableComponentRef, NopPartitioningScheme, Partitioned,
    PartitioningScheme, ThreadPool,
};

type Entity = u128;

struct MySystem1;

system! {
    MySystem1<Entity> {
        a: CopyOnWriteComponentCollection<u8>,
    }
}

impl MySystem1 {
    fn process(&self, entity: Entity, _: &mut CopyOnWriteComponentRef<u8>) {
        println!("processing: {}", entity);
    }
}

struct MySystem2;

system! {
    MySystem2<Entity> {
        a: CopyOnWriteComponentCollection<u8>,
        b: MutableComponentCollection<&'static str>,
    }
}

impl MySystem2 {
    fn process(
        &self,
        entity: Entity,
        _: &mut CopyOnWriteComponentRef<u8>,
        c2: &mut MutableComponentRef<&'static str>,
    ) {
        if entity == 2 {
            c2.unbind();
        }
        println!("processing: {}", entity);
    }
}

struct MySystem3;

system_parallel! {
    MySystem3<Entity> {
        a: CopyOnWriteComponentCollection<u8>,
        b: MutableComponentCollection<&'static str>,
        c: CopyOnWriteComponentCollection<f64>,
    }
}

impl MySystem3 {
    fn process(
        &self,
        entity: Entity,
        _: &mut CopyOnWriteComponentRef<u8>,
        _: &mut MutableComponentRef<&'static str>,
        c3: &mut CopyOnWriteComponentRef<f64>,
    ) {
        if entity == 3 {
            c3.update(|x| *x = 0.0);
        }
        println!("processing: {}", entity);
    }
}

fn main() {
    let mut collection1 = CopyOnWriteComponentCollection::from_iter(vec![
        (1u128, 42u8),
        (2u128, 69u8),
        (3u128, 99u8),
    ]);
    let mut collection2 = MutableComponentCollection::from_iter(vec![
        (1u128, "hello"),
        (2u128, "world"),
        (3u128, "!!!"),
    ]);
    let collection3 = CopyOnWriteComponentCollection::from_iter(vec![
        (1u128, std::f64::consts::PI),
        (2u128, std::f64::consts::E),
        (3u128, std::f64::consts::SQRT_2),
    ]);
    let sys1 = MySystem1;
    let sys2 = MySystem2;
    let sys3 = std::sync::Arc::new(MySystem3);
    println!("----");
    let (changes1,) = sys1.run(&mut collection1);
    assert!(changes1.is_empty());
    println!("----");
    let (changes1, changes2) = sys2.run(&mut collection1, &mut collection2);
    assert!(changes1.is_empty());
    collection2.apply(changes2);
    println!("collection2: {:?}", collection2);
    println!("----");
    let partitioning: Arc<dyn PartitioningScheme<Entity>> = Arc::new(NopPartitioningScheme);
    let collection1 = Partitioned::from(&partitioning, collection1.partition(&*partitioning));
    let mut collection2 = Partitioned::from(&partitioning, collection2.partition(&*partitioning));
    let mut collection3 = Partitioned::from(&partitioning, collection3.partition(&*partitioning));
    let thread_pool = ThreadPool::new("demo", 16);
    let (changes1, changes2, changes3) =
        sys3.run(&thread_pool, &collection1, &collection2, &collection3)();
    assert!(changes1.iter().all(|x| x.is_empty()));
    collection2.apply(changes2);
    collection3.apply(changes3);
    println!("collection2: {:?}", collection2);
    println!("collection3: {:?}", collection3);
}