bevy_atmosphere 0.10.0

A procedural sky plugin for bevy
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

//! Provides system params for easy reading/modifying of [`Atmospheric`] models.

use std::ops::{Deref, DerefMut};

use bevy::{
    ecs::{
        component::{ComponentId, Tick},
        system::{ReadOnlySystemParam, SystemMeta, SystemParam},
        world::unsafe_world_cell::UnsafeWorldCell,
    },
    prelude::*,
};

use crate::{model::Atmospheric, prelude::AtmosphereModel};

/// Accessor for reading from an [`Atmospheric`] model.
pub struct Atmosphere<'w, T: Atmospheric> {
    value: &'w T,
}

// SAFETY: Res only reads a single World resource
unsafe impl<T: Atmospheric> ReadOnlySystemParam for Atmosphere<'_, T> {}

impl<'w, T: Atmospheric> Deref for Atmosphere<'w, T> {
    type Target = T;

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

unsafe impl<T: Atmospheric> SystemParam for Atmosphere<'_, T> {
    type State = ComponentId;
    type Item<'w, 's> = Atmosphere<'w, T>;

    fn init_state(world: &mut World, system_meta: &mut SystemMeta) -> Self::State {
        Res::<AtmosphereModel>::init_state(world, system_meta)
    }

    #[inline]
    unsafe fn get_param<'w, 's>(
        state: &'s mut Self::State,
        system_meta: &SystemMeta,
        world: UnsafeWorldCell<'w>,
        change_tick: Tick,
    ) -> Self::Item<'w, 's> {
        let atmosphere_model = <Res<AtmosphereModel> as SystemParam>::get_param(
            state,
            system_meta,
            world,
            change_tick,
        )
        .into_inner();
        let value = atmosphere_model
            .to_ref::<T>()
            .expect("Wrong type of `Atmospheric` model found");
        Self::Item { value }
    }
}

/// Accessor for writing to an [`Atmospheric`] model.
pub struct AtmosphereMut<'w, T: Atmospheric> {
    value: &'w mut T,
}

impl<'w, T: Atmospheric> Deref for AtmosphereMut<'w, T> {
    type Target = T;

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

impl<'w, T: Atmospheric> DerefMut for AtmosphereMut<'w, T> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        self.value
    }
}

unsafe impl<T: Atmospheric> SystemParam for AtmosphereMut<'_, T> {
    type State = ComponentId;
    type Item<'w, 's> = AtmosphereMut<'w, T>;

    fn init_state(world: &mut World, system_meta: &mut SystemMeta) -> Self::State {
        ResMut::<AtmosphereModel>::init_state(world, system_meta)
    }

    #[inline]
    unsafe fn get_param<'w, 's>(
        state: &'s mut Self::State,
        system_meta: &SystemMeta,
        world: UnsafeWorldCell<'w>,
        change_tick: Tick,
    ) -> Self::Item<'w, 's> {
        let atmosphere_model = <ResMut<AtmosphereModel> as SystemParam>::get_param(
            state,
            system_meta,
            world,
            change_tick,
        )
        .into_inner();
        let value = atmosphere_model
            .to_mut::<T>()
            .expect("Wrong type of `Atmospheric` model found");
        Self::Item { value }
    }
}