got a good obj file, finally

resources/texture-test-1.mtl

@@ -0,0 +1,13 @@
+# Blender MTL File: 'None'
+# Material Count: 1
+
+newmtl Material.002
+Ns 225.000000
+Ka 1.000000 1.000000 1.000000
+Kd 0.800000 0.800000 0.800000
+Ks 0.500000 0.500000 0.500000
+Ke 0.000000 0.000000 0.000000
+Ni 1.450000
+d 1.000000
+illum 2
+map_Kd /Users/mitchellhansen/source/minimum-viable-game-engine/resources/test.jpg

resources/texture-test-1.obj

@@ -0,0 +1,18 @@
+# Blender v2.93.1 OBJ File: ''
+# www.blender.org
+mtllib texture-test-1.mtl
+o Plane_Plane.001
+v -1.000000 0.000000 1.000000
+v 1.000000 0.000000 1.000000
+v -1.000000 0.000000 -1.000000
+v 1.000000 0.000000 -1.000000
+vt 1.000000 0.000000
+vt 0.000000 1.000000
+vt 0.000000 0.000000
+vt 1.000000 1.000000
+vn 0.0000 1.0000 0.0000
+g Plane_Plane.001_Material.002
+usemtl Material.002
+s off
+f 2/1/1 3/2/1 1/3/1
+f 2/1/1 4/4/1 3/2/1

src/geometry.rs

@@ -58,6 +58,11 @@ pub fn load_obj(obj_path: &str) -> Result<RawMesh, String> {
     for model in models {
         let mesh = &model.mesh;
 
+        if let Some(mat_id) = mesh.material_id {
+            let mat : &Material = materials.get(mat_id).unwrap();
+            println!("{:?}", mat);
+        }
+
         // Cycle through the faces and chunk out the indices
         let mut next_face = 0;
         for f in 0..mesh.num_face_indices.len() {

src/render/state.rs

@@ -290,11 +290,6 @@ impl RenderState {
                 }],
             });
 
-        /*
-        There appear to be two passes required for shadows, the shadow pass, and the forward pass
-        Need to open this up in renderdoc and see what it's actually doing
-         */
-
         let shadow_pass = {
             let uniform_size = mem::size_of::<ShadowUniforms>() as wgpu::BufferAddress;
 

src/runtime/state.rs

@@ -111,5 +111,7 @@ impl RuntimeState {
                 self.mesh_cache.insert(filename, mesh);
             }
         }
+
+        panic!("nah");
     }
 }

src/runtime/system.rs

@@ -127,59 +127,59 @@ pub fn runtime_spawn(
 ) {
     for entity in &runtime_state.get_entities() {
         match entity.type_name.as_ref() {
-            "Sprite" => {
+            // "Sprite" => {
-
+            //
-
+            //
-
+            //
-                let mesh_name = entity.mesh.clone().unwrap();
+            //     let mesh_name = entity.mesh.clone().unwrap();
-                let raw_mesh = match runtime_state.get_mesh(mesh_name.as_str()) {
+            //     let raw_mesh = match runtime_state.get_mesh(mesh_name.as_str()) {
-                    None => {
+            //         None => {
-                        log::warn!("Skipping entity with invalid mesh file {:?} ", mesh_name);
+            //             log::warn!("Skipping entity with invalid mesh file {:?} ", mesh_name);
-                        continue;
+            //             continue;
-                    }
+            //         }
-                    Some(mesh) => mesh,
+            //         Some(mesh) => mesh,
-                };
+            //     };
-
+            //
-                let position = Position::from(entity.position.clone());
+            //     let position = Position::from(entity.position.clone());
-
+            //
-                let mut static_body = RigidBodyBuilder::new_static()
+            //     let mut static_body = RigidBodyBuilder::new_static()
-                    .position(Isometry3::new(
+            //         .position(Isometry3::new(
-                        Vector3::new(position.x, position.y, position.z),
+            //             Vector3::new(position.x, position.y, position.z),
-                        Vector::y(),
+            //             Vector::y(),
-                    ))
+            //         ))
-                    .build();
+            //         .build();
-
+            //
-                let mesh_collider = ColliderBuilder::trimesh(
+            //     let mesh_collider = ColliderBuilder::trimesh(
-                    raw_mesh.vertices.iter().map(|v| v.position()).collect(),
+            //         raw_mesh.vertices.iter().map(|v| v.position()).collect(),
-                    raw_mesh.indices.clone(),
+            //         raw_mesh.indices.clone(),
-                )
+            //     )
-                    .build();
+            //         .build();
-
+            //
-                let gpu_mesh_buffer = renderer
+            //     let gpu_mesh_buffer = renderer
-                    .upload_mesh_to_buffer(
+            //         .upload_mesh_to_buffer(
-                        raw_mesh,
+            //             raw_mesh,
-                        Some(wgpu::Color {
+            //             Some(wgpu::Color {
-                            r: 1.0,
+            //                 r: 1.0,
-                            g: 0.7,
+            //                 g: 0.7,
-                            b: 0.3,
+            //                 b: 0.3,
-                            a: 1.0,
+            //                 a: 1.0,
-                        }),
+            //             }),
-                    )
+            //         )
-                    .unwrap();
+            //         .unwrap();
-
+            //
-                let entity: Entity = cmd.push((
+            //     let entity: Entity = cmd.push((
-                    position,
+            //         position,
-                    gpu_mesh_buffer,
+            //         gpu_mesh_buffer,
-                    Physics {
+            //         Physics {
-                        rigid_body: static_body,
+            //             rigid_body: static_body,
-                        rigid_body_handle: None,
+            //             rigid_body_handle: None,
-                    },
+            //         },
-                    Collider {
+            //         Collider {
-                        collider: mesh_collider,
+            //             collider: mesh_collider,
-                        collider_handle: None,
+            //             collider_handle: None,
-                    },
+            //         },
-                ));
+            //     ));
-            }
+            // }
             "PhysicsEntity" => {
                 let mesh_name = entity.mesh.as_ref().unwrap();
                 let raw_mesh = match runtime_state.get_mesh(mesh_name.as_str()) {