335 lines
10 KiB
Rust
335 lines
10 KiB
Rust
use std::collections::HashMap;
|
|
|
|
use async_channel::bounded;
|
|
use bevy::{input::keyboard::Key, prelude::*, tasks::AsyncComputeTaskPool};
|
|
use rand::RngExt;
|
|
|
|
use super::{
|
|
BackgroundHandle, Buddies, GeomWithData, IndexChannel, IndexMessage, LookAt, Naybs, Positions,
|
|
RTree, RawMessage, RawPosChannel, Toid, Velocity,
|
|
};
|
|
|
|
// toid stuff
|
|
const SPEED: f32 = 6.0;
|
|
const SPEED_DIFF_RANGE: f32 = 0.2; // +/- 10%
|
|
const MAX_DELTA_V: f32 = std::f32::consts::PI * 1.5; // basically 360
|
|
// degrees/sec
|
|
|
|
// how far from origin before really wanting to come back
|
|
const RADIUS: f32 = 40.0;
|
|
|
|
// how close to try to stay to your buddies
|
|
const BUDDY_RADIUS: f32 = 10.0;
|
|
|
|
const MIN_ALTITUDE: f32 = 3.5;
|
|
|
|
pub fn setup_channels(mut commands: Commands) {
|
|
let (raw_tx, raw_rx) = bounded(1);
|
|
commands.insert_resource(RawPosChannel {
|
|
tx: raw_tx,
|
|
rx: Some(raw_rx),
|
|
});
|
|
|
|
let (idx_tx, idx_rx) = bounded(1);
|
|
commands.insert_resource(IndexChannel {
|
|
tx: idx_tx,
|
|
rx: idx_rx,
|
|
});
|
|
}
|
|
|
|
pub fn update_naybs(
|
|
mut naybs: ResMut<Naybs>,
|
|
raw_chan: Res<RawPosChannel>,
|
|
positions: Res<Positions>,
|
|
idx_chan: Res<IndexChannel>,
|
|
) {
|
|
if let Ok(idx_msg) = idx_chan.rx.try_recv() {
|
|
naybs.index = idx_msg.index;
|
|
let _ = naybs.positions.insert(idx_msg.raw);
|
|
return;
|
|
}
|
|
|
|
if let Some(mut raw) = naybs.positions.take() {
|
|
for (i, (entity, pos)) in positions.iter().enumerate() {
|
|
raw[i] = (*pos, *entity);
|
|
}
|
|
|
|
if let Err(e) = raw_chan.tx.try_send(RawMessage(raw)) {
|
|
let RawMessage(raw) = e.into_inner();
|
|
let _ = naybs.positions.insert(raw);
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn init_naybs(positions: Res<Positions>, mut naybs: ResMut<Naybs>) {
|
|
let mut raw = Vec::with_capacity(positions.len());
|
|
for (entity, pos) in positions.iter() {
|
|
raw.push((*pos, *entity));
|
|
}
|
|
naybs.positions = Some(raw);
|
|
}
|
|
|
|
pub fn spawn_background(
|
|
mut raw_chan: ResMut<RawPosChannel>,
|
|
idx_chan: Res<IndexChannel>,
|
|
mut handle: ResMut<BackgroundHandle>,
|
|
) {
|
|
let pool = AsyncComputeTaskPool::get();
|
|
|
|
let raw_rx = raw_chan.rx.take().unwrap();
|
|
let idx_tx = idx_chan.tx.clone();
|
|
|
|
let task = pool.spawn(async move {
|
|
let tx = idx_tx;
|
|
let rx = raw_rx;
|
|
loop {
|
|
match rx.recv().await {
|
|
Ok(RawMessage(e_posns)) => {
|
|
let idx = RTree::bulk_load(
|
|
e_posns
|
|
.iter()
|
|
.map(|(p, e)| GeomWithData::new(p.to_array(), *e))
|
|
.collect(),
|
|
);
|
|
let msg = IndexMessage {
|
|
raw: e_posns,
|
|
index: idx,
|
|
};
|
|
if tx.send(msg).await.is_err() {
|
|
break;
|
|
};
|
|
}
|
|
Err(_) => break,
|
|
}
|
|
}
|
|
});
|
|
|
|
let _ = handle.0.insert(task);
|
|
}
|
|
|
|
pub fn turkey_time(
|
|
commands: &mut Commands,
|
|
r: &mut impl rand::prelude::Rng,
|
|
assets: &AssetServer,
|
|
positions: &mut HashMap<Entity, Vec3>,
|
|
) {
|
|
let speed_diff = r.random_range(-SPEED_DIFF_RANGE..=SPEED_DIFF_RANGE);
|
|
let speed = SPEED + (SPEED * speed_diff);
|
|
let vel = unit_vec(r) * speed;
|
|
let buddies = r.random_range(6..=8);
|
|
let x = r.random_range(-10.0..=10.0);
|
|
let z = r.random_range(-10.0..=10.0);
|
|
let y = r.random_range(MIN_ALTITUDE..=(MIN_ALTITUDE + 5.5));
|
|
|
|
let entity = commands
|
|
.spawn((
|
|
Velocity(vel),
|
|
Buddies::default(),
|
|
Toid { speed, buddies },
|
|
Transform::from_xyz(x, y, z),
|
|
Visibility::Visible,
|
|
))
|
|
.with_children(|t| {
|
|
t.spawn(WorldAssetRoot(
|
|
assets.load(GltfAssetLabel::Scene(0).from_asset("models/boid.glb")),
|
|
))
|
|
.insert(Transform::default())
|
|
//.insert(Visibility::Visible);
|
|
.insert(Transform::from_rotation(Quat::from_axis_angle(
|
|
Vec3::Y,
|
|
-std::f32::consts::FRAC_PI_2,
|
|
)));
|
|
})
|
|
.id();
|
|
|
|
positions.insert(entity, Vec3::new(x, y, z));
|
|
}
|
|
|
|
pub fn update_vel(
|
|
mut toids: Query<(&Transform, &mut Velocity, &Toid, &Buddies, Entity)>,
|
|
time: Res<Time>,
|
|
positions: Res<Positions>,
|
|
index: Res<Naybs>,
|
|
) {
|
|
let dt = time.delta_secs();
|
|
let max_delta = MAX_DELTA_V * dt;
|
|
for (xform, mut vel, toid, buddies, entity) in toids.iter_mut() {
|
|
let speed = toid.speed;
|
|
let mut dir = vel.normalize();
|
|
let pos = xform.translation;
|
|
let original_dir = dir;
|
|
|
|
// find buddies and orient; point more towards further-away buddies
|
|
for buddy in buddies.0.iter() {
|
|
let bp = positions.get(buddy).unwrap();
|
|
let bdir = *bp - pos;
|
|
let dist = bdir.length();
|
|
let rot = Quat::from_rotation_arc(dir, bdir.normalize());
|
|
let s = (dist / (BUDDY_RADIUS * 1.2)).min(1.0);
|
|
let rot = Quat::IDENTITY.slerp(rot, s);
|
|
dir = rot.mul_vec3(dir).normalize();
|
|
}
|
|
|
|
// avoid flying into neighbors
|
|
let min_dist = speed;
|
|
for neighbor in index
|
|
.index
|
|
.locate_within_distance(pos.to_array(), min_dist)
|
|
.filter(|n| n.data != entity)
|
|
{
|
|
let bp = Vec3::from_array(*neighbor.geom());
|
|
let bdir = pos - bp;
|
|
let dist = bdir.length();
|
|
let s = 1.0 - (dist / min_dist).min(1.0);
|
|
let rot = Quat::from_rotation_arc(dir, bdir.normalize());
|
|
let rot = Quat::IDENTITY.slerp(rot, s);
|
|
dir = rot.mul_vec3(dir).normalize();
|
|
}
|
|
|
|
// nudge toward origin if too far
|
|
{
|
|
let dist = pos.length();
|
|
let toward_origin = -pos.normalize();
|
|
let s = (dist / RADIUS).min(1.0);
|
|
let rot = Quat::from_rotation_arc(dir, toward_origin);
|
|
let rot = Quat::IDENTITY.slerp(rot, s);
|
|
dir = rot.mul_vec3(dir).normalize();
|
|
}
|
|
|
|
// nudge up if too low
|
|
if pos.y < MIN_ALTITUDE {
|
|
let dh = MIN_ALTITUDE - pos.y;
|
|
let s = (dh / MIN_ALTITUDE).min(1.0);
|
|
let rot = Quat::from_rotation_arc(dir, Vec3::Y);
|
|
let rot = Quat::IDENTITY.slerp(rot, s);
|
|
dir = rot.mul_vec3(dir).normalize();
|
|
}
|
|
|
|
// make sure velocity doesn't change too suddenly
|
|
let delta = dir.dot(original_dir).acos();
|
|
if delta > max_delta {
|
|
let s = max_delta / delta;
|
|
let rot = Quat::from_rotation_arc(original_dir, dir);
|
|
let rot = Quat::IDENTITY.slerp(rot, s);
|
|
dir = rot.mul_vec3(original_dir).normalize();
|
|
}
|
|
|
|
**vel = dir * speed;
|
|
}
|
|
}
|
|
|
|
pub fn update_pos(
|
|
mut toids: Query<(&mut Transform, &Velocity, Entity), With<Toid>>,
|
|
mut positions: ResMut<Positions>,
|
|
mut lookat: ResMut<LookAt>,
|
|
time: Res<Time>,
|
|
) {
|
|
let mut new_look = Vec3::ZERO;
|
|
let dt = time.delta_secs();
|
|
for (mut xform, vel, entity) in toids.iter_mut() {
|
|
let look_at = xform.translation + vel.0;
|
|
xform.translation += vel.0 * dt;
|
|
xform.look_at(look_at, Vec3::Y);
|
|
*positions.entry(entity).or_insert(Vec3::ZERO) = xform.translation;
|
|
new_look += xform.translation;
|
|
}
|
|
**lookat = new_look / positions.len() as f32;
|
|
}
|
|
|
|
pub fn update_buddies(
|
|
mut toids: Query<(&Transform, Entity, &Toid, &mut Buddies)>,
|
|
index: Res<Naybs>,
|
|
positions: Res<Positions>,
|
|
) {
|
|
let d2 = (BUDDY_RADIUS * 1.5).powi(2);
|
|
for (xform, entity, toid, mut buddies) in toids.iter_mut() {
|
|
let pos = xform.translation;
|
|
for buddy in buddies.clone().iter() {
|
|
let bp = positions[buddy];
|
|
let bd2 = (bp - pos).length_squared();
|
|
if bd2 > d2 {
|
|
buddies.remove(buddy);
|
|
}
|
|
}
|
|
|
|
if buddies.len() < toid.buddies {
|
|
let diff = toid.buddies - buddies.len();
|
|
for neighbor in index
|
|
.index
|
|
.nearest_neighbor_iter(pos.to_array())
|
|
.filter(|n| n.data != entity)
|
|
.take(diff)
|
|
{
|
|
buddies.insert(neighbor.data);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn update_gizmos(toids: Query<&Transform, With<Toid>>, mut gizmos: Gizmos) {
|
|
for toid in toids.iter() {
|
|
let pos = toid.translation;
|
|
let up = toid.up().as_vec3();
|
|
let forward = toid.forward().as_vec3();
|
|
let right = toid.right().as_vec3();
|
|
gizmos.ray(pos, pos + forward, Color::srgb(1., 0., 0.));
|
|
gizmos.ray(pos, pos + up, Color::srgb(0., 1., 0.));
|
|
gizmos.ray(pos, pos + right, Color::srgb(0., 0., 1.));
|
|
}
|
|
}
|
|
|
|
pub fn rotate_camera(
|
|
mut query: Query<&mut Transform, With<Camera>>,
|
|
keys: Res<ButtonInput<Key>>,
|
|
lookat: Res<LookAt>,
|
|
) {
|
|
let mut xform = query.single_mut().unwrap();
|
|
|
|
let forward = xform.forward().as_vec3() * 0.7;
|
|
let right = xform.right().as_vec3();
|
|
|
|
if keys.pressed(Key::ArrowRight) {
|
|
xform.translation += right;
|
|
}
|
|
if keys.pressed(Key::ArrowLeft) {
|
|
xform.translation -= right;
|
|
}
|
|
|
|
if keys.pressed(Key::ArrowUp) {
|
|
if keys.pressed(Key::Shift) {
|
|
xform.translation += Vec3::Y;
|
|
} else {
|
|
xform.translation += forward;
|
|
}
|
|
}
|
|
|
|
if keys.pressed(Key::ArrowDown) {
|
|
if keys.pressed(Key::Shift) {
|
|
xform.translation -= Vec3::Y;
|
|
} else {
|
|
xform.translation -= forward;
|
|
}
|
|
}
|
|
|
|
xform.look_at(**lookat, Vec3::Y);
|
|
}
|
|
|
|
//-************************************************************************
|
|
// util
|
|
//-************************************************************************
|
|
|
|
pub fn unit_vec(r: &mut impl rand::Rng) -> Vec3 {
|
|
let mut x1: f32 = 0.0;
|
|
let mut x2: f32 = 0.0;
|
|
let mut ssum = f32::MAX;
|
|
while ssum >= 1.0 {
|
|
x1 = r.random_range(-1.0..=1.0);
|
|
x2 = r.random_range(-1.0..=1.0);
|
|
ssum = x1.powi(2) + x2.powi(2);
|
|
}
|
|
let sqrt = (1.0 - ssum).sqrt();
|
|
let x = 2.0 * x1 * sqrt;
|
|
let y = 2.0 * x2 * sqrt;
|
|
let z = 1.0 - 2.0 * ssum;
|
|
Vec3::new(x, y, z).normalize()
|
|
}
|