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
//a Imports
use geo_nd::matrix;
use crate::Bone;
use crate::{Mat4, Transformation};
//a BonePose
//tp BonePose
/// A pose of a [Bone], referring to it so that many poses can use the
/// same [Bone].
///
/// A [BonePose] has a current [Transformation] which indicates how it
/// is posed; the [Bone] contains mapping matrices for going from
/// bone-parent space to bone space, and for going from mesh space to
/// bone space
pub struct BonePose<'a> {
/// The bone this corresponds to (within its hierarchy)
bone: &'a Bone,
/// transformation relative to bone rest
transformation: Transformation,
/// posed-bone-to-parent Mat4 derived from transformation
pbtp: Mat4,
/// Matrix mapping bone-space to mesh-space
animated_btm: Mat4,
/// Matrix mapping mesh-space to mesh-space
animated_mtm: Mat4,
}
//ip BonePose
impl<'a> BonePose<'a> {
//fp new
/// Create a new pose of a bone
pub fn new(bone: &'a Bone) -> Self {
let transformation = *bone.borrow_transformation();
let pbtp = [0.; 16];
let animated_btm = [0.; 16];
let animated_mtm = [0.; 16];
Self {
bone,
transformation,
pbtp,
animated_btm,
animated_mtm,
}
}
//mp transformation_reset
/// Reset the pose transformation to that of the bone in the skeleton
pub fn transformation_reset(&mut self) {
self.transformation = *self.bone.borrow_transformation();
}
//mp set_transformation
/// Set a new pose transformation for the posed bone
pub fn set_transformation(&mut self, transform: Transformation) {
self.transformation = transform;
self.pbtp = self.transformation.mat4();
}
//mp derive_animation
/// Derive the animation matrices given a parent
/// animated-posed-bone-to-mesh matrix
///
/// If there is no parent (is_root true) then the animated
/// bone-to-mesh is just the posed-bone-to-parent transformation
///
/// If there is a parent then its pose transformation must be
/// preapplied to this; when this animated_btm is applied to a
/// vector (in this local bone space) one must first generate the vector
/// in the parent-bone space (by applying pbtp) and then apply
/// parent pbtm to generate model space
///
/// Vectors in the model mesh space can be multiplied by the
/// *bone*s mtb matrix to get a vector in this local bone space,
/// to which the animated_btm can be applied to get a model space
/// vector. Hence multiplying animated_btm and bone.mtb together.
pub fn derive_animation(&mut self, is_root: bool, parent_animated_pbtm: &Mat4) -> &Mat4 {
if is_root {
self.animated_btm = self.pbtp;
} else {
self.animated_btm = matrix::multiply4(parent_animated_pbtm, &self.pbtp);
}
self.animated_mtm = matrix::multiply4(&self.animated_btm, &self.bone.mtb);
&self.animated_btm
}
//mp borrow_animated_mtm
/// Borrow the animated mesh-to-model-space matrix
///
/// This assumes it has been derived
#[inline]
pub fn borrow_animated_mtm(&self) -> &Mat4 {
&self.animated_mtm
}
//zz All done
}
//ip Display for BonePose
impl<'a> std::fmt::Display for BonePose<'a> {
fn fmt(&self, f: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> {
writeln!(f, "Pose")?;
write!(f, " {}", self.bone)?;
write!(f, " {}", self.transformation)?;
write!(f, " {:?}", self.pbtp)?;
write!(f, " anim_btm: {:?}", self.animated_btm)?;
write!(f, " anim_mtm: {:?}", self.animated_mtm)?;
Ok(())
}
}
//ip DefaultIndentedDisplay for BonePose
impl<'a> indent_display::DefaultIndentedDisplay for BonePose<'a> {}