Implement UniqueId

rbx_binary/CHANGELOG.md

@@ -3,9 +3,11 @@
 ## Unreleased
 * Added support for `Font` values. ([#248])
 * Fixed the nondeterministic output of SSTR chunk when multiple shared strings are present. ([#254])
+* Added support for `UniqueId` values. ([#256])
 
 [#248]: https://github.com/rojo-rbx/rbx-dom/pull/248
 [#254]: https://github.com/rojo-rbx/rbx-dom/pull/254
+[#256]: https://github.com/rojo-rbx/rbx-dom/pull/256
 
 ## 0.6.6 (2022-06-29)
 * Fixed unserialized properties getting deserialized, like `BasePart.MaterialVariant`. ([#230])

rbx_binary/src/core.rs

@@ -47,6 +47,20 @@ pub trait RbxReadExt: Read {
         Ok(f64::from_le_bytes(bytes))
     }
 
+    fn read_be_u32(&mut self) -> io::Result<u32> {
+        let mut bytes = [0; 4];
+        self.read_exact(&mut bytes)?;
+
+        Ok(u32::from_be_bytes(bytes))
+    }
+
+    fn read_be_i64(&mut self) -> io::Result<i64> {
+        let mut bytes = [0; 8];
+        self.read_exact(&mut bytes)?;
+
+        Ok(i64::from_be_bytes(bytes))
+    }
+
     fn read_u8(&mut self) -> io::Result<u8> {
         let mut buffer = [0u8];
         self.read_exact(&mut buffer)?;

rbx_binary/src/deserializer/state.rs

@@ -9,8 +9,8 @@ use rbx_dom_weak::{
         Attributes, Axes, BinaryString, BrickColor, CFrame, Color3, Color3uint8, ColorSequence,
         ColorSequenceKeypoint, Content, CustomPhysicalProperties, Enum, Faces, Font, FontStyle,
         FontWeight, Matrix3, NumberRange, NumberSequence, NumberSequenceKeypoint,
-        PhysicalProperties, Ray, Rect, Ref, SharedString, Tags, UDim, UDim2, Variant, VariantType,
-        Vector2, Vector3, Vector3int16,
+        PhysicalProperties, Ray, Rect, Ref, SharedString, Tags, UDim, UDim2, UniqueId, Variant,
+        VariantType, Vector2, Vector3, Vector3int16,
     },
     InstanceBuilder, WeakDom,
 };
@@ -1224,6 +1224,41 @@ impl<'a, R: Read> DeserializerState<'a, R> {
                     });
                 }
             },
+            Type::UniqueId => match canonical_type {
+                VariantType::UniqueId => {
+                    // This is technically inefficient but memory is cheap
+                    // and we can optimize it later.
+                    let n = type_info.referents.len();
+                    let mut value = Vec::with_capacity(16);
+                    let mut blob = vec![0; 16 * n];
+
+                    chunk.read_exact(&mut blob)?;
+                    for (x, referent) in (0..n).zip(&type_info.referents) {
+                        for y in 0..16 {
+                            value.push(blob[x + y * n]);
+                        }
+                        let mut value_ref = value.as_slice();
+                        let instance = self.instances_by_ref.get_mut(referent).unwrap();
+                        instance.builder.add_property(
+                            &canonical_name,
+                            UniqueId::new(
+                                value_ref.read_be_u32()?,
+                                value_ref.read_be_u32()?,
+                                value_ref.read_be_i64()?.rotate_right(1),
+                            ),
+                        );
+                        value.clear();
+                    }
+                }
+                invalid_type => {
+                    return Err(InnerError::PropTypeMismatch {
+                        type_name: type_info.type_name.clone(),
+                        prop_name,
+                        valid_type_names: "UniqueId",
+                        actual_type_name: format!("{:?}", invalid_type),
+                    });
+                }
+            },
         }
 
         Ok(())

rbx_binary/src/serializer/state.rs

@@ -11,7 +11,7 @@ use rbx_dom_weak::{
         Attributes, Axes, BinaryString, BrickColor, CFrame, Color3, Color3uint8, ColorSequence,
         ColorSequenceKeypoint, Content, Enum, Faces, Font, Matrix3, NumberRange, NumberSequence,
         NumberSequenceKeypoint, PhysicalProperties, Ray, Rect, Ref, SharedString, Tags, UDim,
-        UDim2, Variant, VariantType, Vector2, Vector3, Vector3int16,
+        UDim2, UniqueId, Variant, VariantType, Vector2, Vector3, Vector3int16,
     },
     Instance, WeakDom,
 };
@@ -1112,6 +1112,27 @@ impl<'dom, W: Write> SerializerState<'dom, W> {
                         chunk.write_u8(Type::Bool as u8)?;
                         chunk.write_all(bools.as_slice())?;
                     }
+                    Type::UniqueId => {
+                        let mut blob = vec![0; values.len() * 16];
+                        let mut bytes = Vec::with_capacity(16);
+
+                        for (i, rbx_value) in values {
+                            if let Variant::UniqueId(value) = rbx_value.as_ref() {
+                                bytes.extend_from_slice(&value.index().to_be_bytes());
+                                bytes.extend_from_slice(&value.time().to_be_bytes());
+                                bytes.extend_from_slice(
+                                    &value.random().rotate_left(1).to_be_bytes(),
+                                );
+                                for (y, byte) in (0..16).zip(&bytes) {
+                                    blob[y + i * 16] = *byte;
+                                }
+                            } else {
+                                return type_mismatch(i, &rbx_value, "UniqueId");
+                            }
+                        }
+
+                        chunk.write_all(&blob)?;
+                    }
                 }
 
                 chunk.dump(&mut self.output)?;
@@ -1251,6 +1272,7 @@ impl<'dom, W: Write> SerializerState<'dom, W> {
             VariantType::Tags => Variant::Tags(Tags::new()),
             VariantType::Content => Variant::Content(Content::new()),
             VariantType::Attributes => Variant::Attributes(Attributes::new()),
+            VariantType::UniqueId => Variant::UniqueId(UniqueId::now().unwrap()),
             VariantType::Font => Variant::Font(Font::default()),
             _ => return None,
         })

rbx_binary/src/tests/mod.rs

@@ -1,3 +1,4 @@
 mod models;
+mod places;
 mod serializer;
 mod util;

rbx_binary/src/tests/places.rs

@@ -0,0 +1,29 @@
+use std::path::PathBuf;
+
+use heck::ToKebabCase;
+
+use super::util::run_model_base_suite;
+
+macro_rules! place_tests {
+    ($($test_name: ident,)*) => {
+        $(
+            #[test]
+            fn $test_name() {
+                let _ = env_logger::try_init();
+
+                let mut test_path = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+                assert!(test_path.pop());
+                test_path.push("test-files");
+                test_path.push("places");
+                test_path.push(stringify!($test_name).to_kebab_case());
+                test_path.push("binary.rbxl");
+
+                run_model_base_suite(test_path);
+            }
+        )*
+    };
+}
+
+place_tests! {
+    baseplate_566,
+}