ncube 2.4.1

Generalized Hypercube Visualizer
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

use crate::resources::SIZE;
use crate::vec::{SphericalCoordinate, SphericalCoordinateSystem};
use bevy::prelude::*;
use bevy::render::camera::ScalingMode;
use bevy::window::PrimaryWindow;

pub struct CameraPlugin;

impl Plugin for CameraPlugin {
    fn build(&self, app: &mut App) {
        app.add_systems(Startup, (spawn_camera, spawn_lighting))
            .add_systems(Update, update_camera);
    }
}

const WHEEL_FACTOR: f32 = if cfg!(target_family = "wasm") {
    0.001
} else {
    0.3
} * SIZE;
const MOTION_FACTOR: f32 = 0.3;

pub fn get_default_camera_transform() -> Transform {
    Transform::from_translation(Vec3::from_spherical(SphericalCoordinate::new(
        4.0 * SIZE,
        std::f32::consts::PI / 2.0,
        0.0,
    )))
    .looking_at(Vec3::ZERO, Vec3::Y)
}

/// If `ortho_d` is Some(d) then OrthographicProjection is calculated using the provided `d`
/// else PerspectiveProjection is used
pub fn get_default_camera_projection(ortho_d: Option<f32>) -> Projection {
    match ortho_d {
        Some(d) => Projection::Orthographic(OrthographicProjection {
            scaling_mode: ScalingMode::WindowSize(
                1000.0 * 1.0 / d, // Smooth transition in most cases
            ),
            ..default()
        }),
        None => Projection::Perspective(PerspectiveProjection::default()),
    }
}

fn spawn_camera(mut commands: Commands) {
    commands.spawn(Camera3dBundle {
        transform: get_default_camera_transform(),
        camera: Camera {
            clear_color: bevy::render::camera::ClearColorConfig::Custom(Color::BLACK),
            ..default()
        },
        camera_3d: Camera3d { ..default() },
        projection: get_default_camera_projection(None),
        ..default()
    });
}

fn spawn_lighting(mut commands: Commands) {
    let intensity = 1500000.0 * SIZE.powi(2);
    let range = 20.0 * SIZE;
    commands.spawn(PointLightBundle {
        point_light: PointLight {
            intensity,
            range,
            ..default()
        },
        transform: Transform::from_translation(Vec3::new(3.0, 8.0, 4.0) * SIZE),
        ..default()
    });
    commands.spawn(PointLightBundle {
        point_light: PointLight {
            intensity,
            range,
            ..default()
        },
        transform: Transform::from_translation(Vec3::new(-4.0, 8.0, -4.0) * SIZE),
        ..default()
    });
}

fn update_camera(
    mut q_camera: Query<(&mut Transform, &mut Projection), With<Camera>>,
    mut q_primary_window: Query<&mut Window, With<PrimaryWindow>>,
    mut mouse_wheel_events: EventReader<bevy::input::mouse::MouseWheel>,
    mut mouse_motion_events: EventReader<bevy::input::mouse::MouseMotion>,
    mouse_button_input: Res<ButtonInput<MouseButton>>,
    keys: Res<ButtonInput<KeyCode>>,
) {
    let (mut camera_transform, mut camera_projection) = q_camera.get_single_mut().unwrap();
    let mut window = q_primary_window.get_single_mut().unwrap();

    let curr_pos_spherical = camera_transform.translation.to_spherical();

    if keys.pressed(KeyCode::ControlLeft) || keys.pressed(KeyCode::ControlRight) {
        mouse_wheel_events.read().for_each(|event| {
            if event.y == 0.0 {
                return;
            }
            camera_transform.translation = Vec3::from_spherical(SphericalCoordinate::new(
                curr_pos_spherical.r * 1.0 - event.y * WHEEL_FACTOR,
                curr_pos_spherical.theta,
                curr_pos_spherical.phi,
            ));
            if let Projection::Orthographic(_) = *camera_projection {
                *camera_projection =
                    get_default_camera_projection(Some(camera_transform.translation.length()));
            }
        });
    }

    if !mouse_button_input.pressed(MouseButton::Right) {
        if mouse_button_input.just_released(MouseButton::Right) {
            let new_cursor_pos = Vec2::new(window.width() / 2.0, window.height() / 2.0);
            window.set_cursor_position(Some(new_cursor_pos));
            window.cursor.visible = true;
        }
        return;
    }

    window.cursor.visible = false;

    mouse_motion_events.read().for_each(|event| {
        if event.delta.length() == 0.0 {
            return;
        }
        camera_transform.translation = Vec3::from_spherical(SphericalCoordinate::new(
            curr_pos_spherical.r,
            (curr_pos_spherical.theta + event.delta.y.to_radians() * -MOTION_FACTOR)
                // Prevent flipping effect
                .min(std::f32::consts::PI * (1.0 - std::f32::EPSILON))
                .max(std::f32::EPSILON),
            curr_pos_spherical.phi + event.delta.x.to_radians() * -MOTION_FACTOR,
        ));
        *camera_transform = camera_transform.looking_at(Vec3::ZERO, Vec3::Y);
    });
}