minimize diff

Splits the MeshQuery trait into MeshQuery and MeshTopology and cleans up much of the physics traits.  A notable optimization is using a closure for iterating variable length topological lists.  Intermediate allocations are avoided in this way.

Reviewed-on: #33
Co-authored-by: Rhys Lloyd <krakow20@gmail.com>
Co-committed-by: Rhys Lloyd <krakow20@gmail.com>

engine/physics/src/minkowski.rs

@@ -1,4 +1,10 @@
+use core::ops::{Bound,RangeBounds};
+
+use strafesnet_common::integer::{Planar64Vec3,Ratio,Fixed,vec3::Vector3};
+use crate::model::into_giga_time;
+use crate::model::{SubmeshVertId,SubmeshEdgeId,SubmeshDirectedEdgeId,SubmeshFaceId,TransformedMesh,GigaTime};
 use crate::mesh_query::{MeshQuery,MeshTopology,DirectedEdge,UndirectedEdge};
+use crate::physics::{Time,Trajectory};
 
 struct AsRefHelper<T>(T);
 impl<T> AsRef<T> for AsRefHelper<T>{
@@ -7,30 +13,31 @@ impl<T> AsRef<T> for AsRefHelper<T>{
 	}
 }
 
-#[derive(Clone,Copy)]
-pub struct MinkowskiVert<M0:MeshTopology,M1:MeshTopology>{
-	vert0:M0::Vert,
-	vert1:M1::Vert,
+//Note that a face on a minkowski mesh refers to a pair of fevs on the meshes it's summed from
+//(face,vertex)
+//(edge,edge)
+//(vertex,face)
+#[derive(Clone,Copy,Debug,Eq,PartialEq)]
+pub enum MinkowskiVert{
+	VertVert(SubmeshVertId,SubmeshVertId),
 }
-#[derive(Clone,Copy)]
-pub enum MinkowskiEdge<M0:MeshTopology,M1:MeshTopology>{
-	VertEdge(M0::Vert,M1::Edge),
-	EdgeVert(M0::Edge,M1::Vert),
+// TODO: remove this
+impl core::ops::Neg for MinkowskiVert{
+	type Output=Self;
+	fn neg(self)->Self::Output{
+		match self{
+			MinkowskiVert::VertVert(v0,v1)=>MinkowskiVert::VertVert(v1,v0),
+		}
+	}
 }
-#[derive(Clone,Copy)]
-pub enum MinkowskiDirectedEdge<M0:MeshTopology,M1:MeshTopology>{
-	VertEdge(M0::Vert,M1::DirectedEdge),
-	EdgeVert(M0::DirectedEdge,M1::Vert),
+#[derive(Clone,Copy,Debug)]
+pub enum MinkowskiEdge{
+	VertEdge(SubmeshVertId,SubmeshEdgeId),
+	EdgeVert(SubmeshEdgeId,SubmeshVertId),
+	//EdgeEdge when edges are parallel
 }
-#[derive(Clone,Copy)]
-pub enum MinkowskiFace<M0:MeshTopology,M1:MeshTopology>{
-	VertFace(M0::Vert,M1::Face),
-	EdgeEdge(M0::Edge,M1::Edge,bool),
-	FaceVert(M0::Face,M1::Vert),
-}
-
-impl<M0:MeshTopology,M1:MeshTopology> UndirectedEdge for MinkowskiEdge<M0,M1>{
-	type DirectedEdge=MinkowskiDirectedEdge<M0,M1>;
+impl UndirectedEdge for MinkowskiEdge{
+	type DirectedEdge=MinkowskiDirectedEdge;
 	fn as_directed(self,parity:bool)->Self::DirectedEdge{
 		match self{
 			MinkowskiEdge::VertEdge(v0,e1)=>MinkowskiDirectedEdge::VertEdge(v0,e1.as_directed(parity)),
@@ -38,8 +45,14 @@ impl<M0:MeshTopology,M1:MeshTopology> UndirectedEdge for MinkowskiEdge<M0,M1>{
 		}
 	}
 }
-impl<M0:MeshTopology,M1:MeshTopology> DirectedEdge for MinkowskiDirectedEdge<M0,M1>{
-	type UndirectedEdge=MinkowskiEdge<M0,M1>;
+#[derive(Clone,Copy,Debug)]
+pub enum MinkowskiDirectedEdge{
+	VertEdge(SubmeshVertId,SubmeshDirectedEdgeId),
+	EdgeVert(SubmeshDirectedEdgeId,SubmeshVertId),
+	//EdgeEdge when edges are parallel
+}
+impl DirectedEdge for MinkowskiDirectedEdge{
+	type UndirectedEdge=MinkowskiEdge;
 	fn as_undirected(self)->Self::UndirectedEdge{
 		match self{
 			MinkowskiDirectedEdge::VertEdge(v0,e1)=>MinkowskiEdge::VertEdge(v0,e1.as_undirected()),
@@ -48,27 +61,156 @@ impl<M0:MeshTopology,M1:MeshTopology> DirectedEdge for MinkowskiDirectedEdge<M0,
 	}
 	fn parity(&self)->bool{
 		match self{
-			MinkowskiDirectedEdge::VertEdge(_,e)=>e.parity(),
-			MinkowskiDirectedEdge::EdgeVert(e,_)=>e.parity(),
+			MinkowskiDirectedEdge::VertEdge(_,e)
+			|MinkowskiDirectedEdge::EdgeVert(e,_)=>e.parity(),
 		}
 	}
 }
-
-pub struct Minkowski<M0,M1>{
-	mesh0:M0,
-	mesh1:M1,
+#[derive(Clone,Copy,Debug,Hash)]
+pub enum MinkowskiFace{
+	VertFace(SubmeshVertId,SubmeshFaceId),
+	EdgeEdge(SubmeshEdgeId,SubmeshEdgeId,bool),
+	FaceVert(SubmeshFaceId,SubmeshVertId),
+	//EdgeFace
+	//FaceEdge
+	//FaceFace
 }
 
-impl<M0,M1> Minkowski<M0,M1>{
-	pub fn sum(mesh0:M0,mesh1:M1)->Self{
-		Self{mesh0,mesh1}
+#[derive(Debug)]
+pub struct MinkowskiMesh<'a>{
+	mesh0:TransformedMesh<'a>,
+	mesh1:TransformedMesh<'a>,
+}
+
+// TODO: remove this
+impl<'a> core::ops::Neg for &MinkowskiMesh<'a>{
+	type Output=MinkowskiMesh<'a>;
+	fn neg(self)->Self::Output{
+		MinkowskiMesh::minkowski_sum(self.mesh1,self.mesh0)
 	}
 }
-impl<M0:MeshTopology,M1:MeshTopology> MeshTopology for Minkowski<M0,M1>{
-	type Vert=MinkowskiVert<M0,M1>;
-	type Edge=MinkowskiEdge<M0,M1>;
-	type DirectedEdge=MinkowskiDirectedEdge<M0,M1>;
-	type Face=MinkowskiFace<M0,M1>;
+
+impl MinkowskiMesh<'_>{
+	pub fn minkowski_sum<'a>(mesh0:TransformedMesh<'a>,mesh1:TransformedMesh<'a>)->MinkowskiMesh<'a>{
+		MinkowskiMesh{
+			mesh0,
+			mesh1,
+		}
+	}
+	pub fn predict_collision_in(&self,trajectory:&Trajectory,range:impl RangeBounds<Time>)->Option<(MinkowskiFace,GigaTime)>{
+		let start_position=match range.start_bound(){
+			Bound::Included(time)=>trajectory.extrapolated_position(*time),
+			Bound::Excluded(time)=>trajectory.extrapolated_position(*time),
+			Bound::Unbounded=>trajectory.position,
+		};
+		let fev=crate::minimum_difference::closest_fev_not_inside(self,start_position)?;
+		//continue forwards along the body parabola
+		fev.crawl(self,trajectory,range.start_bound(),range.end_bound()).hit()
+	}
+	pub fn predict_collision_out(&self,trajectory:&Trajectory,range:impl RangeBounds<Time>)->Option<(MinkowskiFace,GigaTime)>{
+		let (lower_bound,upper_bound)=(range.start_bound(),range.end_bound());
+		// TODO: handle unbounded collision using infinity fev
+		let start_position=match upper_bound{
+			Bound::Included(time)=>trajectory.extrapolated_position(*time),
+			Bound::Excluded(time)=>trajectory.extrapolated_position(*time),
+			Bound::Unbounded=>trajectory.position,
+		};
+		let fev=crate::minimum_difference::closest_fev_not_inside(self,start_position)?;
+		// swap and negate bounds to do a time inversion
+		let (lower_bound,upper_bound)=(upper_bound.map(|&t|-t),lower_bound.map(|&t|-t));
+		let time_reversed_trajectory=-trajectory;
+		//continue backwards along the body parabola
+		fev.crawl(self,&time_reversed_trajectory,lower_bound.as_ref(),upper_bound.as_ref()).hit()
+			//no need to test -time<time_limit because of the first step
+			.map(|(face,time)|(face,-time))
+	}
+	pub fn predict_collision_face_out(&self,trajectory:&Trajectory,range:impl RangeBounds<Time>,contact_face_id:MinkowskiFace)->Option<(MinkowskiDirectedEdge,GigaTime)>{
+		// TODO: make better
+		use crate::face_crawler::{low,upp};
+		//no algorithm needed, there is only one state and two cases (Edge,None)
+		//determine when it passes an edge ("sliding off" case)
+		let start_time=range.start_bound().map(|&t|(t-trajectory.time).to_ratio());
+		let mut best_time=range.end_bound().map(|&t|into_giga_time(t,trajectory.time));
+		let mut best_edge=None;
+		let face_n=self.face_nd(contact_face_id).0;
+		self.for_each_face_edge(contact_face_id,|directed_edge_id|{
+			let edge_n=self.directed_edge_n(directed_edge_id);
+			//f x e points in
+			let n=face_n.cross(edge_n);
+			let &[v0,v1]=self.edge_verts(directed_edge_id.as_undirected()).as_ref();
+			let d=n.dot(self.vert(v0)+self.vert(v1));
+			//WARNING! d outside of *2
+			//WARNING: truncated precision
+			//wrap for speed
+			for dt in Fixed::<4,128>::zeroes2(((n.dot(trajectory.position))*2-d).wrap_4(),n.dot(trajectory.velocity).wrap_4()*2,n.dot(trajectory.acceleration).wrap_4()){
+				if low(&start_time,&dt)&&upp(&dt,&best_time)&&n.dot(trajectory.extrapolated_velocity_ratio_dt(dt)).is_negative(){
+					best_time=Bound::Included(dt);
+					best_edge=Some((directed_edge_id,dt));
+					break;
+				}
+			}
+		});
+		best_edge
+	}
+	pub fn contains_point(&self,point:Planar64Vec3)->bool{
+		crate::minimum_difference::contains_point(self,point)
+	}
+}
+impl MeshQuery for MinkowskiMesh<'_>{
+	type Direction=Planar64Vec3;
+	type Position=Planar64Vec3;
+	type Normal=Vector3<Fixed<3,96>>;
+	type Offset=Fixed<4,128>;
+	// TODO: relative d
+	fn face_nd(&self,face_id:MinkowskiFace)->(Self::Normal,Self::Offset){
+		match face_id{
+			MinkowskiFace::VertFace(v0,f1)=>{
+				let (n,d)=self.mesh1.face_nd(f1);
+				(-n,d-n.dot(self.mesh0.vert(v0)))
+			},
+			MinkowskiFace::EdgeEdge(e0,e1,parity)=>{
+				let edge0_n=self.mesh0.edge_n(e0);
+				let edge1_n=self.mesh1.edge_n(e1);
+				let &[e0v0,e0v1]=self.mesh0.edge_verts(e0).as_ref();
+				let &[e1v0,e1v1]=self.mesh1.edge_verts(e1).as_ref();
+				let n=edge0_n.cross(edge1_n);
+				let e0d=n.dot(self.mesh0.vert(e0v0)+self.mesh0.vert(e0v1));
+				let e1d=n.dot(self.mesh1.vert(e1v0)+self.mesh1.vert(e1v1));
+				((n*(parity as i64*4-2)).widen_3(),((e0d-e1d)*(parity as i64*2-1)).widen_4())
+			},
+			MinkowskiFace::FaceVert(f0,v1)=>{
+				let (n,d)=self.mesh0.face_nd(f0);
+				(n,d-n.dot(self.mesh1.vert(v1)))
+			},
+		}
+	}
+	fn vert(&self,vert_id:MinkowskiVert)->Planar64Vec3{
+		match vert_id{
+			MinkowskiVert::VertVert(v0,v1)=>{
+				self.mesh0.vert(v0)-self.mesh1.vert(v1)
+			},
+		}
+	}
+	fn hint_point(&self)->Planar64Vec3{
+		self.mesh0.hint_point()-self.mesh1.hint_point()
+	}
+	fn farthest_vert(&self,dir:Planar64Vec3)->MinkowskiVert{
+		MinkowskiVert::VertVert(self.mesh0.farthest_vert(dir),self.mesh1.farthest_vert(-dir))
+	}
+	fn edge_n(&self,edge_id:Self::Edge)->Self::Direction{
+		let &[v0,v1]=self.edge_verts(edge_id).as_ref();
+		self.vert(v1)-self.vert(v0)
+	}
+	fn directed_edge_n(&self,directed_edge_id:Self::DirectedEdge)->Self::Direction{
+		let &[v0,v1]=self.edge_verts(directed_edge_id.as_undirected()).as_ref();
+		(self.vert(v1)-self.vert(v0))*((directed_edge_id.parity() as i64)*2-1)
+	}
+}
+impl MeshTopology for MinkowskiMesh<'_>{
+	type Face=MinkowskiFace;
+	type Edge=MinkowskiEdge;
+	type DirectedEdge=MinkowskiDirectedEdge;
+	type Vert=MinkowskiVert;
 	fn for_each_vert_edge(&self,vert_id:Self::Vert,mut f:impl FnMut(Self::DirectedEdge)){
 		match vert_id{
 			MinkowskiVert::VertVert(v0,v1)=>{
@@ -233,67 +375,33 @@ impl<M0:MeshTopology,M1:MeshTopology> MeshTopology for Minkowski<M0,M1>{
 	}
 }
 
-use strafesnet_common::integer::vec3::Vector3;
-use strafesnet_common::integer::Fixed;
-impl<M0:MeshQuery,M1:MeshQuery> MeshQuery for Minkowski<M0,M1>
-where
-	M0:MeshQuery<
-		Direction=Vector3<Fixed<1,32>>,
-		Position=Vector3<Fixed<1,32>>,
-		Normal=Vector3<Fixed<3,96>>,
-		Offset=Fixed<4,128>,
-	>,
-	M1:MeshQuery<
-		Direction=Vector3<Fixed<1,32>>,
-		Position=Vector3<Fixed<1,32>>,
-		Normal=Vector3<Fixed<3,96>>,
-		Offset=Fixed<4,128>,
-	>,
-{
-	type Direction=M0::Direction;
-	type Position=M0::Position;
-	type Normal=M0::Normal;
-	type Offset=M0::Offset;
-	fn vert(&self,vert_id:MinkowskiVert<M0,M1>)->Planar64Vec3{
-		self.mesh0.vert(vert_id.vert0)-self.mesh1.vert(vert_id.vert1)
-	}
-	fn face_nd(&self,face_id:MinkowskiFace<M0,M1>)->(Self::Normal,Self::Offset){
-		match face_id{
-			MinkowskiFace::VertFace(v0,f1)=>{
-				let (n,d)=self.mesh1.face_nd(f1);
-				(-n,d-n.dot(self.mesh0.vert(v0)))
-			},
-			MinkowskiFace::EdgeEdge(e0,e1,parity)=>{
-				let edge0_n=self.mesh0.edge_n(e0);
-				let edge1_n=self.mesh1.edge_n(e1);
-				let &[e0v0,e0v1]=self.mesh0.edge_verts(e0).as_ref();
-				let &[e1v0,e1v1]=self.mesh1.edge_verts(e1).as_ref();
-				let n=edge0_n.cross(edge1_n);
-				let e0d=n.dot(self.mesh0.vert(e0v0)+self.mesh0.vert(e0v1));
-				let e1d=n.dot(self.mesh1.vert(e1v0)+self.mesh1.vert(e1v1));
-				((n*(parity as i64*4-2)).widen_3(),((e0d-e1d)*(parity as i64*2-1)).widen_4())
-			},
-			MinkowskiFace::FaceVert(f0,v1)=>{
-				let (n,d)=self.mesh0.face_nd(f0);
-				(n,d-n.dot(self.mesh1.vert(v1)))
-			},
+fn is_empty_volume(normals:&[Vector3<Fixed<3,96>>])->bool{
+	let len=normals.len();
+	for i in 0..len-1{
+		for j in i+1..len{
+			let n=normals[i].cross(normals[j]);
+			let mut d_comp=None;
+			for k in 0..len{
+				if k!=i&&k!=j{
+					let d=n.dot(normals[k]).is_negative();
+					if let &Some(comp)=&d_comp{
+						// This is testing if d_comp*d < 0
+						if comp^d{
+							return true;
+						}
+					}else{
+						d_comp=Some(d);
+					}
+				}
+			}
 		}
 	}
-	fn hint_point(&self)->Planar64Vec3{
-		self.mesh0.hint_point()-self.mesh1.hint_point()
-	}
-	fn farthest_vert(&self,dir:Planar64Vec3)->MinkowskiVert{
-		MinkowskiVert{
-			vert0:self.mesh0.farthest_vert(dir),
-			vert1:self.mesh1.farthest_vert(-dir),
-		}
-	}
-	fn edge_n(&self,edge_id:Self::Edge)->Self::Direction{
-		let &[v0,v1]=self.edge_verts(edge_id).as_ref();
-		self.vert(v1)-self.vert(v0)
-	}
-	fn directed_edge_n(&self,directed_edge_id:Self::DirectedEdge)->Self::Direction{
-		let &[v0,v1]=self.edge_verts(directed_edge_id.as_undirected()).as_ref();
-		(self.vert(v1)-self.vert(v0))*((directed_edge_id.parity() as i64)*2-1)
-	}
+	return false;
+}
+
+#[test]
+fn test_is_empty_volume(){
+	use strafesnet_common::integer::vec3;
+	assert!(!is_empty_volume(&[vec3::X.widen_3(),vec3::Y.widen_3(),vec3::Z.widen_3()]));
+	assert!(is_empty_volume(&[vec3::X.widen_3(),vec3::Y.widen_3(),vec3::Z.widen_3(),vec3::NEG_X.widen_3()]));
 }

engine/physics/src/physics.rs

@@ -57,6 +57,9 @@ impl InputState{
 	fn replace_mouse(&mut self,mouse:MouseState,next_mouse:MouseState){
 		(self.next_mouse,self.mouse)=(next_mouse,mouse);
 	}
+	fn get_control(&self,control:Controls)->bool{
+		self.controls.contains(control)
+	}
 	fn set_control(&mut self,control:Controls,state:bool){
 		self.controls.set(control,state)
 	}
@@ -492,6 +495,27 @@ impl StyleHelper for StyleModifiers{
 	}
 }
 #[derive(Clone,Debug)]
+struct StrafeTickState{
+	tick_number:u64,
+}
+impl StrafeTickState{
+	fn new(time:Time,settings:&gameplay_style::StrafeSettings)->Self{
+		// let time=n*seconds/ticks;
+		let time=time.nanos() as i128;
+		let ticks=settings.tick_rate.num() as i128;
+		let seconds=settings.tick_rate.den() as i128;
+		let tick_number=(time*ticks/seconds) as u64;
+		StrafeTickState{tick_number}
+	}
+	fn next_tick(&self,settings:&gameplay_style::StrafeSettings)->Time{
+		let n=self.tick_number as i128;
+		let ticks=settings.tick_rate.num() as i128;
+		let seconds=settings.tick_rate.den() as i128;
+		let time=n*seconds/ticks;
+		Time::from_nanos(time as i64)
+	}
+}
+#[derive(Clone,Debug)]
 enum MoveState{
 	Air,
 	Walk(ContactMoveState),
@@ -569,7 +593,7 @@ impl MoveState{
 			=>None,
 		}
 	}
-	fn next_move_instruction(&self,strafe:&Option<gameplay_style::StrafeSettings>,time:Time)->Option<TimedInstruction<InternalInstruction,Time>>{
+	fn next_move_instruction(&self,strafe:Option<&gameplay_style::StrafeSettings>,strafe_tick_state:&StrafeTickState)->Option<TimedInstruction<InternalInstruction,Time>>{
 		//check if you have a valid walk state and create an instruction
 		match self{
 			MoveState::Walk(walk_state)|MoveState::Ladder(walk_state)=>match &walk_state.target{
@@ -583,7 +607,7 @@ impl MoveState{
 			}
 			MoveState::Air=>strafe.as_ref().map(|strafe|{
 				TimedInstruction{
-					time:strafe.next_tick(time),
+					time:strafe_tick_state.next_tick(strafe),
 					//only poll the physics if there is a before and after mouse event
 					instruction:InternalInstruction::StrafeTick
 				}
@@ -868,6 +892,7 @@ pub struct PhysicsState{
 	//gameplay_state
 	mode_state:ModeState,
 	move_state:MoveState,
+	strafe_tick_state:StrafeTickState,
 	//run is non optional: when you spawn in a run is created
 	//the run cannot be finished unless you start it by visiting
 	//a start zone.  If you change mode, a new run is created.
@@ -886,6 +911,7 @@ impl Default for PhysicsState{
 			input_state:InputState::default(),
 			_world:WorldState{},
 			mode_state:ModeState::default(),
+			strafe_tick_state:StrafeTickState::new(Time::ZERO,&StyleModifiers::default().strafe.unwrap()),
 			run:run::Run::new(),
 		}
 	}
@@ -922,6 +948,9 @@ impl PhysicsState{
 	pub fn get_finish_time(&self)->Option<run::Time>{
 		self.run.get_finish_time()
 	}
+	fn is_no_clip_enabled(&self)->bool{
+		self.input_state.get_control(Controls::Sprint)
+	}
 	pub fn clear(&mut self){
 		self.touching.clear();
 	}
@@ -929,7 +958,7 @@ impl PhysicsState{
 		*self=Self::default();
 	}
 	fn next_move_instruction(&self)->Option<TimedInstruction<InternalInstruction,Time>>{
-		self.move_state.next_move_instruction(&self.style.strafe,self.time)
+		self.move_state.next_move_instruction(self.style.strafe.as_ref(),&self.strafe_tick_state)
 	}
 	fn cull_velocity(&mut self,data:&PhysicsData,velocity:Planar64Vec3){
 		self.move_state.cull_velocity(velocity,&mut self.body,&mut self.touching,&data.models,&data.hitbox_mesh,&self.style,&self.camera,&self.input_state);
@@ -1195,6 +1224,11 @@ fn next_instruction_internal(state:&PhysicsState,data:&PhysicsData,time_limit:Ti
 	let trajectory=state.body.with_acceleration(state.acceleration(data));
 	//check for collision ends
 	state.touching.predict_collision_end(&mut collector,&data.models,&data.hitbox_mesh,&trajectory,state.time);
+
+	if state.is_no_clip_enabled(){
+		return collector.take();
+	}
+
 	//check for collision starts
 	let mut aabb=aabb::Aabb::default();
 	trajectory.grow_aabb(&mut aabb,state.time,collector.time());
@@ -1782,6 +1816,7 @@ fn atomic_internal_instruction(state:&mut PhysicsState,data:&PhysicsData,ins:Tim
 			),
 		},
 		InternalInstruction::StrafeTick=>{
+			state.strafe_tick_state.tick_number+=1;
 			//TODO make this less huge
 			if let Some(strafe_settings)=&state.style.strafe{
 				let controls=state.input_state.controls;
@@ -1862,7 +1897,8 @@ fn atomic_input_instruction(state:&mut PhysicsState,data:&PhysicsData,ins:TimedI
 			state.input_state.set_next_mouse(m);
 		},
 		Instruction::Mouse(MouseInstruction::ReplaceMouse{m0,m1})=>{
-			state.camera.move_mouse(m0.pos-state.input_state.mouse.pos);
+			state.camera.move_mouse(state.input_state.mouse_delta());
+			state.camera.move_mouse(m0.pos-state.input_state.next_mouse.pos);
 			state.input_state.replace_mouse(m0,m1);
 		},
 		Instruction::Misc(MiscInstruction::SetSensitivity(sensitivity))=>state.camera.sensitivity=sensitivity,

lib/common/src/gameplay_style.rs

@@ -2,7 +2,6 @@ const VALVE_SCALE:Planar64=Planar64::raw(1<<28);// 1/16
 
 use crate::integer::{int,vec3::int as int3,AbsoluteTime,Ratio64,Planar64,Planar64Vec3};
 use crate::controls_bitflag::Controls;
-use crate::physics::Time as PhysicsTime;
 
 #[derive(Clone,Debug)]
 pub struct StyleModifiers{
@@ -273,9 +272,6 @@ impl StrafeSettings{
 			false=>None,
 		}
 	}
-	pub fn next_tick(&self,time:PhysicsTime)->PhysicsTime{
-		PhysicsTime::from_nanos(self.tick_rate.rhs_div_int(self.tick_rate.mul_int(time.nanos())+1))
-	}
 	pub const fn activates(&self,controls:Controls)->bool{
 		self.enable.activates(controls)
 	}

lib/fixed_wide/src/fixed.rs

@@ -7,7 +7,7 @@ const BNUM_DIGIT_WIDTH:usize=64;
 /// N is the number of u64s to use
 /// F is the number of fractional bits (always N*32 lol)
 pub struct Fixed<const N:usize,const F:usize>{
-	pub(crate)bits:BInt<{N}>,
+	bits:BInt<{N}>,
 }
 
 impl<const N:usize,const F:usize> Fixed<N,F>{
@@ -545,7 +545,7 @@ impl_shift_operator!( Fixed, Shr, shr, Self );
 
 // wide operators.  The result width is the sum of the input widths, i.e. none of the multiplication
 
-#[expect(unused_macros)]
+#[allow(unused_macros)]
 macro_rules! impl_wide_operators{
 	($lhs:expr,$rhs:expr)=>{
 		impl core::ops::Mul<Fixed<$rhs,{$rhs*32}>> for Fixed<$lhs,{$lhs*32}>{

strafe-client/src/setup.rs

@@ -45,8 +45,6 @@ struct SetupContextPartial2<'a>{
 }
 impl<'a> SetupContextPartial2<'a>{
 	fn pick_adapter(self)->SetupContextPartial3<'a>{
-		let adapter;
-
 		//TODO: prefer adapter that implements optional features
 		//let optional_features=optional_features();
 		let required_features=required_features();
@@ -54,33 +52,22 @@ impl<'a> SetupContextPartial2<'a>{
 		//no helper function smh gotta write it myself
 		let adapters=pollster::block_on(self.instance.enumerate_adapters(self.backends));
 
-		let mut chosen_adapter=None;
-		let mut chosen_adapter_score=0;
-		for adapter in adapters {
-			if !adapter.is_surface_supported(&self.surface) {
-				continue;
-			}
-
-			let score=match adapter.get_info().device_type{
+		let chosen_adapter=adapters.into_iter()
+			// reverse because we want to select adapters that appear first in ties,
+			// and max_by_key selects the last equal element in the iterator.
+			.rev()
+			.filter(|adapter|
+				adapter.is_surface_supported(&self.surface)
+				&&adapter.features().contains(required_features)
+			)
+			.max_by_key(|adapter|match adapter.get_info().device_type{
 				wgpu::DeviceType::IntegratedGpu=>3,
 				wgpu::DeviceType::DiscreteGpu=>4,
 				wgpu::DeviceType::VirtualGpu=>2,
 				wgpu::DeviceType::Other|wgpu::DeviceType::Cpu=>1,
-			};
-
-			let adapter_features=adapter.features();
-			if chosen_adapter_score<score&&adapter_features.contains(required_features) {
-				chosen_adapter_score=score;
-				chosen_adapter=Some(adapter);
-			}
-		}
-
-		if let Some(maybe_chosen_adapter)=chosen_adapter{
-			adapter=maybe_chosen_adapter;
-		}else{
-			panic!("No suitable GPU adapters found on the system!");
-		}
+			});
 
+		let adapter=chosen_adapter.expect("No suitable GPU adapters found on the system!");
 
 		let adapter_info=adapter.get_info();
 		println!("Using {} ({:?})", adapter_info.name, adapter_info.backend);