move keyboard input to WindowEvent to fix Wayland

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 update(&mut self, window: &winit::window::Window, 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,
@@ -367,7 +368,7 @@ fn start<E: Example>(
 					println!("{:#?}", instance.generate_report());
 				}
 				_ => {
-					example.update(&device,&queue,event);
+					example.update(&window,&device,&queue,event);
 				}
 			},
 			event::Event::DeviceEvent {

src/main.rs

@@ -97,63 +97,70 @@ 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 (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{}",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()
+				})));
 			}
 		}
-		let indexed_models_len=indexed_models.models.len();
+
+		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());
+		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.drain(..){
 			//convert ModelInstance into ModelGraphicsInstance
 			let instances:Vec<ModelGraphicsInstance>=model.instances.iter().map(|instance|{
@@ -298,7 +305,7 @@ impl GraphicsData {
 				});
 			}
 		}
-		println!("Texture References={}",indexed_models.textures.len());
+		println!("Texture References={}",num_textures);
 		println!("Textures Loaded={}",texture_views.len());
 		println!("Indexed Models={}",indexed_models_len);
 		println!("Graphics Objects: {}",self.models.len());
@@ -764,71 +771,122 @@ 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;
 	}
 
-	#[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)))={
-							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
-										},
-									}
+	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.");
+						},
+						//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!("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) {
+		let time=self.start_time.elapsed().as_nanos() as i64;
+		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);
+							}
+						}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{
+								time,
+								instruction:PhysicsInstruction::Input(input_instruction),
+							})
+						}
+					},
+					_=>(),
 				}
 			},
 			_=>(),
@@ -839,6 +897,7 @@ 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,
@@ -868,6 +927,7 @@ impl framework::Example for GraphicsData {
 					})
 				}
 			},
+			*/
 			winit::event::DeviceEvent::MouseMotion {
 			    delta,//these (f64,f64) are integers on my machine
 			} => {
@@ -883,7 +943,7 @@ impl framework::Example for GraphicsData {
 			    delta,
 			} => {
 				println!("mousewheel{:?}",delta);
-				if true{//self.physics.use_scroll
+				if false{//self.physics.style.use_scroll{
 					self.physics.run(time);
 					self.physics.process_instruction(TimedInstruction{
 						time,