newtypes

src/file.rs

@@ -51,19 +51,19 @@ pub(crate) enum FourCC{
 }
 #[binrw]
 #[brw(little)]
-pub struct Header{
+struct Header{
 	/// Type of file
-	pub fourcc:FourCC,
+	fourcc:FourCC,
-	/// File format version
+	/// Type version
-	pub version:u32,
+	version:u32,
 	/// Minimum data required to know the location of all streamable resources for this specific file
-	pub priming:u64,
+	priming:u64,
 	/// uuid for this file
-	pub resource:u128,
+	resource:u128,
 	//don't need try_calc: the struct will force field initialization anyways and it can be calculated there
-	pub block_count:u32,
+	block_count:u32,
 	#[br(count=block_count+1)]
-	pub block_location:Vec<u64>,
+	block_location:Vec<u64>,
 }
 
 #[binrw]

src/map.rs

@@ -3,7 +3,7 @@ use std::collections::HashMap;
 
 use crate::newtypes;
 use crate::file::BlockId;
-use binrw::{binrw,BinReaderExt,BinWriterExt};
+use binrw::{binrw,BinReaderExt};
 use strafesnet_common::model;
 use strafesnet_common::aabb::Aabb;
 use strafesnet_common::bvh::BvhNode;
@@ -135,12 +135,15 @@ struct ResourceExternalHeader{
 #[binrw]
 #[brw(little)]
 struct MapHeader{
+	num_nodes:u32,
 	num_spacial_blocks:u32,
 	num_resource_blocks:u32,
 	num_resources_external:u32,
 	num_modes:u32,
 	num_attributes:u32,
 	num_render_configs:u32,
+	#[br(count=num_nodes)]
+	nodes:Vec<u32>,
 	#[br(count=num_spacial_blocks)]
 	spacial_blocks:Vec<SpacialBlockHeader>,
 	#[br(count=num_resource_blocks)]
@@ -241,7 +244,7 @@ impl<R:BinReaderExt> StreamableMap<R>{
 	}
 	pub fn get_intersecting_region_block_ids(&self,aabb:&Aabb)->Vec<BlockId>{
 		let mut block_ids=Vec::new();
-		self.bvh.the_tester(aabb,&mut |&block_id|block_ids.push(block_id));
+		self.bvh.the_tester(aabb,&mut |block_id|block_ids.push(block_id));
 		block_ids
 	}
 	pub fn load_region(&mut self,block_id:BlockId)->Result<Vec<model::Model>,Error>{
@@ -281,133 +284,3 @@ impl<R:BinReaderExt> StreamableMap<R>{
 		})
 	}
 }
-
-const BVH_NODE_MAX_WEIGHT:usize=64*1024;//64 kB
-fn collect_spacial_blocks(
-	block_location:&mut Vec<u64>,
-	block_headers:&mut Vec<SpacialBlockHeader>,
-	sequential_block_data:&mut std::io::Cursor<&mut Vec<u8>>,
-	bvh_node:strafesnet_common::bvh::BvhWeightNode<usize,newtypes::model::Model>
-)->Result<(),Error>{
-	//inspect the node weights top-down.
-	//When a node weighs less than the limit,
-	//serialize its entire contents into a region block
-	if *bvh_node.weight()<BVH_NODE_MAX_WEIGHT{
-		let mut models=Vec::new();
-		let mut model_count=0;
-		let extents=bvh_node.aabb().clone().into();
-		bvh_node.into_visitor(&mut |model|{
-			model_count+=1;
-			models.push(model);
-		});
-		let id=BlockId::new(block_headers.len() as u32);
-		block_headers.push(SpacialBlockHeader{
-			id,
-			extents,
-		});
-		let region=Region{
-			model_count,
-			models,
-		};
-		binrw::BinWrite::write_le(&region,sequential_block_data).map_err(Error::InvalidData)?;
-		block_location.push(sequential_block_data.position());
-	}else{
-		match bvh_node.into_content(){
-			strafesnet_common::bvh::RecursiveContent::Branch(bvh_node_list)=>{
-				for bvh_node in bvh_node_list{
-					collect_spacial_blocks(block_location,block_headers,sequential_block_data,bvh_node)?;
-				}
-			},
-			strafesnet_common::bvh::RecursiveContent::Leaf(_)=>panic!(),//bvh branches are 20 leaves minimum
-		}
-	}
-	Ok(())
-}
-
-/// TODO: Optionally provide a bot that describes the path through the map
-/// otherwise sort by distance to start zone
-pub fn write_map<W:BinWriterExt>(mut writer:W,map:strafesnet_common::map::CompleteMap)->Result<(),Error>{
-	//serialize models and make a bvh that knows the file size of the branch
-	let boxen=map.models.into_iter().map(|model|{
-		//grow your own aabb
-		let mesh=map.meshes.get(model.mesh.get() as usize).ok_or(Error::InvalidMeshId(model.mesh))?;
-		let mut aabb=strafesnet_common::aabb::Aabb::default();
-		for &pos in &mesh.unique_pos{
-			aabb.grow(model.transform.transform_point3(pos));
-		}
-		Ok((model.into(),aabb))
-	}).collect::<Result<Vec<_>,_>>()?;
-	let bvh=strafesnet_common::bvh::generate_bvh(boxen).weigh_contents(&|_|std::mem::size_of::<newtypes::model::Model>());
-	//build blocks
-	let mut block_location=vec![0];//for file header
-	let mut spacial_blocks=Vec::new();//for map header
-	let mut sequential_block_data=Vec::new();
-	let mut cursor_to_data=std::io::Cursor::new(&mut sequential_block_data);
-	collect_spacial_blocks(&mut block_location,&mut spacial_blocks,&mut cursor_to_data,bvh)?;
-	let mut block_count=spacial_blocks.len() as u32;//continue block id
-	let mut resource_blocks=Vec::new();//for map header
-	//meshes
-	for mesh in map.meshes.into_iter(){
-		resource_blocks.push(ResourceBlockHeader{
-			resource:ResourceType::Mesh,
-			id:BlockId::new(block_count),
-		});
-		block_count+=1;
-		let serializable_mesh:newtypes::model::Mesh=mesh.into();
-		binrw::BinWrite::write_le(&serializable_mesh,&mut cursor_to_data).map_err(Error::InvalidData)?;
-		block_location.push(cursor_to_data.position());
-	}
-	//textures
-	for mut texture in map.textures.into_iter(){
-		resource_blocks.push(ResourceBlockHeader{
-			resource:ResourceType::Texture,
-			id:BlockId::new(block_count),
-		});
-		block_count+=1;
-		sequential_block_data.append(&mut texture);
-		block_location.push(sequential_block_data.len() as u64);
-	}
-	//build header
-	let map_header=MapHeader{
-		num_spacial_blocks:spacial_blocks.len() as u32,
-		num_resource_blocks:resource_blocks.len() as u32,
-		num_resources_external:0,
-		num_modes:map.modes.modes.len() as u32,
-		num_attributes:map.attributes.len() as u32,
-		num_render_configs:map.render_configs.len() as u32,
-		spacial_blocks,
-		resource_blocks,
-		external_resources:Vec::new(),
-		modes:map.modes.modes.into_iter().map(Into::into).collect(),
-		attributes:map.attributes.into_iter().map(Into::into).collect(),
-		render_configs:map.render_configs.into_iter().map(Into::into).collect(),
-	};
-	let mut file_header=crate::file::Header{
-		fourcc:crate::file::FourCC::Map,
-		version:0,
-		priming:0,//TODO
-		resource:0,
-		block_count,
-		block_location,
-	};
-	//probe header lengths
-	let mut file_header_data=Vec::new();
-	binrw::BinWrite::write_le(&file_header,&mut std::io::Cursor::new(&mut file_header_data)).map_err(Error::InvalidData)?;
-	let mut map_header_data=Vec::new();
-	binrw::BinWrite::write_le(&map_header,&mut std::io::Cursor::new(&mut map_header_data)).map_err(Error::InvalidData)?;
-
-	//update file header according to probe data
-	let offset=file_header_data.len() as u64+map_header_data.len() as u64;
-	file_header.priming=offset;
-	for position in &mut file_header.block_location{
-		*position+=offset;
-	}
-
-	//write file header
-	writer.write_le(&file_header).map_err(Error::InvalidData)?;
-	//write map header
-	writer.write(&map_header_data).map_err(Error::IO)?;
-	//write blocks
-	writer.write(&sequential_block_data).map_err(Error::IO)?;
-	Ok(())
-}

src/newtypes/aabb.rs

@@ -13,11 +13,3 @@ impl Into<strafesnet_common::aabb::Aabb> for Aabb{
 		)
 	}
 }
