tuxmain/jsb-gravity
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Compare commits

merge into: tuxmain:incomplete
Branches Tags
tuxmain:main
tuxmain:incomplete
...
pull from: tuxmain:main
Branches Tags
tuxmain:main
tuxmain:incomplete

3 commits
incomplete ... main

Author SHA1 Message Date
ZettaScript
ce5f660861 More doc comments 2024-01-13 17:39:33 +01:00
Pascal Engélibert
13697a6104 Doc comments 2024-01-13 13:51:08 +01:00
Pascal Engélibert
d6280343d5 WASM build 2024-01-03 22:24:53 +01:00
5 changed files with 127 additions and 25 deletions
Show stats Expand all files Collapse all files

3
build-wasm.sh Normal file
View file

@ -0,0 +1,3 @@
cargo build --release --target wasm32-unknown-unknown || exit 1
echo "==> wasm-bindgen..."
wasm-bindgen --out-name jsb-gravity --out-dir target --target web target/wasm32-unknown-unknown/release/jsb-gravity.wasm || exit 1

32
index.html Normal file
View file

@ -0,0 +1,32 @@
<!doctype html>
<html lang="en">
<head>
<meta charset="UTF-8"/>
<title>JSB Gravity</title>
<style type="text/css">
html, body {
margin: 0;
padding: 0;
background-color: #222;
}
body {
display: flex;
flex-flow: column;
color: white;
}
#game {
order: 1;
max-width: 100vw;
max-height: 100vh;
margin: auto;
}
</style>
</head>
<body>
<canvas id="game">Canvas did not load.</canvas>
<script type="module">
import init from './target/jsb-gravity.js'
init()
</script>
</body>
</html>

12
src/gen.rs
View file

