roavatar-renderer 1.5.18 → 1.5.19

package/dist/index.d.ts

@@ -653,7 +653,7 @@ export declare interface AvatarModel_Result {
     avatarConfigurations: AvatarConfigurations | null;
 }
 
-export declare type AvatarModelUpdateType = "UpdateName" | "UpdateBodyColors" | "UpdateAssets" | "UpdateScales" | "UpdateBackground";
+export declare type AvatarModelUpdateType = "UpdateName" | "UpdateBodyColors" | "UpdateAssets" | "UpdateScales" | "UpdateBackground" | "UpdateAvatarType";
 
 /** @category Outfit */
 export declare type AvatarType = "R6" | "R15";
@@ -1493,9 +1493,15 @@ export declare const FLAGS: {
     ALWAYS_SHOW_ATTACHMENTS: boolean;
     /**Multiplier for delta time used by renderer things (does not affect datamodel side of things but particles and such instead) */
     RENDERER_DELTA_TIME_MULTIPLIER: number;
-    /**How many seconds particles will presimulate (mainly so they arent incomplete in thumbnail generations) */
+    /**
+     * How many seconds particles will presimulate (mainly so they arent incomplete in thumbnail generations)
+     * @deprecated This can now be set per-scene
+     * */
     PARTICLES_START_FULL: number;
-    /**Framerate of presimulation particles */
+    /**
+     * Framerate of presimulation particles
+     * @deprecated This can now be set per-scene
+     * */
     PARTICLES_START_FULL_FRAMERATE: number;
     /**shows ThreeJS SkeletonHelper */
     SHOW_SKELETON_HELPER: boolean;
@@ -1621,12 +1627,9 @@ export declare function generateOutfitModelThumbnail(auth: Authentication, outfi
  * **Example on generating 1000x1000 webp thumbnail for blank outfit**
  * ```ts
  * const outfit = new Outfit()
- * FLAGS.THUMBNAIL_TIMEOUT = 1 //makes thumbnail generation faster
- * FLAGS.PARTICLES_START_FULL = 10 //makes emitters appear as if theyve been there for some time (10 seconds)
  * FLAGS.RENDERTARGET_TO_CANVASTEXTURE = true //required for gltf export
  * const result = await generateOutfitThumbnail(new Authentication(), outfit, [1000,1000], "webp", 0.99)
  * FLAGS.RENDERTARGET_TO_CANVASTEXTURE = false
- * FLAGS.PARTICLES_START_FULL = 0
  * console.log(result)
  * ```
  */
@@ -1661,21 +1664,20 @@ export declare function getCameraCFrameForHeadshotCustomized(rig: Instance, fov:
 export declare function getDistIndexArray(ref: FileMesh, dist: FileMesh): (number | undefined)[];
 
 /**
- * @deprecated Use new Thumbnails category instead
  * @category ThumbnailGenerator */
 export declare function getExtents(cframe: CFrame, parts: Instance[]): [Vector3, Vector3];
 
 /**
- * @deprecated Use new Thumbnails category instead
  * @category ThumbnailGenerator */
 export declare function getExtentsCenter(extents: [Vector3, Vector3]): Vector3;
 
 /**
- * @deprecated Use new Thumbnails category instead
  * @category ThumbnailGenerator
  * */
 export declare function getExtentsForParts(parts: Instance[], includeTransform?: boolean): [Vector3, Vector3];
 
+export declare function getExtentsWorld(rig: Instance): [Vector3, Vector3];
+
 export declare function getHeadExtents(rig: Instance): [Vector3, Vector3] | undefined;
 
 /**@category API */
@@ -1707,8 +1709,6 @@ export declare function getPartsInAssembly_Generate(part: Instance): Instance[];
 
 export declare function getRandomBetweenInclusive(min: number, max: number, randomVal?: number): number;
 
-export declare function getRigExtentsWorld(rig: Instance): [Vector3, Vector3];
-
 export declare function getRootAssemblyPart_Generate(part: Instance): Instance;
 
 /**@category API */
@@ -1731,7 +1731,6 @@ export declare interface GetSubscription_Result {
  * Calculates the CFrame the camera should be at when generating a thumbnail
  * @param model The model-like instance to get thumbnail camera for
  * @returns Thumbnail camera cframe
- * @deprecated Use new Thumbnails category instead
  * @category ThumbnailGenerator
  */
 export declare function getThumbnailCameraCFrame(model: Instance, fov: number, forceAngle?: Vec3): CFrame | undefined;
@@ -1921,6 +1920,31 @@ export declare const HumanoidRigType: {
     R15: number;
 };
 
+/**
+ * Renders a scene to an image and returns a data url
+ * @param renderScene Scene that will be rendered
+ * @param width Width in pixels
+ * @param height Height in pixels
+ * @param format Type of image
+ * @param options
+ * @returns data url
+ *
+ * @category ThumbnailGenerator
+ */
+export declare function imageThumbnailClick(renderScene: RBXRendererScene, width: number, height: number, format: ImageThumbnailFormat, options?: Partial<ImageThumbnailOptions>): Promise<string | undefined>;
+
+/**
+ * @category ThumbnailGenerator
+ */
+export declare type ImageThumbnailFormat = "png" | "webp" | "jpeg";
+
+/**
+ * @category ThumbnailGenerator
+ */
+export declare interface ImageThumbnailOptions {
+    quality: number;
+}
+
 export declare function imageUrlToDataUrl(imageUrl: string): Promise<string>;
 
 /**
@@ -2476,6 +2500,31 @@ export declare const minimumDeltaEBodyColorDifference = 11.4;
  */
 export declare function minus(v0: Vec3, v1: Vec3): Vec3;
 
+/**
+ * Generates a 3D model from the scene
+ * @param renderScene Scene that will be rendered
+ * @param format Format of resulting model
+ * @param options
+ * @returns ArrayBuffer for glb or Object for gltf
+ *
+ * @category ThumbnailGenerator
+ */
+export declare function modelThumbnailClick(renderScene: RBXRendererScene, format: ModelThumbnailFormat, options?: Partial<ModelThumbnailOptions>): Promise<ArrayBuffer | {
+    [key: string]: unknown;
+}>;
+
+/**
+ * @category ThumbnailGenerator
+ */
+export declare type ModelThumbnailFormat = "gltf" | "glb";
+
+/**
+ * @category ThumbnailGenerator
+ */
+export declare interface ModelThumbnailOptions {
+    includeAnimations: boolean;
+}
+
 /**
  * @category InstanceWrapper
  */
@@ -2811,6 +2860,37 @@ export declare const OutfitOrigin: {
 
 /**
  * @category Renderer
+ * @example
+ * **Example on usage**
+ * ```ts
+ * const auth = new Authentication()
+ * const outfit = new Outfit()
+ * const renderScene = RBXRenderer.addScene()
+ *
+ * const outfitRenderer = new OutfitRenderer(auth, outfit, renderScene)
+ * outfitRenderer.startAnimating()
+ * outfitRenderer.setMainAnimation("anim.1234") //animation with id 1234, check documentation for other possible values
+ *
+ * outfitRenderer.onRenderSuccess.Connect(() => {
+ *     //handle Instance tree + renderDesc being successfuly
+ * })
+ * outfitRenderer.onError.Connect(() => {
+ *     //handle Instance tree error
+ * })
+ * outfitRenderer.onRenderError.Connect(() => {
+ *     //handle renderDesc error
+ * })
+ *
+ * //onRenderSuccess is fired once after some time
+ *
+ * outfitRenderer.setOutfit(new Outfit())
+ *
+ * //onRenderSuccess is fired again once after some time
+ *
+ * //when we're done rendering
+ * outfitRenderer.destroy()
+ * renderScene.destroy()
+ * ```
  */
 export declare class OutfitRenderer {
     auth: Authentication;
@@ -2820,6 +2900,7 @@ export declare class OutfitRenderer {
     doCameraUpdateOnLoad: boolean; /**Makes camera update when new avatar has loaded */
     doCameraUpdate: boolean; /**Does camera update every frame */
     doAddInstance: boolean; /**If outfitRenderer should call RBXRenderer.addInstance() */
+    forceAnimationLoop: boolean; /**If future loaded animations should be set to loop */
     currentlyChangingRig: boolean;
     currentlyUpdating: boolean;
     hasNewUpdate: boolean;
@@ -2829,14 +2910,34 @@ export declare class OutfitRenderer {
     animationFPS: number;
     deltaTimeMultiplier: number;
     renderScene: RBXRendererScene;
-    /**Event is fired if a new outfit failed to load
+    private _renderSceneCompiledConnection?;
+    private _renderSceneFailedConnection?;
+    /**Event is fired if a new outfit failed to load (specifically the Instance tree, not the rendering part)
+     *
+     * Simple: Fired when, Instance tree = fail
      * @returns OutfitRendererErrorType
      */
     onError: Event_2;
-    /**Event is fired if a new outfit successfully loaded
+    /**Event is fired if a new outfit successfully loaded (specifically the Instance tree, not the rendering part)
+     *
+     * Simple: Fired when, Instance tree = done
      * @returns void
      */
     onSuccess: Event_2;
+    /**Event is fired when all the renderDescs have been compiled, if any renderDescs fail to render this wil never be fired (can only be fired after Instance tree is done)
+     *
+     * Simple: Fired when, Instance tree = done & Rendering = done (AKA everything)
+     *
+     * NOTE: If FLAGS.LAYERED_CLOTHING_COOLDOWN > 0 (non-default), this may be fired too early and later fire again
+     * @returns void
+     */
+    onRenderSuccess: Event_2;
+    /**Event is fired if a renderDesc fails to compile, it can be fired multiple times
+     *
+     * Simple: Fired when, Rendering = fail
+     * @returns void
+     */
+    onRenderError: Event_2;
     /**
      * Creates a new OutfitRenderer which makes it easy to render outfits
      * @param auth The authentication object, you should have one you use for everything
@@ -2874,11 +2975,22 @@ export declare class OutfitRenderer {
     stopAnimating(): void;
     /**
      * Sets the current animation being played
-     * @param name The name of the animation, for example "idle", "run" or "emote.1234"
+     * @param name The name of the animation, for example "idle", "run", "emote.1234" or "anim.1234"
      * @returns If the animation started playing, it may start playing later if it has been queued despite returning false
      */
     setMainAnimation(name: string): Promise<boolean>;
-    /**Calls destroy on the rig and stops animating, the OutfitRenderer should not be interacted with after this */
+    fireFullyRenderedIfNeeded(): void;
+    /**
+     * Prepares the OutfitRenderer to be used for a thumbnail, call IMMEDIATELY after creating the OutfitRenderer
+     * @returns true on success
+     */
+    prepareForThumbnail(): Promise<boolean>;
+    private _prepareForThumbnail;
+    /**
+     * Updates rendered particles so they face the camera without simulating them (usually used when generating thumbnails)
+     */
+    updateParticleMatrix(): void;
+    /**Calls destroy on the rig, stops animating and disconnects connections. The OutfitRenderer should not be interacted with after this */
     destroy(): void;
 }
 
@@ -3261,9 +3373,15 @@ export declare class RBXRendererScene {
     effectComposer: EffectComposer | undefined;
     scissor?: [number, number, number, number];
     viewport?: [number, number, number, number];
+    addedInstances: Instance[];
     isRenderingMesh: Map<Instance, boolean>;
     renderDescs: Map<Instance, RenderDesc>;
     destroyConnections: Map<Instance, Connection>;
+    compiledRenderDesc: Event_2;
+    failedRenderDesc: Event_2;
+    forceAccurateNeedsRegeneration: boolean;
+    particlesStartFull?: number;
+    particlesStartFullFramerate: number;
     lookAwayVector: Vec3;
     lookAwayDistance: number;
     shadowEnabled: boolean;
@@ -3282,6 +3400,16 @@ export declare class RBXRendererScene {
     noRect(): void;
     /** Destroys all renderDescs but does not call Destroy on instances */
     destroy(): void;
+    /**
+     * Checks that renderDescs for provided instances are compiled, ignores instances that shouldn't be compiled or haven't been added
+     * @returns true if all provided instances's renderDescs have been compiled
+     */
+    areInstancesCompiled(instances: Instance[]): boolean;
+    /**
+     * Checks that all renderDescs are compiled
+     * @return true if all have been compiled
+     */
+    isFullyCompiled(): boolean;
     /**
      * Exports scene as a GLTF or GLB
      * @param name Name of the resulting file if autoDownload is true
@@ -3341,6 +3469,8 @@ declare class RenderDesc extends DisposableDesc {
     renderScene: RBXRendererScene;
     results?: THREE.Object3D[];
     instance?: Instance;
+    compiled: boolean;
+    failed: boolean;
     constructor(renderScene: RBXRendererScene);
     isSame(_other: RenderDesc): boolean;
     needsRegeneration(_other: RenderDesc): boolean;
@@ -3544,7 +3674,6 @@ export declare interface Search_Result {
  * Gives a scene the default appearance for thumbnails
  * @param renderScene RBXRenderScene to setup
  *
- * @deprecated Use new Thumbnails category instead
  * @category ThumbnailGenerator
  */
 export declare function setupThumbnailScene(renderScene: RBXRendererScene): void;
@@ -3925,8 +4054,6 @@ export declare const WrapLayerAutoSkin: {
 
 export declare const xmlMagic = "<roblox ";
 
-export declare function zoomExtents(cameraCFrame: CFrame, modelCFrame: CFrame, modelSize: Vector3, targetFOV: number, distanceScale: number, sizeType?: ZoomExtentsSizeType): void;
-
 /**
  * Makes model fit inside camera
  * @param cameraCFrame Original camera cframe
@@ -3936,6 +4063,8 @@ export declare function zoomExtents(cameraCFrame: CFrame, modelCFrame: CFrame, m
  * @param distanceScale Distance is multiplied by this
  * @category ThumbnailGenerator
  */
+export declare function zoomExtents(cameraCFrame: CFrame, modelCFrame: CFrame, modelSize: Vector3, targetFOV: number, distanceScale: number, sizeType?: ZoomExtentsSizeType): void;
+
 export declare type ZoomExtentsSizeType = "largestAxis" | "calculate";
 
 /**

package/dist/index.js

@@ -20,7 +20,7 @@ function cloneSearch_Payload(data) {
   }
   return newData;
 }
-const AllAvatarModelOutfitUpdateTypes = ["UpdateBodyColors", "UpdateAssets", "UpdateScales", "UpdateBackground"];
+const AllAvatarModelOutfitUpdateTypes = ["UpdateBodyColors", "UpdateAssets", "UpdateAvatarType", "UpdateScales", "UpdateBackground"];
 const BrickColors = {
   1: "#F2F3F3",
   2: "#A1A5A2",
@@ -42568,6 +42568,8 @@ class RenderDesc extends DisposableDesc {
   renderScene;
   results;
   instance;
+  compiled = false;
+  failed = false;
   constructor(renderScene) {
     super();
     this.renderScene = renderScene;
@@ -47092,8 +47094,10 @@ class ObjectDesc extends RenderDesc {
     return this.cframe.isSame(other.cframe) && this.meshDesc.isSame(other.meshDesc) && this.materialDesc.isSame(other.materialDesc) && this.isBodyPart === other.isBodyPart && this.size.isSame(other.size) && this.skeletonDesc === other.skeletonDesc;
   }
   needsRegeneration(other) {
-    if (this.meshDesc.layerDesc && Date.now() / 1e3 - this.meshDesc.compilationTimestamp < FLAGS.LAYERED_CLOTHING_COOLDOWN) {
-      return false;
+    if (!this.renderScene.forceAccurateNeedsRegeneration) {
+      if (this.meshDesc.layerDesc && Date.now() / 1e3 - this.meshDesc.compilationTimestamp < FLAGS.LAYERED_CLOTHING_COOLDOWN) {
+        return false;
+      }
     }
     return !this.meshDesc.isSame(other.meshDesc) || this.materialDesc.needsRegeneration(other.materialDesc);
   }
@@ -48643,6 +48647,7 @@ class AnimatorWrapper extends InstanceWrapper {
         }
       }
     }
+    await Promise.all(promises);
     dataModel.Destroy();
   }
   /**
@@ -51449,18 +51454,20 @@ class EmitterGroupDesc extends RenderDesc {
       this.disposeMeshes(scene, originalResults);
       this.disposeRenderLists(renderer);
     }
-    if (FLAGS.PARTICLES_START_FULL) {
+    const startFull = this.renderScene.particlesStartFull || FLAGS.PARTICLES_START_FULL;
+    const startFullFramerate = this.renderScene.particlesStartFullFramerate;
+    if (startFull) {
       for (const emitterDesc of this.emitterDescs) {
-        for (let i = 0; i < Math.min(emitterDesc.lifetime.Max * 2 * FLAGS.PARTICLES_START_FULL_FRAMERATE, FLAGS.PARTICLES_START_FULL * FLAGS.PARTICLES_START_FULL_FRAMERATE); i++) {
-          emitterDesc.tick(1 / FLAGS.PARTICLES_START_FULL_FRAMERATE, this);
+        for (let i = 0; i < Math.min(emitterDesc.lifetime.Max * 2 * startFullFramerate, startFull * startFullFramerate); i++) {
+          emitterDesc.tick(1 / startFullFramerate, this);
         }
         emitterDesc.updateResult(this.renderScene);
       }
     }
     return this.results;
   }
-  updateResults() {
-    const dt = specialClamp(this.time - this.lastTime, 0, 1 / 10) * FLAGS.RENDERER_DELTA_TIME_MULTIPLIER;
+  updateResults(forceDeltaTime) {
+    const dt = forceDeltaTime !== void 0 ? forceDeltaTime : specialClamp(this.time - this.lastTime, 0, 1 / 10) * FLAGS.RENDERER_DELTA_TIME_MULTIPLIER;
     this.lastTime = this.time;
     for (const emitterDesc of this.emitterDescs) {
       emitterDesc.tick(dt, this);
@@ -52189,9 +52196,15 @@ class RBXRendererScene {
   scissor;
   viewport;
   //renderables data
+  addedInstances = [];
   isRenderingMesh = /* @__PURE__ */ new Map();
   renderDescs = /* @__PURE__ */ new Map();
   destroyConnections = /* @__PURE__ */ new Map();
+  compiledRenderDesc = new Event();
+  failedRenderDesc = new Event();
+  forceAccurateNeedsRegeneration = false;
+  particlesStartFull = void 0;
+  particlesStartFullFramerate = FLAGS.PARTICLES_START_FULL_FRAMERATE;
   //scene appearance config
   lookAwayVector = [0.406, 0.306, -0.819];
   lookAwayDistance = 6;
@@ -52240,6 +52253,27 @@ class RBXRendererScene {
       this.shadowPlane = void 0;
     }
   }
+  /**
+   * Checks that renderDescs for provided instances are compiled, ignores instances that shouldn't be compiled or haven't been added
+   * @returns true if all provided instances's renderDescs have been compiled
+   */
+  areInstancesCompiled(instances) {
+    for (const instance of instances) {
+      if (!this.addedInstances.includes(instance)) continue;
+      const renderDesc = this.renderDescs.get(instance);
+      if (!renderDesc || !renderDesc.compiled || this.isRenderingMesh.get(instance)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  /**
+   * Checks that all renderDescs are compiled
+   * @return true if all have been compiled
+   */
+  isFullyCompiled() {
+    return this.areInstancesCompiled(this.addedInstances);
+  }
   /**
    * Exports scene as a GLTF or GLB
    * @param name Name of the resulting file if autoDownload is true
@@ -52828,12 +52862,18 @@ class RBXRenderer {
   /**Removes an instance from the renderer */
   static removeInstance(instance, renderScene = RBXRenderer.firstScene) {
     if (!RBXRenderer.renderer) return;
+    const index = renderScene.addedInstances.indexOf(instance);
+    if (index >= 0) {
+      renderScene.addedInstances[index] = renderScene.addedInstances[renderScene.addedInstances.length - 1];
+      renderScene.addedInstances.splice(renderScene.addedInstances.length - 1, 1);
+    }
     const desc = renderScene.renderDescs.get(instance);
     if (desc) {
       desc.dispose(RBXRenderer.renderer, renderScene.scene);
     }
     renderScene.renderDescs.delete(instance);
     renderScene.isRenderingMesh.delete(instance);
+    renderScene.compiledRenderDesc.Fire(instance);
     for (const child of instance.GetChildren()) {
       RBXRenderer.removeInstance(child, renderScene);
     }
@@ -52851,7 +52891,11 @@ class RBXRenderer {
     const oldDesc = renderScene.renderDescs.get(instance);
     const newDesc = new DescClass(renderScene);
     newDesc.fromInstance(instance);
-    if (oldDesc && !oldDesc.needsRegeneration(newDesc)) {
+    if (oldDesc && !oldDesc.needsRegeneration(newDesc) && !renderScene.isRenderingMesh.get(instance)) {
+      if (!oldDesc.compiled && !oldDesc.failed) {
+        oldDesc.compiled = true;
+        renderScene.compiledRenderDesc.Fire(instance);
+      }
       if (!oldDesc.isSame(newDesc)) {
         oldDesc.fromRenderDesc(newDesc);
         oldDesc.updateResults();
@@ -52892,6 +52936,9 @@ class RBXRenderer {
               newDesc.dispose(RBXRenderer.renderer, renderScene.scene);
             }
           } else {
+            newDesc.failed = true;
+            renderScene.isRenderingMesh.set(instance, false);
+            renderScene.failedRenderDesc.Fire(instance);
             warn(false, "Failed to compile mesh", this, results);
           }
         });
@@ -52911,6 +52958,7 @@ class RBXRenderer {
     if (renderScene.destroyed) return;
     const RenderDescType = getRenderDescForInstance(instance);
     if (RenderDescType) {
+      if (renderScene.addedInstances.indexOf(instance) < 0) renderScene.addedInstances.push(instance);
       RBXRenderer._addRenderDesc(instance, auth, RenderDescType, renderScene);
     }
     for (const child of instance.GetChildren()) {
@@ -53101,209 +53149,6 @@ class HSR {
     }
   }
 }
-function getCorners(cframe, size) {
-  const halfX = size.X / 2;
-  const halfY = size.Y / 2;
-  const halfZ = size.Z / 2;
-  return [
-    cframe.multiply(new CFrame(halfX, halfY, halfZ)),
-    cframe.multiply(new CFrame(halfX, halfY, -halfZ)),
-    cframe.multiply(new CFrame(-halfX, halfY, halfZ)),
-    cframe.multiply(new CFrame(-halfX, halfY, -halfZ)),
-    cframe.multiply(new CFrame(halfX, -halfY, halfZ)),
-    cframe.multiply(new CFrame(halfX, -halfY, -halfZ)),
-    cframe.multiply(new CFrame(-halfX, -halfY, halfZ)),
-    cframe.multiply(new CFrame(-halfX, -halfY, -halfZ))
-  ];
-}
-function getLower(a, b) {
-  return new Vector32(
-    a.X < b.X ? a.X : b.X,
-    a.Y < b.Y ? a.Y : b.Y,
-    a.Z < b.Z ? a.Z : b.Z
-  );
-}
-function getHigher(a, b) {
-  return new Vector32(
-    a.X > b.X ? a.X : b.X,
-    a.Y > b.Y ? a.Y : b.Y,
-    a.Z > b.Z ? a.Z : b.Z
-  );
-}
-function getExtentsForParts(parts, includeTransform) {
-  let lowerExtents = new Vector32(0, 0, 0);
-  let higherExtents = new Vector32(0, 0, 0);
-  for (const child of parts) {
-    if (child.createWrapper()?.IsA("BasePart")) {
-      const cframe = traverseRigCFrame(child, includeTransform, true);
-      const size = child.Prop("Size");
-      const corners = getCorners(cframe, size);
-      for (const corner of corners) {
-        lowerExtents = getLower(lowerExtents, new Vector32().fromVec3(corner.Position));
-        higherExtents = getHigher(higherExtents, new Vector32().fromVec3(corner.Position));
-      }
-    }
-  }
-  return [lowerExtents, higherExtents];
-}
-function getExtents(cframe, parts) {
-  const inverseCF = cframe.inverse();
-  let lowerExtents = new Vector32(0, 0, 0);
-  let higherExtents = new Vector32(0, 0, 0);
-  for (const child of parts) {
-    if (child.createWrapper()?.IsA("BasePart")) {
-      const partCF = child.Prop("CFrame");
-      const partSize = child.Prop("Size");
-      const corners = getCorners(inverseCF.multiply(partCF), partSize);
-      for (const corner of corners) {
-        lowerExtents = getLower(lowerExtents, new Vector32().fromVec3(corner.Position));
-        higherExtents = getHigher(higherExtents, new Vector32().fromVec3(corner.Position));
-      }
-    }
-  }
-  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, 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 = sizeType === "largestAxis" ? 70 / targetFOV : 1;
-  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;
-  const headParts = [];
-  for (const child of rig.GetDescendants()) {
-    if (child === head) {
-      headParts.push(head);
-    } else {
-      const weld = child.FindFirstChildOfClass("Weld");
-      if (weld && child.parent && child.parent.className === "Accessory") {
-        if (weld.Prop("Part0") === head || weld.Prop("Part1") === head) {
-          headParts.push(child);
-        }
-      }
-    }
-  }
-  const extents = getExtents(head.Prop("CFrame"), headParts);
-  return extents;
-}
-function getRigExtentsWorld(rig) {
-  const rigParts = [];
-  for (const child of rig.GetDescendants()) {
-    if (child.createWrapper()?.IsA("BasePart")) {
-      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;
-  const headCF = head.PropOrDefault("CFrame", new CFrame());
-  const headLocalExtents = getHeadExtents(rig);
-  if (!headLocalExtents) return;
-  const headCenterPosLocal = headLocalExtents[0].add(headLocalExtents[1].minus(headLocalExtents[0]).divide(new Vector32(2, 2, 2)));
-  const headCenterPos = new Vector32().fromVec3(headCF.multiply(new CFrame(...headCenterPosLocal.toVec3())).Position);
-  const headCenterCF = new CFrame(...headCenterPos.toVec3());
-  let lookVector = headCF.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, rad(yRot), 0, "ZXY"));
-  lookVector = lookCF.lookVector();
-  const fovMultiplier = 70 / fov2;
-  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, "largestAxis");
-  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;
-}
-function getThumbnailCameraCFrame(model, fov2, forceAngle) {
-  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);
-  if (!forceAngle) {
-    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));
-  } else {
-    lookCF = lookCF.multiply(CFrame.fromEulerAngles(rad(forceAngle[0]), rad(forceAngle[1]), rad(forceAngle[2])));
-  }
-  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, fov2, 1);
-  return cameraCF;
-}
 class OutfitRenderer {
   auth;
   outfit;
@@ -53316,6 +53161,8 @@ class OutfitRenderer {
   /**Does camera update every frame */
   doAddInstance = true;
   /**If outfitRenderer should call RBXRenderer.addInstance() */
+  forceAnimationLoop = true;
+  /**If future loaded animations should be set to loop */
   currentlyChangingRig = false;
   currentlyUpdating = false;
   hasNewUpdate = false;
@@ -53325,14 +53172,34 @@ class OutfitRenderer {
   animationFPS = 60;
   deltaTimeMultiplier = 1;
   renderScene = RBXRenderer.firstScene;
-  /**Event is fired if a new outfit failed to load
+  _renderSceneCompiledConnection;
+  _renderSceneFailedConnection;
+  /**Event is fired if a new outfit failed to load (specifically the Instance tree, not the rendering part)
+   * 
+   * Simple: Fired when, Instance tree = fail
    * @returns OutfitRendererErrorType
    */
   onError = new Event();
-  /**Event is fired if a new outfit successfully loaded
-  * @returns void
-  */
+  /**Event is fired if a new outfit successfully loaded (specifically the Instance tree, not the rendering part)
+   * 
+   * Simple: Fired when, Instance tree = done
+   * @returns void
+   */
   onSuccess = new Event();
+  /**Event is fired when all the renderDescs have been compiled, if any renderDescs fail to render this wil never be fired (can only be fired after Instance tree is done)
+   * 
+   * Simple: Fired when, Instance tree = done & Rendering = done (AKA everything)
+   * 
+   * NOTE: If FLAGS.LAYERED_CLOTHING_COOLDOWN > 0 (non-default), this may be fired too early and later fire again
+   * @returns void
+   */
+  onRenderSuccess = new Event();
+  /**Event is fired if a renderDesc fails to compile, it can be fired multiple times
+   * 
+   * Simple: Fired when, Rendering = fail
+   * @returns void
+   */
+  onRenderError = new Event();
   /**
    * Creates a new OutfitRenderer which makes it easy to render outfits
    * @param auth The authentication object, you should have one you use for everything
@@ -53344,6 +53211,13 @@ class OutfitRenderer {
     this.outfit = outfit;
     this.currentRigType = outfit.playerAvatarType;
     this.renderScene = renderScene;
+    this._renderSceneCompiledConnection = this.renderScene.compiledRenderDesc.Connect(() => {
+      this.fireFullyRenderedIfNeeded();
+    });
+    this._renderSceneFailedConnection = this.renderScene.failedRenderDesc.Connect(() => {
+      console.log("OutfitRenderer failed");
+      this.onRenderError.Fire();
+    });
     this._updateOutfit();
   }
   /**
@@ -53404,7 +53278,10 @@ class OutfitRenderer {
             }
             this.currentlyUpdating = false;
             if (this.currentRig) {
-              if (this.doAddInstance) RBXRenderer.addInstance(this.currentRig, this.auth, this.renderScene);
+              if (this.doAddInstance) {
+                RBXRenderer.addInstance(this.currentRig, this.auth, this.renderScene);
+                this.fireFullyRenderedIfNeeded();
+              }
               if (this.doCameraUpdateOnLoad) {
                 this.centerCamera();
               }
@@ -53479,7 +53356,7 @@ class OutfitRenderer {
       if (humanoid) {
         const animator = humanoid.FindFirstChildOfClass("Animator");
         if (animator) {
-          const deltaTime = deltaTimeOverride || (Date.now() / 1e3 - this.lastFrameTime) * this.deltaTimeMultiplier;
+          const deltaTime = deltaTimeOverride !== void 0 ? deltaTimeOverride : (Date.now() / 1e3 - this.lastFrameTime) * this.deltaTimeMultiplier;
           this.lastFrameTime = Date.now() / 1e3;
           const animatorW = new AnimatorWrapper(animator);
           animatorW.renderAnimation(deltaTime);
@@ -53500,7 +53377,7 @@ class OutfitRenderer {
   }
   /**
    * Sets the current animation being played
-   * @param name The name of the animation, for example "idle", "run" or "emote.1234"
+   * @param name The name of the animation, for example "idle", "run", "emote.1234" or "anim.1234"
    * @returns If the animation started playing, it may start playing later if it has been queued despite returning false
    */
   setMainAnimation(name) {
@@ -53514,7 +53391,12 @@ class OutfitRenderer {
             const successfullyPlayed = animatorW.playAnimation(name);
             if (!successfullyPlayed && name.startsWith("emote.") && name) {
               const emoteId = BigInt(name.split(".")[1]);
-              animatorW.loadAvatarAnimation(emoteId, true, true).then(() => {
+              animatorW.loadAvatarAnimation(emoteId, true, this.forceAnimationLoop).then(() => {
+                resolve(animatorW.playAnimation(name));
+              });
+            } else if (!successfullyPlayed && name.startsWith("id.") && name) {
+              const animId = BigInt(name.split(".")[1]);
+              animatorW.loadAnimation(animId, this.forceAnimationLoop).then(() => {
                 resolve(animatorW.playAnimation(name));
               });
             } else {
@@ -53532,13 +53414,93 @@ class OutfitRenderer {
       }
     });
   }
-  /**Calls destroy on the rig and stops animating, the OutfitRenderer should not be interacted with after this */
+  fireFullyRenderedIfNeeded() {
+    if (!this.currentlyChangingRig && !this.currentlyUpdating && !this.hasNewUpdate && this.currentRig && this.renderScene.areInstancesCompiled(this.currentRig.GetDescendants())) {
+      this.onRenderSuccess.Fire();
+    }
+  }
+  /**
+   * Prepares the OutfitRenderer to be used for a thumbnail, call IMMEDIATELY after creating the OutfitRenderer
+   * @returns true on success
+   */
+  async prepareForThumbnail() {
+    const connections = [];
+    const result = await Promise.race([
+      this._prepareForThumbnail(),
+      new Promise((resolve) => {
+        connections.push(this.onError.Connect(() => {
+          resolve(false);
+        }));
+      }),
+      new Promise((resolve) => {
+        connections.push(this.onRenderError.Connect(() => {
+          resolve(false);
+        }));
+      })
+    ]);
+    for (const connection of connections) {
+      connection.Disconnect();
+    }
+    return result;
+  }
+  async _prepareForThumbnail() {
+    this.doAddInstance = false;
+    if (this.outfit.playerAvatarType === AvatarType.R6) this.deltaTimeMultiplier = 0;
+    await new Promise((resolve) => {
+      this.onSuccess.Connect(() => {
+        if (!this.outfit.containsAssetType("Gear")) {
+          if (this.outfit.playerAvatarType === AvatarType.R15) {
+            this.setMainAnimation("pose").then(() => {
+              resolve(void 0);
+            });
+          } else {
+            this.setMainAnimation("idle").then(() => {
+              resolve(void 0);
+            });
+          }
+        } else {
+          this.setMainAnimation("toolnone").then(() => {
+            resolve(void 0);
+          });
+        }
+      });
+    });
+    this.animateOnce(!this.outfit.containsAssetType("Gear") && this.outfit.playerAvatarType === AvatarType.R6 ? 0 : 1);
+    if (this.currentRig) RBXRenderer.addInstance(this.currentRig, this.auth, this.renderScene);
+    await new Promise((resolve) => {
+      const connection = this.onRenderSuccess.Connect(() => {
+        resolve(void 0);
+        connection.Disconnect();
+      });
+    });
+    return true;
+  }
+  /**
+   * Updates rendered particles so they face the camera without simulating them (usually used when generating thumbnails)
+   */
+  updateParticleMatrix() {
+    if (!this.currentRig) return;
+    for (const instance of this.currentRig.GetDescendants()) {
+      const renderDesc = this.renderScene.renderDescs.get(instance);
+      if (renderDesc && renderDesc instanceof EmitterGroupDesc) {
+        renderDesc.updateResults(0);
+      }
+    }
+  }
+  /**Calls destroy on the rig, stops animating and disconnects connections. The OutfitRenderer should not be interacted with after this */
   destroy() {
     this.stopAnimating();
     this.currentRig?.Destroy();
+    this.currentRig = void 0;
+    this._renderSceneCompiledConnection?.Disconnect();
+    this._renderSceneFailedConnection?.Disconnect();
+    this.onError.Clear();
+    this.onSuccess.Clear();
+    this.onRenderError.Clear();
+    this.onRenderSuccess.Clear();
   }
 }
-function renderToRenderTarget(width, height, renderScene) {
+function renderToRenderTarget$1(width, height, renderScene) {
   const renderTarget = new WebGLRenderTarget(width, height, {
     colorSpace: SRGBColorSpace,
     generateMipmaps: false,
@@ -53553,7 +53515,7 @@ function renderToRenderTarget(width, height, renderScene) {
   rbxRenderer.render(renderScene.scene, renderScene.camera);
   return renderTarget;
 }
-async function renderTargetToCanvas(renderTarget) {
+async function renderTargetToCanvas$1(renderTarget) {
   const rbxRenderer = RBXRenderer.getRenderer();
   if (!rbxRenderer) return;
   const width = renderTarget.width;
@@ -53562,45 +53524,210 @@ async function renderTargetToCanvas(renderTarget) {
   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, includeAnimations = false) {
-  return new Promise((resolve) => {
-    const cameraCFrame = getThumbnailCameraCFrame(model, renderScene.camera.fov);
+async function imageThumbnailClick(renderScene, width, height, format, options) {
+  const resultOptions = {
+    quality: 1
+  };
+  if (options) Object.assign(resultOptions, options);
+  const renderTarget = renderToRenderTarget$1(width, height, renderScene);
+  const canvas = await renderTargetToCanvas$1(renderTarget);
+  renderTarget.dispose();
+  if (canvas) {
+    return canvas.toDataURL(`image/${format}`, resultOptions.quality);
+  } else {
+    return void 0;
+  }
+}
+async function modelThumbnailClick(renderScene, format, options) {
+  const resultOptions = {
+    includeAnimations: false
+  };
+  if (options) Object.assign(resultOptions, options);
+  return await renderScene.exportGLTF(`result`, false, {
+    includeAnimations: resultOptions.includeAnimations,
+    binary: format === "glb"
+  });
+}
+function getCorners(cframe, size) {
+  const halfX = size.X / 2;
+  const halfY = size.Y / 2;
+  const halfZ = size.Z / 2;
+  return [
+    cframe.multiply(new CFrame(halfX, halfY, halfZ)),
+    cframe.multiply(new CFrame(halfX, halfY, -halfZ)),
+    cframe.multiply(new CFrame(-halfX, halfY, halfZ)),
+    cframe.multiply(new CFrame(-halfX, halfY, -halfZ)),
+    cframe.multiply(new CFrame(halfX, -halfY, halfZ)),
+    cframe.multiply(new CFrame(halfX, -halfY, -halfZ)),
+    cframe.multiply(new CFrame(-halfX, -halfY, halfZ)),
+    cframe.multiply(new CFrame(-halfX, -halfY, -halfZ))
+  ];
+}
+function getLower(a, b) {
+  return new Vector32(
+    a.X < b.X ? a.X : b.X,
+    a.Y < b.Y ? a.Y : b.Y,
+    a.Z < b.Z ? a.Z : b.Z
+  );
+}
+function getHigher(a, b) {
+  return new Vector32(
+    a.X > b.X ? a.X : b.X,
+    a.Y > b.Y ? a.Y : b.Y,
+    a.Z > b.Z ? a.Z : b.Z
+  );
+}
+function getExtentsForParts(parts, includeTransform) {
+  let lowerExtents = new Vector32(0, 0, 0);
+  let higherExtents = new Vector32(0, 0, 0);
+  for (const child of parts) {
+    if (child.createWrapper()?.IsA("BasePart")) {
+      const cframe = traverseRigCFrame(child, includeTransform, true);
+      const size = child.Prop("Size");
+      const corners = getCorners(cframe, size);
+      for (const corner of corners) {
+        lowerExtents = getLower(lowerExtents, new Vector32().fromVec3(corner.Position));
+        higherExtents = getHigher(higherExtents, new Vector32().fromVec3(corner.Position));
+      }
+    }
+  }
+  return [lowerExtents, higherExtents];
+}
+function getExtents(cframe, parts) {
+  const inverseCF = cframe.inverse();
+  let lowerExtents = new Vector32(0, 0, 0);
+  let higherExtents = new Vector32(0, 0, 0);
+  for (const child of parts) {
+    if (child.createWrapper()?.IsA("BasePart")) {
+      const partCF = child.Prop("CFrame");
+      const partSize = child.Prop("Size");
+      const corners = getCorners(inverseCF.multiply(partCF), partSize);
+      for (const corner of corners) {
+        lowerExtents = getLower(lowerExtents, new Vector32().fromVec3(corner.Position));
+        higherExtents = getHigher(higherExtents, new Vector32().fromVec3(corner.Position));
+      }
+    }
+  }
+  return [lowerExtents, higherExtents];
+}
+function getExtentsWorld(rig) {
+  const rigParts = [];
+  for (const child of rig.GetDescendants()) {
+    if (child.createWrapper()?.IsA("BasePart")) {
+      rigParts.push(child);
+    }
+  }
+  const extents = getExtents(new CFrame(), rigParts);
+  return extents;
+}
+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, 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 = sizeType === "largestAxis" ? 70 / targetFOV : 1;
+  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 getThumbnailCameraCFrame(model, fov2, forceAngle) {
+  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 = getExtentsWorld(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);
+  if (!forceAngle) {
+    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));
+  } else {
+    lookCF = lookCF.multiply(CFrame.fromEulerAngles(rad(forceAngle[0]), rad(forceAngle[1]), rad(forceAngle[2])));
+  }
+  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, fov2, 1);
+  return cameraCF;
+}
+function setupThumbnailScene(renderScene) {
+  renderScene.particlesStartFull = 4;
+  renderScene.particlesStartFullFramerate = 20;
+  renderScene.forceAccurateNeedsRegeneration = true;
+  renderScene.shouldAnimate = false;
+  renderScene.wellLitDirectionalLightIntensity *= 2;
+  renderScene.shadowEnabled = false;
+  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;
+}
+async function generateOutfitThumbnail(auth, outfit, size = [150, 150], type = "png", quality = 1, gltfAutoDownload = false, includeAnimations = false, renderSceneParam) {
+  const renderScene = renderSceneParam || RBXRenderer.addScene();
+  if (renderScene !== renderSceneParam) {
+    setupThumbnailScene(renderScene);
+  }
+  const outfitRenderer = new OutfitRenderer(auth, outfit, renderScene);
+  const outfitSuccess = await outfitRenderer.prepareForThumbnail();
+  if (!outfitSuccess) {
+    outfitRenderer.destroy();
+    renderScene.destroy();
+    return void 0;
+  }
+  if (outfitRenderer.currentRig) {
+    const cameraCFrame = getThumbnailCameraCFrame(outfitRenderer.currentRig, renderScene.camera.fov);
     if (cameraCFrame) {
       RBXRenderer.setCameraCFrame(cameraCFrame, renderScene);
     }
-    RBXRenderer.addInstance(model, auth, renderScene);
-    let exportTimeout = !API.Misc.getCurrentlyLoading() ? setTimeout(doExport, FLAGS.THUMBNAIL_TIMEOUT) : void 0;
-    const onLoadingConnection = API.Events.OnLoadingAssets.Connect((currentlyLoading) => {
-      if (exportTimeout) {
-        clearTimeout(exportTimeout);
-        exportTimeout = void 0;
-      }
-      if (!currentlyLoading) {
-        exportTimeout = setTimeout(doExport, FLAGS.THUMBNAIL_TIMEOUT);
-      }
+    outfitRenderer.updateParticleMatrix();
+    const result = type === "gltf" || type === "glb" ? await modelThumbnailClick(renderScene, type, {
+      includeAnimations
+    }) : await imageThumbnailClick(renderScene, size[0], size[1], type, {
+      quality
     });
-    async function doExport() {
-      onLoadingConnection.Disconnect();
-      if (type === "gltf" || type === "glb") {
-        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, {
-          includeAnimations,
-          binary: type === "glb"
-        }));
+    if (gltfAutoDownload && (type === "gltf" || type === "glb")) {
+      if (result instanceof ArrayBuffer) {
+        saveByteArray([result], `result.glb`);
       } else {
-        const renderTarget = renderToRenderTarget(...size, renderScene);
-        const canvasTarget = await renderTargetToCanvas(renderTarget);
-        if (canvasTarget) {
-          resolve(canvasTarget.toDataURL(`image/${type}`, quality));
-        } else {
-          resolve(void 0);
-        }
+        download(`result.gltf`, JSON.stringify(result));
       }
-      renderScene.destroy();
     }
-  });
+    outfitRenderer.destroy();
+    renderScene.destroy();
+    return result;
+  } else {
+    outfitRenderer.destroy();
+    renderScene.destroy();
+    return void 0;
+  }
 }
 async function generateOutfitModelThumbnail(auth, outfitModel, options) {
   const defaultOptions = {
@@ -53643,34 +53770,37 @@ async function generateOutfitModelThumbnail(auth, outfitModel, options) {
   }
   return generateOutfitThumbnail(auth, outfitModel.outfit, defaultOptions.size, defaultOptions.type, defaultOptions.quality, defaultOptions.gltfAutoDownload, defaultOptions.includeAnimations, renderScene);
 }
-async function generateOutfitThumbnail(auth, outfit, size = [150, 150], type = "png", quality = 1, gltfAutoDownload = false, includeAnimations = false, renderSceneParam) {
+function renderToRenderTarget(width, height, renderScene) {
+  const renderTarget = new WebGLRenderTarget(width, height, {
+    colorSpace: SRGBColorSpace,
+    generateMipmaps: false,
+    minFilter: LinearFilter,
+    magFilter: LinearFilter,
+    type: UnsignedByteType,
+    samples: 4
+  });
+  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, includeAnimations = false) {
   return new Promise((resolve) => {
-    const startTime = performance.now();
-    const renderScene = renderSceneParam || RBXRenderer.addScene();
-    if (renderScene !== renderSceneParam) {
-      setupThumbnailScene(renderScene);
-    }
-    const outfitRenderer = new OutfitRenderer(auth, outfit, renderScene);
-    outfitRenderer.doAddInstance = false;
-    if (outfit.playerAvatarType === AvatarType.R6) outfitRenderer.deltaTimeMultiplier = 0;
-    API.Misc.startCurrentlyLoadingAssets("thumbnail-animation");
-    outfitRenderer.onSuccess.Connect(() => {
-      if (!outfit.containsAssetType("Gear")) {
-        if (outfit.playerAvatarType === AvatarType.R15) {
-          outfitRenderer.setMainAnimation("pose").then(() => {
-            API.Misc.stopCurrentlyLoadingAssets("thumbnail-animation");
-          });
-        } else {
-          outfitRenderer.setMainAnimation("idle").then(() => {
-            API.Misc.stopCurrentlyLoadingAssets("thumbnail-animation");
-          });
-        }
-      } else {
-        outfitRenderer.setMainAnimation("toolnone").then(() => {
-          API.Misc.stopCurrentlyLoadingAssets("thumbnail-animation");
-        });
-      }
-    });
+    const cameraCFrame = getThumbnailCameraCFrame(model, renderScene.camera.fov);
+    if (cameraCFrame) {
+      RBXRenderer.setCameraCFrame(cameraCFrame, renderScene);
+    }
+    RBXRenderer.addInstance(model, auth, renderScene);
     let exportTimeout = !API.Misc.getCurrentlyLoading() ? setTimeout(doExport, FLAGS.THUMBNAIL_TIMEOUT) : void 0;
     const onLoadingConnection = API.Events.OnLoadingAssets.Connect((currentlyLoading) => {
       if (exportTimeout) {
@@ -53683,27 +53813,27 @@ async function generateOutfitThumbnail(auth, outfit, size = [150, 150], type = "
     });
     async function doExport() {
       onLoadingConnection.Disconnect();
-      if (outfitRenderer.currentRig) {
-        outfitRenderer.animateOnce(!outfit.containsAssetType("Gear") && outfit.playerAvatarType === AvatarType.R6 ? 0 : 1);
-        const thumbnailResult = await generateModelThumbnail(auth, renderScene, outfitRenderer.currentRig, size, type, quality, gltfAutoDownload, includeAnimations);
-        console.log("Generated outfit thumbnail after seconds:", (performance.now() - startTime) / 1e3);
-        resolve(thumbnailResult);
-        if (outfitRenderer.currentRig) outfitRenderer.currentRig.Destroy();
+      if (type === "gltf" || type === "glb") {
+        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, {
+          includeAnimations,
+          binary: type === "glb"
+        }));
       } else {
-        resolve(void 0);
+        const renderTarget = renderToRenderTarget(...size, renderScene);
+        const canvasTarget = await renderTargetToCanvas(renderTarget);
+        if (canvasTarget) {
+          resolve(canvasTarget.toDataURL(`image/${type}`, quality));
+        } else {
+          resolve(void 0);
+        }
       }
+      renderScene.destroy();
     }
   });
 }
-function setupThumbnailScene(renderScene) {
-  renderScene.shouldAnimate = false;
-  renderScene.wellLitDirectionalLightIntensity *= 2;
-  renderScene.shadowEnabled = false;
-  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;
-}
 function exposeAPI() {
   globalThis.API = API;
   globalThis.APICACHE = CACHE;
@@ -53721,6 +53851,79 @@ function exposeThumbnailGenerator() {
   globalThis.setupThumbnailScene = setupThumbnailScene;
   globalThis.getThumbnailCameraCFrame = getThumbnailCameraCFrame;
 }
+function getHeadExtents(rig) {
+  const head = rig.FindFirstChild("Head");
+  if (!head) return;
+  const headParts = [];
+  for (const child of rig.GetDescendants()) {
+    if (child === head) {
+      headParts.push(head);
+    } else {
+      const weld = child.FindFirstChildOfClass("Weld");
+      if (weld && child.parent && child.parent.className === "Accessory") {
+        if (weld.Prop("Part0") === head || weld.Prop("Part1") === head) {
+          headParts.push(child);
+        }
+      }
+    }
+  }
+  const extents = getExtents(head.Prop("CFrame"), headParts);
+  return extents;
+}
+function getCameraCFrameForHeadshotCustomized(rig, fov2, yRot, distance2) {
+  const head = rig.FindFirstChild("Head");
+  if (!head) return;
+  const headCF = head.PropOrDefault("CFrame", new CFrame());
+  const headLocalExtents = getHeadExtents(rig);
+  if (!headLocalExtents) return;
+  const headCenterPosLocal = headLocalExtents[0].add(headLocalExtents[1].minus(headLocalExtents[0]).divide(new Vector32(2, 2, 2)));
+  const headCenterPos = new Vector32().fromVec3(headCF.multiply(new CFrame(...headCenterPosLocal.toVec3())).Position);
+  const headCenterCF = new CFrame(...headCenterPos.toVec3());
+  let lookVector = headCF.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, rad(yRot), 0, "ZXY"));
+  lookVector = lookCF.lookVector();
+  const fovMultiplier = 70 / fov2;
+  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, "largestAxis");
+  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 = getExtentsWorld(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;
+}
 export {
   API,
   AbbreviationToFaceControlProperty,
@@ -53931,6 +54134,7 @@ export {
   getExtents,
   getExtentsCenter,
   getExtentsForParts,
+  getExtentsWorld,
   getHeadExtents,
   getOffsetArray,
   getOriginalAttachmentOrientation,
@@ -53939,7 +54143,6 @@ export {
   getPartAssemblyScore,
   getPartsInAssembly_Generate,
   getRandomBetweenInclusive,
-  getRigExtentsWorld,
   getRootAssemblyPart_Generate,
   getThumbnailCameraCFrame,
   getUVtoIndexMap,
@@ -53952,6 +54155,7 @@ export {
   hashVec3Safe,
   hexToColor3,
   hexToRgb,
+  imageThumbnailClick,
   imageUrlToDataUrl,
   inheritSkeleton,
   inheritUV,
@@ -53972,6 +54176,7 @@ export {
   mergeTargetWithReference,
   minimumDeltaEBodyColorDifference,
   minus,
+  modelThumbnailClick,
   mount,
   mountElement,
   multiply,

package/package.json

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