Doc comments

src/main.rs

@@ -7,12 +7,15 @@ use bevy::{
 	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((
@@ -33,11 +36,13 @@ fn main() {
 		.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());
@@ -45,6 +50,7 @@ fn setup(
 	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(Planet {
 			pos: TransformBundle::from(Transform::from_translation(Vec3::new(0., 0., 0.))),
@@ -87,6 +93,7 @@ fn setup(
 				..default()
 			});
 		});
+	// Créer plein de planètes !
 	for i in 0..4000u32 {
 		commands
 			.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)]
 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)]
 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,
 }
 
+/// Constantes physiques
 #[derive(Resource)]
 struct Constants {
+	/// 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
@@ -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(
 	constants: Res<Constants>,
 	query1: Query<(&Transform, &Mass)>,
@@ -172,22 +197,29 @@ impl quadtree::Body for Body {
 	}
 }*/
 
+/// 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)]) =
@@ -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>) {
 	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))

src/quadtree.rs

@@ -1,26 +1,46 @@
 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
 	pub fn new(pos: (Vec2, Vec2)) -> Self {
 		Node::Leaf { body: None, pos }
 		// let center = (pos.1 - pos.0) / 2.0;