physics: monomorphise MeshQuery over AsRef

This reverts commit 65b49d27261754903b2e39194c80ac096afc1da2.

.cargo/config.toml

@@ -1,2 +1,2 @@
 [registries.strafesnet]
-index = "sparse+https://git.itzana.me/api/packages/strafesnet/cargo/"
+index = "sparse+https://git.itzana.me/api/packages/strafesnet/cargo/"

Cargo.toml

@@ -1,5 +1,10 @@
 [workspace]
 members = [
+	"engine/graphics",
+	"engine/physics",
+	"engine/session",
+	"engine/settings",
+	"integration-testing",
 	"lib/bsp_loader",
 	"lib/common",
 	"lib/deferred_loader",
@@ -7,8 +12,10 @@ members = [
 	"lib/linear_ops",
 	"lib/ratio_ops",
 	"lib/rbx_loader",
+	"lib/rbxassetid",
 	"lib/roblox_emulator",
 	"lib/snf",
+	"map-tool",
 	"strafe-client",
 ]
 resolver = "2"

README.md

@@ -3,6 +3,9 @@
 # Strafe Project
 Monorepo for working on projects related to strafe client.
 
+## Try it out
+See [releases](https://git.itzana.me/StrafesNET/strafe-project/releases) for downloads.
+
 ## How to build and run
 1. Have rust and git installed
 2. `git clone https://git.itzana.me/StrafesNET/strafe-project`
@@ -10,4 +13,4 @@ Monorepo for working on projects related to strafe client.
 4. `cargo run --release --bin strafe-client`
 
 ## Licenses
-Each project has its own license.  Most crates are MIT/Apache but notably the Strafe Client has a sole proprietor license.
+Each project has its own license.  Most crates are MIT/Apache but notably the Strafe Client and engine crates have a sole proprietor license.

engine/graphics/Cargo.toml

@@ -0,0 +1,14 @@
+[package]
+name = "strafesnet_graphics"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+bytemuck = { version = "1.13.1", features = ["derive"] }
+ddsfile = "0.5.1"
+glam = "0.30.0"
+id = { version = "0.1.0", registry = "strafesnet" }
+strafesnet_common = { path = "../../lib/common", registry = "strafesnet" }
+strafesnet_session = { path = "../session", registry = "strafesnet" }
+strafesnet_settings = { path = "../settings", registry = "strafesnet" }
+wgpu = "24.0.0"

engine/graphics/LICENSE

@@ -0,0 +1,8 @@
+/*******************************************************
+* Copyright (C) 2023-2024 Rhys Lloyd <krakow20@gmail.com>
+*
+* This file is part of the StrafesNET bhop/surf client.
+*
+* StrafesNET can not be copied and/or distributed
+* without the express permission of Rhys Lloyd
+*******************************************************/

engine/graphics/src/graphics.rs

@@ -1,10 +1,15 @@
 use std::borrow::Cow;
 use std::collections::{HashSet,HashMap};
 use strafesnet_common::map;
-use strafesnet_common::integer;
+use strafesnet_settings::settings;
+use strafesnet_session::session;
 use strafesnet_common::model::{self, ColorId, NormalId, PolygonIter, PositionId, RenderConfigId, TextureCoordinateId, VertexId};
 use wgpu::{util::DeviceExt,AstcBlock,AstcChannel};
-use crate::model_graphics::{self,IndexedGraphicsMeshOwnedRenderConfig,IndexedGraphicsMeshOwnedRenderConfigId,GraphicsMeshOwnedRenderConfig,GraphicsModelColor4,GraphicsModelOwned,GraphicsVertex};
+use crate::model::{self as model_graphics,IndexedGraphicsMeshOwnedRenderConfig,IndexedGraphicsMeshOwnedRenderConfigId,GraphicsMeshOwnedRenderConfig,GraphicsModelColor4,GraphicsModelOwned,GraphicsVertex};
+
+pub fn required_limits()->wgpu::Limits{
+	wgpu::Limits::default()
+}
 
 struct Indices{
 	count:u32,
@@ -98,12 +103,6 @@ impl std::default::Default for GraphicsCamera{
 	}
 }
 
-pub struct FrameState{
-	pub body:crate::physics::Body,
-	pub camera:crate::physics::PhysicsCamera,
-	pub time:integer::Time,
-}
-
 pub struct GraphicsState{
 	pipelines:GraphicsPipelines,
 	bind_groups:GraphicsBindGroups,
@@ -143,7 +142,7 @@ impl GraphicsState{
 	pub fn clear(&mut self){
 		self.models.clear();
 	}
-	pub fn load_user_settings(&mut self,user_settings:&crate::settings::UserSettings){
+	pub fn load_user_settings(&mut self,user_settings:&settings::UserSettings){
 		self.camera.fov=user_settings.calculate_fov(1.0,&self.camera.screen_size).as_vec2();
 	}
 	pub fn generate_models(&mut self,device:&wgpu::Device,queue:&wgpu::Queue,map:&map::CompleteMap){
@@ -455,7 +454,7 @@ impl GraphicsState{
 		//.into_iter() the modeldata vec so entities can be /moved/ to models.entities
 		let mut model_count=0;
 		let mut instance_count=0;
-		let uniform_buffer_binding_size=crate::setup::required_limits().max_uniform_buffer_binding_size as usize;
+		let uniform_buffer_binding_size=required_limits().max_uniform_buffer_binding_size as usize;
 		let chunk_size=uniform_buffer_binding_size/MODEL_BUFFER_SIZE_BYTES;
 		self.models.reserve(models.len());
 		for model in models.into_iter(){
@@ -615,7 +614,7 @@ impl GraphicsState{
 		// Create the render pipeline
 		let shader=device.create_shader_module(wgpu::ShaderModuleDescriptor{
 			label:None,
-			source:wgpu::ShaderSource::Wgsl(Cow::Borrowed(include_str!("shader.wgsl"))),
+			source:wgpu::ShaderSource::Wgsl(Cow::Borrowed(include_str!("../../../strafe-client/src/shader.wgsl"))),
 		});
 
 		//load textures
@@ -643,10 +642,10 @@ impl GraphicsState{
 				wgpu::TextureFormat::Astc{
 					block:AstcBlock::B4x4,
 					channel:AstcChannel::UnormSrgb,
-				}=>&include_bytes!("../images/astc.dds")[..],
-				wgpu::TextureFormat::Etc2Rgb8UnormSrgb=>&include_bytes!("../images/etc2.dds")[..],
-				wgpu::TextureFormat::Bc1RgbaUnormSrgb=>&include_bytes!("../images/bc1.dds")[..],
-				wgpu::TextureFormat::Bgra8UnormSrgb=>&include_bytes!("../images/bgra.dds")[..],
+				}=>&include_bytes!("../../../strafe-client/images/astc.dds")[..],
+				wgpu::TextureFormat::Etc2Rgb8UnormSrgb=>&include_bytes!("../../../strafe-client/images/etc2.dds")[..],
+				wgpu::TextureFormat::Bc1RgbaUnormSrgb=>&include_bytes!("../../../strafe-client/images/bc1.dds")[..],
+				wgpu::TextureFormat::Bgra8UnormSrgb=>&include_bytes!("../../../strafe-client/images/bgra.dds")[..],
 				_=>unreachable!(),
 			};
 
@@ -689,7 +688,7 @@ impl GraphicsState{
 
 		//squid
 		let squid_texture_view={
-			let bytes=include_bytes!("../images/squid.dds");
+			let bytes=include_bytes!("../../../strafe-client/images/squid.dds");
 
 			let image=ddsfile::Dds::read(&mut std::io::Cursor::new(bytes)).unwrap();
 
@@ -871,7 +870,7 @@ impl GraphicsState{
 		&mut self,
 		device:&wgpu::Device,
 		config:&wgpu::SurfaceConfiguration,
-		user_settings:&crate::settings::UserSettings,
+		user_settings:&settings::UserSettings,
 	){
 		self.depth_view=Self::create_depth_texture(config,device);
 		self.camera.screen_size=glam::uvec2(config.width,config.height);
@@ -882,7 +881,7 @@ impl GraphicsState{
 		view:&wgpu::TextureView,
 		device:&wgpu::Device,
 		queue:&wgpu::Queue,
-		frame_state:FrameState,
+		frame_state:session::FrameState,
 	){
 		//TODO:use scheduled frame times to create beautiful smoothing simulation physics extrapolation assuming no input
 

engine/graphics/src/lib.rs

@@ -0,0 +1,2 @@
+pub mod model;
+pub mod graphics;

engine/physics/Cargo.toml

@@ -0,0 +1,10 @@
+[package]
+name = "strafesnet_physics"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+arrayvec = "0.7.6"
+glam = "0.30.0"
+id = { version = "0.1.0", registry = "strafesnet" }
+strafesnet_common = { path = "../../lib/common", registry = "strafesnet" }

engine/physics/LICENSE

@@ -0,0 +1,8 @@
+/*******************************************************
+* Copyright (C) 2023-2024 Rhys Lloyd <krakow20@gmail.com>
+*
+* This file is part of the StrafesNET bhop/surf client.
+*
+* StrafesNET can not be copied and/or distributed
+* without the express permission of Rhys Lloyd
+*******************************************************/

engine/physics/src/body.rs

@@ -0,0 +1,160 @@
+use strafesnet_common::aabb;
+use strafesnet_common::integer::{self,vec3,Time,Planar64,Planar64Vec3};
+#[derive(Clone,Copy,Debug,Hash)]
+pub struct Body<T>{
+	pub position:Planar64Vec3,//I64 where 2^32 = 1 u
+	pub velocity:Planar64Vec3,//I64 where 2^32 = 1 u/s
+	pub acceleration:Planar64Vec3,//I64 where 2^32 = 1 u/s/s
+	pub time:Time<T>,//nanoseconds x xxxxD!
+}
+impl<T> std::ops::Neg for Body<T>{
+	type Output=Self;
+	fn neg(self)->Self::Output{
+		Self{
+			position:self.position,
+			velocity:-self.velocity,
+			acceleration:self.acceleration,
+			time:-self.time,
+		}
+	}
+}
+
+impl<T> Body<T>
+	where Time<T>:Copy,
+{
+	pub const ZERO:Self=Self::new(vec3::ZERO,vec3::ZERO,vec3::ZERO,Time::ZERO);
+	pub const fn new(position:Planar64Vec3,velocity:Planar64Vec3,acceleration:Planar64Vec3,time:Time<T>)->Self{
+		Self{
+			position,
+			velocity,
+			acceleration,
+			time,
+		}
+	}
+	pub const fn relative_to<'a>(&'a self,body0:&'a Body<T>)->VirtualBody<'a,T>{
+		//(p0,v0,a0,t0)
+		//(p1,v1,a1,t1)
+		VirtualBody{
+			body0,
+			body1:self,
+		}
+	}
+	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())
+	}
+	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())
+	}
+	pub fn advance_time(&mut self,time:Time<T>){
+		self.position=self.extrapolated_position(time);
+		self.velocity=self.extrapolated_velocity(time);
+		self.time=time;
+	}
+	pub fn extrapolated_position_ratio_dt<Num,Den,N1,D1,N2,N3,D2,N4,T1>(&self,dt:integer::Ratio<Num,Den>)->Planar64Vec3
+		where
+			// Why?
+			// All of this can be removed with const generics because the type can be specified as
+			// Ratio<Fixed<N,NF>,Fixed<D,DF>>
+			// which is known to implement all the necessary traits
+			Num:Copy,
+			Den:Copy+core::ops::Mul<i64,Output=D1>,
+			D1:Copy,
+			Num:core::ops::Mul<Planar64,Output=N1>,
+			Planar64:core::ops::Mul<D1,Output=N2>,
+			N1:core::ops::Add<N2,Output=N3>,
+			Num:core::ops::Mul<N3,Output=N4>,
+			Den:core::ops::Mul<D1,Output=D2>,
+			D2:Copy,
+			Planar64:core::ops::Mul<D2,Output=N4>,
+			N4:integer::Divide<D2,Output=T1>,
+			T1:integer::Fix<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
+	}
+	pub fn extrapolated_velocity_ratio_dt<Num,Den,N1,T1>(&self,dt:integer::Ratio<Num,Den>)->Planar64Vec3
+		where
+			Num:Copy,
+			Den:Copy,
+			Num:core::ops::Mul<Planar64,Output=N1>,
+			Planar64:core::ops::Mul<Den,Output=N1>,
+			N1:integer::Divide<Den,Output=T1>,
+			T1:integer::Fix<Planar64>,
+	{
+		// a*dt + v
+		self.acceleration.map(|elem|(dt*elem).divide().fix())+self.velocity
+	}
+	pub fn advance_time_ratio_dt(&mut self,dt:crate::model::GigaTime){
+		self.position=self.extrapolated_position_ratio_dt(dt);
+		self.velocity=self.extrapolated_velocity_ratio_dt(dt);
+		self.time+=dt.into();
+	}
+	pub fn infinity_dir(&self)->Option<Planar64Vec3>{
+		if self.velocity==vec3::ZERO{
+			if self.acceleration==vec3::ZERO{
+				None
+			}else{
+				Some(self.acceleration)
+			}
+		}else{
+			Some(self.velocity)
+		}
+	}
+	pub fn grow_aabb(&self,aabb:&mut aabb::Aabb,t0:Time<T>,t1:Time<T>){
+		aabb.grow(self.extrapolated_position(t0));
+		aabb.grow(self.extrapolated_position(t1));
+		//v+a*t==0
+		//goober code
+		if !self.acceleration.x.is_zero(){
+			let t=-self.velocity.x/self.acceleration.x;
+			if t0.to_ratio().lt_ratio(t)&&t.lt_ratio(t1.to_ratio()){
+				aabb.grow(self.extrapolated_position_ratio_dt(t));
+			}
+		}
+		if !self.acceleration.y.is_zero(){
+			let t=-self.velocity.y/self.acceleration.y;
+			if t0.to_ratio().lt_ratio(t)&&t.lt_ratio(t1.to_ratio()){
+				aabb.grow(self.extrapolated_position_ratio_dt(t));
+			}
+		}
+		if !self.acceleration.z.is_zero(){
+			let t=-self.velocity.z/self.acceleration.z;
+			if t0.to_ratio().lt_ratio(t)&&t.lt_ratio(t1.to_ratio()){
+				aabb.grow(self.extrapolated_position_ratio_dt(t));
+			}
+		}
+	}
+
+}
+impl<T> std::fmt::Display for Body<T>{
+	fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
+		write!(f,"p({}) v({}) a({}) t({})",self.position,self.velocity,self.acceleration,self.time)
+	}
+}
+
+pub struct VirtualBody<'a,T>{
+	body0:&'a Body<T>,
+	body1:&'a Body<T>,
+}
+impl<T> VirtualBody<'_,T>
+	where Time<T>:Copy,
+{
+	pub fn extrapolated_position(&self,time:Time<T>)->Planar64Vec3{
+		self.body1.extrapolated_position(time)-self.body0.extrapolated_position(time)
+	}
+	pub fn extrapolated_velocity(&self,time:Time<T>)->Planar64Vec3{
+		self.body1.extrapolated_velocity(time)-self.body0.extrapolated_velocity(time)
+	}
+	pub fn acceleration(&self)->Planar64Vec3{
+		self.body1.acceleration-self.body0.acceleration
+	}
+	pub fn body(&self,time:Time<T>)->Body<T>{
+		Body::new(self.extrapolated_position(time),self.extrapolated_velocity(time),self.acceleration(),time)
+	}
+}

engine/physics/src/face_crawler.rs

@@ -1,23 +1,48 @@
-use crate::physics::Body;
-use crate::model_physics::{GigaTime,FEV,MeshQuery,DirectedEdge,MinkowskiMesh,MinkowskiFace,MinkowskiDirectedEdge,MinkowskiVert};
-use strafesnet_common::integer::{Time,Fixed,Ratio};
+use crate::model::{GigaTime,FEV,MeshQuery,DirectedEdge};
+use strafesnet_common::integer::{Fixed,Ratio,vec3::Vector3};
+use crate::physics::{Time,Body};
 
-#[derive(Debug)]
-enum Transition<F,E:DirectedEdge,V>{
+enum Transition<M:MeshQuery>{
 	Miss,
-	Next(FEV<F,E,V>,GigaTime),
-	Hit(F,GigaTime),
+	Next(FEV<M>,GigaTime),
+	Hit(M::Face,GigaTime),
 }
 
-type MinkowskiFEV=FEV<MinkowskiFace,MinkowskiDirectedEdge,MinkowskiVert>;
-type MinkowskiTransition=Transition<MinkowskiFace,MinkowskiDirectedEdge,MinkowskiVert>;
+pub enum CrawlResult<M:MeshQuery>{
+	Miss(FEV<M>),
+	Hit(M::Face,GigaTime),
+}
+impl<M:MeshQuery> CrawlResult<M>{
+	pub fn hit(self)->Option<(M::Face,GigaTime)>{
+		match self{
+			CrawlResult::Miss(_)=>None,
+			CrawlResult::Hit(face,time)=>Some((face,time)),
+		}
+	}
+	pub fn miss(self)->Option<FEV<M>>{
+		match self{
+			CrawlResult::Miss(fev)=>Some(fev),
+			CrawlResult::Hit(_,_)=>None,
+		}
+	}
+}
 
-	fn next_transition(fev:&MinkowskiFEV,body_time:GigaTime,mesh:&MinkowskiMesh,body:&Body,mut best_time:GigaTime)->MinkowskiTransition{
+impl<F:Copy,M:MeshQuery<Normal=Vector3<F>,Offset=Fixed<4,128>>> FEV<M>
+	where
+		// This is hardcoded for MinkowskiMesh lol
+		M::Face:Copy,
+		M::Edge:Copy,
+		M::Vert:Copy,
+		F:core::ops::Mul<Fixed<1,32>,Output=Fixed<4,128>>,
+		<F as core::ops::Mul<Fixed<1,32>>>::Output:core::iter::Sum,
+		<M 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>{
 		//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=MinkowskiTransition::Miss;
-		match fev{
-			&MinkowskiFEV::Face(face_id)=>{
+		let mut best_transition=Transition::Miss;
+		match self{
+			&FEV::Face(face_id)=>{
 				//test own face collision time, ignoring roots with zero or conflicting derivative
 				//n=face.normal d=face.dot
 				//n.a t^2+n.v t+n.p-d==0
@@ -27,33 +52,34 @@ type MinkowskiTransition=Transition<MinkowskiFace,MinkowskiDirectedEdge,Minkowsk
 				for dt in Fixed::<4,128>::zeroes2((n.dot(body.position)-d)*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(){
 						best_time=dt;
-						best_transition=MinkowskiTransition::Hit(face_id,dt);
+						best_transition=Transition::Hit(face_id,dt);
 						break;
 					}
 				}
 				//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()){
+					for dt in Fixed::<4,128>::zeroes2(n.dot(body.position*2-(mesh.vert(v0)+mesh.vert(v1))).fix_4(),n.dot(body.velocity).fix_4()*2,n.dot(body.acceleration).fix_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=MinkowskiTransition::Next(MinkowskiFEV::Edge(directed_edge_id.as_undirected()),dt);
+							best_transition=Transition::Next(FEV::Edge(directed_edge_id.as_undirected()),dt);
 							break;
 						}
 					}
 				}
 				//if none:
 			},
-			&MinkowskiFEV::Edge(edge_id)=>{
+			&FEV::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);
@@ -61,36 +87,36 @@ type MinkowskiTransition=Transition<MinkowskiFace,MinkowskiDirectedEdge,Minkowsk
 					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()){
 						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=MinkowskiTransition::Next(MinkowskiFEV::Face(edge_face_id),dt);
+							best_transition=Transition::Next(FEV::Face(edge_face_id),dt);
 							break;
 						}
 					}
 				}
 				//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());
 							best_time=dt;
-							best_transition=MinkowskiTransition::Next(MinkowskiFEV::Vert(vert_id),dt);
+							best_transition=Transition::Next(FEV::Vert(vert_id),dt);
 							break;
 						}
 					}
 				}
 				//if none:
 			},
-			&MinkowskiFEV::Vert(vert_id)=>{
+			&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());
 							best_time=dt;
-							best_transition=MinkowskiTransition::Next(MinkowskiFEV::Edge(directed_edge_id.as_undirected()),dt);
+							best_transition=Transition::Next(FEV::Edge(directed_edge_id.as_undirected()),dt);
 							break;
 						}
 					}
@@ -100,28 +126,24 @@ type MinkowskiTransition=Transition<MinkowskiFace,MinkowskiDirectedEdge,Minkowsk
 		}
 		best_transition
 	}
-pub enum CrawlResult<F,E:DirectedEdge,V>{
-	Miss(FEV<F,E,V>),
-	Hit(F,GigaTime),
-}
-type MinkowskiCrawlResult=CrawlResult<MinkowskiFace,MinkowskiDirectedEdge,MinkowskiVert>;
-pub fn crawl_fev(mut fev:MinkowskiFEV,mesh:&MinkowskiMesh,relative_body:&Body,start_time:Time,time_limit:Time)->MinkowskiCrawlResult{
-	let mut body_time={
-		let r=(start_time-relative_body.time).to_ratio();
-		Ratio::new(r.num.fix_4(),r.den.fix_4())
-	};
-	let time_limit={
-		let r=(time_limit-relative_body.time).to_ratio();
-		Ratio::new(r.num.fix_4(),r.den.fix_4())
-	};
-	for _ in 0..20{
-		match next_transition(&fev,body_time,mesh,relative_body,time_limit){
-			Transition::Miss=>return CrawlResult::Miss(fev),
-			Transition::Next(next_fev,next_time)=>(fev,body_time)=(next_fev,next_time),
-			Transition::Hit(face,time)=>return CrawlResult::Hit(face,time),
+	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())
+		};
+		let time_limit={
+			let r=(time_limit-relative_body.time).to_ratio();
+			Ratio::new(r.num.fix_4(),r.den.fix_4())
+		};
+		for _ in 0..20{
+			match self.next_transition(body_time,mesh,relative_body,time_limit){
+				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),
+			}
 		}
+		//TODO: fix all bugs
+		//println!("Too many iterations!  Using default behaviour instead of crashing...");
+		CrawlResult::Miss(self)
 	}
-	//TODO: fix all bugs
-	//println!("Too many iterations!  Using default behaviour instead of crashing...");
-	CrawlResult::Miss(fev)
 }

engine/physics/src/lib.rs

@@ -0,0 +1,45 @@
+mod body;
+mod push_solve;
+mod face_crawler;
+mod model;
+
+pub mod physics;
+
+// Physics bug fixes can easily desync all bots.
+//
+// When replaying a bot, use the exact physics version which it was recorded with.
+//
+// When validating a new bot, ignore the version and use the latest version,
+// and overwrite the version in the file.
+//
+// Compatible physics versions should be determined
+// empirically at development time via leaderboard resimulation.
+//
+// Compatible physics versions should result in an identical leaderboard state,
+// or the only bots which fail are ones exploiting a surgically patched bug.
+#[derive(Clone,Copy,Hash,Debug,id::Id,Eq,PartialEq,Ord,PartialOrd)]
+pub struct PhysicsVersion(u32);
+pub const VERSION:PhysicsVersion=PhysicsVersion(0);
+const LATEST_COMPATIBLE_VERSION:[u32;1+VERSION.0 as usize]=const{
+	let compat=[0];
+
+	let mut input_version=0;
+	while input_version<compat.len(){
+		// compatible version must be greater than or equal to the input version
+		assert!(input_version as u32<=compat[input_version]);
+		// compatible version must be a version that exists
+		assert!(compat[input_version]<=VERSION.0);
+		input_version+=1;
+	}
+	compat
+};
+pub enum PhysicsVersionError{
+	UnknownPhysicsVersion,
+}
+pub const fn get_latest_compatible_version(PhysicsVersion(version):PhysicsVersion)->Result<PhysicsVersion,PhysicsVersionError>{
+	if (version as usize)<LATEST_COMPATIBLE_VERSION.len(){
+		Ok(PhysicsVersion(LATEST_COMPATIBLE_VERSION[version as usize]))
+	}else{
+		Err(PhysicsVersionError::UnknownPhysicsVersion)
+	}
+}

engine/physics/src/model.rs

@@ -1,8 +1,18 @@
-use std::borrow::{Borrow,Cow};
 use std::collections::{HashSet,HashMap};
+use core::ops::Range;
 use strafesnet_common::integer::vec3::Vector3;
 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>;
+
+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;
@@ -51,10 +61,10 @@ impl DirectedEdge for SubmeshDirectedEdgeId{
 
 //Vertex <-> Edge <-> Face -> Collide
 #[derive(Debug)]
-pub enum FEV<F,E:DirectedEdge,V>{
-	Face(F),
-	Edge(E::UndirectedEdge),
-	Vert(V),
+pub enum FEV<M:MeshQuery>{
+	Face(M::Face),
+	Edge(<M::Edge as DirectedEdge>::UndirectedEdge),
+	Vert(M::Vert),
 }
 
 //use Unit32 #[repr(C)] for map files
@@ -64,25 +74,28 @@ struct Face{
 	dot:Planar64,
 }
 struct Vert(Planar64Vec3);
-pub trait MeshQuery<FACE:Clone,EDGE:Clone+DirectedEdge,VERT:Clone>{
+pub trait MeshQuery{
+	type Face:Copy;
+	type Edge:Copy+DirectedEdge;
+	type Vert:Copy;
 	// Vertex must be Planar64Vec3 because it represents an actual position
 	type Normal;
 	type Offset;
-	fn edge_n(&self,edge_id:EDGE::UndirectedEdge)->Planar64Vec3{
-		let verts=self.edge_verts(edge_id);
-		self.vert(verts[1].clone())-self.vert(verts[0].clone())
+	fn edge_n(&self,edge_id:<Self::Edge as DirectedEdge>::UndirectedEdge)->Planar64Vec3{
+		let &[v0,v1]=self.edge_verts(edge_id).as_ref();
+		self.vert(v1)-self.vert(v0)
 	}
-	fn directed_edge_n(&self,directed_edge_id: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)
+	fn directed_edge_n(&self,directed_edge_id:Self::Edge)->Planar64Vec3{
+		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:VERT)->Planar64Vec3;
-	fn face_nd(&self,face_id:FACE)->(Self::Normal,Self::Offset);
-	fn face_edges(&self,face_id:FACE)->Cow<Vec<EDGE>>;
-	fn edge_faces(&self,edge_id:EDGE::UndirectedEdge)->Cow<[FACE;2]>;
-	fn edge_verts(&self,edge_id:EDGE::UndirectedEdge)->Cow<[VERT;2]>;
-	fn vert_edges(&self,vert_id:VERT)->Cow<Vec<EDGE>>;
-	fn vert_faces(&self,vert_id:VERT)->Cow<Vec<FACE>>;
+	fn vert(&self,vert_id:Self::Vert)->Planar64Vec3;
+	fn face_nd(&self,face_id:Self::Face)->(Self::Normal,Self::Offset);
+	fn face_edges(&self,face_id:Self::Face)->impl AsRef<[Self::Edge]>;
+	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]>;
 }
 struct FaceRefs{
 	edges:Vec<SubmeshDirectedEdgeId>,
@@ -273,15 +286,12 @@ struct EdgePool{
 }
 impl EdgePool{
 	fn push(&mut self,edge_ref_verts:EdgeRefVerts)->(&mut EdgeRefFaces,SubmeshEdgeId){
-		let edge_id=if let Some(&edge_id)=self.edge_id_from_guy.get(&edge_ref_verts){
-			edge_id
-		}else{
+		let edge_id=*self.edge_id_from_guy.entry(edge_ref_verts.clone()).or_insert_with(||{
 			let edge_id=SubmeshEdgeId::new(self.edge_guys.len() as u32);
-			self.edge_guys.push((edge_ref_verts.clone(),EdgeRefFaces::new()));
-			self.edge_id_from_guy.insert(edge_ref_verts,edge_id);
+			self.edge_guys.push((edge_ref_verts,EdgeRefFaces::new()));
 			edge_id
-		};
-		(&mut unsafe{self.edge_guys.get_unchecked_mut(edge_id.get() as usize)}.1,edge_id)
+		});
+		(&mut self.edge_guys[edge_id.get() as usize].1,edge_id)
 	}
 }
 
@@ -316,16 +326,11 @@ impl TryFrom<&model::Mesh> for PhysicsMesh{
 			let mut submesh_verts=Vec::new();
 			let mut submesh_vert_id_from_mesh_vert_id=HashMap::<MeshVertId,SubmeshVertId>::new();
 			//lazy closure
-			let mut get_submesh_vert_id=|vert_id:MeshVertId|{
-				if let Some(&submesh_vert_id)=submesh_vert_id_from_mesh_vert_id.get(&vert_id){
-					submesh_vert_id
-				}else{
-					let submesh_vert_id=SubmeshVertId::new(submesh_verts.len() as u32);
-					submesh_verts.push(vert_id);
-					submesh_vert_id_from_mesh_vert_id.insert(vert_id,submesh_vert_id);
-					submesh_vert_id
-				}
-			};
+			let mut get_submesh_vert_id=|vert_id:MeshVertId|*submesh_vert_id_from_mesh_vert_id.entry(vert_id).or_insert_with(||{
+				let submesh_vert_id=SubmeshVertId::new(submesh_verts.len() as u32);
+				submesh_verts.push(vert_id);
+				submesh_vert_id
+			});
 			let mut edge_pool=EdgePool::default();
 			let mut vert_ref_guys=vec![VertRefGuy::default();mesh.unique_pos.len()];
 			let mut face_ref_guys=Vec::new();
@@ -358,10 +363,10 @@ impl TryFrom<&model::Mesh> for PhysicsMesh{
 						edge_ref_faces.push(!is_sorted as usize,submesh_face_id);
 						//index edges & face into vertices
 						{
-							let vert_ref_guy=unsafe{vert_ref_guys.get_unchecked_mut(submesh_vert0_id.get() as usize)};
+							let vert_ref_guy=&mut vert_ref_guys[submesh_vert0_id.get() as usize];
 							vert_ref_guy.edges.insert(edge_id.as_directed(is_sorted));
 							vert_ref_guy.faces.insert(submesh_face_id);
-							unsafe{vert_ref_guys.get_unchecked_mut(submesh_vert1_id.get() as usize)}.edges.insert(edge_id.as_directed(!is_sorted));
+							vert_ref_guys[submesh_vert1_id.get() as usize].edges.insert(edge_id.as_directed(!is_sorted));
 						}
 						//return directed_edge_id
 						edge_id.as_directed(is_sorted)
@@ -421,7 +426,10 @@ pub struct PhysicsMeshView<'a>{
 	data:&'a PhysicsMeshData,
 	topology:&'a PhysicsMeshTopology,
 }
-impl MeshQuery<SubmeshFaceId,SubmeshDirectedEdgeId,SubmeshVertId> for PhysicsMeshView<'_>{
+impl MeshQuery for PhysicsMeshView<'_>{
+	type Face=SubmeshFaceId;
+	type Edge=SubmeshDirectedEdgeId;
+	type Vert=SubmeshVertId;
 	type Normal=Planar64Vec3;
 	type Offset=Planar64;
 	fn face_nd(&self,face_id:SubmeshFaceId)->(Planar64Vec3,Planar64){
@@ -433,20 +441,20 @@ impl MeshQuery<SubmeshFaceId,SubmeshDirectedEdgeId,SubmeshVertId> for PhysicsMes
 		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<Vec<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<Vec<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<Vec<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()
 	}
 }
 
@@ -482,12 +490,15 @@ impl TransformedMesh<'_>{
 	pub fn verts<'a>(&'a self)->impl Iterator<Item=vec3::Vector3<Fixed<2,64>>>+'a{
 		self.view.data.verts.iter().map(|&Vert(pos)|self.transform.vertex.transform_point3(pos))
 	}
+	pub fn faces(&self)->impl Iterator<Item=SubmeshFaceId>{
+		(0..self.view.topology.faces.len() as u32).map(SubmeshFaceId::new)
+	}
 	fn farthest_vert(&self,dir:Planar64Vec3)->SubmeshVertId{
 		//this happens to be well-defined.  there are no virtual virtices
 		SubmeshVertId::new(
 			self.view.topology.verts.iter()
 			.enumerate()
-			.max_by_key(|(_,&vert_id)|
+			.max_by_key(|&(_,&vert_id)|
 				dir.dot(self.transform.vertex.transform_point3(self.view.data.verts[vert_id.get() as usize].0))
 			)
 			//assume there is more than zero vertices.
@@ -495,7 +506,10 @@ impl TransformedMesh<'_>{
 		)
 	}
 }
-impl MeshQuery<SubmeshFaceId,SubmeshDirectedEdgeId,SubmeshVertId> for TransformedMesh<'_>{
+impl MeshQuery for TransformedMesh<'_>{
+	type Face=SubmeshFaceId;
+	type Edge=SubmeshDirectedEdgeId;
+	type Vert=SubmeshVertId;
 	type Normal=Vector3<Fixed<3,96>>;
 	type Offset=Fixed<4,128>;
 	fn face_nd(&self,face_id:SubmeshFaceId)->(Self::Normal,Self::Offset){
@@ -508,23 +522,23 @@ impl MeshQuery<SubmeshFaceId,SubmeshDirectedEdgeId,SubmeshVertId> for Transforme
 		self.transform.vertex.transform_point3(self.view.vert(vert_id)).fix_1()
 	}
 	#[inline]
-	fn face_edges(&self,face_id:SubmeshFaceId)->Cow<Vec<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<Vec<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<Vec<SubmeshFaceId>>{
+	fn vert_faces(&self,vert_id:SubmeshVertId)->impl AsRef<[SubmeshFaceId]>{
 		self.view.vert_faces(vert_id)
 	}
 }
@@ -613,12 +627,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(){
@@ -634,7 +648,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
@@ -669,22 +683,22 @@ impl MinkowskiMesh<'_>{
 		}
 	}
 	/// This function drops a vertex down to an edge or a face if the path from infinity did not cross any vertex-edge boundaries but the point is supposed to have already crossed a boundary down from a vertex
-	fn infinity_fev(&self,infinity_dir:Planar64Vec3,point:Planar64Vec3)->FEV::<MinkowskiFace,MinkowskiDirectedEdge,MinkowskiVert>{
+	fn infinity_fev(&self,infinity_dir:Planar64Vec3,point:Planar64Vec3)->FEV::<MinkowskiMesh>{
 		//start on any vertex
 		//cross uncrossable vertex-edge boundaries until you find the closest vertex or edge
 		//cross edge-face boundary if it's uncrossable
 		match self.crawl_boundaries(self.farthest_vert(infinity_dir),infinity_dir,point){
 			//if a vert is returned, it is the closest point to the infinity point
-			EV::Vert(vert_id)=>FEV::<MinkowskiFace,MinkowskiDirectedEdge,MinkowskiVert>::Vert(vert_id),
+			EV::Vert(vert_id)=>FEV::Vert(vert_id),
 			EV::Edge(edge_id)=>{
 				//cross to face if the boundary is not crossable and we are on the wrong side
 				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);
@@ -693,71 +707,77 @@ impl MinkowskiMesh<'_>{
 					//infinity_dir can always be treated as a velocity
 					if !boundary_d.is_positive()&&boundary_n.dot(infinity_dir).is_zero(){
 						//both faces cannot pass this condition, return early if one does.
-						return FEV::<MinkowskiFace,MinkowskiDirectedEdge,MinkowskiVert>::Face(face_id);
+						return FEV::Face(face_id);
 					}
 				}
-				FEV::<MinkowskiFace,MinkowskiDirectedEdge,MinkowskiVert>::Edge(edge_id)
+				FEV::Edge(edge_id)
 			},
 		}
 	}
-	fn closest_fev_not_inside(&self,mut infinity_body:crate::physics::Body)->Option<FEV::<MinkowskiFace,MinkowskiDirectedEdge,MinkowskiVert>>{
-		infinity_body.infinity_dir().map_or(None,|dir|{
+	// TODO: fundamentally improve this algorithm.
+	// All it needs to do is find the closest point on the mesh
+	// and return the FEV which the point resides on.
+	//
+	// What it actually does is use the above functions to trace a ray in from infinity,
+	// crawling the closest point along the mesh surface until the ray reaches
+	// the starting point to discover the final FEV.
+	//
+	// The actual collision prediction probably does a single test
+	// and then immediately returns with 0 FEV transitions on average,
+	// because of the strict time_limit constraint.
+	//
+	// Most of the calculation time is just calculating the starting point
+	// for the "actual" crawling algorithm below (predict_collision_{in|out}).
+	fn closest_fev_not_inside(&self,mut infinity_body:Body,start_time:Time)->Option<FEV<MinkowskiMesh>>{
+		infinity_body.infinity_dir().and_then(|dir|{
 			let infinity_fev=self.infinity_fev(-dir,infinity_body.position);
 			//a line is simpler to solve than a parabola
 			infinity_body.velocity=dir;
 			infinity_body.acceleration=vec3::ZERO;
 			//crawl in from negative infinity along a tangent line to get the closest fev
 			// TODO: change crawl_fev args to delta time? Optional values?
-			match crate::face_crawler::crawl_fev(infinity_fev,self,&infinity_body,integer::Time::MIN/4,infinity_body.time){
-				crate::face_crawler::CrawlResult::Miss(fev)=>Some(fev),
-				crate::face_crawler::CrawlResult::Hit(_,_)=>None,
-			}
+			infinity_fev.crawl(self,&infinity_body,Time::MIN/4,start_time).miss()
 		})
 	}
-	pub fn predict_collision_in(&self,relative_body:&crate::physics::Body,time_limit:integer::Time)->Option<(MinkowskiFace,GigaTime)>{
-		self.closest_fev_not_inside(relative_body.clone()).map_or(None,|fev|{
+	pub fn predict_collision_in(&self,relative_body:&Body,Range{start:start_time,end:time_limit}:Range<Time>)->Option<(MinkowskiFace,GigaTime)>{
+		self.closest_fev_not_inside(relative_body.clone(),start_time).and_then(|fev|{
 			//continue forwards along the body parabola
-			match crate::face_crawler::crawl_fev(fev,self,relative_body,relative_body.time,time_limit){
-				crate::face_crawler::CrawlResult::Miss(_)=>None,
-				crate::face_crawler::CrawlResult::Hit(face,time)=>Some((face,time)),
-			}
+			fev.crawl(self,relative_body,start_time,time_limit).hit()
 		})
 	}
-	pub fn predict_collision_out(&self,relative_body:&crate::physics::Body,time_limit:integer::Time)->Option<(MinkowskiFace,GigaTime)>{
+	pub fn predict_collision_out(&self,relative_body:&Body,Range{start:start_time,end:time_limit}:Range<Time>)->Option<(MinkowskiFace,GigaTime)>{
 		//create an extrapolated body at time_limit
-		let infinity_body=crate::physics::Body::new(
-			relative_body.extrapolated_position(time_limit),
-			-relative_body.extrapolated_velocity(time_limit),
-			relative_body.acceleration,
-			-time_limit,
-		);
-		self.closest_fev_not_inside(infinity_body).map_or(None,|fev|{
+		let infinity_body=-relative_body.clone();
+		self.closest_fev_not_inside(infinity_body,-time_limit).and_then(|fev|{
 			//continue backwards along the body parabola
-			match crate::face_crawler::crawl_fev(fev,self,&-relative_body.clone(),-time_limit,-relative_body.time){
-				crate::face_crawler::CrawlResult::Miss(_)=>None,
-				crate::face_crawler::CrawlResult::Hit(face,time)=>Some((face,-time)),//no need to test -time<time_limit because of the first step
-			}
+			fev.crawl(self,&infinity_body,-time_limit,-start_time).hit()
+				//no need to test -time<time_limit because of the first step
+				.map(|(face,time)|(face,-time))
 		})
 	}
-	pub fn predict_collision_face_out(&self,relative_body:&crate::physics::Body,time_limit:integer::Time,contact_face_id:MinkowskiFace)->Option<(MinkowskiEdge,GigaTime)>{
+	pub fn predict_collision_face_out(&self,relative_body:&Body,Range{start:start_time,end:time_limit}:Range<Time>,contact_face_id:MinkowskiFace)->Option<(MinkowskiEdge,GigaTime)>{
 		//no algorithm needed, there is only one state and two cases (Edge,None)
 		//determine when it passes an edge ("sliding off" case)
+		let start_time={
+			let r=(start_time-relative_body.time).to_ratio();
+			Ratio::new(r.num,r.den)
+		};
 		let mut best_time={
 			let r=(time_limit-relative_body.time).to_ratio();
 			Ratio::new(r.num.fix_4(),r.den.fix_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()){
-				if Ratio::new(Planar64::ZERO,Planar64::EPSILON).le_ratio(dt)&&dt.lt_ratio(best_time)&&n.dot(relative_body.extrapolated_velocity_ratio_dt(dt)).is_negative(){
+				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);
 					break;
@@ -766,15 +786,12 @@ impl MinkowskiMesh<'_>{
 		}
 		best_edge.map(|e|(e.as_undirected(),best_time))
 	}
-	fn infinity_in(&self,infinity_body:crate::physics::Body)->Option<(MinkowskiFace,GigaTime)>{
+	fn infinity_in(&self,infinity_body:Body)->Option<(MinkowskiFace,GigaTime)>{
 		let infinity_fev=self.infinity_fev(-infinity_body.velocity,infinity_body.position);
-		match crate::face_crawler::crawl_fev(infinity_fev,self,&infinity_body,integer::Time::MIN/4,infinity_body.time){
-			crate::face_crawler::CrawlResult::Miss(_)=>None,
-			crate::face_crawler::CrawlResult::Hit(face,time)=>Some((face,time)),
-		}
+		infinity_fev.crawl(self,&infinity_body,Time::MIN/4,infinity_body.time).hit()
 	}
 	pub fn is_point_in_mesh(&self,point:Planar64Vec3)->bool{
-		let infinity_body=crate::physics::Body::new(point,vec3::Y,vec3::ZERO,integer::Time::ZERO);
+		let infinity_body=Body::new(point,vec3::Y,vec3::ZERO,Time::ZERO);
 		//movement must escape the mesh forwards and backwards in time,
 		//otherwise the point is not inside the mesh
 		self.infinity_in(infinity_body)
@@ -784,9 +801,13 @@ impl MinkowskiMesh<'_>{
      	)
 	}
 }
-impl MeshQuery<MinkowskiFace,MinkowskiDirectedEdge,MinkowskiVert> for MinkowskiMesh<'_>{
+impl MeshQuery for MinkowskiMesh<'_>{
+	type Face=MinkowskiFace;
+	type Edge=MinkowskiDirectedEdge;
+	type Vert=MinkowskiVert;
 	type Normal=Vector3<Fixed<3,96>>;
 	type Offset=Fixed<4,128>;
+	// TODO: relative d
 	fn face_nd(&self,face_id:MinkowskiFace)->(Self::Normal,Self::Offset){
 		match face_id{
 			MinkowskiFace::VertFace(v0,f1)=>{
@@ -796,8 +817,8 @@ impl MeshQuery<MinkowskiFace,MinkowskiDirectedEdge,MinkowskiVert> for MinkowskiM
 			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));
@@ -816,44 +837,44 @@ impl MeshQuery<MinkowskiFace,MinkowskiDirectedEdge,MinkowskiVert> for MinkowskiM
 			},
 		}
 	}
-	fn face_edges(&self,face_id:MinkowskiFace)->Cow<Vec<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);
@@ -877,13 +898,13 @@ impl MeshQuery<MinkowskiFace,MinkowskiDirectedEdge,MinkowskiVert> for MinkowskiM
 			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;
 					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);
 						let d=edge_face0_n.dot(edge1_n);
 						if d.is_negative(){
@@ -903,31 +924,27 @@ impl MeshQuery<MinkowskiFace,MinkowskiDirectedEdge,MinkowskiVert> for MinkowskiM
 			},
 		}
 	}
-	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<Vec<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
@@ -943,7 +960,7 @@ impl MeshQuery<MinkowskiFace,MinkowskiDirectedEdge,MinkowskiVert> for MinkowskiM
 						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);
@@ -955,12 +972,13 @@ impl MeshQuery<MinkowskiFace,MinkowskiDirectedEdge,MinkowskiVert> for MinkowskiM
 						edges.push(MinkowskiDirectedEdge::VertEdge(v0,directed_edge_id));
 					}
 				}
-				Cow::Owned(edges)
+				edges
 			},
 		}
 	}
-	fn vert_faces(&self,_vert_id:MinkowskiVert)->Cow<Vec<MinkowskiFace>>{
-		unimplemented!()
+	fn vert_faces(&self,_vert_id:MinkowskiVert)->impl AsRef<[MinkowskiFace]>{
+		unimplemented!();
+		vec![]
 	}
 }
 
@@ -973,7 +991,7 @@ fn is_empty_volume(normals:Vec<Vector3<Fixed<3,96>>>)->bool{
 			for k in 0..len{
 				if k!=i&&k!=j{
 					let d=n.dot(normals[k]).is_negative();
-					if let Some(comp)=&d_comp{
+					if let &Some(comp)=&d_comp{
 						// This is testing if d_comp*d < 0
 						if comp^d{
 							return true;
@@ -993,9 +1011,3 @@ 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()));
 }
-
-#[test]
-fn build_me_a_cube(){
-	let mesh=PhysicsMesh::unit_cube();
-	//println!("mesh={:?}",mesh);
-}

engine/physics/src/push_solve.rs

@@ -0,0 +1,333 @@
+use strafesnet_common::integer::vec3::{self,Vector3};
+use strafesnet_common::integer::{Fixed,Planar64Vec3,Ratio};
+use strafesnet_common::ray::Ray;
+
+// This algorithm is based on Lua code
+// written by Trey Reynolds in 2021
+
+// EPSILON=1/2^10
+
+// A stack-allocated variable-size list that holds up to 4 elements
+// Direct references are used instead of indices i0, i1, i2, i3
+type Conts<'a>=arrayvec::ArrayVec<&'a Contact,4>;
+
+// hack to allow comparing ratios to zero
+const RATIO_ZERO:Ratio<Fixed<1,32>,Fixed<1,32>>=Ratio::new(Fixed::ZERO,Fixed::EPSILON);
+
+/// Information about a contact restriction
+pub struct Contact{
+	pub position:Planar64Vec3,
+	pub velocity:Planar64Vec3,
+	pub normal:Planar64Vec3,
+}
+impl Contact{
+	fn relative_to(&self,point:Planar64Vec3)->Self{
+		Self{
+			position:self.position-point,
+			velocity:self.velocity,
+			normal:self.normal,
+		}
+	}
+	fn relative_dot(&self,direction:Planar64Vec3)->Fixed<2,64>{
+		(direction-self.velocity).dot(self.normal)
+	}
+	/// Calculate the time of intersection. (previously get_touch_time)
+	fn solve(&self,ray:&Ray)->Ratio<Fixed<2,64>,Fixed<2,64>>{
+		(self.position-ray.origin).dot(self.normal)/(ray.direction-self.velocity).dot(self.normal)
+	}
+}
+
+//note that this is horrible with fixed point arithmetic
+fn solve1(c0:&Contact)->Option<Ratio<Vector3<Fixed<3,96>>,Fixed<2,64>>>{
+	const EPSILON:Fixed<2,64>=Fixed::from_bits(Fixed::<2,64>::ONE.to_bits().shr(10));
+	let det=c0.normal.dot(c0.velocity);
+	if det.abs()<EPSILON{
+		return None;
+	}
+	let d0=c0.normal.dot(c0.position);
+	Some(c0.normal*d0/det)
+}
+fn solve2(c0:&Contact,c1:&Contact)->Option<Ratio<Vector3<Fixed<5,160>>,Fixed<4,128>>>{
+	const EPSILON:Fixed<4,128>=Fixed::from_bits(Fixed::<4,128>::ONE.to_bits().shr(10));
+	let u0_u1=c0.velocity.cross(c1.velocity);
+	let n0_n1=c0.normal.cross(c1.normal);
+	let det=u0_u1.dot(n0_n1);
+	if det.abs()<EPSILON{
+		return None;
+	}
+	let d0=c0.normal.dot(c0.position);
+	let d1=c1.normal.dot(c1.position);
+	Some((c1.normal.cross(u0_u1)*d0+u0_u1.cross(c0.normal)*d1)/det)
+}
+fn solve3(c0:&Contact,c1:&Contact,c2:&Contact)->Option<Ratio<Vector3<Fixed<4,128>>,Fixed<3,96>>>{
+	const EPSILON:Fixed<3,96>=Fixed::from_bits(Fixed::<3,96>::ONE.to_bits().shr(10));
+	let n0_n1=c0.normal.cross(c1.normal);
+	let det=c2.normal.dot(n0_n1);
+	if det.abs()<EPSILON{
+		return None;
+	}
+	let d0=c0.normal.dot(c0.position);
+	let d1=c1.normal.dot(c1.position);
+	let d2=c2.normal.dot(c2.position);
+	Some((c1.normal.cross(c2.normal)*d0+c2.normal.cross(c0.normal)*d1+c0.normal.cross(c1.normal)*d2)/det)
+}
+
+fn decompose1(point:Planar64Vec3,u0:Planar64Vec3)->Option<[Ratio<Fixed<2,64>,Fixed<2,64>>;1]>{
+	let det=u0.dot(u0);
+	if det==Fixed::ZERO{
+		return None;
+	}
+	let s0=u0.dot(point)/det;
+	Some([s0])
+}
+fn decompose2(point:Planar64Vec3,u0:Planar64Vec3,u1:Planar64Vec3)->Option<[Ratio<Fixed<4,128>,Fixed<4,128>>;2]>{
+	let u0_u1=u0.cross(u1);
+	let det=u0_u1.dot(u0_u1);
+	if det==Fixed::ZERO{
+		return None;
+	}
+	let s0=u0_u1.dot(point.cross(u1))/det;
+	let s1=u0_u1.dot(u0.cross(point))/det;
+	Some([s0,s1])
+}
+fn decompose3(point:Planar64Vec3,u0:Planar64Vec3,u1:Planar64Vec3,u2:Planar64Vec3)->Option<[Ratio<Fixed<3,96>,Fixed<3,96>>;3]>{
+	let det=u0.cross(u1).dot(u2);
+	if det==Fixed::ZERO{
+		return None;
+	}
+	let s0=point.cross(u1).dot(u2)/det;
+	let s1=u0.cross(point).dot(u2)/det;
+	let s2=u0.cross(u1).dot(point)/det;
+	Some([s0,s1,s2])
+}
+
+fn is_space_enclosed_2(
+	a:Planar64Vec3,
+	b:Planar64Vec3,
+)->bool{
+	a.cross(b)==Vector3::new([Fixed::ZERO;3])
+	&&a.dot(b).is_negative()
+}
+fn is_space_enclosed_3(
+	a:Planar64Vec3,
+	b:Planar64Vec3,
+	c:Planar64Vec3
+)->bool{
+	a.cross(b).dot(c)==Fixed::ZERO
+	&&{
+		let det_abac=a.cross(b).dot(a.cross(c));
+		let det_abbc=a.cross(b).dot(b.cross(c));
+		let det_acbc=a.cross(c).dot(b.cross(c));
+		return!( det_abac*det_abbc).is_positive()
+			&&!( det_abbc*det_acbc).is_positive()
+			&&!(-det_acbc*det_abac).is_positive()
+			||is_space_enclosed_2(a,b)
+			||is_space_enclosed_2(a,c)
+			||is_space_enclosed_2(b,c)
+	}
+}
+fn is_space_enclosed_4(
+	a:Planar64Vec3,
+	b:Planar64Vec3,
+	c:Planar64Vec3,
+	d:Planar64Vec3,
+)->bool{
+	let det_abc=a.cross(b).dot(c);
+	let det_abd=a.cross(b).dot(d);
+	let det_acd=a.cross(c).dot(d);
+	let det_bcd=b.cross(c).dot(d);
+	return( det_abc*det_abd).is_negative()
+		&&(-det_abc*det_acd).is_negative()
+		&&( det_abd*det_acd).is_negative()
+		&&( det_abc*det_bcd).is_negative()
+		&&(-det_abd*det_bcd).is_negative()
+		&&( det_acd*det_bcd).is_negative()
+		||is_space_enclosed_3(a,b,c)
+		||is_space_enclosed_3(a,b,d)
+		||is_space_enclosed_3(a,c,d)
+		||is_space_enclosed_3(b,c,d)
+}
+
+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();
+	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();
+	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 [s0,s1]=decompose2(direction,c0.velocity,c1.velocity)?;
+	if s0.lt_ratio(RATIO_ZERO)||s1.lt_ratio(RATIO_ZERO){
+		return None;
+	}
+	let origin=point+solve2(
+		&c0.relative_to(point),
+		&c1.relative_to(point),
+	)?.divide().fix_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 [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;
+	}
+	let origin=point+solve3(
+		&c0.relative_to(point),
+		&c1.relative_to(point),
+		&c2.relative_to(point),
+	)?.divide().fix_1();
+	Some(Ray{origin,direction})
+}
+
+const fn get_best_push_ray_and_conts_0<'a>(point:Planar64Vec3)->(Ray,Conts<'a>){
+	(get_push_ray_0(point),Conts::new_const())
+}
+fn get_best_push_ray_and_conts_1(point:Planar64Vec3,c0:&Contact)->Option<(Ray,Conts)>{
+	get_push_ray_1(point,c0)
+		.map(|ray|(ray,Conts::from_iter([c0])))
+}
+fn get_best_push_ray_and_conts_2<'a>(point:Planar64Vec3,c0:&'a Contact,c1:&'a Contact)->Option<(Ray,Conts<'a>)>{
+	if is_space_enclosed_2(c0.normal,c1.normal){
+		return None;
+	}
+	if let Some(ray)=get_push_ray_2(point,c0,c1){
+		return Some((ray,Conts::from_iter([c0,c1])));
+	}
+	if let Some(ray)=get_push_ray_1(point,c0){
+		if !c1.relative_dot(ray.direction).is_negative(){
+			return Some((ray,Conts::from_iter([c0])));
+		}
+	}
+	return None;
+}
+fn get_best_push_ray_and_conts_3<'a>(point:Planar64Vec3,c0:&'a Contact,c1:&'a Contact,c2:&'a Contact)->Option<(Ray,Conts<'a>)>{
+	if is_space_enclosed_3(c0.normal,c1.normal,c2.normal){
+		return None;
+	}
+	if let Some(ray)=get_push_ray_3(point,c0,c1,c2){
+		return Some((ray,Conts::from_iter([c0,c1,c2])));
+	}
+	if let Some(ray)=get_push_ray_2(point,c0,c1){
+		if !c2.relative_dot(ray.direction).is_negative(){
+			return Some((ray,Conts::from_iter([c0,c1])));
+		}
+	}
+	if let Some(ray)=get_push_ray_2(point,c0,c2){
+		if !c1.relative_dot(ray.direction).is_negative(){
+			return Some((ray,Conts::from_iter([c0,c2])));
+		}
+	}
+	if let Some(ray)=get_push_ray_1(point,c0){
+		if !c1.relative_dot(ray.direction).is_negative()
+		 &&!c2.relative_dot(ray.direction).is_negative(){
+			return Some((ray,Conts::from_iter([c0])));
+		}
+	}
+	return None;
+}
+fn get_best_push_ray_and_conts_4<'a>(point:Planar64Vec3,c0:&'a Contact,c1:&'a Contact,c2:&'a Contact,c3:&'a Contact)->Option<(Ray,Conts<'a>)>{
+	if is_space_enclosed_4(c0.normal,c1.normal,c2.normal,c3.normal){
+		return None;
+	}
+
+	let (ray012,conts012)=get_best_push_ray_and_conts_3(point,c0,c1,c2)?;
+	let (ray013,conts013)=get_best_push_ray_and_conts_3(point,c0,c1,c3)?;
+	let (ray023,conts023)=get_best_push_ray_and_conts_3(point,c0,c2,c3)?;
+
+	let err012=c3.relative_dot(ray012.direction);
+	let err013=c2.relative_dot(ray013.direction);
+	let err023=c1.relative_dot(ray023.direction);
+
+	let best_err=err012.max(err013).max(err023);
+
+	if best_err==err012{
+		return Some((ray012,conts012))
+	}else if best_err==err013{
+		return Some((ray013,conts013))
+	}else if best_err==err023{
+		return Some((ray023,conts023))
+	}
+	unreachable!()
+}
+
+fn get_best_push_ray_and_conts<'a>(
+	point:Planar64Vec3,
+	conts:&[&'a Contact],
+)->Option<(Ray,Conts<'a>)>{
+	match conts{
+		&[c0,c1,c2,c3]=>get_best_push_ray_and_conts_4(point,c0,c1,c2,c3),
+		&[c0,c1,c2]=>get_best_push_ray_and_conts_3(point,c0,c1,c2),
+		&[c0,c1]=>get_best_push_ray_and_conts_2(point,c0,c1),
+		&[c0]=>get_best_push_ray_and_conts_1(point,c0),
+		&[]=>Some(get_best_push_ray_and_conts_0(point)),
+		_=>unreachable!(),
+	}
+}
+
+fn get_first_touch<'a>(contacts:&'a [Contact],ray:&Ray,conts:&Conts)->Option<(Ratio<Fixed<2,64>,Fixed<2,64>>,&'a Contact)>{
+	contacts.iter()
+		.filter(|&contact|
+			!conts.iter().any(|&c|std::ptr::eq(c,contact))
+			&&contact.relative_dot(ray.direction).is_negative()
+		)
+		.map(|contact|(contact.solve(ray),contact))
+		.min_by_key(|&(t,_)|t)
+}
+
+pub fn push_solve(contacts:&[Contact],point:Planar64Vec3)->Planar64Vec3{
+	let (mut ray,mut conts)=get_best_push_ray_and_conts_0(point);
+	loop{
+		let (next_t,next_cont)=match get_first_touch(contacts,&ray,&conts){
+			Some((t,cont))=>(t,cont),
+			None=>return ray.origin,
+		};
+
+		if RATIO_ZERO.le_ratio(next_t){
+			return ray.origin;
+		}
+
+		//push_front
+		if conts.len()==conts.capacity(){
+			//this is a dead case, new_conts never has more than 3 elements
+			conts.rotate_right(1);
+			conts[0]=next_cont;
+		}else{
+			conts.push(next_cont);
+			conts.rotate_right(1);
+		}
+
+		let meet_point=ray.extrapolate(next_t);
+		match get_best_push_ray_and_conts(meet_point,conts.as_slice()){
+			Some((new_ray,new_conts))=>(ray,conts)=(new_ray,new_conts),
+			None=>return meet_point,
+		}
+	}
+}
+
+#[cfg(test)]
+mod tests{
+	use super::*;
+	#[test]
+	fn test_push_solve(){
+		let contacts=vec![
+			Contact{
+				position:vec3::ZERO,
+				velocity:vec3::Y,
+				normal:vec3::Y,
+			}
+		];
+		assert_eq!(
+			vec3::ZERO,
+			push_solve(&contacts,vec3::NEG_Y)
+		);
+	}
+}

engine/session/Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+name = "strafesnet_session"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+glam = "0.30.0"
+replace_with = "0.1.7"
+strafesnet_common = { path = "../../lib/common", registry = "strafesnet" }
+strafesnet_physics = { path = "../physics", registry = "strafesnet" }
+strafesnet_settings = { path = "../settings", registry = "strafesnet" }
+strafesnet_snf = { path = "../../lib/snf", registry = "strafesnet" }

engine/session/LICENSE

@@ -0,0 +1,8 @@
+/*******************************************************
+* Copyright (C) 2023-2024 Rhys Lloyd <krakow20@gmail.com>
+*
+* This file is part of the StrafesNET bhop/surf client.
+*
+* StrafesNET can not be copied and/or distributed
+* without the express permission of Rhys Lloyd
+*******************************************************/

engine/session/src/lib.rs

@@ -0,0 +1,2 @@
+mod mouse_interpolator;
+pub mod session;

engine/session/src/mouse_interpolator.rs

@@ -0,0 +1,282 @@
+use strafesnet_common::mouse::MouseState;
+use strafesnet_common::physics::{
+	MouseInstruction,SetControlInstruction,ModeInstruction,MiscInstruction,
+	Instruction as PhysicsInstruction,
+	TimeInner as PhysicsTimeInner,
+	Time as PhysicsTime,
+};
+use strafesnet_common::session::Time as SessionTime;
+use strafesnet_common::instruction::{InstructionConsumer,InstructionEmitter,TimedInstruction};
+
+type TimedSelfInstruction=TimedInstruction<Instruction,PhysicsTime>;
+type DoubleTimedSelfInstruction=TimedInstruction<TimedSelfInstruction,SessionTime>;
+
+type TimedPhysicsInstruction=TimedInstruction<PhysicsInstruction,PhysicsTime>;
+
+const MOUSE_TIMEOUT:SessionTime=SessionTime::from_millis(10);
+
+/// To be fed into MouseInterpolator
+#[derive(Clone,Debug)]
+pub(crate) enum Instruction{
+	MoveMouse(glam::IVec2),
+	SetControl(SetControlInstruction),
+	Mode(ModeInstruction),
+	Misc(MiscInstruction),
+	Idle,
+}
+#[derive(Clone,Debug)]
+enum UnbufferedInstruction{
+	MoveMouse(glam::IVec2),
+	NonMouse(NonMouseInstruction),
+}
+#[derive(Clone,Debug)]
+enum BufferedInstruction{
+	Mouse(MouseInstruction),
+	NonMouse(NonMouseInstruction),
+}
+#[derive(Clone,Debug)]
+pub(crate) enum NonMouseInstruction{
+	SetControl(SetControlInstruction),
+	Mode(ModeInstruction),
+	Misc(MiscInstruction),
+	Idle,
+}
+impl From<Instruction> for UnbufferedInstruction{
+	#[inline]
+	fn from(value:Instruction)->Self{
+		match value{
+			Instruction::MoveMouse(mouse_instruction)=>UnbufferedInstruction::MoveMouse(mouse_instruction),
+			Instruction::SetControl(set_control_instruction)=>UnbufferedInstruction::NonMouse(NonMouseInstruction::SetControl(set_control_instruction)),
+			Instruction::Mode(mode_instruction)=>UnbufferedInstruction::NonMouse(NonMouseInstruction::Mode(mode_instruction)),
+			Instruction::Misc(misc_instruction)=>UnbufferedInstruction::NonMouse(NonMouseInstruction::Misc(misc_instruction)),
+			Instruction::Idle=>UnbufferedInstruction::NonMouse(NonMouseInstruction::Idle),
+		}
+	}
+}
+impl From<BufferedInstruction> for PhysicsInstruction{
+	#[inline]
+	fn from(value:BufferedInstruction)->Self{
+		match value{
+			BufferedInstruction::Mouse(mouse_instruction)=>PhysicsInstruction::Mouse(mouse_instruction),
+			BufferedInstruction::NonMouse(non_mouse_instruction)=>match non_mouse_instruction{
+				NonMouseInstruction::SetControl(set_control_instruction)=>PhysicsInstruction::SetControl(set_control_instruction),
+				NonMouseInstruction::Mode(mode_instruction)=>PhysicsInstruction::Mode(mode_instruction),
+				NonMouseInstruction::Misc(misc_instruction)=>PhysicsInstruction::Misc(misc_instruction),
+				NonMouseInstruction::Idle=>PhysicsInstruction::Idle,
+			},
+		}
+	}
+}
+
+pub(crate) enum StepInstruction{
+	Pop,
+	Timeout,
+}
+
+#[derive(Clone,Debug)]
+enum BufferState{
+	Unbuffered,
+	Initializing(SessionTime,MouseState<PhysicsTimeInner>),
+	Buffered(SessionTime,MouseState<PhysicsTimeInner>),
+}
+
+pub struct MouseInterpolator{
+	buffer_state:BufferState,
+	// double timestamped timeline?
+	buffer:std::collections::VecDeque<TimedPhysicsInstruction>,
+	output:std::collections::VecDeque<TimedPhysicsInstruction>,
+}
+// Maybe MouseInterpolator manipulation is better expressed using impls
+// and called from Instruction trait impls in session
+impl InstructionConsumer<TimedSelfInstruction> for MouseInterpolator{
+	type Time=SessionTime;
+	fn process_instruction(&mut self,ins:DoubleTimedSelfInstruction){
+		self.push_unbuffered_input(ins.time,ins.instruction.time,ins.instruction.instruction.into())
+	}
+}
+impl InstructionEmitter<StepInstruction> for MouseInterpolator{
+	type Time=SessionTime;
+	fn next_instruction(&self,time_limit:SessionTime)->Option<TimedInstruction<StepInstruction,Self::Time>>{
+		self.buffered_instruction_with_timeout(time_limit)
+	}
+}
+impl MouseInterpolator{
+	pub fn new()->MouseInterpolator{
+		MouseInterpolator{
+			buffer_state:BufferState::Unbuffered,
+			buffer:std::collections::VecDeque::new(),
+			output:std::collections::VecDeque::new(),
+		}
+	}
+	fn push_mouse_and_flush_buffer(&mut self,ins:TimedInstruction<MouseInstruction,PhysicsTime>){
+		self.buffer.push_front(TimedInstruction{
+			time:ins.time,
+			instruction:BufferedInstruction::Mouse(ins.instruction).into(),
+		});
+		// flush buffer to output
+		if self.output.len()==0{
+			// swap buffers
+			core::mem::swap(&mut self.buffer,&mut self.output);
+		}else{
+			// append buffer contents to output
+			self.output.append(&mut self.buffer);
+		}
+	}
+	fn get_mouse_timedout_at(&self,time_limit:SessionTime)->Option<SessionTime>{
+		match &self.buffer_state{
+			BufferState::Unbuffered=>None,
+			BufferState::Initializing(time,_mouse_state)
+			|BufferState::Buffered(time,_mouse_state)=>{
+				let timeout=*time+MOUSE_TIMEOUT;
+				(timeout<time_limit).then_some(timeout)
+			}
+		}
+	}
+	fn timeout_mouse(&mut self,timeout_time:PhysicsTime){
+		// the state always changes to unbuffered
+		let buffer_state=core::mem::replace(&mut self.buffer_state,BufferState::Unbuffered);
+		match buffer_state{
+			BufferState::Unbuffered=>(),
+			BufferState::Initializing(_time,mouse_state)=>{
+				// only a single mouse move was sent in 10ms, this is very much an edge case!
+				self.push_mouse_and_flush_buffer(TimedInstruction{
+					time:mouse_state.time,
+					instruction:MouseInstruction::ReplaceMouse{
+						m1:MouseState{pos:mouse_state.pos,time:timeout_time},
+						m0:mouse_state,
+					},
+				});
+			}
+			BufferState::Buffered(_time,mouse_state)=>{
+				// duplicate the currently buffered mouse state but at a later (future, from the physics perspective) time
+				self.push_mouse_and_flush_buffer(TimedInstruction{
+					time:mouse_state.time,
+					instruction:MouseInstruction::SetNextMouse(MouseState{pos:mouse_state.pos,time:timeout_time}),
+				});
+			},
+		}
+	}
+	fn push_unbuffered_input(&mut self,session_time:SessionTime,physics_time:PhysicsTime,ins:UnbufferedInstruction){
+		// new input
+		// if there is zero instruction buffered, it means the mouse is not moving
+		// case 1: unbuffered
+		// no mouse event is buffered
+		// - ins is mouse event? change to buffered
+		// - ins other -> write to timeline
+		// case 2: buffered
+		// a mouse event is buffered, and exists within the last 10ms
+		// case 3: stop
+		// a mouse event is buffered, but no mouse events have transpired within 10ms
+
+		// replace_with allows the enum variant to safely be replaced
+		// from behind a mutable reference, but a panic in the closure means that
+		// the entire program terminates rather than completing an unwind.
+		let (ins_mouse,ins_other)=replace_with::replace_with_or_abort_and_return(&mut self.buffer_state,|buffer_state|{
+			match ins{
+				UnbufferedInstruction::MoveMouse(pos)=>{
+					let next_mouse_state=MouseState{pos,time:physics_time};
+					match buffer_state{
+						BufferState::Unbuffered=>{
+							((None,None),BufferState::Initializing(session_time,next_mouse_state))
+						},
+						BufferState::Initializing(_time,mouse_state)=>{
+							let ins_mouse=TimedInstruction{
+								time:mouse_state.time,
+								instruction:MouseInstruction::ReplaceMouse{
+									m0:mouse_state,
+									m1:next_mouse_state.clone(),
+								},
+							};
+							((Some(ins_mouse),None),BufferState::Buffered(session_time,next_mouse_state))
+						},
+						BufferState::Buffered(_time,mouse_state)=>{
+							let ins_mouse=TimedInstruction{
+								time:mouse_state.time,
+								instruction:MouseInstruction::SetNextMouse(next_mouse_state.clone()),
+							};
+							((Some(ins_mouse),None),BufferState::Buffered(session_time,next_mouse_state))
+						},
+					}
+				},
+				UnbufferedInstruction::NonMouse(other_instruction)=>((None,Some(TimedInstruction{
+					time:physics_time,
+					instruction:other_instruction,
+				})),buffer_state),
+			}
+		});
+		if let Some(ins)=ins_mouse{
+			self.push_mouse_and_flush_buffer(ins);
+		}
+		if let Some(ins)=ins_other{
+			let instruction=TimedInstruction{
+				time:ins.time,
+				instruction:BufferedInstruction::NonMouse(ins.instruction).into(),
+			};
+			if matches!(self.buffer_state,BufferState::Unbuffered){
+				self.output.push_back(instruction);
+			}else{
+				self.buffer.push_back(instruction);
+			}
+		}
+	}
+	fn buffered_instruction_with_timeout(&self,time_limit:SessionTime)->Option<TimedInstruction<StepInstruction,SessionTime>>{
+		match self.get_mouse_timedout_at(time_limit){
+			Some(timeout)=>Some(TimedInstruction{
+				time:timeout,
+				instruction:StepInstruction::Timeout,
+			}),
+			None=>(self.output.len()!=0).then_some(TimedInstruction{
+				// this timestamp should not matter
+				time:time_limit,
+				instruction:StepInstruction::Pop,
+			}),
+		}
+	}
+	pub fn pop_buffered_instruction(&mut self,ins:TimedInstruction<StepInstruction,PhysicsTime>)->Option<TimedPhysicsInstruction>{
+		match ins.instruction{
+			StepInstruction::Pop=>(),
+			StepInstruction::Timeout=>self.timeout_mouse(ins.time),
+		}
+		self.output.pop_front()
+	}
+}
+
+#[cfg(test)]
+mod test{
+	use super::*;
+	use strafesnet_common::session::TimeInner as SessionTimeInner;
+	#[test]
+	fn test(){
+		let mut interpolator=MouseInterpolator::new();
+
+		let timer=strafesnet_common::timer::Timer::<strafesnet_common::timer::Scaled<SessionTimeInner,PhysicsTimeInner>>::unpaused(SessionTime::ZERO,PhysicsTime::from_secs(1000));
+
+		macro_rules! push{
+			($time:expr,$ins:expr)=>{
+				println!("in={:?}",$ins);
+				interpolator.push_unbuffered_input(
+					$time,
+					timer.time($time),
+					$ins,
+				);
+				while let Some(ins)=interpolator.buffered_instruction_with_timeout($time){
+					let ins_retimed=TimedInstruction{
+						time:timer.time(ins.time),
+						instruction:ins.instruction,
+					};
+					let out=interpolator.pop_buffered_instruction(ins_retimed);
+					println!("out={out:?}");
+				}
+			};
+		}
+
+		// test each buffer_state transition
+		let mut t=SessionTime::ZERO;
+		push!(t,UnbufferedInstruction::MoveMouse(glam::ivec2(0,0)));
+		t+=SessionTime::from_millis(5);
+		push!(t,UnbufferedInstruction::MoveMouse(glam::ivec2(0,0)));
+		t+=SessionTime::from_millis(5);
+		push!(t,UnbufferedInstruction::MoveMouse(glam::ivec2(0,0)));
+		t+=SessionTime::from_millis(1);
+	}
+}

engine/session/src/session.rs

@@ -0,0 +1,443 @@
+use std::collections::HashMap;
+
+use strafesnet_common::gameplay_modes::{ModeId,StageId};
+use strafesnet_common::instruction::{InstructionConsumer,InstructionEmitter,InstructionFeedback,TimedInstruction};
+// session represents the non-hardware state of the client.
+// Ideally it is a deterministic state which is atomically updated by instructions, same as the simulation state.
+use strafesnet_common::physics::{
+	ModeInstruction,MiscInstruction,
+	Instruction as PhysicsInputInstruction,
+	TimeInner as PhysicsTimeInner,
+	Time as PhysicsTime
+};
+use strafesnet_common::timer::{Scaled,Timer};
+use strafesnet_common::session::{TimeInner as SessionTimeInner,Time as SessionTime};
+use strafesnet_settings::directories::Directories;
+
+use crate::mouse_interpolator::{MouseInterpolator,StepInstruction,Instruction as MouseInterpolatorInstruction};
+use strafesnet_physics::physics::{self,PhysicsContext,PhysicsData};
+use strafesnet_settings::settings::UserSettings;
+
+pub enum Instruction<'a>{
+	Input(SessionInputInstruction),
+	Control(SessionControlInstruction),
+	Playback(SessionPlaybackInstruction),
+	ChangeMap(&'a strafesnet_common::map::CompleteMap),
+	LoadReplay(strafesnet_snf::bot::Segment),
+	Idle,
+}
+
+pub enum SessionInputInstruction{
+	Mouse(glam::IVec2),
+	SetControl(strafesnet_common::physics::SetControlInstruction),
+	Mode(ImplicitModeInstruction),
+	Misc(strafesnet_common::physics::MiscInstruction),
+}
+/// Implicit mode instruction are fed separately to session.
+/// Session generates the explicit mode instructions interlaced with a SetSensitivity instruction
+#[derive(Clone,Debug)]
+pub enum ImplicitModeInstruction{
+	ResetAndRestart,
+	ResetAndSpawn(ModeId,StageId),
+}
+
+pub enum SessionControlInstruction{
+	SetPaused(bool),
+	// copy the current session simulation recording into a replay and view it
+	CopyRecordingIntoReplayAndSpectate,
+	StopSpectate,
+	SaveReplay,
+	LoadIntoReplayState,
+}
+pub enum SessionPlaybackInstruction{
+	SkipForward,
+	SkipBack,
+	TogglePaused,
+	DecreaseTimescale,
+	IncreaseTimescale,
+}
+
+pub struct FrameState{
+	pub body:physics::Body,
+	pub camera:physics::PhysicsCamera,
+	pub time:PhysicsTime,
+}
+
+pub struct Simulation{
+	timer:Timer<Scaled<SessionTimeInner,PhysicsTimeInner>>,
+	physics:physics::PhysicsState,
+}
+impl Simulation{
+	pub const fn new(
+		timer:Timer<Scaled<SessionTimeInner,PhysicsTimeInner>>,
+		physics:physics::PhysicsState,
+	)->Self{
+		Self{
+			timer,
+			physics,
+		}
+	}
+	pub fn get_frame_state(&self,time:SessionTime)->FrameState{
+		FrameState{
+			body:self.physics.camera_body(),
+			camera:self.physics.camera(),
+			time:self.timer.time(time),
+		}
+	}
+}
+
+#[derive(Default)]
+pub struct Recording{
+	instructions:Vec<TimedInstruction<PhysicsInputInstruction,PhysicsTime>>,
+}
+impl Recording{
+	pub fn new(
+		instructions:Vec<TimedInstruction<PhysicsInputInstruction,PhysicsTime>>,
+	)->Self{
+		Self{instructions}
+	}
+	fn clear(&mut self){
+		self.instructions.clear();
+	}
+}
+pub struct Replay{
+	next_instruction_id:usize,
+	recording:Recording,
+	simulation:Simulation,
+}
+impl Replay{
+	pub const fn new(
+		recording:Recording,
+		simulation:Simulation,
+	)->Self{
+		Self{
+			next_instruction_id:0,
+			recording,
+			simulation,
+		}
+	}
+	pub fn advance(&mut self,physics_data:&PhysicsData,time_limit:SessionTime){
+		let mut time=self.simulation.timer.time(time_limit);
+		loop{
+			if let Some(ins)=self.recording.instructions.get(self.next_instruction_id){
+				if ins.time<time{
+					PhysicsContext::run_input_instruction(&mut self.simulation.physics,physics_data,ins.clone());
+					self.next_instruction_id+=1;
+				}else{
+					break;
+				}
+			}else{
+				// loop playback
+				self.next_instruction_id=0;
+				// No need to reset physics because the very first instruction is 'Reset'
+				let new_time=self.recording.instructions.first().map_or(PhysicsTime::ZERO,|ins|ins.time);
+				self.simulation.timer.set_time(time_limit,new_time);
+				time=new_time;
+			}
+		}
+	}
+}
+
+#[derive(Clone,Copy,Hash,PartialEq,Eq)]
+struct BotId(u32);
+//#[derive(Clone,Copy,Hash,PartialEq,Eq)]
+//struct PlayerId(u32);
+
+enum ViewState{
+	Play,
+	//Spectate(PlayerId),
+	Replay(BotId),
+}
+
+pub struct Session{
+	directories:Directories,
+	user_settings:UserSettings,
+	mouse_interpolator:crate::mouse_interpolator::MouseInterpolator,
+	view_state:ViewState,
+	//gui:GuiState
+	geometry_shared:physics::PhysicsData,
+	simulation:Simulation,
+	// below fields not included in lite session
+	recording:Recording,
+	//players:HashMap<PlayerId,Simulation>,
+	replays:HashMap<BotId,Replay>,
+}
+impl Session{
+	pub fn new(
+		user_settings:UserSettings,
+		directories:Directories,
+		simulation:Simulation,
+	)->Self{
+		Self{
+			user_settings,
+			directories,
+			mouse_interpolator:MouseInterpolator::new(),
+			geometry_shared:Default::default(),
+			simulation,
+			view_state:ViewState::Play,
+			recording:Default::default(),
+			replays:HashMap::new(),
+		}
+	}
+	fn clear_recording(&mut self){
+		self.recording.clear();
+	}
+	fn change_map(&mut self,map:&strafesnet_common::map::CompleteMap){
+		self.simulation.physics.clear();
+		self.geometry_shared.generate_models(map);
+	}
+	pub fn get_frame_state(&self,time:SessionTime)->Option<FrameState>{
+		match &self.view_state{
+			ViewState::Play=>Some(self.simulation.get_frame_state(time)),
+			ViewState::Replay(bot_id)=>self.replays.get(bot_id).map(|replay|
+				replay.simulation.get_frame_state(time)
+			),
+		}
+	}
+	pub fn user_settings(&self)->&UserSettings{
+		&self.user_settings
+	}
+}
+
+// mouseinterpolator consumes RawInputInstruction
+// mouseinterpolator emits PhysicsInputInstruction
+// mouseinterpolator consumes DoStep to move on to the next emitted instruction
+// Session comsumes SessionInstruction -> forwards RawInputInstruction to mouseinterpolator
+// Session consumes DoStep -> forwards DoStep to mouseinterpolator
+// Session emits DoStep
+
+impl InstructionConsumer<Instruction<'_>> for Session{
+	type Time=SessionTime;
+	fn process_instruction(&mut self,ins:TimedInstruction<Instruction,Self::Time>){
+		// repetitive procedure macro
+		macro_rules! run_mouse_interpolator_instruction{
+			($instruction:expr)=>{
+				self.mouse_interpolator.process_instruction(TimedInstruction{
+					time:ins.time,
+					instruction:TimedInstruction{
+						time:self.simulation.timer.time(ins.time),
+						instruction:$instruction,
+					},
+				});
+			};
+		}
+
+		// process any timeouts that occured since the last instruction
+		self.process_exhaustive(ins.time);
+
+		match ins.instruction{
+			// send it down to MouseInterpolator with two timestamps, SessionTime and PhysicsTime
+			Instruction::Input(SessionInputInstruction::Mouse(pos))=>{
+				run_mouse_interpolator_instruction!(MouseInterpolatorInstruction::MoveMouse(pos));
+			},
+			Instruction::Input(SessionInputInstruction::SetControl(set_control_instruction))=>{
+				run_mouse_interpolator_instruction!(MouseInterpolatorInstruction::SetControl(set_control_instruction));
+			},
+			Instruction::Input(SessionInputInstruction::Mode(ImplicitModeInstruction::ResetAndRestart))=>{
+				self.clear_recording();
+				let mode_id=self.simulation.physics.mode();
+				run_mouse_interpolator_instruction!(MouseInterpolatorInstruction::Mode(ModeInstruction::Reset));
+				run_mouse_interpolator_instruction!(MouseInterpolatorInstruction::Misc(MiscInstruction::SetSensitivity(self.user_settings().calculate_sensitivity())));
+				run_mouse_interpolator_instruction!(MouseInterpolatorInstruction::Mode(ModeInstruction::Restart(mode_id)));
+			},
+			Instruction::Input(SessionInputInstruction::Mode(ImplicitModeInstruction::ResetAndSpawn(mode_id,spawn_id)))=>{
+				self.clear_recording();
+				run_mouse_interpolator_instruction!(MouseInterpolatorInstruction::Mode(ModeInstruction::Reset));
+				run_mouse_interpolator_instruction!(MouseInterpolatorInstruction::Misc(MiscInstruction::SetSensitivity(self.user_settings().calculate_sensitivity())));
+				run_mouse_interpolator_instruction!(MouseInterpolatorInstruction::Mode(ModeInstruction::Spawn(mode_id,spawn_id)));
+			},
+			Instruction::Input(SessionInputInstruction::Misc(misc_instruction))=>{
+				run_mouse_interpolator_instruction!(MouseInterpolatorInstruction::Misc(misc_instruction));
+			},
+			Instruction::Control(SessionControlInstruction::SetPaused(paused))=>{
+				// don't flush the buffered instructions in the mouse interpolator
+				// until the mouse is confirmed to be not moving at a later time
+				// what if they pause for 5ms lmao
+				_=self.simulation.timer.set_paused(ins.time,paused);
+			},
+			Instruction::Control(SessionControlInstruction::CopyRecordingIntoReplayAndSpectate)=> if let ViewState::Play=self.view_state{
+				// Bind: B
+
+				// pause simulation
+				_=self.simulation.timer.set_paused(ins.time,true);
+
+				// create recording
+				let mut recording=Recording::default();
+				recording.instructions.extend(self.recording.instructions.iter().cloned());
+
+				// create timer starting at first instruction (or zero if the list is empty)
+				let new_time=recording.instructions.first().map_or(PhysicsTime::ZERO,|ins|ins.time);
+				let timer=Timer::unpaused(ins.time,new_time);
+
+				// create default physics state
+				let simulation=Simulation::new(timer,Default::default());
+
+				// invent a new bot id and insert the replay
+				let bot_id=BotId(self.replays.len() as u32);
+				self.replays.insert(bot_id,Replay::new(
+					recording,
+					simulation,
+				));
+
+				// begin spectate
+				self.view_state=ViewState::Replay(bot_id);
+			},
+			Instruction::Control(SessionControlInstruction::StopSpectate)=>{
+				let view_state=core::mem::replace(&mut self.view_state,ViewState::Play);
+				// delete the bot, otherwise it's inaccessible and wastes CPU
+				match view_state{
+					ViewState::Play=>(),
+					ViewState::Replay(bot_id)=>{
+						self.replays.remove(&bot_id);
+					},
+				}
+				_=self.simulation.timer.set_paused(ins.time,false);
+			},
+			Instruction::Control(SessionControlInstruction::SaveReplay)=>{
+				// Bind: N
+				let view_state=core::mem::replace(&mut self.view_state,ViewState::Play);
+				match view_state{
+					ViewState::Play=>(),
+					ViewState::Replay(bot_id)=>if let Some(replay)=self.replays.remove(&bot_id){
+						let mut replays_path=self.directories.replays.clone();
+						let file_name=format!("{}.snfb",ins.time);
+						std::thread::spawn(move ||{
+							std::fs::create_dir_all(replays_path.as_path()).unwrap();
+							replays_path.push(file_name);
+							let file=std::fs::File::create(replays_path).unwrap();
+							strafesnet_snf::bot::write_bot(
+								std::io::BufWriter::new(file),
+								strafesnet_physics::VERSION.get(),
+								replay.recording.instructions
+							).unwrap();
+							println!("Finished writing bot file!");
+						});
+					},
+				}
+				_=self.simulation.timer.set_paused(ins.time,false);
+			},
+			Instruction::Control(SessionControlInstruction::LoadIntoReplayState)=>{
+				// Bind: J
+				let view_state=core::mem::replace(&mut self.view_state,ViewState::Play);
+				match view_state{
+					ViewState::Play=>(),
+					ViewState::Replay(bot_id)=>if let Some(replay)=self.replays.remove(&bot_id){
+						self.recording.instructions=replay.recording.instructions.into_iter().take(replay.next_instruction_id).collect();
+						self.simulation=replay.simulation;
+					},
+				}
+				// don't unpause -- use the replay timer state whether it is pasued or unpaused
+			},
+			Instruction::Playback(SessionPlaybackInstruction::IncreaseTimescale)=>{
+				match &self.view_state{
+					ViewState::Play=>{
+						// allow simulation timescale for fun
+						let scale=self.simulation.timer.get_scale();
+						self.simulation.timer.set_scale(ins.time,strafesnet_common::integer::Ratio64::new(scale.num()*5,scale.den()*4).unwrap());
+					},
+					ViewState::Replay(bot_id)=>if let Some(replay)=self.replays.get_mut(bot_id){
+						let scale=replay.simulation.timer.get_scale();
+						replay.simulation.timer.set_scale(ins.time,strafesnet_common::integer::Ratio64::new(scale.num()*5,scale.den()*4).unwrap());
+					},
+				}
+			},
+			Instruction::Playback(SessionPlaybackInstruction::DecreaseTimescale)=>{
+				match &self.view_state{
+					ViewState::Play=>{
+						// allow simulation timescale for fun
+						let scale=self.simulation.timer.get_scale();
+						self.simulation.timer.set_scale(ins.time,strafesnet_common::integer::Ratio64::new(scale.num()*4,scale.den()*5).unwrap());
+					},
+					ViewState::Replay(bot_id)=>if let Some(replay)=self.replays.get_mut(bot_id){
+						let scale=replay.simulation.timer.get_scale();
+						replay.simulation.timer.set_scale(ins.time,strafesnet_common::integer::Ratio64::new(scale.num()*4,scale.den()*5).unwrap());
+					},
+				}
+			},
+			Instruction::Playback(SessionPlaybackInstruction::SkipForward)=>{
+				match &self.view_state{
+					ViewState::Play=>(),
+					ViewState::Replay(bot_id)=>if let Some(replay)=self.replays.get_mut(bot_id){
+						let time=replay.simulation.timer.time(ins.time+SessionTime::from_secs(5));
+						replay.simulation.timer.set_time(ins.time,time);
+					},
+				}
+			},
+			Instruction::Playback(SessionPlaybackInstruction::SkipBack)=>{
+				match &self.view_state{
+					ViewState::Play=>(),
+					ViewState::Replay(bot_id)=>if let Some(replay)=self.replays.get_mut(bot_id){
+						let time=replay.simulation.timer.time(ins.time+SessionTime::from_secs(5));
+						replay.simulation.timer.set_time(ins.time,time);
+						// resimulate the entire playback lol
+						replay.next_instruction_id=0;
+					},
+				}
+			},
+			Instruction::Playback(SessionPlaybackInstruction::TogglePaused)=>{
+				match &self.view_state{
+					ViewState::Play=>(),
+					ViewState::Replay(bot_id)=>if let Some(replay)=self.replays.get_mut(bot_id){
+						_=replay.simulation.timer.set_paused(ins.time,!replay.simulation.timer.is_paused());
+					},
+				}
+			}
+			Instruction::ChangeMap(complete_map)=>{
+				self.clear_recording();
+				self.change_map(complete_map);
+			},
+			Instruction::LoadReplay(bot)=>{
+				// pause simulation
+				_=self.simulation.timer.set_paused(ins.time,true);
+
+				// create recording
+				let recording=Recording::new(bot.instructions);
+
+				// create timer starting at first instruction (or zero if the list is empty)
+				let new_time=recording.instructions.first().map_or(PhysicsTime::ZERO,|ins|ins.time);
+				let timer=Timer::unpaused(ins.time,new_time);
+
+				// create default physics state
+				let simulation=Simulation::new(timer,Default::default());
+
+				// invent a new bot id and insert the replay
+				let bot_id=BotId(self.replays.len() as u32);
+				self.replays.insert(bot_id,Replay::new(
+					recording,
+					simulation,
+				));
+
+				// begin spectate
+				self.view_state=ViewState::Replay(bot_id);
+			},
+			Instruction::Idle=>{
+				run_mouse_interpolator_instruction!(MouseInterpolatorInstruction::Idle);
+				// this just refreshes the replays
+				for replay in self.replays.values_mut(){
+					// TODO: filter idles from recording, inject new idles in real time
+					replay.advance(&self.geometry_shared,ins.time);
+				}
+			}
+		};
+
+		// process all emitted output instructions
+		self.process_exhaustive(ins.time);
+	}
+}
+impl InstructionConsumer<StepInstruction> for Session{
+	type Time=SessionTime;
+	fn process_instruction(&mut self,ins:TimedInstruction<StepInstruction,Self::Time>){
+		let time=self.simulation.timer.time(ins.time);
+		if let Some(instruction)=self.mouse_interpolator.pop_buffered_instruction(ins.set_time(time)){
+			//record
+			self.recording.instructions.push(instruction.clone());
+			PhysicsContext::run_input_instruction(&mut self.simulation.physics,&self.geometry_shared,instruction);
+		}
+	}
+}
+impl InstructionEmitter<StepInstruction> for Session{
+	type Time=SessionTime;
+	fn next_instruction(&self,time_limit:SessionTime)->Option<TimedInstruction<StepInstruction,Self::Time>>{
+		self.mouse_interpolator.next_instruction(time_limit)
+	}
+}

engine/settings/Cargo.toml

@@ -0,0 +1,10 @@
+[package]
+name = "strafesnet_settings"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+configparser = "3.0.2"
+directories = "6.0.0"
+glam = "0.30.0"
+strafesnet_common = { path = "../../lib/common", registry = "strafesnet" }

engine/settings/LICENSE

@@ -0,0 +1,8 @@
+/*******************************************************
+* Copyright (C) 2023-2024 Rhys Lloyd <krakow20@gmail.com>
+*
+* This file is part of the StrafesNET bhop/surf client.
+*
+* StrafesNET can not be copied and/or distributed
+* without the express permission of Rhys Lloyd
+*******************************************************/

engine/settings/src/directories.rs

@@ -0,0 +1,32 @@
+use std::path::PathBuf;
+
+use crate::settings::{UserSettings,load_user_settings};
+
+pub struct Directories{
+	pub settings:PathBuf,
+	pub maps:PathBuf,
+	pub replays:PathBuf,
+}
+impl Directories{
+	pub fn settings(&self)->UserSettings{
+		load_user_settings(&self.settings)
+	}
+	pub fn user()->Option<Self>{
+		let dirs=directories::ProjectDirs::from("net.strafes","StrafesNET","Strafe Client")?;
+		Some(Self{
+			settings:dirs.config_dir().join("settings.conf"),
+			maps:dirs.cache_dir().join("maps"),
+			// separate directory for remote downloaded replays (cache)
+			// bots:dirs.cache_dir().join("bots"),
+			replays:dirs.data_local_dir().join("replays"),
+		})
+	}
+	pub fn portable()->Result<Self,std::io::Error>{
+		let current_dir=std::env::current_dir()?;
+		Ok(Self{
+			settings:current_dir.join("settings.conf"),
+			maps:current_dir.join("maps"),
+			replays:current_dir.join("replays"),
+		})
+	}
+}

engine/settings/src/lib.rs

@@ -0,0 +1,2 @@
+pub mod settings;
+pub mod directories;

engine/settings/src/settings.rs

@@ -74,9 +74,9 @@ sensitivity_y_from_x_ratio=1
 Sensitivity::DeriveY{x:0.0.001,y:DerivedSensitivity{ratio:1.0}}
 */
 
-pub fn read_user_settings()->UserSettings{
+pub fn load_user_settings(path:&std::path::Path)->UserSettings{
 	let mut cfg=configparser::ini::Ini::new();
-	if let Ok(_)=cfg.load("settings.conf"){
+	if let Ok(_)=cfg.load(path){
 		let (cfg_fov_x,cfg_fov_y)=(cfg.getfloat("camera","fov_x"),cfg.getfloat("camera","fov_y"));
 		let fov=match(cfg_fov_x,cfg_fov_y){
 			(Ok(Some(fov_x)),Ok(Some(fov_y)))=>Fov::Exactly {
@@ -136,4 +136,4 @@ pub fn read_user_settings()->UserSettings{
 	}else{
 		UserSettings::default()
 	}
-}
+}

integration-testing/Cargo.toml

@@ -0,0 +1,9 @@
+[package]
+name = "integration-testing"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+strafesnet_common = { path = "../lib/common", registry = "strafesnet" }
+strafesnet_physics = { path = "../engine/physics", registry = "strafesnet" }
+strafesnet_snf = { path = "../lib/snf", registry = "strafesnet" }

integration-testing/src/main.rs

@@ -0,0 +1,253 @@
+use std::io::Cursor;
+use std::path::Path;
+use std::time::Instant;
+
+use strafesnet_physics::physics::{PhysicsData,PhysicsState,PhysicsContext};
+
+fn main(){
+	let arg=std::env::args().skip(1).next();
+	match arg.as_deref(){
+		Some("determinism")|None=>test_determinism().unwrap(),
+		Some("replay")=>run_replay().unwrap(),
+		_=>println!("invalid argument"),
+	}
+}
+
+#[allow(unused)]
+#[derive(Debug)]
+enum ReplayError{
+	IO(std::io::Error),
+	SNF(strafesnet_snf::Error),
+	SNFM(strafesnet_snf::map::Error),
+	SNFB(strafesnet_snf::bot::Error),
+}
+impl From<std::io::Error> for ReplayError{
+	fn from(value:std::io::Error)->Self{
+		Self::IO(value)
+	}
+}
+impl From<strafesnet_snf::Error> for ReplayError{
+	fn from(value:strafesnet_snf::Error)->Self{
+		Self::SNF(value)
+	}
+}
+impl From<strafesnet_snf::map::Error> for ReplayError{
+	fn from(value:strafesnet_snf::map::Error)->Self{
+		Self::SNFM(value)
+	}
+}
+impl From<strafesnet_snf::bot::Error> for ReplayError{
+	fn from(value:strafesnet_snf::bot::Error)->Self{
+		Self::SNFB(value)
+	}
+}
+
+fn read_entire_file(path:impl AsRef<Path>)->Result<Cursor<Vec<u8>>,std::io::Error>{
+	let data=std::fs::read(path)?;
+	Ok(Cursor::new(data))
+}
+
+fn run_replay()->Result<(),ReplayError>{
+	println!("loading map file..");
+	let data=read_entire_file("../tools/bhop_maps/5692113331.snfm")?;
+	let map=strafesnet_snf::read_map(data)?.into_complete_map()?;
+
+	println!("loading bot file..");
+	let data=read_entire_file("../tools/replays/535s+159764769ns.snfb")?;
+	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);
+	println!("simulating...");
+	let mut physics=PhysicsState::default();
+	for ins in bot.instructions{
+		PhysicsContext::run_input_instruction(&mut physics,&physics_data,ins);
+	}
+	match physics.get_finish_time(){
+		Some(time)=>println!("finish time:{}",time),
+		None=>println!("simulation did not end in finished state"),
+	}
+
+	Ok(())
+}
+enum DeterminismResult{
+	Deterministic,
+	NonDeterministic,
+}
+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
+	let mut physics_filtered=PhysicsState::default();
+
+	// invent a new bot id and insert the replay
+	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();
+		let state_filtered=physics_filtered.clone();
+		PhysicsContext::run_input_instruction(&mut physics_deterministic,&physics_data,ins.clone());
+		match ins{
+			strafesnet_common::instruction::TimedInstruction{instruction:strafesnet_common::physics::Instruction::Idle,..}=>(),
+			other=>{
+				non_idle_count+=1;
+				// run
+				PhysicsContext::run_input_instruction(&mut physics_filtered,&physics_data,other.clone());
+				// check if position matches
+				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);
+					println!("deterministic state0:\n{state_deterministic:?}");
+					println!("filtered state0:\n{state_filtered:?}");
+					println!("deterministic state1:\n{:?}",physics_deterministic);
+					println!("filtered state1:\n{:?}",physics_filtered);
+					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"),
+	}
+	match physics_filtered.get_finish_time(){
+		Some(time)=>println!("[filtered] finish time:{}",time),
+		None=>println!("[filtered] simulation did not end in finished state"),
+	}
+	SegmentResult{
+		determinism:DeterminismResult::Deterministic,
+		ticks:instruction_count as u64+non_idle_count,
+		nanoseconds,
+	}
+
+}
+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()?;
+	println!("Running {:?}",file_path.file_stem());
+	Ok(Some(segment_determinism(bot,physics_data)))
+}
+fn do_thread<'a>(s:&'a std::thread::Scope<'a,'_>,file_path:std::path::PathBuf,send:std::sync::mpsc::Sender<ThreadResult>,physics_data:&'a PhysicsData){
+	s.spawn(move ||{
+		let result=read_and_run(file_path,physics_data);
+		// send when thread is complete
+		send.send(result).unwrap();
+	});
+}
+fn get_file_path(dir_entry:std::fs::DirEntry)->Result<Option<std::path::PathBuf>,std::io::Error>{
+	Ok(dir_entry.file_type()?.is_file().then_some(
+		dir_entry.path()
+	))
+}
+fn test_determinism()->Result<(),ReplayError>{
+	let thread_limit=std::thread::available_parallelism()?.get();
+	println!("loading map file..");
+	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 (send,recv)=std::sync::mpsc::channel();
+
+	let mut read_dir=std::fs::read_dir("../tools/replays")?;
+
+	// promise that &physics_data will outlive the spawned threads
+	let thread_results=std::thread::scope(|s|{
+		let mut thread_results=Vec::new();
+
+		// spawn threads
+		println!("spawning up to {thread_limit} threads...");
+		let mut active_thread_count=0;
+		while active_thread_count<thread_limit{
+			if let Some(dir_entry_result)=read_dir.next(){
+				if let Some(file_path)=get_file_path(dir_entry_result?)?{
+					active_thread_count+=1;
+					do_thread(s,file_path,send.clone(),&physics_data);
+				}
+			}else{
+				break;
+			}
+		}
+
+		// spawn another thread every time a message is received from the channel
+		println!("riding parallelism wave...");
+		while let Some(dir_entry_result)=read_dir.next(){
+			if let Some(file_path)=get_file_path(dir_entry_result?)?{
+				// wait for a thread to complete
+				thread_results.push(recv.recv().unwrap());
+				do_thread(s,file_path,send.clone(),&physics_data);
+			}
+		}
+
+		// wait for remaining threads to complete
+		println!("waiting for all threads to complete...");
+		for _ in 0..active_thread_count{
+			thread_results.push(recv.recv().unwrap());
+		}
+
+		println!("done.");
+		Ok::<_,ReplayError>(thread_results)
+	})?;
+
+	// tally results
+	#[derive(Default)]
+	struct Totals{
+		deterministic:u32,
+		nondeterministic:u32,
+		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(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,
+		}
+		totals
+	});
+
+	println!("deterministic={deterministic}");
+	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);
+	assert!(error==0);
+
+	Ok(())
+}

lib/bsp_loader/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "strafesnet_bsp_loader"
-version = "0.2.2"
-edition = "2021"
+version = "0.3.0"
+edition = "2024"
 repository = "https://git.itzana.me/StrafesNET/strafe-project"
 license = "MIT OR Apache-2.0"
 description = "Convert Valve BSP files to StrafesNET data structures."
@@ -10,7 +10,10 @@ authors = ["Rhys Lloyd <krakow20@gmail.com>"]
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-glam = "0.29.0"
-strafesnet_common = { path = "../common", registry = "strafesnet" }
-vbsp = "0.6.0"
+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 = "0.8.0"
+vbsp-entities-css = "0.6.0"
 vmdl = "0.2.0"
+vpk = "0.3.0"

lib/bsp_loader/src/brush.rs

@@ -0,0 +1,342 @@
+use strafesnet_common::integer::Planar64;
+use strafesnet_common::{model,integer};
+use strafesnet_common::integer::{vec3::Vector3,Fixed,Ratio};
+
+use crate::{valve_transform_normal,valve_transform_dist};
+
+#[derive(Hash,Eq,PartialEq)]
+struct Face{
+	normal:integer::Planar64Vec3,
+	dot:integer::Planar64,
+}
+
+#[derive(Debug)]
+struct Faces{
+	faces:Vec<Vec<integer::Planar64Vec3>>,
+}
+
+fn solve3(c0:&Face,c1:&Face,c2:&Face)->Option<Ratio<Vector3<Fixed<3,96>>,Fixed<3,96>>>{
+	let n0_n1=c0.normal.cross(c1.normal);
+	let det=c2.normal.dot(n0_n1);
+	if det.abs().is_zero(){
+		return None;
+	}
+	Some((
+		c1.normal.cross(c2.normal)*c0.dot
+		+c2.normal.cross(c0.normal)*c1.dot
+		+c0.normal.cross(c1.normal)*c2.dot
+	)/det)
+}
+
+#[derive(Debug)]
+pub enum PlanesToFacesError{
+	InitFace1,
+	InitFace2,
+	InitIntersection,
+	FindNewIntersection,
+	EmptyFaces,
+	InfiniteLoop1,
+	InfiniteLoop2,
+}
+impl std::fmt::Display for PlanesToFacesError{
+	fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
+		write!(f,"{self:?}")
+	}
+}
+impl core::error::Error for PlanesToFacesError{}
+
+fn planes_to_faces(face_list:std::collections::HashSet<Face>)->Result<Faces,PlanesToFacesError>{
+	let mut faces=Vec::new();
+	// for each face, determine one edge at a time until you complete the face
+	'face: for face0 in &face_list{
+		// 1. find first edge
+		// 2. follow edges around face
+
+		// === finding first edge ===
+		// 1. pick the most perpendicular set of 3 faces
+		// 2. check if any faces occlude the intersection
+		// 3. use this test to replace left and right alternating until they are not occluded
+
+		// find the most perpendicular face to face0
+		let mut face1=face_list.iter().min_by_key(|&p|{
+			face0.normal.dot(p.normal).abs()
+		}).ok_or(PlanesToFacesError::InitFace1)?;
+
+		// direction of edge formed by face0 x face1
+		let edge_dir=face0.normal.cross(face1.normal);
+
+		// find the most perpendicular face to both face0 and face1
+		let mut face2=face_list.iter().max_by_key(|&p|{
+			// find the best *oriented* face (no .abs())
+			edge_dir.dot(p.normal)
+		}).ok_or(PlanesToFacesError::InitFace2)?;
+
+		let mut detect_loop=200u8;
+
+		let mut intersection=solve3(face0,face1,face2).ok_or(PlanesToFacesError::InitIntersection)?;
+
+		// repeatedly update face1, face2 until all faces form part of the convex solid
+		'find: loop{
+			detect_loop=detect_loop.checked_sub(1).ok_or(PlanesToFacesError::InfiniteLoop1)?;
+			// 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){
+					// 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){
+							face1=new_face;
+							intersection=new_intersection;
+							continue 'find;
+						}
+					}
+					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){
+							face2=new_face;
+							intersection=new_intersection;
+							continue 'find;
+						}
+					}
+				}
+			}
+
+			// we have found a set of faces for which the intersection is on the convex solid
+			break 'find;
+		}
+
+		// check if face0 must go, meaning it is a degenerate face and does not contribute anything to the convex solid
+		for new_face in &face_list{
+			if core::ptr::eq(face0,new_face){
+				continue;
+			}
+			if core::ptr::eq(face1,new_face){
+				continue;
+			}
+			if core::ptr::eq(face2,new_face){
+				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){
+				// abort! reject face0 entirely
+				continue 'face;
+			}
+		}
+
+		// === follow edges around face ===
+		// Note that we chose face2 such that the 3 faces create a particular winding order.
+		// If we choose a consistent face to follow (face1, face2) it will always wind with a consistent chirality
+
+		let mut detect_loop=200u8;
+
+		// keep looping until we meet this face again
+		let face1=face1;
+		let mut face=Vec::new();
+		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());
+
+			// we looped back around to face1, we're done!
+			if core::ptr::eq(face1,face2){
+				break;
+			}
+
+			// the measure
+			let edge_dir=face0.normal.cross(face2.normal);
+
+			// the dot product to beat
+			let d_intersection=edge_dir.dot(intersection.num)/intersection.den;
+
+			// find the next face moving clockwise around face0
+			let (new_face,new_intersection,_)=face_list.iter().filter_map(|new_face|{
+				// ignore faces that are part of the current edge
+				if core::ptr::eq(face0,new_face)
+				  |core::ptr::eq(face2,new_face){
+					return None;
+				}
+				let new_intersection=solve3(face0,face2,new_face)?;
+
+				// the d value must be larger
+				let d_new_intersection=edge_dir.dot(new_intersection.num)/new_intersection.den;
+				if d_new_intersection.le_ratio(d_intersection){
+					return None;
+				}
+
+				Some((new_face,new_intersection,d_new_intersection))
+			}).min_by_key(|&(_,_,d)|d).ok_or(PlanesToFacesError::FindNewIntersection)?;
+
+			face2=new_face;
+			intersection=new_intersection;
+
+			detect_loop=detect_loop.checked_sub(1).ok_or(PlanesToFacesError::InfiniteLoop2)?;
+		}
+
+		faces.push(face);
+	}
+
+	if faces.is_empty(){
+		Err(PlanesToFacesError::EmptyFaces)
+	}else{
+		Ok(Faces{
+			faces,
+		})
+	}
+}
+
+#[allow(dead_code)]
+#[derive(Debug)]
+pub enum BrushToMeshError{
+	SliceBrushSides,
+	MissingPlane,
+	InvalidFaceCount{
+		count:usize,
+	},
+	InvalidPlanes(PlanesToFacesError),
+}
+impl std::fmt::Display for BrushToMeshError{
+	fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
+		write!(f,"{self:?}")
+	}
+}
+impl core::error::Error for BrushToMeshError{}
+
+pub fn faces_to_mesh(faces:Vec<Vec<integer::Planar64Vec3>>)->model::Mesh{
+	// generate the mesh
+	let mut mb=model::MeshBuilder::new();
+	let color=mb.acquire_color_id(glam::Vec4::ONE);
+	let tex=mb.acquire_tex_id(glam::Vec2::ZERO);
+	// normals are ignored by physics
+	let normal=mb.acquire_normal_id(integer::vec3::ZERO);
+
+	let 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{
+				pos,
+				tex,
+				normal,
+				color,
+			})
+		}).collect()
+	}).collect();
+
+	let polygon_groups=vec![model::PolygonGroup::PolygonList(model::PolygonList::new(polygon_list))];
+	let physics_groups=vec![model::IndexedPhysicsGroup{
+		groups:vec![model::PolygonGroupId::new(0)],
+	}];
+	let graphics_groups=vec![];
+
+	mb.build(polygon_groups,graphics_groups,physics_groups)
+}
+
+pub fn brush_to_mesh(bsp:&vbsp::Bsp,brush:&vbsp::Brush)->Result<model::Mesh,BrushToMeshError>{
+	let brush_start_idx=brush.brush_side as usize;
+	let sides_range=brush_start_idx..brush_start_idx+brush.num_brush_sides as usize;
+	let sides=bsp.brush_sides.get(sides_range).ok_or(BrushToMeshError::SliceBrushSides)?;
+	let face_list=sides.iter().map(|side|{
+		// 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.texture_info(side.texture_info as usize){
+			if texture_info.flags.intersects(TUMOR){
+				return None;
+			}
+		}
+		let plane=bsp.plane(side.plane as usize)?;
+		Some(Face{
+			normal:valve_transform_normal(plane.normal.into()),
+			dot:valve_transform_dist(plane.dist.into()),
+		})
+	}).collect::<Option<std::collections::HashSet<_>>>().ok_or(BrushToMeshError::MissingPlane)?;
+
+	if face_list.len()<4{
+		return Err(BrushToMeshError::InvalidFaceCount{count:face_list.len()});
+	}
+
+	let faces=planes_to_faces(face_list).map_err(BrushToMeshError::InvalidPlanes)?;
+
+	let mesh=faces_to_mesh(faces.faces);
+
+	Ok(mesh)
+}
+
+pub fn unit_cube()->model::Mesh{
+	let face_list=[
+		Face{normal:integer::vec3::X,dot:Planar64::ONE},
+		Face{normal:integer::vec3::Y,dot:Planar64::ONE},
+		Face{normal:integer::vec3::Z,dot:Planar64::ONE},
+		Face{normal:integer::vec3::NEG_X,dot:Planar64::ONE},
+		Face{normal:integer::vec3::NEG_Y,dot:Planar64::ONE},
+		Face{normal:integer::vec3::NEG_Z,dot:Planar64::ONE},
+	].into_iter().collect();
+	let faces=planes_to_faces(face_list).unwrap();
+	let mesh=faces_to_mesh(faces.faces);
+	mesh
+}
+
+#[cfg(test)]
+mod test{
+	use super::*;
+	#[test]
+	fn test_cube(){
+		let face_list=[
+			Face{normal:integer::vec3::X,dot:Planar64::ONE},
+			Face{normal:integer::vec3::Y,dot:Planar64::ONE},
+			Face{normal:integer::vec3::Z,dot:Planar64::ONE},
+			Face{normal:integer::vec3::NEG_X,dot:Planar64::ONE},
+			Face{normal:integer::vec3::NEG_Y,dot:Planar64::ONE},
+			Face{normal:integer::vec3::NEG_Z,dot:Planar64::ONE},
+		].into_iter().collect();
+		let faces=planes_to_faces(face_list).unwrap();
+		assert_eq!(faces.faces.len(),6);
+		dbg!(faces);
+	}
+	#[test]
+	fn test_cube_with_degernate_face(){
+		let face_list=[
+			Face{normal:integer::vec3::X,dot:Planar64::ONE},
+			Face{normal:integer::vec3::Y,dot:Planar64::ONE},
+			Face{normal:integer::vec3::Z,dot:Planar64::ONE},
+			Face{normal:integer::vec3::NEG_X,dot:Planar64::ONE},
+			Face{normal:integer::vec3::NEG_Y,dot:Planar64::ONE},
+			Face{normal:integer::vec3::NEG_Z,dot:Planar64::ONE},
+			Face{normal:integer::vec3::NEG_Z,dot:Planar64::EPSILON},
+		].into_iter().collect();
+		let faces=planes_to_faces(face_list).unwrap();
+		assert_eq!(faces.faces.len(),6);
+		dbg!(faces);
+	}
+	#[test]
+	fn test_cube_with_degernate_face2(){
+		let face_list=[
+			Face{normal:integer::vec3::X,dot:Planar64::ONE},
+			Face{normal:integer::vec3::Y,dot:Planar64::ONE},
+			Face{normal:integer::vec3::Z,dot:Planar64::ONE},
+			Face{normal:integer::vec3::NEG_X,dot:Planar64::ONE},
+			Face{normal:integer::vec3::NEG_Y,dot:Planar64::ONE},
+			Face{normal:integer::vec3::NEG_Z,dot:Planar64::ONE},
+			Face{normal:integer::vec3::NEG_X+integer::vec3::NEG_Z,dot:-Planar64::EPSILON},
+		].into_iter().collect();
+		let faces=planes_to_faces(face_list).unwrap();
+		assert_eq!(faces.faces.len(),5);
+		dbg!(faces);
+	}
+	#[test]
+	fn test_cube_with_degernate_face3(){
+		let face_list=[
+			Face{normal:integer::vec3::X,dot:Planar64::ONE},
+			Face{normal:integer::vec3::Y,dot:Planar64::ONE},
+			Face{normal:integer::vec3::Z,dot:Planar64::ONE},
+			Face{normal:integer::vec3::NEG_X,dot:Planar64::ONE},
+			Face{normal:integer::vec3::NEG_Y,dot:Planar64::ONE},
+			Face{normal:integer::vec3::NEG_Z,dot:Planar64::ONE},
+			Face{normal:integer::vec3::NEG_X+integer::vec3::NEG_Z,dot:Planar64::EPSILON},
+		].into_iter().collect();
+		let faces=planes_to_faces(face_list).unwrap();
+		assert_eq!(faces.faces.len(),7);
+		dbg!(faces);
+	}
+}

lib/bsp_loader/src/bsp.rs

@@ -1,43 +1,142 @@
-use strafesnet_common::{map,model,integer,gameplay_attributes};
+use std::borrow::Cow;
 
-const VALVE_SCALE:f32=1.0/16.0;
-fn valve_transform([x,y,z]:[f32;3])->integer::Planar64Vec3{
-	integer::vec3::try_from_f32_array([x*VALVE_SCALE,z*VALVE_SCALE,-y*VALVE_SCALE]).unwrap()
+use vbsp_entities_css::Entity;
+
+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;
+
+fn ingest_vertex(
+	mb:&mut model::MeshBuilder,
+	world_position:vbsp::Vector,
+	texture_transform_u:glam::Vec4,
+	texture_transform_v:glam::Vec4,
+	normal:model::NormalId,
+	color:model::ColorId,
+)->model::VertexId{
+	//world_model.origin seems to always be 0,0,0
+	let vertex_xyz=world_position.into();
+	let pos=mb.acquire_pos_id(valve_transform(vertex_xyz));
+
+	//calculate texture coordinates
+	let pos_4d=glam::Vec3::from_array(vertex_xyz).extend(1.0);
+	let tex=glam::vec2(texture_transform_u.dot(pos_4d),texture_transform_v.dot(pos_4d));
+	let tex=mb.acquire_tex_id(tex);
+
+	mb.acquire_vertex_id(model::IndexedVertex{
+		pos,
+		tex,
+		normal,
+		color,
+	})
 }
-pub fn convert_bsp<AcquireRenderConfigId,AcquireMeshId>(
-	bsp:&vbsp::Bsp,
-	mut acquire_render_config_id:AcquireRenderConfigId,
-	mut acquire_mesh_id:AcquireMeshId
-)->PartialMap1
-where
-	AcquireRenderConfigId:FnMut(Option<&str>)->model::RenderConfigId,
-	AcquireMeshId:FnMut(&str)->model::MeshId,
-{
-	//figure out real attributes later
-	let mut unique_attributes=Vec::new();
-	unique_attributes.push(gameplay_attributes::CollisionAttributes::Decoration);
-	const TEMP_TOUCH_ME_ATTRIBUTE:gameplay_attributes::CollisionAttributesId=gameplay_attributes::CollisionAttributesId::new(0);
 
-	let mut prop_mesh_count=0;
+fn add_brush<'a>(
+	mesh_deferred_loader:&mut MeshDeferredLoader<&'a str>,
+	world_models:&mut Vec<model::Model>,
+	prop_models:&mut Vec<model::Model>,
+	model:&'a str,
+	origin:vbsp::Vector,
+	rendercolor:vbsp::Color,
+	attributes:attr::CollisionAttributesId,
+){
+	let transform=integer::Planar64Affine3::from_translation(
+		valve_transform(origin.into())
+	);
+	let color=(glam::Vec3::from_array([
+		rendercolor.r as f32,
+		rendercolor.g as f32,
+		rendercolor.b as f32
+	])/255.0).extend(1.0);
+
+	match model.chars().next(){
+		// The first character of brush.model is '*'
+		Some('*')=>match model[1..].parse(){
+			Ok(mesh_id)=>{
+				let mesh=model::MeshId::new(mesh_id);
+				world_models.push(
+					model::Model{mesh,attributes,transform,color}
+				);
+			},
+			Err(e)=>{
+				println!("Brush model int parse error: {e} model={model}");
+				return;
+			},
+		},
+		_=>{
+			let mesh=mesh_deferred_loader.acquire_mesh_id(model);
+			prop_models.push(
+				model::Model{mesh,attributes,transform,color}
+			);
+		}
+	}
+}
+
+pub fn convert<'a>(
+	bsp:&'a crate::Bsp,
+	render_config_deferred_loader:&mut RenderConfigDeferredLoader<Cow<'a,str>>,
+	mesh_deferred_loader:&mut MeshDeferredLoader<&'a str>,
+)->PartialMap1{
+	let bsp=bsp.as_ref();
+	//figure out real attributes later
+	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 prop_models=bsp.static_props().map(|prop|{
+	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=acquire_mesh_id(prop.model());
-		//not the most failsafe code but this is just for the map tool lmao
-		if prop_mesh_count==mesh_id.get(){
-			prop_mesh_count+=1;
-		};
-		let placement=prop.as_prop_placement();
+		let mesh_id=mesh_deferred_loader.acquire_mesh_id(prop.model());
 		model::Model{
 			mesh:mesh_id,
-			attributes:TEMP_TOUCH_ME_ATTRIBUTE,
+			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,
 		}
@@ -47,14 +146,12 @@ where
 
 	//the generated MeshIds in here will collide with the Loader Mesh Ids
 	//but I can't think of a good workaround other than just remapping one later.
-	let world_meshes:Vec<model::Mesh>=bsp.models().map(|world_model|{
-		//non-deduplicated
-		let mut spam_pos=Vec::new();
-		let mut spam_tex=Vec::new();
-		let mut spam_normal=Vec::new();
-		let mut spam_vertices=Vec::new();
+	let mut world_meshes:Vec<model::Mesh>=bsp.models().map(|world_model|{
+		let mut mb=model::MeshBuilder::new();
+
+		let color=mb.acquire_color_id(glam::Vec4::ONE);
 		let mut graphics_groups=Vec::new();
-		let mut physics_group=model::IndexedPhysicsGroup::default();
+		let mut render_id_to_graphics_group_id=std::collections::HashMap::new();
 		let polygon_groups=world_model.faces().enumerate().map(|(polygon_group_id,face)|{
 			let polygon_group_id=model::PolygonGroupId::new(polygon_group_id as u32);
 			let face_texture=face.texture();
@@ -63,139 +160,200 @@ where
 			let texture_transform_u=glam::Vec4::from_array(face_texture.texture_transforms_u)/(face_texture_data.width as f32);
 			let texture_transform_v=glam::Vec4::from_array(face_texture.texture_transforms_v)/(face_texture_data.height as f32);
 
-			//this automatically figures out what the texture is trying to do and creates
-			//a render config for it, and then returns the id to that render config
-			let render_id=acquire_render_config_id(Some(face_texture_data.name()));
-
 			//normal
-			let normal=face.normal();
-			let normal_idx=spam_normal.len() as u32;
-			spam_normal.push(valve_transform(normal.into()));
-			let mut polygon_iter=face.vertex_positions().map(|vertex_position|{
-				//world_model.origin seems to always be 0,0,0
-				let vertex_xyz=(world_model.origin+vertex_position).into();
-				let pos_idx=spam_pos.len();
-				spam_pos.push(valve_transform(vertex_xyz));
-
-				//calculate texture coordinates
-				let pos=glam::Vec3::from_array(vertex_xyz).extend(1.0);
-				let tex=glam::vec2(texture_transform_u.dot(pos),texture_transform_v.dot(pos));
-				let tex_idx=spam_tex.len() as u32;
-				spam_tex.push(tex);
-
-				let vertex_id=model::VertexId::new(spam_vertices.len() as u32);
-				spam_vertices.push(model::IndexedVertex{
-					pos:model::PositionId::new(pos_idx as u32),
-					tex:model::TextureCoordinateId::new(tex_idx as u32),
-					normal:model::NormalId::new(normal_idx),
-					color:model::ColorId::new(0),
-				});
-				vertex_id
-			});
+			let normal=mb.acquire_normal_id(valve_transform(face.normal().into()));
+			let mut polygon_iter=face.vertex_positions().map(|vertex_position|
+				world_model.origin+vertex_position
+			);
 			let polygon_list=std::iter::from_fn(move||{
 				match (polygon_iter.next(),polygon_iter.next(),polygon_iter.next()){
-					(Some(v1),Some(v2),Some(v3))=>Some(vec![v1,v2,v3]),
+					(Some(v1),Some(v2),Some(v3))=>Some([v1,v2,v3]),
 					//ignore extra vertices, not sure what to do in this case, failing the whole conversion could be appropriate
 					_=>None,
 				}
+			}).map(|triplet|{
+				triplet.map(|world_position|
+					ingest_vertex(&mut mb,world_position,texture_transform_u,texture_transform_v,normal,color)
+				).to_vec()
 			}).collect();
 			if face.is_visible(){
-				//TODO: deduplicate graphics groups by render id
-				graphics_groups.push(model::IndexedGraphicsGroup{
-					render:render_id,
-					groups:vec![polygon_group_id],
-				})
+				//this automatically figures out what the texture is trying to do and creates
+				//a render config for it, and then returns the id to that render config
+				let render_id=render_config_deferred_loader.acquire_render_config_id(Some(Cow::Borrowed(face_texture_data.name())));
+				//deduplicate graphics groups by render id
+				let graphics_group_id=*render_id_to_graphics_group_id.entry(render_id).or_insert_with(||{
+					let graphics_group_id=graphics_groups.len();
+					graphics_groups.push(model::IndexedGraphicsGroup{
+						render:render_id,
+						groups:vec![],
+					});
+					graphics_group_id
+				});
+				graphics_groups[graphics_group_id].groups.push(polygon_group_id);
 			}
-			physics_group.groups.push(polygon_group_id);
 			model::PolygonGroup::PolygonList(model::PolygonList::new(polygon_list))
 		}).collect();
-		model::Mesh{
-			unique_pos:spam_pos,
-			unique_tex:spam_tex,
-			unique_normal:spam_normal,
-			unique_color:vec![glam::Vec4::ONE],
-			unique_vertices:spam_vertices,
-			polygon_groups,
-			graphics_groups,
-			physics_groups:vec![physics_group],
-		}
+
+		mb.build(polygon_groups,graphics_groups,vec![])
 	}).collect();
 
-	let world_models:Vec<model::Model>=
-	//one instance of the main world mesh
-	std::iter::once((
-		//world_model
-		model::MeshId::new(0),
-		//model_origin
-		vbsp::Vector::from([0.0,0.0,0.0]),
-		//model_color
-		vbsp::Color{r:255,g:255,b:255},
-	)).chain(
-		//entities sprinkle instances of the other meshes around
-		bsp.entities.iter()
-		.flat_map(|ent|ent.parse())//ignore entity parsing errors
-		.filter_map(|ent|match ent{
-			vbsp::Entity::Brush(brush)=>Some(brush),
-			vbsp::Entity::BrushIllusionary(brush)=>Some(brush),
-			vbsp::Entity::BrushWall(brush)=>Some(brush),
-			vbsp::Entity::BrushWallToggle(brush)=>Some(brush),
-			_=>None,
-		}).flat_map(|brush|
-			//The first character of brush.model is '*'
-			brush.model[1..].parse().map(|mesh_id|//ignore parse int errors
-				(model::MeshId::new(mesh_id),brush.origin,brush.color)
-			)
-		)
-	).map(|(mesh_id,model_origin,vbsp::Color{r,g,b})|{
-		model::Model{
-			mesh:mesh_id,
-			attributes:TEMP_TOUCH_ME_ATTRIBUTE,
-			transform:integer::Planar64Affine3::new(
-				integer::mat3::identity(),
-				valve_transform(model_origin.into())
-			),
-			color:(glam::Vec3::from_array([r as f32,g as f32,b as f32])/255.0).extend(1.0),
+	let mut found_spawn=None;
+
+	let mut world_models=Vec::new();
+
+	// the one and only world model 0
+	world_models.push(model::Model{
+		mesh:model::MeshId::new(0),
+		attributes:ATTRIBUTE_DECORATION,
+		transform:integer::Planar64Affine3::IDENTITY,
+		color:glam::Vec4::W,
+	});
+
+	const WHITE:vbsp::Color=vbsp::Color{r:255,g:255,b:255};
+	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,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),
+			Ok(Entity::FuncDoor(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin,brush.rendercolor,ATTRIBUTE_DECORATION),
+			Ok(Entity::FuncDoorRotating(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin,brush.rendercolor,ATTRIBUTE_DECORATION),
+			Ok(Entity::FuncIllusionary(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin,brush.rendercolor,ATTRIBUTE_DECORATION),
+			Ok(Entity::FuncMonitor(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin,brush.rendercolor,ATTRIBUTE_DECORATION),
+			Ok(Entity::FuncMovelinear(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin,brush.rendercolor,ATTRIBUTE_DECORATION),
+			Ok(Entity::FuncPhysbox(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin,brush.rendercolor,ATTRIBUTE_DECORATION),
+			Ok(Entity::FuncPhysboxMultiplayer(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin,brush.rendercolor,ATTRIBUTE_DECORATION),
+			Ok(Entity::FuncRotButton(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin,WHITE,ATTRIBUTE_DECORATION),
+			Ok(Entity::FuncRotating(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin,brush.rendercolor,ATTRIBUTE_DECORATION),
+			Ok(Entity::FuncTracktrain(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin,brush.rendercolor,ATTRIBUTE_DECORATION),
+			Ok(Entity::FuncTrain(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin,brush.rendercolor,ATTRIBUTE_DECORATION),
+			Ok(Entity::FuncWall(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin.unwrap_or_default(),brush.rendercolor,ATTRIBUTE_DECORATION),
+			Ok(Entity::FuncWallToggle(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin.unwrap_or_default(),brush.rendercolor,ATTRIBUTE_DECORATION),
+			Ok(Entity::FuncWaterAnalog(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin,brush.rendercolor.unwrap_or(WHITE),ATTRIBUTE_DECORATION),
+			Ok(Entity::PropDoorRotating(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin,WHITE,ATTRIBUTE_DECORATION),
+			Ok(Entity::PropDynamic(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin,WHITE,ATTRIBUTE_DECORATION),
+			Ok(Entity::PropDynamicOverride(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin,WHITE,ATTRIBUTE_DECORATION),
+			Ok(Entity::PropPhysics(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin,WHITE,ATTRIBUTE_DECORATION),
+			Ok(Entity::PropPhysicsMultiplayer(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin,WHITE,ATTRIBUTE_DECORATION),
+			Ok(Entity::PropPhysicsOverride(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin,WHITE,ATTRIBUTE_DECORATION),
+			Ok(Entity::PropRagdoll(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin,WHITE,ATTRIBUTE_DECORATION),
+			Ok(Entity::TriggerGravity(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin,WHITE,ATTRIBUTE_DECORATION),
+			Ok(Entity::TriggerHurt(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin,WHITE,ATTRIBUTE_DECORATION),
+			Ok(Entity::TriggerLook(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin,WHITE,ATTRIBUTE_DECORATION),
+			Ok(Entity::TriggerMultiple(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model.unwrap_or_default(),brush.origin,WHITE,ATTRIBUTE_DECORATION),
+			Ok(Entity::TriggerOnce(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin,WHITE,ATTRIBUTE_DECORATION),
+			Ok(Entity::TriggerProximity(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin,WHITE,ATTRIBUTE_DECORATION),
+			Ok(Entity::TriggerPush(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin,WHITE,ATTRIBUTE_DECORATION),
+			Ok(Entity::TriggerSoundscape(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin,WHITE,ATTRIBUTE_DECORATION),
+			Ok(Entity::TriggerTeleport(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model.unwrap_or_default(),brush.origin,WHITE,ATTRIBUTE_DECORATION),
+			Ok(Entity::TriggerVphysicsMotion(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin,WHITE,ATTRIBUTE_DECORATION),
+			Ok(Entity::TriggerWind(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin,WHITE,ATTRIBUTE_DECORATION),
+			Ok(Entity::InfoPlayerCounterterrorist(spawn))=>{
+				found_spawn=Some(valve_transform(spawn.origin.into()));
+			},
+			Ok(Entity::InfoPlayerTerrorist(spawn))=>{
+				found_spawn=Some(valve_transform(spawn.origin.into()));
+			},
+			Err(e)=>{
+				println!("Bsp Entity parse error: {e}");
+			},
+			_=>(),
 		}
-	}).collect();
+	}
+
+	// physics models
+	for brush in &bsp.brushes{
+		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)=>{
+				let mesh_id=model::MeshId::new(world_meshes.len() as u32);
+				world_meshes.push(mesh);
+				world_models.push(model::Model{
+					mesh:mesh_id,
+					attributes,
+					transform:integer::Planar64Affine3::new(
+						integer::mat3::identity(),
+						integer::vec3::ZERO,
+					),
+					color:glam::Vec4::ONE,
+				});
+			},
+			Err(e)=>println!("Brush mesh error: {e}"),
+		}
+	}
+
+	let mut modes_list=Vec::new();
+	if let Some(spawn_point)=found_spawn{
+		// create a new mesh
+		let mesh_id=model::MeshId::new(world_meshes.len() as u32);
+		world_meshes.push(crate::brush::unit_cube());
+		// create a new model
+		let model_id=model::ModelId::new(world_models.len() as u32);
+		world_models.push(model::Model{
+			mesh:mesh_id,
+			attributes:ATTRIBUTE_INTERSECT_DEFAULT,
+			transform:integer::Planar64Affine3::from_translation(spawn_point),
+			color:glam::Vec4::W,
+		});
+
+		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(NormalizedMode::new(main_mode));
+	}
 
 	PartialMap1{
 		attributes:unique_attributes,
 		world_meshes,
 		prop_models,
 		world_models,
-		modes:strafesnet_common::gameplay_modes::Modes::new(Vec::new()),
+		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<AcquireRenderConfigId>(
+	pub fn add_prop_meshes<'a>(
 		self,
-		prop_meshes:impl IntoIterator<Item=(model::MeshId,crate::data::ModelData)>,
-		mut acquire_render_config_id:AcquireRenderConfigId,
-	)->PartialMap2
-	where
-		AcquireRenderConfigId:FnMut(Option<&str>)->model::RenderConfigId,
-	{
+		prop_meshes:Meshes,
+	)->PartialMap2{
 		PartialMap2{
 			attributes:self.attributes,
-			prop_meshes:prop_meshes.into_iter().filter_map(|(mesh_id,model_data)|
-				//this will generate new render ids and texture ids
-				match convert_mesh(model_data,&mut acquire_render_config_id){
-					Ok(mesh)=>Some((mesh_id,mesh)),
-					Err(e)=>{
-						println!("error converting mesh: {e}");
-						None
-					}
-				}
-			).collect(),
+			prop_meshes:prop_meshes.consume().collect(),
 			prop_models:self.prop_models,
 			world_meshes:self.world_meshes,
 			world_models:self.world_models,
@@ -204,18 +362,17 @@ 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(
 		mut self,
-		render_configs:impl IntoIterator<Item=(model::RenderConfigId,model::RenderConfig)>,
-		textures:impl IntoIterator<Item=(model::TextureId,Vec<u8>)>,
+		render_configs:RenderConfigs,
 	)->map::CompleteMap{
 		//merge mesh and model lists, flatten and remap all ids
 		let mesh_id_offset=self.world_meshes.len();
@@ -234,13 +391,14 @@ impl PartialMap2{
 			})
 		));
 		//let mut models=Vec::new();
+		let (textures,render_configs)=render_configs.consume();
 		let (textures,texture_id_map):(Vec<Vec<u8>>,std::collections::HashMap<model::TextureId,model::TextureId>)
 		=textures.into_iter()
 		//.filter_map(f) cull unused textures
-		.enumerate().map(|(new_texture_id,(old_texture_id,texture))|{
+		.enumerate().map(|(new_texture_id,(old_texture_id,Texture::ImageDDS(texture)))|{
 			(texture,(old_texture_id,model::TextureId::new(new_texture_id as u32)))
 		}).unzip();
-		let render_configs=render_configs.into_iter().map(|(render_config_id,mut render_config)|{
+		let render_configs=render_configs.into_iter().map(|(_render_config_id,mut render_config)|{
 			//this may generate duplicate no-texture render configs but idc
 			render_config.texture=render_config.texture.and_then(|texture_id|
 				texture_id_map.get(&texture_id).copied()
@@ -257,77 +415,3 @@ impl PartialMap2{
 		}
 	}
 }
-
-fn convert_mesh<AcquireRenderConfigId>(
-	model_data:crate::data::ModelData,
-	acquire_render_config_id:&mut AcquireRenderConfigId,
-)->Result<model::Mesh,vmdl::ModelError>
-where
-	AcquireRenderConfigId:FnMut(Option<&str>)->model::RenderConfigId,
-{
-	let model=model_data.read_model()?;
-	let texture_paths=model.texture_directories();
-	if texture_paths.len()!=1{
-		println!("WARNING: multiple texture paths");
-	}
-	let skin=model.skin_tables().nth(0).unwrap();
-
-	let mut spam_pos=Vec::with_capacity(model.vertices().len());
-	let mut spam_normal=Vec::with_capacity(model.vertices().len());
-	let mut spam_tex=Vec::with_capacity(model.vertices().len());
-	let mut spam_vertices=Vec::with_capacity(model.vertices().len());
-	for (i,vertex) in model.vertices().iter().enumerate(){
-		spam_pos.push(valve_transform(vertex.position.into()));
-		spam_normal.push(valve_transform(vertex.normal.into()));
-		spam_tex.push(glam::Vec2::from_array(vertex.texture_coordinates));
-		spam_vertices.push(model::IndexedVertex{
-			pos:model::PositionId::new(i as u32),
-			tex:model::TextureCoordinateId::new(i as u32),
-			normal:model::NormalId::new(i as u32),
-			color:model::ColorId::new(0),
-		});
-	}
-	let mut graphics_groups=Vec::new();
-	let mut physics_groups=Vec::new();
-	let polygon_groups=model.meshes().enumerate().map(|(polygon_group_id,mesh)|{
-		let polygon_group_id=model::PolygonGroupId::new(polygon_group_id as u32);
-
-		let render_id=if let (Some(texture_path),Some(texture_name))=(texture_paths.get(0),skin.texture(mesh.material_index())){
-			let mut path=std::path::PathBuf::from(texture_path.as_str());
-			path.push(texture_name);
-			acquire_render_config_id(path.as_os_str().to_str())
-		}else{
-			acquire_render_config_id(None)
-		};
-
-		graphics_groups.push(model::IndexedGraphicsGroup{
-			render:render_id,
-			groups:vec![polygon_group_id],
-		});
-		physics_groups.push(model::IndexedPhysicsGroup{
-			groups:vec![polygon_group_id],
-		});
-		model::PolygonGroup::PolygonList(model::PolygonList::new(
-			//looking at the code, it would seem that the strips are pre-deindexed into triangle lists when calling this function
-			mesh.vertex_strip_indices().flat_map(|mut strip|
-				std::iter::from_fn(move||{
-					match (strip.next(),strip.next(),strip.next()){
-						(Some(v1),Some(v2),Some(v3))=>Some([v1,v2,v3].map(|vertex_id|model::VertexId::new(vertex_id as u32)).to_vec()),
-						//ignore extra vertices, not sure what to do in this case, failing the whole conversion could be appropriate
-						_=>None,
-					}
-				})
-			).collect()
-		))
-	}).collect();
-	Ok(model::Mesh{
-		unique_pos:spam_pos,
-		unique_normal:spam_normal,
-		unique_tex:spam_tex,
-		unique_color:vec![glam::Vec4::ONE],
-		unique_vertices:spam_vertices,
-		polygon_groups,
-		graphics_groups,
-		physics_groups,
-	})
-}

lib/bsp_loader/src/data.rs

@@ -1,60 +0,0 @@
-pub struct Bsp(vbsp::Bsp);
-impl Bsp{
-	pub const fn new(value:vbsp::Bsp)->Self{
-		Self(value)
-	}
-}
-impl AsRef<vbsp::Bsp> for Bsp{
-	fn as_ref(&self)->&vbsp::Bsp{
-		&self.0
-	}
-}
-
-pub struct MdlData(Vec<u8>);
-impl MdlData{
-	pub const fn new(value:Vec<u8>)->Self{
-		Self(value)
-	}
-}
-impl AsRef<[u8]> for MdlData{
-	fn as_ref(&self)->&[u8]{
-		self.0.as_ref()
-	}
-}
-pub struct VtxData(Vec<u8>);
-impl VtxData{
-	pub const fn new(value:Vec<u8>)->Self{
-		Self(value)
-	}
-}
-impl AsRef<[u8]> for VtxData{
-	fn as_ref(&self)->&[u8]{
-		self.0.as_ref()
-	}
-}
-pub struct VvdData(Vec<u8>);
-impl VvdData{
-	pub const fn new(value:Vec<u8>)->Self{
-		Self(value)
-	}
-}
-impl AsRef<[u8]> for VvdData{
-	fn as_ref(&self)->&[u8]{
-		self.0.as_ref()
-	}
-}
-
-pub struct ModelData{
-	pub mdl:MdlData,
-	pub vtx:VtxData,
-	pub vvd:VvdData,
-}
-impl ModelData{
-	pub fn read_model(&self)->Result<vmdl::Model,vmdl::ModelError>{
-		Ok(vmdl::Model::from_parts(
-			vmdl::mdl::Mdl::read(self.mdl.as_ref())?,
-			vmdl::vtx::Vtx::read(self.vtx.as_ref())?,
-			vmdl::vvd::Vvd::read(self.vvd.as_ref())?,
-		))
-	}
-}

lib/bsp_loader/src/lib.rs

@@ -1,7 +1,20 @@
-mod bsp;
-pub mod data;
+use strafesnet_deferred_loader::deferred_loader::{LoadFailureMode,MeshDeferredLoader,RenderConfigDeferredLoader};
 
-pub use data::Bsp;
+mod bsp;
+mod mesh;
+mod brush;
+pub mod loader;
+
+const VALVE_SCALE:f32=1.0/16.0;
+pub(crate) fn valve_transform_dist(d:f32)->strafesnet_common::integer::Planar64{
+	(d*VALVE_SCALE).try_into().unwrap()
+}
+pub(crate) fn valve_transform_normal([x,y,z]:[f32;3])->strafesnet_common::integer::Planar64Vec3{
+	strafesnet_common::integer::vec3::try_from_f32_array([x,z,-y]).unwrap()
+}
+pub(crate) fn valve_transform([x,y,z]:[f32;3])->strafesnet_common::integer::Planar64Vec3{
+	strafesnet_common::integer::vec3::try_from_f32_array([x*VALVE_SCALE,z*VALVE_SCALE,-y*VALVE_SCALE]).unwrap()
+}
 
 #[derive(Debug)]
 pub enum ReadError{
@@ -15,6 +28,38 @@ impl std::fmt::Display for ReadError{
 }
 impl std::error::Error for ReadError{}
 
+
+#[derive(Debug)]
+pub enum LoadError{
+	Texture(loader::TextureError),
+	Mesh(loader::MeshError),
+}
+impl std::fmt::Display for LoadError{
+	fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
+		write!(f,"{self:?}")
+	}
+}
+impl std::error::Error for LoadError{}
+impl From<loader::TextureError> for LoadError{
+	fn from(value:loader::TextureError)->Self{
+		Self::Texture(value)
+	}
+}
+impl From<loader::MeshError> for LoadError{
+	fn from(value:loader::MeshError)->Self{
+		Self::Mesh(value)
+	}
+}
+pub struct Bsp{
+	bsp:vbsp::Bsp,
+	case_folded_file_names:std::collections::HashMap<String,String>,
+}
+impl AsRef<vbsp::Bsp> for Bsp{
+	fn as_ref(&self)->&vbsp::Bsp{
+		&self.bsp
+	}
+}
+
 pub fn read<R:std::io::Read>(mut input:R)->Result<Bsp,ReadError>{
 	let mut s=Vec::new();
 
@@ -23,15 +68,66 @@ pub fn read<R:std::io::Read>(mut input:R)->Result<Bsp,ReadError>{
 
 	vbsp::Bsp::read(s.as_slice()).map(Bsp::new).map_err(ReadError::Bsp)
 }
+impl Bsp{
+	pub fn new(bsp:vbsp::Bsp)->Self{
+		let case_folded_file_names=bsp.pack.clone().into_zip().lock().unwrap().file_names().map(|s|{
+			(s.to_lowercase(),s.to_owned())
+		}).collect();
+		Self{
+			bsp,
+			case_folded_file_names,
+		}
+	}
+	pub fn pack_get(&self,name_lowercase:&str)->Result<Option<Vec<u8>>,vbsp::BspError>{
+		match self.case_folded_file_names.get(name_lowercase){
+			Some(name_folded)=>self.bsp.pack.get(name_folded),
+			None=>Ok(None),
+		}
+	}
+	pub fn to_snf(&self,failure_mode:LoadFailureMode,vpk_list:&[Vpk])->Result<strafesnet_common::map::CompleteMap,LoadError>{
+		let mut texture_deferred_loader=RenderConfigDeferredLoader::new();
+		let mut mesh_deferred_loader=MeshDeferredLoader::new();
 
-pub fn convert<AcquireRenderConfigId,AcquireMeshId>(
-	bsp:&Bsp,
-	acquire_render_config_id:AcquireRenderConfigId,
-	acquire_mesh_id:AcquireMeshId
-)->bsp::PartialMap1
-where
-	AcquireRenderConfigId:FnMut(Option<&str>)->strafesnet_common::model::RenderConfigId,
-	AcquireMeshId:FnMut(&str)->strafesnet_common::model::MeshId,
-{
-	bsp::convert_bsp(bsp.as_ref(),acquire_render_config_id,acquire_mesh_id)
-}
+		let map_step1=bsp::convert(
+			self,
+			&mut texture_deferred_loader,
+			&mut mesh_deferred_loader,
+		);
+
+		let mut mesh_loader=loader::MeshLoader::new(loader::BspFinder{bsp:self,vpks:vpk_list},&mut texture_deferred_loader);
+		let prop_meshes=mesh_deferred_loader.into_meshes(&mut mesh_loader,failure_mode).map_err(LoadError::Mesh)?;
+
+		let map_step2=map_step1.add_prop_meshes(prop_meshes);
+
+		let mut texture_loader=loader::TextureLoader::new();
+		let render_configs=texture_deferred_loader.into_render_configs(&mut texture_loader,failure_mode).map_err(LoadError::Texture)?;
+
+		let map=map_step2.add_render_configs_and_textures(render_configs);
+
+		Ok(map)
+	}
+}
+pub struct Vpk{
+	vpk:vpk::VPK,
+	case_folded_file_names:std::collections::HashMap<String,String>,
+}
+impl AsRef<vpk::VPK> for Vpk{
+	fn as_ref(&self)->&vpk::VPK{
+		&self.vpk
+	}
+}
+impl Vpk{
+	pub fn new(vpk:vpk::VPK)->Vpk{
+		let case_folded_file_names=vpk.tree.keys().map(|s|{
+			(s.to_lowercase(),s.to_owned())
+		}).collect();
+		Vpk{
+			vpk,
+			case_folded_file_names,
+		}
+	}
+	pub fn tree_get(&self,name_lowercase:&str)->Option<&vpk::entry::VPKEntry>{
+		let name_folded=self.case_folded_file_names.get(name_lowercase)?;
+		self.vpk.tree.get(name_folded)
+	}
+}

lib/bsp_loader/src/loader.rs

@@ -0,0 +1,175 @@
+use std::{borrow::Cow, io::Read};
+
+use strafesnet_common::model::Mesh;
+use strafesnet_deferred_loader::{loader::Loader,texture::Texture};
+
+use crate::{Bsp,Vpk};
+
+#[allow(dead_code)]
+#[derive(Debug)]
+pub enum TextureError{
+	Io(std::io::Error),
+}
+impl std::fmt::Display for TextureError{
+	fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
+		write!(f,"{self:?}")
+	}
+}
+impl std::error::Error for TextureError{}
+impl From<std::io::Error> for TextureError{
+	fn from(value:std::io::Error)->Self{
+		Self::Io(value)
+	}
+}
+
+pub struct TextureLoader<'a>(std::marker::PhantomData<&'a ()>);
+impl TextureLoader<'_>{
+	pub fn new()->Self{
+		Self(std::marker::PhantomData)
+	}
+}
+impl<'a> Loader for TextureLoader<'a>{
+	type Error=TextureError;
+	type Index=Cow<'a,str>;
+	type Resource=Texture;
+	fn load(&mut self,index:Self::Index)->Result<Self::Resource,Self::Error>{
+		let file_name=format!("textures/{}.dds",index);
+		let mut file=std::fs::File::open(file_name)?;
+		let mut data=Vec::new();
+		file.read_to_end(&mut data)?;
+		Ok(Texture::ImageDDS(data))
+	}
+}
+
+#[allow(dead_code)]
+#[derive(Debug)]
+pub enum MeshError{
+	Io(std::io::Error),
+	VMDL(vmdl::ModelError),
+	VBSP(vbsp::BspError),
+	MissingMdl(String),
+	MissingVtx,
+	MissingVvd,
+}
+impl std::fmt::Display for MeshError{
+	fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
+		write!(f,"{self:?}")
+	}
+}
+impl std::error::Error for MeshError{}
+impl From<std::io::Error> for MeshError{
+	fn from(value:std::io::Error)->Self{
+		Self::Io(value)
+	}
+}
+impl From<vmdl::ModelError> for MeshError{
+	fn from(value:vmdl::ModelError)->Self{
+		Self::VMDL(value)
+	}
+}
+impl From<vbsp::BspError> for MeshError{
+	fn from(value:vbsp::BspError)->Self{
+		Self::VBSP(value)
+	}
+}
+
+#[derive(Clone,Copy)]
+pub struct BspFinder<'bsp,'vpk>{
+	pub bsp:&'bsp Bsp,
+	pub vpks:&'vpk [Vpk],
+}
+impl<'bsp,'vpk> BspFinder<'bsp,'vpk>{
+	pub fn find<'a>(&self,path:&str)->Result<Option<Cow<'a,[u8]>>,vbsp::BspError>
+		where
+			'bsp:'a,
+			'vpk:'a,
+	{
+		// search bsp
+		if let Some(data)=self.bsp.pack_get(path)?{
+			return Ok(Some(Cow::Owned(data)));
+		}
+
+		//search each vpk
+		for vpk in self.vpks{
+			if let Some(vpk_entry)=vpk.tree_get(path){
+				return Ok(Some(vpk_entry.get()?));
+			}
+		}
+
+		Ok(None)
+	}
+}
+
+pub struct ModelLoader<'bsp,'vpk,'a>{
+	finder:BspFinder<'bsp,'vpk>,
+	life:core::marker::PhantomData<&'a ()>,
+}
+impl ModelLoader<'_,'_,'_>{
+	#[inline]
+	pub const fn new<'bsp,'vpk,'a>(
+		finder:BspFinder<'bsp,'vpk>,
+	)->ModelLoader<'bsp,'vpk,'a>{
+		ModelLoader{
+			finder,
+			life:core::marker::PhantomData,
+		}
+	}
+}
+impl<'bsp,'vpk,'a> Loader for ModelLoader<'bsp,'vpk,'a>
+	where
+		'bsp:'a,
+		'vpk:'a,
+{
+	type Error=MeshError;
+	type Index=&'a str;
+	type Resource=vmdl::Model;
+	fn load(&mut self,index:Self::Index)->Result<Self::Resource,Self::Error>{
+		let mdl_path_lower=index.to_lowercase();
+		//.mdl, .vvd, .dx90.vtx
+		let path=std::path::PathBuf::from(mdl_path_lower.as_str());
+		let mut vvd_path=path.clone();
+		let mut vtx_path=path;
+		vvd_path.set_extension("vvd");
+		vtx_path.set_extension("dx90.vtx");
+		// TODO: search more packs, possibly using an index of multiple packs
+		let mdl=self.finder.find(mdl_path_lower.as_str())?.ok_or(MeshError::MissingMdl(mdl_path_lower))?;
+		let vtx=self.finder.find(vtx_path.as_os_str().to_str().unwrap())?.ok_or(MeshError::MissingVtx)?;
+		let vvd=self.finder.find(vvd_path.as_os_str().to_str().unwrap())?.ok_or(MeshError::MissingVvd)?;
+		Ok(vmdl::Model::from_parts(
+			vmdl::mdl::Mdl::read(mdl.as_ref())?,
+			vmdl::vtx::Vtx::read(vtx.as_ref())?,
+			vmdl::vvd::Vvd::read(vvd.as_ref())?,
+		))
+	}
+}
+
+pub struct MeshLoader<'bsp,'vpk,'load,'a>{
+	finder:BspFinder<'bsp,'vpk>,
+	deferred_loader:&'load mut strafesnet_deferred_loader::deferred_loader::RenderConfigDeferredLoader<Cow<'a,str>>,
+}
+impl MeshLoader<'_,'_,'_,'_>{
+	#[inline]
+	pub const fn new<'bsp,'vpk,'load,'a>(
+		finder:BspFinder<'bsp,'vpk>,
+		deferred_loader:&'load mut strafesnet_deferred_loader::deferred_loader::RenderConfigDeferredLoader<Cow<'a,str>>,
+	)->MeshLoader<'bsp,'vpk,'load,'a>{
+		MeshLoader{
+			finder,
+			deferred_loader
+		}
+	}
+}
+impl<'bsp,'vpk,'load,'a> Loader for MeshLoader<'bsp,'vpk,'load,'a>
+	where
+		'bsp:'a,
+		'vpk:'a,
+{
+	type Error=MeshError;
+	type Index=&'a str;
+	type Resource=Mesh;
+	fn load(&mut self,index:Self::Index)->Result<Self::Resource,Self::Error>{
+		let model=ModelLoader::new(self.finder).load(index)?;
+		let mesh=crate::mesh::convert_mesh(model,&mut self.deferred_loader);
+		Ok(mesh)
+	}
+}

lib/bsp_loader/src/mesh.rs

@@ -0,0 +1,78 @@
+use std::borrow::Cow;
+
+use strafesnet_common::model;
+use strafesnet_deferred_loader::deferred_loader::RenderConfigDeferredLoader;
+
+use crate::valve_transform;
+
+fn ingest_vertex(mb:&mut model::MeshBuilder,vertex:&vmdl::vvd::Vertex,color:model::ColorId)->model::VertexId{
+	let pos=mb.acquire_pos_id(valve_transform(vertex.position.into()));
+	let normal=mb.acquire_normal_id(valve_transform(vertex.normal.into()));
+	let tex=mb.acquire_tex_id(glam::Vec2::from_array(vertex.texture_coordinates));
+	mb.acquire_vertex_id(model::IndexedVertex{
+		pos,
+		tex,
+		normal,
+		color,
+	})
+}
+
+pub fn convert_mesh(model:vmdl::Model,deferred_loader:&mut RenderConfigDeferredLoader<Cow<str>>)->model::Mesh{
+	let texture_paths=model.texture_directories();
+	if texture_paths.len()!=1{
+		println!("WARNING: multiple texture paths");
+	}
+	let skin=model.skin_tables().nth(0).unwrap();
+
+	let mut mb=model::MeshBuilder::new();
+
+	let color=mb.acquire_color_id(glam::Vec4::ONE);
+
+	let model_vertices=model.vertices();
+
+	let mut graphics_groups=Vec::new();
+	let mut physics_groups=Vec::new();
+	let polygon_groups=model.meshes().enumerate().map(|(polygon_group_id,mesh)|{
+		let polygon_group_id=model::PolygonGroupId::new(polygon_group_id as u32);
+
+		let render_id=if let (Some(texture_path),Some(texture_name))=(texture_paths.get(0),skin.texture(mesh.material_index())){
+			let mut path=std::path::PathBuf::from(texture_path.as_str());
+			path.push(texture_name);
+			let index=path.as_os_str().to_str().map(|s|Cow::Owned(s.to_owned()));
+			deferred_loader.acquire_render_config_id(index)
+		}else{
+			deferred_loader.acquire_render_config_id(None)
+		};
+
+		graphics_groups.push(model::IndexedGraphicsGroup{
+			render:render_id,
+			groups:vec![polygon_group_id],
+		});
+		physics_groups.push(model::IndexedPhysicsGroup{
+			groups:vec![polygon_group_id],
+		});
+		model::PolygonGroup::PolygonList(model::PolygonList::new(
+			//looking at the code, it would seem that the strips are pre-deindexed into triangle lists when calling this function
+			mesh.vertex_strip_indices().flat_map(|mut strip|{
+				std::iter::from_fn(move ||{
+					match (strip.next(),strip.next(),strip.next()){
+						(Some(v1),Some(v2),Some(v3))=>Some([v1,v2,v3]),
+						//ignore extra vertices, not sure what to do in this case, failing the whole conversion could be appropriate
+						_=>None,
+					}
+				})
+			}).flat_map(|[v1,v2,v3]|{
+				// this should probably be a fatal error :D
+				let v1=model_vertices.get(v1)?;
+				let v2=model_vertices.get(v2)?;
+				let v3=model_vertices.get(v3)?;
+				Some(vec![
+					ingest_vertex(&mut mb,v1,color),
+					ingest_vertex(&mut mb,v2,color),
+					ingest_vertex(&mut mb,v3,color),
+				])
+			}).collect()
+		))
+	}).collect();
+	mb.build(polygon_groups,graphics_groups,physics_groups)
+}

lib/common/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "strafesnet_common"
-version = "0.5.2"
-edition = "2021"
+version = "0.6.0"
+edition = "2024"
 repository = "https://git.itzana.me/StrafesNET/strafe-project"
 license = "MIT OR Apache-2.0"
 description = "Common types and helpers for Strafe Client associated projects."
@@ -12,8 +12,8 @@ authors = ["Rhys Lloyd <krakow20@gmail.com>"]
 [dependencies]
 arrayvec = "0.7.4"
 bitflags = "2.6.0"
-fixed_wide = { path = "../fixed_wide", registry = "strafesnet", features = ["deferred-division","zeroes","wide-mul"] }
-linear_ops = { path = "../linear_ops", registry = "strafesnet", features = ["deferred-division","named-fields"] }
-ratio_ops = { path = "../ratio_ops", registry = "strafesnet" }
-glam = "0.29.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"] }
+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,42 +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/bvh.rs

@@ -1,4 +1,10 @@
+use std::cmp::Ordering;
+use std::collections::BTreeMap;
+
 use crate::aabb::Aabb;
+use crate::ray::Ray;
+use crate::integer::{Ratio,Planar64};
+use crate::instruction::{InstructionCollector,TimedInstruction};
 
 //da algaritum
 //lista boxens
@@ -10,35 +16,117 @@ use crate::aabb::Aabb;
 //sort the centerpoints on each axis (3 lists)
 //bv is put into octant based on whether it is upper or lower in each list
 
-pub enum RecursiveContent<R,T>{
-	Branch(Vec<R>),
-	Leaf(T),
+
+pub fn intersect_aabb(ray:&Ray,aabb:&Aabb)->Option<Ratio<Planar64,Planar64>>{
+	// n.(o+d*t)==n.p
+	// n.o + n.d * t == n.p
+	// t == (n.p - n.o)/n.d
+	let mut hit=None;
+	match ray.direction.x.cmp(&Planar64::ZERO){
+		Ordering::Less=>{
+			let rel_min=aabb.min()-ray.origin;
+			let rel_max=aabb.max()-ray.origin;
+			let dy=rel_max.x*ray.direction.y;
+			let dz=rel_max.x*ray.direction.z;
+			// x is negative, so inequalities are flipped
+			if rel_min.y*ray.direction.x>dy&&dy>rel_max.y*ray.direction.x
+			 &&rel_min.z*ray.direction.x>dz&&dz>rel_max.z*ray.direction.x{
+				let t=rel_max.x/ray.direction.x;
+				hit=Some(hit.map_or(t,|best_t|t.min(best_t)));
+			}
+		},
+		Ordering::Equal=>(),
+		Ordering::Greater=>{
+			let rel_min=aabb.min()-ray.origin;
+			let rel_max=aabb.max()-ray.origin;
+			let dy=rel_min.x*ray.direction.y;
+			let dz=rel_min.x*ray.direction.z;
+			// x is positive, so inequalities are normal
+			if rel_min.y*ray.direction.x<dy&&dy<rel_max.y*ray.direction.x
+			 &&rel_min.z*ray.direction.x<dz&&dz<rel_max.z*ray.direction.x{
+				let t=rel_min.x/ray.direction.x;
+				hit=Some(hit.map_or(t,|best_t|t.min(best_t)));
+			}
+		},
+	}
+	match ray.direction.z.cmp(&Planar64::ZERO){
+		Ordering::Less=>{
+			let rel_min=aabb.min()-ray.origin;
+			let rel_max=aabb.max()-ray.origin;
+			let dx=rel_max.z*ray.direction.x;
+			let dy=rel_max.z*ray.direction.y;
+			// z is negative, so inequalities are flipped
+			if rel_min.x*ray.direction.z>dx&&dx>rel_max.x*ray.direction.z
+			 &&rel_min.y*ray.direction.z>dy&&dy>rel_max.y*ray.direction.z{
+				let t=rel_max.z/ray.direction.z;
+				hit=Some(hit.map_or(t,|best_t|t.min(best_t)));
+			}
+		},
+		Ordering::Equal=>(),
+		Ordering::Greater=>{
+			let rel_min=aabb.min()-ray.origin;
+			let rel_max=aabb.max()-ray.origin;
+			let dx=rel_min.z*ray.direction.x;
+			let dy=rel_min.z*ray.direction.y;
+			// z is positive, so inequalities are normal
+			if rel_min.x*ray.direction.z<dx&&dx<rel_max.x*ray.direction.z
+			 &&rel_min.y*ray.direction.z<dy&&dy<rel_max.y*ray.direction.z{
+				let t=rel_min.z/ray.direction.z;
+				hit=Some(hit.map_or(t,|best_t|t.min(best_t)));
+			}
+		},
+	}
+	match ray.direction.y.cmp(&Planar64::ZERO){
+		Ordering::Less=>{
+			let rel_min=aabb.min()-ray.origin;
+			let rel_max=aabb.max()-ray.origin;
+			let dz=rel_max.y*ray.direction.z;
+			let dx=rel_max.y*ray.direction.x;
+			// y is negative, so inequalities are flipped
+			if rel_min.z*ray.direction.y>dz&&dz>rel_max.z*ray.direction.y
+			 &&rel_min.x*ray.direction.y>dx&&dx>rel_max.x*ray.direction.y{
+				let t=rel_max.y/ray.direction.y;
+				hit=Some(hit.map_or(t,|best_t|t.min(best_t)));
+			}
+		},
+		Ordering::Equal=>(),
+		Ordering::Greater=>{
+			let rel_min=aabb.min()-ray.origin;
+			let rel_max=aabb.max()-ray.origin;
+			let dz=rel_min.y*ray.direction.z;
+			let dx=rel_min.y*ray.direction.x;
+			// y is positive, so inequalities are normal
+			if rel_min.z*ray.direction.y<dz&&dz<rel_max.z*ray.direction.y
+			 &&rel_min.x*ray.direction.y<dx&&dx<rel_max.x*ray.direction.y{
+				let t=rel_min.y/ray.direction.y;
+				hit=Some(hit.map_or(t,|best_t|t.min(best_t)));
+			}
+		},
+	}
+	hit
 }
-impl<R,T> Default for RecursiveContent<R,T>{
-	fn default()->Self{
+
+pub enum RecursiveContent<N,L>{
+	Branch(Vec<N>),
+	Leaf(L),
+}
+impl<N,L> RecursiveContent<N,L>{
+	pub fn empty()->Self{
 		Self::Branch(Vec::new())
 	}
 }
-pub struct BvhNode<T>{
-	content:RecursiveContent<BvhNode<T>,T>,
+pub struct BvhNode<L>{
+	content:RecursiveContent<BvhNode<L>,L>,
 	aabb:Aabb,
 }
-impl<T> Default for BvhNode<T>{
-	fn default()->Self{
+impl<L> BvhNode<L>{
+	pub fn empty()->Self{
 		Self{
-			content:Default::default(),
+			content:RecursiveContent::empty(),
 			aabb:Aabb::default(),
 		}
 	}
-}
-pub struct BvhWeightNode<W,T>{
-	content:RecursiveContent<BvhWeightNode<W,T>,T>,
-	weight:W,
-	aabb:Aabb,
-}
-
-impl<T> BvhNode<T>{
-	pub fn the_tester<F:FnMut(&T)>(&self,aabb:&Aabb,f:&mut F){
+	pub fn sample_aabb<F:FnMut(&L)>(&self,aabb:&Aabb,f:&mut F){
 		match &self.content{
 			RecursiveContent::Leaf(model)=>f(model),
 			RecursiveContent::Branch(children)=>for child in children{
@@ -47,51 +135,101 @@ impl<T> BvhNode<T>{
 				//you're probably not going to spend a lot of time outside the map,
 				//so the test is extra work for nothing
 				if aabb.intersects(&child.aabb){
-					child.the_tester(aabb,f);
+					child.sample_aabb(aabb,f);
 				}
 			},
 		}
 	}
-	pub fn into_visitor<F:FnMut(T)>(self,f:&mut F){
-		match self.content{
-			RecursiveContent::Leaf(model)=>f(model),
+	fn populate_nodes<'a,T,F>(
+		&'a self,
+		collector:&mut InstructionCollector<&'a L,Ratio<Planar64,Planar64>>,
+		nodes:&mut BTreeMap<Ratio<Planar64,Planar64>,&'a BvhNode<L>>,
+		ray:&Ray,
+		start_time:Ratio<Planar64,Planar64>,
+		f:&F,
+	)
+		where
+			T:Ord+Copy,
+			Ratio<Planar64,Planar64>:From<T>,
+			F:Fn(&L,&Ray)->Option<T>,
+	{
+		match &self.content{
+			RecursiveContent::Leaf(leaf)=>if let Some(time)=f(leaf,ray){
+				let ins=TimedInstruction{time:time.into(),instruction:leaf};
+				if start_time.lt_ratio(ins.time)&&ins.time.lt_ratio(collector.time()){
+					collector.collect(Some(ins));
+				}
+			},
 			RecursiveContent::Branch(children)=>for child in children{
-				child.into_visitor(f)
-			},
-		}
-	}
-	pub fn weigh_contents<W:Copy+std::iter::Sum<W>,F:Fn(&T)->W>(self,f:&F)->BvhWeightNode<W,T>{
-		match self.content{
-			RecursiveContent::Leaf(model)=>BvhWeightNode{
-				weight:f(&model),
-				content:RecursiveContent::Leaf(model),
-				aabb:self.aabb,
-			},
-			RecursiveContent::Branch(children)=>{
-				let branch:Vec<BvhWeightNode<W,T>>=children.into_iter().map(|child|
-					child.weigh_contents(f)
-				).collect();
-				BvhWeightNode{
-					weight:branch.iter().map(|node|node.weight).sum(),
-					content:RecursiveContent::Branch(branch),
-					aabb:self.aabb,
+				if child.aabb.contains(ray.origin){
+					child.populate_nodes(collector,nodes,ray,start_time,f);
+				}else{
+					// Am I an upcoming superstar?
+					if let Some(t)=intersect_aabb(ray,&child.aabb){
+						if start_time.lt_ratio(t)&&t.lt_ratio(collector.time()){
+							nodes.insert(t,child);
+						}
+					}
 				}
 			},
 		}
 	}
-}
+	pub fn sample_ray<T,F>(
+		&self,
+		ray:&Ray,
+		start_time:T,
+		time_limit:T,
+		f:F,
+	)->Option<(T,&L)>
+		where
+			T:Ord+Copy,
+			T:From<Ratio<Planar64,Planar64>>,
+			Ratio<Planar64,Planar64>:From<T>,
+			F:Fn(&L,&Ray)->Option<T>,
+	{
+		// source of nondeterminism when Aabb boundaries are coplanar
+		let mut nodes=BTreeMap::new();
 
-impl <W,T> BvhWeightNode<W,T>{
-	pub const fn weight(&self)->&W{
-		&self.weight
+		let start_time=start_time.into();
+		let time_limit=time_limit.into();
+		let mut collector=InstructionCollector::new(time_limit);
+		// break open all nodes that contain ray.origin and populate nodes with future intersection times
+		self.populate_nodes(&mut collector,&mut nodes,ray,start_time,&f);
+
+		// swim through nodes one at a time
+		while let Some((t,node))=nodes.pop_first(){
+			if collector.time()<t{
+				break;
+			}
+			match &node.content{
+				RecursiveContent::Leaf(leaf)=>if let Some(time)=f(leaf,ray){
+					let ins=TimedInstruction{time:time.into(),instruction:leaf};
+					// this lower bound can also be omitted
+					// but it causes type inference errors lol
+					if start_time.lt_ratio(ins.time)&&ins.time.lt_ratio(collector.time()){
+						collector.collect(Some(ins));
+					}
+				},
+				// break open the node and predict collisions with the child nodes
+				RecursiveContent::Branch(children)=>for child in children{
+					// Am I an upcoming superstar?
+					if let Some(t)=intersect_aabb(ray,&child.aabb){
+						// we don't need to check the lower bound
+						// because child aabbs are guaranteed to be within the parent bounds.
+						if t<collector.time(){
+							nodes.insert(t,child);
+						}
+					}
+				},
+			}
+		}
+
+		collector.take().map(|TimedInstruction{time,instruction:leaf}|(time.into(),leaf))
 	}
-	pub const fn aabb(&self)->&Aabb{
-		&self.aabb
+	pub fn into_inner(self)->(RecursiveContent<BvhNode<L>,L>,Aabb){
+		(self.content,self.aabb)
 	}
-	pub fn into_content(self)->RecursiveContent<BvhWeightNode<W,T>,T>{
-		self.content
-	}
-	pub fn into_visitor<F:FnMut(T)>(self,f:&mut F){
+	pub fn into_visitor<F:FnMut(L)>(self,f:&mut F){
 		match self.content{
 			RecursiveContent::Leaf(model)=>f(model),
 			RecursiveContent::Branch(children)=>for child in children{
@@ -130,9 +268,9 @@ fn generate_bvh_node<T>(boxen:Vec<(T,Aabb)>,force:bool)->BvhNode<T>{
 			sort_y.push((i,center.y));
 			sort_z.push((i,center.z));
 		}
-		sort_x.sort_by(|tup0,tup1|tup0.1.cmp(&tup1.1));
-		sort_y.sort_by(|tup0,tup1|tup0.1.cmp(&tup1.1));
-		sort_z.sort_by(|tup0,tup1|tup0.1.cmp(&tup1.1));
+		sort_x.sort_by_key(|&(_,c)|c);
+		sort_y.sort_by_key(|&(_,c)|c);
+		sort_z.sort_by_key(|&(_,c)|c);
 		let h=n/2;
 		let median_x=sort_x[h].1;
 		let median_y=sort_y[h].1;

lib/common/src/controls_bitflag.rs

@@ -18,13 +18,8 @@ bitflags::bitflags!{
 		const Use=1<<14;//Interact with object
 		const PrimaryAction=1<<15;//LBM/Shoot/Melee
 		const SecondaryAction=1<<16;//RMB/ADS/Block
+
+		const WASD=Self::MoveForward.union(Self::MoveLeft).union(Self::MoveBackward).union(Self::MoveRight).bits();
+		const WASDQE=Self::MoveForward.union(Self::MoveLeft).union(Self::MoveBackward).union(Self::MoveRight).union(Self::MoveUp).union(Self::MoveDown).bits();
 	}
 }
-impl Controls{
-	pub const fn wasd()->Self{
-		Self::MoveForward.union(Self::MoveLeft).union(Self::MoveBackward).union(Self::MoveRight)
-	}
-	pub const fn wasdqe()->Self{
-		Self::MoveForward.union(Self::MoveLeft).union(Self::MoveBackward).union(Self::MoveRight).union(Self::MoveUp).union(Self::MoveDown)
-	}
-}

lib/common/src/gameplay_attributes.rs

@@ -1,5 +1,5 @@
 use crate::model;
-use crate::integer::{Time,Planar64,Planar64Vec3};
+use crate::integer::{AbsoluteTime,Planar64,Planar64Vec3};
 
 //you have this effect while in contact
 #[derive(Clone,Hash,Eq,PartialEq)]
@@ -31,7 +31,7 @@ pub enum Booster{
 	//Affine(crate::integer::Planar64Affine3),//capable of SetVelocity,DotVelocity,normal booster,bouncy part,redirect velocity, and much more
 	Velocity(Planar64Vec3),//straight up boost velocity adds to your current velocity
 	Energy{direction:Planar64Vec3,energy:Planar64},//increase energy in direction
-	AirTime(Time),//increase airtime, invariant across mass and gravity changes
+	AirTime(AbsoluteTime),//increase airtime, invariant across mass and gravity changes
 	Height(Planar64),//increase height, invariant across mass and gravity changes
 }
 impl Booster{
@@ -57,13 +57,13 @@ pub enum TrajectoryChoice{
 #[derive(Clone,Hash,Eq,PartialEq)]
 pub enum SetTrajectory{
 	//Speed-type SetTrajectory
-	AirTime(Time),//air time (relative to gravity direction) is invariant across mass and gravity changes
+	AirTime(AbsoluteTime),//air time (relative to gravity direction) is invariant across mass and gravity changes
 	Height(Planar64),//boost height (relative to gravity direction) is invariant across mass and gravity changes
 	DotVelocity{direction:Planar64Vec3,dot:Planar64},//set your velocity in a specific direction without touching other directions
 	//Velocity-type SetTrajectory
 	TargetPointTime{//launch on a trajectory that will land at a target point in a set amount of time
 		target_point:Planar64Vec3,
-		time:Time,//short time = fast and direct, long time = launch high in the air, negative time = wrong way
+		time:AbsoluteTime,//short time = fast and direct, long time = launch high in the air, negative time = wrong way
 	},
 	TargetPointSpeed{//launch at a fixed speed and land at a target point
 		target_point:Planar64Vec3,
@@ -171,4 +171,7 @@ impl CollisionAttributes{
 	pub fn contact_default()->Self{
 		Self::Contact(ContactAttributes::default())
 	}
+	pub fn intersect_default()->Self{
+		Self::Intersect(IntersectAttributes::default())
+	}
 }

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{
@@ -110,6 +109,7 @@ impl Stage{
 	pub fn into_inner(self)->(HashMap<CheckpointId,ModelId>,HashSet<ModelId>){
 		(self.ordered_checkpoints,self.unordered_checkpoints)
 	}
+	/// Returns true if the stage has no checkpoints.
 	#[inline]
 	pub const fn is_empty(&self)->bool{
 		self.is_complete(0,0)
@@ -127,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{
@@ -210,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,
@@ -245,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,
@@ -253,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{
@@ -313,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

@@ -1,7 +1,8 @@
 const VALVE_SCALE:Planar64=Planar64::raw(1<<28);// 1/16
 
-use crate::integer::{int,vec3::int as int3,Time,Ratio64,Planar64,Planar64Vec3};
+use crate::integer::{int,vec3::int as int3,AbsoluteTime,Ratio64,Planar64,Planar64Vec3};
 use crate::controls_bitflag::Controls;
+use crate::physics::Time as PhysicsTime;
 
 #[derive(Clone,Debug)]
 pub struct StyleModifiers{
@@ -48,7 +49,7 @@ pub enum JumpCalculation{
 
 #[derive(Clone,Debug)]
 pub enum JumpImpulse{
-	Time(Time),//jump time is invariant across mass and gravity changes
+	Time(AbsoluteTime),//jump time is invariant across mass and gravity changes
 	Height(Planar64),//jump height is invariant across mass and gravity changes
 	Linear(Planar64),//jump velocity is invariant across mass and gravity changes
 	Energy(Planar64),// :)
@@ -62,7 +63,7 @@ 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()),
@@ -77,7 +78,7 @@ impl JumpImpulse{
 				velocity-(*gravity*(radicand.sqrt().fix_2()+v_g)/gg).divide().fix_1()
 			},
 			&JumpImpulse::Linear(jump_speed)=>velocity+(jump_dir*jump_speed/jump_dir.length()).divide().fix_1(),
-			&JumpImpulse::Energy(energy)=>{
+			&JumpImpulse::Energy(_energy)=>{
 				//calculate energy
 				//let e=gravity.dot(velocity);
 				//add
@@ -199,8 +200,8 @@ impl ControlsActivation{
 	}
 	pub const fn full_3d()->Self{
 		Self{
-			controls_mask:Controls::wasdqe(),
-			controls_intersects:Controls::wasdqe(),
+			controls_mask:Controls::WASDQE,
+			controls_intersects:Controls::WASDQE,
 			controls_contains:Controls::empty(),
 		}
 	}
@@ -208,8 +209,8 @@ impl ControlsActivation{
 	//Normal
 	pub const fn full_2d()->Self{
 		Self{
-			controls_mask:Controls::wasd(),
-			controls_intersects:Controls::wasd(),
+			controls_mask:Controls::WASD,
+			controls_intersects:Controls::WASD,
 			controls_contains:Controls::empty(),
 		}
 	}
@@ -272,8 +273,8 @@ impl StrafeSettings{
 			false=>None,
 		}
 	}
-	pub fn next_tick(&self,time:Time)->Time{
-		Time::from_nanos(self.tick_rate.rhs_div_int(self.tick_rate.mul_int(time.nanos())+1))
+	pub fn next_tick(&self,time:PhysicsTime)->PhysicsTime{
+		PhysicsTime::from_nanos(self.tick_rate.rhs_div_int(self.tick_rate.mul_int(time.nanos())+1))
 	}
 	pub const fn activates(&self,controls:Controls)->bool{
 		self.enable.activates(controls)
@@ -354,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
 	}
@@ -435,7 +436,7 @@ impl StyleModifiers{
 				enable:ControlsActivation::full_2d(),
 				air_accel_limit:None,
 				mv:int(3),
-				tick_rate:Ratio64::new(64,Time::ONE_SECOND.nanos() as u64).unwrap(),
+				tick_rate:Ratio64::new(64,AbsoluteTime::ONE_SECOND.get() as u64).unwrap(),
 			}),
 			jump:Some(JumpSettings{
 				impulse:JumpImpulse::Energy(int(512)),
@@ -477,10 +478,10 @@ impl StyleModifiers{
 				enable:ControlsActivation::full_2d(),
 				air_accel_limit:None,
 				mv:int(27)/10,
-				tick_rate:Ratio64::new(100,Time::ONE_SECOND.nanos() as u64).unwrap(),
+				tick_rate:Ratio64::new(100,AbsoluteTime::ONE_SECOND.get() as u64).unwrap(),
 			}),
 			jump:Some(JumpSettings{
-				impulse:JumpImpulse::Time(Time::from_micros(715_588)),
+				impulse:JumpImpulse::Time(AbsoluteTime::from_micros(715_588)),
 				calculation:JumpCalculation::Max,
 				limit_minimum:true,
 			}),
@@ -528,13 +529,13 @@ 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(),
-				tick_rate:Ratio64::new(100,Time::ONE_SECOND.nanos() as u64).unwrap(),
+				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()),
@@ -569,13 +570,13 @@ impl StyleModifiers{
 	}
 	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(),
-				tick_rate:Ratio64::new(66,Time::ONE_SECOND.nanos() as u64).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()),

lib/common/src/instruction.rs

@@ -1,53 +1,82 @@
-use crate::integer::Time;
-
-#[derive(Debug)]
-pub struct TimedInstruction<I>{
-	pub time:Time,
+#[derive(Clone,Debug)]
+pub struct TimedInstruction<I,T>{
+	pub time:T,
 	pub instruction:I,
 }
+impl<I,T> TimedInstruction<I,T>{
+	#[inline]
+	pub fn set_time<T2>(self,new_time:T2)->TimedInstruction<I,T2>{
+		TimedInstruction{
+			time:new_time,
+			instruction:self.instruction,
+		}
+	}
+}
 
+/// Ensure all emitted instructions are processed before consuming external instructions
 pub trait InstructionEmitter<I>{
-	fn next_instruction(&self,time_limit:Time)->Option<TimedInstruction<I>>;
+	type Time;
+	fn next_instruction(&self,time_limit:Self::Time)->Option<TimedInstruction<I,Self::Time>>;
 }
+/// Apply an atomic state update
 pub trait InstructionConsumer<I>{
-	fn process_instruction(&mut self, instruction:TimedInstruction<I>);
+	type Time;
+	fn process_instruction(&mut self,instruction:TimedInstruction<I,Self::Time>);
 }
+/// If the object produces its own instructions, allow exhaustively feeding them back in
+pub trait InstructionFeedback<I,T>:InstructionEmitter<I,Time=T>+InstructionConsumer<I,Time=T>
+	where
+		T:Copy,
+{
+	#[inline]
+	fn process_exhaustive(&mut self,time_limit:T){
+		while let Some(instruction)=self.next_instruction(time_limit){
+			self.process_instruction(instruction);
+		}
+	}
+}
+impl<I,T,X> InstructionFeedback<I,T> for X
+	where
+		T:Copy,
+		X:InstructionEmitter<I,Time=T>+InstructionConsumer<I,Time=T>,
+{}
 
 //PROPER PRIVATE FIELDS!!!
-pub struct InstructionCollector<I>{
-	time:Time,
+pub struct InstructionCollector<I,T>{
+	time:T,
 	instruction:Option<I>,
 }
-impl<I> InstructionCollector<I>{
-	pub const fn new(time:Time)->Self{
+impl<I,T> InstructionCollector<I,T>{
+	#[inline]
+	pub const fn new(time:T)->Self{
 		Self{
 			time,
 			instruction:None
 		}
 	}
 	#[inline]
-	pub const fn time(&self)->Time{
+	pub fn take(self)->Option<TimedInstruction<I,T>>{
+		//STEAL INSTRUCTION AND DESTROY INSTRUCTIONCOLLECTOR
+		self.instruction.map(|instruction|TimedInstruction{
+			time:self.time,
+			instruction
+		})
+	}
+}
+impl<I,T:Copy> InstructionCollector<I,T>{
+	#[inline]
+	pub const fn time(&self)->T{
 		self.time
 	}
-	pub fn collect(&mut self,instruction:Option<TimedInstruction<I>>){
-		match instruction{
-			Some(unwrap_instruction)=>{
-				if unwrap_instruction.time<self.time {
-					self.time=unwrap_instruction.time;
-					self.instruction=Some(unwrap_instruction.instruction);
-				}
-			},
-			None=>(),
-		}
-	}
-	pub fn instruction(self)->Option<TimedInstruction<I>>{
-		//STEAL INSTRUCTION AND DESTROY INSTRUCTIONCOLLECTOR
-		match self.instruction{
-			Some(instruction)=>Some(TimedInstruction{
-				time:self.time,
-				instruction
-			}),
-			None=>None,
+}
+impl<I,T:PartialOrd> InstructionCollector<I,T>{
+	#[inline]
+	pub fn collect(&mut self,instruction:Option<TimedInstruction<I,T>>){
+		if let Some(ins)=instruction{
+			if ins.time<self.time{
+				self.time=ins.time;
+				self.instruction=Some(ins.instruction);
+			}
 		}
 	}
 }

lib/common/src/integer.rs

@@ -2,19 +2,26 @@ pub use fixed_wide::fixed::{Fixed,Fix};
 pub use ratio_ops::ratio::{Ratio,Divide};
 
 //integer units
-#[derive(Clone,Copy,Hash,Eq,PartialEq,PartialOrd,Debug)]
-pub struct Time(i64);
-impl Time{
-	pub const MIN:Self=Self(i64::MIN);
-	pub const MAX:Self=Self(i64::MAX);
-	pub const ZERO:Self=Self(0);
-	pub const ONE_SECOND:Self=Self(1_000_000_000);
-	pub const ONE_MILLISECOND:Self=Self(1_000_000);
-	pub const ONE_MICROSECOND:Self=Self(1_000);
-	pub const ONE_NANOSECOND:Self=Self(1);
+
+/// specific example of a "default" time type
+#[derive(Clone,Copy,Hash,Eq,PartialEq,Ord,PartialOrd,Debug)]
+pub enum TimeInner{}
+pub type AbsoluteTime=Time<TimeInner>;
+
+#[derive(Clone,Copy,Hash,Eq,PartialEq,Ord,PartialOrd,Debug)]
+pub struct Time<T>(i64,core::marker::PhantomData<T>);
+impl<T> Time<T>{
+	pub const MIN:Self=Self::raw(i64::MIN);
+	pub const MAX:Self=Self::raw(i64::MAX);
+	pub const ZERO:Self=Self::raw(0);
+	pub const EPSILON:Self=Self::raw(1);
+	pub const ONE_SECOND:Self=Self::raw(1_000_000_000);
+	pub const ONE_MILLISECOND:Self=Self::raw(1_000_000);
+	pub const ONE_MICROSECOND:Self=Self::raw(1_000);
+	pub const ONE_NANOSECOND:Self=Self::raw(1);
 	#[inline]
 	pub const fn raw(num:i64)->Self{
-		Self(num)
+		Self(num,core::marker::PhantomData)
 	}
 	#[inline]
 	pub const fn get(self)->i64{
@@ -22,19 +29,19 @@ impl Time{
 	}
 	#[inline]
 	pub const fn from_secs(num:i64)->Self{
-		Self(Self::ONE_SECOND.0*num)
+		Self::raw(Self::ONE_SECOND.0*num)
 	}
 	#[inline]
 	pub const fn from_millis(num:i64)->Self{
-		Self(Self::ONE_MILLISECOND.0*num)
+		Self::raw(Self::ONE_MILLISECOND.0*num)
 	}
 	#[inline]
 	pub const fn from_micros(num:i64)->Self{
-		Self(Self::ONE_MICROSECOND.0*num)
+		Self::raw(Self::ONE_MICROSECOND.0*num)
 	}
 	#[inline]
 	pub const fn from_nanos(num:i64)->Self{
-		Self(Self::ONE_NANOSECOND.0*num)
+		Self::raw(Self::ONE_NANOSECOND.0*num)
 	}
 	//should I have checked subtraction? force all time variables to be positive?
 	#[inline]
@@ -45,14 +52,24 @@ impl Time{
 	pub const fn to_ratio(self)->Ratio<Planar64,Planar64>{
 		Ratio::new(Planar64::raw(self.0),Planar64::raw(1_000_000_000))
 	}
-}
-impl From<Planar64> for Time{
 	#[inline]
-	fn from(value:Planar64)->Self{
-		Time((value*Planar64::raw(1_000_000_000)).fix_1().to_raw())
+	pub const fn coerce<U>(self)->Time<U>{
+		Time::raw(self.0)
 	}
 }
-impl<Num,Den,N1,T1> From<Ratio<Num,Den>> for Time
+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())
+	}
+}
+impl<T> From<Time<T>> for Ratio<Planar64,Planar64>{
+	#[inline]
+	fn from(value:Time<T>)->Self{
+		value.to_ratio()
+	}
+}
+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>,
@@ -60,34 +77,34 @@ impl<Num,Den,N1,T1> From<Ratio<Num,Den>> for Time
 {
 	#[inline]
 	fn from(value:Ratio<Num,Den>)->Self{
-		Time((value*Planar64::raw(1_000_000_000)).divide().fix().to_raw())
+		Self::raw((value*Planar64::raw(1_000_000_000)).divide().fix().to_raw())
 	}
 }
-impl std::fmt::Display for Time{
+impl<T> std::fmt::Display for Time<T>{
 	#[inline]
 	fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
 		write!(f,"{}s+{:09}ns",self.0/Self::ONE_SECOND.0,self.0%Self::ONE_SECOND.0)
 	}
 }
-impl std::default::Default for Time{
+impl<T> std::default::Default for Time<T>{
 	fn default()->Self{
-		Self(0)
+		Self::raw(0)
 	}
 }
-impl std::ops::Neg for Time{
-	type Output=Time;
+impl<T> std::ops::Neg for Time<T>{
+	type Output=Self;
 	#[inline]
 	fn neg(self)->Self::Output {
-		Time(-self.0)
+		Self::raw(-self.0)
 	}
 }
 macro_rules! impl_time_additive_operator {
 	($trait:ty, $method:ident) => {
-		impl $trait for Time{
-			type Output=Time;
+		impl<T> $trait for Time<T>{
+			type Output=Self;
 			#[inline]
 			fn $method(self,rhs:Self)->Self::Output {
-				Time(self.0.$method(rhs.0))
+				Self::raw(self.0.$method(rhs.0))
 			}
 		}
 	};
@@ -97,7 +114,7 @@ impl_time_additive_operator!(core::ops::Sub,sub);
 impl_time_additive_operator!(core::ops::Rem,rem);
 macro_rules! impl_time_additive_assign_operator {
 	($trait:ty, $method:ident) => {
-		impl $trait for Time{
+		impl<T> $trait for Time<T>{
 			#[inline]
 			fn $method(&mut self,rhs:Self){
 				self.0.$method(rhs.0)
@@ -108,53 +125,58 @@ macro_rules! impl_time_additive_assign_operator {
 impl_time_additive_assign_operator!(core::ops::AddAssign,add_assign);
 impl_time_additive_assign_operator!(core::ops::SubAssign,sub_assign);
 impl_time_additive_assign_operator!(core::ops::RemAssign,rem_assign);
-impl std::ops::Mul for Time{
+impl<T> std::ops::Mul for Time<T>{
 	type Output=Ratio<fixed_wide::fixed::Fixed<2,64>,fixed_wide::fixed::Fixed<2,64>>;
 	#[inline]
 	fn mul(self,rhs:Self)->Self::Output{
 		Ratio::new(Fixed::raw(self.0)*Fixed::raw(rhs.0),Fixed::raw_digit(1_000_000_000i64.pow(2)))
 	}
 }
-impl std::ops::Div<i64> for Time{
-	type Output=Time;
+impl<T> std::ops::Div<i64> for Time<T>{
+	type Output=Self;
 	#[inline]
 	fn div(self,rhs:i64)->Self::Output{
-		Time(self.0/rhs)
+		Self::raw(self.0/rhs)
 	}
 }
-impl std::ops::Mul<i64> for Time{
-	type Output=Time;
+impl<T> std::ops::Mul<i64> for Time<T>{
+	type Output=Self;
 	#[inline]
 	fn mul(self,rhs:i64)->Self::Output{
-		Time(self.0*rhs)
+		Self::raw(self.0*rhs)
 	}
 }
-impl core::ops::Mul<Time> for Planar64{
+impl<T> core::ops::Mul<Time<T>> for Planar64{
 	type Output=Ratio<Fixed<2,64>,Planar64>;
-	fn mul(self,rhs:Time)->Self::Output{
+	fn mul(self,rhs:Time<T>)->Self::Output{
 		Ratio::new(self*Fixed::raw(rhs.0),Planar64::raw(1_000_000_000))
 	}
 }
-#[test]
-fn time_from_planar64(){
-	let a:Time=Planar64::from(1).into();
-	assert_eq!(a,Time::ONE_SECOND);
-}
-#[test]
-fn time_from_ratio(){
-	let a:Time=Ratio::new(Planar64::from(1),Planar64::from(1)).into();
-	assert_eq!(a,Time::ONE_SECOND);
-}
-#[test]
-fn time_squared(){
-	let a=Time::from_secs(2);
-	assert_eq!(a*a,Ratio::new(Fixed::<2,64>::raw_digit(1_000_000_000i64.pow(2))*4,Fixed::<2,64>::raw_digit(1_000_000_000i64.pow(2))));
-}
-#[test]
-fn time_times_planar64(){
-	let a=Time::from_secs(2);
-	let b=Planar64::from(2);
-	assert_eq!(b*a,Ratio::new(Fixed::<2,64>::raw_digit(1_000_000_000*(1<<32))<<2,Fixed::<1,32>::raw_digit(1_000_000_000)));
+#[cfg(test)]
+mod test_time{
+	use super::*;
+	type Time=super::AbsoluteTime;
+	#[test]
+	fn time_from_planar64(){
+		let a:Time=Planar64::from(1).into();
+		assert_eq!(a,Time::ONE_SECOND);
+	}
+	#[test]
+	fn time_from_ratio(){
+		let a:Time=Ratio::new(Planar64::from(1),Planar64::from(1)).into();
+		assert_eq!(a,Time::ONE_SECOND);
+	}
+	#[test]
+	fn time_squared(){
+		let a=Time::from_secs(2);
+		assert_eq!(a*a,Ratio::new(Fixed::<2,64>::raw_digit(1_000_000_000i64.pow(2))*4,Fixed::<2,64>::raw_digit(1_000_000_000i64.pow(2))));
+	}
+	#[test]
+	fn time_times_planar64(){
+		let a=Time::from_secs(2);
+		let b=Planar64::from(2);
+		assert_eq!(b*a,Ratio::new(Fixed::<2,64>::raw_digit(1_000_000_000*(1<<32))<<2,Fixed::<1,32>::raw_digit(1_000_000_000)));
+	}
 }
 
 #[inline]
@@ -632,11 +654,19 @@ pub struct Planar64Affine3{
 	pub translation:Planar64Vec3,
 }
 impl Planar64Affine3{
+	pub const IDENTITY:Self=Self::new(mat3::identity(),vec3::ZERO);
 	#[inline]
 	pub const fn new(matrix3:Planar64Mat3,translation:Planar64Vec3)->Self{
 		Self{matrix3,translation}
 	}
 	#[inline]
+	pub const fn from_translation(translation:Planar64Vec3)->Self{
+		Self{
+			matrix3:mat3::identity(),
+			translation,
+		}
+	}
+	#[inline]
 	pub fn transform_point3(&self,point:Planar64Vec3)->vec3::Vector3<Fixed<2,64>>{
 		self.translation.fix_2()+self.matrix3*point
 	}

lib/common/src/lib.rs

@@ -1,5 +1,6 @@
 pub mod bvh;
 pub mod map;
+pub mod ray;
 pub mod run;
 pub mod aabb;
 pub mod model;
@@ -7,7 +8,7 @@ pub mod mouse;
 pub mod timer;
 pub mod integer;
 pub mod physics;
-pub mod updatable;
+pub mod session;
 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/model.rs

@@ -1,3 +1,5 @@
+use std::collections::HashMap;
+
 use crate::integer::{Planar64Vec3,Planar64Affine3};
 use crate::gameplay_attributes;
 
@@ -123,6 +125,87 @@ pub struct Mesh{
 	pub physics_groups:Vec<IndexedPhysicsGroup>,
 }
 
+#[derive(Default)]
+pub struct MeshBuilder{
+	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<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>,
+}
+impl MeshBuilder{
+	pub fn new()->Self{
+		Self::default()
+	}
+	pub fn build(
+		self,
+		polygon_groups:Vec<PolygonGroup>,
+		graphics_groups:Vec<IndexedGraphicsGroup>,
+		physics_groups:Vec<IndexedPhysicsGroup>,
+	)->Mesh{
+		let MeshBuilder{
+			unique_pos,
+			unique_normal,
+			unique_tex,
+			unique_color,
+			unique_vertices,
+			..
+		}=self;
+		Mesh{
+			unique_pos,
+			unique_normal,
+			unique_tex,
+			unique_color,
+			unique_vertices,
+			polygon_groups,
+			graphics_groups,
+			physics_groups,
+		}
+	}
+	pub fn acquire_pos_id(&mut self,pos:Planar64Vec3)->PositionId{
+		*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: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);
+			normal_id
+		})
+	}
+	pub fn acquire_tex_id(&mut self,tex:TextureCoordinate)->TextureCoordinateId{
+		let h=tex.to_array().map(f32::to_bits);
+		*self.tex_id_from.entry(h).or_insert_with(||{
+			let tex_id=TextureCoordinateId::new(self.unique_tex.len() as u32);
+			self.unique_tex.push(tex);
+			tex_id
+		})
+	}
+	pub fn acquire_color_id(&mut self,color:Color4)->ColorId{
+		let h=color.to_array().map(f32::to_bits);
+		*self.color_id_from.entry(h).or_insert_with(||{
+			let color_id=ColorId::new(self.unique_color.len() as u32);
+			self.unique_color.push(color);
+			color_id
+		})
+	}
+	pub fn acquire_vertex_id(&mut self,vertex:IndexedVertex)->VertexId{
+		*self.vertex_id_from.entry(vertex.clone()).or_insert_with(||{
+			let vertex_id=VertexId::new(self.unique_vertices.len() as u32);
+			self.unique_vertices.push(vertex);
+			vertex_id
+		})
+	}
+}
+
 #[derive(Debug,Clone,Copy,Hash,id::Id,Eq,PartialEq)]
 pub struct ModelId(u32);
 pub struct Model{

lib/common/src/mouse.rs

@@ -1,11 +1,11 @@
 use crate::integer::Time;
 
 #[derive(Clone,Debug)]
-pub struct MouseState{
+pub struct MouseState<T>{
 	pub pos:glam::IVec2,
-	pub time:Time,
+	pub time:Time<T>,
 }
-impl Default for MouseState{
+impl<T> Default for MouseState<T>{
 	fn default()->Self{
 		Self{
 			time:Time::ZERO,
@@ -13,8 +13,10 @@ impl Default for MouseState{
 		}
 	}
 }
-impl MouseState{
-	pub fn lerp(&self,target:&MouseState,time:Time)->glam::IVec2{
+impl<T> MouseState<T>
+	where Time<T>:Copy,
+{
+	pub fn lerp(&self,target:&MouseState<T>,time:Time<T>)->glam::IVec2{
 		let m0=self.pos.as_i64vec2();
 		let m1=target.pos.as_i64vec2();
 		//these are deltas

lib/common/src/physics.rs

@@ -1,7 +1,33 @@
+use crate::mouse::MouseState;
+use crate::gameplay_modes::{ModeId,StageId};
+
+#[derive(Clone,Copy,Hash,Eq,PartialEq,Ord,PartialOrd,Debug)]
+pub enum TimeInner{}
+pub type Time=crate::integer::Time<TimeInner>;
+
 #[derive(Clone,Debug)]
 pub enum Instruction{
-	ReplaceMouse(crate::mouse::MouseState,crate::mouse::MouseState),
-	SetNextMouse(crate::mouse::MouseState),
+	Mouse(MouseInstruction),
+	SetControl(SetControlInstruction),
+	Mode(ModeInstruction),
+	Misc(MiscInstruction),
+	/// Idle: there were no input events, but the simulation is safe to advance to this timestep
+	Idle,
+}
+impl Instruction{
+	pub const IDLE:Self=Self::Idle;
+}
+#[derive(Clone,Debug)]
+pub enum MouseInstruction{
+	/// Replace the entire interpolation state to avoid dividing by zero when replacing twice
+	ReplaceMouse{
+		m0:MouseState<TimeInner>,
+		m1:MouseState<TimeInner>,
+	},
+	SetNextMouse(MouseState<TimeInner>),
+}
+#[derive(Clone,Debug)]
+pub enum SetControlInstruction{
 	SetMoveRight(bool),
 	SetMoveUp(bool),
 	SetMoveBack(bool),
@@ -10,18 +36,21 @@ pub enum Instruction{
 	SetMoveForward(bool),
 	SetJump(bool),
 	SetZoom(bool),
+}
+#[derive(Clone,Debug)]
+pub enum ModeInstruction{
 	/// Reset: fully replace the physics state.
 	/// This forgets all inputs and settings which need to be reapplied.
 	Reset,
 	/// Restart: Teleport to the start zone.
-	Restart,
+	/// This runs when you press R or teleport to a bonus
+	Restart(ModeId),
 	/// Spawn: Teleport to a specific mode's spawn
-	/// Sets current mode & spawn
-	Spawn(crate::gameplay_modes::ModeId,crate::gameplay_modes::StageId),
-	Idle,
-		//Idle: there were no input events, but the simulation is safe to advance to this timestep
-		//for interpolation / networking / playback reasons, most playback heads will always want
-		//to be 1 instruction ahead to generate the next state for interpolation.
+	/// This runs when the map loads to put you at the map lobby
+	Spawn(ModeId,StageId),
+}
+#[derive(Clone,Debug)]
+pub enum MiscInstruction{
 	PracticeFly,
 	SetSensitivity(crate::integer::Ratio64Vec2),
 }

lib/common/src/ray.rs

@@ -0,0 +1,20 @@
+use ratio_ops::ratio::Ratio;
+use crate::integer::{self,Planar64,Planar64Vec3};
+
+pub struct Ray{
+	pub origin:Planar64Vec3,
+	pub direction:Planar64Vec3,
+}
+impl Ray{
+	pub fn extrapolate<Num,Den,N1,T1>(&self,t:Ratio<Num,Den>)->Planar64Vec3
+	where
+		Num:Copy,
+		Den:Copy,
+		Num:core::ops::Mul<Planar64,Output=N1>,
+		Planar64:core::ops::Mul<Den,Output=N1>,
+		N1:integer::Divide<Den,Output=T1>,
+		T1:integer::Fix<Planar64>,
+	{
+		self.origin+self.direction.map(|elem|(t*elem).divide().fix())
+	}
+}

lib/common/src/run.rs

@@ -1,5 +1,10 @@
 use crate::timer::{TimerFixed,Realtime,Paused,Unpaused};
-use crate::integer::Time;
+
+use crate::physics::{TimeInner as PhysicsTimeInner,Time as PhysicsTime};
+
+#[derive(Clone,Copy,Hash,Eq,PartialEq,Ord,PartialOrd,Debug)]
+pub enum TimeInner{}
+pub type Time=crate::integer::Time<TimeInner>;
 
 #[derive(Clone,Copy,Debug)]
 pub enum FlagReason{
@@ -15,6 +20,11 @@ pub enum FlagReason{
 }
 impl ToString for FlagReason{
 	fn to_string(&self)->String{
+		self.as_ref().to_owned()
+	}
+}
+impl AsRef<str> for FlagReason{
+	fn as_ref(&self)->&str{
 		match self{
 			FlagReason::Anticheat=>"Passed through anticheat zone.",
 			FlagReason::StyleChange=>"Changed style.",
@@ -25,7 +35,7 @@ impl ToString for FlagReason{
 			FlagReason::Timescale=>"Timescale is not allowed in this style.",
 			FlagReason::TimeTravel=>"Time travel is not allowed in this style.",
 			FlagReason::Teleport=>"Illegal teleport.",
-		}.to_owned()
+		}
 	}
 }
 
@@ -45,8 +55,8 @@ impl std::error::Error for Error{}
 #[derive(Clone,Copy,Debug)]
 enum RunState{
 	Created,
-	Started{timer:TimerFixed<Realtime,Unpaused>},
-	Finished{timer:TimerFixed<Realtime,Paused>},
+	Started{timer:TimerFixed<Realtime<PhysicsTimeInner,TimeInner>,Unpaused>},
+	Finished{timer:TimerFixed<Realtime<PhysicsTimeInner,TimeInner>,Paused>},
 }
 
 #[derive(Clone,Copy,Debug)]
@@ -62,14 +72,14 @@ impl Run{
 			flagged:None,
 		}
 	}
-	pub fn time(&self,time:Time)->Time{
+	pub fn time(&self,time:PhysicsTime)->Time{
 		match &self.state{
 			RunState::Created=>Time::ZERO,
 			RunState::Started{timer}=>timer.time(time),
-			RunState::Finished{timer}=>timer.time(time),
+			RunState::Finished{timer}=>timer.time(),
 		}
 	}
-	pub fn start(&mut self,time:Time)->Result<(),Error>{
+	pub fn start(&mut self,time:PhysicsTime)->Result<(),Error>{
 		match &self.state{
 			RunState::Created=>{
 				self.state=RunState::Started{
@@ -81,7 +91,7 @@ impl Run{
 			RunState::Finished{..}=>Err(Error::AlreadyFinished),
 		}
 	}
-	pub fn finish(&mut self,time:Time)->Result<(),Error>{
+	pub fn finish(&mut self,time:PhysicsTime)->Result<(),Error>{
 		//this uses Copy
 		match &self.state{
 			RunState::Created=>Err(Error::NotStarted),
@@ -100,4 +110,10 @@ impl Run{
 			self.flagged=Some(flag_reason);
 		}
 	}
+	pub fn get_finish_time(&self)->Option<Time>{
+		match &self.state{
+			RunState::Finished{timer}=>Some(timer.time()),
+			_=>None,
+		}
+	}
 }

lib/common/src/session.rs

@@ -0,0 +1,3 @@
+#[derive(Clone,Copy,Hash,Eq,PartialEq,Ord,PartialOrd,Debug)]
+pub enum TimeInner{}
+pub type Time=crate::integer::Time<TimeInner>;

lib/common/src/timer.rs

@@ -22,79 +22,106 @@ impl PauseState for Unpaused{
 	}
 }
 
+#[derive(Clone,Copy,Hash,Eq,PartialEq,PartialOrd,Debug)]
+pub enum Inner{}
+type InnerTime=Time<Inner>;
+
 #[derive(Clone,Copy,Debug)]
-pub struct Realtime{
-	offset:Time,
+pub struct Realtime<In,Out>{
+	offset:InnerTime,
+	_in:core::marker::PhantomData<In>,
+	_out:core::marker::PhantomData<Out>,
 }
-impl Realtime{
-	pub const fn new(offset:Time)->Self{
-		Self{offset}
+impl<In,Out> Realtime<In,Out>{
+	pub const fn new(offset:InnerTime)->Self{
+		Self{
+			offset,
+			_in:core::marker::PhantomData,
+			_out:core::marker::PhantomData,
+		}
 	}
 }
 
 #[derive(Clone,Copy,Debug)]
-pub struct Scaled{
+pub struct Scaled<In,Out>{
 	scale:Ratio64,
-	offset:Time,
+	offset:InnerTime,
+	_in:core::marker::PhantomData<In>,
+	_out:core::marker::PhantomData<Out>,
 }
-impl Scaled{
-	pub const fn new(scale:Ratio64,offset:Time)->Self{
-		Self{scale,offset}
+impl<In,Out> Scaled<In,Out>
+	where Time<In>:Copy,
+{
+	pub const fn new(scale:Ratio64,offset:InnerTime)->Self{
+		Self{
+			scale,
+			offset,
+			_in:core::marker::PhantomData,
+			_out:core::marker::PhantomData,
+		}
 	}
 	const fn with_scale(scale:Ratio64)->Self{
-		Self{scale,offset:Time::ZERO}
+		Self::new(scale,InnerTime::ZERO)
 	}
-	const fn scale(&self,time:Time)->Time{
-		Time::raw(self.scale.mul_int(time.get()))
+	const fn scale(&self,time:Time<In>)->InnerTime{
+		InnerTime::raw(self.scale.mul_int(time.get()))
 	}
 	const fn get_scale(&self)->Ratio64{
 		self.scale
 	}
-	fn set_scale(&mut self,time:Time,new_scale:Ratio64){
+	fn set_scale(&mut self,time:Time<In>,new_scale:Ratio64){
 		let new_time=self.get_time(time);
 		self.scale=new_scale;
 		self.set_time(time,new_time);
 	}
 }
 
-pub trait TimerState:Copy+std::fmt::Debug{
+pub trait TimerState{
+	type In;
+	type Out;
 	fn identity()->Self;
-	fn get_time(&self,time:Time)->Time;
-	fn set_time(&mut self,time:Time,new_time:Time);
-	fn get_offset(&self)->Time;
-	fn set_offset(&mut self,offset:Time);
+	fn get_time(&self,time:Time<Self::In>)->Time<Self::Out>;
+	fn set_time(&mut self,time:Time<Self::In>,new_time:Time<Self::Out>);
+	fn get_offset(&self)->InnerTime;
+	fn set_offset(&mut self,offset:InnerTime);
 }
-impl TimerState for Realtime{
+impl<In,Out> TimerState for Realtime<In,Out>{
+	type In=In;
+	type Out=Out;
 	fn identity()->Self{
-		Self{offset:Time::ZERO}
+		Self::new(InnerTime::ZERO)
 	}
-	fn get_time(&self,time:Time)->Time{
-		time+self.offset
+	fn get_time(&self,time:Time<In>)->Time<Out>{
+		time.coerce()+self.offset.coerce()
 	}
-	fn set_time(&mut self,time:Time,new_time:Time){
-		self.offset=new_time-time;
+	fn set_time(&mut self,time:Time<In>,new_time:Time<Out>){
+		self.offset=new_time.coerce()-time.coerce();
 	}
-	fn get_offset(&self)->Time{
+	fn get_offset(&self)->InnerTime{
 		self.offset
 	}
-	fn set_offset(&mut self,offset:Time){
+	fn set_offset(&mut self,offset:InnerTime){
 		self.offset=offset;
 	}
 }
-impl TimerState for Scaled{
+impl<In,Out> TimerState for Scaled<In,Out>
+	where Time<In>:Copy,
+{
+	type In=In;
+	type Out=Out;
 	fn identity()->Self{
-		Self{scale:Ratio64::ONE,offset:Time::ZERO}
+		Self::new(Ratio64::ONE,InnerTime::ZERO)
 	}
-	fn get_time(&self,time:Time)->Time{
-		self.scale(time)+self.offset
+	fn get_time(&self,time:Time<In>)->Time<Out>{
+		(self.scale(time)+self.offset).coerce()
 	}
-	fn set_time(&mut self,time:Time,new_time:Time){
-		self.offset=new_time-self.scale(time);
+	fn set_time(&mut self,time:Time<In>,new_time:Time<Out>){
+		self.offset=new_time.coerce()-self.scale(time);
 	}
-	fn get_offset(&self)->Time{
+	fn get_offset(&self)->InnerTime{
 		self.offset
 	}
-	fn set_offset(&mut self,offset:Time){
+	fn set_offset(&mut self,offset:InnerTime){
 		self.offset=offset;
 	}
 }
@@ -106,8 +133,10 @@ pub struct TimerFixed<T:TimerState,P:PauseState>{
 }
 
 //scaled timer methods are generic across PauseState
-impl<P:PauseState> TimerFixed<Scaled,P>{
-	pub fn scaled(time:Time,new_time:Time,scale:Ratio64)->Self{
+impl<P:PauseState,In,Out> TimerFixed<Scaled<In,Out>,P>
+	where Time<In>:Copy,
+{
+	pub fn scaled(time:Time<In>,new_time:Time<Out>,scale:Ratio64)->Self{
 		let mut timer=Self{
 			state:Scaled::with_scale(scale),
 			_paused:P::new(),
@@ -118,15 +147,17 @@ impl<P:PauseState> TimerFixed<Scaled,P>{
 	pub const fn get_scale(&self)->Ratio64{
 		self.state.get_scale()
 	}
-	pub fn set_scale(&mut self,time:Time,new_scale:Ratio64){
+	pub fn set_scale(&mut self,time:Time<In>,new_scale:Ratio64){
 		self.state.set_scale(time,new_scale)
 	}
 }
 
 //pause and unpause is generic across TimerState
-impl<T:TimerState> TimerFixed<T,Paused>{
-	pub fn into_unpaused(self,time:Time)->TimerFixed<T,Unpaused>{
-		let new_time=self.time(time);
+impl<T:TimerState> TimerFixed<T,Paused>
+	where Time<T::In>:Copy,
+{
+	pub fn into_unpaused(self,time:Time<T::In>)->TimerFixed<T,Unpaused>{
+		let new_time=self.time();
 		let mut timer=TimerFixed{
 			state:self.state,
 			_paused:Unpaused,
@@ -134,9 +165,14 @@ impl<T:TimerState> TimerFixed<T,Paused>{
 		timer.set_time(time,new_time);
 		timer
 	}
+	pub fn time(&self)->Time<T::Out>{
+		self.state.get_offset().coerce()
+	}
 }
-impl<T:TimerState> TimerFixed<T,Unpaused>{
-	pub fn into_paused(self,time:Time)->TimerFixed<T,Paused>{
+impl<T:TimerState> TimerFixed<T,Unpaused>
+	where Time<T::In>:Copy,
+{
+	pub fn into_paused(self,time:Time<T::In>)->TimerFixed<T,Paused>{
 		let new_time=self.time(time);
 		let mut timer=TimerFixed{
 			state:self.state,
@@ -145,11 +181,14 @@ impl<T:TimerState> TimerFixed<T,Unpaused>{
 		timer.set_time(time,new_time);
 		timer
 	}
+	pub fn time(&self,time:Time<T::In>)->Time<T::Out>{
+		self.state.get_time(time)
+	}
 }
 
 //the new constructor and time queries are generic across both
 impl<T:TimerState,P:PauseState> TimerFixed<T,P>{
-	pub fn new(time:Time,new_time:Time)->Self{
+	pub fn new(time:Time<T::In>,new_time:Time<T::Out>)->Self{
 		let mut timer=Self{
 			state:T::identity(),
 			_paused:P::new(),
@@ -166,15 +205,9 @@ impl<T:TimerState,P:PauseState> TimerFixed<T,P>{
 	pub fn into_state(self)->T{
 		self.state
 	}
-	pub fn time(&self,time:Time)->Time{
+	pub fn set_time(&mut self,time:Time<T::In>,new_time:Time<T::Out>){
 		match P::IS_PAUSED{
-			true=>self.state.get_offset(),
-			false=>self.state.get_time(time),
-		}
-	}
-	pub fn set_time(&mut self,time:Time,new_time:Time){
-		match P::IS_PAUSED{
-			true=>self.state.set_offset(new_time),
+			true=>self.state.set_offset(new_time.coerce()),
 			false=>self.state.set_time(time,new_time),
 		}
 	}
@@ -198,7 +231,11 @@ pub enum Timer<T:TimerState>{
 	Paused(TimerFixed<T,Paused>),
 	Unpaused(TimerFixed<T,Unpaused>),
 }
-impl<T:TimerState> Timer<T>{
+impl<T:TimerState> Timer<T>
+	where
+		T:Copy,
+		Time<T::In>:Copy,
+{
 	pub fn from_state(state:T,paused:bool)->Self{
 		match paused{
 			true=>Self::Paused(TimerFixed::from_state(state)),
@@ -211,32 +248,32 @@ impl<T:TimerState> Timer<T>{
 			Self::Unpaused(timer)=>(timer.into_state(),false),
 		}
 	}
-	pub fn paused(time:Time,new_time:Time)->Self{
+	pub fn paused(time:Time<T::In>,new_time:Time<T::Out>)->Self{
 		Self::Paused(TimerFixed::new(time,new_time))
 	}
-	pub fn unpaused(time:Time,new_time:Time)->Self{
+	pub fn unpaused(time:Time<T::In>,new_time:Time<T::Out>)->Self{
 		Self::Unpaused(TimerFixed::new(time,new_time))
 	}
-	pub fn time(&self,time:Time)->Time{
+	pub fn time(&self,time:Time<T::In>)->Time<T::Out>{
 		match self{
-			Self::Paused(timer)=>timer.time(time),
+			Self::Paused(timer)=>timer.time(),
 			Self::Unpaused(timer)=>timer.time(time),
 		}
 	}
-	pub fn set_time(&mut self,time:Time,new_time:Time){
+	pub fn set_time(&mut self,time:Time<T::In>,new_time:Time<T::Out>){
 		match self{
 			Self::Paused(timer)=>timer.set_time(time,new_time),
 			Self::Unpaused(timer)=>timer.set_time(time,new_time),
 		}
 	}
-	pub fn pause(&mut self,time:Time)->Result<(),Error>{
+	pub fn pause(&mut self,time:Time<T::In>)->Result<(),Error>{
 		*self=match *self{
 			Self::Paused(_)=>return Err(Error::AlreadyPaused),
 			Self::Unpaused(timer)=>Self::Paused(timer.into_paused(time)),
 		};
 		Ok(())
 	}
-	pub fn unpause(&mut self,time:Time)->Result<(),Error>{
+	pub fn unpause(&mut self,time:Time<T::In>)->Result<(),Error>{
 		*self=match *self{
 			Self::Paused(timer)=>Self::Unpaused(timer.into_unpaused(time)),
 			Self::Unpaused(_)=>return Err(Error::AlreadyUnpaused),
@@ -249,7 +286,7 @@ impl<T:TimerState> Timer<T>{
 			Self::Unpaused(_)=>false,
 		}
 	}
-	pub fn set_paused(&mut self,time:Time,paused:bool)->Result<(),Error>{
+	pub fn set_paused(&mut self,time:Time<T::In>,paused:bool)->Result<(),Error>{
 		match paused{
 			true=>self.pause(time),
 			false=>self.unpause(time),
@@ -257,14 +294,16 @@ impl<T:TimerState> Timer<T>{
 	}
 }
 //scaled timer methods are generic across PauseState
-impl Timer<Scaled>{
+impl<In,Out> Timer<Scaled<In,Out>>
+	where Time<In>:Copy,
+{
 	pub const fn get_scale(&self)->Ratio64{
 		match self{
 			Self::Paused(timer)=>timer.get_scale(),
 			Self::Unpaused(timer)=>timer.get_scale(),
 		}
 	}
-	pub fn set_scale(&mut self,time:Time,new_scale:Ratio64){
+	pub fn set_scale(&mut self,time:Time<In>,new_scale:Ratio64){
 		match self{
 			Self::Paused(timer)=>timer.set_scale(time,new_scale),
 			Self::Unpaused(timer)=>timer.set_scale(time,new_scale),
@@ -280,12 +319,17 @@ mod test{
 			Time::from_secs($s)
 		};
 	}
+
+	#[derive(Clone,Copy,Hash,Eq,PartialEq,PartialOrd,Debug)]
+	enum Parent{}
+	#[derive(Clone,Copy,Hash,Eq,PartialEq,PartialOrd,Debug)]
+	enum Calculated{}
 	#[test]
 	fn test_timerfixed_scaled(){
 		//create a paused timer that reads 0s
-		let timer=TimerFixed::<Scaled,Paused>::from_state(Scaled{scale:0.5f32.try_into().unwrap(),offset:sec!(0)});
+		let timer=TimerFixed::<Scaled<Parent,Calculated>,Paused>::from_state(Scaled::new(0.5f32.try_into().unwrap(),sec!(0)));
 		//the paused timer at 1 second should read 0s
-		assert_eq!(timer.time(sec!(1)),sec!(0));
+		assert_eq!(timer.time(),sec!(0));
 
 		//unpause it after one second
 		let timer=timer.into_unpaused(sec!(1));
@@ -295,12 +339,12 @@ mod test{
 		//pause the timer after 11 seconds
 		let timer=timer.into_paused(sec!(11));
 		//the paused timer at 20 seconds should read 5s
-		assert_eq!(timer.time(sec!(20)),sec!(5));
+		assert_eq!(timer.time(),sec!(5));
 	}
 	#[test]
 	fn test_timer()->Result<(),Error>{
 		//create a paused timer that reads 0s
-		let mut timer=Timer::<Realtime>::paused(sec!(0),sec!(0));
+		let mut timer=Timer::<Realtime<Parent,Calculated>>::paused(sec!(0),sec!(0));
 		//the paused timer at 1 second should read 0s
 		assert_eq!(timer.time(sec!(1)),sec!(0));
 

lib/common/src/updatable.rs

@@ -1,56 +0,0 @@
-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/deferred_loader/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "strafesnet_deferred_loader"
-version = "0.4.1"
-edition = "2021"
+version = "0.5.0"
+edition = "2024"
 repository = "https://git.itzana.me/StrafesNET/strafe-project"
 license = "MIT OR Apache-2.0"
 description = "Acquire IDs for objects before loading them in bulk."
@@ -9,13 +9,5 @@ authors = ["Rhys Lloyd <krakow20@gmail.com>"]
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
-[features]
-default = ["legacy"]
-legacy = ["dep:url","dep:vbsp"]
-#roblox = ["dep:lazy-regex"]
-#source = ["dep:vbsp"]
-
 [dependencies]
-strafesnet_common = { path = "../common", registry = "strafesnet" }
-url = { version = "2.5.2", optional = true }
-vbsp = { version = "0.6.0", optional = true }
+strafesnet_common = { version = "0.6.0", path = "../common", registry = "strafesnet" }

lib/deferred_loader/src/deferred_loader.rs

@@ -0,0 +1,116 @@
+use std::collections::HashMap;
+use crate::loader::Loader;
+use crate::mesh::Meshes;
+use crate::texture::{RenderConfigs,Texture};
+use strafesnet_common::model::{Mesh,MeshId,RenderConfig,RenderConfigId,TextureId};
+
+#[derive(Clone,Copy,Debug)]
+pub enum LoadFailureMode{
+	DefaultToNone,
+	Fatal,
+}
+
+pub struct RenderConfigDeferredLoader<H>{
+	texture_count:u32,
+	render_configs:Vec<RenderConfig>,
+	render_config_id_from_asset_id:HashMap<Option<H>,RenderConfigId>,
+}
+impl<H> RenderConfigDeferredLoader<H>{
+	pub fn new()->Self{
+		Self{
+			texture_count:0,
+			render_configs:Vec::new(),
+			render_config_id_from_asset_id:HashMap::new(),
+		}
+	}
+}
+
+impl<H:core::hash::Hash+Eq> RenderConfigDeferredLoader<H>{
+	pub fn acquire_render_config_id(&mut self,index:Option<H>)->RenderConfigId{
+		let some_texture=index.is_some();
+		*self.render_config_id_from_asset_id.entry(index).or_insert_with(||{
+			//create the render config.
+			let render_config=if some_texture{
+				let render_config=RenderConfig::texture(TextureId::new(self.texture_count));
+				self.texture_count+=1;
+				render_config
+			}else{
+				RenderConfig::default()
+			};
+			let render_id=RenderConfigId::new(self.render_configs.len() as u32);
+			self.render_configs.push(render_config);
+			render_id
+		})
+	}
+	pub fn into_indices(self)->impl Iterator<Item=H>{
+		self.render_config_id_from_asset_id.into_keys().flatten()
+	}
+	pub fn into_render_configs<L:Loader<Resource=Texture,Index=H>>(mut self,loader:&mut L,failure_mode:LoadFailureMode)->Result<RenderConfigs,L::Error>{
+		let mut sorted_textures=vec![None;self.texture_count as usize];
+		for (index_option,render_config_id) in self.render_config_id_from_asset_id{
+			let render_config=&mut self.render_configs[render_config_id.get() as usize];
+			if let (Some(index),Some(texture_id))=(index_option,render_config.texture){
+				let resource_result=loader.load(index);
+				let texture=match failure_mode{
+					// if texture fails to load, use no texture
+					LoadFailureMode::DefaultToNone=>match resource_result{
+						Ok(texture)=>Some(texture),
+						Err(e)=>{
+							render_config.texture=None;
+							println!("Error loading texture: {e}");
+							None
+						},
+					},
+					// loading failure is fatal
+					LoadFailureMode::Fatal=>Some(resource_result?)
+				};
+				sorted_textures[texture_id.get() as usize]=texture;
+			}
+		}
+		Ok(RenderConfigs::new(
+			sorted_textures,
+			self.render_configs,
+		))
+	}
+}
+
+pub struct MeshDeferredLoader<H>{
+	mesh_id_from_asset_id:HashMap<H,MeshId>,
+}
+impl<H> MeshDeferredLoader<H>{
+	pub fn new()->Self{
+		Self{
+			mesh_id_from_asset_id:HashMap::new(),
+		}
+	}
+}
+
+impl<H:core::hash::Hash+Eq> MeshDeferredLoader<H>{
+	pub fn acquire_mesh_id(&mut self,index:H)->MeshId{
+		let mesh_id=MeshId::new(self.mesh_id_from_asset_id.len() as u32);
+		*self.mesh_id_from_asset_id.entry(index).or_insert(mesh_id)
+	}
+	pub fn into_indices(self)->impl Iterator<Item=H>{
+		self.mesh_id_from_asset_id.into_keys()
+	}
+	pub fn into_meshes<L:Loader<Resource=Mesh,Index=H>>(self,loader:&mut L,failure_mode:LoadFailureMode)->Result<Meshes,L::Error>{
+		let mut mesh_list=vec![None;self.mesh_id_from_asset_id.len()];
+		for (index,mesh_id) in self.mesh_id_from_asset_id{
+			let resource_result=loader.load(index);
+			let mesh=match failure_mode{
+				// if mesh fails to load, use no mesh
+				LoadFailureMode::DefaultToNone=>match resource_result{
+					Ok(mesh)=>Some(mesh),
+					Err(e)=>{
+						println!("Error loading mesh: {e}");
+						None
+					},
+				},
+				// loading failure is fatal
+				LoadFailureMode::Fatal=>Some(resource_result?)
+			};
+			mesh_list[mesh_id.get() as usize]=mesh;
+		}
+		Ok(Meshes::new(mesh_list))
+	}
+}

lib/deferred_loader/src/lib.rs

@@ -1,34 +1,5 @@
-#[cfg(feature="legacy")]
-mod roblox_legacy;
-#[cfg(feature="legacy")]
-mod source_legacy;
-#[cfg(feature="roblox")]
-mod roblox;
-#[cfg(feature="source")]
-mod source;
-
-#[cfg(any(feature="roblox",feature="legacy"))]
-pub mod rbxassetid;
 
+pub mod mesh;
+pub mod loader;
 pub mod texture;
-#[cfg(any(feature="source",feature="legacy"))]
-pub mod valve_mesh;
-#[cfg(any(feature="roblox",feature="legacy"))]
-pub mod roblox_mesh;
-
-#[cfg(feature="legacy")]
-pub fn roblox_legacy()->roblox_legacy::Loader{
-	roblox_legacy::Loader::new()
-}
-#[cfg(feature="legacy")]
-pub fn source_legacy()->source_legacy::Loader{
-	source_legacy::Loader::new()
-}
-#[cfg(feature="roblox")]
-pub fn roblox()->roblox::Loader{
-	roblox::Loader::new()
-}
-#[cfg(feature="source")]
-pub fn source()->source::Loader{
-	source::Loader::new()
-}
+pub mod deferred_loader;

lib/deferred_loader/src/loader.rs

@@ -0,0 +1,8 @@
+use std::error::Error;
+
+pub trait Loader{
+	type Error:Error;
+	type Index;
+	type Resource;
+	fn load(&mut self,index:Self::Index)->Result<Self::Resource,Self::Error>;
+}

lib/deferred_loader/src/mesh.rs

@@ -0,0 +1,17 @@
+use strafesnet_common::model::{Mesh,MeshId};
+
+pub struct Meshes{
+	meshes:Vec<Option<Mesh>>,
+}
+impl Meshes{
+	pub(crate) const fn new(meshes:Vec<Option<Mesh>>)->Self{
+		Self{
+			meshes,
+		}
+	}
+	pub fn consume(self)->impl Iterator<Item=(MeshId,Mesh)>{
+		self.meshes.into_iter().enumerate().filter_map(|(mesh_id,maybe_mesh)|
+			maybe_mesh.map(|mesh|(MeshId::new(mesh_id as u32),mesh))
+		)
+	}
+}

lib/deferred_loader/src/rbxassetid.rs

@@ -1,48 +0,0 @@
-#[derive(Hash,Eq,PartialEq)]
-pub struct RobloxAssetId(pub u64);
-#[derive(Debug)]
-#[allow(dead_code)]
-pub struct StringWithError{
-	string:String,
-	error:RobloxAssetIdParseErr,
-}
-impl std::fmt::Display for StringWithError{
-	fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
-		write!(f,"{self:?}")
-	}
-}
-impl std::error::Error for StringWithError{}
-impl StringWithError{
-	const fn new(
-		string:String,
-		error:RobloxAssetIdParseErr,
-	)->Self{
-		Self{string,error}
-	}
-}
-#[derive(Debug)]
-pub enum RobloxAssetIdParseErr{
-	Url(url::ParseError),
-	UnknownScheme,
-	ParseInt(std::num::ParseIntError),
-	MissingAssetId,
-}
-impl std::str::FromStr for RobloxAssetId{
-	type Err=StringWithError;
-	fn from_str(s:&str)->Result<Self,Self::Err>{
-		let url=url::Url::parse(s).map_err(|e|StringWithError::new(s.to_owned(),RobloxAssetIdParseErr::Url(e)))?;
-		let parsed_asset_id=match url.scheme(){
-			"rbxassetid"=>url.domain().ok_or_else(||StringWithError::new(s.to_owned(),RobloxAssetIdParseErr::MissingAssetId))?.parse(),
-			"http"|"https"=>{
-				let (_,asset_id)=url.query_pairs()
-				.find(|(id,_)|match id.as_ref(){
-					"ID"|"id"|"Id"|"iD"=>true,
-					_=>false,
-				}).ok_or_else(||StringWithError::new(s.to_owned(),RobloxAssetIdParseErr::MissingAssetId))?;
-				asset_id.parse()
-			},
-			_=>Err(StringWithError::new(s.to_owned(),RobloxAssetIdParseErr::UnknownScheme))?,
-		};
-		Ok(Self(parsed_asset_id.map_err(|e|StringWithError::new(s.to_owned(),RobloxAssetIdParseErr::ParseInt(e)))?))
-	}
-}

lib/deferred_loader/src/roblox_legacy.rs

@@ -1,112 +0,0 @@
-use std::io::Read;
-use std::collections::HashMap;
-use crate::roblox_mesh;
-use crate::texture::{RenderConfigs,Texture};
-use strafesnet_common::model::{MeshId,RenderConfig,RenderConfigId,TextureId};
-use crate::rbxassetid::RobloxAssetId;
-
-#[derive(Default)]
-pub struct RenderConfigLoader{
-	texture_count:u32,
-	render_configs:Vec<RenderConfig>,
-	render_config_id_from_asset_id:HashMap<Option<RobloxAssetId>,RenderConfigId>,
-}
-
-impl RenderConfigLoader{
-	pub fn acquire_render_config_id(&mut self,name:Option<&str>)->RenderConfigId{
-		let render_id=RenderConfigId::new(self.render_config_id_from_asset_id.len() as u32);
-		let index=name.and_then(|name|{
-			match name.parse::<RobloxAssetId>(){
-				Ok(asset_id)=>Some(asset_id),
-				Err(e)=>{
-					println!("Failed to parse AssetId: {e}");
-					None
-				},
-			}
-		});
-		*self.render_config_id_from_asset_id.entry(index).or_insert_with(||{
-			//create the render config.
-			let render_config=if name.is_some(){
-				let render_config=RenderConfig::texture(TextureId::new(self.texture_count));
-				self.texture_count+=1;
-				render_config
-			}else{
-				RenderConfig::default()
-			};
-			self.render_configs.push(render_config);
-			render_id
-		})
-	}
-}
-
-#[derive(Default)]
-pub struct MeshLoader{
-	mesh_id_from_asset_id:HashMap<Option<RobloxAssetId>,MeshId>,
-}
-
-impl MeshLoader{
-	pub fn acquire_mesh_id(&mut self,name:&str)->MeshId{
-		let mesh_id=MeshId::new(self.mesh_id_from_asset_id.len() as u32);
-		let index=match name.parse::<RobloxAssetId>(){
-			Ok(asset_id)=>Some(asset_id),
-			Err(e)=>{
-				println!("Failed to parse AssetId: {e}");
-				None
-			},
-		};
-		*self.mesh_id_from_asset_id.entry(index).or_insert(mesh_id)
-	}
-	pub fn load_meshes(&mut self)->Result<roblox_mesh::Meshes,std::io::Error>{
-		let mut mesh_data=vec![None;self.mesh_id_from_asset_id.len()];
-		for (asset_id_option,mesh_id) in &self.mesh_id_from_asset_id{
-			if let Some(asset_id)=asset_id_option{
-				if let Ok(mut file)=std::fs::File::open(format!("meshes/{}",asset_id.0)){
-					//TODO: parallel
-					let mut data=Vec::<u8>::new();
-					file.read_to_end(&mut data)?;
-					mesh_data[mesh_id.get() as usize]=Some(roblox_mesh::RobloxMeshData::new(data));
-				}else{
-					println!("[roblox_legacy] no mesh name={}",asset_id.0);
-				}
-			}
-		}
-		Ok(roblox_mesh::Meshes::new(mesh_data))
-	}
-}
-
-pub struct Loader{
-	render_config_loader:RenderConfigLoader,
-	mesh_loader:MeshLoader,
-}
-impl Loader{
-	pub fn new()->Self{
-		Self{
-			render_config_loader:RenderConfigLoader::default(),
-			mesh_loader:MeshLoader::default(),
-		}
-	}
-	pub fn get_inner_mut(&mut self)->(&mut RenderConfigLoader,&mut MeshLoader){
-		(&mut self.render_config_loader,&mut self.mesh_loader)
-	}
-	pub fn into_render_configs(mut self)->Result<RenderConfigs,std::io::Error>{
-		let mut sorted_textures=vec![None;self.render_config_loader.texture_count as usize];
-		for (asset_id_option,render_config_id) in self.render_config_loader.render_config_id_from_asset_id{
-			let render_config=self.render_config_loader.render_configs.get_mut(render_config_id.get() as usize).unwrap();
-			if let (Some(asset_id),Some(texture_id))=(asset_id_option,render_config.texture){
-				if let Ok(mut file)=std::fs::File::open(format!("textures/{}.dds",asset_id.0)){
-					//TODO: parallel
-					let mut data=Vec::<u8>::new();
-					file.read_to_end(&mut data)?;
-					sorted_textures[texture_id.get() as usize]=Some(Texture::ImageDDS(data));
-				}else{
-					//texture failed to load
-					render_config.texture=None;
-				}
-			}
-		}
-		Ok(RenderConfigs::new(
-			sorted_textures,
-			self.render_config_loader.render_configs,
-		))
-	}
-}

lib/deferred_loader/src/roblox_mesh.rs

@@ -1,30 +0,0 @@
-use strafesnet_common::model::MeshId;
-
-#[derive(Clone)]
-pub struct RobloxMeshData(Vec<u8>);
-impl RobloxMeshData{
-	pub(crate) fn new(data:Vec<u8>)->Self{
-		Self(data)
-	}
-	pub fn get(self)->Vec<u8>{
-		self.0
-	}
-}
-pub struct Meshes{
-	meshes:Vec<Option<RobloxMeshData>>,
-}
-impl Meshes{
-	pub(crate) const fn new(meshes:Vec<Option<RobloxMeshData>>)->Self{
-		Self{
-			meshes,
-		}
-	}
-	pub fn get_texture(&self,texture_id:MeshId)->Option<&RobloxMeshData>{
-		self.meshes.get(texture_id.get() as usize)?.as_ref()
-	}
-	pub fn into_iter(self)->impl Iterator<Item=(MeshId,RobloxMeshData)>{
-		self.meshes.into_iter().enumerate().filter_map(|(mesh_id,maybe_mesh)|
-			maybe_mesh.map(|mesh|(MeshId::new(mesh_id as u32),mesh))
-		)
-	}
-}

lib/deferred_loader/src/source_legacy.rs

@@ -1,102 +0,0 @@
-use std::io::Read;
-use std::collections::HashMap;
-use crate::valve_mesh;
-use crate::texture::{Texture,RenderConfigs};
-use strafesnet_common::model::{MeshId,TextureId,RenderConfig,RenderConfigId};
-
-pub struct RenderConfigLoader{
-	texture_count:u32,
-	render_configs:Vec<RenderConfig>,
-	texture_paths:HashMap<Option<Box<str>>,RenderConfigId>,
-}
-impl RenderConfigLoader{
-	pub fn acquire_render_config_id(&mut self,name:Option<&str>)->RenderConfigId{
-		let render_id=RenderConfigId::new(self.texture_paths.len() as u32);
-		*self.texture_paths.entry(name.map(Into::into)).or_insert_with(||{
-			//create the render config.
-			let render_config=if name.is_some(){
-				let render_config=RenderConfig::texture(TextureId::new(self.texture_count));
-				self.texture_count+=1;
-				render_config
-			}else{
-				RenderConfig::default()
-			};
-			self.render_configs.push(render_config);
-			render_id
-		})
-	}
-}
-pub struct MeshLoader{
-	mesh_paths:HashMap<Box<str>,MeshId>,
-}
-impl MeshLoader{
-	pub fn acquire_mesh_id(&mut self,name:&str)->MeshId{
-		let mesh_id=MeshId::new(self.mesh_paths.len() as u32);
-		*self.mesh_paths.entry(name.into()).or_insert(mesh_id)
-	}
-	//load_meshes should look like load_textures
-	pub fn load_meshes(&mut self,bsp:&vbsp::Bsp)->valve_mesh::Meshes{
-		let mut mesh_data=vec![None;self.mesh_paths.len()];
-		for (mesh_path,mesh_id) in &self.mesh_paths{
-			let mesh_path_lower=mesh_path.to_lowercase();
-			//.mdl, .vvd, .dx90.vtx
-			let path=std::path::PathBuf::from(mesh_path_lower.as_str());
-			let mut vvd_path=path.clone();
-			let mut vtx_path=path.clone();
-			vvd_path.set_extension("vvd");
-			vtx_path.set_extension("dx90.vtx");
-			match (bsp.pack.get(mesh_path_lower.as_str()),bsp.pack.get(vvd_path.as_os_str().to_str().unwrap()),bsp.pack.get(vtx_path.as_os_str().to_str().unwrap())){
-				(Ok(Some(mdl_file)),Ok(Some(vvd_file)),Ok(Some(vtx_file)))=>{
-					mesh_data[mesh_id.get() as usize]=Some(valve_mesh::ModelData{
-						mdl:valve_mesh::MdlData::new(mdl_file),
-						vtx:valve_mesh::VtxData::new(vtx_file),
-						vvd:valve_mesh::VvdData::new(vvd_file),
-					});
-				},
-				_=>println!("no model name={}",mesh_path),
-			}
-		}
-		valve_mesh::Meshes::new(mesh_data)
-	}
-}
-
-pub struct Loader{
-	render_config_loader:RenderConfigLoader,
-	mesh_loader:MeshLoader,
-}
-impl Loader{
-	pub fn new()->Self{
-		Self{
-			render_config_loader:RenderConfigLoader{
-				texture_count:0,
-				texture_paths:HashMap::new(),
-				render_configs:Vec::new(),
-			},
-			mesh_loader:MeshLoader{mesh_paths:HashMap::new()},
-		}
-	}
-	pub fn get_inner_mut(&mut self)->(&mut RenderConfigLoader,&mut MeshLoader){
-		(&mut self.render_config_loader,&mut self.mesh_loader)
-	}
-	pub fn into_render_configs(mut self)->Result<RenderConfigs,std::io::Error>{
-		let mut sorted_textures=vec![None;self.render_config_loader.texture_count as usize];
-		for (texture_path,render_config_id) in self.render_config_loader.texture_paths{
-			let render_config=self.render_config_loader.render_configs.get_mut(render_config_id.get() as usize).unwrap();
-			if let (Some(texture_path),Some(texture_id))=(texture_path,render_config.texture){
-				if let Ok(mut file)=std::fs::File::open(format!("textures/{}.dds",texture_path)){
-					//TODO: parallel
-					let mut data=Vec::<u8>::new();
-					file.read_to_end(&mut data)?;
-					sorted_textures[texture_id.get() as usize]=Some(Texture::ImageDDS(data));
-				}else{
-					//texture failed to load
-					render_config.texture=None;
-				}
-			}
-		}
-		Ok(RenderConfigs::new(
-			sorted_textures,
-			self.render_config_loader.render_configs,
-		))
-	}
-}

lib/deferred_loader/src/valve_mesh.rs

@@ -1,60 +0,0 @@
-use strafesnet_common::model::MeshId;
-
-//duplicate this code for now
-#[derive(Clone)]
-pub struct MdlData(Vec<u8>);
-impl MdlData{
-	pub const fn new(value:Vec<u8>)->Self{
-		Self(value)
-	}
-	pub fn get(self)->Vec<u8>{
-		self.0
-	}
-}
-#[derive(Clone)]
-pub struct VtxData(Vec<u8>);
-impl VtxData{
-	pub const fn new(value:Vec<u8>)->Self{
-		Self(value)
-	}
-	pub fn get(self)->Vec<u8>{
-		self.0
-	}
-}
-#[derive(Clone)]
-pub struct VvdData(Vec<u8>);
-impl VvdData{
-	pub const fn new(value:Vec<u8>)->Self{
-		Self(value)
-	}
-	pub fn get(self)->Vec<u8>{
-		self.0
-	}
-}
-
-#[derive(Clone)]
-pub struct ModelData{
-	pub mdl:MdlData,
-	pub vtx:VtxData,
-	pub vvd:VvdData,
-}
-
-//meshes is more prone to failure
-pub struct Meshes{
-	meshes:Vec<Option<ModelData>>,
-}
-impl Meshes{
-	pub(crate) const fn new(meshes:Vec<Option<ModelData>>)->Self{
-		Self{
-			meshes,
-		}
-	}
-	pub fn get_texture(&self,texture_id:MeshId)->Option<&ModelData>{
-		self.meshes.get(texture_id.get() as usize)?.as_ref()
-	}
-	pub fn into_iter(self)->impl Iterator<Item=(MeshId,ModelData)>{
-		self.meshes.into_iter().enumerate().filter_map(|(mesh_id,maybe_mesh)|
-			maybe_mesh.map(|mesh|(MeshId::new(mesh_id as u32),mesh))
-		)
-	}
-}

lib/fixed_wide/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "fixed_wide"
-version = "0.1.1"
-edition = "2021"
+version = "0.1.2"
+edition = "2024"
 repository = "https://git.itzana.me/StrafesNET/strafe-project"
 license = "MIT OR Apache-2.0"
 description = "Fixed point numbers with optional widening Mul operator."
@@ -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 = { path = "../ratio_ops", registry = "strafesnet", optional = true }
+ratio_ops = { version = "0.1.0", path = "../ratio_ops", registry = "strafesnet", optional = true }

lib/fixed_wide/src/fixed.rs

@@ -1,6 +1,6 @@
 use bnum::{BInt,cast::As};
 
-#[derive(Clone,Copy,Debug,Default,Hash)]
+#[derive(Clone,Copy,Debug,Default,Hash,PartialEq,Eq,PartialOrd,Ord)]
 /// A Fixed point number for which multiply operations widen the bits in the output. (when the wide-mul feature is enabled)
 /// N is the number of u64s to use
 /// F is the number of fractional bits (always N*32 lol)
@@ -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
@@ -87,12 +99,6 @@ impl_from!(
 	i8,i16,i32,i64,i128,isize
 );
 
-impl<const N:usize,const F:usize> PartialEq for Fixed<N,F>{
-	#[inline]
-	fn eq(&self,other:&Self)->bool{
-		self.bits.eq(&other.bits)
-	}
-}
 impl<const N:usize,const F:usize,T> PartialEq<T> for Fixed<N,F>
 where
 		T:Copy,
@@ -103,14 +109,7 @@ where
 		self.bits.eq(&other.into())
 	}
 }
-impl<const N:usize,const F:usize> Eq for Fixed<N,F>{}
 
-impl<const N:usize,const F:usize> PartialOrd for Fixed<N,F>{
-	#[inline]
-	fn partial_cmp(&self,other:&Self)->Option<std::cmp::Ordering>{
-		self.bits.partial_cmp(&other.bits)
-	}
-}
 impl<const N:usize,const F:usize,T> PartialOrd<T> for Fixed<N,F>
 	where
 		T:Copy,
@@ -121,12 +120,6 @@ impl<const N:usize,const F:usize,T> PartialOrd<T> for Fixed<N,F>
 		self.bits.partial_cmp(&other.into())
 	}
 }
-impl<const N:usize,const F:usize> Ord for Fixed<N,F>{
-	#[inline]
-	fn cmp(&self,other:&Self)->std::cmp::Ordering{
-		self.bits.cmp(&other.bits)
-	}
-}
 
 impl<const N:usize,const F:usize> std::ops::Neg for Fixed<N,F>{
 	type Output=Self;
@@ -807,13 +800,10 @@ macro_rules! impl_not_const_generic{
 				let wide_self=self.[<fix_ $_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

@@ -57,7 +57,7 @@ fn from_f32(){
 	assert_eq!(b,Ok(a));
 	//I32F32::MIN hits a special case since it's not representable as a positive signed integer
 	//TODO: don't return an overflow because this is technically possible
-	let a=I32F32::MIN;
+	let _a=I32F32::MIN;
 	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

lib/linear_ops/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "linear_ops"
 version = "0.1.0"
-edition = "2021"
+edition = "2024"
 repository = "https://git.itzana.me/StrafesNET/strafe-project"
 license = "MIT OR Apache-2.0"
 description = "Vector/Matrix operations using trait bounds."
@@ -14,8 +14,8 @@ fixed-wide=["dep:fixed_wide","dep:paste"]
 deferred-division=["dep:ratio_ops"]
 
 [dependencies]
-ratio_ops = { path = "../ratio_ops", registry = "strafesnet", optional = true }
-fixed_wide = { path = "../fixed_wide", registry = "strafesnet", optional = true }
+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 }
 paste = { version = "1.0.15", optional = true }
 
 [dev-dependencies]

lib/linear_ops/src/matrix.rs

@@ -1,5 +1,6 @@
 use crate::vector::Vector;
 
+#[repr(transparent)]
 #[derive(Clone,Copy,Debug,Hash,Eq,PartialEq)]
 pub struct Matrix<const X:usize,const Y:usize,T>{
 	pub(crate) array:[[T;Y];X],

lib/linear_ops/src/vector.rs

@@ -3,6 +3,7 @@
 /// v.x += v.z;
 /// println!("v.x={}",v.x);
 
+#[repr(transparent)]
 #[derive(Clone,Copy,Debug,Hash,Eq,PartialEq)]
 pub struct Vector<const N:usize,T>{
 	pub(crate) array:[T;N],

lib/ratio_ops/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "ratio_ops"
-version = "0.1.0"
-edition = "2021"
+version = "0.1.1"
+edition = "2024"
 repository = "https://git.itzana.me/StrafesNET/strafe-project"
 license = "MIT OR Apache-2.0"
 description = "Ratio operations using trait bounds for avoiding division like the plague."

lib/ratio_ops/src/ratio.rs

@@ -268,30 +268,35 @@ impl<LhsNum,LhsDen,RhsNum,RhsDen,T,U> PartialEq<Ratio<RhsNum,RhsDen>> for Ratio<
 }
 impl<Num,Den> Eq for Ratio<Num,Den> where Self:PartialEq{}
 
+// Wow! These were both completely wrong!
+// Idea: use a 'signed' trait instead of parity and float the sign to the numerator.
 impl<LhsNum,LhsDen,RhsNum,RhsDen,T,U> PartialOrd<Ratio<RhsNum,RhsDen>> for Ratio<LhsNum,LhsDen>
 	where
 		LhsNum:Copy,
-		LhsDen:Copy,
+		LhsDen:Copy+Parity,
 		RhsNum:Copy,
-		RhsDen:Copy,
+		RhsDen:Copy+Parity,
 		LhsNum:core::ops::Mul<RhsDen,Output=T>,
+		LhsDen:core::ops::Mul<RhsNum,Output=T>,
 		RhsNum:core::ops::Mul<LhsDen,Output=U>,
-		T:PartialOrd<U>,
+		RhsDen:core::ops::Mul<LhsNum,Output=U>,
+		T:PartialOrd<U>+Ord,
 {
 	#[inline]
-	fn partial_cmp(&self,other:&Ratio<RhsNum,RhsDen>)->Option<core::cmp::Ordering>{
-		(self.num*other.den).partial_cmp(&(other.num*self.den))
+	fn partial_cmp(&self,&other:&Ratio<RhsNum,RhsDen>)->Option<core::cmp::Ordering>{
+		self.partial_cmp_ratio(other)
 	}
 }
 impl<Num,Den,T> Ord for Ratio<Num,Den>
 	where
 		Num:Copy,
-		Den:Copy,
+		Den:Copy+Parity,
 		Num:core::ops::Mul<Den,Output=T>,
+		Den:core::ops::Mul<Num,Output=T>,
 		T:Ord,
 {
 	#[inline]
-	fn cmp(&self,other:&Self)->std::cmp::Ordering{
-		(self.num*other.den).cmp(&(other.num*self.den))
+	fn cmp(&self,&other:&Self)->std::cmp::Ordering{
+		self.cmp_ratio(other)
 	}
 }

lib/rbx_loader/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "strafesnet_rbx_loader"
-version = "0.5.2"
-edition = "2021"
+version = "0.6.0"
+edition = "2024"
 repository = "https://git.itzana.me/StrafesNET/strafe-project"
 license = "MIT OR Apache-2.0"
 description = "Convert Roblox place and model files to StrafesNET data structures."
@@ -11,12 +11,14 @@ authors = ["Rhys Lloyd <krakow20@gmail.com>"]
 
 [dependencies]
 bytemuck = "1.14.3"
-glam = "0.29.0"
+glam = "0.30.0"
 lazy-regex = "3.1.0"
 rbx_binary = { version = "0.7.4", registry = "strafesnet" }
 rbx_dom_weak = { version = "2.7.0", registry = "strafesnet" }
-rbx_mesh = "0.1.2"
+rbx_mesh = "0.3.1"
 rbx_reflection_database = { version = "0.2.10", registry = "strafesnet" }
 rbx_xml = { version = "0.13.3", registry = "strafesnet" }
-roblox_emulator = { path = "../roblox_emulator", registry = "strafesnet" }
-strafesnet_common = { path = "../common", registry = "strafesnet" }
+rbxassetid = { version = "0.1.0", path = "../rbxassetid", registry = "strafesnet" }
+roblox_emulator = { version = "0.4.7", path = "../roblox_emulator", registry = "strafesnet" }
+strafesnet_common = { version = "0.6.0", path = "../common", registry = "strafesnet" }
+strafesnet_deferred_loader = { version = "0.5.0", path = "../deferred_loader", registry = "strafesnet" }

lib/rbx_loader/src/lib.rs

@@ -1,8 +1,11 @@
 use std::io::Read;
 use rbx_dom_weak::WeakDom;
+use strafesnet_deferred_loader::deferred_loader::{LoadFailureMode,MeshDeferredLoader,RenderConfigDeferredLoader};
 
 mod rbx;
 mod mesh;
+mod union;
+pub mod loader;
 mod primitives;
 
 pub mod data{
@@ -30,6 +33,9 @@ impl Model{
 		let services=context.convert_into_place();
 		Place{dom,services}
 	}
+	pub fn to_snf(&self,failure_mode:LoadFailureMode)->Result<strafesnet_common::map::CompleteMap,LoadError>{
+		to_snf(self,failure_mode)
+	}
 }
 impl AsRef<WeakDom> for Model{
 	fn as_ref(&self)->&WeakDom{
@@ -42,7 +48,7 @@ pub struct Place{
 	services:roblox_emulator::context::Services,
 }
 impl Place{
-	fn new(dom:WeakDom)->Option<Self>{
+	pub fn new(dom:WeakDom)->Option<Self>{
 		let context=roblox_emulator::context::Context::from_ref(&dom);
 		Some(Self{
 			services:context.find_services()?,
@@ -61,6 +67,9 @@ impl Place{
 			}
 		}
 	}
+	pub fn to_snf(&self,failure_mode:LoadFailureMode)->Result<strafesnet_common::map::CompleteMap,LoadError>{
+		to_snf(self,failure_mode)
+	}
 }
 impl AsRef<WeakDom> for Place{
 	fn as_ref(&self)->&WeakDom{
@@ -92,16 +101,49 @@ pub fn read<R:Read>(input:R)->Result<Model,ReadError>{
 	}
 }
 
-//ConvertError
-
-pub fn convert<AcquireRenderConfigId,AcquireMeshId>(
-	dom:impl AsRef<WeakDom>,
-	acquire_render_config_id:AcquireRenderConfigId,
-	acquire_mesh_id:AcquireMeshId
-)->rbx::PartialMap1
-where
-	AcquireRenderConfigId:FnMut(Option<&str>)->strafesnet_common::model::RenderConfigId,
-	AcquireMeshId:FnMut(&str)->strafesnet_common::model::MeshId,
-{
-	rbx::convert(&dom.as_ref(),acquire_render_config_id,acquire_mesh_id)
+#[derive(Debug)]
+pub enum LoadError{
+	Texture(loader::TextureError),
+	Mesh(loader::MeshError),
+}
+impl std::fmt::Display for LoadError{
+	fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
+		write!(f,"{self:?}")
+	}
+}
+impl std::error::Error for LoadError{}
+impl From<loader::TextureError> for LoadError{
+	fn from(value:loader::TextureError)->Self{
+		Self::Texture(value)
+	}
+}
+impl From<loader::MeshError> for LoadError{
+	fn from(value:loader::MeshError)->Self{
+		Self::Mesh(value)
+	}
+}
+
+fn to_snf(dom:impl AsRef<WeakDom>,failure_mode:LoadFailureMode)->Result<strafesnet_common::map::CompleteMap,LoadError>{
+	let dom=dom.as_ref();
+
+	let mut texture_deferred_loader=RenderConfigDeferredLoader::new();
+	let mut mesh_deferred_loader=MeshDeferredLoader::new();
+
+	let map_step1=rbx::convert(
+		dom,
+		&mut texture_deferred_loader,
+		&mut mesh_deferred_loader,
+	);
+
+	let mut mesh_loader=loader::MeshLoader::new();
+	let meshpart_meshes=mesh_deferred_loader.into_meshes(&mut mesh_loader,failure_mode).map_err(LoadError::Mesh)?;
+
+	let map_step2=map_step1.add_meshpart_meshes_and_calculate_attributes(meshpart_meshes);
+
+	let mut texture_loader=loader::TextureLoader::new();
+	let render_configs=texture_deferred_loader.into_render_configs(&mut texture_loader,failure_mode).map_err(LoadError::Texture)?;
+
+	let map=map_step2.add_render_configs_and_textures(render_configs);
+
+	Ok(map)
 }

lib/rbx_loader/src/loader.rs

@@ -0,0 +1,191 @@
+use std::io::Read;
+use rbxassetid::{RobloxAssetId,RobloxAssetIdParseErr};
+use strafesnet_common::model::Mesh;
+use strafesnet_deferred_loader::{loader::Loader,texture::Texture};
+
+use crate::data::RobloxMeshBytes;
+use crate::rbx::RobloxFaceTextureDescription;
+
+fn read_entire_file(path:impl AsRef<std::path::Path>)->Result<Vec<u8>,std::io::Error>{
+	let mut file=std::fs::File::open(path)?;
+	let mut data=Vec::new();
+	file.read_to_end(&mut data)?;
+	Ok(data)
+}
+
+#[allow(dead_code)]
+#[derive(Debug)]
+pub enum TextureError{
+	Io(std::io::Error),
+	RobloxAssetIdParse(RobloxAssetIdParseErr),
+}
+impl std::fmt::Display for TextureError{
+	fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
+		write!(f,"{self:?}")
+	}
+}
+impl std::error::Error for TextureError{}
+impl From<std::io::Error> for TextureError{
+	fn from(value:std::io::Error)->Self{
+		Self::Io(value)
+	}
+}
+impl From<RobloxAssetIdParseErr> for TextureError{
+	fn from(value:RobloxAssetIdParseErr)->Self{
+		Self::RobloxAssetIdParse(value)
+	}
+}
+
+pub struct TextureLoader<'a>(std::marker::PhantomData<&'a ()>);
+impl TextureLoader<'_>{
+	pub fn new()->Self{
+		Self(std::marker::PhantomData)
+	}
+}
+impl<'a> Loader for TextureLoader<'a>{
+	type Error=TextureError;
+	type Index=&'a str;
+	type Resource=Texture;
+	fn load(&mut self,index:Self::Index)->Result<Self::Resource,Self::Error>{
+		let RobloxAssetId(asset_id)=index.parse()?;
+		let file_name=format!("textures/{}.dds",asset_id);
+		let data=read_entire_file(file_name)?;
+		Ok(Texture::ImageDDS(data))
+	}
+}
+
+#[allow(dead_code)]
+#[derive(Debug)]
+pub enum MeshError{
+	Io(std::io::Error),
+	RobloxAssetIdParse(RobloxAssetIdParseErr),
+	Mesh(crate::mesh::Error),
+	Union(crate::union::Error),
+	DecodeBinary(rbx_binary::DecodeError),
+	OneChildPolicy,
+	MissingInstance,
+}
+impl std::fmt::Display for MeshError{
+	fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
+		write!(f,"{self:?}")
+	}
+}
+impl std::error::Error for MeshError{}
+impl From<std::io::Error> for MeshError{
+	fn from(value:std::io::Error)->Self{
+		Self::Io(value)
+	}
+}
+impl From<RobloxAssetIdParseErr> for MeshError{
+	fn from(value:RobloxAssetIdParseErr)->Self{
+		Self::RobloxAssetIdParse(value)
+	}
+}
+impl From<crate::mesh::Error> for MeshError{
+	fn from(value:crate::mesh::Error)->Self{
+		Self::Mesh(value)
+	}
+}
+impl From<crate::union::Error> for MeshError{
+	fn from(value:crate::union::Error)->Self{
+		Self::Union(value)
+	}
+}
+impl From<rbx_binary::DecodeError> for MeshError{
+	fn from(value:rbx_binary::DecodeError)->Self{
+		Self::DecodeBinary(value)
+	}
+}
+
+#[derive(Hash,Eq,PartialEq)]
+pub enum MeshType<'a>{
+	FileMesh,
+	Union{
+		mesh_data:&'a [u8],
+		physics_data:&'a [u8],
+		size_float_bits:[u32;3],
+		part_texture_description:[Option<RobloxFaceTextureDescription>;6],
+	},
+}
+#[derive(Hash,Eq,PartialEq)]
+pub struct MeshIndex<'a>{
+	mesh_type:MeshType<'a>,
+	content:&'a str,
+}
+impl MeshIndex<'_>{
+	pub fn file_mesh(content:&str)->MeshIndex{
+		MeshIndex{
+			mesh_type:MeshType::FileMesh,
+			content,
+		}
+	}
+	pub fn union<'a>(
+		content:&'a str,
+		mesh_data:&'a [u8],
+		physics_data:&'a [u8],
+		size:&rbx_dom_weak::types::Vector3,
+		part_texture_description:crate::rbx::RobloxPartDescription,
+	)->MeshIndex<'a>{
+		MeshIndex{
+			mesh_type:MeshType::Union{
+				mesh_data,
+				physics_data,
+				size_float_bits:[size.x.to_bits(),size.y.to_bits(),size.z.to_bits()],
+				part_texture_description,
+			},
+			content,
+		}
+	}
+}
+
+pub struct MeshLoader<'a>(std::marker::PhantomData<&'a ()>);
+impl MeshLoader<'_>{
+	pub fn new()->Self{
+		Self(std::marker::PhantomData)
+	}
+}
+impl<'a> Loader for MeshLoader<'a>{
+	type Error=MeshError;
+	type Index=MeshIndex<'a>;
+	type Resource=Mesh;
+	fn load(&mut self,index:Self::Index)->Result<Self::Resource,Self::Error>{
+		let mesh=match index.mesh_type{
+			MeshType::FileMesh=>{
+				let RobloxAssetId(asset_id)=index.content.parse()?;
+				let file_name=format!("meshes/{}",asset_id);
+				let data=read_entire_file(file_name)?;
+				crate::mesh::convert(RobloxMeshBytes::new(data))?
+			},
+			MeshType::Union{mut physics_data,mut mesh_data,size_float_bits,part_texture_description}=>{
+				// decode asset
+				let size=glam::Vec3::from_array(size_float_bits.map(f32::from_bits));
+				if !index.content.is_empty()&&(physics_data.is_empty()||mesh_data.is_empty()){
+					let RobloxAssetId(asset_id)=index.content.parse()?;
+					let file_name=format!("unions/{}",asset_id);
+					let data=read_entire_file(file_name)?;
+					let dom=rbx_binary::from_reader(std::io::Cursor::new(data))?;
+					let &[referent]=dom.root().children()else{
+						return Err(MeshError::OneChildPolicy);
+					};
+					let Some(instance)=dom.get_by_ref(referent)else{
+						return Err(MeshError::MissingInstance);
+					};
+					if physics_data.is_empty(){
+						if let Some(rbx_dom_weak::types::Variant::BinaryString(data))=instance.properties.get("PhysicsData"){
+							physics_data=data.as_ref();
+						}
+					}
+					if mesh_data.is_empty(){
+						if let Some(rbx_dom_weak::types::Variant::BinaryString(data))=instance.properties.get("MeshData"){
+							mesh_data=data.as_ref();
+						}
+					}
+					crate::union::convert(physics_data,mesh_data,size,part_texture_description)?
+				}else{
+					crate::union::convert(physics_data,mesh_data,size,part_texture_description)?
+				}
+			},
+		};
+		Ok(mesh)
+	}
+}

lib/rbx_loader/src/mesh.rs

@@ -1,8 +1,9 @@
 use std::collections::HashMap;
 
-use rbx_mesh::mesh::{Vertex2, Vertex2Truncated};
-use strafesnet_common::{integer::vec3,model::{self, ColorId, IndexedVertex, NormalId, PolygonGroup, PolygonList, PositionId, TextureCoordinateId, VertexId}};
+use rbx_mesh::mesh::{Vertex2,Vertex2Truncated};
+use strafesnet_common::{integer::vec3,model::{self,ColorId,IndexedVertex,NormalId,PolygonGroup,PolygonList,PositionId,RenderConfigId,TextureCoordinateId,VertexId}};
 
+#[allow(dead_code)]
 #[derive(Debug)]
 pub enum Error{
 	Planar64Vec3(strafesnet_common::integer::Planar64TryFromFloatError),
@@ -83,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()))
 	))
 }
@@ -204,7 +205,13 @@ pub fn convert(roblox_mesh_bytes:crate::data::RobloxMeshBytes)->Result<model::Me
 		unique_vertices,
 		polygon_groups,
 		//these should probably be moved to the model...
-		graphics_groups:Vec::new(),
+		//but what if models want to use the same texture
+		graphics_groups:vec![model::IndexedGraphicsGroup{
+			render:RenderConfigId::new(0),
+			//the lowest lod is highest quality
+			groups:vec![model::PolygonGroupId::new(0)]
+		}],
+		//disable physics
 		physics_groups:Vec::new(),
 	})
 }

lib/rbx_loader/src/primitives.rs

@@ -1,4 +1,4 @@
-use strafesnet_common::model::{Color4,TextureCoordinate,Mesh,IndexedGraphicsGroup,IndexedPhysicsGroup,IndexedVertex,PolygonGroupId,PolygonGroup,PolygonList,IndexedVertexList,PositionId,TextureCoordinateId,NormalId,ColorId,VertexId,RenderConfigId};
+use strafesnet_common::model::{Color4,TextureCoordinate,Mesh,IndexedGraphicsGroup,IndexedPhysicsGroup,IndexedVertex,PolygonGroupId,PolygonGroup,PolygonList,PositionId,TextureCoordinateId,NormalId,ColorId,VertexId,RenderConfigId};
 use strafesnet_common::integer::{vec3,Planar64Vec3};
 
 #[derive(Debug)]
@@ -42,50 +42,6 @@ const CUBE_DEFAULT_NORMALS:[Planar64Vec3;6]=[
 	vec3::int( 0,-1, 0),//CubeFace::Bottom
 	vec3::int( 0, 0,-1),//CubeFace::Front
 ];
-const CUBE_DEFAULT_POLYS:[[[u32;3];4];6]=[
-	// right (1, 0, 0)
-	[
-		[6,2,0],//[vertex,tex,norm]
-		[5,1,0],
-		[2,0,0],
-		[1,3,0],
-	],
-	// top (0, 1, 0)
-	[
-		[5,3,1],
-		[4,2,1],
-		[3,1,1],
-		[2,0,1],
-	],
-	// back (0, 0, 1)
-	[
-		[0,3,2],
-		[1,2,2],
-		[2,1,2],
-		[3,0,2],
-	],
-	// left (-1, 0, 0)
-	[
-		[0,2,3],
-		[3,1,3],
-		[4,0,3],
-		[7,3,3],
-	],
-	// bottom (0,-1, 0)
-	[
-		[1,1,4],
-		[0,0,4],
-		[7,3,4],
-		[6,2,4],
-	],
-	// front (0, 0,-1)
-	[
-		[4,1,5],
-		[5,0,5],
-		[6,3,5],
-		[7,2,5],
-	],
-];
 
 #[derive(Hash,PartialEq,Eq)]
 pub enum WedgeFace{
@@ -126,17 +82,14 @@ const CORNERWEDGE_DEFAULT_NORMALS:[Planar64Vec3;5]=[
 	vec3::int( 0,-1, 0),//CornerWedge::Bottom
 	vec3::int( 0, 0,-1),//CornerWedge::Front
 ];
-pub fn unit_sphere(render:RenderConfigId)->Mesh{
-	unit_cube(render)
-}
 #[derive(Default)]
 pub struct CubeFaceDescription([Option<FaceDescription>;6]);
 impl CubeFaceDescription{
 	pub fn insert(&mut self,index:CubeFace,value:FaceDescription){
 		self.0[index as usize]=Some(value);
 	}
-	pub fn pairs(self)->std::iter::FilterMap<std::iter::Enumerate<std::array::IntoIter<Option<FaceDescription>,6>>,impl FnMut((usize,Option<FaceDescription>))->Option<(usize,FaceDescription)>>{
-		self.0.into_iter().enumerate().filter_map(|v|v.1.map(|u|(v.0,u)))
+	pub fn pairs(self)->impl Iterator<Item=(usize,FaceDescription)>{
+		self.0.into_iter().enumerate().filter_map(|(i,v)|v.map(|u|(i,u)))
 	}
 }
 pub fn unit_cube(render:RenderConfigId)->Mesh{
@@ -149,10 +102,6 @@ pub fn unit_cube(render:RenderConfigId)->Mesh{
 	t.insert(CubeFace::Front,FaceDescription::new_with_render_id(render));
 	generate_partial_unit_cube(t)
 }
-pub fn unit_cylinder(render:RenderConfigId)->Mesh{
-	//lmao
-	unit_cube(render)
-}
 #[derive(Default)]
 pub struct WedgeFaceDescription([Option<FaceDescription>;5]);
 impl WedgeFaceDescription{
@@ -163,15 +112,15 @@ impl WedgeFaceDescription{
 		self.0.into_iter().enumerate().filter_map(|v|v.1.map(|u|(v.0,u)))
 	}
 }
-pub fn unit_wedge(render:RenderConfigId)->Mesh{
-	let mut t=WedgeFaceDescription::default();
-	t.insert(WedgeFace::Right,FaceDescription::new_with_render_id(render));
-	t.insert(WedgeFace::TopFront,FaceDescription::new_with_render_id(render));
-	t.insert(WedgeFace::Back,FaceDescription::new_with_render_id(render));
-	t.insert(WedgeFace::Left,FaceDescription::new_with_render_id(render));
-	t.insert(WedgeFace::Bottom,FaceDescription::new_with_render_id(render));
-	generate_partial_unit_wedge(t)
-}
+// pub fn unit_wedge(render:RenderConfigId)->Mesh{
+// 	let mut t=WedgeFaceDescription::default();
+// 	t.insert(WedgeFace::Right,FaceDescription::new_with_render_id(render));
+// 	t.insert(WedgeFace::TopFront,FaceDescription::new_with_render_id(render));
+// 	t.insert(WedgeFace::Back,FaceDescription::new_with_render_id(render));
+// 	t.insert(WedgeFace::Left,FaceDescription::new_with_render_id(render));
+// 	t.insert(WedgeFace::Bottom,FaceDescription::new_with_render_id(render));
+// 	generate_partial_unit_wedge(t)
+// }
 #[derive(Default)]
 pub struct CornerWedgeFaceDescription([Option<FaceDescription>;5]);
 impl CornerWedgeFaceDescription{
@@ -182,15 +131,15 @@ impl CornerWedgeFaceDescription{
 		self.0.into_iter().enumerate().filter_map(|v|v.1.map(|u|(v.0,u)))
 	}
 }
-pub fn unit_cornerwedge(render:RenderConfigId)->Mesh{
-	let mut t=CornerWedgeFaceDescription::default();
-	t.insert(CornerWedgeFace::Right,FaceDescription::new_with_render_id(render));
-	t.insert(CornerWedgeFace::TopBack,FaceDescription::new_with_render_id(render));
-	t.insert(CornerWedgeFace::TopLeft,FaceDescription::new_with_render_id(render));
-	t.insert(CornerWedgeFace::Bottom,FaceDescription::new_with_render_id(render));
-	t.insert(CornerWedgeFace::Front,FaceDescription::new_with_render_id(render));
-	generate_partial_unit_cornerwedge(t)
-}
+// pub fn unit_cornerwedge(render:RenderConfigId)->Mesh{
+// 	let mut t=CornerWedgeFaceDescription::default();
+// 	t.insert(CornerWedgeFace::Right,FaceDescription::new_with_render_id(render));
+// 	t.insert(CornerWedgeFace::TopBack,FaceDescription::new_with_render_id(render));
+// 	t.insert(CornerWedgeFace::TopLeft,FaceDescription::new_with_render_id(render));
+// 	t.insert(CornerWedgeFace::Bottom,FaceDescription::new_with_render_id(render));
+// 	t.insert(CornerWedgeFace::Front,FaceDescription::new_with_render_id(render));
+// 	generate_partial_unit_cornerwedge(t)
+// }
 
 #[derive(Clone)]
 pub struct FaceDescription{
@@ -208,6 +157,50 @@ impl FaceDescription{
 	}
 }
 pub fn generate_partial_unit_cube(face_descriptions:CubeFaceDescription)->Mesh{
+	const CUBE_DEFAULT_POLYS:[[[u32;3];4];6]=[
+		// right (1, 0, 0)
+		[
+			[6,2,0],//[vertex,tex,norm]
+			[5,1,0],
+			[2,0,0],
+			[1,3,0],
+		],
+		// top (0, 1, 0)
+		[
+			[5,3,1],
+			[4,2,1],
+			[3,1,1],
+			[2,0,1],
+		],
+		// back (0, 0, 1)
+		[
+			[0,3,2],
+			[1,2,2],
+			[2,1,2],
+			[3,0,2],
+		],
+		// left (-1, 0, 0)
+		[
+			[0,2,3],
+			[3,1,3],
+			[4,0,3],
+			[7,3,3],
+		],
+		// bottom (0,-1, 0)
+		[
+			[1,1,4],
+			[0,0,4],
+			[7,3,4],
+			[6,2,4],
+		],
+		// front (0, 0,-1)
+		[
+			[4,1,5],
+			[5,0,5],
+			[6,3,5],
+			[7,2,5],
+		],
+	];
 	let mut generated_pos=Vec::new();
 	let mut generated_tex=Vec::new();
 	let mut generated_normal=Vec::new();
@@ -286,35 +279,35 @@ pub fn generate_partial_unit_cube(face_descriptions:CubeFaceDescription)->Mesh{
 }
 //don't think too hard about the copy paste because this is all going into the map tool eventually...
 pub fn generate_partial_unit_wedge(face_descriptions:WedgeFaceDescription)->Mesh{
-	let wedge_default_polys=[
+	const WEDGE_DEFAULT_POLYS:[&[[u32;3]];5]=[
 		// right (1, 0, 0)
-		vec![
+		&[
 			[6,2,0],//[vertex,tex,norm]
 			[2,0,0],
 			[1,3,0],
 		],
 		// FrontTop (0, 1, -1)
-		vec![
+		&[
 			[3,1,1],
 			[2,0,1],
 			[6,3,1],
 			[7,2,1],
 		],
 		// back (0, 0, 1)
-		vec![
+		&[
 			[0,3,2],
 			[1,2,2],
 			[2,1,2],
 			[3,0,2],
 		],
 		// left (-1, 0, 0)
-		vec![
+		&[
 			[0,2,3],
 			[3,1,3],
 			[7,3,3],
 		],
 		// bottom (0,-1, 0)
-		vec![
+		&[
 			[1,1,4],
 			[0,0,4],
 			[7,3,4],
@@ -358,7 +351,7 @@ pub fn generate_partial_unit_wedge(face_descriptions:WedgeFaceDescription)->Mesh
 		//push vertices as they are needed
 		let group_id=PolygonGroupId::new(polygon_groups.len() as u32);
 		polygon_groups.push(PolygonGroup::PolygonList(PolygonList::new(vec![
-			wedge_default_polys[face_id].iter().map(|tup|{
+			WEDGE_DEFAULT_POLYS[face_id].iter().map(|tup|{
 				let pos=CUBE_DEFAULT_VERTICES[tup[0] as usize];
 				let pos_index=if let Some(pos_index)=generated_pos.iter().position(|&p|p==pos){
 					pos_index
@@ -399,34 +392,34 @@ pub fn generate_partial_unit_wedge(face_descriptions:WedgeFaceDescription)->Mesh
 }
 
 pub fn generate_partial_unit_cornerwedge(face_descriptions:CornerWedgeFaceDescription)->Mesh{
-	let cornerwedge_default_polys=[
+	const CORNERWEDGE_DEFAULT_POLYS:[&[[u32;3]];5]=[
 		// right (1, 0, 0)
-		vec![
+		&[
 			[6,2,0],//[vertex,tex,norm]
 			[5,1,0],
 			[1,3,0],
 		],
 		// BackTop (0, 1, 1)
-		vec![
+		&[
 			[5,3,1],
 			[0,1,1],
 			[1,0,1],
 		],
 		// LeftTop (-1, 1, 0)
-		vec![
+		&[
 			[5,3,2],
 			[7,2,2],
 			[0,1,2],
 		],
 		// bottom (0,-1, 0)
-		vec![
+		&[
 			[1,1,3],
 			[0,0,3],
 			[7,3,3],
 			[6,2,3],
 		],
 		// front (0, 0,-1)
-		vec![
+		&[
 			[5,0,4],
 			[6,3,4],
 			[7,2,4],
@@ -469,7 +462,7 @@ pub fn generate_partial_unit_cornerwedge(face_descriptions:CornerWedgeFaceDescri
 		//push vertices as they are needed
 		let group_id=PolygonGroupId::new(polygon_groups.len() as u32);
 		polygon_groups.push(PolygonGroup::PolygonList(PolygonList::new(vec![
-			cornerwedge_default_polys[face_id].iter().map(|tup|{
+			CORNERWEDGE_DEFAULT_POLYS[face_id].iter().map(|tup|{
 				let pos=CUBE_DEFAULT_VERTICES[tup[0] as usize];
 				let pos_index=if let Some(pos_index)=generated_pos.iter().position(|&p|p==pos){
 					pos_index

lib/rbx_loader/src/rbx.rs

@@ -1,13 +1,17 @@
 use std::collections::HashMap;
+use crate::loader::MeshIndex;
 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};
 
 fn class_is_a(class: &str, superclass: &str) -> bool {
 	if class==superclass {
@@ -47,93 +51,7 @@ fn planar64_affine3_from_roblox(cf:&rbx_dom_weak::types::CFrame,size:&rbx_dom_we
 		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();
@@ -162,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
 				)
@@ -173,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,
 				),
 			);
 		},
@@ -184,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
 				),
 			);
 		},
@@ -208,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
 							)
@@ -226,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:
@@ -239,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,
 					),
@@ -267,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())
 							)
 						),
@@ -291,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"),
 						},
 					),
@@ -307,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"),
 			// 	}
@@ -341,58 +259,103 @@ fn get_attributes(name:&str,can_collide:bool,velocity:Planar64Vec3,model_id:mode
 	}
 }
 
-#[derive(Clone,Copy,PartialEq)]
-struct RobloxTextureTransform{
-	offset_u:f32,
-	offset_v:f32,
-	scale_u:f32,
-	scale_v:f32,
+#[derive(Clone,Copy)]
+pub struct RobloxTextureTransform{
+	offset_studs_u:f32,
+	offset_studs_v:f32,
+	studs_per_tile_u:f32,
+	studs_per_tile_v:f32,
+	size_u:f32,
+	size_v:f32,
 }
-impl std::cmp::Eq for RobloxTextureTransform{}//????
-impl std::default::Default for RobloxTextureTransform{
-    fn default()->Self{
-        Self{offset_u:0.0,offset_v:0.0,scale_u:1.0,scale_v:1.0}
-    }
+#[derive(Clone,Copy,Hash,Eq,PartialEq)]
+pub struct RobloxTextureTransformBits{
+	offset_studs_u:u32,
+	offset_studs_v:u32,
+	studs_per_tile_u:u32,
+	studs_per_tile_v:u32,
+	size_u:u32,
+	size_v:u32,
 }
-impl std::hash::Hash for RobloxTextureTransform{
-	fn hash<H:std::hash::Hasher>(&self,state:&mut H) {
-		self.offset_u.to_ne_bytes().hash(state);
-		self.offset_v.to_ne_bytes().hash(state);
-		self.scale_u.to_ne_bytes().hash(state);
-		self.scale_v.to_ne_bytes().hash(state);
+impl RobloxTextureTransform{
+	fn identity()->Self{
+		Self{
+			offset_studs_u:0.0,
+			offset_studs_v:0.0,
+			studs_per_tile_u:1.0,
+			studs_per_tile_v:1.0,
+			size_u:1.0,
+			size_v:1.0,
+		}
+	}
+	pub fn to_bits(self)->RobloxTextureTransformBits{
+		RobloxTextureTransformBits{
+			offset_studs_u:self.offset_studs_u.to_bits(),
+			offset_studs_v:self.offset_studs_v.to_bits(),
+			studs_per_tile_u:self.studs_per_tile_u.to_bits(),
+			studs_per_tile_v:self.studs_per_tile_v.to_bits(),
+			size_u:self.size_u.to_bits(),
+			size_v:self.size_v.to_bits(),
+		}
+	}
+	pub fn affine(&self)->glam::Affine2{
+		glam::Affine2::from_translation(
+			glam::vec2(self.offset_studs_u/self.studs_per_tile_u,self.offset_studs_v/self.studs_per_tile_v)
+		)
+		*glam::Affine2::from_scale(
+			glam::vec2(self.size_u/self.studs_per_tile_u,self.size_v/self.studs_per_tile_v)
+		)
+	}
+	pub fn set_size(&mut self,size_u:f32,size_v:f32){
+		self.size_u=size_u;
+		self.size_v=size_v;
 	}
 }
-#[derive(Clone,PartialEq)]
-struct RobloxFaceTextureDescription{
-	render:RenderConfigId,
-	color:glam::Vec4,
-	transform:RobloxTextureTransform,
+impl core::hash::Hash for RobloxTextureTransform{
+	fn hash<H:core::hash::Hasher>(&self,state:&mut H){
+		self.to_bits().hash(state);
+	}
 }
-impl std::cmp::Eq for RobloxFaceTextureDescription{}//????
-impl std::hash::Hash for RobloxFaceTextureDescription{
-	fn hash<H:std::hash::Hasher>(&self,state:&mut H){
-		self.render.hash(state);
-		self.transform.hash(state);
-        for &el in self.color.as_ref().iter(){
-            el.to_ne_bytes().hash(state);
-        }
-    }
+#[derive(Clone,Copy,Hash,Eq,PartialEq)]
+pub struct RobloxFaceTextureDescriptionBits{
+	render:RenderConfigId,
+	color:[u32;4],
+	transform:RobloxTextureTransformBits,
+}
+#[derive(Clone,Copy)]
+pub struct RobloxFaceTextureDescription{
+	pub render:RenderConfigId,
+	pub color:glam::Vec4,
+	pub transform:RobloxTextureTransform,
+}
+impl core::cmp::PartialEq for RobloxFaceTextureDescription{
+	fn eq(&self,other:&Self)->bool{
+		self.to_bits().eq(&other.to_bits())
+	}
+}
+impl core::cmp::Eq for RobloxFaceTextureDescription{}
+impl core::hash::Hash for RobloxFaceTextureDescription{
+	fn hash<H:core::hash::Hasher>(&self,state:&mut H){
+		self.to_bits().hash(state);
+	}
 }
 impl RobloxFaceTextureDescription{
-	fn to_face_description(&self)->primitives::FaceDescription{
+	pub fn to_bits(self)->RobloxFaceTextureDescriptionBits{
+		RobloxFaceTextureDescriptionBits{
+			render:self.render,
+			color:self.color.to_array().map(f32::to_bits),
+			transform:self.transform.to_bits(),
+		}
+	}
+	pub fn to_face_description(&self)->primitives::FaceDescription{
 		primitives::FaceDescription{
 			render:self.render,
-			transform:glam::Affine2::from_translation(
-				glam::vec2(self.transform.offset_u,self.transform.offset_v)
-			)
-			*glam::Affine2::from_scale(
-				glam::vec2(self.transform.scale_u,self.transform.scale_v)
-			),
+			transform:self.transform.affine(),
 			color:self.color,
 		}
 	}
 }
-type RobloxPartDescription=[Option<RobloxFaceTextureDescription>;6];
+pub type RobloxPartDescription=[Option<RobloxFaceTextureDescription>;6];
 type RobloxWedgeDescription=[Option<RobloxFaceTextureDescription>;5];
 type RobloxCornerWedgeDescription=[Option<RobloxFaceTextureDescription>;5];
 #[derive(Clone,Eq,Hash,PartialEq)]
@@ -403,52 +366,134 @@ enum RobloxBasePartDescription{
 	Wedge(RobloxWedgeDescription),
 	CornerWedge(RobloxCornerWedgeDescription),
 }
+fn get_texture_description<'a>(
+	temp_objects:&mut Vec<rbx_dom_weak::types::Ref>,
+	render_config_deferred_loader:&mut RenderConfigDeferredLoader<&'a str>,
+	dom:&'a rbx_dom_weak::WeakDom,
+	object:&rbx_dom_weak::Instance,
+	size:&rbx_dom_weak::types::Vector3,
+)->RobloxPartDescription{
+	//use the biggest one and cut it down later...
+	let mut part_texture_description:RobloxPartDescription=[None,None,None,None,None,None];
+	temp_objects.clear();
+	recursive_collect_superclass(temp_objects,&dom,object,"Decal");
+	for &mut decal_ref in temp_objects{
+	if let Some(decal)=dom.get_by_ref(decal_ref){
+		if let (
+			Some(rbx_dom_weak::types::Variant::Content(content)),
+			Some(rbx_dom_weak::types::Variant::Enum(normalid)),
+			Some(rbx_dom_weak::types::Variant::Color3(decal_color3)),
+			Some(rbx_dom_weak::types::Variant::Float32(decal_transparency)),
+		) = (
+			decal.properties.get("Texture"),
+			decal.properties.get("Face"),
+			decal.properties.get("Color3"),
+			decal.properties.get("Transparency"),
+		) {
+			let render_id=render_config_deferred_loader.acquire_render_config_id(Some(content.as_ref()));
+				let normal_id=normalid.to_u32();
+				if normal_id<6{
+					let (roblox_texture_color,roblox_texture_transform)=if decal.class=="Texture"{
+						//generate tranform
+						if let (
+								Some(&rbx_dom_weak::types::Variant::Float32(offset_studs_u)),
+								Some(&rbx_dom_weak::types::Variant::Float32(offset_studs_v)),
+								Some(&rbx_dom_weak::types::Variant::Float32(studs_per_tile_u)),
+								Some(&rbx_dom_weak::types::Variant::Float32(studs_per_tile_v)),
+							) = (
+								decal.properties.get("OffsetStudsU"),
+								decal.properties.get("OffsetStudsV"),
+								decal.properties.get("StudsPerTileU"),
+								decal.properties.get("StudsPerTileV"),
+							)
+						{
+							let (size_u,size_v)=match normal_id{
+								0=>(size.z,size.y),//right
+								1=>(size.x,size.z),//top
+								2=>(size.x,size.y),//back
+								3=>(size.z,size.y),//left
+								4=>(size.x,size.z),//bottom
+								5=>(size.x,size.y),//front
+								_=>unreachable!(),
+							};
+							(
+								glam::vec4(decal_color3.r,decal_color3.g,decal_color3.b,1.0-*decal_transparency),
+								RobloxTextureTransform{
+									offset_studs_u,
+									offset_studs_v,
+									studs_per_tile_u,
+									studs_per_tile_v,
+									size_u,
+									size_v,
+								}
+							)
+						}else{
+							(glam::Vec4::ONE,RobloxTextureTransform::identity())
+						}
+					}else{
+						(glam::Vec4::ONE,RobloxTextureTransform::identity())
+					};
+					part_texture_description[normal_id as usize]=Some(RobloxFaceTextureDescription{
+						render:render_id,
+						color:roblox_texture_color,
+						transform:roblox_texture_transform,
+					});
+				}else{
+					println!("NormalId={} is invalid",normal_id);
+				}
+			}
+		}
+	}
+	part_texture_description
+}
 enum Shape{
 	Primitive(primitives::Primitives),
 	MeshPart,
+	PhysicsData,
 }
 enum MeshAvailability{
 	Immediate,
-	Deferred(RenderConfigId),
+	DeferredMesh(RenderConfigId),
+	DeferredUnion(RobloxPartDescription),
 }
-struct DeferredModelDeferredAttributes{
+struct DeferredModelDeferredAttributes<'a>{
 	render:RenderConfigId,
-	model:ModelDeferredAttributes,
+	model:ModelDeferredAttributes<'a>,
 }
-struct ModelDeferredAttributes{
+struct ModelDeferredAttributes<'a>{
 	mesh:model::MeshId,
-	deferred_attributes:GetAttributesArgs,
+	deferred_attributes:GetAttributesArgs<'a>,
 	color:model::Color4,//transparency is in here
 	transform:Planar64Affine3,
 }
+struct DeferredUnionDeferredAttributes<'a>{
+	render:RobloxPartDescription,
+	model:ModelDeferredAttributes<'a>,
+}
 struct ModelOwnedAttributes{
 	mesh:model::MeshId,
 	attributes:attr::CollisionAttributes,
 	color:model::Color4,//transparency is in here
 	transform:Planar64Affine3,
 }
-struct GetAttributesArgs{
-	name:Box<str>,
+struct GetAttributesArgs<'a>{
+	name:&'a str,
 	can_collide:bool,
 	velocity:Planar64Vec3,
 }
-pub fn convert<AcquireRenderConfigId,AcquireMeshId>(
-	dom:&rbx_dom_weak::WeakDom,
-	mut acquire_render_config_id:AcquireRenderConfigId,
-	mut acquire_mesh_id:AcquireMeshId,
-)->PartialMap1
-where
-	AcquireRenderConfigId:FnMut(Option<&str>)->model::RenderConfigId,
-	AcquireMeshId:FnMut(&str)->model::MeshId,
-{
-
+pub fn convert<'a>(
+	dom:&'a rbx_dom_weak::WeakDom,
+	render_config_deferred_loader:&mut RenderConfigDeferredLoader<&'a str>,
+	mesh_deferred_loader:&mut MeshDeferredLoader<MeshIndex<'a>>,
+)->PartialMap1<'a>{
 	let mut deferred_models_deferred_attributes=Vec::new();
+	let mut deferred_unions_deferred_attributes=Vec::new();
 	let mut primitive_models_deferred_attributes=Vec::new();
 	let mut primitive_meshes=Vec::new();
 	let mut mesh_id_from_description=HashMap::new();
 
 	//just going to leave it like this for now instead of reworking the data structures for this whole thing
-	let textureless_render_group=acquire_render_config_id(None);
+	let textureless_render_group=render_config_deferred_loader.acquire_render_config_id(None);
 
 	let mut object_refs=Vec::new();
 	let mut temp_objects=Vec::new();
@@ -485,9 +530,6 @@ where
 					continue;
 				}
 
-				//at this point a new model is going to be generated for sure.
-				let model_id=model::ModelId::new(primitive_models_deferred_attributes.len() as u32);
-
 				//TODO: also detect "CylinderMesh" etc here
 				let shape=match object.class.as_str(){
 					"Part"=>if let Some(rbx_dom_weak::types::Variant::Enum(shape))=object.properties.get("Shape"){
@@ -506,6 +548,7 @@ where
 					"WedgePart"=>Shape::Primitive(primitives::Primitives::Wedge),
 					"CornerWedgePart"=>Shape::Primitive(primitives::Primitives::CornerWedge),
 					"MeshPart"=>Shape::MeshPart,
+					"UnionOperation"=>Shape::PhysicsData,
 					_=>{
 						println!("Unsupported BasePart ClassName={}; defaulting to cube",object.class);
 						Shape::Primitive(primitives::Primitives::Cube)
@@ -514,74 +557,8 @@ where
 
 				let (availability,mesh_id)=match shape{
 					Shape::Primitive(primitive_shape)=>{
-						//TODO: TAB TAB
-				//use the biggest one and cut it down later...
-				let mut part_texture_description:RobloxPartDescription=[None,None,None,None,None,None];
-				temp_objects.clear();
-				recursive_collect_superclass(&mut temp_objects, &dom, object,"Decal");
-				for &decal_ref in &temp_objects{
-					if let Some(decal)=dom.get_by_ref(decal_ref){
-						if let (
-							Some(rbx_dom_weak::types::Variant::Content(content)),
-							Some(rbx_dom_weak::types::Variant::Enum(normalid)),
-							Some(rbx_dom_weak::types::Variant::Color3(decal_color3)),
-							Some(rbx_dom_weak::types::Variant::Float32(decal_transparency)),
-						) = (
-							decal.properties.get("Texture"),
-							decal.properties.get("Face"),
-							decal.properties.get("Color3"),
-							decal.properties.get("Transparency"),
-						) {
-							let render_id=acquire_render_config_id(Some(content.as_ref()));
-								let normal_id=normalid.to_u32();
-								if normal_id<6{
-									let (roblox_texture_color,roblox_texture_transform)=if decal.class=="Texture"{
-										//generate tranform
-										if let (
-												Some(rbx_dom_weak::types::Variant::Float32(ox)),
-												Some(rbx_dom_weak::types::Variant::Float32(oy)),
-												Some(rbx_dom_weak::types::Variant::Float32(sx)),
-												Some(rbx_dom_weak::types::Variant::Float32(sy)),
-											) = (
-												decal.properties.get("OffsetStudsU"),
-												decal.properties.get("OffsetStudsV"),
-												decal.properties.get("StudsPerTileU"),
-												decal.properties.get("StudsPerTileV"),
-											)
-										{
-											let (size_u,size_v)=match normal_id{
-												0=>(size.z,size.y),//right
-												1=>(size.x,size.z),//top
-												2=>(size.x,size.y),//back
-												3=>(size.z,size.y),//left
-												4=>(size.x,size.z),//bottom
-												5=>(size.x,size.y),//front
-												_=>unreachable!(),
-											};
-											(
-												glam::vec4(decal_color3.r,decal_color3.g,decal_color3.b,1.0-*decal_transparency),
-												RobloxTextureTransform{
-													offset_u:*ox/(*sx),offset_v:*oy/(*sy),
-													scale_u:size_u/(*sx),scale_v:size_v/(*sy),
-												}
-											)
-										}else{
-											(glam::Vec4::ONE,RobloxTextureTransform::default())
-										}
-									}else{
-										(glam::Vec4::ONE,RobloxTextureTransform::default())
-									};
-									part_texture_description[normal_id as usize]=Some(RobloxFaceTextureDescription{
-										render:render_id,
-										color:roblox_texture_color,
-										transform:roblox_texture_transform,
-									});
-								}else{
-									println!("NormalId={} unsupported for shape={:?}",normal_id,primitive_shape);
-								}
-						}
-					}
-				}
+				//TODO: TAB TAB
+				let part_texture_description=get_texture_description(&mut temp_objects,render_config_deferred_loader,dom,object,size);
 				//obscure rust syntax "slice pattern"
 				let [
 					f0,//Cube::Right
@@ -598,7 +575,7 @@ where
 					//use front face texture first and use top face texture as a fallback
 					primitives::Primitives::Wedge=>RobloxBasePartDescription::Wedge([
 						f0,//Cube::Right->Wedge::Right
-						if f5.is_some(){f5}else{f1},//Cube::Front|Cube::Top->Wedge::TopFront
+						f5.or(f1),//Cube::Front|Cube::Top->Wedge::TopFront
 						f2,//Cube::Back->Wedge::Back
 						f3,//Cube::Left->Wedge::Left
 						f4,//Cube::Bottom->Wedge::Bottom
@@ -606,8 +583,8 @@ where
 					//TODO: fix Left+Back texture coordinates to match roblox when not overwridden by Top
 					primitives::Primitives::CornerWedge=>RobloxBasePartDescription::CornerWedge([
 						f0,//Cube::Right->CornerWedge::Right
-						if f2.is_some(){f2}else{f1.clone()},//Cube::Back|Cube::Top->CornerWedge::TopBack
-						if f3.is_some(){f3}else{f1},//Cube::Left|Cube::Top->CornerWedge::TopLeft
+						f2.or(f1.clone()),//Cube::Back|Cube::Top->CornerWedge::TopBack
+						f3.or(f1),//Cube::Left|Cube::Top->CornerWedge::TopLeft
 						f4,//Cube::Bottom->CornerWedge::Bottom
 						f5,//Cube::Front->CornerWedge::Front
 					]),
@@ -694,29 +671,51 @@ where
 						object.properties.get("TextureID"),
 					){
 						(
-							MeshAvailability::Deferred(acquire_render_config_id(Some(texture_asset_id.as_ref()))),
-							acquire_mesh_id(mesh_asset_id.as_ref()),
+							MeshAvailability::DeferredMesh(render_config_deferred_loader.acquire_render_config_id(Some(texture_asset_id.as_ref()))),
+							mesh_deferred_loader.acquire_mesh_id(MeshIndex::file_mesh(mesh_asset_id.as_ref())),
 						)
 					}else{
 						panic!("Mesh has no Mesh or Texture");
 					},
+					Shape::PhysicsData=>{
+						let mut content="";
+						let mut mesh_data:&[u8]=&[];
+						let mut physics_data:&[u8]=&[];
+						if let Some(rbx_dom_weak::types::Variant::Content(asset_id))=object.properties.get("AssetId"){
+							content=asset_id.as_ref();
+						}
+						if let Some(rbx_dom_weak::types::Variant::BinaryString(data))=object.properties.get("MeshData"){
+							mesh_data=data.as_ref();
+						}
+						if let Some(rbx_dom_weak::types::Variant::BinaryString(data))=object.properties.get("PhysicsData"){
+							physics_data=data.as_ref();
+						}
+						let part_texture_description=get_texture_description(&mut temp_objects,render_config_deferred_loader,dom,object,size);
+						let mesh_index=MeshIndex::union(content,mesh_data,physics_data,size,part_texture_description.clone());
+						let mesh_id=mesh_deferred_loader.acquire_mesh_id(mesh_index);
+						(MeshAvailability::DeferredUnion(part_texture_description),mesh_id)
+					},
 				};
 				let model_deferred_attributes=ModelDeferredAttributes{
 					mesh:mesh_id,
 					transform:model_transform,
 					color:glam::vec4(color3.r as f32/255f32, color3.g as f32/255f32, color3.b as f32/255f32, 1.0-*transparency),
 					deferred_attributes:GetAttributesArgs{
-						name:object.name.as_str().into(),
+						name:object.name.as_str(),
 						can_collide:*can_collide,
 						velocity:vec3::try_from_f32_array([velocity.x,velocity.y,velocity.z]).unwrap(),
 					},
 				};
 				match availability{
 					MeshAvailability::Immediate=>primitive_models_deferred_attributes.push(model_deferred_attributes),
-					MeshAvailability::Deferred(render)=>deferred_models_deferred_attributes.push(DeferredModelDeferredAttributes{
+					MeshAvailability::DeferredMesh(render)=>deferred_models_deferred_attributes.push(DeferredModelDeferredAttributes{
 						render,
 						model:model_deferred_attributes
 					}),
+					MeshAvailability::DeferredUnion(part_texture_description)=>deferred_unions_deferred_attributes.push(DeferredUnionDeferredAttributes{
+						render:part_texture_description,
+						model:model_deferred_attributes,
+					}),
 				}
 			}
 		}
@@ -725,21 +724,71 @@ where
 		primitive_meshes,
 		primitive_models_deferred_attributes,
 		deferred_models_deferred_attributes,
+		deferred_unions_deferred_attributes,
 	}
 }
 struct MeshWithAabb{
 	mesh:model::Mesh,
-	aabb:strafesnet_common::aabb::Aabb,
+	aabb:Aabb,
 }
-pub struct PartialMap1{
+fn acquire_mesh_id_from_render_config_id<'a>(
+	primitive_meshes:&mut Vec<model::Mesh>,
+	mesh_id_from_render_config_id:&mut HashMap<model::MeshId,HashMap<RenderConfigId,model::MeshId>>,
+	loaded_meshes:&'a HashMap<model::MeshId,MeshWithAabb>,
+	old_mesh_id:model::MeshId,
+	render:RenderConfigId,
+)->Option<(model::MeshId,&'a Aabb)>{
+	//ignore meshes that fail to load completely for now
+	loaded_meshes.get(&old_mesh_id).map(|mesh_with_aabb|(
+		*mesh_id_from_render_config_id.entry(old_mesh_id).or_insert_with(||HashMap::new())
+		.entry(render).or_insert_with(||{
+			let mesh_id=model::MeshId::new(primitive_meshes.len() as u32);
+			let mut mesh_clone=mesh_with_aabb.mesh.clone();
+			//set the render group lool
+			if let Some(graphics_group)=mesh_clone.graphics_groups.first_mut(){
+				graphics_group.render=render;
+			}
+			primitive_meshes.push(mesh_clone);
+			mesh_id
+		}),
+		&mesh_with_aabb.aabb,
+	))
+}
+fn acquire_union_id_from_render_config_id<'a>(
+	primitive_meshes:&mut Vec<model::Mesh>,
+	union_id_from_render_config_id:&mut HashMap<model::MeshId,HashMap<RobloxPartDescription,model::MeshId>>,
+	loaded_meshes:&'a HashMap<model::MeshId,MeshWithAabb>,
+	old_union_id:model::MeshId,
+	part_texture_description:RobloxPartDescription,
+)->Option<(model::MeshId,&'a Aabb)>{
+	//ignore uniones that fail to load completely for now
+	loaded_meshes.get(&old_union_id).map(|union_with_aabb|(
+		*union_id_from_render_config_id.entry(old_union_id).or_insert_with(||HashMap::new())
+		.entry(part_texture_description.clone()).or_insert_with(||{
+			let union_id=model::MeshId::new(primitive_meshes.len() as u32);
+			let mut union_clone=union_with_aabb.mesh.clone();
+			//set the render groups
+			for (graphics_group,maybe_face_texture_description) in union_clone.graphics_groups.iter_mut().zip(part_texture_description){
+				if let Some(face_texture_description)=maybe_face_texture_description{
+					graphics_group.render=face_texture_description.render;
+				}
+			}
+			primitive_meshes.push(union_clone);
+			union_id
+		}),
+		&union_with_aabb.aabb,
+	))
+}
+pub struct PartialMap1<'a>{
 	primitive_meshes:Vec<model::Mesh>,
-	primitive_models_deferred_attributes:Vec<ModelDeferredAttributes>,
-	deferred_models_deferred_attributes:Vec<DeferredModelDeferredAttributes>,
+	primitive_models_deferred_attributes:Vec<ModelDeferredAttributes<'a>>,
+	deferred_models_deferred_attributes:Vec<DeferredModelDeferredAttributes<'a>>,
+	deferred_unions_deferred_attributes:Vec<DeferredUnionDeferredAttributes<'a>>,
 }
-impl PartialMap1{
+impl PartialMap1<'_>{
 	pub fn add_meshpart_meshes_and_calculate_attributes(
 		mut self,
-		meshpart_meshes:impl IntoIterator<Item=(model::MeshId,crate::data::RobloxMeshBytes)>,
+		meshpart_meshes:Meshes,
 	)->PartialMap2{
 		//calculate attributes
 		let mut modes_builder=ModesBuilder::default();
@@ -752,51 +801,32 @@ impl PartialMap1{
 		//decode roblox meshes
 		//generate mesh_id_map based on meshes that failed to load
 		let loaded_meshes:HashMap<model::MeshId,MeshWithAabb>=
-		meshpart_meshes.into_iter().flat_map(|(old_mesh_id,roblox_mesh_bytes)|
-			match crate::mesh::convert(roblox_mesh_bytes){
-				Ok(mesh)=>{
-					let mut aabb=strafesnet_common::aabb::Aabb::default();
-					for &pos in &mesh.unique_pos{
-						aabb.grow(pos);
-					}
-					Some((old_mesh_id,MeshWithAabb{
-						mesh,
-						aabb,
-					}))
-				},
-				Err(e)=>{
-					println!("Error converting mesh: {e:?}");
-					None
-				},
+		meshpart_meshes.consume().map(|(old_mesh_id,mesh)|{
+			let mut aabb=strafesnet_common::aabb::Aabb::default();
+			for &pos in &mesh.unique_pos{
+				aabb.grow(pos);
 			}
-		).collect();
+			(old_mesh_id,MeshWithAabb{
+				mesh,
+				aabb,
+			})
+		}).collect();
+
+		// SAFETY: I have no idea what I'm doing and this is definitely unsound in some subtle way
+		// I just want to chain iterators together man
+		let aint_no_way=core::cell::UnsafeCell::new(&mut self.primitive_meshes);
 
 		let mut mesh_id_from_render_config_id=HashMap::new();
-		//ignore meshes that fail to load completely for now
-		let mut acquire_mesh_id_from_render_config_id=|old_mesh_id,render|{
-			loaded_meshes.get(&old_mesh_id).map(|mesh_with_aabb|(
-				*mesh_id_from_render_config_id.entry(old_mesh_id).or_insert_with(||HashMap::new())
-				.entry(render).or_insert_with(||{
-					let mesh_id=model::MeshId::new(self.primitive_meshes.len() as u32);
-					let mut mesh_clone=mesh_with_aabb.mesh.clone();
-					//add a render group lool
-					mesh_clone.graphics_groups.push(model::IndexedGraphicsGroup{
-						render,
-						//the lowest lod is highest quality
-						groups:vec![model::PolygonGroupId::new(0)]
-					});
-					self.primitive_meshes.push(mesh_clone);
-					mesh_id
-				}),
-				&mesh_with_aabb.aabb,
-			))
-		};
+		let mut union_id_from_render_config_id=HashMap::new();
 		//now that the meshes are loaded, these models can be generated
 		let models_owned_attributes:Vec<ModelOwnedAttributes>=
 		self.deferred_models_deferred_attributes.into_iter().flat_map(|deferred_model_deferred_attributes|{
 			//meshes need to be cloned from loaded_meshes with a new id when they are used with a new render_id
 			//insert into primitive_meshes
 			let (mesh,aabb)=acquire_mesh_id_from_render_config_id(
+				unsafe{*aint_no_way.get()},
+				&mut mesh_id_from_render_config_id,
+				&loaded_meshes,
 				deferred_model_deferred_attributes.model.mesh,
 				deferred_model_deferred_attributes.render
 			)?;
@@ -814,7 +844,32 @@ impl PartialMap1{
 					deferred_model_deferred_attributes.model.transform.translation
 				),
 			})
-		}).chain(self.primitive_models_deferred_attributes.into_iter())
+		}).chain(self.deferred_unions_deferred_attributes.into_iter().flat_map(|deferred_union_deferred_attributes|{
+			//meshes need to be cloned from loaded_meshes with a new id when they are used with a new render_id
+			//insert into primitive_meshes
+			let (mesh,aabb)=acquire_union_id_from_render_config_id(
+				unsafe{*aint_no_way.get()},
+				&mut union_id_from_render_config_id,
+				&loaded_meshes,
+				deferred_union_deferred_attributes.model.mesh,
+				deferred_union_deferred_attributes.render
+			)?;
+			let size=aabb.size();
+			Some(ModelDeferredAttributes{
+				mesh,
+				deferred_attributes:deferred_union_deferred_attributes.model.deferred_attributes,
+				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.translation
+				),
+			})
+		}))
+		.chain(self.primitive_models_deferred_attributes.into_iter())
 		.enumerate().map(|(model_id,model_deferred_attributes)|{
 			let model_id=model::ModelId::new(model_id as u32);
 			ModelOwnedAttributes{
@@ -867,7 +922,7 @@ impl PartialMap1{
 	PartialMap2{
 		meshes:self.primitive_meshes,
 		models,
-		modes:modes_builder.build(),
+		modes:modes_builder.build_normalized(),
 		attributes:unique_attributes,
 	}
 	}
@@ -876,21 +931,27 @@ 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{
 	pub fn add_render_configs_and_textures(
 		self,
-		render_configs:impl IntoIterator<Item=(model::RenderConfigId,model::RenderConfig)>,
-		textures:impl IntoIterator<Item=(model::TextureId,Vec<u8>)>,
+		render_configs:RenderConfigs,
 	)->map::CompleteMap{
+		let (textures,render_configs)=render_configs.consume();
 		let (textures,texture_id_map):(Vec<Vec<u8>>,HashMap<model::TextureId,model::TextureId>)
-		=textures.into_iter().enumerate().map(|(new_texture_id,(old_texture_id,texture))|{
+		=textures.into_iter().enumerate().map(|(new_texture_id,(old_texture_id,Texture::ImageDDS(texture)))|{
 			(texture,(old_texture_id,model::TextureId::new(new_texture_id as u32)))
 		}).unzip();
-		let render_configs=render_configs.into_iter().map(|(render_config_id,mut render_config)|{
-			//this may generate duplicate no-texture render configs but idc
+		let render_configs=render_configs.into_iter().map(|(_render_config_id,mut render_config)|{
+			// This may generate duplicate no-texture render configs but idc
+			//
+			// This is because some textures may not exist, so the render config
+			// that it points to is unique but is texture.
+			//
+			// I don't think this needs to be fixed because missing textures
+			// should be a conversion error anyways.
 			render_config.texture=render_config.texture.and_then(|texture_id|
 				texture_id_map.get(&texture_id).copied()
 			);

lib/rbx_loader/src/union.rs

@@ -0,0 +1,177 @@
+use rbx_mesh::mesh_data::NormalId2 as MeshDataNormalId2;
+use strafesnet_common::model::{self,IndexedVertex,PolygonGroup,PolygonGroupId,PolygonList,RenderConfigId};
+use strafesnet_common::integer::vec3;
+
+#[allow(dead_code)]
+#[derive(Debug)]
+pub enum Error{
+	Block,
+	MissingVertexId(u32),
+	Planar64Vec3(strafesnet_common::integer::Planar64TryFromFloatError),
+	RobloxPhysicsData(rbx_mesh::physics_data::Error),
+	RobloxMeshData(rbx_mesh::mesh_data::Error),
+}
+impl std::fmt::Display for Error{
+	fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
+		write!(f,"{self:?}")
+	}
+}
+
+// wacky state machine to make sure all vertices in a face agree upon what NormalId to use.
+// Roblox duplicates this information per vertex when it should only exist per-face.
+enum MeshDataNormalStatus{
+	Agree(MeshDataNormalId2),
+	Conflicting,
+}
+struct MeshDataNormalChecker{
+	status:Option<MeshDataNormalStatus>,
+}
+impl MeshDataNormalChecker{
+	fn new()->Self{
+		Self{status:None}
+	}
+	fn check(&mut self,normal:MeshDataNormalId2){
+		self.status=match self.status.take(){
+			None=>Some(MeshDataNormalStatus::Agree(normal)),
+			Some(MeshDataNormalStatus::Agree(old_normal))=>{
+				if old_normal==normal{
+					Some(MeshDataNormalStatus::Agree(old_normal))
+				}else{
+					Some(MeshDataNormalStatus::Conflicting)
+				}
+			},
+			Some(MeshDataNormalStatus::Conflicting)=>Some(MeshDataNormalStatus::Conflicting),
+		};
+	}
+	fn into_agreed_normal(self)->Option<MeshDataNormalId2>{
+		self.status.and_then(|status|match status{
+			MeshDataNormalStatus::Agree(normal)=>Some(normal),
+			MeshDataNormalStatus::Conflicting=>None,
+		})
+	}
+}
+
+impl std::error::Error for Error{}
+pub fn convert(
+	roblox_physics_data:&[u8],
+	roblox_mesh_data:&[u8],
+	size:glam::Vec3,
+	part_texture_description:crate::rbx::RobloxPartDescription,
+)->Result<model::Mesh,Error>{
+	const NORMAL_FACES:usize=6;
+	let mut polygon_groups_normal_id=vec![Vec::new();NORMAL_FACES];
+
+	// build graphics and physics meshes
+	let mut mb=strafesnet_common::model::MeshBuilder::new();
+	// graphics
+	let graphics_groups=if !roblox_mesh_data.is_empty(){
+		// create per-face texture coordinate affine transforms
+		let cube_face_description=part_texture_description.map(|opt|opt.map(|mut t|{
+			t.transform.set_size(1.0,1.0);
+			t.to_face_description()
+		}));
+
+		let mesh_data=rbx_mesh::read_mesh_data_versioned(
+			std::io::Cursor::new(roblox_mesh_data)
+		).map_err(Error::RobloxMeshData)?;
+		let graphics_mesh=match mesh_data{
+			rbx_mesh::mesh_data::MeshData::CSGK(_)=>return Err(Error::Block),
+			rbx_mesh::mesh_data::MeshData::CSGMDL(rbx_mesh::mesh_data::CSGMDL::CSGMDL2(mesh_data2))=>mesh_data2.mesh,
+			rbx_mesh::mesh_data::MeshData::CSGMDL(rbx_mesh::mesh_data::CSGMDL::CSGMDL4(mesh_data4))=>mesh_data4.mesh,
+		};
+		for [vertex_id0,vertex_id1,vertex_id2] in graphics_mesh.faces{
+			let face=[
+				graphics_mesh.vertices.get(vertex_id0.0 as usize).ok_or(Error::MissingVertexId(vertex_id0.0))?,
+				graphics_mesh.vertices.get(vertex_id1.0 as usize).ok_or(Error::MissingVertexId(vertex_id1.0))?,
+				graphics_mesh.vertices.get(vertex_id2.0 as usize).ok_or(Error::MissingVertexId(vertex_id2.0))?,
+			];
+			let mut normal_agreement_checker=MeshDataNormalChecker::new();
+			let face=face.into_iter().map(|vertex|{
+				normal_agreement_checker.check(vertex.normal_id);
+				let pos=mb.acquire_pos_id(vec3::try_from_f32_array(vertex.pos)?);
+				let normal=mb.acquire_normal_id(vec3::try_from_f32_array(vertex.norm)?);
+				let tex_coord=glam::Vec2::from_array(vertex.tex);
+				let maybe_face_description=&cube_face_description[vertex.normal_id as usize-1];
+				let (tex,color)=match maybe_face_description{
+					Some(face_description)=>{
+						// transform texture coordinates and set decal color
+						let tex=mb.acquire_tex_id(face_description.transform.transform_point2(tex_coord));
+						let color=mb.acquire_color_id(face_description.color);
+						(tex,color)
+					},
+					None=>{
+						// texture coordinates don't matter and pass through mesh vertex color
+						let tex=mb.acquire_tex_id(tex_coord);
+						let color=mb.acquire_color_id(glam::Vec4::from_array(vertex.color.map(|f|f as f32/255.0f32)));
+						(tex,color)
+					},
+				};
+				Ok(mb.acquire_vertex_id(IndexedVertex{pos,tex,normal,color}))
+			}).collect::<Result<Vec<_>,_>>().map_err(Error::Planar64Vec3)?;
+			if let Some(normal_id)=normal_agreement_checker.into_agreed_normal(){
+				polygon_groups_normal_id[normal_id as usize-1].push(face);
+			}else{
+				panic!("Empty face!");
+			}
+		}
+		(0..NORMAL_FACES).map(|polygon_group_id|{
+			model::IndexedGraphicsGroup{
+				render:cube_face_description[polygon_group_id].as_ref().map_or(RenderConfigId::new(0),|face_description|face_description.render),
+				groups:vec![PolygonGroupId::new(polygon_group_id as u32)]
+			}
+		}).collect()
+	}else{
+		Vec::new()
+	};
+
+	//physics
+	let physics_convex_meshes=if !roblox_physics_data.is_empty(){
+		let physics_data=rbx_mesh::read_physics_data_versioned(
+			std::io::Cursor::new(roblox_physics_data)
+		).map_err(Error::RobloxPhysicsData)?;
+		let physics_convex_meshes=match physics_data{
+			rbx_mesh::physics_data::PhysicsData::CSGK(_)
+			// have not seen this format in practice
+			|rbx_mesh::physics_data::PhysicsData::CSGPHS(rbx_mesh::physics_data::CSGPHS::Block)
+			=>return Err(Error::Block),
+			rbx_mesh::physics_data::PhysicsData::CSGPHS(rbx_mesh::physics_data::CSGPHS::Meshes(meshes))
+			=>meshes.meshes,
+			rbx_mesh::physics_data::PhysicsData::CSGPHS(rbx_mesh::physics_data::CSGPHS::PhysicsInfoMesh(pim))
+			=>vec![pim.mesh],
+		};
+		physics_convex_meshes
+	}else{
+		Vec::new()
+	};
+	let polygon_groups:Vec<PolygonGroup>=polygon_groups_normal_id.into_iter().map(|faces|
+		// graphics polygon groups (to be rendered)
+		Ok(PolygonGroup::PolygonList(PolygonList::new(faces)))
+	).chain(physics_convex_meshes.into_iter().map(|mesh|{
+		// this can be factored out of the loop but I am lazy
+		let color=mb.acquire_color_id(glam::Vec4::ONE);
+		let tex=mb.acquire_tex_id(glam::Vec2::ZERO);
+		// physics polygon groups (to do physics)
+		Ok(PolygonGroup::PolygonList(PolygonList::new(mesh.faces.into_iter().map(|[vertex_id0,vertex_id1,vertex_id2]|{
+			let face=[
+				mesh.vertices.get(vertex_id0.0 as usize).ok_or(Error::MissingVertexId(vertex_id0.0))?,
+				mesh.vertices.get(vertex_id1.0 as usize).ok_or(Error::MissingVertexId(vertex_id1.0))?,
+				mesh.vertices.get(vertex_id2.0 as usize).ok_or(Error::MissingVertexId(vertex_id2.0))?,
+			].map(|v|glam::Vec3::from_slice(v)/size);
+			let vertex_norm=(face[1]-face[0])
+			          .cross(face[2]-face[0]);
+			let normal=mb.acquire_normal_id(vec3::try_from_f32_array(vertex_norm.to_array()).map_err(Error::Planar64Vec3)?);
+			face.into_iter().map(|vertex_pos|{
+				let pos=mb.acquire_pos_id(vec3::try_from_f32_array(vertex_pos.to_array()).map_err(Error::Planar64Vec3)?);
+				Ok(mb.acquire_vertex_id(IndexedVertex{pos,tex,normal,color}))
+			}).collect()
+		}).collect::<Result<_,_>>()?)))
+	})).collect::<Result<_,_>>()?;
+	let physics_groups=(NORMAL_FACES..polygon_groups.len()).map(|id|model::IndexedPhysicsGroup{
+		groups:vec![PolygonGroupId::new(id as u32)]
+	}).collect();
+	Ok(mb.build(
+		polygon_groups,
+		graphics_groups,
+		physics_groups,
+	))
+}

lib/rbxassetid/Cargo.toml

@@ -0,0 +1,11 @@
+[package]
+name = "rbxassetid"
+version = "0.1.0"
+edition = "2024"
+repository = "https://git.itzana.me/StrafesNET/strafe-project"
+license = "MIT OR Apache-2.0"
+description = "Parse Roblox asset id from 'Content' urls."
+authors = ["Rhys Lloyd <krakow20@gmail.com>"]
+
+[dependencies]
+url = "2.5.4"

lib/rbxassetid/LICENSE-APACHE

@@ -0,0 +1,176 @@
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS

lib/rbxassetid/LICENSE-MIT

@@ -0,0 +1,23 @@
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.

lib/rbxassetid/README.md

@@ -0,0 +1,26 @@
+Roblox Asset Id
+===============
+
+## Example
+
+```rust
+use rbxassetid::RobloxAssetId;
+
+let content="rbxassetid://255299419";
+let RobloxAssetId(asset_id)=content.parse()?;
+```
+
+#### License
+
+<sup>
+Licensed under either of <a href="LICENSE-APACHE">Apache License, Version
+2.0</a> or <a href="LICENSE-MIT">MIT license</a> at your option.
+</sup>
+
+<br>
+
+<sub>
+Unless you explicitly state otherwise, any contribution intentionally submitted
+for inclusion in this crate by you, as defined in the Apache-2.0 license, shall
+be dual licensed as above, without any additional terms or conditions.
+</sub>

lib/rbxassetid/src/lib.rs

@@ -0,0 +1,41 @@
+#[derive(Clone,Copy,Debug,Hash,Eq,PartialEq)]
+pub struct RobloxAssetId(pub u64);
+#[derive(Debug)]
+pub enum RobloxAssetIdParseErr{
+	Url(url::ParseError),
+	UnknownScheme,
+	ParseInt(std::num::ParseIntError),
+	MissingAssetId,
+	MissingIDQueryParam,
+}
+impl std::fmt::Display for RobloxAssetIdParseErr{
+	fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
+		write!(f,"{self:?}")
+	}
+}
+impl std::error::Error for RobloxAssetIdParseErr{}
+impl std::str::FromStr for RobloxAssetId{
+	type Err=RobloxAssetIdParseErr;
+	fn from_str(s:&str)->Result<Self,Self::Err>{
+		let url=url::Url::parse(s).map_err(RobloxAssetIdParseErr::Url)?;
+		let parsed_asset_id=match url.scheme(){
+			"rbxassetid"=>url.domain().ok_or(RobloxAssetIdParseErr::MissingAssetId)?.parse(),
+			"http"|"https"=>{
+				let (_,asset_id)=url.query_pairs()
+				.find(|(id,_)|match id.as_ref(){
+					"ID"|"id"|"Id"|"iD"=>true,
+					_=>false,
+				}).ok_or(RobloxAssetIdParseErr::MissingIDQueryParam)?;
+				asset_id.parse()
+			},
+			_=>Err(RobloxAssetIdParseErr::UnknownScheme)?,
+		};
+		Ok(Self(parsed_asset_id.map_err(RobloxAssetIdParseErr::ParseInt)?))
+	}
+}
+
+#[test]
+fn test_rbxassetid(){
+	let content="rbxassetid://255299419";
+	let RobloxAssetId(_asset_id)=content.parse().unwrap();
+}

lib/roblox_emulator/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "roblox_emulator"
 version = "0.4.7"
-edition = "2021"
+edition = "2024"
 repository = "https://git.itzana.me/StrafesNET/strafe-project"
 license = "MIT OR Apache-2.0"
 description = "Run embedded Luau scripts which manipulate the DOM."
@@ -12,7 +12,7 @@ default=["run-service"]
 run-service=[]
 
 [dependencies]
-glam = "0.29.0"
+glam = "0.30.0"
 mlua = { version = "0.10.1", features = ["luau"] }
 phf = { version = "0.11.2", features = ["macros"] }
 rbx_dom_weak = { version = "2.7.0", registry = "strafesnet" }

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

@@ -33,7 +33,7 @@ pub fn set_globals(lua:&mlua::Lua,globals:&mlua::Table)->Result<(),mlua::Error>{
 // LMAO look at this function!
 pub fn dom_mut<T>(lua:&mlua::Lua,mut f:impl FnMut(&mut WeakDom)->mlua::Result<T>)->mlua::Result<T>{
 	let mut dom=lua.app_data_mut::<&'static mut WeakDom>().ok_or_else(||mlua::Error::runtime("DataModel missing"))?;
-	f(&mut *dom)
+	f(*dom)
 }
 
 fn coerce_float32(value:&mlua::Value)->Option<f32>{

lib/roblox_emulator/src/runner/macros.rs

@@ -1,22 +1,22 @@
 macro_rules! type_from_lua_userdata{
-	($asd:ident)=>{
-		impl mlua::FromLua for $asd{
+	($ty:ident)=>{
+		impl mlua::FromLua for $ty{
 			fn from_lua(value:mlua::Value,_lua:&mlua::Lua)->Result<Self,mlua::Error>{
 				match value{
 					mlua::Value::UserData(ud)=>Ok(*ud.borrow::<Self>()?),
-					other=>Err(mlua::Error::runtime(format!("Expected {} got {:?}",stringify!($asd),other))),
+					other=>Err(mlua::Error::runtime(format!("Expected {} got {:?}",stringify!($ty),other))),
 				}
 			}
 		}
 	};
 }
 macro_rules! type_from_lua_userdata_lua_lifetime{
-	($asd:ident)=>{
-		impl mlua::FromLua for $asd<'static>{
+	($ty:ident)=>{
+		impl mlua::FromLua for $ty<'static>{
 			fn from_lua(value:mlua::Value,_lua:&mlua::Lua)->Result<Self,mlua::Error>{
 				match value{
 					mlua::Value::UserData(ud)=>Ok(*ud.borrow::<Self>()?),
-					other=>Err(mlua::Error::runtime(format!("Expected {} got {:?}",stringify!($asd),other))),
+					other=>Err(mlua::Error::runtime(format!("Expected {} got {:?}",stringify!($ty),other))),
 				}
 			}
 		}

lib/roblox_emulator/src/scheduler.rs

@@ -59,8 +59,8 @@ fn schedule_thread(lua:&mlua::Lua,dt:mlua::Value)->Result<(),mlua::Error>{
 			match delay.classify(){
 				std::num::FpCategory::Nan=>Err(mlua::Error::runtime("NaN"))?,
 				// cases where the number is too large to schedule
-				std::num::FpCategory::Infinite=>return Ok(()),
-				std::num::FpCategory::Normal=>if (u64::MAX as f64)<delay{
+				std::num::FpCategory::Infinite
+				|std::num::FpCategory::Normal if (u64::MAX as f64)<delay=>{
 					return Ok(());
 				},
 				_=>(),

lib/snf/Cargo.toml

@@ -1,11 +1,11 @@
 [package]
 name = "strafesnet_snf"
-version = "0.2.0"
-edition = "2021"
+version = "0.3.0"
+edition = "2024"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
 binrw = "0.14.0"
 id = { version = "0.1.0", registry = "strafesnet" }
-strafesnet_common = { path = "../common", registry = "strafesnet" }
+strafesnet_common = { version = "0.6.0", path = "../common", registry = "strafesnet" }

lib/snf/src/bot.rs

@@ -1,98 +1,347 @@
-use binrw::{BinReaderExt, binrw};
+use binrw::{binrw,BinReaderExt,BinWrite,BinWriterExt};
+
+use crate::newtypes;
+use crate::file::BlockId;
+use strafesnet_common::physics::Time;
+
+const VERSION:u32=0;
+
+type TimedPhysicsInstruction=strafesnet_common::instruction::TimedInstruction<strafesnet_common::physics::Instruction,strafesnet_common::physics::Time>;
 
 #[derive(Debug)]
 pub enum Error{
-	InvalidHeader,
+	InvalidHeader(binrw::Error),
 	InvalidSegment(binrw::Error),
+	SegmentConvert(newtypes::integer::RatioError),
+	InstructionConvert(newtypes::physics::InstructionConvert),
+	InstructionWrite(binrw::Error),
 	InvalidSegmentId(SegmentId),
+	InvalidData(binrw::Error),
+	IO(std::io::Error),
 	File(crate::file::Error),
 }
 
+// Bot files are simply the sequence of instructions that the physics received during the run.
+// The instructions are partitioned into timestamped blocks for ease of streaming.
+//
+// Keyframe information required for efficient seeking
+// is part of a different file, and is generated from this file.
+
 /* block types
 
 BLOCK_BOT_HEADER:
-u128 map_resource_uuid //which map is this bot running
-//don't include style info in bot header because it's in the simulation state
-//blocks are laid out in chronological order, but indices may jump around.
-u64 num_segments
+// Segments are laid out in chronological order,
+// but block_id is not necessarily in ascending order.
+//
+// This is to place the final segment close to the start of the file,
+// which allows the duration of the bot to be conveniently calculated
+// from the first and last instruction timestamps.
+//
+// Use exact physics version for replay playback
+// Use highest compatible physics version for verification
+u32 physics_version
+u32 num_segments
 for _ in 0..num_segments{
-	i64 time //simulation_state timestamp
-	u64 block_id
+	i64 time
+	u32 instruction_count
+	u32 block_id
 }
 
 BLOCK_BOT_SEGMENT:
-//format version indicates what version of these structures to use
-SimulationState simulation_state //SimulationState is just under ClientState which includes Play/Pause events that the simulation doesn't know about.
-//to read, greedily decode instructions until eof
-loop{
-	//delta encode as much as possible (time,mousepos)
-	//strafe ticks are implied
-	//physics can be implied in an input-only bot file
-	TimedInstruction<SimulationInstruction> instruction
+// segments can potentially be losslessly compressed!
+for _ in 0..instruction_count{
+	// TODO: delta encode as much as possible (time,mousepos)
+	i64 time
+	physics::Instruction instruction
 }
 
 */
 
-//error hiding mock code
-mod simulation{
-	#[super::binrw]
-	#[brw(little)]
-	pub struct State{}
-	#[super::binrw]
-	#[brw(little)]
-	pub struct Instruction{}
+#[binrw]
+#[brw(little)]
+struct SegmentHeader{
+	time:i64,
+	instruction_count:u32,
+	block_id:BlockId,
+}
+#[binrw]
+#[brw(little)]
+struct Header{
+	physics_version:u32,
+	num_segments:u32,
+	#[br(count=num_segments)]
+	segments:Vec<SegmentHeader>,
 }
-// mod instruction{
-	// #[super::binrw]
-	// #[brw(little)]
-	// pub struct TimedInstruction<Instruction:binrw::BinRead+binrw::BinWrite>{
-		// time:u64,
-		// instruction:Instruction
-	// }
-// }
-// mod timeline{
-	// #[super::binrw]
-	// #[brw(little)]
-	// pub struct Timeline<Instruction:binrw::BinRead+binrw::BinWrite>{
-		// #[bw(try_calc(u32::try_from(instructions.len())))]
-		// instruction_count:u32,
-		// #[br(count=instruction_count)]
-		// instructions:Vec<super::instruction::TimedInstruction<Instruction>>
-	// }
-// }
-
-//serious code
 
 #[binrw]
 #[brw(little)]
 #[derive(Clone,Copy,Debug,id::Id)]
 pub struct SegmentId(u32);
 
-#[binrw]
-#[brw(little)]
 pub struct Segment{
-	state:simulation::State,
-	//#[bw(try_calc(u32::try_from(instructions.len())))]
-	//instruction_count:u32,
-	//#[br(count=instruction_count)]
-	//instructions:Vec<instruction::TimedInstruction<simulation::Instruction>>
+	pub instructions:Vec<TimedPhysicsInstruction>
+}
 
-	//please remember that strafe ticks are implicit! 33% smaller bot files
+#[derive(Clone,Copy,Debug)]
+pub struct SegmentInfo{
+	/// time of the first instruction in this segment.
+	time:Time,
+	instruction_count:u32,
+	/// How many total instructions in segments up to and including this segment
+	/// Alternatively, the id of the first instruction be in the _next_ segment
+	instructions_subtotal:u64,
+	block_id:BlockId,
 }
 
 pub struct StreamableBot<R:BinReaderExt>{
 	file:crate::file::File<R>,
-	//timeline:timeline::Timeline<SegmentId>,
-	segment_id_to_block_id:Vec<crate::file::BlockId>,
+	segment_map:Vec<SegmentInfo>,
 }
 impl<R:BinReaderExt> StreamableBot<R>{
-	pub(crate) fn new(file:crate::file::File<R>)->Result<Self,Error>{
-		Err(Error::InvalidHeader)
+	pub(crate) fn new(mut file:crate::file::File<R>)->Result<Self,Error>{
+		//assume the file seek is in the right place to start reading header
+		let header:Header=file.data_mut().read_le().map_err(Error::InvalidHeader)?;
+		let mut instructions_subtotal=0;
+		let segment_map=header.segments.into_iter().map(|SegmentHeader{time,instruction_count,block_id}|{
+			instructions_subtotal+=instruction_count as u64;
+			SegmentInfo{
+				time:Time::raw(time),
+				instruction_count,
+				instructions_subtotal,
+				block_id,
+			}
+		}).collect();
+		Ok(Self{
+			file,
+			segment_map,
+		})
 	}
-	pub fn load_segment(&mut self,segment_id:SegmentId)->Result<Segment,Error>{
-		let block_id=*self.segment_id_to_block_id.get(segment_id.get() as usize).ok_or(Error::InvalidSegmentId(segment_id))?;
-		let mut block=self.file.block_reader(block_id).map_err(Error::File)?;
-		let segment=block.read_le().map_err(Error::InvalidSegment)?;
+	fn get_segment_info(&self,segment_id:SegmentId)->Result<SegmentInfo,Error>{
+		Ok(*self.segment_map.get(segment_id.get() as usize).ok_or(Error::InvalidSegmentId(segment_id))?)
+	}
+	pub fn find_segments_instruction_range(&self,start_instruction:u64,end_instruction:u64)->&[SegmentInfo]{
+		let start=self.segment_map.partition_point(|segment_info|segment_info.instructions_subtotal<start_instruction);
+		let end=self.segment_map.partition_point(|segment_info|segment_info.instructions_subtotal<end_instruction);
+		&self.segment_map[start..=end]
+	}
+	// pub fn find_segments_time_range(&self,start_time:Time,end_time:Time)->&[SegmentInfo]{
+	// 	// TODO: This is off by one, both should be one less
+	// 	let start=self.segment_map.partition_point(|segment_info|segment_info.time<start_time);
+	// 	let end=self.segment_map.partition_point(|segment_info|segment_info.time<end_time);
+	// 	&self.segment_map[start..=end]
+	// }
+	fn append_to_segment(&mut self,segment_info:SegmentInfo,segment:&mut Segment)->Result<(),Error>{
+		let mut block=self.file.block_reader(segment_info.block_id).map_err(Error::File)?;
+		for _ in 0..segment_info.instruction_count{
+			let instruction:newtypes::physics::TimedInstruction=block.read_le().map_err(Error::InvalidSegment)?;
+			segment.instructions.push(instruction.try_into().map_err(Error::SegmentConvert)?);
+		}
+		Ok(())
+	}
+	pub fn load_segment(&mut self,segment_info:SegmentInfo)->Result<Segment,Error>{
+		let mut segment=Segment{
+			instructions:Vec::with_capacity(segment_info.instruction_count as usize),
+		};
+		self.append_to_segment(segment_info,&mut segment)?;
+		Ok(segment)
+	}
+	pub fn read_all(&mut self)->Result<Segment,Error>{
+		let mut segment=Segment{
+			instructions:Vec::new(),
+		};
+		for i in 0..self.segment_map.len(){
+			let segment_info=self.segment_map[i];
+			self.append_to_segment(segment_info,&mut segment)?;
+		}
 		Ok(segment)
 	}
 }
+
+const MAX_BLOCK_SIZE:usize=64*1024;//64 kB
+pub fn write_bot<W:BinWriterExt>(mut writer:W,physics_version:u32,instructions:impl IntoIterator<Item=TimedPhysicsInstruction>)->Result<(),Error>{
+	// decide which instructions to put in which segment
+	// write segment 1 to block 1
+	// write segment N to block 2
+	// write rest of segments
+	// 1 2 3 4 5
+	// becomes
+	// [1 5] 2 3 4
+	struct SegmentHeaderInfo{
+		time:Time,
+		instruction_count:u32,
+		range:core::ops::Range<usize>
+	}
+
+	let mut segment_header_infos=Vec::new();
+	let mut raw_segments=std::io::Cursor::new(Vec::new());
+
+	// block info
+	let mut start_time=Time::ZERO;
+	let mut start_position=raw_segments.position() as usize;
+	let mut instruction_count=0;
+
+	let mut last_position=start_position;
+
+	let mut iter=instructions.into_iter();
+
+	macro_rules! collect_instruction{
+		($instruction:expr)=>{
+			let time=$instruction.time;
+			let instruction_writable:newtypes::physics::TimedInstruction=$instruction.try_into().map_err(Error::InstructionConvert)?;
+			instruction_writable.write_le(&mut raw_segments).map_err(Error::InstructionWrite)?;
+			instruction_count+=1;
+			let position=raw_segments.position() as usize;
+			// exceeds max block size
+			if MAX_BLOCK_SIZE<position-last_position{
+				segment_header_infos.push(SegmentHeaderInfo{
+					time:start_time,
+					instruction_count,
+					range:start_position..last_position,
+				});
+				start_position=last_position;
+				instruction_count=0;
+				start_time=time;
+			}
+			last_position=position;
+		}
+	}
+
+	// unroll one loop iteration to grab the starting time
+	if let Some(instruction)=iter.next(){
+		start_time=instruction.time;
+		collect_instruction!(instruction);
+	}
+
+	for instruction in iter{
+		collect_instruction!(instruction);
+	}
+	//last block, whatever size it happens to be
+	{
+		let final_position=raw_segments.position() as usize;
+		segment_header_infos.push(SegmentHeaderInfo{
+			time:start_time,
+			instruction_count,
+			range:start_position..final_position,
+		});
+	}
+	// drop cursor
+	let raw_segments=raw_segments.into_inner();
+
+	let num_segments=segment_header_infos.len();
+
+	// segments list is in chronological order
+	let make_segment_header=|block_id,&SegmentHeaderInfo{time,instruction_count,range:ref _range}|SegmentHeader{
+		time:time.get(),
+		instruction_count,
+		block_id,
+	};
+	let segments=if 2<num_segments{
+		let mut segments=Vec::with_capacity(num_segments);
+		// segment 1 is second block
+		if let Some(seg)=segment_header_infos.first(){
+			segments.push(make_segment_header(BlockId::new(1),seg));
+		}
+		// rest of segments start at fourth block
+		for (i,seg) in segment_header_infos[1..num_segments-1].iter().enumerate(){
+			make_segment_header(BlockId::new(3+i as u32),seg);
+		}
+		// last segment is third block
+		if let Some(seg)=segment_header_infos.last(){
+			segments.push(make_segment_header(BlockId::new(2),seg));
+		}
+		segments
+	}else{
+		// all segments in order
+		segment_header_infos.iter().enumerate().map(|(i,seg)|
+			make_segment_header(BlockId::new(1+i as u32),seg)
+		).collect()
+	};
+
+	let header=Header{
+		physics_version,
+		num_segments:num_segments as u32,
+		segments,
+	};
+
+	// map header is +1
+	let block_count=1+num_segments as u32;
+
+	let mut offset=crate::file::Header::calculate_size(block_count) as u64;
+	// block_location is one longer than block_count
+	let mut block_location=Vec::with_capacity(1+block_count as usize);
+
+	//probe header length
+	let mut bot_header_data=Vec::new();
+	binrw::BinWrite::write_le(&header,&mut std::io::Cursor::new(&mut bot_header_data)).map_err(Error::InvalidData)?;
+
+	// the first block location is the map header
+	block_location.push(offset);
+	offset+=bot_header_data.len() as u64;
+	block_location.push(offset);
+
+	// priming includes file header + first 3 blocks [bot header, first segment, last segment]
+	let priming=if 2<num_segments{
+		// segment 1 is block 2
+		if let Some(seg)=segment_header_infos.first(){
+			offset+=seg.range.len() as u64;
+			block_location.push(offset);
+		}
+		// last segment is block 3
+		if let Some(seg)=segment_header_infos.last(){
+			offset+=seg.range.len() as u64;
+			block_location.push(offset);
+		}
+
+		let priming=offset;
+
+		// rest of segments
+		for seg in &segment_header_infos[1..num_segments-1]{
+			offset+=seg.range.len() as u64;
+			block_location.push(offset);
+		}
+		priming
+	}else{
+		// all segments in order
+		for seg in &segment_header_infos{
+			offset+=seg.range.len() as u64;
+			block_location.push(offset);
+		}
+		offset
+	};
+
+	let file_header=crate::file::Header{
+		fourcc:crate::file::FourCC::Bot,
+		version:VERSION,
+		priming,
+		resource:0,
+		block_count,
+		block_location,
+	};
+
+	// write file header
+	writer.write_le(&file_header).map_err(Error::InvalidData)?;
+	// write bot header
+	writer.write(&bot_header_data).map_err(Error::IO)?;
+
+	// write blocks
+	if 2<num_segments{
+		// segment 1 is block 2
+		if let Some(seg)=segment_header_infos.first(){
+			writer.write(&raw_segments[seg.range.clone()]).map_err(Error::IO)?;
+		}
+		// last segment is block 3
+		if let Some(seg)=segment_header_infos.last(){
+			writer.write(&raw_segments[seg.range.clone()]).map_err(Error::IO)?;
+		}
+		// rest of segments
+		for seg in &segment_header_infos[1..num_segments-1]{
+			writer.write(&raw_segments[seg.range.clone()]).map_err(Error::IO)?;
+		}
+	}else{
+		// all segments in order
+		for seg in segment_header_infos{
+			writer.write(&raw_segments[seg.range]).map_err(Error::IO)?;
+		}
+	}
+	Ok(())
+}

lib/snf/src/demo.rs

@@ -7,21 +7,29 @@ pub enum Error{
 
 /*
 BLOCK_DEMO_HEADER:
-u128 map_resource_id
-u64 map_header_block_id
+u32 num_maps
+for map_id in 0..num_maps{
+	i64 simulation_time
+	u128 map_resource_id
+	u64 map_header_block_id
+}
 u32 num_bots
 for bot_id in 0..num_bots{
+	i64 simulation_time
 	u128 bot_resource_id
 	u64 bot_header_block_id
 }
 
+//map loading timeline
+
 //bot loading timeline
 how to do worldstate for deathrun!?
+- this is done in the client, there is no worldstate in the demo file
 
 */
 
 pub struct StreamableDemo<R:BinReaderExt>{
-	map:Box<crate::map::StreamableMap<R>>,
+	map:Vec<crate::map::StreamableMap<R>>,
 	bots:Vec<crate::bot::StreamableBot<R>>,
 }
 impl<R:BinReaderExt> StreamableDemo<R>{

lib/snf/src/file.rs

@@ -73,6 +73,16 @@ pub struct Header{
 	#[br(count=block_count+1)]
 	pub block_location:Vec<u64>,
 }
+impl Header{
+	pub const fn calculate_size(block_count:u32)->usize{
+		4 // fourcc
+		+4 // version
+		+8 // priming
+		+16 // resource
+		+4 // block_count
+		+(block_count as usize+1)*8 // block_location
+	}
+}
 
 #[binrw]
 #[brw(little)]

lib/snf/src/map.rs

@@ -6,7 +6,7 @@ use crate::file::BlockId;
 use binrw::{binrw,BinReaderExt,BinWriterExt};
 use strafesnet_common::model;
 use strafesnet_common::aabb::Aabb;
-use strafesnet_common::bvh::BvhNode;
+use strafesnet_common::bvh::{BvhNode,RecursiveContent};
 use strafesnet_common::gameplay_modes;
 
 #[derive(Debug)]
@@ -86,6 +86,7 @@ for model_id in 0..num_models{
 //if you hash the resource itself and set the first 8 bits to this, that's the resource uuid
 #[binrw]
 #[brw(little,repr=u8)]
+#[repr(u8)]
 enum ResourceType{
 	Mesh,
 	Texture,
@@ -94,21 +95,6 @@ enum ResourceType{
 	//Video,
 	//Animation,
 }
-const RESOURCE_TYPE_VARIANT_COUNT:u8=2;
-#[binrw]
-#[brw(little)]
-struct ResourceId(u128);
-impl ResourceId{
-	fn resource_type(&self)->Option<ResourceType>{
-		let discriminant=self.0 as u8;
-		//TODO: use this when it is stabilized https://github.com/rust-lang/rust/issues/73662
-		//if (discriminant as usize)<std::mem::variant_count::<ResourceType>(){
-		match discriminant<RESOURCE_TYPE_VARIANT_COUNT{
-			true=>Some(unsafe{std::mem::transmute::<u8,ResourceType>(discriminant)}),
-			false=>None,
-		}
-	}
-}
 
 struct ResourceMap<T>{
 	meshes:HashMap<strafesnet_common::model::MeshId,T>,
@@ -135,11 +121,6 @@ struct ResourceBlockHeader{
 	resource:ResourceType,
 	id:BlockId,
 }
-#[binrw]
-#[brw(little)]
-struct ResourceExternalHeader{
-	resource_uuid:ResourceId,
-}
 
 #[binrw]
 #[brw(little)]
@@ -157,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)]
@@ -200,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
@@ -242,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),
@@ -252,7 +233,7 @@ impl<R:BinReaderExt> StreamableMap<R>{
 	}
 	pub fn get_intersecting_region_block_ids(&self,aabb:&Aabb)->Vec<BlockId>{
 		let mut block_ids=Vec::new();
-		self.bvh.the_tester(aabb,&mut |&block_id|block_ids.push(block_id));
+		self.bvh.sample_aabb(aabb,&mut |&block_id|block_ids.push(block_id));
 		block_ids
 	}
 	pub fn load_region(&mut self,block_id:BlockId)->Result<Vec<(model::ModelId,model::Model)>,Error>{
@@ -306,12 +287,60 @@ impl<R:BinReaderExt> StreamableMap<R>{
 	}
 }
 
+// silly redefinition of Bvh for determining the size of subnodes
+// without duplicating work by running weight calculation recursion top down on every node
+pub struct BvhWeightNode<W,T>{
+	content:RecursiveContent<BvhWeightNode<W,T>,T>,
+	weight:W,
+	aabb:Aabb,
+}
+impl <W,T> BvhWeightNode<W,T>{
+	pub const fn weight(&self)->&W{
+		&self.weight
+	}
+	pub const fn aabb(&self)->&Aabb{
+		&self.aabb
+	}
+	pub fn into_content(self)->RecursiveContent<BvhWeightNode<W,T>,T>{
+		self.content
+	}
+	pub fn into_visitor<F:FnMut(T)>(self,f:&mut F){
+		match self.content{
+			RecursiveContent::Leaf(model)=>f(model),
+			RecursiveContent::Branch(children)=>for child in children{
+				child.into_visitor(f)
+			},
+		}
+	}
+}
+
+pub fn weigh_contents<T,W:Copy+std::iter::Sum<W>,F:Fn(&T)->W>(node:BvhNode<T>,f:&F)->BvhWeightNode<W,T>{
+	let (content,aabb)=node.into_inner();
+	match content{
+		RecursiveContent::Leaf(model)=>BvhWeightNode{
+			weight:f(&model),
+			content:RecursiveContent::Leaf(model),
+			aabb,
+		},
+		RecursiveContent::Branch(children)=>{
+			let branch:Vec<BvhWeightNode<W,T>>=children.into_iter().map(|child|
+				weigh_contents(child,f)
+			).collect();
+			BvhWeightNode{
+				weight:branch.iter().map(|node|node.weight).sum(),
+				content:RecursiveContent::Branch(branch),
+				aabb,
+			}
+		},
+	}
+}
+
 const BVH_NODE_MAX_WEIGHT:usize=64*1024;//64 kB
 fn collect_spacial_blocks(
 	block_location:&mut Vec<u64>,
 	block_headers:&mut Vec<SpacialBlockHeader>,
 	sequential_block_data:&mut std::io::Cursor<&mut Vec<u8>>,
-	bvh_node:strafesnet_common::bvh::BvhWeightNode<usize,(model::ModelId,newtypes::model::Model)>
+	bvh_node:BvhWeightNode<usize,(model::ModelId,newtypes::model::Model)>
 )->Result<(),Error>{
 	//inspect the node weights top-down.
 	//When a node weighs less than the limit,
@@ -361,7 +390,7 @@ pub fn write_map<W:BinWriterExt>(mut writer:W,map:strafesnet_common::map::Comple
 		}
 		Ok(((model::ModelId::new(model_id as u32),model.into()),aabb))
 	}).collect::<Result<Vec<_>,_>>()?;
-	let bvh=strafesnet_common::bvh::generate_bvh(boxen).weigh_contents(&|_|std::mem::size_of::<newtypes::model::Model>());
+	let bvh=weigh_contents(strafesnet_common::bvh::generate_bvh(boxen),&|_|std::mem::size_of::<newtypes::model::Model>());
 	//build blocks
 	//block location is initialized with two values
 	//the first value represents the location of the first byte after the file header
@@ -401,38 +430,36 @@ 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(),
 	};
-	let mut file_header=crate::file::Header{
+	//probe header length
+	let mut map_header_data=Vec::new();
+	binrw::BinWrite::write_le(&map_header,&mut std::io::Cursor::new(&mut map_header_data)).map_err(Error::InvalidData)?;
+
+	// calculate final file header
+	let mut offset=crate::file::Header::calculate_size(block_count) as u64;
+	offset+=map_header_data.len() as u64;
+	// priming includes map header
+	let priming=offset;
+	for position in &mut block_location{
+		*position+=offset;
+	}
+	let file_header=crate::file::Header{
 		fourcc:crate::file::FourCC::Map,
 		version:0,
-		priming:0,
+		priming,
 		resource:0,
 		block_count,
 		block_location,
 	};
-	//probe header length
-	let mut file_header_data=Vec::new();
-	binrw::BinWrite::write_le(&file_header,&mut std::io::Cursor::new(&mut file_header_data)).map_err(Error::InvalidData)?;
-	let mut map_header_data=Vec::new();
-	binrw::BinWrite::write_le(&map_header,&mut std::io::Cursor::new(&mut map_header_data)).map_err(Error::InvalidData)?;
-
-	//update file header according to probe data
-	let mut offset=file_header_data.len() as u64;
-	file_header.priming=offset;
-	file_header.block_location[0]=offset;
-	offset+=map_header_data.len() as u64;
-	for position in &mut file_header.block_location[1..]{
-		*position+=offset;
-	}
 
 	//write (updated) file header
 	writer.write_le(&file_header).map_err(Error::InvalidData)?;

lib/snf/src/newtypes/common.rs

@@ -1,3 +1,9 @@
 pub const fn flag(b:bool,mask:u8)->u8{
 	(-(b as i8) as u8)&mask
 }
+pub fn bool_from_u8(value:u8)->bool{
+	value!=0
+}
+pub fn bool_into_u8(value:&bool)->u8{
+	*value as u8
+}

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,

lib/snf/src/newtypes/integer.rs

@@ -38,6 +38,23 @@ pub struct Ratio64Vec2{
 	pub x:Ratio64,
 	pub y:Ratio64,
 }
+impl TryInto<strafesnet_common::integer::Ratio64Vec2> for Ratio64Vec2{
+	type Error=RatioError;
+	fn try_into(self)->Result<strafesnet_common::integer::Ratio64Vec2,Self::Error>{
+		Ok(strafesnet_common::integer::Ratio64Vec2{
+			x:self.x.try_into()?,
+			y:self.y.try_into()?,
+		})
+	}
+}
+impl From<strafesnet_common::integer::Ratio64Vec2> for Ratio64Vec2{
+	fn from(value:strafesnet_common::integer::Ratio64Vec2)->Self{
+		Self{
+			x:value.x.into(),
+			y:value.y.into(),
+		}
+	}
+}
 
 pub type Angle32=i32;
 pub type Planar64=i64;

lib/snf/src/newtypes/mod.rs

@@ -1,7 +1,9 @@
 mod common;
 pub mod aabb;
 pub mod model;
+pub mod mouse;
 pub mod integer;
+pub mod physics;
 pub mod gameplay_modes;
 pub mod gameplay_style;
 pub mod gameplay_attributes;

lib/snf/src/newtypes/mouse.rs

@@ -0,0 +1,25 @@
+use super::integer::Time;
+
+#[binrw::binrw]
+#[brw(little)]
+pub struct MouseState{
+	pub pos:[i32;2],
+	pub time:Time,
+}
+
+impl<T> Into<strafesnet_common::mouse::MouseState<T>> for MouseState{
+	fn into(self)->strafesnet_common::mouse::MouseState<T>{
+		strafesnet_common::mouse::MouseState{
+			pos:self.pos.into(),
+			time:strafesnet_common::integer::Time::raw(self.time),
+		}
+	}
+}
+impl<T> From<strafesnet_common::mouse::MouseState<T>> for MouseState{
+	fn from(value:strafesnet_common::mouse::MouseState<T>)->Self{
+		Self{
+			pos:value.pos.to_array(),
+			time:value.time.get(),
+		}
+	}
+}