-impl From<strafesnet_common::aabb::Aabb> for Aabb{
-	fn from(value:strafesnet_common::aabb::Aabb)->Self{
-		Self{
-			max:value.max().get().to_array(),
-			min:value.min().get().to_array(),
-		}
-	}
-}

src/newtypes/gameplay_attributes.rs

@@ -12,16 +12,6 @@ impl Into<strafesnet_common::gameplay_attributes::ContactingLadder> for Contacti
 		}
 	}
 }
-impl From<strafesnet_common::gameplay_attributes::ContactingLadder> for ContactingLadder{
-	fn from(value:strafesnet_common::gameplay_attributes::ContactingLadder)->Self{
-		Self{
-			sticky:match value.sticky{
-				true=>Some(()),
-				false=>None,
-			}
-		}
-	}
-}
 
 #[binrw::binrw]
 #[brw(little)]
@@ -50,24 +40,6 @@ impl Into<strafesnet_common::gameplay_attributes::ContactingBehaviour> for Conta
 		}
 	}
 }
-impl From<strafesnet_common::gameplay_attributes::ContactingBehaviour> for ContactingBehaviour{
-	fn from(value:strafesnet_common::gameplay_attributes::ContactingBehaviour)->Self{
-		match value{
-			strafesnet_common::gameplay_attributes::ContactingBehaviour::Surf=>
-			ContactingBehaviour::Surf,
-			strafesnet_common::gameplay_attributes::ContactingBehaviour::Ladder(contacting_ladder)=>
-			ContactingBehaviour::Ladder(
-				contacting_ladder.into()
-			),
-			strafesnet_common::gameplay_attributes::ContactingBehaviour::NoJump=>
-			ContactingBehaviour::NoJump,
-			strafesnet_common::gameplay_attributes::ContactingBehaviour::Cling=>
-			ContactingBehaviour::Cling,
-			strafesnet_common::gameplay_attributes::ContactingBehaviour::Elastic(elasticity)=>
-			ContactingBehaviour::Elastic(elasticity),
-		}
-	}
-}
 
 #[binrw::binrw]
 #[brw(little)]
