fix lints

these were supposed to be 3 voxels but were on the order of 3 units

engine/graphics/Cargo.toml

@@ -11,7 +11,7 @@ id = { version = "0.1.0", registry = "strafesnet" }
 strafesnet_common = { path = "../../lib/common", registry = "strafesnet" }
 strafesnet_session = { path = "../session", registry = "strafesnet" }
 strafesnet_settings = { path = "../settings", registry = "strafesnet" }
-wgpu = "27.0.0"
+wgpu = "28.0.0"
 
 [lints]
 workspace = true

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{
@@ -132,6 +143,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,
 }
@@ -166,6 +179,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_instances_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<model::TextureId,wgpu::TextureView>=map.textures.iter().enumerate().filter_map(|(texture_id,texture_data)|{
 			let texture_id=model::TextureId::new(texture_id as u32);
@@ -608,6 +691,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"),
@@ -616,7 +714,7 @@ impl GraphicsState{
 			address_mode_w:wgpu::AddressMode::ClampToEdge,
 			mag_filter:wgpu::FilterMode::Linear,
 			min_filter:wgpu::FilterMode::Linear,
-			mipmap_filter:wgpu::FilterMode::Linear,
+			mipmap_filter:wgpu::MipmapFilterMode::Linear,
 			..Default::default()
 		});
 		let repeat_sampler=device.create_sampler(&wgpu::SamplerDescriptor{
@@ -626,7 +724,7 @@ impl GraphicsState{
 			address_mode_w:wgpu::AddressMode::Repeat,
 			mag_filter:wgpu::FilterMode::Linear,
 			min_filter:wgpu::FilterMode::Linear,
-			mipmap_filter:wgpu::FilterMode::Linear,
+			mipmap_filter:wgpu::MipmapFilterMode::Linear,
 			anisotropy_clamp:16,
 			..Default::default()
 		});
@@ -754,15 +852,23 @@ impl GraphicsState{
 				&skybox_texture_bind_group_layout,
 				&model_bind_group_layout,
 			],
-			push_constant_ranges:&[],
+			immediate_size:0,
 		});
+		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:&[
 				&camera_bind_group_layout,
 				&skybox_texture_bind_group_layout,
 			],
-			push_constant_ranges:&[],
+			immediate_size:0,
 		});
 
 		// Create the render pipelines
@@ -793,7 +899,7 @@ impl GraphicsState{
 				bias:wgpu::DepthBiasState::default(),
 			}),
 			multisample:wgpu::MultisampleState::default(),
-			multiview:None,
+			multiview_mask:None,
 			cache:None,
 		});
 		let model_pipeline=device.create_render_pipeline(&wgpu::RenderPipelineDescriptor{
@@ -828,6 +934,45 @@ impl GraphicsState{
 				bias:wgpu::DepthBiasState::default(),
 			}),
 			multisample:wgpu::MultisampleState::default(),
+			multiview_mask: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: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,
 		});
@@ -870,7 +1015,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,
@@ -879,9 +1025,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),
+			staging_belt:wgpu::util::StagingBelt::new(device.clone(),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,
 		}
@@ -918,7 +1069,6 @@ impl GraphicsState{
 				&self.camera_buf,
 				0,
 				wgpu::BufferSize::new((camera_uniforms.len() * 4) as wgpu::BufferAddress).unwrap(),
-				device,
 			)
 			.copy_from_slice(bytemuck::cast_slice(&camera_uniforms));
 		//This code only needs to run when the uniforms change
@@ -965,11 +1115,13 @@ impl GraphicsState{
 				}),
 				timestamp_writes:Default::default(),
 				occlusion_query_set:Default::default(),
+				multiview_mask:None,
 			});
 
 			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,&[]);
@@ -981,6 +1133,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()));

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

@@ -7,7 +7,6 @@ edition = "2024"
 arrayvec = "0.7.6"
 glam = "0.30.0"
 id = { version = "0.1.0", registry = "strafesnet" }
