10 Commits

Author SHA1 Message Date
50d1a3188e newtypes 2024-07-25 10:42:03 -07:00
9cc099a6eb don't allocate models twice 2024-07-24 14:39:21 -07:00
5d9c124e76 complete map loader 2024-07-24 14:39:21 -07:00
d60486acc3 newtypes 2024-07-24 14:39:21 -07:00
2eef7843a2 generate resource ids + implement load_mesh 2024-07-24 14:39:21 -07:00
5e644c7eed newtypes 2024-07-24 12:00:24 -07:00
567ce86370 wip 2024-07-24 12:00:03 -07:00
9cef23c519 wip 2024-07-23 19:32:29 -07:00
4f90956e16 implement map file format 2024-07-23 19:08:30 -07:00
1883c06f12 newtypes (boilerplate) 2024-07-23 19:08:30 -07:00
13 changed files with 71 additions and 850 deletions

@ -1,6 +1,5 @@
use binrw::{BinReaderExt, binrw};
#[derive(Debug)]
pub enum Error{
InvalidHeader,
InvalidSegment(binrw::Error),
@ -65,7 +64,7 @@ mod simulation{
#[binrw]
#[brw(little)]
#[derive(Clone,Copy,Debug,id::Id)]
#[derive(Clone,Copy,id::Id)]
pub struct SegmentId(u32);
#[binrw]

@ -1,6 +1,5 @@
use binrw::BinReaderExt;
#[derive(Debug)]
pub enum Error{
InvalidHeader,
}
@ -28,4 +27,4 @@ impl<R:BinReaderExt> StreamableDemo<R>{
pub(crate) fn new(file:crate::file::File<R>)->Result<Self,Error>{
Err(Error::InvalidHeader)
}
}
}

@ -2,19 +2,12 @@
use binrw::{binrw, BinReaderExt, io::TakeSeekExt};
#[derive(Debug)]
pub enum Error{
InvalidHeader(binrw::Error),
UnexpectedEOF,
InvalidBlockId(BlockId),
Seek(std::io::Error),
}
impl std::fmt::Display for Error{
fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
write!(f,"{self:?}")
}
}
impl std::error::Error for Error{}
/* spec
@ -47,7 +40,7 @@ for block_id in 1..num_blocks{
*/
#[binrw]
#[brw(little)]
#[derive(Clone,Copy,Debug)]
#[derive(Clone,Copy)]
pub(crate) enum FourCC{
#[brw(magic=b"SNFM")]
Map,
@ -58,25 +51,24 @@ pub(crate) enum FourCC{
}
#[binrw]
#[brw(little)]
#[derive(Debug)]
pub struct Header{
struct Header{
/// Type of file
pub fourcc:FourCC,
/// File format version
pub version:u32,
fourcc:FourCC,
/// Type version
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]
#[brw(little)]
#[derive(Clone,Copy,Debug,Hash,id::Id,Eq,Ord,PartialEq,PartialOrd)]
#[derive(Clone,Copy,Hash,id::Id,Eq,PartialEq)]
pub struct BlockId(u32);
pub(crate) struct File<R:BinReaderExt>{

@ -7,7 +7,6 @@ pub mod map;
pub mod bot;
pub mod demo;
#[derive(Debug)]
pub enum Error{
UnexpectedFourCC,
Header(file::Error),
@ -15,12 +14,6 @@ pub enum Error{
Bot(bot::Error),
Demo(demo::Error),
}
impl std::fmt::Display for Error{
fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
write!(f,"{self:?}")
}
}
impl std::error::Error for Error{}
pub enum SNF<R:BinReaderExt>{
Map(map::StreamableMap<R>),

@ -3,29 +3,21 @@ 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;
use strafesnet_common::gameplay_modes;
#[derive(Debug)]
pub enum Error{
InvalidHeader(binrw::Error),
InvalidBlockId(BlockId),
InvalidMeshId(model::MeshId),
InvalidModelId(model::ModelId),
InvalidTextureId(model::TextureId),
InvalidData(binrw::Error),
IO(std::io::Error),
File(crate::file::Error),
}
impl std::fmt::Display for Error{
fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
write!(f,"{self:?}")
}
}
impl std::error::Error for Error{}
/* block types
@ -143,18 +135,21 @@ struct ResourceExternalHeader{
#[binrw]
#[brw(little)]
struct MapHeader{
num_nodes:u32,
num_spacial_blocks:u32,
num_resource_blocks:u32,
//num_resources_external: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)]
resource_blocks:Vec<ResourceBlockHeader>,
//#[br(count=num_resources_external)]
//external_resources:Vec<ResourceExternalHeader>,
#[br(count=num_resources_external)]
external_resources:Vec<ResourceExternalHeader>,
#[br(count=num_modes)]
modes:Vec<newtypes::gameplay_modes::Mode>,
#[br(count=num_attributes)]
@ -169,20 +164,18 @@ struct Region{
//consider including a bvh in the region instead of needing to rebalance the physics bvh on the fly
model_count:u32,
#[br(count=model_count)]
models:Vec<(u32,newtypes::model::Model)>,
models:Vec<newtypes::model::Model>,
}
//code deduplication reused in into_complete_map
fn read_region<R:BinReaderExt>(file:&mut crate::file::File<R>,block_id:BlockId)->Result<Vec<(model::ModelId,model::Model)>,Error>{
fn read_region<R:BinReaderExt>(file:&mut crate::file::File<R>,block_id:BlockId)->Result<Vec<model::Model>,Error>{
//load region from disk
//parse the models and determine what resources need to be loaded
//load resources into self.resources
//return Region
let mut block=file.block_reader(block_id).map_err(Error::File)?;
let region:Region=block.read_le().map_err(Error::InvalidData)?;
Ok(region.models.into_iter().map(|(model_id,model)|
(model::ModelId::new(model_id),model.into())
).collect())
Ok(region.models.into_iter().map(Into::into).collect())
}
fn read_mesh<R:BinReaderExt>(file:&mut crate::file::File<R>,block_id:BlockId)->Result<model::Mesh,Error>{
let mut block=file.block_reader(block_id).map_err(Error::File)?;
@ -251,10 +244,10 @@ 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::ModelId,model::Model)>,Error>{
pub fn load_region(&mut self,block_id:BlockId)->Result<Vec<model::Model>,Error>{
read_region(&mut self.file,block_id)
}
pub fn load_mesh(&mut self,mesh_id:model::MeshId)->Result<model::Mesh,Error>{
@ -266,33 +259,20 @@ impl<R:BinReaderExt> StreamableMap<R>{
read_texture(&mut self.file,block_id)
}
pub fn into_complete_map(mut self)->Result<strafesnet_common::map::CompleteMap,Error>{
//load all meshes
let meshes=self.resource_blocks.meshes.into_values().map(|block_id|
read_mesh(&mut self.file,block_id)
).collect::<Result<Vec<_>,_>>()?;
//load all textures
let textures=self.resource_blocks.textures.into_values().map(|block_id|
read_texture(&mut self.file,block_id)
).collect::<Result<Vec<_>,_>>()?;
let mut block_ids=Vec::new();
self.bvh.into_visitor(&mut |block_id|block_ids.push(block_id));
//count on reading the file in sequential order being fastest
block_ids.sort_unstable();
//load all regions
let mut model_pairs=HashMap::new();
let mut models=Vec::new();
for block_id in block_ids{
model_pairs.extend(read_region(&mut self.file,block_id)?);
}
let mut models=Vec::with_capacity(model_pairs.len());
for model_id in 0..model_pairs.len() as u32{
let model_id=model::ModelId::new(model_id);
models.push(model_pairs.remove(&model_id).ok_or(Error::InvalidModelId(model_id))?);
}
//load all meshes
let mut meshes=Vec::with_capacity(self.resource_blocks.meshes.len());
for mesh_id in 0..self.resource_blocks.meshes.len() as u32{
let mesh_id=model::MeshId::new(mesh_id);
let block_id=self.resource_blocks.meshes[&mesh_id];
meshes.push(read_mesh(&mut self.file,block_id)?);
};
//load all textures
let mut textures=Vec::with_capacity(self.resource_blocks.textures.len());
for texture_id in 0..self.resource_blocks.textures.len() as u32{
let texture_id=model::TextureId::new(texture_id);
let block_id=self.resource_blocks.textures[&texture_id];
textures.push(read_texture(&mut self.file,block_id)?);
models.append(&mut read_region(&mut self.file,block_id)?);
}
Ok(strafesnet_common::map::CompleteMap{
modes:self.modes,
@ -304,140 +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,(model::ModelId,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_id,model)|{
model_count+=1;
models.push((model_id.get(),model));
});
let id=BlockId::new(block_headers.len() as u32+1);
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().enumerate().map(|(model_id,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::ModelId::new(model_id as u32),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
//block location is initialized with two values
//the first value represents the location of the first byte after the file header
//the second value represents the first byte of the second data block
//the first data block is always the map header, so the difference is the map header size.
//this information is filled in later after the sizes are known.
let mut block_location=vec![0,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+1;//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,
resource:0,
block_count,
block_location,
};
//probe header length
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 mut offset=file_header_data.len() as u64;
file_header.priming=offset;
file_header.block_location[0]=offset;
offset+=map_header_data.len() as u64;
for position in &mut file_header.block_location[1..]{
*position+=offset;
}
//write (updated) 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(())
}

@ -1,4 +1,3 @@
mod common;
pub mod aabb;
pub mod model;
pub mod integer;

@ -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(),
}
}
}

@ -1,26 +0,0 @@
pub const fn flag(b:bool,mask:u8)->u8{
(-(b as i8) as u8)&mask
}
#[binrw::binrw]
#[brw(little,repr=u8)]
pub enum Boolio{
True,
False
}
impl Into<bool> for Boolio{
fn into(self)->bool{
match self{
Boolio::True=>true,
Boolio::False=>false,
}
}
}
impl From<bool> for Boolio{
fn from(value:bool)->Self{
match value{
true=>Boolio::True,
false=>Boolio::False,
}
}
}

@ -1,22 +1,14 @@
use super::common::{flag,Boolio};
use super::integer::{Time,Planar64,Planar64Vec3};
#[binrw::binrw]
#[brw(little)]
pub struct ContactingLadder{
pub sticky:Boolio,
pub sticky:Option<()>,
}
impl Into<strafesnet_common::gameplay_attributes::ContactingLadder> for ContactingLadder{
fn into(self)->strafesnet_common::gameplay_attributes::ContactingLadder{
strafesnet_common::gameplay_attributes::ContactingLadder{
sticky:self.sticky.into(),
}
}
}
impl From<strafesnet_common::gameplay_attributes::ContactingLadder> for ContactingLadder{
fn from(value:strafesnet_common::gameplay_attributes::ContactingLadder)->Self{
Self{
sticky:value.sticky.into(),
sticky:self.sticky.is_some(),
}
}
}
@ -24,15 +16,10 @@ impl From<strafesnet_common::gameplay_attributes::ContactingLadder> for Contacti
#[binrw::binrw]
#[brw(little)]
pub enum ContactingBehaviour{
#[brw(magic=0u8)]
Surf,
#[brw(magic=1u8)]
Ladder(ContactingLadder),
#[brw(magic=2u8)]
NoJump,
#[brw(magic=3u8)]
Cling,
#[brw(magic=4u8)]
Elastic(u32),
}
impl Into<strafesnet_common::gameplay_attributes::ContactingBehaviour> for ContactingBehaviour{
@ -53,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)]
@ -88,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)]
@ -110,20 +70,11 @@ 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)]
pub enum Booster{
#[brw(magic=0u8)]
Velocity(Planar64Vec3),
#[brw(magic=1u8)]
Energy{direction:Planar64Vec3,energy:Planar64},
}
impl Into<strafesnet_common::gameplay_attributes::Booster> for Booster{
@ -141,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)]
@ -171,38 +109,22 @@ 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)]
pub enum SetTrajectory{
#[brw(magic=0u8)]
AirTime(Time),
#[brw(magic=1u8)]
Height(Planar64),
#[brw(magic=2u8)]
DotVelocity{direction:Planar64Vec3,dot:Planar64},
#[brw(magic=3u8)]
TargetPointTime{
target_point:Planar64Vec3,
time:Time,
},
#[brw(magic=4u8)]
TargetPointSpeed{
target_point:Planar64Vec3,
speed:Planar64,
trajectory_choice:TrajectoryChoice,
},
#[brw(magic=5u8)]
Velocity(Planar64Vec3),
}
impl Into<strafesnet_common::gameplay_attributes::SetTrajectory> for SetTrajectory{
@ -239,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)]
@ -286,33 +174,15 @@ 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)]
pub struct GeneralAttributes{
pub header:u8,
#[br(if(header&Self::BOOSTER!=0))]
pub booster:Option<Booster>,
#[br(if(header&Self::TRAJECTORY!=0))]
pub trajectory:Option<SetTrajectory>,
#[br(if(header&Self::WORMHOLE!=0))]
pub wormhole:Option<Wormhole>,
#[br(if(header&Self::ACCELERATOR!=0))]
pub accelerator:Option<Accelerator>,
}
impl GeneralAttributes{
const BOOSTER:u8=1<<0;
const TRAJECTORY:u8=1<<1;
const WORMHOLE:u8=1<<2;
const ACCELERATOR:u8=1<<3;
}
impl Into<strafesnet_common::gameplay_attributes::GeneralAttributes> for GeneralAttributes{
fn into(self)->strafesnet_common::gameplay_attributes::GeneralAttributes{
strafesnet_common::gameplay_attributes::GeneralAttributes{
@ -323,33 +193,12 @@ 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{
let header=
flag(value.booster.is_some(),GeneralAttributes::BOOSTER)
|flag(value.trajectory.is_some(),GeneralAttributes::TRAJECTORY)
|flag(value.wormhole.is_some(),GeneralAttributes::WORMHOLE)
|flag(value.accelerator.is_some(),GeneralAttributes::ACCELERATOR);
Self{
header,
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)]
pub struct ContactingAttributes{
pub header:u8,
#[br(if(header&Self::CONTACTING_BEHAVIOUR!=0))]
pub contact_behaviour:Option<ContactingBehaviour>,
}
impl ContactingAttributes{
const CONTACTING_BEHAVIOUR:u8=1<<0;
}
impl Into<strafesnet_common::gameplay_attributes::ContactingAttributes> for ContactingAttributes{
fn into(self)->strafesnet_common::gameplay_attributes::ContactingAttributes{
strafesnet_common::gameplay_attributes::ContactingAttributes{
@ -357,25 +206,12 @@ 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{
header:flag(value.contact_behaviour.is_some(),ContactingAttributes::CONTACTING_BEHAVIOUR),
contact_behaviour:value.contact_behaviour.map(Into::into),
}
}
}
#[binrw::binrw]
#[brw(little)]
pub struct IntersectingAttributes{
pub header:u8,
#[br(if(header&Self::INTERSECTING_WATER!=0))]
pub water:Option<IntersectingWater>,
}
impl IntersectingAttributes{
const INTERSECTING_WATER:u8=1<<0;
}
impl Into<strafesnet_common::gameplay_attributes::IntersectingAttributes> for IntersectingAttributes{
fn into(self)->strafesnet_common::gameplay_attributes::IntersectingAttributes{
strafesnet_common::gameplay_attributes::IntersectingAttributes{
@ -383,26 +219,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{
header:flag(value.water.is_some(),IntersectingAttributes::INTERSECTING_WATER),
water:value.water.map(Into::into),
}
}
}
#[binrw::binrw]
#[brw(little)]
pub enum CollisionAttributes{
#[brw(magic=0u8)]
Decoration,
#[brw(magic=1u8)]
Contact{
contacting:ContactingAttributes,
general:GeneralAttributes,
},
#[brw(magic=2u8)]
Intersect{
intersecting:IntersectingAttributes,
general:GeneralAttributes,
@ -420,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()},
}
}
}

@ -1,63 +1,46 @@
use super::common::flag;
#[binrw::binrw]
#[brw(little,repr=u8)]
pub enum StageElementBehaviour{
SpawnAt,//must be standing on top to get effect. except cancollide false
Trigger,
Teleport,
Platform,
//Check(point) acts like a trigger if you haven't hit all the checkpoints on previous stages yet.
//Note that all stage elements act like this, this is just the isolated behaviour.
Check,
Checkpoint,//this is a combined behaviour for Ordered & Unordered in case a model is used multiple times or for both.
}
impl Into<strafesnet_common::gameplay_modes::StageElementBehaviour> for StageElementBehaviour{
fn into(self)->strafesnet_common::gameplay_modes::StageElementBehaviour{
match self{
StageElementBehaviour::SpawnAt=>strafesnet_common::gameplay_modes::StageElementBehaviour::SpawnAt,
StageElementBehaviour::Trigger=>strafesnet_common::gameplay_modes::StageElementBehaviour::Trigger,
StageElementBehaviour::Teleport=>strafesnet_common::gameplay_modes::StageElementBehaviour::Teleport,
StageElementBehaviour::Platform=>strafesnet_common::gameplay_modes::StageElementBehaviour::Platform,
StageElementBehaviour::Check=>strafesnet_common::gameplay_modes::StageElementBehaviour::Check,
StageElementBehaviour::Checkpoint=>strafesnet_common::gameplay_modes::StageElementBehaviour::Checkpoint,
}
}
}
#[binrw::binrw]
#[brw(little)]
pub struct StageElement{
pub header:u8,
pub stage_id:u32,
#[br(if(header&Self::JUMP_LIMIT!=0))]
pub stage_id:u32,//which stage spawn to send to
pub behaviour:StageElementBehaviour,
pub jump_limit:Option<u8>,
}
impl StageElement{
const BEHAVIOUR:u8=0b00111;
const JUMP_LIMIT:u8=1<<3;
const FORCE:u8=1<<4;
const fn behaviour(&self)->Option<strafesnet_common::gameplay_modes::StageElementBehaviour>{
match self.header&Self::BEHAVIOUR{
0=>Some(strafesnet_common::gameplay_modes::StageElementBehaviour::SpawnAt),
1=>Some(strafesnet_common::gameplay_modes::StageElementBehaviour::Trigger),
2=>Some(strafesnet_common::gameplay_modes::StageElementBehaviour::Teleport),
3=>Some(strafesnet_common::gameplay_modes::StageElementBehaviour::Platform),
4=>Some(strafesnet_common::gameplay_modes::StageElementBehaviour::Check),
5=>Some(strafesnet_common::gameplay_modes::StageElementBehaviour::Checkpoint),
_=>None,
}
}
const fn force(&self)->bool{
self.header&Self::FORCE!=0
}
pub force:Option<()>,//allow setting to lower spawn id i.e. 7->3
}
impl Into<strafesnet_common::gameplay_modes::StageElement> for StageElement{
fn into(self)->strafesnet_common::gameplay_modes::StageElement{
strafesnet_common::gameplay_modes::StageElement::new(
strafesnet_common::gameplay_modes::StageId::new(self.stage_id),
self.force(),
self.behaviour().unwrap(),
self.force.is_some(),
self.behaviour.into(),
self.jump_limit,
)
}
}
impl From<strafesnet_common::gameplay_modes::StageElement> for StageElement{
fn from(value:strafesnet_common::gameplay_modes::StageElement)->Self{
let behaviour=match value.behaviour(){
strafesnet_common::gameplay_modes::StageElementBehaviour::SpawnAt=>0,
strafesnet_common::gameplay_modes::StageElementBehaviour::Trigger=>1,
strafesnet_common::gameplay_modes::StageElementBehaviour::Teleport=>2,
strafesnet_common::gameplay_modes::StageElementBehaviour::Platform=>3,
strafesnet_common::gameplay_modes::StageElementBehaviour::Check=>4,
strafesnet_common::gameplay_modes::StageElementBehaviour::Checkpoint=>5,
};
let header=
behaviour
|flag(value.jump_limit().is_some(),StageElement::JUMP_LIMIT)
|flag(value.force(),StageElement::FORCE);
Self{
header,
stage_id:value.stage_id().get(),
jump_limit:value.jump_limit(),
}
}
}
#[binrw::binrw]
#[brw(little)]
@ -88,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)]
@ -124,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)]
@ -169,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(),
}
}
}

@ -1,4 +1,3 @@
use super::common::flag;
use super::integer::{Time,Ratio64,Planar64,Planar64Vec3};
pub type Controls=u32;
@ -6,34 +5,19 @@ pub type Controls=u32;
#[binrw::binrw]
#[brw(little)]
pub struct StyleModifiers{
pub header:u8,
pub controls_mask:Controls,
pub controls_mask_state:Controls,
#[br(if(header&Self::STRAFE!=0))]
pub strafe:Option<StrafeSettings>,
#[br(if(header&Self::ROCKET!=0))]
pub rocket:Option<PropulsionSettings>,
#[br(if(header&Self::JUMP!=0))]
pub jump:Option<JumpSettings>,
#[br(if(header&Self::WALK!=0))]
pub walk:Option<WalkSettings>,
#[br(if(header&Self::LADDER!=0))]
pub ladder:Option<LadderSettings>,
#[br(if(header&Self::SWIM!=0))]
pub swim:Option<PropulsionSettings>,
pub gravity:Planar64Vec3,
pub hitbox:Hitbox,
pub camera_offset:Planar64Vec3,
pub mass:Planar64,
}
impl StyleModifiers{
const STRAFE:u8=1<<0;
const ROCKET:u8=1<<1;
const JUMP:u8=1<<2;
const WALK:u8=1<<3;
const LADDER:u8=1<<4;
const SWIM:u8=1<<5;
}
impl Into<strafesnet_common::gameplay_style::StyleModifiers> for StyleModifiers{
fn into(self)->strafesnet_common::gameplay_style::StyleModifiers{
strafesnet_common::gameplay_style::StyleModifiers{
@ -53,32 +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{
let header=
flag(value.strafe.is_some(),StyleModifiers::STRAFE)
|flag(value.rocket.is_some(),StyleModifiers::ROCKET)
|flag(value.jump.is_some(),StyleModifiers::JUMP)
|flag(value.walk.is_some(),StyleModifiers::WALK)
|flag(value.ladder.is_some(),StyleModifiers::LADDER)
|flag(value.swim.is_some(),StyleModifiers::SWIM);
Self{
header,
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)]
@ -96,17 +54,9 @@ 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,
}
}
}
//TODO: test this
#[binrw::binrw]
#[brw(little)]
pub enum JumpImpulse{
FromTime(Time),
FromHeight(Planar64),
@ -123,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)]
@ -150,29 +90,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)]
pub struct StrafeSettings{
header:u8,
enable:ControlsActivation,
mv:Planar64,
#[br(if(header&Self::AIR_ACCEL_LIMIT!=0))]
air_accel_limit:Option<Planar64>,
tick_rate:Ratio64,
}
impl StrafeSettings{
const AIR_ACCEL_LIMIT:u8=1<<0;
}
impl Into<strafesnet_common::gameplay_style::StrafeSettings> for StrafeSettings{
fn into(self)->strafesnet_common::gameplay_style::StrafeSettings{
strafesnet_common::gameplay_style::StrafeSettings::new(
@ -183,19 +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();
let header=flag(air_accel_limit.is_some(),StrafeSettings::AIR_ACCEL_LIMIT);
Self{
header,
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)]
@ -209,72 +122,21 @@ 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)]
pub struct JumpSettings{
header:u8,
impulse:i64,
}
impl JumpSettings{
const IMPULSE:u8=0b0011;
const CALCULATION:u8=0b1100;
const fn impulse(&self)->Option<strafesnet_common::gameplay_style::JumpImpulse>{
match self.header&Self::IMPULSE{
0=>Some(strafesnet_common::gameplay_style::JumpImpulse::FromTime(strafesnet_common::integer::Time::raw(self.impulse))),
1=>Some(strafesnet_common::gameplay_style::JumpImpulse::FromHeight(strafesnet_common::integer::Planar64::raw(self.impulse))),
2=>Some(strafesnet_common::gameplay_style::JumpImpulse::FromDeltaV(strafesnet_common::integer::Planar64::raw(self.impulse))),
3=>Some(strafesnet_common::gameplay_style::JumpImpulse::FromEnergy(strafesnet_common::integer::Planar64::raw(self.impulse))),
_=>None,
}
}
const fn calculation(&self)->Option<strafesnet_common::gameplay_style::JumpCalculation>{
match (self.header&Self::CALCULATION)>>2{
0=>Some(strafesnet_common::gameplay_style::JumpCalculation::Capped),
1=>Some(strafesnet_common::gameplay_style::JumpCalculation::Energy),
2=>Some(strafesnet_common::gameplay_style::JumpCalculation::Linear),
_=>None,
}
}
impulse:JumpImpulse,
calculation:JumpCalculation,
}
impl Into<strafesnet_common::gameplay_style::JumpSettings> for JumpSettings{
fn into(self)->strafesnet_common::gameplay_style::JumpSettings{
strafesnet_common::gameplay_style::JumpSettings::new(
self.impulse().unwrap(),
self.calculation().unwrap(),
self.impulse.into(),
self.calculation.into(),
)
}
}
impl From<strafesnet_common::gameplay_style::JumpSettings> for JumpSettings{
fn from(value:strafesnet_common::gameplay_style::JumpSettings)->Self{
let (impulse_enum,calculation)=value.into_inner();
let (impulse,impulse_header)=match impulse_enum{
strafesnet_common::gameplay_style::JumpImpulse::FromTime(impulse)=>(impulse.get(),0),
strafesnet_common::gameplay_style::JumpImpulse::FromHeight(impulse)=>(impulse.get(),1),
strafesnet_common::gameplay_style::JumpImpulse::FromDeltaV(impulse)=>(impulse.get(),2),
strafesnet_common::gameplay_style::JumpImpulse::FromEnergy(impulse)=>(impulse.get(),3),
};
let calculation_header=match calculation{
strafesnet_common::gameplay_style::JumpCalculation::Capped=>0,
strafesnet_common::gameplay_style::JumpCalculation::Energy=>1,
strafesnet_common::gameplay_style::JumpCalculation::Linear=>2,
};
let header=
impulse_header
|(calculation_header<<2);
Self{
header,
impulse,
}
}
}
#[binrw::binrw]
#[brw(little)]
@ -290,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)]
@ -317,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)]
@ -343,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)]
@ -367,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)]
@ -390,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(),
}
}
}

@ -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)]

@ -1,6 +1,3 @@
use super::common::flag;
use strafesnet_common::model::PolygonIter;
use super::integer::{Planar64Vec3,Planar64Affine3};
pub type TextureCoordinate=[f32;2];
@ -14,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)]
@ -39,35 +26,11 @@ 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{
pub header:u8,
#[br(if(header&Self::TEXTURE!=0))]
pub texture:Option<u32>,
}
impl RenderConfig{
const TEXTURE:u8=1<<0;
}
impl Into<strafesnet_common::model::RenderConfig> for RenderConfig{
fn into(self)->strafesnet_common::model::RenderConfig{
strafesnet_common::model::RenderConfig{
@ -75,15 +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{
let header=flag(value.texture.is_some(),RenderConfig::TEXTURE);
Self{
header,
texture:value.texture.map(|texture_id|texture_id.get()),
}
}
}
#[binrw::binrw]
#[brw(little)]
pub struct IndexedGraphicsGroup{
@ -92,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{
@ -108,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)]
@ -186,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)]
@ -253,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],
}
}
}