comment on what can implement predict_collision

Cargo.lock

@@ -1405,7 +1405,7 @@ checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
 
 [[package]]
 name = "strafe-client"
-version = "0.3.0"
+version = "0.2.0"
 dependencies = [
  "async-executor",
  "bytemuck",

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "strafe-client"
-version = "0.3.0"
+version = "0.2.0"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

src/event.rs

@@ -0,0 +1,15 @@
+pub struct EventStruct {
+	pub time: crate::body::TIME,
+	pub event: EventEnum,
+}
+
+pub enum EventEnum {
+	CollisionStart,//(Collideable),//Body::CollisionStart
+	CollisionEnd,//(Collideable),//Body::CollisionEnd
+	StrafeTick,
+	Jump,
+}
+
+pub trait EventTrait {
+	fn next_event(&self) -> Option<EventStruct>;
+}

src/framework.rs

@@ -1,10 +1,12 @@
 use std::future::Future;
 #[cfg(target_arch = "wasm32")]
 use std::str::FromStr;
+#[cfg(not(target_arch = "wasm32"))]
+use std::time::Instant;
 #[cfg(target_arch = "wasm32")]
 use web_sys::{ImageBitmapRenderingContext, OffscreenCanvas};
 use winit::{
-	event::{self, WindowEvent, DeviceEvent},
+	event::{self, WindowEvent},
 	event_loop::{ControlFlow, EventLoop},
 };
 
@@ -52,7 +54,7 @@ pub trait Example: 'static + Sized {
 		queue: &wgpu::Queue,
 	);
 	fn update(&mut self, event: WindowEvent);
