fake IBSP

I disliked how if Some else None repeated twice looked, but I'm not sure if this is better

Cargo.lock

@@ -92,6 +92,15 @@ version = "0.3.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6b4930d2cb77ce62f89ee5d5289b4ac049559b1c45539271f5ed4fdc7db34545"
 
+[[package]]
+name = "arrayvec"
+version = "0.4.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cd9fd44efafa8690358b7408d253adf110036b88f55672a933f01d616ad9b1b9"
+dependencies = [
+ "nodrop",
+]
+
 [[package]]
 name = "arrayvec"
 version = "0.7.4"
@@ -197,7 +206,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "199c42ab6972d92c9f8995f086273d25c42fc0f7b2a1fcefba465c1352d25ba5"
 dependencies = [
  "arrayref",
- "arrayvec",
+ "arrayvec 0.7.4",
  "cc",
  "cfg-if",
  "constant_time_eq",
@@ -238,12 +247,33 @@ dependencies = [
  "objc2-encode",
 ]
 
+[[package]]
+name = "bsp"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b9d6d699bcff31f0c8a5951d29b9a7edfe3270218c20f6c3509f90ae7e1c46e7"
+dependencies = [
+ "arrayvec 0.4.12",
+ "bitflags 1.3.2",
+ "bv",
+ "byteorder 0.5.3",
+]
+
 [[package]]
 name = "bumpalo"
 version = "3.13.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a3e2c3daef883ecc1b5d58c15adae93470a91d425f3532ba1695849656af3fc1"
 
+[[package]]
+name = "bv"
+version = "0.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8834bb1d8ee5dc048ee3124f2c7c1afcc6bc9aed03f11e9dfd8c69470a5db340"
+dependencies = [
+ "feature-probe",
+]
+
 [[package]]
 name = "bytemuck"
 version = "1.13.1"
@@ -264,6 +294,12 @@ dependencies = [
  "syn 2.0.29",
 ]
 
+[[package]]
+name = "byteorder"
+version = "0.5.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0fc10e8cc6b2580fda3f36eb6dc5316657f812a3df879a44a66fc9f0fdbc4855"
+
 [[package]]
 name = "byteorder"
 version = "1.4.3"
@@ -423,7 +459,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "594ecd967c2f40db5dde8da4c356975fc1fe030e951c7c3962f6dc2e80042e87"
 dependencies = [
  "bitflags 1.3.2",
- "byteorder",
+ "byteorder 1.4.3",
  "enum_primitive",
 ]
 
@@ -532,6 +568,12 @@ dependencies = [
  "simd-adler32",
 ]
 
+[[package]]
+name = "feature-probe"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "835a3dc7d1ec9e75e2b5fb4ba75396837112d2060b03f7d43bc1897c7f7211da"
+
 [[package]]
 name = "flate2"
 version = "1.0.27"
@@ -1058,6 +1100,12 @@ dependencies = [
  "memoffset",
 ]
 
+[[package]]
+name = "nodrop"
+version = "0.1.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72ef4a56884ca558e5ddb05a1d1e7e1bfd9a68d9ed024c21704cc98872dae1bb"
+
 [[package]]
 name = "nom"
 version = "7.1.3"
@@ -1506,7 +1554,7 @@ version = "0.8.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7f9860a6cc38ed1da53456442089b4dfa35e7cedaa326df63017af88385e6b20"
 dependencies = [
- "byteorder",
+ "byteorder 1.4.3",
  "num-traits 0.2.16",
  "paste",
 ]
@@ -1517,7 +1565,7 @@ version = "1.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bffea85eea980d8a74453e5d02a8d93028f3c34725de143085a844ebe953258a"
 dependencies = [
- "byteorder",
+ "byteorder 1.4.3",
  "rmp",
  "serde",
 ]
@@ -1659,9 +1707,10 @@ checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
 
 [[package]]
 name = "strafe-client"
-version = "0.6.0"
+version = "0.7.0"
 dependencies = [
  "async-executor",
+ "bsp",
  "bytemuck",
  "ddsfile",
  "env_logger",
@@ -1748,7 +1797,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "df8493a203431061e901613751931f047d1971337153f96d0e5e363d6dbf6a67"
 dependencies = [
  "arrayref",
- "arrayvec",
+ "arrayvec 0.7.4",
  "bytemuck",
  "cfg-if",
  "png",
@@ -1992,7 +2041,7 @@ version = "0.17.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7472f3b69449a8ae073f6ec41d05b6f846902d92a6c45313c50cb25857b736ce"
 dependencies = [
- "arrayvec",
+ "arrayvec 0.7.4",
  "cfg-if",
  "js-sys",
  "log",
@@ -2016,7 +2065,7 @@ version = "0.17.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ecf7454d9386f602f7399225c92dd2fbdcde52c519bc8fb0bd6fbeb388075dc2"
 dependencies = [
- "arrayvec",
+ "arrayvec 0.7.4",
  "bit-vec",
  "bitflags 2.4.0",
  "codespan-reporting",
@@ -2040,7 +2089,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6654a13885a17f475e8324efb46dc6986d7aaaa98353330f8de2077b153d0101"
 dependencies = [
  "android_system_properties",
- "arrayvec",
+ "arrayvec 0.7.4",
  "ash",
  "bit-set",
  "bitflags 2.4.0",

Cargo.toml

@@ -1,12 +1,13 @@
 [package]
 name = "strafe-client"
-version = "0.6.0"
+version = "0.7.0"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
 async-executor = "1.5.1"
+bsp = "0.1.2"
 bytemuck = { version = "1.13.1", features = ["derive"] }
 ddsfile = "0.5.1"
 env_logger = "0.10.0"

src/body.rs

@@ -29,6 +29,10 @@ pub enum InputInstruction {
 	Jump(bool),
 	Zoom(bool),
 	Reset,
+	Idle,
+		//Idle: there were no input events, but the simulation is safe to advance to this timestep
+		//for interpolation / networking / playback reasons, most playback heads will always want
+		//to be 1 instruction ahead to generate the next state for interpolation.
 }
 
 pub struct Body {
@@ -189,20 +193,20 @@ impl Camera {
 		    offset,
 		    angles: glam::DVec2::ZERO,
 		    fov: glam::vec2(aspect,1.0),
-		    sensitivity: glam::dvec2(1.0/4096.0,1.0/4096.0),
+		    sensitivity: glam::dvec2(1.0/6144.0,1.0/6144.0),
     		time: 0,
 		}
 	}
 	fn simulate_move_angles(&self, delta: glam::IVec2) -> glam::DVec2 {
 		let mut a=self.angles-self.sensitivity*delta.as_dvec2();
-		a.y=a.y.clamp(-std::f64::consts::PI, std::f64::consts::PI);
+		a.y=a.y.clamp(-std::f64::consts::FRAC_PI_2, std::f64::consts::FRAC_PI_2);
 		return a
 	}
 	fn simulate_move_rotation_y(&self, delta_x: i32) -> glam::Mat3 {
 		mat3_from_rotation_y_f64(self.angles.x-self.sensitivity.x*(delta_x as f64))
 	}
 	pub fn proj(&self)->glam::Mat4{
-		perspective_rh(self.fov.x, self.fov.y, 0.5, 1000.0)
+		perspective_rh(self.fov.x, self.fov.y, 0.5, 2000.0)
 	}
 	pub fn view(&self,pos:glam::Vec3)->glam::Mat4{
 		//f32 good enough for view matrix
@@ -972,63 +976,50 @@ impl crate::instruction::InstructionConsumer<PhysicsInstruction> for PhysicsStat
 				self.walk.state=WalkEnum::Reached;
 			},
 			PhysicsInstruction::Input(input_instruction) => {
-				let mut refresh_walk_target=false;
+				let mut refresh_walk_target=true;
+				let mut refresh_walk_target_velocity=true;
 				match input_instruction{
 					InputInstruction::MoveMouse(m) => {
 						self.camera.angles=self.camera.simulate_move_angles(self.mouse_interpolation.mouse1-self.mouse_interpolation.mouse0);
 						self.mouse_interpolation.move_mouse(self.time,m);
-						refresh_walk_target=true;
-					},
-					InputInstruction::MoveForward(s) => {
-						self.set_control(CONTROL_MOVEFORWARD,s);
-						refresh_walk_target=true;
-					},
-					InputInstruction::MoveLeft(s) => {
-						self.set_control(CONTROL_MOVELEFT,s);
-						refresh_walk_target=true;
-					},
-					InputInstruction::MoveBack(s) => {
-						self.set_control(CONTROL_MOVEBACK,s);
-						refresh_walk_target=true;
-					},
-					InputInstruction::MoveRight(s) => {
-						self.set_control(CONTROL_MOVERIGHT,s);
-						refresh_walk_target=true;
-					},
-					InputInstruction::MoveUp(s) => {
-						self.set_control(CONTROL_MOVEUP,s);
-						refresh_walk_target=true;
-					},
-					InputInstruction::MoveDown(s) => {
-						self.set_control(CONTROL_MOVEDOWN,s);
-						refresh_walk_target=true;
 					},
+					InputInstruction::MoveForward(s) => self.set_control(CONTROL_MOVEFORWARD,s),
+					InputInstruction::MoveLeft(s) => self.set_control(CONTROL_MOVELEFT,s),
+					InputInstruction::MoveBack(s) => self.set_control(CONTROL_MOVEBACK,s),
+					InputInstruction::MoveRight(s) => self.set_control(CONTROL_MOVERIGHT,s),
+					InputInstruction::MoveUp(s) => self.set_control(CONTROL_MOVEUP,s),
+					InputInstruction::MoveDown(s) => self.set_control(CONTROL_MOVEDOWN,s),
 					InputInstruction::Jump(s) => {
 						self.set_control(CONTROL_JUMP,s);
-						refresh_walk_target=true;
 						if self.grounded{
 							self.jump();
 						}
+						refresh_walk_target_velocity=false;
 					},
 					InputInstruction::Zoom(s) => {
 						self.set_control(CONTROL_ZOOM,s);
+						refresh_walk_target=false;
 					},
 					InputInstruction::Reset => {
 						//temp
 						self.body.position=self.spawn_point;
+						self.body.velocity=glam::Vec3::ZERO;
 						//manual clear //for c in self.contacts{process_instruction(CollisionEnd(c))}
 						self.contacts.clear();
 						self.body.acceleration=self.gravity;
 						self.walk.state=WalkEnum::Reached;
 						self.grounded=false;
+						refresh_walk_target=false;
 					},
+					InputInstruction::Idle => {refresh_walk_target=false;},//literally idle!
 				}
-				//calculate control dir
-				let camera_mat=self.camera.simulate_move_rotation_y(self.mouse_interpolation.interpolated_position(self.time).x-self.mouse_interpolation.mouse0.x);
-				let control_dir=camera_mat*get_control_dir(self.controls);
-				//calculate walk target velocity
 				if refresh_walk_target{
-					self.walk.target_velocity=self.walkspeed*control_dir;
+					//calculate walk target velocity
+					if refresh_walk_target_velocity{
+						let camera_mat=self.camera.simulate_move_rotation_y(self.mouse_interpolation.interpolated_position(self.time).x-self.mouse_interpolation.mouse0.x);
+						let control_dir=camera_mat*get_control_dir(self.controls);
+						self.walk.target_velocity=self.walkspeed*control_dir;
+					}
 					self.refresh_walk_target();
 				}
 			},

src/framework.rs

@@ -51,8 +51,9 @@ pub trait Example: 'static + Sized {
 		device: &wgpu::Device,
 		queue: &wgpu::Queue,
 	);
-	fn update(&mut self, device: &wgpu::Device, queue: &wgpu::Queue, event: WindowEvent);
-	fn device_event(&mut self, event: DeviceEvent);
+	fn update(&mut self, window: &winit::window::Window, device: &wgpu::Device, queue: &wgpu::Queue, event: WindowEvent);
+	fn device_event(&mut self, window: &winit::window::Window, event: DeviceEvent);
+	fn load_file(&mut self, path:std::path::PathBuf, device: &wgpu::Device, queue: &wgpu::Queue);
 	fn render(
 		&mut self,
 		view: &wgpu::TextureView,
@@ -367,14 +368,14 @@ fn start<E: Example>(
 					println!("{:#?}", instance.generate_report());
 				}
 				_ => {
-					example.update(&device,&queue,event);
+					example.update(&window,&device,&queue,event);
 				}
 			},
 			event::Event::DeviceEvent {
 				event,
 				..
 			} => {
-				example.device_event(event);
+				example.device_event(&window,event);
 			},
 			event::Event::RedrawRequested(_) => {
 

src/load_bsp.rs

@@ -0,0 +1,16 @@
+pub fn generate_indexed_models<R:std::io::Read+std::io::Seek>(input:R) -> crate::model::IndexedModelInstances{
+	let mut spawn_point=glam::Vec3::ZERO;
+
+	let mut indexed_models=Vec::new();
+
+	match bsp::Bsp::read(input){
+		Ok(guac)=>println!("we got the guac {:?}", guac),
+		Err(e)=>println!("rotten {:?}",e),
+	}
+
+	crate::model::IndexedModelInstances{
+		textures:Vec::new(),
+		models:indexed_models,
+		spawn_point,
+	}
+}

src/load_roblox.rs

@@ -1,5 +1,3 @@
-use crate::model::{IndexedModelInstances,ModelInstance};
-
 use crate::primitives;
 
 fn class_is_a(class: &str, superclass: &str) -> bool {
@@ -86,14 +84,32 @@ impl std::hash::Hash for RobloxFaceTextureDescription {
         }
     }
 }
+impl RobloxFaceTextureDescription{
+	fn to_face_description(&self)->primitives::FaceDescription{
+		primitives::FaceDescription{
+			texture:Some(self.texture),
+			transform:glam::Affine2::from_translation(
+				glam::vec2(self.transform.offset_u,self.transform.offset_v)
+			)
+			*glam::Affine2::from_scale(
+				glam::vec2(self.transform.scale_u,self.transform.scale_v)
+			),
+			color:self.color,
+		}
+	}
+}
 type RobloxPartDescription=[Option<RobloxFaceTextureDescription>;6];
-//type RobloxWedgeDescription=[Option<RobloxFaceTextureDescription>;5];
+type RobloxWedgeDescription=[Option<RobloxFaceTextureDescription>;5];
+type RobloxCornerWedgeDescription=[Option<RobloxFaceTextureDescription>;4];
 #[derive(Clone,Eq,Hash,PartialEq)]
 enum RobloxBasePartDescription{
+	Sphere,
 	Part(RobloxPartDescription),
-	//Wedge(RobloxWedgeDescription),
+	Cylinder,
+	Wedge(RobloxWedgeDescription),
+	CornerWedge(RobloxCornerWedgeDescription),
 }
-pub fn generate_indexed_models_roblox(dom:rbx_dom_weak::WeakDom) -> Result<(IndexedModelInstances,glam::Vec3), Box<dyn std::error::Error>>{
+pub fn generate_indexed_models(dom:rbx_dom_weak::WeakDom) -> crate::model::IndexedModelInstances{
 	//IndexedModelInstances includes textures
 	let mut spawn_point=glam::Vec3::ZERO;
 
@@ -113,13 +129,11 @@ pub fn generate_indexed_models_roblox(dom:rbx_dom_weak::WeakDom) -> Result<(Inde
 					Some(rbx_dom_weak::types::Variant::Vector3(size)),
 					Some(rbx_dom_weak::types::Variant::Float32(transparency)),
 					Some(rbx_dom_weak::types::Variant::Color3uint8(color3)),
-					Some(rbx_dom_weak::types::Variant::Enum(shape)),
 				) = (
 					object.properties.get("CFrame"),
 					object.properties.get("Size"),
 					object.properties.get("Transparency"),
 					object.properties.get("Color"),
-					object.properties.get("Shape"),//this will also skip unions
 				)
 			{
 				let model_transform=glam::Affine3A::from_translation(
@@ -139,13 +153,38 @@ pub fn generate_indexed_models_roblox(dom:rbx_dom_weak::WeakDom) -> Result<(Inde
 					spawn_point=model_transform.transform_point3(glam::Vec3::Y)+glam::vec3(0.0,2.5,0.0);
 					println!("Found MapStart{:?}",spawn_point);
 				}
-				if *transparency==1.0||shape.to_u32()!=1 {
+				if *transparency==1.0 {
 					continue;
 				}
+
+				//TODO: also detect "CylinderMesh" etc here
+				let shape=match &object.class[..]{
+					"Part"=>{
+						if let Some(rbx_dom_weak::types::Variant::Enum(shape))=object.properties.get("Shape"){
+							match shape.to_u32(){
+								0=>primitives::Primitives::Sphere,
+								1=>primitives::Primitives::Cube,
+								2=>primitives::Primitives::Cylinder,
+								3=>primitives::Primitives::Wedge,
+								4=>primitives::Primitives::CornerWedge,
+								_=>panic!("Funky roblox PartType={};",shape.to_u32()),
+							}
+						}else{
+							panic!("Part has no Shape!");
+						}
+					},
+					"WedgePart"=>primitives::Primitives::Wedge,
+					"CornerWedgePart"=>primitives::Primitives::CornerWedge,
+					_=>{
+						println!("Unsupported BasePart ClassName={}; defaulting to cube",object.class);
+						primitives::Primitives::Cube
+					}
+				};
+
+				//use the biggest one and cut it down later...
+				let mut part_texture_description:RobloxPartDescription=[None,None,None,None,None,None];
 				temp_objects.clear();
 				recursive_collect_superclass(&mut temp_objects, &dom, object,"Decal");
-
-				let mut part_texture_description:RobloxPartDescription=[None,None,None,None,None,None];
 				for &decal_ref in &temp_objects{
 					if let Some(decal)=dom.get_by_ref(decal_ref){
 						if let (
@@ -168,8 +207,8 @@ pub fn generate_indexed_models_roblox(dom:rbx_dom_weak::WeakDom) -> Result<(Inde
 									asset_id_from_texture_id.push(asset_id.0);
 									texture_id
 								};
-								let face=normalid.to_u32();
-								if face<6{
+								let normal_id=normalid.to_u32();
+								if normal_id<6{
 									let mut roblox_texture_transform=RobloxTextureTransform::default();
 									let mut roblox_texture_color=glam::Vec4::ONE;
 									if decal.class=="Texture"{
@@ -186,14 +225,14 @@ pub fn generate_indexed_models_roblox(dom:rbx_dom_weak::WeakDom) -> Result<(Inde
 												decal.properties.get("StudsPerTileV"),
 											)
 										{
-											let (size_u,size_v)=match face{
+											let (size_u,size_v)=match normal_id{
 												0=>(size.z,size.y),//right
 												1=>(size.x,size.z),//top
 												2=>(size.x,size.y),//back
 												3=>(size.z,size.y),//left
 												4=>(size.x,size.z),//bottom
 												5=>(size.x,size.y),//front
-												_=>(1.,1.),
+												_=>panic!("unreachable"),
 											};
 											roblox_texture_transform=RobloxTextureTransform{
 												offset_u:*ox/(*sx),offset_v:*oy/(*sy),
@@ -202,61 +241,108 @@ pub fn generate_indexed_models_roblox(dom:rbx_dom_weak::WeakDom) -> Result<(Inde
 											roblox_texture_color=glam::vec4(decal_color3.r,decal_color3.g,decal_color3.b,1.0-*decal_transparency);
 										}
 									}
-									part_texture_description[face as usize]=Some(RobloxFaceTextureDescription{
+									part_texture_description[normal_id as usize]=Some(RobloxFaceTextureDescription{
 										texture:texture_id,
 										color:roblox_texture_color,
 										transform:roblox_texture_transform,
 									});
 								}else{
-									println!("goofy ahh roblox gave NormalId {}", face);
+									println!("NormalId={} unsupported for shape={:?}",normal_id,shape);
 								}
 							}
 						}
 					}
 				}
-				//TODO: generate unit Block, Wedge, etc. based on part shape lists
-				let basepart_texture_description=RobloxBasePartDescription::Part(part_texture_description);
-				//make new model if unit cube has not been crated before
+				//obscure rust syntax "slice pattern"
+				let [f0,f1,f2,f3,f4,f5]=part_texture_description;
+				let basepart_texture_description=match shape{
+					primitives::Primitives::Sphere=>RobloxBasePartDescription::Sphere,
+					primitives::Primitives::Cube=>RobloxBasePartDescription::Part([f0,f1,f2,f3,f4,f5]),
+					primitives::Primitives::Cylinder=>RobloxBasePartDescription::Cylinder,
+					//use front face texture first and use top face texture as a fallback
+					primitives::Primitives::Wedge=>RobloxBasePartDescription::Wedge([f0,if f2.is_some(){f2}else{f1},f3,f4,f5]),
+					primitives::Primitives::CornerWedge=>RobloxBasePartDescription::CornerWedge([f1,f3,f4,f5]),
+				};
+				//make new model if unit cube has not been created before
 				let model_id=if let Some(&model_id)=model_id_from_description.get(&basepart_texture_description){
 					//push to existing texture model
 					model_id
 				}else{
 					let model_id=indexed_models.len();
 					model_id_from_description.insert(basepart_texture_description.clone(),model_id);//borrow checker going crazy
-					match basepart_texture_description{
+					indexed_models.push(match basepart_texture_description{
+						RobloxBasePartDescription::Sphere=>primitives::unit_sphere(),
 						RobloxBasePartDescription::Part(part_texture_description)=>{
-							let unit_cube_faces=part_texture_description.map(|face|{
-								match face{
-									Some(roblox_texture_transform)=>Some(
-										primitives::FaceDescription{
-											texture:Some(roblox_texture_transform.texture),
-											transform:glam::Affine2::from_translation(
-												glam::vec2(roblox_texture_transform.transform.offset_u,roblox_texture_transform.transform.offset_v)
-											)
-											*glam::Affine2::from_scale(
-												glam::vec2(roblox_texture_transform.transform.scale_u,roblox_texture_transform.transform.scale_v)
-											),
-											color:roblox_texture_transform.color,
-										}
-									),
-									None=>Some(primitives::FaceDescription::default()),
-								}
-							});
-							let indexed_model=primitives::generate_partial_unit_cube(unit_cube_faces);
-							indexed_models.push(indexed_model);
-							model_id
+							let mut cube_face_description=primitives::CubeFaceDescription::new();
+							for (face_id,roblox_face_description) in part_texture_description.iter().enumerate(){
+								cube_face_description.insert(
+								match face_id{
+									0=>primitives::CubeFace::Right,
+									1=>primitives::CubeFace::Top,
+									2=>primitives::CubeFace::Back,
+									3=>primitives::CubeFace::Left,
+									4=>primitives::CubeFace::Bottom,
+									5=>primitives::CubeFace::Front,
+									_=>panic!("unreachable"),
+								},
+								match roblox_face_description{
+									Some(roblox_texture_transform)=>roblox_texture_transform.to_face_description(),
+									None=>primitives::FaceDescription::default(),
+								});
+							}
+							primitives::generate_partial_unit_cube(cube_face_description)
 						},
-					}
+						RobloxBasePartDescription::Cylinder=>primitives::unit_cylinder(),
+						RobloxBasePartDescription::Wedge(wedge_texture_description)=>{
+							let mut wedge_face_description=primitives::WedgeFaceDescription::new();
+							for (face_id,roblox_face_description) in wedge_texture_description.iter().enumerate(){
+								wedge_face_description.insert(
+								match face_id{
+									0=>primitives::WedgeFace::Right,
+									1=>primitives::WedgeFace::TopFront,
+									2=>primitives::WedgeFace::Back,
+									3=>primitives::WedgeFace::Left,
+									4=>primitives::WedgeFace::Bottom,
+									_=>panic!("unreachable"),
+								},
+								match roblox_face_description{
+									Some(roblox_texture_transform)=>roblox_texture_transform.to_face_description(),
+									None=>primitives::FaceDescription::default(),
+								});
+							}
+							primitives::generate_partial_unit_wedge(wedge_face_description)
+						},
+						RobloxBasePartDescription::CornerWedge(cornerwedge_texture_description)=>{
+							let mut cornerwedge_face_description=primitives::CornerWedgeFaceDescription::new();
+							for (face_id,roblox_face_description) in cornerwedge_texture_description.iter().enumerate(){
+								cornerwedge_face_description.insert(
+								match face_id{
+									0=>primitives::CornerWedgeFace::Top,
+									1=>primitives::CornerWedgeFace::Right,
+									2=>primitives::CornerWedgeFace::Bottom,
+									3=>primitives::CornerWedgeFace::Front,
+									_=>panic!("unreachable"),
+								},
+								match roblox_face_description{
+									Some(roblox_texture_transform)=>roblox_texture_transform.to_face_description(),
+									None=>primitives::FaceDescription::default(),
+								});
+							}
+							primitives::generate_partial_unit_cornerwedge(cornerwedge_face_description)
+						},
+					});
+					model_id
 				};
-				indexed_models[model_id].instances.push(ModelInstance {
-					model_transform,
-					color: glam::Vec4::ONE,//glam::vec4(color3.r as f32/255f32, color3.g as f32/255f32, color3.b as f32/255f32, 1.0-*transparency),
+				indexed_models[model_id].instances.push(crate::model::ModelInstance {
+					transform:model_transform,
+					color:glam::vec4(color3.r as f32/255f32, color3.g as f32/255f32, color3.b as f32/255f32, 1.0-*transparency),
 				});
 			}
 		}
 	}
-	Ok((IndexedModelInstances{
+	crate::model::IndexedModelInstances{
 		textures:asset_id_from_texture_id.iter().map(|t|t.to_string()).collect(),
 		models:indexed_models,
-	},spawn_point))
+		spawn_point,
+	}
 }

src/main.rs

@@ -1,6 +1,6 @@
 use std::{borrow::Cow, time::Instant};
 use wgpu::{util::DeviceExt, AstcBlock, AstcChannel};
-use model::{Vertex,ModelInstance};
+use model::{Vertex,ModelInstance,ModelGraphicsInstance};
 use body::{InputInstruction, PhysicsInstruction};
 use instruction::{TimedInstruction, InstructionConsumer};
 
@@ -10,6 +10,7 @@ mod zeroes;
 mod framework;
 mod primitives;
 mod instruction;
+mod load_bsp;
 mod load_roblox;
 
 struct Entity {
@@ -18,7 +19,7 @@ struct Entity {
 }
 
 struct ModelGraphics {
-	instances: Vec<ModelInstance>,
+	instances: Vec<ModelGraphicsInstance>,
 	vertex_buf: wgpu::Buffer,
 	entities: Vec<Entity>,
 	bind_group: wgpu::BindGroup,
@@ -46,6 +47,7 @@ pub struct GraphicsPipelines {
 pub struct GraphicsData {
 	start_time: std::time::Instant,
 	screen_size: (u32, u32),
+	manual_mouse_lock:bool,
 	physics: body::PhysicsState,
 	pipelines: GraphicsPipelines,
 	bind_groups: GraphicsBindGroups,
@@ -87,7 +89,7 @@ impl GraphicsData {
 		for model in &indexed_models.models{
 			//make aabb and run vertices to get realistic bounds
 			for model_instance in &model.instances{
-				self.physics.models.push(body::ModelPhysics::from_model(&model,model_instance.model_transform));
+				self.physics.models.push(body::ModelPhysics::from_model(&model,model_instance.transform));
 			}
 		}
 		println!("Physics Objects: {}",self.physics.models.len());
@@ -97,50 +99,79 @@ impl GraphicsData {
 
 		//idk how to do this gooder lol
 		let mut double_map=std::collections::HashMap::<u32,u32>::new();
-		let mut texture_views:Vec<wgpu::TextureView>=Vec::with_capacity(indexed_models.textures.len());
-		for (i,t) in indexed_models.textures.iter().enumerate(){
-			if let Ok(mut file) = std::fs::File::open(std::path::Path::new(&format!("textures/{}.dds",t))){
-				let image = ddsfile::Dds::read(&mut file).unwrap();
-
-				let size = wgpu::Extent3d {
-					width: image.get_width()/4*4,//floor(w,4), should be ceil(w,4)
-					height: image.get_height()/4*4,
-					depth_or_array_layers: 1,
-				};
-
-				let layer_size = wgpu::Extent3d {
-					depth_or_array_layers: 1,
-					..size
-				};
-				let max_mips = layer_size.max_mips(wgpu::TextureDimension::D2);
-
-				let texture = device.create_texture_with_data(
-					queue,
-					&wgpu::TextureDescriptor {
-						size,
-						mip_level_count: max_mips,
-						sample_count: 1,
-						dimension: wgpu::TextureDimension::D2,
-						format: wgpu::TextureFormat::Bc7RgbaUnorm,
-						usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST,
-						label: Some(format!("Texture{}",i).as_str()),
-						view_formats: &[],
-					},
-					&image.data,
-				);
-
-				double_map.insert(i as u32, texture_views.len() as u32);
-				texture_views.push(texture.create_view(&wgpu::TextureViewDescriptor {
-					label: Some(format!("Texture{} View",i).as_str()),
-					dimension: Some(wgpu::TextureViewDimension::D2),
-					..wgpu::TextureViewDescriptor::default()
-				}));
+		let mut texture_loading_threads=Vec::new();
+		let num_textures=indexed_models.textures.len();
+		for (i,texture_id) in indexed_models.textures.into_iter().enumerate(){
+			if let Ok(mut file) = std::fs::File::open(std::path::Path::new(&format!("textures/{}.dds",texture_id))){
+				double_map.insert(i as u32, texture_loading_threads.len() as u32);
+				texture_loading_threads.push((texture_id,std::thread::spawn(move ||{
+					ddsfile::Dds::read(&mut file).unwrap()
+				})));
 			}
 		}
-		//de-index models and split groups with different textures into separate models
+
+		let texture_views:Vec<wgpu::TextureView>=texture_loading_threads.into_iter().map(|(texture_id,thread)|{
+			let image=thread.join().unwrap();
+
+			let (mut width,mut height)=(image.get_width(),image.get_height());
+
+			let format=match image.header10.unwrap().dxgi_format{
+				ddsfile::DxgiFormat::R8G8B8A8_UNorm_sRGB => wgpu::TextureFormat::Rgba8UnormSrgb,
+				ddsfile::DxgiFormat::BC7_UNorm_sRGB => {
+					//floor(w,4), should be ceil(w,4)
+					width=width/4*4;
+					height=height/4*4;
+					wgpu::TextureFormat::Bc7RgbaUnormSrgb
+				},
+				other=>panic!("unsupported format {:?}",other),
+			};
+
+			let size = wgpu::Extent3d {
+				width,
+				height,
+				depth_or_array_layers: 1,
+			};
+
+			let layer_size = wgpu::Extent3d {
+				depth_or_array_layers: 1,
+				..size
+			};
+			let max_mips = layer_size.max_mips(wgpu::TextureDimension::D2);
+
+			let texture = device.create_texture_with_data(
+				queue,
+				&wgpu::TextureDescriptor {
+					size,
+					mip_level_count: max_mips,
+					sample_count: 1,
+					dimension: wgpu::TextureDimension::D2,
+					format,
+					usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST,
+					label: Some(format!("Texture{}",texture_id).as_str()),
+					view_formats: &[],
+				},
+				&image.data,
+			);
+			texture.create_view(&wgpu::TextureViewDescriptor {
+				label: Some(format!("Texture{} View",texture_id).as_str()),
+				dimension: Some(wgpu::TextureViewDimension::D2),
+				..wgpu::TextureViewDescriptor::default()
+			})
+		}).collect();
+
+		//split groups with different textures into separate models
 		//the models received here are supposed to be tightly packed, i.e. no code needs to check if two models are using the same groups.
-		let mut unique_texture_models=Vec::with_capacity(indexed_models.models.len());
-		for mut model in indexed_models.models.drain(..){
+		let indexed_models_len=indexed_models.models.len();
+		let mut unique_texture_models=Vec::with_capacity(indexed_models_len);
+		for mut model in indexed_models.models.into_iter(){
+			//convert ModelInstance into ModelGraphicsInstance
+			let instances:Vec<ModelGraphicsInstance>=model.instances.iter().map(|instance|{
+				ModelGraphicsInstance{
+					transform: glam::Mat4::from(instance.transform),
+					normal_transform: glam::Mat4::from(instance.transform.inverse()).transpose(),
+					color: instance.color,
+				}
+			}).collect();
 			//check each group, if it's using a new texture then make a new clone of the model
 			let id=unique_texture_models.len();
 			let mut unique_textures=Vec::new();
@@ -160,7 +191,7 @@ impl GraphicsData {
 						unique_vertices:model.unique_vertices.clone(),
 						texture:group.texture,
 						groups:Vec::new(),
-						instances:model.instances.clone(),
+						instances:instances.clone(),
 					});
 					texture_index
 				};
@@ -169,11 +200,13 @@ impl GraphicsData {
 				});
 			}
 		}
+		//de-index models
 		let mut models=Vec::with_capacity(unique_texture_models.len());
-		for model in unique_texture_models.drain(..){
+		for model in unique_texture_models.into_iter(){
 			let mut vertices = Vec::new();
 			let mut index_from_vertex = std::collections::HashMap::new();//::<IndexedVertex,usize>
 			let mut entities = Vec::new();
+			//TODO: combine groups using the same render pattern
 			for group in model.groups {
 				let mut indices = Vec::new();
 				for poly in group.polys {
@@ -212,7 +245,7 @@ impl GraphicsData {
 		let uniform_buffer_binding_size=<GraphicsData as framework::Example>::required_limits().max_uniform_buffer_binding_size as usize;
 		let chunk_size=uniform_buffer_binding_size/MODEL_BUFFER_SIZE_BYTES;
 		self.models.reserve(models.len());
-		for model in models.drain(..) {
+		for model in models.into_iter() {
 			instance_count+=model.instances.len();
 			for instances_chunk in model.instances.rchunks(chunk_size){
 				model_count+=1;
@@ -274,19 +307,24 @@ impl GraphicsData {
 				});
 			}
 		}
+		println!("Texture References={}",num_textures);
+		println!("Textures Loaded={}",texture_views.len());
+		println!("Indexed Models={}",indexed_models_len);
 		println!("Graphics Objects: {}",self.models.len());
 		println!("Graphics Instances: {}",instance_count);
 	}
 }
 
-const MODEL_BUFFER_SIZE:usize=4*4 + 4;//let size=std::mem::size_of::<ModelInstance>();
+const MODEL_BUFFER_SIZE:usize=4*4 + 4*4 + 4;//let size=std::mem::size_of::<ModelInstance>();
 const MODEL_BUFFER_SIZE_BYTES:usize=MODEL_BUFFER_SIZE*4;
-fn get_instances_buffer_data(instances:&[ModelInstance]) -> Vec<f32> {
+fn get_instances_buffer_data(instances:&[ModelGraphicsInstance]) -> Vec<f32> {
 	let mut raw = Vec::with_capacity(MODEL_BUFFER_SIZE*instances.len());
 	for (i,mi) in instances.iter().enumerate(){
     	let mut v = raw.split_off(MODEL_BUFFER_SIZE*i);
-    	//model_transform
-    	raw.extend_from_slice(&AsRef::<[f32; 4*4]>::as_ref(&glam::Mat4::from(mi.model_transform))[..]);
+    	//model transform
+    	raw.extend_from_slice(&AsRef::<[f32; 4*4]>::as_ref(&mi.transform)[..]);
+    	//normal transform
+    	raw.extend_from_slice(&AsRef::<[f32; 4*4]>::as_ref(&mi.normal_transform)[..]);
     	//color
     	raw.extend_from_slice(AsRef::<[f32; 4]>::as_ref(&mi.color));
     	raw.append(&mut v);
@@ -327,39 +365,39 @@ impl framework::Example for GraphicsData {
 	) -> Self {
 		let mut indexed_models = Vec::new();
 		indexed_models.append(&mut model::generate_indexed_model_list_from_obj(obj::ObjData::load_buf(&include_bytes!("../models/teslacyberv3.0.obj")[..]).unwrap(),*glam::Vec4::ONE.as_ref()));
-		indexed_models.append(&mut model::generate_indexed_model_list_from_obj(obj::ObjData::load_buf(&include_bytes!("../models/suzanne.obj")[..]).unwrap(),*glam::Vec4::ONE.as_ref()));
-		indexed_models.append(&mut model::generate_indexed_model_list_from_obj(obj::ObjData::load_buf(&include_bytes!("../models/teapot.obj")[..]).unwrap(),*glam::Vec4::ONE.as_ref()));
-		indexed_models.push(primitives::the_unit_cube_lol());
+		indexed_models.push(primitives::unit_sphere());
+		indexed_models.push(primitives::unit_cylinder());
+		indexed_models.push(primitives::unit_cube());
 		println!("models.len = {:?}", indexed_models.len());
 		indexed_models[0].instances.push(ModelInstance{
-			model_transform:glam::Affine3A::from_translation(glam::vec3(10.,0.,-10.)),
+			transform:glam::Affine3A::from_translation(glam::vec3(10.,0.,-10.)),
 			color:glam::Vec4::ONE,
 		});
 		//quad monkeys
 		indexed_models[1].instances.push(ModelInstance{
-			model_transform:glam::Affine3A::from_translation(glam::vec3(10.,5.,10.)),
+			transform:glam::Affine3A::from_translation(glam::vec3(10.,5.,10.)),
 			color:glam::Vec4::ONE,
 		});
 		indexed_models[1].instances.push(ModelInstance{
-			model_transform:glam::Affine3A::from_translation(glam::vec3(20.,5.,10.)),
+			transform:glam::Affine3A::from_translation(glam::vec3(20.,5.,10.)),
 			color:glam::vec4(1.0,0.0,0.0,1.0),
 		});
 		indexed_models[1].instances.push(ModelInstance{
-			model_transform:glam::Affine3A::from_translation(glam::vec3(10.,5.,20.)),
+			transform:glam::Affine3A::from_translation(glam::vec3(10.,5.,20.)),
 			color:glam::vec4(0.0,1.0,0.0,1.0),
 		});
 		indexed_models[1].instances.push(ModelInstance{
-			model_transform:glam::Affine3A::from_translation(glam::vec3(20.,5.,20.)),
+			transform:glam::Affine3A::from_translation(glam::vec3(20.,5.,20.)),
 			color:glam::vec4(0.0,0.0,1.0,1.0),
 		});
 		//teapot
 		indexed_models[2].instances.push(ModelInstance{
-			model_transform:glam::Affine3A::from_translation(glam::vec3(-10.,5.,10.)),
+			transform:glam::Affine3A::from_scale_rotation_translation(glam::vec3(0.5, 1.0, 0.2),glam::quat(-0.22248298016985793,-0.839457167990537,-0.05603504040830783,-0.49261857546227916),glam::vec3(-10.,7.,10.)),
 			color:glam::Vec4::ONE,
 		});
 		//ground
 		indexed_models[3].instances.push(ModelInstance{
-			model_transform:glam::Affine3A::from_translation(glam::vec3(0.,0.,0.))*glam::Affine3A::from_scale(glam::vec3(160.0, 1.0, 160.0)),
+			transform:glam::Affine3A::from_translation(glam::vec3(0.,0.,0.))*glam::Affine3A::from_scale(glam::vec3(160.0, 1.0, 160.0)),
 			color:glam::Vec4::ONE,
 		});
 
@@ -708,6 +746,7 @@ impl framework::Example for GraphicsData {
 		let depth_view = Self::create_depth_texture(config, device);
 
 		let mut graphics=GraphicsData {
+			manual_mouse_lock:false,
 			start_time: Instant::now(),
 			screen_size: (config.width,config.height),
 			physics,
@@ -731,80 +770,111 @@ impl framework::Example for GraphicsData {
 		let indexed_model_instances=model::IndexedModelInstances{
 			textures:Vec::new(),
 			models:indexed_models,
+			spawn_point:glam::Vec3::Y*50.0,
 		};
 		graphics.generate_model_physics(&indexed_model_instances);
 		graphics.generate_model_graphics(&device,&queue,indexed_model_instances);
 
+		let args:Vec<String>=std::env::args().collect();
+		if args.len()==2{
+			graphics.load_file(std::path::PathBuf::from(&args[1]), device, queue);
+		}
+
 		return graphics;
 	}
 
-	#[allow(clippy::single_match)]
-	fn update(&mut self, device: &wgpu::Device, queue: &wgpu::Queue, event: winit::event::WindowEvent) {
-		//nothing atm
-		match event {
-			winit::event::WindowEvent::DroppedFile(path) => {
-				println!("opening file: {:?}", &path);
-				//oh boy! let's load the map!
-				if let Ok(file)=std::fs::File::open(path){
-					let mut input = std::io::BufReader::new(file);
-					let mut first_8=[0u8;8];
-					//.rbxm roblox binary = "<roblox!"
-					//.rbxmx roblox xml = "<roblox "
-					//.bsp = "VBSP"
-					//.vmf = 
-					//.snf = "SNMF"
-					//.snf = "SNBF"
-					if let (Ok(()),Ok(()))=(std::io::Read::read_exact(&mut input, &mut first_8),std::io::Seek::rewind(&mut input)){
-						//
-						if let Some(Ok((indexed_model_instances,spawn_point)))={
-							if &first_8==b"<roblox!"{
-								if let Ok(dom) = rbx_binary::from_reader(input){
-									Some(load_roblox::generate_indexed_models_roblox(dom))
-								}else{
+	fn load_file(&mut self,path: std::path::PathBuf, device: &wgpu::Device, queue: &wgpu::Queue){
+		println!("Loading file: {:?}", &path);
+		//oh boy! let's load the map!
+		if let Ok(file)=std::fs::File::open(path){
+			let mut input = std::io::BufReader::new(file);
+			let mut first_8=[0u8;8];
+			//.rbxm roblox binary = "<roblox!"
+			//.rbxmx roblox xml = "<roblox "
+			//.bsp = "VBSP"
+			//.vmf = 
+			//.snf = "SNMF"
+			//.snf = "SNBF"
+			if let (Ok(()),Ok(()))=(std::io::Read::read_exact(&mut input, &mut first_8),std::io::Seek::rewind(&mut input)){
+				//
+				if let Some(indexed_model_instances)={
+					match &first_8[0..4]{
+						b"<rob"=>{
+							match match &first_8[4..8]{
+								b"lox!"=>rbx_binary::from_reader(input).map_err(|e|format!("{:?}",e)),
+								b"lox "=>rbx_xml::from_reader(input,rbx_xml::DecodeOptions::default()).map_err(|e|format!("{:?}",e)),
+								other=>Err(format!("Unknown Roblox file type {:?}",other)),
+							}{
+								Ok(dom)=>Some(load_roblox::generate_indexed_models(dom)),
+								Err(e)=>{
+									println!("Error loading roblox file:{:?}",e);
 									None
-								}
-							}else if &first_8==b"<roblox "{
-								if let Ok(dom) = rbx_xml::from_reader(input,rbx_xml::DecodeOptions::default()){
-									Some(load_roblox::generate_indexed_models_roblox(dom))
-								}else{
-									None
-								}
-							//}else if &first_8[0..4]==b"VBSP"{
-							//	self.generate_indexed_models_valve(input)
-							}else{
-								None
+								},
 							}
-						}{
-							//if generate_indexed_models succeeds, clear the previous ones
-							self.models.clear();
-							self.physics.models.clear();
-							self.generate_model_physics(&indexed_model_instances);
-							self.generate_model_graphics(device,queue,indexed_model_instances);
-							//manual reset
-							let time=self.physics.time;
-							instruction::InstructionConsumer::process_instruction(&mut self.physics, instruction::TimedInstruction{
-								time,
-								instruction: body::PhysicsInstruction::SetSpawnPosition(spawn_point),
-							});
-							instruction::InstructionConsumer::process_instruction(&mut self.physics, instruction::TimedInstruction{
-								time,
-								instruction: body::PhysicsInstruction::Input(body::InputInstruction::Reset),
-							});
-						}else{
-							println!("No modeldatas were generated");
-						}
-					}else{
-						println!("Failed ro read first 8 bytes and seek back to beginning of file.");
+						},
+						b"VBSP"=>{
+							let mut entire_file=Vec::new();
+							match std::io::Read::read_to_end(&mut input, &mut entire_file){
+								Ok(_)=>{
+									//haha yes this is a quake file what do you mean
+									entire_file[0]=b'I';
+									entire_file[4..8].copy_from_slice(&0x2ei32.to_le_bytes());
+									Some(load_bsp::generate_indexed_models(&mut std::io::Cursor::new(entire_file)))
+								},
+								Err(e)=>{
+									println!("Error loading \"valve\" file:{:?}",e);
+									None
+								},
+							}
+						},
+						//b"SNFM"=>Some(sniffer::generate_indexed_models(input)),
+						//b"SNFB"=>Some(sniffer::load_bot(input)),
+						other=>{
+							println!("loser file {:?}",other);
+							None
+						},
 					}
+				}{
+					let spawn_point=indexed_model_instances.spawn_point;
+					//if generate_indexed_models succeeds, clear the previous ones
+					self.models.clear();
+					self.physics.models.clear();
+					self.generate_model_physics(&indexed_model_instances);
+					self.generate_model_graphics(device,queue,indexed_model_instances);
+					//manual reset
+					let time=self.physics.time;
+					instruction::InstructionConsumer::process_instruction(&mut self.physics, instruction::TimedInstruction{
+						time,
+						instruction: body::PhysicsInstruction::SetSpawnPosition(spawn_point),
+					});
+					instruction::InstructionConsumer::process_instruction(&mut self.physics, instruction::TimedInstruction{
+						time,
+						instruction: body::PhysicsInstruction::Input(body::InputInstruction::Reset),
+					});
 				}else{
-					println!("Could not open file");
+					println!("No modeldatas were generated");
 				}
-			},
+			}else{
+				println!("Failed to read first 8 bytes and seek back to beginning of file.");
+			}
+		}else{
+			println!("Could not open file");
+		}
+	}
+
+	#[allow(clippy::single_match)]
+	fn update(&mut self, window: &winit::window::Window, device: &wgpu::Device, queue: &wgpu::Queue, event: winit::event::WindowEvent) {
+		match event {
+			winit::event::WindowEvent::DroppedFile(path) => self.load_file(path,device,queue),
+			winit::event::WindowEvent::Focused(state)=>{
+				//pause unpause
+				//recalculate pressed keys on focus
+			}
 			_=>(),
 		}
 	}
 
-	fn device_event(&mut self, event: winit::event::DeviceEvent) {
+	fn device_event(&mut self, window: &winit::window::Window, event: winit::event::DeviceEvent) {
 		//there's no way this is the best way get a timestamp.
 		let time=self.start_time.elapsed().as_nanos() as i64;
 		match event {
@@ -818,18 +888,58 @@ impl framework::Example for GraphicsData {
 					winit::event::ElementState::Released => false,
 				};
 				if let Some(input_instruction)=match keycode {
-					17 => Some(InputInstruction::MoveForward(s)),//W
-					30 => Some(InputInstruction::MoveLeft(s)),//A
-					31 => Some(InputInstruction::MoveBack(s)),//S
-					32 => Some(InputInstruction::MoveRight(s)),//D
-					18 => Some(InputInstruction::MoveUp(s)),//E
-					16 => Some(InputInstruction::MoveDown(s)),//Q
-					57 => Some(InputInstruction::Jump(s)),//Space
-					44 => Some(InputInstruction::Zoom(s)),//Z
-					19 => if s{Some(InputInstruction::Reset)}else{None},//R
-					_ => None,
-				}
-				{
+					17=>Some(InputInstruction::MoveForward(s)),//W
+					30=>Some(InputInstruction::MoveLeft(s)),//A
+					31=>Some(InputInstruction::MoveBack(s)),//S
+					32=>Some(InputInstruction::MoveRight(s)),//D
+					18=>Some(InputInstruction::MoveUp(s)),//E
+					16=>Some(InputInstruction::MoveDown(s)),//Q
+					57=>Some(InputInstruction::Jump(s)),//Space
+					44=>Some(InputInstruction::Zoom(s)),//Z
+					19=>if s{Some(InputInstruction::Reset)}else{None},//R
+					01=>{//Esc
+						if s{
+							self.manual_mouse_lock=false;
+							match window.set_cursor_grab(winit::window::CursorGrabMode::None){
+								Ok(())=>(),
+								Err(e)=>println!("Could not release cursor: {:?}",e),
+							}
+							window.set_cursor_visible(true);
+						}
+						None
+					},
+					15=>{//Tab
+						if s{
+							self.manual_mouse_lock=false;
+							match window.set_cursor_position(winit::dpi::PhysicalPosition::new(self.screen_size.0 as f32/2.0, self.screen_size.1 as f32/2.0)){
+								Ok(())=>(),
+								Err(e)=>println!("Could not set cursor position: {:?}",e),
+							}
+							match window.set_cursor_grab(winit::window::CursorGrabMode::None){
+								Ok(())=>(),
+								Err(e)=>println!("Could not release cursor: {:?}",e),
+							}
+						}else{
+							//if cursor is outside window don't lock but apparently there's no get pos function
+							//let pos=window.get_cursor_pos();
+							match window.set_cursor_grab(winit::window::CursorGrabMode::Locked){
+								Ok(())=>(),
+								Err(_)=>{
+									match window.set_cursor_grab(winit::window::CursorGrabMode::Confined){
+										Ok(())=>(),
+										Err(e)=>{
+											self.manual_mouse_lock=true;
+											println!("Could not confine cursor: {:?}",e)
+										},
+									}
+								}
+							}
+						}
+						window.set_cursor_visible(s);
+						None
+					},
+					_ => {println!("scancode {}",keycode);None},
+				}{
 					self.physics.run(time);
 					self.physics.process_instruction(TimedInstruction{
 						time,
@@ -840,6 +950,12 @@ impl framework::Example for GraphicsData {
 			winit::event::DeviceEvent::MouseMotion {
 			    delta,//these (f64,f64) are integers on my machine
 			} => {
+				if self.manual_mouse_lock{
+					match window.set_cursor_position(winit::dpi::PhysicalPosition::new(self.screen_size.0 as f32/2.0, self.screen_size.1 as f32/2.0)){
+						Ok(())=>(),
+						Err(e)=>println!("Could not set cursor position: {:?}",e),
+					}
+				}
 				//do not step the physics because the mouse polling rate is higher than the physics can run.
 				//essentially the previous input will be overwritten until a true step runs
 				//which is fine because they run all the time.
@@ -851,8 +967,8 @@ impl framework::Example for GraphicsData {
 			winit::event::DeviceEvent::MouseWheel {
 			    delta,
 			} => {
-				println!("mousewheel{:?}",delta);
-				if true{//self.physics.use_scroll
+				println!("mousewheel {:?}",delta);
+				if false{//self.physics.style.use_scroll{
 					self.physics.run(time);
 					self.physics.process_instruction(TimedInstruction{
 						time,

src/model.rs

@@ -41,23 +41,29 @@ pub struct IndexedModelSingleTexture{
 	pub unique_vertices:Vec<IndexedVertex>,
 	pub texture:Option<u32>,//RenderPattern? material/texture/shader/flat color
 	pub groups: Vec<IndexedGroupFixedTexture>,
-	pub instances:Vec<ModelInstance>,
+	pub instances:Vec<ModelGraphicsInstance>,
 }
 pub struct ModelSingleTexture{
-	pub instances: Vec<ModelInstance>,
+	pub instances: Vec<ModelGraphicsInstance>,
 	pub vertices: Vec<Vertex>,
 	pub entities: Vec<Vec<u16>>,
 	pub texture: Option<u32>,
 }
 #[derive(Clone)]
+pub struct ModelGraphicsInstance{
+	pub transform:glam::Mat4,
+	pub normal_transform:glam::Mat4,
+	pub color:glam::Vec4,
+}
 pub struct ModelInstance{
-	pub model_transform:glam::Affine3A,
+	pub transform:glam::Affine3A,
 	pub color:glam::Vec4,
 }
 pub struct IndexedModelInstances{
 	pub textures:Vec<String>,//RenderPattern
 	pub models:Vec<IndexedModel>,
 	//object_index for spawns, triggers etc?
+	pub spawn_point:glam::Vec3,
 }
 
 pub fn generate_indexed_model_list_from_obj(data:obj::ObjData,color:[f32;4]) -> Vec<IndexedModel>{
@@ -99,4 +105,4 @@ pub fn generate_indexed_model_list_from_obj(data:obj::ObjData,color:[f32;4]) ->
 			instances:Vec::new(),
 		}
 	}).collect()
-}
+}

src/primitives.rs

@@ -1,5 +1,22 @@
 use crate::model::{IndexedModel, IndexedPolygon, IndexedGroup, IndexedVertex};
 
+#[derive(Debug)]
+pub enum Primitives{
+	Sphere,
+	Cube,
+	Cylinder,
+	Wedge,
+	CornerWedge,
+}
+#[derive(Hash,PartialEq,Eq)]
+pub enum CubeFace{
+	Right,
+	Top,
+	Back,
+	Left,
+	Bottom,
+	Front,
+}
 const CUBE_DEFAULT_TEXTURE_COORDS:[[f32;2];4]=[[0.0,0.0],[1.0,0.0],[1.0,1.0],[0.0,1.0]];
 const CUBE_DEFAULT_VERTICES:[[f32;3];8]=[
 	[-1.,-1., 1.],//0 left bottom back
@@ -12,12 +29,12 @@ const CUBE_DEFAULT_VERTICES:[[f32;3];8]=[
 	[-1.,-1.,-1.],//7 left bottom front
 ];
 const CUBE_DEFAULT_NORMALS:[[f32;3];6]=[
-	[ 1., 0., 0.],//AabbFace::Right
-	[ 0., 1., 0.],//AabbFace::Top
-	[ 0., 0., 1.],//AabbFace::Back
-	[-1., 0., 0.],//AabbFace::Left
-	[ 0.,-1., 0.],//AabbFace::Bottom
-	[ 0., 0.,-1.],//AabbFace::Front
+	[ 1., 0., 0.],//CubeFace::Right
+	[ 0., 1., 0.],//CubeFace::Top
+	[ 0., 0., 1.],//CubeFace::Back
+	[-1., 0., 0.],//CubeFace::Left
+	[ 0.,-1., 0.],//CubeFace::Bottom
+	[ 0., 0.,-1.],//CubeFace::Front
 ];
 const CUBE_DEFAULT_POLYS:[[[u32;3];4];6]=[
 	// right (1, 0, 0)
@@ -63,8 +80,92 @@ const CUBE_DEFAULT_POLYS:[[[u32;3];4];6]=[
 		[7,2,5],
 	],
 ];
-pub fn the_unit_cube_lol() -> crate::model::IndexedModel{
-	generate_partial_unit_cube([Some(FaceDescription::default());6])
+
+#[derive(Hash,PartialEq,Eq)]
+pub enum WedgeFace{
+	Right,
+	TopFront,
+	Back,
+	Left,
+	Bottom,
+}
+const WEDGE_DEFAULT_NORMALS:[[f32;3];5]=[
+	[ 1., 0., 0.],//Wedge::Right
+	[ 0., 1.,-1.],//Wedge::TopFront
+	[ 0., 0., 1.],//Wedge::Back
+	[-1., 0., 0.],//Wedge::Left
+	[ 0.,-1., 0.],//Wedge::Bottom
+];
+/*
+local cornerWedgeVerticies = {
+	Vector3.new(-1/2,-1/2,-1/2),7
+	Vector3.new(-1/2,-1/2, 1/2),0
+	Vector3.new( 1/2,-1/2,-1/2),6
+	Vector3.new( 1/2,-1/2, 1/2),1
+	Vector3.new( 1/2, 1/2,-1/2),5
+}
+*/
+#[derive(Hash,PartialEq,Eq)]
+pub enum CornerWedgeFace{
+	Top,
+	Right,
+	Bottom,
+	Front,
+}
+const CORNERWEDGE_DEFAULT_NORMALS:[[f32;3];5]=[
+	[ 1., 0., 0.],//Wedge::Right
+	[ 0., 1., 1.],//Wedge::BackTop
+	[-1., 1., 0.],//Wedge::LeftTop
+	[ 0.,-1., 0.],//Wedge::Bottom
+	[ 0., 0.,-1.],//Wedge::Front
+];
+//HashMap fits this use case perfectly but feels like using a sledgehammer to drive a nail
+pub fn unit_sphere()->crate::model::IndexedModel{
+	let mut indexed_model=crate::model::generate_indexed_model_list_from_obj(obj::ObjData::load_buf(&include_bytes!("../models/suzanne.obj")[..]).unwrap(),*glam::Vec4::ONE.as_ref()).remove(0);
+	for pos in indexed_model.unique_pos.iter_mut(){
+		pos[0]=pos[0]*0.5;
+		pos[1]=pos[1]*0.5;
+		pos[2]=pos[2]*0.5;
+	}
+	indexed_model
+}
+pub type CubeFaceDescription=std::collections::HashMap::<CubeFace,FaceDescription>;
+pub fn unit_cube()->crate::model::IndexedModel{
+	let mut t=CubeFaceDescription::new();
+	t.insert(CubeFace::Right,FaceDescription::default());
+	t.insert(CubeFace::Top,FaceDescription::default());
+	t.insert(CubeFace::Back,FaceDescription::default());
+	t.insert(CubeFace::Left,FaceDescription::default());
+	t.insert(CubeFace::Bottom,FaceDescription::default());
+	t.insert(CubeFace::Front,FaceDescription::default());
+	generate_partial_unit_cube(t)
+}
+const TEAPOT_TRANSFORM:glam::Mat3=glam::mat3(glam::vec3(0.0,0.1,0.0),glam::vec3(-0.1,0.0,0.0),glam::vec3(0.0,0.0,0.1));
+pub fn unit_cylinder()->crate::model::IndexedModel{
+	let mut indexed_model=crate::model::generate_indexed_model_list_from_obj(obj::ObjData::load_buf(&include_bytes!("../models/teapot.obj")[..]).unwrap(),*glam::Vec4::ONE.as_ref()).remove(0);
+	for pos in indexed_model.unique_pos.iter_mut(){
+		[pos[0],pos[1],pos[2]]=*(TEAPOT_TRANSFORM*glam::Vec3::from_array(*pos)).as_ref();
+	}
+	indexed_model
+}
+pub type WedgeFaceDescription=std::collections::HashMap::<WedgeFace,FaceDescription>;
+pub fn unit_wedge()->crate::model::IndexedModel{
+	let mut t=WedgeFaceDescription::new();
+	t.insert(WedgeFace::Right,FaceDescription::default());
+	t.insert(WedgeFace::TopFront,FaceDescription::default());
+	t.insert(WedgeFace::Back,FaceDescription::default());
+	t.insert(WedgeFace::Left,FaceDescription::default());
+	t.insert(WedgeFace::Bottom,FaceDescription::default());
+	generate_partial_unit_wedge(t)
+}
+pub type CornerWedgeFaceDescription=std::collections::HashMap::<CornerWedgeFace,FaceDescription>;
+pub fn unit_cornerwedge()->crate::model::IndexedModel{
+	let mut t=CornerWedgeFaceDescription::new();
+	t.insert(CornerWedgeFace::Right,FaceDescription::default());
+	t.insert(CornerWedgeFace::Top,FaceDescription::default());
+	t.insert(CornerWedgeFace::Bottom,FaceDescription::default());
+	t.insert(CornerWedgeFace::Front,FaceDescription::default());
+	generate_partial_unit_cornerwedge(t)
 }
 
 #[derive(Copy,Clone)]
@@ -74,11 +175,11 @@ pub struct FaceDescription{
 	pub color:glam::Vec4,
 }
 impl std::default::Default for FaceDescription{
-	fn default() -> Self {
+	fn default()->Self {
 		Self{
 			texture:None,
 			transform:glam::Affine2::IDENTITY,
-			color:glam::Vec4::ONE,
+			color:glam::vec4(1.0,1.0,1.0,0.0),//zero alpha to hide the default texture
 		}
 	}
 }
@@ -95,7 +196,8 @@ impl FaceDescription{
 	}
 }
 //TODO: it's probably better to use a shared vertex buffer between all primitives and use indexed rendering instead of generating a unique vertex buffer for each primitive.
-pub fn generate_partial_unit_cube(face_descriptions:[Option<FaceDescription>;6]) -> crate::model::IndexedModel{
+//implementation: put all roblox primitives into one model.groups <- this won't work but I forget why
+pub fn generate_partial_unit_cube(face_descriptions:CubeFaceDescription)->crate::model::IndexedModel{
 	let mut generated_pos=Vec::<[f32;3]>::new();
 	let mut generated_tex=Vec::new();
 	let mut generated_normal=Vec::new();
@@ -104,59 +206,290 @@ pub fn generate_partial_unit_cube(face_descriptions:[Option<FaceDescription>;6])
 	let mut groups=Vec::new();
 	let mut transforms=Vec::new();
 	//note that on a cube every vertex is guaranteed to be unique, so there's no need to hash them against existing vertices.
-	for (i,maybe_face_description) in face_descriptions.iter().enumerate(){
-		if let Some(face_description)=maybe_face_description{
-			//assume that scanning short lists is faster than hashing.
-			let transform_index=if let Some(transform_index)=transforms.iter().position(|&transform|transform==face_description.transform){
-				transform_index
-			}else{
-				//create new transform_index
-				let transform_index=transforms.len();
-				transforms.push(face_description.transform);
-				for tex in CUBE_DEFAULT_TEXTURE_COORDS{
-					generated_tex.push(*face_description.transform.transform_point2(glam::Vec2::from_array(tex)).as_ref());
-				}
-				transform_index
-			} as u32;
-			let color_index=if let Some(color_index)=generated_color.iter().position(|color|color==face_description.color.as_ref()){
-				color_index
-			}else{
-				//create new color_index
-				let color_index=generated_color.len();
-				generated_color.push(*face_description.color.as_ref());
-				color_index
-			} as u32;
-			//always push normal
-			let normal_index=generated_normal.len() as u32;
-			generated_normal.push(CUBE_DEFAULT_NORMALS[i]);
-			//push vertices as they are needed
-			groups.push(IndexedGroup{
-				texture:face_description.texture,
-				polys:vec![IndexedPolygon{
-					vertices:CUBE_DEFAULT_POLYS[i].map(|tup|{
-						let pos=CUBE_DEFAULT_VERTICES[tup[0] as usize];
-						let pos_index=if let Some(pos_index)=generated_pos.iter().position(|&p|p==pos){
-							pos_index
-						}else{
-							//create new pos_index
-							let pos_index=generated_pos.len();
-							generated_pos.push(pos);
-							pos_index
-						} as u32;
-						//always push vertex
-						let vertex=IndexedVertex{
-							pos:pos_index,
-							tex:tup[1]+4*transform_index,
-							normal:normal_index,
-							color:color_index,
-						};
-						let vert_index=generated_vertices.len();
-						generated_vertices.push(vertex);
-						vert_index as u32
-					}).to_vec(),
-				}],
-			});
-		}
+	for (face,face_description) in face_descriptions.into_iter(){
+		//assume that scanning short lists is faster than hashing.
+		let transform_index=if let Some(transform_index)=transforms.iter().position(|&transform|transform==face_description.transform){
+			transform_index
+		}else{
+			//create new transform_index
+			let transform_index=transforms.len();
+			transforms.push(face_description.transform);
+			for tex in CUBE_DEFAULT_TEXTURE_COORDS{
+				generated_tex.push(*face_description.transform.transform_point2(glam::Vec2::from_array(tex)).as_ref());
+			}
+			transform_index
+		} as u32;
+		let color_index=if let Some(color_index)=generated_color.iter().position(|color|color==face_description.color.as_ref()){
+			color_index
+		}else{
+			//create new color_index
+			let color_index=generated_color.len();
+			generated_color.push(*face_description.color.as_ref());
+			color_index
+		} as u32;
+		let face_id=match face{
+			CubeFace::Right => 0,
+			CubeFace::Top => 1,
+			CubeFace::Back => 2,
+			CubeFace::Left => 3,
+			CubeFace::Bottom => 4,
+			CubeFace::Front => 5,
+		};
+		//always push normal
+		let normal_index=generated_normal.len() as u32;
+		generated_normal.push(CUBE_DEFAULT_NORMALS[face_id]);
+		//push vertices as they are needed
+		groups.push(IndexedGroup{
+			texture:face_description.texture,
+			polys:vec![IndexedPolygon{
+				vertices:CUBE_DEFAULT_POLYS[face_id].map(|tup|{
+					let pos=CUBE_DEFAULT_VERTICES[tup[0] as usize];
+					let pos_index=if let Some(pos_index)=generated_pos.iter().position(|&p|p==pos){
+						pos_index
+					}else{
+						//create new pos_index
+						let pos_index=generated_pos.len();
+						generated_pos.push(pos);
+						pos_index
+					} as u32;
+					//always push vertex
+					let vertex=IndexedVertex{
+						pos:pos_index,
+						tex:tup[1]+4*transform_index,
+						normal:normal_index,
+						color:color_index,
+					};
+					let vert_index=generated_vertices.len();
+					generated_vertices.push(vertex);
+					vert_index as u32
+				}).to_vec(),
+			}],
+		});
+	}
+	IndexedModel{
+		unique_pos:generated_pos,
+		unique_tex:generated_tex,
+		unique_normal:generated_normal,
+		unique_color:generated_color,
+		unique_vertices:generated_vertices,
+		groups,
+		instances:Vec::new(),
+	}
+}
+//don't think too hard about the copy paste because this is all going into the map tool eventually...
+pub fn generate_partial_unit_wedge(face_descriptions:WedgeFaceDescription)->crate::model::IndexedModel{
+	let wedge_default_polys=vec![
+		// right (1, 0, 0)
+		vec![
+			[6,2,0],//[vertex,tex,norm]
+			[2,0,0],
+			[1,3,0],
+		],
+		// FrontTop (0, 1, -1)
+		vec![
+			[3,1,1],
+			[2,0,1],
+			[6,3,1],
+			[7,2,1],
+		],
+		// back (0, 0, 1)
+		vec![
+			[0,3,2],
+			[1,2,2],
+			[2,1,2],
+			[3,0,2],
+		],
+		// left (-1, 0, 0)
+		vec![
+			[0,2,3],
+			[3,1,3],
+			[7,3,3],
+		],
+		// bottom (0,-1, 0)
+		vec![
+			[1,1,4],
+			[0,0,4],
+			[7,3,4],
+			[6,2,4],
+		],
+	];
+	let mut generated_pos=Vec::<[f32;3]>::new();
+	let mut generated_tex=Vec::new();
+	let mut generated_normal=Vec::new();
+	let mut generated_color=Vec::new();
+	let mut generated_vertices=Vec::new();
+	let mut groups=Vec::new();
+	let mut transforms=Vec::new();
+	//note that on a cube every vertex is guaranteed to be unique, so there's no need to hash them against existing vertices.
+	for (face,face_description) in face_descriptions.into_iter(){
+		//assume that scanning short lists is faster than hashing.
+		let transform_index=if let Some(transform_index)=transforms.iter().position(|&transform|transform==face_description.transform){
+			transform_index
+		}else{
+			//create new transform_index
+			let transform_index=transforms.len();
+			transforms.push(face_description.transform);
+			for tex in CUBE_DEFAULT_TEXTURE_COORDS{
+				generated_tex.push(*face_description.transform.transform_point2(glam::Vec2::from_array(tex)).as_ref());
+			}
+			transform_index
+		} as u32;
+		let color_index=if let Some(color_index)=generated_color.iter().position(|color|color==face_description.color.as_ref()){
+			color_index
+		}else{
+			//create new color_index
+			let color_index=generated_color.len();
+			generated_color.push(*face_description.color.as_ref());
+			color_index
+		} as u32;
+		let face_id=match face{
+			WedgeFace::Right => 0,
+			WedgeFace::TopFront => 1,
+			WedgeFace::Back => 2,
+			WedgeFace::Left => 3,
+			WedgeFace::Bottom => 4,
+		};
+		//always push normal
+		let normal_index=generated_normal.len() as u32;
+		generated_normal.push(WEDGE_DEFAULT_NORMALS[face_id]);
+		//push vertices as they are needed
+		groups.push(IndexedGroup{
+			texture:face_description.texture,
+			polys:vec![IndexedPolygon{
+				vertices:wedge_default_polys[face_id].iter().map(|tup|{
+					let pos=CUBE_DEFAULT_VERTICES[tup[0] as usize];
+					let pos_index=if let Some(pos_index)=generated_pos.iter().position(|&p|p==pos){
+						pos_index
+					}else{
+						//create new pos_index
+						let pos_index=generated_pos.len();
+						generated_pos.push(pos);
+						pos_index
+					} as u32;
+					//always push vertex
+					let vertex=IndexedVertex{
+						pos:pos_index,
+						tex:tup[1]+4*transform_index,
+						normal:normal_index,
+						color:color_index,
+					};
+					let vert_index=generated_vertices.len();
+					generated_vertices.push(vertex);
+					vert_index as u32
+				}).collect(),
+			}],
+		});
+	}
+	IndexedModel{
+		unique_pos:generated_pos,
+		unique_tex:generated_tex,
+		unique_normal:generated_normal,
+		unique_color:generated_color,
+		unique_vertices:generated_vertices,
+		groups,
+		instances:Vec::new(),
+	}
+}
+
+pub fn generate_partial_unit_cornerwedge(face_descriptions:CornerWedgeFaceDescription)->crate::model::IndexedModel{
+	let cornerwedge_default_polys=vec![
+		// right (1, 0, 0)
+		vec![
+			[6,2,0],//[vertex,tex,norm]
+			[5,1,0],
+			[1,3,0],
+		],
+		// BackTop (0, 1, 1)
+		vec![
+			[5,3,1],
+			[0,1,1],
+			[1,0,1],
+		],
+		// LeftTop (-1, 1, 0)
+		vec![
+			[5,3,2],
+			[7,2,2],
+			[0,1,2],
+		],
+		// bottom (0,-1, 0)
+		vec![
+			[1,1,3],
+			[0,0,3],
+			[7,3,3],
+			[6,2,3],
+		],
+		// front (0, 0,-1)
+		vec![
+			[5,0,4],
+			[6,3,4],
+			[7,2,4],
+		],
+	];
+	let mut generated_pos=Vec::<[f32;3]>::new();
+	let mut generated_tex=Vec::new();
+	let mut generated_normal=Vec::new();
+	let mut generated_color=Vec::new();
+	let mut generated_vertices=Vec::new();
+	let mut groups=Vec::new();
+	let mut transforms=Vec::new();
+	//note that on a cube every vertex is guaranteed to be unique, so there's no need to hash them against existing vertices.
+	for (face,face_description) in face_descriptions.into_iter(){
+		//assume that scanning short lists is faster than hashing.
+		let transform_index=if let Some(transform_index)=transforms.iter().position(|&transform|transform==face_description.transform){
+			transform_index
+		}else{
+			//create new transform_index
+			let transform_index=transforms.len();
+			transforms.push(face_description.transform);
+			for tex in CUBE_DEFAULT_TEXTURE_COORDS{
+				generated_tex.push(*face_description.transform.transform_point2(glam::Vec2::from_array(tex)).as_ref());
+			}
+			transform_index
+		} as u32;
+		let color_index=if let Some(color_index)=generated_color.iter().position(|color|color==face_description.color.as_ref()){
+			color_index
+		}else{
+			//create new color_index
+			let color_index=generated_color.len();
+			generated_color.push(*face_description.color.as_ref());
+			color_index
+		} as u32;
+		let face_id=match face{
+			CornerWedgeFace::Right => 0,
+			CornerWedgeFace::Top => 1,
+			CornerWedgeFace::Bottom => 2,
+			CornerWedgeFace::Front => 3,
+		};
+		//always push normal
+		let normal_index=generated_normal.len() as u32;
+		generated_normal.push(CORNERWEDGE_DEFAULT_NORMALS[face_id]);
+		//push vertices as they are needed
+		groups.push(IndexedGroup{
+			texture:face_description.texture,
+			polys:vec![IndexedPolygon{
+				vertices:cornerwedge_default_polys[face_id].iter().map(|tup|{
+					let pos=CUBE_DEFAULT_VERTICES[tup[0] as usize];
+					let pos_index=if let Some(pos_index)=generated_pos.iter().position(|&p|p==pos){
+						pos_index
+					}else{
+						//create new pos_index
+						let pos_index=generated_pos.len();
+						generated_pos.push(pos);
+						pos_index
+					} as u32;
+					//always push vertex
+					let vertex=IndexedVertex{
+						pos:pos_index,
+						tex:tup[1]+4*transform_index,
+						normal:normal_index,
+						color:color_index,
+					};
+					let vert_index=generated_vertices.len();
+					generated_vertices.push(vertex);
+					vert_index as u32
+				}).collect(),
+			}],
+		});
 	}
 	IndexedModel{
 		unique_pos:generated_pos,

src/shader.wgsl

@@ -42,7 +42,8 @@ fn vs_sky(@builtin(vertex_index) vertex_index: u32) -> SkyOutput {
 }
 
 struct ModelInstance{
-	model_transform:mat4x4<f32>,
+	transform:mat4x4<f32>,
+	normal_transform:mat4x4<f32>,
 	color:vec4<f32>,
 }
 //my fancy idea is to create a megatexture for each model that includes all the textures each intance will need
@@ -65,6 +66,7 @@ struct EntityOutputTexture {
 	@location(2) normal: vec3<f32>,
 	@location(3) view: vec3<f32>,
 	@location(4) color: vec4<f32>,
+	@location(5) @interpolate(flat) model_color: vec4<f32>,
 };
 @vertex
 fn vs_entity_texture(
@@ -74,11 +76,12 @@ fn vs_entity_texture(
 	@location(2) normal: vec3<f32>,
 	@location(3) color: vec4<f32>,
 ) -> EntityOutputTexture {
-	var position: vec4<f32> = model_instances[instance].model_transform * vec4<f32>(pos, 1.0);
+	var position: vec4<f32> = model_instances[instance].transform * vec4<f32>(pos, 1.0);
 	var result: EntityOutputTexture;
-	result.normal = (model_instances[instance].model_transform * vec4<f32>(normal, 0.0)).xyz;
+	result.normal = (model_instances[instance].normal_transform * vec4<f32>(normal, 1.0)).xyz;
 	result.texture = texture;
-	result.color = model_instances[instance].color * color;
+	result.color = color;
+	result.model_color = model_instances[instance].color;
 	result.view = position.xyz - camera.cam_pos.xyz;
 	result.position = camera.proj * camera.view * position;
 	return result;
@@ -106,5 +109,5 @@ fn fs_entity_texture(vertex: EntityOutputTexture) -> @location(0) vec4<f32> {
 
 	let fragment_color = textureSample(model_texture, model_sampler, vertex.texture)*vertex.color;
 	let reflected_color = textureSample(cube_texture, cube_sampler, reflected).rgb;
-	return mix(vec4<f32>(vec3<f32>(0.1) + 0.5 * reflected_color,1.0),fragment_color,1.0-pow(1.0-abs(d),2.0));
+	return mix(vec4<f32>(vec3<f32>(0.05) + 0.2 * reflected_color,1.0),mix(vertex.model_color,vec4<f32>(fragment_color.rgb,1.0),fragment_color.a),1.0-pow(1.0-abs(d),2.0));
 }