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

@@ -2,6 +2,7 @@ use crate::model::{GigaTime,FEV,MeshQuery,DirectedEdge};
 use strafesnet_common::integer::{Fixed,Ratio,vec3::Vector3};
 use crate::physics::{Time,Body};
 
+#[derive(Debug)]
 enum Transition<M:MeshQuery>{
 	Miss,
 	Next(FEV<M>,GigaTime),
@@ -27,17 +28,18 @@ impl<M:MeshQuery> CrawlResult<M>{
 	}
 }
 
-impl<F:Copy,M:MeshQuery<Normal=Vector3<F>,Offset=Fixed<4,128>>> FEV<M>
+impl<F:Copy,M:MeshQuery<Normal=Vector3<F>,Offset=Fixed<4,128>>+std::fmt::Debug> FEV<M>
 	where
 		// This is hardcoded for MinkowskiMesh lol
 		M::Face:Copy,
 		M::Edge:Copy,
 		M::Vert:Copy,
-		F:core::ops::Mul<Fixed<1,32>,Output=Fixed<4,128>>,
+		F:core::ops::Mul<Fixed<1,32>,Output=Fixed<4,128>>+std::fmt::Debug+std::fmt::Display,
 		<F as core::ops::Mul<Fixed<1,32>>>::Output:core::iter::Sum,
 		<M as MeshQuery>::Offset:core::ops::Sub<<F as std::ops::Mul<Fixed<1,32>>>::Output>,
 {
 	fn next_transition(&self,body_time:GigaTime,mesh:&M,body:&Body,mut best_time:GigaTime)->Transition<M>{
+		println!("next_transition fev={self:?}");
 		//conflicting derivative means it crosses in the wrong direction.
 		//if the transition time is equal to an already tested transition, do not replace the current best.
 		let mut best_transition=Transition::Miss;
@@ -75,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);
@@ -84,6 +87,7 @@ 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);
+					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(n.dot(delta_pos).wrap_4(),n.dot(body.velocity).wrap_4()*2,n.dot(body.acceleration).wrap_4()){
@@ -138,7 +142,9 @@ impl<F:Copy,M:MeshQuery<Normal=Vector3<F>,Offset=Fixed<4,128>>> FEV<M>
 			Ratio::new(r.num.widen_4(),r.den.widen_4())
 		};
 		for _ in 0..20{
-			match self.next_transition(body_time,mesh,relative_body,time_limit){
+			let transition=self.next_transition(body_time,mesh,relative_body,time_limit);
+			println!("transition={transition:?}");
+			match transition{
 				Transition::Miss=>return CrawlResult::Miss(self),
 				Transition::Next(next_fev,next_time)=>(self,body_time)=(next_fev,next_time),
 				Transition::Hit(face,time)=>return CrawlResult::Hit(face,time),

engine/physics/src/model.rs

@@ -68,16 +68,17 @@ pub enum FEV<M:MeshQuery>{
 }
 
 //use Unit32 #[repr(C)] for map files
-#[derive(Clone,Hash,Eq,PartialEq)]
+#[derive(Clone,Debug,Hash,Eq,PartialEq)]
 struct Face{
 	normal:Planar64Vec3,
 	dot:Planar64,
 }
+#[derive(Debug)]
 struct Vert(Planar64Vec3);
 pub trait MeshQuery{
-	type Face:Copy;
-	type Edge:Copy+DirectedEdge;
-	type Vert:Copy;
+	type Face:Copy+std::fmt::Debug;
+	type Edge:Copy+DirectedEdge+std::fmt::Debug;
+	type Vert:Copy+std::fmt::Debug;
 	// Vertex must be Planar64Vec3 because it represents an actual position
 	type Normal;
 	type Offset;
@@ -97,18 +98,22 @@ pub trait MeshQuery{
 	fn vert_edges(&self,vert_id:Self::Vert)->impl AsRef<[Self::Edge]>;
 	fn vert_faces(&self,vert_id:Self::Vert)->impl AsRef<[Self::Face]>;
 }
+#[derive(Debug)]
 struct FaceRefs{
 	edges:Vec<SubmeshDirectedEdgeId>,
 	//verts:Vec<VertId>,
 }
+#[derive(Debug)]
 struct EdgeRefs{
 	faces:[SubmeshFaceId;2],//left, right
 	verts:[SubmeshVertId;2],//bottom, top
 }
+#[derive(Debug)]
 struct VertRefs{
 	faces:Vec<SubmeshFaceId>,
 	edges:Vec<SubmeshDirectedEdgeId>,
 }
+#[derive(Debug)]
 pub struct PhysicsMeshData{
 	//this contains all real and virtual faces used in both the complete mesh and convex submeshes
 	//faces are sorted such that all faces that belong to the complete mesh appear first, and then
@@ -118,6 +123,7 @@ pub struct PhysicsMeshData{
 	faces:Vec<Face>,//MeshFaceId indexes this list
 	verts:Vec<Vert>,//MeshVertId indexes this list
 }
+#[derive(Debug)]
 pub struct PhysicsMeshTopology{
 	//mapping of local ids to PhysicsMeshData ids
 	faces:Vec<MeshFaceId>,//SubmeshFaceId indexes this list
@@ -314,6 +320,9 @@ impl TryFrom<&model::Mesh> for PhysicsMesh{
 			return Err(PhysicsMeshError::ZeroVertices);
 		}
 		let verts=mesh.unique_pos.iter().copied().map(Vert).collect();
+		// TODO: do not hash faces to get face id
+		// meshes can have multiple identical nd representations while still being distinct faces,
+		// especially when the complete mesh is a non-convex mesh.
 		//TODO: fix submeshes
 		//flat map mesh.physics_groups[$1].groups.polys()[$2] as face_id
 		//lower face_id points to upper face_id
@@ -422,6 +431,7 @@ impl TryFrom<&model::Mesh> for PhysicsMesh{
 	}
 }
 
+#[derive(Debug)]
 pub struct PhysicsMeshView<'a>{
 	data:&'a PhysicsMeshData,
 	topology:&'a PhysicsMeshTopology,
@@ -458,6 +468,7 @@ impl MeshQuery for PhysicsMeshView<'_>{
 	}
 }
 
+#[derive(Debug)]
 pub struct PhysicsMeshTransform{
 	pub vertex:integer::Planar64Affine3,
 	pub normal:integer::mat3::Matrix3<Fixed<2,64>>,
@@ -473,6 +484,7 @@ impl PhysicsMeshTransform{
 	}
 }
 
+#[derive(Debug)]
 pub struct TransformedMesh<'a>{
 	view:PhysicsMeshView<'a>,
 	transform:&'a PhysicsMeshTransform,
@@ -598,6 +610,7 @@ pub enum MinkowskiFace{
 	//FaceFace
 }
 
+#[derive(Debug)]
 pub struct MinkowskiMesh<'a>{
 	mesh0:TransformedMesh<'a>,
 	mesh1:TransformedMesh<'a>,
@@ -742,7 +755,9 @@ impl MinkowskiMesh<'_>{
 		})
 	}
 	pub fn predict_collision_in(&self,relative_body:&Body,Range{start:start_time,end:time_limit}:Range<Time>)->Option<(MinkowskiFace,GigaTime)>{
+		println!("=== physics setup ===");
 		self.closest_fev_not_inside(relative_body.clone(),start_time).and_then(|fev|{
+			println!("=== physics crawl ===");
 			//continue forwards along the body parabola
 			fev.crawl(self,relative_body,start_time,time_limit).hit()
 		})
@@ -899,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();
@@ -906,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);
 							}

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,
 }
