Get something on the screen

src/overlay/mod.rs

@@ -106,6 +106,8 @@ impl Overlay {
                 swapchain.height(),
             )
             .ok();
+
+            write_log!("created RFactorData");
         }
 
         // check twice for rfactor data, because of borrowing rules

src/overlay/rendering.rs

@@ -52,7 +52,6 @@ pub struct Rendering {
     render_target: RenderTarget,
     command_buffer: Arc<CommandBuffer>,
 
-    device: Arc<Device>,
     queue: Arc<Mutex<Queue>>,
 }
 
@@ -99,7 +98,6 @@ impl Rendering {
             render_target,
             command_buffer: CommandBuffer::new_primary().build(device.clone(), queue.clone())?,
 
-            device,
             queue,
         })
     }

src/overlay/rfactor_data.rs

@@ -3,9 +3,10 @@ use cgmath::{ortho, vec2, vec3, InnerSpace, Matrix4, Vector2, Vector3, VectorSpa
 use rfactor_sm_reader::*;
 use vulkan_rs::prelude::*;
 
-use std::sync::Arc;
+use std::{sync::Arc, time::Instant};
 
 use super::rendering::PositionOnlyVertex;
+use crate::write_log;
 
 fn convert_vec(v: rF2Vec3) -> Vector3<f32> {
     vec3(v.x as f32, v.y as f32, v.z as f32)
@@ -44,9 +45,12 @@ pub struct RFactorData {
     ortho: Matrix4<f32>,
     window_width: u32,
     window_height: u32,
+    radar_extent: f32,
     car_width: f32,
     car_height: f32,
 
+    start_time: Instant,
+
     device: Arc<Device>,
     descriptor_layout: Arc<DescriptorSetLayout>,
 }
@@ -59,6 +63,8 @@ impl RFactorData {
         width: u32,
         height: u32,
     ) -> Result<Self> {
+        write_log!(" =================== create RFactorData ===================");
+
         let radar_extent = width as f32 * 0.075 * config.radar_scale;
         let car_height = radar_extent * 0.2;
         let car_width = car_height * 0.5;
@@ -68,12 +74,13 @@ impl RFactorData {
         );
 
         let ortho = ortho(0.0, width as f32, 0.0, height as f32, -1.0, 1.0);
+        let start_time = Instant::now();
 
         Ok(Self {
             config,
 
-            telemetry_reader: TelemetryReader::new()?,
+            telemetry_reader: TelemetryReader::new(start_time.elapsed().as_secs_f32())?,
-            scoring_reader: ScoringReader::new()?,
+            scoring_reader: ScoringReader::new(start_time.elapsed().as_secs_f32())?,
 
             background: RadarObject::new(
                 device.clone(),
@@ -111,15 +118,20 @@ impl RFactorData {
             ortho,
             window_width: width,
             window_height: height,
+            radar_extent,
             car_width,
             car_height,
 
+            start_time,
+
             device,
             descriptor_layout: descriptor_layout.clone(),
         })
     }
 
     fn create_car_object(&self, offset: Vector2<f32>, color: [f32; 4]) -> Result<RadarObject> {
+        write_log!(" =================== create car object ===================");
+
         RadarObject::new(
             self.device.clone(),
             &self.descriptor_layout,
@@ -148,9 +160,21 @@ impl RFactorData {
         )
     }
 
+    fn now(&self) -> f32 {
+        self.start_time.elapsed().as_secs_f32()
+    }
+
     pub fn update(&mut self) -> Result<()> {
+        write_log!(" =================== update RFactorData ===================");
+
         // get scoring info
-        let (scoring_info, vehicle_scorings) = self.scoring_reader.vehicle_scoring();
+        if let Some((scoring_info, vehicle_scorings)) =
+            self.scoring_reader.vehicle_scoring(self.now())
+        {
+            write_log!(format!(
+                "new scoring info: vehicles: {}",
+                scoring_info.mNumVehicles
+            ));
 
             // check for player id
             if scoring_info.mNumVehicles == 0 {
@@ -158,14 +182,19 @@ impl RFactorData {
             } else if self.player_id.is_none() {
                 for vehicle_scoring in vehicle_scorings.iter() {
                     if vehicle_scoring.mIsPlayer != 0 {
+                        write_log!(format!("player found: {}", vehicle_scoring.mID));
                         self.player_id = Some(vehicle_scoring.mID);
+                        break;
+                    }
                 }
             }
         }
 
         // if player id is set (a map is loaded), check telemetry data
         if let Some(player_id) = &self.player_id {
-            let telemetries = self.telemetry_reader.query_telemetry();
+            write_log!("before telemetry update");
+            if let Some(telemetries) = self.telemetry_reader.query_telemetry(self.now()) {
+                write_log!("new telemetry update");
 
                 let mut player_position = CarPosition::default();
                 let mut other_positions = Vec::new();
@@ -193,14 +222,19 @@ impl RFactorData {
 
                     // check if car is close enough the players car
                     if distance < self.config.radar_car_distance {
-                    let offset = diff.truncate();
+                        let distance_ratio = distance / self.config.radar_car_distance;
-                    let color = self.config.danger_color.lerp(
-                        self.config.safe_color,
-                        distance / self.config.radar_car_distance,
-                    );
 
-                    self.cars
+                        let offset =
-                        .push(self.create_car_object(offset, [color.x, color.y, color.z, 0.9])?);
+                            diff.truncate() * (self.radar_extent / self.config.radar_car_distance);
+                        let color = self
+                            .config
+                            .danger_color
+                            .lerp(self.config.safe_color, distance_ratio);
+
+                        self.cars.push(
+                            self.create_car_object(offset, [color.x, color.y, color.z, 0.9])?,
+                        );
+                    }
                 }
             }
         }
@@ -209,6 +243,8 @@ impl RFactorData {
     }
 
     pub fn objects(&self) -> Vec<&dyn RenderObject> {
+        write_log!(" =================== get objects of RFactorData ===================");
+
         let mut objects: Vec<&dyn RenderObject> = Vec::new();
 
         // only draw radar when player is loaded into a map