Print Only Horizontal Velocity

The Speed function is unnecessary I forgot to remove it

.gitignore

@@ -1 +1,2 @@
 /target
+/textures

Cargo.toml

@@ -1,23 +1,30 @@
 [package]
 name = "strafe-client"
-version = "0.2.0"
+version = "0.9.0"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-async-executor = "1.5.1"
 bytemuck = { version = "1.13.1", features = ["derive"] }
+configparser = "3.0.2"
 ddsfile = "0.5.1"
-env_logger = "0.10.0"
+glam = "0.25.0"
-glam = "0.24.1"
+lazy-regex = "3.0.2"
-log = "0.4.20"
 obj = "0.10.2"
+parking_lot = "0.12.1"
 pollster = "0.3.0"
-wgpu = "0.17.0"
+rbx_binary = "0.7.1"
-winit = "0.28.6"
+rbx_dom_weak = "2.5.0"
+rbx_reflection_database = "0.2.7"
+rbx_xml = "0.13.1"
+strafesnet_common = { git = "https://git.itzana.me/StrafesNET/common", rev = "434ca29aef7e3015c9ca1ed45de8fef42e33fdfb" }
+vbsp = "0.5.0"
+vmdl = "0.1.1"
+wgpu = "0.19.0"
+winit = "0.29.2"
 
-[profile.release]
+#[profile.release]
-lto = true
+#lto = true
-strip = true
+#strip = true
-codegen-units = 1
+#codegen-units = 1

LICENSE

@@ -1,5 +1,5 @@
 /*******************************************************
-* Copyright (C) 2023 Rhys Lloyd <krakow20@gmail.com>
+* Copyright (C) 2023-2024 Rhys Lloyd <krakow20@gmail.com>
 *
 * This file is part of the StrafesNET bhop/surf client.
 *

src/body.rs

@@ -1,310 +0,0 @@
-use crate::instruction::TimedInstruction;
-
-pub enum PhysicsInstruction {
-	CollisionStart(RelativeCollision),
-	CollisionEnd(RelativeCollision),
-	StrafeTick,
-	Jump,
-	// Water,
-	// Spawn(
-	// 	Option<SpawnId>,
-	// 	bool,//true = Trigger; false = teleport
-	// 	bool,//true = Force
-	// )
-}
-
-pub struct Body {
-	pub position: glam::Vec3,//I64 where 2^32 = 1 u
-	pub velocity: glam::Vec3,//I64 where 2^32 = 1 u/s
-	pub time: TIME,//nanoseconds x xxxxD!
-}
-
-pub struct PhysicsState {
-	pub body: Body,
-	pub contacts: Vec<RelativeCollision>,
-	pub models_cringe_clone: Vec<Model>,
-	pub time: TIME,
-	pub strafe_tick_num: TIME,
-	pub strafe_tick_den: TIME,
-	pub tick: u32,
-	pub mv: f32,
-	pub walkspeed: f32,
-	pub friction: f32,
-	pub gravity: glam::Vec3,
-	pub grounded: bool,
-	pub jump_trying: bool,
-}
-
-#[derive(Clone,Copy)]
-pub enum AabbFace{
-	Right,//+X
-	Top,
-	Back,
-	Left,
-	Bottom,
-	Front,
-}
-
-pub struct Aabb {
-	min: glam::Vec3,
-	max: glam::Vec3,
-}
-
-impl Aabb {
-	// const FACE_DATA: [[f32; 3]; 6] = [
-	// 	[0.0f32, 0., 1.],
-	// 	[0.0f32, 0., -1.],
-	// 	[1.0f32, 0., 0.],
-	// 	[-1.0f32, 0., 0.],
-	// 	[0.0f32, 1., 0.],
-	// 	[0.0f32, -1., 0.],
-	// ];
-	const VERTEX_DATA_RIGHT: [glam::Vec3; 4] = [
-		glam::vec3(1., -1., -1.),
-		glam::vec3(1., 1., -1.),
-		glam::vec3(1., 1., 1.),
-		glam::vec3(1., -1., 1.),
-	];
-	const VERTEX_DATA_TOP: [glam::Vec3; 4] = [
-		glam::vec3(1., 1., -1.),
-		glam::vec3(-1., 1., -1.),
-		glam::vec3(-1., 1., 1.),
-		glam::vec3(1., 1., 1.),
-	];
-	const VERTEX_DATA_BACK: [glam::Vec3; 4] = [
-		glam::vec3(-1., -1., 1.),
-		glam::vec3(1., -1., 1.),
-		glam::vec3(1., 1., 1.),
-		glam::vec3(-1., 1., 1.),
-	];
-	const VERTEX_DATA_LEFT: [glam::Vec3; 4] = [
-		glam::vec3(-1., -1., 1.),
-		glam::vec3(-1., 1., 1.),
-		glam::vec3(-1., 1., -1.),
-		glam::vec3(-1., -1., -1.),
-	];
-	const VERTEX_DATA_BOTTOM: [glam::Vec3; 4] = [
-		glam::vec3(1., -1., 1.),
-		glam::vec3(-1., -1., 1.),
-		glam::vec3(-1., -1., -1.),
-		glam::vec3(1., -1., -1.),
-	];
-	const VERTEX_DATA_FRONT: [glam::Vec3; 4] = [
-		glam::vec3(-1., 1., -1.),
-		glam::vec3(1., 1., -1.),
-		glam::vec3(1., -1., -1.),
-		glam::vec3(-1., -1., -1.),
-	];
-
-	pub fn new() -> Self {
-		Self {min: glam::Vec3::INFINITY,max: glam::Vec3::NEG_INFINITY}
-	}
-
-	pub fn grow(&mut self, point:glam::Vec3){
-		self.min=self.min.min(point);
-		self.max=self.max.max(point);
-	}
-
-	pub fn normal(face:AabbFace) -> glam::Vec3 {
-		match face {
-			AabbFace::Right => glam::vec3(1.,0.,0.),
-			AabbFace::Top => glam::vec3(0.,1.,0.),
-			AabbFace::Back => glam::vec3(0.,0.,1.),
-			AabbFace::Left => glam::vec3(-1.,0.,0.),
-			AabbFace::Bottom => glam::vec3(0.,-1.,0.),
-			AabbFace::Front => glam::vec3(0.,0.,-1.),
-		}
-	}
-	pub fn face_vertices(face:AabbFace) -> [glam::Vec3;4] {
-		match face {
-			AabbFace::Right => Self::VERTEX_DATA_RIGHT,
-			AabbFace::Top => Self::VERTEX_DATA_TOP,
-			AabbFace::Back => Self::VERTEX_DATA_BACK,
-			AabbFace::Left => Self::VERTEX_DATA_LEFT,
-			AabbFace::Bottom => Self::VERTEX_DATA_BOTTOM,
-			AabbFace::Front => Self::VERTEX_DATA_FRONT,
-		}
-	}
-}
-
-type Face = AabbFace;
-type TreyMesh = Aabb;
-
-pub struct Model {
-	//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.
-	transform: glam::Mat4,
-}
-
-impl Model {
-	pub fn new(transform:glam::Mat4) -> Self {
-		Self{transform}
-	}
-	pub fn face_vertices(&self,face:Face) -> [glam::Vec3;4] {
-		Aabb::face_vertices(face)
-	}
-	pub fn face_mesh(&self,face:Face) -> TreyMesh {
-		let mut aabb=Aabb::new();
-		for &vertex in self.face_vertices(face).iter() {
-			aabb.grow(vertex);
-		}
-		return aabb;
-	}
-	pub fn face_normal(&self,face:Face) -> glam::Vec3 {
-		let mut n=glam::Vec3Swizzles::xyzz(Aabb::normal(face));
-		n.w=0.0;//what a man will do to avoid writing out the components
-		glam::Vec4Swizzles::xyz(self.transform*n)//this is wrong for scale
-	}
-}
-
-pub struct RelativeCollision {
-	face: Face,//just an id
-	model: u32,//using id to avoid lifetimes
-}
-
-impl RelativeCollision {
-	pub fn mesh(&self,models:&Vec<Model>) -> TreyMesh {
-		return models.get(self.model as usize).unwrap().face_mesh(self.face)
-	}
-	pub fn normal(&self,models:&Vec<Model>) -> glam::Vec3 {
-		return models.get(self.model as usize).unwrap().face_normal(self.face)
-	}
-}
-
-pub type TIME = i64;
-
-const CONTROL_JUMP:u32 = 0b01000000;//temp DATA NORMALIZATION!@#$
-impl PhysicsState {
-	//delete this, we are tickless gamers
-	pub fn run(&mut self, time: TIME, control_dir: glam::Vec3, controls: u32){
-		let target_tick = (time*self.strafe_tick_num/self.strafe_tick_den) as u32;
-		//the game code can run for 1 month before running out of ticks
-		while self.tick<target_tick {
-			self.tick += 1;
-			let dt=0.01;
-			let d=self.body.velocity.dot(control_dir);
-			if d<self.mv {
-				self.body.velocity+=(self.mv-d)*control_dir;
-			}
-			self.body.velocity+=self.gravity*dt;
-			self.body.position+=self.body.velocity*dt;
-			if self.body.position.y<0.0{
-				self.body.position.y=0.0;
-				self.body.velocity.y=0.0;
-				self.grounded=true;
-			}
-			if self.grounded&&(controls&CONTROL_JUMP)!=0 {
-				self.grounded=false;
-				self.body.velocity+=glam::Vec3::new(0.0,0.715588/2.0*100.0,0.0);
-			}
-			if self.grounded {
-				let applied_friction=self.friction*dt;
-				let targetv=control_dir*self.walkspeed;
-				let diffv=targetv-self.body.velocity;
-				if applied_friction*applied_friction<diffv.length_squared() {
-					self.body.velocity+=applied_friction*diffv.normalize();
-				} else {
-					//PhysicsInstruction::WalkTargetReached
-					self.body.velocity=targetv;
-				}
-			}
-		}
-
-		self.body.time=target_tick as TIME*self.strafe_tick_den/self.strafe_tick_num;
-	}
-
-	//delete this
-	pub fn extrapolate_position(&self, time: TIME) -> glam::Vec3 {
-		let dt=(time-self.body.time) as f64/1_000_000_000f64;
-		self.body.position+self.body.velocity*(dt as f32)+self.gravity*((0.5*dt*dt) as f32)
-	}
-
-	fn next_strafe_instruction(&self) -> Option<TimedInstruction<PhysicsInstruction>> {
-		return Some(TimedInstruction{
-			time:(self.time*self.strafe_tick_num/self.strafe_tick_den+1)*self.strafe_tick_den/self.strafe_tick_num,
-			//only poll the physics if there is a before and after mouse event
-			instruction:PhysicsInstruction::StrafeTick
-		});
-	}
-
-	//state mutated on collision:
-	//Accelerator
-	//stair step-up
-
-	//state mutated on instruction
-	//change fly acceleration (fly_sustain)
-	//change fly velocity
-
-	//generic event emmiters
-	//PlatformStandTime
-	//walk/swim/air/ladder sounds
-	//VState?
-
-	//falling under the map
-	// fn next_respawn_instruction(&self) -> Option<TimedInstruction<PhysicsInstruction>> {
-	// 	if self.body.position<self.world.min_y {
-	// 		return Some(TimedInstruction{
-	// 			time:self.time,
-	// 			instruction:PhysicsInstruction::Trigger(None)
-	// 		});
-	// 	}
-	// }
-
-	// fn next_water_instruction(&self) -> Option<TimedInstruction<PhysicsInstruction>> {
-	// 	return Some(TimedInstruction{
-	// 		time:(self.time*self.strafe_tick_num/self.strafe_tick_den+1)*self.strafe_tick_den/self.strafe_tick_num,
-	// 		//only poll the physics if there is a before and after mouse event
-	// 		instruction:PhysicsInstruction::Water
-	// 	});
-	// }
-
-	fn next_walk_instruction(&self) -> Option<TimedInstruction<PhysicsInstruction>> {
-		//check if you are accelerating towards a walk target velocity and create an instruction
-		return None;
-	}
-	fn predict_collision_end(&self,model:&Model) -> Option<TimedInstruction<PhysicsInstruction>> {
-		//must treat cancollide false objects differently: you may not exit through the same face you entered.
-		None
-	}
-	fn predict_collision_start(&self,model:&Model) -> Option<TimedInstruction<PhysicsInstruction>> {
-		None
-	}
-}
-
-impl crate::instruction::InstructionEmitter<PhysicsInstruction> for PhysicsState {
-	//this little next instruction function can cache its return value and invalidate the cached value by watching the State.
-	fn next_instruction(&self) -> Option<TimedInstruction<PhysicsInstruction>> {
-		//JUST POLLING!!! NO MUTATION
-		let mut collector = crate::instruction::InstructionCollector::new();
-		//autohop (already pressing spacebar; the signal to begin trying to jump is different)
-		if self.grounded&&self.jump_trying {
-			//scroll will be implemented with InputInstruction::Jump(true) but it blocks setting self.jump_trying=true
-			collector.collect(Some(TimedInstruction{
-				time:self.time,
-				instruction:PhysicsInstruction::Jump
-			}));
-		}
-		//check for collision stop instructions with curent contacts
-		for collision_data in self.contacts.iter() {
-			collector.collect(self.predict_collision_end(self.models_cringe_clone.get(collision_data.model as usize).unwrap()));
-		}
-		//check for collision start instructions (against every part in the game with no optimization!!)
-		for model in &self.models_cringe_clone {
-			collector.collect(self.predict_collision_start(model));
-		}
-		if self.grounded {
-			//walk maintenance
-			collector.collect(self.next_walk_instruction());
-		}else{
-			//check to see when the next strafe tick is
-			collector.collect(self.next_strafe_instruction());
-		}
-		collector.instruction()
-	}
-}
-
-impl crate::instruction::InstructionConsumer<PhysicsInstruction> for PhysicsState {
-	fn process_instruction(&mut self, instruction:TimedInstruction<PhysicsInstruction>) {
-		//
-	}
-}

src/compat_worker.rs

@@ -0,0 +1,21 @@
+pub type QNWorker<'a,Task>=CompatNWorker<'a,Task>;
+pub type INWorker<'a,Task>=CompatNWorker<'a,Task>;
+
+pub struct CompatNWorker<'a,Task>{
+	data:std::marker::PhantomData<Task>,
+	f:Box<dyn FnMut(Task)+Send+'a>,
+}
+
+impl<'a,Task> CompatNWorker<'a,Task>{
+	pub fn new(f:impl FnMut(Task)+Send+'a)->CompatNWorker<'a,Task>{
+		Self{
+			data:std::marker::PhantomData,
+			f:Box::new(f),
+		}
+	}
+
+	pub fn send(&mut self,task:Task)->Result<(),()>{
+		(self.f)(task);
+		Ok(())
+	}
+}

src/face_crawler.rs

@@ -0,0 +1,119 @@
+use crate::physics::Body;
+use crate::model_physics::{FEV,MeshQuery,DirectedEdge};
+use strafesnet_common::integer::{Time,Planar64};
+use strafesnet_common::zeroes::zeroes2;
+
+enum Transition<F,E:DirectedEdge,V>{
+	Miss,
+	Next(FEV<F,E,V>,Time),
+	Hit(F,Time),
+}
+
+	fn next_transition<F:Copy,E:Copy+DirectedEdge,V:Copy>(fev:&FEV<F,E,V>,time:Time,mesh:&impl MeshQuery<F,E,V>,body:&Body,time_limit:Time)->Transition<F,E,V>{
+		//conflicting derivative means it crosses in the wrong direction.
+		//if the transition time is equal to an already tested transition, do not replace the current best.
+		let mut best_time=time_limit;
+		let mut best_transtition=Transition::Miss;
+		match fev{
+			&FEV::<F,E,V>::Face(face_id)=>{
+				//test own face collision time, ignoring roots with zero or conflicting derivative
+				//n=face.normal d=face.dot
+				//n.a t^2+n.v t+n.p-d==0
+				let (n,d)=mesh.face_nd(face_id);
+				//TODO: use higher precision d value?
+				//use the mesh transform translation instead of baking it into the d value.
+				for t in zeroes2((n.dot(body.position)-d)*2,n.dot(body.velocity)*2,n.dot(body.acceleration)){
+					let t=body.time+Time::from(t);
+					if time<=t&&t<best_time&&n.dot(body.extrapolated_velocity(t))<Planar64::ZERO{
+						best_time=t;
+						best_transtition=Transition::Hit(face_id,t);
+						break;
+					}
+				}
+				//test each edge collision time, ignoring roots with zero or conflicting derivative
+				for &directed_edge_id in mesh.face_edges(face_id).iter(){
+					let edge_n=mesh.directed_edge_n(directed_edge_id);
+					let n=n.cross(edge_n);
+					let verts=mesh.edge_verts(directed_edge_id.as_undirected());
+					//WARNING: d is moved out of the *2 block because of adding two vertices!
+					for t in zeroes2(n.dot(body.position*2-(mesh.vert(verts[0])+mesh.vert(verts[1]))),n.dot(body.velocity)*2,n.dot(body.acceleration)){
+						let t=body.time+Time::from(t);
+						if time<=t&&t<best_time&&n.dot(body.extrapolated_velocity(t))<Planar64::ZERO{
+							best_time=t;
+							best_transtition=Transition::Next(FEV::<F,E,V>::Edge(directed_edge_id.as_undirected()),t);
+							break;
+						}
+					}
+				}
+				//if none:
+			},
+			&FEV::<F,E,V>::Edge(edge_id)=>{
+				//test each face collision time, ignoring roots with zero or conflicting derivative
+				let edge_n=mesh.edge_n(edge_id);
+				let edge_verts=mesh.edge_verts(edge_id);
+				let delta_pos=body.position*2-(mesh.vert(edge_verts[0])+mesh.vert(edge_verts[1]));
+				for (i,&edge_face_id) in mesh.edge_faces(edge_id).iter().enumerate(){
+					let face_n=mesh.face_nd(edge_face_id).0;
+					//edge_n gets parity from the order of edge_faces
+					let n=face_n.cross(edge_n)*((i as i64)*2-1);
+					//WARNING yada yada d *2
+					for t in zeroes2(n.dot(delta_pos),n.dot(body.velocity)*2,n.dot(body.acceleration)){
+						let t=body.time+Time::from(t);
+						if time<=t&&t<best_time&&n.dot(body.extrapolated_velocity(t))<Planar64::ZERO{
+							best_time=t;
+							best_transtition=Transition::Next(FEV::<F,E,V>::Face(edge_face_id),t);
+							break;
+						}
+					}
+				}
+				//test each vertex collision time, ignoring roots with zero or conflicting derivative
+				for (i,&vert_id) in edge_verts.iter().enumerate(){
+					//vertex normal gets parity from vert index
+					let n=edge_n*(1-2*(i as i64));
+					for t in zeroes2((n.dot(body.position-mesh.vert(vert_id)))*2,n.dot(body.velocity)*2,n.dot(body.acceleration)){
+						let t=body.time+Time::from(t);
+						if time<=t&&t<best_time&&n.dot(body.extrapolated_velocity(t))<Planar64::ZERO{
+							best_time=t;
+							best_transtition=Transition::Next(FEV::<F,E,V>::Vert(vert_id),t);
+							break;
+						}
+					}
+				}
+				//if none:
+			},
+			&FEV::<F,E,V>::Vert(vert_id)=>{
+				//test each edge collision time, ignoring roots with zero or conflicting derivative
+				for &directed_edge_id in mesh.vert_edges(vert_id).iter(){
+					//edge is directed away from vertex, but we want the dot product to turn out negative
+					let n=-mesh.directed_edge_n(directed_edge_id);
+					for t in zeroes2((n.dot(body.position-mesh.vert(vert_id)))*2,n.dot(body.velocity)*2,n.dot(body.acceleration)){
+						let t=body.time+Time::from(t);
+						if time<=t&&t<best_time&&n.dot(body.extrapolated_velocity(t))<Planar64::ZERO{
+							best_time=t;
+							best_transtition=Transition::Next(FEV::<F,E,V>::Edge(directed_edge_id.as_undirected()),t);
+							break;
+						}
+					}
+				}
+				//if none:
+			},
+		}
+		best_transtition
+	}
+pub enum CrawlResult<F,E:DirectedEdge,V>{
+	Miss(FEV<F,E,V>),
+	Hit(F,Time),
+}
+pub fn crawl_fev<F:Copy,E:Copy+DirectedEdge,V:Copy>(mut fev:FEV<F,E,V>,mesh:&impl MeshQuery<F,E,V>,relative_body:&Body,start_time:Time,time_limit:Time)->CrawlResult<F,E,V>{	
+	let mut time=start_time;
+	for _ in 0..20{
+		match next_transition(&fev,time,mesh,relative_body,time_limit){
+			Transition::Miss=>return CrawlResult::Miss(fev),
+			Transition::Next(next_fev,next_time)=>(fev,time)=(next_fev,next_time),
+			Transition::Hit(face,time)=>return CrawlResult::Hit(face,time),
+		}
+	}
+	//TODO: fix all bugs
+	println!("Too many iterations!  Using default behaviour instead of crashing...");
+	CrawlResult::Miss(fev)
+}

src/framework.rs

@@ -1,516 +0,0 @@
-use std::future::Future;
-#[cfg(target_arch = "wasm32")]
-use std::str::FromStr;
-#[cfg(not(target_arch = "wasm32"))]
-use std::time::Instant;
-#[cfg(target_arch = "wasm32")]
-use web_sys::{ImageBitmapRenderingContext, OffscreenCanvas};
-use winit::{
-	event::{self, WindowEvent},
-	event_loop::{ControlFlow, EventLoop},
-};
-
-#[allow(dead_code)]
-pub fn cast_slice<T>(data: &[T]) -> &[u8] {
-	use std::{mem::size_of, slice::from_raw_parts};
-
-	unsafe { from_raw_parts(data.as_ptr() as *const u8, data.len() * size_of::<T>()) }
-}
-
-#[allow(dead_code)]
-pub enum ShaderStage {
-	Vertex,
-	Fragment,
-	Compute,
-}
-
-pub trait Example: 'static + Sized {
-	fn optional_features() -> wgpu::Features {
-		wgpu::Features::empty()
-	}
-	fn required_features() -> wgpu::Features {
-		wgpu::Features::empty()
-	}
-	fn required_downlevel_capabilities() -> wgpu::DownlevelCapabilities {
-		wgpu::DownlevelCapabilities {
-			flags: wgpu::DownlevelFlags::empty(),
-			shader_model: wgpu::ShaderModel::Sm5,
-			..wgpu::DownlevelCapabilities::default()
-		}
-	}
-	fn required_limits() -> wgpu::Limits {
-		wgpu::Limits::downlevel_webgl2_defaults() // These downlevel limits will allow the code to run on all possible hardware
-	}
-	fn init(
-		config: &wgpu::SurfaceConfiguration,
-		adapter: &wgpu::Adapter,
-		device: &wgpu::Device,
-		queue: &wgpu::Queue,
-	) -> Self;
-	fn resize(
-		&mut self,
-		config: &wgpu::SurfaceConfiguration,
-		device: &wgpu::Device,
-		queue: &wgpu::Queue,
-	);
-	fn update(&mut self, event: WindowEvent);
-	fn move_mouse(&mut self, delta: (f64,f64));
-	fn render(
-		&mut self,
-		view: &wgpu::TextureView,
-		device: &wgpu::Device,
-		queue: &wgpu::Queue,
-		spawner: &Spawner,
-	);
-}
-
-struct Setup {
-	window: winit::window::Window,
-	event_loop: EventLoop<()>,
-	instance: wgpu::Instance,
-	size: winit::dpi::PhysicalSize<u32>,
-	surface: wgpu::Surface,
-	adapter: wgpu::Adapter,
-	device: wgpu::Device,
-	queue: wgpu::Queue,
-	#[cfg(target_arch = "wasm32")]
-	offscreen_canvas_setup: Option<OffscreenCanvasSetup>,
-}
-
-#[cfg(target_arch = "wasm32")]
-struct OffscreenCanvasSetup {
-	offscreen_canvas: OffscreenCanvas,
-	bitmap_renderer: ImageBitmapRenderingContext,
-}
-
-async fn setup<E: Example>(title: &str) -> Setup {
-	#[cfg(not(target_arch = "wasm32"))]
-	{
-		env_logger::init();
-	};
-
-	let event_loop = EventLoop::new();
-	let mut builder = winit::window::WindowBuilder::new();
-	builder = builder.with_title(title);
-	#[cfg(windows_OFF)] // TODO
-	{
-		use winit::platform::windows::WindowBuilderExtWindows;
-		builder = builder.with_no_redirection_bitmap(true);
-	}
-	let window = builder.build(&event_loop).unwrap();
-
-	#[cfg(target_arch = "wasm32")]
-	{
-		use winit::platform::web::WindowExtWebSys;
-		let query_string = web_sys::window().unwrap().location().search().unwrap();
-		let level: log::Level = parse_url_query_string(&query_string, "RUST_LOG")
-			.and_then(|x| x.parse().ok())
-			.unwrap_or(log::Level::Error);
-		console_log::init_with_level(level).expect("could not initialize logger");
-		std::panic::set_hook(Box::new(console_error_panic_hook::hook));
-		// On wasm, append the canvas to the document body
-		web_sys::window()
-			.and_then(|win| win.document())
-			.and_then(|doc| doc.body())
-			.and_then(|body| {
-				body.append_child(&web_sys::Element::from(window.canvas()))
-					.ok()
-			})
-			.expect("couldn't append canvas to document body");
-	}
-
-	#[cfg(target_arch = "wasm32")]
-	let mut offscreen_canvas_setup: Option<OffscreenCanvasSetup> = None;
-	#[cfg(target_arch = "wasm32")]
-	{
-		use wasm_bindgen::JsCast;
-		use winit::platform::web::WindowExtWebSys;
-
-		let query_string = web_sys::window().unwrap().location().search().unwrap();
-		if let Some(offscreen_canvas_param) =
-			parse_url_query_string(&query_string, "offscreen_canvas")
-		{
-			if FromStr::from_str(offscreen_canvas_param) == Ok(true) {
-				log::info!("Creating OffscreenCanvasSetup");
-
-				let offscreen_canvas =
-					OffscreenCanvas::new(1024, 768).expect("couldn't create OffscreenCanvas");
-
-				let bitmap_renderer = window
-					.canvas()
-					.get_context("bitmaprenderer")
-					.expect("couldn't create ImageBitmapRenderingContext (Result)")
-					.expect("couldn't create ImageBitmapRenderingContext (Option)")
-					.dyn_into::<ImageBitmapRenderingContext>()
-					.expect("couldn't convert into ImageBitmapRenderingContext");
-
-				offscreen_canvas_setup = Some(OffscreenCanvasSetup {
-					offscreen_canvas,
-					bitmap_renderer,
-				})
-			}
-		}
-	};
-
-	log::info!("Initializing the surface...");
-
-	let backends = wgpu::util::backend_bits_from_env().unwrap_or_else(wgpu::Backends::all);
-	let dx12_shader_compiler = wgpu::util::dx12_shader_compiler_from_env().unwrap_or_default();
-
-	let instance = wgpu::Instance::new(wgpu::InstanceDescriptor {
-		backends,
-		dx12_shader_compiler,
-	});
-	let (size, surface) = unsafe {
-		let size = window.inner_size();
-
-		#[cfg(any(not(target_arch = "wasm32"), target_os = "emscripten"))]
-		let surface = instance.create_surface(&window).unwrap();
-		#[cfg(all(target_arch = "wasm32", not(target_os = "emscripten")))]
-		let surface = {
-			if let Some(offscreen_canvas_setup) = &offscreen_canvas_setup {
-				log::info!("Creating surface from OffscreenCanvas");
-				instance.create_surface_from_offscreen_canvas(
-					offscreen_canvas_setup.offscreen_canvas.clone(),
-				)
-			} else {
-				instance.create_surface(&window)
-			}
-		}
-		.unwrap();
-
-		(size, surface)
-	};
-	let adapter = wgpu::util::initialize_adapter_from_env_or_default(&instance, Some(&surface))
-		.await
-		.expect("No suitable GPU adapters found on the system!");
-
-	#[cfg(not(target_arch = "wasm32"))]
-	{
-		let adapter_info = adapter.get_info();
-		println!("Using {} ({:?})", adapter_info.name, adapter_info.backend);
-	}
-
-	let optional_features = E::optional_features();
-	let required_features = E::required_features();
-	let adapter_features = adapter.features();
-	assert!(
-		adapter_features.contains(required_features),
-		"Adapter does not support required features for this example: {:?}",
-		required_features - adapter_features
-	);
-
-	let required_downlevel_capabilities = E::required_downlevel_capabilities();
-	let downlevel_capabilities = adapter.get_downlevel_capabilities();
-	assert!(
-		downlevel_capabilities.shader_model >= required_downlevel_capabilities.shader_model,
-		"Adapter does not support the minimum shader model required to run this example: {:?}",
-		required_downlevel_capabilities.shader_model
-	);
-	assert!(
-		downlevel_capabilities
-			.flags
-			.contains(required_downlevel_capabilities.flags),
-		"Adapter does not support the downlevel capabilities required to run this example: {:?}",
-		required_downlevel_capabilities.flags - downlevel_capabilities.flags
-	);
-
-	// Make sure we use the texture resolution limits from the adapter, so we can support images the size of the surface.
-	let needed_limits = E::required_limits().using_resolution(adapter.limits());
-
-	let trace_dir = std::env::var("WGPU_TRACE");
-	let (device, queue) = adapter
-		.request_device(
-			&wgpu::DeviceDescriptor {
-				label: None,
-				features: (optional_features & adapter_features) | required_features,
-				limits: needed_limits,
-			},
-			trace_dir.ok().as_ref().map(std::path::Path::new),
-		)
-		.await
-		.expect("Unable to find a suitable GPU adapter!");
-
-	Setup {
-		window,
-		event_loop,
-		instance,
-		size,
-		surface,
-		adapter,
-		device,
-		queue,
-		#[cfg(target_arch = "wasm32")]
-		offscreen_canvas_setup,
-	}
-}
-
-fn start<E: Example>(
-	#[cfg(not(target_arch = "wasm32"))] Setup {
-		window,
-		event_loop,
-		instance,
-		size,
-		surface,
-		adapter,
-		device,
-		queue,
-	}: Setup,
-	#[cfg(target_arch = "wasm32")] Setup {
-		window,
-		event_loop,
-		instance,
-		size,
-		surface,
-		adapter,
-		device,
-		queue,
-		offscreen_canvas_setup,
-	}: Setup,
-) {
-	let spawner = Spawner::new();
-	let mut config = surface
-		.get_default_config(&adapter, size.width, size.height)
-		.expect("Surface isn't supported by the adapter.");
-	let surface_view_format = config.format.add_srgb_suffix();
-	config.view_formats.push(surface_view_format);
-	surface.configure(&device, &config);
-
-	log::info!("Initializing the example...");
-	let mut example = E::init(&config, &adapter, &device, &queue);
-
-	#[cfg(not(target_arch = "wasm32"))]
-	let mut last_frame_inst = Instant::now();
-	#[cfg(not(target_arch = "wasm32"))]
-	let (mut frame_count, mut accum_time) = (0, 0.0);
-
-	log::info!("Entering render loop...");
-	event_loop.run(move |event, _, control_flow| {
-		let _ = (&instance, &adapter); // force ownership by the closure
-		*control_flow = if cfg!(feature = "metal-auto-capture") {
-			ControlFlow::Exit
-		} else {
-			ControlFlow::Poll
-		};
-		match event {
-			event::Event::RedrawEventsCleared => {
-				#[cfg(not(target_arch = "wasm32"))]
-				spawner.run_until_stalled();
-
-				window.request_redraw();
-			}
-			event::Event::WindowEvent {
-				event:
-					WindowEvent::Resized(size)
-					| WindowEvent::ScaleFactorChanged {
-						new_inner_size: &mut size,
-						..
-					},
-				..
-			} => {
-				// Once winit is fixed, the detection conditions here can be removed.
-				// https://github.com/rust-windowing/winit/issues/2876
-				let max_dimension = adapter.limits().max_texture_dimension_2d;
-				if size.width > max_dimension || size.height > max_dimension {
-					log::warn!(
-						"The resizing size {:?} exceeds the limit of {}.",
-						size,
-						max_dimension
-					);
-				} else {
-					log::info!("Resizing to {:?}", size);
-					config.width = size.width.max(1);
-					config.height = size.height.max(1);
-					example.resize(&config, &device, &queue);
-					surface.configure(&device, &config);
-				}
-			}
-			event::Event::WindowEvent { event, .. } => match event {
-				WindowEvent::KeyboardInput {
-					input:
-						event::KeyboardInput {
-							virtual_keycode: Some(event::VirtualKeyCode::Escape),
-							state: event::ElementState::Pressed,
-							..
-						},
-					..
-				}
-				| WindowEvent::CloseRequested => {
-					*control_flow = ControlFlow::Exit;
-				}
-				#[cfg(not(target_arch = "wasm32"))]
-				WindowEvent::KeyboardInput {
-					input:
-						event::KeyboardInput {
-							virtual_keycode: Some(event::VirtualKeyCode::R),
-							state: event::ElementState::Pressed,
-							..
-						},
-					..
-				} => {
-					println!("{:#?}", instance.generate_report());
-				}
-				_ => {
-					example.update(event);
-				}
-			},
-			event::Event::DeviceEvent {
-				event:
-					winit::event::DeviceEvent::MouseMotion {
-						delta,
-					},
-				..
-			} => {
-				example.move_mouse(delta);
-			},
-			event::Event::RedrawRequested(_) => {
-				#[cfg(not(target_arch = "wasm32"))]
-				{
-					accum_time += last_frame_inst.elapsed().as_secs_f32();
-					last_frame_inst = Instant::now();
-					frame_count += 1;
-					if frame_count == 100 {
-						println!(
-							"Avg frame time {}ms",
-							accum_time * 1000.0 / frame_count as f32
-						);
-						accum_time = 0.0;
-						frame_count = 0;
-					}
-				}
-
-				let frame = match surface.get_current_texture() {
-					Ok(frame) => frame,
-					Err(_) => {
-						surface.configure(&device, &config);
-						surface
-							.get_current_texture()
-							.expect("Failed to acquire next surface texture!")
-					}
-				};
-				let view = frame.texture.create_view(&wgpu::TextureViewDescriptor {
-					format: Some(surface_view_format),
-					..wgpu::TextureViewDescriptor::default()
-				});
-
-				example.render(&view, &device, &queue, &spawner);
-
-				frame.present();
-
-				#[cfg(target_arch = "wasm32")]
-				{
-					if let Some(offscreen_canvas_setup) = &offscreen_canvas_setup {
-						let image_bitmap = offscreen_canvas_setup
-							.offscreen_canvas
-							.transfer_to_image_bitmap()
-							.expect("couldn't transfer offscreen canvas to image bitmap.");
-						offscreen_canvas_setup
-							.bitmap_renderer
-							.transfer_from_image_bitmap(&image_bitmap);
-
-						log::info!("Transferring OffscreenCanvas to ImageBitmapRenderer");
-					}
-				}
-			}
-			_ => {}
-		}
-	});
-}
-
-#[cfg(not(target_arch = "wasm32"))]
-pub struct Spawner<'a> {
-	executor: async_executor::LocalExecutor<'a>,
-}
-
-#[cfg(not(target_arch = "wasm32"))]
-impl<'a> Spawner<'a> {
-	fn new() -> Self {
-		Self {
-			executor: async_executor::LocalExecutor::new(),
-		}
-	}
-
-	#[allow(dead_code)]
-	pub fn spawn_local(&self, future: impl Future<Output = ()> + 'a) {
-		self.executor.spawn(future).detach();
-	}
-
-	fn run_until_stalled(&self) {
-		while self.executor.try_tick() {}
-	}
-}
-
-#[cfg(target_arch = "wasm32")]
-pub struct Spawner {}
-
-#[cfg(target_arch = "wasm32")]
-impl Spawner {
-	fn new() -> Self {
-		Self {}
-	}
-
-	#[allow(dead_code)]
-	pub fn spawn_local(&self, future: impl Future<Output = ()> + 'static) {
-		wasm_bindgen_futures::spawn_local(future);
-	}
-}
-
-#[cfg(not(target_arch = "wasm32"))]
-pub fn run<E: Example>(title: &str) {
-	let setup = pollster::block_on(setup::<E>(title));
-	start::<E>(setup);
-}
-
-#[cfg(target_arch = "wasm32")]
-pub fn run<E: Example>(title: &str) {
-	use wasm_bindgen::prelude::*;
-
-	let title = title.to_owned();
-	wasm_bindgen_futures::spawn_local(async move {
-		let setup = setup::<E>(&title).await;
-		let start_closure = Closure::once_into_js(move || start::<E>(setup));
-
-		// make sure to handle JS exceptions thrown inside start.
-		// Otherwise wasm_bindgen_futures Queue would break and never handle any tasks again.
-		// This is required, because winit uses JS exception for control flow to escape from `run`.
-		if let Err(error) = call_catch(&start_closure) {
-			let is_control_flow_exception = error.dyn_ref::<js_sys::Error>().map_or(false, |e| {
-				e.message().includes("Using exceptions for control flow", 0)
-			});
-
-			if !is_control_flow_exception {
-				web_sys::console::error_1(&error);
-			}
-		}
-
-		#[wasm_bindgen]
-		extern "C" {
-			#[wasm_bindgen(catch, js_namespace = Function, js_name = "prototype.call.call")]
-			fn call_catch(this: &JsValue) -> Result<(), JsValue>;
-		}
-	});
-}
-
-#[cfg(target_arch = "wasm32")]
-/// Parse the query string as returned by `web_sys::window()?.location().search()?` and get a
-/// specific key out of it.
-pub fn parse_url_query_string<'a>(query: &'a str, search_key: &str) -> Option<&'a str> {
-	let query_string = query.strip_prefix('?')?;
-
-	for pair in query_string.split('&') {
-		let mut pair = pair.split('=');
-		let key = pair.next()?;
-		let value = pair.next()?;
-
-		if key == search_key {
-			return Some(value);
-		}
-	}
-
-	None
-}
-
-// This allows treating the framework as a standalone example,
-// thus avoiding listing the example names in `Cargo.toml`.
-#[allow(dead_code)]
-fn main() {}

src/graphics_worker.rs

@@ -0,0 +1,72 @@
+use strafesnet_common::integer;
+
+pub enum Instruction{
+	Render(crate::physics::PhysicsOutputState,integer::Time,glam::IVec2),
+	//UpdateModel(crate::graphics::GraphicsModelUpdate),
+	Resize(winit::dpi::PhysicalSize<u32>,crate::settings::UserSettings),
+	GenerateModels(crate::model::IndexedModelInstances),
+	ClearModels,
+}
+
+//Ideally the graphics thread worker description is:
+/*
+WorkerDescription{
+	input:Immediate,
+	output:Realtime(PoolOrdering::Ordered(3)),
+}
+*/
+//up to three frames in flight, dropping new frame requests when all three are busy, and dropping output frames when one renders out of order
+
+pub fn new<'a>(
+		mut graphics:crate::graphics::GraphicsState,
+		mut config:wgpu::SurfaceConfiguration,
+		surface:wgpu::Surface<'a>,
+		device:wgpu::Device,
+		queue:wgpu::Queue,
+	)->crate::compat_worker::INWorker<'a,Instruction>{
+	let mut resize=None;
+	crate::compat_worker::INWorker::new(move |ins:Instruction|{
+		match ins{
+			Instruction::GenerateModels(indexed_model_instances)=>{
+				graphics.generate_models(&device,&queue,indexed_model_instances);
+			},
+			Instruction::ClearModels=>{
+				graphics.clear();
+			},
+			Instruction::Resize(size,user_settings)=>{
+				resize=Some((size,user_settings));
+			}
+			Instruction::Render(physics_output,predicted_time,mouse_pos)=>{
+				if let Some((size,user_settings))=&resize{
+					println!("Resizing to {:?}",size);
+					let t0=std::time::Instant::now();
+					config.width=size.width.max(1);
+					config.height=size.height.max(1);
+					surface.configure(&device,&config);
+					graphics.resize(&device,&config,user_settings);
+					println!("Resize took {:?}",t0.elapsed());
+				}
+				//clear every time w/e
+				resize=None;
+				//this has to go deeper somehow
+				let frame=match surface.get_current_texture(){
+					Ok(frame)=>frame,
+					Err(_)=>{
+						surface.configure(&device,&config);
+						surface
+							.get_current_texture()
+							.expect("Failed to acquire next surface texture!")
+					}
+				};
+				let view=frame.texture.create_view(&wgpu::TextureViewDescriptor{
+					format:Some(config.view_formats[0]),
+					..wgpu::TextureViewDescriptor::default()
+				});
+
+				graphics.render(&view,&device,&queue,physics_output,predicted_time,mouse_pos);
+
+				frame.present();
+			}
+		}
+	})
+}

