precalculate track + arc helper fn + structs

src/states/linear/systems_track.rs

@@ -1,6 +1,8 @@
+use std::f32::consts::FRAC_PI_2;
 use crate::states::linear::*;
-use crate::{FACTOR, HEIGHT, WIDTH};
+use crate::{FACTOR};
 use bevy::prelude::*;
+use bevy::reflect::List;
 
 pub const CENTER_X: f32 = 0.0;
 pub const CENTER_Y: f32 = 0.0;
@@ -11,10 +13,8 @@ pub const STEP: f32 = FACTOR as f32 / SCALE;
 pub const SCALE: f32 = 2.0;
 
 
-pub fn setup_linear_track(mut commands: Commands) {
+pub fn setup_linear_track() -> Track {
     println!("Построение трека начато");
-
-    commands.spawn((
         Track {
             start_point: Vec2 {
                 x: CENTER_X - FACTOR as f32 * 7.0,
@@ -41,7 +41,101 @@ pub fn setup_linear_track(mut commands: Commands) {
                 PathSegment::Turn { radius: STEP, left: false },
                 PathSegment::Line { length: STEP * 2.0 },
             ],
-        },
-        LinearStateMarker,
-    ));
+        }
 }
+
+pub fn precalculate_track(track: &Track) -> PrecalculatedTrack {
+    let mut pt = PrecalculatedTrack { segments: vec![] };
+    let mut cumulative_length: Vec<f32> = vec![0.0];
+
+    let mut current_pos = track.start_point;
+    let mut current_dir = track.start_direction;
+    
+    // на первом проходе заполняем все, кроме t_start и t_end,
+    // потому что мы не можем посчитать их без общей длины
+    for seg in track.segments.iter(){
+        match seg {
+            PathSegment::Line { length } => {
+                let calc_seg = PTSegment {
+                    t_start: 0.0,
+                    t_end: 0.0,
+                    segment_type: SegementType::Line,
+                    start_pos: current_pos,
+                    direction: current_dir,
+                    center: Vec2::ZERO,
+                    radius: 0.0,
+                    start_angle: 0.0,
+                    sweep_sign: 0.0,
+                };
+
+                pt.segments.push(calc_seg);
+                // сдвигаем позицию для следующего сегмента
+                current_pos = current_pos + length * current_dir;
+                // направление не меняем, пропуск
+                // накапливаем длину
+                cumulative_length.push(cumulative_length[cumulative_length.len() -1] + *length);
+            }
+
+            PathSegment::Turn {radius, left } => {
+                let arc = helper_arc_calculator(current_pos, current_dir, *left, *radius);
+                
+                let calc_seg = PTSegment {
+                    t_start: 0.0,
+                    t_end: 0.0,
+                    segment_type: SegementType::Turn,
+                    start_pos: current_pos,
+                    direction: current_dir,
+                    center: arc.center,
+                    radius: *radius,
+                    start_angle: arc.start_angle,
+                    sweep_sign: arc.sweep_sign,
+                };
+                pt.segments.push(calc_seg);
+                // сдвигаем позицию для следующего сегмента
+                current_pos = arc.end_pos;
+                current_dir = arc.normal;
+                // накапливаем длину
+                cumulative_length.push(cumulative_length[cumulative_length.len() -1] + (FRAC_PI_2 * radius));
+            }
+        }
+    }
+    
+    let last_index = cumulative_length.len() - 1;
+    let total_length = cumulative_length[last_index];
+    
+    // итерируемся уже по прекалькулированному вектору
+    // заполняем точки на треке в пересчете на общую длину
+    println!("Precalculated track:");
+    for (i, seg) in pt.segments.iter_mut().enumerate() {
+        seg.t_start = cumulative_length[i] / total_length;
+        if i < last_index {
+            seg.t_end = cumulative_length[i+1] / total_length;
+        } else {
+            seg.t_end = 1.0;
+        }
+        println!("{:?}", seg);
+    }
+    
+    pt
+}
+
+pub fn helper_arc_calculator(pos: Vec2, dir: Vec2, turn_to: bool, radius: f32) -> ArcCalculation{
+    let (normal, sign): (Vec2, f32) = if turn_to {
+        (Vec2::new(-dir.y, dir.x), -1.0)
+    } else {
+        (Vec2::new(dir.y, -dir.x), 1.0)
+    };
+
+    let center = pos + normal * radius;
+    let start_vec = pos - center;
+    let initial_vec = if turn_to { -start_vec.perp() } else { -start_vec };
+    let angle = initial_vec.to_angle();
+    
+    ArcCalculation{
+        normal,
+        center,
+        start_angle: angle,
+        sweep_sign: sign,
+        end_pos: center + normal.perp() * radius * sign,
+    }
+}