siecs 0.1.2

Rust bindings for SIECS
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

use siecs::{raw, Resource, World};
use std::sync::atomic::{AtomicUsize, Ordering};

#[derive(Resource)]
struct Time {
    dt: f32,
}

#[derive(Resource)]
struct Counter {
    value: i32,
}

#[derive(Resource)]
struct DropResource {
    value: String,
}

static RESOURCE_SET: AtomicUsize = AtomicUsize::new(0);
static RESOURCE_REMOVE: AtomicUsize = AtomicUsize::new(0);
static DROP_RESOURCE_DROPS: AtomicUsize = AtomicUsize::new(0);

impl Drop for DropResource {
    fn drop(&mut self) {
        DROP_RESOURCE_DROPS.fetch_add(1, Ordering::SeqCst);
    }
}

unsafe extern "C" fn resource_on_set(_world: *mut raw::WorldRaw, ptr: *const core::ffi::c_void) {
    assert_eq!((*ptr.cast::<HookedResource>()).value, 7);
    RESOURCE_SET.fetch_add(1, Ordering::SeqCst);
}

unsafe extern "C" fn resource_on_remove(_world: *mut raw::WorldRaw, ptr: *const core::ffi::c_void) {
    assert_eq!((*ptr.cast::<HookedResource>()).value, 7);
    RESOURCE_REMOVE.fetch_add(1, Ordering::SeqCst);
}

#[derive(Resource)]
#[resource(name = "HookedResourceName", on_set = resource_on_set, on_remove = resource_on_remove)]
struct HookedResource {
    value: i32,
}

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

    assert!(world.try_resource::<Time>().is_none());
    assert!(!world.has_resource::<Time>());

    world.set_resource(Time { dt: 0.016 });
    assert!(world.has_resource::<Time>());
    assert_eq!(world.resource::<Time>().dt, 0.016);

    world.resource_mut::<Time>().dt = 0.033;
    assert_eq!(world.try_resource::<Time>().unwrap().dt, 0.033);

    world.remove_resource::<Time>();
    assert!(!world.has_resource::<Time>());
}

#[test]
fn resources_are_isolated_per_world() {
    let mut a = World::new();
    let mut b = World::new();

    a.set_resource(Counter { value: 1 });
    b.set_resource(Counter { value: 2 });

    assert_eq!(a.resource::<Counter>().value, 1);
    assert_eq!(b.resource::<Counter>().value, 2);
}

#[test]
fn resource_hooks_fire() {
    RESOURCE_SET.store(0, Ordering::SeqCst);
    RESOURCE_REMOVE.store(0, Ordering::SeqCst);

    let mut world = World::new();
    world.set_resource(HookedResource { value: 7 });
    world.remove_resource::<HookedResource>();

    assert_eq!(RESOURCE_SET.load(Ordering::SeqCst), 1);
    assert_eq!(RESOURCE_REMOVE.load(Ordering::SeqCst), 1);
}

#[test]
fn resource_drop_runs_on_replace_and_remove() {
    DROP_RESOURCE_DROPS.store(0, Ordering::SeqCst);

    let mut world = World::new();
    world.set_resource(DropResource {
        value: "first".to_string(),
    });
    assert_eq!(world.resource::<DropResource>().value, "first");
    assert_eq!(DROP_RESOURCE_DROPS.load(Ordering::SeqCst), 0);

    world.set_resource(DropResource {
        value: "second".to_string(),
    });
    assert_eq!(world.resource::<DropResource>().value, "second");
    assert_eq!(DROP_RESOURCE_DROPS.load(Ordering::SeqCst), 1);

    world.remove_resource::<DropResource>();
    assert_eq!(DROP_RESOURCE_DROPS.load(Ordering::SeqCst), 2);
}