src/instruction.rs

@@ -1,37 +0,0 @@
-pub struct TimedInstruction<I> {
-	pub time: crate::body::TIME,
-	pub instruction: I,
-}
-
-pub trait InstructionEmitter<I> {
-	fn next_instruction(&self) -> Option<TimedInstruction<I>>;
-}
-pub trait InstructionConsumer<I> {
-	fn process_instruction(&mut self, instruction:TimedInstruction<I>);
-}
-
-//PROPER PRIVATE FIELDS!!!
-pub struct InstructionCollector<I> {
-	instruction: Option<TimedInstruction<I>>,
-}
-impl<I> InstructionCollector<I> {
-	pub fn new() -> Self {
-		Self{instruction:None}
-	}
-
-	pub fn collect(&mut self,instruction:Option<TimedInstruction<I>>){
-		match &instruction {
-			Some(unwrap_instruction) => match &self.instruction {
-				Some(unwrap_best_instruction) => if unwrap_instruction.time<unwrap_best_instruction.time {
-					self.instruction=instruction;
-				},
-				None => self.instruction=instruction,
-			},
-			None => (),
-		}
-	}
-	pub fn instruction(self) -> Option<TimedInstruction<I>> {
-		//STEAL INSTRUCTION AND DESTROY INSTRUCTIONCOLLECTOR
-		return self.instruction
-	}
-}

src/lib.rs

@@ -1,3 +0,0 @@
-pub mod framework;
-pub mod body;
-pub mod instruction;

src/load_bsp.rs

@@ -0,0 +1,232 @@
+use strafesnet_common::integer;
+
+const VALVE_SCALE:f32=1.0/16.0;
+fn valve_transform(v:[f32;3])->integer::Planar64Vec3{
+	integer::Planar64Vec3::try_from([v[0]*VALVE_SCALE,v[2]*VALVE_SCALE,-v[1]*VALVE_SCALE]).unwrap()
+}
+pub fn generate_indexed_models<R:std::io::Read+std::io::Seek>(input:&mut R)->Result<crate::model::IndexedModelInstances,vbsp::BspError>{
+	let mut s=Vec::new();
+
+	match input.read_to_end(&mut s){
+		Ok(_)=>(),
+		Err(e)=>println!("load_bsp::generate_indexed_models read_to_end failed: {:?}",e),
+	}
+
+	match vbsp::Bsp::read(s.as_slice()){
+		Ok(bsp)=>{
+			let mut spawn_point=integer::Planar64Vec3::ZERO;
+
+			let mut name_from_texture_id=Vec::new();
+			let mut texture_id_from_name=std::collections::HashMap::new();
+
+			let mut models=bsp.models().map(|world_model|{
+				//non-deduplicated
+				let mut spam_pos=Vec::new();
+				let mut spam_tex=Vec::new();
+				let mut spam_normal=Vec::new();
+				let mut spam_vertices=Vec::new();
+				let groups=world_model.faces()
+				.filter(|face| face.is_visible())//TODO: look at this
+				.map(|face|{
+					let face_texture=face.texture();
+					let face_texture_data=face_texture.texture_data();
+					let (texture_u,texture_v)=(glam::Vec3A::from_slice(&face_texture.texture_transforms_u[0..3]),glam::Vec3A::from_slice(&face_texture.texture_transforms_v[0..3]));
+					let texture_offset=glam::vec2(face_texture.texture_transforms_u[3],face_texture.texture_transforms_v[3]);
+					let texture_size=glam::vec2(face_texture_data.width as f32,face_texture_data.height as f32);
+
+					//texture
+					let texture_id=if let Some(&texture_id)=texture_id_from_name.get(face_texture_data.name()){
+						texture_id
+					}else{
+						let texture_id=name_from_texture_id.len() as u32;
+						texture_id_from_name.insert(face_texture_data.name().to_string(),texture_id);
+						name_from_texture_id.push(face_texture_data.name().to_string());
+						texture_id
+					};
+
+					//normal
+					let normal=face.normal();
+					let normal_idx=spam_normal.len() as u32;
+					spam_normal.push(valve_transform(<[f32;3]>::from(normal)));
+					let mut vertices:Vec<u32>=face.vertex_positions().map(|vertex_pos|{
+						let vertex_xyz=<[f32;3]>::from(vertex_pos);
+						let pos=glam::Vec3A::from_array(vertex_xyz);
+						let pos_idx=spam_pos.len();
+						spam_pos.push(valve_transform(vertex_xyz));
+
+						//calculate texture coordinates
+						let tex=(glam::vec2(pos.dot(texture_u),pos.dot(texture_v))+texture_offset)/texture_size;
+						let tex_idx=spam_tex.len() as u32;
+						spam_tex.push(tex);
+
+						let i=spam_vertices.len() as u32;
+						spam_vertices.push(crate::model::IndexedVertex{
+							pos: pos_idx as u32,
+							tex: tex_idx as u32,
+							normal: normal_idx,
+							color: 0,
+						});
+						i
+					}).collect();
+					vertices.reverse();
+					crate::model::IndexedGroup{
+						texture:Some(texture_id),
+						polys:vec![crate::model::IndexedPolygon{vertices}],
+					}
+				}).collect();
+				crate::model::IndexedModel{
+					unique_pos:spam_pos,
+					unique_tex:spam_tex,
+					unique_normal:spam_normal,
+					unique_color:vec![glam::Vec4::ONE],
+					unique_vertices:spam_vertices,
+					groups,
+					instances:vec![crate::model::ModelInstance{
+						attributes:crate::model::CollisionAttributes::Decoration,
+						transform:integer::Planar64Affine3::new(
+							integer::Planar64Mat3::default(),
+							valve_transform(<[f32;3]>::from(world_model.origin))
+						),
+						..Default::default()
+					}],
+				}
+			}).collect();
+
+			//dedupe prop models
+			let mut model_dedupe=std::collections::HashSet::new();
+			for prop in bsp.static_props(){
+				model_dedupe.insert(prop.model());
+			}
+
+			//generate unique meshes
+			let mut model_map=std::collections::HashMap::with_capacity(model_dedupe.len());
+			let mut prop_models=Vec::new();
+			for model_name in model_dedupe{
+				let model_name_lower=model_name.to_lowercase();
+				//.mdl, .vvd, .dx90.vtx
+				let mut path=std::path::PathBuf::from(model_name_lower.as_str());
+				let file_name=std::path::PathBuf::from(path.file_stem().unwrap());
+				path.pop();
+				path.push(file_name);
+				let mut vvd_path=path.clone();
+				let mut vtx_path=path.clone();
+				vvd_path.set_extension("vvd");
+				vtx_path.set_extension("dx90.vtx");
+				match (bsp.pack.get(model_name_lower.as_str()),bsp.pack.get(vvd_path.as_os_str().to_str().unwrap()),bsp.pack.get(vtx_path.as_os_str().to_str().unwrap())){
+					(Ok(Some(mdl_file)),Ok(Some(vvd_file)),Ok(Some(vtx_file)))=>{
+						match (vmdl::mdl::Mdl::read(mdl_file.as_ref()),vmdl::vvd::Vvd::read(vvd_file.as_ref()),vmdl::vtx::Vtx::read(vtx_file.as_ref())){
+							(Ok(mdl),Ok(vvd),Ok(vtx))=>{
+								let model=vmdl::Model::from_parts(mdl,vtx,vvd);
+								let texture_paths=model.texture_directories();
+								if texture_paths.len()!=1{
+									println!("WARNING: multiple texture paths");
+								}
+								let skin=model.skin_tables().nth(0).unwrap();
+
+								let mut spam_pos=Vec::with_capacity(model.vertices().len());
+								let mut spam_normal=Vec::with_capacity(model.vertices().len());
+								let mut spam_tex=Vec::with_capacity(model.vertices().len());
+								let mut spam_vertices=Vec::with_capacity(model.vertices().len());
+								for (i,vertex) in model.vertices().iter().enumerate(){
+									spam_pos.push(valve_transform(<[f32;3]>::from(vertex.position)));
+									spam_normal.push(valve_transform(<[f32;3]>::from(vertex.normal)));
+									spam_tex.push(glam::Vec2::from_array(vertex.texture_coordinates));
+									spam_vertices.push(crate::model::IndexedVertex{
+										pos:i as u32,
+										tex:i as u32,
+										normal:i as u32,
+										color:0,
+									});
+								}
+
+								let model_id=prop_models.len();
+								model_map.insert(model_name,model_id);
+								prop_models.push(crate::model::IndexedModel{
+									unique_pos:spam_pos,
+									unique_normal:spam_normal,
+									unique_tex:spam_tex,
+									unique_color:vec![glam::Vec4::ONE],
+									unique_vertices:spam_vertices,
+									groups:model.meshes().map(|mesh|{
+										let texture=if let (Some(texture_path),Some(texture_name))=(texture_paths.get(0),skin.texture(mesh.material_index())){
+											let mut path=std::path::PathBuf::from(texture_path.as_str());
+											path.push(texture_name);
+											let texture_location=path.as_os_str().to_str().unwrap();
+											let texture_id=if let Some(&texture_id)=texture_id_from_name.get(texture_location){
+												texture_id
+											}else{
+												println!("texture! {}",texture_location);
+												let texture_id=name_from_texture_id.len() as u32;
+												texture_id_from_name.insert(texture_location.to_string(),texture_id);
+												name_from_texture_id.push(texture_location.to_string());
+												texture_id
+											};
+											Some(texture_id)
+										}else{
+											None
+										};
+
+										crate::model::IndexedGroup{
+											texture,
+											polys:{
+												//looking at the code, it would seem that the strips are pre-deindexed into triangle lists when calling this function
+												mesh.vertex_strip_indices().map(|strip|{
+													strip.collect::<Vec<usize>>().chunks(3).map(|tri|{
+														crate::model::IndexedPolygon{vertices:vec![tri[0] as u32,tri[1] as u32,tri[2] as u32]}
+													}).collect::<Vec<crate::model::IndexedPolygon>>()
+												}).flatten().collect()
+											},
+										}
+									}).collect(),
+									instances:Vec::new(),
+								});
+							},
+							_=>println!("model_name={} error",model_name),
+						}
+					},
+					_=>println!("no model name={}",model_name),
+				}
+			}
+
+			//generate model instances
+			for prop in bsp.static_props(){
+				let placement=prop.as_prop_placement();
+				if let Some(&model_index)=model_map.get(placement.model){
+					prop_models[model_index].instances.push(crate::model::ModelInstance{
+						transform:integer::Planar64Affine3::new(
+							integer::Planar64Mat3::try_from(
+								glam::Mat3A::from_diagonal(glam::Vec3::splat(placement.scale))
+								//TODO: figure this out
+								*glam::Mat3A::from_quat(glam::Quat::from_xyzw(
+									placement.rotation.v.x,//b
+									placement.rotation.v.y,//c
+									placement.rotation.v.z,//d
+									placement.rotation.s,//a
+								))
+							).unwrap(),
+							valve_transform(<[f32;3]>::from(placement.origin)),
+						),
+						attributes:crate::model::CollisionAttributes::Decoration,
+						..Default::default()
+					});
+				}else{
+					//println!("model not found {}",placement.model);
+				}
+			}
+
+			//actually add the prop models
+			prop_models.append(&mut models);
+
+			Ok(crate::model::IndexedModelInstances{
+				textures:name_from_texture_id,
+				models:prop_models,
+				spawn_point,
+				modes:Vec::new(),
+			})
+		},
+		Err(e)=>{
+			println!("rotten {:?}",e);
+			Err(e)
+		},
+	}
+}

src/load_roblox.rs

