???

Cargo.toml

@@ -35,22 +35,3 @@ 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,14 +1,16 @@
 [package]
 name = "strafesnet_graphics"
-version = "0.0.4"
+version = "0.1.0"
 edition = "2024"
 
 [dependencies]
 bytemuck = { version = "1.13.1", features = ["derive"] }
 ddsfile = "0.5.1"
-glam.workspace = true
+glam = "0.30.0"
 id = { version = "0.1.0", registry = "strafesnet" }
-strafesnet_common.workspace = true
+strafesnet_common = { path = "../../lib/common", registry = "strafesnet" }
+strafesnet_session = { path = "../session", registry = "strafesnet" }
+strafesnet_settings = { path = "../settings", registry = "strafesnet" }
 wgpu = "28.0.0"
 
 [lints]

engine/graphics/src/graphics.rs

@@ -1,10 +1,16 @@
 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,
@@ -48,10 +54,6 @@ 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
@@ -73,10 +75,15 @@ 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,view_inv:glam::Mat4)->[f32;16*4]{
+	pub fn to_uniform_data(&self,pos:glam::Vec3,angles:glam::Vec2)->[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];
@@ -155,6 +162,9 @@ 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)|{
@@ -464,7 +474,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=crate::setup::required_limits().max_uniform_buffer_binding_size as usize;
+		let uniform_buffer_binding_size=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(){
@@ -624,7 +634,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!("../shaders/shader.wgsl"))),
+			source:wgpu::ShaderSource::Wgsl(Cow::Borrowed(include_str!("../../../strafe-client/src/shader.wgsl"))),
 		});
 
 		//load textures
@@ -652,10 +662,10 @@ impl GraphicsState{
 				wgpu::TextureFormat::Astc{
 					block:AstcBlock::B4x4,
 					channel:AstcChannel::UnormSrgb,
-				}=>&include_bytes!("../images/astc.dds")[..],
-				wgpu::TextureFormat::Etc2Rgb8UnormSrgb=>&include_bytes!("../images/etc2.dds")[..],
-				wgpu::TextureFormat::Bc1RgbaUnormSrgb=>&include_bytes!("../images/bc1.dds")[..],
-				wgpu::TextureFormat::Bgra8UnormSrgb=>&include_bytes!("../images/bgra.dds")[..],
+				}=>&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")[..],
 				_=>unreachable!(),
 			};
 
@@ -698,7 +708,7 @@ impl GraphicsState{
 
 		//squid
 		let squid_texture_view={
-			let bytes=include_bytes!("../images/squid.dds");
+			let bytes=include_bytes!("../../../strafe-client/images/squid.dds");
 
 			let image=ddsfile::Dds::read(&mut std::io::Cursor::new(bytes)).unwrap();
 
@@ -823,7 +833,7 @@ impl GraphicsState{
 		});
 
 		let camera=GraphicsCamera::default();
-		let camera_uniforms=camera.to_uniform_data(view_inv(glam::Vec3::ZERO,glam::Vec2::ZERO));
+		let camera_uniforms=camera.to_uniform_data(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),
@@ -880,25 +890,28 @@ impl GraphicsState{
 		&mut self,
 		device:&wgpu::Device,
 		config:&wgpu::SurfaceConfiguration,
-		fov:glam::Vec2,
+		user_settings:&settings::UserSettings,
 	){
 		self.depth_view=Self::create_depth_texture(config,device);
 		self.camera.screen_size=glam::uvec2(config.width,config.height);
-		self.camera.fov=fov;
+		self.load_user_settings(user_settings);
 	}
 	pub fn render(
 		&mut self,
 		view:&wgpu::TextureView,
 		device:&wgpu::Device,
 		queue:&wgpu::Queue,
-		camera:glam::Mat4,
+		frame_state:session::FrameState,
 	){
 		//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(camera);
+		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)
+		);
 		self.staging_belt
 			.write_buffer(
 				&mut encoder,

engine/graphics/src/lib.rs

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

engine/graphics/src/setup.rs

@@ -1,118 +0,0 @@
-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.0.1"
+version = "0.1.0"
 edition = "2024"
 
 [dependencies]
 arrayvec = "0.7.6"
-glam.workspace = true
+glam = "0.30.0"
 id = { version = "0.1.0", registry = "strafesnet" }
-strafesnet_common.workspace = true
+strafesnet_common = { path = "../../lib/common", registry = "strafesnet" }
 
 [lints]
 workspace = true

engine/physics/src/physics.rs

@@ -268,12 +268,6 @@ 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(
@@ -1879,11 +1873,10 @@ 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(state.input_state.mouse_delta());
-			state.camera.move_mouse(m0.pos-state.input_state.next_mouse.pos);
+			state.camera.move_mouse(m0.pos-state.input_state.mouse.pos);
 			state.input_state.replace_mouse(m0,m1);
 		},
-		Instruction::Misc(MiscInstruction::SetSensitivity(sensitivity))=>state.camera.set_sensitivity(sensitivity),
+		Instruction::Misc(MiscInstruction::SetSensitivity(sensitivity))=>state.camera.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),

engine/session/Cargo.toml

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

engine/session/src/session.rs

@@ -61,14 +61,6 @@ 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.workspace = true
-strafesnet_common.workspace = true
+glam = "0.30.0"
+strafesnet_common = { path = "../../lib/common", registry = "strafesnet" }
 
 [lints]
 workspace = true

integration-testing/Cargo.toml

@@ -4,12 +4,12 @@ version = "0.1.0"
 edition = "2024"
 
 [dependencies]
-glam.workspace = true
-strafesnet_common.workspace = true
-strafesnet_physics.workspace = true
-strafesnet_snf.workspace = true
+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" }
 # this is just for the primitive constructor
