Schweeble/4 (#13)

* WIP

* Camera models loading into view

* cargofmt fix

* Caste usize to u32 for face_indices

* Changed where caste takes place

Author: Schweeble

Cargo.lock

@@ -23,6 +23,7 @@ structopt = "0.3.22"
 eyre = "0.6.5"
 log = "0.4.14"
 image = "0.23.14"
+itertools = "0.10.1"
 
 [profile.release]
 opt-level = 2 # fast and small wasm

Cargo.toml

@@ -0,0 +1,85 @@
+use wgpu::{
+    util::DeviceExt, Buffer, Device, PipelineLayout, RenderPipeline, ShaderModule,
+    SwapChainDescriptor,
+};
+
+use crate::{import::PlyData, state::Vertex};
+
+#[derive(Debug)]
+pub struct Face {
+    pub vertex_index: Vec<i32>,
+}
+
+pub struct FaceState {
+    pub pipeline: RenderPipeline,
+    pub vertex_buffer: Buffer,
+    pub index_buffer: Buffer,
+    pub num_indices: u32,
+}
+
+impl FaceState {
+    pub fn new(
+        sc_desc: &SwapChainDescriptor,
+        device: &Device,
+        render_pipeline_layout: &PipelineLayout,
+        point_shader: &ShaderModule,
+    ) -> Self {
+        let pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
+            label: Some("Face Render Pipeline"),
+            layout: Some(render_pipeline_layout),
+            vertex: wgpu::VertexState {
+                module: point_shader,
+                entry_point: "vs_main",
+                buffers: &[Vertex::desc()],
+            },
+            fragment: Some(wgpu::FragmentState {
+                module: point_shader,
+                entry_point: "fs_main",
+                targets: &[sc_desc.format.into()],
+            }),
+            primitive: wgpu::PrimitiveState {
+                topology: wgpu::PrimitiveTopology::TriangleList,
+                polygon_mode: wgpu::PolygonMode::Line,
+                ..Default::default()
+            },
+            depth_stencil: None,
+            multisample: wgpu::MultisampleState::default(),
+        });
+
+        let vertex_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
+            label: Some("Face Vertex Buffer"),
+            contents: bytemuck::cast_slice(&[Vertex {
+                position: [0.0, 0.0, 0.0],
+                color: [0.0, 0.0, 0.0],
+            }]),
+            usage: wgpu::BufferUsage::VERTEX,
+        });
+
+        let index_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
+            label: Some("Face Index Buffer"),
+            contents: &[],
+            usage: wgpu::BufferUsage::INDEX,
+        });
+        let num_indices = 0;
+        Self {
+            vertex_buffer,
+            index_buffer,
+            num_indices,
+            pipeline,
+        }
+    }
+
+    pub fn import_faces(&mut self, device: &Device, ply: &PlyData) {
+        self.vertex_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
+            label: Some("Face Vertex Buffer"),
+            contents: bytemuck::cast_slice(&ply.face_vertices),
+            usage: wgpu::BufferUsage::VERTEX,
+        });
+        self.num_indices = ply.face_indices.len() as u32;
+        self.index_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
+            label: Some("Face Index Buffer"),
+            contents: bytemuck::cast_slice(&ply.face_indices),
+            usage: wgpu::BufferUsage::INDEX,
+        });
+    }
+}

icon.jpg

@@ -1,15 +1,21 @@
+use crate::{face::Face, state::Vertex};
 use eyre::{eyre, Result};
-use std::path::Path;
-
-use crate::state::Vertex;
+use itertools::Itertools;
 use nalgebra::{distance, Point3, Vector3};
 use ply_rs::{parser::Parser, ply};
+use std::{collections::HashMap, path::Path};
 
 pub enum Import {
-    Ply(Vec<Vertex>),
+    Ply(PlyData),
     Image(image::DynamicImage),
 }
 