@@ -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();
 
@@ -1128,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);
@@ -1140,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());
@@ -1626,14 +1627,10 @@ 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),
 	}
 }
@@ -1675,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(

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/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/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/integer.rs

@@ -401,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!
@@ -562,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]);
@@ -656,7 +648,7 @@ pub mod mat3{
 	}
 }
 
-#[derive(Clone,Copy,Default,Hash,Eq,PartialEq)]
+#[derive(Clone,Copy,Debug,Default,Hash,Eq,PartialEq)]
 pub struct Planar64Affine3{
 	pub matrix3:Planar64Mat3,//includes scale above 1
 	pub translation:Planar64Vec3,

lib/deferred_loader/src/deferred_loader.rs

@@ -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,L:Loader<Resource=Mesh,Index<'a>=H>+'a>(self,loader:&mut L,failure_mode:LoadFailureMode)->Result<Meshes,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/rbx_loader/Cargo.toml

@@ -13,11 +13,11 @@ 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-sn2", 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.4.7", path = "../roblox_emulator", registry = "strafesnet" }
 strafesnet_common = { version = "0.6.0", path = "../common", registry = "strafesnet" }

lib/rbx_loader/src/loader.rs

@@ -1,11 +1,10 @@
 use std::io::Read;
-use rbx_dom_weak::ustr;
 use rbxassetid::{RobloxAssetId,RobloxAssetIdParseErr};
 use strafesnet_common::model::Mesh;
 use strafesnet_deferred_loader::{loader::Loader,texture::Texture};
 
 use crate::data::RobloxMeshBytes;
