script invocation

The build fails due to using an outdated compiler.  Odd considering it was updated recently.

Cargo.toml

@@ -24,14 +24,3 @@ resolver = "2"
 #lto = true
 strip = true
 codegen-units = 1
-
-[workspace.lints.rust]
-# unsafe_code = "forbid"
-# missing_docs = "warn"
-# missing_debug_implementations = "warn"
-single_use_lifetimes = "warn"
-trivial_casts = "warn"
-unused_lifetimes = "warn"
-unused_qualifications = "warn"
-# variant_size_differences = "warn"
-unexpected_cfgs = "warn"

docker/aarch64-apple-darwin.Dockerfile

@@ -0,0 +1,10 @@
+FROM docker.io/joseluisq/rust-linux-darwin-builder:2.0.0-beta.1-amd64 as build
+COPY .cargo/config.toml .cargo/config.toml
+COPY . .
+RUN cargo build --bin strafe-client --release --target aarch64-apple-darwin
+# RUN cargo build --release --target x86_64-apple-darwin
+
+# isolate the binary
+FROM scratch
+COPY --from=build /root/src/target/aarch64-apple-darwin/release/strafe-client /
+ENTRYPOINT ["/strafe-client"]

docker/build-apple.sh

@@ -0,0 +1 @@
+docker build -f docker/aarch64-apple-darwin.Dockerfile . -o target/aarch64-apple-darwin/release/

engine/graphics/Cargo.toml

@@ -11,7 +11,4 @@ id = { version = "0.1.0", registry = "strafesnet" }
 strafesnet_common = { path = "../../lib/common", registry = "strafesnet" }
 strafesnet_session = { path = "../session", registry = "strafesnet" }
 strafesnet_settings = { path = "../settings", registry = "strafesnet" }
-wgpu = "27.0.0"
+wgpu = "26.0.1"
-
-[lints]
-workspace = true

engine/graphics/src/graphics.rs

@@ -94,7 +94,7 @@ impl GraphicsCamera{
 		raw
 	}
 }