-strafesnet_rbx_loader.workspace = true
+strafesnet_rbx_loader = { path = "../lib/rbx_loader", registry = "strafesnet" }
 
 [lints]
 workspace = true

lib/bsp_loader/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "strafesnet_bsp_loader"
-version = "0.4.0"
+version = "0.3.1"
 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.workspace = true
-strafesnet_common.workspace = true
-strafesnet_deferred_loader.workspace = true
+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" }
 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,25 +30,26 @@ impl std::error::Error for ReadError{}
 
 
 #[derive(Debug)]
-pub enum LoadError<M,T>{
-	Mesh(M),
-	Texture(T),
+pub enum LoadError{
+	Texture(loader::TextureError),
+	Mesh(loader::MeshError),
 }
-impl<M,T> std::fmt::Display for LoadError<M,T>
-	where
-		M:std::fmt::Debug,
-		T:std::fmt::Debug,
-{
+impl std::fmt::Display for LoadError{
 	fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
 		write!(f,"{self:?}")
 	}
 }
-impl<M,T> std::error::Error for LoadError<M,T>
-where
-		M:std::fmt::Debug,
-		T:std::fmt::Debug,
-{}
-
+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)
+	}
+}
 pub struct Bsp{
 	bsp:vbsp::Bsp,
 	case_folded_file_names:std::collections::HashMap<String,String>,
@@ -83,17 +84,7 @@ impl Bsp{
 			None=>Ok(None),
 		}
 	}
