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

// Copyright (C) 2026 COOLJAPAN OU (Team KitaSan)
// SPDX-License-Identifier: Apache-2.0

//! Main viewer struct and render loop.

use crate::camera::CameraState;
use crate::gpu::MeshUploadBuffer;
use crate::scene_state::{ViewerConfig, ViewerStats};

// ── Viewer ────────────────────────────────────────────────────────────────────

/// Stub viewer -- will be replaced by wgpu surface in Phase 2.
pub struct Viewer {
    config: ViewerConfig,
    pub camera: CameraState,
    pub current_mesh: Option<MeshUploadBuffer>,
    frame_count: u64,
}

impl Viewer {
    pub fn new(config: ViewerConfig) -> Self {
        Viewer {
            config,
            camera: CameraState::default(),
            current_mesh: None,
            frame_count: 0,
        }
    }

    /// Upload a mesh buffer to the viewer (CPU-side store; GPU upload in Phase 2).
    pub fn upload_mesh(&mut self, buf: MeshUploadBuffer) {
        self.current_mesh = Some(buf);
    }

    /// Simulate a render tick.  Returns [`ViewerStats`] for the current frame.
    pub fn render_frame(&mut self) -> ViewerStats {
        self.frame_count += 1;
        let (verts, tris) = self
            .current_mesh
            .as_ref()
            .map(|m| (m.positions.len(), m.indices.len() / 3))
            .unwrap_or((0, 0));
        ViewerStats {
            frame_count: self.frame_count,
            vertex_count: verts,
            triangle_count: tris,
        }
    }

    /// Return a reference to the current camera state.
    pub fn get_camera(&self) -> &CameraState {
        &self.camera
    }

    /// Orbit the camera around its target.
    pub fn orbit_camera(&mut self, yaw: f32, pitch: f32) {
        self.camera.orbit(yaw, pitch);
    }

    /// Return a reference to the viewer configuration.
    pub fn config(&self) -> &ViewerConfig {
        &self.config
    }
}

// ── Tests ─────────────────────────────────────────────────────────────────────

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

    #[test]
    fn viewer_render_frame_returns_stats() {
        let mut v = Viewer::new(ViewerConfig::default());
        let stats = v.render_frame();
        assert_eq!(stats.frame_count, 1);
        assert_eq!(stats.vertex_count, 0);
        assert_eq!(stats.triangle_count, 0);
    }

    #[test]
    fn viewer_upload_mesh_reflected_in_stats() {
        let buf = MeshUploadBuffer {
            positions: vec![[0.0; 3], [1.0, 0.0, 0.0], [0.0, 1.0, 0.0]],
            normals: vec![[0.0, 0.0, 1.0]; 3],
            uvs: vec![[0.0; 2]; 3],
            indices: vec![0, 1, 2],
            timestamp: 0,
        };
        let mut v = Viewer::new(ViewerConfig::default());
        v.upload_mesh(buf);
        let stats = v.render_frame();
        assert_eq!(stats.vertex_count, 3);
        assert_eq!(stats.triangle_count, 1);
    }

    #[test]
    fn viewer_orbit_camera_delegates() {
        let mut v = Viewer::new(ViewerConfig::default());
        let before = v.get_camera().position;
        v.orbit_camera(30.0, 0.0);
        assert_ne!(v.get_camera().position, before);
    }

    #[test]
    fn viewer_frame_count_increments() {
        let mut v = Viewer::new(ViewerConfig::default());
        v.render_frame();
        v.render_frame();
        let s = v.render_frame();
        assert_eq!(s.frame_count, 3);
    }
}