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

use core::mem::offset_of;
use flecs_ecs::prelude::*;

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

    #[derive(Component, Default)]
    struct Test {
        a: u32,
        b: i64,
        c: i16,
        d: i8,
        e: i64,
    }

    world
        .component::<Test>()
        .member(u32::id(), ("a", Count(0), offset_of!(Test, a)))
        .member(i64::id(), ("b", Count(0), offset_of!(Test, b)))
        .member(i16::id(), ("c", Count(0), offset_of!(Test, c)))
        .member(i8::id(), ("d", Count(0), offset_of!(Test, d)))
        .member(i64::id(), ("e", Count(0), offset_of!(Test, e)));

    let e = world.entity().set(Test {
        a: 10,
        b: 20,
        c: 30,
        d: 40,
        e: 50,
    });

    e.get::<&Test>(|ptr| {
        assert_eq!(ptr.a, 10);
        assert_eq!(ptr.b, 20);
        let json = world.to_expr(ptr);
        assert_eq!(json, "{a: 10, b: 20, c: 30, d: 40, e: 50}"); //if this fails, field re-ordering is not working
    });
}

#[test]
fn test_meta_debug_stringify() {
    #[derive(Debug, flecs_ecs_derive::Component)]
    struct Position {
        x: f32,
        y: f32,
    }

    #[derive(flecs_ecs_derive::Component)]
    struct Velocity {
        x: f32,
        y: f32,
    }

    impl core::fmt::Display for Velocity {
        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
            write!(f, "Velocity {{ x: {}, y: {} }}", self.x, self.y)
        }
    }

    let world = World::new();

    world
        .component::<Position>()
        .opaque_func(meta_ser_stringify_type_debug::<Position>);

    world
        .component::<Velocity>()
        .opaque_func(meta_ser_stringify_type_display::<Velocity>);

    let ent = world
        .entity_named("bob")
        .set(Position { x: 1.0, y: 2.0 })
        .set(Velocity { x: 3.0, y: 4.0 });

    let json = ent.to_json(None);

    assert_eq!(
        json,
        r#"{"name":"bob", "components":{"flecs.meta_test_rust.test_meta_debug_stringify.Position":"Position { x: 1.0, y: 2.0 }", "flecs.meta_test_rust.test_meta_debug_stringify.Velocity":"Velocity { x: 3, y: 4 }"}}"#
    );
}