oxihuman-viewer 0.2.1

wgpu/WebGPU rendering adapter for OxiHuman
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)]

/// Highlight triangles (3-vertex faces) in a predominantly quad mesh.
#[derive(Debug, Clone)]
pub struct TriHighlightView {
    pub enabled: bool,
    /// Highlight colour for triangle faces.
    pub color: [f32; 3],
    /// Opacity of the highlight.
    pub opacity: f32,
    /// If true, also count triangles and show in stats.
    pub show_count: bool,
}

pub fn new_tri_highlight_view() -> TriHighlightView {
    TriHighlightView {
        enabled: false,
        color: [1.0, 0.5, 0.0],
        opacity: 0.7,
        show_count: true,
    }
}

pub fn thv_enable(v: &mut TriHighlightView) {
    v.enabled = true;
}

pub fn thv_set_opacity(v: &mut TriHighlightView, o: f32) {
    v.opacity = o.clamp(0.0, 1.0);
}

pub fn thv_set_color(v: &mut TriHighlightView, r: f32, g: f32, b: f32) {
    v.color = [r.clamp(0.0, 1.0), g.clamp(0.0, 1.0), b.clamp(0.0, 1.0)];
}

pub fn thv_set_show_count(v: &mut TriHighlightView, show: bool) {
    v.show_count = show;
}

pub fn thv_is_tri(face_vert_count: u32) -> bool {
    face_vert_count == 3
}

/// Returns ratio of triangles among total faces (0.0 … 1.0).
pub fn thv_tri_ratio(tri_count: u32, total_count: u32) -> f32 {
    if total_count == 0 {
        return 0.0;
    }
    (tri_count as f32 / total_count as f32).clamp(0.0, 1.0)
}

pub fn thv_to_json(v: &TriHighlightView) -> String {
    format!(
        r#"{{"enabled":{},"opacity":{:.4},"show_count":{}}}"#,
        v.enabled, v.opacity, v.show_count
    )
}

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

    #[test]
    fn test_defaults() {
        /* enabled=false, show_count=true */
        let v = new_tri_highlight_view();
        assert!(!v.enabled);
        assert!(v.show_count);
    }

    #[test]
    fn test_enable() {
        /* enable */
        let mut v = new_tri_highlight_view();
        thv_enable(&mut v);
        assert!(v.enabled);
    }

    #[test]
    fn test_is_tri_true() {
        /* 3 verts is tri */
        assert!(thv_is_tri(3));
    }

    #[test]
    fn test_is_tri_false() {
        /* 4 verts is not tri */
        assert!(!thv_is_tri(4));
    }

    #[test]
    fn test_tri_ratio() {
        /* 1 out of 4 = 0.25 */
        assert!((thv_tri_ratio(1, 4) - 0.25).abs() < 1e-6);
    }

    #[test]
    fn test_tri_ratio_zero_total() {
        /* no faces → ratio 0 */
        assert_eq!(thv_tri_ratio(0, 0), 0.0);
    }

    #[test]
    fn test_set_opacity() {
        /* opacity stored */
        let mut v = new_tri_highlight_view();
        thv_set_opacity(&mut v, 0.5);
        assert!((v.opacity - 0.5).abs() < 1e-6);
    }

    #[test]
    fn test_opacity_clamp() {
        /* clamped above 1 */
        let mut v = new_tri_highlight_view();
        thv_set_opacity(&mut v, 3.0);
        assert_eq!(v.opacity, 1.0);
    }

    #[test]
    fn test_color_set() {
        /* colour stored */
        let mut v = new_tri_highlight_view();
        thv_set_color(&mut v, 0.1, 0.2, 0.3);
        assert!((v.color[0] - 0.1).abs() < 1e-6);
    }

    #[test]
    fn test_to_json() {
        /* JSON has opacity */
        assert!(thv_to_json(&new_tri_highlight_view()).contains("opacity"));
    }
}