Refactor done, still works.

Mostly resisted the urge to add or change functionality. Checks clean and should have the foundation
for real game-focused devel going forward.
This commit is contained in:
Joe Ardent 2022-01-12 00:18:13 -08:00
parent 5fba5af72e
commit 483dc3f864
9 changed files with 633 additions and 533 deletions

63
src/camera.rs Normal file
View File

@ -0,0 +1,63 @@
use bevy::prelude::*;
use crate::{geometry::CyberBike, input::InputState, physics::MovementSettings};
pub(crate) const CAM_DIST: f32 = 50.0;
#[derive(Component, Debug)]
pub struct CyberCam;
fn setup_cybercam(mut commands: Commands) {
use crate::geometry::PLAYER_DIST;
commands
.spawn_bundle(PerspectiveCameraBundle {
transform: Transform::from_xyz(PLAYER_DIST + CAM_DIST, 0.0, 0.0)
.looking_at(Vec3::ZERO, Vec3::Y),
..Default::default()
})
.insert(CyberCam);
}
fn follow_player(
bike_query: Query<(&Transform, &CyberBike), Without<CyberCam>>,
mut cam_query: Query<(&mut Transform, &CyberCam), Without<CyberBike>>,
) {
let (bike_xform, _) = bike_query.single();
let up = bike_xform.translation.normalize();
let look_at = bike_xform.translation;
let cam_pos = bike_xform.translation + (bike_xform.back() * CAM_DIST * 1.3) + (up * CAM_DIST);
let (mut cam_xform, _) = cam_query.single_mut();
cam_xform.translation = cam_pos;
cam_xform.look_at(look_at, up);
}
fn player_look(
settings: Res<MovementSettings>,
windows: Res<Windows>,
time: Res<Time>,
istate: Res<InputState>,
mut query: Query<(&mut Transform, &CyberBike)>,
) {
let window = windows.get_primary().unwrap();
let window_scale = window.height().min(window.width());
let dt = time.delta_seconds();
let (mut transform, _) = query.single_mut();
let d_alt = (settings.sensitivity * dt * window_scale * istate.pitch).to_radians();
let d_az = (settings.sensitivity * dt * window_scale * istate.yaw).to_radians();
let rotation = Quat::from_axis_angle(transform.local_y(), d_az)
* Quat::from_axis_angle(transform.local_x(), d_alt);
transform.rotate(rotation);
}
pub struct CyberCamPlugin;
impl Plugin for CyberCamPlugin {
fn build(&self, app: &mut bevy::prelude::App) {
app.add_startup_system(setup_cybercam)
.add_system(follow_player)
.add_system(player_look);
}
}

View File

