wrong the whole time

world models are not guaranteed to be convex, so this is problematic for physics

engine/graphics/Cargo.toml

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

engine/graphics/src/graphics.rs

@@ -5,7 +5,7 @@ use strafesnet_settings::settings;
 use strafesnet_session::session;
 use strafesnet_common::model::{self, ColorId, NormalId, PolygonIter, PositionId, RenderConfigId, TextureCoordinateId, VertexId};
 use wgpu::{util::DeviceExt,AstcBlock,AstcChannel};
-use crate::model::{self as model_graphics,IndexedGraphicsMeshOwnedRenderConfig,IndexedGraphicsMeshOwnedRenderConfigId,GraphicsMeshOwnedRenderConfig,GraphicsModelColor4,GraphicsModelOwned,GraphicsVertex};
+use crate::model::{self as model_graphics,IndexedGraphicsMeshOwnedRenderConfig,IndexedGraphicsMeshOwnedRenderConfigId,GraphicsMeshOwnedRenderConfig,GraphicsModelColor4,GraphicsModelOwned,GraphicsVertex,DebugGraphicsVertex};
 
 pub fn required_limits()->wgpu::Limits{
 	wgpu::Limits::default()
@@ -36,12 +36,22 @@ struct GraphicsModel{
 	instance_count:u32,
 }
 
+struct DebugGraphicsMesh{
+	indices:Indices,
+	vertex_buf:wgpu::Buffer,
+}
+struct DebugGraphicsModel{
+	debug_mesh_id:u32,
+	bind_group:wgpu::BindGroup,
+}
+
 struct GraphicsSamplers{
 	repeat:wgpu::Sampler,
 }
 
 struct GraphicsBindGroupLayouts{
 	model:wgpu::BindGroupLayout,
+	debug_model:wgpu::BindGroupLayout,
 }
 
 struct GraphicsBindGroups{
@@ -52,6 +62,7 @@ struct GraphicsBindGroups{
 struct GraphicsPipelines{
 	skybox:wgpu::RenderPipeline,
 	model:wgpu::RenderPipeline,
+	debug:wgpu::RenderPipeline,
 }
 
 struct GraphicsCamera{
@@ -112,6 +123,8 @@ pub struct GraphicsState{
 	camera_buf:wgpu::Buffer,
 	temp_squid_texture_view:wgpu::TextureView,
 	models:Vec<GraphicsModel>,
+	debug_meshes:Vec<DebugGraphicsMesh>,
+	debug_models:Vec<DebugGraphicsModel>,
 	depth_view:wgpu::TextureView,
 	staging_belt:wgpu::util::StagingBelt,
 }
@@ -146,6 +159,76 @@ impl GraphicsState{
 		self.camera.fov=user_settings.calculate_fov(1.0,&self.camera.screen_size).as_vec2();
 	}
 	pub fn generate_models(&mut self,device:&wgpu::Device,queue:&wgpu::Queue,map:&map::CompleteMap){
+		//generate debug meshes, each debug model refers to one
+		self.debug_meshes=map.meshes.iter().map(|mesh|{
+			let vertices:Vec<DebugGraphicsVertex>=mesh.unique_vertices.iter().map(|vertex|{
+				DebugGraphicsVertex{
+					pos:mesh.unique_pos[vertex.pos.get() as usize].to_array().map(Into::into),
+					normal:mesh.unique_normal[vertex.normal.get() as usize].to_array().map(Into::into),
+				}
+			}).collect();
+			let vertex_buf=device.create_buffer_init(&wgpu::util::BufferInitDescriptor{
+				label:Some("Vertex"),
+				contents:bytemuck::cast_slice(&vertices),
+				usage:wgpu::BufferUsages::VERTEX,
+			});
+
+			let mut indices=Vec::new();
+			for physics_group in &mesh.physics_groups{
+				for polygon_group_id in &physics_group.groups{
+					for poly in mesh.polygon_groups[polygon_group_id.get() as usize].polys(){
+						// triangulate
+						let mut poly_vertices=poly.into_iter().copied();
+						if let (Some(a),Some(mut b))=(poly_vertices.next(),poly_vertices.next()){
+							for c in poly_vertices{
+								indices.extend([a,b,c]);
+								b=c;
+							}
+						}
+					}
+				}
+			}
+
+			DebugGraphicsMesh{
+				indices:if (u32::MAX as usize)<vertices.len(){
+					panic!("Model has too many vertices!")
+				}else if (u16::MAX as usize)<vertices.len(){
+					Indices::new(device,&indices.into_iter().map(|vertex_idx|vertex_idx.get() as u32).collect(),wgpu::IndexFormat::Uint32)
+				}else{
+					Indices::new(device,&indices.into_iter().map(|vertex_idx|vertex_idx.get() as u16).collect(),wgpu::IndexFormat::Uint16)
+				},
+				vertex_buf,
+			}
+		}).collect();
+
+		//generate debug models, only one will be rendered at a time
+		self.debug_models=map.models.iter().enumerate().map(|(model_id,model)|{
+			let model_uniforms=get_instance_buffer_data(&GraphicsModelOwned{
+				transform:model.transform.into(),
+				normal_transform:glam::Mat3::from_cols_array_2d(&model.transform.matrix3.to_array().map(|row|row.map(Into::into))).inverse().transpose(),
+				color:GraphicsModelColor4::new(glam::vec4(1.0,0.0,0.0,0.2)),
+			});
+			let model_buf=device.create_buffer_init(&wgpu::util::BufferInitDescriptor{
+				label:Some(format!("Debug Model{} Buf",model_id).as_str()),
+				contents:bytemuck::cast_slice(&model_uniforms),
+				usage:wgpu::BufferUsages::UNIFORM|wgpu::BufferUsages::COPY_DST,
+			});
+			let bind_group=device.create_bind_group(&wgpu::BindGroupDescriptor{
+				layout:&self.bind_group_layouts.debug_model,
+				entries:&[
+					wgpu::BindGroupEntry{
+						binding:0,
+						resource:model_buf.as_entire_binding(),
+					},
+				],
+				label:Some(format!("Debug Model{} Bind Group",model_id).as_str()),
+			});
+			DebugGraphicsModel{
+				debug_mesh_id:model.mesh.get(),
+				bind_group,
+			}
+		}).collect();
+
 		//generate texture view per texture
 		let texture_views:HashMap<strafesnet_common::model::TextureId,wgpu::TextureView>=map.textures.iter().enumerate().filter_map(|(texture_id,texture_data)|{
 			let texture_id=model::TextureId::new(texture_id as u32);
@@ -588,6 +671,21 @@ impl GraphicsState{
 				},
 			],
 		});
+		let debug_model_bind_group_layout=device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor{
+			label:Some("Debug Model Bind Group Layout"),
+			entries:&[
+				wgpu::BindGroupLayoutEntry{
+					binding:0,
+					visibility:wgpu::ShaderStages::VERTEX_FRAGMENT,
+					ty:wgpu::BindingType::Buffer{
+						ty:wgpu::BufferBindingType::Uniform,
+						has_dynamic_offset:false,
+						min_binding_size:None,
+					},
+					count:None,
+				},
+			],
+		});
 
 		let clamp_sampler=device.create_sampler(&wgpu::SamplerDescriptor{
 			label:Some("Clamp Sampler"),
@@ -736,6 +834,14 @@ impl GraphicsState{
 			],
 			push_constant_ranges:&[],
 		});
+		let debug_model_pipeline_layout=device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor{
+				label:None,
+				bind_group_layouts:&[
+					&camera_bind_group_layout,
+					&debug_model_bind_group_layout,
+				],
+				push_constant_ranges:&[],
+			});
 		let sky_pipeline_layout=device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor{
 			label:None,
 			bind_group_layouts:&[
@@ -811,6 +917,45 @@ impl GraphicsState{
 			multiview:None,
 			cache:None,
 		});
+		let debug_model_pipeline=device.create_render_pipeline(&wgpu::RenderPipelineDescriptor{
+			label:Some("Debug Model Pipeline"),
+			layout:Some(&debug_model_pipeline_layout),
+			vertex:wgpu::VertexState{
+				module:&shader,
+				entry_point:Some("vs_debug"),
+				buffers:&[wgpu::VertexBufferLayout{
+					array_stride:std::mem::size_of::<DebugGraphicsVertex>() as wgpu::BufferAddress,
+					step_mode:wgpu::VertexStepMode::Vertex,
+					attributes:&wgpu::vertex_attr_array![0=>Float32x3,1=>Float32x3],
+				}],
+				compilation_options:wgpu::PipelineCompilationOptions::default(),
+			},
+			fragment:Some(wgpu::FragmentState{
+				module:&shader,
+				entry_point:Some("fs_debug"),
+				targets:&[Some(wgpu::ColorTargetState{
+					format:config.view_formats[0],
+					blend:Some(wgpu::BlendState::ALPHA_BLENDING),
+					write_mask:wgpu::ColorWrites::default(),
+				})],
+				compilation_options:wgpu::PipelineCompilationOptions::default(),
+			}),
+			primitive:wgpu::PrimitiveState{
+				front_face:wgpu::FrontFace::Cw,
+				cull_mode:Some(wgpu::Face::Front),
+				..Default::default()
+			},
+			depth_stencil:Some(wgpu::DepthStencilState{
+				format:Self::DEPTH_FORMAT,
+				depth_write_enabled:true,
+				depth_compare:wgpu::CompareFunction::Always,
+				stencil:wgpu::StencilState::default(),
+				bias:wgpu::DepthBiasState::default(),
+			}),
+			multisample:wgpu::MultisampleState::default(),
+			multiview:None,
+			cache:None,
+		});
 
 		let camera=GraphicsCamera::default();
 		let camera_uniforms=camera.to_uniform_data(glam::Vec3::ZERO,glam::Vec2::ZERO);
@@ -850,7 +995,8 @@ impl GraphicsState{
 		Self{
 			pipelines:GraphicsPipelines{
 				skybox:sky_pipeline,
-				model:model_pipeline
+				model:model_pipeline,
+				debug:debug_model_pipeline,
 			},
 			bind_groups:GraphicsBindGroups{
 				camera:camera_bind_group,
@@ -859,9 +1005,14 @@ impl GraphicsState{
 			camera,
 			camera_buf,
 			models:Vec::new(),
+			debug_meshes:Vec::new(),
+			debug_models:Vec::new(),
 			depth_view,
 			staging_belt:wgpu::util::StagingBelt::new(0x100),
-			bind_group_layouts:GraphicsBindGroupLayouts{model:model_bind_group_layout},
+			bind_group_layouts:GraphicsBindGroupLayouts{
+				model:model_bind_group_layout,
+				debug_model:debug_model_bind_group_layout,
+			},
 			samplers:GraphicsSamplers{repeat:repeat_sampler},
 			temp_squid_texture_view:squid_texture_view,
 		}
@@ -949,6 +1100,7 @@ impl GraphicsState{
 			rpass.set_bind_group(0,&self.bind_groups.camera,&[]);
 			rpass.set_bind_group(1,&self.bind_groups.skybox_texture,&[]);
 
+			// Draw all models.
 			rpass.set_pipeline(&self.pipelines.model);
 			for model in &self.models{
 				rpass.set_bind_group(2,&model.bind_group,&[]);
@@ -960,6 +1112,19 @@ impl GraphicsState{
 
 			rpass.set_pipeline(&self.pipelines.skybox);
 			rpass.draw(0..3,0..1);
+
+			// render a single debug_model in red
+			if let Some(model_id)=frame_state.debug_model{
+				if let Some(model)=self.debug_models.get(model_id.get() as usize){
+					let mesh=&self.debug_meshes[model.debug_mesh_id as usize];
+					rpass.set_pipeline(&self.pipelines.debug);
+					rpass.set_bind_group(1,&model.bind_group,&[]);
+					rpass.set_vertex_buffer(0,mesh.vertex_buf.slice(..));
+					rpass.set_index_buffer(mesh.indices.buf.slice(..),mesh.indices.format);
+					//TODO: loop over triangle strips
+					rpass.draw_indexed(0..mesh.indices.count,0,0..1);
+				}
+			}
 		}
 
 		queue.submit(std::iter::once(encoder.finish()));
@@ -968,21 +1133,23 @@ impl GraphicsState{
 	}
 }
 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;
+const MODEL_BUFFER_SIZE_BYTES:usize=MODEL_BUFFER_SIZE*core::mem::size_of::<f32>();
+fn get_instance_buffer_data(instance:&GraphicsModelOwned)->[f32;MODEL_BUFFER_SIZE]{
+	let mut out=[0.0;MODEL_BUFFER_SIZE];
+	out[0..16].copy_from_slice(instance.transform.as_ref());
+	out[16..19].copy_from_slice(instance.normal_transform.x_axis.as_ref());
+	// out[20]=0.0;
+	out[20..23].copy_from_slice(instance.normal_transform.y_axis.as_ref());
+	// out[24]=0.0;
+	out[24..27].copy_from_slice(instance.normal_transform.z_axis.as_ref());
+	// out[28]=0.0;
+	out[28..32].copy_from_slice(instance.color.get().as_ref());
+	out
+}
 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.extend_from_slice(&get_instance_buffer_data(mi));
 	}
 	raw
 }

engine/graphics/src/model.rs

@@ -8,6 +8,12 @@ pub struct GraphicsVertex{
 	pub normal:[f32;3],
 	pub color:[f32;4],
 }
+#[derive(Clone,Copy,Pod,Zeroable)]
+#[repr(C)]
+pub struct DebugGraphicsVertex{
+	pub pos:[f32;3],
+	pub normal:[f32;3],
+}
 #[derive(Clone,Copy,id::Id)]
 pub struct IndexedGraphicsMeshOwnedRenderConfigId(u32);
 pub struct IndexedGraphicsMeshOwnedRenderConfig{

engine/physics/Cargo.toml

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

engine/physics/src/model.rs

@@ -484,12 +484,15 @@ impl TransformedMesh<'_>{
 	pub fn verts<'a>(&'a self)->impl Iterator<Item=vec3::Vector3<Fixed<2,64>>>+'a{
 		self.view.data.verts.iter().map(|&Vert(pos)|self.transform.vertex.transform_point3(pos))
 	}
+	pub fn faces(&self)->impl Iterator<Item=SubmeshFaceId>{
+		(0..self.view.topology.faces.len() as u32).map(SubmeshFaceId::new)
+	}
 	fn farthest_vert(&self,dir:Planar64Vec3)->SubmeshVertId{
 		//this happens to be well-defined.  there are no virtual virtices
 		SubmeshVertId::new(
 			self.view.topology.verts.iter()
 			.enumerate()
-			.max_by_key(|(_,&vert_id)|
+			.max_by_key(|&(_,&vert_id)|
 				dir.dot(self.transform.vertex.transform_point3(self.view.data.verts[vert_id.get() as usize].0))
 			)
 			//assume there is more than zero vertices.

engine/physics/src/physics.rs

@@ -1,4 +1,5 @@
 use std::collections::{HashMap,HashSet};
+use crate::model::DirectedEdge;
 use crate::model::{self as model_physics,PhysicsMesh,PhysicsMeshTransform,TransformedMesh,MeshQuery,PhysicsMeshId,PhysicsSubmeshId};
 use strafesnet_common::bvh;
 use strafesnet_common::map;
@@ -280,7 +281,8 @@ impl PhysicsCamera{
 		.clamp(Self::ANGLE_PITCH_LOWER_LIMIT,Self::ANGLE_PITCH_UPPER_LIMIT);
 		mat3::from_rotation_yx(ax,ay)
 	}
-	fn rotation(&self)->Planar64Mat3{
+	#[inline]
+	pub fn rotation(&self)->Planar64Mat3{
 		self.get_rotation(self.clamped_mouse_pos)
 	}
 	fn simulate_move_rotation(&self,mouse_delta:glam::IVec2)->Planar64Mat3{
@@ -556,7 +558,7 @@ impl MoveState{
 			=>None,
 		}
 	}
-	fn next_move_instruction(&self,strafe:&Option<gameplay_style::StrafeSettings>,time:Time)->Option<TimedInstruction<InternalInstruction,TimeInner>>{
+	fn next_move_instruction(&self,strafe:&Option<gameplay_style::StrafeSettings>,time:Time)->Option<TimedInstruction<InternalInstruction,Time>>{
 		//check if you have a valid walk state and create an instruction
 		match self{
 			MoveState::Walk(walk_state)|MoveState::Ladder(walk_state)=>match &walk_state.target{
@@ -784,7 +786,7 @@ impl TouchingState{
 		}).collect();
 		crate::push_solve::push_solve(&contacts,acceleration)
 	}
-	fn predict_collision_end(&self,collector:&mut instruction::InstructionCollector<InternalInstruction,TimeInner>,models:&PhysicsModels,hitbox_mesh:&HitboxMesh,body:&Body,start_time:Time){
+	fn predict_collision_end(&self,collector:&mut instruction::InstructionCollector<InternalInstruction,Time>,models:&PhysicsModels,hitbox_mesh:&HitboxMesh,body:&Body,start_time:Time){
 		// let relative_body=body.relative_to(&Body::ZERO);
 		let relative_body=body;
 		for contact in &self.contacts{
@@ -878,7 +880,7 @@ impl PhysicsState{
 	fn reset_to_default(&mut self){
 		*self=Self::default();
 	}
-	fn next_move_instruction(&self)->Option<TimedInstruction<InternalInstruction,TimeInner>>{
+	fn next_move_instruction(&self)->Option<TimedInstruction<InternalInstruction,Time>>{
 		self.move_state.next_move_instruction(&self.style.strafe,self.time)
 	}
 	fn cull_velocity(&mut self,data:&PhysicsData,velocity:Planar64Vec3){
@@ -931,14 +933,16 @@ pub struct PhysicsData{
 	modes:gameplay_modes::Modes,
 	//cached calculations
 	hitbox_mesh:HitboxMesh,
+	pub le_models:Vec<strafesnet_common::model::Model>,
 }
 impl Default for PhysicsData{
 	fn default()->Self{
  		Self{
-			bvh:bvh::BvhNode::default(),
+			bvh:bvh::BvhNode::empty(),
 			models:Default::default(),
 			modes:Default::default(),
 			hitbox_mesh:StyleModifiers::default().calculate_mesh(),
+			le_models:Default::default(),
 		}
 	}
 }
@@ -950,21 +954,21 @@ pub struct PhysicsContext<'a>{
 // the physics consumes both Instruction and PhysicsInternalInstruction,
 // but can only emit PhysicsInternalInstruction
 impl InstructionConsumer<InternalInstruction> for PhysicsContext<'_>{
-	type TimeInner=TimeInner;
-	fn process_instruction(&mut self,ins:TimedInstruction<InternalInstruction,TimeInner>){
+	type Time=Time;
+	fn process_instruction(&mut self,ins:TimedInstruction<InternalInstruction,Time>){
 		atomic_internal_instruction(&mut self.state,&self.data,ins)
 	}
 }
 impl InstructionConsumer<Instruction> for PhysicsContext<'_>{
-	type TimeInner=TimeInner;
-	fn process_instruction(&mut self,ins:TimedInstruction<Instruction,TimeInner>){
+	type Time=Time;
+	fn process_instruction(&mut self,ins:TimedInstruction<Instruction,Time>){
 		atomic_input_instruction(&mut self.state,&self.data,ins)
 	}
 }
 impl InstructionEmitter<InternalInstruction> for PhysicsContext<'_>{
-	type TimeInner=TimeInner;
+	type Time=Time;
 	//this little next instruction function could cache its return value and invalidate the cached value by watching the State.
-	fn next_instruction(&self,time_limit:Time)->Option<TimedInstruction<InternalInstruction,TimeInner>>{
+	fn next_instruction(&self,time_limit:Time)->Option<TimedInstruction<InternalInstruction,Time>>{
 		next_instruction_internal(&self.state,&self.data,time_limit)
 	}
 }
@@ -972,7 +976,7 @@ impl PhysicsContext<'_>{
 	pub fn run_input_instruction(
 		state:&mut PhysicsState,
 		data:&PhysicsData,
-		instruction:TimedInstruction<Instruction,TimeInner>
+		instruction:TimedInstruction<Instruction,Time>
 	){
 		let mut context=PhysicsContext{state,data};
 		context.process_exhaustive(instruction.time);
@@ -980,12 +984,37 @@ impl PhysicsContext<'_>{
 	}
 }
 impl PhysicsData{
+	pub fn trace_ray(&self,ray:strafesnet_common::ray::Ray)->Option<ModelId>{
+		let (_time,convex_mesh_id)=self.bvh.sample_ray(&ray,Time::ZERO,Time::MAX/4,|&model,ray|{
+			let mesh=self.models.mesh(model);
+			// brute force trace every face
+			mesh.faces().filter_map(|face_id|{
+				let (n,d)=mesh.face_nd(face_id);
+				// trace ray onto face
+				// n.(o+d*t)==n.p
+				// n.o + n.d * t == n.p
+				// t == (n.p - n.o)/n.d
+				let nd=n.dot(ray.direction);
+				if nd.is_zero(){
+					return None;
+				}
+				let t=(d-n.dot(ray.origin))/nd;
+				// check if point of intersection is behind face edges
+				// *2 because average of 2 vertices
+				let p=ray.extrapolate(t)*2;
+				mesh.face_edges(face_id).iter().all(|&directed_edge_id|{
+					let edge_n=mesh.directed_edge_n(directed_edge_id);
+					let cross_n=edge_n.cross(n);
+					let &[vert0,vert1]=mesh.edge_verts(directed_edge_id.as_undirected()).as_ref();
+					cross_n.dot(p)<cross_n.dot(mesh.vert(vert0)+mesh.vert(vert1))
+				}).then(||t)
+			}).min().map(Into::into)
+		})?;
+		Some(convex_mesh_id.model_id.into())
+	}
 	/// use with caution, this is the only non-instruction way to mess with physics
 	pub fn generate_models(&mut self,map:&map::CompleteMap){
-		let mut modes=map.modes.clone();
-		for mode in &mut modes.modes{
-			mode.denormalize_data();
-		}
+		let mut modes=map.modes.clone().denormalize();
 		let mut used_contact_attributes=Vec::new();
 		let mut used_intersect_attributes=Vec::new();
 
@@ -1115,13 +1144,14 @@ impl PhysicsData{
 		self.bvh=bvh;
 		self.models=models;
 		self.modes=modes;
+		self.le_models=map.models.clone();
 		//hitbox_mesh is unchanged
 		println!("Physics Objects: {}",model_count);
 	}
 }
 
 	//this is the one who asks
-	fn next_instruction_internal(state:&PhysicsState,data:&PhysicsData,time_limit:Time)->Option<TimedInstruction<InternalInstruction,TimeInner>>{
+	fn next_instruction_internal(state:&PhysicsState,data:&PhysicsData,time_limit:Time)->Option<TimedInstruction<InternalInstruction,Time>>{
 		//JUST POLLING!!! NO MUTATION
 		let mut collector=instruction::InstructionCollector::new(time_limit);
 
@@ -1136,7 +1166,7 @@ impl PhysicsData{
 		//relative to moving platforms
 		//let relative_body=state.body.relative_to(&Body::ZERO);
 		let relative_body=&state.body;
-		data.bvh.the_tester(&aabb,&mut |&convex_mesh_id|{
+		data.bvh.sample_aabb(&aabb,&mut |&convex_mesh_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());
@@ -1198,7 +1228,7 @@ fn recalculate_touching(
 	aabb.inflate(hitbox_mesh.halfsize);
 	//relative to moving platforms
 	//let relative_body=state.body.relative_to(&Body::ZERO);
-	bvh.the_tester(&aabb,&mut |&convex_mesh_id|{
+	bvh.sample_aabb(&aabb,&mut |&convex_mesh_id|{
 		//no checks are needed because of the time limits.
 		let model_mesh=models.mesh(convex_mesh_id);
 		let minkowski=model_physics::MinkowskiMesh::minkowski_sum(model_mesh,hitbox_mesh.transformed_mesh());
@@ -1259,7 +1289,7 @@ fn set_velocity_cull(body:&mut Body,touching:&mut TouchingState,models:&PhysicsM
 	culled
 }
 fn set_velocity(body:&mut Body,touching:&TouchingState,models:&PhysicsModels,hitbox_mesh:&HitboxMesh,v:Planar64Vec3){
-	body.velocity=touching.constrain_velocity(models,hitbox_mesh,v);;
+	body.velocity=touching.constrain_velocity(models,hitbox_mesh,v);
 }
 fn set_acceleration_cull(body:&mut Body,touching:&mut TouchingState,models:&PhysicsModels,hitbox_mesh:&HitboxMesh,a:Planar64Vec3)->bool{
 	//This is not correct but is better than what I have
@@ -1651,7 +1681,7 @@ fn collision_end_intersect(
 		}
 	}
 }
-fn atomic_internal_instruction(state:&mut PhysicsState,data:&PhysicsData,ins:TimedInstruction<InternalInstruction,TimeInner>){
+fn atomic_internal_instruction(state:&mut PhysicsState,data:&PhysicsData,ins:TimedInstruction<InternalInstruction,Time>){
 	state.time=ins.time;
 	let (should_advance_body,goober_time)=match ins.instruction{
 		InternalInstruction::CollisionStart(_,dt)
@@ -1747,7 +1777,7 @@ fn atomic_internal_instruction(state:&mut PhysicsState,data:&PhysicsData,ins:Tim
 		}
 	}
 
-fn atomic_input_instruction(state:&mut PhysicsState,data:&PhysicsData,ins:TimedInstruction<Instruction,TimeInner>){
+fn atomic_input_instruction(state:&mut PhysicsState,data:&PhysicsData,ins:TimedInstruction<Instruction,Time>){
 	state.time=ins.time;
 	let should_advance_body=match ins.instruction{
 		//the body may as well be a quantum wave function
@@ -1814,14 +1844,18 @@ fn atomic_input_instruction(state:&mut PhysicsState,data:&PhysicsData,ins:TimedI
 		},
 		Instruction::Mode(ModeInstruction::Restart(mode_id))=>{
 			//teleport to mode start zone
+			let mut spawn_point=vec3::ZERO;
 			let mode=data.modes.get_mode(mode_id);
-			let spawn_point=mode.and_then(|mode|
+			if let Some(mode)=mode{
+				// set style
+				state.style=mode.get_style().clone();
 				//TODO: spawn at the bottom of the start zone plus the hitbox size
-				//TODO: set camera andles to face the same way as the start zone
-				data.models.get_model_transform(mode.get_start().into()).map(|transform|
-					transform.vertex.translation
-				)
-			).unwrap_or(vec3::ZERO);
+				//TODO: set camera angles to face the same way as the start zone
+				if let Some(transform)=data.models.get_model_transform(mode.get_start()){
+					// NOTE: this value may be 0,0,0 on source maps
+					spawn_point=transform.vertex.translation;
+				}
+			}
 			set_position(spawn_point,&mut state.move_state,&mut state.body,&mut state.touching,&mut state.run,&mut state.mode_state,mode,&data.models,&data.hitbox_mesh,&data.bvh,&state.style,&state.camera,&state.input_state,state.time);
 			set_velocity(&mut state.body,&state.touching,&data.models,&data.hitbox_mesh,vec3::ZERO);
 			state.set_move_state(data,MoveState::Air);
@@ -1831,6 +1865,9 @@ fn atomic_input_instruction(state:&mut PhysicsState,data:&PhysicsData,ins:TimedI
 		Instruction::Mode(ModeInstruction::Spawn(mode_id,stage_id))=>{
 			//spawn at a particular stage
 			if let Some(mode)=data.modes.get_mode(mode_id){
+				// set style
+				state.style=mode.get_style().clone();
+				// teleport to stage in mode
 				if let Some(stage)=mode.get_stage(stage_id){
 					let _=teleport_to_spawn(
 						stage.spawn(),

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,

engine/session/Cargo.toml

@@ -1,10 +1,10 @@
 [package]
 name = "strafesnet_session"
 version = "0.1.0"
-edition = "2021"
+edition = "2024"
 
 [dependencies]
-glam = "0.29.0"
+glam = "0.30.0"
 replace_with = "0.1.7"
 strafesnet_common = { path = "../../lib/common", registry = "strafesnet" }
 strafesnet_physics = { path = "../physics", registry = "strafesnet" }

engine/session/src/mouse_interpolator.rs

@@ -5,13 +5,13 @@ use strafesnet_common::physics::{
 	TimeInner as PhysicsTimeInner,
 	Time as PhysicsTime,
 };
-use strafesnet_common::session::{Time as SessionTime,TimeInner as SessionTimeInner};
+use strafesnet_common::session::Time as SessionTime;
 use strafesnet_common::instruction::{InstructionConsumer,InstructionEmitter,TimedInstruction};
 
-type TimedSelfInstruction=TimedInstruction<Instruction,PhysicsTimeInner>;
-type DoubleTimedSelfInstruction=TimedInstruction<TimedSelfInstruction,SessionTimeInner>;
+type TimedSelfInstruction=TimedInstruction<Instruction,PhysicsTime>;
+type DoubleTimedSelfInstruction=TimedInstruction<TimedSelfInstruction,SessionTime>;
 
-type TimedPhysicsInstruction=TimedInstruction<PhysicsInstruction,PhysicsTimeInner>;
+type TimedPhysicsInstruction=TimedInstruction<PhysicsInstruction,PhysicsTime>;
 
 const MOUSE_TIMEOUT:SessionTime=SessionTime::from_millis(10);
 
@@ -89,14 +89,14 @@ pub struct MouseInterpolator{
 // Maybe MouseInterpolator manipulation is better expressed using impls
 // and called from Instruction trait impls in session
 impl InstructionConsumer<TimedSelfInstruction> for MouseInterpolator{
-	type TimeInner=SessionTimeInner;
+	type Time=SessionTime;
 	fn process_instruction(&mut self,ins:DoubleTimedSelfInstruction){
 		self.push_unbuffered_input(ins.time,ins.instruction.time,ins.instruction.instruction.into())
 	}
 }
 impl InstructionEmitter<StepInstruction> for MouseInterpolator{
-	type TimeInner=SessionTimeInner;
-	fn next_instruction(&self,time_limit:SessionTime)->Option<TimedInstruction<StepInstruction,Self::TimeInner>>{
+	type Time=SessionTime;
+	fn next_instruction(&self,time_limit:SessionTime)->Option<TimedInstruction<StepInstruction,Self::Time>>{
 		self.buffered_instruction_with_timeout(time_limit)
 	}
 }
@@ -108,7 +108,7 @@ impl MouseInterpolator{
 			output:std::collections::VecDeque::new(),
 		}
 	}
-	fn push_mouse_and_flush_buffer(&mut self,ins:TimedInstruction<MouseInstruction,PhysicsTimeInner>){
+	fn push_mouse_and_flush_buffer(&mut self,ins:TimedInstruction<MouseInstruction,PhysicsTime>){
 		self.buffer.push_front(TimedInstruction{
 			time:ins.time,
 			instruction:BufferedInstruction::Mouse(ins.instruction).into(),
@@ -219,7 +219,7 @@ impl MouseInterpolator{
 			}
 		}
 	}
-	fn buffered_instruction_with_timeout(&self,time_limit:SessionTime)->Option<TimedInstruction<StepInstruction,SessionTimeInner>>{
+	fn buffered_instruction_with_timeout(&self,time_limit:SessionTime)->Option<TimedInstruction<StepInstruction,SessionTime>>{
 		match self.get_mouse_timedout_at(time_limit){
 			Some(timeout)=>Some(TimedInstruction{
 				time:timeout,
@@ -232,7 +232,7 @@ impl MouseInterpolator{
 			}),
 		}
 	}
-	pub fn pop_buffered_instruction(&mut self,ins:TimedInstruction<StepInstruction,PhysicsTimeInner>)->Option<TimedPhysicsInstruction>{
+	pub fn pop_buffered_instruction(&mut self,ins:TimedInstruction<StepInstruction,PhysicsTime>)->Option<TimedPhysicsInstruction>{
 		match ins.instruction{
 			StepInstruction::Pop=>(),
 			StepInstruction::Timeout=>self.timeout_mouse(ins.time),
@@ -244,6 +244,7 @@ impl MouseInterpolator{
 #[cfg(test)]
 mod test{
 	use super::*;
+	use strafesnet_common::session::TimeInner as SessionTimeInner;
 	#[test]
 	fn test(){
 		let mut interpolator=MouseInterpolator::new();

engine/session/src/session.rs

@@ -2,6 +2,7 @@ use std::collections::HashMap;
 
 use strafesnet_common::gameplay_modes::{ModeId,StageId};
 use strafesnet_common::instruction::{InstructionConsumer,InstructionEmitter,InstructionFeedback,TimedInstruction};
+use strafesnet_common::model::ModelId;
 // session represents the non-hardware state of the client.
 // Ideally it is a deterministic state which is atomically updated by instructions, same as the simulation state.
 use strafesnet_common::physics::{
@@ -61,6 +62,7 @@ pub struct FrameState{
 	pub body:physics::Body,
 	pub camera:physics::PhysicsCamera,
 	pub time:PhysicsTime,
+	pub debug_model:Option<strafesnet_common::model::ModelId>,
 }
 
 pub struct Simulation{
@@ -77,22 +79,23 @@ impl Simulation{
 			physics,
 		}
 	}
-	pub fn get_frame_state(&self,time:SessionTime)->FrameState{
+	pub fn get_frame_state(&self,time:SessionTime,debug_model:Option<ModelId>)->FrameState{
 		FrameState{
 			body:self.physics.camera_body(),
 			camera:self.physics.camera(),
 			time:self.timer.time(time),
+			debug_model,
 		}
 	}
 }
 
 #[derive(Default)]
 pub struct Recording{
-	instructions:Vec<TimedInstruction<PhysicsInputInstruction,PhysicsTimeInner>>,
+	instructions:Vec<TimedInstruction<PhysicsInputInstruction,PhysicsTime>>,
 }
 impl Recording{
 	pub fn new(
-		instructions:Vec<TimedInstruction<PhysicsInputInstruction,PhysicsTimeInner>>,
+		instructions:Vec<TimedInstruction<PhysicsInputInstruction,PhysicsTime>>,
 	)->Self{
 		Self{instructions}
 	}
@@ -161,6 +164,7 @@ pub struct Session{
 	recording:Recording,
 	//players:HashMap<PlayerId,Simulation>,
 	replays:HashMap<BotId,Replay>,
+	last_ray_hit:Option<strafesnet_common::model::ModelId>,
 }
 impl Session{
 	pub fn new(
@@ -177,6 +181,7 @@ impl Session{
 			view_state:ViewState::Play,
 			recording:Default::default(),
 			replays:HashMap::new(),
+			last_ray_hit:None,
 		}
 	}
 	fn clear_recording(&mut self){
@@ -188,12 +193,30 @@ impl Session{
 	}
 	pub fn get_frame_state(&self,time:SessionTime)->Option<FrameState>{
 		match &self.view_state{
-			ViewState::Play=>Some(self.simulation.get_frame_state(time)),
+			ViewState::Play=>Some(self.simulation.get_frame_state(time,self.last_ray_hit)),
 			ViewState::Replay(bot_id)=>self.replays.get(bot_id).map(|replay|
-				replay.simulation.get_frame_state(time)
+				replay.simulation.get_frame_state(time,None)
 			),
 		}
 	}
+	pub fn debug_raycast_print_model_id_if_changed(&mut self,time:SessionTime){
+		if let Some(frame_state)=self.get_frame_state(time){
+			let ray=strafesnet_common::ray::Ray{
+				origin:frame_state.body.extrapolated_position(self.simulation.timer.time(time)),
+				direction:-frame_state.camera.rotation().z_axis,
+			};
+			let model_id=self.geometry_shared.trace_ray(ray);
+			if model_id!=self.last_ray_hit{
+				println!("hit={model_id:?}");
+				self.last_ray_hit=model_id;
+				if let Some(model_id)=model_id{
+					if let Some(model)=self.geometry_shared.le_models.get(model_id.get() as usize){
+						println!("{}",model.debug_info);
+					}
+				}
+			}
+		}
+	}
 	pub fn user_settings(&self)->&UserSettings{
 		&self.user_settings
 	}
@@ -207,8 +230,8 @@ impl Session{
 // Session emits DoStep
 
 impl InstructionConsumer<Instruction<'_>> for Session{
-	type TimeInner=SessionTimeInner;
-	fn process_instruction(&mut self,ins:TimedInstruction<Instruction,Self::TimeInner>){
+	type Time=SessionTime;
+	fn process_instruction(&mut self,ins:TimedInstruction<Instruction,Self::Time>){
 		// repetitive procedure macro
 		macro_rules! run_mouse_interpolator_instruction{
 			($instruction:expr)=>{
@@ -425,8 +448,8 @@ impl InstructionConsumer<Instruction<'_>> for Session{
 	}
 }
 impl InstructionConsumer<StepInstruction> for Session{
-	type TimeInner=SessionTimeInner;
-	fn process_instruction(&mut self,ins:TimedInstruction<StepInstruction,Self::TimeInner>){
+	type Time=SessionTime;
+	fn process_instruction(&mut self,ins:TimedInstruction<StepInstruction,Self::Time>){
 		let time=self.simulation.timer.time(ins.time);
 		if let Some(instruction)=self.mouse_interpolator.pop_buffered_instruction(ins.set_time(time)){
 			//record
@@ -436,8 +459,8 @@ impl InstructionConsumer<StepInstruction> for Session{
 	}
 }
 impl InstructionEmitter<StepInstruction> for Session{
-	type TimeInner=SessionTimeInner;
-	fn next_instruction(&self,time_limit:SessionTime)->Option<TimedInstruction<StepInstruction,Self::TimeInner>>{
+	type Time=SessionTime;
+	fn next_instruction(&self,time_limit:SessionTime)->Option<TimedInstruction<StepInstruction,Self::Time>>{
 		self.mouse_interpolator.next_instruction(time_limit)
 	}
 }

engine/settings/Cargo.toml

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

integration-testing/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "integration-testing"
 version = "0.1.0"
-edition = "2021"
+edition = "2024"
 
 [dependencies]
 strafesnet_common = { path = "../lib/common", registry = "strafesnet" }

integration-testing/src/main.rs

@@ -1,5 +1,7 @@
 
-use std::{io::{Cursor,Read},path::Path};
+use std::io::Cursor;
+use std::path::Path;
+use std::time::Instant;
 
 use strafesnet_physics::physics::{PhysicsData,PhysicsState,PhysicsContext};
 
@@ -37,9 +39,7 @@ impl From<strafesnet_snf::bot::Error> for ReplayError{
 }
 
 fn read_entire_file(path:impl AsRef<Path>)->Result<Cursor<Vec<u8>>,std::io::Error>{
-	let mut file=std::fs::File::open(path)?;
-	let mut data=Vec::new();
-	file.read_to_end(&mut data)?;
+	let data=std::fs::read(path)?;
 	Ok(Cursor::new(data))
 }
 
@@ -72,7 +72,12 @@ enum DeterminismResult{
 	Deterministic,
 	NonDeterministic,
 }
-fn segment_determinism(bot:strafesnet_snf::bot::Segment,physics_data:&PhysicsData)->DeterminismResult{
+struct SegmentResult{
+	determinism:DeterminismResult,
+	ticks:u64,
+	nanoseconds:u64,
+}
+fn segment_determinism(bot:strafesnet_snf::bot::Segment,physics_data:&PhysicsData)->SegmentResult{
 	// create default physics state
 	let mut physics_deterministic=PhysicsState::default();
 	// create a second physics state
@@ -82,6 +87,9 @@ fn segment_determinism(bot:strafesnet_snf::bot::Segment,physics_data:&PhysicsDat
 	println!("simulating...");
 
 	let mut non_idle_count=0;
+	let instruction_count=bot.instructions.len();
+
+	let start=Instant::now();
 
 	for (i,ins) in bot.instructions.into_iter().enumerate(){
 		let state_deterministic=physics_deterministic.clone();
@@ -97,6 +105,7 @@ fn segment_determinism(bot:strafesnet_snf::bot::Segment,physics_data:&PhysicsDat
 				let b0=physics_deterministic.camera_body();
 				let b1=physics_filtered.camera_body();
 				if b0.position!=b1.position{
+					let nanoseconds=start.elapsed().as_nanos() as u64;
 					println!("desync at instruction #{}",i);
 					println!("non idle instructions completed={non_idle_count}");
 					println!("instruction #{i}={:?}",other);
@@ -104,11 +113,16 @@ fn segment_determinism(bot:strafesnet_snf::bot::Segment,physics_data:&PhysicsDat
 					println!("filtered state0:\n{state_filtered:?}");
 					println!("deterministic state1:\n{:?}",physics_deterministic);
 					println!("filtered state1:\n{:?}",physics_filtered);
-					return DeterminismResult::NonDeterministic;
+					return SegmentResult{
+						determinism:DeterminismResult::NonDeterministic,
+						ticks:1+i as u64+non_idle_count,
+						nanoseconds,
+					};
 				}
 			},
 		}
 	}
+	let nanoseconds=start.elapsed().as_nanos() as u64;
 	match physics_deterministic.get_finish_time(){
 		Some(time)=>println!("[with idle] finish time:{}",time),
 		None=>println!("[with idle] simulation did not end in finished state"),
@@ -117,9 +131,14 @@ fn segment_determinism(bot:strafesnet_snf::bot::Segment,physics_data:&PhysicsDat
 		Some(time)=>println!("[filtered] finish time:{}",time),
 		None=>println!("[filtered] simulation did not end in finished state"),
 	}
-	DeterminismResult::Deterministic
+	SegmentResult{
+		determinism:DeterminismResult::Deterministic,
+		ticks:instruction_count as u64+non_idle_count,
+		nanoseconds,
+	}
+
 }
-type ThreadResult=Result<Option<DeterminismResult>,ReplayError>;
+type ThreadResult=Result<Option<SegmentResult>,ReplayError>;
 fn read_and_run(file_path:std::path::PathBuf,physics_data:&PhysicsData)->ThreadResult{
 	let data=read_entire_file(file_path.as_path())?;
 	let bot=strafesnet_snf::read_bot(data)?.read_all()?;
@@ -198,10 +217,18 @@ fn test_determinism()->Result<(),ReplayError>{
 		invalid:u32,
 		error:u32,
 	}
+	let mut nanoseconds=0;
+	let mut ticks=0;
 	let Totals{deterministic,nondeterministic,invalid,error}=thread_results.into_iter().fold(Totals::default(),|mut totals,result|{
 		match result{
-			Ok(Some(DeterminismResult::Deterministic))=>totals.deterministic+=1,
-			Ok(Some(DeterminismResult::NonDeterministic))=>totals.nondeterministic+=1,
+			Ok(Some(segment_result))=>{
+				ticks+=segment_result.ticks;
+				nanoseconds+=segment_result.nanoseconds;
+				match segment_result.determinism{
+					DeterminismResult::Deterministic=>totals.deterministic+=1,
+					DeterminismResult::NonDeterministic=>totals.nondeterministic+=1,
+				}
+			},
 			Ok(None)=>totals.invalid+=1,
 			Err(_)=>totals.error+=1,
 		}
@@ -212,6 +239,7 @@ fn test_determinism()->Result<(),ReplayError>{
 	println!("nondeterministic={nondeterministic}");
 	println!("invalid={invalid}");
 	println!("error={error}");
+	println!("average ticks/s per core: {}",ticks*1_000_000_000/nanoseconds);
 
 	assert!(nondeterministic==0);
 	assert!(invalid==0);

lib/bsp_loader/Cargo.toml

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

lib/bsp_loader/src/brush.rs

@@ -75,13 +75,9 @@ fn planes_to_faces(face_list:std::collections::HashSet<Face>)->Result<Faces,Plan
 
 		let mut intersection=solve3(face0,face1,face2).ok_or(PlanesToFacesError::InitIntersection)?;
 
-		// repeatedly update face0, face1 until all faces form part of the convex solid
+		// repeatedly update face1, face2 until all faces form part of the convex solid
 		'find: loop{
-			if let Some(a)=detect_loop.checked_sub(1){
-				detect_loop=a;
-			}else{
-				return Err(PlanesToFacesError::InfiniteLoop1);
-			}
+			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
@@ -122,12 +118,10 @@ fn planes_to_faces(face_list:std::collections::HashSet<Face>)->Result<Faces,Plan
 			if core::ptr::eq(face2,new_face){
 				continue;
 			}
-			if let Some(new_intersection)=solve3(new_face,face1,face2){
-				// face0 does not occlude (or intersect) the new intersection
-				if (face0.dot.fix_2()/Planar64::ONE).lt_ratio(face0.normal.dot(new_intersection.num)/new_intersection.den){
-					// abort! reject face0 entirely
-					continue 'face;
-				}
+			// 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;
 			}
 		}
 
@@ -177,11 +171,7 @@ fn planes_to_faces(face_list:std::collections::HashSet<Face>)->Result<Faces,Plan
 			face2=new_face;
 			intersection=new_intersection;
 
-			if let Some(a)=detect_loop.checked_sub(1){
-				detect_loop=a;
-			}else{
-				return Err(PlanesToFacesError::InfiniteLoop2);
-			}
+			detect_loop=detect_loop.checked_sub(1).ok_or(PlanesToFacesError::InfiniteLoop2)?;
 		}
 
 		faces.push(face);
@@ -196,6 +186,7 @@ fn planes_to_faces(face_list:std::collections::HashSet<Face>)->Result<Faces,Plan
 	}
 }
 
+#[allow(dead_code)]
 #[derive(Debug)]
 pub enum BrushToMeshError{
 	SliceBrushSides,
@@ -212,24 +203,7 @@ impl std::fmt::Display for BrushToMeshError{
 }
 impl core::error::Error for BrushToMeshError{}
 
-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|{
-		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)?;
-
+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);
@@ -237,7 +211,7 @@ pub fn brush_to_mesh(bsp:&vbsp::Bsp,brush:&vbsp::Brush)->Result<model::Mesh,Brus
 	// normals are ignored by physics
 	let normal=mb.acquire_normal_id(integer::vec3::ZERO);
 
-	let polygon_list=faces.faces.into_iter().map(|face|{
+	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{
@@ -253,12 +227,54 @@ pub fn brush_to_mesh(bsp:&vbsp::Bsp,brush:&vbsp::Brush)->Result<model::Mesh,Brus
 	let physics_groups=vec![model::IndexedPhysicsGroup{
 		groups:vec![model::PolygonGroupId::new(0)],
 	}];
-	let graphics_groups=vec![model::IndexedGraphicsGroup{
-		render:model::RenderConfigId::new(0),
-		groups:vec![model::PolygonGroupId::new(0)],
-	}];
+	let graphics_groups=vec![];
 
-	Ok(mb.build(polygon_groups,graphics_groups,physics_groups))
+	mb.build(polygon_groups,graphics_groups,physics_groups)
+}
+
+pub fn brush_to_mesh(bsp:&vbsp::Bsp,brush:&vbsp::Brush)->Result<model::Mesh,BrushToMeshError>{
+	let brush_start_idx=brush.brush_side as usize;
+	let sides_range=brush_start_idx..brush_start_idx+brush.num_brush_sides as usize;
+	let sides=bsp.brush_sides.get(sides_range).ok_or(BrushToMeshError::SliceBrushSides)?;
+	let face_list=sides.iter().map(|side|{
+		// The so-called tumor brushes have TRIGGER bit set
+		// but also ignore visleaf hint and skip sides
+		const TUMOR:vbsp::TextureFlags=vbsp::TextureFlags::HINT.union(vbsp::TextureFlags::SKIP).union(vbsp::TextureFlags::TRIGGER);
+		if let Some(texture_info)=bsp.texture_info(side.texture_info as usize){
+			if texture_info.flags.intersects(TUMOR){
+				return None;
+			}
+		}
+		let plane=bsp.plane(side.plane as usize)?;
+		Some(Face{
+			normal:valve_transform_normal(plane.normal.into()),
+			dot:valve_transform_dist(plane.dist.into()),
+		})
+	}).collect::<Option<std::collections::HashSet<_>>>().ok_or(BrushToMeshError::MissingPlane)?;
+
+	if face_list.len()<4{
+		return Err(BrushToMeshError::InvalidFaceCount{count:face_list.len()});
+	}
+
+	let faces=planes_to_faces(face_list).map_err(BrushToMeshError::InvalidPlanes)?;
+
+	let mesh=faces_to_mesh(faces.faces);
+
+	Ok(mesh)
+}
+
+pub fn unit_cube()->model::Mesh{
+	let face_list=[
+		Face{normal:integer::vec3::X,dot:Planar64::ONE},
+		Face{normal:integer::vec3::Y,dot:Planar64::ONE},
+		Face{normal:integer::vec3::Z,dot:Planar64::ONE},
+		Face{normal:integer::vec3::NEG_X,dot:Planar64::ONE},
+		Face{normal:integer::vec3::NEG_Y,dot:Planar64::ONE},
+		Face{normal:integer::vec3::NEG_Z,dot:Planar64::ONE},
+	].into_iter().collect();
+	let faces=planes_to_faces(face_list).unwrap();
+	let mesh=faces_to_mesh(faces.faces);
+	mesh
 }
 
 #[cfg(test)]
@@ -275,6 +291,7 @@ mod test{
 			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]
@@ -289,6 +306,37 @@ mod test{
 			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,9 +1,13 @@
 use std::borrow::Cow;
+use std::collections::HashMap;
 
-use strafesnet_common::{map,model,integer,gameplay_attributes};
+use vbsp_entities_css::Entity;
+
+use strafesnet_common::{map,model,integer,gameplay_attributes as attr};
 use strafesnet_deferred_loader::deferred_loader::{MeshDeferredLoader,RenderConfigDeferredLoader};
 use strafesnet_deferred_loader::mesh::Meshes;
 use strafesnet_deferred_loader::texture::{RenderConfigs,Texture};
+use strafesnet_common::gameplay_modes::{self as modes,NormalizedMode,NormalizedModes,Mode,Stage};
 
 use crate::valve_transform;
 
@@ -32,39 +36,124 @@ fn ingest_vertex(
 	})
 }
 
+#[derive(Debug,Clone,Copy,Hash,Eq,PartialEq)]
+enum AddBrush{
+	Available(model::ModelId),
+	Deferred(model::ModelId),
+}
+
+fn add_brush<'a>(
+	mesh_deferred_loader:&mut MeshDeferredLoader<&'a str>,
+	world_models:&mut Vec<model::Model>,
+	prop_models:&mut Vec<model::Model>,
+	model:&'a str,
+	origin:vbsp::Vector,
+	rendercolor:vbsp::Color,
+	attributes:attr::CollisionAttributesId,
+	debug_info:model::DebugInfo,
+)->Option<AddBrush>{
+	let transform=integer::Planar64Affine3::from_translation(
+		valve_transform(origin.into())
+	);
+	let color=(glam::Vec3::from_array([
+		rendercolor.r as f32,
+		rendercolor.g as f32,
+		rendercolor.b as f32
+	])/255.0).extend(1.0);
+
+	match model.chars().next(){
+		// The first character of brush.model is '*'
+		Some('*')=>match model[1..].parse(){
+			Ok(mesh_id)=>{
+				let mesh=model::MeshId::new(mesh_id);
+				let model_id=model::ModelId::new(world_models.len() as u32);
+				world_models.push(
+					model::Model{mesh,attributes,transform,color,debug_info}
+				);
+				Some(AddBrush::Available(model_id))
+			},
+			Err(e)=>{
+				println!("Brush model int parse error: {e} model={model}");
+				None
+			},
+		},
+		_=>{
+			let mesh=mesh_deferred_loader.acquire_mesh_id(model);
+			let model_id=model::ModelId::new(prop_models.len() as u32);
+			prop_models.push(
+				model::Model{mesh,attributes,transform,color,debug_info}
+			);
+			Some(AddBrush::Deferred(model_id))
+		}
+	}
+}
+
 pub fn convert<'a>(
 	bsp:&'a crate::Bsp,
 	render_config_deferred_loader:&mut RenderConfigDeferredLoader<Cow<'a,str>>,
 	mesh_deferred_loader:&mut MeshDeferredLoader<&'a str>,
-)->PartialMap1{
+)->PartialMap1<'a>{
 	let bsp=bsp.as_ref();
 	//figure out real attributes later
-	let mut unique_attributes=Vec::new();
-	unique_attributes.push(gameplay_attributes::CollisionAttributes::Decoration);
-	unique_attributes.push(gameplay_attributes::CollisionAttributes::contact_default());
-	const ATTRIBUTE_DECORATION:gameplay_attributes::CollisionAttributesId=gameplay_attributes::CollisionAttributesId::new(0);
-	const ATTRIBUTE_CONTACT_DEFAULT:gameplay_attributes::CollisionAttributesId=gameplay_attributes::CollisionAttributesId::new(1);
+	let unique_attributes=vec![
+		attr::CollisionAttributes::Decoration,
+		attr::CollisionAttributes::contact_default(),
+		attr::CollisionAttributes::intersect_default(),
+		// ladder
+		attr::CollisionAttributes::Contact(
+			attr::ContactAttributes{
+				contacting:attr::ContactingAttributes{
+					contact_behaviour:Some(attr::ContactingBehaviour::Ladder(
+						attr::ContactingLadder{sticky:true}
+					))
+				},
+				general:attr::GeneralAttributes::default(),
+			}
+		),
+		// water
+		attr::CollisionAttributes::Intersect(
+			attr::IntersectAttributes{
+				intersecting:attr::IntersectingAttributes{
+					water:Some(attr::IntersectingWater{
+						viscosity:integer::Planar64::ONE,
+						density:integer::Planar64::ONE,
+						velocity:integer::vec3::ZERO,
+					}),
+				},
+				general:attr::GeneralAttributes::default(),
+			}
+		),
+	];
+	const ATTRIBUTE_DECORATION:attr::CollisionAttributesId=attr::CollisionAttributesId::new(0);
+	const ATTRIBUTE_CONTACT_DEFAULT:attr::CollisionAttributesId=attr::CollisionAttributesId::new(1);
+	const ATTRIBUTE_INTERSECT_DEFAULT:attr::CollisionAttributesId=attr::CollisionAttributesId::new(2);
+	const ATTRIBUTE_LADDER_DEFAULT:attr::CollisionAttributesId=attr::CollisionAttributesId::new(3);
+	const ATTRIBUTE_WATER_DEFAULT:attr::CollisionAttributesId=attr::CollisionAttributesId::new(4);
 
 	//declare all prop models to Loader
-	let prop_models=Vec::new();
-	// let 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:ATTRIBUTE_DECORATION,
-	// 		transform:integer::Planar64Affine3::new(
-	// 			integer::mat3::try_from_f32_array_2d((
-	// 				glam::Mat3A::from_diagonal(glam::Vec3::splat(placement.scale))
-	// 				//TODO: figure this out
-	// 				*glam::Mat3A::from_quat(glam::Quat::from_array(placement.rotation.into()))
-	// 			).to_cols_array_2d()).unwrap(),
-	// 			valve_transform(placement.origin.into()),
-	// 		),
-	// 		color:glam::Vec4::ONE,
-	// 	}
-	// }).collect();
+	let mut prop_models=bsp.static_props().map(|prop|{
+		const DEG_TO_RAD:f32=std::f32::consts::TAU/360.0;
+		//get or create mesh_id
+		let mesh_id=mesh_deferred_loader.acquire_mesh_id(prop.model());
+		model::Model{
+			mesh:mesh_id,
+			attributes:ATTRIBUTE_DECORATION,
+			transform:integer::Planar64Affine3::new(
+				integer::mat3::try_from_f32_array_2d(
+					//TODO: figure this out
+					glam::Mat3A::from_euler(
+						glam::EulerRot::XYZ,
+						prop.angles.pitch*DEG_TO_RAD,
+						prop.angles.yaw*DEG_TO_RAD,
+						prop.angles.roll*DEG_TO_RAD
+					).to_cols_array_2d()
+				).unwrap(),
+				valve_transform(prop.origin.into()),
+			),
+			color:glam::Vec4::ONE,
+			debug_info:model::DebugInfo::Prop,
+		}
+	}).collect();
 
 	//TODO: make the main map one single mesh with a bunch of different physics groups and graphics groups
 
@@ -75,7 +164,7 @@ pub fn convert<'a>(
 
 		let color=mb.acquire_color_id(glam::Vec4::ONE);
 		let mut graphics_groups=Vec::new();
-		//let mut render_id_to_graphics_group_id=std::collections::HashMap::new();
+		let mut render_id_to_graphics_group_id=HashMap::new();
 		let polygon_groups=world_model.faces().enumerate().map(|(polygon_group_id,face)|{
 			let polygon_group_id=model::PolygonGroupId::new(polygon_group_id as u32);
 			let face_texture=face.texture();
@@ -105,120 +194,382 @@ pub fn convert<'a>(
 				//a render config for it, and then returns the id to that render config
 				let render_id=render_config_deferred_loader.acquire_render_config_id(Some(Cow::Borrowed(face_texture_data.name())));
 				//deduplicate graphics groups by render id
-				// let graphics_group_id=*render_id_to_graphics_group_id.entry(render_id).or_insert_with(||{
-				// 	let graphics_group_id=graphics_groups.len();
-				// 	graphics_groups.push(model::IndexedGraphicsGroup{
-				// 		render:render_id,
-				// 		groups:vec![],
-				// 	});
-				// 	graphics_group_id
-				// });
-				// graphics_groups[graphics_group_id].groups.push(polygon_group_id);
+				let graphics_group_id=*render_id_to_graphics_group_id.entry(render_id).or_insert_with(||{
+					let graphics_group_id=graphics_groups.len();
+					graphics_groups.push(model::IndexedGraphicsGroup{
+						render:render_id,
+						groups:vec![],
+					});
+					graphics_group_id
+				});
+				graphics_groups[graphics_group_id].groups.push(polygon_group_id);
 			}
 			model::PolygonGroup::PolygonList(model::PolygonList::new(polygon_list))
 		}).collect();
 
-		mb.build(polygon_groups,graphics_groups,vec![])
+		let physics_groups=vec![model::IndexedPhysicsGroup{
+			groups:(0..world_model.face_count as u32).map(model::PolygonGroupId::new).collect(),
+		}];
+
+		mb.build(polygon_groups,graphics_groups,physics_groups)
 	}).collect();
 
-	let brush_mesh_start_idx=world_meshes.len();
+	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,
+		debug_info:model::DebugInfo::World,
+	});
+
+	// THE CUBE OF DESTINY
+	let destination_mesh_id=model::MeshId::new(world_meshes.len() as u32);
+	world_meshes.push(crate::brush::unit_cube());
+
+	let mut teleports=HashMap::new();
+	let mut teleport_destinations=HashMap::new();
+
+	const WHITE:vbsp::Color=vbsp::Color{r:255,g:255,b:255};
+	const ENTITY_ATTRIBUTE:attr::CollisionAttributesId=ATTRIBUTE_CONTACT_DEFAULT;
+	const ENTITY_TRIGGER_ATTRIBUTE:attr::CollisionAttributesId=ATTRIBUTE_INTERSECT_DEFAULT;
+	for raw_ent in &bsp.entities{
+		let debug_info=match model::EntityInfo::new(raw_ent.properties()){
+			Ok(entity_info)=>model::DebugInfo::Entity(entity_info),
+			Err(_)=>{
+				println!("EntityInfoError");
+				model::DebugInfo::World
+			},
+		};
+		macro_rules! ent_brush_default{
+			($entity:ident)=>{
+				{add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,$entity.model,$entity.origin,$entity.rendercolor,ENTITY_ATTRIBUTE,debug_info);}
+			};
+		}	macro_rules! ent_brush_prop{
+			($entity:ident)=>{
+				{add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,$entity.model,$entity.origin,WHITE,ENTITY_ATTRIBUTE,debug_info);}
+			};
+		}
+		macro_rules! ent_brush_trigger{
+			($entity:ident)=>{
+				{add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,$entity.model,$entity.origin,WHITE,ENTITY_TRIGGER_ATTRIBUTE,debug_info);}
+			};
+		}
+		match raw_ent.parse(){
+			Ok(Entity::AmbientGeneric(_ambient_generic))=>(),
+			Ok(Entity::Cycler(brush))=>ent_brush_default!(brush),
+			Ok(Entity::EnvBeam(_env_beam))=>(),
+			Ok(Entity::EnvBubbles(_env_bubbles))=>(),
+			Ok(Entity::EnvDetailController(_env_detail_controller))=>(),
+			Ok(Entity::EnvEmbers(_env_embers))=>(),
+			Ok(Entity::EnvEntityMaker(_env_entity_maker))=>(),
+			Ok(Entity::EnvExplosion(_env_explosion))=>(),
+			Ok(Entity::EnvFade(_env_fade))=>(),
+			Ok(Entity::EnvFire(_env_fire))=>(),
+			Ok(Entity::EnvFireTrail(_env_fire_trail))=>(),
+			Ok(Entity::EnvFiresource(_env_firesource))=>(),
+			Ok(Entity::EnvFogController(_env_fog_controller))=>(),
+			Ok(Entity::EnvHudhint(_env_hudhint))=>(),
+			Ok(Entity::EnvLaser(_env_laser))=>(),
+			Ok(Entity::EnvLightglow(_env_lightglow))=>(),
+			Ok(Entity::EnvPhysexplosion(_env_physexplosion))=>(),
+			Ok(Entity::EnvProjectedtexture(_env_projectedtexture))=>(),
+			Ok(Entity::EnvScreenoverlay(_env_screenoverlay))=>(),
+			Ok(Entity::EnvShake(_env_shake))=>(),
+			Ok(Entity::EnvShooter(_env_shooter))=>(),
+			Ok(Entity::EnvSmokestack(_env_smokestack))=>(),
+			Ok(Entity::EnvSoundscape(_env_soundscape))=>(),
+			Ok(Entity::EnvSoundscapeProxy(_env_soundscape_proxy))=>(),
+			Ok(Entity::EnvSoundscapeTriggerable(_env_soundscape_triggerable))=>(),
+			Ok(Entity::EnvSpark(_env_spark))=>(),
+			Ok(Entity::EnvSprite(brush))=>ent_brush_default!(brush),
+			Ok(Entity::EnvSpritetrail(_env_spritetrail))=>(),
+			Ok(Entity::EnvSteam(_env_steam))=>(),
+			Ok(Entity::EnvSun(_env_sun))=>(),
+			Ok(Entity::EnvTonemapController(_env_tonemap_controller))=>(),
+			Ok(Entity::EnvWind(_env_wind))=>(),
+			// trigger_teleport.filtername probably has to do with one of these
+			Ok(Entity::FilterActivatorClass(_filter_activator_class))=>(),
+			Ok(Entity::FilterActivatorName(_filter_activator_name))=>(),
+			Ok(Entity::FilterDamageType(_filter_damage_type))=>(),
+			Ok(Entity::FilterMulti(_filter_multi))=>(),
+			Ok(Entity::FuncAreaportal(_func_areaportal))=>(),
+			Ok(Entity::FuncAreaportalwindow(_func_areaportalwindow))=>(),
+			Ok(Entity::FuncBombTarget(_func_bomb_target))=>(),
+			Ok(Entity::FuncBreakable(brush))=>ent_brush_default!(brush),
+			Ok(Entity::FuncBreakableSurf(_func_breakable_surf))=>(),
+			Ok(Entity::FuncBrush(brush))=>ent_brush_default!(brush),
+			Ok(Entity::FuncButton(brush))=>ent_brush_default!(brush),
+			Ok(Entity::FuncBuyzone(_func_buyzone))=>(),
+			Ok(Entity::FuncClipVphysics(_func_clip_vphysics))=>(),
+			Ok(Entity::FuncConveyor(_func_conveyor))=>(),
+			// FuncDoor is Platform
+			Ok(Entity::FuncDoor(brush))=>ent_brush_default!(brush),
+			Ok(Entity::FuncDoorRotating(brush))=>ent_brush_default!(brush),
+			Ok(Entity::FuncDustcloud(_func_dustcloud))=>(),
+			Ok(Entity::FuncDustmotes(_func_dustmotes))=>(),
+			Ok(Entity::FuncFishPool(_func_fish_pool))=>(),
+			Ok(Entity::FuncFootstepControl(_func_footstep_control))=>(),
+			Ok(Entity::FuncHostageRescue(_func_hostage_rescue))=>(),
+			Ok(Entity::FuncIllusionary(brush))=>{add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin,brush.rendercolor,ATTRIBUTE_DECORATION,debug_info);},
+			Ok(Entity::FuncLod(_func_lod))=>(),
+			Ok(Entity::FuncMonitor(brush))=>ent_brush_default!(brush),
+			Ok(Entity::FuncMovelinear(brush))=>ent_brush_default!(brush),
+			Ok(Entity::FuncOccluder(_func_occluder))=>(),
+			Ok(Entity::FuncPhysbox(brush))=>ent_brush_default!(brush),
+			Ok(Entity::FuncPhysboxMultiplayer(brush))=>ent_brush_default!(brush),
+			Ok(Entity::FuncPrecipitation(_func_precipitation))=>(),
+			Ok(Entity::FuncRotButton(brush))=>ent_brush_prop!(brush),
+			Ok(Entity::FuncRotating(brush))=>ent_brush_default!(brush),
+			Ok(Entity::FuncSmokevolume(_func_smokevolume))=>(),
+			Ok(Entity::FuncTracktrain(brush))=>ent_brush_default!(brush),
+			Ok(Entity::FuncTrain(brush))=>ent_brush_default!(brush),
+			Ok(Entity::FuncWall(brush))=>{add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin.unwrap_or_default(),brush.rendercolor,ENTITY_ATTRIBUTE,debug_info);},
+			Ok(Entity::FuncWallToggle(brush))=>{add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin.unwrap_or_default(),brush.rendercolor,ENTITY_ATTRIBUTE,debug_info);},
+			Ok(Entity::FuncWaterAnalog(brush))=>{add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model,brush.origin,brush.rendercolor.unwrap_or(WHITE),ENTITY_ATTRIBUTE,debug_info);},
+			Ok(Entity::GamePlayerEquip(_game_player_equip))=>(),
+			Ok(Entity::GameText(_game_text))=>(),
+			Ok(Entity::GameUi(_game_ui))=>(),
+			Ok(Entity::GameWeaponManager(_game_weapon_manager))=>(),
+			Ok(Entity::HostageEntity(_hostage_entity))=>(),
+			Ok(Entity::InfoCameraLink(_info_camera_link))=>(),
+			Ok(Entity::InfoLadder(_info_ladder))=>(),
+			Ok(Entity::InfoLightingRelative(_info_lighting_relative))=>(),
+			Ok(Entity::InfoMapParameters(_info_map_parameters))=>(),
+			Ok(Entity::InfoNode(_info_node))=>(),
+			Ok(Entity::InfoNodeHint(_info_node_hint))=>(),
+			Ok(Entity::InfoParticleSystem(_info_particle_system))=>(),
+			Ok(Entity::InfoPlayerCounterterrorist(spawn))=>found_spawn=Some(spawn.origin),
+			Ok(Entity::InfoPlayerLogo(_info_player_logo))=>(),
+			Ok(Entity::InfoPlayerStart(_info_player_start))=>(),
+			Ok(Entity::InfoPlayerTerrorist(spawn))=>found_spawn=Some(spawn.origin),
+			Ok(Entity::InfoTarget(_info_target))=>(),
+			// InfoTeleportDestination is Spawn#
+			Ok(Entity::InfoTeleportDestination(info_teleport_destination))=>if let Some(target)=info_teleport_destination.targetname{
+				// create a new model
+				let model_id=model::ModelId::new(world_models.len() as u32);
+				world_models.push(model::Model{
+					mesh:destination_mesh_id,
+					attributes:ATTRIBUTE_INTERSECT_DEFAULT,
+					transform:integer::Planar64Affine3::from_translation(valve_transform(info_teleport_destination.origin.into())),
+					color:glam::Vec4::W,
+					debug_info,
+				});
+				teleport_destinations.insert(target,model_id);
+			},
+			Ok(Entity::Infodecal(_infodecal))=>(),
+			Ok(Entity::KeyframeRope(_keyframe_rope))=>(),
+			Ok(Entity::Light(_light))=>(),
+			Ok(Entity::LightEnvironment(_light_environment))=>(),
+			Ok(Entity::LightSpot(_light_spot))=>(),
+			Ok(Entity::LogicAuto(_logic_auto))=>(),
+			Ok(Entity::LogicBranch(_logic_branch))=>(),
+			Ok(Entity::LogicCase(_logic_case))=>(),
+			Ok(Entity::LogicCompare(_logic_compare))=>(),
+			Ok(Entity::LogicMeasureMovement(_logic_measure_movement))=>(),
+			Ok(Entity::LogicRelay(_logic_relay))=>(),
+			Ok(Entity::LogicTimer(_logic_timer))=>(),
+			Ok(Entity::MathCounter(_math_counter))=>(),
+			Ok(Entity::MoveRope(_move_rope))=>(),
+			Ok(Entity::PathTrack(_path_track))=>(),
+			Ok(Entity::PhysBallsocket(_phys_ballsocket))=>(),
+			Ok(Entity::PhysConstraint(_phys_constraint))=>(),
+			Ok(Entity::PhysConstraintsystem(_phys_constraintsystem))=>(),
+			Ok(Entity::PhysHinge(_phys_hinge))=>(),
+			Ok(Entity::PhysKeepupright(_phys_keepupright))=>(),
+			Ok(Entity::PhysLengthconstraint(_phys_lengthconstraint))=>(),
+			Ok(Entity::PhysPulleyconstraint(_phys_pulleyconstraint))=>(),
+			Ok(Entity::PhysRagdollconstraint(_phys_ragdollconstraint))=>(),
+			Ok(Entity::PhysRagdollmagnet(_phys_ragdollmagnet))=>(),
+			Ok(Entity::PhysThruster(_phys_thruster))=>(),
+			Ok(Entity::PhysTorque(_phys_torque))=>(),
+			Ok(Entity::PlayerSpeedmod(_player_speedmod))=>(),
+			Ok(Entity::PlayerWeaponstrip(_player_weaponstrip))=>(),
+			Ok(Entity::PointCamera(_point_camera))=>(),
+			Ok(Entity::PointClientcommand(_point_clientcommand))=>(),
+			Ok(Entity::PointDevshotCamera(_point_devshot_camera))=>(),
+			Ok(Entity::PointServercommand(_point_servercommand))=>(),
+			Ok(Entity::PointSpotlight(_point_spotlight))=>(),
+			Ok(Entity::PointSurroundtest(_point_surroundtest))=>(),
+			Ok(Entity::PointTemplate(_point_template))=>(),
+			Ok(Entity::PointTesla(_point_tesla))=>(),
+			Ok(Entity::PointViewcontrol(_point_viewcontrol))=>(),
+			Ok(Entity::PropDoorRotating(brush))=>ent_brush_prop!(brush),
+			Ok(Entity::PropDynamic(brush))=>ent_brush_prop!(brush),
+			Ok(Entity::PropDynamicOverride(brush))=>ent_brush_prop!(brush),
+			Ok(Entity::PropPhysics(brush))=>ent_brush_prop!(brush),
+			Ok(Entity::PropPhysicsMultiplayer(brush))=>ent_brush_prop!(brush),
+			Ok(Entity::PropPhysicsOverride(brush))=>ent_brush_prop!(brush),
+			Ok(Entity::PropRagdoll(brush))=>ent_brush_prop!(brush),
+			Ok(Entity::ShadowControl(_shadow_control))=>(),
+			Ok(Entity::SkyCamera(_sky_camera))=>(),
+			Ok(Entity::TriggerGravity(brush))=>ent_brush_trigger!(brush),
+			Ok(Entity::TriggerHurt(brush))=>ent_brush_trigger!(brush),
+			Ok(Entity::TriggerLook(brush))=>ent_brush_trigger!(brush),
+			Ok(Entity::TriggerMultiple(brush))=>{add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model.unwrap_or_default(),brush.origin,WHITE,ENTITY_TRIGGER_ATTRIBUTE,debug_info);},
+			Ok(Entity::TriggerOnce(brush))=>ent_brush_trigger!(brush),
+			Ok(Entity::TriggerProximity(brush))=>ent_brush_trigger!(brush),
+			// TriggerPush is booster
+			Ok(Entity::TriggerPush(brush))=>ent_brush_trigger!(brush),
+			Ok(Entity::TriggerSoundscape(brush))=>ent_brush_trigger!(brush),
+			// TriggerTeleport is Trigger#
+			Ok(Entity::TriggerTeleport(brush))=>{
+				if let (Some(model_id),Some(target))=(add_brush(mesh_deferred_loader,&mut world_models,&mut prop_models,brush.model.unwrap_or_default(),brush.origin,WHITE,ENTITY_TRIGGER_ATTRIBUTE,debug_info),brush.target){
+					teleports.insert(model_id,target);
+				}
+			},
+			Ok(Entity::TriggerVphysicsMotion(brush))=>ent_brush_trigger!(brush),
+			Ok(Entity::TriggerWind(brush))=>ent_brush_trigger!(brush),
+			Ok(Entity::WaterLodControl(_water_lod_control))=>(),
+			Ok(Entity::WeaponAk47(_weapon_ak47))=>(),
+			Ok(Entity::WeaponAwp(_weapon_awp))=>(),
+			Ok(Entity::WeaponDeagle(_weapon_deagle))=>(),
+			Ok(Entity::WeaponElite(_weapon_elite))=>(),
+			Ok(Entity::WeaponFamas(_weapon_famas))=>(),
+			Ok(Entity::WeaponFiveseven(_weapon_fiveseven))=>(),
+			Ok(Entity::WeaponFlashbang(_weapon_flashbang))=>(),
+			Ok(Entity::WeaponG3sg1(_weapon_g3sg1))=>(),
+			Ok(Entity::WeaponGlock(_weapon_glock))=>(),
+			Ok(Entity::WeaponHegrenade(_weapon_hegrenade))=>(),
+			Ok(Entity::WeaponKnife(_weapon_knife))=>(),
+			Ok(Entity::WeaponM249(_weapon_m249))=>(),
+			Ok(Entity::WeaponM3(_weapon_m3))=>(),
+			Ok(Entity::WeaponM4a1(_weapon_m4a1))=>(),
+			Ok(Entity::WeaponMac10(_weapon_mac10))=>(),
+			Ok(Entity::WeaponP228(_weapon_p228))=>(),
+			Ok(Entity::WeaponP90(_weapon_p90))=>(),
+			Ok(Entity::WeaponScout(_weapon_scout))=>(),
+			Ok(Entity::WeaponSg550(_weapon_sg550))=>(),
+			Ok(Entity::WeaponSmokegrenade(_weapon_smokegrenade))=>(),
+			Ok(Entity::WeaponTmp(_weapon_tmp))=>(),
+			Ok(Entity::WeaponUmp45(_weapon_ump45))=>(),
+			Ok(Entity::WeaponUsp(_weapon_usp))=>(),
+			Ok(Entity::WeaponXm1014(_weapon_xm1014))=>(),
+			Ok(Entity::Worldspawn(_worldspawn))=>(),
+			Err(e)=>{
+				println!("Bsp Entity parse error: {e}");
+			},
+			_=>(),
+		}
+	}
+
+	// physics models
 	for brush in &bsp.brushes{
+		const RELEVANT:vbsp::BrushFlags=
+			vbsp::BrushFlags::SOLID
+			.union(vbsp::BrushFlags::PLAYERCLIP)
+			.union(vbsp::BrushFlags::WATER)
+			.union(vbsp::BrushFlags::MOVEABLE)
+			.union(vbsp::BrushFlags::LADDER);
+		if !brush.flags.intersects(RELEVANT){
+			continue;
+		}
+		let is_ladder=brush.flags.contains(vbsp::BrushFlags::LADDER);
+		let is_water=brush.flags.contains(vbsp::BrushFlags::WATER);
+		let attributes=match (is_ladder,is_water){
+			(true,false)=>ATTRIBUTE_LADDER_DEFAULT,
+			(false,true)=>ATTRIBUTE_WATER_DEFAULT,
+			(false,false)=>ATTRIBUTE_CONTACT_DEFAULT,
+			(true,true)=>{
+				// water ladder? wtf
+				println!("brush is a water ladder o_o defaulting to ladder");
+				ATTRIBUTE_LADDER_DEFAULT
+			}
+		};
 		let mesh_result=crate::brush::brush_to_mesh(bsp,brush);
 		match mesh_result{
-			Ok(mesh)=>world_meshes.push(mesh),
+			Ok(mesh)=>{
+				let mesh_id=model::MeshId::new(world_meshes.len() as u32);
+				world_meshes.push(mesh);
+				let sides={
+					let brush_start_idx=brush.brush_side as usize;
+					let sides_range=brush_start_idx..brush_start_idx+brush.num_brush_sides as usize;
+					bsp.brush_sides[sides_range].iter().filter_map(|side|bsp.texture_info(side.texture_info as usize)).map(|texture_info|{
+						texture_info.flags
+					}).collect()
+				};
+				world_models.push(model::Model{
+					mesh:mesh_id,
+					attributes,
+					transform:integer::Planar64Affine3::new(
+						integer::mat3::identity(),
+						integer::vec3::ZERO,
+					),
+					color:glam::Vec4::ONE,
+					debug_info:model::DebugInfo::Brush(model::BrushInfo{flags:brush.flags,sides}),
+				});
+			},
 			Err(e)=>println!("Brush mesh error: {e}"),
 		}
 	}
-	println!("How many brush: {}",bsp.brushes.len());
-	println!("Generated brush models: {}",world_meshes.len()-brush_mesh_start_idx);
 
-	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:ATTRIBUTE_DECORATION,
-		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),
-	}).chain(
-		// physics models
-		(brush_mesh_start_idx..world_meshes.len()).map(|mesh_id|model::Model{
-			mesh:model::MeshId::new(mesh_id as u32),
-			attributes:ATTRIBUTE_CONTACT_DEFAULT,
-			transform:integer::Planar64Affine3::new(
-				integer::mat3::identity(),
-				integer::vec3::ZERO,
-			),
-			color:glam::Vec4::ONE,
-		})
-	).collect();
+	let first_stage=found_spawn.map(|spawn_point|{
+		// create a new model
+		let model_id=model::ModelId::new(world_models.len() as u32);
+		world_models.push(model::Model{
+			mesh:destination_mesh_id,
+			attributes:ATTRIBUTE_INTERSECT_DEFAULT,
+			transform:integer::Planar64Affine3::from_translation(valve_transform(spawn_point.into())),
+			color:glam::Vec4::W,
+			debug_info:model::DebugInfo::World,
+		});
+
+		Stage::empty(model_id)
+	});
 
 	PartialMap1{
 		attributes:unique_attributes,
 		world_meshes,
 		prop_models,
 		world_models,
-		modes:strafesnet_common::gameplay_modes::Modes::new(Vec::new()),
+		first_stage,
+		teleports,
+		teleport_destinations,
 	}
 }
 
 //partially constructed map types
-pub struct PartialMap1{
-	attributes:Vec<strafesnet_common::gameplay_attributes::CollisionAttributes>,
+pub struct PartialMap1<'a>{
+	attributes:Vec<attr::CollisionAttributes>,
 	prop_models:Vec<model::Model>,
 	world_meshes:Vec<model::Mesh>,
 	world_models:Vec<model::Model>,
-	modes:strafesnet_common::gameplay_modes::Modes,
+	first_stage:Option<Stage>,
+	teleports:HashMap<AddBrush,&'a str>,
+	teleport_destinations:HashMap<&'a str,model::ModelId>,
 }
-impl PartialMap1{
-	pub fn add_prop_meshes<'a>(
+impl<'a> PartialMap1<'a>{
+	pub fn add_prop_meshes(
 		self,
 		prop_meshes:Meshes,
-	)->PartialMap2{
+	)->PartialMap2<'a>{
 		PartialMap2{
 			attributes:self.attributes,
 			prop_meshes:prop_meshes.consume().collect(),
 			prop_models:self.prop_models,
 			world_meshes:self.world_meshes,
 			world_models:self.world_models,
-			modes:self.modes,
+			first_stage:self.first_stage,
+			teleports:self.teleports,
+			teleport_destinations:self.teleport_destinations,
 		}
 	}
 }
-pub struct PartialMap2{
-	attributes:Vec<strafesnet_common::gameplay_attributes::CollisionAttributes>,
+pub struct PartialMap2<'a>{
+	attributes:Vec<attr::CollisionAttributes>,
 	prop_meshes:Vec<(model::MeshId,model::Mesh)>,
 	prop_models:Vec<model::Model>,
 	world_meshes:Vec<model::Mesh>,
 	world_models:Vec<model::Model>,
-	modes:strafesnet_common::gameplay_modes::Modes,
+	first_stage:Option<Stage>,
+	teleports:HashMap<AddBrush,&'a str>,
+	teleport_destinations:HashMap<&'a str,model::ModelId>,
 }
-impl PartialMap2{
+impl PartialMap2<'_>{
 	pub fn add_render_configs_and_textures(
 		mut self,
 		render_configs:RenderConfigs,
@@ -226,22 +577,70 @@ impl PartialMap2{
 		//merge mesh and model lists, flatten and remap all ids
 		let mesh_id_offset=self.world_meshes.len();
 		println!("prop_meshes.len()={}",self.prop_meshes.len());
-		let (mut prop_meshes,prop_mesh_id_map):(Vec<model::Mesh>,std::collections::HashMap<model::MeshId,model::MeshId>)
+		let (mut prop_meshes,prop_mesh_id_map):(Vec<model::Mesh>,HashMap<model::MeshId,model::MeshId>)
 		=self.prop_meshes.into_iter().enumerate().map(|(new_mesh_id,(old_mesh_id,mesh))|{
 			(mesh,(old_mesh_id,model::MeshId::new((mesh_id_offset+new_mesh_id) as u32)))
 		}).unzip();
 		self.world_meshes.append(&mut prop_meshes);
-		//there is no modes or runtime behaviour with references to the model ids currently
-		//so just relentlessly cull them if the mesh is missing
-		self.world_models.extend(self.prop_models.into_iter().filter_map(|mut model|
+
+		// cull models with a missing mesh
+		let model_id_offset=self.world_models.len();
+		let mut prop_model_id_to_final_model_id=HashMap::new();
+		self.world_models.extend(self.prop_models.into_iter().enumerate().filter_map(|(prop_model_id,mut model)|
 			prop_mesh_id_map.get(&model.mesh).map(|&new_mesh_id|{
 				model.mesh=new_mesh_id;
-				model
+				(prop_model_id,model)
 			})
+		).enumerate().map(|(model_id,(prop_model_id,model))|{
+			prop_model_id_to_final_model_id.insert(
+				model::ModelId::new(prop_model_id as u32),
+				model::ModelId::new((model_id_offset+model_id) as u32),
+			);
+			model
+		}));
+
+		//calculate teleports
+		let first_stage_spawn_model_id=self.first_stage.as_ref().unwrap().spawn();
+		let mut teleport_destinations=HashMap::new();
+		let stages={
+			let mut stages=self.teleport_destinations.iter().map(|(&target,&model_id)|(target,model_id)).collect::<Vec<_>>();
+			stages.sort_by_key(|&(target,_)|target);
+			self.first_stage.into_iter().chain(
+				stages.into_iter().enumerate().map(|(stage_id,(target,model_id))|{
+					let stage_id=modes::StageId::new(1+stage_id as u32);
+					teleport_destinations.insert(target,stage_id);
+					Stage::empty(model_id)
+				})
+			).collect()
+		};
+		let mut elements=HashMap::new();
+		for (teleport_model,target) in self.teleports{
+			if let Some(&stage_id)=teleport_destinations.get(target){
+				let model_id=match teleport_model{
+					AddBrush::Available(model_id)=>Some(model_id),
+					AddBrush::Deferred(model_id)=>prop_model_id_to_final_model_id.get(&model_id).copied(),
+				};
+				if let Some(model_id)=model_id{
+					elements.insert(model_id,modes::StageElement::new(
+						stage_id,
+						true,
+						modes::StageElementBehaviour::Teleport,
+						None,
+					));
+				}
+			}
+		}
+		let main_mode=NormalizedMode::new(Mode::new(
+			strafesnet_common::gameplay_style::StyleModifiers::source_bhop(),
+			first_stage_spawn_model_id,
+			HashMap::new(),
+			stages,
+			elements,
 		));
-		//let mut models=Vec::new();
+		let modes=NormalizedModes::new(vec![main_mode]);
+
 		let (textures,render_configs)=render_configs.consume();
-		let (textures,texture_id_map):(Vec<Vec<u8>>,std::collections::HashMap<model::TextureId,model::TextureId>)
+		let (textures,texture_id_map):(Vec<Vec<u8>>,HashMap<model::TextureId,model::TextureId>)
 		=textures.into_iter()
 		//.filter_map(f) cull unused textures
 		.enumerate().map(|(new_texture_id,(old_texture_id,Texture::ImageDDS(texture)))|{
@@ -255,7 +654,7 @@ impl PartialMap2{
 			render_config
 		}).collect();
 		map::CompleteMap{
-			modes:self.modes,
+			modes,
 			attributes:self.attributes,
 			meshes:self.world_meshes,
 			models:self.world_models,

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/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "strafesnet_common"
 version = "0.6.0"
-edition = "2021"
+edition = "2024"
 repository = "https://git.itzana.me/StrafesNET/strafe-project"
 license = "MIT OR Apache-2.0"
 description = "Common types and helpers for Strafe Client associated projects."
@@ -15,5 +15,6 @@ bitflags = "2.6.0"
 fixed_wide = { version = "0.1.2", path = "../fixed_wide", registry = "strafesnet", features = ["deferred-division","zeroes","wide-mul"] }
 linear_ops = { version = "0.1.0", path = "../linear_ops", registry = "strafesnet", features = ["deferred-division","named-fields"] }
 ratio_ops = { version = "0.1.0", path = "../ratio_ops", registry = "strafesnet" }
-glam = "0.29.0"
+glam = "0.30.0"
 id = { version = "0.1.0", registry = "strafesnet" }
+vbsp = "0.8.0"

lib/common/src/aabb.rs

@@ -7,42 +7,57 @@ pub struct Aabb{
 }
 
 impl Default for Aabb{
+	#[inline]
 	fn default()->Self{
 		Self{min:vec3::MAX,max:vec3::MIN}
 	}
 }
 
 impl Aabb{
+	#[inline]
 	pub const fn new(min:Planar64Vec3,max:Planar64Vec3)->Self{
 		Self{min,max}
 	}
+	#[inline]
 	pub const fn max(&self)->Planar64Vec3{
 		self.max
 	}
+	#[inline]
 	pub const fn min(&self)->Planar64Vec3{
 		self.min
 	}
+	#[inline]
 	pub fn grow(&mut self,point:Planar64Vec3){
 		self.min=self.min.min(point);
 		self.max=self.max.max(point);
 	}
+	#[inline]
 	pub fn join(&mut self,aabb:&Aabb){
 		self.min=self.min.min(aabb.min);
 		self.max=self.max.max(aabb.max);
 	}
+	#[inline]
 	pub fn inflate(&mut self,hs:Planar64Vec3){
 		self.min-=hs;
 		self.max+=hs;
 	}
+	#[inline]
+	pub fn contains(&self,point:Planar64Vec3)->bool{
+		let bvec=self.min.lt(point)&point.lt(self.max);
+		bvec.all()
+	}
+	#[inline]
 	pub fn intersects(&self,aabb:&Aabb)->bool{
 		let bvec=self.min.lt(aabb.max)&aabb.min.lt(self.max);
 		bvec.all()
 	}
+	#[inline]
 	pub fn size(&self)->Planar64Vec3{
 		self.max-self.min
 	}
+	#[inline]
 	pub fn center(&self)->Planar64Vec3{
-		self.min+(self.max-self.min)>>1
+		self.min.map_zip(self.max,|(min,max)|min.midpoint(max))
 	}
 	//probably use floats for area & volume because we don't care about precision
 	// pub fn area_weight(&self)->f32{

lib/common/src/bvh.rs

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

lib/common/src/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/gameplay_modes.rs

@@ -1,7 +1,6 @@
 use std::collections::{HashSet,HashMap};
 use crate::model::ModelId;
 use crate::gameplay_style;
-use crate::updatable::Updatable;
 
 #[derive(Clone)]
 pub struct StageElement{
@@ -128,18 +127,6 @@ impl Stage{
 		self.unordered_checkpoints.contains(&model_id)
 	}
 }
-#[derive(Default)]
-pub struct StageUpdate{
-	//other behaviour models of this stage can have
-	ordered_checkpoints:HashMap<CheckpointId,ModelId>,
-	unordered_checkpoints:HashSet<ModelId>,
-}
-impl Updatable<StageUpdate> for Stage{
-	fn update(&mut self,update:StageUpdate){
-		self.ordered_checkpoints.extend(update.ordered_checkpoints);
-		self.unordered_checkpoints.extend(update.unordered_checkpoints);
-	}
-}
 
 #[derive(Clone,Copy,Hash,Eq,PartialEq)]
 pub enum Zone{
@@ -211,34 +198,47 @@ impl Mode{
 	pub fn push_stage(&mut self,stage:Stage){
 		self.stages.push(stage)
 	}
-	pub fn get_stage_mut(&mut self,stage:StageId)->Option<&mut Stage>{
-		self.stages.get_mut(stage.0 as usize)
+	pub fn get_stage_mut(&mut self,StageId(stage_id):StageId)->Option<&mut Stage>{
+		self.stages.get_mut(stage_id as usize)
 	}
-	pub fn get_spawn_model_id(&self,stage:StageId)->Option<ModelId>{
-		self.stages.get(stage.0 as usize).map(|s|s.spawn)
+	pub fn get_spawn_model_id(&self,StageId(stage_id):StageId)->Option<ModelId>{
+		self.stages.get(stage_id as usize).map(|s|s.spawn)
 	}
 	pub fn get_zone(&self,model_id:ModelId)->Option<&Zone>{
 		self.zones.get(&model_id)
 	}
-	pub fn get_stage(&self,stage_id:StageId)->Option<&Stage>{
-		self.stages.get(stage_id.0 as usize)
+	pub fn get_stage(&self,StageId(stage_id):StageId)->Option<&Stage>{
+		self.stages.get(stage_id as usize)
 	}
 	pub fn get_element(&self,model_id:ModelId)->Option<&StageElement>{
 		self.elements.get(&model_id)
 	}
+}
+
+#[derive(Clone)]
+pub struct NormalizedMode(Mode);
+impl NormalizedMode{
+	pub fn new(mode:Mode)->Self{
+		Self(mode)
+	}
+	pub fn into_inner(self)->Mode{
+		let Self(mode)=self;
+		mode
+	}
 	//TODO: put this in the SNF
-	pub fn denormalize_data(&mut self){
+	pub fn denormalize(self)->Mode{
+		let NormalizedMode(mut mode)=self;
 		//expand and index normalized data
-		self.zones.insert(self.start,Zone::Start);
-		for (stage_id,stage) in self.stages.iter().enumerate(){
-			self.elements.insert(stage.spawn,StageElement{
+		mode.zones.insert(mode.start,Zone::Start);
+		for (stage_id,stage) in mode.stages.iter().enumerate(){
+			mode.elements.insert(stage.spawn,StageElement{
 				stage_id:StageId(stage_id as u32),
 				force:false,
 				behaviour:StageElementBehaviour::SpawnAt,
 				jump_limit:None,
 			});
 			for (_,&model) in &stage.ordered_checkpoints{
-				self.elements.insert(model,StageElement{
+				mode.elements.insert(model,StageElement{
 					stage_id:StageId(stage_id as u32),
 					force:false,
 					behaviour:StageElementBehaviour::Checkpoint,
@@ -246,7 +246,7 @@ impl Mode{
 				});
 			}
 			for &model in &stage.unordered_checkpoints{
-				self.elements.insert(model,StageElement{
+				mode.elements.insert(model,StageElement{
 					stage_id:StageId(stage_id as u32),
 					force:false,
 					behaviour:StageElementBehaviour::Checkpoint,
@@ -254,53 +254,13 @@ impl Mode{
 				});
 			}
 		}
-	}
-}
-//this would be nice as a macro
-#[derive(Default)]
-pub struct ModeUpdate{
-	zones:HashMap<ModelId,Zone>,
-	stages:HashMap<StageId,StageUpdate>,
-	//mutually exlusive stage element behaviour
-	elements:HashMap<ModelId,StageElement>,
-}
-impl Updatable<ModeUpdate> for Mode{
-	fn update(&mut self,update:ModeUpdate){
-		self.zones.extend(update.zones);
-		for (stage,stage_update) in update.stages{
-			if let Some(stage)=self.stages.get_mut(stage.0 as usize){
-				stage.update(stage_update);
-			}
-		}
-		self.elements.extend(update.elements);
-	}
-}
-impl ModeUpdate{
-	pub fn zone(model_id:ModelId,zone:Zone)->Self{
-		let mut mu=Self::default();
-		mu.zones.insert(model_id,zone);
-		mu
-	}
-	pub fn stage(stage_id:StageId,stage_update:StageUpdate)->Self{
-		let mut mu=Self::default();
-		mu.stages.insert(stage_id,stage_update);
-		mu
-	}
-	pub fn element(model_id:ModelId,element:StageElement)->Self{
-		let mut mu=Self::default();
-		mu.elements.insert(model_id,element);
-		mu
-	}
-	pub fn map_stage_element_ids<F:Fn(StageId)->StageId>(&mut self,f:F){
-		for (_,stage_element) in self.elements.iter_mut(){
-			stage_element.stage_id=f(stage_element.stage_id);
-		}
+		mode
 	}
 }
 
 #[derive(Default,Clone)]
 pub struct Modes{
-	pub modes:Vec<Mode>,
+	modes:Vec<Mode>,
 }
 impl Modes{
 	pub const fn new(modes:Vec<Mode>)->Self{
@@ -314,19 +274,182 @@ impl Modes{
 	pub fn push_mode(&mut self,mode:Mode){
 		self.modes.push(mode)
 	}
-	pub fn get_mode(&self,mode:ModeId)->Option<&Mode>{
-		self.modes.get(mode.0 as usize)
+	pub fn get_mode(&self,ModeId(mode_id):ModeId)->Option<&Mode>{
+		self.modes.get(mode_id as usize)
 	}
 }
-pub struct ModesUpdate{
-	modes:HashMap<ModeId,ModeUpdate>,
+
+#[derive(Clone)]
+pub struct NormalizedModes{
+	modes:Vec<NormalizedMode>,
 }
-impl Updatable<ModesUpdate> for Modes{
-	fn update(&mut self,update:ModesUpdate){
-		for (mode,mode_update) in update.modes{
-			if let Some(mode)=self.modes.get_mut(mode.0 as usize){
-				mode.update(mode_update);
-			}
+impl NormalizedModes{
+	pub fn new(modes:Vec<NormalizedMode>)->Self{
+		Self{modes}
+	}
+	pub fn len(&self)->usize{
+		self.modes.len()
+	}
+	pub fn denormalize(self)->Modes{
+		Modes{
+			modes:self.modes.into_iter().map(NormalizedMode::denormalize).collect(),
 		}
 	}
 }
+impl IntoIterator for NormalizedModes{
+	type Item=<Vec<NormalizedMode> as IntoIterator>::Item;
+	type IntoIter=<Vec<NormalizedMode> as IntoIterator>::IntoIter;
+	fn into_iter(self)->Self::IntoIter{
+		self.modes.into_iter()
+	}
+}
+
+
+#[derive(Default)]
+pub struct StageUpdate{
+	//other behaviour models of this stage can have
+	ordered_checkpoints:HashMap<CheckpointId,ModelId>,
+	unordered_checkpoints:HashSet<ModelId>,
+}
+impl StageUpdate{
+	fn apply_to(self,stage:&mut Stage){
+		stage.ordered_checkpoints.extend(self.ordered_checkpoints);
+		stage.unordered_checkpoints.extend(self.unordered_checkpoints);
+	}
+}
+
+//this would be nice as a macro
+#[derive(Default)]
+pub struct ModeUpdate{
+	zones:Option<(ModelId,Zone)>,
+	stages:Option<(StageId,StageUpdate)>,
+	//mutually exlusive stage element behaviour
+	elements:Option<(ModelId,StageElement)>,
+}
+impl ModeUpdate{
+	fn apply_to(self,mode:&mut Mode){
+		mode.zones.extend(self.zones);
+		if let Some((StageId(stage_id),stage_update))=self.stages{
+			if let Some(stage)=mode.stages.get_mut(stage_id as usize){
+				stage_update.apply_to(stage);
+			}
+		}
+		mode.elements.extend(self.elements);
+	}
+}
+impl ModeUpdate{
+	pub fn zone(model_id:ModelId,zone:Zone)->Self{
+		Self{
+			zones:Some((model_id,zone)),
+			stages:None,
+			elements:None,
+		}
+	}
+	pub fn stage(stage_id:StageId,stage_update:StageUpdate)->Self{
+		Self{
+			zones:None,
+			stages:Some((stage_id,stage_update)),
+			elements:None,
+		}
+	}
+	pub fn element(model_id:ModelId,element:StageElement)->Self{
+		Self{
+			zones:None,
+			stages:None,
+			elements:Some((model_id,element)),
+		}
+	}
+	pub fn map_stage_element_ids<F:Fn(StageId)->StageId>(&mut self,f:F){
+		for (_,stage_element) in self.elements.iter_mut(){
+			stage_element.stage_id=f(stage_element.stage_id);
+		}
+	}
+}
+
+struct ModeBuilder{
+	mode:Mode,
+	stage_id_map:HashMap<StageId,StageId>,
+}
+#[derive(Default)]
+pub struct ModesBuilder{
+	modes:HashMap<ModeId,Mode>,
+	stages:HashMap<ModeId,HashMap<StageId,Stage>>,
+	mode_updates:Vec<(ModeId,ModeUpdate)>,
+	stage_updates:Vec<(ModeId,StageId,StageUpdate)>,
+}
+impl ModesBuilder{
+	pub fn build_normalized(mut self)->NormalizedModes{
+		//collect modes and stages into contiguous arrays
+		let mut unique_modes:Vec<(ModeId,Mode)>
+		=self.modes.into_iter().collect();
+		unique_modes.sort_by_key(|&(mode_id,_)|mode_id);
+		let (mut modes,mode_id_map):(Vec<ModeBuilder>,HashMap<ModeId,ModeId>)
+		=unique_modes.into_iter().enumerate()
+		.map(|(final_mode_id,(builder_mode_id,mut mode))|{
+			(
+				ModeBuilder{
+					stage_id_map:self.stages.remove(&builder_mode_id).map_or_else(||HashMap::new(),|stages|{
+						let mut unique_stages:Vec<(StageId,Stage)>
+						=stages.into_iter().collect();
+						unique_stages.sort_by_key(|&(StageId(stage_id),_)|stage_id);
+						unique_stages.into_iter().enumerate()
+						.map(|(final_stage_id,(builder_stage_id,stage))|{
+							mode.push_stage(stage);
+							(builder_stage_id,StageId::new(final_stage_id as u32))
+						}).collect()
+					}),
+					mode,
+				},
+				(
+					builder_mode_id,
+					ModeId::new(final_mode_id as u32)
+				)
+			)
+		}).unzip();
+		//TODO: failure messages or errors or something
+		//push stage updates
+		for (builder_mode_id,builder_stage_id,stage_update) in self.stage_updates{
+			if let Some(final_mode_id)=mode_id_map.get(&builder_mode_id){
+				if let Some(mode)=modes.get_mut(final_mode_id.get() as usize){
+					if let Some(&final_stage_id)=mode.stage_id_map.get(&builder_stage_id){
+						if let Some(stage)=mode.mode.get_stage_mut(final_stage_id){
+							stage_update.apply_to(stage);
+						}
+					}
+				}
+			}
+		}
+		//push mode updates
+		for (builder_mode_id,mut mode_update) in self.mode_updates{
+			if let Some(final_mode_id)=mode_id_map.get(&builder_mode_id){
+				if let Some(mode)=modes.get_mut(final_mode_id.get() as usize){
+					//map stage id on stage elements
+					mode_update.map_stage_element_ids(|stage_id|
+						//walk down one stage id at a time until a stage is found
+						//TODO use better logic like BTreeMap::upper_bound instead of walking
+						// final_stage_id_from_builder_stage_id.upper_bound(Bound::Included(&stage_id))
+						// .value().copied().unwrap_or(StageId::FIRST)
+						(0..=stage_id.get()).rev().find_map(|builder_stage_id|
+							//map the stage element to that stage
+							mode.stage_id_map.get(&StageId::new(builder_stage_id)).copied()
+						).unwrap_or(StageId::FIRST)
+					);
+					mode_update.apply_to(&mut mode.mode);
+				}
+			}
+		}
+		NormalizedModes::new(modes.into_iter().map(|mode_builder|NormalizedMode(mode_builder.mode)).collect())
+	}
+	pub fn insert_mode(&mut self,mode_id:ModeId,mode:Mode){
+		assert!(self.modes.insert(mode_id,mode).is_none(),"Cannot replace existing mode");
+	}
+	pub fn insert_stage(&mut self,mode_id:ModeId,stage_id:StageId,stage:Stage){
+		assert!(self.stages.entry(mode_id).or_insert(HashMap::new()).insert(stage_id,stage).is_none(),"Cannot replace existing stage");
+	}
+	pub fn push_mode_update(&mut self,mode_id:ModeId,mode_update:ModeUpdate){
+		self.mode_updates.push((mode_id,mode_update));
+	}
+	// fn push_stage_update(&mut self,mode_id:ModeId,stage_id:StageId,stage_update:StageUpdate){
+	// 	self.stage_updates.push((mode_id,stage_id,stage_update));
+	// }
+}

lib/common/src/gameplay_style.rs

@@ -63,7 +63,7 @@ impl JumpImpulse{
 		velocity:Planar64Vec3,
 		jump_dir:Planar64Vec3,
 		gravity:&Planar64Vec3,
-		mass:Planar64,
+		_mass:Planar64,
 	)->Planar64Vec3{
 		match self{
 			&JumpImpulse::Time(time)=>velocity-(*gravity*time).map(|t|t.divide().fix_1()),
@@ -78,7 +78,7 @@ impl JumpImpulse{
 				velocity-(*gravity*(radicand.sqrt().fix_2()+v_g)/gg).divide().fix_1()
 			},
 			&JumpImpulse::Linear(jump_speed)=>velocity+(jump_dir*jump_speed/jump_dir.length()).divide().fix_1(),
-			&JumpImpulse::Energy(energy)=>{
+			&JumpImpulse::Energy(_energy)=>{
 				//calculate energy
 				//let e=gravity.dot(velocity);
 				//add
@@ -355,7 +355,7 @@ pub struct LadderSettings{
 	pub dot:Planar64,
 }
 impl LadderSettings{
-	pub const fn accel(&self,target_diff:Planar64Vec3,gravity:Planar64Vec3)->Planar64{
+	pub const fn accel(&self,_target_diff:Planar64Vec3,_gravity:Planar64Vec3)->Planar64{
 		//TODO: fallible ladder accel
 		self.accelerate.accel
 	}
@@ -529,12 +529,12 @@ impl StyleModifiers{
 
 	pub fn source_bhop()->Self{
 		Self{
-			controls_mask:Controls::all()-Controls::MoveUp-Controls::MoveDown,
+			controls_mask:Controls::all(),
 			controls_mask_state:Controls::all(),
 			strafe:Some(StrafeSettings{
 				enable:ControlsActivation::full_2d(),
-				air_accel_limit:Some(Planar64::raw(150<<28)*100),
-				mv:(Planar64::raw(30)*VALVE_SCALE).fix_1(),
+				air_accel_limit:Some(Planar64::raw((150<<28)*100)),
+				mv:Planar64::raw(30<<28),
 				tick_rate:Ratio64::new(100,AbsoluteTime::ONE_SECOND.get() as u64).unwrap(),
 			}),
 			jump:Some(JumpSettings{
@@ -570,12 +570,12 @@ impl StyleModifiers{
 	}
 	pub fn source_surf()->Self{
 		Self{
-			controls_mask:Controls::all()-Controls::MoveUp-Controls::MoveDown,
+			controls_mask:Controls::all(),
 			controls_mask_state:Controls::all(),
 			strafe:Some(StrafeSettings{
 				enable:ControlsActivation::full_2d(),
 				air_accel_limit:Some((int(150)*66*VALVE_SCALE).fix_1()),
-				mv:(int(30)*VALVE_SCALE).fix_1(),
+				mv:Planar64::raw(30<<28),
 				tick_rate:Ratio64::new(66,AbsoluteTime::ONE_SECOND.get() as u64).unwrap(),
 			}),
 			jump:Some(JumpSettings{

lib/common/src/instruction.rs

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

lib/common/src/integer.rs

@@ -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);
@@ -63,6 +63,12 @@ impl<T> From<Planar64> for Time<T>{
 		Self::raw((value*Planar64::raw(1_000_000_000)).fix_1().to_raw())
 	}
 }
+impl<T> From<Time<T>> for Ratio<Planar64,Planar64>{
+	#[inline]
+	fn from(value:Time<T>)->Self{
+		value.to_ratio()
+	}
+}
 impl<T,Num,Den,N1,T1> From<Ratio<Num,Den>> for Time<T>
 	where
 		Num:core::ops::Mul<Planar64,Output=N1>,
@@ -648,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;
@@ -8,7 +9,6 @@ pub mod timer;
 pub mod integer;
 pub mod physics;
 pub mod session;
-pub mod updatable;
 pub mod instruction;
 pub mod gameplay_attributes;
 pub mod gameplay_modes;

lib/common/src/map.rs

@@ -4,7 +4,7 @@ use crate::gameplay_attributes;
 //this is a temporary struct to try to get the code running again
 //TODO: use snf::map::Region to update the data in physics and graphics instead of this
 pub struct CompleteMap{
-	pub modes:gameplay_modes::Modes,
+	pub modes:gameplay_modes::NormalizedModes,
 	pub attributes:Vec<gameplay_attributes::CollisionAttributes>,
 	pub meshes:Vec<model::Mesh>,
 	pub models:Vec<model::Model>,

lib/common/src/model.rs

@@ -208,9 +208,87 @@ impl MeshBuilder{
 
 #[derive(Debug,Clone,Copy,Hash,id::Id,Eq,PartialEq)]
 pub struct ModelId(u32);
+#[derive(Clone)]
 pub struct Model{
 	pub mesh:MeshId,
 	pub attributes:gameplay_attributes::CollisionAttributesId,
 	pub color:Color4,//transparency is in here
 	pub transform:Planar64Affine3,
+	pub debug_info:DebugInfo,
+}
+
+#[derive(Debug,Clone)]
+pub enum DebugInfo{
+	World,
+	Prop,
+	Brush(BrushInfo),
+	Entity(EntityInfo),
+}
+impl std::fmt::Display for DebugInfo{
+	fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
+		match self{
+			DebugInfo::World=>write!(f,"World"),
+			DebugInfo::Prop=>write!(f,"Prop"),
+			DebugInfo::Brush(brush_info)=>brush_info.fmt(f),
+			DebugInfo::Entity(entity_info)=>entity_info.fmt(f),
+		}
+	}
+}
+
+#[derive(Debug,Clone)]
+pub struct BrushInfo{
+	pub flags:vbsp::BrushFlags,
+	pub sides:Vec<vbsp::TextureFlags>,
+}
+impl std::fmt::Display for BrushInfo{
+	fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
+		let noice=self.flags.iter_names().filter_map(|(name,flags)|{
+			(flags.bits()!=0).then(||name)
+		}).collect::<Vec<&str>>().join("|");
+		writeln!(f,"brush_info.flags={noice}")?;
+		for (i,side) in self.sides.iter().enumerate(){
+			let noice_string=side.iter_names().filter_map(|(name,flags)|{
+				(flags.bits()!=0).then(||name)
+			}).collect::<Vec<&str>>().join("|");
+			writeln!(f,"brush_info.sides[{i}]={noice_string}")?;
+		}
+		Ok(())
+	}
+}
+
+#[derive(Debug,Clone)]
+pub struct EntityInfo{
+	pub classname:Box<str>,
+	pub properties:Vec<(Box<str>,Box<str>)>,
+}
+pub enum EntityInfoError{
+	MissingClassname,
+}
+impl EntityInfo{
+	pub fn new<'a>(iter:impl IntoIterator<Item=(&'a str,&'a str)>)->Result<Self,EntityInfoError>{
+		let mut classname:Option<Box<str>>=None;
+		let mut properties:Vec<(Box<str>,Box<str>)>=Vec::new();
+		for (name,value) in iter{
+			match name{
+				"classname"=>classname=Some(value.into()),
+				"hammerid"=>(),
+				_=>properties.push((name.into(),value.into())),
+			}
+		}
+		properties.sort_by(|(n0,_),(n1,_)|n0.cmp(n1));
+		let Some(classname)=classname else{
+			return Err(EntityInfoError::MissingClassname);
+		};
+		Ok(EntityInfo{classname,properties})
+	}
+}
+impl std::fmt::Display for EntityInfo{
+	fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
+		writeln!(f,"struct {}{{",self.classname)?;
+		for (name,value) in &self.properties{
+			writeln!(f,"\t{name}:{value},")?;
+		}
+		write!(f,"}}")?;
+		Ok(())
+	}
 }

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/common/src/updatable.rs

@@ -1,57 +0,0 @@
-// This whole thing should be a drive macro
-
-pub trait Updatable<Updater>{
-	fn update(&mut self,update:Updater);
-}
-#[derive(Clone,Copy,Hash,Eq,PartialEq)]
-struct InnerId(u32);
-#[derive(Clone)]
-struct Inner{
-	id:InnerId,
-	enabled:bool,
-}
-#[derive(Clone,Copy,Hash,Eq,PartialEq)]
-struct OuterId(u32);
-struct Outer{
-	id:OuterId,
-	inners:std::collections::HashMap<InnerId,Inner>,
-}
-
-enum Update<I,U>{
-	Insert(I),
-	Update(U),
-	Remove
-}
-
-struct InnerUpdate{
-	//#[updatable(Update)]
-	enabled:Option<bool>,
-}
-struct OuterUpdate{
-	//#[updatable(Insert,Update,Remove)]
-	inners:std::collections::HashMap<InnerId,Update<Inner,InnerUpdate>>,
-	//#[updatable(Update)]
-	//inners:std::collections::HashMap<InnerId,InnerUpdate>,
-}
-impl Updatable<InnerUpdate> for Inner{
-	fn update(&mut self,update:InnerUpdate){
-		if let Some(enabled)=update.enabled{
-			self.enabled=enabled;
-		}
-	}
-}
-impl Updatable<OuterUpdate> for Outer{
-	fn update(&mut self,update:OuterUpdate){
-		for (id,up) in update.inners{
-			match up{
-				Update::Insert(new_inner)=>self.inners.insert(id,new_inner),
-				Update::Update(inner_update)=>self.inners.get_mut(&id).map(|inner|{
-					let old=inner.clone();
-					inner.update(inner_update);
-					old
-				}),
-				Update::Remove=>self.inners.remove(&id),
-			};
-		}
-	}
-}

lib/deferred_loader/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "strafesnet_deferred_loader"
 version = "0.5.0"
-edition = "2021"
+edition = "2024"
 repository = "https://git.itzana.me/StrafesNET/strafe-project"
 license = "MIT OR Apache-2.0"
 description = "Acquire IDs for objects before loading them in bulk."

lib/fixed_wide/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "fixed_wide"
 version = "0.1.2"
-edition = "2021"
+edition = "2024"
 repository = "https://git.itzana.me/StrafesNET/strafe-project"
 license = "MIT OR Apache-2.0"
 description = "Fixed point numbers with optional widening Mul operator."
@@ -14,7 +14,7 @@ wide-mul=[]
 zeroes=["dep:arrayvec"]
 
 [dependencies]
-bnum = "0.12.0"
+bnum = "0.13.0"
 arrayvec = { version = "0.7.6", optional = true }
 paste = "1.0.15"
 ratio_ops = { version = "0.1.0", path = "../ratio_ops", registry = "strafesnet", optional = true }

lib/fixed_wide/src/fixed.rs

@@ -33,6 +33,14 @@ impl<const N:usize,const F:usize> Fixed<N,F>{
 		self.bits
 	}
 	#[inline]
+	pub const fn as_bits(&self)->&BInt<N>{
+		&self.bits
+	}
+	#[inline]
+	pub const fn as_bits_mut(&mut self)->&mut BInt<N>{
+		&mut self.bits
+	}
+	#[inline]
 	pub const fn raw_digit(value:i64)->Self{
 		let mut digits=[0u64;N];
 		digits[0]=value.abs() as u64;
@@ -56,6 +64,10 @@ impl<const N:usize,const F:usize> Fixed<N,F>{
 	pub const fn abs(self)->Self{
 		Self::from_bits(self.bits.abs())
 	}
+	#[inline]
+	pub const fn midpoint(self,other:Self)->Self{
+		Self::from_bits(self.bits.midpoint(other.bits))
+	}
 }
 impl<const F:usize> Fixed<1,F>{
 	/// My old code called this function everywhere so let's provide it
@@ -788,13 +800,10 @@ macro_rules! impl_not_const_generic{
 				let wide_self=self.[<fix_ $_2n>]();
 				//descend down the bits and check if flipping each bit would push the square over the input value
 				for shift in (0..=max_shift).rev(){
-					let new_result={
-						let mut bits=result.to_bits().to_bits();
-						bits.set_bit(shift,true);
-						Self::from_bits(BInt::from_bits(bits))
-					};
-					if new_result.[<wide_mul_ $n _ $n>](new_result)<=wide_self{
-						result=new_result;
+					result.as_bits_mut().as_bits_mut().set_bit(shift,true);
+					if wide_self<result.[<wide_mul_ $n _ $n>](result){
+						// put it back lol
+						result.as_bits_mut().as_bits_mut().set_bit(shift,false);
 					}
 				}
 				result

lib/linear_ops/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "linear_ops"
 version = "0.1.0"
-edition = "2021"
+edition = "2024"
 repository = "https://git.itzana.me/StrafesNET/strafe-project"
 license = "MIT OR Apache-2.0"
 description = "Vector/Matrix operations using trait bounds."

lib/ratio_ops/Cargo.toml

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

lib/ratio_ops/src/ratio.rs

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

lib/rbx_loader/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "strafesnet_rbx_loader"
 version = "0.6.0"
-edition = "2021"
+edition = "2024"
 repository = "https://git.itzana.me/StrafesNET/strafe-project"
 license = "MIT OR Apache-2.0"
 description = "Convert Roblox place and model files to StrafesNET data structures."
@@ -11,7 +11,7 @@ authors = ["Rhys Lloyd <krakow20@gmail.com>"]
 
 [dependencies]
 bytemuck = "1.14.3"
-glam = "0.29.0"
+glam = "0.30.0"
 lazy-regex = "3.1.0"
 rbx_binary = { version = "0.7.4", registry = "strafesnet" }
 rbx_dom_weak = { version = "2.7.0", registry = "strafesnet" }

lib/rbx_loader/src/mesh.rs

@@ -84,13 +84,13 @@ where
 fn ingest_faces2_lods3(
 	polygon_groups:&mut Vec<PolygonGroup>,
 	vertex_id_map:&HashMap<rbx_mesh::mesh::VertexId2,VertexId>,
-	faces:&Vec<rbx_mesh::mesh::Face2>,
-	lods:&Vec<rbx_mesh::mesh::Lod3>
+	faces:&[rbx_mesh::mesh::Face2],
+	lods:&[rbx_mesh::mesh::Lod3],
 ){
 	//faces have to be split into polygon groups based on lod
 	polygon_groups.extend(lods.windows(2).map(|lod_pair|
-		PolygonGroup::PolygonList(PolygonList::new(faces[lod_pair[0].0 as usize..lod_pair[1].0 as usize].iter().map(|face|
-			vec![vertex_id_map[&face.0],vertex_id_map[&face.1],vertex_id_map[&face.2]]
+		PolygonGroup::PolygonList(PolygonList::new(faces[lod_pair[0].0 as usize..lod_pair[1].0 as usize].iter().map(|rbx_mesh::mesh::Face2(v0,v1,v2)|
+			vec![vertex_id_map[&v0],vertex_id_map[&v1],vertex_id_map[&v2]]
 		).collect()))
 	))
 }

lib/rbx_loader/src/rbx.rs

@@ -4,12 +4,11 @@ use crate::primitives;
 use strafesnet_common::aabb::Aabb;
 use strafesnet_common::map;
 use strafesnet_common::model;
-use strafesnet_common::gameplay_modes;
+use strafesnet_common::gameplay_modes::{NormalizedModes,Mode,ModeId,ModeUpdate,ModesBuilder,Stage,StageElement,StageElementBehaviour,StageId,Zone};
 use strafesnet_common::gameplay_style;
 use strafesnet_common::gameplay_attributes as attr;
 use strafesnet_common::integer::{self,vec3,Planar64,Planar64Vec3,Planar64Mat3,Planar64Affine3};
 use strafesnet_common::model::RenderConfigId;
-use strafesnet_common::updatable::Updatable;
 use strafesnet_deferred_loader::deferred_loader::{RenderConfigDeferredLoader,MeshDeferredLoader};
 use strafesnet_deferred_loader::mesh::Meshes;
 use strafesnet_deferred_loader::texture::{RenderConfigs,Texture};
@@ -52,93 +51,7 @@ fn planar64_affine3_from_roblox(cf:&rbx_dom_weak::types::CFrame,size:&rbx_dom_we
 		vec3::try_from_f32_array([cf.position.x,cf.position.y,cf.position.z]).unwrap()
 	)
 }
-struct ModeBuilder{
-	mode:gameplay_modes::Mode,
-	final_stage_id_from_builder_stage_id:HashMap<gameplay_modes::StageId,gameplay_modes::StageId>,
-}
-#[derive(Default)]
-struct ModesBuilder{
-	modes:HashMap<gameplay_modes::ModeId,gameplay_modes::Mode>,
-	stages:HashMap<gameplay_modes::ModeId,HashMap<gameplay_modes::StageId,gameplay_modes::Stage>>,
-	mode_updates:Vec<(gameplay_modes::ModeId,gameplay_modes::ModeUpdate)>,
-	stage_updates:Vec<(gameplay_modes::ModeId,gameplay_modes::StageId,gameplay_modes::StageUpdate)>,
-}
-impl ModesBuilder{
-	fn build(mut self)->gameplay_modes::Modes{
-		//collect modes and stages into contiguous arrays
-		let mut unique_modes:Vec<(gameplay_modes::ModeId,gameplay_modes::Mode)>
-		=self.modes.into_iter().collect();
-		unique_modes.sort_by_key(|&(mode_id,_)|mode_id);
-		let (mut modes,final_mode_id_from_builder_mode_id):(Vec<ModeBuilder>,HashMap<gameplay_modes::ModeId,gameplay_modes::ModeId>)
-		=unique_modes.into_iter().enumerate()
-		.map(|(final_mode_id,(builder_mode_id,mut mode))|{
-			(
-				ModeBuilder{
-					final_stage_id_from_builder_stage_id:self.stages.remove(&builder_mode_id).map_or_else(||HashMap::new(),|stages|{
-						let mut unique_stages:Vec<(gameplay_modes::StageId,gameplay_modes::Stage)>
-						=stages.into_iter().collect();
-						unique_stages.sort_by(|a,b|a.0.cmp(&b.0));
-						unique_stages.into_iter().enumerate()
-						.map(|(final_stage_id,(builder_stage_id,stage))|{
-							mode.push_stage(stage);
-							(builder_stage_id,gameplay_modes::StageId::new(final_stage_id as u32))
-						}).collect()
-					}),
-					mode,
-				},
-				(
-					builder_mode_id,
-					gameplay_modes::ModeId::new(final_mode_id as u32)
-				)
-			)
-		}).unzip();
-		//TODO: failure messages or errors or something
-		//push stage updates
-		for (builder_mode_id,builder_stage_id,stage_update) in self.stage_updates{
-			if let Some(final_mode_id)=final_mode_id_from_builder_mode_id.get(&builder_mode_id){
-				if let Some(mode)=modes.get_mut(final_mode_id.get() as usize){
-					if let Some(&final_stage_id)=mode.final_stage_id_from_builder_stage_id.get(&builder_stage_id){
-						if let Some(stage)=mode.mode.get_stage_mut(final_stage_id){
-							stage.update(stage_update);
-						}
-					}
-				}
-			}
-		}
-		//push mode updates
-		for (builder_mode_id,mut mode_update) in self.mode_updates{
-			if let Some(final_mode_id)=final_mode_id_from_builder_mode_id.get(&builder_mode_id){
-				if let Some(mode)=modes.get_mut(final_mode_id.get() as usize){
-					//map stage id on stage elements
-					mode_update.map_stage_element_ids(|stage_id|
-						//walk down one stage id at a time until a stage is found
-						//TODO use better logic like BTreeMap::upper_bound instead of walking
-						// final_stage_id_from_builder_stage_id.upper_bound(Bound::Included(&stage_id))
-						// .value().copied().unwrap_or(gameplay_modes::StageId::FIRST)
-						(0..=stage_id.get()).rev().find_map(|builder_stage_id|
-							//map the stage element to that stage
-							mode.final_stage_id_from_builder_stage_id.get(&gameplay_modes::StageId::new(builder_stage_id)).copied()
-						).unwrap_or(gameplay_modes::StageId::FIRST)
-					);
-					mode.mode.update(mode_update);
-				}
-			}
-		}
-		gameplay_modes::Modes::new(modes.into_iter().map(|mode_builder|mode_builder.mode).collect())
-	}
-	fn insert_mode(&mut self,mode_id:gameplay_modes::ModeId,mode:gameplay_modes::Mode){
-		assert!(self.modes.insert(mode_id,mode).is_none(),"Cannot replace existing mode");
-	}
-	fn insert_stage(&mut self,mode_id:gameplay_modes::ModeId,stage_id:gameplay_modes::StageId,stage:gameplay_modes::Stage){
-		assert!(self.stages.entry(mode_id).or_insert(HashMap::new()).insert(stage_id,stage).is_none(),"Cannot replace existing stage");
-	}
-	fn push_mode_update(&mut self,mode_id:gameplay_modes::ModeId,mode_update:gameplay_modes::ModeUpdate){
-		self.mode_updates.push((mode_id,mode_update));
-	}
-	// fn push_stage_update(&mut self,mode_id:gameplay_modes::ModeId,stage_id:gameplay_modes::StageId,stage_update:gameplay_modes::StageUpdate){
-	// 	self.stage_updates.push((mode_id,stage_id,stage_update));
-	// }
-}
+
 fn get_attributes(name:&str,can_collide:bool,velocity:Planar64Vec3,model_id:model::ModelId,modes_builder:&mut ModesBuilder,wormhole_in_model_to_id:&mut HashMap<model::ModelId,u32>,wormhole_id_to_out_model:&mut HashMap<u32,model::ModelId>)->attr::CollisionAttributes{
 	let mut general=attr::GeneralAttributes::default();
 	let mut intersecting=attr::IntersectingAttributes::default();
@@ -167,8 +80,8 @@ fn get_attributes(name:&str,can_collide:bool,velocity:Planar64Vec3,model_id:mode
 			force_can_collide=false;
 			force_intersecting=true;
 			modes_builder.insert_mode(
-				gameplay_modes::ModeId::MAIN,
-				gameplay_modes::Mode::empty(
+				ModeId::MAIN,
+				Mode::empty(
 					gameplay_style::StyleModifiers::roblox_bhop(),
 					model_id
 				)
@@ -178,10 +91,10 @@ fn get_attributes(name:&str,can_collide:bool,velocity:Planar64Vec3,model_id:mode
 			force_can_collide=false;
 			force_intersecting=true;
 			modes_builder.push_mode_update(
-				gameplay_modes::ModeId::MAIN,
-				gameplay_modes::ModeUpdate::zone(
+				ModeId::MAIN,
+				ModeUpdate::zone(
 					model_id,
-					gameplay_modes::Zone::Finish,
+					Zone::Finish,
 				),
 			);
 		},
@@ -189,19 +102,19 @@ fn get_attributes(name:&str,can_collide:bool,velocity:Planar64Vec3,model_id:mode
 			force_can_collide=false;
 			force_intersecting=true;
 			modes_builder.push_mode_update(
-				gameplay_modes::ModeId::MAIN,
-				gameplay_modes::ModeUpdate::zone(
+				ModeId::MAIN,
+				ModeUpdate::zone(
 					model_id,
-					gameplay_modes::Zone::Anticheat,
+					Zone::Anticheat,
 				),
 			);
 		},
 		"Platform"=>{
 			modes_builder.push_mode_update(
-				gameplay_modes::ModeId::MAIN,
-				gameplay_modes::ModeUpdate::element(
+				ModeId::MAIN,
+				ModeUpdate::element(
 					model_id,
-					gameplay_modes::StageElement::new(gameplay_modes::StageId::FIRST,false,gameplay_modes::StageElementBehaviour::Platform,None),//roblox does not know which stage the platform belongs to
+					StageElement::new(StageId::FIRST,false,StageElementBehaviour::Platform,None),//roblox does not know which stage the platform belongs to
 				),
 			);
 		},
@@ -213,8 +126,8 @@ fn get_attributes(name:&str,can_collide:bool,velocity:Planar64Vec3,model_id:mode
 						force_can_collide=false;
 						force_intersecting=true;
 						modes_builder.insert_mode(
-							gameplay_modes::ModeId::new(captures[2].parse::<u32>().unwrap()),
-							gameplay_modes::Mode::empty(
+							ModeId::new(captures[2].parse::<u32>().unwrap()),
+							Mode::empty(
 								gameplay_style::StyleModifiers::roblox_bhop(),
 								model_id
 							)
@@ -231,8 +144,8 @@ fn get_attributes(name:&str,can_collide:bool,velocity:Planar64Vec3,model_id:mode
 			}else if let Some(captures)=lazy_regex::regex!(r"^(Force)?(Spawn|SpawnAt|Trigger|Teleport|Platform)(\d+)$")
 			.captures(other){
 				force_intersecting=true;
-				let stage_id=gameplay_modes::StageId::new(captures[3].parse::<u32>().unwrap());
-				let stage_element=gameplay_modes::StageElement::new(
+				let stage_id=StageId::new(captures[3].parse::<u32>().unwrap());
+				let stage_element=StageElement::new(
 					//stage_id:
 					stage_id,
 					//force:
@@ -244,26 +157,26 @@ fn get_attributes(name:&str,can_collide:bool,velocity:Planar64Vec3,model_id:mode
 					match &captures[2]{
 						"Spawn"=>{
 							modes_builder.insert_stage(
-								gameplay_modes::ModeId::MAIN,
+								ModeId::MAIN,
 								stage_id,
-								gameplay_modes::Stage::empty(model_id),
+								Stage::empty(model_id),
 							);
 							//TODO: let denormalize handle this
-							gameplay_modes::StageElementBehaviour::SpawnAt
+							StageElementBehaviour::SpawnAt
 						},
-						"SpawnAt"=>gameplay_modes::StageElementBehaviour::SpawnAt,
+						"SpawnAt"=>StageElementBehaviour::SpawnAt,
 						//cancollide false so you don't hit the side
 						//NOT a decoration
-						"Trigger"=>{force_can_collide=false;gameplay_modes::StageElementBehaviour::Trigger},
-						"Teleport"=>{force_can_collide=false;gameplay_modes::StageElementBehaviour::Teleport},
-						"Platform"=>gameplay_modes::StageElementBehaviour::Platform,
+						"Trigger"=>{force_can_collide=false;StageElementBehaviour::Trigger},
+						"Teleport"=>{force_can_collide=false;StageElementBehaviour::Teleport},
+						"Platform"=>StageElementBehaviour::Platform,
 						_=>panic!("regex1[2] messed up bad"),
 					},
 					None
 				);
 				modes_builder.push_mode_update(
-					gameplay_modes::ModeId::MAIN,
-					gameplay_modes::ModeUpdate::element(
+					ModeId::MAIN,
+					ModeUpdate::element(
 						model_id,
 						stage_element,
 					),
@@ -272,14 +185,14 @@ fn get_attributes(name:&str,can_collide:bool,velocity:Planar64Vec3,model_id:mode
 			.captures(other){
 				match &captures[1]{
 					"Jump"=>modes_builder.push_mode_update(
-						gameplay_modes::ModeId::MAIN,
-						gameplay_modes::ModeUpdate::element(
+						ModeId::MAIN,
+						ModeUpdate::element(
 							model_id,
 							//jump_limit:
-							gameplay_modes::StageElement::new(
-								gameplay_modes::StageId::FIRST,
+							StageElement::new(
+								StageId::FIRST,
 								false,
-								gameplay_modes::StageElementBehaviour::Check,
+								StageElementBehaviour::Check,
 								Some(captures[2].parse::<u8>().unwrap())
 							)
 						),
@@ -296,13 +209,13 @@ fn get_attributes(name:&str,can_collide:bool,velocity:Planar64Vec3,model_id:mode
 				force_can_collide=false;
 				force_intersecting=true;
 				modes_builder.push_mode_update(
-					gameplay_modes::ModeId::new(captures[2].parse::<u32>().unwrap()),
-					gameplay_modes::ModeUpdate::zone(
+					ModeId::new(captures[2].parse::<u32>().unwrap()),
+					ModeUpdate::zone(
 						model_id,
 						//zone:
 						match &captures[1]{
-							"Finish"=>gameplay_modes::Zone::Finish,
-							"Anticheat"=>gameplay_modes::Zone::Anticheat,
+							"Finish"=>Zone::Finish,
+							"Anticheat"=>Zone::Anticheat,
 							_=>panic!("regex3[1] messed up bad"),
 						},
 					),
@@ -312,9 +225,9 @@ fn get_attributes(name:&str,can_collide:bool,velocity:Planar64Vec3,model_id:mode
 			// .captures(other){
 			// 	match &captures[1]{
 			// 		"OrderedCheckpoint"=>modes_builder.push_stage_update(
-			// 			gameplay_modes::ModeId::MAIN,
-			// 			gameplay_modes::StageId::new(0),
-			// 			gameplay_modes::StageUpdate::ordered_checkpoint(captures[2].parse::<u32>().unwrap()),
+			// 			ModeId::MAIN,
+			// 			StageId::new(0),
+			// 			StageUpdate::ordered_checkpoint(captures[2].parse::<u32>().unwrap()),
 			// 		),
 			// 		_=>panic!("regex3[1] messed up bad"),
 			// 	}
@@ -1009,7 +922,7 @@ impl PartialMap1<'_>{
 	PartialMap2{
 		meshes:self.primitive_meshes,
 		models,
-		modes:modes_builder.build(),
+		modes:modes_builder.build_normalized(),
 		attributes:unique_attributes,
 	}
 	}
@@ -1018,7 +931,7 @@ impl PartialMap1<'_>{
 pub struct PartialMap2{
 	meshes:Vec<model::Mesh>,
 	models:Vec<model::Model>,
-	modes:gameplay_modes::Modes,
+	modes:NormalizedModes,
 	attributes:Vec<strafesnet_common::gameplay_attributes::CollisionAttributes>,
 }
 impl PartialMap2{

lib/rbxassetid/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "rbxassetid"
 version = "0.1.0"
-edition = "2021"
+edition = "2024"
 repository = "https://git.itzana.me/StrafesNET/strafe-project"
 license = "MIT OR Apache-2.0"
 description = "Parse Roblox asset id from 'Content' urls."

lib/roblox_emulator/Cargo.toml

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

lib/snf/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "strafesnet_snf"
 version = "0.3.0"
-edition = "2021"
+edition = "2024"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 

lib/snf/src/bot.rs

@@ -6,7 +6,7 @@ use strafesnet_common::physics::Time;
 
 const VERSION:u32=0;
 
-type TimedPhysicsInstruction=strafesnet_common::instruction::TimedInstruction<strafesnet_common::physics::Instruction,strafesnet_common::physics::TimeInner>;
+type TimedPhysicsInstruction=strafesnet_common::instruction::TimedInstruction<strafesnet_common::physics::Instruction,strafesnet_common::physics::Time>;
 
 #[derive(Debug)]
 pub enum Error{

lib/snf/src/map.rs

@@ -6,7 +6,7 @@ use crate::file::BlockId;
 use binrw::{binrw,BinReaderExt,BinWriterExt};
 use strafesnet_common::model;
 use strafesnet_common::aabb::Aabb;
-use strafesnet_common::bvh::BvhNode;
+use strafesnet_common::bvh::{BvhNode,RecursiveContent};
 use strafesnet_common::gameplay_modes;
 
 #[derive(Debug)]
@@ -138,7 +138,7 @@ struct MapHeader{
 	//#[br(count=num_resources_external)]
 	//external_resources:Vec<ResourceExternalHeader>,
 	#[br(count=num_modes)]
-	modes:Vec<newtypes::gameplay_modes::Mode>,
+	modes:Vec<newtypes::gameplay_modes::NormalizedMode>,
 	#[br(count=num_attributes)]
 	attributes:Vec<newtypes::gameplay_attributes::CollisionAttributes>,
 	#[br(count=num_render_configs)]
@@ -181,7 +181,7 @@ fn read_texture<R:BinReaderExt>(file:&mut crate::file::File<R>,block_id:BlockId)
 pub struct StreamableMap<R:BinReaderExt>{
 	file:crate::file::File<R>,
 	//this includes every platform... move the unconstrained datas to their appropriate data block?
-	modes:gameplay_modes::Modes,
+	modes:gameplay_modes::NormalizedModes,
 	//this is every possible attribute... need some sort of streaming system
 	attributes:Vec<strafesnet_common::gameplay_attributes::CollisionAttributes>,
 	//this is every possible render configuration... shaders and such... need streaming
@@ -223,7 +223,7 @@ impl<R:BinReaderExt> StreamableMap<R>{
 		}
 		Ok(Self{
 			file,
-			modes:strafesnet_common::gameplay_modes::Modes::new(modes),
+			modes:strafesnet_common::gameplay_modes::NormalizedModes::new(modes),
 			attributes,
 			render_configs,
 			bvh:strafesnet_common::bvh::generate_bvh(bvh),
@@ -233,7 +233,7 @@ impl<R:BinReaderExt> StreamableMap<R>{
 	}
 	pub fn get_intersecting_region_block_ids(&self,aabb:&Aabb)->Vec<BlockId>{
 		let mut block_ids=Vec::new();
-		self.bvh.the_tester(aabb,&mut |&block_id|block_ids.push(block_id));
+		self.bvh.sample_aabb(aabb,&mut |&block_id|block_ids.push(block_id));
 		block_ids
 	}
 	pub fn load_region(&mut self,block_id:BlockId)->Result<Vec<(model::ModelId,model::Model)>,Error>{
@@ -287,12 +287,60 @@ impl<R:BinReaderExt> StreamableMap<R>{
 	}
 }
 
+// silly redefinition of Bvh for determining the size of subnodes
+// without duplicating work by running weight calculation recursion top down on every node
+pub struct BvhWeightNode<W,T>{
+	content:RecursiveContent<BvhWeightNode<W,T>,T>,
+	weight:W,
+	aabb:Aabb,
+}
+impl <W,T> BvhWeightNode<W,T>{
+	pub const fn weight(&self)->&W{
+		&self.weight
+	}
+	pub const fn aabb(&self)->&Aabb{
+		&self.aabb
+	}
+	pub fn into_content(self)->RecursiveContent<BvhWeightNode<W,T>,T>{
+		self.content
+	}
+	pub fn into_visitor<F:FnMut(T)>(self,f:&mut F){
+		match self.content{
+			RecursiveContent::Leaf(model)=>f(model),
+			RecursiveContent::Branch(children)=>for child in children{
+				child.into_visitor(f)
+			},
+		}
+	}
+}
+
+pub fn weigh_contents<T,W:Copy+std::iter::Sum<W>,F:Fn(&T)->W>(node:BvhNode<T>,f:&F)->BvhWeightNode<W,T>{
+	let (content,aabb)=node.into_inner();
+	match content{
+		RecursiveContent::Leaf(model)=>BvhWeightNode{
+			weight:f(&model),
+			content:RecursiveContent::Leaf(model),
+			aabb,
+		},
+		RecursiveContent::Branch(children)=>{
+			let branch:Vec<BvhWeightNode<W,T>>=children.into_iter().map(|child|
+				weigh_contents(child,f)
+			).collect();
+			BvhWeightNode{
+				weight:branch.iter().map(|node|node.weight).sum(),
+				content:RecursiveContent::Branch(branch),
+				aabb,
+			}
+		},
+	}
+}
+
 const BVH_NODE_MAX_WEIGHT:usize=64*1024;//64 kB
 fn collect_spacial_blocks(
 	block_location:&mut Vec<u64>,
 	block_headers:&mut Vec<SpacialBlockHeader>,
 	sequential_block_data:&mut std::io::Cursor<&mut Vec<u8>>,
-	bvh_node:strafesnet_common::bvh::BvhWeightNode<usize,(model::ModelId,newtypes::model::Model)>
+	bvh_node:BvhWeightNode<usize,(model::ModelId,newtypes::model::Model)>
 )->Result<(),Error>{
 	//inspect the node weights top-down.
 	//When a node weighs less than the limit,
@@ -342,7 +390,7 @@ pub fn write_map<W:BinWriterExt>(mut writer:W,map:strafesnet_common::map::Comple
 		}
 		Ok(((model::ModelId::new(model_id as u32),model.into()),aabb))
 	}).collect::<Result<Vec<_>,_>>()?;
-	let bvh=strafesnet_common::bvh::generate_bvh(boxen).weigh_contents(&|_|std::mem::size_of::<newtypes::model::Model>());
+	let bvh=weigh_contents(strafesnet_common::bvh::generate_bvh(boxen),&|_|std::mem::size_of::<newtypes::model::Model>());
 	//build blocks
 	//block location is initialized with two values
 	//the first value represents the location of the first byte after the file header
@@ -382,13 +430,13 @@ pub fn write_map<W:BinWriterExt>(mut writer:W,map:strafesnet_common::map::Comple
 		num_spacial_blocks:spacial_blocks.len() as u32,
 		num_resource_blocks:resource_blocks.len() as u32,
 		//num_resources_external:0,
-		num_modes:map.modes.modes.len() as u32,
+		num_modes:map.modes.len() as u32,
 		num_attributes:map.attributes.len() as u32,
 		num_render_configs:map.render_configs.len() as u32,
 		spacial_blocks,
 		resource_blocks,
 		//external_resources:Vec::new(),
-		modes:map.modes.modes.into_iter().map(Into::into).collect(),
+		modes:map.modes.into_iter().map(Into::into).collect(),
 		attributes:map.attributes.into_iter().map(Into::into).collect(),
 		render_configs:map.render_configs.into_iter().map(Into::into).collect(),
 	};

lib/snf/src/newtypes/gameplay_modes.rs

@@ -157,7 +157,7 @@ pub struct ModeHeader{
 }
 #[binrw::binrw]
 #[brw(little)]
-pub struct Mode{
+pub struct NormalizedMode{
 	pub header:ModeHeader,
 	pub style:super::gameplay_style::StyleModifiers,
 	pub start:u32,
@@ -179,10 +179,10 @@ impl std::fmt::Display for ModeError{
 	}
 }
 impl std::error::Error for ModeError{}
-impl TryInto<strafesnet_common::gameplay_modes::Mode> for Mode{
+impl TryInto<strafesnet_common::gameplay_modes::NormalizedMode> for NormalizedMode{
 	type Error=ModeError;
-	fn try_into(self)->Result<strafesnet_common::gameplay_modes::Mode,Self::Error>{
-		Ok(strafesnet_common::gameplay_modes::Mode::new(
+	fn try_into(self)->Result<strafesnet_common::gameplay_modes::NormalizedMode,Self::Error>{
+		Ok(strafesnet_common::gameplay_modes::NormalizedMode::new(strafesnet_common::gameplay_modes::Mode::new(
 			self.style.try_into().map_err(ModeError::StyleModifier)?,
 			strafesnet_common::model::ModelId::new(self.start),
 			self.zones.into_iter().map(|(model_id,zone)|
@@ -192,12 +192,12 @@ impl TryInto<strafesnet_common::gameplay_modes::Mode> for Mode{
 			self.elements.into_iter().map(|(model_id,stage_element)|
 				Ok((strafesnet_common::model::ModelId::new(model_id),stage_element.try_into()?))
 			).collect::<Result<_,_>>().map_err(ModeError::StageElement)?,
-		))
+		)))
 	}
 }
-impl From<strafesnet_common::gameplay_modes::Mode> for Mode{
-	fn from(value:strafesnet_common::gameplay_modes::Mode)->Self{
-		let (style,start,zones,stages,elements)=value.into_inner();
+impl From<strafesnet_common::gameplay_modes::NormalizedMode> for NormalizedMode{
+	fn from(value:strafesnet_common::gameplay_modes::NormalizedMode)->Self{
+		let (style,start,zones,stages,elements)=value.into_inner().into_inner();
 		Self{
 			header:ModeHeader{
 				zones:zones.len() as u32,

lib/snf/src/newtypes/model.rs

@@ -250,6 +250,7 @@ impl Into<strafesnet_common::model::Model> for Model{
 				]),
 				strafesnet_common::integer::vec3::raw_xyz(_9,_a,_b)
 			),
+			debug_info:strafesnet_common::model::DebugInfo::World,
 		}
 	}
 }

lib/snf/src/newtypes/physics.rs

@@ -1,7 +1,7 @@
 use super::integer::Time;
 use super::common::{bool_from_u8,bool_into_u8};
 
-type TimedPhysicsInstruction=strafesnet_common::instruction::TimedInstruction<strafesnet_common::physics::Instruction,strafesnet_common::physics::TimeInner>;
+type TimedPhysicsInstruction=strafesnet_common::instruction::TimedInstruction<strafesnet_common::physics::Instruction,strafesnet_common::physics::Time>;
 
 #[binrw::binrw]
 #[brw(little)]

map-tool/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "map-tool"
 version = "1.7.0"
-edition = "2021"
+edition = "2024"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
@@ -25,10 +25,11 @@ 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 = "0.8.0"
+vbsp-entities-css = "0.6.0"
 vmdl = "0.2.0"
 vmt-parser = "0.2.0"
-vpk = "0.2.0"
+vpk = "0.3.0"
 vtf = "0.3.0"
 
 #[profile.release]

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{

strafe-client/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "strafe-client"
 version = "0.11.0"
-edition = "2021"
+edition = "2024"
 repository = "https://git.itzana.me/StrafesNET/strafe-project"
 license = "Custom"
 description = "StrafesNET game client for bhop and surf."
@@ -16,7 +16,7 @@ source = ["dep:strafesnet_deferred_loader", "dep:strafesnet_bsp_loader"]
 roblox = ["dep:strafesnet_deferred_loader", "dep:strafesnet_rbx_loader"]
 
 [dependencies]
-glam = "0.29.0"
+glam = "0.30.0"
 parking_lot = "0.12.1"
 pollster = "0.4.0"
 strafesnet_bsp_loader = { path = "../lib/bsp_loader", registry = "strafesnet", optional = true }

strafe-client/src/app.rs

@@ -1,16 +1,16 @@
 use crate::window::Instruction;
 use strafesnet_common::integer;
 use strafesnet_common::instruction::TimedInstruction;
-use strafesnet_common::session::TimeInner as SessionTimeInner;
+use strafesnet_common::session::Time as SessionTime;
 
 pub struct App<'a>{
 	root_time:std::time::Instant,
-	window_thread:crate::compat_worker::QNWorker<'a,TimedInstruction<Instruction,SessionTimeInner>>,
+	window_thread:crate::compat_worker::QNWorker<'a,TimedInstruction<Instruction,SessionTime>>,
 }
 impl<'a> App<'a>{
 	pub fn new(
 		root_time:std::time::Instant,
-		window_thread:crate::compat_worker::QNWorker<'a,TimedInstruction<Instruction,SessionTimeInner>>,
+		window_thread:crate::compat_worker::QNWorker<'a,TimedInstruction<Instruction,SessionTime>>,
 	)->App<'a>{
 		Self{
 			root_time,

strafe-client/src/main.rs

@@ -2,7 +2,6 @@ mod app;
 mod file;
 mod setup;
 mod window;
-mod worker;
 mod compat_worker;
 mod physics_worker;
 mod graphics_worker;

strafe-client/src/physics_worker.rs

@@ -6,7 +6,7 @@ use strafesnet_session::session::{
 };
 use strafesnet_common::instruction::{TimedInstruction,InstructionConsumer};
 use strafesnet_common::physics::Time as PhysicsTime;
-use strafesnet_common::session::{Time as SessionTime,TimeInner as SessionTimeInner};
+use strafesnet_common::session::Time as SessionTime;
 use strafesnet_common::timer::Timer;
 
 pub enum Instruction{
@@ -23,7 +23,7 @@ pub fn new<'a>(
 	mut graphics_worker:crate::compat_worker::INWorker<'a,crate::graphics_worker::Instruction>,
 	directories:Directories,
 	user_settings:settings::UserSettings,
-)->crate::compat_worker::QNWorker<'a,TimedInstruction<Instruction,SessionTimeInner>>{
+)->crate::compat_worker::QNWorker<'a,TimedInstruction<Instruction,SessionTime>>{
 	let physics=strafesnet_physics::physics::PhysicsState::default();
 	let timer=Timer::unpaused(SessionTime::ZERO,PhysicsTime::ZERO);
 	let simulation=Simulation::new(timer,physics);
@@ -32,7 +32,7 @@ pub fn new<'a>(
 		directories,
 		simulation,
 	);
-	crate::compat_worker::QNWorker::new(move |ins:TimedInstruction<Instruction,SessionTimeInner>|{
+	crate::compat_worker::QNWorker::new(move |ins:TimedInstruction<Instruction,SessionTime>|{
 		// excruciating pain
 		macro_rules! run_session_instruction{
 			($time:expr,$instruction:expr)=>{
@@ -77,5 +77,8 @@ pub fn new<'a>(
 				run_session_instruction!(ins.time,SessionInstruction::LoadReplay(bot));
 			}
 		}
+
+		//whatever just do it
+		session.debug_raycast_print_model_id_if_changed(ins.time);
 	})
 }

strafe-client/src/shader.wgsl

@@ -86,6 +86,29 @@ fn vs_entity_texture(
 	return result;
 }
 
+@group(1)
+@binding(0)
+var<uniform> model_instance: ModelInstance;
+
+struct DebugEntityOutput {
+	@builtin(position) position: vec4<f32>,
+	@location(1) normal: vec3<f32>,
+	@location(2) view: vec3<f32>,
+};
+
+@vertex
+fn vs_debug(
+	@location(0) pos: vec3<f32>,
+	@location(1) normal: vec3<f32>,
+) -> DebugEntityOutput {
+	var position: vec4<f32> = model_instance.transform * vec4<f32>(pos, 1.0);
+	var result: DebugEntityOutput;
+	result.normal = model_instance.normal_transform * normal;
+	result.view = position.xyz - camera.view_inv[3].xyz;//col(3)
+	result.position = camera.proj * camera.view * position;
+	return result;
+}
+
 //group 2 is the skybox texture
 @group(1)
 @binding(0)
@@ -110,3 +133,8 @@ fn fs_entity_texture(vertex: EntityOutputTexture) -> @location(0) vec4<f32> {
 	let reflected_color = textureSample(cube_texture, cube_sampler, reflected).rgb;
 	return mix(vec4<f32>(vec3<f32>(0.05) + 0.2 * reflected_color,1.0),mix(vertex.model_color,vec4<f32>(fragment_color.rgb,1.0),fragment_color.a),0.5+0.5*abs(d));
 }
+
+@fragment
+fn fs_debug(vertex: DebugEntityOutput) -> @location(0) vec4<f32> {
+	return model_instance.color;
+}

strafe-client/src/window.rs

@@ -1,5 +1,5 @@
 use strafesnet_common::instruction::TimedInstruction;
-use strafesnet_common::session::{Time as SessionTime,TimeInner as SessionTimeInner};
+use strafesnet_common::session::Time as SessionTime;
 use strafesnet_common::physics::{MiscInstruction,SetControlInstruction};
 use crate::file::LoadFormat;
 use crate::physics_worker::Instruction as PhysicsWorkerInstruction;
@@ -17,7 +17,7 @@ struct WindowContext<'a>{
 	mouse_pos:glam::DVec2,
 	screen_size:glam::UVec2,
 	window:&'a winit::window::Window,
-	physics_thread:crate::compat_worker::QNWorker<'a,TimedInstruction<PhysicsWorkerInstruction,SessionTimeInner>>,
+	physics_thread:crate::compat_worker::QNWorker<'a,TimedInstruction<PhysicsWorkerInstruction,SessionTime>>,
 }
 
 impl WindowContext<'_>{
@@ -223,7 +223,7 @@ impl WindowContext<'_>{
 pub fn worker<'a>(
 	window:&'a winit::window::Window,
 	setup_context:crate::setup::SetupContext<'a>,
-)->crate::compat_worker::QNWorker<'a,TimedInstruction<Instruction,SessionTimeInner>>{
+)->crate::compat_worker::QNWorker<'a,TimedInstruction<Instruction,SessionTime>>{
 	// WindowContextSetup::new
 	#[cfg(feature="user-install")]
 	let directories=Directories::user().unwrap();
@@ -252,7 +252,7 @@ pub fn worker<'a>(
 	};
 
 	//WindowContextSetup::into_worker
-	crate::compat_worker::QNWorker::new(move |ins:TimedInstruction<Instruction,SessionTimeInner>|{
+	crate::compat_worker::QNWorker::new(move |ins:TimedInstruction<Instruction,SessionTime>|{
 		match ins.instruction{
 			Instruction::WindowEvent(window_event)=>{
 				window_context.window_event(ins.time,window_event);

tools/bhop_maps

@@ -1 +1 @@
-/run/media/quat/Files/Documents/map-files/verify-scripts/maps/bhop_snfm
+/run/media/quat/Files/Documents/map-files/strafesnet/maps/bhop_snfm

tools/meshes

@@ -1 +1 @@
-/run/media/quat/Files/Documents/map-files/verify-scripts/meshes
+/run/media/quat/Files/Documents/map-files/strafesnet/meshes

tools/replays

@@ -1 +1 @@
-/run/media/quat/Files/Documents/map-files/verify-scripts/replays
+/run/media/quat/Files/Documents/map-files/strafesnet/replays

tools/surf_maps

@@ -1 +1 @@
-/run/media/quat/Files/Documents/map-files/verify-scripts/maps/surf_snfm
+/run/media/quat/Files/Documents/map-files/strafesnet/maps/surf_snfm

tools/textures

@@ -1 +1 @@
-/run/media/quat/Files/Documents/map-files/verify-scripts/textures
+/run/media/quat/Files/Documents/map-files/strafesnet/textures

tools/unions

@@ -1 +1 @@
-/run/media/quat/Files/Documents/map-files/verify-scripts/unions
+/run/media/quat/Files/Documents/map-files/strafesnet/unions