roavatar-renderer 1.4.4 → 1.5.0

package/dist/index.js

@@ -15585,6 +15585,207 @@ class LightShadow {
     return object;
   }
 }
+class SpotLightShadow extends LightShadow {
+  /**
+   * Constructs a new spot light shadow.
+   */
+  constructor() {
+    super(new PerspectiveCamera(50, 1, 0.5, 500));
+    this.isSpotLightShadow = true;
+    this.focus = 1;
+    this.aspect = 1;
+  }
+  updateMatrices(light) {
+    const camera = this.camera;
+    const fov2 = RAD2DEG * 2 * light.angle * this.focus;
+    const aspect2 = this.mapSize.width / this.mapSize.height * this.aspect;
+    const far = light.distance || camera.far;
+    if (fov2 !== camera.fov || aspect2 !== camera.aspect || far !== camera.far) {
+      camera.fov = fov2;
+      camera.aspect = aspect2;
+      camera.far = far;
+      camera.updateProjectionMatrix();
+    }
+    super.updateMatrices(light);
+  }
+  copy(source) {
+    super.copy(source);
+    this.focus = source.focus;
+    return this;
+  }
+}
+class SpotLight extends Light {
+  /**
+   * Constructs a new spot light.
+   *
+   * @param {(number|Color|string)} [color=0xffffff] - The light's color.
+   * @param {number} [intensity=1] - The light's strength/intensity measured in candela (cd).
+   * @param {number} [distance=0] - Maximum range of the light. `0` means no limit.
+   * @param {number} [angle=Math.PI/3] - Maximum angle of light dispersion from its direction whose upper bound is `Math.PI/2`.
+   * @param {number} [penumbra=0] - Percent of the spotlight cone that is attenuated due to penumbra. Value range is `[0,1]`.
+   * @param {number} [decay=2] - The amount the light dims along the distance of the light.
+   */
+  constructor(color, intensity, distance2 = 0, angle = Math.PI / 3, penumbra = 0, decay = 2) {
+    super(color, intensity);
+    this.isSpotLight = true;
+    this.type = "SpotLight";
+    this.position.copy(Object3D.DEFAULT_UP);
+    this.updateMatrix();
+    this.target = new Object3D();
+    this.distance = distance2;
+    this.angle = angle;
+    this.penumbra = penumbra;
+    this.decay = decay;
+    this.map = null;
+    this.shadow = new SpotLightShadow();
+  }
+  /**
+   * The light's power. Power is the luminous power of the light measured in lumens (lm).
+   *  Changing the power will also change the light's intensity.
+   *
+   * @type {number}
+   */
+  get power() {
+    return this.intensity * Math.PI;
+  }
+  set power(power) {
+    this.intensity = power / Math.PI;
+  }
+  dispose() {
+    this.shadow.dispose();
+  }
+  copy(source, recursive) {
+    super.copy(source, recursive);
+    this.distance = source.distance;
+    this.angle = source.angle;
+    this.penumbra = source.penumbra;
+    this.decay = source.decay;
+    this.target = source.target.clone();
+    this.shadow = source.shadow.clone();
+    return this;
+  }
+}
+const _projScreenMatrix = /* @__PURE__ */ new Matrix4();
+const _lightPositionWorld = /* @__PURE__ */ new Vector3$1();
+const _lookTarget = /* @__PURE__ */ new Vector3$1();
+class PointLightShadow extends LightShadow {
+  /**
+   * Constructs a new point light shadow.
+   */
+  constructor() {
+    super(new PerspectiveCamera(90, 1, 0.5, 500));
+    this.isPointLightShadow = true;
+    this._frameExtents = new Vector2$1(4, 2);
+    this._viewportCount = 6;
+    this._viewports = [
+      // These viewports map a cube-map onto a 2D texture with the
+      // following orientation:
+      //
+      //  xzXZ
+      //   y Y
+      //
+      // X - Positive x direction
+      // x - Negative x direction
+      // Y - Positive y direction
+      // y - Negative y direction
+      // Z - Positive z direction
+      // z - Negative z direction
+      // positive X
+      new Vector4(2, 1, 1, 1),
+      // negative X
+      new Vector4(0, 1, 1, 1),
+      // positive Z
+      new Vector4(3, 1, 1, 1),
+      // negative Z
+      new Vector4(1, 1, 1, 1),
+      // positive Y
+      new Vector4(3, 0, 1, 1),
+      // negative Y
+      new Vector4(1, 0, 1, 1)
+    ];
+    this._cubeDirections = [
+      new Vector3$1(1, 0, 0),
+      new Vector3$1(-1, 0, 0),
+      new Vector3$1(0, 0, 1),
+      new Vector3$1(0, 0, -1),
+      new Vector3$1(0, 1, 0),
+      new Vector3$1(0, -1, 0)
+    ];
+    this._cubeUps = [
+      new Vector3$1(0, 1, 0),
+      new Vector3$1(0, 1, 0),
+      new Vector3$1(0, 1, 0),
+      new Vector3$1(0, 1, 0),
+      new Vector3$1(0, 0, 1),
+      new Vector3$1(0, 0, -1)
+    ];
+  }
+  /**
+   * Update the matrices for the camera and shadow, used internally by the renderer.
+   *
+   * @param {Light} light - The light for which the shadow is being rendered.
+   * @param {number} [viewportIndex=0] - The viewport index.
+   */
+  updateMatrices(light, viewportIndex = 0) {
+    const camera = this.camera;
+    const shadowMatrix = this.matrix;
+    const far = light.distance || camera.far;
+    if (far !== camera.far) {
+      camera.far = far;
+      camera.updateProjectionMatrix();
+    }
+    _lightPositionWorld.setFromMatrixPosition(light.matrixWorld);
+    camera.position.copy(_lightPositionWorld);
+    _lookTarget.copy(camera.position);
+    _lookTarget.add(this._cubeDirections[viewportIndex]);
+    camera.up.copy(this._cubeUps[viewportIndex]);
+    camera.lookAt(_lookTarget);
+    camera.updateMatrixWorld();
+    shadowMatrix.makeTranslation(-_lightPositionWorld.x, -_lightPositionWorld.y, -_lightPositionWorld.z);
+    _projScreenMatrix.multiplyMatrices(camera.projectionMatrix, camera.matrixWorldInverse);
+    this._frustum.setFromProjectionMatrix(_projScreenMatrix, camera.coordinateSystem, camera.reversedDepth);
+  }
+}
+class PointLight extends Light {
+  /**
+   * Constructs a new point light.
+   *
+   * @param {(number|Color|string)} [color=0xffffff] - The light's color.
+   * @param {number} [intensity=1] - The light's strength/intensity measured in candela (cd).
+   * @param {number} [distance=0] - Maximum range of the light. `0` means no limit.
+   * @param {number} [decay=2] - The amount the light dims along the distance of the light.
+   */
+  constructor(color, intensity, distance2 = 0, decay = 2) {
+    super(color, intensity);
+    this.isPointLight = true;
+    this.type = "PointLight";
+    this.distance = distance2;
+    this.decay = decay;
+    this.shadow = new PointLightShadow();
+  }
+  /**
+   * The light's power. Power is the luminous power of the light measured in lumens (lm).
+   * Changing the power will also change the light's intensity.
+   *
+   * @type {number}
+   */
+  get power() {
+    return this.intensity * 4 * Math.PI;
+  }
+  set power(power) {
+    this.intensity = power / (4 * Math.PI);
+  }
+  dispose() {
+    this.shadow.dispose();
+  }
+  copy(source, recursive) {
+    super.copy(source, recursive);
+    this.distance = source.distance;
+    this.decay = source.decay;
+    this.shadow = source.shadow.clone();
+    return this;
+  }
+}
 class OrthographicCamera extends Camera {
   /**
    * Constructs a new orthographic camera.
@@ -25266,7 +25467,7 @@ class WebGLRenderer {
     const _frustum = new Frustum();
     let _clippingEnabled = false;
     let _localClippingEnabled = false;
-    const _projScreenMatrix = new Matrix4();
+    const _projScreenMatrix2 = new Matrix4();
     const _vector32 = new Vector3$1();
     const _vector4 = new Vector4();
     const _emptyScene = { background: null, fog: null, environment: null, overrideMaterial: null, isScene: true };
@@ -25775,8 +25976,8 @@ class WebGLRenderer {
       currentRenderState = renderStates.get(scene, renderStateStack.length);
       currentRenderState.init(camera);
       renderStateStack.push(currentRenderState);
-      _projScreenMatrix.multiplyMatrices(camera.projectionMatrix, camera.matrixWorldInverse);
-      _frustum.setFromProjectionMatrix(_projScreenMatrix, WebGLCoordinateSystem, camera.reversedDepth);
+      _projScreenMatrix2.multiplyMatrices(camera.projectionMatrix, camera.matrixWorldInverse);
+      _frustum.setFromProjectionMatrix(_projScreenMatrix2, WebGLCoordinateSystem, camera.reversedDepth);
       _localClippingEnabled = this.localClippingEnabled;
       _clippingEnabled = clipping.init(this.clippingPlanes, _localClippingEnabled);
       currentRenderList = renderLists.get(scene, renderListStack.length);
@@ -25862,7 +26063,7 @@ class WebGLRenderer {
         } else if (object.isSprite) {
           if (!object.frustumCulled || _frustum.intersectsSprite(object)) {
             if (sortObjects) {
-              _vector4.setFromMatrixPosition(object.matrixWorld).applyMatrix4(_projScreenMatrix);
+              _vector4.setFromMatrixPosition(object.matrixWorld).applyMatrix4(_projScreenMatrix2);
             }
             const geometry = objects.update(object);
             const material = object.material;
@@ -25882,7 +26083,7 @@ class WebGLRenderer {
                 if (geometry.boundingSphere === null) geometry.computeBoundingSphere();
                 _vector4.copy(geometry.boundingSphere.center);
               }
-              _vector4.applyMatrix4(object.matrixWorld).applyMatrix4(_projScreenMatrix);
+              _vector4.applyMatrix4(object.matrixWorld).applyMatrix4(_projScreenMatrix2);
             }
             if (Array.isArray(material)) {
               const groups = geometry.groups;
@@ -27110,6 +27311,7 @@ const magic = "<roblox!";
 const xmlMagic = "<roblox ";
 const ObjectDescClassTypes = ["Part", "MeshPart", "Decal"];
 const EmitterGroupDescClassTypes = ["ParticleEmitter", "Sparkles", "Fire", "Smoke"];
+const LightDescClassTypes = ["PointLight", "SpotLight", "SurfaceLight"];
 const ParticleOrientation = {
   "FacingCamera": 0,
   "FacingCameraWorldUp": 1,
@@ -29548,7 +29750,7 @@ const FLAGS = {
   USE_RENDERTARGET: true,
   AUTO_RESTORE_CONTEXT: true,
   RENDERTARGET_TO_CANVASTEXTURE: false,
-  THUMBNAIL_TIMEOUT: 750,
+  THUMBNAIL_TIMEOUT: 500,
   //skeleton
   SHOW_SKELETON_HELPER: false,
   UPDATE_SKELETON: true,
@@ -30168,6 +30370,7 @@ class Instance {
       this._hasWrappered = true;
       wrapper.created();
     }
+    return wrapper;
   }
   addConnectionReference(connection) {
     if (!this._connectionReferences.includes(connection)) {
@@ -30307,6 +30510,9 @@ class Instance {
           const hex = BrickColors[this.Prop("BrickColor")];
           const rgb = hexToRgb(hex);
           const color3uint8 = new Color3uint8(rgb?.r, rgb?.g, rgb?.b);
+          color3uint8.R *= 255;
+          color3uint8.G *= 255;
+          color3uint8.B *= 255;
           return color3uint8;
         }
         break;
@@ -31802,6 +32008,22 @@ function snapToNumber(value, numbers) {
   }
   return closestNumber;
 }
+async function awaitTimeoutThrows(promise, time2 = 15e3) {
+  const timeoutPromise = new Promise((_resolve, reject) => {
+    setTimeout(() => {
+      reject(`Promise timed out after ${time2} milliseconds`);
+    }, time2);
+  });
+  return Promise.race([promise, timeoutPromise]);
+}
+async function awaitTimeout(promise, time2 = 15e3) {
+  const timeoutPromise = new Promise((resolve) => {
+    setTimeout(() => {
+      resolve(new Response(`Promise timed out after ${time2} milliseconds`));
+    }, time2);
+  });
+  return Promise.race([promise, timeoutPromise]);
+}
 function getXMLProperty(doc, propertyName) {
   const propertyNode = doc.querySelector('[name="' + propertyName + '"]');
   if (!propertyNode) {
@@ -35288,14 +35510,15 @@ async function RBLXPatch(url, auth, body, attempt = 0) {
   return RBLXPost(url, auth, body, attempt, "PATCH");
 }
 async function getAssetBufferInternal(url, headers, extraStr) {
-  API.Misc.startCurrentlyLoadingAssets();
+  const loadingLabel = `getAssetBufferInternal-${url}-${extraStr}`;
+  API.Misc.startCurrentlyLoadingAssets(loadingLabel);
   const fetchStr = await API.Misc.assetURLToCDNURL(url, headers, extraStr);
   if (fetchStr instanceof Response) {
-    API.Misc.stopCurrentlyLoadingAssets();
+    API.Misc.stopCurrentlyLoadingAssets(loadingLabel);
     return fetchStr;
   }
   const response = await RBLXGet(fetchStr, void 0, false);
-  API.Misc.stopCurrentlyLoadingAssets();
+  API.Misc.stopCurrentlyLoadingAssets(loadingLabel);
   if (response.status === 200) {
     const data = await response.arrayBuffer();
     return data;
@@ -35303,14 +35526,10 @@ async function getAssetBufferInternal(url, headers, extraStr) {
     return response;
   }
 }
-let isCurrentlyLoading = false;
-let currentlyLoadingAssets = 0;
-function _updateCurrentlyLoadingAssets() {
-  const newCurrentlyLoading = currentlyLoadingAssets > 0;
-  if (isCurrentlyLoading !== newCurrentlyLoading) {
-    API.Events.OnLoadingAssets.Fire(newCurrentlyLoading);
-  }
-  isCurrentlyLoading = newCurrentlyLoading;
+const currentlyLoadingAssets = [];
+function _updateCurrentlyLoadingAssets(type, label) {
+  const newCurrentlyLoading = currentlyLoadingAssets.length > 0;
+  API.Events.OnLoadingAssets.Fire(newCurrentlyLoading, type, label);
 }
 const CACHE = {
   "AssetBuffer": /* @__PURE__ */ new Map(),
@@ -35424,18 +35643,25 @@ function createContentMap() {
     ContentMap.set("roavatar://RigR6.rbxm", FLAGS.RIG_PATH + "RigR6.rbxm");
     ContentMap.set("roavatar://RigR15.rbxm", FLAGS.RIG_PATH + "RigR15.rbxm");
   }
+  ContentMap.set("roavatar://AvatarEditorScene.rbxm", "74148511291027");
+  ContentMap.set("roavatar://AvatarSceneNew.rbxm", "130507237273896");
 }
 let CachedRoAvatarData = void 0;
 let ThumbnailsToBatch = [];
 const API = {
   "Misc": {
-    "startCurrentlyLoadingAssets": function() {
-      currentlyLoadingAssets += 1;
-      _updateCurrentlyLoadingAssets();
+    "startCurrentlyLoadingAssets": function(label) {
+      currentlyLoadingAssets.push(label);
+      _updateCurrentlyLoadingAssets("start", label);
     },
-    "stopCurrentlyLoadingAssets": function() {
-      currentlyLoadingAssets -= 1;
-      _updateCurrentlyLoadingAssets();
+    "stopCurrentlyLoadingAssets": function(label) {
+      const labelIndex = currentlyLoadingAssets.indexOf(label);
+      if (labelIndex > -1) {
+        currentlyLoadingAssets.splice(labelIndex, 1);
+        _updateCurrentlyLoadingAssets("finish", label);
+      } else {
+        throw new Error(`Invalid loading label: ${label}`);
+      }
     },
     "idFromStr": function(str) {
       const numStrs = str.match(/\d+(\.\d+)?/g) || [];
@@ -35465,7 +35691,7 @@ const API = {
       } else if (str.startsWith(".")) {
         url = str;
       } else {
-        warn(false, `Failed to parse path of ${str}`);
+        warn(false, `Failed to parse path of ${str}, leaving as is`);
       }
       if (FLAGS.ASSETDELIVERY_V2) {
         if (url.includes("/v1/")) {
@@ -35497,6 +35723,12 @@ const API = {
       }
       const cdnURL = await API.Misc.getCDNURLFromAssetDelivery(fetchStr, headers);
       return cdnURL;
+    },
+    "getCurrentlyLoading": function() {
+      return currentlyLoadingAssets.length > 0;
+    },
+    "getCurrentlyLoadingLabels": function() {
+      return currentlyLoadingAssets;
     }
   },
   "Events": {
@@ -35514,6 +35746,7 @@ const API = {
             API.Misc.assetURLToCDNURL(url).then((fetchStr) => {
               if (fetchStr instanceof Response) {
                 resolve(void 0);
+                cacheResolve(void 0);
                 return;
               }
               const image = new Image();
@@ -35523,7 +35756,7 @@ const API = {
                 CACHE.Image.set(cacheURL, image);
               };
               image.onerror = () => {
-                cacheResolve(image);
+                cacheResolve(void 0);
                 resolve(void 0);
                 CACHE.Image.set(cacheURL, void 0);
               };
@@ -36447,6 +36680,7 @@ class RBFDeformerPatch {
   epsilon = 1e-6;
   // avoid matrix from being singular
   affectBones = true;
+  hasSolved = false;
   id = rbfDeformerIdCount++;
   /**
    * Creates the deformer and prepares for deformation
@@ -36512,29 +36746,37 @@ class RBFDeformerPatch {
    * @returns void
    */
   async solveAsync() {
+    this.hasSolved = true;
     if (this.refVerts.length === 0) {
       return;
     }
-    const [neighborIndicesBuf, weightsBuf, nearestPatchBuf] = await WorkerPool.instance.work(
-      "RBFDeformerSolveAsync",
-      [this.patchCount, this.K, this.epsilon, this.importantIndices.buffer, this.refVerts.buffer, this.distVerts.buffer, this.meshVerts.buffer, this.meshBones.buffer],
-      [
-        this.importantIndices.buffer,
-        /*this.refVerts.buffer,*/
-        this.distVerts.buffer,
-        this.meshVerts.buffer,
-        this.meshBones.buffer
-      ]
-    );
-    time(`RBFDeformerPatch.solveAsync.unpack.${this.id}`);
-    this.neighborIndices = neighborIndicesBuf.map((a) => {
-      return new Uint16Array(a);
-    });
-    this.weights = weightsBuf.map((a) => {
-      return new Float32Array(a);
-    });
-    this.nearestPatch = new Uint16Array(nearestPatchBuf);
-    timeEnd(`RBFDeformerPatch.solveAsync.unpack.${this.id}`);
+    const loadingLabel = `rbfDeform-${this.id}`;
+    API.Misc.startCurrentlyLoadingAssets(loadingLabel);
+    try {
+      const [neighborIndicesBuf, weightsBuf, nearestPatchBuf] = await awaitTimeoutThrows(WorkerPool.instance.work(
+        "RBFDeformerSolveAsync",
+        [this.patchCount, this.K, this.epsilon, this.importantIndices.buffer, this.refVerts.buffer, this.distVerts.buffer, this.meshVerts.buffer, this.meshBones.buffer],
+        [
+          this.importantIndices.buffer,
+          /*this.refVerts.buffer,*/
+          this.distVerts.buffer,
+          this.meshVerts.buffer,
+          this.meshBones.buffer
+        ]
+      ));
+      time(`RBFDeformerPatch.solveAsync.unpack.${this.id}`);
+      this.neighborIndices = neighborIndicesBuf.map((a) => {
+        return new Uint16Array(a);
+      });
+      this.weights = weightsBuf.map((a) => {
+        return new Float32Array(a);
+      });
+      this.nearestPatch = new Uint16Array(nearestPatchBuf);
+      timeEnd(`RBFDeformerPatch.solveAsync.unpack.${this.id}`);
+    } catch (e) {
+      error(true, "RBFDeformerPatch.solveAsync() failed", e);
+    }
+    API.Misc.stopCurrentlyLoadingAssets(loadingLabel);
   }
   /**
    * solveAsync() needs to be called before this
@@ -36543,11 +36785,15 @@ class RBFDeformerPatch {
    * @returns New position after deformation
    */
   deform(i) {
-    if (!this.nearestPatch || !this.neighborIndices || !this.weights) {
-      throw new Error("RBF has not been solved");
-    }
     const vertLen = this.mesh.coreMesh.numverts;
     const vec = i < vertLen ? this.mesh.coreMesh.getPos(i) : this.mesh.skinning.bones[i - vertLen].position;
+    if (!this.nearestPatch || !this.neighborIndices || !this.weights) {
+      if (this.hasSolved) {
+        return vec;
+      } else {
+        throw new Error("RBF has not been solved");
+      }
+    }
     const idx = this.nearestPatch[i];
     const neighborIndices = this.neighborIndices[idx];
     const weights = this.weights[idx];
@@ -42261,6 +42507,50 @@ function getModelHSRDesc(model) {
     return newHSRDesc;
   }
 }
+function addTri(mesh, totalVerts, totalFaces, a, b, c, an, bn, cn, auv = [0, 0], buv = [0, 0], cuv = [0, 0]) {
+  if (!bn) bn = an;
+  if (!cn) cn = an;
+  mesh.coreMesh.setPos(totalVerts++, a);
+  mesh.coreMesh.setPos(totalVerts++, b);
+  mesh.coreMesh.setPos(totalVerts++, c);
+  totalVerts -= 3;
+  mesh.coreMesh.setNormal(totalVerts++, an);
+  mesh.coreMesh.setNormal(totalVerts++, bn);
+  mesh.coreMesh.setNormal(totalVerts++, cn);
+  totalVerts -= 3;
+  mesh.coreMesh.setUV(totalVerts++, auv);
+  mesh.coreMesh.setUV(totalVerts++, buv);
+  mesh.coreMesh.setUV(totalVerts++, cuv);
+  mesh.coreMesh.setFace(totalFaces, [totalVerts - 3, totalVerts - 2, totalVerts - 1]);
+  return totalVerts;
+}
+function addQuad(mesh, totalVerts, totalFaces, a, b, c, d, an, bn, cn, dn, auv = [0, 0], buv = [0, 0], cuv = [0, 0], duv = [0, 0]) {
+  if (!bn) bn = an;
+  if (!cn) cn = an;
+  if (!dn) dn = an;
+  totalVerts = addTri(mesh, totalVerts, totalFaces, c, b, a, cn, bn, an, cuv, buv, auv);
+  totalVerts = addTri(mesh, totalVerts, totalFaces + 1, c, a, d, cn, an, dn, cuv, auv, duv);
+  return totalVerts;
+}
+function buildCube(x, y, z) {
+  const mesh = new FileMesh();
+  mesh.coreMesh.increaseVerts(3 * 2 * 6);
+  mesh.coreMesh.increaseFaces(2 * 6);
+  let totalVerts = 0;
+  let totalFaces = 0;
+  totalVerts = addQuad(mesh, totalVerts, totalFaces, [-x, y, -z], [x, y, -z], [x, y, z], [-x, y, z], [0, 1, 0], void 0, void 0, void 0, [0, 0], [1, 0], [1, 1], [0, 1]);
+  totalFaces += 2;
+  totalVerts = addQuad(mesh, totalVerts, totalFaces, [-x, -y, z], [x, -y, z], [x, -y, -z], [-x, -y, -z], [0, -1, 0], void 0, void 0, void 0, [0, 0], [1, 0], [1, 1], [0, 1]);
+  totalFaces += 2;
+  totalVerts = addQuad(mesh, totalVerts, totalFaces, [-x, y, z], [x, y, z], [x, -y, z], [-x, -y, z], [0, 0, 1], void 0, void 0, void 0, [0, 0], [1, 0], [1, 1], [0, 1]);
+  totalFaces += 2;
+  totalVerts = addQuad(mesh, totalVerts, totalFaces, [x, y, -z], [-x, y, -z], [-x, -y, -z], [x, -y, -z], [0, 0, -1], void 0, void 0, void 0, [0, 0], [1, 0], [1, 1], [0, 1]);
+  totalFaces += 2;
+  totalVerts = addQuad(mesh, totalVerts, totalFaces, [-x, y, -z], [-x, y, z], [-x, -y, z], [-x, -y, -z], [-1, 0, 0], void 0, void 0, void 0, [0, 0], [1, 0], [1, 1], [0, 1]);
+  totalFaces += 2;
+  addQuad(mesh, totalVerts, totalFaces, [x, y, z], [x, y, -z], [x, -y, -z], [x, -y, z], [1, 0, 0], void 0, void 0, void 0, [0, 0], [1, 0], [1, 1], [0, 1]);
+  return mesh;
+}
 const HSR_CACHE = /* @__PURE__ */ new Map();
 function doHSR(totalUvToHits, targetCage, mesh, moveVerts = true, cacheStr) {
   let closestVertIndexArr = void 0;
@@ -42720,12 +43010,16 @@ class MeshDesc {
     }
   }
   async compileMesh() {
-    if (!this.mesh) return;
+    let mesh = void 0;
     const meshToLoad = this.mesh;
-    const mesh = await API.Asset.GetMesh(meshToLoad, void 0);
-    if (mesh instanceof Response) {
-      warn(true, "Failed to get mesh for compileMesh", mesh);
-      return mesh;
+    if (meshToLoad) {
+      mesh = await API.Asset.GetMesh(meshToLoad, void 0);
+      if (mesh instanceof Response) {
+        warn(true, "Failed to get mesh for compileMesh", meshToLoad, mesh);
+        return mesh;
+      }
+    } else {
+      mesh = buildCube(0.5, 0.5, 0.5);
     }
     if (!mesh.facs && this.headMesh && mesh.skinning.skinnings.length > 0) {
       const headMesh = await API.Asset.GetMesh(this.headMesh, void 0, true);
@@ -43358,6 +43652,7 @@ class TextureLayer {
 class MaterialDesc {
   layers = [];
   isDecal = false;
+  canHaveMipmaps = true;
   transparent = false;
   transparency = 0;
   doubleSided = false;
@@ -43372,7 +43667,7 @@ class MaterialDesc {
   createdTextures = [];
   isSame(other) {
     if (this.dirty || other.dirty) return false;
-    const propertiesSame = this.isDecal === other.isDecal && this.transparent === other.transparent && Math.round(this.transparency * 100) === Math.round(other.transparency * 100) && this.doubleSided === other.doubleSided && this.visible === other.visible;
+    const propertiesSame = this.isDecal === other.isDecal && this.transparent === other.transparent && Math.round(this.transparency * 100) === Math.round(other.transparency * 100) && this.doubleSided === other.doubleSided && this.visible === other.visible && this.canHaveMipmaps === other.canHaveMipmaps;
     let layersSame = true;
     if (this.layers.length !== other.layers.length) {
       layersSame = false;
@@ -43464,6 +43759,7 @@ class MaterialDesc {
     const texturesToDestroy = [];
     let noMipmaps = false;
     let hasColorLayer = false;
+    if (!this.canHaveMipmaps) noMipmaps = true;
     for (const layer of this.layers) {
       if (layer instanceof TextureLayer && layer[textureType]) {
         const layerImage = layerTextures.get(layer[textureType]);
@@ -43690,6 +43986,7 @@ class MaterialDesc {
         texture.wrapT = ogTexture.wrapT;
         texture.minFilter = ogTexture.minFilter;
         texture.magFilter = ogTexture.magFilter;
+        texture.generateMipmaps = ogTexture.generateMipmaps;
       }
     }
     if (!this.transparent) {
@@ -43721,7 +44018,7 @@ class MaterialDesc {
     texture.colorSpace = textureType === "color" ? SRGBColorSpace : NoColorSpace;
     texture.wrapS = RepeatWrapping;
     texture.wrapT = RepeatWrapping;
-    if (this.isDecal) {
+    if (this.isDecal || !this.canHaveMipmaps) {
       texture.generateMipmaps = false;
     }
     for (const layer of this.layers) {
@@ -43778,6 +44075,7 @@ class MaterialDesc {
         texture.wrapS = RepeatWrapping;
         texture.wrapT = RepeatWrapping;
         texture.colorSpace = textureType === "color" ? SRGBColorSpace : NoColorSpace;
+        texture.generateMipmaps = this.canHaveMipmaps;
         texture.needsUpdate = true;
         return [texture, hasTransparency];
       }
@@ -43872,7 +44170,7 @@ class MaterialDesc {
     if (normalTexture || roughnessTexture || metalnessTexture || emissiveTexture) {
       material = new MeshStandardMaterial({
         ...textureTemplate,
-        emissiveIntensity: hasEmissive ? this.emissiveStrength : 0,
+        emissiveIntensity: hasEmissive ? 1 / Math.sqrt(40) * Math.sqrt(this.emissiveStrength) : 0,
         emissive: hasEmissive ? new Color(this.emissiveTint.R, this.emissiveTint.G, this.emissiveTint.B) : new Color(0, 0, 0),
         transparent: hasTransparency,
         opacity: 1 - this.transparency,
@@ -44023,6 +44321,7 @@ class MaterialDesc {
               decalLayer.roughness = roughnessMap;
             }
             decalLayer.uvType = "Normal";
+            this.canHaveMipmaps = false;
             let ZIndex = 1;
             if (decal.HasProperty("ZIndex")) {
               ZIndex = decal.Prop("ZIndex");
@@ -44174,6 +44473,7 @@ class MaterialDesc {
           }
           if (child.Prop("Name") === "Head" && isAffectedByHumanoid(child)) {
             decalLayer.uvType = "Normal";
+            this.canHaveMipmaps = false;
           } else {
             decalLayer.uvType = "Decal";
             decalLayer.face = decal.Prop("Face");
@@ -44251,12 +44551,73 @@ class FaceControlsWrapper extends InstanceWrapper {
     }
   }
 }
-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 setTHREEObjectCF(threeObject, cframe) {
+  threeObject.position.set(cframe.Position[0], cframe.Position[1], cframe.Position[2]);
+  threeObject.rotation.order = "YXZ";
+  threeObject.rotation.x = rad(cframe.Orientation[0]);
+  threeObject.rotation.y = rad(cframe.Orientation[1]);
+  threeObject.rotation.z = rad(cframe.Orientation[2]);
+}
+class DisposableDesc {
+  disposeMesh(scene, mesh) {
+    disposeMesh(scene, mesh);
+  }
+  disposeMeshes(scene, meshes) {
+    for (const mesh of meshes) {
+      this.disposeMesh(scene, mesh);
+    }
+  }
+  disposeRenderLists(renderer) {
+    renderer.renderLists.dispose();
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  dispose(_renderer, _scene) {
+    throw new Error("Virtual method dispose called");
+  }
+}
+class RenderDesc extends DisposableDesc {
+  renderScene;
+  results;
+  instance;
+  constructor(renderScene) {
+    super();
+    this.renderScene = renderScene;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  isSame(_other) {
+    throw new Error("Virtual method isSame called");
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  needsRegeneration(_other) {
+    throw new Error("Virtual method needsRegeneration called");
+  }
+  fromRenderDesc(other) {
+    if (this.needsRegeneration(other)) {
+      throw new Error("These RenderableDesc objects have differences that require recompilation");
+    }
+    this.virtualFromRenderDesc(other);
+  }
+  transferFrom(other) {
+    this.virtualTransferFrom(other);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  virtualTransferFrom(_other) {
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  virtualFromRenderDesc(_other) {
+    throw new Error("Virtual method virtualFromRenderDesc called");
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  fromInstance(_child) {
+    throw new Error("Virtual method fromInstance called");
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  async compileResults(_renderer, _scene) {
+    throw new Error("Virtual method compileResults called");
+  }
+  updateResults() {
+    throw new Error("Virtual method updateResults called");
+  }
 }
 const BaseR15Bones = ["Root", "HumanoidRootNode", "LowerTorso", "UpperTorso", "RightUpperArm", "RightLowerArm", "RightHand", "LeftUpperArm", "LeftLowerArm", "LeftHand", "Head", "DynamicHead"];
 function getJointForInstances$1(parent, child, includeTransform) {
@@ -44393,14 +44754,14 @@ let SkeletonDesc$1 = class SkeletonDesc {
         } else if (threeBone.name === "DynamicHead") {
           this.originalDynamicHeadCFrame = boneCF;
         }
-        setBoneToCFrame$1(threeBone, boneCF);
+        setTHREEObjectCF(threeBone, boneCF);
         parentThreeBone.add(threeBone);
       } else {
         rootBone = threeBone;
         const boneCF = new CFrame(...bone.position);
         boneCF.fromRotationMatrix(...bone.rotationMatrix);
         this.originalBoneCFrames.push(boneCF);
-        setBoneToCFrame$1(threeBone, boneCF);
+        setTHREEObjectCF(threeBone, boneCF);
       }
     }
     if (!rootBone) {
@@ -44542,27 +44903,27 @@ let SkeletonDesc$1 = class SkeletonDesc {
         rootBoneCF = rootBoneCFog.inverse();
       }
       if (partEquivalent && parentPartEquivalent) {
-        setBoneToCFrame$1(bone, rootBoneCF.multiply(getJointForInstances$1(parentPartEquivalent, partEquivalent, includeTransform)));
+        setTHREEObjectCF(bone, rootBoneCF.multiply(getJointForInstances$1(parentPartEquivalent, partEquivalent, includeTransform)));
       } else if (partEquivalent) {
         if (includeTransform) {
-          setBoneToCFrame$1(bone, rootBoneCF.multiply(partEquivalent.Prop("CFrame")));
+          setTHREEObjectCF(bone, rootBoneCF.multiply(partEquivalent.Prop("CFrame")));
         } else {
           let hrpCF = new CFrame();
           const hrp = humanoidRootPartEquivalent;
           if (hrp) {
             hrpCF = hrp.Prop("CFrame");
           }
-          setBoneToCFrame$1(bone, rootBoneCF.multiply(hrpCF.multiply(traverseRigCFrame(partEquivalent))));
+          setTHREEObjectCF(bone, rootBoneCF.multiply(hrpCF.multiply(traverseRigCFrame(partEquivalent))));
         }
       } else if (bone.name === "Root") {
-        setBoneToCFrame$1(bone, rootBoneCF.multiply(new CFrame()));
+        setTHREEObjectCF(bone, rootBoneCF.multiply(new CFrame()));
       } else if (bone.name === "HumanoidRootNode") {
         let rootCF = new CFrame();
         const rootPart = humanoidRootPartEquivalent;
         if (rootPart) {
           rootCF = rootPart.Prop("CFrame");
         }
-        setBoneToCFrame$1(bone, rootBoneCF.multiply(rootCF));
+        setTHREEObjectCF(bone, rootBoneCF.multiply(rootCF));
       } else if (bone.name === "DynamicHead" && isHead) {
         const head = this.getPartEquivalent(selfInstance, "Head");
         if (head) {
@@ -44587,7 +44948,7 @@ let SkeletonDesc$1 = class SkeletonDesc {
             neckCF = new CFrame();
           }
           const totalCF = neckCF.inverse().multiply(scaledCF);
-          setBoneToCFrame$1(bone, totalCF);
+          setTHREEObjectCF(bone, totalCF);
         }
       } else if (!isHead || boneIsChildOf(bone, "DynamicHead")) {
         const ogCF = this.originalBoneCFrames[i];
@@ -44607,7 +44968,7 @@ let SkeletonDesc$1 = class SkeletonDesc {
             headOffset.Orientation = [0, 0, 0];
           }
           const finalCF = headOffset.multiply(scaledCF);
-          setBoneToCFrame$1(bone, finalCF);
+          setTHREEObjectCF(bone, finalCF);
         }
       }
     }
@@ -44701,7 +45062,7 @@ let SkeletonDesc$1 = class SkeletonDesc {
                 euler.reorder("YXZ");
                 resultCF.Orientation = [deg(euler.x), deg(euler.y), deg(euler.z)];
                 resultCF.Position = multiply(totalPosition.toVec3(), headScale);
-                setBoneToCFrame$1(bone, jointCF.multiply(resultCF));
+                setTHREEObjectCF(bone, jointCF.multiply(resultCF));
                 break;
               }
             }
@@ -44985,74 +45346,6 @@ class SkeletonDesc2 {
     return meshDesc.canHaveSkinning && meshDesc.fileMesh && meshDesc.fileMesh.skinning && meshDesc.fileMesh.skinning.subsets.length > 0 && meshDesc.fileMesh.skinning.skinnings.length > 0;
   }
 }
-class DisposableDesc {
-  disposeMesh(scene, mesh) {
-    disposeMesh(scene, mesh);
-  }
-  disposeMeshes(scene, meshes) {
-    for (const mesh of meshes) {
-      this.disposeMesh(scene, mesh);
-    }
-  }
-  disposeRenderLists(renderer) {
-    renderer.renderLists.dispose();
-  }
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  dispose(_renderer, _scene) {
-    throw new Error("Virtual method dispose called");
-  }
-}
-class RenderDesc extends DisposableDesc {
-  renderScene;
-  results;
-  instance;
-  constructor(renderScene) {
-    super();
-    this.renderScene = renderScene;
-  }
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  isSame(_other) {
-    throw new Error("Virtual method isSame called");
-  }
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  needsRegeneration(_other) {
-    throw new Error("Virtual method needsRegeneration called");
-  }
-  fromRenderDesc(other) {
-    if (this.needsRegeneration(other)) {
-      throw new Error("These RenderableDesc objects have differences that require recompilation");
-    }
-    this.virtualFromRenderDesc(other);
-  }
-  transferFrom(other) {
-    this.virtualTransferFrom(other);
-  }
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  virtualTransferFrom(_other) {
-  }
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  virtualFromRenderDesc(_other) {
-    throw new Error("Virtual method virtualFromRenderDesc called");
-  }
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  fromInstance(_child) {
-    throw new Error("Virtual method fromInstance called");
-  }
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  async compileResults(_renderer, _scene) {
-    throw new Error("Virtual method compileResults called");
-  }
-  updateResults() {
-    throw new Error("Virtual method updateResults called");
-  }
-}
-function setTHREEMeshCF(threeMesh, cframe) {
-  threeMesh.position.set(cframe.Position[0], cframe.Position[1], cframe.Position[2]);
-  threeMesh.rotation.order = "YXZ";
-  threeMesh.rotation.x = rad(cframe.Orientation[0]);
-  threeMesh.rotation.y = rad(cframe.Orientation[1]);
-  threeMesh.rotation.z = rad(cframe.Orientation[2]);
-}
 class ObjectDesc extends RenderDesc {
   cframe = new CFrame();
   size = new Vector32(1, 1, 1);
@@ -45108,6 +45401,7 @@ class ObjectDesc extends RenderDesc {
     if (part) {
       switch (part.className) {
         case "Part": {
+          if (!isAffectedByHumanoid(part)) this.size = part.PropOrDefault("Size", this.size);
           const specialMesh = part.FindFirstChildOfClass("SpecialMesh");
           if (specialMesh) {
             this.size = specialMesh.Property("Scale");
@@ -45164,7 +45458,8 @@ class ObjectDesc extends RenderDesc {
     }
   }
   async compileResults(renderer, scene) {
-    API.Misc.startCurrentlyLoadingAssets();
+    const loadingLabel = this.instance ? this.instance.GetFullName() : "unknown";
+    API.Misc.startCurrentlyLoadingAssets(loadingLabel);
     const originalResult = this.results;
     const originalSkeletonDesc = this.skeletonDesc;
     this.results = void 0;
@@ -45175,7 +45470,8 @@ class ObjectDesc extends RenderDesc {
     ];
     const [threeMesh, threeMaterial] = await Promise.all(promises);
     if (!(threeMesh instanceof Mesh)) {
-      API.Misc.stopCurrentlyLoadingAssets();
+      warn(true, "Failed to get mesh for objectDesc", this.instance ? this.instance.GetFullName() : "unknown");
+      API.Misc.stopCurrentlyLoadingAssets(loadingLabel);
       return threeMesh;
     }
     if (threeMesh instanceof SkinnedMesh) {
@@ -45211,7 +45507,7 @@ class ObjectDesc extends RenderDesc {
     if (originalResult) {
       this.disposeRenderLists(renderer);
     }
-    API.Misc.stopCurrentlyLoadingAssets();
+    API.Misc.stopCurrentlyLoadingAssets(loadingLabel);
     return this.results;
   }
   getScale() {
@@ -45240,7 +45536,7 @@ class ObjectDesc extends RenderDesc {
       }
       for (const result of this.results) {
         result.scale.set(...this.getScale().toVec3());
-        setTHREEMeshCF(result, resultCF);
+        setTHREEObjectCF(result, resultCF);
         result.updateMatrix();
         result.updateMatrixWorld(true);
         if (this.skeletonDesc && this.instance) {
@@ -46914,7 +47210,7 @@ class AnimatorWrapper extends InstanceWrapper {
     }
     this.data.currentAnimation = name;
     let toPlayTrack = void 0;
-    if (!name.startsWith("emote.")) {
+    if (!name.startsWith("emote.") && !name.startsWith("id.")) {
       const entries = this.data.animationSet[name];
       if (entries && entries.length > 0) {
         const entry = this._pickRandom(entries);
@@ -46922,12 +47218,15 @@ class AnimatorWrapper extends InstanceWrapper {
           toPlayTrack = this._getTrack(entry.id);
         }
       }
-    } else {
+    } else if (name.startsWith("emote.")) {
       const emoteId = BigInt(name.split(".")[1]);
       const entry = this.data.emotes.get(emoteId);
       if (entry) {
         toPlayTrack = this._getTrack(entry.id);
       }
+    } else {
+      const animId = BigInt(name.split(".")[1]);
+      toPlayTrack = this.data.animationTracks.get(animId);
     }
     if (toPlayTrack !== this.data.currentAnimationTrack) {
       if (toPlayTrack || name === "") {
@@ -47153,7 +47452,39 @@ class AnimatorWrapper extends InstanceWrapper {
     }
   }
   /**
-   * Loads a new animation
+   * Loads an animation (not to be confused with an avatar animation like those found on the catalog)
+   * @param id 
+   * @param forceLoop Forces animation track to loop
+   * @returns AnimationTrack on success
+   */
+  async loadAnimation(id, forceLoop = false) {
+    const humanoid = this.instance.parent;
+    if (!humanoid) {
+      throw new Error("Parent is missing from Animator");
+    }
+    const result = await API.Asset.GetRBX(`rbxassetid://${id}`, void 0);
+    if (result instanceof RBX) {
+      log(false, "loading anim", id);
+      const animTrackInstance = result.generateTree().GetChildren()[0];
+      if (animTrackInstance && humanoid.parent) {
+        const animTrack = new AnimationTrack().loadAnimation(humanoid.parent, animTrackInstance);
+        if (forceLoop) {
+          animTrack.looped = true;
+        }
+        if (this.data.animationTracks.get(id)) {
+          throw new Error("Animation was already loaded");
+        }
+        this.data.animationTracks.set(id, animTrack);
+        this.instance.setProperty("_HasLoadedAnimation", true);
+        return animTrack;
+      }
+    } else {
+      return result;
+    }
+    return void 0;
+  }
+  /**
+   * Loads a new avatar animation (catalog run animation or emote, not to be confused with a creator store animation)
    * @param id 
    * @param isEmote 
    * @param forceLoop Forces animation track to loop
@@ -47197,32 +47528,15 @@ class AnimatorWrapper extends InstanceWrapper {
               });
             } else {
               promises.push(new Promise((resolve) => {
-                API.Asset.GetRBX(`rbxassetid://${subAnimId}`, void 0).then((result) => {
-                  if (result instanceof RBX) {
-                    log(false, "loading anim", subAnimId);
-                    const animTrackInstance = result.generateTree().GetChildren()[0];
-                    if (animTrackInstance && humanoid.parent) {
-                      const animTrack = new AnimationTrack().loadAnimation(humanoid.parent, animTrackInstance);
-                      if (forceLoop) {
-                        animTrack.looped = true;
-                      }
-                      if (!this.data.animationSet[animName]) {
-                        this.data.animationSet[animName] = [];
-                      }
-                      this.data.animationSet[animName].push({
-                        id: `rbxassetid://${subAnimId}`,
-                        weight: subWeight
-                      });
-                      if (this.data.animationTracks.get(subAnimId)) {
-                        throw new Error("Animation was already loaded");
-                      }
-                      this.data.animationTracks.set(subAnimId, animTrack);
-                      this.instance.setProperty("_HasLoadedAnimation", true);
-                    }
-                    resolve(void 0);
-                  } else {
-                    resolve(result);
+                this.loadAnimation(subAnimId, forceLoop).then((result) => {
+                  if (!this.data.animationSet[animName]) {
+                    this.data.animationSet[animName] = [];
                   }
+                  this.data.animationSet[animName].push({
+                    id: `rbxassetid://${subAnimId}`,
+                    weight: subWeight
+                  });
+                  resolve(result instanceof Response ? result : void 0);
                 });
               }));
             }
@@ -47244,25 +47558,12 @@ class AnimatorWrapper extends InstanceWrapper {
           });
         } else {
           promises.push(new Promise((resolve) => {
-            API.Asset.GetRBX(`rbxassetid://${animId}`, void 0).then((result) => {
-              if (result instanceof RBX) {
-                const animTrackInstance = result.generateTree().GetChildren()[0];
-                if (animTrackInstance && humanoid.parent) {
-                  const animTrack = new AnimationTrack().loadAnimation(humanoid.parent, animTrackInstance);
-                  if (forceLoop) {
-                    animTrack.looped = true;
-                  }
-                  this.data.emotes.set(id, {
-                    id: `rbxassetid://${animId}`,
-                    weight: 1
-                  });
-                  this.data.animationTracks.set(animId, animTrack);
-                  this.instance.setProperty("_HasLoadedAnimation", true);
-                }
-                resolve(void 0);
-              } else {
-                resolve(result);
-              }
+            this.loadAnimation(animId, forceLoop).then((result) => {
+              this.data.emotes.set(id, {
+                id: `rbxassetid://${animId}`,
+                weight: 1
+              });
+              resolve(result instanceof Response ? result : void 0);
             });
           }));
         }
@@ -47271,7 +47572,7 @@ class AnimatorWrapper extends InstanceWrapper {
   }
   /**
    * Switches to new animation
-   * @param name Animation name, such as "idle", "walk" or "emote.1234"
+   * @param name Animation name, such as "idle", "walk", "emote.1234" or "id.1234"
    * @param type 
    * @returns If animation sucessfully played
    */
@@ -48747,10 +49048,34 @@ class HumanoidDescriptionWrapper extends InstanceWrapper {
     }
     return void 0;
   }
+  async _loadDefaultAnimation(animationProp, avatarType, animatorW, promises) {
+    const animName = AnimationPropToName[animationProp];
+    const animationSetEntries = avatarType === AvatarType.R15 ? animNamesR15[animName] : animNamesR6[animName];
+    animatorW.data.animationSet[animName] = [];
+    if (animationSetEntries) {
+      for (const subAnim of animationSetEntries) {
+        const subAnimId = BigInt(API.Misc.idFromStr(subAnim.id));
+        if (!animatorW.data.animationTracks.has(subAnimId)) {
+          promises.push(new Promise((resolve) => {
+            animatorW.loadAnimation(subAnimId, true).then((result) => {
+              if (!animatorW.data.animationSet[animName]) {
+                animatorW.data.animationSet[animName] = [];
+              }
+              animatorW.data.animationSet[animName].push(subAnim);
+              resolve(result instanceof Response ? result : void 0);
+            });
+          }));
+        } else {
+          animatorW.data.animationSet[animName].push(subAnim);
+        }
+      }
+    } else {
+      warn(false, `No default found for animation ${animName}`);
+    }
+  }
   /**
    * @returns undefined on success
    */
-  //TODO: CLEAN UP THIS CODE, the comments are not enough!
   async _applyAnimations(humanoid, toChange = AllAnimations) {
     const animator = humanoid.FindFirstChildOfClass("Animator");
     if (!animator) {
@@ -48760,7 +49085,7 @@ class HumanoidDescriptionWrapper extends InstanceWrapper {
     const animatorW = new AnimatorWrapper(animator);
     const promises = [];
     for (const animationProp of toChange) {
-      if (this.instance.HasProperty(animationProp) && this.instance.Prop(animationProp) > 0n && avatarType === AvatarType.R15) {
+      if (this.instance.PropOrDefault(animationProp, 0n) > 0n && avatarType === AvatarType.R15) {
         const id = this.instance.Prop(animationProp);
         promises.push(new Promise((resolve) => {
           animatorW.loadAvatarAnimation(id, false, true).then((result) => {
@@ -48768,35 +49093,7 @@ class HumanoidDescriptionWrapper extends InstanceWrapper {
           });
         }));
       } else {
-        const animName = AnimationPropToName[animationProp];
-        const animationSetEntries = avatarType === AvatarType.R15 ? animNamesR15[animName] : animNamesR6[animName];
-        animatorW.data.animationSet[animName] = [];
-        if (animationSetEntries) {
-          for (const subAnim of animationSetEntries) {
-            promises.push(new Promise((resolve) => {
-              API.Asset.GetRBX(subAnim.id, void 0).then((result) => {
-                if (result instanceof RBX) {
-                  const animTrackInstance = result.generateTree().GetChildren()[0];
-                  if (animTrackInstance && humanoid.parent) {
-                    const animTrack = new AnimationTrack().loadAnimation(humanoid.parent, animTrackInstance);
-                    animTrack.looped = true;
-                    animatorW.data.animationTracks.set(BigInt(API.Misc.idFromStr(subAnim.id)), animTrack);
-                    if (!animatorW.data.animationSet[animName]) {
-                      animatorW.data.animationSet[animName] = [];
-                    }
-                    animatorW.data.animationSet[animName].push(subAnim);
-                    animatorW.instance.setProperty("_HasLoadedAnimation", true);
-                  }
-                  resolve(void 0);
-                } else {
-                  resolve(result);
-                }
-              });
-            }));
-          }
-        } else {
-          warn(false, `No default found for animation ${animName}`);
-        }
+        this._loadDefaultAnimation(animationProp, avatarType, animatorW, promises);
       }
     }
     const values = await Promise.all(promises);
@@ -49067,15 +49364,21 @@ class SoundWrapperData {
 }
 class SoundWrapper extends InstanceWrapper {
   static className = "Sound";
-  static requiredProperties = ["Name", "_data"];
+  static requiredProperties = ["Name", "Looped", "Playing", "Volume", "_data"];
   setup() {
     if (!this.instance.HasProperty("Name")) this.instance.addProperty(new Property("Name", DataType.String), this.instance.className);
+    if (!this.instance.HasProperty("Looped")) this.instance.addProperty(new Property("Looped", DataType.Bool), false);
+    if (!this.instance.HasProperty("Playing")) this.instance.addProperty(new Property("Playing", DataType.Bool), false);
+    if (!this.instance.HasProperty("Volume")) this.instance.addProperty(new Property("Volume", DataType.Float32), false);
     if (!this.instance.HasProperty("_data")) this.instance.addProperty(new Property("_data", DataType.NonSerializable), new SoundWrapperData());
   }
   get data() {
     return this.instance.Prop("_data");
   }
   created() {
+    if (this.instance.Prop("Playing")) {
+      this.Play();
+    }
     this.instance.Destroying.Connect(() => {
       if (this.data.playingSource) {
         this.Stop();
@@ -49093,6 +49396,9 @@ class SoundWrapper extends InstanceWrapper {
       }
     }
   }
+  setPlaying(value) {
+    this.instance.setProperty("Playing", value);
+  }
   playSource() {
     if (!this.data.audioContext || !this.data.gainNode || !this.data.buffer) return;
     this.data.playingSource = this.data.audioContext.createBufferSource();
@@ -49101,10 +49407,18 @@ class SoundWrapper extends InstanceWrapper {
     this.data.gainNode.connect(this.data.audioContext.destination);
     this._updateVolume();
     this.data.playingSource.start(0);
+    this.data.playingSource.onended = (() => {
+      if (this.instance.Prop("Looped")) {
+        this.Play();
+      } else {
+        this.Stop();
+      }
+    });
   }
   Play() {
     if (!FLAGS.AUDIO_ENABLED) return;
     this.Stop();
+    this.setPlaying(true);
     if (!this.data.audioContext) {
       this.data.audioContext = new AudioContext();
     }
@@ -49134,6 +49448,7 @@ class SoundWrapper extends InstanceWrapper {
     }
   }
   Stop() {
+    this.setPlaying(false);
     if (this.data.playingSource) {
       this.data.playingSource.stop();
       this.data.playingSource = void 0;
@@ -49274,6 +49589,142 @@ function RegisterWrappers() {
   BodyColorsWrapper.register();
   AccessoryWrapper.register();
 }
+function disposeLight(scene, light) {
+  if (light.shadow && light.shadow.map) {
+    light.shadow.map.dispose();
+  }
+  scene.remove(light);
+}
+class LightDesc extends RenderDesc {
+  enabled = true;
+  cframe = new CFrame();
+  shadows = false;
+  color = new Color3(1, 1, 1);
+  brightness = 1;
+  range = 8;
+  lightType = "point";
+  //spot and face only
+  angle = 90;
+  face = NormalId.Front;
+  isSame(other) {
+    return this.enabled === other.enabled && this.shadows === other.shadows && this.color.isSame(other.color) && this.brightness === other.brightness && this.range === other.range && this.lightType === other.lightType && this.angle === other.angle && this.face === other.face && this.cframe.isSame(other.cframe);
+  }
+  needsRegeneration(other) {
+    return this.lightType !== other.lightType;
+  }
+  virtualFromRenderDesc(other) {
+    this.enabled = other.enabled;
+    this.shadows = other.shadows;
+    this.color = other.color.clone();
+    this.brightness = other.brightness;
+    this.range = other.range;
+    this.angle = other.angle;
+    this.face = other.face;
+    this.cframe = other.cframe.clone();
+  }
+  fromInstance(child) {
+    switch (child.className) {
+      case "PointLight":
+        this.lightType = "point";
+        break;
+      case "SpotLight":
+        this.lightType = "spot";
+        break;
+      case "SurfaceLight":
+        this.lightType = "surface";
+        break;
+    }
+    if (child.parent) {
+      if (child.parent.className === "Attachment") {
+        const attachmentW = new AttachmentWrapper(child.parent);
+        this.cframe = attachmentW.getWorldCFrame();
+      } else {
+        this.cframe = child.parent.PropOrDefault("CFrame", this.cframe).clone();
+      }
+    }
+    this.enabled = child.PropOrDefault("Enabled", this.enabled);
+    this.color = child.PropOrDefault("Color", this.color);
+    this.brightness = child.PropOrDefault("Brightness", this.brightness);
+    this.range = child.PropOrDefault("Range", this.range);
+    this.angle = child.PropOrDefault("Angle", this.angle);
+    this.face = child.PropOrDefault("Face", this.face);
+  }
+  async compileResults(_renderer, scene) {
+    if (this.results) {
+      for (const light of this.results) {
+        disposeLight(scene, light);
+      }
+    }
+    this.results = [];
+    switch (this.lightType) {
+      case "point": {
+        const pointLight = new PointLight();
+        this.results.push(
+          pointLight
+          /*, pointLightHelper*/
+        );
+        break;
+      }
+      case "spot":
+      case "surface": {
+        const spotLight = new SpotLight();
+        spotLight.add(spotLight.target);
+        this.results.push();
+        break;
+      }
+    }
+    this.updateResults();
+    return this.results;
+  }
+  updateResults() {
+    if (!this.results) return;
+    for (const light of this.results) {
+      if (light instanceof PointLight || light instanceof SpotLight) {
+        light.decay = 0.4;
+        light.visible = this.enabled;
+        light.intensity = this.brightness;
+        light.distance = this.range + 0.5;
+        light.castShadow = this.shadows;
+        light.shadow.intensity = 0.5;
+        light.color = new Color().setRGB(this.color.R, this.color.G, this.color.B);
+        const resultCF = this.cframe;
+        const targetCF = new CFrame();
+        if (light instanceof SpotLight) {
+          light.angle = rad(this.angle);
+          switch (this.face) {
+            case NormalId.Front:
+              targetCF.Position = [0, 0, -1];
+              break;
+            case NormalId.Back:
+              targetCF.Position = [0, 0, 1];
+              break;
+            case NormalId.Right:
+              targetCF.Position = [1, 0, 0];
+              break;
+            case NormalId.Left:
+              targetCF.Position = [-1, 0, 0];
+              break;
+            case NormalId.Top:
+              targetCF.Position = [0, 1, 0];
+              break;
+            case NormalId.Bottom:
+              targetCF.Position = [0, -1, 0];
+              break;
+          }
+          light.target.position.set(...targetCF.Position);
+        }
+        setTHREEObjectCF(light, resultCF);
+      }
+    }
+  }
+  dispose(_renderer, scene) {
+    if (this.results) {
+      for (const result of this.results) {
+        disposeLight(scene, result);
+      }
+    }
+  }
+}
 function disposeMesh(scene, mesh) {
   if (mesh.material) {
     const materials = Array.isArray(mesh.material) ? mesh.material : [mesh.material];
@@ -49635,8 +50086,7 @@ class RBXRenderer {
     RBXRenderer.backgroundColorHex = backgroundColorHex;
     const backgroundColor = new Color(backgroundColorHex);
     renderScene.scene.background = backgroundColor;
-    let thumbnailAmbientVal = 138;
-    thumbnailAmbientVal = 128;
+    const thumbnailAmbientVal = 128;
     let ambientLightColor = void 0;
     if (lightingType === "Thumbnail") {
       ambientLightColor = new Color(thumbnailAmbientVal / 255, thumbnailAmbientVal / 255, thumbnailAmbientVal / 255);
@@ -49647,7 +50097,7 @@ class RBXRenderer {
     renderScene.scene.add(ambientLight);
     renderScene.ambientLight = ambientLight;
     let directionalLightColor = void 0;
-    const directionalLightVal = 0.7 * 0.9 * 2 * 0.4;
+    const directionalLightVal = Math.PI;
     if (lightingType === "Thumbnail") {
       directionalLightColor = new Color(directionalLightVal, directionalLightVal, directionalLightVal);
     } else if (lightingType === "WellLit") {
@@ -49687,7 +50137,7 @@ class RBXRenderer {
       renderScene.scene.add(directionalLight2);
       renderScene.directionalLight2 = directionalLight2;
     } else if (lightingType === "Thumbnail") {
-      const directionalLight2 = new DirectionalLight(directionalLightColor, directionalLightIntensity * 0.5);
+      const directionalLight2 = new DirectionalLight(directionalLightColor, directionalLightVal * 0.1);
       directionalLight2.position.set(-0.47489210963249207 * -10, 0.8225368857383728 * -10, 0.3129066228866577 * -10);
       directionalLight2.target.position.set(0, 0, 0);
       renderScene.scene.add(directionalLight2);
@@ -49919,6 +50369,8 @@ class RBXRenderer {
       RBXRenderer._addRenderDesc(instance, auth, ObjectDesc, renderScene);
     } else if (EmitterGroupDescClassTypes.includes(instance.className)) {
       RBXRenderer._addRenderDesc(instance, auth, EmitterGroupDesc, renderScene);
+    } else if (LightDescClassTypes.includes(instance.className)) {
+      RBXRenderer._addRenderDesc(instance, auth, LightDesc, renderScene);
     }
     for (const child of instance.GetChildren()) {
       RBXRenderer.addInstance(child, auth, renderScene);
@@ -50173,8 +50625,11 @@ function getExtents(cframe, parts) {
 function getExtentsCenter(extents) {
   return extents[1].minus(extents[0]).divide(new Vector32(2, 2, 2)).add(extents[0]);
 }
-function zoomExtents(cameraCFrame, modelCFrame, modelSize, targetFOV, distanceScale) {
-  const largestSize = Math.max(modelSize.X, modelSize.Y, modelSize.Z);
+function zoomExtents(cameraCFrame, modelCFrame, modelSize, targetFOV, distanceScale, sizeType = "calculate") {
+  let largestSize = Math.max(modelSize.X, modelSize.Y, modelSize.Z);
+  if (sizeType === "calculate") {
+    largestSize = modelSize.magnitude() / 2 / Math.sin(rad(targetFOV / 2));
+  }
   const fovMultiplier = 70 / targetFOV;
   const lookDir = multiply(normalize(minus(cameraCFrame.Position, modelCFrame.Position)), [distanceScale, distanceScale, distanceScale]);
   cameraCFrame.Position = add(modelCFrame.Position, multiply(multiply(lookDir, [largestSize, largestSize, largestSize]), [fovMultiplier, fovMultiplier, fovMultiplier]));
@@ -50243,7 +50698,7 @@ function getCameraCFrameForHeadshotCustomized(rig, fov2, yRot, distance2) {
   lookCF.Position = add(headCenterCF.Position, multiply(multiply([10, 10, 10], lookVector), [fovMultiplier, fovMultiplier, fovMultiplier]));
   lookCF = CFrame.lookAt(lookCF.Position, headCenterCF.Position);
   const cameraCF = lookCF.clone();
-  zoomExtents(cameraCF, headCenterCF, headLocalExtents[1].minus(headLocalExtents[0]), fov2, distance2);
+  zoomExtents(cameraCF, headCenterCF, headLocalExtents[1].minus(headLocalExtents[0]), fov2, distance2, "largestAxis");
   return cameraCF;
 }
 function getCameraCFrameForAvatarNonCustomized(rig) {
@@ -50274,6 +50729,36 @@ function getCameraCFrameForAvatarNonCustomized(rig) {
   zoomExtents(cameraCF, rootPartCF, extentsSize, 70, 1);
   return cameraCF;
 }
+function getThumbnailCameraCFrame(model) {
+  const thumbnailCamera = model.FindFirstChildOfClass("Camera");
+  if (thumbnailCamera) return thumbnailCamera.PropOrDefault("CFrame", new CFrame());
+  let rootPart = model.PropOrDefault("PrimaryPart", void 0);
+  if (!rootPart) rootPart = model.FindFirstChildOfClass("Part");
+  if (!rootPart) rootPart = model.FindFirstChildOfClass("MeshPart");
+  if (!rootPart) return;
+  const rootPartCF = rootPart.PropOrDefault("CFrame", new CFrame()).clone();
+  const worldExtents = getRigExtentsWorld(model);
+  if (!worldExtents) return;
+  const extentsSize = worldExtents[1].minus(worldExtents[0]);
+  rootPartCF.Position = getExtentsCenter(worldExtents).toVec3();
+  let lookVector = rootPartCF.lookVector();
+  if (Math.abs(lookVector[1]) > 0.95) {
+    lookVector = [0, 0, -1];
+  } else {
+    lookVector[1] = 0;
+    lookVector = normalize(lookVector);
+  }
+  let lookCF = CFrame.lookAt([0, 0, 0], lookVector);
+  lookCF = lookCF.multiply(CFrame.fromEulerAngles(0, 0, rad(45)));
+  lookCF = lookCF.multiply(CFrame.fromEulerAngles(rad(35), 0, 0));
+  lookCF = lookCF.multiply(CFrame.fromEulerAngles(0, 0, 0));
+  lookVector = lookCF.lookVector();
+  lookCF.Position = add(rootPartCF.Position, multiply([10, 10, 10], lookVector));
+  lookCF = CFrame.lookAt(lookCF.Position, rootPartCF.Position);
+  const cameraCF = lookCF.clone();
+  zoomExtents(cameraCF, rootPartCF, extentsSize, 70, 1);
+  return cameraCF;
+}
 class OutfitRenderer {
   auth;
   outfit;
@@ -50475,7 +50960,8 @@ function renderToRenderTarget(width, height, renderScene) {
     generateMipmaps: false,
     minFilter: LinearFilter,
     magFilter: LinearFilter,
-    type: UnsignedByteType
+    type: UnsignedByteType,
+    samples: 4
   });
   const rbxRenderer = RBXRenderer.getRenderer();
   if (!rbxRenderer) return renderTarget;
@@ -50494,12 +50980,12 @@ async function renderTargetToCanvas(renderTarget) {
 }
 async function generateModelThumbnail(auth, renderScene, model, size = [150, 150], type = "png", quality = 1, gltfAutoDownload = false) {
   return new Promise((resolve) => {
-    const cameraCFrame = getCameraCFrameForAvatarNonCustomized(model);
+    const cameraCFrame = getThumbnailCameraCFrame(model);
     if (cameraCFrame) {
       RBXRenderer.setCameraCFrame(cameraCFrame, renderScene);
     }
     RBXRenderer.addInstance(model, auth, renderScene);
-    let exportTimeout = setTimeout(doExport, FLAGS.THUMBNAIL_TIMEOUT);
+    let exportTimeout = !API.Misc.getCurrentlyLoading() ? setTimeout(doExport, FLAGS.THUMBNAIL_TIMEOUT) : void 0;
     const onLoadingConnection = API.Events.OnLoadingAssets.Connect((currentlyLoading) => {
       if (exportTimeout) {
         clearTimeout(exportTimeout);
@@ -50531,12 +51017,20 @@ async function generateModelThumbnail(auth, renderScene, model, size = [150, 150
 }
 async function generateOutfitThumbnail(auth, outfit, size = [150, 150], type = "png", quality = 1, gltfAutoDownload = false) {
   return new Promise((resolve) => {
+    const startTime = performance.now();
     const renderScene = RBXRenderer.addScene();
     setupThumbnailScene(renderScene);
     const outfitRenderer = new OutfitRenderer(auth, outfit, renderScene);
     if (outfit.playerAvatarType === AvatarType.R6) outfitRenderer.deltaTimeMultiplier = 0;
     outfitRenderer.startAnimating();
-    let exportTimeout = setTimeout(doExport, FLAGS.THUMBNAIL_TIMEOUT);
+    if (!outfit.containsAssetType("Gear")) {
+      if (outfit.playerAvatarType === AvatarType.R15) {
+        outfitRenderer.setMainAnimation("pose");
+      }
+    } else {
+      outfitRenderer.setMainAnimation("toolnone");
+    }
+    let exportTimeout = !API.Misc.getCurrentlyLoading() ? setTimeout(doExport, FLAGS.THUMBNAIL_TIMEOUT) : void 0;
     const onLoadingConnection = API.Events.OnLoadingAssets.Connect((currentlyLoading) => {
       if (exportTimeout) {
         clearTimeout(exportTimeout);
@@ -50548,15 +51042,9 @@ async function generateOutfitThumbnail(auth, outfit, size = [150, 150], type = "
     });
     async function doExport() {
       onLoadingConnection.Disconnect();
-      if (!outfit.containsAssetType("Gear")) {
-        if (outfit.playerAvatarType === AvatarType.R15) {
-          outfitRenderer.setMainAnimation("pose");
-        }
-      } else {
-        outfitRenderer.setMainAnimation("toolnone");
-      }
       if (outfitRenderer.currentRig) {
         const thumbnailResult = await generateModelThumbnail(auth, renderScene, outfitRenderer.currentRig, size, type, quality, gltfAutoDownload);
+        console.log("Generated outfit thumbnail after seconds:", (performance.now() - startTime) / 1e3);
         resolve(thumbnailResult);
         outfitRenderer.stopAnimating();
         if (outfitRenderer.currentRig) outfitRenderer.currentRig.Destroy();
@@ -50570,7 +51058,7 @@ function setupThumbnailScene(renderScene) {
   renderScene.shouldAnimate = false;
   renderScene.wellLitDirectionalLightIntensity *= 2;
   renderScene.shadowEnabled = false;
-  RBXRenderer.setupScene("WellLit", 16777215, renderScene);
+  RBXRenderer.setupScene("Thumbnail", 16777215, renderScene);
   if (renderScene.plane) renderScene.scene.remove(renderScene.plane);
   if (renderScene.shadowPlane) renderScene.scene.remove(renderScene.shadowPlane);
   renderScene.scene.background = null;
@@ -50590,6 +51078,7 @@ function exposeThumbnailGenerator() {
   globalThis.generateOutfitThumbnail = generateOutfitThumbnail;
   globalThis.generateModelThumbnail = generateModelThumbnail;
   globalThis.setupThumbnailScene = setupThumbnailScene;
+  globalThis.getThumbnailCameraCFrame = getThumbnailCameraCFrame;
 }
 export {
   API,
@@ -50635,6 +51124,7 @@ export {
   BundleTypes,
   CACHE,
   CFrame,
+  COREMESH,
   CatalogBundleTypes,
   CategoryDictionary,
   Color3,
@@ -50652,10 +51142,12 @@ export {
   DefaultSearchData,
   EmitterGroupDescClassTypes,
   Event,
+  FACS,
   FLAGS,
   FaceControlNames,
   FaceControlsWrapper,
   FileMesh,
+  FileMeshBone,
   FileMeshSkinning,
   FileMeshSubset,
   FindFirstMatchingAttachment,
@@ -50663,14 +51155,17 @@ export {
   GetAttachedPart,
   GetWrapperForInstance,
   HSR,
+  HSRAVIS,
   HumanoidDescriptionWrapper,
   HumanoidRigType,
   Instance,
   InstanceWrapper,
   ItemInfo,
   ItemSort,
+  LODS,
   LayeredAssetTypes,
   LayeredClothingAssetOrder,
+  LightDescClassTypes,
   LocalOutfit,
   MakeupAssetTypes,
   MakeupDescriptionWrapper,
@@ -50705,6 +51200,7 @@ export {
   RoAvatarData,
   RoAvatarDataError,
   RoAvatarVersions,
+  SKINNING,
   Scale,
   ScaleAccessory,
   ScaleAccessoryForRig,
@@ -50736,6 +51232,8 @@ export {
   animNamesR6,
   arrayBufferToBase64,
   averageVec3,
+  awaitTimeout,
+  awaitTimeoutThrows,
   barycentric,
   base64ToArrayBuffer,
   browserOpenURL,
@@ -50775,7 +51273,6 @@ export {
   generateUUIDv4,
   getCameraCFrameForAvatarNonCustomized,
   getCameraCFrameForHeadshotCustomized,
-  getCameraOffset,
   getDistIndexArray,
   getExtents,
   getExtentsCenter,
@@ -50787,6 +51284,7 @@ export {
   getOriginalSize,
   getRandomBetweenInclusive,
   getRigExtentsWorld,
+  getThumbnailCameraCFrame,
   getUVtoIndexMap,
   getUVtoIndicesMap,
   getWorkerOnMessage,