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
135
136
137
138

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

//! Acceleration vector visualization — renders acceleration as scaled arrow glyphs.

/// Acceleration view configuration.
#[derive(Debug, Clone)]
pub struct AccelerationView {
    pub enabled: bool,
    pub scale: f32,
    pub color: [f32; 4],
    pub min_display_magnitude: f32,
}

impl AccelerationView {
    pub fn new() -> Self {
        Self {
            enabled: false,
            scale: 0.005,
            color: [1.0, 0.8, 0.0, 1.0],
            min_display_magnitude: 0.01,
        }
    }
}

impl Default for AccelerationView {
    fn default() -> Self {
        Self::new()
    }
}

/// Create a new acceleration view.
pub fn new_acceleration_view() -> AccelerationView {
    AccelerationView::new()
}

/// Enable or disable acceleration display.
pub fn acv_set_enabled(v: &mut AccelerationView, enabled: bool) {
    v.enabled = enabled;
}

/// Set arrow scale per unit acceleration.
pub fn acv_set_scale(v: &mut AccelerationView, scale: f32) {
    v.scale = scale.clamp(0.0001, 1.0);
}

/// Set display color.
pub fn acv_set_color(v: &mut AccelerationView, color: [f32; 4]) {
    v.color = color;
}

/// Set minimum magnitude threshold.
pub fn acv_set_min_magnitude(v: &mut AccelerationView, mag: f32) {
    v.min_display_magnitude = mag.max(0.0);
}

/// Compute display length for given acceleration magnitude.
pub fn acv_display_length(v: &AccelerationView, magnitude: f32) -> f32 {
    if magnitude < v.min_display_magnitude {
        return 0.0;
    }
    magnitude * v.scale
}

/// Serialize to JSON-like string.
pub fn acceleration_view_to_json(v: &AccelerationView) -> String {
    format!(
        r#"{{"enabled":{},"scale":{:.6},"min_display_magnitude":{:.4}}}"#,
        v.enabled, v.scale, v.min_display_magnitude
    )
}

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

    #[test]
    fn test_defaults() {
        let v = new_acceleration_view();
        assert!(!v.enabled);
    }

    #[test]
    fn test_enable() {
        let mut v = new_acceleration_view();
        acv_set_enabled(&mut v, true);
        assert!(v.enabled);
    }

    #[test]
    fn test_scale_clamp() {
        let mut v = new_acceleration_view();
        acv_set_scale(&mut v, 0.0);
        assert_eq!(v.scale, 0.0001);
    }

    #[test]
    fn test_display_length_below_min() {
        let v = new_acceleration_view();
        assert_eq!(acv_display_length(&v, 0.0), 0.0);
    }

    #[test]
    fn test_display_length_above_min() {
        let v = new_acceleration_view();
        let len = acv_display_length(&v, 10.0);
        assert!(len > 0.0);
    }

    #[test]
    fn test_color_set() {
        let mut v = new_acceleration_view();
        acv_set_color(&mut v, [0.5, 0.5, 0.5, 1.0]);
        assert!((v.color[0] - 0.5).abs() < 1e-6);
    }

    #[test]
    fn test_min_magnitude_clamp() {
        let mut v = new_acceleration_view();
        acv_set_min_magnitude(&mut v, -5.0);
        assert_eq!(v.min_display_magnitude, 0.0);
    }

    #[test]
    fn test_json_keys() {
        let v = new_acceleration_view();
        let s = acceleration_view_to_json(&v);
        assert!(s.contains("min_display_magnitude"));
    }

    #[test]
    fn test_clone() {
        let v = new_acceleration_view();
        let v2 = v.clone();
        assert!((v2.scale - v.scale).abs() < 1e-6);
    }
}