oxihuman_morph/
ear_helix_fold.rs

1// Copyright (C) 2026 COOLJAPAN OU (Team KitaSan)
2// SPDX-License-Identifier: Apache-2.0
3#![allow(dead_code)]
4
5//! Ear helix fold — controls the roll and definition of the helical rim.
6
7/// Configuration for ear helix fold.
8#[allow(dead_code)]
9#[derive(Debug, Clone)]
10pub struct EarHelixConfig {
11    pub max_fold: f32,
12}
13
14/// Side selector.
15#[allow(dead_code)]
16#[derive(Debug, Clone, Copy, PartialEq, Eq)]
17pub enum EarHelixSide {
18    Left,
19    Right,
20}
21
22/// Runtime state.
23#[allow(dead_code)]
24#[derive(Debug, Clone)]
25pub struct EarHelixState {
26    pub left_fold: f32,
27    pub right_fold: f32,
28    pub definition: f32,
29}
30
31#[allow(dead_code)]
32pub fn default_ear_helix_config() -> EarHelixConfig {
33    EarHelixConfig { max_fold: 1.0 }
34}
35
36#[allow(dead_code)]
37pub fn new_ear_helix_state() -> EarHelixState {
38    EarHelixState {
39        left_fold: 0.0,
40        right_fold: 0.0,
41        definition: 0.0,
42    }
43}
44
45#[allow(dead_code)]
46pub fn ehf_set_fold(state: &mut EarHelixState, cfg: &EarHelixConfig, side: EarHelixSide, v: f32) {
47    let clamped = v.clamp(0.0, cfg.max_fold);
48    match side {
49        EarHelixSide::Left => state.left_fold = clamped,
50        EarHelixSide::Right => state.right_fold = clamped,
51    }
52}
53
54#[allow(dead_code)]
55pub fn ehf_set_both(state: &mut EarHelixState, cfg: &EarHelixConfig, v: f32) {
56    let clamped = v.clamp(0.0, cfg.max_fold);
57    state.left_fold = clamped;
58    state.right_fold = clamped;
59}
60
61#[allow(dead_code)]
62pub fn ehf_set_definition(state: &mut EarHelixState, v: f32) {
63    state.definition = v.clamp(0.0, 1.0);
64}
65
66#[allow(dead_code)]
67pub fn ehf_reset(state: &mut EarHelixState) {
68    *state = new_ear_helix_state();
69}
70
71#[allow(dead_code)]
72pub fn ehf_is_neutral(state: &EarHelixState) -> bool {
73    state.left_fold.abs() < 1e-6 && state.right_fold.abs() < 1e-6 && state.definition.abs() < 1e-6
74}
75
76#[allow(dead_code)]
77pub fn ehf_average_fold(state: &EarHelixState) -> f32 {
78    (state.left_fold + state.right_fold) * 0.5
79}
80
81#[allow(dead_code)]
82pub fn ehf_symmetry(state: &EarHelixState) -> f32 {
83    (state.left_fold - state.right_fold).abs()
84}
85
86#[allow(dead_code)]
87pub fn ehf_blend(a: &EarHelixState, b: &EarHelixState, t: f32) -> EarHelixState {
88    let t = t.clamp(0.0, 1.0);
89    EarHelixState {
90        left_fold: a.left_fold + (b.left_fold - a.left_fold) * t,
91        right_fold: a.right_fold + (b.right_fold - a.right_fold) * t,
92        definition: a.definition + (b.definition - a.definition) * t,
93    }
94}
95
96#[allow(dead_code)]
97pub fn ehf_to_weights(state: &EarHelixState) -> Vec<(String, f32)> {
98    vec![
99        ("ear_helix_fold_l".to_string(), state.left_fold),
100        ("ear_helix_fold_r".to_string(), state.right_fold),
101        ("ear_helix_definition".to_string(), state.definition),
102    ]
103}
104
105#[allow(dead_code)]
106pub fn ehf_to_json(state: &EarHelixState) -> String {
107    format!(
108        r#"{{"left_fold":{:.4},"right_fold":{:.4},"definition":{:.4}}}"#,
109        state.left_fold, state.right_fold, state.definition
110    )
111}
112
113#[cfg(test)]
114mod tests {
115    use super::*;
116
117    #[test]
118    fn default_config() {
119        let cfg = default_ear_helix_config();
120        assert!((cfg.max_fold - 1.0).abs() < 1e-6);
121    }
122
123    #[test]
124    fn new_state_neutral() {
125        let s = new_ear_helix_state();
126        assert!(ehf_is_neutral(&s));
127    }
128
129    #[test]
130    fn set_fold_left() {
131        let cfg = default_ear_helix_config();
132        let mut s = new_ear_helix_state();
133        ehf_set_fold(&mut s, &cfg, EarHelixSide::Left, 0.5);
134        assert!((s.left_fold - 0.5).abs() < 1e-6);
135    }
136
137    #[test]
138    fn set_fold_clamps() {
139        let cfg = default_ear_helix_config();
140        let mut s = new_ear_helix_state();
141        ehf_set_fold(&mut s, &cfg, EarHelixSide::Right, 10.0);
142        assert!((s.right_fold - 1.0).abs() < 1e-6);
143    }
144
145    #[test]
146    fn set_both_symmetric() {
147        let cfg = default_ear_helix_config();
148        let mut s = new_ear_helix_state();
149        ehf_set_both(&mut s, &cfg, 0.7);
150        assert!(ehf_symmetry(&s) < 1e-6);
151    }
152
153    #[test]
154    fn set_definition() {
155        let mut s = new_ear_helix_state();
156        ehf_set_definition(&mut s, 0.8);
157        assert!((s.definition - 0.8).abs() < 1e-6);
158    }
159
160    #[test]
161    fn reset_clears() {
162        let cfg = default_ear_helix_config();
163        let mut s = new_ear_helix_state();
164        ehf_set_both(&mut s, &cfg, 0.9);
165        ehf_reset(&mut s);
166        assert!(ehf_is_neutral(&s));
167    }
168
169    #[test]
170    fn blend_midpoint() {
171        let a = new_ear_helix_state();
172        let cfg = default_ear_helix_config();
173        let mut b = new_ear_helix_state();
174        ehf_set_both(&mut b, &cfg, 1.0);
175        let m = ehf_blend(&a, &b, 0.5);
176        assert!((m.left_fold - 0.5).abs() < 1e-6);
177    }
178
179    #[test]
180    fn to_weights_count() {
181        let s = new_ear_helix_state();
182        assert_eq!(ehf_to_weights(&s).len(), 3);
183    }
184
185    #[test]
186    fn to_json_fields() {
187        let s = new_ear_helix_state();
188        let j = ehf_to_json(&s);
189        assert!(j.contains("left_fold"));
190    }
191}
oxihuman_morph/ear_helix_fold.rs

oxihuman_morph/
ear_helix_fold.rs
