cyber_rider/src/planet.rs

123 lines
3.3 KiB
Rust
Raw Normal View History

use bevy::{
2023-01-23 05:06:08 +00:00
prelude::{shape::Plane, *},
render::mesh::Indices,
};
use bevy_rapier3d::prelude::*;
use wgpu::PrimitiveTopology;
2022-02-08 21:27:57 +00:00
use crate::Label;
2022-01-14 06:05:51 +00:00
2023-01-23 05:06:08 +00:00
pub const PLANET_RADIUS: f32 = 600.0;
2022-01-14 00:14:08 +00:00
#[derive(Component)]
2022-03-02 06:31:44 +00:00
pub struct CyberPlanet;
2022-01-14 00:14:08 +00:00
2022-03-02 06:31:44 +00:00
fn spawn_planet(
mut commands: Commands,
mut meshes: ResMut<Assets<Mesh>>,
mut materials: ResMut<Assets<StandardMaterial>>,
) {
2023-01-24 04:12:15 +00:00
let color = Color::rgba(0.7, 0.7, 0.8, 0.3);
2023-01-23 05:06:08 +00:00
let plane = Plane {
size: PLANET_RADIUS,
};
2023-01-23 05:06:08 +00:00
//let (mesh, shape) = gen_planet(plane);
let mesh = Mesh::from(plane);
let shape = Collider::from_bevy_mesh(&mesh, &ComputedColliderShape::TriMesh).unwrap();
let pbody = (RigidBody::Fixed, Ccd { enabled: true });
let pcollide = (
shape,
Friction {
coefficient: 0.05,
..Default::default()
},
Restitution::new(0.0),
);
commands
2023-01-20 22:40:51 +00:00
.spawn(PbrBundle {
mesh: meshes.add(mesh),
material: materials.add(StandardMaterial {
base_color: color,
2022-02-21 21:08:49 +00:00
metallic: 0.1,
2022-02-09 06:27:41 +00:00
perceptual_roughness: 0.3,
alpha_mode: AlphaMode::Opaque,
..Default::default()
}),
..Default::default()
})
2023-01-20 22:40:51 +00:00
.insert(pbody)
.insert(pcollide)
2022-03-02 06:31:44 +00:00
.insert(CyberPlanet);
}
pub struct CyberPlanetPlugin;
impl Plugin for CyberPlanetPlugin {
2022-01-14 00:14:08 +00:00
fn build(&self, app: &mut App) {
app.add_startup_system(spawn_planet.label(Label::Geometry));
2022-01-14 00:14:08 +00:00
}
}
//---------------------------------------------------------------------
// utils
//---------------------------------------------------------------------
2023-01-23 05:06:08 +00:00
/*
fn gen_planet(sphere: Plane) -> (Mesh, Collider) {
// straight-up stolen from Bevy's impl of Mesh from Icosphere, so I can do the
// displacement before normals are calculated.
let generated = IcoSphere::new(sphere.subdivisions, |point| {
let inclination = point.y.acos();
let azimuth = point.z.atan2(point.x);
let norm_inclination = inclination / std::f32::consts::PI;
let norm_azimuth = 0.5 - (azimuth / std::f32::consts::TAU);
[norm_azimuth, norm_inclination]
});
2022-02-25 21:18:44 +00:00
let noise = HybridMulti::<SuperSimplex>::default();
let noisy_points = generated
2022-02-21 21:08:49 +00:00
.raw_points()
.iter()
.map(|&p| {
let disp = noise.get(p.as_dvec3().into()) as f32 * 0.05;
2022-03-01 02:18:23 +00:00
let pt = p + (p.normalize() * disp);
pt.into()
})
.collect::<Vec<[f32; 3]>>();
let points = noisy_points
2022-02-21 21:08:49 +00:00
.iter()
.map(|&p| (Vec3::from_slice(&p) * sphere.radius).into())
.collect::<Vec<[f32; 3]>>();
let uvs = generated.raw_data().to_owned();
let mut indices = Vec::with_capacity(generated.indices_per_main_triangle() * 20);
for i in 0..20 {
generated.get_indices(i, &mut indices);
}
let mut idxs = Vec::new();
for idx in indices.chunks_exact(3) {
idxs.push([idx[0], idx[1], idx[2]]);
}
let shape = Collider::trimesh(points.iter().map(|p| Vect::from_slice(p)).collect(), idxs);
let indices = Indices::U32(indices);
let mut mesh = Mesh::new(PrimitiveTopology::TriangleList);
mesh.set_indices(Some(indices));
mesh.insert_attribute(Mesh::ATTRIBUTE_POSITION, points);
mesh.insert_attribute(Mesh::ATTRIBUTE_UV_0, uvs);
(mesh, shape)
}
2023-01-23 05:06:08 +00:00
*/