@@ -0,0 +1,523 @@
+use crate::primitives;
+use strafesnet_common::integer::{Planar64,Planar64Vec3,Planar64Mat3,Planar64Affine3};
+
+fn class_is_a(class: &str, superclass: &str) -> bool {
+	if class==superclass {
+		return true
+	}
+	let class_descriptor=rbx_reflection_database::get().classes.get(class);
+	if let Some(descriptor) = &class_descriptor {
+		if let Some(class_super) = &descriptor.superclass {
+			return class_is_a(&class_super, superclass)
+		}
+	}
+	return false
+}
+fn recursive_collect_superclass(objects: &mut std::vec::Vec<rbx_dom_weak::types::Ref>,dom: &rbx_dom_weak::WeakDom, instance: &rbx_dom_weak::Instance, superclass: &str){
+	let mut stack=vec![instance];
+	while let Some(item)=stack.pop(){
+		for &referent in item.children(){
+			if let Some(c)=dom.get_by_ref(referent){
+				if class_is_a(c.class.as_str(),superclass){
+					objects.push(c.referent());//copy ref
+				}
+				stack.push(c);
+			}
+		}
+	}
+}
+fn planar64_affine3_from_roblox(cf:&rbx_dom_weak::types::CFrame,size:&rbx_dom_weak::types::Vector3)->Planar64Affine3{
+	Planar64Affine3::new(
+		Planar64Mat3::from_cols(
+			Planar64Vec3::try_from([cf.orientation.x.x,cf.orientation.y.x,cf.orientation.z.x]).unwrap()
+			*Planar64::try_from(size.x/2.0).unwrap(),
+			Planar64Vec3::try_from([cf.orientation.x.y,cf.orientation.y.y,cf.orientation.z.y]).unwrap()
+			*Planar64::try_from(size.y/2.0).unwrap(),
+			Planar64Vec3::try_from([cf.orientation.x.z,cf.orientation.y.z,cf.orientation.z.z]).unwrap()
+			*Planar64::try_from(size.z/2.0).unwrap(),
+		),
+		Planar64Vec3::try_from([cf.position.x,cf.position.y,cf.position.z]).unwrap()
+	)
+}
+fn get_attributes(name:&str,can_collide:bool,velocity:Planar64Vec3,force_intersecting:bool)->crate::model::CollisionAttributes{
+	let mut general=crate::model::GameMechanicAttributes::default();
+	let mut intersecting=crate::model::IntersectingAttributes::default();
+	let mut contacting=crate::model::ContactingAttributes::default();
+	let mut force_can_collide=can_collide;
+	match name{
+		"Water"=>{
+			force_can_collide=false;
+			//TODO: read stupid CustomPhysicalProperties
+			intersecting.water=Some(crate::model::IntersectingWater{density:Planar64::ONE,viscosity:Planar64::ONE/10,velocity});
+		},
+		"Accelerator"=>{
+			//although the new game supports collidable accelerators, this is a roblox compatability map loader
+			force_can_collide=false;
+			general.accelerator=Some(crate::model::GameMechanicAccelerator{acceleration:velocity});
+		},
+		// "UnorderedCheckpoint"=>general.teleport_behaviour=Some(crate::model::TeleportBehaviour::StageElement(crate::model::GameMechanicStageElement{
+		// 	mode_id:0,
+		// 	stage_id:0,
+		// 	force:false,
+		// 	behaviour:crate::model::StageElementBehaviour::Unordered
+		// })),
+		"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})},
+		"Platform"=>general.teleport_behaviour=Some(crate::model::TeleportBehaviour::StageElement(crate::model::GameMechanicStageElement{
+			mode_id:0,
+			stage_id:0,
+			force:false,
+			behaviour:crate::model::StageElementBehaviour::Platform,
+		})),
+		other=>{
+			if let Some(captures)=lazy_regex::regex!(r"^(Force)?(Spawn|SpawnAt|Trigger|Teleport|Platform)(\d+)$")
+			.captures(other){
+				general.teleport_behaviour=Some(crate::model::TeleportBehaviour::StageElement(crate::model::GameMechanicStageElement{
+					mode_id:0,
+					stage_id:captures[3].parse::<u32>().unwrap(),
+					force:match captures.get(1){
+						Some(m)=>m.as_str()=="Force",
+						None=>false,
+					},
+					behaviour:match &captures[2]{
+						"Spawn"|"SpawnAt"=>crate::model::StageElementBehaviour::SpawnAt,
+						//cancollide false so you don't hit the side
+						//NOT a decoration
+						"Trigger"=>{force_can_collide=false;crate::model::StageElementBehaviour::Trigger},
+						"Teleport"=>{force_can_collide=false;crate::model::StageElementBehaviour::Teleport},
+						"Platform"=>crate::model::StageElementBehaviour::Platform,
+						_=>panic!("regex1[2] messed up bad"),
+					}
+				}));
+			}else if let Some(captures)=lazy_regex::regex!(r"^(Force)?(Jump)(\d+)$")
+			.captures(other){
+				general.teleport_behaviour=Some(crate::model::TeleportBehaviour::StageElement(crate::model::GameMechanicStageElement{
+					mode_id:0,
+					stage_id:0,
+					force:match captures.get(1){
+						Some(m)=>m.as_str()=="Force",
+						None=>false,
+					},
+					behaviour:match &captures[2]{
+						"Jump"=>crate::model::StageElementBehaviour::JumpLimit(captures[3].parse::<u32>().unwrap()),
+						_=>panic!("regex4[1] messed up bad"),
+					}
+				}));
+			}else if let Some(captures)=lazy_regex::regex!(r"^Bonus(Finish|Anticheat)(\d+)$")
+			.captures(other){
+				force_can_collide=false;
+				match &captures[1]{
+					"Finish"=>general.zone=Some(crate::model::GameMechanicZone{mode_id:captures[2].parse::<u32>().unwrap(),behaviour:crate::model::ZoneBehaviour::Finish}),
+					"Anticheat"=>general.zone=Some(crate::model::GameMechanicZone{mode_id:captures[2].parse::<u32>().unwrap(),behaviour:crate::model::ZoneBehaviour::Anitcheat}),
+					_=>panic!("regex2[1] messed up bad"),
+				}
+			}else if let Some(captures)=lazy_regex::regex!(r"^(WormholeIn)(\d+)$")
+			.captures(other){
+				force_can_collide=false;
+				match &captures[1]{
+					"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"),
+			// 	}
+			// }
+		}
+	}
+	//need some way to skip this
+	if velocity!=Planar64Vec3::ZERO{
+		general.booster=Some(crate::model::GameMechanicBooster::Velocity(velocity));
+	}
+	match force_can_collide{
+		true=>{
+			match name{
+				"Bounce"=>contacting.contact_behaviour=Some(crate::model::ContactingBehaviour::Elastic(u32::MAX)),
+				"Surf"=>contacting.contact_behaviour=Some(crate::model::ContactingBehaviour::Surf),
+				"Ladder"=>contacting.contact_behaviour=Some(crate::model::ContactingBehaviour::Ladder(crate::model::ContactingLadder{sticky:true})),
+				_=>(),
+			}
+			crate::model::CollisionAttributes::Contact{contacting,general}
+		},
+		false=>if force_intersecting
+		||general.any()
+		||intersecting.any()
+		{
+			crate::model::CollisionAttributes::Intersect{intersecting,general}
+		}else{
+			crate::model::CollisionAttributes::Decoration
+		},
+	}
+}
+
+struct RobloxAssetId(u64);
+struct RobloxAssetIdParseErr;
+impl std::str::FromStr for RobloxAssetId {
+	type Err=RobloxAssetIdParseErr;
+	fn from_str(s: &str) -> Result<Self, Self::Err>{
+		let regman=lazy_regex::regex!(r"(\d+)$");
+		if let Some(captures) = regman.captures(s) {
+			if captures.len()==2{//captures[0] is all captures concatenated, and then each individual capture
+				if let Ok(id) = captures[0].parse::<u64>() {
+					return Ok(Self(id));
+				}
+			}
+		}
+		Err(RobloxAssetIdParseErr)
+	}
+}
+#[derive(Clone,Copy,PartialEq)]
+struct RobloxTextureTransform{
+	offset_u:f32,
+	offset_v:f32,
+	scale_u:f32,
+	scale_v:f32,
+}
+impl std::cmp::Eq for RobloxTextureTransform{}//????
+impl std::default::Default for RobloxTextureTransform{
+    fn default() -> Self {
+        Self{offset_u:0.0,offset_v:0.0,scale_u:1.0,scale_v:1.0}
+    }
+}
+impl std::hash::Hash for RobloxTextureTransform {
+	fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+		self.offset_u.to_ne_bytes().hash(state);
+		self.offset_v.to_ne_bytes().hash(state);
+		self.scale_u.to_ne_bytes().hash(state);
+		self.scale_v.to_ne_bytes().hash(state);
+	}
+}
+#[derive(Clone,PartialEq)]
+struct RobloxFaceTextureDescription{
+	texture:u32,
+	color:glam::Vec4,
+	transform:RobloxTextureTransform,
+}
+impl std::cmp::Eq for RobloxFaceTextureDescription{}//????
+impl std::hash::Hash for RobloxFaceTextureDescription {
+	fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+		self.texture.hash(state);
+		self.transform.hash(state);
+        for &el in self.color.as_ref().iter() {
+            el.to_ne_bytes().hash(state);
+        }
+    }
+}
+impl RobloxFaceTextureDescription{
+	fn to_face_description(&self)->primitives::FaceDescription{
+		primitives::FaceDescription{
+			texture:Some(self.texture),
+			transform:glam::Affine2::from_translation(
+				glam::vec2(self.transform.offset_u,self.transform.offset_v)
+			)
+			*glam::Affine2::from_scale(
+				glam::vec2(self.transform.scale_u,self.transform.scale_v)
+			),
+			color:self.color,
+		}
+	}
+}
+type RobloxPartDescription=[Option<RobloxFaceTextureDescription>;6];
+type RobloxWedgeDescription=[Option<RobloxFaceTextureDescription>;5];
+type RobloxCornerWedgeDescription=[Option<RobloxFaceTextureDescription>;5];
+#[derive(Clone,Eq,Hash,PartialEq)]
+enum RobloxBasePartDescription{
+	Sphere(RobloxPartDescription),
+	Part(RobloxPartDescription),
+	Cylinder(RobloxPartDescription),
+	Wedge(RobloxWedgeDescription),
+	CornerWedge(RobloxCornerWedgeDescription),
+}
+pub fn generate_indexed_models(dom:rbx_dom_weak::WeakDom) -> crate::model::IndexedModelInstances{
+	//IndexedModelInstances includes textures
+	let mut spawn_point=Planar64Vec3::ZERO;
+
+	let mut indexed_models=Vec::new();
+	let mut model_id_from_description=std::collections::HashMap::<RobloxBasePartDescription,usize>::new();
+
+	let mut texture_id_from_asset_id=std::collections::HashMap::<u64,u32>::new();
+	let mut asset_id_from_texture_id=Vec::new();
+
+	let mut object_refs=Vec::new();
+	let mut temp_objects=Vec::new();
+	recursive_collect_superclass(&mut object_refs, &dom, dom.root(),"BasePart");
+	for object_ref in object_refs {
+		if let Some(object)=dom.get_by_ref(object_ref){
+			if let (
+					Some(rbx_dom_weak::types::Variant::CFrame(cf)),
+					Some(rbx_dom_weak::types::Variant::Vector3(size)),
+					Some(rbx_dom_weak::types::Variant::Vector3(velocity)),
+					Some(rbx_dom_weak::types::Variant::Float32(transparency)),
+					Some(rbx_dom_weak::types::Variant::Color3uint8(color3)),
+					Some(rbx_dom_weak::types::Variant::Bool(can_collide)),
+				) = (
+					object.properties.get("CFrame"),
+					object.properties.get("Size"),
+					object.properties.get("Velocity"),
+					object.properties.get("Transparency"),
+					object.properties.get("Color"),
+					object.properties.get("CanCollide"),
+				)
+			{
+				let model_transform=planar64_affine3_from_roblox(cf,size);
+
+				if model_transform.matrix3.determinant()==Planar64::ZERO{
+					let mut parent_ref=object.parent();
+					let mut full_path=object.name.clone();
+					while let Some(parent)=dom.get_by_ref(parent_ref){
+						full_path=format!("{}.{}",parent.name,full_path);
+						parent_ref=parent.parent();
+					}
+					println!("Zero determinant CFrame at location {}",full_path);
+					println!("matrix3:{}",model_transform.matrix3);
+					continue;
+				}
+
+				//push TempIndexedAttributes
+				let mut force_intersecting=false;
+				let mut temp_indexing_attributes=Vec::new();
+				if let Some(attr)=match &object.name[..]{
+					"MapStart"=>{
+						spawn_point=model_transform.transform_point3(Planar64Vec3::ZERO)+Planar64Vec3::Y*5/2;
+						Some(crate::model::TempIndexedAttributes::Start(crate::model::TempAttrStart{mode_id:0}))
+					},
+					other=>{
+						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()})),
+								"WormholeOut"=>Some(crate::model::TempIndexedAttributes::Wormhole(crate::model::TempAttrWormhole{wormhole_id:captures[2].parse::<u32>().unwrap()})),
+								_=>None,
+							}
+						}else{
+							None
+						}
+					}
+				}{
+					force_intersecting=true;
+					temp_indexing_attributes.push(attr);
+				}
+
+				//TODO: also detect "CylinderMesh" etc here
+				let shape=match &object.class[..]{
+					"Part"=>{
+						if let Some(rbx_dom_weak::types::Variant::Enum(shape))=object.properties.get("Shape"){
+							match shape.to_u32(){
+								0=>primitives::Primitives::Sphere,
+								1=>primitives::Primitives::Cube,
+								2=>primitives::Primitives::Cylinder,
+								3=>primitives::Primitives::Wedge,
+								4=>primitives::Primitives::CornerWedge,
+								_=>panic!("Funky roblox PartType={};",shape.to_u32()),
+							}
+						}else{
+							panic!("Part has no Shape!");
+						}
+					},
+					"TrussPart"=>primitives::Primitives::Cube,
+					"WedgePart"=>primitives::Primitives::Wedge,
+					"CornerWedgePart"=>primitives::Primitives::CornerWedge,
+					_=>{
+						println!("Unsupported BasePart ClassName={}; defaulting to cube",object.class);
+						primitives::Primitives::Cube
+					}
+				};
+
+				//use the biggest one and cut it down later...
+				let mut part_texture_description:RobloxPartDescription=[None,None,None,None,None,None];
+				temp_objects.clear();
+				recursive_collect_superclass(&mut temp_objects, &dom, object,"Decal");
+				for &decal_ref in &temp_objects{
+					if let Some(decal)=dom.get_by_ref(decal_ref){
+						if let (
+							Some(rbx_dom_weak::types::Variant::Content(content)),
+							Some(rbx_dom_weak::types::Variant::Enum(normalid)),
+							Some(rbx_dom_weak::types::Variant::Color3(decal_color3)),
+							Some(rbx_dom_weak::types::Variant::Float32(decal_transparency)),
+						) = (
+							decal.properties.get("Texture"),
+							decal.properties.get("Face"),
+							decal.properties.get("Color3"),
+							decal.properties.get("Transparency"),
+						) {
+							if let Ok(asset_id)=content.clone().into_string().parse::<RobloxAssetId>(){
+								let texture_id=if let Some(&texture_id)=texture_id_from_asset_id.get(&asset_id.0){
+									texture_id
+								}else{
+									let texture_id=asset_id_from_texture_id.len() as u32;
+									texture_id_from_asset_id.insert(asset_id.0,texture_id);
+									asset_id_from_texture_id.push(asset_id.0);
+									texture_id
+								};
+								let normal_id=normalid.to_u32();
+								if normal_id<6{
+									let (roblox_texture_color,roblox_texture_transform)=if decal.class=="Texture"{
+										//generate tranform
+										if let (
+												Some(rbx_dom_weak::types::Variant::Float32(ox)),
+												Some(rbx_dom_weak::types::Variant::Float32(oy)),
+												Some(rbx_dom_weak::types::Variant::Float32(sx)),
+												Some(rbx_dom_weak::types::Variant::Float32(sy)),
+											) = (
+												decal.properties.get("OffsetStudsU"),
+												decal.properties.get("OffsetStudsV"),
+												decal.properties.get("StudsPerTileU"),
+												decal.properties.get("StudsPerTileV"),
+											)
+										{
+											let (size_u,size_v)=match normal_id{
+												0=>(size.z,size.y),//right
+												1=>(size.x,size.z),//top
+												2=>(size.x,size.y),//back
+												3=>(size.z,size.y),//left
+												4=>(size.x,size.z),//bottom
+												5=>(size.x,size.y),//front
+												_=>panic!("unreachable"),
+											};
+											(
+												glam::vec4(decal_color3.r,decal_color3.g,decal_color3.b,1.0-*decal_transparency),
+												RobloxTextureTransform{
+													offset_u:*ox/(*sx),offset_v:*oy/(*sy),
+													scale_u:size_u/(*sx),scale_v:size_v/(*sy),
+												}
+											)
+										}else{
+											(glam::Vec4::ONE,RobloxTextureTransform::default())
+										}
+									}else{
+										(glam::Vec4::ONE,RobloxTextureTransform::default())
+									};
+									part_texture_description[normal_id as usize]=Some(RobloxFaceTextureDescription{
+										texture:texture_id,
+										color:roblox_texture_color,
+										transform:roblox_texture_transform,
+									});
+								}else{
+									println!("NormalId={} unsupported for shape={:?}",normal_id,shape);
+								}
+							}
+						}
+					}
+				}
+				//obscure rust syntax "slice pattern"
+				let [
+					f0,//Cube::Right
+					f1,//Cube::Top
+					f2,//Cube::Back
+					f3,//Cube::Left
+					f4,//Cube::Bottom
+					f5,//Cube::Front
+				]=part_texture_description;
+				let basepart_texture_description=match shape{
+					primitives::Primitives::Sphere=>RobloxBasePartDescription::Sphere([f0,f1,f2,f3,f4,f5]),
+					primitives::Primitives::Cube=>RobloxBasePartDescription::Part([f0,f1,f2,f3,f4,f5]),
+					primitives::Primitives::Cylinder=>RobloxBasePartDescription::Cylinder([f0,f1,f2,f3,f4,f5]),
+					//use front face texture first and use top face texture as a fallback
+					primitives::Primitives::Wedge=>RobloxBasePartDescription::Wedge([
+						f0,//Cube::Right->Wedge::Right
+						if f5.is_some(){f5}else{f1},//Cube::Front|Cube::Top->Wedge::TopFront
+						f2,//Cube::Back->Wedge::Back
+						f3,//Cube::Left->Wedge::Left
+						f4,//Cube::Bottom->Wedge::Bottom
+					]),
+					//TODO: fix Left+Back texture coordinates to match roblox when not overwridden by Top
+					primitives::Primitives::CornerWedge=>RobloxBasePartDescription::CornerWedge([
+						f0,//Cube::Right->CornerWedge::Right
+						if f2.is_some(){f2}else{f1.clone()},//Cube::Back|Cube::Top->CornerWedge::TopBack
+						if f3.is_some(){f3}else{f1},//Cube::Left|Cube::Top->CornerWedge::TopLeft
+						f4,//Cube::Bottom->CornerWedge::Bottom
+						f5,//Cube::Front->CornerWedge::Front
+					]),
+				};
+				//make new model if unit cube has not been created before
+				let model_id=if let Some(&model_id)=model_id_from_description.get(&basepart_texture_description){
+					//push to existing texture model
+					model_id
+				}else{
+					let model_id=indexed_models.len();
+					model_id_from_description.insert(basepart_texture_description.clone(),model_id);//borrow checker going crazy
+					indexed_models.push(match basepart_texture_description{
+						RobloxBasePartDescription::Sphere(part_texture_description)
+						|RobloxBasePartDescription::Cylinder(part_texture_description)
+						|RobloxBasePartDescription::Part(part_texture_description)=>{
+							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{
+									0=>primitives::CubeFace::Right,
+									1=>primitives::CubeFace::Top,
+									2=>primitives::CubeFace::Back,
+									3=>primitives::CubeFace::Left,
+									4=>primitives::CubeFace::Bottom,
+									5=>primitives::CubeFace::Front,
+									_=>panic!("unreachable"),
+								},
+								match roblox_face_description{
+									Some(roblox_texture_transform)=>roblox_texture_transform.to_face_description(),
+									None=>primitives::FaceDescription::default(),
+								});
+							}
+							primitives::generate_partial_unit_cube(cube_face_description)
+						},
+						RobloxBasePartDescription::Wedge(wedge_texture_description)=>{
+							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{
+									0=>primitives::WedgeFace::Right,
+									1=>primitives::WedgeFace::TopFront,
+									2=>primitives::WedgeFace::Back,
+									3=>primitives::WedgeFace::Left,
+									4=>primitives::WedgeFace::Bottom,
+									_=>panic!("unreachable"),
+								},
+								match roblox_face_description{
+									Some(roblox_texture_transform)=>roblox_texture_transform.to_face_description(),
+									None=>primitives::FaceDescription::default(),
+								});
+							}
+							primitives::generate_partial_unit_wedge(wedge_face_description)
+						},
+						RobloxBasePartDescription::CornerWedge(cornerwedge_texture_description)=>{
+							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{
+									0=>primitives::CornerWedgeFace::Right,
+									1=>primitives::CornerWedgeFace::TopBack,
+									2=>primitives::CornerWedgeFace::TopLeft,
+									3=>primitives::CornerWedgeFace::Bottom,
+									4=>primitives::CornerWedgeFace::Front,
+									_=>panic!("unreachable"),
+								},
+								match roblox_face_description{
+									Some(roblox_texture_transform)=>roblox_texture_transform.to_face_description(),
+									None=>primitives::FaceDescription::default(),
+								});
+							}
+							primitives::generate_partial_unit_cornerwedge(cornerwedge_face_description)
+						},
+					});
+					model_id
+				};
+				indexed_models[model_id].instances.push(crate::model::ModelInstance {
+					transform:model_transform,
+					color:glam::vec4(color3.r as f32/255f32, color3.g as f32/255f32, color3.b as f32/255f32, 1.0-*transparency),
+					attributes:get_attributes(&object.name,*can_collide,Planar64Vec3::try_from([velocity.x,velocity.y,velocity.z]).unwrap(),force_intersecting),
+					temp_indexing:temp_indexing_attributes,
+				});
+			}
+		}
+	}
+	crate::model::IndexedModelInstances{
+		textures:asset_id_from_texture_id.iter().map(|t|t.to_string()).collect(),
+		models:indexed_models,
+		spawn_point,
+		modes:Vec::new(),
+	}
+}

src/main.rs

@@ -1,732 +1,118 @@
-use bytemuck::{Pod, Zeroable};
+use strafesnet_common::integer;
-use std::{borrow::Cow, time::Instant};
-use wgpu::{util::DeviceExt, AstcBlock, AstcChannel};
 
-const IMAGE_SIZE: u32 = 128;
+mod model;
+mod setup;
+mod window;
+mod worker;
+mod physics;
+mod graphics;
+mod settings;
+mod primitives;
+mod load_bsp;
+mod load_roblox;
+mod face_crawler;
+mod compat_worker;
+mod model_physics;
+mod model_graphics;
+mod physics_worker;
+mod graphics_worker;
 
-#[derive(Clone, Copy, Pod, Zeroable)]
+fn load_file(path: std::path::PathBuf)->Option<model::IndexedModelInstances>{
-#[repr(C)]
+	println!("Loading file: {:?}", &path);
-struct Vertex {
+	//oh boy! let's load the map!
-	pos: [f32; 3],
+	if let Ok(file)=std::fs::File::open(path){
-	texture: [f32; 2],
+		let mut input = std::io::BufReader::new(file);
-	normal: [f32; 3],
+		let mut first_8=[0u8;8];
-}
+		//.rbxm roblox binary = "<roblox!"
-
+		//.rbxmx roblox xml = "<roblox "
-struct Entity {
+		//.bsp = "VBSP"
-	index_count: u32,
+		//.vmf = 
-	index_buf: wgpu::Buffer,
+		//.snf = "SNMF"
-}
+		//.snf = "SNBF"
-
+		if let (Ok(()),Ok(()))=(std::io::Read::read_exact(&mut input, &mut first_8),std::io::Seek::rewind(&mut input)){
-//temp?
+			match &first_8[0..4]{
-struct ModelData {
+				b"<rob"=>{
-	transform: glam::Mat4,
+					match match &first_8[4..8]{
-	vertex_buf: wgpu::Buffer,
+						b"lox!"=>rbx_binary::from_reader(input).map_err(|e|format!("{:?}",e)),
-	entities: Vec<Entity>,
+						b"lox "=>rbx_xml::from_reader(input,rbx_xml::DecodeOptions::default()).map_err(|e|format!("{:?}",e)),
-}
+						other=>Err(format!("Unknown Roblox file type {:?}",other)),
-
+					}{
-struct ModelGraphics {
+						Ok(dom)=>Some(load_roblox::generate_indexed_models(dom)),
-	transform: glam::Mat4,
+						Err(e)=>{
-	vertex_buf: wgpu::Buffer,
+							println!("Error loading roblox file:{:?}",e);
-	entities: Vec<Entity>,
+							None
-	bind_group: wgpu::BindGroup,
+						},
-	model_buf: wgpu::Buffer,
+					}
-}
+				},
-
+				b"VBSP"=>load_bsp::generate_indexed_models(&mut input).ok(),
-// Note: we use the Y=up coordinate space in this example.
+				//b"SNFM"=>Some(sniffer::generate_indexed_models(input)),
-struct Camera {
+				//b"SNFB"=>Some(sniffer::load_bot(input)),
-	screen_size: (u32, u32),
+				other=>{
-	offset: glam::Vec3,
+					println!("loser file {:?}",other);
-	fov: f32,
+					None
-	yaw: f32,
+				},
-	pitch: f32,
+			}
-	controls: u32,
-}
-
-const CONTROL_MOVEFORWARD:u32 = 0b00000001;
-const CONTROL_MOVEBACK:u32 = 0b00000010;
-const CONTROL_MOVERIGHT:u32 = 0b00000100;
-const CONTROL_MOVELEFT:u32 = 0b00001000;
-const CONTROL_MOVEUP:u32 = 0b00010000;
-const CONTROL_MOVEDOWN:u32 = 0b00100000;
-const CONTROL_JUMP:u32 = 0b01000000;
-const CONTROL_ZOOM:u32 = 0b10000000;
-
-const FORWARD_DIR:glam::Vec3 = glam::Vec3::new(0.0,0.0,-1.0);
-const RIGHT_DIR:glam::Vec3 = glam::Vec3::new(1.0,0.0,0.0);
-const UP_DIR:glam::Vec3 = glam::Vec3::new(0.0,1.0,0.0);
-
-fn get_control_dir(controls: u32) -> glam::Vec3{
-	//don't get fancy just do it
-	let mut control_dir:glam::Vec3 = glam::Vec3::new(0.0,0.0,0.0);
-	if controls & CONTROL_MOVEFORWARD == CONTROL_MOVEFORWARD {
-		control_dir+=FORWARD_DIR;
-	}
-	if controls & CONTROL_MOVEBACK == CONTROL_MOVEBACK {
-		control_dir+=-FORWARD_DIR;
-	}
-	if controls & CONTROL_MOVELEFT == CONTROL_MOVELEFT {
-		control_dir+=-RIGHT_DIR;
-	}
-	if controls & CONTROL_MOVERIGHT == CONTROL_MOVERIGHT {
-		control_dir+=RIGHT_DIR;
-	}
-	if controls & CONTROL_MOVEUP == CONTROL_MOVEUP {
-		control_dir+=UP_DIR;
-	}
-	if controls & CONTROL_MOVEDOWN == CONTROL_MOVEDOWN {
-		control_dir+=-UP_DIR;
-	}
-	return control_dir
-}
-
-	#[inline]
-	fn perspective_rh(fov_y_slope: f32, aspect_ratio: f32, z_near: f32, z_far: f32) -> glam::Mat4 {
-		//glam_assert!(z_near > 0.0 && z_far > 0.0);
-		let r = z_far / (z_near - z_far);
-		glam::Mat4::from_cols(
-			glam::Vec4::new(1.0/(fov_y_slope * aspect_ratio), 0.0, 0.0, 0.0),
-			glam::Vec4::new(0.0, 1.0/fov_y_slope, 0.0, 0.0),
-			glam::Vec4::new(0.0, 0.0, r, -1.0),
-			glam::Vec4::new(0.0, 0.0, r * z_near, 0.0),
-		)
-	}
-
-impl Camera {
-	fn to_uniform_data(&self, pos: glam::Vec3) -> [f32; 16 * 3 + 4] {
-		let aspect = self.screen_size.0 as f32 / self.screen_size.1 as f32;
-		let fov = if self.controls&CONTROL_ZOOM==0 {
-			self.fov
 		}else{
-			self.fov/5.0
+			println!("Failed to read first 8 bytes and seek back to beginning of file.");
-		};
+			None
-		let proj = perspective_rh(fov, aspect, 0.5, 1000.0);
-		let proj_inv = proj.inverse();
-		let view = glam::Mat4::from_translation(pos+self.offset) * glam::Mat4::from_euler(glam::EulerRot::YXZ, self.yaw, self.pitch, 0f32);
-		let view_inv = view.inverse();
-
-		let mut raw = [0f32; 16 * 3 + 4];
-		raw[..16].copy_from_slice(&AsRef::<[f32; 16]>::as_ref(&proj)[..]);
-		raw[16..32].copy_from_slice(&AsRef::<[f32; 16]>::as_ref(&proj_inv)[..]);
-		raw[32..48].copy_from_slice(&AsRef::<[f32; 16]>::as_ref(&view_inv)[..]);
-		raw[48..52].copy_from_slice(AsRef::<[f32; 4]>::as_ref(&view.col(3)));
-		raw
-	}
-}
-
-pub struct Skybox {
-	start_time: std::time::Instant,
-	camera: Camera,
-	physics: strafe_client::body::PhysicsState,
-	sky_pipeline: wgpu::RenderPipeline,
-	entity_pipeline: wgpu::RenderPipeline,
-	ground_pipeline: wgpu::RenderPipeline,
-	main_bind_group: wgpu::BindGroup,
-	camera_buf: wgpu::Buffer,
-	models: Vec<ModelGraphics>,
-	depth_view: wgpu::TextureView,
-	staging_belt: wgpu::util::StagingBelt,
-}
-
-impl Skybox {
-	const DEPTH_FORMAT: wgpu::TextureFormat = wgpu::TextureFormat::Depth24Plus;
-
-	fn create_depth_texture(
-		config: &wgpu::SurfaceConfiguration,
-		device: &wgpu::Device,
-	) -> wgpu::TextureView {
-		let depth_texture = device.create_texture(&wgpu::TextureDescriptor {
-			size: wgpu::Extent3d {
-				width: config.width,
-				height: config.height,
-				depth_or_array_layers: 1,
-			},
-			mip_level_count: 1,
-			sample_count: 1,
-			dimension: wgpu::TextureDimension::D2,
-			format: Self::DEPTH_FORMAT,
-			usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
-			label: None,
-			view_formats: &[],
-		});
-
-		depth_texture.create_view(&wgpu::TextureViewDescriptor::default())
-	}
-}
-
-fn get_transform_uniform_data(transform:&glam::Mat4) -> [f32; 4*4] {
-	let mut raw = [0f32; 4*4];
-	raw[0..16].copy_from_slice(&AsRef::<[f32; 4*4]>::as_ref(transform)[..]);
-	raw
-}
-
-fn add_obj(device:&wgpu::Device,modeldatas:& mut Vec<ModelData>,source:&[u8]){
-	let data = obj::ObjData::load_buf(&source[..]).unwrap();
-	let mut vertices = Vec::new();
-	let mut vertex_index = std::collections::HashMap::<obj::IndexTuple,u16>::new();
-	for object in data.objects {
-		let mut entities = Vec::<Entity>::new();
-		for group in object.groups {
-			let mut indices = Vec::new();
-			for poly in group.polys {
-				for end_index in 2..poly.0.len() {
-					for &index in &[0, end_index - 1, end_index] {
-						let vert = poly.0[index];
-						if let Some(&i)=vertex_index.get(&vert){
-							indices.push(i as u16);
-						}else{
-							let i=vertices.len() as u16;
-							vertices.push(Vertex {
-								pos: data.position[vert.0],
-								texture: data.texture[vert.1.unwrap()],
-								normal: data.normal[vert.2.unwrap()],
-							});
-							vertex_index.insert(vert,i);
-							indices.push(i);
-						}
-					}
-				}
-			}
-			let index_buf = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
-				label: Some("Index"),
-				contents: bytemuck::cast_slice(&indices),
-				usage: wgpu::BufferUsages::INDEX,
-			});
-			entities.push(Entity {
-				index_buf,
-				index_count: indices.len() as u32,
-			});
 		}
-		let vertex_buf = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
+	}else{
-			label: Some("Vertex"),
+		println!("Could not open file");
-			contents: bytemuck::cast_slice(&vertices),
+		None
-			usage: wgpu::BufferUsages::VERTEX,
-		});
-		modeldatas.push(ModelData {
-			transform: glam::Mat4::default(),
-			vertex_buf,
-			entities,
-		})
 	}
 }
 
