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

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

/// Blend mode for combining morph weights.
#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum MorphBlendMode {
    Additive,
    Override,
    Multiply,
    Screen,
}

/// Blend two values using additive mode.
#[allow(dead_code)]
pub fn blend_additive(base: f32, layer: f32) -> f32 {
    (base + layer).clamp(0.0, 1.0)
}

/// Blend two values using override mode (layer replaces base).
#[allow(dead_code)]
pub fn blend_override(_base: f32, layer: f32) -> f32 {
    layer.clamp(0.0, 1.0)
}

/// Blend two values using multiply mode.
#[allow(dead_code)]
pub fn blend_multiply(base: f32, layer: f32) -> f32 {
    (base * layer).clamp(0.0, 1.0)
}

/// Blend two values using screen mode.
#[allow(dead_code)]
pub fn blend_screen(base: f32, layer: f32) -> f32 {
    (1.0 - (1.0 - base) * (1.0 - layer)).clamp(0.0, 1.0)
}

/// Return the name of a blend mode.
#[allow(dead_code)]
pub fn blend_mode_name(mode: MorphBlendMode) -> &'static str {
    match mode {
        MorphBlendMode::Additive => "additive",
        MorphBlendMode::Override => "override",
        MorphBlendMode::Multiply => "multiply",
        MorphBlendMode::Screen => "screen",
    }
}

/// Blend two values using the specified mode.
#[allow(dead_code)]
pub fn blend_two_values(mode: MorphBlendMode, base: f32, layer: f32) -> f32 {
    match mode {
        MorphBlendMode::Additive => blend_additive(base, layer),
        MorphBlendMode::Override => blend_override(base, layer),
        MorphBlendMode::Multiply => blend_multiply(base, layer),
        MorphBlendMode::Screen => blend_screen(base, layer),
    }
}

/// Serialize a blend mode to a JSON string.
#[allow(dead_code)]
pub fn blend_mode_to_json(mode: MorphBlendMode) -> String {
    format!("{{\"mode\":\"{}\"}}", blend_mode_name(mode))
}

/// Return the default blend mode (Additive).
#[allow(dead_code)]
pub fn default_blend_mode() -> MorphBlendMode {
    MorphBlendMode::Additive
}

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

    #[test]
    fn additive_basic() {
        assert!((blend_additive(0.3, 0.4) - 0.7).abs() < 1e-6);
    }

    #[test]
    fn additive_clamp() {
        assert!((blend_additive(0.8, 0.5) - 1.0).abs() < 1e-6);
    }

    #[test]
    fn override_replaces() {
        assert!((blend_override(0.3, 0.9) - 0.9).abs() < 1e-6);
    }

    #[test]
    fn multiply_basic() {
        assert!((blend_multiply(0.5, 0.5) - 0.25).abs() < 1e-6);
    }

    #[test]
    fn screen_basic() {
        let r = blend_screen(0.5, 0.5);
        assert!((r - 0.75).abs() < 1e-6);
    }

    #[test]
    fn mode_name() {
        assert_eq!(blend_mode_name(MorphBlendMode::Additive), "additive");
        assert_eq!(blend_mode_name(MorphBlendMode::Override), "override");
    }

    #[test]
    fn blend_two() {
        let r = blend_two_values(MorphBlendMode::Multiply, 0.5, 0.8);
        assert!((r - 0.4).abs() < 1e-6);
    }

    #[test]
    fn to_json() {
        let j = blend_mode_to_json(MorphBlendMode::Screen);
        assert!(j.contains("screen"));
    }

    #[test]
    fn default_is_additive() {
        assert_eq!(default_blend_mode(), MorphBlendMode::Additive);
    }

    #[test]
    fn screen_zeros() {
        assert!(blend_screen(0.0, 0.0).abs() < 1e-6);
    }
}