refactor: update render code (#62)

* refactor: transform triangular arrows into proper ones

* refactor: remove relative computation of arrow thickness/head size

* feat: add conditional arrow resize to render params

* feat: add a binding to F1 to stop the render

* feat: render beta2 as diamonds

* chore: mention missing content in changelog

Author: imrn99

CHANGELOG.md

@@ -4,7 +4,7 @@
 
 ## To be released
 
-...
+content from PR #49 / commit ce3948d2e7ccda4e58395ff9e715c946e9b8f744 onward
 
 ---
 

honeycomb-examples/examples/render/squaremap_shift.rs

@@ -11,6 +11,7 @@ fn main() {
     const N_SQUARE: usize = 16;
     let render_params = RenderParameters {
         smaa_mode: SmaaMode::Smaa1X,
+        relative_resize: false,
         ..Default::default()
     };
 

honeycomb-render/src/handle.rs

@@ -8,7 +8,9 @@
 use crate::representations::intermediates::{Entity, IntermediateFace};
 use crate::shader_data::Coords2Shader;
 use crate::SmaaMode;
-use honeycomb_core::{CMap2, CoordsFloat, DartIdentifier, Orbit2, OrbitPolicy};
+use honeycomb_core::{
+    CMap2, CoordsFloat, DartIdentifier, EdgeIdentifier, Orbit2, OrbitPolicy, Vertex2, NULL_DART_ID,
+};
 
 // ------ CONTENT
 
@@ -25,15 +27,18 @@ pub struct RenderParameters {
     pub arrow_headsize: f32,
     /// Thickness of the darts.
     pub arrow_thickness: f32,
+    /// Size arrow thcikness and head relatively to their length.
+    pub relative_resize: bool,
 }
 
 impl Default for RenderParameters {
     fn default() -> Self {
         Self {
             smaa_mode: SmaaMode::Disabled,
             shrink_factor: 0.1,    // need to adjust
-            arrow_headsize: 0.1,   // need to adjust
+            arrow_headsize: 0.05,  // need to adjust
             arrow_thickness: 0.01, // need to adjust
+            relative_resize: true,
         }
     }
 }
@@ -87,33 +92,46 @@ impl<'a, T: CoordsFloat> CMap2RenderHandle<'a, T> {
             .filter(|face| face.n_vertices > 1)
             .flat_map(|face| {
                 (0..face.n_vertices).flat_map(|id| {
-                    let mut v1 = face.vertices[id];
-                    let mut v6 = face.vertices[(id + 1) % face.n_vertices];
+                    let mut va = face.vertices[id];
+                    let mut vb = face.vertices[(id + 1) % face.n_vertices];
 
-                    let seg_dir = (v6 - v1).unit_dir().unwrap();
-                    v1 += seg_dir * T::from(self.params.shrink_factor).unwrap();
-                    v6 -= seg_dir * T::from(self.params.shrink_factor).unwrap();
+                    let seg_dir = (vb - va).unit_dir().unwrap();
+                    va += seg_dir * T::from(self.params.shrink_factor).unwrap();
+                    vb -= seg_dir * T::from(self.params.shrink_factor).unwrap();
 
-                    let seg = v6 - v1;
-                    let seg_length = seg.norm();
-                    let seg_dir = seg.unit_dir().unwrap();
+                    let seg = vb - va;
                     let seg_normal = seg.normal_dir();
                     let ahs = T::from(self.params.arrow_headsize).unwrap();
                     let at = T::from(self.params.arrow_thickness).unwrap();
-
-                    let vcenter = v6 - seg_dir * ahs;
-                    let v2 = vcenter - seg_normal * at;
-                    let v3 = vcenter + seg_normal * at;
-                    let v4 = vcenter + seg_normal * (ahs * seg_length);
-                    let v5 = vcenter - seg_normal * (ahs * seg_length);
-
+                    let mut body_offset = seg_normal * at;
+                    let mut head_offset = seg_normal * ahs;
+                    let mut vcenter = vb - seg * ahs;
+                    if self.params.relative_resize {
+                        let seg_length = seg.norm();
+                        body_offset *= seg_length;
+                        head_offset *= seg_length;
+                        vcenter = vb - seg * seg_length * ahs;
+                    }
+
+                    let v1 = va + body_offset;
+                    let v2 = va - body_offset;
+                    let v3 = vcenter - body_offset;
+                    let v4 = v3;
+                    let v5 = v1;
+                    let v6 = vcenter + body_offset;
+                    let v7 = vcenter + head_offset;
+                    let v8 = vcenter - head_offset;
+                    let v9 = vb;
                     [
                         Coords2Shader::from((v1, Entity::Dart)),
                         Coords2Shader::from((v2, Entity::Dart)),
                         Coords2Shader::from((v3, Entity::Dart)),
                         Coords2Shader::from((v4, Entity::Dart)),
                         Coords2Shader::from((v5, Entity::Dart)),
                         Coords2Shader::from((v6, Entity::Dart)),
+                        Coords2Shader::from((v7, Entity::Dart)),
+                        Coords2Shader::from((v8, Entity::Dart)),
+                        Coords2Shader::from((v9, Entity::Dart)),
                     ]
                     .into_iter()
                 })
@@ -123,7 +141,37 @@ impl<'a, T: CoordsFloat> CMap2RenderHandle<'a, T> {
 
     #[allow(dead_code)]
     pub fn build_betas(&mut self) {
-        todo!()
+        let tmp: Vec<EdgeIdentifier> = self.handle.fetch_edges().identifiers.clone();
+        let tmp = tmp
+            .iter()
+            .map(|edge_id| {
+                (
+                    *edge_id as DartIdentifier,
+                    self.handle.beta::<2>(*edge_id as DartIdentifier),
+                )
+            })
+            .filter(|(_, b2vid)| *b2vid != NULL_DART_ID)
+            .flat_map(|(dart_id, b2dart_id)| {
+                let va = self.handle.vertex(self.handle.vertex_id(dart_id));
+                let vb = self.handle.vertex(self.handle.vertex_id(b2dart_id));
+                let seg_dir = vb - va;
+                let center = Vertex2::average(&va, &vb);
+                let seg_normal = seg_dir.normal_dir();
+                let vr = center + seg_dir * T::from(0.01).unwrap();
+                let vl = center - seg_dir * T::from(0.01).unwrap();
+                let vt = center + seg_normal * T::from(0.1).unwrap();
+                let vb = center - seg_normal * T::from(0.1).unwrap();
+                [
+                    Coords2Shader::from((vt, Entity::Beta)),
+                    Coords2Shader::from((vl, Entity::Beta)),
+                    Coords2Shader::from((vr, Entity::Beta)),
+                    Coords2Shader::from((vl, Entity::Beta)),
+                    Coords2Shader::from((vr, Entity::Beta)),
+                    Coords2Shader::from((vb, Entity::Beta)),
+                ]
+                .into_iter()
+            });
+        self._beta_construction_buffer.extend(tmp);
     }
 
     pub fn build_faces(&mut self) {
@@ -155,6 +203,7 @@ impl<'a, T: CoordsFloat> CMap2RenderHandle<'a, T> {
         self.vertices.clear();
         self.vertices.append(&mut self.face_construction_buffer);
         self.vertices.append(&mut self.dart_construction_buffer);
+        self.vertices.append(&mut self._beta_construction_buffer);
     }
 
     pub fn vertices(&self) -> &[Coords2Shader] {

honeycomb-render/src/representations/intermediates.rs

@@ -2,6 +2,7 @@ use honeycomb_core::{Coords2, CoordsFloat, Vertex2};
 
 pub enum Entity {
     Dart,
+    Beta,
     Face,
 }
 

honeycomb-render/src/runner.rs

@@ -38,6 +38,7 @@ async fn inner<T: CoordsFloat>(
     } else {
         State::new_test(&window, render_params).await
     };
+    println!("I: Press F1 to quit");
     event_loop
         .run(move |event, target| {
             // process events
@@ -46,7 +47,7 @@ async fn inner<T: CoordsFloat>(
                     window_id,
                     event: wevent,
                 } => {
-                    if window_id == state.window().id() && !state.input(&wevent) {
+                    if window_id == state.window().id() && !state.input(&wevent, target) {
                         match wevent {
                             WindowEvent::Resized(new_size) => state.resize(Some(new_size)),
                             WindowEvent::RedrawRequested => {

honeycomb-render/src/shader_data.rs

@@ -43,6 +43,7 @@ impl<T: CoordsFloat> From<(Vertex2<T>, Entity)> for Coords2Shader {
             position: as_f32_array!(v),
             color: match e {
                 Entity::Dart => 0,
+                Entity::Beta => 1,
                 Entity::Face => 2,
             },
         }

honeycomb-render/src/shaders/shader2.wgsl

@@ -33,7 +33,7 @@ fn vs_main(
 fn fs_main(in: VertexOutput) -> @location(0) vec4<f32> {
     var color: array<vec4<f32>, 7> = array(
         vec4<f32>(0.1, 0.1, 0.1, 1.0), // 0 -> black darts
-        vec4<f32>(1.0, 0.1, 0.1, 0.1), // 1 ->
+        vec4<f32>(0.3, 0.8, 0.3, 0.1), // 1 -> beta
         vec4<f32>(0.8, 0.3, 0.3, 0.1), // 2 -> face
         vec4<f32>(0.1, 0.1, 1.0, 0.1), // 3 ->
         vec4<f32>(0.1, 1.0, 1.0, 0.1), // 4 ->

honeycomb-render/src/state.rs

@@ -16,6 +16,9 @@ use std::borrow::Cow;
 use wgpu::util::DeviceExt;
 use wgpu::PrimitiveTopology;
 use winit::dpi::PhysicalSize;
+use winit::event::{ElementState, KeyEvent};
+use winit::event_loop::EventLoopWindowTarget;
+use winit::keyboard::{Key, NamedKey};
 use winit::{event::WindowEvent, window::Window};
 
 // ------ CONTENT
@@ -263,7 +266,7 @@ impl<'a, T: CoordsFloat> State<'a, T> {
         map_handle.build_intermediate();
         map_handle.build_darts();
         map_handle.build_faces();
-        // map_handle.build_betas();
+        map_handle.build_betas();
         map_handle.save_buffered();
 
         let render_slice = map_handle.vertices();
@@ -364,7 +367,22 @@ impl<'a, T: CoordsFloat> State<'a, T> {
         self.window.request_redraw();
     }
 
-    pub fn input(&mut self, event: &WindowEvent) -> bool {
+    pub fn input(&mut self, event: &WindowEvent, target: &EventLoopWindowTarget<()>) -> bool {
+        // early check for exit
+        if let WindowEvent::KeyboardInput {
+            event: KeyEvent {
+                state, logical_key, ..
+            },
+            ..
+        } = event
+        {
+            let is_pressed = *state == ElementState::Pressed;
+            if let Key::Named(key) = logical_key {
+                if is_pressed & (key == &NamedKey::F1) {
+                    target.exit();
+                }
+            }
+        };
         self.camera_controller.process_events(event)
     }