read some common, but rarely important for us, values lazily

src/demo/packet/consolecmd.rs

@@ -1,11 +1,11 @@
-use bitstream_reader::{BitRead, LittleEndian};
+use bitstream_reader::{BitRead, LittleEndian, LazyBitReadSized};
 
 use crate::{ReadResult, Stream};
 
 #[derive(Debug)]
 pub struct ConsoleCmdPacket {
     tick: u32,
-    command: String,
+    command: LazyBitReadSized<String, LittleEndian>,
 }
 
 impl BitRead<LittleEndian> for ConsoleCmdPacket {
@@ -13,7 +13,7 @@ impl BitRead<LittleEndian> for ConsoleCmdPacket {
         let tick = stream.read_int(32)?;
         let len = stream.read_int::<usize>(32)?;
         let mut packet_data = stream.read_bits(len * 8)?;
-        let command = packet_data.read_string(Some(len))?;
+        let command = packet_data.read_sized(len)?;
         Ok(ConsoleCmdPacket { tick, command })
     }
 }

src/demo/packet/message.rs

@@ -1,30 +1,54 @@
+use bitstream_reader::{BitRead, BitSize, LittleEndian, LazyBitRead};
+
+use crate::{Parse, ParseError, ParserState, Result, Stream, ReadResult};
 use crate::demo::message::Message;
 use crate::demo::vector::Vector;
-use crate::{Parse, ParseError, ParserState, Result, Stream};
 
 #[derive(Debug)]
 pub struct MessagePacket {
     pub tick: u32,
     pub messages: Vec<Message>,
-    pub view_origin: (Vector, Vector),
-    pub view_angles: (Vector, Vector),
-    pub local_view_angles: (Vector, Vector),
     pub sequence_in: u32,
     pub sequence_out: u32,
+    pub view_angles: LazyBitRead<ViewAngles, LittleEndian>,
     pub flags: u32, // TODO
 }
 
+#[derive(Clone, Debug)]
+pub struct ViewAngles {
+    pub origin: (Vector, Vector),
+    pub angles: (Vector, Vector),
+    pub local_angles: (Vector, Vector),
+}
+
+impl BitSize for ViewAngles {
+    fn bit_size() -> usize {
+        Vector::bit_size() * 6
+    }
+}
+
+impl BitRead<LittleEndian> for ViewAngles {
+    fn read(stream: &mut Stream) -> ReadResult<Self> {
+        let view_origin_1 = Vector::read(stream)?;
+        let view_angle_1 = Vector::read(stream)?;
+        let local_view_angle_1 = Vector::read(stream)?;
+        let origin = (Vector::read(stream)?, view_origin_1);
+        let angles = (Vector::read(stream)?, view_angle_1);
+        let local_angles = (Vector::read(stream)?, local_view_angle_1);
+        Ok(ViewAngles {
+            origin,
+            angles,
+            local_angles,
+        })
+    }
+}
+
 impl Parse for MessagePacket {
     fn parse(stream: &mut Stream, state: &ParserState) -> Result<Self> {
         let tick = stream.read()?;
         let flags = stream.read()?;
 
-        let view_origin_1 = Vector::parse(stream, state)?;
+        let view_angles = stream.read()?;
-        let view_angle_1 = Vector::parse(stream, state)?;
-        let local_view_angle_1 = Vector::parse(stream, state)?;
-        let view_origin = (Vector::parse(stream, state)?, view_origin_1);
-        let view_angles = (Vector::parse(stream, state)?, view_angle_1);
-        let local_view_angles = (Vector::parse(stream, state)?, local_view_angle_1);
 
         let sequence_in = stream.read()?;
         let sequence_out = stream.read()?;
@@ -43,9 +67,7 @@ impl Parse for MessagePacket {
         let packet = MessagePacket {
             tick,
             messages,
-            view_origin,
             view_angles,
-            local_view_angles,
             sequence_in,
             sequence_out,
             flags,

src/demo/packet/usercmd.rs

@@ -10,10 +10,10 @@ pub struct UserCmdPacket {
 
 impl BitRead<LittleEndian> for UserCmdPacket {
     fn read(stream: &mut Stream) -> ReadResult<Self> {
-        let tick = stream.read_int(32)?;
+        let tick = stream.read()?;
-        let sequence_out = stream.read_int(32)?;
+        let sequence_out = stream.read()?;
-        let len = stream.read_int::<usize>(32)?;
+        let len:u32 = stream.read()?;
-        let mut _packet_data = stream.read_bits(len * 8)?;
+        let mut _packet_data = stream.read_bits(len as usize * 8)?;
         // TODO parse the packet data
         Ok(UserCmdPacket { tick, sequence_out })
     }

src/demo/vector.rs

@@ -1,26 +1,16 @@
-use bitstream_reader::{BitRead, LittleEndian};
+use bitstream_reader::{BitRead, LittleEndian, BitSize};
 use serde::Serialize;
 
 use crate::{ReadResult, Stream};
 
-#[derive(Debug, Clone, Copy, Default, Serialize)]
+#[derive(BitRead, BitSize, Debug, Clone, Copy, Default, Serialize)]
 pub struct Vector {
     pub x: f32,
     pub y: f32,
     pub z: f32,
 }
 
-impl BitRead<LittleEndian> for Vector {
+#[derive(BitRead, BitSize, Debug, Clone, Copy, Default, Serialize)]
-    fn read(stream: &mut Stream) -> ReadResult<Self> {
-        Ok(Vector {
-            x: stream.read()?,
-            y: stream.read()?,
-            z: stream.read()?,
-        })
-    }
-}
-
-#[derive(BitRead, Debug, Clone, Copy, Default, Serialize)]
 pub struct VectorXY {
     pub x: f32,
     pub y: f32,