fix comment

Cargo.lock

@@ -1726,6 +1726,15 @@ dependencies = [
  "either",
 ]
 
+[[package]]
+name = "itertools"
+version = "0.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2b192c782037fadd9cfa75548310488aabdbf3d2da73885b31bd0abd03351285"
+dependencies = [
+ "either",
+]
+
 [[package]]
 name = "itoa"
 version = "1.0.14"
@@ -1854,7 +1863,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fc2f4eb4bc735547cfed7c0a4922cbd04a4655978c09b54f1f7b228750664c34"
 dependencies = [
  "cfg-if",
- "windows-targets 0.52.6",
+ "windows-targets 0.48.5",
 ]
 
 [[package]]
@@ -2039,6 +2048,7 @@ dependencies = [
  "thiserror 2.0.11",
  "tokio",
  "vbsp",
+ "vbsp-entities",
  "vmdl",
  "vmt-parser",
  "vpk",
@@ -2991,7 +3001,7 @@ checksum = "c3d6831663a5098ea164f89cff59c6284e95f4e3c76ce9848d4529f5ccca9bde"
 
 [[package]]
 name = "ratio_ops"
-version = "0.1.0"
+version = "0.1.1"
 
 [[package]]
 name = "rav1e"
@@ -3712,6 +3722,7 @@ dependencies = [
  "strafesnet_common",
  "strafesnet_deferred_loader",
  "vbsp",
+ "vbsp-entities",
  "vmdl",
  "vpk",
 ]
@@ -4314,9 +4325,9 @@ dependencies = [
 
 [[package]]
 name = "vbsp"
-version = "0.6.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f14a5685e0bb386aac9b9c6046a05152a46a0bc58d53afb3fbe577f1a1c2bb05"
+version = "0.7.0-codegen5"
+source = "sparse+https://git.itzana.me/api/packages/strafesnet/cargo/"
+checksum = "48f8eea87da5b3597470871ebd3ad6e566263b0dc71e17f3b6693e7955853997"
 dependencies = [
  "ahash",
  "arrayvec",
@@ -4324,16 +4335,26 @@ dependencies = [
  "bitflags 2.8.0",
  "bv",
  "cgmath",
- "itertools 0.13.0",
+ "itertools 0.14.0",
  "lzma-rs",
  "num_enum",
  "serde",
  "static_assertions",
- "thiserror 1.0.69",
+ "thiserror 2.0.11",
  "vdf-reader",
  "zip-lzma",
 ]
 
+[[package]]
+name = "vbsp-entities"
+version = "0.1.0"
+source = "sparse+https://git.itzana.me/api/packages/strafesnet/cargo/"
+checksum = "7e2dac7bd8d1d809f2092e0978a32bcefe546fea945841eeff45ce462c1b6886"
+dependencies = [
+ "serde",
+ "vbsp",
+]
+
 [[package]]
 name = "vcpkg"
 version = "0.2.15"

engine/physics/src/model.rs

@@ -484,6 +484,9 @@ impl TransformedMesh<'_>{
 	pub fn verts<'a>(&'a self)->impl Iterator<Item=vec3::Vector3<Fixed<2,64>>>+'a{
 		self.view.data.verts.iter().map(|&Vert(pos)|self.transform.vertex.transform_point3(pos))
 	}
+	pub fn faces(&self)->impl Iterator<Item=SubmeshFaceId>{
+		(0..self.view.topology.faces.len() as u32).map(SubmeshFaceId::new)
+	}
 	fn farthest_vert(&self,dir:Planar64Vec3)->SubmeshVertId{
 		//this happens to be well-defined.  there are no virtual virtices
 		SubmeshVertId::new(

engine/physics/src/push_solve.rs

@@ -1,4 +1,6 @@
-use strafesnet_common::integer::{self,vec3::{self,Vector3},Fixed,Planar64,Planar64Vec3,Ratio};
+use strafesnet_common::integer::vec3::{self,Vector3};
+use strafesnet_common::integer::{Fixed,Planar64Vec3,Ratio};
+use strafesnet_common::ray::Ray;
 
 // This algorithm is based on Lua code
 // written by Trey Reynolds in 2021
@@ -12,24 +14,6 @@ type Conts<'a>=arrayvec::ArrayVec<&'a Contact,4>;
 // hack to allow comparing ratios to zero
 const RATIO_ZERO:Ratio<Fixed<1,32>,Fixed<1,32>>=Ratio::new(Fixed::ZERO,Fixed::EPSILON);
 
-struct Ray{
-	origin:Planar64Vec3,
-	direction:Planar64Vec3,
-}
-impl Ray{
-	fn extrapolate<Num,Den,N1,T1>(&self,t:Ratio<Num,Den>)->Planar64Vec3
-	where
-		Num:Copy,
-		Den:Copy,
-		Num:core::ops::Mul<Planar64,Output=N1>,
-		Planar64:core::ops::Mul<Den,Output=N1>,
-		N1:integer::Divide<Den,Output=T1>,
-		T1:integer::Fix<Planar64>,
-	{
-		self.origin+self.direction.map(|elem|(t*elem).divide().fix())
-	}
-}
-
 /// Information about a contact restriction
 pub struct Contact{
 	pub position:Planar64Vec3,

lib/bsp_loader/Cargo.toml

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

lib/bsp_loader/src/brush.rs

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

lib/bsp_loader/src/bsp.rs

@@ -1,5 +1,7 @@
 use std::borrow::Cow;
 
+use vbsp_entities::css::Entity;
+
 use strafesnet_common::{map,model,integer,gameplay_attributes};
 use strafesnet_deferred_loader::deferred_loader::{MeshDeferredLoader,RenderConfigDeferredLoader};
 use strafesnet_deferred_loader::mesh::Meshes;
@@ -32,6 +34,47 @@ fn ingest_vertex(
 	})
 }
 
+fn add_brush<'a>(
+	mesh_deferred_loader:&mut MeshDeferredLoader<&'a str>,
+	world_models:&mut Vec<model::Model>,
+	prop_models:&mut Vec<model::Model>,
+	model:&'a str,
+	origin:vbsp::Vector,
+	rendercolor:vbsp::Color,
+	attributes:gameplay_attributes::CollisionAttributesId,
+){
+	let transform=integer::Planar64Affine3::from_translation(
+		valve_transform(origin.into())
+	);
+	let color=(glam::Vec3::from_array([
+		rendercolor.r as f32,
+		rendercolor.g as f32,
+		rendercolor.b as f32
+	])/255.0).extend(1.0);
+
+	match model.split_at(1){
+		// The first character of brush.model is '*'
+		("*",id_str)=>match id_str.parse(){
+			Ok(mesh_id)=>{
+				let mesh=model::MeshId::new(mesh_id);
+				world_models.push(
+					model::Model{mesh,attributes,transform,color}
+				);
+			},
+			Err(e)=>{
+				println!("Brush model int parse error: {e} model={model}");
+				return;
+			},
+		},
+		_=>{
+			let mesh=mesh_deferred_loader.acquire_mesh_id(model);
+			prop_models.push(
+				model::Model{mesh,attributes,transform,color}
+			);
+		}
+	}
+}
+
 pub fn convert<'a>(
 	bsp:&'a crate::Bsp,
 	render_config_deferred_loader:&mut RenderConfigDeferredLoader<Cow<'a,str>>,
@@ -41,16 +84,20 @@ pub fn convert<'a>(
 	//figure out real attributes later
 	let mut unique_attributes=Vec::new();
 	unique_attributes.push(gameplay_attributes::CollisionAttributes::Decoration);
-	const TEMP_TOUCH_ME_ATTRIBUTE:gameplay_attributes::CollisionAttributesId=gameplay_attributes::CollisionAttributesId::new(0);
+	unique_attributes.push(gameplay_attributes::CollisionAttributes::contact_default());
+	unique_attributes.push(gameplay_attributes::CollisionAttributes::intersect_default());
+	const ATTRIBUTE_DECORATION:gameplay_attributes::CollisionAttributesId=gameplay_attributes::CollisionAttributesId::new(0);
+	const ATTRIBUTE_CONTACT_DEFAULT:gameplay_attributes::CollisionAttributesId=gameplay_attributes::CollisionAttributesId::new(1);
+	const ATTRIBUTE_INTERSECT_DEFAULT:gameplay_attributes::CollisionAttributesId=gameplay_attributes::CollisionAttributesId::new(2);
 
 	//declare all prop models to Loader
-	let prop_models=bsp.static_props().map(|prop|{
+	let mut prop_models=bsp.static_props().map(|prop|{
 		//get or create mesh_id
 		let mesh_id=mesh_deferred_loader.acquire_mesh_id(prop.model());
 		let placement=prop.as_prop_placement();
 		model::Model{
 			mesh:mesh_id,
-			attributes:TEMP_TOUCH_ME_ATTRIBUTE,
+			attributes:ATTRIBUTE_DECORATION,
 			transform:integer::Planar64Affine3::new(
 				integer::mat3::try_from_f32_array_2d((
 					glam::Mat3A::from_diagonal(glam::Vec3::splat(placement.scale))
@@ -67,7 +114,7 @@ pub fn convert<'a>(
 
 	//the generated MeshIds in here will collide with the Loader Mesh Ids
 	//but I can't think of a good workaround other than just remapping one later.
-	let world_meshes:Vec<model::Mesh>=bsp.models().map(|world_model|{
+	let mut world_meshes:Vec<model::Mesh>=bsp.models().map(|world_model|{
 		let mut mb=model::MeshBuilder::new();
 
 		let color=mb.acquire_color_id(glam::Vec4::ONE);
@@ -118,49 +165,126 @@ pub fn convert<'a>(
 		mb.build(polygon_groups,graphics_groups,vec![])
 	}).collect();
 
-	let world_models:Vec<model::Model>=
-	//one instance of the main world mesh
-	std::iter::once((
-		//world_model
-		model::MeshId::new(0),
-		//model_origin
-		vbsp::Vector::from([0.0,0.0,0.0]),
-		//model_color
-		vbsp::Color{r:255,g:255,b:255},
-	)).chain(
-		//entities sprinkle instances of the other meshes around
-		bsp.entities.iter()
-		.flat_map(|ent|ent.parse())//ignore entity parsing errors
-		.filter_map(|ent|match ent{
-			vbsp::Entity::Brush(brush)=>Some(brush),
-			vbsp::Entity::BrushIllusionary(brush)=>Some(brush),
-			vbsp::Entity::BrushWall(brush)=>Some(brush),
-			vbsp::Entity::BrushWallToggle(brush)=>Some(brush),
-			_=>None,
-		}).flat_map(|brush|
-			//The first character of brush.model is '*'
-			brush.model[1..].parse().map(|mesh_id|//ignore parse int errors
-				(model::MeshId::new(mesh_id),brush.origin,brush.color)
-			)
-		)
-	).map(|(mesh_id,model_origin,vbsp::Color{r,g,b})|{
-		model::Model{
-			mesh:mesh_id,
-			attributes:TEMP_TOUCH_ME_ATTRIBUTE,
-			transform:integer::Planar64Affine3::new(
-				integer::mat3::identity(),
-				valve_transform(model_origin.into())
-			),
-			color:(glam::Vec3::from_array([r as f32,g as f32,b as f32])/255.0).extend(1.0),
+	let mut found_spawn=None;
+
+	let mut world_models=Vec::new();
+
+	// the one and only world model 0
+	world_models.push(model::Model{
+		mesh:model::MeshId::new(0),
+		attributes:ATTRIBUTE_DECORATION,
+		transform:integer::Planar64Affine3::IDENTITY,
+		color:glam::Vec4::W,
+	});
+
+	const WHITE:vbsp::Color=vbsp::Color{r:255,g:255,b:255};
+	for raw_ent in &bsp.entities{
+		match raw_ent.parse(){
+			Ok(Entity::Cycler(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin,brush.rendercolor,ATTRIBUTE_DECORATION),
+			Ok(Entity::EnvSprite(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin,brush.rendercolor.parse().unwrap_or(WHITE),ATTRIBUTE_DECORATION),
+			Ok(Entity::FuncBreakable(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin,brush.rendercolor,ATTRIBUTE_DECORATION),
+			Ok(Entity::FuncBrush(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin,brush.rendercolor,ATTRIBUTE_DECORATION),
+			Ok(Entity::FuncButton(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin,brush.rendercolor,ATTRIBUTE_DECORATION),
+			Ok(Entity::FuncDoor(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin,brush.rendercolor,ATTRIBUTE_DECORATION),
+			Ok(Entity::FuncDoorRotating(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin,brush.rendercolor,ATTRIBUTE_DECORATION),
+			Ok(Entity::FuncIllusionary(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin,brush.rendercolor,ATTRIBUTE_DECORATION),
+			Ok(Entity::FuncMonitor(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin,brush.rendercolor,ATTRIBUTE_DECORATION),
+			Ok(Entity::FuncMovelinear(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin,brush.rendercolor,ATTRIBUTE_DECORATION),
+			Ok(Entity::FuncPhysbox(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin,brush.rendercolor,ATTRIBUTE_DECORATION),
+			Ok(Entity::FuncPhysboxMultiplayer(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin,brush.rendercolor,ATTRIBUTE_DECORATION),
+			Ok(Entity::FuncRotButton(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin,WHITE,ATTRIBUTE_DECORATION),
+			Ok(Entity::FuncRotating(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin,brush.rendercolor,ATTRIBUTE_DECORATION),
+			Ok(Entity::FuncTracktrain(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin,brush.rendercolor,ATTRIBUTE_DECORATION),
+			Ok(Entity::FuncTrain(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin,brush.rendercolor,ATTRIBUTE_DECORATION),
+			Ok(Entity::FuncWall(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin.unwrap_or_default(),brush.rendercolor,ATTRIBUTE_DECORATION),
+			Ok(Entity::FuncWallToggle(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin.unwrap_or_default(),brush.rendercolor,ATTRIBUTE_DECORATION),
+			Ok(Entity::FuncWaterAnalog(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin,brush.rendercolor.unwrap_or(WHITE),ATTRIBUTE_DECORATION),
+			Ok(Entity::PropDoorRotating(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin,WHITE,ATTRIBUTE_DECORATION),
+			Ok(Entity::PropDynamic(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin,WHITE,ATTRIBUTE_DECORATION),
+			Ok(Entity::PropDynamicOverride(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin,WHITE,ATTRIBUTE_DECORATION),
+			Ok(Entity::PropPhysics(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin,WHITE,ATTRIBUTE_DECORATION),
+			Ok(Entity::PropPhysicsMultiplayer(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin,WHITE,ATTRIBUTE_DECORATION),
+			Ok(Entity::PropPhysicsOverride(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin,WHITE,ATTRIBUTE_DECORATION),
+			Ok(Entity::PropRagdoll(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin,WHITE,ATTRIBUTE_DECORATION),
+			Ok(Entity::TriggerGravity(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin,WHITE,ATTRIBUTE_DECORATION),
+			Ok(Entity::TriggerHurt(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin,WHITE,ATTRIBUTE_DECORATION),
+			Ok(Entity::TriggerLook(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin,WHITE,ATTRIBUTE_DECORATION),
+			Ok(Entity::TriggerMultiple(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model.unwrap_or_default(),brush.origin,WHITE,ATTRIBUTE_DECORATION),
+			Ok(Entity::TriggerOnce(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin,WHITE,ATTRIBUTE_DECORATION),
+			Ok(Entity::TriggerProximity(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin,WHITE,ATTRIBUTE_DECORATION),
+			Ok(Entity::TriggerPush(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin,WHITE,ATTRIBUTE_DECORATION),
+			Ok(Entity::TriggerSoundscape(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin,WHITE,ATTRIBUTE_DECORATION),
+			Ok(Entity::TriggerTeleport(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model.unwrap_or_default(),brush.origin,WHITE,ATTRIBUTE_DECORATION),
+			Ok(Entity::TriggerVphysicsMotion(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin,WHITE,ATTRIBUTE_DECORATION),
+			Ok(Entity::TriggerWind(brush))=>add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin,WHITE,ATTRIBUTE_DECORATION),
+			Ok(Entity::InfoPlayerCounterterrorist(spawn))=>{
+				found_spawn=Some(valve_transform(spawn.origin.into()));
+			},
+			Ok(Entity::InfoPlayerTerrorist(spawn))=>{
+				found_spawn=Some(valve_transform(spawn.origin.into()));
+			},
+			Err(e)=>{
+				println!("Bsp Entity parse error: {e}");
+			},
+			_=>(),
 		}
-	}).collect();
+	}
+
+	// physics models
+	for brush in &bsp.brushes{
+		if !brush.flags.contains(vbsp::BrushFlags::SOLID){
+			continue;
+		}
+		let mesh_result=crate::brush::brush_to_mesh(bsp,brush);
+		match mesh_result{
+			Ok(mesh)=>{
+				let mesh_id=model::MeshId::new(world_meshes.len() as u32);
+				world_meshes.push(mesh);
+				world_models.push(model::Model{
+					mesh:mesh_id,
+					attributes:ATTRIBUTE_CONTACT_DEFAULT,
+					transform:integer::Planar64Affine3::new(
+						integer::mat3::identity(),
+						integer::vec3::ZERO,
+					),
+					color:glam::Vec4::ONE,
+				});
+			},
+			Err(e)=>println!("Brush mesh error: {e}"),
+		}
+	}
+
+	let mut modes_list=Vec::new();
+	if let Some(spawn_point)=found_spawn{
+		// create a new mesh
+		let mesh_id=model::MeshId::new(world_meshes.len() as u32);
+		world_meshes.push(crate::brush::unit_cube());
+		// create a new model
+		let model_id=model::ModelId::new(world_models.len() as u32);
+		world_models.push(model::Model{
+			mesh:mesh_id,
+			attributes:ATTRIBUTE_INTERSECT_DEFAULT,
+			transform:integer::Planar64Affine3::from_translation(spawn_point),
+			color:glam::Vec4::W,
+		});
+
+		let first_stage=strafesnet_common::gameplay_modes::Stage::empty(model_id);
+		let main_mode=strafesnet_common::gameplay_modes::Mode::new(
+			strafesnet_common::gameplay_style::StyleModifiers::source_bhop(),
+			model_id,
+			std::collections::HashMap::new(),
+			vec![first_stage],
+			std::collections::HashMap::new(),
+		);
+		modes_list.push(main_mode);
+	}
 
 	PartialMap1{
 		attributes:unique_attributes,
 		world_meshes,
 		prop_models,
 		world_models,
-		modes:strafesnet_common::gameplay_modes::Modes::new(Vec::new()),
+		modes:strafesnet_common::gameplay_modes::Modes::new(modes_list),
 	}
 }
 

lib/bsp_loader/src/lib.rs

@@ -2,9 +2,16 @@ use strafesnet_deferred_loader::deferred_loader::{LoadFailureMode,MeshDeferredLo
 
 mod bsp;
 mod mesh;
+mod brush;
 pub mod loader;
 
 const VALVE_SCALE:f32=1.0/16.0;
+pub(crate) fn valve_transform_dist(d:f32)->strafesnet_common::integer::Planar64{
+	(d*VALVE_SCALE).try_into().unwrap()
+}
+pub(crate) fn valve_transform_normal([x,y,z]:[f32;3])->strafesnet_common::integer::Planar64Vec3{
+	strafesnet_common::integer::vec3::try_from_f32_array([x,z,-y]).unwrap()
+}
 pub(crate) fn valve_transform([x,y,z]:[f32;3])->strafesnet_common::integer::Planar64Vec3{
 	strafesnet_common::integer::vec3::try_from_f32_array([x*VALVE_SCALE,z*VALVE_SCALE,-y*VALVE_SCALE]).unwrap()
 }

lib/bsp_loader/src/loader.rs

@@ -47,7 +47,7 @@ pub enum MeshError{
 	Io(std::io::Error),
 	VMDL(vmdl::ModelError),
 	VBSP(vbsp::BspError),
-	MissingMdl,
+	MissingMdl(String),
 	MissingVtx,
 	MissingVvd,
 }
@@ -132,7 +132,7 @@ impl<'bsp,'vpk,'a> Loader for ModelLoader<'bsp,'vpk,'a>
 		vvd_path.set_extension("vvd");
 		vtx_path.set_extension("dx90.vtx");
 		// TODO: search more packs, possibly using an index of multiple packs
-		let mdl=self.finder.find(mdl_path_lower.as_str())?.ok_or(MeshError::MissingMdl)?;
+		let mdl=self.finder.find(mdl_path_lower.as_str())?.ok_or(MeshError::MissingMdl(mdl_path_lower))?;
 		let vtx=self.finder.find(vtx_path.as_os_str().to_str().unwrap())?.ok_or(MeshError::MissingVtx)?;
 		let vvd=self.finder.find(vvd_path.as_os_str().to_str().unwrap())?.ok_or(MeshError::MissingVvd)?;
 		Ok(vmdl::Model::from_parts(

lib/common/src/aabb.rs

@@ -34,6 +34,10 @@ impl Aabb{
 		self.min-=hs;
 		self.max+=hs;
 	}
+	pub fn contains(&self,point:Planar64Vec3)->bool{
+		let bvec=self.min.lt(point)&point.lt(self.max);
+		bvec.all()
+	}
 	pub fn intersects(&self,aabb:&Aabb)->bool{
 		let bvec=self.min.lt(aabb.max)&aabb.min.lt(self.max);
 		bvec.all()

lib/common/src/bvh.rs

@@ -1,4 +1,10 @@
+use std::cmp::Ordering;
+use std::collections::BTreeMap;
+
 use crate::aabb::Aabb;
+use crate::ray::Ray;
+use crate::integer::{Ratio,Planar64};
+use crate::instruction::{InstructionCollector,TimedInstruction};
 
 //da algaritum
 //lista boxens
@@ -10,6 +16,96 @@ use crate::aabb::Aabb;
 //sort the centerpoints on each axis (3 lists)
 //bv is put into octant based on whether it is upper or lower in each list
 
+
+pub fn intersect_aabb(ray:&Ray,aabb:&Aabb)->Option<Ratio<Planar64,Planar64>>{
+	// n.(o+d*t)==n.p
+	// n.o + n.d * t == n.p
+	// t == (n.p - n.o)/n.d
+	let mut hit=None;
+	match ray.direction.x.cmp(&Planar64::ZERO){
+		Ordering::Less=>{
+			let rel_min=aabb.min()-ray.origin;
+			let rel_max=aabb.max()-ray.origin;
+			let dy=rel_max.x*ray.direction.y;
+			let dz=rel_max.x*ray.direction.z;
+			// x is negative, so inequalities are flipped
+			if rel_min.y*ray.direction.x>dy&&dy>rel_max.y*ray.direction.x
+			 &&rel_min.z*ray.direction.x>dz&&dz>rel_max.z*ray.direction.x{
+				let t=rel_max.x/ray.direction.x;
+				hit=Some(hit.map_or(t,|best_t|t.min(best_t)));
+			}
+		},
+		Ordering::Equal=>(),
+		Ordering::Greater=>{
+			let rel_min=aabb.min()-ray.origin;
+			let rel_max=aabb.max()-ray.origin;
+			let dy=rel_min.x*ray.direction.y;
+			let dz=rel_min.x*ray.direction.z;
+			// x is positive, so inequalities are normal
+			if rel_min.y*ray.direction.x<dy&&dy<rel_max.y*ray.direction.x
+			 &&rel_min.z*ray.direction.x<dz&&dz<rel_max.z*ray.direction.x{
+				let t=rel_min.x/ray.direction.x;
+				hit=Some(hit.map_or(t,|best_t|t.min(best_t)));
+			}
+		},
+	}
+	match ray.direction.z.cmp(&Planar64::ZERO){
+		Ordering::Less=>{
+			let rel_min=aabb.min()-ray.origin;
+			let rel_max=aabb.max()-ray.origin;
+			let dx=rel_max.z*ray.direction.x;
+			let dy=rel_max.z*ray.direction.y;
+			// z is negative, so inequalities are flipped
+			if rel_min.x*ray.direction.z>dx&&dx>rel_max.x*ray.direction.z
+			 &&rel_min.y*ray.direction.z>dy&&dy>rel_max.y*ray.direction.z{
+				let t=rel_max.z/ray.direction.z;
+				hit=Some(hit.map_or(t,|best_t|t.min(best_t)));
+			}
+		},
+		Ordering::Equal=>(),
+		Ordering::Greater=>{
+			let rel_min=aabb.min()-ray.origin;
+			let rel_max=aabb.max()-ray.origin;
+			let dx=rel_min.z*ray.direction.x;
+			let dy=rel_min.z*ray.direction.y;
+			// z is positive, so inequalities are normal
+			if rel_min.x*ray.direction.z<dx&&dx<rel_max.x*ray.direction.z
+			 &&rel_min.y*ray.direction.z<dy&&dy<rel_max.y*ray.direction.z{
+				let t=rel_min.z/ray.direction.z;
+				hit=Some(hit.map_or(t,|best_t|t.min(best_t)));
+			}
+		},
+	}
+	match ray.direction.y.cmp(&Planar64::ZERO){
+		Ordering::Less=>{
+			let rel_min=aabb.min()-ray.origin;
+			let rel_max=aabb.max()-ray.origin;
+			let dz=rel_max.y*ray.direction.z;
+			let dx=rel_max.y*ray.direction.x;
+			// y is negative, so inequalities are flipped
+			if rel_min.z*ray.direction.y>dz&&dz>rel_max.z*ray.direction.y
+			 &&rel_min.x*ray.direction.y>dx&&dx>rel_max.x*ray.direction.y{
+				let t=rel_max.y/ray.direction.y;
+				hit=Some(hit.map_or(t,|best_t|t.min(best_t)));
+			}
+		},
+		Ordering::Equal=>(),
+		Ordering::Greater=>{
+			let rel_min=aabb.min()-ray.origin;
+			let rel_max=aabb.max()-ray.origin;
+			let dz=rel_min.y*ray.direction.z;
+			let dx=rel_min.y*ray.direction.x;
+			// y is positive, so inequalities are normal
+			if rel_min.z*ray.direction.y<dz&&dz<rel_max.z*ray.direction.y
+			 &&rel_min.x*ray.direction.y<dx&&dx<rel_max.x*ray.direction.y{
+				let t=rel_min.y/ray.direction.y;
+				hit=Some(hit.map_or(t,|best_t|t.min(best_t)));
+			}
+		},
+	}
+	hit
+}
+
 pub enum RecursiveContent<N,L>{
 	Branch(Vec<N>),
 	Leaf(L),
@@ -44,6 +140,92 @@ impl<L> BvhNode<L>{
 			},
 		}
 	}
+	fn populate_nodes<'a,T,F>(
+		&'a self,
+		collector:&mut InstructionCollector<&'a L,Ratio<Planar64,Planar64>>,
+		nodes:&mut BTreeMap<Ratio<Planar64,Planar64>,&'a BvhNode<L>>,
+		ray:&Ray,
+		start_time:Ratio<Planar64,Planar64>,
+		f:&F,
+	)
+		where
+			T:Ord+Copy,
+			Ratio<Planar64,Planar64>:From<T>,
+			F:Fn(&L,&Ray)->Option<T>,
+	{
+		match &self.content{
+			RecursiveContent::Leaf(leaf)=>if let Some(time)=f(leaf,ray){
+				let ins=TimedInstruction{time:time.into(),instruction:leaf};
+				if start_time.lt_ratio(ins.time)&&ins.time.lt_ratio(collector.time()){
+					collector.collect(Some(ins));
+				}
+			},
+			RecursiveContent::Branch(children)=>for child in children{
+				if child.aabb.contains(ray.origin){
+					child.populate_nodes(collector,nodes,ray,start_time,f);
+				}else{
+					// Am I an upcoming superstar?
+					if let Some(t)=intersect_aabb(ray,&child.aabb){
+						if start_time.lt_ratio(t)&&t.lt_ratio(collector.time()){
+							nodes.insert(t,child);
+						}
+					}
+				}
+			},
+		}
+	}
+	pub fn sample_ray<T,F>(
+		&self,
+		ray:&Ray,
+		start_time:T,
+		time_limit:T,
+		f:F,
+	)->Option<(T,&L)>
+		where
+			T:Ord+Copy,
+			T:From<Ratio<Planar64,Planar64>>,
+			Ratio<Planar64,Planar64>:From<T>,
+			F:Fn(&L,&Ray)->Option<T>,
+	{
+		// source of nondeterminism when Aabb boundaries are coplanar
+		let mut nodes=BTreeMap::new();
+
+		let start_time=start_time.into();
+		let time_limit=time_limit.into();
+		let mut collector=InstructionCollector::new(time_limit);
+		// break open all nodes that contain ray.origin and populate nodes with future intersection times
+		self.populate_nodes(&mut collector,&mut nodes,ray,start_time,&f);
+
+		// swim through nodes one at a time
+		while let Some((t,node))=nodes.pop_first(){
+			if collector.time()<t{
+				break;
+			}
+			match &node.content{
+				RecursiveContent::Leaf(leaf)=>if let Some(time)=f(leaf,ray){
+					let ins=TimedInstruction{time:time.into(),instruction:leaf};
+					// this lower bound can also be omitted
+					// but it causes type inference errors lol
+					if start_time.lt_ratio(ins.time)&&ins.time.lt_ratio(collector.time()){
+						collector.collect(Some(ins));
+					}
+				},
+				// break open the node and predict collisions with the child nodes
+				RecursiveContent::Branch(children)=>for child in children{
+					// Am I an upcoming superstar?
+					if let Some(t)=intersect_aabb(ray,&child.aabb){
+						// we don't need to check the lower bound
+						// because child aabbs are guaranteed to be within the parent bounds.
+						if t<collector.time(){
+							nodes.insert(t,child);
+						}
+					}
+				},
+			}
+		}
+
+		collector.take().map(|TimedInstruction{time,instruction:leaf}|(time.into(),leaf))
+	}
 	pub fn into_inner(self)->(RecursiveContent<BvhNode<L>,L>,Aabb){
 		(self.content,self.aabb)
 	}

lib/common/src/gameplay_attributes.rs

@@ -171,4 +171,7 @@ impl CollisionAttributes{
 	pub fn contact_default()->Self{
 		Self::Contact(ContactAttributes::default())
 	}
+	pub fn intersect_default()->Self{
+		Self::Intersect(IntersectAttributes::default())
+	}
 }

lib/common/src/integer.rs

@@ -4,11 +4,11 @@ pub use ratio_ops::ratio::{Ratio,Divide};
 //integer units
 
 /// specific example of a "default" time type
-#[derive(Clone,Copy,Hash,Eq,PartialEq,PartialOrd,Debug)]
+#[derive(Clone,Copy,Hash,Eq,PartialEq,Ord,PartialOrd,Debug)]
 pub enum TimeInner{}
 pub type AbsoluteTime=Time<TimeInner>;
 
-#[derive(Clone,Copy,Hash,Eq,PartialEq,PartialOrd,Debug)]
+#[derive(Clone,Copy,Hash,Eq,PartialEq,Ord,PartialOrd,Debug)]
 pub struct Time<T>(i64,core::marker::PhantomData<T>);
 impl<T> Time<T>{
 	pub const MIN:Self=Self::raw(i64::MIN);
@@ -654,11 +654,19 @@ pub struct Planar64Affine3{
 	pub translation:Planar64Vec3,
 }
 impl Planar64Affine3{
+	pub const IDENTITY:Self=Self::new(mat3::identity(),vec3::ZERO);
 	#[inline]
 	pub const fn new(matrix3:Planar64Mat3,translation:Planar64Vec3)->Self{
 		Self{matrix3,translation}
 	}
 	#[inline]
+	pub const fn from_translation(translation:Planar64Vec3)->Self{
+		Self{
+			matrix3:mat3::identity(),
+			translation,
+		}
+	}
+	#[inline]
 	pub fn transform_point3(&self,point:Planar64Vec3)->vec3::Vector3<Fixed<2,64>>{
 		self.translation.fix_2()+self.matrix3*point
 	}

lib/common/src/lib.rs

@@ -1,5 +1,6 @@
 pub mod bvh;
 pub mod map;
+pub mod ray;
 pub mod run;
 pub mod aabb;
 pub mod model;

lib/common/src/physics.rs

@@ -1,7 +1,7 @@
 use crate::mouse::MouseState;
 use crate::gameplay_modes::{ModeId,StageId};
 
-#[derive(Clone,Copy,Hash,Eq,PartialEq,PartialOrd,Debug)]
+#[derive(Clone,Copy,Hash,Eq,PartialEq,Ord,PartialOrd,Debug)]
 pub enum TimeInner{}
 pub type Time=crate::integer::Time<TimeInner>;
 

lib/common/src/ray.rs

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

lib/common/src/run.rs

@@ -2,7 +2,7 @@ use crate::timer::{TimerFixed,Realtime,Paused,Unpaused};
 
 use crate::physics::{TimeInner as PhysicsTimeInner,Time as PhysicsTime};
 
-#[derive(Clone,Copy,Hash,Eq,PartialEq,PartialOrd,Debug)]
+#[derive(Clone,Copy,Hash,Eq,PartialEq,Ord,PartialOrd,Debug)]
 pub enum TimeInner{}
 pub type Time=crate::integer::Time<TimeInner>;
 

lib/common/src/session.rs

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

lib/linear_ops/src/matrix.rs

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

lib/linear_ops/src/vector.rs

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

lib/ratio_ops/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ratio_ops"
-version = "0.1.0"
+version = "0.1.1"
 edition = "2024"
 repository = "https://git.itzana.me/StrafesNET/strafe-project"
 license = "MIT OR Apache-2.0"

lib/ratio_ops/src/ratio.rs

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

map-tool/Cargo.toml

@@ -25,7 +25,8 @@ strafesnet_rbx_loader = { version = "0.6.0", path = "../lib/rbx_loader", registr
 strafesnet_snf = { version = "0.3.0", path = "../lib/snf", registry = "strafesnet" }
 thiserror = "2.0.11"
 tokio = { version = "1.43.0", features = ["macros", "rt-multi-thread", "fs"] }
-vbsp = "0.6.0"
+vbsp = { version = "0.7.0-codegen5", registry = "strafesnet", default-features = false }
+vbsp-entities = { version = "0.1.0", registry = "strafesnet", default-features = false, features = ["css"]}
 vmdl = "0.2.0"
 vmt-parser = "0.2.0"
 vpk = "0.2.0"

map-tool/src/source.rs

@@ -6,6 +6,7 @@ use futures::StreamExt;
 use strafesnet_bsp_loader::loader::BspFinder;
 use strafesnet_deferred_loader::loader::Loader;
 use strafesnet_deferred_loader::deferred_loader::{LoadFailureMode,MeshDeferredLoader,RenderConfigDeferredLoader};
+use vbsp_entities::css::Entity;
 
 #[derive(Subcommand)]
 pub enum Commands{
@@ -244,8 +245,57 @@ async fn gimme_them_textures(path:&Path,vpk_list:&[strafesnet_bsp_loader::Vpk],s
 	}
 
 	let mut mesh_deferred_loader=MeshDeferredLoader::new();
-	for prop in bsp.static_props(){
-		mesh_deferred_loader.acquire_mesh_id(prop.model());
+	for name in &bsp.static_props.dict.name{
+		mesh_deferred_loader.acquire_mesh_id(name.as_str());
+	}
+
+	for raw_ent in &bsp.entities{
+		let model=match raw_ent.parse(){
+			Ok(Entity::Cycler(brush))=>brush.model,
+			Ok(Entity::EnvSprite(brush))=>brush.model,
+			Ok(Entity::FuncBreakable(brush))=>brush.model,
+			Ok(Entity::FuncBrush(brush))=>brush.model,
+			Ok(Entity::FuncButton(brush))=>brush.model,
+			Ok(Entity::FuncDoor(brush))=>brush.model,
+			Ok(Entity::FuncDoorRotating(brush))=>brush.model,
+			Ok(Entity::FuncIllusionary(brush))=>brush.model,
+			Ok(Entity::FuncMonitor(brush))=>brush.model,
+			Ok(Entity::FuncMovelinear(brush))=>brush.model,
+			Ok(Entity::FuncPhysbox(brush))=>brush.model,
+			Ok(Entity::FuncPhysboxMultiplayer(brush))=>brush.model,
+			Ok(Entity::FuncRotButton(brush))=>brush.model,
+			Ok(Entity::FuncRotating(brush))=>brush.model,
+			Ok(Entity::FuncTracktrain(brush))=>brush.model,
+			Ok(Entity::FuncTrain(brush))=>brush.model,
+			Ok(Entity::FuncWall(brush))=>brush.model,
+			Ok(Entity::FuncWallToggle(brush))=>brush.model,
+			Ok(Entity::FuncWaterAnalog(brush))=>brush.model,
+			Ok(Entity::PropDoorRotating(brush))=>brush.model,
+			Ok(Entity::PropDynamic(brush))=>brush.model,
+			Ok(Entity::PropDynamicOverride(brush))=>brush.model,
+			Ok(Entity::PropPhysics(brush))=>brush.model,
+			Ok(Entity::PropPhysicsMultiplayer(brush))=>brush.model,
+			Ok(Entity::PropPhysicsOverride(brush))=>brush.model,
+			Ok(Entity::PropRagdoll(brush))=>brush.model,
+			Ok(Entity::TriggerGravity(brush))=>brush.model,
+			Ok(Entity::TriggerHurt(brush))=>brush.model,
+			Ok(Entity::TriggerLook(brush))=>brush.model,
+			Ok(Entity::TriggerMultiple(brush))=>brush.model.unwrap_or_default(),
+			Ok(Entity::TriggerOnce(brush))=>brush.model,
+			Ok(Entity::TriggerProximity(brush))=>brush.model,
+			Ok(Entity::TriggerPush(brush))=>brush.model,
+			Ok(Entity::TriggerSoundscape(brush))=>brush.model,
+			Ok(Entity::TriggerTeleport(brush))=>brush.model.unwrap_or_default(),
+			Ok(Entity::TriggerVphysicsMotion(brush))=>brush.model,
+			Ok(Entity::TriggerWind(brush))=>brush.model,
+			_=>continue,
+		};
+		match model.chars().next(){
+			Some('*')=>(),
+			_=>{
+				mesh_deferred_loader.acquire_mesh_id(model);
+			},
+		}
 	}
 
 	let finder=BspFinder{