@@ -85,15 +57,6 @@ impl Into<strafesnet_common::gameplay_attributes::IntersectingWater> for Interse
 		}
 	}
 }
-impl From<strafesnet_common::gameplay_attributes::IntersectingWater> for IntersectingWater{
-	fn from(value:strafesnet_common::gameplay_attributes::IntersectingWater)->Self{
-		Self{
-			viscosity:value.viscosity.get(),
-			density:value.density.get(),
-			velocity:value.velocity.get().to_array(),
-		}
-	}
-}
 
 #[binrw::binrw]
 #[brw(little)]
@@ -107,13 +70,6 @@ impl Into<strafesnet_common::gameplay_attributes::Accelerator> for Accelerator{
 		}
 	}
 }
-impl From<strafesnet_common::gameplay_attributes::Accelerator> for Accelerator{
-	fn from(value:strafesnet_common::gameplay_attributes::Accelerator)->Self{
-		Self{
-			acceleration:value.acceleration.get().to_array(),
-		}
-	}
-}
 
 #[binrw::binrw]
 #[brw(little)]
@@ -136,19 +92,6 @@ impl Into<strafesnet_common::gameplay_attributes::Booster> for Booster{
 		}
 	}
 }
-impl From<strafesnet_common::gameplay_attributes::Booster> for Booster{
-	fn from(value:strafesnet_common::gameplay_attributes::Booster)->Self{
-		match value{
-			strafesnet_common::gameplay_attributes::Booster::Velocity(velocity)=>
-			Booster::Velocity(velocity.get().to_array()),
-			strafesnet_common::gameplay_attributes::Booster::Energy{direction,energy}=>
-			Booster::Energy{
-				direction:direction.get().to_array(),
-				energy:energy.get(),
-			},
-		}
-	}
-}
 
 #[binrw::binrw]
 #[brw(little,repr=u8)]
@@ -166,16 +109,6 @@ impl Into<strafesnet_common::gameplay_attributes::TrajectoryChoice> for Trajecto
 		}
 	}
 }
-impl From<strafesnet_common::gameplay_attributes::TrajectoryChoice> for TrajectoryChoice{
-	fn from(value:strafesnet_common::gameplay_attributes::TrajectoryChoice)->Self{
-		match value{
-			strafesnet_common::gameplay_attributes::TrajectoryChoice::HighArcLongDuration=>
-			TrajectoryChoice::HighArcLongDuration,
-			strafesnet_common::gameplay_attributes::TrajectoryChoice::LowArcShortDuration=>
-			TrajectoryChoice::LowArcShortDuration,
-		}
-	}
-}
 
 #[binrw::binrw]
 #[brw(little)]
@@ -228,40 +161,6 @@ impl Into<strafesnet_common::gameplay_attributes::SetTrajectory> for SetTrajecto
 		}
 	}
 }
