dolly 0.4.0

Composable camera rigs
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
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

use crate::{
    driver::{RigDriver, RigDriverTraits},
    handedness::{Handedness, RightHanded},
    transform::Transform,
};
use core::fmt::Debug;
use std::marker::PhantomData;

/// A chain of drivers, calculating displacements, and animating in succession.
#[derive(Debug)]
pub struct CameraRig<H: Handedness = RightHanded> {
    ///
    pub drivers: Vec<Box<dyn RigDriverTraits<H>>>,

    ///
    pub final_transform: Transform<H>,

    phantom: PhantomData<H>,
}

// Prevents user calls to `RigDriver::update`. All updates must come from `CameraRig::update`.
struct RigUpdateToken;

///
pub struct RigUpdateParams<'a, H: Handedness> {
    ///
    pub parent: &'a Transform<H>,
    ///
    pub delta_time_seconds: f32,

    phantom: PhantomData<H>,

    _token: RigUpdateToken,
}

impl<H: Handedness> CameraRig<H> {
    /// Returns the first driver of the matching type. Panics if no such driver is present.
    pub fn driver_mut<T: RigDriver<H>>(&mut self) -> &mut T {
        self.try_driver_mut::<T>().unwrap_or_else(|| {
            panic!(
                "No {} driver found in the CameraRig",
                std::any::type_name::<T>()
            )
        })
    }

    /// Returns the Some with the first driver of the matching type, or `None` if no such driver is present.
    pub fn try_driver_mut<T: RigDriver<H>>(&mut self) -> Option<&mut T> {
        self.drivers
            .iter_mut()
            .find_map(|driver| driver.as_mut().as_any_mut().downcast_mut::<T>())
    }

    /// Returns the first driver of the matching type. Panics if no such driver is present.
    pub fn driver<T: RigDriver<H>>(&self) -> &T {
        self.try_driver::<T>().unwrap_or_else(|| {
            panic!(
                "No {} driver found in the CameraRig",
                std::any::type_name::<T>()
            )
        })
    }

    /// Returns the Some with the first driver of the matching type, or `None` if no such driver is present.
    pub fn try_driver<T: RigDriver<H>>(&self) -> Option<&T> {
        self.drivers
            .iter()
            .find_map(|driver| driver.as_ref().as_any().downcast_ref::<T>())
    }

    /// Runs all the drivers in sequence, animating the rig, and producing a final transform of the camera.
    ///
    /// Camera rigs are approximately framerate independent, so `update` can be called at any frequency.
    pub fn update(&mut self, delta_time_seconds: f32) -> Transform<H> {
        let mut parent_transform = Transform::IDENTITY;

        for driver in self.drivers.iter_mut() {
            let transform = driver.update(RigUpdateParams {
                parent: &parent_transform,
                delta_time_seconds,
                phantom: PhantomData,
                _token: RigUpdateToken,
            });

            parent_transform = transform;
        }

        self.final_transform = parent_transform;
        self.final_transform
    }

    /// Use this to make a new rig
    pub fn builder() -> CameraRigBuilder<H> {
        CameraRigBuilder {
            drivers: Default::default(),
            phantom: PhantomData,
        }
    }
}

///
pub struct CameraRigBuilder<H: Handedness> {
    drivers: Vec<Box<dyn RigDriverTraits<H>>>,
    phantom: PhantomData<H>,
}

impl<H: Handedness> CameraRigBuilder<H> {
    ///
    pub fn with(mut self, driver: impl RigDriverTraits<H>) -> Self {
        self.drivers.push(Box::new(driver));
        self
    }

    ///
    pub fn build(self) -> CameraRig<H> {
        let mut rig = CameraRig {
            drivers: self.drivers,
            // Initialize with a dummy identity transform. Will be overridden in a moment.
            final_transform: Transform::IDENTITY,
            phantom: PhantomData,
        };

        // Update once to find the final transform
        rig.update(0.0);
        rig
    }
}