generic to_snf

Makes map tool work for external libs. It works if you have problems merge it and fix it later.

Reviewed-on: #42
Reviewed-by: Rhys Lloyd <quaternions@noreply@itzana.me>
Co-authored-by: itzaname <me@sliving.io>
Co-committed-by: itzaname <me@sliving.io>

Cargo.toml

@@ -35,3 +35,22 @@ unused_lifetimes = "warn"
 unused_qualifications = "warn"
 # variant_size_differences = "warn"
 unexpected_cfgs = "warn"
+
+[workspace.dependencies]
+glam = "0.32.0"
+
+# engine
+strafesnet_graphics = { path = "engine/graphics", registry = "strafesnet" }
+strafesnet_physics = { version = "0.0.1", path = "engine/physics", registry = "strafesnet" }
+strafesnet_session = { path = "engine/session", registry = "strafesnet" }
+strafesnet_settings = { path = "engine/settings", registry = "strafesnet" }
+
+# lib
+fixed_wide = { version = "0.2.2", path = "lib/fixed_wide", registry = "strafesnet" }
+linear_ops = { version = "0.1.1", path = "lib/linear_ops", registry = "strafesnet" }
+ratio_ops = { version = "0.1.0", path = "lib/ratio_ops", registry = "strafesnet" }
+strafesnet_bsp_loader = { version = "0.4.0", path = "lib/bsp_loader", registry = "strafesnet" }
+strafesnet_common = { version = "0.8.6", path = "lib/common", registry = "strafesnet" }
+strafesnet_deferred_loader = { version = "0.6.0", path = "lib/deferred_loader", registry = "strafesnet" }
+strafesnet_rbx_loader = { version = "0.8.0", path = "lib/rbx_loader", registry = "strafesnet" }
+strafesnet_snf = { version = "0.3.2", path = "lib/snf", registry = "strafesnet" }

engine/graphics/Cargo.toml

@@ -1,16 +1,14 @@
 [package]
 name = "strafesnet_graphics"
-version = "0.1.0"
+version = "0.0.4"
 edition = "2024"
 
 [dependencies]
 bytemuck = { version = "1.13.1", features = ["derive"] }
 ddsfile = "0.5.1"
-glam = "0.30.0"
+glam.workspace = true
 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" }
+strafesnet_common.workspace = true
 wgpu = "28.0.0"
 
 [lints]

engine/graphics/src/graphics.rs

@@ -1,16 +1,10 @@
 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};
 