-impl From<strafesnet_common::gameplay_attributes::SetTrajectory> for SetTrajectory{
-	fn from(value:strafesnet_common::gameplay_attributes::SetTrajectory)->Self{
-		match value{
-			strafesnet_common::gameplay_attributes::SetTrajectory::AirTime(time)=>
-			SetTrajectory::AirTime(
-				time.get()
-			),
-			strafesnet_common::gameplay_attributes::SetTrajectory::Height(height)=>
-			SetTrajectory::Height(
-				height.get()
-			),
-			strafesnet_common::gameplay_attributes::SetTrajectory::DotVelocity{direction,dot}=>
-			SetTrajectory::DotVelocity{
-				direction:direction.get().to_array(),
-				dot:dot.get(),
-			},
-			strafesnet_common::gameplay_attributes::SetTrajectory::TargetPointTime{target_point,time}=>
-			SetTrajectory::TargetPointTime{
-				target_point:target_point.get().to_array(),
-				time:time.get(),
-			},
-			strafesnet_common::gameplay_attributes::SetTrajectory::TargetPointSpeed{target_point,speed,trajectory_choice}=>
-			SetTrajectory::TargetPointSpeed{
-				target_point:target_point.get().to_array(),
-				speed:speed.get(),
-				trajectory_choice:trajectory_choice.into(),
-			},
-			strafesnet_common::gameplay_attributes::SetTrajectory::Velocity(velocity)=>
-			SetTrajectory::Velocity(
-				velocity.get().to_array()
-			),
-		}
-	}
-}
 
 #[binrw::binrw]
 #[brw(little)]
@@ -275,13 +174,6 @@ impl Into<strafesnet_common::gameplay_attributes::Wormhole> for Wormhole{
 		}
 	}
 }
-impl From<strafesnet_common::gameplay_attributes::Wormhole> for Wormhole{
-	fn from(value:strafesnet_common::gameplay_attributes::Wormhole)->Self{
-		Self{
-			destination_model:value.destination_model.get(),
-		}
-	}
-}
 
 #[binrw::binrw]
 #[brw(little)]
@@ -301,16 +193,6 @@ impl Into<strafesnet_common::gameplay_attributes::GeneralAttributes> for General
 		}
 	}
 }
-impl From<strafesnet_common::gameplay_attributes::GeneralAttributes> for GeneralAttributes{
-	fn from(value:strafesnet_common::gameplay_attributes::GeneralAttributes)->Self{
-		Self{
-			booster:value.booster.map(Into::into),
-			trajectory:value.trajectory.map(Into::into),
-			wormhole:value.wormhole.map(Into::into),
-			accelerator:value.accelerator.map(Into::into),
-		}
-	}
-}
 
 #[binrw::binrw]
 #[brw(little)]
@@ -324,13 +206,6 @@ impl Into<strafesnet_common::gameplay_attributes::ContactingAttributes> for Cont
 		}
 	}
 }
-impl From<strafesnet_common::gameplay_attributes::ContactingAttributes> for ContactingAttributes{
-	fn from(value:strafesnet_common::gameplay_attributes::ContactingAttributes)->Self{
-		Self{
-			contact_behaviour:value.contact_behaviour.map(Into::into),
-		}
-	}
-}
 
 #[binrw::binrw]
 #[brw(little)]
@@ -344,14 +219,6 @@ impl Into<strafesnet_common::gameplay_attributes::IntersectingAttributes> for In
 		}
 	}
 }
-impl From<strafesnet_common::gameplay_attributes::IntersectingAttributes> for IntersectingAttributes{
-	fn from(value:strafesnet_common::gameplay_attributes::IntersectingAttributes)->Self{
-		Self{
-			water:value.water.map(Into::into),
-		}
-	}
-}
-
 #[binrw::binrw]
 #[brw(little)]
 pub enum CollisionAttributes{
@@ -377,15 +244,3 @@ impl Into<strafesnet_common::gameplay_attributes::CollisionAttributes> for Colli
 		}
 	}
 }
-impl From<strafesnet_common::gameplay_attributes::CollisionAttributes> for CollisionAttributes{
-	fn from(value:strafesnet_common::gameplay_attributes::CollisionAttributes)->Self{
-		match value{
-			strafesnet_common::gameplay_attributes::CollisionAttributes::Decoration=>
-			CollisionAttributes::Decoration,
-			strafesnet_common::gameplay_attributes::CollisionAttributes::Contact{contacting,general}=>
-			CollisionAttributes::Contact{contacting:contacting.into(),general:general.into()},
-			strafesnet_common::gameplay_attributes::CollisionAttributes::Intersect{intersecting,general}=>
-			CollisionAttributes::Intersect{intersecting:intersecting.into(),general:general.into()},
-		}
-	}
-}

src/newtypes/gameplay_modes.rs

@@ -22,18 +22,6 @@ impl Into<strafesnet_common::gameplay_modes::StageElementBehaviour> for StageEle
 		}
 	}
 }
