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
128
129
130
131
132
133
134

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

//! Forearm / wrist twist morph control.

/// State for wrist twist (pronation/supination) control.
#[derive(Debug, Clone)]
pub struct WristTwistState {
    pub left_deg: f32,
    pub right_deg: f32,
    pub max_deg: f32,
    pub forearm_couple: f32,
}

impl Default for WristTwistState {
    fn default() -> Self {
        Self { left_deg: 0.0, right_deg: 0.0, max_deg: 90.0, forearm_couple: 0.7 }
    }
}

/// Set the left wrist twist in degrees (positive = pronation).
pub fn wt_set_left(state: &mut WristTwistState, deg: f32) {
    state.left_deg = deg.clamp(-state.max_deg, state.max_deg);
}

/// Set the right wrist twist in degrees.
pub fn wt_set_right(state: &mut WristTwistState, deg: f32) {
    state.right_deg = deg.clamp(-state.max_deg, state.max_deg);
}

/// Return the normalised left twist (-1 to 1).
pub fn wt_normalised_left(state: &WristTwistState) -> f32 {
    if state.max_deg < 1e-6 { return 0.0; }
    state.left_deg / state.max_deg
}

/// Return the normalised right twist (-1 to 1).
pub fn wt_normalised_right(state: &WristTwistState) -> f32 {
    if state.max_deg < 1e-6 { return 0.0; }
    state.right_deg / state.max_deg
}

/// Return the forearm twist weight for the left arm.
pub fn wt_forearm_left(state: &WristTwistState) -> f32 {
    wt_normalised_left(state).abs() * state.forearm_couple
}

/// Reset both wrists to neutral.
pub fn wt_reset(state: &mut WristTwistState) {
    state.left_deg = 0.0;
    state.right_deg = 0.0;
}

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

    #[test]
    fn test_default_neutral() {
        /* default should be zero twist */
        let s = WristTwistState::default();
        assert_eq!(s.left_deg, 0.0);
        assert_eq!(s.right_deg, 0.0);
    }

    #[test]
    fn test_set_left() {
        /* left twist should be set */
        let mut s = WristTwistState::default();
        wt_set_left(&mut s, 45.0);
        assert!((s.left_deg - 45.0).abs() < 1e-5);
    }

    #[test]
    fn test_set_right() {
        /* right twist should be set */
        let mut s = WristTwistState::default();
        wt_set_right(&mut s, -30.0);
        assert!((s.right_deg + 30.0).abs() < 1e-5);
    }

    #[test]
    fn test_clamp_max() {
        /* values beyond max should be clamped */
        let mut s = WristTwistState::default();
        wt_set_left(&mut s, 999.0);
        assert!((s.left_deg - s.max_deg).abs() < 1e-5);
    }

    #[test]
    fn test_normalised_left() {
        /* half max should normalise to 0.5 */
        let mut s = WristTwistState::default();
        let half = s.max_deg / 2.0;
        wt_set_left(&mut s, half);
        assert!((wt_normalised_left(&s) - 0.5).abs() < 1e-5);
    }

    #[test]
    fn test_normalised_right() {
        /* normalised right should reflect sign */
        let mut s = WristTwistState::default();
        let max = s.max_deg;
        wt_set_right(&mut s, -max);
        assert!((wt_normalised_right(&s) + 1.0).abs() < 1e-5);
    }

    #[test]
    fn test_forearm_left_nonzero() {
        /* forearm weight should be nonzero when twisted */
        let mut s = WristTwistState::default();
        wt_set_left(&mut s, 90.0);
        assert!(wt_forearm_left(&s) > 0.0);
    }

    #[test]
    fn test_forearm_left_zero_at_neutral() {
        /* forearm weight should be zero at neutral */
        let s = WristTwistState::default();
        assert_eq!(wt_forearm_left(&s), 0.0);
    }

    #[test]
    fn test_reset() {
        /* reset should zero both twists */
        let mut s = WristTwistState::default();
        wt_set_left(&mut s, 60.0);
        wt_set_right(&mut s, -45.0);
        wt_reset(&mut s);
        assert_eq!(s.left_deg, 0.0);
        assert_eq!(s.right_deg, 0.0);
    }
}