@ -1,295 +0,0 @@
use bevy::{
app::{Events, ManualEventReader},
input::{
gamepad::{GamepadAxisType, GamepadEvent, GamepadEventType},
Input,
},
prelude::*,
utils::tracing::info,
};
use heron::{
prelude::{CollisionShape, RigidBody},
CollisionEvent,
};
pub const PLANET_RADIUS: f32 = 150.0;
const PLAYER_DIST: f32 = PLANET_RADIUS + 100.0;
const CAM_DIST: f32 = 50.0;
#[derive(Component, Default)]
struct PlayerState {
velocity: Vec3,
colliding: bool,
}
#[derive(Default)]
struct InputState {
event_reader: ManualEventReader<GamepadEvent>,
pitch: f32,
yaw: f32,
throttle: f32,
}
/// Mouse sensitivity and movement speed
pub struct MovementSettings {
pub sensitivity: f32,
pub accel: f32,
pub drag: f32,
pub gravity: f32,
}
impl Default for MovementSettings {
fn default() -> Self {
Self {
sensitivity: 1.0,
accel: 40.,
drag: 0.0005,
gravity: 10.0,
}
}
}
/// Used in queries when you want flycams and not other cameras
#[derive(Component, Debug)]
pub struct FlyCam;
#[derive(Component, Debug)]
pub struct CyberBike;
#[derive(Component)]
struct UpText;
/// Spawns the `Camera3dBundle` to be controlled
fn setup_player(mut commands: Commands, asset_server: Res<AssetServer>) {
commands
.spawn_bundle(PerspectiveCameraBundle {
transform: Transform::from_xyz(PLAYER_DIST + CAM_DIST, 0.0, 0.0)
.looking_at(Vec3::ZERO, Vec3::Y),
..Default::default()
})
.insert(FlyCam);
commands
.spawn_bundle((
Transform {
translation: Vec3::new(PLAYER_DIST, 0.0, 0.0),
..Default::default()
}
.looking_at(Vec3::ZERO, Vec3::Y),
GlobalTransform::identity(),
))
.with_children(|rider| {
rider.spawn_scene(asset_server.load("cyber-bike_no_y_up.glb#Scene0"));
})
.insert(CyberBike)
.insert(RigidBody::Dynamic)
.insert(CollisionShape::Cone {
half_height: 2.0,
radius: 0.8,
})
.insert(PlayerState::default());
}
fn setup_ui(mut commands: Commands, asset_server: Res<AssetServer>) {
commands.spawn_bundle(UiCameraBundle::default());
commands
.spawn_bundle(TextBundle {
style: Style {
align_self: AlignSelf::FlexEnd,
..Default::default()
},
// Use `Text` directly
text: Text {
// Construct a `Vec` of `TextSection`s
sections: vec![TextSection {
value: "".to_string(),
style: TextStyle {
font: asset_server.load("fonts/FiraMono-Medium.ttf"),
font_size: 40.0,
color: Color::GOLD,
},
}],
..Default::default()
},
..Default::default()
})
.insert(UpText);
}
fn ui_system(pstate_query: Query<&PlayerState>, mut text_query: Query<&mut Text, With<UpText>>) {
let mut text = text_query.single_mut();
let pstate = pstate_query.single();
text.sections[0].value = format!("{:.2}", pstate.velocity.length());
}
fn player_move(
time: Res<Time>,
mut bike_query: Query<(&mut Transform, &PlayerState), Without<FlyCam>>,
mut cam_query: Query<(&mut Transform, &FlyCam), Without<PlayerState>>,
) {
let dt = time.delta_seconds();
let (mut bike_xform, player_state) = bike_query.single_mut();
let up = bike_xform.translation.normalize();
let cam_up = bike_xform.up();
let cos = up.dot(cam_up);
let theta = cos.acos();
let rate = if !theta.is_normal() {
0.0
} else if theta.is_sign_negative() {
-0.4
} else {
0.4
} * dt;
let angle = if rate.is_sign_negative() {
rate.max(theta)
} else {
rate.min(theta)
};
let rot = Quat::from_axis_angle(cam_up.cross(up).normalize(), angle);
if rot.is_finite() && theta.abs() > 0.0085 {
bike_xform.rotate(rot);
}
if player_state.velocity.is_finite() {
bike_xform.translation += player_state.velocity * dt;
}
let look_at = bike_xform.translation;
let cam_pos = bike_xform.translation + (bike_xform.back() * CAM_DIST * 1.3) + (up * CAM_DIST);
let (mut cam_xform, _) = cam_query.single_mut();
cam_xform.translation = cam_pos;
cam_xform.look_at(look_at, up);
}
fn player_look(
settings: Res<MovementSettings>,
windows: Res<Windows>,
events: Res<Events<GamepadEvent>>,
time: Res<Time>,
mut istate: ResMut<InputState>,
mut query: Query<(&mut Transform, &mut PlayerState)>,
) {
let window = windows.get_primary().unwrap();
let window_scale = window.height().min(window.width());
let dt = time.delta_seconds();
let (mut transform, mut pstate) = query.single_mut();
let mut vel = pstate.velocity;
if pstate.velocity.is_finite() {
for GamepadEvent(_, ev) in istate.event_reader.iter(&events) {
match *ev {
GamepadEventType::ButtonChanged(GamepadButtonType::RightTrigger2, val) => {
istate.throttle = val;
}
GamepadEventType::ButtonChanged(GamepadButtonType::LeftTrigger2, val) => {
istate.throttle = -val;
}
GamepadEventType::ButtonChanged(GamepadButtonType::East, val) => {
if val > 0.5 {
vel = Vec3::ZERO;
}
}
GamepadEventType::AxisChanged(GamepadAxisType::LeftStickX, val) => {
istate.yaw = -val;
}
GamepadEventType::AxisChanged(GamepadAxisType::LeftStickY, val) => {
istate.pitch = -val;
}
_ => {
info!("unhandled gamepad event: {:?}", ev);
}
}
}
let accel = settings.accel * dt * istate.throttle;
vel += transform.forward() * accel;
// drag
let v2 = vel.length_squared().min(100_000.0);
if v2 < 0.05 {
vel = Vec3::ZERO;
} else {
let drag = vel * settings.drag * v2.sqrt() * time.delta_seconds();
vel -= drag;
}
} else {
vel = Vec3::ZERO;
}
let d_alt = (settings.sensitivity * dt * window_scale * istate.pitch).to_radians();
let d_az = (settings.sensitivity * dt * window_scale * istate.yaw).to_radians();
let rotation = Quat::from_axis_angle(transform.local_y(), d_az)
* Quat::from_axis_angle(transform.local_x(), d_alt);
transform.rotate(rotation);
pstate.velocity = vel;
}
fn collision_detection(
mut events: EventReader<CollisionEvent>,
mut query: Query<&mut PlayerState>,
) {
let mut pstate = query.single_mut();
for event in events.iter() {
if let CollisionEvent::Started(_, _) = event {
pstate.colliding = true;
} else {
pstate.colliding = false;
}
}
}
fn gravity_collision_reaction(
time: Res<Time>,
settings: Res<MovementSettings>,
mut query: Query<(&mut PlayerState, &Transform)>,
) {
let dt = time.delta_seconds();
let g = settings.gravity;
let (mut pstate, xform) = query.single_mut();
// first gravity
let down = -xform.translation.normalize();
let dvel = down * g * dt;
let mut vel = if pstate.velocity.is_finite() {
pstate.velocity + dvel
} else {
dvel
};
// now see if we're currently colliding
if pstate.colliding {
let dvel = down * vel.dot(down) * 1.02;
vel -= dvel;
}
pstate.velocity = vel;
}
/// Contains everything needed to add first-person fly camera behavior to your
/// game
pub struct PlayerPlugin;
impl Plugin for PlayerPlugin {
fn build(&self, app: &mut bevy::prelude::App) {
app.init_resource::<PlayerState>()
.init_resource::<MovementSettings>()
.init_resource::<InputState>()
.add_startup_system(setup_player)
.add_startup_system(setup_ui)
.add_system(ui_system)
.add_system(player_move.label("move"))
.add_system(player_look.after("move"))
.add_system(collision_detection)
.add_system(gravity_collision_reaction);
}
}

