bevy_editor_cam 0.9.2

A camera controller for editors and CAD.
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

//! Defines how the camera controller reads and writes transform data.
//!
//! By default, [`TransformAdapter`] reads and writes Bevy's built-in [`Transform`] component.
//! To use a different transform representation (e.g. a 64-bit transform), replace this resource
//! with custom `read` and `apply_delta` callbacks.

use bevy_ecs::prelude::*;
use bevy_log::error_once;
use bevy_math::{DQuat, DVec3};
use bevy_transform::prelude::*;

/// Resource that defines how the camera controller reads and writes transform data.
///
/// By default, this reads and writes Bevy's built-in [`Transform`] component. Replace this
/// resource to use a different transform component (e.g. a 64-bit transform) via [`Self::new`].
#[derive(Resource)]
pub struct TransformAdapter {
    read_fn: Box<dyn Fn(&EntityRef) -> Option<(DVec3, DQuat)> + Send + Sync>,
    apply_delta_fn: Box<dyn Fn(&mut EntityMut, DVec3, DQuat) + Send + Sync>,
}

impl TransformAdapter {
    /// Create a new `TransformAdapter` with custom read and apply_delta callbacks.
    pub fn new(
        read: impl Fn(&EntityRef) -> Option<(DVec3, DQuat)> + Send + Sync + 'static,
        apply_delta: impl Fn(&mut EntityMut, DVec3, DQuat) + Send + Sync + 'static,
    ) -> Self {
        Self {
            read_fn: Box::new(read),
            apply_delta_fn: Box::new(apply_delta),
        }
    }

    /// Read the translation and rotation of an entity.
    pub fn read(&self, entity: &EntityRef) -> Option<(DVec3, DQuat)> {
        (self.read_fn)(entity)
    }

    /// Apply a movement delta to an entity. The delta is in the entity's local space, as produced
    /// by [`transform_delta`]; implementations should compose it onto the current transform, not
    /// overwrite it, and should keep the resulting rotation normalized.
    pub fn apply_delta(
        &self,
        entity: &mut EntityMut,
        delta_translation: DVec3,
        delta_rotation: DQuat,
    ) {
        (self.apply_delta_fn)(entity, delta_translation, delta_rotation)
    }
}

/// Compute the entity-local delta that takes a transform from `original` to `new`, in the form
/// expected by [`TransformAdapter::apply_delta`]. Both inputs are `(translation, rotation)`.
pub fn transform_delta(
    (original_translation, original_rotation): (DVec3, DQuat),
    (new_translation, new_rotation): (DVec3, DQuat),
) -> (DVec3, DQuat) {
    let inverse = original_rotation.inverse();
    (
        inverse * (new_translation - original_translation),
        inverse * new_rotation,
    )
}

impl Default for TransformAdapter {
    fn default() -> Self {
        Self::new(
            |entity| {
                let Some(cam_transform) = entity.get::<Transform>() else {
                    error_once!("Unable to retrieve Transform from EditorCam entity.");
                    return None;
                };
                Some((
                    cam_transform.translation.as_dvec3(),
                    cam_transform.rotation.as_dquat(),
                ))
            },
            |entity, delta_translation, delta_rotation| {
                let Some(mut cam_transform) = entity.get_mut::<Transform>() else {
                    error_once!("Unable to retrieve Transform from EditorCam entity.");
                    return;
                };
                // The delta is composed in 64-bit and only rounded to the stored 32-bit
                // `Transform` once. Composing with `Transform::mul_transform` instead would do
                // the quaternion product in 32-bit and leave the result un-normalized, which
                // accumulates a systematic error every frame. That is invisible with the camera
                // close to the anchor, but a dolly zoom into ortho parks the camera thousands of
                // units away to maximize depth precision, where the same angular error is enough
                // to visibly slide the anchor out from under the pointer while orbiting.
                let rotation = cam_transform.rotation.as_dquat();
                let translation = cam_transform.translation.as_dvec3();
                cam_transform.translation = (translation + rotation * delta_translation).as_vec3();
                cam_transform.rotation = (rotation * delta_rotation).normalize().as_quat();
            },
        )
    }
}