oxihuman-morph 0.1.2

Parametric morphology engine for human body generation — targets, blendshapes, FACS
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

// Copyright (C) 2026 COOLJAPAN OU (Team KitaSan)
// SPDX-License-Identifier: Apache-2.0
#![allow(dead_code)]

//! Anticipation: brief opposite motion before main action.

#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct AnticipationMorph {
    pub target: f32,
    pub current: f32,
    pub anticipation_amt: f32,
    pub phase: u8,
}

#[allow(dead_code)]
pub fn new_anticipation_morph(anticipation_amt: f32) -> AnticipationMorph {
    AnticipationMorph { target: 0.0, current: 0.0, anticipation_amt, phase: 2 /* done */ }
}

#[allow(dead_code)]
pub fn am_trigger(m: &mut AnticipationMorph, target: f32) {
    m.target = target;
    m.phase = 0;
}

#[allow(dead_code)]
pub fn am_step(m: &mut AnticipationMorph, dt: f32) {
    match m.phase {
        0 => {
            /* phase 0: move opposite to target direction */
            let dir = if m.target > m.current { -1.0 } else { 1.0 };
            m.current += dir * m.anticipation_amt * dt;
            m.phase = 1;
        }
        1 => {
            /* phase 1: move toward target */
            let diff = m.target - m.current;
            m.current += diff * (5.0 * dt).min(1.0);
            if (m.current - m.target).abs() < 1e-4 {
                m.current = m.target;
                m.phase = 2;
            }
        }
        _ => { /* done */ }
    }
}

#[allow(dead_code)]
pub fn am_value(m: &AnticipationMorph) -> f32 {
    m.current
}

#[allow(dead_code)]
pub fn am_phase(m: &AnticipationMorph) -> u8 {
    m.phase
}

#[allow(dead_code)]
pub fn am_is_done(m: &AnticipationMorph) -> bool {
    m.phase >= 2
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_trigger_sets_target() {
        let mut m = new_anticipation_morph(0.2);
        am_trigger(&mut m, 1.0);
        assert!((m.target - 1.0).abs() < 1e-6);
    }

    #[test]
    fn test_trigger_sets_phase_zero() {
        let mut m = new_anticipation_morph(0.2);
        am_trigger(&mut m, 1.0);
        assert_eq!(am_phase(&m), 0);
    }

    #[test]
    fn test_phase_transitions_to_one() {
        let mut m = new_anticipation_morph(0.1);
        am_trigger(&mut m, 1.0);
        am_step(&mut m, 0.1);
        assert_eq!(am_phase(&m), 1);
    }

    #[test]
    fn test_phase_one_moves_toward_target() {
        let mut m = new_anticipation_morph(0.0);
        am_trigger(&mut m, 1.0);
        am_step(&mut m, 0.0); /* phase 0: no anticipation */
        am_step(&mut m, 0.5); /* phase 1: move toward target */
        assert!(m.current > 0.0);
    }

    #[test]
    fn test_is_done_initially() {
        let m = new_anticipation_morph(0.2);
        assert!(am_is_done(&m));
    }

    #[test]
    fn test_is_not_done_after_trigger() {
        let mut m = new_anticipation_morph(0.2);
        am_trigger(&mut m, 1.0);
        assert!(!am_is_done(&m));
    }

    #[test]
    fn test_anticipation_amt_stored() {
        let m = new_anticipation_morph(0.35);
        assert!((m.anticipation_amt - 0.35).abs() < 1e-6);
    }

    #[test]
    fn test_value_finite_after_steps() {
        let mut m = new_anticipation_morph(0.1);
        am_trigger(&mut m, 0.5);
        for _ in 0..20 {
            am_step(&mut m, 0.1);
        }
        assert!(am_value(&m).is_finite());
    }
}