roavatar-renderer 1.3.6 → 1.4.0

package/dist/index.d.ts

@@ -97,7 +97,7 @@ export declare class AnimationConstraintWrapper extends InstanceWrapper {
     setup(): void;
 }
 
-export declare type AnimationProp = "ClimbAnimation" | "FallAnimation" | "IdleAnimation" | "JumpAnimation" | "MoodAnimation" | "RunAnimation" | "SwimAnimation" | "WalkAnimation" | "dance1" | "dance2" | "dance3" | "toolnone";
+export declare type AnimationProp = "ClimbAnimation" | "FallAnimation" | "IdleAnimation" | "JumpAnimation" | "MoodAnimation" | "RunAnimation" | "SwimAnimation" | "WalkAnimation" | "dance1" | "dance2" | "dance3" | "toolnone" | "pose";
 
 export declare const AnimationPropToName: {
     [K in AnimationProp]: string;
@@ -309,6 +309,9 @@ export declare const API: {
     PremiumFeatures: {
         GetSubscription: (userId: number) => Promise<Response | GetSubscription_Result>;
     };
+    Subscriptions: {
+        HasPlus: () => Promise<Response | boolean>;
+    };
     RBLXGet: typeof RBLXGet;
     RBLXPost: typeof RBLXPost;
     RBLXDelete: typeof RBLXDelete;
@@ -418,6 +421,13 @@ export declare const AssetTypeToMakeupType: {
     EyeMakeup: number;
 };
 
+export declare class AttachmentWrapper extends InstanceWrapper {
+    static className: string;
+    static requiredProperties: string[];
+    setup(): void;
+    getWorldCFrame(): CFrame;
+}
+
 export declare class Authentication {
     TOKEN?: string;
     SessionUUID?: string;
@@ -810,6 +820,9 @@ declare class COREMESH {
     getColors(): Uint8Array;
     getIndices(): Uint16Array;
     getTouchingVerts(index: number): number[];
+    getEdgeId(v0: number, v1: number): bigint;
+    getFaceEdges(i: number): [bigint, bigint, bigint];
+    getEdgeCounts(): Map<bigint, number>;
 }
 
 export declare function createContentMap(): void;
@@ -893,6 +906,8 @@ declare class DisposableDesc {
     dispose(_renderer: THREE.WebGLRenderer, _scene: THREE.Scene): void;
 }
 
+export declare function disposeMesh(scene: THREE.Scene, mesh: THREE.Mesh): void;
+
 export declare function distance(v0: Vec3, v1: Vec3): number;
 
 export declare function divide(v0: Vec3, v1: Vec3): Vec3;
@@ -914,8 +929,12 @@ export { Event_2 as Event }
 
 export declare function exposeAPI(): void;
 
+export declare function exposeFLAGS(): void;
+
 export declare function exposeMesh(): void;
 
+export declare function exposeThumbnailGenerator(): void;
+
 export declare const FaceControlNames: string[];
 
 export declare class FaceControlsWrapper extends InstanceWrapper {
@@ -1012,6 +1031,8 @@ export declare class FileMeshSubset {
 
 export declare function fileMeshToTHREEGeometry(mesh: FileMesh, canIncludeSkinning?: boolean, forceVertexColor?: Vector3): THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>;
 
+export declare function FindFirstMatchingAttachment(attachmentName: string, rig: Instance): Instance | null;
+
 export declare const FLAGS: {
     HAIR_IS_BODYPART: boolean;
     AVATAR_JOINT_UPGRADE: boolean;
@@ -1045,6 +1066,8 @@ export declare const FLAGS: {
     LEGACY_WELD_BEHAVIOR: boolean;
     USE_RENDERTARGET: boolean;
     AUTO_RESTORE_CONTEXT: boolean;
+    RENDERTARGET_TO_CANVASTEXTURE: boolean;
+    THUMBNAIL_TIMEOUT: number;
     SHOW_SKELETON_HELPER: boolean;
     UPDATE_SKELETON: boolean;
     ANIMATE_SKELETON: boolean;
@@ -1085,16 +1108,26 @@ export declare const FullBodyColors: string[];
 
 export declare function gaussian_rbf(v0: Vec3, v1: Vec3, sigma?: number): number;
 
+export declare function generateModelThumbnail(auth: Authentication, renderScene: RBXRendererScene, model: Instance, size?: Vec2, type?: ThumbnailType, quality?: number, gltfAutoDownload?: boolean): Promise<ThumbnailResult>;
+
+export declare function generateOutfitThumbnail(auth: Authentication, outfit: Outfit, size?: Vec2, type?: ThumbnailType, quality?: number, gltfAutoDownload?: boolean): Promise<ThumbnailResult>;
+
 export declare function generateUUIDv4(): string;
 
 export declare function GetAttachedPart(accessory: Instance, rig: Instance): Instance | undefined;
 
+export declare function getCameraCFrameForAvatarNonCustomized(rig: Instance): CFrame | undefined;
+
 export declare function getCameraCFrameForHeadshotCustomized(rig: Instance, fov: number, yRot: number, distance: number): CFrame | undefined;
 
+export declare function getCameraOffset(fov: number, extentsSize: Vector3): number;
+
 export declare function getDistIndexArray(ref: FileMesh, dist: FileMesh): (number | undefined)[];
 
 export declare function getExtents(cframe: CFrame, parts: Instance[]): [Vector3, Vector3];
 
+export declare function getExtentsCenter(extents: [Vector3, Vector3]): Vector3;
+
 /**@deprecated this is SO broken */
 export declare function getExtentsForParts(parts: Instance[], includeTransform?: boolean): [Vector3, Vector3];
 
@@ -1113,10 +1146,16 @@ export declare interface GetInfoForId_Result {
 
 export declare function getOffsetArray(inner: FileMesh, outer: FileMesh): ([Vec3, THREE.Quaternion, number] | undefined)[];
 
+export declare function getOriginalAttachmentOrientation(attachment: Instance): Vector3;
+
+export declare function getOriginalAttachmentPosition(attachment: Instance): Vector3;
+
 export declare function getOriginalSize(part: Instance): Vector3;
 
 export declare function getRandomBetweenInclusive(min: number, max: number): number;
 
+export declare function getRigExtentsWorld(rig: Instance): [Vector3, Vector3];
+
 export declare interface GetSubscription_Result {
     "subscriptionProductModel": {
         "premiumFeatureId": number;
@@ -2254,6 +2293,8 @@ export declare class RBXRendererScene {
     scene: THREE.Scene;
     camera: THREE.PerspectiveCamera;
     controls: OrbitControls | undefined;
+    shouldAnimate: boolean;
+    destroyed: boolean;
     effectComposer: EffectComposer | undefined;
     scissor?: [number, number, number, number];
     viewport?: [number, number, number, number];
@@ -2274,6 +2315,10 @@ export declare class RBXRendererScene {
     directionalLight2?: THREE.DirectionalLight;
     setRect(bounds: DOMRect): void;
     noRect(): void;
+    destroy(): void;
+    exportGLTF(name?: string, autoDownload?: boolean): Promise<ArrayBuffer | {
+        [key: string]: unknown;
+    }>;
 }
 
 declare class RBXSimpleView {
@@ -2503,6 +2548,8 @@ export declare interface Search_Result {
     }[];
 }
 
+export declare function setupThumbnailScene(renderScene: RBXRendererScene): void;
+
 declare class SimpleView {
     view: DataView;
     viewOffset: number;
@@ -2606,6 +2653,10 @@ export declare interface ThumbnailCustomizations_Result {
     }[];
 }
 
+export declare type ThumbnailResult = ArrayBuffer | {
+    [key: string]: unknown;
+} | string | undefined;
+
 export declare interface ThumbnailsCustomization_Payload {
     thumbnailType: number;
     emoteAssetId: number;
@@ -2616,6 +2667,8 @@ export declare interface ThumbnailsCustomization_Payload {
     };
 }
 
+export declare type ThumbnailType = "png" | "webp" | "gltf";
+
 export declare class ToolWrapper extends InstanceWrapper {
     static className: string;
     static requiredProperties: string[];
@@ -2803,4 +2856,6 @@ export declare const xmlMagic = "<roblox ";
 
 export declare function zoomExtents(cameraCFrame: CFrame, modelCFrame: CFrame, modelSize: Vector3, targetFOV: number, distanceScale: number): void;
 
+export declare function zoomToExtents(cameraCFrame: CFrame, modelCFrame: CFrame, modelSize: Vector3, fov?: number): void;
+
 export { }

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,
@@ -33962,6 +33984,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 +36148,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 +42378,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 +42407,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 +42547,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 +42584,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 +42615,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 +42686,9 @@ class MeshDesc {
         break;
       }
     }
+    if (child.className === "Decal") {
+      this.forceVertexColor = void 0;
+    }
   }
   fromPart(child) {
     this.canHaveSkinning = false;
@@ -43126,6 +43205,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 +43575,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 +43584,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 +43645,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 +43708,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 +43765,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 +43789,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 +44889,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) {
@@ -47061,6 +47147,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 = [
@@ -48610,6 +48716,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 +49086,7 @@ function RegisterWrappers() {
   WeldWrapper.register();
   Motor6DWrapper.register();
   ManualWeldWrapper.register();
+  AttachmentWrapper.register();
   AnimationConstraintWrapper.register();
   AnimatorWrapper.register();
   FaceControlsWrapper.register();
@@ -48989,11 +49097,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
@@ -49032,6 +49169,39 @@ class RBXRendererScene {
     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 +49595,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();
@@ -49545,6 +49716,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 +49917,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 +49979,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 +50019,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 +50055,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 +50271,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 +50422,7 @@ export {
   AssetTypeToAccessoryType,
   AssetTypeToMakeupType,
   AssetTypes,
+  AttachmentWrapper,
   Authentication,
   AvatarType,
   BodyColor3s,
@@ -50120,6 +50460,7 @@ export {
   FileMesh,
   FileMeshSkinning,
   FileMeshSubset,
+  FindFirstMatchingAttachment,
   FullBodyColors,
   GetAttachedPart,
   HSR,
@@ -50217,24 +50558,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 +50630,7 @@ export {
   rotationMatrixToEulerAngles,
   saveByteArray,
   scaleMesh,
+  setupThumbnailScene,
   snapToNumber,
   specialClamp,
   transferSkeleton,
@@ -50287,5 +50640,6 @@ export {
   versionToNumber,
   vertPosToChunkPos,
   xmlMagic,
-  zoomExtents
+  zoomExtents,
+  zoomToExtents
 };

package/package.json

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