-	fn device_event(&mut self, event: DeviceEvent);
+	fn move_mouse(&mut self, delta: (f64,f64));
 	fn render(
 		&mut self,
 		view: &wgpu::TextureView,
@@ -277,6 +279,11 @@ fn start<E: Example>(
 	log::info!("Initializing the example...");
 	let mut example = E::init(&config, &adapter, &device, &queue);
 
+	#[cfg(not(target_arch = "wasm32"))]
+	let mut last_frame_inst = Instant::now();
+	#[cfg(not(target_arch = "wasm32"))]
+	let (mut frame_count, mut accum_time) = (0, 0.0);
+
 	log::info!("Entering render loop...");
 	event_loop.run(move |event, _, control_flow| {
 		let _ = (&instance, &adapter); // force ownership by the closure
@@ -348,12 +355,29 @@ fn start<E: Example>(
 				}
 			},
 			event::Event::DeviceEvent {
-				event,
+				event:
+					winit::event::DeviceEvent::MouseMotion {
+						delta,
+					},
 				..
 			} => {
-				example.device_event(event);
+				example.move_mouse(delta);
 			},
 			event::Event::RedrawRequested(_) => {
+				#[cfg(not(target_arch = "wasm32"))]
+				{
+					accum_time += last_frame_inst.elapsed().as_secs_f32();
+					last_frame_inst = Instant::now();
+					frame_count += 1;
+					if frame_count == 100 {
+						println!(
+							"Avg frame time {}ms",
+							accum_time * 1000.0 / frame_count as f32
+						);
+						accum_time = 0.0;
+						frame_count = 0;
+					}
+				}
 
 				let frame = match surface.get_current_texture() {
 					Ok(frame) => frame,

src/instruction.rs

@@ -1,48 +0,0 @@
-#[derive(Debug)]
-pub struct TimedInstruction<I> {
-	pub time: crate::body::TIME,
-	pub instruction: I,
-}
-
-pub trait InstructionEmitter<I> {
-	fn next_instruction(&self, time_limit:crate::body::TIME) -> Option<TimedInstruction<I>>;
-}
-pub trait InstructionConsumer<I> {
-	fn process_instruction(&mut self, instruction:TimedInstruction<I>);
-}
-
-//PROPER PRIVATE FIELDS!!!
-pub struct InstructionCollector<I> {
-	time: crate::body::TIME,
-	instruction: Option<I>,
-}
-impl<I> InstructionCollector<I> {
-	pub fn new(time:crate::body::TIME) -> Self {
-		Self{
-			time,
-			instruction:None
-		}
-	}
-
-	pub fn collect(&mut self,instruction:Option<TimedInstruction<I>>){
-		match instruction {
-			Some(unwrap_instruction) => {
-				if unwrap_instruction.time<self.time {
-					self.time=unwrap_instruction.time;
-					self.instruction=Some(unwrap_instruction.instruction);
-				}
-			},
-			None => (),
-		}
-	}
-	pub fn instruction(self) -> Option<TimedInstruction<I>> {
-		//STEAL INSTRUCTION AND DESTROY INSTRUCTIONCOLLECTOR
-		match self.instruction {
-			Some(instruction)=>Some(TimedInstruction{
-				time:self.time,
-				instruction
-			}),
-			None => None,
-		}
-	}
-}

src/lib.rs

@@ -1,4 +1,3 @@
 pub mod framework;
 pub mod body;
-pub mod zeroes;
-pub mod instruction;
+pub mod event;

src/main.rs

@@ -1,5 +1,4 @@
 use bytemuck::{Pod, Zeroable};
-use strafe_client::{instruction::{TimedInstruction, InstructionConsumer},body::{InputInstruction, PhysicsInstruction}};
 use std::{borrow::Cow, time::Instant};
 use wgpu::{util::DeviceExt, AstcBlock, AstcChannel};
 
@@ -25,7 +24,7 @@ struct ModelData {
 	entities: Vec<Entity>,
 }
 
-struct ModelGraphics {
+struct Model {
 	transform: glam::Mat4,
 	vertex_buf: wgpu::Buffer,
 	entities: Vec<Entity>,
@@ -33,16 +32,97 @@ struct ModelGraphics {
 	model_buf: wgpu::Buffer,
 }
 
+// Note: we use the Y=up coordinate space in this example.
+struct Camera {
+	screen_size: (u32, u32),
+	offset: glam::Vec3,
+	fov: f32,
+	yaw: f32,
+	pitch: f32,
+	controls: u32,
+}
+
+const CONTROL_MOVEFORWARD:u32 = 0b00000001;
+const CONTROL_MOVEBACK:u32 = 0b00000010;
+const CONTROL_MOVERIGHT:u32 = 0b00000100;
+const CONTROL_MOVELEFT:u32 = 0b00001000;
+const CONTROL_MOVEUP:u32 = 0b00010000;
+const CONTROL_MOVEDOWN:u32 = 0b00100000;
+const CONTROL_JUMP:u32 = 0b01000000;
+const CONTROL_ZOOM:u32 = 0b10000000;
+
+const FORWARD_DIR:glam::Vec3 = glam::Vec3::new(0.0,0.0,-1.0);
+const RIGHT_DIR:glam::Vec3 = glam::Vec3::new(1.0,0.0,0.0);
+const UP_DIR:glam::Vec3 = glam::Vec3::new(0.0,1.0,0.0);
+
+fn get_control_dir(controls: u32) -> glam::Vec3{
+	//don't get fancy just do it
+	let mut control_dir:glam::Vec3 = glam::Vec3::new(0.0,0.0,0.0);
+	if controls & CONTROL_MOVEFORWARD == CONTROL_MOVEFORWARD {
+		control_dir+=FORWARD_DIR;
+	}
+	if controls & CONTROL_MOVEBACK == CONTROL_MOVEBACK {
+		control_dir+=-FORWARD_DIR;
+	}
+	if controls & CONTROL_MOVELEFT == CONTROL_MOVELEFT {
+		control_dir+=-RIGHT_DIR;
+	}
+	if controls & CONTROL_MOVERIGHT == CONTROL_MOVERIGHT {
+		control_dir+=RIGHT_DIR;
+	}
+	if controls & CONTROL_MOVEUP == CONTROL_MOVEUP {
+		control_dir+=UP_DIR;
+	}
+	if controls & CONTROL_MOVEDOWN == CONTROL_MOVEDOWN {
+		control_dir+=-UP_DIR;
+	}
+	return control_dir
+}
+
+	#[inline]
+	fn perspective_rh(fov_y_slope: f32, aspect_ratio: f32, z_near: f32, z_far: f32) -> glam::Mat4 {
+		//glam_assert!(z_near > 0.0 && z_far > 0.0);
+		let r = z_far / (z_near - z_far);
+		glam::Mat4::from_cols(
+			glam::Vec4::new(1.0/(fov_y_slope * aspect_ratio), 0.0, 0.0, 0.0),
+			glam::Vec4::new(0.0, 1.0/fov_y_slope, 0.0, 0.0),
+			glam::Vec4::new(0.0, 0.0, r, -1.0),
+			glam::Vec4::new(0.0, 0.0, r * z_near, 0.0),
+		)
+	}
+
+impl Camera {
+	fn to_uniform_data(&self, pos: glam::Vec3) -> [f32; 16 * 3 + 4] {
+		let aspect = self.screen_size.0 as f32 / self.screen_size.1 as f32;
+		let fov = if self.controls&CONTROL_ZOOM==0 {
+			self.fov
+		}else{
+			self.fov/5.0
+		};
+		let proj = perspective_rh(fov, aspect, 0.5, 1000.0);
+		let proj_inv = proj.inverse();
+		let view = glam::Mat4::from_translation(pos+self.offset) * glam::Mat4::from_euler(glam::EulerRot::YXZ, self.yaw, self.pitch, 0f32);
+		let view_inv = view.inverse();
+
+		let mut raw = [0f32; 16 * 3 + 4];
+		raw[..16].copy_from_slice(&AsRef::<[f32; 16]>::as_ref(&proj)[..]);
+		raw[16..32].copy_from_slice(&AsRef::<[f32; 16]>::as_ref(&proj_inv)[..]);
+		raw[32..48].copy_from_slice(&AsRef::<[f32; 16]>::as_ref(&view_inv)[..]);
+		raw[48..52].copy_from_slice(AsRef::<[f32; 4]>::as_ref(&view.col(3)));
+		raw
+	}
+}
+
 pub struct Skybox {
 	start_time: std::time::Instant,
-	screen_size: (u32, u32),
+	camera: Camera,
 	physics: strafe_client::body::PhysicsState,
 	sky_pipeline: wgpu::RenderPipeline,
 	entity_pipeline: wgpu::RenderPipeline,
 	ground_pipeline: wgpu::RenderPipeline,
 	main_bind_group: wgpu::BindGroup,
 	camera_buf: wgpu::Buffer,
-	models: Vec<ModelGraphics>,
+	models: Vec<Model>,
 	depth_view: wgpu::TextureView,
 	staging_belt: wgpu::util::StagingBelt,
 }
@@ -92,7 +172,7 @@ fn add_obj(device:&wgpu::Device,modeldatas:& mut Vec<ModelData>,source:&[u8]){
 					for &index in &[0, end_index - 1, end_index] {
 						let vert = poly.0[index];
 						if let Some(&i)=vertex_index.get(&vert){
-							indices.push(i);
+							indices.push(i as u16);
 						}else{
 							let i=vertices.len() as u16;
 							vertices.push(Vertex {
@@ -129,21 +209,6 @@ fn add_obj(device:&wgpu::Device,modeldatas:& mut Vec<ModelData>,source:&[u8]){
 	}
 }
 
-
-fn to_uniform_data(camera: &strafe_client::body::Camera, pos: glam::Vec3) -> [f32; 16 * 3 + 4] {
-	let proj=camera.proj();
-	let proj_inv = proj.inverse();
-	let view=camera.view(pos);
-	let view_inv = view.inverse();
-
-	let mut raw = [0f32; 16 * 3 + 4];
-	raw[..16].copy_from_slice(&AsRef::<[f32; 16]>::as_ref(&proj)[..]);
-	raw[16..32].copy_from_slice(&AsRef::<[f32; 16]>::as_ref(&proj_inv)[..]);
-	raw[32..48].copy_from_slice(&AsRef::<[f32; 16]>::as_ref(&view_inv)[..]);
-	raw[48..52].copy_from_slice(AsRef::<[f32; 4]>::as_ref(&view.col(3)));
-	raw
-}
-
 impl strafe_client::framework::Example for Skybox {
 	fn optional_features() -> wgpu::Features {
 		wgpu::Features::TEXTURE_COMPRESSION_ASTC
@@ -218,63 +283,37 @@ impl strafe_client::framework::Example for Skybox {
 			source: wgpu::ShaderSource::Wgsl(Cow::Borrowed(include_str!("shader.wgsl"))),
 		});
 
+		let camera = Camera {
+			screen_size: (config.width, config.height),
+			offset: glam::Vec3::new(0.0,4.5,0.0),
+			fov: 1.0, //fov_slope = tan(fov_y/2)
+			pitch: 0.0,
+			yaw: 0.0,
+			controls:0,
+		};
 		let physics = strafe_client::body::PhysicsState {
-			body: strafe_client::body::Body::with_pva(glam::vec3(0.0,50.0,0.0),glam::vec3(0.0,0.0,0.0),glam::vec3(0.0,-100.0,0.0)),
+			body: strafe_client::body::Body {
+				position: glam::Vec3::new(5.0,0.0,5.0),
+				velocity: glam::Vec3::new(0.0,0.0,0.0),
+				time: 0,
+			},
 			time: 0,
 			tick: 0,
-			strafe_tick_num: 100,//100t
-			strafe_tick_den: 1_000_000_000,
-			gravity: glam::vec3(0.0,-100.0,0.0),
-			friction: 1.2,
-			walk_accel: 90.0,
+			tick_rate: 100,
+			gravity: glam::Vec3::new(0.0,-100.0,0.0),
+			friction: 90.0,
 			mv: 2.7,
-			grounded: false,
+			grounded: true,
 			walkspeed: 18.0,
-			contacts: std::collections::HashSet::new(),
-			models_cringe_clone: modeldatas.iter().map(|m|strafe_client::body::Model::new(m.transform)).collect(),
-			walk: strafe_client::body::WalkState::new(),
-			hitbox_halfsize: glam::vec3(1.0,2.5,1.0),
-			camera: strafe_client::body::Camera::from_offset(glam::vec3(0.0,4.5-2.5,0.0),(config.width as f32)/(config.height as f32)),
-			mouse_interpolation: strafe_client::body::MouseInterpolationState::new(),
-			controls: 0,
 		};
 
-		let camera_uniforms = to_uniform_data(&physics.camera,physics.body.extrapolated_position(0));
+		let camera_uniforms = camera.to_uniform_data(physics.extrapolate_position(0));
 		let camera_buf = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
 			label: Some("Camera"),
 			contents: bytemuck::cast_slice(&camera_uniforms),
 			usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
 		});
 
-		//drain the modeldata vec so entities can be /moved/ to models.entities
-		let mut models = Vec::<ModelGraphics>::with_capacity(modeldatas.len());
-		for (i,modeldata) in modeldatas.drain(..).enumerate() {
-			let model_uniforms = get_transform_uniform_data(&modeldata.transform);
-			let model_buf = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
-				label: Some(format!("ModelGraphics{}",i).as_str()),
-				contents: bytemuck::cast_slice(&model_uniforms),
-				usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
-			});
-			let model_bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
-				layout: &model_bind_group_layout,
-				entries: &[
-					wgpu::BindGroupEntry {
-						binding: 0,
-						resource: model_buf.as_entire_binding(),
-					},
-				],
-				label: Some(format!("ModelGraphics{}",i).as_str()),
-			});
-			//all of these are being moved here
-			models.push(ModelGraphics{
-				transform: modeldata.transform,
-				vertex_buf:modeldata.vertex_buf,
-				entities: modeldata.entities,
-				bind_group: model_bind_group,
-				model_buf,
-			})
-		}
-
 		let pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
 			label: None,
 			bind_group_layouts: &[&main_bind_group_layout, &model_bind_group_layout],
@@ -470,11 +509,40 @@ impl strafe_client::framework::Example for Skybox {
 			label: Some("Camera"),
 		});
 
+		//drain the modeldata vec so entities can be /moved/ to models.entities
+		let mut models = Vec::<Model>::with_capacity(modeldatas.len());
+		for (i,modeldata) in modeldatas.drain(..).enumerate() {
+			let model_uniforms = get_transform_uniform_data(&modeldata.transform);
+			let model_buf = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
+				label: Some(format!("Model{}",i).as_str()),
+				contents: bytemuck::cast_slice(&model_uniforms),
+				usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
+			});
+			let model_bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
+				layout: &model_bind_group_layout,
+				entries: &[
+					wgpu::BindGroupEntry {
+						binding: 0,
+						resource: model_buf.as_entire_binding(),
+					},
+				],
+				label: Some(format!("Model{}",i).as_str()),
+			});
+			//all of these are being moved here
+			models.push(Model{
+				transform: modeldata.transform,
+				vertex_buf:modeldata.vertex_buf,
+				entities: modeldata.entities,
+				bind_group: model_bind_group,
+				model_buf,
+			})
+		}
+
 		let depth_view = Self::create_depth_texture(config, device);
 
 		Skybox {
 			start_time: Instant::now(),
-			screen_size: (config.width,config.height),
+			camera,
 			physics,
 			sky_pipeline,
 			entity_pipeline,
@@ -489,69 +557,61 @@ impl strafe_client::framework::Example for Skybox {
 
 	#[allow(clippy::single_match)]
 	fn update(&mut self, event: winit::event::WindowEvent) {
-		//nothing atm
-	}
-
-	fn device_event(&mut self, 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 {
-			winit::event::DeviceEvent::Key(winit::event::KeyboardInput {
-				state,
-				scancode: keycode,
+			winit::event::WindowEvent::KeyboardInput {
+				input:
+					winit::event::KeyboardInput {
+						state,
+						virtual_keycode: Some(keycode),
+						..
+					},
 				..
-			}) => {
-				let s=match state {
-					winit::event::ElementState::Pressed => true,
-					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,
-				}
-				{
-					self.physics.run(time);
-					self.physics.process_instruction(TimedInstruction{
-						time,
-						instruction:PhysicsInstruction::Input(input_instruction),
-					})
-				}
-			},
-			winit::event::DeviceEvent::MouseMotion {
-			    delta,//these (f64,f64) are integers on my machine
 			} => {
-				//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.
-				self.physics.process_instruction(TimedInstruction{
-					time,
-					instruction:PhysicsInstruction::Input(InputInstruction::MoveMouse(glam::ivec2(delta.0 as i32,delta.1 as i32))),
-				})
-			},
-			winit::event::DeviceEvent::MouseWheel {
-			    delta,
-			} => {
-				println!("mousewheel{:?}",delta);
-				if true{//self.physics.use_scroll
-					self.physics.run(time);
-					self.physics.process_instruction(TimedInstruction{
-						time,
-						instruction:PhysicsInstruction::Input(InputInstruction::Jump(true)),//activates the immediate jump path, but the style modifier prevents controls&CONTROL_JUMP bit from being set to auto jump
-					})
+				match (state,keycode) {
+					(k,winit::event::VirtualKeyCode::W) => match k {
+						winit::event::ElementState::Pressed => self.camera.controls|=CONTROL_MOVEFORWARD,
+						winit::event::ElementState::Released => self.camera.controls&=!CONTROL_MOVEFORWARD,
+					}
+					(k,winit::event::VirtualKeyCode::A) => match k {
+						winit::event::ElementState::Pressed => self.camera.controls|=CONTROL_MOVELEFT,
+						winit::event::ElementState::Released => self.camera.controls&=!CONTROL_MOVELEFT,
+					}
+					(k,winit::event::VirtualKeyCode::S) => match k {
+						winit::event::ElementState::Pressed => self.camera.controls|=CONTROL_MOVEBACK,
+						winit::event::ElementState::Released => self.camera.controls&=!CONTROL_MOVEBACK,
+					}
+					(k,winit::event::VirtualKeyCode::D) => match k {
+						winit::event::ElementState::Pressed => self.camera.controls|=CONTROL_MOVERIGHT,
+						winit::event::ElementState::Released => self.camera.controls&=!CONTROL_MOVERIGHT,
+					}
+					(k,winit::event::VirtualKeyCode::E) => match k {
+						winit::event::ElementState::Pressed => self.camera.controls|=CONTROL_MOVEUP,
+						winit::event::ElementState::Released => self.camera.controls&=!CONTROL_MOVEUP,
+					}
+					(k,winit::event::VirtualKeyCode::Q) => match k {
+						winit::event::ElementState::Pressed => self.camera.controls|=CONTROL_MOVEDOWN,
+						winit::event::ElementState::Released => self.camera.controls&=!CONTROL_MOVEDOWN,
+					}
+					(k,winit::event::VirtualKeyCode::Space) => match k {
+						winit::event::ElementState::Pressed => self.camera.controls|=CONTROL_JUMP,
+						winit::event::ElementState::Released => self.camera.controls&=!CONTROL_JUMP,
+					}
+					(k,winit::event::VirtualKeyCode::Z) => match k {
+						winit::event::ElementState::Pressed => self.camera.controls|=CONTROL_ZOOM,
+						winit::event::ElementState::Released => self.camera.controls&=!CONTROL_ZOOM,
+					}
+					_ => (),
 				}
 			}
-			_=>(),
+			_ => {}
 		}
 	}
 
+	fn move_mouse(&mut self, delta: (f64,f64)) {
+		self.camera.pitch=(self.camera.pitch as f64+delta.1/-2048.) as f32;
+		self.camera.yaw=(self.camera.yaw as f64+delta.0/-2048.) as f32;
+	}
+
 	fn resize(
 		&mut self,
 		config: &wgpu::SurfaceConfiguration,
@@ -559,8 +619,7 @@ impl strafe_client::framework::Example for Skybox {
 		_queue: &wgpu::Queue,
 	) {
 		self.depth_view = Self::create_depth_texture(config, device);
-		self.screen_size = (config.width, config.height);
-		self.physics.camera.set_fov_aspect(1.0,(config.width as f32)/(config.height as f32));
+		self.camera.screen_size = (config.width, config.height);
 	}
 
 	fn render(
@@ -570,15 +629,18 @@ impl strafe_client::framework::Example for Skybox {
 		queue: &wgpu::Queue,
 		_spawner: &strafe_client::framework::Spawner,
 	) {
+		let camera_mat=glam::Mat3::from_euler(glam::EulerRot::YXZ,self.camera.yaw,0f32,0f32);
+		let control_dir=camera_mat*get_control_dir(self.camera.controls&(CONTROL_MOVELEFT|CONTROL_MOVERIGHT|CONTROL_MOVEFORWARD|CONTROL_MOVEBACK)).normalize_or_zero();
+
 		let time=self.start_time.elapsed().as_nanos() as i64;
 
-		self.physics.run(time);
+		self.physics.run(time,control_dir,self.camera.controls);
 
 		let mut encoder =
 			device.create_command_encoder(&wgpu::CommandEncoderDescriptor { label: None });
 
 		// update rotation
-		let camera_uniforms = to_uniform_data(&self.physics.camera,self.physics.body.extrapolated_position(time));
+		let camera_uniforms = self.camera.to_uniform_data(self.physics.extrapolate_position(time));
 		self.staging_belt
 			.write_buffer(
 				&mut encoder,

src/sweep.rs

@@ -1,8 +0,0 @@
-
-//something that implements body + hitbox + transform can predict collision
-impl crate::sweep::PredictCollision for Model {
-	fn predict_collision(&self,other:&Model) -> Option<crate::event::EventStruct> {
-		//math!
-		None
-	}
-}

src/zeroes.rs

@@ -1,27 +0,0 @@
-//find roots of polynomials
-pub fn zeroes2(a0:f32,a1:f32,a2:f32) -> Vec<f32>{
-	if a2==0f32{
-		return zeroes1(a0, a1);
-	}
-	let mut radicand=a1*a1-4f32*a2*a0;
-	if 0f32<radicand {
-		radicand=radicand.sqrt();
-		if 0f32<a2 {
-			return vec![(-a1-radicand)/(2f32*a2),(-a1+radicand)/(2f32*a2)];
-		} else {
-			return vec![(-a1+radicand)/(2f32*a2),(-a1-radicand)/(2f32*a2)];
-		}
-	} else if radicand==0f32 {
-		return vec![-a1/(2f32*a2)];
-	} else {
-		return vec![];
-	}
-}
-#[inline]
-pub fn zeroes1(a0:f32,a1:f32) -> Vec<f32> {
-	if a1==0f32{
-		return vec![];
-	} else {
-		return vec![-a0/a1];
-	}
-}