Compare commits
1 Commits
convert
...
block-head
| Author | SHA1 | Date | |
|---|---|---|---|
8162fa90bc
|
159
src/convert.rs
159
src/convert.rs
@@ -1,159 +0,0 @@
|
||||
use crate::v1 as latest;
|
||||
|
||||
// investigate reuse using #[br(map=trey_vec3)]
|
||||
// Vector2
|
||||
// Vector3
|
||||
//
|
||||
// Settings are looking rather destructive, pls ensure all files round-trip
|
||||
|
||||
pub fn from_v0(block_v0:&crate::v0::Block)->latest::Block{
|
||||
let input_events=block_v0.input_events.iter().map(|event|{
|
||||
latest::Timed{
|
||||
time:latest::Time::new(event.time).unwrap(),
|
||||
event:latest::InputEvent{
|
||||
game_controls:event.event.game_controls,
|
||||
mouse_pos:latest::Vector2{x:event.event.mouse_pos.x,y:event.event.mouse_pos.y},
|
||||
},
|
||||
}
|
||||
}).collect();
|
||||
let output_events=block_v0.output_events.iter().map(|event|{
|
||||
latest::Timed{
|
||||
time:latest::Time::new(event.time).unwrap(),
|
||||
event:latest::OutputEvent{
|
||||
tick_info:event.event.tick_info,
|
||||
angles:latest::Vector3{x:event.event.angles.x,y:event.event.angles.y,z:event.event.angles.z},
|
||||
position:latest::Vector3{x:event.event.position.x,y:event.event.position.y,z:event.event.position.z},
|
||||
velocity:latest::Vector3{x:event.event.velocity.x,y:event.event.velocity.y,z:event.event.velocity.z},
|
||||
acceleration:latest::Vector3{x:event.event.acceleration.x,y:event.event.acceleration.y,z:event.event.acceleration.z},
|
||||
},
|
||||
}
|
||||
}).collect();
|
||||
let sound_events=block_v0.sound_events.iter().map(|event|{
|
||||
latest::Timed{
|
||||
time:latest::Time::new(event.time).unwrap(),
|
||||
event:event.event.clone(),
|
||||
}
|
||||
}).collect();
|
||||
let world_events=block_v0.world_events.iter().map(|event|{
|
||||
latest::Timed{
|
||||
time:latest::Time::new(event.time).unwrap(),
|
||||
event:match &event.event{
|
||||
crate::v0::WorldEvent::Reset(world_event_reset)=>latest::WorldEvent::Reset(latest::WorldEventReset{
|
||||
position:latest::Vector3{x:world_event_reset.position.x,y:world_event_reset.position.y,z:world_event_reset.position.z},
|
||||
}),
|
||||
crate::v0::WorldEvent::Button(world_event_button)=>latest::WorldEvent::Button(latest::WorldEventButton{
|
||||
button_id:world_event_button.button_id,
|
||||
}),
|
||||
crate::v0::WorldEvent::SetTime(world_event_set_time)=>latest::WorldEvent::SetTime(latest::WorldEventSetTime{
|
||||
time:latest::Time::new(world_event_set_time.time).unwrap(),
|
||||
}),
|
||||
crate::v0::WorldEvent::SetPaused(world_event_set_paused)=>latest::WorldEvent::SetPaused(latest::WorldEventSetPaused{
|
||||
paused:world_event_set_paused.paused,
|
||||
}),
|
||||
},
|
||||
}
|
||||
}).collect();
|
||||
let gravity_events=block_v0.gravity_events.iter().map(|event|{
|
||||
latest::Timed{
|
||||
time:latest::Time::new(event.time).unwrap(),
|
||||
event:latest::GravityEvent{
|
||||
gravity:latest::Vector3{x:event.event.gravity.x,y:event.event.gravity.y,z:event.event.gravity.z},
|
||||
},
|
||||
}
|
||||
}).collect();
|
||||
// need to generate a setting event for the style in RunPrepare
|
||||
let run_events=block_v0.run_events.iter().map(|event|{
|
||||
latest::Timed{
|
||||
time:latest::Time::new(event.time).unwrap(),
|
||||
event:match &event.event{
|
||||
crate::v0::RunEvent::Prepare(run_event_prepare)=>latest::RunEvent::Prepare(latest::RunEventPrepare{
|
||||
mode:run_event_prepare.mode,
|
||||
}),
|
||||
crate::v0::RunEvent::Start(run_event_zone)=>latest::RunEvent::Start(latest::RunEventZone{
|
||||
mode:run_event_zone.mode,
|
||||
}),
|
||||
crate::v0::RunEvent::Finish(run_event_zone)=>latest::RunEvent::Finish(latest::RunEventZone{
|
||||
mode:run_event_zone.mode,
|
||||
}),
|
||||
crate::v0::RunEvent::Clear(run_event_clear)=>latest::RunEvent::Clear(latest::RunEventClear{
|
||||
mode:run_event_clear.mode,
|
||||
}),
|
||||
crate::v0::RunEvent::Flag(run_event_flag)=>latest::RunEvent::Flag(latest::RunEventFlag{
|
||||
mode:run_event_flag.mode,
|
||||
flag_reason:run_event_flag.flag_reason,
|
||||
}),
|
||||
crate::v0::RunEvent::LoadState(run_event_practice)=>latest::RunEvent::LoadState(latest::RunEventPractice{
|
||||
mode:run_event_practice.mode,
|
||||
state_id:run_event_practice.state_id,
|
||||
}),
|
||||
crate::v0::RunEvent::SaveState(run_event_practice)=>latest::RunEvent::SaveState(latest::RunEventPractice{
|
||||
mode:run_event_practice.mode,
|
||||
state_id:run_event_practice.state_id,
|
||||
}),
|
||||
},
|
||||
}
|
||||
}).collect();
|
||||
let camera_events=block_v0.camera_events.iter().map(|event|{
|
||||
latest::Timed{
|
||||
time:latest::Time::new(event.time).unwrap(),
|
||||
event:match &event.event{
|
||||
crate::v0::CameraEvent::CameraPunch(camera_event_camera_punch)=>latest::CameraEvent::CameraPunch(latest::CameraEventCameraPunch{
|
||||
rot_velocity:latest::Vector3{x:camera_event_camera_punch.rot_velocity.x,y:camera_event_camera_punch.rot_velocity.y,z:camera_event_camera_punch.rot_velocity.z},
|
||||
}),
|
||||
crate::v0::CameraEvent::Transform(camera_event_transform)=>latest::CameraEvent::Transform(latest::CameraEventTransform{
|
||||
axis_angle:latest::Vector3{x:camera_event_transform.axis_angle.x,y:camera_event_transform.axis_angle.y,z:camera_event_transform.axis_angle.z},
|
||||
}),
|
||||
},
|
||||
}
|
||||
}).collect();
|
||||
let setting_events=block_v0.setting_events.iter().map(|event|{
|
||||
latest::Timed{
|
||||
time:latest::Time::new(event.time).unwrap(),
|
||||
event:match &event.event{
|
||||
crate::v0::SettingEvent::FieldOfView(setting_event_field_of_view)=>{
|
||||
// generate three events
|
||||
// - FOV
|
||||
// - SensX
|
||||
// - SensY
|
||||
todo!();
|
||||
},
|
||||
crate::v0::SettingEvent::Sensitivity(setting_event_sensitivity)=>{
|
||||
// calculate absolute sensitivity from current fov
|
||||
// generate two events
|
||||
// - SensX
|
||||
// - SensY
|
||||
todo!();
|
||||
},
|
||||
crate::v0::SettingEvent::VerticalSensitivityMultiplier(setting_event_vertical_sensitivity_multiplier)=>{
|
||||
// calculate absolute horizontal sensitivity
|
||||
// generate one event
|
||||
// - SensY
|
||||
let sensitivity=todo!();
|
||||
latest::SettingEvent::SensitivityY(latest::SettingEventSensitivity{
|
||||
sensitivity,
|
||||
})
|
||||
},
|
||||
crate::v0::SettingEvent::AbsoluteSensitivity(setting_event_absolute_sensitivity)=>{
|
||||
// calculate SensY from current VerticalSensitivityMultiplier
|
||||
// generate two events
|
||||
// - SensX
|
||||
// - SensY
|
||||
todo!();
|
||||
},
|
||||
crate::v0::SettingEvent::TurnSpeed(setting_event_turn_speed)=>latest::SettingEvent::TurnSpeed(latest::SettingEventTurnSpeed{
|
||||
turn_speed:setting_event_turn_speed.turn_speed,
|
||||
}),
|
||||
},
|
||||
}
|
||||
}).collect();
|
||||
latest::Block{
|
||||
input_events,
|
||||
output_events,
|
||||
sound_events,
|
||||
world_events,
|
||||
gravity_events,
|
||||
run_events,
|
||||
camera_events,
|
||||
setting_events,
|
||||
}
|
||||
}
|
||||
@@ -2,7 +2,6 @@ pub use binrw::Error as BinrwError;
|
||||
|
||||
pub mod v0;
|
||||
pub mod v1;
|
||||
pub mod convert;
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests;
|
||||
|
||||
65
src/v1.rs
65
src/v1.rs
@@ -363,25 +363,17 @@ enum EventType{
|
||||
#[binrw]
|
||||
#[brw(little)]
|
||||
struct BlockHeader{
|
||||
num_input_events:u16,
|
||||
num_output_events:u16,
|
||||
num_sound_events:u16,
|
||||
num_world_events:u16,
|
||||
num_gravity_events:u16,
|
||||
num_run_events:u16,
|
||||
num_camera_events:u16,
|
||||
num_setting_events:u16,
|
||||
num_events:[u16;8],
|
||||
}
|
||||
impl BlockHeader{
|
||||
fn payload_size(&self)->usize{
|
||||
self.num_input_events as usize*EVENT_SIZE[EventType::Input as usize]
|
||||
+self.num_output_events as usize*EVENT_SIZE[EventType::Output as usize]
|
||||
+self.num_sound_events as usize*EVENT_SIZE[EventType::Sound as usize]
|
||||
+self.num_world_events as usize*EVENT_SIZE[EventType::World as usize]
|
||||
+self.num_gravity_events as usize*EVENT_SIZE[EventType::Gravity as usize]
|
||||
+self.num_run_events as usize*EVENT_SIZE[EventType::Run as usize]
|
||||
+self.num_camera_events as usize*EVENT_SIZE[EventType::Camera as usize]
|
||||
+self.num_setting_events as usize*EVENT_SIZE[EventType::Setting as usize]
|
||||
self.num_events
|
||||
.into_iter()
|
||||
.zip(EVENT_SIZE)
|
||||
.map(|(num_events,event_size)|
|
||||
num_events as usize*event_size
|
||||
)
|
||||
.sum()
|
||||
}
|
||||
}
|
||||
|
||||
@@ -419,14 +411,14 @@ impl Block{
|
||||
let mut buffer=Vec::with_capacity(block_header.payload_size());
|
||||
zstd::stream::copy_decode(data,&mut buffer)?;
|
||||
let mut reader=std::io::Cursor::new(buffer);
|
||||
read_data_into_events(&mut reader,&mut self.input_events,block_header.num_input_events as usize,Vec::reserve_exact)?;
|
||||
read_data_into_events(&mut reader,&mut self.output_events,block_header.num_output_events as usize,Vec::reserve_exact)?;
|
||||
read_data_into_events(&mut reader,&mut self.sound_events,block_header.num_sound_events as usize,Vec::reserve_exact)?;
|
||||
read_data_into_events(&mut reader,&mut self.world_events,block_header.num_world_events as usize,Vec::reserve_exact)?;
|
||||
read_data_into_events(&mut reader,&mut self.gravity_events,block_header.num_gravity_events as usize,Vec::reserve_exact)?;
|
||||
read_data_into_events(&mut reader,&mut self.run_events,block_header.num_run_events as usize,Vec::reserve_exact)?;
|
||||
read_data_into_events(&mut reader,&mut self.camera_events,block_header.num_camera_events as usize,Vec::reserve_exact)?;
|
||||
read_data_into_events(&mut reader,&mut self.setting_events,block_header.num_setting_events as usize,Vec::reserve_exact)?;
|
||||
read_data_into_events(&mut reader,&mut self.input_events,block_header.num_events[EventType::Input as usize] as usize,Vec::reserve_exact)?;
|
||||
read_data_into_events(&mut reader,&mut self.output_events,block_header.num_events[EventType::Output as usize] as usize,Vec::reserve_exact)?;
|
||||
read_data_into_events(&mut reader,&mut self.sound_events,block_header.num_events[EventType::Sound as usize] as usize,Vec::reserve_exact)?;
|
||||
read_data_into_events(&mut reader,&mut self.world_events,block_header.num_events[EventType::World as usize] as usize,Vec::reserve_exact)?;
|
||||
read_data_into_events(&mut reader,&mut self.gravity_events,block_header.num_events[EventType::Gravity as usize] as usize,Vec::reserve_exact)?;
|
||||
read_data_into_events(&mut reader,&mut self.run_events,block_header.num_events[EventType::Run as usize] as usize,Vec::reserve_exact)?;
|
||||
read_data_into_events(&mut reader,&mut self.camera_events,block_header.num_events[EventType::Camera as usize] as usize,Vec::reserve_exact)?;
|
||||
read_data_into_events(&mut reader,&mut self.setting_events,block_header.num_events[EventType::Setting as usize] as usize,Vec::reserve_exact)?;
|
||||
Ok(())
|
||||
}
|
||||
/// Read a complete data block and append the elements to the timelines in this block.
|
||||
@@ -436,14 +428,14 @@ impl Block{
|
||||
let mut buffer=Vec::with_capacity(block_header.payload_size());
|
||||
zstd::stream::copy_decode(data,&mut buffer)?;
|
||||
let mut reader=std::io::Cursor::new(buffer);
|
||||
read_data_into_events(&mut reader,&mut self.input_events,block_header.num_input_events as usize,Vec::reserve)?;
|
||||
read_data_into_events(&mut reader,&mut self.output_events,block_header.num_output_events as usize,Vec::reserve)?;
|
||||
read_data_into_events(&mut reader,&mut self.sound_events,block_header.num_sound_events as usize,Vec::reserve)?;
|
||||
read_data_into_events(&mut reader,&mut self.world_events,block_header.num_world_events as usize,Vec::reserve)?;
|
||||
read_data_into_events(&mut reader,&mut self.gravity_events,block_header.num_gravity_events as usize,Vec::reserve)?;
|
||||
read_data_into_events(&mut reader,&mut self.run_events,block_header.num_run_events as usize,Vec::reserve)?;
|
||||
read_data_into_events(&mut reader,&mut self.camera_events,block_header.num_camera_events as usize,Vec::reserve)?;
|
||||
read_data_into_events(&mut reader,&mut self.setting_events,block_header.num_setting_events as usize,Vec::reserve)?;
|
||||
read_data_into_events(&mut reader,&mut self.input_events,block_header.num_events[EventType::Input as usize] as usize,Vec::reserve)?;
|
||||
read_data_into_events(&mut reader,&mut self.output_events,block_header.num_events[EventType::Output as usize] as usize,Vec::reserve)?;
|
||||
read_data_into_events(&mut reader,&mut self.sound_events,block_header.num_events[EventType::Sound as usize] as usize,Vec::reserve)?;
|
||||
read_data_into_events(&mut reader,&mut self.world_events,block_header.num_events[EventType::World as usize] as usize,Vec::reserve)?;
|
||||
read_data_into_events(&mut reader,&mut self.gravity_events,block_header.num_events[EventType::Gravity as usize] as usize,Vec::reserve)?;
|
||||
read_data_into_events(&mut reader,&mut self.run_events,block_header.num_events[EventType::Run as usize] as usize,Vec::reserve)?;
|
||||
read_data_into_events(&mut reader,&mut self.camera_events,block_header.num_events[EventType::Camera as usize] as usize,Vec::reserve)?;
|
||||
read_data_into_events(&mut reader,&mut self.setting_events,block_header.num_events[EventType::Setting as usize] as usize,Vec::reserve)?;
|
||||
Ok(())
|
||||
}
|
||||
fn extend_from_block_id_iter<'a,R:BinReaderExt>(&mut self,mut data:R,block_timelines:&BlockTimelines,blocks:impl IntoIterator<Item=&'a Timed<BlockId>>)->Result<(),Error>{
|
||||
@@ -653,14 +645,7 @@ pub fn serialize<W:binrw::BinWriterExt>(block:&Block,writer:&mut W)->Result<(),B
|
||||
}
|
||||
fn header(&self)->BlockHeader{
|
||||
BlockHeader{
|
||||
num_input_events:self.0[EventType::Input as usize].len() as u16,
|
||||
num_output_events:self.0[EventType::Output as usize].len() as u16,
|
||||
num_sound_events:self.0[EventType::Sound as usize].len() as u16,
|
||||
num_world_events:self.0[EventType::World as usize].len() as u16,
|
||||
num_gravity_events:self.0[EventType::Gravity as usize].len() as u16,
|
||||
num_run_events:self.0[EventType::Run as usize].len() as u16,
|
||||
num_camera_events:self.0[EventType::Camera as usize].len() as u16,
|
||||
num_setting_events:self.0[EventType::Setting as usize].len() as u16,
|
||||
num_events:self.0.map(|events|events.len() as u16),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user