physics: hardcoded cylinder

engine/graphics/src/graphics.rs

@@ -103,6 +103,26 @@ impl std::default::Default for GraphicsCamera{
 	}
 }
 
+const MODEL_BUFFER_SIZE:usize=4*4 + 12 + 4;//let size=std::mem::size_of::<ModelInstance>();
+const MODEL_BUFFER_SIZE_BYTES:usize=MODEL_BUFFER_SIZE*4;
+fn get_instances_buffer_data(instances:&[GraphicsModelOwned])->Vec<f32>{
+	let mut raw=Vec::with_capacity(MODEL_BUFFER_SIZE*instances.len());
+	for mi in instances{
+		//model transform
+		raw.extend_from_slice(&AsRef::<[f32; 4*4]>::as_ref(&mi.transform)[..]);
+		//normal transform
+		raw.extend_from_slice(AsRef::<[f32; 3]>::as_ref(&mi.normal_transform.x_axis));
+		raw.extend_from_slice(&[0.0]);
+		raw.extend_from_slice(AsRef::<[f32; 3]>::as_ref(&mi.normal_transform.y_axis));
+		raw.extend_from_slice(&[0.0]);
+		raw.extend_from_slice(AsRef::<[f32; 3]>::as_ref(&mi.normal_transform.z_axis));
+		raw.extend_from_slice(&[0.0]);
+		//color
+		raw.extend_from_slice(AsRef::<[f32; 4]>::as_ref(&mi.color.get()));
+	}
+	raw
+}
+
 pub struct GraphicsState{
 	pipelines:GraphicsPipelines,
 	bind_groups:GraphicsBindGroups,
@@ -967,22 +987,3 @@ impl GraphicsState{
 		self.staging_belt.recall();
 	}
 }
-const MODEL_BUFFER_SIZE:usize=4*4 + 12 + 4;//let size=std::mem::size_of::<ModelInstance>();
-const MODEL_BUFFER_SIZE_BYTES:usize=MODEL_BUFFER_SIZE*4;
-fn get_instances_buffer_data(instances:&[GraphicsModelOwned])->Vec<f32>{
-	let mut raw=Vec::with_capacity(MODEL_BUFFER_SIZE*instances.len());
-	for mi in instances{
-		//model transform
-		raw.extend_from_slice(&AsRef::<[f32; 4*4]>::as_ref(&mi.transform)[..]);
-		//normal transform
-		raw.extend_from_slice(AsRef::<[f32; 3]>::as_ref(&mi.normal_transform.x_axis));
-		raw.extend_from_slice(&[0.0]);
-		raw.extend_from_slice(AsRef::<[f32; 3]>::as_ref(&mi.normal_transform.y_axis));
-		raw.extend_from_slice(&[0.0]);
-		raw.extend_from_slice(AsRef::<[f32; 3]>::as_ref(&mi.normal_transform.z_axis));
-		raw.extend_from_slice(&[0.0]);
-		//color
-		raw.extend_from_slice(AsRef::<[f32; 4]>::as_ref(&mi.color.get()));
-	}
-	raw
-}

engine/physics/src/physics.rs

