insane sphere gen

Cargo.toml

@@ -18,7 +18,7 @@ rbx_binary = "0.7.1"
 rbx_dom_weak = "2.5.0"
 rbx_reflection_database = "0.2.7"
 rbx_xml = "0.13.1"
-wgpu = "0.17.0"
+wgpu = "0.18.0"
 winit = { version = "0.29.2", features = ["rwh_05"] }
 
 #[profile.release]

src/bvh.rs

@@ -9,22 +9,34 @@ use crate::aabb::Aabb;
 //start with bisection into octrees because a bad bvh is still 1000x better than no bvh
 //sort the centerpoints on each axis (3 lists)
 //bv is put into octant based on whether it is upper or lower in each list
+enum BvhNodeContent{
+	Branch(Vec<BvhNode>),
+	Leaf(usize),
+}
+impl Default for BvhNodeContent{
+	fn default()->Self{
+		Self::Branch(Vec::new())
+	}
+}
 #[derive(Default)]
 pub struct BvhNode{
-	children:Vec<Self>,
-	models:Vec<usize>,
+	content:BvhNodeContent,
 	aabb:Aabb,
 }
 
 impl BvhNode{
 	pub fn the_tester<F:FnMut(usize)>(&self,aabb:&Aabb,f:&mut F){
-		for &model in &self.models{
-			f(model);
-		}
-		for child in &self.children{
+		match &self.content{
+			&BvhNodeContent::Leaf(model)=>f(model),
+			BvhNodeContent::Branch(children)=>for child in children{
+				//this test could be moved outside the match statement
+				//but that would test the root node aabb
+				//you're probably not going to spend a lot of time outside the map,
+				//so the test is extra work for nothing
 				if aabb.intersects(&child.aabb){
 					child.the_tester(aabb,f);
 				}
+			},
 		}
 	}
 }
@@ -37,10 +49,15 @@ fn generate_bvh_node(boxen:Vec<(usize,Aabb)>)->BvhNode{
 	let n=boxen.len();
 	if n<20{
 		let mut aabb=Aabb::default();
-		let models=boxen.into_iter().map(|b|{aabb.join(&b.1);b.0}).collect();
+		let nodes=boxen.into_iter().map(|b|{
+			aabb.join(&b.1);
 			BvhNode{
-			children:Vec::new(),
-			models,
+				content:BvhNodeContent::Leaf(b.0),
+				aabb:b.1,
+			}
+		}).collect();
+		BvhNode{
+			content:BvhNodeContent::Branch(nodes),
 			aabb,
 		}
 	}else{
@@ -99,8 +116,7 @@ fn generate_bvh_node(boxen:Vec<(usize,Aabb)>)->BvhNode{
 			node
 		}).collect();
 		BvhNode{
-			children,
-			models:Vec::new(),
+			content:BvhNodeContent::Branch(children),
 			aabb,
 		}
 	}

src/compat_worker.rs

@@ -3,11 +3,11 @@ pub type INWorker<'a,Task>=CompatNWorker<'a,Task>;
 
 pub struct CompatNWorker<'a,Task>{
 	data:std::marker::PhantomData<Task>,
-	f:Box<dyn FnMut(Task)+'a>,
+	f:Box<dyn FnMut(Task)+Send+'a>,
 }
 
 impl<'a,Task> CompatNWorker<'a,Task>{
-	pub fn new(f:impl FnMut(Task)+'a)->CompatNWorker<'a,Task>{
+	pub fn new(f:impl FnMut(Task)+Send+'a)->CompatNWorker<'a,Task>{
 		Self{
 			data:std::marker::PhantomData,
 			f:Box::new(f),

src/graphics.rs

@@ -1,24 +1,38 @@
 use std::borrow::Cow;
 use wgpu::{util::DeviceExt,AstcBlock,AstcChannel};
-use crate::model_graphics::{GraphicsVertex,ModelGraphicsColor4,ModelGraphicsInstance,ModelGraphicsSingleTexture,IndexedModelGraphicsSingleTexture,IndexedGroupFixedTexture};
+use crate::model_graphics::{GraphicsVertex,GraphicsModelColor4,GraphicsModelInstance,GraphicsModelSingleTexture,IndexedGraphicsModelSingleTexture,IndexedGroupFixedTexture};
 
 #[derive(Clone)]
-pub struct ModelUpdate{
+pub struct GraphicsModelUpdate{
 	transform:Option<glam::Mat4>,
 	color:Option<glam::Vec4>,
 }
 
-struct Entity {
-	index_count: u32,
-	index_buf: wgpu::Buffer,
+struct Entity{
+	index_count:u32,
+	index_buf:wgpu::Buffer,
+}
+fn create_entities<T:bytemuck::Pod>(device:&wgpu::Device,entities:&Vec<Vec<T>>)->Vec<Entity>{
+	entities.iter().map(|indices|{
+		let index_buf=device.create_buffer_init(&wgpu::util::BufferInitDescriptor{
+			label:Some("Index"),
+			contents:bytemuck::cast_slice(indices),
+			usage:wgpu::BufferUsages::INDEX,
+		});
+		Entity{
+			index_buf,
+			index_count:indices.len() as u32,
+		}
+	}).collect()
 }
 
-struct ModelGraphics {
-	instances: Vec<ModelGraphicsInstance>,
-	vertex_buf: wgpu::Buffer,
-	entities: Vec<Entity>,
-	bind_group: wgpu::BindGroup,
-	model_buf: wgpu::Buffer,
+struct GraphicsModel{
+	entities:Vec<Entity>,
+	model_buf:wgpu::Buffer,
+	vertex_buf:wgpu::Buffer,
+	bind_group:wgpu::BindGroup,
+	index_format:wgpu::IndexFormat,
+	instances:Vec<GraphicsModelInstance>,
 }
 
 pub struct GraphicsSamplers{
@@ -57,12 +71,6 @@ fn perspective_rh(fov_x_slope: f32, fov_y_slope: f32, z_near: f32, z_far: f32) -
 	)
 }
 impl GraphicsCamera{
-	pub fn new(screen_size:glam::UVec2,fov:glam::Vec2)->Self{
-		Self{
-			screen_size,
-			fov,
-		}
-	}
 	pub fn proj(&self)->glam::Mat4{
 		perspective_rh(self.fov.x, self.fov.y, 0.5, 2000.0)
 	}
@@ -102,7 +110,7 @@ pub struct GraphicsState{
 	camera:GraphicsCamera,
 	camera_buf: wgpu::Buffer,
 	temp_squid_texture_view: wgpu::TextureView,
-	models: Vec<ModelGraphics>,
+	models: Vec<GraphicsModel>,
 	depth_view: wgpu::TextureView,
 	staging_belt: wgpu::util::StagingBelt,
 }
@@ -206,15 +214,15 @@ impl GraphicsState{
 		let indexed_models_len=indexed_models.models.len();
 		let mut unique_texture_models=Vec::with_capacity(indexed_models_len);
 		for model in indexed_models.models.into_iter(){
-			//convert ModelInstance into ModelGraphicsInstance
-			let instances:Vec<ModelGraphicsInstance>=model.instances.into_iter().filter_map(|instance|{
+			//convert ModelInstance into GraphicsModelInstance
+			let instances:Vec<GraphicsModelInstance>=model.instances.into_iter().filter_map(|instance|{
 				if instance.color.w==0.0{
 					None
 				}else{
-					Some(ModelGraphicsInstance{
+					Some(GraphicsModelInstance{
 						transform: instance.transform.into(),
 						normal_transform: Into::<glam::Mat3>::into(instance.transform.matrix3).inverse().transpose(),
-						color:ModelGraphicsColor4::from(instance.color),
+						color:GraphicsModelColor4::from(instance.color),
 					})
 				}
 			}).collect();
@@ -233,7 +241,7 @@ impl GraphicsState{
 					//create new texture_index
 					let texture_index=unique_textures.len();
 					unique_textures.push(group.texture);
-					unique_texture_models.push(IndexedModelGraphicsSingleTexture{
+					unique_texture_models.push(IndexedGraphicsModelSingleTexture{
 						unique_pos:model.unique_pos.iter().map(|&v|*Into::<glam::Vec3>::into(v).as_ref()).collect(),
 						unique_tex:model.unique_tex.iter().map(|v|*v.as_ref()).collect(),
 						unique_normal:model.unique_normal.iter().map(|&v|*Into::<glam::Vec3>::into(v).as_ref()).collect(),
@@ -367,10 +375,10 @@ impl GraphicsState{
 						//creating the vertex map is slightly different because the vertices are directly hashable
 						let map_vertex_id:Vec<u32>=model.unique_vertices.iter().map(|unmapped_vertex|{
 							let vertex=crate::model::IndexedVertex{
-								pos:map_pos_id[unmapped_vertex.pos as usize] as u32,
-								tex:map_tex_id[unmapped_vertex.tex as usize] as u32,
-								normal:map_normal_id[unmapped_vertex.normal as usize] as u32,
-								color:map_color_id[unmapped_vertex.color as usize] as u32,
+								pos:map_pos_id[unmapped_vertex.pos as usize],
+								tex:map_tex_id[unmapped_vertex.tex as usize],
+								normal:map_normal_id[unmapped_vertex.normal as usize],
+								color:map_color_id[unmapped_vertex.color as usize],
 							};
 							(if let Some(&vertex_id)=vertex_id_from.get(&vertex){
 								vertex_id
@@ -388,7 +396,7 @@ impl GraphicsState{
 						}
 					}
 					//push model into dedup
-					deduplicated_models.push(IndexedModelGraphicsSingleTexture{
+					deduplicated_models.push(IndexedGraphicsModelSingleTexture{
 						unique_pos,
 						unique_tex,
 						unique_normal,
@@ -398,7 +406,7 @@ impl GraphicsState{
 						groups:vec![IndexedGroupFixedTexture{
 							polys
 						}],
-						instances:vec![ModelGraphicsInstance{
+						instances:vec![GraphicsModelInstance{
 							transform:glam::Mat4::IDENTITY,
 							normal_transform:glam::Mat3::IDENTITY,
 							color
@@ -416,10 +424,9 @@ impl GraphicsState{
 
 		//de-index models
 		let deduplicated_models_len=deduplicated_models.len();
-		let models:Vec<ModelGraphicsSingleTexture>=deduplicated_models.into_iter().map(|model|{
+		let models:Vec<GraphicsModelSingleTexture>=deduplicated_models.into_iter().map(|model|{
 			let mut vertices = Vec::new();
 			let mut index_from_vertex = std::collections::HashMap::new();//::<IndexedVertex,usize>
-			let mut entities = Vec::new();
 			//this mut be combined in a more complex way if the models use different render patterns per group
 				let mut indices = Vec::new();
 			for group in model.groups {
@@ -430,7 +437,7 @@ impl GraphicsState{
 							if let Some(&i)=index_from_vertex.get(&vertex_index){
 								indices.push(i);
 							}else{
-								let i=vertices.len() as u16;
+								let i=vertices.len();
 								let vertex=&model.unique_vertices[vertex_index as usize];
 								vertices.push(GraphicsVertex{
 									pos: model.unique_pos[vertex.pos as usize],
@@ -445,11 +452,16 @@ impl GraphicsState{
 					}
 				}
 			}
-				entities.push(indices);
-			ModelGraphicsSingleTexture{
+			GraphicsModelSingleTexture{
 				instances:model.instances,
+				entities:if (u32::MAX as usize)<vertices.len(){
+					panic!("Model has too many vertices!")
+				}else if (u16::MAX as usize)<vertices.len(){
+					crate::model_graphics::Entities::U32(vec![indices.into_iter().map(|vertex_id|vertex_id as u32).collect()])
+				}else{
+					crate::model_graphics::Entities::U16(vec![indices.into_iter().map(|vertex_id|vertex_id as u16).collect()])
+				},
 				vertices,
-				entities,
 				texture:model.texture,
 			}
 		}).collect();
@@ -502,20 +514,17 @@ impl GraphicsState{
 					usage: wgpu::BufferUsages::VERTEX,
 				});
 				//all of these are being moved here
-				self.models.push(ModelGraphics{
+				self.models.push(GraphicsModel{
 					instances:instances_chunk.to_vec(),
 					vertex_buf,
-					entities: model.entities.iter().map(|indices|{
-						let index_buf = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
-							label: Some("Index"),
-							contents: bytemuck::cast_slice(&indices),
-							usage: wgpu::BufferUsages::INDEX,
-						});
-						Entity {
-							index_buf,
-							index_count: indices.len() as u32,
-						}
-					}).collect(),
+					index_format:match &model.entities{
+						crate::model_graphics::Entities::U32(_)=>wgpu::IndexFormat::Uint32,
+						crate::model_graphics::Entities::U16(_)=>wgpu::IndexFormat::Uint16,
+					},
+					entities:match &model.entities{
+						crate::model_graphics::Entities::U32(entities)=>create_entities(device,entities),
+						crate::model_graphics::Entities::U16(entities)=>create_entities(device,entities),
+					},
 					bind_group: model_bind_group,
 					model_buf,
 				});
@@ -935,17 +944,19 @@ impl GraphicsState{
 							b: 0.3,
 							a: 1.0,
 						}),
-						store: true,
+						store:wgpu::StoreOp::Store,
 					},
 				})],
 				depth_stencil_attachment: Some(wgpu::RenderPassDepthStencilAttachment {
 					view: &self.depth_view,
 					depth_ops: Some(wgpu::Operations {
 						load: wgpu::LoadOp::Clear(1.0),
-						store: false,
+						store:wgpu::StoreOp::Discard,
 					}),
 					stencil_ops: None,
 				}),
+				timestamp_writes:Default::default(),
+				occlusion_query_set:Default::default(),
 			});
 
 			rpass.set_bind_group(0, &self.bind_groups.camera, &[]);
@@ -956,9 +967,9 @@ impl GraphicsState{
 				rpass.set_bind_group(2, &model.bind_group, &[]);
 				rpass.set_vertex_buffer(0, model.vertex_buf.slice(..));
 
-				for entity in model.entities.iter() {
-					rpass.set_index_buffer(entity.index_buf.slice(..), wgpu::IndexFormat::Uint16);
-					rpass.draw_indexed(0..entity.index_count, 0, 0..model.instances.len() as u32);
+				for entity in model.entities.iter(){
+					rpass.set_index_buffer(entity.index_buf.slice(..),model.index_format);
+					rpass.draw_indexed(0..entity.index_count,0,0..model.instances.len() as u32);
 				}
 			}
 
@@ -973,7 +984,7 @@ impl GraphicsState{
 }
 const MODEL_BUFFER_SIZE:usize=4*4 + 12 + 4;//let size=std::mem::size_of::<ModelInstance>();
 const MODEL_BUFFER_SIZE_BYTES:usize=MODEL_BUFFER_SIZE*4;
-fn get_instances_buffer_data(instances:&[ModelGraphicsInstance]) -> Vec<f32> {
+fn get_instances_buffer_data(instances:&[GraphicsModelInstance]) -> Vec<f32> {
 	let mut raw = Vec::with_capacity(MODEL_BUFFER_SIZE*instances.len());
 	for (i,mi) in instances.iter().enumerate(){
 		let mut v = raw.split_off(MODEL_BUFFER_SIZE*i);

src/graphics_worker.rs

@@ -1,6 +1,6 @@
 pub enum Instruction{
 	Render(crate::physics::PhysicsOutputState,crate::integer::Time,glam::IVec2),
-	//UpdateModel(crate::graphics::ModelUpdate),
+	//UpdateModel(crate::graphics::GraphicsModelUpdate),
 	Resize(winit::dpi::PhysicalSize<u32>,crate::settings::UserSettings),
 	GenerateModels(crate::model::IndexedModelInstances),
 	ClearModels,

src/integer.rs

@@ -315,8 +315,8 @@ impl Angle32{
 	pub fn clamp(&self,theta_min:Self,theta_max:Self)->Self{
 		//((max-min as u32)/2 as i32)+min
 		let midpoint=((
-			u32::from_ne_bytes(theta_max.0.to_ne_bytes())
-			.wrapping_sub(u32::from_ne_bytes(theta_min.0.to_ne_bytes()))
+			(theta_max.0 as u32)
+			.wrapping_sub(theta_min.0 as u32)
 			/2
 		) as i32)//(u32::MAX/2) as i32 ALWAYS works
 		.wrapping_add(theta_min.0);

src/load_roblox.rs

@@ -52,6 +52,7 @@ fn get_attributes(name:&str,can_collide:bool,velocity:Planar64Vec3,force_interse
 			force_can_collide=false;
 			general.accelerator=Some(crate::model::GameMechanicAccelerator{acceleration:velocity});
 		},
+		"UnorderedCheckpoint"=>general.checkpoint=Some(crate::model::GameMechanicCheckpoint::Unordered{mode_id:0}),
 		"SetVelocity"=>general.trajectory=Some(crate::model::GameMechanicSetTrajectory::Velocity(velocity)),
 		"MapFinish"=>{force_can_collide=false;general.zone=Some(crate::model::GameMechanicZone{mode_id:0,behaviour:crate::model::ZoneBehaviour::Finish})},
 		"MapAnticheat"=>{force_can_collide=false;general.zone=Some(crate::model::GameMechanicZone{mode_id:0,behaviour:crate::model::ZoneBehaviour::Anitcheat})},
@@ -110,6 +111,12 @@ fn get_attributes(name:&str,can_collide:bool,velocity:Planar64Vec3,force_interse
 					"WormholeIn"=>general.teleport_behaviour=Some(crate::model::TeleportBehaviour::Wormhole(crate::model::GameMechanicWormhole{destination_model_id:captures[2].parse::<u32>().unwrap()})),
 					_=>panic!("regex3[1] messed up bad"),
 				}
+			}else if let Some(captures)=lazy_regex::regex!(r"^(OrderedCheckpoint)(\d+)$")
+			.captures(other){
+				match &captures[1]{
+					"OrderedCheckpoint"=>general.checkpoint=Some(crate::model::GameMechanicCheckpoint::Ordered{mode_id:0,checkpoint_id:captures[2].parse::<u32>().unwrap()}),
+					_=>panic!("regex3[1] messed up bad"),
+				}
 			}
 		}
 	}
@@ -257,14 +264,12 @@ pub fn generate_indexed_models(dom:rbx_dom_weak::WeakDom) -> crate::model::Index
 						spawn_point=model_transform.transform_point3(Planar64Vec3::ZERO)+Planar64Vec3::Y*5/2;
 						Some(crate::model::TempIndexedAttributes::Start(crate::model::TempAttrStart{mode_id:0}))
 					},
-					"UnorderedCheckpoint"=>Some(crate::model::TempIndexedAttributes::UnorderedCheckpoint(crate::model::TempAttrUnorderedCheckpoint{mode_id:0})),
 					other=>{
-						let regman=lazy_regex::regex!(r"^(BonusStart|Spawn|ForceSpawn|OrderedCheckpoint|WormholeOut)(\d+)$");
+						let regman=lazy_regex::regex!(r"^(BonusStart|Spawn|ForceSpawn|WormholeOut)(\d+)$");
 						if let Some(captures) = regman.captures(other) {
 							match &captures[1]{
 								"BonusStart"=>Some(crate::model::TempIndexedAttributes::Start(crate::model::TempAttrStart{mode_id:captures[2].parse::<u32>().unwrap()})),
 								"Spawn"|"ForceSpawn"=>Some(crate::model::TempIndexedAttributes::Spawn(crate::model::TempAttrSpawn{mode_id:0,stage_id:captures[2].parse::<u32>().unwrap()})),
-								"OrderedCheckpoint"=>Some(crate::model::TempIndexedAttributes::OrderedCheckpoint(crate::model::TempAttrOrderedCheckpoint{mode_id:0,checkpoint_id:captures[2].parse::<u32>().unwrap()})),
 								"WormholeOut"=>Some(crate::model::TempIndexedAttributes::Wormhole(crate::model::TempAttrWormhole{wormhole_id:captures[2].parse::<u32>().unwrap()})),
 								_=>None,
 							}
@@ -417,7 +422,7 @@ pub fn generate_indexed_models(dom:rbx_dom_weak::WeakDom) -> crate::model::Index
 					indexed_models.push(match basepart_texture_description{
 						RobloxBasePartDescription::Sphere=>primitives::unit_sphere(),
 						RobloxBasePartDescription::Part(part_texture_description)=>{
-							let mut cube_face_description=primitives::CubeFaceDescription::new();
+							let mut cube_face_description=primitives::CubeFaceDescription::default();
 							for (face_id,roblox_face_description) in part_texture_description.iter().enumerate(){
 								cube_face_description.insert(
 								match face_id{
@@ -438,7 +443,7 @@ pub fn generate_indexed_models(dom:rbx_dom_weak::WeakDom) -> crate::model::Index
 						},
 						RobloxBasePartDescription::Cylinder=>primitives::unit_cylinder(),
 						RobloxBasePartDescription::Wedge(wedge_texture_description)=>{
-							let mut wedge_face_description=primitives::WedgeFaceDescription::new();
+							let mut wedge_face_description=primitives::WedgeFaceDescription::default();
 							for (face_id,roblox_face_description) in wedge_texture_description.iter().enumerate(){
 								wedge_face_description.insert(
 								match face_id{
@@ -457,7 +462,7 @@ pub fn generate_indexed_models(dom:rbx_dom_weak::WeakDom) -> crate::model::Index
 							primitives::generate_partial_unit_wedge(wedge_face_description)
 						},
 						RobloxBasePartDescription::CornerWedge(cornerwedge_texture_description)=>{
-							let mut cornerwedge_face_description=primitives::CornerWedgeFaceDescription::new();
+							let mut cornerwedge_face_description=primitives::CornerWedgeFaceDescription::default();
 							for (face_id,roblox_face_description) in cornerwedge_texture_description.iter().enumerate(){
 								cornerwedge_face_description.insert(
 								match face_id{

src/model.rs

@@ -50,10 +50,10 @@ pub struct IndexedModelInstances{
 }
 //stage description referencing flattened ids is spooky, but the map loading is meant to be deterministic.
 pub struct ModeDescription{
+	//TODO: put "default" style modifiers in mode
+	//pub style:StyleModifiers,
 	pub start:usize,//start=model_id
 	pub spawns:Vec<usize>,//spawns[spawn_id]=model_id
-	pub ordered_checkpoints:Vec<usize>,//ordered_checkpoints[checkpoint_id]=model_id
-	pub unordered_checkpoints:Vec<usize>,//unordered_checkpoints[checkpoint_id]=model_id
 	pub spawn_from_stage_id:std::collections::HashMap::<u32,usize>,
 	pub ordered_checkpoint_from_checkpoint_id:std::collections::HashMap::<u32,usize>,
 }
@@ -61,9 +61,6 @@ impl ModeDescription{
 	pub fn get_spawn_model_id(&self,stage_id:u32)->Option<&usize>{
 		self.spawns.get(*self.spawn_from_stage_id.get(&stage_id)?)
 	}
-	pub fn get_ordered_checkpoint_model_id(&self,checkpoint_id:u32)->Option<&usize>{
-		self.ordered_checkpoints.get(*self.ordered_checkpoint_from_checkpoint_id.get(&checkpoint_id)?)
-	}
 }
 //I don't want this code to exist!
 #[derive(Clone)]
@@ -76,23 +73,12 @@ pub struct TempAttrSpawn{
 	pub stage_id:u32,
 }
 #[derive(Clone)]
-pub struct TempAttrOrderedCheckpoint{
-	pub mode_id:u32,
-	pub checkpoint_id:u32,
-}
-#[derive(Clone)]
-pub struct TempAttrUnorderedCheckpoint{
-	pub mode_id:u32,
-}
-#[derive(Clone)]
 pub struct TempAttrWormhole{
 	pub wormhole_id:u32,
 }
 pub enum TempIndexedAttributes{
 	Start(TempAttrStart),
 	Spawn(TempAttrSpawn),
-	OrderedCheckpoint(TempAttrOrderedCheckpoint),
-	UnorderedCheckpoint(TempAttrUnorderedCheckpoint),
 	Wormhole(TempAttrWormhole),
 }
 
@@ -126,6 +112,16 @@ pub enum GameMechanicBooster{
 	Energy{direction:Planar64Vec3,energy:Planar64},//increase energy in direction
 }
 #[derive(Clone)]
+pub enum GameMechanicCheckpoint{
+	Ordered{
+		mode_id:u32,
+		checkpoint_id:u32,
+	},
+	Unordered{
+		mode_id:u32,
+	},
+}
+#[derive(Clone)]
 pub enum TrajectoryChoice{
 	HighArcLongDuration,//underhand lob at target: less horizontal speed and more air time
 	LowArcShortDuration,//overhand throw at target: more horizontal speed and less air time
@@ -171,6 +167,13 @@ pub enum StageElementBehaviour{
  	Trigger,
  	Teleport,
  	Platform,
+ 	//Acts like a trigger if you haven't hit all the checkpoints.
+ 	Checkpoint{
+ 		//if this is 2 you must have hit OrderedCheckpoint(0) OrderedCheckpoint(1) OrderedCheckpoint(2) to pass
+ 		ordered_checkpoint_id:Option<u32>,
+ 		//if this is 2 you must have hit at least 2 UnorderedCheckpoints to pass
+ 		unordered_checkpoint_count:u32,
+ 	},
  	JumpLimit(u32),
  	//Speedtrap(TrapCondition),//Acts as a trigger with a speed condition
 }
@@ -199,15 +202,17 @@ pub enum TeleportBehaviour{
 pub struct GameMechanicAttributes{
 	pub zone:Option<GameMechanicZone>,
 	pub booster:Option<GameMechanicBooster>,
+	pub checkpoint:Option<GameMechanicCheckpoint>,
 	pub trajectory:Option<GameMechanicSetTrajectory>,
 	pub teleport_behaviour:Option<TeleportBehaviour>,
 	pub accelerator:Option<GameMechanicAccelerator>,
 }
 impl GameMechanicAttributes{
 	pub fn any(&self)->bool{
-		self.booster.is_some()
+		self.zone.is_some()
+		||self.booster.is_some()
+		||self.checkpoint.is_some()
 		||self.trajectory.is_some()
-		||self.zone.is_some()
 		||self.teleport_behaviour.is_some()
 		||self.accelerator.is_some()
 	}

src/model_graphics.rs

@@ -11,7 +11,7 @@ pub struct GraphicsVertex {
 pub struct IndexedGroupFixedTexture{
 	pub polys:Vec<IndexedPolygon>,
 }
-pub struct IndexedModelGraphicsSingleTexture{
+pub struct IndexedGraphicsModelSingleTexture{
 	pub unique_pos:Vec<[f32; 3]>,
 	pub unique_tex:Vec<[f32; 2]>,
 	pub unique_normal:Vec<[f32; 3]>,
@@ -19,37 +19,41 @@ pub struct IndexedModelGraphicsSingleTexture{
 	pub unique_vertices:Vec<IndexedVertex>,
 	pub texture:Option<u32>,//RenderPattern? material/texture/shader/flat color
 	pub groups: Vec<IndexedGroupFixedTexture>,
-	pub instances:Vec<ModelGraphicsInstance>,
+	pub instances:Vec<GraphicsModelInstance>,
 }
-pub struct ModelGraphicsSingleTexture{
-	pub instances: Vec<ModelGraphicsInstance>,
-	pub vertices: Vec<GraphicsVertex>,
-	pub entities: Vec<Vec<u16>>,
-	pub texture: Option<u32>,
+pub enum Entities{
+	U32(Vec<Vec<u32>>),
+	U16(Vec<Vec<u16>>),
+}
+pub struct GraphicsModelSingleTexture{
+	pub instances:Vec<GraphicsModelInstance>,
+	pub vertices:Vec<GraphicsVertex>,
+	pub entities:Entities,
+	pub texture:Option<u32>,
 }
 #[derive(Clone,PartialEq)]
-pub struct ModelGraphicsColor4(glam::Vec4);
-impl ModelGraphicsColor4{
+pub struct GraphicsModelColor4(glam::Vec4);
+impl GraphicsModelColor4{
 	pub const fn get(&self)->glam::Vec4{
 		self.0
 	}
 }
-impl From<glam::Vec4> for ModelGraphicsColor4{
+impl From<glam::Vec4> for GraphicsModelColor4{
 	fn from(value:glam::Vec4)->Self{
 		Self(value)
 	}
 }
-impl std::hash::Hash for ModelGraphicsColor4{
+impl std::hash::Hash for GraphicsModelColor4{
 	fn hash<H: std::hash::Hasher>(&self,state:&mut H) {
 		for &f in self.0.as_ref(){
 			bytemuck::cast::<f32,u32>(f).hash(state);
 		}
 	}
 }
-impl Eq for ModelGraphicsColor4{}
+impl Eq for GraphicsModelColor4{}
 #[derive(Clone)]
-pub struct ModelGraphicsInstance{
+pub struct GraphicsModelInstance{
 	pub transform:glam::Mat4,
 	pub normal_transform:glam::Mat3,
-	pub color:ModelGraphicsColor4,
+	pub color:GraphicsModelColor4,
 }

src/physics.rs

@@ -155,7 +155,7 @@ impl Default for Modes{
 }
 
 struct PhysicsModels{
-	models:Vec<ModelPhysics>,
+	models:Vec<PhysicsModel>,
 	model_id_from_wormhole_id:std::collections::HashMap::<u32,usize>,
 }
 impl PhysicsModels{
@@ -163,13 +163,13 @@ impl PhysicsModels{
 		self.models.clear();
 		self.model_id_from_wormhole_id.clear();
 	}
-	fn get(&self,i:usize)->Option<&ModelPhysics>{
+	fn get(&self,i:usize)->Option<&PhysicsModel>{
 		self.models.get(i)
 	}
-	fn get_wormhole_model(&self,wormhole_id:u32)->Option<&ModelPhysics>{
+	fn get_wormhole_model(&self,wormhole_id:u32)->Option<&PhysicsModel>{
 		self.models.get(*self.model_id_from_wormhole_id.get(&wormhole_id)?)
 	}
-	fn push(&mut self,model:ModelPhysics)->usize{
+	fn push(&mut self,model:PhysicsModel)->usize{
 		let model_id=self.models.len();
 		self.models.push(model);
 		model_id
@@ -185,8 +185,7 @@ impl Default for PhysicsModels{
 }
 
 #[derive(Clone)]
-pub struct PhysicsCamera {
-	offset: Planar64Vec3,
+pub struct PhysicsCamera{
 	//punch: Planar64Vec3,
 	//punch_velocity: Planar64Vec3,
 	sensitivity:Ratio64Vec2,//dots to Angle32 ratios
@@ -204,16 +203,6 @@ pub struct PhysicsCamera {
 }
 
 impl PhysicsCamera {
-	pub fn from_offset(offset:Planar64Vec3) -> Self {
-		Self{
-			offset,
-			sensitivity:Ratio64Vec2::ONE*200_000,
-			mouse:MouseState::default(),//t=0 does not cause divide by zero because it's immediately replaced
-			clamped_mouse_pos:glam::IVec2::ZERO,
-			angle_pitch_lower_limit:-Angle32::FRAC_PI_2,
-			angle_pitch_upper_limit:Angle32::FRAC_PI_2,
-		}
-	}
 	pub fn move_mouse(&mut self,mouse_pos:glam::IVec2){
 		let mut unclamped_mouse_pos=self.clamped_mouse_pos+mouse_pos-self.mouse.pos;
 		unclamped_mouse_pos.y=unclamped_mouse_pos.y.clamp(
@@ -247,7 +236,6 @@ impl PhysicsCamera {
 impl std::default::Default for PhysicsCamera{
 	fn default()->Self{
 		Self{
-			offset:Planar64Vec3::ZERO,//TODO: delete this from PhysicsCamera, it should be GraphicsCamera only
 			sensitivity:Ratio64Vec2::ONE*200_000,
 			mouse:MouseState::default(),//t=0 does not cause divide by zero because it's immediately replaced
 			clamped_mouse_pos:glam::IVec2::ZERO,
@@ -258,13 +246,18 @@ impl std::default::Default for PhysicsCamera{
 }
 
 pub struct GameMechanicsState{
-	pub stage_id:u32,
-	//jump_counts:HashMap<u32,u32>,
+	stage_id:u32,
+	jump_counts:std::collections::HashMap<usize,u32>,//model_id -> jump count
+	next_ordered_checkpoint_id:u32,//which OrderedCheckpoint model_id you must pass next (if 0 you haven't passed OrderedCheckpoint0)
+	unordered_checkpoints:std::collections::HashSet<usize>,//hashset of UnorderedCheckpoint model ids
 }
 impl std::default::Default for GameMechanicsState{
-	fn default() -> Self {
+	fn default()->Self{
 		Self{
 			stage_id:0,
+			next_ordered_checkpoint_id:0,
+			unordered_checkpoints:std::collections::HashSet::new(),
+			jump_counts:std::collections::HashMap::new(),
 		}
 	}
 }
@@ -288,10 +281,23 @@ enum JumpImpulse{
 //Energy means it adds energy
 //Linear means it linearly adds on
 
+enum EnableStrafe{
+	Always,
+	MaskAny(u32),//hsw, shsw
+	MaskAll(u32),
+	//Function(Box<dyn Fn(u32)->bool>),
+}
+
+struct StrafeSettings{
+	enable:EnableStrafe,
+	air_accel_limit:Option<Planar64>,
+	tick_rate:Ratio64,
+}
+
 struct StyleModifiers{
-	controls_mask:u32,//controls which are unable to be activated
-	controls_held:u32,//controls which must be active to be able to strafe
-	strafe_tick_rate:Option<Ratio64>,
+	controls_used:u32,//controls which are allowed to pass into gameplay
+	controls_mask:u32,//controls which are masked from control state (e.g. jump in scroll style)
+	strafe:Option<StrafeSettings>,
 	jump_impulse:JumpImpulse,
 	jump_calculation:JumpCalculation,
 	static_friction:Planar64,
@@ -304,13 +310,13 @@ struct StyleModifiers{
 	swim_speed:Planar64,
 	mass:Planar64,
 	mv:Planar64,
-	air_accel_limit:Option<Planar64>,
 	rocket_force:Option<Planar64>,
 	gravity:Planar64Vec3,
 	hitbox_halfsize:Planar64Vec3,
+	camera_offset:Planar64Vec3,
 }
 impl std::default::Default for StyleModifiers{
-	fn default() -> Self {
+	fn default()->Self{
 		Self::roblox_bhop()
 	}
 }
@@ -330,9 +336,13 @@ impl StyleModifiers{
 
 	fn new()->Self{
 		Self{
+			controls_used:!0,
 			controls_mask:!0,//&!(Self::CONTROL_MOVEUP|Self::CONTROL_MOVEDOWN),
-			controls_held:0,
-			strafe_tick_rate:Some(Ratio64::new(128,Time::ONE_SECOND.nanos() as u64).unwrap()),
+			strafe:Some(StrafeSettings{
+				enable:EnableStrafe::Always,
+				air_accel_limit:None,
+				tick_rate:Ratio64::new(128,Time::ONE_SECOND.nanos() as u64).unwrap(),
+			}),
 			jump_impulse:JumpImpulse::FromEnergy(Planar64::int(512)),
 			jump_calculation:JumpCalculation::Energy,
 			gravity:Planar64Vec3::int(0,-80,0),
@@ -340,7 +350,6 @@ impl StyleModifiers{
 			kinetic_friction:Planar64::int(3),//unrealistic: kinetic friction is typically lower than static
 			mass:Planar64::int(1),
 			mv:Planar64::int(2),
-			air_accel_limit:None,
 			rocket_force:None,
 			walk_speed:Planar64::int(16),
 			walk_accel:Planar64::int(80),
@@ -349,14 +358,19 @@ impl StyleModifiers{
 			ladder_dot:(Planar64::int(1)/2).sqrt(),
 			swim_speed:Planar64::int(12),
 			hitbox_halfsize:Planar64Vec3::int(2,5,2)/2,
+			camera_offset:Planar64Vec3::int(0,2,0),//4.5-2.5=2
 		}
 	}
 
 	fn roblox_bhop()->Self{
 		Self{
+			controls_used:!0,
 			controls_mask:!0,//&!(Self::CONTROL_MOVEUP|Self::CONTROL_MOVEDOWN),
-			controls_held:0,
-			strafe_tick_rate:Some(Ratio64::new(100,Time::ONE_SECOND.nanos() as u64).unwrap()),
+			strafe:Some(StrafeSettings{
+				enable:EnableStrafe::Always,
+				air_accel_limit:None,
+				tick_rate:Ratio64::new(100,Time::ONE_SECOND.nanos() as u64).unwrap(),
+			}),
 			jump_impulse:JumpImpulse::FromTime(Time::from_micros(715_588)),
 			jump_calculation:JumpCalculation::Capped,
 			gravity:Planar64Vec3::int(0,-100,0),
@@ -364,7 +378,6 @@ impl StyleModifiers{
 			kinetic_friction:Planar64::int(3),//unrealistic: kinetic friction is typically lower than static
 			mass:Planar64::int(1),
 			mv:Planar64::int(27)/10,
-			air_accel_limit:None,
 			rocket_force:None,
 			walk_speed:Planar64::int(18),
 			walk_accel:Planar64::int(90),
@@ -373,13 +386,18 @@ impl StyleModifiers{
 			ladder_dot:(Planar64::int(1)/2).sqrt(),
 			swim_speed:Planar64::int(12),
 			hitbox_halfsize:Planar64Vec3::int(2,5,2)/2,
+			camera_offset:Planar64Vec3::int(0,2,0),//4.5-2.5=2
 		}
 	}
 	fn roblox_surf()->Self{
 		Self{
+			controls_used:!0,
 			controls_mask:!0,//&!(Self::CONTROL_MOVEUP|Self::CONTROL_MOVEDOWN),
-			controls_held:0,
-			strafe_tick_rate:Some(Ratio64::new(100,Time::ONE_SECOND.nanos() as u64).unwrap()),
+			strafe:Some(StrafeSettings{
+				enable:EnableStrafe::Always,
+				air_accel_limit:None,
+				tick_rate:Ratio64::new(100,Time::ONE_SECOND.nanos() as u64).unwrap(),
+			}),
 			jump_impulse:JumpImpulse::FromTime(Time::from_micros(715_588)),
 			jump_calculation:JumpCalculation::Capped,
 			gravity:Planar64Vec3::int(0,-50,0),
@@ -387,7 +405,6 @@ impl StyleModifiers{
 			kinetic_friction:Planar64::int(3),//unrealistic: kinetic friction is typically lower than static
 			mass:Planar64::int(1),
 			mv:Planar64::int(27)/10,
-			air_accel_limit:None,
 			rocket_force:None,
 			walk_speed:Planar64::int(18),
 			walk_accel:Planar64::int(90),
@@ -396,15 +413,19 @@ impl StyleModifiers{
 			ladder_dot:(Planar64::int(1)/2).sqrt(),
 			swim_speed:Planar64::int(12),
 			hitbox_halfsize:Planar64Vec3::int(2,5,2)/2,
+			camera_offset:Planar64Vec3::int(0,2,0),//4.5-2.5=2
 		}
 	}
 
 	fn source_bhop()->Self{
-		//camera_offset=vec3(0,64/16-73/16/2,0),
 		Self{
+			controls_used:!0,
 			controls_mask:!0,//&!(Self::CONTROL_MOVEUP|Self::CONTROL_MOVEDOWN),
-			controls_held:0,
-			strafe_tick_rate:Some(Ratio64::new(100,Time::ONE_SECOND.nanos() as u64).unwrap()),
+			strafe:Some(StrafeSettings{
+				enable:EnableStrafe::Always,
+				air_accel_limit:Some(Planar64::raw(150<<28)*66),
+				tick_rate:Ratio64::new(100,Time::ONE_SECOND.nanos() as u64).unwrap(),
+			}),
 			jump_impulse:JumpImpulse::FromHeight(Planar64::raw(52<<28)),
 			jump_calculation:JumpCalculation::Linear,
 			gravity:Planar64Vec3::raw(0,-800<<28,0),
@@ -412,7 +433,6 @@ impl StyleModifiers{
 			kinetic_friction:Planar64::int(3),//?
 			mass:Planar64::int(1),
 			mv:Planar64::raw(30<<28),
-			air_accel_limit:Some(Planar64::raw(150<<28)*66),
 			rocket_force:None,
 			walk_speed:Planar64::int(18),//?
 			walk_accel:Planar64::int(90),//?
@@ -421,14 +441,18 @@ impl StyleModifiers{
 			ladder_dot:(Planar64::int(1)/2).sqrt(),//?
 			swim_speed:Planar64::int(12),//?
 			hitbox_halfsize:Planar64Vec3::raw(33<<28,73<<28,33<<28)/2,
+			camera_offset:Planar64Vec3::raw(0,(64<<28)-(73<<27),0),
 		}
 	}
 	fn source_surf()->Self{
-		//camera_offset=vec3(0,64/16-73/16/2,0),
 		Self{
+			controls_used:!0,
 			controls_mask:!0,//&!(Self::CONTROL_MOVEUP|Self::CONTROL_MOVEDOWN),
-			controls_held:0,
-			strafe_tick_rate:Some(Ratio64::new(66,Time::ONE_SECOND.nanos() as u64).unwrap()),
+			strafe:Some(StrafeSettings{
+				enable:EnableStrafe::Always,
+				air_accel_limit:Some(Planar64::raw(150<<28)*66),
+				tick_rate:Ratio64::new(66,Time::ONE_SECOND.nanos() as u64).unwrap(),
+			}),
 			jump_impulse:JumpImpulse::FromHeight(Planar64::raw(52<<28)),
 			jump_calculation:JumpCalculation::Linear,
 			gravity:Planar64Vec3::raw(0,-800<<28,0),
@@ -436,7 +460,6 @@ impl StyleModifiers{
 			kinetic_friction:Planar64::int(3),//?
 			mass:Planar64::int(1),
 			mv:Planar64::raw(30<<28),
-			air_accel_limit:Some(Planar64::raw(150<<28)*66),
 			rocket_force:None,
 			walk_speed:Planar64::int(18),//?
 			walk_accel:Planar64::int(90),//?
@@ -445,13 +468,14 @@ impl StyleModifiers{
 			ladder_dot:(Planar64::int(1)/2).sqrt(),//?
 			swim_speed:Planar64::int(12),//?
 			hitbox_halfsize:Planar64Vec3::raw(33<<28,73<<28,33<<28)/2,
+			camera_offset:Planar64Vec3::raw(0,(64<<28)-(73<<27),0),
 		}
 	}
 	fn roblox_rocket()->Self{
 		Self{
-			controls_mask:!0,//&!(Self::CONTROL_MOVEUP|Self::CONTROL_MOVEDOWN),
-			controls_held:0,
-			strafe_tick_rate:None,
+			controls_used:!0,
+			controls_mask:!0,
+			strafe:None,
 			jump_impulse:JumpImpulse::FromTime(Time::from_micros(715_588)),
 			jump_calculation:JumpCalculation::Capped,
 			gravity:Planar64Vec3::int(0,-100,0),
@@ -459,7 +483,6 @@ impl StyleModifiers{
 			kinetic_friction:Planar64::int(3),//unrealistic: kinetic friction is typically lower than static
 			mass:Planar64::int(1),
 			mv:Planar64::int(27)/10,
-			air_accel_limit:None,
 			rocket_force:Some(Planar64::int(200)),
 			walk_speed:Planar64::int(18),
 			walk_accel:Planar64::int(90),
@@ -468,6 +491,7 @@ impl StyleModifiers{
 			ladder_dot:(Planar64::int(1)/2).sqrt(),
 			swim_speed:Planar64::int(12),
 			hitbox_halfsize:Planar64Vec3::int(2,5,2)/2,
+			camera_offset:Planar64Vec3::int(0,2,0),//4.5-2.5=2
 		}
 	}
 
@@ -475,13 +499,19 @@ impl StyleModifiers{
 		controls&self.controls_mask&control==control
 	}
 
+	fn allow_strafe(&self,controls:u32)->bool{
+		//disable strafing according to strafe settings
+		match &self.strafe{
+			Some(StrafeSettings{enable:EnableStrafe::Always,air_accel_limit:_,tick_rate:_})=>true,
+			&Some(StrafeSettings{enable:EnableStrafe::MaskAny(mask),air_accel_limit:_,tick_rate:_})=>mask&controls!=0,
+			&Some(StrafeSettings{enable:EnableStrafe::MaskAll(mask),air_accel_limit:_,tick_rate:_})=>mask&controls==mask,
+			None=>false,
+		}
+	}
+
 	fn get_control_dir(&self,controls:u32)->Planar64Vec3{
 		//don't get fancy just do it
 		let mut control_dir:Planar64Vec3 = Planar64Vec3::ZERO;
-		//Disallow strafing if held controls are not held
-		if controls&self.controls_held!=self.controls_held{
-			return control_dir;
-		}
 		//Apply mask after held check so you can require non-allowed keys to be held for some reason
 		let controls=controls&self.controls_mask;
 		if controls & Self::CONTROL_MOVEFORWARD == Self::CONTROL_MOVEFORWARD {
@@ -573,12 +603,13 @@ pub struct PhysicsState{
 }
 #[derive(Clone,Default)]
 pub struct PhysicsOutputState{
-	camera:PhysicsCamera,
 	body:Body,
+	camera:PhysicsCamera,
+	camera_offset:Planar64Vec3,
 }
 impl PhysicsOutputState{
 	pub fn extrapolate(&self,mouse_pos:glam::IVec2,time:Time)->(glam::Vec3,glam::Vec2){
-		((self.body.extrapolated_position(time)+self.camera.offset).into(),self.camera.simulate_move_angles(mouse_pos))
+		((self.body.extrapolated_position(time)+self.camera_offset).into(),self.camera.simulate_move_angles(mouse_pos))
 	}
 }
 
@@ -597,7 +628,7 @@ enum PhysicsCollisionAttributes{
 	},
 }
 
-pub struct ModelPhysics {
+pub struct PhysicsModel {
 	//A model is a thing that has a hitbox. can be represented by a list of TreyMesh-es
 	//in this iteration, all it needs is extents.
 	mesh: TreyMesh,
@@ -605,7 +636,7 @@ pub struct ModelPhysics {
 	attributes:PhysicsCollisionAttributes,
 }
 
-impl ModelPhysics {
+impl PhysicsModel {
 	fn from_model_transform_attributes(model:&crate::model::IndexedModel,transform:&crate::integer::Planar64Affine3,attributes:PhysicsCollisionAttributes)->Self{
 		let mut aabb=TreyMesh::default();
 		for indexed_vertex in &model.unique_vertices {
@@ -619,8 +650,8 @@ impl ModelPhysics {
 	}
 	pub fn from_model(model:&crate::model::IndexedModel,instance:&crate::model::ModelInstance) -> Option<Self> {
 		match &instance.attributes{
-			crate::model::CollisionAttributes::Contact{contacting,general}=>Some(ModelPhysics::from_model_transform_attributes(model,&instance.transform,PhysicsCollisionAttributes::Contact{contacting:contacting.clone(),general:general.clone()})),
-			crate::model::CollisionAttributes::Intersect{intersecting,general}=>Some(ModelPhysics::from_model_transform_attributes(model,&instance.transform,PhysicsCollisionAttributes::Intersect{intersecting:intersecting.clone(),general:general.clone()})),
+			crate::model::CollisionAttributes::Contact{contacting,general}=>Some(PhysicsModel::from_model_transform_attributes(model,&instance.transform,PhysicsCollisionAttributes::Contact{contacting:contacting.clone(),general:general.clone()})),
+			crate::model::CollisionAttributes::Intersect{intersecting,general}=>Some(PhysicsModel::from_model_transform_attributes(model,&instance.transform,PhysicsCollisionAttributes::Intersect{intersecting:intersecting.clone(),general:general.clone()})),
 			crate::model::CollisionAttributes::Decoration=>None,
 		}
 	}
@@ -647,10 +678,10 @@ pub struct RelativeCollision {
 }
 
 impl RelativeCollision {
-	fn model<'a>(&self,models:&'a PhysicsModels)->Option<&'a ModelPhysics>{
+	fn model<'a>(&self,models:&'a PhysicsModels)->Option<&'a PhysicsModel>{
 		models.get(self.model)
 	}
-	// pub fn mesh(&self,models:&Vec<ModelPhysics>) -> TreyMesh {
+	// pub fn mesh(&self,models:&Vec<PhysicsModel>) -> TreyMesh {
 	// 	return self.model(models).unwrap().face_mesh(self.face).clone()
 	// }
 	fn normal(&self,models:&PhysicsModels) -> Planar64Vec3 {
@@ -737,19 +768,19 @@ impl std::fmt::Display for Body{
 }
 
 impl Default for PhysicsState{
-	fn default() -> Self {
+	fn default()->Self{
  		Self{
 			spawn_point:Planar64Vec3::int(0,50,0),
-			body: Body::with_pva(Planar64Vec3::int(0,50,0),Planar64Vec3::int(0,0,0),Planar64Vec3::int(0,-100,0)),
-			time: Time::ZERO,
+			body:Body::with_pva(Planar64Vec3::int(0,50,0),Planar64Vec3::int(0,0,0),Planar64Vec3::int(0,-100,0)),
+			time:Time::ZERO,
 			style:StyleModifiers::default(),
 			touching:TouchingState::default(),
 			models:PhysicsModels::default(),
 			bvh:crate::bvh::BvhNode::default(),
 			move_state: MoveState::Air,
-			camera: PhysicsCamera::from_offset(Planar64Vec3::int(0,2,0)),//4.5-2.5=2
-			next_mouse: MouseState::default(),
-			controls: 0,
+			camera:PhysicsCamera::default(),
+			next_mouse:MouseState::default(),
+			controls:0,
 			world:WorldState{},
 			game:GameMechanicsState::default(),
 			modes:Modes::default(),
@@ -769,6 +800,7 @@ impl PhysicsState {
 		PhysicsOutputState{
 			body:self.body.clone(),
 			camera:self.camera.clone(),
+			camera_offset:self.style.camera_offset.clone(),
 		}
 	}
 
@@ -784,19 +816,15 @@ impl PhysicsState {
 	pub fn generate_models(&mut self,indexed_models:&crate::model::IndexedModelInstances){
 		let mut starts=Vec::new();
 		let mut spawns=Vec::new();
-		let mut ordered_checkpoints=Vec::new();
-		let mut unordered_checkpoints=Vec::new();
 		for model in &indexed_models.models{
 			//make aabb and run vertices to get realistic bounds
 			for model_instance in &model.instances{
-				if let Some(model_physics)=ModelPhysics::from_model(model,model_instance){
+				if let Some(model_physics)=PhysicsModel::from_model(model,model_instance){
 					let model_id=self.models.push(model_physics);
 					for attr in &model_instance.temp_indexing{
 						match attr{
 							crate::model::TempIndexedAttributes::Start(s)=>starts.push((model_id,s.clone())),
 							crate::model::TempIndexedAttributes::Spawn(s)=>spawns.push((model_id,s.clone())),
-							crate::model::TempIndexedAttributes::OrderedCheckpoint(s)=>ordered_checkpoints.push((model_id,s.clone())),
-							crate::model::TempIndexedAttributes::UnorderedCheckpoint(s)=>unordered_checkpoints.push((model_id,s.clone())),
 							crate::model::TempIndexedAttributes::Wormhole(s)=>{self.models.model_id_from_wormhole_id.insert(s.wormhole_id,model_id);},
 						}
 					}
@@ -808,9 +836,9 @@ impl PhysicsState {
 		//this code builds ModeDescriptions from the unsorted lists at the top of the function
 		starts.sort_by_key(|tup|tup.1.mode_id);
 		let mut mode_id_from_map_mode_id=std::collections::HashMap::new();
-		let mut modedatas:Vec<(usize,Vec<(u32,usize)>,Vec<(u32,usize)>,Vec<usize>,u32)>=starts.into_iter().enumerate().map(|(i,(model_id,s))|{
+		let mut modedatas:Vec<(usize,Vec<(u32,usize)>,u32)>=starts.into_iter().enumerate().map(|(i,(model_id,s))|{
 			mode_id_from_map_mode_id.insert(s.mode_id,i);
-			(model_id,Vec::new(),Vec::new(),Vec::new(),s.mode_id)
+			(model_id,Vec::new(),s.mode_id)
 		}).collect();
 		for (model_id,s) in spawns{
 			if let Some(mode_id)=mode_id_from_map_mode_id.get(&s.mode_id){
@@ -819,30 +847,13 @@ impl PhysicsState {
 				}
 			}
 		}
-		for (model_id,s) in ordered_checkpoints{
-			if let Some(mode_id)=mode_id_from_map_mode_id.get(&s.mode_id){
-				if let Some(modedata)=modedatas.get_mut(*mode_id){
-					modedata.2.push((s.checkpoint_id,model_id));
-				}
-			}
-		}
-		for (model_id,s) in unordered_checkpoints{
-			if let Some(mode_id)=mode_id_from_map_mode_id.get(&s.mode_id){
-				if let Some(modedata)=modedatas.get_mut(*mode_id){
-					modedata.3.push(model_id);
-				}
-			}
-		}
 		for mut tup in modedatas.into_iter(){
 			tup.1.sort_by_key(|tup|tup.0);
-			tup.2.sort_by_key(|tup|tup.0);
 			let mut eshmep1=std::collections::HashMap::new();
 			let mut eshmep2=std::collections::HashMap::new();
-			self.modes.insert(tup.4,crate::model::ModeDescription{
+			self.modes.insert(tup.2,crate::model::ModeDescription{
 				start:tup.0,
 				spawns:tup.1.into_iter().enumerate().map(|(i,tup)|{eshmep1.insert(tup.0,i);tup.1}).collect(),
-				ordered_checkpoints:tup.2.into_iter().enumerate().map(|(i,tup)|{eshmep2.insert(tup.0,i);tup.1}).collect(),
-				unordered_checkpoints:tup.3,
 				spawn_from_stage_id:eshmep1,
 				ordered_checkpoint_from_checkpoint_id:eshmep2,
 			});
@@ -883,10 +894,10 @@ impl PhysicsState {
 		}
 	}
 
-	fn next_strafe_instruction(&self) -> Option<TimedInstruction<PhysicsInstruction>> {
-		self.style.strafe_tick_rate.as_ref().map(|strafe_tick_rate|{
+	fn next_strafe_instruction(&self)->Option<TimedInstruction<PhysicsInstruction>>{
+		self.style.strafe.as_ref().map(|strafe|{
 			TimedInstruction{
-				time:Time::from_nanos(strafe_tick_rate.rhs_div_int(strafe_tick_rate.mul_int(self.time.nanos())+1)),
+				time:Time::from_nanos(strafe.tick_rate.rhs_div_int(strafe.tick_rate.mul_int(self.time.nanos())+1)),
 				//only poll the physics if there is a before and after mouse event
 				instruction:PhysicsInstruction::StrafeTick
 			}
@@ -975,8 +986,7 @@ impl PhysicsState {
 		//collect x
 		match collision_data.face {
 			TreyMeshFace::Top|TreyMeshFace::Back|TreyMeshFace::Bottom|TreyMeshFace::Front=>{
-				let (roots,nroots)=zeroes2(mesh0.max.x()-mesh1.min.x(),v.x(),a.x()/2);
-				for &t in &roots[0..nroots]{
+				for t in zeroes2(mesh0.max.x()-mesh1.min.x(),v.x(),a.x()/2) {
 					//negative t = back in time
 					//must be moving towards surface to collide
 					//must beat the current soonest collision time
@@ -989,8 +999,7 @@ impl PhysicsState {
 						break;
 					}
 				}
-				let (roots,nroots)=zeroes2(mesh0.min.x()-mesh1.max.x(),v.x(),a.x()/2);
-				for &t in &roots[0..nroots]{
+				for t in zeroes2(mesh0.min.x()-mesh1.max.x(),v.x(),a.x()/2) {
 					//negative t = back in time
 					//must be moving towards surface to collide
 					//must beat the current soonest collision time
@@ -1022,8 +1031,7 @@ impl PhysicsState {
 		//collect y
 		match collision_data.face {
 			TreyMeshFace::Left|TreyMeshFace::Back|TreyMeshFace::Right|TreyMeshFace::Front=>{
-				let (roots,nroots)=zeroes2(mesh0.max.y()-mesh1.min.y(),v.y(),a.y()/2);
-				for &t in &roots[0..nroots]{
+				for t in zeroes2(mesh0.max.y()-mesh1.min.y(),v.y(),a.y()/2) {
 					//negative t = back in time
 					//must be moving towards surface to collide
 					//must beat the current soonest collision time
@@ -1036,8 +1044,7 @@ impl PhysicsState {
 						break;
 					}
 				}
-				let (roots,nroots)=zeroes2(mesh0.min.y()-mesh1.max.y(),v.y(),a.y()/2);
-				for &t in &roots[0..nroots]{
+				for t in zeroes2(mesh0.min.y()-mesh1.max.y(),v.y(),a.y()/2) {
 					//negative t = back in time
 					//must be moving towards surface to collide
 					//must beat the current soonest collision time
@@ -1069,8 +1076,7 @@ impl PhysicsState {
 		//collect z
 		match collision_data.face {
 			TreyMeshFace::Left|TreyMeshFace::Bottom|TreyMeshFace::Right|TreyMeshFace::Top=>{
-				let (roots,nroots)=zeroes2(mesh0.max.z()-mesh1.min.z(),v.z(),a.z()/2);
-				for &t in &roots[0..nroots]{
+				for t in zeroes2(mesh0.max.z()-mesh1.min.z(),v.z(),a.z()/2) {
 					//negative t = back in time
 					//must be moving towards surface to collide
 					//must beat the current soonest collision time
@@ -1083,8 +1089,7 @@ impl PhysicsState {
 						break;
 					}
 				}
-				let (roots,nroots)=zeroes2(mesh0.min.z()-mesh1.max.z(),v.z(),a.z()/2);
-				for &t in &roots[0..nroots]{
+				for t in zeroes2(mesh0.min.z()-mesh1.max.z(),v.z(),a.z()/2) {
 					//negative t = back in time
 					//must be moving towards surface to collide
 					//must beat the current soonest collision time
@@ -1130,8 +1135,7 @@ impl PhysicsState {
 		let mut best_time=time_limit;
 		let mut best_face:Option<TreyMeshFace>=None;
 		//collect x
-		let (roots,nroots)=zeroes2(mesh0.max.x()-mesh1.min.x(),v.x(),a.x()/2);
-		for &t in &roots[0..nroots]{
+		for t in zeroes2(mesh0.max.x()-mesh1.min.x(),v.x(),a.x()/2) {
 			//must collide now or in the future
 			//must beat the current soonest collision time
 			//must be moving towards surface
@@ -1147,8 +1151,7 @@ impl PhysicsState {
 				}
 			}
 		}
-		let (roots,nroots)=zeroes2(mesh0.min.x()-mesh1.max.x(),v.x(),a.x()/2);
-		for &t in &roots[0..nroots]{
+		for t in zeroes2(mesh0.min.x()-mesh1.max.x(),v.x(),a.x()/2) {
 			//must collide now or in the future
 			//must beat the current soonest collision time
 			//must be moving towards surface
@@ -1165,8 +1168,7 @@ impl PhysicsState {
 			}
 		}
 		//collect y
-		let (roots,nroots)=zeroes2(mesh0.max.y()-mesh1.min.y(),v.y(),a.y()/2);
-		for &t in &roots[0..nroots]{
+		for t in zeroes2(mesh0.max.y()-mesh1.min.y(),v.y(),a.y()/2) {
 			//must collide now or in the future
 			//must beat the current soonest collision time
 			//must be moving towards surface
@@ -1182,8 +1184,7 @@ impl PhysicsState {
 				}
 			}
 		}
-		let (roots,nroots)=zeroes2(mesh0.min.y()-mesh1.max.y(),v.y(),a.y()/2);
-		for &t in &roots[0..nroots]{
+		for t in zeroes2(mesh0.min.y()-mesh1.max.y(),v.y(),a.y()/2) {
 			//must collide now or in the future
 			//must beat the current soonest collision time
 			//must be moving towards surface
@@ -1200,8 +1201,7 @@ impl PhysicsState {
 			}
 		}
 		//collect z
-		let (roots,nroots)=zeroes2(mesh0.max.z()-mesh1.min.z(),v.z(),a.z()/2);
-		for &t in &roots[0..nroots]{
+		for t in zeroes2(mesh0.max.z()-mesh1.min.z(),v.z(),a.z()/2) {
 			//must collide now or in the future
 			//must beat the current soonest collision time
 			//must be moving towards surface
@@ -1217,8 +1217,7 @@ impl PhysicsState {
 				}
 			}
 		}
-		let (roots,nroots)=zeroes2(mesh0.min.z()-mesh1.max.z(),v.z(),a.z()/2);
-		for &t in &roots[0..nroots]{
+		for t in zeroes2(mesh0.min.z()-mesh1.max.z(),v.z(),a.z()/2) {
 			//must collide now or in the future
 			//must beat the current soonest collision time
 			//must be moving towards surface
@@ -1285,8 +1284,13 @@ fn teleport(body:&mut Body,touching:&mut TouchingState,style:&StyleModifiers,poi
 	//TODO: calculate contacts and determine the actual state
 	//touching.recalculate(body);
 }
+fn teleport_to_spawn(body:&mut Body,touching:&mut TouchingState,style:&StyleModifiers,mode:&crate::model::ModeDescription,models:&PhysicsModels,stage_id:u32)->Option<MoveState>{
+	let model=models.get(*mode.get_spawn_model_id(stage_id)? as usize)?;
+	let point=model.transform.transform_point3(Planar64Vec3::Y)+Planar64Vec3::Y*(style.hitbox_halfsize.y()+Planar64::ONE/16);
+	Some(teleport(body,touching,style,point))
+}
 
-fn run_teleport_behaviour(teleport_behaviour:&Option<crate::model::TeleportBehaviour>,game:&mut GameMechanicsState,models:&PhysicsModels,modes:&Modes,style:&StyleModifiers,touching:&mut TouchingState,body:&mut Body,model:&ModelPhysics)->Option<MoveState>{
+fn run_teleport_behaviour(teleport_behaviour:&Option<crate::model::TeleportBehaviour>,game:&mut GameMechanicsState,models:&PhysicsModels,modes:&Modes,style:&StyleModifiers,touching:&mut TouchingState,body:&mut Body,model:&PhysicsModel)->Option<MoveState>{
 	match teleport_behaviour{
 		Some(crate::model::TeleportBehaviour::StageElement(stage_element))=>{
 			if stage_element.force||game.stage_id<stage_element.stage_id{
@@ -1297,12 +1301,24 @@ fn run_teleport_behaviour(teleport_behaviour:&Option<crate::model::TeleportBehav
 				crate::model::StageElementBehaviour::Trigger
 				|crate::model::StageElementBehaviour::Teleport=>{
 					//I guess this is correct behaviour when trying to teleport to a non-existent spawn but it's still weird
-					let model=models.get(*modes.get_mode(stage_element.mode_id)?.get_spawn_model_id(game.stage_id)? as usize)?;
-					let point=model.transform.transform_point3(Planar64Vec3::Y)+Planar64Vec3::Y*(style.hitbox_halfsize.y()+Planar64::ONE/16);
-					Some(teleport(body,touching,style,point))
+					teleport_to_spawn(body,touching,style,modes.get_mode(stage_element.mode_id)?,models,game.stage_id)
 				},
 				crate::model::StageElementBehaviour::Platform=>None,
-				crate::model::StageElementBehaviour::JumpLimit(_)=>None,//TODO
+				&crate::model::StageElementBehaviour::JumpLimit(jump_limit)=>{
+					//let count=game.jump_counts.get(&model.id);
+					//TODO
+					None
+				},
+				&crate::model::StageElementBehaviour::Checkpoint{ordered_checkpoint_id,unordered_checkpoint_count}=>{
+					if (ordered_checkpoint_id.is_none()||ordered_checkpoint_id.is_some_and(|id|id<game.next_ordered_checkpoint_id))
+						&&unordered_checkpoint_count<=game.unordered_checkpoints.len() as u32{
+						//pass
+						None
+					}else{
+						//fail
+						teleport_to_spawn(body,touching,style,modes.get_mode(stage_element.mode_id)?,models,game.stage_id)
+					}
+				},
 			}
 		},
 		Some(crate::model::TeleportBehaviour::Wormhole(wormhole))=>{

src/primitives.rs

@@ -126,7 +126,146 @@ const CORNERWEDGE_DEFAULT_NORMALS:[Planar64Vec3;5]=[
 	Planar64Vec3::int( 0,-1, 0),//CornerWedge::Bottom
 	Planar64Vec3::int( 0, 0,-1),//CornerWedge::Front
 ];
-//HashMap fits this use case perfectly but feels like using a sledgehammer to drive a nail
+const GON:u32=6;
+const SPHERE_STUFF:([[[[u32;3];4];((GON-1)*(GON-1)) as usize];6])={
+	const CUBE_EDGES:[[u32;2];12]=[[0,1],[0,3],[0,7],[1,2],[1,6],[2,3],[2,5],[3,4],[4,5],[4,7],[5,6],[6,7]];
+	const fn get_pos_id(p:[[u32;3];4],tex_id:u32)->u32{
+		if p[0][1]==tex_id{
+			return p[0][0];
+		}
+		if p[1][1]==tex_id{
+			return p[1][0];
+		}
+		if p[2][1]==tex_id{
+			return p[2][0];
+		}
+		if p[3][1]==tex_id{
+			return p[3][0];
+		}
+		panic!("tex missing")
+	}
+	const fn get_edge_id(v0:u32,v1:u32)->(u32,bool){
+		(match if v0<v1{[v0,v1]}else{[v1,v0]}{
+			[0,1]=>0,
+			[0,3]=>1,
+			[0,7]=>2,
+			[1,2]=>3,
+			[1,6]=>4,
+			[2,3]=>5,
+			[2,5]=>6,
+			[3,4]=>7,
+			[4,5]=>8,
+			[4,7]=>9,
+			[5,6]=>10,
+			[6,7]=>11,
+			_=>panic!(":)")
+		},v0<v1)
+	}
+	const fn get_idx(face_id:u32,v00:u32,v10:u32,v11:u32,v01:u32,x:u32,y:u32)->u32{
+		if x==0&&y==0{
+			return v00
+		}
+		if x==0&&y==GON-1{
+			return v01
+		}
+		if x==GON-1&&y==GON-1{
+			return v11
+		}
+		if x==GON-1&&y==0{
+			return v10
+		}
+		if x==0{
+			//left edge
+			let (edge_id,parity)=get_edge_id(v00,v01);
+			if parity{
+				return 8+edge_id*(GON-2)+(y-1)
+			}else{
+				return 8+edge_id*(GON-2)+(GON-(y-1))
+			}
+		}
+		if x==GON-1{
+			//right edge
+			let (edge_id,parity)=get_edge_id(v10,v11);
+			if parity{
+				return 8+edge_id*(GON-2)+(y-1)
+			}else{
+				return 8+edge_id*(GON-2)+(GON-(y-1))
+			}
+		}
+		if y==0{
+			//top edge
+			let (edge_id,parity)=get_edge_id(v00,v10);
+			if parity{
+				return 8+edge_id*(GON-2)+(x-1)
+			}else{
+				return 8+edge_id*(GON-2)+(GON-(x-1))
+			}
+		}
+		if y==GON-1{
+			//bottom edge
+			let (edge_id,parity)=get_edge_id(v01,v11);
+			if parity{
+				return 8+edge_id*(GON-2)+(x-1)
+			}else{
+				return 8+edge_id*(GON-2)+(GON-(x-1))
+			}
+		}
+		return 8+12*(GON-2)+face_id*(GON-2)*(GON-2)+(x-1)+(y-1)*(GON-2)
+	}
+	//topology (indexed polys)
+	let mut polys=[[[[0u32;3];4];((GON-1)*(GON-1)) as usize];6];
+	let mut face_id=0;
+	while face_id<6{
+		let p=CUBE_DEFAULT_POLYS[face_id];
+		//vertex ids
+		let v00=get_pos_id(p,0);//top left
+		let v10=get_pos_id(p,1);//top right
+		let v11=get_pos_id(p,2);//bottom right
+		let v01=get_pos_id(p,3);//bottom left
+		let mut i=0;
+		while i<(GON-1)*(GON-1){
+			let x=i as u32%GON;
+			let y=i as u32/GON;
+			let i00=get_idx(face_id as u32,v00,v10,v11,v01,x+0,y+0);
+			let i10=get_idx(face_id as u32,v00,v10,v11,v01,x+1,y+0);
+			let i11=get_idx(face_id as u32,v00,v10,v11,v01,x+1,y+1);
+			let i01=get_idx(face_id as u32,v00,v10,v11,v01,x+0,y+1);
+			//[pos,tex,norm]
+			polys[face_id][i as usize][0]=[i00,(x+0)+(y+0)*GON,i00];
+			polys[face_id][i as usize][1]=[i10,(x+1)+(y+0)*GON,i10];
+			polys[face_id][i as usize][2]=[i11,(x+1)+(y+1)*GON,i11];
+			polys[face_id][i as usize][3]=[i01,(x+0)+(y+1)*GON,i01];
+			i+=1;
+		}
+		face_id+=1;
+	}
+	//verts
+	const N_VERTS:usize=(8+12*(GON-2)+6*(GON-2)*(GON-2)) as usize;
+	let mut verts=[Planar64Vec3::ZERO;N_VERTS];
+	let mut i=0;
+	while i<8{
+		verts[i]=CUBE_DEFAULT_VERTICES[i].normalize();
+		i+=1;
+	}
+	i=0;
+	while i<12{
+		//
+	}
+	i=0;
+	while i<6{
+		//
+	}
+	//tex
+	let mut tex=[TextureCoordinate::new(0.0,0.0);(GON*GON) as usize];
+	let mut i=0;
+	while i<(GON*GON) as usize{
+		let x=i as u32%GON;
+		let y=i as u32/GON;
+		tex[i]=TextureCoordinate::new(x as f32/(GON-1) as f32,y as f32/(GON-1) as f32);
+		i+=1;
+	}
+	(verts,tex,polys)
+};
 pub fn unit_sphere()->crate::model::IndexedModel{
 	let mut indexed_model=crate::model::generate_indexed_model_list_from_obj(obj::ObjData::load_buf(&include_bytes!("../models/suzanne.obj")[..]).unwrap(),Color4::ONE).remove(0);
 	for pos in indexed_model.unique_pos.iter_mut(){
@@ -134,9 +273,18 @@ pub fn unit_sphere()->crate::model::IndexedModel{
 	}
 	indexed_model
 }
-pub type CubeFaceDescription=std::collections::HashMap::<CubeFace,FaceDescription>;
+#[derive(Default)]
+pub struct CubeFaceDescription([Option<FaceDescription>;6]);
+impl CubeFaceDescription{
+	pub fn insert(&mut self,index:CubeFace,value:FaceDescription){
+		self.0[index as usize]=Some(value);
+	}
+	pub fn pairs(self)->std::iter::FilterMap<std::iter::Enumerate<std::array::IntoIter<Option<FaceDescription>,6>>,impl FnMut((usize,Option<FaceDescription>))->Option<(usize,FaceDescription)>>{
+		self.0.into_iter().enumerate().filter_map(|v|v.1.map(|u|(v.0,u)))
+	}
+}
 pub fn unit_cube()->crate::model::IndexedModel{
-	let mut t=CubeFaceDescription::new();
+	let mut t=CubeFaceDescription::default();
 	t.insert(CubeFace::Right,FaceDescription::default());
 	t.insert(CubeFace::Top,FaceDescription::default());
 	t.insert(CubeFace::Back,FaceDescription::default());
@@ -153,9 +301,18 @@ pub fn unit_cylinder()->crate::model::IndexedModel{
 	}
 	indexed_model
 }
-pub type WedgeFaceDescription=std::collections::HashMap::<WedgeFace,FaceDescription>;
+#[derive(Default)]
+pub struct WedgeFaceDescription([Option<FaceDescription>;5]);
+impl WedgeFaceDescription{
+	pub fn insert(&mut self,index:WedgeFace,value:FaceDescription){
+		self.0[index as usize]=Some(value);
+	}
+	pub fn pairs(self)->std::iter::FilterMap<std::iter::Enumerate<std::array::IntoIter<Option<FaceDescription>,5>>,impl FnMut((usize,Option<FaceDescription>))->Option<(usize,FaceDescription)>>{
+		self.0.into_iter().enumerate().filter_map(|v|v.1.map(|u|(v.0,u)))
+	}
+}
 pub fn unit_wedge()->crate::model::IndexedModel{
-	let mut t=WedgeFaceDescription::new();
+	let mut t=WedgeFaceDescription::default();
 	t.insert(WedgeFace::Right,FaceDescription::default());
 	t.insert(WedgeFace::TopFront,FaceDescription::default());
 	t.insert(WedgeFace::Back,FaceDescription::default());
@@ -163,9 +320,18 @@ pub fn unit_wedge()->crate::model::IndexedModel{
 	t.insert(WedgeFace::Bottom,FaceDescription::default());
 	generate_partial_unit_wedge(t)
 }
-pub type CornerWedgeFaceDescription=std::collections::HashMap::<CornerWedgeFace,FaceDescription>;
+#[derive(Default)]
+pub struct CornerWedgeFaceDescription([Option<FaceDescription>;5]);
+impl CornerWedgeFaceDescription{
+	pub fn insert(&mut self,index:CornerWedgeFace,value:FaceDescription){
+		self.0[index as usize]=Some(value);
+	}
+	pub fn pairs(self)->std::iter::FilterMap<std::iter::Enumerate<std::array::IntoIter<Option<FaceDescription>,5>>,impl FnMut((usize,Option<FaceDescription>))->Option<(usize,FaceDescription)>>{
+		self.0.into_iter().enumerate().filter_map(|v|v.1.map(|u|(v.0,u)))
+	}
+}
 pub fn unit_cornerwedge()->crate::model::IndexedModel{
-	let mut t=CornerWedgeFaceDescription::new();
+	let mut t=CornerWedgeFaceDescription::default();
 	t.insert(CornerWedgeFace::Right,FaceDescription::default());
 	t.insert(CornerWedgeFace::TopBack,FaceDescription::default());
 	t.insert(CornerWedgeFace::TopLeft,FaceDescription::default());
@@ -189,18 +355,6 @@ impl std::default::Default for FaceDescription{
 		}
 	}
 }
-impl FaceDescription{
-	pub fn new(texture:u32,transform:glam::Affine2,color:Color4)->Self{
-		Self{texture:Some(texture),transform,color}
-	}
-	pub fn from_texture(texture:u32)->Self{
-		Self{
-			texture:Some(texture),
-			transform:glam::Affine2::IDENTITY,
-			color:Color4::ONE,
-		}
-	}
-}
 //TODO: it's probably better to use a shared vertex buffer between all primitives and use indexed rendering instead of generating a unique vertex buffer for each primitive.
 //implementation: put all roblox primitives into one model.groups <- this won't work but I forget why
 pub fn generate_partial_unit_cube(face_descriptions:CubeFaceDescription)->crate::model::IndexedModel{
@@ -212,7 +366,7 @@ pub fn generate_partial_unit_cube(face_descriptions:CubeFaceDescription)->crate:
 	let mut groups=Vec::new();
 	let mut transforms=Vec::new();
 	//note that on a cube every vertex is guaranteed to be unique, so there's no need to hash them against existing vertices.
-	for (face,face_description) in face_descriptions.into_iter(){
+	for (face_id,face_description) in face_descriptions.pairs(){
 		//assume that scanning short lists is faster than hashing.
 		let transform_index=if let Some(transform_index)=transforms.iter().position(|&transform|transform==face_description.transform){
 			transform_index
@@ -233,14 +387,6 @@ pub fn generate_partial_unit_cube(face_descriptions:CubeFaceDescription)->crate:
 			generated_color.push(face_description.color);
 			color_index
 		} as u32;
-		let face_id=match face{
-			CubeFace::Right => 0,
-			CubeFace::Top => 1,
-			CubeFace::Back => 2,
-			CubeFace::Left => 3,
-			CubeFace::Bottom => 4,
-			CubeFace::Front => 5,
-		};
 		//always push normal
 		let normal_index=generated_normal.len() as u32;
 		generated_normal.push(CUBE_DEFAULT_NORMALS[face_id]);
@@ -327,7 +473,7 @@ pub fn generate_partial_unit_wedge(face_descriptions:WedgeFaceDescription)->crat
 	let mut groups=Vec::new();
 	let mut transforms=Vec::new();
 	//note that on a cube every vertex is guaranteed to be unique, so there's no need to hash them against existing vertices.
-	for (face,face_description) in face_descriptions.into_iter(){
+	for (face_id,face_description) in face_descriptions.pairs(){
 		//assume that scanning short lists is faster than hashing.
 		let transform_index=if let Some(transform_index)=transforms.iter().position(|&transform|transform==face_description.transform){
 			transform_index
@@ -348,13 +494,6 @@ pub fn generate_partial_unit_wedge(face_descriptions:WedgeFaceDescription)->crat
 			generated_color.push(face_description.color);
 			color_index
 		} as u32;
-		let face_id=match face{
-			WedgeFace::Right => 0,
-			WedgeFace::TopFront => 1,
-			WedgeFace::Back => 2,
-			WedgeFace::Left => 3,
-			WedgeFace::Bottom => 4,
-		};
 		//always push normal
 		let normal_index=generated_normal.len() as u32;
 		generated_normal.push(WEDGE_DEFAULT_NORMALS[face_id]);
@@ -439,7 +578,7 @@ pub fn generate_partial_unit_cornerwedge(face_descriptions:CornerWedgeFaceDescri
 	let mut groups=Vec::new();
 	let mut transforms=Vec::new();
 	//note that on a cube every vertex is guaranteed to be unique, so there's no need to hash them against existing vertices.
-	for (face,face_description) in face_descriptions.into_iter(){
+	for (face_id,face_description) in face_descriptions.pairs(){
 		//assume that scanning short lists is faster than hashing.
 		let transform_index=if let Some(transform_index)=transforms.iter().position(|&transform|transform==face_description.transform){
 			transform_index
@@ -460,13 +599,6 @@ pub fn generate_partial_unit_cornerwedge(face_descriptions:CornerWedgeFaceDescri
 			generated_color.push(face_description.color);
 			color_index
 		} as u32;
-		let face_id=match face{
-			CornerWedgeFace::Right => 0,
-			CornerWedgeFace::TopBack => 1,
-			CornerWedgeFace::TopLeft => 2,
-			CornerWedgeFace::Bottom => 3,
-			CornerWedgeFace::Front => 4,
-		};
 		//always push normal
 		let normal_index=generated_normal.len() as u32;
 		generated_normal.push(CORNERWEDGE_DEFAULT_NORMALS[face_id]);

src/setup.rs

@@ -41,6 +41,7 @@ fn create_instance()->SetupContextPartial1{
 		instance:wgpu::Instance::new(wgpu::InstanceDescriptor{
 			backends,
 			dx12_shader_compiler,
+			..Default::default()
 		}),
 	}
 }
@@ -169,6 +170,7 @@ impl SetupContextPartial4{
 			.expect("Surface isn't supported by the adapter.");
 		let surface_view_format=config.format.add_srgb_suffix();
 		config.view_formats.push(surface_view_format);
+		config.present_mode=wgpu::PresentMode::AutoNoVsync;
 		self.surface.configure(&self.device, &config);
 
 		SetupContext{

src/zeroes.rs

@@ -2,32 +2,31 @@
 use crate::integer::Planar64;
 
 #[inline]
-pub fn zeroes2(a0:Planar64,a1:Planar64,a2:Planar64)->([Planar64;2],usize){
+pub fn zeroes2(a0:Planar64,a1:Planar64,a2:Planar64) -> Vec<Planar64>{
 	if a2==Planar64::ZERO{
-		let ([ret],ret_len)=zeroes1(a0,a1);
-		return ([ret,Planar64::ZERO],ret_len);
+		return zeroes1(a0, a1);
 	}
 	let radicand=a1.get() as i128*a1.get() as i128-a2.get() as i128*a0.get() as i128*4;
-	if 0<radicand{
+	if 0<radicand {
 		//start with f64 sqrt
 		let planar_radicand=Planar64::raw(unsafe{(radicand as f64).sqrt().to_int_unchecked()});
 		//TODO: one or two newtons
-		if Planar64::ZERO<a2{
-			([(-a1-planar_radicand)/(a2*2),(-a1+planar_radicand)/(a2*2)],2)
-		}else{
-			([(-a1+planar_radicand)/(a2*2),(-a1-planar_radicand)/(a2*2)],2)
+		if Planar64::ZERO<a2 {
+			return vec![(-a1-planar_radicand)/(a2*2),(-a1+planar_radicand)/(a2*2)];
+		} else {
+			return vec![(-a1+planar_radicand)/(a2*2),(-a1-planar_radicand)/(a2*2)];
 		}
-	}else if radicand==0{
-		([a1/(a2*-2),Planar64::ZERO],1)
-	}else{
-		([Planar64::ZERO,Planar64::ZERO],0)
+	} else if radicand==0 {
+		return vec![a1/(a2*-2)];
+	} else {
+		return vec![];
 	}
 }
 #[inline]
-pub fn zeroes1(a0:Planar64,a1:Planar64)->([Planar64;1],usize){
+pub fn zeroes1(a0:Planar64,a1:Planar64) -> Vec<Planar64> {
 	if a1==Planar64::ZERO{
-		return ([Planar64::ZERO],0);
-	}else{
-		return ([-a0/a1],1);
+		return vec![];
+	} else {
+		return vec![-a0/a1];
 	}
 }

tools/arcane

@@ -0,0 +1 @@
+mangohud ../target/release/strafe-client bhop_maps/5692113331.rbxm

tools/bhop_maps

@@ -0,0 +1 @@
+/run/media/quat/Files/Documents/map-files/verify-scripts/maps/bhop_all/

tools/cross-compile.sh

@@ -0,0 +1 @@
+cargo build --release --target x86_64-pc-windows-gnu

tools/make-demo.sh

@@ -0,0 +1,4 @@
+mkdir -p ../target/demo
+mv ../target/x86_64-pc-windows-gnu/release/strafe-client.exe ../target/demo/strafe-client.exe
+rm ../target/demo.7z
+7z a -t7z -mx=9 -mfb=273 -ms -md=31 -myx=9 -mtm=- -mmt -mmtf -md=1536m -mmf=bt3 -mmc=10000 -mpb=0 -mlc=0 ../target/demo.7z ../target/demo

tools/run

@@ -0,0 +1 @@
+mangohud ../target/release/strafe-client "$1"

tools/settings.conf

@@ -0,0 +1,4 @@
+[camera]
+sensitivity_x=98384
+fov_y=1.0
+#fov_x_from_y_ratio=1.33333333333333333333333333333333

tools/textures

@@ -0,0 +1 @@
+/run/media/quat/Files/Documents/map-files/verify-scripts/textures/dds/

tools/toc

@@ -0,0 +1 @@
+mangohud ../target/release/strafe-client bhop_maps/5692152916.rbxm