-impl strafe_client::framework::Example for Skybox {
+pub fn default_models()->model::IndexedModelInstances{
-	fn optional_features() -> wgpu::Features {
+	let mut indexed_models = Vec::new();
-		wgpu::Features::TEXTURE_COMPRESSION_ASTC
+	indexed_models.push(primitives::unit_sphere());
-			| wgpu::Features::TEXTURE_COMPRESSION_ETC2
+	indexed_models.push(primitives::unit_cylinder());
-			| wgpu::Features::TEXTURE_COMPRESSION_BC
+	indexed_models.push(primitives::unit_cube());
-	}
+	println!("models.len = {:?}", indexed_models.len());
-
+	//quad monkeys
-	fn init(
+	indexed_models[0].instances.push(model::ModelInstance{
-		config: &wgpu::SurfaceConfiguration,
+		transform:integer::Planar64Affine3::try_from(glam::Affine3A::from_translation(glam::vec3(10.,5.,10.))).unwrap(),
-		_adapter: &wgpu::Adapter,
+		..Default::default()
-		device: &wgpu::Device,
+	});
-		queue: &wgpu::Queue,
+	indexed_models[0].instances.push(model::ModelInstance{
-	) -> Self {
+		transform:integer::Planar64Affine3::try_from(glam::Affine3A::from_translation(glam::vec3(20.,5.,10.))).unwrap(),
-		let mut modeldatas = Vec::<ModelData>::new();
+		color:glam::vec4(1.0,0.0,0.0,1.0),
-		add_obj(device,& mut modeldatas,include_bytes!("../models/teslacyberv3.0.obj"));
+		..Default::default()
-		add_obj(device,& mut modeldatas,include_bytes!("../models/suzanne.obj"));
+	});
-		add_obj(device,& mut modeldatas,include_bytes!("../models/teapot.obj"));
+	indexed_models[0].instances.push(model::ModelInstance{
-		println!("models.len = {:?}", modeldatas.len());
+		transform:integer::Planar64Affine3::try_from(glam::Affine3A::from_translation(glam::vec3(10.,5.,20.))).unwrap(),
-		modeldatas[1].transform=glam::Mat4::from_translation(glam::vec3(10.,5.,10.));
+		color:glam::vec4(0.0,1.0,0.0,1.0),
-		modeldatas[2].transform=glam::Mat4::from_translation(glam::vec3(-10.,5.,10.));
+		..Default::default()
-
+	});
-		let main_bind_group_layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
+	indexed_models[0].instances.push(model::ModelInstance{
-			label: None,
+		transform:integer::Planar64Affine3::try_from(glam::Affine3A::from_translation(glam::vec3(20.,5.,20.))).unwrap(),
-			entries: &[
+		color:glam::vec4(0.0,0.0,1.0,1.0),
-				wgpu::BindGroupLayoutEntry {
+		..Default::default()
-					binding: 0,
+	});
-					visibility: wgpu::ShaderStages::VERTEX,
+	//decorative monkey
-					ty: wgpu::BindingType::Buffer {
+	indexed_models[0].instances.push(model::ModelInstance{
-						ty: wgpu::BufferBindingType::Uniform,
+		transform:integer::Planar64Affine3::try_from(glam::Affine3A::from_translation(glam::vec3(15.,10.,15.))).unwrap(),
-						has_dynamic_offset: false,
+		color:glam::vec4(0.5,0.5,0.5,0.5),
-						min_binding_size: None,
+		attributes:model::CollisionAttributes::Decoration,
-					},
+		..Default::default()
-					count: None,
+	});
-				},
+	//teapot
-				wgpu::BindGroupLayoutEntry {
+	indexed_models[1].instances.push(model::ModelInstance{
-					binding: 1,
+		transform:integer::Planar64Affine3::try_from(glam::Affine3A::from_scale_rotation_translation(glam::vec3(0.5, 1.0, 0.2),glam::quat(-0.22248298016985793,-0.839457167990537,-0.05603504040830783,-0.49261857546227916),glam::vec3(-10.,7.,10.))).unwrap(),
-					visibility: wgpu::ShaderStages::FRAGMENT,
+		..Default::default()
-					ty: wgpu::BindingType::Texture {
+	});
-						sample_type: wgpu::TextureSampleType::Float { filterable: true },
+	//ground
-						multisampled: false,
+	indexed_models[2].instances.push(model::ModelInstance{
-						view_dimension: wgpu::TextureViewDimension::Cube,
+		transform:integer::Planar64Affine3::try_from(glam::Affine3A::from_translation(glam::vec3(0.,0.,0.))*glam::Affine3A::from_scale(glam::vec3(160.0, 1.0, 160.0))).unwrap(),
-					},
+		..Default::default()
-					count: None,
+	});
-				},
+	model::IndexedModelInstances{
-				wgpu::BindGroupLayoutEntry {
+		textures:Vec::new(),
-					binding: 2,
+		models:indexed_models,
-					visibility: wgpu::ShaderStages::FRAGMENT,
+		spawn_point:integer::Planar64Vec3::Y*50,
-					ty: wgpu::BindingType::Sampler(wgpu::SamplerBindingType::Filtering),
+		modes:Vec::new(),
-					count: None,
-				},
-			],
-		});
-		let model_bind_group_layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
-			label: None,
-			entries: &[
-				wgpu::BindGroupLayoutEntry {
-					binding: 0,
-					visibility: wgpu::ShaderStages::VERTEX,
-					ty: wgpu::BindingType::Buffer {
-						ty: wgpu::BufferBindingType::Uniform,
-						has_dynamic_offset: false,
-						min_binding_size: None,
-					},
-					count: None,
-				},
-			],
-		});
-
-		// Create the render pipeline
-		let shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
-			label: None,
-			source: wgpu::ShaderSource::Wgsl(Cow::Borrowed(include_str!("shader.wgsl"))),
-		});
-
-		let camera = Camera {
-			screen_size: (config.width, config.height),
-			offset: glam::Vec3::new(0.0,4.5,0.0),
-			fov: 1.0, //fov_slope = tan(fov_y/2)
-			pitch: 0.0,
-			yaw: 0.0,
-			controls:0,
-		};
-		let physics = strafe_client::body::PhysicsState {
-			body: strafe_client::body::Body {
-				position: glam::Vec3::new(5.0,0.0,5.0),
-				velocity: glam::Vec3::new(0.0,0.0,0.0),
-				time: 0,
-			},
-			time: 0,
-			tick: 0,
-			strafe_tick_num: 100,//100t
-			strafe_tick_den: 1_000_000_000,
-			gravity: glam::Vec3::new(0.0,-100.0,0.0),
-			friction: 90.0,
-			mv: 2.7,
-			grounded: true,
-			jump_trying: false,
-			walkspeed: 18.0,
-			contacts: Vec::<strafe_client::body::RelativeCollision>::new(),
-    		models_cringe_clone: modeldatas.iter().map(|m|strafe_client::body::Model::new(m.transform)).collect(),
-		};
-
-		let camera_uniforms = camera.to_uniform_data(physics.extrapolate_position(0));
-		let camera_buf = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
-			label: Some("Camera"),
-			contents: bytemuck::cast_slice(&camera_uniforms),
-			usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
-		});
-
-		//drain the modeldata vec so entities can be /moved/ to models.entities
-		let mut models = Vec::<ModelGraphics>::with_capacity(modeldatas.len());
-		for (i,modeldata) in modeldatas.drain(..).enumerate() {
-			let model_uniforms = get_transform_uniform_data(&modeldata.transform);
-			let model_buf = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
-				label: Some(format!("ModelGraphics{}",i).as_str()),
-				contents: bytemuck::cast_slice(&model_uniforms),
-				usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
-			});
-			let model_bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
-				layout: &model_bind_group_layout,
-				entries: &[
-					wgpu::BindGroupEntry {
-						binding: 0,
-						resource: model_buf.as_entire_binding(),
-					},
-				],
-				label: Some(format!("ModelGraphics{}",i).as_str()),
-			});
-			//all of these are being moved here
-			models.push(ModelGraphics{
-				transform: modeldata.transform,
-				vertex_buf:modeldata.vertex_buf,
-				entities: modeldata.entities,
-				bind_group: model_bind_group,
-				model_buf,
-			})
-		}
-
-		let pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
-			label: None,
-			bind_group_layouts: &[&main_bind_group_layout, &model_bind_group_layout],
-			push_constant_ranges: &[],
-		});
-
-		// Create the render pipelines
-		let sky_pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
-			label: Some("Sky"),
-			layout: Some(&pipeline_layout),
-			vertex: wgpu::VertexState {
-				module: &shader,
-				entry_point: "vs_sky",
-				buffers: &[],
-			},
-			fragment: Some(wgpu::FragmentState {
-				module: &shader,
-				entry_point: "fs_sky",
-				targets: &[Some(config.view_formats[0].into())],
-			}),
-			primitive: wgpu::PrimitiveState {
-				front_face: wgpu::FrontFace::Cw,
-				..Default::default()
-			},
-			depth_stencil: Some(wgpu::DepthStencilState {
-				format: Self::DEPTH_FORMAT,
-				depth_write_enabled: false,
-				depth_compare: wgpu::CompareFunction::LessEqual,
-				stencil: wgpu::StencilState::default(),
-				bias: wgpu::DepthBiasState::default(),
-			}),
-			multisample: wgpu::MultisampleState::default(),
-			multiview: None,
-		});
-		let entity_pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
-			label: Some("Entity"),
-			layout: Some(&pipeline_layout),
-			vertex: wgpu::VertexState {
-				module: &shader,
-				entry_point: "vs_entity",
-				buffers: &[wgpu::VertexBufferLayout {
-					array_stride: std::mem::size_of::<Vertex>() as wgpu::BufferAddress,
-					step_mode: wgpu::VertexStepMode::Vertex,
-					attributes: &wgpu::vertex_attr_array![0 => Float32x3, 1 => Float32x2, 2 => Float32x3],
-				}],
-			},
-			fragment: Some(wgpu::FragmentState {
-				module: &shader,
-				entry_point: "fs_entity",
-				targets: &[Some(config.view_formats[0].into())],
-			}),
-			primitive: wgpu::PrimitiveState {
-				front_face: wgpu::FrontFace::Cw,
-				..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: None,
-		});
-		let ground_pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
-			label: Some("Ground"),
-			layout: Some(&pipeline_layout),
-			vertex: wgpu::VertexState {
-				module: &shader,
-				entry_point: "vs_ground",
-				buffers: &[],
-			},
-			fragment: Some(wgpu::FragmentState {
-				module: &shader,
-				entry_point: "fs_ground",
-				targets: &[Some(config.view_formats[0].into())],
-			}),
-			primitive: wgpu::PrimitiveState {
-				front_face: wgpu::FrontFace::Cw,
-				..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: None,
-		});
-
-		let sampler = device.create_sampler(&wgpu::SamplerDescriptor {
-			label: None,
-			address_mode_u: wgpu::AddressMode::ClampToEdge,
-			address_mode_v: wgpu::AddressMode::ClampToEdge,
-			address_mode_w: wgpu::AddressMode::ClampToEdge,
-			mag_filter: wgpu::FilterMode::Linear,
-			min_filter: wgpu::FilterMode::Linear,
-			mipmap_filter: wgpu::FilterMode::Linear,
-			..Default::default()
-		});
-
-		let device_features = device.features();
-
-		let skybox_format = if device_features.contains(wgpu::Features::TEXTURE_COMPRESSION_ASTC) {
-			log::info!("Using ASTC");
-			wgpu::TextureFormat::Astc {
-				block: AstcBlock::B4x4,
-				channel: AstcChannel::UnormSrgb,
-			}
-		} else if device_features.contains(wgpu::Features::TEXTURE_COMPRESSION_ETC2) {
-			log::info!("Using ETC2");
-			wgpu::TextureFormat::Etc2Rgb8UnormSrgb
-		} else if device_features.contains(wgpu::Features::TEXTURE_COMPRESSION_BC) {
-			log::info!("Using BC");
-			wgpu::TextureFormat::Bc1RgbaUnormSrgb
-		} else {
-			log::info!("Using plain");
-			wgpu::TextureFormat::Bgra8UnormSrgb
-		};
-
-		let size = wgpu::Extent3d {
-			width: IMAGE_SIZE,
-			height: IMAGE_SIZE,
-			depth_or_array_layers: 6,
-		};
-
-		let layer_size = wgpu::Extent3d {
-			depth_or_array_layers: 1,
-			..size
-		};
-		let max_mips = layer_size.max_mips(wgpu::TextureDimension::D2);
-
-		log::debug!(
-			"Copying {:?} skybox images of size {}, {}, 6 with {} mips to gpu",
-			skybox_format,
-			IMAGE_SIZE,
-			IMAGE_SIZE,
-			max_mips,
-		);
-
-		let bytes = match skybox_format {
-			wgpu::TextureFormat::Astc {
-				block: AstcBlock::B4x4,
-				channel: AstcChannel::UnormSrgb,
-			} => &include_bytes!("../images/astc.dds")[..],
-			wgpu::TextureFormat::Etc2Rgb8UnormSrgb => &include_bytes!("../images/etc2.dds")[..],
-			wgpu::TextureFormat::Bc1RgbaUnormSrgb => &include_bytes!("../images/bc1.dds")[..],
-			wgpu::TextureFormat::Bgra8UnormSrgb => &include_bytes!("../images/bgra.dds")[..],
-			_ => unreachable!(),
-		};
-
-		let image = ddsfile::Dds::read(&mut std::io::Cursor::new(&bytes)).unwrap();
-
-		let texture = device.create_texture_with_data(
-			queue,
-			&wgpu::TextureDescriptor {
-				size,
-				mip_level_count: max_mips,
-				sample_count: 1,
-				dimension: wgpu::TextureDimension::D2,
-				format: skybox_format,
-				usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST,
-				label: None,
-				view_formats: &[],
-			},
-			&image.data,
-		);
-
-		let texture_view = texture.create_view(&wgpu::TextureViewDescriptor {
-			label: None,
-			dimension: Some(wgpu::TextureViewDimension::Cube),
-			..wgpu::TextureViewDescriptor::default()
-		});
-		let main_bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
-			layout: &main_bind_group_layout,
-			entries: &[
-				wgpu::BindGroupEntry {
-					binding: 0,
-					resource: camera_buf.as_entire_binding(),
-				},
-				wgpu::BindGroupEntry {
-					binding: 1,
-					resource: wgpu::BindingResource::TextureView(&texture_view),
-				},
-				wgpu::BindGroupEntry {
-					binding: 2,
-					resource: wgpu::BindingResource::Sampler(&sampler),
-				},
-			],
-			label: Some("Camera"),
-		});
-
-		let depth_view = Self::create_depth_texture(config, device);
-
-		Skybox {
-			start_time: Instant::now(),
-			camera,
-			physics,
-			sky_pipeline,
-			entity_pipeline,
-			ground_pipeline,
-			main_bind_group,
-			camera_buf,
-			models,
-			depth_view,
-			staging_belt: wgpu::util::StagingBelt::new(0x100),
-		}
-	}
-
-	#[allow(clippy::single_match)]
-	fn update(&mut self, event: winit::event::WindowEvent) {
-		match event {
-			winit::event::WindowEvent::KeyboardInput {
-				input:
-					winit::event::KeyboardInput {
-						state,
-						virtual_keycode: Some(keycode),
-						..
-					},
-				..
-			} => {
-				match (state,keycode) {
-					(k,winit::event::VirtualKeyCode::W) => match k {
-						winit::event::ElementState::Pressed => self.camera.controls|=CONTROL_MOVEFORWARD,
-						winit::event::ElementState::Released => self.camera.controls&=!CONTROL_MOVEFORWARD,
-					}
-					(k,winit::event::VirtualKeyCode::A) => match k {
-						winit::event::ElementState::Pressed => self.camera.controls|=CONTROL_MOVELEFT,
-						winit::event::ElementState::Released => self.camera.controls&=!CONTROL_MOVELEFT,
-					}
-					(k,winit::event::VirtualKeyCode::S) => match k {
-						winit::event::ElementState::Pressed => self.camera.controls|=CONTROL_MOVEBACK,
-						winit::event::ElementState::Released => self.camera.controls&=!CONTROL_MOVEBACK,
-					}
-					(k,winit::event::VirtualKeyCode::D) => match k {
-						winit::event::ElementState::Pressed => self.camera.controls|=CONTROL_MOVERIGHT,
-						winit::event::ElementState::Released => self.camera.controls&=!CONTROL_MOVERIGHT,
-					}
-					(k,winit::event::VirtualKeyCode::E) => match k {
-						winit::event::ElementState::Pressed => self.camera.controls|=CONTROL_MOVEUP,
-						winit::event::ElementState::Released => self.camera.controls&=!CONTROL_MOVEUP,
-					}
-					(k,winit::event::VirtualKeyCode::Q) => match k {
-						winit::event::ElementState::Pressed => self.camera.controls|=CONTROL_MOVEDOWN,
-						winit::event::ElementState::Released => self.camera.controls&=!CONTROL_MOVEDOWN,
-					}
-					(k,winit::event::VirtualKeyCode::Space) => match k {
-						winit::event::ElementState::Pressed => self.camera.controls|=CONTROL_JUMP,
-						winit::event::ElementState::Released => self.camera.controls&=!CONTROL_JUMP,
-					}
-					(k,winit::event::VirtualKeyCode::Z) => match k {
-						winit::event::ElementState::Pressed => self.camera.controls|=CONTROL_ZOOM,
-						winit::event::ElementState::Released => self.camera.controls&=!CONTROL_ZOOM,
-					}
-					_ => (),
-				}
-			}
-			_ => {}
-		}
-	}
-
-	fn move_mouse(&mut self, delta: (f64,f64)) {
-		self.camera.pitch=(self.camera.pitch as f64+delta.1/-2048.) as f32;
-		self.camera.yaw=(self.camera.yaw as f64+delta.0/-2048.) as f32;
-	}
-
-	fn resize(
-		&mut self,
-		config: &wgpu::SurfaceConfiguration,
-		device: &wgpu::Device,
-		_queue: &wgpu::Queue,
-	) {
-		self.depth_view = Self::create_depth_texture(config, device);
-		self.camera.screen_size = (config.width, config.height);
-	}
-
-	fn render(
-		&mut self,
-		view: &wgpu::TextureView,
-		device: &wgpu::Device,
-		queue: &wgpu::Queue,
-		_spawner: &strafe_client::framework::Spawner,
-	) {
-		let camera_mat=glam::Mat3::from_euler(glam::EulerRot::YXZ,self.camera.yaw,0f32,0f32);
-		let control_dir=camera_mat*get_control_dir(self.camera.controls&(CONTROL_MOVELEFT|CONTROL_MOVERIGHT|CONTROL_MOVEFORWARD|CONTROL_MOVEBACK)).normalize_or_zero();
-
-		let time=self.start_time.elapsed().as_nanos() as i64;
-
-		self.physics.run(time,control_dir,self.camera.controls);
-
-		let mut encoder =
-			device.create_command_encoder(&wgpu::CommandEncoderDescriptor { label: None });
-
-		// update rotation
-		let camera_uniforms = self.camera.to_uniform_data(self.physics.extrapolate_position(time));
-		self.staging_belt
-			.write_buffer(
-				&mut encoder,
-				&self.camera_buf,
-				0,
-				wgpu::BufferSize::new((camera_uniforms.len() * 4) as wgpu::BufferAddress).unwrap(),
-				device,
-			)
-			.copy_from_slice(bytemuck::cast_slice(&camera_uniforms));
-		//This code only needs to run when the uniforms change
-		for model in self.models.iter() {
-			let model_uniforms = get_transform_uniform_data(&model.transform);
-			self.staging_belt
-				.write_buffer(
-					&mut encoder,
-					&model.model_buf,//description of where data will be written when command is executed
-					0,//offset in staging belt?
-					wgpu::BufferSize::new((model_uniforms.len() * 4) as wgpu::BufferAddress).unwrap(),
-					device,
-				)
-				.copy_from_slice(bytemuck::cast_slice(&model_uniforms));
-		}
-		self.staging_belt.finish();
-
-		{
-			let mut rpass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
-				label: None,
-				color_attachments: &[Some(wgpu::RenderPassColorAttachment {
-					view,
-					resolve_target: None,
-					ops: wgpu::Operations {
-						load: wgpu::LoadOp::Clear(wgpu::Color {
-							r: 0.1,
-							g: 0.2,
-							b: 0.3,
-							a: 1.0,
-						}),
-						store: true,
-					},
-				})],
-				depth_stencil_attachment: Some(wgpu::RenderPassDepthStencilAttachment {
-					view: &self.depth_view,
-					depth_ops: Some(wgpu::Operations {
-						load: wgpu::LoadOp::Clear(1.0),
-						store: false,
-					}),
-					stencil_ops: None,
-				}),
-			});
-
-			rpass.set_bind_group(0, &self.main_bind_group, &[]);
-
-			rpass.set_pipeline(&self.entity_pipeline);
-			for model in self.models.iter() {
-				rpass.set_bind_group(1, &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..1);
-				}
-			}
-
-			rpass.set_pipeline(&self.ground_pipeline);
-			//rpass.set_index_buffer(&[0u16,1,2,1,2,3][..] as wgpu::BufferSlice, wgpu::IndexFormat::Uint16);
-			//rpass.draw_indexed(0..4, 0, 0..1);
-			rpass.draw(0..6, 0..1);
-
-			rpass.set_pipeline(&self.sky_pipeline);
-			rpass.draw(0..3, 0..1);
-		}
-
-		queue.submit(std::iter::once(encoder.finish()));
-
-		self.staging_belt.recall();
 	}
 }
 