-impl From<strafesnet_common::gameplay_modes::StageElementBehaviour> for StageElementBehaviour{
-	fn from(value:strafesnet_common::gameplay_modes::StageElementBehaviour)->Self{
-		match value{
-			strafesnet_common::gameplay_modes::StageElementBehaviour::SpawnAt=>StageElementBehaviour::SpawnAt,
-			strafesnet_common::gameplay_modes::StageElementBehaviour::Trigger=>StageElementBehaviour::Trigger,
-			strafesnet_common::gameplay_modes::StageElementBehaviour::Teleport=>StageElementBehaviour::Teleport,
-			strafesnet_common::gameplay_modes::StageElementBehaviour::Platform=>StageElementBehaviour::Platform,
-			strafesnet_common::gameplay_modes::StageElementBehaviour::Check=>StageElementBehaviour::Check,
-			strafesnet_common::gameplay_modes::StageElementBehaviour::Checkpoint=>StageElementBehaviour::Checkpoint,
-		}
-	}
-}
 
 #[binrw::binrw]
 #[brw(little)]
@@ -53,16 +41,6 @@ impl Into<strafesnet_common::gameplay_modes::StageElement> for StageElement{
 		)
 	}
 }
-impl From<strafesnet_common::gameplay_modes::StageElement> for StageElement{
-	fn from(value:strafesnet_common::gameplay_modes::StageElement)->Self{
-		Self{
-			stage_id:value.stage_id().get(),
-			behaviour:value.behaviour().into(),
-			jump_limit:value.jump_limit(),
-			force:match value.force(){true=>Some(()),false=>None},
-		}
-	}
-}
 
 #[binrw::binrw]
 #[brw(little)]
@@ -93,25 +71,6 @@ impl Into<strafesnet_common::gameplay_modes::Stage> for Stage{
 		)
 	}
 }
-impl From<strafesnet_common::gameplay_modes::Stage> for Stage{
-	fn from(value:strafesnet_common::gameplay_modes::Stage)->Self{
-		let spawn=value.spawn().get();
-		let ordered_checkpoints_count=value.ordered_checkpoints_count();
-		let unordered_checkpoints_count=value.unordered_checkpoints_count();
-		let (ordered_checkpoints,unordered_checkpoints)=value.into_inner();
-		Self{
-			spawn,
-			ordered_checkpoints_count,
-			unordered_checkpoints_count,
-			ordered_checkpoints:ordered_checkpoints.into_iter()
-			.map(|(checkpoint_id,model_id)|(checkpoint_id.get(),model_id.get()))
-			.collect(),
-			unordered_checkpoints:unordered_checkpoints.into_iter()
-			.map(|model_id|model_id.get())
-			.collect(),
-		}
-	}
-}
 
 #[binrw::binrw]
 #[brw(little,repr=u8)]
@@ -129,15 +88,6 @@ impl Into<strafesnet_common::gameplay_modes::Zone> for Zone{
 		}
 	}
 }
-impl From<strafesnet_common::gameplay_modes::Zone> for Zone{
-	fn from(value:strafesnet_common::gameplay_modes::Zone)->Self{
-		match value{
-			strafesnet_common::gameplay_modes::Zone::Start=>Zone::Start,
-			strafesnet_common::gameplay_modes::Zone::Finish=>Zone::Finish,
-			strafesnet_common::gameplay_modes::Zone::Anticheat=>Zone::Anticheat,
-		}
-	}
-}
 
 #[binrw::binrw]
 #[brw(little)]
@@ -174,26 +124,3 @@ impl Into<strafesnet_common::gameplay_modes::Mode> for Mode{
 		)
 	}
 }
-impl From<strafesnet_common::gameplay_modes::Mode> for Mode{
-	fn from(value:strafesnet_common::gameplay_modes::Mode)->Self{
-		let (style,start,zones,stages,elements)=value.into_inner();
-		Self{
-			header:ModeHeader{
-				zones:zones.len() as u32,
-				stages:stages.len() as u32,
-				elements:elements.len() as u32,
-			},
-			style:style.into(),
-			start:start.get(),
-			zones:zones.into_iter()
-			.map(|(model_id,zone)|(model_id.get(),zone.into()))
-			.collect(),
-			stages:stages.into_iter()
-			.map(Into::into)
-			.collect(),
-			elements:elements.into_iter()
-			.map(|(model_id,stage_element)|(model_id.get(),stage_element.into()))
-			.collect(),
-		}
-	}
-}

src/newtypes/gameplay_style.rs

@@ -37,24 +37,6 @@ impl Into<strafesnet_common::gameplay_style::StyleModifiers> for StyleModifiers{
 		}
 	}
 }
-impl From<strafesnet_common::gameplay_style::StyleModifiers> for StyleModifiers{
-	fn from(value:strafesnet_common::gameplay_style::StyleModifiers)->Self{
-		Self{
-			controls_mask:value.controls_mask.bits(),
-			controls_mask_state:value.controls_mask_state.bits(),
-			strafe:value.strafe.map(Into::into),
-			rocket:value.rocket.map(Into::into),
-			jump:value.jump.map(Into::into),
-			walk:value.walk.map(Into::into),
-			ladder:value.ladder.map(Into::into),
-			swim:value.swim.map(Into::into),
-			gravity:value.gravity.get().to_array(),
-			hitbox:value.hitbox.into(),
-			camera_offset:value.camera_offset.get().to_array(),
-			mass:value.mass.get(),
-		}
-	}
-}
 
 #[binrw::binrw]
 #[brw(little,repr=u8)]