-mlua = { version = "0.11.5", features = ["luau"] }
 strafesnet_common = { path = "../../lib/common", registry = "strafesnet" }
 
 [lints]

engine/physics/src/lib.rs

@@ -3,7 +3,6 @@ mod face_crawler;
 mod model;
 mod push_solve;
 mod minimum_difference;
-mod minimum_difference_lua;
 
 pub mod physics;
 

engine/physics/src/minimum_difference.rs

@@ -100,6 +100,37 @@ const fn choose_any_direction()->Planar64Vec3{
 	vec3::X
 }
 
+fn narrow_dir2(dir:Vector3<Fixed<2,64>>)->Planar64Vec3{
+	if dir==vec3::zero(){
+		return dir.narrow_1().unwrap();
+	}
+	let x=dir.x.as_bits().unsigned_abs().bits();
+	let y=dir.y.as_bits().unsigned_abs().bits();
+	let z=dir.z.as_bits().unsigned_abs().bits();
+	let big=x.max(y).max(z);
+	const MAX_BITS:u32=64+31;
+	if MAX_BITS<big{
+		dir>>(big-MAX_BITS)
+	}else{
+		dir
+	}.narrow_1().unwrap()
+}
+fn narrow_dir3(dir:Vector3<Fixed<3,96>>)->Planar64Vec3{
+	if dir==vec3::zero(){
+		return dir.narrow_1().unwrap();
+	}
+	let x=dir.x.as_bits().unsigned_abs().bits();
+	let y=dir.y.as_bits().unsigned_abs().bits();
+	let z=dir.z.as_bits().unsigned_abs().bits();
+	let big=x.max(y).max(z);
+	const MAX_BITS:u32=96+31;
+	if MAX_BITS<big{
+		dir>>(big-MAX_BITS)
+	}else{
+		dir
+	}.narrow_1().unwrap()
+}
+
 fn reduce1<M:MeshQuery>(
 	[v0]:Simplex<1,M::Vert>,
 	mesh:&M,
@@ -165,7 +196,7 @@ fn reduce2<M:MeshQuery>(
 		// -- modify the direction to take into account a0R and b0R
 		// return direction, a0, a1, b0, b1
 		return Reduced{
-			dir:direction.narrow_1().unwrap(),
+			dir:narrow_dir3(direction),
 			simplex:Simplex1_3::Simplex2([v0,v1]),
 		};
 	}
@@ -231,7 +262,7 @@ fn reduce3<M:MeshQuery>(
 
 		// return direction, a0, a1, b0, b1, c0, c1
 		return Reduced{
-			dir:direction.narrow_1().unwrap(),
+			dir:narrow_dir2(direction),
 			simplex:Simplex1_3::Simplex3([v0,v1,v2]),
 		};
 	}
@@ -265,14 +296,14 @@ fn reduce3<M:MeshQuery>(
 		if direction==vec3::zero(){
 			// direction = uv
 			return Reduced{
-				dir:uv.narrow_1().unwrap(),
+				dir:narrow_dir2(uv),
 				simplex:Simplex1_3::Simplex2([v0,v1]),
 			};
 		}
 
 		// return direction, a0, a1, b0, b1
 		return Reduced{
-			dir:direction.narrow_1().unwrap(),
+			dir:narrow_dir3(direction),
 			simplex:Simplex1_3::Simplex2([v0,v1]),
 		};
 	}
@@ -283,7 +314,7 @@ fn reduce3<M:MeshQuery>(
 	if dir==vec3::zero(){
 		// direction = uv
 		return Reduced{
-			dir:uv.narrow_1().unwrap(),
+			dir:narrow_dir2(uv),
 			simplex:Simplex1_3::Simplex1([v0]),
 		};
 	}
@@ -399,12 +430,12 @@ fn reduce4<M:MeshQuery>(
 		// return direction, a0, a1, b0, b1, c0, c1
 		if uv_w.is_negative(){
 			return Reduce::Reduced(Reduced{
-				dir:uv.narrow_1().unwrap(),
+				dir:narrow_dir2(uv),
 				simplex:Simplex1_3::Simplex3([v0,v1,v2]),
 			});
 		}else{
 			return Reduce::Reduced(Reduced{
-				dir:-uv.narrow_1().unwrap(),
+				dir:narrow_dir2(-uv),
 				simplex:Simplex1_3::Simplex3([v0,v1,v2]),
 			});
 		}
@@ -441,12 +472,12 @@ fn reduce4<M:MeshQuery>(
 			// return direction, a0, a1, b0, b1
 			if uv_w.is_negative(){
 				return Reduce::Reduced(Reduced{
-					dir:uv.narrow_1().unwrap(),
+					dir:narrow_dir2(uv),
 					simplex:Simplex1_3::Simplex2([v0,v1]),
 				});
 			}else{
 				return Reduce::Reduced(Reduced{
-					dir:-uv.narrow_1().unwrap(),
+					dir:narrow_dir2(-uv),
 					simplex:Simplex1_3::Simplex2([v0,v1]),
 				});
 			}
@@ -454,7 +485,7 @@ fn reduce4<M:MeshQuery>(
 
 		// return direction, a0, a1, b0, b1
 		return Reduce::Reduced(Reduced{
-			dir:direction.narrow_1().unwrap(),
+			dir:narrow_dir3(direction),
 			simplex:Simplex1_3::Simplex2([v0,v1]),
 		});
 	}
@@ -466,12 +497,12 @@ fn reduce4<M:MeshQuery>(
 		// direction = uvw < 0 and uv or -uv
 		if uv_w.is_negative(){
 			return Reduce::Reduced(Reduced{
-				dir:uv.narrow_1().unwrap(),
+				dir:narrow_dir2(uv),
 				simplex:Simplex1_3::Simplex1([v0]),
 			});
 		}else{
 			return Reduce::Reduced(Reduced{
-				dir:-uv.narrow_1().unwrap(),
+				dir:narrow_dir2(-uv),
 				simplex:Simplex1_3::Simplex1([v0]),
 			});
 		}

engine/physics/src/minimum_difference_lua.rs

@@ -1,173 +0,0 @@
-use mlua::{Lua,FromLuaMulti,IntoLuaMulti,Function,Result as LuaResult,Vector};
-use strafesnet_common::integer::{Planar64,Planar64Vec3,FixedFromFloatError};
-
-use crate::model::{MeshQuery,MinkowskiMesh};
-
-pub fn contains_point(
-	mesh:&MinkowskiMesh,
-	point:Planar64Vec3,
-)->LuaResult<bool>{
-	Ok(minimum_difference(mesh,point,true)?.hits)
-}
-pub fn minimum_difference_details(
-	mesh:&MinkowskiMesh,
-	point:Planar64Vec3,
-)->LuaResult<(bool,Option<Details>)>{
-	let md=minimum_difference(mesh,point,false)?;
-	Ok((md.hits,md.details))
-}
-fn p64v3(v:Vector)->Result<Planar64Vec3,FixedFromFloatError>{
-	Ok(Planar64Vec3::new([
-		v.x().try_into()?,
-		v.y().try_into()?,
-		v.z().try_into()?,
-	]))
-}
-fn vec(v:Planar64Vec3)->Vector{
-	Vector::new(v.x.into(),v.y.into(),v.z.into())
-}
-struct MinimumDifference{
-	hits:bool,
-	details:Option<Details>
-}
-pub struct Details{
-	pub distance:Planar64,
-	pub p_pos:Planar64Vec3,
-	pub p_norm:Planar64Vec3,
-	pub q_pos:Planar64Vec3,
-	pub q_norm:Planar64Vec3,
-}
-impl FromLuaMulti for MinimumDifference{
-	fn from_lua_multi(mut values:mlua::MultiValue,_lua:&Lua)->LuaResult<Self>{
-		match values.make_contiguous(){
-			&mut [
-				mlua::Value::Boolean(hits),
-				mlua::Value::Nil,
-				mlua::Value::Nil,
-				mlua::Value::Nil,
-				mlua::Value::Nil,
-				mlua::Value::Nil,
-			]=>Ok(Self{hits,details:None}),
-			&mut [
-				mlua::Value::Boolean(hits),
-				mlua::Value::Number(distance),
-				mlua::Value::Vector(p_pos),
-				mlua::Value::Vector(p_norm),
-				mlua::Value::Vector(q_pos),
-				mlua::Value::Vector(q_norm),
-			]=>Ok(Self{
-				hits,
-				details:Some(Details{
-					distance:distance.try_into().unwrap(),
-					p_pos:p64v3(p_pos).unwrap(),
-					p_norm:p64v3(p_norm).unwrap(),
-					q_pos:p64v3(q_pos).unwrap(),
-					q_norm:p64v3(q_norm).unwrap(),
-				}),
-			}),
-			&mut [
-				mlua::Value::Boolean(hits),
-				mlua::Value::Integer(distance),
-				mlua::Value::Vector(p_pos),
-				mlua::Value::Vector(p_norm),
-				mlua::Value::Vector(q_pos),
-				mlua::Value::Vector(q_norm),
-			]=>Ok(Self{
-				hits,
-				details:Some(Details{
-					distance:distance.into(),
-					p_pos:p64v3(p_pos).unwrap(),
-					p_norm:p64v3(p_norm).unwrap(),
-					q_pos:p64v3(q_pos).unwrap(),
-					q_norm:p64v3(q_norm).unwrap(),
-				}),
-			}),
-			values=>Err(mlua::Error::runtime(format!("Invalid return values: {values:?}"))),
-		}
-	}
-}
-
-struct Args{
-	query_p:Function,
-	radius_p:f64,
-	query_q:Function,
-	radius_q:f64,
-	test_intersection:bool,
-}
-impl Args{
-	fn new(
-		lua:&Lua,
-		mesh:&'static MinkowskiMesh<'static>,
-		point:Planar64Vec3,
-		test_intersection:bool,
-	)->LuaResult<Self>{
-		let radius_p=0.0;
-		let radius_q=0.0;
-		// Query the farthest point on the mesh in the given direction.
-		let query_p=lua.create_function(move|_,dir:Option<Vector>|{
-			let Some(dir)=dir else{
-				return Ok(vec(mesh.mesh0.hint_point()));
-			};
-			let dir=p64v3(dir).unwrap();
-			let vert_id=mesh.mesh0.farthest_vert(dir);
-			let dir=mesh.mesh0.vert(vert_id);
-			Ok(vec(dir))
-		})?;
-		// query_q is different since it includes the test point offset.
-		let query_q=lua.create_function(move|_,dir:Option<Vector>|{
-			let Some(dir)=dir else{
-				return Ok(vec(mesh.mesh1.hint_point()+point));
-			};
-			let dir=p64v3(dir).unwrap();
-			let vert_id=mesh.mesh1.farthest_vert(dir);
-			let dir=mesh.mesh1.vert(vert_id)+point;
-			Ok(vec(dir))
-		})?;
-		Ok(Args{
-			query_p,
-			radius_p,
-			query_q,
-			radius_q,
-			test_intersection,
-		})
-	}
-}
-impl IntoLuaMulti for Args{
-	fn into_lua_multi(self,lua:&Lua)->LuaResult<mlua::MultiValue>{
-		use mlua::IntoLua;
-		Ok(mlua::MultiValue::from_vec(vec![
-			self.query_p.into_lua(lua)?,
-			self.radius_p.into_lua(lua)?,
-			self.query_q.into_lua(lua)?,
-			self.radius_q.into_lua(lua)?,
-			mlua::Value::Nil,
-			self.test_intersection.into_lua(lua)?,
-		]))
-	}
-}
-
-fn minimum_difference(
-	mesh:&MinkowskiMesh,
-	point:Planar64Vec3,
-	test_intersection:bool,
-)->LuaResult<MinimumDifference>{
-	let ctx=init_lua()?;
-	// SAFETY: mesh lifetime must outlive args usages
-	let mesh=unsafe{core::mem::transmute(mesh)};
-	let args=Args::new(&ctx.lua,mesh,point,test_intersection)?;
-	ctx.f.call(args)
-}
-
-struct Ctx{
-	lua:Lua,
-	f:Function,
-}
-fn init_lua()->LuaResult<Ctx>{
-	static SOURCE:std::sync::LazyLock<String>=std::sync::LazyLock::new(||std::fs::read_to_string("/home/quat/strafesnet/game/src/ReplicatedStorage/Shared/Trey-MinimumDifference.lua").unwrap());
-	let lua=Lua::new();
-	lua.sandbox(true)?;
-	let lib_f=lua.load(SOURCE.as_str()).set_name("Trey-MinimumDifference").into_function()?;
-	let lib:mlua::Table=lib_f.call(())?;
-	let f=lib.raw_get("difference")?;
-	Ok(Ctx{lua,f})
-}

engine/physics/src/model.rs

@@ -91,6 +91,7 @@ pub trait MeshQuery{
 		(self.vert(v1)-self.vert(v0))*((directed_edge_id.parity() as i64)*2-1)
 	}
 	/// This must return a point inside the mesh.
+	#[expect(dead_code)]
 	fn hint_point(&self)->Planar64Vec3;
 	fn farthest_vert(&self,dir:Planar64Vec3)->Self::Vert;
 	fn vert(&self,vert_id:Self::Vert)->Planar64Vec3;
@@ -103,17 +104,21 @@ pub trait MeshQuery{
 }
 #[derive(Debug)]
 struct FaceRefs{
+	// I didn't write it down, but I assume the edges are directed
+	// clockwise when looking towards the face normal, i.e. right hand rule.
 	edges:Vec<SubmeshDirectedEdgeId>,
+	//verts are redundant, use edge[i].verts[0]
 	//verts:Vec<VertId>,
 }
 #[derive(Debug)]
 struct EdgeRefs{
 	faces:[SubmeshFaceId;2],//left, right
-	verts:[SubmeshVertId;2],//bottom, top
+	verts:[SubmeshVertId;2],//start, end
 }
 #[derive(Debug)]
 struct VertRefs{
 	faces:Vec<SubmeshFaceId>,
+	// edges are always directed away from the vert
 	edges:Vec<SubmeshDirectedEdgeId>,
 }
 #[derive(Debug)]
@@ -522,6 +527,9 @@ impl TransformedMesh<'_>{
 	pub fn verts<'a>(&'a self)->impl Iterator<Item=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)
+	}
 }
 impl MeshQuery for TransformedMesh<'_>{
 	type Face=SubmeshFaceId;
@@ -641,8 +649,8 @@ pub enum MinkowskiFace{
 
 #[derive(Debug)]
 pub struct MinkowskiMesh<'a>{
-	pub mesh0:TransformedMesh<'a>,
+	mesh0:TransformedMesh<'a>,
-	pub mesh1:TransformedMesh<'a>,
+	mesh1:TransformedMesh<'a>,
 }
 
 pub type GigaTime=Ratio<Fixed<4,128>,Fixed<4,128>>;
@@ -672,8 +680,14 @@ impl MinkowskiMesh<'_>{
 		fev.crawl(self,relative_body,range.start_bound(),range.end_bound()).hit()
 	}
 	pub fn predict_collision_out(&self,relative_body:&Body,range:impl RangeBounds<Time>)->Option<(MinkowskiFace,GigaTime)>{
-		let fev=crate::minimum_difference::closest_fev_not_inside(self,relative_body.position)?;
 		let (lower_bound,upper_bound)=(range.start_bound(),range.end_bound());
+		// TODO: handle unbounded collision using infinity fev
+		let time=match upper_bound{
+			Bound::Included(&time)=>time,
+			Bound::Excluded(&time)=>time,
+			Bound::Unbounded=>unimplemented!("unbounded collision out"),
+		};
+		let fev=crate::minimum_difference::closest_fev_not_inside(self,relative_body.extrapolated_position(time))?;
 		// swap and negate bounds to do a time inversion
 		let (lower_bound,upper_bound)=(upper_bound.map(|&t|-t),lower_bound.map(|&t|-t));
 		let infinity_body=-relative_body;

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;
@@ -286,7 +287,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)
 	}
 	#[expect(dead_code)]
