roavatar-renderer 1.3.6 → 1.4.1

package/dist/index.js

@@ -27277,7 +27277,8 @@ const AnimationPropToName = {
   "dance1": "dance1",
   "dance2": "dance2",
   "dance3": "dance3",
-  "toolnone": "toolnone"
+  "toolnone": "toolnone",
+  "pose": "pose"
 };
 const DefaultAnimations = {
   "ClimbAnimation": ["climb", [["ClimbAnim", 507765644n]]],
@@ -27292,7 +27293,8 @@ const DefaultAnimations = {
   "dance1": ["dance1", [["2", 507772104n]]],
   "dance2": ["dance2", [["2", 507776879n]]],
   "dance3": ["dance3", [["2", 507777623n]]],
-  "toolnone": ["toolnone", [["ToolNoneAnim", 507768375n]]]
+  "toolnone": ["toolnone", [["ToolNoneAnim", 507768375n]]],
+  "pose": ["pose", [["pose", 11600209531n]]]
 };
 const DefaultAnimationsR6 = {
   "ClimbAnimation": ["climb", [["ClimbAnim", 180436334n]]],
@@ -27307,7 +27309,8 @@ const DefaultAnimationsR6 = {
   "dance1": ["dance1", [["2", 182491065n]]],
   "dance2": ["dance2", [["2", 182491277n]]],
   "dance3": ["dance3", [["2", 182491423n]]],
-  "toolnone": ["toolnone", [["ToolNoneAnim", 182393478n]]]
+  "toolnone": ["toolnone", [["ToolNoneAnim", 182393478n]]],
+  "pose": ["pose", []]
 };
 const animNamesR6 = {
   idle: [
@@ -27410,6 +27413,9 @@ const animNamesR15 = {
   ],
   mood: [
     { id: "http://www.roblox.com/asset/?id=14366558676", weight: 10 }
+  ],
+  pose: [
+    { id: "http://www.roblox.com/asset/?id=11600209531", weight: 10 }
   ]
   /*wave: [
       { id: "http://www.roblox.com/asset/?id=507770239", weight: 10 }
@@ -28490,7 +28496,7 @@ function hashVec3Safe(a, b, c) {
   a = BigInt(a);
   b = BigInt(b);
   c = BigInt(c);
-  return a * 100n + b * 10n + c * 1n;
+  return a * 10000000n + b * 1000n + c * 1n;
 }
 function calculateMagnitude3D(x, y, z) {
   return Math.sqrt(x * x + y * y + z * z);
@@ -28663,6 +28669,7 @@ function buildVertKD(mesh) {
 function inheritUV(to, from) {
   const meshCollider = new MeshCollider(to);
   const faceKD = buildFaceKD(from);
+  const edgeCountMap = from.coreMesh.getEdgeCounts();
   for (let i = 0; i < to.coreMesh.numverts; i++) {
     const pos = to.coreMesh.getPos(i);
     const closest = nearestSearch(faceKD, pos);
@@ -28671,6 +28678,7 @@ function inheritUV(to, from) {
     const va = from.coreMesh.getUV(face[0]);
     const vb = from.coreMesh.getUV(face[1]);
     const vc = from.coreMesh.getUV(face[2]);
+    let newAlpha = 255;
     const triangle = from.coreMesh.getTriangle(closestI);
     const closestPointPos = closestPointTriangle(pos, triangle);
     const barycentricPos = barycentric(closestPointPos, triangle);
@@ -28678,15 +28686,27 @@ function inheritUV(to, from) {
       barycentricPos[0] * va[0] + barycentricPos[1] * vb[0] + barycentricPos[2] * vc[0],
       barycentricPos[0] * va[1] + barycentricPos[1] * vb[1] + barycentricPos[2] * vc[1]
     ];
+    if (barycentricPos[0] <= 0.1) {
+      const edgeId = from.coreMesh.getEdgeId(face[1], face[2]);
+      const edgeCount = edgeCountMap.get(edgeId) || 999;
+      if (edgeCount <= 1) newAlpha = 0;
+    } else if (barycentricPos[1] <= 0.1) {
+      const edgeId = from.coreMesh.getEdgeId(face[0], face[2]);
+      const edgeCount = edgeCountMap.get(edgeId) || 999;
+      if (edgeCount <= 1) newAlpha = 0;
+    } else if (barycentricPos[2] <= 0.1) {
+      const edgeId = from.coreMesh.getEdgeId(face[0], face[1]);
+      const edgeCount = edgeCountMap.get(edgeId) || 999;
+      if (edgeCount <= 1) newAlpha = 0;
+    }
     const ray = new Ray$1(pos, closestPointPos);
     if (meshCollider.raycast(ray)) {
-      newUV[0] = -Infinity;
-      newUV[1] = -Infinity;
+      newAlpha = 0;
     }
     if (magnitude(minus(closestPointPos, pos)) > 0.1) {
-      newUV[0] = -Infinity;
-      newUV[1] = -Infinity;
+      newAlpha = 0;
     }
+    to.coreMesh.setColor(i, [255, 255, 255, newAlpha]);
     to.coreMesh.setUV(i, newUV);
   }
 }
@@ -29505,7 +29525,7 @@ const FLAGS = {
   //only used by linear algorithms
   LAYERED_CLOTHING_ALGORITHM: "rbf",
   SHOW_CAGE: false,
-  LAYERED_CLOTHING_COOLDOWN: 0.6,
+  LAYERED_CLOTHING_COOLDOWN: 0.25,
   GET_WORKER_FUNC: DefaultGetWorkerFunc,
   RBF_PATCH_COUNT: 300,
   //amount of "patches" that are used for layered clothing, multiple verts share the same patch
@@ -29524,6 +29544,8 @@ const FLAGS = {
   LEGACY_WELD_BEHAVIOR: false,
   USE_RENDERTARGET: true,
   AUTO_RESTORE_CONTEXT: true,
+  RENDERTARGET_TO_CANVASTEXTURE: false,
+  THUMBNAIL_TIMEOUT: 750,
   //skeleton
   SHOW_SKELETON_HELPER: false,
   UPDATE_SKELETON: true,
@@ -29608,10 +29630,19 @@ class InstanceWrapper {
     log(false, "Registered InstanceWrapper:", ClassNameToWrapper);
   }
   //virtual functions
+  /**
+   * @virtual
+   */
   created() {
   }
+  /**
+   * @virtual
+   */
   destroy() {
   }
+  /**
+   * @virtual
+   */
   preRender() {
   }
 }
@@ -29742,6 +29773,9 @@ class Color3 {
   clone() {
     return new Color3(this.R, this.G, this.B);
   }
+  isSame(other) {
+    return this.R === other.R && this.G === other.G && this.B === other.B;
+  }
   toColor3uint8() {
     return new Color3uint8(Math.round(this.R * 255), Math.round(this.G * 255), Math.round(this.B * 255));
   }
@@ -29786,6 +29820,9 @@ class NumberSequenceKeypoint {
   clone() {
     return new NumberSequenceKeypoint(this.time, this.value, this.envelope);
   }
+  isSame(other) {
+    return this.time === other.time && this.value === other.value && this.envelope === other.envelope;
+  }
 }
 class NumberSequence {
   keypoints = [];
@@ -29799,6 +29836,13 @@ class NumberSequence {
     }
     return copy;
   }
+  isSame(other) {
+    if (this.keypoints.length !== other.keypoints.length) return false;
+    for (let i = 0; i < this.keypoints.length; i++) {
+      if (!this.keypoints[i].isSame(other.keypoints[i])) return false;
+    }
+    return true;
+  }
   getLowerKey(time2) {
     let resultKey = null;
     for (const key of this.keypoints) {
@@ -29854,6 +29898,9 @@ class ColorSequenceKeypoint {
   clone() {
     return new ColorSequenceKeypoint(this.time, this.value.R, this.value.G, this.value.B);
   }
+  isSame(other) {
+    return this.time === other.time && this.value.isSame(other.value);
+  }
 }
 class ColorSequence {
   keypoints = [];
@@ -29869,6 +29916,13 @@ class ColorSequence {
     }
     return copy;
   }
+  isSame(other) {
+    if (this.keypoints.length !== other.keypoints.length) return false;
+    for (let i = 0; i < this.keypoints.length; i++) {
+      if (!this.keypoints[i].isSame(other.keypoints[i])) return false;
+    }
+    return true;
+  }
   getLowerKey(time2) {
     let resultKey = null;
     for (const key of this.keypoints) {
@@ -30056,17 +30110,23 @@ let lastInstanceId = 0;
 const AllInstances = [];
 class Instance {
   _id;
+  /**
+   * @deprecated Use .Prop("Name") instead
+   */
   _name;
   //USED TO MAKE VIEWING EASIER
   className;
+  /**
+   * @deprecated Do not use this directly
+   */
   _properties = /* @__PURE__ */ new Map();
   _referencedBy = [];
   _connectionReferences = [];
-  children = [];
+  _children = [];
   parent = void 0;
   destroyed = false;
-  hasWrappered = false;
-  canGC = true;
+  _hasWrappered = false;
+  //private _canGC: boolean = true
   classID;
   //dont use this to identify instance class, it is only used during file loading
   objectFormat;
@@ -30101,8 +30161,8 @@ class Instance {
   }
   createWrapper() {
     const wrapper = GetWrapperForInstance(this);
-    if (wrapper && !this.hasWrappered) {
-      this.hasWrappered = true;
+    if (wrapper && !this._hasWrappered) {
+      this._hasWrappered = true;
       wrapper.created();
     }
   }
@@ -30220,6 +30280,13 @@ class Instance {
     name = this.fixPropertyName(name);
     return !!this._properties.get(name);
   }
+  /**
+   * Returns the value of a property
+   * @param name Name of property
+   * @returns Property's value
+   * 
+   * @throws When property doesn't exist, PropOrDefault is a safer alternative
+   */
   Property(name) {
     let property = this._properties.get(name);
     if (property) return property.value;
@@ -30263,6 +30330,13 @@ class Instance {
       throw new Error(`Property: ${name} does not exist`);
     }
   }
+  /**
+   * Returns the value of a property
+   * @param name Name of property
+   * @returns Property's value
+   * 
+   * @throws When property doesn't exist, PropOrDefault is a safer alternative
+   */
   Prop(name) {
     return this.Property(name);
   }
@@ -30283,9 +30357,9 @@ class Instance {
       throw new Error("Cannot set parent of instance to a destroyed instance");
     }
     if (this.parent) {
-      const index = this.parent.children.indexOf(this);
+      const index = this.parent._children.indexOf(this);
       if (index !== -1) {
-        this.parent.children.splice(index, 1);
+        this.parent._children.splice(index, 1);
       }
     }
     const originalParent = this.parent;
@@ -30294,7 +30368,7 @@ class Instance {
       originalParent.ChildRemoved.Fire(this);
     }
     if (instance) {
-      instance.children.push(this);
+      instance._children.push(this);
     }
     if (fireEvents) {
       if (instance) {
@@ -30351,7 +30425,7 @@ class Instance {
   }
   GetChildren() {
     const childrenList = [];
-    for (const child of this.children) {
+    for (const child of this._children) {
       childrenList.push(child);
     }
     return childrenList;
@@ -30381,7 +30455,7 @@ class Instance {
     return this.FindFirstChild(name);
   }
   FindFirstChildOfClass(className) {
-    for (const child of this.children) {
+    for (const child of this._children) {
       if (child.className === className) {
         return child;
       }
@@ -30389,7 +30463,7 @@ class Instance {
   }
   FindLastChildOfClass(className) {
     let lastChild = void 0;
-    for (const child of this.children) {
+    for (const child of this._children) {
       if (child.className === className) {
         lastChild = child;
       }
@@ -30505,7 +30579,7 @@ class RBX {
   treeGenerated = false;
   xmlString;
   get instances() {
-    return this.dataModel.children;
+    return this.dataModel.GetChildren();
   }
   constructor() {
     this.reset();
@@ -31399,6 +31473,10 @@ class RBX {
     }
     return buffer2;
   }
+  /**
+   * Generates if needed hierarchy and returns root instance
+   * @returns Root instance
+   */
   generateTree() {
     if (this.treeGenerated) {
       warn(false, "Tree already generated");
@@ -32854,10 +32932,12 @@ class Outfit {
     return HumanoidDescription;
   }
   //TODO: Implement
+  /** @deprecated */
   async fromHumanoidDescription(rootDocument) {
     const humanoidDescription = rootDocument.querySelector(".HumanoidDescription");
     log(false, humanoidDescription);
   }
+  /** @deprecated */
   async downloadHumanoidDescription() {
     const humanoidDescription = await this.toHumanoidDescription();
     if (humanoidDescription) {
@@ -33962,6 +34042,36 @@ class COREMESH {
     }
     return touchingVerts;
   }
+  getEdgeId(v0, v1) {
+    const [x0, y0, z0] = this.getPos(v0);
+    const [x1, y1, z1] = this.getPos(v1);
+    const v0h = hashVec3Safe(Math.round(x0 * 1e3), Math.round(y0 * 1e3), Math.round(z0 * 1e3));
+    const v1h = hashVec3Safe(Math.round(x1 * 1e3), Math.round(y1 * 1e3), Math.round(z1 * 1e3));
+    const tv0 = v0h < v1h ? v0h : v1h;
+    const tv1 = v0h > v1h ? v0h : v1h;
+    return tv1 * 10000000n + tv0;
+  }
+  getFaceEdges(i) {
+    const face = this.getFace(i);
+    const edge0 = this.getEdgeId(face[0], face[1]);
+    const edge1 = this.getEdgeId(face[1], face[2]);
+    const edge2 = this.getEdgeId(face[2], face[0]);
+    return [edge0, edge1, edge2];
+  }
+  getEdgeCounts() {
+    const edgeCountMap = /* @__PURE__ */ new Map();
+    for (let i = 0; i < this.numfaces; i++) {
+      const edges = this.getFaceEdges(i);
+      for (const edge of edges) {
+        if (!edgeCountMap.has(edge)) {
+          edgeCountMap.set(edge, 1);
+        } else {
+          edgeCountMap.set(edge, edgeCountMap.get(edge) + 1);
+        }
+      }
+    }
+    return edgeCountMap;
+  }
 }
 class LODS {
   lodType = LodType.Unknown;
@@ -36096,6 +36206,15 @@ const API = {
       return await response.json();
     }
   },
+  "Subscriptions": {
+    HasPlus: async function() {
+      const response = await RBLXGet("https://apis.roblox.com/subscriptions/v2/user/subscriptions?ProductType=Blackbird&ResultsPerPage=1");
+      if (response.status !== 200) {
+        return response;
+      }
+      return (await response.json()).subscriptions.length > 0;
+    }
+  },
   "RBLXGet": RBLXGet,
   "RBLXPost": RBLXPost,
   "RBLXDelete": RBLXDelete,
@@ -42317,27 +42436,7 @@ class MeshDesc {
     }
     return true;
   }
-  async compileMesh() {
-    if (!this.mesh) {
-      return 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 (!mesh.facs && this.headMesh && mesh.skinning.skinnings.length > 0) {
-      const headMesh = await API.Asset.GetMesh(this.headMesh, void 0, true);
-      if (headMesh instanceof Response) {
-        warn(true, "Failed to get headMesh for compileMesh", headMesh);
-        return headMesh;
-      }
-      if (headMesh.facs) {
-        mesh.facs = headMesh.facs.clone();
-      }
-    }
-    let the_ref_mesh = void 0;
+  async wrapDeformer(mesh) {
     if (this.deformerDesc) {
       const meshMap = /* @__PURE__ */ new Map();
       const meshPromises = [];
@@ -42366,6 +42465,9 @@ class MeshDesc {
       await targetDeformer.solveAsync();
       targetDeformer.deformMesh();
     }
+  }
+  async wrapLayer(mesh) {
+    let the_ref_mesh = void 0;
     if (this.layerDesc && this.modelLayersDesc && this.modelLayersDesc.targetCages && this.modelLayersDesc.targetCages.length > 0 && this.modelLayersDesc.targetCFrames && this.modelLayersDesc.targetSizes && this.modelLayersDesc.layers) {
       const meshMap = /* @__PURE__ */ new Map();
       const meshPromises = [];
@@ -42503,8 +42605,11 @@ class MeshDesc {
         offsetMesh(mesh, totalOffset);
       }
       if (!FLAGS.SHOW_CAGE) the_ref_mesh = void 0;
-      if (FLAGS.HIDE_LAYERED_CLOTHING) return;
+      if (FLAGS.HIDE_LAYERED_CLOTHING) return the_ref_mesh;
     }
+    return the_ref_mesh;
+  }
+  async wrapTarget(mesh) {
     if (this.target && this.targetOrigin && this.hsrDesc) {
       const meshMap = /* @__PURE__ */ new Map();
       const meshPromises = [];
@@ -42537,6 +42642,8 @@ class MeshDesc {
         doHSR(totalUvToHits, targetCage, mesh, true, `${this.target}-${this.mesh}`);
       }
     }
+  }
+  async wrapTextureTransfer(mesh) {
     if (this.wrapTextureTarget && this.wrapTextureTargetOrigin && this.wrapTextureMinBound && this.wrapTextureMaxBound) {
       const meshMap = /* @__PURE__ */ new Map();
       const meshPromises = [];
@@ -42566,11 +42673,38 @@ class MeshDesc {
       }
       for (let i = mesh.coreMesh.numverts - 1; i >= 0; i--) {
         const vertUV = mesh.coreMesh.getUV(i);
-        if (vertUV[0] < -0.05 || vertUV[0] > 1.05 || vertUV[1] < -0.05 || vertUV[1] > 1.05) {
-          mesh.coreMesh.setUV(i, [-Infinity, -Infinity]);
+        if (vertUV[0] < 0.05 || vertUV[0] > 0.95 || vertUV[1] < 0.05 || vertUV[1] > 0.95) {
+          mesh.coreMesh.setColor(i, [255, 255, 255, 0]);
         }
       }
     }
+  }
+  async compileMesh() {
+    if (!this.mesh) return;
+    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 (!mesh.facs && this.headMesh && mesh.skinning.skinnings.length > 0) {
+      const headMesh = await API.Asset.GetMesh(this.headMesh, void 0, true);
+      if (headMesh instanceof Response) {
+        warn(true, "Failed to get headMesh for compileMesh", headMesh);
+        return headMesh;
+      }
+      if (headMesh.facs) {
+        mesh.facs = headMesh.facs.clone();
+      }
+    }
+    const wrapDeformerResult = await this.wrapDeformer(mesh);
+    if (wrapDeformerResult instanceof Response) return wrapDeformerResult;
+    const the_ref_mesh = await this.wrapLayer(mesh);
+    if (the_ref_mesh instanceof Response) return the_ref_mesh;
+    const wrapTargetResult = await this.wrapTarget(mesh);
+    if (wrapTargetResult instanceof Response) return wrapTargetResult;
+    const wrapTextureTransferResult = await this.wrapTextureTransfer(mesh);
+    if (wrapTextureTransferResult instanceof Response) return wrapTextureTransferResult;
     this.fileMesh = mesh;
     const geometry = fileMeshToTHREEGeometry(the_ref_mesh || mesh, this.canHaveSkinning, this.forceVertexColor);
     let threeMesh = void 0;
@@ -42610,6 +42744,9 @@ class MeshDesc {
         break;
       }
     }
+    if (child.className === "Decal") {
+      this.forceVertexColor = void 0;
+    }
   }
   fromPart(child) {
     this.canHaveSkinning = false;
@@ -43126,6 +43263,26 @@ function fastMask(mask, image) {
   ctx.drawImage(image, 0, 0, mask.width, mask.height);
   return canvas;
 }
+function imageDataToCanvas(data, width, height) {
+  const offscreenCanvas = new OffscreenCanvas(width, height);
+  const offscreenCtx = offscreenCanvas.getContext("2d");
+  const canvas = document.createElement("canvas");
+  const ctx = canvas.getContext("2d");
+  canvas.width = width;
+  canvas.height = height;
+  if (!ctx || !offscreenCtx) {
+    throw new Error("Failed to get CanvasContext");
+  }
+  const imgData = new ImageData(new Uint8ClampedArray(data.buffer), width, height);
+  offscreenCtx.putImageData(imgData, 0, 0);
+  ctx.translate(0, height);
+  ctx.scale(1, -1);
+  ctx.drawImage(offscreenCanvas, 0, 0);
+  return canvas;
+}
+function imageDataToCanvasTexture(data, width, height) {
+  return new CanvasTexture(imageDataToCanvas(data, width, height));
+}
 class ColorLayer {
   color;
   bodyPart;
@@ -43476,7 +43633,7 @@ class MaterialDesc {
     }
     let hasTransparency = false;
     const rbxRenderer = RBXRenderer.getRenderer();
-    if (!hasColorLayer && rbxRenderer) {
+    if (!hasColorLayer && rbxRenderer || FLAGS.RENDERTARGET_TO_CANVASTEXTURE && rbxRenderer) {
       const data = new Uint8Array(width * height * 4);
       await rbxRenderer.readRenderTargetPixelsAsync(renderTarget, 0, 0, width, height, data);
       for (let i = 3; i < data.length; i += 4) {
@@ -43485,6 +43642,15 @@ class MaterialDesc {
           break;
         }
       }
+      if (FLAGS.RENDERTARGET_TO_CANVASTEXTURE) {
+        const ogTexture = texture;
+        texture = imageDataToCanvasTexture(data, width, height);
+        texture.colorSpace = textureType === "color" ? SRGBColorSpace : NoColorSpace;
+        texture.wrapS = ogTexture.wrapS;
+        texture.wrapT = ogTexture.wrapT;
+        texture.minFilter = ogTexture.minFilter;
+        texture.magFilter = ogTexture.magFilter;
+      }
     }
     if (!this.transparent) {
       hasTransparency = false;
@@ -43537,7 +43703,7 @@ class MaterialDesc {
       }
     }
     let hasTransparency = false;
-    if (this.transparent) {
+    if (this.transparent || FLAGS.RENDERTARGET_TO_CANVASTEXTURE) {
       const imageData = ctx.getImageData(0, 0, canvas.width, canvas.height);
       const data = imageData.data;
       for (let i = 3; i < data.length; i += 4) {
@@ -43600,7 +43766,7 @@ class MaterialDesc {
     if (!hasLayerOfType) return;
     if ((hasSpecialUVType || this.bodyPart !== void 0) && FLAGS.USE_RENDERTARGET) {
       return "full";
-    } else if (this.layers.length > 1 || hasColorLayer && FLAGS.USE_RENDERTARGET) {
+    } else if ((this.layers.length > 1 || hasColorLayer) && FLAGS.USE_RENDERTARGET) {
       return "simple";
     } else {
       return "direct";
@@ -43657,13 +43823,15 @@ class MaterialDesc {
       hasTransparency = true;
     }
     let material = void 0;
+    const textureTemplate = {};
+    if (colorTexture) textureTemplate.map = colorTexture;
+    if (normalTexture) textureTemplate.normalMap = normalTexture;
+    if (roughnessTexture) textureTemplate.roughnessMap = roughnessTexture;
+    if (metalnessTexture) textureTemplate.metalnessMap = metalnessTexture;
+    if (emissiveTexture) textureTemplate.emissiveMap = emissiveTexture;
     if (normalTexture || roughnessTexture || metalnessTexture || emissiveTexture) {
       material = new MeshStandardMaterial({
-        map: colorTexture,
-        normalMap: normalTexture,
-        roughnessMap: roughnessTexture,
-        metalnessMap: metalnessTexture,
-        emissiveMap: emissiveTexture,
+        ...textureTemplate,
         emissiveIntensity: hasEmissive ? this.emissiveStrength : 0,
         emissive: hasEmissive ? new Color(this.emissiveTint.R, this.emissiveTint.G, this.emissiveTint.B) : new Color(0, 0, 0),
         transparent: hasTransparency,
@@ -43679,7 +43847,7 @@ class MaterialDesc {
       });
     } else {
       material = new MeshPhongMaterial({
-        map: colorTexture,
+        ...textureTemplate,
         specular: new Color(1 / 102, 1 / 102, 1 / 102),
         shininess: 9,
         transparent: hasTransparency,
@@ -44779,31 +44947,7 @@ class SkeletonDesc2 {
 }
 class DisposableDesc {
   disposeMesh(scene, mesh) {
-    if (mesh.material) {
-      const materials = Array.isArray(mesh.material) ? mesh.material : [mesh.material];
-      for (const material of materials) {
-        for (const key of Object.keys(material)) {
-          const value = material[key];
-          if (value instanceof Texture) {
-            value.dispose();
-          }
-        }
-        if (material instanceof ShaderMaterial) {
-          const uniforms = material.uniforms;
-          for (const key of Object.keys(uniforms)) {
-            const value = uniforms[key].value;
-            if (value instanceof Texture) {
-              value.dispose();
-            }
-          }
-        }
-        material.dispose();
-      }
-    }
-    if (mesh.geometry) {
-      mesh.geometry.dispose();
-    }
-    scene.remove(mesh);
+    disposeMesh(scene, mesh);
   }
   disposeMeshes(scene, meshes) {
     for (const mesh of meshes) {
@@ -44840,6 +44984,12 @@ class RenderDesc extends DisposableDesc {
     }
     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");
@@ -45245,7 +45395,6 @@ class EmitterDesc extends DisposableDesc {
   passedTime = 0;
   lockedToPart = false;
   lifetime = new NumberRange(1, 1);
-  rate = 10;
   spreadAngle = new Vector22(0, 0);
   speed = new NumberRange(1, 1);
   rotation = new NumberRange(0, 0);
@@ -45258,9 +45407,6 @@ class EmitterDesc extends DisposableDesc {
   zOffset = 0;
   offset = new Vector32();
   shapeInOut = 0;
-  colorTexture;
-  alphaTexture;
-  texture;
   opacity = 1;
   lightEmission = 1;
   blending = AdditiveBlending;
@@ -45268,16 +45414,52 @@ class EmitterDesc extends DisposableDesc {
   size = new NumberSequence();
   transparency = new NumberSequence([new NumberSequenceKeypoint(0, 0, 0)]);
   normalizeSizeKeypointTime = true;
+  //requires recompilation
+  rate = 10;
+  colorTexture;
+  alphaTexture;
+  texture;
+  //results
   instanceOpacityBuffer;
   instanceColorBuffer;
   instanceSeedTimeBuffer;
   result;
   particles = [];
+  initialParticleCount = 0;
   get maxCount() {
-    return Math.max(Math.ceil(this.lifetime.Max * this.rate) * 2, 1);
+    const calculatedMax = Math.max(Math.ceil(this.lifetime.Max * this.rate) * 2, 1);
+    const particleMax = this.initialParticleCount + calculatedMax;
+    return particleMax;
+  }
+  needsRegeneration(other) {
+    return this.texture === other.texture && this.alphaTexture === other.alphaTexture && this.colorTexture === other.colorTexture && this.rate === other.rate;
   }
   isSame(other) {
-    return this.lifetime.isSame(other.lifetime) && this.rate === other.rate && this.texture === other.texture;
+    return !this.needsRegeneration(other) && this.lockedToPart === other.lockedToPart && this.lifetime.isSame(other.lifetime) && this.spreadAngle.isSame(other.spreadAngle) && this.speed.isSame(other.speed) && this.rotation.isSame(other.rotation) && this.rotationSpeed.isSame(other.rotationSpeed) && this.localAcceleration.isSame(other.localAcceleration) && this.acceleration.isSame(other.acceleration) && this.drag === other.drag && this.timeScale === other.timeScale && this.orientation === other.orientation && this.zOffset === other.zOffset && this.offset.isSame(other.offset) && this.shapeInOut === other.shapeInOut && this.opacity === other.opacity && this.lightEmission === other.lightEmission && this.blending === other.blending && this.color.isSame(other.color) && this.size.isSame(other.size) && this.transparency.isSame(other.transparency) && this.normalizeSizeKeypointTime === other.normalizeSizeKeypointTime;
+  }
+  fromEmitterDesc(other) {
+    this.lockedToPart = other.lockedToPart;
+    this.lifetime = other.lifetime.clone();
+    this.rate = other.rate;
+    this.spreadAngle = other.spreadAngle.clone();
+    this.speed = other.speed.clone();
+    this.rotation = other.rotation.clone();
+    this.rotationSpeed = other.rotationSpeed.clone();
+    this.localAcceleration = other.localAcceleration.clone();
+    this.acceleration = other.acceleration.clone();
+    this.drag = other.drag;
+    this.timeScale = other.timeScale;
+    this.orientation = other.orientation;
+    this.zOffset = other.zOffset;
+    this.offset = other.offset.clone();
+    this.shapeInOut = other.shapeInOut;
+    this.opacity = other.opacity;
+    this.lightEmission = other.lightEmission;
+    this.blending = other.blending;
+    this.color = other.color.clone();
+    this.size = other.size.clone();
+    this.transparency = other.transparency.clone();
+    this.normalizeSizeKeypointTime = other.normalizeSizeKeypointTime;
   }
   dispose(renderer, scene) {
     const mesh = this.result;
@@ -45503,17 +45685,14 @@ class EmitterGroupDesc extends RenderDesc {
     if (this.needsRegeneration(other)) {
       return false;
     }
-    if (this.time !== other.time) {
-      return false;
-    }
-    return true;
+    return this.time === other.time;
   }
   needsRegeneration(other) {
     if (this.emitterDescs.length !== other.emitterDescs.length) {
       return true;
     }
     for (let i = 0; i < this.emitterDescs.length; i++) {
-      if (!this.emitterDescs[i].isSame(other.emitterDescs[i])) {
+      if (!this.emitterDescs[i].needsRegeneration(other.emitterDescs[i])) {
         return true;
       }
     }
@@ -45525,6 +45704,17 @@ class EmitterGroupDesc extends RenderDesc {
     this.lowerBound = other.lowerBound;
     this.higherBound = other.higherBound;
     this.emitterDir = other.emitterDir;
+    for (let i = 0; i < this.emitterDescs.length; i++) {
+      this.emitterDescs[i].fromEmitterDesc(other.emitterDescs[i]);
+    }
+  }
+  virtualTransferFrom(other) {
+    if (this.emitterDescs.length === other.emitterDescs.length) {
+      for (let i = 0; i < this.emitterDescs.length; i++) {
+        this.emitterDescs[i].particles = other.emitterDescs[i].particles;
+        this.emitterDescs[i].initialParticleCount = this.emitterDescs[i].particles.length;
+      }
+    }
   }
   fromInstance(child) {
     this.instance = child;
@@ -47061,6 +47251,26 @@ class AnimatorWrapper extends InstanceWrapper {
     return false;
   }
 }
+class AttachmentWrapper extends InstanceWrapper {
+  static className = "Attachment";
+  static requiredProperties = [
+    "Name",
+    "CFrame"
+  ];
+  setup() {
+    if (!this.instance.HasProperty("Name")) this.instance.addProperty(new Property("Name", DataType.String), this.instance.className);
+    if (!this.instance.HasProperty("CFrame")) this.instance.addProperty(new Property("CFrame", DataType.CFrame), new CFrame());
+  }
+  getWorldCFrame() {
+    if (this.instance.parent) {
+      if (this.instance.parent.className.includes("Part")) {
+        const parentCF = this.instance.parent.PropOrDefault("CFrame", new CFrame());
+        return parentCF.multiply(this.instance.Prop("CFrame"));
+      }
+    }
+    return this.instance.Prop("CFrame");
+  }
+}
 class BodyColorsWrapper extends InstanceWrapper {
   static className = "BodyColors";
   static requiredProperties = [
@@ -47647,6 +47857,11 @@ class HumanoidDescriptionWrapper extends InstanceWrapper {
       return void 0;
     }
   }
+  /**
+   * Update the data of the HumanoidDescription to match that inside an Outfit
+   * @param outfit 
+   * @returns HumanoidDescription or Response if it fails
+   */
   async fromOutfit(outfit) {
     this.instance.setProperty("BodyTypeScale", outfit.scale.bodyType);
     this.instance.setProperty("ProportionScale", outfit.scale.proportion);
@@ -48610,6 +48825,7 @@ class HumanoidDescriptionWrapper extends InstanceWrapper {
           toChange.push("dance2");
           toChange.push("dance3");
           toChange.push("toolnone");
+          if (this.instance.Prop("IdleAnimation") <= 0) toChange.push("pose");
         }
         miniPromises.push(this._applyAnimations(humanoid, toChange));
       }
@@ -48979,6 +49195,7 @@ function RegisterWrappers() {
   WeldWrapper.register();
   Motor6DWrapper.register();
   ManualWeldWrapper.register();
+  AttachmentWrapper.register();
   AnimationConstraintWrapper.register();
   AnimatorWrapper.register();
   FaceControlsWrapper.register();
@@ -48989,11 +49206,40 @@ function RegisterWrappers() {
   BodyColorsWrapper.register();
   AccessoryWrapper.register();
 }
+function disposeMesh(scene, mesh) {
+  if (mesh.material) {
+    const materials = Array.isArray(mesh.material) ? mesh.material : [mesh.material];
+    for (const material of materials) {
+      for (const key of Object.keys(material)) {
+        const value = material[key];
+        if (value instanceof Texture) {
+          value.dispose();
+        }
+      }
+      if (material instanceof ShaderMaterial) {
+        const uniforms = material.uniforms;
+        for (const key of Object.keys(uniforms)) {
+          const value = uniforms[key].value;
+          if (value instanceof Texture) {
+            value.dispose();
+          }
+        }
+      }
+      material.dispose();
+    }
+  }
+  if (mesh.geometry) {
+    mesh.geometry.dispose();
+  }
+  scene.remove(mesh);
+}
 class RBXRendererScene {
   //important scene components
   scene = new Scene();
   camera = new PerspectiveCamera(70, 1 / 1, 0.1, 100);
   controls;
+  shouldAnimate = true;
+  destroyed = false;
   //renderer
   effectComposer;
   //viewport
@@ -49024,14 +49270,49 @@ class RBXRendererScene {
   ambientLight;
   directionalLight;
   directionalLight2;
+  /** Forces viewport to be within bounds */
   setRect(bounds) {
     this.viewport = [bounds.left, window.innerHeight - bounds.bottom, bounds.width, bounds.height];
     this.scissor = [...this.viewport];
   }
+  /** Makes viewport size 0x0, invisible */
   noRect() {
     this.viewport = [0, 0, 0, 0];
     this.scissor = [0, 0, 0, 0];
   }
+  destroy() {
+    if (this.destroyed) return;
+    this.destroyed = true;
+    for (const instance of this.renderDescs.keys()) {
+      RBXRenderer.removeInstance(instance, this);
+    }
+    RBXRenderer.scenes.splice(RBXRenderer.scenes.indexOf(this), 1);
+    if (this.plane) {
+      disposeMesh(this.scene, this.plane);
+      this.plane = void 0;
+    }
+    if (this.shadowPlane) {
+      disposeMesh(this.scene, this.shadowPlane);
+      this.shadowPlane = void 0;
+    }
+  }
+  async exportGLTF(name = "scene", autoDownload = true) {
+    return new Promise((resolve, reject) => {
+      const exporter = new GLTFExporter();
+      exporter.parse(this.scene, (gltf) => {
+        if (autoDownload) {
+          if (gltf instanceof ArrayBuffer) {
+            saveByteArray([gltf], `${name}.glb`);
+          } else {
+            download(`${name}.gltf`, JSON.stringify(gltf));
+          }
+        }
+        resolve(gltf);
+      }, (error2) => {
+        reject(error2);
+      });
+    });
+  }
 }
 class RBXRenderer {
   static orbitControlsTarget = [0, 3, 0];
@@ -49425,6 +49706,7 @@ class RBXRenderer {
   }
   static renderScene(renderScene, autoClear = true) {
     if (!RBXRenderer.renderer) return;
+    if (!renderScene.shouldAnimate) return;
     RBXRenderer.renderer.autoClear = autoClear;
     if (!autoClear) {
       RBXRenderer.renderer.clearDepth();
@@ -49496,6 +49778,7 @@ class RBXRenderer {
       }
     } else {
       if (!renderScene.isRenderingMesh.get(instance)) {
+        if (oldDesc) newDesc.transferFrom(oldDesc);
         newDesc.results = oldDesc?.results;
         renderScene.renderDescs.set(instance, newDesc);
         renderScene.isRenderingMesh.set(instance, true);
@@ -49545,6 +49828,7 @@ class RBXRenderer {
   }
   /**Adds an instance to the renderer or updates it */
   static addInstance(instance, auth, renderScene = RBXRenderer.firstScene) {
+    if (renderScene.destroyed) return;
     const isDecal = instance.className === "Decal";
     const isBakedDecal = isDecal && !instance.FindFirstChildOfClass("WrapTextureTransfer");
     let isFirstDecal = true;
@@ -49745,14 +50029,6 @@ class HSR {
     }
   }
 }
-function exposeAPI() {
-  globalThis.API = API;
-  globalThis.APICACHE = CACHE;
-  globalThis.Authentication = Authentication;
-}
-function exposeMesh() {
-  globalThis.fileMeshToTHREEGeometry = fileMeshToTHREEGeometry;
-}
 function getCorners(cframe, size) {
   const halfX = size.X / 2;
   const halfY = size.Y / 2;
@@ -49815,12 +50091,27 @@ function getExtents(cframe, parts) {
   }
   return [lowerExtents, higherExtents];
 }
+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);
   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]));
 }
+function getCameraOffset(fov2, extentsSize) {
+  const halfSize = extentsSize.magnitude() / 2;
+  const fovDivisor = Math.tan(rad(fov2 / 2));
+  return halfSize / fovDivisor;
+}
+function zoomToExtents(cameraCFrame, modelCFrame, modelSize, fov2 = 70) {
+  const cameraOffset = getCameraOffset(fov2, modelSize);
+  const cameraRotation = new CFrame();
+  cameraRotation.Orientation = cameraCFrame.Orientation;
+  const instancePosition = modelCFrame.Position;
+  cameraCFrame.Position = add(instancePosition, multiply(minus([0, 0, 0], cameraRotation.lookVector()), [cameraOffset, cameraOffset, cameraOffset]));
+}
 function getHeadExtents(rig) {
   const head = rig.FindFirstChild("Head");
   if (!head) return;
@@ -49840,6 +50131,16 @@ function getHeadExtents(rig) {
   const extents = getExtents(head.Prop("CFrame"), headParts);
   return extents;
 }
+function getRigExtentsWorld(rig) {
+  const rigParts = [];
+  for (const child of rig.GetDescendants()) {
+    if (child.className === "Part" || child.className === "MeshPart") {
+      rigParts.push(child);
+    }
+  }
+  const extents = getExtents(new CFrame(), rigParts);
+  return extents;
+}
 function getCameraCFrameForHeadshotCustomized(rig, fov2, yRot, distance2) {
   const head = rig.FindFirstChild("Head");
   if (!head) return;
@@ -49866,6 +50167,34 @@ function getCameraCFrameForHeadshotCustomized(rig, fov2, yRot, distance2) {
   zoomExtents(cameraCF, headCenterCF, headLocalExtents[1].minus(headLocalExtents[0]), fov2, distance2);
   return cameraCF;
 }
+function getCameraCFrameForAvatarNonCustomized(rig) {
+  const thumbnailCamera = rig.FindFirstChildOfClass("Camera");
+  if (thumbnailCamera) return thumbnailCamera.PropOrDefault("CFrame", new CFrame());
+  let rootPart = rig.PropOrDefault("PrimaryPart", void 0);
+  if (!rootPart) rootPart = rig.FindFirstChildOfClass("Part");
+  if (!rootPart) rootPart = rig.FindFirstChildOfClass("MeshPart");
+  if (!rootPart) return;
+  const rootPartCF = rootPart.PropOrDefault("CFrame", new CFrame()).clone();
+  const worldExtents = getRigExtentsWorld(rig);
+  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(25 * Math.PI / 180, 27.5 * Math.PI / 180, 0, "ZXY"));
+  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;
@@ -50054,6 +50383,128 @@ class OutfitRenderer {
     }
   }
 }
+function renderToRenderTarget(width, height, renderScene) {
+  const renderTarget = new WebGLRenderTarget(width, height, {
+    colorSpace: SRGBColorSpace,
+    generateMipmaps: false,
+    minFilter: LinearFilter,
+    magFilter: LinearFilter,
+    type: UnsignedByteType
+  });
+  const rbxRenderer = RBXRenderer.getRenderer();
+  if (!rbxRenderer) return renderTarget;
+  rbxRenderer.setRenderTarget(renderTarget);
+  rbxRenderer.render(renderScene.scene, renderScene.camera);
+  return renderTarget;
+}
+async function renderTargetToCanvas(renderTarget) {
+  const rbxRenderer = RBXRenderer.getRenderer();
+  if (!rbxRenderer) return;
+  const width = renderTarget.width;
+  const height = renderTarget.height;
+  const data = new Uint8Array(width * height * 4);
+  await rbxRenderer.readRenderTargetPixelsAsync(renderTarget, 0, 0, width, height, data);
+  return imageDataToCanvas(data, width, height);
+}
+async function generateModelThumbnail(auth, renderScene, model, size = [150, 150], type = "png", quality = 1, gltfAutoDownload = false) {
+  return new Promise((resolve) => {
+    const cameraCFrame = getCameraCFrameForAvatarNonCustomized(model);
+    if (cameraCFrame) {
+      RBXRenderer.setCameraCFrame(cameraCFrame, renderScene);
+    }
+    RBXRenderer.addInstance(model, auth, renderScene);
+    let exportTimeout = setTimeout(doExport, FLAGS.THUMBNAIL_TIMEOUT);
+    const onLoadingConnection = API.Events.OnLoadingAssets.Connect((currentlyLoading) => {
+      if (exportTimeout) {
+        clearTimeout(exportTimeout);
+        exportTimeout = void 0;
+      }
+      if (!currentlyLoading) {
+        exportTimeout = setTimeout(doExport, FLAGS.THUMBNAIL_TIMEOUT);
+      }
+    });
+    async function doExport() {
+      onLoadingConnection.Disconnect();
+      if (type === "gltf") {
+        if (!FLAGS.RENDERTARGET_TO_CANVASTEXTURE && FLAGS.USE_RENDERTARGET) {
+          warn(true, "FLAGS.RENDERTARGET_TO_CANVASTEXTURE is false, GLTF export cannot export render target textures, consider setting this flag to true");
+        }
+        resolve(await renderScene.exportGLTF(`result`, gltfAutoDownload));
+      } else {
+        const renderTarget = renderToRenderTarget(...size, renderScene);
+        const canvasTarget = await renderTargetToCanvas(renderTarget);
+        if (canvasTarget) {
+          resolve(canvasTarget.toDataURL(`image/${type}`, quality));
+        } else {
+          resolve(void 0);
+        }
+      }
+      renderScene.destroy();
+    }
+  });
+}
+async function generateOutfitThumbnail(auth, outfit, size = [150, 150], type = "png", quality = 1, gltfAutoDownload = false) {
+  return new Promise((resolve) => {
+    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);
+    const onLoadingConnection = API.Events.OnLoadingAssets.Connect((currentlyLoading) => {
+      if (exportTimeout) {
+        clearTimeout(exportTimeout);
+        exportTimeout = void 0;
+      }
+      if (!currentlyLoading) {
+        exportTimeout = setTimeout(doExport, FLAGS.THUMBNAIL_TIMEOUT);
+      }
+    });
+    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);
+        resolve(thumbnailResult);
+        outfitRenderer.stopAnimating();
+        if (outfitRenderer.currentRig) outfitRenderer.currentRig.Destroy();
+      } else {
+        resolve(void 0);
+      }
+    }
+  });
+}
+function setupThumbnailScene(renderScene) {
+  renderScene.shouldAnimate = false;
+  renderScene.wellLitDirectionalLightIntensity *= 2;
+  renderScene.shadowEnabled = false;
+  RBXRenderer.setupScene("WellLit", 16777215, renderScene);
+  if (renderScene.plane) renderScene.scene.remove(renderScene.plane);
+  if (renderScene.shadowPlane) renderScene.scene.remove(renderScene.shadowPlane);
+  renderScene.scene.background = null;
+}
+function exposeAPI() {
+  globalThis.API = API;
+  globalThis.APICACHE = CACHE;
+  globalThis.Authentication = Authentication;
+}
+function exposeMesh() {
+  globalThis.fileMeshToTHREEGeometry = fileMeshToTHREEGeometry;
+}
+function exposeFLAGS() {
+  globalThis.FLAGS = FLAGS;
+}
+function exposeThumbnailGenerator() {
+  globalThis.generateOutfitThumbnail = generateOutfitThumbnail;
+  globalThis.generateModelThumbnail = generateModelThumbnail;
+  globalThis.setupThumbnailScene = setupThumbnailScene;
+}
 export {
   API,
   AbbreviationToFaceControlProperty,
@@ -50083,6 +50534,7 @@ export {
   AssetTypeToAccessoryType,
   AssetTypeToMakeupType,
   AssetTypes,
+  AttachmentWrapper,
   Authentication,
   AvatarType,
   BodyColor3s,
@@ -50120,12 +50572,15 @@ export {
   FileMesh,
   FileMeshSkinning,
   FileMeshSubset,
+  FindFirstMatchingAttachment,
   FullBodyColors,
   GetAttachedPart,
+  GetWrapperForInstance,
   HSR,
   HumanoidDescriptionWrapper,
   HumanoidRigType,
   Instance,
+  InstanceWrapper,
   ItemInfo,
   ItemSort,
   LayeredAssetTypes,
@@ -50217,24 +50672,35 @@ export {
   defaultShirtTemplateAssetIds,
   deformReferenceToBaseBodyParts,
   deg,
+  disposeMesh,
   distance,
   divide,
   dot,
   download,
   exposeAPI,
+  exposeFLAGS,
   exposeMesh,
+  exposeThumbnailGenerator,
   fileMeshToTHREEGeometry,
   floor,
   gaussian_rbf,
+  generateModelThumbnail,
+  generateOutfitThumbnail,
   generateUUIDv4,
+  getCameraCFrameForAvatarNonCustomized,
   getCameraCFrameForHeadshotCustomized,
+  getCameraOffset,
   getDistIndexArray,
   getExtents,
+  getExtentsCenter,
   getExtentsForParts,
   getHeadExtents,
   getOffsetArray,
+  getOriginalAttachmentOrientation,
+  getOriginalAttachmentPosition,
   getOriginalSize,
   getRandomBetweenInclusive,
+  getRigExtentsWorld,
   getUVtoIndexMap,
   getUVtoIndicesMap,
   getWorkerOnMessage,
@@ -50278,6 +50744,7 @@ export {
   rotationMatrixToEulerAngles,
   saveByteArray,
   scaleMesh,
+  setupThumbnailScene,
   snapToNumber,
   specialClamp,
   transferSkeleton,
@@ -50287,5 +50754,6 @@ export {
   versionToNumber,
   vertPosToChunkPos,
   xmlMagic,
-  zoomExtents
+  zoomExtents,
+  zoomToExtents
 };