More object work

src/ezcad/layer.rs

@@ -2,7 +2,7 @@ use binrw::{BinRead, BinWrite};
 
 use crate::{
     object::Object,
-    types::{Field, WString, U32},
+    types::{Field, WString, F64, U16, U32},
 };
 
 #[derive(BinRead, BinWrite, Debug)]
@@ -20,21 +20,21 @@ pub struct Layer {
     pub name: WString,
     pub count: U32,
     _unknown_2: Field,
-    pub input_signal_wait_enable_mask: U32,
-    pub input_signal_wait_disable_mask: U32,
+    pub input_signal_wait_enable_mask: U16,
+    pub input_signal_wait_disable_mask: U16,
     _unknown_3: [Field; 9],
     pub object_count: u32,
     #[br(count = object_count)]
     pub objects: Vec<Object>,
-    #[br(assert(field_count_1 == 151))]
+    #[br(assert(field_count_2 == 151))]
     field_count_2: u32, // Number of remaining fields
     _unknown_4: [Field; 54],
-    pub output_signal_start_enable_mask: U32,
-    pub output_signal_start_disable_mask: U32,
-    pub output_signal_end_enable_mask: U32,
-    pub output_signal_end_disable_mask: U32,
+    pub output_signal_start_enable_mask: U16,
+    pub output_signal_start_disable_mask: U16,
+    pub output_signal_end_enable_mask: U16,
+    pub output_signal_end_disable_mask: U16,
     _unknown_5: [Field; 9],
-    pub fixture_offset: U32,
+    pub fixture_offset: F64,
     _unknown_6: [Field; 64],
     pub output_signal_start_delay: U32,
     pub output_signal_end_delay: U32,

src/ezcad/object.rs

@@ -1,4 +1,122 @@
 use binrw::{BinRead, BinWrite};
 
+use crate::{
+    field_of::FieldOf,
+    types::{Field, ObjectType, Point, WString, F64, U32, U16},
+};
+
+#[derive(BinRead, BinWrite, Debug)]
+pub enum LineType {
+    #[brw(magic = 0x0001u64)]
+    Point(Point),
+    #[brw(magic = 0x0100u64)]
+    Line {
+        count: u32,
+        #[br(count = count)]
+        points: Vec<Point>,
+    },
+    #[brw(magic = 0x0300u64)]
+    Bezier {
+        count: u32,
+        #[br(count = count)]
+        points: Vec<Point>,
+    },
+}
+
+#[derive(BinRead, BinWrite, Debug)]
+#[brw(magic(17u32))]
+pub struct ObjBase {
+    pub pen: U32,
+    pub obj_type: FieldOf<ObjectType>,
+    pub flags: U16,
+    pub name: WString,
+    pub count: U32,
+    _unknown_1: Field,
+    pub io_control_enable_mask: U16,
+    pub io_control_disable_mask: U16,
+    _unknown_2: [Field; 5],
+    pub origin: FieldOf<Point>,
+    pub z: F64,
+    pub a: F64,
+    _unknown_3: Field,
+}
+
+#[derive(BinRead, BinWrite, Debug)]
+pub struct Lines {
+    pub base: ObjBase,
+    count: u64,
+    #[br(count = count)]
+    pub lines: Vec<LineType>,
+}
+
+#[derive(BinRead, BinWrite, Debug)]
+pub struct Rectangle {
+    pub base: ObjBase,
+    #[br(assert(field_count == 8))]
+    field_count: u32,
+    pub corner_a: FieldOf<Point>,
+    pub corner_b: FieldOf<Point>,
+    pub round_bottom_left: F64,
+    pub round_bottom_right: F64,
+    pub round_top_right: F64,
+    pub round_top_left: F64,
+    _unknown_1: [Field; 2],
+}
+
+#[derive(BinRead, BinWrite, Debug)]
+pub struct Circle {
+    pub base: ObjBase,
+    #[br(assert(field_count == 6))]
+    field_count: u32,
+    pub origin: FieldOf<Point>,
+    pub radius: F64,
+    pub start_angle: F64,
+    pub clockwise: U32,
+    _unknown_1: [Field; 2],
+}
+
+#[derive(BinRead, BinWrite, Debug)]
+pub struct Ellipse {
+    pub base: ObjBase,
+    #[br(assert(field_count == 8))]
+    field_count: u32,
+    pub clockwise: U32,
+    pub corner_a: FieldOf<Point>,
+    pub corner_b: FieldOf<Point>,
+    pub start_angle: F64,
+    pub end_angle: F64,
+    _unknown_1: [Field; 2],
+    pub open_curve: U32,
+}
+
+#[derive(BinRead, BinWrite, Debug)]
+pub struct Polygon {
+    pub base: ObjBase,
+    #[br(assert(field_count == 10))]
+    field_count: u32,
+    pub invert_shape: U32,
+    pub corner_a: FieldOf<Point>,
+    pub corner_b: FieldOf<Point>,
+    pub offset_cx: F64,
+    pub offset_cy: F64,
+    pub offset_dx: F64,
+    pub offset_dy: F64,
+    pub edges: U32,
+    _unknown_1: [Field; 2],
+}
+
 #[derive(BinRead, BinWrite, Debug)]
-pub struct Object {}
+pub enum Object {
+    #[brw(magic = 1u32)]
+    Curve(Lines),
+    #[brw(magic = 2u32)]
+    Point(Lines),
+    #[brw(magic = 3u32)]
+    Rectangle(Rectangle),
+    #[brw(magic = 4u32)]
+    Circle(Circle),
+    #[brw(magic = 5u32)]
+    Ellipse(Ellipse),
+    #[brw(magic = 6u32)]
+    Polygon(Polygon),
+}

src/ezcad/pen.rs

@@ -1,6 +1,9 @@
 use binrw::{BinRead, BinWrite, FilePtr64};
 
-use crate::types::{Color, Double, Field, WString, Wobble, U32};
+use crate::{
+    field_of::FieldOf,
+    types::{Field, Rgba, WString, WobbleType, F64, U32},
+};
 
 #[derive(BinRead, Debug)]
 pub struct PenHeader {
@@ -16,8 +19,6 @@ pub struct PenHeader {
 #[derive(BinRead, BinWrite, Debug)]
 #[br(import {pen_count: u32})]
 pub struct Pens {
-    // #[br(count = pen_count)]
-    // pens: Vec<ArrayOf<Field>>,
     #[br(count = pen_count)]
     pub pens: Vec<Pen>,
 }
@@ -26,36 +27,36 @@ pub struct Pens {
 pub struct Pen {
     #[br(assert(field_count == 236))]
     field_count: u32,
-    pub color: Color,
+    pub color: FieldOf<Rgba>,
     pub name: WString,
     pub disabled: U32,
     pub use_default: U32,
     pub loop_count: U32,
-    pub speed: Double, // Changes with wobble relative speed
-    pub power: Double,
+    pub speed: F64, // Changes with wobble relative speed
+    pub power: F64,
     pub frequency: U32,
     _unknown_1: Field,
     pub start_tc: U32,
     pub end_tc: U32,
     pub polygon_tc: U32,
-    pub jump_speed: Double,
+    pub jump_speed: F64,
     _unknown_2: [Field; 10],
     pub laser_off_tc: U32,
     pub wave: U32, // Only available if continue_mode is false
     _unknown_3: Field,
     pub wobble_enable: U32,
-    pub wobble_diameter: Double,
-    pub wobble_distance: Double,
+    pub wobble_diameter: F64,
+    pub wobble_distance: F64,
     _unknown_4: [Field; 8],
     pub min_jump_tc: U32,
     pub max_jump_tc: U32,
-    pub jump_limit: Double,
+    pub jump_limit: F64,
     _unknown_5: [Field; 2],
-    pub frequency_2: Double,
+    pub frequency_2: F64,
     _unknown_6: [Field; 152],
-    pub wobble_type: Wobble,
+    pub wobble_type: FieldOf<WobbleType>,
     pub continue_mode: U32,
     _unknown_7: [Field; 12],
-    pub wobble_diameter_2: Double, // Only with wobble type ellipse
+    pub wobble_diameter_2: F64, // Only with wobble type ellipse
     _unknown_8: [Field; 26],
 }

src/ezcad/types.rs

@@ -9,9 +9,7 @@ pub type Field = ArrayOf<u8>;
 
 pub type U32 = FieldOf<u32>;
 pub type U16 = FieldOf<u16>;
-pub type Double = FieldOf<f64>;
-pub type Color = FieldOf<Rgba>;
-pub type Wobble = FieldOf<WobbleType>;
+pub type F64 = FieldOf<f64>;
 
 pub type WString = ArrayOf<u16>;
 
@@ -64,8 +62,8 @@ pub enum WobbleType {
 }
 
 #[derive(BinRead, BinWrite, PartialEq, Debug)]
-#[brw(repr(u32))]
-#[repr(u32)]
+#[brw(repr(u16))]
+#[repr(u16)]
 pub enum ObjectType {
     Curve = 1,
     Point = 2,

src/main.rs

@@ -1,11 +1,12 @@
 use std::{
     fs::{self},
-    path::PathBuf,
+    path::PathBuf, time::Instant,
 };
 
 use binrw::BinRead;
 use clap::Parser;
 use ezcad::file::Header;
+use log::info;
 
 #[derive(Debug, Parser)]
 struct Cli {
@@ -35,8 +36,16 @@ fn main() {
     let mut input = fs::File::open(args.input).unwrap();
     // let _config = read(args.config).unwrap();
 
+    let time = Instant::now();
+
     let file = Header::read_le(&mut input).unwrap();
-    dbg!(&file.pens_offset.start_offset.pens[255].color);
-    dbg!(String::from(&file.pens_offset.start_offset.pens[255].name));
-    dbg!(&file.pens_offset.start_offset.pens[255].wobble_type);
+
+    info!("Execution time: {:?}", time.elapsed());
+
+    // for i in 0..50 {
+    //     dbg!(&file.pens_offset.start_offset.pens[i].disabled);
+    // }
+    // dbg!(String::from(&file.pens_offset.start_offset.pens[0].name));
+    // dbg!(&file.pens_offset.start_offset.pens[255].wobble_type);
+
 }