token-value-map 0.2.5

A token-value map with interpolation of values: what you need for DCCs
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

use super::*;
use core::num::NonZeroU16;
#[cfg(feature = "builtin-types")]
use rayon::prelude::*;

/// Weight value for motion blur sampling.
pub type SampleWeight = f32;

/// `trait` for generating motion blur samples with shutter timing.
///
/// The [`Sample`] `trait` generates multiple samples across a [`Shutter`]
/// interval for motion blur rendering. Each sample includes the interpolated
/// value and a weight based on the shutter opening at that time.
pub trait Sample<T> {
    /// Generate samples across the shutter interval.
    ///
    /// Returns a vector of value-weight pairs for the specified number of
    /// samples distributed across the shutter's time range.
    fn sample(&self, shutter: &Shutter, samples: NonZeroU16) -> Result<Vec<(T, SampleWeight)>>;
}

#[cfg(feature = "builtin-types")]
macro_rules! impl_sample {
    ($data_type:ty) => {
        impl Sample<$data_type> for TimeDataMap<$data_type> {
            fn sample(
                &self,
                shutter: &Shutter,
                samples: NonZeroU16,
            ) -> Result<Vec<($data_type, SampleWeight)>> {
                Ok((0..samples.into())
                    .into_par_iter()
                    .map(|t| {
                        let time = shutter.evaluate(t as f32 / u16::from(samples) as f32);
                        (self.interpolate(time), shutter.opening(time))
                    })
                    .collect::<Vec<_>>())
            }
        }
    };
}

#[cfg(feature = "builtin-types")]
impl_sample!(Real);
#[cfg(feature = "builtin-types")]
impl_sample!(Integer);
#[cfg(feature = "builtin-types")]
impl_sample!(Color);

#[cfg(all(feature = "builtin-types", feature = "vector2"))]
impl_sample!(Vector2);
#[cfg(all(feature = "builtin-types", feature = "vector3"))]
impl_sample!(Vector3);
#[cfg(all(feature = "builtin-types", feature = "normal3"))]
impl_sample!(Normal3);
#[cfg(all(feature = "builtin-types", feature = "point3"))]
impl_sample!(Point3);
#[cfg(all(feature = "builtin-types", feature = "matrix4"))]
impl_sample!(Matrix4);

// AIDEV-NOTE: Matrix3 sampling uses analytical 2×2 SVD decomposition for proper
// rotation/stretch interpolation on all backends. Rotation is interpolated via
// shortest-path angle slerp; translation and stretch are interpolated linearly.
#[cfg(all(feature = "builtin-types", feature = "matrix3"))]
impl Sample<Matrix3> for TimeDataMap<Matrix3> {
    fn sample(
        &self,
        shutter: &Shutter,
        samples: NonZeroU16,
    ) -> Result<Vec<(Matrix3, SampleWeight)>> {
        // Split all matrices into their component parts via analytical 2×2 SVD.
        let mut translations = BTreeMap::new();
        let mut rotations = BTreeMap::new();
        let mut stretches = BTreeMap::new();

        #[cfg(not(feature = "interpolation"))]
        for (time, matrix) in self.values.as_btree_map().iter() {
            let crate::Matrix3(ref inner) = *matrix;
            let (translate, rotate, stretch) = decompose_matrix(inner);
            translations.insert(*time, translate);
            rotations.insert(*time, rotate);
            stretches.insert(*time, stretch);
        }
        #[cfg(feature = "interpolation")]
        for (time, (matrix, _spec)) in self.values.as_btree_map().iter() {
            let crate::Matrix3(ref inner) = *matrix;
            let (translate, rotate, stretch) = decompose_matrix(inner);
            translations.insert(*time, translate);
            rotations.insert(*time, rotate);
            stretches.insert(*time, stretch);
        }

        // Interpolate the samples and recompose the matrices.
        Ok((0..samples.into())
            .into_par_iter()
            .map(|t| {
                let time = shutter.evaluate(t as f32 / u16::from(samples) as f32);
                (
                    crate::Matrix3(recompose_matrix(
                        interpolate(&translations, time),
                        interpolate_rotation(&rotations, time),
                        interpolate(&stretches, time),
                    )),
                    shutter.opening(time),
                )
            })
            .collect::<Vec<_>>())
    }
}