use existing replay timer

.cargo/config.toml

@@ -1,2 +1,6 @@
 [registries.strafesnet]
 index = "sparse+https://git.itzana.me/api/packages/strafesnet/cargo/"
+
+[target.x86_64-unknown-linux-gnu]
+linker = "clang"
+rustflags = ["-C", "link-arg=-fuse-ld=/usr/bin/mold"]

Cargo.lock

@@ -493,27 +493,6 @@ dependencies = [
  "num-traits",
 ]
 
-[[package]]
-name = "directories"
-version = "6.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "16f5094c54661b38d03bd7e50df373292118db60b585c08a411c6d840017fe7d"
-dependencies = [
- "dirs-sys",
-]
-
-[[package]]
-name = "dirs-sys"
-version = "0.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e01a3366d27ee9890022452ee61b2b63a67e6f13f58900b651ff5665f0bb1fab"
-dependencies = [
- "libc",
- "option-ext",
- "redox_users",
- "windows-sys 0.59.0",
-]
-
 [[package]]
 name = "dispatch"
 version = "0.2.0"
@@ -965,15 +944,6 @@ dependencies = [
  "hashbrown",
 ]
 
-[[package]]
-name = "integration-testing"
-version = "0.1.0"
-dependencies = [
- "strafesnet_common",
- "strafesnet_physics",
- "strafesnet_snf",
-]
-
 [[package]]
 name = "itertools"
 version = "0.13.0"
@@ -1618,12 +1588,6 @@ version = "1.20.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1261fe7e33c73b354eab43b1273a57c8f967d0391e80353e51f764ac02cf6775"
 
-[[package]]
-name = "option-ext"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "04744f49eae99ab78e0d5c0b603ab218f515ea8cfe5a456d7629ad883a3b6e7d"
-
 [[package]]
 name = "orbclient"
 version = "0.3.48"
