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

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

/// Shading normals debug visualization.
#[derive(Debug, Clone)]
pub struct ShadingNormalView {
    pub enabled: bool,
    /// Arrow scale factor (length of each normal line in world units).
    pub scale: f32,
    /// Colour for outward normals.
    pub color: [f32; 3],
    /// Show face normals instead of vertex normals.
    pub show_face_normals: bool,
}

pub fn new_shading_normal_view() -> ShadingNormalView {
    ShadingNormalView {
        enabled: false,
        scale: 0.02,
        color: [0.0, 1.0, 0.5],
        show_face_normals: false,
    }
}

pub fn snv_enable(v: &mut ShadingNormalView) {
    v.enabled = true;
}

pub fn snv_set_scale(v: &mut ShadingNormalView, s: f32) {
    v.scale = s.max(1e-4);
}

pub fn snv_set_show_face_normals(v: &mut ShadingNormalView, show: bool) {
    v.show_face_normals = show;
}

/// Compute the endpoint of a normal line given origin and normal direction.
pub fn snv_normal_endpoint(origin: [f32; 3], normal: [f32; 3], scale: f32) -> [f32; 3] {
    [
        origin[0] + normal[0] * scale,
        origin[1] + normal[1] * scale,
        origin[2] + normal[2] * scale,
    ]
}

pub fn snv_normal_facing(normal: [f32; 3]) -> bool {
    /* facing camera if z-component > 0 in view space */
    normal[2] > 0.0
}

pub fn snv_to_json(v: &ShadingNormalView) -> String {
    format!(
        r#"{{"enabled":{},"scale":{:.4},"show_face_normals":{}}}"#,
        v.enabled, v.scale, v.show_face_normals
    )
}

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

    #[test]
    fn test_defaults() {
        /* scale=0.02, enabled=false */
        let v = new_shading_normal_view();
        assert!((v.scale - 0.02).abs() < 1e-6);
        assert!(!v.enabled);
    }

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

    #[test]
    fn test_set_scale() {
        /* valid scale */
        let mut v = new_shading_normal_view();
        snv_set_scale(&mut v, 0.1);
        assert!((v.scale - 0.1).abs() < 1e-6);
    }

    #[test]
    fn test_scale_min() {
        /* scale cannot be negative */
        let mut v = new_shading_normal_view();
        snv_set_scale(&mut v, -1.0);
        assert!(v.scale > 0.0);
    }

    #[test]
    fn test_endpoint() {
        /* endpoint offsets by scale in normal direction */
        let ep = snv_normal_endpoint([0.0, 0.0, 0.0], [0.0, 1.0, 0.0], 0.1);
        assert!((ep[1] - 0.1).abs() < 1e-6);
    }

    #[test]
    fn test_facing_positive() {
        /* z > 0 is facing */
        assert!(snv_normal_facing([0.0, 0.0, 1.0]));
    }

    #[test]
    fn test_facing_negative() {
        /* z < 0 is not facing */
        assert!(!snv_normal_facing([0.0, 0.0, -1.0]));
    }

    #[test]
    fn test_show_face_normals() {
        /* toggle face normals */
        let mut v = new_shading_normal_view();
        snv_set_show_face_normals(&mut v, true);
        assert!(v.show_face_normals);
    }

    #[test]
    fn test_to_json() {
        /* JSON has scale */
        assert!(snv_to_json(&new_shading_normal_view()).contains("scale"));
    }
}