67
src/geometry.rs Normal file
View File

@ -0,0 +1,67 @@
use bevy::prelude::*;
use heron::prelude::{CollisionShape, RigidBody};
pub const PLANET_RADIUS: f32 = 150.0;
pub(crate) const PLAYER_DIST: f32 = PLANET_RADIUS + 100.0;
pub struct CyberGeomPlugin;
impl Plugin for CyberGeomPlugin {
fn build(&self, app: &mut App) {
app.add_startup_system(setup_giant_sphere)
.add_startup_system(setup_player);
}
}
#[derive(Component, Debug)]
pub struct CyberBike;
fn setup_giant_sphere(
mut commands: Commands,
mut meshes: ResMut<Assets<Mesh>>,
mut materials: ResMut<Assets<StandardMaterial>>,
) {
// world
commands
.spawn_bundle(PbrBundle {
mesh: meshes.add(Mesh::from(shape::Icosphere {
radius: PLANET_RADIUS,
subdivisions: 6,
})),
material: materials.add(StandardMaterial {
base_color: Color::GRAY,
metallic: 0.7,
perceptual_roughness: 0.5,
..Default::default()
}),
..Default::default()
})
.insert(RigidBody::Static)
.insert(CollisionShape::Sphere {
radius: PLANET_RADIUS,
});
}
fn setup_player(mut commands: Commands, asset_server: Res<AssetServer>) {
use crate::physics::PlayerState;
commands
.spawn_bundle((
Transform {
translation: Vec3::new(PLAYER_DIST, 0.0, 0.0),
..Default::default()
}
.looking_at(Vec3::ZERO, Vec3::Y),
GlobalTransform::identity(),
))
.with_children(|rider| {
rider.spawn_scene(asset_server.load("cyber-bike_no_y_up.glb#Scene0"));
})
.insert(CyberBike)
.insert(RigidBody::Dynamic)
.insert(CollisionShape::Cone {
half_height: 2.0,
radius: 0.8,
})
.insert(PlayerState::default());
}

