the bug

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

Cargo.lock

@@ -3893,7 +3893,6 @@ dependencies = [
  "id",
  "strafesnet_common",
  "strafesnet_physics",
- "strafesnet_rbx_loader",
  "strafesnet_session",
  "strafesnet_settings",
  "wgpu",

engine/graphics/Cargo.toml

@@ -10,7 +10,6 @@ glam = "0.30.0"
 id = { version = "0.1.0", registry = "strafesnet" }
 strafesnet_common = { path = "../../lib/common", registry = "strafesnet" }
 strafesnet_physics = { path = "../physics", registry = "strafesnet" }
-strafesnet_rbx_loader = { path = "../../lib/rbx_loader", registry = "strafesnet" }
 strafesnet_session = { path = "../session", registry = "strafesnet" }
 strafesnet_settings = { path = "../settings", registry = "strafesnet" }
 wgpu = "28.0.0"

engine/graphics/src/graphics.rs

@@ -8,17 +8,7 @@ use wgpu::{util::DeviceExt,AstcBlock,AstcChannel};
 use crate::model::{self as model_graphics,IndexedGraphicsMeshOwnedRenderConfig,IndexedGraphicsMeshOwnedRenderConfigId,GraphicsMeshOwnedRenderConfig,GraphicsModelColor4,GraphicsModelOwned,GraphicsVertex,DebugGraphicsVertex};
 
 pub fn required_limits()->wgpu::Limits{
-	let mut limits=wgpu::Limits::default();
-	limits.max_task_invocations_per_dimension=1;
-	limits.max_task_invocations_per_workgroup=1;
-	limits.max_mesh_invocations_per_dimension=1;
-	limits.max_mesh_invocations_per_workgroup=1;
-	limits.max_task_mesh_workgroup_total_count=1;
-	limits.max_task_mesh_workgroups_per_dimension=1;
-	limits.max_task_payload_size=4;
-	limits.max_mesh_output_vertices=2*(3+2+4+8);
-	limits.max_mesh_output_primitives=2*(1+2+4+8)+2;
-	limits
+	wgpu::Limits::default()
 }
 
 struct Indices{
@@ -48,124 +38,17 @@ struct GraphicsModel{
 
 struct DebugGraphicsSubmesh{
 	verts:Vec<strafesnet_physics::model::MeshVertId>,
-	edges:Vec<[strafesnet_physics::model::MeshVertId;2]>,
+	edges:Vec<Indices>,
 	faces:Vec<Indices>,
 }
 struct DebugGraphicsMesh{
-	vertices:Vec<DebugGraphicsVertex>,
-	indices:Indices,
+	verts:Indices,
 	submeshes:Vec<DebugGraphicsSubmesh>,
 	vertex_buf:wgpu::Buffer,
 }
-impl DebugGraphicsMesh{
-	fn new(device:&wgpu::Device,mesh:&model::Mesh)->Self{
-		let vertices:Vec<DebugGraphicsVertex>=mesh.unique_pos.iter().copied().map(|pos|{
-			DebugGraphicsVertex{
-				pos:pos.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,
-		});
-
-		macro_rules! indices{
-			($indices:expr)=>{
-				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)
-				}
-			};
-		}
-
-
-		let mut all_indices=Vec::new();
-
-		let submeshes=if let Ok(physics_mesh)=strafesnet_physics::model::PhysicsMesh::try_from(mesh){
-			physics_mesh.submesh_views().into_iter().map(|submesh_view|DebugGraphicsSubmesh{
-				verts:submesh_view.verts().to_owned(),
-				edges:submesh_view.edge_vert_ids_iter().collect(),
-				faces:submesh_view.face_vert_ids_iter().map(|face_verts|{
-					// triangulate
-					let mut indices=Vec::new();
-					let mut poly_vertices=face_verts.into_iter();
-					if let (Some(a),Some(mut b))=(poly_vertices.next(),poly_vertices.next()){
-						for c in poly_vertices{
-							indices.extend([a,b,c]);
-							all_indices.extend([a,b,c]);
-							b=c;
-						}
-					}
-					indices!(indices)
-				}).collect(),
-			}).collect()
-		}else{
-			//idc
-			Vec::new()
-		};
-
-		let indices=indices!(all_indices);
-
-		DebugGraphicsMesh{
-			vertices,
-			indices,
-			submeshes,
-			vertex_buf,
-		}
-	}
-}
-
 struct DebugGraphicsModel{
 	debug_mesh_id:u32,
 	bind_group:wgpu::BindGroup,
-	// 32 bytes used to tell the mesh shader where to draw
-	// Vert: [vec4,_]
-	// Edge: [vec4,vec4]
-	debug_buf:wgpu::Buffer,
-	model_buf:wgpu::Buffer,
-}
-impl DebugGraphicsModel{
-	fn new(device:&wgpu::Device,layout:&wgpu::BindGroupLayout,model:&model::Model,model_id:usize,color:glam::Vec4)->Self{
-		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(color),
-		}]);
-		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 debug_buf=device.create_buffer_init(&wgpu::util::BufferInitDescriptor{
-			label:Some(format!("Debug Model{} EV Buf",model_id).as_str()),
-			contents:bytemuck::cast_slice(&[0u8;32]),
-			usage:wgpu::BufferUsages::UNIFORM|wgpu::BufferUsages::COPY_DST,
-		});
-		let bind_group=device.create_bind_group(&wgpu::BindGroupDescriptor{
-			layout,
-			entries:&[
-				wgpu::BindGroupEntry{
-					binding:0,
-					resource:model_buf.as_entire_binding(),
-				},
-				wgpu::BindGroupEntry{
-					binding:1,
-					resource:debug_buf.as_entire_binding(),
-				},
-			],
-			label:Some(format!("Debug Model{} Bind Group",model_id).as_str()),
-		});
-		DebugGraphicsModel{
-			debug_mesh_id:model.mesh.get(),
-			bind_group,
-			debug_buf,
-			model_buf,
-		}
-	}
 }
 
 struct GraphicsSamplers{
@@ -185,7 +68,7 @@ struct GraphicsBindGroups{
 struct GraphicsPipelines{
 	skybox:wgpu::RenderPipeline,
 	model:wgpu::RenderPipeline,
-	debug:wgpu::RenderPipeline,
+	debug_face:wgpu::RenderPipeline,
 	debug_edge:wgpu::RenderPipeline,
 	debug_vert:wgpu::RenderPipeline,
 }
@@ -270,8 +153,6 @@ pub struct GraphicsState{
 	models:Vec<GraphicsModel>,
 	debug_meshes:Vec<DebugGraphicsMesh>,
 	debug_models:Vec<DebugGraphicsModel>,
-	hitbox_mesh:DebugGraphicsMesh,
-	hitbox_model:DebugGraphicsModel,
 	depth_view:wgpu::TextureView,
 	staging_belt:wgpu::util::StagingBelt,
 }
@@ -307,13 +188,85 @@ impl GraphicsState{
 	}
 	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|
-			DebugGraphicsMesh::new(device,mesh)
-		).collect();
+		self.debug_meshes=map.meshes.iter().map(|mesh|{
+			let vertices:Vec<DebugGraphicsVertex>=mesh.unique_pos.iter().copied().map(|pos|{
+				DebugGraphicsVertex{
+					pos:pos.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,
+			});
+
+			macro_rules! indices{
+				($indices:expr)=>{
+					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)
+					}
+				};
+			}
+
+			let submeshes=if let Ok(physics_mesh)=strafesnet_physics::model::PhysicsMesh::try_from(mesh){
+				physics_mesh.submesh_views().into_iter().map(|submesh_view|DebugGraphicsSubmesh{
+					verts:submesh_view.verts().to_owned(),
+					edges:submesh_view.edge_vert_ids_iter().map(|edge_verts|indices!(edge_verts)).collect(),
+					faces:submesh_view.face_vert_ids_iter().map(|face_verts|{
+						// triangulate
+						let mut indices=Vec::new();
+						let mut poly_vertices=face_verts.into_iter();
+						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;
+							}
+						}
+						indices!(indices)
+					}).collect(),
+				}).collect()
+			}else{
+				//idc
+				Vec::new()
+			};
+
+			DebugGraphicsMesh{
+				verts:indices!((0..vertices.len() as u32).map(strafesnet_physics::model::MeshVertId::new)),
+				submeshes,
+				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)|{
-			DebugGraphicsModel::new(device,&self.bind_group_layouts.debug_model,model,model_id,glam::vec4(1.0,0.0,0.0,0.2))
+			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
@@ -696,7 +649,7 @@ impl GraphicsState{
 			entries:&[
 				wgpu::BindGroupLayoutEntry{
 					binding:0,
-					visibility:wgpu::ShaderStages::VERTEX|wgpu::ShaderStages::MESH,
+					visibility:wgpu::ShaderStages::VERTEX,
 					ty:wgpu::BindingType::Buffer{
 						ty:wgpu::BufferBindingType::Uniform,
 						has_dynamic_offset:false,
@@ -763,17 +716,7 @@ impl GraphicsState{
 			entries:&[
 				wgpu::BindGroupLayoutEntry{
 					binding:0,
-					visibility:wgpu::ShaderStages::VERTEX_FRAGMENT|wgpu::ShaderStages::MESH,
-					ty:wgpu::BindingType::Buffer{
-						ty:wgpu::BufferBindingType::Uniform,
-						has_dynamic_offset:false,
-						min_binding_size:None,
-					},
-					count:None,
-				},
-				wgpu::BindGroupLayoutEntry{
-					binding:1,
-					visibility:wgpu::ShaderStages::MESH,
+					visibility:wgpu::ShaderStages::VERTEX_FRAGMENT,
 					ty:wgpu::BindingType::Buffer{
 						ty:wgpu::BufferBindingType::Uniform,
 						has_dynamic_offset:false,
@@ -937,7 +880,7 @@ impl GraphicsState{
 					&camera_bind_group_layout,
 					&debug_model_bind_group_layout,
 				],
-				immediate_size:0,
+				push_constant_ranges:&[],
 			});
 		let sky_pipeline_layout=device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor{
 			label:None,
@@ -1014,8 +957,8 @@ impl GraphicsState{
 			multiview_mask:None,
 			cache:None,
 		});
-		let debug_model_pipeline=device.create_render_pipeline(&wgpu::RenderPipelineDescriptor{
-			label:Some("Debug Pipeline"),
+		let mut debug_model_pipeline=wgpu::RenderPipelineDescriptor{
+			label:None,
 			layout:Some(&debug_model_pipeline_layout),
 			vertex:wgpu::VertexState{
 				module:&shader,
@@ -1038,51 +981,10 @@ impl GraphicsState{
 				compilation_options:wgpu::PipelineCompilationOptions::default(),
 			}),
 			primitive:wgpu::PrimitiveState{
-				topology:wgpu::PrimitiveTopology::TriangleList,
 				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::LessEqual,
-				stencil:wgpu::StencilState::default(),
-				bias:wgpu::DepthBiasState::default(),
-			}),
-			multisample:wgpu::MultisampleState::default(),
-			multiview_mask:None,
-			cache:None,
-		});
-		let mut debug_model_pipeline_ms=wgpu::MeshPipelineDescriptor{
-			label:None,//filled in below
-			layout:Some(&debug_model_pipeline_layout),
-			task:Some(wgpu::TaskState{
-				module:&shader,
-				entry_point:Some("ts_main"),
-				compilation_options:wgpu::PipelineCompilationOptions::default(),
-			}),
-			mesh:wgpu::MeshState{
-				module:&shader,
-				entry_point:None,//filled in below
-				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{
-				topology:wgpu::PrimitiveTopology::TriangleList,
-				front_face:wgpu::FrontFace::Cw,
-				cull_mode:None,
-				..Default::default()
-			},
 			depth_stencil:Some(wgpu::DepthStencilState{
 				format:Self::DEPTH_FORMAT,
 				depth_write_enabled:true,
@@ -1094,12 +996,15 @@ impl GraphicsState{
 			multiview:None,
 			cache:None,
 		};
-		debug_model_pipeline_ms.label=Some("Debug Vert Pipeline");
-		debug_model_pipeline_ms.mesh.entry_point=Some("ms_debug_vert");
-		let debug_model_pipeline_vert=device.create_mesh_pipeline(&debug_model_pipeline_ms);
-		debug_model_pipeline_ms.label=Some("Debug Edge Pipeline");
-		debug_model_pipeline_ms.mesh.entry_point=Some("ms_debug_edge");
-		let debug_model_pipeline_edge=device.create_mesh_pipeline(&debug_model_pipeline_ms);
+		debug_model_pipeline.label=Some("Debug Face Pipeline");
+		debug_model_pipeline.primitive.topology=wgpu::PrimitiveTopology::TriangleList;
+		let debug_model_pipeline_face=device.create_render_pipeline(&debug_model_pipeline);
+		debug_model_pipeline.label=Some("Debug Edge Pipeline");
+		debug_model_pipeline.primitive.topology=wgpu::PrimitiveTopology::LineList;
+		let debug_model_pipeline_edge=device.create_render_pipeline(&debug_model_pipeline);
+		debug_model_pipeline.label=Some("Debug Vert Pipeline");
+		debug_model_pipeline.primitive.topology=wgpu::PrimitiveTopology::PointList;
+		let debug_model_pipeline_vert=device.create_render_pipeline(&debug_model_pipeline);
 
 		let camera=GraphicsCamera::default();
 		let camera_uniforms=camera.to_uniform_data(glam::Vec3::ZERO,glam::Vec2::ZERO);
@@ -1136,21 +1041,11 @@ impl GraphicsState{
 
 		let depth_view=Self::create_depth_texture(config,device);
 
-		// WHIP UP A CUBE
-		let cube_face_description=strafesnet_rbx_loader::primitives::CubeFaceDescription::new(Default::default(),RenderConfigId::new(0));
-		let hitbox_mesh=DebugGraphicsMesh::new(device,&strafesnet_rbx_loader::primitives::unit_cube(cube_face_description));
-		let hitbox_model=DebugGraphicsModel::new(device,&debug_model_bind_group_layout,&model::Model{
-			mesh:model::MeshId::new(u32::MAX),
-			attributes:strafesnet_common::gameplay_attributes::CollisionAttributesId::new(0),
-			color:glam::Vec4::new(0.0,0.0,1.0,0.2),
-			transform:strafesnet_common::integer::Planar64Affine3::IDENTITY,
-		},u32::MAX as usize,glam::vec4(0.0,1.0,0.0,0.2));
-
 		Self{
 			pipelines:GraphicsPipelines{
 				skybox:sky_pipeline,
 				model:model_pipeline,
-				debug:debug_model_pipeline,
+				debug_face:debug_model_pipeline_face,
 				debug_edge:debug_model_pipeline_edge,
 				debug_vert:debug_model_pipeline_vert,
 			},
@@ -1163,8 +1058,6 @@ impl GraphicsState{
 			models:Vec::new(),
 			debug_meshes:Vec::new(),
 			debug_models:Vec::new(),
-			hitbox_mesh,
-			hitbox_model,
 			depth_view,
 			staging_belt:wgpu::util::StagingBelt::new(device.clone(),0x100),
 			bind_group_layouts:GraphicsBindGroupLayouts{
@@ -1224,66 +1117,6 @@ impl GraphicsState{
 				.copy_from_slice(bytemuck::cast_slice(&model_uniforms));
 		}
 		*/
-
-		// update hitbox mesh transform
-		if let Some(debug_hitbox_position)=frame_state.debug_hitbox_position{
-			let model_uniforms=get_instances_buffer_data(&[GraphicsModelOwned{
-				transform:debug_hitbox_position.into(),
-				normal_transform:glam::Mat3::IDENTITY,
-				color:GraphicsModelColor4::new(glam::vec4(1.0,0.0,0.0,0.2)),
-			}]);
-			let debug_slice=bytemuck::cast_slice(&model_uniforms);
-			self.staging_belt.write_buffer(
-				&mut encoder,
-				&self.hitbox_model.model_buf,
-				0,
-				wgpu::BufferSize::new(debug_slice.len() as wgpu::BufferAddress).unwrap(),
-			).copy_from_slice(debug_slice);
-		}
-
-		// upload the edge or vertex for the mesh shader to highlight
-		if let Some(hit)=&frame_state.hit{
-			if let Some(closest_fev)=&hit.closest_fev{
-				let model_id:model::ModelId=hit.convex_mesh_id.model_id.into();
-				if let Some(model)=self.debug_models.get(model_id.get() as usize){
-					let mesh=&self.debug_meshes[model.debug_mesh_id as usize];
-					match closest_fev{
-						strafesnet_physics::model::FEV::Face(_face)=>{
-							// face is rendered normally
-						},
-						strafesnet_physics::model::FEV::Edge(edge)=>{
-							let [v0_id,v1_id]=mesh.submeshes[hit.convex_mesh_id.submesh_id.get() as usize].edges[edge.get() as usize];
-							let v0_pos=mesh.vertices[v0_id.get() as usize].pos;
-							let v1_pos=mesh.vertices[v1_id.get() as usize].pos;
-							let debug_data=[glam::Vec3A::from_array(v0_pos).extend(1.0).to_array(),glam::Vec3A::from_array(v1_pos).extend(1.0).to_array()];
-							let debug_slice=bytemuck::cast_slice(&debug_data);
-							self.staging_belt
-								.write_buffer(
-									&mut encoder,
-									&model.debug_buf,
-									0,
-									wgpu::BufferSize::new(debug_slice.len() as wgpu::BufferAddress).unwrap(),
-								)
-								.copy_from_slice(debug_slice);
-						},
-						strafesnet_physics::model::FEV::Vert(vert)=>{
-							let vert_id=mesh.submeshes[hit.convex_mesh_id.submesh_id.get() as usize].verts[vert.get() as usize].get();
-							let pos=mesh.vertices[vert_id as usize].pos;
-							let debug_data=[glam::Vec3A::from_array(pos).extend(1.0).to_array()];
-							let debug_slice=bytemuck::cast_slice(&debug_data);
-							self.staging_belt
-								.write_buffer(
-									&mut encoder,
-									&model.debug_buf,
-									0,
-									wgpu::BufferSize::new(debug_slice.len() as wgpu::BufferAddress).unwrap(),
-								)
-								.copy_from_slice(debug_slice);
-						},
-					}
-				}
-			}
-		}
 		self.staging_belt.finish();
 
 		{
@@ -1333,7 +1166,7 @@ impl GraphicsState{
 			rpass.draw(0..3,0..1);
 
 			// render a single debug_model in red
-			if let Some(hit)=&frame_state.hit{
+			if let Some(hit)=frame_state.hit{
 				if let Some(closest_fev)=&hit.closest_fev{
 					let model_id:model::ModelId=hit.convex_mesh_id.model_id.into();
 					if let Some(model)=self.debug_models.get(model_id.get() as usize){
@@ -1342,35 +1175,29 @@ impl GraphicsState{
 						rpass.set_vertex_buffer(0,mesh.vertex_buf.slice(..));
 						match closest_fev{
 							strafesnet_physics::model::FEV::Face(face)=>{
-								rpass.set_pipeline(&self.pipelines.debug);
+								rpass.set_pipeline(&self.pipelines.debug_face);
 								let indices=&mesh.submeshes[hit.convex_mesh_id.submesh_id.get() as usize].faces[face.get() as usize];
 								rpass.set_index_buffer(indices.buf.slice(..),indices.format);
 								//TODO: loop over triangle strips
 								rpass.draw_indexed(0..indices.count,0,0..1);
 							},
-							strafesnet_physics::model::FEV::Edge(_edge)=>{
+							strafesnet_physics::model::FEV::Edge(edge)=>{
 								rpass.set_pipeline(&self.pipelines.debug_edge);
-								// the data has already been primed by the staging belt
-								rpass.draw_mesh_tasks(1, 1, 1);
+								let indices=&mesh.submeshes[hit.convex_mesh_id.submesh_id.get() as usize].edges[edge.get() as usize];
+								rpass.set_index_buffer(indices.buf.slice(..),indices.format);
+								rpass.draw_indexed(0..indices.count,0,0..1);
 							},
-							strafesnet_physics::model::FEV::Vert(_vert)=>{
+							strafesnet_physics::model::FEV::Vert(vert)=>{
 								rpass.set_pipeline(&self.pipelines.debug_vert);
-								// the data has already been primed by the staging belt
-								rpass.draw_mesh_tasks(1, 1, 1);
+								let indices=&mesh.verts;
+								rpass.set_index_buffer(indices.buf.slice(..),indices.format);
+								let vert_id=mesh.submeshes[hit.convex_mesh_id.submesh_id.get() as usize].verts[vert.get() as usize].get();
+								rpass.draw_indexed(0..1,vert_id as i32,0..1);
 							},
 						}
 					}
 				}
 			}
-
-			if frame_state.debug_hitbox_position.is_some(){
-				rpass.set_bind_group(1,&self.hitbox_model.bind_group,&[]);
-				rpass.set_vertex_buffer(0,self.hitbox_mesh.vertex_buf.slice(..));
-				rpass.set_pipeline(&self.pipelines.debug);
-				rpass.set_index_buffer(self.hitbox_mesh.indices.buf.slice(..),self.hitbox_mesh.indices.format);
-				//TODO: loop over triangle strips
-				rpass.draw_indexed(0..self.hitbox_mesh.indices.count,0,0..1);
-			}
 		}
 
 		queue.submit(std::iter::once(encoder.finish()));

engine/physics/src/face_crawler.rs

@@ -15,12 +15,6 @@ pub enum CrawlResult<M:MeshQuery>{
 	Hit(M::Face,GigaTime),
 }
 impl<M:MeshQuery> CrawlResult<M>{
-	pub fn fev(self)->FEV<M>{
-		match self{
-			CrawlResult::Miss(fev)=>fev,
-			CrawlResult::Hit(face,_)=>FEV::Face(face),
-		}
-	}
 	pub fn hit(self)->Option<(M::Face,GigaTime)>{
 		match self{
 			CrawlResult::Miss(_)=>None,

engine/physics/src/minimum_difference.rs

@@ -367,8 +367,8 @@ fn reduce4<M:MeshQuery>(
 
 	// if pvw/uvw >= 0 and upw/uvw >= 0 and uvp/uvw >= 0 then
 	if !pv_w.div_sign(uv_w).is_negative()
-	 &&!up_w.div_sign(uv_w).is_negative()
-	 &&!uv_p.div_sign(uv_w).is_negative(){
+	 ||!up_w.div_sign(uv_w).is_negative()
+	 ||!uv_p.div_sign(uv_w).is_negative(){
 		// origin is contained, this is a positive detection
 		// local direction = Vector3.new(0, 0, 0)
 		// return direction, a0, a1, b0, b1, c0, c1, d0, d1
@@ -396,6 +396,8 @@ fn reduce4<M:MeshQuery>(
 			// b0, c0 = c0, d0
 			// b1, c1 = c1, d1
 			(v1,v2)=(v2,v3);
+		}else{
+			v2=v3;
 		}
 	}else{
 		// elseif wuDist == minDist3 then
@@ -408,6 +410,8 @@ fn reduce4<M:MeshQuery>(
 			// before [a,b,c,d]
 			(v1,v2)=(v3,v1);
 			// after [a,d,b]
+		}else{
+			v2=v3;
 		}
 	}
 
@@ -424,15 +428,17 @@ fn reduce4<M:MeshQuery>(
 	if !uv_up.is_negative()&&!uv_pv.is_negative(){
 		// local direction = uvw < 0 and uv or -uv
 		// return direction, a0, a1, b0, b1, c0, c1
-		let dir=if uv_w.is_negative(){
-			narrow_dir2(uv)
+		if uv_w.is_negative(){
+			return Reduce::Reduced(Reduced{
+				dir:narrow_dir2(uv),
+				simplex:Simplex1_3::Simplex3([v0,v1,v2]),
+			});
 		}else{
-			narrow_dir2(-uv)
-		};
-		return Reduce::Reduced(Reduced{
-			dir,
-			simplex:Simplex1_3::Simplex3([v0,v1,v2]),
-		});
+			return Reduce::Reduced(Reduced{
+				dir:narrow_dir2(-uv),
+				simplex:Simplex1_3::Simplex3([v0,v1,v2]),
+			});
+		}
 	}
 
 	// local u_u = u:Dot(u)
@@ -464,15 +470,17 @@ fn reduce4<M:MeshQuery>(
 		if direction==vec3::zero(){
 			// direction = uvw < 0 and uv or -uv
 			// return direction, a0, a1, b0, b1
-			let dir=if uv_w.is_negative(){
-				narrow_dir2(uv)
+			if uv_w.is_negative(){
+				return Reduce::Reduced(Reduced{
+					dir:narrow_dir2(uv),
+					simplex:Simplex1_3::Simplex2([v0,v1]),
+				});
 			}else{
-				narrow_dir2(-uv)
-			};
-			return Reduce::Reduced(Reduced{
-				dir,
-				simplex:Simplex1_3::Simplex2([v0,v1]),
-			});
+				return Reduce::Reduced(Reduced{
+					dir:narrow_dir2(-uv),
+					simplex:Simplex1_3::Simplex2([v0,v1]),
+				});
+			}
 		}
 
 		// return direction, a0, a1, b0, b1
@@ -487,15 +495,17 @@ fn reduce4<M:MeshQuery>(
 	// if direction.magnitude == 0 then
 	if dir==vec3::zero(){
 		// direction = uvw < 0 and uv or -uv
-		let dir=if uv_w.is_negative(){
-			narrow_dir2(uv)
+		if uv_w.is_negative(){
+			return Reduce::Reduced(Reduced{
+				dir:narrow_dir2(uv),
+				simplex:Simplex1_3::Simplex1([v0]),
+			});
 		}else{
-			narrow_dir2(-uv)
-		};
-		return Reduce::Reduced(Reduced{
-			dir,
-			simplex:Simplex1_3::Simplex1([v0]),
-		});
+			return Reduce::Reduced(Reduced{
+				dir:narrow_dir2(-uv),
+				simplex:Simplex1_3::Simplex1([v0]),
+			});
+		}
 	}
 
 	// return direction, a0, a1
@@ -525,6 +535,24 @@ impl<Vert> Simplex2_4<Vert>{
 	}
 }
 
+pub fn contains_point(mesh:&MinkowskiMesh<'_>,point:Planar64Vec3)->bool{
+	const ENABLE_FAST_FAIL:bool=true;
+	// TODO: remove mesh negation
+	minimum_difference::<ENABLE_FAST_FAIL,_,_>(&-mesh,point,
+		// on_exact
+		|is_intersecting,_simplex|{
+			is_intersecting
+		},
+		// on_escape
+		|_simplex|{
+			// intersection is guaranteed at this point
+			true
+		},
+		// fast_fail value
+		||false
+	)
+}
+
 //infinity fev algorithm state transition
 #[derive(Debug)]
 enum Transition<Vert>{
@@ -740,7 +768,11 @@ pub fn closest_fev_not_inside<'a>(mesh:&MinkowskiMesh<'a>,point:Planar64Vec3)->O
 				Simplex1_3::Simplex2([v0,v1])=>{
 					// invert
 					let (v0,v1)=(-v0,-v1);
-					crawl_to_closest_ev(mesh,[v0,v1],point).into()
+					let ev=crawl_to_closest_ev(mesh,[v0,v1],point);
+					if !matches!(ev,EV::Edge(_)){
+						println!("I can't believe it's not an edge!");
+					}
+					ev.into()
 				},
 				Simplex1_3::Simplex3([v0,v1,v2])=>{
 					// invert
@@ -748,7 +780,11 @@ pub fn closest_fev_not_inside<'a>(mesh:&MinkowskiMesh<'a>,point:Planar64Vec3)->O
 					// Shimmy to the side until you find a face that contains the closest point
 					// it's ALWAYS representable as a face, but this algorithm may
 					// return E or V in edge cases but I don't think that will break the face crawler
-					crawl_to_closest_fev(mesh,[v0,v1,v2],point)
+					let fev=crawl_to_closest_fev(mesh,[v0,v1,v2],point);
+					if !matches!(fev,FEV::Face(_)){
+						println!("I can't believe it's not a face!");
+					}
+					fev
 				},
 			})
 		},
@@ -764,24 +800,6 @@ pub fn closest_fev_not_inside<'a>(mesh:&MinkowskiMesh<'a>,point:Planar64Vec3)->O
 	)
 }
 
-pub fn contains_point(mesh:&MinkowskiMesh<'_>,point:Planar64Vec3)->bool{
-	const ENABLE_FAST_FAIL:bool=true;
-	// TODO: remove mesh negation
-	minimum_difference::<ENABLE_FAST_FAIL,_,_>(&-mesh,point,
-		// on_exact
-		|is_intersecting,_simplex|{
-			is_intersecting
-		},
-		// on_escape
-		|_simplex|{
-			// intersection is guaranteed at this point
-			true
-		},
-		// fast_fail value
-		||false
-	)
-}
-
 // local function minimumDifference(
 // 	queryP, radiusP,
 // 	queryQ, radiusQ,

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;
@@ -618,7 +619,7 @@ impl core::ops::Neg for MinkowskiVert{
 		}
 	}
 }
-#[derive(Clone,Copy,Debug)]
+#[derive(Clone,Copy,Debug,Eq,PartialEq)]
 pub enum MinkowskiEdge{
 	VertEdge(SubmeshVertId,SubmeshEdgeId),
 	EdgeVert(SubmeshEdgeId,SubmeshVertId),
@@ -670,31 +671,6 @@ pub struct MinkowskiMesh<'a>{
 	mesh1:TransformedMesh<'a>,
 }
 
-impl FEV<MinkowskiMesh<'_>>{
-	pub fn mesh0<'a>(self)->FEV<TransformedMesh<'a>>{
-		match self{
-			FEV::Face(face)=>{
-				match face{
-					MinkowskiFace::VertFace(submesh_vert_id,_)=>FEV::Vert(submesh_vert_id),
-					MinkowskiFace::EdgeEdge(submesh_edge_id,..)=>FEV::Edge(submesh_edge_id),
-					MinkowskiFace::FaceVert(submesh_face_id,_)=>FEV::Face(submesh_face_id),
-				}
-			},
-			FEV::Edge(edge)=>{
-				match edge{
-					MinkowskiEdge::VertEdge(submesh_vert_id,_)=>FEV::Vert(submesh_vert_id),
-					MinkowskiEdge::EdgeVert(submesh_edge_id,_)=>FEV::Edge(submesh_edge_id),
-				}
-			},
-			FEV::Vert(vert)=>{
-				match vert{
-					MinkowskiVert::VertVert(submesh_vert_id,_)=>FEV::Vert(submesh_vert_id),
-				}
-			},
-		}
-	}
-}
-
 pub type GigaTime=Ratio<Fixed<4,128>,Fixed<4,128>>;
 pub fn into_giga_time(time:Time,relative_to:Time)->GigaTime{
 	let r=(time-relative_to).to_ratio();
@@ -717,24 +693,19 @@ impl MinkowskiMesh<'_>{
 		}
 	}
 	pub fn predict_collision_in(&self,relative_body:&Body,range:impl RangeBounds<Time>)->Option<(MinkowskiFace,GigaTime)>{
-		let start_position=match range.start_bound(){
-			Bound::Included(time)=>relative_body.extrapolated_position(*time),
-			Bound::Excluded(time)=>relative_body.extrapolated_position(*time),
-			Bound::Unbounded=>relative_body.position,
-		};
-		let fev=crate::minimum_difference::closest_fev_not_inside(self,start_position)?;
+		let fev=crate::minimum_difference::closest_fev_not_inside(self,relative_body.position)?;
 		//continue forwards along the body parabola
 		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 (lower_bound,upper_bound)=(range.start_bound(),range.end_bound());
 		// TODO: handle unbounded collision using infinity fev
-		let start_position=match upper_bound{
-			Bound::Included(time)=>relative_body.extrapolated_position(*time),
-			Bound::Excluded(time)=>relative_body.extrapolated_position(*time),
-			Bound::Unbounded=>relative_body.position,
+		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,start_position)?;
+		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

@@ -29,7 +29,6 @@ pub enum InternalInstruction{
 	CollisionStart(Collision,model_physics::GigaTime),
 	CollisionEnd(Collision,model_physics::GigaTime),
 	StrafeTick,
-	// TODO: add GigaTime to ReachWalkTargetVelocity
 	ReachWalkTargetVelocity,
 	// Water,
 }
@@ -1039,17 +1038,30 @@ impl PhysicsData{
 		})?;
 		Some(*convex_mesh_id)
 	}
-	pub fn closest_fev_not_inside(&self,convex_mesh_id:ConvexMeshId<PhysicsModelId>,point:Planar64Vec3)->Option<model_physics::FEV<model_physics::MinkowskiMesh<'_>>>{
+	pub fn closest_fev_not_inside(&self,convex_mesh_id:ConvexMeshId<PhysicsModelId>,point:Planar64Vec3)->Option<model_physics::FEV<TransformedMesh<'static>>>{
 		let model_mesh=self.models.mesh(convex_mesh_id);
 		let minkowski=model_physics::MinkowskiMesh::minkowski_sum(model_mesh,self.hitbox_mesh.transformed_mesh());
 		let fev=crate::minimum_difference::closest_fev_not_inside(&minkowski,point)?;
-		Some(fev)
-	}
-	pub fn trace(&self,convex_mesh_id:ConvexMeshId<PhysicsModelId>,body:&Body,time:Time)->Option<model_physics::FEV<model_physics::MinkowskiMesh<'_>>>{
-		let model_mesh=self.models.mesh(convex_mesh_id);
-		let minkowski=model_physics::MinkowskiMesh::minkowski_sum(model_mesh,self.hitbox_mesh.transformed_mesh());
-		let fev=crate::minimum_difference::closest_fev_not_inside(&minkowski,body.extrapolated_position(time))?;
-		Some(fev)
+		Some(match fev{
+			model_physics::FEV::Face(face)=>{
+				match face{
+					model_physics::MinkowskiFace::VertFace(submesh_vert_id,_)=>model_physics::FEV::Vert(submesh_vert_id),
+					model_physics::MinkowskiFace::EdgeEdge(submesh_edge_id,..)=>model_physics::FEV::Edge(submesh_edge_id),
+					model_physics::MinkowskiFace::FaceVert(submesh_face_id,_)=>model_physics::FEV::Face(submesh_face_id),
+				}
+			},
+			model_physics::FEV::Edge(edge)=>{
+				match edge{
+					model_physics::MinkowskiEdge::VertEdge(submesh_vert_id,_)=>model_physics::FEV::Vert(submesh_vert_id),
+					model_physics::MinkowskiEdge::EdgeVert(submesh_edge_id,_)=>model_physics::FEV::Edge(submesh_edge_id),
+				}
+			},
+			model_physics::FEV::Vert(vert)=>{
+				match vert{
+					model_physics::MinkowskiVert::VertVert(submesh_vert_id,_)=>model_physics::FEV::Vert(submesh_vert_id),
+				}
+			},
+		})
 	}
 	pub fn new(map:&map::CompleteMap)->Self{
 		let modes=map.modes.clone().denormalize();
@@ -1199,9 +1211,6 @@ impl PhysicsData{
 			modes,
 		}
 	}
-	pub fn vertex_transform(&self)->&integer::Planar64Affine3{
-		&self.hitbox_mesh.transform.vertex
-	}
 }
 // the collection of information required to run physics
 pub struct PhysicsContext<'a>{
@@ -1726,20 +1735,7 @@ fn collision_start_intersect(
 			},
 			Some(gameplay_modes::Zone::Finish)=>{
 				match run.finish(time){
-					Ok(())=>{
-						let time=run.time(time);
-						let h=time.get()/(Time::ONE_SECOND.get()*60*60);
-						let m=(time.get()/(Time::ONE_SECOND.get()*60)).rem_euclid(60);
-						let s=(time.get()/(Time::ONE_SECOND.get())).rem_euclid(60);
-						let ms=(time.get()/(Time::ONE_MILLISECOND.get())).rem_euclid(1000);
-						let us=(time.get()/(Time::ONE_MICROSECOND.get())).rem_euclid(1000);
-						let ns=(time.get()/(Time::ONE_NANOSECOND.get())).rem_euclid(1000);
-						if h==0{
-							println!("@@@@ Finished run time={m:02}:{s:02}.{ms:03}_{us:03}_{ns:03}");
-						}else{
-							println!("@@@@ Finished run time={h}:{m:02}:{s:02}.{ms:03}_{us:03}_{ns:03}");
-						}
-					},
+					Ok(())=>println!("@@@@ Finished run time={}",run.time(time)),
 					Err(e)=>println!("@@@@ Run Finish error:{e:?}"),
 				}
 			},
@@ -1813,14 +1809,17 @@ fn collision_end_intersect(
 }
 fn atomic_internal_instruction(state:&mut PhysicsState,data:&PhysicsData,ins:TimedInstruction<InternalInstruction,Time>){
 	state.time=ins.time;
-	match ins.instruction{
-		// collisions advance the body precisely
+	let (should_advance_body,goober_time)=match ins.instruction{
 		InternalInstruction::CollisionStart(_,dt)
-		|InternalInstruction::CollisionEnd(_,dt)=>state.body.advance_time_ratio_dt(dt),
-		// this advances imprecisely
-		InternalInstruction::ReachWalkTargetVelocity=>state.body.advance_time(state.time),
-		// strafe tick decides for itself whether to advance the body.
-		InternalInstruction::StrafeTick=>(),
+		|InternalInstruction::CollisionEnd(_,dt)=>(true,Some(dt)),
+		InternalInstruction::StrafeTick
+		|InternalInstruction::ReachWalkTargetVelocity=>(true,None),
+	};
+	if should_advance_body{
+		match goober_time{
+			Some(dt)=>state.body.advance_time_ratio_dt(dt),
+			None=>state.body.advance_time(state.time),
+		}
 	}
 		match ins.instruction{
 			InternalInstruction::CollisionStart(collision,_)=>{
@@ -1867,8 +1866,6 @@ fn atomic_internal_instruction(state:&mut PhysicsState,data:&PhysicsData,ins:Tim
 						let masked_controls=strafe_settings.mask(controls);
 						let control_dir=state.style.get_control_dir(masked_controls);
 						if control_dir!=vec3::zero(){
-							// manually advance time
-							state.body.advance_time(state.time);
 							let camera_mat=state.camera.simulate_move_rotation_y(state.input_state.lerp_delta(state.time).x);
 							if let Some(ticked_velocity)=strafe_settings.tick_velocity(state.body.velocity,(camera_mat*control_dir).with_length(Planar64::ONE).divide().wrap_1()){
 								//this is wrong but will work ig
@@ -2041,7 +2038,7 @@ mod test{
 		let hitbox_mesh=h1.transformed_mesh();
 		let platform_mesh=h0.transformed_mesh();
 		let minkowski=model_physics::MinkowskiMesh::minkowski_sum(platform_mesh,hitbox_mesh);
-		let collision=minkowski.predict_collision_in(&relative_body,..);
+		let collision=minkowski.predict_collision_in(&relative_body,Time::ZERO..Time::from_secs(10));
 		assert_eq!(collision.map(|tup|relative_body.time+tup.1.into()),expected_collision_time,"Incorrect time of collision");
 	}
 	fn test_collision_rotated(relative_body:Body,expected_collision_time:Option<Time>){
@@ -2059,7 +2056,7 @@ mod test{
 		let hitbox_mesh=h1.transformed_mesh();
 		let platform_mesh=h0.transformed_mesh();
 		let minkowski=model_physics::MinkowskiMesh::minkowski_sum(platform_mesh,hitbox_mesh);
-		let collision=minkowski.predict_collision_in(&relative_body,..);
+		let collision=minkowski.predict_collision_in(&relative_body,Time::ZERO..Time::from_secs(10));
 		assert_eq!(collision.map(|tup|relative_body.time+tup.1.into()),expected_collision_time,"Incorrect time of collision");
 	}
 	fn test_collision(relative_body:Body,expected_collision_time:Option<Time>){

engine/session/src/session.rs

@@ -48,11 +48,11 @@ pub enum SessionControlInstruction{
 	StopSpectate,
 	SaveReplay,
 	LoadIntoReplayState,
-	DebugSimulation,
 }
 pub enum SessionPlaybackInstruction{
 	SkipForward,
 	SkipBack,
+	TogglePaused,
 	DecreaseTimescale,
 	IncreaseTimescale,
 }
@@ -62,7 +62,6 @@ pub struct FrameState{
 	pub camera:physics::PhysicsCamera,
 	pub time:PhysicsTime,
 	pub hit:Option<Hit>,
-	pub debug_hitbox_position:Option<strafesnet_common::integer::Planar64Affine3>,
 }
 
 pub struct Simulation{
@@ -79,38 +78,12 @@ impl Simulation{
 			physics,
 		}
 	}
-	pub fn get_frame_state(
-		&self,
-		time:SessionTime,
-		debug_model:Option<Hit>,
-		debug_hitbox_position:Option<strafesnet_common::integer::Planar64Affine3>,
-	)->FrameState{
+	pub fn get_frame_state(&self,time:SessionTime,debug_model:Option<Hit>)->FrameState{
 		FrameState{
 			body:self.physics.camera_body(),
 			camera:self.physics.camera(),
 			time:self.timer.time(time),
-			hit:debug_model,
-			debug_hitbox_position,
-		}
-	}
-}
-
-// a paused simulation which displays a period of its future traced over the model under the cursor
-struct DebugSimulation{
-	physics:physics::PhysicsState,
-	timer:strafesnet_common::timer::TimerFixed<Scaled<SessionTimeInner,PhysicsTimeInner>,strafesnet_common::timer::Paused>,
-	cycle_duration:PhysicsTime,
-}
-impl DebugSimulation{
-	pub fn new(simulation:&Simulation,time:SessionTime,cycle_duration:PhysicsTime)->Self{
-		let timer=match &simulation.timer{
-			Timer::Paused(timer_fixed)=>*timer_fixed,
-			Timer::Unpaused(timer_fixed)=>timer_fixed.into_paused(time),
-		};
-		Self{
-			physics:simulation.physics.clone(),
-			timer,
-			cycle_duration,
+			hit: debug_model,
 		}
 	}
 }
@@ -197,7 +170,6 @@ pub struct Session{
 	//players:HashMap<PlayerId,Simulation>,
 	replays:HashMap<BotId,Replay>,
 	last_ray_hit:Option<Hit>,
-	debug_simulation:Option<DebugSimulation>,
 }
 impl Session{
 	pub fn new(
@@ -215,7 +187,6 @@ impl Session{
 			recording:Default::default(),
 			replays:HashMap::new(),
 			last_ray_hit:None,
-			debug_simulation:None,
 		}
 	}
 	fn clear_recording(&mut self){
@@ -226,23 +197,14 @@ impl Session{
 		self.geometry_shared=PhysicsData::new(map);
 	}
 	pub fn get_frame_state(&self,time:SessionTime)->Option<FrameState>{
-		let debug_hitbox_position=self.debug_simulation.as_ref().map(|debug_simulation|{
-			let simulation_time=debug_simulation.timer.time();
-			let loop_time=simulation_time+PhysicsTime::raw(time.get().rem_euclid(debug_simulation.cycle_duration.get())>>1);
-			let transform=self.geometry_shared.vertex_transform();
-			strafesnet_common::integer::Planar64Affine3::new(transform.matrix3,debug_simulation.physics.body().extrapolated_position(loop_time))
-		});
 		match &self.view_state{
-			ViewState::Play=>Some(self.simulation.get_frame_state(time,self.last_ray_hit.clone(),debug_hitbox_position)),
+			ViewState::Play=>Some(self.simulation.get_frame_state(time,self.last_ray_hit.clone())),
 			ViewState::Replay(bot_id)=>self.replays.get(bot_id).map(|replay|
-				replay.simulation.get_frame_state(time,None,debug_hitbox_position)
+				replay.simulation.get_frame_state(time,None)
 			),
 		}
 	}
 	pub fn debug_raycast_print_model_id_if_changed(&mut self,time:SessionTime){
-		let Some(debug_simulation)=&self.debug_simulation else{
-			return;
-		};
 		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)),
@@ -250,15 +212,10 @@ impl Session{
 			};
 			match self.geometry_shared.trace_ray(ray){
 				Some(convex_mesh_id)=>{
-					if self.last_ray_hit.as_ref().map_or(true,|last|last.convex_mesh_id!=convex_mesh_id){
-						println!("MeshId={convex_mesh_id:?}");
-					}
-					let simulation_time=debug_simulation.timer.time();
-					let loop_time=simulation_time+PhysicsTime::raw(time.get().rem_euclid(debug_simulation.cycle_duration.get())>>1);
-					let closest_fev=self.geometry_shared.trace(convex_mesh_id,debug_simulation.physics.body(),loop_time);
+					let closest_fev=self.geometry_shared.closest_fev_not_inside(convex_mesh_id,self.simulation.physics.body().position);
 					self.last_ray_hit=Some(Hit{
 						convex_mesh_id,
-						closest_fev:closest_fev.map(|fev|fev.mesh0()),
+						closest_fev,
 					});
 				},
 				None=>self.last_ray_hit=None,
@@ -324,14 +281,7 @@ impl InstructionConsumer<Instruction<'_>> for Session{
 				// don't flush the buffered instructions in the mouse interpolator
 				// until the mouse is confirmed to be not moving at a later time
 				// what if they pause for 5ms lmao
-				match &self.view_state{
-					ViewState::Play=>{
-						_=self.simulation.timer.set_paused(ins.time,paused);
-					},
-					ViewState::Replay(bot_id)=>if let Some(replay)=self.replays.get_mut(bot_id){
-						_=replay.simulation.timer.set_paused(ins.time,paused);
-					},
-				}
+				_=self.simulation.timer.set_paused(ins.time,paused);
 			},
 			Instruction::Control(SessionControlInstruction::CopyRecordingIntoReplayAndSpectate)=> if let ViewState::Play=self.view_state{
 				// Bind: B
@@ -452,6 +402,14 @@ impl InstructionConsumer<Instruction<'_>> for Session{
 					},
 				}
 			},
+			Instruction::Playback(SessionPlaybackInstruction::TogglePaused)=>{
+				match &self.view_state{
+					ViewState::Play=>(),
+					ViewState::Replay(bot_id)=>if let Some(replay)=self.replays.get_mut(bot_id){
+						_=replay.simulation.timer.set_paused(ins.time,!replay.simulation.timer.is_paused());
+					},
+				}
+			}
 			Instruction::ChangeMap(complete_map)=>{
 				self.clear_recording();
 				self.change_map(complete_map);
@@ -480,10 +438,6 @@ impl InstructionConsumer<Instruction<'_>> for Session{
 				// begin spectate
 				self.view_state=ViewState::Replay(bot_id);
 			},
-			Instruction::Control(SessionControlInstruction::DebugSimulation)=>{
-				println!("Body={}",self.simulation.physics.body());
-				self.debug_simulation=Some(DebugSimulation::new(&self.simulation,ins.time,PhysicsTime::ONE_SECOND<<1));
-			},
 			Instruction::Idle=>{
 				run_mouse_interpolator_instruction!(MouseInterpolatorInstruction::Idle);
 				// this just refreshes the replays

integration-testing/src/tests.rs

@@ -60,12 +60,8 @@ fn physics_bug_3()->Result<(),ReplayError>{
 		// vec3::raw_xyz(0,-96915585363,1265),
 		// vec3::raw_xyz(0,-429496729600,0),
 		// corner setup before wall hits
-		// vec3::raw_xyz(-1392580080675,3325402529458,-2444727738679),
-		// vec3::raw_xyz(-30259028820,-22950929553,-71141663007),
-		// vec3::raw_xyz(0,-429496729600,0),
-		// Actual bug 3 repro
-		vec3::raw_xyz(-2505538624455,3357963283914,557275711118),
-		vec3::raw_xyz(204188283920,-282280474198,166172785440),
+		vec3::raw_xyz(-1392580080675,3325402529458,-2444727738679),
+		vec3::raw_xyz(-30259028820,-22950929553,-71141663007),
 		vec3::raw_xyz(0,-429496729600,0),
 		Time::ZERO,
 	);

lib/rbx_loader/Cargo.toml

@@ -12,7 +12,7 @@ authors = ["Rhys Lloyd <krakow20@gmail.com>"]
 [dependencies]
 bytemuck = "1.14.3"
 glam = "0.30.0"
-regex = { version = "1.11.3", default-features = false, features = ["unicode-perl"] }
+regex = { version = "1.11.3", default-features = false }
 rbx_mesh = "0.5.0"
 rbxassetid = { version = "0.1.0", path = "../rbxassetid", registry = "strafesnet" }
 roblox_emulator = { version = "0.5.1", path = "../roblox_emulator", default-features = false, registry = "strafesnet" }

strafe-client/models/teslacyberv3.0.mtl

@@ -0,0 +1,62 @@
+# Blender MTL File: 'teslacyberv3.0.blend'
+# Material Count: 6
+
+newmtl Material
+Ns 65.476285
+Ka 1.000000 1.000000 1.000000
+Kd 0.411568 0.411568 0.411568
+Ks 0.614679 0.614679 0.614679
+Ke 0.000000 0.000000 0.000000
+Ni 36.750000
+d 1.000000
+illum 3
+
+newmtl Материал
+Ns 323.999994
+Ka 1.000000 1.000000 1.000000
+Kd 0.800000 0.800000 0.800000
+Ks 0.500000 0.500000 0.500000
+Ke 0.000000 0.000000 0.000000
+Ni 1.000000
+d 1.000000
+illum 2
+
+newmtl Материал.001
+Ns 900.000000
+Ka 1.000000 1.000000 1.000000
+Kd 0.026240 0.026240 0.026240
+Ks 0.000000 0.000000 0.000000
+Ke 0.000000 0.000000 0.000000
+Ni 1.450000
+d 1.000000
+illum 1
+
+newmtl Материал.002
+Ns 0.000000
+Ka 1.000000 1.000000 1.000000
+Kd 0.031837 0.032429 0.029425
+Ks 0.169725 0.169725 0.169725
+Ke 0.000000 0.000000 0.000000
+Ni 0.000000
+d 1.000000
+illum 2
+
+newmtl Материал.003
+Ns 900.000000
+Ka 1.000000 1.000000 1.000000
+Kd 0.023585 0.083235 0.095923
+Ks 1.000000 1.000000 1.000000
+Ke 0.000000 0.000000 0.000000
+Ni 45.049999
+d 1.000000
+illum 3
+
+newmtl Материал.004
+Ns 323.999994
+Ka 1.000000 1.000000 1.000000
+Kd 0.800000 0.800000 0.800000
+Ks 0.500000 0.500000 0.500000
+Ke 0.000000 0.000000 0.000000
+Ni 1.000000
+d 1.000000
+illum 2

strafe-client/src/graphics_worker.rs

@@ -34,8 +34,8 @@ pub fn new(
 			Instruction::Resize(size,user_settings)=>{
 				println!("Resizing to {:?}",size);
 				let t0=std::time::Instant::now();
-				config.width=size.width.max(1);
-				config.height=size.height.max(1);
+				config.width=640;
+				config.height=480;
 				surface.configure(&device,&config);
 				graphics.resize(&device,&config,&user_settings);
 				println!("Resize took {:?}",t0.elapsed());

strafe-client/src/physics_worker.rs

@@ -59,10 +59,6 @@ pub fn new<'a>(
 			},
 			Instruction::Render=>{
 				run_session_instruction!(ins.time,SessionInstruction::Idle);
-
-				// update model under cursor
-				session.debug_raycast_print_model_id_if_changed(ins.time);
-
 				if let Some(frame_state)=session.get_frame_state(ins.time){
 					run_graphics_worker_instruction!(GraphicsInstruction::Render(frame_state));
 				}
@@ -81,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

@@ -3,7 +3,7 @@ fn optional_features()->wgpu::Features{
 	|wgpu::Features::TEXTURE_COMPRESSION_ETC2
 }
 fn required_features()->wgpu::Features{
-	wgpu::Features::TEXTURE_COMPRESSION_BC|wgpu::Features::EXPERIMENTAL_MESH_SHADER
+	wgpu::Features::TEXTURE_COMPRESSION_BC
 }
 fn required_downlevel_capabilities()->wgpu::DownlevelCapabilities{
 	wgpu::DownlevelCapabilities{
@@ -125,7 +125,7 @@ impl<'a> SetupContextPartial3<'a>{
 					required_limits:needed_limits,
 					memory_hints:wgpu::MemoryHints::Performance,
 					trace:wgpu::Trace::Off,
-					experimental_features:unsafe{wgpu::ExperimentalFeatures::enabled()},
+					experimental_features:wgpu::ExperimentalFeatures::disabled(),
 				},
 			))
 			.expect("Unable to find a suitable GPU adapter!");

strafe-client/src/shader.wgsl

@@ -1,5 +1,3 @@
-enable wgpu_mesh_shader;
-
 struct Camera {
 	// from camera to screen
 	proj: mat4x4<f32>,
@@ -92,12 +90,10 @@ fn vs_entity_texture(
 @binding(0)
 var<uniform> model_instance: ModelInstance;
 
-@group(1)
-@binding(1)
-var<uniform> ve_verts: array<vec4<f32>, 2>;
-
 struct DebugEntityOutput {
 	@builtin(position) position: vec4<f32>,
+	@location(1) normal: vec3<f32>,
+	@location(2) view: vec3<f32>,
 };
 
 @vertex
@@ -106,148 +102,11 @@ fn vs_debug(
 ) -> DebugEntityOutput {
 	var position: vec4<f32> = model_instance.transform * vec4<f32>(pos, 1.0);
 	var result: DebugEntityOutput;
+	result.view = position.xyz - camera.view_inv[3].xyz;//col(3)
 	result.position = camera.proj * camera.view * position;
 	return result;
 }
 
-struct TaskPayload {
-    four_bytes: u32,
-}
-
-var<task_payload> taskPayload: TaskPayload;
-
-@task
-@payload(taskPayload)
-@workgroup_size(1)
-fn ts_main() -> @builtin(mesh_task_size) vec3<u32> {
-	taskPayload.four_bytes = 0;
-	return vec3(1, 1, 1);
-}
-
-struct VertexOutput {
-	@builtin(position) position: vec4<f32>,
-	@location(0) color: vec4<f32>,
-}
-struct PrimitiveOutput {
-	@builtin(triangle_indices) indices: vec3<u32>,
-}
-
-struct CircleOutput {
-	@builtin(vertices) vertices: array<VertexOutput, 24>,
-	@builtin(primitives) primitives: array<PrimitiveOutput, 22>,
-	@builtin(vertex_count) vertex_count: u32,
-	@builtin(primitive_count) primitive_count: u32,
-}
-
-var<workgroup> mesh_output: CircleOutput;
-
-const tau: f32 = 3.141592653589793 * 2.0;
-
-fn modulo(value:u32,modulus:u32)->u32{
-	return value-value/modulus*modulus;
-}
-
-@mesh(mesh_output)
-@payload(taskPayload)
-@workgroup_size(1)
-fn ms_debug_vert(){
-	// circle with 24 vertices.
-	const LAYERS:u32 = 3;
-	const N:u32 = 3*(1<<LAYERS);
-	mesh_output.vertex_count = N;
-	mesh_output.primitive_count = N-2;
-
-	var vertex_world_position: vec4<f32> = model_instance.transform * ve_verts[0];
-	var vertex_screen_position: vec4<f32> = camera.proj * camera.view * vertex_world_position;
-
-	for (var i:u32 = 0; i<N/4; i++){
-		// draw a 1 unit redius circle
-		var theta: f32 = f32(i) * tau / f32(N);
-		var cos_sin: vec2<f32> = vec2(cos(theta), sin(theta));
-		var offset: vec2<f32> = 0.5 * cos_sin;
-		mesh_output.vertices[i].position = vertex_screen_position + vec4<f32>(offset, 0.0, 0.0);
-		mesh_output.vertices[i+N/4].position = vertex_screen_position + vec4<f32>(-offset.y, offset.x, 0.0, 0.0);
-		mesh_output.vertices[i+N/4*2].position = vertex_screen_position + vec4<f32>(-offset, 0.0, 0.0);
-		mesh_output.vertices[i+N/4*3].position = vertex_screen_position + vec4<f32>(offset.y, -offset.x, 0.0, 0.0);
-	}
-
-	// max area triangle indices
-
-	// the big triangle
-	mesh_output.primitives[0].indices = vec3<u32>(0, N/3, N/3*2);
-
-	// 3 layers of infill triangles to approximate circle better than 1 triangle.
-	// we start on the outer layer because it's easier to construct this way
-	var count:u32=N;
-	var base:u32=1;
-	for (var layer:u32 = 0; layer<LAYERS; layer++){
-		count=count>>1;
-		var step:u32=N/count;
-		for (var i:u32 = 0; i<count; i++){
-			mesh_output.primitives[base+i].indices = vec3<u32>(i*step, i*step+(step>>1), modulo(i*step+step,N));
-		}
-		base+=count;
-	}
-}
-
-@mesh(mesh_output)
-@payload(taskPayload)
-@workgroup_size(1)
-fn ms_debug_edge(){
-	// draw two circles for now.
-	const LAYERS:u32 = 3;
-	const N:u32 = 2*(1<<LAYERS);
-	mesh_output.vertex_count = 2*(3+2+4+8);
-	mesh_output.primitive_count = 2*(1+2+4+8)+2;
-
-	var v0_world_position: vec4<f32> = model_instance.transform * ve_verts[0];
-	var v1_world_position: vec4<f32> = model_instance.transform * ve_verts[1];
-
-	var v0_screen_position: vec4<f32> = camera.proj * camera.view * v0_world_position;
-	var v1_screen_position: vec4<f32> = camera.proj * camera.view * v1_world_position;
-
-	var edge_dir_world: vec4<f32> = normalize(v0_world_position - v1_world_position);
-	var edge_dir_screen: vec4<f32> = camera.proj * camera.view * edge_dir_world;
-
-	for (var i:u32 = 0; i<=N/2; i++){
-		// two half circles that make a whole
-		var theta: f32 = f32(i) * tau / f32(N);
-		var cos_sin: vec2<f32> = vec2(cos(theta), sin(theta));
-
-		// construct basis vectors
-		var y_axis: vec2<f32> = edge_dir_screen.xy;
-		var x_axis: vec2<f32> = y_axis.yx;
-		x_axis.x = -x_axis.x;
-
-		var offset: vec4<f32> = vec4<f32>(0.5 * (x_axis * cos_sin.x + y_axis * cos_sin.y), 0.0, 0.0);;
-
-		mesh_output.vertices[i].position = v0_screen_position + offset;
-		mesh_output.vertices[N/2+1+i].position = v1_screen_position - offset;
-	}
-
-	// max area triangle indices
-	// number of primitives per circle half
-	const P:u32 = N/2;
-	// the big triangles between the circles
-	mesh_output.primitives[0].indices = vec3<u32>(0, N/2+1, P);
-	mesh_output.primitives[P].indices = vec3<u32>(N/2+1, 0, P + N/2+1);
-
-	// 3 layers of infill triangles to approximate circle better than 1 triangle.
-	// we start on the outer layer because it's easier to construct this way
-	var count:u32=P;
-	var base:u32=1;
-	for (var layer:u32 = 0; layer<LAYERS; layer++){
-		count=count>>1;
-		var step:u32=P/count;
-		for (var i:u32 = 0; i<count; i++){
-			var indices = vec3<u32>(i*step, i*step+(step>>1), i*step+step);
-			mesh_output.primitives[base+i].indices = indices;
-			mesh_output.primitives[P+base+i].indices = indices + N/2+1;
-		}
-		base+=count;
-	}
-}
-
 //group 2 is the skybox texture
 @group(1)
 @binding(0)

strafe-client/src/window.rs

@@ -15,7 +15,6 @@ pub enum Instruction{
 struct WindowContext<'a>{
 	manual_mouse_lock:bool,
 	mouse_pos:glam::DVec2,
-	simulation_paused:bool,
 	screen_size:glam::UVec2,
 	window:&'a winit::window::Window,
 	physics_thread:crate::compat_worker::QNWorker<'a,TimedInstruction<PhysicsWorkerInstruction,SessionTime>>,
@@ -25,35 +24,6 @@ impl WindowContext<'_>{
 	fn get_middle_of_screen(&self)->winit::dpi::PhysicalPosition<u32>{
 		winit::dpi::PhysicalPosition::new(self.screen_size.x/2,self.screen_size.y/2)
 	}
-	fn free_mouse(&mut self){
-		self.manual_mouse_lock=false;
-		match self.window.set_cursor_position(self.get_middle_of_screen()){
-			Ok(())=>(),
-			Err(e)=>println!("Could not set cursor position: {:?}",e),
-		}
-		match self.window.set_cursor_grab(winit::window::CursorGrabMode::None){
-			Ok(())=>(),
-			Err(e)=>println!("Could not release cursor: {:?}",e),
-		}
-		self.window.set_cursor_visible(true);
-	}
-	fn lock_mouse(&mut self){
-		//if cursor is outside window don't lock but apparently there's no get pos function
-		//let pos=window.get_cursor_pos();
-		match self.window.set_cursor_grab(winit::window::CursorGrabMode::Locked){
-			Ok(())=>(),
-			Err(_)=>{
-				match self.window.set_cursor_grab(winit::window::CursorGrabMode::Confined){
-					Ok(())=>(),
-					Err(e)=>{
-						self.manual_mouse_lock=true;
-						println!("Could not confine cursor: {:?}",e)
-					},
-				}
-			}
-		}
-		self.window.set_cursor_visible(false);
-	}
 	fn window_event(&mut self,time:SessionTime,event:winit::event::WindowEvent){
 		match event{
 			winit::event::WindowEvent::DroppedFile(path)=>{
@@ -64,10 +34,6 @@ impl WindowContext<'_>{
 				}
 			},
 			winit::event::WindowEvent::Focused(state)=>{
-				// don't unpause if manually paused
-				if self.simulation_paused{
-					return;
-				}
 				//pause unpause
 				self.physics_thread.send(TimedInstruction{
 					time,
@@ -80,8 +46,35 @@ impl WindowContext<'_>{
 				..
 			}=>{
 				match (logical_key,state){
-					(winit::keyboard::Key::Named(winit::keyboard::NamedKey::Tab),winit::event::ElementState::Pressed)=>self.free_mouse(),
-					(winit::keyboard::Key::Named(winit::keyboard::NamedKey::Tab),winit::event::ElementState::Released)=>self.lock_mouse(),
+					(winit::keyboard::Key::Named(winit::keyboard::NamedKey::Tab),winit::event::ElementState::Pressed)=>{
+						self.manual_mouse_lock=false;
+						match self.window.set_cursor_position(self.get_middle_of_screen()){
+							Ok(())=>(),
+							Err(e)=>println!("Could not set cursor position: {:?}",e),
+						}
+						match self.window.set_cursor_grab(winit::window::CursorGrabMode::None){
+							Ok(())=>(),
+							Err(e)=>println!("Could not release cursor: {:?}",e),
+						}
+						self.window.set_cursor_visible(state.is_pressed());
+					},
+					(winit::keyboard::Key::Named(winit::keyboard::NamedKey::Tab),winit::event::ElementState::Released)=>{
+						//if cursor is outside window don't lock but apparently there's no get pos function
+						//let pos=window.get_cursor_pos();
+						match self.window.set_cursor_grab(winit::window::CursorGrabMode::Locked){
+							Ok(())=>(),
+							Err(_)=>{
+								match self.window.set_cursor_grab(winit::window::CursorGrabMode::Confined){
+									Ok(())=>(),
+									Err(e)=>{
+										self.manual_mouse_lock=true;
+										println!("Could not confine cursor: {:?}",e)
+									},
+								}
+							}
+						}
+						self.window.set_cursor_visible(state.is_pressed());
+					},
 					(winit::keyboard::Key::Named(winit::keyboard::NamedKey::F11),winit::event::ElementState::Pressed)=>{
 						if self.window.fullscreen().is_some(){
 							self.window.set_fullscreen(None);
@@ -139,16 +132,7 @@ impl WindowContext<'_>{
 						if let Some(session_instruction)=match keycode{
 							winit::keyboard::Key::Named(winit::keyboard::NamedKey::Space)=>input_ctrl!(SetJump,s),
 							// TODO: bind system so playback pausing can use spacebar
-							winit::keyboard::Key::Named(winit::keyboard::NamedKey::Enter)=>if s{
-								let paused=!self.simulation_paused;
-								self.simulation_paused=paused;
-								if paused{
-									self.free_mouse();
-								}else{
-									self.lock_mouse();
-								}
-								Some(SessionInstructionSubset::Control(SessionControlInstruction::SetPaused(paused)))
-							}else{None},
+							winit::keyboard::Key::Named(winit::keyboard::NamedKey::Enter)=>session_playback!(TogglePaused,s),
 							winit::keyboard::Key::Named(winit::keyboard::NamedKey::ArrowUp)=>session_playback!(IncreaseTimescale,s),
 							winit::keyboard::Key::Named(winit::keyboard::NamedKey::ArrowDown)=>session_playback!(DecreaseTimescale,s),
 							winit::keyboard::Key::Named(winit::keyboard::NamedKey::ArrowLeft)=>session_playback!(SkipBack,s),
@@ -171,7 +155,6 @@ impl WindowContext<'_>{
 								"X"|"x"=>session_ctrl!(StopSpectate,s),
 								"N"|"n"=>session_ctrl!(SaveReplay,s),
 								"J"|"j"=>session_ctrl!(LoadIntoReplayState,s),
-								"H"|"h"=>session_ctrl!(DebugSimulation,s),
 								_=>None,
 							},
 							_=>None,
@@ -258,7 +241,6 @@ pub fn worker<'a>(
 	let mut window_context=WindowContext{
 		manual_mouse_lock:false,
 		mouse_pos:glam::DVec2::ZERO,
-		simulation_paused:false,
 		//make sure to update this!!!!!
 		screen_size,
 		window,