@ -2,24 +2,36 @@ use bevy::{prelude::*, render::render_resource::PrimitiveTopology};
use opensimplex_noise_rs::OpenSimplexNoise; use opensimplex_noise_rs::OpenSimplexNoise;
use rand::Rng; use rand::Rng;
/// Générer une planète
pub fn planet() -> Mesh { pub fn planet() -> Mesh {
// Initialiser l'aléatoire
let mut rng = rand::thread_rng(); let mut rng = rand::thread_rng();
let simplex = OpenSimplexNoise::new(Some(rng.gen())); let simplex = OpenSimplexNoise::new(Some(rng.gen()));
// Créer un mesh vide
let mut mesh = Mesh::new(PrimitiveTopology::TriangleList); let mut mesh = Mesh::new(PrimitiveTopology::TriangleList);
let perimeter: u32 = 1000; let perimeter: u32 = 1000;
// Ajouter des points dans le mesh
mesh.insert_attribute( mesh.insert_attribute(
Mesh::ATTRIBUTE_POSITION, Mesh::ATTRIBUTE_POSITION,
(0..perimeter) (0..perimeter)
.map(|i| { .map(|i| {
// Rayon
let mut r = simplex.eval_2d(i as f64 * 0.02, 0.) as f32 * 20.0 + 100.0; let mut r = simplex.eval_2d(i as f64 * 0.02, 0.) as f32 * 20.0 + 100.0;
r += simplex.eval_2d(i as f64 * 0.05, 10.) as f32 * 10.0; r += simplex.eval_2d(i as f64 * 0.05, 10.) as f32 * 10.0;
r += simplex.eval_2d(i as f64 * 0.2, 10.) as f32 * 4.0; r += simplex.eval_2d(i as f64 * 0.2, 10.) as f32 * 4.0;
// Angle
let a = std::f32::consts::TAU * i as f32 / perimeter as f32; let a = std::f32::consts::TAU * i as f32 / perimeter as f32;
// Coordonnées du point
[r * a.cos(), r * a.sin(), 0.] [r * a.cos(), r * a.sin(), 0.]
}) })
.chain([[0., 0., 0.]]) .chain([[0., 0., 0.]])
.collect::<Vec<_>>(), .collect::<Vec<_>>(),
); );
// Ajouter des triangles en indiquant quels points (de ceux définis juste avant) doivent être reliés
let mut triangles = Vec::new(); let mut triangles = Vec::new();
for i in 0..perimeter { for i in 0..perimeter {
triangles.extend_from_slice(&[i, perimeter, (i + 1) % perimeter]); triangles.extend_from_slice(&[i, perimeter, (i + 1) % perimeter]);

35
src/main.rs
View file

@ -7,12 +7,15 @@ use bevy::{
sprite::{MaterialMesh2dBundle, Mesh2dHandle}, sprite::{MaterialMesh2dBundle, Mesh2dHandle},
}; };
/// Empêche les fuites mémoire, arrête tout à 1 Go
#[global_allocator] #[global_allocator]
static ALLOCATOR: cap::Cap<std::alloc::System> = static ALLOCATOR: cap::Cap<std::alloc::System> =
cap::Cap::new(std::alloc::System, 1024 * 1024 * 1024); cap::Cap::new(std::alloc::System, 1024 * 1024 * 1024);
/// Ces deux points définissent le rectangle contenant tout l'univers
static UNIVERSE_POS: (Vec2, Vec2) = (Vec2::new(-1e6, -1e6), Vec2::new(1e6, 1e6)); static UNIVERSE_POS: (Vec2, Vec2) = (Vec2::new(-1e6, -1e6), Vec2::new(1e6, 1e6));
/// Cette fonction est l'entrée du programme
fn main() { fn main() {
App::new() App::new()
.add_plugins(( .add_plugins((
@ -33,11 +36,13 @@ fn main() {
.run(); .run();
} }
/// Cette fonction est appelée à l'initialisation du jeu, par main
fn setup( fn setup(
mut commands: Commands, mut commands: Commands,
mut meshes: ResMut<Assets<Mesh>>, mut meshes: ResMut<Assets<Mesh>>,
mut materials: ResMut<Assets<ColorMaterial>>, mut materials: ResMut<Assets<ColorMaterial>>,
) { ) {
// Créer une caméra qui filme ce qu'on va afficher à l'écran
commands commands
.spawn(Camera2dBundle::default()) .spawn(Camera2dBundle::default())
.insert(bevy_pancam::PanCam::default()); .insert(bevy_pancam::PanCam::default());
@ -45,6 +50,7 @@ fn setup(
let red = materials.add(ColorMaterial::from(Color::RED)); let red = materials.add(ColorMaterial::from(Color::RED));
let circle_5: Mesh2dHandle = meshes.add(shape::Circle::new(5.).into()).into(); let circle_5: Mesh2dHandle = meshes.add(shape::Circle::new(5.).into()).into();
// Créer des planètes
commands commands
.spawn(Planet { .spawn(Planet {
pos: TransformBundle::from(Transform::from_translation(Vec3::new(0., 0., 0.))), pos: TransformBundle::from(Transform::from_translation(Vec3::new(0., 0., 0.))),
@ -87,6 +93,7 @@ fn setup(
..default() ..default()
}); });
}); });
// Créer plein de planètes !
for i in 0..4000u32 { for i in 0..4000u32 {
commands commands
.spawn(Planet { .spawn(Planet {
@ -109,36 +116,53 @@ fn setup(
} }
} }
/// Un set est un ensemble de systèmes.
/// Chaque système est dans un set, ici Force ou Apply.
/// Les sets sont exécutés dans un certain ordre (défini dans main)
#[derive(Clone, Debug, Eq, Hash, PartialEq, SystemSet)] #[derive(Clone, Debug, Eq, Hash, PartialEq, SystemSet)]
enum Set { enum Set {
/// Systèmes modélisant des forces (poids, champ électrique, rebonds...), donc changeant la vitesse des objets
Force, Force,
/// Systèmes appliquant les forces, donc changeant la position des objets selon leur vitesse
Apply, Apply,
} }
/// Une vitesse (x, y) en m/s
#[derive(Component)] #[derive(Component)]
struct Speed(Vec2); struct Speed(Vec2);
/// Une masse en kg
#[derive(Component)] #[derive(Component)]
struct Mass(f32); struct Mass(f32);
/// Une planète
#[derive(Bundle)] #[derive(Bundle)]
struct Planet { struct Planet {
/// Position du centre de la planète
pos: TransformBundle, pos: TransformBundle,
/// Masse de la planète
mass: Mass, mass: Mass,
/// Vitesse de la planète
speed: Speed, speed: Speed,
visibility: InheritedVisibility, visibility: InheritedVisibility,
} }
/// Constantes physiques
#[derive(Resource)] #[derive(Resource)]
struct Constants { struct Constants {
/// Constante gravitationnelle
g: f32, g: f32,
} }
/// Corps. Sert à utiliser le quadtree
struct Body { struct Body {
mass: f32, mass: f32,
pos: Vec2, pos: Vec2,
} }
/// On implémente le trait Body pour la struct Body.
/// C'est-à-dire qu'on ajoute à la struct Body l'information qu'elle se comporte comme un corps.
/// On lui ajoute les méthodes (fonctions) d'un corps.
impl quadtree::Body for Body { impl quadtree::Body for Body {
fn mass(&self) -> f32 { fn mass(&self) -> f32 {
self.mass self.mass
@ -151,6 +175,7 @@ impl quadtree::Body for Body {
} }
} }
// Ici l'ancien système de poids, mis en commentaire pour être ignoré.
/*fn weight_system( /*fn weight_system(
constants: Res<Constants>, constants: Res<Constants>,
query1: Query<(&Transform, &Mass)>, query1: Query<(&Transform, &Mass)>,
@ -172,22 +197,29 @@ impl quadtree::Body for Body {
} }
}*/ }*/
/// Le système de poids.
fn weight_system( fn weight_system(
constants: Res<Constants>, constants: Res<Constants>,
mut query: Query<(&Transform, &Mass, &mut Speed)>, mut query: Query<(&Transform, &Mass, &mut Speed)>,
time: Res<Time>, time: Res<Time>,
) { ) {
// Créer un arbre
let mut tree = quadtree::Node::new(UNIVERSE_POS); let mut tree = quadtree::Node::new(UNIVERSE_POS);
// Calculer autant de constantes que possible pour éviter d'avoir à le faire plein de fois dans la boucle
let gdt = constants.g * time.delta_seconds(); let gdt = constants.g * time.delta_seconds();
// Ajouter toutes les planètes dans l'arbre
for (pos, mass, _speed) in query.iter() { for (pos, mass, _speed) in query.iter() {
tree.add_body(Body { tree.add_body(Body {
mass: mass.0, mass: mass.0,
pos: pos.translation.xy(), pos: pos.translation.xy(),
}); });
} }
// Pour chaque planète, on calcule son accélération et on change sa vitesse
query.par_iter_mut().for_each(|(pos, _mass, mut speed)| { query.par_iter_mut().for_each(|(pos, _mass, mut speed)| {
speed.0 += gdt * tree.apply(pos.translation.xy(), 0.5); speed.0 += gdt * tree.apply(pos.translation.xy(), 0.5);
}); });
// Encore un vieux système de poids :
// let gdt = constants.g * time.delta_seconds(); // let gdt = constants.g * time.delta_seconds();
// let mut iter = query.iter_combinations_mut(); // let mut iter = query.iter_combinations_mut();
// while let Some([(n1_pos, n1_mass, mut n1_speed), (n2_pos, n2_mass, mut n2_speed)]) = // while let Some([(n1_pos, n1_mass, mut n1_speed), (n2_pos, n2_mass, mut n2_speed)]) =
@ -203,8 +235,11 @@ fn weight_system(
// } // }
} }
/// Système déplaçant les objets selon leur vitesse
fn apply_system(mut query: Query<(&mut Transform, &Speed)>, time: Res<Time>) { fn apply_system(mut query: Query<(&mut Transform, &Speed)>, time: Res<Time>) {
let dt = time.delta_seconds(); let dt = time.delta_seconds();
// iter_mut travaille planète par planète, alors que par_iter_mut travaille en parallèle :
// le code dans le for_each tourne en même temps sur plusieurs planètes, en utilisant plusieurs cœurs de votre processeur pour aller plus vite !
query query
.par_iter_mut() .par_iter_mut()
.batching_strategy(BatchingStrategy::fixed(128)) .batching_strategy(BatchingStrategy::fixed(128))

70
src/quadtree.rs
View file

@ -1,56 +1,53 @@
use bevy::prelude::*; use bevy::prelude::*;
/// Un trait est la définition abstraite d'un comportement.
/// Tout ce qui implémente ce trait possède les méthodes mass, pos, add_mass.
pub trait Body { pub trait Body {
/// Quelle est la masse en kg du corps ?
fn mass(&self) -> f32; fn mass(&self) -> f32;
/// Quelle est la position (x, y) du corps ?
fn pos(&self) -> Vec2; fn pos(&self) -> Vec2;
/// Ajouter de la masse dans le corps.
fn add_mass(&mut self, mass: f32); fn add_mass(&mut self, mass: f32);
} }
/// Nœud de l'arbre, étant soit une feuille soit une branche.
/// Sur chaque branche pousse des branches et des feuilles.
/// Rien ne pousse sur une feuille.
/// Un nœud représente une portion rectangulaire de l'univers, contenant tous les objets qui sont dans ce rectangle.
pub enum Node<L> { pub enum Node<L> {
/// Branche
Branch { Branch {
/// 4 nœuds contenus par cette branche, séparant son espace en 4 cadrants de même taille
nodes: Box<[Node<L>; 4]>, nodes: Box<[Node<L>; 4]>,
/// Position du centre du rectangle
center: Vec2, center: Vec2,
/// Masse cumulée de tous les objets dans le nœud
mass: f32, mass: f32,
/// Centre de masse d'ensemble des objets contenus
center_of_mass: Vec2, center_of_mass: Vec2,
/// Largeur de notre rectangle
width: f32, width: f32,
}, },
/// Feuille
Leaf { Leaf {
/// Contient soit un corps Some(body) soit rien None
body: Option<L>, body: Option<L>,
/// Position de la feuille (pas celle du corps, qui peut être à des endroits différents dans la feuille)
pos: (Vec2, Vec2), pos: (Vec2, Vec2),
}, },
} }
/// Ajoutons des fonctions aux nœuds
impl<L: Body> Node<L> { impl<L: Body> Node<L> {
/// Création d'un nouveau nœud vide
pub fn new(pos: (Vec2, Vec2)) -> Self { pub fn new(pos: (Vec2, Vec2)) -> Self {
Node::Leaf { body: None, pos } Node::Leaf { body: None, pos }
// let center = (pos.1 - pos.0) / 2.0;
// Node::Branch {
// nodes: [
// Box::new(Node::Leaf {
// body: None,
// pos: (pos.0, center),
// }),
// Box::new(Node::Leaf {
// body: None,
// pos: (Vec2::new(center.x, pos.0.y), Vec2::new(pos.1.x, center.y)),
// }),
// Box::new(Node::Leaf {
// body: None,
// pos: (Vec2::new(pos.0.x, center.y), Vec2::new(center.x, pos.1.y)),
// }),
// Box::new(Node::Leaf {
// body: None,
// pos: (center, pos.1),
// }),
// ],
// center,
// mass: 0.0,
// center_of_mass: center,
// width: pos.1.x - pos.0.x,
// }
} }
/// Ajouter un corps dans le nœud
pub fn add_body(&mut self, new_body: L) { pub fn add_body(&mut self, new_body: L) {
match self { match self {
// Si le nœud est une branche...
Node::Branch { Node::Branch {
nodes, nodes,
center, center,
@ -60,9 +57,11 @@ impl<L: Body> Node<L> {
} => { } => {
let new_body_pos = new_body.pos(); let new_body_pos = new_body.pos();
let new_body_mass = new_body.mass(); let new_body_mass = new_body.mass();
// Calculer le centre de masse des corps dans la branche plus le nouveau corps
*center_of_mass = (*center_of_mass * *mass + new_body_mass * new_body_pos) *center_of_mass = (*center_of_mass * *mass + new_body_mass * new_body_pos)
/ (*mass + new_body_mass); / (*mass + new_body_mass);
*mass += new_body_mass; *mass += new_body_mass;
// Trouver le bon cadrant où ajouter le corps
nodes[if new_body_pos.x < center.x { nodes[if new_body_pos.x < center.x {
if new_body_pos.y < center.y { if new_body_pos.y < center.y {
0 0
@ -78,8 +77,12 @@ impl<L: Body> Node<L> {
}] }]
.add_body(new_body) .add_body(new_body)
} }
// Si le nœud est une feuille...
Node::Leaf { body, pos } => { Node::Leaf { body, pos } => {
// Si la feuille contient un corps...
if let Some(mut body) = body.take() { if let Some(mut body) = body.take() {
// Si les deux corps sont très proches, on évite de créer plein de branches ce qui ferait tout planter.
// Dans ce cas on fusionne les deux
if body.pos().distance_squared(new_body.pos()) < 1.0 { if body.pos().distance_squared(new_body.pos()) < 1.0 {
body.add_mass(new_body.mass()); body.add_mass(new_body.mass());
*self = Node::Leaf { *self = Node::Leaf {
@ -88,7 +91,10 @@ impl<L: Body> Node<L> {
}; };
return; return;
} }
// Cette feuille va devenir une branche.
// On calcule donc son centre.
let center = (pos.0 + pos.1) / 2.0; let center = (pos.0 + pos.1) / 2.0;
// Et on la remplace par une branche, pour l'instant avec ses 4 cadrants vides.
*self = Node::Branch { *self = Node::Branch {
nodes: Box::new([ nodes: Box::new([
Node::Leaf { Node::Leaf {
@ -113,17 +119,23 @@ impl<L: Body> Node<L> {
center_of_mass: center, center_of_mass: center,
width: pos.1.x - pos.0.x, width: pos.1.x - pos.0.x,
}; };
// On ajoute les deux corps dans la branche.
self.add_body(body); self.add_body(body);
self.add_body(new_body) self.add_body(new_body)
} else { } else {
// Ici est le cas où la feuille était vide, alors on met juste le nouveau corps dedans.
*body = Some(new_body); *body = Some(new_body);
} }
} }
} }
} }
/// Calculer la force de gravité s'appliquant sur le point `on`
/// `theta` est un nombre entre 0.0 et 1.0, qui détermine si on veut plus de précision ou plus de rapidité.
pub fn apply(&self, on: Vec2, theta: f32) -> Vec2 { pub fn apply(&self, on: Vec2, theta: f32) -> Vec2 {
match self { match self {
// Si le nœud est une branche...
Node::Branch { Node::Branch {
nodes, nodes,
mass, mass,
@ -132,26 +144,34 @@ impl<L: Body> Node<L> {
.. ..
} => { } => {
if on == *center_of_mass { if on == *center_of_mass {
// Dans ce cas la distance est nulle, donc on évite de diviser par zéro.
return Vec2::ZERO; return Vec2::ZERO;
} }
let dist = on.distance(*center_of_mass); let dist = on.distance(*center_of_mass);
if width / dist < theta { if width / dist < theta {
// On est dans le cas où on est assez loin pour pouvoir faire une approximation.
// On fait comme si le nœud était un gros corps, la fusion de tous les corps qu'il contient.
*mass * (*center_of_mass - on) / (dist * dist * dist) *mass * (*center_of_mass - on) / (dist * dist * dist)
} else { } else {
// On est dans le cas où on est trop près pour faire l'approximation.
// On applique alors récursivement pour chaque sous-nœud.
nodes[0].apply(on, theta) nodes[0].apply(on, theta)
+ nodes[1].apply(on, theta) + nodes[1].apply(on, theta)
+ nodes[2].apply(on, theta) + nodes[2].apply(on, theta)
+ nodes[3].apply(on, theta) + nodes[3].apply(on, theta)
} }
} }
// Si le nœud est une feuille...
Node::Leaf { body, .. } => { Node::Leaf { body, .. } => {
if let Some(body) = body { if let Some(body) = body {
// La feuille contient un corps.
if on == body.pos() { if on == body.pos() {
return Vec2::ZERO; return Vec2::ZERO;
} }
let dist = on.distance(body.pos()); let dist = on.distance(body.pos());
body.mass() * (body.pos() - on) / (dist * dist * dist) body.mass() * (body.pos() - on) / (dist * dist * dist)
} else { } else {
// La feuille est vide.
Vec2::ZERO Vec2::ZERO
} }
} }