new bug who dis

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

Cargo.toml

@@ -24,7 +24,3 @@ resolver = "2"
 #lto = true
 strip = true
 codegen-units = 1
-
-[profile.dev]
-strip = false
-opt-level = 3

engine/graphics/Cargo.toml

@@ -11,4 +11,4 @@ id = { version = "0.1.0", registry = "strafesnet" }
 strafesnet_common = { path = "../../lib/common", registry = "strafesnet" }
 strafesnet_session = { path = "../session", registry = "strafesnet" }
 strafesnet_settings = { path = "../settings", registry = "strafesnet" }
-wgpu = "25.0.0"
+wgpu = "24.0.0"

engine/graphics/src/graphics.rs

@@ -11,6 +11,15 @@ pub fn required_limits()->wgpu::Limits{
 	wgpu::Limits::default()
 }
 
+// physics debug view:
+// render two meshes adjacent according to Minkowski FEV
+// render additional mesh at path point
+// render path parabola
+// highlight meshes according to Minkowski FEV
+//
+// debug process:
+// press a button to step physics by one transition
+
 struct Indices{
 	count:u32,
 	buf:wgpu::Buffer,
@@ -103,26 +112,6 @@ impl std::default::Default for GraphicsCamera{
 	}
 }
 
-const MODEL_BUFFER_SIZE:usize=4*4 + 12 + 4;//let size=std::mem::size_of::<ModelInstance>();
-const MODEL_BUFFER_SIZE_BYTES:usize=MODEL_BUFFER_SIZE*4;
-fn get_instances_buffer_data(instances:&[GraphicsModelOwned])->Vec<f32>{
-	let mut raw=Vec::with_capacity(MODEL_BUFFER_SIZE*instances.len());
-	for mi in instances{
-		//model transform
-		raw.extend_from_slice(&AsRef::<[f32; 4*4]>::as_ref(&mi.transform)[..]);
-		//normal transform
-		raw.extend_from_slice(AsRef::<[f32; 3]>::as_ref(&mi.normal_transform.x_axis));
-		raw.extend_from_slice(&[0.0]);
-		raw.extend_from_slice(AsRef::<[f32; 3]>::as_ref(&mi.normal_transform.y_axis));
-		raw.extend_from_slice(&[0.0]);
-		raw.extend_from_slice(AsRef::<[f32; 3]>::as_ref(&mi.normal_transform.z_axis));
-		raw.extend_from_slice(&[0.0]);
-		//color
-		raw.extend_from_slice(AsRef::<[f32; 4]>::as_ref(&mi.color.get()));
-	}
-	raw
-}
-
 pub struct GraphicsState{
 	pipelines:GraphicsPipelines,
 	bind_groups:GraphicsBindGroups,
@@ -987,3 +976,22 @@ impl GraphicsState{
 		self.staging_belt.recall();
 	}
 }
+const MODEL_BUFFER_SIZE:usize=4*4 + 12 + 4;//let size=std::mem::size_of::<ModelInstance>();
+const MODEL_BUFFER_SIZE_BYTES:usize=MODEL_BUFFER_SIZE*4;
+fn get_instances_buffer_data(instances:&[GraphicsModelOwned])->Vec<f32>{
+	let mut raw=Vec::with_capacity(MODEL_BUFFER_SIZE*instances.len());
+	for mi in instances{
+		//model transform
+		raw.extend_from_slice(&AsRef::<[f32; 4*4]>::as_ref(&mi.transform)[..]);
+		//normal transform
+		raw.extend_from_slice(AsRef::<[f32; 3]>::as_ref(&mi.normal_transform.x_axis));
+		raw.extend_from_slice(&[0.0]);
+		raw.extend_from_slice(AsRef::<[f32; 3]>::as_ref(&mi.normal_transform.y_axis));
+		raw.extend_from_slice(&[0.0]);
+		raw.extend_from_slice(AsRef::<[f32; 3]>::as_ref(&mi.normal_transform.z_axis));
+		raw.extend_from_slice(&[0.0]);
+		//color
+		raw.extend_from_slice(AsRef::<[f32; 4]>::as_ref(&mi.color.get()));
+	}
+	raw
+}

engine/physics/src/face_crawler.rs

@@ -1,9 +1,7 @@
-use crate::model::{into_giga_time,GigaTime,FEV,MeshQuery,DirectedEdge};
+use crate::model::{GigaTime,FEV,MeshQuery,DirectedEdge};
 use strafesnet_common::integer::{Fixed,Ratio,vec3::Vector3};
 use crate::physics::{Time,Body};
 
-use core::ops::Bound;
-
 #[derive(Debug)]
 enum Transition<M:MeshQuery>{
 	Miss,
@@ -30,60 +28,18 @@ impl<M:MeshQuery> CrawlResult<M>{
 	}
 }
 
-// TODO: move predict_collision_face_out algorithm in here or something
-
-/// check_lower_bound
-pub fn low<LhsNum,LhsDen,RhsNum,RhsDen,T>(lower_bound:&Bound<Ratio<LhsNum,LhsDen>>,dt:&Ratio<RhsNum,RhsDen>)->bool
-where
-	RhsNum:Copy,
-	RhsDen:Copy,
-	LhsNum:Copy,
-	LhsDen:Copy,
-	LhsDen:strafesnet_common::integer::Parity,
-	RhsDen:strafesnet_common::integer::Parity,
-	LhsNum:core::ops::Mul<RhsDen,Output=T>,
-	LhsDen:core::ops::Mul<RhsNum,Output=T>,
-	T:Ord+Copy,
-{
-	match lower_bound{
-		Bound::Included(time)=>time.le_ratio(*dt),
-		Bound::Excluded(time)=>time.lt_ratio(*dt),
-		Bound::Unbounded=>true,
-	}
-}
-/// check_upper_bound
-pub fn upp<LhsNum,LhsDen,RhsNum,RhsDen,T>(dt:&Ratio<LhsNum,LhsDen>,upper_bound:&Bound<Ratio<RhsNum,RhsDen>>)->bool
-where
-	RhsNum:Copy,
-	RhsDen:Copy,
-	LhsNum:Copy,
-	LhsDen:Copy,
-	LhsDen:strafesnet_common::integer::Parity,
-	RhsDen:strafesnet_common::integer::Parity,
-	LhsNum:core::ops::Mul<RhsDen,Output=T>,
-	LhsDen:core::ops::Mul<RhsNum,Output=T>,
-	T:Ord+Copy,
-{
-	match upper_bound{
-		Bound::Included(time)=>dt.le_ratio(*time),
-		Bound::Excluded(time)=>dt.lt_ratio(*time),
-		Bound::Unbounded=>true,
-	}
-}
-
-impl<F:Copy,M:MeshQuery<Normal=Vector3<F>,Offset=Fixed<4,128>>> FEV<M>
+impl<F:Copy,M:MeshQuery<Normal=Vector3<F>,Offset=Fixed<4,128>>+std::fmt::Debug> FEV<M>
 	where
 		// This is hardcoded for MinkowskiMesh lol
 		M::Face:Copy,
 		M::Edge:Copy,
 		M::Vert:Copy,
-		M:std::fmt::Debug,
-		F:std::fmt::Display,
-		F:core::ops::Mul<Fixed<1,32>,Output=Fixed<4,128>>,
+		F:core::ops::Mul<Fixed<1,32>,Output=Fixed<4,128>>+std::fmt::Debug+std::fmt::Display,
 		<F as core::ops::Mul<Fixed<1,32>>>::Output:core::iter::Sum,