@@ -72,15 +54,6 @@ impl Into<strafesnet_common::gameplay_style::JumpCalculation> for JumpCalculatio
 		}
 	}
 }
-impl From<strafesnet_common::gameplay_style::JumpCalculation> for JumpCalculation{
-	fn from(value:strafesnet_common::gameplay_style::JumpCalculation)->Self{
-		match value{
-			strafesnet_common::gameplay_style::JumpCalculation::Capped=>JumpCalculation::Capped,
-			strafesnet_common::gameplay_style::JumpCalculation::Energy=>JumpCalculation::Energy,
-			strafesnet_common::gameplay_style::JumpCalculation::Linear=>JumpCalculation::Linear,
-		}
-	}
-}
 
 #[binrw::binrw]
 #[brw(little)]
@@ -100,16 +73,6 @@ impl Into<strafesnet_common::gameplay_style::JumpImpulse> for JumpImpulse{
 		}
 	}
 }
-impl From<strafesnet_common::gameplay_style::JumpImpulse> for JumpImpulse{
-	fn from(value:strafesnet_common::gameplay_style::JumpImpulse)->Self{
-		match value{
-			strafesnet_common::gameplay_style::JumpImpulse::FromTime(time)=>JumpImpulse::FromTime(time.get()),
-			strafesnet_common::gameplay_style::JumpImpulse::FromHeight(height)=>JumpImpulse::FromHeight(height.get()),
-			strafesnet_common::gameplay_style::JumpImpulse::FromDeltaV(deltav)=>JumpImpulse::FromDeltaV(deltav.get()),
-			strafesnet_common::gameplay_style::JumpImpulse::FromEnergy(energy)=>JumpImpulse::FromEnergy(energy.get()),
-		}
-	}
-}
 
 #[binrw::binrw]
 #[brw(little)]
@@ -127,15 +90,6 @@ impl Into<strafesnet_common::gameplay_style::ControlsActivation> for ControlsAct
 		)
 	}
 }
-impl From<strafesnet_common::gameplay_style::ControlsActivation> for ControlsActivation{
-	fn from(value:strafesnet_common::gameplay_style::ControlsActivation)->Self{
-		Self{
-			controls_mask:value.controls_mask().bits(),
-			controls_intersects:value.controls_intersects().bits(),
-			controls_contains:value.controls_contains().bits(),
-		}
-	}
-}
 
 #[binrw::binrw]
 #[brw(little)]
@@ -155,17 +109,6 @@ impl Into<strafesnet_common::gameplay_style::StrafeSettings> for StrafeSettings{
 		)
 	}
 }
-impl From<strafesnet_common::gameplay_style::StrafeSettings> for StrafeSettings{
-	fn from(value:strafesnet_common::gameplay_style::StrafeSettings)->Self{
-		let (enable,mv,air_accel_limit,tick_rate)=value.into_inner();
-		Self{
-			enable:enable.into(),
-			mv:mv.get(),
-			air_accel_limit:air_accel_limit.map(|a|a.get()),
-			tick_rate:tick_rate.into(),
-		}
-	}
-}
 
 #[binrw::binrw]
 #[brw(little)]
@@ -179,13 +122,6 @@ impl Into<strafesnet_common::gameplay_style::PropulsionSettings> for PropulsionS
 		)
 	}
 }
-impl From<strafesnet_common::gameplay_style::PropulsionSettings> for PropulsionSettings{
-	fn from(value:strafesnet_common::gameplay_style::PropulsionSettings)->Self{
-		Self{
-			magnitude:value.magnitude().get(),
-		}
-	}
-}
 
 #[binrw::binrw]
 #[brw(little)]
@@ -201,15 +137,6 @@ impl Into<strafesnet_common::gameplay_style::JumpSettings> for JumpSettings{
 		)
 	}
 }
-impl From<strafesnet_common::gameplay_style::JumpSettings> for JumpSettings{
-	fn from(value:strafesnet_common::gameplay_style::JumpSettings)->Self{
-		let (impulse,calculation)=value.into_inner();
-		Self{
-			impulse:impulse.into(),
-			calculation:calculation.into(),
-		}
-	}
-}
 
 #[binrw::binrw]
 #[brw(little)]
@@ -225,14 +152,6 @@ impl Into<strafesnet_common::gameplay_style::AccelerateSettings> for AccelerateS
 		)
 	}
 }
