new bug who dis

The physics algorithm expects vertices to align exactly with faces.  Since the face normal is calculated via the cross product of vertex positions, this allows the face normals to be exact with respect to the vertex positions.

engine/graphics/src/graphics.rs

@@ -11,6 +11,15 @@ pub fn required_limits()->wgpu::Limits{
 	wgpu::Limits::default()
 }
 
+// physics debug view:
+// render two meshes adjacent according to Minkowski FEV
+// render additional mesh at path point
+// render path parabola
+// highlight meshes according to Minkowski FEV
+//
+// debug process:
+// press a button to step physics by one transition
+
 struct Indices{
 	count:u32,
 	buf:wgpu::Buffer,

engine/physics/src/body.rs

@@ -42,12 +42,12 @@ impl<T> Body<T>
 	pub fn extrapolated_position(&self,time:Time<T>)->Planar64Vec3{
 		let dt=time-self.time;
 		self.position
-		+(self.velocity*dt).map(|elem|elem.divide().fix_1())
-		+self.acceleration.map(|elem|(dt*dt*elem/2).divide().fix_1())
+		+(self.velocity*dt).map(|elem|elem.divide().clamp_1())
+		+self.acceleration.map(|elem|(dt*dt*elem/2).divide().clamp_1())
 	}
 	pub fn extrapolated_velocity(&self,time:Time<T>)->Planar64Vec3{
 		let dt=time-self.time;
-		self.velocity+(self.acceleration*dt).map(|elem|elem.divide().fix_1())
+		self.velocity+(self.acceleration*dt).map(|elem|elem.divide().clamp_1())
 	}
 	pub fn advance_time(&mut self,time:Time<T>){
 		self.position=self.extrapolated_position(time);
@@ -71,12 +71,12 @@ impl<T> Body<T>
 			D2:Copy,
 			Planar64:core::ops::Mul<D2,Output=N4>,
 			N4:integer::Divide<D2,Output=T1>,
-			T1:integer::Fix<Planar64>,
+			T1:integer::Clamp<Planar64>,
 	{
 		// a*dt^2/2 + v*dt + p
 		// (a*dt/2+v)*dt+p
 		(self.acceleration.map(|elem|dt*elem/2)+self.velocity).map(|elem|dt.mul_ratio(elem))
-		.map(|elem|elem.divide().fix())+self.position
+		.map(|elem|elem.divide().clamp())+self.position
 	}
 	pub fn extrapolated_velocity_ratio_dt<Num,Den,N1,T1>(&self,dt:integer::Ratio<Num,Den>)->Planar64Vec3
 		where
@@ -85,10 +85,10 @@ impl<T> Body<T>
 			Num:core::ops::Mul<Planar64,Output=N1>,
 			Planar64:core::ops::Mul<Den,Output=N1>,
 			N1:integer::Divide<Den,Output=T1>,
-			T1:integer::Fix<Planar64>,
+			T1:integer::Clamp<Planar64>,
 	{
 		// a*dt + v
-		self.acceleration.map(|elem|(dt*elem).divide().fix())+self.velocity
+		self.acceleration.map(|elem|(dt*elem).divide().clamp())+self.velocity
 	}
 	pub fn advance_time_ratio_dt(&mut self,dt:crate::model::GigaTime){
 		self.position=self.extrapolated_position_ratio_dt(dt);

engine/physics/src/face_crawler.rs

@@ -2,6 +2,7 @@ use crate::model::{GigaTime,FEV,MeshQuery,DirectedEdge};
 use strafesnet_common::integer::{Fixed,Ratio,vec3::Vector3};
 use crate::physics::{Time,Body};
 
+#[derive(Debug)]
 enum Transition<M:MeshQuery>{
 	Miss,
 	Next(FEV<M>,GigaTime),
@@ -27,17 +28,18 @@ impl<M:MeshQuery> CrawlResult<M>{
 	}
 }
 
-impl<F:Copy,M:MeshQuery<Normal=Vector3<F>,Offset=Fixed<4,128>>> FEV<M>
+impl<F:Copy,M:MeshQuery<Normal=Vector3<F>,Offset=Fixed<4,128>>+std::fmt::Debug> FEV<M>
 	where
 		// This is hardcoded for MinkowskiMesh lol
 		M::Face:Copy,
 		M::Edge:Copy,
 		M::Vert:Copy,
-		F:core::ops::Mul<Fixed<1,32>,Output=Fixed<4,128>>,
+		F:core::ops::Mul<Fixed<1,32>,Output=Fixed<4,128>>+std::fmt::Debug+std::fmt::Display,
 		<F as core::ops::Mul<Fixed<1,32>>>::Output:core::iter::Sum,
 		<M as MeshQuery>::Offset:core::ops::Sub<<F as std::ops::Mul<Fixed<1,32>>>::Output>,
 {
 	fn next_transition(&self,body_time:GigaTime,mesh:&M,body:&Body,mut best_time:GigaTime)->Transition<M>{
+		println!("next_transition fev={self:?}");
 		//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;
@@ -57,13 +59,14 @@ impl<F:Copy,M:MeshQuery<Normal=Vector3<F>,Offset=Fixed<4,128>>> FEV<M>
 					}
 				}
 				//test each edge collision time, ignoring roots with zero or conflicting derivative
-				for &directed_edge_id in mesh.face_edges(face_id).iter(){
+				for &directed_edge_id in mesh.face_edges(face_id).as_ref(){
 					let edge_n=mesh.directed_edge_n(directed_edge_id);
 					let n=n.cross(edge_n);
-					let verts=mesh.edge_verts(directed_edge_id.as_undirected());
+					let &[v0,v1]=mesh.edge_verts(directed_edge_id.as_undirected()).as_ref();
 					//WARNING: d is moved out of the *2 block because of adding two vertices!
 					//WARNING: precision is swept under the rug!
-					for dt in Fixed::<4,128>::zeroes2(n.dot(body.position*2-(mesh.vert(verts[0])+mesh.vert(verts[1]))).fix_4(),n.dot(body.velocity).fix_4()*2,n.dot(body.acceleration).fix_4()){
+					//wrap for speed
+					for dt in Fixed::<4,128>::zeroes2(n.dot(body.position*2-(mesh.vert(v0)+mesh.vert(v1))).wrap_4(),n.dot(body.velocity).wrap_4()*2,n.dot(body.acceleration).wrap_4()){
 						if body_time.le_ratio(dt)&&dt.lt_ratio(best_time)&&n.dot(body.extrapolated_velocity_ratio_dt(dt)).is_negative(){
 							best_time=dt;
 							best_transition=Transition::Next(FEV::Edge(directed_edge_id.as_undirected()),dt);
@@ -74,16 +77,20 @@ impl<F:Copy,M:MeshQuery<Normal=Vector3<F>,Offset=Fixed<4,128>>> FEV<M>
 				//if none:
 			},
 			&FEV::Edge(edge_id)=>{
+				println!("test edge={edge_id:?}");
 				//test each face collision time, ignoring roots with zero or conflicting derivative
 				let edge_n=mesh.edge_n(edge_id);
 				let edge_verts=mesh.edge_verts(edge_id);
-				let delta_pos=body.position*2-(mesh.vert(edge_verts[0])+mesh.vert(edge_verts[1]));
-				for (i,&edge_face_id) in mesh.edge_faces(edge_id).iter().enumerate(){
+				let &[ev0,ev1]=edge_verts.as_ref();
+				let delta_pos=body.position*2-(mesh.vert(ev0)+mesh.vert(ev1));
+				for (i,&edge_face_id) in mesh.edge_faces(edge_id).as_ref().iter().enumerate(){
 					let face_n=mesh.face_nd(edge_face_id).0;
 					//edge_n gets parity from the order of edge_faces
 					let n=face_n.cross(edge_n)*((i as i64)*2-1);
+					println!("edge_face={edge_face_id:?} face_n={face_n} n={n}");
 					//WARNING yada yada d *2
-					for dt in Fixed::<4,128>::zeroes2(n.dot(delta_pos).fix_4(),n.dot(body.velocity).fix_4()*2,n.dot(body.acceleration).fix_4()){
+					//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 body_time.le_ratio(dt)&&dt.lt_ratio(best_time)&&n.dot(body.extrapolated_velocity_ratio_dt(dt)).is_negative(){
 							best_time=dt;
 							best_transition=Transition::Next(FEV::Face(edge_face_id),dt);
@@ -92,12 +99,12 @@ impl<F:Copy,M:MeshQuery<Normal=Vector3<F>,Offset=Fixed<4,128>>> FEV<M>
 					}
 				}
 				//test each vertex collision time, ignoring roots with zero or conflicting derivative
-				for (i,&vert_id) in edge_verts.iter().enumerate(){
+				for (i,&vert_id) in edge_verts.as_ref().iter().enumerate(){
 					//vertex normal gets parity from vert index
 					let n=edge_n*(1-2*(i as i64));
 					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 body_time.le_ratio(dt)&&dt.lt_ratio(best_time)&&n.dot(body.extrapolated_velocity_ratio_dt(dt)).is_negative(){
-							let dt=Ratio::new(dt.num.fix_4(),dt.den.fix_4());
+							let dt=Ratio::new(dt.num.widen_4(),dt.den.widen_4());
 							best_time=dt;
 							best_transition=Transition::Next(FEV::Vert(vert_id),dt);
 							break;
@@ -108,12 +115,12 @@ impl<F:Copy,M:MeshQuery<Normal=Vector3<F>,Offset=Fixed<4,128>>> FEV<M>
 			},
 			&FEV::Vert(vert_id)=>{
 				//test each edge collision time, ignoring roots with zero or conflicting derivative
-				for &directed_edge_id in mesh.vert_edges(vert_id).iter(){
+				for &directed_edge_id in mesh.vert_edges(vert_id).as_ref(){
 					//edge is directed away from vertex, but we want the dot product to turn out negative
 					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 body_time.le_ratio(dt)&&dt.lt_ratio(best_time)&&n.dot(body.extrapolated_velocity_ratio_dt(dt)).is_negative(){
-							let dt=Ratio::new(dt.num.fix_4(),dt.den.fix_4());
+							let dt=Ratio::new(dt.num.widen_4(),dt.den.widen_4());
 							best_time=dt;
 							best_transition=Transition::Next(FEV::Edge(directed_edge_id.as_undirected()),dt);
 							break;
@@ -128,14 +135,16 @@ impl<F:Copy,M:MeshQuery<Normal=Vector3<F>,Offset=Fixed<4,128>>> FEV<M>
 	pub fn crawl(mut self,mesh:&M,relative_body:&Body,start_time:Time,time_limit:Time)->CrawlResult<M>{
 		let mut body_time={
 			let r=(start_time-relative_body.time).to_ratio();
-			Ratio::new(r.num.fix_4(),r.den.fix_4())
+			Ratio::new(r.num.widen_4(),r.den.widen_4())
 		};
 		let time_limit={
 			let r=(time_limit-relative_body.time).to_ratio();
-			Ratio::new(r.num.fix_4(),r.den.fix_4())
+			Ratio::new(r.num.widen_4(),r.den.widen_4())
 		};
 		for _ in 0..20{
-			match self.next_transition(body_time,mesh,relative_body,time_limit){
+			let transition=self.next_transition(body_time,mesh,relative_body,time_limit);
+			println!("transition={transition:?}");
+			match transition{
 				Transition::Miss=>return CrawlResult::Miss(self),
 				Transition::Next(next_fev,next_time)=>(self,body_time)=(next_fev,next_time),
 				Transition::Hit(face,time)=>return CrawlResult::Hit(face,time),

engine/physics/src/model.rs

@@ -1,4 +1,3 @@
-use std::borrow::{Borrow,Cow};
 use std::collections::{HashSet,HashMap};
 use core::ops::Range;
 use strafesnet_common::integer::vec3::Vector3;
@@ -8,6 +7,13 @@ use strafesnet_common::physics::Time;
 
 type Body=crate::body::Body<strafesnet_common::physics::TimeInner>;
 
+struct AsRefHelper<T>(T);
+impl<T> AsRef<T> for AsRefHelper<T>{
+	fn as_ref(&self)->&T{
+		&self.0
+	}
+}
+
 pub trait UndirectedEdge{
 	type DirectedEdge:Copy+DirectedEdge;
 	fn as_directed(&self,parity:bool)->Self::DirectedEdge;
@@ -62,47 +68,52 @@ pub enum FEV<M:MeshQuery>{
 }
 
 //use Unit32 #[repr(C)] for map files
-#[derive(Clone,Hash,Eq,PartialEq)]
+#[derive(Clone,Debug,Hash,Eq,PartialEq)]
 struct Face{
 	normal:Planar64Vec3,
 	dot:Planar64,
 }
+#[derive(Debug)]
 struct Vert(Planar64Vec3);
 pub trait MeshQuery{
-	type Face:Clone;
-	type Edge:Clone+DirectedEdge;
-	type Vert:Clone;
+	type Face:Copy+std::fmt::Debug;
+	type Edge:Copy+DirectedEdge+std::fmt::Debug;
+	type Vert:Copy+std::fmt::Debug;
 	// Vertex must be Planar64Vec3 because it represents an actual position
 	type Normal;
 	type Offset;
 	fn edge_n(&self,edge_id:<Self::Edge as DirectedEdge>::UndirectedEdge)->Planar64Vec3{
-		let verts=self.edge_verts(edge_id);
-		self.vert(verts[1].clone())-self.vert(verts[0].clone())
+		let &[v0,v1]=self.edge_verts(edge_id).as_ref();
+		self.vert(v1)-self.vert(v0)
 	}
 	fn directed_edge_n(&self,directed_edge_id:Self::Edge)->Planar64Vec3{
-		let verts=self.edge_verts(directed_edge_id.as_undirected());
-		(self.vert(verts[1].clone())-self.vert(verts[0].clone()))*((directed_edge_id.parity() as i64)*2-1)
+		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)
 	}
 	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)->Cow<[Self::Edge]>;
-	fn edge_faces(&self,edge_id:<Self::Edge as DirectedEdge>::UndirectedEdge)->Cow<[Self::Face;2]>;
-	fn edge_verts(&self,edge_id:<Self::Edge as DirectedEdge>::UndirectedEdge)->Cow<[Self::Vert;2]>;
-	fn vert_edges(&self,vert_id:Self::Vert)->Cow<[Self::Edge]>;
-	fn vert_faces(&self,vert_id:Self::Vert)->Cow<[Self::Face]>;
+	fn face_edges(&self,face_id:Self::Face)->impl AsRef<[Self::Edge]>;
+	fn edge_faces(&self,edge_id:<Self::Edge as DirectedEdge>::UndirectedEdge)->impl AsRef<[Self::Face;2]>;
+	fn edge_verts(&self,edge_id:<Self::Edge as DirectedEdge>::UndirectedEdge)->impl AsRef<[Self::Vert;2]>;
+	fn vert_edges(&self,vert_id:Self::Vert)->impl AsRef<[Self::Edge]>;
+	fn vert_faces(&self,vert_id:Self::Vert)->impl AsRef<[Self::Face]>;
 }
+#[derive(Debug)]
 struct FaceRefs{
 	edges:Vec<SubmeshDirectedEdgeId>,
 	//verts:Vec<VertId>,
 }
+#[derive(Debug)]
 struct EdgeRefs{
 	faces:[SubmeshFaceId;2],//left, right
 	verts:[SubmeshVertId;2],//bottom, top
 }
+#[derive(Debug)]
 struct VertRefs{
 	faces:Vec<SubmeshFaceId>,
 	edges:Vec<SubmeshDirectedEdgeId>,
 }
+#[derive(Debug)]
 pub struct PhysicsMeshData{
 	//this contains all real and virtual faces used in both the complete mesh and convex submeshes
 	//faces are sorted such that all faces that belong to the complete mesh appear first, and then
@@ -112,6 +123,7 @@ pub struct PhysicsMeshData{
 	faces:Vec<Face>,//MeshFaceId indexes this list
 	verts:Vec<Vert>,//MeshVertId indexes this list
 }
+#[derive(Debug)]
 pub struct PhysicsMeshTopology{
 	//mapping of local ids to PhysicsMeshData ids
 	faces:Vec<MeshFaceId>,//SubmeshFaceId indexes this list
@@ -308,6 +320,9 @@ impl TryFrom<&model::Mesh> for PhysicsMesh{
 			return Err(PhysicsMeshError::ZeroVertices);
 		}
 		let verts=mesh.unique_pos.iter().copied().map(Vert).collect();
+		// TODO: do not hash faces to get face id
+		// meshes can have multiple identical nd representations while still being distinct faces,
+		// especially when the complete mesh is a non-convex mesh.
 		//TODO: fix submeshes
 		//flat map mesh.physics_groups[$1].groups.polys()[$2] as face_id
 		//lower face_id points to upper face_id
@@ -372,8 +387,8 @@ impl TryFrom<&model::Mesh> for PhysicsMesh{
 					}
 					//assume face hash is stable, and there are no flush faces...
 					let face=Face{
-						normal:(normal/len as i64).divide().fix_1(),
-						dot:(dot/(len*len) as i64).fix_1(),
+						normal:(normal/len as i64).divide().narrow_1().unwrap(),
+						dot:(dot/(len*len) as i64).narrow_1().unwrap(),
 					};
 					let face_id=match face_id_from_face.get(&face){
 						Some(&face_id)=>face_id,
@@ -416,6 +431,7 @@ impl TryFrom<&model::Mesh> for PhysicsMesh{
 	}
 }
 
+#[derive(Debug)]
 pub struct PhysicsMeshView<'a>{
 	data:&'a PhysicsMeshData,
 	topology:&'a PhysicsMeshTopology,
@@ -435,23 +451,24 @@ impl MeshQuery for PhysicsMeshView<'_>{
 		let vert_idx=self.topology.verts[vert_id.get() as usize].get() as usize;
 		self.data.verts[vert_idx].0
 	}
-	fn face_edges(&self,face_id:SubmeshFaceId)->Cow<[SubmeshDirectedEdgeId]>{
-		Cow::Borrowed(&self.topology.face_topology[face_id.get() as usize].edges)
+	fn face_edges(&self,face_id:SubmeshFaceId)->impl AsRef<[SubmeshDirectedEdgeId]>{
+		self.topology.face_topology[face_id.get() as usize].edges.as_slice()
 	}
-	fn edge_faces(&self,edge_id:SubmeshEdgeId)->Cow<[SubmeshFaceId;2]>{
-		Cow::Borrowed(&self.topology.edge_topology[edge_id.get() as usize].faces)
+	fn edge_faces(&self,edge_id:SubmeshEdgeId)->impl AsRef<[SubmeshFaceId;2]>{
+		AsRefHelper(self.topology.edge_topology[edge_id.get() as usize].faces)
 	}
-	fn edge_verts(&self,edge_id:SubmeshEdgeId)->Cow<[SubmeshVertId;2]>{
-		Cow::Borrowed(&self.topology.edge_topology[edge_id.get() as usize].verts)
+	fn edge_verts(&self,edge_id:SubmeshEdgeId)->impl AsRef<[SubmeshVertId;2]>{
+		AsRefHelper(self.topology.edge_topology[edge_id.get() as usize].verts)
 	}
-	fn vert_edges(&self,vert_id:SubmeshVertId)->Cow<[SubmeshDirectedEdgeId]>{
-		Cow::Borrowed(&self.topology.vert_topology[vert_id.get() as usize].edges)
+	fn vert_edges(&self,vert_id:SubmeshVertId)->impl AsRef<[SubmeshDirectedEdgeId]>{
+		self.topology.vert_topology[vert_id.get() as usize].edges.as_slice()
 	}
-	fn vert_faces(&self,vert_id:SubmeshVertId)->Cow<[SubmeshFaceId]>{
-		Cow::Borrowed(&self.topology.vert_topology[vert_id.get() as usize].faces)
+	fn vert_faces(&self,vert_id:SubmeshVertId)->impl AsRef<[SubmeshFaceId]>{
+		self.topology.vert_topology[vert_id.get() as usize].faces.as_slice()
 	}
 }
 
+#[derive(Debug)]
 pub struct PhysicsMeshTransform{
 	pub vertex:integer::Planar64Affine3,
 	pub normal:integer::mat3::Matrix3<Fixed<2,64>>,
@@ -467,6 +484,7 @@ impl PhysicsMeshTransform{
 	}
 }
 
+#[derive(Debug)]
 pub struct TransformedMesh<'a>{
 	view:PhysicsMeshView<'a>,
 	transform:&'a PhysicsMeshTransform,
@@ -513,26 +531,27 @@ impl MeshQuery for TransformedMesh<'_>{
 		(transformed_n,transformed_d)
 	}
 	fn vert(&self,vert_id:SubmeshVertId)->Planar64Vec3{
-		self.transform.vertex.transform_point3(self.view.vert(vert_id)).fix_1()
+		// wrap for speed
+		self.transform.vertex.transform_point3(self.view.vert(vert_id)).wrap_1()
 	}
 	#[inline]
-	fn face_edges(&self,face_id:SubmeshFaceId)->Cow<[SubmeshDirectedEdgeId]>{
+	fn face_edges(&self,face_id:SubmeshFaceId)->impl AsRef<[SubmeshDirectedEdgeId]>{
 		self.view.face_edges(face_id)
 	}
 	#[inline]
-	fn edge_faces(&self,edge_id:SubmeshEdgeId)->Cow<[SubmeshFaceId;2]>{
+	fn edge_faces(&self,edge_id:SubmeshEdgeId)->impl AsRef<[SubmeshFaceId;2]>{
 		self.view.edge_faces(edge_id)
 	}
 	#[inline]
-	fn edge_verts(&self,edge_id:SubmeshEdgeId)->Cow<[SubmeshVertId;2]>{
+	fn edge_verts(&self,edge_id:SubmeshEdgeId)->impl AsRef<[SubmeshVertId;2]>{
 		self.view.edge_verts(edge_id)
 	}
 	#[inline]
-	fn vert_edges(&self,vert_id:SubmeshVertId)->Cow<[SubmeshDirectedEdgeId]>{
+	fn vert_edges(&self,vert_id:SubmeshVertId)->impl AsRef<[SubmeshDirectedEdgeId]>{
 		self.view.vert_edges(vert_id)
 	}
 	#[inline]
-	fn vert_faces(&self,vert_id:SubmeshVertId)->Cow<[SubmeshFaceId]>{
+	fn vert_faces(&self,vert_id:SubmeshVertId)->impl AsRef<[SubmeshFaceId]>{
 		self.view.vert_faces(vert_id)
 	}
 }
@@ -591,6 +610,7 @@ pub enum MinkowskiFace{
 	//FaceFace
 }
 
+#[derive(Debug)]
 pub struct MinkowskiMesh<'a>{
 	mesh0:TransformedMesh<'a>,
 	mesh1:TransformedMesh<'a>,
@@ -621,12 +641,12 @@ impl MinkowskiMesh<'_>{
 	}
 	fn next_transition_vert(&self,vert_id:MinkowskiVert,best_distance_squared:&mut Fixed<2,64>,infinity_dir:Planar64Vec3,point:Planar64Vec3)->Transition{
 		let mut best_transition=Transition::Done;
-		for &directed_edge_id in self.vert_edges(vert_id).iter(){
+		for &directed_edge_id in self.vert_edges(vert_id).as_ref(){
 			let edge_n=self.directed_edge_n(directed_edge_id);
 			//is boundary uncrossable by a crawl from infinity
 			let edge_verts=self.edge_verts(directed_edge_id.as_undirected());
 			//select opposite vertex
-			let test_vert_id=edge_verts[directed_edge_id.parity() as usize];
+			let test_vert_id=edge_verts.as_ref()[directed_edge_id.parity() as usize];
 			//test if it's closer
 			let diff=point-self.vert(test_vert_id);
 			if edge_n.dot(infinity_dir).is_zero(){
@@ -642,7 +662,7 @@ impl MinkowskiMesh<'_>{
 	fn final_ev(&self,vert_id:MinkowskiVert,best_distance_squared:&mut Fixed<2,64>,infinity_dir:Planar64Vec3,point:Planar64Vec3)->EV{
 		let mut best_transition=EV::Vert(vert_id);
 		let diff=point-self.vert(vert_id);
-		for &directed_edge_id in self.vert_edges(vert_id).iter(){
+		for &directed_edge_id in self.vert_edges(vert_id).as_ref(){
 			let edge_n=self.directed_edge_n(directed_edge_id);
 			//is boundary uncrossable by a crawl from infinity
 			//check if time of collision is outside Time::MIN..Time::MAX
@@ -653,7 +673,8 @@ impl MinkowskiMesh<'_>{
 				if !d.is_negative()&&d<=edge_nn{
 					let distance_squared={
 						let c=diff.cross(edge_n);
-						(c.dot(c)/edge_nn).divide().fix_2()
+						//wrap for speed
+						(c.dot(c)/edge_nn).divide().wrap_2()
 					};
 					if distance_squared<=*best_distance_squared{
 						best_transition=EV::Edge(directed_edge_id.as_undirected());
@@ -689,10 +710,10 @@ impl MinkowskiMesh<'_>{
 				let edge_n=self.edge_n(edge_id);
 				// point is multiplied by two because vert_sum sums two vertices.
 				let delta_pos=point*2-{
-					let &[v0,v1]=self.edge_verts(edge_id).borrow();
+					let &[v0,v1]=self.edge_verts(edge_id).as_ref();
 					self.vert(v0)+self.vert(v1)
 				};
-				for (i,&face_id) in self.edge_faces(edge_id).iter().enumerate(){
+				for (i,&face_id) in self.edge_faces(edge_id).as_ref().iter().enumerate(){
 					let face_n=self.face_nd(face_id).0;
 					//edge-face boundary nd, n facing out of the face towards the edge
 					let boundary_n=face_n.cross(edge_n)*(i as i64*2-1);
@@ -734,7 +755,9 @@ impl MinkowskiMesh<'_>{
 		})
 	}
 	pub fn predict_collision_in(&self,relative_body:&Body,Range{start:start_time,end:time_limit}:Range<Time>)->Option<(MinkowskiFace,GigaTime)>{
+		println!("=== physics setup ===");
 		self.closest_fev_not_inside(relative_body.clone(),start_time).and_then(|fev|{
+			println!("=== physics crawl ===");
 			//continue forwards along the body parabola
 			fev.crawl(self,relative_body,start_time,time_limit).hit()
 		})
@@ -758,19 +781,20 @@ impl MinkowskiMesh<'_>{
 		};
 		let mut best_time={
 			let r=(time_limit-relative_body.time).to_ratio();
-			Ratio::new(r.num.fix_4(),r.den.fix_4())
+			Ratio::new(r.num.widen_4(),r.den.widen_4())
 		};
 		let mut best_edge=None;
 		let face_n=self.face_nd(contact_face_id).0;
-		for &directed_edge_id in self.face_edges(contact_face_id).iter(){
+		for &directed_edge_id in self.face_edges(contact_face_id).as_ref(){
 			let edge_n=self.directed_edge_n(directed_edge_id);
 			//f x e points in
 			let n=face_n.cross(edge_n);
-			let verts=self.edge_verts(directed_edge_id.as_undirected());
-			let d=n.dot(self.vert(verts[0])+self.vert(verts[1]));
+			let &[v0,v1]=self.edge_verts(directed_edge_id.as_undirected()).as_ref();
+			let d=n.dot(self.vert(v0)+self.vert(v1));
 			//WARNING! d outside of *2
 			//WARNING: truncated precision
-			for dt in Fixed::<4,128>::zeroes2(((n.dot(relative_body.position))*2-d).fix_4(),n.dot(relative_body.velocity).fix_4()*2,n.dot(relative_body.acceleration).fix_4()){
+			//wrap for speed
+			for dt in Fixed::<4,128>::zeroes2(((n.dot(relative_body.position))*2-d).wrap_4(),n.dot(relative_body.velocity).wrap_4()*2,n.dot(relative_body.acceleration).wrap_4()){
 				if start_time.le_ratio(dt)&&dt.lt_ratio(best_time)&&n.dot(relative_body.extrapolated_velocity_ratio_dt(dt)).is_negative(){
 					best_time=dt;
 					best_edge=Some(directed_edge_id);
@@ -811,12 +835,12 @@ impl MeshQuery for MinkowskiMesh<'_>{
 			MinkowskiFace::EdgeEdge(e0,e1,parity)=>{
 				let edge0_n=self.mesh0.edge_n(e0);
 				let edge1_n=self.mesh1.edge_n(e1);
-				let &[e0v0,e0v1]=self.mesh0.edge_verts(e0).borrow();
-				let &[e1v0,e1v1]=self.mesh1.edge_verts(e1).borrow();
+				let &[e0v0,e0v1]=self.mesh0.edge_verts(e0).as_ref();
+				let &[e1v0,e1v1]=self.mesh1.edge_verts(e1).as_ref();
 				let n=edge0_n.cross(edge1_n);
 				let e0d=n.dot(self.mesh0.vert(e0v0)+self.mesh0.vert(e0v1));
 				let e1d=n.dot(self.mesh1.vert(e1v0)+self.mesh1.vert(e1v1));
-				((n*(parity as i64*4-2)).fix_3(),((e0d-e1d)*(parity as i64*2-1)).fix_4())
+				((n*(parity as i64*4-2)).widen_3(),((e0d-e1d)*(parity as i64*2-1)).widen_4())
 			},
 			MinkowskiFace::FaceVert(f0,v1)=>{
 				let (n,d)=self.mesh0.face_nd(f0);
@@ -831,44 +855,44 @@ impl MeshQuery for MinkowskiMesh<'_>{
 			},
 		}
 	}
-	fn face_edges(&self,face_id:MinkowskiFace)->Cow<[MinkowskiDirectedEdge]>{
+	fn face_edges(&self,face_id:MinkowskiFace)->impl AsRef<[MinkowskiDirectedEdge]>{
 		match face_id{
 			MinkowskiFace::VertFace(v0,f1)=>{
-				Cow::Owned(self.mesh1.face_edges(f1).iter().map(|&edge_id1|{
+				self.mesh1.face_edges(f1).as_ref().iter().map(|&edge_id1|
 					MinkowskiDirectedEdge::VertEdge(v0,edge_id1.reverse())
-				}).collect())
+				).collect()
 			},
 			MinkowskiFace::EdgeEdge(e0,e1,parity)=>{
-				let e0v=self.mesh0.edge_verts(e0);
-				let e1v=self.mesh1.edge_verts(e1);
+				let &[e0v0,e0v1]=self.mesh0.edge_verts(e0).as_ref();
+				let &[e1v0,e1v1]=self.mesh1.edge_verts(e1).as_ref();
 				//could sort this if ordered edges are needed
 				//probably just need to reverse this list according to parity
-				Cow::Owned(vec![
-					MinkowskiDirectedEdge::VertEdge(e0v[0],e1.as_directed(parity)),
-					MinkowskiDirectedEdge::EdgeVert(e0.as_directed(!parity),e1v[0]),
-					MinkowskiDirectedEdge::VertEdge(e0v[1],e1.as_directed(!parity)),
-					MinkowskiDirectedEdge::EdgeVert(e0.as_directed(parity),e1v[1]),
-				])
+				vec![
+					MinkowskiDirectedEdge::VertEdge(e0v0,e1.as_directed(parity)),
+					MinkowskiDirectedEdge::EdgeVert(e0.as_directed(!parity),e1v0),
+					MinkowskiDirectedEdge::VertEdge(e0v1,e1.as_directed(!parity)),
+					MinkowskiDirectedEdge::EdgeVert(e0.as_directed(parity),e1v1),
+				]
 			},
 			MinkowskiFace::FaceVert(f0,v1)=>{
-				Cow::Owned(self.mesh0.face_edges(f0).iter().map(|&edge_id0|{
+				self.mesh0.face_edges(f0).as_ref().iter().map(|&edge_id0|
 					MinkowskiDirectedEdge::EdgeVert(edge_id0,v1)
-				}).collect())
+				).collect()
 			},
 		}
 	}
-	fn edge_faces(&self,edge_id:MinkowskiEdge)->Cow<[MinkowskiFace;2]>{
+	fn edge_faces(&self,edge_id:MinkowskiEdge)->impl AsRef<[MinkowskiFace;2]>{
 		match edge_id{
 			MinkowskiEdge::VertEdge(v0,e1)=>{
 				//faces are listed backwards from the minkowski mesh
 				let v0e=self.mesh0.vert_edges(v0);
-				let &[e1f0,e1f1]=self.mesh1.edge_faces(e1).borrow();
-				Cow::Owned([(e1f1,false),(e1f0,true)].map(|(edge_face_id1,face_parity)|{
+				let &[e1f0,e1f1]=self.mesh1.edge_faces(e1).as_ref();
+				AsRefHelper([(e1f1,false),(e1f0,true)].map(|(edge_face_id1,face_parity)|{
 					let mut best_edge=None;
 					let mut best_d:Ratio<Fixed<8,256>,Fixed<8,256>>=Ratio::new(Fixed::ZERO,Fixed::ONE);
 					let edge_face1_n=self.mesh1.face_nd(edge_face_id1).0;
 					let edge_face1_nn=edge_face1_n.dot(edge_face1_n);
-					for &directed_edge_id0 in v0e.iter(){
+					for &directed_edge_id0 in v0e.as_ref(){
 						let edge0_n=self.mesh0.directed_edge_n(directed_edge_id0);
 						//must be behind other face.
 						let d=edge_face1_n.dot(edge0_n);
@@ -890,21 +914,26 @@ impl MeshQuery for MinkowskiMesh<'_>{
 				}))
 			},
 			MinkowskiEdge::EdgeVert(e0,v1)=>{
+				println!("MinkowskiEdge::EdgeVert({e0:?},{v1:?})");
 				//tracking index with an external variable because .enumerate() is not available
 				let v1e=self.mesh1.vert_edges(v1);
-				let &[e0f0,e0f1]=self.mesh0.edge_faces(e0).borrow();
-				Cow::Owned([(e0f0,true),(e0f1,false)].map(|(edge_face_id0,face_parity)|{
+				let &[e0f0,e0f1]=self.mesh0.edge_faces(e0).as_ref();
+				AsRefHelper([(e0f0,true),(e0f1,false)].map(|(edge_face_id0,face_parity)|{
 					let mut best_edge=None;
 					let mut best_d:Ratio<Fixed<8,256>,Fixed<8,256>>=Ratio::new(Fixed::ZERO,Fixed::ONE);
 					let edge_face0_n=self.mesh0.face_nd(edge_face_id0).0;
+					println!("edge_face0_n={edge_face0_n}");
 					let edge_face0_nn=edge_face0_n.dot(edge_face0_n);
-					for &directed_edge_id1 in v1e.iter(){
+					for &directed_edge_id1 in v1e.as_ref(){
 						let edge1_n=self.mesh1.directed_edge_n(directed_edge_id1);
+						println!("edge1_n={edge1_n}");
 						let d=edge_face0_n.dot(edge1_n);
+						println!("d={d} {d:?}");
 						if d.is_negative(){
 							let edge1_nn=edge1_n.dot(edge1_n);
 							let dd=(d*d)/(edge_face0_nn*edge1_nn);
-							if best_d<dd{
+							if !dd.den.is_zero()&&best_d<dd{
+								println!("dd={dd:?}");
 								best_d=dd;
 								best_edge=Some(directed_edge_id1);
 							}
@@ -918,31 +947,27 @@ impl MeshQuery for MinkowskiMesh<'_>{
 			},
 		}
 	}
-	fn edge_verts(&self,edge_id:MinkowskiEdge)->Cow<[MinkowskiVert;2]>{
-		match edge_id{
-			MinkowskiEdge::VertEdge(v0,e1)=>{
-				Cow::Owned(self.mesh1.edge_verts(e1).map(|vert_id1|{
-					MinkowskiVert::VertVert(v0,vert_id1)
-				}))
-			},
-			MinkowskiEdge::EdgeVert(e0,v1)=>{
-				Cow::Owned(self.mesh0.edge_verts(e0).map(|vert_id0|{
-					MinkowskiVert::VertVert(vert_id0,v1)
-				}))
-			},
-		}
+	fn edge_verts(&self,edge_id:MinkowskiEdge)->impl AsRef<[MinkowskiVert;2]>{
+		AsRefHelper(match edge_id{
+			MinkowskiEdge::VertEdge(v0,e1)=>(*self.mesh1.edge_verts(e1).as_ref()).map(|vert_id1|
+				MinkowskiVert::VertVert(v0,vert_id1)
+			),
+			MinkowskiEdge::EdgeVert(e0,v1)=>(*self.mesh0.edge_verts(e0).as_ref()).map(|vert_id0|
+				MinkowskiVert::VertVert(vert_id0,v1)
+			),
+		})
 	}
-	fn vert_edges(&self,vert_id:MinkowskiVert)->Cow<[MinkowskiDirectedEdge]>{
+	fn vert_edges(&self,vert_id:MinkowskiVert)->impl AsRef<[MinkowskiDirectedEdge]>{
 		match vert_id{
 			MinkowskiVert::VertVert(v0,v1)=>{
 				let mut edges=Vec::new();
 				//detect shared volume when the other mesh is mirrored along a test edge dir
 				let v0f=self.mesh0.vert_faces(v0);
 				let v1f=self.mesh1.vert_faces(v1);
-				let v0f_n:Vec<_>=v0f.iter().map(|&face_id|self.mesh0.face_nd(face_id).0).collect();
-				let v1f_n:Vec<_>=v1f.iter().map(|&face_id|self.mesh1.face_nd(face_id).0).collect();
-				let the_len=v0f.len()+v1f.len();
-				for &directed_edge_id in self.mesh0.vert_edges(v0).iter(){
+				let v0f_n:Vec<_>=v0f.as_ref().iter().map(|&face_id|self.mesh0.face_nd(face_id).0).collect();
+				let v1f_n:Vec<_>=v1f.as_ref().iter().map(|&face_id|self.mesh1.face_nd(face_id).0).collect();
+				let the_len=v0f.as_ref().len()+v1f.as_ref().len();
+				for &directed_edge_id in self.mesh0.vert_edges(v0).as_ref(){
 					let n=self.mesh0.directed_edge_n(directed_edge_id);
 					let nn=n.dot(n);
 					// TODO: there's gotta be a better way to do this
@@ -952,30 +977,33 @@ impl MeshQuery for MinkowskiMesh<'_>{
 					face_normals.clone_from(&v0f_n);
 					for face_n in &v1f_n{
 						//add reflected mesh1 faces
-						face_normals.push(*face_n-(n*face_n.dot(n)*2/nn).divide().fix_3());
+						//wrap for speed
+						face_normals.push(*face_n-(n*face_n.dot(n)*2/nn).divide().wrap_3());
 					}
 					if is_empty_volume(face_normals){
 						edges.push(MinkowskiDirectedEdge::EdgeVert(directed_edge_id,v1));
 					}
 				}
-				for &directed_edge_id in self.mesh1.vert_edges(v1).iter(){
+				for &directed_edge_id in self.mesh1.vert_edges(v1).as_ref(){
 					let n=self.mesh1.directed_edge_n(directed_edge_id);
 					let nn=n.dot(n);
 					let mut face_normals=Vec::with_capacity(the_len);
 					face_normals.clone_from(&v1f_n);
 					for face_n in &v0f_n{
-						face_normals.push(*face_n-(n*face_n.dot(n)*2/nn).divide().fix_3());
+						//wrap for speed
+						face_normals.push(*face_n-(n*face_n.dot(n)*2/nn).divide().wrap_3());
 					}
 					if is_empty_volume(face_normals){
 						edges.push(MinkowskiDirectedEdge::VertEdge(v0,directed_edge_id));
 					}
 				}
-				Cow::Owned(edges)
+				edges
 			},
 		}
 	}
-	fn vert_faces(&self,_vert_id:MinkowskiVert)->Cow<[MinkowskiFace]>{
-		unimplemented!()
+	fn vert_faces(&self,_vert_id:MinkowskiVert)->impl AsRef<[MinkowskiFace]>{
+		unimplemented!();
+		vec![]
 	}
 }
 
@@ -1005,6 +1033,6 @@ fn is_empty_volume(normals:Vec<Vector3<Fixed<3,96>>>)->bool{
 
 #[test]
 fn test_is_empty_volume(){
-	assert!(!is_empty_volume([vec3::X.fix_3(),vec3::Y.fix_3(),vec3::Z.fix_3()].to_vec()));
-	assert!(is_empty_volume([vec3::X.fix_3(),vec3::Y.fix_3(),vec3::Z.fix_3(),vec3::NEG_X.fix_3()].to_vec()));
+	assert!(!is_empty_volume([vec3::X.widen_3(),vec3::Y.widen_3(),vec3::Z.widen_3()].to_vec()));
+	assert!(is_empty_volume([vec3::X.widen_3(),vec3::Y.widen_3(),vec3::Z.widen_3(),vec3::NEG_X.widen_3()].to_vec()));
 }

engine/physics/src/physics.rs

@@ -117,8 +117,8 @@ impl TransientAcceleration{
 		}else{
 			//normal friction acceleration is clippedAcceleration.dot(normal)*friction
 			TransientAcceleration::Reachable{
-				acceleration:target_diff.with_length(accel).divide().fix_1(),
-				time:time+Time::from((target_diff.length()/accel).divide().fix_1())
+				acceleration:target_diff.with_length(accel).divide().wrap_1(),
+				time:time+Time::from((target_diff.length()/accel).divide().clamp_1())
 			}
 		}
 	}
@@ -407,7 +407,7 @@ impl HitboxMesh{
 		let transform=PhysicsMeshTransform::new(transform);
 		let transformed_mesh=TransformedMesh::new(mesh.complete_mesh_view(),&transform);
 		for vert in transformed_mesh.verts(){
-			aabb.grow(vert.fix_1());
+			aabb.grow(vert.narrow_1().unwrap());
 		}
 		Self{
 			halfsize:aabb.size()>>1,
@@ -460,12 +460,12 @@ impl StyleHelper for StyleModifiers{
 	}
 
 	fn get_y_control_dir(&self,camera:&PhysicsCamera,controls:Controls)->Planar64Vec3{
-		(camera.rotation_y()*self.get_control_dir(controls)).fix_1()
+		(camera.rotation_y()*self.get_control_dir(controls)).wrap_1()
 	}
 
 	fn get_propulsion_control_dir(&self,camera:&PhysicsCamera,controls:Controls)->Planar64Vec3{
 		//don't interpolate this! discrete mouse movement, constant acceleration
-		(camera.rotation()*self.get_control_dir(controls)).fix_1()
+		(camera.rotation()*self.get_control_dir(controls)).wrap_1()
 	}
 	fn calculate_mesh(&self)->HitboxMesh{
 		let mesh=match self.hitbox.mesh{
@@ -857,6 +857,12 @@ impl Default for PhysicsState{
 }
 
 impl PhysicsState{
+	pub fn new_at_position(position:Planar64Vec3)->Self{
+		Self{
+			body:Body::new(position,vec3::int(0,0,0),vec3::int(0,-100,0),Time::ZERO),
+			..Self::default()
+		}
+	}
 	pub fn camera_body(&self)->Body{
 		Body{
 			position:self.body.position+self.style.camera_offset,
@@ -982,10 +988,7 @@ impl PhysicsContext<'_>{
 impl PhysicsData{
 	/// use with caution, this is the only non-instruction way to mess with physics
 	pub fn generate_models(&mut self,map:&map::CompleteMap){
-		let mut modes=map.modes.clone();
-		for mode in &mut modes.modes{
-			mode.denormalize_data();
-		}
+		let mut modes=map.modes.clone().denormalize();
 		let mut used_contact_attributes=Vec::new();
 		let mut used_intersect_attributes=Vec::new();
 
@@ -1087,7 +1090,7 @@ impl PhysicsData{
 				let mut aabb=aabb::Aabb::default();
 				let transformed_mesh=TransformedMesh::new(view,transform);
 				for v in transformed_mesh.verts(){
-					aabb.grow(v.fix_1());
+					aabb.grow(v.narrow_1().unwrap());
 				}
 				(ConvexMeshId{
 					model_id,
@@ -1125,7 +1128,7 @@ impl PhysicsData{
 		//JUST POLLING!!! NO MUTATION
 		let mut collector=instruction::InstructionCollector::new(time_limit);
 
-		collector.collect(state.next_move_instruction());
+		// collector.collect(state.next_move_instruction());
 
 		//check for collision ends
 		state.touching.predict_collision_end(&mut collector,&data.models,&data.hitbox_mesh,&state.body,state.time);
@@ -1137,6 +1140,7 @@ impl PhysicsData{
 		//let relative_body=state.body.relative_to(&Body::ZERO);
 		let relative_body=&state.body;
 		data.bvh.sample_aabb(&aabb,&mut |&convex_mesh_id|{
+			println!("sample model={:?}",convex_mesh_id.model_id);
 			//no checks are needed because of the time limits.
 			let model_mesh=data.models.mesh(convex_mesh_id);
 			let minkowski=model_physics::MinkowskiMesh::minkowski_sum(model_mesh,data.hitbox_mesh.transformed_mesh());
@@ -1165,7 +1169,8 @@ fn contact_normal(models:&PhysicsModels,hitbox_mesh:&HitboxMesh,contact:&Contact
 	let model_mesh=models.contact_mesh(contact);
 	let minkowski=model_physics::MinkowskiMesh::minkowski_sum(model_mesh,hitbox_mesh.transformed_mesh());
 	// TODO: normalize to i64::MAX>>1
-	minkowski.face_nd(contact.face_id).0.fix_1()
+	// wrap for speed
+	minkowski.face_nd(contact.face_id).0.wrap_1()
 }
 
 fn recalculate_touching(
@@ -1324,7 +1329,7 @@ fn teleport_to_spawn(
 	const EPSILON:Planar64=Planar64::raw((1<<32)/16);
 	let transform=models.get_model_transform(spawn_model_id).ok_or(TeleportToSpawnError::NoModel)?;
 	//TODO: transform.vertex.matrix3.col(1)+transform.vertex.translation
-	let point=transform.vertex.transform_point3(vec3::Y).fix_1()+Planar64Vec3::new([Planar64::ZERO,style.hitbox.halfsize.y+EPSILON,Planar64::ZERO]);
+	let point=transform.vertex.transform_point3(vec3::Y).clamp_1()+Planar64Vec3::new([Planar64::ZERO,style.hitbox.halfsize.y+EPSILON,Planar64::ZERO]);
 	teleport(point,move_state,body,touching,run,mode_state,Some(mode),models,hitbox_mesh,bvh,style,camera,input_state,time);
 	Ok(())
 }
@@ -1488,7 +1493,7 @@ fn collision_start_contact(
 		Some(gameplay_attributes::ContactingBehaviour::Surf)=>(),
 		Some(gameplay_attributes::ContactingBehaviour::Cling)=>println!("Unimplemented!"),
 		&Some(gameplay_attributes::ContactingBehaviour::Elastic(elasticity))=>{
-			let reflected_velocity=body.velocity+((body.velocity-incident_velocity)*Planar64::raw(elasticity as i64+1)).fix_1();
+			let reflected_velocity=body.velocity+((body.velocity-incident_velocity)*Planar64::raw(elasticity as i64+1)).wrap_1();
 			set_velocity(body,touching,models,hitbox_mesh,reflected_velocity);
 		},
 		Some(gameplay_attributes::ContactingBehaviour::Ladder(contacting_ladder))=>
@@ -1667,6 +1672,7 @@ fn atomic_internal_instruction(state:&mut PhysicsState,data:&PhysicsData,ins:Tim
 	}
 		match ins.instruction{
 			InternalInstruction::CollisionStart(collision,_)=>{
+				println!("yeaahhh!");
 				let mode=data.modes.get_mode(state.mode_state.get_mode_id());
 				match collision{
 					Collision::Contact(contact)=>collision_start_contact(
@@ -1711,7 +1717,7 @@ fn atomic_internal_instruction(state:&mut PhysicsState,data:&PhysicsData,ins:Tim
 						let control_dir=state.style.get_control_dir(masked_controls);
 						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().fix_1()){
+							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
 								//need to note which push planes activate in push solve and keep those
 								state.cull_velocity(data,ticked_velocity);
@@ -1814,14 +1820,18 @@ 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 mode=data.modes.get_mode(mode_id);
-			let spawn_point=mode.and_then(|mode|
+			if let Some(mode)=mode{
+				// set style
+				state.style=mode.get_style().clone();
 				//TODO: spawn at the bottom of the start zone plus the hitbox size
-				//TODO: set camera andles to face the same way as the start zone
-				data.models.get_model_transform(mode.get_start().into()).map(|transform|
-					transform.vertex.translation
-				)
-			).unwrap_or(vec3::ZERO);
+				//TODO: set camera angles to face the same way as the start zone
+				if let Some(transform)=data.models.get_model_transform(mode.get_start()){
+					// NOTE: this value may be 0,0,0 on source maps
+					spawn_point=transform.vertex.translation;
+				}
+			}
 			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);
 			state.set_move_state(data,MoveState::Air);
@@ -1831,6 +1841,9 @@ fn atomic_input_instruction(state:&mut PhysicsState,data:&PhysicsData,ins:TimedI
 		Instruction::Mode(ModeInstruction::Spawn(mode_id,stage_id))=>{
 			//spawn at a particular stage
 			if let Some(mode)=data.modes.get_mode(mode_id){
+				// set style
+				state.style=mode.get_style().clone();
+				// teleport to stage in mode
 				if let Some(stage)=mode.get_stage(stage_id){
 					let _=teleport_to_spawn(
 						stage.spawn(),

engine/physics/src/push_solve.rs

@@ -152,18 +152,19 @@ const fn get_push_ray_0(point:Planar64Vec3)->Ray{
 	Ray{origin:point,direction:vec3::ZERO}
 }
 fn get_push_ray_1(point:Planar64Vec3,c0:&Contact)->Option<Ray>{
-	let direction=solve1(c0)?.divide().fix_1();
+	//wrap for speed
+	let direction=solve1(c0)?.divide().wrap_1();
 	let [s0]=decompose1(direction,c0.velocity)?;
 	if s0.lt_ratio(RATIO_ZERO){
 		return None;
 	}
 	let origin=point+solve1(
 		&c0.relative_to(point),
-	)?.divide().fix_1();
+	)?.divide().wrap_1();
 	Some(Ray{origin,direction})
 }
 fn get_push_ray_2(point:Planar64Vec3,c0:&Contact,c1:&Contact)->Option<Ray>{
-	let direction=solve2(c0,c1)?.divide().fix_1();
+	let direction=solve2(c0,c1)?.divide().wrap_1();
 	let [s0,s1]=decompose2(direction,c0.velocity,c1.velocity)?;
 	if s0.lt_ratio(RATIO_ZERO)||s1.lt_ratio(RATIO_ZERO){
 		return None;
@@ -171,11 +172,11 @@ fn get_push_ray_2(point:Planar64Vec3,c0:&Contact,c1:&Contact)->Option<Ray>{
 	let origin=point+solve2(
 		&c0.relative_to(point),
 		&c1.relative_to(point),
-	)?.divide().fix_1();
+	)?.divide().wrap_1();
 	Some(Ray{origin,direction})
 }
 fn get_push_ray_3(point:Planar64Vec3,c0:&Contact,c1:&Contact,c2:&Contact)->Option<Ray>{
-	let direction=solve3(c0,c1,c2)?.divide().fix_1();
+	let direction=solve3(c0,c1,c2)?.divide().wrap_1();
 	let [s0,s1,s2]=decompose3(direction,c0.velocity,c1.velocity,c2.velocity)?;
 	if s0.lt_ratio(RATIO_ZERO)||s1.lt_ratio(RATIO_ZERO)||s2.lt_ratio(RATIO_ZERO){
 		return None;
@@ -184,7 +185,7 @@ fn get_push_ray_3(point:Planar64Vec3,c0:&Contact,c1:&Contact,c2:&Contact)->Optio
 		&c0.relative_to(point),
 		&c1.relative_to(point),
 		&c2.relative_to(point),
-	)?.divide().fix_1();
+	)?.divide().wrap_1();
 	Some(Ray{origin,direction})
 }
 

integration-testing/src/main.rs

@@ -1,10 +1,43 @@
-
-use std::{io::{Cursor,Read},path::Path};
+use std::io::Cursor;
+use std::path::Path;
+use std::time::Instant;
 
 use strafesnet_physics::physics::{PhysicsData,PhysicsState,PhysicsContext};
 
 fn main(){
-	test_determinism().unwrap();
+	let arg=std::env::args().skip(1).next();
+	match arg.as_deref(){
+		Some("determinism")|None=>test_determinism().unwrap(),
+		Some("replay")=>run_replay().unwrap(),
+		Some("bug2")=>physics_bug_2().unwrap(),
+		_=>println!("invalid argument"),
+	}
+}
+
+fn physics_bug_2()->Result<(),ReplayError>{
+	println!("loading map file..");
+	let data=read_entire_file("bhop_monster_jam.snfm")?;
+	let map=strafesnet_snf::read_map(data)?.into_complete_map()?;
+
+	// create recording
+	let mut physics_data=PhysicsData::default();
+	println!("generating models..");
+	physics_data.generate_models(&map);
+	println!("simulating...");
+
+	//teleport to bug
+	// body pos = Vector { array: [Fixed { bits: 554895163352 }, Fixed { bits: 1485633089990 }, Fixed { bits: 1279601007173 }] }
+	// after the fix it's still happening, possibly for a different reason, new position to evince:
+	// body pos = Vector { array: [Fixed { bits: 555690659654 }, Fixed { bits: 1490485868773 }, Fixed { bits: 1277783839382 }] }
+	let mut physics=PhysicsState::new_at_position(strafesnet_common::integer::vec3::raw_xyz(555690659654,1490485868773,1277783839382));
+	// wait one second to activate the bug
+	// hit=Some(ModelId(2262))
+	PhysicsContext::run_input_instruction(&mut physics,&physics_data,strafesnet_common::instruction::TimedInstruction{
+		time:strafesnet_common::integer::Time::from_millis(500),
+		instruction:strafesnet_common::physics::Instruction::Idle,
+	});
+
+	Ok(())
 }
 
 #[allow(unused)]
@@ -37,9 +70,7 @@ impl From<strafesnet_snf::bot::Error> for ReplayError{
 }
 
 fn read_entire_file(path:impl AsRef<Path>)->Result<Cursor<Vec<u8>>,std::io::Error>{
-	let mut file=std::fs::File::open(path)?;
-	let mut data=Vec::new();
-	file.read_to_end(&mut data)?;
+	let data=std::fs::read(path)?;
 	Ok(Cursor::new(data))
 }
 
@@ -72,7 +103,12 @@ enum DeterminismResult{
 	Deterministic,
 	NonDeterministic,
 }
-fn segment_determinism(bot:strafesnet_snf::bot::Segment,physics_data:&PhysicsData)->DeterminismResult{
+struct SegmentResult{
+	determinism:DeterminismResult,
+	ticks:u64,
+	nanoseconds:u64,
+}
+fn segment_determinism(bot:strafesnet_snf::bot::Segment,physics_data:&PhysicsData)->SegmentResult{
 	// create default physics state
 	let mut physics_deterministic=PhysicsState::default();
 	// create a second physics state
@@ -82,6 +118,9 @@ fn segment_determinism(bot:strafesnet_snf::bot::Segment,physics_data:&PhysicsDat
 	println!("simulating...");
 
 	let mut non_idle_count=0;
+	let instruction_count=bot.instructions.len();
+
+	let start=Instant::now();
 
 	for (i,ins) in bot.instructions.into_iter().enumerate(){
 		let state_deterministic=physics_deterministic.clone();
@@ -97,6 +136,7 @@ fn segment_determinism(bot:strafesnet_snf::bot::Segment,physics_data:&PhysicsDat
 				let b0=physics_deterministic.camera_body();
 				let b1=physics_filtered.camera_body();
 				if b0.position!=b1.position{
+					let nanoseconds=start.elapsed().as_nanos() as u64;
 					println!("desync at instruction #{}",i);
 					println!("non idle instructions completed={non_idle_count}");
 					println!("instruction #{i}={:?}",other);
@@ -104,11 +144,16 @@ fn segment_determinism(bot:strafesnet_snf::bot::Segment,physics_data:&PhysicsDat
 					println!("filtered state0:\n{state_filtered:?}");
 					println!("deterministic state1:\n{:?}",physics_deterministic);
 					println!("filtered state1:\n{:?}",physics_filtered);
-					return DeterminismResult::NonDeterministic;
+					return SegmentResult{
+						determinism:DeterminismResult::NonDeterministic,
+						ticks:1+i as u64+non_idle_count,
+						nanoseconds,
+					};
 				}
 			},
 		}
 	}
+	let nanoseconds=start.elapsed().as_nanos() as u64;
 	match physics_deterministic.get_finish_time(){
 		Some(time)=>println!("[with idle] finish time:{}",time),
 		None=>println!("[with idle] simulation did not end in finished state"),
@@ -117,9 +162,14 @@ fn segment_determinism(bot:strafesnet_snf::bot::Segment,physics_data:&PhysicsDat
 		Some(time)=>println!("[filtered] finish time:{}",time),
 		None=>println!("[filtered] simulation did not end in finished state"),
 	}
-	DeterminismResult::Deterministic
+	SegmentResult{
+		determinism:DeterminismResult::Deterministic,
+		ticks:instruction_count as u64+non_idle_count,
+		nanoseconds,
+	}
+
 }
-type ThreadResult=Result<Option<DeterminismResult>,ReplayError>;
+type ThreadResult=Result<Option<SegmentResult>,ReplayError>;
 fn read_and_run(file_path:std::path::PathBuf,physics_data:&PhysicsData)->ThreadResult{
 	let data=read_entire_file(file_path.as_path())?;
 	let bot=strafesnet_snf::read_bot(data)?.read_all()?;
@@ -198,10 +248,18 @@ fn test_determinism()->Result<(),ReplayError>{
 		invalid:u32,
 		error:u32,
 	}
+	let mut nanoseconds=0;
+	let mut ticks=0;
 	let Totals{deterministic,nondeterministic,invalid,error}=thread_results.into_iter().fold(Totals::default(),|mut totals,result|{
 		match result{
-			Ok(Some(DeterminismResult::Deterministic))=>totals.deterministic+=1,
-			Ok(Some(DeterminismResult::NonDeterministic))=>totals.nondeterministic+=1,
+			Ok(Some(segment_result))=>{
+				ticks+=segment_result.ticks;
+				nanoseconds+=segment_result.nanoseconds;
+				match segment_result.determinism{
+					DeterminismResult::Deterministic=>totals.deterministic+=1,
+					DeterminismResult::NonDeterministic=>totals.nondeterministic+=1,
+				}
+			},
 			Ok(None)=>totals.invalid+=1,
 			Err(_)=>totals.error+=1,
 		}
@@ -212,6 +270,7 @@ fn test_determinism()->Result<(),ReplayError>{
 	println!("nondeterministic={nondeterministic}");
 	println!("invalid={invalid}");
 	println!("error={error}");
+	println!("average ticks/s per core: {}",ticks*1_000_000_000/nanoseconds);
 
 	assert!(nondeterministic==0);
 	assert!(invalid==0);

lib/bsp_loader/Cargo.toml

@@ -13,7 +13,7 @@ authors = ["Rhys Lloyd <krakow20@gmail.com>"]
 glam = "0.30.0"
 strafesnet_common = { version = "0.6.0", path = "../common", registry = "strafesnet" }
 strafesnet_deferred_loader = { version = "0.5.0", path = "../deferred_loader", registry = "strafesnet" }
-vbsp = { version = "0.7.0-codegen5", registry = "strafesnet", default-features = false }
-vbsp-entities = { version = "0.1.0", registry = "strafesnet", default-features = false, features = ["css"]}
+vbsp = "0.8.0"
+vbsp-entities-css = "0.6.0"
 vmdl = "0.2.0"
-vpk = "0.2.0"
+vpk = "0.3.0"

lib/bsp_loader/src/brush.rs

@@ -1,5 +1,5 @@
-use strafesnet_common::integer::Planar64;
-use strafesnet_common::{model,integer};
+use strafesnet_common::integer::{self,Planar64,Planar64Vec3};
+use strafesnet_common::model::{self,VertexId};
 use strafesnet_common::integer::{vec3::Vector3,Fixed,Ratio};
 
 use crate::{valve_transform_normal,valve_transform_dist};
@@ -34,6 +34,7 @@ pub enum PlanesToFacesError{
 	InitFace2,
 	InitIntersection,
 	FindNewIntersection,
+	// Narrow(strafesnet_common::integer::NarrowError),
 	EmptyFaces,
 	InfiniteLoop1,
 	InfiniteLoop2,
@@ -81,12 +82,12 @@ fn planes_to_faces(face_list:std::collections::HashSet<Face>)->Result<Faces,Plan
 			// test if any *other* faces occlude the intersection
 			for new_face in &face_list{
 				// new face occludes intersection point
-				if (new_face.dot.fix_2()/Planar64::ONE).lt_ratio(new_face.normal.dot(intersection.num)/intersection.den){
+				if (new_face.dot.widen_2()/Planar64::ONE).lt_ratio(new_face.normal.dot(intersection.num)/intersection.den){
 					// replace one of the faces with the new face
 					// dont' try to replace face0 because we are exploring that face in particular
 					if let Some(new_intersection)=solve3(face0,new_face,face2){
 						// face1 does not occlude (or intersect) the new intersection
-						if (face1.dot.fix_2()/Planar64::ONE).gt_ratio(face1.normal.dot(new_intersection.num)/new_intersection.den){
+						if (face1.dot.widen_2()/Planar64::ONE).gt_ratio(face1.normal.dot(new_intersection.num)/new_intersection.den){
 							face1=new_face;
 							intersection=new_intersection;
 							continue 'find;
@@ -94,7 +95,7 @@ fn planes_to_faces(face_list:std::collections::HashSet<Face>)->Result<Faces,Plan
 					}
 					if let Some(new_intersection)=solve3(face0,face1,new_face){
 						// face2 does not occlude (or intersect) the new intersection
-						if (face2.dot.fix_2()/Planar64::ONE).gt_ratio(face2.normal.dot(new_intersection.num)/new_intersection.den){
+						if (face2.dot.widen_2()/Planar64::ONE).gt_ratio(face2.normal.dot(new_intersection.num)/new_intersection.den){
 							face2=new_face;
 							intersection=new_intersection;
 							continue 'find;
@@ -119,7 +120,7 @@ fn planes_to_faces(face_list:std::collections::HashSet<Face>)->Result<Faces,Plan
 				continue;
 			}
 			// new_face occludes intersection meaning intersection is not on convex solid and face0 is degenrate
-			if (new_face.dot.fix_2()/Planar64::ONE).lt_ratio(new_face.normal.dot(intersection.num)/intersection.den){
+			if (new_face.dot.widen_2()/Planar64::ONE).lt_ratio(new_face.normal.dot(intersection.num)/intersection.den){
 				// abort! reject face0 entirely
 				continue 'face;
 			}
@@ -137,7 +138,15 @@ fn planes_to_faces(face_list:std::collections::HashSet<Face>)->Result<Faces,Plan
 		loop{
 			// push point onto vertices
 			// problem: this may push a vertex that does not fit in the fixed point range and is thus meaningless
-			face.push(intersection.divide().fix_1());
+			//
+			// physics bug 2 originates from vertices being imprecise?
+			//
+			// Mask off the most precise 16 bits so that
+			// when face normals are calculated from
+			// the remaining 16 fractional bits
+			// they never exceed 32 bits of precision.
+			const MASK:Planar64=Planar64::raw(!((1<<16)-1));
+			face.push(intersection.divide().narrow_1().unwrap().map(|c|c&MASK));
 
 			// we looped back around to face1, we're done!
 			if core::ptr::eq(face1,face2){
@@ -203,6 +212,33 @@ impl std::fmt::Display for BrushToMeshError{
 }
 impl core::error::Error for BrushToMeshError{}
 
+fn subdivide_max_area(tris:&mut Vec<Vec<VertexId>>,cw_verts:&[(VertexId,Planar64Vec3)],i0:usize,i2:usize,id0:VertexId,id2:VertexId,v0:Planar64Vec3,v2:Planar64Vec3){
+	if i0+1==i2{
+		return;
+	}
+	let mut best_i1=i0+1;
+	if i0+2<i2{
+		let mut best_area={
+			let (_,v1)=cw_verts[best_i1.rem_euclid(cw_verts.len())];
+			(v2-v0).cross(v1-v0).length_squared()
+		};
+		for i1 in i0+2..=i2-1{
+			let (_,v1)=cw_verts[i1.rem_euclid(cw_verts.len())];
+			let area=(v2-v0).cross(v1-v0).length_squared();
+			if best_area<area{
+				best_i1=i1;
+				best_area=area;
+			}
+		}
+	}
+	let i1=best_i1;
+	let (id1,v1)=cw_verts[i1.rem_euclid(cw_verts.len())];
+	// draw max area first
+	tris.push(vec![id0,id1,id2]);
+	subdivide_max_area(tris,cw_verts,i0,i1,id0,id1,v0,v1);
+	subdivide_max_area(tris,cw_verts,i1,i2,id1,id2,v1,v2);
+}
+
 pub fn faces_to_mesh(faces:Vec<Vec<integer::Planar64Vec3>>)->model::Mesh{
 	// generate the mesh
 	let mut mb=model::MeshBuilder::new();
@@ -211,16 +247,34 @@ pub fn faces_to_mesh(faces:Vec<Vec<integer::Planar64Vec3>>)->model::Mesh{
 	// normals are ignored by physics
 	let normal=mb.acquire_normal_id(integer::vec3::ZERO);
 
-	let polygon_list=faces.into_iter().map(|face|{
-		face.into_iter().map(|pos|{
-			let pos=mb.acquire_pos_id(pos);
-			mb.acquire_vertex_id(model::IndexedVertex{
+	let polygon_list=faces.into_iter().flat_map(|face|{
+		let cw_verts=face.into_iter().map(|position|{
+			let pos=mb.acquire_pos_id(position);
+			(mb.acquire_vertex_id(model::IndexedVertex{
 				pos,
 				tex,
 				normal,
 				color,
-			})
-		}).collect()
+			}),position)
+		}).collect::<Vec<_>>();
+
+		// scan and select maximum area triangle O(n^3)
+		let len=cw_verts.len();
+		let cw_verts=cw_verts.as_slice();
+		let ((i0,i1,i2),(v0,v1,v2))=cw_verts[..len-2].iter().enumerate().flat_map(|(i0,&(_,v0))|
+			cw_verts[i0+1..len-1].iter().enumerate().flat_map(move|(i1,&(_,v1))|
+				cw_verts[i0+i1+2..].iter().enumerate().map(move|(i2,&(_,v2))|((i0,i0+i1+1,i0+i1+i2+2),(v0,v1,v2)))
+			)
+		).max_by_key(|&(_,(v0,v1,v2))|(v2-v0).cross(v1-v0).length_squared()).unwrap();
+		// scan and select more maximum area triangles n * O(n)
+		let mut tris=Vec::with_capacity(len-2);
+		// da big one
+		let (id0,id1,id2)=(cw_verts[i0].0,cw_verts[i1].0,cw_verts[i2].0);
+		tris.push(vec![id0,id1,id2]);
+		subdivide_max_area(&mut tris,cw_verts,i0,i1,id0,id1,v0,v1);
+		subdivide_max_area(&mut tris,cw_verts,i1,i2,id1,id2,v1,v2);
+		subdivide_max_area(&mut tris,cw_verts,i2,i0+len,id2,id0,v2,v0);
+		tris
 	}).collect();
 
 	let polygon_groups=vec![model::PolygonGroup::PolygonList(model::PolygonList::new(polygon_list))];
@@ -240,7 +294,7 @@ pub fn brush_to_mesh(bsp:&vbsp::Bsp,brush:&vbsp::Brush)->Result<model::Mesh,Brus
 		// The so-called tumor brushes have TRIGGER bit set
 		// but also ignore visleaf hint and skip sides
 		const TUMOR:vbsp::TextureFlags=vbsp::TextureFlags::HINT.union(vbsp::TextureFlags::SKIP).union(vbsp::TextureFlags::TRIGGER);
-		if let Some(texture_info)=bsp.textures_info.get(side.texture_info as usize){
+		if let Some(texture_info)=bsp.texture_info(side.texture_info as usize){
 			if texture_info.flags.intersects(TUMOR){
 				return None;
 			}

lib/bsp_loader/src/bsp.rs

@@ -1,11 +1,12 @@
 use std::borrow::Cow;
 
-use vbsp_entities::css::Entity;
+use vbsp_entities_css::Entity;
 
-use strafesnet_common::{map,model,integer,gameplay_attributes};
+use strafesnet_common::{map,model,integer,gameplay_attributes as attr};
 use strafesnet_deferred_loader::deferred_loader::{MeshDeferredLoader,RenderConfigDeferredLoader};
 use strafesnet_deferred_loader::mesh::Meshes;
 use strafesnet_deferred_loader::texture::{RenderConfigs,Texture};
+use strafesnet_common::gameplay_modes::{NormalizedMode,NormalizedModes,Mode,Stage};
 
 use crate::valve_transform;
 
@@ -41,7 +42,7 @@ fn add_brush<'a>(
 	model:&'a str,
 	origin:vbsp::Vector,
 	rendercolor:vbsp::Color,
-	attributes:gameplay_attributes::CollisionAttributesId,
+	attributes:attr::CollisionAttributesId,
 ){
 	let transform=integer::Planar64Affine3::from_translation(
 		valve_transform(origin.into())
@@ -52,9 +53,9 @@ fn add_brush<'a>(
 		rendercolor.b as f32
 	])/255.0).extend(1.0);
 
-	match model.split_at(1){
+	match model.chars().next(){
 		// The first character of brush.model is '*'
-		("*",id_str)=>match id_str.parse(){
+		Some('*')=>match model[1..].parse(){
 			Ok(mesh_id)=>{
 				let mesh=model::MeshId::new(mesh_id);
 				world_models.push(
@@ -82,29 +83,60 @@ pub fn convert<'a>(
 )->PartialMap1{
 	let bsp=bsp.as_ref();
 	//figure out real attributes later
-	let mut unique_attributes=Vec::new();
-	unique_attributes.push(gameplay_attributes::CollisionAttributes::Decoration);
-	unique_attributes.push(gameplay_attributes::CollisionAttributes::contact_default());
-	unique_attributes.push(gameplay_attributes::CollisionAttributes::intersect_default());
-	const ATTRIBUTE_DECORATION:gameplay_attributes::CollisionAttributesId=gameplay_attributes::CollisionAttributesId::new(0);
-	const ATTRIBUTE_CONTACT_DEFAULT:gameplay_attributes::CollisionAttributesId=gameplay_attributes::CollisionAttributesId::new(1);
-	const ATTRIBUTE_INTERSECT_DEFAULT:gameplay_attributes::CollisionAttributesId=gameplay_attributes::CollisionAttributesId::new(2);
+	let unique_attributes=vec![
+		attr::CollisionAttributes::Decoration,
+		attr::CollisionAttributes::contact_default(),
+		attr::CollisionAttributes::intersect_default(),
+		// ladder
+		attr::CollisionAttributes::Contact(
+			attr::ContactAttributes{
+				contacting:attr::ContactingAttributes{
+					contact_behaviour:Some(attr::ContactingBehaviour::Ladder(
+						attr::ContactingLadder{sticky:true}
+					))
+				},
+				general:attr::GeneralAttributes::default(),
+			}
+		),
+		// water
+		attr::CollisionAttributes::Intersect(
+			attr::IntersectAttributes{
+				intersecting:attr::IntersectingAttributes{
+					water:Some(attr::IntersectingWater{
+						viscosity:integer::Planar64::ONE,
+						density:integer::Planar64::ONE,
+						velocity:integer::vec3::ZERO,
+					}),
+				},
+				general:attr::GeneralAttributes::default(),
+			}
+		),
+	];
+	const ATTRIBUTE_DECORATION:attr::CollisionAttributesId=attr::CollisionAttributesId::new(0);
+	const ATTRIBUTE_CONTACT_DEFAULT:attr::CollisionAttributesId=attr::CollisionAttributesId::new(1);
+	const ATTRIBUTE_INTERSECT_DEFAULT:attr::CollisionAttributesId=attr::CollisionAttributesId::new(2);
+	const ATTRIBUTE_LADDER_DEFAULT:attr::CollisionAttributesId=attr::CollisionAttributesId::new(3);
+	const ATTRIBUTE_WATER_DEFAULT:attr::CollisionAttributesId=attr::CollisionAttributesId::new(4);
 
 	//declare all prop models to Loader
 	let mut prop_models=bsp.static_props().map(|prop|{
+		const DEG_TO_RAD:f32=std::f32::consts::TAU/360.0;
 		//get or create mesh_id
 		let mesh_id=mesh_deferred_loader.acquire_mesh_id(prop.model());
-		let placement=prop.as_prop_placement();
 		model::Model{
 			mesh:mesh_id,
 			attributes:ATTRIBUTE_DECORATION,
 			transform:integer::Planar64Affine3::new(
-				integer::mat3::try_from_f32_array_2d((
-					glam::Mat3A::from_diagonal(glam::Vec3::splat(placement.scale))
+				integer::mat3::try_from_f32_array_2d(
 					//TODO: figure this out
-					*glam::Mat3A::from_quat(glam::Quat::from_array(placement.rotation.into()))
-				).to_cols_array_2d()).unwrap(),
-				valve_transform(placement.origin.into()),
+					glam::Mat3A::from_euler(
+						glam::EulerRot::XYZ,
+						prop.angles.pitch*DEG_TO_RAD,
+						prop.angles.yaw*DEG_TO_RAD,
+						prop.angles.roll*DEG_TO_RAD
+					).to_cols_array_2d()
+				).unwrap(),
+				valve_transform(prop.origin.into()),
 			),
 			color:glam::Vec4::ONE,
 		}
@@ -181,7 +213,7 @@ pub fn convert<'a>(
 	for raw_ent in &bsp.entities{
 		match raw_ent.parse(){
 			Ok(Entity::Cycler(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin,brush.rendercolor,ATTRIBUTE_DECORATION),
-			Ok(Entity::EnvSprite(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin,brush.rendercolor.parse().unwrap_or(WHITE),ATTRIBUTE_DECORATION),
+			Ok(Entity::EnvSprite(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin,brush.rendercolor,ATTRIBUTE_DECORATION),
 			Ok(Entity::FuncBreakable(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin,brush.rendercolor,ATTRIBUTE_DECORATION),
 			Ok(Entity::FuncBrush(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin,brush.rendercolor,ATTRIBUTE_DECORATION),
 			Ok(Entity::FuncButton(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin,brush.rendercolor,ATTRIBUTE_DECORATION),
@@ -232,9 +264,27 @@ pub fn convert<'a>(
 
 	// physics models
 	for brush in &bsp.brushes{
-		if !brush.flags.contains(vbsp::BrushFlags::SOLID){
+		const RELEVANT:vbsp::BrushFlags=
+			vbsp::BrushFlags::SOLID
+			.union(vbsp::BrushFlags::PLAYERCLIP)
+			.union(vbsp::BrushFlags::WATER)
+			.union(vbsp::BrushFlags::MOVEABLE)
+			.union(vbsp::BrushFlags::LADDER);
+		if !brush.flags.intersects(RELEVANT){
 			continue;
 		}
+		let is_ladder=brush.flags.contains(vbsp::BrushFlags::LADDER);
+		let is_water=brush.flags.contains(vbsp::BrushFlags::WATER);
+		let attributes=match (is_ladder,is_water){
+			(true,false)=>ATTRIBUTE_LADDER_DEFAULT,
+			(false,true)=>ATTRIBUTE_WATER_DEFAULT,
+			(false,false)=>ATTRIBUTE_CONTACT_DEFAULT,
+			(true,true)=>{
+				// water ladder? wtf
+				println!("brush is a water ladder o_o defaulting to ladder");
+				ATTRIBUTE_LADDER_DEFAULT
+			}
+		};
 		let mesh_result=crate::brush::brush_to_mesh(bsp,brush);
 		match mesh_result{
 			Ok(mesh)=>{
@@ -242,7 +292,7 @@ pub fn convert<'a>(
 				world_meshes.push(mesh);
 				world_models.push(model::Model{
 					mesh:mesh_id,
-					attributes:ATTRIBUTE_CONTACT_DEFAULT,
+					attributes,
 					transform:integer::Planar64Affine3::new(
 						integer::mat3::identity(),
 						integer::vec3::ZERO,
@@ -268,15 +318,15 @@ pub fn convert<'a>(
 			color:glam::Vec4::W,
 		});
 
-		let first_stage=strafesnet_common::gameplay_modes::Stage::empty(model_id);
-		let main_mode=strafesnet_common::gameplay_modes::Mode::new(
+		let first_stage=Stage::empty(model_id);
+		let main_mode=Mode::new(
 			strafesnet_common::gameplay_style::StyleModifiers::source_bhop(),
 			model_id,
 			std::collections::HashMap::new(),
 			vec![first_stage],
 			std::collections::HashMap::new(),
 		);
-		modes_list.push(main_mode);
+		modes_list.push(NormalizedMode::new(main_mode));
 	}
 
 	PartialMap1{
@@ -284,17 +334,17 @@ pub fn convert<'a>(
 		world_meshes,
 		prop_models,
 		world_models,
-		modes:strafesnet_common::gameplay_modes::Modes::new(modes_list),
+		modes:NormalizedModes::new(modes_list),
 	}
 }
 
 //partially constructed map types
 pub struct PartialMap1{
-	attributes:Vec<strafesnet_common::gameplay_attributes::CollisionAttributes>,
+	attributes:Vec<attr::CollisionAttributes>,
 	prop_models:Vec<model::Model>,
 	world_meshes:Vec<model::Mesh>,
 	world_models:Vec<model::Model>,
-	modes:strafesnet_common::gameplay_modes::Modes,
+	modes:NormalizedModes,
 }
 impl PartialMap1{
 	pub fn add_prop_meshes<'a>(
@@ -312,12 +362,12 @@ impl PartialMap1{
 	}
 }
 pub struct PartialMap2{
-	attributes:Vec<strafesnet_common::gameplay_attributes::CollisionAttributes>,
+	attributes:Vec<attr::CollisionAttributes>,
 	prop_meshes:Vec<(model::MeshId,model::Mesh)>,
 	prop_models:Vec<model::Model>,
 	world_meshes:Vec<model::Mesh>,
 	world_models:Vec<model::Model>,
-	modes:strafesnet_common::gameplay_modes::Modes,
+	modes:NormalizedModes,
 }
 impl PartialMap2{
 	pub fn add_render_configs_and_textures(

lib/common/Cargo.toml

@@ -12,8 +12,8 @@ authors = ["Rhys Lloyd <krakow20@gmail.com>"]
 [dependencies]
 arrayvec = "0.7.4"
 bitflags = "2.6.0"
-fixed_wide = { version = "0.1.2", path = "../fixed_wide", registry = "strafesnet", features = ["deferred-division","zeroes","wide-mul"] }
-linear_ops = { version = "0.1.0", path = "../linear_ops", registry = "strafesnet", features = ["deferred-division","named-fields"] }
+fixed_wide = { version = "0.2.0", path = "../fixed_wide", registry = "strafesnet", features = ["deferred-division","zeroes","wide-mul"] }
+linear_ops = { version = "0.1.1", path = "../linear_ops", registry = "strafesnet", features = ["deferred-division","named-fields"] }
 ratio_ops = { version = "0.1.0", path = "../ratio_ops", registry = "strafesnet" }
 glam = "0.30.0"
 id = { version = "0.1.0", registry = "strafesnet" }

lib/common/src/aabb.rs

@@ -7,46 +7,57 @@ pub struct Aabb{
 }
 
 impl Default for Aabb{
+	#[inline]
 	fn default()->Self{
 		Self{min:vec3::MAX,max:vec3::MIN}
 	}
 }
 
 impl Aabb{
+	#[inline]
 	pub const fn new(min:Planar64Vec3,max:Planar64Vec3)->Self{
 		Self{min,max}
 	}
+	#[inline]
 	pub const fn max(&self)->Planar64Vec3{
 		self.max
 	}
+	#[inline]
 	pub const fn min(&self)->Planar64Vec3{
 		self.min
 	}
+	#[inline]
 	pub fn grow(&mut self,point:Planar64Vec3){
 		self.min=self.min.min(point);
 		self.max=self.max.max(point);
 	}
+	#[inline]
 	pub fn join(&mut self,aabb:&Aabb){
 		self.min=self.min.min(aabb.min);
 		self.max=self.max.max(aabb.max);
 	}
+	#[inline]
 	pub fn inflate(&mut self,hs:Planar64Vec3){
 		self.min-=hs;
 		self.max+=hs;
 	}
+	#[inline]
 	pub fn contains(&self,point:Planar64Vec3)->bool{
 		let bvec=self.min.lt(point)&point.lt(self.max);
 		bvec.all()
 	}
+	#[inline]
 	pub fn intersects(&self,aabb:&Aabb)->bool{
 		let bvec=self.min.lt(aabb.max)&aabb.min.lt(self.max);
 		bvec.all()
 	}
+	#[inline]
 	pub fn size(&self)->Planar64Vec3{
 		self.max-self.min
 	}
+	#[inline]
 	pub fn center(&self)->Planar64Vec3{
-		self.min+(self.max-self.min)>>1
+		self.min.map_zip(self.max,|(min,max)|min.midpoint(max))
 	}
 	//probably use floats for area & volume because we don't care about precision
 	// pub fn area_weight(&self)->f32{

lib/common/src/gameplay_modes.rs

@@ -1,7 +1,6 @@
 use std::collections::{HashSet,HashMap};
 use crate::model::ModelId;
 use crate::gameplay_style;
-use crate::updatable::Updatable;
 
 #[derive(Clone)]
 pub struct StageElement{
@@ -128,18 +127,6 @@ impl Stage{
 		self.unordered_checkpoints.contains(&model_id)
 	}
 }
-#[derive(Default)]
-pub struct StageUpdate{
-	//other behaviour models of this stage can have
-	ordered_checkpoints:HashMap<CheckpointId,ModelId>,
-	unordered_checkpoints:HashSet<ModelId>,
-}
-impl Updatable<StageUpdate> for Stage{
-	fn update(&mut self,update:StageUpdate){
-		self.ordered_checkpoints.extend(update.ordered_checkpoints);
-		self.unordered_checkpoints.extend(update.unordered_checkpoints);
-	}
-}
 
 #[derive(Clone,Copy,Hash,Eq,PartialEq)]
 pub enum Zone{
@@ -211,34 +198,47 @@ impl Mode{
 	pub fn push_stage(&mut self,stage:Stage){
 		self.stages.push(stage)
 	}
-	pub fn get_stage_mut(&mut self,stage:StageId)->Option<&mut Stage>{
-		self.stages.get_mut(stage.0 as usize)
+	pub fn get_stage_mut(&mut self,StageId(stage_id):StageId)->Option<&mut Stage>{
+		self.stages.get_mut(stage_id as usize)
 	}
-	pub fn get_spawn_model_id(&self,stage:StageId)->Option<ModelId>{
-		self.stages.get(stage.0 as usize).map(|s|s.spawn)
+	pub fn get_spawn_model_id(&self,StageId(stage_id):StageId)->Option<ModelId>{
+		self.stages.get(stage_id as usize).map(|s|s.spawn)
 	}
 	pub fn get_zone(&self,model_id:ModelId)->Option<&Zone>{
 		self.zones.get(&model_id)
 	}
-	pub fn get_stage(&self,stage_id:StageId)->Option<&Stage>{
-		self.stages.get(stage_id.0 as usize)
+	pub fn get_stage(&self,StageId(stage_id):StageId)->Option<&Stage>{
+		self.stages.get(stage_id as usize)
 	}
 	pub fn get_element(&self,model_id:ModelId)->Option<&StageElement>{
 		self.elements.get(&model_id)
 	}
+}
+
+#[derive(Clone)]
+pub struct NormalizedMode(Mode);
+impl NormalizedMode{
+	pub fn new(mode:Mode)->Self{
+		Self(mode)
+	}
+	pub fn into_inner(self)->Mode{
+		let Self(mode)=self;
+		mode
+	}
 	//TODO: put this in the SNF
-	pub fn denormalize_data(&mut self){
+	pub fn denormalize(self)->Mode{
+		let NormalizedMode(mut mode)=self;
 		//expand and index normalized data
-		self.zones.insert(self.start,Zone::Start);
-		for (stage_id,stage) in self.stages.iter().enumerate(){
-			self.elements.insert(stage.spawn,StageElement{
+		mode.zones.insert(mode.start,Zone::Start);
+		for (stage_id,stage) in mode.stages.iter().enumerate(){
+			mode.elements.insert(stage.spawn,StageElement{
 				stage_id:StageId(stage_id as u32),
 				force:false,
 				behaviour:StageElementBehaviour::SpawnAt,
 				jump_limit:None,
 			});
 			for (_,&model) in &stage.ordered_checkpoints{
-				self.elements.insert(model,StageElement{
+				mode.elements.insert(model,StageElement{
 					stage_id:StageId(stage_id as u32),
 					force:false,
 					behaviour:StageElementBehaviour::Checkpoint,
@@ -246,7 +246,7 @@ impl Mode{
 				});
 			}
 			for &model in &stage.unordered_checkpoints{
-				self.elements.insert(model,StageElement{
+				mode.elements.insert(model,StageElement{
 					stage_id:StageId(stage_id as u32),
 					force:false,
 					behaviour:StageElementBehaviour::Checkpoint,
@@ -254,53 +254,13 @@ impl Mode{
 				});
 			}
 		}
-	}
-}
-//this would be nice as a macro
-#[derive(Default)]
-pub struct ModeUpdate{
-	zones:HashMap<ModelId,Zone>,
-	stages:HashMap<StageId,StageUpdate>,
-	//mutually exlusive stage element behaviour
-	elements:HashMap<ModelId,StageElement>,
-}
-impl Updatable<ModeUpdate> for Mode{
-	fn update(&mut self,update:ModeUpdate){
-		self.zones.extend(update.zones);
-		for (stage,stage_update) in update.stages{
-			if let Some(stage)=self.stages.get_mut(stage.0 as usize){
-				stage.update(stage_update);
-			}
-		}
-		self.elements.extend(update.elements);
-	}
-}
-impl ModeUpdate{
-	pub fn zone(model_id:ModelId,zone:Zone)->Self{
-		let mut mu=Self::default();
-		mu.zones.insert(model_id,zone);
-		mu
-	}
-	pub fn stage(stage_id:StageId,stage_update:StageUpdate)->Self{
-		let mut mu=Self::default();
-		mu.stages.insert(stage_id,stage_update);
-		mu
-	}
-	pub fn element(model_id:ModelId,element:StageElement)->Self{
-		let mut mu=Self::default();
-		mu.elements.insert(model_id,element);
-		mu
-	}
-	pub fn map_stage_element_ids<F:Fn(StageId)->StageId>(&mut self,f:F){
-		for (_,stage_element) in self.elements.iter_mut(){
-			stage_element.stage_id=f(stage_element.stage_id);
-		}
+		mode
 	}
 }
 
 #[derive(Default,Clone)]
 pub struct Modes{
-	pub modes:Vec<Mode>,
+	modes:Vec<Mode>,
 }
 impl Modes{
 	pub const fn new(modes:Vec<Mode>)->Self{
@@ -314,19 +274,182 @@ impl Modes{
 	pub fn push_mode(&mut self,mode:Mode){
 		self.modes.push(mode)
 	}
-	pub fn get_mode(&self,mode:ModeId)->Option<&Mode>{
-		self.modes.get(mode.0 as usize)
+	pub fn get_mode(&self,ModeId(mode_id):ModeId)->Option<&Mode>{
+		self.modes.get(mode_id as usize)
 	}
 }
-pub struct ModesUpdate{
-	modes:HashMap<ModeId,ModeUpdate>,
+
+#[derive(Clone)]
+pub struct NormalizedModes{
+	modes:Vec<NormalizedMode>,
 }
-impl Updatable<ModesUpdate> for Modes{
-	fn update(&mut self,update:ModesUpdate){
-		for (mode,mode_update) in update.modes{
-			if let Some(mode)=self.modes.get_mut(mode.0 as usize){
-				mode.update(mode_update);
-			}
+impl NormalizedModes{
+	pub fn new(modes:Vec<NormalizedMode>)->Self{
+		Self{modes}
+	}
+	pub fn len(&self)->usize{
+		self.modes.len()
+	}
+	pub fn denormalize(self)->Modes{
+		Modes{
+			modes:self.modes.into_iter().map(NormalizedMode::denormalize).collect(),
 		}
 	}
 }
+impl IntoIterator for NormalizedModes{
+	type Item=<Vec<NormalizedMode> as IntoIterator>::Item;
+	type IntoIter=<Vec<NormalizedMode> as IntoIterator>::IntoIter;
+	fn into_iter(self)->Self::IntoIter{
+		self.modes.into_iter()
+	}
+}
+
+
+#[derive(Default)]
+pub struct StageUpdate{
+	//other behaviour models of this stage can have
+	ordered_checkpoints:HashMap<CheckpointId,ModelId>,
+	unordered_checkpoints:HashSet<ModelId>,
+}
+impl StageUpdate{
+	fn apply_to(self,stage:&mut Stage){
+		stage.ordered_checkpoints.extend(self.ordered_checkpoints);
+		stage.unordered_checkpoints.extend(self.unordered_checkpoints);
+	}
+}
+
+//this would be nice as a macro
+#[derive(Default)]
+pub struct ModeUpdate{
+	zones:Option<(ModelId,Zone)>,
+	stages:Option<(StageId,StageUpdate)>,
+	//mutually exlusive stage element behaviour
+	elements:Option<(ModelId,StageElement)>,
+}
+impl ModeUpdate{
+	fn apply_to(self,mode:&mut Mode){
+		mode.zones.extend(self.zones);
+		if let Some((StageId(stage_id),stage_update))=self.stages{
+			if let Some(stage)=mode.stages.get_mut(stage_id as usize){
+				stage_update.apply_to(stage);
+			}
+		}
+		mode.elements.extend(self.elements);
+	}
+}
+impl ModeUpdate{
+	pub fn zone(model_id:ModelId,zone:Zone)->Self{
+		Self{
+			zones:Some((model_id,zone)),
+			stages:None,
+			elements:None,
+		}
+	}
+	pub fn stage(stage_id:StageId,stage_update:StageUpdate)->Self{
+		Self{
+			zones:None,
+			stages:Some((stage_id,stage_update)),
+			elements:None,
+		}
+	}
+	pub fn element(model_id:ModelId,element:StageElement)->Self{
+		Self{
+			zones:None,
+			stages:None,
+			elements:Some((model_id,element)),
+		}
+	}
+	pub fn map_stage_element_ids<F:Fn(StageId)->StageId>(&mut self,f:F){
+		for (_,stage_element) in self.elements.iter_mut(){
+			stage_element.stage_id=f(stage_element.stage_id);
+		}
+	}
+}
+
+struct ModeBuilder{
+	mode:Mode,
+	stage_id_map:HashMap<StageId,StageId>,
+}
+#[derive(Default)]
+pub struct ModesBuilder{
+	modes:HashMap<ModeId,Mode>,
+	stages:HashMap<ModeId,HashMap<StageId,Stage>>,
+	mode_updates:Vec<(ModeId,ModeUpdate)>,
+	stage_updates:Vec<(ModeId,StageId,StageUpdate)>,
+}
+impl ModesBuilder{
+	pub fn build_normalized(mut self)->NormalizedModes{
+		//collect modes and stages into contiguous arrays
+		let mut unique_modes:Vec<(ModeId,Mode)>
+		=self.modes.into_iter().collect();
+		unique_modes.sort_by_key(|&(mode_id,_)|mode_id);
+		let (mut modes,mode_id_map):(Vec<ModeBuilder>,HashMap<ModeId,ModeId>)
+		=unique_modes.into_iter().enumerate()
+		.map(|(final_mode_id,(builder_mode_id,mut mode))|{
+			(
+				ModeBuilder{
+					stage_id_map:self.stages.remove(&builder_mode_id).map_or_else(||HashMap::new(),|stages|{
+						let mut unique_stages:Vec<(StageId,Stage)>
+						=stages.into_iter().collect();
+						unique_stages.sort_by_key(|&(StageId(stage_id),_)|stage_id);
+						unique_stages.into_iter().enumerate()
+						.map(|(final_stage_id,(builder_stage_id,stage))|{
+							mode.push_stage(stage);
+							(builder_stage_id,StageId::new(final_stage_id as u32))
+						}).collect()
+					}),
+					mode,
+				},
+				(
+					builder_mode_id,
+					ModeId::new(final_mode_id as u32)
+				)
+			)
+		}).unzip();
+		//TODO: failure messages or errors or something
+		//push stage updates
+		for (builder_mode_id,builder_stage_id,stage_update) in self.stage_updates{
+			if let Some(final_mode_id)=mode_id_map.get(&builder_mode_id){
+				if let Some(mode)=modes.get_mut(final_mode_id.get() as usize){
+					if let Some(&final_stage_id)=mode.stage_id_map.get(&builder_stage_id){
+						if let Some(stage)=mode.mode.get_stage_mut(final_stage_id){
+							stage_update.apply_to(stage);
+						}
+					}
+				}
+			}
+		}
+		//push mode updates
+		for (builder_mode_id,mut mode_update) in self.mode_updates{
+			if let Some(final_mode_id)=mode_id_map.get(&builder_mode_id){
+				if let Some(mode)=modes.get_mut(final_mode_id.get() as usize){
+					//map stage id on stage elements
+					mode_update.map_stage_element_ids(|stage_id|
+						//walk down one stage id at a time until a stage is found
+						//TODO use better logic like BTreeMap::upper_bound instead of walking
+						// final_stage_id_from_builder_stage_id.upper_bound(Bound::Included(&stage_id))
+						// .value().copied().unwrap_or(StageId::FIRST)
+						(0..=stage_id.get()).rev().find_map(|builder_stage_id|
+							//map the stage element to that stage
+							mode.stage_id_map.get(&StageId::new(builder_stage_id)).copied()
+						).unwrap_or(StageId::FIRST)
+					);
+					mode_update.apply_to(&mut mode.mode);
+				}
+			}
+		}
+		NormalizedModes::new(modes.into_iter().map(|mode_builder|NormalizedMode(mode_builder.mode)).collect())
+	}
+	pub fn insert_mode(&mut self,mode_id:ModeId,mode:Mode){
+		assert!(self.modes.insert(mode_id,mode).is_none(),"Cannot replace existing mode");
+	}
+	pub fn insert_stage(&mut self,mode_id:ModeId,stage_id:StageId,stage:Stage){
+		assert!(self.stages.entry(mode_id).or_insert(HashMap::new()).insert(stage_id,stage).is_none(),"Cannot replace existing stage");
+	}
+	pub fn push_mode_update(&mut self,mode_id:ModeId,mode_update:ModeUpdate){
+		self.mode_updates.push((mode_id,mode_update));
+	}
+	// fn push_stage_update(&mut self,mode_id:ModeId,stage_id:StageId,stage_update:StageUpdate){
+	// 	self.stage_updates.push((mode_id,stage_id,stage_update));
+	// }
+}

lib/common/src/gameplay_style.rs

@@ -63,22 +63,22 @@ impl JumpImpulse{
 		velocity:Planar64Vec3,
 		jump_dir:Planar64Vec3,
 		gravity:&Planar64Vec3,
-		mass:Planar64,
+		_mass:Planar64,
 	)->Planar64Vec3{
 		match self{
-			&JumpImpulse::Time(time)=>velocity-(*gravity*time).map(|t|t.divide().fix_1()),
+			&JumpImpulse::Time(time)=>velocity-(*gravity*time).map(|t|t.divide().clamp_1()),
 			&JumpImpulse::Height(height)=>{
 				//height==-v.y*v.y/(2*g.y);
 				//use energy to determine max height
 				let gg=gravity.length_squared();
-				let g=gg.sqrt().fix_1();
+				let g=gg.sqrt();
 				let v_g=gravity.dot(velocity);
 				//do it backwards
-				let radicand=v_g*v_g+(g*height*2).fix_4();
-				velocity-(*gravity*(radicand.sqrt().fix_2()+v_g)/gg).divide().fix_1()
+				let radicand=v_g*v_g+(g*height*2).widen_4();
+				velocity-(*gravity*(radicand.sqrt().wrap_2()+v_g)/gg).divide().clamp_1()
 			},
-			&JumpImpulse::Linear(jump_speed)=>velocity+(jump_dir*jump_speed/jump_dir.length()).divide().fix_1(),
-			&JumpImpulse::Energy(energy)=>{
+			&JumpImpulse::Linear(jump_speed)=>velocity+(jump_dir*jump_speed/jump_dir.length()).divide().clamp_1(),
+			&JumpImpulse::Energy(_energy)=>{
 				//calculate energy
 				//let e=gravity.dot(velocity);
 				//add
@@ -91,10 +91,10 @@ impl JumpImpulse{
 	pub fn get_jump_deltav(&self,gravity:&Planar64Vec3,mass:Planar64)->Planar64{
 		//gravity.length() is actually the proper calculation because the jump is always opposite the gravity direction
 		match self{
-			&JumpImpulse::Time(time)=>(gravity.length().fix_1()*time/2).divide().fix_1(),
-			&JumpImpulse::Height(height)=>(gravity.length()*height*2).sqrt().fix_1(),
+			&JumpImpulse::Time(time)=>(gravity.length().wrap_1()*time/2).divide().clamp_1(),
+			&JumpImpulse::Height(height)=>(gravity.length()*height*2).sqrt().wrap_1(),
 			&JumpImpulse::Linear(deltav)=>deltav,
-			&JumpImpulse::Energy(energy)=>(energy.sqrt()*2/mass.sqrt()).divide().fix_1(),
+			&JumpImpulse::Energy(energy)=>(energy.sqrt()*2/mass.sqrt()).divide().clamp_1(),
 		}
 	}
 }
@@ -126,10 +126,10 @@ impl JumpSettings{
 					None=>rel_velocity,
 				};
 				let j=boost_vel.dot(jump_dir);
-				let js=jump_speed.fix_2();
+				let js=jump_speed.widen_2();
 				if j<js{
 					//weak booster: just do a regular jump
-					boost_vel+jump_dir.with_length(js-j).divide().fix_1()
+					boost_vel+jump_dir.with_length(js-j).divide().wrap_1()
 				}else{
 					//activate booster normally, jump does nothing
 					boost_vel
@@ -142,13 +142,13 @@ impl JumpSettings{
 					None=>rel_velocity,
 				};
 				let j=boost_vel.dot(jump_dir);
-				let js=jump_speed.fix_2();
+				let js=jump_speed.widen_2();
 				if j<js{
 					//speed in direction of jump cannot be lower than amount
-					boost_vel+jump_dir.with_length(js-j).divide().fix_1()
+					boost_vel+jump_dir.with_length(js-j).divide().wrap_1()
 				}else{
 					//boost and jump add together
-					boost_vel+jump_dir.with_length(js).divide().fix_1()
+					boost_vel+jump_dir.with_length(js).divide().wrap_1()
 				}
 			}
 			(false,JumpCalculation::Max)=>{
@@ -159,10 +159,10 @@ impl JumpSettings{
 					None=>rel_velocity,
 				};
 				let boost_dot=boost_vel.dot(jump_dir);
-				let js=jump_speed.fix_2();
+				let js=jump_speed.widen_2();
 				if boost_dot<js{
 					//weak boost is extended to jump speed
-					boost_vel+jump_dir.with_length(js-boost_dot).divide().fix_1()
+					boost_vel+jump_dir.with_length(js-boost_dot).divide().wrap_1()
 				}else{
 					//activate booster normally, jump does nothing
 					boost_vel
@@ -174,7 +174,7 @@ impl JumpSettings{
 					Some(booster)=>booster.boost(rel_velocity),
 					None=>rel_velocity,
 				};
-				boost_vel+jump_dir.with_length(jump_speed).divide().fix_1()
+				boost_vel+jump_dir.with_length(jump_speed).divide().wrap_1()
 			},
 		}
 	}
@@ -267,9 +267,9 @@ pub struct StrafeSettings{
 impl StrafeSettings{
 	pub fn tick_velocity(&self,velocity:Planar64Vec3,control_dir:Planar64Vec3)->Option<Planar64Vec3>{
 		let d=velocity.dot(control_dir);
-		let mv=self.mv.fix_2();
+		let mv=self.mv.widen_2();
 		match d<mv{
-			true=>Some(velocity+(control_dir*self.air_accel_limit.map_or(mv-d,|limit|limit.fix_2().min(mv-d))).fix_1()),
+			true=>Some(velocity+(control_dir*self.air_accel_limit.map_or(mv-d,|limit|limit.widen_2().min(mv-d))).wrap_1()),
 			false=>None,
 		}
 	}
@@ -290,7 +290,7 @@ pub struct PropulsionSettings{
 }
 impl PropulsionSettings{
 	pub fn acceleration(&self,control_dir:Planar64Vec3)->Planar64Vec3{
-		(control_dir*self.magnitude).fix_1()
+		(control_dir*self.magnitude).clamp_1()
 	}
 }
 
@@ -310,13 +310,13 @@ pub struct WalkSettings{
 impl WalkSettings{
 	pub fn accel(&self,target_diff:Planar64Vec3,gravity:Planar64Vec3)->Planar64{
 		//TODO: fallible walk accel
-		let diff_len=target_diff.length().fix_1();
+		let diff_len=target_diff.length().wrap_1();
 		let friction=if diff_len<self.accelerate.topspeed{
 			self.static_friction
 		}else{
 			self.kinetic_friction
 		};
-		self.accelerate.accel.min((-gravity.y*friction).fix_1())
+		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{
@@ -332,7 +332,7 @@ impl WalkSettings{
 			if cr==crate::integer::vec3::ZERO_2{
 				crate::integer::vec3::ZERO
 			}else{
-				(cr.cross(normal)*self.accelerate.topspeed/((nn*(nnmm-dd)).sqrt())).divide().fix_1()
+				(cr.cross(normal)*self.accelerate.topspeed/((nn*(nnmm-dd)).sqrt())).divide().clamp_1()
 			}
 		}else{
 			crate::integer::vec3::ZERO
@@ -341,7 +341,7 @@ impl WalkSettings{
 	pub fn is_slope_walkable(&self,normal:Planar64Vec3,up:Planar64Vec3)->bool{
 		//normal is not guaranteed to be unit length
 		let ny=normal.dot(up);
-		let h=normal.length().fix_1();
+		let h=normal.length().wrap_1();
 		//remember this is a normal vector
 		ny.is_positive()&&h*self.surf_dot<ny
 	}
@@ -355,7 +355,7 @@ pub struct LadderSettings{
 	pub dot:Planar64,
 }
 impl LadderSettings{
-	pub const fn accel(&self,target_diff:Planar64Vec3,gravity:Planar64Vec3)->Planar64{
+	pub const fn accel(&self,_target_diff:Planar64Vec3,_gravity:Planar64Vec3)->Planar64{
 		//TODO: fallible ladder accel
 		self.accelerate.accel
 	}
@@ -368,13 +368,13 @@ impl LadderSettings{
 		let nnmm=nn*mm;
 		let d=normal.dot(control_dir);
 		let mut dd=d*d;
-		if (self.dot*self.dot*nnmm).fix_4()<dd{
+		if (self.dot*self.dot*nnmm).clamp_4()<dd{
 			if d.is_negative(){
-				control_dir=Planar64Vec3::new([Planar64::ZERO,mm.fix_1(),Planar64::ZERO]);
+				control_dir=Planar64Vec3::new([Planar64::ZERO,mm.clamp_1(),Planar64::ZERO]);
 			}else{
-				control_dir=Planar64Vec3::new([Planar64::ZERO,-mm.fix_1(),Planar64::ZERO]);
+				control_dir=Planar64Vec3::new([Planar64::ZERO,-mm.clamp_1(),Planar64::ZERO]);
 			}
-			dd=(normal.y*normal.y).fix_4();
+			dd=(normal.y*normal.y).widen_4();
 		}
 		//n=d if you are standing on top of a ladder and press E.
 		//two fixes:
@@ -385,7 +385,7 @@ impl LadderSettings{
 			if cr==crate::integer::vec3::ZERO_2{
 				crate::integer::vec3::ZERO
 			}else{
-				(cr.cross(normal)*self.accelerate.topspeed/((nn*(nnmm-dd)).sqrt())).divide().fix_1()
+				(cr.cross(normal)*self.accelerate.topspeed/((nn*(nnmm-dd)).sqrt())).divide().clamp_1()
 			}
 		}else{
 			crate::integer::vec3::ZERO
@@ -417,7 +417,7 @@ impl Hitbox{
 	}
 	pub fn source()->Self{
 		Self{
-			halfsize:((int3(33,73,33)>>1)*VALVE_SCALE).fix_1(),
+			halfsize:((int3(33,73,33)>>1)*VALVE_SCALE).narrow_1().unwrap(),
 			mesh:HitboxMesh::Box,
 		}
 	}
@@ -529,20 +529,20 @@ impl StyleModifiers{
 
 	pub fn source_bhop()->Self{
 		Self{
-			controls_mask:Controls::all()-Controls::MoveUp-Controls::MoveDown,
+			controls_mask:Controls::all(),
 			controls_mask_state:Controls::all(),
 			strafe:Some(StrafeSettings{
 				enable:ControlsActivation::full_2d(),
-				air_accel_limit:Some(Planar64::raw(150<<28)*100),
-				mv:(Planar64::raw(30)*VALVE_SCALE).fix_1(),
+				air_accel_limit:Some(Planar64::raw((150<<28)*100)),
+				mv:Planar64::raw(30<<28),
 				tick_rate:Ratio64::new(100,AbsoluteTime::ONE_SECOND.get() as u64).unwrap(),
 			}),
 			jump:Some(JumpSettings{
-				impulse:JumpImpulse::Height((int(52)*VALVE_SCALE).fix_1()),
+				impulse:JumpImpulse::Height((int(52)*VALVE_SCALE).narrow_1().unwrap()),
 				calculation:JumpCalculation::JumpThenBoost,
 				limit_minimum:true,
 			}),
-			gravity:(int3(0,-800,0)*VALVE_SCALE).fix_1(),
+			gravity:(int3(0,-800,0)*VALVE_SCALE).narrow_1().unwrap(),
 			mass:int(1),
 			rocket:None,
 			walk:Some(WalkSettings{
@@ -565,25 +565,25 @@ impl StyleModifiers{
 				magnitude:int(12),//?
 			}),
 			hitbox:Hitbox::source(),
-			camera_offset:((int3(0,64,0)-(int3(0,73,0)>>1))*VALVE_SCALE).fix_1(),
+			camera_offset:((int3(0,64,0)-(int3(0,73,0)>>1))*VALVE_SCALE).narrow_1().unwrap(),
 		}
 	}
 	pub fn source_surf()->Self{
 		Self{
-			controls_mask:Controls::all()-Controls::MoveUp-Controls::MoveDown,
+			controls_mask:Controls::all(),
 			controls_mask_state:Controls::all(),
 			strafe:Some(StrafeSettings{
 				enable:ControlsActivation::full_2d(),
-				air_accel_limit:Some((int(150)*66*VALVE_SCALE).fix_1()),
-				mv:(int(30)*VALVE_SCALE).fix_1(),
+				air_accel_limit:Some((int(150)*66*VALVE_SCALE).narrow_1().unwrap()),
+				mv:Planar64::raw(30<<28),
 				tick_rate:Ratio64::new(66,AbsoluteTime::ONE_SECOND.get() as u64).unwrap(),
 			}),
 			jump:Some(JumpSettings{
-				impulse:JumpImpulse::Height((int(52)*VALVE_SCALE).fix_1()),
+				impulse:JumpImpulse::Height((int(52)*VALVE_SCALE).narrow_1().unwrap()),
 				calculation:JumpCalculation::JumpThenBoost,
 				limit_minimum:true,
 			}),
-			gravity:(int3(0,-800,0)*VALVE_SCALE).fix_1(),
+			gravity:(int3(0,-800,0)*VALVE_SCALE).narrow_1().unwrap(),
 			mass:int(1),
 			rocket:None,
 			walk:Some(WalkSettings{
@@ -606,7 +606,7 @@ impl StyleModifiers{
 				magnitude:int(12),//?
 			}),
 			hitbox:Hitbox::source(),
-			camera_offset:((int3(0,64,0)-(int3(0,73,0)>>1))*VALVE_SCALE).fix_1(),
+			camera_offset:((int3(0,64,0)-(int3(0,73,0)>>1))*VALVE_SCALE).narrow_1().unwrap(),
 		}
 	}
 }

lib/common/src/integer.rs

@@ -1,4 +1,4 @@
-pub use fixed_wide::fixed::{Fixed,Fix};
+pub use fixed_wide::fixed::*;
 pub use ratio_ops::ratio::{Ratio,Divide};
 
 //integer units
@@ -60,7 +60,7 @@ impl<T> Time<T>{
 impl<T> From<Planar64> for Time<T>{
 	#[inline]
 	fn from(value:Planar64)->Self{
-		Self::raw((value*Planar64::raw(1_000_000_000)).fix_1().to_raw())
+		Self::raw((value*Planar64::raw(1_000_000_000)).clamp_1().to_raw())
 	}
 }
 impl<T> From<Time<T>> for Ratio<Planar64,Planar64>{
@@ -73,11 +73,11 @@ impl<T,Num,Den,N1,T1> From<Ratio<Num,Den>> for Time<T>
 	where
 		Num:core::ops::Mul<Planar64,Output=N1>,
 		N1:Divide<Den,Output=T1>,
-		T1:Fix<Planar64>,
+		T1:Clamp<Planar64>,
 {
 	#[inline]
 	fn from(value:Ratio<Num,Den>)->Self{
-		Self::raw((value*Planar64::raw(1_000_000_000)).divide().fix().to_raw())
+		Self::raw((value*Planar64::raw(1_000_000_000)).divide().clamp().to_raw())
 	}
 }
 impl<T> std::fmt::Display for Time<T>{
@@ -515,8 +515,8 @@ fn angle_sin_cos(){
 		println!("cordic s={} c={}",(s/h).divide(),(c/h).divide());
 		let (fs,fc)=f.sin_cos();
 		println!("float s={} c={}",fs,fc);
-		assert!(close_enough((c/h).divide().fix_1(),Planar64::raw((fc*((1u64<<32) as f64)) as i64)));
-		assert!(close_enough((s/h).divide().fix_1(),Planar64::raw((fs*((1u64<<32) as f64)) as i64)));
+		assert!(close_enough((c/h).divide().wrap_1(),Planar64::raw((fc*((1u64<<32) as f64)) as i64)));
+		assert!(close_enough((s/h).divide().wrap_1(),Planar64::raw((fs*((1u64<<32) as f64)) as i64)));
 	}
 	test_angle(1.0);
 	test_angle(std::f64::consts::PI/4.0);
@@ -625,8 +625,8 @@ pub mod mat3{
 		let (yc,ys)=y.cos_sin();
 		Planar64Mat3::from_cols([
 			Planar64Vec3::new([xc,Planar64::ZERO,-xs]),
-			Planar64Vec3::new([(xs*ys).fix_1(),yc,(xc*ys).fix_1()]),
-			Planar64Vec3::new([(xs*yc).fix_1(),-ys,(xc*yc).fix_1()]),
+			Planar64Vec3::new([(xs*ys).wrap_1(),yc,(xc*ys).wrap_1()]),
+			Planar64Vec3::new([(xs*yc).wrap_1(),-ys,(xc*yc).wrap_1()]),
 		])
 	}
 	#[inline]
@@ -648,7 +648,7 @@ pub mod mat3{
 	}
 }
 
-#[derive(Clone,Copy,Default,Hash,Eq,PartialEq)]
+#[derive(Clone,Copy,Debug,Default,Hash,Eq,PartialEq)]
 pub struct Planar64Affine3{
 	pub matrix3:Planar64Mat3,//includes scale above 1
 	pub translation:Planar64Vec3,
@@ -668,7 +668,7 @@ impl Planar64Affine3{
 	}
 	#[inline]
 	pub fn transform_point3(&self,point:Planar64Vec3)->vec3::Vector3<Fixed<2,64>>{
-		self.translation.fix_2()+self.matrix3*point
+		self.translation.widen_2()+self.matrix3*point
 	}
 }
 impl Into<glam::Mat4> for Planar64Affine3{

lib/common/src/lib.rs

@@ -9,7 +9,6 @@ pub mod timer;
 pub mod integer;
 pub mod physics;
 pub mod session;
-pub mod updatable;
 pub mod instruction;
 pub mod gameplay_attributes;
 pub mod gameplay_modes;

lib/common/src/map.rs

@@ -4,7 +4,7 @@ use crate::gameplay_attributes;
 //this is a temporary struct to try to get the code running again
 //TODO: use snf::map::Region to update the data in physics and graphics instead of this
 pub struct CompleteMap{
-	pub modes:gameplay_modes::Modes,
+	pub modes:gameplay_modes::NormalizedModes,
 	pub attributes:Vec<gameplay_attributes::CollisionAttributes>,
 	pub meshes:Vec<model::Mesh>,
 	pub models:Vec<model::Model>,

lib/common/src/ray.rs

@@ -13,8 +13,8 @@ impl Ray{
 		Num:core::ops::Mul<Planar64,Output=N1>,
 		Planar64:core::ops::Mul<Den,Output=N1>,
 		N1:integer::Divide<Den,Output=T1>,
-		T1:integer::Fix<Planar64>,
+		T1:integer::Clamp<Planar64>,
 	{
-		self.origin+self.direction.map(|elem|(t*elem).divide().fix())
+		self.origin+self.direction.map(|elem|(t*elem).divide().clamp())
 	}
 }

lib/common/src/updatable.rs

@@ -1,57 +0,0 @@
-// This whole thing should be a drive macro
-
-pub trait Updatable<Updater>{
-	fn update(&mut self,update:Updater);
-}
-#[derive(Clone,Copy,Hash,Eq,PartialEq)]
-struct InnerId(u32);
-#[derive(Clone)]
-struct Inner{
-	id:InnerId,
-	enabled:bool,
-}
-#[derive(Clone,Copy,Hash,Eq,PartialEq)]
-struct OuterId(u32);
-struct Outer{
-	id:OuterId,
-	inners:std::collections::HashMap<InnerId,Inner>,
-}
-
-enum Update<I,U>{
-	Insert(I),
-	Update(U),
-	Remove
-}
-
-struct InnerUpdate{
-	//#[updatable(Update)]
-	enabled:Option<bool>,
-}
-struct OuterUpdate{
-	//#[updatable(Insert,Update,Remove)]
-	inners:std::collections::HashMap<InnerId,Update<Inner,InnerUpdate>>,
-	//#[updatable(Update)]
-	//inners:std::collections::HashMap<InnerId,InnerUpdate>,
-}
-impl Updatable<InnerUpdate> for Inner{
-	fn update(&mut self,update:InnerUpdate){
-		if let Some(enabled)=update.enabled{
-			self.enabled=enabled;
-		}
-	}
-}
-impl Updatable<OuterUpdate> for Outer{
-	fn update(&mut self,update:OuterUpdate){
-		for (id,up) in update.inners{
-			match up{
-				Update::Insert(new_inner)=>self.inners.insert(id,new_inner),
-				Update::Update(inner_update)=>self.inners.get_mut(&id).map(|inner|{
-					let old=inner.clone();
-					inner.update(inner_update);
-					old
-				}),
-				Update::Remove=>self.inners.remove(&id),
-			};
-		}
-	}
-}

lib/fixed_wide/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "fixed_wide"
-version = "0.1.2"
+version = "0.2.0"
 edition = "2024"
 repository = "https://git.itzana.me/StrafesNET/strafe-project"
 license = "MIT OR Apache-2.0"
@@ -14,7 +14,7 @@ wide-mul=[]
 zeroes=["dep:arrayvec"]
 
 [dependencies]
-bnum = "0.12.0"
+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 }

lib/fixed_wide/src/fixed.rs

@@ -33,6 +33,14 @@ impl<const N:usize,const F:usize> Fixed<N,F>{
 		self.bits
 	}
 	#[inline]
+	pub const fn as_bits(&self)->&BInt<N>{
+		&self.bits
+	}
+	#[inline]
+	pub const fn as_bits_mut(&mut self)->&mut BInt<N>{
+		&mut self.bits
+	}
+	#[inline]
 	pub const fn raw_digit(value:i64)->Self{
 		let mut digits=[0u64;N];
 		digits[0]=value.abs() as u64;
@@ -56,6 +64,10 @@ impl<const N:usize,const F:usize> Fixed<N,F>{
 	pub const fn abs(self)->Self{
 		Self::from_bits(self.bits.abs())
 	}
+	#[inline]
+	pub const fn midpoint(self,other:Self)->Self{
+		Self::from_bits(self.bits.midpoint(other.bits))
+	}
 }
 impl<const F:usize> Fixed<1,F>{
 	/// My old code called this function everywhere so let's provide it
@@ -651,74 +663,94 @@ macro_repeated!(
 	1,2,3,4,5,6,7,8
 );
 
-pub trait Fix<Out>{
-	fn fix(self)->Out;
+#[derive(Debug,Eq,PartialEq)]
+pub enum NarrowError{
+	Overflow,
+	Underflow,
 }
 
-macro_rules! impl_fix_rhs_lt_lhs_not_const_generic{
+pub trait Wrap<Output>{
+	fn wrap(self)->Output;
+}
+pub trait Clamp<Output>{
+	fn clamp(self)->Output;
+}
+impl<const N:usize,const F:usize> Clamp<Fixed<N,F>> for Result<Fixed<N,F>,NarrowError>{
+	fn clamp(self)->Fixed<N,F>{
+		match self{
+			Ok(fixed)=>fixed,
+			Err(NarrowError::Overflow)=>Fixed::MAX,
+			Err(NarrowError::Underflow)=>Fixed::MIN,
+		}
+	}
+}
+
+macro_rules! impl_narrow_not_const_generic{
 	(
 		(),
 		($lhs:expr,$rhs:expr)
 	)=>{
-		impl Fixed<$lhs,{$lhs*32}>
-		{
-			paste::item!{
+		paste::item!{
+			impl Fixed<$lhs,{$lhs*32}>
+			{
 				#[inline]
-				pub fn [<fix_ $rhs>](self)->Fixed<$rhs,{$rhs*32}>{
+				pub fn [<wrap_ $rhs>](self)->Fixed<$rhs,{$rhs*32}>{
 					Fixed::from_bits(bnum::cast::As::as_::<BInt::<$rhs>>(self.bits.shr(($lhs-$rhs)*32)))
 				}
+				#[inline]
+				pub fn [<narrow_ $rhs>](self)->Result<Fixed<$rhs,{$rhs*32}>,NarrowError>{
+					if Fixed::<$rhs,{$rhs*32}>::MAX.[<widen_ $lhs>]().bits<self.bits{
+						return Err(NarrowError::Overflow);
+					}
+					if self.bits<Fixed::<$rhs,{$rhs*32}>::MIN.[<widen_ $lhs>]().bits{
+						return Err(NarrowError::Underflow);
+					}
+					Ok(self.[<wrap_ $rhs>]())
+				}
+				#[inline]
+				pub fn [<clamp_ $rhs>](self)->Fixed<$rhs,{$rhs*32}>{
+					self.[<narrow_ $rhs>]().clamp()
+				}
 			}
-		}
-		impl Fix<Fixed<$rhs,{$rhs*32}>> for Fixed<$lhs,{$lhs*32}>{
-			fn fix(self)->Fixed<$rhs,{$rhs*32}>{
-				paste::item!{
-				self.[<fix_ $rhs>]()
+			impl Wrap<Fixed<$rhs,{$rhs*32}>> for Fixed<$lhs,{$lhs*32}>{
+				#[inline]
+				fn wrap(self)->Fixed<$rhs,{$rhs*32}>{
+					self.[<wrap_ $rhs>]()
+				}
+			}
+			impl TryInto<Fixed<$rhs,{$rhs*32}>> for Fixed<$lhs,{$lhs*32}>{
+				type Error=NarrowError;
+				#[inline]
+				fn try_into(self)->Result<Fixed<$rhs,{$rhs*32}>,Self::Error>{
+					self.[<narrow_ $rhs>]()
+				}
+			}
+			impl Clamp<Fixed<$rhs,{$rhs*32}>> for Fixed<$lhs,{$lhs*32}>{
+				#[inline]
+				fn clamp(self)->Fixed<$rhs,{$rhs*32}>{
+					self.[<clamp_ $rhs>]()
 				}
 			}
 		}
 	}
 }
-macro_rules! impl_fix_lhs_lt_rhs_not_const_generic{
+macro_rules! impl_widen_not_const_generic{
 	(
 		(),
 		($lhs:expr,$rhs:expr)
 	)=>{
-		impl Fixed<$lhs,{$lhs*32}>
-		{
-			paste::item!{
+		paste::item!{
+			impl Fixed<$lhs,{$lhs*32}>
+			{
 				#[inline]
-				pub fn [<fix_ $rhs>](self)->Fixed<$rhs,{$rhs*32}>{
+				pub fn [<widen_ $rhs>](self)->Fixed<$rhs,{$rhs*32}>{
 					Fixed::from_bits(bnum::cast::As::as_::<BInt::<$rhs>>(self.bits).shl(($rhs-$lhs)*32))
 				}
 			}
-		}
-		impl Fix<Fixed<$rhs,{$rhs*32}>> for Fixed<$lhs,{$lhs*32}>{
-			fn fix(self)->Fixed<$rhs,{$rhs*32}>{
-				paste::item!{
-				self.[<fix_ $rhs>]()
-				}
-			}
-		}
-	}
-}
-macro_rules! impl_fix_lhs_eq_rhs_not_const_generic{
-	(
-		(),
-		($lhs:expr,$rhs:expr)
-	)=>{
-		impl Fixed<$lhs,{$lhs*32}>
-		{
-			paste::item!{
+			impl Into<Fixed<$rhs,{$rhs*32}>> for Fixed<$lhs,{$lhs*32}>{
 				#[inline]
-				pub fn [<fix_ $rhs>](self)->Fixed<$rhs,{$rhs*32}>{
-					self
-				}
-			}
-		}
-		impl Fix<Fixed<$rhs,{$rhs*32}>> for Fixed<$lhs,{$lhs*32}>{
-			fn fix(self)->Fixed<$rhs,{$rhs*32}>{
-				paste::item!{
-				self.[<fix_ $rhs>]()
+				fn into(self)->Fixed<$rhs,{$rhs*32}>{
+					self.[<widen_ $rhs>]()
 				}
 			}
 		}
@@ -728,7 +760,7 @@ macro_rules! impl_fix_lhs_eq_rhs_not_const_generic{
 // I LOVE NOT BEING ABLE TO USE CONST GENERICS
 
 macro_repeated!(
-	impl_fix_rhs_lt_lhs_not_const_generic,(),
+	impl_narrow_not_const_generic,(),
 	(2,1),(3,1),(4,1),(5,1),(6,1),(7,1),(8,1),(9,1),(10,1),(11,1),(12,1),(13,1),(14,1),(15,1),(16,1),(17,1),
 	(3,2),(4,2),(5,2),(6,2),(7,2),(8,2),(9,2),(10,2),(11,2),(12,2),(13,2),(14,2),(15,2),(16,2),
 	(4,3),(5,3),(6,3),(7,3),(8,3),(9,3),(10,3),(11,3),(12,3),(13,3),(14,3),(15,3),(16,3),
@@ -746,7 +778,7 @@ macro_repeated!(
 	(16,15)
 );
 macro_repeated!(
-	impl_fix_lhs_lt_rhs_not_const_generic,(),
+	impl_widen_not_const_generic,(),
 	(1,2),
 	(1,3),(2,3),
 	(1,4),(2,4),(3,4),
@@ -761,11 +793,8 @@ macro_repeated!(
 	(1,13),(2,13),(3,13),(4,13),(5,13),(6,13),(7,13),(8,13),(9,13),(10,13),(11,13),(12,13),
 	(1,14),(2,14),(3,14),(4,14),(5,14),(6,14),(7,14),(8,14),(9,14),(10,14),(11,14),(12,14),(13,14),
 	(1,15),(2,15),(3,15),(4,15),(5,15),(6,15),(7,15),(8,15),(9,15),(10,15),(11,15),(12,15),(13,15),(14,15),
-	(1,16),(2,16),(3,16),(4,16),(5,16),(6,16),(7,16),(8,16),(9,16),(10,16),(11,16),(12,16),(13,16),(14,16),(15,16)
-);
-macro_repeated!(
-	impl_fix_lhs_eq_rhs_not_const_generic,(),
-	(1,1),(2,2),(3,3),(4,4),(5,5),(6,6),(7,7),(8,8),(9,9),(10,10),(11,11),(12,12),(13,13),(14,14),(15,15),(16,16)
+	(1,16),(2,16),(3,16),(4,16),(5,16),(6,16),(7,16),(8,16),(9,16),(10,16),(11,16),(12,16),(13,16),(14,16),(15,16),
+	(1,17)
 );
 
 macro_rules! impl_not_const_generic{
@@ -785,16 +814,13 @@ macro_rules! impl_not_const_generic{
 				let mut result=Self::ZERO;
 
 				//resize self to match the wide mul output
-				let wide_self=self.[<fix_ $_2n>]();
+				let wide_self=self.[<widen_ $_2n>]();
 				//descend down the bits and check if flipping each bit would push the square over the input value
 				for shift in (0..=max_shift).rev(){
-					let new_result={
-						let mut bits=result.to_bits().to_bits();
-						bits.set_bit(shift,true);
-						Self::from_bits(BInt::from_bits(bits))
-					};
-					if new_result.[<wide_mul_ $n _ $n>](new_result)<=wide_self{
-						result=new_result;
+					result.as_bits_mut().as_bits_mut().set_bit(shift,true);
+					if wide_self<result.[<wide_mul_ $n _ $n>](result){
+						// put it back lol
+						result.as_bits_mut().as_bits_mut().set_bit(shift,false);
 					}
 				}
 				result

lib/fixed_wide/src/tests.rs

@@ -61,7 +61,7 @@ fn from_f32(){
 	let b:Result<I32F32,_>=Into::<f32>::into(I32F32::MIN).try_into();
 	assert_eq!(b,Err(crate::fixed::FixedFromFloatError::Overflow));
 	//16 is within the 24 bits of float precision
-	let b:Result<I32F32,_>=Into::<f32>::into(-I32F32::MIN.fix_2()).try_into();
+	let b:Result<I32F32,_>=Into::<f32>::into(-I32F32::MIN.widen_2()).try_into();
 	assert_eq!(b,Err(crate::fixed::FixedFromFloatError::Overflow));
 	let b:Result<I32F32,_>=f32::MIN_POSITIVE.try_into();
 	assert_eq!(b,Err(crate::fixed::FixedFromFloatError::Underflow));
@@ -136,11 +136,24 @@ fn test_bint(){
 }
 
 #[test]
-fn test_fix(){
-	assert_eq!(I32F32::ONE.fix_8(),I256F256::ONE);
-	assert_eq!(I32F32::ONE,I256F256::ONE.fix_1());
-	assert_eq!(I32F32::NEG_ONE.fix_8(),I256F256::NEG_ONE);
-	assert_eq!(I32F32::NEG_ONE,I256F256::NEG_ONE.fix_1());
+fn test_wrap(){
+	assert_eq!(I32F32::ONE,I256F256::ONE.wrap_1());
+	assert_eq!(I32F32::NEG_ONE,I256F256::NEG_ONE.wrap_1());
+}
+#[test]
+fn test_narrow(){
+	assert_eq!(Ok(I32F32::ONE),I256F256::ONE.narrow_1());
+	assert_eq!(Ok(I32F32::NEG_ONE),I256F256::NEG_ONE.narrow_1());
+}
+#[test]
+fn test_widen(){
+	assert_eq!(I32F32::ONE.widen_8(),I256F256::ONE);
+	assert_eq!(I32F32::NEG_ONE.widen_8(),I256F256::NEG_ONE);
+}
+#[test]
+fn test_clamp(){
+	assert_eq!(I32F32::ONE,I256F256::ONE.clamp_1());
+	assert_eq!(I32F32::NEG_ONE,I256F256::NEG_ONE.clamp_1());
 }
 #[test]
 fn test_sqrt(){

lib/fixed_wide/src/zeroes.rs

@@ -15,8 +15,10 @@ macro_rules! impl_zeroes{
 				let radicand=a1*a1-a2*a0*4;
 				match radicand.cmp(&<Self as core::ops::Mul>::Output::ZERO){
 					Ordering::Greater=>{
+						// using wrap because sqrt always halves the number of leading digits.
+						// clamp would be more defensive, but is slower.
 						paste::item!{
-						let planar_radicand=radicand.sqrt().[<fix_ $n>]();
+						let planar_radicand=radicand.sqrt().[<wrap_ $n>]();
 						}
 						//sort roots ascending and avoid taking the difference of large numbers
 						let zeroes=match (a2pos,Self::ZERO<a1){

lib/linear_ops/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "linear_ops"
-version = "0.1.0"
+version = "0.1.1"
 edition = "2024"
 repository = "https://git.itzana.me/StrafesNET/strafe-project"
 license = "MIT OR Apache-2.0"
@@ -15,7 +15,7 @@ deferred-division=["dep:ratio_ops"]
 
 [dependencies]
 ratio_ops = { version = "0.1.0", path = "../ratio_ops", registry = "strafesnet", optional = true }
-fixed_wide = { version = "0.1.2", path = "../fixed_wide", registry = "strafesnet", optional = true }
+fixed_wide = { version = "0.2.0", path = "../fixed_wide", registry = "strafesnet", optional = true }
 paste = { version = "1.0.15", optional = true }
 
 [dev-dependencies]

lib/linear_ops/src/macros/fixed_wide.rs

@@ -38,40 +38,95 @@ macro_rules! impl_fixed_wide_vector {
 		$crate::macro_4!(impl_fixed_wide_vector_not_const_generic,());
 		// I LOVE NOT BEING ABLE TO USE CONST GENERICS
 		$crate::macro_repeated!(
-			impl_fix_not_const_generic,(),
-			(1,1),(2,1),(3,1),(4,1),(5,1),(6,1),(7,1),(8,1),(9,1),(10,1),(11,1),(12,1),(13,1),(14,1),(15,1),(16,1),
-			(1,2),(2,2),(3,2),(4,2),(5,2),(6,2),(7,2),(8,2),(9,2),(10,2),(11,2),(12,2),(13,2),(14,2),(15,2),(16,2),
-			(1,3),(2,3),(3,3),(4,3),(5,3),(6,3),(7,3),(8,3),(9,3),(10,3),(11,3),(12,3),(13,3),(14,3),(15,3),(16,3),
-			(1,4),(2,4),(3,4),(4,4),(5,4),(6,4),(7,4),(8,4),(9,4),(10,4),(11,4),(12,4),(13,4),(14,4),(15,4),(16,4),
-			(1,5),(2,5),(3,5),(4,5),(5,5),(6,5),(7,5),(8,5),(9,5),(10,5),(11,5),(12,5),(13,5),(14,5),(15,5),(16,5),
-			(1,6),(2,6),(3,6),(4,6),(5,6),(6,6),(7,6),(8,6),(9,6),(10,6),(11,6),(12,6),(13,6),(14,6),(15,6),(16,6),
-			(1,7),(2,7),(3,7),(4,7),(5,7),(6,7),(7,7),(8,7),(9,7),(10,7),(11,7),(12,7),(13,7),(14,7),(15,7),(16,7),
-			(1,8),(2,8),(3,8),(4,8),(5,8),(6,8),(7,8),(8,8),(9,8),(10,8),(11,8),(12,8),(13,8),(14,8),(15,8),(16,8),
-			(1,9),(2,9),(3,9),(4,9),(5,9),(6,9),(7,9),(8,9),(9,9),(10,9),(11,9),(12,9),(13,9),(14,9),(15,9),(16,9),
-			(1,10),(2,10),(3,10),(4,10),(5,10),(6,10),(7,10),(8,10),(9,10),(10,10),(11,10),(12,10),(13,10),(14,10),(15,10),(16,10),
-			(1,11),(2,11),(3,11),(4,11),(5,11),(6,11),(7,11),(8,11),(9,11),(10,11),(11,11),(12,11),(13,11),(14,11),(15,11),(16,11),
-			(1,12),(2,12),(3,12),(4,12),(5,12),(6,12),(7,12),(8,12),(9,12),(10,12),(11,12),(12,12),(13,12),(14,12),(15,12),(16,12),
-			(1,13),(2,13),(3,13),(4,13),(5,13),(6,13),(7,13),(8,13),(9,13),(10,13),(11,13),(12,13),(13,13),(14,13),(15,13),(16,13),
-			(1,14),(2,14),(3,14),(4,14),(5,14),(6,14),(7,14),(8,14),(9,14),(10,14),(11,14),(12,14),(13,14),(14,14),(15,14),(16,14),
-			(1,15),(2,15),(3,15),(4,15),(5,15),(6,15),(7,15),(8,15),(9,15),(10,15),(11,15),(12,15),(13,15),(14,15),(15,15),(16,15),
-			(1,16),(2,16),(3,16),(4,16),(5,16),(6,16),(7,16),(8,16),(9,16),(10,16),(11,16),(12,16),(13,16),(14,16),(15,16),(16,16)
+			impl_narrow_not_const_generic,(),
+			(2,1),(3,1),(4,1),(5,1),(6,1),(7,1),(8,1),(9,1),(10,1),(11,1),(12,1),(13,1),(14,1),(15,1),(16,1),(17,1),
+			(3,2),(4,2),(5,2),(6,2),(7,2),(8,2),(9,2),(10,2),(11,2),(12,2),(13,2),(14,2),(15,2),(16,2),
+			(4,3),(5,3),(6,3),(7,3),(8,3),(9,3),(10,3),(11,3),(12,3),(13,3),(14,3),(15,3),(16,3),
+			(5,4),(6,4),(7,4),(8,4),(9,4),(10,4),(11,4),(12,4),(13,4),(14,4),(15,4),(16,4),
+			(6,5),(7,5),(8,5),(9,5),(10,5),(11,5),(12,5),(13,5),(14,5),(15,5),(16,5),
+			(7,6),(8,6),(9,6),(10,6),(11,6),(12,6),(13,6),(14,6),(15,6),(16,6),
+			(8,7),(9,7),(10,7),(11,7),(12,7),(13,7),(14,7),(15,7),(16,7),
+			(9,8),(10,8),(11,8),(12,8),(13,8),(14,8),(15,8),(16,8),
+			(10,9),(11,9),(12,9),(13,9),(14,9),(15,9),(16,9),
+			(11,10),(12,10),(13,10),(14,10),(15,10),(16,10),
+			(12,11),(13,11),(14,11),(15,11),(16,11),
+			(13,12),(14,12),(15,12),(16,12),
+			(14,13),(15,13),(16,13),
+			(15,14),(16,14),
+			(16,15)
 		);
+		$crate::macro_repeated!(
+			impl_widen_not_const_generic,(),
+			(1,2),
+			(1,3),(2,3),
+			(1,4),(2,4),(3,4),
+			(1,5),(2,5),(3,5),(4,5),
+			(1,6),(2,6),(3,6),(4,6),(5,6),
+			(1,7),(2,7),(3,7),(4,7),(5,7),(6,7),
+			(1,8),(2,8),(3,8),(4,8),(5,8),(6,8),(7,8),
+			(1,9),(2,9),(3,9),(4,9),(5,9),(6,9),(7,9),(8,9),
+			(1,10),(2,10),(3,10),(4,10),(5,10),(6,10),(7,10),(8,10),(9,10),
+			(1,11),(2,11),(3,11),(4,11),(5,11),(6,11),(7,11),(8,11),(9,11),(10,11),
+			(1,12),(2,12),(3,12),(4,12),(5,12),(6,12),(7,12),(8,12),(9,12),(10,12),(11,12),
+			(1,13),(2,13),(3,13),(4,13),(5,13),(6,13),(7,13),(8,13),(9,13),(10,13),(11,13),(12,13),
+			(1,14),(2,14),(3,14),(4,14),(5,14),(6,14),(7,14),(8,14),(9,14),(10,14),(11,14),(12,14),(13,14),
+			(1,15),(2,15),(3,15),(4,15),(5,15),(6,15),(7,15),(8,15),(9,15),(10,15),(11,15),(12,15),(13,15),(14,15),
+			(1,16),(2,16),(3,16),(4,16),(5,16),(6,16),(7,16),(8,16),(9,16),(10,16),(11,16),(12,16),(13,16),(14,16),(15,16),
+			(1,17)
+		);
+		impl<const N:usize,T:fixed_wide::fixed::Wrap<U>,U> fixed_wide::fixed::Wrap<Vector<N,U>> for Vector<N,T>
+		{
+			#[inline]
+			fn wrap(self)->Vector<N,U>{
+				self.map(|t|t.wrap())
+			}
+		}
+		impl<const N:usize,T:fixed_wide::fixed::Clamp<U>,U> fixed_wide::fixed::Clamp<Vector<N,U>> for Vector<N,T>
+		{
+			#[inline]
+			fn clamp(self)->Vector<N,U>{
+				self.map(|t|t.clamp())
+			}
+		}
 	};
 }
-
 #[doc(hidden)]
 #[macro_export(local_inner_macros)]
-macro_rules! impl_fix_not_const_generic{
+macro_rules! impl_narrow_not_const_generic{
 	(
 		(),
 		($lhs:expr,$rhs:expr)
 	)=>{
-		impl<const N:usize> Vector<N,fixed_wide::fixed::Fixed<$lhs,{$lhs*32}>>
-		{
-			paste::item!{
+		paste::item!{
+			impl<const N:usize> Vector<N,fixed_wide::fixed::Fixed<$lhs,{$lhs*32}>>{
 				#[inline]
-				pub fn [<fix_ $rhs>](self)->Vector<N,fixed_wide::fixed::Fixed<$rhs,{$rhs*32}>>{
-					self.map(|t|t.[<fix_ $rhs>]())
+				pub fn [<wrap_ $rhs>](self)->Vector<N,fixed_wide::fixed::Fixed<$rhs,{$rhs*32}>>{
+					self.map(|t|t.[<wrap_ $rhs>]())
+				}
+				#[inline]
+				pub fn [<narrow_ $rhs>](self)->Vector<N,Result<fixed_wide::fixed::Fixed<$rhs,{$rhs*32}>,fixed_wide::fixed::NarrowError>>{
+					self.map(|t|t.[<narrow_ $rhs>]())
+				}
+				#[inline]
+				pub fn [<clamp_ $rhs>](self)->Vector<N,fixed_wide::fixed::Fixed<$rhs,{$rhs*32}>>{
+					self.map(|t|t.[<clamp_ $rhs>]())
+				}
+			}
+		}
+	}
+}
+#[doc(hidden)]
+#[macro_export(local_inner_macros)]
+macro_rules! impl_widen_not_const_generic{
+	(
+		(),
+		($lhs:expr,$rhs:expr)
+	)=>{
+		paste::item!{
+			impl<const N:usize> Vector<N,fixed_wide::fixed::Fixed<$lhs,{$lhs*32}>>{
+				#[inline]
+				pub fn [<widen_ $rhs>](self)->Vector<N,fixed_wide::fixed::Fixed<$rhs,{$rhs*32}>>{
+					self.map(|t|t.[<widen_ $rhs>]())
 				}
 			}
 		}

lib/linear_ops/src/macros/vector.rs

@@ -58,6 +58,15 @@ macro_rules! impl_vector {
 			}
 		}
 
+		impl<const N:usize,T,E:std::fmt::Debug> Vector<N,Result<T,E>>{
+			#[inline]
+			pub fn unwrap(self)->Vector<N,T>{
+				Vector{
+					array:self.array.map(Result::unwrap)
+				}
+			}
+		}
+
 		impl<const N:usize,T:Ord> Vector<N,T>{
 			#[inline]
 			pub fn min(self,rhs:Self)->Self{

lib/rbx_loader/src/mesh.rs

@@ -84,13 +84,13 @@ where
 fn ingest_faces2_lods3(
 	polygon_groups:&mut Vec<PolygonGroup>,
 	vertex_id_map:&HashMap<rbx_mesh::mesh::VertexId2,VertexId>,
-	faces:&Vec<rbx_mesh::mesh::Face2>,
-	lods:&Vec<rbx_mesh::mesh::Lod3>
+	faces:&[rbx_mesh::mesh::Face2],
+	lods:&[rbx_mesh::mesh::Lod3],
 ){
 	//faces have to be split into polygon groups based on lod
 	polygon_groups.extend(lods.windows(2).map(|lod_pair|
-		PolygonGroup::PolygonList(PolygonList::new(faces[lod_pair[0].0 as usize..lod_pair[1].0 as usize].iter().map(|face|
-			vec![vertex_id_map[&face.0],vertex_id_map[&face.1],vertex_id_map[&face.2]]
+		PolygonGroup::PolygonList(PolygonList::new(faces[lod_pair[0].0 as usize..lod_pair[1].0 as usize].iter().map(|rbx_mesh::mesh::Face2(v0,v1,v2)|
+			vec![vertex_id_map[&v0],vertex_id_map[&v1],vertex_id_map[&v2]]
 		).collect()))
 	))
 }

lib/rbx_loader/src/rbx.rs

@@ -4,12 +4,11 @@ use crate::primitives;
 use strafesnet_common::aabb::Aabb;
 use strafesnet_common::map;
 use strafesnet_common::model;
-use strafesnet_common::gameplay_modes;
+use strafesnet_common::gameplay_modes::{NormalizedModes,Mode,ModeId,ModeUpdate,ModesBuilder,Stage,StageElement,StageElementBehaviour,StageId,Zone};
 use strafesnet_common::gameplay_style;
 use strafesnet_common::gameplay_attributes as attr;
 use strafesnet_common::integer::{self,vec3,Planar64,Planar64Vec3,Planar64Mat3,Planar64Affine3};
 use strafesnet_common::model::RenderConfigId;
-use strafesnet_common::updatable::Updatable;
 use strafesnet_deferred_loader::deferred_loader::{RenderConfigDeferredLoader,MeshDeferredLoader};
 use strafesnet_deferred_loader::mesh::Meshes;
 use strafesnet_deferred_loader::texture::{RenderConfigs,Texture};
@@ -48,97 +47,11 @@ fn planar64_affine3_from_roblox(cf:&rbx_dom_weak::types::CFrame,size:&rbx_dom_we
 			*integer::try_from_f32(size.y/2.0).unwrap(),
 			vec3::try_from_f32_array([cf.orientation.x.z,cf.orientation.y.z,cf.orientation.z.z]).unwrap()
 			*integer::try_from_f32(size.z/2.0).unwrap(),
-			].map(|t|t.fix_1())),
+			].map(|t|t.narrow_1().unwrap())),
 		vec3::try_from_f32_array([cf.position.x,cf.position.y,cf.position.z]).unwrap()
 	)
 }
-struct ModeBuilder{
-	mode:gameplay_modes::Mode,
-	final_stage_id_from_builder_stage_id:HashMap<gameplay_modes::StageId,gameplay_modes::StageId>,
-}
-#[derive(Default)]
-struct ModesBuilder{
-	modes:HashMap<gameplay_modes::ModeId,gameplay_modes::Mode>,
-	stages:HashMap<gameplay_modes::ModeId,HashMap<gameplay_modes::StageId,gameplay_modes::Stage>>,
-	mode_updates:Vec<(gameplay_modes::ModeId,gameplay_modes::ModeUpdate)>,
-	stage_updates:Vec<(gameplay_modes::ModeId,gameplay_modes::StageId,gameplay_modes::StageUpdate)>,
-}
-impl ModesBuilder{
-	fn build(mut self)->gameplay_modes::Modes{
-		//collect modes and stages into contiguous arrays
-		let mut unique_modes:Vec<(gameplay_modes::ModeId,gameplay_modes::Mode)>
-		=self.modes.into_iter().collect();
-		unique_modes.sort_by_key(|&(mode_id,_)|mode_id);
-		let (mut modes,final_mode_id_from_builder_mode_id):(Vec<ModeBuilder>,HashMap<gameplay_modes::ModeId,gameplay_modes::ModeId>)
-		=unique_modes.into_iter().enumerate()
-		.map(|(final_mode_id,(builder_mode_id,mut mode))|{
-			(
-				ModeBuilder{
-					final_stage_id_from_builder_stage_id:self.stages.remove(&builder_mode_id).map_or_else(||HashMap::new(),|stages|{
-						let mut unique_stages:Vec<(gameplay_modes::StageId,gameplay_modes::Stage)>
-						=stages.into_iter().collect();
-						unique_stages.sort_by(|a,b|a.0.cmp(&b.0));
-						unique_stages.into_iter().enumerate()
-						.map(|(final_stage_id,(builder_stage_id,stage))|{
-							mode.push_stage(stage);
-							(builder_stage_id,gameplay_modes::StageId::new(final_stage_id as u32))
-						}).collect()
-					}),
-					mode,
-				},
-				(
-					builder_mode_id,
-					gameplay_modes::ModeId::new(final_mode_id as u32)
-				)
-			)
-		}).unzip();
-		//TODO: failure messages or errors or something
-		//push stage updates
-		for (builder_mode_id,builder_stage_id,stage_update) in self.stage_updates{
-			if let Some(final_mode_id)=final_mode_id_from_builder_mode_id.get(&builder_mode_id){
-				if let Some(mode)=modes.get_mut(final_mode_id.get() as usize){
-					if let Some(&final_stage_id)=mode.final_stage_id_from_builder_stage_id.get(&builder_stage_id){
-						if let Some(stage)=mode.mode.get_stage_mut(final_stage_id){
-							stage.update(stage_update);
-						}
-					}
-				}
-			}
-		}
-		//push mode updates
-		for (builder_mode_id,mut mode_update) in self.mode_updates{
-			if let Some(final_mode_id)=final_mode_id_from_builder_mode_id.get(&builder_mode_id){
-				if let Some(mode)=modes.get_mut(final_mode_id.get() as usize){
-					//map stage id on stage elements
-					mode_update.map_stage_element_ids(|stage_id|
-						//walk down one stage id at a time until a stage is found
-						//TODO use better logic like BTreeMap::upper_bound instead of walking
-						// final_stage_id_from_builder_stage_id.upper_bound(Bound::Included(&stage_id))
-						// .value().copied().unwrap_or(gameplay_modes::StageId::FIRST)
-						(0..=stage_id.get()).rev().find_map(|builder_stage_id|
-							//map the stage element to that stage
-							mode.final_stage_id_from_builder_stage_id.get(&gameplay_modes::StageId::new(builder_stage_id)).copied()
-						).unwrap_or(gameplay_modes::StageId::FIRST)
-					);
-					mode.mode.update(mode_update);
-				}
-			}
-		}
-		gameplay_modes::Modes::new(modes.into_iter().map(|mode_builder|mode_builder.mode).collect())
-	}
-	fn insert_mode(&mut self,mode_id:gameplay_modes::ModeId,mode:gameplay_modes::Mode){
-		assert!(self.modes.insert(mode_id,mode).is_none(),"Cannot replace existing mode");
-	}
-	fn insert_stage(&mut self,mode_id:gameplay_modes::ModeId,stage_id:gameplay_modes::StageId,stage:gameplay_modes::Stage){
-		assert!(self.stages.entry(mode_id).or_insert(HashMap::new()).insert(stage_id,stage).is_none(),"Cannot replace existing stage");
-	}
-	fn push_mode_update(&mut self,mode_id:gameplay_modes::ModeId,mode_update:gameplay_modes::ModeUpdate){
-		self.mode_updates.push((mode_id,mode_update));
-	}
-	// fn push_stage_update(&mut self,mode_id:gameplay_modes::ModeId,stage_id:gameplay_modes::StageId,stage_update:gameplay_modes::StageUpdate){
-	// 	self.stage_updates.push((mode_id,stage_id,stage_update));
-	// }
-}
+
 fn get_attributes(name:&str,can_collide:bool,velocity:Planar64Vec3,model_id:model::ModelId,modes_builder:&mut ModesBuilder,wormhole_in_model_to_id:&mut HashMap<model::ModelId,u32>,wormhole_id_to_out_model:&mut HashMap<u32,model::ModelId>)->attr::CollisionAttributes{
 	let mut general=attr::GeneralAttributes::default();
 	let mut intersecting=attr::IntersectingAttributes::default();
@@ -167,8 +80,8 @@ fn get_attributes(name:&str,can_collide:bool,velocity:Planar64Vec3,model_id:mode
 			force_can_collide=false;
 			force_intersecting=true;
 			modes_builder.insert_mode(
-				gameplay_modes::ModeId::MAIN,
-				gameplay_modes::Mode::empty(
+				ModeId::MAIN,
+				Mode::empty(
 					gameplay_style::StyleModifiers::roblox_bhop(),
 					model_id
 				)
@@ -178,10 +91,10 @@ fn get_attributes(name:&str,can_collide:bool,velocity:Planar64Vec3,model_id:mode
 			force_can_collide=false;
 			force_intersecting=true;
 			modes_builder.push_mode_update(
-				gameplay_modes::ModeId::MAIN,
-				gameplay_modes::ModeUpdate::zone(
+				ModeId::MAIN,
+				ModeUpdate::zone(
 					model_id,
-					gameplay_modes::Zone::Finish,
+					Zone::Finish,
 				),
 			);
 		},
@@ -189,19 +102,19 @@ fn get_attributes(name:&str,can_collide:bool,velocity:Planar64Vec3,model_id:mode
 			force_can_collide=false;
 			force_intersecting=true;
 			modes_builder.push_mode_update(
-				gameplay_modes::ModeId::MAIN,
-				gameplay_modes::ModeUpdate::zone(
+				ModeId::MAIN,
+				ModeUpdate::zone(
 					model_id,
-					gameplay_modes::Zone::Anticheat,
+					Zone::Anticheat,
 				),
 			);
 		},
 		"Platform"=>{
 			modes_builder.push_mode_update(
-				gameplay_modes::ModeId::MAIN,
-				gameplay_modes::ModeUpdate::element(
+				ModeId::MAIN,
+				ModeUpdate::element(
 					model_id,
-					gameplay_modes::StageElement::new(gameplay_modes::StageId::FIRST,false,gameplay_modes::StageElementBehaviour::Platform,None),//roblox does not know which stage the platform belongs to
+					StageElement::new(StageId::FIRST,false,StageElementBehaviour::Platform,None),//roblox does not know which stage the platform belongs to
 				),
 			);
 		},
@@ -213,8 +126,8 @@ fn get_attributes(name:&str,can_collide:bool,velocity:Planar64Vec3,model_id:mode
 						force_can_collide=false;
 						force_intersecting=true;
 						modes_builder.insert_mode(
-							gameplay_modes::ModeId::new(captures[2].parse::<u32>().unwrap()),
-							gameplay_modes::Mode::empty(
+							ModeId::new(captures[2].parse::<u32>().unwrap()),
+							Mode::empty(
 								gameplay_style::StyleModifiers::roblox_bhop(),
 								model_id
 							)
@@ -231,8 +144,8 @@ fn get_attributes(name:&str,can_collide:bool,velocity:Planar64Vec3,model_id:mode
 			}else if let Some(captures)=lazy_regex::regex!(r"^(Force)?(Spawn|SpawnAt|Trigger|Teleport|Platform)(\d+)$")
 			.captures(other){
 				force_intersecting=true;
-				let stage_id=gameplay_modes::StageId::new(captures[3].parse::<u32>().unwrap());
-				let stage_element=gameplay_modes::StageElement::new(
+				let stage_id=StageId::new(captures[3].parse::<u32>().unwrap());
+				let stage_element=StageElement::new(
 					//stage_id:
 					stage_id,
 					//force:
@@ -244,26 +157,26 @@ fn get_attributes(name:&str,can_collide:bool,velocity:Planar64Vec3,model_id:mode
 					match &captures[2]{
 						"Spawn"=>{
 							modes_builder.insert_stage(
-								gameplay_modes::ModeId::MAIN,
+								ModeId::MAIN,
 								stage_id,
-								gameplay_modes::Stage::empty(model_id),
+								Stage::empty(model_id),
 							);
 							//TODO: let denormalize handle this
-							gameplay_modes::StageElementBehaviour::SpawnAt
+							StageElementBehaviour::SpawnAt
 						},
-						"SpawnAt"=>gameplay_modes::StageElementBehaviour::SpawnAt,
+						"SpawnAt"=>StageElementBehaviour::SpawnAt,
 						//cancollide false so you don't hit the side
 						//NOT a decoration
-						"Trigger"=>{force_can_collide=false;gameplay_modes::StageElementBehaviour::Trigger},
-						"Teleport"=>{force_can_collide=false;gameplay_modes::StageElementBehaviour::Teleport},
-						"Platform"=>gameplay_modes::StageElementBehaviour::Platform,
+						"Trigger"=>{force_can_collide=false;StageElementBehaviour::Trigger},
+						"Teleport"=>{force_can_collide=false;StageElementBehaviour::Teleport},
+						"Platform"=>StageElementBehaviour::Platform,
 						_=>panic!("regex1[2] messed up bad"),
 					},
 					None
 				);
 				modes_builder.push_mode_update(
-					gameplay_modes::ModeId::MAIN,
-					gameplay_modes::ModeUpdate::element(
+					ModeId::MAIN,
+					ModeUpdate::element(
 						model_id,
 						stage_element,
 					),
@@ -272,14 +185,14 @@ fn get_attributes(name:&str,can_collide:bool,velocity:Planar64Vec3,model_id:mode
 			.captures(other){
 				match &captures[1]{
 					"Jump"=>modes_builder.push_mode_update(
-						gameplay_modes::ModeId::MAIN,
-						gameplay_modes::ModeUpdate::element(
+						ModeId::MAIN,
+						ModeUpdate::element(
 							model_id,
 							//jump_limit:
-							gameplay_modes::StageElement::new(
-								gameplay_modes::StageId::FIRST,
+							StageElement::new(
+								StageId::FIRST,
 								false,
-								gameplay_modes::StageElementBehaviour::Check,
+								StageElementBehaviour::Check,
 								Some(captures[2].parse::<u8>().unwrap())
 							)
 						),
@@ -296,13 +209,13 @@ fn get_attributes(name:&str,can_collide:bool,velocity:Planar64Vec3,model_id:mode
 				force_can_collide=false;
 				force_intersecting=true;
 				modes_builder.push_mode_update(
-					gameplay_modes::ModeId::new(captures[2].parse::<u32>().unwrap()),
-					gameplay_modes::ModeUpdate::zone(
+					ModeId::new(captures[2].parse::<u32>().unwrap()),
+					ModeUpdate::zone(
 						model_id,
 						//zone:
 						match &captures[1]{
-							"Finish"=>gameplay_modes::Zone::Finish,
-							"Anticheat"=>gameplay_modes::Zone::Anticheat,
+							"Finish"=>Zone::Finish,
+							"Anticheat"=>Zone::Anticheat,
 							_=>panic!("regex3[1] messed up bad"),
 						},
 					),
@@ -312,9 +225,9 @@ fn get_attributes(name:&str,can_collide:bool,velocity:Planar64Vec3,model_id:mode
 			// .captures(other){
 			// 	match &captures[1]{
 			// 		"OrderedCheckpoint"=>modes_builder.push_stage_update(
-			// 			gameplay_modes::ModeId::MAIN,
-			// 			gameplay_modes::StageId::new(0),
-			// 			gameplay_modes::StageUpdate::ordered_checkpoint(captures[2].parse::<u32>().unwrap()),
+			// 			ModeId::MAIN,
+			// 			StageId::new(0),
+			// 			StageUpdate::ordered_checkpoint(captures[2].parse::<u32>().unwrap()),
 			// 		),
 			// 		_=>panic!("regex3[1] messed up bad"),
 			// 	}
@@ -924,9 +837,9 @@ impl PartialMap1<'_>{
 				color:deferred_model_deferred_attributes.model.color,
 				transform:Planar64Affine3::new(
 					Planar64Mat3::from_cols([
-						(deferred_model_deferred_attributes.model.transform.matrix3.x_axis*2/size.x).divide().fix_1(),
-						(deferred_model_deferred_attributes.model.transform.matrix3.y_axis*2/size.y).divide().fix_1(),
-						(deferred_model_deferred_attributes.model.transform.matrix3.z_axis*2/size.z).divide().fix_1()
+						(deferred_model_deferred_attributes.model.transform.matrix3.x_axis*2/size.x).divide().narrow_1().unwrap(),
+						(deferred_model_deferred_attributes.model.transform.matrix3.y_axis*2/size.y).divide().narrow_1().unwrap(),
+						(deferred_model_deferred_attributes.model.transform.matrix3.z_axis*2/size.z).divide().narrow_1().unwrap(),
 					]),
 					deferred_model_deferred_attributes.model.transform.translation
 				),
@@ -948,9 +861,9 @@ impl PartialMap1<'_>{
 				color:deferred_union_deferred_attributes.model.color,
 				transform:Planar64Affine3::new(
 					Planar64Mat3::from_cols([
-						(deferred_union_deferred_attributes.model.transform.matrix3.x_axis*2/size.x).divide().fix_1(),
-						(deferred_union_deferred_attributes.model.transform.matrix3.y_axis*2/size.y).divide().fix_1(),
-						(deferred_union_deferred_attributes.model.transform.matrix3.z_axis*2/size.z).divide().fix_1()
+						(deferred_union_deferred_attributes.model.transform.matrix3.x_axis*2/size.x).divide().narrow_1().unwrap(),
+						(deferred_union_deferred_attributes.model.transform.matrix3.y_axis*2/size.y).divide().narrow_1().unwrap(),
+						(deferred_union_deferred_attributes.model.transform.matrix3.z_axis*2/size.z).divide().narrow_1().unwrap(),
 					]),
 					deferred_union_deferred_attributes.model.transform.translation
 				),
@@ -1009,7 +922,7 @@ impl PartialMap1<'_>{
 	PartialMap2{
 		meshes:self.primitive_meshes,
 		models,
-		modes:modes_builder.build(),
+		modes:modes_builder.build_normalized(),
 		attributes:unique_attributes,
 	}
 	}
@@ -1018,7 +931,7 @@ impl PartialMap1<'_>{
 pub struct PartialMap2{
 	meshes:Vec<model::Mesh>,
 	models:Vec<model::Model>,
-	modes:gameplay_modes::Modes,
+	modes:NormalizedModes,
 	attributes:Vec<strafesnet_common::gameplay_attributes::CollisionAttributes>,
 }
 impl PartialMap2{

lib/snf/src/map.rs

@@ -138,7 +138,7 @@ struct MapHeader{
 	//#[br(count=num_resources_external)]
 	//external_resources:Vec<ResourceExternalHeader>,
 	#[br(count=num_modes)]
-	modes:Vec<newtypes::gameplay_modes::Mode>,
+	modes:Vec<newtypes::gameplay_modes::NormalizedMode>,
 	#[br(count=num_attributes)]
 	attributes:Vec<newtypes::gameplay_attributes::CollisionAttributes>,
 	#[br(count=num_render_configs)]
@@ -181,7 +181,7 @@ fn read_texture<R:BinReaderExt>(file:&mut crate::file::File<R>,block_id:BlockId)
 pub struct StreamableMap<R:BinReaderExt>{
 	file:crate::file::File<R>,
 	//this includes every platform... move the unconstrained datas to their appropriate data block?
-	modes:gameplay_modes::Modes,
+	modes:gameplay_modes::NormalizedModes,
 	//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
@@ -223,7 +223,7 @@ impl<R:BinReaderExt> StreamableMap<R>{
 		}
 		Ok(Self{
 			file,
-			modes:strafesnet_common::gameplay_modes::Modes::new(modes),
+			modes:strafesnet_common::gameplay_modes::NormalizedModes::new(modes),
 			attributes,
 			render_configs,
 			bvh:strafesnet_common::bvh::generate_bvh(bvh),
@@ -386,7 +386,7 @@ pub fn write_map<W:BinWriterExt>(mut writer:W,map:strafesnet_common::map::Comple
 		let mesh=map.meshes.get(model.mesh.get() as usize).ok_or(Error::InvalidMeshId(model.mesh))?;
 		let mut aabb=strafesnet_common::aabb::Aabb::default();
 		for &pos in &mesh.unique_pos{
-			aabb.grow(model.transform.transform_point3(pos).fix_1());
+			aabb.grow(model.transform.transform_point3(pos).narrow_1().unwrap());
 		}
 		Ok(((model::ModelId::new(model_id as u32),model.into()),aabb))
 	}).collect::<Result<Vec<_>,_>>()?;
@@ -430,13 +430,13 @@ pub fn write_map<W:BinWriterExt>(mut writer:W,map:strafesnet_common::map::Comple
 		num_spacial_blocks:spacial_blocks.len() as u32,
 		num_resource_blocks:resource_blocks.len() as u32,
 		//num_resources_external:0,
-		num_modes:map.modes.modes.len() as u32,
+		num_modes:map.modes.len() as u32,
 		num_attributes:map.attributes.len() as u32,
 		num_render_configs:map.render_configs.len() as u32,
 		spacial_blocks,
 		resource_blocks,
 		//external_resources:Vec::new(),
-		modes:map.modes.modes.into_iter().map(Into::into).collect(),
+		modes:map.modes.into_iter().map(Into::into).collect(),
 		attributes:map.attributes.into_iter().map(Into::into).collect(),
 		render_configs:map.render_configs.into_iter().map(Into::into).collect(),
 	};

lib/snf/src/newtypes/gameplay_modes.rs

@@ -157,7 +157,7 @@ pub struct ModeHeader{
 }
 #[binrw::binrw]
 #[brw(little)]
-pub struct Mode{
+pub struct NormalizedMode{
 	pub header:ModeHeader,
 	pub style:super::gameplay_style::StyleModifiers,
 	pub start:u32,
@@ -179,10 +179,10 @@ impl std::fmt::Display for ModeError{
 	}
 }
 impl std::error::Error for ModeError{}
-impl TryInto<strafesnet_common::gameplay_modes::Mode> for Mode{
+impl TryInto<strafesnet_common::gameplay_modes::NormalizedMode> for NormalizedMode{
 	type Error=ModeError;
-	fn try_into(self)->Result<strafesnet_common::gameplay_modes::Mode,Self::Error>{
-		Ok(strafesnet_common::gameplay_modes::Mode::new(
+	fn try_into(self)->Result<strafesnet_common::gameplay_modes::NormalizedMode,Self::Error>{
+		Ok(strafesnet_common::gameplay_modes::NormalizedMode::new(strafesnet_common::gameplay_modes::Mode::new(
 			self.style.try_into().map_err(ModeError::StyleModifier)?,
 			strafesnet_common::model::ModelId::new(self.start),
 			self.zones.into_iter().map(|(model_id,zone)|
@@ -192,12 +192,12 @@ impl TryInto<strafesnet_common::gameplay_modes::Mode> for Mode{
 			self.elements.into_iter().map(|(model_id,stage_element)|
 				Ok((strafesnet_common::model::ModelId::new(model_id),stage_element.try_into()?))
 			).collect::<Result<_,_>>().map_err(ModeError::StageElement)?,
-		))
+		)))
 	}
 }
-impl From<strafesnet_common::gameplay_modes::Mode> for Mode{
-	fn from(value:strafesnet_common::gameplay_modes::Mode)->Self{
-		let (style,start,zones,stages,elements)=value.into_inner();
+impl From<strafesnet_common::gameplay_modes::NormalizedMode> for NormalizedMode{
+	fn from(value:strafesnet_common::gameplay_modes::NormalizedMode)->Self{
+		let (style,start,zones,stages,elements)=value.into_inner().into_inner();
 		Self{
 			header:ModeHeader{
 				zones:zones.len() as u32,

map-tool/Cargo.toml

@@ -25,11 +25,11 @@ strafesnet_rbx_loader = { version = "0.6.0", path = "../lib/rbx_loader", registr
 strafesnet_snf = { version = "0.3.0", path = "../lib/snf", registry = "strafesnet" }
 thiserror = "2.0.11"
 tokio = { version = "1.43.0", features = ["macros", "rt-multi-thread", "fs"] }
-vbsp = { version = "0.7.0-codegen5", registry = "strafesnet", default-features = false }
-vbsp-entities = { version = "0.1.0", registry = "strafesnet", default-features = false, features = ["css"]}
+vbsp = "0.8.0"
+vbsp-entities-css = "0.6.0"
 vmdl = "0.2.0"
 vmt-parser = "0.2.0"
-vpk = "0.2.0"
+vpk = "0.3.0"
 vtf = "0.3.0"
 
 #[profile.release]

map-tool/src/source.rs

@@ -6,7 +6,7 @@ use futures::StreamExt;
 use strafesnet_bsp_loader::loader::BspFinder;
 use strafesnet_deferred_loader::loader::Loader;
 use strafesnet_deferred_loader::deferred_loader::{LoadFailureMode,MeshDeferredLoader,RenderConfigDeferredLoader};
-use vbsp_entities::css::Entity;
+use vbsp_entities_css::Entity;
 
 #[derive(Subcommand)]
 pub enum Commands{