Compare commits
3 commits
incomplete
...
main
| Author | SHA1 | Date | |
|---|---|---|---|
|
ce5f660861 | ||
| 13697a6104 | |||
| d6280343d5 |
6 changed files with 462 additions and 34 deletions
36
README.md
36
README.md
|
|
@ -1,19 +1,17 @@
|
||||||
# Stage JSB : Simulation spatiale
|
## Feuille de route
|
||||||
|
* Créer deuxième planète
|
||||||
## Aide
|
* Gravité naïve
|
||||||
|
* Vitesse
|
||||||
[Documentation de Bevy](https://docs.rs/bevy/latest/bevy/)
|
* Poids
|
||||||
|
* Faire un système solaire (trouver valeurs)
|
||||||
## Commandes
|
* Quadtree
|
||||||
|
* Réutiliser les mêmes Mesh et Material (augmente FPS en dézoom)
|
||||||
Vérifier la validité du code :
|
* Générer un mesh avec noise
|
||||||
|
* Générer plusieurs meshes
|
||||||
cargo check
|
* (?) Collision
|
||||||
|
* Détection
|
||||||
Compiler et lancer le programme :
|
* Double boucle naïve
|
||||||
|
* Intégré au quadtree
|
||||||
cargo run
|
* Fusion simple
|
||||||
|
* Fragmentation
|
||||||
Compiler et lancer le programme optimisé (plus lent à compiler, mais plus léger et rapide à exécuter) :
|
* Cratère
|
||||||
|
|
||||||
cargo run --release
|
|
||||||
|
|
|
||||||
3
build-wasm.sh
Normal file
3
build-wasm.sh
Normal 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
32
index.html
Normal 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>
|
||||||
34
src/gen.rs
34
src/gen.rs
|
|
@ -2,14 +2,40 @@ use bevy::{prelude::*, render::render_resource::PrimitiveTopology};
|
||||||
use opensimplex_noise_rs::OpenSimplexNoise;
|
use opensimplex_noise_rs::OpenSimplexNoise;
|
||||||
use rand::Rng;
|
use rand::Rng;
|
||||||
|
|
||||||
pub fn _planet() -> Mesh {
|
/// Générer une planète
|
||||||
|
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;
|
||||||
|
|
||||||
|
// Ajouter des points dans le mesh
|
||||||
mesh.insert_attribute(
|
mesh.insert_attribute(
|
||||||
Mesh::ATTRIBUTE_POSITION,
|
Mesh::ATTRIBUTE_POSITION,
|
||||||
vec![[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.0, 1.0, 0.0]],
|
(0..perimeter)
|
||||||
|
.map(|i| {
|
||||||
|
// Rayon
|
||||||
|
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.2, 10.) as f32 * 4.0;
|
||||||
|
// Angle
|
||||||
|
let a = std::f32::consts::TAU * i as f32 / perimeter as f32;
|
||||||
|
// Coordonnées du point
|
||||||
|
[r * a.cos(), r * a.sin(), 0.]
|
||||||
|
})
|
||||||
|
.chain([[0., 0., 0.]])
|
||||||
|
.collect::<Vec<_>>(),
|
||||||
);
|
);
|
||||||
mesh.set_indices(Some(bevy::render::mesh::Indices::U32(vec![0, 1, 2])));
|
|
||||||
|
// Ajouter des triangles en indiquant quels points (de ceux définis juste avant) doivent être reliés
|
||||||
|
let mut triangles = Vec::new();
|
||||||
|
for i in 0..perimeter {
|
||||||
|
triangles.extend_from_slice(&[i, perimeter, (i + 1) % perimeter]);
|
||||||
|
}
|
||||||
|
mesh.set_indices(Some(bevy::render::mesh::Indices::U32(triangles)));
|
||||||
mesh
|
mesh
|
||||||
}
|
}
|
||||||
|
|
|
||||||
217
src/main.rs
217
src/main.rs
|
|
@ -1,11 +1,21 @@
|
||||||
mod gen;
|
mod gen;
|
||||||
|
mod quadtree;
|
||||||
|
|
||||||
use bevy::{prelude::*, sprite::MaterialMesh2dBundle};
|
use bevy::{
|
||||||
|
ecs::query::BatchingStrategy,
|
||||||
|
prelude::*,
|
||||||
|
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));
|
||||||
|
|
||||||
|
/// Cette fonction est l'entrée du programme
|
||||||
fn main() {
|
fn main() {
|
||||||
App::new()
|
App::new()
|
||||||
.add_plugins((
|
.add_plugins((
|
||||||
|
|
@ -13,49 +23,228 @@ fn main() {
|
||||||
bevy_fps_counter::FpsCounterPlugin,
|
bevy_fps_counter::FpsCounterPlugin,
|
||||||
bevy_pancam::PanCamPlugin,
|
bevy_pancam::PanCamPlugin,
|
||||||
))
|
))
|
||||||
|
.insert_resource(Constants { g: 6.674e-11 })
|
||||||
.add_systems(Startup, setup)
|
.add_systems(Startup, setup)
|
||||||
.configure_sets(Update, (Set::Demo).chain())
|
.configure_sets(Update, (Set::Force, Set::Apply).chain())
|
||||||
.add_systems(Update, (demo_system.in_set(Set::Demo),))
|
.add_systems(
|
||||||
|
Update,
|
||||||
|
(
|
||||||
|
weight_system.in_set(Set::Force),
|
||||||
|
apply_system.in_set(Set::Apply),
|
||||||
|
),
|
||||||
|
)
|
||||||
.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());
|
||||||
|
|
||||||
|
let red = materials.add(ColorMaterial::from(Color::RED));
|
||||||
|
let circle_5: Mesh2dHandle = meshes.add(shape::Circle::new(5.).into()).into();
|
||||||
|
|
||||||
|
// Créer des planètes
|
||||||
commands
|
commands
|
||||||
.spawn(Ball {
|
.spawn(Planet {
|
||||||
pos: TransformBundle::from(Transform::from_translation(Vec3::new(0., 0., 0.))),
|
pos: TransformBundle::from(Transform::from_translation(Vec3::new(0., 0., 0.))),
|
||||||
|
mass: Mass(1.988e18),
|
||||||
|
speed: Speed(Vec2::new(0.0, 0.0)),
|
||||||
|
visibility: InheritedVisibility::VISIBLE,
|
||||||
|
})
|
||||||
|
.with_children(|parent| {
|
||||||
|
parent.spawn(MaterialMesh2dBundle {
|
||||||
|
mesh: meshes.add(gen::planet()).into(),
|
||||||
|
material: materials.add(ColorMaterial::from(Color::YELLOW)),
|
||||||
|
..default()
|
||||||
|
});
|
||||||
|
});
|
||||||
|
commands
|
||||||
|
.spawn(Planet {
|
||||||
|
pos: TransformBundle::from(Transform::from_translation(Vec3::new(400., 0., 0.))),
|
||||||
|
mass: Mass(5.9736e14),
|
||||||
|
speed: Speed(Vec2::new(0.0, 500.0)),
|
||||||
visibility: InheritedVisibility::VISIBLE,
|
visibility: InheritedVisibility::VISIBLE,
|
||||||
})
|
})
|
||||||
.with_children(|parent| {
|
.with_children(|parent| {
|
||||||
parent.spawn(MaterialMesh2dBundle {
|
parent.spawn(MaterialMesh2dBundle {
|
||||||
mesh: meshes.add(shape::Circle::new(10.).into()).into(),
|
mesh: meshes.add(shape::Circle::new(10.).into()).into(),
|
||||||
material: materials.add(ColorMaterial::from(Color::ORANGE)),
|
material: materials.add(ColorMaterial::from(Color::BLUE)),
|
||||||
|
..default()
|
||||||
|
});
|
||||||
|
});
|
||||||
|
commands
|
||||||
|
.spawn(Planet {
|
||||||
|
pos: TransformBundle::from(Transform::from_translation(Vec3::new(-400., 0., 0.))),
|
||||||
|
mass: Mass(5.9736e14),
|
||||||
|
speed: Speed(Vec2::new(0.0, -500.0)),
|
||||||
|
visibility: InheritedVisibility::VISIBLE,
|
||||||
|
})
|
||||||
|
.with_children(|parent| {
|
||||||
|
parent.spawn(MaterialMesh2dBundle {
|
||||||
|
mesh: meshes.add(shape::Circle::new(10.).into()).into(),
|
||||||
|
material: materials.add(ColorMaterial::from(Color::BLUE)),
|
||||||
|
..default()
|
||||||
|
});
|
||||||
|
});
|
||||||
|
// Créer plein de planètes !
|
||||||
|
for i in 0..4000u32 {
|
||||||
|
commands
|
||||||
|
.spawn(Planet {
|
||||||
|
pos: TransformBundle::from(Transform::from_translation(Vec3::new(
|
||||||
|
-450. - i as f32 / 4.,
|
||||||
|
0.,
|
||||||
|
0.,
|
||||||
|
))),
|
||||||
|
mass: Mass(1.),
|
||||||
|
speed: Speed(Vec2::new(0.0, -500.0)),
|
||||||
|
visibility: InheritedVisibility::VISIBLE,
|
||||||
|
})
|
||||||
|
.with_children(|parent| {
|
||||||
|
parent.spawn(MaterialMesh2dBundle {
|
||||||
|
mesh: circle_5.clone(),
|
||||||
|
material: red.clone(),
|
||||||
..default()
|
..default()
|
||||||
});
|
});
|
||||||
});
|
});
|
||||||
}
|
}
|
||||||
|
|
||||||
#[derive(Clone, Debug, Eq, Hash, PartialEq, SystemSet)]
|
|
||||||
enum Set {
|
|
||||||
Demo,
|
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/// 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)]
|
||||||
|
enum Set {
|
||||||
|
/// Systèmes modélisant des forces (poids, champ électrique, rebonds...), donc changeant la vitesse des objets
|
||||||
|
Force,
|
||||||
|
/// Systèmes appliquant les forces, donc changeant la position des objets selon leur vitesse
|
||||||
|
Apply,
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Une vitesse (x, y) en m/s
|
||||||
|
#[derive(Component)]
|
||||||
|
struct Speed(Vec2);
|
||||||
|
|
||||||
|
/// Une masse en kg
|
||||||
|
#[derive(Component)]
|
||||||
|
struct Mass(f32);
|
||||||
|
|
||||||
|
/// Une planète
|
||||||
#[derive(Bundle)]
|
#[derive(Bundle)]
|
||||||
struct Ball {
|
struct Planet {
|
||||||
|
/// Position du centre de la planète
|
||||||
pos: TransformBundle,
|
pos: TransformBundle,
|
||||||
|
/// Masse de la planète
|
||||||
|
mass: Mass,
|
||||||
|
/// Vitesse de la planète
|
||||||
|
speed: Speed,
|
||||||
visibility: InheritedVisibility,
|
visibility: InheritedVisibility,
|
||||||
}
|
}
|
||||||
|
|
||||||
fn demo_system(query: Query<&Transform>, time: Res<Time>) {
|
/// Constantes physiques
|
||||||
println!("Temps écoulé : {}s", time.delta_seconds());
|
#[derive(Resource)]
|
||||||
for pos in query.iter() {
|
struct Constants {
|
||||||
println!("Il y a un objet aux coordonnées {:?}", pos.translation);
|
/// Constante gravitationnelle
|
||||||
|
g: f32,
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Corps. Sert à utiliser le quadtree
|
||||||
|
struct Body {
|
||||||
|
mass: f32,
|
||||||
|
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 {
|
||||||
|
fn mass(&self) -> f32 {
|
||||||
|
self.mass
|
||||||
|
}
|
||||||
|
fn pos(&self) -> Vec2 {
|
||||||
|
self.pos
|
||||||
|
}
|
||||||
|
fn add_mass(&mut self, mass: f32) {
|
||||||
|
self.mass += mass;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
// Ici l'ancien système de poids, mis en commentaire pour être ignoré.
|
||||||
|
/*fn weight_system(
|
||||||
|
constants: Res<Constants>,
|
||||||
|
query1: Query<(&Transform, &Mass)>,
|
||||||
|
mut query2: Query<(&Transform, &mut Speed)>,
|
||||||
|
time: Res<Time>,
|
||||||
|
) {
|
||||||
|
let gdt = constants.g * time.delta_seconds();
|
||||||
|
for (n1_pos, n1_mass) in query1.iter() {
|
||||||
|
for (n2_pos, mut n2_speed) in query2.iter_mut() {
|
||||||
|
let d2 = (n1_pos.translation.x - n2_pos.translation.x).powi(2)
|
||||||
|
+ (n1_pos.translation.y - n2_pos.translation.y).powi(2);
|
||||||
|
if d2 == 0.0 {
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
let f = n1_mass.0 * gdt / (d2 * d2.sqrt());
|
||||||
|
n2_speed.x += (n1_pos.translation.x - n2_pos.translation.x) * f;
|
||||||
|
n2_speed.y += (n1_pos.translation.y - n2_pos.translation.y) * f;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}*/
|
||||||
|
|
||||||
|
/// Le système de poids.
|
||||||
|
fn weight_system(
|
||||||
|
constants: Res<Constants>,
|
||||||
|
mut query: Query<(&Transform, &Mass, &mut Speed)>,
|
||||||
|
time: Res<Time>,
|
||||||
|
) {
|
||||||
|
// Créer un arbre
|
||||||
|
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();
|
||||||
|
// Ajouter toutes les planètes dans l'arbre
|
||||||
|
for (pos, mass, _speed) in query.iter() {
|
||||||
|
tree.add_body(Body {
|
||||||
|
mass: mass.0,
|
||||||
|
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)| {
|
||||||
|
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 mut iter = query.iter_combinations_mut();
|
||||||
|
// while let Some([(n1_pos, n1_mass, mut n1_speed), (n2_pos, n2_mass, mut n2_speed)]) =
|
||||||
|
// iter.fetch_next()
|
||||||
|
// {
|
||||||
|
// let d2 = (n1_pos.translation.x - n2_pos.translation.x).powi(2)
|
||||||
|
// + (n1_pos.translation.y - n2_pos.translation.y).powi(2);
|
||||||
|
// let f = gdt / (d2 * d2.sqrt());
|
||||||
|
// n1_speed.x -= (n1_pos.translation.x - n2_pos.translation.x) * f * n2_mass.0;
|
||||||
|
// n1_speed.y -= (n1_pos.translation.y - n2_pos.translation.y) * f * n2_mass.0;
|
||||||
|
// n2_speed.x += (n1_pos.translation.x - n2_pos.translation.x) * f * n1_mass.0;
|
||||||
|
// n2_speed.y += (n1_pos.translation.y - n2_pos.translation.y) * f * n1_mass.0;
|
||||||
|
// }
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Système déplaçant les objets selon leur vitesse
|
||||||
|
fn apply_system(mut query: Query<(&mut Transform, &Speed)>, time: Res<Time>) {
|
||||||
|
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
|
||||||
|
.par_iter_mut()
|
||||||
|
.batching_strategy(BatchingStrategy::fixed(128))
|
||||||
|
.for_each(|(mut pos, speed)| {
|
||||||
|
pos.translation.x += speed.0.x * dt;
|
||||||
|
pos.translation.y += speed.0.y * dt;
|
||||||
|
});
|
||||||
|
}
|
||||||
|
|
|
||||||
180
src/quadtree.rs
Normal file
180
src/quadtree.rs
Normal file
|
|
@ -0,0 +1,180 @@
|
||||||
|
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 {
|
||||||
|
/// Quelle est la masse en kg du corps ?
|
||||||
|
fn mass(&self) -> f32;
|
||||||
|
/// Quelle est la position (x, y) du corps ?
|
||||||
|
fn pos(&self) -> Vec2;
|
||||||
|
/// Ajouter de la masse dans le corps.
|
||||||
|
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> {
|
||||||
|
/// Branche
|
||||||
|
Branch {
|
||||||
|
/// 4 nœuds contenus par cette branche, séparant son espace en 4 cadrants de même taille
|
||||||
|
nodes: Box<[Node<L>; 4]>,
|
||||||
|
/// Position du centre du rectangle
|
||||||
|
center: Vec2,
|
||||||
|
/// Masse cumulée de tous les objets dans le nœud
|
||||||
|
mass: f32,
|
||||||
|
/// Centre de masse d'ensemble des objets contenus
|
||||||
|
center_of_mass: Vec2,
|
||||||
|
/// Largeur de notre rectangle
|
||||||
|
width: f32,
|
||||||
|
},
|
||||||
|
/// Feuille
|
||||||
|
Leaf {
|
||||||
|
/// Contient soit un corps Some(body) soit rien None
|
||||||
|
body: Option<L>,
|
||||||
|
/// Position de la feuille (pas celle du corps, qui peut être à des endroits différents dans la feuille)
|
||||||
|
pos: (Vec2, Vec2),
|
||||||
|
},
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Ajoutons des fonctions aux nœuds
|
||||||
|
impl<L: Body> Node<L> {
|
||||||
|
/// Création d'un nouveau nœud vide
|
||||||
|
pub fn new(pos: (Vec2, Vec2)) -> Self {
|
||||||
|
Node::Leaf { body: None, pos }
|
||||||
|
}
|
||||||
|
/// Ajouter un corps dans le nœud
|
||||||
|
pub fn add_body(&mut self, new_body: L) {
|
||||||
|
match self {
|
||||||
|
// Si le nœud est une branche...
|
||||||
|
Node::Branch {
|
||||||
|
nodes,
|
||||||
|
center,
|
||||||
|
mass,
|
||||||
|
center_of_mass,
|
||||||
|
..
|
||||||
|
} => {
|
||||||
|
let new_body_pos = new_body.pos();
|
||||||
|
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)
|
||||||
|
/ (*mass + new_body_mass);
|
||||||
|
*mass += new_body_mass;
|
||||||
|
// Trouver le bon cadrant où ajouter le corps
|
||||||
|
nodes[if new_body_pos.x < center.x {
|
||||||
|
if new_body_pos.y < center.y {
|
||||||
|
0
|
||||||
|
} else {
|
||||||
|
2
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
if new_body_pos.y < center.y {
|
||||||
|
1
|
||||||
|
} else {
|
||||||
|
3
|
||||||
|
}
|
||||||
|
}]
|
||||||
|
.add_body(new_body)
|
||||||
|
}
|
||||||
|
// Si le nœud est une feuille...
|
||||||
|
Node::Leaf { body, pos } => {
|
||||||
|
// Si la feuille contient un corps...
|
||||||
|
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 {
|
||||||
|
body.add_mass(new_body.mass());
|
||||||
|
*self = Node::Leaf {
|
||||||
|
body: Some(body),
|
||||||
|
pos: *pos,
|
||||||
|
};
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
// Cette feuille va devenir une branche.
|
||||||
|
// On calcule donc son centre.
|
||||||
|
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 {
|
||||||
|
nodes: Box::new([
|
||||||
|
Node::Leaf {
|
||||||
|
body: None,
|
||||||
|
pos: (pos.0, center),
|
||||||
|
},
|
||||||
|
Node::Leaf {
|
||||||
|
body: None,
|
||||||
|
pos: (Vec2::new(center.x, pos.0.y), Vec2::new(pos.1.x, center.y)),
|
||||||
|
},
|
||||||
|
Node::Leaf {
|
||||||
|
body: None,
|
||||||
|
pos: (Vec2::new(pos.0.x, center.y), Vec2::new(center.x, pos.1.y)),
|
||||||
|
},
|
||||||
|
Node::Leaf {
|
||||||
|
body: None,
|
||||||
|
pos: (center, pos.1),
|
||||||
|
},
|
||||||
|
]),
|
||||||
|
center,
|
||||||
|
mass: 0.0,
|
||||||
|
center_of_mass: center,
|
||||||
|
width: pos.1.x - pos.0.x,
|
||||||
|
};
|
||||||
|
|
||||||
|
// On ajoute les deux corps dans la branche.
|
||||||
|
self.add_body(body);
|
||||||
|
self.add_body(new_body)
|
||||||
|
} else {
|
||||||
|
// Ici est le cas où la feuille était vide, alors on met juste le nouveau corps dedans.
|
||||||
|
*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 {
|
||||||
|
match self {
|
||||||
|
// Si le nœud est une branche...
|
||||||
|
Node::Branch {
|
||||||
|
nodes,
|
||||||
|
mass,
|
||||||
|
center_of_mass,
|
||||||
|
width,
|
||||||
|
..
|
||||||
|
} => {
|
||||||
|
if on == *center_of_mass {
|
||||||
|
// Dans ce cas la distance est nulle, donc on évite de diviser par zéro.
|
||||||
|
return Vec2::ZERO;
|
||||||
|
}
|
||||||
|
let dist = on.distance(*center_of_mass);
|
||||||
|
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)
|
||||||
|
} 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[1].apply(on, theta)
|
||||||
|
+ nodes[2].apply(on, theta)
|
||||||
|
+ nodes[3].apply(on, theta)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
// Si le nœud est une feuille...
|
||||||
|
Node::Leaf { body, .. } => {
|
||||||
|
if let Some(body) = body {
|
||||||
|
// La feuille contient un corps.
|
||||||
|
if on == body.pos() {
|
||||||
|
return Vec2::ZERO;
|
||||||
|
}
|
||||||
|
let dist = on.distance(body.pos());
|
||||||
|
body.mass() * (body.pos() - on) / (dist * dist * dist)
|
||||||
|
} else {
|
||||||
|
// La feuille est vide.
|
||||||
|
Vec2::ZERO
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
Loading…
Reference in a new issue