-	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,
-	{
+	pub fn to_snf(&self,failure_mode:LoadFailureMode,vpk_list:&[Vpk])->Result<strafesnet_common::map::CompleteMap,LoadError>{
 		let mut texture_deferred_loader=RenderConfigDeferredLoader::new();
 		let mut mesh_deferred_loader=MeshDeferredLoader::new();
 
@@ -103,10 +94,12 @@ 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.8.6"
+version = "0.7.0"
 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 = { workspace = true, features = ["deferred-division","zeroes","wide-mul"] }
-linear_ops = { workspace = true, features = ["deferred-division","named-fields"] }
-ratio_ops = { workspace = true }
-glam.workspace = true
+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"
 id = { version = "0.1.0", registry = "strafesnet" }
 
 [lints]

lib/common/src/integer.rs

@@ -56,14 +56,6 @@ 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]
@@ -157,23 +149,10 @@ 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::*;
@@ -235,11 +214,11 @@ impl Ratio64{
 	}
 	#[inline]
 	pub const fn mul_int(&self,rhs:i64)->i64{
-		(rhs as i128*self.num as i128/self.den as i128) as i64
+		rhs*self.num/(self.den as i64)
 	}
 	#[inline]
 	pub const fn rhs_div_int(&self,rhs:i64)->i64{
-		(rhs as i128*self.den as i128/self.num as i128) as i64
+		rhs*(self.den as i64)/self.num
 	}
 	#[inline]
 	pub const fn mul_ref(&self,rhs:&Ratio64)->Ratio64{
@@ -284,6 +263,7 @@ fn integer_decode_f64(f: f64) -> (u64, i16, i8) {
 pub enum Ratio64TryFromFloatError{
 	Nan,
 	Infinite,
+	Subnormal,
 	HighlyNegativeExponent(i16),
 	HighlyPositiveExponent(i16),
 }
@@ -318,10 +298,8 @@ 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))
@@ -353,29 +331,6 @@ 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,23 +53,36 @@ impl std::fmt::Display for Error{
 impl std::error::Error for Error{}
 
 #[derive(Clone,Copy,Debug)]
-pub enum RunState{
+enum RunState{
 	Created,
 	Started{timer:TimerFixed<Realtime<PhysicsTimeInner,TimeInner>,Unpaused>},
 	Finished{timer:TimerFixed<Realtime<PhysicsTimeInner,TimeInner>,Paused>},
 }
-impl RunState{
+
+#[derive(Clone,Copy,Debug)]
+pub struct Run{
+	state:RunState,
+	flagged:Option<FlagReason>,
+}
+
+impl Run{
+	pub fn new()->Self{
+		Self{
+			state:RunState::Created,
+			flagged:None,
+		}
+	}
 	pub fn time(&self,time:PhysicsTime)->Time{
-		match &self{
+		match &self.state{
 			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{
+		match &self.state{
 			RunState::Created=>{
-				*self=RunState::Started{
+				self.state=RunState::Started{
 					timer:TimerFixed::new(time,Time::ZERO),
 				};
 				Ok(())
@@ -80,10 +93,10 @@ impl RunState{
 	}
 	pub fn finish(&mut self,time:PhysicsTime)->Result<(),Error>{
 		//this uses Copy
-		match &self{
+		match &self.state{
 			RunState::Created=>Err(Error::NotStarted),
 			RunState::Started{timer}=>{
-				*self=RunState::Finished{
+				self.state=RunState::Finished{
 					timer:timer.into_paused(time),
 				};
 				Ok(())
@@ -91,39 +104,12 @@ impl RunState{
 			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.flag_reason.is_none(){
-			self.flag_reason=Some(flag_reason);
+		if self.flagged.is_none(){
+			self.flagged=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,8 +69,10 @@ impl<In,Out> Scaled<In,Out>
 	const fn get_scale(&self)->Ratio64{
 		self.scale
 	}
-	const fn set_scale(&mut self,new_scale:Ratio64){
+	fn set_scale(&mut self,time:Time<In>,new_scale:Ratio64){
+		let new_time=self.get_time(time);
 		self.scale=new_scale;
+		self.set_time(time,new_time);
 	}
 }
 
@@ -130,7 +132,7 @@ pub struct TimerFixed<T:TimerState,P:PauseState>{
 	_paused:P,
 }
 
-//some scaled timer methods are generic across PauseState
+//scaled timer methods are generic across PauseState
 impl<P:PauseState,In,Out> TimerFixed<Scaled<In,Out>,P>
 	where Time<In>:Copy,
 {
@@ -145,22 +147,8 @@ 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){
-		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);
+		self.state.set_scale(time,new_scale)
 	}
 }
 
@@ -317,7 +305,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(new_scale),
+			Self::Paused(timer)=>timer.set_scale(time,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.6.0"
+version = "0.5.1"
 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.workspace = true
+strafesnet_common = { version = "0.7.0", path = "../common", registry = "strafesnet" }
 
 [lints]
 workspace = true

lib/fixed_wide/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "fixed_wide"
-version = "0.2.2"
+version = "0.2.1"
 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 = { workspace = true, optional = true }
+ratio_ops = { version = "0.1.0", path = "../ratio_ops", registry = "strafesnet", optional = true }
 
 [lints]
 workspace = true

lib/fixed_wide/src/fixed.rs

@@ -505,16 +505,10 @@ impl_multiplicative_assign_operator!( Fixed, DivAssign, div_assign, div_euclid )
 impl_multiplicative_operator!( Fixed, Div, div, div_euclid, Self );
 #[cfg(feature="deferred-division")]
 impl<const LHS_N:usize,const LHS_F:usize,const RHS_N:usize,const RHS_F:usize> core::ops::Div<Fixed<RHS_N,RHS_F>> for Fixed<LHS_N,LHS_F>{
-	type Output=ratio_ops::ratio::Ratio<Fixed<LHS_N,LHS_F>,Fixed<RHS_N,RHS_F>>;
+	type Output=crate::ratio::Ratio<LHS_N,RHS_N,LHS_F,RHS_F>;
 	#[inline]
 	fn div(self, other: Fixed<RHS_N,RHS_F>)->Self::Output{
-		ratio_ops::ratio::Ratio::new(self,other)
-	}
-}
-#[cfg(feature="deferred-division")]
-impl<const N:usize,const F:usize> ratio_ops::ratio::Parity for Fixed<N,F>{
-	fn parity(&self)->bool{
-		self.is_negative()
+		crate::ratio::Ratio::new(self,other)
 	}
 }
 macro_rules! impl_shift_operator {

lib/fixed_wide/src/lib.rs

@@ -1,4 +1,5 @@
 pub mod fixed;
+pub mod ratio;
 pub mod types;
 
 #[cfg(feature="zeroes")]

lib/fixed_wide/src/ratio.rs

@@ -0,0 +1,22 @@
+use bnum::{BInt,BUInt,cast::As};
+use crate::fixed::Fixed;
+
+pub struct Ratio<const N:usize,const D:usize,const NF:usize,const DF:usize>{
+	num:BInt<{N}>,
+	den:BUInt<{D}>,
+}
+
+// Fixed<N = 8 bits,NF = 4 frac> / Fixed<D = 8 bits,DF = 3 frac>
+// 0100.0000/00100.000
+// 01000000<<DF/00100000 = 10>>NF
+
+impl Ratio{
+	/// Evaluate a ratio to a specific precision
+	pub fn evaluate<const OUT_N:usize,const OUT_F:usize>(&self)->Fixed<OUT_N,OUT_F>{
+		// TODO: Think (this is completely wrong)
+		// (lhs/2^LHS_FRAC)/(rhs/2^RHS_FRAC)
+		let lhs=num.bits.as_::<BInt<OUT_N>>().shl(OUT_N*64);
+		let rhs=rhs.bits.as_::<BInt<OUT_N>>();
+		Fixed::from_bits(lhs/rhs)
+	}
+}

lib/linear_ops/Cargo.toml

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

lib/ratio_ops/.gitignore

@@ -1 +0,0 @@
-/target

lib/ratio_ops/Cargo.toml

@@ -1,13 +0,0 @@
-[package]
-name = "ratio_ops"
-version = "0.1.1"
-edition = "2024"
-repository = "https://git.itzana.me/StrafesNET/strafe-project"
-license = "MIT OR Apache-2.0"
-description = "Ratio operations using trait bounds for avoiding division like the plague."
-authors = ["Rhys Lloyd <krakow20@gmail.com>"]
-
-[dependencies]
-
-[lints]
-workspace = true

lib/ratio_ops/LICENSE-APACHE

@@ -1,176 +0,0 @@
-                              Apache License
-                        Version 2.0, January 2004
-                     http://www.apache.org/licenses/
-
-TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-1. Definitions.
-
-   "License" shall mean the terms and conditions for use, reproduction,
-   and distribution as defined by Sections 1 through 9 of this document.
-
-   "Licensor" shall mean the copyright owner or entity authorized by
-   the copyright owner that is granting the License.
-
-   "Legal Entity" shall mean the union of the acting entity and all
-   other entities that control, are controlled by, or are under common
-   control with that entity. For the purposes of this definition,
-   "control" means (i) the power, direct or indirect, to cause the
-   direction or management of such entity, whether by contract or
-   otherwise, or (ii) ownership of fifty percent (50%) or more of the
-   outstanding shares, or (iii) beneficial ownership of such entity.
-
-   "You" (or "Your") shall mean an individual or Legal Entity
-   exercising permissions granted by this License.
-
-   "Source" form shall mean the preferred form for making modifications,
-   including but not limited to software source code, documentation
-   source, and configuration files.
-
-   "Object" form shall mean any form resulting from mechanical
-   transformation or translation of a Source form, including but
-   not limited to compiled object code, generated documentation,
-   and conversions to other media types.
-
-   "Work" shall mean the work of authorship, whether in Source or
-   Object form, made available under the License, as indicated by a
-   copyright notice that is included in or attached to the work
-   (an example is provided in the Appendix below).
-
-   "Derivative Works" shall mean any work, whether in Source or Object
-   form, that is based on (or derived from) the Work and for which the
-   editorial revisions, annotations, elaborations, or other modifications
-   represent, as a whole, an original work of authorship. For the purposes
-   of this License, Derivative Works shall not include works that remain
-   separable from, or merely link (or bind by name) to the interfaces of,
-   the Work and Derivative Works thereof.
-
-   "Contribution" shall mean any work of authorship, including
-   the original version of the Work and any modifications or additions
-   to that Work or Derivative Works thereof, that is intentionally
-   submitted to Licensor for inclusion in the Work by the copyright owner
-   or by an individual or Legal Entity authorized to submit on behalf of
-   the copyright owner. For the purposes of this definition, "submitted"
-   means any form of electronic, verbal, or written communication sent
-   to the Licensor or its representatives, including but not limited to
-   communication on electronic mailing lists, source code control systems,
-   and issue tracking systems that are managed by, or on behalf of, the
-   Licensor for the purpose of discussing and improving the Work, but
-   excluding communication that is conspicuously marked or otherwise
-   designated in writing by the copyright owner as "Not a Contribution."
-
-   "Contributor" shall mean Licensor and any individual or Legal Entity
-   on behalf of whom a Contribution has been received by Licensor and
-   subsequently incorporated within the Work.
-
-2. Grant of Copyright License. Subject to the terms and conditions of
-   this License, each Contributor hereby grants to You a perpetual,
-   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-   copyright license to reproduce, prepare Derivative Works of,
-   publicly display, publicly perform, sublicense, and distribute the
-   Work and such Derivative Works in Source or Object form.
-
-3. Grant of Patent License. Subject to the terms and conditions of
-   this License, each Contributor hereby grants to You a perpetual,
-   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-   (except as stated in this section) patent license to make, have made,
-   use, offer to sell, sell, import, and otherwise transfer the Work,
-   where such license applies only to those patent claims licensable
-   by such Contributor that are necessarily infringed by their
-   Contribution(s) alone or by combination of their Contribution(s)
-   with the Work to which such Contribution(s) was submitted. If You
-   institute patent litigation against any entity (including a
-   cross-claim or counterclaim in a lawsuit) alleging that the Work
-   or a Contribution incorporated within the Work constitutes direct
-   or contributory patent infringement, then any patent licenses
-   granted to You under this License for that Work shall terminate
-   as of the date such litigation is filed.
-
-4. Redistribution. You may reproduce and distribute copies of the
-   Work or Derivative Works thereof in any medium, with or without
-   modifications, and in Source or Object form, provided that You
-   meet the following conditions:
-
-   (a) You must give any other recipients of the Work or
-       Derivative Works a copy of this License; and
-
-   (b) You must cause any modified files to carry prominent notices
-       stating that You changed the files; and
-
-   (c) You must retain, in the Source form of any Derivative Works
-       that You distribute, all copyright, patent, trademark, and
-       attribution notices from the Source form of the Work,
-       excluding those notices that do not pertain to any part of
-       the Derivative Works; and
-
-   (d) If the Work includes a "NOTICE" text file as part of its
-       distribution, then any Derivative Works that You distribute must
-       include a readable copy of the attribution notices contained
-       within such NOTICE file, excluding those notices that do not
-       pertain to any part of the Derivative Works, in at least one
-       of the following places: within a NOTICE text file distributed
-       as part of the Derivative Works; within the Source form or
-       documentation, if provided along with the Derivative Works; or,
-       within a display generated by the Derivative Works, if and
-       wherever such third-party notices normally appear. The contents
-       of the NOTICE file are for informational purposes only and
-       do not modify the License. You may add Your own attribution
-       notices within Derivative Works that You distribute, alongside
-       or as an addendum to the NOTICE text from the Work, provided
-       that such additional attribution notices cannot be construed
-       as modifying the License.
-
-   You may add Your own copyright statement to Your modifications and
-   may provide additional or different license terms and conditions
-   for use, reproduction, or distribution of Your modifications, or
-   for any such Derivative Works as a whole, provided Your use,
-   reproduction, and distribution of the Work otherwise complies with
-   the conditions stated in this License.
-
-5. Submission of Contributions. Unless You explicitly state otherwise,
-   any Contribution intentionally submitted for inclusion in the Work
-   by You to the Licensor shall be under the terms and conditions of
-   this License, without any additional terms or conditions.
-   Notwithstanding the above, nothing herein shall supersede or modify
-   the terms of any separate license agreement you may have executed
-   with Licensor regarding such Contributions.
-
-6. Trademarks. This License does not grant permission to use the trade
-   names, trademarks, service marks, or product names of the Licensor,
-   except as required for reasonable and customary use in describing the
-   origin of the Work and reproducing the content of the NOTICE file.
-
-7. Disclaimer of Warranty. Unless required by applicable law or
-   agreed to in writing, Licensor provides the Work (and each
-   Contributor provides its Contributions) on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-   implied, including, without limitation, any warranties or conditions
-   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-   PARTICULAR PURPOSE. You are solely responsible for determining the
-   appropriateness of using or redistributing the Work and assume any
-   risks associated with Your exercise of permissions under this License.
-
-8. Limitation of Liability. In no event and under no legal theory,
-   whether in tort (including negligence), contract, or otherwise,
-   unless required by applicable law (such as deliberate and grossly
-   negligent acts) or agreed to in writing, shall any Contributor be
-   liable to You for damages, including any direct, indirect, special,
-   incidental, or consequential damages of any character arising as a
-   result of this License or out of the use or inability to use the
-   Work (including but not limited to damages for loss of goodwill,
-   work stoppage, computer failure or malfunction, or any and all
-   other commercial damages or losses), even if such Contributor
-   has been advised of the possibility of such damages.
-
-9. Accepting Warranty or Additional Liability. While redistributing
-   the Work or Derivative Works thereof, You may choose to offer,
-   and charge a fee for, acceptance of support, warranty, indemnity,
-   or other liability obligations and/or rights consistent with this
-   License. However, in accepting such obligations, You may act only
-   on Your own behalf and on Your sole responsibility, not on behalf
-   of any other Contributor, and only if You agree to indemnify,
-   defend, and hold each Contributor harmless for any liability
-   incurred by, or claims asserted against, such Contributor by reason
-   of your accepting any such warranty or additional liability.
-
-END OF TERMS AND CONDITIONS

lib/ratio_ops/LICENSE-MIT

@@ -1,23 +0,0 @@
-Permission is hereby granted, free of charge, to any
-person obtaining a copy of this software and associated
-documentation files (the "Software"), to deal in the
-Software without restriction, including without
-limitation the rights to use, copy, modify, merge,
-publish, distribute, sublicense, and/or sell copies of
-the Software, and to permit persons to whom the Software
-is furnished to do so, subject to the following
-conditions:
-
-The above copyright notice and this permission notice
-shall be included in all copies or substantial portions
-of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
-ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
-TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
-PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
-SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
-IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-DEALINGS IN THE SOFTWARE.

lib/ratio_ops/src/lib.rs

@@ -1,4 +0,0 @@
-pub mod ratio;
-
-#[cfg(test)]
-mod tests;

lib/ratio_ops/src/ratio.rs

@@ -1,302 +0,0 @@
-#[derive(Clone,Copy,Debug,Hash)]
-pub struct Ratio<Num,Den>{
-	pub num:Num,
-	pub den:Den,
-}
-impl<Num,Den> Ratio<Num,Den>{
-	#[inline(always)]
-	pub const fn new(num:Num,den:Den)->Self{
-		Self{num,den}
-	}
-}
-
-/// The actual divide implementation, Div is replaced with a Ratio constructor
-pub trait Divide<Rhs=Self>{
-	type Output;
-	fn divide(self,rhs:Rhs)->Self::Output;
-}
-
-impl<Num,Den> Ratio<Num,Den>
-	where
-		Num:Divide<Den>,
-{
-	#[inline]
-	pub fn divide(self)-><Num as Divide<Den>>::Output{
-		self.num.divide(self.den)
-	}
-}
-
-//take care to use the ratio methods to avoid nested ratios
-
-impl<LhsNum,LhsDen> Ratio<LhsNum,LhsDen>{
-	#[inline]
-	pub fn mul_ratio<RhsNum,RhsDen>(self,rhs:Ratio<RhsNum,RhsDen>)->Ratio<<LhsNum as core::ops::Mul<RhsNum>>::Output,<LhsDen as core::ops::Mul<RhsDen>>::Output>
-		where
-			LhsNum:core::ops::Mul<RhsNum>,
-			LhsDen:core::ops::Mul<RhsDen>,
-	{
-		Ratio::new(self.num*rhs.num,self.den*rhs.den)
-	}
-	#[inline]
-	pub fn div_ratio<RhsNum,RhsDen>(self,rhs:Ratio<RhsNum,RhsDen>)->Ratio<<LhsNum as core::ops::Mul<RhsDen>>::Output,<LhsDen as core::ops::Mul<RhsNum>>::Output>
-		where
-			LhsNum:core::ops::Mul<RhsDen>,
-			LhsDen:core::ops::Mul<RhsNum>,
-	{
-		Ratio::new(self.num*rhs.den,self.den*rhs.num)
-	}
-}
-macro_rules! impl_ratio_method {
-	($trait:ident, $method:ident, $ratio_method:ident) => {
-		impl<LhsNum,LhsDen> Ratio<LhsNum,LhsDen>{
-			#[inline]
-			pub fn $ratio_method<RhsNum,RhsDen,LhsCrossMul,RhsCrossMul>(self,rhs:Ratio<RhsNum,RhsDen>)->Ratio<<LhsCrossMul as core::ops::$trait<RhsCrossMul>>::Output,<LhsDen as core::ops::Mul<RhsDen>>::Output>
-				where
-					LhsNum:core::ops::Mul<RhsDen,Output=LhsCrossMul>,
-					LhsDen:core::ops::Mul<RhsNum,Output=RhsCrossMul>,
-					LhsDen:core::ops::Mul<RhsDen>,
-					LhsDen:Copy,
-					RhsDen:Copy,
-					LhsCrossMul:core::ops::$trait<RhsCrossMul>,
-			{
-				Ratio::new((self.num*rhs.den).$method(self.den*rhs.num),self.den*rhs.den)
-			}
-		}
-	};
-}
-impl_ratio_method!(Add,add,add_ratio);
-impl_ratio_method!(Sub,sub,sub_ratio);
-impl_ratio_method!(Rem,rem,rem_ratio);
-
-/// Comparing two ratios needs to know the parity of the denominators
-/// For signed integers this can be implemented with is_negative()
-pub trait Parity{
-	fn parity(&self)->bool;
-}
-macro_rules! impl_parity_unsigned{
-	($($type:ty),*)=>{
-		$(
-		impl Parity for $type{
-			fn parity(&self)->bool{
-				false
-			}
-		}
-		)*
-	};
-}
-macro_rules! impl_parity_signed{
-	($($type:ty),*)=>{
-		$(
-		impl Parity for $type{
-			fn parity(&self)->bool{
-				self.is_negative()
-			}
-		}
-		)*
-	};
-}
-macro_rules! impl_parity_float{
-	($($type:ty),*)=>{
-		$(
-		impl Parity for $type{
-			fn parity(&self)->bool{
-				self.is_sign_negative()
-			}
-		}
-		)*
-	};
-}
-
-impl_parity_unsigned!(u8,u16,u32,u64,u128,usize);
-impl_parity_signed!(i8,i16,i32,i64,i128,isize);
-impl_parity_float!(f32,f64);
-
-macro_rules! impl_ratio_ord_method{
-	($method:ident, $ratio_method:ident, $output:ty)=>{
-		impl<LhsNum,LhsDen:Parity> Ratio<LhsNum,LhsDen>{
-			#[inline]
-			pub fn $ratio_method<RhsNum,RhsDen:Parity,T>(self,rhs:Ratio<RhsNum,RhsDen>)->$output
-				where
-					LhsNum:core::ops::Mul<RhsDen,Output=T>,
-					LhsDen:core::ops::Mul<RhsNum,Output=T>,
-					T:Ord,
-			{
-				match self.den.parity()^rhs.den.parity(){
-					true=>(self.den*rhs.num).$method(&(self.num*rhs.den)),
-					false=>(self.num*rhs.den).$method(&(self.den*rhs.num)),
-				}
-			}
-		}
-	}
-}
-//PartialEq
-impl_ratio_ord_method!(eq,eq_ratio,bool);
-//PartialOrd
-impl_ratio_ord_method!(lt,lt_ratio,bool);
-impl_ratio_ord_method!(gt,gt_ratio,bool);
-impl_ratio_ord_method!(le,le_ratio,bool);
-impl_ratio_ord_method!(ge,ge_ratio,bool);
-impl_ratio_ord_method!(partial_cmp,partial_cmp_ratio,Option<core::cmp::Ordering>);
-//Ord
-impl_ratio_ord_method!(cmp,cmp_ratio,core::cmp::Ordering);
-
-/* generic rhs mul is not possible!
-impl<Lhs,RhsNum,RhsDen> core::ops::Mul<Ratio<RhsNum,RhsDen>> for Lhs
-	where
-		Lhs:core::ops::Mul<RhsNum>,
-{
-	type Output=Ratio<<Lhs as core::ops::Mul<RhsNum>>::Output,RhsDen>;
-	#[inline]
-	fn mul(self,rhs:Ratio<RhsNum,RhsDen>)->Self::Output{
-		Ratio::new(self*rhs.num,rhs.den)
-	}
-}
-*/
-
-//operators
-
-impl<LhsNum,LhsDen> core::ops::Neg for Ratio<LhsNum,LhsDen>
-	where
-		LhsNum:core::ops::Neg,
-{
-	type Output=Ratio<<LhsNum as core::ops::Neg>::Output,LhsDen>;
-	#[inline]
-	fn neg(self)->Self::Output{
-		Ratio::new(-self.num,self.den)
-	}
-}
-impl<LhsNum,LhsDen,Rhs> core::ops::Mul<Rhs> for Ratio<LhsNum,LhsDen>
-	where
-		LhsNum:core::ops::Mul<Rhs>,
-{
-	type Output=Ratio<<LhsNum as core::ops::Mul<Rhs>>::Output,LhsDen>;
-	#[inline]
-	fn mul(self,rhs:Rhs)->Self::Output{
-		Ratio::new(self.num*rhs,self.den)
-	}
-}
-impl<LhsNum,LhsDen,Rhs> core::ops::Div<Rhs> for Ratio<LhsNum,LhsDen>
-	where
-		LhsDen:core::ops::Mul<Rhs>,
-{
-	type Output=Ratio<LhsNum,<LhsDen as core::ops::Mul<Rhs>>::Output>;
-	#[inline]
-	fn div(self,rhs:Rhs)->Self::Output{
-		Ratio::new(self.num,self.den*rhs)
-	}
-}
-
-macro_rules! impl_ratio_operator {
-	($trait:ident, $method:ident) => {
-		impl<LhsNum,LhsDen,Rhs,Intermediate> core::ops::$trait<Rhs> for Ratio<LhsNum,LhsDen>
-			where
-				LhsNum:core::ops::$trait<Intermediate>,
-				LhsDen:Copy,
-				Rhs:core::ops::Mul<LhsDen,Output=Intermediate>,
-		{
-			type Output=Ratio<<LhsNum as core::ops::$trait<Intermediate>>::Output,LhsDen>;
-			#[inline]
-			fn $method(self,rhs:Rhs)->Self::Output{
-				Ratio::new(self.num.$method(rhs*self.den),self.den)
-			}
-		}
-	};
-}
-
-impl_ratio_operator!(Add,add);
-impl_ratio_operator!(Sub,sub);
-impl_ratio_operator!(Rem,rem);
-
-//assign operators
-
-impl<LhsNum,LhsDen,Rhs> core::ops::MulAssign<Rhs> for Ratio<LhsNum,LhsDen>
-	where
-		LhsNum:core::ops::MulAssign<Rhs>,
-{
-	#[inline]
-	fn mul_assign(&mut self,rhs:Rhs){
-		self.num*=rhs;
-	}
-}
-impl<LhsNum,LhsDen,Rhs> core::ops::DivAssign<Rhs> for Ratio<LhsNum,LhsDen>
-	where
-		LhsDen:core::ops::MulAssign<Rhs>,
-{
-	#[inline]
-	fn div_assign(&mut self,rhs:Rhs){
-		self.den*=rhs;
-	}
-}
-
-macro_rules! impl_ratio_assign_operator {
-	($trait:ident, $method:ident) => {
-		impl<LhsNum,LhsDen,Rhs> core::ops::$trait<Rhs> for Ratio<LhsNum,LhsDen>
-			where
-				LhsNum:core::ops::$trait,
-				LhsDen:Copy,
-				Rhs:core::ops::Mul<LhsDen,Output=LhsNum>,
-		{
-			#[inline]
-			fn $method(&mut self,rhs:Rhs){
-				self.num.$method(rhs*self.den)
-			}
-		}
-	};
-}
-
-impl_ratio_assign_operator!(AddAssign,add_assign);
-impl_ratio_assign_operator!(SubAssign,sub_assign);
-impl_ratio_assign_operator!(RemAssign,rem_assign);
-
-// Only implement PartialEq<Self>
-// Rust's operators aren't actually that good
-
-impl<LhsNum,LhsDen,RhsNum,RhsDen,T,U> PartialEq<Ratio<RhsNum,RhsDen>> for Ratio<LhsNum,LhsDen>
-	where
-		LhsNum:Copy,
-		LhsDen:Copy,
-		RhsNum:Copy,
-		RhsDen:Copy,
-		LhsNum:core::ops::Mul<RhsDen,Output=T>,
-		RhsNum:core::ops::Mul<LhsDen,Output=U>,
-		T:PartialEq<U>,
-{
-	#[inline]
-	fn eq(&self,other:&Ratio<RhsNum,RhsDen>)->bool{
-		(self.num*other.den).eq(&(other.num*self.den))
-	}
-}
-impl<Num,Den> Eq for Ratio<Num,Den> where Self:PartialEq{}
-
-// Wow! These were both completely wrong!
-// Idea: use a 'signed' trait instead of parity and float the sign to the numerator.
-impl<LhsNum,LhsDen,RhsNum,RhsDen,T,U> PartialOrd<Ratio<RhsNum,RhsDen>> for Ratio<LhsNum,LhsDen>
-	where
-		LhsNum:Copy,
-		LhsDen:Copy+Parity,
-		RhsNum:Copy,
-		RhsDen:Copy+Parity,
-		LhsNum:core::ops::Mul<RhsDen,Output=T>,
-		LhsDen:core::ops::Mul<RhsNum,Output=T>,
-		RhsNum:core::ops::Mul<LhsDen,Output=U>,
-		RhsDen:core::ops::Mul<LhsNum,Output=U>,
-		T:PartialOrd<U>+Ord,
-{
-	#[inline]
-	fn partial_cmp(&self,&other:&Ratio<RhsNum,RhsDen>)->Option<core::cmp::Ordering>{
-		self.partial_cmp_ratio(other)
-	}
-}
-impl<Num,Den,T> Ord for Ratio<Num,Den>
-	where
-		Num:Copy,
-		Den:Copy+Parity,
-		Num:core::ops::Mul<Den,Output=T>,
-		Den:core::ops::Mul<Num,Output=T>,
-		T:Ord,
-{
-	#[inline]
-	fn cmp(&self,&other:&Self)->std::cmp::Ordering{
-		self.cmp_ratio(other)
-	}
-}

lib/ratio_ops/src/tests.rs

@@ -1,58 +0,0 @@
-use crate::ratio::Ratio;
-
-macro_rules! test_op{
-	($ratio_op:ident,$op:ident,$a:expr,$b:expr,$c:expr,$d:expr)=>{
-		assert_eq!(
-			Ratio::new($a,$b).$ratio_op(Ratio::new($c,$d)),
-			(($a as f32)/($b as f32)).$op(&(($c as f32)/($d as f32)))
-		);
-	};
-}
-
-macro_rules! test_many_ops{
-	($ratio_op:ident,$op:ident)=>{
-		test_op!($ratio_op,$op,1,2,3,4);
-		test_op!($ratio_op,$op,1,2,-3,4);
-		test_op!($ratio_op,$op,-1,2,-3,4);
-		test_op!($ratio_op,$op,-1,-2,-3,4);
-		test_op!($ratio_op,$op,2,1,6,3);
-		test_op!($ratio_op,$op,-2,1,6,3);
-		test_op!($ratio_op,$op,2,-1,-6,3);
-		test_op!($ratio_op,$op,2,1,6,-3);
-	};
-}
-
-#[test]
-fn test_lt(){
-	test_many_ops!(lt_ratio,lt);
-}
-
-#[test]
-fn test_gt(){
-	test_many_ops!(gt_ratio,gt);
-}
-
-#[test]
-fn test_le(){
-	test_many_ops!(le_ratio,le);
-}
-
-#[test]
-fn test_ge(){
-	test_many_ops!(ge_ratio,ge);
-}
-
-#[test]
-fn test_eq(){
-	test_many_ops!(eq_ratio,eq);
-}
-
-#[test]
-fn test_partial_cmp(){
-	test_many_ops!(partial_cmp_ratio,partial_cmp);
-}
-
-// #[test]
-// fn test_cmp(){
-// 	test_many_ops!(cmp_ratio,cmp);
-// }

lib/rbx_loader/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "strafesnet_rbx_loader"
-version = "0.8.0"
+version = "0.7.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.workspace = true
+glam = "0.30.0"
 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.workspace = true
-strafesnet_deferred_loader.workspace = true
+strafesnet_common = { version = "0.7.0", path = "../common", registry = "strafesnet" }
+strafesnet_deferred_loader = { version = "0.5.1", path = "../deferred_loader", registry = "strafesnet" }
 rbx_binary = "2.0.1"
 rbx_dom_weak = "4.1.0"
 rbx_reflection = "6.1.0"

lib/rbx_loader/src/lib.rs

@@ -1,19 +1,17 @@
+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{
@@ -32,21 +30,11 @@ pub struct Model{
 	dom:WeakDom,
 }
 impl Model{
-	pub fn new(dom:WeakDom)->Self{
+	fn new(dom:WeakDom)->Self{
 		Self{dom}
 	}
-	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)
+	pub fn to_snf(&self,failure_mode:LoadFailureMode)->Result<(CompleteMap,RecoverableErrors),LoadError>{
+		to_snf(self,failure_mode)
 	}
 }
 impl AsRef<WeakDom> for Model{
@@ -78,18 +66,8 @@ impl Place{
 		}
 		Ok(errors)
 	}
-	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)
+	pub fn to_snf(&self,failure_mode:LoadFailureMode)->Result<(CompleteMap,RecoverableErrors),LoadError>{
+		to_snf(self,failure_mode)
 	}
 }
 impl AsRef<WeakDom> for Place{
@@ -107,36 +85,54 @@ impl From<Model> for Place{
 }
 
 #[derive(Debug)]
-pub enum LoadError<M,T>{
-	Mesh(M),
-	Texture(T),
+pub enum ReadError{
+	RbxBinary(rbx_binary::DecodeError),
+	RbxXml(rbx_xml::DecodeError),
+	Io(std::io::Error),
+	UnknownFileFormat,
 }
-impl<M,T> std::fmt::Display for LoadError<M,T>
-	where
-		M:std::fmt::Debug,
-		T:std::fmt::Debug,
-{
+impl std::fmt::Display for ReadError{
 	fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
 		write!(f,"{self:?}")
 	}
 }
-impl<M,T> std::error::Error for LoadError<M,T>
-where
-		M:std::fmt::Debug,
-		T:std::fmt::Debug,
-{}
+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();
 
-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();
 
@@ -146,10 +142,12 @@ fn to_snf<'dom,'mesh,'texture,M,T>(
 		&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,11 +867,6 @@ 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{
-			print!("[union] Empty face!");
+			panic!("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{
-			print!("[union] Empty face!");
+			panic!("Empty face!");
 		}
 	}
 	Ok(())

lib/roblox_emulator/Cargo.toml

@@ -12,7 +12,7 @@ default=["run-service"]
 run-service=[]
 
 [dependencies]
-glam.workspace = true
+glam = "0.30.0"
 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.2"
+version = "0.3.1"
 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.workspace = true
+strafesnet_common = { version = "0.7.0", path = "../common", registry = "strafesnet" }
 
 [lints]
 workspace = true

map-tool/Cargo.toml

@@ -1,26 +1,15 @@
 [package]
 name = "map-tool"
-version = "2.0.0"
+version = "1.7.2"
 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"], optional = true }
+clap = { version = "4.4.2", features = ["derive"] }
 flate2 = "1.0.27"
-futures = { version = "0.3.31", optional = true }
+futures = "0.3.31"
 image = "0.25.2"
 image_dds = "0.7.1"
 rbx_asset = { version = "0.5.0", registry = "strafesnet" }
@@ -29,12 +18,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.workspace = true
-strafesnet_deferred_loader.workspace = true
-strafesnet_rbx_loader.workspace = true
-strafesnet_snf.workspace = true
+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" }
 thiserror = "2.0.11"
-tokio = { version = "1.43.0", features = ["time"] }
+tokio = { version = "1.43.0", features = ["macros", "rt-multi-thread", "fs"] }
 vbsp = "0.9.1"
 vbsp-entities-css = "0.6.0"
 vmdl = "0.2.0"

map-tool/src/lib.rs

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

map-tool/src/main.rs

@@ -1,20 +1,23 @@
+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(map_tool::roblox::Commands),
+	Roblox(roblox::Commands),
 	#[command(flatten)]
-	Source(map_tool::source::Commands),
+	Source(source::Commands),
 }
 
 #[tokio::main]

map-tool/src/roblox.rs

@@ -0,0 +1,501 @@
+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

@@ -1,287 +0,0 @@
-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

@@ -1,248 +0,0 @@
-#[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

@@ -0,0 +1,514 @@
+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

@@ -1,300 +0,0 @@
-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

@@ -1,246 +0,0 @@
-#[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.workspace = true
+glam = "0.30.0"
 parking_lot = "0.12.1"
 pollster = "0.4.0"
-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 }
+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 }
 wgpu = "28.0.0"
 winit = "0.30.7"
 

strafe-client/src/graphics_worker.rs

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

strafe-client/src/setup.rs

@@ -1,41 +1,199 @@
-use strafesnet_graphics::setup;
+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()
+	}
+}
 
+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;
 
-pub async fn setup_and_start(title:&str){
+		//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){
 	let event_loop=winit::event_loop::EventLoop::new().unwrap();
 
-	let window=create_window(title,&event_loop).unwrap();
-
 	println!("Initializing the surface...");
 
-	let instance=setup::step1::create_instance();
+	let partial_1=create_instance();
 
-	let surface=setup::step2::create_surface(&instance,&window).unwrap();
+	let window=create_window(title,&event_loop).unwrap();
 
-	let adapter=setup::step3::pick_adapter(&instance,&surface).await.expect("No suitable GPU adapters found on the system!");
+	let partial_2=partial_1.create_surface(&window).unwrap();
 
-	let adapter_info=adapter.get_info();
-	println!("Using {} ({:?})", adapter_info.name, adapter_info.backend);
+	let partial_3=partial_2.pick_adapter();
 
-	let (device,queue)=setup::step4::request_device(&adapter).await.unwrap();
+	let partial_4=partial_3.request_device();
 
 	let size=window.inner_size();
-	let config=setup::step5::configure_surface(&adapter,&device,&surface,(size.width,size.height)).unwrap();
+
+	let setup_context=partial_4.configure_surface(&size);
 
 	//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,
-		device,
-		queue,
-		surface,
-		config,
+		setup_context,
 	);
 
 	for arg in std::env::args().skip(1){

strafe-client/src/window.rs

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