49
src/input.rs Normal file
View File

@ -0,0 +1,49 @@
use bevy::{
app::{Events, ManualEventReader},
prelude::*,
};
#[derive(Default)]
pub(crate) struct InputState {
event_reader: ManualEventReader<GamepadEvent>,
pub pitch: f32,
pub yaw: f32,
pub throttle: f32,
pub brake: bool,
}
fn update_input(events: Res<Events<GamepadEvent>>, mut istate: ResMut<InputState>) {
for GamepadEvent(_, ev) in istate.event_reader.iter(&events) {
match *ev {
GamepadEventType::ButtonChanged(GamepadButtonType::RightTrigger2, val) => {
istate.throttle = val;
}
GamepadEventType::ButtonChanged(GamepadButtonType::LeftTrigger2, val) => {
istate.throttle = -val;
}
GamepadEventType::ButtonChanged(GamepadButtonType::East, val) => {
if val > 0.5 {
istate.brake = true;
} else {
istate.brake = false;
}
}
GamepadEventType::AxisChanged(GamepadAxisType::LeftStickX, val) => {
istate.yaw = -val;
}
GamepadEventType::AxisChanged(GamepadAxisType::LeftStickY, val) => {
istate.pitch = -val;
}
_ => {
info!("unhandled gamepad event: {:?}", ev);
}
}
}
}
pub struct CyberInputPlugin;
impl Plugin for CyberInputPlugin {
fn build(&self, app: &mut App) {
app.init_resource::<InputState>().add_system(update_input);
}
}

View File

@ -1 +1,14 @@
pub mod flycam; use bevy::prelude::{ResMut, Windows};
pub mod camera;
pub mod geometry;
pub mod input;
pub mod lights;
pub mod physics;
pub mod ui;
pub fn disable_mouse_trap(mut windows: ResMut<Windows>) {
let window = windows.get_primary_mut().unwrap();
window.set_cursor_lock_mode(false);
window.set_cursor_visibility(true);
}

209
src/lights.rs Normal file
View File