+pub struct PlyData {
+    pub point_vertices: Vec<Vertex>,
+    pub face_vertices: Vec<Vertex>,
+    pub face_indices: Vec<u32>,
+}
+
 pub fn import(path: &Path) -> Result<Import> {
     let f = std::fs::File::open(path).unwrap();
     let mut buf_read = std::io::BufReader::new(f);
@@ -21,17 +27,69 @@ pub fn import(path: &Path) -> Result<Import> {
     match extension {
         "ply" => {
             let vertex_parser = Parser::<Vertex>::new();
+            let face_parser = Parser::<Face>::new();
             let header = vertex_parser.read_header(&mut buf_read)?;
 
-            let mut vertex_list = Vec::new();
+            let mut all_vertices = Vec::new();
+            let mut faces = Vec::new();
 
             for (_, element) in &header.elements {
                 if element.name == "vertex" {
-                    vertex_list =
+                    all_vertices =
                         vertex_parser.read_payload_for_element(&mut buf_read, element, &header)?;
                 }
+                if element.name == "face" {
+                    faces =
+                        face_parser.read_payload_for_element(&mut buf_read, element, &header)?;
+                }
+            }
+
+            // maps from ply vertex indices to face vertex indices
+            let mut all_vertices_to_face_vertices = HashMap::new();
+            let mut face_vertices = Vec::new();
+            let mut face_indices = Vec::new();
+            // looks up face vertex index or creates face vertex for ply vertex
+            let mut get_or_insert_vertex = |index| {
+                *all_vertices_to_face_vertices
+                    .entry(index)
+                    .or_insert_with(|| {
+                        let pos = face_vertices.len() as u32;
+                        face_vertices.push(all_vertices[index]);
+                        pos
+                    })
+            };
+            // tesselate faces
+            for face in faces {
+                // turns ply vertices into face vertices
+                let mut face_iter = face
+                    .vertex_index
+                    .iter()
+                    .map(|&i| get_or_insert_vertex(i as usize));
+                // first vertex is center of triangle fan and first vertex
+                // of all triangles
+                if let Some(first) = face_iter.next() {
+                    for (second, third) in face_iter.tuple_windows() {
+                        // each set of 2 indicies is a new triangle in the triangle fan.
+                        face_indices.extend_from_slice(&[first, second, third]);
+                    }
+                }
             }
-            Ok(Import::Ply(vertex_list))
+
+            // set of vertices that do not corrispond to faces.
+            let point_vertices = all_vertices
+                .iter()
+                .enumerate()
+                .filter(|(i, _)| !all_vertices_to_face_vertices.contains_key(i))
+                .map(|(_, &v)| v)
+                .collect_vec();
+
+            let ply_data = PlyData {
+                point_vertices,
+                face_vertices,
+                face_indices,
+            };
+
+            Ok(Import::Ply(ply_data))
         }
         "png" | "jpg" | "jpeg" => {
             // let img = image::load_from_memory(buf_read)?;
@@ -69,6 +127,21 @@ impl ply::PropertyAccess for Vertex {
     }
 }
 
+impl ply::PropertyAccess for Face {
+    fn new() -> Self {
+        Face {
+            vertex_index: Vec::new(),
+        }
+    }
+
+    fn set_property(&mut self, key: String, property: ply::Property) {
+        match (key.as_ref(), property) {
+            ("vertex_index", ply::Property::ListInt(vec)) => self.vertex_index = vec,
+            (k, _) => panic!("Face: Unexpected key/value combination: key: {}", k),
+        }
+    }
+}
+
 /// Calculates the average position of all vertices provided in the list
 pub fn avg_vertex_position(vertices: &[Vertex]) -> Point3<f32> {
     let mut center = Point3::<f64>::new(0.0, 0.0, 0.0);

src/face.rs

@@ -1,6 +1,7 @@
 #![warn(clippy::all, rust_2018_idioms)]
 
 mod camera;
+mod face;
 mod import;
 mod interface;
 mod state;
@@ -71,15 +72,15 @@ fn main() -> Result<()> {
     );
 
     if let Some(f) = opt.input_file {
-        let points = import::import(&f)?;
-        if let import::Import::Ply(points) = points {
-            let avg_pos = import::avg_vertex_position(&points);
-            let avg_dist = import::avg_vertex_distance(avg_pos, &points);
+        let import = import::import(&f)?;
+        if let import::Import::Ply(gpu_data) = import {
+            let avg_pos = import::avg_vertex_position(&gpu_data.point_vertices);
+            let avg_dist = import::avg_vertex_distance(avg_pos, &gpu_data.point_vertices);
 
             camera.set_camera_facing(avg_pos, avg_dist * 5.0);
             app.set_camera_scale(avg_dist);
 
-            state.import_vertices(&points);
+            state.import_ply_data(&gpu_data);
         } else {
             log::warn!("Ignoring `input_file` option. Can't parse as PLY.");
         }
@@ -146,14 +147,18 @@ fn main() -> Result<()> {
                     WindowEvent::DroppedFile(path) => {
                         match import::import(path) {
                             Ok(imported) => match imported {
-                                import::Import::Ply(points) => {
-                                    let avg_pos = import::avg_vertex_position(&points);
-                                    let avg_dist = import::avg_vertex_distance(avg_pos, &points);
+                                import::Import::Ply(ply_data) => {
+                                    let avg_pos =
+                                        import::avg_vertex_position(&ply_data.point_vertices);
+                                    let avg_dist = import::avg_vertex_distance(
+                                        avg_pos,
+                                        &ply_data.point_vertices,
+                                    );
 
                                     camera.set_camera_facing(avg_pos, avg_dist * 5.0);
                                     app.set_camera_scale(avg_dist);
 
-                                    state.import_vertices(&points);
+                                    state.import_ply_data(&ply_data);
                                 }
                                 import::Import::Image(img) => {
                                     state.import_image(img, &mut app);

src/import.rs

@@ -0,0 +1,33 @@
+[[block]]
+struct Uniforms {
+    view_proj: mat4x4<f32>;
+};
+
+[[group(0), binding(0)]]
+var<uniform> uniforms: Uniforms;
+
+struct VertexOutput {
+    [[builtin(position)]]
+    out_position: vec4<f32>;
+    [[location(0)]]
+    f_color: vec3<f32>;
+};
+
+[[stage(vertex)]]
+fn vs_main(
+    [[location(0)]] position: vec3<f32>,
+    [[location(1)]] color: vec3<f32>,
+) -> VertexOutput {
+    var out: VertexOutput;
+    out.f_color = color;
+    out.out_position = uniforms.view_proj * vec4<f32>(position, 1.0);
+    return out;
+}
+
+
+[[stage(fragment)]]
+fn fs_main(
+    in: VertexOutput
+) -> [[location(0)]] vec4<f32> {
+    return vec4<f32>(in.f_color, 1.0);
+}