-fn main() {
+fn main(){
-	strafe_client::framework::run::<Skybox>(
+	setup::setup_and_start(format!("Strafe Client v{}",env!("CARGO_PKG_VERSION")));
-		format!("Strafe Client v{}",
-			env!("CARGO_PKG_VERSION")
-		).as_str()
-	);
 }

src/model.rs

@@ -0,0 +1,321 @@
+use strafesnet_common::integer::{Time,Planar64,Planar64Vec3,Planar64Affine3};
+pub type TextureCoordinate=glam::Vec2;
+pub type Color4=glam::Vec4;
+#[derive(Clone,Hash,PartialEq,Eq)]
+pub struct IndexedVertex{
+	pub pos:u32,
+	pub tex:u32,
+	pub normal:u32,
+	pub color:u32,
+}
+pub struct IndexedPolygon{
+	pub vertices:Vec<u32>,
+}
+pub struct IndexedGroup{
+	pub texture:Option<u32>,//RenderPattern? material/texture/shader/flat color
+	pub polys:Vec<IndexedPolygon>,
+}
+pub struct IndexedModel{
+	pub unique_pos:Vec<Planar64Vec3>,
+	pub unique_normal:Vec<Planar64Vec3>,
+	pub unique_tex:Vec<TextureCoordinate>,
+	pub unique_color:Vec<Color4>,
+	pub unique_vertices:Vec<IndexedVertex>,
+	pub groups: Vec<IndexedGroup>,
+	pub instances:Vec<ModelInstance>,
+}
+pub struct ModelInstance{
+	//pub id:u64,//this does not actually help with map fixes resimulating bots, they must always be resimulated
+	pub transform:Planar64Affine3,
+	pub color:Color4,//transparency is in here
+	pub attributes:CollisionAttributes,
+	pub temp_indexing:Vec<TempIndexedAttributes>,
+}
+impl std::default::Default for ModelInstance{
+	fn default() -> Self {
+		Self{
+			color:Color4::ONE,
+			transform:Default::default(),
+			attributes:Default::default(),
+			temp_indexing:Default::default(),
+		}
+	}
+}
+pub struct IndexedModelInstances{
+	pub textures:Vec<String>,//RenderPattern
+	pub models:Vec<IndexedModel>,
+	//may make this into an object later.
+	pub modes:Vec<ModeDescription>,
+	pub spawn_point:Planar64Vec3,
+}
+//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 spawn_from_stage_id:std::collections::HashMap::<u32,usize>,
+	pub ordered_checkpoint_from_checkpoint_id:std::collections::HashMap::<u32,usize>,
+}
+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)?)
+	}
+}
+//I don't want this code to exist!
+#[derive(Clone)]
+pub struct TempAttrStart{
+	pub mode_id:u32,
+}
+#[derive(Clone)]
+pub struct TempAttrSpawn{
+	pub mode_id:u32,
+	pub stage_id:u32,
+}
+#[derive(Clone)]
+pub struct TempAttrWormhole{
+	pub wormhole_id:u32,
+}
+pub enum TempIndexedAttributes{
+	Start(TempAttrStart),
+	Spawn(TempAttrSpawn),
+	Wormhole(TempAttrWormhole),
+}
+
+//you have this effect while in contact
+#[derive(Clone,Hash,Eq,PartialEq)]
+pub struct ContactingLadder{
+	pub sticky:bool
+}
+#[derive(Clone,Hash,Eq,PartialEq)]
+pub enum ContactingBehaviour{
+	Surf,
+	Cling,//usable as a zipline, or other weird and wonderful things
+	Ladder(ContactingLadder),
+	Elastic(u32),//[1/2^32,1] 0=None (elasticity+1)/2^32
+}
+//you have this effect while intersecting
+#[derive(Clone,Hash,Eq,PartialEq)]
+pub struct IntersectingWater{
+	pub viscosity:Planar64,
+	pub density:Planar64,
+	pub velocity:Planar64Vec3,
+}
+//All models can be given these attributes
+#[derive(Clone,Hash,Eq,PartialEq)]
+pub struct GameMechanicAccelerator{
+	pub acceleration:Planar64Vec3
+}
+#[derive(Clone,Hash,Eq,PartialEq)]
+pub enum GameMechanicBooster{
+	Affine(Planar64Affine3),//capable of SetVelocity,DotVelocity,normal booster,bouncy part,redirect velocity, and much more
+	Velocity(Planar64Vec3),//straight up boost velocity adds to your current velocity
+	Energy{direction:Planar64Vec3,energy:Planar64},//increase energy in direction
+}
+#[derive(Clone,Hash,Eq,PartialEq)]
+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
+}
+#[derive(Clone,Hash,Eq,PartialEq)]
+pub enum GameMechanicSetTrajectory{
+	//Speed-type SetTrajectory
+	AirTime(Time),//air time (relative to gravity direction) is invariant across mass and gravity changes
+	Height(Planar64),//boost height (relative to gravity direction) is invariant across mass and gravity changes
+	DotVelocity{direction:Planar64Vec3,dot:Planar64},//set your velocity in a specific direction without touching other directions
+	//Velocity-type SetTrajectory
+	TargetPointTime{//launch on a trajectory that will land at a target point in a set amount of time
+		target_point:Planar64Vec3,
+		time:Time,//short time = fast and direct, long time = launch high in the air, negative time = wrong way
+	},
+	TargetPointSpeed{//launch at a fixed speed and land at a target point
+		target_point:Planar64Vec3,
+		speed:Planar64,//if speed is too low this will fail to reach the target.  The closest-passing trajectory will be chosen instead
+		trajectory_choice:TrajectoryChoice,
+	},
+	Velocity(Planar64Vec3),//SetVelocity
+}
+impl GameMechanicSetTrajectory{
+	fn is_velocity(&self)->bool{
+		match self{
+			GameMechanicSetTrajectory::AirTime(_)
+			|GameMechanicSetTrajectory::Height(_)
+			|GameMechanicSetTrajectory::DotVelocity{direction:_,dot:_}=>false,
+			GameMechanicSetTrajectory::TargetPointTime{target_point:_,time:_}
+			|GameMechanicSetTrajectory::TargetPointSpeed{target_point:_,speed:_,trajectory_choice:_}
+			|GameMechanicSetTrajectory::Velocity(_)=>true,
+		}
+	}
+}
+#[derive(Clone,Hash,Eq,PartialEq)]
+pub enum ZoneBehaviour{
+	//Start is indexed
+	//Checkpoints are indexed
+	Finish,
+	Anitcheat,
+}
+#[derive(Clone,Hash,Eq,PartialEq)]
+pub struct GameMechanicZone{
+	pub mode_id:u32,
+	pub behaviour:ZoneBehaviour,
+}
+// enum TrapCondition{
+// 	FasterThan(Planar64),
+// 	SlowerThan(Planar64),
+// 	InRange(Planar64,Planar64),
+// 	OutsideRange(Planar64,Planar64),
+// }
+#[derive(Clone,Hash,Eq,PartialEq)]
+pub enum StageElementBehaviour{
+	//Spawn,//The behaviour of stepping on a spawn setting the spawnid
+	SpawnAt,//must be standing on top to get effect. except cancollide false
+	Trigger,
+	Teleport,
+	Platform,
+	//Checkpoint acts like a trigger if you haven't hit all the checkpoints yet.
+	//Note that all stage elements act like this for the next stage.
+	Checkpoint,
+	//OrderedCheckpoint. You must pass through all of these in ascending order.
+	//If you hit them out of order it acts like a trigger.
+	//Do not support backtracking at all for now.
+	Ordered{
+		checkpoint_id:u32,
+	},
+	//UnorderedCheckpoint. You must pass through all of these in any order.
+	Unordered,
+	//If you get reset by a jump limit
+	JumpLimit(u32),
+	//Speedtrap(TrapCondition),//Acts as a trigger with a speed condition
+}
+#[derive(Clone,Hash,Eq,PartialEq)]
+pub struct GameMechanicStageElement{
+	pub mode_id:u32,
+	pub stage_id:u32,//which spawn to send to
+	pub force:bool,//allow setting to lower spawn id i.e. 7->3
+	pub behaviour:StageElementBehaviour
+}
+#[derive(Clone,Hash,Eq,PartialEq)]
+pub struct GameMechanicWormhole{
+	//destination does not need to be another wormhole
+	//this defines a one way portal to a destination model transform
+	//two of these can create a two way wormhole
+	pub destination_model_id:u32,
+	//(position,angles)*=origin.transform.inverse()*destination.transform
+}
+#[derive(Clone,Hash,Eq,PartialEq)]
+pub enum TeleportBehaviour{
+	StageElement(GameMechanicStageElement),
+	Wormhole(GameMechanicWormhole),
+}
+//attributes listed in order of handling
+#[derive(Default,Clone,Hash,Eq,PartialEq)]
+pub struct GameMechanicAttributes{
+	pub zone:Option<GameMechanicZone>,
+	pub booster:Option<GameMechanicBooster>,
+	pub trajectory:Option<GameMechanicSetTrajectory>,
+	pub teleport_behaviour:Option<TeleportBehaviour>,
+	pub accelerator:Option<GameMechanicAccelerator>,
+}
+impl GameMechanicAttributes{
+	pub fn any(&self)->bool{
+		self.zone.is_some()
+		||self.booster.is_some()
+		||self.trajectory.is_some()
+		||self.teleport_behaviour.is_some()
+		||self.accelerator.is_some()
+	}
+	pub fn is_wrcp(&self,current_mode_id:u32)->bool{
+		self.trajectory.as_ref().map_or(false,|t|t.is_velocity())
+		&&match &self.teleport_behaviour{
+			Some(TeleportBehaviour::StageElement(
+				GameMechanicStageElement{
+					mode_id,
+					stage_id:_,
+					force:true,
+					behaviour:StageElementBehaviour::Trigger|StageElementBehaviour::Teleport
+				}
+			))=>current_mode_id==*mode_id,
+			_=>false,
+		}
+	}
+}
+#[derive(Default,Clone,Hash,Eq,PartialEq)]
+pub struct ContactingAttributes{
+	//friction?
+	pub contact_behaviour:Option<ContactingBehaviour>,
+}
+impl ContactingAttributes{
+	pub fn any(&self)->bool{
+		self.contact_behaviour.is_some()
+	}
+}
+#[derive(Default,Clone,Hash,Eq,PartialEq)]
+pub struct IntersectingAttributes{
+	pub water:Option<IntersectingWater>,
+}
+impl IntersectingAttributes{
+	pub fn any(&self)->bool{
+		self.water.is_some()
+	}
+}
+//Spawn(u32) NO! spawns are indexed in the map header instead of marked with attibutes
+pub enum CollisionAttributes{
+	Decoration,//visual only
+	Contact{//track whether you are contacting the object
+		contacting:ContactingAttributes,
+		general:GameMechanicAttributes,
+	},
+	Intersect{//track whether you are intersecting the object
+		intersecting:IntersectingAttributes,
+		general:GameMechanicAttributes,
+	},
+}
+impl std::default::Default for CollisionAttributes{
+	fn default() -> Self {
+		Self::Contact{
+			contacting:ContactingAttributes::default(),
+			general:GameMechanicAttributes::default()
+		}
+	}
+}
+
+pub fn generate_indexed_model_list_from_obj(data:obj::ObjData,color:Color4)->Vec<IndexedModel>{
+	let mut unique_vertex_index = std::collections::HashMap::<obj::IndexTuple,u32>::new();
+	return data.objects.iter().map(|object|{
+		unique_vertex_index.clear();
+		let mut unique_vertices = Vec::new();
+		let groups = object.groups.iter().map(|group|{
+			IndexedGroup{
+				texture:None,
+				polys:group.polys.iter().map(|poly|{
+					IndexedPolygon{
+						vertices:poly.0.iter().map(|&tup|{
+							if let Some(&i)=unique_vertex_index.get(&tup){
+								i
+							}else{
+								let i=unique_vertices.len() as u32;
+								unique_vertices.push(IndexedVertex{
+									pos: tup.0 as u32,
+									tex: tup.1.unwrap() as u32,
+									normal: tup.2.unwrap() as u32,
+									color: 0,
+								});
+								unique_vertex_index.insert(tup,i);
+								i
+							}
+						}).collect()
+					}
+				}).collect()
+			}
+		}).collect();
+		IndexedModel{
+			unique_pos: data.position.iter().map(|&v|Planar64Vec3::try_from(v).unwrap()).collect(),
+			unique_tex: data.texture.iter().map(|&v|TextureCoordinate::from_array(v)).collect(),
+			unique_normal: data.normal.iter().map(|&v|Planar64Vec3::try_from(v).unwrap()).collect(),
+			unique_color: vec![color],
+			unique_vertices,
+			groups,
+			instances:Vec::new(),
+		}
+	}).collect()
+}

src/model_graphics.rs

@@ -0,0 +1,59 @@
+use bytemuck::{Pod, Zeroable};
+use crate::model::{IndexedVertex,IndexedPolygon};
+#[derive(Clone, Copy, Pod, Zeroable)]
+#[repr(C)]
+pub struct GraphicsVertex {
+	pub pos: [f32; 3],
+	pub tex: [f32; 2],
+	pub normal: [f32; 3],
+	pub color: [f32; 4],
+}
+pub struct IndexedGroupFixedTexture{
+	pub polys:Vec<IndexedPolygon>,
+}
+pub struct IndexedGraphicsModelSingleTexture{
+	pub unique_pos:Vec<[f32; 3]>,
+	pub unique_tex:Vec<[f32; 2]>,
+	pub unique_normal:Vec<[f32; 3]>,
+	pub unique_color:Vec<[f32; 4]>,
+	pub unique_vertices:Vec<IndexedVertex>,
+	pub texture:Option<u32>,//RenderPattern? material/texture/shader/flat color
+	pub groups: Vec<IndexedGroupFixedTexture>,
+	pub instances:Vec<GraphicsModelInstance>,
+}
+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 GraphicsModelColor4(glam::Vec4);
+impl GraphicsModelColor4{
+	pub const fn get(&self)->glam::Vec4{
+		self.0
+	}
+}
+impl From<glam::Vec4> for GraphicsModelColor4{
+	fn from(value:glam::Vec4)->Self{
+		Self(value)
+	}
+}
+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 GraphicsModelColor4{}
+#[derive(Clone)]
+pub struct GraphicsModelInstance{
+	pub transform:glam::Mat4,
+	pub normal_transform:glam::Mat3,
+	pub color:GraphicsModelColor4,
+}

src/model_physics.rs

