Skip to main content

qualia_core_db/render/camera_mount/
placement.rs

1use crate::render::camera::{orbit_forward, CameraState};
2use crate::render::skeletal::Motor;
3#[derive(Debug, Clone, Copy, PartialEq)]
4pub enum MountError {
5    InvalidInput,
6}
7#[derive(Debug, Clone, Copy)]
8pub struct MountedCamera {
9    pub eye: [f32; 3],
10    pub yaw: f32,
11    pub pitch: f32,
12    pub zoom: f32,
13    pub target: [f32; 3],
14}
15/// Local angles are relative to the body's forward (-Z). Scene center/scale
16/// must be the same normalization used by geometry upload and HUD projection.
17pub fn mounted_camera(
18    body: Motor,
19    eye: [f64; 3],
20    local_angles: [f32; 2],
21    center: [f64; 3],
22    scale: f64,
23) -> Result<MountedCamera, MountError> {
24    if eye.iter().chain(center.iter()).any(|v| !v.is_finite())
25        || local_angles.iter().any(|v| !v.is_finite())
26        || !scale.is_finite()
27        || scale <= 0.0
28    {
29        return Err(MountError::InvalidInput);
30    }
31    let world_eye = body.transform_point(eye);
32    let direction = orbit_forward(local_angles[0], local_angles[1]);
33    let aim = body.transform_point([
34        eye[0] + direction[0] as f64,
35        eye[1] + direction[1] as f64,
36        eye[2] + direction[2] as f64,
37    ]);
38    let forward = [
39        aim[0] - world_eye[0],
40        aim[1] - world_eye[1],
41        aim[2] - world_eye[2],
42    ];
43    let length = forward.iter().map(|n| n * n).sum::<f64>().sqrt();
44    if !length.is_finite() || length < 1e-12 {
45        return Err(MountError::InvalidInput);
46    }
47    let yaw = (-forward[0]).atan2(-forward[2]) as f32;
48    let pitch = (-(forward[1] / length).clamp(-1.0, 1.0).asin()) as f32;
49    let state = CameraState::new(yaw, pitch, 0.35).clamped();
50    let normalized = std::array::from_fn(|i| ((world_eye[i] - center[i]) * scale) as f32);
51    if normalized.iter().any(|v: &f32| !v.is_finite()) {
52        return Err(MountError::InvalidInput);
53    }
54    let direction = orbit_forward(state.yaw, state.pitch);
55    let target = std::array::from_fn(|i| normalized[i] + state.zoom * direction[i]);
56    Ok(MountedCamera {
57        eye: normalized,
58        yaw: state.yaw,
59        pitch: state.pitch,
60        zoom: state.zoom,
61        target,
62    })
63}