implement config

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

@@ -10,6 +10,7 @@ mod model;
 mod zeroes;
 mod worker;
 mod physics;
+mod settings;
 mod framework;
 mod primitives;
 mod instruction;
@@ -64,35 +65,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 +111,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 +227,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 +236,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 +266,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 +290,8 @@ impl GlobalState{
 						}
 					}
 				}
-				entities.push(indices);
 			}
+				entities.push(indices);
 			models.push(model::ModelSingleTexture{
 				instances:model.instances,
 				vertices,
@@ -374,7 +375,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 +384,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 +414,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 +755,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 +794,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 +813,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 +836,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 +898,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{
@@ -1024,7 +1041,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

@@ -175,7 +175,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
 		}
 	}
@@ -617,6 +617,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 +1098,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 +1146,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,124 @@
+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));
 }