Bevy camera mirror attempt

Cargo.toml

[package]
name = "test-bevy-mirror"
version = "0.1.0"
edition = "2021"

# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

[dependencies]
bevy = { version = "0.9.1", default-features = false, features = [
    "bevy_render",
    "bevy_core_pipeline",
    "bevy_pbr",
    "x11",
] }
bevy_flycam = "0.9"

main.rs

use std::f32::consts::FRAC_PI_2;

use bevy::{
    prelude::{shape::{Plane, Cube}, *},
    render::{
        camera::RenderTarget,
        render_resource::{Extent3d, TextureUsages},
    },
};
use bevy_flycam::{FlyCam, PlayerPlugin};

fn main() {
    App::new()
        .add_plugins(DefaultPlugins)
        .add_plugin(PlayerPlugin)
        .add_startup_system(spawn_scene_system)
        .add_startup_system(spawn_mirror_system)
        .add_system(mirror_cam_rotation_system)
        .run();
}

#[derive(Component)]
struct MirrorCam;

#[derive(Component)]
struct Mirror;

fn spawn_scene_system(
    mut commands: Commands,
    mut meshes: ResMut<Assets<Mesh>>,
    mut materials: ResMut<Assets<StandardMaterial>>,
) {
    commands.spawn(PbrBundle {
        mesh: meshes.add(Mesh::from(Plane { size: 5.0 })),
        material: materials.add(Color::rgb(0.3, 0.5, 0.3).into()),
        ..Default::default()
    });
    commands.spawn(PbrBundle {
        mesh: meshes.add(Mesh::from(Cube { size: 1.0 })),
        material: materials.add(Color::rgb(0.8, 0.7, 0.6).into()),
        transform: Transform::from_xyz(0.0, 0.5, 0.0),
        ..Default::default()
    });
    commands.spawn(PointLightBundle {
        point_light: PointLight {
            intensity: 1500.0,
            shadows_enabled: true,
            ..Default::default()
        },
        transform: Transform::from_xyz(4.0, 8.0, 4.0),
        ..Default::default()
    });
}

fn spawn_mirror_system(
    mut commands: Commands,
    mut meshes: ResMut<Assets<Mesh>>,
    mut materials: ResMut<Assets<StandardMaterial>>,
    mut images: ResMut<Assets<Image>>,
) {
    const RENDER_SIZE: u32 = 400;
    let mut image = Image::default();
    image.texture_descriptor.usage |= TextureUsages::RENDER_ATTACHMENT;
    image.resize(Extent3d {
        width: RENDER_SIZE,
        height: RENDER_SIZE,
        ..Default::default()
    });
    let image_handle = images.add(image);

    commands.spawn((
        Mirror,
        PbrBundle {
            mesh: meshes.add(Mesh::from(Plane { size: 5.0 })),
            material: materials.add(image_handle.clone().into()),
            transform: Transform {
                translation: Vec3::new(0.0, 2.5, -2.5),
                rotation: Quat::from_rotation_x(FRAC_PI_2),
                ..Default::default()
            },
            ..Default::default()
        },
    ));

    commands.spawn((
        MirrorCam,
        Camera3dBundle {
            camera: Camera {
                target: RenderTarget::Image(image_handle),
                ..Default::default()
            },
            ..Default::default()
        },
    ));
}

fn mirror_cam_rotation_system(
    player_cams: Query<&GlobalTransform, With<FlyCam>>,
    mut mirror_cams: Query<&mut Transform, With<MirrorCam>>,
    mirrors: Query<&GlobalTransform, With<Mirror>>,
) {
    let player_transform = player_cams.single();
    let plane_transform = mirrors.single();
    let mut mirror_transform = mirror_cams.single_mut();

    let p_mirror = plane_transform.translation();
    let p_player = player_transform.translation();
    let v_mirror_to_player = p_player - p_mirror;
    let v_mirror_to_camera = -plane_transform.forward() * v_mirror_to_player;
    mirror_transform.translation = p_mirror + v_mirror_to_camera;
    mirror_transform.look_at(p_mirror, Vec3::Y);
}