oxihuman-export 0.1.2

Export pipeline for OxiHuman — glTF, COLLADA, STL, and streaming formats
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
139
140
141

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

//! Export camera data to JSON-compatible format.

use std::f32::consts::PI;

/* ── legacy API (kept) ── */

#[derive(Debug, Clone)]
pub struct CameraExport {
    pub name: String,
    pub position: [f32; 3],
    pub target: [f32; 3],
    pub up: [f32; 3],
    pub fov_y: f32,
    pub near: f32,
    pub far: f32,
    pub camera_type: u8,
}

pub fn default_camera_export(name: &str) -> CameraExport {
    CameraExport {
        name: name.to_string(),
        position: [0.0, 0.0, 5.0],
        target: [0.0, 0.0, 0.0],
        up: [0.0, 1.0, 0.0],
        fov_y: PI / 3.0,
        near: 0.1,
        far: 1000.0,
        camera_type: 0,
    }
}

/* ── spec functions (wave 150B) ── */

/// Spec-style camera data.
#[derive(Debug, Clone)]
pub struct CameraData {
    pub name: String,
    pub fov_deg: f32,
    pub near: f32,
    pub far: f32,
    pub orthographic: bool,
    pub ortho_scale: f32,
}

/// Create a new `CameraData`.
pub fn new_camera_data(name: &str, fov_deg: f32) -> CameraData {
    CameraData {
        name: name.to_string(),
        fov_deg,
        near: 0.1,
        far: 1000.0,
        orthographic: false,
        ortho_scale: 1.0,
    }
}

/// Serialize to JSON.
pub fn camera_to_json(c: &CameraData) -> String {
    format!(
        "{{\"name\":\"{}\",\"fov_deg\":{},\"near\":{},\"far\":{},\"ortho\":{}}}",
        c.name, c.fov_deg, c.near, c.far, c.orthographic
    )
}

/// Column-major 4×4 perspective projection matrix (right-handed, OpenGL convention).
pub fn camera_projection_matrix(c: &CameraData) -> [f32; 16] {
    let fov_rad = c.fov_deg * PI / 180.0;
    let f = 1.0 / (fov_rad / 2.0).tan();
    let rng = c.near - c.far;
    [
        f,
        0.0,
        0.0,
        0.0,
        0.0,
        f,
        0.0,
        0.0,
        0.0,
        0.0,
        (c.far + c.near) / rng,
        -1.0,
        0.0,
        0.0,
        (2.0 * c.far * c.near) / rng,
        0.0,
    ]
}

/// Maximum view distance (far plane).
pub fn camera_view_distance(c: &CameraData) -> f32 {
    c.far
}

/// Returns true if the camera is orthographic.
pub fn camera_is_orthographic(c: &CameraData) -> bool {
    c.orthographic
}

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

    #[test]
    fn test_new_camera_data() {
        let c = new_camera_data("cam", 60.0);
        assert_eq!(c.name, "cam");
        assert!((c.fov_deg - 60.0).abs() < 1e-5);
    }

    #[test]
    fn test_camera_to_json() {
        let c = new_camera_data("main", 45.0);
        let j = camera_to_json(&c);
        assert!(j.contains("main"));
    }

    #[test]
    fn test_camera_projection_matrix() {
        let c = new_camera_data("c", 60.0);
        let m = camera_projection_matrix(&c);
        /* [0] = f component should be positive */
        assert!(m[0] > 0.0);
    }

    #[test]
    fn test_camera_view_distance() {
        let c = new_camera_data("c", 60.0);
        assert!((camera_view_distance(&c) - 1000.0).abs() < 1e-5);
    }

    #[test]
    fn test_camera_is_orthographic_false() {
        let c = new_camera_data("c", 60.0);
        assert!(!camera_is_orthographic(&c));
    }
}