-impl From<strafesnet_common::gameplay_style::AccelerateSettings> for AccelerateSettings{
-	fn from(value:strafesnet_common::gameplay_style::AccelerateSettings)->Self{
-		Self{
-			accel:value.accel().get(),
-			topspeed:value.topspeed().get(),
-		}
-	}
-}
 
 #[binrw::binrw]
 #[brw(little)]
@@ -252,17 +171,6 @@ impl Into<strafesnet_common::gameplay_style::WalkSettings> for WalkSettings{
 		)
 	}
 }
-impl From<strafesnet_common::gameplay_style::WalkSettings> for WalkSettings{
-	fn from(value:strafesnet_common::gameplay_style::WalkSettings)->Self{
-		let (accelerate,static_friction,kinetic_friction,surf_dot)=value.into_inner();
-		Self{
-			accelerate:accelerate.into(),
-			static_friction:static_friction.get(),
-			kinetic_friction:kinetic_friction.get(),
-			surf_dot:surf_dot.get(),
-		}
-	}
-}
 
 #[binrw::binrw]
 #[brw(little)]
@@ -278,15 +186,6 @@ impl Into<strafesnet_common::gameplay_style::LadderSettings> for LadderSettings{
 		)
 	}
 }
-impl From<strafesnet_common::gameplay_style::LadderSettings> for LadderSettings{
-	fn from(value:strafesnet_common::gameplay_style::LadderSettings)->Self{
-		let (accelerate,dot)=value.into_inner();
-		Self{
-			accelerate:accelerate.into(),
-			dot:dot.get(),
-		}
-	}
-}
 
 #[binrw::binrw]
 #[brw(little,repr=u8)]
@@ -302,14 +201,6 @@ impl Into<strafesnet_common::gameplay_style::HitboxMesh> for HitboxMesh{
 		}
 	}
 }
-impl From<strafesnet_common::gameplay_style::HitboxMesh> for HitboxMesh{
-	fn from(value:strafesnet_common::gameplay_style::HitboxMesh)->Self{
-		match value{
-			strafesnet_common::gameplay_style::HitboxMesh::Box=>HitboxMesh::Box,
-			strafesnet_common::gameplay_style::HitboxMesh::Cylinder=>HitboxMesh::Cylinder,
-		}
-	}
-}
 
 #[binrw::binrw]
 #[brw(little)]
@@ -325,11 +216,3 @@ impl Into<strafesnet_common::gameplay_style::Hitbox> for Hitbox{
 		}
 	}
 }
-impl From<strafesnet_common::gameplay_style::Hitbox> for Hitbox{
-	fn from(value:strafesnet_common::gameplay_style::Hitbox)->Self{
-		Self{
-			halfsize:value.halfsize.get().to_array(),
-			mesh:value.mesh.into(),
-		}
-	}
-}

src/newtypes/integer.rs

@@ -11,14 +11,6 @@ impl Into<strafesnet_common::integer::Ratio64> for Ratio64{
 		strafesnet_common::integer::Ratio64::new(self.num,self.den).unwrap()
 	}
 }
-impl From<strafesnet_common::integer::Ratio64> for Ratio64{
-	fn from(value:strafesnet_common::integer::Ratio64)->Self{
-		Self{
-			num:value.num(),
-			den:value.den(),
-		}
-	}
-}
 
 #[binrw::binrw]
 #[brw(little)]

src/newtypes/model.rs

@@ -1,5 +1,3 @@
-use strafesnet_common::model::PolygonIter;
-
 use super::integer::{Planar64Vec3,Planar64Affine3};
 
 pub type TextureCoordinate=[f32;2];
@@ -13,16 +11,6 @@ pub struct IndexedVertex{
 	pub normal:u32,
 	pub color:u32,
 }
-impl From<strafesnet_common::model::IndexedVertex> for IndexedVertex{
-	fn from(value:strafesnet_common::model::IndexedVertex)->Self{
-		Self{
-			pos:value.pos.get(),
-			tex:value.tex.get(),
-			normal:value.normal.get(),
-			color:value.color.get(),
-		}
-	}
-}
 
 #[binrw::binrw]
 #[brw(little)]
@@ -38,25 +26,6 @@ pub struct PolygonGroup{
 	#[br(count=count)]
 	pub polys:Vec<Polygon>,
 }
-impl From<strafesnet_common::model::PolygonGroup> for PolygonGroup{
-	fn from(value:strafesnet_common::model::PolygonGroup)->Self{
-		match value{
-			strafesnet_common::model::PolygonGroup::PolygonList(polygon_list)=>{
-				let polys:Vec<Polygon>=polygon_list.polys().map(|poly|{
-					let vertices:Vec<u32>=poly.iter().map(|vert|vert.get()).collect();
-					Polygon{
-						count:vertices.len() as u32,
-						vertices,
-					}
-				}).collect();
-				Self{
-					count:polys.len() as u32,
-					polys,
-				}
-			}
-		}
-	}
-}
 #[binrw::binrw]
 #[brw(little)]
 pub struct RenderConfig{
@@ -69,13 +38,6 @@ impl Into<strafesnet_common::model::RenderConfig> for RenderConfig{
 		}
 	}
 }
