idea: multiple collisions can happen in the same instant

.gitignore

@@ -1 +1,2 @@
 /target
+.zed

Cargo.lock

@@ -1677,8 +1677,10 @@ dependencies = [
 name = "integration-testing"
 version = "0.1.0"
 dependencies = [
+ "glam",
  "strafesnet_common",
  "strafesnet_physics",
+ "strafesnet_rbx_loader",
  "strafesnet_snf",
 ]
 

engine/physics/src/model.rs

@@ -1,8 +1,8 @@
 use std::collections::{HashSet,HashMap};
 use core::ops::{Bound,RangeBounds};
 use strafesnet_common::integer::vec3::Vector3;
-use strafesnet_common::model::{self,MeshId};
-use strafesnet_common::integer::{self,vec3,Fixed,Planar32Vec3,Planar64,Planar64Vec3,Ratio};
+use strafesnet_common::model::{self,MeshId,PolygonIter};
+use strafesnet_common::integer::{self,vec3,Fixed,Planar64,Planar64Vec3,Ratio};
 use strafesnet_common::physics::Time;
 
 type Body=crate::body::Body<strafesnet_common::physics::TimeInner>;
@@ -74,7 +74,7 @@ struct Face{
 	dot:Planar64,
 }
 #[derive(Debug)]
-struct Vert(Planar32Vec3);
+struct Vert(Planar64Vec3);
 pub trait MeshQuery{
 	type Face:Copy;
 	type Edge:Copy+DirectedEdge;

engine/physics/src/physics.rs

@@ -25,8 +25,13 @@ use strafesnet_common::physics::{Instruction,MouseInstruction,ModeInstruction,Mi
 //when the physics asks itself what happens next, this is how it's represented
 #[derive(Debug)]
 pub enum InternalInstruction{
-	CollisionStart(Collision,model_physics::GigaTime),
-	CollisionEnd(Collision,model_physics::GigaTime),
+	// begin accepting touch updates
+	OpenMultiCollision(model_physics::GigaTime),
+	// mutliple touch updates
+	CollisionStart(Collision),
+	CollisionEnd(Collision),
+	// confirm there will be no more touch updates and apply the transaction
+	CloseMultiCollision,
 	StrafeTick,
 	ReachWalkTargetVelocity,
 	// Water,
@@ -874,6 +879,9 @@ impl PhysicsState{
 			..Self::default()
 		}
 	}
+	pub const fn body(&self)->&Body{
+		&self.body
+	}
 	pub fn camera_body(&self)->Body{
 		Body{
 			position:self.body.position+self.style.camera_offset,
@@ -949,8 +957,8 @@ pub struct PhysicsData{
 	//cached calculations
 	hitbox_mesh:HitboxMesh,
 }
-impl Default for PhysicsData{
-	fn default()->Self{
+impl PhysicsData{
+	pub fn empty()->Self{
  		Self{
 			bvh:bvh::BvhNode::empty(),
 			models:Default::default(),
@@ -958,47 +966,7 @@ impl Default for PhysicsData{
 			hitbox_mesh:StyleModifiers::default().calculate_mesh(),
 		}
 	}
-}
-// the collection of information required to run physics
-pub struct PhysicsContext<'a>{
-	state:&'a mut PhysicsState,//this captures the entire state of the physics.
-	data:&'a PhysicsData,//data currently loaded into memory which is needded for physics to run, but is not part of the state.
-}
-// the physics consumes both Instruction and PhysicsInternalInstruction,
-// but can only emit PhysicsInternalInstruction
-impl InstructionConsumer<InternalInstruction> for PhysicsContext<'_>{
-	type Time=Time;
-	fn process_instruction(&mut self,ins:TimedInstruction<InternalInstruction,Time>){
-		atomic_internal_instruction(&mut self.state,&self.data,ins)
-	}
-}
-impl InstructionConsumer<Instruction> for PhysicsContext<'_>{
-	type Time=Time;
-	fn process_instruction(&mut self,ins:TimedInstruction<Instruction,Time>){
-		atomic_input_instruction(&mut self.state,&self.data,ins)
-	}
-}
-impl InstructionEmitter<InternalInstruction> for PhysicsContext<'_>{
-	type Time=Time;
-	//this little next instruction function could cache its return value and invalidate the cached value by watching the State.
-	fn next_instruction(&self,time_limit:Time)->Option<TimedInstruction<InternalInstruction,Time>>{
-		next_instruction_internal(&self.state,&self.data,time_limit)
-	}
-}
-impl PhysicsContext<'_>{
-	pub fn run_input_instruction(
-		state:&mut PhysicsState,
-		data:&PhysicsData,
-		instruction:TimedInstruction<Instruction,Time>
-	){
-		let mut context=PhysicsContext{state,data};
-		context.process_exhaustive(instruction.time);
-		context.process_instruction(instruction);
-	}
-}
-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){
+	pub fn new(map:&map::CompleteMap)->Self{
 		let modes=map.modes.clone().denormalize();
 		let mut used_contact_attributes=Vec::new();
 		let mut used_intersect_attributes=Vec::new();
@@ -1125,11 +1093,50 @@ impl PhysicsData{
 					(IntersectAttributesId::new(attr_id as u32),attr)
 				).collect(),
 		};
-		self.bvh=bvh;
-		self.models=models;
-		self.modes=modes;
-		//hitbox_mesh is unchanged
 		println!("Physics Objects: {}",model_count);
+		Self{
+			hitbox_mesh:StyleModifiers::default().calculate_mesh(),
+			bvh,
+			models,
+			modes,
+		}
+	}
+}
+// the collection of information required to run physics
+pub struct PhysicsContext<'a>{
+	state:&'a mut PhysicsState,//this captures the entire state of the physics.
+	data:&'a PhysicsData,//data currently loaded into memory which is needded for physics to run, but is not part of the state.
+}
+// the physics consumes both Instruction and PhysicsInternalInstruction,
+// but can only emit PhysicsInternalInstruction
+impl InstructionConsumer<InternalInstruction> for PhysicsContext<'_>{
+	type Time=Time;
+	fn process_instruction(&mut self,ins:TimedInstruction<InternalInstruction,Time>){
+		atomic_internal_instruction(&mut self.state,&self.data,ins)
+	}
+}
+impl InstructionConsumer<Instruction> for PhysicsContext<'_>{
+	type Time=Time;
+	fn process_instruction(&mut self,ins:TimedInstruction<Instruction,Time>){
+		atomic_input_instruction(&mut self.state,&self.data,ins)
+	}
+}
+impl InstructionEmitter<InternalInstruction> for PhysicsContext<'_>{
+	type Time=Time;
+	//this little next instruction function could cache its return value and invalidate the cached value by watching the State.
+	fn next_instruction(&self,time_limit:Time)->Option<TimedInstruction<InternalInstruction,Time>>{
+		next_instruction_internal(&self.state,&self.data,time_limit)
+	}
+}
+impl PhysicsContext<'_>{
+	pub fn run_input_instruction(
+		state:&mut PhysicsState,
+		data:&PhysicsData,
+		instruction:TimedInstruction<Instruction,Time>
+	){
+		let mut context=PhysicsContext{state,data};
+		context.process_exhaustive(instruction.time);
+		context.process_instruction(instruction);
 	}
 }
 