@@ -0,0 +1,745 @@
+use std::borrow::{Borrow,Cow};
+use strafesnet_common::zeroes;
+use strafesnet_common::integer::{self,Planar64,Planar64Vec3};
+
+#[derive(Debug,Clone,Copy,Hash,Eq,PartialEq)]
+pub struct VertId(usize);
+#[derive(Debug,Clone,Copy,Hash,Eq,PartialEq)]
+pub struct EdgeId(usize);
+pub trait UndirectedEdge{
+	type DirectedEdge:Copy+DirectedEdge;
+	fn as_directed(&self,parity:bool)->Self::DirectedEdge;
+}
+impl UndirectedEdge for EdgeId{
+	type DirectedEdge=DirectedEdgeId;
+	fn as_directed(&self,parity:bool)->DirectedEdgeId{
+		DirectedEdgeId(self.0|((parity as usize)<<(usize::BITS-1)))
+	}
+}
+pub trait DirectedEdge{
+	type UndirectedEdge:Copy+UndirectedEdge;
+	fn as_undirected(&self)->Self::UndirectedEdge;
+	fn parity(&self)->bool;
+	//this is stupid but may work fine
+	fn reverse(&self)-><<Self as DirectedEdge>::UndirectedEdge as UndirectedEdge>::DirectedEdge{
+		self.as_undirected().as_directed(!self.parity())
+	}
+}
+/// DirectedEdgeId refers to an EdgeId when undirected.
+#[derive(Debug,Clone,Copy,Hash,Eq,PartialEq)]
+pub struct DirectedEdgeId(usize);
+impl DirectedEdge for DirectedEdgeId{
+	type UndirectedEdge=EdgeId;
+	fn as_undirected(&self)->EdgeId{
+		EdgeId(self.0&!(1<<(usize::BITS-1)))
+	}
+	fn parity(&self)->bool{
+		self.0&(1<<(usize::BITS-1))!=0
+	}
+}
+#[derive(Debug,Clone,Copy,Hash,Eq,PartialEq)]
+pub struct FaceId(usize);
+
+//Vertex <-> Edge <-> Face -> Collide
+pub enum FEV<F,E:DirectedEdge,V>{
+	Face(F),
+	Edge(E::UndirectedEdge),
+	Vert(V),
+}
+
+//use Unit32 #[repr(C)] for map files
+struct Face{
+	normal:Planar64Vec3,
+	dot:Planar64,
+}
+struct Vert(Planar64Vec3);
+pub trait MeshQuery<FACE:Clone,EDGE:Clone+DirectedEdge,VERT:Clone>{
+	fn edge_n(&self,edge_id:EDGE::UndirectedEdge)->Planar64Vec3{
+		let verts=self.edge_verts(edge_id);
+		self.vert(verts[1].clone())-self.vert(verts[0].clone())
+	}
+	fn directed_edge_n(&self,directed_edge_id:EDGE)->Planar64Vec3{
+		let verts=self.edge_verts(directed_edge_id.as_undirected());
+		(self.vert(verts[1].clone())-self.vert(verts[0].clone()))*((directed_edge_id.parity() as i64)*2-1)
+	}
+	fn vert(&self,vert_id:VERT)->Planar64Vec3;
+	fn face_nd(&self,face_id:FACE)->(Planar64Vec3,Planar64);
+	fn face_edges(&self,face_id:FACE)->Cow<Vec<EDGE>>;
+	fn edge_faces(&self,edge_id:EDGE::UndirectedEdge)->Cow<[FACE;2]>;
+	fn edge_verts(&self,edge_id:EDGE::UndirectedEdge)->Cow<[VERT;2]>;
+	fn vert_edges(&self,vert_id:VERT)->Cow<Vec<EDGE>>;
+	fn vert_faces(&self,vert_id:VERT)->Cow<Vec<FACE>>;
+}
+struct FaceRefs{
+	edges:Vec<DirectedEdgeId>,
+	//verts:Vec<VertId>,
+}
+struct EdgeRefs{
+	faces:[FaceId;2],//left, right
+	verts:[VertId;2],//bottom, top
+}
+struct VertRefs{
+	faces:Vec<FaceId>,
+	edges:Vec<DirectedEdgeId>,
+}
+pub struct PhysicsMesh{
+	faces:Vec<Face>,
+	verts:Vec<Vert>,
+	face_topology:Vec<FaceRefs>,
+	edge_topology:Vec<EdgeRefs>,
+	vert_topology:Vec<VertRefs>,
+}
+
+#[derive(Default,Clone)]
+struct VertRefGuy{
+	edges:std::collections::HashSet<DirectedEdgeId>,
+	faces:std::collections::HashSet<FaceId>,
+}
+#[derive(Clone,Hash,Eq,PartialEq)]
+struct EdgeRefVerts([VertId;2]);
+impl EdgeRefVerts{
+	fn new(v0:VertId,v1:VertId)->(Self,bool){
+		(if v0.0<v1.0{
+			Self([v0,v1])
+		}else{
+			Self([v1,v0])
+		},v0.0<v1.0)
+	}
+}
+struct EdgeRefFaces([FaceId;2]);
+impl EdgeRefFaces{
+	fn new()->Self{
+		Self([FaceId(0);2])
+	}
+	fn push(&mut self,i:usize,face_id:FaceId){
+		self.0[i]=face_id;
+	}
+}
+struct FaceRefEdges(Vec<DirectedEdgeId>);
+#[derive(Default)]
+struct EdgePool{
+	edge_guys:Vec<(EdgeRefVerts,EdgeRefFaces)>,
+	edge_id_from_guy:std::collections::HashMap<EdgeRefVerts,usize>,
+}
+impl EdgePool{
+	fn push(&mut self,edge_ref_verts:EdgeRefVerts)->(&mut EdgeRefFaces,EdgeId){
+		let edge_id=if let Some(&edge_id)=self.edge_id_from_guy.get(&edge_ref_verts){
+			edge_id
+		}else{
+			let edge_id=self.edge_guys.len();
+			self.edge_guys.push((edge_ref_verts.clone(),EdgeRefFaces::new()));
+			self.edge_id_from_guy.insert(edge_ref_verts,edge_id);
+			edge_id
+		};
+		(&mut unsafe{self.edge_guys.get_unchecked_mut(edge_id)}.1,EdgeId(edge_id))
+	}
+}
+impl From<&crate::model::IndexedModel> for PhysicsMesh{
+	fn from(indexed_model:&crate::model::IndexedModel)->Self{
+		assert!(indexed_model.unique_pos.len()!=0,"Mesh cannot have 0 vertices");
+		let verts=indexed_model.unique_pos.iter().map(|v|Vert(v.clone())).collect();
+		let mut vert_ref_guys=vec![VertRefGuy::default();indexed_model.unique_pos.len()];
+		let mut edge_pool=EdgePool::default();
+		let mut face_i=0;
+		let mut faces=Vec::new();
+		let mut face_ref_guys=Vec::new();
+		for group in indexed_model.groups.iter(){for poly in group.polys.iter(){
+			let face_id=FaceId(face_i);
+			//one face per poly
+			let mut normal=Planar64Vec3::ZERO;
+			let len=poly.vertices.len();
+			let face_edges=poly.vertices.iter().enumerate().map(|(i,&vert_id)|{
+				let vert0_id=indexed_model.unique_vertices[vert_id as usize].pos as usize;
+				let vert1_id=indexed_model.unique_vertices[poly.vertices[(i+1)%len] as usize].pos as usize;
+				//https://www.khronos.org/opengl/wiki/Calculating_a_Surface_Normal (Newell's Method)
+				let v0=indexed_model.unique_pos[vert0_id];
+				let v1=indexed_model.unique_pos[vert1_id];
+				normal+=Planar64Vec3::new(
+					(v0.y()-v1.y())*(v0.z()+v1.z()),
+					(v0.z()-v1.z())*(v0.x()+v1.x()),
+					(v0.x()-v1.x())*(v0.y()+v1.y()),
+				);
+				//get/create edge and push face into it
+				let (edge_ref_verts,is_sorted)=EdgeRefVerts::new(VertId(vert0_id),VertId(vert1_id));
+				let (edge_ref_faces,edge_id)=edge_pool.push(edge_ref_verts);
+				//polygon vertices as assumed to be listed clockwise
+				//populate the edge face on the left or right depending on how the edge vertices got sorted
+				edge_ref_faces.push(!is_sorted as usize,face_id);
+				//index edges & face into vertices
+				{
+					let vert_ref_guy=unsafe{vert_ref_guys.get_unchecked_mut(vert0_id)};
+					vert_ref_guy.edges.insert(edge_id.as_directed(is_sorted));
+					vert_ref_guy.faces.insert(face_id);
+					unsafe{vert_ref_guys.get_unchecked_mut(vert1_id)}.edges.insert(edge_id.as_directed(!is_sorted));
+				}
+				//return directed_edge_id
+				edge_id.as_directed(is_sorted)
+			}).collect();
+			//choose precision loss randomly idk
+			normal=normal/len as i64;
+			let mut dot=Planar64::ZERO;
+			for &v in poly.vertices.iter(){
+				dot+=normal.dot(indexed_model.unique_pos[indexed_model.unique_vertices[v as usize].pos as usize]);
+			}
+			faces.push(Face{normal,dot:dot/len as i64});
+			face_ref_guys.push(FaceRefEdges(face_edges));
+			face_i+=1;
+		}}
+		//conceivably faces, edges, and vertices exist now
+		Self{
+			faces,
+			verts,
+			face_topology:face_ref_guys.into_iter().map(|face_ref_guy|{
+				FaceRefs{edges:face_ref_guy.0}
+			}).collect(),
+			edge_topology:edge_pool.edge_guys.into_iter().map(|(edge_ref_verts,edge_ref_faces)|
+				EdgeRefs{faces:edge_ref_faces.0,verts:edge_ref_verts.0}
+			).collect(),
+			vert_topology:vert_ref_guys.into_iter().map(|vert_ref_guy|
+				VertRefs{
+					edges:vert_ref_guy.edges.into_iter().collect(),
+					faces:vert_ref_guy.faces.into_iter().collect(),
+				}
+			).collect(),
+		}
+	}
+}
+
+impl PhysicsMesh{
+	pub fn verts<'a>(&'a self)->impl Iterator<Item=Planar64Vec3>+'a{
+		self.verts.iter().map(|Vert(pos)|*pos)
+	}
+}
+impl MeshQuery<FaceId,DirectedEdgeId,VertId> for PhysicsMesh{
+	fn face_nd(&self,face_id:FaceId)->(Planar64Vec3,Planar64){
+		(self.faces[face_id.0].normal,self.faces[face_id.0].dot)
+	}
+	//ideally I never calculate the vertex position, but I have to for the graphical meshes...
+	fn vert(&self,vert_id:VertId)->Planar64Vec3{
+		self.verts[vert_id.0].0
+	}
+	fn face_edges(&self,face_id:FaceId)->Cow<Vec<DirectedEdgeId>>{
+		Cow::Borrowed(&self.face_topology[face_id.0].edges)
+	}
+	fn edge_faces(&self,edge_id:EdgeId)->Cow<[FaceId;2]>{
+		Cow::Borrowed(&self.edge_topology[edge_id.0].faces)
+	}
+	fn edge_verts(&self,edge_id:EdgeId)->Cow<[VertId;2]>{
+		Cow::Borrowed(&self.edge_topology[edge_id.0].verts)
+	}
+	fn vert_edges(&self,vert_id:VertId)->Cow<Vec<DirectedEdgeId>>{
+		Cow::Borrowed(&self.vert_topology[vert_id.0].edges)
+	}
+	fn vert_faces(&self,vert_id:VertId)->Cow<Vec<FaceId>>{
+		Cow::Borrowed(&self.vert_topology[vert_id.0].faces)
+	}
+}
+
+pub struct TransformedMesh<'a>{
+	mesh:&'a PhysicsMesh,
+	transform:&'a integer::Planar64Affine3,
+	normal_transform:&'a integer::Planar64Mat3,
+	transform_det:Planar64,
+}
+impl TransformedMesh<'_>{
+	pub fn new<'a>(
+		mesh:&'a PhysicsMesh,
+		transform:&'a integer::Planar64Affine3,
+		normal_transform:&'a integer::Planar64Mat3,
+		transform_det:Planar64,
+		)->TransformedMesh<'a>{
+		TransformedMesh{
+			mesh,
+			transform,
+			normal_transform,
+			transform_det,
+		}
+	}
+	fn farthest_vert(&self,dir:Planar64Vec3)->VertId{
+		let mut best_dot=Planar64::MIN;
+		let mut best_vert=VertId(0);
+		for (i,vert) in self.mesh.verts.iter().enumerate(){
+			let p=self.transform.transform_point3(vert.0);
+			let d=dir.dot(p);
+			if best_dot<d{
+				best_dot=d;
+				best_vert=VertId(i);
+			}
+		}
+		best_vert
+	}
+}
+impl MeshQuery<FaceId,DirectedEdgeId,VertId> for TransformedMesh<'_>{
+	fn face_nd(&self,face_id:FaceId)->(Planar64Vec3,Planar64){
+		let (n,d)=self.mesh.face_nd(face_id);
+		let transformed_n=*self.normal_transform*n;
+		let transformed_d=d+transformed_n.dot(self.transform.translation)/self.transform_det;
+		(transformed_n/self.transform_det,transformed_d)
+	}
+	fn vert(&self,vert_id:VertId)->Planar64Vec3{
+		self.transform.transform_point3(self.mesh.vert(vert_id))
+	}
+	#[inline]
+	fn face_edges(&self,face_id:FaceId)->Cow<Vec<DirectedEdgeId>>{
+		self.mesh.face_edges(face_id)
+	}
+	#[inline]
+	fn edge_faces(&self,edge_id:EdgeId)->Cow<[FaceId;2]>{
+		self.mesh.edge_faces(edge_id)
+	}
+	#[inline]
+	fn edge_verts(&self,edge_id:EdgeId)->Cow<[VertId;2]>{
+		self.mesh.edge_verts(edge_id)
+	}
+	#[inline]
+	fn vert_edges(&self,vert_id:VertId)->Cow<Vec<DirectedEdgeId>>{
+		self.mesh.vert_edges(vert_id)
+	}
+	#[inline]
+	fn vert_faces(&self,vert_id:VertId)->Cow<Vec<FaceId>>{
+		self.mesh.vert_faces(vert_id)
+	}
+}
+
+//Note that a face on a minkowski mesh refers to a pair of fevs on the meshes it's summed from
+//(face,vertex)
+//(edge,edge)
+//(vertex,face)
+#[derive(Clone,Copy)]
+pub enum MinkowskiVert{
+	VertVert(VertId,VertId),
+}
+#[derive(Clone,Copy)]
+pub enum MinkowskiEdge{
+	VertEdge(VertId,EdgeId),
+	EdgeVert(EdgeId,VertId),
+	//EdgeEdge when edges are parallel
+}
+impl UndirectedEdge for MinkowskiEdge{
+	type DirectedEdge=MinkowskiDirectedEdge;
+	fn as_directed(&self,parity:bool)->Self::DirectedEdge{
+		match self{
+			MinkowskiEdge::VertEdge(v0,e1)=>MinkowskiDirectedEdge::VertEdge(*v0,e1.as_directed(parity)),
+			MinkowskiEdge::EdgeVert(e0,v1)=>MinkowskiDirectedEdge::EdgeVert(e0.as_directed(parity),*v1),
+		}
+	}
+}
+#[derive(Clone,Copy)]
+pub enum MinkowskiDirectedEdge{
+	VertEdge(VertId,DirectedEdgeId),
+	EdgeVert(DirectedEdgeId,VertId),
+	//EdgeEdge when edges are parallel
+}
+impl DirectedEdge for MinkowskiDirectedEdge{
+	type UndirectedEdge=MinkowskiEdge;
+	fn as_undirected(&self)->Self::UndirectedEdge{
+		match self{
+			MinkowskiDirectedEdge::VertEdge(v0,e1)=>MinkowskiEdge::VertEdge(*v0,e1.as_undirected()),
+			MinkowskiDirectedEdge::EdgeVert(e0,v1)=>MinkowskiEdge::EdgeVert(e0.as_undirected(),*v1),
+		}
+	}
+	fn parity(&self)->bool{
+		match self{
+			MinkowskiDirectedEdge::VertEdge(_,e)
+			|MinkowskiDirectedEdge::EdgeVert(e,_)=>e.parity(),
+		}
+	}
+}
+#[derive(Debug,Clone,Copy,Hash,Eq,PartialEq)]
+pub enum MinkowskiFace{
+	VertFace(VertId,FaceId),
+	EdgeEdge(EdgeId,EdgeId,bool),
+	FaceVert(FaceId,VertId),
+	//EdgeFace
+	//FaceEdge
+	//FaceFace
+}
+
+pub struct MinkowskiMesh<'a>{
+	mesh0:&'a TransformedMesh<'a>,
+	mesh1:&'a TransformedMesh<'a>,
+}
+
+//infinity fev algorithm state transition
+enum Transition{
+	Done,//found closest vert, no edges are better
+	Vert(MinkowskiVert),//transition to vert
+}
+enum EV{
+	Vert(MinkowskiVert),
+	Edge(MinkowskiEdge),
+}
+
+impl MinkowskiMesh<'_>{
+	pub fn minkowski_sum<'a>(mesh0:&'a TransformedMesh,mesh1:&'a TransformedMesh)->MinkowskiMesh<'a>{
+		MinkowskiMesh{
+			mesh0,
+			mesh1,
+		}
+	}
+	fn farthest_vert(&self,dir:Planar64Vec3)->MinkowskiVert{
+		MinkowskiVert::VertVert(self.mesh0.farthest_vert(dir),self.mesh1.farthest_vert(-dir))
+	}
+	fn next_transition_vert(&self,vert_id:MinkowskiVert,best_distance_squared:&mut Planar64,infinity_dir:Planar64Vec3,point:Planar64Vec3)->Transition{
+		let mut best_transition=Transition::Done;
+		for &directed_edge_id in self.vert_edges(vert_id).iter(){
+			let edge_n=self.directed_edge_n(directed_edge_id);
+			//is boundary uncrossable by a crawl from infinity
+			let edge_verts=self.edge_verts(directed_edge_id.as_undirected());
+			//select opposite vertex
+			let test_vert_id=edge_verts[directed_edge_id.parity() as usize];
+			//test if it's closer
+			let diff=point-self.vert(test_vert_id);
+			if zeroes::zeroes1(edge_n.dot(diff),edge_n.dot(infinity_dir)).len()==0{
+				let distance_squared=diff.dot(diff);
+				if distance_squared<*best_distance_squared{
+					best_transition=Transition::Vert(test_vert_id);
+					*best_distance_squared=distance_squared;
+				}
+			}
+		}
+		best_transition
+	}
+	fn final_ev(&self,vert_id:MinkowskiVert,best_distance_squared:&mut Planar64,infinity_dir:Planar64Vec3,point:Planar64Vec3)->EV{
+		let mut best_transition=EV::Vert(vert_id);
+		let diff=point-self.vert(vert_id);
+		for &directed_edge_id in self.vert_edges(vert_id).iter(){
+			let edge_n=self.directed_edge_n(directed_edge_id);
+			//is boundary uncrossable by a crawl from infinity
+			//check if time of collision is outside Time::MIN..Time::MAX
+			let d=edge_n.dot(diff);
+			if zeroes::zeroes1(d,edge_n.dot(infinity_dir)).len()==0{
+				//test the edge
+				let edge_nn=edge_n.dot(edge_n);
+				if Planar64::ZERO<=d&&d<=edge_nn{
+					let distance_squared={
+						let c=diff.cross(edge_n);
+						c.dot(c)/edge_nn
+					};
+					if distance_squared<=*best_distance_squared{
+						best_transition=EV::Edge(directed_edge_id.as_undirected());
+						*best_distance_squared=distance_squared;
+					}
+				}
+			}
+		}
+		best_transition
+	}
+	fn crawl_boundaries(&self,mut vert_id:MinkowskiVert,infinity_dir:Planar64Vec3,point:Planar64Vec3)->EV{
+		let mut best_distance_squared={
+			let diff=point-self.vert(vert_id);
+			diff.dot(diff)
+		};
+		loop{
+			match self.next_transition_vert(vert_id,&mut best_distance_squared,infinity_dir,point){
+				Transition::Done=>return self.final_ev(vert_id,&mut best_distance_squared,infinity_dir,point),
+				Transition::Vert(new_vert_id)=>vert_id=new_vert_id,
+			}
+		}
+	}
+	/// This function drops a vertex down to an edge or a face if the path from infinity did not cross any vertex-edge boundaries but the point is supposed to have already crossed a boundary down from a vertex
+	fn infinity_fev(&self,infinity_dir:Planar64Vec3,point:Planar64Vec3)->FEV::<MinkowskiFace,MinkowskiDirectedEdge,MinkowskiVert>{
+		//start on any vertex
+		//cross uncrossable vertex-edge boundaries until you find the closest vertex or edge
+		//cross edge-face boundary if it's uncrossable
+		match self.crawl_boundaries(self.farthest_vert(infinity_dir),infinity_dir,point){
+			//if a vert is returned, it is the closest point to the infinity point
+			EV::Vert(vert_id)=>FEV::<MinkowskiFace,MinkowskiDirectedEdge,MinkowskiVert>::Vert(vert_id),
+			EV::Edge(edge_id)=>{
+				//cross to face if the boundary is not crossable and we are on the wrong side
+				let edge_n=self.edge_n(edge_id);
+				// point is multiplied by two because vert_sum sums two vertices.
+				let delta_pos=point*2-{
+					let &[v0,v1]=self.edge_verts(edge_id).borrow();
+					self.vert(v0)+self.vert(v1)
+				};
+				for (i,&face_id) in self.edge_faces(edge_id).iter().enumerate(){
+					let face_n=self.face_nd(face_id).0;
+					//edge-face boundary nd, n facing out of the face towards the edge
+					let boundary_n=face_n.cross(edge_n)*(i as i64*2-1);
+					let boundary_d=boundary_n.dot(delta_pos);
+					//check if time of collision is outside Time::MIN..Time::MAX
+					//infinity_dir can always be treated as a velocity
+					if (boundary_d)<=Planar64::ZERO&&zeroes::zeroes1(boundary_d,boundary_n.dot(infinity_dir)*2).len()==0{
+						//both faces cannot pass this condition, return early if one does.
+						return FEV::<MinkowskiFace,MinkowskiDirectedEdge,MinkowskiVert>::Face(face_id);
+					}
+				}
+				FEV::<MinkowskiFace,MinkowskiDirectedEdge,MinkowskiVert>::Edge(edge_id)
+			},
+		}
+	}
+	fn closest_fev_not_inside(&self,mut infinity_body:crate::physics::Body)->Option<FEV::<MinkowskiFace,MinkowskiDirectedEdge,MinkowskiVert>>{
+		infinity_body.infinity_dir().map_or(None,|dir|{
+			let infinity_fev=self.infinity_fev(-dir,infinity_body.position);
+			//a line is simpler to solve than a parabola
+			infinity_body.velocity=dir;
+			infinity_body.acceleration=Planar64Vec3::ZERO;
+			//crawl in from negative infinity along a tangent line to get the closest fev
+			match crate::face_crawler::crawl_fev(infinity_fev,self,&infinity_body,integer::Time::MIN,infinity_body.time){
+				crate::face_crawler::CrawlResult::Miss(fev)=>Some(fev),
+				crate::face_crawler::CrawlResult::Hit(_,_)=>None,
+			}
+		})
+	}
+	pub fn predict_collision_in(&self,relative_body:&crate::physics::Body,time_limit:integer::Time)->Option<(MinkowskiFace,integer::Time)>{
+		self.closest_fev_not_inside(relative_body.clone()).map_or(None,|fev|{
+			//continue forwards along the body parabola
+			match crate::face_crawler::crawl_fev(fev,self,relative_body,relative_body.time,time_limit){
+				crate::face_crawler::CrawlResult::Miss(_)=>None,
+				crate::face_crawler::CrawlResult::Hit(face,time)=>Some((face,time)),
+			}
+		})
+	}
+	pub fn predict_collision_out(&self,relative_body:&crate::physics::Body,time_limit:integer::Time)->Option<(MinkowskiFace,integer::Time)>{
+		//create an extrapolated body at time_limit
+		let infinity_body=crate::physics::Body::new(
+			relative_body.extrapolated_position(time_limit),
+			-relative_body.extrapolated_velocity(time_limit),
+			relative_body.acceleration,
+			-time_limit,
+		);
+		self.closest_fev_not_inside(infinity_body).map_or(None,|fev|{
+			//continue backwards along the body parabola
+			match crate::face_crawler::crawl_fev(fev,self,&-relative_body.clone(),-time_limit,-relative_body.time){
+				crate::face_crawler::CrawlResult::Miss(_)=>None,
+				crate::face_crawler::CrawlResult::Hit(face,time)=>Some((face,-time)),//no need to test -time<time_limit because of the first step
+			}
+		})
+	}
+	pub fn predict_collision_face_out(&self,relative_body:&crate::physics::Body,time_limit:integer::Time,contact_face_id:MinkowskiFace)->Option<(MinkowskiEdge,integer::Time)>{
+		//no algorithm needed, there is only one state and two cases (Edge,None)
+		//determine when it passes an edge ("sliding off" case)
+		let mut best_time=time_limit;
+		let mut best_edge=None;
+		let face_n=self.face_nd(contact_face_id).0;
+		for &directed_edge_id in self.face_edges(contact_face_id).iter(){
+			let edge_n=self.directed_edge_n(directed_edge_id);
+			//f x e points in
+			let n=face_n.cross(edge_n);
+			let verts=self.edge_verts(directed_edge_id.as_undirected());
+			let d=n.dot(self.vert(verts[0])+self.vert(verts[1]));
+			//WARNING! d outside of *2
+			for t in zeroes::zeroes2((n.dot(relative_body.position))*2-d,n.dot(relative_body.velocity)*2,n.dot(relative_body.acceleration)){
+				let t=relative_body.time+integer::Time::from(t);
+				if relative_body.time<t&&t<best_time&&n.dot(relative_body.extrapolated_velocity(t))<Planar64::ZERO{
+					best_time=t;
+					best_edge=Some(directed_edge_id);
+					break;
+				}
+			}
+		}
+		best_edge.map(|e|(e.as_undirected(),best_time))
+	}
+}
+impl MeshQuery<MinkowskiFace,MinkowskiDirectedEdge,MinkowskiVert> for MinkowskiMesh<'_>{
+	fn face_nd(&self,face_id:MinkowskiFace)->(Planar64Vec3,Planar64){
+		match face_id{
+			MinkowskiFace::VertFace(v0,f1)=>{
+				let (n,d)=self.mesh1.face_nd(f1);
+				(-n,d-n.dot(self.mesh0.vert(v0)))
+			},
+			MinkowskiFace::EdgeEdge(e0,e1,parity)=>{
+				let edge0_n=self.mesh0.edge_n(e0);
+				let edge1_n=self.mesh1.edge_n(e1);
+				let &[e0v0,e0v1]=self.mesh0.edge_verts(e0).borrow();
+				let &[e1v0,e1v1]=self.mesh1.edge_verts(e1).borrow();
+				let n=edge0_n.cross(edge1_n);
+				let e0d=n.dot(self.mesh0.vert(e0v0)+self.mesh0.vert(e0v1));
+				let e1d=n.dot(self.mesh1.vert(e1v0)+self.mesh1.vert(e1v1));
+				(n*(parity as i64*4-2),(e0d-e1d)*(parity as i64*2-1))
+			},
+			MinkowskiFace::FaceVert(f0,v1)=>{
+				let (n,d)=self.mesh0.face_nd(f0);
+				(n,d-n.dot(self.mesh1.vert(v1)))
+			},
+		}
+	}
+	fn vert(&self,vert_id:MinkowskiVert)->Planar64Vec3{
+		match vert_id{
+			MinkowskiVert::VertVert(v0,v1)=>{
+				self.mesh0.vert(v0)-self.mesh1.vert(v1)
+			},
+		}
+	}
+	fn face_edges(&self,face_id:MinkowskiFace)->Cow<Vec<MinkowskiDirectedEdge>>{
+		match face_id{
+			MinkowskiFace::VertFace(v0,f1)=>{
+				Cow::Owned(self.mesh1.face_edges(f1).iter().map(|&edge_id1|{
+					MinkowskiDirectedEdge::VertEdge(v0,edge_id1.reverse())
+				}).collect())
+			},
+			MinkowskiFace::EdgeEdge(e0,e1,parity)=>{
+				let e0v=self.mesh0.edge_verts(e0);
+				let e1v=self.mesh1.edge_verts(e1);
+				//could sort this if ordered edges are needed
+				//probably just need to reverse this list according to parity
+				Cow::Owned(vec![
+					MinkowskiDirectedEdge::VertEdge(e0v[0],e1.as_directed(parity)),
+					MinkowskiDirectedEdge::EdgeVert(e0.as_directed(!parity),e1v[0]),
+					MinkowskiDirectedEdge::VertEdge(e0v[1],e1.as_directed(!parity)),
+					MinkowskiDirectedEdge::EdgeVert(e0.as_directed(parity),e1v[1]),
+				])
+			},
+			MinkowskiFace::FaceVert(f0,v1)=>{
+				Cow::Owned(self.mesh0.face_edges(f0).iter().map(|&edge_id0|{
+					MinkowskiDirectedEdge::EdgeVert(edge_id0,v1)
+				}).collect())
+			},
+		}
+	}
+	fn edge_faces(&self,edge_id:MinkowskiEdge)->Cow<[MinkowskiFace;2]>{
+		match edge_id{
+			MinkowskiEdge::VertEdge(v0,e1)=>{
+				//faces are listed backwards from the minkowski mesh
+				let v0e=self.mesh0.vert_edges(v0);
+				let &[e1f0,e1f1]=self.mesh1.edge_faces(e1).borrow();
+				Cow::Owned([(e1f1,false),(e1f0,true)].map(|(edge_face_id1,face_parity)|{
+					let mut best_edge=None;
+					let mut best_d=Planar64::ZERO;
+					let edge_face1_n=self.mesh1.face_nd(edge_face_id1).0;
+					let edge_face1_nn=edge_face1_n.dot(edge_face1_n);
+					for &directed_edge_id0 in v0e.iter(){
+						let edge0_n=self.mesh0.directed_edge_n(directed_edge_id0);
+						//must be behind other face.
+						let d=edge_face1_n.dot(edge0_n);
+						if d<Planar64::ZERO{
+							let edge0_nn=edge0_n.dot(edge0_n);
+							//divide by zero???
+							let dd=d*d/(edge_face1_nn*edge0_nn);
+							if best_d<dd{
+								best_d=dd;
+								best_edge=Some(directed_edge_id0);
+							}
+						}
+					}
+					best_edge.map_or(
+						MinkowskiFace::VertFace(v0,edge_face_id1),
+						|directed_edge_id0|MinkowskiFace::EdgeEdge(directed_edge_id0.as_undirected(),e1,directed_edge_id0.parity()^face_parity)
+					)
+				}))
+			},
+			MinkowskiEdge::EdgeVert(e0,v1)=>{
+				//tracking index with an external variable because .enumerate() is not available
+				let v1e=self.mesh1.vert_edges(v1);
+				let &[e0f0,e0f1]=self.mesh0.edge_faces(e0).borrow();
+				Cow::Owned([(e0f0,true),(e0f1,false)].map(|(edge_face_id0,face_parity)|{
+					let mut best_edge=None;
+					let mut best_d=Planar64::ZERO;
+					let edge_face0_n=self.mesh0.face_nd(edge_face_id0).0;
+					let edge_face0_nn=edge_face0_n.dot(edge_face0_n);
+					for &directed_edge_id1 in v1e.iter(){
+						let edge1_n=self.mesh1.directed_edge_n(directed_edge_id1);
+						let d=edge_face0_n.dot(edge1_n);
+						if d<Planar64::ZERO{
+							let edge1_nn=edge1_n.dot(edge1_n);
+							let dd=d*d/(edge_face0_nn*edge1_nn);
+							if best_d<dd{
+								best_d=dd;
+								best_edge=Some(directed_edge_id1);
+							}
+						}
+					}
+					best_edge.map_or(
+						MinkowskiFace::FaceVert(edge_face_id0,v1),
+						|directed_edge_id1|MinkowskiFace::EdgeEdge(e0,directed_edge_id1.as_undirected(),directed_edge_id1.parity()^face_parity)
+					)
+				}))
+			},
+		}
+	}
+	fn edge_verts(&self,edge_id:MinkowskiEdge)->Cow<[MinkowskiVert;2]>{
+		match edge_id{
+			MinkowskiEdge::VertEdge(v0,e1)=>{
+				Cow::Owned(self.mesh1.edge_verts(e1).map(|vert_id1|{
+					MinkowskiVert::VertVert(v0,vert_id1)
+				}))
+			},
+			MinkowskiEdge::EdgeVert(e0,v1)=>{
+				Cow::Owned(self.mesh0.edge_verts(e0).map(|vert_id0|{
+					MinkowskiVert::VertVert(vert_id0,v1)
+				}))
+			},
+		}
+	}
+	fn vert_edges(&self,vert_id:MinkowskiVert)->Cow<Vec<MinkowskiDirectedEdge>>{
+		match vert_id{
+			MinkowskiVert::VertVert(v0,v1)=>{
+				let mut edges=Vec::new();
+				//detect shared volume when the other mesh is mirrored along a test edge dir
+				let v0f=self.mesh0.vert_faces(v0);
+				let v1f=self.mesh1.vert_faces(v1);
+				let v0f_n:Vec<Planar64Vec3>=v0f.iter().map(|&face_id|self.mesh0.face_nd(face_id).0).collect();
+				let v1f_n:Vec<Planar64Vec3>=v1f.iter().map(|&face_id|self.mesh1.face_nd(face_id).0).collect();
+				let the_len=v0f.len()+v1f.len();
+				for &directed_edge_id in self.mesh0.vert_edges(v0).iter(){
+					let n=self.mesh0.directed_edge_n(directed_edge_id);
+					let nn=n.dot(n);
+					//make a set of faces
+					let mut face_normals=Vec::with_capacity(the_len);
+					//add mesh0 faces as-is
+					face_normals.clone_from(&v0f_n);
+					for face_n in &v1f_n{
+						//add reflected mesh1 faces
+						face_normals.push(*face_n-n*(face_n.dot(n)*2/nn));
+					}
+					if is_empty_volume(face_normals){
+						edges.push(MinkowskiDirectedEdge::EdgeVert(directed_edge_id,v1));
+					}
+				}
+				for &directed_edge_id in self.mesh1.vert_edges(v1).iter(){
+					let n=self.mesh1.directed_edge_n(directed_edge_id);
+					let nn=n.dot(n);
+					let mut face_normals=Vec::with_capacity(the_len);
+					face_normals.clone_from(&v1f_n);
+					for face_n in &v0f_n{
+						face_normals.push(*face_n-n*(face_n.dot(n)*2/nn));
+					}
+					if is_empty_volume(face_normals){
+						edges.push(MinkowskiDirectedEdge::VertEdge(v0,directed_edge_id));
+					}
+				}
+				Cow::Owned(edges)
+			},
+		}
+	}
+	fn vert_faces(&self,_vert_id:MinkowskiVert)->Cow<Vec<MinkowskiFace>>{
+		unimplemented!()
+	}
+}
+
+fn is_empty_volume(normals:Vec<Planar64Vec3>)->bool{
+	let len=normals.len();
+	for i in 0..len-1{
+		for j in i+1..len{
+			let n=normals[i].cross(normals[j]);
+			let mut d_comp=None;
+			for k in 0..len{
+				if k!=i&&k!=j{
+					let d=n.dot(normals[k]);
+					if let Some(comp)=&d_comp{
+						if *comp*d<Planar64::ZERO{
+							return true;
+						}
+					}else{
+						d_comp=Some(d);
+					}
+				}
+			}
+		}
+	}
+	return false;
+}
+
+#[test]
+fn test_is_empty_volume(){
+	assert!(!is_empty_volume([Planar64Vec3::X,Planar64Vec3::Y,Planar64Vec3::Z].to_vec()));
+	assert!(is_empty_volume([Planar64Vec3::X,Planar64Vec3::Y,Planar64Vec3::Z,Planar64Vec3::NEG_X].to_vec()));
+}
+
+#[test]
+fn build_me_a_cube(){
+	let unit_cube=crate::primitives::unit_cube();
+	let mesh=PhysicsMesh::from(&unit_cube);
+	//println!("mesh={:?}",mesh);
+}

src/physics_worker.rs

@@ -0,0 +1,165 @@
+use crate::physics::{MouseState,PhysicsInputInstruction};
+use strafesnet_common::integer::Time;
+use strafesnet_common::instruction::{TimedInstruction,InstructionConsumer};
+use strafesnet_common::integer::{self,Planar64,Planar64Vec3,Planar64Mat3,Angle32,Ratio64,Ratio64Vec2};
+
+#[derive(Debug)]
+pub enum InputInstruction {
+	MoveMouse(glam::IVec2),
+	MoveRight(bool),
+	MoveUp(bool),
+	MoveBack(bool),
+	MoveLeft(bool),
+	MoveDown(bool),
+	MoveForward(bool),
+	Jump(bool),
+	Zoom(bool),
+	Reset,
+}
+pub enum Instruction{
+	Input(InputInstruction),
+	Render,
+	Resize(winit::dpi::PhysicalSize<u32>,crate::settings::UserSettings),
+	GenerateModels(crate::model::IndexedModelInstances),
+	ClearModels,
+	//Graphics(crate::graphics_worker::Instruction),
+}
+
+pub struct Speed{
+	pub player_vel:Planar64Vec3,
+	pub time:Time
+}
+
+impl std::ops::Neg for Speed{
+	type Output=Self;
+	fn neg(self)->Self::Output{
+		Self{
+			player_vel:self.player_vel,
+			time:self.time
+		}
+	}
+}
+
+impl  Speed{
+	pub fn new(player_vel:Planar64Vec3,time:Time)->Self{
+		Self{
+			player_vel,
+			time,
+		}
+	}
+}
+	pub fn new(mut physics:crate::physics::PhysicsState,mut graphics_worker:crate::compat_worker::INWorker<crate::graphics_worker::Instruction>)->crate::compat_worker::QNWorker<TimedInstruction<Instruction>>{
+		let mut mouse_blocking=true;
+		let mut last_mouse_time=physics.next_mouse.time;
+		let mut timeline=std::collections::VecDeque::new();
+		let mut next_velocity_print=std::time::Instant::now();
+		let mut player_vel = physics.body.velocity.length();
+		crate::compat_worker::QNWorker::new(move |ins:TimedInstruction<Instruction>|{
+			if if let Some(phys_input)=match &ins.instruction{
+				Instruction::Input(input_instruction)=>match input_instruction{
+					&InputInstruction::MoveMouse(m)=>{
+						if mouse_blocking{
+							//tell the game state which is living in the past about its future
+							timeline.push_front(TimedInstruction{
+								time:last_mouse_time,
+								instruction:PhysicsInputInstruction::SetNextMouse(MouseState{time:ins.time,pos:m}),
+							});
+						}else{
+							//mouse has just started moving again after being still for longer than 10ms.
+							//replace the entire mouse interpolation state to avoid an intermediate state with identical m0.t m1.t timestamps which will divide by zero
+							timeline.push_front(TimedInstruction{
+								time:last_mouse_time,
+								instruction:PhysicsInputInstruction::ReplaceMouse(
+									MouseState{time:last_mouse_time,pos:physics.next_mouse.pos},
+									MouseState{time:ins.time,pos:m}
+								),
+							});
+							//delay physics execution until we have an interpolation target
+							mouse_blocking=true;
+						}
+						last_mouse_time=ins.time;
+						None
+					},
+					&InputInstruction::MoveForward(s)=>Some(PhysicsInputInstruction::SetMoveForward(s)),
+					&InputInstruction::MoveLeft(s)=>Some(PhysicsInputInstruction::SetMoveLeft(s)),
+					&InputInstruction::MoveBack(s)=>Some(PhysicsInputInstruction::SetMoveBack(s)),
+					&InputInstruction::MoveRight(s)=>Some(PhysicsInputInstruction::SetMoveRight(s)),
+					&InputInstruction::MoveUp(s)=>Some(PhysicsInputInstruction::SetMoveUp(s)),
+					&InputInstruction::MoveDown(s)=>Some(PhysicsInputInstruction::SetMoveDown(s)),
+					&InputInstruction::Jump(s)=>Some(PhysicsInputInstruction::SetJump(s)),
+					&InputInstruction::Zoom(s)=>Some(PhysicsInputInstruction::SetZoom(s)),
+					InputInstruction::Reset=>Some(PhysicsInputInstruction::Reset),
+				},
+				Instruction::GenerateModels(_)=>Some(PhysicsInputInstruction::Idle),
+				Instruction::ClearModels=>Some(PhysicsInputInstruction::Idle),
+				Instruction::Resize(_,_)=>Some(PhysicsInputInstruction::Idle),
+				Instruction::Render=>Some(PhysicsInputInstruction::Idle),
+			}{
+				//non-mouse event
+				timeline.push_back(TimedInstruction{
+					time:ins.time,
+					instruction:phys_input,
+				});
+				
+				if mouse_blocking{
+					//assume the mouse has stopped moving after 10ms.
+					//shitty mice are 125Hz which is 8ms so this should cover that.
+					//setting this to 100us still doesn't print even though it's 10x lower than the polling rate,
+					//so mouse events are probably not handled separately from drawing and fire right before it :(
+					if Time::from_millis(10)<ins.time-physics.next_mouse.time{
+						//push an event to extrapolate no movement from
+						timeline.push_front(TimedInstruction{
+							time:last_mouse_time,
+							instruction:PhysicsInputInstruction::SetNextMouse(MouseState{time:ins.time,pos:physics.next_mouse.pos}),
+						});
+						last_mouse_time=ins.time;
+						//stop blocking. the mouse is not moving so the physics does not need to live in the past and wait for interpolation targets.
+						mouse_blocking=false;
+						true
+					}else{
+						false
+					}
+				}else{
+					//keep this up to date so that it can be used as a known-timestamp
+					//that the mouse was not moving when the mouse starts moving again
+					last_mouse_time=ins.time;
+					true
+				}
+			}else{
+				//mouse event
+				true
+			}{
+				//empty queue
+				while let Some(instruction)=timeline.pop_front(){
+					physics.run(instruction.time);
+					physics.process_instruction(TimedInstruction{
+						time:instruction.time,
+						instruction:crate::physics::PhysicsInstruction::Input(instruction.instruction),
+					});
+				}
+				//some random print stuff
+				if 3.0/5.0<next_velocity_print.elapsed().as_secs_f64(){
+					next_velocity_print=next_velocity_print+std::time::Duration::from_secs_f64(1.0/30.0);
+					println!("velocity: {} u/s", (Planar64Vec3::new(physics.body.velocity.x(), Planar64::int(0), physics.body.velocity.z())).length()*(Planar64::int(130)/9));
+				}
+			}
+			match ins.instruction{
+				Instruction::Render=>{
+					graphics_worker.send(crate::graphics_worker::Instruction::Render(physics.output(),ins.time,physics.next_mouse.pos)).unwrap();
+				},
+				Instruction::Resize(size,user_settings)=>{
+					graphics_worker.send(crate::graphics_worker::Instruction::Resize(size,user_settings)).unwrap();
+				},
+				Instruction::GenerateModels(indexed_model_instances)=>{
+					physics.generate_models(&indexed_model_instances);
+					physics.spawn(indexed_model_instances.spawn_point);
+					graphics_worker.send(crate::graphics_worker::Instruction::GenerateModels(indexed_model_instances)).unwrap();
+				},
+				Instruction::ClearModels=>{
+					physics.clear();
+					graphics_worker.send(crate::graphics_worker::Instruction::ClearModels).unwrap();
+				},
+				_=>(),
+			}
+		})
+	}

src/primitives.rs