@ -0,0 +1,209 @@
use bevy::prelude::*;
use crate::geometry::PLANET_RADIUS;
pub const LIGHT_RANGE: f32 = PLANET_RADIUS * 0.6;
pub const LIGHT_DIST: f32 = PLANET_RADIUS * 1.2;
pub struct CyberSpaceLightsPlugin;
impl Plugin for CyberSpaceLightsPlugin {
fn build(&self, app: &mut App) {
app.add_startup_system(setup).add_system(animate_lights);
}
}
#[derive(Component)]
struct Animate;
fn setup(
mut commands: Commands,
mut meshes: ResMut<Assets<Mesh>>,
mut materials: ResMut<Assets<StandardMaterial>>,
) {
let red_light = PointLight {
intensity: 1_000.0,
range: LIGHT_RANGE,
color: Color::RED,
radius: 1.0,
..Default::default()
};
let blue_light = PointLight {
intensity: 1_000.0,
range: LIGHT_RANGE,
color: Color::BLUE,
radius: 1.0,
..Default::default()
};
let purple_light = PointLight {
intensity: 1_000.0,
range: LIGHT_RANGE,
color: Color::PURPLE,
radius: 1.0,
..Default::default()
};
commands.insert_resource(AmbientLight {
color: Color::WHITE,
brightness: 0.32,
});
// east light
commands
.spawn_bundle(PointLightBundle {
transform: Transform::from_xyz(LIGHT_DIST, 0.0, 0.0),
point_light: purple_light,
..Default::default()
})
.with_children(|builder| {
builder.spawn_bundle(PbrBundle {
mesh: meshes.add(Mesh::from(shape::UVSphere {
radius: 10.0,
..Default::default()
})),
material: materials.add(StandardMaterial {
base_color: Color::PURPLE,
emissive: Color::rgba_linear(50.0, 0.0, 50.0, 0.0),
..Default::default()
}),
..Default::default()
});
})
.insert(Animate);
// west light
commands
.spawn_bundle(PointLightBundle {
transform: Transform::from_xyz(-LIGHT_DIST, 0.0, 0.0),
point_light: purple_light,
..Default::default()
})
.with_children(|builder| {
builder.spawn_bundle(PbrBundle {
mesh: meshes.add(Mesh::from(shape::UVSphere {
radius: 10.0,
..Default::default()
})),
material: materials.add(StandardMaterial {
base_color: Color::PURPLE,
emissive: Color::rgba_linear(50.0, 0.0, 50.0, 0.0),
..Default::default()
}),
..Default::default()
});
})
.insert(Animate);
// north light
commands
.spawn_bundle(PointLightBundle {
transform: Transform::from_xyz(0.0, 0.0, LIGHT_DIST),
point_light: purple_light,
..Default::default()
})
.with_children(|builder| {
builder.spawn_bundle(PbrBundle {
mesh: meshes.add(Mesh::from(shape::UVSphere {
radius: 10.0,
..Default::default()
})),
material: materials.add(StandardMaterial {
base_color: Color::PURPLE,
emissive: Color::rgba_linear(50.0, 0.0, 50.0, 0.0),
..Default::default()
}),
..Default::default()
});
})
.insert(Animate);
// south light
commands
.spawn_bundle(PointLightBundle {
transform: Transform::from_xyz(0.0, 0.0, -LIGHT_DIST),
point_light: purple_light,
..Default::default()
})
.with_children(|builder| {
builder.spawn_bundle(PbrBundle {
mesh: meshes.add(Mesh::from(shape::UVSphere {
radius: 10.0,
..Default::default()
})),
material: materials.add(StandardMaterial {
base_color: Color::PURPLE,
emissive: Color::rgba_linear(50.0, 0.0, 50.0, 0.0),
..Default::default()
}),
..Default::default()
});
})
.insert(Animate);
// up light
commands
.spawn_bundle(PointLightBundle {
transform: Transform::from_xyz(0.0, LIGHT_DIST, 0.0),
point_light: red_light,
..Default::default()
})
.with_children(|builder| {
builder.spawn_bundle(PbrBundle {
mesh: meshes.add(Mesh::from(shape::Icosphere {
radius: 10.0,
subdivisions: 2,
})),
material: materials.add(StandardMaterial {
base_color: Color::RED,
emissive: Color::rgba_linear(100.0, 0.0, 0.0, 0.0),
..Default::default()
}),
..Default::default()
});
});
// down light
commands
.spawn_bundle(PointLightBundle {
transform: Transform::from_xyz(0.0, -LIGHT_DIST, 0.0),
point_light: blue_light,
..Default::default()
})
.with_children(|builder| {
builder.spawn_bundle(PbrBundle {
mesh: meshes.add(Mesh::from(shape::Icosphere {
radius: 10.0,
subdivisions: 2,
})),
material: materials.add(StandardMaterial {
base_color: Color::BLUE,
emissive: Color::rgba_linear(0.0, 0.0, 100.0, 0.0),
..Default::default()
}),
..Default::default()
});
});
}
fn animate_lights(
time: Res<Time>,
mut query: Query<&mut Transform, (With<PointLight>, With<Animate>)>,
) {
let dt = time.delta_seconds();
for mut transform in query.iter_mut() {
let translation = &transform.translation;
let x = translation.x;
let y = translation.y;
let z = if translation.z.abs() < 0.1 {
translation.z + 0.15
} else {
translation.z
};
let rads = 10.0f32.to_radians();
let anim_rate = rads * dt;
let theta = z.atan2(x) + anim_rate;
let x_new = LIGHT_DIST * theta.cos();
let z_new = LIGHT_DIST * theta.sin();
*transform = Transform::from_xyz(x_new, y, z_new);
}
}

View File

