colin/mslicer
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add little endian serde functions

Browse Source
This commit is contained in:
Connor Slade
2024-09-02 22:08:45 -04:00
parent b9c6958ee1
commit a55f2eb130
15 changed files with 224 additions and 165 deletions
Download Patch File Download Diff File Expand all files Collapse all files

65
common/src/serde/deserializer.rs
View File

@@ -1,3 +1,5 @@
use std::mem;
use super::SizedString; use super::SizedString;
pub struct Deserializer<'a> { pub struct Deserializer<'a> {
@@ -18,6 +20,18 @@ impl<'a> Deserializer<'a> {
self.offset self.offset
} }
pub fn advance_by(&mut self, amount: usize) {
self.offset += amount;
}
pub fn advance<T>(&mut self) {
self.advance_by(mem::size_of::<T>());
}
pub fn jump_to(&mut self, pos: usize) {
self.offset = pos;
}
pub fn read_bool(&mut self) -> bool { pub fn read_bool(&mut self) -> bool {
self.read_u8() != 0 self.read_u8() != 0
} }
@@ -28,13 +42,19 @@ impl<'a> Deserializer<'a> {
value value
} }
pub fn read_u16(&mut self) -> u16 { pub fn read_u16_be(&mut self) -> u16 {
let value = u16::from_be_bytes([self.buffer[self.offset], self.buffer[self.offset + 1]]); let value = u16::from_be_bytes([self.buffer[self.offset], self.buffer[self.offset + 1]]);
self.offset += 2; self.offset += 2;
value value
} }
pub fn read_u32(&mut self) -> u32 { pub fn read_u16_le(&mut self) -> u16 {
let value = u16::from_le_bytes([self.buffer[self.offset], self.buffer[self.offset + 1]]);
self.offset += 2;
value
}
pub fn read_u32_be(&mut self) -> u32 {
let value = u32::from_be_bytes([ let value = u32::from_be_bytes([
self.buffer[self.offset], self.buffer[self.offset],
self.buffer[self.offset + 1], self.buffer[self.offset + 1],
@@ -45,7 +65,18 @@ impl<'a> Deserializer<'a> {
value value
} }
pub fn read_u64(&mut self) -> u64 { pub fn read_u32_le(&mut self) -> u32 {
let value = u32::from_le_bytes([
self.buffer[self.offset],
self.buffer[self.offset + 1],
self.buffer[self.offset + 2],
self.buffer[self.offset + 3],
]);
self.offset += 4;
value
}
pub fn read_u64_be(&mut self) -> u64 {
let value = u64::from_be_bytes([ let value = u64::from_be_bytes([
self.buffer[self.offset], self.buffer[self.offset],
self.buffer[self.offset + 1], self.buffer[self.offset + 1],
@@ -60,7 +91,22 @@ impl<'a> Deserializer<'a> {
value value
} }
pub fn read_f32(&mut self) -> f32 { pub fn read_u64_le(&mut self) -> u64 {
let value = u64::from_le_bytes([
self.buffer[self.offset],
self.buffer[self.offset + 1],
self.buffer[self.offset + 2],
self.buffer[self.offset + 3],
self.buffer[self.offset + 4],
self.buffer[self.offset + 5],
self.buffer[self.offset + 6],
self.buffer[self.offset + 7],
]);
self.offset += 8;
value
}
pub fn read_f32_be(&mut self) -> f32 {
let value = f32::from_be_bytes([ let value = f32::from_be_bytes([
self.buffer[self.offset], self.buffer[self.offset],
self.buffer[self.offset + 1], self.buffer[self.offset + 1],
@@ -71,6 +117,17 @@ impl<'a> Deserializer<'a> {
value value
} }
pub fn read_f32_le(&mut self) -> f32 {
let value = f32::from_le_bytes([
self.buffer[self.offset],
self.buffer[self.offset + 1],
self.buffer[self.offset + 2],
self.buffer[self.offset + 3],
]);
self.offset += 4;
value
}
pub fn read_bytes(&mut self, length: usize) -> &'a [u8] { pub fn read_bytes(&mut self, length: usize) -> &'a [u8] {
let value = &self.buffer[self.offset..self.offset + length]; let value = &self.buffer[self.offset..self.offset + length];
self.offset += length; self.offset += length;

24
common/src/serde/serializer.rs
View File

@@ -3,10 +3,10 @@ use super::SizedString;
pub trait Serializer { pub trait Serializer {
fn write_bool(&mut self, data: bool); fn write_bool(&mut self, data: bool);
fn write_u8(&mut self, data: u8); fn write_u8(&mut self, data: u8);
fn write_u16(&mut self, data: u16); fn write_u16_be(&mut self, data: u16);
fn write_u32(&mut self, data: u32); fn write_u32_be(&mut self, data: u32);
fn write_u64(&mut self, data: u64); fn write_u64_be(&mut self, data: u64);
fn write_f32(&mut self, data: f32); fn write_f32_be(&mut self, data: f32);
fn write_bytes(&mut self, data: &[u8]); fn write_bytes(&mut self, data: &[u8]);
fn write_sized_string<const SIZE: usize>(&mut self, data: &SizedString<SIZE>); fn write_sized_string<const SIZE: usize>(&mut self, data: &SizedString<SIZE>);
} }
@@ -46,22 +46,22 @@ impl Serializer for SizedSerializer<'_> {
self.offset += 1; self.offset += 1;
} }
fn write_u16(&mut self, data: u16) { fn write_u16_be(&mut self, data: u16) {
self.buffer[self.offset..self.offset + 2].copy_from_slice(&data.to_be_bytes()); self.buffer[self.offset..self.offset + 2].copy_from_slice(&data.to_be_bytes());
self.offset += 2; self.offset += 2;
} }
fn write_u32(&mut self, data: u32) { fn write_u32_be(&mut self, data: u32) {
self.buffer[self.offset..self.offset + 4].copy_from_slice(&data.to_be_bytes()); self.buffer[self.offset..self.offset + 4].copy_from_slice(&data.to_be_bytes());
self.offset += 4; self.offset += 4;
} }
fn write_u64(&mut self, data: u64) { fn write_u64_be(&mut self, data: u64) {
self.buffer[self.offset..self.offset + 8].copy_from_slice(&data.to_be_bytes()); self.buffer[self.offset..self.offset + 8].copy_from_slice(&data.to_be_bytes());
self.offset += 8; self.offset += 8;
} }
fn write_f32(&mut self, data: f32) { fn write_f32_be(&mut self, data: f32) {
self.buffer[self.offset..self.offset + 4].copy_from_slice(&data.to_be_bytes()); self.buffer[self.offset..self.offset + 4].copy_from_slice(&data.to_be_bytes());
self.offset += 4; self.offset += 4;
} }
@@ -87,19 +87,19 @@ impl Serializer for DynamicSerializer {
self.buffer.push(data); self.buffer.push(data);
} }
fn write_u16(&mut self, data: u16) { fn write_u16_be(&mut self, data: u16) {
self.buffer.extend_from_slice(&data.to_be_bytes()); self.buffer.extend_from_slice(&data.to_be_bytes());
} }
fn write_u32(&mut self, data: u32) { fn write_u32_be(&mut self, data: u32) {
self.buffer.extend_from_slice(&data.to_be_bytes()); self.buffer.extend_from_slice(&data.to_be_bytes());
} }
fn write_u64(&mut self, data: u64) { fn write_u64_be(&mut self, data: u64) {
self.buffer.extend_from_slice(&data.to_be_bytes()); self.buffer.extend_from_slice(&data.to_be_bytes());
} }
fn write_f32(&mut self, data: f32) { fn write_f32_be(&mut self, data: f32) {
self.buffer.extend_from_slice(&data.to_be_bytes()); self.buffer.extend_from_slice(&data.to_be_bytes());
} }

4
goo_format/src/default.rs
View File

@@ -1,8 +1,8 @@
use common::serde::SizedString; use common::serde::SizedString;
use crate::{header_info::ExposureDelayMode, HeaderInfo, LayerContent, PreviewImage}; use crate::{header::ExposureDelayMode, Header, LayerContent, PreviewImage};
impl Default for HeaderInfo { impl Default for Header {
fn default() -> Self { fn default() -> Self {
Self { Self {
version: SizedString::new(b"V3.0"), version: SizedString::new(b"V3.0"),

10
goo_format/src/file.rs
View File

@@ -6,15 +6,15 @@ use common::{
serde::{Deserializer, Serializer, SizedString}, serde::{Deserializer, Serializer, SizedString},
}; };
use crate::{HeaderInfo, LayerContent, ENDING_STRING}; use crate::{Header, LayerContent, ENDING_STRING};
pub struct File { pub struct File {
pub header: HeaderInfo, pub header: Header,
pub layers: Vec<LayerContent>, pub layers: Vec<LayerContent>,
} }
impl File { impl File {
pub fn new(header: HeaderInfo, layers: Vec<LayerContent>) -> Self { pub fn new(header: Header, layers: Vec<LayerContent>) -> Self {
Self { header, layers } Self { header, layers }
} }
@@ -37,7 +37,7 @@ impl File {
+ slice_config.first_layers as f32 * bottom_layer_time; + slice_config.first_layers as f32 * bottom_layer_time;
Self::new( Self::new(
HeaderInfo { Header {
x_resolution: slice_config.platform_resolution.x as u16, x_resolution: slice_config.platform_resolution.x as u16,
y_resolution: slice_config.platform_resolution.y as u16, y_resolution: slice_config.platform_resolution.y as u16,
x_size: slice_config.platform_size.x, x_size: slice_config.platform_size.x,
@@ -87,7 +87,7 @@ impl File {
pub fn deserialize(buf: &[u8]) -> Result<Self> { pub fn deserialize(buf: &[u8]) -> Result<Self> {
let mut des = Deserializer::new(buf); let mut des = Deserializer::new(buf);
let header = HeaderInfo::deserialize(&mut des)?; let header = Header::deserialize(&mut des)?;
let mut layers = Vec::with_capacity(header.layer_count as usize); let mut layers = Vec::with_capacity(header.layer_count as usize);
for _ in 0..header.layer_count { for _ in 0..header.layer_count {

184
goo_format/src/header_info.rs → goo_format/src/header.rs
View File

@@ -7,7 +7,7 @@ use common::serde::{Deserializer, Serializer, SizedString};
use crate::{PreviewImage, DELIMITER, MAGIC_TAG}; use crate::{PreviewImage, DELIMITER, MAGIC_TAG};
/// The header section of a `.goo` file. /// The header section of a `.goo` file.
pub struct HeaderInfo { pub struct Header {
/// Format version, should be "V3.0". /// Format version, should be "V3.0".
pub version: SizedString<4>, pub version: SizedString<4>,
/// Name of software that generated the file. /// Name of software that generated the file.
@@ -142,12 +142,12 @@ pub enum ExposureDelayMode {
StaticTime, StaticTime,
} }
impl HeaderInfo { impl Header {
pub const SIZE: usize = 0x2FB95; pub const SIZE: usize = 0x2FB95;
} }
// this is fine // this is fine
impl HeaderInfo { impl Header {
pub fn serialize<T: Serializer>(&self, ser: &mut T) { pub fn serialize<T: Serializer>(&self, ser: &mut T) {
ser.write_sized_string(&self.version); ser.write_sized_string(&self.version);
ser.write_bytes(MAGIC_TAG); ser.write_bytes(MAGIC_TAG);
@@ -157,60 +157,60 @@ impl HeaderInfo {
ser.write_sized_string(&self.printer_name); ser.write_sized_string(&self.printer_name);
ser.write_sized_string(&self.printer_type); ser.write_sized_string(&self.printer_type);
ser.write_sized_string(&self.profile_name); ser.write_sized_string(&self.profile_name);
ser.write_u16(self.anti_aliasing_level); ser.write_u16_be(self.anti_aliasing_level);
ser.write_u16(self.grey_level); ser.write_u16_be(self.grey_level);
ser.write_u16(self.blur_level); ser.write_u16_be(self.blur_level);
self.small_preview.serializes(ser); self.small_preview.serializes(ser);
ser.write_bytes(DELIMITER); ser.write_bytes(DELIMITER);
self.big_preview.serializes(ser); self.big_preview.serializes(ser);
ser.write_bytes(DELIMITER); ser.write_bytes(DELIMITER);
ser.write_u32(self.layer_count); ser.write_u32_be(self.layer_count);
ser.write_u16(self.x_resolution); ser.write_u16_be(self.x_resolution);
ser.write_u16(self.y_resolution); ser.write_u16_be(self.y_resolution);
ser.write_bool(self.x_mirror); ser.write_bool(self.x_mirror);
ser.write_bool(self.y_mirror); ser.write_bool(self.y_mirror);
ser.write_f32(self.x_size); ser.write_f32_be(self.x_size);
ser.write_f32(self.y_size); ser.write_f32_be(self.y_size);
ser.write_f32(self.z_size); ser.write_f32_be(self.z_size);
ser.write_f32(self.layer_thickness); ser.write_f32_be(self.layer_thickness);
ser.write_f32(self.exposure_time); ser.write_f32_be(self.exposure_time);
ser.write_u8(self.exposure_delay_mode as u8); ser.write_u8(self.exposure_delay_mode as u8);
ser.write_f32(self.turn_off_time); ser.write_f32_be(self.turn_off_time);
ser.write_f32(self.bottom_before_lift_time); ser.write_f32_be(self.bottom_before_lift_time);
ser.write_f32(self.bottom_after_lift_time); ser.write_f32_be(self.bottom_after_lift_time);
ser.write_f32(self.bottom_after_retract_time); ser.write_f32_be(self.bottom_after_retract_time);
ser.write_f32(self.before_lift_time); ser.write_f32_be(self.before_lift_time);
ser.write_f32(self.after_lift_time); ser.write_f32_be(self.after_lift_time);
ser.write_f32(self.after_retract_time); ser.write_f32_be(self.after_retract_time);
ser.write_f32(self.bottom_exposure_time); ser.write_f32_be(self.bottom_exposure_time);
ser.write_u32(self.bottom_layers); ser.write_u32_be(self.bottom_layers);
ser.write_f32(self.bottom_lift_distance); ser.write_f32_be(self.bottom_lift_distance);
ser.write_f32(self.bottom_lift_speed); ser.write_f32_be(self.bottom_lift_speed);
ser.write_f32(self.lift_distance); ser.write_f32_be(self.lift_distance);
ser.write_f32(self.lift_speed); ser.write_f32_be(self.lift_speed);
ser.write_f32(self.bottom_retract_distance); ser.write_f32_be(self.bottom_retract_distance);
ser.write_f32(self.bottom_retract_speed); ser.write_f32_be(self.bottom_retract_speed);
ser.write_f32(self.retract_distance); ser.write_f32_be(self.retract_distance);
ser.write_f32(self.retract_speed); ser.write_f32_be(self.retract_speed);
ser.write_f32(self.bottom_second_lift_distance); ser.write_f32_be(self.bottom_second_lift_distance);
ser.write_f32(self.bottom_second_lift_speed); ser.write_f32_be(self.bottom_second_lift_speed);
ser.write_f32(self.second_lift_distance); ser.write_f32_be(self.second_lift_distance);
ser.write_f32(self.second_lift_speed); ser.write_f32_be(self.second_lift_speed);
ser.write_f32(self.bottom_second_retract_distance); ser.write_f32_be(self.bottom_second_retract_distance);
ser.write_f32(self.bottom_second_retract_speed); ser.write_f32_be(self.bottom_second_retract_speed);
ser.write_f32(self.second_retract_distance); ser.write_f32_be(self.second_retract_distance);
ser.write_f32(self.second_retract_speed); ser.write_f32_be(self.second_retract_speed);
ser.write_u16(self.bottom_light_pwm as u16); ser.write_u16_be(self.bottom_light_pwm as u16);
ser.write_u16(self.light_pwm as u16); ser.write_u16_be(self.light_pwm as u16);
ser.write_bool(self.per_layer_settings); ser.write_bool(self.per_layer_settings);
ser.write_u32(self.printing_time); ser.write_u32_be(self.printing_time);
ser.write_f32(self.total_volume); ser.write_f32_be(self.total_volume);
ser.write_f32(self.total_weight); ser.write_f32_be(self.total_weight);
ser.write_f32(self.total_price); ser.write_f32_be(self.total_price);
ser.write_sized_string(&self.price_unit); ser.write_sized_string(&self.price_unit);
ser.write_u32(Self::SIZE as u32); ser.write_u32_be(Self::SIZE as u32);
ser.write_bool(self.grey_scale_level); ser.write_bool(self.grey_scale_level);
ser.write_u16(self.transition_layers); ser.write_u16_be(self.transition_layers);
} }
pub fn deserialize(des: &mut Deserializer) -> Result<Self> { pub fn deserialize(des: &mut Deserializer) -> Result<Self> {
@@ -222,60 +222,60 @@ impl HeaderInfo {
let printer_name = des.read_sized_string(); let printer_name = des.read_sized_string();
let printer_type = des.read_sized_string(); let printer_type = des.read_sized_string();
let profile_name = des.read_sized_string(); let profile_name = des.read_sized_string();
let anti_aliasing_level = des.read_u16(); let anti_aliasing_level = des.read_u16_be();
let grey_level = des.read_u16(); let grey_level = des.read_u16_be();
let blur_level = des.read_u16(); let blur_level = des.read_u16_be();
let small_preview = PreviewImage::deserializes(des); let small_preview = PreviewImage::deserializes(des);
ensure!(des.read_bytes(2) == [0xd, 0xa]); ensure!(des.read_bytes(2) == [0xd, 0xa]);
let big_preview = PreviewImage::deserializes(des); let big_preview = PreviewImage::deserializes(des);
ensure!(des.read_bytes(2) == [0xd, 0xa]); ensure!(des.read_bytes(2) == [0xd, 0xa]);
let layer_count = des.read_u32(); let layer_count = des.read_u32_be();
let x_resolution = des.read_u16(); let x_resolution = des.read_u16_be();
let y_resolution = des.read_u16(); let y_resolution = des.read_u16_be();
let x_mirror = des.read_bool(); let x_mirror = des.read_bool();
let y_mirror = des.read_bool(); let y_mirror = des.read_bool();
let x_size = des.read_f32(); let x_size = des.read_f32_be();
let y_size = des.read_f32(); let y_size = des.read_f32_be();
let z_size = des.read_f32(); let z_size = des.read_f32_be();
let layer_thickness = des.read_f32(); let layer_thickness = des.read_f32_be();
let exposure_time = des.read_f32(); let exposure_time = des.read_f32_be();
let exposure_delay_mode = ExposureDelayMode::from_bool(des.read_bool()); let exposure_delay_mode = ExposureDelayMode::from_bool(des.read_bool());
let turn_off_time = des.read_f32(); let turn_off_time = des.read_f32_be();
let bottom_before_lift_time = des.read_f32(); let bottom_before_lift_time = des.read_f32_be();
let bottom_after_lift_time = des.read_f32(); let bottom_after_lift_time = des.read_f32_be();
let bottom_after_retract_time = des.read_f32(); let bottom_after_retract_time = des.read_f32_be();
let before_lift_time = des.read_f32(); let before_lift_time = des.read_f32_be();
let after_lift_time = des.read_f32(); let after_lift_time = des.read_f32_be();
let after_retract_time = des.read_f32(); let after_retract_time = des.read_f32_be();
let bottom_exposure_time = des.read_f32(); let bottom_exposure_time = des.read_f32_be();
let bottom_layers = des.read_u32(); let bottom_layers = des.read_u32_be();
let bottom_lift_distance = des.read_f32(); let bottom_lift_distance = des.read_f32_be();
let bottom_lift_speed = des.read_f32(); let bottom_lift_speed = des.read_f32_be();
let lift_distance = des.read_f32(); let lift_distance = des.read_f32_be();
let lift_speed = des.read_f32(); let lift_speed = des.read_f32_be();
let bottom_retract_distance = des.read_f32(); let bottom_retract_distance = des.read_f32_be();
let bottom_retract_speed = des.read_f32(); let bottom_retract_speed = des.read_f32_be();
let retract_distance = des.read_f32(); let retract_distance = des.read_f32_be();
let retract_speed = des.read_f32(); let retract_speed = des.read_f32_be();
let bottom_second_lift_distance = des.read_f32(); let bottom_second_lift_distance = des.read_f32_be();
let bottom_second_lift_speed = des.read_f32(); let bottom_second_lift_speed = des.read_f32_be();
let second_lift_distance = des.read_f32(); let second_lift_distance = des.read_f32_be();
let second_lift_speed = des.read_f32(); let second_lift_speed = des.read_f32_be();
let bottom_second_retract_distance = des.read_f32(); let bottom_second_retract_distance = des.read_f32_be();
let bottom_second_retract_speed = des.read_f32(); let bottom_second_retract_speed = des.read_f32_be();
let second_retract_distance = des.read_f32(); let second_retract_distance = des.read_f32_be();
let second_retract_speed = des.read_f32(); let second_retract_speed = des.read_f32_be();
let bottom_light_pwm = des.read_u16().min(255) as u8; let bottom_light_pwm = des.read_u16_be().min(255) as u8;
let light_pwm = des.read_u16().min(255) as u8; let light_pwm = des.read_u16_be().min(255) as u8;
let advance_mode = des.read_bool(); let advance_mode = des.read_bool();
let printing_time = des.read_u32(); let printing_time = des.read_u32_be();
let total_volume = des.read_f32(); let total_volume = des.read_f32_be();
let total_weight = des.read_f32(); let total_weight = des.read_f32_be();
let total_price = des.read_f32(); let total_price = des.read_f32_be();
let price_unit = des.read_sized_string(); let price_unit = des.read_sized_string();
ensure!(des.read_u32() == Self::SIZE as u32); ensure!(des.read_u32_be() == Self::SIZE as u32);
let grey_scale_level = des.read_bool(); let grey_scale_level = des.read_bool();
let transition_layers = des.read_u16(); let transition_layers = des.read_u16_be();
Ok(Self { Ok(Self {
version, version,
@@ -349,7 +349,7 @@ impl ExposureDelayMode {
} }
} }
impl Debug for HeaderInfo { impl Debug for Header {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("HeaderInfo") f.debug_struct("HeaderInfo")
.field("version", &self.version) .field("version", &self.version)

72
goo_format/src/layer_content.rs
View File

@@ -48,25 +48,25 @@ pub struct LayerContent {
impl LayerContent { impl LayerContent {
pub fn serialize<T: Serializer>(&self, ser: &mut T) { pub fn serialize<T: Serializer>(&self, ser: &mut T) {
ser.write_u16(self.pause as u16); ser.write_u16_be(self.pause as u16);
ser.write_f32(self.pause_position_z); ser.write_f32_be(self.pause_position_z);
ser.write_f32(self.layer_position_z); ser.write_f32_be(self.layer_position_z);
ser.write_f32(self.layer_exposure_time); ser.write_f32_be(self.layer_exposure_time);
ser.write_f32(self.layer_off_time); ser.write_f32_be(self.layer_off_time);
ser.write_f32(self.before_lift_time); ser.write_f32_be(self.before_lift_time);
ser.write_f32(self.after_lift_time); ser.write_f32_be(self.after_lift_time);
ser.write_f32(self.after_retract_time); ser.write_f32_be(self.after_retract_time);
ser.write_f32(self.lift_distance); ser.write_f32_be(self.lift_distance);
ser.write_f32(self.lift_speed); ser.write_f32_be(self.lift_speed);
ser.write_f32(self.second_lift_distance); ser.write_f32_be(self.second_lift_distance);
ser.write_f32(self.second_lift_speed); ser.write_f32_be(self.second_lift_speed);
ser.write_f32(self.retract_distance); ser.write_f32_be(self.retract_distance);
ser.write_f32(self.retract_speed); ser.write_f32_be(self.retract_speed);
ser.write_f32(self.second_retract_distance); ser.write_f32_be(self.second_retract_distance);
ser.write_f32(self.second_retract_speed); ser.write_f32_be(self.second_retract_speed);
ser.write_u16(self.light_pwm as u16); ser.write_u16_be(self.light_pwm as u16);
ser.write_bytes(DELIMITER); ser.write_bytes(DELIMITER);
ser.write_u32(self.data.len() as u32 + 2); ser.write_u32_be(self.data.len() as u32 + 2);
ser.write_bytes(&[0x55]); ser.write_bytes(&[0x55]);
ser.write_bytes(&self.data); ser.write_bytes(&self.data);
ser.write_u8(calculate_checksum(&self.data)); ser.write_u8(calculate_checksum(&self.data));
@@ -74,25 +74,25 @@ impl LayerContent {
} }
pub fn deserialize(des: &mut Deserializer) -> Result<Self> { pub fn deserialize(des: &mut Deserializer) -> Result<Self> {
let pause_flag = des.read_u16(); let pause_flag = des.read_u16_be();
let pause_position_z = des.read_f32(); let pause_position_z = des.read_f32_be();
let layer_position_z = des.read_f32(); let layer_position_z = des.read_f32_be();
let layer_exposure_time = des.read_f32(); let layer_exposure_time = des.read_f32_be();
let layer_off_time = des.read_f32(); let layer_off_time = des.read_f32_be();
let before_lift_time = des.read_f32(); let before_lift_time = des.read_f32_be();
let after_lift_time = des.read_f32(); let after_lift_time = des.read_f32_be();
let after_retract_time = des.read_f32(); let after_retract_time = des.read_f32_be();
let lift_distance = des.read_f32(); let lift_distance = des.read_f32_be();
let lift_speed = des.read_f32(); let lift_speed = des.read_f32_be();
let second_lift_distance = des.read_f32(); let second_lift_distance = des.read_f32_be();
let second_lift_speed = des.read_f32(); let second_lift_speed = des.read_f32_be();
let retract_distance = des.read_f32(); let retract_distance = des.read_f32_be();
let retract_speed = des.read_f32(); let retract_speed = des.read_f32_be();
let second_retract_distance = des.read_f32(); let second_retract_distance = des.read_f32_be();
let second_retract_speed = des.read_f32(); let second_retract_speed = des.read_f32_be();
let light_pwm = des.read_u16().min(255) as u8; let light_pwm = des.read_u16_be().min(255) as u8;
ensure!(des.read_bytes(2) == DELIMITER); ensure!(des.read_bytes(2) == DELIMITER);
let data_len = des.read_u32() as usize - 2; let data_len = des.read_u32_be() as usize - 2;
ensure!(des.read_u8() == 0x55); ensure!(des.read_u8() == 0x55);
let data = des.read_bytes(data_len); let data = des.read_bytes(data_len);
let checksum = des.read_u8(); let checksum = des.read_u8();

4
goo_format/src/lib.rs
View File

@@ -3,13 +3,13 @@
mod default; mod default;
mod encoded_layer; mod encoded_layer;
mod file; mod file;
mod header_info; mod header;
mod layer_content; mod layer_content;
mod preview_image; mod preview_image;
pub use encoded_layer::{LayerDecoder, LayerEncoder}; pub use encoded_layer::{LayerDecoder, LayerEncoder};
pub use file::File; pub use file::File;
pub use header_info::HeaderInfo; pub use header::Header;
pub use layer_content::LayerContent; pub use layer_content::LayerContent;
pub use preview_image::PreviewImage; pub use preview_image::PreviewImage;

4
goo_format/src/preview_image.rs
View File

@@ -48,7 +48,7 @@ impl<const WIDTH: usize, const HEIGHT: usize> PreviewImage<WIDTH, HEIGHT> {
pub fn serializes<T: Serializer>(&self, serializer: &mut T) { pub fn serializes<T: Serializer>(&self, serializer: &mut T) {
for pixel in self.data.iter() { for pixel in self.data.iter() {
serializer.write_u16(*pixel); serializer.write_u16_be(*pixel);
} }
} }
@@ -56,7 +56,7 @@ impl<const WIDTH: usize, const HEIGHT: usize> PreviewImage<WIDTH, HEIGHT> {
let mut out = Self::empty(); let mut out = Self::empty();
for pixel in out.data.iter_mut() { for pixel in out.data.iter_mut() {
*pixel = deserializer.read_u16(); *pixel = deserializer.read_u16_be();
} }
out out

4
mslicer/src/app/mod.rs
View File

@@ -20,7 +20,9 @@ use tracing::{info, warn};
use crate::{ use crate::{
plugins::{ plugins::{
anti_alias, elephant_foot_fixer::{self}, PluginManager anti_alias,
elephant_foot_fixer::{self},
PluginManager,
}, },
render::{camera::Camera, rendered_mesh::RenderedMesh}, render::{camera::Camera, rendered_mesh::RenderedMesh},
ui::{ ui::{

4
remote_send/src/mqtt/misc.rs
View File

@@ -15,7 +15,7 @@ pub trait MqttSerializer {
impl<'a> MqttDeserialize<'a> for Deserializer<'a> { impl<'a> MqttDeserialize<'a> for Deserializer<'a> {
fn read_string(&mut self) -> Cow<'a, str> { fn read_string(&mut self) -> Cow<'a, str> {
let len = self.read_u16(); let len = self.read_u16_be();
let buf = self.read_bytes(len as usize); let buf = self.read_bytes(len as usize);
String::from_utf8_lossy(buf) String::from_utf8_lossy(buf)
} }
@@ -28,7 +28,7 @@ where
fn write_string(&mut self, data: &str) { fn write_string(&mut self, data: &str) {
assert!(data.len() <= u16::MAX as usize); assert!(data.len() <= u16::MAX as usize);
let len = data.len() as u16; let len = data.len() as u16;
self.write_u16(len); self.write_u16_be(len);
self.write_bytes(data.as_bytes()); self.write_bytes(data.as_bytes());
} }
} }

2
remote_send/src/mqtt/packets/connect.rs
View File

@@ -43,7 +43,7 @@ impl ConnectPacket {
let protocol_name = des.read_string().into_owned(); let protocol_name = des.read_string().into_owned();
let protocol_level = des.read_u8(); let protocol_level = des.read_u8();
let connect_flags = ConnectFlags::from_bits(des.read_u8()).unwrap(); let connect_flags = ConnectFlags::from_bits(des.read_u8()).unwrap();
let keep_alive = des.read_u16(); let keep_alive = des.read_u16_be();
let client_id = des.read_string().into_owned(); let client_id = des.read_string().into_owned();
let will_topic = connect_flags let will_topic = connect_flags

4
remote_send/src/mqtt/packets/publish.rs
View File

@@ -36,7 +36,7 @@ impl PublishPacket {
let topic = des.read_string().into_owned(); let topic = des.read_string().into_owned();
let packet_id = (flags.contains(PublishFlags::QOS1) || flags.contains(PublishFlags::QOS2)) let packet_id = (flags.contains(PublishFlags::QOS1) || flags.contains(PublishFlags::QOS2))
.then(|| des.read_u16()); .then(|| des.read_u16_be());
let data = des let data = des
.read_bytes(packet.remaining_length as usize - des.pos()) .read_bytes(packet.remaining_length as usize - des.pos())
.to_vec(); .to_vec();
@@ -53,7 +53,7 @@ impl PublishPacket {
let mut ser = DynamicSerializer::new(); let mut ser = DynamicSerializer::new();
ser.write_string(&self.topic); ser.write_string(&self.topic);
if self.flags.contains(PublishFlags::QOS1) || self.flags.contains(PublishFlags::QOS2) { if self.flags.contains(PublishFlags::QOS1) || self.flags.contains(PublishFlags::QOS2) {
ser.write_u16(self.packet_id.unwrap()); ser.write_u16_be(self.packet_id.unwrap());
} }
ser.write_bytes(&self.data); ser.write_bytes(&self.data);

4
remote_send/src/mqtt/packets/publish_ack.rs
View File

@@ -13,7 +13,7 @@ impl PublishAckPacket {
pub fn to_packet(&self) -> Packet { pub fn to_packet(&self) -> Packet {
let mut ser = DynamicSerializer::new(); let mut ser = DynamicSerializer::new();
ser.write_u16(self.packet_id); ser.write_u16_be(self.packet_id);
let data = ser.into_inner(); let data = ser.into_inner();
Packet { Packet {
@@ -28,7 +28,7 @@ impl PublishAckPacket {
assert_eq!(packet.packet_type, Self::PACKET_TYPE); assert_eq!(packet.packet_type, Self::PACKET_TYPE);
let mut des = Deserializer::new(&packet.remaining_bytes); let mut des = Deserializer::new(&packet.remaining_bytes);
let packet_id = des.read_u16(); let packet_id = des.read_u16_be();
Ok(Self { packet_id }) Ok(Self { packet_id })
} }

2
remote_send/src/mqtt/packets/subscribe.rs
View File

@@ -17,7 +17,7 @@ impl SubscribePacket {
pub fn from_packet(packet: &Packet) -> Result<Self> { pub fn from_packet(packet: &Packet) -> Result<Self> {
let mut des = Deserializer::new(&packet.remaining_bytes); let mut des = Deserializer::new(&packet.remaining_bytes);
let packet_id = des.read_u16(); let packet_id = des.read_u16_be();
let mut filters = Vec::new(); let mut filters = Vec::new();
while !des.is_empty() { while !des.is_empty() {
let topic = des.read_string().into_owned(); let topic = des.read_string().into_owned();

2
remote_send/src/mqtt/packets/subscribe_ack.rs
View File

@@ -20,7 +20,7 @@ impl SubscribeAckPacket {
pub fn to_packet(&self) -> Packet { pub fn to_packet(&self) -> Packet {
let mut ser = DynamicSerializer::new(); let mut ser = DynamicSerializer::new();
ser.write_u16(self.packet_id); ser.write_u16_be(self.packet_id);
for return_code in &self.return_codes { for return_code in &self.return_codes {
match return_code { match return_code {
SubscribeReturnCode::Failure => ser.write_u8(0x80), SubscribeReturnCode::Failure => ser.write_u8(0x80),