flecs_ecs 0.2.2

Rust API for the C/CPP flecs ECS library <https://github.com/SanderMertens/flecs>
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
117
118
119
120

#![allow(dead_code)]
use flecs_ecs::core::*;

use crate::common_test::*;

#[test]
fn query_rust_pass_query_to_system() {
    let world = World::new();

    world
        .component::<Position>()
        .add_trait::<flecs::Singleton>();

    world.set(Position { x: 1, y: 2 });

    let query = world.query::<(&Position, &Velocity)>().set_cached().build();

    world.entity().set(Velocity { x: 590, y: 20 });

    let query_entity = query.entity().id();

    let sys = world.system::<()>().run(move |it| {
        let world = it.world();
        let query = world.query_from(query_entity);
        query.run(|mut it| {
            let mut count = 0;
            while it.next() {
                let pos = &it.field::<Position>(0)[0]; //singleton
                let vel = it.field::<Velocity>(1);
                for i in it.iter() {
                    count += 1;
                    assert_eq!(pos.x, 1);
                    assert_eq!(pos.y, 2);
                    assert_eq!(vel[i].x, 590);
                    assert_eq!(vel[i].y, 20);
                }
            }
            assert_eq!(count, 1);
        });
    });

    sys.run();
}

#[test]
fn test_trait_query() {
    pub trait Shapes {
        fn calculate(&self) -> u64;
    }

    // Define a ShapesTrait component with the necessary functionality
    ecs_rust_trait!(Shapes);

    #[derive(Component)]
    pub struct Circle {
        radius: f32,
    }

    //implement the Shapes trait as you want
    impl Shapes for Circle {
        fn calculate(&self) -> u64 {
            1
        }
    }

    #[derive(Component)]
    pub struct Square {
        side: f32,
    }

    impl Shapes for Square {
        fn calculate(&self) -> u64 {
            2
        }
    }

    #[derive(Component)]
    pub struct Triangle {
        side: f32,
    }

    impl Shapes for Triangle {
        fn calculate(&self) -> u64 {
            3
        }
    }

    let world = World::new();

    // Register a vtable per component that implements the trait through the ShapesTrait component
    ShapesTrait::register_vtable::<Circle>(&world);
    ShapesTrait::register_vtable::<Square>(&world);
    ShapesTrait::register_vtable::<Triangle>(&world);

    world.entity_named("circle").set(Circle { radius: 5.0 });
    world.entity_named("square").set(Square { side: 5.0 });
    world.entity_named("triangle").set(Triangle { side: 5.0 });

    // query for all entities with components that implement the Shapes trait
    let query = world.query::<&ShapesTrait>().build();

    let mut count = 0;

    query.run(|mut it| {
        while it.next() {
            for i in it.iter() {
                let e = it.get_entity(i).unwrap();
                let id = it.id(0);
                // cast the component to the Shapes trait
                let _test_compile: &mut dyn Shapes = ShapesTrait::cast_mut(e, id);
                let shape: &dyn Shapes = ShapesTrait::cast(e, id);
                // call the method on the trait
                let calc = shape.calculate();
                count += calc;
            }
        }
    });

    assert_eq!(count, 6);
}