rantz_camera2d 1.1.2

A 2D camera plugin for Bevy, inspired by the Love2D camera plugin - STALKER-X
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

use crate::prelude::*;
use bevy::prelude::*;
use rantz_spatial2d::prelude::*;

fn main_camera_valid(num_cameras: usize, num_camera_targets: usize) -> bool {
    if main_camera_exists(num_cameras) && main_camera_target_exists(num_camera_targets) {
        return true;
    }

    if num_cameras > 1 {
        error!("Multiple main cameras found, only one is supported");
    }

    if num_camera_targets > 1 {
        error!("Multiple main camera targets found, only one is supported");
    }
    false
}

fn main_camera_exists(num_cameras: usize) -> bool {
    if num_cameras == 1 {
        return true;
    }
    false
}

fn main_camera_target_exists(num_camera_targets: usize) -> bool {
    if num_camera_targets == 1 {
        return true;
    }
    false
}

pub fn set_initial_main_camera_target(
    mut commands: Commands,
    main_camera_query: Query<Entity, (With<MainCamera>, Without<CameraTarget>)>,
    main_camera_target_query: Query<Entity, (With<MainCameraShouldTarget>, With<Position2D>)>,
) {
    let num_cams = main_camera_query.iter().count();
    let num_targets = main_camera_target_query.iter().count();
    if main_camera_valid(num_cams, num_targets) {
        let main_camera = main_camera_query.get_single().unwrap();
        let main_camera_target = main_camera_target_query.get_single().unwrap();

        commands
            .entity(main_camera)
            .insert(CameraTarget(Some(main_camera_target)));
    }
}

pub fn main_camera_target_added(
    main_camera_target_query: Query<Entity, (Added<MainCameraShouldTarget>, With<Position2D>)>,
    mut main_camera_query: Query<&mut CameraTarget, With<MainCamera>>,
) {
    let num_cams = main_camera_query.iter().count();
    let num_targets = main_camera_target_query.iter().count();
    if main_camera_valid(num_cams, num_targets) {
        let mut camera_target = main_camera_query.get_single_mut().unwrap();
        let main_camera_target = main_camera_target_query.get_single().unwrap();
        let previous_target = camera_target.0;
        if let Some(t) = previous_target {
            if t == main_camera_target {
                return;
            }
        }
        camera_target.0 = Some(main_camera_target);
    }
}

pub fn main_camera_target_removed(
    mut main_camera_query: Query<&mut CameraTarget, With<MainCamera>>,
    main_camera_target_query: Query<Entity, (With<MainCameraShouldTarget>, With<Position2D>)>,
) {
    let num_cams = main_camera_query.iter().count();
    let num_targets = main_camera_target_query.iter().count();
    if main_camera_exists(num_cams) && num_targets == 0 {
        let mut camera_target = main_camera_query.get_single_mut().unwrap();
        if camera_target.0.is_some() {
            camera_target.0 = None;
        }
    }
}