summaryrefslogtreecommitdiff
path: root/ecs/src/component/local.rs
blob: a365efeb5baa57febf05b191b92666c175b38aab (plain)
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
use std::any::Any;
use std::ops::{Deref, DerefMut};

use crate::component::{Component, Id};
use crate::system::{ComponentRefMut, Param as SystemParam, System};
use crate::World;

/// Holds a component which is local to a single system.
#[derive(Debug)]
pub struct Local<'world, LocalComponent: Component>
{
    local_component: ComponentRefMut<'world, LocalComponent>,
}

unsafe impl<'world, LocalComponent> SystemParam<'world> for Local<'world, LocalComponent>
where
    LocalComponent: Component,
{
    type Flags = ();
    type Input = LocalComponent;

    fn initialize<SystemImpl>(
        system: &mut impl System<'world, SystemImpl>,
        input: Self::Input,
    )
    {
        system.set_local_component(input);
    }

    fn new<SystemImpl>(
        system: &'world impl System<'world, SystemImpl>,
        _world: &'world World,
    ) -> Self
    {
        let local_component = system
            .get_local_component_mut::<LocalComponent>()
            .expect("Local component is uninitialized");

        Self { local_component }
    }

    fn is_compatible<Other: SystemParam<'world>>() -> bool
    {
        let other_comparable = Other::get_comparable();

        let Some(other_id) = other_comparable.downcast_ref::<Id>() else {
            return true;
        };

        Id::of::<LocalComponent>() != *other_id
    }

    fn get_comparable() -> Box<dyn Any>
    {
        Box::new(Id::of::<LocalComponent>())
    }
}

impl<'world, LocalComponent> Deref for Local<'world, LocalComponent>
where
    LocalComponent: Component,
{
    type Target = LocalComponent;

    fn deref(&self) -> &Self::Target
    {
        &self.local_component
    }
}

impl<'world, LocalComponent> DerefMut for Local<'world, LocalComponent>
where
    LocalComponent: Component,
{
    fn deref_mut(&mut self) -> &mut Self::Target
    {
        &mut self.local_component
    }
}