@@ -2124,4 +2131,115 @@ mod test{
 			Time::ZERO
 		),None);
 	}
+	// overlap edges by 1 epsilon
+	#[test]
+	fn almost_miss_north(){
+		test_collision_axis_aligned(Body::new(
+			(int3(0,10,-7)>>1)+vec3::raw_xyz(0,0,1),
+			int3(0,-1,0),
+			vec3::ZERO,
+			Time::ZERO
+		),Some(Time::from_secs(2)))
+	}
+	#[test]
+	fn almost_miss_east(){
+		test_collision_axis_aligned(Body::new(
+			(int3(7,10,0)>>1)+vec3::raw_xyz(-1,0,0),
+			int3(0,-1,0),
+			vec3::ZERO,
+			Time::ZERO
+		),Some(Time::from_secs(2)))
+	}
+	#[test]
+	fn almost_miss_south(){
+		test_collision_axis_aligned(Body::new(
+			(int3(0,10,7)>>1)+vec3::raw_xyz(0,0,-1),
+			int3(0,-1,0),
+			vec3::ZERO,
+			Time::ZERO
+		),Some(Time::from_secs(2)))
+	}
+	#[test]
+	fn almost_miss_west(){
+		test_collision_axis_aligned(Body::new(
+			(int3(-7,10,0)>>1)+vec3::raw_xyz(1,0,0),
+			int3(0,-1,0),
+			vec3::ZERO,
+			Time::ZERO
+		),Some(Time::from_secs(2)))
+	}
+	// exactly miss edges
+	#[test]
+	fn exact_miss_north(){
+		test_collision_axis_aligned(Body::new(
+			int3(0,10,-7)>>1,
+			int3(0,-1,0),
+			vec3::ZERO,
+			Time::ZERO
+		),None)
+	}
+	#[test]
+	fn exact_miss_east(){
+		test_collision_axis_aligned(Body::new(
+			int3(7,10,0)>>1,
+			int3(0,-1,0),
+			vec3::ZERO,
+			Time::ZERO
+		),None)
+	}
+	#[test]
+	fn exact_miss_south(){
+		test_collision_axis_aligned(Body::new(
+			int3(0,10,7)>>1,
+			int3(0,-1,0),
+			vec3::ZERO,
+			Time::ZERO
+		),None)
+	}
+	#[test]
+	fn exact_miss_west(){
+		test_collision_axis_aligned(Body::new(
+			int3(-7,10,0)>>1,
+			int3(0,-1,0),
+			vec3::ZERO,
+			Time::ZERO
+		),None)
+	}
+	// miss edges by 1 epsilon
+	#[test]
+	fn narrow_miss_north(){
+		test_collision_axis_aligned(Body::new(
+			(int3(0,10,-7)>>1)-vec3::raw_xyz(0,0,1),
+			int3(0,-1,0),
+			vec3::ZERO,
+			Time::ZERO
+		),None)
+	}
+	#[test]
+	fn narrow_miss_east(){
+		test_collision_axis_aligned(Body::new(
+			(int3(7,10,0)>>1)-vec3::raw_xyz(-1,0,0),
+			int3(0,-1,0),
+			vec3::ZERO,
+			Time::ZERO
+		),None)
+	}
+	#[test]
+	fn narrow_miss_south(){
+		test_collision_axis_aligned(Body::new(
+			(int3(0,10,7)>>1)-vec3::raw_xyz(0,0,-1),
+			int3(0,-1,0),
+			vec3::ZERO,
+			Time::ZERO
+		),None)
+	}
+	#[test]
+	fn narrow_miss_west(){
+		test_collision_axis_aligned(Body::new(
+			(int3(-7,10,0)>>1)-vec3::raw_xyz(1,0,0),
+			int3(0,-1,0),
+			vec3::ZERO,
+			Time::ZERO
+		),None)
+	}
 }

