data thing

Cargo.lock

@@ -1955,9 +1955,9 @@ dependencies = [
 
 [[package]]
 name = "rbx_mesh"
-version = "0.1.2"
+version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "864ead0e98afce28c960f653d6203483834890d07f87b60e2f01415530a2fe9d"
+checksum = "1205fdae1f9a8bfd5d8fbe6036066673d530ee392f7840d6f8a24e763559c7fd"
 dependencies = [
  "binrw",
  "lazy-regex",

engine/physics/src/model.rs

@@ -1005,9 +1005,3 @@ fn test_is_empty_volume(){
 	assert!(!is_empty_volume([vec3::X.fix_3(),vec3::Y.fix_3(),vec3::Z.fix_3()].to_vec()));
 	assert!(is_empty_volume([vec3::X.fix_3(),vec3::Y.fix_3(),vec3::Z.fix_3(),vec3::NEG_X.fix_3()].to_vec()));
 }
-
-#[test]
-fn build_me_a_cube(){
-	let mesh=PhysicsMesh::unit_cube();
-	//println!("mesh={:?}",mesh);
-}

engine/physics/src/physics.rs

@@ -229,12 +229,6 @@ impl PhysicsModels{
 				.map(|model|&model.transform),
 		}
 	}
-	fn contact_model(&self,model_id:ContactModelId)->&ContactModel{
-		&self.contact_models[&model_id]
-	}
-	fn intersect_model(&self,model_id:IntersectModelId)->&IntersectModel{
-		&self.intersect_models[&model_id]
-	}
 	fn contact_attr(&self,model_id:ContactModelId)->&gameplay_attributes::ContactAttributes{
 		&self.contact_attributes[&self.contact_models[&model_id].attr_id]
 	}
@@ -269,7 +263,7 @@ impl PhysicsCamera{
 		);
 		self.clamped_mouse_pos=unclamped_mouse_pos;
 	}