@@ -0,0 +1,493 @@
+use crate::model::{Color4,TextureCoordinate,IndexedModel,IndexedPolygon,IndexedGroup,IndexedVertex};
+use strafesnet_common::integer::Planar64Vec3;
+
+#[derive(Debug)]
+pub enum Primitives{
+	Sphere,
+	Cube,
+	Cylinder,
+	Wedge,
+	CornerWedge,
+}
+#[derive(Hash,PartialEq,Eq)]
+pub enum CubeFace{
+	Right,
+	Top,
+	Back,
+	Left,
+	Bottom,
+	Front,
+}
+const CUBE_DEFAULT_TEXTURE_COORDS:[TextureCoordinate;4]=[
+	TextureCoordinate::new(0.0,0.0),
+	TextureCoordinate::new(1.0,0.0),
+	TextureCoordinate::new(1.0,1.0),
+	TextureCoordinate::new(0.0,1.0),
+];
+const CUBE_DEFAULT_VERTICES:[Planar64Vec3;8]=[
+	Planar64Vec3::int(-1,-1, 1),//0 left bottom back
+	Planar64Vec3::int( 1,-1, 1),//1 right bottom back
+	Planar64Vec3::int( 1, 1, 1),//2 right top back
+	Planar64Vec3::int(-1, 1, 1),//3 left top back
+	Planar64Vec3::int(-1, 1,-1),//4 left top front
+	Planar64Vec3::int( 1, 1,-1),//5 right top front
+	Planar64Vec3::int( 1,-1,-1),//6 right bottom front
+	Planar64Vec3::int(-1,-1,-1),//7 left bottom front
+];
+const CUBE_DEFAULT_NORMALS:[Planar64Vec3;6]=[
+	Planar64Vec3::int( 1, 0, 0),//CubeFace::Right
+	Planar64Vec3::int( 0, 1, 0),//CubeFace::Top
+	Planar64Vec3::int( 0, 0, 1),//CubeFace::Back
+	Planar64Vec3::int(-1, 0, 0),//CubeFace::Left
+	Planar64Vec3::int( 0,-1, 0),//CubeFace::Bottom
+	Planar64Vec3::int( 0, 0,-1),//CubeFace::Front
+];
+const CUBE_DEFAULT_POLYS:[[[u32;3];4];6]=[
+	// right (1, 0, 0)
+	[
+		[6,2,0],//[vertex,tex,norm]
+		[5,1,0],
+		[2,0,0],
+		[1,3,0],
+	],
+	// top (0, 1, 0)
+	[
+		[5,3,1],
+		[4,2,1],
+		[3,1,1],
+		[2,0,1],
+	],
+	// back (0, 0, 1)
+	[
+		[0,3,2],
+		[1,2,2],
+		[2,1,2],
+		[3,0,2],
+	],
+	// left (-1, 0, 0)
+	[
+		[0,2,3],
+		[3,1,3],
+		[4,0,3],
+		[7,3,3],
+	],
+	// bottom (0,-1, 0)
+	[
+		[1,1,4],
+		[0,0,4],
+		[7,3,4],
+		[6,2,4],
+	],
+	// front (0, 0,-1)
+	[
+		[4,1,5],
+		[5,0,5],
+		[6,3,5],
+		[7,2,5],
+	],
+];
+
+#[derive(Hash,PartialEq,Eq)]
+pub enum WedgeFace{
+	Right,
+	TopFront,
+	Back,
+	Left,
+	Bottom,
+}
+const WEDGE_DEFAULT_NORMALS:[Planar64Vec3;5]=[
+	Planar64Vec3::int( 1, 0, 0),//Wedge::Right
+	Planar64Vec3::int( 0, 1,-1),//Wedge::TopFront
+	Planar64Vec3::int( 0, 0, 1),//Wedge::Back
+	Planar64Vec3::int(-1, 0, 0),//Wedge::Left
+	Planar64Vec3::int( 0,-1, 0),//Wedge::Bottom
+];
+/*
+local cornerWedgeVerticies = {
+	Vector3.new(-1/2,-1/2,-1/2),7
+	Vector3.new(-1/2,-1/2, 1/2),0
+	Vector3.new( 1/2,-1/2,-1/2),6
+	Vector3.new( 1/2,-1/2, 1/2),1
+	Vector3.new( 1/2, 1/2,-1/2),5
+}
+*/
+#[derive(Hash,PartialEq,Eq)]
+pub enum CornerWedgeFace{
+	Right,
+	TopBack,
+	TopLeft,
+	Bottom,
+	Front,
+}
+const CORNERWEDGE_DEFAULT_NORMALS:[Planar64Vec3;5]=[
+	Planar64Vec3::int( 1, 0, 0),//CornerWedge::Right
+	Planar64Vec3::int( 0, 1, 1),//CornerWedge::BackTop
+	Planar64Vec3::int(-1, 1, 0),//CornerWedge::LeftTop
+	Planar64Vec3::int( 0,-1, 0),//CornerWedge::Bottom
+	Planar64Vec3::int( 0, 0,-1),//CornerWedge::Front
+];
+pub fn unit_sphere()->crate::model::IndexedModel{
+	unit_cube()
+}
+#[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::default();
+	t.insert(CubeFace::Right,FaceDescription::default());
+	t.insert(CubeFace::Top,FaceDescription::default());
+	t.insert(CubeFace::Back,FaceDescription::default());
+	t.insert(CubeFace::Left,FaceDescription::default());
+	t.insert(CubeFace::Bottom,FaceDescription::default());
+	t.insert(CubeFace::Front,FaceDescription::default());
+	generate_partial_unit_cube(t)
+}
+pub fn unit_cylinder()->crate::model::IndexedModel{
+	unit_cube()
+}
+#[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::default();
+	t.insert(WedgeFace::Right,FaceDescription::default());
+	t.insert(WedgeFace::TopFront,FaceDescription::default());
+	t.insert(WedgeFace::Back,FaceDescription::default());
+	t.insert(WedgeFace::Left,FaceDescription::default());
+	t.insert(WedgeFace::Bottom,FaceDescription::default());
+	generate_partial_unit_wedge(t)
+}
+#[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::default();
+	t.insert(CornerWedgeFace::Right,FaceDescription::default());
+	t.insert(CornerWedgeFace::TopBack,FaceDescription::default());
+	t.insert(CornerWedgeFace::TopLeft,FaceDescription::default());
+	t.insert(CornerWedgeFace::Bottom,FaceDescription::default());
+	t.insert(CornerWedgeFace::Front,FaceDescription::default());
+	generate_partial_unit_cornerwedge(t)
+}
+
+#[derive(Clone)]
+pub struct FaceDescription{
+	pub texture:Option<u32>,
+	pub transform:glam::Affine2,
+	pub color:Color4,
+}
+impl std::default::Default for FaceDescription{
+	fn default()->Self {
+		Self{
+			texture:None,
+			transform:glam::Affine2::IDENTITY,
+			color:Color4::new(1.0,1.0,1.0,0.0),//zero alpha to hide the default texture
+		}
+	}
+}
+//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{
+	let mut generated_pos=Vec::new();
+	let mut generated_tex=Vec::new();
+	let mut generated_normal=Vec::new();
+	let mut generated_color=Vec::new();
+	let mut generated_vertices=Vec::new();
+	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_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
+		}else{
+			//create new transform_index
+			let transform_index=transforms.len();
+			transforms.push(face_description.transform);
+			for tex in CUBE_DEFAULT_TEXTURE_COORDS{
+				generated_tex.push(face_description.transform.transform_point2(tex));
+			}
+			transform_index
+		} as u32;
+		let color_index=if let Some(color_index)=generated_color.iter().position(|&color|color==face_description.color){
+			color_index
+		}else{
+			//create new color_index
+			let color_index=generated_color.len();
+			generated_color.push(face_description.color);
+			color_index
+		} as u32;
+		//always push normal
+		let normal_index=generated_normal.len() as u32;
+		generated_normal.push(CUBE_DEFAULT_NORMALS[face_id]);
+		//push vertices as they are needed
+		groups.push(IndexedGroup{
+			texture:face_description.texture,
+			polys:vec![IndexedPolygon{
+				vertices:CUBE_DEFAULT_POLYS[face_id].map(|tup|{
+					let pos=CUBE_DEFAULT_VERTICES[tup[0] as usize];
+					let pos_index=if let Some(pos_index)=generated_pos.iter().position(|&p|p==pos){
+						pos_index
+					}else{
+						//create new pos_index
+						let pos_index=generated_pos.len();
+						generated_pos.push(pos);
+						pos_index
+					} as u32;
+					//always push vertex
+					let vertex=IndexedVertex{
+						pos:pos_index,
+						tex:tup[1]+4*transform_index,
+						normal:normal_index,
+						color:color_index,
+					};
+					let vert_index=generated_vertices.len();
+					generated_vertices.push(vertex);
+					vert_index as u32
+				}).to_vec(),
+			}],
+		});
+	}
+	IndexedModel{
+		unique_pos:generated_pos,
+		unique_tex:generated_tex,
+		unique_normal:generated_normal,
+		unique_color:generated_color,
+		unique_vertices:generated_vertices,
+		groups,
+		instances:Vec::new(),
+	}
+}
+//don't think too hard about the copy paste because this is all going into the map tool eventually...
+pub fn generate_partial_unit_wedge(face_descriptions:WedgeFaceDescription)->crate::model::IndexedModel{
+	let wedge_default_polys=vec![
+		// right (1, 0, 0)
+		vec![
+			[6,2,0],//[vertex,tex,norm]
+			[2,0,0],
+			[1,3,0],
+		],
+		// FrontTop (0, 1, -1)
+		vec![
+			[3,1,1],
+			[2,0,1],
+			[6,3,1],
+			[7,2,1],
+		],
+		// back (0, 0, 1)
+		vec![
+			[0,3,2],
+			[1,2,2],
+			[2,1,2],
+			[3,0,2],
+		],
+		// left (-1, 0, 0)
+		vec![
+			[0,2,3],
+			[3,1,3],
+			[7,3,3],
+		],
+		// bottom (0,-1, 0)
+		vec![
+			[1,1,4],
+			[0,0,4],
+			[7,3,4],
+			[6,2,4],
+		],
+	];
+	let mut generated_pos=Vec::new();
+	let mut generated_tex=Vec::new();
+	let mut generated_normal=Vec::new();
+	let mut generated_color=Vec::new();
+	let mut generated_vertices=Vec::new();
+	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_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
+		}else{
+			//create new transform_index
+			let transform_index=transforms.len();
+			transforms.push(face_description.transform);
+			for tex in CUBE_DEFAULT_TEXTURE_COORDS{
+				generated_tex.push(face_description.transform.transform_point2(tex));
+			}
+			transform_index
+		} as u32;
+		let color_index=if let Some(color_index)=generated_color.iter().position(|&color|color==face_description.color){
+			color_index
+		}else{
+			//create new color_index
+			let color_index=generated_color.len();
+			generated_color.push(face_description.color);
+			color_index
+		} as u32;
+		//always push normal
+		let normal_index=generated_normal.len() as u32;
+		generated_normal.push(WEDGE_DEFAULT_NORMALS[face_id]);
+		//push vertices as they are needed
+		groups.push(IndexedGroup{
+			texture:face_description.texture,
+			polys:vec![IndexedPolygon{
+				vertices:wedge_default_polys[face_id].iter().map(|tup|{
+					let pos=CUBE_DEFAULT_VERTICES[tup[0] as usize];
+					let pos_index=if let Some(pos_index)=generated_pos.iter().position(|&p|p==pos){
+						pos_index
+					}else{
+						//create new pos_index
+						let pos_index=generated_pos.len();
+						generated_pos.push(pos);
+						pos_index
+					} as u32;
+					//always push vertex
+					let vertex=IndexedVertex{
+						pos:pos_index,
+						tex:tup[1]+4*transform_index,
+						normal:normal_index,
+						color:color_index,
+					};
+					let vert_index=generated_vertices.len();
+					generated_vertices.push(vertex);
+					vert_index as u32
+				}).collect(),
+			}],
+		});
+	}
+	IndexedModel{
+		unique_pos:generated_pos,
+		unique_tex:generated_tex,
+		unique_normal:generated_normal,
+		unique_color:generated_color,
+		unique_vertices:generated_vertices,
+		groups,
+		instances:Vec::new(),
+	}
+}
+
+pub fn generate_partial_unit_cornerwedge(face_descriptions:CornerWedgeFaceDescription)->crate::model::IndexedModel{
+	let cornerwedge_default_polys=vec![
+		// right (1, 0, 0)
+		vec![
+			[6,2,0],//[vertex,tex,norm]
+			[5,1,0],
+			[1,3,0],
+		],
+		// BackTop (0, 1, 1)
+		vec![
+			[5,3,1],
+			[0,1,1],
+			[1,0,1],
+		],
+		// LeftTop (-1, 1, 0)
+		vec![
+			[5,3,2],
+			[7,2,2],
+			[0,1,2],
+		],
+		// bottom (0,-1, 0)
+		vec![
+			[1,1,3],
+			[0,0,3],
+			[7,3,3],
+			[6,2,3],
+		],
+		// front (0, 0,-1)
+		vec![
+			[5,0,4],
+			[6,3,4],
+			[7,2,4],
+		],
+	];
+	let mut generated_pos=Vec::new();
+	let mut generated_tex=Vec::new();
+	let mut generated_normal=Vec::new();
+	let mut generated_color=Vec::new();
+	let mut generated_vertices=Vec::new();
+	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_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
+		}else{
+			//create new transform_index
+			let transform_index=transforms.len();
+			transforms.push(face_description.transform);
+			for tex in CUBE_DEFAULT_TEXTURE_COORDS{
+				generated_tex.push(face_description.transform.transform_point2(tex));
+			}
+			transform_index
+		} as u32;
+		let color_index=if let Some(color_index)=generated_color.iter().position(|&color|color==face_description.color){
+			color_index
+		}else{
+			//create new color_index
+			let color_index=generated_color.len();
+			generated_color.push(face_description.color);
+			color_index
+		} as u32;
+		//always push normal
+		let normal_index=generated_normal.len() as u32;
+		generated_normal.push(CORNERWEDGE_DEFAULT_NORMALS[face_id]);
+		//push vertices as they are needed
+		groups.push(IndexedGroup{
+			texture:face_description.texture,
+			polys:vec![IndexedPolygon{
+				vertices:cornerwedge_default_polys[face_id].iter().map(|tup|{
+					let pos=CUBE_DEFAULT_VERTICES[tup[0] as usize];
+					let pos_index=if let Some(pos_index)=generated_pos.iter().position(|&p|p==pos){
+						pos_index
+					}else{
+						//create new pos_index
+						let pos_index=generated_pos.len();
+						generated_pos.push(pos);
+						pos_index
+					} as u32;
+					//always push vertex
+					let vertex=IndexedVertex{
+						pos:pos_index,
+						tex:tup[1]+4*transform_index,
+						normal:normal_index,
+						color:color_index,
+					};
+					let vert_index=generated_vertices.len();
+					generated_vertices.push(vertex);
+					vert_index as u32
+				}).collect(),
+			}],
+		});
+	}
+	IndexedModel{
+		unique_pos:generated_pos,
+		unique_tex:generated_tex,
+		unique_normal:generated_normal,
+		unique_color:generated_color,
+		unique_vertices:generated_vertices,
+		groups,
+		instances:Vec::new(),
+	}
+}

src/settings.rs

@@ -0,0 +1,139 @@
+use strafesnet_common::integer::{Ratio64,Ratio64Vec2};
+#[derive(Clone)]
+struct Ratio{
+	ratio:f64,
+}
+#[derive(Clone)]
+enum DerivedFov{
+	FromScreenAspect,
+	FromAspect(Ratio),
+}
+#[derive(Clone)]
+enum Fov{
+	Exactly{x:f64,y:f64},
+	SpecifyXDeriveY{x:f64,y:DerivedFov},
+	SpecifyYDeriveX{x:DerivedFov,y:f64},
+}
+impl Default for Fov{
+	fn default()->Self{
+		Fov::SpecifyYDeriveX{x:DerivedFov::FromScreenAspect,y:1.0}
+	}
+}
+#[derive(Clone)]
+enum DerivedSensitivity{
+	FromRatio(Ratio64),
+}
+#[derive(Clone)]
+enum Sensitivity{
+	Exactly{x:Ratio64,y:Ratio64},
+	SpecifyXDeriveY{x:Ratio64,y:DerivedSensitivity},
+	SpecifyYDeriveX{x:DerivedSensitivity,y:Ratio64},
+}
+impl Default for Sensitivity{
+	fn default()->Self{
+		Sensitivity::SpecifyXDeriveY{x:Ratio64::ONE*524288,y:DerivedSensitivity::FromRatio(Ratio64::ONE)}
+	}
+}
+
+#[derive(Default,Clone)]
+pub struct UserSettings{
+	fov:Fov,
+	sensitivity:Sensitivity,
+}
+impl UserSettings{
+	pub fn calculate_fov(&self,zoom:f64,screen_size:&glam::UVec2)->glam::DVec2{
+		zoom*match &self.fov{
+			&Fov::Exactly{x,y}=>glam::dvec2(x,y),
+			Fov::SpecifyXDeriveY{x,y}=>match y{
+				DerivedFov::FromScreenAspect=>glam::dvec2(*x,x*(screen_size.y as f64/screen_size.x as f64)),
+				DerivedFov::FromAspect(ratio)=>glam::dvec2(*x,x*ratio.ratio),
+			},
+			Fov::SpecifyYDeriveX{x,y}=>match x{
+				DerivedFov::FromScreenAspect=>glam::dvec2(y*(screen_size.x as f64/screen_size.y as f64),*y),
+				DerivedFov::FromAspect(ratio)=>glam::dvec2(y*ratio.ratio,*y),
+			},
+		}
+	}
+	pub fn calculate_sensitivity(&self)->Ratio64Vec2{
+		match &self.sensitivity{
+			Sensitivity::Exactly{x,y}=>Ratio64Vec2::new(x.clone(),y.clone()),
+			Sensitivity::SpecifyXDeriveY{x,y}=>match y{
+				DerivedSensitivity::FromRatio(ratio)=>Ratio64Vec2::new(x.clone(),x.mul_ref(ratio)),
+			}
+			Sensitivity::SpecifyYDeriveX{x,y}=>match x{
+				DerivedSensitivity::FromRatio(ratio)=>Ratio64Vec2::new(y.mul_ref(ratio),y.clone()),
+			}
+		}
+	}
+}
+
+/*
+//sensitivity is raw input dots (i.e. dpi = dots per inch) to radians conversion factor
+sensitivity_x=0.001
+sensitivity_y_from_x_ratio=1
+Sensitivity::DeriveY{x:0.0.001,y:DerivedSensitivity{ratio:1.0}}
+*/
+
+pub fn read_user_settings()->UserSettings{
+	let mut cfg=configparser::ini::Ini::new();
+	if let Ok(_)=cfg.load("settings.conf"){
+		let (cfg_fov_x,cfg_fov_y)=(cfg.getfloat("camera","fov_x"),cfg.getfloat("camera","fov_y"));
+		let fov=match(cfg_fov_x,cfg_fov_y){
+			(Ok(Some(fov_x)),Ok(Some(fov_y)))=>Fov::Exactly {
+				x:fov_x,
+				y:fov_y
+			},
+			(Ok(Some(fov_x)),Ok(None))=>Fov::SpecifyXDeriveY{
+				x:fov_x,
+				y:if let Ok(Some(fov_y_from_x_ratio))=cfg.getfloat("camera","fov_y_from_x_ratio"){
+					DerivedFov::FromAspect(Ratio{ratio:fov_y_from_x_ratio})
+				}else{
+					DerivedFov::FromScreenAspect
+				}
+			},
+			(Ok(None),Ok(Some(fov_y)))=>Fov::SpecifyYDeriveX{
+				x:if let Ok(Some(fov_x_from_y_ratio))=cfg.getfloat("camera","fov_x_from_y_ratio"){
+					DerivedFov::FromAspect(Ratio{ratio:fov_x_from_y_ratio})
+				}else{
+					DerivedFov::FromScreenAspect
+				},
+				y:fov_y,
+			},
+			_=>{
+				Fov::default()
+			},
+		};
+		let (cfg_sensitivity_x,cfg_sensitivity_y)=(cfg.getfloat("camera","sensitivity_x"),cfg.getfloat("camera","sensitivity_y"));
+		let sensitivity=match(cfg_sensitivity_x,cfg_sensitivity_y){
+			(Ok(Some(sensitivity_x)),Ok(Some(sensitivity_y)))=>Sensitivity::Exactly {
+				x:Ratio64::try_from(sensitivity_x).unwrap(),
+				y:Ratio64::try_from(sensitivity_y).unwrap(),
+			},
+			(Ok(Some(sensitivity_x)),Ok(None))=>Sensitivity::SpecifyXDeriveY{
+				x:Ratio64::try_from(sensitivity_x).unwrap(),
+				y:if let Ok(Some(sensitivity_y_from_x_ratio))=cfg.getfloat("camera","sensitivity_y_from_x_ratio"){
+					DerivedSensitivity::FromRatio(Ratio64::try_from(sensitivity_y_from_x_ratio).unwrap())
+				}else{
+					DerivedSensitivity::FromRatio(Ratio64::ONE)
+				},
+			},
+			(Ok(None),Ok(Some(sensitivity_y)))=>Sensitivity::SpecifyYDeriveX{
+				x:if let Ok(Some(sensitivity_x_from_y_ratio))=cfg.getfloat("camera","sensitivity_x_from_y_ratio"){
+					DerivedSensitivity::FromRatio(Ratio64::try_from(sensitivity_x_from_y_ratio).unwrap())
+				}else{
+					DerivedSensitivity::FromRatio(Ratio64::ONE)
+				},
+				y:Ratio64::try_from(sensitivity_y).unwrap(),
+			},
+			_=>{
+				Sensitivity::default()
+			},
+		};
+		UserSettings{
+			fov,
+			sensitivity,
+		}
+	}else{
+		UserSettings::default()
+	}
+}

src/setup.rs

@@ -0,0 +1,281 @@
+use crate::window::WindowInstruction;
+use strafesnet_common::instruction::TimedInstruction;
+use strafesnet_common::integer;
+
+fn optional_features()->wgpu::Features{
+	wgpu::Features::TEXTURE_COMPRESSION_ASTC
+	|wgpu::Features::TEXTURE_COMPRESSION_ETC2
+}
+fn required_features()->wgpu::Features{
+	wgpu::Features::TEXTURE_COMPRESSION_BC
+}
+fn required_downlevel_capabilities()->wgpu::DownlevelCapabilities{
+	wgpu::DownlevelCapabilities{
+		flags:wgpu::DownlevelFlags::empty(),
+		shader_model:wgpu::ShaderModel::Sm5,
+		..wgpu::DownlevelCapabilities::default()
+	}
+}
+pub fn required_limits()->wgpu::Limits{
+	wgpu::Limits::default()
+}
+
+struct SetupContextPartial1{
+	backends:wgpu::Backends,
+	instance:wgpu::Instance,
+}
+fn create_window(title:&str,event_loop:&winit::event_loop::EventLoop<()>)->Result<winit::window::Window,winit::error::OsError>{
+	let mut builder = winit::window::WindowBuilder::new();
+	builder = builder.with_title(title);
+	#[cfg(windows_OFF)] // TODO
+	{
+		use winit::platform::windows::WindowBuilderExtWindows;
+		builder = builder.with_no_redirection_bitmap(true);
+	}
+	builder.build(event_loop)
+}
+fn create_instance()->SetupContextPartial1{
+	let backends=wgpu::util::backend_bits_from_env().unwrap_or_else(wgpu::Backends::all);
+	let dx12_shader_compiler=wgpu::util::dx12_shader_compiler_from_env().unwrap_or_default();
+	SetupContextPartial1{
+		backends,
+		instance:wgpu::Instance::new(wgpu::InstanceDescriptor{
+			backends,
+			dx12_shader_compiler,
+			..Default::default()
+		}),
+	}
+}
+impl SetupContextPartial1{
+	fn create_surface<'a>(self,window:&'a winit::window::Window)->Result<SetupContextPartial2<'a>,wgpu::CreateSurfaceError>{
+		Ok(SetupContextPartial2{
+			backends:self.backends,
+			surface:self.instance.create_surface(window)?,
+			instance:self.instance,
+		})
+	}
+}
+struct SetupContextPartial2<'a>{
+	backends:wgpu::Backends,
+	instance:wgpu::Instance,
+	surface:wgpu::Surface<'a>,
+}
+impl<'a> SetupContextPartial2<'a>{
+	fn pick_adapter(self)->SetupContextPartial3<'a>{
+		let adapter;
+
+		//TODO: prefer adapter that implements optional features
+		//let optional_features=optional_features();
+		let required_features=required_features();
+
+		//no helper function smh gotta write it myself
+		let adapters=self.instance.enumerate_adapters(self.backends);
+
+		let mut chosen_adapter=None;
+		let mut chosen_adapter_score=0;
+		for adapter in adapters {
+			if !adapter.is_surface_supported(&self.surface) {
+				continue;
+			}
+
+			let score=match adapter.get_info().device_type{
+				wgpu::DeviceType::IntegratedGpu=>3,
+				wgpu::DeviceType::DiscreteGpu=>4,
+				wgpu::DeviceType::VirtualGpu=>2,
+				wgpu::DeviceType::Other|wgpu::DeviceType::Cpu=>1,
+			};
+
+			let adapter_features=adapter.features();
+			if chosen_adapter_score<score&&adapter_features.contains(required_features) {
+				chosen_adapter_score=score;
+				chosen_adapter=Some(adapter);
+			}
+		}
+
+		if let Some(maybe_chosen_adapter)=chosen_adapter{
+			adapter=maybe_chosen_adapter;
+		}else{
+			panic!("No suitable GPU adapters found on the system!");
+		}
+
+
+		let adapter_info=adapter.get_info();
+		println!("Using {} ({:?})", adapter_info.name, adapter_info.backend);
+
+		let required_downlevel_capabilities=required_downlevel_capabilities();
+		let downlevel_capabilities=adapter.get_downlevel_capabilities();
+		assert!(
+			downlevel_capabilities.shader_model >= required_downlevel_capabilities.shader_model,
+			"Adapter does not support the minimum shader model required to run this example: {:?}",
+			required_downlevel_capabilities.shader_model
+		);
+		assert!(
+			downlevel_capabilities
+				.flags
+				.contains(required_downlevel_capabilities.flags),
+			"Adapter does not support the downlevel capabilities required to run this example: {:?}",
+			required_downlevel_capabilities.flags - downlevel_capabilities.flags
+		);
+		SetupContextPartial3{
+			instance:self.instance,
+			surface:self.surface,
+			adapter,
+		}
+	}
+}
+struct SetupContextPartial3<'a>{
+	instance:wgpu::Instance,
+	surface:wgpu::Surface<'a>,
+	adapter:wgpu::Adapter,
+}
+impl<'a> SetupContextPartial3<'a>{
+	fn request_device(self)->SetupContextPartial4<'a>{
+		let optional_features=optional_features();
+		let required_features=required_features();
+
+		// Make sure we use the texture resolution limits from the adapter, so we can support images the size of the surface.
+		let needed_limits=required_limits().using_resolution(self.adapter.limits());
+
+		let trace_dir=std::env::var("WGPU_TRACE");
+		let (device, queue)=pollster::block_on(self.adapter
+			.request_device(
+				&wgpu::DeviceDescriptor {
+					label: None,
+					required_features: (optional_features & self.adapter.features()) | required_features,
+					required_limits: needed_limits,
+				},
+				trace_dir.ok().as_ref().map(std::path::Path::new),
+			))
+			.expect("Unable to find a suitable GPU adapter!");
+
+		SetupContextPartial4{
+			instance:self.instance,
+			surface:self.surface,
+			adapter:self.adapter,
+			device,
+			queue,
+		}
+	}
+}
+struct SetupContextPartial4<'a>{
+	instance:wgpu::Instance,
+	surface:wgpu::Surface<'a>,
+	adapter:wgpu::Adapter,
+	device:wgpu::Device,
+	queue:wgpu::Queue,
+}
+impl<'a> SetupContextPartial4<'a>{
+	fn configure_surface(self,size:&'a winit::dpi::PhysicalSize<u32>)->SetupContext<'a>{
+		let mut config=self.surface
+			.get_default_config(&self.adapter, size.width, size.height)
+			.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{
+			instance:self.instance,
+			surface:self.surface,
+			device:self.device,
+			queue:self.queue,
+			config,
+		}
+	}
+}
+pub struct SetupContext<'a>{
+	pub instance:wgpu::Instance,
+	pub surface:wgpu::Surface<'a>,
+	pub device:wgpu::Device,
+	pub queue:wgpu::Queue,
+	pub config:wgpu::SurfaceConfiguration,
+}
+
+pub fn setup_and_start(title:String){
+	let event_loop=winit::event_loop::EventLoop::new().unwrap();
+
+	println!("Initializing the surface...");
+
+	let partial_1=create_instance();
+
+	let window=create_window(title.as_str(),&event_loop).unwrap();
+
+	let partial_2=partial_1.create_surface(&window).unwrap();
+
+	let partial_3=partial_2.pick_adapter();
+
+	let partial_4=partial_3.request_device();
+
+	let size=window.inner_size();
+
+	let setup_context=partial_4.configure_surface(&size);
+
+	//dedicated thread to ping request redraw back and resize the window doesn't seem logical
+
+	let window=crate::window::WindowContextSetup::new(&setup_context,&window);
+	//the thread that spawns the physics thread
+	let window_thread=window.into_worker(setup_context);
+
+	println!("Entering event loop...");
+	let root_time=std::time::Instant::now();
+	run_event_loop(event_loop,window_thread,root_time).unwrap();
+}
+
+fn run_event_loop(
+	event_loop:winit::event_loop::EventLoop<()>,
+	mut window_thread:crate::compat_worker::QNWorker<TimedInstruction<WindowInstruction>>,
+	root_time:std::time::Instant
+	)->Result<(),winit::error::EventLoopError>{
+		event_loop.run(move |event,elwt|{
+			let time=integer::Time::from_nanos(root_time.elapsed().as_nanos() as i64);
+			// *control_flow=if cfg!(feature="metal-auto-capture"){
+			// 	winit::event_loop::ControlFlow::Exit
+			// }else{
+			// 	winit::event_loop::ControlFlow::Poll
+			// };
+			match event{
+				winit::event::Event::AboutToWait=>{
+					window_thread.send(TimedInstruction{time,instruction:WindowInstruction::RequestRedraw}).unwrap();
+				}
+				winit::event::Event::WindowEvent {
+					event:
+						// WindowEvent::Resized(size)
+						// | WindowEvent::ScaleFactorChanged {
+						// 	new_inner_size: &mut size,
+						// 	..
+						// },
+						winit::event::WindowEvent::Resized(size),//ignoring scale factor changed for now because mutex bruh
+					window_id:_,
+				} => {
+					window_thread.send(TimedInstruction{time,instruction:WindowInstruction::Resize(size)}).unwrap();
+				}
+				winit::event::Event::WindowEvent{event,..}=>match event{
+					winit::event::WindowEvent::KeyboardInput{
+						event:
+							winit::event::KeyEvent {
+							logical_key: winit::keyboard::Key::Named(winit::keyboard::NamedKey::Escape),
+								state: winit::event::ElementState::Pressed,
+								..
+							},
+						..
+					}
+					|winit::event::WindowEvent::CloseRequested=>{
+						elwt.exit();
+					}
+					winit::event::WindowEvent::RedrawRequested=>{
+						window_thread.send(TimedInstruction{time,instruction:WindowInstruction::Render}).unwrap();
+					}
+					_=>{
+						window_thread.send(TimedInstruction{time,instruction:WindowInstruction::WindowEvent(event)}).unwrap();
+					}
+				},
+				winit::event::Event::DeviceEvent{
+					event,
+					..
+				} => {
+					window_thread.send(TimedInstruction{time,instruction:WindowInstruction::DeviceEvent(event)}).unwrap();
+				},
+				_=>{}
+			}
+		})
+}

