its working look at this

.gitignore

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

Cargo.lock

@@ -1442,6 +1442,20 @@ dependencies = [
  "thiserror",
 ]
 
+[[package]]
+name = "rbx_xml"
+version = "0.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4bc65b70827519fdc4ab47416d1085b912f087fadab9ed415471b6daba635574"
+dependencies = [
+ "base64",
+ "log",
+ "rbx_dom_weak",
+ "rbx_reflection",
+ "rbx_reflection_database",
+ "xml-rs",
+]
+
 [[package]]
 name = "redox_syscall"
 version = "0.3.5"
@@ -1453,9 +1467,9 @@ dependencies = [
 
 [[package]]
 name = "regex"
-version = "1.9.4"
+version = "1.9.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "12de2eff854e5fa4b1295edd650e227e9d8fb0c9e90b12e7f36d6a6811791a29"
+checksum = "697061221ea1b4a94a624f67d0ae2bfe4e22b8a17b6a192afb11046542cc8c47"
 dependencies = [
  "aho-corasick",
  "memchr",
@@ -1465,9 +1479,9 @@ dependencies = [
 
 [[package]]
 name = "regex-automata"
-version = "0.3.7"
+version = "0.3.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "49530408a136e16e5b486e883fbb6ba058e8e4e8ae6621a77b048b314336e629"
+checksum = "c2f401f4955220693b56f8ec66ee9c78abffd8d1c4f23dc41a23839eb88f0795"
 dependencies = [
  "aho-corasick",
  "memchr",
@@ -1658,6 +1672,8 @@ dependencies = [
  "rbx_binary",
  "rbx_dom_weak",
  "rbx_reflection_database",
+ "rbx_xml",
+ "regex",
  "wgpu",
  "winit",
 ]

Cargo.toml

@@ -17,6 +17,8 @@ pollster = "0.3.0"
 rbx_binary = "0.7.1"
 rbx_dom_weak = "2.5.0"
 rbx_reflection_database = "0.2.7"
+rbx_xml = "0.13.1"
+regex = "1.9.5"
 wgpu = "0.17.0"
 winit = "0.28.6"
 

src/body.rs

@@ -4,7 +4,11 @@ use crate::{instruction::{InstructionEmitter, InstructionConsumer, TimedInstruct
 pub enum PhysicsInstruction {
 	CollisionStart(RelativeCollision),
 	CollisionEnd(RelativeCollision),
+	SetControlDir(glam::Vec3),
 	StrafeTick,
+	Jump,
+	SetWalkTargetVelocity(glam::Vec3),
+	RefreshWalkTarget,
 	ReachWalkTargetVelocity,
 	// Water,
 	// Spawn(
@@ -12,21 +16,8 @@ pub enum PhysicsInstruction {
 	// 	bool,//true = Trigger; false = teleport
 	// 	bool,//true = Force
 	// )
-	//Both of these conditionally activate RefreshWalkTarget (by doing what SetWalkTargetVelocity used to do and then flagging it)
-	Input(InputInstruction),
-}
-#[derive(Debug)]
-pub enum InputInstruction {
-	MoveMouse(glam::IVec2),
-	MoveForward(bool),
-	MoveLeft(bool),
-	MoveBack(bool),
-	MoveRight(bool),
-	MoveUp(bool),
-	MoveDown(bool),
-	Jump(bool),
-	Zoom(bool),
-	Reset,
+	//temp
+	SetPosition(glam::Vec3),
 }
 
 pub struct Body {
@@ -62,35 +53,34 @@ pub enum MoveRestriction {
 	Ladder,//multiple ladders how
 }
 
-/*
-enum InputInstruction {
-}
-struct InputState {
-}
-impl InputState {
-	pub fn get_control(&self,control:u32) -> bool {
-		self.controls&control!=0
-	}
-}
-impl crate::instruction::InstructionEmitter<InputInstruction> for InputState{
-	fn next_instruction(&self, time_limit:crate::body::TIME) -> Option<TimedInstruction<InputInstruction>> {
-	    //this is polled by PhysicsState for actions like Jump
-	    //no, it has to be the other way around. physics is run up until the jump instruction, and then the jump instruction is pushed.
-	    self.queue.get(0)
-	}
-}
-impl crate::instruction::InstructionConsumer<InputInstruction> for InputState{
-	fn process_instruction(&mut self,ins:TimedInstruction<InputInstruction>){
-		//add to queue
-		self.queue.push(ins);
-	}
-}
-*/
-
 enum MouseInterpolation {
 	First,//just checks the last value
 	Lerp,//lerps between
 }
+
+enum InputInstruction {
+	MoveMouse(glam::IVec2),
+	Jump(bool),
+}
+
+struct InputState {
+	controls: u32,
+	mouse_interpolation: MouseInterpolation,
+	time: TIME,
+}
+
+impl InputState {
+	pub fn get_control(&self,control:u32) -> bool {
+		self.controls&control!=0
+	}
+	pub fn process_instruction(&mut self,ins:InputInstruction){
+		match ins {
+			InputInstruction::MoveMouse(m) => todo!("set mouse_interpolation"),
+			InputInstruction::Jump(b) => todo!("how does info about style modifiers get here"),
+		}
+	}
+}
+
 pub struct MouseInterpolationState {
 	interpolation: MouseInterpolation,
 	time0: TIME,
@@ -100,20 +90,11 @@ pub struct MouseInterpolationState {
 }
 
 impl MouseInterpolationState {
-	pub fn new() -> Self {
-		Self {
-			interpolation:MouseInterpolation::First,
-			time0:0,
-			time1:1,//ONE NANOSECOND!!!! avoid divide by zero
-			mouse0:glam::IVec2::ZERO,
-			mouse1:glam::IVec2::ZERO,
-		}
-	}
-	pub fn move_mouse(&mut self,time:TIME,delta:glam::IVec2){
+	pub fn move_mouse(&mut self,time:TIME,pos:glam::IVec2){
 		self.time0=self.time1;
 		self.mouse0=self.mouse1;
 		self.time1=time;
-		self.mouse1=self.mouse1+delta;
+		self.mouse1=pos;
 	}
 	pub fn interpolated_position(&self,time:TIME) -> glam::IVec2 {
 		match self.interpolation {
@@ -134,6 +115,7 @@ impl MouseInterpolationState {
 pub enum WalkEnum{
 	Reached,
 	Transient,
+	Invalid,
 }
 pub struct WalkState {
 	pub target_velocity: glam::Vec3,
@@ -145,120 +127,22 @@ impl WalkState {
 		Self{
 			target_velocity:glam::Vec3::ZERO,
 			target_time:0,
-			state:WalkEnum::Reached,
+			state:WalkEnum::Invalid,
 		}
 	}
 }
 
-// Note: we use the Y=up coordinate space in this example.
-pub struct Camera {
-	offset: glam::Vec3,
-	angles: glam::DVec2,//YAW AND THEN PITCH
-	//punch: glam::Vec3,
-	//punch_velocity: glam::Vec3,
-	fov: glam::Vec2,//slope
-	sensitivity: glam::DVec2,
-	time: TIME,
-}
-
-#[inline]
-fn mat3_from_rotation_y_f64(angle: f64) -> glam::Mat3 {
-    let (sina, cosa) = angle.sin_cos();
-    glam::Mat3::from_cols(
-        glam::Vec3::new(cosa as f32, 0.0, -sina as f32),
-        glam::Vec3::Y,
-        glam::Vec3::new(sina as f32, 0.0, cosa as f32),
-    )
-}
-#[inline]
-fn perspective_rh(fov_x_slope: f32, fov_y_slope: 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_x_slope, 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 {
-	pub fn from_offset(offset:glam::Vec3,aspect:f32) -> Self {
-		Self{
-		    offset,
-		    angles: glam::DVec2::ZERO,
-		    fov: glam::vec2(aspect,1.0),
-		    sensitivity: glam::dvec2(1.0/2048.0,1.0/2048.0),
-    		time: 0,
-		}
-	}
-	fn simulate_move_angles(&self, delta: glam::IVec2) -> glam::DVec2 {
-		let mut a=self.angles-self.sensitivity*delta.as_dvec2();
-		a.y=a.y.clamp(-std::f64::consts::PI, std::f64::consts::PI);
-		return a
-	}
-	fn simulate_move_rotation_y(&self, delta_x: i32) -> glam::Mat3 {
-		mat3_from_rotation_y_f64(self.angles.x-self.sensitivity.x*(delta_x as f64))
-	}
-	pub fn proj(&self)->glam::Mat4{
-		perspective_rh(self.fov.x, self.fov.y, 0.5, 1000.0)
-	}
-	pub fn view(&self,pos:glam::Vec3)->glam::Mat4{
-		//f32 good enough for view matrix
-		glam::Mat4::from_translation(pos+self.offset) * glam::Mat4::from_euler(glam::EulerRot::YXZ, self.angles.x as f32, self.angles.y as f32, 0f32)
-	}
-	pub fn set_fov_aspect(&mut self,fov:f32,aspect:f32){
-		self.fov.x=fov*aspect;
-		self.fov.y=fov;
-	}
-}
-
-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
-}
-
 pub struct PhysicsState {
 	pub body: Body,
 	pub hitbox_halfsize: glam::Vec3,
 	pub contacts: std::collections::HashSet::<RelativeCollision>,
 	//pub intersections: Vec<ModelId>,
 	pub models: Vec<ModelPhysics>,
+	//temp
+	pub temp_control_dir: glam::Vec3,
 	//camera must exist in state because wormholes modify the camera, also camera punch
-	pub camera: Camera,
-	pub mouse_interpolation: MouseInterpolationState,
-	pub controls: u32,
+	//pub camera: Camera,
+	//pub mouse_interpolation: MouseInterpolationState,
 	pub time: TIME,
 	pub strafe_tick_num: TIME,
 	pub strafe_tick_den: TIME,
@@ -270,6 +154,7 @@ pub struct PhysicsState {
 	pub walk_accel:  f32,
 	pub gravity: glam::Vec3,
 	pub grounded: bool,
+	pub jump_trying: bool,
 }
 
 #[derive(Debug,Clone,Copy,Hash,Eq,PartialEq)]
@@ -470,6 +355,8 @@ impl PhysicsState {
 	pub fn run(&mut self, time_limit:TIME){
 		//prepare is ommitted - everything is done via instructions.
 		while let Some(instruction) = self.next_instruction(time_limit) {//collect
+			//advance
+			//self.advance_time(instruction.time);
 			//process
 			self.process_instruction(instruction);
 			//write hash lol
@@ -481,16 +368,6 @@ impl PhysicsState {
 		self.time=time;
 	}
 
-	fn set_control(&mut self,control:u32,state:bool){
-		self.controls=if state{self.controls|control}else{self.controls&!control};
-	}
-	fn jump(&mut self){
-		self.grounded=false;//do I need this?
-		let mut v=self.body.velocity+glam::Vec3::new(0.0,0.715588/2.0*100.0,0.0);
-		self.contact_constrain_velocity(&mut v);
-		self.body.velocity=v;
-	}
-
 	fn contact_constrain_velocity(&self,velocity:&mut glam::Vec3){
 		for contact in self.contacts.iter() {
 			let n=contact.normal(&self.models);
@@ -509,6 +386,7 @@ impl PhysicsState {
 			}
 		}
 	}
+
 	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,
@@ -548,31 +426,6 @@ impl PhysicsState {
 	// 	});
 	// }
 
-	fn refresh_walk_target(&mut self){
-		//calculate acceleration yada yada
-		if self.grounded{
-			let mut v=self.walk.target_velocity;
-			self.contact_constrain_velocity(&mut v);
-			let mut target_diff=v-self.body.velocity;
-			target_diff.y=0f32;
-			if target_diff==glam::Vec3::ZERO{
-				let mut a=glam::Vec3::ZERO;
-				self.contact_constrain_acceleration(&mut a);
-				self.body.acceleration=a;
-				self.walk.state=WalkEnum::Reached;
-			}else{
-				let accel=self.walk_accel.min(self.gravity.length()*self.friction);
-				let time_delta=target_diff.length()/accel;
-				let mut a=target_diff/time_delta;
-				self.contact_constrain_acceleration(&mut a);
-				self.body.acceleration=a;
-				self.walk.target_time=self.body.time+((time_delta as f64)*1_000_000_000f64) as TIME;
-				self.walk.state=WalkEnum::Transient;
-			}
-		}else{
-			self.walk.state=WalkEnum::Reached;//there is no walk target while not grounded
-		}
-	}
 	fn next_walk_instruction(&self) -> Option<TimedInstruction<PhysicsInstruction>> {
 		//check if you have a valid walk state and create an instruction
 		if self.grounded{
@@ -581,6 +434,10 @@ impl PhysicsState {
 					time:self.walk.target_time,
 					instruction:PhysicsInstruction::ReachWalkTargetVelocity
 				}),
+				WalkEnum::Invalid=>Some(TimedInstruction{
+					time:self.time,
+					instruction:PhysicsInstruction::RefreshWalkTarget,
+				}),
 				WalkEnum::Reached=>None,
 			}
 		}else{
@@ -896,19 +753,30 @@ impl crate::instruction::InstructionConsumer<PhysicsInstruction> for PhysicsStat
 	fn process_instruction(&mut self, ins:TimedInstruction<PhysicsInstruction>) {
 		match &ins.instruction {
 		    PhysicsInstruction::StrafeTick => (),
-		    PhysicsInstruction::Input(InputInstruction::MoveMouse(_)) => (),
 		    _=>println!("{:?}",ins),
 		}
 		//selectively update body
 		match &ins.instruction {
-		    PhysicsInstruction::Input(InputInstruction::MoveMouse(_)) => (),//dodge time for mouse movement
-    		PhysicsInstruction::Input(_)
+		    PhysicsInstruction::SetWalkTargetVelocity(_)
+		    |PhysicsInstruction::SetPosition(_)
+		    |PhysicsInstruction::SetControlDir(_) => self.time=ins.time,//TODO: queue instructions
+		    PhysicsInstruction::RefreshWalkTarget
 		    |PhysicsInstruction::ReachWalkTargetVelocity
 		    |PhysicsInstruction::CollisionStart(_)
 		    |PhysicsInstruction::CollisionEnd(_)
-		    |PhysicsInstruction::StrafeTick => self.advance_time(ins.time),
+		    |PhysicsInstruction::StrafeTick
+		    |PhysicsInstruction::Jump => self.advance_time(ins.time),
 		}
 		match ins.instruction {
+			PhysicsInstruction::SetPosition(position)=>{
+				//temp
+				self.body.position=position;
+				//manual clear //for c in self.contacts{process_instruction(CollisionEnd(c))}
+				self.contacts.clear();
+				self.body.acceleration=self.gravity;
+				self.walk.state=WalkEnum::Reached;
+				self.grounded=false;
+			}
 			PhysicsInstruction::CollisionStart(c) => {
 				//check ground
 				match &c.face {
@@ -923,16 +791,14 @@ impl crate::instruction::InstructionConsumer<PhysicsInstruction> for PhysicsStat
 				let mut v=self.body.velocity;
 				self.contact_constrain_velocity(&mut v);
 				self.body.velocity=v;
-				if self.grounded&&self.controls&CONTROL_JUMP!=0{
-					self.jump();
-				}
-				self.refresh_walk_target();
+				self.walk.state=WalkEnum::Invalid;
 			},
 			PhysicsInstruction::CollisionEnd(c) => {
 			    self.contacts.remove(&c);//remove contact before calling contact_constrain_acceleration
 				let mut a=self.gravity;
 				self.contact_constrain_acceleration(&mut a);
 				self.body.acceleration=a;
+				self.walk.state=WalkEnum::Invalid;
 				//check ground
 				match &c.face {
 			        AabbFace::Top => {
@@ -940,18 +806,27 @@ impl crate::instruction::InstructionConsumer<PhysicsInstruction> for PhysicsStat
 			        },
 			        _ => (),
 			    }
-				self.refresh_walk_target();
+			},
+			PhysicsInstruction::SetControlDir(control_dir)=>{
+				self.temp_control_dir=control_dir;
+				self.walk.state=WalkEnum::Invalid;
 			},
 			PhysicsInstruction::StrafeTick => {
-				let camera_mat=self.camera.simulate_move_rotation_y(self.mouse_interpolation.interpolated_position(self.time).x-self.mouse_interpolation.mouse0.x);
-				let control_dir=camera_mat*get_control_dir(self.controls);
-				let d=self.body.velocity.dot(control_dir);
+				//let control_dir=self.get_control_dir();//this should respect your mouse interpolation settings
+				let d=self.body.velocity.dot(self.temp_control_dir);
 				if d<self.mv {
-					let mut v=self.body.velocity+(self.mv-d)*control_dir;
+					let mut v=self.body.velocity+(self.mv-d)*self.temp_control_dir;
 					self.contact_constrain_velocity(&mut v);
 					self.body.velocity=v;
 				}
 			}
+			PhysicsInstruction::Jump => {
+				self.grounded=false;//do I need this?
+				let mut v=self.body.velocity+glam::Vec3::new(0.0,0.715588/2.0*100.0,0.0);
+				self.contact_constrain_velocity(&mut v);
+				self.body.velocity=v;
+				self.walk.state=WalkEnum::Invalid;
+			},
 			PhysicsInstruction::ReachWalkTargetVelocity => {
 				//precisely set velocity
 				let mut a=glam::Vec3::ZERO;
@@ -962,59 +837,33 @@ impl crate::instruction::InstructionConsumer<PhysicsInstruction> for PhysicsStat
 				self.body.velocity=v;
 				self.walk.state=WalkEnum::Reached;
 			},
-			PhysicsInstruction::Input(input_instruction) => {
-				let mut refresh_walk_target=false;
-				match input_instruction{
-					InputInstruction::MoveMouse(m) => {
-						self.camera.angles=self.camera.simulate_move_angles(self.mouse_interpolation.mouse1-self.mouse_interpolation.mouse0);
-						self.mouse_interpolation.move_mouse(self.time,m);
-						refresh_walk_target=true;
-					},
-					InputInstruction::MoveForward(s) => {
-						self.set_control(CONTROL_MOVEFORWARD,s);
-						refresh_walk_target=true;
-					},
-					InputInstruction::MoveLeft(s) => {
-						self.set_control(CONTROL_MOVELEFT,s);
-						refresh_walk_target=true;
-					},
-					InputInstruction::MoveBack(s) => {
-						self.set_control(CONTROL_MOVEBACK,s);
-						refresh_walk_target=true;
-					},
-					InputInstruction::MoveRight(s) => {
-						self.set_control(CONTROL_MOVERIGHT,s);
-						refresh_walk_target=true;
-					},
-					InputInstruction::MoveUp(s) => {
-						self.set_control(CONTROL_MOVEUP,s);
-						refresh_walk_target=true;
-					},
-					InputInstruction::MoveDown(s) => {
-						self.set_control(CONTROL_MOVEDOWN,s);
-						refresh_walk_target=true;
-					},
-					InputInstruction::Jump(s) => {
-						self.set_control(CONTROL_JUMP,s);
-						refresh_walk_target=true;
-						if self.grounded{
-							self.jump();
-						}
-					},
-					InputInstruction::Zoom(s) => {
-						self.set_control(CONTROL_ZOOM,s);
-					},
-					InputInstruction::Reset => println!("reset"),
-				}
-				//calculate control dir
-				let camera_mat=self.camera.simulate_move_rotation_y(self.mouse_interpolation.interpolated_position(self.time).x-self.mouse_interpolation.mouse0.x);
-				let control_dir=camera_mat*get_control_dir(self.controls);
-				//calculate walk target velocity
-				if refresh_walk_target{
-					self.walk.target_velocity=self.walkspeed*control_dir;
-					self.refresh_walk_target();
+			PhysicsInstruction::RefreshWalkTarget => {
+				//calculate acceleration yada yada
+				if self.grounded{
+					let mut v=self.walk.target_velocity;
+					self.contact_constrain_velocity(&mut v);
+					let mut target_diff=v-self.body.velocity;
+					target_diff.y=0f32;
+					if target_diff==glam::Vec3::ZERO{
+						let mut a=glam::Vec3::ZERO;
+						self.contact_constrain_acceleration(&mut a);
+						self.body.acceleration=a;
+						self.walk.state=WalkEnum::Reached;
+					}else{
+						let accel=self.walk_accel.min(self.gravity.length()*self.friction);
+						let time_delta=target_diff.length()/accel;
+						let mut a=target_diff/time_delta;
+						self.contact_constrain_acceleration(&mut a);
+						self.body.acceleration=a;
+						self.walk.target_time=self.body.time+((time_delta as f64)*1_000_000_000f64) as TIME;
+						self.walk.state=WalkEnum::Transient;
+					}
 				}
 			},
+			PhysicsInstruction::SetWalkTargetVelocity(v) => {
+				self.walk.target_velocity=v;
+				self.walk.state=WalkEnum::Invalid;
+			},
 		}
 	}
 }

src/framework.rs

@@ -1,10 +1,12 @@
 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, DeviceEvent},
+	event::{self, WindowEvent},
 	event_loop::{ControlFlow, EventLoop},
 };
 
@@ -51,8 +53,8 @@ pub trait Example: 'static + Sized {
 		device: &wgpu::Device,
 		queue: &wgpu::Queue,
 	);
-	fn update(&mut self, device: &wgpu::Device, event: WindowEvent);
-	fn device_event(&mut self, event: DeviceEvent);
+	fn update(&mut self, device: &wgpu::Device, queue: &wgpu::Queue, event: WindowEvent);
+	fn move_mouse(&mut self, delta: (f64,f64));
 	fn render(
 		&mut self,
 		view: &wgpu::TextureView,
@@ -179,9 +181,41 @@ async fn setup<E: Example>(title: &str) -> Setup {
 
 		(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!");
+
+	let adapter;
+
+	let optional_features = E::optional_features();
+	let required_features = E::required_features();
+
+	//no helper function smh gotta write it myself
+	let adapters = instance.enumerate_adapters(backends);
+
+	let mut chosen_adapter = None;
+	let mut chosen_adapter_score=0;
+	for adapter in adapters {
+		if !adapter.is_surface_supported(&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!");
+	}
 
 	#[cfg(not(target_arch = "wasm32"))]
 	{
@@ -189,15 +223,6 @@ async fn setup<E: Example>(title: &str) -> Setup {
 		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!(
@@ -221,7 +246,7 @@ async fn setup<E: Example>(title: &str) -> Setup {
 		.request_device(
 			&wgpu::DeviceDescriptor {
 				label: None,
-				features: (optional_features & adapter_features) | required_features,
+				features: (optional_features & adapter.features()) | required_features,
 				limits: needed_limits,
 			},
 			trace_dir.ok().as_ref().map(std::path::Path::new),
@@ -344,14 +369,17 @@ fn start<E: Example>(
 					println!("{:#?}", instance.generate_report());
 				}
 				_ => {
-					example.update(&device,event);
+					example.update(&device,&queue,event);
 				}
 			},
 			event::Event::DeviceEvent {
-				event,
+				event:
+					winit::event::DeviceEvent::MouseMotion {
+						delta,
+					},
 				..
 			} => {
-				example.device_event(event);
+				example.move_mouse(delta);
 			},
 			event::Event::RedrawRequested(_) => {
 

src/lib.rs

@@ -1,5 +0,0 @@
-pub mod framework;
-pub mod body;
-pub mod zeroes;
-pub mod instruction;
-pub mod load_roblox;

src/load_roblox.rs

@@ -1,3 +1,9 @@
+use std::todo;
+
+use crate::model::{ModelData,ModelInstance};
+
+use crate::primitives;
+
 fn class_is_a(class: &str, superclass: &str) -> bool {
 	if class==superclass {
 		return true
@@ -10,18 +16,125 @@ fn class_is_a(class: &str, superclass: &str) -> bool {
 	}
 	return false
 }
-pub fn get_objects<R: std::io::Read>(buf_thing: R, superclass: &str) -> Result<std::vec::Vec<rbx_dom_weak::Instance>, Box<dyn std::error::Error>> {
-	// Using buffered I/O is recommended with rbx_binary
-	let dom = rbx_binary::from_reader(buf_thing)?;
-
-	let mut objects = std::vec::Vec::<rbx_dom_weak::Instance>::new();
-	//move matching instances into objects
-	let (_,mut instances) = dom.into_raw();
-	for (_,instance) in instances.drain() {
-		if class_is_a(instance.class.as_str(), superclass) {
-			objects.push(instance);
+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){
+	for &referent in instance.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
+			}
+			recursive_collect_superclass(objects,dom,c,superclass);
 		}
 	}
-
-	return Ok(objects)
+}
+fn get_texture_refs(dom:&rbx_dom_weak::WeakDom) -> Vec<rbx_dom_weak::types::Ref>{
+	let mut objects = std::vec::Vec::new();
+	recursive_collect_superclass(&mut objects, dom, dom.root(),"Decal");
+	//get ids
+	//clear vec
+	//next class
+	objects
+}
+
+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=regex::Regex::new(r"(\d+)$").unwrap();
+        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)
+    }
+}
+pub fn generate_modeldatas_roblox(dom:rbx_dom_weak::WeakDom) -> Result<(Vec<ModelData>,Vec<String>,glam::Vec3), Box<dyn std::error::Error>>{
+	//ModelData includes texture dds
+	let mut spawn_point=glam::Vec3::ZERO;
+
+	//TODO: generate unit Block, Wedge, etc. after based on part shape lists
+	let mut modeldatas=crate::model::generate_modeldatas(primitives::the_unit_cube_lol(),ModelData::COLOR_FLOATS_WHITE);
+	let unit_cube_modeldata=modeldatas[0].clone();
+
+	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 = std::vec::Vec::new();
+	let mut temp_objects = std::vec::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::Float32(transparency)),
+					Some(rbx_dom_weak::types::Variant::Color3uint8(color3)),
+					Some(rbx_dom_weak::types::Variant::Enum(shape)),
+				) = (
+					object.properties.get("CFrame"),
+					object.properties.get("Size"),
+					object.properties.get("Transparency"),
+					object.properties.get("Color"),
+					object.properties.get("Shape"),//this will also skip unions
+				)
+			{
+				let model_instance=ModelInstance {
+						transform:glam::Mat4::from_translation(
+								glam::Vec3::new(cf.position.x,cf.position.y,cf.position.z)
+							)
+							* glam::Mat4::from_mat3(
+								glam::Mat3::from_cols(
+									glam::Vec3::new(cf.orientation.x.x,cf.orientation.y.x,cf.orientation.z.x),
+									glam::Vec3::new(cf.orientation.x.y,cf.orientation.y.y,cf.orientation.z.y),
+									glam::Vec3::new(cf.orientation.x.z,cf.orientation.y.z,cf.orientation.z.z),
+								),
+							)
+							* glam::Mat4::from_scale(
+								glam::Vec3::new(size.x,size.y,size.z)/2.0
+							),
+						color: glam::vec4(color3.r as f32/255f32, color3.g as f32/255f32, color3.b as f32/255f32, 1.0-*transparency),
+					};
+				if object.name=="MapStart"{
+					spawn_point=glam::Vec4Swizzles::xyz(model_instance.transform*glam::Vec3::Y.extend(1.0))+glam::vec3(0.0,2.5,0.0);
+					println!("Found MapStart{:?}",spawn_point);
+				}
+				if *transparency==1.0||shape.to_u32()!=1 {
+					continue;
+				}
+				temp_objects.clear();
+				recursive_collect_superclass(&mut temp_objects, &dom, object,"Decal");
+
+				let mut i_can_only_load_one_texture_per_model=None;
+				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)) = decal.properties.get("Texture") {
+							if let Ok(asset_id)=content.clone().into_string().parse::<RobloxAssetId>(){
+								if let Some(&texture_id)=texture_id_from_asset_id.get(&asset_id.0){
+									i_can_only_load_one_texture_per_model=Some(texture_id);
+								}else{
+									let texture_id=asset_id_from_texture_id.len();
+									texture_id_from_asset_id.insert(asset_id.0,texture_id as u32);
+									asset_id_from_texture_id.push(asset_id.0);
+									//make new model
+									let mut unit_cube_texture=unit_cube_modeldata.clone();
+									unit_cube_texture.texture=Some(texture_id as u32);
+									modeldatas.push(unit_cube_texture);
+								}
+							}
+						}
+					}
+				}
+				match i_can_only_load_one_texture_per_model{
+					//push to existing texture model
+					Some(texture_id)=>modeldatas[(texture_id+1) as usize].instances.push(model_instance),
+					//push instance to big unit cube in the sky
+					None=>modeldatas[0].instances.push(model_instance),
+				}
+			}
+		}
+	}
+	Ok((modeldatas,asset_id_from_texture_id.iter().map(|t|t.to_string()).collect(),spawn_point))
 }

src/main.rs

@@ -1,40 +1,20 @@
-use bytemuck::{Pod, Zeroable};
-use strafe_client::{instruction::{TimedInstruction, InstructionConsumer},body::{InputInstruction, PhysicsInstruction}};
 use std::{borrow::Cow, time::Instant};
 use wgpu::{util::DeviceExt, AstcBlock, AstcChannel};
+use model::{Vertex,ModelData,ModelInstance};
 
-const IMAGE_SIZE: u32 = 128;
-
-#[derive(Clone, Copy, Pod, Zeroable)]
-#[repr(C)]
-struct Vertex {
-	pos: [f32; 3],
-	texture: [f32; 2],
-	normal: [f32; 3],
-	color: [f32; 4],
-}
+mod body;
+mod model;
+mod zeroes;
+mod framework;
+mod primitives;
+mod instruction;
+mod load_roblox;
 
 struct Entity {
 	index_count: u32,
 	index_buf: wgpu::Buffer,
 }
 
-struct ModelInstance {
-	transform: glam::Mat4,
-	color: glam::Vec4,
-}
-
-struct ModelData {
-	instances: Vec<ModelInstance>,
-	vertices: Vec<Vertex>,
-	entities: Vec<Vec<u16>>,
-}
-
-impl ModelData {
-	const COLOR_FLOATS_WHITE: [f32;4] = [1.0,1.0,1.0,1.0];
-	const COLOR_VEC4_WHITE: glam::Vec4 = glam::vec4(1.0,1.0,1.0,1.0);
-}
-
 struct ModelGraphics {
 	instances: Vec<ModelInstance>,
 	vertex_buf: wgpu::Buffer,
@@ -43,6 +23,86 @@ struct ModelGraphics {
 	model_buf: wgpu::Buffer,
 }
 
+// Note: we use the Y=up coordinate space in this example.
+struct Camera {
+	screen_size: (u32, u32),
+	offset: glam::Vec3,
+	fov: f32,
+	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
+		};
+		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 GraphicsSamplers{
 	repeat: wgpu::Sampler,
 }
@@ -63,8 +123,8 @@ pub struct GraphicsPipelines {
 
 pub struct GraphicsData {
 	start_time: std::time::Instant,
-	screen_size: (u32, u32),
-	physics: strafe_client::body::PhysicsState,
+	camera: Camera,
+	physics: body::PhysicsState,
 	pipelines: GraphicsPipelines,
 	bind_groups: GraphicsBindGroups,
 	bind_group_layouts: GraphicsBindGroupLayouts,
@@ -74,7 +134,6 @@ pub struct GraphicsData {
 	models: Vec<ModelGraphics>,
 	depth_view: wgpu::TextureView,
 	staging_belt: wgpu::util::StagingBelt,
-	handy_unit_cube: obj::ObjData,
 }
 
 impl GraphicsData {
@@ -102,109 +161,127 @@ impl GraphicsData {
 		depth_texture.create_view(&wgpu::TextureViewDescriptor::default())
 	}
 
-	fn generate_modeldatas_roblox<R: std::io::Read>(&self,input:R) -> Vec<ModelData>{
-		let mut modeldatas=generate_modeldatas(self.handy_unit_cube.clone(),ModelData::COLOR_FLOATS_WHITE);
-		match strafe_client::load_roblox::get_objects(input, "BasePart") {
-			Ok(objects)=>{
-				for object in objects.iter() {
-					if let (
-							Some(rbx_dom_weak::types::Variant::CFrame(cf)),
-							Some(rbx_dom_weak::types::Variant::Vector3(size)),
-							Some(rbx_dom_weak::types::Variant::Float32(transparency)),
-							Some(rbx_dom_weak::types::Variant::Color3uint8(color3)),
-							Some(rbx_dom_weak::types::Variant::Enum(shape)),
-						) = (
-							object.properties.get("CFrame"),
-							object.properties.get("Size"),
-							object.properties.get("Transparency"),
-							object.properties.get("Color"),
-							object.properties.get("Shape"),//this will also skip unions
-						)
-					{
-						if *transparency==1.0||shape.to_u32()!=1 {
-							continue;
-						}
-						modeldatas[0].instances.push(ModelInstance {
-							transform:glam::Mat4::from_translation(
-									glam::Vec3::new(cf.position.x,cf.position.y,cf.position.z)
-								)
-								* glam::Mat4::from_mat3(
-									glam::Mat3::from_cols(
-										glam::Vec3::new(cf.orientation.x.x,cf.orientation.y.x,cf.orientation.z.x),
-										glam::Vec3::new(cf.orientation.x.y,cf.orientation.y.y,cf.orientation.z.y),
-										glam::Vec3::new(cf.orientation.x.z,cf.orientation.y.z,cf.orientation.z.z),
-									),
-								)
-								* glam::Mat4::from_scale(
-									glam::Vec3::new(size.x,size.y,size.z)/2.0
-								),
-							color: glam::vec4(color3.r as f32/255f32, color3.g as f32/255f32, color3.b as f32/255f32, 1.0-*transparency),
-						})
-					}
-				}
-			},
-			Err(e) => println!("lmao err {:?}", e),
-		}
-		modeldatas
-	}
 	fn generate_model_physics(&mut self,modeldatas:&Vec<ModelData>){
 		self.physics.models.append(&mut modeldatas.iter().map(|m|
 			//make aabb and run vertices to get realistic bounds
-			m.instances.iter().map(|t|strafe_client::body::ModelPhysics::new(t.transform))
+			m.instances.iter().map(|t|body::ModelPhysics::new(t.transform))
 		).flatten().collect());
+		println!("Physics Objects: {}",self.physics.models.len());
 	}
-	fn generate_model_graphics(&mut self,device:&wgpu::Device,mut modeldatas:Vec<ModelData>){
+	fn generate_model_graphics(&mut self,device:&wgpu::Device,queue:&wgpu::Queue,mut modeldatas:Vec<ModelData>,textures:Vec<String>){
+		//generate texture view per texture
+
+		//idk how to do this gooder lol
+		let mut double_map=std::collections::HashMap::<u32,u32>::new();
+		let mut texture_views:Vec<wgpu::TextureView>=Vec::with_capacity(textures.len());
+		for (i,t) in textures.iter().enumerate(){
+			if let Ok(mut file) = std::fs::File::open(std::path::Path::new(&format!("textures/{}.dds",t))){
+				let image = ddsfile::Dds::read(&mut file).unwrap();
+
+				let size = wgpu::Extent3d {
+					width: image.get_width()/4*4,//floor(w,4), should be ceil(w,4)
+					height: image.get_height()/4*4,
+					depth_or_array_layers: 1,
+				};
+
+				let layer_size = wgpu::Extent3d {
+					depth_or_array_layers: 1,
+					..size
+				};
+				let max_mips = layer_size.max_mips(wgpu::TextureDimension::D2);
+
+				let texture = device.create_texture_with_data(
+					queue,
+					&wgpu::TextureDescriptor {
+						size,
+						mip_level_count: max_mips,
+						sample_count: 1,
+						dimension: wgpu::TextureDimension::D2,
+						format: wgpu::TextureFormat::Bc7RgbaUnorm,
+						usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST,
+						label: Some(format!("Texture{}",i).as_str()),
+						view_formats: &[],
+					},
+					&image.data,
+				);
+
+				double_map.insert(i as u32, texture_views.len() as u32);
+				texture_views.push(texture.create_view(&wgpu::TextureViewDescriptor {
+					label: Some(format!("Texture{} View",i).as_str()),
+					dimension: Some(wgpu::TextureViewDimension::D2),
+					..wgpu::TextureViewDescriptor::default()
+				}));
+			}
+		}
 		//drain the modeldata vec so entities can be /moved/ to models.entities
+		let mut instance_count=0;
 		self.models.reserve(modeldatas.len());
 		for (i,modeldata) in modeldatas.drain(..).enumerate() {
-			let model_uniforms = get_instances_buffer_data(&modeldata.instances);
-			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::STORAGE | wgpu::BufferUsages::COPY_DST,
-			});
-			let model_bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
-				layout: &self.bind_group_layouts.model,
-				entries: &[
-					wgpu::BindGroupEntry {
-						binding: 0,
-						resource: model_buf.as_entire_binding(),
+			let n_instances=modeldata.instances.len();
+			if 0<n_instances{
+				let model_uniforms = get_instances_buffer_data(&modeldata.instances);
+				let model_buf = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
+					label: Some(format!("Model{} Buf",i).as_str()),
+					contents: bytemuck::cast_slice(&model_uniforms),
+					usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
+				});
+				let texture_view=match modeldata.texture{
+					Some(texture_id)=>{
+						match double_map.get(&texture_id){
+							Some(&mapped_texture_id)=>&texture_views[mapped_texture_id as usize],
+							None=>&self.temp_squid_texture_view,
+						}
 					},
-					wgpu::BindGroupEntry {
-						binding: 1,
-						resource: wgpu::BindingResource::TextureView(&self.temp_squid_texture_view),
-					},
-					wgpu::BindGroupEntry {
-						binding: 2,
-						resource: wgpu::BindingResource::Sampler(&self.samplers.repeat),
-					},
-				],
-				label: Some(format!("ModelGraphics{}",i).as_str()),
-			});
-			let vertex_buf = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
-				label: Some("Vertex"),
-				contents: bytemuck::cast_slice(&modeldata.vertices),
-				usage: wgpu::BufferUsages::VERTEX,
-			});
-			//all of these are being moved here
-			self.models.push(ModelGraphics{
-				instances:modeldata.instances,
-				vertex_buf,
-				entities: modeldata.entities.iter().map(|indices|{
-					let index_buf = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
-						label: Some("Index"),
-						contents: bytemuck::cast_slice(&indices),
-						usage: wgpu::BufferUsages::INDEX,
-					});
-					Entity {
-						index_buf,
-						index_count: indices.len() as u32,
-					}
-				}).collect(),
-				bind_group: model_bind_group,
-				model_buf,
-			})
+					None=>&self.temp_squid_texture_view,
+				};
+				let model_bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
+					layout: &self.bind_group_layouts.model,
+					entries: &[
+						wgpu::BindGroupEntry {
+							binding: 0,
+							resource: model_buf.as_entire_binding(),
+						},
+						wgpu::BindGroupEntry {
+							binding: 1,
+							resource: wgpu::BindingResource::TextureView(texture_view),
+						},
+						wgpu::BindGroupEntry {
+							binding: 2,
+							resource: wgpu::BindingResource::Sampler(&self.samplers.repeat),
+						},
+					],
+					label: Some(format!("Model{} Bind Group",i).as_str()),
+				});
+				let vertex_buf = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
+					label: Some("Vertex"),
+					contents: bytemuck::cast_slice(&modeldata.vertices),
+					usage: wgpu::BufferUsages::VERTEX,
+				});
+				//all of these are being moved here
+				instance_count+=n_instances;
+				self.models.push(ModelGraphics{
+					instances:modeldata.instances,
+					vertex_buf,
+					entities: modeldata.entities.iter().map(|indices|{
+						let index_buf = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
+							label: Some("Index"),
+							contents: bytemuck::cast_slice(&indices),
+							usage: wgpu::BufferUsages::INDEX,
+						});
+						Entity {
+							index_buf,
+							index_count: indices.len() as u32,
+						}
+					}).collect(),
+					bind_group: model_bind_group,
+					model_buf,
+				});
+			}else{
+				println!("WARNING: Model{} has 0 instances",i);
+			}
 		}
+		println!("Graphics Objects: {}",self.models.len());
+		println!("Graphics Instances: {}",instance_count);
 	}
 }
 
@@ -220,71 +297,12 @@ fn get_instances_buffer_data(instances:&Vec<ModelInstance>) -> Vec<f32> {
 	raw
 }
 
-fn generate_modeldatas(data:obj::ObjData,color:[f32;4]) -> Vec<ModelData>{
-	let mut modeldatas=Vec::new();
-	let mut vertices = Vec::new();
-	let mut vertex_index = std::collections::HashMap::<obj::IndexTuple,u16>::new();
-	for object in data.objects {
-		vertices.clear();
-		vertex_index.clear();
-		let mut entities = Vec::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);
-						}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()],
-								color,
-							});
-							vertex_index.insert(vert,i);
-							indices.push(i);
-						}
-					}
-				}
-			}
-			entities.push(indices);
-		}
-		modeldatas.push(ModelData {
-			instances: Vec::new(),
-			vertices:vertices.clone(),
-			entities,
-		});
-	}
-	modeldatas
-}
-
-
-fn to_uniform_data(camera: &strafe_client::body::Camera, pos: glam::Vec3) -> [f32; 16 * 3 + 4] {
-	let proj=camera.proj();
-	let proj_inv = proj.inverse();
-	let view=camera.view(pos);
-	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
-}
-
-impl strafe_client::framework::Example for GraphicsData {
+impl framework::Example for GraphicsData {
 	fn optional_features() -> wgpu::Features {
 		wgpu::Features::TEXTURE_COMPRESSION_ASTC
 			| wgpu::Features::TEXTURE_COMPRESSION_ETC2
 			| wgpu::Features::TEXTURE_COMPRESSION_BC
 	}
-	fn required_features() -> wgpu::Features {
-		wgpu::Features::STORAGE_RESOURCE_BINDING_ARRAY
-	}
 	fn required_limits() -> wgpu::Limits {
 		wgpu::Limits::default() //framework.rs was using goofy limits that caused me a multi-day headache
 	}
@@ -294,85 +312,12 @@ impl strafe_client::framework::Example for GraphicsData {
 		device: &wgpu::Device,
 		queue: &wgpu::Queue,
 	) -> Self {
-		let unit_cube=obj::ObjData{
-			position: vec![
-				[-1.,-1., 1.],//left bottom back
-				[ 1.,-1., 1.],//right bottom back
-				[ 1., 1., 1.],//right top back
-				[-1., 1., 1.],//left top back
-				[-1., 1.,-1.],//left top front
-				[ 1., 1.,-1.],//right top front
-				[ 1.,-1.,-1.],//right bottom front
-				[-1.,-1.,-1.],//left bottom front
-			],
-			texture: vec![[0.0,0.0],[1.0,0.0],[1.0,1.0],[0.0,1.0]],
-			normal: vec![
-				[1.,0.,0.],//AabbFace::Right
-				[0.,1.,0.],//AabbFace::Top
-				[0.,0.,1.],//AabbFace::Back
-				[-1.,0.,0.],//AabbFace::Left
-				[0.,-1.,0.],//AabbFace::Bottom
-				[0.,0.,-1.],//AabbFace::Front
-			],
-			objects: vec![obj::Object{
-				name: "Unit Cube".to_owned(),
-				groups: vec![obj::Group{
-					name: "Cube Vertices".to_owned(),
-					index: 0,
-					material: None,
-					polys: vec![
-						// back (0, 0, 1)
-						obj::SimplePolygon(vec![
-							obj::IndexTuple(0,Some(0),Some(2)),
-							obj::IndexTuple(1,Some(1),Some(2)),
-							obj::IndexTuple(2,Some(2),Some(2)),
-							obj::IndexTuple(3,Some(3),Some(2)),
-						]),
-						// front (0, 0,-1)
-						obj::SimplePolygon(vec![
-							obj::IndexTuple(4,Some(0),Some(5)),
-							obj::IndexTuple(5,Some(1),Some(5)),
-							obj::IndexTuple(6,Some(2),Some(5)),
-							obj::IndexTuple(7,Some(3),Some(5)),
-						]),
-						// right (1, 0, 0)
-						obj::SimplePolygon(vec![
-							obj::IndexTuple(6,Some(0),Some(0)),
-							obj::IndexTuple(5,Some(1),Some(0)),
-							obj::IndexTuple(2,Some(2),Some(0)),
-							obj::IndexTuple(1,Some(3),Some(0)),
-						]),
-						// left (-1, 0, 0)
-						obj::SimplePolygon(vec![
-							obj::IndexTuple(0,Some(0),Some(3)),
-							obj::IndexTuple(3,Some(1),Some(3)),
-							obj::IndexTuple(4,Some(2),Some(3)),
-							obj::IndexTuple(7,Some(3),Some(3)),
-						]),
-						// top (0, 1, 0)
-						obj::SimplePolygon(vec![
-							obj::IndexTuple(5,Some(1),Some(1)),
-							obj::IndexTuple(4,Some(0),Some(1)),
-							obj::IndexTuple(3,Some(3),Some(1)),
-							obj::IndexTuple(2,Some(2),Some(1)),
-						]),
-						// bottom (0,-1, 0)
-						obj::SimplePolygon(vec![
-							obj::IndexTuple(1,Some(1),Some(4)),
-							obj::IndexTuple(0,Some(0),Some(4)),
-							obj::IndexTuple(7,Some(3),Some(4)),
-							obj::IndexTuple(6,Some(2),Some(4)),
-						]),
-					],
-				}]
-			}],
-			material_libs: Vec::new(),
-		};
+		let unit_cube=primitives::the_unit_cube_lol();
 		let mut modeldatas = Vec::<ModelData>::new();
-		modeldatas.append(&mut generate_modeldatas(obj::ObjData::load_buf(&include_bytes!("../models/teslacyberv3.0.obj")[..]).unwrap(),ModelData::COLOR_FLOATS_WHITE));
-		modeldatas.append(&mut generate_modeldatas(obj::ObjData::load_buf(&include_bytes!("../models/suzanne.obj")[..]).unwrap(),ModelData::COLOR_FLOATS_WHITE));
-		modeldatas.append(&mut generate_modeldatas(obj::ObjData::load_buf(&include_bytes!("../models/teapot.obj")[..]).unwrap(),ModelData::COLOR_FLOATS_WHITE));
-		modeldatas.append(&mut generate_modeldatas(unit_cube.clone(),ModelData::COLOR_FLOATS_WHITE));
+		modeldatas.append(&mut model::generate_modeldatas(obj::ObjData::load_buf(&include_bytes!("../models/teslacyberv3.0.obj")[..]).unwrap(),ModelData::COLOR_FLOATS_WHITE));
+		modeldatas.append(&mut model::generate_modeldatas(obj::ObjData::load_buf(&include_bytes!("../models/suzanne.obj")[..]).unwrap(),ModelData::COLOR_FLOATS_WHITE));
+		modeldatas.append(&mut model::generate_modeldatas(obj::ObjData::load_buf(&include_bytes!("../models/teapot.obj")[..]).unwrap(),ModelData::COLOR_FLOATS_WHITE));
+		modeldatas.append(&mut model::generate_modeldatas(unit_cube.clone(),ModelData::COLOR_FLOATS_WHITE));
 		println!("models.len = {:?}", modeldatas.len());
 		modeldatas[0].instances.push(ModelInstance{
 			transform:glam::Mat4::from_translation(glam::vec3(10.,0.,-10.)),
@@ -449,7 +394,7 @@ impl strafe_client::framework::Example for GraphicsData {
 					binding: 0,
 					visibility: wgpu::ShaderStages::VERTEX,
 					ty: wgpu::BindingType::Buffer {
-						ty: wgpu::BufferBindingType::Storage { read_only: true },
+						ty: wgpu::BufferBindingType::Uniform,
 						has_dynamic_offset: false,
 						min_binding_size: None,
 					},
@@ -501,8 +446,16 @@ impl strafe_client::framework::Example for GraphicsData {
 			source: wgpu::ShaderSource::Wgsl(Cow::Borrowed(include_str!("shader.wgsl"))),
 		});
 
-		let physics = strafe_client::body::PhysicsState {
-			body: strafe_client::body::Body::with_pva(glam::vec3(0.0,50.0,0.0),glam::vec3(0.0,0.0,0.0),glam::vec3(0.0,-100.0,0.0)),
+		let camera = Camera {
+			screen_size: (config.width, config.height),
+			offset: glam::Vec3::new(0.0,4.5-2.5,0.0),
+			fov: 1.0, //fov_slope = tan(fov_y/2)
+			pitch: 0.0,
+			yaw: 0.0,
+			controls:0,
+		};
+		let physics = body::PhysicsState {
+			body: body::Body::with_pva(glam::vec3(0.0,50.0,0.0),glam::vec3(0.0,0.0,0.0),glam::vec3(0.0,-100.0,0.0)),
 			time: 0,
 			tick: 0,
 			strafe_tick_num: 100,//100t
@@ -512,14 +465,13 @@ impl strafe_client::framework::Example for GraphicsData {
 			walk_accel: 90.0,
 			mv: 2.7,
 			grounded: false,
+			jump_trying: false,
+			temp_control_dir: glam::Vec3::ZERO,
 			walkspeed: 18.0,
 			contacts: std::collections::HashSet::new(),
-			models: Vec::new(),
-			walk: strafe_client::body::WalkState::new(),
-			hitbox_halfsize: glam::vec3(1.0,2.5,1.0),
-			camera: strafe_client::body::Camera::from_offset(glam::vec3(0.0,4.5-2.5,0.0),(config.width as f32)/(config.height as f32)),
-			mouse_interpolation: strafe_client::body::MouseInterpolationState::new(),
-			controls: 0,
+    		models: Vec::new(),
+    		walk: body::WalkState::new(),
+    		hitbox_halfsize: glam::vec3(1.0,2.5,1.0),
 		};
 
 		//load textures
@@ -543,9 +495,22 @@ impl strafe_client::framework::Example for GraphicsData {
 				wgpu::TextureFormat::Bgra8UnormSrgb
 			};
 
+			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 skybox_image = ddsfile::Dds::read(&mut std::io::Cursor::new(bytes)).unwrap();
+
 			let size = wgpu::Extent3d {
-				width: IMAGE_SIZE,
-				height: IMAGE_SIZE,
+				width: skybox_image.get_width(),
+				height: skybox_image.get_height(),
 				depth_or_array_layers: 6,
 			};
 
@@ -558,24 +523,11 @@ impl strafe_client::framework::Example for GraphicsData {
 			log::debug!(
 				"Copying {:?} skybox images of size {}, {}, 6 with {} mips to gpu",
 				skybox_format,
-				IMAGE_SIZE,
-				IMAGE_SIZE,
+				size.width,
+				size.height,
 				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 skybox_image = ddsfile::Dds::read(&mut std::io::Cursor::new(&bytes)).unwrap();
-
 			let skybox_texture = device.create_texture_with_data(
 				queue,
 				&wgpu::TextureDescriptor {
@@ -600,9 +552,9 @@ impl strafe_client::framework::Example for GraphicsData {
 
 		//squid
 		let squid_texture_view={
-			let bytes = &include_bytes!("../images/squid.dds")[..];
+			let bytes = include_bytes!("../images/squid.dds");
 
-			let image = ddsfile::Dds::read(&mut std::io::Cursor::new(&bytes)).unwrap();
+			let image = ddsfile::Dds::read(&mut std::io::Cursor::new(bytes)).unwrap();
 
 			let size = wgpu::Extent3d {
 				width: image.get_width(),
@@ -708,7 +660,7 @@ impl strafe_client::framework::Example for GraphicsData {
 			multiview: None,
 		});
 
-		let camera_uniforms = to_uniform_data(&physics.camera,physics.body.extrapolated_position(0));
+		let camera_uniforms = camera.to_uniform_data(physics.body.extrapolated_position(0));
 		let camera_buf = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
 			label: Some("Camera"),
 			contents: bytemuck::cast_slice(&camera_uniforms),
@@ -742,9 +694,8 @@ impl strafe_client::framework::Example for GraphicsData {
 		let depth_view = Self::create_depth_texture(config, device);
 
 		let mut graphics=GraphicsData {
-			handy_unit_cube:unit_cube,
 			start_time: Instant::now(),
-			screen_size: (config.width,config.height),
+			camera,
 			physics,
 			pipelines:GraphicsPipelines{
 				skybox:sky_pipeline,
@@ -764,91 +715,121 @@ impl strafe_client::framework::Example for GraphicsData {
 		};
 
 		graphics.generate_model_physics(&modeldatas);
-		graphics.generate_model_graphics(&device,modeldatas);
+		graphics.generate_model_graphics(&device,&queue,modeldatas,Vec::new());
 
 		return graphics;
 	}
 
 	#[allow(clippy::single_match)]
-	fn update(&mut self, device: &wgpu::Device, event: winit::event::WindowEvent) {
+	fn update(&mut self, device: &wgpu::Device, queue: &wgpu::Queue, event: winit::event::WindowEvent) {
+		//nothing atm
 		match event {
 			winit::event::WindowEvent::DroppedFile(path) => {
 				println!("opening file: {:?}", &path);
 				//oh boy! let's load the map!
 				if let Ok(file)=std::fs::File::open(path){
-					let input = std::io::BufReader::new(file);
-					let modeldatas=self.generate_modeldatas_roblox(input);
-					//if generate_modeldatas succeeds, clear the previous ones
-					self.models.clear();
-					self.physics.models.clear();
-					self.generate_model_physics(&modeldatas);
-					self.generate_model_graphics(device,modeldatas);
+					let mut input = std::io::BufReader::new(file);
+					let mut first_8=[0u8;8];
+					//.rbxm roblox binary = "<roblox!"
+					//.rbxmx roblox xml = "<roblox "
+					//.bsp = "VBSP"
+					//.vmf = 
+					//.snf = "SNMF"
+					//.snf = "SNBF"
+					if let (Ok(()),Ok(()))=(std::io::Read::read_exact(&mut input, &mut first_8),std::io::Seek::rewind(&mut input)){
+						//
+						if let Some(Ok((modeldatas,textures,spawn_point)))={
+							if &first_8==b"<roblox!"{
+								if let Ok(dom) = rbx_binary::from_reader(input){
+									Some(load_roblox::generate_modeldatas_roblox(dom))
+								}else{
+									None
+								}
+							}else if &first_8==b"<roblox "{
+								if let Ok(dom) = rbx_xml::from_reader(input,rbx_xml::DecodeOptions::default()){
+									Some(load_roblox::generate_modeldatas_roblox(dom))
+								}else{
+									None
+								}
+							//}else if &first_8[0..4]==b"VBSP"{
+							//	self.generate_modeldatas_valve(input)
+							}else{
+								None
+							}
+						}{
+							//if generate_modeldatas succeeds, clear the previous ones
+							self.models.clear();
+							self.physics.models.clear();
+							self.generate_model_physics(&modeldatas);
+							self.generate_model_graphics(device,queue,modeldatas,textures);
+							//manual reset
+							let time=self.physics.time;
+							instruction::InstructionConsumer::process_instruction(&mut self.physics, instruction::TimedInstruction{
+								time,
+								instruction: body::PhysicsInstruction::SetPosition(spawn_point),
+							})
+						}else{
+							println!("No modeldatas were generated");
+						}
+					}else{
+						println!("Failed ro read first 8 bytes and seek back to beginning of file.");
+					}
 				}else{
 					println!("Could not open file");
 				}
 			},
-			_=>(),
+			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 device_event(&mut self, event: winit::event::DeviceEvent) {
-		//there's no way this is the best way get a timestamp.
-		let time=self.start_time.elapsed().as_nanos() as i64;
-		match event {
-			winit::event::DeviceEvent::Key(winit::event::KeyboardInput {
-				state,
-				scancode: keycode,
-				..
-			}) => {
-				let s=match state {
-					winit::event::ElementState::Pressed => true,
-					winit::event::ElementState::Released => false,
-				};
-				if let Some(input_instruction)=match keycode {
-					17 => Some(InputInstruction::MoveForward(s)),//W
-					30 => Some(InputInstruction::MoveLeft(s)),//A
-					31 => Some(InputInstruction::MoveBack(s)),//S
-					32 => Some(InputInstruction::MoveRight(s)),//D
-					18 => Some(InputInstruction::MoveUp(s)),//E
-					16 => Some(InputInstruction::MoveDown(s)),//Q
-					57 => Some(InputInstruction::Jump(s)),//Space
-					44 => Some(InputInstruction::Zoom(s)),//Z
-					19 => if s{Some(InputInstruction::Reset)}else{None},//R
-					_ => None,
-				}
-				{
-					self.physics.run(time);
-					self.physics.process_instruction(TimedInstruction{
-						time,
-						instruction:PhysicsInstruction::Input(input_instruction),
-					})
-				}
-			},
-			winit::event::DeviceEvent::MouseMotion {
-			    delta,//these (f64,f64) are integers on my machine
-			} => {
-				//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.
-				self.physics.process_instruction(TimedInstruction{
-					time,
-					instruction:PhysicsInstruction::Input(InputInstruction::MoveMouse(glam::ivec2(delta.0 as i32,delta.1 as i32))),
-				})
-			},
-			winit::event::DeviceEvent::MouseWheel {
-			    delta,
-			} => {
-				println!("mousewheel{:?}",delta);
-				if true{//self.physics.use_scroll
-					self.physics.run(time);
-					self.physics.process_instruction(TimedInstruction{
-						time,
-						instruction:PhysicsInstruction::Input(InputInstruction::Jump(true)),//activates the immediate jump path, but the style modifier prevents controls&CONTROL_JUMP bit from being set to auto jump
-					})
-				}
-			}
-			_=>(),
-		}
+	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(
@@ -858,8 +839,7 @@ impl strafe_client::framework::Example for GraphicsData {
 		_queue: &wgpu::Queue,
 	) {
 		self.depth_view = Self::create_depth_texture(config, device);
-		self.screen_size = (config.width, config.height);
-		self.physics.camera.set_fov_aspect(1.0,(config.width as f32)/(config.height as f32));
+		self.camera.screen_size = (config.width, config.height);
 	}
 
 	fn render(
@@ -867,17 +847,47 @@ impl strafe_client::framework::Example for GraphicsData {
 		view: &wgpu::TextureView,
 		device: &wgpu::Device,
 		queue: &wgpu::Queue,
-		_spawner: &strafe_client::framework::Spawner,
+		_spawner: &framework::Spawner,
 	) {
+		let camera_mat=glam::Mat3::from_rotation_y(self.camera.yaw);
+		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);
 
+		//ALL OF THIS IS TOTALLY WRONG!!!
+		let walk_target_velocity=self.physics.walkspeed*control_dir;
+		//autohop (already pressing spacebar; the signal to begin trying to jump is different)
+		if self.physics.grounded&&walk_target_velocity!=self.physics.walk.target_velocity {
+			instruction::InstructionConsumer::process_instruction(&mut self.physics, instruction::TimedInstruction{
+				time,
+				instruction:body::PhysicsInstruction::SetWalkTargetVelocity(walk_target_velocity)
+			});
+		}
+
+		if control_dir!=self.physics.temp_control_dir {
+			instruction::InstructionConsumer::process_instruction(&mut self.physics, instruction::TimedInstruction{
+				time,
+				instruction:body::PhysicsInstruction::SetControlDir(control_dir)
+			});
+		}
+
+		self.physics.jump_trying=self.camera.controls&CONTROL_JUMP!=0;
+		//autohop (already pressing spacebar; the signal to begin trying to jump is different)
+		if self.physics.grounded&&self.physics.jump_trying {
+			//scroll will be implemented with InputInstruction::Jump(true) but it blocks setting self.jump_trying=true
+			instruction::InstructionConsumer::process_instruction(&mut self.physics, instruction::TimedInstruction{
+				time,
+				instruction:body::PhysicsInstruction::Jump
+			});
+		}
+
 		let mut encoder =
 			device.create_command_encoder(&wgpu::CommandEncoderDescriptor { label: None });
 
 		// update rotation
-		let camera_uniforms = to_uniform_data(&self.physics.camera,self.physics.body.extrapolated_position(time));
+		let camera_uniforms = self.camera.to_uniform_data(self.physics.body.extrapolated_position(time));
 		self.staging_belt
 			.write_buffer(
 				&mut encoder,
@@ -953,7 +963,7 @@ impl strafe_client::framework::Example for GraphicsData {
 }
 
 fn main() {
-	strafe_client::framework::run::<GraphicsData>(
+	framework::run::<GraphicsData>(
 		format!("Strafe Client v{}",
 			env!("CARGO_PKG_VERSION")
 		).as_str()

src/model.rs

@@ -0,0 +1,70 @@
+use bytemuck::{Pod, Zeroable};
+#[derive(Clone, Copy, Pod, Zeroable)]
+#[repr(C)]
+pub struct Vertex {
+	pub pos: [f32; 3],
+	pub texture: [f32; 2],
+	pub normal: [f32; 3],
+	pub color: [f32; 4],
+}
+
+#[derive(Clone)]
+pub struct ModelInstance {
+	pub transform: glam::Mat4,
+	pub color: glam::Vec4,
+}
+
+#[derive(Clone)]
+pub struct ModelData {
+	pub instances: Vec<ModelInstance>,
+	pub vertices: Vec<Vertex>,
+	pub entities: Vec<Vec<u16>>,
+	pub texture: Option<u32>,
+}
+
+impl ModelData {
+	pub const COLOR_FLOATS_WHITE: [f32;4] = [1.0,1.0,1.0,1.0];
+	pub const COLOR_VEC4_WHITE: glam::Vec4 = glam::vec4(1.0,1.0,1.0,1.0);
+}
+
+pub fn generate_modeldatas(data:obj::ObjData,color:[f32;4]) -> Vec<ModelData>{
+	let mut modeldatas=Vec::new();
+	let mut vertices = Vec::new();
+	let mut vertex_index = std::collections::HashMap::<obj::IndexTuple,u16>::new();
+	for object in data.objects {
+		vertices.clear();
+		vertex_index.clear();
+		let mut entities = Vec::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);
+						}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()],
+								color,
+							});
+							vertex_index.insert(vert,i);
+							indices.push(i);
+						}
+					}
+				}
+			}
+			entities.push(indices);
+		}
+		modeldatas.push(ModelData {
+			instances: Vec::new(),
+			vertices:vertices.clone(),
+			entities,
+			texture: None,
+		});
+	}
+	modeldatas
+}

src/primitives.rs

@@ -0,0 +1,76 @@
+pub fn the_unit_cube_lol() -> obj::ObjData{
+	obj::ObjData{
+		position: vec![
+			[-1.,-1., 1.],//left bottom back
+			[ 1.,-1., 1.],//right bottom back
+			[ 1., 1., 1.],//right top back
+			[-1., 1., 1.],//left top back
+			[-1., 1.,-1.],//left top front
+			[ 1., 1.,-1.],//right top front
+			[ 1.,-1.,-1.],//right bottom front
+			[-1.,-1.,-1.],//left bottom front
+		],
+		texture: vec![[0.0,0.0],[1.0,0.0],[1.0,1.0],[0.0,1.0]],
+		normal: vec![
+			[1.,0.,0.],//AabbFace::Right
+			[0.,1.,0.],//AabbFace::Top
+			[0.,0.,1.],//AabbFace::Back
+			[-1.,0.,0.],//AabbFace::Left
+			[0.,-1.,0.],//AabbFace::Bottom
+			[0.,0.,-1.],//AabbFace::Front
+		],
+		objects: vec![obj::Object{
+			name: "Unit Cube".to_owned(),
+			groups: vec![obj::Group{
+				name: "Cube Vertices".to_owned(),
+				index: 0,
+				material: None,
+				polys: vec![
+					// back (0, 0, 1)
+					obj::SimplePolygon(vec![
+						obj::IndexTuple(0,Some(0),Some(2)),
+						obj::IndexTuple(1,Some(1),Some(2)),
+						obj::IndexTuple(2,Some(2),Some(2)),
+						obj::IndexTuple(3,Some(3),Some(2)),
+					]),
+					// front (0, 0,-1)
+					obj::SimplePolygon(vec![
+						obj::IndexTuple(4,Some(0),Some(5)),
+						obj::IndexTuple(5,Some(1),Some(5)),
+						obj::IndexTuple(6,Some(2),Some(5)),
+						obj::IndexTuple(7,Some(3),Some(5)),
+					]),
+					// right (1, 0, 0)
+					obj::SimplePolygon(vec![
+						obj::IndexTuple(6,Some(0),Some(0)),
+						obj::IndexTuple(5,Some(1),Some(0)),
+						obj::IndexTuple(2,Some(2),Some(0)),
+						obj::IndexTuple(1,Some(3),Some(0)),
+					]),
+					// left (-1, 0, 0)
+					obj::SimplePolygon(vec![
+						obj::IndexTuple(0,Some(0),Some(3)),
+						obj::IndexTuple(3,Some(1),Some(3)),
+						obj::IndexTuple(4,Some(2),Some(3)),
+						obj::IndexTuple(7,Some(3),Some(3)),
+					]),
+					// top (0, 1, 0)
+					obj::SimplePolygon(vec![
+						obj::IndexTuple(5,Some(1),Some(1)),
+						obj::IndexTuple(4,Some(0),Some(1)),
+						obj::IndexTuple(3,Some(3),Some(1)),
+						obj::IndexTuple(2,Some(2),Some(1)),
+					]),
+					// bottom (0,-1, 0)
+					obj::SimplePolygon(vec![
+						obj::IndexTuple(1,Some(1),Some(4)),
+						obj::IndexTuple(0,Some(0),Some(4)),
+						obj::IndexTuple(7,Some(3),Some(4)),
+						obj::IndexTuple(6,Some(2),Some(4)),
+					]),
+				],
+			}]
+		}],
+		material_libs: Vec::new(),
+	}
+}

src/shader.wgsl

@@ -49,9 +49,10 @@ struct ModelInstance{
 //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(1)
 @binding(0)
-var<storage> model_instances: array<ModelInstance>;
+var<uniform> model_instances: array<ModelInstance, MAX_MODEL_INSTANCES>;
 @group(1)
 @binding(1)
 var model_texture: texture_2d<f32>;

src/zeroes.rs

@@ -1,4 +1,5 @@
 //find roots of polynomials
+#[inline]
 pub fn zeroes2(a0:f32,a1:f32,a2:f32) -> Vec<f32>{
 	if a2==0f32{
 		return zeroes1(a0, a1);