-		M::Offset:core::ops::Sub<<F as std::ops::Mul<Fixed<1,32>>>::Output>,
+		<M as MeshQuery>::Offset:core::ops::Sub<<F as std::ops::Mul<Fixed<1,32>>>::Output>,
 {
-	fn next_transition(&self,mesh:&M,body:&Body,lower_bound:Bound<GigaTime>,mut upper_bound:Bound<GigaTime>)->Transition<M>{
+	fn next_transition(&self,body_time:GigaTime,mesh:&M,body:&Body,mut best_time:GigaTime)->Transition<M>{
+		println!("next_transition fev={self:?}");
 		//conflicting derivative means it crosses in the wrong direction.
 		//if the transition time is equal to an already tested transition, do not replace the current best.
 		let mut best_transition=Transition::Miss;
@@ -93,16 +49,11 @@ impl<F:Copy,M:MeshQuery<Normal=Vector3<F>,Offset=Fixed<4,128>>> FEV<M>
 				//n=face.normal d=face.dot
 				//n.a t^2+n.v t+n.p-d==0
 				let (n,d)=mesh.face_nd(face_id);
-				println!("Face n={} d={}",n,d);
 				//TODO: use higher precision d value?
 				//use the mesh transform translation instead of baking it into the d value.
 				for dt in Fixed::<4,128>::zeroes2((n.dot(body.position)-d)*2,n.dot(body.velocity)*2,n.dot(body.acceleration)){
-					let low=low(&lower_bound,&dt);
-					let upp=upp(&dt,&upper_bound);
-					let into=n.dot(body.extrapolated_velocity_ratio_dt(dt)).is_negative();
-					println!("dt={} low={low} upp={upp} into={into}",dt.divide());
-					if low&&upp&&into{
-						upper_bound=Bound::Included(dt);
+					if body_time.le_ratio(dt)&&dt.lt_ratio(best_time)&&n.dot(body.extrapolated_velocity_ratio_dt(dt)).is_negative(){
+						best_time=dt;
 						best_transition=Transition::Hit(face_id,dt);
 						break;
 					}
@@ -116,8 +67,8 @@ impl<F:Copy,M:MeshQuery<Normal=Vector3<F>,Offset=Fixed<4,128>>> FEV<M>
 					//WARNING: precision is swept under the rug!
 					//wrap for speed
 					for dt in Fixed::<4,128>::zeroes2(n.dot(body.position*2-(mesh.vert(v0)+mesh.vert(v1))).wrap_4(),n.dot(body.velocity).wrap_4()*2,n.dot(body.acceleration).wrap_4()){
-						if low(&lower_bound,&dt)&&upp(&dt,&upper_bound)&&n.dot(body.extrapolated_velocity_ratio_dt(dt)).is_negative(){
-							upper_bound=Bound::Included(dt);
+						if body_time.le_ratio(dt)&&dt.lt_ratio(best_time)&&n.dot(body.extrapolated_velocity_ratio_dt(dt)).is_negative(){
+							best_time=dt;
 							best_transition=Transition::Next(FEV::Edge(directed_edge_id.as_undirected()),dt);
 							break;
 						}
@@ -126,6 +77,7 @@ impl<F:Copy,M:MeshQuery<Normal=Vector3<F>,Offset=Fixed<4,128>>> FEV<M>
 				//if none:
 			},
 			&FEV::Edge(edge_id)=>{
+				println!("test edge={edge_id:?}");
 				//test each face collision time, ignoring roots with zero or conflicting derivative
 				let edge_n=mesh.edge_n(edge_id);
 				let edge_verts=mesh.edge_verts(edge_id);
@@ -135,17 +87,12 @@ impl<F:Copy,M:MeshQuery<Normal=Vector3<F>,Offset=Fixed<4,128>>> FEV<M>
 					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);
-					let d=n.dot(delta_pos).wrap_4();
-					println!("Edge Face={:?} boundary_n={} boundary_d={}",edge_face_id,n,d>>1);
+					println!("edge_face={edge_face_id:?} face_n={face_n} n={n}");
 					//WARNING yada yada d *2
 					//wrap for speed
-					for dt in Fixed::<4,128>::zeroes2(d,n.dot(body.velocity).wrap_4()*2,n.dot(body.acceleration).wrap_4()){
-						let low=low(&lower_bound,&dt);
-						let upp=upp(&dt,&upper_bound);
-						let into=n.dot(body.extrapolated_velocity_ratio_dt(dt)).is_negative();
-						println!("dt={} low={low} upp={upp} into={into}",dt.divide());
-						if low&&upp&&into{
-							upper_bound=Bound::Included(dt);
+					for dt in Fixed::<4,128>::zeroes2(n.dot(delta_pos).wrap_4(),n.dot(body.velocity).wrap_4()*2,n.dot(body.acceleration).wrap_4()){
+						if body_time.le_ratio(dt)&&dt.lt_ratio(best_time)&&n.dot(body.extrapolated_velocity_ratio_dt(dt)).is_negative(){
+							best_time=dt;
 							best_transition=Transition::Next(FEV::Face(edge_face_id),dt);
 							break;
 						}
@@ -156,9 +103,9 @@ impl<F:Copy,M:MeshQuery<Normal=Vector3<F>,Offset=Fixed<4,128>>> FEV<M>
 					//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 low(&lower_bound,&dt)&&upp(&dt,&upper_bound)&&n.dot(body.extrapolated_velocity_ratio_dt(dt)).is_negative(){
+						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.widen_4(),dt.den.widen_4());
-							upper_bound=Bound::Included(dt);
+							best_time=dt;
 							best_transition=Transition::Next(FEV::Vert(vert_id),dt);
 							break;
 						}
@@ -172,9 +119,9 @@ impl<F:Copy,M:MeshQuery<Normal=Vector3<F>,Offset=Fixed<4,128>>> FEV<M>
 					//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 low(&lower_bound,&dt)&&upp(&dt,&upper_bound)&&n.dot(body.extrapolated_velocity_ratio_dt(dt)).is_negative(){
+						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.widen_4(),dt.den.widen_4());
-							upper_bound=Bound::Included(dt);
+							best_time=dt;
 							best_transition=Transition::Next(FEV::Edge(directed_edge_id.as_undirected()),dt);
 							break;
 						}
@@ -185,16 +132,21 @@ impl<F:Copy,M:MeshQuery<Normal=Vector3<F>,Offset=Fixed<4,128>>> FEV<M>
 		}
 		best_transition
 	}
-	pub fn crawl(mut self,mesh:&M,relative_body:&Body,lower_bound:Bound<&Time>,upper_bound:Bound<&Time>)->CrawlResult<M>{
-		let mut lower_bound=lower_bound.map(|&t|into_giga_time(t,relative_body.time));
-		let upper_bound=upper_bound.map(|&t|into_giga_time(t,relative_body.time));
-		println!("crawl begin={self:?}");
+	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.widen_4(),r.den.widen_4())
+		};
+		let time_limit={
+			let r=(time_limit-relative_body.time).to_ratio();
+			Ratio::new(r.num.widen_4(),r.den.widen_4())
+		};
 		for _ in 0..20{
-			let transition=self.next_transition(mesh,relative_body,lower_bound,upper_bound);
+			let transition=self.next_transition(body_time,mesh,relative_body,time_limit);
 			println!("transition={transition:?}");
 			match transition{
 				Transition::Miss=>return CrawlResult::Miss(self),
-				Transition::Next(next_fev,next_time)=>(self,lower_bound)=(next_fev,Bound::Included(next_time)),
+				Transition::Next(next_fev,next_time)=>(self,body_time)=(next_fev,next_time),
 				Transition::Hit(face,time)=>return CrawlResult::Hit(face,time),
 			}
 		}

engine/physics/src/model.rs

@@ -1,5 +1,5 @@
 use std::collections::{HashSet,HashMap};
-use core::ops::{Bound,RangeBounds};
+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};
@@ -68,7 +68,7 @@ pub enum FEV<M:MeshQuery>{
 }
 
 //use Unit32 #[repr(C)] for map files
-#[derive(Clone,Copy,Debug,Hash,Eq,PartialEq)]
+#[derive(Clone,Debug,Hash,Eq,PartialEq)]
 struct Face{
 	normal:Planar64Vec3,
 	dot:Planar64,
@@ -149,12 +149,10 @@ impl From<MeshId> for PhysicsMeshId{
 pub struct PhysicsSubmeshId(u32);
 pub struct PhysicsMesh{
 	data:PhysicsMeshData,
-	// The complete mesh is unused at this time.
-	// complete_mesh:PhysicsMeshTopology,
-	// Submeshes are guaranteed to be convex and may contain
-	// "virtual" faces which are not part of the complete mesh.
-	// Physics calculations should never resolve to hitting
-	// a virtual face.
+	complete_mesh:PhysicsMeshTopology,
+	//Most objects in roblox maps are already convex, so the list length is 0
+	//as soon as the mesh is divided into 2 submeshes, the list length jumps to 2.
+	//length 1 is unnecessary since the complete mesh would be a duplicate of the only submesh, but would still function properly
 	submeshes:Vec<PhysicsMeshTopology>,
 }
 impl PhysicsMesh{
@@ -218,24 +216,19 @@ impl PhysicsMesh{
 		};
 		Self{
 			data,
-			// complete_mesh:mesh_topology.clone(),
-			submeshes:vec![mesh_topology],
+			complete_mesh:mesh_topology,
+			submeshes:Vec::new(),
 		}
 	}
 	pub fn unit_cylinder()->Self{
 		Self::unit_cube()
 	}
 	#[inline]
-	pub fn complete_mesh(&self)->&PhysicsMeshTopology{
-		// If there is exactly one submesh, then the complete mesh is identical to it.
-		if self.submeshes.len()==1{
-			self.submeshes.first().unwrap()
-		}else{
-			panic!("PhysicsMesh complete mesh is not known");
-		}
+	pub const fn complete_mesh(&self)->&PhysicsMeshTopology{
+		&self.complete_mesh
 	}
 	#[inline]
-	pub fn complete_mesh_view(&self)->PhysicsMeshView{
+	pub const fn complete_mesh_view(&self)->PhysicsMeshView{
 		PhysicsMeshView{
 			data:&self.data,
 			topology:self.complete_mesh(),
@@ -243,7 +236,12 @@ impl PhysicsMesh{
 	}
 	#[inline]
 	pub fn submeshes(&self)->&[PhysicsMeshTopology]{
-		&self.submeshes
+		//the complete mesh is already a convex mesh when len()==0, len()==1 is invalid but will still work
+		if self.submeshes.len()==0{
+			std::slice::from_ref(&self.complete_mesh)
+		}else{
+			&self.submeshes.as_slice()
+		}
 	}
 	#[inline]
 	pub fn submesh_view(&self,submesh_id:PhysicsSubmeshId)->PhysicsMeshView{
@@ -321,20 +319,17 @@ impl TryFrom<&model::Mesh> for PhysicsMesh{
 		if mesh.unique_pos.len()==0{
 			return Err(PhysicsMeshError::ZeroVertices);
 		}
-		// An empty physics mesh is a waste of resources
-		if mesh.physics_groups.len()==0{
-			return Err(PhysicsMeshError::NoPhysicsGroups);
-		}
 		let verts=mesh.unique_pos.iter().copied().map(Vert).collect();
+		// TODO: do not hash faces to get face id
+		// meshes can have multiple identical nd representations while still being distinct faces,
+		// especially when the complete mesh is a non-convex mesh.
 		//TODO: fix submeshes
 		//flat map mesh.physics_groups[$1].groups.polys()[$2] as face_id
 		//lower face_id points to upper face_id
 		//the same face is not allowed to be in multiple polygon groups
-		// because SubmeshFaceId -> CompleteMeshFaceId -> SubmeshFaceId is ambiguous
-		// when multiple SubmeshFaceId point to one MeshFaceId
 		let mut faces=Vec::new();
 		let mut face_id_from_face=HashMap::new();
-		let mesh_topologies:Vec<PhysicsMeshTopology>=mesh.physics_groups.iter().map(|physics_group|{
+		let mut mesh_topologies:Vec<PhysicsMeshTopology>=mesh.physics_groups.iter().map(|physics_group|{
 			//construct submesh
 			let mut submesh_faces=Vec::new();//these contain a map from submeshId->meshId
 			let mut submesh_verts=Vec::new();
@@ -395,11 +390,15 @@ impl TryFrom<&model::Mesh> for PhysicsMesh{
 						normal:(normal/len as i64).divide().narrow_1().unwrap(),
 						dot:(dot/(len*len) as i64).narrow_1().unwrap(),
 					};
-					let face_id=*face_id_from_face.entry(face).or_insert_with(||{
-						let face_id=MeshFaceId::new(faces.len() as u32);
-						faces.push(face);
-						face_id
-					});
+					let face_id=match face_id_from_face.get(&face){
+						Some(&face_id)=>face_id,
+						None=>{
+							let face_id=MeshFaceId::new(faces.len() as u32);
+							face_id_from_face.insert(face.clone(),face_id);
+							faces.push(face);
+							face_id
+						}
+					};
 					submesh_faces.push(face_id);
 					face_ref_guys.push(FaceRefEdges(face_edges));
 				}
@@ -407,16 +406,16 @@ impl TryFrom<&model::Mesh> for PhysicsMesh{
 			PhysicsMeshTopology{
 				faces:submesh_faces,
 				verts:submesh_verts,
-				face_topology:face_ref_guys.into_iter().map(|FaceRefEdges(edges)|{
-					FaceRefs{edges}
+				face_topology:face_ref_guys.into_iter().map(|face_ref_guy|{
+					FaceRefs{edges:face_ref_guy.0}
 				}).collect(),
-				edge_topology:edge_pool.edge_guys.into_iter().map(|(EdgeRefVerts(verts),EdgeRefFaces(faces))|
-					EdgeRefs{faces,verts}
+				edge_topology:edge_pool.edge_guys.into_iter().map(|(edge_ref_verts,edge_ref_faces)|
+					EdgeRefs{faces:edge_ref_faces.0,verts:edge_ref_verts.0}
 				).collect(),
-				vert_topology:vert_ref_guys.into_iter().map(|VertRefGuy{edges,faces}|
+				vert_topology:vert_ref_guys.into_iter().map(|vert_ref_guy|
 					VertRefs{
-						edges:edges.into_iter().collect(),
-						faces:faces.into_iter().collect(),
+						edges:vert_ref_guy.edges.into_iter().collect(),
+						faces:vert_ref_guy.faces.into_iter().collect(),
 					}
 				).collect(),
 			}
@@ -426,7 +425,7 @@ impl TryFrom<&model::Mesh> for PhysicsMesh{
 				faces,
 				verts,
 			},
-			// complete_mesh:None,
+			complete_mesh:mesh_topologies.pop().ok_or(PhysicsMeshError::NoPhysicsGroups)?,
 			submeshes:mesh_topologies,
 		})
 	}
@@ -629,10 +628,6 @@ enum EV{
 }
 
 pub type GigaTime=Ratio<Fixed<4,128>,Fixed<4,128>>;
-pub fn into_giga_time(time:Time,relative_to:Time)->GigaTime{
-	let r=(time-relative_to).to_ratio();
-	Ratio::new(r.num.widen_4(),r.den.widen_4())
-}
 
 impl MinkowskiMesh<'_>{
 	pub fn minkowski_sum<'a>(mesh0:TransformedMesh<'a>,mesh1:TransformedMesh<'a>)->MinkowskiMesh<'a>{
@@ -748,46 +743,46 @@ impl MinkowskiMesh<'_>{
 	//
 	// 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:Bound<&Time>)->Option<FEV<MinkowskiMesh>>{
+	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
-			infinity_fev.crawl(self,&infinity_body,Bound::Unbounded,start_time).miss()
+			// TODO: change crawl_fev args to delta time? Optional values?
+			infinity_fev.crawl(self,&infinity_body,Time::MIN/4,start_time).miss()
 		})
 	}
-	pub fn predict_collision_in(&self,relative_body:&Body,range:impl RangeBounds<Time>)->Option<(MinkowskiFace,GigaTime)>{
-		println!("@@@BEGIN SETUP@@@");
-		self.closest_fev_not_inside(relative_body.clone(),range.start_bound()).and_then(|fev|{
-			println!("@@@BEGIN REAL CRAWL@@@");
+	pub fn predict_collision_in(&self,relative_body:&Body,Range{start:start_time,end:time_limit}:Range<Time>)->Option<(MinkowskiFace,GigaTime)>{
+		println!("=== physics setup ===");
+		self.closest_fev_not_inside(relative_body.clone(),start_time).and_then(|fev|{
+			println!("=== physics crawl ===");
 			//continue forwards along the body parabola
-			fev.crawl(self,relative_body,range.start_bound(),range.end_bound()).hit()
+			fev.crawl(self,relative_body,start_time,time_limit).hit()
 		})
 	}
-	pub fn predict_collision_out(&self,relative_body:&Body,range:impl RangeBounds<Time>)->Option<(MinkowskiFace,GigaTime)>{
-		let (lower_bound,upper_bound)=(range.start_bound(),range.end_bound());
-		// swap and negate bounds to do a time inversion
-		let (lower_bound,upper_bound)=(upper_bound.map(|&t|-t),lower_bound.map(|&t|-t));
+	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=-relative_body.clone();
-		self.closest_fev_not_inside(infinity_body,lower_bound.as_ref()).and_then(|fev|{
+		self.closest_fev_not_inside(infinity_body,-time_limit).and_then(|fev|{
 			//continue backwards along the body parabola
-			fev.crawl(self,&infinity_body,lower_bound.as_ref(),upper_bound.as_ref()).hit()
+			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:&Body,range:impl RangeBounds<Time>,contact_face_id:MinkowskiFace)->Option<(MinkowskiDirectedEdge,GigaTime)>{
-		// TODO: make better
-		use crate::face_crawler::{low,upp};
+	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=range.start_bound().map(|&t|{
-			let r=(t-relative_body.time).to_ratio();
+		let start_time={
+			let r=(start_time-relative_body.time).to_ratio();
 			Ratio::new(r.num,r.den)
-		});
-		let mut best_time=range.end_bound().map(|&t|into_giga_time(t,relative_body.time));
+		};
+		let mut best_time={
+			let r=(time_limit-relative_body.time).to_ratio();
+			Ratio::new(r.num.widen_4(),r.den.widen_4())
+		};
 		let mut best_edge=None;
 		let face_n=self.face_nd(contact_face_id).0;
 		for &directed_edge_id in self.face_edges(contact_face_id).as_ref(){
@@ -800,19 +795,18 @@ impl MinkowskiMesh<'_>{
 			//WARNING: truncated precision
 			//wrap for speed
 			for dt in Fixed::<4,128>::zeroes2(((n.dot(relative_body.position))*2-d).wrap_4(),n.dot(relative_body.velocity).wrap_4()*2,n.dot(relative_body.acceleration).wrap_4()){
-				if low(&start_time,&dt)&&upp(&dt,&best_time)&&n.dot(relative_body.extrapolated_velocity_ratio_dt(dt)).is_negative(){
-					best_time=Bound::Included(dt);
-					best_edge=Some((directed_edge_id,dt));
+				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;
 				}
 			}
 		}
-		best_edge
+		best_edge.map(|e|(e.as_undirected(),best_time))
 	}
 	fn infinity_in(&self,infinity_body:Body)->Option<(MinkowskiFace,GigaTime)>{
 		let infinity_fev=self.infinity_fev(-infinity_body.velocity,infinity_body.position);
-		// Bound::Included means that the surface of the mesh is included in the mesh
-		infinity_fev.crawl(self,&infinity_body,Bound::Unbounded,Bound::Included(&infinity_body.time)).hit()
+		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=Body::new(point,vec3::Y,vec3::ZERO,Time::ZERO);
@@ -920,6 +914,7 @@ impl MeshQuery for MinkowskiMesh<'_>{
 				}))
 			},
 			MinkowskiEdge::EdgeVert(e0,v1)=>{
+				println!("MinkowskiEdge::EdgeVert({e0:?},{v1:?})");
 				//tracking index with an external variable because .enumerate() is not available
 				let v1e=self.mesh1.vert_edges(v1);
 				let &[e0f0,e0f1]=self.mesh0.edge_faces(e0).as_ref();
@@ -927,14 +922,18 @@ impl MeshQuery for MinkowskiMesh<'_>{
 					let mut best_edge=None;
 					let mut best_d:Ratio<Fixed<8,256>,Fixed<8,256>>=Ratio::new(Fixed::ZERO,Fixed::ONE);
 					let edge_face0_n=self.mesh0.face_nd(edge_face_id0).0;
+					println!("edge_face0_n={edge_face0_n}");
 					let edge_face0_nn=edge_face0_n.dot(edge_face0_n);
 					for &directed_edge_id1 in v1e.as_ref(){
 						let edge1_n=self.mesh1.directed_edge_n(directed_edge_id1);
+						println!("edge1_n={edge1_n}");
 						let d=edge_face0_n.dot(edge1_n);
+						println!("d={d} {d:?}");
 						if d.is_negative(){
 							let edge1_nn=edge1_n.dot(edge1_n);
 							let dd=(d*d)/(edge_face0_nn*edge1_nn);
-							if best_d<dd{
+							if !dd.den.is_zero()&&best_d<dd{
+								println!("dd={dd:?}");
 								best_d=dd;
 								best_edge=Some(directed_edge_id1);
 							}
@@ -950,10 +949,10 @@ impl MeshQuery for MinkowskiMesh<'_>{
 	}
 	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|
+			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|
+			MinkowskiEdge::EdgeVert(e0,v1)=>(*self.mesh0.edge_verts(e0).as_ref()).map(|vert_id0|
 				MinkowskiVert::VertVert(vert_id0,v1)
 			),
 		})
@@ -963,43 +962,38 @@ impl MeshQuery for MinkowskiMesh<'_>{
 			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_thing=self.mesh0.vert_faces(v0);
-				let v1f_thing=self.mesh1.vert_faces(v1);
-				let v0f=v0f_thing.as_ref();
-				let v1f=v1f_thing.as_ref();
-				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();
-				// scratch vector
-				let mut face_normals=Vec::with_capacity(v0f.len()+v1f.len());
-				face_normals.clone_from(&v0f_n);
+				let v0f=self.mesh0.vert_faces(v0);
+				let v1f=self.mesh1.vert_faces(v1);
+				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
-					// drop faces beyond v0f_n
-					face_normals.truncate(v0f.len());
-					// make a set of faces from mesh0's perspective
+					//make a set of faces
+					let mut face_normals=Vec::with_capacity(the_len);
+					//add mesh0 faces as-is
+					face_normals.clone_from(&v0f_n);
 					for face_n in &v1f_n{
 						//add reflected mesh1 faces
 						//wrap for speed
 						face_normals.push(*face_n-(n*face_n.dot(n)*2/nn).divide().wrap_3());
 					}
-					if is_empty_volume(&face_normals){
+					if is_empty_volume(face_normals){
 						edges.push(MinkowskiDirectedEdge::EdgeVert(directed_edge_id,v1));
 					}
 				}
-				face_normals.clone_from(&v1f_n);
 				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);
-					// drop faces beyond v1f_n
-					face_normals.truncate(v1f.len());
-					// make a set of faces from mesh1's perspective
+					let mut face_normals=Vec::with_capacity(the_len);
+					face_normals.clone_from(&v1f_n);
 					for face_n in &v0f_n{
 						//wrap for speed
 						face_normals.push(*face_n-(n*face_n.dot(n)*2/nn).divide().wrap_3());
 					}
-					if is_empty_volume(&face_normals){
+					if is_empty_volume(face_normals){
 						edges.push(MinkowskiDirectedEdge::VertEdge(v0,directed_edge_id));
 					}
 				}
@@ -1013,7 +1007,7 @@ impl MeshQuery for MinkowskiMesh<'_>{
 	}
 }
 
-fn is_empty_volume(normals:&[Vector3<Fixed<3,96>>])->bool{
+fn is_empty_volume(normals:Vec<Vector3<Fixed<3,96>>>)->bool{
 	let len=normals.len();
 	for i in 0..len-1{
 		for j in i+1..len{
@@ -1039,6 +1033,6 @@ fn is_empty_volume(normals:&[Vector3<Fixed<3,96>>])->bool{
 
 #[test]
 fn test_is_empty_volume(){
-	assert!(!is_empty_volume(&[vec3::X.widen_3(),vec3::Y.widen_3(),vec3::Z.widen_3()]));
-	assert!(is_empty_volume(&[vec3::X.widen_3(),vec3::Y.widen_3(),vec3::Z.widen_3(),vec3::NEG_X.widen_3()]));
+	assert!(!is_empty_volume([vec3::X.widen_3(),vec3::Y.widen_3(),vec3::Z.widen_3()].to_vec()));
+	assert!(is_empty_volume([vec3::X.widen_3(),vec3::Y.widen_3(),vec3::Z.widen_3(),vec3::NEG_X.widen_3()].to_vec()));
 }

engine/physics/src/physics.rs

@@ -107,7 +107,6 @@ enum TransientAcceleration{
 #[derive(Clone,Debug)]
 struct ContactMoveState{
 	jump_direction:JumpDirection,
-	// TODO: this is bad data normalization, remove this
 	contact:ContactCollision,
 	target:TransientAcceleration,
 }
@@ -417,7 +416,7 @@ impl HitboxMesh{
 		}
 	}
 	#[inline]
-	fn transformed_mesh(&self)->TransformedMesh{
+	const fn transformed_mesh(&self)->TransformedMesh{
 		TransformedMesh::new(self.mesh.complete_mesh_view(),&self.transform)
 	}
 }
@@ -602,17 +601,12 @@ impl MoveState{
 	fn cull_velocity(&mut self,velocity:Planar64Vec3,body:&mut Body,touching:&mut TouchingState,models:&PhysicsModels,hitbox_mesh:&HitboxMesh,style:&StyleModifiers,camera:&PhysicsCamera,input_state:&InputState){
 		//TODO: be more precise about contacts
 		if set_velocity_cull(body,touching,models,hitbox_mesh,velocity){
-			// TODO do better
-			// TODO: unduplicate this code
+			//TODO do better
 			match self.get_walk_state(){
-				// did you stop touching the thing you were walking on?
+				//did you stop touching the thing you were walking on?
 				Some(walk_state)=>if !touching.contacts.contains(&walk_state.contact){
 					self.set_move_state(MoveState::Air,body,touching,models,hitbox_mesh,style,camera,input_state);
-				}else{
-					// stopped touching something else while walking
-					self.apply_enum_and_input_and_body(body,touching,models,hitbox_mesh,style,camera,input_state);
 				},
-				// not walking, but stopped touching something
 				None=>self.apply_enum_and_body(body,touching,models,hitbox_mesh,style,camera,input_state),
 			}
 		}
@@ -863,6 +857,12 @@ impl Default for PhysicsState{
 }
 
 impl PhysicsState{
+	pub fn new_at_position(position:Planar64Vec3)->Self{
+		Self{
+			body:Body::new(position,vec3::int(0,0,0),vec3::int(0,-100,0),Time::ZERO),
+			..Self::default()
+		}
+	}
 	pub fn camera_body(&self)->Body{
 		Body{
 			position:self.body.position+self.style.camera_offset,
@@ -988,7 +988,7 @@ impl PhysicsContext<'_>{
 impl PhysicsData{
 	/// use with caution, this is the only non-instruction way to mess with physics
 	pub fn generate_models(&mut self,map:&map::CompleteMap){
-		let modes=map.modes.clone().denormalize();
+		let mut modes=map.modes.clone().denormalize();
 		let mut used_contact_attributes=Vec::new();
 		let mut used_intersect_attributes=Vec::new();
 
@@ -1006,30 +1006,31 @@ impl PhysicsData{
 		let mut used_meshes=Vec::new();
 		let mut physics_mesh_id_from_model_mesh_id=HashMap::<MeshId,PhysicsMeshId>::new();
 		for (model_id,model) in map.models.iter().enumerate(){
-			let attr_id=match physics_attr_id_from_model_attr_id.entry(model.attributes){
-				std::collections::hash_map::Entry::Occupied(entry)=>*entry.get(),
-				std::collections::hash_map::Entry::Vacant(entry)=>{
-					//check if it's real
-					match map.attributes.get(model.attributes.get() as usize).and_then(|m_attr|{
-						PhysicsCollisionAttributes::try_from(m_attr).map_or(None,|p_attr|{
-							let attr_id=match p_attr{
-								PhysicsCollisionAttributes::Contact(attr)=>{
-									let attr_id=ContactAttributesId::new(used_contact_attributes.len() as u32);
-									used_contact_attributes.push(attr);
-									PhysicsAttributesId::Contact(attr_id)
-								},
-								PhysicsCollisionAttributes::Intersect(attr)=>{
-									let attr_id=IntersectAttributesId::new(used_intersect_attributes.len() as u32);
-									used_intersect_attributes.push(attr);
-									PhysicsAttributesId::Intersect(attr_id)
-								},
-							};
-							Some(*entry.insert(attr_id))
-						})
-					}){
-						Some(attr_id)=>attr_id,
-						None=>continue,
-					}
+			//TODO: use .entry().or_insert_with(||{
+			let attr_id=if let Some(&attr_id)=physics_attr_id_from_model_attr_id.get(&model.attributes){
+				attr_id
+			}else{
+				//check if it's real
+				match map.attributes.get(model.attributes.get() as usize).and_then(|m_attr|{
+					PhysicsCollisionAttributes::try_from(m_attr).map_or(None,|p_attr|{
+						let attr_id=match p_attr{
+							PhysicsCollisionAttributes::Contact(attr)=>{
+								let attr_id=ContactAttributesId::new(used_contact_attributes.len() as u32);
+								used_contact_attributes.push(attr);
+								PhysicsAttributesId::Contact(attr_id)
+							},
+							PhysicsCollisionAttributes::Intersect(attr)=>{
+								let attr_id=IntersectAttributesId::new(used_intersect_attributes.len() as u32);
+								used_intersect_attributes.push(attr);
+								PhysicsAttributesId::Intersect(attr_id)
+							},
+						};
+						physics_attr_id_from_model_attr_id.insert(model.attributes,attr_id);
+						Some(attr_id)
+					})
+				}){
+					Some(attr_id)=>attr_id,
+					None=>continue,
 				}
 			};
 			let mesh_id=if let Some(&mesh_id)=physics_mesh_id_from_model_mesh_id.get(&model.mesh){
@@ -1127,7 +1128,7 @@ impl PhysicsData{
 		//JUST POLLING!!! NO MUTATION
 		let mut collector=instruction::InstructionCollector::new(time_limit);
 
-		collector.collect(state.next_move_instruction());
+		// collector.collect(state.next_move_instruction());
 
 		//check for collision ends
 		state.touching.predict_collision_end(&mut collector,&data.models,&data.hitbox_mesh,&state.body,state.time);
@@ -1139,6 +1140,7 @@ impl PhysicsData{
 		//let relative_body=state.body.relative_to(&Body::ZERO);
 		let relative_body=&state.body;
 		data.bvh.sample_aabb(&aabb,&mut |&convex_mesh_id|{
+			println!("sample model={:?}",convex_mesh_id.model_id);
 			//no checks are needed because of the time limits.
 			let model_mesh=data.models.mesh(convex_mesh_id);
 			let minkowski=model_physics::MinkowskiMesh::minkowski_sum(model_mesh,data.hitbox_mesh.transformed_mesh());
@@ -1193,7 +1195,7 @@ fn recalculate_touching(
 		collision_end_contact(move_state,body,touching,models,hitbox_mesh,style,camera,input_state,models.contact_attr(contact.model_id),contact)
 	}
 	while let Some(&intersect)=touching.intersects.iter().next(){
-		collision_end_intersect(move_state,body,touching,models,hitbox_mesh,style,camera,input_state,mode,run,models.intersect_attr(intersect.model_id),intersect,time);
+		collision_end_intersect(touching,mode,run,models.intersect_attr(intersect.model_id),intersect,time);
 	}
 	//find all models in the teleport region
 	let mut aabb=aabb::Aabb::default();
@@ -1605,7 +1607,6 @@ fn collision_start_intersect(
 			None=>(),
 		}
 	}
-	move_state.apply_enum_and_body(body,touching,models,hitbox_mesh,style,camera,input_state);
 	run_teleport_behaviour(intersect.model_id.into(),attr.general.wormhole.as_ref(),mode,move_state,body,touching,run,mode_state,models,hitbox_mesh,bvh,style,camera,input_state,time);
 }
 
@@ -1626,26 +1627,15 @@ fn collision_end_contact(
 	//TODO do better
 	//this is inner code from move_state.cull_velocity
 	match move_state.get_walk_state(){
-		// did you stop touching the thing you were walking on?
+		//did you stop touching the thing you were walking on?
 		Some(walk_state)=>if walk_state.contact==contact{
 			move_state.set_move_state(MoveState::Air,body,touching,models,hitbox_mesh,style,camera,input_state);
-		}else{
-			// stopped touching something else while walking
-			move_state.apply_enum_and_input_and_body(body,touching,models,hitbox_mesh,style,camera,input_state);
 		},
-		// not walking, but stopped touching something
 		None=>move_state.apply_enum_and_body(body,touching,models,hitbox_mesh,style,camera,input_state),
 	}
 }
 fn collision_end_intersect(
-	move_state:&mut MoveState,
-	body:&mut Body,
 	touching:&mut TouchingState,
-	models:&PhysicsModels,
-	hitbox_mesh:&HitboxMesh,
-	style:&StyleModifiers,
-	camera:&PhysicsCamera,
-	input_state:&InputState,
 	mode:Option<&gameplay_modes::Mode>,
 	run:&mut run::Run,
 	_attr:&gameplay_attributes::IntersectAttributes,
@@ -1653,7 +1643,6 @@ fn collision_end_intersect(
 	time:Time,
 ){
 	touching.remove(&Collision::Intersect(intersect));
-	move_state.apply_enum_and_body(body,touching,models,hitbox_mesh,style,camera,input_state);
 	if let Some(mode)=mode{
 		let zone=mode.get_zone(intersect.model_id.into());
 		match zone{
@@ -1683,6 +1672,7 @@ fn atomic_internal_instruction(state:&mut PhysicsState,data:&PhysicsData,ins:Tim
 	}
 		match ins.instruction{
 			InternalInstruction::CollisionStart(collision,_)=>{
+				println!("yeaahhh!");
 				let mode=data.modes.get_mode(state.mode_state.get_mode_id());
 				match collision{
 					Collision::Contact(contact)=>collision_start_contact(
@@ -1710,7 +1700,7 @@ fn atomic_internal_instruction(state:&mut PhysicsState,data:&PhysicsData,ins:Tim
 					contact
 				),
 				Collision::Intersect(intersect)=>collision_end_intersect(
-					&mut state.move_state,&mut state.body,&mut state.touching,&data.models,&data.hitbox_mesh,&state.style,&state.camera,&state.input_state,
+					&mut state.touching,
 					data.modes.get_mode(state.mode_state.get_mode_id()),
 					&mut state.run,
 					data.models.intersect_attr(intersect.model_id),
@@ -1933,15 +1923,6 @@ mod test{
 		),Some(Time::from_secs(2)));
 	}
 	#[test]
-	fn test_collision_small_mv(){
-		test_collision(Body::new(
-			int3(0,5,0),
-			int3(0,-1,0)+(vec3::X>>32),
-			vec3::ZERO,
-			Time::ZERO
-		),Some(Time::from_secs(2)));
-	}
-	#[test]
 	fn test_collision_degenerate_east(){
 		test_collision(Body::new(
 			int3(3,5,0),

integration-testing/src/main.rs

@@ -9,10 +9,37 @@ fn main(){
 	match arg.as_deref(){
 		Some("determinism")|None=>test_determinism().unwrap(),
 		Some("replay")=>run_replay().unwrap(),
+		Some("bug2")=>physics_bug_2().unwrap(),
 		_=>println!("invalid argument"),
 	}
 }
 
+fn physics_bug_2()->Result<(),ReplayError>{
+	println!("loading map file..");
+	let data=read_entire_file("bhop_monster_jam.snfm")?;
+	let map=strafesnet_snf::read_map(data)?.into_complete_map()?;
+
+	// create recording
+	let mut physics_data=PhysicsData::default();
+	println!("generating models..");
+	physics_data.generate_models(&map);
+	println!("simulating...");
+
+	//teleport to bug
+	// body pos = Vector { array: [Fixed { bits: 554895163352 }, Fixed { bits: 1485633089990 }, Fixed { bits: 1279601007173 }] }
+	// after the fix it's still happening, possibly for a different reason, new position to evince:
+	// body pos = Vector { array: [Fixed { bits: 555690659654 }, Fixed { bits: 1490485868773 }, Fixed { bits: 1277783839382 }] }
+	let mut physics=PhysicsState::new_at_position(strafesnet_common::integer::vec3::raw_xyz(555690659654,1490485868773,1277783839382));
+	// wait one second to activate the bug
+	// hit=Some(ModelId(2262))
+	PhysicsContext::run_input_instruction(&mut physics,&physics_data,strafesnet_common::instruction::TimedInstruction{
+		time:strafesnet_common::integer::Time::from_millis(500),
+		instruction:strafesnet_common::physics::Instruction::Idle,
+	});
+
+	Ok(())
+}
+
 #[allow(unused)]
 #[derive(Debug)]
 enum ReplayError{

lib/bsp_loader/Cargo.toml

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

lib/bsp_loader/src/brush.rs

@@ -1,5 +1,5 @@
-use strafesnet_common::integer::Planar64;
-use strafesnet_common::{model,integer};
+use strafesnet_common::integer::{self,Planar64,Planar64Vec3};
+use strafesnet_common::model::{self,VertexId};
 use strafesnet_common::integer::{vec3::Vector3,Fixed,Ratio};
 
 use crate::{valve_transform_normal,valve_transform_dist};
@@ -138,7 +138,15 @@ fn planes_to_faces(face_list:std::collections::HashSet<Face>)->Result<Faces,Plan
 		loop{
 			// push point onto vertices
 			// problem: this may push a vertex that does not fit in the fixed point range and is thus meaningless
-			face.push(intersection.divide().narrow_1().unwrap());
+			//
+			// physics bug 2 originates from vertices being imprecise?
+			//
+			// Mask off the most precise 16 bits so that
+			// when face normals are calculated from
+			// the remaining 16 fractional bits
+			// they never exceed 32 bits of precision.
+			const MASK:Planar64=Planar64::raw(!((1<<16)-1));
+			face.push(intersection.divide().narrow_1().unwrap().map(|c|c&MASK));
 
 			// we looped back around to face1, we're done!
 			if core::ptr::eq(face1,face2){
@@ -204,6 +212,33 @@ impl std::fmt::Display for BrushToMeshError{
 }
 impl core::error::Error for BrushToMeshError{}
 
+fn subdivide_max_area(tris:&mut Vec<Vec<VertexId>>,cw_verts:&[(VertexId,Planar64Vec3)],i0:usize,i2:usize,id0:VertexId,id2:VertexId,v0:Planar64Vec3,v2:Planar64Vec3){
+	if i0+1==i2{
+		return;
+	}
+	let mut best_i1=i0+1;
+	if i0+2<i2{
+		let mut best_area={
+			let (_,v1)=cw_verts[best_i1.rem_euclid(cw_verts.len())];
+			(v2-v0).cross(v1-v0).length_squared()
+		};
+		for i1 in i0+2..=i2-1{
+			let (_,v1)=cw_verts[i1.rem_euclid(cw_verts.len())];
+			let area=(v2-v0).cross(v1-v0).length_squared();
+			if best_area<area{
+				best_i1=i1;
+				best_area=area;
+			}
+		}
+	}
+	let i1=best_i1;
+	let (id1,v1)=cw_verts[i1.rem_euclid(cw_verts.len())];
+	// draw max area first
+	tris.push(vec![id0,id1,id2]);
+	subdivide_max_area(tris,cw_verts,i0,i1,id0,id1,v0,v1);
+	subdivide_max_area(tris,cw_verts,i1,i2,id1,id2,v1,v2);
+}
+
 pub fn faces_to_mesh(faces:Vec<Vec<integer::Planar64Vec3>>)->model::Mesh{
 	// generate the mesh
 	let mut mb=model::MeshBuilder::new();
@@ -212,16 +247,34 @@ pub fn faces_to_mesh(faces:Vec<Vec<integer::Planar64Vec3>>)->model::Mesh{
 	// normals are ignored by physics
 	let normal=mb.acquire_normal_id(integer::vec3::ZERO);
 
-	let polygon_list=faces.into_iter().map(|face|{
-		face.into_iter().map(|pos|{
-			let pos=mb.acquire_pos_id(pos);
-			mb.acquire_vertex_id(model::IndexedVertex{
+	let polygon_list=faces.into_iter().flat_map(|face|{
+		let cw_verts=face.into_iter().map(|position|{
+			let pos=mb.acquire_pos_id(position);
+			(mb.acquire_vertex_id(model::IndexedVertex{
 				pos,
 				tex,
 				normal,
 				color,
-			})
-		}).collect()
+			}),position)
+		}).collect::<Vec<_>>();
+
+		// scan and select maximum area triangle O(n^3)
+		let len=cw_verts.len();
+		let cw_verts=cw_verts.as_slice();
+		let ((i0,i1,i2),(v0,v1,v2))=cw_verts[..len-2].iter().enumerate().flat_map(|(i0,&(_,v0))|
+			cw_verts[i0+1..len-1].iter().enumerate().flat_map(move|(i1,&(_,v1))|
+				cw_verts[i0+i1+2..].iter().enumerate().map(move|(i2,&(_,v2))|((i0,i0+i1+1,i0+i1+i2+2),(v0,v1,v2)))
+			)
+		).max_by_key(|&(_,(v0,v1,v2))|(v2-v0).cross(v1-v0).length_squared()).unwrap();
+		// scan and select more maximum area triangles n * O(n)
+		let mut tris=Vec::with_capacity(len-2);
+		// da big one
+		let (id0,id1,id2)=(cw_verts[i0].0,cw_verts[i1].0,cw_verts[i2].0);
+		tris.push(vec![id0,id1,id2]);
+		subdivide_max_area(&mut tris,cw_verts,i0,i1,id0,id1,v0,v1);
+		subdivide_max_area(&mut tris,cw_verts,i1,i2,id1,id2,v1,v2);
+		subdivide_max_area(&mut tris,cw_verts,i2,i0+len,id2,id0,v2,v0);
+		tris
 	}).collect();
 
 	let polygon_groups=vec![model::PolygonGroup::PolygonList(model::PolygonList::new(polygon_list))];

lib/bsp_loader/src/bsp.rs

@@ -349,7 +349,7 @@ pub struct PartialMap1{
 impl PartialMap1{
 	pub fn add_prop_meshes<'a>(
 		self,
-		prop_meshes:Meshes<model::Mesh>,
+		prop_meshes:Meshes,
 	)->PartialMap2{
 		PartialMap2{
 			attributes:self.attributes,

lib/bsp_loader/src/loader.rs

@@ -22,17 +22,17 @@ impl From<std::io::Error> for TextureError{
 	}
 }
 
-pub struct TextureLoader;
-impl TextureLoader{
+pub struct TextureLoader<'a>(std::marker::PhantomData<&'a ()>);
+impl TextureLoader<'_>{
 	pub fn new()->Self{
-		Self
+		Self(std::marker::PhantomData)
 	}
 }
-impl Loader for TextureLoader{
+impl<'a> Loader for TextureLoader<'a>{
 	type Error=TextureError;
-	type Index<'a>=Cow<'a,str>;
+	type Index=Cow<'a,str>;
 	type Resource=Texture;
-	fn load<'a>(&mut self,index:Self::Index<'a>)->Result<Self::Resource,Self::Error>{
+	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();
@@ -100,24 +100,30 @@ impl<'bsp,'vpk> BspFinder<'bsp,'vpk>{
 	}
 }
 
-pub struct ModelLoader<'bsp,'vpk>{
+pub struct ModelLoader<'bsp,'vpk,'a>{
 	finder:BspFinder<'bsp,'vpk>,
+	life:core::marker::PhantomData<&'a ()>,
 }
-impl ModelLoader<'_,'_>{
+impl ModelLoader<'_,'_,'_>{
 	#[inline]
-	pub const fn new<'bsp,'vpk>(
+	pub const fn new<'bsp,'vpk,'a>(
 		finder:BspFinder<'bsp,'vpk>,
-	)->ModelLoader<'bsp,'vpk>{
+	)->ModelLoader<'bsp,'vpk,'a>{
 		ModelLoader{
 			finder,
+			life:core::marker::PhantomData,
 		}
 	}
 }
-impl<'bsp,'vpk> Loader for ModelLoader<'bsp,'vpk>{
+impl<'bsp,'vpk,'a> Loader for ModelLoader<'bsp,'vpk,'a>
+	where
+		'bsp:'a,
+		'vpk:'a,
+{
 	type Error=MeshError;
-	type Index<'a>=&'a str where Self:'a;
+	type Index=&'a str;
 	type Resource=vmdl::Model;
-	fn load<'a>(&'a mut self,index:Self::Index<'a>)->Result<Self::Resource,Self::Error>{
+	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());
@@ -137,27 +143,31 @@ impl<'bsp,'vpk> Loader for ModelLoader<'bsp,'vpk>{
 	}
 }
 
-pub struct MeshLoader<'bsp,'vpk,'load,'str>{
+pub struct MeshLoader<'bsp,'vpk,'load,'a>{
 	finder:BspFinder<'bsp,'vpk>,
-	deferred_loader:&'load mut strafesnet_deferred_loader::deferred_loader::RenderConfigDeferredLoader<Cow<'str,str>>,
+	deferred_loader:&'load mut strafesnet_deferred_loader::deferred_loader::RenderConfigDeferredLoader<Cow<'a,str>>,
 }
 impl MeshLoader<'_,'_,'_,'_>{
 	#[inline]
-	pub const fn new<'bsp,'vpk,'load,'str>(
+	pub const fn new<'bsp,'vpk,'load,'a>(
 		finder:BspFinder<'bsp,'vpk>,
-		deferred_loader:&'load mut strafesnet_deferred_loader::deferred_loader::RenderConfigDeferredLoader<Cow<'str,str>>,
-	)->MeshLoader<'bsp,'vpk,'load,'str>{
+		deferred_loader:&'load mut strafesnet_deferred_loader::deferred_loader::RenderConfigDeferredLoader<Cow<'a,str>>,
+	)->MeshLoader<'bsp,'vpk,'load,'a>{
 		MeshLoader{
 			finder,
 			deferred_loader
 		}
 	}
 }
-impl<'str,'bsp,'vpk,'load> Loader for MeshLoader<'bsp,'vpk,'load,'str>{
+impl<'bsp,'vpk,'load,'a> Loader for MeshLoader<'bsp,'vpk,'load,'a>
+	where
+		'bsp:'a,
+		'vpk:'a,
+{
 	type Error=MeshError;
-	type Index<'a>=&'a str where Self:'a;
+	type Index=&'a str;
 	type Resource=Mesh;
-	fn load<'a>(&'a mut self,index:Self::Index<'a>)->Result<Self::Resource,Self::Error>{
+	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/common/src/gameplay_modes.rs

@@ -440,11 +440,11 @@ impl ModesBuilder{
 		}
 		NormalizedModes::new(modes.into_iter().map(|mode_builder|NormalizedMode(mode_builder.mode)).collect())
 	}
-	pub fn insert_mode(&mut self,mode_id:ModeId,mode:Mode)->Result<(),ExistingEntryError>{
-		error_if_exists(self.modes.insert(mode_id,mode))
+	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)->Result<(),ExistingEntryError>{
-		error_if_exists(self.stages.entry(mode_id).or_insert(HashMap::new()).insert(stage_id,stage))
+	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));
@@ -453,12 +453,3 @@ impl ModesBuilder{
 	// 	self.stage_updates.push((mode_id,stage_id,stage_update));
 	// }
 }
-
-#[derive(Debug)]
-pub struct ExistingEntryError;
-fn error_if_exists<T>(value:Option<T>)->Result<(),ExistingEntryError>{
-	match value{
-		Some(_)=>Err(ExistingEntryError),
-		None=>Ok(())
-	}
-}

lib/common/src/integer.rs

@@ -1,5 +1,5 @@
 pub use fixed_wide::fixed::*;
-pub use ratio_ops::ratio::{Ratio,Divide,Parity};
+pub use ratio_ops::ratio::{Ratio,Divide};
 
 //integer units
 
@@ -132,21 +132,20 @@ impl<T> std::ops::Mul for Time<T>{
 		Ratio::new(Fixed::raw(self.0)*Fixed::raw(rhs.0),Fixed::raw_digit(1_000_000_000i64.pow(2)))
 	}
 }
-macro_rules! impl_time_i64_rhs_operator {
-	($op:ident,$method:ident)=>{
-		impl<T> core::ops::$op<i64> for Time<T>{
-			type Output=Self;
-			#[inline]
-			fn $method(self,rhs:i64)->Self::Output{
-				Self::raw(self.0.$method(rhs))
-			}
-		}
+impl<T> std::ops::Div<i64> for Time<T>{
+	type Output=Self;
+	#[inline]
+	fn div(self,rhs:i64)->Self::Output{
+		Self::raw(self.0/rhs)
+	}
+}
+impl<T> std::ops::Mul<i64> for Time<T>{
+	type Output=Self;
+	#[inline]
+	fn mul(self,rhs:i64)->Self::Output{
+		Self::raw(self.0*rhs)
 	}
 }
-impl_time_i64_rhs_operator!(Div,div);
-impl_time_i64_rhs_operator!(Mul,mul);
-impl_time_i64_rhs_operator!(Shr,shr);
-impl_time_i64_rhs_operator!(Shl,shl);
 impl<T> core::ops::Mul<Time<T>> for Planar64{
 	type Output=Ratio<Fixed<2,64>,Planar64>;
 	fn mul(self,rhs:Time<T>)->Self::Output{
@@ -402,10 +401,6 @@ impl Angle32{
 	pub const NEG_FRAC_PI_2:Self=Self(-1<<30);
 	pub const PI:Self=Self(-1<<31);
 	#[inline]
-	pub const fn raw(num:i32)->Self{
-		Self(num)
-	}
-	#[inline]
 	pub const fn wrap_from_i64(theta:i64)->Self{
 		//take lower bits
 		//note: this was checked on compiler explorer and compiles to 1 instruction!
@@ -563,10 +558,6 @@ pub mod vec3{
 	pub const MAX:Planar64Vec3=Planar64Vec3::new([Planar64::MAX;3]);
 	pub const ZERO:Planar64Vec3=Planar64Vec3::new([Planar64::ZERO;3]);
 	pub const ZERO_2:linear_ops::types::Vector3<Fixed::<2,64>>=linear_ops::types::Vector3::new([Fixed::<2,64>::ZERO;3]);
-	pub const ZERO_3:linear_ops::types::Vector3<Fixed::<3,96>>=linear_ops::types::Vector3::new([Fixed::<3,96>::ZERO;3]);
-	pub const ZERO_4:linear_ops::types::Vector3<Fixed::<4,128>>=linear_ops::types::Vector3::new([Fixed::<4,128>::ZERO;3]);
-	pub const ZERO_5:linear_ops::types::Vector3<Fixed::<5,160>>=linear_ops::types::Vector3::new([Fixed::<5,160>::ZERO;3]);
-	pub const ZERO_6:linear_ops::types::Vector3<Fixed::<6,192>>=linear_ops::types::Vector3::new([Fixed::<6,192>::ZERO;3]);
 	pub const X:Planar64Vec3=Planar64Vec3::new([Planar64::ONE,Planar64::ZERO,Planar64::ZERO]);
 	pub const Y:Planar64Vec3=Planar64Vec3::new([Planar64::ZERO,Planar64::ONE,Planar64::ZERO]);
 	pub const Z:Planar64Vec3=Planar64Vec3::new([Planar64::ZERO,Planar64::ZERO,Planar64::ONE]);

lib/deferred_loader/src/deferred_loader.rs

@@ -2,7 +2,7 @@ use std::collections::HashMap;
 use crate::loader::Loader;
 use crate::mesh::Meshes;
 use crate::texture::{RenderConfigs,Texture};
-use strafesnet_common::model::{MeshId,RenderConfig,RenderConfigId,TextureId};
+use strafesnet_common::model::{Mesh,MeshId,RenderConfig,RenderConfigId,TextureId};
 
 #[derive(Clone,Copy,Debug)]
 pub enum LoadFailureMode{
@@ -45,7 +45,7 @@ impl<H:core::hash::Hash+Eq> RenderConfigDeferredLoader<H>{
 	pub fn into_indices(self)->impl Iterator<Item=H>{
 		self.render_config_id_from_asset_id.into_keys().flatten()
 	}
-	pub fn into_render_configs<'a,L:Loader<Resource=Texture,Index<'a>=H>+'a>(mut self,loader:&mut L,failure_mode:LoadFailureMode)->Result<RenderConfigs,L::Error>{
+	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];
@@ -93,7 +93,7 @@ impl<H:core::hash::Hash+Eq> MeshDeferredLoader<H>{
 	pub fn into_indices(self)->impl Iterator<Item=H>{
 		self.mesh_id_from_asset_id.into_keys()
 	}
-	pub fn into_meshes<'a,M:Clone,L:Loader<Resource=M,Index<'a>=H>+'a>(self,loader:&mut L,failure_mode:LoadFailureMode)->Result<Meshes<M>,L::Error>{
+	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);

lib/deferred_loader/src/loader.rs

@@ -2,7 +2,7 @@ use std::error::Error;
 
 pub trait Loader{
 	type Error:Error;
-	type Index<'a> where Self:'a;
+	type Index;
 	type Resource;
-	fn load<'a>(&mut self,index:Self::Index<'a>)->Result<Self::Resource,Self::Error>;
+	fn load(&mut self,index:Self::Index)->Result<Self::Resource,Self::Error>;
 }

lib/deferred_loader/src/mesh.rs

@@ -1,15 +1,15 @@
-use strafesnet_common::model::MeshId;
+use strafesnet_common::model::{Mesh,MeshId};
 
-pub struct Meshes<M>{
-	meshes:Vec<Option<M>>,
+pub struct Meshes{
+	meshes:Vec<Option<Mesh>>,
 }
-impl<M> Meshes<M>{
-	pub(crate) const fn new(meshes:Vec<Option<M>>)->Self{
+impl Meshes{
+	pub(crate) const fn new(meshes:Vec<Option<Mesh>>)->Self{
 		Self{
 			meshes,
 		}
 	}
-	pub fn consume(self)->impl Iterator<Item=(MeshId,M)>{
+	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/linear_ops/src/macros/matrix.rs

@@ -204,19 +204,13 @@ macro_rules! impl_matrix_named_fields_shape {
 			type Target=$struct_outer<Vector<$size_inner,T>>;
 			#[inline]
 			fn deref(&self)->&Self::Target{
-				// This cast is valid because Matrix has #[repr(transparent)]
-				let ptr=&self.array as *const [[T;$size_inner];$size_outer] as *const Self::Target;
-				// SAFETY: this pointer is non-null because it comes from a reference
-				unsafe{&*ptr}
+				unsafe{core::mem::transmute(&self.array)}
 			}
 		}
 		impl<T> core::ops::DerefMut for Matrix<$size_outer,$size_inner,T>{
 			#[inline]
 			fn deref_mut(&mut self)->&mut Self::Target{
-				// This cast is valid because Matrix has #[repr(transparent)]
-				let ptr=&mut self.array as *mut [[T;$size_inner];$size_outer] as *mut Self::Target;
-				// SAFETY: this pointer is non-null because it comes from a reference
-				unsafe{&mut*ptr}
+				unsafe{core::mem::transmute(&mut self.array)}
 			}
 		}
 	}

lib/linear_ops/src/macros/vector.rs

@@ -330,19 +330,13 @@ macro_rules! impl_vector_named_fields {
 			type Target=$struct<T>;
 			#[inline]
 			fn deref(&self)->&Self::Target{
-				// This cast is valid because Vector has #[repr(transparent)]
-				let ptr=&self.array as *const [T;$size] as *const Self::Target;
-				// SAFETY: this pointer is non-null because it comes from a reference
-				unsafe{&*ptr}
+				unsafe{core::mem::transmute(&self.array)}
 			}
 		}
 		impl<T> core::ops::DerefMut for Vector<$size,T>{
 			#[inline]
 			fn deref_mut(&mut self)->&mut Self::Target{
-				// This cast is valid because Vector has #[repr(transparent)]
-				let ptr=&mut self.array as *mut [T;$size] as *mut Self::Target;
-				// SAFETY: this pointer is non-null because it comes from a reference
-				unsafe{&mut*ptr}
+				unsafe{core::mem::transmute(&mut self.array)}
 			}
 		}
 	}

lib/rbx_loader/Cargo.toml

@@ -13,12 +13,12 @@ authors = ["Rhys Lloyd <krakow20@gmail.com>"]
 bytemuck = "1.14.3"
 glam = "0.30.0"
 lazy-regex = "3.1.0"
-rbx_binary  = { version = "1.1.0-sn4", registry = "strafesnet" }
-rbx_dom_weak =  { version = "3.1.0-sn4", registry = "strafesnet", features = ["instance-userdata"] }
+rbx_binary = { version = "0.7.4", registry = "strafesnet" }
+rbx_dom_weak = { version = "2.7.0", registry = "strafesnet" }
 rbx_mesh = "0.3.1"
-rbx_reflection_database = "1.0.0"
-rbx_xml  = { version = "1.1.0-sn4", registry = "strafesnet" }
+rbx_reflection_database = { version = "0.2.10", registry = "strafesnet" }
+rbx_xml = { version = "0.13.3", registry = "strafesnet" }
 rbxassetid = { version = "0.1.0", path = "../rbxassetid", registry = "strafesnet" }
-roblox_emulator = { version = "0.5.0", path = "../roblox_emulator", default-features = false, 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,6 +1,5 @@
 use std::io::Read;
 use rbx_dom_weak::WeakDom;
-use roblox_emulator::context::Context;
 use strafesnet_deferred_loader::deferred_loader::{LoadFailureMode,MeshDeferredLoader,RenderConfigDeferredLoader};
 
 mod rbx;
@@ -28,6 +27,12 @@ impl Model{
 	fn new(dom:WeakDom)->Self{
 		Self{dom}
 	}
+	pub fn into_place(self)->Place{
+		let Self{mut dom}=self;
+		let context=roblox_emulator::context::Context::from_mut(&mut dom);
+		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)
 	}
@@ -39,20 +44,23 @@ impl AsRef<WeakDom> for Model{
 }
 
 pub struct Place{
-	context:Context,
+	dom:WeakDom,
+	services:roblox_emulator::context::Services,
 }
 impl Place{
-	pub fn new(dom:WeakDom)->Result<Self,roblox_emulator::context::ServicesError>{
-		let context=Context::from_place(dom)?;
-		Ok(Self{
-			context,
+	pub fn new(dom:WeakDom)->Option<Self>{
+		let context=roblox_emulator::context::Context::from_ref(&dom);
+		Some(Self{
+			services:context.find_services()?,
+			dom,
 		})
 	}
 	pub fn run_scripts(&mut self){
-		let Place{context}=self;
+		let Place{dom,services}=self;
 		let runner=roblox_emulator::runner::Runner::new().unwrap();
+		let context=roblox_emulator::context::Context::from_mut(dom);
 		let scripts=context.scripts();
-		let runnable=runner.runnable_context(context).unwrap();
+		let runnable=runner.runnable_context_with_services(context,services).unwrap();
 		for script in scripts{
 			if let Err(e)=runnable.run_script(script){
 				println!("runner error: {e}");
@@ -65,15 +73,7 @@ impl Place{
 }
 impl AsRef<WeakDom> for Place{
 	fn as_ref(&self)->&WeakDom{
-		self.context.as_ref()
-	}
-}
-impl From<Model> for Place{
-	fn from(model:Model)->Self{
-		let context=Context::from_model(model.dom);
-		Self{
-			context,
-		}
+		&self.dom
 	}
 }
 
@@ -94,9 +94,9 @@ impl std::error::Error for ReadError{}
 pub fn read<R:Read>(input:R)->Result<Model,ReadError>{
 	let mut buf=std::io::BufReader::new(input);
 	let peek=std::io::BufRead::fill_buf(&mut buf).map_err(ReadError::Io)?;
-	match peek.get(0..8){
-		Some(b"<roblox!")=>rbx_binary::from_reader(buf).map(Model::new).map_err(ReadError::RbxBinary),
-		Some(b"<roblox ")=>rbx_xml::from_reader_default(buf).map(Model::new).map_err(ReadError::RbxXml),
+	match &peek[0..8]{
+		b"<roblox!"=>rbx_binary::from_reader(buf).map(Model::new).map_err(ReadError::RbxBinary),
+		b"<roblox "=>rbx_xml::from_reader_default(buf).map(Model::new).map_err(ReadError::RbxXml),
 		_=>Err(ReadError::UnknownFileFormat),
 	}
 }

lib/rbx_loader/src/loader.rs

@@ -4,12 +4,7 @@ use strafesnet_common::model::Mesh;
 use strafesnet_deferred_loader::{loader::Loader,texture::Texture};
 
 use crate::data::RobloxMeshBytes;
-use crate::rbx::RobloxPartDescription;
-
-// disallow non-static lifetimes
-fn static_ustr(s:&'static str)->rbx_dom_weak::Ustr{
-	rbx_dom_weak::ustr(s)
-}
+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)?;
@@ -41,17 +36,17 @@ impl From<RobloxAssetIdParseErr> for TextureError{
 	}
 }
 
-pub struct TextureLoader;
-impl TextureLoader{
+pub struct TextureLoader<'a>(std::marker::PhantomData<&'a ()>);
+impl TextureLoader<'_>{
 	pub fn new()->Self{
-		Self
+		Self(std::marker::PhantomData)
 	}
 }
-impl Loader for TextureLoader{
+impl<'a> Loader for TextureLoader<'a>{
 	type Error=TextureError;
-	type Index<'a>=&'a str;
+	type Index=&'a str;
 	type Resource=Texture;
-	fn load<'a>(&mut self,index:Self::Index<'a>)->Result<Self::Resource,Self::Error>{
+	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)?;
@@ -109,7 +104,7 @@ pub enum MeshType<'a>{
 		mesh_data:&'a [u8],
 		physics_data:&'a [u8],
 		size_float_bits:[u32;3],
-		part_texture_description:RobloxPartDescription,
+		part_texture_description:[Option<RobloxFaceTextureDescription>;6],
 	},
 }
 #[derive(Hash,Eq,PartialEq)]
@@ -129,7 +124,7 @@ impl MeshIndex<'_>{
 		mesh_data:&'a [u8],
 		physics_data:&'a [u8],
 		size:&rbx_dom_weak::types::Vector3,
-		part_texture_description:RobloxPartDescription,
+		part_texture_description:crate::rbx::RobloxPartDescription,
 	)->MeshIndex<'a>{
 		MeshIndex{
 			mesh_type:MeshType::Union{
@@ -143,23 +138,17 @@ impl MeshIndex<'_>{
 	}
 }
 
-#[derive(Clone)]
-pub struct MeshWithSize{
-	pub(crate) mesh:Mesh,
-	pub(crate) size:strafesnet_common::integer::Planar64Vec3,
-}
-
-pub struct MeshLoader;
-impl MeshLoader{
+pub struct MeshLoader<'a>(std::marker::PhantomData<&'a ()>);
+impl MeshLoader<'_>{
 	pub fn new()->Self{
-		Self
+		Self(std::marker::PhantomData)
 	}
 }
-impl Loader for MeshLoader{
+impl<'a> Loader for MeshLoader<'a>{
 	type Error=MeshError;
-	type Index<'a>=MeshIndex<'a>;
-	type Resource=MeshWithSize;
-	fn load<'a>(&mut self,index:Self::Index<'a>)->Result<Self::Resource,Self::Error>{
+	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()?;
@@ -182,12 +171,12 @@ impl Loader for MeshLoader{
 						return Err(MeshError::MissingInstance);
 					};
 					if physics_data.is_empty(){
-						if let Some(rbx_dom_weak::types::Variant::BinaryString(data))=instance.properties.get(&static_ustr("PhysicsData")){
+						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(&static_ustr("MeshData")){
+						if let Some(rbx_dom_weak::types::Variant::BinaryString(data))=instance.properties.get("MeshData"){
 							mesh_data=data.as_ref();
 						}
 					}

lib/rbx_loader/src/mesh.rs

@@ -1,11 +1,7 @@
 use std::collections::HashMap;
 
 use rbx_mesh::mesh::{Vertex2,Vertex2Truncated};
-use strafesnet_common::aabb::Aabb;
-use strafesnet_common::integer::vec3;
-use strafesnet_common::model::{self,ColorId,IndexedVertex,NormalId,PolygonGroup,PolygonList,PositionId,RenderConfigId,TextureCoordinateId,VertexId};
-
-use crate::loader::MeshWithSize;
+use strafesnet_common::{integer::vec3,model::{self,ColorId,IndexedVertex,NormalId,PolygonGroup,PolygonList,PositionId,RenderConfigId,TextureCoordinateId,VertexId}};
 
 #[allow(dead_code)]
 #[derive(Debug)]
@@ -99,7 +95,7 @@ fn ingest_faces2_lods3(
 	))
 }
 
-pub fn convert(roblox_mesh_bytes:crate::data::RobloxMeshBytes)->Result<MeshWithSize,Error>{
+pub fn convert(roblox_mesh_bytes:crate::data::RobloxMeshBytes)->Result<model::Mesh,Error>{
 	//generate that mesh boi
 	let mut unique_pos=Vec::new();
 	let mut pos_id_from=HashMap::new();
@@ -112,10 +108,8 @@ pub fn convert(roblox_mesh_bytes:crate::data::RobloxMeshBytes)->Result<MeshWithS
 	let mut unique_vertices=Vec::new();
 	let mut vertex_id_from=HashMap::new();
 	let mut polygon_groups=Vec::new();
-	let mut aabb=Aabb::default();
 	let mut acquire_pos_id=|pos|{
 		let p=vec3::try_from_f32_array(pos).map_err(Error::Planar64Vec3)?;
-		aabb.grow(p);
 		Ok(PositionId::new(*pos_id_from.entry(p).or_insert_with(||{
 			let pos_id=unique_pos.len();
 			unique_pos.push(p);
@@ -203,7 +197,7 @@ pub fn convert(roblox_mesh_bytes:crate::data::RobloxMeshBytes)->Result<MeshWithS
 			ingest_faces2_lods3(&mut polygon_groups,&vertex_id_map,&mesh.faces,&mesh.lods);
 		},
 	}
-	let mesh=model::Mesh{
+	Ok(model::Mesh{
 		unique_pos,
 		unique_normal,
 		unique_tex,
@@ -219,6 +213,5 @@ pub fn convert(roblox_mesh_bytes:crate::data::RobloxMeshBytes)->Result<MeshWithS
 		}],
 		//disable physics
 		physics_groups:Vec::new(),
-	};
-	Ok(MeshWithSize{mesh,size:aabb.size()})
+	})
 }

lib/rbx_loader/src/primitives.rs

@@ -1,6 +1,5 @@
-use crate::rbx::{RobloxPartDescription,RobloxWedgeDescription,RobloxCornerWedgeDescription};
-use strafesnet_common::model::{Color4,TextureCoordinate,Mesh,MeshBuilder,IndexedGraphicsGroup,IndexedPhysicsGroup,IndexedVertex,PolygonGroupId,PolygonGroup,PolygonList,PositionId,TextureCoordinateId,NormalId,ColorId,VertexId,RenderConfigId};
-use strafesnet_common::integer::{vec3,Planar64,Planar64Vec3};
+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)]
 pub enum Primitives{
@@ -10,22 +9,7 @@ pub enum Primitives{
 	Wedge,
 	CornerWedge,
 }
-#[derive(Debug)]
-pub struct PrimitivesError;
-impl TryFrom<u32> for Primitives{
-	type Error=PrimitivesError;
-	fn try_from(value:u32)->Result<Self,Self::Error>{
-		match value{
-			0=>Ok(Primitives::Sphere),
-			1=>Ok(Primitives::Cube),
-			2=>Ok(Primitives::Cylinder),
-			3=>Ok(Primitives::Wedge),
-			4=>Ok(Primitives::CornerWedge),
-			_=>Err(PrimitivesError),
-		}
-	}
-}
-#[derive(Clone,Copy,Hash,PartialEq,Eq)]
+#[derive(Hash,PartialEq,Eq)]
 pub enum CubeFace{
 	Right,
 	Top,
@@ -34,29 +18,13 @@ pub enum CubeFace{
 	Bottom,
 	Front,
 }
-#[derive(Debug)]
-pub struct CubeFaceError;
-impl TryFrom<u32> for CubeFace{
-	type Error=CubeFaceError;
-	fn try_from(value:u32)->Result<Self,Self::Error>{
-		match value{
-			0=>Ok(CubeFace::Right),
-			1=>Ok(CubeFace::Top),
-			2=>Ok(CubeFace::Back),
-			3=>Ok(CubeFace::Left),
-			4=>Ok(CubeFace::Bottom),
-			5=>Ok(CubeFace::Front),
-			_=>Err(CubeFaceError),
-		}
-	}
-}
 const CUBE_DEFAULT_TEXTURE_COORDS:[TextureCoordinate;4]=[
 	TextureCoordinate::new(0.0,0.0),
 	TextureCoordinate::new(1.0,0.0),
 	TextureCoordinate::new(1.0,1.0),
 	TextureCoordinate::new(0.0,1.0),
 ];
-pub const CUBE_DEFAULT_VERTICES:[Planar64Vec3;8]=[
+const CUBE_DEFAULT_VERTICES:[Planar64Vec3;8]=[
 	vec3::int(-1,-1, 1),//0 left bottom back
 	vec3::int( 1,-1, 1),//1 right bottom back
 	vec3::int( 1, 1, 1),//2 right top back
@@ -66,7 +34,7 @@ pub const CUBE_DEFAULT_VERTICES:[Planar64Vec3;8]=[
 	vec3::int( 1,-1,-1),//6 right bottom front
 	vec3::int(-1,-1,-1),//7 left bottom front
 ];
-pub const CUBE_DEFAULT_NORMALS:[Planar64Vec3;6]=[
+const CUBE_DEFAULT_NORMALS:[Planar64Vec3;6]=[
 	vec3::int( 1, 0, 0),//CubeFace::Right
 	vec3::int( 0, 1, 0),//CubeFace::Top
 	vec3::int( 0, 0, 1),//CubeFace::Back
@@ -75,36 +43,103 @@ pub const CUBE_DEFAULT_NORMALS:[Planar64Vec3;6]=[
 	vec3::int( 0, 0,-1),//CubeFace::Front
 ];
 
-pub struct CubeFaceDescription([FaceDescription;Self::FACES]);
+#[derive(Hash,PartialEq,Eq)]
+pub enum WedgeFace{
+	Right,
+	TopFront,
+	Back,
+	Left,
+	Bottom,
+}
+const WEDGE_DEFAULT_NORMALS:[Planar64Vec3;5]=[
+	vec3::int( 1, 0, 0),//Wedge::Right
+	vec3::int( 0, 1,-1),//Wedge::TopFront
+	vec3::int( 0, 0, 1),//Wedge::Back
+	vec3::int(-1, 0, 0),//Wedge::Left
+	vec3::int( 0,-1, 0),//Wedge::Bottom
+];
+/*
+local cornerWedgeVerticies = {
+	Vector3.new(-1/2,-1/2,-1/2),7
+	Vector3.new(-1/2,-1/2, 1/2),0
+	Vector3.new( 1/2,-1/2,-1/2),6
+	Vector3.new( 1/2,-1/2, 1/2),1
+	Vector3.new( 1/2, 1/2,-1/2),5
+}
+*/
+#[derive(Hash,PartialEq,Eq)]
+pub enum CornerWedgeFace{
+	Right,
+	TopBack,
+	TopLeft,
+	Bottom,
+	Front,
+}
+const CORNERWEDGE_DEFAULT_NORMALS:[Planar64Vec3;5]=[
+	vec3::int( 1, 0, 0),//CornerWedge::Right
+	vec3::int( 0, 1, 1),//CornerWedge::BackTop
+	vec3::int(-1, 1, 0),//CornerWedge::LeftTop
+	vec3::int( 0,-1, 0),//CornerWedge::Bottom
+	vec3::int( 0, 0,-1),//CornerWedge::Front
+];
+#[derive(Default)]
+pub struct CubeFaceDescription([Option<FaceDescription>;6]);
 impl CubeFaceDescription{
-	pub const FACES:usize=6;
-	pub fn new(RobloxPartDescription(part_description):RobloxPartDescription,textureless_render_id:RenderConfigId)->Self{
-		Self(part_description.map(|face_description|match face_description{
-			Some(roblox_texture_transform)=>roblox_texture_transform.to_face_description(),
-			None=>FaceDescription::new_with_render_id(textureless_render_id),
-		}))
+	pub fn insert(&mut self,index:CubeFace,value:FaceDescription){
+		self.0[index as usize]=Some(value);
+	}
+	pub fn pairs(self)->impl Iterator<Item=(usize,FaceDescription)>{
+		self.0.into_iter().enumerate().filter_map(|(i,v)|v.map(|u|(i,u)))
 	}
 }
-pub struct WedgeFaceDescription([FaceDescription;Self::FACES]);
+pub fn unit_cube(render:RenderConfigId)->Mesh{
+	let mut t=CubeFaceDescription::default();
+	t.insert(CubeFace::Right,FaceDescription::new_with_render_id(render));
+	t.insert(CubeFace::Top,FaceDescription::new_with_render_id(render));
+	t.insert(CubeFace::Back,FaceDescription::new_with_render_id(render));
+	t.insert(CubeFace::Left,FaceDescription::new_with_render_id(render));
+	t.insert(CubeFace::Bottom,FaceDescription::new_with_render_id(render));
+	t.insert(CubeFace::Front,FaceDescription::new_with_render_id(render));
+	generate_partial_unit_cube(t)
+}
+#[derive(Default)]
+pub struct WedgeFaceDescription([Option<FaceDescription>;5]);
 impl WedgeFaceDescription{
-	pub const FACES:usize=5;
-	pub fn new(RobloxWedgeDescription(part_description):RobloxWedgeDescription,textureless_render_id:RenderConfigId)->Self{
-		Self(part_description.map(|face_description|match face_description{
-			Some(roblox_texture_transform)=>roblox_texture_transform.to_face_description(),
-			None=>FaceDescription::new_with_render_id(textureless_render_id),
-		}))
+	pub fn insert(&mut self,index:WedgeFace,value:FaceDescription){
+		self.0[index as usize]=Some(value);
+	}
+	pub fn pairs(self)->std::iter::FilterMap<std::iter::Enumerate<std::array::IntoIter<Option<FaceDescription>,5>>,impl FnMut((usize,Option<FaceDescription>))->Option<(usize,FaceDescription)>>{
+		self.0.into_iter().enumerate().filter_map(|v|v.1.map(|u|(v.0,u)))
 	}
 }
-pub struct CornerWedgeFaceDescription([FaceDescription;Self::FACES]);
+// 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{
-	pub const FACES:usize=5;
-	pub fn new(RobloxCornerWedgeDescription(part_description):RobloxCornerWedgeDescription,textureless_render_id:RenderConfigId)->Self{
-		Self(part_description.map(|face_description|match face_description{
-			Some(roblox_texture_transform)=>roblox_texture_transform.to_face_description(),
-			None=>FaceDescription::new_with_render_id(textureless_render_id),
-		}))
+	pub fn insert(&mut self,index:CornerWedgeFace,value:FaceDescription){
+		self.0[index as usize]=Some(value);
+	}
+	pub fn pairs(self)->std::iter::FilterMap<std::iter::Enumerate<std::array::IntoIter<Option<FaceDescription>,5>>,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 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{
@@ -113,7 +148,7 @@ pub struct FaceDescription{
 	pub color:Color4,
 }
 impl FaceDescription{
-	pub fn new_with_render_id(render:RenderConfigId)->Self{
+	pub fn new_with_render_id(render:RenderConfigId)->Self {
 		Self{
 			render,
 			transform:glam::Affine2::IDENTITY,
@@ -121,51 +156,51 @@ impl FaceDescription{
 		}
 	}
 }
-pub const CUBE_DEFAULT_POLYS:[[[u32;2];4];6]=[
+pub fn generate_partial_unit_cube(face_descriptions:CubeFaceDescription)->Mesh{
+	const CUBE_DEFAULT_POLYS:[[[u32;3];4];6]=[
 		// right (1, 0, 0)
 		[
-			[6,2],//[vertex,tex]
-			[5,1],
-			[2,0],
-			[1,3],
+			[6,2,0],//[vertex,tex,norm]
+			[5,1,0],
+			[2,0,0],
+			[1,3,0],
 		],
 		// top (0, 1, 0)
 		[
-			[5,3],
-			[4,2],
-			[3,1],
-			[2,0],
+			[5,3,1],
+			[4,2,1],
+			[3,1,1],
+			[2,0,1],
 		],
 		// back (0, 0, 1)
 		[
-			[0,3],
-			[1,2],
-			[2,1],
-			[3,0],
+			[0,3,2],
+			[1,2,2],
+			[2,1,2],
+			[3,0,2],
 		],
 		// left (-1, 0, 0)
 		[
-			[0,2],
-			[3,1],
-			[4,0],
-			[7,3],
+			[0,2,3],
+			[3,1,3],
+			[4,0,3],
+			[7,3,3],
 		],
 		// bottom (0,-1, 0)
 		[
-			[1,1],
-			[0,0],
-			[7,3],
-			[6,2],
+			[1,1,4],
+			[0,0,4],
+			[7,3,4],
+			[6,2,4],
 		],
 		// front (0, 0,-1)
 		[
-			[4,1],
-			[5,0],
-			[6,3],
-			[7,2],
+			[4,1,5],
+			[5,0,5],
+			[6,3,5],
+			[7,2,5],
 		],
 	];
-pub fn unit_cube(CubeFaceDescription(face_descriptions):CubeFaceDescription)->Mesh{
 	let mut generated_pos=Vec::new();
 	let mut generated_tex=Vec::new();
 	let mut generated_normal=Vec::new();
@@ -176,7 +211,7 @@ pub fn unit_cube(CubeFaceDescription(face_descriptions):CubeFaceDescription)->Me
 	let mut physics_group=IndexedPhysicsGroup::default();
 	let mut transforms=Vec::new();
 	//note that on a cube every vertex is guaranteed to be unique, so there's no need to hash them against existing vertices.
-	for (face_id,face_description) in face_descriptions.into_iter().enumerate(){
+	for (face_id,face_description) in face_descriptions.pairs(){
 		//assume that scanning short lists is faster than hashing.
 		let transform_index=if let Some(transform_index)=transforms.iter().position(|&transform|transform==face_description.transform){
 			transform_index
@@ -203,8 +238,8 @@ pub fn unit_cube(CubeFaceDescription(face_descriptions):CubeFaceDescription)->Me
 		//push vertices as they are needed
 		let group_id=PolygonGroupId::new(polygon_groups.len() as u32);
 		polygon_groups.push(PolygonGroup::PolygonList(PolygonList::new(vec![
-			CUBE_DEFAULT_POLYS[face_id].map(|[pos_id,tex_id]|{
-				let pos=CUBE_DEFAULT_VERTICES[pos_id as usize];
+			CUBE_DEFAULT_POLYS[face_id].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
 				}else{
@@ -216,7 +251,7 @@ pub fn unit_cube(CubeFaceDescription(face_descriptions):CubeFaceDescription)->Me
 				//always push vertex
 				let vertex=IndexedVertex{
 					pos:PositionId::new(pos_index),
-					tex:TextureCoordinateId::new(tex_id+4*transform_index),
+					tex:TextureCoordinateId::new(tup[1]+4*transform_index),
 					normal:NormalId::new(normal_index),
 					color:ColorId::new(color_index),
 				};
@@ -243,49 +278,42 @@ pub fn unit_cube(CubeFaceDescription(face_descriptions):CubeFaceDescription)->Me
 	}
 }
 //don't think too hard about the copy paste because this is all going into the map tool eventually...
-pub fn unit_wedge(WedgeFaceDescription(face_descriptions):WedgeFaceDescription)->Mesh{
-	const WEDGE_DEFAULT_POLYS:[&[[u32;2]];5]=[
+pub fn generate_partial_unit_wedge(face_descriptions:WedgeFaceDescription)->Mesh{
+	const WEDGE_DEFAULT_POLYS:[&[[u32;3]];5]=[
 		// right (1, 0, 0)
 		&[
-			[6,2],//[vertex,tex]
-			[2,0],
-			[1,3],
+			[6,2,0],//[vertex,tex,norm]
+			[2,0,0],
+			[1,3,0],
 		],
 		// FrontTop (0, 1, -1)
 		&[
-			[3,1],
-			[2,0],
-			[6,3],
-			[7,2],
+			[3,1,1],
+			[2,0,1],
+			[6,3,1],
+			[7,2,1],
 		],
 		// back (0, 0, 1)
 		&[
-			[0,3],
-			[1,2],
-			[2,1],
-			[3,0],
+			[0,3,2],
+			[1,2,2],
+			[2,1,2],
+			[3,0,2],
 		],
 		// left (-1, 0, 0)
 		&[
-			[0,2],
-			[3,1],
-			[7,3],
+			[0,2,3],
+			[3,1,3],
+			[7,3,3],
 		],
 		// bottom (0,-1, 0)
 		&[
-			[1,1],
-			[0,0],
-			[7,3],
-			[6,2],
+			[1,1,4],
+			[0,0,4],
+			[7,3,4],
+			[6,2,4],
 		],
 	];
-	const WEDGE_DEFAULT_NORMALS:[Planar64Vec3;5]=[
-		vec3::int( 1, 0, 0),//Wedge::Right
-		vec3::int( 0, 1,-1),//Wedge::TopFront
-		vec3::int( 0, 0, 1),//Wedge::Back
-		vec3::int(-1, 0, 0),//Wedge::Left
-		vec3::int( 0,-1, 0),//Wedge::Bottom
-	];
 	let mut generated_pos=Vec::new();
 	let mut generated_tex=Vec::new();
 	let mut generated_normal=Vec::new();
@@ -296,7 +324,7 @@ pub fn unit_wedge(WedgeFaceDescription(face_descriptions):WedgeFaceDescription)-
 	let mut physics_group=IndexedPhysicsGroup::default();
 	let mut transforms=Vec::new();
 	//note that on a cube every vertex is guaranteed to be unique, so there's no need to hash them against existing vertices.
-	for (face_id,face_description) in face_descriptions.into_iter().enumerate(){
+	for (face_id,face_description) in face_descriptions.pairs(){
 		//assume that scanning short lists is faster than hashing.
 		let transform_index=if let Some(transform_index)=transforms.iter().position(|&transform|transform==face_description.transform){
 			transform_index
@@ -323,8 +351,8 @@ pub fn unit_wedge(WedgeFaceDescription(face_descriptions):WedgeFaceDescription)-
 		//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(|&[pos_id,tex_id]|{
-				let pos=CUBE_DEFAULT_VERTICES[pos_id as usize];
+			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
 				}else{
@@ -336,7 +364,7 @@ pub fn unit_wedge(WedgeFaceDescription(face_descriptions):WedgeFaceDescription)-
 				//always push vertex
 				let vertex=IndexedVertex{
 					pos:PositionId::new(pos_index),
-					tex:TextureCoordinateId::new(tex_id+4*transform_index),
+					tex:TextureCoordinateId::new(tup[1]+4*transform_index),
 					normal:NormalId::new(normal_index),
 					color:ColorId::new(color_index),
 				};
@@ -363,47 +391,40 @@ pub fn unit_wedge(WedgeFaceDescription(face_descriptions):WedgeFaceDescription)-
 	}
 }
 
-pub fn unit_cornerwedge(CornerWedgeFaceDescription(face_descriptions):CornerWedgeFaceDescription)->Mesh{
-	const CORNERWEDGE_DEFAULT_POLYS:[&[[u32;2]];5]=[
+pub fn generate_partial_unit_cornerwedge(face_descriptions:CornerWedgeFaceDescription)->Mesh{
+	const CORNERWEDGE_DEFAULT_POLYS:[&[[u32;3]];5]=[
 		// right (1, 0, 0)
 		&[
-			[6,2],//[vertex,tex]
-			[5,1],
-			[1,3],
+			[6,2,0],//[vertex,tex,norm]
+			[5,1,0],
+			[1,3,0],
 		],
 		// BackTop (0, 1, 1)
 		&[
-			[5,3],
-			[0,1],
-			[1,0],
+			[5,3,1],
+			[0,1,1],
+			[1,0,1],
 		],
 		// LeftTop (-1, 1, 0)
 		&[
-			[5,3],
-			[7,2],
-			[0,1],
+			[5,3,2],
+			[7,2,2],
+			[0,1,2],
 		],
 		// bottom (0,-1, 0)
 		&[
-			[1,1],
-			[0,0],
-			[7,3],
-			[6,2],
+			[1,1,3],
+			[0,0,3],
+			[7,3,3],
+			[6,2,3],
 		],
 		// front (0, 0,-1)
 		&[
-			[5,0],
-			[6,3],
-			[7,2],
+			[5,0,4],
+			[6,3,4],
+			[7,2,4],
 		],
 	];
-	const CORNERWEDGE_DEFAULT_NORMALS:[Planar64Vec3;5]=[
-		vec3::int( 1, 0, 0),//CornerWedge::Right
-		vec3::int( 0, 1, 1),//CornerWedge::BackTop
-		vec3::int(-1, 1, 0),//CornerWedge::LeftTop
-		vec3::int( 0,-1, 0),//CornerWedge::Bottom
-		vec3::int( 0, 0,-1),//CornerWedge::Front
-	];
 	let mut generated_pos=Vec::new();
 	let mut generated_tex=Vec::new();
 	let mut generated_normal=Vec::new();
@@ -414,7 +435,7 @@ pub fn unit_cornerwedge(CornerWedgeFaceDescription(face_descriptions):CornerWedg
 	let mut physics_group=IndexedPhysicsGroup::default();
 	let mut transforms=Vec::new();
 	//note that on a cube every vertex is guaranteed to be unique, so there's no need to hash them against existing vertices.
-	for (face_id,face_description) in face_descriptions.into_iter().enumerate(){
+	for (face_id,face_description) in face_descriptions.pairs(){
 		//assume that scanning short lists is faster than hashing.
 		let transform_index=if let Some(transform_index)=transforms.iter().position(|&transform|transform==face_description.transform){
 			transform_index
@@ -441,8 +462,8 @@ pub fn unit_cornerwedge(CornerWedgeFaceDescription(face_descriptions):CornerWedg
 		//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(|&[pos_id,tex_id]|{
-				let pos=CUBE_DEFAULT_VERTICES[pos_id as usize];
+			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
 				}else{
@@ -454,7 +475,7 @@ pub fn unit_cornerwedge(CornerWedgeFaceDescription(face_descriptions):CornerWedg
 				//always push vertex
 				let vertex=IndexedVertex{
 					pos:PositionId::new(pos_index),
-					tex:TextureCoordinateId::new(tex_id+4*transform_index),
+					tex:TextureCoordinateId::new(tup[1]+4*transform_index),
 					normal:NormalId::new(normal_index),
 					color:ColorId::new(color_index),
 				};
@@ -480,133 +501,3 @@ pub fn unit_cornerwedge(CornerWedgeFaceDescription(face_descriptions):CornerWedg
 		physics_groups:vec![physics_group],
 	}
 }
-
-// TODO: fix face texture orientation
-pub fn unit_cylinder(face_descriptions:CubeFaceDescription)->Mesh{
-	// cylinder is oriented about the x axis
-	// roblox cylinders use projected grid coordinates
-	/// how many grid coordinates to use (positive and negative)
-	const GON:i32=3;
-	/// grid perimeter
-	const POINTS:[[i32;2];4*2*GON as usize]=const{
-		let mut points=[[0;2];{4*2*GON as usize}];
-		let mut i=-GON;
-		while i<GON{
-			points[(i+GON) as usize]=[i,GON];
-			points[(i+GON+1*2*GON) as usize]=[GON,-i];
-			points[(i+GON+2*2*GON) as usize]=[-i,-GON];
-			points[(i+GON+3*2*GON) as usize]=[-GON,i];
-			i+=1;
-		}
-		points
-	};
-
-	let mut mb=MeshBuilder::new();
-	let mut polygon_groups=Vec::with_capacity(CubeFaceDescription::FACES);
-	let mut graphics_groups=Vec::with_capacity(CubeFaceDescription::FACES);
-	let mut physics_group=IndexedPhysicsGroup{groups:Vec::with_capacity(CubeFaceDescription::FACES)};
-	let CubeFaceDescription([right,top,back,left,bottom,front])=face_descriptions;
-
-	macro_rules! end_face{
-		($face_description:expr,$end:expr,$iter:expr)=>{
-			let normal=mb.acquire_normal_id($end);
-			let color=mb.acquire_color_id($face_description.color);
-
-			// single polygon for physics
-			let polygon:Vec<_>=$iter.map(|[x,y]|{
-				let tex=mb.acquire_tex_id(
-					$face_description.transform.transform_point2(
-						(glam::vec2(-x as f32,y as f32).normalize()+1.0)/2.0
-					)
-				);
-				let pos=mb.acquire_pos_id($end+vec3::int(0,-x,y).with_length(Planar64::ONE).divide().wrap_1());
-				mb.acquire_vertex_id(IndexedVertex{pos,tex,normal,color})
-			}).collect();
-
-			// fanned polygons for graphics
-			let pos=mb.acquire_pos_id($end);
-			let tex=mb.acquire_tex_id($face_description.transform.transform_point2(glam::Vec2::ONE/2.0));
-			let center=mb.acquire_vertex_id(IndexedVertex{pos,tex,normal,color});
-			let polygon_list=(0..POINTS.len()).map(|i|
-				vec![center,polygon[i],polygon[(i+1)%POINTS.len()]]
-			).collect();
-
-			// end face graphics
-			let group_id=PolygonGroupId::new(polygon_groups.len() as u32);
-			polygon_groups.push(PolygonGroup::PolygonList(PolygonList::new(polygon_list)));
-			graphics_groups.push(IndexedGraphicsGroup{
-				render:$face_description.render,
-				groups:vec![group_id],
-			});
-
-			// end face physics
-			let polygon_list=vec![polygon];
-
-			let group_id=PolygonGroupId::new(polygon_groups.len() as u32);
-			polygon_groups.push(PolygonGroup::PolygonList(PolygonList::new(polygon_list)));
-			physics_group.groups.push(group_id);
-		}
-	}
-	macro_rules! tex{
-		($face_description:expr,$tex:expr)=>{{
-			let [x,y]=$tex;
-			$face_description.transform.transform_point2(
-				glam::vec2((x+GON) as f32,(y+GON) as f32)/(2*GON) as f32
-			)
-		}};
-	}
-	macro_rules! barrel_face{
-		($face_description:expr,$loop:ident,$lo_dir:expr,$hi_dir:expr,$tex_0:expr,$tex_1:expr,$tex_2:expr,$tex_3:expr)=>{
-			let mut polygon_list=Vec::with_capacity(CubeFaceDescription::FACES);
-			for $loop in -GON..GON{
-				// lo Z
-				let lz_dir=$lo_dir.with_length(Planar64::ONE).divide().wrap_1();
-				// hi Z
-				let hz_dir=$hi_dir.with_length(Planar64::ONE).divide().wrap_1();
-
-				// pos
-				let lx_lz_pos=mb.acquire_pos_id(vec3::NEG_X+lz_dir);
-				let lx_hz_pos=mb.acquire_pos_id(vec3::NEG_X+hz_dir);
-				let hx_hz_pos=mb.acquire_pos_id(vec3::X+hz_dir);
-				let hx_lz_pos=mb.acquire_pos_id(vec3::X+lz_dir);
-				// tex
-				let lx_lz_tex=mb.acquire_tex_id(tex!($face_description,$tex_0));
-				let lx_hz_tex=mb.acquire_tex_id(tex!($face_description,$tex_1));
-				let hx_hz_tex=mb.acquire_tex_id(tex!($face_description,$tex_2));
-				let hx_lz_tex=mb.acquire_tex_id(tex!($face_description,$tex_3));
-				// norm
-				let lz_norm=mb.acquire_normal_id(lz_dir);
-				let hz_norm=mb.acquire_normal_id(hz_dir);
-				// color
-				let color=mb.acquire_color_id($face_description.color);
-
-				polygon_list.push(vec![
-					mb.acquire_vertex_id(IndexedVertex{pos:lx_lz_pos,tex:lx_lz_tex,normal:lz_norm,color}),
-					mb.acquire_vertex_id(IndexedVertex{pos:lx_hz_pos,tex:lx_hz_tex,normal:hz_norm,color}),
-					mb.acquire_vertex_id(IndexedVertex{pos:hx_hz_pos,tex:hx_hz_tex,normal:hz_norm,color}),
-					mb.acquire_vertex_id(IndexedVertex{pos:hx_lz_pos,tex:hx_lz_tex,normal:lz_norm,color}),
-				]);
-			}
-
-			// push face
-			let group_id=PolygonGroupId::new(polygon_groups.len() as u32);
-			polygon_groups.push(PolygonGroup::PolygonList(PolygonList::new(polygon_list)));
-			graphics_groups.push(IndexedGraphicsGroup{
-				render:$face_description.render,
-				groups:vec![group_id],
-			});
-			physics_group.groups.push(group_id);
-		};
-	}
-
-	end_face!(right, vec3::X,POINTS.into_iter());
-	barrel_face!(top, z,vec3::int(0,GON,z),vec3::int(0,GON,z+1), [GON,z],[GON,z+1],[-GON,z+1],[-GON,z]);
-	barrel_face!(back, y,vec3::int(0,y+1,GON),vec3::int(0,y,GON), [GON,y+1],[GON,y],[-GON,y],[-GON,y+1]);
-	end_face!(left, vec3::NEG_X,POINTS.into_iter().rev());
-	barrel_face!(bottom, z,vec3::int(0,-GON,z+1),vec3::int(0,-GON,z), [-GON,z+1],[-GON,z],[GON,z],[GON,z+1]);
-	barrel_face!(front, y,vec3::int(0,y,-GON),vec3::int(0,y+1,-GON), [-GON,y],[-GON,y+1],[GON,y+1],[GON,y]);
-
-	let physics_groups=vec![physics_group];
-
-	mb.build(polygon_groups,graphics_groups,physics_groups)
-}

lib/rbx_loader/src/rbx.rs

@@ -1,6 +1,7 @@
 use std::collections::HashMap;
-use crate::loader::{MeshWithSize,MeshIndex};
-use crate::primitives::{self,CubeFace,CubeFaceDescription,WedgeFaceDescription,CornerWedgeFaceDescription,FaceDescription,Primitives};
+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::{NormalizedModes,Mode,ModeId,ModeUpdate,ModesBuilder,Stage,StageElement,StageElementBehaviour,StageId,Zone};
@@ -12,30 +13,31 @@ use strafesnet_deferred_loader::deferred_loader::{RenderConfigDeferredLoader,Mes
 use strafesnet_deferred_loader::mesh::Meshes;
 use strafesnet_deferred_loader::texture::{RenderConfigs,Texture};
 
-// disallow non-static lifetimes
-fn static_ustr(s:&'static str)->rbx_dom_weak::Ustr{
-	rbx_dom_weak::ustr(s)
+fn class_is_a(class: &str, superclass: &str) -> bool {
+	if class==superclass {
+		return true
+	}
+	let class_descriptor=rbx_reflection_database::get().classes.get(class);
+	if let Some(descriptor) = &class_descriptor {
+		if let Some(class_super) = &descriptor.superclass {
+			return class_is_a(&class_super, superclass)
+		}
+	}
+	false
 }
-
-fn recursive_collect_superclass(
-	objects:&mut std::vec::Vec<rbx_dom_weak::types::Ref>,
-	dom:&rbx_dom_weak::WeakDom,
-	instance:&rbx_dom_weak::Instance,
-	superclass:&str
-){
-	let instance=instance;
-	let db=rbx_reflection_database::get();
-	let Some(superclass)=db.classes.get(superclass)else{
-		return;
-	};
-	objects.extend(
-		dom.descendants_of(instance.referent()).filter_map(|instance|{
-			let class=db.classes.get(instance.class.as_str())?;
-			db.has_superclass(class,superclass).then(||instance.referent())
-		})
-	);
+fn recursive_collect_superclass(objects: &mut std::vec::Vec<rbx_dom_weak::types::Ref>,dom: &rbx_dom_weak::WeakDom, instance: &rbx_dom_weak::Instance, superclass: &str){
+	let mut stack=vec![instance];
+	while let Some(item)=stack.pop(){
+		for &referent in item.children(){
+			if let Some(c)=dom.get_by_ref(referent){
+				if class_is_a(c.class.as_str(),superclass){
+					objects.push(c.referent());//copy ref
+				}
+				stack.push(c);
+			}
+		}
+	}
 }
-
 fn planar64_affine3_from_roblox(cf:&rbx_dom_weak::types::CFrame,size:&rbx_dom_weak::types::Vector3)->Planar64Affine3{
 	Planar64Affine3::new(
 		Planar64Mat3::from_cols([
@@ -56,19 +58,15 @@ fn get_attributes(name:&str,can_collide:bool,velocity:Planar64Vec3,model_id:mode
 	let mut contacting=attr::ContactingAttributes::default();
 	let mut force_can_collide=can_collide;
 	let mut force_intersecting=false;
-	let mut allow_booster=true;
 	match name{
 		"Water"=>{
 			force_can_collide=false;
-			allow_booster=false;
 			//TODO: read stupid CustomPhysicalProperties
 			intersecting.water=Some(attr::IntersectingWater{density:Planar64::ONE,viscosity:Planar64::ONE/10,velocity});
 		},
 		"Accelerator"=>{
 			//although the new game supports collidable accelerators, this is a roblox compatability map loader
 			force_can_collide=false;
-			// Accelerator is not allowed to be booster in roblox
-			allow_booster=false;
 			general.accelerator=Some(attr::Accelerator{acceleration:velocity});
 		},
 		// "UnorderedCheckpoint"=>general.teleport_behaviour=Some(model::TeleportBehaviour::StageElement(attr::StageElement{
@@ -77,10 +75,7 @@ fn get_attributes(name:&str,can_collide:bool,velocity:Planar64Vec3,model_id:mode
 		// 	force:false,
 		// 	behaviour:model::StageElementBehaviour::Unordered
 		// })),
-		"SetVelocity"=>{
-			allow_booster=false;
-			general.trajectory=Some(attr::SetTrajectory::Velocity(velocity));
-		},
+		"SetVelocity"=>general.trajectory=Some(attr::SetTrajectory::Velocity(velocity)),
 		"MapStart"=>{
 			force_can_collide=false;
 			force_intersecting=true;
@@ -90,7 +85,7 @@ fn get_attributes(name:&str,can_collide:bool,velocity:Planar64Vec3,model_id:mode
 					gameplay_style::StyleModifiers::roblox_bhop(),
 					model_id
 				)
-			).unwrap();
+			);
 		},
 		"MapFinish"=>{
 			force_can_collide=false;
@@ -136,7 +131,7 @@ fn get_attributes(name:&str,can_collide:bool,velocity:Planar64Vec3,model_id:mode
 								gameplay_style::StyleModifiers::roblox_bhop(),
 								model_id
 							)
-						).unwrap();
+						);
 					},
 					"WormholeOut"=>{
 						//the PhysicsModelId has to exist for it to be teleported to!
@@ -165,7 +160,7 @@ fn get_attributes(name:&str,can_collide:bool,velocity:Planar64Vec3,model_id:mode
 								ModeId::MAIN,
 								stage_id,
 								Stage::empty(model_id),
-							).unwrap();
+							);
 							//TODO: let denormalize handle this
 							StageElementBehaviour::SpawnAt
 						},
@@ -240,7 +235,7 @@ fn get_attributes(name:&str,can_collide:bool,velocity:Planar64Vec3,model_id:mode
 		}
 	}
 	//need some way to skip this
-	if allow_booster&&velocity!=vec3::ZERO{
+	if velocity!=vec3::ZERO{
 		general.booster=Some(attr::Booster::Velocity(velocity));
 	}
 	match force_can_collide{
@@ -352,40 +347,17 @@ impl RobloxFaceTextureDescription{
 			transform:self.transform.to_bits(),
 		}
 	}
-	pub fn to_face_description(&self)->FaceDescription{
-		FaceDescription{
+	pub fn to_face_description(&self)->primitives::FaceDescription{
+		primitives::FaceDescription{
 			render:self.render,
 			transform:self.transform.affine(),
 			color:self.color,
 		}
 	}
 }
-macro_rules! impl_description_index{
-	($description:ident,$index:ty)=>{
-		impl core::ops::Index<$index> for $description{
-			type Output=Option<RobloxFaceTextureDescription>;
-			fn index(&self,index:$index)->&Self::Output{
-				&self.0[index as usize]
-			}
-		}
-		impl core::ops::IndexMut<$index> for $description{
-			fn index_mut(&mut self,index:$index)->&mut Self::Output{
-				&mut self.0[index as usize]
-			}
-		}
-	};
-}
-
-#[derive(Clone,Default,Eq,Hash,PartialEq)]
-pub struct RobloxPartDescription(pub(crate)[Option<RobloxFaceTextureDescription>;6]);
-impl_description_index!(RobloxPartDescription,CubeFace);
-
-#[derive(Clone,Default,Eq,Hash,PartialEq)]
-pub struct RobloxWedgeDescription(pub(crate)[Option<RobloxFaceTextureDescription>;5]);
-
-#[derive(Clone,Default,Eq,Hash,PartialEq)]
-pub struct RobloxCornerWedgeDescription(pub(crate)[Option<RobloxFaceTextureDescription>;5]);
-
+pub type RobloxPartDescription=[Option<RobloxFaceTextureDescription>;6];
+type RobloxWedgeDescription=[Option<RobloxFaceTextureDescription>;5];
+type RobloxCornerWedgeDescription=[Option<RobloxFaceTextureDescription>;5];
 #[derive(Clone,Eq,Hash,PartialEq)]
 enum RobloxBasePartDescription{
 	Sphere(RobloxPartDescription),
@@ -394,18 +366,6 @@ enum RobloxBasePartDescription{
 	Wedge(RobloxWedgeDescription),
 	CornerWedge(RobloxCornerWedgeDescription),
 }
-
-// TODO: initialize all ustrs in a top level struct thrown around as a reference
-// struct UstrKludge{
-// }
-
-fn get_content_url(content:&rbx_dom_weak::types::Content)->Option<&str>{
-	match content.value(){
-		rbx_dom_weak::types::ContentType::Uri(uri)=>Some(uri.as_str()),
-		_=>None,
-	}
-}
-
 fn get_texture_description<'a>(
 	temp_objects:&mut Vec<rbx_dom_weak::types::Ref>,
 	render_config_deferred_loader:&mut RenderConfigDeferredLoader<&'a str>,
@@ -414,86 +374,80 @@ fn get_texture_description<'a>(
 	size:&rbx_dom_weak::types::Vector3,
 )->RobloxPartDescription{
 	//use the biggest one and cut it down later...
-	let mut part_texture_description=RobloxPartDescription::default();
+	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{
-		let Some(decal)=dom.get_by_ref(decal_ref) else{
-			println!("Decal get_by_ref failed");
-			continue;
-		};
-		let (
+	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(&static_ustr("TextureContent")),
-			decal.properties.get(&static_ustr("Face")),
-			decal.properties.get(&static_ustr("Color3")),
-			decal.properties.get(&static_ustr("Transparency")),
-		)else{
-			println!("Decal is missing a required property");
-			continue;
-		};
-		let texture_id=match content.value(){
-			rbx_dom_weak::types::ContentType::Uri(uri)=>Some(uri.as_str()),
-			_=>None,
-		};
-		let render_id=render_config_deferred_loader.acquire_render_config_id(texture_id);
-		let Ok(cube_face)=normalid.to_u32().try_into()else{
-			println!("NormalId is invalid");
-			continue;
-		};
-		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(&static_ustr("OffsetStudsU")),
-					decal.properties.get(&static_ustr("OffsetStudsV")),
-					decal.properties.get(&static_ustr("StudsPerTileU")),
-					decal.properties.get(&static_ustr("StudsPerTileV")),
-				)
-			{
-				let (size_u,size_v)=match cube_face{
-					CubeFace::Right=>(size.z,size.y),//right
-					CubeFace::Top=>(size.x,size.z),//top
-					CubeFace::Back=>(size.x,size.y),//back
-					CubeFace::Left=>(size.z,size.y),//left
-					CubeFace::Bottom=>(size.x,size.z),//bottom
-					CubeFace::Front=>(size.x,size.y),//front
-				};
-				(
-					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())
+		) = (
+			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);
+				}
 			}
-		}else{
-			(glam::Vec4::ONE,RobloxTextureTransform::identity())
-		};
-		part_texture_description[cube_face]=Some(RobloxFaceTextureDescription{
-			render:render_id,
-			color:roblox_texture_color,
-			transform:roblox_texture_transform,
-		});
+		}
 	}
 	part_texture_description
 }
 enum Shape{
-	Primitive(Primitives),
+	Primitive(primitives::Primitives),
 	MeshPart,
 	PhysicsData,
 }
@@ -554,12 +508,12 @@ pub fn convert<'a>(
 					Some(rbx_dom_weak::types::Variant::Color3uint8(color3)),
 					Some(rbx_dom_weak::types::Variant::Bool(can_collide)),
 				) = (
-					object.properties.get(&static_ustr("CFrame")),
-					object.properties.get(&static_ustr("Size")),
-					object.properties.get(&static_ustr("Velocity")),
-					object.properties.get(&static_ustr("Transparency")),
-					object.properties.get(&static_ustr("Color")),
-					object.properties.get(&static_ustr("CanCollide")),
+					object.properties.get("CFrame"),
+					object.properties.get("Size"),
+					object.properties.get("Velocity"),
+					object.properties.get("Transparency"),
+					object.properties.get("Color"),
+					object.properties.get("CanCollide"),
 				)
 			{
 				let model_transform=planar64_affine3_from_roblox(cf,size);
@@ -578,19 +532,26 @@ pub fn convert<'a>(
 
 				//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(&static_ustr("Shape")){
-						Shape::Primitive(shape.to_u32().try_into().expect("Funky roblox PartType"))
+					"Part"=>if let Some(rbx_dom_weak::types::Variant::Enum(shape))=object.properties.get("Shape"){
+						Shape::Primitive(match shape.to_u32(){
+							0=>primitives::Primitives::Sphere,
+							1=>primitives::Primitives::Cube,
+							2=>primitives::Primitives::Cylinder,
+							3=>primitives::Primitives::Wedge,
+							4=>primitives::Primitives::CornerWedge,
+							other=>panic!("Funky roblox PartType={};",other),
+						})
 					}else{
 						panic!("Part has no Shape!");
 					},
-					"TrussPart"=>Shape::Primitive(Primitives::Cube),
-					"WedgePart"=>Shape::Primitive(Primitives::Wedge),
-					"CornerWedgePart"=>Shape::Primitive(Primitives::CornerWedge),
+					"TrussPart"=>Shape::Primitive(primitives::Primitives::Cube),
+					"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::Cube)
+						Shape::Primitive(primitives::Primitives::Cube)
 					}
 				};
 
@@ -599,34 +560,34 @@ pub fn convert<'a>(
 				//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 RobloxPartDescription([
+				let [
 					f0,//Cube::Right
 					f1,//Cube::Top
 					f2,//Cube::Back
 					f3,//Cube::Left
 					f4,//Cube::Bottom
 					f5,//Cube::Front
-				])=part_texture_description;
+				]=part_texture_description;
 				let basepart_description=match primitive_shape{
-					Primitives::Sphere=>RobloxBasePartDescription::Sphere(RobloxPartDescription([f0,f1,f2,f3,f4,f5])),
-					Primitives::Cube=>RobloxBasePartDescription::Part(RobloxPartDescription([f0,f1,f2,f3,f4,f5])),
-					Primitives::Cylinder=>RobloxBasePartDescription::Cylinder(RobloxPartDescription([f0,f1,f2,f3,f4,f5])),
+					primitives::Primitives::Sphere=>RobloxBasePartDescription::Sphere([f0,f1,f2,f3,f4,f5]),
+					primitives::Primitives::Cube=>RobloxBasePartDescription::Part([f0,f1,f2,f3,f4,f5]),
+					primitives::Primitives::Cylinder=>RobloxBasePartDescription::Cylinder([f0,f1,f2,f3,f4,f5]),
 					//use front face texture first and use top face texture as a fallback
-					Primitives::Wedge=>RobloxBasePartDescription::Wedge(RobloxWedgeDescription([
+					primitives::Primitives::Wedge=>RobloxBasePartDescription::Wedge([
 						f0,//Cube::Right->Wedge::Right
 						f5.or(f1),//Cube::Front|Cube::Top->Wedge::TopFront
 						f2,//Cube::Back->Wedge::Back
 						f3,//Cube::Left->Wedge::Left
 						f4,//Cube::Bottom->Wedge::Bottom
-					])),
+					]),
 					//TODO: fix Left+Back texture coordinates to match roblox when not overwridden by Top
-					Primitives::CornerWedge=>RobloxBasePartDescription::CornerWedge(RobloxCornerWedgeDescription([
+					primitives::Primitives::CornerWedge=>RobloxBasePartDescription::CornerWedge([
 						f0,//Cube::Right->CornerWedge::Right
 						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
-					])),
+					]),
 				};
 				//make new model if unit cube has not been created before
 				let mesh_id=if let Some(&mesh_id)=mesh_id_from_description.get(&basepart_description){
@@ -636,11 +597,66 @@ pub fn convert<'a>(
 					let mesh_id=model::MeshId::new(primitive_meshes.len() as u32);
 					mesh_id_from_description.insert(basepart_description.clone(),mesh_id);//borrow checker going crazy
 					let mesh=match basepart_description{
-						RobloxBasePartDescription::Cylinder(part_texture_description)=>primitives::unit_cylinder(CubeFaceDescription::new(part_texture_description,textureless_render_group)),
 						RobloxBasePartDescription::Sphere(part_texture_description)
-						|RobloxBasePartDescription::Part(part_texture_description)=>primitives::unit_cube(CubeFaceDescription::new(part_texture_description,textureless_render_group)),
-						RobloxBasePartDescription::Wedge(wedge_texture_description)=>primitives::unit_wedge(WedgeFaceDescription::new(wedge_texture_description,textureless_render_group)),
-						RobloxBasePartDescription::CornerWedge(cornerwedge_texture_description)=>primitives::unit_cornerwedge(CornerWedgeFaceDescription::new(cornerwedge_texture_description,textureless_render_group)),
+						|RobloxBasePartDescription::Cylinder(part_texture_description)
+						|RobloxBasePartDescription::Part(part_texture_description)=>{
+							let mut cube_face_description=primitives::CubeFaceDescription::default();
+							for (face_id,roblox_face_description) in part_texture_description.iter().enumerate(){
+								cube_face_description.insert(
+								match face_id{
+									0=>primitives::CubeFace::Right,
+									1=>primitives::CubeFace::Top,
+									2=>primitives::CubeFace::Back,
+									3=>primitives::CubeFace::Left,
+									4=>primitives::CubeFace::Bottom,
+									5=>primitives::CubeFace::Front,
+									_=>unreachable!(),
+								},
+								match roblox_face_description{
+									Some(roblox_texture_transform)=>roblox_texture_transform.to_face_description(),
+									None=>primitives::FaceDescription::new_with_render_id(textureless_render_group),
+								});
+							}
+							primitives::generate_partial_unit_cube(cube_face_description)
+						},
+						RobloxBasePartDescription::Wedge(wedge_texture_description)=>{
+							let mut wedge_face_description=primitives::WedgeFaceDescription::default();
+							for (face_id,roblox_face_description) in wedge_texture_description.iter().enumerate(){
+								wedge_face_description.insert(
+								match face_id{
+									0=>primitives::WedgeFace::Right,
+									1=>primitives::WedgeFace::TopFront,
+									2=>primitives::WedgeFace::Back,
+									3=>primitives::WedgeFace::Left,
+									4=>primitives::WedgeFace::Bottom,
+									_=>unreachable!(),
+								},
+								match roblox_face_description{
+									Some(roblox_texture_transform)=>roblox_texture_transform.to_face_description(),
+									None=>primitives::FaceDescription::new_with_render_id(textureless_render_group),
+								});
+							}
+							primitives::generate_partial_unit_wedge(wedge_face_description)
+						},
+						RobloxBasePartDescription::CornerWedge(cornerwedge_texture_description)=>{
+							let mut cornerwedge_face_description=primitives::CornerWedgeFaceDescription::default();
+							for (face_id,roblox_face_description) in cornerwedge_texture_description.iter().enumerate(){
+								cornerwedge_face_description.insert(
+								match face_id{
+									0=>primitives::CornerWedgeFace::Right,
+									1=>primitives::CornerWedgeFace::TopBack,
+									2=>primitives::CornerWedgeFace::TopLeft,
+									3=>primitives::CornerWedgeFace::Bottom,
+									4=>primitives::CornerWedgeFace::Front,
+									_=>unreachable!(),
+								},
+								match roblox_face_description{
+									Some(roblox_texture_transform)=>roblox_texture_transform.to_face_description(),
+									None=>primitives::FaceDescription::new_with_render_id(textureless_render_group),
+								});
+							}
+							primitives::generate_partial_unit_cornerwedge(cornerwedge_face_description)
+						},
 					};
 					primitive_meshes.push(mesh);
 					mesh_id
@@ -648,19 +664,15 @@ pub fn convert<'a>(
 				(MeshAvailability::Immediate,mesh_id)
 					},
 					Shape::MeshPart=>if let (
-						Some(rbx_dom_weak::types::Variant::Content(mesh_content)),
-						Some(rbx_dom_weak::types::Variant::Content(texture_content)),
+						Some(rbx_dom_weak::types::Variant::Content(mesh_asset_id)),
+						Some(rbx_dom_weak::types::Variant::Content(texture_asset_id)),
 					)=(
-						// mesh must exist
-						object.properties.get(&static_ustr("MeshContent")),
-						// texture is allowed to be none
-						object.properties.get(&static_ustr("TextureContent")),
+						object.properties.get("MeshId"),
+						object.properties.get("TextureID"),
 					){
-						let mesh_asset_id=get_content_url(mesh_content).unwrap_or_default();
-						let texture_asset_id=get_content_url(texture_content);
 						(
-							MeshAvailability::DeferredMesh(render_config_deferred_loader.acquire_render_config_id(texture_asset_id)),
-							mesh_deferred_loader.acquire_mesh_id(MeshIndex::file_mesh(mesh_asset_id)),
+							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");
@@ -669,13 +681,13 @@ pub fn convert<'a>(
 						let mut content="";
 						let mut mesh_data:&[u8]=&[];
 						let mut physics_data:&[u8]=&[];
-						if let Some(rbx_dom_weak::types::Variant::ContentId(asset_id))=object.properties.get(&static_ustr("AssetId")){
+						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(&static_ustr("MeshData")){
+						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(&static_ustr("PhysicsData")){
+						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);
@@ -715,23 +727,23 @@ pub fn convert<'a>(
 		deferred_unions_deferred_attributes,
 	}
 }
-struct MeshIdWithSize{
-	mesh:model::MeshId,
-	size:Planar64Vec3,
+struct MeshWithAabb{
+	mesh:model::Mesh,
+	aabb:Aabb,
 }
 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,MeshWithSize>,
+	loaded_meshes:&'a HashMap<model::MeshId,MeshWithAabb>,
 	old_mesh_id:model::MeshId,
 	render:RenderConfigId,
-)->Option<MeshIdWithSize>{
+)->Option<(model::MeshId,&'a Aabb)>{
 	//ignore meshes that fail to load completely for now
-	loaded_meshes.get(&old_mesh_id).map(|&MeshWithSize{ref mesh,size}|MeshIdWithSize{
-		mesh:*mesh_id_from_render_config_id.entry(old_mesh_id).or_insert_with(||HashMap::new())
+	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.clone();
+			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;
@@ -739,24 +751,24 @@ fn acquire_mesh_id_from_render_config_id<'a>(
 			primitive_meshes.push(mesh_clone);
 			mesh_id
 		}),
-		size,
-	})
+		&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,MeshWithSize>,
+	loaded_meshes:&'a HashMap<model::MeshId,MeshWithAabb>,
 	old_union_id:model::MeshId,
 	part_texture_description:RobloxPartDescription,
-)->Option<MeshIdWithSize>{
+)->Option<(model::MeshId,&'a Aabb)>{
 	//ignore uniones that fail to load completely for now
-	loaded_meshes.get(&old_union_id).map(|&MeshWithSize{ref mesh,size}|MeshIdWithSize{
-		mesh:*union_id_from_render_config_id.entry(old_union_id).or_insert_with(||HashMap::new())
+	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=mesh.clone();
+			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.0){
+			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;
 				}
@@ -764,8 +776,8 @@ fn acquire_union_id_from_render_config_id<'a>(
 			primitive_meshes.push(union_clone);
 			union_id
 		}),
-		size,
-	})
+		&union_with_aabb.aabb,
+	))
 }
 pub struct PartialMap1<'a>{
 	primitive_meshes:Vec<model::Mesh>,
@@ -776,7 +788,7 @@ pub struct PartialMap1<'a>{
 impl PartialMap1<'_>{
 	pub fn add_meshpart_meshes_and_calculate_attributes(
 		mut self,
-		meshpart_meshes:Meshes<MeshWithSize>,
+		meshpart_meshes:Meshes,
 	)->PartialMap2{
 		//calculate attributes
 		let mut modes_builder=ModesBuilder::default();
@@ -788,8 +800,17 @@ impl PartialMap1<'_>{
 
 		//decode roblox meshes
 		//generate mesh_id_map based on meshes that failed to load
-		let loaded_meshes:HashMap<model::MeshId,MeshWithSize>=
-		meshpart_meshes.consume().collect();
+		let loaded_meshes:HashMap<model::MeshId,MeshWithAabb>=
+		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);
+			}
+			(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
@@ -802,22 +823,23 @@ impl PartialMap1<'_>{
 		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 MeshIdWithSize{mesh,size:mesh_size}=acquire_mesh_id_from_render_config_id(
+			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
 			)?;
+			let size=aabb.size();
 			Some(ModelDeferredAttributes{
 				mesh,
 				deferred_attributes:deferred_model_deferred_attributes.model.deferred_attributes,
 				color:deferred_model_deferred_attributes.model.color,
 				transform:Planar64Affine3::new(
 					Planar64Mat3::from_cols([
-						(deferred_model_deferred_attributes.model.transform.matrix3.x_axis*2/mesh_size.x).divide().narrow_1().unwrap(),
-						(deferred_model_deferred_attributes.model.transform.matrix3.y_axis*2/mesh_size.y).divide().narrow_1().unwrap(),
-						(deferred_model_deferred_attributes.model.transform.matrix3.z_axis*2/mesh_size.z).divide().narrow_1().unwrap(),
+						(deferred_model_deferred_attributes.model.transform.matrix3.x_axis*2/size.x).divide().narrow_1().unwrap(),
+						(deferred_model_deferred_attributes.model.transform.matrix3.y_axis*2/size.y).divide().narrow_1().unwrap(),
+						(deferred_model_deferred_attributes.model.transform.matrix3.z_axis*2/size.z).divide().narrow_1().unwrap(),
 					]),
 					deferred_model_deferred_attributes.model.transform.translation
 				),
@@ -825,13 +847,14 @@ impl PartialMap1<'_>{
 		}).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 MeshIdWithSize{mesh,size}=acquire_union_id_from_render_config_id(
+			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,

lib/rbx_loader/src/union.rs

@@ -1,9 +1,4 @@
-use crate::loader::MeshWithSize;
-use crate::rbx::RobloxPartDescription;
-use crate::primitives::{CUBE_DEFAULT_VERTICES,CUBE_DEFAULT_POLYS};
-
-use rbx_mesh::mesh_data::{VertexId as MeshDataVertexId,NormalId2 as MeshDataNormalId2};
-use rbx_mesh::physics_data::VertexId as PhysicsDataVertexId;
+use rbx_mesh::mesh_data::NormalId2 as MeshDataNormalId2;
 use strafesnet_common::model::{self,IndexedVertex,PolygonGroup,PolygonGroupId,PolygonList,RenderConfigId};
 use strafesnet_common::integer::vec3;
 
@@ -61,10 +56,10 @@ pub fn convert(
 	roblox_physics_data:&[u8],
 	roblox_mesh_data:&[u8],
 	size:glam::Vec3,
-	RobloxPartDescription(part_texture_description):RobloxPartDescription,
-)->Result<MeshWithSize,Error>{
+	part_texture_description:crate::rbx::RobloxPartDescription,
+)->Result<model::Mesh,Error>{
 	const NORMAL_FACES:usize=6;
-	let mut polygon_groups_normal_id:[_;NORMAL_FACES]=[vec![],vec![],vec![],vec![],vec![],vec![]];
+	let mut polygon_groups_normal_id=vec![Vec::new();NORMAL_FACES];
 
 	// build graphics and physics meshes
 	let mut mb=strafesnet_common::model::MeshBuilder::new();
@@ -84,26 +79,16 @@ pub fn convert(
 			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,
 		};
-		//autoscale to size, idk what roblox is doing with the graphics mesh size
-		let mut pos_min=glam::Vec3::MAX;
-		let mut pos_max=glam::Vec3::MIN;
-		for vertex in &graphics_mesh.vertices{
-			let p=vertex.pos.into();
-			pos_min=pos_min.min(p);
-			pos_max=pos_max.max(p);
-		}
-		let graphics_size=pos_max-pos_min;
-		for [MeshDataVertexId(vertex_id0),MeshDataVertexId(vertex_id1),MeshDataVertexId(vertex_id2)] in graphics_mesh.faces{
+		for [vertex_id0,vertex_id1,vertex_id2] in graphics_mesh.faces{
 			let face=[
-				graphics_mesh.vertices.get(vertex_id0 as usize).ok_or(Error::MissingVertexId(vertex_id0))?,
-				graphics_mesh.vertices.get(vertex_id1 as usize).ok_or(Error::MissingVertexId(vertex_id1))?,
-				graphics_mesh.vertices.get(vertex_id2 as usize).ok_or(Error::MissingVertexId(vertex_id2))?,
+				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=glam::Vec3::from_array(vertex.pos)/graphics_size;
-				let pos=mb.acquire_pos_id(vec3::try_from_f32_array(pos.to_array())?);
+				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];
@@ -140,11 +125,7 @@ pub fn convert(
 	};
 
 	//physics
-	let polygon_groups_normal_it=polygon_groups_normal_id.into_iter().map(|faces|
-		// graphics polygon groups (to be rendered)
-		Ok(PolygonGroup::PolygonList(PolygonList::new(faces)))
-	);
-	let polygon_groups:Vec<PolygonGroup>=if !roblox_physics_data.is_empty(){
+	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)?;
@@ -158,48 +139,39 @@ pub fn convert(
 			rbx_mesh::physics_data::PhysicsData::CSGPHS(rbx_mesh::physics_data::CSGPHS::PhysicsInfoMesh(pim))
 			=>vec![pim.mesh],
 		};
-		let physics_convex_meshes_it=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(|[PhysicsDataVertexId(vertex_id0),PhysicsDataVertexId(vertex_id1),PhysicsDataVertexId(vertex_id2)]|{
-				let face=[
-					mesh.vertices.get(vertex_id0 as usize).ok_or(Error::MissingVertexId(vertex_id0))?,
-					mesh.vertices.get(vertex_id1 as usize).ok_or(Error::MissingVertexId(vertex_id1))?,
-					mesh.vertices.get(vertex_id2 as usize).ok_or(Error::MissingVertexId(vertex_id2))?,
-				].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<_,_>>()?)))
-		});
-		polygon_groups_normal_it.chain(physics_convex_meshes_it).collect::<Result<_,_>>()?
+		physics_convex_meshes
 	}else{
-		// generate a unit cube as default physics
-		let pos_list=CUBE_DEFAULT_VERTICES.map(|pos|mb.acquire_pos_id(pos>>1));
-		let tex=mb.acquire_tex_id(glam::Vec2::ZERO);
-		let normal=mb.acquire_normal_id(vec3::ZERO);
-		let color=mb.acquire_color_id(glam::Vec4::ONE);
-		let polygon_group=PolygonGroup::PolygonList(PolygonList::new(CUBE_DEFAULT_POLYS.map(|poly|poly.map(|[pos_id,_]|
-			mb.acquire_vertex_id(IndexedVertex{pos:pos_list[pos_id as usize],tex,normal,color})
-		).to_vec()).to_vec()));
-		polygon_groups_normal_it.chain([Ok(polygon_group)]).collect::<Result<_,_>>()?
+		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();
-	let mesh=mb.build(
+	Ok(mb.build(
 		polygon_groups,
 		graphics_groups,
 		physics_groups,
-	);
-	Ok(MeshWithSize{
-		mesh,
-		size:vec3::ONE,
-	})
+	))
 }

lib/roblox_emulator/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "roblox_emulator"
-version = "0.5.0"
+version = "0.4.7"
 edition = "2024"
 repository = "https://git.itzana.me/StrafesNET/strafe-project"
 license = "MIT OR Apache-2.0"
@@ -15,7 +15,7 @@ run-service=[]
 glam = "0.30.0"
 mlua = { version = "0.10.1", features = ["luau"] }
 phf = { version = "0.11.2", features = ["macros"] }
-rbx_dom_weak = { version = "3.1.0-sn4", registry = "strafesnet", features = ["instance-userdata"] }
-rbx_reflection = "5.0.0"
-rbx_reflection_database = "1.0.0"
-rbx_types = "2.0.0"
+rbx_dom_weak = { version = "2.7.0", registry = "strafesnet" }
+rbx_reflection = { version = "4.7.0", registry = "strafesnet" }
+rbx_reflection_database = { version = "0.2.10", registry = "strafesnet" }
+rbx_types = { version = "1.10.0", registry = "strafesnet" }

lib/roblox_emulator/src/context.rs

@@ -1,113 +1,93 @@
-use crate::util::static_ustr;
 use rbx_dom_weak::{types::Ref,InstanceBuilder,WeakDom};
 
-#[derive(Debug)]
-pub enum ServicesError{
-	WorkspaceNotFound,
-}
-impl std::fmt::Display for ServicesError{
-	fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
-		write!(f,"{self:?}")
-	}
-}
-impl std::error::Error for ServicesError{}
-
-pub struct Services{
-	pub(crate) game:Ref,
-	pub(crate) workspace:Ref,
+pub fn class_is_a(class:&str,superclass:&str)->bool{
+	class==superclass
+	||rbx_reflection_database::get().classes.get(class)
+	.is_some_and(|descriptor|
+		descriptor.superclass.as_ref().is_some_and(|class_super|
+			class_is_a(class_super,superclass)
+		)
+	)
 }
 
-impl Services{
-	fn find_services(dom:&WeakDom)->Result<Services,ServicesError>{
-		Ok(Services{
-			workspace:*dom.root().children().iter().find(|&&r|
-				dom.get_by_ref(r).is_some_and(|instance|instance.class=="Workspace")
-			).ok_or(ServicesError::WorkspaceNotFound)?,
-			game:dom.root_ref(),
-		})
-	}
-}
-
-pub type LuaAppData=&'static mut WeakDom;
+#[repr(transparent)]
 pub struct Context{
 	pub(crate)dom:WeakDom,
-	pub(crate)services:Services,
 }
 
 impl Context{
-	pub fn from_place(dom:WeakDom)->Result<Context,ServicesError>{
-		let services=Services::find_services(&dom)?;
-		Ok(Self{dom,services})
+	pub const fn new(dom:WeakDom)->Self{
+		Self{dom}
 	}
-	pub fn script_singleton(source:String)->(Context,crate::runner::instance::Instance){
+	pub fn script_singleton(source:String)->(Context,crate::runner::instance::Instance,Services){
 		let script=InstanceBuilder::new("Script")
 			.with_property("Source",rbx_types::Variant::String(source));
 		let script_ref=script.referent();
-		let dom=WeakDom::new(
+		let mut context=Self::new(WeakDom::new(
 			InstanceBuilder::new("DataModel")
 			.with_child(script)
-		);
-		let context=Self::from_model(dom);
-		(context,crate::runner::instance::Instance::new_unchecked(script_ref))
+		));
+		let services=context.convert_into_place();
+		(context,crate::runner::instance::Instance::new(script_ref),services)
+	}
+	pub fn from_ref(dom:&WeakDom)->&Context{
+		unsafe{&*(dom as *const WeakDom as *const Context)}
+	}
+	pub fn from_mut(dom:&mut WeakDom)->&mut Context{
+		unsafe{&mut *(dom as *mut WeakDom as *mut Context)}
 	}
 	/// Creates an iterator over all items of a particular class.
 	pub fn superclass_iter<'a>(&'a self,superclass:&'a str)->impl Iterator<Item=Ref>+'a{
-		let db=rbx_reflection_database::get();
-		let Some(superclass)=db.classes.get(superclass)else{
-			panic!("Invalid class");
-		};
-		self.dom.descendants().filter_map(|instance|{
-			let class=db.classes.get(instance.class.as_str())?;
-			db.has_superclass(class,superclass).then(||instance.referent())
-		})
+		self.dom.descendants().filter(|&instance|
+			class_is_a(instance.class.as_ref(),superclass)
+		).map(|instance|instance.referent())
 	}
 	pub fn scripts(&self)->Vec<crate::runner::instance::Instance>{
-		self.superclass_iter("Script")
-			.filter_map(|script_ref|{
-				let script=self.dom.get_by_ref(script_ref)?;
-				if let None|Some(rbx_dom_weak::types::Variant::Bool(false))=script.properties.get(&static_ustr("Disabled")){
-					return Some(crate::runner::instance::Instance::new_unchecked(script_ref));
-				}
-				None
-			})
-			.collect()
+		self.superclass_iter("LuaSourceContainer").map(crate::runner::instance::Instance::new).collect()
 	}
 
-	pub fn from_model(mut dom:WeakDom)->Context{
+	pub fn find_services(&self)->Option<Services>{
+		Some(Services{
+			workspace:*self.dom.root().children().iter().find(|&&r|
+				self.dom.get_by_ref(r).is_some_and(|instance|instance.class=="Workspace")
+			)?,
+			game:self.dom.root_ref(),
+		})
+	}
+	pub fn convert_into_place(&mut self)->Services{
 		//snapshot root instances
-		let children=dom.root().children().to_owned();
+		let children=self.dom.root().children().to_owned();
 
 		//insert services
-		let game=dom.root_ref();
+		let game=self.dom.root_ref();
 		let terrain_bldr=InstanceBuilder::new("Terrain");
-		let workspace=dom.insert(game,
+		let workspace=self.dom.insert(game,
 			InstanceBuilder::new("Workspace")
 				//Set Workspace.Terrain property equal to Terrain
 				.with_property("Terrain",terrain_bldr.referent())
 				.with_child(terrain_bldr)
 		);
+		{
+			//Lowercase and upper case workspace property!
+			let game=self.dom.root_mut();
+			game.properties.insert("workspace".to_owned(),rbx_types::Variant::Ref(workspace));
+			game.properties.insert("Workspace".to_owned(),rbx_types::Variant::Ref(workspace));
+		}
+		self.dom.insert(game,InstanceBuilder::new("Lighting"));
 
 		//transfer original root instances into workspace
 		for instance in children{
-			dom.transfer_within(instance,workspace);
+			self.dom.transfer_within(instance,workspace);
 		}
 
-		{
-			//Lowercase and upper case workspace property!
-			let game=dom.root_mut();
-			// TODO: DELETE THIS!
-			game.properties.insert(static_ustr("workspace"),rbx_types::Variant::Ref(workspace));
-			game.properties.insert(static_ustr("Workspace"),rbx_types::Variant::Ref(workspace));
+		Services{
+			game,
+			workspace,
 		}
-		dom.insert(game,InstanceBuilder::new("Lighting"));
-
-		let services=Services{game,workspace};
-		Self{dom,services}
 	}
 }
 
-impl AsRef<WeakDom> for Context{
-	fn as_ref(&self)->&WeakDom{
-		&self.dom
-	}
+pub struct Services{
+	pub game:Ref,
+	pub workspace:Ref,
 }

lib/roblox_emulator/src/lib.rs

@@ -1,4 +1,3 @@
-mod util;
 pub mod runner;
 pub mod context;
 #[cfg(feature="run-service")]
@@ -6,7 +5,3 @@ pub(crate) mod scheduler;
 
 #[cfg(test)]
 mod tests;
-
-pub mod mlua{
-	pub use mlua::{Result,Error};
-}

lib/roblox_emulator/src/runner/brickcolor.rs

@@ -1,59 +0,0 @@
-use super::color3::Color3;
-
-#[derive(Clone,Copy)]
-pub struct BrickColor(rbx_types::BrickColor);
-impl BrickColor{
-	pub fn from_name(name:&str)->Option<Self>{
-		Some(BrickColor(rbx_types::BrickColor::from_name(name)?))
-	}
-	pub fn from_number(number:u16)->Option<Self>{
-		Some(BrickColor(rbx_types::BrickColor::from_number(number)?))
-	}
-}
-
-pub fn set_globals(lua:&mlua::Lua,globals:&mlua::Table)->Result<(),mlua::Error>{
-	let table=lua.create_table()?;
-
-	table.raw_set("new",
-		lua.create_function(|_,r:mlua::Value|
-			match r{
-				mlua::Value::String(name)=>Ok(BrickColor::from_name(&*name.to_str()?)),
-				mlua::Value::Integer(number)=>Ok(BrickColor::from_number(number as u16)),
-				_=>Err(mlua::Error::runtime("Unsupported arguments"))
-			}
-
-		)?
-	)?;
-
-	macro_rules! brickcolor_constructor{
-		($fname:expr,$internal:ident)=>{
-			table.raw_set($fname,
-				lua.create_function(|_,_:()|
-					Ok(BrickColor(rbx_types::BrickColor::$internal))
-				)?
-			)?;
-		};
-	}
-	brickcolor_constructor!("White",White);
-	brickcolor_constructor!("Gray",MediumStoneGrey);
-	brickcolor_constructor!("DarkGray",DarkStoneGrey);
-	brickcolor_constructor!("Black",Black);
-	brickcolor_constructor!("Red",BrightRed);
-	brickcolor_constructor!("Yellow",BrightYellow);
-	brickcolor_constructor!("Green",DarkGreen);
-	brickcolor_constructor!("Blue",BrightBlue);
-
-	globals.set("BrickColor",table)?;
-
-	Ok(())
-}
-
-impl mlua::UserData for BrickColor{
-	fn add_fields<F:mlua::UserDataFields<Self>>(fields:&mut F){
-		fields.add_field_method_get("Color",|_,BrickColor(this)|{
-			let rbx_types::Color3uint8{r,g,b}=this.to_color3uint8();
-			Ok(Color3::from_rgb(r,g,b))
-		});
-	}
-}
-type_from_lua_userdata!(BrickColor);

lib/roblox_emulator/src/runner/cframe.rs

@@ -1,10 +1,7 @@
-use mlua::FromLua;
-
-use super::number::Number;
 use super::vector3::Vector3;
 
 #[derive(Clone,Copy)]
-pub struct CFrame(glam::Affine3A);
+pub struct CFrame(pub(crate)glam::Affine3A);
 
 impl CFrame{
 	pub fn new(
@@ -37,14 +34,14 @@ fn vec3_from_glam(v:rbx_types::Vector3)->glam::Vec3A{
 	glam::vec3a(v.x,v.y,v.z)
 }
 
-impl From<CFrame> for rbx_types::CFrame{
-	fn from(CFrame(cf):CFrame)->rbx_types::CFrame{
+impl Into<rbx_types::CFrame> for CFrame{
+	fn into(self)->rbx_types::CFrame{
 		rbx_types::CFrame::new(
-			vec3_to_glam(cf.translation),
+			vec3_to_glam(self.0.translation),
 			rbx_types::Matrix3::new(
-				vec3_to_glam(cf.matrix3.x_axis),
-				vec3_to_glam(cf.matrix3.y_axis),
-				vec3_to_glam(cf.matrix3.z_axis),
+				vec3_to_glam(self.0.matrix3.x_axis),
+				vec3_to_glam(self.0.matrix3.y_axis),
+				vec3_to_glam(self.0.matrix3.z_axis),
 			)
 		)
 	}
@@ -63,25 +60,16 @@ impl From<rbx_types::CFrame> for CFrame{
 }
 
 pub fn set_globals(lua:&mlua::Lua,globals:&mlua::Table)->Result<(),mlua::Error>{
-	let table=lua.create_table()?;
+	let cframe_table=lua.create_table()?;
 
 	//CFrame.new
-	table.raw_set("new",
-		lua.create_function(|lua,tuple:(
-			mlua::Value,mlua::Value,Option<Number>,
-			Option<Number>,Option<Number>,Option<Number>,
-			Option<Number>,Option<Number>,Option<Number>,
-			Option<Number>,Option<Number>,Option<Number>,
+	cframe_table.raw_set("new",
+		lua.create_function(|_,tuple:(
+			mlua::Value,mlua::Value,Option<f32>,
+			Option<f32>,Option<f32>,Option<f32>,
+			Option<f32>,Option<f32>,Option<f32>,
+			Option<f32>,Option<f32>,Option<f32>,
 		)|match tuple{
-			//CFrame.new()
-			(
-				mlua::Value::Nil,mlua::Value::Nil,None,
-				None,None,None,
-				None,None,None,
-				None,None,None,
-			)=>{
-				Ok(CFrame(glam::Affine3A::IDENTITY))
-			},
 			//CFrame.new(pos)
 			(
 				mlua::Value::UserData(pos),mlua::Value::Nil,None,
@@ -89,8 +77,8 @@ pub fn set_globals(lua:&mlua::Lua,globals:&mlua::Table)->Result<(),mlua::Error>{
 				None,None,None,
 				None,None,None,
 			)=>{
-				let Vector3(pos):&Vector3=&*pos.borrow()?;
-				Ok(CFrame::point(pos.x,pos.y,pos.z))
+				let pos:Vector3=pos.take()?;
+				Ok(CFrame::point(pos.0.x,pos.0.y,pos.0.z))
 			},
 			//TODO: CFrame.new(pos,look)
 			(
@@ -99,99 +87,85 @@ pub fn set_globals(lua:&mlua::Lua,globals:&mlua::Table)->Result<(),mlua::Error>{
 				None,None,None,
 				None,None,None,
 			)=>{
-				let _pos:&Vector3=&*pos.borrow()?;
-				let _look:&Vector3=&*look.borrow()?;
+				let _pos:Vector3=pos.take()?;
+				let _look:Vector3=look.take()?;
 				Err(mlua::Error::runtime("Not yet implemented"))
 			},
 			//CFrame.new(x,y,z)
 			(
-				x,y,Some(z),
+				mlua::Value::Number(x),mlua::Value::Number(y),Some(z),
 				None,None,None,
 				None,None,None,
 				None,None,None,
-			)=>Ok(CFrame::point(Number::from_lua(x,lua)?.into(),Number::from_lua(y,lua)?.into(),z.into())),
+			)=>Ok(CFrame::point(x as f32,y as f32,z)),
 			//CFrame.new(x,y,z,xx,yx,zx,xy,yy,zy,xz,yz,zz)
 			(
-				x,y,Some(z),
+				mlua::Value::Number(x),mlua::Value::Number(y),Some(z),
 				Some(xx),Some(yx),Some(zx),
 				Some(xy),Some(yy),Some(zy),
 				Some(xz),Some(yz),Some(zz),
-			)=>Ok(CFrame::new(Number::from_lua(x,lua)?.into(),Number::from_lua(y,lua)?.into(),z.into(),
-				xx.into(),yx.into(),zx.into(),
-				xy.into(),yy.into(),zy.into(),
-				xz.into(),yz.into(),zz.into(),
+			)=>Ok(CFrame::new(x as f32,y as f32,z,
+				xx,yx,zx,
+				xy,yy,zy,
+				xz,yz,zz,
 			)),
 			_=>Err(mlua::Error::runtime("Invalid arguments"))
 		})?
 	)?;
 
 	//CFrame.Angles
-	let from_euler_angles=lua.create_function(|_,(x,y,z):(Number,Number,Number)|
-		Ok(CFrame::angles(x.into(),y.into(),z.into()))
+	cframe_table.raw_set("Angles",
+		lua.create_function(|_,(x,y,z):(f32,f32,f32)|
+			Ok(CFrame::angles(x,y,z))
+		)?
 	)?;
-	table.raw_set("Angles",from_euler_angles.clone())?;
-	table.raw_set("fromEulerAnglesXYZ",from_euler_angles.clone())?;
-	table.raw_set("FromEulerAnglesXYZ",from_euler_angles)?;
 
-	globals.set("CFrame",table)?;
+	globals.set("CFrame",cframe_table)?;
 
 	Ok(())
 }
 
 impl mlua::UserData for CFrame{
 	fn add_fields<F:mlua::UserDataFields<Self>>(fields:&mut F){
-		fields.add_field_method_get("p",|_,CFrame(this)|Ok(Vector3(this.translation)));
-		fields.add_field_method_get("x",|_,CFrame(this)|Ok(this.translation.x));
-		fields.add_field_method_get("X",|_,CFrame(this)|Ok(this.translation.x));
-		fields.add_field_method_get("y",|_,CFrame(this)|Ok(this.translation.y));
-		fields.add_field_method_get("Y",|_,CFrame(this)|Ok(this.translation.y));
-		fields.add_field_method_get("z",|_,CFrame(this)|Ok(this.translation.z));
-		fields.add_field_method_get("Z",|_,CFrame(this)|Ok(this.translation.z));
-		fields.add_field_method_get("rightVector",|_,CFrame(this)|Ok(Vector3(this.matrix3.x_axis)));
-		fields.add_field_method_get("RightVector",|_,CFrame(this)|Ok(Vector3(this.matrix3.x_axis)));
-		fields.add_field_method_get("upVector",|_,CFrame(this)|Ok(Vector3(this.matrix3.y_axis)));
-		fields.add_field_method_get("UpVector",|_,CFrame(this)|Ok(Vector3(this.matrix3.y_axis)));
-		fields.add_field_method_get("lookVector",|_,CFrame(this)|Ok(Vector3(-this.matrix3.z_axis)));
-		fields.add_field_method_get("LookVector",|_,CFrame(this)|Ok(Vector3(-this.matrix3.z_axis)));
-		fields.add_field_method_get("XVector",|_,CFrame(this)|Ok(Vector3(this.matrix3.row(0))));
-		fields.add_field_method_get("YVector",|_,CFrame(this)|Ok(Vector3(this.matrix3.row(1))));
-		fields.add_field_method_get("ZVector",|_,CFrame(this)|Ok(Vector3(this.matrix3.row(2))));
+		//CFrame.p
+		fields.add_field_method_get("p",|_,this|Ok(Vector3(this.0.translation)));
 	}
 
 	fn add_methods<M:mlua::UserDataMethods<Self>>(methods:&mut M){
-		methods.add_method("components",|_,CFrame(this),()|Ok((
-			this.translation.x,
-			this.translation.y,
-			this.translation.z,
-			this.matrix3.x_axis.x,
-			this.matrix3.y_axis.x,
-			this.matrix3.z_axis.x,
-			this.matrix3.x_axis.y,
-			this.matrix3.y_axis.y,
-			this.matrix3.z_axis.y,
-			this.matrix3.x_axis.z,
-			this.matrix3.y_axis.z,
-			this.matrix3.z_axis.z,
+		methods.add_method("components",|_,this,()|Ok((
+			this.0.translation.x,
+			this.0.translation.y,
+			this.0.translation.z,
+			this.0.matrix3.x_axis.x,
+			this.0.matrix3.y_axis.x,
+			this.0.matrix3.z_axis.x,
+			this.0.matrix3.x_axis.y,
+			this.0.matrix3.y_axis.y,
+			this.0.matrix3.z_axis.y,
+			this.0.matrix3.x_axis.z,
+			this.0.matrix3.y_axis.z,
+			this.0.matrix3.z_axis.z,
 		)));
-		methods.add_method("VectorToWorldSpace",|_,CFrame(this),Vector3(v):Vector3|
-			Ok(Vector3(this.transform_vector3a(v)))
+		methods.add_method("VectorToWorldSpace",|_,this,v:Vector3|
+			Ok(Vector3(this.0.transform_vector3a(v.0)))
 		);
 
-		methods.add_meta_function(mlua::MetaMethod::Mul,|_,(CFrame(this),CFrame(val)):(Self,Self)|Ok(Self(this*val)));
-		methods.add_meta_function(mlua::MetaMethod::ToString,|_,CFrame(this):Self|
+		//methods.add_meta_method(mlua::MetaMethod::Mul,|_,this,val:&Vector3|Ok(Vector3(this.0.matrix3*val.0+this.0.translation)));
+		methods.add_meta_function(mlua::MetaMethod::Mul,|_,(this,val):(Self,Self)|Ok(Self(this.0*val.0)));
+		methods.add_meta_function(mlua::MetaMethod::ToString,|_,this:Self|
 			Ok(format!("CFrame.new({},{},{},{},{},{},{},{},{},{},{},{})",
-				this.translation.x,
-				this.translation.y,
-				this.translation.z,
-				this.matrix3.x_axis.x,
-				this.matrix3.y_axis.x,
-				this.matrix3.z_axis.x,
-				this.matrix3.x_axis.y,
-				this.matrix3.y_axis.y,
-				this.matrix3.z_axis.y,
-				this.matrix3.x_axis.z,
-				this.matrix3.y_axis.z,
-				this.matrix3.z_axis.z,
+				this.0.translation.x,
+				this.0.translation.y,
+				this.0.translation.z,
+				this.0.matrix3.x_axis.x,
+				this.0.matrix3.y_axis.x,
+				this.0.matrix3.z_axis.x,
+				this.0.matrix3.x_axis.y,
+				this.0.matrix3.y_axis.y,
+				this.0.matrix3.z_axis.y,
+				this.0.matrix3.x_axis.z,
+				this.0.matrix3.y_axis.z,
+				this.0.matrix3.z_axis.z,
 			))
 		);
 	}

lib/roblox_emulator/src/runner/color3.rs

@@ -1,5 +1,3 @@
-use super::number::Number;
-
 #[derive(Clone,Copy)]
 pub struct Color3{
 	r:f32,
@@ -10,37 +8,28 @@ impl Color3{
 	pub const fn new(r:f32,g:f32,b:f32)->Self{
 		Self{r,g,b}
 	}
-	pub const fn from_rgb(r:u8,g:u8,b:u8)->Self{
-		Color3::new(r as f32/255.0,g as f32/255.0,b as f32/255.0)
-	}
 }
-impl From<rbx_types::Color3> for Color3{
-	fn from(value:rbx_types::Color3)->Color3{
-		Color3::new(value.r,value.g,value.b)
-	}
-}
-impl From<Color3> for rbx_types::Color3{
-	fn from(value:Color3)->rbx_types::Color3{
-		rbx_types::Color3::new(value.r,value.g,value.b)
+impl Into<rbx_types::Color3> for Color3{
+	fn into(self)->rbx_types::Color3{
+		rbx_types::Color3::new(self.r,self.g,self.b)
 	}
 }
 
 pub fn set_globals(lua:&mlua::Lua,globals:&mlua::Table)->Result<(),mlua::Error>{
-	let table=lua.create_table()?;
+	let color3_table=lua.create_table()?;
 
-	table.raw_set("new",
-		lua.create_function(|_,(r,g,b):(Number,Number,Number)|
-			Ok(Color3::new(r.into(),g.into(),b.into()))
+	color3_table.raw_set("new",
+		lua.create_function(|_,(r,g,b):(f32,f32,f32)|
+			Ok(Color3::new(r,g,b))
+		)?
+	)?;
+	color3_table.raw_set("fromRGB",
+		lua.create_function(|_,(r,g,b):(u8,u8,u8)|
+			Ok(Color3::new(r as f32/255.0,g as f32/255.0,b as f32/255.0))
 		)?
 	)?;
 
-	let from_rgb=lua.create_function(|_,(r,g,b):(u8,u8,u8)|
-		Ok(Color3::from_rgb(r,g,b))
-	)?;
-	table.raw_set("fromRGB",from_rgb.clone())?;
-	table.raw_set("FromRGB",from_rgb)?;
-
-	globals.set("Color3",table)?;
+	globals.set("Color3",color3_table)?;
 
 	Ok(())
 }

lib/roblox_emulator/src/runner/color_sequence.rs

@@ -1,29 +1,31 @@
-#[derive(Clone)]
-pub struct ColorSequence(rbx_types::ColorSequence);
+#[derive(Clone,Copy)]
+pub struct ColorSequence{}
 impl ColorSequence{
-	pub const fn new(keypoints:Vec<rbx_types::ColorSequenceKeypoint>)->Self{
-		Self(rbx_types::ColorSequence{keypoints})
+	pub const fn new()->Self{
+		Self{}
 	}
 }
-impl From<ColorSequence> for rbx_types::ColorSequence{
-	fn from(ColorSequence(value):ColorSequence)->rbx_types::ColorSequence{
-		value
+impl Into<rbx_types::ColorSequence> for ColorSequence{
+	fn into(self)->rbx_types::ColorSequence{
+		rbx_types::ColorSequence{
+			keypoints:Vec::new()
+		}
 	}
 }
 
 pub fn set_globals(lua:&mlua::Lua,globals:&mlua::Table)->Result<(),mlua::Error>{
-	let table=lua.create_table()?;
+	let number_sequence_table=lua.create_table()?;
 
-	table.raw_set("new",
+	number_sequence_table.raw_set("new",
 		lua.create_function(|_,_:mlua::MultiValue|
-			Ok(ColorSequence::new(Vec::new()))
+			Ok(ColorSequence::new())
 		)?
 	)?;
 
-	globals.set("ColorSequence",table)?;
+	globals.set("ColorSequence",number_sequence_table)?;
 
 	Ok(())
 }
 
 impl mlua::UserData for ColorSequence{}
-type_from_lua_userdata_clone!(ColorSequence);
+type_from_lua_userdata!(ColorSequence);

lib/roblox_emulator/src/runner/enum.rs

@@ -1,136 +1,63 @@
-#[derive(Clone,Copy)]
-pub struct EnumItem<'a>{
-	name:Option<&'a str>,
-	value:u32,
-}
-impl<'a> EnumItem<'a>{
-	fn known_name((name,&value):(&'a std::borrow::Cow<'a,str>,&u32))->Self{
-		Self{name:Some(name.as_ref()),value}
-	}
-}
-impl<'a> From<rbx_types::Enum> for EnumItem<'a>{
-	fn from(e:rbx_types::Enum)->Self{
-		EnumItem{
-			name:None,
-			value:e.to_u32(),
-		}
-	}
-}
-impl From<EnumItem<'_>> for rbx_types::Enum{
-	fn from(e:EnumItem)->rbx_types::Enum{
-		rbx_types::Enum::from_u32(e.value)
-	}
-}
-impl PartialEq for EnumItem<'_>{
-	fn eq(&self,other:&EnumItem<'_>)->bool{
-		self.value==other.value&&{
-			// if both names are known, they must match, otherwise whatever
-			match (self.name,other.name){
-				(Some(lhs),Some(rhs))=>lhs==rhs,
-				_=>true,
-			}
-		}
-	}
-}
+use mlua::IntoLua;
 
 #[derive(Clone,Copy)]
-pub struct Enums;
-impl Enums{
-	pub fn get(&self,index:&str)->Option<EnumItems<'static>>{
-		let db=rbx_reflection_database::get();
-		db.enums.get(index).map(|ed|EnumItems{ed})
-	}
-}
+pub struct Enum(u32);
 #[derive(Clone,Copy)]
-pub struct EnumItems<'a>{
+pub struct EnumItems;
+#[derive(Clone,Copy)]
+pub struct EnumItem<'a>{
 	ed:&'a rbx_reflection::EnumDescriptor<'a>,
 }
 
-impl<'a> EnumItems<'a>{
-	pub fn from_value(&self,value:u32)->Option<EnumItem<'a>>{
-		self.ed.items.iter().find(|&(_,&v)|v==value).map(EnumItem::known_name)
-	}
-	pub fn from_name(&self,name:&str)->Option<EnumItem<'a>>{
-		self.ed.items.get_key_value(name).map(EnumItem::known_name)
-	}
-	pub fn from_enum(&self,enum_item:EnumItem)->Option<EnumItem<'a>>{
-		match enum_item.name{
-			Some(s)=>{
-				let got=self.from_name(s)?;
-				(got.value==enum_item.value).then_some(got)
-			},
-			None=>self.from_value(enum_item.value)
-		}
+impl Into<rbx_types::Enum> for Enum{
+	fn into(self)->rbx_types::Enum{
+		rbx_types::Enum::from_u32(self.0)
 	}
 }
 
-pub enum CoerceEnum<'a>{
-	Integer(i32),
-	String(mlua::String),
-	Enum(EnumItem<'a>),
-}
-impl CoerceEnum<'_>{
-	pub fn coerce_to<'a>(self,enum_items:EnumItems<'a>)->mlua::Result<EnumItem<'a>>{
-		match self{
-			CoerceEnum::Integer(int)=>enum_items.from_value(int as u32),
-			CoerceEnum::String(s)=>enum_items.from_name(&*s.to_str()?),
-			CoerceEnum::Enum(enum_item)=>enum_items.from_enum(enum_item),
-		}.ok_or_else(||mlua::Error::runtime(format!("Bad {} EnumItem",enum_items.ed.name)))
-	}
-}
-
-impl mlua::FromLua for CoerceEnum<'_>{
-	fn from_lua(value:mlua::Value,_lua:&mlua::Lua)->Result<Self,mlua::Error>{
-		match value{
-			mlua::Value::Integer(int)=>Ok(CoerceEnum::Integer(int)),
-			mlua::Value::String(s)=>Ok(CoerceEnum::String(s)),
-			mlua::Value::UserData(ud)=>Ok(CoerceEnum::Enum(*ud.borrow()?)),
-			other=>Err(mlua::Error::runtime(format!("Expected {} got {:?}",stringify!(Enum),other))),
-		}
+impl<'a> EnumItem<'a>{
+	const fn new(ed:&'a rbx_reflection::EnumDescriptor)->Self{
+		Self{ed}
 	}
 }
 
 pub fn set_globals(_lua:&mlua::Lua,globals:&mlua::Table)->Result<(),mlua::Error>{
-	globals.set("Enum",Enums)
+	globals.set("Enum",EnumItems)
 }
 
-impl mlua::UserData for EnumItems<'static>{
-	fn add_fields<F:mlua::UserDataFields<Self>>(_fields:&mut F){
-	}
-	fn add_methods<M:mlua::UserDataMethods<Self>>(methods:&mut M){
-		methods.add_method("FromName",|_,this:&EnumItems,name:mlua::String|Ok(this.from_name(&*name.to_str()?)));
-		methods.add_method("FromValue",|_,this:&EnumItems,value:u32|Ok(this.from_value(value)));
-		methods.add_method("GetEnumItems",|_,this:&EnumItems,()|->mlua::Result<Vec<EnumItem>>{
-			Ok(this.ed.items.iter().map(EnumItem::known_name).collect())
-		});
-		methods.add_meta_function(mlua::MetaMethod::Index,|_,(this,val):(EnumItems,mlua::String)|{
-			let index=&*val.to_str()?;
-			Ok(this.ed.items.get_key_value(index).map(EnumItem::known_name))
-		});
-	}
-}
-type_from_lua_userdata_lua_lifetime!(EnumItems);
-
-impl mlua::UserData for Enums{
-	fn add_fields<F:mlua::UserDataFields<Self>>(_fields:&mut F){
-	}
-	fn add_methods<M:mlua::UserDataMethods<Self>>(methods:&mut M){
-		methods.add_meta_function(mlua::MetaMethod::Index,|_,(enums,val):(Self,mlua::String)|{
-			Ok(enums.get(&*val.to_str()?))
-		});
-	}
-}
-type_from_lua_userdata!(Enums);
-
 impl mlua::UserData for EnumItem<'_>{
-	fn add_fields<F:mlua::UserDataFields<Self>>(fields:&mut F){
-		fields.add_field_method_get("Name",|_,this|Ok(this.name));
-		fields.add_field_method_get("Value",|_,this|Ok(this.value));
+	fn add_fields<F:mlua::UserDataFields<Self>>(_fields:&mut F){
 	}
 	fn add_methods<M:mlua::UserDataMethods<Self>>(methods:&mut M){
-		methods.add_meta_function(mlua::MetaMethod::Eq,|_,(lhs,rhs):(EnumItem<'_>,EnumItem<'_>)|{
-			Ok(lhs==rhs)
+		methods.add_meta_function(mlua::MetaMethod::Index,|lua,(this,val):(EnumItem<'_>,mlua::String)|{
+			match this.ed.items.get(&*val.to_str()?){
+				Some(&id)=>Enum(id).into_lua(lua),
+				None=>mlua::Value::Nil.into_lua(lua),
+			}
 		});
 	}
 }
 type_from_lua_userdata_lua_lifetime!(EnumItem);
+
+impl mlua::UserData for EnumItems{
+	fn add_fields<F:mlua::UserDataFields<Self>>(_fields:&mut F){
+	}
+	fn add_methods<M:mlua::UserDataMethods<Self>>(methods:&mut M){
+		methods.add_meta_function(mlua::MetaMethod::Index,|lua,(_,val):(Self,mlua::String)|{
+			let db=rbx_reflection_database::get();
+			match db.enums.get(&*val.to_str()?){
+				Some(ed)=>EnumItem::new(ed).into_lua(lua),
+				None=>mlua::Value::Nil.into_lua(lua),
+			}
+		});
+	}
+}
+type_from_lua_userdata!(EnumItems);
+
+impl mlua::UserData for Enum{
+	fn add_fields<F:mlua::UserDataFields<Self>>(_fields:&mut F){
+	}
+	fn add_methods<M:mlua::UserDataMethods<Self>>(_methods:&mut M){
+	}
+}
+type_from_lua_userdata!(Enum);

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

@@ -2,47 +2,48 @@ use std::collections::{hash_map::Entry,HashMap};
 
 use mlua::{FromLua,FromLuaMulti,IntoLua,IntoLuaMulti};
 use rbx_types::Ref;
-use rbx_dom_weak::{Ustr,InstanceBuilder,WeakDom};
+use rbx_dom_weak::{InstanceBuilder,WeakDom};
 
-use crate::util::static_ustr;
 use crate::runner::vector3::Vector3;
-use crate::runner::number::Number;
 
 pub fn set_globals(lua:&mlua::Lua,globals:&mlua::Table)->Result<(),mlua::Error>{
 	//class functions store
 	lua.set_app_data(ClassMethodsStore::default());
+	lua.set_app_data(InstanceValueStore::default());
 
-	let table=lua.create_table()?;
+	let instance_table=lua.create_table()?;
 
 	//Instance.new
-	table.raw_set("new",
+	instance_table.raw_set("new",
 		lua.create_function(|lua,(class_name,parent):(mlua::String,Option<Instance>)|{
 			let class_name_str=&*class_name.to_str()?;
-			let parent_ref=parent.map_or(Ref::none(),|instance|instance.referent);
+			let parent=parent.ok_or_else(||mlua::Error::runtime("Nil Parent not yet supported"))?;
 			dom_mut(lua,|dom|{
-				Ok(Instance::new_unchecked(dom.insert(parent_ref,InstanceBuilder::new(class_name_str))))
+				//TODO: Nil instances
+				Ok(Instance::new(dom.insert(parent.referent,InstanceBuilder::new(class_name_str))))
 			})
 		})?
 	)?;
 
-	globals.set("Instance",table)?;
+	globals.set("Instance",instance_table)?;
 
 	Ok(())
 }
 
 // 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::<crate::context::LuaAppData>().ok_or_else(||mlua::Error::runtime("DataModel missing"))?;
+	let mut dom=lua.app_data_mut::<&'static mut WeakDom>().ok_or_else(||mlua::Error::runtime("DataModel missing"))?;
 	f(*dom)
 }
 
-pub fn class_is_a(class:&str,superclass:&str)->bool{
-	let db=rbx_reflection_database::get();
-	let (Some(class),Some(superclass))=(db.classes.get(class),db.classes.get(superclass))else{
-		return false;
-	};
-	db.has_superclass(class,superclass)
+fn coerce_float32(value:&mlua::Value)->Option<f32>{
+	match value{
+		&mlua::Value::Integer(i)=>Some(i as f32),
+		&mlua::Value::Number(f)=>Some(f as f32),
+		_=>None,
+	}
 }
+
 fn get_full_name(dom:&rbx_dom_weak::WeakDom,instance:&rbx_dom_weak::Instance)->String{
 	let mut full_name=instance.name.clone();
 	let mut pref=instance.parent();
@@ -57,7 +58,7 @@ fn get_full_name(dom:&rbx_dom_weak::WeakDom,instance:&rbx_dom_weak::Instance)->S
 pub fn get_name_source(lua:&mlua::Lua,script:Instance)->Result<(String,String),mlua::Error>{
 	dom_mut(lua,|dom|{
 		let instance=script.get(dom)?;
-		let source=match instance.properties.get(&static_ustr("Source")){
+		let source=match instance.properties.get("Source"){
 			Some(rbx_dom_weak::types::Variant::String(s))=>s.clone(),
 			_=>Err(mlua::Error::external("Missing script.Source"))?,
 		};
@@ -79,32 +80,14 @@ pub fn find_first_descendant_of_class<'a>(dom:&'a rbx_dom_weak::WeakDom,instance
 	dom.descendants_of(instance.referent()).find(|&inst|inst.class==class)
 }
 
-pub fn find_first_child_which_is_a<'a>(dom:&'a rbx_dom_weak::WeakDom,instance:&rbx_dom_weak::Instance,superclass:&str)->Option<&'a rbx_dom_weak::Instance>{
-	let db=rbx_reflection_database::get();
-	let superclass_descriptor=db.classes.get(superclass)?;
-	instance.children().iter().filter_map(|&r|dom.get_by_ref(r)).find(|inst|{
-		db.classes.get(inst.class.as_str()).is_some_and(|descriptor|db.has_superclass(descriptor,superclass_descriptor))
-	})
-}
-pub fn find_first_descendant_which_is_a<'a>(dom:&'a rbx_dom_weak::WeakDom,instance:&rbx_dom_weak::Instance,superclass:&str)->Option<&'a rbx_dom_weak::Instance>{
-	let db=rbx_reflection_database::get();
-	let superclass_descriptor=db.classes.get(superclass)?;
-	dom.descendants_of(instance.referent()).find(|inst|{
-		db.classes.get(inst.class.as_str()).is_some_and(|descriptor|db.has_superclass(descriptor,superclass_descriptor))
-	})
-}
-
 #[derive(Clone,Copy)]
 pub struct Instance{
 	referent:Ref,
 }
 impl Instance{
-	pub const fn new_unchecked(referent:Ref)->Self{
+	pub const fn new(referent:Ref)->Self{
 		Self{referent}
 	}
-	pub fn new(referent:Ref)->Option<Self>{
-		referent.is_some().then_some(Self{referent})
-	}
 	pub fn get<'a>(&self,dom:&'a WeakDom)->mlua::Result<&'a rbx_dom_weak::Instance>{
 		dom.get_by_ref(self.referent).ok_or_else(||mlua::Error::runtime("Instance missing"))
 	}
@@ -114,25 +97,40 @@ impl Instance{
 }
 type_from_lua_userdata!(Instance);
 
+//TODO: update rbx_reflection and use dom.superclasses_iter
+pub struct SuperClassIter<'a> {
+    database: &'a rbx_reflection::ReflectionDatabase<'a>,
+    descriptor: Option<&'a rbx_reflection::ClassDescriptor<'a>>,
+}
+impl<'a> SuperClassIter<'a> {
+    fn next_descriptor(&self) -> Option<&'a rbx_reflection::ClassDescriptor<'a>> {
+        let superclass = self.descriptor?.superclass.as_ref()?;
+        self.database.classes.get(superclass)
+    }
+}
+impl<'a> Iterator for SuperClassIter<'a> {
+    type Item = &'a rbx_reflection::ClassDescriptor<'a>;
+    fn next(&mut self) -> Option<Self::Item> {
+        let next_descriptor = self.next_descriptor();
+        std::mem::replace(&mut self.descriptor, next_descriptor)
+    }
+}
+
 impl mlua::UserData for Instance{
 	fn add_fields<F:mlua::UserDataFields<Self>>(fields:&mut F){
-		fn get_parent(lua:&mlua::Lua,this:&Instance)->mlua::Result<Option<Instance>>{
+		fields.add_field_method_get("Parent",|lua,this|{
 			dom_mut(lua,|dom|{
 				let instance=this.get(dom)?;
 				Ok(Instance::new(instance.parent()))
 			})
-		}
-		fields.add_field_method_get("parent",get_parent);
-		fields.add_field_method_get("Parent",get_parent);
-		fn set_parent(lua:&mlua::Lua,this:&mut Instance,new_parent:Option<Instance>)->mlua::Result<()>{
-			let parent_ref=new_parent.map_or(Ref::none(),|instance|instance.referent);
+		});
+		fields.add_field_method_set("Parent",|lua,this,val:Option<Instance>|{
+			let parent=val.ok_or_else(||mlua::Error::runtime("Nil Parent not yet supported"))?;
 			dom_mut(lua,|dom|{
-				dom.transfer_within(this.referent,parent_ref);
+				dom.transfer_within(this.referent,parent.referent);
 				Ok(())
 			})
-		}
-		fields.add_field_method_set("parent",set_parent);
-		fields.add_field_method_set("Parent",set_parent);
+		});
 		fields.add_field_method_get("Name",|lua,this|{
 			dom_mut(lua,|dom|{
 				let instance=this.get(dom)?;
@@ -150,38 +148,22 @@ impl mlua::UserData for Instance{
 		fields.add_field_method_get("ClassName",|lua,this|{
 			dom_mut(lua,|dom|{
 				let instance=this.get(dom)?;
-				Ok(instance.class.to_owned())
+				Ok(instance.class.clone())
 			})
 		});
 	}
 	fn add_methods<M:mlua::UserDataMethods<Self>>(methods:&mut M){
-		fn clone(lua:&mlua::Lua,this:&Instance,_:())->mlua::Result<Instance>{
-			dom_mut(lua,|dom|{
-				let instance_ref=dom.clone_within(this.referent);
-				Ok(Instance::new_unchecked(instance_ref))
-			})
-		}
-		methods.add_method("clone",clone);
-		methods.add_method("Clone",clone);
-		fn get_children(lua:&mlua::Lua,this:&Instance,_:())->mlua::Result<Vec<Instance>>{
+		methods.add_method("GetChildren",|lua,this,_:()|
 			dom_mut(lua,|dom|{
 				let instance=this.get(dom)?;
 				let children:Vec<_>=instance
 					.children()
 					.iter()
 					.copied()
-					.map(Instance::new_unchecked)
+					.map(Instance::new)
 					.collect();
 				Ok(children)
 			})
-		}
-		methods.add_method("children",get_children);
-		methods.add_method("GetChildren",get_children);
-		methods.add_method("GetFullName",|lua,this,()|
-			dom_mut(lua,|dom|{
-				let instance=this.get(dom)?;
-				Ok(get_full_name(dom,instance))
-			})
 		);
 		fn ffc(lua:&mlua::Lua,this:&Instance,(name,search_descendants):(mlua::String,Option<bool>))->mlua::Result<Option<Instance>>{
 			let name_str=&*name.to_str()?;
@@ -193,7 +175,7 @@ impl mlua::UserData for Instance{
 						false=>find_first_child(dom,instance,name_str),
 					}
 					.map(|instance|
-						Instance::new_unchecked(instance.referent())
+						Instance::new(instance.referent())
 					)
 				)
 			})
@@ -203,29 +185,13 @@ impl mlua::UserData for Instance{
 		methods.add_method("FindFirstChildOfClass",|lua,this,(class,search_descendants):(mlua::String,Option<bool>)|{
 			let class_str=&*class.to_str()?;
 			dom_mut(lua,|dom|{
-				let inst=this.get(dom)?;
 				Ok(
 					match search_descendants.unwrap_or(false){
-						true=>find_first_descendant_of_class(dom,inst,class_str),
-						false=>find_first_child_of_class(dom,inst,class_str),
+						true=>find_first_descendant_of_class(dom,this.get(dom)?,class_str),
+						false=>find_first_child_of_class(dom,this.get(dom)?,class_str),
 					}
 					.map(|instance|
-						Instance::new_unchecked(instance.referent())
-					)
-				)
-			})
-		});
-		methods.add_method("FindFirstChildWhichIsA",|lua,this,(class,search_descendants):(mlua::String,Option<bool>)|{
-			let class_str=&*class.to_str()?;
-			dom_mut(lua,|dom|{
-				let inst=this.get(dom)?;
-				Ok(
-					match search_descendants.unwrap_or(false){
-						true=>find_first_descendant_which_is_a(dom,inst,class_str),
-						false=>find_first_child_which_is_a(dom,inst,class_str),
-					}
-					.map(|instance|
-						Instance::new_unchecked(instance.referent())
+						Instance::new(instance.referent())
 					)
 				)
 			})
@@ -235,42 +201,24 @@ impl mlua::UserData for Instance{
 				let children:Vec<_>=dom
 					.descendants_of(this.referent)
 					.map(|instance|
-						Instance::new_unchecked(instance.referent())
+						Instance::new(instance.referent())
 					)
 					.collect();
 				Ok(children)
 			})
 		);
-		methods.add_method("IsAncestorOf",|lua,this,descendant:Instance|
-			dom_mut(lua,|dom|{
-				let instance=descendant.get(dom)?;
-				Ok(std::iter::successors(Some(instance),|inst|dom.get_by_ref(inst.parent())).any(|inst|inst.referent()==this.referent))
-			})
-		);
-		methods.add_method("IsDescendantOf",|lua,this,ancestor:Instance|
+		methods.add_method("IsA",|lua,this,classname:mlua::String|
 			dom_mut(lua,|dom|{
 				let instance=this.get(dom)?;
-				Ok(std::iter::successors(Some(instance),|inst|dom.get_by_ref(inst.parent())).any(|inst|inst.referent()==ancestor.referent))
+				Ok(crate::context::class_is_a(instance.class.as_str(),&*classname.to_str()?))
 			})
 		);
-		fn is_a(lua:&mlua::Lua,this:&Instance,classname:mlua::String)->mlua::Result<bool>{
+		methods.add_method("Destroy",|lua,this,()|
 			dom_mut(lua,|dom|{
-				let instance=this.get(dom)?;
-				Ok(class_is_a(instance.class.as_str(),&*classname.to_str()?))
-			})
-		}
-		methods.add_method("isA",is_a);
-		methods.add_method("IsA",is_a);
-		fn destroy(lua:&mlua::Lua,this:&Instance,_:())->mlua::Result<()>{
-			dom_mut(lua,|dom|{
-				dom.transfer_within(this.referent,Ref::none());
+				dom.destroy(this.referent);
 				Ok(())
 			})
-		}
-		methods.add_method("remove",destroy);
-		methods.add_method("Remove",destroy);
-		methods.add_method("destroy",destroy);
-		methods.add_method("Destroy",destroy);
+		);
 		methods.add_meta_function(mlua::MetaMethod::ToString,|lua,this:Instance|{
 			dom_mut(lua,|dom|{
 				let instance=this.get(dom)?;
@@ -284,38 +232,39 @@ impl mlua::UserData for Instance{
 				//println!("__index t={} i={index:?}",instance.name);
 				let db=rbx_reflection_database::get();
 				let class=db.classes.get(instance.class.as_str()).ok_or_else(||mlua::Error::runtime("Class missing"))?;
-				// Find existing property
-				// Interestingly, ustr can know ahead of time if
-				// a property does not exist in any runtime instance
-				match Ustr::from_existing(index_str)
-					.and_then(|index_ustr|
-						instance.properties.get(&index_ustr).cloned()
-					)
+				//Find existing property
+				match instance.properties.get(index_str)
+					.cloned()
 					//Find default value
 					.or_else(||db.find_default_property(class,index_str).cloned())
 					//Find virtual property
-					.or_else(||db.superclasses_iter(class).find_map(|class|
-						find_virtual_property(&instance.properties,class,index_str)
-					))
+					.or_else(||{
+						SuperClassIter{
+							database:db,
+							descriptor:Some(class),
+						}
+						.find_map(|class|
+							find_virtual_property(&instance.properties,class,index_str)
+						)
+					})
 				{
-					Some(rbx_types::Variant::Bool(val))=>return val.into_lua(lua),
 					Some(rbx_types::Variant::Int32(val))=>return val.into_lua(lua),
 					Some(rbx_types::Variant::Int64(val))=>return val.into_lua(lua),
 					Some(rbx_types::Variant::Float32(val))=>return val.into_lua(lua),
 					Some(rbx_types::Variant::Float64(val))=>return val.into_lua(lua),
-					Some(rbx_types::Variant::String(val))=>return val.into_lua(lua),
-					Some(rbx_types::Variant::Ref(val))=>return Instance::new_unchecked(val).into_lua(lua),
-					Some(rbx_types::Variant::Enum(e))=>return crate::runner::r#enum::EnumItem::from(e).into_lua(lua),
-					Some(rbx_types::Variant::Color3(c))=>return crate::runner::color3::Color3::from(c).into_lua(lua),
-					Some(rbx_types::Variant::CFrame(cf))=>return crate::runner::cframe::CFrame::from(cf).into_lua(lua),
-					Some(rbx_types::Variant::Vector2(v))=>return crate::runner::vector2::Vector2::from(v).into_lua(lua),
-					Some(rbx_types::Variant::Vector3(v))=>return crate::runner::vector3::Vector3::from(v).into_lua(lua),
+					Some(rbx_types::Variant::Ref(val))=>return Instance::new(val).into_lua(lua),
+					Some(rbx_types::Variant::CFrame(cf))=>return Into::<crate::runner::cframe::CFrame>::into(cf).into_lua(lua),
+					Some(rbx_types::Variant::Vector3(v))=>return Into::<crate::runner::vector3::Vector3>::into(v).into_lua(lua),
 					None=>(),
 					other=>return Err(mlua::Error::runtime(format!("Instance.__index Unsupported property type instance={} index={index_str} value={other:?}",instance.name))),
 				}
 				//find a function with a matching name
 				if let Some(function)=class_methods_store_mut(lua,|cf|{
-					db.superclasses_iter(class).find_map(|class|{
+					let mut iter=SuperClassIter{
+						database:db,
+						descriptor:Some(class),
+					};
+					iter.find_map(|class|{
 						let mut class_methods=cf.get_or_create_class_methods(&class.name)?;
 						class_methods.get_or_create_function(lua,index_str)
 							.transpose()
@@ -325,114 +274,80 @@ impl mlua::UserData for Instance{
 				}
 
 				//find or create an associated userdata object
-				let instance=this.get_mut(dom)?;
-				if let Some(value)=get_or_create_userdata(instance,lua,index_str)?{
+				if let Some(value)=instance_value_store_mut(lua,|ivs|{
+					//TODO: walk class tree somehow
+					match ivs.get_or_create_instance_values(&instance){
+						Some(mut instance_values)=>instance_values.get_or_create_value(lua,index_str),
+						None=>Ok(None)
+					}
+				})?{
 					return value.into_lua(lua);
 				}
-				// drop mutable borrow
 				//find a child with a matching name
-				let instance=this.get(dom)?;
 				find_first_child(dom,instance,index_str)
-				.map(|instance|Instance::new_unchecked(instance.referent()))
+				.map(|instance|Instance::new(instance.referent()))
 				.into_lua(lua)
 			})
 		});
 		methods.add_meta_function(mlua::MetaMethod::NewIndex,|lua,(this,index,value):(Instance,mlua::String,mlua::Value)|{
-			let index_str=&*index.to_str()?;
 			dom_mut(lua,|dom|{
 				let instance=this.get_mut(dom)?;
+				//println!("__newindex t={} i={index:?} v={value:?}",instance.name);
+				let index_str=&*index.to_str()?;
 				let db=rbx_reflection_database::get();
 				let class=db.classes.get(instance.class.as_str()).ok_or_else(||mlua::Error::runtime("Class missing"))?;
-				let property=db.superclasses_iter(class).find_map(|cls|
-					cls.properties.get(index_str)
-				).ok_or_else(||
-					mlua::Error::runtime(format!("Property '{index_str}' missing on class '{}'",class.name))
-				)?;
-				let value=match &property.data_type{
+				let mut iter=SuperClassIter{
+					database:db,
+					descriptor:Some(class),
+				};
+				let property=iter.find_map(|cls|cls.properties.get(index_str)).ok_or_else(||mlua::Error::runtime(format!("Property '{index_str}' missing on class '{}'",class.name)))?;
+				match &property.data_type{
+					rbx_reflection::DataType::Value(rbx_types::VariantType::Vector3)=>{
+						let typed_value:Vector3=*value.as_userdata().ok_or_else(||mlua::Error::runtime("Expected Userdata"))?.borrow()?;
+						instance.properties.insert(index_str.to_owned(),rbx_types::Variant::Vector3(typed_value.into()));
+					},
 					rbx_reflection::DataType::Value(rbx_types::VariantType::Float32)=>{
-						let typed_value=Number::from_lua(value.clone(),lua)?.to_f32();
-						rbx_types::Variant::Float32(typed_value)
+						let typed_value:f32=coerce_float32(&value).ok_or_else(||mlua::Error::runtime("Expected f32"))?;
+						instance.properties.insert(index_str.to_owned(),rbx_types::Variant::Float32(typed_value));
 					},
 					rbx_reflection::DataType::Enum(enum_name)=>{
 						let typed_value=match &value{
 							&mlua::Value::Integer(int)=>Ok(rbx_types::Enum::from_u32(int as u32)),
 							&mlua::Value::Number(num)=>Ok(rbx_types::Enum::from_u32(num as u32)),
 							mlua::Value::String(s)=>{
-								let e=db.enums.get(enum_name).ok_or_else(||mlua::Error::runtime("Database DataType Enum name does not exist"))?;
+								let e=db.enums.get(enum_name).ok_or_else(||mlua::Error::runtime("Database DataType Enum name  does not exist"))?;
 								Ok(rbx_types::Enum::from_u32(*e.items.get(&*s.to_str()?).ok_or_else(||mlua::Error::runtime("Invalid enum item"))?))
 							},
 							mlua::Value::UserData(any_user_data)=>{
-								let e:crate::runner::r#enum::EnumItem=*any_user_data.borrow()?;
+								let e:crate::runner::r#enum::Enum=*any_user_data.borrow()?;
 								Ok(e.into())
 							},
 							_=>Err(mlua::Error::runtime("Expected Enum")),
 						}?;
-						rbx_types::Variant::Enum(typed_value)
+						instance.properties.insert(index_str.to_owned(),rbx_types::Variant::Enum(typed_value));
 					},
 					rbx_reflection::DataType::Value(rbx_types::VariantType::Color3)=>{
 						let typed_value:crate::runner::color3::Color3=*value.as_userdata().ok_or_else(||mlua::Error::runtime("Expected Color3"))?.borrow()?;
-						rbx_types::Variant::Color3(typed_value.into())
+						instance.properties.insert(index_str.to_owned(),rbx_types::Variant::Color3(typed_value.into()));
 					},
 					rbx_reflection::DataType::Value(rbx_types::VariantType::Bool)=>{
 						let typed_value=value.as_boolean().ok_or_else(||mlua::Error::runtime("Expected boolean"))?;
-						rbx_types::Variant::Bool(typed_value)
-					},
-					rbx_reflection::DataType::Value(rbx_types::VariantType::Int32)=>{
-						let typed_value=value.as_i32().ok_or_else(||mlua::Error::runtime("Expected Int32"))?;
-						rbx_types::Variant::Int32(typed_value)
+						instance.properties.insert(index_str.to_owned(),rbx_types::Variant::Bool(typed_value));
 					},
 					rbx_reflection::DataType::Value(rbx_types::VariantType::String)=>{
-						let typed_value=match &value{
-							mlua::Value::Integer(i)=>i.to_string(),
-							mlua::Value::Number(n)=>n.to_string(),
-							mlua::Value::String(s)=>s.to_str()?.to_owned(),
-							_=>return Err(mlua::Error::runtime("Expected string")),
-						};
-						rbx_types::Variant::String(typed_value)
-					},
-					rbx_reflection::DataType::Value(rbx_types::VariantType::UDim2)=>{
-						let typed_value:&crate::runner::udim2::UDim2=&*value.as_userdata().ok_or_else(||mlua::Error::runtime("Expected UDim2"))?.borrow()?;
-						rbx_types::Variant::UDim2(typed_value.clone().into())
-					},
-					rbx_reflection::DataType::Value(rbx_types::VariantType::NumberRange)=>{
-						let typed_value:&crate::runner::number_range::NumberRange=&*value.as_userdata().ok_or_else(||mlua::Error::runtime("Expected NumberRange"))?.borrow()?;
-						rbx_types::Variant::NumberRange(typed_value.clone().into())
+						let typed_value=value.as_str().ok_or_else(||mlua::Error::runtime("Expected boolean"))?;
+						instance.properties.insert(index_str.to_owned(),rbx_types::Variant::String(typed_value.to_owned()));
 					},
 					rbx_reflection::DataType::Value(rbx_types::VariantType::NumberSequence)=>{
-						let typed_value:&crate::runner::number_sequence::NumberSequence=&*value.as_userdata().ok_or_else(||mlua::Error::runtime("Expected NumberSequence"))?.borrow()?;
-						rbx_types::Variant::NumberSequence(typed_value.clone().into())
+						let typed_value:crate::runner::number_sequence::NumberSequence=*value.as_userdata().ok_or_else(||mlua::Error::runtime("Expected NumberSequence"))?.borrow()?;
+						instance.properties.insert(index_str.to_owned(),rbx_types::Variant::NumberSequence(typed_value.into()));
 					},
 					rbx_reflection::DataType::Value(rbx_types::VariantType::ColorSequence)=>{
-						let typed_value:&crate::runner::color_sequence::ColorSequence=&*value.as_userdata().ok_or_else(||mlua::Error::runtime("Expected ColorSequence"))?.borrow()?;
-						rbx_types::Variant::ColorSequence(typed_value.clone().into())
-					},
-					rbx_reflection::DataType::Value(rbx_types::VariantType::Vector2)=>{
-						let typed_value:crate::runner::vector2::Vector2=*value.as_userdata().ok_or_else(||mlua::Error::runtime("Expected Vector2"))?.borrow()?;
-						rbx_types::Variant::Vector2(typed_value.clone().into())
-					},
-					rbx_reflection::DataType::Value(rbx_types::VariantType::Vector3)=>{
-						let typed_value:crate::runner::vector3::Vector3=*value.as_userdata().ok_or_else(||mlua::Error::runtime("Expected Vector3"))?.borrow()?;
-						rbx_types::Variant::Vector3(typed_value.clone().into())
-					},
-					rbx_reflection::DataType::Value(rbx_types::VariantType::CFrame)=>{
-						let typed_value:crate::runner::cframe::CFrame=*value.as_userdata().ok_or_else(||mlua::Error::runtime("Expected CFrame"))?.borrow()?;
-						rbx_types::Variant::CFrame(typed_value.clone().into())
-					},
-					rbx_reflection::DataType::Value(rbx_types::VariantType::ContentId)=>{
-						let typed_value=value.as_str().ok_or_else(||mlua::Error::runtime("Expected string"))?.to_owned();
-						rbx_types::Variant::ContentId(typed_value.into())
-					},
-					rbx_reflection::DataType::Value(rbx_types::VariantType::Ref)=>{
-						// why clone?
-						let typed_value=Option::<Instance>::from_lua(value.clone(),lua)?;
-						rbx_types::Variant::Ref(typed_value.map_or(Ref::none(),|instance|instance.referent))
+						let typed_value:crate::runner::color_sequence::ColorSequence=*value.as_userdata().ok_or_else(||mlua::Error::runtime("Expected ColorSequence"))?.borrow()?;
+						instance.properties.insert(index_str.to_owned(),rbx_types::Variant::ColorSequence(typed_value.into()));
 					},
 					other=>return Err(mlua::Error::runtime(format!("Unimplemented property type: {other:?}"))),
-				};
-				// the index is known to be a real property at this point
-				// allow creating a permanent ustr (memory leak)
-				let index_ustr=rbx_dom_weak::ustr(index_str);
-				instance.properties.insert(index_ustr,value);
+				}
 				Ok(())
 			})
 		});
@@ -457,53 +372,28 @@ type CFD=phf::Map<&'static str,// Class name
 		ClassFunctionPointer
 	>
 >;
-const GET_SERVICE:ClassFunctionPointer=cf!(|lua,_this,service:mlua::String|{
-	dom_mut(lua,|dom|{
-		//dom.root_ref()==this.referent ?
-		let service=&*service.to_str()?;
-		match service{
-			"Lighting"|"RunService"|"Players"|"Workspace"|"MaterialService"|"TweenService"=>{
-				let referent=find_first_child_of_class(dom,dom.root(),service)
-				.map(|instance|instance.referent())
-				.unwrap_or_else(||
-					dom.insert(dom.root_ref(),InstanceBuilder::new(service))
-				);
-				Ok(Instance::new_unchecked(referent))
-			},
-			other=>Err(mlua::Error::runtime(format!("Service '{other}' not supported"))),
-		}
-	})
-});
-const GET_PLAYERS:ClassFunctionPointer=cf!(|_lua,_this,()|->mlua::Result<_>{
-	Ok(Vec::<Instance>::new())
-});
-const NO_OP:ClassFunctionPointer=cf!(|_lua,_this,_:mlua::MultiValue|->mlua::Result<_>{Ok(())});
 static CLASS_FUNCTION_DATABASE:CFD=phf::phf_map!{
 	"DataModel"=>phf::phf_map!{
-		"service"=>GET_SERVICE,
-		"GetService"=>GET_SERVICE,
+		"GetService"=>cf!(|lua,_this,service:mlua::String|{
+			dom_mut(lua,|dom|{
+				//dom.root_ref()==this.referent ?
+				let service=&*service.to_str()?;
+				match service{
+					"Lighting"|"RunService"=>{
+						let referent=find_first_child_of_class(dom,dom.root(),service)
+        				.map(|instance|instance.referent())
+						.unwrap_or_else(||
+							dom.insert(dom.root_ref(),InstanceBuilder::new(service))
+						);
+						Ok(Instance::new(referent))
+					},
+					other=>Err::<Instance,_>(mlua::Error::runtime(format!("Service '{other}' not supported"))),
+				}
+			})
+		}),
 	},
 	"Terrain"=>phf::phf_map!{
-		"FillBall"=>cf!(|_lua,_,_:(Vector3,Number,crate::runner::r#enum::CoerceEnum)|mlua::Result::Ok(())),
-		"FillBlock"=>cf!(|_lua,_,_:(crate::runner::cframe::CFrame,Vector3,crate::runner::r#enum::CoerceEnum)|mlua::Result::Ok(())),
-		"FillCylinder"=>cf!(|_lua,_,_:(crate::runner::cframe::CFrame,Number,Number,crate::runner::r#enum::CoerceEnum)|mlua::Result::Ok(())),
-		"SetMaterialColor"=>cf!(|_lua,_,_:(crate::runner::r#enum::CoerceEnum,crate::runner::color3::Color3)|mlua::Result::Ok(())),
-	},
-	"Players"=>phf::phf_map!{
-		"players"=>GET_PLAYERS,
-		"GetPlayers"=>GET_PLAYERS,
-	},
-	"Sound"=>phf::phf_map!{
-		"Play"=>NO_OP,
-	},
-	"TweenService"=>phf::phf_map!{
-		"Create"=>cf!(|_lua,_,(instance,tween_info,goal):(Instance,crate::runner::tween_info::TweenInfo,mlua::Table)|->mlua::Result<_>{
-			Ok(crate::runner::tween::Tween::create(
-				instance,
-				tween_info,
-				goal,
-			))
-		}),
+		"FillBlock"=>cf!(|_lua,_,_:(crate::runner::cframe::CFrame,Vector3,crate::runner::r#enum::Enum)|mlua::Result::Ok(()))
 	},
 };
 
@@ -590,70 +480,78 @@ static VIRTUAL_PROPERTY_DATABASE:VPD=phf::phf_map!{
 };
 
 fn find_virtual_property(
-	properties:&rbx_dom_weak::UstrMap<rbx_types::Variant>,
+	properties:&HashMap<String,rbx_types::Variant>,
 	class:&rbx_reflection::ClassDescriptor,
-	index:&str,
+	index:&str
 )->Option<rbx_types::Variant>{
 	//Find virtual property
 	let class_virtual_properties=VIRTUAL_PROPERTY_DATABASE.get(&class.name)?;
 	let virtual_property=class_virtual_properties.get(index)?;
 
 	//Get source property
-	let variant=properties.get(&static_ustr(virtual_property.property))?;
+	let variant=properties.get(virtual_property.property)?;
 
 	//Transform Source property with provided function
 	(virtual_property.pointer)(variant)
 }
 
 // lazy-loaded per-instance userdata values
+// This whole thing is a bad idea and a garbage collection nightmare.
+// TODO: recreate rbx_dom_weak with my own instance type that owns this data.
 type CreateUserData=fn(&mlua::Lua)->mlua::Result<mlua::AnyUserData>;
 type LUD=phf::Map<&'static str,// Class name
 	phf::Map<&'static str,// Value name
 		CreateUserData
 	>
 >;
-fn create_script_signal(lua:&mlua::Lua)->mlua::Result<mlua::AnyUserData>{
-	lua.create_any_userdata(crate::runner::script_signal::ScriptSignal::new())
-}
 static LAZY_USER_DATA:LUD=phf::phf_map!{
 	"RunService"=>phf::phf_map!{
-		"Stepped"=>create_script_signal,
-		"Heartbeat"=>create_script_signal,
-		"RenderStepped"=>create_script_signal,
-	},
-	"Players"=>phf::phf_map!{
-		"PlayerAdded"=>create_script_signal,
-	},
-	"BasePart"=>phf::phf_map!{
-		"Touched"=>create_script_signal,
-		"TouchEnded"=>create_script_signal,
-	},
-	"Instance"=>phf::phf_map!{
-		"ChildAdded"=>create_script_signal,
-		"ChildRemoved"=>create_script_signal,
-		"DescendantAdded"=>create_script_signal,
-		"DescendantRemoved"=>create_script_signal,
-	},
-	"ClickDetector"=>phf::phf_map!{
-		"MouseClick"=>create_script_signal,
+		"RenderStepped"=>|lua|{
+			lua.create_any_userdata(crate::runner::script_signal::ScriptSignal::new())
+		},
 	},
 };
-fn get_or_create_userdata(instance:&mut rbx_dom_weak::Instance,lua:&mlua::Lua,index:&str)->mlua::Result<Option<mlua::AnyUserData>>{
-	use std::collections::hash_map::Entry;
-	let db=rbx_reflection_database::get();
-	let Some(class)=db.classes.get(instance.class.as_str())else{
-		return Ok(None)
-	};
-	if let Some((&static_str,create_userdata))=db.superclasses_iter(class).find_map(|superclass|
-		// find pair (class,index)
-		LAZY_USER_DATA.get(&superclass.name)
-		.and_then(|map|map.get_entry(index))
-	){
-		let index_ustr=static_ustr(static_str);
-		return Ok(Some(match instance.userdata.entry(index_ustr){
-			Entry::Occupied(entry)=>entry.get().clone(),
-			Entry::Vacant(entry)=>entry.insert(create_userdata(lua)?).clone(),
-		}));
-	}
-	Ok(None)
+#[derive(Default)]
+pub struct InstanceValueStore{
+	values:HashMap<Ref,
+		HashMap<&'static str,
+			mlua::AnyUserData
+		>
+	>,
+}
+pub struct InstanceValues<'a>{
+	named_values:&'static phf::Map<&'static str,CreateUserData>,
+	values:&'a mut HashMap<&'static str,mlua::AnyUserData>,
+}
+impl InstanceValueStore{
+	pub fn get_or_create_instance_values(&mut self,instance:&rbx_dom_weak::Instance)->Option<InstanceValues>{
+		LAZY_USER_DATA.get(instance.class.as_str())
+			.map(|named_values|
+				InstanceValues{
+					named_values,
+					values:self.values.entry(instance.referent())
+					.or_insert_with(||HashMap::new()),
+				}
+			)
+	}
+}
+impl InstanceValues<'_>{
+	pub fn get_or_create_value(&mut self,lua:&mlua::Lua,index:&str)->mlua::Result<Option<mlua::AnyUserData>>{
+		Ok(match self.named_values.get_entry(index){
+			Some((&static_index_str,&function_pointer))=>Some(
+				match self.values.entry(static_index_str){
+					Entry::Occupied(entry)=>entry.get().clone(),
+					Entry::Vacant(entry)=>entry.insert(
+						function_pointer(lua)?
+					).clone(),
+				}
+			),
+			None=>None,
+		})
+	}
+}
+
+pub fn instance_value_store_mut<T>(lua:&mlua::Lua,mut f:impl FnMut(&mut InstanceValueStore)->mlua::Result<T>)->mlua::Result<T>{
+	let mut cf=lua.app_data_mut::<InstanceValueStore>().ok_or_else(||mlua::Error::runtime("InstanceValueStore missing"))?;
+	f(&mut *cf)
 }

lib/roblox_emulator/src/runner/macros.rs

@@ -10,18 +10,6 @@ macro_rules! type_from_lua_userdata{
 		}
 	};
 }
-macro_rules! type_from_lua_userdata_clone{
-	($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>()?.clone()),
-					other=>Err(mlua::Error::runtime(format!("Expected {} got {:?}",stringify!($ty),other))),
-				}
-			}
-		}
-	};
-}
 macro_rules! type_from_lua_userdata_lua_lifetime{
 	($ty:ident)=>{
 		impl mlua::FromLua for $ty<'static>{

lib/roblox_emulator/src/runner/mod.rs

@@ -3,19 +3,10 @@ mod macros;
 mod runner;
 
 mod r#enum;
-mod task;
-mod udim;
-mod tween;
-mod udim2;
 mod color3;
 mod cframe;
-mod number;
-mod vector2;
 mod vector3;
-mod brickcolor;
-mod tween_info;
 pub mod instance;
-mod number_range;
 mod script_signal;
 mod color_sequence;
 mod number_sequence;

lib/roblox_emulator/src/runner/number.rs

@@ -1,43 +0,0 @@
-// the goal of this module is to provide an intermediate type
-// that is guaranteed to be some kind of number, and provide
-// methods to coerce it into various more specific types.
-
-#[derive(Clone,Copy)]
-pub enum Number{
-	Integer(i32),
-	Number(f64),
-}
-macro_rules! impl_ty{
-	($ident:ident,$ty:ty)=>{
-		impl Number{
-			#[inline]
-			pub fn $ident(self)->$ty{
-				match self{
-					Self::Integer(int)=>int as $ty,
-					Self::Number(num)=>num as $ty,
-				}
-			}
-		}
-		impl From<Number> for $ty{
-			fn from(value:Number)->$ty{
-				value.$ident()
-			}
-		}
-	};
-}
-impl_ty!(to_u32,u32);
-impl_ty!(to_i32,i32);
-impl_ty!(to_f32,f32);
-impl_ty!(to_u64,u64);
-impl_ty!(to_i64,i64);
-impl_ty!(to_f64,f64);
-
-impl mlua::FromLua for Number{
-	fn from_lua(value:mlua::Value,_lua:&mlua::Lua)->Result<Self,mlua::Error>{
-		match value{
-			mlua::Value::Integer(int)=>Ok(Number::Integer(int)),
-			mlua::Value::Number(num)=>Ok(Number::Number(num)),
-			other=>Err(mlua::Error::runtime(format!("Expected {} got {:?}",stringify!(Number),other))),
-		}
-	}
-}

lib/roblox_emulator/src/runner/number_range.rs

@@ -1,34 +0,0 @@
-use super::number::Number;
-
-#[derive(Clone)]
-pub struct NumberRange(rbx_types::NumberRange);
-impl NumberRange{
-	pub const fn new(min:f32,max:f32)->Self{
-		Self(rbx_types::NumberRange{min,max})
-	}
-}
-impl From<NumberRange> for rbx_types::NumberRange{
-	fn from(NumberRange(value):NumberRange)->rbx_types::NumberRange{
-		value
-	}
-}
-
-pub fn set_globals(lua:&mlua::Lua,globals:&mlua::Table)->Result<(),mlua::Error>{
-	let table=lua.create_table()?;
-
-	table.raw_set("new",
-		lua.create_function(|_,(min,max):(Number,Option<Number>)|{
-			Ok(match max{
-				Some(max)=>NumberRange::new(min.into(),max.into()),
-				None=>NumberRange::new(min.into(),min.into()),
-			})
-		})?
-	)?;
-
-	globals.set("NumberRange",table)?;
-
-	Ok(())
-}
-
-impl mlua::UserData for NumberRange{}
-type_from_lua_userdata_clone!(NumberRange);

lib/roblox_emulator/src/runner/number_sequence.rs

@@ -1,36 +1,31 @@
-#[derive(Clone)]
-pub struct NumberSequence(rbx_types::NumberSequence);
+#[derive(Clone,Copy)]
+pub struct NumberSequence{}
 impl NumberSequence{
-	pub const fn new(keypoints:Vec<rbx_types::NumberSequenceKeypoint>)->Self{
-		Self(rbx_types::NumberSequence{keypoints})
+	pub const fn new()->Self{
+		Self{}
 	}
 }
-impl From<NumberSequence> for rbx_types::NumberSequence{
-	fn from(NumberSequence(value):NumberSequence)->rbx_types::NumberSequence{
-		value
+impl Into<rbx_types::NumberSequence> for NumberSequence{
+	fn into(self)->rbx_types::NumberSequence{
+		rbx_types::NumberSequence{
+			keypoints:Vec::new()
+		}
 	}
 }
 
 pub fn set_globals(lua:&mlua::Lua,globals:&mlua::Table)->Result<(),mlua::Error>{
-	let table=lua.create_table()?;
+	let number_sequence_table=lua.create_table()?;
 
-	table.raw_set("new",
+	number_sequence_table.raw_set("new",
 		lua.create_function(|_,_:mlua::MultiValue|
-			Ok(NumberSequence::new(Vec::new()))
+			Ok(NumberSequence::new())
 		)?
 	)?;
 
-	globals.set("NumberSequence",table)?;
+	globals.set("NumberSequence",number_sequence_table)?;
 
 	Ok(())
 }
 
 impl mlua::UserData for NumberSequence{}
-impl mlua::FromLua for NumberSequence{
-	fn from_lua(value:mlua::Value,_lua:&mlua::Lua)->Result<Self,mlua::Error>{
-		match value{
-			mlua::Value::UserData(ud)=>Ok(ud.borrow::<Self>()?.clone()),
-			other=>Err(mlua::Error::runtime(format!("Expected {} got {:?}",stringify!(NumberSequence),other))),
-		}
-	}
-}
+type_from_lua_userdata!(NumberSequence);

lib/roblox_emulator/src/runner/runner.rs

@@ -1,5 +1,4 @@
 use crate::context::Context;
-use crate::util::static_ustr;
 #[cfg(feature="run-service")]
 use crate::scheduler::scheduler_mut;
 
@@ -13,7 +12,7 @@ pub enum Error{
 		error:mlua::Error
 	},
 	RustLua(mlua::Error),
-	Services(crate::context::ServicesError),
+	NoServices,
 }
 impl std::fmt::Display for Error{
 	fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
@@ -32,19 +31,14 @@ fn init(lua:&mlua::Lua)->mlua::Result<()>{
 	//global environment
 	let globals=lua.globals();
 
-	super::task::set_globals(lua,&globals)?;
+	#[cfg(feature="run-service")]
+	crate::scheduler::set_globals(lua,&globals)?;
 	super::script_signal::set_globals(lua,&globals)?;
 	super::r#enum::set_globals(lua,&globals)?;
-	super::udim::set_globals(lua,&globals)?;
-	super::udim2::set_globals(lua,&globals)?;
 	super::color3::set_globals(lua,&globals)?;
-	super::brickcolor::set_globals(lua,&globals)?;
-	super::vector2::set_globals(lua,&globals)?;
 	super::vector3::set_globals(lua,&globals)?;
 	super::cframe::set_globals(lua,&globals)?;
 	super::instance::instance::set_globals(lua,&globals)?;
-	super::tween_info::set_globals(lua,&globals)?;
-	super::number_range::set_globals(lua,&globals)?;
 	super::number_sequence::set_globals(lua,&globals)?;
 	super::color_sequence::set_globals(lua,&globals)?;
 
@@ -60,21 +54,22 @@ impl Runner{
 		Ok(runner)
 	}
 	pub fn runnable_context<'a>(self,context:&'a mut Context)->Result<Runnable<'a>,Error>{
+		let services=context.find_services().ok_or(Error::NoServices)?;
+		self.runnable_context_with_services(context,&services)
+	}
+	pub fn runnable_context_with_services<'a>(self,context:&'a mut Context,services:&crate::context::Services)->Result<Runnable<'a>,Error>{
 		{
 			let globals=self.lua.globals();
-			globals.set("game",super::instance::Instance::new_unchecked(context.services.game)).map_err(Error::RustLua)?;
-			globals.set("workspace",super::instance::Instance::new_unchecked(context.services.workspace)).map_err(Error::RustLua)?;
+			globals.set("game",super::instance::Instance::new(services.game)).map_err(Error::RustLua)?;
+			globals.set("workspace",super::instance::Instance::new(services.workspace)).map_err(Error::RustLua)?;
 		}
-		// SAFETY: This is not a &'static mut WeakDom,
-		// but as long as Runnable<'a> holds the lifetime of &'a mut Context
-		// it is a valid unique reference.
-		let ptr=&mut context.dom as *mut rbx_dom_weak::WeakDom;
-		self.lua.set_app_data::<crate::context::LuaAppData>(unsafe{&mut*ptr});
+		//this makes set_app_data shut up about the lifetime
+		self.lua.set_app_data::<&'static mut rbx_dom_weak::WeakDom>(unsafe{core::mem::transmute(&mut context.dom)});
 		#[cfg(feature="run-service")]
 		self.lua.set_app_data::<crate::scheduler::Scheduler>(crate::scheduler::Scheduler::default());
 		Ok(Runnable{
 			lua:self.lua,
-			_lifetime:std::marker::PhantomData
+			_lifetime:&std::marker::PhantomData
 		})
 	}
 }
@@ -82,11 +77,11 @@ impl Runner{
 //Runnable is the same thing but has context set, which it holds the lifetime for.
 pub struct Runnable<'a>{
 	lua:mlua::Lua,
-	_lifetime:std::marker::PhantomData<&'a ()>
+	_lifetime:&'a std::marker::PhantomData<()>
 }
 impl Runnable<'_>{
 	pub fn drop_context(self)->Runner{
-		self.lua.remove_app_data::<crate::context::LuaAppData>();
+		self.lua.remove_app_data::<&'static mut rbx_dom_weak::WeakDom>();
 		#[cfg(feature="run-service")]
 		self.lua.remove_app_data::<crate::scheduler::Scheduler>();
 		Runner{
@@ -128,15 +123,20 @@ impl Runnable<'_>{
 	}
 	#[cfg(feature="run-service")]
 	pub fn run_service_step(&self)->Result<(),mlua::Error>{
-		let render_stepped_signal=super::instance::instance::dom_mut(&self.lua,|dom|{
+		let render_stepped=super::instance::instance::dom_mut(&self.lua,|dom|{
 			let run_service=super::instance::instance::find_first_child_of_class(dom,dom.root(),"RunService").ok_or_else(||mlua::Error::runtime("RunService missing"))?;
-			Ok(match run_service.userdata.get(&static_ustr("RenderStepped")){
-				Some(render_stepped)=>Some(render_stepped.borrow::<super::script_signal::ScriptSignal>()?.clone()),
-				None=>None
+			super::instance::instance::instance_value_store_mut(&self.lua,|instance_value_store|{
+				//unwrap because I trust my find_first_child_of_class function to
+				let mut instance_values=instance_value_store.get_or_create_instance_values(run_service).ok_or_else(||mlua::Error::runtime("RunService InstanceValues missing"))?;
+				let render_stepped=instance_values.get_or_create_value(&self.lua,"RenderStepped")?;
+				//let stepped=instance_values.get_or_create_value(&self.lua,"Stepped")?;
+				//let heartbeat=instance_values.get_or_create_value(&self.lua,"Heartbeat")?;
+				Ok(render_stepped)
 			})
 		})?;
-		if let Some(render_stepped_signal)=render_stepped_signal{
-			render_stepped_signal.fire(&mlua::MultiValue::new());
+		if let Some(render_stepped)=render_stepped{
+			let signal:&super::script_signal::ScriptSignal=&*render_stepped.borrow()?;
+			signal.fire(&mlua::MultiValue::new());
 		}
 		Ok(())
 	}

lib/roblox_emulator/src/runner/script_signal.rs

@@ -98,9 +98,12 @@ impl ScriptConnection{
 
 impl mlua::UserData for ScriptSignal{
 	fn add_methods<M:mlua::UserDataMethods<Self>>(methods:&mut M){
-		methods.add_method("connect",|_lua,this,f:mlua::Function|Ok(this.connect(f)));
-		methods.add_method("Connect",|_lua,this,f:mlua::Function|Ok(this.connect(f)));
-		methods.add_method("Once",|_lua,this,f:mlua::Function|Ok(this.once(f)));
+		methods.add_method("Connect",|_lua,this,f:mlua::Function|
+			Ok(this.connect(f))
+		);
+		methods.add_method("Once",|_lua,this,f:mlua::Function|
+			Ok(this.once(f))
+		);
 		// Fire is not allowed to be called from Lua
 		// methods.add_method("Fire",|_lua,this,args:mlua::MultiValue|
 		// 	Ok(this.fire(args))
@@ -161,7 +164,6 @@ pub fn set_globals(lua:&mlua::Lua,globals:&mlua::Table)->Result<(),mlua::Error>{
 	.call::<mlua::Function>(())?;
 
 	lua.register_userdata_type::<ScriptSignal>(|reg|{
-		reg.add_field("wait",wait.clone());
 		reg.add_field("Wait",wait);
 		mlua::UserData::register(reg);
 	})?;

lib/roblox_emulator/src/runner/task.rs

@@ -1,42 +0,0 @@
-#[cfg(not(feature="run-service"))]
-fn no_op(_lua:&mlua::Lua,_time:Option<super::number::Number>)->mlua::Result<f64>{
-	Ok(0.0)
-}
-fn tick(_lua:&mlua::Lua,_:())->mlua::Result<f64>{
-	Ok(0.0)
-}
-// This is used to avoid calling coroutine.yield from the rust side.
-const LUA_WAIT:&str=
-"local coroutine_yield=coroutine.yield
-local schedule_thread=schedule_thread
-return function(dt)
-	schedule_thread(dt)
-	return coroutine_yield()
-end";
-
-pub fn set_globals(lua:&mlua::Lua,globals:&mlua::Table)->Result<(),mlua::Error>{
-	let coroutine_table=globals.get::<mlua::Table>("coroutine")?;
-	#[cfg(feature="run-service")]
-	let schedule_thread=lua.create_function(crate::scheduler::schedule_thread)?;
-	#[cfg(not(feature="run-service"))]
-	let schedule_thread=lua.create_function(no_op)?;
-
-	//create wait function environment
-	let wait_env=lua.create_table()?;
-	wait_env.raw_set("coroutine",coroutine_table)?;
-	wait_env.raw_set("schedule_thread",schedule_thread)?;
-
-	//construct wait function from Lua code
-	let wait=lua.load(LUA_WAIT)
-	.set_name("wait")
-	.set_environment(wait_env)
-	.call::<mlua::Function>(())?;
-
-	globals.raw_set("wait",wait)?;
-
-	// TODO: move this somewhere it belongs
-	let tick=lua.create_function(tick)?;
-	globals.raw_set("tick",tick)?;
-
-	Ok(())
-}

lib/roblox_emulator/src/runner/tween.rs

@@ -1,35 +0,0 @@
-use super::instance::Instance;
-use super::tween_info::TweenInfo;
-
-#[allow(dead_code)]
-#[derive(Clone)]
-pub struct Tween{
-	instance:Instance,
-	tween_info:TweenInfo,
-	goal:mlua::Table,
-	playback_state:rbx_types::Enum,
-}
-impl Tween{
-	pub fn create(
-		instance:Instance,
-		tween_info:TweenInfo,
-		goal:mlua::Table,
-	)->Self{
-		Self{
-			instance,
-			tween_info,
-			goal,
-			// Enum.PlaybackState.Begin
-			playback_state:rbx_types::Enum::from_u32(0),
-		}
-	}
-	pub fn play(&mut self){
-	}
-}
-
-impl mlua::UserData for Tween{
-	fn add_methods<M:mlua::UserDataMethods<Self>>(methods:&mut M){
-		methods.add_method_mut("Play",|_,this,()|Ok(this.play()))
-	}
-}
-type_from_lua_userdata_clone!(Tween);

lib/roblox_emulator/src/runner/tween_info.rs

@@ -1,45 +0,0 @@
-use super::number::Number;
-use super::r#enum::{CoerceEnum,Enums};
-
-#[allow(dead_code)]
-#[derive(Clone)]
-pub struct TweenInfo{
-	time:f64,
-	easing_style:rbx_types::Enum,
-	easing_direction:rbx_types::Enum,
-	repeat_count:u32,
-	reverses:bool,
-	delay_time:f64,
-}
-
-pub fn set_globals(lua:&mlua::Lua,globals:&mlua::Table)->Result<(),mlua::Error>{
-	let table=lua.create_table()?;
-
-	table.raw_set("new",
-		lua.create_function(|_,(time,easing_style,easing_direction,repeat_count,reverses,delay_time):(Option<Number>,Option<CoerceEnum>,Option<CoerceEnum>,Option<u32>,Option<bool>,Option<Number>)|{
-			Ok(TweenInfo{
-				time:time.map_or(1.0,Number::to_f64),
-				easing_style:match easing_style{
-					// Enum.EasingStyle.Quad
-					None=>rbx_types::Enum::from_u32(3),
-					Some(e)=>e.coerce_to(Enums.get("EasingStyle").unwrap())?.into(),
-				},
-				easing_direction:match easing_direction{
-					// Enum.EasingDirection.Out
-					None=>rbx_types::Enum::from_u32(1),
-					Some(e)=>e.coerce_to(Enums.get("EasingDirection").unwrap())?.into(),
-				},
-				repeat_count:repeat_count.unwrap_or(0),
-				reverses:reverses.unwrap_or(false),
-				delay_time:delay_time.map_or(0.0,Number::to_f64),
-			})
-		})?
-	)?;
-
-	globals.set("TweenInfo",table)?;
-
-	Ok(())
-}
-
-impl mlua::UserData for TweenInfo{}
-type_from_lua_userdata_clone!(TweenInfo);

lib/roblox_emulator/src/runner/udim.rs

@@ -1,36 +0,0 @@
-use super::number::Number;
-
-#[derive(Clone,Copy)]
-pub struct UDim(rbx_types::UDim);
-impl UDim{
-	pub fn new(scale:f32,offset:i32)->Self{
-		UDim(rbx_types::UDim::new(scale,offset))
-	}
-}
-impl From<rbx_types::UDim> for UDim{
-	fn from(value:rbx_types::UDim)->Self{
-		Self(value)
-	}
-}
-
-pub fn set_globals(lua:&mlua::Lua,globals:&mlua::Table)->Result<(),mlua::Error>{
-	let table=lua.create_table()?;
-
-	table.raw_set("new",
-		lua.create_function(|_,(scale,offset):(Number,i32)|
-			Ok(UDim::new(scale.into(),offset))
-		)?
-	)?;
-
-	globals.set("UDim",table)?;
-
-	Ok(())
-}
-
-impl mlua::UserData for UDim{
-	fn add_fields<F:mlua::UserDataFields<Self>>(fields:&mut F){
-		fields.add_field_method_get("Scale",|_,UDim(this)|Ok(this.scale));
-		fields.add_field_method_get("Offset",|_,UDim(this)|Ok(this.offset));
-	}
-}
-type_from_lua_userdata!(UDim);

lib/roblox_emulator/src/runner/udim2.rs

@@ -1,40 +0,0 @@
-use super::udim::UDim;
-use super::number::Number;
-
-#[derive(Clone,Copy)]
-pub struct UDim2(rbx_types::UDim2);
-impl UDim2{
-	pub fn new(sx:f32,ox:i32,sy:f32,oy:i32)->Self{
-		UDim2(rbx_types::UDim2::new(
-			rbx_types::UDim::new(sx,ox),
-			rbx_types::UDim::new(sy,oy),
-		))
-	}
-}
-impl From<UDim2> for rbx_types::UDim2{
-	fn from(UDim2(value):UDim2)->rbx_types::UDim2{
-		value
-	}
-}
-
-pub fn set_globals(lua:&mlua::Lua,globals:&mlua::Table)->Result<(),mlua::Error>{
-	let table=lua.create_table()?;
-
-	table.raw_set("new",
-		lua.create_function(|_,(sx,ox,sy,oy):(Number,i32,Number,i32)|
-			Ok(UDim2::new(sx.into(),ox,sy.into(),oy))
-		)?
-	)?;
-
-	globals.set("UDim2",table)?;
-
-	Ok(())
-}
-
-impl mlua::UserData for UDim2{
-	fn add_fields<F:mlua::UserDataFields<Self>>(fields:&mut F){
-		fields.add_field_method_get("X",|_,UDim2(this)|Ok(UDim::from(this.x)));
-		fields.add_field_method_get("Y",|_,UDim2(this)|Ok(UDim::from(this.y)));
-	}
-}
-type_from_lua_userdata!(UDim2);

lib/roblox_emulator/src/runner/vector2.rs

@@ -1,93 +0,0 @@
-use mlua::FromLua;
-
-use super::number::Number;
-
-#[derive(Clone,Copy)]
-pub struct Vector2(glam::Vec2);
-
-impl Vector2{
-	pub const fn new(x:f32,y:f32)->Self{
-		Self(glam::vec2(x,y))
-	}
-}
-
-pub fn set_globals(lua:&mlua::Lua,globals:&mlua::Table)->Result<(),mlua::Error>{
-	let table=lua.create_table()?;
-
-	//Vector2.new
-	table.raw_set("new",
-		lua.create_function(|_,(x,y):(Option<Number>,Option<Number>)|
-			match (x,y){
-				(Some(x),Some(y))=>Ok(Vector2::new(x.into(),y.into())),
-				(None,None)=>Ok(Vector2(glam::Vec2::ZERO)),
-				_=>Err(mlua::Error::runtime("Unsupported arguments to Vector2.new")),
-			}
-		)?
-	)?;
-
-	globals.set("Vector2",table)?;
-
-	Ok(())
-}
-
-impl From<Vector2> for rbx_types::Vector2{
-	fn from(Vector2(v):Vector2)->rbx_types::Vector2{
-		rbx_types::Vector2::new(v.x,v.y)
-	}
-}
-
-impl From<rbx_types::Vector2> for Vector2{
-	fn from(value:rbx_types::Vector2)->Vector2{
-		Vector2::new(value.x,value.y)
-	}
-}
-
-impl mlua::UserData for Vector2{
-	fn add_fields<F:mlua::UserDataFields<Self>>(fields:&mut F){
-		fields.add_field_method_get("magnitude",|_,Vector2(this)|Ok(this.length()));
-		fields.add_field_method_get("Magnitude",|_,Vector2(this)|Ok(this.length()));
-		fields.add_field_method_get("unit",|_,Vector2(this)|Ok(Vector2(this.normalize())));
-		fields.add_field_method_get("Unit",|_,Vector2(this)|Ok(Vector2(this.normalize())));
-		fields.add_field_method_get("x",|_,Vector2(this)|Ok(this.x));
-		fields.add_field_method_get("X",|_,Vector2(this)|Ok(this.x));
-		fields.add_field_method_get("y",|_,Vector2(this)|Ok(this.y));
-		fields.add_field_method_get("Y",|_,Vector2(this)|Ok(this.y));
-	}
-
-	fn add_methods<M:mlua::UserDataMethods<Self>>(methods:&mut M){
-		//methods.add_method("area",|_,this,()| Ok(this.length * this.width));
-
-		methods.add_meta_function(mlua::MetaMethod::Add,|_,(Vector2(this),Vector2(val)):(Self,Self)|Ok(Self(this+val)));
-		methods.add_meta_function(mlua::MetaMethod::Sub,|_,(Vector2(this),Vector2(val)):(Self,Self)|Ok(Self(this-val)));
-		methods.add_meta_function(mlua::MetaMethod::Mul,|lua,(lhs,rhs):(mlua::Value,mlua::Value)|{
-			match (lhs,rhs){
-				(mlua::Value::UserData(lhs),mlua::Value::UserData(rhs))=>lhs.borrow_scoped(|Vector2(lhs):&Vector2|rhs.borrow_scoped(|Vector2(rhs):&Vector2|Self(lhs*rhs)))?,
-				(lhs,mlua::Value::UserData(rhs))=>{
-					let lhs=Number::from_lua(lhs,lua)?;
-					rhs.borrow_scoped(|Vector2(rhs):&Vector2|Self(lhs.to_f32()*rhs))
-				},
-				(mlua::Value::UserData(lhs),rhs)=>{
-					let rhs=Number::from_lua(rhs,lua)?;
-					lhs.borrow_scoped(|Vector2(lhs):&Vector2|Self(lhs*rhs.to_f32()))
-				},
-				_=>Err(mlua::Error::runtime(format!("Expected Vector2")))
-			}
-		});
-		methods.add_meta_function(mlua::MetaMethod::Div,|_,(Vector2(this),val):(Self,mlua::Value)|{
-			match val{
-				mlua::Value::Integer(n)=>Ok(Self(this/(n as f32))),
-				mlua::Value::Number(n)=>Ok(Self(this/(n as f32))),
-				mlua::Value::UserData(ud)=>ud.borrow_scoped(|Vector2(rhs):&Vector2|Self(this/rhs)),
-				other=>Err(mlua::Error::runtime(format!("Attempt to divide Vector2 by {other:?}"))),
-			}
-		});
-		methods.add_meta_function(mlua::MetaMethod::ToString,|_,Vector2(this):Self|
-			Ok(format!("Vector2.new({},{})",
-				this.x,
-				this.y,
-			))
-		);
-	}
-}
-
-type_from_lua_userdata!(Vector2);

lib/roblox_emulator/src/runner/vector3.rs

@@ -1,7 +1,3 @@
-use mlua::FromLua;
-
-use super::number::Number;
-
 #[derive(Clone,Copy)]
 pub struct Vector3(pub(crate)glam::Vec3A);
 
@@ -12,27 +8,23 @@ impl Vector3{
 }
 
 pub fn set_globals(lua:&mlua::Lua,globals:&mlua::Table)->Result<(),mlua::Error>{
-	let table=lua.create_table()?;
+	let vector3_table=lua.create_table()?;
 
 	//Vector3.new
-	table.raw_set("new",
-		lua.create_function(|_,(x,y,z):(Option<Number>,Option<Number>,Option<Number>)|
-			match (x,y,z){
-				(Some(x),Some(y),Some(z))=>Ok(Vector3::new(x.into(),y.into(),z.into())),
-				(None,None,None)=>Ok(Vector3(glam::Vec3A::ZERO)),
-				_=>Err(mlua::Error::runtime("Unsupported arguments to Vector3.new")),
-			}
+	vector3_table.raw_set("new",
+		lua.create_function(|_,(x,y,z):(f32,f32,f32)|
+			Ok(Vector3::new(x,y,z))
 		)?
 	)?;
 
-	globals.set("Vector3",table)?;
+	globals.set("Vector3",vector3_table)?;
 
 	Ok(())
 }
 
-impl From<Vector3> for rbx_types::Vector3{
-	fn from(Vector3(v):Vector3)->rbx_types::Vector3{
-		rbx_types::Vector3::new(v.x,v.y,v.z)
+impl Into<rbx_types::Vector3> for Vector3{
+	fn into(self)->rbx_types::Vector3{
+		rbx_types::Vector3::new(self.0.x,self.0.y,self.0.z)
 	}
 }
 
@@ -44,50 +36,44 @@ impl From<rbx_types::Vector3> for Vector3{
 
 impl mlua::UserData for Vector3{
 	fn add_fields<F:mlua::UserDataFields<Self>>(fields:&mut F){
-		fields.add_field_method_get("magnitude",|_,Vector3(this)|Ok(this.length()));
-		fields.add_field_method_get("Magnitude",|_,Vector3(this)|Ok(this.length()));
-		fields.add_field_method_get("unit",|_,Vector3(this)|Ok(Vector3(this.normalize())));
-		fields.add_field_method_get("Unit",|_,Vector3(this)|Ok(Vector3(this.normalize())));
-		fields.add_field_method_get("x",|_,Vector3(this)|Ok(this.x));
-		fields.add_field_method_get("X",|_,Vector3(this)|Ok(this.x));
-		fields.add_field_method_get("y",|_,Vector3(this)|Ok(this.y));
-		fields.add_field_method_get("Y",|_,Vector3(this)|Ok(this.y));
-		fields.add_field_method_get("z",|_,Vector3(this)|Ok(this.z));
-		fields.add_field_method_get("Z",|_,Vector3(this)|Ok(this.z));
+		fields.add_field_method_get("magnitude",|_,this|Ok(this.0.length()));
+		fields.add_field_method_get("x",|_,this|Ok(this.0.x));
+		fields.add_field_method_set("x",|_,this,val|{
+			this.0.x=val;
+			Ok(())
+		});
+		fields.add_field_method_get("y",|_,this|Ok(this.0.y));
+		fields.add_field_method_set("y",|_,this,val|{
+			this.0.y=val;
+			Ok(())
+		});
+		fields.add_field_method_get("z",|_,this|Ok(this.0.z));
+		fields.add_field_method_set("z",|_,this,val|{
+			this.0.z=val;
+			Ok(())
+		});
 	}
 
 	fn add_methods<M:mlua::UserDataMethods<Self>>(methods:&mut M){
 		//methods.add_method("area",|_,this,()| Ok(this.length * this.width));
 
-		methods.add_meta_function(mlua::MetaMethod::Add,|_,(Vector3(this),Vector3(val)):(Self,Self)|Ok(Self(this+val)));
-		methods.add_meta_function(mlua::MetaMethod::Sub,|_,(Vector3(this),Vector3(val)):(Self,Self)|Ok(Self(this-val)));
-		methods.add_meta_function(mlua::MetaMethod::Mul,|lua,(lhs,rhs):(mlua::Value,mlua::Value)|{
-			match (lhs,rhs){
-				(mlua::Value::UserData(lhs),mlua::Value::UserData(rhs))=>lhs.borrow_scoped(|Vector3(lhs):&Vector3|rhs.borrow_scoped(|Vector3(rhs):&Vector3|Self(lhs*rhs)))?,
-				(lhs,mlua::Value::UserData(rhs))=>{
-					let lhs=Number::from_lua(lhs,lua)?;
-					rhs.borrow_scoped(|Vector3(rhs):&Vector3|Self(lhs.to_f32()*rhs))
-				},
-				(mlua::Value::UserData(lhs),rhs)=>{
-					let rhs=Number::from_lua(rhs,lua)?;
-					lhs.borrow_scoped(|Vector3(lhs):&Vector3|Self(lhs*rhs.to_f32()))
-				},
-				_=>Err(mlua::Error::runtime(format!("Expected Vector3")))
-			}
-		});
-		methods.add_meta_function(mlua::MetaMethod::Div,|_,(Vector3(this),val):(Self,mlua::Value)|{
+		methods.add_meta_function(mlua::MetaMethod::Add,|_,(this,val):(Self,Self)|Ok(Self(this.0+val.0)));
+		methods.add_meta_function(mlua::MetaMethod::Div,|_,(this,val):(Self,mlua::Value)|{
 			match val{
-				mlua::Value::Integer(n)=>Ok(Self(this/(n as f32))),
-				mlua::Value::Number(n)=>Ok(Self(this/(n as f32))),
-				mlua::Value::UserData(ud)=>ud.borrow_scoped(|Vector3(rhs):&Vector3|Self(this/rhs)),
+				mlua::Value::Integer(n)=>Ok(Self(this.0/(n as f32))),
+				mlua::Value::Number(n)=>Ok(Self(this.0/(n as f32))),
+				mlua::Value::UserData(ud)=>{
+					let rhs:Vector3=ud.take()?;
+					Ok(Self(this.0/rhs.0))
+				},
 				other=>Err(mlua::Error::runtime(format!("Attempt to divide Vector3 by {other:?}"))),
 			}
 		});
-		methods.add_meta_function(mlua::MetaMethod::ToString,|_,Vector3(this):Self|
+		methods.add_meta_function(mlua::MetaMethod::ToString,|_,this:Self|
 			Ok(format!("Vector3.new({},{},{})",
-				this.x,
-				this.y,
-				this.z,
+				this.0.x,
+				this.0.y,
+				this.0.z,
 			))
 		);
 	}

lib/roblox_emulator/src/scheduler.rs

@@ -51,7 +51,7 @@ pub fn scheduler_mut<T>(lua:&mlua::Lua,mut f:impl FnMut(&mut crate::scheduler::S
 	f(&mut *scheduler)
 }
 
-pub fn schedule_thread(lua:&mlua::Lua,dt:mlua::Value)->Result<(),mlua::Error>{
+fn schedule_thread(lua:&mlua::Lua,dt:mlua::Value)->Result<(),mlua::Error>{
 	let delay=match dt{
 		mlua::Value::Integer(i)=>i.max(0) as u64*60,
 		mlua::Value::Number(f)=>{
@@ -75,3 +75,32 @@ pub fn schedule_thread(lua:&mlua::Lua,dt:mlua::Value)->Result<(),mlua::Error>{
 		Ok(())
 	})
 }
+
+// This is used to avoid calling coroutine.yield from the rust side.
+const LUA_WAIT:&str=
+"local coroutine_yield=coroutine.yield
+local schedule_thread=schedule_thread
+return function(dt)
+	schedule_thread(dt)
+	return coroutine_yield()
+end";
+
+pub fn set_globals(lua:&mlua::Lua,globals:&mlua::Table)->Result<(),mlua::Error>{
+	let coroutine_table=globals.get::<mlua::Table>("coroutine")?;
+	let schedule_thread=lua.create_function(schedule_thread)?;
+
+	//create wait function environment
+	let wait_env=lua.create_table()?;
+	wait_env.raw_set("coroutine",coroutine_table)?;
+	wait_env.raw_set("schedule_thread",schedule_thread)?;
+
+	//construct wait function from Lua code
+	let wait=lua.load(LUA_WAIT)
+	.set_name("wait")
+	.set_environment(wait_env)
+	.call::<mlua::Function>(())?;
+
+	globals.raw_set("wait",wait)?;
+
+	Ok(())
+}

lib/roblox_emulator/src/util.rs

@@ -1,3 +0,0 @@
-pub fn static_ustr(s:&'static str)->rbx_dom_weak::Ustr{
-	rbx_dom_weak::ustr(s)
-}

lib/snf/src/newtypes/integer.rs

@@ -56,6 +56,8 @@ impl From<strafesnet_common::integer::Ratio64Vec2> for Ratio64Vec2{
 	}
 }
 
+pub type Angle32=i32;
 pub type Planar64=i64;
 pub type Planar64Vec3=[i64;3];
+pub type Planar64Mat3=[i64;9];
 pub type Planar64Affine3=[i64;12];

map-tool/Cargo.toml

@@ -13,11 +13,11 @@ futures = "0.3.31"
 image = "0.25.2"
 image_dds = "0.7.1"
 lazy-regex = "3.1.0"
-rbx_asset = { version = "0.4.4", registry = "strafesnet" }
-rbx_binary  = { version = "1.1.0-sn4", registry = "strafesnet" }
-rbx_dom_weak =  { version = "3.1.0-sn4", registry = "strafesnet" }
-rbx_reflection_database = "1.0.0"
-rbx_xml = { version = "1.1.0-sn4", registry = "strafesnet" }
+rbx_asset = { version = "0.2.5", registry = "strafesnet" }
+rbx_binary = { version = "0.7.4", registry = "strafesnet" }
+rbx_dom_weak = { version = "2.7.0", registry = "strafesnet" }
+rbx_reflection_database = { version = "0.2.10", registry = "strafesnet" }
+rbx_xml = { version = "0.13.3", registry = "strafesnet" }
 rbxassetid = { version = "0.1.0", registry = "strafesnet" }
 strafesnet_bsp_loader = { version = "0.3.0", path = "../lib/bsp_loader", registry = "strafesnet" }
 strafesnet_deferred_loader = { version = "0.5.0", path = "../lib/deferred_loader", registry = "strafesnet" }
@@ -25,7 +25,7 @@ strafesnet_rbx_loader = { version = "0.6.0", path = "../lib/rbx_loader", registr
 strafesnet_snf = { version = "0.3.0", path = "../lib/snf", registry = "strafesnet" }
 thiserror = "2.0.11"
 tokio = { version = "1.43.0", features = ["macros", "rt-multi-thread", "fs"] }
-vbsp = "0.9.1"
+vbsp = "0.8.0"
 vbsp-entities-css = "0.6.0"
 vmdl = "0.2.0"
 vmt-parser = "0.2.0"

map-tool/src/roblox.rs

@@ -8,11 +8,6 @@ use strafesnet_deferred_loader::deferred_loader::LoadFailureMode;
 use rbxassetid::RobloxAssetId;
 use tokio::io::AsyncReadExt;
 
-// disallow non-static lifetimes
-fn static_ustr(s:&'static str)->rbx_dom_weak::Ustr{
-	rbx_dom_weak::ustr(s)
-}
-
 const DOWNLOAD_LIMIT:usize=16;
 
 #[derive(Subcommand)]
@@ -93,45 +88,17 @@ SurfaceAppearance.NormalMap
 SurfaceAppearance.RoughnessMap
 SurfaceAppearance.TexturePack
 */
-/* These properties now use Content
-BaseWrap.CageMeshContent
-Decal.TextureContent
-ImageButton.ImageContent
-ImageLabel.ImageContent
-MeshPart.MeshContent
-MeshPart.TextureContent
-SurfaceAppearance.ColorMapContent
-SurfaceAppearance.MetalnessMapContent
-SurfaceAppearance.NormalMapContent
-SurfaceAppearance.RoughnessMapContent
-WrapLayer.ReferenceMeshContent
-*/
-
-fn accumulate_content(content_list:&mut HashSet<RobloxAssetId>,object:&Instance,property:&'static str){
-	let Some(rbx_dom_weak::types::Variant::Content(content))=object.properties.get(&static_ustr(property))else{
+fn accumulate_content_id(content_list:&mut HashSet<RobloxAssetId>,object:&Instance,property:&str){
+	if let Some(rbx_dom_weak::types::Variant::Content(content))=object.properties.get(property){
+		let url:&str=content.as_ref();
+		if let Ok(asset_id)=url.parse(){
+			content_list.insert(asset_id);
+		}else{
+			println!("Content failed to parse into AssetID: {:?}",content);
+		}
+	}else{
 		println!("property={} does not exist for class={}",property,object.class.as_str());
-		return;
-	};
-	let rbx_dom_weak::types::ContentType::Uri(uri)=content.value()else{
-		println!("ContentType is not Uri");
-		return;
-	};
-	let Ok(asset_id)=uri.parse()else{
-		println!("Content failed to parse into AssetID: {:?}",content);
-		return;
-	};
-	content_list.insert(asset_id);
-}
-fn accumulate_content_id(content_list:&mut HashSet<RobloxAssetId>,object:&Instance,property:&'static str){
-	let Some(rbx_dom_weak::types::Variant::ContentId(content))=object.properties.get(&static_ustr(property))else{
-		println!("property={} does not exist for class={}",property,object.class.as_str());
-		return;
-	};
-	let Ok(asset_id)=content.as_str().parse()else{
-		println!("Content failed to parse into AssetID: {:?}",content);
-		return;
-	};
-	content_list.insert(asset_id);
+	}
 }
 async fn read_entire_file(path:impl AsRef<Path>)->Result<Cursor<Vec<u8>>,std::io::Error>{
 	let mut file=tokio::fs::File::open(path).await?;
@@ -149,12 +116,12 @@ impl UniqueAssets{
 	fn collect(&mut self,object:&Instance){
 		match object.class.as_str(){
 			"Beam"=>accumulate_content_id(&mut self.textures,object,"Texture"),
-			"Decal"=>accumulate_content(&mut self.textures,object,"TextureContent"),
-			"Texture"=>accumulate_content(&mut self.textures,object,"TextureContent"),
+			"Decal"=>accumulate_content_id(&mut self.textures,object,"Texture"),
+			"Texture"=>accumulate_content_id(&mut self.textures,object,"Texture"),
 			"FileMesh"=>accumulate_content_id(&mut self.textures,object,"TextureId"),
 			"MeshPart"=>{
-				accumulate_content(&mut self.textures,object,"TextureContent");
-				accumulate_content(&mut self.meshes,object,"MeshContent");
+				accumulate_content_id(&mut self.textures,object,"TextureID");
+				accumulate_content_id(&mut self.meshes,object,"MeshId");
 			},
 			"SpecialMesh"=>accumulate_content_id(&mut self.meshes,object,"MeshId"),
 			"ParticleEmitter"=>accumulate_content_id(&mut self.textures,object,"Texture"),
@@ -198,16 +165,16 @@ enum DownloadType{
 impl DownloadType{
 	fn path(&self)->PathBuf{
 		match self{
-			DownloadType::Texture(RobloxAssetId(asset_id))=>format!("downloaded_textures/{asset_id}").into(),
-			DownloadType::Mesh(RobloxAssetId(asset_id))=>format!("meshes/{asset_id}").into(),
-			DownloadType::Union(RobloxAssetId(asset_id))=>format!("unions/{asset_id}").into(),
+			DownloadType::Texture(asset_id)=>format!("downloaded_textures/{}",asset_id.0.to_string()).into(),
+			DownloadType::Mesh(asset_id)=>format!("meshes/{}",asset_id.0.to_string()).into(),
+			DownloadType::Union(asset_id)=>format!("unions/{}",asset_id.0.to_string()).into(),
 		}
 	}
 	fn asset_id(&self)->u64{
 		match self{
-			&DownloadType::Texture(RobloxAssetId(asset_id))=>asset_id,
-			&DownloadType::Mesh(RobloxAssetId(asset_id))=>asset_id,
-			&DownloadType::Union(RobloxAssetId(asset_id))=>asset_id,
+			DownloadType::Texture(asset_id)=>asset_id.0,
+			DownloadType::Mesh(asset_id)=>asset_id.0,
+			DownloadType::Union(asset_id)=>asset_id.0,
 		}
 	}
 }
@@ -224,8 +191,9 @@ struct Stats{
 	failed_downloads:u32,
 	timed_out_downloads:u32,
 }
-async fn download_retry(stats:&mut Stats,context:&rbx_asset::cookie::Context,download_instruction:DownloadType)->Result<DownloadResult,std::io::Error>{
+async fn download_retry(stats:&mut Stats,context:&rbx_asset::cookie::CookieContext,download_instruction:DownloadType)->Result<DownloadResult,std::io::Error>{
 	stats.total_assets+=1;
+	let download_instruction=download_instruction;
 	// check if file exists on disk
 	let path=download_instruction.path();
 	if tokio::fs::try_exists(path.as_path()).await?{
@@ -245,11 +213,10 @@ async fn download_retry(stats:&mut Stats,context:&rbx_asset::cookie::Context,dow
 		match asset_result{
 			Ok(asset_result)=>{
 				stats.downloaded_assets+=1;
-				let data=asset_result.to_vec()?;
-				tokio::fs::write(path,&data).await?;
-				break Ok(DownloadResult::Data(data));
+				tokio::fs::write(path,&asset_result).await?;
+				break Ok(DownloadResult::Data(asset_result));
 			},
-			Err(rbx_asset::cookie::GetError::Response(rbx_asset::types::ResponseError::StatusCodeWithUrlAndBody(scwuab)))=>{
+			Err(rbx_asset::cookie::GetError::Response(rbx_asset::ResponseError::StatusCodeWithUrlAndBody(scwuab)))=>{
 				if scwuab.status_code.as_u16()==429{
 					if retry==12{
 						println!("Giving up asset download {asset_id}");
@@ -285,7 +252,7 @@ enum ConvertTextureError{
 	#[error("DDS write error {0:?}")]
 	DDSWrite(#[from]image_dds::ddsfile::Error),
 }
-async fn convert_texture(RobloxAssetId(asset_id):RobloxAssetId,download_result:DownloadResult)->Result<(),ConvertTextureError>{
+async fn convert_texture(asset_id:RobloxAssetId,download_result:DownloadResult)->Result<(),ConvertTextureError>{
 	let data=match download_result{
 		DownloadResult::Cached(path)=>tokio::fs::read(path).await?,
 		DownloadResult::Data(data)=>data,
@@ -310,7 +277,7 @@ async fn convert_texture(RobloxAssetId(asset_id):RobloxAssetId,download_result:D
 		image_dds::Mipmaps::GeneratedAutomatic,
 	)?;
 
-	let file_name=format!("textures/{asset_id}.dds");
+	let file_name=format!("textures/{}.dds",asset_id.0);
 	let mut file=std::fs::File::create(file_name)?;
 	dds.write(&mut file)?;
 	Ok(())
@@ -348,7 +315,7 @@ async fn download_assets(paths:Vec<PathBuf>,cookie:rbx_asset::cookie::Cookie)->A
 	// insert into global unique assets guy
 	// add to download queue if the asset is globally unique and does not already exist on disk
 	let mut stats=Stats::default();
-	let context=rbx_asset::cookie::Context::new(cookie);
+	let context=rbx_asset::cookie::CookieContext::new(cookie);
 	let mut globally_unique_assets=UniqueAssets::default();
 	// pop a job = retry_queue.pop_front() or ingest(recv.recv().await)
 	// SLOW MODE:
@@ -423,7 +390,7 @@ async fn convert_to_snf(path:&Path,output_folder:PathBuf)->AResult<()>{
 		std::io::Cursor::new(entire_file)
 	).map_err(ConvertError::RobloxRead)?;
 
-	let mut place=strafesnet_rbx_loader::Place::from(model);
+	let mut place=model.into_place();
 	place.run_scripts();
 
 	let map=place.to_snf(LoadFailureMode::DefaultToNone).map_err(ConvertError::RobloxLoad)?;

strafe-client/Cargo.toml

@@ -28,5 +28,5 @@ strafesnet_rbx_loader = { path = "../lib/rbx_loader", registry = "strafesnet", o
 strafesnet_session = { path = "../engine/session", registry = "strafesnet" }
 strafesnet_settings = { path = "../engine/settings", registry = "strafesnet" }
 strafesnet_snf = { path = "../lib/snf", registry = "strafesnet", optional = true }
-wgpu = "25.0.0"
+wgpu = "24.0.0"
 winit = "0.30.7"

strafe-client/src/compat_worker.rs

@@ -2,12 +2,14 @@ pub type QNWorker<'a,Task>=CompatNWorker<'a,Task>;
 pub type INWorker<'a,Task>=CompatNWorker<'a,Task>;
 
 pub struct CompatNWorker<'a,Task>{
+	data:std::marker::PhantomData<Task>,
 	f:Box<dyn FnMut(Task)+Send+'a>,
 }
 
 impl<'a,Task> CompatNWorker<'a,Task>{
 	pub fn new(f:impl FnMut(Task)+Send+'a)->CompatNWorker<'a,Task>{
 		Self{
+			data:std::marker::PhantomData,
 			f:Box::new(f),
 		}
 	}

strafe-client/src/file.rs

@@ -97,7 +97,7 @@ pub fn load<P:AsRef<std::path::Path>>(path:P)->Result<LoadFormat,LoadError>{
 		ReadFormat::SNFM(map)=>Ok(LoadFormat::Map(map)),
 		#[cfg(feature="roblox")]
 		ReadFormat::Roblox(model)=>{
-			let mut place=strafesnet_rbx_loader::Place::from(model);
+			let mut place=model.into_place();
 			place.run_scripts();
 			Ok(LoadFormat::Map(
 				place.to_snf(LoadFailureMode::DefaultToNone).map_err(LoadError::LoadRoblox)?

strafe-client/src/setup.rs

@@ -117,6 +117,7 @@ impl<'a> SetupContextPartial3<'a>{
 		// Make sure we use the texture resolution limits from the adapter, so we can support images the size of the surface.
 		let needed_limits=strafesnet_graphics::graphics::required_limits().using_resolution(self.adapter.limits());
 
+		let trace_dir=std::env::var("WGPU_TRACE");
 		let (device, queue)=pollster::block_on(self.adapter
 			.request_device(
 				&wgpu::DeviceDescriptor {
@@ -124,8 +125,8 @@ impl<'a> SetupContextPartial3<'a>{
 					required_features: (optional_features & self.adapter.features()) | required_features,
 					required_limits: needed_limits,
 					memory_hints:wgpu::MemoryHints::Performance,
-					trace: wgpu::Trace::Off,
 				},
+				trace_dir.ok().as_ref().map(std::path::Path::new),
 			))
 			.expect("Unable to find a suitable GPU adapter!");
 

tools/dev

@@ -1 +0,0 @@
-RUST_BACKTRACE=1 mangohud ../target/debug/strafe-client "$@"