@@ -1955,9 +1919,9 @@ dependencies = [
 
 [[package]]
 name = "rbx_mesh"
-version = "0.2.0"
+version = "0.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1205fdae1f9a8bfd5d8fbe6036066673d530ee392f7840d6f8a24e763559c7fd"
+checksum = "864ead0e98afce28c960f653d6203483834890d07f87b60e2f01415530a2fe9d"
 dependencies = [
  "binrw",
  "lazy-regex",
@@ -2033,17 +1997,6 @@ dependencies = [
  "bitflags 2.8.0",
 ]
 
-[[package]]
-name = "redox_users"
-version = "0.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dd6f9d3d47bdd2ad6945c5015a226ec6155d0bcdfd8f7cd29f86b71f8de99d2b"
-dependencies = [
- "getrandom",
- "libredox",
- "thiserror 2.0.11",
-]
-
 [[package]]
 name = "regex"
 version = "1.11.1"
@@ -2298,19 +2251,21 @@ checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
 
 [[package]]
 name = "strafe-client"
-version = "0.11.0"
+version = "0.10.5"
 dependencies = [
+ "arrayvec",
+ "bytemuck",
+ "configparser",
+ "ddsfile",
  "glam",
+ "id",
  "parking_lot",
  "pollster",
+ "replace_with",
  "strafesnet_bsp_loader",
  "strafesnet_common",
  "strafesnet_deferred_loader",
- "strafesnet_graphics",
- "strafesnet_physics",
  "strafesnet_rbx_loader",
- "strafesnet_session",
- "strafesnet_settings",
  "strafesnet_snf",
  "wgpu",
  "winit",
@@ -2348,30 +2303,6 @@ dependencies = [
  "vbsp",
 ]
 
-[[package]]
-name = "strafesnet_graphics"
-version = "0.1.0"
-dependencies = [
- "bytemuck",
- "ddsfile",
- "glam",
- "id",
- "strafesnet_common",
- "strafesnet_session",
- "strafesnet_settings",
- "wgpu",
-]
-
-[[package]]
-name = "strafesnet_physics"
-version = "0.1.0"
-dependencies = [
- "arrayvec",
- "glam",
- "id",
- "strafesnet_common",
-]
-
 [[package]]
 name = "strafesnet_rbx_loader"
 version = "0.5.2"
@@ -2388,28 +2319,6 @@ dependencies = [
  "strafesnet_common",
 ]
 
-[[package]]
-name = "strafesnet_session"
-version = "0.1.0"
-dependencies = [
- "glam",
- "replace_with",
- "strafesnet_common",
- "strafesnet_physics",
- "strafesnet_settings",
- "strafesnet_snf",
-]
-
-[[package]]
-name = "strafesnet_settings"
-version = "0.1.0"
-dependencies = [
- "configparser",
- "directories",
- "glam",
- "strafesnet_common",
-]
-
 [[package]]
 name = "strafesnet_snf"
 version = "0.2.0"

Cargo.toml

@@ -1,10 +1,5 @@
 [workspace]
 members = [
-	"engine/graphics",
-	"engine/physics",
-	"engine/session",
-	"engine/settings",
-	"integration-testing",
 	"lib/bsp_loader",
 	"lib/common",
 	"lib/deferred_loader",

README.md

@@ -3,9 +3,6 @@
 # Strafe Project
 Monorepo for working on projects related to strafe client.
 
-## Try it out
-See [releases](https://git.itzana.me/StrafesNET/strafe-project/releases) for downloads.
-
 ## How to build and run
 1. Have rust and git installed
 2. `git clone https://git.itzana.me/StrafesNET/strafe-project`
@@ -13,4 +10,4 @@ See [releases](https://git.itzana.me/StrafesNET/strafe-project/releases) for dow
 4. `cargo run --release --bin strafe-client`
 
 ## Licenses
-Each project has its own license.  Most crates are MIT/Apache but notably the Strafe Client and engine crates have a sole proprietor license.
+Each project has its own license.  Most crates are MIT/Apache but notably the Strafe Client has a sole proprietor license.

engine/graphics/Cargo.toml

@@ -1,14 +0,0 @@
-[package]
-name = "strafesnet_graphics"
-version = "0.1.0"
-edition = "2021"
-
-[dependencies]
-bytemuck = { version = "1.13.1", features = ["derive"] }
-ddsfile = "0.5.1"
-glam = "0.29.0"
-id = { version = "0.1.0", registry = "strafesnet" }
-strafesnet_common = { path = "../../lib/common", registry = "strafesnet" }
-strafesnet_session = { path = "../session", registry = "strafesnet" }
-strafesnet_settings = { path = "../settings", registry = "strafesnet" }
-wgpu = "24.0.0"

engine/graphics/LICENSE

@@ -1,8 +0,0 @@
-/*******************************************************
-* Copyright (C) 2023-2024 Rhys Lloyd <krakow20@gmail.com>
-*
-* This file is part of the StrafesNET bhop/surf client.
-*
-* StrafesNET can not be copied and/or distributed
-* without the express permission of Rhys Lloyd
-*******************************************************/

engine/graphics/src/lib.rs

@@ -1,2 +0,0 @@
-pub mod model;
-pub mod graphics;

engine/physics/Cargo.toml

@@ -1,10 +0,0 @@
-[package]
-name = "strafesnet_physics"
-version = "0.1.0"
-edition = "2021"
-
-[dependencies]
-arrayvec = "0.7.6"
-glam = "0.29.0"
-id = { version = "0.1.0", registry = "strafesnet" }
-strafesnet_common = { path = "../../lib/common", registry = "strafesnet" }

engine/physics/LICENSE

@@ -1,8 +0,0 @@
-/*******************************************************
-* Copyright (C) 2023-2024 Rhys Lloyd <krakow20@gmail.com>
-*
-* This file is part of the StrafesNET bhop/surf client.
-*
-* StrafesNET can not be copied and/or distributed
-* without the express permission of Rhys Lloyd
-*******************************************************/

engine/physics/src/lib.rs

@@ -1,45 +0,0 @@
-mod body;
-mod push_solve;
-mod face_crawler;
-mod model;
-
-pub mod physics;
-
-// Physics bug fixes can easily desync all bots.
-//
-// When replaying a bot, use the exact physics version which it was recorded with.
-//
-// When validating a new bot, ignore the version and use the latest version,
-// and overwrite the version in the file.
-//
-// Compatible physics versions should be determined
-// empirically at development time via leaderboard resimulation.
-//
-// Compatible physics versions should result in an identical leaderboard state,
-// or the only bots which fail are ones exploiting a surgically patched bug.
-#[derive(Clone,Copy,Hash,Debug,id::Id,Eq,PartialEq,Ord,PartialOrd)]
-pub struct PhysicsVersion(u32);
-pub const VERSION:PhysicsVersion=PhysicsVersion(0);
-const LATEST_COMPATIBLE_VERSION:[u32;1+VERSION.0 as usize]=const{
-	let compat=[0];
-
-	let mut input_version=0;
-	while input_version<compat.len(){
-		// compatible version must be greater than or equal to the input version
-		assert!(input_version as u32<=compat[input_version]);
-		// compatible version must be a version that exists
-		assert!(compat[input_version]<=VERSION.0);
-		input_version+=1;
-	}
-	compat
-};
-pub enum PhysicsVersionError{
-	UnknownPhysicsVersion,
-}
-pub const fn get_latest_compatible_version(PhysicsVersion(version):PhysicsVersion)->Result<PhysicsVersion,PhysicsVersionError>{
-	if (version as usize)<LATEST_COMPATIBLE_VERSION.len(){
-		Ok(PhysicsVersion(LATEST_COMPATIBLE_VERSION[version as usize]))
-	}else{
-		Err(PhysicsVersionError::UnknownPhysicsVersion)
-	}
-}

engine/session/Cargo.toml

@@ -1,12 +0,0 @@
-[package]
-name = "strafesnet_session"
-version = "0.1.0"
-edition = "2021"
-
-[dependencies]
-glam = "0.29.0"
-replace_with = "0.1.7"
-strafesnet_common = { path = "../../lib/common", registry = "strafesnet" }
-strafesnet_physics = { path = "../physics", registry = "strafesnet" }
-strafesnet_settings = { path = "../settings", registry = "strafesnet" }
-strafesnet_snf = { path = "../../lib/snf", registry = "strafesnet" }

engine/session/LICENSE

@@ -1,8 +0,0 @@
-/*******************************************************
-* Copyright (C) 2023-2024 Rhys Lloyd <krakow20@gmail.com>
-*
-* This file is part of the StrafesNET bhop/surf client.
-*
-* StrafesNET can not be copied and/or distributed
-* without the express permission of Rhys Lloyd
-*******************************************************/

engine/session/src/lib.rs

@@ -1,2 +0,0 @@
-mod mouse_interpolator;
-pub mod session;

engine/settings/Cargo.toml

@@ -1,10 +0,0 @@
-[package]
-name = "strafesnet_settings"
-version = "0.1.0"
-edition = "2021"
-
-[dependencies]
-configparser = "3.0.2"
-directories = "6.0.0"
-glam = "0.29.0"
-strafesnet_common = { path = "../../lib/common", registry = "strafesnet" }

engine/settings/LICENSE

@@ -1,8 +0,0 @@
-/*******************************************************
-* Copyright (C) 2023-2024 Rhys Lloyd <krakow20@gmail.com>
-*
-* This file is part of the StrafesNET bhop/surf client.
-*
-* StrafesNET can not be copied and/or distributed
-* without the express permission of Rhys Lloyd
-*******************************************************/

engine/settings/src/directories.rs

@@ -1,32 +0,0 @@
-use std::path::PathBuf;
-
-use crate::settings::{UserSettings,load_user_settings};
-
-pub struct Directories{
-	pub settings:PathBuf,
-	pub maps:PathBuf,
-	pub replays:PathBuf,
-}
-impl Directories{
-	pub fn settings(&self)->UserSettings{
-		load_user_settings(&self.settings)
-	}
-	pub fn user()->Option<Self>{
-		let dirs=directories::ProjectDirs::from("net.strafes","StrafesNET","Strafe Client")?;
-		Some(Self{
-			settings:dirs.config_dir().join("settings.conf"),
-			maps:dirs.cache_dir().join("maps"),
-			// separate directory for remote downloaded replays (cache)
-			// bots:dirs.cache_dir().join("bots"),
-			replays:dirs.data_local_dir().join("replays"),
-		})
-	}
-	pub fn portable()->Result<Self,std::io::Error>{
-		let current_dir=std::env::current_dir()?;
-		Ok(Self{
-			settings:current_dir.join("settings.conf"),
-			maps:current_dir.join("maps"),
-			replays:current_dir.join("replays"),
-		})
-	}
-}

engine/settings/src/lib.rs

@@ -1,2 +0,0 @@
-pub mod settings;
-pub mod directories;

integration-testing/Cargo.toml

@@ -1,9 +0,0 @@
-[package]
-name = "integration-testing"
-version = "0.1.0"
-edition = "2021"
-
-[dependencies]
-strafesnet_common = { version = "0.5.2", path = "../lib/common", registry = "strafesnet" }
-strafesnet_physics = { version = "0.1.0", path = "../engine/physics", registry = "strafesnet" }
-strafesnet_snf = { path = "../lib/snf", registry = "strafesnet" }

integration-testing/src/main.rs

@@ -1,221 +0,0 @@
-
-use std::{io::{Cursor,Read},path::Path};
-
-use strafesnet_physics::physics::{PhysicsData,PhysicsState,PhysicsContext};
-
-fn main(){
-	test_determinism().unwrap();
-}
-
-#[allow(unused)]
-#[derive(Debug)]
-enum ReplayError{
-	IO(std::io::Error),
-	SNF(strafesnet_snf::Error),
-	SNFM(strafesnet_snf::map::Error),
-	SNFB(strafesnet_snf::bot::Error),
-}
-impl From<std::io::Error> for ReplayError{
-	fn from(value:std::io::Error)->Self{
-		Self::IO(value)
-	}
-}
-impl From<strafesnet_snf::Error> for ReplayError{
-	fn from(value:strafesnet_snf::Error)->Self{
-		Self::SNF(value)
-	}
-}
-impl From<strafesnet_snf::map::Error> for ReplayError{
-	fn from(value:strafesnet_snf::map::Error)->Self{
-		Self::SNFM(value)
-	}
-}
-impl From<strafesnet_snf::bot::Error> for ReplayError{
-	fn from(value:strafesnet_snf::bot::Error)->Self{
-		Self::SNFB(value)
-	}
-}
-
-fn read_entire_file(path:impl AsRef<Path>)->Result<Cursor<Vec<u8>>,std::io::Error>{
-	let mut file=std::fs::File::open(path)?;
-	let mut data=Vec::new();
-	file.read_to_end(&mut data)?;
-	Ok(Cursor::new(data))
-}
-
-fn run_replay()->Result<(),ReplayError>{
-	println!("loading map file..");
-	let data=read_entire_file("../tools/bhop_maps/5692113331.snfm")?;
-	let map=strafesnet_snf::read_map(data)?.into_complete_map()?;
-
-	println!("loading bot file..");
-	let data=read_entire_file("../tools/replays/535s+159764769ns.snfb")?;
-	let bot=strafesnet_snf::read_bot(data)?.read_all()?;
-
-	// create recording
-	let mut physics_data=PhysicsData::default();
-	println!("generating models..");
-	physics_data.generate_models(&map);
-	println!("simulating...");
-	let mut physics=PhysicsState::default();
-	for ins in bot.instructions{
-		PhysicsContext::run_input_instruction(&mut physics,&physics_data,ins);
-	}
-	match physics.get_finish_time(){
-		Some(time)=>println!("finish time:{}",time),
-		None=>println!("simulation did not end in finished state"),
-	}
-
-	Ok(())
-}
-enum DeterminismResult{
-	Deterministic,
-	NonDeterministic,
-}
-fn segment_determinism(bot:strafesnet_snf::bot::Segment,physics_data:&PhysicsData)->DeterminismResult{
-	// create default physics state
-	let mut physics_deterministic=PhysicsState::default();
-	// create a second physics state
-	let mut physics_filtered=PhysicsState::default();
-
-	// invent a new bot id and insert the replay
-	println!("simulating...");
-
-	let mut non_idle_count=0;
-
-	for (i,ins) in bot.instructions.into_iter().enumerate(){
-		let state_deterministic=physics_deterministic.clone();
-		let state_filtered=physics_filtered.clone();
-		PhysicsContext::run_input_instruction(&mut physics_deterministic,&physics_data,ins.clone());
-		match ins{
-			strafesnet_common::instruction::TimedInstruction{instruction:strafesnet_common::physics::Instruction::Idle,..}=>(),
-			other=>{
-				non_idle_count+=1;
-				// run
-				PhysicsContext::run_input_instruction(&mut physics_filtered,&physics_data,other.clone());
-				// check if position matches
-				let b0=physics_deterministic.camera_body();
-				let b1=physics_filtered.camera_body();
-				if b0.position!=b1.position{
-					println!("desync at instruction #{}",i);
-					println!("non idle instructions completed={non_idle_count}");
-					println!("instruction #{i}={:?}",other);
-					println!("deterministic state0:\n{state_deterministic:?}");
-					println!("filtered state0:\n{state_filtered:?}");
-					println!("deterministic state1:\n{:?}",physics_deterministic);
-					println!("filtered state1:\n{:?}",physics_filtered);
-					return DeterminismResult::NonDeterministic;
-				}
-			},
-		}
-	}
-	match physics_deterministic.get_finish_time(){
-		Some(time)=>println!("[with idle] finish time:{}",time),
-		None=>println!("[with idle] simulation did not end in finished state"),
-	}
-	match physics_filtered.get_finish_time(){
-		Some(time)=>println!("[filtered] finish time:{}",time),
-		None=>println!("[filtered] simulation did not end in finished state"),
-	}
-	DeterminismResult::Deterministic
-}
-type ThreadResult=Result<Option<DeterminismResult>,ReplayError>;
-fn read_and_run(file_path:std::path::PathBuf,physics_data:&PhysicsData)->ThreadResult{
-	let data=read_entire_file(file_path.as_path())?;
-	let bot=strafesnet_snf::read_bot(data)?.read_all()?;
-	println!("Running {:?}",file_path.file_stem());
-	Ok(Some(segment_determinism(bot,physics_data)))
-}
-fn do_thread<'a>(s:&'a std::thread::Scope<'a,'_>,file_path:std::path::PathBuf,send:std::sync::mpsc::Sender<ThreadResult>,physics_data:&'a PhysicsData){
-	s.spawn(move ||{
-		let result=read_and_run(file_path,physics_data);
-		// send when thread is complete
-		send.send(result).unwrap();
-	});
-}
-fn get_file_path(dir_entry:std::fs::DirEntry)->Result<Option<std::path::PathBuf>,std::io::Error>{
-	Ok(dir_entry.file_type()?.is_file().then_some(
-		dir_entry.path()
-	))
-}
-fn test_determinism()->Result<(),ReplayError>{
-	let thread_limit=std::thread::available_parallelism()?.get();
-	println!("loading map file..");
-	let data=read_entire_file("../tools/bhop_maps/5692113331.snfm")?;
-	let map=strafesnet_snf::read_map(data)?.into_complete_map()?;
-
-	let mut physics_data=PhysicsData::default();
-	println!("generating models..");
-	physics_data.generate_models(&map);
-
-	let (send,recv)=std::sync::mpsc::channel();
-
-	let mut read_dir=std::fs::read_dir("../tools/replays")?;
-
-	// promise that &physics_data will outlive the spawned threads
-	let thread_results=std::thread::scope(|s|{
-		let mut thread_results=Vec::new();
-
-		// spawn threads
-		println!("spawning up to {thread_limit} threads...");
-		let mut active_thread_count=0;
-		while active_thread_count<thread_limit{
-			if let Some(dir_entry_result)=read_dir.next(){
-				if let Some(file_path)=get_file_path(dir_entry_result?)?{
-					active_thread_count+=1;
-					do_thread(s,file_path,send.clone(),&physics_data);
-				}
-			}else{
-				break;
-			}
-		}
-
-		// spawn another thread every time a message is received from the channel
-		println!("riding parallelism wave...");
-		while let Some(dir_entry_result)=read_dir.next(){
-			if let Some(file_path)=get_file_path(dir_entry_result?)?{
-				// wait for a thread to complete
-				thread_results.push(recv.recv().unwrap());
-				do_thread(s,file_path,send.clone(),&physics_data);
-			}
-		}
-
-		// wait for remaining threads to complete
-		println!("waiting for all threads to complete...");
-		for _ in 0..active_thread_count{
-			thread_results.push(recv.recv().unwrap());
-		}
-
-		println!("done.");
-		Ok::<_,ReplayError>(thread_results)
-	})?;
-
-	// tally results
-	#[derive(Default)]
-	struct Totals{
-		deterministic:u32,
-		nondeterministic:u32,
-		invalid:u32,
-		error:u32,
-	}
-	let Totals{deterministic,nondeterministic,invalid,error}=thread_results.into_iter().fold(Totals::default(),|mut totals,result|{
-		match result{
-			Ok(Some(DeterminismResult::Deterministic))=>totals.deterministic+=1,
-			Ok(Some(DeterminismResult::NonDeterministic))=>totals.nondeterministic+=1,
-			Ok(None)=>totals.invalid+=1,
-			Err(_)=>totals.error+=1,
-		}
-		totals
-	});
-
-	println!("deterministic={deterministic}");
-	println!("nondeterministic={nondeterministic}");
-	println!("invalid={invalid}");
-	println!("error={error}");
-
-	assert!(nondeterministic==0);
-	assert!(invalid==0);
-	assert!(error==0);
-
-	Ok(())
-}

lib/bsp_loader/src/bsp.rs

@@ -240,7 +240,7 @@ impl PartialMap2{
 		.enumerate().map(|(new_texture_id,(old_texture_id,texture))|{
 			(texture,(old_texture_id,model::TextureId::new(new_texture_id as u32)))
 		}).unzip();
-		let render_configs=render_configs.into_iter().map(|(_render_config_id,mut render_config)|{
+		let render_configs=render_configs.into_iter().map(|(render_config_id,mut render_config)|{
 			//this may generate duplicate no-texture render configs but idc
 			render_config.texture=render_config.texture.and_then(|texture_id|
 				texture_id_map.get(&texture_id).copied()

lib/common/src/instruction.rs

@@ -62,7 +62,6 @@ impl<I,T> InstructionCollector<I,T>
 	pub const fn time(&self)->Time<T>{
 		self.time
 	}
-	#[inline]
 	pub fn collect(&mut self,instruction:Option<TimedInstruction<I,T>>){
 		if let Some(ins)=instruction{
 			if ins.time<self.time{
@@ -71,8 +70,7 @@ impl<I,T> InstructionCollector<I,T>
 			}
 		}
 	}
-	#[inline]
+	pub fn instruction(self)->Option<TimedInstruction<I,T>>{
-	pub fn take(self)->Option<TimedInstruction<I,T>>{
 		//STEAL INSTRUCTION AND DESTROY INSTRUCTIONCOLLECTOR
 		self.instruction.map(|instruction|TimedInstruction{
 			time:self.time,

lib/common/src/integer.rs

@@ -14,7 +14,6 @@ impl<T> Time<T>{
 	pub const MIN:Self=Self::raw(i64::MIN);
 	pub const MAX:Self=Self::raw(i64::MAX);
 	pub const ZERO:Self=Self::raw(0);
-	pub const EPSILON:Self=Self::raw(1);
 	pub const ONE_SECOND:Self=Self::raw(1_000_000_000);
 	pub const ONE_MILLISECOND:Self=Self::raw(1_000_000);
 	pub const ONE_MICROSECOND:Self=Self::raw(1_000);

lib/common/src/run.rs

@@ -76,7 +76,7 @@ impl Run{
 		match &self.state{
 			RunState::Created=>Time::ZERO,
 			RunState::Started{timer}=>timer.time(time),
-			RunState::Finished{timer}=>timer.time(),
+			RunState::Finished{timer}=>timer.time(time),
 		}
 	}
 	pub fn start(&mut self,time:PhysicsTime)->Result<(),Error>{
@@ -110,10 +110,4 @@ impl Run{
 			self.flagged=Some(flag_reason);
 		}
 	}
-	pub fn get_finish_time(&self)->Option<Time>{
-		match &self.state{
-			RunState::Finished{timer}=>Some(timer.time()),
-			_=>None,
-		}
-	}
 }

lib/common/src/timer.rs

@@ -23,7 +23,7 @@ impl PauseState for Unpaused{
 }
 
 #[derive(Clone,Copy,Hash,Eq,PartialEq,PartialOrd,Debug)]
-pub enum Inner{}
+enum Inner{}
 type InnerTime=Time<Inner>;
 
 #[derive(Clone,Copy,Debug)]
@@ -157,7 +157,7 @@ impl<T:TimerState> TimerFixed<T,Paused>
 	where Time<T::In>:Copy,
 {
 	pub fn into_unpaused(self,time:Time<T::In>)->TimerFixed<T,Unpaused>{
-		let new_time=self.time();
+		let new_time=self.time(time);
 		let mut timer=TimerFixed{
 			state:self.state,
 			_paused:Unpaused,
@@ -165,9 +165,6 @@ impl<T:TimerState> TimerFixed<T,Paused>
 		timer.set_time(time,new_time);
 		timer
 	}
-	pub fn time(&self)->Time<T::Out>{
-		self.state.get_offset().coerce()
-	}
 }
 impl<T:TimerState> TimerFixed<T,Unpaused>
 	where Time<T::In>:Copy,
@@ -181,9 +178,6 @@ impl<T:TimerState> TimerFixed<T,Unpaused>
 		timer.set_time(time,new_time);
 		timer
 	}
-	pub fn time(&self,time:Time<T::In>)->Time<T::Out>{
-		self.state.get_time(time)
-	}
 }
 
 //the new constructor and time queries are generic across both
@@ -205,6 +199,12 @@ impl<T:TimerState,P:PauseState> TimerFixed<T,P>{
 	pub fn into_state(self)->T{
 		self.state
 	}
+	pub fn time(&self,time:Time<T::In>)->Time<T::Out>{
+		match P::IS_PAUSED{
+			true=>self.state.get_offset().coerce(),
+			false=>self.state.get_time(time),
+		}
+	}
 	pub fn set_time(&mut self,time:Time<T::In>,new_time:Time<T::Out>){
 		match P::IS_PAUSED{
 			true=>self.state.set_offset(new_time.coerce()),
@@ -256,7 +256,7 @@ impl<T:TimerState> Timer<T>
 	}
 	pub fn time(&self,time:Time<T::In>)->Time<T::Out>{
 		match self{
-			Self::Paused(timer)=>timer.time(),
+			Self::Paused(timer)=>timer.time(time),
 			Self::Unpaused(timer)=>timer.time(time),
 		}
 	}
@@ -329,7 +329,7 @@ mod test{
 		//create a paused timer that reads 0s
 		let timer=TimerFixed::<Scaled<Parent,Calculated>,Paused>::from_state(Scaled::new(0.5f32.try_into().unwrap(),sec!(0)));
 		//the paused timer at 1 second should read 0s
-		assert_eq!(timer.time(),sec!(0));
+		assert_eq!(timer.time(sec!(1)),sec!(0));
 
 		//unpause it after one second
 		let timer=timer.into_unpaused(sec!(1));
@@ -339,7 +339,7 @@ mod test{
 		//pause the timer after 11 seconds
 		let timer=timer.into_paused(sec!(11));
 		//the paused timer at 20 seconds should read 5s
-		assert_eq!(timer.time(),sec!(5));
+		assert_eq!(timer.time(sec!(20)),sec!(5));
 	}
 	#[test]
 	fn test_timer()->Result<(),Error>{

lib/common/src/updatable.rs

@@ -1,5 +1,3 @@
-// This whole thing should be a drive macro
-
 pub trait Updatable<Updater>{
 	fn update(&mut self,update:Updater);
 }
@@ -55,3 +53,4 @@ impl Updatable<OuterUpdate> for Outer{
 		}
 	}
 }
+//*/

lib/deferred_loader/Cargo.toml

@@ -12,8 +12,8 @@ authors = ["Rhys Lloyd <krakow20@gmail.com>"]
 [features]
 default = ["legacy"]
 legacy = ["dep:url","dep:vbsp"]
-roblox = []
+#roblox = ["dep:lazy-regex"]
-source = ["dep:vbsp"]
+#source = ["dep:vbsp"]
 
 [dependencies]
 strafesnet_common = { path = "../common", registry = "strafesnet" }

lib/fixed_wide/src/tests.rs

@@ -57,7 +57,7 @@ fn from_f32(){
 	assert_eq!(b,Ok(a));
 	//I32F32::MIN hits a special case since it's not representable as a positive signed integer
 	//TODO: don't return an overflow because this is technically possible
-	let _a=I32F32::MIN;
+	let a=I32F32::MIN;
 	let b:Result<I32F32,_>=Into::<f32>::into(I32F32::MIN).try_into();
 	assert_eq!(b,Err(crate::fixed::FixedFromFloatError::Overflow));
 	//16 is within the 24 bits of float precision

lib/rbx_loader/Cargo.toml

@@ -15,7 +15,7 @@ glam = "0.29.0"
 lazy-regex = "3.1.0"
 rbx_binary = { version = "0.7.4", registry = "strafesnet" }
 rbx_dom_weak = { version = "2.7.0", registry = "strafesnet" }
-rbx_mesh = "0.2.0"
+rbx_mesh = "0.1.2"
 rbx_reflection_database = { version = "0.2.10", registry = "strafesnet" }
 rbx_xml = { version = "0.13.3", registry = "strafesnet" }
 roblox_emulator = { path = "../roblox_emulator", registry = "strafesnet" }

lib/rbx_loader/src/directories.rs

@@ -1,6 +0,0 @@
-// TODO: make a directories structure like strafe client
-struct Directories{
-	textures:PathBuf,
-	meshes:PathBuf,
-	unions:PathBuf,
-}

lib/rbx_loader/src/lib.rs

@@ -3,7 +3,6 @@ use rbx_dom_weak::WeakDom;
 
 mod rbx;
 mod mesh;
-mod union;
 mod primitives;
 
 pub mod data{
@@ -43,7 +42,7 @@ pub struct Place{
 	services:roblox_emulator::context::Services,
 }
 impl Place{
-	pub fn new(dom:WeakDom)->Option<Self>{
+	fn new(dom:WeakDom)->Option<Self>{
 		let context=roblox_emulator::context::Context::from_ref(&dom);
 		Some(Self{
 			services:context.find_services()?,

lib/rbx_loader/src/loader.rs

@@ -1,4 +0,0 @@
-// TODO: move code from deferred_loader to here
-// use generics to specify a hashable type for the acquire_X function signature
-// use impls/traits instead of passing around functions
-// part of the goob remains in deferred loader, the common bits between both

lib/rbx_loader/src/mesh.rs

@@ -1,9 +1,8 @@
 use std::collections::HashMap;
 
-use rbx_mesh::mesh::{Vertex2,Vertex2Truncated};
+use rbx_mesh::mesh::{Vertex2, Vertex2Truncated};
-use strafesnet_common::{integer::vec3,model::{self,ColorId,IndexedVertex,NormalId,PolygonGroup,PolygonList,PositionId,RenderConfigId,TextureCoordinateId,VertexId}};
+use strafesnet_common::{integer::vec3,model::{self, ColorId, IndexedVertex, NormalId, PolygonGroup, PolygonList, PositionId, TextureCoordinateId, VertexId}};
 
-#[allow(dead_code)]
 #[derive(Debug)]
 pub enum Error{
 	Planar64Vec3(strafesnet_common::integer::Planar64TryFromFloatError),
@@ -205,13 +204,7 @@ pub fn convert(roblox_mesh_bytes:crate::data::RobloxMeshBytes)->Result<model::Me
 		unique_vertices,
 		polygon_groups,
 		//these should probably be moved to the model...
-		//but what if models want to use the same texture
+		graphics_groups:Vec::new(),
-		graphics_groups:vec![model::IndexedGraphicsGroup{
-			render:RenderConfigId::new(0),
-			//the lowest lod is highest quality
-			groups:vec![model::PolygonGroupId::new(0)]
-		}],
-		//disable physics
 		physics_groups:Vec::new(),
 	})
 }

lib/rbx_loader/src/primitives.rs

@@ -1,4 +1,4 @@
-use strafesnet_common::model::{Color4,TextureCoordinate,Mesh,IndexedGraphicsGroup,IndexedPhysicsGroup,IndexedVertex,PolygonGroupId,PolygonGroup,PolygonList,PositionId,TextureCoordinateId,NormalId,ColorId,VertexId,RenderConfigId};
+use strafesnet_common::model::{Color4,TextureCoordinate,Mesh,IndexedGraphicsGroup,IndexedPhysicsGroup,IndexedVertex,PolygonGroupId,PolygonGroup,PolygonList,IndexedVertexList,PositionId,TextureCoordinateId,NormalId,ColorId,VertexId,RenderConfigId};
 use strafesnet_common::integer::{vec3,Planar64Vec3};
 
 #[derive(Debug)]
@@ -126,6 +126,9 @@ const CORNERWEDGE_DEFAULT_NORMALS:[Planar64Vec3;5]=[
 	vec3::int( 0,-1, 0),//CornerWedge::Bottom
 	vec3::int( 0, 0,-1),//CornerWedge::Front
 ];
+pub fn unit_sphere(render:RenderConfigId)->Mesh{
+	unit_cube(render)
+}
 #[derive(Default)]
 pub struct CubeFaceDescription([Option<FaceDescription>;6]);
 impl CubeFaceDescription{
@@ -146,6 +149,10 @@ pub fn unit_cube(render:RenderConfigId)->Mesh{
 	t.insert(CubeFace::Front,FaceDescription::new_with_render_id(render));
 	generate_partial_unit_cube(t)
 }
+pub fn unit_cylinder(render:RenderConfigId)->Mesh{
+	//lmao
+	unit_cube(render)
+}
 #[derive(Default)]
 pub struct WedgeFaceDescription([Option<FaceDescription>;5]);
 impl WedgeFaceDescription{
@@ -156,15 +163,15 @@ impl WedgeFaceDescription{
 		self.0.into_iter().enumerate().filter_map(|v|v.1.map(|u|(v.0,u)))
 	}
 }
-// pub fn unit_wedge(render:RenderConfigId)->Mesh{
+pub fn unit_wedge(render:RenderConfigId)->Mesh{
-// 	let mut t=WedgeFaceDescription::default();
+	let mut t=WedgeFaceDescription::default();
-// 	t.insert(WedgeFace::Right,FaceDescription::new_with_render_id(render));
+	t.insert(WedgeFace::Right,FaceDescription::new_with_render_id(render));
-// 	t.insert(WedgeFace::TopFront,FaceDescription::new_with_render_id(render));
+	t.insert(WedgeFace::TopFront,FaceDescription::new_with_render_id(render));
-// 	t.insert(WedgeFace::Back,FaceDescription::new_with_render_id(render));
+	t.insert(WedgeFace::Back,FaceDescription::new_with_render_id(render));
-// 	t.insert(WedgeFace::Left,FaceDescription::new_with_render_id(render));
+	t.insert(WedgeFace::Left,FaceDescription::new_with_render_id(render));
-// 	t.insert(WedgeFace::Bottom,FaceDescription::new_with_render_id(render));
+	t.insert(WedgeFace::Bottom,FaceDescription::new_with_render_id(render));
-// 	generate_partial_unit_wedge(t)
+	generate_partial_unit_wedge(t)
-// }
+}
 #[derive(Default)]
 pub struct CornerWedgeFaceDescription([Option<FaceDescription>;5]);
 impl CornerWedgeFaceDescription{
@@ -175,15 +182,15 @@ impl CornerWedgeFaceDescription{
 		self.0.into_iter().enumerate().filter_map(|v|v.1.map(|u|(v.0,u)))
 	}
 }
-// pub fn unit_cornerwedge(render:RenderConfigId)->Mesh{
+pub fn unit_cornerwedge(render:RenderConfigId)->Mesh{
-// 	let mut t=CornerWedgeFaceDescription::default();
+	let mut t=CornerWedgeFaceDescription::default();
-// 	t.insert(CornerWedgeFace::Right,FaceDescription::new_with_render_id(render));
+	t.insert(CornerWedgeFace::Right,FaceDescription::new_with_render_id(render));
-// 	t.insert(CornerWedgeFace::TopBack,FaceDescription::new_with_render_id(render));
+	t.insert(CornerWedgeFace::TopBack,FaceDescription::new_with_render_id(render));
-// 	t.insert(CornerWedgeFace::TopLeft,FaceDescription::new_with_render_id(render));
+	t.insert(CornerWedgeFace::TopLeft,FaceDescription::new_with_render_id(render));
-// 	t.insert(CornerWedgeFace::Bottom,FaceDescription::new_with_render_id(render));
+	t.insert(CornerWedgeFace::Bottom,FaceDescription::new_with_render_id(render));
-// 	t.insert(CornerWedgeFace::Front,FaceDescription::new_with_render_id(render));
+	t.insert(CornerWedgeFace::Front,FaceDescription::new_with_render_id(render));
-// 	generate_partial_unit_cornerwedge(t)
+	generate_partial_unit_cornerwedge(t)
-// }
+}
 
 #[derive(Clone)]
 pub struct FaceDescription{

lib/rbx_loader/src/rbx.rs

@@ -130,9 +130,9 @@ impl ModesBuilder{
 	fn push_mode_update(&mut self,mode_id:gameplay_modes::ModeId,mode_update:gameplay_modes::ModeUpdate){
 		self.mode_updates.push((mode_id,mode_update));
 	}
-	// fn push_stage_update(&mut self,mode_id:gameplay_modes::ModeId,stage_id:gameplay_modes::StageId,stage_update:gameplay_modes::StageUpdate){
+	fn push_stage_update(&mut self,mode_id:gameplay_modes::ModeId,stage_id:gameplay_modes::StageId,stage_update:gameplay_modes::StageUpdate){
-	// 	self.stage_updates.push((mode_id,stage_id,stage_update));
+		self.stage_updates.push((mode_id,stage_id,stage_update));
-	// }
+	}
 }
 fn get_attributes(name:&str,can_collide:bool,velocity:Planar64Vec3,model_id:model::ModelId,modes_builder:&mut ModesBuilder,wormhole_in_model_to_id:&mut HashMap<model::ModelId,u32>,wormhole_id_to_out_model:&mut HashMap<u32,model::ModelId>)->attr::CollisionAttributes{
 	let mut general=attr::GeneralAttributes::default();
@@ -403,94 +403,13 @@ enum RobloxBasePartDescription{
 	Wedge(RobloxWedgeDescription),
 	CornerWedge(RobloxCornerWedgeDescription),
 }
-fn get_texture_description<AcquireRenderConfigId>(
-	temp_objects:&mut Vec<rbx_dom_weak::types::Ref>,
-	acquire_render_config_id:&mut AcquireRenderConfigId,
-	dom:&rbx_dom_weak::WeakDom,
-	object:&rbx_dom_weak::Instance,
-	size:&rbx_dom_weak::types::Vector3,
-)->RobloxPartDescription
-	where
-		AcquireRenderConfigId:FnMut(Option<&str>)->model::RenderConfigId,
-{
-	//use the biggest one and cut it down later...
-	let mut part_texture_description:RobloxPartDescription=[None,None,None,None,None,None];
-	temp_objects.clear();
-	recursive_collect_superclass(temp_objects,&dom,object,"Decal");
-	for &mut decal_ref in temp_objects{
-	if let Some(decal)=dom.get_by_ref(decal_ref){
-		if let (
-			Some(rbx_dom_weak::types::Variant::Content(content)),
-			Some(rbx_dom_weak::types::Variant::Enum(normalid)),
-			Some(rbx_dom_weak::types::Variant::Color3(decal_color3)),
-			Some(rbx_dom_weak::types::Variant::Float32(decal_transparency)),
-		) = (
-			decal.properties.get("Texture"),
-			decal.properties.get("Face"),
-			decal.properties.get("Color3"),
-			decal.properties.get("Transparency"),
-		) {
-			let render_id=acquire_render_config_id(Some(content.as_ref()));
-				let normal_id=normalid.to_u32();
-				if normal_id<6{
-					let (roblox_texture_color,roblox_texture_transform)=if decal.class=="Texture"{
-						//generate tranform
-						if let (
-								Some(rbx_dom_weak::types::Variant::Float32(ox)),
-								Some(rbx_dom_weak::types::Variant::Float32(oy)),
-								Some(rbx_dom_weak::types::Variant::Float32(sx)),
-								Some(rbx_dom_weak::types::Variant::Float32(sy)),
-							) = (
-								decal.properties.get("OffsetStudsU"),
-								decal.properties.get("OffsetStudsV"),
-								decal.properties.get("StudsPerTileU"),
-								decal.properties.get("StudsPerTileV"),
-							)
-						{
-							let (size_u,size_v)=match normal_id{
-								0=>(size.z,size.y),//right
-								1=>(size.x,size.z),//top
-								2=>(size.x,size.y),//back
-								3=>(size.z,size.y),//left
-								4=>(size.x,size.z),//bottom
-								5=>(size.x,size.y),//front
-								_=>unreachable!(),
-							};
-							(
-								glam::vec4(decal_color3.r,decal_color3.g,decal_color3.b,1.0-*decal_transparency),
-								RobloxTextureTransform{
-									offset_u:*ox/(*sx),offset_v:*oy/(*sy),
-									scale_u:size_u/(*sx),scale_v:size_v/(*sy),
-								}
-							)
-						}else{
-							(glam::Vec4::ONE,RobloxTextureTransform::default())
-						}
-					}else{
-						(glam::Vec4::ONE,RobloxTextureTransform::default())
-					};
-					part_texture_description[normal_id as usize]=Some(RobloxFaceTextureDescription{
-						render:render_id,
-						color:roblox_texture_color,
-						transform:roblox_texture_transform,
-					});
-				}else{
-					println!("NormalId={} is invalid",normal_id);
-				}
-			}
-		}
-	}
-	part_texture_description
-}
 enum Shape{
 	Primitive(primitives::Primitives),
 	MeshPart,
-	PhysicsData,
 }
-enum MeshAvailability<'a>{
+enum MeshAvailability{
 	Immediate,
-	DeferredMesh(RenderConfigId),
+	Deferred(RenderConfigId),
-	DeferredUnion(RobloxPartDescription,UnionDeferredAttributes<'a>),
 }
 struct DeferredModelDeferredAttributes{
 	render:RenderConfigId,
@@ -502,17 +421,6 @@ struct ModelDeferredAttributes{
 	color:model::Color4,//transparency is in here
 	transform:Planar64Affine3,
 }
-struct DeferredUnionDeferredAttributes<'a>{
-	render:RobloxPartDescription,
-	model:ModelDeferredAttributes,
-	union:UnionDeferredAttributes<'a>,
-}
-#[derive(Hash)]
-struct UnionDeferredAttributes<'a>{
-	asset_id:Option<&'a str>,
-	mesh_data:Option<&'a [u8]>,
-	physics_data:Option<&'a [u8]>,
-}
 struct ModelOwnedAttributes{
 	mesh:model::MeshId,
 	attributes:attr::CollisionAttributes,
@@ -524,17 +432,16 @@ struct GetAttributesArgs{
 	can_collide:bool,
 	velocity:Planar64Vec3,
 }
-pub fn convert<'a,AcquireRenderConfigId,AcquireMeshId>(
+pub fn convert<AcquireRenderConfigId,AcquireMeshId>(
-	dom:&'a rbx_dom_weak::WeakDom,
+	dom:&rbx_dom_weak::WeakDom,
 	mut acquire_render_config_id:AcquireRenderConfigId,
 	mut acquire_mesh_id:AcquireMeshId,
-)->PartialMap1<'a>
+)->PartialMap1
 where
 	AcquireRenderConfigId:FnMut(Option<&str>)->model::RenderConfigId,
 	AcquireMeshId:FnMut(&str)->model::MeshId,
 {
 
-	let mut deferred_unions_deferred_attributes=Vec::new();
 	let mut deferred_models_deferred_attributes=Vec::new();
 	let mut primitive_models_deferred_attributes=Vec::new();
 	let mut primitive_meshes=Vec::new();
@@ -564,7 +471,7 @@ where
 					object.properties.get("CanCollide"),
 				)
 			{
-				let mut model_transform=planar64_affine3_from_roblox(cf,size);
+				let model_transform=planar64_affine3_from_roblox(cf,size);
 
 				if model_transform.matrix3.det().is_zero(){
 					let mut parent_ref=object.parent();
@@ -578,6 +485,9 @@ where
 					continue;
 				}
 
+				//at this point a new model is going to be generated for sure.
+				let model_id=model::ModelId::new(primitive_models_deferred_attributes.len() as u32);
+
 				//TODO: also detect "CylinderMesh" etc here
 				let shape=match object.class.as_str(){
 					"Part"=>if let Some(rbx_dom_weak::types::Variant::Enum(shape))=object.properties.get("Shape"){
@@ -596,7 +506,6 @@ where
 					"WedgePart"=>Shape::Primitive(primitives::Primitives::Wedge),
 					"CornerWedgePart"=>Shape::Primitive(primitives::Primitives::CornerWedge),
 					"MeshPart"=>Shape::MeshPart,
-					"UnionOperation"=>Shape::PhysicsData,
 					_=>{
 						println!("Unsupported BasePart ClassName={}; defaulting to cube",object.class);
 						Shape::Primitive(primitives::Primitives::Cube)
@@ -605,8 +514,74 @@ where
 
 				let (availability,mesh_id)=match shape{
 					Shape::Primitive(primitive_shape)=>{
-				//TODO: TAB TAB
+						//TODO: TAB TAB
-				let part_texture_description=get_texture_description(&mut temp_objects,&mut acquire_render_config_id,dom,object,size);
+				//use the biggest one and cut it down later...
+				let mut part_texture_description:RobloxPartDescription=[None,None,None,None,None,None];
+				temp_objects.clear();
+				recursive_collect_superclass(&mut temp_objects, &dom, object,"Decal");
+				for &decal_ref in &temp_objects{
+					if let Some(decal)=dom.get_by_ref(decal_ref){
+						if let (
+							Some(rbx_dom_weak::types::Variant::Content(content)),
+							Some(rbx_dom_weak::types::Variant::Enum(normalid)),
+							Some(rbx_dom_weak::types::Variant::Color3(decal_color3)),
+							Some(rbx_dom_weak::types::Variant::Float32(decal_transparency)),
+						) = (
+							decal.properties.get("Texture"),
+							decal.properties.get("Face"),
+							decal.properties.get("Color3"),
+							decal.properties.get("Transparency"),
+						) {
+							let render_id=acquire_render_config_id(Some(content.as_ref()));
+								let normal_id=normalid.to_u32();
+								if normal_id<6{
+									let (roblox_texture_color,roblox_texture_transform)=if decal.class=="Texture"{
+										//generate tranform
+										if let (
+												Some(rbx_dom_weak::types::Variant::Float32(ox)),
+												Some(rbx_dom_weak::types::Variant::Float32(oy)),
+												Some(rbx_dom_weak::types::Variant::Float32(sx)),
+												Some(rbx_dom_weak::types::Variant::Float32(sy)),
+											) = (
+												decal.properties.get("OffsetStudsU"),
+												decal.properties.get("OffsetStudsV"),
+												decal.properties.get("StudsPerTileU"),
+												decal.properties.get("StudsPerTileV"),
+											)
+										{
+											let (size_u,size_v)=match normal_id{
+												0=>(size.z,size.y),//right
+												1=>(size.x,size.z),//top
+												2=>(size.x,size.y),//back
+												3=>(size.z,size.y),//left
+												4=>(size.x,size.z),//bottom
+												5=>(size.x,size.y),//front
+												_=>unreachable!(),
+											};
+											(
+												glam::vec4(decal_color3.r,decal_color3.g,decal_color3.b,1.0-*decal_transparency),
+												RobloxTextureTransform{
+													offset_u:*ox/(*sx),offset_v:*oy/(*sy),
+													scale_u:size_u/(*sx),scale_v:size_v/(*sy),
+												}
+											)
+										}else{
+											(glam::Vec4::ONE,RobloxTextureTransform::default())
+										}
+									}else{
+										(glam::Vec4::ONE,RobloxTextureTransform::default())
+									};
+									part_texture_description[normal_id as usize]=Some(RobloxFaceTextureDescription{
+										render:render_id,
+										color:roblox_texture_color,
+										transform:roblox_texture_transform,
+									});
+								}else{
+									println!("NormalId={} unsupported for shape={:?}",normal_id,primitive_shape);
+								}
+						}
+					}
+				}
 				//obscure rust syntax "slice pattern"
 				let [
 					f0,//Cube::Right
@@ -719,45 +694,12 @@ where
 						object.properties.get("TextureID"),
 					){
 						(
-							MeshAvailability::DeferredMesh(acquire_render_config_id(Some(texture_asset_id.as_ref()))),
+							MeshAvailability::Deferred(acquire_render_config_id(Some(texture_asset_id.as_ref()))),
 							acquire_mesh_id(mesh_asset_id.as_ref()),
 						)
 					}else{
 						panic!("Mesh has no Mesh or Texture");
 					},
-					Shape::PhysicsData=>{
-						//The union mesh is sized already
-						model_transform=planar64_affine3_from_roblox(cf,&rbx_dom_weak::types::Vector3{x:2.0,y:2.0,z:2.0});
-
-						let mut asset_id=None;
-						let mut mesh_data=None;
-						let mut physics_data=None;
-						if let Some(rbx_dom_weak::types::Variant::Content(content))=object.properties.get("AssetId"){
-							let value:&str=content.as_ref();
-							if !value.is_empty(){
-								asset_id=Some(value);
-							}
-						}
-						if let Some(rbx_dom_weak::types::Variant::BinaryString(data))=object.properties.get("MeshData"){
-							let value:&[u8]=data.as_ref();
-							if !value.is_empty(){
-								mesh_data=Some(value);
-							}
-						}
-						if let Some(rbx_dom_weak::types::Variant::BinaryString(data))=object.properties.get("PhysicsData"){
-							let value:&[u8]=data.as_ref();
-							if !value.is_empty(){
-								physics_data=Some(value);
-							}
-						}
-						let part_texture_description=get_texture_description(&mut temp_objects,&mut acquire_render_config_id,dom,object,size);
-						let union_deferred_attributes=UnionDeferredAttributes{
-							asset_id,
-							mesh_data,
-							physics_data,
-						};
-						(MeshAvailability::DeferredUnion(part_texture_description,union_deferred_attributes),mesh_id)
-					},
 				};
 				let model_deferred_attributes=ModelDeferredAttributes{
 					mesh:mesh_id,
@@ -771,15 +713,10 @@ where
 				};
 				match availability{
 					MeshAvailability::Immediate=>primitive_models_deferred_attributes.push(model_deferred_attributes),
-					MeshAvailability::DeferredMesh(render)=>deferred_models_deferred_attributes.push(DeferredModelDeferredAttributes{
+					MeshAvailability::Deferred(render)=>deferred_models_deferred_attributes.push(DeferredModelDeferredAttributes{
 						render,
 						model:model_deferred_attributes
 					}),
-					MeshAvailability::DeferredUnion(part_texture_description,union_deferred_attributes)=>deferred_unions_deferred_attributes.push(DeferredUnionDeferredAttributes{
-						render:part_texture_description,
-						model:model_deferred_attributes,
-						union:union_deferred_attributes,
-					}),
 				}
 			}
 		}
@@ -794,11 +731,10 @@ struct MeshWithAabb{
 	mesh:model::Mesh,
 	aabb:strafesnet_common::aabb::Aabb,
 }
-pub struct PartialMap1<'a>{
+pub struct PartialMap1{
 	primitive_meshes:Vec<model::Mesh>,
 	primitive_models_deferred_attributes:Vec<ModelDeferredAttributes>,
 	deferred_models_deferred_attributes:Vec<DeferredModelDeferredAttributes>,
-	deferred_union_deferred_attributes:Vec<DeferredModelDeferredAttributes>,
 }
 impl PartialMap1{
 	pub fn add_meshpart_meshes_and_calculate_attributes(
@@ -843,10 +779,12 @@ impl PartialMap1{
 				.entry(render).or_insert_with(||{
 					let mesh_id=model::MeshId::new(self.primitive_meshes.len() as u32);
 					let mut mesh_clone=mesh_with_aabb.mesh.clone();
-					//set the render group lool
+					//add a render group lool
-					if let Some(graphics_group)=mesh_clone.graphics_groups.first_mut(){
+					mesh_clone.graphics_groups.push(model::IndexedGraphicsGroup{
-						graphics_group.render=render;
+						render,
-					}
+						//the lowest lod is highest quality
+						groups:vec![model::PolygonGroupId::new(0)]
+					});
 					self.primitive_meshes.push(mesh_clone);
 					mesh_id
 				}),
@@ -951,14 +889,8 @@ impl PartialMap2{
 		=textures.into_iter().enumerate().map(|(new_texture_id,(old_texture_id,texture))|{
 			(texture,(old_texture_id,model::TextureId::new(new_texture_id as u32)))
 		}).unzip();
-		let render_configs=render_configs.into_iter().map(|(_render_config_id,mut render_config)|{
+		let render_configs=render_configs.into_iter().map(|(render_config_id,mut render_config)|{
-			// This may generate duplicate no-texture render configs but idc
+			//this may generate duplicate no-texture render configs but idc
-			//
-			// This is because some textures may not exist, so the render config
-			// that it points to is unique but is texture.
-			//
-			// I don't think this needs to be fixed because missing textures
-			// should be a conversion error anyways.
 			render_config.texture=render_config.texture.and_then(|texture_id|
 				texture_id_map.get(&texture_id).copied()
 			);

lib/rbx_loader/src/union.rs

@@ -1,144 +0,0 @@
-use std::collections::HashMap;
-
-use strafesnet_common::model::{self, ColorId, IndexedVertex, NormalId, PolygonGroup, PolygonGroupId, PolygonList, PositionId, RenderConfigId, TextureCoordinateId, VertexId};
-use strafesnet_common::integer::vec3;
-
-#[allow(dead_code)]
-#[derive(Debug)]
-pub enum Error{
-	Block,
-	NotSupposedToHappen,
-	MissingVertexId(u32),
-	Planar64Vec3(strafesnet_common::integer::Planar64TryFromFloatError),
-	RobloxPhysicsData(rbx_mesh::physics_data::Error),
-	RobloxMeshData(rbx_mesh::mesh_data::Error),
-}
-impl std::fmt::Display for Error{
-	fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
-		write!(f,"{self:?}")
-	}
-}
-
-impl std::error::Error for Error{}
-pub fn convert(roblox_physics_data:&[u8],roblox_mesh_data:&[u8])->Result<model::Mesh,Error>{
-	match (roblox_physics_data,roblox_mesh_data){
-		(b"",b"")=>return Err(Error::Block),
-		(b"",_)
-		|(_,b"")=>return Err(Error::NotSupposedToHappen),
-		_=>(),
-	}
-
-	// graphical
-	let mesh_data=rbx_mesh::read_mesh_data_versioned(
-		std::io::Cursor::new(roblox_mesh_data)
-	).map_err(Error::RobloxMeshData)?;
-	let graphics_mesh=match mesh_data{
-		rbx_mesh::mesh_data::CSGPHS::CSGK(csgk)=>return Err(Error::NotSupposedToHappen),
-		rbx_mesh::mesh_data::CSGPHS::CSGPHS2(mesh_data2)=>mesh_data2.mesh,
-		rbx_mesh::mesh_data::CSGPHS::CSGPHS4(mesh_data4)=>mesh_data4.mesh,
-	};
-
-	// physical
-	let physics_data=rbx_mesh::read_physics_data(
-		std::io::Cursor::new(roblox_physics_data)
-	).map_err(Error::RobloxPhysicsData)?;
-	let physics_convex_meshes=match physics_data{
-		rbx_mesh::physics_data::PhysicsData::CSGK(_)
-		// have not seen this format in practice
-		|rbx_mesh::physics_data::PhysicsData::CSGPHS(rbx_mesh::physics_data::CSGPHS::Block)
-		=>return Err(Error::NotSupposedToHappen),
-		rbx_mesh::physics_data::PhysicsData::CSGPHS(rbx_mesh::physics_data::CSGPHS::Meshes3(meshes))
-		|rbx_mesh::physics_data::PhysicsData::CSGPHS(rbx_mesh::physics_data::CSGPHS::Meshes5(meshes))
-		=>meshes.meshes,
-		rbx_mesh::physics_data::PhysicsData::CSGPHS(rbx_mesh::physics_data::CSGPHS::PhysicsInfoMesh(pim))
-		=>vec![pim.mesh],
-	};
-	let mut unique_pos=Vec::new();
-	let mut pos_id_from=HashMap::new();
-	let mut unique_tex=Vec::new();
-	let mut tex_id_from=HashMap::new();
-	let mut unique_normal=Vec::new();
-	let mut normal_id_from=HashMap::new();
-	let mut unique_color=Vec::new();
-	let mut color_id_from=HashMap::new();
-	let mut unique_vertices=Vec::new();
-	let mut vertex_id_from=HashMap::new();
-	let mut acquire_pos_id=|pos|{
-		let p=vec3::try_from_f32_array(pos).map_err(Error::Planar64Vec3)?;
-		Ok(*pos_id_from.entry(p).or_insert_with(||{
-			let pos_id=PositionId::new(unique_pos.len() as u32);
-			unique_pos.push(p);
-			pos_id
-		}))
-	};
-	let mut acquire_tex_id=|tex|{
-		let h=bytemuck::cast::<[f32;2],[u32;2]>(tex);
-		*tex_id_from.entry(h).or_insert_with(||{
-			let tex_id=TextureCoordinateId::new(unique_tex.len() as u32);
-			unique_tex.push(glam::Vec2::from_array(tex));
-			tex_id
-		})
-	};
-	let mut acquire_normal_id=|normal|{
-		let n=vec3::try_from_f32_array(normal).map_err(Error::Planar64Vec3)?;
-		Ok(*normal_id_from.entry(n).or_insert_with(||{
-			let normal_id=NormalId::new(unique_normal.len() as u32);
-			unique_normal.push(n);
-			normal_id
-		}))
-	};
-	let mut acquire_color_id=|color|{
-		let h=bytemuck::cast::<[f32;4],[u32;4]>(color);
-		*color_id_from.entry(h).or_insert_with(||{
-			let color_id=ColorId::new(unique_color.len() as u32);
-			unique_color.push(glam::Vec4::from_array(color));
-			color_id
-		})
-	};
-	let mut acquire_vertex_id=|vertex:IndexedVertex|{
-		*vertex_id_from.entry(vertex.clone()).or_insert_with(||{
-			let vertex_id=VertexId::new(unique_vertices.len() as u32);
-			unique_vertices.push(vertex);
-			vertex_id
-		})
-	};
-	let color=acquire_color_id([1.0f32;4]);
-	let tex=acquire_tex_id([0.0f32;2]);
-	let polygon_groups:Vec<PolygonGroup>=physics_convex_meshes.into_iter().map(|mesh|{
-		Ok(PolygonGroup::PolygonList(PolygonList::new(mesh.faces.into_iter().map(|[vertex_id0,vertex_id1,vertex_id2]|{
-			let v0=mesh.vertices.get(vertex_id0.0 as usize).ok_or(Error::MissingVertexId(vertex_id0.0))?;
-			let v1=mesh.vertices.get(vertex_id1.0 as usize).ok_or(Error::MissingVertexId(vertex_id1.0))?;
-			let v2=mesh.vertices.get(vertex_id2.0 as usize).ok_or(Error::MissingVertexId(vertex_id2.0))?;
-			let vertex_norm=(glam::Vec3::from_slice(v1)-glam::Vec3::from_slice(v0))
-			          .cross(glam::Vec3::from_slice(v2)-glam::Vec3::from_slice(v0)).to_array();
-			let mut ingest_vertex_id=|&vertex_pos:&[f32;3]|Ok(acquire_vertex_id(IndexedVertex{
-				pos:acquire_pos_id(vertex_pos)?,
-				tex,
-				normal:acquire_normal_id(vertex_norm)?,
-				color,
-			}));
-			Ok(vec![
-				ingest_vertex_id(v0)?,
-				ingest_vertex_id(v1)?,
-				ingest_vertex_id(v2)?,
-			])
-		}).collect::<Result<_,_>>()?)))
-	}).collect::<Result<_,_>>()?;
-	let graphics_groups=vec![model::IndexedGraphicsGroup{
-		render:RenderConfigId::new(0),
-		groups:(0..polygon_groups.len()).map(|id|PolygonGroupId::new(id as u32)).collect()
-	}];
-	let physics_groups=(0..polygon_groups.len()).map(|id|model::IndexedPhysicsGroup{
-		groups:vec![PolygonGroupId::new(id as u32)]
-	}).collect();
-	Ok(model::Mesh{
-		unique_pos,
-		unique_normal,
-		unique_tex,
-		unique_color,
-		unique_vertices,
-		polygon_groups,
-		graphics_groups,
-		physics_groups,
-	})
-}

lib/roblox_emulator/src/runner/macros.rs

@@ -1,22 +1,22 @@
 macro_rules! type_from_lua_userdata{
-	($ty:ident)=>{
+	($asd:ident)=>{
-		impl mlua::FromLua for $ty{
+		impl mlua::FromLua for $asd{
 			fn from_lua(value:mlua::Value,_lua:&mlua::Lua)->Result<Self,mlua::Error>{
 				match value{
 					mlua::Value::UserData(ud)=>Ok(*ud.borrow::<Self>()?),
-					other=>Err(mlua::Error::runtime(format!("Expected {} got {:?}",stringify!($ty),other))),
+					other=>Err(mlua::Error::runtime(format!("Expected {} got {:?}",stringify!($asd),other))),
 				}
 			}
 		}
 	};
 }
 macro_rules! type_from_lua_userdata_lua_lifetime{
-	($ty:ident)=>{
+	($asd:ident)=>{
-		impl mlua::FromLua for $ty<'static>{
+		impl mlua::FromLua for $asd<'static>{
 			fn from_lua(value:mlua::Value,_lua:&mlua::Lua)->Result<Self,mlua::Error>{
 				match value{
 					mlua::Value::UserData(ud)=>Ok(*ud.borrow::<Self>()?),
-					other=>Err(mlua::Error::runtime(format!("Expected {} got {:?}",stringify!($ty),other))),
+					other=>Err(mlua::Error::runtime(format!("Expected {} got {:?}",stringify!($asd),other))),
 				}
 			}
 		}

lib/roblox_emulator/src/scheduler.rs

@@ -59,8 +59,8 @@ fn schedule_thread(lua:&mlua::Lua,dt:mlua::Value)->Result<(),mlua::Error>{
 			match delay.classify(){
 				std::num::FpCategory::Nan=>Err(mlua::Error::runtime("NaN"))?,
 				// cases where the number is too large to schedule
-				std::num::FpCategory::Infinite
+				std::num::FpCategory::Infinite=>return Ok(()),
-				|std::num::FpCategory::Normal if (u64::MAX as f64)<delay=>{
+				std::num::FpCategory::Normal=>if (u64::MAX as f64)<delay{
 					return Ok(());
 				},
 				_=>(),

lib/snf/src/bot.rs

@@ -4,8 +4,6 @@ use crate::newtypes;
 use crate::file::BlockId;
 use strafesnet_common::physics::Time;
 
-const VERSION:u32=0;
-
 type TimedPhysicsInstruction=strafesnet_common::instruction::TimedInstruction<strafesnet_common::physics::Instruction,strafesnet_common::physics::TimeInner>;
 
 #[derive(Debug)]
@@ -30,16 +28,12 @@ pub enum Error{
 /* block types
 
 BLOCK_BOT_HEADER:
-// Segments are laid out in chronological order,
+// Tegments are laid out in chronological order,
 // but block_id is not necessarily in ascending order.
 //
 // This is to place the final segment close to the start of the file,
 // which allows the duration of the bot to be conveniently calculated
 // from the first and last instruction timestamps.
-//
-// Use exact physics version for replay playback
-// Use highest compatible physics version for verification
-u32 physics_version
 u32 num_segments
 for _ in 0..num_segments{
 	i64 time
@@ -67,7 +61,6 @@ struct SegmentHeader{
 #[binrw]
 #[brw(little)]
 struct Header{
-	physics_version:u32,
 	num_segments:u32,
 	#[br(count=num_segments)]
 	segments:Vec<SegmentHeader>,
@@ -76,7 +69,7 @@ struct Header{
 #[binrw]
 #[brw(little)]
 #[derive(Clone,Copy,Debug,id::Id)]
-pub struct SegmentId(u32);
+struct SegmentId(u32);
 
 pub struct Segment{
 	pub instructions:Vec<TimedPhysicsInstruction>
@@ -158,7 +151,7 @@ impl<R:BinReaderExt> StreamableBot<R>{
 }
 
 const MAX_BLOCK_SIZE:usize=64*1024;//64 kB
-pub fn write_bot<W:BinWriterExt>(mut writer:W,physics_version:u32,instructions:impl IntoIterator<Item=TimedPhysicsInstruction>)->Result<(),Error>{
+pub fn write_bot<W:BinWriterExt>(mut writer:W,instructions:impl IntoIterator<Item=TimedPhysicsInstruction>)->Result<(),Error>{
 	// decide which instructions to put in which segment
 	// write segment 1 to block 1
 	// write segment N to block 2
@@ -258,7 +251,6 @@ pub fn write_bot<W:BinWriterExt>(mut writer:W,physics_version:u32,instructions:i
 	};
 
 	let header=Header{
-		physics_version,
 		num_segments:num_segments as u32,
 		segments,
 	};
@@ -311,7 +303,7 @@ pub fn write_bot<W:BinWriterExt>(mut writer:W,physics_version:u32,instructions:i
 
 	let file_header=crate::file::Header{
 		fourcc:crate::file::FourCC::Bot,
-		version:VERSION,
+		version:0,
 		priming,
 		resource:0,
 		block_count,

lib/snf/src/map.rs

@@ -95,6 +95,21 @@ enum ResourceType{
 	//Video,
 	//Animation,
 }
+const RESOURCE_TYPE_VARIANT_COUNT:u8=2;
+#[binrw]
+#[brw(little)]
+struct ResourceId(u128);
+impl ResourceId{
+	fn resource_type(&self)->Option<ResourceType>{
+		let discriminant=self.0 as u8;
+		//TODO: use this when it is stabilized https://github.com/rust-lang/rust/issues/73662
+		//if (discriminant as usize)<std::mem::variant_count::<ResourceType>(){
+		match discriminant<RESOURCE_TYPE_VARIANT_COUNT{
+			true=>Some(unsafe{std::mem::transmute::<u8,ResourceType>(discriminant)}),
+			false=>None,
+		}
+	}
+}
 
 struct ResourceMap<T>{
 	meshes:HashMap<strafesnet_common::model::MeshId,T>,
@@ -121,6 +136,11 @@ struct ResourceBlockHeader{
 	resource:ResourceType,
 	id:BlockId,
 }
+#[binrw]
+#[brw(little)]
+struct ResourceExternalHeader{
+	resource_uuid:ResourceId,
+}
 
 #[binrw]
 #[brw(little)]

strafe-client/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "strafe-client"
-version = "0.11.0"
+version = "0.10.5"
 edition = "2021"
 repository = "https://git.itzana.me/StrafesNET/strafe-project"
 license = "Custom"
@@ -9,24 +9,25 @@ authors = ["Rhys Lloyd <krakow20@gmail.com>"]
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 [features]
-user-install=[] # as opposed to portable install
 default = ["snf"]
 snf = ["dep:strafesnet_snf"]
 source = ["dep:strafesnet_deferred_loader", "dep:strafesnet_bsp_loader"]
 roblox = ["dep:strafesnet_deferred_loader", "dep:strafesnet_rbx_loader"]
 
 [dependencies]
+arrayvec = "0.7.6"
+bytemuck = { version = "1.13.1", features = ["derive"] }
+configparser = "3.0.2"
+ddsfile = "0.5.1"
 glam = "0.29.0"
+id = { version = "0.1.0", registry = "strafesnet" }
 parking_lot = "0.12.1"
 pollster = "0.4.0"
+replace_with = "0.1.7"
 strafesnet_bsp_loader = { path = "../lib/bsp_loader", registry = "strafesnet", optional = true }
 strafesnet_common = { path = "../lib/common", registry = "strafesnet" }
 strafesnet_deferred_loader = { path = "../lib/deferred_loader", features = ["legacy"], registry = "strafesnet", optional = true }
-strafesnet_graphics = { path = "../engine/graphics", registry = "strafesnet" }
-strafesnet_physics = { path = "../engine/physics", registry = "strafesnet" }
 strafesnet_rbx_loader = { path = "../lib/rbx_loader", registry = "strafesnet", optional = true }
-strafesnet_session = { path = "../engine/session", registry = "strafesnet" }
-strafesnet_settings = { path = "../engine/settings", registry = "strafesnet" }
 strafesnet_snf = { path = "../lib/snf", registry = "strafesnet", optional = true }
 wgpu = "24.0.0"
 winit = "0.30.7"

strafe-client/src/app.rs

@@ -1,68 +0,0 @@
-use crate::window::Instruction;
-use strafesnet_common::integer;
-use strafesnet_common::instruction::TimedInstruction;
-use strafesnet_common::session::TimeInner as SessionTimeInner;
-
-pub struct App<'a>{
-	root_time:std::time::Instant,
-	window_thread:crate::compat_worker::QNWorker<'a,TimedInstruction<Instruction,SessionTimeInner>>,
-}
-impl<'a> App<'a>{
-	pub fn new(
-		root_time:std::time::Instant,
-		window_thread:crate::compat_worker::QNWorker<'a,TimedInstruction<Instruction,SessionTimeInner>>,
-	)->App<'a>{
-		Self{
-			root_time,
-			window_thread,
-		}
-	}
-	fn send_timed_instruction(&mut self,instruction:Instruction){
-		let time=integer::Time::from_nanos(self.root_time.elapsed().as_nanos() as i64);
-		self.window_thread.send(TimedInstruction{time,instruction}).unwrap();
-	}
-}
-impl winit::application::ApplicationHandler for App<'_>{
-	fn resumed(&mut self,_event_loop:&winit::event_loop::ActiveEventLoop){
-		//
-	}
-
-	fn window_event(
-		&mut self,
-		event_loop:&winit::event_loop::ActiveEventLoop,
-		_window_id:winit::window::WindowId,
-		event:winit::event::WindowEvent,
-	){
-		match event{
-			winit::event::WindowEvent::KeyboardInput{
-				event:winit::event::KeyEvent{
-					logical_key:winit::keyboard::Key::Named(winit::keyboard::NamedKey::Escape),
-					state:winit::event::ElementState::Pressed,
-					..
-				},
-				..
-			}
-			|winit::event::WindowEvent::CloseRequested=>{
-				event_loop.exit();
-			},
-			_=>(),
-		}
-		self.send_timed_instruction(Instruction::WindowEvent(event));
-	}
-
-	fn device_event(
-		&mut self,
-		_event_loop:&winit::event_loop::ActiveEventLoop,
-		_device_id:winit::event::DeviceId,
-		event:winit::event::DeviceEvent,
-	){
-		self.send_timed_instruction(Instruction::DeviceEvent(event));
-	}
-
-	fn about_to_wait(
-		&mut self,
-		_event_loop:&winit::event_loop::ActiveEventLoop
-	){
-		self.send_timed_instruction(Instruction::WindowEvent(winit::event::WindowEvent::RedrawRequested));
-	}
-}

strafe-client/src/body.rs

@@ -31,14 +31,6 @@ impl<T> Body<T>
 			time,
 		}
 	}
-	pub const fn relative_to<'a>(&'a self,body0:&'a Body<T>)->VirtualBody<'a,T>{
-		//(p0,v0,a0,t0)
-		//(p1,v1,a1,t1)
-		VirtualBody{
-			body0,
-			body1:self,
-		}
-	}
 	pub fn extrapolated_position(&self,time:Time<T>)->Planar64Vec3{
 		let dt=time-self.time;
 		self.position
@@ -90,7 +82,7 @@ impl<T> Body<T>
 		// a*dt + v
 		self.acceleration.map(|elem|(dt*elem).divide().fix())+self.velocity
 	}
-	pub fn advance_time_ratio_dt(&mut self,dt:crate::model::GigaTime){
+	pub fn advance_time_ratio_dt(&mut self,dt:crate::model_physics::GigaTime){
 		self.position=self.extrapolated_position_ratio_dt(dt);
 		self.velocity=self.extrapolated_velocity_ratio_dt(dt);
 		self.time+=dt.into();
@@ -145,6 +137,14 @@ pub struct VirtualBody<'a,T>{
 impl<T> VirtualBody<'_,T>
 	where Time<T>:Copy,
 {
+	pub const fn relative<'a>(body0:&'a Body<T>,body1:&'a Body<T>)->VirtualBody<'a,T>{
+		//(p0,v0,a0,t0)
+		//(p1,v1,a1,t1)
+		VirtualBody{
+			body0,
+			body1,
+		}
+	}
 	pub fn extrapolated_position(&self,time:Time<T>)->Planar64Vec3{
 		self.body1.extrapolated_position(time)-self.body0.extrapolated_position(time)
 	}

strafe-client/src/face_crawler.rs

@@ -1,4 +1,4 @@
-use crate::model::{GigaTime,FEV,MeshQuery,DirectedEdge};
+use crate::model_physics::{GigaTime,FEV,MeshQuery,DirectedEdge};
 use strafesnet_common::integer::{Fixed,Ratio,vec3::Vector3};
 use crate::physics::{Time,Body};
 
@@ -12,20 +12,6 @@ pub enum CrawlResult<M:MeshQuery>{
 	Miss(FEV<M>),
 	Hit(M::Face,GigaTime),
 }
-impl<M:MeshQuery> CrawlResult<M>{
-	pub fn hit(self)->Option<(M::Face,GigaTime)>{
-		match self{
-			CrawlResult::Miss(_)=>None,
-			CrawlResult::Hit(face,time)=>Some((face,time)),
-		}
-	}
-	pub fn miss(self)->Option<FEV<M>>{
-		match self{
-			CrawlResult::Miss(fev)=>Some(fev),
-			CrawlResult::Hit(_,_)=>None,
-		}
-	}
-}
 
 impl<F:Copy,M:MeshQuery<Normal=Vector3<F>,Offset=Fixed<4,128>>> FEV<M>
 	where

strafe-client/src/file.rs

@@ -1,6 +1,5 @@
 use std::io::Read;
 
-#[allow(dead_code)]
 #[derive(Debug)]
 pub enum ReadError{
 	#[cfg(feature="roblox")]
@@ -23,7 +22,7 @@ impl std::fmt::Display for ReadError{
 }
 impl std::error::Error for ReadError{}
 
-pub enum ReadFormat{
+enum Format{
 	#[cfg(feature="roblox")]
 	Roblox(strafesnet_rbx_loader::Model),
 	#[cfg(feature="source")]
@@ -34,33 +33,28 @@ pub enum ReadFormat{
 	SNFB(strafesnet_snf::bot::Segment),
 }
 
-pub fn read<R:Read+std::io::Seek>(input:R)->Result<ReadFormat,ReadError>{
+pub fn read<R:Read+std::io::Seek>(input:R)->Result<Format,ReadError>{
 	let mut buf=std::io::BufReader::new(input);
-	let peek=std::io::BufRead::fill_buf(&mut buf).map_err(ReadError::Io)?[0..4].to_owned();
+	let peek=std::io::BufRead::fill_buf(&mut buf).map_err(ReadError::Io)?;
-	// reading the entire file is way faster than round tripping the disk constantly
+	match &peek[0..4]{
-	let mut entire_file=Vec::new();
-	buf.read_to_end(&mut entire_file).map_err(ReadError::Io)?;
-	let cursor=std::io::Cursor::new(entire_file);
-	match peek.as_slice(){
 		#[cfg(feature="roblox")]
-		b"<rob"=>Ok(ReadFormat::Roblox(strafesnet_rbx_loader::read(cursor).map_err(ReadError::Roblox)?)),
+		b"<rob"=>Ok(Format::Roblox(strafesnet_rbx_loader::read(buf).map_err(ReadError::Roblox)?)),
 		#[cfg(feature="source")]
-		b"VBSP"=>Ok(ReadFormat::Source(strafesnet_bsp_loader::read(cursor).map_err(ReadError::Source)?)),
+		b"VBSP"=>Ok(Format::Source(strafesnet_bsp_loader::read(buf).map_err(ReadError::Source)?)),
 		#[cfg(feature="snf")]
-		b"SNFM"=>Ok(ReadFormat::SNFM(
+		b"SNFM"=>Ok(Format::SNFM(
-			strafesnet_snf::read_map(cursor).map_err(ReadError::StrafesNET)?
+			strafesnet_snf::read_map(buf).map_err(ReadError::StrafesNET)?
 			.into_complete_map().map_err(ReadError::StrafesNETMap)?
 		)),
 		#[cfg(feature="snf")]
-		b"SNFB"=>Ok(ReadFormat::SNFB(
+		b"SNFB"=>Ok(Format::SNFB(
-			strafesnet_snf::read_bot(cursor).map_err(ReadError::StrafesNET)?
+			strafesnet_snf::read_bot(buf).map_err(ReadError::StrafesNET)?
 			.read_all().map_err(ReadError::StrafesNETBot)?
 		)),
 		_=>Err(ReadError::UnknownFileFormat),
 	}
 }
 
-#[allow(dead_code)]
 #[derive(Debug)]
 pub enum LoadError{
 	ReadError(ReadError),
@@ -74,23 +68,23 @@ impl std::fmt::Display for LoadError{
 }
 impl std::error::Error for LoadError{}
 
-pub enum LoadFormat{
+pub enum Format2{
 	#[cfg(feature="snf")]
 	Map(strafesnet_common::map::CompleteMap),
 	#[cfg(feature="snf")]
 	Bot(strafesnet_snf::bot::Segment),
 }
 
-pub fn load<P:AsRef<std::path::Path>>(path:P)->Result<LoadFormat,LoadError>{
+pub fn load<P:AsRef<std::path::Path>>(path:P)->Result<Format2,LoadError>{
 	//blocking because it's simpler...
 	let file=std::fs::File::open(path).map_err(LoadError::File)?;
 	match read(file).map_err(LoadError::ReadError)?{
 		#[cfg(feature="snf")]
-		ReadFormat::SNFB(bot)=>Ok(LoadFormat::Bot(bot)),
+		Format::SNFB(bot)=>Ok(Format2::Bot(bot)),
 		#[cfg(feature="snf")]
-		ReadFormat::SNFM(map)=>Ok(LoadFormat::Map(map)),
+		Format::SNFM(map)=>Ok(Format2::Map(map)),
 		#[cfg(feature="roblox")]
-		ReadFormat::Roblox(model)=>{
+		Format::Roblox(model)=>{
 			let mut place=model.into_place();
 			place.run_scripts();
 
@@ -123,10 +117,10 @@ pub fn load<P:AsRef<std::path::Path>>(path:P)->Result<LoadFormat,LoadError>{
 				)
 			);
 
-			Ok(LoadFormat::Map(map))
+			Ok(Format2::Map(map))
 		},
 		#[cfg(feature="source")]
-		ReadFormat::Source(bsp)=>{
+		Format::Source(bsp)=>{
 			let mut loader=strafesnet_deferred_loader::source_legacy();
 
 			let (texture_loader,mesh_loader)=loader.get_inner_mut();
@@ -162,7 +156,7 @@ pub fn load<P:AsRef<std::path::Path>>(path:P)->Result<LoadFormat,LoadError>{
 				),
 			);
 
-			Ok(LoadFormat::Map(map))
+			Ok(Format2::Map(map))
 		},
 	}
 }

strafe-client/src/graphics.rs

@@ -1,15 +1,9 @@
 use std::borrow::Cow;
 use std::collections::{HashSet,HashMap};
 use strafesnet_common::map;
-use strafesnet_settings::settings;
-use strafesnet_session::session;
 use strafesnet_common::model::{self, ColorId, NormalId, PolygonIter, PositionId, RenderConfigId, TextureCoordinateId, VertexId};
 use wgpu::{util::DeviceExt,AstcBlock,AstcChannel};
-use crate::model::{self as model_graphics,IndexedGraphicsMeshOwnedRenderConfig,IndexedGraphicsMeshOwnedRenderConfigId,GraphicsMeshOwnedRenderConfig,GraphicsModelColor4,GraphicsModelOwned,GraphicsVertex};
+use crate::model_graphics::{self,IndexedGraphicsMeshOwnedRenderConfig,IndexedGraphicsMeshOwnedRenderConfigId,GraphicsMeshOwnedRenderConfig,GraphicsModelColor4,GraphicsModelOwned,GraphicsVertex};
-
-pub fn required_limits()->wgpu::Limits{
-	wgpu::Limits::default()
-}
 
 struct Indices{
 	count:u32,
@@ -142,7 +136,7 @@ impl GraphicsState{
 	pub fn clear(&mut self){
 		self.models.clear();
 	}
-	pub fn load_user_settings(&mut self,user_settings:&settings::UserSettings){
+	pub fn load_user_settings(&mut self,user_settings:&crate::settings::UserSettings){
 		self.camera.fov=user_settings.calculate_fov(1.0,&self.camera.screen_size).as_vec2();
 	}
 	pub fn generate_models(&mut self,device:&wgpu::Device,queue:&wgpu::Queue,map:&map::CompleteMap){
@@ -454,7 +448,7 @@ impl GraphicsState{
 		//.into_iter() the modeldata vec so entities can be /moved/ to models.entities
 		let mut model_count=0;
 		let mut instance_count=0;
-		let uniform_buffer_binding_size=required_limits().max_uniform_buffer_binding_size as usize;
+		let uniform_buffer_binding_size=crate::setup::required_limits().max_uniform_buffer_binding_size as usize;
 		let chunk_size=uniform_buffer_binding_size/MODEL_BUFFER_SIZE_BYTES;
 		self.models.reserve(models.len());
 		for model in models.into_iter(){
@@ -614,7 +608,7 @@ impl GraphicsState{
 		// Create the render pipeline
 		let shader=device.create_shader_module(wgpu::ShaderModuleDescriptor{
 			label:None,
-			source:wgpu::ShaderSource::Wgsl(Cow::Borrowed(include_str!("../../../strafe-client/src/shader.wgsl"))),
+			source:wgpu::ShaderSource::Wgsl(Cow::Borrowed(include_str!("shader.wgsl"))),
 		});
 
 		//load textures
@@ -642,10 +636,10 @@ impl GraphicsState{
 				wgpu::TextureFormat::Astc{
 					block:AstcBlock::B4x4,
 					channel:AstcChannel::UnormSrgb,
-				}=>&include_bytes!("../../../strafe-client/images/astc.dds")[..],
+				}=>&include_bytes!("../images/astc.dds")[..],
-				wgpu::TextureFormat::Etc2Rgb8UnormSrgb=>&include_bytes!("../../../strafe-client/images/etc2.dds")[..],
+				wgpu::TextureFormat::Etc2Rgb8UnormSrgb=>&include_bytes!("../images/etc2.dds")[..],
-				wgpu::TextureFormat::Bc1RgbaUnormSrgb=>&include_bytes!("../../../strafe-client/images/bc1.dds")[..],
+				wgpu::TextureFormat::Bc1RgbaUnormSrgb=>&include_bytes!("../images/bc1.dds")[..],
-				wgpu::TextureFormat::Bgra8UnormSrgb=>&include_bytes!("../../../strafe-client/images/bgra.dds")[..],
+				wgpu::TextureFormat::Bgra8UnormSrgb=>&include_bytes!("../images/bgra.dds")[..],
 				_=>unreachable!(),
 			};
 
@@ -688,7 +682,7 @@ impl GraphicsState{
 
 		//squid
 		let squid_texture_view={
-			let bytes=include_bytes!("../../../strafe-client/images/squid.dds");
+			let bytes=include_bytes!("../images/squid.dds");
 
 			let image=ddsfile::Dds::read(&mut std::io::Cursor::new(bytes)).unwrap();
 
@@ -870,7 +864,7 @@ impl GraphicsState{
 		&mut self,
 		device:&wgpu::Device,
 		config:&wgpu::SurfaceConfiguration,
-		user_settings:&settings::UserSettings,
+		user_settings:&crate::settings::UserSettings,
 	){
 		self.depth_view=Self::create_depth_texture(config,device);
 		self.camera.screen_size=glam::uvec2(config.width,config.height);
@@ -881,7 +875,7 @@ impl GraphicsState{
 		view:&wgpu::TextureView,
 		device:&wgpu::Device,
 		queue:&wgpu::Queue,
-		frame_state:session::FrameState,
+		frame_state:crate::session::FrameState,
 	){
 		//TODO:use scheduled frame times to create beautiful smoothing simulation physics extrapolation assuming no input
 

strafe-client/src/graphics_worker.rs

@@ -1,11 +1,7 @@
-use strafesnet_graphics::graphics;
-use strafesnet_session::session;
-use strafesnet_settings::settings;
-
 pub enum Instruction{
-	Render(session::FrameState),
+	Render(crate::session::FrameState),
-	//UpdateModel(graphics::GraphicsModelUpdate),
+	//UpdateModel(crate::graphics::GraphicsModelUpdate),
-	Resize(winit::dpi::PhysicalSize<u32>,settings::UserSettings),
+	Resize(winit::dpi::PhysicalSize<u32>,crate::settings::UserSettings),
 	ChangeMap(strafesnet_common::map::CompleteMap),
 }
 
@@ -19,7 +15,7 @@ WorkerDescription{
 //up to three frames in flight, dropping new frame requests when all three are busy, and dropping output frames when one renders out of order
 
 pub fn new(
-	mut graphics:graphics::GraphicsState,
+	mut graphics:crate::graphics::GraphicsState,
 	mut config:wgpu::SurfaceConfiguration,
 	surface:wgpu::Surface,
 	device:wgpu::Device,

strafe-client/src/main.rs

@@ -1,11 +1,20 @@
-mod app;
+mod body;
 mod file;
 mod setup;
 mod window;
 mod worker;
+mod physics;
+mod session;
+mod graphics;
+mod settings;
+mod push_solve;
+mod face_crawler;
 mod compat_worker;
+mod model_physics;
+mod model_graphics;
 mod physics_worker;
 mod graphics_worker;
+mod mouse_interpolator;
 
 const TITLE:&'static str=concat!("Strafe Client v",env!("CARGO_PKG_VERSION"));
 

strafe-client/src/model_physics.rs

@@ -1,6 +1,5 @@
 use std::borrow::{Borrow,Cow};
 use std::collections::{HashSet,HashMap};
-use core::ops::Range;
 use strafesnet_common::integer::vec3::Vector3;
 use strafesnet_common::model::{self,MeshId,PolygonIter};
 use strafesnet_common::integer::{self,vec3,Fixed,Planar64,Planar64Vec3,Ratio};
@@ -719,40 +718,48 @@ impl MinkowskiMesh<'_>{
 	//
 	// Most of the calculation time is just calculating the starting point
 	// for the "actual" crawling algorithm below (predict_collision_{in|out}).
-	fn closest_fev_not_inside(&self,mut infinity_body:Body,start_time:Time)->Option<FEV<MinkowskiMesh>>{
+	fn closest_fev_not_inside(&self,mut infinity_body:Body)->Option<FEV<MinkowskiMesh>>{
-		infinity_body.infinity_dir().and_then(|dir|{
+		infinity_body.infinity_dir().map_or(None,|dir|{
 			let infinity_fev=self.infinity_fev(-dir,infinity_body.position);
 			//a line is simpler to solve than a parabola
 			infinity_body.velocity=dir;
 			infinity_body.acceleration=vec3::ZERO;
 			//crawl in from negative infinity along a tangent line to get the closest fev
 			// TODO: change crawl_fev args to delta time? Optional values?
-			infinity_fev.crawl(self,&infinity_body,Time::MIN/4,start_time).miss()
+			match infinity_fev.crawl(self,&infinity_body,Time::MIN/4,infinity_body.time){
+				crate::face_crawler::CrawlResult::Miss(fev)=>Some(fev),
+				crate::face_crawler::CrawlResult::Hit(_,_)=>None,
+			}
 		})
 	}
-	pub fn predict_collision_in(&self,relative_body:&Body,Range{start:start_time,end:time_limit}:Range<Time>)->Option<(MinkowskiFace,GigaTime)>{
+	pub fn predict_collision_in(&self,relative_body:&Body,time_limit:Time)->Option<(MinkowskiFace,GigaTime)>{
-		self.closest_fev_not_inside(relative_body.clone(),start_time).and_then(|fev|{
+		self.closest_fev_not_inside(relative_body.clone()).map_or(None,|fev|{
 			//continue forwards along the body parabola
-			fev.crawl(self,relative_body,start_time,time_limit).hit()
+			match fev.crawl(self,relative_body,relative_body.time,time_limit){
+				crate::face_crawler::CrawlResult::Miss(_)=>None,
+				crate::face_crawler::CrawlResult::Hit(face,time)=>Some((face,time)),
+			}
 		})
 	}
-	pub fn predict_collision_out(&self,relative_body:&Body,Range{start:start_time,end:time_limit}:Range<Time>)->Option<(MinkowskiFace,GigaTime)>{
+	pub fn predict_collision_out(&self,relative_body:&Body,time_limit:Time)->Option<(MinkowskiFace,GigaTime)>{
 		//create an extrapolated body at time_limit
-		let infinity_body=-relative_body.clone();
+		let infinity_body=Body::new(
-		self.closest_fev_not_inside(infinity_body,-time_limit).and_then(|fev|{
+			relative_body.extrapolated_position(time_limit),
+			-relative_body.extrapolated_velocity(time_limit),
+			relative_body.acceleration,
+			-time_limit,
+		);
+		self.closest_fev_not_inside(infinity_body).map_or(None,|fev|{
 			//continue backwards along the body parabola
-			fev.crawl(self,&infinity_body,-time_limit,-start_time).hit()
+			match fev.crawl(self,&-relative_body.clone(),-time_limit,-relative_body.time){
-				//no need to test -time<time_limit because of the first step
+				crate::face_crawler::CrawlResult::Miss(_)=>None,
-				.map(|(face,time)|(face,-time))
+				crate::face_crawler::CrawlResult::Hit(face,time)=>Some((face,-time)),//no need to test -time<time_limit because of the first step
+			}
 		})
 	}
-	pub fn predict_collision_face_out(&self,relative_body:&Body,Range{start:start_time,end:time_limit}:Range<Time>,contact_face_id:MinkowskiFace)->Option<(MinkowskiEdge,GigaTime)>{
+	pub fn predict_collision_face_out(&self,relative_body:&Body,time_limit:Time,contact_face_id:MinkowskiFace)->Option<(MinkowskiEdge,GigaTime)>{
 		//no algorithm needed, there is only one state and two cases (Edge,None)
 		//determine when it passes an edge ("sliding off" case)
-		let start_time={
-			let r=(start_time-relative_body.time).to_ratio();
-			Ratio::new(r.num,r.den)
-		};
 		let mut best_time={
 			let r=(time_limit-relative_body.time).to_ratio();
 			Ratio::new(r.num.fix_4(),r.den.fix_4())
@@ -768,7 +775,7 @@ impl MinkowskiMesh<'_>{
 			//WARNING! d outside of *2
 			//WARNING: truncated precision
 			for dt in Fixed::<4,128>::zeroes2(((n.dot(relative_body.position))*2-d).fix_4(),n.dot(relative_body.velocity).fix_4()*2,n.dot(relative_body.acceleration).fix_4()){
-				if start_time.le_ratio(dt)&&dt.lt_ratio(best_time)&&n.dot(relative_body.extrapolated_velocity_ratio_dt(dt)).is_negative(){
+				if Ratio::new(Planar64::ZERO,Planar64::EPSILON).le_ratio(dt)&&dt.lt_ratio(best_time)&&n.dot(relative_body.extrapolated_velocity_ratio_dt(dt)).is_negative(){
 					best_time=dt;
 					best_edge=Some(directed_edge_id);
 					break;
@@ -779,7 +786,10 @@ impl MinkowskiMesh<'_>{
 	}
 	fn infinity_in(&self,infinity_body:Body)->Option<(MinkowskiFace,GigaTime)>{
 		let infinity_fev=self.infinity_fev(-infinity_body.velocity,infinity_body.position);
-		infinity_fev.crawl(self,&infinity_body,Time::MIN/4,infinity_body.time).hit()
+		match infinity_fev.crawl(self,&infinity_body,Time::MIN/4,infinity_body.time){
+			crate::face_crawler::CrawlResult::Miss(_)=>None,
+			crate::face_crawler::CrawlResult::Hit(face,time)=>Some((face,time)),
+		}
 	}
 	pub fn is_point_in_mesh(&self,point:Planar64Vec3)->bool{
 		let infinity_body=Body::new(point,vec3::Y,vec3::ZERO,Time::ZERO);
@@ -985,7 +995,7 @@ fn is_empty_volume(normals:Vec<Vector3<Fixed<3,96>>>)->bool{
 			for k in 0..len{
 				if k!=i&&k!=j{
 					let d=n.dot(normals[k]).is_negative();
-					if let &Some(comp)=&d_comp{
+					if let Some(comp)=&d_comp{
 						// This is testing if d_comp*d < 0
 						if comp^d{
 							return true;
@@ -1005,3 +1015,9 @@ fn test_is_empty_volume(){
 	assert!(!is_empty_volume([vec3::X.fix_3(),vec3::Y.fix_3(),vec3::Z.fix_3()].to_vec()));
 	assert!(is_empty_volume([vec3::X.fix_3(),vec3::Y.fix_3(),vec3::Z.fix_3(),vec3::NEG_X.fix_3()].to_vec()));
 }
+
+#[test]
+fn build_me_a_cube(){
+	let mesh=PhysicsMesh::unit_cube();
+	//println!("mesh={:?}",mesh);
+}

strafe-client/src/physics.rs

@@ -1,5 +1,5 @@
 use std::collections::{HashMap,HashSet};
-use crate::model::{self as model_physics,PhysicsMesh,PhysicsMeshTransform,TransformedMesh,MeshQuery,PhysicsMeshId,PhysicsSubmeshId};
+use crate::model_physics::{self,PhysicsMesh,PhysicsMeshTransform,TransformedMesh,MeshQuery,PhysicsMeshId,PhysicsSubmeshId};
 use strafesnet_common::bvh;
 use strafesnet_common::map;
 use strafesnet_common::run;
@@ -32,7 +32,7 @@ pub enum InternalInstruction{
 	// Water,
 }
 
-#[derive(Clone,Debug)]
+#[derive(Clone,Debug,Default)]
 pub struct InputState{
 	mouse:MouseState,
 	next_mouse:MouseState,
@@ -40,15 +40,10 @@ pub struct InputState{
 }
 impl InputState{
 	fn set_next_mouse(&mut self,next_mouse:MouseState){
-		// would this be correct?
-		// if self.next_mouse.time==next_mouse.time{
-			// self.next_mouse=next_mouse;
-		// }else{
 		//I like your functions magic language
 		self.mouse=std::mem::replace(&mut self.next_mouse,next_mouse);
 		//equivalently:
 		//(self.next_mouse,self.mouse)=(next_mouse,self.next_mouse.clone());
-		// }
 	}
 	fn replace_mouse(&mut self,mouse:MouseState,next_mouse:MouseState){
 		(self.next_mouse,self.mouse)=(next_mouse,mouse);
@@ -70,15 +65,6 @@ impl InputState{
 		((dm*t)/dt).as_ivec2()
 	}
 }
-impl Default for InputState{
-	fn default()->Self{
-		Self{
-			mouse:MouseState{pos:Default::default(),time:Time::ZERO-Time::EPSILON*2},
-			next_mouse:MouseState{pos:Default::default(),time:Time::ZERO-Time::EPSILON},
-			controls:Default::default(),
-		}
-	}
-}
 #[derive(Clone,Debug)]
 enum JumpDirection{
 	Exactly(Planar64Vec3),
@@ -161,17 +147,17 @@ fn ground_things(walk_settings:&gameplay_style::WalkSettings,contact:&ContactCol
 	let normal=contact_normal(models,hitbox_mesh,contact);
 	let gravity=touching.base_acceleration(models,style,camera,input_state);
 	let control_dir=style.get_y_control_dir(camera,input_state.controls);
-	let target_velocity=walk_settings.get_walk_target_velocity(control_dir,normal);
+	let mut target_velocity=walk_settings.get_walk_target_velocity(control_dir,normal);
-	let target_velocity_clipped=touching.constrain_velocity(models,hitbox_mesh,target_velocity);
+	touching.constrain_velocity(models,hitbox_mesh,&mut target_velocity);
-	(gravity,target_velocity_clipped)
+	(gravity,target_velocity)
 }
 fn ladder_things(ladder_settings:&gameplay_style::LadderSettings,contact:&ContactCollision,touching:&TouchingState,models:&PhysicsModels,hitbox_mesh:&HitboxMesh,style:&StyleModifiers,camera:&PhysicsCamera,input_state:&InputState)->(Planar64Vec3,Planar64Vec3){
 	let normal=contact_normal(models,hitbox_mesh,contact);
 	let gravity=touching.base_acceleration(models,style,camera,input_state);
 	let control_dir=style.get_y_control_dir(camera,input_state.controls);
-	let target_velocity=ladder_settings.get_ladder_target_velocity(control_dir,normal);
+	let mut target_velocity=ladder_settings.get_ladder_target_velocity(control_dir,normal);
-	let target_velocity_clipped=touching.constrain_velocity(models,hitbox_mesh,target_velocity);
+	touching.constrain_velocity(models,hitbox_mesh,&mut target_velocity);
-	(gravity,target_velocity_clipped)
+	(gravity,target_velocity)
 }
 
 #[derive(Default)]
@@ -229,6 +215,12 @@ impl PhysicsModels{
 				.map(|model|&model.transform),
 		}
 	}
+	fn contact_model(&self,model_id:ContactModelId)->&ContactModel{
+		&self.contact_models[&model_id]
+	}
+	fn intersect_model(&self,model_id:IntersectModelId)->&IntersectModel{
+		&self.intersect_models[&model_id]
+	}
 	fn contact_attr(&self,model_id:ContactModelId)->&gameplay_attributes::ContactAttributes{
 		&self.contact_attributes[&self.contact_models[&model_id].attr_id]
 	}
@@ -263,7 +255,7 @@ impl PhysicsCamera{
 		);
 		self.clamped_mouse_pos=unclamped_mouse_pos;
 	}
-	pub fn simulate_move_angles(&self,mouse_delta:glam::IVec2)->glam::Vec2{
+	pub fn simulate_move_angles(&self,mouse_delta:glam::IVec2)->glam::Vec2 {
 		let a=-self.sensitivity.mul_int((self.clamped_mouse_pos+mouse_delta).as_i64vec2());
 		let ax=Angle32::wrap_from_i64(a.x);
 		let ay=Angle32::clamp_from_i64(a.y)
@@ -762,8 +754,8 @@ impl TouchingState{
 		//TODO: add water
 		a
 	}
-	fn constrain_velocity(&self,models:&PhysicsModels,hitbox_mesh:&HitboxMesh,velocity:Planar64Vec3)->Planar64Vec3{
+	fn constrain_velocity(&self,models:&PhysicsModels,hitbox_mesh:&HitboxMesh,velocity:&mut Planar64Vec3){
-		let contacts:Vec<_>=self.contacts.iter().map(|contact|{
+		let contacts=self.contacts.iter().map(|contact|{
 			let n=contact_normal(models,hitbox_mesh,contact);
 			crate::push_solve::Contact{
 				position:vec3::ZERO,
@@ -771,10 +763,10 @@ impl TouchingState{
 				normal:n,
 			}
 		}).collect();
-		crate::push_solve::push_solve(&contacts,velocity)
+		*velocity=crate::push_solve::push_solve(&contacts,*velocity);
 	}
-	fn constrain_acceleration(&self,models:&PhysicsModels,hitbox_mesh:&HitboxMesh,acceleration:Planar64Vec3)->Planar64Vec3{
+	fn constrain_acceleration(&self,models:&PhysicsModels,hitbox_mesh:&HitboxMesh,acceleration:&mut Planar64Vec3){
-		let contacts:Vec<_>=self.contacts.iter().map(|contact|{
+		let contacts=self.contacts.iter().map(|contact|{
 			let n=contact_normal(models,hitbox_mesh,contact);
 			crate::push_solve::Contact{
 				position:vec3::ZERO,
@@ -782,16 +774,15 @@ impl TouchingState{
 				normal:n,
 			}
 		}).collect();
-		crate::push_solve::push_solve(&contacts,acceleration)
+		*acceleration=crate::push_solve::push_solve(&contacts,*acceleration);
 	}
-	fn predict_collision_end(&self,collector:&mut instruction::InstructionCollector<InternalInstruction,TimeInner>,models:&PhysicsModels,hitbox_mesh:&HitboxMesh,body:&Body,start_time:Time){
+	fn predict_collision_end(&self,collector:&mut instruction::InstructionCollector<InternalInstruction,TimeInner>,models:&PhysicsModels,hitbox_mesh:&HitboxMesh,body:&Body,time:Time){
-		// let relative_body=body.relative_to(&Body::ZERO);
+		let relative_body=crate::body::VirtualBody::relative(&Body::ZERO,body).body(time);
-		let relative_body=body;
 		for contact in &self.contacts{
 			//detect face slide off
 			let model_mesh=models.contact_mesh(contact);
 			let minkowski=model_physics::MinkowskiMesh::minkowski_sum(model_mesh,hitbox_mesh.transformed_mesh());
-			collector.collect(minkowski.predict_collision_face_out(&relative_body,start_time..collector.time(),contact.face_id).map(|(_face,time)|{
+			collector.collect(minkowski.predict_collision_face_out(&relative_body,collector.time(),contact.face_id).map(|(_face,time)|{
 				TimedInstruction{
 					time:relative_body.time+time.into(),
 					instruction:InternalInstruction::CollisionEnd(
@@ -805,7 +796,7 @@ impl TouchingState{
 			//detect model collision in reverse
 			let model_mesh=models.intersect_mesh(intersect);
 			let minkowski=model_physics::MinkowskiMesh::minkowski_sum(model_mesh,hitbox_mesh.transformed_mesh());
-			collector.collect(minkowski.predict_collision_out(&relative_body,start_time..collector.time()).map(|(_face,time)|{
+			collector.collect(minkowski.predict_collision_out(&relative_body,collector.time()).map(|(_face,time)|{
 				TimedInstruction{
 					time:relative_body.time+time.into(),
 					instruction:InternalInstruction::CollisionEnd(
@@ -869,9 +860,6 @@ impl PhysicsState{
 	pub const fn mode(&self)->gameplay_modes::ModeId{
 		self.mode_state.get_mode_id()
 	}
-	pub fn get_finish_time(&self)->Option<run::Time>{
-		self.run.get_finish_time()
-	}
 	pub fn clear(&mut self){
 		self.touching.clear();
 	}
@@ -1123,7 +1111,7 @@ impl PhysicsData{
 	//this is the one who asks
 	fn next_instruction_internal(state:&PhysicsState,data:&PhysicsData,time_limit:Time)->Option<TimedInstruction<InternalInstruction,TimeInner>>{
 		//JUST POLLING!!! NO MUTATION
-		let mut collector=instruction::InstructionCollector::new(time_limit);
+		let mut collector = instruction::InstructionCollector::new(time_limit);
 
 		collector.collect(state.next_move_instruction());
 
@@ -1134,15 +1122,15 @@ impl PhysicsData{
 		state.body.grow_aabb(&mut aabb,state.time,collector.time());
 		aabb.inflate(data.hitbox_mesh.halfsize);
 		//relative to moving platforms
-		//let relative_body=state.body.relative_to(&Body::ZERO);
+		//let relative_body=&VirtualBody::relative(&Body::default(),&state.body).body(state.time);
 		let relative_body=&state.body;
 		data.bvh.the_tester(&aabb,&mut |&convex_mesh_id|{
 			//no checks are needed because of the time limits.
 			let model_mesh=data.models.mesh(convex_mesh_id);
 			let minkowski=model_physics::MinkowskiMesh::minkowski_sum(model_mesh,data.hitbox_mesh.transformed_mesh());
-			collector.collect(minkowski.predict_collision_in(relative_body,state.time..collector.time())
+			collector.collect(minkowski.predict_collision_in(relative_body,collector.time())
 				//temp (?) code to avoid collision loops
-				.and_then(|(face,dt)|{
+				.map_or(None,|(face,dt)|{
 					// this must be rounded to avoid the infinite loop when hitting the start zone
 					let time=relative_body.time+dt.into();
 					(state.time<time).then_some((time,face,dt))
@@ -1157,7 +1145,7 @@ impl PhysicsData{
 				)
 			);
 		});
-		collector.take()
+		collector.instruction()
 	}
 
 
@@ -1197,7 +1185,7 @@ fn recalculate_touching(
 	aabb.grow(body.position);
 	aabb.inflate(hitbox_mesh.halfsize);
 	//relative to moving platforms
-	//let relative_body=state.body.relative_to(&Body::ZERO);
+	//let relative_body=&VirtualBody::relative(&Body::default(),&state.body).body(state.time);
 	bvh.the_tester(&aabb,&mut |&convex_mesh_id|{
 		//no checks are needed because of the time limits.
 		let model_mesh=models.mesh(convex_mesh_id);
@@ -1252,14 +1240,16 @@ fn set_velocity_cull(body:&mut Body,touching:&mut TouchingState,models:&PhysicsM
 		let r=n.dot(v).is_positive();
 		if r{
 			culled=true;
+			println!("set_velocity_cull contact={:?}",contact);
 		}
 		!r
 	});
 	set_velocity(body,touching,models,hitbox_mesh,v);
 	culled
 }
-fn set_velocity(body:&mut Body,touching:&TouchingState,models:&PhysicsModels,hitbox_mesh:&HitboxMesh,v:Planar64Vec3){
+fn set_velocity(body:&mut Body,touching:&TouchingState,models:&PhysicsModels,hitbox_mesh:&HitboxMesh,mut v:Planar64Vec3){
-	body.velocity=touching.constrain_velocity(models,hitbox_mesh,v);;
+	touching.constrain_velocity(models,hitbox_mesh,&mut v);
+	body.velocity=v;
 }
 fn set_acceleration_cull(body:&mut Body,touching:&mut TouchingState,models:&PhysicsModels,hitbox_mesh:&HitboxMesh,a:Planar64Vec3)->bool{
 	//This is not correct but is better than what I have
@@ -1269,14 +1259,16 @@ fn set_acceleration_cull(body:&mut Body,touching:&mut TouchingState,models:&Phys
 		let r=n.dot(a).is_positive();
 		if r{
 			culled=true;
+			println!("set_acceleration_cull contact={:?}",contact);
 		}
 		!r
 	});
 	set_acceleration(body,touching,models,hitbox_mesh,a);
 	culled
 }
-fn set_acceleration(body:&mut Body,touching:&TouchingState,models:&PhysicsModels,hitbox_mesh:&HitboxMesh,a:Planar64Vec3){
+fn set_acceleration(body:&mut Body,touching:&TouchingState,models:&PhysicsModels,hitbox_mesh:&HitboxMesh,mut a:Planar64Vec3){
-	body.acceleration=touching.constrain_acceleration(models,hitbox_mesh,a);
+	touching.constrain_acceleration(models,hitbox_mesh,&mut a);
+	body.acceleration=a;
 }
 
 fn teleport(
@@ -1485,7 +1477,7 @@ fn collision_start_contact(
 	let model_id=contact.model_id.into();
 	let mut allow_run_teleport_behaviour=not_spawn_at(mode,model_id);
 	match &attr.contacting.contact_behaviour{
-		Some(gameplay_attributes::ContactingBehaviour::Surf)=>(),
+		Some(gameplay_attributes::ContactingBehaviour::Surf)=>println!("I'm surfing!"),
 		Some(gameplay_attributes::ContactingBehaviour::Cling)=>println!("Unimplemented!"),
 		&Some(gameplay_attributes::ContactingBehaviour::Elastic(elasticity))=>{
 			let reflected_velocity=body.velocity+((body.velocity-incident_velocity)*Planar64::raw(elasticity as i64+1)).fix_1();
@@ -1515,21 +1507,6 @@ fn collision_start_contact(
 			}
 		},
 	}
-	match &attr.general.trajectory{
-		Some(trajectory)=>{
-			match trajectory{
-				gameplay_attributes::SetTrajectory::AirTime(_)=>todo!(),
-				gameplay_attributes::SetTrajectory::Height(_)=>todo!(),
-				gameplay_attributes::SetTrajectory::TargetPointTime{..}=>todo!(),
-				gameplay_attributes::SetTrajectory::TargetPointSpeed{..}=>todo!(),
-				&gameplay_attributes::SetTrajectory::Velocity(velocity)=>{
-					move_state.cull_velocity(velocity,body,touching,models,hitbox_mesh,style,camera,input_state);
-				},
-				gameplay_attributes::SetTrajectory::DotVelocity{..}=>todo!(),
-			}
-		},
-		None=>(),
-	}
 	//I love making functions with 10 arguments to dodge the borrow checker
 	if allow_run_teleport_behaviour{
 		run_teleport_behaviour(model_id,attr.general.wormhole.as_ref(),mode,move_state,body,touching,run,mode_state,models,hitbox_mesh,bvh,style,camera,input_state,time);
@@ -1557,6 +1534,21 @@ fn collision_start_contact(
 			}
 		}
 	}
+	match &attr.general.trajectory{
+		Some(trajectory)=>{
+			match trajectory{
+				gameplay_attributes::SetTrajectory::AirTime(_)=>todo!(),
+				gameplay_attributes::SetTrajectory::Height(_)=>todo!(),
+				gameplay_attributes::SetTrajectory::TargetPointTime { target_point: _, time: _ }=>todo!(),
+				gameplay_attributes::SetTrajectory::TargetPointSpeed { target_point: _, speed: _, trajectory_choice: _ }=>todo!(),
+				&gameplay_attributes::SetTrajectory::Velocity(velocity)=>{
+					move_state.cull_velocity(velocity,body,touching,models,hitbox_mesh,style,camera,input_state);
+				},
+				gameplay_attributes::SetTrajectory::DotVelocity { direction: _, dot: _ }=>todo!(),
+			}
+		},
+		None=>(),
+	}
 	//doing enum to set the acceleration when surfing
 	//doing input_and_body to refresh the walk state if you hit a wall while accelerating
 	move_state.apply_enum_and_input_and_body(body,touching,models,hitbox_mesh,style,camera,input_state);
@@ -1727,19 +1719,19 @@ fn atomic_internal_instruction(state:&mut PhysicsState,data:&PhysicsData,ins:Tim
 					|MoveState::Fly
 					=>println!("ReachWalkTargetVelocity fired for non-walking MoveState"),
 					MoveState::Walk(walk_state)|MoveState::Ladder(walk_state)=>{
-						//velocity is already handled by advance_time
+						match &walk_state.target{
-						//we know that the acceleration is precisely zero because the walk target is known to be reachable
-						//which means that gravity can be fully cancelled
-						//ignore moving platforms for now
-						let target=core::mem::replace(&mut walk_state.target,TransientAcceleration::Reached);
-						set_acceleration(&mut state.body,&state.touching,&data.models,&data.hitbox_mesh,vec3::ZERO);
-						// check what the target was to see if it was invalid
-						match target{
 							//you are not supposed to reach a walk target which is already reached!
-							TransientAcceleration::Reached=>println!("Invalid walk target: Reached"),
+							TransientAcceleration::Reached=>unreachable!(),
-							TransientAcceleration::Reachable{..}=>(),
+							TransientAcceleration::Reachable{acceleration:_,time:_}=>{
+								//velocity is already handled by advance_time
+								//we know that the acceleration is precisely zero because the walk target is known to be reachable
+								//which means that gravity can be fully cancelled
+								//ignore moving platforms for now
+								set_acceleration(&mut state.body,&state.touching,&data.models,&data.hitbox_mesh,vec3::ZERO);
+								walk_state.target=TransientAcceleration::Reached;
+							},
 							//you are not supposed to reach an unreachable walk target!
-							TransientAcceleration::Unreachable{..}=>println!("Invalid walk target: Unreachable"),
+							TransientAcceleration::Unreachable{acceleration:_}=>unreachable!(),
 						}
 					}
 				}
@@ -1798,7 +1790,7 @@ fn atomic_input_instruction(state:&mut PhysicsState,data:&PhysicsData,ins:TimedI
 					let jump_dir=walk_state.jump_direction.direction(&data.models,&data.hitbox_mesh,&walk_state.contact);
 					let booster_option=data.models.contact_attr(walk_state.contact.model_id).general.booster.as_ref();
 					let jumped_velocity=jump_settings.jumped_velocity(&state.style,jump_dir,state.body.velocity,booster_option);
-					state.cull_velocity(data,jumped_velocity);
+					state.cull_velocity(&data,jumped_velocity);
 				}
 			}
 			b_refresh_walk_target=false;
@@ -1868,6 +1860,7 @@ fn atomic_input_instruction(state:&mut PhysicsState,data:&PhysicsData,ins:TimedI
 #[cfg(test)]
 mod test{
 	use strafesnet_common::integer::{vec3::{self,int as int3},mat3};
+	use crate::body::VirtualBody;
 	use super::*;
 	fn test_collision_axis_aligned(relative_body:Body,expected_collision_time:Option<Time>){
 		let h0=HitboxMesh::new(PhysicsMesh::unit_cube(),integer::Planar64Affine3::new(mat3::from_diagonal(int3(5,1,5)>>1),vec3::ZERO));
@@ -1875,7 +1868,7 @@ mod test{
 		let hitbox_mesh=h1.transformed_mesh();
 		let platform_mesh=h0.transformed_mesh();
 		let minkowski=model_physics::MinkowskiMesh::minkowski_sum(platform_mesh,hitbox_mesh);
-		let collision=minkowski.predict_collision_in(&relative_body,Time::ZERO..Time::from_secs(10));
+		let collision=minkowski.predict_collision_in(&relative_body,Time::from_secs(10));
 		assert_eq!(collision.map(|tup|relative_body.time+tup.1.into()),expected_collision_time,"Incorrect time of collision");
 	}
 	fn test_collision_rotated(relative_body:Body,expected_collision_time:Option<Time>){
@@ -1893,7 +1886,7 @@ mod test{
 		let hitbox_mesh=h1.transformed_mesh();
 		let platform_mesh=h0.transformed_mesh();
 		let minkowski=model_physics::MinkowskiMesh::minkowski_sum(platform_mesh,hitbox_mesh);
-		let collision=minkowski.predict_collision_in(&relative_body,Time::ZERO..Time::from_secs(10));
+		let collision=minkowski.predict_collision_in(&relative_body,Time::from_secs(10));
 		assert_eq!(collision.map(|tup|relative_body.time+tup.1.into()),expected_collision_time,"Incorrect time of collision");
 	}
 	fn test_collision(relative_body:Body,expected_collision_time:Option<Time>){
@@ -1947,111 +1940,111 @@ mod test{
 	}
 	#[test]
 	fn test_collision_parabola_edge_east_from_west(){
-		test_collision(Body::new(
+		test_collision(VirtualBody::relative(&Body::ZERO,&Body::new(
 			int3(3,3,0),
 			int3(100,-1,0),
 			int3(0,-1,0),
 			Time::ZERO
-		).relative_to(&Body::ZERO).body(Time::from_secs(-1)),Some(Time::from_secs(0)));
+		)).body(Time::from_secs(-1)),Some(Time::from_secs(0)));
 	}
 	#[test]
 	fn test_collision_parabola_edge_south_from_north(){
-		test_collision(Body::new(
+		test_collision(VirtualBody::relative(&Body::ZERO,&Body::new(
 			int3(0,3,3),
 			int3(0,-1,100),
 			int3(0,-1,0),
 			Time::ZERO
-		).relative_to(&Body::ZERO).body(Time::from_secs(-1)),Some(Time::from_secs(0)));
+		)).body(Time::from_secs(-1)),Some(Time::from_secs(0)));
 	}
 	#[test]
 	fn test_collision_parabola_edge_west_from_east(){
-		test_collision(Body::new(
+		test_collision(VirtualBody::relative(&Body::ZERO,&Body::new(
 			int3(-3,3,0),
 			int3(-100,-1,0),
 			int3(0,-1,0),
 			Time::ZERO
-		).relative_to(&Body::ZERO).body(Time::from_secs(-1)),Some(Time::from_secs(0)));
+		)).body(Time::from_secs(-1)),Some(Time::from_secs(0)));
 	}
 	#[test]
 	fn test_collision_parabola_edge_north_from_south(){
-		test_collision(Body::new(
+		test_collision(VirtualBody::relative(&Body::ZERO,&Body::new(
 			int3(0,3,-3),
 			int3(0,-1,-100),
 			int3(0,-1,0),
 			Time::ZERO
-		).relative_to(&Body::ZERO).body(Time::from_secs(-1)),Some(Time::from_secs(0)));
+		)).body(Time::from_secs(-1)),Some(Time::from_secs(0)));
 	}
 	#[test]
 	fn test_collision_parabola_edge_north_from_ne(){
-		test_collision(Body::new(
+		test_collision(VirtualBody::relative(&Body::ZERO,&Body::new(
 			int3(0,6,-7)>>1,
 			int3(-10,-1,1),
 			int3(0,-1,0),
 			Time::ZERO
-		).relative_to(&Body::ZERO).body(Time::from_secs(-1)),Some(Time::from_secs(0)));
+		)).body(Time::from_secs(-1)),Some(Time::from_secs(0)));
 	}
 	#[test]
 	fn test_collision_parabola_edge_north_from_nw(){
-		test_collision(Body::new(
+		test_collision(VirtualBody::relative(&Body::ZERO,&Body::new(
 			int3(0,6,-7)>>1,
 			int3(10,-1,1),
 			int3(0,-1,0),
 			Time::ZERO
-		).relative_to(&Body::ZERO).body(Time::from_secs(-1)),Some(Time::from_secs(0)));
+		)).body(Time::from_secs(-1)),Some(Time::from_secs(0)));
 	}
 	#[test]
 	fn test_collision_parabola_edge_east_from_se(){
-		test_collision(Body::new(
+		test_collision(VirtualBody::relative(&Body::ZERO,&Body::new(
 			int3(7,6,0)>>1,
 			int3(-1,-1,-10),
 			int3(0,-1,0),
 			Time::ZERO
-		).relative_to(&Body::ZERO).body(Time::from_secs(-1)),Some(Time::from_secs(0)));
+		)).body(Time::from_secs(-1)),Some(Time::from_secs(0)));
 	}
 	#[test]
 	fn test_collision_parabola_edge_east_from_ne(){
-		test_collision(Body::new(
+		test_collision(VirtualBody::relative(&Body::ZERO,&Body::new(
 			int3(7,6,0)>>1,
 			int3(-1,-1,10),
 			int3(0,-1,0),
 			Time::ZERO
-		).relative_to(&Body::ZERO).body(Time::from_secs(-1)),Some(Time::from_secs(0)));
+		)).body(Time::from_secs(-1)),Some(Time::from_secs(0)));
 	}
 	#[test]
 	fn test_collision_parabola_edge_south_from_se(){
-		test_collision(Body::new(
+		test_collision(VirtualBody::relative(&Body::ZERO,&Body::new(
 			int3(0,6,7)>>1,
 			int3(-10,-1,-1),
 			int3(0,-1,0),
 			Time::ZERO
-		).relative_to(&Body::ZERO).body(Time::from_secs(-1)),Some(Time::from_secs(0)));
+		)).body(Time::from_secs(-1)),Some(Time::from_secs(0)));
 	}
 	#[test]
 	fn test_collision_parabola_edge_south_from_sw(){
-		test_collision(Body::new(
+		test_collision(VirtualBody::relative(&Body::ZERO,&Body::new(
 			int3(0,6,7)>>1,
 			int3(10,-1,-1),
 			int3(0,-1,0),
 			Time::ZERO
-		).relative_to(&Body::ZERO).body(Time::from_secs(-1)),Some(Time::from_secs(0)));
+		)).body(Time::from_secs(-1)),Some(Time::from_secs(0)));
 	}
 	#[test]
 	fn test_collision_parabola_edge_west_from_se(){
-		test_collision(Body::new(
+		test_collision(VirtualBody::relative(&Body::ZERO,&Body::new(
 			int3(-7,6,0)>>1,
 			int3(1,-1,-10),
 			int3(0,-1,0),
 			Time::ZERO
-		).relative_to(&Body::ZERO).body(Time::from_secs(-1)),Some(Time::from_secs(0)));
+		)).body(Time::from_secs(-1)),Some(Time::from_secs(0)));
 	}
 	#[test]
 	fn test_collision_parabola_edge_west_from_ne(){
-		test_collision(Body::new(
+		test_collision(VirtualBody::relative(&Body::ZERO,&Body::new(
 			int3(-7,6,0)>>1,
 			int3(1,-1,10),
 			int3(0,-1,0),
 			Time::ZERO
-		).relative_to(&Body::ZERO).body(Time::from_secs(-1)),Some(Time::from_secs(0)));
+		)).body(Time::from_secs(-1)),Some(Time::from_secs(0)));
 	}
 	#[test]
 	fn test_collision_oblique(){

strafe-client/src/physics_worker.rs

@@ -1,7 +1,6 @@
 use crate::graphics_worker::Instruction as GraphicsInstruction;
-use strafesnet_settings::{directories::Directories,settings};
+use crate::session::{
-use strafesnet_session::session::{
+	Session,Simulation,SessionInputInstruction,SessionControlInstruction,SessionPlaybackInstruction,
-	Session,Simulation,SessionInputInstruction,SessionControlInstruction,SessionPlaybackInstruction,ImplicitModeInstruction,
 	Instruction as SessionInstruction,
 };
 use strafesnet_common::instruction::{TimedInstruction,InstructionConsumer};
@@ -21,15 +20,13 @@ pub enum Instruction{
 
 pub fn new<'a>(
 	mut graphics_worker:crate::compat_worker::INWorker<'a,crate::graphics_worker::Instruction>,
-	directories:Directories,
+	user_settings:crate::settings::UserSettings,
-	user_settings:settings::UserSettings,
 )->crate::compat_worker::QNWorker<'a,TimedInstruction<Instruction,SessionTimeInner>>{
-	let physics=strafesnet_physics::physics::PhysicsState::default();
+	let physics=crate::physics::PhysicsState::default();
 	let timer=Timer::unpaused(SessionTime::ZERO,PhysicsTime::ZERO);
 	let simulation=Simulation::new(timer,physics);
 	let mut session=Session::new(
 		user_settings,
-		directories,
 		simulation,
 	);
 	crate::compat_worker::QNWorker::new(move |ins:TimedInstruction<Instruction,SessionTimeInner>|{
@@ -70,7 +67,7 @@ pub fn new<'a>(
 			},
 			Instruction::ChangeMap(complete_map)=>{
 				run_session_instruction!(ins.time,SessionInstruction::ChangeMap(&complete_map));
-				run_session_instruction!(ins.time,SessionInstruction::Input(SessionInputInstruction::Mode(ImplicitModeInstruction::ResetAndSpawn(strafesnet_common::gameplay_modes::ModeId::MAIN,strafesnet_common::gameplay_modes::StageId::FIRST))));
+				run_session_instruction!(ins.time,SessionInstruction::Input(SessionInputInstruction::Mode(crate::session::ImplicitModeInstruction::ResetAndSpawn(strafesnet_common::gameplay_modes::ModeId::MAIN,strafesnet_common::gameplay_modes::StageId::FIRST))));
 				run_graphics_worker_instruction!(GraphicsInstruction::ChangeMap(complete_map));
 			},
 			Instruction::LoadReplay(bot)=>{

strafe-client/src/push_solve.rs

@@ -289,7 +289,7 @@ fn get_best_push_ray_and_conts<'a>(
 	}
 }
 
-fn get_first_touch<'a>(contacts:&'a [Contact],ray:&Ray,conts:&Conts)->Option<(Ratio<Fixed<2,64>,Fixed<2,64>>,&'a Contact)>{
+fn get_first_touch<'a>(contacts:&'a Vec<Contact>,ray:&Ray,conts:&Conts)->Option<(Ratio<Fixed<2,64>,Fixed<2,64>>,&'a Contact)>{
 	contacts.iter()
 		.filter(|&contact|
 			!conts.iter().any(|&c|std::ptr::eq(c,contact))
@@ -299,7 +299,7 @@ fn get_first_touch<'a>(contacts:&'a [Contact],ray:&Ray,conts:&Conts)->Option<(Ra
 		.min_by_key(|&(t,_)|t)
 }
 
-pub fn push_solve(contacts:&[Contact],point:Planar64Vec3)->Planar64Vec3{
+pub fn push_solve(contacts:&Vec<Contact>,point:Planar64Vec3)->Planar64Vec3{
 	let (mut ray,mut conts)=get_best_push_ray_and_conts_0(point);
 	loop{
 		let (next_t,next_cont)=match get_first_touch(contacts,&ray,&conts){

strafe-client/src/session.rs

@@ -12,11 +12,10 @@ use strafesnet_common::physics::{
 };
 use strafesnet_common::timer::{Scaled,Timer};
 use strafesnet_common::session::{TimeInner as SessionTimeInner,Time as SessionTime};
-use strafesnet_settings::directories::Directories;
 
 use crate::mouse_interpolator::{MouseInterpolator,StepInstruction,Instruction as MouseInterpolatorInstruction};
-use strafesnet_physics::physics::{self,PhysicsContext,PhysicsData};
+use crate::physics::{PhysicsContext,PhysicsData};
-use strafesnet_settings::settings::UserSettings;
+use crate::settings::UserSettings;
 
 pub enum Instruction<'a>{
 	Input(SessionInputInstruction),
@@ -58,19 +57,19 @@ pub enum SessionPlaybackInstruction{
 }
 
 pub struct FrameState{
-	pub body:physics::Body,
+	pub body:crate::physics::Body,
-	pub camera:physics::PhysicsCamera,
+	pub camera:crate::physics::PhysicsCamera,
 	pub time:PhysicsTime,
 }
 
 pub struct Simulation{
 	timer:Timer<Scaled<SessionTimeInner,PhysicsTimeInner>>,
-	physics:physics::PhysicsState,
+	physics:crate::physics::PhysicsState,
 }
 impl Simulation{
 	pub const fn new(
 		timer:Timer<Scaled<SessionTimeInner,PhysicsTimeInner>>,
-		physics:physics::PhysicsState,
+		physics:crate::physics::PhysicsState,
 	)->Self{
 		Self{
 			timer,
@@ -91,7 +90,7 @@ pub struct Recording{
 	instructions:Vec<TimedInstruction<PhysicsInputInstruction,PhysicsTimeInner>>,
 }
 impl Recording{
-	pub fn new(
+	fn new(
 		instructions:Vec<TimedInstruction<PhysicsInputInstruction,PhysicsTimeInner>>,
 	)->Self{
 		Self{instructions}
@@ -150,12 +149,11 @@ enum ViewState{
 }
 
 pub struct Session{
-	directories:Directories,
 	user_settings:UserSettings,
 	mouse_interpolator:crate::mouse_interpolator::MouseInterpolator,
 	view_state:ViewState,
 	//gui:GuiState
-	geometry_shared:physics::PhysicsData,
+	geometry_shared:crate::physics::PhysicsData,
 	simulation:Simulation,
 	// below fields not included in lite session
 	recording:Recording,
@@ -165,12 +163,10 @@ pub struct Session{
 impl Session{
 	pub fn new(
 		user_settings:UserSettings,
-		directories:Directories,
 		simulation:Simulation,
 	)->Self{
 		Self{
 			user_settings,
-			directories,
 			mouse_interpolator:MouseInterpolator::new(),
 			geometry_shared:Default::default(),
 			simulation,
@@ -296,22 +292,11 @@ impl InstructionConsumer<Instruction<'_>> for Session{
 			Instruction::Control(SessionControlInstruction::SaveReplay)=>{
 				// Bind: N
 				let view_state=core::mem::replace(&mut self.view_state,ViewState::Play);
+				let file=std::fs::File::create(format!("{}.snfb",ins.time)).unwrap();
 				match view_state{
 					ViewState::Play=>(),
 					ViewState::Replay(bot_id)=>if let Some(replay)=self.replays.remove(&bot_id){
-						let mut replays_path=self.directories.replays.clone();
+						strafesnet_snf::bot::write_bot(std::io::BufWriter::new(file),replay.recording.instructions).unwrap();
-						let file_name=format!("{}.snfb",ins.time);
-						std::thread::spawn(move ||{
-							std::fs::create_dir_all(replays_path.as_path()).unwrap();
-							replays_path.push(file_name);
-							let file=std::fs::File::create(replays_path).unwrap();
-							strafesnet_snf::bot::write_bot(
-								std::io::BufWriter::new(file),
-								strafesnet_physics::VERSION.get(),
-								replay.recording.instructions
-							).unwrap();
-							println!("Finished writing bot file!");
-						});
 					},
 				}
 				_=self.simulation.timer.set_paused(ins.time,false);

strafe-client/src/settings.rs

@@ -74,9 +74,9 @@ sensitivity_y_from_x_ratio=1
 Sensitivity::DeriveY{x:0.0.001,y:DerivedSensitivity{ratio:1.0}}
 */
 
-pub fn load_user_settings(path:&std::path::Path)->UserSettings{
+pub fn read_user_settings()->UserSettings{
 	let mut cfg=configparser::ini::Ini::new();
-	if let Ok(_)=cfg.load(path){
+	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 {
@@ -136,4 +136,4 @@ pub fn load_user_settings(path:&std::path::Path)->UserSettings{
 	}else{
 		UserSettings::default()
 	}
-}
+}

strafe-client/src/setup.rs

@@ -1,3 +1,8 @@
+use crate::window::Instruction;
+use strafesnet_common::instruction::TimedInstruction;
+use strafesnet_common::integer;
+use strafesnet_common::session::TimeInner as SessionTimeInner;
+
 fn optional_features()->wgpu::Features{
 	wgpu::Features::TEXTURE_COMPRESSION_ASTC
 	|wgpu::Features::TEXTURE_COMPRESSION_ETC2
@@ -12,6 +17,9 @@ fn required_downlevel_capabilities()->wgpu::DownlevelCapabilities{
 		..wgpu::DownlevelCapabilities::default()
 	}
 }
+pub fn required_limits()->wgpu::Limits{
+	wgpu::Limits::default()
+}
 
 struct SetupContextPartial1{
 	backends:wgpu::Backends,
@@ -20,6 +28,11 @@ struct SetupContextPartial1{
 fn create_window(title:&str,event_loop:&winit::event_loop::EventLoop<()>)->Result<winit::window::Window,winit::error::OsError>{
 	let mut attr=winit::window::WindowAttributes::default();
 	attr=attr.with_title(title);
+	#[cfg(windows_OFF)] // TODO
+	{
+		use winit::platform::windows::WindowBuilderExtWindows;
+		builder=builder.with_no_redirection_bitmap(true);
+	}
 	event_loop.create_window(attr)
 }
 fn create_instance()->SetupContextPartial1{
@@ -100,12 +113,14 @@ impl<'a> SetupContextPartial2<'a>{
 			required_downlevel_capabilities.flags - downlevel_capabilities.flags
 		);
 		SetupContextPartial3{
+			instance:self.instance,
 			surface:self.surface,
 			adapter,
 		}
 	}
 }
 struct SetupContextPartial3<'a>{
+	instance:wgpu::Instance,
 	surface:wgpu::Surface<'a>,
 	adapter:wgpu::Adapter,
 }
@@ -115,7 +130,7 @@ impl<'a> SetupContextPartial3<'a>{
 		let required_features=required_features();
 
 		// Make sure we use the texture resolution limits from the adapter, so we can support images the size of the surface.
-		let needed_limits=strafesnet_graphics::graphics::required_limits().using_resolution(self.adapter.limits());
+		let needed_limits=required_limits().using_resolution(self.adapter.limits());
 
 		let trace_dir=std::env::var("WGPU_TRACE");
 		let (device, queue)=pollster::block_on(self.adapter
@@ -131,6 +146,7 @@ impl<'a> SetupContextPartial3<'a>{
 			.expect("Unable to find a suitable GPU adapter!");
 
 		SetupContextPartial4{
+			instance:self.instance,
 			surface:self.surface,
 			adapter:self.adapter,
 			device,
@@ -139,6 +155,7 @@ impl<'a> SetupContextPartial3<'a>{
 	}
 }
 struct SetupContextPartial4<'a>{
+	instance:wgpu::Instance,
 	surface:wgpu::Surface<'a>,
 	adapter:wgpu::Adapter,
 	device:wgpu::Device,
@@ -155,6 +172,7 @@ impl<'a> SetupContextPartial4<'a>{
 		self.surface.configure(&self.device, &config);
 
 		SetupContext{
+			instance:self.instance,
 			surface:self.surface,
 			device:self.device,
 			queue:self.queue,
@@ -163,6 +181,7 @@ impl<'a> SetupContextPartial4<'a>{
 	}
 }
 pub struct SetupContext<'a>{
+	pub instance:wgpu::Instance,
 	pub surface:wgpu::Surface<'a>,
 	pub device:wgpu::Device,
 	pub queue:wgpu::Queue,
@@ -197,16 +216,73 @@ pub fn setup_and_start(title:&str){
 	);
 
 	for arg in std::env::args().skip(1){
-		window_thread.send(strafesnet_common::instruction::TimedInstruction{
+		let path=std::path::PathBuf::from(arg);
-			time:strafesnet_common::integer::Time::ZERO,
+		window_thread.send(TimedInstruction{
-			instruction:crate::window::Instruction::WindowEvent(winit::event::WindowEvent::DroppedFile(arg.into())),
+			time:integer::Time::ZERO,
+			instruction:Instruction::WindowEvent(winit::event::WindowEvent::DroppedFile(path)),
 		}).unwrap();
 	};
 
 	println!("Entering event loop...");
-	let mut app=crate::app::App::new(
+	let root_time=std::time::Instant::now();
-		std::time::Instant::now(),
+	run_event_loop(event_loop,window_thread,root_time).unwrap();
-		window_thread
+}
-	);
+
-	event_loop.run_app(&mut app).unwrap();
+fn run_event_loop(
+	event_loop:winit::event_loop::EventLoop<()>,
+	mut window_thread:crate::compat_worker::QNWorker<TimedInstruction<Instruction,SessionTimeInner>>,
+	root_time:std::time::Instant
+	)->Result<(),winit::error::EventLoopError>{
+		event_loop.run(move |event,elwt|{
+			let time=integer::Time::from_nanos(root_time.elapsed().as_nanos() as i64);
+			// *control_flow=if cfg!(feature="metal-auto-capture"){
+			// 	winit::event_loop::ControlFlow::Exit
+			// }else{
+			// 	winit::event_loop::ControlFlow::Poll
+			// };
+			match event{
+				winit::event::Event::AboutToWait=>{
+					window_thread.send(TimedInstruction{time,instruction:Instruction::RequestRedraw}).unwrap();
+				}
+				winit::event::Event::WindowEvent {
+					event:
+						// WindowEvent::Resized(size)
+						// | WindowEvent::ScaleFactorChanged {
+						// 	new_inner_size: &mut size,
+						// 	..
+						// },
+						winit::event::WindowEvent::Resized(size),//ignoring scale factor changed for now because mutex bruh
+					window_id:_,
+				} => {
+					window_thread.send(TimedInstruction{time,instruction:Instruction::Resize(size)}).unwrap();
+				}
+				winit::event::Event::WindowEvent{event,..}=>match event{
+					winit::event::WindowEvent::KeyboardInput{
+						event:
+							winit::event::KeyEvent {
+							logical_key: winit::keyboard::Key::Named(winit::keyboard::NamedKey::Escape),
+								state: winit::event::ElementState::Pressed,
+								..
+							},
+						..
+					}
+					|winit::event::WindowEvent::CloseRequested=>{
+						elwt.exit();
+					}
+					winit::event::WindowEvent::RedrawRequested=>{
+						window_thread.send(TimedInstruction{time,instruction:Instruction::Render}).unwrap();
+					}
+					_=>{
+						window_thread.send(TimedInstruction{time,instruction:Instruction::WindowEvent(event)}).unwrap();
+					}
+				},
+				winit::event::Event::DeviceEvent{
+					event,
+					..
+				} => {
+					window_thread.send(TimedInstruction{time,instruction:Instruction::DeviceEvent(event)}).unwrap();
+				},
+				_=>{}
+			}
+		})
 }

strafe-client/src/window.rs

@@ -1,14 +1,16 @@
 use strafesnet_common::instruction::TimedInstruction;
 use strafesnet_common::session::{Time as SessionTime,TimeInner as SessionTimeInner};
 use strafesnet_common::physics::{MiscInstruction,SetControlInstruction};
-use crate::file::LoadFormat;
+use crate::file::Format2;
 use crate::physics_worker::Instruction as PhysicsWorkerInstruction;
-use strafesnet_session::session::{self,SessionInputInstruction,SessionControlInstruction,SessionPlaybackInstruction};
+use crate::session::{SessionInputInstruction,SessionControlInstruction,SessionPlaybackInstruction};
-use strafesnet_settings::directories::Directories;
 
 pub enum Instruction{
+	Resize(winit::dpi::PhysicalSize<u32>),
 	WindowEvent(winit::event::WindowEvent),
 	DeviceEvent(winit::event::DeviceEvent),
+	RequestRedraw,
+	Render,
 }
 
 //holds thread handles to dispatch to
@@ -28,8 +30,8 @@ impl WindowContext<'_>{
 		match event{
 			winit::event::WindowEvent::DroppedFile(path)=>{
 				match crate::file::load(path.as_path()){
-					Ok(LoadFormat::Map(map))=>self.physics_thread.send(TimedInstruction{time,instruction:PhysicsWorkerInstruction::ChangeMap(map)}).unwrap(),
+					Ok(Format2::Map(map))=>self.physics_thread.send(TimedInstruction{time,instruction:PhysicsWorkerInstruction::ChangeMap(map)}).unwrap(),
-					Ok(LoadFormat::Bot(bot))=>self.physics_thread.send(TimedInstruction{time,instruction:PhysicsWorkerInstruction::LoadReplay(bot)}).unwrap(),
+					Ok(Format2::Bot(bot))=>self.physics_thread.send(TimedInstruction{time,instruction:PhysicsWorkerInstruction::LoadReplay(bot)}).unwrap(),
 					Err(e)=>println!("Failed to load file: {e}"),
 				}
 			},
@@ -148,7 +150,7 @@ impl WindowContext<'_>{
 								"R"|"r"=>s.then(||{
 									//mouse needs to be reset since the position is absolute
 									self.mouse_pos=glam::DVec2::ZERO;
-									SessionInstructionSubset::Input(SessionInputInstruction::Mode(session::ImplicitModeInstruction::ResetAndRestart))
+									SessionInstructionSubset::Input(SessionInputInstruction::Mode(crate::session::ImplicitModeInstruction::ResetAndRestart))
 								}),
 								"F"|"f"=>input_misc!(PracticeFly,s),
 								"B"|"b"=>session_ctrl!(CopyRecordingIntoReplayAndSpectate,s),
@@ -167,23 +169,6 @@ impl WindowContext<'_>{
 					},
 				}
 			},
-			winit::event::WindowEvent::Resized(size)=>{
-				self.physics_thread.send(
-					TimedInstruction{
-						time,
-						instruction:PhysicsWorkerInstruction::Resize(size)
-					}
-				).unwrap();
-			},
-			winit::event::WindowEvent::RedrawRequested=>{
-				self.window.request_redraw();
-				self.physics_thread.send(
-					TimedInstruction{
-						time,
-						instruction:PhysicsWorkerInstruction::Render
-					}
-				).unwrap();
-			},
 			_=>(),
 		}
 	}
@@ -225,14 +210,9 @@ pub fn worker<'a>(
 	setup_context:crate::setup::SetupContext<'a>,
 )->crate::compat_worker::QNWorker<'a,TimedInstruction<Instruction,SessionTimeInner>>{
 	// WindowContextSetup::new
-	#[cfg(feature="user-install")]
+	let user_settings=crate::settings::read_user_settings();
-	let directories=Directories::user().unwrap();
-	#[cfg(not(feature="user-install"))]
-	let directories=Directories::portable().unwrap();
 
-	let user_settings=directories.settings();
+	let mut graphics=crate::graphics::GraphicsState::new(&setup_context.device,&setup_context.queue,&setup_context.config);
-
-	let mut graphics=strafesnet_graphics::graphics::GraphicsState::new(&setup_context.device,&setup_context.queue,&setup_context.config);
 	graphics.load_user_settings(&user_settings);
 
 	//WindowContextSetup::into_context
@@ -246,7 +226,6 @@ pub fn worker<'a>(
 		window,
 		physics_thread:crate::physics_worker::new(
 			graphics_thread,
-			directories,
 			user_settings,
 		),
 	};
@@ -254,12 +233,31 @@ pub fn worker<'a>(
 	//WindowContextSetup::into_worker
 	crate::compat_worker::QNWorker::new(move |ins:TimedInstruction<Instruction,SessionTimeInner>|{
 		match ins.instruction{
+			Instruction::RequestRedraw=>{
+				window_context.window.request_redraw();
+			}
 			Instruction::WindowEvent(window_event)=>{
 				window_context.window_event(ins.time,window_event);
 			},
 			Instruction::DeviceEvent(device_event)=>{
 				window_context.device_event(ins.time,device_event);
 			},
+			Instruction::Resize(size)=>{
+				window_context.physics_thread.send(
+					TimedInstruction{
+						time:ins.time,
+						instruction:PhysicsWorkerInstruction::Resize(size)
+					}
+				).unwrap();
+			}
+			Instruction::Render=>{
+				window_context.physics_thread.send(
+					TimedInstruction{
+						time:ins.time,
+						instruction:PhysicsWorkerInstruction::Render
+					}
+				).unwrap();
+			}
 		}
 	})
 }

strafe-client/src/worker.rs

@@ -176,7 +176,7 @@ impl<'a,Task:Send+'a> INWorker<'a,Task>{
 #[cfg(test)]
 mod test{
 	use super::{thread,QRWorker};
-	type Body=strafesnet_physics::physics::Body;
+	type Body=crate::physics::Body;
 	use strafesnet_common::{integer,instruction};
 	#[test]//How to run this test with printing: cargo test --release -- --nocapture
 	fn test_worker() {

tools/arcane

@@ -1 +1 @@
-mangohud ../target/release/strafe-client bhop_maps/5692113331.snfm "$@"
+mangohud ../target/release/strafe-client bhop_maps/5692113331.snfm

tools/iso

@@ -1 +1 @@
-mangohud ../target/release/strafe-client bhop_maps/5692124338.snfm "$@"
+mangohud ../target/release/strafe-client bhop_maps/5692124338.snfm

tools/replays

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

tools/run

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

tools/toc

@@ -1 +1 @@
-mangohud ../target/release/strafe-client bhop_maps/5692152916.snfm "$@"
+mangohud ../target/release/strafe-client bhop_maps/5692152916.snfm

tools/utopia

@@ -1 +1 @@
-mangohud ../target/release/strafe-client surf_maps/5692145408.snfm "$@"
+mangohud ../target/release/strafe-client surf_maps/5692145408.snfm