we're chilling

src/framework.rs

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

src/main.rs

@@ -98,18 +98,17 @@ impl GraphicsData {
 		//idk how to do this gooder lol
 		let mut double_map=std::collections::HashMap::<u32,u32>::new();
 		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))){
+		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))){
 				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()
-				})));
+				texture_loading_threads.push(std::thread::spawn(move ||{
+					(i,ddsfile::Dds::read(&mut file).unwrap())
+				}));
 			}
 		}
 
-		let texture_views:Vec<wgpu::TextureView>=texture_loading_threads.into_iter().map(|(texture_id,thread)|{
-			let image=thread.join().unwrap();
+		let texture_views:Vec<wgpu::TextureView>=texture_loading_threads.into_iter().map(|t|{
+			let (i,image)=t.join().unwrap();
 
 			let (mut width,mut height)=(image.get_width(),image.get_height());
 
@@ -145,22 +144,22 @@ impl GraphicsData {
 					dimension: wgpu::TextureDimension::D2,
 					format,
 					usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST,
-					label: Some(format!("Texture{}",texture_id).as_str()),
+					label: Some(format!("Texture{}",i).as_str()),
 					view_formats: &[],
 				},
 				&image.data,
 			);
 			texture.create_view(&wgpu::TextureViewDescriptor {
-				label: Some(format!("Texture{} View",texture_id).as_str()),
+				label: Some(format!("Texture{} View",i).as_str()),
 				dimension: Some(wgpu::TextureViewDimension::D2),
 				..wgpu::TextureViewDescriptor::default()
 			})
 		}).collect();
 
+		let indexed_models_len=indexed_models.models.len();
 		//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 indexed_models_len=indexed_models.models.len();
-		let mut unique_texture_models=Vec::with_capacity(indexed_models_len);
+		let mut unique_texture_models=Vec::with_capacity(indexed_models.models.len());
 		for mut model in indexed_models.models.drain(..){
 			//convert ModelInstance into ModelGraphicsInstance
 			let instances:Vec<ModelGraphicsInstance>=model.instances.iter().map(|instance|{
@@ -305,7 +304,7 @@ impl GraphicsData {
 				});
 			}
 		}
-		println!("Texture References={}",num_textures);
+		println!("Texture References={}",indexed_models.textures.len());
 		println!("Textures Loaded={}",texture_views.len());
 		println!("Indexed Models={}",indexed_models_len);
 		println!("Graphics Objects: {}",self.models.len());
@@ -771,122 +770,71 @@ impl framework::Example for GraphicsData {
 		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;
 	}
 
-	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(Ok((indexed_model_instances,spawn_point)))={
-					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_roblox(dom)),
-								Err(e)=>{
-									println!("Error loading roblox file:{:?}",e);
-									None
-								},
-							}
-						},
-						//b"VBSP"=>load_valve::generate_indexed_models_valve(input),
-						//b"SNFM"=>sniffer::generate_indexed_models(input),
-						//b"SNFB"=>sniffer::load_bot(input),
-						_=>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 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) {
-		let time=self.start_time.elapsed().as_nanos() as i64;
+	fn update(&mut self, device: &wgpu::Device, queue: &wgpu::Queue, event: winit::event::WindowEvent) {
+		//nothing atm
 		match event {
-			winit::event::WindowEvent::DroppedFile(path) => self.load_file(path,device,queue),
-			winit::event::WindowEvent::KeyboardInput {
-				input:winit::event::KeyboardInput{state, virtual_keycode,..},
-				..
-			}=>{
-				let s=match state {
-					winit::event::ElementState::Pressed => true,
-					winit::event::ElementState::Released => false,
-				};
-				match virtual_keycode{
-					Some(winit::event::VirtualKeyCode::Tab)=>{
-						if s{
-							if let Ok(())=window.set_cursor_grab(winit::window::CursorGrabMode::None){
-								window.set_cursor_visible(true);
+			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)))={
+							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_roblox(dom)),
+										Err(e)=>{
+											println!("Error loading roblox file:{:?}",e);
+											None
+										},
+									}
+								},
+								//b"VBSP"=>load_valve::generate_indexed_models_valve(input),
+								//b"SNFM"=>sniffer::generate_indexed_models(input),
+								//b"SNFB"=>sniffer::load_bot(input),
+								_=>None,
 							}
-						}else{
-							if let Ok(())=window.set_cursor_grab(winit::window::CursorGrabMode::Locked){
-								window.set_cursor_visible(false);
-							}
-						}
-					},
-					Some(keycode)=>{
-						if let Some(input_instruction)=match keycode {
-							winit::event::VirtualKeyCode::W => Some(InputInstruction::MoveForward(s)),
-							winit::event::VirtualKeyCode::A => Some(InputInstruction::MoveLeft(s)),
-							winit::event::VirtualKeyCode::S => Some(InputInstruction::MoveBack(s)),
-							winit::event::VirtualKeyCode::D => Some(InputInstruction::MoveRight(s)),
-							winit::event::VirtualKeyCode::E => Some(InputInstruction::MoveUp(s)),
-							winit::event::VirtualKeyCode::Q => Some(InputInstruction::MoveDown(s)),
-							winit::event::VirtualKeyCode::Space => Some(InputInstruction::Jump(s)),
-							winit::event::VirtualKeyCode::Z => Some(InputInstruction::Zoom(s)),
-							winit::event::VirtualKeyCode::R => if s{Some(InputInstruction::Reset)}else{None},
-							_ => None,
-						}
-						{
-							self.physics.run(time);
-							self.physics.process_instruction(TimedInstruction{
+						}{
+							//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:PhysicsInstruction::Input(input_instruction),
-							})
+								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 to read first 8 bytes and seek back to beginning of file.");
+					}
+				}else{
+					println!("Could not open file");
 				}
 			},
 			_=>(),
@@ -897,7 +845,6 @@ impl framework::Example for GraphicsData {
 		//there's no way this is the best way get a timestamp.
 		let time=self.start_time.elapsed().as_nanos() as i64;
 		match event {
-			/* use WindowEvent for input for now because DeviceEvent doesn't work on wayland
 			winit::event::DeviceEvent::Key(winit::event::KeyboardInput {
 				state,
 				scancode: keycode,
@@ -927,7 +874,6 @@ impl framework::Example for GraphicsData {
 					})
 				}
 			},
-			*/
 			winit::event::DeviceEvent::MouseMotion {
 			    delta,//these (f64,f64) are integers on my machine
 			} => {
@@ -943,7 +889,7 @@ impl framework::Example for GraphicsData {
 			    delta,
 			} => {
 				println!("mousewheel{:?}",delta);
-				if false{//self.physics.style.use_scroll{
+				if true{//self.physics.use_scroll
 					self.physics.run(time);
 					self.physics.process_instruction(TimedInstruction{
 						time,