Add telemetry history graph

Cargo.toml

@@ -20,3 +20,4 @@ cgmath = { version = "0.18.0", features = ["swizzle", "serde"] }
 paste = "1.0.11"
 serde = "1.0.152"
 serde_json = "1.0.91"
+ringbuf = "0.3.2"

build.rs

@@ -10,8 +10,10 @@ const VK_HEADER: &[&str] = &[
 const FN_PREFIX: &str = "PFN_";
 
 const SHADER: &[&str] = &[
-    "src/overlay/elements/pedals/single_color.vert",
+    "src/overlay/elements/radar/single_color.vert",
-    "src/overlay/elements/pedals/single_color.frag",
+    "src/overlay/elements/radar/single_color.frag",
+    "src/overlay/elements/pedals/history.vert",
+    "src/overlay/elements/pedals/history.frag",
 ];
 
 fn query_vulkan_function_typedefs() {

src/overlay/elements/leaderboard/leaderboard_grid.xml

@@ -1,5 +1,5 @@
 <?xml-model href="../gui.xsd" type="application/xml" schematypens="http://www.w3.org/2001/XMLSchema"?>
 <root reference_width="2560" reference_height="1440">
-    <grid id="main_grid" x_dim="1" y_dim="25" x_offset="10" y_offset="70" width="350" height="875"
+    <grid id="main_grid" x_dim="1" y_dim="25" x_offset="10" y_offset="10" width="350" height="875"
         vert_align="top" hori_align="left" margin="0" padding="0"> </grid>
 </root>

src/overlay/elements/mod.rs

@@ -7,3 +7,42 @@ pub use leaderboard::*;
 pub use pedals::*;
 pub use radar::*;
 pub use watermark::*;
+
+#[derive(Clone)]
+pub struct PositionOnlyVertex {
+    pub position: cgmath::Vector4<f32>,
+}
+
+impl PositionOnlyVertex {
+    ///
+    /// corners[0]  -  bottom left
+    /// corners[1]  -  top left
+    /// corners[2]  -  top right
+    /// corners[3]  -  bottom right
+    ///
+    pub fn from_2d_corners(
+        ortho: cgmath::Matrix4<f32>,
+        corners: [cgmath::Vector2<f32>; 4],
+    ) -> [Self; 6] {
+        [
+            Self {
+                position: ortho * corners[0].extend(0.0).extend(1.0),
+            },
+            Self {
+                position: ortho * corners[1].extend(0.0).extend(1.0),
+            },
+            Self {
+                position: ortho * corners[2].extend(0.0).extend(1.0),
+            },
+            Self {
+                position: ortho * corners[2].extend(0.0).extend(1.0),
+            },
+            Self {
+                position: ortho * corners[3].extend(0.0).extend(1.0),
+            },
+            Self {
+                position: ortho * corners[0].extend(0.0).extend(1.0),
+            },
+        ]
+    }
+}

src/overlay/elements/pedals/history.frag

@@ -0,0 +1,12 @@
+#version 450
+
+layout (set = 0, binding = 0) uniform Color {
+	vec4 val;
+} color;
+
+layout (location = 0) out vec4 out_color;
+
+void main()
+{
+	out_color = color.val;
+}

src/overlay/elements/pedals/history.vert

@@ -0,0 +1,8 @@
+#version 450
+
+layout (location = 0) in vec4 position;
+
+void main()
+{
+	gl_Position = position;
+}

src/overlay/elements/pedals/mod.rs

@@ -1,45 +1,230 @@
-use std::sync::Arc;
+mod pipeline;
+
+use std::sync::{Arc, Mutex};
 
 use anyhow::Result;
+use cgmath::{ortho, vec4, Matrix4};
 use rfactor_sm_reader::{rF2VehicleTelemetry, VehicleScoringInfoV01};
+use ringbuf::{HeapRb, Rb};
 use ui::prelude::*;
+use vulkan_rs::prelude::*;
 
 use crate::overlay::{
     rfactor_data::{DataReceiver, GamePhase},
     UiOverlay,
 };
+use crate::write_log;
+
+use self::pipeline::HistoryPipeline;
+
+use super::PositionOnlyVertex;
 
 pub struct Pedals {
     gui: Arc<GuiBuilder>,
 
     brake: Arc<ProgressBar>,
     throttle: Arc<ProgressBar>,
-    history: Arc<Icon>,
+    _history: Arc<Icon>,
 
-    throttle_samples: Vec<f32>,
+    throttle_samples: HeapRb<f32>,
-    brake_samples: Vec<f32>,
+    brake_samples: HeapRb<f32>,
+
+    ortho: Matrix4<f32>,
+
+    device: Arc<Device>,
+    queue: Arc<Mutex<Queue>>,
+
+    render_target: RenderTarget,
+    pipeline: HistoryPipeline,
+
+    brake_descriptor: Arc<DescriptorSet>,
+    brake_vertex_buffer: Arc<Buffer<PositionOnlyVertex>>,
+    throttle_descriptor: Arc<DescriptorSet>,
+    throttle_vertex_buffer: Arc<Buffer<PositionOnlyVertex>>,
 }
 
 impl Pedals {
-    pub fn new(gui_handler: &Arc<GuiHandler>) -> Result<Self> {
+    pub fn new(
+        gui_handler: &Arc<GuiHandler>,
+        device: Arc<Device>,
+        queue: Arc<Mutex<Queue>>,
+    ) -> Result<Self> {
         const DESC: &str = include_str!("pedals.xml");
 
         let gui = GuiBuilder::from_str(gui_handler, DESC)?;
 
         let brake = gui.element("brake")?;
         let throttle = gui.element("throttle")?;
-        let history = gui.element("history")?;
+        let history: Arc<Icon> = gui.element("history")?;
 
-        Ok(Self {
+        let (icon_width, icon_height) = history.extent();
+        let history_image = Image::empty(
+            icon_width as u32,
+            icon_height as u32,
+            VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT,
+            VK_SAMPLE_COUNT_1_BIT,
+        )
+        .format(VK_FORMAT_R8G8B8A8_UNORM)
+        .attach_sampler(Sampler::nearest_sampler().build(&device)?)
+        .build(&device, &queue)?;
+
+        history_image.convert_layout(VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL)?;
+
+        history.set_icon(&history_image)?;
+
+        let render_target = RenderTarget::builder()
+            .add_sub_pass(
+                SubPass::builder(history_image.width(), history_image.height())
+                    .set_prepared_targets(&[history_image.clone()], 0, [0.3, 0.3, 0.3, 1.0], true)
+                    .build(&device, &queue)?,
+            )
+            .build(&device)?;
+
+        let pipeline = HistoryPipeline::new(
+            device.clone(),
+            render_target.render_pass(),
+            history_image.width(),
+            history_image.height(),
+        )?;
+
+        let ortho = ortho(0.0, history_image.width() as f32, 0.0, 1.0, -1.0, 1.0);
+
+        let descriptor_pool = DescriptorPool::builder()
+            .set_layout(pipeline.descriptor_layout().clone())
+            .set_descriptor_set_count(2)
+            .build(device.clone())?;
+
+        let brake_color_buffer: Arc<Buffer<f32>> = Buffer::builder()
+            .set_usage(VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT)
+            .set_memory_usage(MemoryUsage::CpuOnly)
+            .set_data(&[0.9, 0.0, 0.0, 1.0])
+            .build(device.clone())?;
+
+        write_log!("allocate brake descriptor");
+
+        let brake_descriptor = descriptor_pool.prepare_set().allocate()?;
+        brake_descriptor.update(&[DescriptorWrite::uniform_buffers(0, &[&brake_color_buffer])])?;
+
+        let throttle_color_buffer: Arc<Buffer<f32>> = Buffer::builder()
+            .set_usage(VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT)
+            .set_memory_usage(MemoryUsage::CpuOnly)
+            .set_data(&[0.0, 0.9, 0.0, 1.0])
+            .build(device.clone())?;
+
+        write_log!("allocate throttle descriptor");
+
+        let throttle_descriptor = descriptor_pool.prepare_set().allocate()?;
+        throttle_descriptor.update(&[DescriptorWrite::uniform_buffers(
+            0,
+            &[&throttle_color_buffer],
+        )])?;
+
+        let mut throttle_samples = HeapRb::new(icon_width as usize);
+        let mut brake_samples = HeapRb::new(icon_width as usize);
+
+        for _ in 0..icon_width {
+            throttle_samples.push_overwrite(0.0);
+            brake_samples.push_overwrite(0.0);
+        }
+
+        let brake_vertex_buffer = Self::create_vertex_buffer(&device, icon_width as VkDeviceSize)?;
+        let throttle_vertex_buffer =
+            Self::create_vertex_buffer(&device, icon_width as VkDeviceSize)?;
+
+        let me = Self {
             gui,
 
             brake,
             throttle,
-            history,
+            _history: history,
 
-            throttle_samples: Vec::new(),
+            throttle_samples,
-            brake_samples: Vec::new(),
+            brake_samples,
+
+            ortho,
+
+            device,
+            queue,
+
+            render_target,
+            pipeline,
+
+            brake_descriptor,
+            brake_vertex_buffer,
+            throttle_descriptor,
+            throttle_vertex_buffer,
+        };
+
+        me.update_vertex_buffers()?;
+
+        Ok(me)
+    }
+
+    fn create_vertex_buffer(
+        device: &Arc<Device>,
+        size: VkDeviceSize,
+    ) -> Result<Arc<Buffer<PositionOnlyVertex>>> {
+        Buffer::builder()
+            .set_usage(VK_BUFFER_USAGE_VERTEX_BUFFER_BIT)
+            .set_memory_usage(MemoryUsage::CpuOnly)
+            .set_size(size)
+            .build(device.clone())
+    }
+
+    fn update_vertex_buffers(&self) -> Result<()> {
+        self.update_vertex_buffer(
+            &self.throttle_vertex_buffer,
+            self.throttle_samples.as_slices(),
+        )?;
+        self.update_vertex_buffer(&self.brake_vertex_buffer, self.brake_samples.as_slices())?;
+
+        Ok(())
+    }
+
+    fn update_vertex_buffer(
+        &self,
+        buffer: &Arc<Buffer<PositionOnlyVertex>>,
+        (data1, data2): (&[f32], &[f32]),
+    ) -> Result<()> {
+        let points = data1
+            .iter()
+            .chain(data2.iter())
+            .enumerate()
+            .map(|(x, &date)| PositionOnlyVertex {
+                position: self.ortho * vec4(x as f32, date, 0.0, 1.0),
             })
+            .collect::<Vec<PositionOnlyVertex>>();
+
+        buffer.fill(&points)
+    }
+
+    pub fn render(&self) -> Result<Arc<CommandBuffer>> {
+        let command_buffer =
+            CommandBuffer::new_primary().build(self.device.clone(), self.queue.clone())?;
+
+        {
+            let mut recorder = command_buffer.begin(VkCommandBufferBeginInfo::new(
+                VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT
+                    | VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT,
+            ))?;
+
+            self.render_target
+                .begin(&recorder, VK_SUBPASS_CONTENTS_INLINE, 0);
+
+            recorder.bind_pipeline(self.pipeline.pipeline())?;
+
+            recorder.bind_descriptor_sets_minimal(&[&self.throttle_descriptor]);
+            recorder.bind_vertex_buffer(&self.throttle_vertex_buffer);
+            recorder.draw_complete_single_instance(self.throttle_vertex_buffer.size() as u32);
+
+            recorder.bind_descriptor_sets_minimal(&[&self.brake_descriptor]);
+            recorder.bind_vertex_buffer(&self.brake_vertex_buffer);
+            recorder.draw_complete_single_instance(self.brake_vertex_buffer.size() as u32);
+
+            self.render_target.end(&recorder);
+        }
+
+        Ok(command_buffer)
     }
 }
 
@@ -70,8 +255,10 @@ impl DataReceiver for Pedals {
                     self.throttle.set_progress(throttle)?;
                     self.brake.set_progress(brake)?;
 
-                    self.throttle_samples.push(throttle);
+                    self.throttle_samples.push_overwrite(throttle);
-                    self.brake_samples.push(brake);
+                    self.brake_samples.push_overwrite(brake);
+
+                    self.update_vertex_buffers()?;
                 }
             }
             None => {
@@ -82,3 +269,28 @@ impl DataReceiver for Pedals {
         Ok(())
     }
 }
+
+#[cfg(test)]
+mod test {
+    use ringbuf::{HeapRb, Rb};
+
+    #[test]
+    fn rb_test() {
+        const CAP: usize = 10;
+
+        let mut buf = HeapRb::new(CAP);
+
+        for _ in 0..CAP {
+            buf.push_overwrite(20);
+        }
+
+        println!("{:?}", buf.as_slices());
+
+        buf.push_overwrite(40);
+        buf.push_overwrite(40);
+        buf.push_overwrite(40);
+        buf.push_overwrite(40);
+
+        println!("{:?}", buf.as_slices());
+    }
+}

src/overlay/elements/pedals/pedals.xml

@@ -1,6 +1,6 @@
 <?xml-model href="../gui.xsd" type="application/xml" schematypens="http://www.w3.org/2001/XMLSchema"?>
 <root reference_width="2560" reference_height="1440">
-    <grid x_dim="7" y_dim="2" x_offset="-750" y_offset="-250" width="150" height="200"
+    <grid x_dim="10" y_dim="2" x_offset="-850" y_offset="-190" width="200" height="160"
         vert_align="bottom" hori_align="right" margin="3" padding="3" background="#686868">
         <progressbar id="brake" x_slot="0" y_slot="0" y_size="2" background="#494949"
             direction="bottom_to_top" foreground="#e30000"></progressbar>
@@ -8,7 +8,7 @@
             x_slot="1" y_slot="0" y_size="2" background="#494949" direction="bottom_to_top"
             foreground="#00b900"></progressbar>
 
-        <icon id="history" x_slot="2" x_size="5" y_slot="0"
+        <icon id="history" x_slot="2" x_size="8" y_slot="0"
             y_size="2"></icon>
     </grid>
 </root>

src/overlay/elements/pedals/pipeline.rs

@@ -0,0 +1,102 @@
+use anyhow::Result;
+use vulkan_rs::prelude::*;
+
+use std::{mem, sync::Arc};
+
+use super::super::PositionOnlyVertex;
+
+pub struct HistoryPipeline {
+    pipeline: Arc<Pipeline>,
+    descriptor_layout: Arc<DescriptorSetLayout>,
+}
+
+impl HistoryPipeline {
+    pub fn new(
+        device: Arc<Device>,
+        renderpass: &Arc<RenderPass>,
+        width: u32,
+        height: u32,
+    ) -> Result<Self> {
+        let vertex_shader = ShaderModule::from_slice(
+            device.clone(),
+            include_bytes!("history.vert.spv"),
+            ShaderType::Vertex,
+        )?;
+        let fragment_shader = ShaderModule::from_slice(
+            device.clone(),
+            include_bytes!("history.frag.spv"),
+            ShaderType::Fragment,
+        )?;
+
+        let descriptor_layout = DescriptorSetLayout::builder()
+            .add_layout_binding(
+                0,
+                VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
+                VK_SHADER_STAGE_FRAGMENT_BIT,
+                0,
+            )
+            .build(device.clone())?;
+
+        let pipeline_layout = PipelineLayout::builder()
+            .add_descriptor_set_layout(&descriptor_layout)
+            .build(device.clone())?;
+
+        let viewport = VkViewport {
+            x: 0.0,
+            y: 0.0,
+            width: width as f32,
+            height: height as f32,
+            minDepth: 0.0,
+            maxDepth: 1.0,
+        };
+
+        let scissor = VkRect2D {
+            offset: VkOffset2D { x: 0, y: 0 },
+            extent: VkExtent2D {
+                width: width,
+                height: height,
+            },
+        };
+
+        let pipeline = Pipeline::new_graphics()
+            .set_vertex_shader(
+                vertex_shader.clone(),
+                vec![VkVertexInputBindingDescription {
+                    binding: 0,
+                    stride: mem::size_of::<PositionOnlyVertex>() as u32,
+                    inputRate: VK_VERTEX_INPUT_RATE_VERTEX,
+                }],
+                vec![
+                    // position
+                    VkVertexInputAttributeDescription {
+                        location: 0,
+                        binding: 0,
+                        format: VK_FORMAT_R32G32B32A32_SFLOAT,
+                        offset: 0,
+                    },
+                ],
+            )
+            .set_fragment_shader(fragment_shader.clone())
+            .input_assembly(VK_PRIMITIVE_TOPOLOGY_LINE_STRIP, false)
+            .default_depth_stencil(false, false)
+            .default_color_blend(vec![VkPipelineColorBlendAttachmentState::default()])
+            .default_rasterization(VK_CULL_MODE_NONE, VK_FRONT_FACE_COUNTER_CLOCKWISE)
+            .default_multisample(VK_SAMPLE_COUNT_1_BIT)
+            .add_viewport(viewport)
+            .add_scissor(scissor)
+            .build(device, &pipeline_layout, &renderpass, 0)?;
+
+        Ok(Self {
+            descriptor_layout,
+            pipeline,
+        })
+    }
+
+    pub fn pipeline(&self) -> &Arc<Pipeline> {
+        &self.pipeline
+    }
+
+    pub fn descriptor_layout(&self) -> &Arc<DescriptorSetLayout> {
+        &self.descriptor_layout
+    }
+}

src/overlay/elements/radar/mod.rs

@@ -1,7 +1,7 @@
 mod pipeline;
 
 use anyhow::Result;
-use cgmath::{ortho, vec2, vec3, vec4, Deg, InnerSpace, Matrix4, Rad, Vector2, Vector3, Vector4};
+use cgmath::{ortho, vec2, vec3, vec4, Deg, InnerSpace, Matrix4, Rad, Vector2, Vector3};
 use rfactor_sm_reader::*;
 use serde::{Deserialize, Serialize};
 use vulkan_rs::prelude::*;
@@ -19,41 +19,7 @@ use crate::{
     write_log,
 };
 
-#[derive(Clone)]
+use super::PositionOnlyVertex;
-pub struct PositionOnlyVertex {
-    pub position: Vector4<f32>,
-}
-
-impl PositionOnlyVertex {
-    ///
-    /// corners[0]  -  bottom left
-    /// corners[1]  -  top left
-    /// corners[2]  -  top right
-    /// corners[3]  -  bottom right
-    ///
-    pub fn from_2d_corners(ortho: Matrix4<f32>, corners: [Vector2<f32>; 4]) -> [Self; 6] {
-        [
-            Self {
-                position: ortho * corners[0].extend(0.0).extend(1.0),
-            },
-            Self {
-                position: ortho * corners[1].extend(0.0).extend(1.0),
-            },
-            Self {
-                position: ortho * corners[2].extend(0.0).extend(1.0),
-            },
-            Self {
-                position: ortho * corners[2].extend(0.0).extend(1.0),
-            },
-            Self {
-                position: ortho * corners[3].extend(0.0).extend(1.0),
-            },
-            Self {
-                position: ortho * corners[0].extend(0.0).extend(1.0),
-            },
-        ]
-    }
-}
 
 fn convert_vec(v: rF2Vec3) -> Vector3<f32> {
     vec3(v.x as f32, v.y as f32, v.z as f32)

src/overlay/elements/watermark/mod.rs

@@ -10,7 +10,7 @@ use crate::overlay::{
 };
 
 pub struct Watermark {
-    _gui: Arc<GuiBuilder>,
+    gui: Arc<GuiBuilder>,
 }
 
 impl Watermark {
@@ -19,9 +19,7 @@ impl Watermark {
 
         let gui = GuiBuilder::from_str(gui_handler, DESC)?;
 
-        gui.enable()?;
+        Ok(Self { gui })
-
-        Ok(Self { _gui: gui })
     }
 }
 
@@ -30,9 +28,14 @@ impl UiOverlay for Watermark {}
 impl DataReceiver for Watermark {
     fn scoring_update(
         &mut self,
-        _phase: GamePhase,
+        phase: GamePhase,
         _vehicle_scoring: &[VehicleScoringInfoV01],
     ) -> Result<()> {
+        match phase {
+            GamePhase::TestDay => self.gui.enable()?,
+            _ => self.gui.disable()?,
+        }
+
         Ok(())
     }
 

src/overlay/mod.rs

@@ -142,7 +142,7 @@ impl Overlay {
         // only font is used
         let mut create_info = GuiHandlerCreateInfo::default();
 
-        create_info.font_path = AssetPath::from("/usr/share/vulkan_rf2_layer/font.png");
+        create_info.font_path = AssetPath::from("/opt/sata_ssd/Workspace/vk_layer_rs/font.png");
         create_info.font_path.assume_prefix_free();
 
         // required to not crash
@@ -196,8 +196,15 @@ impl Overlay {
 
         // create pedals
         if self.config.ui_config.enable_pedals {
-            let pedals = Rc::new(RefCell::new(Pedals::new(&gui_handler)?));
+            let pedals = Rc::new(RefCell::new(Pedals::new(
-            self.ui_elements.push(pedals);
+                &gui_handler,
+                self.device(),
+                self.queue(),
+            )?));
+
+            self.ui_elements.push(pedals.clone());
+
+            rendering.add_render_callback(move |_| pedals.borrow().render());
 
             write_log!("Pedals successfully created");
         }

src/overlay/rfactor_data.rs

@@ -109,6 +109,8 @@ impl RFactorData {
 
             let phase = GamePhase::try_from(scoring_info.mSession)?;
 
+            write_log!(format!("GamePhase: {:?}", phase));
+
             for receiver in self.receivers.iter() {
                 receiver
                     .borrow_mut()