-use crate::rbx::RobloxPartDescription;
+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)?;
@@ -37,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)?;
@@ -105,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)]
@@ -125,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{
@@ -139,17 +138,17 @@ impl MeshIndex<'_>{
 	}
 }
 
-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 Index=MeshIndex<'a>;
 	type Resource=Mesh;
-	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 mesh=match index.mesh_type{
 			MeshType::FileMesh=>{
 				let RobloxAssetId(asset_id)=index.content.parse()?;
@@ -172,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(&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(&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/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,22 +18,6 @@ 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),
@@ -75,36 +43,103 @@ 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,49 +156,49 @@ impl FaceDescription{
 		}
 	}
 }
-pub fn unit_cube(CubeFaceDescription(face_descriptions):CubeFaceDescription)->Mesh{
-	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],
 		],
 	];
 	let mut generated_pos=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,7 +1,6 @@
 use std::collections::HashMap;
 use crate::loader::MeshIndex;
-use crate::primitives::{self,CubeFace,CubeFaceDescription,WedgeFaceDescription,CornerWedgeFaceDescription,FaceDescription,Primitives};
-use rbx_dom_weak::ustr;
+use crate::primitives;
 use strafesnet_common::aabb::Aabb;
 use strafesnet_common::map;
 use strafesnet_common::model;
@@ -348,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),
@@ -390,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>,
@@ -410,83 +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 (
-			Some(rbx_dom_weak::types::Variant::ContentId(content)),
+	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(&ustr("Texture")),
-			decal.properties.get(&ustr("Face")),
-			decal.properties.get(&ustr("Color3")),
-			decal.properties.get(&ustr("Transparency")),
-		)else{
-			println!("Decal is missing a required property");
-			continue;
-		};
-		let texture_id=Some(content.as_str());
-		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(&ustr("OffsetStudsU")),
-					decal.properties.get(&ustr("OffsetStudsV")),
-					decal.properties.get(&ustr("StudsPerTileU")),
-					decal.properties.get(&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,
 }
@@ -547,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(&ustr("CFrame")),
-					object.properties.get(&ustr("Size")),
-					object.properties.get(&ustr("Velocity")),
-					object.properties.get(&ustr("Transparency")),
-					object.properties.get(&ustr("Color")),
-					object.properties.get(&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);
@@ -571,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(&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)
 					}
 				};
 
