bevy_dolly 0.0.5

The dolly abstraction layer for the bevy game framework
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

//use std::marker::PhantomData;

use bevy_transform::prelude::Transform;

use crate::dolly::{
    driver::RigDriver,
    //handedness::Handedness,
    rig::RigUpdateParams,
    //transform::Transform,
};

/// Locks/constrains the position of the camera to one or more axes
#[derive(Debug)]
pub struct LockPosition {
    x: Option<f32>,
    y: Option<f32>,
    z: Option<f32>,
}

impl LockPosition {
    pub fn new() -> Self {
        Self {
            x: None,
            y: None,
            z: None,
        }
    }
    pub fn from(x: Option<f32>, y: Option<f32>, z: Option<f32>) -> Self {
        Self { x, y, z }
    }
    pub fn x(&self, x: f32) -> Self {
        Self {
            x: Some(x),
            y: self.y,
            z: self.z,
        }
    }
    pub fn y(&self, y: f32) -> Self {
        Self {
            x: self.x,
            y: Some(y),
            z: self.z,
        }
    }
    pub fn z(&self, z: f32) -> Self {
        Self {
            x: self.x,
            y: self.y,
            z: Some(z),
        }
    }
}

impl Default for LockPosition {
    fn default() -> Self {
        Self::new()
    }
}

impl RigDriver for LockPosition {
    fn update(&mut self, params: RigUpdateParams) -> Transform {
        let mut delta_pos = params.parent.translation;
        delta_pos.x = self.x.unwrap_or(delta_pos.x);
        delta_pos.y = self.y.unwrap_or(delta_pos.y);
        delta_pos.z = self.z.unwrap_or(delta_pos.z);
        Transform {
            translation: delta_pos,
            rotation: params.parent.rotation,
            ..Default::default()
        }
    }
}