@@ -997,6 +999,45 @@ impl PhysicsData{
 			hitbox_mesh:StyleModifiers::default().calculate_mesh(),
 		}
 	}
+	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
+			let faces=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;
+				Some((face_id,t,n))
+			});
+			let mut min=None;
+			for (face_id,t,n) in faces{
+				if let Some(min)=min&&min<t{
+					continue;
+				}
+				// check if point of intersection is behind face edges
+				// *2 because average of 2 vertices
+				let p=ray.extrapolate(t)*2;
+				let is_inside_face=mesh.face_edges(face_id).as_ref().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))
+				});
+				if is_inside_face{
+					min=Some(t);
+				}
+			}
+			min.map(Into::into)
+		})?;
+		Some(convex_mesh_id.model_id.into())
+	}
 	pub fn new(map:&map::CompleteMap)->Self{
 		let modes=map.modes.clone().denormalize();
 		let mut used_contact_attributes=Vec::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<ModelId>,
 }
 
 pub struct Simulation{
@@ -77,11 +79,12 @@ 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,
 		}
 	}
 }
@@ -161,6 +164,7 @@ pub struct Session{
 	recording:Recording,
 	//players:HashMap<PlayerId,Simulation>,
 	replays:HashMap<BotId,Replay>,
+	last_ray_hit:Option<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,25 @@ 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;
+			}
+		}
+	}
 	pub fn user_settings(&self)->&UserSettings{
 		&self.user_settings
 	}