@@ -592,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){
@@ -629,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
@@ -641,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(&ustr("MeshContent")),
-						// texture is allowed to be none
-						object.properties.get(&ustr("TextureContent")),
+						object.properties.get("MeshId"),
+						object.properties.get("TextureID"),
 					){
-						let mesh_asset_id=get_content_url(mesh_content).expect("MeshPart Mesh is not a Uri");
-						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");
@@ -662,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(&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(&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(&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);
@@ -749,7 +768,7 @@ fn acquire_union_id_from_render_config_id<'a>(
 			let union_id=model::MeshId::new(primitive_meshes.len() as u32);
 			let mut union_clone=union_with_aabb.mesh.clone();
 			//set the render groups
-			for (graphics_group,maybe_face_texture_description) in union_clone.graphics_groups.iter_mut().zip(part_texture_description.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;
 				}

lib/rbx_loader/src/union.rs

@@ -1,5 +1,4 @@
-use rbx_mesh::mesh_data::{NormalId2 as MeshDataNormalId2,VertexId as MeshDataVertexId};
-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;
 
@@ -57,7 +56,7 @@ pub fn convert(
 	roblox_physics_data:&[u8],
 	roblox_mesh_data:&[u8],
 	size:glam::Vec3,
-	crate::rbx::RobloxPartDescription(part_texture_description):crate::rbx::RobloxPartDescription,
+	part_texture_description:crate::rbx::RobloxPartDescription,
 )->Result<model::Mesh,Error>{
 	const NORMAL_FACES:usize=6;
 	let mut polygon_groups_normal_id=vec![Vec::new();NORMAL_FACES];
@@ -80,11 +79,11 @@ 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,
 		};
-		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|{
@@ -152,11 +151,11 @@ pub fn convert(
 		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)]|{
+		Ok(PolygonGroup::PolygonList(PolygonList::new(mesh.faces.into_iter().map(|[vertex_id0,vertex_id1,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))?,
+				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]);

lib/roblox_emulator/Cargo.toml

@@ -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-sn1", 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,4 +1,4 @@
-use rbx_dom_weak::{types::Ref,ustr,InstanceBuilder,WeakDom};
+use rbx_dom_weak::{types::Ref,InstanceBuilder,WeakDom};
 
 pub fn class_is_a(class:&str,superclass:&str)->bool{
 	class==superclass
@@ -70,8 +70,8 @@ impl Context{
 		{
 			//Lowercase and upper case workspace property!
 			let game=self.dom.root_mut();
-			game.properties.insert(ustr("workspace"),rbx_types::Variant::Ref(workspace));
-			game.properties.insert(ustr("Workspace"),rbx_types::Variant::Ref(workspace));
+			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"));
 

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

@@ -2,13 +2,14 @@ use std::collections::{hash_map::Entry,HashMap};
 
 use mlua::{FromLua,FromLuaMulti,IntoLua,IntoLuaMulti};
 use rbx_types::Ref;
-use rbx_dom_weak::{ustr,Ustr,InstanceBuilder,WeakDom};
+use rbx_dom_weak::{InstanceBuilder,WeakDom};
 
 use crate::runner::vector3::Vector3;
 
 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 instance_table=lua.create_table()?;
 
@@ -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(&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"))?,
 		};
@@ -96,6 +97,25 @@ 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){
 		fields.add_field_method_get("Parent",|lua,this|{
@@ -128,7 +148,7 @@ 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())
 			})
 		});
 	}
@@ -207,21 +227,26 @@ impl mlua::UserData for Instance{
 		});
 		methods.add_meta_function(mlua::MetaMethod::Index,|lua,(this,index):(Instance,mlua::String)|{
 			let index_str=&*index.to_str()?;
-			let index_ustr=ustr(index_str);
 			dom_mut(lua,|dom|{
 				let instance=this.get(dom)?;
 				//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
-				match instance.properties.get(&index_ustr)
+				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_ustr)
-					))
+					.or_else(||{
+						SuperClassIter{
+							database:db,
+							descriptor:Some(class),
+						}
+						.find_map(|class|
+							find_virtual_property(&instance.properties,class,index_str)
+						)
+					})
 				{
 					Some(rbx_types::Variant::Int32(val))=>return val.into_lua(lua),
 					Some(rbx_types::Variant::Int64(val))=>return val.into_lua(lua),
@@ -235,7 +260,11 @@ impl mlua::UserData for Instance{
 				}
 				//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()
@@ -245,13 +274,16 @@ 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_ustr)?{
+				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(instance.referent()))
 				.into_lua(lua)
@@ -262,22 +294,21 @@ impl mlua::UserData for Instance{
 				let instance=this.get_mut(dom)?;
 				//println!("__newindex t={} i={index:?} v={value:?}",instance.name);
 				let index_str=&*index.to_str()?;
-				let index_ustr=ustr(index_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 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_ustr,rbx_types::Variant::Vector3(typed_value.into()));
+						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:f32=coerce_float32(&value).ok_or_else(||mlua::Error::runtime("Expected f32"))?;
-						instance.properties.insert(index_ustr,rbx_types::Variant::Float32(typed_value));
+						instance.properties.insert(index_str.to_owned(),rbx_types::Variant::Float32(typed_value));
 					},
 					rbx_reflection::DataType::Enum(enum_name)=>{
 						let typed_value=match &value{
@@ -293,27 +324,27 @@ impl mlua::UserData for Instance{
 							},
 							_=>Err(mlua::Error::runtime("Expected Enum")),
 						}?;
-						instance.properties.insert(index_ustr,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()?;
-						instance.properties.insert(index_ustr,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"))?;
-						instance.properties.insert(index_ustr,rbx_types::Variant::Bool(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=value.as_str().ok_or_else(||mlua::Error::runtime("Expected boolean"))?;
-						instance.properties.insert(index_ustr,rbx_types::Variant::String(typed_value.to_owned()));
+						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()?;
-						instance.properties.insert(index_ustr,rbx_types::Variant::NumberSequence(typed_value.into()));
+						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()?;
-						instance.properties.insert(index_ustr,rbx_types::Variant::ColorSequence(typed_value.into()));
+						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:?}"))),
 				}
@@ -449,22 +480,24 @@ 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:&Ustr,
+	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(&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
@@ -473,19 +506,52 @@ type LUD=phf::Map<&'static str,// Class name
 >;
 static LAZY_USER_DATA:LUD=phf::phf_map!{
 	"RunService"=>phf::phf_map!{
-		"RenderStepped"=>|lua|lua.create_any_userdata(crate::runner::script_signal::ScriptSignal::new()),
+		"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:rbx_dom_weak::Ustr)->mlua::Result<Option<mlua::AnyUserData>>{
-	use std::collections::hash_map::Entry;
-	Ok(match LAZY_USER_DATA.get(instance.class.as_str()){
-		Some(userdata_map)=>match instance.userdata.entry(index){
-			Entry::Occupied(entry)=>Some(entry.get().clone()),
-			Entry::Vacant(entry)=>match userdata_map.get(index.as_str()){
-				Some(create_userdata)=>Some(entry.insert(create_userdata(lua)?).clone()),
-				None=>None,
-			},
-		},
-		None=>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/runner.rs

@@ -123,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(&rbx_dom_weak::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(())
 	}

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-sn2", 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" }

map-tool/src/roblox.rs

@@ -3,7 +3,7 @@ use std::io::{Cursor,Read,Seek};
 use std::collections::HashSet;
 use clap::{Args,Subcommand};
 use anyhow::Result as AResult;
-use rbx_dom_weak::{ustr,Instance};
+use rbx_dom_weak::Instance;
 use strafesnet_deferred_loader::deferred_loader::LoadFailureMode;
 use rbxassetid::RobloxAssetId;
 use tokio::io::AsyncReadExt;
@@ -88,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:&str){
-	let Some(rbx_dom_weak::types::Variant::Content(content))=object.properties.get(&ustr(property))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:&str){
-	let Some(rbx_dom_weak::types::Variant::ContentId(content))=object.properties.get(&ustr(property))else{
+	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 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?;
@@ -148,8 +120,8 @@ impl UniqueAssets{
 			"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"),
@@ -193,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,
 		}
 	}
 }
@@ -219,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?{
@@ -240,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}");
@@ -280,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,
@@ -305,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(())
@@ -343,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:

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/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 "$@"