-impl From<strafesnet_common::model::RenderConfig> for RenderConfig{
-	fn from(value:strafesnet_common::model::RenderConfig)->Self{
-		Self{
-			texture:value.texture.map(|texture_id|texture_id.get()),
-		}
-	}
-}
 #[binrw::binrw]
 #[brw(little)]
 pub struct IndexedGraphicsGroup{
@@ -84,15 +46,6 @@ pub struct IndexedGraphicsGroup{
 	#[br(count=count)]
 	pub groups:Vec<u32>,
 }
-impl From<strafesnet_common::model::IndexedGraphicsGroup> for IndexedGraphicsGroup{
-	fn from(value:strafesnet_common::model::IndexedGraphicsGroup)->Self{
-		Self{
-			count:value.groups.len() as u32,
-			render:value.render.get(),
-			groups:value.groups.into_iter().map(|group_id|group_id.get()).collect(),
-		}
-	}
-}
 #[binrw::binrw]
 #[brw(little)]
 pub struct IndexedPhysicsGroup{
@@ -100,14 +53,6 @@ pub struct IndexedPhysicsGroup{
 	#[br(count=count)]
 	pub groups:Vec<u32>,
 }
-impl From<strafesnet_common::model::IndexedPhysicsGroup> for IndexedPhysicsGroup{
-	fn from(value:strafesnet_common::model::IndexedPhysicsGroup)->Self{
-		Self{
-			count:value.groups.len() as u32,
-			groups:value.groups.into_iter().map(|group_id|group_id.get()).collect(),
-		}
-	}
-}
 
 #[binrw::binrw]
 #[brw(little)]
@@ -178,46 +123,6 @@ impl Into<strafesnet_common::model::Mesh> for Mesh{
 		}
 	}
 }
-impl From<strafesnet_common::model::Mesh> for Mesh{
-	fn from(value:strafesnet_common::model::Mesh)->Self{
-		Self{
-			header:MeshHeader{
-				unique_pos:value.unique_pos.len() as u32,
-				unique_normal:value.unique_normal.len() as u32,
-				unique_tex:value.unique_tex.len() as u32,
-				unique_color:value.unique_color.len() as u32,
-				unique_vertices:value.unique_vertices.len() as u32,
-				polygon_groups:value.polygon_groups.len() as u32,
-				graphics_groups:value.graphics_groups.len() as u32,
-				physics_groups:value.physics_groups.len() as u32,
-			},
-			unique_pos:value.unique_pos.into_iter()
-			.map(|pos|pos.get().to_array())
-			.collect(),
-			unique_normal:value.unique_normal.into_iter()
-			.map(|normal|normal.get().to_array())
-			.collect(),
-			unique_tex:value.unique_tex.into_iter()
-			.map(|tex|tex.to_array())
-			.collect(),
-			unique_color:value.unique_color.into_iter()
-			.map(|color|color.to_array())
-			.collect(),
-			unique_vertices:value.unique_vertices.into_iter()
-			.map(Into::into)
-			.collect(),
-			polygon_groups:value.polygon_groups.into_iter()
-			.map(Into::into)
-			.collect(),
-			graphics_groups:value.graphics_groups.into_iter()
-			.map(Into::into)
-			.collect(),
-			physics_groups:value.physics_groups.into_iter()
-			.map(Into::into)
-			.collect(),
-		}
-	}
-}
 
 #[binrw::binrw]
 #[brw(little)]
@@ -245,24 +150,3 @@ impl Into<strafesnet_common::model::Model> for Model{
 		}
 	}
 }
-impl From<strafesnet_common::model::Model> for Model{
-	fn from(value:strafesnet_common::model::Model)->Self{
-		let (
-			[_0,_1,_2],
-			[_3,_4,_5],
-			[_6,_7,_8],
-			[_9,_a,_b]
-		)=(
-			value.transform.matrix3.x_axis.get().to_array(),
-			value.transform.matrix3.y_axis.get().to_array(),
-			value.transform.matrix3.z_axis.get().to_array(),
-			value.transform.translation.get().to_array()
-		);
-		Self{
-			mesh:value.mesh.get(),
-			attributes:value.attributes.get(),
-			color:value.color.to_array(),
-			transform:[_0,_1,_2,_3,_4,_5,_6,_7,_8,_9,_a,_b],
-		}
-	}
-}