From 47aef14ff3cdcb58adde58e07724049388e07ea5 Mon Sep 17 00:00:00 2001 From: Quaternions Date: Thu, 25 Jul 2024 15:35:51 -0700 Subject: [PATCH] newtypes from engine types (boilerplate) --- src/newtypes/aabb.rs | 8 ++ src/newtypes/gameplay_attributes.rs | 145 ++++++++++++++++++++++++++++ src/newtypes/gameplay_modes.rs | 73 ++++++++++++++ src/newtypes/gameplay_style.rs | 117 ++++++++++++++++++++++ src/newtypes/integer.rs | 8 ++ src/newtypes/model.rs | 116 ++++++++++++++++++++++ 6 files changed, 467 insertions(+) diff --git a/src/newtypes/aabb.rs b/src/newtypes/aabb.rs index 3908287..ae8cb52 100644 --- a/src/newtypes/aabb.rs +++ b/src/newtypes/aabb.rs @@ -13,3 +13,11 @@ impl Into for Aabb{ ) } } +impl From for Aabb{ + fn from(value:strafesnet_common::aabb::Aabb)->Self{ + Self{ + max:value.max().get().to_array(), + min:value.min().get().to_array(), + } + } +} diff --git a/src/newtypes/gameplay_attributes.rs b/src/newtypes/gameplay_attributes.rs index 10921cd..c8039d7 100644 --- a/src/newtypes/gameplay_attributes.rs +++ b/src/newtypes/gameplay_attributes.rs @@ -12,6 +12,16 @@ impl Into for Contacti } } } +impl From 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 for Conta } } } +impl From 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 for Interse } } } +impl From 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 for Accelerator{ } } } +impl From 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 for Booster{ } } } +impl From 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 for Trajecto } } } +impl From 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 for SetTrajecto } } } +impl From 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 for Wormhole{ } } } +impl From 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 for General } } } +impl From 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 for Cont } } } +impl From 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 for In } } } +impl From 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 for Colli } } } +impl From 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()}, + } + } +} diff --git a/src/newtypes/gameplay_modes.rs b/src/newtypes/gameplay_modes.rs index 73c2eb4..aa7848e 100644 --- a/src/newtypes/gameplay_modes.rs +++ b/src/newtypes/gameplay_modes.rs @@ -22,6 +22,18 @@ impl Into for StageEle } } } +impl From 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 for StageElement{ ) } } +impl From 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 for Stage{ ) } } +impl From 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 for Zone{ } } } +impl From 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 for Mode{ ) } } +impl From 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(), + } + } +} diff --git a/src/newtypes/gameplay_style.rs b/src/newtypes/gameplay_style.rs index 71c8320..1983a22 100644 --- a/src/newtypes/gameplay_style.rs +++ b/src/newtypes/gameplay_style.rs @@ -37,6 +37,24 @@ impl Into for StyleModifiers{ } } } +impl From 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 for JumpCalculatio } } } +impl From 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 for JumpImpulse{ } } } +impl From 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 for ControlsAct ) } } +impl From 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 for StrafeSettings{ ) } } +impl From 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 for PropulsionS ) } } +impl From 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 for JumpSettings{ ) } } +impl From 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 for AccelerateS ) } } +impl From 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 for WalkSettings{ ) } } +impl From 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 for LadderSettings{ ) } } +impl From 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 for HitboxMesh{ } } } +impl From 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 for Hitbox{ } } } +impl From for Hitbox{ + fn from(value:strafesnet_common::gameplay_style::Hitbox)->Self{ + Self{ + halfsize:value.halfsize.get().to_array(), + mesh:value.mesh.into(), + } + } +} diff --git a/src/newtypes/integer.rs b/src/newtypes/integer.rs index 86a8b8c..f75ba70 100644 --- a/src/newtypes/integer.rs +++ b/src/newtypes/integer.rs @@ -11,6 +11,14 @@ impl Into for Ratio64{ strafesnet_common::integer::Ratio64::new(self.num,self.den).unwrap() } } +impl From for Ratio64{ + fn from(value:strafesnet_common::integer::Ratio64)->Self{ + Self{ + num:value.num(), + den:value.den(), + } + } +} #[binrw::binrw] #[brw(little)] diff --git a/src/newtypes/model.rs b/src/newtypes/model.rs index 1ad02f3..4d42aa9 100644 --- a/src/newtypes/model.rs +++ b/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 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, } +impl From for PolygonGroup{ + fn from(value:strafesnet_common::model::PolygonGroup)->Self{ + match value{ + strafesnet_common::model::PolygonGroup::PolygonList(polygon_list)=>{ + let polys:Vec=polygon_list.polys().map(|poly|{ + let vertices:Vec=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 for RenderConfig{ } } } +impl From 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, } +impl From 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, } +impl From 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 for Mesh{ } } } +impl From 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 for Model{ } } } +impl From 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], + } + } +}