the bug

Cargo.lock

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

engine/graphics/Cargo.toml

@@ -9,6 +9,7 @@ ddsfile = "0.5.1"
 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_session = { path = "../session", registry = "strafesnet" }
 strafesnet_settings = { path = "../settings", registry = "strafesnet" }
 wgpu = "28.0.0"

engine/graphics/src/graphics.rs

@@ -36,8 +36,14 @@ struct GraphicsModel{
 	instance_count:u32,
 }
 
+struct DebugGraphicsSubmesh{
+	verts:Vec<strafesnet_physics::model::MeshVertId>,
+	edges:Vec<Indices>,
+	faces:Vec<Indices>,
+}
 struct DebugGraphicsMesh{
-	indices:Indices,
+	verts:Indices,
+	submeshes:Vec<DebugGraphicsSubmesh>,
 	vertex_buf:wgpu::Buffer,
 }
 struct DebugGraphicsModel{
@@ -62,7 +68,9 @@ 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,
 }
 
 struct GraphicsCamera{
@@ -181,10 +189,9 @@ 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|{
-			let vertices:Vec<DebugGraphicsVertex>=mesh.unique_vertices.iter().map(|vertex|{
+			let vertices:Vec<DebugGraphicsVertex>=mesh.unique_pos.iter().copied().map(|pos|{
 				DebugGraphicsVertex{
-					pos:mesh.unique_pos[vertex.pos.get() as usize].to_array().map(Into::into),
+					pos:pos.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{
@@ -193,30 +200,43 @@ impl GraphicsState{
 				usage:wgpu::BufferUsages::VERTEX,
 			});
 
-			let mut indices=Vec::new();
+			macro_rules! indices{
-			for physics_group in &mesh.physics_groups{
+				($indices:expr)=>{
-				for polygon_group_id in &physics_group.groups{
+					if (u32::MAX as usize)<vertices.len(){
-					for poly in mesh.polygon_groups[polygon_group_id.get() as usize].polys(){
+						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 poly_vertices=poly.into_iter().copied();
+						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{
-				indices:if (u32::MAX as usize)<vertices.len(){
+				verts:indices!((0..vertices.len() as u32).map(strafesnet_physics::model::MeshVertId::new)),
-					panic!("Model has too many vertices!")
+				submeshes,
-				}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();
@@ -937,8 +957,8 @@ impl GraphicsState{
 			multiview_mask:None,
 			cache:None,
 		});
-		let debug_model_pipeline=device.create_render_pipeline(&wgpu::RenderPipelineDescriptor{
+		let mut debug_model_pipeline=wgpu::RenderPipelineDescriptor{
-			label:Some("Debug Model Pipeline"),
+			label:None,
 			layout:Some(&debug_model_pipeline_layout),
 			vertex:wgpu::VertexState{
 				module:&shader,
@@ -946,7 +966,7 @@ impl GraphicsState{
 				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],
+					attributes:&wgpu::vertex_attr_array![0=>Float32x3],
 				}],
 				compilation_options:wgpu::PipelineCompilationOptions::default(),
 			},
@@ -975,7 +995,16 @@ impl GraphicsState{
 			multisample:wgpu::MultisampleState::default(),
 			multiview:None,
 			cache:None,
-		});
+		};
+		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);
@@ -1016,7 +1045,9 @@ impl GraphicsState{
 			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,
 			},
 			bind_groups:GraphicsBindGroups{
 				camera:camera_bind_group,
@@ -1135,15 +1166,36 @@ impl GraphicsState{
 			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(hit)=frame_state.hit{
-				if let Some(model)=self.debug_models.get(model_id.get() as usize){
+				if let Some(closest_fev)=&hit.closest_fev{
-					let mesh=&self.debug_meshes[model.debug_mesh_id as usize];
+					let model_id:model::ModelId=hit.convex_mesh_id.model_id.into();
-					rpass.set_pipeline(&self.pipelines.debug);
+					if let Some(model)=self.debug_models.get(model_id.get() as usize){
-					rpass.set_bind_group(1,&model.bind_group,&[]);
+						let mesh=&self.debug_meshes[model.debug_mesh_id as usize];
-					rpass.set_vertex_buffer(0,mesh.vertex_buf.slice(..));
+						rpass.set_bind_group(1,&model.bind_group,&[]);
-					rpass.set_index_buffer(mesh.indices.buf.slice(..),mesh.indices.format);
+						rpass.set_vertex_buffer(0,mesh.vertex_buf.slice(..));
-					//TODO: loop over triangle strips
+						match closest_fev{
-					rpass.draw_indexed(0..mesh.indices.count,0,0..1);
+							strafesnet_physics::model::FEV::Face(face)=>{
+								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)=>{
+								rpass.set_pipeline(&self.pipelines.debug_edge);
+								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)=>{
+								rpass.set_pipeline(&self.pipelines.debug_vert);
+								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);
+							},
+						}
+					}
 				}
 			}
 		}

engine/graphics/src/model.rs

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

engine/physics/src/lib.rs

@@ -1,6 +1,6 @@
 mod body;
 mod face_crawler;
-mod model;
+pub mod model;
 mod push_solve;
 mod minimum_difference;
 

engine/physics/src/model.rs

@@ -60,7 +60,7 @@ impl DirectedEdge for SubmeshDirectedEdgeId{
 }
 
 //Vertex <-> Edge <-> Face -> Collide
-#[derive(Debug)]
+#[derive(Debug,Clone)]
 pub enum FEV<M:MeshQuery>{
 	Face(M::Face),
 	Edge(<M::Edge as DirectedEdge>::UndirectedEdge),
@@ -445,6 +445,24 @@ pub struct PhysicsMeshView<'a>{
 	data:&'a PhysicsMeshData,
 	topology:&'a PhysicsMeshTopology,
 }
+impl PhysicsMeshView<'_>{
+	pub fn verts(&self)->&[MeshVertId]{
+		&self.topology.verts
+	}
+	pub fn edge_vert_ids_iter(&self)->impl Iterator<Item=[MeshVertId;2]>+'_{
+		self.topology.edge_topology.iter().map(|edge|{
+			edge.verts.map(|vert_id|self.topology.verts[vert_id.get() as usize])
+		})
+	}
+	pub fn face_vert_ids_iter(&self)->impl Iterator<Item=impl Iterator<Item=MeshVertId>>+'_{
+		self.topology.face_topology.iter().map(|face|{
+			face.edges.iter().map(|edge_id|{
+				let vert_id=self.topology.edge_topology[edge_id.as_undirected().get() as usize].verts[edge_id.parity() as usize];
+				self.topology.verts[vert_id.get() as usize]
+			})
+		})
+	}
+}
 impl MeshQuery for PhysicsMeshView<'_>{
 	type Face=SubmeshFaceId;
 	type Edge=SubmeshDirectedEdgeId;

engine/physics/src/physics.rs

@@ -670,7 +670,7 @@ impl From<CollisionAttributesId> for IntersectAttributesId{
 	}
 }
 #[derive(Debug,Clone,Copy,Hash,id::Id,Eq,PartialEq)]
-struct ContactModelId(u32);
+pub struct ContactModelId(u32);
 impl From<ContactModelId> for ModelId{
 	fn from(value:ContactModelId)->ModelId{
 		ModelId::new(value.get())
@@ -682,7 +682,7 @@ impl From<ModelId> for ContactModelId{
 	}
 }
 #[derive(Debug,Clone,Copy,Hash,id::Id,Eq,PartialEq)]
-struct IntersectModelId(u32);
+pub struct IntersectModelId(u32);
 impl From<IntersectModelId> for ModelId{
 	fn from(value:IntersectModelId)->ModelId{
 		ModelId::new(value.get())
@@ -694,7 +694,7 @@ impl From<ModelId> for IntersectModelId{
 	}
 }
 #[derive(Debug,Clone,Copy,Hash,Eq,PartialEq)]
-enum PhysicsModelId{
+pub enum PhysicsModelId{
 	Contact(ContactModelId),
 	Intersect(IntersectModelId),
 }
@@ -708,9 +708,9 @@ impl From<PhysicsModelId> for ModelId{
 }
 //unique physics meshes indexed by this
 #[derive(Debug,Clone,Copy,Eq,Hash,PartialEq)]
-struct ConvexMeshId<Id>{
+pub struct ConvexMeshId<Id>{
-	model_id:Id,
+	pub model_id:Id,
-	submesh_id:PhysicsSubmeshId,
+	pub submesh_id:PhysicsSubmeshId,
 }
 impl<Id> ConvexMeshId<Id>{
 	fn map<NewId>(self,model_id:NewId)->ConvexMeshId<NewId>{
@@ -999,7 +999,7 @@ impl PhysicsData{
 			hitbox_mesh:StyleModifiers::default().calculate_mesh(),
 		}
 	}
-	pub fn trace_ray(&self,ray:strafesnet_common::ray::Ray)->Option<ModelId>{
+	pub fn trace_ray(&self,ray:strafesnet_common::ray::Ray)->Option<ConvexMeshId<PhysicsModelId>>{
 		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
@@ -1036,7 +1036,32 @@ impl PhysicsData{
 			}
 			min.map(Into::into)
 		})?;
-		Some(convex_mesh_id.model_id.into())
+		Some(*convex_mesh_id)
+	}
+	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(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();

engine/session/src/session.rs

@@ -2,7 +2,6 @@ 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::{
@@ -62,7 +61,7 @@ pub struct FrameState{
 	pub body:physics::Body,
 	pub camera:physics::PhysicsCamera,
 	pub time:PhysicsTime,
-	pub debug_model:Option<ModelId>,
+	pub hit:Option<Hit>,
 }
 
 pub struct Simulation{
@@ -79,12 +78,12 @@ impl Simulation{
 			physics,
 		}
 	}
-	pub fn get_frame_state(&self,time:SessionTime,debug_model:Option<ModelId>)->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),
-			debug_model,
+			hit: debug_model,
 		}
 	}
 }
@@ -152,6 +151,12 @@ enum ViewState{
 	Replay(BotId),
 }
 
+#[derive(Clone)]
+pub struct Hit{
+	pub convex_mesh_id:physics::ConvexMeshId<physics::PhysicsModelId>,
+	pub closest_fev:Option<strafesnet_physics::model::FEV<strafesnet_physics::model::TransformedMesh<'static>>>
+}
+
 pub struct Session{
 	directories:Directories,
 	user_settings:UserSettings,
@@ -164,7 +169,7 @@ pub struct Session{
 	recording:Recording,
 	//players:HashMap<PlayerId,Simulation>,
 	replays:HashMap<BotId,Replay>,
-	last_ray_hit:Option<ModelId>,
+	last_ray_hit:Option<Hit>,
 }
 impl Session{
 	pub fn new(
@@ -193,7 +198,7 @@ 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,self.last_ray_hit)),
+			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)
 			),
@@ -205,10 +210,15 @@ impl Session{
 				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);
+			match self.geometry_shared.trace_ray(ray){
-			if model_id!=self.last_ray_hit{
+				Some(convex_mesh_id)=>{
-				println!("hit={model_id:?}");
+					let closest_fev=self.geometry_shared.closest_fev_not_inside(convex_mesh_id,self.simulation.physics.body().position);
-				self.last_ray_hit=model_id;
+					self.last_ray_hit=Some(Hit{
+						convex_mesh_id,
+						closest_fev,
+					});
+				},
+				None=>self.last_ray_hit=None,
 			}
 		}
 	}

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.width=640;
-				config.height=size.height.max(1);
+				config.height=480;
 				surface.configure(&device,&config);
 				graphics.resize(&device,&config,&user_settings);
 				println!("Resize took {:?}",t0.elapsed());

strafe-client/src/shader.wgsl

@@ -99,11 +99,9 @@ struct DebugEntityOutput {
 @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;