lib/fixed_wide/src/fixed.rs

@@ -366,7 +366,7 @@ impl_additive_operator!( Fixed, BitXor, bitxor, Self );
 // non-wide operators.  The result is the same width as the inputs.
 
 // This macro is not used in the default configuration.
-#[allow(unused_macros)]
+#[expect(unused_macros)]
 macro_rules! impl_multiplicative_operator_not_const_generic {
 	( ($struct: ident, $trait: ident, $method: ident, $output: ty ), $width:expr ) => {
 		impl<const F:usize> core::ops::$trait for $struct<$width,F>{
@@ -545,7 +545,7 @@ impl_shift_operator!( Fixed, Shr, shr, Self );
 
 // wide operators.  The result width is the sum of the input widths, i.e. none of the multiplication
 
-#[allow(unused_macros)]
+#[expect(unused_macros)]
 macro_rules! impl_wide_operators{
 	($lhs:expr,$rhs:expr)=>{
 		impl core::ops::Mul<Fixed<$rhs,{$rhs*32}>> for Fixed<$lhs,{$lhs*32}>{

lib/rbx_loader/Cargo.toml

@@ -13,16 +13,16 @@ authors = ["Rhys Lloyd <krakow20@gmail.com>"]
 bytemuck = "1.14.3"
 glam = "0.30.0"
 regex = { version = "1.11.3", default-features = false }
-rbx_binary = { version = "1.0.1-sn5", registry = "strafesnet" }
-rbx_dom_weak =  { version = "3.0.1-sn5", registry = "strafesnet" }
 rbx_mesh = "0.5.0"
-rbx_reflection = "5.0.0"
-rbx_reflection_database = "1.0.0"
-rbx_xml = { version = "1.0.1-sn5", registry = "strafesnet" }
 rbxassetid = { version = "0.1.0", path = "../rbxassetid", registry = "strafesnet" }
 roblox_emulator = { version = "0.5.1", path = "../roblox_emulator", default-features = false, registry = "strafesnet" }
 strafesnet_common = { version = "0.7.0", path = "../common", registry = "strafesnet" }
 strafesnet_deferred_loader = { version = "0.5.1", path = "../deferred_loader", registry = "strafesnet" }
+rbx_binary = "2.0.1"
+rbx_dom_weak = "4.1.0"
+rbx_reflection = "6.1.0"
+rbx_reflection_database = "2.0.2"
+rbx_xml = "2.0.1"
 
 [lints]
 workspace = true

lib/rbx_loader/src/rbx.rs

@@ -559,7 +559,7 @@ pub fn convert<'a>(
 	//just going to leave it like this for now instead of reworking the data structures for this whole thing
 	let textureless_render_group=render_config_deferred_loader.acquire_render_config_id(None);
 
-	let db=rbx_reflection_database::get();
+	let db=rbx_reflection_database::get().unwrap();
 	let basepart=&db.classes["BasePart"];
 	let baseparts=dom.descendants().filter(|&instance|
 		db.classes.get(instance.class.as_str()).is_some_and(|class|

lib/roblox_emulator/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "roblox_emulator"
-version = "0.5.1"
+version = "0.5.2"
 edition = "2024"
 repository = "https://git.itzana.me/StrafesNET/strafe-project"
 license = "MIT OR Apache-2.0"
@@ -15,10 +15,10 @@ run-service=[]
 glam = "0.30.0"
 mlua = { version = "0.11.3", features = ["luau"] }
 phf = { version = "0.13.1", features = ["macros"] }
-rbx_dom_weak = { version = "3.0.1-sn5", registry = "strafesnet" }
+rbx_dom_weak = "4.1.0"
-rbx_reflection = "5.0.0"
+rbx_reflection = "6.1.0"
-rbx_reflection_database = "1.0.0"
+rbx_reflection_database = "2.0.2"
-rbx_types = "2.0.0"
+rbx_types = "3.1.0"
 
 [lints]
 workspace = true

lib/roblox_emulator/src/context.rs

@@ -52,7 +52,7 @@ impl Context{
 	}
 	/// Creates an iterator over all items of a particular class.
 	pub fn superclass_iter<'a>(&'a self,superclass:&'a str)->impl Iterator<Item=Ref>+'a{
-		let db=rbx_reflection_database::get();
+		let db=rbx_reflection_database::get().unwrap();
 		let Some(superclass)=db.classes.get(superclass)else{
 			panic!("Invalid class");
 		};

lib/roblox_emulator/src/runner/enum.rs

@@ -37,7 +37,7 @@ impl PartialEq for EnumItem<'_>{
 pub struct Enums;
 impl Enums{
 	pub fn get(&self,index:&str)->Option<EnumItems<'static>>{
-		let db=rbx_reflection_database::get();
+		let db=rbx_reflection_database::get().unwrap();
 		db.enums.get(index).map(|ed|EnumItems{ed})
 	}
 }

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

@@ -37,7 +37,7 @@ pub fn dom_mut<T>(lua:&mlua::Lua,mut f:impl FnMut(&mut WeakDom)->mlua::Result<T>
 }
 
 pub fn class_is_a(class:&str,superclass:&str)->bool{
-	let db=rbx_reflection_database::get();
+	let db=rbx_reflection_database::get().unwrap();
 	let (Some(class),Some(superclass))=(db.classes.get(class),db.classes.get(superclass))else{
 		return false;
 	};
@@ -80,14 +80,14 @@ pub fn find_first_descendant_of_class<'a>(dom:&'a WeakDom,instance:&rbx_dom_weak
 }
 
 pub fn find_first_child_which_is_a<'a>(dom:&'a WeakDom,instance:&rbx_dom_weak::Instance,superclass:&str)->Option<&'a rbx_dom_weak::Instance>{
-	let db=rbx_reflection_database::get();
+	let db=rbx_reflection_database::get().unwrap();
 	let superclass_descriptor=db.classes.get(superclass)?;
 	instance.children().iter().filter_map(|&r|dom.get_by_ref(r)).find(|inst|{
 		db.classes.get(inst.class.as_str()).is_some_and(|descriptor|db.has_superclass(descriptor,superclass_descriptor))
 	})
 }
 pub fn find_first_descendant_which_is_a<'a>(dom:&'a WeakDom,instance:&rbx_dom_weak::Instance,superclass:&str)->Option<&'a rbx_dom_weak::Instance>{
-	let db=rbx_reflection_database::get();
+	let db=rbx_reflection_database::get().unwrap();
 	let superclass_descriptor=db.classes.get(superclass)?;
 	dom.descendants_of(instance.referent()).find(|inst|{
 		db.classes.get(inst.class.as_str()).is_some_and(|descriptor|db.has_superclass(descriptor,superclass_descriptor))
@@ -282,7 +282,7 @@ impl mlua::UserData for Instance{
 			dom_mut(lua,|dom|{
 				let instance=this.get(dom)?;
 				//println!("__index t={} i={index:?}",instance.name);
-				let db=rbx_reflection_database::get();
+				let db=rbx_reflection_database::get().unwrap();
 				let class=db.classes.get(instance.class.as_str()).ok_or_else(||mlua::Error::runtime("Class missing"))?;
 				// Find existing property
 				// Interestingly, ustr can know ahead of time if
@@ -344,7 +344,7 @@ impl mlua::UserData for Instance{
 			let index_str=&*index.to_str()?;
 			dom_mut(lua,|dom|{
 				let instance=this.get_mut(dom)?;
-				let db=rbx_reflection_database::get();
+				let db=rbx_reflection_database::get().unwrap();
 				let class=db.classes.get(instance.class.as_str()).ok_or_else(||mlua::Error::runtime("Class missing"))?;
 				let property=db.superclasses_iter(class).find_map(|cls|
 					cls.properties.get(index_str)

map-tool/Cargo.toml

@@ -13,10 +13,10 @@ futures = "0.3.31"
 image = "0.25.2"
 image_dds = "0.7.1"
 rbx_asset = { version = "0.5.0", registry = "strafesnet" }
-rbx_binary  = { version = "1.0.1-sn5", registry = "strafesnet" }
+rbx_binary = "2.0.1"
-rbx_dom_weak =  { version = "3.0.1-sn5", registry = "strafesnet" }
+rbx_dom_weak = "4.1.0"
-rbx_reflection_database = "1.0.0"
+rbx_reflection_database = "2.0.2"
-rbx_xml = { version = "1.0.1-sn5", registry = "strafesnet" }
+rbx_xml = "2.0.1"
 rbxassetid = { version = "0.1.0", registry = "strafesnet" }
 strafesnet_bsp_loader = { version = "0.3.1", path = "../lib/bsp_loader", registry = "strafesnet" }
 strafesnet_deferred_loader = { version = "0.5.1", path = "../lib/deferred_loader", registry = "strafesnet" }

strafe-client/Cargo.toml

@@ -28,7 +28,7 @@ strafesnet_rbx_loader = { path = "../lib/rbx_loader", registry = "strafesnet", o
 strafesnet_session = { path = "../engine/session", registry = "strafesnet" }
 strafesnet_settings = { path = "../engine/settings", registry = "strafesnet" }
 strafesnet_snf = { path = "../lib/snf", registry = "strafesnet", optional = true }
-wgpu = "27.0.0"
+wgpu = "28.0.0"
 winit = "0.30.7"
 
 [profile.dev]

strafe-client/src/physics_worker.rs

@@ -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/setup.rs

@@ -52,7 +52,7 @@ impl<'a> SetupContextPartial2<'a>{
 		let required_features=required_features();
 
 		//no helper function smh gotta write it myself
-		let adapters=self.instance.enumerate_adapters(self.backends);
+		let adapters=pollster::block_on(self.instance.enumerate_adapters(self.backends));
 
 		let mut chosen_adapter=None;
 		let mut chosen_adapter_score=0;

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;
+}