@ -1,247 +1,33 @@
use bevy::prelude::*; use bevy::prelude::*;
use cyber_rider::flycam::{MovementSettings, PlayerPlugin, PLANET_RADIUS}; use cyber_rider::{
use heron::prelude::*; camera::CyberCamPlugin,
disable_mouse_trap,
geometry::CyberGeomPlugin,
input::CyberInputPlugin,
lights::CyberSpaceLightsPlugin,
physics::{CyberPhysicsPlugin, MovementSettings},
ui::CyberUIPlugin,
};
const LIGHT_RANGE: f32 = PLANET_RADIUS * 0.6; const MOVEMENT_SETTINGS: MovementSettings = MovementSettings {
const LIGHT_DIST: f32 = PLANET_RADIUS * 1.2; sensitivity: 0.3, // default: 1.0
accel: 20.0, // default: 40.0
drag: 0.0001, // default: 0.0005
gravity: 10.0, // default: 10.0
};
fn main() { fn main() {
App::new() App::new()
.insert_resource(Msaa { samples: 4 }) .insert_resource(Msaa { samples: 4 })
.add_plugins(DefaultPlugins) .add_plugins(DefaultPlugins)
.add_plugin(PlayerPlugin) .add_plugin(CyberGeomPlugin)
.add_plugin(PhysicsPlugin::default()) .add_plugin(CyberInputPlugin)
.insert_resource(MovementSettings { .add_plugin(CyberPhysicsPlugin)
sensitivity: 0.3, // default: 1.0 .insert_resource(MOVEMENT_SETTINGS)
accel: 20.0, // default: 40.0 .add_plugin(CyberCamPlugin)
drag: 0.01, // default: 0.0005 .add_plugin(CyberSpaceLightsPlugin)
gravity: 10.0, // default: 10.0 .add_plugin(CyberUIPlugin)
}) .add_startup_system(disable_mouse_trap)
.add_startup_system(setup.label("world"))
.add_startup_system(disable_cursor.after("world"))
.add_system(animate_lights)
.add_system(bevy::input::system::exit_on_esc_system) .add_system(bevy::input::system::exit_on_esc_system)
.run(); .run();
} }
fn disable_cursor(mut windows: ResMut<Windows>) {
let window = windows.get_primary_mut().unwrap();
window.set_cursor_lock_mode(false);
window.set_cursor_visibility(true);
}
#[derive(Component)]
struct Animate;
fn setup(
mut commands: Commands,
mut meshes: ResMut<Assets<Mesh>>,
mut materials: ResMut<Assets<StandardMaterial>>,
) {
let red_light = PointLight {
intensity: 1_000.0,
range: LIGHT_RANGE,
color: Color::RED,
radius: 10.0,
..Default::default()
};
let blue_light = PointLight {
intensity: 1_000.0,
range: LIGHT_RANGE,
color: Color::BLUE,
radius: 10.0,
..Default::default()
};
let purple_light = PointLight {
intensity: 1_000.0,
range: LIGHT_RANGE,
color: Color::PURPLE,
radius: 10.0,
..Default::default()
};
commands.insert_resource(AmbientLight {
color: Color::WHITE,
brightness: 0.32,
});
// world
commands
.spawn_bundle(PbrBundle {
mesh: meshes.add(Mesh::from(shape::Icosphere {
radius: PLANET_RADIUS,
subdivisions: 6,
})),
material: materials.add(StandardMaterial {
base_color: Color::GRAY,
metallic: 0.7,
perceptual_roughness: 0.5,
..Default::default()
}),
..Default::default()
})
.insert(RigidBody::Static)
.insert(CollisionShape::Sphere {
radius: PLANET_RADIUS,
});
// east light
commands
.spawn_bundle(PointLightBundle {
transform: Transform::from_xyz(LIGHT_DIST, 0.0, 0.0),
point_light: purple_light,
..Default::default()
})
.with_children(|builder| {
builder.spawn_bundle(PbrBundle {
mesh: meshes.add(Mesh::from(shape::UVSphere {
radius: 10.0,
..Default::default()
})),
material: materials.add(StandardMaterial {
base_color: Color::PURPLE,
emissive: Color::rgba_linear(50.0, 0.0, 50.0, 0.0),
..Default::default()
}),
..Default::default()
});
})
.insert(Animate);
// west light
commands
.spawn_bundle(PointLightBundle {
transform: Transform::from_xyz(-LIGHT_DIST, 0.0, 0.0),
point_light: purple_light,
..Default::default()
})
.with_children(|builder| {
builder.spawn_bundle(PbrBundle {
mesh: meshes.add(Mesh::from(shape::UVSphere {
radius: 10.0,
..Default::default()
})),
material: materials.add(StandardMaterial {
base_color: Color::PURPLE,
emissive: Color::rgba_linear(50.0, 0.0, 50.0, 0.0),
..Default::default()
}),
..Default::default()
});
})
.insert(Animate);
// north light
commands
.spawn_bundle(PointLightBundle {
transform: Transform::from_xyz(0.0, 0.0, LIGHT_DIST),
point_light: purple_light,
..Default::default()
})
.with_children(|builder| {
builder.spawn_bundle(PbrBundle {
mesh: meshes.add(Mesh::from(shape::UVSphere {
radius: 10.0,
..Default::default()
})),
material: materials.add(StandardMaterial {
base_color: Color::PURPLE,
emissive: Color::rgba_linear(50.0, 0.0, 50.0, 0.0),
..Default::default()
}),
..Default::default()
});
})
.insert(Animate);
// south light
commands
.spawn_bundle(PointLightBundle {
transform: Transform::from_xyz(0.0, 0.0, -LIGHT_DIST),
point_light: purple_light,
..Default::default()
})
.with_children(|builder| {
builder.spawn_bundle(PbrBundle {
mesh: meshes.add(Mesh::from(shape::UVSphere {
radius: 10.0,
..Default::default()
})),
material: materials.add(StandardMaterial {
base_color: Color::PURPLE,
emissive: Color::rgba_linear(50.0, 0.0, 50.0, 0.0),
..Default::default()
}),
..Default::default()
});
})
.insert(Animate);
// up light
commands
.spawn_bundle(PointLightBundle {
transform: Transform::from_xyz(0.0, LIGHT_DIST, 0.0),
point_light: red_light,
..Default::default()
})
.with_children(|builder| {
builder.spawn_bundle(PbrBundle {
mesh: meshes.add(Mesh::from(shape::Icosphere {
radius: 10.0,
subdivisions: 2,
})),
material: materials.add(StandardMaterial {
base_color: Color::RED,
emissive: Color::rgba_linear(100.0, 0.0, 0.0, 0.0),
..Default::default()
}),
..Default::default()
});
});
// down light
commands
.spawn_bundle(PointLightBundle {
transform: Transform::from_xyz(0.0, -LIGHT_DIST, 0.0),
point_light: blue_light,
..Default::default()
})
.with_children(|builder| {
builder.spawn_bundle(PbrBundle {
mesh: meshes.add(Mesh::from(shape::Icosphere {
radius: 10.0,
subdivisions: 2,
})),
material: materials.add(StandardMaterial {
base_color: Color::BLUE,
emissive: Color::rgba_linear(0.0, 0.0, 100.0, 0.0),
..Default::default()
}),
..Default::default()
});
});
}
fn animate_lights(
time: Res<Time>,
mut query: Query<&mut Transform, (With<PointLight>, With<Animate>)>,
) {
let dt = time.delta_seconds();
for mut transform in query.iter_mut() {
let translation = &transform.translation;
let x = translation.x;
let y = translation.y;
let z = if translation.z.abs() < 0.1 {
translation.z + 0.15
} else {
translation.z
};
// 10 degrees == 0.174533 radians
let anim_rate = 0.174533 * dt;
let theta = z.atan2(x) + anim_rate;
let x_new = LIGHT_DIST * theta.cos();
let z_new = LIGHT_DIST * theta.sin();
*transform = Transform::from_xyz(x_new, y, z_new);
}
}