engine/session/src/session.rs

@@ -172,7 +172,7 @@ impl Session{
 			user_settings,
 			directories,
 			mouse_interpolator:MouseInterpolator::new(),
-			geometry_shared:Default::default(),
+			geometry_shared:PhysicsData::empty(),
 			simulation,
 			view_state:ViewState::Play,
 			recording:Default::default(),
@@ -184,7 +184,7 @@ impl Session{
 	}
 	fn change_map(&mut self,map:&strafesnet_common::map::CompleteMap){
 		self.simulation.physics.clear();
-		self.geometry_shared.generate_models(map);
+		self.geometry_shared=PhysicsData::new(map);
 	}
 	pub fn get_frame_state(&self,time:SessionTime)->Option<FrameState>{
 		match &self.view_state{

integration-testing/Cargo.toml

@@ -4,6 +4,9 @@ version = "0.1.0"
 edition = "2024"
 
 [dependencies]
+glam = "0.30.0"
 strafesnet_common = { path = "../lib/common", registry = "strafesnet" }
 strafesnet_physics = { path = "../engine/physics", registry = "strafesnet" }
 strafesnet_snf = { path = "../lib/snf", registry = "strafesnet" }
+# this is just for the primitive constructor
+strafesnet_rbx_loader = { path = "../lib/rbx_loader", registry = "strafesnet" }

integration-testing/src/main.rs

@@ -3,6 +3,8 @@ mod util;
 
 #[cfg(test)]
 mod tests;
+#[cfg(test)]
+mod test_scenes;
 
 use std::time::Instant;
 
@@ -29,9 +31,8 @@ fn run_replay()->Result<(),ReplayError>{
 	let bot=strafesnet_snf::read_bot(data)?.read_all()?;
 
 	// create recording
-	let mut physics_data=PhysicsData::default();
 	println!("generating models..");
-	physics_data.generate_models(&map);
+	let physics_data=PhysicsData::new(&map);
 	println!("simulating...");
 	let mut physics=PhysicsState::default();
 	for ins in bot.instructions{
@@ -139,9 +140,8 @@ fn test_determinism()->Result<(),ReplayError>{
 	let data=read_entire_file("../tools/bhop_maps/5692113331.snfm")?;
 	let map=strafesnet_snf::read_map(data)?.into_complete_map()?;
 
-	let mut physics_data=PhysicsData::default();
 	println!("generating models..");
-	physics_data.generate_models(&map);
+	let physics_data=PhysicsData::new(&map);
 
 	let (send,recv)=std::sync::mpsc::channel();
 

integration-testing/src/test_scenes.rs

@@ -0,0 +1,91 @@
+use strafesnet_physics::physics::{PhysicsData,PhysicsState,PhysicsContext};
+use strafesnet_common::gameplay_modes::NormalizedModes;
+use strafesnet_common::gameplay_attributes::{CollisionAttributes,CollisionAttributesId};
+use strafesnet_common::integer::{vec3,mat3,Planar64Affine3,Time};
+use strafesnet_common::model::{Mesh,Model,MeshId,ModelId,RenderConfigId};
+use strafesnet_common::map::CompleteMap;
+use strafesnet_common::physics::Instruction;
+use strafesnet_common::instruction::TimedInstruction;
+use strafesnet_rbx_loader::primitives::{unit_cube,CubeFaceDescription};
+
+struct TestSceneBuilder{
+	meshes:Vec<Mesh>,
+	models:Vec<Model>,
+}
+impl TestSceneBuilder{
+	fn new()->Self{
+		Self{
+			meshes:Vec::new(),
+			models:Vec::new(),
+		}
+	}
+	fn push_mesh(&mut self,mesh:Mesh)->MeshId{
+		let mesh_id=self.meshes.len();
+		self.meshes.push(mesh);
+		MeshId::new(mesh_id as u32)
+	}
+	fn push_mesh_instance(&mut self,mesh:MeshId,transform:Planar64Affine3)->ModelId{
+		let model=Model{
+			mesh,
+			attributes:CollisionAttributesId::new(0),
+			color:glam::Vec4::ONE,
+			transform,
+		};
+		let model_id=self.models.len();
+		self.models.push(model);
+		ModelId::new(model_id as u32)
+	}
+	fn build(self)->PhysicsData{
+		let modes=NormalizedModes::new(Vec::new());
+		let attributes=vec![CollisionAttributes::contact_default()];
+		let meshes=self.meshes;
+		let models=self.models;
+		let textures=Vec::new();
+		let render_configs=Vec::new();
+		PhysicsData::new(&CompleteMap{
+			modes,
+			attributes,
+			meshes,
+			models,
+			textures,
+			render_configs,
+		})
+	}
+}
+
+fn test_scene()->PhysicsData{
+	let mut builder=TestSceneBuilder::new();
+	let cube_face_description=CubeFaceDescription::new(Default::default(),RenderConfigId::new(0));
+	let mesh=builder.push_mesh(unit_cube(cube_face_description));
+	// place two 5x5x5 cubes.
+	builder.push_mesh_instance(mesh,Planar64Affine3::new(
+		mat3::from_diagonal(vec3::int(5,5,5)>>1),
+		vec3::int(0,0,0)
+	));
+	builder.push_mesh_instance(mesh,Planar64Affine3::new(
+		mat3::from_diagonal(vec3::int(5,5,5)>>1),
+		vec3::int(5,-5,0)
+	));
+	builder.build()
+}
+
+#[test]
+fn simultaneous_collision(){
+	let physics_data=test_scene();
+	let body=strafesnet_physics::physics::Body::new(
+		vec3::int(5+1,1,0),
+		vec3::int(-1,-1,0),
+		vec3::int(0,0,0),
+		Time::ZERO,
+	);
+	let mut physics=PhysicsState::new_with_body(body);
+	PhysicsContext::run_input_instruction(&mut physics,&physics_data,TimedInstruction{
+		time:Time::from_secs(2),
+		instruction:Instruction::Idle,
+	});
+	let body=physics.body();
+	assert_eq!(body.position,vec3::int(5,0,0));
+	assert_eq!(body.velocity,vec3::int(0,0,0));
+	assert_eq!(body.acceleration,vec3::int(0,0,0));
+	assert_eq!(body.time,Time::ONE_SECOND);
+}

integration-testing/src/tests.rs

@@ -10,9 +10,8 @@ fn physics_bug_2()->Result<(),ReplayError>{
 	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);
+	let physics_data=PhysicsData::new(&map);
 	println!("simulating...");
 
 	//teleport to bug
@@ -45,9 +44,8 @@ fn physics_bug_3()->Result<(),ReplayError>{
 	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);
+	let physics_data=PhysicsData::new(&map);
 	println!("simulating...");
 
 	//teleport to bug

lib/common/src/aabb.rs

@@ -2,7 +2,9 @@ use crate::integer::{vec3,Planar64Vec3};
 
 #[derive(Clone)]
 pub struct Aabb{
+	// min is inclusive
 	min:Planar64Vec3,
+	// max is not inclusive
 	max:Planar64Vec3,
 }
 
@@ -43,7 +45,7 @@ impl Aabb{
 	}
 	#[inline]
 	pub fn contains(&self,point:Planar64Vec3)->bool{
-		let bvec=self.min.lt(point)&point.lt(self.max);
+		let bvec=self.min.le(point)&point.lt(self.max);
 		bvec.all()
 	}
 	#[inline]

lib/common/src/integer.rs

@@ -552,12 +552,6 @@ impl TryFrom<[f32;3]> for Unit32Vec3{
 }
 */
 
-// placeholder until bnum supports u8
-#[derive(Clone,Copy,Debug,Hash,Eq,PartialEq,Ord,PartialOrd)]
-pub struct Planar32(i32);
-pub type Planar32Vec3=linear_ops::types::Vector3<Planar32>;
-pub type Planar32Mat3=linear_ops::types::Matrix3<Planar32>;
-
 pub type Planar64TryFromFloatError=fixed_wide::fixed::FixedFromFloatError;
 pub type Planar64=fixed_wide::types::I32F32;
 pub type Planar64Vec3=linear_ops::types::Vector3<Planar64>;

lib/common/src/model.rs

@@ -1,6 +1,6 @@
 use std::collections::HashMap;
 
-use crate::integer::{Planar32Vec3,Planar32Mat3,Planar64Vec3};
+use crate::integer::{Planar64,Planar64Vec3,Planar64Affine3};
 use crate::gameplay_attributes;
 
 pub type TextureCoordinate=glam::Vec2;
@@ -22,32 +22,61 @@ pub struct IndexedVertex{
 }
 #[derive(Clone,Copy,Hash,id::Id,PartialEq,Eq)]
 pub struct VertexId(u32);
-#[derive(Clone)]
-pub struct Triangle([VertexId;3]);
-impl Triangle{
-	pub fn new(verts:[VertexId;3])->Self{
-		Self(verts)
-	}
+pub type IndexedVertexList=Vec<VertexId>;
+pub trait PolygonIter{
+	fn polys(&self)->impl Iterator<Item=&[VertexId]>;
+}
+pub trait MapVertexId{
+	fn map_vertex_id<F:Fn(VertexId)->VertexId>(self,f:F)->Self;
 }
 #[derive(Clone)]
-pub struct TriangleList(Vec<Triangle>);
-impl TriangleList{
-	pub const fn new(list:Vec<Triangle>)->Self{
+pub struct PolygonList(Vec<IndexedVertexList>);
+impl PolygonList{
+	pub const fn new(list:Vec<IndexedVertexList>)->Self{
 		Self(list)
 	}
-	pub fn extend<T:IntoIterator<Item=Triangle>>(&mut self,iter:T){
+	pub fn extend<T:IntoIterator<Item=IndexedVertexList>>(&mut self,iter:T){
 		self.0.extend(iter);
 	}
 }
-
+impl PolygonIter for PolygonList{
+	fn polys(&self)->impl Iterator<Item=&[VertexId]>{
+		self.0.iter().map(|poly|poly.as_slice())
+	}
+}
+impl MapVertexId for PolygonList{
+	fn map_vertex_id<F:Fn(VertexId)->VertexId>(self,f:F)->Self{
+		Self(self.0.into_iter().map(|ivl|ivl.into_iter().map(&f).collect()).collect())
+	}
+}
+// pub struct TriangleStrip(IndexedVertexList);
+// impl PolygonIter for TriangleStrip{
+// 	fn polys(&self)->impl Iterator<Item=&[VertexId]>{
+// 		self.0.vertices.windows(3).enumerate().map(|(i,s)|if i&0!=0{return s.iter().rev()}else{return s.iter()})
+// 	}
+// }
 #[derive(Clone,Copy,Hash,id::Id,PartialEq,Eq)]
 pub struct PolygonGroupId(u32);
 #[derive(Clone)]
 pub enum PolygonGroup{
-	TriangleList(TriangleList),
+	PolygonList(PolygonList),
 	//TriangleStrip(TriangleStrip),
 }
-
+impl PolygonIter for PolygonGroup{
+	fn polys(&self)->impl Iterator<Item=&[VertexId]>{
+		match self{
+			PolygonGroup::PolygonList(list)=>list.polys(),
+			//PolygonGroup::TriangleStrip(strip)=>strip.polys(),
+		}
+	}
+}
+impl MapVertexId for PolygonGroup{
+	fn map_vertex_id<F:Fn(VertexId)->VertexId>(self,f:F)->Self{
+		match self{
+			PolygonGroup::PolygonList(polys)=>Self::PolygonList(polys.map_vertex_id(f)),
+		}
+	}
+}
 /// Ah yes, a group of things to render at the same time
 #[derive(Clone,Copy,Debug,Hash,id::Id,Eq,PartialEq)]
 pub struct TextureId(u32);
@@ -80,8 +109,8 @@ pub struct IndexedPhysicsGroup{
 pub struct MeshId(u32);
 #[derive(Clone)]
 pub struct Mesh{
-	pub unique_pos:Vec<Planar32Vec3>,
-	pub unique_normal:Vec<Planar32Vec3>,
+	pub unique_pos:Vec<Planar64Vec3>,//Unit32Vec3
+	pub unique_normal:Vec<Planar64Vec3>,//Unit32Vec3
 	pub unique_tex:Vec<TextureCoordinate>,
 	pub unique_color:Vec<Color4>,
 	pub unique_vertices:Vec<IndexedVertex>,
@@ -98,13 +127,13 @@ pub struct Mesh{
 
 #[derive(Default)]
 pub struct MeshBuilder{
-	unique_pos:Vec<Planar32Vec3>,
-	unique_normal:Vec<Planar32Vec3>,
+	unique_pos:Vec<Planar64Vec3>,//Unit32Vec3
+	unique_normal:Vec<Planar64Vec3>,//Unit32Vec3
 	unique_tex:Vec<TextureCoordinate>,
 	unique_color:Vec<Color4>,
 	unique_vertices:Vec<IndexedVertex>,
-	pos_id_from:HashMap<Planar32Vec3,PositionId>,
-	normal_id_from:HashMap<Planar32Vec3,NormalId>,
+	pos_id_from:HashMap<Planar64Vec3,PositionId>,//Unit32Vec3
+	normal_id_from:HashMap<Planar64Vec3,NormalId>,//Unit32Vec3
 	tex_id_from:HashMap<[u32;2],TextureCoordinateId>,
 	color_id_from:HashMap<[u32;4],ColorId>,
 	vertex_id_from:HashMap<IndexedVertex,VertexId>,
@@ -138,14 +167,19 @@ impl MeshBuilder{
 			physics_groups,
 		}
 	}
-	pub fn acquire_pos_id(&mut self,pos:Planar32Vec3)->PositionId{
+	pub fn acquire_pos_id(&mut self,pos:Planar64Vec3)->PositionId{
+		// Truncate the 16 most precise bits of the vertex positions.
+		// This allows the normal vectors to exactly represent the face.
+		// Remove this in Mesh V2
+		const MASK:Planar64=Planar64::raw(!((1<<16)-1));
+		let pos=pos.map(|c|c&MASK);
 		*self.pos_id_from.entry(pos).or_insert_with(||{
 			let pos_id=PositionId::new(self.unique_pos.len() as u32);
 			self.unique_pos.push(pos);
 			pos_id
 		})
 	}
-	pub fn acquire_normal_id(&mut self,normal:Planar32Vec3)->NormalId{
+	pub fn acquire_normal_id(&mut self,normal:Planar64Vec3)->NormalId{
 		*self.normal_id_from.entry(normal).or_insert_with(||{
 			let normal_id=NormalId::new(self.unique_normal.len() as u32);
 			self.unique_normal.push(normal);
@@ -183,6 +217,5 @@ pub struct Model{
 	pub mesh:MeshId,
 	pub attributes:gameplay_attributes::CollisionAttributesId,
 	pub color:Color4,//transparency is in here
-	pub matrix3:Planar32Mat3,
-	pub translation:Planar64Vec3,
+	pub transform:Planar64Affine3,
 }

lib/rbx_loader/src/lib.rs

@@ -12,7 +12,7 @@ mod mesh;
 mod error;
 mod union;
 pub mod loader;
-mod primitives;
+pub mod primitives;
 
 pub mod data{
 	pub struct RobloxMeshBytes(Vec<u8>);

lib/rbx_loader/src/mesh.rs

@@ -3,7 +3,7 @@ use std::collections::HashMap;
 use rbx_mesh::mesh::{Vertex2,Vertex2Truncated};
 use strafesnet_common::aabb::Aabb;
 use strafesnet_common::integer::vec3;
-use strafesnet_common::model::{self,ColorId,IndexedVertex,NormalId,PolygonGroup,Triangle,TriangleList,PositionId,RenderConfigId,TextureCoordinateId,VertexId};
+use strafesnet_common::model::{self,ColorId,IndexedVertex,PolygonGroup,PolygonList,RenderConfigId,VertexId};
 
 use crate::loader::MeshWithSize;
 
@@ -67,8 +67,8 @@ fn ingest_faces2_lods3(
 ){
 	//faces have to be split into polygon groups based on lod
 	polygon_groups.extend(lods.windows(2).map(|lod_pair|
-		PolygonGroup::TriangleList(TriangleList::new(faces[lod_pair[0].0 as usize..lod_pair[1].0 as usize].iter().map(|rbx_mesh::mesh::Face2(v0,v1,v2)|
-			Triangle::new([vertex_id_map[&v0],vertex_id_map[&v1],vertex_id_map[&v2]])
+		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()))
 	))
 }
@@ -90,7 +90,7 @@ pub fn convert(roblox_mesh_bytes:crate::data::RobloxMeshBytes)->Result<MeshWithS
 					};
 					Ok(mb.acquire_vertex_id(vertex))
 				};
-				Ok(Triangle::new([ingest_vertex1(&trip[0])?,ingest_vertex1(&trip[1])?,ingest_vertex1(&trip[2])?))
+				Ok(vec![ingest_vertex1(&trip[0])?,ingest_vertex1(&trip[1])?,ingest_vertex1(&trip[2])?])
 			}).collect::<Result<_,_>>().map_err(Error::Planar64Vec3)?)));
 		},
 		rbx_mesh::mesh::Mesh::V2(mesh)=>{
@@ -103,8 +103,8 @@ pub fn convert(roblox_mesh_bytes:crate::data::RobloxMeshBytes)->Result<MeshWithS
 				rbx_mesh::mesh::SizeOfVertex2::Full=>ingest_vertices2(mesh.vertices,&mut mb),
 			}?;
 			//one big happy group for all the faces
-			polygon_groups.push(PolygonGroup::TriangleList(TriangleList::new(mesh.faces.into_iter().map(|face|
-				Triangle::new([vertex_id_map[&face.0],vertex_id_map[&face.1],vertex_id_map[&face.2]])
+			polygon_groups.push(PolygonGroup::PolygonList(PolygonList::new(mesh.faces.into_iter().map(|face|
+				vec![vertex_id_map[&face.0],vertex_id_map[&face.1],vertex_id_map[&face.2]]
 			).collect())));
 		},
 		rbx_mesh::mesh::Mesh::V3(mesh)=>{