-impl Default for GraphicsCamera{
+impl std::default::Default for GraphicsCamera{
 	fn default()->Self{
 		Self{
 			screen_size:glam::UVec2::ONE,
@@ -167,7 +167,7 @@ impl GraphicsState{
 	}
 	pub fn generate_models(&mut self,device:&wgpu::Device,queue:&wgpu::Queue,map:&map::CompleteMap){
 		//generate texture view per texture
-		let texture_views:HashMap<model::TextureId,wgpu::TextureView>=map.textures.iter().enumerate().filter_map(|(texture_id,texture_data)|{
+		let texture_views:HashMap<strafesnet_common::model::TextureId,wgpu::TextureView>=map.textures.iter().enumerate().filter_map(|(texture_id,texture_data)|{
 			let texture_id=model::TextureId::new(texture_id as u32);
 			let image=match ddsfile::Dds::read(std::io::Cursor::new(texture_data)){
 				Ok(image)=>image,
@@ -803,7 +803,7 @@ impl GraphicsState{
 				module:&shader,
 				entry_point:Some("vs_entity_texture"),
 				buffers:&[wgpu::VertexBufferLayout{
-					array_stride:size_of::<GraphicsVertex>() as wgpu::BufferAddress,
+					array_stride:std::mem::size_of::<GraphicsVertex>() as wgpu::BufferAddress,
 					step_mode:wgpu::VertexStepMode::Vertex,
 					attributes:&wgpu::vertex_attr_array![0=>Float32x3,1=>Float32x2,2=>Float32x3,3=>Float32x4],
 				}],

engine/physics/Cargo.toml

@@ -8,6 +8,3 @@ arrayvec = "0.7.6"
 glam = "0.30.0"
 id = { version = "0.1.0", registry = "strafesnet" }
 strafesnet_common = { path = "../../lib/common", registry = "strafesnet" }
-
-[lints]
-workspace = true

engine/physics/src/body.rs

@@ -33,7 +33,7 @@ impl<T:Copy> std::ops::Neg for &Body<T>{
 impl<T> Body<T>
 	where Time<T>:Copy,
 {
-	pub const ZERO:Self=Self::new(vec3::zero(),vec3::zero(),vec3::zero(),Time::ZERO);
+	pub const ZERO:Self=Self::new(vec3::ZERO,vec3::ZERO,vec3::ZERO,Time::ZERO);
 	pub const fn new(position:Planar64Vec3,velocity:Planar64Vec3,acceleration:Planar64Vec3,time:Time<T>)->Self{
 		Self{
 			position,
@@ -107,8 +107,8 @@ impl<T> Body<T>
 		self.time+=dt.into();
 	}
 	pub fn infinity_dir(&self)->Option<Planar64Vec3>{
-		if self.velocity==vec3::zero(){
+		if self.velocity==vec3::ZERO{
-			if self.acceleration==vec3::zero(){
+			if self.acceleration==vec3::ZERO{
 				None
 			}else{
 				Some(self.acceleration)

engine/physics/src/face_crawler.rs

@@ -74,13 +74,13 @@ impl<F:Copy,M:MeshQuery<Normal=Vector3<F>,Offset=Fixed<4,128>>> FEV<M>
 	where
 		// This is hardcoded for MinkowskiMesh lol
 		M::Face:Copy,
-		M::Edge:Copy+core::fmt::Debug,
+		M::Edge:Copy,
-		M::Vert:Copy+core::fmt::Debug,
+		M::Vert:Copy,
 		F:core::ops::Mul<Fixed<1,32>,Output=Fixed<4,128>>,
 		<F as core::ops::Mul<Fixed<1,32>>>::Output:core::iter::Sum,
 		M::Offset:core::ops::Sub<<F as std::ops::Mul<Fixed<1,32>>>::Output>,
 {
-	fn next_transition<const ENABLE_DEBUG:bool>(&self,mesh:&M,body:&Body,lower_bound:Bound<GigaTime>,mut upper_bound:Bound<GigaTime>)->Transition<M>{
+	fn next_transition(&self,mesh:&M,body:&Body,lower_bound:Bound<GigaTime>,mut upper_bound:Bound<GigaTime>)->Transition<M>{
 		//conflicting derivative means it crosses in the wrong direction.
 		//if the transition time is equal to an already tested transition, do not replace the current best.
 		let mut best_transition=Transition::Miss;
@@ -132,9 +132,6 @@ impl<F:Copy,M:MeshQuery<Normal=Vector3<F>,Offset=Fixed<4,128>>> FEV<M>
 					//wrap for speed
 					for dt in Fixed::<4,128>::zeroes2(n.dot(delta_pos).wrap_4(),n.dot(body.velocity).wrap_4()*2,n.dot(body.acceleration).wrap_4()){
 						if low(&lower_bound,&dt)&&upp(&dt,&upper_bound)&&n.dot(body.extrapolated_velocity_ratio_dt(dt)).is_negative(){
-							if ENABLE_DEBUG{
-								println!("Face Crawler FEV::Edge({edge_id:?}) -> FEV::Face");
-							}
 							upper_bound=Bound::Included(dt);
 							best_transition=Transition::Next(FEV::Face(edge_face_id),dt);
 							break;
@@ -163,9 +160,6 @@ impl<F:Copy,M:MeshQuery<Normal=Vector3<F>,Offset=Fixed<4,128>>> FEV<M>
 					let n=-mesh.directed_edge_n(directed_edge_id);
 					for dt in Fixed::<2,64>::zeroes2((n.dot(body.position-mesh.vert(vert_id)))*2,n.dot(body.velocity)*2,n.dot(body.acceleration)){
 						if low(&lower_bound,&dt)&&upp(&dt,&upper_bound)&&n.dot(body.extrapolated_velocity_ratio_dt(dt)).is_negative(){
-							if ENABLE_DEBUG{
-								println!("Face Crawler FEV::Vert({vert_id:?}) -> FEV::Edge");
-							}
 							let dt=Ratio::new(dt.num.widen_4(),dt.den.widen_4());
 							upper_bound=Bound::Included(dt);
 							best_transition=Transition::Next(FEV::Edge(directed_edge_id.as_undirected()),dt);
@@ -178,11 +172,11 @@ impl<F:Copy,M:MeshQuery<Normal=Vector3<F>,Offset=Fixed<4,128>>> FEV<M>
 		}
 		best_transition
 	}
-	pub fn crawl<const ENABLE_DEBUG:bool>(mut self,mesh:&M,relative_body:&Body,lower_bound:Bound<&Time>,upper_bound:Bound<&Time>)->CrawlResult<M>{
+	pub fn crawl(mut self,mesh:&M,relative_body:&Body,lower_bound:Bound<&Time>,upper_bound:Bound<&Time>)->CrawlResult<M>{
 		let mut lower_bound=lower_bound.map(|&t|into_giga_time(t,relative_body.time));
 		let upper_bound=upper_bound.map(|&t|into_giga_time(t,relative_body.time));
 		for _ in 0..20{
-			match self.next_transition::<ENABLE_DEBUG>(mesh,relative_body,lower_bound,upper_bound){
+			match self.next_transition(mesh,relative_body,lower_bound,upper_bound){
 				Transition::Miss=>return CrawlResult::Miss(self),
 				Transition::Next(next_fev,next_time)=>(self,lower_bound)=(next_fev,Bound::Included(next_time)),
 				Transition::Hit(face,time)=>return CrawlResult::Hit(face,time),

engine/physics/src/model.rs

@@ -90,9 +90,6 @@ pub trait MeshQuery{
 		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)
 	}
-	/// This must return a point inside the mesh.
-	#[expect(dead_code)]
-	fn hint_point(&self)->Planar64Vec3;
 	fn vert(&self,vert_id:Self::Vert)->Planar64Vec3;
 	fn face_nd(&self,face_id:Self::Face)->(Self::Normal,Self::Offset);
 	fn face_edges(&self,face_id:Self::Face)->impl AsRef<[Self::Edge]>;
@@ -103,21 +100,17 @@ pub trait MeshQuery{
 }
 #[derive(Debug)]
 struct FaceRefs{
-	// I didn't write it down, but I assume the edges are directed
-	// clockwise when looking towards the face normal, i.e. right hand rule.
 	edges:Vec<SubmeshDirectedEdgeId>,
-	//verts are redundant, use edge[i].verts[0]
 	//verts:Vec<VertId>,
 }
 #[derive(Debug)]
 struct EdgeRefs{
 	faces:[SubmeshFaceId;2],//left, right
-	verts:[SubmeshVertId;2],//start, end
+	verts:[SubmeshVertId;2],//bottom, top
 }
 #[derive(Debug)]
 struct VertRefs{
 	faces:Vec<SubmeshFaceId>,
-	// edges are always directed away from the vert
 	edges:Vec<SubmeshDirectedEdgeId>,
 }
 #[derive(Debug)]
@@ -454,10 +447,6 @@ impl MeshQuery for PhysicsMeshView<'_>{
 		let face_idx=self.topology.faces[face_id.get() as usize].get() as usize;
 		(self.data.faces[face_idx].normal,self.data.faces[face_idx].dot)
 	}
-	fn hint_point(&self)->Planar64Vec3{
-		// invariant: meshes always encompass the origin
-		vec3::zero()
-	}
 	//ideally I never calculate the vertex position, but I have to for the graphical meshes...
 	fn vert(&self,vert_id:SubmeshVertId)->Planar64Vec3{
 		let vert_idx=self.topology.verts[vert_id.get() as usize].get() as usize;
@@ -511,7 +500,7 @@ impl TransformedMesh<'_>{
 			transform,
 		}
 	}
-	pub fn verts<'a>(&'a self)->impl Iterator<Item=Vector3<Fixed<2,64>>>+'a{
+	pub fn verts<'a>(&'a self)->impl Iterator<Item=vec3::Vector3<Fixed<2,64>>>+'a{
 		self.view.data.verts.iter().map(|&Vert(pos)|self.transform.vertex.transform_point3(pos))
 	}
 	fn farthest_vert(&self,dir:Planar64Vec3)->SubmeshVertId{
@@ -543,9 +532,6 @@ impl MeshQuery for TransformedMesh<'_>{
 		// wrap for speed
 		self.transform.vertex.transform_point3(self.view.vert(vert_id)).wrap_1()
 	}
-	fn hint_point(&self)->Planar64Vec3{
-		self.transform.vertex.translation
-	}
 	#[inline]
 	fn face_edges(&self,face_id:SubmeshFaceId)->impl AsRef<[SubmeshDirectedEdgeId]>{
 		self.view.face_edges(face_id)
@@ -764,15 +750,15 @@ impl MinkowskiMesh<'_>{
 			let infinity_fev=self.infinity_fev(-dir,infinity_body.position);
 			//a line is simpler to solve than a parabola
 			infinity_body.velocity=dir;
-			infinity_body.acceleration=vec3::zero();
+			infinity_body.acceleration=vec3::ZERO;
 			//crawl in from negative infinity along a tangent line to get the closest fev
-			infinity_fev.crawl::<false>(self,&infinity_body,Bound::Unbounded,start_time).miss()
+			infinity_fev.crawl(self,&infinity_body,Bound::Unbounded,start_time).miss()
 		})
 	}
 	pub fn predict_collision_in(&self,relative_body:&Body,range:impl RangeBounds<Time>)->Option<(MinkowskiFace,GigaTime)>{
 		self.closest_fev_not_inside(*relative_body,range.start_bound()).and_then(|fev|{
 			//continue forwards along the body parabola
-			fev.crawl::<true>(self,relative_body,range.start_bound(),range.end_bound()).hit()
+			fev.crawl(self,relative_body,range.start_bound(),range.end_bound()).hit()
 		})
 	}
 	pub fn predict_collision_out(&self,relative_body:&Body,range:impl RangeBounds<Time>)->Option<(MinkowskiFace,GigaTime)>{
@@ -782,7 +768,7 @@ impl MinkowskiMesh<'_>{
 		let infinity_body=-relative_body;
 		self.closest_fev_not_inside(infinity_body,lower_bound.as_ref()).and_then(|fev|{
 			//continue backwards along the body parabola
-			fev.crawl::<true>(self,&infinity_body,lower_bound.as_ref(),upper_bound.as_ref()).hit()
+			fev.crawl(self,&infinity_body,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))
 		})
@@ -792,7 +778,10 @@ impl MinkowskiMesh<'_>{
 		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-relative_body.time).to_ratio());
+		let start_time=range.start_bound().map(|&t|{
+			let r=(t-relative_body.time).to_ratio();
+			Ratio::new(r.num,r.den)
+		});
 		let mut best_time=range.end_bound().map(|&t|into_giga_time(t,relative_body.time));
 		let mut best_edge=None;
 		let face_n=self.face_nd(contact_face_id).0;
@@ -818,10 +807,10 @@ impl MinkowskiMesh<'_>{
 	fn infinity_in(&self,infinity_body:Body)->Option<(MinkowskiFace,GigaTime)>{
 		let infinity_fev=self.infinity_fev(-infinity_body.velocity,infinity_body.position);
 		// Bound::Included means that the surface of the mesh is included in the mesh
-		infinity_fev.crawl::<false>(self,&infinity_body,Bound::Unbounded,Bound::Included(&infinity_body.time)).hit()
+		infinity_fev.crawl(self,&infinity_body,Bound::Unbounded,Bound::Included(&infinity_body.time)).hit()
 	}
 	pub fn is_point_in_mesh(&self,point:Planar64Vec3)->bool{
-		let infinity_body=Body::new(point,vec3::Y,vec3::zero(),Time::ZERO);
+		let infinity_body=Body::new(point,vec3::Y,vec3::ZERO,Time::ZERO);
 		//movement must escape the mesh forwards and backwards in time,
 		//otherwise the point is not inside the mesh
 		self.infinity_in(infinity_body)
@@ -867,10 +856,6 @@ impl MeshQuery for MinkowskiMesh<'_>{
 			},
 		}
 	}
-	fn hint_point(&self)->Planar64Vec3{
-		self.mesh1.transform.vertex.translation-
-		self.mesh0.transform.vertex.translation
-	}
 	fn face_edges(&self,face_id:MinkowskiFace)->impl AsRef<[MinkowskiDirectedEdge]>{
 		match face_id{
 			MinkowskiFace::VertFace(v0,f1)=>{

engine/physics/src/physics.rs

@@ -36,7 +36,7 @@ pub enum InternalInstruction{
 pub struct InputState{
 	mouse:MouseState,
 	next_mouse:MouseState,
-	controls:Controls,
+	controls:strafesnet_common::controls_bitflag::Controls,
 }
 impl InputState{
 	fn set_next_mouse(&mut self,next_mouse:MouseState){
@@ -87,7 +87,7 @@ enum JumpDirection{
 impl JumpDirection{
 	fn direction(&self,models:&PhysicsModels,hitbox_mesh:&HitboxMesh,contact:&ContactCollision)->Planar64Vec3{
 		match self{
-			JumpDirection::FromContactNormal=>contact_normal(models,hitbox_mesh,&contact.convex_mesh_id,contact.face_id),
+			JumpDirection::FromContactNormal=>contact_normal(models,hitbox_mesh,contact),
 			&JumpDirection::Exactly(dir)=>dir,
 		}
 	}
@@ -100,6 +100,7 @@ enum TransientAcceleration{
 		time:Time,
 	},
 	//walk target will never be reached
+	#[expect(dead_code)]
 	Unreachable{
 		acceleration:Planar64Vec3,
 	}
@@ -113,12 +114,8 @@ struct ContactMoveState{
 }
 impl TransientAcceleration{
 	fn with_target_diff(target_diff:Planar64Vec3,accel:Planar64,time:Time)->Self{
-		if target_diff==vec3::zero(){
+		if target_diff==vec3::ZERO{
 			TransientAcceleration::Reached
-		}else if accel==Planar64::ZERO{
-			TransientAcceleration::Unreachable{
-				acceleration:vec3::zero()
-			}
 		}else{
 			//normal friction acceleration is clippedAcceleration.dot(normal)*friction
 			TransientAcceleration::Reachable{
@@ -140,7 +137,7 @@ impl TransientAcceleration{
 	}
 	fn acceleration(&self)->Planar64Vec3{
 		match self{
-			TransientAcceleration::Reached=>vec3::zero(),
+			TransientAcceleration::Reached=>vec3::ZERO,
 			&TransientAcceleration::Reachable{acceleration,time:_}=>acceleration,
 			&TransientAcceleration::Unreachable{acceleration}=>acceleration,
 		}
@@ -163,7 +160,7 @@ impl ContactMoveState{
 	}
 }
 fn ground_things(walk_settings:&gameplay_style::WalkSettings,contact:&ContactCollision,touching:&TouchingState,models:&PhysicsModels,hitbox_mesh:&HitboxMesh,style:&StyleModifiers,camera:&PhysicsCamera,input_state:&InputState)->(Planar64Vec3,Planar64Vec3){
-	let normal=contact_normal(models,hitbox_mesh,&contact.convex_mesh_id,contact.face_id);
+	let normal=contact_normal(models,hitbox_mesh,contact);
 	let gravity=touching.base_acceleration(models,style,camera,input_state);
 	let control_dir=style.get_y_control_dir(camera,input_state.controls);
 	let target_velocity=walk_settings.get_walk_target_velocity(control_dir,normal);
@@ -171,7 +168,7 @@ fn ground_things(walk_settings:&gameplay_style::WalkSettings,contact:&ContactCol
 	(gravity,target_velocity_clipped)
 }
 fn ladder_things(ladder_settings:&gameplay_style::LadderSettings,contact:&ContactCollision,touching:&TouchingState,models:&PhysicsModels,hitbox_mesh:&HitboxMesh,style:&StyleModifiers,camera:&PhysicsCamera,input_state:&InputState)->(Planar64Vec3,Planar64Vec3){
-	let normal=contact_normal(models,hitbox_mesh,&contact.convex_mesh_id,contact.face_id);
+	let normal=contact_normal(models,hitbox_mesh,contact);
 	let gravity=touching.base_acceleration(models,style,camera,input_state);
 	let control_dir=style.get_y_control_dir(camera,input_state.controls);
 	let target_velocity=ladder_settings.get_ladder_target_velocity(control_dir,normal);
@@ -196,7 +193,7 @@ impl PhysicsModels{
 		self.contact_attributes.clear();
 		self.intersect_attributes.clear();
 	}
-	fn mesh(&self,convex_mesh_id:ConvexMeshId<PhysicsModelId>)->TransformedMesh<'_>{
+	fn mesh(&self,convex_mesh_id:ConvexMeshId)->TransformedMesh<'_>{
 		let (mesh_id,transform)=match convex_mesh_id.model_id{
 			PhysicsModelId::Contact(model_id)=>{
 				let model=&self.contact_models[&model_id];
@@ -213,25 +210,25 @@ impl PhysicsModels{
 		)
 	}
 	//it's a bit weird to have three functions, but it's always going to be one of these
-	fn contact_mesh(&self,convex_mesh_id:&ConvexMeshId<ContactModelId>)->TransformedMesh<'_>{
+	fn contact_mesh(&self,contact:&ContactCollision)->TransformedMesh<'_>{
-		let model=&self.contact_models[&convex_mesh_id.model_id];
+		let model=&self.contact_models[&contact.model_id];
 		TransformedMesh::new(
-			self.meshes[&model.mesh_id].submesh_view(convex_mesh_id.submesh_id),
+			self.meshes[&model.mesh_id].submesh_view(contact.submesh_id),
 			&model.transform
 		)
 	}
-	fn intersect_mesh(&self,convex_mesh_id:&ConvexMeshId<IntersectModelId>)->TransformedMesh<'_>{
+	fn intersect_mesh(&self,intersect:&IntersectCollision)->TransformedMesh<'_>{
-		let model=&self.intersect_models[&convex_mesh_id.model_id];
+		let model=&self.intersect_models[&intersect.model_id];
 		TransformedMesh::new(
-			self.meshes[&model.mesh_id].submesh_view(convex_mesh_id.submesh_id),
+			self.meshes[&model.mesh_id].submesh_view(intersect.submesh_id),
 			&model.transform
 		)
 	}
 	fn get_model_transform(&self,model_id:ModelId)->Option<&PhysicsMeshTransform>{
 		//ModelId can possibly be a decoration
-		match self.contact_models.get(&model_id.into()){
+		match self.contact_models.get(&ContactModelId::new(model_id.get())){
 			Some(model)=>Some(&model.transform),
-			None=>self.intersect_models.get(&model_id.into())
+			None=>self.intersect_models.get(&IntersectModelId::new(model_id.get()))
 				.map(|model|&model.transform),
 		}
 	}
@@ -305,7 +302,7 @@ impl PhysicsCamera{
 	}
 }
 
-impl Default for PhysicsCamera{
+impl std::default::Default for PhysicsCamera{
 	fn default()->Self{
 		Self{
 			sensitivity:Ratio64Vec2::ONE*200_000,
@@ -388,7 +385,7 @@ mod gameplay{
 			self.unordered_checkpoints.clear();
 		}
 	}
-	impl Default for ModeState{
+	impl std::default::Default for ModeState{
 		fn default()->Self{
 			Self{
 				mode_id:gameplay_modes::ModeId::MAIN,
@@ -443,7 +440,7 @@ impl StyleHelper for StyleModifiers{
 
 	fn get_control_dir(&self,controls:Controls)->Planar64Vec3{
 		//don't get fancy just do it
-		let mut control_dir:Planar64Vec3=vec3::zero();
+		let mut control_dir:Planar64Vec3=vec3::ZERO;
 		//Apply mask after held check so you can require non-allowed keys to be held for some reason
 		let controls=controls.intersection(self.controls_mask);
 		if controls.contains(Controls::MoveForward){
@@ -482,7 +479,7 @@ impl StyleHelper for StyleModifiers{
 		};
 		let transform=integer::Planar64Affine3::new(
 			mat3::from_diagonal(self.hitbox.halfsize),
-			vec3::zero()
+			vec3::ZERO
 		);
 		HitboxMesh::new(mesh,transform)
 	}
@@ -500,7 +497,7 @@ impl MoveState{
 	//call this after state.move_state is changed
 	fn apply_enum(&self,body:&mut Body,touching:&TouchingState,models:&PhysicsModels,hitbox_mesh:&HitboxMesh,style:&StyleModifiers,camera:&PhysicsCamera,input_state:&InputState){
 		match self{
-			MoveState::Fly=>body.acceleration=vec3::zero(),
+			MoveState::Fly=>body.acceleration=vec3::ZERO,
 			MoveState::Air=>{
 				//calculate base acceleration
 				let a=touching.base_acceleration(models,style,camera,input_state);
@@ -614,7 +611,7 @@ impl MoveState{
 			// TODO: unduplicate this code
 			match self.get_walk_state(){
 				// did you stop touching the thing you were walking on?
-				Some(walk_state)=>if !touching.contains_contact(&walk_state.contact.convex_mesh_id){
+				Some(walk_state)=>if !touching.contacts.contains(&walk_state.contact){
 					self.set_move_state(MoveState::Air,body,touching,models,hitbox_mesh,style,camera,input_state);
 				}else{
 					// stopped touching something else while walking
@@ -645,9 +642,9 @@ impl TryFrom<&gameplay_attributes::CollisionAttributes> for PhysicsCollisionAttr
 }
 #[derive(Clone,Copy,Hash,id::Id,Eq,PartialEq)]
 struct ContactAttributesId(u32);
-impl From<ContactAttributesId> for CollisionAttributesId{
+impl Into<CollisionAttributesId> for ContactAttributesId{
-	fn from(value:ContactAttributesId)->CollisionAttributesId{
+	fn into(self)->CollisionAttributesId{
-		CollisionAttributesId::new(value.0)
+		CollisionAttributesId::new(self.0)
 	}
 }
 impl From<CollisionAttributesId> for ContactAttributesId{
@@ -657,9 +654,9 @@ impl From<CollisionAttributesId> for ContactAttributesId{
 }
 #[derive(Clone,Copy,Hash,id::Id,Eq,PartialEq)]
 struct IntersectAttributesId(u32);
-impl From<IntersectAttributesId> for CollisionAttributesId{
+impl Into<CollisionAttributesId> for IntersectAttributesId{
-	fn from(value:IntersectAttributesId)->CollisionAttributesId{
+	fn into(self)->CollisionAttributesId{
-		CollisionAttributesId::new(value.0)
+		CollisionAttributesId::new(self.0)
 	}
 }
 impl From<CollisionAttributesId> for IntersectAttributesId{
@@ -669,26 +666,16 @@ impl From<CollisionAttributesId> for IntersectAttributesId{
 }
 #[derive(Debug,Clone,Copy,Hash,id::Id,Eq,PartialEq)]
 struct ContactModelId(u32);
-impl From<ContactModelId> for ModelId{
+impl Into<ModelId> for ContactModelId{
-	fn from(value:ContactModelId)->ModelId{
+	fn into(self)->ModelId{
-		ModelId::new(value.get())
+		ModelId::new(self.get())
-	}
-}
-impl From<ModelId> for ContactModelId{
-	fn from(other: ModelId)->Self{
-		Self::new(other.get())
 	}
 }
 #[derive(Debug,Clone,Copy,Hash,id::Id,Eq,PartialEq)]
 struct IntersectModelId(u32);
-impl From<IntersectModelId> for ModelId{
+impl Into<ModelId> for IntersectModelId{
-	fn from(value:IntersectModelId)->ModelId{
+	fn into(self)->ModelId{
-		ModelId::new(value.get())
+		ModelId::new(self.get())
-	}
-}
-impl From<ModelId> for IntersectModelId{
-	fn from(other: ModelId)->Self{
-		Self::new(other.get())
 	}
 }
 #[derive(Debug,Clone,Copy,Hash,Eq,PartialEq)]
@@ -696,9 +683,9 @@ enum PhysicsModelId{
 	Contact(ContactModelId),
 	Intersect(IntersectModelId),
 }
-impl From<PhysicsModelId> for ModelId{
+impl Into<ModelId> for PhysicsModelId{
-	fn from(value:PhysicsModelId)->ModelId{
+	fn into(self)->ModelId{
-		ModelId::new(match value{
+		ModelId::new(match self{
 			PhysicsModelId::Contact(model_id)=>model_id.get(),
 			PhysicsModelId::Intersect(model_id)=>model_id.get(),
 		})
@@ -706,18 +693,10 @@ impl From<PhysicsModelId> for ModelId{
 }
 //unique physics meshes indexed by this
 #[derive(Debug,Clone,Copy,Eq,Hash,PartialEq)]
-struct ConvexMeshId<Id>{
+struct ConvexMeshId{
-	model_id:Id,
+	model_id:PhysicsModelId,
 	submesh_id:PhysicsSubmeshId,
 }
-impl<Id> ConvexMeshId<Id>{
-	fn map<NewId>(self,model_id:NewId)->ConvexMeshId<NewId>{
-		ConvexMeshId{
-			model_id,
-			submesh_id:self.submesh_id,
-		}
-	}
-}
 struct ContactModel{
 	mesh_id:PhysicsMeshId,
 	attr_id:ContactAttributesId,
@@ -731,12 +710,14 @@ struct IntersectModel{
 
 #[derive(Debug,Clone,Copy,Eq,Hash,PartialEq)]
 pub struct ContactCollision{
-	convex_mesh_id:ConvexMeshId<ContactModelId>,
 	face_id:model_physics::MinkowskiFace,
+	model_id:ContactModelId,
+	submesh_id:PhysicsSubmeshId,
 }
 #[derive(Debug,Clone,Copy,Eq,Hash,PartialEq)]
 pub struct IntersectCollision{
-	convex_mesh_id:ConvexMeshId<IntersectModelId>,
+	model_id:IntersectModelId,
+	submesh_id:PhysicsSubmeshId,
 }
 #[derive(Debug,Clone,Eq,Hash,PartialEq)]
 pub enum Collision{
@@ -744,47 +725,33 @@ pub enum Collision{
 	Intersect(IntersectCollision),
 }
 impl Collision{
-	fn new(convex_mesh_id:ConvexMeshId<PhysicsModelId>,face_id:model_physics::MinkowskiFace)->Self{
+	const fn new(convex_mesh_id:ConvexMeshId,face_id:model_physics::MinkowskiFace)->Self{
 		match convex_mesh_id.model_id{
-			PhysicsModelId::Contact(model_id)=>Collision::Contact(ContactCollision{convex_mesh_id:convex_mesh_id.map(model_id),face_id}),
+			PhysicsModelId::Contact(model_id)=>Collision::Contact(ContactCollision{model_id,submesh_id:convex_mesh_id.submesh_id,face_id}),
-			PhysicsModelId::Intersect(model_id)=>Collision::Intersect(IntersectCollision{convex_mesh_id:convex_mesh_id.map(model_id)}),
+			PhysicsModelId::Intersect(model_id)=>Collision::Intersect(IntersectCollision{model_id,submesh_id:convex_mesh_id.submesh_id}),
 		}
 	}
 }
 #[derive(Clone,Debug,Default)]
 struct TouchingState{
-	// This is kind of jank, it's a ContactCollision
+	contacts:HashSet<ContactCollision>,
-	// but split over the Key and Value of the HashMap.
+	intersects:HashSet<IntersectCollision>,
-	contacts:HashMap<ConvexMeshId<ContactModelId>,model_physics::MinkowskiFace>,
-	intersects:HashSet<ConvexMeshId<IntersectModelId>>,
 }
 impl TouchingState{
 	fn clear(&mut self){
 		self.contacts.clear();
 		self.intersects.clear();
 	}
-	fn insert_contact(&mut self,contact:ContactCollision)->Option<model_physics::MinkowskiFace>{
+	fn insert(&mut self,collision:Collision)->bool{
-		self.contacts.insert(contact.convex_mesh_id,contact.face_id)
+		match collision{
+			Collision::Contact(collision)=>self.contacts.insert(collision),
+			Collision::Intersect(collision)=>self.intersects.insert(collision),
+		}
 	}
-	fn insert_intersect(&mut self,intersect:IntersectCollision)->bool{
+	fn remove(&mut self,collision:&Collision)->bool{
-		self.intersects.insert(intersect.convex_mesh_id)
+		match collision{
-	}
+			Collision::Contact(collision)=>self.contacts.remove(collision),
-	fn remove_contact(&mut self,convex_mesh_id:&ConvexMeshId<ContactModelId>)->Option<model_physics::MinkowskiFace>{
+			Collision::Intersect(collision)=>self.intersects.remove(collision),
-		self.contacts.remove(convex_mesh_id)
-	}
-	fn remove_intersect(&mut self,convex_mesh_id:&ConvexMeshId<IntersectModelId>)->bool{
-		self.intersects.remove(convex_mesh_id)
-	}
-	fn contains_contact(&self,convex_mesh_id:&ConvexMeshId<ContactModelId>)->bool{
-		self.contacts.contains_key(convex_mesh_id)
-	}
-	fn contains_intersect(&self,convex_mesh_id:&ConvexMeshId<IntersectModelId>)->bool{
-		self.intersects.contains(convex_mesh_id)
-	}
-	fn contains(&self,convex_mesh_id:&ConvexMeshId<PhysicsModelId>)->bool{
-		match convex_mesh_id.model_id{
-			PhysicsModelId::Contact(contact_model_id)=>self.contains_contact(&convex_mesh_id.map(contact_model_id)),
-			PhysicsModelId::Intersect(intersect_model_id)=>self.contains_intersect(&convex_mesh_id.map(intersect_model_id)),
 		}
 	}
 	fn base_acceleration(&self,models:&PhysicsModels,style:&StyleModifiers,camera:&PhysicsCamera,input_state:&InputState)->Planar64Vec3{
@@ -793,7 +760,7 @@ impl TouchingState{
 			a+=rocket_settings.acceleration(style.get_propulsion_control_dir(camera,input_state.controls));
 		}
 		//add accelerators
-		for contact in self.contacts.keys(){
+		for contact in &self.contacts{
 			if let Some(accelerator)=&models.contact_attr(contact.model_id).general.accelerator{
 				a+=accelerator.acceleration;
 			}
@@ -807,10 +774,10 @@ impl TouchingState{
 		a
 	}
 	fn constrain_velocity(&self,models:&PhysicsModels,hitbox_mesh:&HitboxMesh,velocity:Planar64Vec3)->Planar64Vec3{
-		let contacts:Vec<_>=self.contacts.iter().map(|(convex_mesh_id,face_id)|{
+		let contacts:Vec<_>=self.contacts.iter().map(|contact|{
-			let n=contact_normal(models,hitbox_mesh,convex_mesh_id,*face_id);
+			let n=contact_normal(models,hitbox_mesh,contact);
 			crate::push_solve::Contact{
-				position:vec3::zero(),
+				position:vec3::ZERO,
 				velocity:n,
 				normal:n,
 			}
@@ -818,10 +785,10 @@ impl TouchingState{
 		crate::push_solve::push_solve(&contacts,velocity)
 	}
 	fn constrain_acceleration(&self,models:&PhysicsModels,hitbox_mesh:&HitboxMesh,acceleration:Planar64Vec3)->Planar64Vec3{
-		let contacts:Vec<_>=self.contacts.iter().map(|(convex_mesh_id,face_id)|{
+		let contacts:Vec<_>=self.contacts.iter().map(|contact|{
-			let n=contact_normal(models,hitbox_mesh,convex_mesh_id,*face_id);
+			let n=contact_normal(models,hitbox_mesh,contact);
 			crate::push_solve::Contact{
-				position:vec3::zero(),
+				position:vec3::ZERO,
 				velocity:n,
 				normal:n,
 			}
@@ -831,29 +798,29 @@ impl TouchingState{
 	fn predict_collision_end(&self,collector:&mut instruction::InstructionCollector<InternalInstruction,Time>,models:&PhysicsModels,hitbox_mesh:&HitboxMesh,body:&Body,start_time:Time){
 		// let relative_body=body.relative_to(&Body::ZERO);
 		let relative_body=body;
-		for (convex_mesh_id,face_id) in &self.contacts{
+		for contact in &self.contacts{
 			//detect face slide off
-			let model_mesh=models.contact_mesh(convex_mesh_id);
+			let model_mesh=models.contact_mesh(contact);
 			let minkowski=model_physics::MinkowskiMesh::minkowski_sum(model_mesh,hitbox_mesh.transformed_mesh());
-			collector.collect(minkowski.predict_collision_face_out(&relative_body,start_time..collector.time(),*face_id).map(|(_face,time)|{
+			collector.collect(minkowski.predict_collision_face_out(&relative_body,start_time..collector.time(),contact.face_id).map(|(_face,time)|{
 				TimedInstruction{
 					time:relative_body.time+time.into(),
 					instruction:InternalInstruction::CollisionEnd(
-						Collision::Contact(ContactCollision{face_id:*face_id,convex_mesh_id:*convex_mesh_id}),
+						Collision::Contact(*contact),
 						time
 					),
 				}
 			}));
 		}
-		for convex_mesh_id in &self.intersects{
+		for intersect in &self.intersects{
 			//detect model collision in reverse
-			let model_mesh=models.intersect_mesh(convex_mesh_id);
+			let model_mesh=models.intersect_mesh(intersect);
 			let minkowski=model_physics::MinkowskiMesh::minkowski_sum(model_mesh,hitbox_mesh.transformed_mesh());
 			collector.collect(minkowski.predict_collision_out(&relative_body,start_time..collector.time()).map(|(_face,time)|{
 				TimedInstruction{
 					time:relative_body.time+time.into(),
 					instruction:InternalInstruction::CollisionEnd(
-						Collision::Intersect(IntersectCollision{convex_mesh_id:*convex_mesh_id}),
+						Collision::Intersect(*intersect),
 						time
 					),
 				}
@@ -980,7 +947,7 @@ impl PhysicsState{
 // shared geometry for simulations
 pub struct PhysicsData{
 	//permanent map data
-	bvh:bvh::BvhNode<ConvexMeshId<PhysicsModelId>>,
+	bvh:bvh::BvhNode<ConvexMeshId>,
 	//transient map/environment data (open world loads/unloads parts of this data)
 	models:PhysicsModels,
 	//semi-transient data
@@ -1066,16 +1033,14 @@ impl PhysicsData{
 			let transform=PhysicsMeshTransform::new(model.transform);
 			match attr_id{
 				PhysicsAttributesId::Contact(attr_id)=>{
-					let contact_model_id=ContactModelId::new(model_id as u32);
+					contact_models.insert(ContactModelId::new(model_id as u32),ContactModel{
-					contact_models.insert(contact_model_id,ContactModel{
 						mesh_id,
 						attr_id,
 						transform,
 					});
 				},
 				PhysicsAttributesId::Intersect(attr_id)=>{
-					let intersect_model_id=IntersectModelId::new(model_id as u32);
+					intersect_models.insert(IntersectModelId::new(model_id as u32),IntersectModel{
-					intersect_models.insert(intersect_model_id,IntersectModel{
 						mesh_id,
 						attr_id,
 						transform,
@@ -1089,23 +1054,12 @@ impl PhysicsData{
 				(PhysicsMeshId::new(mesh_id as u32),mesh)
 			).collect();
 		let convex_mesh_aabb_list=
-		// use the map models iteration order to ensure that the
+		//map the two lists into a single type so they can be processed with one closure
-		// order that the models are passed into bvh::generate_bvh is consistent
+		contact_models.iter().map(|(&model_id,model)|
-		map.models.iter().enumerate().filter_map(|(model_id,model)|{
+			(PhysicsModelId::Contact(model_id),&model.mesh_id,&model.transform)
-			match map.attributes.get(model.attributes.get() as usize){
+		).chain(intersect_models.iter().map(|(&model_id,model)|
-				None|Some(gameplay_attributes::CollisionAttributes::Decoration)=>None,
+			(PhysicsModelId::Intersect(model_id),&model.mesh_id,&model.transform)
-				Some(gameplay_attributes::CollisionAttributes::Contact(_))=>{
+		))
-					let model_id=ContactModelId::new(model_id as u32);
-					let model=contact_models.get(&model_id)?;
-					Some((PhysicsModelId::Contact(model_id),&model.mesh_id,&model.transform))
-				},
-				Some(gameplay_attributes::CollisionAttributes::Intersect(_))=>{
-					let model_id=IntersectModelId::new(model_id as u32);
-					let model=intersect_models.get(&model_id)?;
-					Some((PhysicsModelId::Intersect(model_id),&model.mesh_id,&model.transform))
-				},
-			}
-		})
 		.flat_map(|(model_id,mesh_id,transform)|{
 			meshes[mesh_id].submesh_views()
 			.enumerate().map(move|(submesh_id,view)|{
@@ -1207,19 +1161,21 @@ impl<'a> PhysicsContext<'a>{
 		//relative to moving platforms
 		//let relative_body=state.body.relative_to(&Body::ZERO);
 		let relative_body=&state.body;
-		data.bvh.sample_aabb(&aabb,&mut |convex_mesh_id|{
+		data.bvh.sample_aabb(&aabb,&mut |&convex_mesh_id|{
-			if state.touching.contains(convex_mesh_id){
-				return;
-			}
 			//no checks are needed because of the time limits.
-			let model_mesh=data.models.mesh(*convex_mesh_id);
+			let model_mesh=data.models.mesh(convex_mesh_id);
 			let minkowski=model_physics::MinkowskiMesh::minkowski_sum(model_mesh,data.hitbox_mesh.transformed_mesh());
 			collector.collect(minkowski.predict_collision_in(relative_body,state.time..collector.time())
-				.map(|(face,dt)|
+				//temp (?) code to avoid collision loops
+				.and_then(|(face,dt)|{
+					// this must be rounded to avoid the infinite loop when hitting the start zone
+					let time=relative_body.time+dt.into();
+					(state.time<time).then_some((time,face,dt))
+				}).map(|(time,face,dt)|
 					TimedInstruction{
-						time:relative_body.time+dt.into(),
+						time,
 						instruction:InternalInstruction::CollisionStart(
-							Collision::new(*convex_mesh_id,face),
+							Collision::new(convex_mesh_id,face),
 							dt
 						)
 					}
@@ -1230,17 +1186,12 @@ impl<'a> PhysicsContext<'a>{
 	}
 
 
-fn contact_normal(
+fn contact_normal(models:&PhysicsModels,hitbox_mesh:&HitboxMesh,contact:&ContactCollision)->Planar64Vec3{
-	models:&PhysicsModels,
+	let model_mesh=models.contact_mesh(contact);
-	hitbox_mesh:&HitboxMesh,
-	convex_mesh_id:&ConvexMeshId<ContactModelId>,
-    face_id:model_physics::MinkowskiFace,
-)->Planar64Vec3{
-	let model_mesh=models.contact_mesh(convex_mesh_id);
 	let minkowski=model_physics::MinkowskiMesh::minkowski_sum(model_mesh,hitbox_mesh.transformed_mesh());
 	// TODO: normalize to i64::MAX>>1
 	// wrap for speed
-	minkowski.face_nd(face_id).0.wrap_1()
+	minkowski.face_nd(contact.face_id).0.wrap_1()
 }
 
 fn recalculate_touching(
@@ -1252,7 +1203,7 @@ fn recalculate_touching(
 	mode:Option<&gameplay_modes::Mode>,
 	models:&PhysicsModels,
 	hitbox_mesh:&HitboxMesh,
-	bvh:&bvh::BvhNode<ConvexMeshId<PhysicsModelId>>,
+	bvh:&bvh::BvhNode<ConvexMeshId>,
 	style:&StyleModifiers,
 	camera:&PhysicsCamera,
 	input_state:&InputState,
@@ -1261,11 +1212,11 @@ fn recalculate_touching(
 	//collision_end all existing contacts
 	//I would have preferred while let Some(contact)=contacts.pop()
 	//but there is no such method
-	while let Some((&convex_mesh_id,_face_id))=touching.contacts.iter().next(){
+	while let Some(&contact)=touching.contacts.iter().next(){
-		collision_end_contact(move_state,body,touching,models,hitbox_mesh,style,camera,input_state,models.contact_attr(convex_mesh_id.model_id),&convex_mesh_id)
+		collision_end_contact(move_state,body,touching,models,hitbox_mesh,style,camera,input_state,models.contact_attr(contact.model_id),contact)
 	}
-	while let Some(&convex_mesh_id)=touching.intersects.iter().next(){
+	while let Some(&intersect)=touching.intersects.iter().next(){
-		collision_end_intersect(move_state,body,touching,models,hitbox_mesh,style,camera,input_state,mode,run,models.intersect_attr(convex_mesh_id.model_id),&convex_mesh_id,time);
+		collision_end_intersect(move_state,body,touching,models,hitbox_mesh,style,camera,input_state,mode,run,models.intersect_attr(intersect.model_id),intersect,time);
 	}
 	//find all models in the teleport region
 	let mut aabb=aabb::Aabb::default();
@@ -1287,7 +1238,8 @@ fn recalculate_touching(
 				collision_start_intersect(move_state,body,mode_state,touching,mode,run,models,hitbox_mesh,bvh,style,camera,input_state,
 					models.intersect_attr(model_id),
 					IntersectCollision{
-						convex_mesh_id:convex_mesh_id.map(model_id),
+						model_id,
+						submesh_id:convex_mesh_id.submesh_id,
 					},
 					time,
 				),
@@ -1305,7 +1257,7 @@ fn set_position(
 	mode:Option<&gameplay_modes::Mode>,
 	models:&PhysicsModels,
 	hitbox_mesh:&HitboxMesh,
-	bvh:&bvh::BvhNode<ConvexMeshId<PhysicsModelId>>,
+	bvh:&bvh::BvhNode<ConvexMeshId>,
 	style:&StyleModifiers,
 	camera:&PhysicsCamera,
 	input_state:&InputState,
@@ -1321,8 +1273,8 @@ fn set_position(
 fn set_velocity_cull(body:&mut Body,touching:&mut TouchingState,models:&PhysicsModels,hitbox_mesh:&HitboxMesh,v:Planar64Vec3)->bool{
 	//This is not correct but is better than what I have
 	let mut culled=false;
-	touching.contacts.retain(|convex_mesh_id,face_id|{
+	touching.contacts.retain(|contact|{
-		let n=contact_normal(models,hitbox_mesh,convex_mesh_id,*face_id);
+		let n=contact_normal(models,hitbox_mesh,contact);
 		let r=n.dot(v).is_positive();
 		if r{
 			culled=true;
@@ -1339,8 +1291,8 @@ fn set_velocity(body:&mut Body,touching:&TouchingState,models:&PhysicsModels,hit
 fn set_acceleration_cull(body:&mut Body,touching:&mut TouchingState,models:&PhysicsModels,hitbox_mesh:&HitboxMesh,a:Planar64Vec3)->bool{
 	//This is not correct but is better than what I have
 	let mut culled=false;
-	touching.contacts.retain(|convex_mesh_id,face_id|{
+	touching.contacts.retain(|contact|{
-		let n=contact_normal(models,hitbox_mesh,convex_mesh_id,*face_id);
+		let n=contact_normal(models,hitbox_mesh,contact);
 		let r=n.dot(a).is_positive();
 		if r{
 			culled=true;
@@ -1364,7 +1316,7 @@ fn teleport(
 	mode:Option<&gameplay_modes::Mode>,
 	models:&PhysicsModels,
 	hitbox_mesh:&HitboxMesh,
-	bvh:&bvh::BvhNode<ConvexMeshId<PhysicsModelId>>,
+	bvh:&bvh::BvhNode<ConvexMeshId>,
 	style:&StyleModifiers,
 	camera:&PhysicsCamera,
 	input_state:&InputState,
@@ -1386,7 +1338,7 @@ fn teleport_to_spawn(
 	mode:&gameplay_modes::Mode,
 	models:&PhysicsModels,
 	hitbox_mesh:&HitboxMesh,
-	bvh:&bvh::BvhNode<ConvexMeshId<PhysicsModelId>>,
+	bvh:&bvh::BvhNode<ConvexMeshId>,
 	style:&StyleModifiers,
 	camera:&PhysicsCamera,
 	input_state:&InputState,
@@ -1475,7 +1427,7 @@ fn run_teleport_behaviour(
 	mode_state:&mut ModeState,
 	models:&PhysicsModels,
 	hitbox_mesh:&HitboxMesh,
-	bvh:&bvh::BvhNode<ConvexMeshId<PhysicsModelId>>,
+	bvh:&bvh::BvhNode<ConvexMeshId>,
 	style:&StyleModifiers,
 	camera:&PhysicsCamera,
 	input_state:&InputState,
@@ -1522,7 +1474,7 @@ fn run_teleport_behaviour(
 	}
 }
 
-fn is_not_spawn_at(
+fn not_spawn_at(
 	mode:Option<&gameplay_modes::Mode>,
 	model_id:ModelId,
 )->bool{
@@ -1543,7 +1495,7 @@ fn collision_start_contact(
 	mode:Option<&gameplay_modes::Mode>,
 	models:&PhysicsModels,
 	hitbox_mesh:&HitboxMesh,
-	bvh:&bvh::BvhNode<ConvexMeshId<PhysicsModelId>>,
+	bvh:&bvh::BvhNode<ConvexMeshId>,
 	style:&StyleModifiers,
 	camera:&PhysicsCamera,
 	input_state:&InputState,
@@ -1553,12 +1505,12 @@ fn collision_start_contact(
 ){
 	let incident_velocity=body.velocity;
 	//add to touching
-	touching.insert_contact(contact);
+	touching.insert(Collision::Contact(contact));
 	//clip v
 	set_velocity(body,touching,models,hitbox_mesh,incident_velocity);
 	let mut allow_jump=true;
-	let model_id=contact.convex_mesh_id.model_id.into();
+	let model_id=contact.model_id.into();
-	let mut allow_run_teleport_behaviour=is_not_spawn_at(mode,model_id);
+	let mut allow_run_teleport_behaviour=not_spawn_at(mode,model_id);
 	match &attr.contacting.contact_behaviour{
 		Some(gameplay_attributes::ContactingBehaviour::Surf)=>(),
 		Some(gameplay_attributes::ContactingBehaviour::Cling)=>println!("Unimplemented!"),
@@ -1572,7 +1524,7 @@ fn collision_start_contact(
 				//kill v
 				//actually you could do this with a booster attribute :thinking:
 				//it's a little bit different because maybe you want to chain ladders together
-				set_velocity(body,touching,models,hitbox_mesh,vec3::zero());//model.velocity
+				set_velocity(body,touching,models,hitbox_mesh,vec3::ZERO);//model.velocity
 			}
 			//ladder walkstate
 			let (gravity,target_velocity)=ladder_things(ladder_settings,&contact,touching,models,hitbox_mesh,style,camera,input_state);
@@ -1581,7 +1533,7 @@ fn collision_start_contact(
 		},
 		Some(gameplay_attributes::ContactingBehaviour::NoJump)=>allow_jump=false,
 		None=>if let Some(walk_settings)=&style.walk{
-			if walk_settings.is_slope_walkable(contact_normal(models,hitbox_mesh,&contact.convex_mesh_id,contact.face_id),vec3::Y){
+			if walk_settings.is_slope_walkable(contact_normal(models,hitbox_mesh,&contact),vec3::Y){
 				allow_run_teleport_behaviour=true;
 				//ground
 				let (gravity,target_velocity)=ground_things(walk_settings,&contact,touching,models,hitbox_mesh,style,camera,input_state);
@@ -1646,7 +1598,7 @@ fn collision_start_intersect(
 	run:&mut run::Run,
 	models:&PhysicsModels,
 	hitbox_mesh:&HitboxMesh,
-	bvh:&bvh::BvhNode<ConvexMeshId<PhysicsModelId>>,
+	bvh:&bvh::BvhNode<ConvexMeshId>,
 	style:&StyleModifiers,
 	camera:&PhysicsCamera,
 	input_state:&InputState,
@@ -1655,13 +1607,13 @@ fn collision_start_intersect(
 	time:Time,
 ){
 	//I think that setting the velocity to 0 was preventing surface contacts from entering an infinite loop
-	touching.insert_intersect(intersect);
+	touching.insert(Collision::Intersect(intersect));
 	//insta booster!
 	if let Some(booster)=&attr.general.booster{
 		move_state.cull_velocity(booster.boost(body.velocity),body,touching,models,hitbox_mesh,style,camera,input_state);
 	}
 	if let Some(mode)=mode{
-		let zone=mode.get_zone(intersect.convex_mesh_id.model_id.into());
+		let zone=mode.get_zone(intersect.model_id.into());
 		match zone{
 			Some(gameplay_modes::Zone::Start)=>{
 				println!("@@@@ Starting new run!");
@@ -1678,7 +1630,7 @@ fn collision_start_intersect(
 		}
 	}
 	move_state.apply_enum_and_body(body,touching,models,hitbox_mesh,style,camera,input_state);
-	run_teleport_behaviour(intersect.convex_mesh_id.model_id.into(),attr.general.wormhole.as_ref(),mode,move_state,body,touching,run,mode_state,models,hitbox_mesh,bvh,style,camera,input_state,time);
+	run_teleport_behaviour(intersect.model_id.into(),attr.general.wormhole.as_ref(),mode,move_state,body,touching,run,mode_state,models,hitbox_mesh,bvh,style,camera,input_state,time);
 }
 
 fn collision_end_contact(
@@ -1691,17 +1643,15 @@ fn collision_end_contact(
 	camera:&PhysicsCamera,
 	input_state:&InputState,
 	_attr:&gameplay_attributes::ContactAttributes,
-	convex_mesh_id:&ConvexMeshId<ContactModelId>,
+	contact:ContactCollision,
 ){
-	touching.remove_contact(convex_mesh_id);//remove contact before calling contact_constrain_acceleration
+	touching.remove(&Collision::Contact(contact));//remove contact before calling contact_constrain_acceleration
 	//check ground
 	//TODO do better
 	//this is inner code from move_state.cull_velocity
 	match move_state.get_walk_state(){
 		// did you stop touching the thing you were walking on?
-		// This does not check the face! Is that a bad thing? It should be
+		Some(walk_state)=>if walk_state.contact==contact{
-		// impossible to stop touching a different face than you started touching...
-		Some(walk_state)=>if &walk_state.contact.convex_mesh_id==convex_mesh_id{
 			move_state.set_move_state(MoveState::Air,body,touching,models,hitbox_mesh,style,camera,input_state);
 		}else{
 			// stopped touching something else while walking
@@ -1723,13 +1673,13 @@ fn collision_end_intersect(
 	mode:Option<&gameplay_modes::Mode>,
 	run:&mut run::Run,
 	_attr:&gameplay_attributes::IntersectAttributes,
-	convex_mesh_id:&ConvexMeshId<IntersectModelId>,
+	intersect:IntersectCollision,
 	time:Time,
 ){
-	touching.remove_intersect(convex_mesh_id);
+	touching.remove(&Collision::Intersect(intersect));
 	move_state.apply_enum_and_body(body,touching,models,hitbox_mesh,style,camera,input_state);
 	if let Some(mode)=mode{
-		let zone=mode.get_zone(convex_mesh_id.model_id.into());
+		let zone=mode.get_zone(intersect.model_id.into());
 		match zone{
 			Some(gameplay_modes::Zone::Start)=>{
 				match run.start(time){
@@ -1763,7 +1713,7 @@ fn atomic_internal_instruction(state:&mut PhysicsState,data:&PhysicsData,ins:Tim
 						&mut state.move_state,&mut state.body,&mut state.mode_state,&mut state.touching,&mut state.run,
 						mode,
 						&data.models,&data.hitbox_mesh,&data.bvh,&state.style,&state.camera,&state.input_state,
-						data.models.contact_attr(contact.convex_mesh_id.model_id),
+						data.models.contact_attr(contact.model_id),
 						contact,
 						state.time,
 					),
@@ -1771,7 +1721,7 @@ fn atomic_internal_instruction(state:&mut PhysicsState,data:&PhysicsData,ins:Tim
 						&mut state.move_state,&mut state.body,&mut state.mode_state,&mut state.touching,
 						mode,
 						&mut state.run,&data.models,&data.hitbox_mesh,&data.bvh,&state.style,&state.camera,&state.input_state,
-						data.models.intersect_attr(intersect.convex_mesh_id.model_id),
+						data.models.intersect_attr(intersect.model_id),
 						intersect,
 						state.time,
 					),
@@ -1780,15 +1730,15 @@ fn atomic_internal_instruction(state:&mut PhysicsState,data:&PhysicsData,ins:Tim
 			InternalInstruction::CollisionEnd(collision,_)=>match collision{
 				Collision::Contact(contact)=>collision_end_contact(
 					&mut state.move_state,&mut state.body,&mut state.touching,&data.models,&data.hitbox_mesh,&state.style,&state.camera,&state.input_state,
-					data.models.contact_attr(contact.convex_mesh_id.model_id),
+					data.models.contact_attr(contact.model_id),
-					&contact.convex_mesh_id
+					contact
 				),
 				Collision::Intersect(intersect)=>collision_end_intersect(
 					&mut state.move_state,&mut state.body,&mut state.touching,&data.models,&data.hitbox_mesh,&state.style,&state.camera,&state.input_state,
 					data.modes.get_mode(state.mode_state.get_mode_id()),
 					&mut state.run,
-					data.models.intersect_attr(intersect.convex_mesh_id.model_id),
+					data.models.intersect_attr(intersect.model_id),
-					&intersect.convex_mesh_id,
+					intersect,
 					state.time
 				),
 			},
@@ -1799,7 +1749,7 @@ fn atomic_internal_instruction(state:&mut PhysicsState,data:&PhysicsData,ins:Tim
 					if strafe_settings.activates(controls){
 						let masked_controls=strafe_settings.mask(controls);
 						let control_dir=state.style.get_control_dir(masked_controls);
-						if control_dir!=vec3::zero(){
+						if control_dir!=vec3::ZERO{
 							let camera_mat=state.camera.simulate_move_rotation_y(state.input_state.lerp_delta(state.time).x);
 							if let Some(ticked_velocity)=strafe_settings.tick_velocity(state.body.velocity,(camera_mat*control_dir).with_length(Planar64::ONE).divide().wrap_1()){
 								//this is wrong but will work ig
@@ -1822,7 +1772,7 @@ fn atomic_internal_instruction(state:&mut PhysicsState,data:&PhysicsData,ins:Tim
 						//which means that gravity can be fully cancelled
 						//ignore moving platforms for now
 						let target=core::mem::replace(&mut walk_state.target,TransientAcceleration::Reached);
-						set_acceleration(&mut state.body,&state.touching,&data.models,&data.hitbox_mesh,vec3::zero());
+						set_acceleration(&mut state.body,&state.touching,&data.models,&data.hitbox_mesh,vec3::ZERO);
 						// check what the target was to see if it was invalid
 						match target{
 							//you are not supposed to reach a walk target which is already reached!
@@ -1886,7 +1836,7 @@ fn atomic_input_instruction(state:&mut PhysicsState,data:&PhysicsData,ins:TimedI
 			if let Some(walk_state)=state.move_state.get_walk_state(){
 				if let Some(jump_settings)=&state.style.jump{
 					let jump_dir=walk_state.jump_direction.direction(&data.models,&data.hitbox_mesh,&walk_state.contact);
-					let booster_option=data.models.contact_attr(walk_state.contact.convex_mesh_id.model_id).general.booster.as_ref();
+					let booster_option=data.models.contact_attr(walk_state.contact.model_id).general.booster.as_ref();
 					let jumped_velocity=jump_settings.jumped_velocity(&state.style,jump_dir,state.body.velocity,booster_option);
 					state.cull_velocity(data,jumped_velocity);
 				}
@@ -1904,7 +1854,7 @@ fn atomic_input_instruction(state:&mut PhysicsState,data:&PhysicsData,ins:TimedI
 		},
 		Instruction::Mode(ModeInstruction::Restart(mode_id))=>{
 			//teleport to mode start zone
-			let mut spawn_point=vec3::zero();
+			let mut spawn_point=vec3::ZERO;
 			let mode=data.modes.get_mode(mode_id);
 			if let Some(mode)=mode{
 				// set style
@@ -1917,7 +1867,7 @@ fn atomic_input_instruction(state:&mut PhysicsState,data:&PhysicsData,ins:TimedI
 				}
 			}
 			set_position(spawn_point,&mut state.move_state,&mut state.body,&mut state.touching,&mut state.run,&mut state.mode_state,mode,&data.models,&data.hitbox_mesh,&data.bvh,&state.style,&state.camera,&state.input_state,state.time);
-			set_velocity(&mut state.body,&state.touching,&data.models,&data.hitbox_mesh,vec3::zero());
+			set_velocity(&mut state.body,&state.touching,&data.models,&data.hitbox_mesh,vec3::ZERO);
 			state.set_move_state(data,MoveState::Air);
 			b_refresh_walk_target=false;
 		}
@@ -1967,7 +1917,7 @@ mod test{
 	use strafesnet_common::integer::{vec3::{self,int as int3},mat3};
 	use super::*;
 	fn test_collision_axis_aligned(relative_body:Body,expected_collision_time:Option<Time>){
-		let h0=HitboxMesh::new(PhysicsMesh::unit_cube(),integer::Planar64Affine3::new(mat3::from_diagonal(int3(5,1,5)>>1),vec3::zero()));
+		let h0=HitboxMesh::new(PhysicsMesh::unit_cube(),integer::Planar64Affine3::new(mat3::from_diagonal(int3(5,1,5)>>1),vec3::ZERO));
 		let h1=StyleModifiers::roblox_bhop().calculate_mesh();
 		let hitbox_mesh=h1.transformed_mesh();
 		let platform_mesh=h0.transformed_mesh();
@@ -1978,12 +1928,12 @@ mod test{
 	fn test_collision_rotated(relative_body:Body,expected_collision_time:Option<Time>){
 		let h0=HitboxMesh::new(PhysicsMesh::unit_cube(),
 			integer::Planar64Affine3::new(
-				Planar64Mat3::from_cols([
+				integer::Planar64Mat3::from_cols([
 					int3(5,0,1)>>1,
 					int3(0,1,0)>>1,
 					int3(-1,0,5)>>1,
 				]),
-				vec3::zero()
+				vec3::ZERO
 			),
 		);
 		let h1=StyleModifiers::roblox_bhop().calculate_mesh();
@@ -2002,7 +1952,7 @@ mod test{
 		test_collision(Body::new(
 			int3(0,5,0),
 			int3(0,-1,0),
-			vec3::zero(),
+			vec3::ZERO,
 			Time::ZERO
 		),Some(Time::from_secs(2)));
 	}
@@ -2011,7 +1961,7 @@ mod test{
 		test_collision(Body::new(
 			int3(0,5,0),
 			int3(0,-1,0)+(vec3::X>>32),
-			vec3::zero(),
+			vec3::ZERO,
 			Time::ZERO
 		),Some(Time::from_secs(2)));
 	}
@@ -2020,7 +1970,7 @@ mod test{
 		test_collision(Body::new(
 			int3(3,5,0),
 			int3(0,-1,0),
-			vec3::zero(),
+			vec3::ZERO,
 			Time::ZERO
 		),Some(Time::from_secs(2)));
 	}
@@ -2029,7 +1979,7 @@ mod test{
 		test_collision(Body::new(
 			int3(0,5,3),
 			int3(0,-1,0),
-			vec3::zero(),
+			vec3::ZERO,
 			Time::ZERO
 		),Some(Time::from_secs(2)));
 	}
@@ -2038,7 +1988,7 @@ mod test{
 		test_collision(Body::new(
 			int3(-3,5,0),
 			int3(0,-1,0),
-			vec3::zero(),
+			vec3::ZERO,
 			Time::ZERO
 		),Some(Time::from_secs(2)));
 	}
@@ -2047,7 +1997,7 @@ mod test{
 		test_collision(Body::new(
 			int3(0,5,-3),
 			int3(0,-1,0),
-			vec3::zero(),
+			vec3::ZERO,
 			Time::ZERO
 		),Some(Time::from_secs(2)));
 	}
@@ -2164,7 +2114,7 @@ mod test{
 		test_collision(Body::new(
 			int3(0,5,0),
 			int3(1,-64,2)>>6,// /64
-			vec3::zero(),
+			vec3::ZERO,
 			Time::ZERO
 		),Some(Time::from_secs(2)));
 	}
@@ -2180,7 +2130,7 @@ mod test{
 	#[test]
 	fn already_inside_hit_nothing(){
 		test_collision(Body::new(
-			vec3::zero(),
+			vec3::ZERO,
 			int3(1,0,0),
 			int3(0,1,0),
 			Time::ZERO
@@ -2192,7 +2142,7 @@ mod test{
 		test_collision_axis_aligned(Body::new(
 			(int3(0,10,-7)>>1)+vec3::raw_xyz(0,0,1),
 			int3(0,-1,0),
-			vec3::zero(),
+			vec3::ZERO,
 			Time::ZERO
 		),Some(Time::from_secs(2)))
 	}
@@ -2201,7 +2151,7 @@ mod test{
 		test_collision_axis_aligned(Body::new(
 			(int3(7,10,0)>>1)+vec3::raw_xyz(-1,0,0),
 			int3(0,-1,0),
-			vec3::zero(),
+			vec3::ZERO,
 			Time::ZERO
 		),Some(Time::from_secs(2)))
 	}
@@ -2210,7 +2160,7 @@ mod test{
 		test_collision_axis_aligned(Body::new(
 			(int3(0,10,7)>>1)+vec3::raw_xyz(0,0,-1),
 			int3(0,-1,0),
-			vec3::zero(),
+			vec3::ZERO,
 			Time::ZERO
 		),Some(Time::from_secs(2)))
 	}
@@ -2219,7 +2169,7 @@ mod test{
 		test_collision_axis_aligned(Body::new(
 			(int3(-7,10,0)>>1)+vec3::raw_xyz(1,0,0),
 			int3(0,-1,0),
-			vec3::zero(),
+			vec3::ZERO,
 			Time::ZERO
 		),Some(Time::from_secs(2)))
 	}
@@ -2229,7 +2179,7 @@ mod test{
 		test_collision_axis_aligned(Body::new(
 			int3(0,10,-7)>>1,
 			int3(0,-1,0),
-			vec3::zero(),
+			vec3::ZERO,
 			Time::ZERO
 		),None)
 	}
@@ -2238,7 +2188,7 @@ mod test{
 		test_collision_axis_aligned(Body::new(
 			int3(7,10,0)>>1,
 			int3(0,-1,0),
-			vec3::zero(),
+			vec3::ZERO,
 			Time::ZERO
 		),None)
 	}
@@ -2247,7 +2197,7 @@ mod test{
 		test_collision_axis_aligned(Body::new(
 			int3(0,10,7)>>1,
 			int3(0,-1,0),
-			vec3::zero(),
+			vec3::ZERO,
 			Time::ZERO
 		),None)
 	}
@@ -2256,7 +2206,7 @@ mod test{
 		test_collision_axis_aligned(Body::new(
 			int3(-7,10,0)>>1,
 			int3(0,-1,0),
-			vec3::zero(),
+			vec3::ZERO,
 			Time::ZERO
 		),None)
 	}
@@ -2266,7 +2216,7 @@ mod test{
 		test_collision_axis_aligned(Body::new(
 			(int3(0,10,-7)>>1)-vec3::raw_xyz(0,0,1),
 			int3(0,-1,0),
-			vec3::zero(),
+			vec3::ZERO,
 			Time::ZERO
 		),None)
 	}
@@ -2275,7 +2225,7 @@ mod test{
 		test_collision_axis_aligned(Body::new(
 			(int3(7,10,0)>>1)-vec3::raw_xyz(-1,0,0),
 			int3(0,-1,0),
-			vec3::zero(),
+			vec3::ZERO,
 			Time::ZERO
 		),None)
 	}
@@ -2284,7 +2234,7 @@ mod test{
 		test_collision_axis_aligned(Body::new(
 			(int3(0,10,7)>>1)-vec3::raw_xyz(0,0,-1),
 			int3(0,-1,0),
-			vec3::zero(),
+			vec3::ZERO,
 			Time::ZERO
 		),None)
 	}
@@ -2293,7 +2243,7 @@ mod test{
 		test_collision_axis_aligned(Body::new(
 			(int3(-7,10,0)>>1)-vec3::raw_xyz(1,0,0),
 			int3(0,-1,0),
-			vec3::zero(),
+			vec3::ZERO,
 			Time::ZERO
 		),None)
 	}

engine/physics/src/push_solve.rs

@@ -39,18 +39,20 @@ impl Contact{
 
 //note that this is horrible with fixed point arithmetic
 fn solve1(c0:&Contact)->Option<Ratio<Vector3<Fixed<3,96>>,Fixed<2,64>>>{
+	const EPSILON:Fixed<2,64>=Fixed::from_bits(Fixed::<2,64>::ONE.to_bits().shr(10));
 	let det=c0.normal.dot(c0.velocity);
-	if det.abs()==Fixed::ZERO{
+	if det.abs()<EPSILON{
 		return None;
 	}
 	let d0=c0.normal.dot(c0.position);
 	Some(c0.normal*d0/det)
 }
 fn solve2(c0:&Contact,c1:&Contact)->Option<Ratio<Vector3<Fixed<5,160>>,Fixed<4,128>>>{
+	const EPSILON:Fixed<4,128>=Fixed::from_bits(Fixed::<4,128>::ONE.to_bits().shr(10));
 	let u0_u1=c0.velocity.cross(c1.velocity);
 	let n0_n1=c0.normal.cross(c1.normal);
 	let det=u0_u1.dot(n0_n1);
-	if det.abs()==Fixed::ZERO{
+	if det.abs()<EPSILON{
 		return None;
 	}
 	let d0=c0.normal.dot(c0.position);
@@ -58,9 +60,10 @@ fn solve2(c0:&Contact,c1:&Contact)->Option<Ratio<Vector3<Fixed<5,160>>,Fixed<4,1
 	Some((c1.normal.cross(u0_u1)*d0+u0_u1.cross(c0.normal)*d1)/det)
 }
 fn solve3(c0:&Contact,c1:&Contact,c2:&Contact)->Option<Ratio<Vector3<Fixed<4,128>>,Fixed<3,96>>>{
+	const EPSILON:Fixed<3,96>=Fixed::from_bits(Fixed::<3,96>::ONE.to_bits().shr(10));
 	let n0_n1=c0.normal.cross(c1.normal);
 	let det=c2.normal.dot(n0_n1);
-	if det.abs()==Fixed::ZERO{
+	if det.abs()<EPSILON{
 		return None;
 	}
 	let d0=c0.normal.dot(c0.position);
@@ -146,7 +149,7 @@ fn is_space_enclosed_4(
 }
 
 const fn get_push_ray_0(point:Planar64Vec3)->Ray{
-	Ray{origin:point,direction:vec3::zero()}
+	Ray{origin:point,direction:vec3::ZERO}
 }
 fn get_push_ray_1(point:Planar64Vec3,c0:&Contact)->Option<Ray>{
 	//wrap for speed
@@ -318,13 +321,13 @@ mod tests{
 	fn test_push_solve(){
 		let contacts=vec![
 			Contact{
-				position:vec3::zero(),
+				position:vec3::ZERO,
 				velocity:vec3::Y,
 				normal:vec3::Y,
 			}
 		];
 		assert_eq!(
-			vec3::zero(),
+			vec3::ZERO,
 			push_solve(&contacts,vec3::NEG_Y)
 		);
 	}

engine/session/Cargo.toml

@@ -10,6 +10,3 @@ strafesnet_common = { path = "../../lib/common", registry = "strafesnet" }
 strafesnet_physics = { path = "../physics", registry = "strafesnet" }
 strafesnet_settings = { path = "../settings", registry = "strafesnet" }
 strafesnet_snf = { path = "../../lib/snf", registry = "strafesnet" }
-
-[lints]
-workspace = true

engine/session/src/session.rs

@@ -31,7 +31,7 @@ pub enum SessionInputInstruction{
 	Mouse(glam::IVec2),
 	SetControl(strafesnet_common::physics::SetControlInstruction),
 	Mode(ImplicitModeInstruction),
-	Misc(MiscInstruction),
+	Misc(strafesnet_common::physics::MiscInstruction),
 }
 /// Implicit mode instruction are fed separately to session.
 /// Session generates the explicit mode instructions interlaced with a SetSensitivity instruction
@@ -152,10 +152,10 @@ enum ViewState{
 pub struct Session{
 	directories:Directories,
 	user_settings:UserSettings,
-	mouse_interpolator:MouseInterpolator,
+	mouse_interpolator:crate::mouse_interpolator::MouseInterpolator,
 	view_state:ViewState,
 	//gui:GuiState
-	geometry_shared:PhysicsData,
+	geometry_shared:physics::PhysicsData,
 	simulation:Simulation,
 	// below fields not included in lite session
 	recording:Recording,

engine/settings/Cargo.toml

@@ -8,6 +8,3 @@ configparser = "3.0.2"
 directories = "6.0.0"
 glam = "0.30.0"
 strafesnet_common = { path = "../../lib/common", registry = "strafesnet" }
-
-[lints]
-workspace = true

integration-testing/Cargo.toml

@@ -10,6 +10,3 @@ strafesnet_physics = { path = "../engine/physics", registry = "strafesnet" }
 strafesnet_snf = { path = "../lib/snf", registry = "strafesnet" }
 # this is just for the primitive constructor
 strafesnet_rbx_loader = { path = "../lib/rbx_loader", registry = "strafesnet" }
-
-[lints]
-workspace = true

integration-testing/src/test_scenes.rs

@@ -77,7 +77,7 @@ fn simultaneous_collision(){
 		Time::ZERO,
 	);
 	let mut physics=PhysicsState::new_with_body(body);
-	physics.style_mut().gravity=vec3::zero();
+	physics.style_mut().gravity=vec3::ZERO;
 	let mut phys_iter=PhysicsContext::iter_internal(&mut physics,&physics_data,Time::from_secs(2))
 		.filter(|ins|!matches!(ins.instruction,InternalInstruction::StrafeTick));
 	// the order that they hit does matter, but we aren't currently worrying about that.
@@ -101,7 +101,7 @@ fn bug_3(){
 		Time::ZERO,
 	);
 	let mut physics=PhysicsState::new_with_body(body);
-	physics.style_mut().gravity=vec3::zero();
+	physics.style_mut().gravity=vec3::ZERO;
 	let mut phys_iter=PhysicsContext::iter_internal(&mut physics,&physics_data,Time::from_secs(3))
 		.filter(|ins|!matches!(ins.instruction,InternalInstruction::StrafeTick));
 	// touch side of part at 0,0,0

integration-testing/src/tests.rs

@@ -29,7 +29,7 @@ fn physics_bug_2()->Result<(),ReplayError>{
 	// wait one second to activate the bug
 	// hit=Some(ModelId(2262))
 	PhysicsContext::run_input_instruction(&mut physics,&physics_data,strafesnet_common::instruction::TimedInstruction{
-		time:Time::from_millis(500),
+		time:strafesnet_common::integer::Time::from_millis(500),
 		instruction:strafesnet_common::physics::Instruction::Idle,
 	});
 
@@ -68,7 +68,7 @@ fn physics_bug_3()->Result<(),ReplayError>{
 	let mut physics=PhysicsState::new_with_body(body);
 	// wait one second to activate the bug
 	PhysicsContext::run_input_instruction(&mut physics,&physics_data,strafesnet_common::instruction::TimedInstruction{
-		time:Time::from_millis(500),
+		time:strafesnet_common::integer::Time::from_millis(500),
 		instruction:strafesnet_common::physics::Instruction::Idle,
 	});
 

lib/bsp_loader/Cargo.toml

@@ -17,6 +17,3 @@ vbsp = "0.9.1"
 vbsp-entities-css = "0.6.0"
 vmdl = "0.2.0"
 vpk = "0.3.0"
-
-[lints]
-workspace = true

lib/bsp_loader/src/brush.rs

@@ -7,7 +7,7 @@ use crate::{valve_transform_normal,valve_transform_dist};
 #[derive(Hash,Eq,PartialEq)]
 struct Face{
 	normal:integer::Planar64Vec3,
-	dot:Planar64,
+	dot:integer::Planar64,
 }
 
 #[derive(Debug)]
@@ -210,7 +210,7 @@ pub fn faces_to_mesh(faces:Vec<Vec<integer::Planar64Vec3>>)->model::Mesh{
 	let color=mb.acquire_color_id(glam::Vec4::ONE);
 	let tex=mb.acquire_tex_id(glam::Vec2::ZERO);
 	// normals are ignored by physics
-	let normal=mb.acquire_normal_id(integer::vec3::zero());
+	let normal=mb.acquire_normal_id(integer::vec3::ZERO);
 
 	let polygon_list=faces.into_iter().map(|face|{
 		face.into_iter().map(|pos|{

lib/bsp_loader/src/bsp.rs

@@ -105,7 +105,7 @@ pub fn convert<'a>(
 					water:Some(attr::IntersectingWater{
 						viscosity:integer::Planar64::ONE,
 						density:integer::Planar64::ONE,
-						velocity:integer::vec3::zero(),
+						velocity:integer::vec3::ZERO,
 					}),
 				},
 				general:attr::GeneralAttributes::default(),
@@ -295,7 +295,7 @@ pub fn convert<'a>(
 					attributes,
 					transform:integer::Planar64Affine3::new(
 						integer::mat3::identity(),
-						integer::vec3::zero(),
+						integer::vec3::ZERO,
 					),
 					color:glam::Vec4::ONE,
 				});
@@ -347,7 +347,7 @@ pub struct PartialMap1{
 	modes:NormalizedModes,
 }
 impl PartialMap1{
-	pub fn add_prop_meshes(
+	pub fn add_prop_meshes<'a>(
 		self,
 		prop_meshes:Meshes<model::Mesh>,
 	)->PartialMap2{

lib/bsp_loader/src/loader.rs

@@ -31,7 +31,7 @@ impl Loader for TextureLoader{
 	type Error=TextureError;
 	type Index<'a>=Cow<'a,str>;
 	type Resource=Texture;
-	fn load(&mut self,index:Self::Index<'_>)->Result<Self::Resource,Self::Error>{
+	fn load<'a>(&mut self,index:Self::Index<'a>)->Result<Self::Resource,Self::Error>{
 		let file_name=format!("textures/{}.dds",index);
 		let mut file=std::fs::File::open(file_name)?;
 		let mut data=Vec::new();
@@ -111,7 +111,7 @@ impl ModelLoader<'_,'_>{
 		}
 	}
 }
-impl Loader for ModelLoader<'_,'_>{
+impl<'bsp,'vpk> Loader for ModelLoader<'bsp,'vpk>{
 	type Error=MeshError;
 	type Index<'a>=&'a str where Self:'a;
 	type Resource=vmdl::Model;
@@ -151,7 +151,7 @@ impl MeshLoader<'_,'_,'_,'_>{
 		}
 	}
 }
-impl Loader for MeshLoader<'_,'_,'_,'_>{
+impl<'str,'bsp,'vpk,'load> Loader for MeshLoader<'bsp,'vpk,'load,'str>{
 	type Error=MeshError;
 	type Index<'a>=&'a str where Self:'a;
 	type Resource=Mesh;

lib/common/Cargo.toml

@@ -17,6 +17,3 @@ linear_ops = { version = "0.1.1", path = "../linear_ops", registry = "strafesnet
 ratio_ops = { version = "0.1.0", path = "../ratio_ops", registry = "strafesnet" }
 glam = "0.30.0"
 id = { version = "0.1.0", registry = "strafesnet" }
-
-[lints]
-workspace = true

lib/common/src/aabb.rs

@@ -61,11 +61,11 @@ impl Aabb{
 	pub fn center(&self)->Planar64Vec3{
 		self.min.map_zip(self.max,|(min,max)|min.midpoint(max))
 	}
-	#[inline]
+	//probably use floats for area & volume because we don't care about precision
-	pub fn area_weight(&self)->fixed_wide::fixed::Fixed<2,64>{
+	// pub fn area_weight(&self)->f32{
-		let d=self.max-self.min;
+	// 	let d=self.max-self.min;
-		d.x*d.y+d.y*d.z+d.z*d.x
+	// 	d.x*d.y+d.y*d.z+d.z*d.x
-	}
+	// }
 	// pub fn volume(&self)->f32{
 	// 	let d=self.max-self.min;
 	// 	d.x*d.y*d.z

lib/common/src/bvh.rs

@@ -245,19 +245,18 @@ pub fn generate_bvh<T>(boxen:Vec<(T,Aabb)>)->BvhNode<T>{
 
 fn generate_bvh_node<T>(boxen:Vec<(T,Aabb)>,force:bool)->BvhNode<T>{
 	let n=boxen.len();
-	const MAX_TERMINAL_BRANCH_LEAF_NODES:usize=20;
+	if force||n<20{
-	if force||n<MAX_TERMINAL_BRANCH_LEAF_NODES{
+		let mut aabb=Aabb::default();
-		let mut aabb_outer=Aabb::default();
+		let nodes=boxen.into_iter().map(|b|{
-		let nodes=boxen.into_iter().map(|(data,aabb)|{
+			aabb.join(&b.1);
-			aabb_outer.join(&aabb);
 			BvhNode{
-				content:RecursiveContent::Leaf(data),
+				content:RecursiveContent::Leaf(b.0),
-				aabb,
+				aabb:b.1,
 			}
 		}).collect();
 		BvhNode{
 			content:RecursiveContent::Branch(nodes),
-			aabb:aabb_outer,
+			aabb,
 		}
 	}else{
 		let mut sort_x=Vec::with_capacity(n);
@@ -273,9 +272,9 @@ fn generate_bvh_node<T>(boxen:Vec<(T,Aabb)>,force:bool)->BvhNode<T>{
 		sort_y.sort_by_key(|&(_,c)|c);
 		sort_z.sort_by_key(|&(_,c)|c);
 		let h=n/2;
-		let (_,median_x)=sort_x[h];
+		let median_x=sort_x[h].1;
-		let (_,median_y)=sort_y[h];
+		let median_y=sort_y[h].1;
-		let (_,median_z)=sort_z[h];
+		let median_z=sort_z[h].1;
 		//locate a run of values equal to the median
 		//partition point gives the first index for which the predicate evaluates to false
 		let first_index_eq_median_x=sort_x.partition_point(|&(_,x)|x<median_x);
@@ -314,10 +313,10 @@ fn generate_bvh_node<T>(boxen:Vec<(T,Aabb)>,force:bool)->BvhNode<T>{
 			};
 			list_list[list_id].push((data,aabb));
 		}
+		let mut aabb=Aabb::default();
 		if list_list.len()==1{
 			generate_bvh_node(list_list.remove(0),true)
 		}else{
-			let mut aabb=Aabb::default();
 			BvhNode{
 				content:RecursiveContent::Branch(
 					list_list.into_iter().map(|b|{

lib/common/src/gameplay_style.rs

@@ -34,7 +34,7 @@ pub struct StyleModifiers{
 	//unused
 	pub mass:Planar64,
 }
-impl Default for StyleModifiers{
+impl std::default::Default for StyleModifiers{
 	fn default()->Self{
 		Self::roblox_bhop()
 	}
@@ -319,7 +319,7 @@ impl WalkSettings{
 		self.accelerate.accel.min((-gravity.y*friction).clamp_1())
 	}
 	pub fn get_walk_target_velocity(&self,control_dir:Planar64Vec3,normal:Planar64Vec3)->Planar64Vec3{
-		if control_dir==crate::integer::vec3::zero(){
+		if control_dir==crate::integer::vec3::ZERO{
 			return control_dir;
 		}
 		let nn=normal.length_squared();
@@ -329,13 +329,13 @@ impl WalkSettings{
 		let dd=d*d;
 		if dd<nnmm{
 			let cr=normal.cross(control_dir);
-			if cr==crate::integer::vec3::zero(){
+			if cr==crate::integer::vec3::ZERO_2{
-				crate::integer::vec3::zero()
+				crate::integer::vec3::ZERO
 			}else{
 				(cr.cross(normal)*self.accelerate.topspeed/((nn*(nnmm-dd)).sqrt())).divide().clamp_1()
 			}
 		}else{
-			crate::integer::vec3::zero()
+			crate::integer::vec3::ZERO
 		}
 	}
 	pub fn is_slope_walkable(&self,normal:Planar64Vec3,up:Planar64Vec3)->bool{
@@ -360,7 +360,7 @@ impl LadderSettings{
 		self.accelerate.accel
 	}
 	pub fn get_ladder_target_velocity(&self,mut control_dir:Planar64Vec3,normal:Planar64Vec3)->Planar64Vec3{
-		if control_dir==crate::integer::vec3::zero(){
+		if control_dir==crate::integer::vec3::ZERO{
 			return control_dir;
 		}
 		let nn=normal.length_squared();
@@ -382,13 +382,13 @@ impl LadderSettings{
 		//- fix the underlying issue
 		if dd<nnmm{
 			let cr=normal.cross(control_dir);
-			if cr==crate::integer::vec3::zero(){
+			if cr==crate::integer::vec3::ZERO_2{
-				crate::integer::vec3::zero()
+				crate::integer::vec3::ZERO
 			}else{
 				(cr.cross(normal)*self.accelerate.topspeed/((nn*(nnmm-dd)).sqrt())).divide().clamp_1()
 			}
 		}else{
-			crate::integer::vec3::zero()
+			crate::integer::vec3::ZERO
 		}
 	}
 }

lib/common/src/integer.rs

@@ -86,7 +86,7 @@ impl<T> std::fmt::Display for Time<T>{
 		write!(f,"{}s+{:09}ns",self.0/Self::ONE_SECOND.0,self.0%Self::ONE_SECOND.0)
 	}
 }
-impl<T> Default for Time<T>{
+impl<T> std::default::Default for Time<T>{
 	fn default()->Self{
 		Self::raw(0)
 	}
@@ -126,7 +126,7 @@ impl_time_additive_assign_operator!(core::ops::AddAssign,add_assign);
 impl_time_additive_assign_operator!(core::ops::SubAssign,sub_assign);
 impl_time_additive_assign_operator!(core::ops::RemAssign,rem_assign);
 impl<T> std::ops::Mul for Time<T>{
-	type Output=Ratio<Fixed<2,64>,Fixed<2,64>>;
+	type Output=Ratio<fixed_wide::fixed::Fixed<2,64>,fixed_wide::fixed::Fixed<2,64>>;
 	#[inline]
 	fn mul(self,rhs:Self)->Self::Output{
 		Ratio::new(Fixed::raw(self.0)*Fixed::raw(rhs.0),Fixed::raw_digit(1_000_000_000i64.pow(2)))
@@ -156,7 +156,7 @@ impl<T> core::ops::Mul<Time<T>> for Planar64{
 #[cfg(test)]
 mod test_time{
 	use super::*;
-	type Time=AbsoluteTime;
+	type Time=super::AbsoluteTime;
 	#[test]
 	fn time_from_planar64(){
 		let a:Time=Planar64::from(1).into();
@@ -552,7 +552,7 @@ impl TryFrom<[f32;3]> for Unit32Vec3{
 }
 */
 
-pub type Planar64TryFromFloatError=FixedFromFloatError;
+pub type Planar64TryFromFloatError=fixed_wide::fixed::FixedFromFloatError;
 pub type Planar64=fixed_wide::types::I32F32;
 pub type Planar64Vec3=linear_ops::types::Vector3<Planar64>;
 pub type Planar64Mat3=linear_ops::types::Matrix3<Planar64>;
@@ -561,6 +561,12 @@ pub mod vec3{
 	pub use linear_ops::types::Vector3;
 	pub const MIN:Planar64Vec3=Planar64Vec3::new([Planar64::MIN;3]);
 	pub const MAX:Planar64Vec3=Planar64Vec3::new([Planar64::MAX;3]);
+	pub const ZERO:Planar64Vec3=Planar64Vec3::new([Planar64::ZERO;3]);
+	pub const ZERO_2:linear_ops::types::Vector3<Fixed::<2,64>>=linear_ops::types::Vector3::new([Fixed::<2,64>::ZERO;3]);
+	pub const ZERO_3:linear_ops::types::Vector3<Fixed::<3,96>>=linear_ops::types::Vector3::new([Fixed::<3,96>::ZERO;3]);
+	pub const ZERO_4:linear_ops::types::Vector3<Fixed::<4,128>>=linear_ops::types::Vector3::new([Fixed::<4,128>::ZERO;3]);
+	pub const ZERO_5:linear_ops::types::Vector3<Fixed::<5,160>>=linear_ops::types::Vector3::new([Fixed::<5,160>::ZERO;3]);
+	pub const ZERO_6:linear_ops::types::Vector3<Fixed::<6,192>>=linear_ops::types::Vector3::new([Fixed::<6,192>::ZERO;3]);
 	pub const X:Planar64Vec3=Planar64Vec3::new([Planar64::ONE,Planar64::ZERO,Planar64::ZERO]);
 	pub const Y:Planar64Vec3=Planar64Vec3::new([Planar64::ZERO,Planar64::ONE,Planar64::ZERO]);
 	pub const Z:Planar64Vec3=Planar64Vec3::new([Planar64::ZERO,Planar64::ZERO,Planar64::ONE]);
@@ -569,10 +575,6 @@ pub mod vec3{
 	pub const NEG_Y:Planar64Vec3=Planar64Vec3::new([Planar64::ZERO,Planar64::NEG_ONE,Planar64::ZERO]);
 	pub const NEG_Z:Planar64Vec3=Planar64Vec3::new([Planar64::ZERO,Planar64::ZERO,Planar64::NEG_ONE]);
 	pub const NEG_ONE:Planar64Vec3=Planar64Vec3::new([Planar64::NEG_ONE,Planar64::NEG_ONE,Planar64::NEG_ONE]);
-	// TODO: use #![feature(generic_const_items)] when stabilized https://github.com/rust-lang/rust/issues/113521
-	pub const fn zero<const N:usize,const F:usize>()->Vector3<Fixed<N,F>>{
-		Vector3::new([Fixed::ZERO;3])
-	}
 	#[inline]
 	pub const fn int(x:i32,y:i32,z:i32)->Planar64Vec3{
 		Planar64Vec3::new([Planar64::raw((x as i64)<<32),Planar64::raw((y as i64)<<32),Planar64::raw((z as i64)<<32)])
@@ -661,7 +663,7 @@ pub struct Planar64Affine3{
 	pub translation:Planar64Vec3,
 }
 impl Planar64Affine3{
-	pub const IDENTITY:Self=Self::new(mat3::identity(),vec3::zero());
+	pub const IDENTITY:Self=Self::new(mat3::identity(),vec3::ZERO);
 	#[inline]
 	pub const fn new(matrix3:Planar64Mat3,translation:Planar64Vec3)->Self{
 		Self{matrix3,translation}

lib/deferred_loader/Cargo.toml

@@ -11,6 +11,3 @@ authors = ["Rhys Lloyd <krakow20@gmail.com>"]
 
 [dependencies]
 strafesnet_common = { version = "0.7.0", path = "../common", registry = "strafesnet" }
-
-[lints]
-workspace = true

lib/deferred_loader/src/loader.rs

@@ -4,5 +4,5 @@ pub trait Loader{
 	type Error:Error;
 	type Index<'a> where Self:'a;
 	type Resource;
-	fn load(&mut self,index:Self::Index<'_>)->Result<Self::Resource,Self::Error>;
+	fn load<'a>(&mut self,index:Self::Index<'a>)->Result<Self::Resource,Self::Error>;
 }

lib/fixed_wide/Cargo.toml

@@ -18,6 +18,3 @@ bnum = "0.13.0"
 arrayvec = { version = "0.7.6", optional = true }
 paste = "1.0.15"
 ratio_ops = { version = "0.1.0", path = "../ratio_ops", registry = "strafesnet", optional = true }
-
-[lints]
-workspace = true

lib/fixed_wide/src/fixed.rs

@@ -1,8 +1,6 @@
 use bnum::{BInt,cast::As};
 
-const BNUM_DIGIT_WIDTH:usize=64;
+#[derive(Clone,Copy,Debug,Default,Hash,PartialEq,Eq,PartialOrd,Ord)]
-
-#[derive(Clone,Copy,Default,Hash,PartialEq,Eq,PartialOrd,Ord)]
 /// A Fixed point number for which multiply operations widen the bits in the output. (when the wide-mul feature is enabled)
 /// N is the number of u64s to use
 /// F is the number of fractional bits (always N*32 lol)
@@ -70,34 +68,6 @@ impl<const N:usize,const F:usize> Fixed<N,F>{
 	pub const fn midpoint(self,other:Self)->Self{
 		Self::from_bits(self.bits.midpoint(other.bits))
 	}
-	#[inline]
-	pub const fn min(self,other:Self)->Self{
-		Self::from_bits(self.bits.min(other.bits))
-	}
-	#[inline]
-	pub const fn max(self,other:Self)->Self{
-		Self::from_bits(self.bits.max(other.bits))
-	}
-	/// return the result of self*sign(other)
-	#[inline]
-	pub const fn mul_sign<const N1:usize,const F1:usize>(self,other:Fixed<N1,F1>)->Self{
-		if other.is_negative(){
-			Self::from_bits(self.bits.neg())
-		}else if other.is_zero(){
-			Fixed::ZERO
-		}else{
-			self
-		}
-	}
-	/// return the result of self/sign(other) (divide by zero does not change the sign)
-	#[inline]
-	pub const fn div_sign<const N1:usize,const F1:usize>(self,other:Fixed<N1,F1>)->Self{
-		if other.is_negative(){
-			Self::from_bits(self.bits.neg())
-		}else{
-			self
-		}
-	}
 }
 impl<const F:usize> Fixed<1,F>{
 	/// My old code called this function everywhere so let's provide it
@@ -129,6 +99,28 @@ impl_from!(
 	i8,i16,i32,i64,i128,isize
 );
 
+impl<const N:usize,const F:usize,T> PartialEq<T> for Fixed<N,F>
+where
+		T:Copy,
+		BInt::<N>:From<T>,
+{
+	#[inline]
+	fn eq(&self,&other:&T)->bool{
+		self.bits.eq(&other.into())
+	}
+}
+
+impl<const N:usize,const F:usize,T> PartialOrd<T> for Fixed<N,F>
+	where
+		T:Copy,
+		BInt::<N>:From<T>,
+{
+	#[inline]
+	fn partial_cmp(&self,&other:&T)->Option<std::cmp::Ordering>{
+		self.bits.partial_cmp(&other.into())
+	}
+}
+
 impl<const N:usize,const F:usize> std::ops::Neg for Fixed<N,F>{
 	type Output=Self;
 	#[inline]
@@ -294,23 +286,6 @@ macro_rules! impl_from_float {
 impl_from_float!(integer_decode_f32,f32,24);
 impl_from_float!(integer_decode_f64,f64,53);
 
-impl<const N:usize,const F:usize> core::fmt::Debug for Fixed<N,F>{
-	#[inline]
-	fn fmt(&self,f:&mut core::fmt::Formatter)->Result<(),core::fmt::Error>{
-		let integral=self.as_bits().unsigned_abs()>>F;
-		let fractional=self.as_bits().unsigned_abs()&((bnum::BUint::<N>::ONE<<F)-bnum::BUint::<N>::ONE);
-		let leading_zeroes=(fractional.leading_zeros() as usize).saturating_sub(N*BNUM_DIGIT_WIDTH-F)>>2;
-		if self.is_negative(){
-			core::write!(f,"-")?;
-		}
-		if fractional.is_zero(){
-			core::write!(f,"{integral:x}.{}","0".repeat(leading_zeroes))
-		}else{
-			core::write!(f,"{integral:x}.{}{fractional:x}","0".repeat(leading_zeroes))
-		}
-	}
-}
-
 impl<const N:usize,const F:usize> core::fmt::Display for Fixed<N,F>{
 	#[inline]
 	fn fmt(&self,f:&mut core::fmt::Formatter)->Result<(),core::fmt::Error>{
@@ -334,6 +309,16 @@ macro_rules! impl_additive_operator {
 				self.$method(other)
 			}
 		}
+		impl<const N:usize,const F:usize,U> core::ops::$trait<U> for $struct<N,F>
+			where
+				BInt::<N>:From<U>,
+		{
+			type Output = $output;
+			#[inline]
+			fn $method(self, other: U) -> Self::Output {
+				Self::from_bits(self.bits.$method(BInt::<N>::from(other).shl(F as u32)))
+			}
+		}
 	};
 }
 macro_rules! impl_additive_assign_operator {
@@ -344,6 +329,15 @@ macro_rules! impl_additive_assign_operator {
 				self.bits.$method(other.bits);
 			}
 		}
+		impl<const N:usize,const F:usize,U> core::ops::$trait<U> for $struct<N,F>
+		where
+				BInt::<N>:From<U>,
+		{
+			#[inline]
+			fn $method(&mut self, other: U) {
+				self.bits.$method(BInt::<N>::from(other).shl(F as u32));
+			}
+		}
 	};
 }
 
@@ -366,7 +360,7 @@ impl_additive_operator!( Fixed, BitXor, bitxor, Self );
 // non-wide operators.  The result is the same width as the inputs.
 
 // This macro is not used in the default configuration.
-#[expect(unused_macros)]
+#[allow(unused_macros)]
 macro_rules! impl_multiplicative_operator_not_const_generic {
 	( ($struct: ident, $trait: ident, $method: ident, $output: ty ), $width:expr ) => {
 		impl<const F:usize> core::ops::$trait for $struct<$width,F>{
@@ -545,7 +539,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}>{

lib/fixed_wide/src/tests.rs

@@ -229,16 +229,3 @@ fn test_zeroes_deferred_division(){
 		])
 	);
 }
-
-#[test]
-fn test_debug(){
-	assert_eq!(format!("{:?}",I32F32::EPSILON),"0.00000001");
-	assert_eq!(format!("{:?}",I32F32::ONE),"1.00000000");
-	assert_eq!(format!("{:?}",I32F32::TWO),"2.00000000");
-	assert_eq!(format!("{:?}",I32F32::MAX),"7fffffff.ffffffff");
-	assert_eq!(format!("{:?}",I32F32::try_from(core::f64::consts::PI).unwrap()),"3.243f6a88");
-	assert_eq!(format!("{:?}",I32F32::NEG_EPSILON),"-0.00000001");
-	assert_eq!(format!("{:?}",I32F32::NEG_ONE),"-1.00000000");
-	assert_eq!(format!("{:?}",I32F32::NEG_TWO),"-2.00000000");
-	assert_eq!(format!("{:?}",I32F32::MIN),"-80000000.00000000");
-}

lib/linear_ops/Cargo.toml

@@ -20,6 +20,3 @@ paste = { version = "1.0.15", optional = true }
 
 [dev-dependencies]
 fixed_wide = { path = "../fixed_wide", registry = "strafesnet", features = ["wide-mul"] }
-
-[lints]
-workspace = true

lib/linear_ops/src/macros/matrix.rs

@@ -205,8 +205,7 @@ macro_rules! impl_matrix_named_fields_shape {
 			#[inline]
 			fn deref(&self)->&Self::Target{
 				// This cast is valid because Matrix has #[repr(transparent)]
-				let ptr:*const [[T;$size_inner];$size_outer]=&self.array;
+				let ptr=&self.array as *const [[T;$size_inner];$size_outer] as *const Self::Target;
-				let ptr=ptr as *const Self::Target;
 				// SAFETY: this pointer is non-null because it comes from a reference
 				unsafe{&*ptr}
 			}
@@ -215,8 +214,7 @@ macro_rules! impl_matrix_named_fields_shape {
 			#[inline]
 			fn deref_mut(&mut self)->&mut Self::Target{
 				// This cast is valid because Matrix has #[repr(transparent)]
-				let ptr:*mut [[T;$size_inner];$size_outer]=&mut self.array;
+				let ptr=&mut self.array as *mut [[T;$size_inner];$size_outer] as *mut Self::Target;
-				let ptr=ptr as *mut Self::Target;
 				// SAFETY: this pointer is non-null because it comes from a reference
 				unsafe{&mut*ptr}
 			}

lib/linear_ops/src/macros/vector.rs

@@ -331,8 +331,7 @@ macro_rules! impl_vector_named_fields {
 			#[inline]
 			fn deref(&self)->&Self::Target{
 				// This cast is valid because Vector has #[repr(transparent)]
-				let ptr:*const [T;$size]=&self.array;
+				let ptr=&self.array as *const [T;$size] as *const Self::Target;
-				let ptr=ptr as *const Self::Target;
 				// SAFETY: this pointer is non-null because it comes from a reference
 				unsafe{&*ptr}
 			}
@@ -341,8 +340,7 @@ macro_rules! impl_vector_named_fields {
 			#[inline]
 			fn deref_mut(&mut self)->&mut Self::Target{
 				// This cast is valid because Vector has #[repr(transparent)]
-				let ptr:*mut [T;$size]=&mut self.array;
+				let ptr=&mut self.array as *mut [T;$size] as *mut Self::Target;
-				let ptr=ptr as *mut Self::Target;
 				// SAFETY: this pointer is non-null because it comes from a reference
 				unsafe{&mut*ptr}
 			}

lib/ratio_ops/Cargo.toml

@@ -8,6 +8,3 @@ description = "Ratio operations using trait bounds for avoiding division like th
 authors = ["Rhys Lloyd <krakow20@gmail.com>"]
 
 [dependencies]
-
-[lints]
-workspace = true

lib/rbx_loader/Cargo.toml

@@ -12,17 +12,14 @@ authors = ["Rhys Lloyd <krakow20@gmail.com>"]
 [dependencies]
 bytemuck = "1.14.3"
 glam = "0.30.0"
-regex = { version = "1.11.3", default-features = false }
+lazy-regex = "3.1.0"
+rbx_binary = { version = "1.0.1-sn5", registry = "strafesnet" }
+rbx_dom_weak =  { version = "3.0.1-sn5", registry = "strafesnet" }
 rbx_mesh = "0.5.0"
+rbx_reflection = "5.0.0"
+rbx_reflection_database = "1.0.0"
+rbx_xml = { version = "1.0.1-sn5", registry = "strafesnet" }
 rbxassetid = { version = "0.1.0", path = "../rbxassetid", registry = "strafesnet" }
 roblox_emulator = { version = "0.5.1", path = "../roblox_emulator", default-features = false, registry = "strafesnet" }
 strafesnet_common = { version = "0.7.0", path = "../common", registry = "strafesnet" }
 strafesnet_deferred_loader = { version = "0.5.1", path = "../deferred_loader", registry = "strafesnet" }
-rbx_binary = "2.0.1"
-rbx_dom_weak = "4.1.0"
-rbx_reflection = "6.1.0"
-rbx_reflection_database = "2.0.2"
-rbx_xml = "2.0.1"
-
-[lints]
-workspace = true

lib/rbx_loader/src/loader.rs

@@ -50,7 +50,7 @@ impl Loader for TextureLoader{
 	type Error=TextureError;
 	type Index<'a>=&'a str;
 	type Resource=Texture;
-	fn load(&mut self,index:Self::Index<'_>)->Result<Self::Resource,Self::Error>{
+	fn load<'a>(&mut self,index:Self::Index<'a>)->Result<Self::Resource,Self::Error>{
 		let RobloxAssetId(asset_id)=index.parse()?;
 		let file_name=format!("textures/{}.dds",asset_id);
 		let data=read_entire_file(file_name)?;
@@ -157,7 +157,7 @@ impl Loader for MeshLoader{
 	type Error=MeshError;
 	type Index<'a>=MeshIndex<'a>;
 	type Resource=MeshWithSize;
-	fn load(&mut self,index:Self::Index<'_>)->Result<Self::Resource,Self::Error>{
+	fn load<'a>(&mut self,index:Self::Index<'a>)->Result<Self::Resource,Self::Error>{
 		let mesh=match index.mesh_type{
 			MeshType::FileMesh=>{
 				let RobloxAssetId(asset_id)=index.content.parse()?;

lib/rbx_loader/src/rbx.rs

@@ -18,15 +18,6 @@ fn static_ustr(s:&'static str)->rbx_dom_weak::Ustr{
 	rbx_dom_weak::ustr(s)
 }
 
-macro_rules! lazy_regex{
-	($r:literal)=>{{
-		use regex::Regex;
-		use std::sync::LazyLock;
-		static RE:LazyLock<Regex>=LazyLock::new(||Regex::new($r).unwrap());
-		&RE
-	}};
-}
-
 fn planar64_affine3_from_roblox(cf:&rbx_dom_weak::types::CFrame,size:&rbx_dom_weak::types::Vector3)->Result<Planar64Affine3,Planar64TryFromFloatError>{
 	Ok(Planar64Affine3::new(
 		Planar64Mat3::from_cols([
@@ -127,7 +118,7 @@ fn get_attributes(name:&str,can_collide:bool,velocity:Planar64Vec3,model_id:mode
 			);
 		},
 		other=>{
-			let regman=lazy_regex!(r"^(BonusStart|WormholeOut)(\d+)$");
+			let regman=lazy_regex::regex!(r"^(BonusStart|WormholeOut)(\d+)$");
 			if let Some(captures)=regman.captures(other){
 				match &captures[1]{
 					"BonusStart"=>{
@@ -153,7 +144,7 @@ fn get_attributes(name:&str,can_collide:bool,velocity:Planar64Vec3,model_id:mode
 					},
 					_=>(),
 				}
-			}else if let Some(captures)=lazy_regex!(r"^(Force)?(Spawn|SpawnAt|Trigger|Teleport|Platform)(\d+)$")
+			}else if let Some(captures)=lazy_regex::regex!(r"^(Force)?(Spawn|SpawnAt|Trigger|Teleport|Platform)(\d+)$")
 			.captures(other){
 				force_intersecting=true;
 				let stage_id=StageId::new(ParseIntContext::parse(&captures[3]).map_err(GetAttributesError::StageIdParseInt)?);
@@ -194,7 +185,7 @@ fn get_attributes(name:&str,can_collide:bool,velocity:Planar64Vec3,model_id:mode
 						stage_element,
 					),
 				);
-			}else if let Some(captures)=lazy_regex!(r"^(Jump|WormholeIn)(\d+)$")
+			}else if let Some(captures)=lazy_regex::regex!(r"^(Jump|WormholeIn)(\d+)$")
 			.captures(other){
 				match &captures[1]{
 					"Jump"=>modes_builder.push_mode_update(
@@ -219,7 +210,7 @@ fn get_attributes(name:&str,can_collide:bool,velocity:Planar64Vec3,model_id:mode
 					},
 					_=>unreachable!("regex2[1] messed up bad"),
 				}
-			}else if let Some(captures)=lazy_regex!(r"^Bonus(Finish|Anticheat)(\d+)$")
+			}else if let Some(captures)=lazy_regex::regex!(r"^Bonus(Finish|Anticheat)(\d+)$")
 			.captures(other){
 				force_can_collide=false;
 				force_intersecting=true;
@@ -251,7 +242,7 @@ fn get_attributes(name:&str,can_collide:bool,velocity:Planar64Vec3,model_id:mode
 		}
 	}
 	//need some way to skip this
-	if allow_booster&&velocity!=vec3::zero(){
+	if allow_booster&&velocity!=vec3::ZERO{
 		general.booster=Some(attr::Booster::Velocity(velocity));
 	}
 	Ok(match force_can_collide{
@@ -344,12 +335,12 @@ pub struct RobloxFaceTextureDescription{
 	pub color:glam::Vec4,
 	pub transform:RobloxTextureTransform,
 }
-impl PartialEq for RobloxFaceTextureDescription{
+impl core::cmp::PartialEq for RobloxFaceTextureDescription{
 	fn eq(&self,other:&Self)->bool{
 		self.to_bits().eq(&other.to_bits())
 	}
 }
-impl Eq for RobloxFaceTextureDescription{}
+impl core::cmp::Eq for RobloxFaceTextureDescription{}
 impl core::hash::Hash for RobloxFaceTextureDescription{
 	fn hash<H:core::hash::Hasher>(&self,state:&mut H){
 		self.to_bits().hash(state);
@@ -559,7 +550,7 @@ pub fn convert<'a>(
 	//just going to leave it like this for now instead of reworking the data structures for this whole thing
 	let textureless_render_group=render_config_deferred_loader.acquire_render_config_id(None);
 
-	let db=rbx_reflection_database::get().unwrap();
+	let db=rbx_reflection_database::get();
 	let basepart=&db.classes["BasePart"];
 	let baseparts=dom.descendants().filter(|&instance|
 		db.classes.get(instance.class.as_str()).is_some_and(|class|
@@ -775,10 +766,10 @@ struct MeshIdWithSize{
 	mesh:model::MeshId,
 	size:Planar64Vec3,
 }
-fn acquire_mesh_id_from_render_config_id(
+fn acquire_mesh_id_from_render_config_id<'a>(
 	primitive_meshes:&mut Vec<model::Mesh>,
 	mesh_id_from_render_config_id:&mut HashMap<model::MeshId,HashMap<RenderConfigId,model::MeshId>>,
-	loaded_meshes:&HashMap<model::MeshId,MeshWithSize>,
+	loaded_meshes:&'a HashMap<model::MeshId,MeshWithSize>,
 	old_mesh_id:model::MeshId,
 	render:RenderConfigId,
 )->Option<MeshIdWithSize>{
@@ -798,10 +789,10 @@ fn acquire_mesh_id_from_render_config_id(
 		size,
 	})
 }
-fn acquire_union_id_from_render_config_id(
+fn acquire_union_id_from_render_config_id<'a>(
 	primitive_meshes:&mut Vec<model::Mesh>,
 	union_id_from_render_config_id:&mut HashMap<model::MeshId,HashMap<RobloxPartDescription,model::MeshId>>,
-	loaded_meshes:&HashMap<model::MeshId,MeshWithSize>,
+	loaded_meshes:&'a HashMap<model::MeshId,MeshWithSize>,
 	old_union_id:model::MeshId,
 	part_texture_description:RobloxPartDescription,
 )->Option<MeshIdWithSize>{

lib/rbx_loader/src/union.rs

@@ -250,7 +250,7 @@ pub fn convert(
 		// generate a unit cube as default physics
 		let pos_list=CUBE_DEFAULT_VERTICES.map(|pos|mb.acquire_pos_id(pos>>1));
 		let tex=mb.acquire_tex_id(glam::Vec2::ZERO);
-		let normal=mb.acquire_normal_id(vec3::zero());
+		let normal=mb.acquire_normal_id(vec3::ZERO);
 		let color=mb.acquire_color_id(glam::Vec4::ONE);
 		let polygon_group=PolygonGroup::PolygonList(PolygonList::new(CUBE_DEFAULT_POLYS.map(|poly|poly.map(|[pos_id,_]|
 			mb.acquire_vertex_id(IndexedVertex{pos:pos_list[pos_id as usize],tex,normal,color})

lib/rbxassetid/Cargo.toml

@@ -9,6 +9,3 @@ authors = ["Rhys Lloyd <krakow20@gmail.com>"]
 
 [dependencies]
 url = "2.5.4"
-
-[lints]
-workspace = true

lib/roblox_emulator/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "roblox_emulator"
-version = "0.5.2"
+version = "0.5.1"
 edition = "2024"
 repository = "https://git.itzana.me/StrafesNET/strafe-project"
 license = "MIT OR Apache-2.0"
@@ -15,10 +15,7 @@ run-service=[]
 glam = "0.30.0"
 mlua = { version = "0.11.3", features = ["luau"] }
 phf = { version = "0.13.1", features = ["macros"] }
-rbx_dom_weak = "4.1.0"
+rbx_dom_weak = { version = "3.0.1-sn5", registry = "strafesnet" }
-rbx_reflection = "6.1.0"
+rbx_reflection = "5.0.0"
-rbx_reflection_database = "2.0.2"
+rbx_reflection_database = "1.0.0"
-rbx_types = "3.1.0"
+rbx_types = "2.0.0"
-
-[lints]
-workspace = true

lib/roblox_emulator/src/context.rs

@@ -52,7 +52,7 @@ impl Context{
 	}
 	/// Creates an iterator over all items of a particular class.
 	pub fn superclass_iter<'a>(&'a self,superclass:&'a str)->impl Iterator<Item=Ref>+'a{
-		let db=rbx_reflection_database::get().unwrap();
+		let db=rbx_reflection_database::get();
 		let Some(superclass)=db.classes.get(superclass)else{
 			panic!("Invalid class");
 		};

lib/roblox_emulator/src/runner/enum.rs

@@ -8,7 +8,7 @@ impl<'a> EnumItem<'a>{
 		Self{name:Some(name.as_ref()),value}
 	}
 }
-impl From<rbx_types::Enum> for EnumItem<'_>{
+impl<'a> From<rbx_types::Enum> for EnumItem<'a>{
 	fn from(e:rbx_types::Enum)->Self{
 		EnumItem{
 			name:None,
@@ -37,7 +37,7 @@ impl PartialEq for EnumItem<'_>{
 pub struct Enums;
 impl Enums{
 	pub fn get(&self,index:&str)->Option<EnumItems<'static>>{
-		let db=rbx_reflection_database::get().unwrap();
+		let db=rbx_reflection_database::get();
 		db.enums.get(index).map(|ed|EnumItems{ed})
 	}
 }

lib/roblox_emulator/src/runner/instance/instance.rs

@@ -5,6 +5,7 @@ use rbx_types::Ref;
 use rbx_dom_weak::{Ustr,InstanceBuilder,WeakDom};
 
 use crate::util::static_ustr;
+use crate::runner::vector3::Vector3;
 use crate::runner::number::Number;
 
 pub fn set_globals(lua:&mlua::Lua,globals:&mlua::Table)->Result<(),mlua::Error>{
@@ -37,13 +38,13 @@ pub fn dom_mut<T>(lua:&mlua::Lua,mut f:impl FnMut(&mut WeakDom)->mlua::Result<T>
 }
 
 pub fn class_is_a(class:&str,superclass:&str)->bool{
-	let db=rbx_reflection_database::get().unwrap();
+	let db=rbx_reflection_database::get();
 	let (Some(class),Some(superclass))=(db.classes.get(class),db.classes.get(superclass))else{
 		return false;
 	};
 	db.has_superclass(class,superclass)
 }
-fn get_full_name(dom:&WeakDom,instance:&rbx_dom_weak::Instance)->String{
+fn get_full_name(dom:&rbx_dom_weak::WeakDom,instance:&rbx_dom_weak::Instance)->String{
 	let mut full_name=instance.name.clone();
 	let mut pref=instance.parent();
 	while let Some(parent)=dom.get_by_ref(pref){
@@ -65,29 +66,29 @@ pub fn get_name_source(lua:&mlua::Lua,script:Instance)->Result<(String,String),m
 	})
 }
 
-pub fn find_first_child<'a>(dom:&'a WeakDom,instance:&rbx_dom_weak::Instance,name:&str)->Option<&'a rbx_dom_weak::Instance>{
+pub fn find_first_child<'a>(dom:&'a rbx_dom_weak::WeakDom,instance:&rbx_dom_weak::Instance,name:&str)->Option<&'a rbx_dom_weak::Instance>{
 	instance.children().iter().filter_map(|&r|dom.get_by_ref(r)).find(|inst|inst.name==name)
 }
-pub fn find_first_descendant<'a>(dom:&'a WeakDom,instance:&rbx_dom_weak::Instance,name:&str)->Option<&'a rbx_dom_weak::Instance>{
+pub fn find_first_descendant<'a>(dom:&'a rbx_dom_weak::WeakDom,instance:&rbx_dom_weak::Instance,name:&str)->Option<&'a rbx_dom_weak::Instance>{
 	dom.descendants_of(instance.referent()).find(|&inst|inst.name==name)
 }
 
-pub fn find_first_child_of_class<'a>(dom:&'a WeakDom,instance:&rbx_dom_weak::Instance,class:&str)->Option<&'a rbx_dom_weak::Instance>{
+pub fn find_first_child_of_class<'a>(dom:&'a rbx_dom_weak::WeakDom,instance:&rbx_dom_weak::Instance,class:&str)->Option<&'a rbx_dom_weak::Instance>{
 	instance.children().iter().filter_map(|&r|dom.get_by_ref(r)).find(|inst|inst.class==class)
 }
-pub fn find_first_descendant_of_class<'a>(dom:&'a WeakDom,instance:&rbx_dom_weak::Instance,class:&str)->Option<&'a rbx_dom_weak::Instance>{
+pub fn find_first_descendant_of_class<'a>(dom:&'a rbx_dom_weak::WeakDom,instance:&rbx_dom_weak::Instance,class:&str)->Option<&'a rbx_dom_weak::Instance>{
 	dom.descendants_of(instance.referent()).find(|&inst|inst.class==class)
 }
 
-pub fn find_first_child_which_is_a<'a>(dom:&'a WeakDom,instance:&rbx_dom_weak::Instance,superclass:&str)->Option<&'a rbx_dom_weak::Instance>{
+pub fn find_first_child_which_is_a<'a>(dom:&'a rbx_dom_weak::WeakDom,instance:&rbx_dom_weak::Instance,superclass:&str)->Option<&'a rbx_dom_weak::Instance>{
-	let db=rbx_reflection_database::get().unwrap();
+	let db=rbx_reflection_database::get();
 	let superclass_descriptor=db.classes.get(superclass)?;
 	instance.children().iter().filter_map(|&r|dom.get_by_ref(r)).find(|inst|{
 		db.classes.get(inst.class.as_str()).is_some_and(|descriptor|db.has_superclass(descriptor,superclass_descriptor))
 	})
 }
-pub fn find_first_descendant_which_is_a<'a>(dom:&'a WeakDom,instance:&rbx_dom_weak::Instance,superclass:&str)->Option<&'a rbx_dom_weak::Instance>{
+pub fn find_first_descendant_which_is_a<'a>(dom:&'a rbx_dom_weak::WeakDom,instance:&rbx_dom_weak::Instance,superclass:&str)->Option<&'a rbx_dom_weak::Instance>{
-	let db=rbx_reflection_database::get().unwrap();
+	let db=rbx_reflection_database::get();
 	let superclass_descriptor=db.classes.get(superclass)?;
 	dom.descendants_of(instance.referent()).find(|inst|{
 		db.classes.get(inst.class.as_str()).is_some_and(|descriptor|db.has_superclass(descriptor,superclass_descriptor))
@@ -282,7 +283,7 @@ impl mlua::UserData for Instance{
 			dom_mut(lua,|dom|{
 				let instance=this.get(dom)?;
 				//println!("__index t={} i={index:?}",instance.name);
-				let db=rbx_reflection_database::get().unwrap();
+				let db=rbx_reflection_database::get();
 				let class=db.classes.get(instance.class.as_str()).ok_or_else(||mlua::Error::runtime("Class missing"))?;
 				// Find existing property
 				// Interestingly, ustr can know ahead of time if
@@ -344,7 +345,7 @@ impl mlua::UserData for Instance{
 			let index_str=&*index.to_str()?;
 			dom_mut(lua,|dom|{
 				let instance=this.get_mut(dom)?;
-				let db=rbx_reflection_database::get().unwrap();
+				let db=rbx_reflection_database::get();
 				let class=db.classes.get(instance.class.as_str()).ok_or_else(||mlua::Error::runtime("Class missing"))?;
 				let property=db.superclasses_iter(class).find_map(|cls|
 					cls.properties.get(index_str)
@@ -487,8 +488,8 @@ static CLASS_FUNCTION_DATABASE:CFD=phf::phf_map!{
 		"GetService"=>GET_SERVICE,
 	},
 	"Terrain"=>phf::phf_map!{
-		"FillBall"=>cf!(|_lua,_,_:(crate::runner::vector3::Vector3,Number,crate::runner::r#enum::CoerceEnum)|mlua::Result::Ok(())),
+		"FillBall"=>cf!(|_lua,_,_:(Vector3,Number,crate::runner::r#enum::CoerceEnum)|mlua::Result::Ok(())),
-		"FillBlock"=>cf!(|_lua,_,_:(crate::runner::cframe::CFrame,crate::runner::vector3::Vector3,crate::runner::r#enum::CoerceEnum)|mlua::Result::Ok(())),
+		"FillBlock"=>cf!(|_lua,_,_:(crate::runner::cframe::CFrame,Vector3,crate::runner::r#enum::CoerceEnum)|mlua::Result::Ok(())),
 		"FillCylinder"=>cf!(|_lua,_,_:(crate::runner::cframe::CFrame,Number,Number,crate::runner::r#enum::CoerceEnum)|mlua::Result::Ok(())),
 		"SetMaterialColor"=>cf!(|_lua,_,_:(crate::runner::r#enum::CoerceEnum,crate::runner::color3::Color3)|mlua::Result::Ok(())),
 	},

lib/roblox_emulator/src/runner/runner.rs

@@ -48,11 +48,6 @@ fn init(lua:&mlua::Lua)->mlua::Result<()>{
 	Ok(())
 }
 
-unsafe fn extend_lifetime_mut<'a,T>(src:&mut T)->&'a mut T{
-	let ptr:*mut T=src;
-	unsafe{&mut*ptr}
-}
-
 impl Runner{
 	pub fn new()->Result<Self,Error>{
 		let runner=Self{
@@ -70,7 +65,8 @@ impl Runner{
 		// SAFETY: This is not a &'static mut WeakDom,
 		// but as long as Runnable<'a> holds the lifetime of &'a mut Context
 		// it is a valid unique reference.
-		self.lua.set_app_data::<crate::context::LuaAppData>(unsafe{extend_lifetime_mut(&mut context.dom)});
+		let ptr=&mut context.dom as *mut rbx_dom_weak::WeakDom;
+		self.lua.set_app_data::<crate::context::LuaAppData>(unsafe{&mut*ptr});
 		#[cfg(feature="run-service")]
 		self.lua.set_app_data::<crate::scheduler::Scheduler>(crate::scheduler::Scheduler::default());
 		Ok(Runnable{

lib/roblox_emulator/src/runner/script_signal.rs

@@ -117,7 +117,7 @@ impl mlua::FromLua for ScriptSignal{
 }
 
 impl mlua::UserData for ScriptConnection{
-	fn add_fields<F:UserDataFields<Self>>(fields:&mut F){
+	fn add_fields<F:mlua::UserDataFields<Self>>(fields:&mut F){
 		fields.add_field_method_get("Connected",|_,this|{
 			Ok(this.position().is_some())
 		});

lib/roblox_emulator/src/scheduler.rs

@@ -46,8 +46,8 @@ impl Scheduler{
 	}
 }
 
-pub fn scheduler_mut<T>(lua:&mlua::Lua,mut f:impl FnMut(&mut Scheduler)->mlua::Result<T>)->mlua::Result<T>{
+pub fn scheduler_mut<T>(lua:&mlua::Lua,mut f:impl FnMut(&mut crate::scheduler::Scheduler)->mlua::Result<T>)->mlua::Result<T>{
-	let mut scheduler=lua.app_data_mut::<Scheduler>().ok_or_else(||mlua::Error::runtime("Scheduler missing"))?;
+	let mut scheduler=lua.app_data_mut::<crate::scheduler::Scheduler>().ok_or_else(||mlua::Error::runtime("Scheduler missing"))?;
 	f(&mut *scheduler)
 }
 

lib/snf/Cargo.toml

@@ -9,6 +9,3 @@ edition = "2024"
 binrw = "0.15.0"
 id = { version = "0.1.0", registry = "strafesnet" }
 strafesnet_common = { version = "0.7.0", path = "../common", registry = "strafesnet" }
-
-[lints]
-workspace = true

lib/snf/src/bot.rs

@@ -6,7 +6,7 @@ use strafesnet_common::physics::Time;
 
 const VERSION:u32=0;
 
-type TimedPhysicsInstruction=strafesnet_common::instruction::TimedInstruction<strafesnet_common::physics::Instruction,Time>;
+type TimedPhysicsInstruction=strafesnet_common::instruction::TimedInstruction<strafesnet_common::physics::Instruction,strafesnet_common::physics::Time>;
 
 #[derive(Debug)]
 pub enum Error{
@@ -274,7 +274,7 @@ pub fn write_bot<W:BinWriterExt>(mut writer:W,physics_version:u32,instructions:i
 
 	//probe header length
 	let mut bot_header_data=Vec::new();
-	header.write_le(&mut std::io::Cursor::new(&mut bot_header_data)).map_err(Error::InvalidData)?;
+	binrw::BinWrite::write_le(&header,&mut std::io::Cursor::new(&mut bot_header_data)).map_err(Error::InvalidData)?;
 
 	// the first block location is the map header
 	block_location.push(offset);

lib/snf/src/map.rs

@@ -97,8 +97,8 @@ enum ResourceType{
 }
 
 struct ResourceMap<T>{
-	meshes:HashMap<model::MeshId,T>,
+	meshes:HashMap<strafesnet_common::model::MeshId,T>,
-	textures:HashMap<model::TextureId,T>,
+	textures:HashMap<strafesnet_common::model::TextureId,T>,
 }
 impl<T> Default for ResourceMap<T>{
 	fn default()->Self{
@@ -185,7 +185,7 @@ pub struct StreamableMap<R:BinReaderExt>{
 	//this is every possible attribute... need some sort of streaming system
 	attributes:Vec<strafesnet_common::gameplay_attributes::CollisionAttributes>,
 	//this is every possible render configuration... shaders and such... need streaming
-	render_configs:Vec<model::RenderConfig>,
+	render_configs:Vec<strafesnet_common::model::RenderConfig>,
 	//this makes sense to keep in memory for streaming, a map of which blocks occupy what space
 	bvh:BvhNode<BlockId>,
 	//something something resources hashmaps
@@ -223,7 +223,7 @@ impl<R:BinReaderExt> StreamableMap<R>{
 		}
 		Ok(Self{
 			file,
-			modes:gameplay_modes::NormalizedModes::new(modes),
+			modes:strafesnet_common::gameplay_modes::NormalizedModes::new(modes),
 			attributes,
 			render_configs,
 			bvh:strafesnet_common::bvh::generate_bvh(bvh),
@@ -366,12 +366,12 @@ fn collect_spacial_blocks(
 		block_location.push(sequential_block_data.position());
 	}else{
 		match bvh_node.into_content(){
-			RecursiveContent::Branch(bvh_node_list)=>{
+			strafesnet_common::bvh::RecursiveContent::Branch(bvh_node_list)=>{
 				for bvh_node in bvh_node_list{
 					collect_spacial_blocks(block_location,block_headers,sequential_block_data,bvh_node)?;
 				}
 			},
-			RecursiveContent::Leaf(_)=>panic!(),//bvh branches are 20 leaves minimum
+			strafesnet_common::bvh::RecursiveContent::Leaf(_)=>panic!(),//bvh branches are 20 leaves minimum
 		}
 	}
 	Ok(())
@@ -384,13 +384,13 @@ pub fn write_map<W:BinWriterExt>(mut writer:W,map:strafesnet_common::map::Comple
 	let boxen=map.models.into_iter().enumerate().map(|(model_id,model)|{
 		//grow your own aabb
 		let mesh=map.meshes.get(model.mesh.get() as usize).ok_or(Error::InvalidMeshId(model.mesh))?;
-		let mut aabb=Aabb::default();
+		let mut aabb=strafesnet_common::aabb::Aabb::default();
 		for &pos in &mesh.unique_pos{
 			aabb.grow(model.transform.transform_point3(pos).narrow_1().unwrap());
 		}
 		Ok(((model::ModelId::new(model_id as u32),model.into()),aabb))
 	}).collect::<Result<Vec<_>,_>>()?;
-	let bvh=weigh_contents(strafesnet_common::bvh::generate_bvh(boxen),&|_|size_of::<newtypes::model::Model>());
+	let bvh=weigh_contents(strafesnet_common::bvh::generate_bvh(boxen),&|_|std::mem::size_of::<newtypes::model::Model>());
 	//build blocks
 	//block location is initialized with two values
 	//the first value represents the location of the first byte after the file header

lib/snf/src/newtypes/physics.rs

@@ -20,7 +20,7 @@ impl TryInto<TimedPhysicsInstruction> for TimedInstruction{
 	}
 }
 impl TryFrom<TimedPhysicsInstruction> for TimedInstruction{
-	type Error=InstructionConvert;
+	type Error=super::physics::InstructionConvert;
 	fn try_from(value:TimedPhysicsInstruction)->Result<Self,Self::Error>{
 		Ok(Self{
 			time:value.time.get(),

map-tool/Cargo.toml

@@ -12,11 +12,12 @@ flate2 = "1.0.27"
 futures = "0.3.31"
 image = "0.25.2"
 image_dds = "0.7.1"
+lazy-regex = "3.1.0"
 rbx_asset = { version = "0.5.0", registry = "strafesnet" }
-rbx_binary = "2.0.1"
+rbx_binary  = { version = "1.0.1-sn5", registry = "strafesnet" }
-rbx_dom_weak = "4.1.0"
+rbx_dom_weak =  { version = "3.0.1-sn5", registry = "strafesnet" }
-rbx_reflection_database = "2.0.2"
+rbx_reflection_database = "1.0.0"
-rbx_xml = "2.0.1"
+rbx_xml = { version = "1.0.1-sn5", registry = "strafesnet" }
 rbxassetid = { version = "0.1.0", registry = "strafesnet" }
 strafesnet_bsp_loader = { version = "0.3.1", path = "../lib/bsp_loader", registry = "strafesnet" }
 strafesnet_deferred_loader = { version = "0.5.1", path = "../lib/deferred_loader", registry = "strafesnet" }
@@ -35,6 +36,3 @@ vtf = "0.3.0"
 #lto = true
 #strip = true
 #codegen-units = 1
-
-[lints]
-workspace = true

map-tool/src/roblox.rs

@@ -465,7 +465,7 @@ fn convert_to_snf(path:&Path,output_folder:PathBuf)->Result<Errors,ConvertError>
 	})
 }
 
-async fn roblox_to_snf(paths:Vec<PathBuf>,output_folder:PathBuf)->AResult<()>{
+async fn roblox_to_snf(paths:Vec<std::path::PathBuf>,output_folder:PathBuf)->AResult<()>{
 	let start=std::time::Instant::now();
 
 	let thread_limit=std::thread::available_parallelism()?.get();

map-tool/src/source.rs

@@ -484,7 +484,7 @@ async fn convert_to_snf(path:&Path,vpk_list:&[strafesnet_bsp_loader::Vpk],output
 
 	Ok(())
 }
-async fn source_to_snf(paths:Vec<PathBuf>,output_folder:PathBuf,vpk_paths:Vec<PathBuf>)->AResult<()>{
+async fn source_to_snf(paths:Vec<std::path::PathBuf>,output_folder:PathBuf,vpk_paths:Vec<PathBuf>)->AResult<()>{
 	let start=std::time::Instant::now();
 
 	let thread_limit=std::thread::available_parallelism()?.get();

strafe-client/Cargo.toml

@@ -28,12 +28,9 @@ strafesnet_rbx_loader = { path = "../lib/rbx_loader", registry = "strafesnet", o
 strafesnet_session = { path = "../engine/session", registry = "strafesnet" }
 strafesnet_settings = { path = "../engine/settings", registry = "strafesnet" }
 strafesnet_snf = { path = "../lib/snf", registry = "strafesnet", optional = true }
-wgpu = "27.0.0"
+wgpu = "26.0.1"
 winit = "0.30.7"
 
 [profile.dev]
 strip = false
 opt-level = 3
-
-[lints]
-workspace = true

strafe-client/src/setup.rs

@@ -119,13 +119,12 @@ impl<'a> SetupContextPartial3<'a>{
 
 		let (device, queue)=pollster::block_on(self.adapter
 			.request_device(
-				&wgpu::DeviceDescriptor{
+				&wgpu::DeviceDescriptor {
-					label:None,
+					label: None,
-					required_features:(optional_features&self.adapter.features())|required_features,
+					required_features: (optional_features & self.adapter.features()) | required_features,
-					required_limits:needed_limits,
+					required_limits: needed_limits,
 					memory_hints:wgpu::MemoryHints::Performance,
-					trace:wgpu::Trace::Off,
+					trace: wgpu::Trace::Off,
-					experimental_features:wgpu::ExperimentalFeatures::disabled(),
 				},
 			))
 			.expect("Unable to find a suitable GPU adapter!");

strafe-client/src/window.rs

@@ -188,7 +188,7 @@ impl WindowContext<'_>{
 		}
 	}
 
-	fn device_event(&mut self,time:SessionTime,event:winit::event::DeviceEvent){
+	fn device_event(&mut self,time:SessionTime,event: winit::event::DeviceEvent){
 		match event{
 			winit::event::DeviceEvent::MouseMotion{
 			    delta,