161
src/physics.rs Normal file
View File

@ -0,0 +1,161 @@
use bevy::prelude::*;
use heron::prelude::*;
use crate::{geometry::CyberBike, input::InputState};
/// Mouse sensitivity and movement speed
pub struct MovementSettings {
pub sensitivity: f32,
pub accel: f32,
pub drag: f32,
pub gravity: f32,
}
impl Default for MovementSettings {
fn default() -> Self {
Self {
sensitivity: 1.0,
accel: 40.,
drag: 0.0005,
gravity: 10.0,
}
}
}
#[derive(Component, Default)]
pub(crate) struct PlayerState {
pub velocity: Vec3,
pub colliding: bool,
}
fn falling_cat(time: Res<Time>, mut bike_query: Query<(&mut Transform, &CyberBike)>) {
let dt = time.delta_seconds();
let (mut bike_xform, _) = bike_query.single_mut();
let up = bike_xform.translation.normalize();
let cam_up = bike_xform.up();
let cos = up.dot(cam_up);
let theta = cos.acos();
let rate = if !theta.is_normal() {
0.0
} else if theta.is_sign_negative() {
-0.4
} else {
0.4
} * dt;
let angle = if rate.is_sign_negative() {
rate.max(theta)
} else {
rate.min(theta)
};
let rot = Quat::from_axis_angle(cam_up.cross(up).normalize(), angle);
if rot.is_finite() && theta.abs() > 0.0085 {
bike_xform.rotate(rot);
}
}
fn apply_velocity(
time: Res<Time>,
mut bike_query: Query<(&mut Transform, &PlayerState, &CyberBike)>,
) {
let dt = time.delta_seconds();
let (mut bike_xform, player_state, _) = bike_query.single_mut();
if player_state.velocity.is_finite() {
bike_xform.translation += player_state.velocity * dt;
}
}
fn update_player_vel(
time: Res<Time>,
settings: Res<MovementSettings>,
input: Res<InputState>,
mut query: Query<(&Transform, &mut PlayerState, &CyberBike)>,
) {
let dt = time.delta_seconds();
let (xform, mut pstate, _) = query.single_mut();
// first gravity
let down = -xform.translation.normalize();
let dvel = down * settings.gravity * dt;
let mut vel = if pstate.velocity.is_finite() {
pstate.velocity + dvel
} else {
dvel
};
// thrust or brake
let accel = xform.forward() * input.throttle * dt * settings.accel;
if pstate.velocity.is_finite() {
vel += accel;
} else {
vel = accel;
}
// brake
if input.brake {
let s = vel.length_squared();
if s < 0.05 {
vel = Vec3::ZERO;
} else {
vel -= vel.normalize() * settings.accel * dt;
}
}
// drag
let v2 = vel.length_squared().min(100_000.0);
if v2 < 0.05 {
vel = Vec3::ZERO;
} else {
let drag = vel * settings.drag * v2 * dt;
vel -= drag;
}
pstate.velocity = vel;
}
fn collision_detection(
mut events: EventReader<CollisionEvent>,
mut query: Query<&mut PlayerState>,
) {
let mut pstate = query.single_mut();
for event in events.iter() {
if let CollisionEvent::Started(_, _) = event {
pstate.colliding = true;
} else {
pstate.colliding = false;
}
}
}
fn collision_reaction(mut query: Query<(&mut PlayerState, &Transform)>) {
let (mut pstate, xform) = query.single_mut();
let down = -xform.translation.normalize();
// now see if we're currently colliding
if pstate.colliding {
let vel = pstate.velocity;
let dvel = down * vel.dot(down) * 1.02;
pstate.velocity -= dvel;
}
}
pub struct CyberPhysicsPlugin;
impl Plugin for CyberPhysicsPlugin {
fn build(&self, app: &mut App) {
app.init_resource::<PlayerState>()
.init_resource::<MovementSettings>()
.add_plugin(PhysicsPlugin::default())
.add_system(collision_detection)
.add_system(collision_reaction)
.add_system(falling_cat)
.add_system(update_player_vel)
.add_system(apply_velocity);
}
}