-	pub fn simulate_move_angles(&self,mouse_delta:glam::IVec2)->glam::Vec2 {
+	pub fn simulate_move_angles(&self,mouse_delta:glam::IVec2)->glam::Vec2{
 		let a=-self.sensitivity.mul_int((self.clamped_mouse_pos+mouse_delta).as_i64vec2());
 		let ax=Angle32::wrap_from_i64(a.x);
 		let ay=Angle32::clamp_from_i64(a.y)
@@ -1873,7 +1867,6 @@ fn atomic_input_instruction(state:&mut PhysicsState,data:&PhysicsData,ins:TimedI
 
 #[cfg(test)]
 mod test{
-	use crate::body::VirtualBody;
 	use strafesnet_common::integer::{vec3::{self,int as int3},mat3};
 	use super::*;
 	fn test_collision_axis_aligned(relative_body:Body,expected_collision_time:Option<Time>){

lib/bsp_loader/src/bsp.rs

@@ -240,7 +240,7 @@ impl PartialMap2{
 		.enumerate().map(|(new_texture_id,(old_texture_id,texture))|{
 			(texture,(old_texture_id,model::TextureId::new(new_texture_id as u32)))
 		}).unzip();
-		let render_configs=render_configs.into_iter().map(|(render_config_id,mut render_config)|{
+		let render_configs=render_configs.into_iter().map(|(_render_config_id,mut render_config)|{
 			//this may generate duplicate no-texture render configs but idc
 			render_config.texture=render_config.texture.and_then(|texture_id|
 				texture_id_map.get(&texture_id).copied()

lib/common/src/timer.rs

@@ -23,7 +23,7 @@ impl PauseState for Unpaused{
 }
 
 #[derive(Clone,Copy,Hash,Eq,PartialEq,PartialOrd,Debug)]
-enum Inner{}
+pub enum Inner{}
 type InnerTime=Time<Inner>;
 
 #[derive(Clone,Copy,Debug)]

lib/common/src/updatable.rs

@@ -1,3 +1,5 @@
+// This whole thing should be a drive macro
+
 pub trait Updatable<Updater>{
 	fn update(&mut self,update:Updater);
 }
@@ -53,4 +55,3 @@ impl Updatable<OuterUpdate> for Outer{
 		}
 	}
 }
-//*/

lib/deferred_loader/Cargo.toml

@@ -12,8 +12,8 @@ authors = ["Rhys Lloyd <krakow20@gmail.com>"]
 [features]
 default = ["legacy"]
 legacy = ["dep:url","dep:vbsp"]
-#roblox = ["dep:lazy-regex"]
-#source = ["dep:vbsp"]
+roblox = []
+source = ["dep:vbsp"]
 
 [dependencies]
 strafesnet_common = { path = "../common", registry = "strafesnet" }

lib/fixed_wide/src/tests.rs

@@ -57,7 +57,7 @@ fn from_f32(){
 	assert_eq!(b,Ok(a));
 	//I32F32::MIN hits a special case since it's not representable as a positive signed integer
 	//TODO: don't return an overflow because this is technically possible
-	let a=I32F32::MIN;
+	let _a=I32F32::MIN;
 	let b:Result<I32F32,_>=Into::<f32>::into(I32F32::MIN).try_into();
 	assert_eq!(b,Err(crate::fixed::FixedFromFloatError::Overflow));
 	//16 is within the 24 bits of float precision

lib/rbx_loader/Cargo.toml

@@ -15,7 +15,7 @@ glam = "0.29.0"
 lazy-regex = "3.1.0"
 rbx_binary = { version = "0.7.4", registry = "strafesnet" }
 rbx_dom_weak = { version = "2.7.0", registry = "strafesnet" }
-rbx_mesh = "0.1.2"
+rbx_mesh = "0.2.0"
 rbx_reflection_database = { version = "0.2.10", registry = "strafesnet" }
 rbx_xml = { version = "0.13.3", registry = "strafesnet" }
 roblox_emulator = { path = "../roblox_emulator", registry = "strafesnet" }

lib/rbx_loader/src/directories.rs

@@ -0,0 +1,6 @@
+// TODO: make a directories structure like strafe client
+struct Directories{
+	textures:PathBuf,
+	meshes:PathBuf,
+	unions:PathBuf,
+}

lib/rbx_loader/src/lib.rs

@@ -3,6 +3,7 @@ use rbx_dom_weak::WeakDom;
 
 mod rbx;
 mod mesh;
+mod union;
 mod primitives;
 
 pub mod data{
@@ -42,7 +43,7 @@ pub struct Place{
 	services:roblox_emulator::context::Services,
 }
 impl Place{
-	fn new(dom:WeakDom)->Option<Self>{
+	pub fn new(dom:WeakDom)->Option<Self>{
 		let context=roblox_emulator::context::Context::from_ref(&dom);
 		Some(Self{
 			services:context.find_services()?,

lib/rbx_loader/src/loader.rs

@@ -0,0 +1,4 @@
+// TODO: move code from deferred_loader to here
+// use generics to specify a hashable type for the acquire_X function signature
+// use impls/traits instead of passing around functions
+// part of the goob remains in deferred loader, the common bits between both

lib/rbx_loader/src/mesh.rs

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

lib/rbx_loader/src/primitives.rs

@@ -1,4 +1,4 @@
-use strafesnet_common::model::{Color4,TextureCoordinate,Mesh,IndexedGraphicsGroup,IndexedPhysicsGroup,IndexedVertex,PolygonGroupId,PolygonGroup,PolygonList,IndexedVertexList,PositionId,TextureCoordinateId,NormalId,ColorId,VertexId,RenderConfigId};
+use strafesnet_common::model::{Color4,TextureCoordinate,Mesh,IndexedGraphicsGroup,IndexedPhysicsGroup,IndexedVertex,PolygonGroupId,PolygonGroup,PolygonList,PositionId,TextureCoordinateId,NormalId,ColorId,VertexId,RenderConfigId};
 use strafesnet_common::integer::{vec3,Planar64Vec3};
 
 #[derive(Debug)]
@@ -126,9 +126,6 @@ const CORNERWEDGE_DEFAULT_NORMALS:[Planar64Vec3;5]=[
 	vec3::int( 0,-1, 0),//CornerWedge::Bottom
 	vec3::int( 0, 0,-1),//CornerWedge::Front
 ];
-pub fn unit_sphere(render:RenderConfigId)->Mesh{
-	unit_cube(render)
-}
 #[derive(Default)]
 pub struct CubeFaceDescription([Option<FaceDescription>;6]);
 impl CubeFaceDescription{
@@ -149,10 +146,6 @@ pub fn unit_cube(render:RenderConfigId)->Mesh{
 	t.insert(CubeFace::Front,FaceDescription::new_with_render_id(render));
 	generate_partial_unit_cube(t)
 }
-pub fn unit_cylinder(render:RenderConfigId)->Mesh{
-	//lmao
-	unit_cube(render)
-}
 #[derive(Default)]
 pub struct WedgeFaceDescription([Option<FaceDescription>;5]);
 impl WedgeFaceDescription{
@@ -163,15 +156,15 @@ impl WedgeFaceDescription{
 		self.0.into_iter().enumerate().filter_map(|v|v.1.map(|u|(v.0,u)))
 	}
 }
-pub fn unit_wedge(render:RenderConfigId)->Mesh{
-	let mut t=WedgeFaceDescription::default();
-	t.insert(WedgeFace::Right,FaceDescription::new_with_render_id(render));
-	t.insert(WedgeFace::TopFront,FaceDescription::new_with_render_id(render));
-	t.insert(WedgeFace::Back,FaceDescription::new_with_render_id(render));
-	t.insert(WedgeFace::Left,FaceDescription::new_with_render_id(render));
-	t.insert(WedgeFace::Bottom,FaceDescription::new_with_render_id(render));
-	generate_partial_unit_wedge(t)
-}
+// pub fn unit_wedge(render:RenderConfigId)->Mesh{
+// 	let mut t=WedgeFaceDescription::default();
+// 	t.insert(WedgeFace::Right,FaceDescription::new_with_render_id(render));
+// 	t.insert(WedgeFace::TopFront,FaceDescription::new_with_render_id(render));
+// 	t.insert(WedgeFace::Back,FaceDescription::new_with_render_id(render));
+// 	t.insert(WedgeFace::Left,FaceDescription::new_with_render_id(render));
+// 	t.insert(WedgeFace::Bottom,FaceDescription::new_with_render_id(render));
+// 	generate_partial_unit_wedge(t)
+// }
 #[derive(Default)]
 pub struct CornerWedgeFaceDescription([Option<FaceDescription>;5]);
 impl CornerWedgeFaceDescription{
@@ -182,15 +175,15 @@ impl CornerWedgeFaceDescription{
 		self.0.into_iter().enumerate().filter_map(|v|v.1.map(|u|(v.0,u)))
 	}
 }
-pub fn unit_cornerwedge(render:RenderConfigId)->Mesh{
-	let mut t=CornerWedgeFaceDescription::default();
-	t.insert(CornerWedgeFace::Right,FaceDescription::new_with_render_id(render));
-	t.insert(CornerWedgeFace::TopBack,FaceDescription::new_with_render_id(render));
-	t.insert(CornerWedgeFace::TopLeft,FaceDescription::new_with_render_id(render));
-	t.insert(CornerWedgeFace::Bottom,FaceDescription::new_with_render_id(render));
-	t.insert(CornerWedgeFace::Front,FaceDescription::new_with_render_id(render));
-	generate_partial_unit_cornerwedge(t)
-}
+// pub fn unit_cornerwedge(render:RenderConfigId)->Mesh{
+// 	let mut t=CornerWedgeFaceDescription::default();
+// 	t.insert(CornerWedgeFace::Right,FaceDescription::new_with_render_id(render));
+// 	t.insert(CornerWedgeFace::TopBack,FaceDescription::new_with_render_id(render));
+// 	t.insert(CornerWedgeFace::TopLeft,FaceDescription::new_with_render_id(render));
+// 	t.insert(CornerWedgeFace::Bottom,FaceDescription::new_with_render_id(render));
+// 	t.insert(CornerWedgeFace::Front,FaceDescription::new_with_render_id(render));
+// 	generate_partial_unit_cornerwedge(t)
+// }
 
 #[derive(Clone)]
 pub struct FaceDescription{

lib/rbx_loader/src/rbx.rs

@@ -130,9 +130,9 @@ impl ModesBuilder{
 	fn push_mode_update(&mut self,mode_id:gameplay_modes::ModeId,mode_update:gameplay_modes::ModeUpdate){
 		self.mode_updates.push((mode_id,mode_update));
 	}
-	fn push_stage_update(&mut self,mode_id:gameplay_modes::ModeId,stage_id:gameplay_modes::StageId,stage_update:gameplay_modes::StageUpdate){
-		self.stage_updates.push((mode_id,stage_id,stage_update));
-	}
+	// fn push_stage_update(&mut self,mode_id:gameplay_modes::ModeId,stage_id:gameplay_modes::StageId,stage_update:gameplay_modes::StageUpdate){
+	// 	self.stage_updates.push((mode_id,stage_id,stage_update));
+	// }
 }
 fn get_attributes(name:&str,can_collide:bool,velocity:Planar64Vec3,model_id:model::ModelId,modes_builder:&mut ModesBuilder,wormhole_in_model_to_id:&mut HashMap<model::ModelId,u32>,wormhole_id_to_out_model:&mut HashMap<u32,model::ModelId>)->attr::CollisionAttributes{
 	let mut general=attr::GeneralAttributes::default();
@@ -403,13 +403,94 @@ enum RobloxBasePartDescription{
 	Wedge(RobloxWedgeDescription),
 	CornerWedge(RobloxCornerWedgeDescription),
 }
+fn get_texture_description<AcquireRenderConfigId>(
+	temp_objects:&mut Vec<rbx_dom_weak::types::Ref>,
+	acquire_render_config_id:&mut AcquireRenderConfigId,
+	dom:&rbx_dom_weak::WeakDom,
+	object:&rbx_dom_weak::Instance,
+	size:&rbx_dom_weak::types::Vector3,
+)->RobloxPartDescription
+	where
+		AcquireRenderConfigId:FnMut(Option<&str>)->model::RenderConfigId,
+{
+	//use the biggest one and cut it down later...
+	let mut part_texture_description:RobloxPartDescription=[None,None,None,None,None,None];
+	temp_objects.clear();
+	recursive_collect_superclass(temp_objects,&dom,object,"Decal");
+	for &mut decal_ref in temp_objects{
+	if let Some(decal)=dom.get_by_ref(decal_ref){
+		if let (
+			Some(rbx_dom_weak::types::Variant::Content(content)),
+			Some(rbx_dom_weak::types::Variant::Enum(normalid)),
+			Some(rbx_dom_weak::types::Variant::Color3(decal_color3)),
+			Some(rbx_dom_weak::types::Variant::Float32(decal_transparency)),
+		) = (
+			decal.properties.get("Texture"),
+			decal.properties.get("Face"),
+			decal.properties.get("Color3"),
+			decal.properties.get("Transparency"),
+		) {
+			let render_id=acquire_render_config_id(Some(content.as_ref()));
+				let normal_id=normalid.to_u32();
+				if normal_id<6{
+					let (roblox_texture_color,roblox_texture_transform)=if decal.class=="Texture"{
+						//generate tranform
+						if let (
+								Some(rbx_dom_weak::types::Variant::Float32(ox)),
+								Some(rbx_dom_weak::types::Variant::Float32(oy)),
+								Some(rbx_dom_weak::types::Variant::Float32(sx)),
+								Some(rbx_dom_weak::types::Variant::Float32(sy)),
+							) = (
+								decal.properties.get("OffsetStudsU"),
+								decal.properties.get("OffsetStudsV"),
+								decal.properties.get("StudsPerTileU"),
+								decal.properties.get("StudsPerTileV"),
+							)
+						{
+							let (size_u,size_v)=match normal_id{
+								0=>(size.z,size.y),//right
+								1=>(size.x,size.z),//top
+								2=>(size.x,size.y),//back
+								3=>(size.z,size.y),//left
+								4=>(size.x,size.z),//bottom
+								5=>(size.x,size.y),//front
+								_=>unreachable!(),
+							};
+							(
+								glam::vec4(decal_color3.r,decal_color3.g,decal_color3.b,1.0-*decal_transparency),
+								RobloxTextureTransform{
+									offset_u:*ox/(*sx),offset_v:*oy/(*sy),
+									scale_u:size_u/(*sx),scale_v:size_v/(*sy),
+								}
+							)
+						}else{
+							(glam::Vec4::ONE,RobloxTextureTransform::default())
+						}
+					}else{
+						(glam::Vec4::ONE,RobloxTextureTransform::default())
+					};
+					part_texture_description[normal_id as usize]=Some(RobloxFaceTextureDescription{
+						render:render_id,
+						color:roblox_texture_color,
+						transform:roblox_texture_transform,
+					});
+				}else{
+					println!("NormalId={} is invalid",normal_id);
+				}
+			}
+		}
+	}
+	part_texture_description
+}
 enum Shape{
 	Primitive(primitives::Primitives),
 	MeshPart,
+	PhysicsData,
 }
-enum MeshAvailability{
+enum MeshAvailability<'a>{
 	Immediate,
-	Deferred(RenderConfigId),
+	DeferredMesh(RenderConfigId),
+	DeferredUnion(RobloxPartDescription,UnionDeferredAttributes<'a>),
 }
 struct DeferredModelDeferredAttributes{
 	render:RenderConfigId,
@@ -421,6 +502,17 @@ struct ModelDeferredAttributes{
 	color:model::Color4,//transparency is in here
 	transform:Planar64Affine3,
 }
+struct DeferredUnionDeferredAttributes<'a>{
+	render:RobloxPartDescription,
+	model:ModelDeferredAttributes,
+	union:UnionDeferredAttributes<'a>,
+}
+#[derive(Hash)]
+struct UnionDeferredAttributes<'a>{
+	asset_id:Option<&'a str>,
+	mesh_data:Option<&'a [u8]>,
+	physics_data:Option<&'a [u8]>,
+}
 struct ModelOwnedAttributes{
 	mesh:model::MeshId,
 	attributes:attr::CollisionAttributes,
@@ -432,16 +524,17 @@ struct GetAttributesArgs{
 	can_collide:bool,
 	velocity:Planar64Vec3,
 }
-pub fn convert<AcquireRenderConfigId,AcquireMeshId>(
-	dom:&rbx_dom_weak::WeakDom,
+pub fn convert<'a,AcquireRenderConfigId,AcquireMeshId>(
+	dom:&'a rbx_dom_weak::WeakDom,
 	mut acquire_render_config_id:AcquireRenderConfigId,
 	mut acquire_mesh_id:AcquireMeshId,
-)->PartialMap1
+)->PartialMap1<'a>
 where
 	AcquireRenderConfigId:FnMut(Option<&str>)->model::RenderConfigId,
 	AcquireMeshId:FnMut(&str)->model::MeshId,
 {
 
+	let mut deferred_unions_deferred_attributes=Vec::new();
 	let mut deferred_models_deferred_attributes=Vec::new();
 	let mut primitive_models_deferred_attributes=Vec::new();
 	let mut primitive_meshes=Vec::new();
@@ -471,7 +564,7 @@ where
 					object.properties.get("CanCollide"),
 				)
 			{
-				let model_transform=planar64_affine3_from_roblox(cf,size);
+				let mut model_transform=planar64_affine3_from_roblox(cf,size);
 
 				if model_transform.matrix3.det().is_zero(){
 					let mut parent_ref=object.parent();
@@ -485,9 +578,6 @@ where
 					continue;
 				}
 
-				//at this point a new model is going to be generated for sure.
-				let model_id=model::ModelId::new(primitive_models_deferred_attributes.len() as u32);
-
 				//TODO: also detect "CylinderMesh" etc here
 				let shape=match object.class.as_str(){
 					"Part"=>if let Some(rbx_dom_weak::types::Variant::Enum(shape))=object.properties.get("Shape"){
@@ -506,6 +596,7 @@ where
 					"WedgePart"=>Shape::Primitive(primitives::Primitives::Wedge),
 					"CornerWedgePart"=>Shape::Primitive(primitives::Primitives::CornerWedge),
 					"MeshPart"=>Shape::MeshPart,
+					"UnionOperation"=>Shape::PhysicsData,
 					_=>{
 						println!("Unsupported BasePart ClassName={}; defaulting to cube",object.class);
 						Shape::Primitive(primitives::Primitives::Cube)
@@ -514,74 +605,8 @@ where
 
 				let (availability,mesh_id)=match shape{
 					Shape::Primitive(primitive_shape)=>{
-						//TODO: TAB TAB
-				//use the biggest one and cut it down later...
-				let mut part_texture_description:RobloxPartDescription=[None,None,None,None,None,None];
-				temp_objects.clear();
-				recursive_collect_superclass(&mut temp_objects, &dom, object,"Decal");
-				for &decal_ref in &temp_objects{
-					if let Some(decal)=dom.get_by_ref(decal_ref){
-						if let (
-							Some(rbx_dom_weak::types::Variant::Content(content)),
-							Some(rbx_dom_weak::types::Variant::Enum(normalid)),
-							Some(rbx_dom_weak::types::Variant::Color3(decal_color3)),
-							Some(rbx_dom_weak::types::Variant::Float32(decal_transparency)),
-						) = (
-							decal.properties.get("Texture"),
-							decal.properties.get("Face"),
-							decal.properties.get("Color3"),
-							decal.properties.get("Transparency"),
-						) {
-							let render_id=acquire_render_config_id(Some(content.as_ref()));
-								let normal_id=normalid.to_u32();
-								if normal_id<6{
-									let (roblox_texture_color,roblox_texture_transform)=if decal.class=="Texture"{
-										//generate tranform
-										if let (
-												Some(rbx_dom_weak::types::Variant::Float32(ox)),
-												Some(rbx_dom_weak::types::Variant::Float32(oy)),
-												Some(rbx_dom_weak::types::Variant::Float32(sx)),
-												Some(rbx_dom_weak::types::Variant::Float32(sy)),
-											) = (
-												decal.properties.get("OffsetStudsU"),
-												decal.properties.get("OffsetStudsV"),
-												decal.properties.get("StudsPerTileU"),
-												decal.properties.get("StudsPerTileV"),
-											)
-										{
-											let (size_u,size_v)=match normal_id{
-												0=>(size.z,size.y),//right
-												1=>(size.x,size.z),//top
-												2=>(size.x,size.y),//back
-												3=>(size.z,size.y),//left
-												4=>(size.x,size.z),//bottom
-												5=>(size.x,size.y),//front
-												_=>unreachable!(),
-											};
-											(
-												glam::vec4(decal_color3.r,decal_color3.g,decal_color3.b,1.0-*decal_transparency),
-												RobloxTextureTransform{
-													offset_u:*ox/(*sx),offset_v:*oy/(*sy),
-													scale_u:size_u/(*sx),scale_v:size_v/(*sy),
-												}
-											)
-										}else{
-											(glam::Vec4::ONE,RobloxTextureTransform::default())
-										}
-									}else{
-										(glam::Vec4::ONE,RobloxTextureTransform::default())
-									};
-									part_texture_description[normal_id as usize]=Some(RobloxFaceTextureDescription{
-										render:render_id,
-										color:roblox_texture_color,
-										transform:roblox_texture_transform,
-									});
-								}else{
-									println!("NormalId={} unsupported for shape={:?}",normal_id,primitive_shape);
-								}
-						}
-					}
-				}
+				//TODO: TAB TAB
+				let part_texture_description=get_texture_description(&mut temp_objects,&mut acquire_render_config_id,dom,object,size);
 				//obscure rust syntax "slice pattern"
 				let [
 					f0,//Cube::Right
@@ -694,12 +719,45 @@ where
 						object.properties.get("TextureID"),
 					){
 						(
-							MeshAvailability::Deferred(acquire_render_config_id(Some(texture_asset_id.as_ref()))),
+							MeshAvailability::DeferredMesh(acquire_render_config_id(Some(texture_asset_id.as_ref()))),
 							acquire_mesh_id(mesh_asset_id.as_ref()),
 						)
 					}else{
 						panic!("Mesh has no Mesh or Texture");
 					},
+					Shape::PhysicsData=>{
+						//The union mesh is sized already
+						model_transform=planar64_affine3_from_roblox(cf,&rbx_dom_weak::types::Vector3{x:2.0,y:2.0,z:2.0});
+
+						let mut asset_id=None;
+						let mut mesh_data=None;
+						let mut physics_data=None;
+						if let Some(rbx_dom_weak::types::Variant::Content(content))=object.properties.get("AssetId"){
+							let value:&str=content.as_ref();
+							if !value.is_empty(){
+								asset_id=Some(value);
+							}
+						}
+						if let Some(rbx_dom_weak::types::Variant::BinaryString(data))=object.properties.get("MeshData"){
+							let value:&[u8]=data.as_ref();
+							if !value.is_empty(){
+								mesh_data=Some(value);
+							}
+						}
+						if let Some(rbx_dom_weak::types::Variant::BinaryString(data))=object.properties.get("PhysicsData"){
+							let value:&[u8]=data.as_ref();
+							if !value.is_empty(){
+								physics_data=Some(value);
+							}
+						}
+						let part_texture_description=get_texture_description(&mut temp_objects,&mut acquire_render_config_id,dom,object,size);
+						let union_deferred_attributes=UnionDeferredAttributes{
+							asset_id,
+							mesh_data,
+							physics_data,
+						};
+						(MeshAvailability::DeferredUnion(part_texture_description,union_deferred_attributes),mesh_id)
+					},
 				};
 				let model_deferred_attributes=ModelDeferredAttributes{
 					mesh:mesh_id,
@@ -713,10 +771,15 @@ where
 				};
 				match availability{
 					MeshAvailability::Immediate=>primitive_models_deferred_attributes.push(model_deferred_attributes),
-					MeshAvailability::Deferred(render)=>deferred_models_deferred_attributes.push(DeferredModelDeferredAttributes{
+					MeshAvailability::DeferredMesh(render)=>deferred_models_deferred_attributes.push(DeferredModelDeferredAttributes{
 						render,
 						model:model_deferred_attributes
 					}),
+					MeshAvailability::DeferredUnion(part_texture_description,union_deferred_attributes)=>deferred_unions_deferred_attributes.push(DeferredUnionDeferredAttributes{
+						render:part_texture_description,
+						model:model_deferred_attributes,
+						union:union_deferred_attributes,
+					}),
 				}
 			}
 		}
@@ -731,10 +794,11 @@ struct MeshWithAabb{
 	mesh:model::Mesh,
 	aabb:strafesnet_common::aabb::Aabb,
 }
-pub struct PartialMap1{
+pub struct PartialMap1<'a>{
 	primitive_meshes:Vec<model::Mesh>,
 	primitive_models_deferred_attributes:Vec<ModelDeferredAttributes>,
 	deferred_models_deferred_attributes:Vec<DeferredModelDeferredAttributes>,
+	deferred_union_deferred_attributes:Vec<DeferredModelDeferredAttributes>,
 }
 impl PartialMap1{
 	pub fn add_meshpart_meshes_and_calculate_attributes(
@@ -779,12 +843,10 @@ impl PartialMap1{
 				.entry(render).or_insert_with(||{
 					let mesh_id=model::MeshId::new(self.primitive_meshes.len() as u32);
 					let mut mesh_clone=mesh_with_aabb.mesh.clone();
-					//add a render group lool
-					mesh_clone.graphics_groups.push(model::IndexedGraphicsGroup{
-						render,
-						//the lowest lod is highest quality
-						groups:vec![model::PolygonGroupId::new(0)]
-					});
+					//set the render group lool
+					if let Some(graphics_group)=mesh_clone.graphics_groups.first_mut(){
+						graphics_group.render=render;
+					}
 					self.primitive_meshes.push(mesh_clone);
 					mesh_id
 				}),
@@ -889,8 +951,14 @@ impl PartialMap2{
 		=textures.into_iter().enumerate().map(|(new_texture_id,(old_texture_id,texture))|{
 			(texture,(old_texture_id,model::TextureId::new(new_texture_id as u32)))
 		}).unzip();
-		let render_configs=render_configs.into_iter().map(|(render_config_id,mut render_config)|{
-			//this may generate duplicate no-texture render configs but idc
+		let render_configs=render_configs.into_iter().map(|(_render_config_id,mut render_config)|{
+			// This may generate duplicate no-texture render configs but idc
+			//
+			// This is because some textures may not exist, so the render config
+			// that it points to is unique but is texture.
+			//
+			// I don't think this needs to be fixed because missing textures
+			// should be a conversion error anyways.
 			render_config.texture=render_config.texture.and_then(|texture_id|
 				texture_id_map.get(&texture_id).copied()
 			);

lib/rbx_loader/src/union.rs

@@ -0,0 +1,144 @@
+use std::collections::HashMap;
+
+use strafesnet_common::model::{self, ColorId, IndexedVertex, NormalId, PolygonGroup, PolygonGroupId, PolygonList, PositionId, RenderConfigId, TextureCoordinateId, VertexId};
+use strafesnet_common::integer::vec3;
+
+#[allow(dead_code)]
+#[derive(Debug)]
+pub enum Error{
+	Block,
+	NotSupposedToHappen,
+	MissingVertexId(u32),
+	Planar64Vec3(strafesnet_common::integer::Planar64TryFromFloatError),
+	RobloxPhysicsData(rbx_mesh::physics_data::Error),
+	RobloxMeshData(rbx_mesh::mesh_data::Error),
+}
+impl std::fmt::Display for Error{
+	fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
+		write!(f,"{self:?}")
+	}
+}
+
+impl std::error::Error for Error{}
+pub fn convert(roblox_physics_data:&[u8],roblox_mesh_data:&[u8])->Result<model::Mesh,Error>{
+	match (roblox_physics_data,roblox_mesh_data){
+		(b"",b"")=>return Err(Error::Block),
+		(b"",_)
+		|(_,b"")=>return Err(Error::NotSupposedToHappen),
+		_=>(),
+	}
+
+	// graphical
+	let mesh_data=rbx_mesh::read_mesh_data_versioned(
+		std::io::Cursor::new(roblox_mesh_data)
+	).map_err(Error::RobloxMeshData)?;
+	let graphics_mesh=match mesh_data{
+		rbx_mesh::mesh_data::CSGPHS::CSGK(csgk)=>return Err(Error::NotSupposedToHappen),
+		rbx_mesh::mesh_data::CSGPHS::CSGPHS2(mesh_data2)=>mesh_data2.mesh,
+		rbx_mesh::mesh_data::CSGPHS::CSGPHS4(mesh_data4)=>mesh_data4.mesh,
+	};
+
+	// physical
+	let physics_data=rbx_mesh::read_physics_data(
+		std::io::Cursor::new(roblox_physics_data)
+	).map_err(Error::RobloxPhysicsData)?;
+	let physics_convex_meshes=match physics_data{
+		rbx_mesh::physics_data::PhysicsData::CSGK(_)
+		// have not seen this format in practice
+		|rbx_mesh::physics_data::PhysicsData::CSGPHS(rbx_mesh::physics_data::CSGPHS::Block)
+		=>return Err(Error::NotSupposedToHappen),
+		rbx_mesh::physics_data::PhysicsData::CSGPHS(rbx_mesh::physics_data::CSGPHS::Meshes3(meshes))
+		|rbx_mesh::physics_data::PhysicsData::CSGPHS(rbx_mesh::physics_data::CSGPHS::Meshes5(meshes))
+		=>meshes.meshes,
+		rbx_mesh::physics_data::PhysicsData::CSGPHS(rbx_mesh::physics_data::CSGPHS::PhysicsInfoMesh(pim))
+		=>vec![pim.mesh],
+	};
+	let mut unique_pos=Vec::new();
+	let mut pos_id_from=HashMap::new();
+	let mut unique_tex=Vec::new();
+	let mut tex_id_from=HashMap::new();
+	let mut unique_normal=Vec::new();
+	let mut normal_id_from=HashMap::new();
+	let mut unique_color=Vec::new();
+	let mut color_id_from=HashMap::new();
+	let mut unique_vertices=Vec::new();
+	let mut vertex_id_from=HashMap::new();
+	let mut acquire_pos_id=|pos|{
+		let p=vec3::try_from_f32_array(pos).map_err(Error::Planar64Vec3)?;
+		Ok(*pos_id_from.entry(p).or_insert_with(||{
+			let pos_id=PositionId::new(unique_pos.len() as u32);
+			unique_pos.push(p);
+			pos_id
+		}))
+	};
+	let mut acquire_tex_id=|tex|{
+		let h=bytemuck::cast::<[f32;2],[u32;2]>(tex);
+		*tex_id_from.entry(h).or_insert_with(||{
+			let tex_id=TextureCoordinateId::new(unique_tex.len() as u32);
+			unique_tex.push(glam::Vec2::from_array(tex));
+			tex_id
+		})
+	};
+	let mut acquire_normal_id=|normal|{
+		let n=vec3::try_from_f32_array(normal).map_err(Error::Planar64Vec3)?;
+		Ok(*normal_id_from.entry(n).or_insert_with(||{
+			let normal_id=NormalId::new(unique_normal.len() as u32);
+			unique_normal.push(n);
+			normal_id
+		}))
+	};
+	let mut acquire_color_id=|color|{
+		let h=bytemuck::cast::<[f32;4],[u32;4]>(color);
+		*color_id_from.entry(h).or_insert_with(||{
+			let color_id=ColorId::new(unique_color.len() as u32);
+			unique_color.push(glam::Vec4::from_array(color));
+			color_id
+		})
+	};
+	let mut acquire_vertex_id=|vertex:IndexedVertex|{
+		*vertex_id_from.entry(vertex.clone()).or_insert_with(||{
+			let vertex_id=VertexId::new(unique_vertices.len() as u32);
+			unique_vertices.push(vertex);
+			vertex_id
+		})
+	};
+	let color=acquire_color_id([1.0f32;4]);
+	let tex=acquire_tex_id([0.0f32;2]);
+	let polygon_groups:Vec<PolygonGroup>=physics_convex_meshes.into_iter().map(|mesh|{
+		Ok(PolygonGroup::PolygonList(PolygonList::new(mesh.faces.into_iter().map(|[vertex_id0,vertex_id1,vertex_id2]|{
+			let v0=mesh.vertices.get(vertex_id0.0 as usize).ok_or(Error::MissingVertexId(vertex_id0.0))?;
+			let v1=mesh.vertices.get(vertex_id1.0 as usize).ok_or(Error::MissingVertexId(vertex_id1.0))?;
+			let v2=mesh.vertices.get(vertex_id2.0 as usize).ok_or(Error::MissingVertexId(vertex_id2.0))?;
+			let vertex_norm=(glam::Vec3::from_slice(v1)-glam::Vec3::from_slice(v0))
+			          .cross(glam::Vec3::from_slice(v2)-glam::Vec3::from_slice(v0)).to_array();
+			let mut ingest_vertex_id=|&vertex_pos:&[f32;3]|Ok(acquire_vertex_id(IndexedVertex{
+				pos:acquire_pos_id(vertex_pos)?,
+				tex,
+				normal:acquire_normal_id(vertex_norm)?,
+				color,
+			}));
+			Ok(vec![
+				ingest_vertex_id(v0)?,
+				ingest_vertex_id(v1)?,
+				ingest_vertex_id(v2)?,
+			])
+		}).collect::<Result<_,_>>()?)))
+	}).collect::<Result<_,_>>()?;
+	let graphics_groups=vec![model::IndexedGraphicsGroup{
+		render:RenderConfigId::new(0),
+		groups:(0..polygon_groups.len()).map(|id|PolygonGroupId::new(id as u32)).collect()
+	}];
+	let physics_groups=(0..polygon_groups.len()).map(|id|model::IndexedPhysicsGroup{
+		groups:vec![PolygonGroupId::new(id as u32)]
+	}).collect();
+	Ok(model::Mesh{
+		unique_pos,
+		unique_normal,
+		unique_tex,
+		unique_color,
+		unique_vertices,
+		polygon_groups,
+		graphics_groups,
+		physics_groups,
+	})
+}

lib/snf/src/map.rs

@@ -95,21 +95,6 @@ enum ResourceType{
 	//Video,
 	//Animation,
 }
-const RESOURCE_TYPE_VARIANT_COUNT:u8=2;
-#[binrw]
-#[brw(little)]
-struct ResourceId(u128);
-impl ResourceId{
-	fn resource_type(&self)->Option<ResourceType>{
-		let discriminant=self.0 as u8;
-		//TODO: use this when it is stabilized https://github.com/rust-lang/rust/issues/73662
-		//if (discriminant as usize)<std::mem::variant_count::<ResourceType>(){
-		match discriminant<RESOURCE_TYPE_VARIANT_COUNT{
-			true=>Some(unsafe{std::mem::transmute::<u8,ResourceType>(discriminant)}),
-			false=>None,
-		}
-	}
-}
 
 struct ResourceMap<T>{
 	meshes:HashMap<strafesnet_common::model::MeshId,T>,
@@ -136,11 +121,6 @@ struct ResourceBlockHeader{
 	resource:ResourceType,
 	id:BlockId,
 }
-#[binrw]
-#[brw(little)]
-struct ResourceExternalHeader{
-	resource_uuid:ResourceId,
-}
 
 #[binrw]
 #[brw(little)]

strafe-client/src/file.rs

@@ -1,5 +1,6 @@
 use std::io::Read;
 
+#[allow(dead_code)]
 #[derive(Debug)]
 pub enum ReadError{
 	#[cfg(feature="roblox")]
@@ -59,6 +60,7 @@ pub fn read<R:Read+std::io::Seek>(input:R)->Result<ReadFormat,ReadError>{
 	}
 }
 
+#[allow(dead_code)]
 #[derive(Debug)]
 pub enum LoadError{
 	ReadError(ReadError),

strafe-client/src/setup.rs

@@ -20,11 +20,6 @@ struct SetupContextPartial1{
 fn create_window(title:&str,event_loop:&winit::event_loop::EventLoop<()>)->Result<winit::window::Window,winit::error::OsError>{
 	let mut attr=winit::window::WindowAttributes::default();
 	attr=attr.with_title(title);
-	#[cfg(windows_OFF)] // TODO
-	{
-		use winit::platform::windows::WindowBuilderExtWindows;
-		builder=builder.with_no_redirection_bitmap(true);
-	}
 	event_loop.create_window(attr)
 }
 fn create_instance()->SetupContextPartial1{
@@ -105,14 +100,12 @@ impl<'a> SetupContextPartial2<'a>{
 			required_downlevel_capabilities.flags - downlevel_capabilities.flags
 		);
 		SetupContextPartial3{
-			instance:self.instance,
 			surface:self.surface,
 			adapter,
 		}
 	}
 }
 struct SetupContextPartial3<'a>{
-	instance:wgpu::Instance,
 	surface:wgpu::Surface<'a>,
 	adapter:wgpu::Adapter,
 }
@@ -138,7 +131,6 @@ impl<'a> SetupContextPartial3<'a>{
 			.expect("Unable to find a suitable GPU adapter!");
 
 		SetupContextPartial4{
-			instance:self.instance,
 			surface:self.surface,
 			adapter:self.adapter,
 			device,
@@ -147,7 +139,6 @@ impl<'a> SetupContextPartial3<'a>{
 	}
 }
 struct SetupContextPartial4<'a>{
-	instance:wgpu::Instance,
 	surface:wgpu::Surface<'a>,
 	adapter:wgpu::Adapter,
 	device:wgpu::Device,
@@ -164,7 +155,6 @@ impl<'a> SetupContextPartial4<'a>{
 		self.surface.configure(&self.device, &config);
 
 		SetupContext{
-			instance:self.instance,
 			surface:self.surface,
 			device:self.device,
 			queue:self.queue,
@@ -173,7 +163,6 @@ impl<'a> SetupContextPartial4<'a>{
 	}
 }
 pub struct SetupContext<'a>{
-	pub instance:wgpu::Instance,
 	pub surface:wgpu::Surface<'a>,
 	pub device:wgpu::Device,
 	pub queue:wgpu::Queue,