public NumberRange ReadAttribute(RbxAttribute attr)
        {
            float min = attr.ReadFloat();
            float max = attr.ReadFloat();

            return(new NumberRange(min, max));
        }
        public static Vector2 ReadVector2(RbxAttribute attr)
        {
            float x = attr.ReadFloat(),
                  y = attr.ReadFloat();

            return(new Vector2(x, y));
        }
        public Rect ReadAttribute(RbxAttribute attr)
        {
            Vector2 min = Vector2Token.ReadVector2(attr);
            Vector2 max = Vector2Token.ReadVector2(attr);

            return(new Rect(min, max));
        }
Esempio n. 4
0
        public static UDim ReadUDim(RbxAttribute attr)
        {
            float scale  = attr.ReadFloat();
            int   offset = attr.ReadInt();

            return(new UDim(scale, offset));
        }
Esempio n. 5
0
        public UDim2 ReadAttribute(RbxAttribute attr)
        {
            UDim x = UDimToken.ReadUDim(attr);
            UDim y = UDimToken.ReadUDim(attr);

            return(new UDim2(x, y));
        }
Esempio n. 6
0
        public static Vector3 ReadVector3(RbxAttribute attr)
        {
            float x = attr.ReadFloat(),
                  y = attr.ReadFloat(),
                  z = attr.ReadFloat();

            return(new Vector3(x, y, z));
        }
        public static Color3 ReadColor3(RbxAttribute attr)
        {
            float r = attr.ReadFloat(),
                  g = attr.ReadFloat(),
                  b = attr.ReadFloat();

            return(new Color3(r, g, b));
        }
Esempio n. 8
0
        public static void WriteUDim(RbxAttribute attr, UDim value)
        {
            float scale = value.Scale;

            attr.WriteFloat(scale);

            int offset = value.Offset;

            attr.WriteInt(offset);
        }
        public void WriteAttribute(RbxAttribute attr, NumberSequence value)
        {
            attr.WriteInt(value.Keypoints.Length);

            foreach (var keypoint in value.Keypoints)
            {
                attr.WriteFloat(keypoint.Envelope);
                attr.WriteFloat(keypoint.Time);
                attr.WriteFloat(keypoint.Value);
            }
        }
        public NumberSequence ReadAttribute(RbxAttribute attr)
        {
            int numKeys   = attr.ReadInt();
            var keypoints = new NumberSequenceKeypoint[numKeys];

            for (int i = 0; i < numKeys; i++)
            {
                float envelope = attr.ReadInt(),
                      time     = attr.ReadFloat(),
                      value    = attr.ReadFloat();

                keypoints[i] = new NumberSequenceKeypoint(time, value, envelope);
            }

            return(new NumberSequence(keypoints));
        }
        public ColorSequence ReadAttribute(RbxAttribute attr)
        {
            int numKeys   = attr.ReadInt();
            var keypoints = new ColorSequenceKeypoint[numKeys];

            for (int i = 0; i < numKeys; i++)
            {
                int   envelope = attr.ReadInt();
                float time     = attr.ReadFloat();

                Color3 value = Color3Token.ReadColor3(attr);
                keypoints[i] = new ColorSequenceKeypoint(time, value, envelope);
            }

            return(new ColorSequence(keypoints));
        }
Esempio n. 12
0
 public double ReadAttribute(RbxAttribute attr) => attr.ReadDouble();
Esempio n. 13
0
 public float ReadAttribute(RbxAttribute attr) => attr.ReadFloat();
Esempio n. 14
0
 public UDim ReadAttribute(RbxAttribute attr) => ReadUDim(attr);
Esempio n. 15
0
 public void WriteAttribute(RbxAttribute attr, UDim value) => WriteUDim(attr, value);
Esempio n. 16
0
 public void WriteAttribute(RbxAttribute attr, double value) => attr.WriteDouble(value);
Esempio n. 17
0
 public static void WriteVector3(RbxAttribute attr, Vector3 value)
 {
     attr.WriteFloat(value.X);
     attr.WriteFloat(value.Y);
     attr.WriteFloat(value.Z);
 }
Esempio n. 18
0
 public Vector3 ReadAttribute(RbxAttribute attr) => ReadVector3(attr);
Esempio n. 19
0
 public void WriteAttribute(RbxAttribute attr, Vector3 value) => WriteVector3(attr, value);
 public Vector2 ReadAttribute(RbxAttribute attr) => ReadVector2(attr);
 public Color3 ReadAttribute(RbxAttribute attr) => ReadColor3(attr);
Esempio n. 22
0
 public void WriteAttribute(RbxAttribute attr, string value) => attr.WriteString(value);
 public void WriteAttribute(RbxAttribute attr, Color3 value) => WriteColor3(attr, value);
 public static void WriteColor3(RbxAttribute attr, Color3 value)
 {
     attr.WriteFloat(value.R);
     attr.WriteFloat(value.G);
     attr.WriteFloat(value.B);
 }
 public void WriteAttribute(RbxAttribute attr, NumberRange value)
 {
     attr.WriteFloat(value.Min);
     attr.WriteFloat(value.Max);
 }
Esempio n. 26
0
 public void WriteAttribute(RbxAttribute attr, float value) => attr.WriteFloat(value);
Esempio n. 27
0
 public string ReadAttribute(RbxAttribute attr) => attr.ReadString();
Esempio n. 28
0
 public bool ReadAttribute(RbxAttribute attr) => attr.ReadBool();
Esempio n. 29
0
 public void WriteAttribute(RbxAttribute attr, Rect value)
 {
     Vector2Token.WriteVector2(attr, value.Min);
     Vector2Token.WriteVector2(attr, value.Max);
 }
Esempio n. 30
0
 public void WriteAttribute(RbxAttribute attr, bool value) => attr.WriteBool(value);