this is very cool but it won't work because mouse timestamps will be identical while paused

why can't I make this into a function

Cargo.lock

@@ -331,6 +331,12 @@ dependencies = [
  "crossbeam-utils",
 ]
 
+[[package]]
+name = "configparser"
+version = "3.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5458d9d1a587efaf5091602c59d299696a3877a439c8f6d461a2d3cce11df87a"
+
 [[package]]
 name = "constant_time_eq"
 version = "0.3.0"
@@ -1682,10 +1688,11 @@ checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
 
 [[package]]
 name = "strafe-client"
-version = "0.7.0"
+version = "0.8.0"
 dependencies = [
  "async-executor",
  "bytemuck",
+ "configparser",
  "ddsfile",
  "env_logger",
  "glam",

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "strafe-client"
-version = "0.7.0"
+version = "0.8.0"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
@@ -8,6 +8,7 @@ edition = "2021"
 [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.24.1"

src/load_roblox.rs

@@ -34,11 +34,12 @@ fn get_attributes(name:&str,can_collide:bool,velocity:glam::Vec3,force_intersect
 	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"=>intersecting.water=Some(crate::model::IntersectingWater{density:1.0,drag:1.0}),
-		"Accelerator"=>intersecting.accelerator=Some(crate::model::IntersectingAccelerator{acceleration:velocity}),
-		"MapFinish"=>general.zone=Some(crate::model::GameMechanicZone{mode_id:0,behaviour:crate::model::ZoneBehaviour::Finish}),
-		"MapAnticheat"=>general.zone=Some(crate::model::GameMechanicZone{mode_id:0,behaviour:crate::model::ZoneBehaviour::Anitcheat}),
+		"Accelerator"=>{force_can_collide=false;intersecting.accelerator=Some(crate::model::IntersectingAccelerator{acceleration: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.stage_element=Some(crate::model::GameMechanicStageElement{
 			mode_id:0,
 			stage_id:0,
@@ -57,14 +58,15 @@ fn get_attributes(name:&str,can_collide:bool,velocity:glam::Vec3,force_intersect
 					},
 					behaviour:match &captures[2]{
 						"Spawn"|"SpawnAt"=>crate::model::StageElementBehaviour::SpawnAt,
-						"Trigger"=>crate::model::StageElementBehaviour::Trigger,
-						"Teleport"=>crate::model::StageElementBehaviour::Teleport,
+						"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"^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}),
@@ -77,7 +79,7 @@ fn get_attributes(name:&str,can_collide:bool,velocity:glam::Vec3,force_intersect
 	if velocity!=glam::Vec3::ZERO{
 		general.booster=Some(crate::model::GameMechanicBooster{velocity});
 	}
-	match can_collide{
+	match force_can_collide{
 		true=>{
 			match name{
 				//"Bounce"=>(),
@@ -176,7 +178,7 @@ impl RobloxFaceTextureDescription{
 }
 type RobloxPartDescription=[Option<RobloxFaceTextureDescription>;6];
 type RobloxWedgeDescription=[Option<RobloxFaceTextureDescription>;5];
-type RobloxCornerWedgeDescription=[Option<RobloxFaceTextureDescription>;4];
+type RobloxCornerWedgeDescription=[Option<RobloxFaceTextureDescription>;5];
 #[derive(Clone,Eq,Hash,PartialEq)]
 enum RobloxBasePartDescription{
 	Sphere,
@@ -309,9 +311,7 @@ pub fn generate_indexed_models(dom:rbx_dom_weak::WeakDom) -> crate::model::Index
 								};
 								let normal_id=normalid.to_u32();
 								if normal_id<6{
-									let mut roblox_texture_transform=RobloxTextureTransform::default();
-									let mut roblox_texture_color=glam::Vec4::ONE;
-									if decal.class=="Texture"{
+									let (roblox_texture_color,roblox_texture_transform)=if decal.class=="Texture"{
 										//generate tranform
 										if let (
 												Some(rbx_dom_weak::types::Variant::Float32(ox)),
@@ -334,13 +334,19 @@ pub fn generate_indexed_models(dom:rbx_dom_weak::WeakDom) -> crate::model::Index
 												5=>(size.x,size.y),//front
 												_=>panic!("unreachable"),
 											};
-											roblox_texture_transform=RobloxTextureTransform{
-												offset_u:*ox/(*sx),offset_v:*oy/(*sy),
-												scale_u:size_u/(*sx),scale_v:size_v/(*sy),
-											};
-											roblox_texture_color=glam::vec4(decal_color3.r,decal_color3.g,decal_color3.b,1.0-*decal_transparency);
+											(
+												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,
@@ -374,9 +380,11 @@ pub fn generate_indexed_models(dom:rbx_dom_weak::WeakDom) -> crate::model::Index
 						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
-						f1,//Cube::Top->CornerWedge::Top
+						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
 					]),
@@ -435,10 +443,11 @@ pub fn generate_indexed_models(dom:rbx_dom_weak::WeakDom) -> crate::model::Index
 							for (face_id,roblox_face_description) in cornerwedge_texture_description.iter().enumerate(){
 								cornerwedge_face_description.insert(
 								match face_id{
-									0=>primitives::CornerWedgeFace::Top,
-									1=>primitives::CornerWedgeFace::Right,
-									2=>primitives::CornerWedgeFace::Bottom,
-									3=>primitives::CornerWedgeFace::Front,
+									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{

src/main.rs

@@ -7,9 +7,11 @@ use instruction::{TimedInstruction, InstructionConsumer};
 mod bvh;
 mod aabb;
 mod model;
+mod timers;
 mod zeroes;
 mod worker;
 mod physics;
+mod settings;
 mod framework;
 mod primitives;
 mod instruction;
@@ -64,35 +66,31 @@ fn perspective_rh(fov_x_slope: f32, fov_y_slope: f32, z_near: f32, z_far: f32) -
 	)
 }
 impl GraphicsCamera{
-	pub fn new(screen_size:glam::UVec2,fov_y:f32)->Self{
+	pub fn new(screen_size:glam::UVec2,fov:glam::Vec2)->Self{
 		Self{
 			screen_size,
-			fov: glam::vec2(fov_y*(screen_size.x as f32)/(screen_size.y as f32),fov_y),
+			fov,
 		}
 	}
 	pub fn proj(&self)->glam::Mat4{
 		perspective_rh(self.fov.x, self.fov.y, 0.5, 2000.0)
 	}
-	pub fn view(&self,pos:glam::Vec3,angles:glam::Vec2)->glam::Mat4{
+	pub fn world(&self,pos:glam::Vec3,angles:glam::Vec2)->glam::Mat4{
 		//f32 good enough for view matrix
 		glam::Mat4::from_translation(pos) * glam::Mat4::from_euler(glam::EulerRot::YXZ, angles.x, angles.y, 0f32)
 	}
-	pub fn set_screen_size(&mut self,screen_size:glam::UVec2){
-		self.screen_size=screen_size;
-		self.fov.x=self.fov.y*(screen_size.x as f32)/(screen_size.y as f32);
-	}
 
-	pub fn to_uniform_data(&self,(pos,angles): (glam::Vec3,glam::Vec2)) -> [f32; 16 * 3 + 4] {
+	pub fn to_uniform_data(&self,(pos,angles): (glam::Vec3,glam::Vec2)) -> [f32; 16 * 4] {
 		let proj=self.proj();
 		let proj_inv = proj.inverse();
-		let view=self.view(pos,angles);
-		let view_inv = view.inverse();
+		let view_inv=self.world(pos,angles);
+		let view=view_inv.inverse();
 
-		let mut raw = [0f32; 16 * 3 + 4];
+		let mut raw = [0f32; 16 * 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[32..48].copy_from_slice(&AsRef::<[f32; 16]>::as_ref(&view)[..]);
+		raw[48..64].copy_from_slice(&AsRef::<[f32; 16]>::as_ref(&view_inv)[..]);
 		raw
 	}
 }
@@ -114,12 +112,16 @@ impl GraphicsState{
 	pub fn clear(&mut self){
 		self.models.clear();
 	}
+	pub fn load_user_settings(&mut self,user_settings:&settings::UserSettings){
+		self.camera.fov=user_settings.calculate_fov(1.0,&self.camera.screen_size).as_vec2();
+	}
 }
 
 pub struct GlobalState{
 	start_time: std::time::Instant,
 	manual_mouse_lock:bool,
 	mouse:physics::MouseState,
+	user_settings:settings::UserSettings,
 	graphics:GraphicsState,
 	physics_thread:worker::CompatWorker<TimedInstruction<InputInstruction>,physics::PhysicsOutputState,Box<dyn FnMut(TimedInstruction<InputInstruction>)->physics::PhysicsOutputState>>,
 }
@@ -226,7 +228,7 @@ impl GlobalState{
 				}else{
 					Some(ModelGraphicsInstance{
 						transform: glam::Mat4::from(instance.transform),
-						normal_transform: glam::Mat4::from(instance.transform.inverse()).transpose(),
+						normal_transform: glam::Mat3::from(instance.transform.matrix3.inverse().transpose()),
 						color: instance.color,
 					})
 				}
@@ -235,7 +237,7 @@ impl GlobalState{
 			let id=unique_texture_models.len();
 			let mut unique_textures=Vec::new();
 			for group in model.groups.into_iter(){
-				//ignore zero coppy optimization for now
+				//ignore zero copy optimization for now
 				let texture_index=if let Some(texture_index)=unique_textures.iter().position(|&texture|texture==group.texture){
 					texture_index
 				}else{
@@ -265,9 +267,9 @@ impl GlobalState{
 			let mut vertices = Vec::new();
 			let mut index_from_vertex = std::collections::HashMap::new();//::<IndexedVertex,usize>
 			let mut entities = Vec::new();
-			//TODO: combine groups using the same render pattern
-			for group in model.groups {
+			//this mut be combined in a more complex way if the models use different render patterns per group
 				let mut indices = Vec::new();
+			for group in model.groups {
 				for poly in group.polys {
 					for end_index in 2..poly.vertices.len() {
 						for &index in &[0, end_index - 1, end_index] {
@@ -289,8 +291,8 @@ impl GlobalState{
 						}
 					}
 				}
-				entities.push(indices);
 			}
+				entities.push(indices);
 			models.push(model::ModelSingleTexture{
 				instances:model.instances,
 				vertices,
@@ -374,7 +376,7 @@ impl GlobalState{
 	}
 }
 
-const MODEL_BUFFER_SIZE:usize=4*4 + 4*4 + 4;//let size=std::mem::size_of::<ModelInstance>();
+const MODEL_BUFFER_SIZE:usize=4*4 + 12 + 4;//let size=std::mem::size_of::<ModelInstance>();
 const MODEL_BUFFER_SIZE_BYTES:usize=MODEL_BUFFER_SIZE*4;
 fn get_instances_buffer_data(instances:&[ModelGraphicsInstance]) -> Vec<f32> {
 	let mut raw = Vec::with_capacity(MODEL_BUFFER_SIZE*instances.len());
@@ -383,7 +385,12 @@ fn get_instances_buffer_data(instances:&[ModelGraphicsInstance]) -> Vec<f32> {
     	//model transform
     	raw.extend_from_slice(&AsRef::<[f32; 4*4]>::as_ref(&mi.transform)[..]);
     	//normal transform
-    	raw.extend_from_slice(&AsRef::<[f32; 4*4]>::as_ref(&mi.normal_transform)[..]);
+    	raw.extend_from_slice(AsRef::<[f32; 3]>::as_ref(&mi.normal_transform.x_axis));
+    	raw.extend_from_slice(&[0.0]);
+    	raw.extend_from_slice(AsRef::<[f32; 3]>::as_ref(&mi.normal_transform.y_axis));
+    	raw.extend_from_slice(&[0.0]);
+    	raw.extend_from_slice(AsRef::<[f32; 3]>::as_ref(&mi.normal_transform.z_axis));
+    	raw.extend_from_slice(&[0.0]);
     	//color
     	raw.extend_from_slice(AsRef::<[f32; 4]>::as_ref(&mi.color));
     	raw.append(&mut v);
@@ -408,6 +415,8 @@ impl framework::Example for GlobalState {
 		device: &wgpu::Device,
 		queue: &wgpu::Queue,
 	) -> Self {
+		//wee
+		let user_settings=settings::read_user_settings();
 		let mut indexed_models = Vec::new();
 		indexed_models.append(&mut model::generate_indexed_model_list_from_obj(obj::ObjData::load_buf(&include_bytes!("../models/teslacyberv3.0.obj")[..]).unwrap(),*glam::Vec4::ONE.as_ref()));
 		indexed_models.push(primitives::unit_sphere());
@@ -747,7 +756,11 @@ impl framework::Example for GlobalState {
 
 		let mut physics = physics::PhysicsState::default();
 
-		let camera=GraphicsCamera::new(glam::uvec2(config.width,config.height), 1.0);
+		physics.load_user_settings(&user_settings);
+
+		let screen_size=glam::uvec2(config.width,config.height);
+
+		let camera=GraphicsCamera::new(screen_size,user_settings.calculate_fov(1.0,&screen_size).as_vec2());
 		let camera_uniforms = camera.to_uniform_data(physics.output().adjust_mouse(&physics.next_mouse));
 		let camera_buf = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
 			label: Some("Camera"),
@@ -782,7 +795,7 @@ impl framework::Example for GlobalState {
 
 		let depth_view = Self::create_depth_texture(config, device);
 
-		let graphics=GraphicsState {
+		let mut graphics=GraphicsState {
 			pipelines:GraphicsPipelines{
 				skybox:sky_pipeline,
 				model:model_pipeline
@@ -801,6 +814,8 @@ impl framework::Example for GlobalState {
 			temp_squid_texture_view: squid_texture_view,
 		};
 
+		graphics.load_user_settings(&user_settings);
+
 		let indexed_model_instances=model::IndexedModelInstances{
 			textures:Vec::new(),
 			models:indexed_models,
@@ -822,6 +837,7 @@ impl framework::Example for GlobalState {
 			start_time:Instant::now(),
 			manual_mouse_lock:false,
 			mouse:physics::MouseState::default(),
+			user_settings,
 			graphics,
 			physics_thread,
 		};
@@ -883,9 +899,11 @@ impl framework::Example for GlobalState {
 						time:physics.time,
 						instruction: PhysicsInstruction::Input(physics::PhysicsInputInstruction::Reset),
 					});
+					physics.load_user_settings(&self.user_settings);
 					physics.generate_models(&indexed_model_instances);
 					self.physics_thread=physics.into_worker();
 
+					//graphics.load_user_settings(&self.user_settings);
 					self.generate_model_graphics(device,queue,indexed_model_instances);
 					//manual reset
 				}else{
@@ -901,51 +919,23 @@ impl framework::Example for GlobalState {
 
 	#[allow(clippy::single_match)]
 	fn update(&mut self, window: &winit::window::Window, device: &wgpu::Device, queue: &wgpu::Queue, event: winit::event::WindowEvent) {
+		let time=self.start_time.elapsed().as_nanos() as i64;
 		match event {
 			winit::event::WindowEvent::DroppedFile(path) => self.load_file(path,device,queue),
 			winit::event::WindowEvent::Focused(state)=>{
 				//pause unpause
 				//recalculate pressed keys on focus
-			}
-			_=>(),
-		}
-	}
-
-	fn device_event(&mut self, window: &winit::window::Window, 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,
+			},
+			winit::event::WindowEvent::KeyboardInput {
+				input:winit::event::KeyboardInput{state, virtual_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
-					01=>{//Esc
-						if s{
-							self.manual_mouse_lock=false;
-							match window.set_cursor_grab(winit::window::CursorGrabMode::None){
-								Ok(())=>(),
-								Err(e)=>println!("Could not release cursor: {:?}",e),
-							}
-							window.set_cursor_visible(true);
-						}
-						None
-					},
-					15=>{//Tab
+				match virtual_keycode{
+					Some(winit::event::VirtualKeyCode::Tab)=>{
 						if s{
 							self.manual_mouse_lock=false;
 							match window.set_cursor_position(winit::dpi::PhysicalPosition::new(self.graphics.camera.screen_size.x as f32/2.0, self.graphics.camera.screen_size.y as f32/2.0)){
@@ -973,16 +963,56 @@ impl framework::Example for GlobalState {
 							}
 						}
 						window.set_cursor_visible(s);
-						None
 					},
-					_ => {println!("scancode {}",keycode);None},
-				}{
-					self.physics_thread.send(TimedInstruction{
-						time,
-						instruction:input_instruction,
-					}).unwrap();
+					Some(winit::event::VirtualKeyCode::F11)=>{
+						if s{
+							if window.fullscreen().is_some(){
+								window.set_fullscreen(None);
+							}else{
+								window.set_fullscreen(Some(winit::window::Fullscreen::Borderless(None)));
+							}
+						}
+					},
+					Some(winit::event::VirtualKeyCode::Escape)=>{
+						if s{
+							self.manual_mouse_lock=false;
+							match window.set_cursor_grab(winit::window::CursorGrabMode::None){
+								Ok(())=>(),
+								Err(e)=>println!("Could not release cursor: {:?}",e),
+							}
+							window.set_cursor_visible(true);
+						}
+					},
+					Some(keycode)=>{
+						if let Some(input_instruction)=match keycode {
+							winit::event::VirtualKeyCode::W => Some(InputInstruction::MoveForward(s)),
+							winit::event::VirtualKeyCode::A => Some(InputInstruction::MoveLeft(s)),
+							winit::event::VirtualKeyCode::S => Some(InputInstruction::MoveBack(s)),
+							winit::event::VirtualKeyCode::D => Some(InputInstruction::MoveRight(s)),
+							winit::event::VirtualKeyCode::E => Some(InputInstruction::MoveUp(s)),
+							winit::event::VirtualKeyCode::Q => Some(InputInstruction::MoveDown(s)),
+							winit::event::VirtualKeyCode::Space => Some(InputInstruction::Jump(s)),
+							winit::event::VirtualKeyCode::Z => Some(InputInstruction::Zoom(s)),
+							winit::event::VirtualKeyCode::R => if s{Some(InputInstruction::Reset)}else{None},
+							_ => None,
+						}{
+							self.physics_thread.send(TimedInstruction{
+								time,
+								instruction:input_instruction,
+							}).unwrap();
+						}
+					},
+					_=>(),
 				}
 			},
+			_=>(),
+		}
+	}
+
+	fn device_event(&mut self, window: &winit::window::Window, 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::MouseMotion {
 			    delta,//these (f64,f64) are integers on my machine
 			} => {
@@ -1024,7 +1054,8 @@ impl framework::Example for GlobalState {
 		_queue: &wgpu::Queue,
 	) {
 		self.graphics.depth_view = Self::create_depth_texture(config, device);
-		self.graphics.camera.set_screen_size(glam::uvec2(config.width, config.height));
+		self.graphics.camera.screen_size=glam::uvec2(config.width, config.height);
+		self.graphics.load_user_settings(&self.user_settings);
 	}
 
 	fn render(

src/model.rs

@@ -52,7 +52,7 @@ pub struct ModelSingleTexture{
 #[derive(Clone)]
 pub struct ModelGraphicsInstance{
 	pub transform:glam::Mat4,
-	pub normal_transform:glam::Mat4,
+	pub normal_transform:glam::Mat3,
 	pub color:glam::Vec4,
 }
 pub struct ModelInstance{

src/physics.rs

@@ -19,12 +19,12 @@ pub enum PhysicsInstruction {
 pub enum PhysicsInputInstruction {
 	ReplaceMouse(MouseState,MouseState),
 	SetNextMouse(MouseState),
-	SetMoveForward(bool),
-	SetMoveLeft(bool),
-	SetMoveBack(bool),
 	SetMoveRight(bool),
 	SetMoveUp(bool),
+	SetMoveBack(bool),
+	SetMoveLeft(bool),
 	SetMoveDown(bool),
+	SetMoveForward(bool),
 	SetJump(bool),
 	SetZoom(bool),
 	Reset,
@@ -33,21 +33,22 @@ pub enum PhysicsInputInstruction {
 #[derive(Debug)]
 pub enum InputInstruction {
 	MoveMouse(glam::IVec2),
-	MoveForward(bool),
-	MoveLeft(bool),
-	MoveBack(bool),
 	MoveRight(bool),
 	MoveUp(bool),
+	MoveBack(bool),
+	MoveLeft(bool),
 	MoveDown(bool),
+	MoveForward(bool),
 	Jump(bool),
 	Zoom(bool),
 	Reset,
+	SetPaused(bool),
 	Idle,
 		//Idle: there were no input events, but the simulation is safe to advance to this timestep
 		//for interpolation / networking / playback reasons, most playback heads will always want
 		//to be 1 instruction ahead to generate the next state for interpolation.
 }
-#[derive(Clone)]
+#[derive(Clone,Debug)]
 pub struct Body {
 	position: glam::Vec3,//I64 where 2^32 = 1 u
 	velocity: glam::Vec3,//I64 where 2^32 = 1 u/s
@@ -175,7 +176,7 @@ impl PhysicsCamera {
 		Self{
 			offset,
 			angles: glam::DVec2::ZERO,
-			sensitivity: glam::dvec2(1.0/16384.0,1.0/16384.0),
+			sensitivity: glam::dvec2(1.0/1024.0,1.0/1024.0),
 			mouse:MouseState{pos:glam::IVec2::ZERO,time:-1},//escape initialization hell divide by zero
 		}
 	}
@@ -453,6 +454,7 @@ impl PhysicsState {
 	pub fn into_worker(mut self)->crate::worker::CompatWorker<TimedInstruction<InputInstruction>,PhysicsOutputState,Box<dyn FnMut(TimedInstruction<InputInstruction>)->PhysicsOutputState>>{
 		let mut mouse_blocking=true;
 		let mut last_mouse_time=self.next_mouse.time;
+		let mut simulation_timer=crate::timers::UnscaledTimer::unpaused();
 		let mut timeline=std::collections::VecDeque::new();
 		crate::worker::CompatWorker::new(self.output(),Box::new(move |ins:TimedInstruction<InputInstruction>|{
 			if if let Some(phys_input)=match ins.instruction{
@@ -460,17 +462,17 @@ impl PhysicsState {
 					if mouse_blocking{
 						//tell the game state which is living in the past about its future
 						timeline.push_front(TimedInstruction{
-							time:last_mouse_time,
+							time:simulation_timer.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,
+							time:simulation_timer.time(last_mouse_time),
 							instruction:PhysicsInputInstruction::ReplaceMouse(
-								MouseState{time:last_mouse_time,pos:self.next_mouse.pos},
-								MouseState{time:ins.time,pos:m}
+								MouseState{time:simulation_timer.time(last_mouse_time),pos:self.next_mouse.pos},
+								MouseState{time:simulation_timer.time(ins.time),pos:m}
 							),
 						});
 						//delay physics execution until we have an interpolation target
@@ -479,6 +481,14 @@ impl PhysicsState {
 					last_mouse_time=ins.time;
 					None
 				},
+				InputInstruction::SetPaused(s)=>{
+					if s{
+						simulation_timer.pause(ins.time);
+					}else{
+						simulation_timer.unpause(ins.time);
+					}
+					Some(PhysicsInputInstruction::Idle)
+				}
 				InputInstruction::MoveForward(s)=>Some(PhysicsInputInstruction::SetMoveForward(s)),
 				InputInstruction::MoveLeft(s)=>Some(PhysicsInputInstruction::SetMoveLeft(s)),
 				InputInstruction::MoveBack(s)=>Some(PhysicsInputInstruction::SetMoveBack(s)),
@@ -492,7 +502,7 @@ impl PhysicsState {
 			}{
 				//non-mouse event
 				timeline.push_back(TimedInstruction{
-					time:ins.time,
+					time:simulation_timer.time(ins.time),
 					instruction:phys_input,
 				});
 				
@@ -504,7 +514,7 @@ impl PhysicsState {
 					if 10_000_000<ins.time-self.next_mouse.time{
 						//push an event to extrapolate no movement from
 						timeline.push_front(TimedInstruction{
-							time:last_mouse_time,
+							time:simulation_timer.time(last_mouse_time),
 							instruction:PhysicsInputInstruction::SetNextMouse(MouseState{time:ins.time,pos:self.next_mouse.pos}),
 						});
 						last_mouse_time=ins.time;
@@ -526,9 +536,10 @@ impl PhysicsState {
 			}{
 				//empty queue
 				while let Some(instruction)=timeline.pop_front(){
-					self.run(instruction.time);
+					let simulation_time=simulation_timer.time(instruction.time);
+					self.run(simulation_time);
 					self.process_instruction(TimedInstruction{
-						time:instruction.time,
+						time:simulation_time,
 						instruction:PhysicsInstruction::Input(instruction.instruction),
 					});
 				}
@@ -617,6 +628,10 @@ impl PhysicsState {
 		println!("Physics Objects: {}",self.models.len());
 	}
 
+	pub fn load_user_settings(&mut self,user_settings:&crate::settings::UserSettings){
+		self.camera.sensitivity=user_settings.calculate_sensitivity();
+	}
+
 	pub fn get_mode(&self,mode_id:u32)->Option<&crate::model::ModeDescription>{
 		if let Some(&mode)=self.mode_from_mode_id.get(&mode_id){
 			self.modes.get(mode)
@@ -1094,35 +1109,35 @@ impl crate::instruction::InstructionConsumer<PhysicsInstruction> for PhysicsStat
 						}
 						//check ground
 						self.contacts.insert(c.model,c);
-						match &general.stage_element{
-							Some(stage_element)=>{
-								if stage_element.force||self.game.stage_id<stage_element.stage_id{
-									self.game.stage_id=stage_element.stage_id;
-								}
-								match stage_element.behaviour{
-									crate::model::StageElementBehaviour::SpawnAt=>(),
-									crate::model::StageElementBehaviour::Trigger
-									|crate::model::StageElementBehaviour::Teleport=>{
-										//TODO make good
-										if let Some(mode)=self.get_mode(stage_element.mode_id){
-											if let Some(&spawn)=mode.get_spawn_model_id(self.game.stage_id){
-												if let Some(model)=self.models.get(spawn as usize){
-													self.body.position=model.transform.transform_point3(glam::Vec3::Y)+glam::Vec3::Y*(self.style.hitbox_halfsize.y+0.1);
-													//manual clear //for c in self.contacts{process_instruction(CollisionEnd(c))}
-													self.contacts.clear();
-													self.intersects.clear();
-													self.body.acceleration=self.style.gravity;
-													self.walk.state=WalkEnum::Reached;
-													self.grounded=false;
-												}else{println!("bad1");}
-											}else{println!("bad2");}
-										}else{println!("bad3");}
-									},
-									crate::model::StageElementBehaviour::Platform=>(),
-								}
-							},
-							None=>(),
-						}
+		match &general.stage_element{
+			Some(stage_element)=>{
+				if stage_element.force||self.game.stage_id<stage_element.stage_id{
+					self.game.stage_id=stage_element.stage_id;
+				}
+				match stage_element.behaviour{
+					crate::model::StageElementBehaviour::SpawnAt=>(),
+					crate::model::StageElementBehaviour::Trigger
+					|crate::model::StageElementBehaviour::Teleport=>{
+						//TODO make good
+						if let Some(mode)=self.get_mode(stage_element.mode_id){
+							if let Some(&spawn)=mode.get_spawn_model_id(self.game.stage_id){
+								if let Some(model)=self.models.get(spawn as usize){
+									self.body.position=model.transform.transform_point3(glam::Vec3::Y)+glam::Vec3::Y*(self.style.hitbox_halfsize.y+0.1);
+									//manual clear //for c in self.contacts{process_instruction(CollisionEnd(c))}
+									self.contacts.clear();
+									self.intersects.clear();
+									self.body.acceleration=self.style.gravity;
+									self.walk.state=WalkEnum::Reached;
+									self.grounded=false;
+								}else{println!("bad1");}
+							}else{println!("bad2");}
+						}else{println!("bad3");}
+					},
+					crate::model::StageElementBehaviour::Platform=>(),
+				}
+			},
+			None=>(),
+		}
 						//flatten v
 						let mut v=self.body.velocity;
 						self.contact_constrain_velocity(&mut v);
@@ -1142,6 +1157,35 @@ impl crate::instruction::InstructionConsumer<PhysicsInstruction> for PhysicsStat
 					PhysicsCollisionAttributes::Intersect{intersecting,general}=>{
 						//I think that setting the velocity to 0 was preventing surface contacts from entering an infinite loop
 						self.intersects.insert(c.model,c);
+		match &general.stage_element{
+			Some(stage_element)=>{
+				if stage_element.force||self.game.stage_id<stage_element.stage_id{
+					self.game.stage_id=stage_element.stage_id;
+				}
+				match stage_element.behaviour{
+					crate::model::StageElementBehaviour::SpawnAt=>(),
+					crate::model::StageElementBehaviour::Trigger
+					|crate::model::StageElementBehaviour::Teleport=>{
+						//TODO make good
+						if let Some(mode)=self.get_mode(stage_element.mode_id){
+							if let Some(&spawn)=mode.get_spawn_model_id(self.game.stage_id){
+								if let Some(model)=self.models.get(spawn as usize){
+									self.body.position=model.transform.transform_point3(glam::Vec3::Y)+glam::Vec3::Y*(self.style.hitbox_halfsize.y+0.1);
+									//manual clear //for c in self.contacts{process_instruction(CollisionEnd(c))}
+									self.contacts.clear();
+									self.intersects.clear();
+									self.body.acceleration=self.style.gravity;
+									self.walk.state=WalkEnum::Reached;
+									self.grounded=false;
+								}else{println!("bad1");}
+							}else{println!("bad2");}
+						}else{println!("bad3");}
+					},
+					crate::model::StageElementBehaviour::Platform=>(),
+				}
+			},
+			None=>(),
+		}
 					},
 				}
 			},

src/primitives.rs

@@ -107,8 +107,9 @@ local cornerWedgeVerticies = {
 */
 #[derive(Hash,PartialEq,Eq)]
 pub enum CornerWedgeFace{
-	Top,
 	Right,
+	TopBack,
+	TopLeft,
 	Bottom,
 	Front,
 }
@@ -162,7 +163,8 @@ pub type CornerWedgeFaceDescription=std::collections::HashMap::<CornerWedgeFace,
 pub fn unit_cornerwedge()->crate::model::IndexedModel{
 	let mut t=CornerWedgeFaceDescription::new();
 	t.insert(CornerWedgeFace::Right,FaceDescription::default());
-	t.insert(CornerWedgeFace::Top,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)
@@ -456,9 +458,10 @@ pub fn generate_partial_unit_cornerwedge(face_descriptions:CornerWedgeFaceDescri
 		} as u32;
 		let face_id=match face{
 			CornerWedgeFace::Right => 0,
-			CornerWedgeFace::Top => 1,
-			CornerWedgeFace::Bottom => 2,
-			CornerWedgeFace::Front => 3,
+			CornerWedgeFace::TopBack => 1,
+			CornerWedgeFace::TopLeft => 2,
+			CornerWedgeFace::Bottom => 3,
+			CornerWedgeFace::Front => 4,
 		};
 		//always push normal
 		let normal_index=generated_normal.len() as u32;

src/settings.rs

@@ -0,0 +1,123 @@
+struct Ratio{
+	ratio:f64,
+}
+enum DerivedFov{
+	FromScreenAspect,
+	FromAspect(Ratio),
+}
+enum Fov{
+	Exactly{x:f64,y:f64},
+	DeriveX{x:DerivedFov,y:f64},
+	DeriveY{x:f64,y:DerivedFov},
+}
+impl Default for Fov{
+	fn default() -> Self {
+		Fov::DeriveX{x:DerivedFov::FromScreenAspect,y:1.0}
+	}
+}
+
+enum Sensitivity{
+	Exactly{x:f64,y:f64},
+	DeriveX{x:Ratio,y:f64},
+	DeriveY{x:f64,y:Ratio},
+}
+impl Default for Sensitivity{
+	fn default() -> Self {
+		Sensitivity::DeriveY{x:0.001,y:Ratio{ratio:1.0}}
+	}
+}
+
+#[derive(Default)]
+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::DeriveX{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),
+			},
+			Fov::DeriveY{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),
+			},
+		}
+	}
+	pub fn calculate_sensitivity(&self)->glam::DVec2{
+		match &self.sensitivity{
+			&Sensitivity::Exactly{x,y}=>glam::dvec2(x,y),
+			Sensitivity::DeriveX{x,y}=>glam::dvec2(y*x.ratio,*y),
+			Sensitivity::DeriveY{x,y}=>glam::dvec2(*x,x*y.ratio),
+		}
+	}
+}
+
+/*
+//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::DeriveY{
+				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::DeriveX{
+				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:sensitivity_x,
+				y:sensitivity_y
+			},
+			(Ok(Some(sensitivity_x)),Ok(None))=>Sensitivity::DeriveY{
+				x:sensitivity_x,
+				y:Ratio{
+					ratio:if let Ok(Some(sensitivity_y_from_x_ratio))=cfg.getfloat("camera","sensitivity_y_from_x_ratio"){sensitivity_y_from_x_ratio}else{1.0}
+				}
+			},
+			(Ok(None),Ok(Some(sensitivity_y)))=>Sensitivity::DeriveX{
+				x:Ratio{
+					ratio:if let Ok(Some(sensitivity_x_from_y_ratio))=cfg.getfloat("camera","sensitivity_x_from_y_ratio"){sensitivity_x_from_y_ratio}else{1.0}
+				},
+				y:sensitivity_y,
+			},
+			_=>{
+				Sensitivity::default()
+			},
+		};
+		UserSettings{
+			fov,
+			sensitivity,
+		}
+	}else{
+		UserSettings::default()
+	}
+}

src/shader.wgsl

@@ -5,8 +5,8 @@ struct Camera {
 	proj_inv: mat4x4<f32>,
 	// from world to camera
 	view: mat4x4<f32>,
-	// camera position
-	cam_pos: vec4<f32>,
+	// from camera to world
+	view_inv: mat4x4<f32>,
 };
 
 //group 0 is the camera
@@ -31,8 +31,7 @@ fn vs_sky(@builtin(vertex_index) vertex_index: u32) -> SkyOutput {
 		1.0
 	);
 
-	// transposition = inversion for this orthonormal matrix
-	let inv_model_view = transpose(mat3x3<f32>(camera.view[0].xyz, camera.view[1].xyz, camera.view[2].xyz));
+	let inv_model_view = mat3x3<f32>(camera.view_inv[0].xyz, camera.view_inv[1].xyz, camera.view_inv[2].xyz);
 	let unprojected = camera.proj_inv * pos;
 
 	var result: SkyOutput;
@@ -43,7 +42,7 @@ fn vs_sky(@builtin(vertex_index) vertex_index: u32) -> SkyOutput {
 
 struct ModelInstance{
 	transform:mat4x4<f32>,
-	normal_transform:mat4x4<f32>,
+	normal_transform:mat3x3<f32>,
 	color:vec4<f32>,
 }
 //my fancy idea is to create a megatexture for each model that includes all the textures each intance will need
@@ -78,11 +77,11 @@ fn vs_entity_texture(
 ) -> EntityOutputTexture {
 	var position: vec4<f32> = model_instances[instance].transform * vec4<f32>(pos, 1.0);
 	var result: EntityOutputTexture;
-	result.normal = (model_instances[instance].normal_transform * vec4<f32>(normal, 1.0)).xyz;
+	result.normal = model_instances[instance].normal_transform * normal;
 	result.texture = texture;
 	result.color = color;
 	result.model_color = model_instances[instance].color;
-	result.view = position.xyz - camera.cam_pos.xyz;
+	result.view = position.xyz - camera.view_inv[3].xyz;//col(3)
 	result.position = camera.proj * camera.view * position;
 	return result;
 }
@@ -109,5 +108,5 @@ fn fs_entity_texture(vertex: EntityOutputTexture) -> @location(0) vec4<f32> {
 
 	let fragment_color = textureSample(model_texture, model_sampler, vertex.texture)*vertex.color;
 	let reflected_color = textureSample(cube_texture, cube_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),1.0-pow(1.0-abs(d),2.0));
+	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));
 }

src/timers.rs

@@ -0,0 +1,237 @@
+type TIME=crate::physics::TIME;
+
+#[derive(Clone)]
+pub struct Timescale{
+	num:i64,
+	den:std::num::NonZeroU64,
+}
+
+#[derive(Clone)]
+pub struct Paused{}
+#[derive(Clone)]
+pub struct Unpaused{}
+#[derive(Clone)]
+pub struct PausedScaled{scale:Timescale}
+#[derive(Clone)]
+pub struct UnpausedScaled{scale:Timescale}
+
+pub trait TimerState{}
+impl TimerState for Paused{}
+impl TimerState for Unpaused{}
+impl TimerState for PausedScaled{}
+impl TimerState for UnpausedScaled{}
+
+pub trait IsPaused{}
+impl IsPaused for Paused{}
+impl IsPaused for PausedScaled{}
+
+pub trait IsUnpaused{}
+impl IsUnpaused for Unpaused{}
+impl IsUnpaused for UnpausedScaled{}
+
+pub trait IsScaled{}
+impl IsScaled for PausedScaled{}
+impl IsScaled for UnpausedScaled{}
+
+pub trait IsUnscaled{}
+impl IsUnscaled for Paused{}
+impl IsUnscaled for Unpaused{}
+
+//scaled timer wrapper
+enum Scaled{
+	Paused(Timer<PausedScaled>),
+	Unpaused(Timer<UnpausedScaled>),
+}
+pub struct ScaledTimer{
+	timer:Scaled,
+}
+impl ScaledTimer{
+	pub fn unpaused()->Self{
+		Self{
+			timer:Scaled::Unpaused(unpaused_scaled(Timescale{num:1,den:std::num::NonZeroU64::new(1).unwrap()}))
+		}
+	}
+	pub fn time(&self,time:TIME)->TIME{
+		match &self.timer{
+			Scaled::Paused(timer)=>timer.time(),
+			Scaled::Unpaused(timer)=>timer.time(time),
+		}
+	}
+	pub fn pause(&mut self,time:TIME){
+		match &self.timer{
+			Scaled::Paused(_)=>(),
+			Scaled::Unpaused(timer)=>self.timer=Scaled::Paused(timer.clone().pause(time)),
+		};
+	}
+	pub fn unpause(&mut self,time:TIME){
+		match &self.timer{
+			Scaled::Paused(timer)=>self.timer=Scaled::Unpaused(timer.clone().unpause(time)),
+			Scaled::Unpaused(_)=>(),
+		};
+	}
+}
+
+//unscaled timer wrapper
+enum Unscaled{
+	Paused(Timer<Paused>),
+	Unpaused(Timer<Unpaused>),
+}
+pub struct UnscaledTimer{
+	timer:Unscaled,
+}
+
+impl UnscaledTimer{
+	pub fn unpaused()->Self{
+		Self{
+			timer:Unscaled::Unpaused(unpaused())
+		}
+	}
+	pub fn time(&self,time:TIME)->TIME{
+		match &self.timer{
+			Unscaled::Paused(timer)=>timer.time(),
+			Unscaled::Unpaused(timer)=>timer.time(time),
+		}
+	}
+	pub fn pause(&mut self,time:TIME){
+		match &self.timer{
+			Unscaled::Paused(_)=>(),
+			Unscaled::Unpaused(timer)=>self.timer=Unscaled::Paused(timer.clone().pause(time)),
+		};
+	}
+	pub fn unpause(&mut self,time:TIME){
+		match &self.timer{
+			Unscaled::Paused(timer)=>self.timer=Unscaled::Unpaused(timer.clone().unpause(time)),
+			Unscaled::Unpaused(_)=>(),
+		};
+	}
+}
+
+#[derive(Clone)]
+pub struct Timer<State:TimerState>{
+	offset:crate::physics::TIME,
+	state:State,
+}
+
+fn get_offset(time:TIME,write_time:TIME)->TIME{
+	write_time-time
+}
+fn get_offset_scaled(time:TIME,write_time:TIME,scale:&Timescale)->TIME{
+	write_time-time*scale.num/scale.den.get() as i64
+}
+
+fn paused()->Timer<Paused>{
+	Timer{
+		offset:0,
+		state:Paused{},
+	}
+}
+fn unpaused()->Timer<Unpaused>{
+	Timer{
+		offset:0,
+		state:Unpaused{},
+	}
+}
+fn paused_scaled(scale:Timescale)->Timer<PausedScaled>{
+	Timer{
+		offset:0,
+		state:PausedScaled{scale},
+	}
+}
+fn unpaused_scaled(scale:Timescale)->Timer<UnpausedScaled>{
+	Timer{
+		offset:0,
+		state:UnpausedScaled{scale},
+	}
+}
+impl Timer<Paused>{
+	pub fn time(&self)->TIME{
+		self.offset
+	}
+	pub fn unpause(self,time:TIME)->Timer<Unpaused>{
+		Timer{
+			offset:get_offset(time,self.time()),
+			state:Unpaused{},
+		}
+	}
+	pub fn set_time(&mut self,time:TIME,write_time:TIME){
+		self.offset=get_offset(time,write_time);
+	}
+	pub fn set_scale(self,time:TIME,scale:Timescale)->Timer<PausedScaled>{
+		Timer{
+			offset:get_offset_scaled(time,self.time(),&scale),
+			state:PausedScaled{scale},
+		}
+	}
+}
+impl Timer<Unpaused>{
+	pub fn time(&self,time:TIME)->TIME{
+		self.offset+time
+	}
+	pub fn pause(self,time:TIME)->Timer<Paused>{
+		Timer{
+			offset:self.time(time),
+			state:Paused{},
+		}
+	}
+	pub fn set_time(&mut self,time:TIME,write_time:TIME){
+		self.offset=get_offset(time,write_time);
+	}
+	pub fn set_scale(self,time:TIME,scale:Timescale)->Timer<UnpausedScaled>{
+		Timer{
+			offset:get_offset_scaled(time,self.time(time),&scale),
+			state:UnpausedScaled{scale},
+		}
+	}
+}
+impl Timer<PausedScaled>{
+	pub fn time(&self)->TIME{
+		self.offset
+	}
+	pub fn unpause(self,time:TIME)->Timer<UnpausedScaled>{
+		Timer{
+			offset:get_offset_scaled(time,self.time(),&self.state.scale),
+			state:UnpausedScaled{scale:self.state.scale},
+		}
+	}
+	pub fn set_time(&mut self,time:TIME,write_time:TIME){
+		self.offset=get_offset_scaled(time,write_time,&self.state.scale);
+	}
+	pub fn set_scale(self,time:TIME,scale:Timescale)->Timer<PausedScaled>{
+		Timer{
+			offset:get_offset_scaled(time,self.time(),&scale),
+			state:PausedScaled{scale},
+		}
+	}
+}
+impl Timer<UnpausedScaled>{
+	pub fn time(&self,time:TIME)->TIME{
+		self.offset+time*self.state.scale.num/self.state.scale.den.get() as i64
+	}
+	pub fn pause(self,time:TIME)->Timer<PausedScaled>{
+		Timer{
+			offset:self.time(time),
+			state:PausedScaled{scale:self.state.scale},
+		}
+	}
+	pub fn set_time(&mut self,time:TIME,write_time:TIME){
+		self.offset=get_offset_scaled(time,write_time,&self.state.scale);
+	}
+	pub fn set_scale(self,time:TIME,scale:Timescale)->Timer<UnpausedScaled>{
+		Timer{
+			offset:get_offset_scaled(time,self.time(time),&scale),
+			//self.offset+time*self.state.scale.num/self.state.scale.den.get() as i64-time*scale.num/scale.den.get() as i64
+			state:UnpausedScaled{scale},
+		}
+	}
+}
+
+#[test]
+fn test_timer_unscaled(){
+	const ONE_SECOND:TIME=1_000_000_000;
+	let run_prepare=paused();
+
+	let run_start=run_prepare.unpause(ONE_SECOND);
+	let run_finish=run_start.pause(11*ONE_SECOND);
+
+	assert_eq!(run_finish.time(),10*ONE_SECOND);
+}