Camera with RigidBody attached is affected by gravity but not collision

[uglyluigi]

Hi there,

I have a simple scene, containing a cube, camera (with attached RigidBody and CollisionShape), and a plane (also with attached RigidBody and CollisionShape, but it's static). The cube and plane collide fine after some gravity brings it down. However, the camera, while it does not ignore gravity, does ignore collision with anything else, and falls straight through my plane after gravity acts on it for a short time. There are no collision layers configured. Why does this happen?

use bevy::prelude::*;
use bevy_egui::EguiPlugin;
use heron::{prelude::*, CollisionShape};
mod controller;
mod hud;
mod key_hooks;
use controller::CameraController;
use hud::render_hud;

fn main() {
    App::new()
        .add_startup_system(setup)
        .insert_resource(Msaa { samples: 4 })
        .insert_resource(WindowDescriptor {
            title: "C U B E".to_string(),
            width: 1600.,
            height: 1600.,
            ..Default::default()
        })
        .add_system(controller::camera_controller)
        .add_system(key_hooks::key_hooks)
        .add_system(render_hud)
        .add_plugins(DefaultPlugins)
        .add_plugin(PhysicsPlugin::default())
        .insert_resource(Gravity::from(Vec3::new(0.0, -9.81, 0.0)))
        .add_plugin(EguiPlugin)
        .run();
}

fn setup(
    mut commands: Commands,
    mut meshes: ResMut<Assets<Mesh>>,
    mut materials: ResMut<Assets<StandardMaterial>>,
) {
    commands
        .spawn_bundle(PbrBundle {
            mesh: meshes.add(Mesh::from(shape::Cube { size: 10.0 })),
            material: materials.add(Color::rgb(0.3, 0.5, 0.3).into()),
            transform: Transform::from_xyz(0.0, 50.0, 0.0).into(),
            ..default()
        })
        .insert(RigidBody::Dynamic)
        .insert(heron::CollisionShape::Cuboid {
            half_extends: Vec3::new(10.0, 10.0, 10.0) / 2.0,
            border_radius: None,
        })
        .insert(GlobalTransform::default())
        .insert(PhysicMaterial {
            restitution: 0.7,
            ..default()
        })
        .insert(RotationConstraints::lock());

    commands
        .spawn_bundle(PbrBundle {
            mesh: meshes.add(Mesh::from(shape::Plane { size: 1000.0 })),
            material: materials.add(Color::rgb(0.3, 0.5, 0.3).into()),
            transform: Transform::from_xyz(0.0, 0.0, 0.0).into(),
            ..default()
        })
        .insert(RigidBody::Static)
        .insert(CollisionShape::Cuboid {
            half_extends: Vec3::new(0.0, 0.0, 0.0),
            border_radius: None,
        })
        .insert(PhysicMaterial {
            friction: 0.5,
            density: 100000000.0,
            ..default()
        })
        .insert(RotationConstraints::lock());

    // light
    commands.spawn_bundle(PointLightBundle {
        point_light: PointLight {
            intensity: 15_000.0,
            shadows_enabled: true,
            ..default()
        },
        transform: Transform::from_xyz(9.0, 8.0, 4.0),
        ..default()
    });

    // camera
    commands
        .spawn_bundle(PerspectiveCameraBundle {
            transform: Transform::from_xyz(-2.0, 10.0, 10.0).looking_at(Vec3::ZERO, Vec3::Y),
            ..default()
        })
        .insert(CameraController::default())
        .insert(RigidBody::Dynamic)
        .insert(CollisionShape::Sphere { radius: 1.0 })
        .insert(GlobalTransform::default())
        .insert(PhysicMaterial {
            restitution: 7.0,
            ..default()
        })
        .insert(RotationConstraints::lock());
}

[jcornaz]

Hi.

What is the CameraController? Can you try without it?

[uglyluigi]

The CameraController just translates and rotates the camera based on key presses and mouse movements. Here's the complete code of it. With or without the camera controller, the RigidBody and the plane simply do not interact; when logging collisions, the cube and plane interact as you'd expect, but the camera's RigidBody appears to ignores everything.

use bevy::input::mouse::MouseMotion;
use bevy::prelude::*;

#[derive(Component)]
pub struct CameraController {
    pub enabled: bool,
    pub sensitivity: f32,
    pub key_forward: KeyCode,
    pub key_back: KeyCode,
    pub key_left: KeyCode,
    pub key_right: KeyCode,
    pub key_up: KeyCode,
    pub key_down: KeyCode,
    pub key_run: KeyCode,
    pub walk_speed: f32,
    pub run_speed: f32,
    pub friction: f32,
    pub pitch: f32,
    pub yaw: f32,
    pub velocity: Vec3,
}

impl Default for CameraController {
    fn default() -> Self {
        Self {
            enabled: true,
            sensitivity: 0.2,
            key_forward: KeyCode::W,
            key_back: KeyCode::S,
            key_left: KeyCode::A,
            key_right: KeyCode::D,
            key_up: KeyCode::E,
            key_down: KeyCode::Q,
            key_run: KeyCode::LShift,
            walk_speed: 10.0,
            run_speed: 30.0,
            friction: 0.5,
            pitch: 0.0,
            yaw: 0.0,
            velocity: Vec3::ZERO,
        }
    }
}

pub fn camera_controller(
    time: Res<Time>,
    mut mouse_events: EventReader<MouseMotion>,
    key_input: Res<Input<KeyCode>>,
    mut query: Query<(&mut Transform, &mut CameraController), With<Camera>>,
) {
    let dt = time.delta_seconds();

    // Handle mouse input
    let mut mouse_delta = Vec2::ZERO;
    for mouse_event in mouse_events.iter() {
        mouse_delta += mouse_event.delta;
    }

    for (mut transform, mut options) in query.iter_mut() {
        if !options.enabled {
            continue;
        }

        // Handle key input
        let mut axis_input = Vec3::ZERO;
        if key_input.pressed(options.key_forward) {
            axis_input.z += 1.0;
        }
        if key_input.pressed(options.key_back) {
            axis_input.z -= 1.0;
        }
        if key_input.pressed(options.key_right) {
            axis_input.x += 1.0;
        }
        if key_input.pressed(options.key_left) {
            axis_input.x -= 1.0;
        }
        if key_input.pressed(options.key_up) {
            axis_input.y += 1.0;
        }
        if key_input.pressed(options.key_down) {
            axis_input.y -= 1.0;
        }

        // Apply movement update
        if axis_input != Vec3::ZERO {
            let max_speed = if key_input.pressed(options.key_run) {
                options.run_speed
            } else {
                options.walk_speed
            };
            options.velocity = axis_input.normalize() * max_speed;
        } else {
            let friction = options.friction.clamp(0.0, 1.0);
            options.velocity *= 1.0 - friction;
            if options.velocity.length_squared() < 1e-6 {
                options.velocity = Vec3::ZERO;
            }
        }
        let forward = transform.forward();
        let right = transform.right();
        transform.translation += options.velocity.x * dt * right
            + options.velocity.y * dt * Vec3::Y
            + options.velocity.z * dt * forward;

        if mouse_delta != Vec2::ZERO {
            // Apply look update
            let (pitch, yaw) = (
                (options.pitch - mouse_delta.y * 0.5 * options.sensitivity * dt).clamp(
                    -0.99 * std::f32::consts::FRAC_PI_2,
                    0.99 * std::f32::consts::FRAC_PI_2,
                ),
                options.yaw - mouse_delta.x * options.sensitivity * dt,
            );
            transform.rotation = Quat::from_euler(EulerRot::ZYX, 0.0, yaw, pitch);
            options.pitch = pitch;
            options.yaw = yaw;
        }
    }
}