More doc comments

Doc comments
WASM build
2024-01-13 17:39:33 +01:00 · 2024-01-13 13:51:08 +01:00 · 2024-01-03 22:24:53 +01:00
6 changed files with 462 additions and 34 deletions
--- a/README.md
+++ b/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
--- a/build-wasm.sh
+++ b/build-wasm.sh
@ -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
--- a/index.html
+++ b/index.html
@ -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>
--- a/src/gen.rs
+++ b/src/gen.rs
@ -2,14 +2,40 @@ use bevy::{prelude::*, render::render_resource::PrimitiveTopology};
 use opensimplex_noise_rs::OpenSimplexNoise;
 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 _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 perimeter: u32 = 1000;
 	// Ajouter des points dans le mesh
 	mesh.insert_attribute(
 		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
 }
--- a/src/main.rs
+++ b/src/main.rs
@ -1,11 +1,21 @@
 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]
 static ALLOCATOR: cap::Cap<std::alloc::System> =
 	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() {
 	App::new()
 		.add_plugins((
@ -13,49 +23,228 @@ fn main() {
 			bevy_fps_counter::FpsCounterPlugin,
 			bevy_pancam::PanCamPlugin,
 		))
 		.insert_resource(Constants { g: 6.674e-11 })
 		.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();
 }
 /// Cette fonction est appelée à l'initialisation du jeu, par main
 fn setup(
 	mut commands: Commands,
 	mut meshes: ResMut<Assets<Mesh>>,
 	mut materials: ResMut<Assets<ColorMaterial>>,
 ) {
 	// Créer une caméra qui filme ce qu'on va afficher à l'écran
 	commands
 		.spawn(Camera2dBundle::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
-		.spawn(Ball {
+		.spawn(Planet {
 			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,
 		})
 		.with_children(|parent| {
 			parent.spawn(MaterialMesh2dBundle {
 				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()
 				});
 			});
 	}
 }
 /// 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 {
-	Demo,
+	/// 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)]
-struct Ball {
+struct Planet {
 	/// Position du centre de la planète
 	pos: TransformBundle,
 	/// Masse de la planète
 	mass: Mass,
 	/// Vitesse de la planète
 	speed: Speed,
 	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;
 		});
 }
--- a/src/quadtree.rs
+++ b/src/quadtree.rs
@ -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
 				}
 			}
 		}
 	}
 }
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