47
src/ui.rs Normal file
View File

@ -0,0 +1,47 @@
use bevy::prelude::*;
use crate::physics::PlayerState;
#[derive(Component)]
struct UpText;
fn setup_ui(mut commands: Commands, asset_server: Res<AssetServer>) {
commands.spawn_bundle(UiCameraBundle::default());
commands
.spawn_bundle(TextBundle {
style: Style {
align_self: AlignSelf::FlexEnd,
..Default::default()
},
// Use `Text` directly
text: Text {
// Construct a `Vec` of `TextSection`s
sections: vec![TextSection {
value: "".to_string(),
style: TextStyle {
font: asset_server.load("fonts/FiraMono-Medium.ttf"),
font_size: 40.0,
color: Color::GOLD,
},
}],
..Default::default()
},
..Default::default()
})
.insert(UpText);
}
fn update_ui(pstate_query: Query<&PlayerState>, mut text_query: Query<&mut Text, With<UpText>>) {
let mut text = text_query.single_mut();
let pstate = pstate_query.single();
text.sections[0].value = format!("{:.2}", pstate.velocity.length());
}
pub struct CyberUIPlugin;
impl Plugin for CyberUIPlugin {
fn build(&self, app: &mut App) {
app.add_startup_system(setup_ui).add_system(update_ui);
}
}