src/shader.wgsl

@@ -1,21 +1,23 @@
-struct SkyOutput {
+struct Camera {
-	@builtin(position) position: vec4<f32>,
-	@location(0) sampledir: vec3<f32>,
-};
-
-struct Data {
 	// from camera to screen
 	proj: mat4x4<f32>,
 	// from screen to camera
 	proj_inv: mat4x4<f32>,
 	// from world to camera
 	view: mat4x4<f32>,
-	// camera position
+	// from camera to world
-	cam_pos: vec4<f32>,
+	view_inv: mat4x4<f32>,
 };
+
+//group 0 is the camera
 @group(0)
 @binding(0)
-var<uniform> r_data: Data;
+var<uniform> camera: Camera;
+
+struct SkyOutput {
+	@builtin(position) position: vec4<f32>,
+	@location(0) sampledir: vec3<f32>,
+};
 
 @vertex
 fn vs_sky(@builtin(vertex_index) vertex_index: u32) -> SkyOutput {
@@ -29,9 +31,8 @@ fn vs_sky(@builtin(vertex_index) vertex_index: u32) -> SkyOutput {
 		1.0
 	);
 
-	// transposition = inversion for this orthonormal matrix
+	let inv_model_view = mat3x3<f32>(camera.view_inv[0].xyz, camera.view_inv[1].xyz, camera.view_inv[2].xyz);
-	let inv_model_view = transpose(mat3x3<f32>(r_data.view[0].xyz, r_data.view[1].xyz, r_data.view[2].xyz));
+	let unprojected = camera.proj_inv * pos;
-	let unprojected = r_data.proj_inv * pos;
 
 	var result: SkyOutput;
 	result.sampledir = inv_model_view * unprojected.xyz;
@@ -39,93 +40,73 @@ fn vs_sky(@builtin(vertex_index) vertex_index: u32) -> SkyOutput {
 	return result;
 }
 
-struct GroundOutput {
+struct ModelInstance{
-	@builtin(position) position: vec4<f32>,
+	transform:mat4x4<f32>,
-	@location(4) pos: vec3<f32>,
+	normal_transform:mat3x3<f32>,
-};
+	color:vec4<f32>,
-
-@vertex
-fn vs_ground(@builtin(vertex_index) vertex_index: u32) -> GroundOutput {
-	// hacky way to draw two triangles that make a square
-	let tmp1 = i32(vertex_index)/2-i32(vertex_index)/3;
-	let tmp2 = i32(vertex_index)&1;
-	let pos = vec3<f32>(
-		f32(tmp1) * 2.0 - 1.0,
-		0.0,
-		f32(tmp2) * 2.0 - 1.0
-	) * 160.0;
-
-	var result: GroundOutput;
-	result.pos = pos;
-	result.position = r_data.proj * r_data.view * vec4<f32>(pos, 1.0);
-	return result;
 }
+//my fancy idea is to create a megatexture for each model that includes all the textures each intance will need
+//the texture transform then maps the texture coordinates to the location of the specific texture
+//group 1 is the model
+const MAX_MODEL_INSTANCES=4096;
+@group(2)
+@binding(0)
+var<uniform> model_instances: array<ModelInstance, MAX_MODEL_INSTANCES>;
+@group(2)
+@binding(1)
+var model_texture: texture_2d<f32>;
+@group(2)
+@binding(2)
+var model_sampler: sampler;
 
-struct EntityOutput {
+struct EntityOutputTexture {
 	@builtin(position) position: vec4<f32>,
 	@location(1) texture: vec2<f32>,
 	@location(2) normal: vec3<f32>,
 	@location(3) view: vec3<f32>,
+	@location(4) color: vec4<f32>,
+	@location(5) @interpolate(flat) model_color: vec4<f32>,
 };
-
-@group(1)
-@binding(0)
-var<uniform> r_EntityTransform: mat4x4<f32>;
-
 @vertex
-fn vs_entity(
+fn vs_entity_texture(
+	@builtin(instance_index) instance: u32,
 	@location(0) pos: vec3<f32>,
 	@location(1) texture: vec2<f32>,
 	@location(2) normal: vec3<f32>,
-) -> EntityOutput {
+	@location(3) color: vec4<f32>,
-	var position: vec4<f32> = r_EntityTransform * vec4<f32>(pos, 1.0);
+) -> EntityOutputTexture {
-	var result: EntityOutput;
+	var position: vec4<f32> = model_instances[instance].transform * vec4<f32>(pos, 1.0);
-	result.normal = (r_EntityTransform * vec4<f32>(normal, 0.0)).xyz;
+	var result: EntityOutputTexture;
-	result.texture=texture;
+	result.normal = model_instances[instance].normal_transform * normal;
-	result.view = position.xyz - r_data.cam_pos.xyz;
+	result.texture = texture;
-	result.position = r_data.proj * r_data.view * position;
+	result.color = color;
+	result.model_color = model_instances[instance].color;
+	result.view = position.xyz - camera.view_inv[3].xyz;//col(3)
+	result.position = camera.proj * camera.view * position;
 	return result;
 }
 
-@group(0)
+//group 2 is the skybox texture
+@group(1)
+@binding(0)
+var cube_texture: texture_cube<f32>;
+@group(1)
 @binding(1)
-var r_texture: texture_cube<f32>;
+var cube_sampler: sampler;
-@group(0)
-@binding(2)
-var r_sampler: sampler;
 
 @fragment
 fn fs_sky(vertex: SkyOutput) -> @location(0) vec4<f32> {
-	return textureSample(r_texture, r_sampler, vertex.sampledir);
+	return textureSample(cube_texture, cube_sampler, vertex.sampledir);
 }
 
 @fragment
-fn fs_entity(vertex: EntityOutput) -> @location(0) vec4<f32> {
+fn fs_entity_texture(vertex: EntityOutputTexture) -> @location(0) vec4<f32> {
 	let incident = normalize(vertex.view);
 	let normal = normalize(vertex.normal);
 	let d = dot(normal, incident);
 	let reflected = incident - 2.0 * d * normal;
 
-	let dir = vec3<f32>(-1.0)+2.0*vec3<f32>(vertex.texture.x,0.0,vertex.texture.y);
+	let fragment_color = textureSample(model_texture, model_sampler, vertex.texture)*vertex.color;
-	let texture_color = textureSample(r_texture, r_sampler, dir).rgb;
+	let reflected_color = textureSample(cube_texture, cube_sampler, reflected).rgb;
-	let reflected_color = textureSample(r_texture, r_sampler, reflected).rgb;
+	return mix(vec4<f32>(vec3<f32>(0.05) + 0.2 * reflected_color,1.0),mix(vertex.model_color,vec4<f32>(fragment_color.rgb,1.0),fragment_color.a),0.5+0.5*abs(d));
-	return vec4<f32>(mix(vec3<f32>(0.1) + 0.5 * reflected_color,texture_color,1.0-pow(1.0-abs(d),2.0)), 1.0);
-}
-
-fn modulo_euclidean (a: f32, b: f32) -> f32 {
-	var m = a % b;
-	if (m < 0.0) {
-		if (b < 0.0) {
-			m -= b;
-		} else {
-			m += b;
-		}
-	}
-	return m;
-}
-
-@fragment
-fn fs_ground(vertex: GroundOutput) -> @location(0) vec4<f32> {
-	let dir = vec3<f32>(-1.0)+vec3<f32>(modulo_euclidean(vertex.pos.x/16.,1.0),0.0,modulo_euclidean(vertex.pos.z/16.,1.0))*2.0;
-	return vec4<f32>(textureSample(r_texture, r_sampler, dir).rgb, 1.0);
 }

src/sweep.rs

@@ -1,8 +0,0 @@
-
-//something that implements body + hitbox + transform can predict collision
-impl crate::sweep::PredictCollision for Model {
-	fn predict_collision(&self,other:&Model) -> Option<crate::event::EventStruct> {
-		//math!
-		None
-	}
-}

src/window.rs

@@ -0,0 +1,244 @@
+use crate::physics_worker::InputInstruction;
+use strafesnet_common::integer;
+use strafesnet_common::instruction::TimedInstruction;
+
+pub enum WindowInstruction{
+	Resize(winit::dpi::PhysicalSize<u32>),
+	WindowEvent(winit::event::WindowEvent),
+	DeviceEvent(winit::event::DeviceEvent),
+	RequestRedraw,
+	Render,
+}
+
+//holds thread handles to dispatch to
+struct WindowContext<'a>{
+	manual_mouse_lock:bool,
+	mouse:crate::physics::MouseState,//std::sync::Arc<std::sync::Mutex<>>
+	screen_size:glam::UVec2,
+	user_settings:crate::settings::UserSettings,
+	window:&'a winit::window::Window,
+	physics_thread:crate::compat_worker::QNWorker<'a, TimedInstruction<crate::physics_worker::Instruction>>,
+}
+
+impl WindowContext<'_>{
+	fn get_middle_of_screen(&self)->winit::dpi::PhysicalPosition<f32>{
+		winit::dpi::PhysicalPosition::new(self.screen_size.x as f32/2.0,self.screen_size.y as f32/2.0)
+	}
+	fn window_event(&mut self,time:integer::Time,event: winit::event::WindowEvent) {
+		match event {
+			winit::event::WindowEvent::DroppedFile(path)=>{
+				//blocking because it's simpler...
+				if let Some(indexed_model_instances)=crate::load_file(path){
+					self.physics_thread.send(TimedInstruction{time,instruction:crate::physics_worker::Instruction::ClearModels}).unwrap();
+					self.physics_thread.send(TimedInstruction{time,instruction:crate::physics_worker::Instruction::GenerateModels(indexed_model_instances)}).unwrap();
+				}
+			},
+			winit::event::WindowEvent::Focused(_state)=>{
+				//pause unpause
+				//recalculate pressed keys on focus
+			},
+			winit::event::WindowEvent::KeyboardInput{
+				event:winit::event::KeyEvent{state,logical_key,repeat:false,..},
+				..
+			}=>{
+				let s=match state{
+					winit::event::ElementState::Pressed=>true,
+					winit::event::ElementState::Released=>false,
+				};
+				match logical_key{
+					winit::keyboard::Key::Named(winit::keyboard::NamedKey::Tab)=>{
+						if s{
+							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),
+							}
+						}else{
+							//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(s);
+					},
+					winit::keyboard::Key::Named(winit::keyboard::NamedKey::F11)=>{
+						if s{
+							if self.window.fullscreen().is_some(){
+								self.window.set_fullscreen(None);
+							}else{
+								self.window.set_fullscreen(Some(winit::window::Fullscreen::Borderless(None)));
+							}
+						}
+					},
+					winit::keyboard::Key::Named(winit::keyboard::NamedKey::Escape)=>{
+						if s{
+							self.manual_mouse_lock=false;
+							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);
+						}
+					},
+					keycode=>{
+						if let Some(input_instruction)=match keycode{
+							winit::keyboard::Key::Named(winit::keyboard::NamedKey::Space)=>Some(InputInstruction::Jump(s)),
+							winit::keyboard::Key::Character(key)=>match key.as_str(){
+								"w"=>Some(InputInstruction::MoveForward(s)),
+								"a"=>Some(InputInstruction::MoveLeft(s)),
+								"s"=>Some(InputInstruction::MoveBack(s)),
+								"d"=>Some(InputInstruction::MoveRight(s)),
+								"e"=>Some(InputInstruction::MoveUp(s)),
+								"q"=>Some(InputInstruction::MoveDown(s)),
+								"z"=>Some(InputInstruction::Zoom(s)),
+								"r"=>if s{Some(InputInstruction::Reset)}else{None},
+								_=>None,
+							},
+							_=>None,
+						}{
+							self.physics_thread.send(TimedInstruction{
+								time,
+								instruction:crate::physics_worker::Instruction::Input(input_instruction),
+							}).unwrap();
+						}
+					},
+				}
+			},
+			_=>(),
+		}
+	}
+
+	fn device_event(&mut self,time:integer::Time,event: winit::event::DeviceEvent) {
+		match event {
+			winit::event::DeviceEvent::MouseMotion {
+			    delta,//these (f64,f64) are integers on my machine
+			} => {
+				if self.manual_mouse_lock{
+					match self.window.set_cursor_position(self.get_middle_of_screen()){
+						Ok(())=>(),
+						Err(e)=>println!("Could not set cursor position: {:?}",e),
+					}
+				}
+				//do not step the physics because the mouse polling rate is higher than the physics can run.
+				//essentially the previous input will be overwritten until a true step runs
+				//which is fine because they run all the time.
+				let delta=glam::ivec2(delta.0 as i32,delta.1 as i32);
+				self.mouse.pos+=delta;
+				self.physics_thread.send(TimedInstruction{
+					time,
+					instruction:crate::physics_worker::Instruction::Input(InputInstruction::MoveMouse(self.mouse.pos)),
+				}).unwrap();
+			},
+			winit::event::DeviceEvent::MouseWheel {
+			    delta,
+			} => {
+				println!("mousewheel {:?}",delta);
+				if false{//self.physics.style.use_scroll{
+					self.physics_thread.send(TimedInstruction{
+						time,
+						instruction:crate::physics_worker::Instruction::Input(InputInstruction::Jump(true)),//activates the immediate jump path, but the style modifier prevents controls&CONTROL_JUMP bit from being set to auto jump
+					}).unwrap();
+				}
+			}
+			_=>(),
+		}
+	}
+}
+
+pub struct WindowContextSetup<'a>{
+	user_settings:crate::settings::UserSettings,
+	window:&'a winit::window::Window,
+	physics:crate::physics::PhysicsState,
+	graphics:crate::graphics::GraphicsState,
+}
+
+impl<'a> WindowContextSetup<'a>{
+	pub fn new(context:&crate::setup::SetupContext,window:&'a winit::window::Window)->Self{
+		//wee
+		let user_settings=crate::settings::read_user_settings();
+
+		let args:Vec<String>=std::env::args().collect();
+		let indexed_model_instances=if args.len()==2{
+			crate::load_file(std::path::PathBuf::from(&args[1]))
+		}else{
+			None
+		}.unwrap_or(crate::default_models());
+
+		let mut physics=crate::physics::PhysicsState::default();
+		physics.load_user_settings(&user_settings);
+		physics.generate_models(&indexed_model_instances);
+		physics.spawn(indexed_model_instances.spawn_point);
+
+		let mut graphics=crate::graphics::GraphicsState::new(&context.device,&context.queue,&context.config);
+		graphics.load_user_settings(&user_settings);
+		graphics.generate_models(&context.device,&context.queue,indexed_model_instances);
+
+		Self{
+			user_settings,
+			window,
+			graphics,
+			physics,
+		}
+	}
+
+	fn into_context(self,setup_context:crate::setup::SetupContext<'a>)->WindowContext<'a>{
+		let screen_size=glam::uvec2(setup_context.config.width,setup_context.config.height);
+		let graphics_thread=crate::graphics_worker::new(self.graphics,setup_context.config,setup_context.surface,setup_context.device,setup_context.queue);
+		WindowContext{
+			manual_mouse_lock:false,
+			mouse:crate::physics::MouseState::default(),
+			//make sure to update this!!!!!
+			screen_size,
+			user_settings:self.user_settings,
+			window:self.window,
+			physics_thread:crate::physics_worker::new(self.physics,graphics_thread),
+		}
+	}
+
+	pub fn into_worker(self,setup_context:crate::setup::SetupContext<'a>)->crate::compat_worker::QNWorker<'a,TimedInstruction<WindowInstruction>>{
+		let mut window_context=self.into_context(setup_context);
+		crate::compat_worker::QNWorker::new(move |ins:TimedInstruction<WindowInstruction>|{
+			match ins.instruction{
+				WindowInstruction::RequestRedraw=>{
+					window_context.window.request_redraw();
+				}
+				WindowInstruction::WindowEvent(window_event)=>{
+					window_context.window_event(ins.time,window_event);
+				},
+				WindowInstruction::DeviceEvent(device_event)=>{
+					window_context.device_event(ins.time,device_event);
+				},
+				WindowInstruction::Resize(size)=>{
+					window_context.physics_thread.send(
+						TimedInstruction{
+							time:ins.time,
+							instruction:crate::physics_worker::Instruction::Resize(size,window_context.user_settings.clone())
+						}
+					).unwrap();
+				}
+				WindowInstruction::Render=>{
+					window_context.physics_thread.send(
+						TimedInstruction{
+							time:ins.time,
+							instruction:crate::physics_worker::Instruction::Render
+						}
+					).unwrap();
+				}
+			}
+		})
+	}
+}

src/worker.rs

@@ -0,0 +1,210 @@
+use std::thread;
+use std::sync::{mpsc,Arc};
+use parking_lot::Mutex;
+
+//WorkerPool
+struct Pool(u32);
+enum PoolOrdering{
+	Single,//single thread cannot get out of order
+	Ordered(u32),//order matters and should be buffered/dropped according to ControlFlow
+	Unordered(u32),//order does not matter
+}
+//WorkerInput
+enum Input{
+	//no input, workers have everything needed at creation
+	None,
+	//Immediate input to any available worker, dropped if they are overflowing (all workers are busy)
+	Immediate,
+	//Queued input is ordered, but serial jobs that mutate state (such as running physics) can only be done with a single worker
+	Queued,//"Fifo"
+	//Query a function to get next input when a thread becomes available
+	//worker stops querying when Query function returns None and dies after all threads complete
+	//lifetimes sound crazy on this one
+	Query,
+	//Queue of length one, the input is replaced if it is submitted twice before the current work finishes
+	Mailbox,
+}
+//WorkerOutput
+enum Output{
+	None(Pool),
+	Realtime(PoolOrdering),//outputs are dropped if they are out of order and order is demanded
+	Buffered(PoolOrdering),//outputs are held back internally if they are out of order and order is demanded
+}
+
+//It would be possible to implement all variants
+//with a query input function and callback output function but I'm not sure if that's worth it.
+//Immediate = Condvar
+//Queued = receiver.recv()
+//a callback function would need to use an async runtime!
+
+//realtime output is an arc mutex of the output value that is assigned every time a worker completes a job
+//buffered output produces a receiver object that can be passed to the creation of another worker
+//when ordering is requested, output is ordered by the order each thread is run
+//which is the same as the order that the input data is processed except for Input::None which has no input data
+//WorkerDescription
+struct Description{
+	input:Input,
+	output:Output,
+}
+
+//The goal here is to have a worker thread that parks itself when it runs out of work.
+//The worker thread publishes the result of its work back to the worker object for every item in the work queue.
+//Previous values do not matter as soon as a new value is produced, which is why it's called "Realtime"
+//The physics (target use case) knows when it has not changed the body, so not updating the value is also an option.
+
+/*
+QR = WorkerDescription{
+	input:Queued,
+	output:Realtime(Single),
+}
+*/
+pub struct QRWorker<Task:Send,Value:Clone>{
+	sender: mpsc::Sender<Task>,
+	value:Arc<Mutex<Value>>,
+}
+
+impl<Task:Send+'static,Value:Clone+Send+'static> QRWorker<Task,Value>{
+	pub fn new<F:FnMut(Task)->Value+Send+'static>(value:Value,mut f:F) -> Self {
+		let (sender, receiver) = mpsc::channel::<Task>();
+		let ret=Self {
+			sender,
+			value:Arc::new(Mutex::new(value)),
+		};
+		let value=ret.value.clone();
+		thread::spawn(move || {
+			loop {
+				match receiver.recv() {
+					Ok(task) => {
+						let v=f(task);//make sure function is evaluated before lock is acquired
+						*value.lock()=v;
+					}
+					Err(_) => {
+						println!("Worker stopping.",);
+						break;
+					}
+				}
+			}
+		});
+		ret
+	}
+
+	pub fn send(&self,task:Task)->Result<(), mpsc::SendError<Task>>{
+		self.sender.send(task)
+	}
+
+	pub fn grab_clone(&self)->Value{
+		self.value.lock().clone()
+	}
+}
+
+/*
+QN = WorkerDescription{
+	input:Queued,
+	output:None(Single),
+}
+*/
+//None Output Worker does all its work internally from the perspective of the work submitter
+pub struct QNWorker<'a,Task:Send>{
+	sender: mpsc::Sender<Task>,
+	handle:thread::ScopedJoinHandle<'a,()>,
+}
+
+impl<'a,Task:Send+'a> QNWorker<'a,Task>{
+	pub fn new<F:FnMut(Task)+Send+'a>(scope:&'a thread::Scope<'a,'_>,mut f:F)->QNWorker<'a,Task>{
+		let (sender,receiver)=mpsc::channel::<Task>();
+		let handle=scope.spawn(move ||{
+			loop {
+				match receiver.recv() {
+					Ok(task)=>f(task),
+					Err(_)=>{
+						println!("Worker stopping.",);
+						break;
+					}
+				}
+			}
+		});
+		Self{
+			sender,
+			handle,
+		}
+	}
+	pub fn send(&self,task:Task)->Result<(),mpsc::SendError<Task>>{
+		self.sender.send(task)
+	}
+}
+
+/*
+IN = WorkerDescription{
+	input:Immediate,
+	output:None(Single),
+}
+*/
+//Inputs are dropped if the worker is busy
+pub struct INWorker<'a,Task:Send>{
+	sender: mpsc::SyncSender<Task>,
+	handle:thread::ScopedJoinHandle<'a,()>,
+}
+
+impl<'a,Task:Send+'a> INWorker<'a,Task>{
+	pub fn new<F:FnMut(Task)+Send+'a>(scope:&'a thread::Scope<'a,'_>,mut f:F)->INWorker<'a,Task>{
+		let (sender,receiver)=mpsc::sync_channel::<Task>(1);
+		let handle=scope.spawn(move ||{
+			loop {
+				match receiver.recv() {
+					Ok(task)=>f(task),
+					Err(_)=>{
+						println!("Worker stopping.",);
+						break;
+					}
+				}
+			}
+		});
+		Self{
+			sender,
+			handle,
+		}
+	}
+	//blocking!
+	pub fn blocking_send(&self,task:Task)->Result<(), mpsc::SendError<Task>>{
+		self.sender.send(task)
+	}
+	pub fn send(&self,task:Task)->Result<(), mpsc::TrySendError<Task>>{
+		self.sender.try_send(task)
+	}
+}
+
+#[test]//How to run this test with printing: cargo test --release -- --nocapture
+fn test_worker() {
+	// Create the worker thread
+	let test_body=crate::physics::Body::new(crate::integer::Planar64Vec3::ONE,crate::integer::Planar64Vec3::ONE,crate::integer::Planar64Vec3::ONE,crate::integer::Time::ZERO);
+	let worker=QRWorker::new(crate::physics::Body::default(),
+		|_|crate::physics::Body::new(crate::integer::Planar64Vec3::ONE,crate::integer::Planar64Vec3::ONE,crate::integer::Planar64Vec3::ONE,crate::integer::Time::ZERO)
+	);
+
+	// Send tasks to the worker
+	for _ in 0..5 {
+		let task = strafesnet_common::instruction::TimedInstruction{
+			time:strafesnet_common::integer::Time::ZERO,
+			instruction:crate::physics::PhysicsInstruction::StrafeTick,
+		};
+		worker.send(task).unwrap();
+	}
+
+	// Optional: Signal the worker to stop (in a real-world scenario)
+	// sender.send("STOP".to_string()).unwrap();
+
+	// Sleep to allow the worker thread to finish processing
+	thread::sleep(std::time::Duration::from_millis(10));
+
+	// Send a new task
+	let task = strafesnet_common::instruction::TimedInstruction{
+		time:strafesnet_common::integer::Time::ZERO,
+		instruction:crate::physics::PhysicsInstruction::StrafeTick,
+	};
+	worker.send(task).unwrap();
+
+	//assert_eq!(test_body,worker.grab_clone());
+
+	// wait long enough to see print from final task
+	thread::sleep(std::time::Duration::from_millis(10));
+}

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/surf_maps

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

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

tools/utopia

@@ -0,0 +1 @@
+mangohud ../target/release/strafe-client surf_maps/5692145408.rbxm