@@ -982,7 +982,7 @@ impl PhysicsContext<'_>{
 impl PhysicsData{
 	/// use with caution, this is the only non-instruction way to mess with physics
 	pub fn generate_models(&mut self,map:&map::CompleteMap){
-		let mut modes=map.modes.clone().denormalize();
+		let modes=map.modes.clone().denormalize();
 		let mut used_contact_attributes=Vec::new();
 		let mut used_intersect_attributes=Vec::new();
 

lib/bsp_loader/src/brush.rs

@@ -1,5 +1,5 @@
-use strafesnet_common::integer::{self,Planar64,Planar64Vec3};
-use strafesnet_common::model::{self,VertexId};
+use strafesnet_common::integer::Planar64;
+use strafesnet_common::{model,integer};
 use strafesnet_common::integer::{vec3::Vector3,Fixed,Ratio};
 
 use crate::{valve_transform_normal,valve_transform_dist};
@@ -138,15 +138,7 @@ fn planes_to_faces(face_list:std::collections::HashSet<Face>)->Result<Faces,Plan
 		loop{
 			// push point onto vertices
 			// problem: this may push a vertex that does not fit in the fixed point range and is thus meaningless
-			//
-			// physics bug 2 originates from vertices being imprecise?
-			//
-			// Mask off the most precise 16 bits so that
-			// when face normals are calculated from
-			// the remaining 16 fractional bits
-			// they never exceed 32 bits of precision.
-			const MASK:Planar64=Planar64::raw(!((1<<16)-1));
-			face.push(intersection.divide().narrow_1().unwrap().map(|c|c&MASK));
+			face.push(intersection.divide().narrow_1().unwrap());
 
 			// we looped back around to face1, we're done!
 			if core::ptr::eq(face1,face2){
@@ -212,33 +204,6 @@ impl std::fmt::Display for BrushToMeshError{
 }
 impl core::error::Error for BrushToMeshError{}
 
-fn subdivide_max_area(tris:&mut Vec<Vec<VertexId>>,cw_verts:&[(VertexId,Planar64Vec3)],i0:usize,i2:usize,id0:VertexId,id2:VertexId,v0:Planar64Vec3,v2:Planar64Vec3){
-	if i0+1==i2{
-		return;
-	}
-	let mut best_i1=i0+1;
-	if i0+2<i2{
-		let mut best_area={
-			let (_,v1)=cw_verts[best_i1.rem_euclid(cw_verts.len())];
-			(v2-v0).cross(v1-v0).length_squared()
-		};
-		for i1 in i0+2..=i2-1{
-			let (_,v1)=cw_verts[i1.rem_euclid(cw_verts.len())];
-			let area=(v2-v0).cross(v1-v0).length_squared();
-			if best_area<area{
-				best_i1=i1;
-				best_area=area;
-			}
-		}
-	}
-	let i1=best_i1;
-	let (id1,v1)=cw_verts[i1.rem_euclid(cw_verts.len())];
-	// draw max area first
-	tris.push(vec![id0,id1,id2]);
-	subdivide_max_area(tris,cw_verts,i0,i1,id0,id1,v0,v1);
-	subdivide_max_area(tris,cw_verts,i1,i2,id1,id2,v1,v2);
-}
-
 pub fn faces_to_mesh(faces:Vec<Vec<integer::Planar64Vec3>>)->model::Mesh{
 	// generate the mesh
 	let mut mb=model::MeshBuilder::new();
@@ -247,34 +212,16 @@ pub fn faces_to_mesh(faces:Vec<Vec<integer::Planar64Vec3>>)->model::Mesh{
 	// normals are ignored by physics
 	let normal=mb.acquire_normal_id(integer::vec3::ZERO);
 
-	let polygon_list=faces.into_iter().flat_map(|face|{
-		let cw_verts=face.into_iter().map(|position|{
-			let pos=mb.acquire_pos_id(position);
-			(mb.acquire_vertex_id(model::IndexedVertex{
+	let polygon_list=faces.into_iter().map(|face|{
+		face.into_iter().map(|pos|{
+			let pos=mb.acquire_pos_id(pos);
+			mb.acquire_vertex_id(model::IndexedVertex{
 				pos,
 				tex,
 				normal,
 				color,
-			}),position)
-		}).collect::<Vec<_>>();
-
-		// scan and select maximum area triangle O(n^3)
-		let len=cw_verts.len();
-		let cw_verts=cw_verts.as_slice();
-		let ((i0,i1,i2),(v0,v1,v2))=cw_verts[..len-2].iter().enumerate().flat_map(|(i0,&(_,v0))|
-			cw_verts[i0+1..len-1].iter().enumerate().flat_map(move|(i1,&(_,v1))|
-				cw_verts[i0+i1+2..].iter().enumerate().map(move|(i2,&(_,v2))|((i0,i0+i1+1,i0+i1+i2+2),(v0,v1,v2)))
-			)
-		).max_by_key(|&(_,(v0,v1,v2))|(v2-v0).cross(v1-v0).length_squared()).unwrap();
-		// scan and select more maximum area triangles n * O(n)
-		let mut tris=Vec::with_capacity(len-2);
-		// da big one
-		let (id0,id1,id2)=(cw_verts[i0].0,cw_verts[i1].0,cw_verts[i2].0);
-		tris.push(vec![id0,id1,id2]);
-		subdivide_max_area(&mut tris,cw_verts,i0,i1,id0,id1,v0,v1);
-		subdivide_max_area(&mut tris,cw_verts,i1,i2,id1,id2,v1,v2);
-		subdivide_max_area(&mut tris,cw_verts,i2,i0+len,id2,id0,v2,v0);
-		tris
+			})
+		}).collect()
 	}).collect();
 
 	let polygon_groups=vec![model::PolygonGroup::PolygonList(model::PolygonList::new(polygon_list))];

lib/common/src/integer.rs

@@ -401,6 +401,10 @@ impl Angle32{
 	pub const NEG_FRAC_PI_2:Self=Self(-1<<30);
 	pub const PI:Self=Self(-1<<31);
 	#[inline]
+	pub const fn raw(num:i32)->Self{
+		Self(num)
+	}
+	#[inline]
 	pub const fn wrap_from_i64(theta:i64)->Self{
 		//take lower bits
 		//note: this was checked on compiler explorer and compiles to 1 instruction!
@@ -558,6 +562,10 @@ pub mod vec3{
 	pub const MAX:Planar64Vec3=Planar64Vec3::new([Planar64::MAX;3]);
 	pub const ZERO:Planar64Vec3=Planar64Vec3::new([Planar64::ZERO;3]);
 	pub const ZERO_2:linear_ops::types::Vector3<Fixed::<2,64>>=linear_ops::types::Vector3::new([Fixed::<2,64>::ZERO;3]);
+	pub const ZERO_3:linear_ops::types::Vector3<Fixed::<3,96>>=linear_ops::types::Vector3::new([Fixed::<3,96>::ZERO;3]);
+	pub const ZERO_4:linear_ops::types::Vector3<Fixed::<4,128>>=linear_ops::types::Vector3::new([Fixed::<4,128>::ZERO;3]);
+	pub const ZERO_5:linear_ops::types::Vector3<Fixed::<5,160>>=linear_ops::types::Vector3::new([Fixed::<5,160>::ZERO;3]);
+	pub const ZERO_6:linear_ops::types::Vector3<Fixed::<6,192>>=linear_ops::types::Vector3::new([Fixed::<6,192>::ZERO;3]);
 	pub const X:Planar64Vec3=Planar64Vec3::new([Planar64::ONE,Planar64::ZERO,Planar64::ZERO]);
 	pub const Y:Planar64Vec3=Planar64Vec3::new([Planar64::ZERO,Planar64::ONE,Planar64::ZERO]);
 	pub const Z:Planar64Vec3=Planar64Vec3::new([Planar64::ZERO,Planar64::ZERO,Planar64::ONE]);