roavatar-renderer 1.2.2 → 1.2.3

package/dist/index.d.ts

@@ -107,6 +107,7 @@ export declare class AnimationTrack {
     length: number;
     looped: boolean;
     priority: number;
+    shouldUpdateMotors: boolean;
     pOriginalWeight: number;
     pTargetWeight: number;
     pSpeed: number;
@@ -128,7 +129,8 @@ export declare class AnimationTrack {
      * @deprecated, reset inside Animator instead
      */
     resetMotorTransforms(): void;
-    renderPose(): void;
+    renderPose(updateMotors?: boolean): void;
+    updateMotors(): void;
     setTime(time: number): void;
     /**
      * Remember to call tick() on each frame
@@ -918,6 +920,8 @@ export declare const FLAGS: {
     HAIR_IS_BODYPART: boolean;
     BODYCOLOR3: boolean;
     ENABLE_API_CACHE: boolean;
+    ENABLE_API_MESH_CACHE: boolean;
+    ENABLE_API_RBX_CACHE: boolean;
     ROAVATAR_DATA_URL: string;
     ROAVATAR_TRYON_PLACE: number;
     ASSETS_PATH: string;
@@ -937,6 +941,7 @@ export declare const FLAGS: {
     UPDATE_SKELETON: boolean;
     ANIMATE_SKELETON: boolean;
     AUTO_SKIN_EVERYTHING: boolean;
+    USE_LOCAL_SKELETONDESC: boolean;
     SEARCH_FOR_STRING: string | undefined;
     LOAD_TEST_PLACE: string | undefined;
 };
@@ -1143,7 +1148,7 @@ export declare class Instance {
     removeReferencedBy(instance: Instance): void;
     addProperty(property: Property, value?: unknown): void;
     fixPropertyName(name: string): string;
-    setProperty(name: string, value: unknown): void;
+    setProperty(name: string, value: unknown, supressEvents?: boolean): void;
     HasProperty(name: string): boolean;
     Property(name: string): unknown;
     Prop(name: string): unknown;
@@ -1950,6 +1955,9 @@ export declare class RBXRenderer {
     static loadingIconStyle?: HTMLStyleElement;
     static plane?: THREE.Mesh;
     static shadowPlane?: THREE.Mesh;
+    static ambientLight?: THREE.AmbientLight;
+    static directionalLight?: THREE.DirectionalLight;
+    static directionalLight2?: THREE.DirectionalLight;
     static boilerplateSetup(): Promise<void>;
     /**Fully sets up renderer with scene, camera and frame rendering*/
     static fullSetup(includeScene?: boolean, includeControls?: boolean): Promise<void>;

package/dist/index.js

@@ -28208,10 +28208,12 @@ class InstanceWrapper {
     if (this.instance.className !== this.static().className) {
       throw new Error(`Provided Instance is not a ${this.static().className}`);
     }
-    const hasAllProperties = this.static().requiredProperties.every((value) => this.instance.getPropertyNames().includes(value));
+    const propertyNames = this.instance.getPropertyNames();
+    const hasAllProperties = this.static().requiredProperties.every((value) => propertyNames.includes(value));
     if (!hasAllProperties) {
       this.setup();
-      const hasAllProperties2 = this.static().requiredProperties.every((value) => this.instance.getPropertyNames().includes(value));
+      const newPropertyNames = this.instance.getPropertyNames();
+      const hasAllProperties2 = this.static().requiredProperties.every((value) => newPropertyNames.includes(value));
       if (!hasAllProperties2) {
         throw new Error("setup() does not add all properties listed in requiredProperties");
       }
@@ -28239,6 +28241,8 @@ const FLAGS = {
   //api
   BODYCOLOR3: true,
   ENABLE_API_CACHE: true,
+  ENABLE_API_MESH_CACHE: true,
+  ENABLE_API_RBX_CACHE: true,
   ROAVATAR_DATA_URL: "rbxassetid://102463700065175",
   //url of model to load that lists issues with specific versions
   ROAVATAR_TRYON_PLACE: 135979364355750,
@@ -28268,6 +28272,7 @@ const FLAGS = {
   UPDATE_SKELETON: true,
   ANIMATE_SKELETON: true,
   AUTO_SKIN_EVERYTHING: false,
+  USE_LOCAL_SKELETONDESC: false,
   //debug
   SEARCH_FOR_STRING: void 0,
   //"requestparams" //"looks/" //this is useful if you want to find api endpoints
@@ -28587,9 +28592,7 @@ class CFrame {
     return cloneCF;
   }
   getTHREEMatrix() {
-    const quat = new Quaternion().setFromEuler(new Euler(rad(this.Orientation[0]), rad(this.Orientation[1]), rad(this.Orientation[2]), "YXZ"));
-    const transformMatrix = new Matrix4().makeTranslation(this.Position[0], this.Position[1], this.Position[2]);
-    return transformMatrix.multiply(new Matrix4().makeRotationFromQuaternion(quat));
+    return new Matrix4().compose(new Vector3$1(...this.Position), new Quaternion().setFromEuler(new Euler(rad(this.Orientation[0]), rad(this.Orientation[1]), rad(this.Orientation[2]), "YXZ")), new Vector3$1(1, 1, 1));
   }
   getMatrix() {
     return this.getTHREEMatrix().toArray();
@@ -28721,132 +28724,6 @@ class Instance {
       throw new Error("Instance was not provided a className");
     }
     this.className = className;
-    switch (this.className) {
-      case "Motor6D":
-      case "Weld":
-        {
-          let update = function(self2, affectedPart = 1) {
-            if (!self2.HasProperty("Part0") || !self2.HasProperty("Part1")) return;
-            let part0 = void 0;
-            if (self2.HasProperty("Part0")) {
-              part0 = self2.Property("Part0");
-              if (part0) {
-                if (part0ChangedConnection) {
-                  part0ChangedConnection.Disconnect();
-                  self2.removeConnectionReference(part0ChangedConnection);
-                }
-              }
-            }
-            let part1 = void 0;
-            if (self2.HasProperty("Part1")) {
-              part1 = self2.Property("Part1");
-            }
-            if (!self2.HasProperty("C0") || !self2.HasProperty("C1")) {
-              return;
-            }
-            const C0 = self2.Property("C0");
-            const C1 = self2.Property("C1");
-            if (!C0 || !C1) {
-              return;
-            }
-            let transform = new CFrame();
-            if (self2.HasProperty("Transform")) {
-              transform = self2.Property("Transform");
-            }
-            if (self2.HasProperty("Enabled") && self2.Prop("Enabled")) {
-              if (self2.parent) {
-                if (affectedPart === 1) {
-                  if (part0 && part1 && part0.HasProperty("CFrame")) {
-                    const part0Cf = part0.Property("CFrame");
-                    const offset1 = C1.multiply(transform).inverse();
-                    const finalCF = part0Cf.multiply(C0).multiply(offset1);
-                    part1.setProperty("CFrame", finalCF);
-                  }
-                } else {
-                  if (part1 && part0 && part1.HasProperty("CFrame")) {
-                    const part1Cf = part1.Property("CFrame");
-                    const offset0 = C0.multiply(transform).inverse();
-                    const finalCF = part1Cf.multiply(C1).multiply(offset0);
-                    part0.setProperty("CFrame", finalCF);
-                  }
-                }
-              } else {
-                console.warn("Motor6D/Weld is missing parent");
-              }
-            }
-            if (part0) {
-              part0ChangedConnection = part0.Changed.Connect((propertyName) => {
-                if (propertyName === "CFrame") {
-                  update(self2, 1);
-                }
-              });
-              self2.addConnectionReference(part0ChangedConnection);
-            }
-          }, setup = function() {
-            if (this.className === "Motor6D") {
-              const transformProperty = new Property();
-              transformProperty.name = "Transform";
-              transformProperty.typeID = DataType.CFrame;
-              this.addProperty(transformProperty);
-              this.setProperty(transformProperty.name, new CFrame());
-            }
-            const changedConnection = this.Changed.Connect(() => {
-              update(this);
-            });
-            const ancestryChangedConnection = this.AncestryChanged.Connect(() => {
-              update(this);
-            });
-            this.addConnectionReference(changedConnection);
-            this.addConnectionReference(ancestryChangedConnection);
-          };
-          let part0ChangedConnection = void 0;
-          setup.bind(this)();
-        }
-        break;
-      case "BodyColors":
-        {
-          let update = function(self2) {
-            const rig = self2.parent;
-            if (!rig) {
-              return;
-            }
-            const humanoid = rig.FindFirstChildOfClass("Humanoid");
-            if (!humanoid) {
-              return;
-            }
-            const bodyPartDictionary = {
-              "Head": ["Head"],
-              "Torso": ["Torso", "UpperTorso", "LowerTorso"],
-              "LeftArm": ["Left Arm", "LeftHand", "LeftLowerArm", "LeftUpperArm"],
-              "RightArm": ["Right Arm", "RightHand", "RightLowerArm", "RightUpperArm"],
-              "LeftLeg": ["Left Leg", "LeftFoot", "LeftLowerLeg", "LeftUpperLeg"],
-              "RightLeg": ["Right Leg", "RightFoot", "RightLowerLeg", "RightUpperLeg"]
-            };
-            const bodyParts = [];
-            for (const child of rig.GetChildren()) {
-              if (child.className === "Part" || child.className === "MeshPart") {
-                bodyParts.push(child);
-              }
-            }
-            for (const bodyPart in bodyPartDictionary) {
-              const bodyPartNames = bodyPartDictionary[bodyPart];
-              const color = self2.Prop(bodyPart + "Color3").toColor3uint8();
-              for (const child of bodyParts) {
-                if (bodyPartNames.includes(child.Prop("Name"))) {
-                  child.setProperty("Color", color);
-                }
-              }
-            }
-          }, setup = function() {
-            const changedConnection = this.Changed.Connect(() => {
-              update(this);
-            });
-            this.addConnectionReference(changedConnection);
-          };
-          setup.bind(this)();
-        }
-        break;
-    }
     if (!notComplete) {
       this.createWrapper();
     }
@@ -28934,7 +28811,7 @@ class Instance {
     }
     return name2;
   }
-  setProperty(name2, value) {
+  setProperty(name2, value, supressEvents = false) {
     let property = this._properties.get(name2);
     if (!property) {
       name2 = this.fixPropertyName(name2);
@@ -28972,7 +28849,7 @@ class Instance {
         const valueInstance = property.value;
         valueInstance.addReferencedBy(this);
       }
-      this.Changed.Fire(name2);
+      if (!supressEvents) this.Changed.Fire(name2);
     } else {
       console.warn(`Property with name ${name2} was not found in ${this.GetFullName()}`);
     }
@@ -33845,6 +33722,9 @@ class FileMesh {
       console.warn(`Issue with parsed mesh: ${issue}`);
     }
     console.log(`Bytes left: ${view.view.byteLength - view.viewOffset}`);
+    if (this.skinning && this.skinning.skinnings.length > 0) {
+      console.log(this);
+    }
   }
   stripLODS() {
     let facesEnd = this.coreMesh.faces.length;
@@ -34732,7 +34612,7 @@ const API = {
           const buffer = response;
           const rbx = new RBX();
           rbx.fromBuffer(buffer);
-          if (FLAGS.ENABLE_API_CACHE) {
+          if (FLAGS.ENABLE_API_CACHE && FLAGS.ENABLE_API_RBX_CACHE) {
             CACHE.RBX.set(cacheStr, rbx.clone());
           }
           return rbx;
@@ -34760,7 +34640,7 @@ const API = {
           const buffer = response;
           const mesh = new FileMesh();
           await mesh.fromBuffer(buffer);
-          if (FLAGS.ENABLE_API_CACHE) {
+          if (FLAGS.ENABLE_API_CACHE && FLAGS.ENABLE_API_MESH_CACHE) {
             CACHE.Mesh.set(cacheStr, mesh.clone());
           }
           return mesh;
@@ -50396,6 +50276,7 @@ class AnimationTrack {
   length = 0;
   looped = false;
   priority = AnimationPriority.Core;
+  shouldUpdateMotors = false;
   //playing info
   pOriginalWeight = 0;
   pTargetWeight = 0;
@@ -50681,13 +50562,13 @@ class AnimationTrack {
         const propertyNames = child.getPropertyNames();
         for (const propertyName of propertyNames) {
           if (FaceControlNames.includes(propertyName)) {
-            child.setProperty(propertyName, 0);
+            child.setProperty(propertyName, 0, true);
           }
         }
       }
     }
   }
-  renderPose() {
+  renderPose(updateMotors = true) {
     const time = this.timePosition;
     if (this.trackType === "Sequence") {
       for (const group of this.keyframeGroups) {
@@ -50703,11 +50584,11 @@ class AnimationTrack {
               const easedTime = getEasingFunction(lowerKeyframe.easingDirection, lowerKeyframe.easingStyle)(keyframeTime);
               const oldTransformCF = motor.Prop("Transform").clone();
               const transformCF = lerpCFrame(oldTransformCF, lerpCFrame(lowerKeyframe.cframe, higherKeyframe.cframe, easedTime).inverse(), this.weight);
-              motor.setProperty("Transform", transformCF);
+              motor.setProperty("Transform", transformCF, true);
             } else if (lowerKeyframe) {
               const oldTransformCF = motor.Prop("Transform").clone();
               const transformCF = lerpCFrame(oldTransformCF, lowerKeyframe.cframe.inverse(), this.weight);
-              motor.setProperty("Transform", transformCF);
+              motor.setProperty("Transform", transformCF, true);
             }
           }
         } else if (group instanceof FaceKeyframeGroup && this.rig) {
@@ -50774,7 +50655,7 @@ class AnimationTrack {
             }
             const oldTransformCF = motor.Prop("Transform").clone();
             const transformCF = lerpCFrame(oldTransformCF, cf.inverse(), this.weight);
-            motor.setProperty("Transform", transformCF);
+            motor.setProperty("Transform", transformCF, true);
           }
         } else if (curve instanceof FaceCruve && this.rig && curve.value) {
           const part = this.rig.FindFirstChild(curve.parentName);
@@ -50795,6 +50676,15 @@ class AnimationTrack {
         }
       }
     }
+    if (updateMotors) this.updateMotors();
+  }
+  updateMotors() {
+    if (!this.rig) return;
+    for (const child of this.rig.GetDescendants()) {
+      if (child.className === "Motor6D" || child.className === "Weld") {
+        child.Changed.Fire("C0");
+      }
+    }
   }
   setTime(time) {
     if (this.looped) {
@@ -50805,7 +50695,7 @@ class AnimationTrack {
     }
     this.timePosition = time;
     this.finished = time >= this.length;
-    this.renderPose();
+    this.renderPose(this.shouldUpdateMotors);
   }
   /**
    * Remember to call tick() on each frame
@@ -51065,7 +50955,7 @@ class AnimatorWrapper extends InstanceWrapper {
     const descendants = rig.GetDescendants();
     for (const child of descendants) {
       if (child.className === "Motor6D" && includeMotors) {
-        child.setProperty("Transform", new CFrame(0, 0, 0));
+        child.setProperty("Transform", new CFrame(0, 0, 0), true);
       } else if (child.className === "FaceControls" && includeFACS) {
         const propertyNames = child.getPropertyNames();
         for (const propertyName of propertyNames) {
@@ -51108,11 +50998,12 @@ class AnimatorWrapper extends InstanceWrapper {
     }
     const rig = this.instance.parent?.parent;
     if (rig) {
-      for (const child of rig.GetDescendants()) {
-        if (child.className === "Motor6D") {
-          child.setProperty("Transform", child.Prop("Transform"));
-        } else if (child.className === "Weld") {
-          child.setProperty("C0", child.Prop("C0"));
+      const descedants = rig.GetDescendants();
+      for (let i = 0; i < 2; i++) {
+        for (const child of descedants) {
+          if (child.className === "Motor6D" || child.className === "Weld") {
+            child.Changed.Fire("C0");
+          }
         }
       }
     }
@@ -51259,6 +51150,65 @@ class AnimatorWrapper extends InstanceWrapper {
     return false;
   }
 }
+class BodyColorsWrapper extends InstanceWrapper {
+  static className = "BodyColors";
+  static requiredProperties = [
+    "Name",
+    "HeadColor3",
+    "TorsoColor3",
+    "LeftArmColor3",
+    "RightArmColor3",
+    "LeftLegColor3",
+    "RightLegColor3"
+  ];
+  setup() {
+    if (!this.instance.HasProperty("Name")) this.instance.addProperty(new Property("Name", DataType.String), this.instance.className);
+    if (!this.instance.HasProperty("HeadColor3")) this.instance.addProperty(new Property("HeadColor3", DataType.Color3), new Color3());
+    if (!this.instance.HasProperty("TorsoColor3")) this.instance.addProperty(new Property("TorsoColor3", DataType.Color3), new Color3());
+    if (!this.instance.HasProperty("LeftArmColor3")) this.instance.addProperty(new Property("LeftArmColor3", DataType.Color3), new Color3());
+    if (!this.instance.HasProperty("RightArmColor3")) this.instance.addProperty(new Property("RightArmColor3", DataType.Color3), new Color3());
+    if (!this.instance.HasProperty("LeftLegColor3")) this.instance.addProperty(new Property("LeftLegColor3", DataType.Color3), new Color3());
+    if (!this.instance.HasProperty("RightLegColor3")) this.instance.addProperty(new Property("RightLegColor3", DataType.Color3), new Color3());
+  }
+  created() {
+    this.instance.Changed.Connect(() => {
+      this.update();
+    });
+  }
+  update() {
+    const rig = this.instance.parent;
+    if (!rig) {
+      return;
+    }
+    const humanoid = rig.FindFirstChildOfClass("Humanoid");
+    if (!humanoid) {
+      return;
+    }
+    const bodyPartDictionary = {
+      "Head": ["Head"],
+      "Torso": ["Torso", "UpperTorso", "LowerTorso"],
+      "LeftArm": ["Left Arm", "LeftHand", "LeftLowerArm", "LeftUpperArm"],
+      "RightArm": ["Right Arm", "RightHand", "RightLowerArm", "RightUpperArm"],
+      "LeftLeg": ["Left Leg", "LeftFoot", "LeftLowerLeg", "LeftUpperLeg"],
+      "RightLeg": ["Right Leg", "RightFoot", "RightLowerLeg", "RightUpperLeg"]
+    };
+    const bodyParts = [];
+    for (const child of rig.GetChildren()) {
+      if (child.className === "Part" || child.className === "MeshPart") {
+        bodyParts.push(child);
+      }
+    }
+    for (const bodyPart in bodyPartDictionary) {
+      const bodyPartNames = bodyPartDictionary[bodyPart];
+      const color = this.instance.Prop(bodyPart + "Color3").toColor3uint8();
+      for (const child of bodyParts) {
+        if (bodyPartNames.includes(child.Prop("Name"))) {
+          child.setProperty("Color", color);
+        }
+      }
+    }
+  }
+}
 class BodyPartDescriptionWrapper extends InstanceWrapper {
   static className = "BodyPartDescription";
   static requiredProperties = ["Name", "AssetId", "BodyPart", "Color", "Instance"];
@@ -52143,13 +52093,15 @@ class HumanoidDescriptionWrapper extends InstanceWrapper {
             if (rbx instanceof RBX) {
               const dataModel = rbx.generateTree();
               const asset = dataModel.GetChildren()[0];
-              if (asset) {
+              if (asset && ["Shirt", "Pants", "ShirtGraphic"].includes(asset.className)) {
                 const assetClassName = asset.className;
                 const originalAsset = rig.FindFirstChildOfClass(assetClassName);
                 if (originalAsset) {
                   originalAsset.Destroy();
                 }
                 asset.setParent(rig);
+              } else {
+                console.warn(`Clothing asset does not exist or is invalid`);
               }
               resolve(void 0);
             } else {
@@ -52192,7 +52144,7 @@ class HumanoidDescriptionWrapper extends InstanceWrapper {
       if (rbx instanceof RBX) {
         const dataModel = rbx.generateTree();
         const face = dataModel.GetChildren()[0];
-        if (face) {
+        if (face && face.className === "Decal") {
           const head = rig.FindFirstChild("Head");
           if (head) {
             const children = head.GetChildren();
@@ -52203,6 +52155,8 @@ class HumanoidDescriptionWrapper extends InstanceWrapper {
             }
             face.setParent(head);
           }
+        } else {
+          console.warn(`Face asset does not exist or is invalid`);
         }
       } else {
         return rbx;
@@ -52236,17 +52190,32 @@ class HumanoidDescriptionWrapper extends InstanceWrapper {
       if (rbx instanceof RBX) {
         const dataModel = rbx.generateTree();
         const tool = dataModel.GetChildren()[0];
-        if (tool) {
+        if (tool && tool.className === "Tool") {
           const oldTool = rig.FindFirstChildOfClass("Tool");
           if (oldTool) {
             oldTool.Destroy();
           }
+          const handle = tool.FindFirstChild("Handle");
           for (const child of tool.GetDescendants()) {
             if (child.className === "Motor6D" || child.className === "Weld") {
-              child.Destroy();
+              if (child.HasProperty("Part0") && child.HasProperty("Part1") && child.HasProperty("C0") && child.HasProperty("C1") && child.Prop("Part1") === handle) {
+                const part0 = child.Prop("Part0");
+                const part1 = child.Prop("Part1");
+                const c0 = child.Prop("C0");
+                const c1 = child.Prop("C1");
+                child.setProperty("Part0", part1, true);
+                child.setProperty("Part1", part0, true);
+                child.setProperty("C0", c1, true);
+                child.setProperty("C1", c0);
+              } else if (child.HasProperty("Part0") && child.Prop("Part0") === handle) ;
+              else {
+                child.Destroy();
+              }
             }
           }
           tool.setParent(rig);
+        } else {
+          console.warn(`Gear asset does not exist or is invalid`);
         }
       } else {
         return rbx;
@@ -52323,7 +52292,7 @@ class HumanoidDescriptionWrapper extends InstanceWrapper {
           if (rbx instanceof RBX) {
             const dataModel = rbx.generateTree();
             const accessory = dataModel.GetChildren()[0];
-            if (accessory) {
+            if (accessory && accessory.className === "Accessory") {
               let isLayered = false;
               const handle = accessory.FindFirstChild("Handle");
               if (handle) {
@@ -52336,6 +52305,8 @@ class HumanoidDescriptionWrapper extends InstanceWrapper {
               if (accessoryDesc) {
                 accessoryDesc.setProperty("Instance", accessory);
               }
+            } else {
+              console.warn(`Accessory asset does not exist or is invalid`);
             }
             resolve(void 0);
           } else {
@@ -52409,7 +52380,7 @@ class HumanoidDescriptionWrapper extends InstanceWrapper {
           if (rbx instanceof RBX) {
             const dataModel = rbx.generateTree();
             const makeup = dataModel.GetChildren()[0];
-            if (makeup) {
+            if (makeup && makeup.className === "Decal") {
               const head2 = rig.FindFirstChild("Head");
               if (head2) {
                 makeup.setParent(head2);
@@ -52418,6 +52389,8 @@ class HumanoidDescriptionWrapper extends InstanceWrapper {
               if (makeupDesc) {
                 makeupDesc.setProperty("Instance", makeup);
               }
+            } else {
+              console.warn(`Makeup asset does not exist or is invalid`);
             }
             resolve(void 0);
           } else {
@@ -52690,6 +52663,106 @@ class ModelWrapper extends InstanceWrapper {
     return higherExtents.minus(lowerExtents);
   }
 }
+class WeldWrapperData {
+  part0ChangedConnection;
+  lastUpdateTime = 0;
+  timeUpdates = 0;
+}
+class WeldWrapper extends InstanceWrapper {
+  static className = "Weld";
+  static requiredProperties = [
+    "Name",
+    "Enabled",
+    "Part0",
+    "Part1",
+    "C0",
+    "C1",
+    "_data"
+  ];
+  setup() {
+    if (!this.instance.HasProperty("Name")) this.instance.addProperty(new Property("Name", DataType.String), this.instance.className);
+    if (!this.instance.HasProperty("Enabled")) this.instance.addProperty(new Property("Enabled", DataType.Bool), true);
+    if (!this.instance.HasProperty("Part0")) this.instance.addProperty(new Property("Part0", DataType.Referent), void 0);
+    if (!this.instance.HasProperty("Part1")) this.instance.addProperty(new Property("Part1", DataType.Referent), void 0);
+    if (!this.instance.HasProperty("C0")) this.instance.addProperty(new Property("C0", DataType.CFrame), new CFrame());
+    if (!this.instance.HasProperty("C1")) this.instance.addProperty(new Property("C1", DataType.CFrame), new CFrame());
+    if (!this.instance.HasProperty("_data")) this.instance.addProperty(new Property("_data", DataType.NonSerializable), new WeldWrapperData());
+  }
+  get data() {
+    return this.instance.Prop("_data");
+  }
+  created() {
+    const changedConnection = this.instance.Changed.Connect(() => {
+      this.update();
+    });
+    const ancestryChangedConnection = this.instance.AncestryChanged.Connect(() => {
+      this.update();
+    });
+    this.instance.addConnectionReference(changedConnection);
+    this.instance.addConnectionReference(ancestryChangedConnection);
+  }
+  update(affectedPart = 1) {
+    if (!this.instance.parent) return;
+    if (this.data.lastUpdateTime === Date.now()) {
+      this.data.timeUpdates += 1;
+      if (this.data.timeUpdates > 100) {
+        console.error(this.instance);
+        console.error(`${this.instance.className} is exhausted`);
+        return;
+      }
+    } else {
+      this.data.timeUpdates = 0;
+    }
+    this.data.lastUpdateTime = Date.now();
+    const part0 = this.instance.Prop("Part0");
+    if (part0) {
+      if (this.data.part0ChangedConnection) {
+        this.data.part0ChangedConnection.Disconnect();
+        this.instance.removeConnectionReference(this.data.part0ChangedConnection);
+      }
+    }
+    const part1 = this.instance.Prop("Part1");
+    const C0 = this.instance.Prop("C0");
+    const C1 = this.instance.Prop("C1");
+    const transform = this.instance.PropOrDefault("Transform", new CFrame());
+    if (part0 === part1 || !part0 || !part1) {
+      return;
+    }
+    if (this.instance.HasProperty("Enabled") && this.instance.Prop("Enabled")) {
+      if (this.instance.parent) {
+        if (affectedPart === 1) {
+          if (part0.HasProperty("CFrame") && part1.HasProperty("CFrame")) {
+            const part0Cf = part0.Property("CFrame");
+            const offset1 = C1.multiply(transform).inverse();
+            const finalCF = part0Cf.multiply(C0).multiply(offset1);
+            part1.setProperty("CFrame", finalCF);
+          }
+        }
+      } else {
+        console.warn("Motor6D/Weld is missing parent");
+      }
+    }
+    if (part0) {
+      this.data.part0ChangedConnection = part0.Changed.Connect((propertyName) => {
+        if (propertyName === "CFrame") {
+          this.update(1);
+        }
+      });
+      this.instance.addConnectionReference(this.data.part0ChangedConnection);
+    }
+  }
+}
+class Motor6DWrapper extends WeldWrapper {
+  static className = "Motor6D";
+  static requiredProperties = [
+    ...super.requiredProperties,
+    "Transform"
+  ];
+  setup() {
+    super.setup();
+    if (!this.instance.HasProperty("Transform")) this.instance.addProperty(new Property("Transform", DataType.CFrame), new CFrame());
+  }
+}
 class SoundWrapperData {
   audio;
 }
@@ -52866,12 +52939,15 @@ function RegisterWrappers() {
   ScriptWrapper.register();
   SoundWrapper.register();
   ToolWrapper.register();
+  WeldWrapper.register();
+  Motor6DWrapper.register();
   AnimatorWrapper.register();
   FaceControlsWrapper.register();
   HumanoidDescriptionWrapper.register();
   BodyPartDescriptionWrapper.register();
   AccessoryDescriptionWrapper.register();
   MakeupDescriptionWrapper.register();
+  BodyColorsWrapper.register();
 }
 const _changeEvent = { type: "change" };
 const _startEvent = { type: "start" };
@@ -57581,7 +57657,7 @@ class MeshDesc {
               inheritSkeleton(mesh, transferTo);
             }
             const rbfDeformer = new RBFDeformerPatch(ref_mesh, dist_mesh, mesh);
-            rbfDeformer.affectBones = false;
+            rbfDeformer.affectBones = FLAGS.USE_LOCAL_SKELETONDESC;
             await rbfDeformer.solveAsync();
             rbfDeformer.deformMesh();
             break;
@@ -59046,14 +59122,14 @@ class MaterialDesc {
     }
   }
 }
-function setBoneToCFrame(bone, cf) {
+function setBoneToCFrame$1(bone, cf) {
   bone.position.set(...cf.Position);
   bone.rotation.order = "YXZ";
   bone.rotation.x = rad(cf.Orientation[0]);
   bone.rotation.y = rad(cf.Orientation[1]);
   bone.rotation.z = rad(cf.Orientation[2]);
 }
-function getJointForInstances(parent, child, includeTransform) {
+function getJointForInstances$1(parent, child, includeTransform) {
   const childMotor = child.FindFirstChildOfClass("Motor6D");
   const parentMotor = parent.FindFirstChildOfClass("Motor6D");
   let transform = new CFrame();
@@ -59070,13 +59146,65 @@ function getJointForInstances(parent, child, includeTransform) {
   }
   return new CFrame();
 }
-class SkeletonDesc {
+function boneIsChildOf(bone, parentName) {
+  let nextParent = bone.parent;
+  while (nextParent) {
+    if (nextParent.name === parentName) {
+      return true;
+    }
+    nextParent = nextParent.parent;
+  }
+  return false;
+}
+function getMotorsInRig(rigChildren) {
+  const motors = [];
+  for (const child of rigChildren) {
+    for (const motor of child.GetChildren()) {
+      if (motor.className === "Motor6D") {
+        motors.push(motor);
+      }
+    }
+  }
+  return motors;
+}
+function getBoneDependencies(rig) {
+  const names = /* @__PURE__ */ new Map();
+  const hrp = rig.FindFirstChild("HumanoidRootPart");
+  let currentSearch = hrp ? [hrp] : [];
+  let currentSearchOrigin = hrp ? ["Root"] : [];
+  const children = rig.GetChildren();
+  const motors = getMotorsInRig(children);
+  while (currentSearch.length > 0 && currentSearch[0]) {
+    const newCurrentSearch = [];
+    const newCurrentSearchOrigin = [];
+    for (let i = 0; i < currentSearch.length; i++) {
+      const toSearch = currentSearch[i];
+      const selfName = toSearch === hrp ? "HumanoidRootNode" : toSearch.Prop("Name");
+      names.set(selfName, currentSearchOrigin[i]);
+      for (const motor of motors) {
+        if (motor.Prop("Part0") === toSearch) {
+          newCurrentSearch.push(motor.parent);
+          newCurrentSearchOrigin.push(selfName);
+        }
+      }
+    }
+    currentSearch = newCurrentSearch;
+    currentSearchOrigin = newCurrentSearchOrigin;
+  }
+  if (names.get("Head")) {
+    names.set("DynamicHead", "Head");
+  }
+  return names;
+}
+let SkeletonDesc$1 = class SkeletonDesc {
   renderableDesc;
   meshDesc;
   skeleton;
   rootBone;
   bones;
   originalBoneCFrames = [];
+  originalHeadCFrame = new CFrame();
+  originalDynamicHeadCFrame = new CFrame();
   skeletonHelper;
   constructor(renderableDesc, meshDesc, scene) {
     this.renderableDesc = renderableDesc;
@@ -59090,6 +59218,9 @@ class SkeletonDesc {
     for (let i = 0; i < skinning.bones.length; i++) {
       const threeBone = new Bone();
       threeBone.name = skinning.nameTable[i];
+      if (threeBone.name === "HumanoidRootPart") {
+        threeBone.name = "HumanoidRootNode";
+      }
       boneArr.push(threeBone);
     }
     this.bones = boneArr;
@@ -59106,13 +59237,19 @@ class SkeletonDesc {
         worldBoneCF.fromRotationMatrix(...bone.rotationMatrix);
         const boneCF = worldParentBoneCF.inverse().multiply(worldBoneCF);
         this.originalBoneCFrames.push(boneCF);
-        setBoneToCFrame(threeBone, boneCF);
+        if (threeBone.name === "Head") {
+          this.originalHeadCFrame = boneCF;
+        } else if (threeBone.name === "DynamicHead") {
+          this.originalDynamicHeadCFrame = boneCF;
+        }
+        setBoneToCFrame$1(threeBone, boneCF);
         parentThreeBone.add(threeBone);
       } else {
         rootBone = threeBone;
-        threeBone.position.set(0, 0, 0);
-        threeBone.rotation.set(0, 0, 0, "YXZ");
-        this.originalBoneCFrames.push(new CFrame());
+        const boneCF = new CFrame(...bone.position);
+        boneCF.fromRotationMatrix(...bone.rotationMatrix);
+        this.originalBoneCFrames.push(boneCF);
+        setBoneToCFrame$1(threeBone, boneCF);
       }
     }
     if (!rootBone) {
@@ -59130,6 +59267,20 @@ class SkeletonDesc {
       }
       this.rootBone = rootBone;
     }
+    const rig = this.getRig();
+    if (rig) {
+      const boneDependencies = getBoneDependencies(rig);
+      for (const bone of [...this.bones]) {
+        let lastBone = bone.name;
+        while (lastBone) {
+          const newLastBone = boneDependencies.get(lastBone);
+          if (newLastBone && !this.getBoneWithName(newLastBone)) {
+            this.insertBefore(newLastBone, lastBone);
+          }
+          lastBone = newLastBone;
+        }
+      }
+    }
     this.skeleton = new Skeleton(boneArr);
     this.setAsRest();
     if (FLAGS.SHOW_SKELETON_HELPER) {
@@ -59137,6 +59288,7 @@ class SkeletonDesc {
       scene.add(skeletonHelper);
       this.skeletonHelper = skeletonHelper;
     }
+    console.log(this.skeleton);
   }
   setAsRest() {
     for (const bone of this.skeleton.bones) {
@@ -59144,6 +59296,57 @@ class SkeletonDesc {
       this.skeleton.boneInverses[boneIndex].copy(bone.matrixWorld).invert();
     }
   }
+  traverseOriginal(name2) {
+    const cframes = [];
+    let lastBone = this.getBoneWithName(name2);
+    while (lastBone) {
+      const index = this.bones.indexOf(lastBone);
+      const ogCFrame = this.originalBoneCFrames[index];
+      cframes.push(ogCFrame);
+      lastBone = lastBone.parent ? this.getBoneWithName(lastBone.parent.name) : void 0;
+    }
+    cframes.reverse();
+    let finalCF = new CFrame();
+    for (const cf of cframes) {
+      finalCF = finalCF.multiply(cf);
+    }
+    return finalCF;
+  }
+  insertBefore(toInsert, before) {
+    const bone = new Bone();
+    bone.name = toInsert;
+    bone.position.set(0, 0, 0);
+    bone.rotation.set(0, 0, 0, "YXZ");
+    for (let i = 0; i < this.bones.length; i++) {
+      if (this.bones[i].name === before) {
+        const beforeBone = this.bones[i];
+        const beforeParent = beforeBone.parent;
+        this.originalBoneCFrames.push(new CFrame());
+        this.bones.push(bone);
+        bone.add(beforeBone);
+        beforeParent?.add(bone);
+        break;
+      }
+    }
+  }
+  getBoneWithName(name2) {
+    for (const bone of this.bones) {
+      if (bone.name === name2) {
+        return bone;
+      }
+    }
+  }
+  getRig() {
+    const selfInstance = this.meshDesc.instance;
+    if (!selfInstance) return;
+    let rig = selfInstance.parent;
+    if (rig && rig.className !== "Model") {
+      rig = rig.parent;
+    }
+    if (rig?.className === "Model") {
+      return rig;
+    }
+  }
   getPartEquivalent(selfInstance, name2) {
     if (!selfInstance.parent) return;
     let partEquivalent = selfInstance.parent.FindFirstChild(name2);
@@ -59171,51 +59374,87 @@ class SkeletonDesc {
   }
   updateBoneMatrix(selfInstance, includeTransform = false) {
     if (!selfInstance.parent) return;
+    if (!this.meshDesc.fileMesh) return;
+    const isHead = this.meshDesc.headMesh === this.meshDesc.mesh;
+    const rootBoneCFog = this.getRootCFrame(selfInstance, includeTransform);
+    const humanoidRootPartEquivalent = this.getPartEquivalent(selfInstance, "HumanoidRootPart");
     for (let i = 0; i < this.bones.length; i++) {
       const bone = this.bones[i];
       const partEquivalent = this.getPartEquivalent(selfInstance, bone.name);
-      const parentPartEquivalent = bone.parent ? this.getPartEquivalent(selfInstance, bone.parent.name !== "HumanoidRootNode" ? bone.parent.name : "HumanoidRootPart") : void 0;
+      const parentPartEquivalent = bone.parent ? bone.parent.name !== "HumanoidRootNode" ? this.getPartEquivalent(selfInstance, bone.parent.name) : humanoidRootPartEquivalent : void 0;
       let rootBoneCF = new CFrame();
       if (bone.name === "Root") {
-        rootBoneCF = this.getRootCFrame(selfInstance, includeTransform);
+        rootBoneCF = rootBoneCFog;
       } else if (bone.parent?.name === "Root") {
-        rootBoneCF = this.getRootCFrame(selfInstance, includeTransform).inverse();
+        rootBoneCF = rootBoneCFog.inverse();
       }
       if (partEquivalent && parentPartEquivalent) {
-        setBoneToCFrame(bone, rootBoneCF.multiply(getJointForInstances(parentPartEquivalent, partEquivalent, includeTransform)));
+        setBoneToCFrame$1(bone, rootBoneCF.multiply(getJointForInstances$1(parentPartEquivalent, partEquivalent, includeTransform)));
       } else if (partEquivalent) {
         if (includeTransform) {
-          setBoneToCFrame(bone, rootBoneCF.multiply(partEquivalent.Prop("CFrame")));
+          setBoneToCFrame$1(bone, rootBoneCF.multiply(partEquivalent.Prop("CFrame")));
         } else {
           let hrpCF = new CFrame();
-          const hrp = this.getPartEquivalent(selfInstance, "HumanoidRootPart");
+          const hrp = humanoidRootPartEquivalent;
           if (hrp) {
             hrpCF = hrp.Prop("CFrame");
           }
-          setBoneToCFrame(bone, rootBoneCF.multiply(hrpCF.multiply(traverseRigCFrame(partEquivalent))));
+          setBoneToCFrame$1(bone, rootBoneCF.multiply(hrpCF.multiply(traverseRigCFrame(partEquivalent))));
         }
       } else if (bone.name === "Root") {
-        setBoneToCFrame(bone, rootBoneCF.multiply(new CFrame()));
+        setBoneToCFrame$1(bone, rootBoneCF.multiply(new CFrame()));
       } else if (bone.name === "HumanoidRootNode") {
         let rootCF = new CFrame();
-        const rootPart = this.getPartEquivalent(selfInstance, "HumanoidRootPart");
+        const rootPart = humanoidRootPartEquivalent;
         if (rootPart) {
           rootCF = rootPart.Prop("CFrame");
         }
-        setBoneToCFrame(bone, rootBoneCF.multiply(rootCF));
-      } else if (bone.name === "DynamicHead" || bone.parent?.name === "DynamicHead" || bone.parent?.parent?.name === "DynamicHead" || bone.parent?.parent?.parent?.name === "DynamicHead") {
+        setBoneToCFrame$1(bone, rootBoneCF.multiply(rootCF));
+      } else if (bone.name === "DynamicHead" && isHead) {
+        const head = this.getPartEquivalent(selfInstance, "Head");
+        if (head) {
+          let targetCF = this.traverseOriginal("DynamicHead");
+          if (this.meshDesc.wasAutoSkinned) {
+            targetCF = this.originalBoneCFrames[i];
+          }
+          const headSize = head.Prop("Size");
+          const ogHeadSize = isHead ? new Vector32(...this.meshDesc.fileMesh.size) : getOriginalSize(head);
+          let scale = divide$1(headSize.toVec3(), ogHeadSize.toVec3());
+          if (this.meshDesc.wasAutoSkinned) {
+            scale = [1, 1, 1];
+          }
+          const scaledCF = targetCF.clone();
+          scaledCF.Position = multiply$1(scaledCF.Position, scale);
+          const neck = head.FindFirstChildOfClass("Motor6D");
+          let neckCF = new CFrame();
+          if (neck) {
+            neckCF = neck.PropOrDefault("C1", new CFrame());
+          }
+          if (this.meshDesc.wasAutoSkinned) {
+            neckCF = new CFrame();
+          }
+          const totalCF = neckCF.inverse().multiply(scaledCF);
+          setBoneToCFrame$1(bone, totalCF);
+        }
+      } else if (!isHead || boneIsChildOf(bone, "DynamicHead")) {
         const ogCF = this.originalBoneCFrames[i];
         const head = this.getPartEquivalent(selfInstance, "Head");
         if (head) {
           const headSize = head.Prop("Size");
-          const ogHeadSize = getOriginalSize(head);
+          const ogHeadSize = isHead ? new Vector32(...this.meshDesc.fileMesh.size) : getOriginalSize(head);
           let scale = divide$1(headSize.toVec3(), ogHeadSize.toVec3());
           if (this.meshDesc.wasAutoSkinned) {
             scale = [1, 1, 1];
           }
           const scaledCF = ogCF.clone();
           scaledCF.Position = multiply$1(scaledCF.Position, scale);
-          setBoneToCFrame(bone, scaledCF);
+          const headOffset = this.originalHeadCFrame.clone();
+          headOffset.Position = [0, 0, 0];
+          if (bone.name !== "DynamicHead") {
+            headOffset.Orientation = [0, 0, 0];
+          }
+          const finalCF = headOffset.multiply(scaledCF);
+          setBoneToCFrame$1(bone, finalCF);
         }
       }
     }
@@ -59231,7 +59470,8 @@ class SkeletonDesc {
     }
   }
   update(instance) {
-    if (!FLAGS.UPDATE_SKELETON || !instance.parent) return;
+    if (!FLAGS.UPDATE_SKELETON || !instance.parent || !this.meshDesc.fileMesh) return;
+    const isHead = this.meshDesc.headMesh === this.meshDesc.mesh;
     this.updateBoneMatrix(instance);
     if (FLAGS.ANIMATE_SKELETON) {
       this.updateBoneMatrix(instance, true);
@@ -59243,7 +59483,7 @@ class SkeletonDesc {
           const head = this.getPartEquivalent(instance, "Head");
           if (head && facsMesh && facs && facs.quantizedTransforms) {
             const headSize = head.Prop("Size");
-            const ogHeadSize = getOriginalSize(head);
+            const ogHeadSize = isHead ? new Vector32(...this.meshDesc.fileMesh.size) : getOriginalSize(head);
             let headScale = divide$1(headSize.toVec3(), ogHeadSize.toVec3());
             if (this.meshDesc.wasAutoSkinned) {
               headScale = [1, 1, 1];
@@ -59263,7 +59503,7 @@ class SkeletonDesc {
                 const head2 = this.getPartEquivalent(instance, "Head");
                 if (head2) {
                   const headSize2 = head2.Prop("Size");
-                  const ogHeadSize2 = getOriginalSize(head2);
+                  const ogHeadSize2 = isHead ? new Vector32(...this.meshDesc.fileMesh.size) : getOriginalSize(head2);
                   let scale = divide$1(headSize2.toVec3(), ogHeadSize2.toVec3());
                   if (this.meshDesc.wasAutoSkinned) {
                     scale = [1, 1, 1];
@@ -59304,9 +59544,265 @@ class SkeletonDesc {
                   totalRotation = totalRotation.add(rot.multiply(new Vector32(weight, weight, weight)));
                 }
                 const resultCF = new CFrame();
-                const euler = new Euler(rad(totalRotation.X), rad(totalRotation.Y), rad(totalRotation.Z), "YXZ");
+                const euler = new Euler(rad(totalRotation.X), rad(totalRotation.Y), rad(totalRotation.Z), "XYZ");
+                euler.reorder("YXZ");
                 resultCF.Orientation = [deg(euler.x), deg(euler.y), deg(euler.z)];
                 resultCF.Position = multiply$1(totalPosition.toVec3(), headScale);
+                setBoneToCFrame$1(bone, jointCF.multiply(resultCF));
+                break;
+              }
+            }
+          }
+        }
+      }
+    }
+    this.updateMatrixWorld();
+  }
+  dispose(scene) {
+    if (this.skeletonHelper) {
+      scene.remove(this.skeletonHelper);
+      this.skeletonHelper.dispose();
+      this.skeletonHelper = void 0;
+    }
+    if (this.rootBone.parent) {
+      this.rootBone.parent.remove(this.rootBone);
+    }
+    for (let i = 0; i < this.skeleton.bones.length; i++) {
+      const bone = this.skeleton.bones[i];
+      if (bone.parent) {
+        bone.removeFromParent();
+      }
+    }
+  }
+  static descNeedsSkeleton(meshDesc) {
+    return meshDesc.canHaveSkinning && meshDesc.fileMesh && meshDesc.fileMesh.skinning && meshDesc.fileMesh.skinning.subsets.length > 0 && meshDesc.fileMesh.skinning.skinnings.length > 0;
+  }
+};
+function setBoneToCFrame(bone, cf) {
+  bone.position.set(...cf.Position);
+  bone.rotation.order = "YXZ";
+  bone.rotation.x = rad(cf.Orientation[0]);
+  bone.rotation.y = rad(cf.Orientation[1]);
+  bone.rotation.z = rad(cf.Orientation[2]);
+}
+function getJointForInstances(child, includeTransform) {
+  const childMotor = child.FindFirstChildOfClass("Motor6D");
+  let transform = new CFrame();
+  if (childMotor) {
+    if (includeTransform) {
+      transform = childMotor.Prop("Transform");
+      return transform.inverse();
+    }
+  }
+  return new CFrame();
+}
+class SkeletonDesc2 {
+  renderableDesc;
+  meshDesc;
+  skeleton;
+  rootBone;
+  bones;
+  originalBoneCFrames = [];
+  originalHeadCFrame = new CFrame();
+  originalDynamicHeadCFrame = new CFrame();
+  skeletonHelper;
+  constructor(renderableDesc, meshDesc, scene) {
+    this.renderableDesc = renderableDesc;
+    this.meshDesc = meshDesc;
+    const mesh = this.meshDesc.fileMesh;
+    if (!mesh) {
+      throw new Error("MeshDesc is not compiled");
+    }
+    const skinning = mesh.skinning;
+    const boneArr = [];
+    for (let i = 0; i < skinning.bones.length; i++) {
+      const threeBone = new Bone();
+      threeBone.name = skinning.nameTable[i];
+      boneArr.push(threeBone);
+    }
+    this.bones = boneArr;
+    let rootBone = void 0;
+    for (let i = 0; i < skinning.bones.length; i++) {
+      const bone = skinning.bones[i];
+      const threeBone = boneArr[i];
+      if (bone.parentIndex < skinning.bones.length) {
+        const parentBone = skinning.bones[bone.parentIndex];
+        const parentThreeBone = boneArr[bone.parentIndex];
+        const worldParentBoneCF = new CFrame(...parentBone.position);
+        worldParentBoneCF.fromRotationMatrix(...parentBone.rotationMatrix);
+        const worldBoneCF = new CFrame(...bone.position);
+        worldBoneCF.fromRotationMatrix(...bone.rotationMatrix);
+        const boneCF = worldParentBoneCF.inverse().multiply(worldBoneCF);
+        this.originalBoneCFrames.push(boneCF);
+        if (threeBone.name === "Head") {
+          this.originalHeadCFrame = boneCF;
+        } else if (threeBone.name === "DynamicHead") {
+          this.originalDynamicHeadCFrame = boneCF;
+        }
+        setBoneToCFrame(threeBone, boneCF);
+        parentThreeBone.add(threeBone);
+      } else {
+        rootBone = threeBone;
+        const worldBoneCF = new CFrame(...bone.position);
+        worldBoneCF.fromRotationMatrix(...bone.rotationMatrix);
+        setBoneToCFrame(threeBone, worldBoneCF);
+        this.originalBoneCFrames.push(worldBoneCF);
+      }
+    }
+    if (!rootBone) {
+      throw new Error("FileMesh has no root bone");
+    } else {
+      if (rootBone && rootBone.name !== "Root") {
+        const trueRootBone = new Bone();
+        trueRootBone.name = "Root";
+        trueRootBone.position.set(0, 0, 0);
+        trueRootBone.rotation.set(0, 0, 0, "YXZ");
+        this.originalBoneCFrames.unshift(new CFrame());
+        this.bones.unshift(trueRootBone);
+        trueRootBone.add(rootBone);
+        rootBone = trueRootBone;
+      }
+      this.rootBone = rootBone;
+    }
+    this.skeleton = new Skeleton(boneArr);
+    this.setAsRest();
+    if (FLAGS.SHOW_SKELETON_HELPER) {
+      const skeletonHelper = new SkeletonHelper(this.rootBone);
+      scene.add(skeletonHelper);
+      this.skeletonHelper = skeletonHelper;
+    }
+    console.log(this.skeleton);
+  }
+  setAsRest() {
+    for (const bone of this.skeleton.bones) {
+      const boneIndex = this.skeleton.bones.indexOf(bone);
+      this.skeleton.boneInverses[boneIndex].copy(bone.matrixWorld).invert();
+    }
+  }
+  getPartEquivalent(selfInstance, name2) {
+    if (!selfInstance.parent) return;
+    let partEquivalent = selfInstance.parent.FindFirstChild(name2);
+    if (partEquivalent === void 0 && selfInstance.parent.parent) {
+      partEquivalent = selfInstance.parent.parent.FindFirstChild(name2);
+    }
+    return partEquivalent;
+  }
+  getRootCFrame(instance, includeTransform) {
+    if (includeTransform) {
+      return instance.Prop("CFrame");
+    } else {
+      let bodyPart = void 0;
+      if (instance.parent && instance.parent.FindFirstChildOfClass("Humanoid")) {
+        bodyPart = instance;
+      } else if (instance.parent && instance.parent.parent && instance.parent.className === "Accessory") {
+        bodyPart = GetAttachedPart(instance.parent, instance.parent.parent);
+      }
+      const hrp = this.getPartEquivalent(instance, "HumanoidRootPart");
+      if (hrp && bodyPart) {
+        return hrp.Prop("CFrame").multiply(traverseRigCFrame(bodyPart));
+      }
+    }
+    return new CFrame();
+  }
+  updateBoneMatrix(selfInstance, includeTransform = false) {
+    if (!selfInstance.parent) return;
+    if (!this.meshDesc.fileMesh) return;
+    const ogMeshSize = new Vector32(...this.meshDesc.fileMesh.size);
+    const scale = divide$1((this.meshDesc.instance?.Prop("Size")).toVec3(), ogMeshSize.toVec3());
+    for (let i = 0; i < this.bones.length; i++) {
+      const bone = this.bones[i];
+      const partEquivalent = this.getPartEquivalent(selfInstance, bone.name);
+      const ogBoneCF = this.originalBoneCFrames[i].clone();
+      ogBoneCF.Position = multiply$1(ogBoneCF.Position, scale);
+      if (partEquivalent && includeTransform) {
+        setBoneToCFrame(bone, ogBoneCF.multiply(getJointForInstances(partEquivalent, includeTransform)));
+      } else {
+        setBoneToCFrame(bone, ogBoneCF);
+      }
+    }
+    this.updateMatrixWorld();
+    if (!includeTransform) {
+      this.setAsRest();
+      this.updateMatrixWorld();
+    }
+  }
+  updateMatrixWorld() {
+    for (const bone of this.skeleton.bones) {
+      bone.updateMatrixWorld(true);
+    }
+  }
+  update(instance) {
+    if (!FLAGS.UPDATE_SKELETON || !instance.parent || !this.meshDesc.fileMesh) return;
+    const isHead = this.meshDesc.headMesh === this.meshDesc.mesh;
+    this.updateBoneMatrix(instance);
+    if (FLAGS.ANIMATE_SKELETON) {
+      this.updateBoneMatrix(instance, true);
+      for (const bone of this.skeleton.bones) {
+        const isFACS = this.meshDesc.fileMesh?.facs?.faceBoneNames.includes(bone.name);
+        if (isFACS) {
+          const facsMesh = this.meshDesc.fileMesh;
+          const facs = this.meshDesc.fileMesh?.facs;
+          const head = this.getPartEquivalent(instance, "Head");
+          if (head && facsMesh && facs && facs.quantizedTransforms) {
+            let faceControls = head.FindFirstChildOfClass("FaceControls");
+            if (!faceControls) {
+              faceControls = new Instance("FaceControls");
+              faceControls.setParent(head);
+            }
+            new FaceControlsWrapper(faceControls);
+            for (let j = 0; j < facs.faceBoneNames.length; j++) {
+              const boneName = facs.faceBoneNames[j];
+              if (boneName === bone.name) {
+                let jointCF = new CFrame();
+                const ogCF = this.originalBoneCFrames[this.bones.indexOf(bone)];
+                jointCF = ogCF.clone();
+                const head2 = this.getPartEquivalent(instance, "Head");
+                if (head2) {
+                  const headSize = head2.Prop("Size");
+                  const ogHeadSize = isHead ? new Vector32(...this.meshDesc.fileMesh.size) : getOriginalSize(head2);
+                  let scale = divide$1(headSize.toVec3(), ogHeadSize.toVec3());
+                  if (this.meshDesc.wasAutoSkinned) {
+                    scale = [1, 1, 1];
+                  }
+                  jointCF.Position = multiply$1(jointCF.Position, scale);
+                }
+                let totalPosition = new Vector32();
+                let totalRotation = new Vector32();
+                for (let i = 0; i < facs.faceControlNames.length; i++) {
+                  const faceControlName = facs.faceControlNames[i];
+                  const col = i;
+                  const row = j;
+                  const cols = facs.faceControlNames.length;
+                  const index = row * cols + col;
+                  const posX = facs.quantizedTransforms.px.matrix[index];
+                  const posY = facs.quantizedTransforms.py.matrix[index];
+                  const posZ = facs.quantizedTransforms.pz.matrix[index];
+                  const rotX = facs.quantizedTransforms.rx.matrix[index];
+                  const rotY = facs.quantizedTransforms.ry.matrix[index];
+                  const rotZ = facs.quantizedTransforms.rz.matrix[index];
+                  const pos = new Vector32(posX, posY, posZ);
+                  const rot = new Vector32(rotX, rotY, rotZ);
+                  let weight = 0;
+                  if (faceControlName.includes(" ")) {
+                    weight = 1;
+                    for (const faceControlSubname of faceControlName.split(" ")) {
+                      const propertyName = AbbreviationToFaceControlProperty[faceControlSubname];
+                      weight *= faceControls.Prop(propertyName);
+                    }
+                  } else {
+                    const propertyName = AbbreviationToFaceControlProperty[faceControlName];
+                    if (propertyName === void 0) {
+                      console.log(faceControlName);
+                    }
+                    weight = faceControls.Prop(propertyName);
+                  }
+                  totalPosition = totalPosition.add(pos.multiply(new Vector32(weight, weight, weight)));
+                  totalRotation = totalRotation.add(rot.multiply(new Vector32(weight, weight, weight)));
+                }
+                const resultCF = new CFrame();
+                const euler = new Euler(rad(totalRotation.X), rad(totalRotation.Y), rad(totalRotation.Z), "YXZ");
+                resultCF.Orientation = [deg(euler.x), deg(euler.y), deg(euler.z)];
+                resultCF.Position = totalPosition.toVec3();
                 setBoneToCFrame(bone, jointCF.multiply(resultCF));
                 break;
               }
@@ -59558,8 +60054,14 @@ class ObjectDesc extends RenderDesc {
       const oldSize = this.originalScale;
       threeMesh.scale.set(this.size.X / oldSize.x, this.size.Y / oldSize.y, this.size.Z / oldSize.z);
     }
-    if (SkeletonDesc.descNeedsSkeleton(this.meshDesc)) {
-      this.skeletonDesc = new SkeletonDesc(this, this.meshDesc, scene);
+    if (SkeletonDesc$1.descNeedsSkeleton(this.meshDesc)) {
+      if (FLAGS.USE_LOCAL_SKELETONDESC) {
+        this.skeletonDesc = new SkeletonDesc2(this, this.meshDesc, scene);
+      } else {
+        this.skeletonDesc = new SkeletonDesc$1(this, this.meshDesc, scene);
+      }
+    } else {
+      this.meshDesc.fileMesh = void 0;
     }
     if (originalResult) {
       this.disposeMeshes(scene, originalResult);
@@ -59902,7 +60404,7 @@ class EmitterDesc extends DisposableDesc {
     return this.result;
   }
   emit(groupDesc) {
-    if (this.particles.length >= this.maxCount) {
+    if (this.particles.length >= this.maxCount || groupDesc.enabled === false) {
       return;
     }
     const speed = randomBetween(this.speed.Min, this.speed.Max);
@@ -59995,6 +60497,7 @@ class EmitterDesc extends DisposableDesc {
 class EmitterGroupDesc extends RenderDesc {
   lastTime = Date.now() / 1e3;
   time = Date.now() / 1e3;
+  enabled = true;
   lowerBound = new Vector32(0, 0, 0);
   higherBound = new Vector32(0, 0, 0);
   lastCframe = new CFrame();
@@ -60094,6 +60597,7 @@ class EmitterGroupDesc extends RenderDesc {
         this.lowerBound = size2.multiply(new Vector32(-0.5, -0.5, -0.5));
       }
     }
+    this.enabled = child.PropOrDefault("Enabled", true);
     const className = child.className;
     switch (className) {
       case "ParticleEmitter":
@@ -60305,6 +60809,9 @@ class RBXRenderer {
   static loadingIconStyle;
   static plane;
   static shadowPlane;
+  static ambientLight;
+  static directionalLight;
+  static directionalLight2;
   static async boilerplateSetup() {
     RegisterWrappers();
     setupWorkerPool();
@@ -60402,6 +60909,7 @@ class RBXRenderer {
     }
     const ambientLight = new AmbientLight(ambientLightColor, Math.PI / 2);
     RBXRenderer.scene.add(ambientLight);
+    RBXRenderer.ambientLight = ambientLight;
     let directionalLightColor = void 0;
     const directionalLightVal = 0.7 * 0.9 * 2 * 0.4;
     if (lightingType === "Thumbnail") {
@@ -60435,16 +60943,19 @@ class RBXRenderer {
     directionalLight.shadow.intensity = 0.5;
     directionalLight.target.position.set(0, 0, 0);
     RBXRenderer.scene.add(directionalLight);
+    RBXRenderer.directionalLight = directionalLight;
     if (lightingType === "WellLit") {
       const directionalLight2 = new DirectionalLight(16777215, 0.3);
       directionalLight2.position.set(5, -7, 5);
       directionalLight2.target.position.set(0, 0, 0);
       RBXRenderer.scene.add(directionalLight2);
+      RBXRenderer.directionalLight2 = directionalLight2;
     } else if (lightingType === "Thumbnail") {
       const directionalLight2 = new DirectionalLight(directionalLightColor, directionalLightIntensity * 0.5);
       directionalLight2.position.set(-0.47489210963249207 * -10, 0.8225368857383728 * -10, 0.3129066228866577 * -10);
       directionalLight2.target.position.set(0, 0, 0);
       RBXRenderer.scene.add(directionalLight2);
+      RBXRenderer.directionalLight2 = directionalLight2;
     }
     const planeGeometry = new PlaneGeometry(100, 100, 1, 1);
     const planeShadowMaterial = new ShadowMaterial({ opacity: 1 });
@@ -60570,7 +61081,11 @@ class RBXRenderer {
                   if (skeleton) {
                     result.bindMode = "detached";
                     if (newDesc.skeletonDesc) {
-                      RBXRenderer.scene.add(newDesc.skeletonDesc.rootBone);
+                      if (FLAGS.USE_LOCAL_SKELETONDESC) {
+                        result.add(newDesc.skeletonDesc.rootBone);
+                      } else {
+                        RBXRenderer.scene.add(newDesc.skeletonDesc.rootBone);
+                      }
                     }
                     result.bind(skeleton);
                     RBXRenderer.scene.add(result);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "roavatar-renderer",
-  "version": "1.2.2",
+  "version": "1.2.3",
   "description": "A renderer for Roblox avatars, used by the RoAvatar extension.",
   "author": "steinan",
   "type": "module",