nebkor/cyber_rider
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

ready to enable input

Browse source
This commit is contained in:
Joe Ardent 2024-07-25 15:49:10 -07:00
parent 85fe12bd3f
commit ecfa9b5864
10 changed files with 165 additions and 283 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
src/action/components.rs
View file

@ -37,7 +37,7 @@ impl Default for MovementSettings {
fn default() -> Self {
Self {
accel: 20.0,
gravity: 4.8,
gravity: 9.8,
}
}
}
@ -53,9 +53,9 @@ pub struct CatControllerSettings {
impl Default for CatControllerSettings {
fn default() -> Self {
Self {
kp: 80.0,
kp: 1200.0,
kd: 10.0,
ki: 0.4,
ki: 50.0,
}
}
}

16
src/action/mod.rs
View file

@ -1,6 +1,6 @@
use avian3d::prelude::{PhysicsPlugins, SubstepCount};
use bevy::{
app::Update,
app::FixedUpdate,
diagnostic::FrameTimeDiagnosticsPlugin,
ecs::reflect::ReflectResource,
prelude::{App, IntoSystemConfigs, Plugin, Resource},
@ -29,18 +29,10 @@ impl Plugin for CyberActionPlugin {
.register_type::<CyberLean>()
.register_type::<CatControllerSettings>()
.add_plugins((PhysicsPlugins::default(), FrameTimeDiagnosticsPlugin))
.insert_resource(SubstepCount(6))
.insert_resource(SubstepCount(12))
.add_systems(
Update,
(
set_gravity,
clear_forces,
calculate_lean,
apply_lean,
//#[cfg(feature = "inspector")]
debug_bodies,
)
.chain(),
FixedUpdate,
(set_gravity, calculate_lean, apply_lean).chain(),
);
}
}

152
src/action/systems.rs
View file

@ -1,18 +1,16 @@
use std::f32::consts::{FRAC_PI_3, FRAC_PI_4};
use avian3d::{
collision::Collisions,
dynamics::solver::xpbd::AngularConstraint,
prelude::{
ColliderMassProperties, Collision, ExternalForce, ExternalTorque, Gravity, LinearVelocity,
PrismaticJoint, RigidBodyQuery,
},
prelude::{ExternalTorque, FixedJoint, Gravity, LinearVelocity, RigidBodyQuery},
};
use bevy::prelude::{EventReader, Quat, Query, Res, ResMut, Time, Transform, Vec3, With, Without};
#[cfg(feature = "inspector")]
use bevy::prelude::Gizmos;
use bevy::prelude::{Quat, Query, Res, ResMut, Time, Transform, Vec3, With, Without};
use super::{CatControllerSettings, CatControllerState, CyberLean, MovementSettings};
use crate::{
bike::{CyberBikeBody, CyberFork, CyberSpring, CyberSteering, CyberWheel, WheelConfig},
bike::{CyberBikeBody, CyberFork, CyberSteering, CyberWheel},
input::InputState,
};
@ -39,7 +37,6 @@ fn rotate_point(pt: &Vec3, rot: &Quat) -> Vec3 {
/// The gravity vector points from the cyberbike to the center of the planet.
pub(super) fn set_gravity(
xform: Query<&Transform, With<CyberBikeBody>>,
settings: Res<MovementSettings>,
mut gravity: ResMut<Gravity>,
) {
@ -47,42 +44,6 @@ pub(super) fn set_gravity(
*gravity = Gravity(xform.translation.normalize() * -settings.gravity);
}
pub(super) fn clear_forces(
mut forces: Query<(Option<&mut ExternalForce>, Option<&mut ExternalTorque>)>,
) {
for (force, torque) in forces.iter_mut() {
if let Some(mut force) = force {
force.clear();
}
if let Some(mut torque) = torque {
torque.clear();
}
}
}
pub(super) fn suspension(
movment_settings: Res<MovementSettings>,
wheel_config: Res<WheelConfig>,
time: Res<Time>,
mass: Query<&ColliderMassProperties, With<CyberBikeBody>>,
mut axels: Query<(&mut ExternalForce, &CyberSpring, &Transform)>,
) {
let mass = if let Ok(mass) = mass.get_single() {
mass.mass.0
} else {
1.0
};
let dt = time.delta_seconds();
let gravity = movment_settings.gravity;
let mag = -wheel_config.stiffness * mass * gravity * dt;
for (mut force, spring, xform) in axels.iter_mut() {
let spring = mag * spring.0;
let spring = xform.translation + spring;
bevy::log::info!("suspension force: {spring:?}");
let _ = force.apply_force(spring);
}
}
/// The desired lean angle, given steering input and speed.
pub(super) fn calculate_lean(
bike_state: Query<(&LinearVelocity, &Transform), With<CyberBikeBody>>,
@ -102,7 +63,7 @@ pub(super) fn calculate_lean(
let v2_r = v_squared / radius;
let tan_theta = (v2_r / gravity).clamp(-FRAC_PI_3, FRAC_PI_3);
if tan_theta.is_finite() && !tan_theta.is_subnormal() {
if tan_theta.is_normal() {
lean.lean = tan_theta.atan().clamp(-FRAC_PI_4, FRAC_PI_4);
} else {
lean.lean = 0.0;
@ -115,6 +76,7 @@ pub(super) fn apply_lean(
time: Res<Time>,
settings: Res<CatControllerSettings>,
lean: Res<CyberLean>,
#[cfg(feature = "inspector")] mut gizmos: Gizmos,
) {
let (xform, mut torque, mut control_vars) = bike_query.single_mut();
let world_up = xform.translation.normalize();
@ -131,8 +93,15 @@ pub(super) fn apply_lean(
let (derivative, integral) = control_vars.update_roll(roll_error, time.delta_seconds());
let mag =
(settings.kp * roll_error) + (settings.ki * integral) + (settings.kd * derivative);
if mag.is_finite() {
torque.apply_torque(*xform.back() * mag);
if mag.is_normal() {
let tork = mag * *xform.back();
torque.apply_torque(tork);
#[cfg(feature = "inspector")]
gizmos.arrow(
xform.translation + Vec3::Y,
xform.translation + tork + Vec3::Y,
bevy::color::Color::WHITE,
);
}
}
}
@ -142,94 +111,35 @@ pub(super) fn apply_inputs(
settings: Res<MovementSettings>,
input: Res<InputState>,
time: Res<Time>,
fork: Query<&PrismaticJoint, With<CyberFork>>,
mut axle: Query<(RigidBodyQuery, &Transform), With<CyberSteering>>,
mut braking_query: Query<&mut ExternalTorque, With<CyberWheel>>,
mut body_query: Query<
(
RigidBodyQuery,
&Transform,
&ColliderMassProperties,
&mut ExternalForce,
),
(With<CyberBikeBody>, Without<CyberSteering>),
>,
fork: Query<(&FixedJoint, &CyberFork), With<CyberSteering>>,
mut hub: Query<(RigidBodyQuery, &Transform), With<CyberSteering>>,
mut braking_query: Query<(&Transform, &mut ExternalTorque), With<CyberWheel>>,
mut body_query: Query<RigidBodyQuery, (With<CyberBikeBody>, Without<CyberSteering>)>,
) {
let Ok((mut bike, xform, mass, mut forces)) = body_query.get_single_mut() else {
let Ok(mut bike) = body_query.get_single_mut() else {
bevy::log::debug!("no bike body found");
return;
};
let dt = time.delta_seconds();
// thrust
let thrust = xform.forward() * input.throttle * settings.accel;
let point = xform.translation + *xform.back();
//let _ = *forces.apply_force_at_point(dt * thrust, point,
// mass.center_of_mass.0);
// brake + thrust
for mut motor in braking_query.iter_mut() {
let factor = if input.brake {
500.00
} else {
input.throttle * settings.accel
};
let speed = if input.brake { 0.0 } else { -70.0 };
let target = dt * factor * speed;
let torque = target * Vec3::X;
for (xform, mut motor) in braking_query.iter_mut() {
let factor = input.throttle * settings.accel;
let target = dt * factor;
let torque = target * *xform.right();
motor.apply_torque(torque);
}
// steering
let _angle = yaw_to_angle(input.yaw);
let (mut axle, xform) = axle.single_mut();
let (mut axle, xform) = hub.single_mut();
let cur_rot = xform.rotation;
let fork = fork.single();
let axis = fork.free_axis.normalize();
let new = Quat::from_axis_angle(axis, _angle);
let (fork, CyberFork(axis)) = fork.single();
let new = Quat::from_axis_angle(*axis, _angle);
let diff = (new - cur_rot).to_scaled_axis();
let mut compliance = 1.0;
let mut lagrange = 1.0;
fork.align_orientation(&mut axle, &mut bike, diff, &mut compliance, 1.0, dt);
fork.align_orientation(&mut axle, &mut bike, diff, &mut lagrange, 0.0, dt);
}
//#[cfg(feature = "inspector")]
mod inspector {
use bevy::prelude::Entity;
use super::*;
pub(crate) fn debug_bodies(
bodies: Query<(Entity, RigidBodyQuery)>,
mut collisions: EventReader<Collision>,
) {
let bodies: Vec<_> = bodies.iter().collect();
for i in 0..(bodies.len()) {
let (ent, ref rb) = bodies[i];
let cur_pos = rb.current_position();
let mut max = 0.0f32;
let mut min = f32::MAX;
for j in 0..(bodies.len()) {
if j == i {
continue;
}
let (_, ref other) = bodies[j];
let dist = (cur_pos - other.current_position()).length();
max = max.max(dist);
min = min.min(dist);
}
let line = format!("{ent:?} at {cur_pos:?} -- min: {min}, max: {max}");
bevy::log::info!(line);
}
for Collision(contacts) in collisions.read() {
bevy::log::info!(
"Entities {:?} and {:?} are colliding",
contacts.entity1,
contacts.entity2,
);
}
}
}
//#[cfg(feature = "inspector")]
pub(super) use inspector::debug_bodies;

7
src/bike/body.rs
View file

@ -1,5 +1,6 @@
use avian3d::prelude::*;
use bevy::{
core::Name,
prelude::{AssetServer, BuildChildren, Commands, Quat, Res, SpatialBundle, Transform, Vec3},
scene::SceneBundle,
};
@ -42,6 +43,7 @@ pub(super) fn spawn_cyberbike(
let bike = commands
.spawn(SpatialBundle::from_transform(xform))
.insert((
Name::new("bike body"),
RigidBody::Dynamic,
body_collider,
bike_collision_group,
@ -50,13 +52,12 @@ pub(super) fn spawn_cyberbike(
SleepingDisabled,
CyberBikeBody,
CatControllerState::default(),
ColliderDensity(0.06),
ColliderDensity(20.0),
LinearDamping(0.1),
AngularDamping(2.0),
LinearVelocity::ZERO,
AngularVelocity::ZERO,
ExternalForce::ZERO,
ExternalTorque::ZERO,
ExternalTorque::ZERO.with_persistence(false),
))
.with_children(|rider| {
rider.spawn(SceneBundle {

17
src/bike/components.rs
View file

@ -14,10 +14,7 @@ pub struct CyberSteering;
pub struct CyberWheel;
#[derive(Clone, Debug, Component)]
pub struct CyberSpring(pub Vec3);
#[derive(Clone, Debug, Component)]
pub struct CyberFork;
pub struct CyberFork(pub Vec3);
#[derive(Resource, Reflect)]
#[reflect(Resource)]
@ -40,15 +37,15 @@ impl Default for WheelConfig {
Self {
front_forward: 0.8,
rear_back: 1.0,
y: -0.1,
y: -0.5,
limits: [-0.5, 0.1],
stiffness: 3.0,
damping: 8.0,
radius: 0.25,
thickness: 0.11,
friction: 1.2,
restitution: 0.95,
density: 0.05,
radius: 0.40,
thickness: 0.15,
friction: 0.9,
restitution: 0.5,
density: 30.0,
}
}
}

202
src/bike/wheels.rs
View file

@ -1,7 +1,7 @@
use avian3d::prelude::*;
use bevy::prelude::{Torus as Tire, *};
use bevy::prelude::*;
use super::{CyberFork, CyberSpring, CyberSteering, CyberWheel, Meshterial, WheelConfig};
use super::{CyberFork, CyberSteering, CyberWheel, Meshterial, WheelConfig};
use crate::ColliderGroups;
pub fn spawn_wheels(
@ -11,21 +11,11 @@ pub fn spawn_wheels(
conf: &WheelConfig,
meshterials: &mut Meshterial,
) {
let wheels_collision_group =
CollisionLayers::new(ColliderGroups::Wheels, ColliderGroups::Planet);
let wheel_y = conf.y;
let not_sleeping = SleepingDisabled;
let ccd = SweptCcd::LINEAR.include_dynamic(false);
let limits = conf.limits;
let (meshes, materials) = meshterials;
let rake_vec: Vec3 = Vec3::new(0.0, 1.0, 0.57).normalize(); // about 30 degrees of rake
let friction = Friction {
dynamic_coefficient: conf.friction,
static_coefficient: conf.friction,
combine_rule: CoefficientCombine::Average,
};
let mut wheel_poses = Vec::with_capacity(2);
// front
@ -44,105 +34,34 @@ pub fn spawn_wheels(
wheel_poses.push((offset, None));
}
let (mesh, collider) = gen_tire(conf);
for (offset, steering) in wheel_poses {
let (mesh, collider) = gen_tires(conf);
let hub = wheels_helper(
commands,
meshes,
materials,
offset + xform.translation,
mesh.clone(),
collider.clone(),
conf,
);
let material = StandardMaterial {
base_color: Color::linear_rgba(0.01, 0.01, 0.01, 1.0),
alpha_mode: AlphaMode::Opaque,
perceptual_roughness: 0.5,
..Default::default()
};
let pbr_bundle = PbrBundle {
material: materials.add(material),
mesh: meshes.add(mesh),
..Default::default()
};
let suspension_axis = if steering.is_some() {
rake_vec
} else {
Vec3::Y
};
let wheel = commands
.spawn(pbr_bundle)
.insert((
collider,
ccd,
not_sleeping,
wheels_collision_group,
friction,
CyberWheel,
ExternalForce::default(),
Restitution::new(conf.restitution),
SpatialBundle::default(),
RigidBody::Dynamic,
ColliderDensity(0.1),
CollisionMargin(0.1),
AngularVelocity::ZERO,
ExternalTorque::ZERO,
))
.insert(SpatialBundle::from_transform(
xform.with_translation(xform.translation + offset),
))
let fork = commands
.spawn(FixedJoint::new(hub, bike).with_local_anchor_2(offset))
.id();
let spring = CyberSpring(suspension_axis);
let axle = if let Some(steering) = steering {
commands.spawn((
RigidBody::Dynamic,
ExternalForce::ZERO,
steering,
spring,
MassPropertiesBundle::new_computed(&Collider::sphere(0.1), 0.1),
))
} else {
commands.spawn((
RigidBody::Dynamic,
ExternalForce::ZERO,
spring,
MassPropertiesBundle::new_computed(&Collider::sphere(0.1), 0.1),
))
if let Some(steering) = steering {
let axis = CyberFork(rake_vec);
commands.entity(fork).insert((steering, axis));
commands.entity(hub).insert(steering);
}
.insert(SpatialBundle::from_transform(
xform.with_translation(xform.translation + offset),
))
.id();
bevy::log::info!("axle RB: {axle:?}");
let axel_joint = RevoluteJoint::new(axle, wheel).with_aligned_axis(Vec3::NEG_X);
commands.spawn(axel_joint);
// suspension and steering:
if steering.is_some() {
let joint = PrismaticJoint::new(axle, bike)
.with_free_axis(suspension_axis)
.with_local_anchor_1(Vec3::new(0.0, 0.0, 0.1))
.with_local_anchor_2(offset)
.with_limits(limits[0], limits[1]);
commands.spawn((joint, CyberFork));
} else {
let joint = PrismaticJoint::new(axle, bike)
.with_free_axis(suspension_axis)
.with_local_anchor_2(offset)
.with_limits(limits[0], limits[1]);
commands.spawn(joint);
};
}
}
// do mesh shit
fn gen_tires(conf: &WheelConfig) -> (Mesh, Collider) {
let wheel_rad = conf.radius;
let tire_thickness = conf.thickness;
let tire = Tire {
minor_radius: tire_thickness,
major_radius: wheel_rad,
};
let mut mesh = Mesh::from(tire);
let tire_verts = mesh
fn gen_tire(conf: &WheelConfig) -> (Mesh, Collider) {
let outer_radius = conf.radius;
let inner_radius = conf.radius - conf.thickness;
let mut tire_mesh: Mesh = Torus::new(inner_radius, outer_radius).into();
let tire_verts = tire_mesh
.attribute(Mesh::ATTRIBUTE_POSITION)
.unwrap()
.as_float3()
@ -156,15 +75,70 @@ fn gen_tires(conf: &WheelConfig) -> (Mesh, Collider) {
p.to_array()
})
.collect::<Vec<[f32; 3]>>();
mesh.remove_attribute(Mesh::ATTRIBUTE_POSITION);
mesh.insert_attribute(Mesh::ATTRIBUTE_POSITION, tire_verts);
tire_mesh.remove_attribute(Mesh::ATTRIBUTE_POSITION);
tire_mesh.insert_attribute(Mesh::ATTRIBUTE_POSITION, tire_verts);
let mut idxs = Vec::new();
let indices = mesh.indices().unwrap().iter().collect::<Vec<_>>();
for idx in indices.as_slice().chunks_exact(3) {
idxs.push([idx[0] as u32, idx[1] as u32, idx[2] as u32]);
}
let wheel_collider = Collider::trimesh_from_mesh(&mesh).unwrap();
let collider = Collider::convex_hull_from_mesh(&tire_mesh).unwrap();
(mesh, wheel_collider)
(tire_mesh, collider)
}
fn wheels_helper(
commands: &mut Commands,
meshes: &mut ResMut<Assets<Mesh>>,
materials: &mut ResMut<Assets<StandardMaterial>>,
position: Vec3,
tire_mesh: Mesh,
collider: Collider,
conf: &WheelConfig,
) -> Entity {
let wheel_material = &StandardMaterial {
base_color: Color::srgb(0.01, 0.01, 0.01),
alpha_mode: AlphaMode::Opaque,
perceptual_roughness: 0.5,
..Default::default()
};
let xform = Transform::from_translation(position);
let hub_mesh: Mesh = Sphere::new(0.1).into();
let hub = commands
.spawn((
Name::new("hub"),
RigidBody::Dynamic,
MassPropertiesBundle::new_computed(&Collider::sphere(0.1), 200.0),
PbrBundle {
mesh: meshes.add(hub_mesh),
material: materials.add(wheel_material.clone()),
transform: xform,
..Default::default()
},
))
.id();
let tire = commands
.spawn((
Name::new("tire"),
PbrBundle {
mesh: meshes.add(tire_mesh),
material: materials.add(wheel_material.clone()),
transform: xform,
..Default::default()
},
CyberWheel,
RigidBody::Dynamic,
collider,
Friction::new(conf.friction),
Restitution::new(conf.restitution),
ColliderDensity(conf.density),
CollisionLayers::new(ColliderGroups::Wheels, ColliderGroups::Planet),
ExternalTorque::ZERO.with_persistence(false),
CollisionMargin(0.05),
SweptCcd::NON_LINEAR,
))
.id();
// connect hubs and tires to make wheels
commands.spawn(RevoluteJoint::new(hub, tire).with_aligned_axis(Vec3::X));
hub
}

17
src/camera.rs
View file

@ -1,6 +1,6 @@
use bevy::prelude::*;
use crate::{bike::CyberBikeBody, input::InputState};
use crate::{bike::CyberBikeBody, input::InputState, ui::setup_ui};
// 85 degrees in radians
const MAX_PITCH: f32 = 1.48353;
@ -38,7 +38,7 @@ impl CyberCameras {
}
}
fn setup_cybercams(mut commands: Commands) {
fn setup_cybercams(mut commands: Commands, asset_server: Res<AssetServer>) {
let hero_projection = PerspectiveProjection {
fov: std::f32::consts::FRAC_PI_3,
..Default::default()
@ -55,6 +55,8 @@ fn setup_cybercams(mut commands: Commands) {
commands
.spawn(Camera3dBundle::default())
.insert(CyberCameras::Debug);
setup_ui(commands, asset_server, id);
}
fn follow_cyberbike(
@ -85,7 +87,7 @@ fn follow_cyberbike(
cam_xform.rotate(Quat::from_axis_angle(*axis, angle));
}
CyberCameras::Debug => {
let mut ncx = bike_xform.to_owned();
let mut ncx = Transform::from_translation(bike_xform.translation);
ncx.rotate(Quat::from_axis_angle(up, offset.rot.to_radians()));
ncx.translation += ncx.forward() * offset.dist;
ncx.translation += ncx.up() * offset.alt;
@ -98,12 +100,15 @@ fn follow_cyberbike(
fn update_active_camera(
state: Res<State<CyberCameras>>,
mut query: Query<(&mut Camera, &CyberCameras)>,
mut cameras: Query<(Entity, &mut Camera, &CyberCameras)>,
mut target: Query<&mut TargetCamera>,
) {
let mut target = target.single_mut();
// find the camera with the current state, set it as the ActiveCamera
query.iter_mut().for_each(|(mut cam, cyber)| {
if cyber.eq(&state.get()) {
cameras.iter_mut().for_each(|(ent, mut cam, cyber)| {
if cyber.eq(state.get()) {
cam.is_active = true;
*target = TargetCamera(ent);
} else {
cam.is_active = false;
}

8
src/lights.rs
View file

@ -2,7 +2,7 @@ use bevy::{pbr::CascadeShadowConfigBuilder, prelude::*};
use crate::planet::PLANET_RADIUS;
pub const LIGHT_RANGE: f32 = 90.0;
pub const LIGHT_RANGE: f32 = 900.0;
static BLUE: Color = Color::linear_rgb(0.0, 0.0, 1.0);
static PINK: Color = Color::linear_rgb(199.0 / 255.0, 21.0 / 255.0, 113.0 / 255.0);
@ -13,7 +13,7 @@ fn spawn_static_lights(
mut materials: ResMut<Assets<StandardMaterial>>,
) {
let pink_light = PointLight {
intensity: 1_00.0,
intensity: 1_000_000.0,
range: LIGHT_RANGE,
color: PINK,
radius: 1.0,
@ -22,7 +22,7 @@ fn spawn_static_lights(
};
let blue_light = PointLight {
intensity: 1_000.0,
intensity: 1_000_000.0,
range: LIGHT_RANGE,
color: BLUE,
radius: 1.0,
@ -32,7 +32,7 @@ fn spawn_static_lights(
commands.insert_resource(AmbientLight {
color: Color::WHITE,
brightness: 10_000.0,
brightness: 8_000.0,
});
let _cascade_shadow_config = CascadeShadowConfigBuilder {

6
src/planet.rs
View file

@ -25,8 +25,9 @@ fn spawn_planet(
let pcollide = (
shape,
Friction {
static_coefficient: 1.2,
..Default::default()
static_coefficient: 0.8,
dynamic_coefficient: 0.5,
combine_rule: CoefficientCombine::Average,
},
Restitution::new(0.8),
);
@ -136,7 +137,6 @@ fn gen_planet(radius: f32) -> (Mesh, Collider) {
}
}
dbg!(&colors.len());
mesh.insert_attribute(Mesh::ATTRIBUTE_COLOR, colors);
(mesh, collider)

17
src/ui.rs
View file

@ -1,9 +1,9 @@
use avian3d::prelude::LinearVelocity;
use bevy::{
app::{Startup, Update},
app::Update,
prelude::{
AlignSelf, App, AssetServer, Color, Commands, Component, Plugin, Query, Res, Style, Text,
TextBundle, TextSection, TextStyle, With,
AlignSelf, App, AssetServer, Color, Commands, Component, Entity, Plugin, Query, Res, Style,
Text, TextBundle, TextSection, TextStyle, With,
},
ui::TargetCamera,
};
@ -13,7 +13,11 @@ use crate::bike::CyberBikeBody;
#[derive(Component)]
struct UpText;
fn setup_ui(mut commands: Commands, asset_server: Res<AssetServer>) {
pub(crate) fn setup_ui(
mut commands: Commands,
asset_server: Res<AssetServer>,
target_camera: Entity,
) {
commands
.spawn(TextBundle {
style: Style {
@ -35,7 +39,7 @@ fn setup_ui(mut commands: Commands, asset_server: Res<AssetServer>) {
},
..Default::default()
})
.insert(UpText);
.insert((UpText, TargetCamera(target_camera)));
}
fn update_ui(
@ -52,7 +56,6 @@ pub struct CyberUIPlugin;
impl Plugin for CyberUIPlugin {
fn build(&self, app: &mut App) {
app.add_systems(Startup, setup_ui)
.add_systems(Update, update_ui);
app.add_systems(Update, update_ui);
}
}