whoops forgot file header

src/file.rs

@@ -51,19 +51,19 @@ pub(crate) enum FourCC{
 }
 #[binrw]
 #[brw(little)]
-struct Header{
+pub struct Header{
 	/// Type of file
-	fourcc:FourCC,
-	/// Type version
-	version:u32,
+	pub fourcc:FourCC,
+	/// File format version
+	pub version:u32,
 	/// Minimum data required to know the location of all streamable resources for this specific file
-	priming:u64,
+	pub priming:u64,
 	/// uuid for this file
-	resource:u128,
+	pub resource:u128,
 	//don't need try_calc: the struct will force field initialization anyways and it can be calculated there
-	block_count:u32,
+	pub block_count:u32,
 	#[br(count=block_count+1)]
-	block_location:Vec<u64>,
+	pub 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};
+use binrw::{binrw,BinReaderExt,BinWriterExt};
 use strafesnet_common::model;
 use strafesnet_common::aabb::Aabb;
 use strafesnet_common::bvh::BvhNode;
@@ -135,15 +135,12 @@ 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)]
@@ -244,7 +241,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>{
@@ -284,3 +281,133 @@ 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,3 +13,11 @@ 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,6 +12,16 @@ 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)]
@@ -40,6 +50,24 @@ 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)]
@@ -57,6 +85,15 @@ 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)]
@@ -70,6 +107,13 @@ 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)]
@@ -92,6 +136,19 @@ 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)]
@@ -109,6 +166,16 @@ 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)]
@@ -161,6 +228,40 @@ 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)]
@@ -174,6 +275,13 @@ 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)]
@@ -193,6 +301,16 @@ 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)]
@@ -206,6 +324,13 @@ 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)]
@@ -219,6 +344,14 @@ 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{
@@ -244,3 +377,15 @@ 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,6 +22,18 @@ 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)]
@@ -41,6 +53,16 @@ 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)]
@@ -71,6 +93,25 @@ 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)]
@@ -88,6 +129,15 @@ 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)]
@@ -124,3 +174,26 @@ 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,6 +37,24 @@ 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)]
@@ -54,6 +72,15 @@ 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)]
@@ -73,6 +100,16 @@ 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)]
@@ -90,6 +127,15 @@ 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)]
@@ -109,6 +155,17 @@ 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)]
@@ -122,6 +179,13 @@ 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)]
@@ -137,6 +201,15 @@ 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)]
@@ -152,6 +225,14 @@ 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)]
@@ -171,6 +252,17 @@ 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)]
@@ -186,6 +278,15 @@ 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)]
@@ -201,6 +302,14 @@ 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)]
@@ -216,3 +325,11 @@ 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,6 +11,14 @@ 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,3 +1,5 @@
+use strafesnet_common::model::PolygonIter;
+
 use super::integer::{Planar64Vec3,Planar64Affine3};
 
 pub type TextureCoordinate=[f32;2];
@@ -11,6 +13,16 @@ 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)]
@@ -26,6 +38,25 @@ 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{
@@ -38,6 +69,13 @@ 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{
@@ -46,6 +84,15 @@ 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{
@@ -53,6 +100,14 @@ 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)]
@@ -123,6 +178,46 @@ 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)]
@@ -150,3 +245,24 @@ 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],
+		}
+	}
+}