-pub fn required_limits()->wgpu::Limits{
-	wgpu::Limits::default()
-}
-
 struct Indices{
 	count:u32,
 	buf:wgpu::Buffer,
@@ -54,6 +48,10 @@ struct GraphicsPipelines{
 	model:wgpu::RenderPipeline,
 }
 
+pub fn view_inv(pos:glam::Vec3,angles:glam::Vec2)->glam::Mat4{
+	//f32 good enough for view matrix
+	glam::Mat4::from_mat3_translation(glam::Mat3::from_euler(glam::EulerRot::YXZ,angles.x,angles.y,0f32),pos)
+}
 struct GraphicsCamera{
 	screen_size:glam::UVec2,
 	fov:glam::Vec2,//slope
@@ -75,15 +73,10 @@ impl GraphicsCamera{
 	pub fn proj(&self)->glam::Mat4{
 		perspective_rh(self.fov.x,self.fov.y,0.4,4000.0)
 	}
-	pub fn world(&self,pos:glam::Vec3,angles:glam::Vec2)->glam::Mat4{
-		//f32 good enough for view matrix
-		glam::Mat4::from_translation(pos)*glam::Mat4::from_euler(glam::EulerRot::YXZ,angles.x,angles.y,0f32)
-	}
 
-	pub fn to_uniform_data(&self,pos:glam::Vec3,angles:glam::Vec2)->[f32;16*4]{
+	pub fn to_uniform_data(&self,view_inv:glam::Mat4)->[f32;16*4]{
 		let proj=self.proj();
 		let proj_inv=proj.inverse();
-		let view_inv=self.world(pos,angles);
 		let view=view_inv.inverse();
 
 		let mut raw=[0f32; 16 * 4];
@@ -162,9 +155,6 @@ impl GraphicsState{
 	pub fn clear(&mut self){
 		self.models.clear();
 	}
-	pub fn load_user_settings(&mut self,user_settings:&settings::UserSettings){
-		self.camera.fov=user_settings.calculate_fov(1.0,&self.camera.screen_size).as_vec2();
-	}
 	pub fn generate_models(&mut self,device:&wgpu::Device,queue:&wgpu::Queue,map:&map::CompleteMap){
 		//generate texture view per texture
 		let texture_views:HashMap<model::TextureId,wgpu::TextureView>=map.textures.iter().enumerate().filter_map(|(texture_id,texture_data)|{
@@ -474,7 +464,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(){
@@ -634,7 +624,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!("../shaders/shader.wgsl"))),
 		});
 
 		//load textures
@@ -662,10 +652,10 @@ impl GraphicsState{
 				wgpu::TextureFormat::Astc{
 					block:AstcBlock::B4x4,
 					channel:AstcChannel::UnormSrgb,
-				}=>&include_bytes!("../../../strafe-client/images/astc.dds")[..],
-				wgpu::TextureFormat::Etc2Rgb8UnormSrgb=>&include_bytes!("../../../strafe-client/images/etc2.dds")[..],
-				wgpu::TextureFormat::Bc1RgbaUnormSrgb=>&include_bytes!("../../../strafe-client/images/bc1.dds")[..],
-				wgpu::TextureFormat::Bgra8UnormSrgb=>&include_bytes!("../../../strafe-client/images/bgra.dds")[..],
+				}=>&include_bytes!("../images/astc.dds")[..],
+				wgpu::TextureFormat::Etc2Rgb8UnormSrgb=>&include_bytes!("../images/etc2.dds")[..],
+				wgpu::TextureFormat::Bc1RgbaUnormSrgb=>&include_bytes!("../images/bc1.dds")[..],
+				wgpu::TextureFormat::Bgra8UnormSrgb=>&include_bytes!("../images/bgra.dds")[..],
 				_=>unreachable!(),
 			};
 
@@ -708,7 +698,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();
 
@@ -833,7 +823,7 @@ impl GraphicsState{
 		});
 
 		let camera=GraphicsCamera::default();
-		let camera_uniforms=camera.to_uniform_data(glam::Vec3::ZERO,glam::Vec2::ZERO);
+		let camera_uniforms=camera.to_uniform_data(view_inv(glam::Vec3::ZERO,glam::Vec2::ZERO));
 		let camera_buf=device.create_buffer_init(&wgpu::util::BufferInitDescriptor{
 			label:Some("Camera"),
 			contents:bytemuck::cast_slice(&camera_uniforms),
@@ -890,28 +880,25 @@ impl GraphicsState{
 		&mut self,
 		device:&wgpu::Device,
 		config:&wgpu::SurfaceConfiguration,
-		user_settings:&settings::UserSettings,
+		fov:glam::Vec2,
 	){
 		self.depth_view=Self::create_depth_texture(config,device);
 		self.camera.screen_size=glam::uvec2(config.width,config.height);
-		self.load_user_settings(user_settings);
+		self.camera.fov=fov;
 	}
 	pub fn render(
 		&mut self,
 		view:&wgpu::TextureView,
 		device:&wgpu::Device,
 		queue:&wgpu::Queue,
-		frame_state:session::FrameState,
+		camera:glam::Mat4,
 	){
 		//TODO:use scheduled frame times to create beautiful smoothing simulation physics extrapolation assuming no input
 
 		let mut encoder=device.create_command_encoder(&wgpu::CommandEncoderDescriptor{label:None});
 
 		// update rotation
-		let camera_uniforms=self.camera.to_uniform_data(
-			frame_state.trajectory.extrapolated_position(frame_state.time).map(Into::<f32>::into).to_array().into(),
-			frame_state.camera.simulate_move_angles(glam::IVec2::ZERO)
-		);
+		let camera_uniforms=self.camera.to_uniform_data(camera);
 		self.staging_belt
 			.write_buffer(
 				&mut encoder,

engine/graphics/src/lib.rs

@@ -1,2 +1,3 @@
 pub mod model;
+pub mod setup;
 pub mod graphics;

engine/graphics/src/setup.rs

@@ -0,0 +1,118 @@
+fn optional_features()->wgpu::Features{
+	wgpu::Features::TEXTURE_COMPRESSION_ASTC
+	|wgpu::Features::TEXTURE_COMPRESSION_ETC2
+}
+fn required_features()->wgpu::Features{
+	wgpu::Features::TEXTURE_COMPRESSION_BC
+}
+pub fn required_limits()->wgpu::Limits{
+	wgpu::Limits::defaults()
+}
+fn required_downlevel_capabilities()->wgpu::DownlevelCapabilities{
+	wgpu::DownlevelCapabilities{
+		flags:wgpu::DownlevelFlags::empty(),
+		shader_model:wgpu::ShaderModel::Sm5,
+		..wgpu::DownlevelCapabilities::default()
+	}
+}
+
+pub mod step1{
+	pub fn create_instance()->wgpu::Instance{
+		Default::default()
+	}
+}
+
+pub mod step2{
+	pub fn create_surface<'window>(instance:&wgpu::Instance,target:impl Into<wgpu::SurfaceTarget<'window>>)->Result<wgpu::Surface<'window>,wgpu::CreateSurfaceError>{
+		instance.create_surface(target)
+	}
+}
+
+pub mod step3{
+	pub async fn pick_adapter(instance:&wgpu::Instance,surface:&wgpu::Surface<'_>)->Option<wgpu::Adapter>{
+		let backends=wgpu::Backends::from_env().unwrap_or_default();
+		//TODO: prefer adapter that implements optional features
+		//let optional_features=optional_features();
+		let required_features=super::required_features();
+		let required_downlevel_capabilities=super::required_downlevel_capabilities();
+
+		//no helper function smh gotta write it myself
+		let adapters=instance.enumerate_adapters(backends).await;
+
+		let adapter=adapters.into_iter()
+			// reverse because we want to select adapters that appear first in ties,
+			// and max_by_key selects the last equal element in the iterator.
+			.rev()
+			.filter(|adapter|
+				adapter.is_surface_supported(surface)
+				&&adapter.features().contains(required_features)
+				&&{
+					let downlevel_capabilities=adapter.get_downlevel_capabilities();
+					downlevel_capabilities.shader_model>=required_downlevel_capabilities.shader_model
+					&&downlevel_capabilities.flags.contains(required_downlevel_capabilities.flags)
+				}
+			)
+			.max_by_key(|adapter|match adapter.get_info().device_type{
+				wgpu::DeviceType::IntegratedGpu=>3,
+				wgpu::DeviceType::DiscreteGpu=>4,
+				wgpu::DeviceType::VirtualGpu=>2,
+				wgpu::DeviceType::Other|wgpu::DeviceType::Cpu=>1,
+			})?;
+
+		Some(adapter)
+	}
+}
+
+pub mod step4{
+	pub async fn request_device(adapter:&wgpu::Adapter)->Result<(wgpu::Device,wgpu::Queue),wgpu::RequestDeviceError>{
+		let optional_features=super::optional_features();
+		let required_features=super::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=super::required_limits().using_resolution(adapter.limits());
+
+		let (device, queue)=adapter
+			.request_device(
+				&wgpu::DeviceDescriptor{
+					label:None,
+					required_features:(optional_features&adapter.features())|required_features,
+					required_limits:needed_limits,
+					memory_hints:wgpu::MemoryHints::Performance,
+					trace:wgpu::Trace::Off,
+					experimental_features:wgpu::ExperimentalFeatures::disabled(),
+				},
+			).await?;
+
+		Ok((
+			device,
+			queue,
+		))
+	}
+}
+
+pub mod step5{
+	#[derive(Debug)]
+	pub struct ErrorSurfaceNotSupported;
+	impl std::fmt::Display for ErrorSurfaceNotSupported{
+		fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
+			write!(f,"Surface isn't supported by the adapter.")
+		}
+	}
+	pub fn configure_surface(
+		adapter:&wgpu::Adapter,
+		device:&wgpu::Device,
+		surface:&wgpu::Surface<'_>,
+		(width,height):(u32,u32),
+	)->Result<wgpu::SurfaceConfiguration,ErrorSurfaceNotSupported>{
+		let mut config=surface
+			.get_default_config(adapter, width, height)
+			.ok_or(ErrorSurfaceNotSupported)?;
+
+		let surface_view_format=config.format.add_srgb_suffix();
+		config.view_formats.push(surface_view_format);
+		config.present_mode=wgpu::PresentMode::AutoNoVsync;
+		surface.configure(device,&config);
+
+		Ok(config)
+	}
+}

engine/physics/Cargo.toml

@@ -1,13 +1,13 @@
 [package]
 name = "strafesnet_physics"
-version = "0.1.0"
+version = "0.0.1"
 edition = "2024"
 
 [dependencies]
 arrayvec = "0.7.6"
-glam = "0.30.0"
+glam.workspace = true
 id = { version = "0.1.0", registry = "strafesnet" }
-strafesnet_common = { path = "../../lib/common", registry = "strafesnet" }
+strafesnet_common.workspace = true
 
 [lints]
 workspace = true

engine/physics/src/face_crawler.rs

@@ -1,20 +1,21 @@
-use crate::model::{into_giga_time,GigaTime,FEV,MeshQuery,DirectedEdge};
-use strafesnet_common::integer::{Fixed,Ratio,vec3::Vector3};
+use crate::model::{into_giga_time,GigaTime};
+use strafesnet_common::integer::{Fixed,Ratio,vec3::Vector3,Planar64Vec3};
 use crate::physics::{Time,Trajectory};
+use crate::mesh_query::{FEV,DirectedEdge,MeshQuery,MeshTopology};
 
 use core::ops::Bound;
 
-enum Transition<M:MeshQuery>{
+enum Transition<M:MeshTopology>{
 	Miss,
 	Next(FEV<M>,GigaTime),
 	Hit(M::Face,GigaTime),
 }
 
-pub enum CrawlResult<M:MeshQuery>{
+pub enum CrawlResult<M:MeshTopology>{
 	Miss(FEV<M>),
 	Hit(M::Face,GigaTime),
 }
-impl<M:MeshQuery> CrawlResult<M>{
+impl<M:MeshTopology> CrawlResult<M>{
 	pub fn hit(self)->Option<(M::Face,GigaTime)>{
 		match self{
 			CrawlResult::Miss(_)=>None,
@@ -64,11 +65,12 @@ where
 	}
 }
 
-impl<F:Copy,M:MeshQuery<Normal=Vector3<F>,Offset=Fixed<4,128>>> FEV<M>
+impl<F:Copy,M:MeshQuery<Normal=Vector3<F>,Offset=Fixed<4,128>,Position=Planar64Vec3,Direction=Planar64Vec3>> FEV<M>
 	where
 		// This is hardcoded for MinkowskiMesh lol
 		M::Face:Copy,
 		M::Edge:Copy,
+		M::DirectedEdge:Copy,
 		M::Vert:Copy,
 		F:core::ops::Mul<Fixed<1,32>,Output=Fixed<4,128>>,
 		<F as core::ops::Mul<Fixed<1,32>>>::Output:core::iter::Sum,
@@ -94,7 +96,7 @@ impl<F:Copy,M:MeshQuery<Normal=Vector3<F>,Offset=Fixed<4,128>>> FEV<M>
 					}
 				}
 				//test each edge collision time, ignoring roots with zero or conflicting derivative
-				for &directed_edge_id in mesh.face_edges(face_id).as_ref(){
+				mesh.for_each_face_edge(face_id,|directed_edge_id|{
 					let edge_n=mesh.directed_edge_n(directed_edge_id);
 					let n=n.cross(edge_n);
 					let &[v0,v1]=mesh.edge_verts(directed_edge_id.as_undirected()).as_ref();
@@ -108,7 +110,7 @@ impl<F:Copy,M:MeshQuery<Normal=Vector3<F>,Offset=Fixed<4,128>>> FEV<M>
 							break;
 						}
 					}
-				}
+				});
 				//if none:
 			},
 			&FEV::Edge(edge_id)=>{
@@ -149,7 +151,7 @@ impl<F:Copy,M:MeshQuery<Normal=Vector3<F>,Offset=Fixed<4,128>>> FEV<M>
 			},
 			&FEV::Vert(vert_id)=>{
 				//test each edge collision time, ignoring roots with zero or conflicting derivative
-				for &directed_edge_id in mesh.vert_edges(vert_id).as_ref(){
+				mesh.for_each_vert_edge(vert_id,|directed_edge_id|{
 					//edge is directed away from vertex, but we want the dot product to turn out negative
 					let n=-mesh.directed_edge_n(directed_edge_id);
 					for dt in Fixed::<2,64>::zeroes2((n.dot(trajectory.position-mesh.vert(vert_id)))*2,n.dot(trajectory.velocity)*2,n.dot(trajectory.acceleration)){
@@ -160,7 +162,7 @@ impl<F:Copy,M:MeshQuery<Normal=Vector3<F>,Offset=Fixed<4,128>>> FEV<M>
 							break;
 						}
 					}
-				}
+				});
 				//if none:
 			},
 		}

engine/physics/src/lib.rs

@@ -1,5 +1,7 @@
 mod body;
 mod face_crawler;
+mod mesh_query;
+mod minkowski;
 mod model;
 mod push_solve;
 mod minimum_difference;

engine/physics/src/mesh_query.rs

@@ -0,0 +1,56 @@
+pub enum FEV<M:MeshTopology>{
+	Vert(M::Vert),
+	Edge(M::Edge),
+	Face(M::Face),
+}
+
+pub trait UndirectedEdge{
+	type DirectedEdge:DirectedEdge<UndirectedEdge=Self>;
+	fn as_directed(self,parity:bool)->Self::DirectedEdge;
+}
+pub trait DirectedEdge{
+	type UndirectedEdge:UndirectedEdge<DirectedEdge=Self>;
+	fn as_undirected(self)->Self::UndirectedEdge;
+	fn parity(&self)->bool;
+	fn reverse(self)->Self
+		where
+			Self:Sized
+	{
+		let parity=!self.parity();
+		self.as_undirected().as_directed(parity)
+	}
+}
+
+pub trait MeshTopology{
+	type Face;
+	type Edge:UndirectedEdge<DirectedEdge=Self::DirectedEdge>;
+	type DirectedEdge:DirectedEdge<UndirectedEdge=Self::Edge>;
+	type Vert;
+	fn for_each_vert_edge(&self,vert_id:Self::Vert,f:impl FnMut(Self::DirectedEdge));
+	fn for_each_vert_face(&self,vert_id:Self::Vert,f:impl FnMut(Self::Face));
+	fn edge_faces(&self,edge_id:Self::Edge)->impl AsRef<[Self::Face;2]>;
+	fn edge_verts(&self,edge_id:Self::Edge)->impl AsRef<[Self::Vert;2]>;
+	#[expect(unused)]
+	fn for_each_face_vert(&self,face_id:Self::Face,f:impl FnMut(Self::Vert));
+	fn for_each_face_edge(&self,face_id:Self::Face,f:impl FnMut(Self::DirectedEdge));
+}
+
+// Make face_nd d value relative
+// euclidean point?
+// Simplex physics
+// Directed edge necessary?
+// recursive for_each function calls
+// define faces from vertices (Fixed<2> vs Fixed<3>)
+pub trait MeshQuery:MeshTopology{
+	type Position;
+	type Direction;
+	type Normal;
+	type Offset;
+	fn vert(&self,vert_id:Self::Vert)->Self::Position;
+	fn farthest_vert(&self,dir:Self::Direction)->Self::Vert;
+	/// This must return a point inside the mesh.
+	fn hint_point(&self)->Self::Position;
+	fn face_nd(&self,face_id:Self::Face)->(Self::Normal,Self::Offset);
+	fn edge_n(&self,edge_id:Self::Edge)->Self::Direction;
+	fn directed_edge_n(&self,directed_edge_id:Self::DirectedEdge)->Self::Direction;
+}

engine/physics/src/minimum_difference.rs

@@ -2,9 +2,9 @@ use strafesnet_common::integer::vec3;
 use strafesnet_common::integer::vec3::Vector3;
 use strafesnet_common::integer::{Fixed,Planar64,Planar64Vec3};
 
-use crate::model::{DirectedEdge,FEV,MeshQuery};
+use crate::mesh_query::{FEV,DirectedEdge,MeshQuery,MeshTopology};
 // TODO: remove mesh invert
-use crate::model::{MinkowskiMesh,MinkowskiVert};
+use crate::minkowski::{MinkowskiMesh,MinkowskiVert};
 
 // This algorithm is based on Lua code
 // written by Trey Reynolds in 2021
@@ -46,7 +46,7 @@ local function absDet(r, u, v, w)
 end
 */
 impl<Vert> Simplex2_4<Vert>{
-	fn det_is_zero<M:MeshQuery<Vert=Vert>>(self,mesh:&M)->bool{
+	fn det_is_zero<M:MeshQuery<Vert=Vert,Position=Planar64Vec3>>(self,mesh:&M)->bool{
 		match self{
 			Self::Simplex4([p0,p1,p2,p3])=>{
 				let p0=mesh.vert(p0);
@@ -131,11 +131,13 @@ fn narrow_dir3(dir:Vector3<Fixed<3,96>>)->Planar64Vec3{
 	}.narrow_1().unwrap()
 }
 
-fn reduce1<M:MeshQuery>(
+fn reduce1<M:MeshQuery<Position=Planar64Vec3>>(
 	[v0]:Simplex<1,M::Vert>,
 	mesh:&M,
 	point:Planar64Vec3,
-)->Reduced<M::Vert>{
+)->Reduced<M::Vert>
+	where M::Vert:Copy,
+{
 	// --debug.profilebegin("reduceSimplex0")
 	// local a = a1 - a0
 	let p0=mesh.vert(v0);
@@ -160,11 +162,14 @@ fn reduce1<M:MeshQuery>(
 }
 
 // local function reduceSimplex1(a0, a1, b0, b1)
-fn reduce2<M:MeshQuery>(
+fn reduce2<M:MeshQuery<Position=Planar64Vec3>>(
 	[v0,v1]:Simplex<2,M::Vert>,
 	mesh:&M,
 	point:Planar64Vec3,
-)->Reduced<M::Vert>{
+)->Reduced<M::Vert>
+	where
+		M::Vert:Copy
+{
 	// --debug.profilebegin("reduceSimplex1")
 	// local a = a1 - a0
 	// local b = b1 - b0
@@ -217,11 +222,14 @@ fn reduce2<M:MeshQuery>(
 }
 
 // local function reduceSimplex2(a0, a1, b0, b1, c0, c1)
-fn reduce3<M:MeshQuery>(
+fn reduce3<M:MeshQuery<Position=Planar64Vec3>>(
 	[v0,mut v1,v2]:Simplex<3,M::Vert>,
 	mesh:&M,
 	point:Planar64Vec3,
-)->Reduced<M::Vert>{
+)->Reduced<M::Vert>
+	where
+		M::Vert:Copy
+{
 	// --debug.profilebegin("reduceSimplex2")
 	// local a = a1 - a0
 	// local b = b1 - b0
@@ -326,11 +334,14 @@ fn reduce3<M:MeshQuery>(
 }
 
 // local function reduceSimplex3(a0, a1, b0, b1, c0, c1, d0, d1)
-fn reduce4<M:MeshQuery>(
+fn reduce4<M:MeshQuery<Position=Planar64Vec3>>(
 	[v0,mut v1,mut v2,v3]:Simplex<4,M::Vert>,
 	mesh:&M,
 	point:Planar64Vec3,
-)->Reduce<M::Vert>{
+)->Reduce<M::Vert>
+	where
+		M::Vert:Copy
+{
 	// --debug.profilebegin("reduceSimplex3")
 	// local a = a1 - a0
 	// local b = b1 - b0
@@ -516,7 +527,10 @@ enum Reduce<Vert>{
 }
 
 impl<Vert> Simplex2_4<Vert>{
-	fn reduce<M:MeshQuery<Vert=Vert>>(self,mesh:&M,point:Planar64Vec3)->Reduce<Vert>{
+	fn reduce<M:MeshQuery<Vert=Vert,Position=Planar64Vec3>>(self,mesh:&M,point:Planar64Vec3)->Reduce<Vert>
+		where
+			M::Vert:Copy
+	{
 		match self{
 			Self::Simplex2(simplex)=>Reduce::Reduced(reduce2(simplex,mesh,point)),
 			Self::Simplex3(simplex)=>Reduce::Reduced(reduce3(simplex,mesh,point)),
@@ -531,11 +545,11 @@ enum Transition<Vert>{
 	Done,//found closest vert, no edges are better
 	Vert(Vert),//transition to vert
 }
-enum EV<M:MeshQuery>{
+enum EV<M:MeshTopology>{
 	Vert(M::Vert),
-	Edge(<M::Edge as DirectedEdge>::UndirectedEdge),
+	Edge(M::Edge),
 }
-impl<M:MeshQuery> From<EV<M>> for FEV<M>{
+impl<M:MeshTopology> From<EV<M>> for FEV<M>{
 	fn from(value:EV<M>)->Self{
 		match value{
 			EV::Vert(minkowski_vert)=>FEV::Vert(minkowski_vert),
@@ -555,7 +569,7 @@ struct ThickPlane{
 	epsilon:Fixed<3,96>,
 }
 impl ThickPlane{
-	fn new<M:MeshQuery>(mesh:&M,[v0,v1,v2]:Simplex<3,M::Vert>)->Self{
+	fn new<M:MeshQuery<Position=Planar64Vec3>>(mesh:&M,[v0,v1,v2]:Simplex<3,M::Vert>)->Self{
 		let p0=mesh.vert(v0);
 		let p1=mesh.vert(v1);
 		let p2=mesh.vert(v2);
@@ -579,7 +593,7 @@ struct ThickLine{
 	epsilon:Fixed<4,128>,
 }
 impl ThickLine{
-	fn new<M:MeshQuery>(mesh:&M,[v0,v1]:Simplex<2,M::Vert>)->Self{
+	fn new<M:MeshQuery<Position=Planar64Vec3>>(mesh:&M,[v0,v1]:Simplex<2,M::Vert>)->Self{
 		let p0=mesh.vert(v0);
 		let p1=mesh.vert(v1);
 		let point=p0;
@@ -602,10 +616,14 @@ struct EVFinder<'a,M,C>{
 	best_distance_squared:Fixed<2,64>,
 }
 
-impl<M:MeshQuery,C:Contains> EVFinder<'_,M,C>{
+impl<M:MeshQuery<Position=Planar64Vec3>,C:Contains> EVFinder<'_,M,C>
+	where
+		M::Vert:Copy,
+		M::DirectedEdge:Copy,
+{
 	fn next_transition_vert(&mut self,vert_id:M::Vert,point:Planar64Vec3)->Transition<M::Vert>{
 		let mut best_transition=Transition::Done;
-		for &directed_edge_id in self.mesh.vert_edges(vert_id).as_ref(){
+		self.mesh.for_each_vert_edge(vert_id,|directed_edge_id|{
 			//test if this edge's opposite vertex closer
 			let edge_verts=self.mesh.edge_verts(directed_edge_id.as_undirected());
 			//select opposite vertex
@@ -618,14 +636,14 @@ impl<M:MeshQuery,C:Contains> EVFinder<'_,M,C>{
 				best_transition=Transition::Vert(test_vert_id);
 				self.best_distance_squared=distance_squared;
 			}
-		}
+		});
 		best_transition
 	}
 	fn final_ev(&mut self,vert_id:M::Vert,point:Planar64Vec3)->EV<M>{
 		let mut best_transition=EV::Vert(vert_id);
 		let vert_pos=self.mesh.vert(vert_id);
 		let diff=point-vert_pos;
-		for &directed_edge_id in self.mesh.vert_edges(vert_id).as_ref(){
+		self.mesh.for_each_vert_edge(vert_id,|directed_edge_id|{
 			//test if this edge is closer
 			let edge_verts=self.mesh.edge_verts(directed_edge_id.as_undirected());
 			let test_vert_id=edge_verts.as_ref()[directed_edge_id.parity() as usize];
@@ -646,10 +664,13 @@ impl<M:MeshQuery,C:Contains> EVFinder<'_,M,C>{
 					self.best_distance_squared=distance_squared;
 				}
 			}
-		}
+		});
 		best_transition
 	}
-	fn crawl_boundaries(&mut self,mut vert_id:M::Vert,point:Planar64Vec3)->EV<M>{
+	fn crawl_boundaries(&mut self,mut vert_id:M::Vert,point:Planar64Vec3)->EV<M>
+		where
+			M::Vert:Copy
+	{
 		loop{
 			match self.next_transition_vert(vert_id,point){
 				Transition::Done=>return self.final_ev(vert_id,point),
@@ -659,7 +680,11 @@ impl<M:MeshQuery,C:Contains> EVFinder<'_,M,C>{
 	}
 }
 /// This function hops along parallel vertices until it finds the EV which contains the closest point to `point`.
-fn crawl_to_closest_ev<M:MeshQuery>(mesh:&M,simplex:Simplex<2,M::Vert>,point:Planar64Vec3)->EV<M>{
+fn crawl_to_closest_ev<M:MeshQuery<Position=Planar64Vec3>>(mesh:&M,simplex:Simplex<2,M::Vert>,point:Planar64Vec3)->EV<M>
+	where
+		M::Vert:Copy,
+		M::DirectedEdge:Copy,
+{
 	// naively start at the closest vertex
 	// the closest vertex is not necessarily the one with the fewest boundary hops
 	// but it doesn't matter, we will get there regardless.
@@ -787,13 +812,16 @@ pub fn contains_point(mesh:&MinkowskiMesh<'_>,point:Planar64Vec3)->bool{
 // 	queryQ, radiusQ,
 // 	exitRadius, testIntersection
 // )
-fn minimum_difference<const ENABLE_FAST_FAIL:bool,T,M:MeshQuery>(
+fn minimum_difference<const ENABLE_FAST_FAIL:bool,T,M:MeshQuery<Position=Planar64Vec3,Direction=Planar64Vec3>>(
 	mesh:&M,
 	point:Planar64Vec3,
 	on_exact:impl FnOnce(bool,Simplex1_3<M::Vert>)->T,
 	on_escape:impl FnOnce(Simplex<4,M::Vert>)->T,
 	on_fast_fail:impl FnOnce()->T,
-)->T{
+)->T
+	where
+		M::Vert:Copy
+{
 	// local initialAxis = queryQ() - queryP()
 	// local new_point_p = queryP(initialAxis)
 	// local new_point_q = queryQ(-initialAxis)

engine/physics/src/minkowski.rs

@@ -0,0 +1,407 @@
+use core::ops::{Bound,RangeBounds};
+
+use strafesnet_common::integer::{Planar64Vec3,Ratio,Fixed,vec3::Vector3};
+use crate::model::into_giga_time;
+use crate::model::{SubmeshVertId,SubmeshEdgeId,SubmeshDirectedEdgeId,SubmeshFaceId,TransformedMesh,GigaTime};
+use crate::mesh_query::{MeshQuery,MeshTopology,DirectedEdge,UndirectedEdge};
+use crate::physics::{Time,Trajectory};
+
+struct AsRefHelper<T>(T);
+impl<T> AsRef<T> for AsRefHelper<T>{
+	fn as_ref(&self)->&T{
+		&self.0
+	}
+}
+
+//Note that a face on a minkowski mesh refers to a pair of fevs on the meshes it's summed from
+//(face,vertex)
+//(edge,edge)
+//(vertex,face)
+#[derive(Clone,Copy,Debug,Eq,PartialEq)]
+pub enum MinkowskiVert{
+	VertVert(SubmeshVertId,SubmeshVertId),
+}
+// TODO: remove this
+impl core::ops::Neg for MinkowskiVert{
+	type Output=Self;
+	fn neg(self)->Self::Output{
+		match self{
+			MinkowskiVert::VertVert(v0,v1)=>MinkowskiVert::VertVert(v1,v0),
+		}
+	}
+}
+#[derive(Clone,Copy,Debug)]
+pub enum MinkowskiEdge{
+	VertEdge(SubmeshVertId,SubmeshEdgeId),
+	EdgeVert(SubmeshEdgeId,SubmeshVertId),
+	//EdgeEdge when edges are parallel
+}
+impl UndirectedEdge for MinkowskiEdge{
+	type DirectedEdge=MinkowskiDirectedEdge;
+	fn as_directed(self,parity:bool)->Self::DirectedEdge{
+		match self{
+			MinkowskiEdge::VertEdge(v0,e1)=>MinkowskiDirectedEdge::VertEdge(v0,e1.as_directed(parity)),
+			MinkowskiEdge::EdgeVert(e0,v1)=>MinkowskiDirectedEdge::EdgeVert(e0.as_directed(parity),v1),
+		}
+	}
+}
+#[derive(Clone,Copy,Debug)]
+pub enum MinkowskiDirectedEdge{
+	VertEdge(SubmeshVertId,SubmeshDirectedEdgeId),
+	EdgeVert(SubmeshDirectedEdgeId,SubmeshVertId),
+	//EdgeEdge when edges are parallel
+}
+impl DirectedEdge for MinkowskiDirectedEdge{
+	type UndirectedEdge=MinkowskiEdge;
+	fn as_undirected(self)->Self::UndirectedEdge{
+		match self{
+			MinkowskiDirectedEdge::VertEdge(v0,e1)=>MinkowskiEdge::VertEdge(v0,e1.as_undirected()),
+			MinkowskiDirectedEdge::EdgeVert(e0,v1)=>MinkowskiEdge::EdgeVert(e0.as_undirected(),v1),
+		}
+	}
+	fn parity(&self)->bool{
+		match self{
+			MinkowskiDirectedEdge::VertEdge(_,e)
+			|MinkowskiDirectedEdge::EdgeVert(e,_)=>e.parity(),
+		}
+	}
+}
+#[derive(Clone,Copy,Debug,Hash)]
+pub enum MinkowskiFace{
+	VertFace(SubmeshVertId,SubmeshFaceId),
+	EdgeEdge(SubmeshEdgeId,SubmeshEdgeId,bool),
+	FaceVert(SubmeshFaceId,SubmeshVertId),
+	//EdgeFace
+	//FaceEdge
+	//FaceFace
+}
+
+#[derive(Debug)]
+pub struct MinkowskiMesh<'a>{
+	mesh0:TransformedMesh<'a>,
+	mesh1:TransformedMesh<'a>,
+}
+
+// TODO: remove this
+impl<'a> core::ops::Neg for &MinkowskiMesh<'a>{
+	type Output=MinkowskiMesh<'a>;
+	fn neg(self)->Self::Output{
+		MinkowskiMesh::minkowski_sum(self.mesh1,self.mesh0)
+	}
+}
+
+impl MinkowskiMesh<'_>{
+	pub fn minkowski_sum<'a>(mesh0:TransformedMesh<'a>,mesh1:TransformedMesh<'a>)->MinkowskiMesh<'a>{
+		MinkowskiMesh{
+			mesh0,
+			mesh1,
+		}
+	}
+	pub fn predict_collision_in(&self,trajectory:&Trajectory,range:impl RangeBounds<Time>)->Option<(MinkowskiFace,GigaTime)>{
+		let start_position=match range.start_bound(){
+			Bound::Included(time)=>trajectory.extrapolated_position(*time),
+			Bound::Excluded(time)=>trajectory.extrapolated_position(*time),
+			Bound::Unbounded=>trajectory.position,
+		};
+		let fev=crate::minimum_difference::closest_fev_not_inside(self,start_position)?;
+		//continue forwards along the body parabola
+		fev.crawl(self,trajectory,range.start_bound(),range.end_bound()).hit()
+	}
+	pub fn predict_collision_out(&self,trajectory:&Trajectory,range:impl RangeBounds<Time>)->Option<(MinkowskiFace,GigaTime)>{
+		let (lower_bound,upper_bound)=(range.start_bound(),range.end_bound());
+		// TODO: handle unbounded collision using infinity fev
+		let start_position=match upper_bound{
+			Bound::Included(time)=>trajectory.extrapolated_position(*time),
+			Bound::Excluded(time)=>trajectory.extrapolated_position(*time),
+			Bound::Unbounded=>trajectory.position,
+		};
+		let fev=crate::minimum_difference::closest_fev_not_inside(self,start_position)?;
+		// swap and negate bounds to do a time inversion
+		let (lower_bound,upper_bound)=(upper_bound.map(|&t|-t),lower_bound.map(|&t|-t));
+		let time_reversed_trajectory=-trajectory;
+		//continue backwards along the body parabola
+		fev.crawl(self,&time_reversed_trajectory,lower_bound.as_ref(),upper_bound.as_ref()).hit()
+			//no need to test -time<time_limit because of the first step
+			.map(|(face,time)|(face,-time))
+	}
+	pub fn predict_collision_face_out(&self,trajectory:&Trajectory,range:impl RangeBounds<Time>,contact_face_id:MinkowskiFace)->Option<(MinkowskiDirectedEdge,GigaTime)>{
+		// TODO: make better
+		use crate::face_crawler::{low,upp};
+		//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=range.start_bound().map(|&t|(t-trajectory.time).to_ratio());
+		let mut best_time=range.end_bound().map(|&t|into_giga_time(t,trajectory.time));
+		let mut best_edge=None;
+		let face_n=self.face_nd(contact_face_id).0;
+		self.for_each_face_edge(contact_face_id,|directed_edge_id|{
+			let edge_n=self.directed_edge_n(directed_edge_id);
+			//f x e points in
+			let n=face_n.cross(edge_n);
+			let &[v0,v1]=self.edge_verts(directed_edge_id.as_undirected()).as_ref();
+			let d=n.dot(self.vert(v0)+self.vert(v1));
+			//WARNING! d outside of *2
+			//WARNING: truncated precision
+			//wrap for speed
+			for dt in Fixed::<4,128>::zeroes2(((n.dot(trajectory.position))*2-d).wrap_4(),n.dot(trajectory.velocity).wrap_4()*2,n.dot(trajectory.acceleration).wrap_4()){
+				if low(&start_time,&dt)&&upp(&dt,&best_time)&&n.dot(trajectory.extrapolated_velocity_ratio_dt(dt)).is_negative(){
+					best_time=Bound::Included(dt);
+					best_edge=Some((directed_edge_id,dt));
+					break;
+				}
+			}
+		});
+		best_edge
+	}
+	pub fn contains_point(&self,point:Planar64Vec3)->bool{
+		crate::minimum_difference::contains_point(self,point)
+	}
+}
+impl MeshQuery for MinkowskiMesh<'_>{
+	type Direction=Planar64Vec3;
+	type Position=Planar64Vec3;
+	type Normal=Vector3<Fixed<3,96>>;
+	type Offset=Fixed<4,128>;
+	// TODO: relative d
+	fn face_nd(&self,face_id:MinkowskiFace)->(Self::Normal,Self::Offset){
+		match face_id{
+			MinkowskiFace::VertFace(v0,f1)=>{
+				let (n,d)=self.mesh1.face_nd(f1);
+				(-n,d-n.dot(self.mesh0.vert(v0)))
+			},
+			MinkowskiFace::EdgeEdge(e0,e1,parity)=>{
+				let edge0_n=self.mesh0.edge_n(e0);
+				let edge1_n=self.mesh1.edge_n(e1);
+				let &[e0v0,e0v1]=self.mesh0.edge_verts(e0).as_ref();
+				let &[e1v0,e1v1]=self.mesh1.edge_verts(e1).as_ref();
+				let n=edge0_n.cross(edge1_n);
+				let e0d=n.dot(self.mesh0.vert(e0v0)+self.mesh0.vert(e0v1));
+				let e1d=n.dot(self.mesh1.vert(e1v0)+self.mesh1.vert(e1v1));
+				((n*(parity as i64*4-2)).widen_3(),((e0d-e1d)*(parity as i64*2-1)).widen_4())
+			},
+			MinkowskiFace::FaceVert(f0,v1)=>{
+				let (n,d)=self.mesh0.face_nd(f0);
+				(n,d-n.dot(self.mesh1.vert(v1)))
+			},
+		}
+	}
+	fn vert(&self,vert_id:MinkowskiVert)->Planar64Vec3{
+		match vert_id{
+			MinkowskiVert::VertVert(v0,v1)=>{
+				self.mesh0.vert(v0)-self.mesh1.vert(v1)
+			},
+		}
+	}
+	fn hint_point(&self)->Planar64Vec3{
+		self.mesh0.hint_point()-self.mesh1.hint_point()
+	}
+	fn farthest_vert(&self,dir:Planar64Vec3)->MinkowskiVert{
+		MinkowskiVert::VertVert(self.mesh0.farthest_vert(dir),self.mesh1.farthest_vert(-dir))
+	}
+	fn edge_n(&self,edge_id:Self::Edge)->Self::Direction{
+		let &[v0,v1]=self.edge_verts(edge_id).as_ref();
+		self.vert(v1)-self.vert(v0)
+	}
+	fn directed_edge_n(&self,directed_edge_id:Self::DirectedEdge)->Self::Direction{
+		let &[v0,v1]=self.edge_verts(directed_edge_id.as_undirected()).as_ref();
+		(self.vert(v1)-self.vert(v0))*((directed_edge_id.parity() as i64)*2-1)
+	}
+}
+impl MeshTopology for MinkowskiMesh<'_>{
+	type Face=MinkowskiFace;
+	type Edge=MinkowskiEdge;
+	type DirectedEdge=MinkowskiDirectedEdge;
+	type Vert=MinkowskiVert;
+	fn for_each_vert_edge(&self,vert_id:Self::Vert,mut f:impl FnMut(Self::DirectedEdge)){
+		match vert_id{
+			MinkowskiVert::VertVert(v0,v1)=>{
+				//detect shared volume when the other mesh is mirrored along a test edge dir
+				let v0f={
+					let mut faces=Vec::new();
+					self.mesh0.for_each_vert_face(v0,|face|faces.push(face));
+					faces
+				};
+				let v1f={
+					let mut faces=Vec::new();
+					self.mesh1.for_each_vert_face(v1,|face|faces.push(face));
+					faces
+				};
+				let v0f_n:Vec<_>=v0f.iter().map(|&face_id|self.mesh0.face_nd(face_id).0).collect();
+				let v1f_n:Vec<_>=v1f.iter().map(|&face_id|self.mesh1.face_nd(face_id).0).collect();
+				// scratch vector
+				let mut face_normals=Vec::with_capacity(v0f.len()+v1f.len());
+				face_normals.clone_from(&v0f_n);
+				self.mesh0.for_each_vert_edge(v0,|directed_edge_id|{
+					let n=self.mesh0.directed_edge_n(directed_edge_id);
+					let nn=n.dot(n);
+					// TODO: there's gotta be a better way to do this
+					// drop faces beyond v0f_n
+					face_normals.truncate(v0f.len());
+					// make a set of faces from mesh0's perspective
+					for face_n in &v1f_n{
+						//add reflected mesh1 faces
+						//wrap for speed
+						face_normals.push(*face_n-(n*face_n.dot(n)*2/nn).divide().wrap_3());
+					}
+					if is_empty_volume(&face_normals){
+						f(MinkowskiDirectedEdge::EdgeVert(directed_edge_id,v1));
+					}
+				});
+				face_normals.clone_from(&v1f_n);
+				self.mesh1.for_each_vert_edge(v1,|directed_edge_id|{
+					let n=self.mesh1.directed_edge_n(directed_edge_id);
+					let nn=n.dot(n);
+					// drop faces beyond v1f_n
+					face_normals.truncate(v1f.len());
+					// make a set of faces from mesh1's perspective
+					for face_n in &v0f_n{
+						//wrap for speed
+						face_normals.push(*face_n-(n*face_n.dot(n)*2/nn).divide().wrap_3());
+					}
+					if is_empty_volume(&face_normals){
+						f(MinkowskiDirectedEdge::VertEdge(v0,directed_edge_id));
+					}
+				});
+			},
+		}
+	}
+	fn for_each_vert_face(&self,_vert_id:Self::Vert,_f:impl FnMut(Self::Face)){
+		unimplemented!()
+	}
+	fn edge_faces(&self,edge_id:Self::Edge)->impl AsRef<[Self::Face;2]>{
+		match edge_id{
+			MinkowskiEdge::VertEdge(v0,e1)=>{
+				//faces are listed backwards from the minkowski mesh
+				let v0e={
+					let mut edges=Vec::new();
+					self.mesh0.for_each_vert_edge(v0,|edge|edges.push(edge));
+					edges
+				};
+				let &[e1f0,e1f1]=self.mesh1.edge_faces(e1).as_ref();
+				AsRefHelper([(e1f1,false),(e1f0,true)].map(|(edge_face_id1,face_parity)|{
+					let mut best_edge=None;
+					let mut best_d:Ratio<Fixed<8,256>,Fixed<8,256>>=Ratio::new(Fixed::ZERO,Fixed::ONE);
+					let edge_face1_n=self.mesh1.face_nd(edge_face_id1).0;
+					let edge_face1_nn=edge_face1_n.dot(edge_face1_n);
+					for &directed_edge_id0 in &v0e{
+						let edge0_n=self.mesh0.directed_edge_n(directed_edge_id0);
+						//must be behind other face.
+						let d=edge_face1_n.dot(edge0_n);
+						if d.is_negative(){
+							let edge0_nn=edge0_n.dot(edge0_n);
+							// Assume not every number is huge
+							// TODO: revisit this
+							let dd=(d*d)/(edge_face1_nn*edge0_nn);
+							if best_d<dd{
+								best_d=dd;
+								best_edge=Some(directed_edge_id0);
+							}
+						}
+					}
+					best_edge.map_or(
+						MinkowskiFace::VertFace(v0,edge_face_id1),
+						|directed_edge_id0|MinkowskiFace::EdgeEdge(directed_edge_id0.as_undirected(),e1,directed_edge_id0.parity()^face_parity)
+					)
+				}))
+			},
+			MinkowskiEdge::EdgeVert(e0,v1)=>{
+				//tracking index with an external variable because .enumerate() is not available
+				let v1e={
+					let mut edges=Vec::new();
+					self.mesh1.for_each_vert_edge(v1,|edge|edges.push(edge));
+					edges
+				};
+				let &[e0f0,e0f1]=self.mesh0.edge_faces(e0).as_ref();
+				AsRefHelper([(e0f0,true),(e0f1,false)].map(|(edge_face_id0,face_parity)|{
+					let mut best_edge=None;
+					let mut best_d:Ratio<Fixed<8,256>,Fixed<8,256>>=Ratio::new(Fixed::ZERO,Fixed::ONE);
+					let edge_face0_n=self.mesh0.face_nd(edge_face_id0).0;
+					let edge_face0_nn=edge_face0_n.dot(edge_face0_n);
+					for &directed_edge_id1 in &v1e{
+						let edge1_n=self.mesh1.directed_edge_n(directed_edge_id1);
+						let d=edge_face0_n.dot(edge1_n);
+						if d.is_negative(){
+							let edge1_nn=edge1_n.dot(edge1_n);
+							let dd=(d*d)/(edge_face0_nn*edge1_nn);
+							if best_d<dd{
+								best_d=dd;
+								best_edge=Some(directed_edge_id1);
+							}
+						}
+					}
+					best_edge.map_or(
+						MinkowskiFace::FaceVert(edge_face_id0,v1),
+						|directed_edge_id1|MinkowskiFace::EdgeEdge(e0,directed_edge_id1.as_undirected(),directed_edge_id1.parity()^face_parity)
+					)
+				}))
+			},
+		}
+	}
+	fn edge_verts(&self,edge_id:Self::Edge)->impl AsRef<[Self::Vert;2]>{
+		AsRefHelper(match edge_id{
+			MinkowskiEdge::VertEdge(v0,e1)=>self.mesh1.edge_verts(e1).as_ref().map(|vert_id1|
+				MinkowskiVert::VertVert(v0,vert_id1)
+			),
+			MinkowskiEdge::EdgeVert(e0,v1)=>self.mesh0.edge_verts(e0).as_ref().map(|vert_id0|
+				MinkowskiVert::VertVert(vert_id0,v1)
+			),
+		})
+	}
+	fn for_each_face_vert(&self,_face_id:Self::Face,_f:impl FnMut(Self::Vert)){
+		unimplemented!()
+	}
+	fn for_each_face_edge(&self,face_id:Self::Face,mut f:impl FnMut(Self::DirectedEdge)){
+		match face_id{
+			MinkowskiFace::VertFace(v0,f1)=>{
+				self.mesh1.for_each_face_edge(f1,|edge_id1|
+					f(MinkowskiDirectedEdge::VertEdge(v0,edge_id1.reverse()))
+				)
+			},
+			MinkowskiFace::EdgeEdge(e0,e1,parity)=>{
+				let &[e0v0,e0v1]=self.mesh0.edge_verts(e0).as_ref();
+				let &[e1v0,e1v1]=self.mesh1.edge_verts(e1).as_ref();
+				//could sort this if ordered edges are needed
+				//probably just need to reverse this list according to parity
+				f(MinkowskiDirectedEdge::VertEdge(e0v0,e1.as_directed(parity)));
+				f(MinkowskiDirectedEdge::EdgeVert(e0.as_directed(!parity),e1v0));
+				f(MinkowskiDirectedEdge::VertEdge(e0v1,e1.as_directed(!parity)));
+				f(MinkowskiDirectedEdge::EdgeVert(e0.as_directed(parity),e1v1));
+			},
+			MinkowskiFace::FaceVert(f0,v1)=>{
+				self.mesh0.for_each_face_edge(f0,|edge_id0|
+					f(MinkowskiDirectedEdge::EdgeVert(edge_id0,v1))
+				)
+			},
+		}
+	}
+}
+
+fn is_empty_volume(normals:&[Vector3<Fixed<3,96>>])->bool{
+	let len=normals.len();
+	for i in 0..len-1{
+		for j in i+1..len{
+			let n=normals[i].cross(normals[j]);
+			let mut d_comp=None;
+			for k in 0..len{
+				if k!=i&&k!=j{
+					let d=n.dot(normals[k]).is_negative();
+					if let &Some(comp)=&d_comp{
+						// This is testing if d_comp*d < 0
+						if comp^d{
+							return true;
+						}
+					}else{
+						d_comp=Some(d);
+					}
+				}
+			}
+		}
+	}
+	return false;
+}
+
+#[test]
+fn test_is_empty_volume(){
+	use strafesnet_common::integer::vec3;
+	assert!(!is_empty_volume(&[vec3::X.widen_3(),vec3::Y.widen_3(),vec3::Z.widen_3()]));
+	assert!(is_empty_volume(&[vec3::X.widen_3(),vec3::Y.widen_3(),vec3::Z.widen_3(),vec3::NEG_X.widen_3()]));
+}

engine/physics/src/model.rs

@@ -1,11 +1,9 @@
 use std::collections::{HashSet,HashMap};
-use core::ops::{Bound,RangeBounds};
 use strafesnet_common::integer::vec3::Vector3;
 use strafesnet_common::model::{self,MeshId,PolygonIter};
 use strafesnet_common::integer::{self,vec3,Fixed,Planar64,Planar64Vec3,Ratio};
 use strafesnet_common::physics::Time;
-
-type Trajectory=crate::body::Trajectory<strafesnet_common::physics::TimeInner>;
+use crate::mesh_query::{MeshQuery,MeshTopology,DirectedEdge,UndirectedEdge};
 
 struct AsRefHelper<T>(T);
 impl<T> AsRef<T> for AsRefHelper<T>{
@@ -14,20 +12,6 @@ impl<T> AsRef<T> for AsRefHelper<T>{
 	}
 }
 
-pub trait UndirectedEdge{
-	type DirectedEdge:Copy+DirectedEdge;
-	fn as_directed(self,parity:bool)->Self::DirectedEdge;
-}
-pub trait DirectedEdge:Copy{
-	type UndirectedEdge:Copy+std::fmt::Debug+UndirectedEdge;
-	fn as_undirected(self)->Self::UndirectedEdge;
-	fn parity(&self)->bool;
-	//this is stupid but may work fine
-	fn reverse(self)-><<Self as DirectedEdge>::UndirectedEdge as UndirectedEdge>::DirectedEdge{
-		self.as_undirected().as_directed(!self.parity())
-	}
-}
-
 #[derive(Debug,Clone,Copy,Hash,id::Id,Eq,PartialEq)]
 pub struct MeshVertId(u32);
 #[derive(Debug,Clone,Copy,Hash,id::Id,Eq,PartialEq)]
@@ -59,14 +43,6 @@ impl DirectedEdge for SubmeshDirectedEdgeId{
 	}
 }
 
-//Vertex <-> Edge <-> Face -> Collide
-#[derive(Debug)]
-pub enum FEV<M:MeshQuery>{
-	Face(M::Face),
-	Edge(<M::Edge as DirectedEdge>::UndirectedEdge),
-	Vert(M::Vert),
-}
-
 //use Unit32 #[repr(C)] for map files
 #[derive(Clone,Copy,Debug,Hash,Eq,PartialEq)]
 struct Face{
@@ -75,32 +51,6 @@ struct Face{
 }
 #[derive(Debug)]
 struct Vert(Planar64Vec3);
-pub trait MeshQuery{
-	type Face:Copy;
-	type Edge:Copy+DirectedEdge;
-	type Vert:Copy;
-	// Vertex must be Planar64Vec3 because it represents an actual position
-	type Normal;
-	type Offset;
-	fn edge_n(&self,edge_id:<Self::Edge as DirectedEdge>::UndirectedEdge)->Planar64Vec3{
-		let &[v0,v1]=self.edge_verts(edge_id).as_ref();
-		self.vert(v1)-self.vert(v0)
-	}
-	fn directed_edge_n(&self,directed_edge_id:Self::Edge)->Planar64Vec3{
-		let &[v0,v1]=self.edge_verts(directed_edge_id.as_undirected()).as_ref();
-		(self.vert(v1)-self.vert(v0))*((directed_edge_id.parity() as i64)*2-1)
-	}
-	/// This must return a point inside the mesh.
-	fn hint_point(&self)->Planar64Vec3;
-	fn farthest_vert(&self,dir:Planar64Vec3)->Self::Vert;
-	fn vert(&self,vert_id:Self::Vert)->Planar64Vec3;
-	fn face_nd(&self,face_id:Self::Face)->(Self::Normal,Self::Offset);
-	fn face_edges(&self,face_id:Self::Face)->impl AsRef<[Self::Edge]>;
-	fn edge_faces(&self,edge_id:<Self::Edge as DirectedEdge>::UndirectedEdge)->impl AsRef<[Self::Face;2]>;
-	fn edge_verts(&self,edge_id:<Self::Edge as DirectedEdge>::UndirectedEdge)->impl AsRef<[Self::Vert;2]>;
-	fn vert_edges(&self,vert_id:Self::Vert)->impl AsRef<[Self::Edge]>;
-	fn vert_faces(&self,vert_id:Self::Vert)->impl AsRef<[Self::Face]>;
-}
 #[derive(Debug)]
 struct FaceRefs{
 	// I didn't write it down, but I assume the edges are directed
@@ -445,9 +395,8 @@ pub struct PhysicsMeshView<'a>{
 	topology:&'a PhysicsMeshTopology,
 }
 impl MeshQuery for PhysicsMeshView<'_>{
-	type Face=SubmeshFaceId;
-	type Edge=SubmeshDirectedEdgeId;
-	type Vert=SubmeshVertId;
+	type Position=Planar64Vec3;
+	type Direction=Planar64Vec3;
 	type Normal=Planar64Vec3;
 	type Offset=Planar64;
 	fn face_nd(&self,face_id:SubmeshFaceId)->(Planar64Vec3,Planar64){
@@ -475,20 +424,37 @@ impl MeshQuery for PhysicsMeshView<'_>{
 		let vert_idx=self.topology.verts[vert_id.get() as usize].get() as usize;
 		self.data.verts[vert_idx].0
 	}
-	fn face_edges(&self,face_id:SubmeshFaceId)->impl AsRef<[SubmeshDirectedEdgeId]>{
-		self.topology.face_topology[face_id.get() as usize].edges.as_slice()
+	fn edge_n(&self,edge_id:Self::Edge)->Self::Direction{
+		let &[v0,v1]=self.edge_verts(edge_id).as_ref();
+		self.vert(v1)-self.vert(v0)
 	}
-	fn edge_faces(&self,edge_id:SubmeshEdgeId)->impl AsRef<[SubmeshFaceId;2]>{
+	fn directed_edge_n(&self,directed_edge_id:Self::DirectedEdge)->Self::Direction{
+		let &[v0,v1]=self.edge_verts(directed_edge_id.as_undirected()).as_ref();
+		(self.vert(v1)-self.vert(v0))*((directed_edge_id.parity() as i64)*2-1)
+	}
+}
+impl MeshTopology for PhysicsMeshView<'_>{
+	type Face=SubmeshFaceId;
+	type Edge=SubmeshEdgeId;
+	type DirectedEdge=SubmeshDirectedEdgeId;
+	type Vert=SubmeshVertId;
+	fn for_each_vert_edge(&self,vert_id:Self::Vert,f:impl FnMut(Self::DirectedEdge)){
+		self.topology.vert_topology[vert_id.get() as usize].edges.iter().copied().for_each(f);
+	}
+	fn for_each_vert_face(&self,vert_id:Self::Vert,f:impl FnMut(Self::Face)){
+		self.topology.vert_topology[vert_id.get() as usize].faces.iter().copied().for_each(f);
+	}
+	fn edge_faces(&self,edge_id:Self::Edge)->impl AsRef<[Self::Face;2]>{
 		AsRefHelper(self.topology.edge_topology[edge_id.get() as usize].faces)
 	}
-	fn edge_verts(&self,edge_id:SubmeshEdgeId)->impl AsRef<[SubmeshVertId;2]>{
+	fn edge_verts(&self,edge_id:Self::Edge)->impl AsRef<[Self::Vert;2]>{
 		AsRefHelper(self.topology.edge_topology[edge_id.get() as usize].verts)
 	}
-	fn vert_edges(&self,vert_id:SubmeshVertId)->impl AsRef<[SubmeshDirectedEdgeId]>{
-		self.topology.vert_topology[vert_id.get() as usize].edges.as_slice()
+	fn for_each_face_vert(&self,_face_id:Self::Face,_f:impl FnMut(Self::Vert)){
+		unimplemented!()
 	}
-	fn vert_faces(&self,vert_id:SubmeshVertId)->impl AsRef<[SubmeshFaceId]>{
-		self.topology.vert_topology[vert_id.get() as usize].faces.as_slice()
+	fn for_each_face_edge(&self,face_id:Self::Face,f:impl FnMut(Self::DirectedEdge)){
+		self.topology.face_topology[face_id.get() as usize].edges.iter().copied().for_each(f);
 	}
 }
 
@@ -528,9 +494,8 @@ impl TransformedMesh<'_>{
 	}
 }
 impl MeshQuery for TransformedMesh<'_>{
-	type Face=SubmeshFaceId;
-	type Edge=SubmeshDirectedEdgeId;
-	type Vert=SubmeshVertId;
+	type Direction=Planar64Vec3;
+	type Position=Planar64Vec3;
 	type Normal=Vector3<Fixed<3,96>>;
 	type Offset=Fixed<4,128>;
 	fn face_nd(&self,face_id:SubmeshFaceId)->(Self::Normal,Self::Offset){
@@ -558,398 +523,47 @@ impl MeshQuery for TransformedMesh<'_>{
 			.unwrap().0 as u32
 		)
 	}
+	fn edge_n(&self,edge_id:Self::Edge)->Self::Direction{
+		let &[v0,v1]=self.edge_verts(edge_id).as_ref();
+		self.vert(v1)-self.vert(v0)
+	}
+	fn directed_edge_n(&self,directed_edge_id:Self::DirectedEdge)->Self::Direction{
+		let &[v0,v1]=self.edge_verts(directed_edge_id.as_undirected()).as_ref();
+		(self.vert(v1)-self.vert(v0))*((directed_edge_id.parity() as i64)*2-1)
+	}
+}
+impl MeshTopology for TransformedMesh<'_>{
+	type Face=SubmeshFaceId;
+	type Edge=SubmeshEdgeId;
+	type DirectedEdge=SubmeshDirectedEdgeId;
+	type Vert=SubmeshVertId;
 	#[inline]
-	fn face_edges(&self,face_id:SubmeshFaceId)->impl AsRef<[SubmeshDirectedEdgeId]>{
-		self.view.face_edges(face_id)
+	fn for_each_vert_edge(&self,vert_id:Self::Vert,f:impl FnMut(Self::DirectedEdge)){
+		self.view.for_each_vert_edge(vert_id,f)
 	}
 	#[inline]
-	fn edge_faces(&self,edge_id:SubmeshEdgeId)->impl AsRef<[SubmeshFaceId;2]>{
+	fn for_each_vert_face(&self,vert_id:Self::Vert,f:impl FnMut(Self::Face)){
+		self.view.for_each_vert_face(vert_id,f)
+	}
+	#[inline]
+	fn edge_faces(&self,edge_id:Self::Edge)->impl AsRef<[Self::Face;2]>{
 		self.view.edge_faces(edge_id)
 	}
 	#[inline]
-	fn edge_verts(&self,edge_id:SubmeshEdgeId)->impl AsRef<[SubmeshVertId;2]>{
+	fn edge_verts(&self,edge_id:Self::Edge)->impl AsRef<[Self::Vert;2]>{
 		self.view.edge_verts(edge_id)
 	}
-	#[inline]
-	fn vert_edges(&self,vert_id:SubmeshVertId)->impl AsRef<[SubmeshDirectedEdgeId]>{
-		self.view.vert_edges(vert_id)
+	fn for_each_face_vert(&self,face_id:Self::Face,f:impl FnMut(Self::Vert)){
+		self.view.for_each_face_vert(face_id,f)
 	}
 	#[inline]
-	fn vert_faces(&self,vert_id:SubmeshVertId)->impl AsRef<[SubmeshFaceId]>{
-		self.view.vert_faces(vert_id)
+	fn for_each_face_edge(&self,face_id:Self::Face,f:impl FnMut(Self::DirectedEdge)){
+		self.view.for_each_face_edge(face_id,f)
 	}
 }
 
-//Note that a face on a minkowski mesh refers to a pair of fevs on the meshes it's summed from
-//(face,vertex)
-//(edge,edge)
-//(vertex,face)
-#[derive(Clone,Copy,Debug,Eq,PartialEq)]
-pub enum MinkowskiVert{
-	VertVert(SubmeshVertId,SubmeshVertId),
-}
-// TODO: remove this
-impl core::ops::Neg for MinkowskiVert{
-	type Output=Self;
-	fn neg(self)->Self::Output{
-		match self{
-			MinkowskiVert::VertVert(v0,v1)=>MinkowskiVert::VertVert(v1,v0),
-		}
-	}
-}
-#[derive(Clone,Copy,Debug)]
-pub enum MinkowskiEdge{
-	VertEdge(SubmeshVertId,SubmeshEdgeId),
-	EdgeVert(SubmeshEdgeId,SubmeshVertId),
-	//EdgeEdge when edges are parallel
-}
-impl UndirectedEdge for MinkowskiEdge{
-	type DirectedEdge=MinkowskiDirectedEdge;
-	fn as_directed(self,parity:bool)->Self::DirectedEdge{
-		match self{
-			MinkowskiEdge::VertEdge(v0,e1)=>MinkowskiDirectedEdge::VertEdge(v0,e1.as_directed(parity)),
-			MinkowskiEdge::EdgeVert(e0,v1)=>MinkowskiDirectedEdge::EdgeVert(e0.as_directed(parity),v1),
-		}
-	}
-}
-#[derive(Clone,Copy,Debug)]
-pub enum MinkowskiDirectedEdge{
-	VertEdge(SubmeshVertId,SubmeshDirectedEdgeId),
-	EdgeVert(SubmeshDirectedEdgeId,SubmeshVertId),
-	//EdgeEdge when edges are parallel
-}
-impl DirectedEdge for MinkowskiDirectedEdge{
-	type UndirectedEdge=MinkowskiEdge;
-	fn as_undirected(self)->Self::UndirectedEdge{
-		match self{
-			MinkowskiDirectedEdge::VertEdge(v0,e1)=>MinkowskiEdge::VertEdge(v0,e1.as_undirected()),
-			MinkowskiDirectedEdge::EdgeVert(e0,v1)=>MinkowskiEdge::EdgeVert(e0.as_undirected(),v1),
-		}
-	}
-	fn parity(&self)->bool{
-		match self{
-			MinkowskiDirectedEdge::VertEdge(_,e)
-			|MinkowskiDirectedEdge::EdgeVert(e,_)=>e.parity(),
-		}
-	}
-}
-#[derive(Clone,Copy,Debug,Hash)]
-pub enum MinkowskiFace{
-	VertFace(SubmeshVertId,SubmeshFaceId),
-	EdgeEdge(SubmeshEdgeId,SubmeshEdgeId,bool),
-	FaceVert(SubmeshFaceId,SubmeshVertId),
-	//EdgeFace
-	//FaceEdge
-	//FaceFace
-}
-
-#[derive(Debug)]
-pub struct MinkowskiMesh<'a>{
-	mesh0:TransformedMesh<'a>,
-	mesh1:TransformedMesh<'a>,
-}
-
 pub type GigaTime=Ratio<Fixed<4,128>,Fixed<4,128>>;
 pub fn into_giga_time(time:Time,relative_to:Time)->GigaTime{
 	let r=(time-relative_to).to_ratio();
 	Ratio::new(r.num.widen_4(),r.den.widen_4())
 }
-
-// TODO: remove this
-impl<'a> core::ops::Neg for &MinkowskiMesh<'a>{
-	type Output=MinkowskiMesh<'a>;
-	fn neg(self)->Self::Output{
-		MinkowskiMesh::minkowski_sum(self.mesh1,self.mesh0)
-	}
-}
-
-impl MinkowskiMesh<'_>{
-	pub fn minkowski_sum<'a>(mesh0:TransformedMesh<'a>,mesh1:TransformedMesh<'a>)->MinkowskiMesh<'a>{
-		MinkowskiMesh{
-			mesh0,
-			mesh1,
-		}
-	}
-	pub fn predict_collision_in(&self,trajectory:&Trajectory,range:impl RangeBounds<Time>)->Option<(MinkowskiFace,GigaTime)>{
-		let start_position=match range.start_bound(){
-			Bound::Included(time)=>trajectory.extrapolated_position(*time),
-			Bound::Excluded(time)=>trajectory.extrapolated_position(*time),
-			Bound::Unbounded=>trajectory.position,
-		};
-		let fev=crate::minimum_difference::closest_fev_not_inside(self,start_position)?;
-		//continue forwards along the body parabola
-		fev.crawl(self,trajectory,range.start_bound(),range.end_bound()).hit()
-	}
-	pub fn predict_collision_out(&self,trajectory:&Trajectory,range:impl RangeBounds<Time>)->Option<(MinkowskiFace,GigaTime)>{
-		let (lower_bound,upper_bound)=(range.start_bound(),range.end_bound());
-		// TODO: handle unbounded collision using infinity fev
-		let start_position=match upper_bound{
-			Bound::Included(time)=>trajectory.extrapolated_position(*time),
-			Bound::Excluded(time)=>trajectory.extrapolated_position(*time),
-			Bound::Unbounded=>trajectory.position,
-		};
-		let fev=crate::minimum_difference::closest_fev_not_inside(self,start_position)?;
-		// swap and negate bounds to do a time inversion
-		let (lower_bound,upper_bound)=(upper_bound.map(|&t|-t),lower_bound.map(|&t|-t));
-		let time_reversed_trajectory=-trajectory;
-		//continue backwards along the body parabola
-		fev.crawl(self,&time_reversed_trajectory,lower_bound.as_ref(),upper_bound.as_ref()).hit()
-			//no need to test -time<time_limit because of the first step
-			.map(|(face,time)|(face,-time))
-	}
-	pub fn predict_collision_face_out(&self,trajectory:&Trajectory,range:impl RangeBounds<Time>,contact_face_id:MinkowskiFace)->Option<(MinkowskiDirectedEdge,GigaTime)>{
-		// TODO: make better
-		use crate::face_crawler::{low,upp};
-		//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=range.start_bound().map(|&t|(t-trajectory.time).to_ratio());
-		let mut best_time=range.end_bound().map(|&t|into_giga_time(t,trajectory.time));
-		let mut best_edge=None;
-		let face_n=self.face_nd(contact_face_id).0;
-		for &directed_edge_id in self.face_edges(contact_face_id).as_ref(){
-			let edge_n=self.directed_edge_n(directed_edge_id);
-			//f x e points in
-			let n=face_n.cross(edge_n);
-			let &[v0,v1]=self.edge_verts(directed_edge_id.as_undirected()).as_ref();
-			let d=n.dot(self.vert(v0)+self.vert(v1));
-			//WARNING! d outside of *2
-			//WARNING: truncated precision
-			//wrap for speed
-			for dt in Fixed::<4,128>::zeroes2(((n.dot(trajectory.position))*2-d).wrap_4(),n.dot(trajectory.velocity).wrap_4()*2,n.dot(trajectory.acceleration).wrap_4()){
-				if low(&start_time,&dt)&&upp(&dt,&best_time)&&n.dot(trajectory.extrapolated_velocity_ratio_dt(dt)).is_negative(){
-					best_time=Bound::Included(dt);
-					best_edge=Some((directed_edge_id,dt));
-					break;
-				}
-			}
-		}
-		best_edge
-	}
-	pub fn contains_point(&self,point:Planar64Vec3)->bool{
-		crate::minimum_difference::contains_point(self,point)
-	}
-}
-impl MeshQuery for MinkowskiMesh<'_>{
-	type Face=MinkowskiFace;
-	type Edge=MinkowskiDirectedEdge;
-	type Vert=MinkowskiVert;
-	type Normal=Vector3<Fixed<3,96>>;
-	type Offset=Fixed<4,128>;
-	// TODO: relative d
-	fn face_nd(&self,face_id:MinkowskiFace)->(Self::Normal,Self::Offset){
-		match face_id{
-			MinkowskiFace::VertFace(v0,f1)=>{
-				let (n,d)=self.mesh1.face_nd(f1);
-				(-n,d-n.dot(self.mesh0.vert(v0)))
-			},
-			MinkowskiFace::EdgeEdge(e0,e1,parity)=>{
-				let edge0_n=self.mesh0.edge_n(e0);
-				let edge1_n=self.mesh1.edge_n(e1);
-				let &[e0v0,e0v1]=self.mesh0.edge_verts(e0).as_ref();
-				let &[e1v0,e1v1]=self.mesh1.edge_verts(e1).as_ref();
-				let n=edge0_n.cross(edge1_n);
-				let e0d=n.dot(self.mesh0.vert(e0v0)+self.mesh0.vert(e0v1));
-				let e1d=n.dot(self.mesh1.vert(e1v0)+self.mesh1.vert(e1v1));
-				((n*(parity as i64*4-2)).widen_3(),((e0d-e1d)*(parity as i64*2-1)).widen_4())
-			},
-			MinkowskiFace::FaceVert(f0,v1)=>{
-				let (n,d)=self.mesh0.face_nd(f0);
-				(n,d-n.dot(self.mesh1.vert(v1)))
-			},
-		}
-	}
-	fn vert(&self,vert_id:MinkowskiVert)->Planar64Vec3{
-		match vert_id{
-			MinkowskiVert::VertVert(v0,v1)=>{
-				self.mesh0.vert(v0)-self.mesh1.vert(v1)
-			},
-		}
-	}
-	fn hint_point(&self)->Planar64Vec3{
-		self.mesh0.transform.vertex.translation-self.mesh1.transform.vertex.translation
-	}
-	fn farthest_vert(&self,dir:Planar64Vec3)->MinkowskiVert{
-		MinkowskiVert::VertVert(self.mesh0.farthest_vert(dir),self.mesh1.farthest_vert(-dir))
-	}
-	fn face_edges(&self,face_id:MinkowskiFace)->impl AsRef<[MinkowskiDirectedEdge]>{
-		match face_id{
-			MinkowskiFace::VertFace(v0,f1)=>{
-				self.mesh1.face_edges(f1).as_ref().iter().map(|&edge_id1|
-					MinkowskiDirectedEdge::VertEdge(v0,edge_id1.reverse())
-				).collect()
-			},
-			MinkowskiFace::EdgeEdge(e0,e1,parity)=>{
-				let &[e0v0,e0v1]=self.mesh0.edge_verts(e0).as_ref();
-				let &[e1v0,e1v1]=self.mesh1.edge_verts(e1).as_ref();
-				//could sort this if ordered edges are needed
-				//probably just need to reverse this list according to parity
-				vec![
-					MinkowskiDirectedEdge::VertEdge(e0v0,e1.as_directed(parity)),
-					MinkowskiDirectedEdge::EdgeVert(e0.as_directed(!parity),e1v0),
-					MinkowskiDirectedEdge::VertEdge(e0v1,e1.as_directed(!parity)),
-					MinkowskiDirectedEdge::EdgeVert(e0.as_directed(parity),e1v1),
-				]
-			},
-			MinkowskiFace::FaceVert(f0,v1)=>{
-				self.mesh0.face_edges(f0).as_ref().iter().map(|&edge_id0|
-					MinkowskiDirectedEdge::EdgeVert(edge_id0,v1)
-				).collect()
-			},
-		}
-	}
-	fn edge_faces(&self,edge_id:MinkowskiEdge)->impl AsRef<[MinkowskiFace;2]>{
-		match edge_id{
-			MinkowskiEdge::VertEdge(v0,e1)=>{
-				//faces are listed backwards from the minkowski mesh
-				let v0e=self.mesh0.vert_edges(v0);
-				let &[e1f0,e1f1]=self.mesh1.edge_faces(e1).as_ref();
-				AsRefHelper([(e1f1,false),(e1f0,true)].map(|(edge_face_id1,face_parity)|{
-					let mut best_edge=None;
-					let mut best_d:Ratio<Fixed<8,256>,Fixed<8,256>>=Ratio::new(Fixed::ZERO,Fixed::ONE);
-					let edge_face1_n=self.mesh1.face_nd(edge_face_id1).0;
-					let edge_face1_nn=edge_face1_n.dot(edge_face1_n);
-					for &directed_edge_id0 in v0e.as_ref(){
-						let edge0_n=self.mesh0.directed_edge_n(directed_edge_id0);
-						//must be behind other face.
-						let d=edge_face1_n.dot(edge0_n);
-						if d.is_negative(){
-							let edge0_nn=edge0_n.dot(edge0_n);
-							// Assume not every number is huge
-							// TODO: revisit this
-							let dd=(d*d)/(edge_face1_nn*edge0_nn);
-							if best_d<dd{
-								best_d=dd;
-								best_edge=Some(directed_edge_id0);
-							}
-						}
-					}
-					best_edge.map_or(
-						MinkowskiFace::VertFace(v0,edge_face_id1),
-						|directed_edge_id0|MinkowskiFace::EdgeEdge(directed_edge_id0.as_undirected(),e1,directed_edge_id0.parity()^face_parity)
-					)
-				}))
-			},
-			MinkowskiEdge::EdgeVert(e0,v1)=>{
-				//tracking index with an external variable because .enumerate() is not available
-				let v1e=self.mesh1.vert_edges(v1);
-				let &[e0f0,e0f1]=self.mesh0.edge_faces(e0).as_ref();
-				AsRefHelper([(e0f0,true),(e0f1,false)].map(|(edge_face_id0,face_parity)|{
-					let mut best_edge=None;
-					let mut best_d:Ratio<Fixed<8,256>,Fixed<8,256>>=Ratio::new(Fixed::ZERO,Fixed::ONE);
-					let edge_face0_n=self.mesh0.face_nd(edge_face_id0).0;
-					let edge_face0_nn=edge_face0_n.dot(edge_face0_n);
-					for &directed_edge_id1 in v1e.as_ref(){
-						let edge1_n=self.mesh1.directed_edge_n(directed_edge_id1);
-						let d=edge_face0_n.dot(edge1_n);
-						if d.is_negative(){
-							let edge1_nn=edge1_n.dot(edge1_n);
-							let dd=(d*d)/(edge_face0_nn*edge1_nn);
-							if best_d<dd{
-								best_d=dd;
-								best_edge=Some(directed_edge_id1);
-							}
-						}
-					}
-					best_edge.map_or(
-						MinkowskiFace::FaceVert(edge_face_id0,v1),
-						|directed_edge_id1|MinkowskiFace::EdgeEdge(e0,directed_edge_id1.as_undirected(),directed_edge_id1.parity()^face_parity)
-					)
-				}))
-			},
-		}
-	}
-	fn edge_verts(&self,edge_id:MinkowskiEdge)->impl AsRef<[MinkowskiVert;2]>{
-		AsRefHelper(match edge_id{
-			MinkowskiEdge::VertEdge(v0,e1)=>self.mesh1.edge_verts(e1).as_ref().map(|vert_id1|
-				MinkowskiVert::VertVert(v0,vert_id1)
-			),
-			MinkowskiEdge::EdgeVert(e0,v1)=>self.mesh0.edge_verts(e0).as_ref().map(|vert_id0|
-				MinkowskiVert::VertVert(vert_id0,v1)
-			),
-		})
-	}
-	fn vert_edges(&self,vert_id:MinkowskiVert)->impl AsRef<[MinkowskiDirectedEdge]>{
-		match vert_id{
-			MinkowskiVert::VertVert(v0,v1)=>{
-				let mut edges=Vec::new();
-				//detect shared volume when the other mesh is mirrored along a test edge dir
-				let v0f_thing=self.mesh0.vert_faces(v0);
-				let v1f_thing=self.mesh1.vert_faces(v1);
-				let v0f=v0f_thing.as_ref();
-				let v1f=v1f_thing.as_ref();
-				let v0f_n:Vec<_>=v0f.iter().map(|&face_id|self.mesh0.face_nd(face_id).0).collect();
-				let v1f_n:Vec<_>=v1f.iter().map(|&face_id|self.mesh1.face_nd(face_id).0).collect();
-				// scratch vector
-				let mut face_normals=Vec::with_capacity(v0f.len()+v1f.len());
-				face_normals.clone_from(&v0f_n);
-				for &directed_edge_id in self.mesh0.vert_edges(v0).as_ref(){
-					let n=self.mesh0.directed_edge_n(directed_edge_id);
-					let nn=n.dot(n);
-					// TODO: there's gotta be a better way to do this
-					// drop faces beyond v0f_n
-					face_normals.truncate(v0f.len());
-					// make a set of faces from mesh0's perspective
-					for face_n in &v1f_n{
-						//add reflected mesh1 faces
-						//wrap for speed
-						face_normals.push(*face_n-(n*face_n.dot(n)*2/nn).divide().wrap_3());
-					}
-					if is_empty_volume(&face_normals){
-						edges.push(MinkowskiDirectedEdge::EdgeVert(directed_edge_id,v1));
-					}
-				}
-				face_normals.clone_from(&v1f_n);
-				for &directed_edge_id in self.mesh1.vert_edges(v1).as_ref(){
-					let n=self.mesh1.directed_edge_n(directed_edge_id);
-					let nn=n.dot(n);
-					// drop faces beyond v1f_n
-					face_normals.truncate(v1f.len());
-					// make a set of faces from mesh1's perspective
-					for face_n in &v0f_n{
-						//wrap for speed
-						face_normals.push(*face_n-(n*face_n.dot(n)*2/nn).divide().wrap_3());
-					}
-					if is_empty_volume(&face_normals){
-						edges.push(MinkowskiDirectedEdge::VertEdge(v0,directed_edge_id));
-					}
-				}
-				edges
-			},
-		}
-	}
-	fn vert_faces(&self,_vert_id:MinkowskiVert)->impl AsRef<[MinkowskiFace]>{
-		unimplemented!();
-		#[expect(unreachable_code)]
-		Vec::new()
-	}
-}
-
-fn is_empty_volume(normals:&[Vector3<Fixed<3,96>>])->bool{
-	let len=normals.len();
-	for i in 0..len-1{
-		for j in i+1..len{
-			let n=normals[i].cross(normals[j]);
-			let mut d_comp=None;
-			for k in 0..len{
-				if k!=i&&k!=j{
-					let d=n.dot(normals[k]).is_negative();
-					if let &Some(comp)=&d_comp{
-						// This is testing if d_comp*d < 0
-						if comp^d{
-							return true;
-						}
-					}else{
-						d_comp=Some(d);
-					}
-				}
-			}
-		}
-	}
-	return false;
-}
-
-#[test]
-fn test_is_empty_volume(){
-	assert!(!is_empty_volume(&[vec3::X.widen_3(),vec3::Y.widen_3(),vec3::Z.widen_3()]));
-	assert!(is_empty_volume(&[vec3::X.widen_3(),vec3::Y.widen_3(),vec3::Z.widen_3(),vec3::NEG_X.widen_3()]));
-}

engine/physics/src/physics.rs

@@ -1,5 +1,7 @@
 use std::collections::{HashMap,HashSet};
-use crate::model::{self as model_physics,PhysicsMesh,PhysicsMeshTransform,TransformedMesh,MeshQuery,PhysicsMeshId,PhysicsSubmeshId};
+use crate::mesh_query::MeshQuery;
+use crate::minkowski::{MinkowskiMesh,MinkowskiFace};
+use crate::model::{self as model_physics,PhysicsMesh,PhysicsMeshTransform,TransformedMesh,PhysicsMeshId,PhysicsSubmeshId};
 use strafesnet_common::bvh;
 use strafesnet_common::map;
 use strafesnet_common::run;
@@ -55,6 +57,9 @@ impl InputState{
 	fn replace_mouse(&mut self,mouse:MouseState,next_mouse:MouseState){
 		(self.next_mouse,self.mouse)=(next_mouse,mouse);
 	}
+	fn get_control(&self,control:Controls)->bool{
+		self.controls.contains(control)
+	}
 	fn set_control(&mut self,control:Controls,state:bool){
 		self.controls.set(control,state)
 	}
@@ -263,6 +268,12 @@ pub struct PhysicsCamera{
 impl PhysicsCamera{
 	const ANGLE_PITCH_LOWER_LIMIT:Angle32=Angle32::NEG_FRAC_PI_2;
 	const ANGLE_PITCH_UPPER_LIMIT:Angle32=Angle32::FRAC_PI_2;
+	fn set_sensitivity(&mut self,sensitivity:Ratio64Vec2){
+		// Calculate nearest mouse position in new sensitivity
+		self.clamped_mouse_pos.x=(self.clamped_mouse_pos.x as i128*self.sensitivity.x.num() as i128*sensitivity.x.den() as i128/(sensitivity.x.num() as i128*self.sensitivity.x.den() as i128)) as i32;
+		self.clamped_mouse_pos.y=(self.clamped_mouse_pos.y as i128*self.sensitivity.y.num() as i128*sensitivity.y.den() as i128/(sensitivity.y.num() as i128*self.sensitivity.y.den() as i128)) as i32;
+		self.sensitivity=sensitivity;
+	}
 	pub fn move_mouse(&mut self,mouse_delta:glam::IVec2){
 		let mut unclamped_mouse_pos=self.clamped_mouse_pos+mouse_delta;
 		unclamped_mouse_pos.y=unclamped_mouse_pos.y.clamp(
@@ -722,7 +733,7 @@ struct IntersectModel{
 #[derive(Debug,Clone,Copy,Hash)]
 pub struct ContactCollision{
 	convex_mesh_id:ConvexMeshId<ContactModelId>,
-	face_id:model_physics::MinkowskiFace,
+	face_id:MinkowskiFace,
 }
 #[derive(Debug,Clone,Copy,Eq,Hash,PartialEq)]
 pub struct IntersectCollision{
@@ -734,7 +745,7 @@ pub enum Collision{
 	Intersect(IntersectCollision),
 }
 impl Collision{
-	fn new(convex_mesh_id:ConvexMeshId<PhysicsModelId>,face_id:model_physics::MinkowskiFace)->Self{
+	fn new(convex_mesh_id:ConvexMeshId<PhysicsModelId>,face_id:MinkowskiFace)->Self{
 		match convex_mesh_id.model_id{
 			PhysicsModelId::Contact(model_id)=>Collision::Contact(ContactCollision{convex_mesh_id:convex_mesh_id.map(model_id),face_id}),
 			PhysicsModelId::Intersect(model_id)=>Collision::Intersect(IntersectCollision{convex_mesh_id:convex_mesh_id.map(model_id)}),
@@ -745,7 +756,7 @@ impl Collision{
 struct TouchingState{
 	// This is kind of jank, it's a ContactCollision
 	// but split over the Key and Value of the HashMap.
-	contacts:HashMap<ConvexMeshId<ContactModelId>,model_physics::MinkowskiFace>,
+	contacts:HashMap<ConvexMeshId<ContactModelId>,MinkowskiFace>,
 	intersects:HashSet<ConvexMeshId<IntersectModelId>>,
 }
 impl TouchingState{
@@ -753,13 +764,13 @@ impl TouchingState{
 		self.contacts.clear();
 		self.intersects.clear();
 	}
-	fn insert_contact(&mut self,contact:ContactCollision)->Option<model_physics::MinkowskiFace>{
+	fn insert_contact(&mut self,contact:ContactCollision)->Option<MinkowskiFace>{
 		self.contacts.insert(contact.convex_mesh_id,contact.face_id)
 	}
 	fn insert_intersect(&mut self,intersect:IntersectCollision)->bool{
 		self.intersects.insert(intersect.convex_mesh_id)
 	}
-	fn remove_contact(&mut self,convex_mesh_id:&ConvexMeshId<ContactModelId>)->Option<model_physics::MinkowskiFace>{
+	fn remove_contact(&mut self,convex_mesh_id:&ConvexMeshId<ContactModelId>)->Option<MinkowskiFace>{
 		self.contacts.remove(convex_mesh_id)
 	}
 	fn remove_intersect(&mut self,convex_mesh_id:&ConvexMeshId<IntersectModelId>)->bool{
@@ -823,7 +834,7 @@ impl TouchingState{
 		for (convex_mesh_id,face_id) in &self.contacts{
 			//detect face slide off
 			let model_mesh=models.contact_mesh(convex_mesh_id);
-			let minkowski=model_physics::MinkowskiMesh::minkowski_sum(model_mesh,hitbox_mesh.transformed_mesh());
+			let minkowski=MinkowskiMesh::minkowski_sum(model_mesh,hitbox_mesh.transformed_mesh());
 			collector.collect(minkowski.predict_collision_face_out(&trajectory,start_time..collector.time(),*face_id).map(|(_face,time)|{
 				TimedInstruction{
 					time:trajectory.time+time.into(),
@@ -837,7 +848,7 @@ impl TouchingState{
 		for convex_mesh_id in &self.intersects{
 			//detect model collision in reverse
 			let model_mesh=models.intersect_mesh(convex_mesh_id);
-			let minkowski=model_physics::MinkowskiMesh::minkowski_sum(model_mesh,hitbox_mesh.transformed_mesh());
+			let minkowski=MinkowskiMesh::minkowski_sum(model_mesh,hitbox_mesh.transformed_mesh());
 			collector.collect(minkowski.predict_collision_out(&trajectory,start_time..collector.time()).map(|(_face,time)|{
 				TimedInstruction{
 					time:trajectory.time+time.into(),
@@ -920,6 +931,9 @@ impl PhysicsState{
 	pub fn get_finish_time(&self)->Option<run::Time>{
 		self.run.get_finish_time()
 	}
+	fn is_no_clip_enabled(&self)->bool{
+		self.input_state.get_control(Controls::Sprint)
+	}
 	pub fn clear(&mut self){
 		self.touching.clear();
 	}
@@ -1193,6 +1207,11 @@ fn next_instruction_internal(state:&PhysicsState,data:&PhysicsData,time_limit:Ti
 	let trajectory=state.body.with_acceleration(state.acceleration(data));
 	//check for collision ends
 	state.touching.predict_collision_end(&mut collector,&data.models,&data.hitbox_mesh,&trajectory,state.time);
+
+	if state.is_no_clip_enabled(){
+		return collector.take();
+	}
+
 	//check for collision starts
 	let mut aabb=aabb::Aabb::default();
 	trajectory.grow_aabb(&mut aabb,state.time,collector.time());
@@ -1205,7 +1224,7 @@ fn next_instruction_internal(state:&PhysicsState,data:&PhysicsData,time_limit:Ti
 		}
 		//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());
+		let minkowski=MinkowskiMesh::minkowski_sum(model_mesh,data.hitbox_mesh.transformed_mesh());
 		collector.collect(minkowski.predict_collision_in(&trajectory,state.time..collector.time())
 			.map(|(face,dt)|
 				TimedInstruction{
@@ -1226,10 +1245,10 @@ fn contact_normal(
 	models:&PhysicsModels,
 	hitbox_mesh:&HitboxMesh,
 	convex_mesh_id:&ConvexMeshId<ContactModelId>,
-    face_id:model_physics::MinkowskiFace,
+    face_id:MinkowskiFace,
 )->Planar64Vec3{
 	let model_mesh=models.contact_mesh(convex_mesh_id);
-	let minkowski=model_physics::MinkowskiMesh::minkowski_sum(model_mesh,hitbox_mesh.transformed_mesh());
+	let minkowski=MinkowskiMesh::minkowski_sum(model_mesh,hitbox_mesh.transformed_mesh());
 	// TODO: normalize to i64::MAX>>1
 	// wrap for speed
 	minkowski.face_nd(face_id).0.wrap_1()
@@ -1268,7 +1287,7 @@ fn recalculate_touching(
 	bvh.sample_aabb(&aabb,&mut |&convex_mesh_id|{
 		//no checks are needed because of the time limits.
 		let model_mesh=models.mesh(convex_mesh_id);
-		let minkowski=model_physics::MinkowskiMesh::minkowski_sum(model_mesh,hitbox_mesh.transformed_mesh());
+		let minkowski=MinkowskiMesh::minkowski_sum(model_mesh,hitbox_mesh.transformed_mesh());
 		if minkowski.contains_point(body.position){
 			match convex_mesh_id.model_id{
 				//being inside of contact objects is an invalid physics state
@@ -1860,10 +1879,11 @@ fn atomic_input_instruction(state:&mut PhysicsState,data:&PhysicsData,ins:TimedI
 			state.input_state.set_next_mouse(m);
 		},
 		Instruction::Mouse(MouseInstruction::ReplaceMouse{m0,m1})=>{
-			state.camera.move_mouse(m0.pos-state.input_state.mouse.pos);
+			state.camera.move_mouse(state.input_state.mouse_delta());
+			state.camera.move_mouse(m0.pos-state.input_state.next_mouse.pos);
 			state.input_state.replace_mouse(m0,m1);
 		},
-		Instruction::Misc(MiscInstruction::SetSensitivity(sensitivity))=>state.camera.sensitivity=sensitivity,
+		Instruction::Misc(MiscInstruction::SetSensitivity(sensitivity))=>state.camera.set_sensitivity(sensitivity),
 		Instruction::SetControl(SetControlInstruction::SetMoveForward(s))=>state.input_state.set_control(Controls::MoveForward,s),
 		Instruction::SetControl(SetControlInstruction::SetMoveLeft(s))=>state.input_state.set_control(Controls::MoveLeft,s),
 		Instruction::SetControl(SetControlInstruction::SetMoveBack(s))=>state.input_state.set_control(Controls::MoveBackward,s),
@@ -1964,7 +1984,7 @@ mod test{
 		let h1=StyleModifiers::roblox_bhop().calculate_mesh();
 		let hitbox_mesh=h1.transformed_mesh();
 		let platform_mesh=h0.transformed_mesh();
-		let minkowski=model_physics::MinkowskiMesh::minkowski_sum(platform_mesh,hitbox_mesh);
+		let minkowski=MinkowskiMesh::minkowski_sum(platform_mesh,hitbox_mesh);
 		let collision=minkowski.predict_collision_in(&relative_body,..);
 		assert_eq!(collision.map(|tup|relative_body.time+tup.1.into()),expected_collision_time,"Incorrect time of collision");
 	}
@@ -1982,7 +2002,7 @@ mod test{
 		let h1=StyleModifiers::roblox_bhop().calculate_mesh();
 		let hitbox_mesh=h1.transformed_mesh();
 		let platform_mesh=h0.transformed_mesh();
-		let minkowski=model_physics::MinkowskiMesh::minkowski_sum(platform_mesh,hitbox_mesh);
+		let minkowski=MinkowskiMesh::minkowski_sum(platform_mesh,hitbox_mesh);
 		let collision=minkowski.predict_collision_in(&relative_body,..);
 		assert_eq!(collision.map(|tup|relative_body.time+tup.1.into()),expected_collision_time,"Incorrect time of collision");
 	}

engine/session/Cargo.toml

@@ -4,12 +4,12 @@ version = "0.1.0"
 edition = "2024"
 
 [dependencies]
-glam = "0.30.0"
+glam.workspace = true
 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" }
+strafesnet_common.workspace = true
+strafesnet_physics.workspace = true
+strafesnet_settings.workspace = true
+strafesnet_snf.workspace = true
 
 [lints]
 workspace = true

engine/session/src/session.rs

@@ -61,6 +61,14 @@ pub struct FrameState{
 	pub camera:physics::PhysicsCamera,
 	pub time:PhysicsTime,
 }
+impl FrameState{
+	pub fn pos(&self)->glam::Vec3{
+		self.trajectory.extrapolated_position(self.time).map(Into::<f32>::into).to_array().into()
+	}
+	pub fn angles(&self)->glam::Vec2{
+		self.camera.simulate_move_angles(glam::IVec2::ZERO)
+	}
+}
 
 pub struct Simulation{
 	timer:Timer<Scaled<SessionTimeInner,PhysicsTimeInner>>,

engine/settings/Cargo.toml

@@ -6,8 +6,8 @@ edition = "2024"
 [dependencies]
 configparser = "3.0.2"
 directories = "6.0.0"
-glam = "0.30.0"
-strafesnet_common = { path = "../../lib/common", registry = "strafesnet" }
+glam.workspace = true
+strafesnet_common.workspace = true
 
 [lints]
 workspace = true

integration-testing/Cargo.toml

@@ -4,12 +4,12 @@ version = "0.1.0"
 edition = "2024"
 
 [dependencies]
-glam = "0.30.0"
-strafesnet_common = { path = "../lib/common", registry = "strafesnet" }
-strafesnet_physics = { path = "../engine/physics", registry = "strafesnet" }
-strafesnet_snf = { path = "../lib/snf", registry = "strafesnet" }
+glam.workspace = true
+strafesnet_common.workspace = true
+strafesnet_physics.workspace = true
+strafesnet_snf.workspace = true
 # this is just for the primitive constructor
-strafesnet_rbx_loader = { path = "../lib/rbx_loader", registry = "strafesnet" }
+strafesnet_rbx_loader.workspace = true
 
 [lints]
 workspace = true

lib/bsp_loader/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "strafesnet_bsp_loader"
-version = "0.3.1"
+version = "0.4.0"
 edition = "2024"
 repository = "https://git.itzana.me/StrafesNET/strafe-project"
 license = "MIT OR Apache-2.0"
@@ -10,9 +10,9 @@ authors = ["Rhys Lloyd <krakow20@gmail.com>"]
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-glam = "0.30.0"
-strafesnet_common = { version = "0.7.0", path = "../common", registry = "strafesnet" }
-strafesnet_deferred_loader = { version = "0.5.1", path = "../deferred_loader", registry = "strafesnet" }
+glam.workspace = true
+strafesnet_common.workspace = true
+strafesnet_deferred_loader.workspace = true
 vbsp = "0.9.1"
 vbsp-entities-css = "0.6.0"
 vmdl = "0.2.0"

lib/bsp_loader/src/lib.rs

@@ -1,9 +1,9 @@
 use strafesnet_deferred_loader::deferred_loader::{LoadFailureMode,MeshDeferredLoader,RenderConfigDeferredLoader};
+use strafesnet_deferred_loader::loader::Loader;
 
 mod bsp;
 mod mesh;
 mod brush;
-pub mod loader;
 
 const VALVE_SCALE:f32=1.0/16.0;
 pub(crate) fn valve_transform_dist(d:f32)->strafesnet_common::integer::Planar64{
@@ -30,26 +30,25 @@ impl std::error::Error for ReadError{}
 
 
 #[derive(Debug)]
-pub enum LoadError{
-	Texture(loader::TextureError),
-	Mesh(loader::MeshError),
+pub enum LoadError<M,T>{
+	Mesh(M),
+	Texture(T),
 }
-impl std::fmt::Display for LoadError{
+impl<M,T> std::fmt::Display for LoadError<M,T>
+	where
+		M:std::fmt::Debug,
+		T:std::fmt::Debug,
+{
 	fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
 		write!(f,"{self:?}")
 	}
 }
-impl std::error::Error for LoadError{}
-impl From<loader::TextureError> for LoadError{
-	fn from(value:loader::TextureError)->Self{
-		Self::Texture(value)
-	}
-}
-impl From<loader::MeshError> for LoadError{
-	fn from(value:loader::MeshError)->Self{
-		Self::Mesh(value)
-	}
-}
+impl<M,T> std::error::Error for LoadError<M,T>
+where
+		M:std::fmt::Debug,
+		T:std::fmt::Debug,
+{}
+
 pub struct Bsp{
 	bsp:vbsp::Bsp,
 	case_folded_file_names:std::collections::HashMap<String,String>,
@@ -84,7 +83,17 @@ impl Bsp{
 			None=>Ok(None),
 		}
 	}
-	pub fn to_snf(&self,failure_mode:LoadFailureMode,vpk_list:&[Vpk])->Result<strafesnet_common::map::CompleteMap,LoadError>{
+	pub fn to_snf<'dom,'mesh,'texture,M,T>(
+		&'dom self,
+		failure_mode:LoadFailureMode,
+		mut mesh_loader:M,
+		mut texture_loader:T,
+	)->Result<strafesnet_common::map::CompleteMap,LoadError<M::Error,T::Error>>
+		where
+			'dom:'mesh+'texture,
+			M:Loader<Resource=strafesnet_common::model::Mesh,Index<'mesh>=&'mesh str>+'mesh,
+			T:Loader<Resource=strafesnet_deferred_loader::texture::Texture,Index<'texture>=std::borrow::Cow<'texture,str>>+'texture,
+	{
 		let mut texture_deferred_loader=RenderConfigDeferredLoader::new();
 		let mut mesh_deferred_loader=MeshDeferredLoader::new();
 
@@ -94,12 +103,10 @@ impl Bsp{
 			&mut mesh_deferred_loader,
 		);
 
-		let mut mesh_loader=loader::MeshLoader::new(loader::BspFinder{bsp:self,vpks:vpk_list},&mut texture_deferred_loader);
 		let prop_meshes=mesh_deferred_loader.into_meshes(&mut mesh_loader,failure_mode).map_err(LoadError::Mesh)?;
 
 		let map_step2=map_step1.add_prop_meshes(prop_meshes);
 
-		let mut texture_loader=loader::TextureLoader::new();
 		let render_configs=texture_deferred_loader.into_render_configs(&mut texture_loader,failure_mode).map_err(LoadError::Texture)?;
 
 		let map=map_step2.add_render_configs_and_textures(render_configs);

lib/common/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "strafesnet_common"
-version = "0.7.0"
+version = "0.8.6"
 edition = "2024"
 repository = "https://git.itzana.me/StrafesNET/strafe-project"
 license = "MIT OR Apache-2.0"
@@ -12,10 +12,10 @@ authors = ["Rhys Lloyd <krakow20@gmail.com>"]
 [dependencies]
 arrayvec = "0.7.4"
 bitflags = "2.6.0"
-fixed_wide = { version = "0.2.0", path = "../fixed_wide", registry = "strafesnet", features = ["deferred-division","zeroes","wide-mul"] }
-linear_ops = { version = "0.1.1", path = "../linear_ops", registry = "strafesnet", features = ["deferred-division","named-fields"] }
-ratio_ops = { version = "0.1.0", path = "../ratio_ops", registry = "strafesnet" }
-glam = "0.30.0"
+fixed_wide = { workspace = true, features = ["deferred-division","zeroes","wide-mul"] }
+linear_ops = { workspace = true, features = ["deferred-division","named-fields"] }
+ratio_ops = { workspace = true }
+glam.workspace = true
 id = { version = "0.1.0", registry = "strafesnet" }
 
 [lints]

lib/common/src/integer.rs

@@ -56,6 +56,14 @@ impl<T> Time<T>{
 	pub const fn coerce<U>(self)->Time<U>{
 		Time::raw(self.0)
 	}
+	#[inline]
+	pub const fn div_euclid(self,other:Self)->Self{
+		Time::raw(self.0.div_euclid(other.0))
+	}
+	#[inline]
+	pub const fn rem_euclid(self,other:Self)->Self{
+		Time::raw(self.0.rem_euclid(other.0))
+	}
 }
 impl<T> From<Planar64> for Time<T>{
 	#[inline]
@@ -149,10 +157,23 @@ impl_time_i64_rhs_operator!(Shr,shr);
 impl_time_i64_rhs_operator!(Shl,shl);
 impl<T> core::ops::Mul<Time<T>> for Planar64{
 	type Output=Ratio<Fixed<2,64>,Planar64>;
+	#[inline]
 	fn mul(self,rhs:Time<T>)->Self::Output{
 		Ratio::new(self*Fixed::raw(rhs.0),Planar64::raw(1_000_000_000))
 	}
 }
+impl<T> From<Time<T>> for f32{
+	#[inline]
+	fn from(value:Time<T>)->Self{
+		value.get() as f32/Time::<T>::ONE_SECOND.get() as f32
+	}
+}
+impl<T> From<Time<T>> for f64{
+	#[inline]
+	fn from(value:Time<T>)->Self{
+		value.get() as f64/Time::<T>::ONE_SECOND.get() as f64
+	}
+}
 #[cfg(test)]
 mod test_time{
 	use super::*;
@@ -214,11 +235,11 @@ impl Ratio64{
 	}
 	#[inline]
 	pub const fn mul_int(&self,rhs:i64)->i64{
-		rhs*self.num/(self.den as i64)
+		(rhs as i128*self.num as i128/self.den as i128) as i64
 	}
 	#[inline]
 	pub const fn rhs_div_int(&self,rhs:i64)->i64{
-		rhs*(self.den as i64)/self.num
+		(rhs as i128*self.den as i128/self.num as i128) as i64
 	}
 	#[inline]
 	pub const fn mul_ref(&self,rhs:&Ratio64)->Ratio64{
@@ -263,7 +284,6 @@ fn integer_decode_f64(f: f64) -> (u64, i16, i8) {
 pub enum Ratio64TryFromFloatError{
 	Nan,
 	Infinite,
-	Subnormal,
 	HighlyNegativeExponent(i16),
 	HighlyPositiveExponent(i16),
 }
@@ -298,8 +318,10 @@ fn ratio64_from_mes((m,e,s):(u64,i16,i8))->Result<Ratio64,Ratio64TryFromFloatErr
 
 		Ok(Ratio64::new(num as i64,den as u64).unwrap())
 	}else if e<0{
+		// simple exact representation
 		Ok(Ratio64::new((m as i64)*(s as i64),1<<-e).unwrap())
 	}else if (64-m.leading_zeros() as i16)+e<64{
+		// integer
 		Ok(Ratio64::new((m as i64)*(s as i64)*(1<<e),1).unwrap())
 	}else{
 		Err(Ratio64TryFromFloatError::HighlyPositiveExponent(e))
@@ -331,6 +353,29 @@ impl TryFrom<f64> for Ratio64{
 		}
 	}
 }
+#[cfg(test)]
+fn req(r0:Ratio64,r1:Ratio64){
+	println!("r0={r0:?} r1={r1:?}");
+	assert_eq!(r0.num(),r1.num(),"Nums not eq");
+	assert_eq!(r0.den(),r1.den(),"Dens not eq");
+}
+#[test]
+fn test_ratio64_from_float(){
+	req(2.0.try_into().unwrap(),Ratio64::new(2,1).unwrap());
+	req(1.0.try_into().unwrap(),Ratio64::new(1,1).unwrap());
+	req(0.5.try_into().unwrap(),Ratio64::new(1,2).unwrap());
+	req(1.1.try_into().unwrap(),Ratio64::new(2476979795053773,2251799813685248).unwrap());
+	req(0.8.try_into().unwrap(),Ratio64::new(3602879701896397,4503599627370496).unwrap());
+	req(0.61.try_into().unwrap(),Ratio64::new(5494391545392005,9007199254740992).unwrap());
+	req(0.01.try_into().unwrap(),Ratio64::new(5764607523034235,576460752303423488).unwrap());
+	req(0.001.try_into().unwrap(),Ratio64::new(1152921504606847,1152921504606846976).unwrap());
+	req(0.00001.try_into().unwrap(),Ratio64::new(89605456633725,8960545663372499267).unwrap());
+	req(0.00000000001.try_into().unwrap(),Ratio64::new(35204848,3520484800000000213).unwrap());
+	req(0.000000000000000001.try_into().unwrap(),Ratio64::new(11,10999999999999999213).unwrap());
+	req(2222222222222.0.try_into().unwrap(),Ratio64::new(2222222222222,1).unwrap());
+	req(core::f64::consts::PI.try_into().unwrap(),Ratio64::new(884279719003555,281474976710656).unwrap());
+}
+
 impl std::ops::Mul<Ratio64> for Ratio64{
 	type Output=Ratio64;
 	#[inline]

lib/common/src/run.rs

@@ -53,36 +53,23 @@ impl std::fmt::Display for Error{
 impl std::error::Error for Error{}
 
 #[derive(Clone,Copy,Debug)]
-enum RunState{
+pub enum RunState{
 	Created,
 	Started{timer:TimerFixed<Realtime<PhysicsTimeInner,TimeInner>,Unpaused>},
 	Finished{timer:TimerFixed<Realtime<PhysicsTimeInner,TimeInner>,Paused>},
 }
-
-#[derive(Clone,Copy,Debug)]
-pub struct Run{
-	state:RunState,
-	flagged:Option<FlagReason>,
-}
-
-impl Run{
-	pub fn new()->Self{
-		Self{
-			state:RunState::Created,
-			flagged:None,
-		}
-	}
+impl RunState{
 	pub fn time(&self,time:PhysicsTime)->Time{
-		match &self.state{
+		match &self{
 			RunState::Created=>Time::ZERO,
 			RunState::Started{timer}=>timer.time(time),
 			RunState::Finished{timer}=>timer.time(),
 		}
 	}
 	pub fn start(&mut self,time:PhysicsTime)->Result<(),Error>{
-		match &self.state{
+		match &self{
 			RunState::Created=>{
-				self.state=RunState::Started{
+				*self=RunState::Started{
 					timer:TimerFixed::new(time,Time::ZERO),
 				};
 				Ok(())
@@ -93,10 +80,10 @@ impl Run{
 	}
 	pub fn finish(&mut self,time:PhysicsTime)->Result<(),Error>{
 		//this uses Copy
-		match &self.state{
+		match &self{
 			RunState::Created=>Err(Error::NotStarted),
 			RunState::Started{timer}=>{
-				self.state=RunState::Finished{
+				*self=RunState::Finished{
 					timer:timer.into_paused(time),
 				};
 				Ok(())
@@ -104,12 +91,39 @@ impl Run{
 			RunState::Finished{..}=>Err(Error::AlreadyFinished),
 		}
 	}
+}
+
+#[derive(Clone,Copy,Debug)]
+pub struct Run{
+	state:RunState,
+	flag_reason:Option<FlagReason>,
+}
+
+impl Run{
+	pub fn new()->Self{
+		Self{
+			state:RunState::Created,
+			flag_reason:None,
+		}
+	}
+	pub fn time(&self,time:PhysicsTime)->Time{
+		self.state.time(time)
+	}
+	pub fn start(&mut self,time:PhysicsTime)->Result<(),Error>{
+		self.state.start(time)
+	}
+	pub fn finish(&mut self,time:PhysicsTime)->Result<(),Error>{
+		self.state.finish(time)
+	}
 	pub fn flag(&mut self,flag_reason:FlagReason){
 		//don't replace the first reason the run was flagged
-		if self.flagged.is_none(){
-			self.flagged=Some(flag_reason);
+		if self.flag_reason.is_none(){
+			self.flag_reason=Some(flag_reason);
 		}
 	}
+	pub fn flag_reason(&self)->Option<FlagReason>{
+		self.flag_reason
+	}
 	pub fn get_finish_time(&self)->Option<Time>{
 		match &self.state{
 			RunState::Finished{timer}=>Some(timer.time()),

lib/common/src/timer.rs

@@ -69,10 +69,8 @@ impl<In,Out> Scaled<In,Out>
 	const fn get_scale(&self)->Ratio64{
 		self.scale
 	}
-	fn set_scale(&mut self,time:Time<In>,new_scale:Ratio64){
-		let new_time=self.get_time(time);
+	const fn set_scale(&mut self,new_scale:Ratio64){
 		self.scale=new_scale;
-		self.set_time(time,new_time);
 	}
 }
 
@@ -132,7 +130,7 @@ pub struct TimerFixed<T:TimerState,P:PauseState>{
 	_paused:P,
 }
 
-//scaled timer methods are generic across PauseState
+//some scaled timer methods are generic across PauseState
 impl<P:PauseState,In,Out> TimerFixed<Scaled<In,Out>,P>
 	where Time<In>:Copy,
 {
@@ -147,8 +145,22 @@ impl<P:PauseState,In,Out> TimerFixed<Scaled<In,Out>,P>
 	pub const fn get_scale(&self)->Ratio64{
 		self.state.get_scale()
 	}
+}
+// setting the scale of an unpaused timer is different than a paused timer
+impl<In,Out> TimerFixed<Scaled<In,Out>,Unpaused>
+	where Time<In>:Copy,
+{
 	pub fn set_scale(&mut self,time:Time<In>,new_scale:Ratio64){
-		self.state.set_scale(time,new_scale)
+		let new_time=self.state.get_time(time);
+		self.state.set_scale(new_scale);
+		self.state.set_time(time,new_time);
+	}
+}
+impl<In,Out> TimerFixed<Scaled<In,Out>,Paused>
+	where Time<In>:Copy,
+{
+	pub fn set_scale(&mut self,new_scale:Ratio64){
+		self.state.set_scale(new_scale);
 	}
 }
 
@@ -305,7 +317,7 @@ impl<In,Out> Timer<Scaled<In,Out>>
 	}
 	pub fn set_scale(&mut self,time:Time<In>,new_scale:Ratio64){
 		match self{
-			Self::Paused(timer)=>timer.set_scale(time,new_scale),
+			Self::Paused(timer)=>timer.set_scale(new_scale),
 			Self::Unpaused(timer)=>timer.set_scale(time,new_scale),
 		}
 	}

lib/deferred_loader/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "strafesnet_deferred_loader"
-version = "0.5.1"
+version = "0.6.0"
 edition = "2024"
 repository = "https://git.itzana.me/StrafesNET/strafe-project"
 license = "MIT OR Apache-2.0"
@@ -10,7 +10,7 @@ authors = ["Rhys Lloyd <krakow20@gmail.com>"]
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-strafesnet_common = { version = "0.7.0", path = "../common", registry = "strafesnet" }
+strafesnet_common.workspace = true
 
 [lints]
 workspace = true

lib/fixed_wide/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "fixed_wide"
-version = "0.2.1"
+version = "0.2.2"
 edition = "2024"
 repository = "https://git.itzana.me/StrafesNET/strafe-project"
 license = "MIT OR Apache-2.0"
@@ -17,7 +17,7 @@ zeroes=["dep:arrayvec"]
 bnum = "0.13.0"
 arrayvec = { version = "0.7.6", optional = true }
 paste = "1.0.15"
-ratio_ops = { version = "0.1.0", path = "../ratio_ops", registry = "strafesnet", optional = true }
+ratio_ops = { workspace = true, optional = true }
 
 [lints]
 workspace = true

lib/fixed_wide/src/fixed.rs

@@ -7,7 +7,7 @@ const BNUM_DIGIT_WIDTH:usize=64;
 /// N is the number of u64s to use
 /// F is the number of fractional bits (always N*32 lol)
 pub struct Fixed<const N:usize,const F:usize>{
-	pub(crate)bits:BInt<{N}>,
+	bits:BInt<{N}>,
 }
 
 impl<const N:usize,const F:usize> Fixed<N,F>{
@@ -545,7 +545,7 @@ impl_shift_operator!( Fixed, Shr, shr, Self );
 
 // wide operators.  The result width is the sum of the input widths, i.e. none of the multiplication
 
-#[expect(unused_macros)]
+#[allow(unused_macros)]
 macro_rules! impl_wide_operators{
 	($lhs:expr,$rhs:expr)=>{
 		impl core::ops::Mul<Fixed<$rhs,{$rhs*32}>> for Fixed<$lhs,{$lhs*32}>{

lib/linear_ops/Cargo.toml

@@ -14,12 +14,12 @@ fixed-wide=["dep:fixed_wide","dep:paste"]
 deferred-division=["dep:ratio_ops"]
 
 [dependencies]
-ratio_ops = { version = "0.1.0", path = "../ratio_ops", registry = "strafesnet", optional = true }
-fixed_wide = { version = "0.2.0", path = "../fixed_wide", registry = "strafesnet", optional = true }
+ratio_ops = { workspace = true, optional = true }
+fixed_wide = { workspace = true, optional = true }
 paste = { version = "1.0.15", optional = true }
 
 [dev-dependencies]
-fixed_wide = { path = "../fixed_wide", registry = "strafesnet", features = ["wide-mul"] }
+fixed_wide = { workspace = true, features = ["wide-mul"] }
 
 [lints]
 workspace = true

lib/rbx_loader/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "strafesnet_rbx_loader"
-version = "0.7.0"
+version = "0.8.0"
 edition = "2024"
 repository = "https://git.itzana.me/StrafesNET/strafe-project"
 license = "MIT OR Apache-2.0"
@@ -11,13 +11,13 @@ authors = ["Rhys Lloyd <krakow20@gmail.com>"]
 
 [dependencies]
 bytemuck = "1.14.3"
-glam = "0.30.0"
+glam.workspace = true
 regex = { version = "1.11.3", default-features = false, features = ["unicode-perl"] }
 rbx_mesh = "0.5.0"
 rbxassetid = { version = "0.1.0", path = "../rbxassetid", registry = "strafesnet" }
 roblox_emulator = { version = "0.5.1", path = "../roblox_emulator", default-features = false, registry = "strafesnet" }
-strafesnet_common = { version = "0.7.0", path = "../common", registry = "strafesnet" }
-strafesnet_deferred_loader = { version = "0.5.1", path = "../deferred_loader", registry = "strafesnet" }
+strafesnet_common.workspace = true
+strafesnet_deferred_loader.workspace = true
 rbx_binary = "2.0.1"
 rbx_dom_weak = "4.1.0"
 rbx_reflection = "6.1.0"

lib/rbx_loader/src/lib.rs

@@ -1,17 +1,19 @@
-use std::io::Read;
 use rbx_dom_weak::WeakDom;
 use roblox_emulator::context::Context;
 use strafesnet_common::map::CompleteMap;
 use strafesnet_deferred_loader::deferred_loader::{LoadFailureMode,MeshDeferredLoader,RenderConfigDeferredLoader};
+use strafesnet_deferred_loader::loader::Loader;
+use strafesnet_deferred_loader::texture::Texture;
 
 pub use error::RecoverableErrors;
 pub use roblox_emulator::runner::Error as RunnerError;
 
+use crate::loader::{MeshIndex,MeshWithSize};
+
 mod rbx;
 mod mesh;
 mod error;
 mod union;
-pub mod loader;
 pub mod primitives;
 
 pub mod data{
@@ -30,11 +32,21 @@ pub struct Model{
 	dom:WeakDom,
 }
 impl Model{
-	fn new(dom:WeakDom)->Self{
+	pub fn new(dom:WeakDom)->Self{
 		Self{dom}
 	}
-	pub fn to_snf(&self,failure_mode:LoadFailureMode)->Result<(CompleteMap,RecoverableErrors),LoadError>{
-		to_snf(self,failure_mode)
+	pub fn to_snf<'dom,'mesh,'texture,M,T>(
+		&'dom self,
+		failure_mode:LoadFailureMode,
+		mesh_loader:M,
+		texture_loader:T,
+	)->Result<(CompleteMap,RecoverableErrors),LoadError<M::Error,T::Error>>
+		where
+			'dom:'mesh+'texture,
+			M:Loader<Resource=MeshWithSize,Index<'mesh>=MeshIndex<'mesh>>+'mesh,
+			T:Loader<Resource=Texture,Index<'texture>=&'texture str>+'texture,
+	{
+		to_snf(self.as_ref(),failure_mode,mesh_loader,texture_loader)
 	}
 }
 impl AsRef<WeakDom> for Model{
@@ -66,8 +78,18 @@ impl Place{
 		}
 		Ok(errors)
 	}
-	pub fn to_snf(&self,failure_mode:LoadFailureMode)->Result<(CompleteMap,RecoverableErrors),LoadError>{
-		to_snf(self,failure_mode)
+	pub fn to_snf<'dom,'mesh,'texture,M,T>(
+		&'dom self,
+		failure_mode:LoadFailureMode,
+		mesh_loader:M,
+		texture_loader:T,
+	)->Result<(CompleteMap,RecoverableErrors),LoadError<M::Error,T::Error>>
+		where
+			'dom:'mesh+'texture,
+			M:Loader<Resource=MeshWithSize,Index<'mesh>=MeshIndex<'mesh>>+'mesh,
+			T:Loader<Resource=Texture,Index<'texture>=&'texture str>+'texture,
+	{
+		to_snf(self.as_ref(),failure_mode,mesh_loader,texture_loader)
 	}
 }
 impl AsRef<WeakDom> for Place{
@@ -85,54 +107,36 @@ impl From<Model> for Place{
 }
 
 #[derive(Debug)]
-pub enum ReadError{
-	RbxBinary(rbx_binary::DecodeError),
-	RbxXml(rbx_xml::DecodeError),
-	Io(std::io::Error),
-	UnknownFileFormat,
+pub enum LoadError<M,T>{
+	Mesh(M),
+	Texture(T),
 }
-impl std::fmt::Display for ReadError{
+impl<M,T> std::fmt::Display for LoadError<M,T>
+	where
+		M:std::fmt::Debug,
+		T:std::fmt::Debug,
+{
 	fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
 		write!(f,"{self:?}")
 	}
 }
-impl std::error::Error for ReadError{}
-
-pub fn read<R:Read>(input:R)->Result<Model,ReadError>{
-	let mut buf=std::io::BufReader::new(input);
-	let peek=std::io::BufRead::fill_buf(&mut buf).map_err(ReadError::Io)?;
-	match peek.get(0..8){
-		Some(b"<roblox!")=>rbx_binary::from_reader(buf).map(Model::new).map_err(ReadError::RbxBinary),
-		Some(b"<roblox ")=>rbx_xml::from_reader_default(buf).map(Model::new).map_err(ReadError::RbxXml),
-		_=>Err(ReadError::UnknownFileFormat),
-	}
-}
-
-#[derive(Debug)]
-pub enum LoadError{
-	Texture(loader::TextureError),
-	Mesh(loader::MeshError),
-}
-impl std::fmt::Display for LoadError{
-	fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
-		write!(f,"{self:?}")
-	}
-}
-impl std::error::Error for LoadError{}
-impl From<loader::TextureError> for LoadError{
-	fn from(value:loader::TextureError)->Self{
-		Self::Texture(value)
-	}
-}
-impl From<loader::MeshError> for LoadError{
-	fn from(value:loader::MeshError)->Self{
-		Self::Mesh(value)
-	}
-}
-
-fn to_snf(dom:impl AsRef<WeakDom>,failure_mode:LoadFailureMode)->Result<(CompleteMap,RecoverableErrors),LoadError>{
-	let dom=dom.as_ref();
+impl<M,T> std::error::Error for LoadError<M,T>
+where
+		M:std::fmt::Debug,
+		T:std::fmt::Debug,
+{}
 
+fn to_snf<'dom,'mesh,'texture,M,T>(
+	dom:&'dom WeakDom,
+	failure_mode:LoadFailureMode,
+	mut mesh_loader:M,
+	mut texture_loader:T,
+)->Result<(CompleteMap,RecoverableErrors),LoadError<M::Error,T::Error>>
+	where
+		'dom:'mesh+'texture,
+		M:Loader<Resource=MeshWithSize,Index<'mesh>=MeshIndex<'mesh>>+'mesh,
+		T:Loader<Resource=Texture,Index<'texture>=&'texture str>+'texture,
+{
 	let mut texture_deferred_loader=RenderConfigDeferredLoader::new();
 	let mut mesh_deferred_loader=MeshDeferredLoader::new();
 
@@ -142,12 +146,10 @@ fn to_snf(dom:impl AsRef<WeakDom>,failure_mode:LoadFailureMode)->Result<(Complet
 		&mut mesh_deferred_loader,
 	);
 
-	let mut mesh_loader=loader::MeshLoader::new();
 	let meshpart_meshes=mesh_deferred_loader.into_meshes(&mut mesh_loader,failure_mode).map_err(LoadError::Mesh)?;
 
 	let map_step2=map_step1.add_meshpart_meshes_and_calculate_attributes(meshpart_meshes);
 
-	let mut texture_loader=loader::TextureLoader::new();
 	let render_configs=texture_deferred_loader.into_render_configs(&mut texture_loader,failure_mode).map_err(LoadError::Texture)?;
 
 	Ok(map_step2.add_render_configs_and_textures(render_configs))

lib/rbx_loader/src/rbx.rs

@@ -867,6 +867,11 @@ impl PartialMap1<'_>{
 				deferred_model_deferred_attributes.model.mesh,
 				deferred_model_deferred_attributes.render
 			)?;
+			// If the mesh size is zero we can't auto-scale it, throw it out.
+			if mesh_size.x==integer::Fixed::ZERO||mesh_size.y==integer::Fixed::ZERO||mesh_size.z==integer::Fixed::ZERO{
+				print!("[rbx_loader] Mesh with zero size!");
+				return None;
+			}
 			Some(ModelDeferredAttributes{
 				mesh,
 				deferred_attributes:deferred_model_deferred_attributes.model.deferred_attributes,

lib/rbx_loader/src/union.rs

@@ -104,7 +104,7 @@ fn build_mesh2(
 		if let Some(normal_id)=normal_agreement_checker.into_agreed_normal(){
 			polygon_groups_normal_id[normal_id as usize-1].push(face);
 		}else{
-			panic!("Empty face!");
+			print!("[union] Empty face!");
 		}
 	}
 	Ok(())
@@ -158,7 +158,7 @@ fn build_mesh5(
 		if let Some(normal_id)=normal_agreement_checker.into_agreed_normal(){
 			polygon_groups_normal_id[normal_id as usize-1].push(face);
 		}else{
-			panic!("Empty face!");
+			print!("[union] Empty face!");
 		}
 	}
 	Ok(())

lib/roblox_emulator/Cargo.toml

@@ -12,7 +12,7 @@ default=["run-service"]
 run-service=[]
 
 [dependencies]
-glam = "0.30.0"
+glam.workspace = true
 mlua = { version = "0.11.3", features = ["luau"] }
 phf = { version = "0.13.1", features = ["macros"] }
 rbx_dom_weak = "4.1.0"

lib/snf/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "strafesnet_snf"
-version = "0.3.1"
+version = "0.3.2"
 edition = "2024"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
@@ -8,7 +8,7 @@ edition = "2024"
 [dependencies]
 binrw = "0.15.0"
 id = { version = "0.1.0", registry = "strafesnet" }
-strafesnet_common = { version = "0.7.0", path = "../common", registry = "strafesnet" }
+strafesnet_common.workspace = true
 
 [lints]
 workspace = true

map-tool/Cargo.toml

@@ -1,15 +1,26 @@
 [package]
 name = "map-tool"
-version = "1.7.2"
+version = "2.0.0"
 edition = "2024"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
+[features]
+default = ["cli"]
+cli = ["dep:clap", "tokio/macros", "tokio/rt-multi-thread", "tokio/fs", "dep:futures"]
+
+[lib]
+name = "map_tool"
+
+[[bin]]
+name = "map-tool"
+required-features = ["cli"]
+
 [dependencies]
 anyhow = "1.0.75"
-clap = { version = "4.4.2", features = ["derive"] }
+clap = { version = "4.4.2", features = ["derive"], optional = true }
 flate2 = "1.0.27"
-futures = "0.3.31"
+futures = { version = "0.3.31", optional = true }
 image = "0.25.2"
 image_dds = "0.7.1"
 rbx_asset = { version = "0.5.0", registry = "strafesnet" }
@@ -18,12 +29,12 @@ rbx_dom_weak = "4.1.0"
 rbx_reflection_database = "2.0.2"
 rbx_xml = "2.0.1"
 rbxassetid = { version = "0.1.0", registry = "strafesnet" }
-strafesnet_bsp_loader = { version = "0.3.1", path = "../lib/bsp_loader", registry = "strafesnet" }
-strafesnet_deferred_loader = { version = "0.5.1", path = "../lib/deferred_loader", registry = "strafesnet" }
-strafesnet_rbx_loader = { version = "0.7.0", path = "../lib/rbx_loader", registry = "strafesnet" }
-strafesnet_snf = { version = "0.3.1", path = "../lib/snf", registry = "strafesnet" }
+strafesnet_bsp_loader.workspace = true
+strafesnet_deferred_loader.workspace = true
+strafesnet_rbx_loader.workspace = true
+strafesnet_snf.workspace = true
 thiserror = "2.0.11"
-tokio = { version = "1.43.0", features = ["macros", "rt-multi-thread", "fs"] }
+tokio = { version = "1.43.0", features = ["time"] }
 vbsp = "0.9.1"
 vbsp-entities-css = "0.6.0"
 vmdl = "0.2.0"

map-tool/src/lib.rs

@@ -0,0 +1,2 @@
+pub mod roblox;
+pub mod source;

map-tool/src/main.rs

@@ -1,23 +1,20 @@
-mod roblox;
-mod source;
-
 use clap::{Parser,Subcommand};
 use anyhow::Result as AResult;
 
 #[derive(Parser)]
-#[command(author, version, about, long_about = None)]
-#[command(propagate_version = true)]
-struct Cli {
+#[command(author,version,about,long_about=None)]
+#[command(propagate_version=true)]
+struct Cli{
 	#[command(subcommand)]
-	command: Commands,
+	command:Commands,
 }
 
 #[derive(Subcommand)]
 enum Commands{
 	#[command(flatten)]
-	Roblox(roblox::Commands),
+	Roblox(map_tool::roblox::Commands),
 	#[command(flatten)]
-	Source(source::Commands),
+	Source(map_tool::source::Commands),
 }
 
 #[tokio::main]

map-tool/src/roblox.rs

@@ -1,501 +0,0 @@
-use std::path::{Path,PathBuf};
-use std::io::{Cursor,Read,Seek};
-use std::collections::HashSet;
-use clap::{Args,Subcommand};
-use anyhow::Result as AResult;
-use rbx_dom_weak::Instance;
-use strafesnet_deferred_loader::deferred_loader::LoadFailureMode;
-use rbxassetid::RobloxAssetId;
-use tokio::io::AsyncReadExt;
-
-// disallow non-static lifetimes
-fn static_ustr(s:&'static str)->rbx_dom_weak::Ustr{
-	rbx_dom_weak::ustr(s)
-}
-
-const DOWNLOAD_LIMIT:usize=16;
-
-#[derive(Subcommand)]
-pub enum Commands{
-	RobloxToSNF(RobloxToSNFSubcommand),
-	DownloadAssets(DownloadAssetsSubcommand),
-}
-
-#[derive(Args)]
-pub struct RobloxToSNFSubcommand {
-	#[arg(long)]
-	output_folder:PathBuf,
-	#[arg(required=true)]
-	input_files:Vec<PathBuf>,
-}
-#[derive(Args)]
-pub struct DownloadAssetsSubcommand{
-	#[arg(required=true)]
-	roblox_files:Vec<PathBuf>,
-	#[arg(long,group="cookie",required=true)]
-	cookie_literal:Option<String>,
-	#[arg(long,group="cookie",required=true)]
-	cookie_envvar:Option<String>,
-	#[arg(long,group="cookie",required=true)]
-	cookie_file:Option<PathBuf>,
-}
-
-impl Commands{
-	pub async fn run(self)->AResult<()>{
-		match self{
-			Commands::RobloxToSNF(subcommand)=>roblox_to_snf(subcommand.input_files,subcommand.output_folder).await,
-			Commands::DownloadAssets(subcommand)=>download_assets(
-				subcommand.roblox_files,
-				cookie_from_args(
-					subcommand.cookie_literal,
-					subcommand.cookie_envvar,
-					subcommand.cookie_file,
-				).await?,
-			).await,
-		}
-	}
-}
-
-async fn cookie_from_args(literal:Option<String>,environment:Option<String>,file:Option<PathBuf>)->AResult<rbx_asset::cookie::Cookie>{
-	let cookie=match (literal,environment,file){
-		(Some(cookie_literal),None,None)=>cookie_literal,
-		(None,Some(cookie_environment),None)=>std::env::var(cookie_environment)?,
-		(None,None,Some(cookie_file))=>tokio::fs::read_to_string(cookie_file).await?,
-		_=>Err(anyhow::Error::msg("Illegal cookie argument triple"))?,
-	};
-	Ok(rbx_asset::cookie::Cookie::new(cookie))
-}
-
-#[expect(dead_code)]
-#[derive(Debug)]
-enum LoadDomError{
-	IO(std::io::Error),
-	Binary(rbx_binary::DecodeError),
-	Xml(rbx_xml::DecodeError),
-	UnknownFormat,
-}
-fn load_dom<R:Read+Seek>(mut input:R)->Result<rbx_dom_weak::WeakDom,LoadDomError>{
-	let mut first_8=[0u8;8];
-	input.read_exact(&mut first_8).map_err(LoadDomError::IO)?;
-	input.rewind().map_err(LoadDomError::IO)?;
-	match &first_8{
-		b"<roblox!"=>rbx_binary::from_reader(input).map_err(LoadDomError::Binary),
-		b"<roblox "=>rbx_xml::from_reader(input,rbx_xml::DecodeOptions::default()).map_err(LoadDomError::Xml),
-		_=>Err(LoadDomError::UnknownFormat),
-	}
-}
-
-/* The ones I'm interested in:
-Beam.Texture
-Decal.Texture
-FileMesh.MeshId
-FileMesh.TextureId
-MaterialVariant.ColorMap
-MaterialVariant.MetalnessMap
-MaterialVariant.NormalMap
-MaterialVariant.RoughnessMap
-MeshPart.MeshId
-MeshPart.TextureID
-ParticleEmitter.Texture
-Sky.MoonTextureId
-Sky.SkyboxBk
-Sky.SkyboxDn
-Sky.SkyboxFt
-Sky.SkyboxLf
-Sky.SkyboxRt
-Sky.SkyboxUp
-Sky.SunTextureId
-SurfaceAppearance.ColorMap
-SurfaceAppearance.MetalnessMap
-SurfaceAppearance.NormalMap
-SurfaceAppearance.RoughnessMap
-SurfaceAppearance.TexturePack
-*/
-/* These properties now use Content
-BaseWrap.CageMeshContent
-Decal.TextureContent
-ImageButton.ImageContent
-ImageLabel.ImageContent
-MeshPart.MeshContent
-MeshPart.TextureContent
-SurfaceAppearance.ColorMapContent
-SurfaceAppearance.MetalnessMapContent
-SurfaceAppearance.NormalMapContent
-SurfaceAppearance.RoughnessMapContent
-WrapLayer.ReferenceMeshContent
-*/
-
-fn accumulate_content(content_list:&mut HashSet<RobloxAssetId>,object:&Instance,property:&'static str){
-	let Some(rbx_dom_weak::types::Variant::Content(content))=object.properties.get(&static_ustr(property))else{
-		println!("property={} does not exist for class={}",property,object.class.as_str());
-		return;
-	};
-	let rbx_dom_weak::types::ContentType::Uri(uri)=content.value()else{
-		println!("ContentType is not Uri");
-		return;
-	};
-	let Ok(asset_id)=uri.parse()else{
-		println!("Content failed to parse into AssetID: {:?}",content);
-		return;
-	};
-	content_list.insert(asset_id);
-}
-fn accumulate_content_id(content_list:&mut HashSet<RobloxAssetId>,object:&Instance,property:&'static str){
-	let Some(rbx_dom_weak::types::Variant::ContentId(content))=object.properties.get(&static_ustr(property))else{
-		println!("property={} does not exist for class={}",property,object.class.as_str());
-		return;
-	};
-	let Ok(asset_id)=content.as_str().parse()else{
-		println!("Content failed to parse into AssetID: {:?}",content);
-		return;
-	};
-	content_list.insert(asset_id);
-}
-async fn read_entire_file(path:impl AsRef<Path>)->Result<Cursor<Vec<u8>>,std::io::Error>{
-	let mut file=tokio::fs::File::open(path).await?;
-	let mut data=Vec::new();
-	file.read_to_end(&mut data).await?;
-	Ok(Cursor::new(data))
-}
-#[derive(Default)]
-struct UniqueAssets{
-	meshes:HashSet<RobloxAssetId>,
-	unions:HashSet<RobloxAssetId>,
-	textures:HashSet<RobloxAssetId>,
-}
-impl UniqueAssets{
-	fn collect(&mut self,object:&Instance){
-		match object.class.as_str(){
-			"Beam"=>accumulate_content_id(&mut self.textures,object,"Texture"),
-			"Decal"=>accumulate_content(&mut self.textures,object,"TextureContent"),
-			"Texture"=>accumulate_content(&mut self.textures,object,"TextureContent"),
-			"FileMesh"=>accumulate_content_id(&mut self.textures,object,"TextureId"),
-			"MeshPart"=>{
-				accumulate_content(&mut self.textures,object,"TextureContent");
-				accumulate_content(&mut self.meshes,object,"MeshContent");
-			},
-			"SpecialMesh"=>accumulate_content_id(&mut self.meshes,object,"MeshId"),
-			"ParticleEmitter"=>accumulate_content_id(&mut self.textures,object,"Texture"),
-			"Sky"=>{
-				accumulate_content_id(&mut self.textures,object,"MoonTextureId");
-				accumulate_content_id(&mut self.textures,object,"SkyboxBk");
-				accumulate_content_id(&mut self.textures,object,"SkyboxDn");
-				accumulate_content_id(&mut self.textures,object,"SkyboxFt");
-				accumulate_content_id(&mut self.textures,object,"SkyboxLf");
-				accumulate_content_id(&mut self.textures,object,"SkyboxRt");
-				accumulate_content_id(&mut self.textures,object,"SkyboxUp");
-				accumulate_content_id(&mut self.textures,object,"SunTextureId");
-			},
-			"UnionOperation"=>accumulate_content_id(&mut self.unions,object,"AssetId"),
-			_=>(),
-		}
-	}
-}
-
-#[expect(dead_code)]
-#[derive(Debug)]
-enum UniqueAssetError{
-	IO(std::io::Error),
-	LoadDom(LoadDomError),
-}
-async fn unique_assets(path:&Path)->Result<UniqueAssets,UniqueAssetError>{
-	// read entire file
-	let mut assets=UniqueAssets::default();
-	let data=read_entire_file(path).await.map_err(UniqueAssetError::IO)?;
-	let dom=load_dom(data).map_err(UniqueAssetError::LoadDom)?;
-	for object in dom.into_raw().1.into_values(){
-		assets.collect(&object);
-	}
-	Ok(assets)
-}
-enum DownloadType{
-	Texture(RobloxAssetId),
-	Mesh(RobloxAssetId),
-	Union(RobloxAssetId),
-}
-impl DownloadType{
-	fn path(&self)->PathBuf{
-		match self{
-			DownloadType::Texture(RobloxAssetId(asset_id))=>format!("downloaded_textures/{asset_id}").into(),
-			DownloadType::Mesh(RobloxAssetId(asset_id))=>format!("meshes/{asset_id}").into(),
-			DownloadType::Union(RobloxAssetId(asset_id))=>format!("unions/{asset_id}").into(),
-		}
-	}
-	fn asset_id(&self)->u64{
-		match self{
-			&DownloadType::Texture(RobloxAssetId(asset_id))=>asset_id,
-			&DownloadType::Mesh(RobloxAssetId(asset_id))=>asset_id,
-			&DownloadType::Union(RobloxAssetId(asset_id))=>asset_id,
-		}
-	}
-}
-enum DownloadResult{
-	Cached(PathBuf),
-	Data(Vec<u8>),
-	Failed,
-}
-#[derive(Default,Debug)]
-struct Stats{
-	total_assets:u32,
-	cached_assets:u32,
-	downloaded_assets:u32,
-	failed_downloads:u32,
-	timed_out_downloads:u32,
-}
-async fn download_retry(stats:&mut Stats,context:&rbx_asset::cookie::Context,download_instruction:DownloadType)->Result<DownloadResult,std::io::Error>{
-	stats.total_assets+=1;
-	// check if file exists on disk
-	let path=download_instruction.path();
-	if tokio::fs::try_exists(path.as_path()).await?{
-		stats.cached_assets+=1;
-		return Ok(DownloadResult::Cached(path));
-	}
-	let asset_id=download_instruction.asset_id();
-	// if not, download file
-	let mut retry=0;
-	const BACKOFF_MUL:f32=1.3956124250860895286;//exp(1/3)
-	let mut backoff=1000f32;
-	loop{
-		let asset_result=context.get_asset(rbx_asset::cookie::GetAssetRequest{
-			asset_id,
-			version:None,
-		}).await;
-		match asset_result{
-			Ok(asset_result)=>{
-				stats.downloaded_assets+=1;
-				let data=asset_result.to_vec()?;
-				tokio::fs::write(path,&data).await?;
-				break Ok(DownloadResult::Data(data));
-			},
-			Err(rbx_asset::cookie::GetError::Response(rbx_asset::types::ResponseError::Details{status_code,url_and_body}))=>{
-				if status_code.as_u16()==429{
-					if retry==12{
-						println!("Giving up asset download {asset_id}");
-						stats.timed_out_downloads+=1;
-						break Ok(DownloadResult::Failed);
-					}
-					println!("Hit roblox rate limit, waiting {:.0}ms...",backoff);
-					tokio::time::sleep(std::time::Duration::from_millis(backoff as u64)).await;
-					backoff*=BACKOFF_MUL;
-					retry+=1;
-				}else{
-					stats.failed_downloads+=1;
-					println!("weird status_code error: status_code={status_code} url={} body={}",url_and_body.url,url_and_body.body);
-					break Ok(DownloadResult::Failed);
-				}
-			},
-			Err(e)=>{
-				stats.failed_downloads+=1;
-				println!("sadly error: {e}");
-				break Ok(DownloadResult::Failed);
-			},
-		}
-	}
-}
-#[derive(Debug,thiserror::Error)]
-enum ConvertTextureError{
-	#[error("Io error {0:?}")]
-	Io(#[from]std::io::Error),
-	#[error("Image error {0:?}")]
-	Image(#[from]image::ImageError),
-	#[error("DDS create error {0:?}")]
-	DDS(#[from]image_dds::CreateDdsError),
-	#[error("DDS write error {0:?}")]
-	DDSWrite(#[from]image_dds::ddsfile::Error),
-}
-async fn convert_texture(RobloxAssetId(asset_id):RobloxAssetId,download_result:DownloadResult)->Result<(),ConvertTextureError>{
-	let data=match download_result{
-		DownloadResult::Cached(path)=>tokio::fs::read(path).await?,
-		DownloadResult::Data(data)=>data,
-		DownloadResult::Failed=>return Ok(()),
-	};
-	// image::ImageFormat::Png
-	// image::ImageFormat::Jpeg
-	let image=image::load_from_memory(&data)?.to_rgba8();
-
-	// pick format
-	let format=if image.width()%4!=0||image.height()%4!=0{
-		image_dds::ImageFormat::Rgba8UnormSrgb
-	}else{
-		image_dds::ImageFormat::BC7RgbaUnormSrgb
-	};
-
-	//this fails if the image dimensions are not a multiple of 4
-	let dds=image_dds::dds_from_image(
-		&image,
-		format,
-		image_dds::Quality::Slow,
-		image_dds::Mipmaps::GeneratedAutomatic,
-	)?;
-
-	let file_name=format!("textures/{asset_id}.dds");
-	let mut file=std::fs::File::create(file_name)?;
-	dds.write(&mut file)?;
-	Ok(())
-}
-async fn download_assets(paths:Vec<PathBuf>,cookie:rbx_asset::cookie::Cookie)->AResult<()>{
-	tokio::try_join!(
-		tokio::fs::create_dir_all("downloaded_textures"),
-		tokio::fs::create_dir_all("textures"),
-		tokio::fs::create_dir_all("meshes"),
-		tokio::fs::create_dir_all("unions"),
-	)?;
-	// use mpsc
-	let thread_limit=std::thread::available_parallelism()?.get();
-	let (send_assets,mut recv_assets)=tokio::sync::mpsc::channel(DOWNLOAD_LIMIT);
-	let (send_texture,mut recv_texture)=tokio::sync::mpsc::channel(thread_limit);
-	// map decode dispatcher
-	// read files multithreaded
-	// produce UniqueAssetsResult per file
-	tokio::spawn(async move{
-		// move send so it gets dropped when all maps have been decoded
-		// closing the channel
-		let mut it=paths.into_iter();
-		static SEM:tokio::sync::Semaphore=tokio::sync::Semaphore::const_new(0);
-		SEM.add_permits(thread_limit);
-		while let (Ok(permit),Some(path))=(SEM.acquire().await,it.next()){
-			let send=send_assets.clone();
-			tokio::spawn(async move{
-				let result=unique_assets(path.as_path()).await;
-				_=send.send(result).await;
-				drop(permit);
-			});
-		}
-	});
-	// download manager
-	// insert into global unique assets guy
-	// add to download queue if the asset is globally unique and does not already exist on disk
-	let mut stats=Stats::default();
-	let context=rbx_asset::cookie::Context::new(cookie);
-	let mut globally_unique_assets=UniqueAssets::default();
-	// pop a job = retry_queue.pop_front() or ingest(recv.recv().await)
-	// SLOW MODE:
-	// acquire all permits
-	// drop all permits
-	// pop one job
-	// if it succeeds go into fast mode
-	// FAST MODE:
-	// acquire one permit
-	// pop a job
-	let download_thread=tokio::spawn(async move{
-		while let Some(result)=recv_assets.recv().await{
-			let unique_assets=match result{
-				Ok(unique_assets)=>unique_assets,
-				Err(e)=>{
-					println!("error: {e:?}");
-					continue;
-				},
-			};
-			for texture_id in unique_assets.textures{
-				if globally_unique_assets.textures.insert(texture_id){
-					let data=download_retry(&mut stats,&context,DownloadType::Texture(texture_id)).await?;
-					send_texture.send((texture_id,data)).await?;
-				}
-			}
-			for mesh_id in unique_assets.meshes{
-				if globally_unique_assets.meshes.insert(mesh_id){
-					download_retry(&mut stats,&context,DownloadType::Mesh(mesh_id)).await?;
-				}
-			}
-			for union_id in unique_assets.unions{
-				if globally_unique_assets.unions.insert(union_id){
-					download_retry(&mut stats,&context,DownloadType::Union(union_id)).await?;
-				}
-			}
-		}
-		dbg!(stats);
-		Ok::<(),anyhow::Error>(())
-	});
-	static SEM:tokio::sync::Semaphore=tokio::sync::Semaphore::const_new(0);
-	SEM.add_permits(thread_limit);
-	while let (Ok(permit),Some((asset_id,download_result)))=(SEM.acquire().await,recv_texture.recv().await){
-		tokio::spawn(async move{
-			let result=convert_texture(asset_id,download_result).await;
-			drop(permit);
-			result.unwrap();
-		});
-	}
-	download_thread.await??;
-	_=SEM.acquire_many(thread_limit as u32).await.unwrap();
-	Ok(())
-}
-
-#[derive(Debug)]
-#[expect(dead_code)]
-enum ConvertError{
-	IO(std::io::Error),
-	SNFMap(strafesnet_snf::map::Error),
-	RobloxRead(strafesnet_rbx_loader::ReadError),
-	RobloxLoad(strafesnet_rbx_loader::LoadError),
-}
-impl std::fmt::Display for ConvertError{
-	fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
-		write!(f,"{self:?}")
-	}
-}
-impl std::error::Error for ConvertError{}
-
-struct Errors{
-	script_errors:Vec<strafesnet_rbx_loader::RunnerError>,
-	convert_errors:strafesnet_rbx_loader::RecoverableErrors,
-}
-
-fn convert_to_snf(path:&Path,output_folder:PathBuf)->Result<Errors,ConvertError>{
-	let entire_file=std::fs::read(path).map_err(ConvertError::IO)?;
-
-	let model=strafesnet_rbx_loader::read(
-		entire_file.as_slice()
-	).map_err(ConvertError::RobloxRead)?;
-
-	let mut place=strafesnet_rbx_loader::Place::from(model);
-	let script_errors=place.run_scripts().unwrap_or_else(|e|vec![e]);
-
-	let (map,convert_errors)=place.to_snf(LoadFailureMode::DefaultToNone).map_err(ConvertError::RobloxLoad)?;
-
-	let mut dest=output_folder;
-	dest.push(path.file_stem().unwrap());
-	dest.set_extension("snfm");
-	let file=std::fs::File::create(dest).map_err(ConvertError::IO)?;
-
-	strafesnet_snf::map::write_map(file,map).map_err(ConvertError::SNFMap)?;
-
-	Ok(Errors{
-		script_errors,
-		convert_errors,
-	})
-}
-
-async fn roblox_to_snf(paths:Vec<PathBuf>,output_folder:PathBuf)->AResult<()>{
-	let start=std::time::Instant::now();
-
-	let thread_limit=std::thread::available_parallelism()?.get();
-	let mut it=paths.into_iter();
-	static SEM:tokio::sync::Semaphore=tokio::sync::Semaphore::const_new(0);
-	// This is wrong! Calling roblox_to_snf multiple times keeps adding permits
-	SEM.add_permits(thread_limit);
-
-	while let (Ok(permit),Some(path))=(SEM.acquire().await,it.next()){
-		let output_folder=output_folder.clone();
-		tokio::task::spawn_blocking(move||{
-			let result=convert_to_snf(path.as_path(),output_folder);
-			drop(permit);
-			match result{
-				Ok(errors)=>{
-					for error in errors.script_errors{
-						println!("Script error: {error}");
-					}
-					let error_count=errors.convert_errors.count();
-					if error_count!=0{
-						println!("Error count: {error_count}");
-						println!("Errors: {}",errors.convert_errors);
-					}
-				},
-				Err(e)=>println!("Convert error: {e:?}"),
-			}
-		});
-	}
-	_=SEM.acquire_many(thread_limit as u32).await.unwrap();
-
-	println!("elapsed={:?}", start.elapsed());
-	Ok(())
-}

map-tool/src/roblox/cli.rs

@@ -0,0 +1,287 @@
+use std::path::PathBuf;
+use anyhow::Result as AResult;
+use rbxassetid::RobloxAssetId;
+
+use super::{convert_to_snf,convert_texture_to_dds,get_unique_assets_from_file};
+use super::{ConvertTextureError,UniqueAssets};
+
+const DOWNLOAD_LIMIT:usize=16;
+
+#[derive(clap::Subcommand)]
+pub enum Commands{
+	RobloxToSNF(RobloxToSNFSubcommand),
+	DownloadAssets(DownloadAssetsSubcommand),
+}
+
+#[derive(clap::Args)]
+pub struct RobloxToSNFSubcommand{
+	#[arg(long)]
+	output_folder:PathBuf,
+	#[arg(required=true)]
+	input_files:Vec<PathBuf>,
+}
+#[derive(clap::Args)]
+pub struct DownloadAssetsSubcommand{
+	#[arg(required=true)]
+	roblox_files:Vec<PathBuf>,
+	#[arg(long,group="cookie",required=true)]
+	cookie_literal:Option<String>,
+	#[arg(long,group="cookie",required=true)]
+	cookie_envvar:Option<String>,
+	#[arg(long,group="cookie",required=true)]
+	cookie_file:Option<PathBuf>,
+}
+
+impl Commands{
+	pub async fn run(self)->AResult<()>{
+		match self{
+			Commands::RobloxToSNF(subcommand)=>roblox_to_snf(subcommand.input_files,subcommand.output_folder).await,
+			Commands::DownloadAssets(subcommand)=>download_assets(
+				subcommand.roblox_files,
+				cookie_from_args(
+					subcommand.cookie_literal,
+					subcommand.cookie_envvar,
+					subcommand.cookie_file,
+				).await?,
+			).await,
+		}
+	}
+}
+
+async fn cookie_from_args(literal:Option<String>,environment:Option<String>,file:Option<PathBuf>)->AResult<rbx_asset::cookie::Cookie>{
+	let cookie=match (literal,environment,file){
+		(Some(cookie_literal),None,None)=>cookie_literal,
+		(None,Some(cookie_environment),None)=>std::env::var(cookie_environment)?,
+		(None,None,Some(cookie_file))=>tokio::fs::read_to_string(cookie_file).await?,
+		_=>Err(anyhow::Error::msg("Illegal cookie argument triple"))?,
+	};
+	Ok(rbx_asset::cookie::Cookie::new(cookie))
+}
+
+enum DownloadType{
+	Texture(RobloxAssetId),
+	Mesh(RobloxAssetId),
+	Union(RobloxAssetId),
+}
+impl DownloadType{
+	fn path(&self)->PathBuf{
+		match self{
+			DownloadType::Texture(RobloxAssetId(asset_id))=>format!("downloaded_textures/{asset_id}").into(),
+			DownloadType::Mesh(RobloxAssetId(asset_id))=>format!("meshes/{asset_id}").into(),
+			DownloadType::Union(RobloxAssetId(asset_id))=>format!("unions/{asset_id}").into(),
+		}
+	}
+	fn asset_id(&self)->u64{
+		match self{
+			&DownloadType::Texture(RobloxAssetId(asset_id))=>asset_id,
+			&DownloadType::Mesh(RobloxAssetId(asset_id))=>asset_id,
+			&DownloadType::Union(RobloxAssetId(asset_id))=>asset_id,
+		}
+	}
+}
+enum DownloadResult{
+	Cached(PathBuf),
+	Data(Vec<u8>),
+	Failed,
+}
+#[derive(Default,Debug)]
+struct Stats{
+	total_assets:u32,
+	cached_assets:u32,
+	downloaded_assets:u32,
+	failed_downloads:u32,
+	timed_out_downloads:u32,
+}
+async fn download_retry(stats:&mut Stats,context:&rbx_asset::cookie::Context,download_instruction:DownloadType)->Result<DownloadResult,std::io::Error>{
+	stats.total_assets+=1;
+	// check if file exists on disk
+	let path=download_instruction.path();
+	if tokio::fs::try_exists(path.as_path()).await?{
+		stats.cached_assets+=1;
+		return Ok(DownloadResult::Cached(path));
+	}
+	let asset_id=download_instruction.asset_id();
+	// if not, download file
+	let mut retry=0;
+	let mut backoff=1000f32;
+	loop{
+		let asset_result=context.get_asset(rbx_asset::cookie::GetAssetRequest{
+			asset_id,
+			version:None,
+		}).await;
+		match asset_result{
+			Ok(asset_result)=>{
+				stats.downloaded_assets+=1;
+				let data=asset_result.to_vec()?;
+				tokio::fs::write(path,&data).await?;
+				break Ok(DownloadResult::Data(data));
+			},
+			Err(rbx_asset::cookie::GetError::Response(rbx_asset::types::ResponseError::Details{status_code,url_and_body}))=>{
+				if status_code.as_u16()==429{
+					if retry==12{
+						println!("Giving up asset download {asset_id}");
+						stats.timed_out_downloads+=1;
+						break Ok(DownloadResult::Failed);
+					}
+					println!("Hit roblox rate limit, waiting {:.0}ms...",backoff);
+					tokio::time::sleep(std::time::Duration::from_millis(backoff as u64)).await;
+					backoff*=super::BACKOFF_MUL;
+					retry+=1;
+				}else{
+					stats.failed_downloads+=1;
+					println!("weird status_code error: status_code={status_code} url={} body={}",url_and_body.url,url_and_body.body);
+					break Ok(DownloadResult::Failed);
+				}
+			},
+			Err(e)=>{
+				stats.failed_downloads+=1;
+				println!("sadly error: {e}");
+				break Ok(DownloadResult::Failed);
+			},
+		}
+	}
+}
+
+async fn cli_convert_texture(RobloxAssetId(asset_id):RobloxAssetId,download_result:DownloadResult)->Result<(),CliConvertTextureError>{
+	let data=match download_result{
+		DownloadResult::Cached(path)=>tokio::fs::read(path).await?,
+		DownloadResult::Data(data)=>data,
+		DownloadResult::Failed=>return Ok(()),
+	};
+	let dds=convert_texture_to_dds(&data)?;
+
+	let file_name=format!("textures/{asset_id}.dds");
+	tokio::fs::write(file_name,&dds).await?;
+	Ok(())
+}
+#[derive(Debug,thiserror::Error)]
+enum CliConvertTextureError{
+	#[error("Io error {0:?}")]
+	Io(#[from]std::io::Error),
+	#[error("ConvertTexture error {0:?}")]
+	ConvertTexture(#[from]ConvertTextureError),
+}
+
+async fn download_assets(paths:Vec<PathBuf>,cookie:rbx_asset::cookie::Cookie)->AResult<()>{
+	tokio::try_join!(
+		tokio::fs::create_dir_all("downloaded_textures"),
+		tokio::fs::create_dir_all("textures"),
+		tokio::fs::create_dir_all("meshes"),
+		tokio::fs::create_dir_all("unions"),
+	)?;
+	// use mpsc
+	let thread_limit=std::thread::available_parallelism()?.get();
+	let (send_assets,mut recv_assets)=tokio::sync::mpsc::channel(DOWNLOAD_LIMIT);
+	let (send_texture,mut recv_texture)=tokio::sync::mpsc::channel(thread_limit);
+	// map decode dispatcher
+	// read files multithreaded
+	// produce UniqueAssetsResult per file
+	tokio::spawn(async move{
+		// move send so it gets dropped when all maps have been decoded
+		// closing the channel
+		let mut it=paths.into_iter();
+		static SEM:tokio::sync::Semaphore=tokio::sync::Semaphore::const_new(0);
+		SEM.add_permits(thread_limit);
+		while let (Ok(permit),Some(path))=(SEM.acquire().await,it.next()){
+			let send=send_assets.clone();
+			tokio::spawn(async move{
+				let result=match tokio::fs::read(&path).await{
+					Ok(data)=>get_unique_assets_from_file(&data).map_err(|e|format!("{e:?}")),
+					Err(e)=>Err(format!("{e:?}")),
+				};
+				_=send.send(result).await;
+				drop(permit);
+			});
+		}
+	});
+	// download manager
+	let mut stats=Stats::default();
+	let context=rbx_asset::cookie::Context::new(cookie);
+	let mut globally_unique_assets=UniqueAssets::default();
+	let download_thread=tokio::spawn(async move{
+		while let Some(result)=recv_assets.recv().await{
+			let unique_assets=match result{
+				Ok(unique_assets)=>unique_assets,
+				Err(e)=>{
+					println!("error: {e:?}");
+					continue;
+				},
+			};
+			for texture_id in unique_assets.textures{
+				if globally_unique_assets.textures.insert(texture_id){
+					let data=download_retry(&mut stats,&context,DownloadType::Texture(texture_id)).await?;
+					send_texture.send((texture_id,data)).await?;
+				}
+			}
+			for mesh_id in unique_assets.meshes{
+				if globally_unique_assets.meshes.insert(mesh_id){
+					download_retry(&mut stats,&context,DownloadType::Mesh(mesh_id)).await?;
+				}
+			}
+			for union_id in unique_assets.unions{
+				if globally_unique_assets.unions.insert(union_id){
+					download_retry(&mut stats,&context,DownloadType::Union(union_id)).await?;
+				}
+			}
+		}
+		dbg!(stats);
+		Ok::<(),anyhow::Error>(())
+	});
+	static SEM:tokio::sync::Semaphore=tokio::sync::Semaphore::const_new(0);
+	SEM.add_permits(thread_limit);
+	while let (Ok(permit),Some((asset_id,download_result)))=(SEM.acquire().await,recv_texture.recv().await){
+		tokio::spawn(async move{
+			let result=cli_convert_texture(asset_id,download_result).await;
+			drop(permit);
+			result.unwrap();
+		});
+	}
+	download_thread.await??;
+	_=SEM.acquire_many(thread_limit as u32).await.unwrap();
+	Ok(())
+}
+
+async fn roblox_to_snf(paths:Vec<PathBuf>,output_folder:PathBuf)->AResult<()>{
+	let start=std::time::Instant::now();
+
+	let thread_limit=std::thread::available_parallelism()?.get();
+	let mut it=paths.into_iter();
+	static SEM:tokio::sync::Semaphore=tokio::sync::Semaphore::const_new(0);
+	// This is wrong! Calling roblox_to_snf multiple times keeps adding permits
+	SEM.add_permits(thread_limit);
+
+	while let (Ok(permit),Some(path))=(SEM.acquire().await,it.next()){
+		let output_folder=output_folder.clone();
+		tokio::task::spawn_blocking(move||{
+			let result=std::fs::read(&path).and_then(|data|{
+				super::load_dom(&data).map_err(|e|std::io::Error::other(e))
+				.and_then(|dom|convert_to_snf(dom).map_err(|e|std::io::Error::other(e)))
+				.and_then(|output|{
+					let mut dest=output_folder;
+					dest.push(path.file_stem().unwrap());
+					dest.set_extension("snfm");
+					std::fs::write(dest,&output.snf)?;
+					Ok(output)
+				})
+			});
+			drop(permit);
+			match result{
+				Ok(output)=>{
+					for error in output.script_errors{
+						println!("Script error: {error}");
+					}
+					let error_count=output.convert_errors.count();
+					if error_count!=0{
+						println!("Error count: {error_count}");
+						println!("Errors: {}",output.convert_errors);
+					}
+				},
+				Err(e)=>println!("Convert error: {e:?}"),
+			}
+		});
+	}
+	_=SEM.acquire_many(thread_limit as u32).await.unwrap();
+
+	println!("elapsed={:?}", start.elapsed());
+	Ok(())
+}

map-tool/src/roblox/mod.rs

@@ -0,0 +1,248 @@
+#[cfg(feature="cli")]
+mod cli;
+#[cfg(feature="cli")]
+pub use cli::Commands;
+#[cfg(feature="cli")]
+mod loader;
+
+use std::io::{Cursor,Read,Seek};
+use std::collections::HashSet;
+use strafesnet_deferred_loader::deferred_loader::LoadFailureMode;
+pub use rbxassetid::RobloxAssetId;
+use rbx_dom_weak::Instance;
+
+// disallow non-static lifetimes
+fn static_ustr(s:&'static str)->rbx_dom_weak::Ustr{
+	rbx_dom_weak::ustr(s)
+}
+
+#[derive(Debug)]
+pub enum LoadDomError{
+	IO(std::io::Error),
+	Binary(rbx_binary::DecodeError),
+	Xml(rbx_xml::DecodeError),
+	UnknownFormat,
+}
+impl std::fmt::Display for LoadDomError{
+	fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
+		write!(f,"{self:?}")
+	}
+}
+impl std::error::Error for LoadDomError{}
+pub fn load_dom(data:&[u8])->Result<rbx_dom_weak::WeakDom,LoadDomError>{
+	let mut input=Cursor::new(data);
+	let mut first_8=[0u8;8];
+	input.read_exact(&mut first_8).map_err(LoadDomError::IO)?;
+	input.rewind().map_err(LoadDomError::IO)?;
+	match &first_8{
+		b"<roblox!"=>rbx_binary::from_reader(input).map_err(LoadDomError::Binary),
+		b"<roblox "=>rbx_xml::from_reader(input,rbx_xml::DecodeOptions::default()).map_err(LoadDomError::Xml),
+		_=>Err(LoadDomError::UnknownFormat),
+	}
+}
+
+fn accumulate_content(content_list:&mut HashSet<RobloxAssetId>,object:&Instance,property:&'static str){
+	let Some(rbx_dom_weak::types::Variant::Content(content))=object.properties.get(&static_ustr(property))else{
+		println!("property={} does not exist for class={}",property,object.class.as_str());
+		return;
+	};
+	let rbx_dom_weak::types::ContentType::Uri(uri)=content.value()else{
+		println!("ContentType is not Uri");
+		return;
+	};
+	let Ok(asset_id)=uri.parse()else{
+		println!("Content failed to parse into AssetID: {:?}",content);
+		return;
+	};
+	content_list.insert(asset_id);
+}
+fn accumulate_content_id(content_list:&mut HashSet<RobloxAssetId>,object:&Instance,property:&'static str){
+	let Some(rbx_dom_weak::types::Variant::ContentId(content))=object.properties.get(&static_ustr(property))else{
+		println!("property={} does not exist for class={}",property,object.class.as_str());
+		return;
+	};
+	let Ok(asset_id)=content.as_str().parse()else{
+		println!("Content failed to parse into AssetID: {:?}",content);
+		return;
+	};
+	content_list.insert(asset_id);
+}
+
+#[derive(Default)]
+pub struct UniqueAssets{
+	pub meshes:HashSet<RobloxAssetId>,
+	pub unions:HashSet<RobloxAssetId>,
+	pub textures:HashSet<RobloxAssetId>,
+}
+impl UniqueAssets{
+	fn collect(&mut self,object:&Instance){
+		match object.class.as_str(){
+			"Beam"=>accumulate_content_id(&mut self.textures,object,"Texture"),
+			"Decal"=>accumulate_content(&mut self.textures,object,"TextureContent"),
+			"Texture"=>accumulate_content(&mut self.textures,object,"TextureContent"),
+			"FileMesh"=>accumulate_content_id(&mut self.textures,object,"TextureId"),
+			"MeshPart"=>{
+				accumulate_content(&mut self.textures,object,"TextureContent");
+				accumulate_content(&mut self.meshes,object,"MeshContent");
+			},
+			"SpecialMesh"=>accumulate_content_id(&mut self.meshes,object,"MeshId"),
+			"ParticleEmitter"=>accumulate_content_id(&mut self.textures,object,"Texture"),
+			"Sky"=>{
+				accumulate_content_id(&mut self.textures,object,"MoonTextureId");
+				accumulate_content_id(&mut self.textures,object,"SkyboxBk");
+				accumulate_content_id(&mut self.textures,object,"SkyboxDn");
+				accumulate_content_id(&mut self.textures,object,"SkyboxFt");
+				accumulate_content_id(&mut self.textures,object,"SkyboxLf");
+				accumulate_content_id(&mut self.textures,object,"SkyboxRt");
+				accumulate_content_id(&mut self.textures,object,"SkyboxUp");
+				accumulate_content_id(&mut self.textures,object,"SunTextureId");
+			},
+			"UnionOperation"=>accumulate_content_id(&mut self.unions,object,"AssetId"),
+			_=>(),
+		}
+	}
+}
+
+pub fn get_unique_assets(dom:rbx_dom_weak::WeakDom)->UniqueAssets{
+	let mut assets=UniqueAssets::default();
+	for object in dom.into_raw().1.into_values(){
+		assets.collect(&object);
+	}
+	assets
+}
+
+pub fn get_unique_assets_from_file(data:&[u8])->Result<UniqueAssets,UniqueAssetError>{
+	let dom=load_dom(data).map_err(UniqueAssetError::LoadDom)?;
+	Ok(get_unique_assets(dom))
+}
+
+#[derive(Debug)]
+pub enum UniqueAssetError{
+	LoadDom(LoadDomError),
+}
+
+#[derive(Debug)]
+pub enum ConvertError{
+	IO(std::io::Error),
+	SNFMap(strafesnet_snf::map::Error),
+	RobloxLoad(strafesnet_rbx_loader::LoadError),
+}
+impl std::fmt::Display for ConvertError{
+	fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
+		write!(f,"{self:?}")
+	}
+}
+impl std::error::Error for ConvertError{}
+
+pub struct ConvertOutput{
+	pub snf:Vec<u8>,
+	pub script_errors:Vec<strafesnet_rbx_loader::RunnerError>,
+	pub convert_errors:strafesnet_rbx_loader::RecoverableErrors,
+}
+
+pub fn convert_to_snf(dom:rbx_dom_weak::WeakDom)->Result<ConvertOutput,ConvertError>{
+	let model=strafesnet_rbx_loader::Model::new(dom);
+
+	let mut place=strafesnet_rbx_loader::Place::from(model);
+	let script_errors=place.run_scripts().unwrap_or_else(|e|vec![e]);
+
+	let (map,convert_errors)=place.to_snf(LoadFailureMode::DefaultToNone).map_err(ConvertError::RobloxLoad)?;
+
+	let mut snf_buf=Vec::new();
+	strafesnet_snf::map::write_map(Cursor::new(&mut snf_buf),map).map_err(ConvertError::SNFMap)?;
+
+	Ok(ConvertOutput{
+		snf:snf_buf,
+		script_errors,
+		convert_errors,
+	})
+}
+
+#[derive(Debug,thiserror::Error)]
+pub enum ConvertTextureError{
+	#[error("Image error {0:?}")]
+	Image(#[from]image::ImageError),
+	#[error("DDS create error {0:?}")]
+	DDS(#[from]image_dds::CreateDdsError),
+	#[error("DDS write error {0:?}")]
+	DDSWrite(#[from]image_dds::ddsfile::Error),
+}
+pub fn convert_texture_to_dds(data:&[u8])->Result<Vec<u8>,ConvertTextureError>{
+	let image=image::load_from_memory(data)?.to_rgba8();
+
+	let format=if image.width()%4!=0||image.height()%4!=0{
+		image_dds::ImageFormat::Rgba8UnormSrgb
+	}else{
+		image_dds::ImageFormat::BC7RgbaUnormSrgb
+	};
+
+	let dds=image_dds::dds_from_image(
+		&image,
+		format,
+		image_dds::Quality::Slow,
+		image_dds::Mipmaps::GeneratedAutomatic,
+	)?;
+
+	let mut buf=Vec::new();
+	dds.write(&mut Cursor::new(&mut buf))?;
+	Ok(buf)
+}
+
+#[derive(Debug)]
+pub enum DownloadAssetError{
+	Get(rbx_asset::cookie::GetError),
+	IO(std::io::Error),
+}
+impl std::fmt::Display for DownloadAssetError{
+	fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
+		write!(f,"{self:?}")
+	}
+}
+impl std::error::Error for DownloadAssetError{}
+
+pub async fn download_asset(context:&rbx_asset::cookie::Context,asset_id:u64)->Result<Vec<u8>,DownloadAssetError>{
+	let data=context.get_asset(rbx_asset::cookie::GetAssetRequest{
+		asset_id,
+		version:None,
+	}).await.map_err(DownloadAssetError::Get)?;
+	Ok(data.to_vec().map_err(DownloadAssetError::IO)?)
+}
+
+pub(crate) const BACKOFF_MUL:f32=1.3956124250860895286;//exp(1/3)
+const RETRY_LIMIT:u32=12;
+
+pub enum DownloadRetryResult{
+	Ok(Vec<u8>),
+	TimedOut,
+}
+
+pub async fn download_asset_retry(context:&rbx_asset::cookie::Context,asset_id:u64)->Result<DownloadRetryResult,DownloadAssetError>{
+	let mut retry=0u32;
+	let mut backoff=1000f32;
+	loop{
+		match context.get_asset(rbx_asset::cookie::GetAssetRequest{
+			asset_id,
+			version:None,
+		}).await{
+			Ok(data)=>{
+				let bytes=data.to_vec().map_err(DownloadAssetError::IO)?;
+				break Ok(DownloadRetryResult::Ok(bytes));
+			},
+			Err(rbx_asset::cookie::GetError::Response(rbx_asset::types::ResponseError::Details{status_code,url_and_body}))=>{
+				if status_code.as_u16()==429{
+					if retry==RETRY_LIMIT{
+						break Ok(DownloadRetryResult::TimedOut);
+					}
+					tokio::time::sleep(std::time::Duration::from_millis(backoff as u64)).await;
+					backoff*=BACKOFF_MUL;
+					retry+=1;
+				}else{
+					break Err(DownloadAssetError::Get(rbx_asset::cookie::GetError::Response(rbx_asset::types::ResponseError::Details{status_code,url_and_body})));
+				}
+			},
+			Err(e)=>{
+				break Err(DownloadAssetError::Get(e));
+			},
+		}
+	}
+}

map-tool/src/source.rs

@@ -1,514 +0,0 @@
-use std::path::{Path,PathBuf};
-use std::borrow::Cow;
-use clap::{Args,Subcommand};
-use anyhow::Result as AResult;
-use futures::StreamExt;
-use strafesnet_bsp_loader::loader::BspFinder;
-use strafesnet_deferred_loader::loader::Loader;
-use strafesnet_deferred_loader::deferred_loader::{LoadFailureMode,MeshDeferredLoader,RenderConfigDeferredLoader};
-use vbsp_entities_css::Entity;
-
-#[derive(Subcommand)]
-pub enum Commands{
-	SourceToSNF(SourceToSNFSubcommand),
-	ExtractTextures(ExtractTexturesSubcommand),
-	VPKContents(VPKContentsSubcommand),
-	BSPContents(BSPContentsSubcommand),
-}
-
-#[derive(Args)]
-pub struct SourceToSNFSubcommand {
-	#[arg(long)]
-	output_folder:PathBuf,
-	#[arg(required=true)]
-	input_files:Vec<PathBuf>,
-	#[arg(long)]
-	vpks:Vec<PathBuf>,
-}
-#[derive(Args)]
-pub struct ExtractTexturesSubcommand{
-	#[arg(required=true)]
-	bsp_files:Vec<PathBuf>,
-	#[arg(long)]
-	vpks:Vec<PathBuf>,
-}
-#[derive(Args)]
-pub struct VPKContentsSubcommand {
-	#[arg(long)]
-	input_file:PathBuf,
-}
-#[derive(Args)]
-pub struct BSPContentsSubcommand {
-	#[arg(long)]
-	input_file:PathBuf,
-}
-
-impl Commands{
-	pub async fn run(self)->AResult<()>{
-		match self{
-			Commands::SourceToSNF(subcommand)=>source_to_snf(subcommand.input_files,subcommand.output_folder,subcommand.vpks).await,
-			Commands::ExtractTextures(subcommand)=>extract_textures(subcommand.bsp_files,subcommand.vpks).await,
-			Commands::VPKContents(subcommand)=>vpk_contents(subcommand.input_file),
-			Commands::BSPContents(subcommand)=>bsp_contents(subcommand.input_file),
-		}
-	}
-}
-
-
-enum VMTContent{
-	VMT(String),
-	VTF(String),
-	Patch(vmt_parser::material::PatchMaterial),
-	Unsupported,//don't want to deal with whatever vmt variant
-	Unresolved,//could not locate a texture because of vmt content
-}
-impl VMTContent{
-	fn vtf(opt:Option<String>)->Self{
-		match opt{
-			Some(s)=>Self::VTF(s),
-			None=>Self::Unresolved,
-		}
-	}
-}
-
-fn get_some_texture(material:vmt_parser::material::Material)->VMTContent{
-	//just grab some texture from somewhere for now
-	match material{
-		vmt_parser::material::Material::LightMappedGeneric(mat)=>VMTContent::vtf(Some(mat.base_texture)),
-		vmt_parser::material::Material::VertexLitGeneric(mat)=>VMTContent::vtf(mat.base_texture.or(mat.decal_texture)),//this just dies if there is none
-		vmt_parser::material::Material::VertexLitGenericDx6(mat)=>VMTContent::vtf(mat.base_texture.or(mat.decal_texture)),
-		vmt_parser::material::Material::UnlitGeneric(mat)=>VMTContent::vtf(mat.base_texture),
-		vmt_parser::material::Material::UnlitTwoTexture(mat)=>VMTContent::vtf(mat.base_texture),
-		vmt_parser::material::Material::Water(mat)=>VMTContent::vtf(mat.base_texture),
-		vmt_parser::material::Material::WorldVertexTransition(mat)=>VMTContent::vtf(Some(mat.base_texture)),
-		vmt_parser::material::Material::EyeRefract(mat)=>VMTContent::vtf(Some(mat.cornea_texture)),
-		vmt_parser::material::Material::SubRect(mat)=>VMTContent::VMT(mat.material),//recursive
-		vmt_parser::material::Material::Sprite(mat)=>VMTContent::vtf(Some(mat.base_texture)),
-		vmt_parser::material::Material::SpriteCard(mat)=>VMTContent::vtf(mat.base_texture),
-		vmt_parser::material::Material::Cable(mat)=>VMTContent::vtf(Some(mat.base_texture)),
-		vmt_parser::material::Material::Refract(mat)=>VMTContent::vtf(mat.base_texture),
-		vmt_parser::material::Material::Modulate(mat)=>VMTContent::vtf(Some(mat.base_texture)),
-		vmt_parser::material::Material::DecalModulate(mat)=>VMTContent::vtf(Some(mat.base_texture)),
-		vmt_parser::material::Material::Sky(mat)=>VMTContent::vtf(Some(mat.base_texture)),
-		vmt_parser::material::Material::Replacements(_mat)=>VMTContent::Unsupported,
-		vmt_parser::material::Material::Patch(mat)=>VMTContent::Patch(mat),
-		_=>unreachable!(),
-	}
-}
-
-#[derive(Debug,thiserror::Error)]
-enum GetVMTError{
-	#[error("Bsp error {0:?}")]
-	Bsp(#[from]vbsp::BspError),
-	#[error("Utf8 error {0:?}")]
-	Utf8(#[from]std::str::Utf8Error),
-	#[error("Vdf error {0:?}")]
-	Vdf(#[from]vmt_parser::VdfError),
-	#[error("Vmt not found")]
-	NotFound,
-}
-
-fn get_vmt(finder:BspFinder,search_name:&str)->Result<vmt_parser::material::Material,GetVMTError>{
-	let vmt_data=finder.find(search_name)?.ok_or(GetVMTError::NotFound)?;
-	//decode vmt and then write
-	let vmt_str=core::str::from_utf8(&vmt_data)?;
-	let material=vmt_parser::from_str(vmt_str)?;
-	//println!("vmt material={:?}",material);
-	Ok(material)
-}
-
-#[derive(Debug,thiserror::Error)]
-enum LoadVMTError{
-	#[error("Bsp error {0:?}")]
-	Bsp(#[from]vbsp::BspError),
-	#[error("GetVMT error {0:?}")]
-	GetVMT(#[from]GetVMTError),
-	#[error("FromUtf8 error {0:?}")]
-	FromUtf8(#[from]std::string::FromUtf8Error),
-	#[error("Vdf error {0:?}")]
-	Vdf(#[from]vmt_parser::VdfError),
-	#[error("Vmt unsupported")]
-	Unsupported,
-	#[error("Vmt unresolved")]
-	Unresolved,
-	#[error("Vmt not found")]
-	NotFound,
-}
-fn recursive_vmt_loader<'bsp,'vpk,'a>(finder:BspFinder<'bsp,'vpk>,material:vmt_parser::material::Material)->Result<Option<Cow<'a,[u8]>>,LoadVMTError>
-	where
-		'bsp:'a,
-		'vpk:'a,
-{
-	match get_some_texture(material){
-		VMTContent::VMT(mut s)=>{
-			s.make_ascii_lowercase();
-			recursive_vmt_loader(finder,get_vmt(finder,&s)?)
-		},
-		VMTContent::VTF(s)=>{
-			let mut texture_file_name=PathBuf::from("materials");
-			texture_file_name.push(s);
-			texture_file_name.set_extension("vtf");
-			texture_file_name.as_mut_os_str().make_ascii_lowercase();
-			Ok(finder.find(texture_file_name.to_str().unwrap())?)
-		},
-		VMTContent::Patch(mat)=>recursive_vmt_loader(finder,
-			mat.resolve(|search_name|{
-				let name_lowercase=search_name.to_lowercase();
-				match finder.find(&name_lowercase)?{
-					Some(bytes)=>Ok(String::from_utf8(bytes.into_owned())?),
-					None=>Err(LoadVMTError::NotFound),
-				}
-			})?
-		),
-		VMTContent::Unsupported=>Err(LoadVMTError::Unsupported),
-		VMTContent::Unresolved=>Err(LoadVMTError::Unresolved),
-	}
-}
-fn load_texture<'bsp,'vpk,'a>(finder:BspFinder<'bsp,'vpk>,texture_name:&str)->Result<Option<Cow<'a,[u8]>>,LoadVMTError>
-	where
-		'bsp:'a,
-		'vpk:'a,
-{
-	let mut texture_file_name=PathBuf::from("materials");
-	//lower case
-	texture_file_name.push(texture_name);
-	texture_file_name.as_mut_os_str().make_ascii_lowercase();
-	//remove stem and search for both vtf and vmt files
-	let stem=texture_file_name.file_stem().unwrap().to_owned();
-	texture_file_name.pop();
-	texture_file_name.push(stem);
-	if let Some(stuff)=finder.find(texture_file_name.to_str().unwrap())?{
-		return Ok(Some(stuff));
-	}
-
-	// search for both vmt,vtf
-	let mut texture_file_name_vmt=texture_file_name.clone();
-	texture_file_name_vmt.set_extension("vmt");
-
-	let get_vmt_result=get_vmt(finder,texture_file_name_vmt.to_str().unwrap());
-	match get_vmt_result{
-		Ok(material)=>{
-			let vmt_result=recursive_vmt_loader(finder,material);
-			match vmt_result{
-				Ok(Some(stuff))=>return Ok(Some(stuff)),
-				Ok(None)
-				|Err(LoadVMTError::NotFound)=>(),
-				|Err(LoadVMTError::GetVMT(GetVMTError::NotFound))=>(),
-				Err(e)=>return Err(e),
-			}
-		}
-		|Err(GetVMTError::NotFound)=>(),
-		Err(e)=>Err(e)?,
-	}
-
-	// try looking for vtf
-	let mut texture_file_name_vtf=texture_file_name.clone();
-	texture_file_name_vtf.set_extension("vtf");
-
-	let get_vtf_result=get_vmt(finder,texture_file_name_vtf.to_str().unwrap());
-	match get_vtf_result{
-		Ok(material)=>{
-			let vtf_result=recursive_vmt_loader(finder,material);
-			match vtf_result{
-				Ok(Some(stuff))=>return Ok(Some(stuff)),
-				Ok(None)
-				|Err(LoadVMTError::NotFound)=>(),
-				|Err(LoadVMTError::GetVMT(GetVMTError::NotFound))=>(),
-				Err(e)=>return Err(e),
-			}
-		}
-		|Err(GetVMTError::NotFound)=>(),
-		Err(e)=>Err(e)?,
-	}
-
-	Ok(None)
-}
-#[derive(Debug,thiserror::Error)]
-enum ExtractTextureError{
-	#[error("Io error {0:?}")]
-	Io(#[from]std::io::Error),
-	#[error("Bsp error {0:?}")]
-	Bsp(#[from]vbsp::BspError),
-	#[error("MeshLoad error {0:?}")]
-	MeshLoad(#[from]strafesnet_bsp_loader::loader::MeshError),
-	#[error("Load VMT error {0:?}")]
-	LoadVMT(#[from]LoadVMTError),
-}
-async fn gimme_them_textures(path:&Path,vpk_list:&[strafesnet_bsp_loader::Vpk],send_texture:tokio::sync::mpsc::Sender<(Vec<u8>,String)>)->Result<(),ExtractTextureError>{
-	let bsp=vbsp::Bsp::read(tokio::fs::read(path).await?.as_ref())?;
-	let loader_bsp=strafesnet_bsp_loader::Bsp::new(bsp);
-	let bsp=loader_bsp.as_ref();
-
-	let mut texture_deferred_loader=RenderConfigDeferredLoader::new();
-	for texture in bsp.textures(){
-		texture_deferred_loader.acquire_render_config_id(Some(Cow::Borrowed(texture.name())));
-	}
-
-	let mut mesh_deferred_loader=MeshDeferredLoader::new();
-	for name in &bsp.static_props.dict.name{
-		mesh_deferred_loader.acquire_mesh_id(name.as_str());
-	}
-
-	for raw_ent in &bsp.entities{
-		let model=match raw_ent.parse(){
-			Ok(Entity::Cycler(brush))=>brush.model,
-			Ok(Entity::EnvSprite(brush))=>brush.model,
-			Ok(Entity::FuncBreakable(brush))=>brush.model,
-			Ok(Entity::FuncBrush(brush))=>brush.model,
-			Ok(Entity::FuncButton(brush))=>brush.model,
-			Ok(Entity::FuncDoor(brush))=>brush.model,
-			Ok(Entity::FuncDoorRotating(brush))=>brush.model,
-			Ok(Entity::FuncIllusionary(brush))=>brush.model,
-			Ok(Entity::FuncMonitor(brush))=>brush.model,
-			Ok(Entity::FuncMovelinear(brush))=>brush.model,
-			Ok(Entity::FuncPhysbox(brush))=>brush.model,
-			Ok(Entity::FuncPhysboxMultiplayer(brush))=>brush.model,
-			Ok(Entity::FuncRotButton(brush))=>brush.model,
-			Ok(Entity::FuncRotating(brush))=>brush.model,
-			Ok(Entity::FuncTracktrain(brush))=>brush.model,
-			Ok(Entity::FuncTrain(brush))=>brush.model,
-			Ok(Entity::FuncWall(brush))=>brush.model,
-			Ok(Entity::FuncWallToggle(brush))=>brush.model,
-			Ok(Entity::FuncWaterAnalog(brush))=>brush.model,
-			Ok(Entity::PropDoorRotating(brush))=>brush.model,
-			Ok(Entity::PropDynamic(brush))=>brush.model,
-			Ok(Entity::PropDynamicOverride(brush))=>brush.model,
-			Ok(Entity::PropPhysics(brush))=>brush.model,
-			Ok(Entity::PropPhysicsMultiplayer(brush))=>brush.model,
-			Ok(Entity::PropPhysicsOverride(brush))=>brush.model,
-			Ok(Entity::PropRagdoll(brush))=>brush.model,
-			Ok(Entity::TriggerGravity(brush))=>brush.model,
-			Ok(Entity::TriggerHurt(brush))=>brush.model,
-			Ok(Entity::TriggerLook(brush))=>brush.model,
-			Ok(Entity::TriggerMultiple(brush))=>brush.model.unwrap_or_default(),
-			Ok(Entity::TriggerOnce(brush))=>brush.model,
-			Ok(Entity::TriggerProximity(brush))=>brush.model,
-			Ok(Entity::TriggerPush(brush))=>brush.model,
-			Ok(Entity::TriggerSoundscape(brush))=>brush.model,
-			Ok(Entity::TriggerTeleport(brush))=>brush.model.unwrap_or_default(),
-			Ok(Entity::TriggerVphysicsMotion(brush))=>brush.model,
-			Ok(Entity::TriggerWind(brush))=>brush.model,
-			_=>continue,
-		};
-		match model.chars().next(){
-			Some('*')=>(),
-			_=>{
-				mesh_deferred_loader.acquire_mesh_id(model);
-			},
-		}
-	}
-
-	let finder=BspFinder{
-		bsp:&loader_bsp,
-		vpks:vpk_list
-	};
-
-	let mut mesh_loader=strafesnet_bsp_loader::loader::ModelLoader::new(finder);
-	// load models and collect requested textures
-	for model_path in mesh_deferred_loader.into_indices(){
-		let model:vmdl::Model=match mesh_loader.load(model_path){
-			Ok(model)=>model,
-			Err(e)=>{
-				println!("Model={model_path} Load model error: {e}");
-				continue;
-			},
-		};
-		for texture in model.textures(){
-			for search_path in &texture.search_paths{
-				let mut path=PathBuf::from(search_path.as_str());
-				path.push(texture.name.as_str());
-				let path=path.to_str().unwrap().to_owned();
-				texture_deferred_loader.acquire_render_config_id(Some(Cow::Owned(path)));
-			}
-		}
-	}
-
-	for texture_path in texture_deferred_loader.into_indices(){
-		match load_texture(finder,&texture_path){
-			Ok(Some(texture))=>send_texture.send(
-				(texture.into_owned(),texture_path.into_owned())
-			).await.unwrap(),
-			Ok(None)=>(),
-			Err(e)=>println!("Texture={texture_path} Load error: {e}"),
-		}
-	}
-
-	Ok(())
-}
-
-
-#[derive(Debug,thiserror::Error)]
-enum ConvertTextureError{
-	#[error("Bsp error {0:?}")]
-	Bsp(#[from]vbsp::BspError),
-	#[error("Vtf error {0:?}")]
-	Vtf(#[from]vtf::Error),
-	#[error("DDS create error {0:?}")]
-	DDS(#[from]image_dds::CreateDdsError),
-	#[error("DDS write error {0:?}")]
-	DDSWrite(#[from]image_dds::ddsfile::Error),
-	#[error("Io error {0:?}")]
-	Io(#[from]std::io::Error),
-}
-
-async fn convert_texture(texture:Vec<u8>,write_file_name:impl AsRef<Path>)->Result<(),ConvertTextureError>{
-	let image=vtf::from_bytes(&texture)?.highres_image.decode(0)?.to_rgba8();
-
-	let format=if image.width()%4!=0||image.height()%4!=0{
-		image_dds::ImageFormat::Rgba8UnormSrgb
-	}else{
-		image_dds::ImageFormat::BC7RgbaUnormSrgb
-	};
-	//this fails if the image dimensions are not a multiple of 4
-	let dds = image_dds::dds_from_image(
-		&image,
-		format,
-		image_dds::Quality::Slow,
-		image_dds::Mipmaps::GeneratedAutomatic,
-	)?;
-
-	//write dds
-	let mut dest=PathBuf::from("textures");
-	dest.push(write_file_name);
-	dest.set_extension("dds");
-	std::fs::create_dir_all(dest.parent().unwrap())?;
-	let mut writer=std::io::BufWriter::new(std::fs::File::create(dest)?);
-	dds.write(&mut writer)?;
-
-	Ok(())
-}
-
-async fn read_vpks(vpk_paths:Vec<PathBuf>,thread_limit:usize)->Vec<strafesnet_bsp_loader::Vpk>{
-	futures::stream::iter(vpk_paths).map(|vpk_path|async{
-		// idk why it doesn't want to pass out the errors but this is fatal anyways
-		tokio::task::spawn_blocking(move||Ok::<_,vpk::Error>(strafesnet_bsp_loader::Vpk::new(vpk::VPK::read(&vpk_path)?))).await.unwrap().unwrap()
-	})
-	.buffer_unordered(thread_limit)
-	.collect().await
-}
-
-async fn extract_textures(paths:Vec<PathBuf>,vpk_paths:Vec<PathBuf>)->AResult<()>{
-	tokio::try_join!(
-		tokio::fs::create_dir_all("extracted_textures"),
-		tokio::fs::create_dir_all("textures"),
-		tokio::fs::create_dir_all("meshes"),
-	)?;
-	let thread_limit=std::thread::available_parallelism()?.get();
-
-	// load vpk list and leak for static lifetime
-	let vpk_list:&[strafesnet_bsp_loader::Vpk]=read_vpks(vpk_paths,thread_limit).await.leak();
-
-	let (send_texture,mut recv_texture)=tokio::sync::mpsc::channel(thread_limit);
-	let mut it=paths.into_iter();
-	let extract_thread=tokio::spawn(async move{
-		static SEM:tokio::sync::Semaphore=tokio::sync::Semaphore::const_new(0);
-		SEM.add_permits(thread_limit);
-		while let (Ok(permit),Some(path))=(SEM.acquire().await,it.next()){
-			let send=send_texture.clone();
-			tokio::spawn(async move{
-				let result=gimme_them_textures(&path,vpk_list,send).await;
-				drop(permit);
-				match result{
-					Ok(())=>(),
-					Err(e)=>println!("Map={path:?} Decode error: {e:?}"),
-				}
-			});
-		}
-	});
-
-	// convert images
-	static SEM:tokio::sync::Semaphore=tokio::sync::Semaphore::const_new(0);
-	SEM.add_permits(thread_limit);
-	while let (Ok(permit),Some((data,dest)))=(SEM.acquire().await,recv_texture.recv().await){
-		// TODO: dedup dest?
-		tokio::spawn(async move{
-			let result=convert_texture(data,dest).await;
-			drop(permit);
-			match result{
-				Ok(())=>(),
-				Err(e)=>println!("Convert error: {e:?}"),
-			}
-		});
-	}
-	extract_thread.await?;
-	_=SEM.acquire_many(thread_limit as u32).await?;
-	Ok(())
-}
-
-fn vpk_contents(vpk_path:PathBuf)->AResult<()>{
-	let vpk_index=vpk::VPK::read(&vpk_path)?;
-	for (label,entry) in vpk_index.tree.into_iter(){
-		println!("vpk label={} entry={:?}",label,entry);
-	}
-	Ok(())
-}
-
-fn bsp_contents(path:PathBuf)->AResult<()>{
-	let bsp=vbsp::Bsp::read(std::fs::read(path)?.as_ref())?;
-	for file_name in bsp.pack.into_zip().into_inner().unwrap().file_names(){
-		println!("file_name={:?}",file_name);
-	}
-	Ok(())
-}
-
-#[derive(Debug)]
-#[expect(dead_code)]
-enum ConvertError{
-	IO(std::io::Error),
-	SNFMap(strafesnet_snf::map::Error),
-	BspRead(strafesnet_bsp_loader::ReadError),
-	BspLoad(strafesnet_bsp_loader::LoadError),
-}
-impl std::fmt::Display for ConvertError{
-	fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
-		write!(f,"{self:?}")
-	}
-}
-impl std::error::Error for ConvertError{}
-
-async fn convert_to_snf(path:&Path,vpk_list:&[strafesnet_bsp_loader::Vpk],output_folder:PathBuf)->AResult<()>{
-	let entire_file=tokio::fs::read(path).await?;
-
-	let bsp=strafesnet_bsp_loader::read(
-		std::io::Cursor::new(entire_file)
-	).map_err(ConvertError::BspRead)?;
-
-	let map=bsp.to_snf(LoadFailureMode::DefaultToNone,vpk_list).map_err(ConvertError::BspLoad)?;
-
-	let mut dest=output_folder;
-	dest.push(path.file_stem().unwrap());
-	dest.set_extension("snfm");
-	let file=std::fs::File::create(dest).map_err(ConvertError::IO)?;
-
-	strafesnet_snf::map::write_map(file,map).map_err(ConvertError::SNFMap)?;
-
-	Ok(())
-}
-async fn source_to_snf(paths:Vec<PathBuf>,output_folder:PathBuf,vpk_paths:Vec<PathBuf>)->AResult<()>{
-	let start=std::time::Instant::now();
-
-	let thread_limit=std::thread::available_parallelism()?.get();
-
-	// load vpk list and leak for static lifetime
-	let vpk_list:&[strafesnet_bsp_loader::Vpk]=read_vpks(vpk_paths,thread_limit).await.leak();
-
-	let mut it=paths.into_iter();
-	static SEM:tokio::sync::Semaphore=tokio::sync::Semaphore::const_new(0);
-	SEM.add_permits(thread_limit);
-
-	while let (Ok(permit),Some(path))=(SEM.acquire().await,it.next()){
-		let output_folder=output_folder.clone();
-		tokio::spawn(async move{
-			let result=convert_to_snf(path.as_path(),vpk_list,output_folder).await;
-			drop(permit);
-			match result{
-				Ok(())=>(),
-				Err(e)=>println!("Convert error: {e:?}"),
-			}
-		});
-	}
-	_=SEM.acquire_many(thread_limit as u32).await.unwrap();
-
-	println!("elapsed={:?}", start.elapsed());
-	Ok(())
-}

map-tool/src/source/cli.rs

@@ -0,0 +1,300 @@
+use std::path::PathBuf;
+use std::borrow::Cow;
+use strafesnet_deferred_loader::loader::Loader;
+use strafesnet_deferred_loader::deferred_loader::{MeshDeferredLoader,RenderConfigDeferredLoader};
+use vbsp_entities_css::Entity;
+
+use anyhow::Result as AResult;
+use futures::StreamExt;
+
+use super::{convert_texture_to_dds,convert_to_snf,load_texture};
+use super::{BspFinder,ConvertTextureError,LoadVMTError};
+
+#[derive(clap::Subcommand)]
+pub enum Commands{
+	SourceToSNF(SourceToSNFSubcommand),
+	ExtractTextures(ExtractTexturesSubcommand),
+	VPKContents(VPKContentsSubcommand),
+	BSPContents(BSPContentsSubcommand),
+}
+
+#[derive(clap::Args)]
+pub struct SourceToSNFSubcommand{
+	#[arg(long)]
+	output_folder:PathBuf,
+	#[arg(required=true)]
+	input_files:Vec<PathBuf>,
+	#[arg(long)]
+	vpks:Vec<PathBuf>,
+}
+#[derive(clap::Args)]
+pub struct ExtractTexturesSubcommand{
+	#[arg(required=true)]
+	bsp_files:Vec<PathBuf>,
+	#[arg(long)]
+	vpks:Vec<PathBuf>,
+}
+#[derive(clap::Args)]
+pub struct VPKContentsSubcommand{
+	#[arg(long)]
+	input_file:PathBuf,
+}
+#[derive(clap::Args)]
+pub struct BSPContentsSubcommand{
+	#[arg(long)]
+	input_file:PathBuf,
+}
+
+impl Commands{
+	pub async fn run(self)->AResult<()>{
+		match self{
+			Commands::SourceToSNF(subcommand)=>source_to_snf(subcommand.input_files,subcommand.output_folder,subcommand.vpks).await,
+			Commands::ExtractTextures(subcommand)=>extract_textures(subcommand.bsp_files,subcommand.vpks).await,
+			Commands::VPKContents(subcommand)=>vpk_contents(subcommand.input_file),
+			Commands::BSPContents(subcommand)=>bsp_contents(subcommand.input_file),
+		}
+	}
+}
+
+#[derive(Debug,thiserror::Error)]
+enum ExtractTextureError{
+	#[error("Io error {0:?}")]
+	Io(#[from]std::io::Error),
+	#[error("Bsp error {0:?}")]
+	Bsp(#[from]vbsp::BspError),
+	#[error("MeshLoad error {0:?}")]
+	MeshLoad(#[from]strafesnet_bsp_loader::loader::MeshError),
+	#[error("Load VMT error {0:?}")]
+	LoadVMT(#[from]LoadVMTError),
+}
+async fn gimme_them_textures(path:&std::path::Path,vpk_list:&[strafesnet_bsp_loader::Vpk],send_texture:tokio::sync::mpsc::Sender<(Vec<u8>,String)>)->Result<(),ExtractTextureError>{
+	let bsp=vbsp::Bsp::read(tokio::fs::read(path).await?.as_ref())?;
+	let loader_bsp=strafesnet_bsp_loader::Bsp::new(bsp);
+	let bsp=loader_bsp.as_ref();
+
+	let mut texture_deferred_loader=RenderConfigDeferredLoader::new();
+	for texture in bsp.textures(){
+		texture_deferred_loader.acquire_render_config_id(Some(Cow::Borrowed(texture.name())));
+	}
+
+	let mut mesh_deferred_loader=MeshDeferredLoader::new();
+	for name in &bsp.static_props.dict.name{
+		mesh_deferred_loader.acquire_mesh_id(name.as_str());
+	}
+
+	for raw_ent in &bsp.entities{
+		let model=match raw_ent.parse(){
+			Ok(Entity::Cycler(brush))=>brush.model,
+			Ok(Entity::EnvSprite(brush))=>brush.model,
+			Ok(Entity::FuncBreakable(brush))=>brush.model,
+			Ok(Entity::FuncBrush(brush))=>brush.model,
+			Ok(Entity::FuncButton(brush))=>brush.model,
+			Ok(Entity::FuncDoor(brush))=>brush.model,
+			Ok(Entity::FuncDoorRotating(brush))=>brush.model,
+			Ok(Entity::FuncIllusionary(brush))=>brush.model,
+			Ok(Entity::FuncMonitor(brush))=>brush.model,
+			Ok(Entity::FuncMovelinear(brush))=>brush.model,
+			Ok(Entity::FuncPhysbox(brush))=>brush.model,
+			Ok(Entity::FuncPhysboxMultiplayer(brush))=>brush.model,
+			Ok(Entity::FuncRotButton(brush))=>brush.model,
+			Ok(Entity::FuncRotating(brush))=>brush.model,
+			Ok(Entity::FuncTracktrain(brush))=>brush.model,
+			Ok(Entity::FuncTrain(brush))=>brush.model,
+			Ok(Entity::FuncWall(brush))=>brush.model,
+			Ok(Entity::FuncWallToggle(brush))=>brush.model,
+			Ok(Entity::FuncWaterAnalog(brush))=>brush.model,
+			Ok(Entity::PropDoorRotating(brush))=>brush.model,
+			Ok(Entity::PropDynamic(brush))=>brush.model,
+			Ok(Entity::PropDynamicOverride(brush))=>brush.model,
+			Ok(Entity::PropPhysics(brush))=>brush.model,
+			Ok(Entity::PropPhysicsMultiplayer(brush))=>brush.model,
+			Ok(Entity::PropPhysicsOverride(brush))=>brush.model,
+			Ok(Entity::PropRagdoll(brush))=>brush.model,
+			Ok(Entity::TriggerGravity(brush))=>brush.model,
+			Ok(Entity::TriggerHurt(brush))=>brush.model,
+			Ok(Entity::TriggerLook(brush))=>brush.model,
+			Ok(Entity::TriggerMultiple(brush))=>brush.model.unwrap_or_default(),
+			Ok(Entity::TriggerOnce(brush))=>brush.model,
+			Ok(Entity::TriggerProximity(brush))=>brush.model,
+			Ok(Entity::TriggerPush(brush))=>brush.model,
+			Ok(Entity::TriggerSoundscape(brush))=>brush.model,
+			Ok(Entity::TriggerTeleport(brush))=>brush.model.unwrap_or_default(),
+			Ok(Entity::TriggerVphysicsMotion(brush))=>brush.model,
+			Ok(Entity::TriggerWind(brush))=>brush.model,
+			_=>continue,
+		};
+		match model.chars().next(){
+			Some('*')=>(),
+			_=>{
+				mesh_deferred_loader.acquire_mesh_id(model);
+			},
+		}
+	}
+
+	let finder=BspFinder{
+		bsp:&loader_bsp,
+		vpks:vpk_list
+	};
+
+	let mut mesh_loader=strafesnet_bsp_loader::loader::ModelLoader::new(finder);
+	// load models and collect requested textures
+	for model_path in mesh_deferred_loader.into_indices(){
+		let model:vmdl::Model=match mesh_loader.load(model_path){
+			Ok(model)=>model,
+			Err(e)=>{
+				println!("Model={model_path} Load model error: {e}");
+				continue;
+			},
+		};
+		for texture in model.textures(){
+			for search_path in &texture.search_paths{
+				let mut path=PathBuf::from(search_path.as_str());
+				path.push(texture.name.as_str());
+				let path=path.to_str().unwrap().to_owned();
+				texture_deferred_loader.acquire_render_config_id(Some(Cow::Owned(path)));
+			}
+		}
+	}
+
+	for texture_path in texture_deferred_loader.into_indices(){
+		match load_texture(finder,&texture_path){
+			Ok(Some(texture))=>send_texture.send(
+				(texture.into_owned(),texture_path.into_owned())
+			).await.unwrap(),
+			Ok(None)=>(),
+			Err(e)=>println!("Texture={texture_path} Load error: {e}"),
+		}
+	}
+
+	Ok(())
+}
+
+#[derive(Debug,thiserror::Error)]
+enum CliConvertTextureError{
+	#[error("Io error {0:?}")]
+	Io(#[from]std::io::Error),
+	#[error("ConvertTexture error {0:?}")]
+	ConvertTexture(#[from]ConvertTextureError),
+}
+
+async fn cli_convert_texture(texture:Vec<u8>,write_file_name:impl AsRef<std::path::Path>)->Result<(),CliConvertTextureError>{
+	let dds=convert_texture_to_dds(&texture)?;
+
+	let mut dest=PathBuf::from("textures");
+	dest.push(write_file_name);
+	dest.set_extension("dds");
+	std::fs::create_dir_all(dest.parent().unwrap())?;
+	std::fs::write(&dest,&dds)?;
+
+	Ok(())
+}
+
+async fn async_read_vpks(vpk_paths:Vec<PathBuf>,thread_limit:usize)->Vec<strafesnet_bsp_loader::Vpk>{
+	futures::stream::iter(vpk_paths).map(|vpk_path|async{
+		tokio::task::spawn_blocking(move||Ok::<_,vpk::Error>(strafesnet_bsp_loader::Vpk::new(vpk::VPK::read(&vpk_path)?))).await.unwrap().unwrap()
+	})
+	.buffer_unordered(thread_limit)
+	.collect().await
+}
+
+async fn extract_textures(paths:Vec<PathBuf>,vpk_paths:Vec<PathBuf>)->AResult<()>{
+	tokio::try_join!(
+		tokio::fs::create_dir_all("extracted_textures"),
+		tokio::fs::create_dir_all("textures"),
+		tokio::fs::create_dir_all("meshes"),
+	)?;
+	let thread_limit=std::thread::available_parallelism()?.get();
+
+	// load vpk list and leak for static lifetime
+	let vpk_list:&[strafesnet_bsp_loader::Vpk]=async_read_vpks(vpk_paths,thread_limit).await.leak();
+
+	let (send_texture,mut recv_texture)=tokio::sync::mpsc::channel(thread_limit);
+	let mut it=paths.into_iter();
+	let extract_thread=tokio::spawn(async move{
+		static SEM:tokio::sync::Semaphore=tokio::sync::Semaphore::const_new(0);
+		SEM.add_permits(thread_limit);
+		while let (Ok(permit),Some(path))=(SEM.acquire().await,it.next()){
+			let send=send_texture.clone();
+			tokio::spawn(async move{
+				let result=gimme_them_textures(&path,vpk_list,send).await;
+				drop(permit);
+				match result{
+					Ok(())=>(),
+					Err(e)=>println!("Map={path:?} Decode error: {e:?}"),
+				}
+			});
+		}
+	});
+
+	// convert images
+	static SEM:tokio::sync::Semaphore=tokio::sync::Semaphore::const_new(0);
+	SEM.add_permits(thread_limit);
+	while let (Ok(permit),Some((data,dest)))=(SEM.acquire().await,recv_texture.recv().await){
+		// TODO: dedup dest?
+		tokio::spawn(async move{
+			let result=cli_convert_texture(data,dest).await;
+			drop(permit);
+			match result{
+				Ok(())=>(),
+				Err(e)=>println!("Convert error: {e:?}"),
+			}
+		});
+	}
+	extract_thread.await?;
+	_=SEM.acquire_many(thread_limit as u32).await?;
+	Ok(())
+}
+
+fn vpk_contents(vpk_path:PathBuf)->AResult<()>{
+	let vpk_index=vpk::VPK::read(&vpk_path)?;
+	for (label,entry) in vpk_index.tree.into_iter(){
+		println!("vpk label={} entry={:?}",label,entry);
+	}
+	Ok(())
+}
+
+fn bsp_contents(path:PathBuf)->AResult<()>{
+	let bsp=vbsp::Bsp::read(std::fs::read(path)?.as_ref())?;
+	for file_name in bsp.pack.into_zip().into_inner().unwrap().file_names(){
+		println!("file_name={:?}",file_name);
+	}
+	Ok(())
+}
+
+async fn source_to_snf(paths:Vec<PathBuf>,output_folder:PathBuf,vpk_paths:Vec<PathBuf>)->AResult<()>{
+	let start=std::time::Instant::now();
+
+	let thread_limit=std::thread::available_parallelism()?.get();
+
+	// load vpk list and leak for static lifetime
+	let vpk_list:&[strafesnet_bsp_loader::Vpk]=async_read_vpks(vpk_paths,thread_limit).await.leak();
+
+	let mut it=paths.into_iter();
+	static SEM:tokio::sync::Semaphore=tokio::sync::Semaphore::const_new(0);
+	SEM.add_permits(thread_limit);
+
+	while let (Ok(permit),Some(path))=(SEM.acquire().await,it.next()){
+		let output_folder=output_folder.clone();
+		tokio::spawn(async move{
+			let result=match tokio::fs::read(&path).await{
+				Ok(data)=>convert_to_snf(&data,vpk_list).map_err(|e|anyhow::anyhow!("{e:?}")).and_then(|snf_buf|{
+					let mut dest=output_folder;
+					dest.push(path.file_stem().unwrap());
+					dest.set_extension("snfm");
+					std::fs::write(dest,&snf_buf)?;
+					Ok(())
+				}),
+				Err(e)=>Err(e.into()),
+			};
+			drop(permit);
+			match result{
+				Ok(())=>(),
+				Err(e)=>println!("Convert error: {e:?}"),
+			}
+		});
+	}
+	_=SEM.acquire_many(thread_limit as u32).await.unwrap();
+
+	println!("elapsed={:?}", start.elapsed());
+	Ok(())
+}

map-tool/src/source/mod.rs

@@ -0,0 +1,246 @@
+#[cfg(feature="cli")]
+mod cli;
+#[cfg(feature="cli")]
+pub use cli::Commands;
+#[cfg(feature="cli")]
+mod loader;
+
+use std::path::PathBuf;
+use std::borrow::Cow;
+use std::io::Cursor;
+use strafesnet_bsp_loader::loader::BspFinder;
+use strafesnet_deferred_loader::deferred_loader::LoadFailureMode;
+
+enum VMTContent{
+	VMT(String),
+	VTF(String),
+	Patch(vmt_parser::material::PatchMaterial),
+	Unsupported,//don't want to deal with whatever vmt variant
+	Unresolved,//could not locate a texture because of vmt content
+}
+impl VMTContent{
+	fn vtf(opt:Option<String>)->Self{
+		match opt{
+			Some(s)=>Self::VTF(s),
+			None=>Self::Unresolved,
+		}
+	}
+}
+
+fn get_some_texture(material:vmt_parser::material::Material)->VMTContent{
+	//just grab some texture from somewhere for now
+	match material{
+		vmt_parser::material::Material::LightMappedGeneric(mat)=>VMTContent::vtf(Some(mat.base_texture)),
+		vmt_parser::material::Material::VertexLitGeneric(mat)=>VMTContent::vtf(mat.base_texture.or(mat.decal_texture)),//this just dies if there is none
+		vmt_parser::material::Material::VertexLitGenericDx6(mat)=>VMTContent::vtf(mat.base_texture.or(mat.decal_texture)),
+		vmt_parser::material::Material::UnlitGeneric(mat)=>VMTContent::vtf(mat.base_texture),
+		vmt_parser::material::Material::UnlitTwoTexture(mat)=>VMTContent::vtf(mat.base_texture),
+		vmt_parser::material::Material::Water(mat)=>VMTContent::vtf(mat.base_texture),
+		vmt_parser::material::Material::WorldVertexTransition(mat)=>VMTContent::vtf(Some(mat.base_texture)),
+		vmt_parser::material::Material::EyeRefract(mat)=>VMTContent::vtf(Some(mat.cornea_texture)),
+		vmt_parser::material::Material::SubRect(mat)=>VMTContent::VMT(mat.material),//recursive
+		vmt_parser::material::Material::Sprite(mat)=>VMTContent::vtf(Some(mat.base_texture)),
+		vmt_parser::material::Material::SpriteCard(mat)=>VMTContent::vtf(mat.base_texture),
+		vmt_parser::material::Material::Cable(mat)=>VMTContent::vtf(Some(mat.base_texture)),
+		vmt_parser::material::Material::Refract(mat)=>VMTContent::vtf(mat.base_texture),
+		vmt_parser::material::Material::Modulate(mat)=>VMTContent::vtf(Some(mat.base_texture)),
+		vmt_parser::material::Material::DecalModulate(mat)=>VMTContent::vtf(Some(mat.base_texture)),
+		vmt_parser::material::Material::Sky(mat)=>VMTContent::vtf(Some(mat.base_texture)),
+		vmt_parser::material::Material::Replacements(_mat)=>VMTContent::Unsupported,
+		vmt_parser::material::Material::Patch(mat)=>VMTContent::Patch(mat),
+		_=>unreachable!(),
+	}
+}
+
+#[derive(Debug,thiserror::Error)]
+pub enum GetVMTError{
+	#[error("Bsp error {0:?}")]
+	Bsp(#[from]vbsp::BspError),
+	#[error("Utf8 error {0:?}")]
+	Utf8(#[from]std::str::Utf8Error),
+	#[error("Vdf error {0:?}")]
+	Vdf(#[from]vmt_parser::VdfError),
+	#[error("Vmt not found")]
+	NotFound,
+}
+
+fn get_vmt(finder:BspFinder,search_name:&str)->Result<vmt_parser::material::Material,GetVMTError>{
+	let vmt_data=finder.find(search_name)?.ok_or(GetVMTError::NotFound)?;
+	//decode vmt and then write
+	let vmt_str=core::str::from_utf8(&vmt_data)?;
+	let material=vmt_parser::from_str(vmt_str)?;
+	Ok(material)
+}
+
+#[derive(Debug,thiserror::Error)]
+pub enum LoadVMTError{
+	#[error("Bsp error {0:?}")]
+	Bsp(#[from]vbsp::BspError),
+	#[error("GetVMT error {0:?}")]
+	GetVMT(#[from]GetVMTError),
+	#[error("FromUtf8 error {0:?}")]
+	FromUtf8(#[from]std::string::FromUtf8Error),
+	#[error("Vdf error {0:?}")]
+	Vdf(#[from]vmt_parser::VdfError),
+	#[error("Vmt unsupported")]
+	Unsupported,
+	#[error("Vmt unresolved")]
+	Unresolved,
+	#[error("Vmt not found")]
+	NotFound,
+}
+fn recursive_vmt_loader<'bsp,'vpk,'a>(finder:BspFinder<'bsp,'vpk>,material:vmt_parser::material::Material)->Result<Option<Cow<'a,[u8]>>,LoadVMTError>
+	where
+		'bsp:'a,
+		'vpk:'a,
+{
+	match get_some_texture(material){
+		VMTContent::VMT(mut s)=>{
+			s.make_ascii_lowercase();
+			recursive_vmt_loader(finder,get_vmt(finder,&s)?)
+		},
+		VMTContent::VTF(s)=>{
+			let mut texture_file_name=PathBuf::from("materials");
+			texture_file_name.push(s);
+			texture_file_name.set_extension("vtf");
+			texture_file_name.as_mut_os_str().make_ascii_lowercase();
+			Ok(finder.find(texture_file_name.to_str().unwrap())?)
+		},
+		VMTContent::Patch(mat)=>recursive_vmt_loader(finder,
+			mat.resolve(|search_name|{
+				let name_lowercase=search_name.to_lowercase();
+				match finder.find(&name_lowercase)?{
+					Some(bytes)=>Ok(String::from_utf8(bytes.into_owned())?),
+					None=>Err(LoadVMTError::NotFound),
+				}
+			})?
+		),
+		VMTContent::Unsupported=>Err(LoadVMTError::Unsupported),
+		VMTContent::Unresolved=>Err(LoadVMTError::Unresolved),
+	}
+}
+pub fn load_texture<'bsp,'vpk,'a>(finder:BspFinder<'bsp,'vpk>,texture_name:&str)->Result<Option<Cow<'a,[u8]>>,LoadVMTError>
+	where
+		'bsp:'a,
+		'vpk:'a,
+{
+	let mut texture_file_name=PathBuf::from("materials");
+	//lower case
+	texture_file_name.push(texture_name);
+	texture_file_name.as_mut_os_str().make_ascii_lowercase();
+	//remove stem and search for both vtf and vmt files
+	let stem=texture_file_name.file_stem().unwrap().to_owned();
+	texture_file_name.pop();
+	texture_file_name.push(stem);
+	if let Some(stuff)=finder.find(texture_file_name.to_str().unwrap())?{
+		return Ok(Some(stuff));
+	}
+
+	// search for both vmt,vtf
+	let mut texture_file_name_vmt=texture_file_name.clone();
+	texture_file_name_vmt.set_extension("vmt");
+
+	let get_vmt_result=get_vmt(finder,texture_file_name_vmt.to_str().unwrap());
+	match get_vmt_result{
+		Ok(material)=>{
+			let vmt_result=recursive_vmt_loader(finder,material);
+			match vmt_result{
+				Ok(Some(stuff))=>return Ok(Some(stuff)),
+				Ok(None)
+				|Err(LoadVMTError::NotFound)=>(),
+				|Err(LoadVMTError::GetVMT(GetVMTError::NotFound))=>(),
+				Err(e)=>return Err(e),
+			}
+		}
+		|Err(GetVMTError::NotFound)=>(),
+		Err(e)=>Err(e)?,
+	}
+
+	// try looking for vtf
+	let mut texture_file_name_vtf=texture_file_name.clone();
+	texture_file_name_vtf.set_extension("vtf");
+
+	let get_vtf_result=get_vmt(finder,texture_file_name_vtf.to_str().unwrap());
+	match get_vtf_result{
+		Ok(material)=>{
+			let vtf_result=recursive_vmt_loader(finder,material);
+			match vtf_result{
+				Ok(Some(stuff))=>return Ok(Some(stuff)),
+				Ok(None)
+				|Err(LoadVMTError::NotFound)=>(),
+				|Err(LoadVMTError::GetVMT(GetVMTError::NotFound))=>(),
+				Err(e)=>return Err(e),
+			}
+		}
+		|Err(GetVMTError::NotFound)=>(),
+		Err(e)=>Err(e)?,
+	}
+
+	Ok(None)
+}
+
+#[derive(Debug)]
+pub enum ConvertError{
+	IO(std::io::Error),
+	SNFMap(strafesnet_snf::map::Error),
+	BspRead(strafesnet_bsp_loader::ReadError),
+	BspLoad(strafesnet_bsp_loader::LoadError),
+}
+impl std::fmt::Display for ConvertError{
+	fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
+		write!(f,"{self:?}")
+	}
+}
+impl std::error::Error for ConvertError{}
+
+pub fn convert_to_snf(bsp_data:&[u8],vpk_list:&[strafesnet_bsp_loader::Vpk])->Result<Vec<u8>,ConvertError>{
+	let bsp=strafesnet_bsp_loader::read(
+		Cursor::new(bsp_data)
+	).map_err(ConvertError::BspRead)?;
+
+	let mut mesh_loader=loader::MeshLoader::new(loader::BspFinder{bsp:self,vpks:vpk_list},&mut texture_deferred_loader);
+	let mut texture_loader=loader::TextureLoader::new();
+	let map=bsp.to_snf(LoadFailureMode::DefaultToNone,mesh_loader,texture_loader).map_err(ConvertError::BspLoad)?;
+
+	let mut snf_buf=Vec::new();
+	strafesnet_snf::map::write_map(Cursor::new(&mut snf_buf),map).map_err(ConvertError::SNFMap)?;
+
+	Ok(snf_buf)
+}
+
+#[derive(Debug,thiserror::Error)]
+pub enum ConvertTextureError{
+	#[error("Vtf error {0:?}")]
+	Vtf(#[from]vtf::Error),
+	#[error("DDS create error {0:?}")]
+	DDS(#[from]image_dds::CreateDdsError),
+	#[error("DDS write error {0:?}")]
+	DDSWrite(#[from]image_dds::ddsfile::Error),
+}
+
+pub fn convert_texture_to_dds(vtf_data:&[u8])->Result<Vec<u8>,ConvertTextureError>{
+	let vtf_vec=vtf_data.to_vec();
+	let image=vtf::from_bytes(&vtf_vec)?.highres_image.decode(0)?.to_rgba8();
+
+	let format=if image.width()%4!=0||image.height()%4!=0{
+		image_dds::ImageFormat::Rgba8UnormSrgb
+	}else{
+		image_dds::ImageFormat::BC7RgbaUnormSrgb
+	};
+	let dds=image_dds::dds_from_image(
+		&image,
+		format,
+		image_dds::Quality::Slow,
+		image_dds::Mipmaps::GeneratedAutomatic,
+	)?;
+
+	let mut buf=Vec::new();
+	dds.write(&mut Cursor::new(&mut buf))?;
+	Ok(buf)
+}
+
+pub fn read_vpks(vpk_paths:&[PathBuf])->Result<Vec<strafesnet_bsp_loader::Vpk>,vpk::Error>{
+	vpk_paths.iter().map(|vpk_path|{
+		Ok(strafesnet_bsp_loader::Vpk::new(vpk::VPK::read(vpk_path)?))
+	}).collect()
+}

strafe-client/Cargo.toml

@@ -16,18 +16,18 @@ source = ["dep:strafesnet_deferred_loader", "dep:strafesnet_bsp_loader"]
 roblox = ["dep:strafesnet_deferred_loader", "dep:strafesnet_rbx_loader"]
 
 [dependencies]
-glam = "0.30.0"
+glam.workspace = true
 parking_lot = "0.12.1"
 pollster = "0.4.0"
-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", 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 }
+strafesnet_bsp_loader = { workspace = true, optional = true }
+strafesnet_common.workspace = true
+strafesnet_deferred_loader = { workspace = true, optional = true }
+strafesnet_graphics.workspace = true
+strafesnet_physics.workspace = true
+strafesnet_rbx_loader = { workspace = true, optional = true }
+strafesnet_session.workspace = true
+strafesnet_settings.workspace = true
+strafesnet_snf = { workspace = true, optional = true }
 wgpu = "28.0.0"
 winit = "0.30.7"
 

strafe-client/src/graphics_worker.rs

@@ -37,7 +37,8 @@ pub fn new(
 				config.width=size.width.max(1);
 				config.height=size.height.max(1);
 				surface.configure(&device,&config);
-				graphics.resize(&device,&config,&user_settings);
+				let fov=user_settings.calculate_fov(1.0,&glam::uvec2(config.width,config.height)).as_vec2();
+				graphics.resize(&device,&config,fov);
 				println!("Resize took {:?}",t0.elapsed());
 			}
 			Instruction::Render(frame_state)=>{
@@ -56,7 +57,7 @@ pub fn new(
 					..wgpu::TextureViewDescriptor::default()
 				});
 
-				graphics.render(&view,&device,&queue,frame_state);
+				graphics.render(&view,&device,&queue,graphics::view_inv(frame_state.pos(),frame_state.angles()));
 
 				frame.present();
 			}

strafe-client/src/main.rs

@@ -9,5 +9,5 @@ mod graphics_worker;
 const TITLE:&'static str=concat!("Strafe Client v",env!("CARGO_PKG_VERSION"));
 
 fn main(){
-	setup::setup_and_start(TITLE);
+	pollster::block_on(setup::setup_and_start(TITLE));
 }

strafe-client/src/setup.rs

@@ -1,199 +1,41 @@
-fn optional_features()->wgpu::Features{
-	wgpu::Features::TEXTURE_COMPRESSION_ASTC
-	|wgpu::Features::TEXTURE_COMPRESSION_ETC2
-}
-fn required_features()->wgpu::Features{
-	wgpu::Features::TEXTURE_COMPRESSION_BC
-}
-fn required_downlevel_capabilities()->wgpu::DownlevelCapabilities{
-	wgpu::DownlevelCapabilities{
-		flags:wgpu::DownlevelFlags::empty(),
-		shader_model:wgpu::ShaderModel::Sm5,
-		..wgpu::DownlevelCapabilities::default()
-	}
-}
+use strafesnet_graphics::setup;
 
-struct SetupContextPartial1{
-	backends:wgpu::Backends,
-	instance:wgpu::Instance,
-}
 fn create_window(title:&str,event_loop:&winit::event_loop::EventLoop<()>)->Result<winit::window::Window,winit::error::OsError>{
 	let mut attr=winit::window::WindowAttributes::default();
 	attr=attr.with_title(title);
 	event_loop.create_window(attr)
 }
-fn create_instance()->SetupContextPartial1{
-	let backends=wgpu::Backends::from_env().unwrap_or_default();
-	SetupContextPartial1{
-		backends,
-		instance:Default::default(),
-	}
-}
-impl SetupContextPartial1{
-	fn create_surface<'a>(self,window:&'a winit::window::Window)->Result<SetupContextPartial2<'a>,wgpu::CreateSurfaceError>{
-		Ok(SetupContextPartial2{
-			backends:self.backends,
-			surface:self.instance.create_surface(window)?,
-			instance:self.instance,
-		})
-	}
-}
-struct SetupContextPartial2<'a>{
-	backends:wgpu::Backends,
-	instance:wgpu::Instance,
-	surface:wgpu::Surface<'a>,
-}
-impl<'a> SetupContextPartial2<'a>{
-	fn pick_adapter(self)->SetupContextPartial3<'a>{
-		let adapter;
 
-		//TODO: prefer adapter that implements optional features
-		//let optional_features=optional_features();
-		let required_features=required_features();
-
-		//no helper function smh gotta write it myself
-		let adapters=pollster::block_on(self.instance.enumerate_adapters(self.backends));
-
-		let mut chosen_adapter=None;
-		let mut chosen_adapter_score=0;
-		for adapter in adapters {
-			if !adapter.is_surface_supported(&self.surface) {
-				continue;
-			}
-
-			let score=match adapter.get_info().device_type{
-				wgpu::DeviceType::IntegratedGpu=>3,
-				wgpu::DeviceType::DiscreteGpu=>4,
-				wgpu::DeviceType::VirtualGpu=>2,
-				wgpu::DeviceType::Other|wgpu::DeviceType::Cpu=>1,
-			};
-
-			let adapter_features=adapter.features();
-			if chosen_adapter_score<score&&adapter_features.contains(required_features) {
-				chosen_adapter_score=score;
-				chosen_adapter=Some(adapter);
-			}
-		}
-
-		if let Some(maybe_chosen_adapter)=chosen_adapter{
-			adapter=maybe_chosen_adapter;
-		}else{
-			panic!("No suitable GPU adapters found on the system!");
-		}
-
-
-		let adapter_info=adapter.get_info();
-		println!("Using {} ({:?})", adapter_info.name, adapter_info.backend);
-
-		let required_downlevel_capabilities=required_downlevel_capabilities();
-		let downlevel_capabilities=adapter.get_downlevel_capabilities();
-		assert!(
-			downlevel_capabilities.shader_model >= required_downlevel_capabilities.shader_model,
-			"Adapter does not support the minimum shader model required to run this example: {:?}",
-			required_downlevel_capabilities.shader_model
-		);
-		assert!(
-			downlevel_capabilities
-				.flags
-				.contains(required_downlevel_capabilities.flags),
-			"Adapter does not support the downlevel capabilities required to run this example: {:?}",
-			required_downlevel_capabilities.flags - downlevel_capabilities.flags
-		);
-		SetupContextPartial3{
-			surface:self.surface,
-			adapter,
-		}
-	}
-}
-struct SetupContextPartial3<'a>{
-	surface:wgpu::Surface<'a>,
-	adapter:wgpu::Adapter,
-}
-impl<'a> SetupContextPartial3<'a>{
-	fn request_device(self)->SetupContextPartial4<'a>{
-		let optional_features=optional_features();
-		let required_features=required_features();
-
-		// Make sure we use the texture resolution limits from the adapter, so we can support images the size of the surface.
-		let needed_limits=strafesnet_graphics::graphics::required_limits().using_resolution(self.adapter.limits());
-
-		let (device, queue)=pollster::block_on(self.adapter
-			.request_device(
-				&wgpu::DeviceDescriptor{
-					label:None,
-					required_features:(optional_features&self.adapter.features())|required_features,
-					required_limits:needed_limits,
-					memory_hints:wgpu::MemoryHints::Performance,
-					trace:wgpu::Trace::Off,
-					experimental_features:wgpu::ExperimentalFeatures::disabled(),
-				},
-			))
-			.expect("Unable to find a suitable GPU adapter!");
-
-		SetupContextPartial4{
-			surface:self.surface,
-			adapter:self.adapter,
-			device,
-			queue,
-		}
-	}
-}
-struct SetupContextPartial4<'a>{
-	surface:wgpu::Surface<'a>,
-	adapter:wgpu::Adapter,
-	device:wgpu::Device,
-	queue:wgpu::Queue,
-}
-impl<'a> SetupContextPartial4<'a>{
-	fn configure_surface(self,size:&'a winit::dpi::PhysicalSize<u32>)->SetupContext<'a>{
-		let mut config=self.surface
-			.get_default_config(&self.adapter, size.width, size.height)
-			.expect("Surface isn't supported by the adapter.");
-		let surface_view_format=config.format.add_srgb_suffix();
-		config.view_formats.push(surface_view_format);
-		config.present_mode=wgpu::PresentMode::AutoNoVsync;
-		self.surface.configure(&self.device, &config);
-
-		SetupContext{
-			surface:self.surface,
-			device:self.device,
-			queue:self.queue,
-			config,
-		}
-	}
-}
-pub struct SetupContext<'a>{
-	pub surface:wgpu::Surface<'a>,
-	pub device:wgpu::Device,
-	pub queue:wgpu::Queue,
-	pub config:wgpu::SurfaceConfiguration,
-}
-
-pub fn setup_and_start(title:&str){
+pub async fn setup_and_start(title:&str){
 	let event_loop=winit::event_loop::EventLoop::new().unwrap();
 
-	println!("Initializing the surface...");
-
-	let partial_1=create_instance();
-
 	let window=create_window(title,&event_loop).unwrap();
 
-	let partial_2=partial_1.create_surface(&window).unwrap();
+	println!("Initializing the surface...");
 
-	let partial_3=partial_2.pick_adapter();
+	let instance=setup::step1::create_instance();
 
-	let partial_4=partial_3.request_device();
+	let surface=setup::step2::create_surface(&instance,&window).unwrap();
+
+	let adapter=setup::step3::pick_adapter(&instance,&surface).await.expect("No suitable GPU adapters found on the system!");
+
+	let adapter_info=adapter.get_info();
+	println!("Using {} ({:?})", adapter_info.name, adapter_info.backend);
+
+	let (device,queue)=setup::step4::request_device(&adapter).await.unwrap();
 
 	let size=window.inner_size();
-
-	let setup_context=partial_4.configure_surface(&size);
+	let config=setup::step5::configure_surface(&adapter,&device,&surface,(size.width,size.height)).unwrap();
 
 	//dedicated thread to ping request redraw back and resize the window doesn't seem logical
 
 	//the thread that spawns the physics thread
 	let mut window_thread=crate::window::worker(
 		&window,
-		setup_context,
+		device,
+		queue,
+		surface,
+		config,
 	);
 
 	for arg in std::env::args().skip(1){

strafe-client/src/window.rs

@@ -239,7 +239,10 @@ impl WindowContext<'_>{
 }
 pub fn worker<'a>(
 	window:&'a winit::window::Window,
-	setup_context:crate::setup::SetupContext<'a>,
+	device:wgpu::Device,
+	queue:wgpu::Queue,
+	surface:wgpu::Surface<'a>,
+	config:wgpu::SurfaceConfiguration,
 )->crate::compat_worker::QNWorker<'a,TimedInstruction<Instruction,SessionTime>>{
 	// WindowContextSetup::new
 	#[cfg(feature="user-install")]
@@ -249,12 +252,13 @@ pub fn worker<'a>(
 
 	let user_settings=directories.settings();
 
-	let mut graphics=strafesnet_graphics::graphics::GraphicsState::new(&setup_context.device,&setup_context.queue,&setup_context.config);
-	graphics.load_user_settings(&user_settings);
+	let mut graphics=strafesnet_graphics::graphics::GraphicsState::new(&device,&queue,&config);
 
 	//WindowContextSetup::into_context
-	let screen_size=glam::uvec2(setup_context.config.width,setup_context.config.height);
-	let graphics_thread=crate::graphics_worker::new(graphics,setup_context.config,setup_context.surface,setup_context.device,setup_context.queue);
+	let screen_size=glam::uvec2(config.width,config.height);
+	let fov=user_settings.calculate_fov(1.0,&screen_size).as_vec2();
+	graphics.resize(&device,&config,fov);
+	let graphics_thread=crate::graphics_worker::new(graphics,config,surface,device,queue);
 	let mut window_context=WindowContext{
 		manual_mouse_lock:false,
 		mouse_pos:glam::DVec2::ZERO,