roavatar-renderer 1.9.9 → 1.9.11

package/dist/index.js

@@ -33687,7 +33687,13 @@ class Instance {
     }
     return lastChild;
   }
+  /**
+   * IMPORTANT: Only works properly for instances with an InstanceWrapper
+   * @param className 
+   * @returns 
+   */
   IsA(className) {
+    if (this.className === className) return true;
     const wrapper = this.w;
     if (wrapper) {
       return wrapper.IsA(className);
@@ -35104,37 +35110,45 @@ class ItemInfo {
 class AssetType {
   _id;
   //67
-  name;
+  _name;
   //JacketAccessory
   constructor() {
     this._id = 2;
-    this.name = "TShirt";
+    this._name = "TShirt";
   }
   clone() {
     const copy = new AssetType();
     copy.id = this.id;
-    copy.name = this.name;
+    copy._name = this._name;
     return copy;
   }
   toJson() {
     return {
       "id": this.id,
-      "name": this.name
+      "name": this._name
     };
   }
   fromJson(assetTypeJson) {
     if (assetTypeJson.id)
       this.id = assetTypeJson.id;
     if (assetTypeJson.name)
-      this.name = assetTypeJson.name;
+      this._name = assetTypeJson.name;
   }
   set id(newId) {
     this._id = newId;
-    this.name = AssetTypes[Number(newId)];
+    this._name = AssetTypes[Number(newId)];
   }
   get id() {
     return this._id;
   }
+  set name(newName) {
+    const newId = AssetTypeNameToId.get(newName);
+    this._id = newId || this._id;
+    this._name = newName;
+  }
+  get name() {
+    return this._name;
+  }
 }
 function cloneVecXYZ(vec) {
   return { X: vec.X, Y: vec.Y, Z: vec.Z };
@@ -36722,7 +36736,7 @@ class LocalOutfit {
     this.name = outfit.name;
     this.id = outfit.id;
     this.creator = outfit.creatorId;
-    this.date = Date.now();
+    this.date = outfit.creationDate || Date.now();
     this.buffer = arrayBufferToBase64(outfit.toBuffer());
   }
   toJson() {
@@ -36740,6 +36754,7 @@ class LocalOutfit {
     this.name = data.name;
     this.id = data.id;
     this.creator = data.creator;
+    this.date = data.date;
     this.image = data.image;
     this.buffer = data.buffer;
     this.bg = data.bg || 0;
@@ -36759,6 +36774,7 @@ class LocalOutfit {
     outfit.name = this.name;
     outfit.id = this.id;
     outfit.creatorId = this.creator;
+    outfit.creationDate = this.date;
     await outfit.fromBuffer(base64ToArrayBuffer(this.buffer), auth);
     return outfit;
   }
@@ -36768,6 +36784,7 @@ class LocalOutfit {
     outfit.name = this.name;
     outfit.id = this.id;
     outfit.creatorId = this.creator;
+    outfit.creationDate = this.date;
     await outfit.fromBuffer(base64ToArrayBuffer(this.buffer), auth);
     if (this.bg) {
       await outfit.addAssetId(this.bg, auth);
@@ -36817,9 +36834,7 @@ const AllAccessorySorts = [
   new ItemSort(46),
   new ItemSort(47)
 ];
-if (!FLAGS.HAIR_IS_BODYPART) {
-  AllAccessorySorts.push(new ItemSort(41));
-}
+AllAccessorySorts.push(new ItemSort(41));
 const AllClothingSorts = [
   new ItemSort(12),
   new ItemSort(11),
@@ -36843,9 +36858,7 @@ const AllBodyPartsSorts = [
   new ItemSort(31),
   new ItemSort(27)
 ];
-if (FLAGS.HAIR_IS_BODYPART) {
-  AllBodyPartsSorts.push(new ItemSort(41));
-}
+AllBodyPartsSorts.push(new ItemSort(41));
 const AllAnimationSorts = [
   new ItemSort(48),
   new ItemSort(50),
@@ -36906,6 +36919,7 @@ const CategoryDictionary = {
       "Dynamic Heads": new SortInfo([new ItemSort(2, "Outfit")]),
       "Adjustment": new SpecialInfo("HeadAdjustment"),
       "|": new SortDivision(),
+      "Hair": new SortInfo([new ItemSort(41)]),
       "Heads": new SortInfo([new ItemSort(17)], "inventory"),
       "Faces": new SortInfo([new ItemSort(18)], "inventory")
     },
@@ -39386,6 +39400,7 @@ class Cache {
   map = /* @__PURE__ */ new Map();
   lastAccess = /* @__PURE__ */ new Map();
   maxEntries;
+  minDeleteLifetime = 5;
   onDelete;
   constructor(maxEntries = 250) {
     this.maxEntries = maxEntries;
@@ -39399,12 +39414,7 @@ class Cache {
   set(key, value) {
     this.map.set(key, value);
     this.lastAccess.set(key, Date.now());
-    if (this.map.size > this.maxEntries) {
-      const toDelete = [...this.lastAccess.entries()].reduce((min, current) => {
-        return current[1] < min[1] ? current : min;
-      });
-      this.delete(toDelete[0]);
-    }
+    this.deleteUntil();
     return this;
   }
   has(key) {
@@ -39416,11 +39426,28 @@ class Cache {
     this.lastAccess.delete(key);
     return toReturn;
   }
+  deleteUntil() {
+    while (this.map.size > this.maxEntries) {
+      if (!this.deleteOne()) break;
+    }
+  }
+  deleteOne() {
+    if (this.map.size > this.maxEntries) {
+      const toDelete = [...this.lastAccess.entries()].reduce((min, current) => {
+        return current[1] < min[1] ? current : min;
+      });
+      if (Date.now() - toDelete[1] >= this.minDeleteLifetime * 1e3) {
+        this.delete(toDelete[0]);
+        return true;
+      }
+    }
+    return false;
+  }
 }
 const CACHE = {
-  "AssetBuffer": new Cache(250),
+  "AssetBuffer": new Cache(100),
   "RBX": new Cache(100),
-  "Mesh": new Cache(250),
+  "Mesh": new Cache(100),
   "Image": new Cache(100),
   "Thumbnails": new Cache(1e3),
   "ItemOwned": new Cache(1e3),
@@ -39429,6 +39456,54 @@ const CACHE = {
   "ItemDetails": new Cache(1e4),
   "UserInfo": void 0
 };
+function setCacheFootprintPreset(preset) {
+  switch (preset) {
+    case "none":
+      CACHE.AssetBuffer.maxEntries = 0;
+      CACHE.RBX.maxEntries = 0;
+      CACHE.Mesh.maxEntries = 0;
+      CACHE.Image.maxEntries = 0;
+      CACHE.Thumbnails.maxEntries = 0;
+      CACHE.ItemOwned.maxEntries = 0;
+      CACHE.IsLayered.maxEntries = 0;
+      CACHE.AvatarInventoryItem.maxEntries = 0;
+      CACHE.ItemDetails.maxEntries = 0;
+      break;
+    case "low":
+      CACHE.AssetBuffer.maxEntries = 10;
+      CACHE.RBX.maxEntries = 10;
+      CACHE.Mesh.maxEntries = 10;
+      CACHE.Image.maxEntries = 10;
+      CACHE.Thumbnails.maxEntries = 500;
+      CACHE.ItemOwned.maxEntries = 500;
+      CACHE.IsLayered.maxEntries = 100;
+      CACHE.AvatarInventoryItem.maxEntries = 500;
+      CACHE.ItemDetails.maxEntries = 5e3;
+      break;
+    case "normal":
+      CACHE.AssetBuffer.maxEntries = 100;
+      CACHE.RBX.maxEntries = 100;
+      CACHE.Mesh.maxEntries = 100;
+      CACHE.Image.maxEntries = 100;
+      CACHE.Thumbnails.maxEntries = 1e3;
+      CACHE.ItemOwned.maxEntries = 1e3;
+      CACHE.IsLayered.maxEntries = 1e3;
+      CACHE.AvatarInventoryItem.maxEntries = 1e3;
+      CACHE.ItemDetails.maxEntries = 1e4;
+      break;
+    case "high":
+      CACHE.AssetBuffer.maxEntries = 250;
+      CACHE.RBX.maxEntries = 250;
+      CACHE.Mesh.maxEntries = 250;
+      CACHE.Image.maxEntries = 250;
+      CACHE.Thumbnails.maxEntries = 1e3;
+      CACHE.ItemOwned.maxEntries = 1e3;
+      CACHE.IsLayered.maxEntries = 1e3;
+      CACHE.AvatarInventoryItem.maxEntries = 1e3;
+      CACHE.ItemDetails.maxEntries = 1e4;
+      break;
+  }
+}
 const ContentMap = /* @__PURE__ */ new Map();
 function createContentMap() {
   ContentMap.set("rbxasset://fonts/BaseballCap.mesh", "12220916");
@@ -43854,6 +43929,89 @@ GLTFExporter.Utils = {
     return dstAttribute;
   }
 };
+const managedTextures = /* @__PURE__ */ new Map();
+async function createTexturePromise(url, params) {
+  const image = await API.Generic.LoadImage(url.replace(".dds", ".png"));
+  if (!image) return void 0;
+  const texture = new Texture(
+    image,
+    void 0,
+    params?.wrapS || ClampToEdgeWrapping,
+    params?.wrapT || ClampToEdgeWrapping,
+    params?.magFilter,
+    params?.minFilter,
+    void 0,
+    void 0,
+    void 0,
+    params?.colorSpace || SRGBColorSpace
+  );
+  if (params?.generateMipmaps !== void 0) texture.generateMipmaps = params?.generateMipmaps;
+  texture.needsUpdate = true;
+  return texture;
+}
+function createManagedTexture(url, params) {
+  const textureInfo = {
+    texture: void 0,
+    uses: 1
+    //used by texture promise (internal), so we dont try to dispose when it doesnt even exist yet
+  };
+  textureInfo.texture = new Promise((resolve) => {
+    createTexturePromise(url, params).then((result) => {
+      textureInfo.texture = result;
+      finishManagedTexture(url, params);
+      resolve(result);
+    });
+  });
+  return textureInfo;
+}
+function getTextureInfoKey(url, params) {
+  url = url.replace(".dds", ".png");
+  if (params?.colorSpace === "srgb") delete params.colorSpace;
+  if (params?.wrapS === ClampToEdgeWrapping) delete params.wrapS;
+  if (params?.wrapT === ClampToEdgeWrapping) delete params.wrapT;
+  if (params?.magFilter === LinearFilter) delete params.magFilter;
+  if (params?.minFilter === LinearMipmapLinearFilter) delete params.minFilter;
+  if (params && Object.keys(params).length > 0) {
+    return url + JSON.stringify(params);
+  } else {
+    return url;
+  }
+}
+async function getManagedTexture(url, params) {
+  const key = getTextureInfoKey(url, params);
+  let managedTextureInfo = managedTextures.get(key);
+  if (!managedTextureInfo) {
+    managedTextureInfo = createManagedTexture(url, params);
+    managedTextures.set(key, managedTextureInfo);
+  }
+  managedTextureInfo.uses += 1;
+  const disposeTimeout = managedTextureInfo.disposeTimeout;
+  if (disposeTimeout) {
+    clearTimeout(disposeTimeout);
+    managedTextureInfo.disposeTimeout = void 0;
+  }
+  return managedTextureInfo.texture;
+}
+async function finishManagedTexture(url, params) {
+  const key = getTextureInfoKey(url, params);
+  const managedTextureInfo = managedTextures.get(key);
+  if (managedTextureInfo) {
+    managedTextureInfo.uses -= 1;
+    if (managedTextureInfo.uses <= 0) {
+      if (!managedTextureInfo.disposeTimeout) {
+        const disposeTimeout = setTimeout(() => {
+          if (managedTextureInfo.disposeTimeout !== disposeTimeout || managedTextureInfo.uses > 0) return;
+          const texture = managedTextureInfo.texture;
+          if (texture && texture instanceof Texture || texture === void 0) {
+            managedTextures.delete(key);
+            if (texture) texture.dispose();
+          }
+        }, 5e3);
+        managedTextureInfo.disposeTimeout = disposeTimeout;
+      }
+    }
+  }
+}
 const RenderDescClassTypes = /* @__PURE__ */ new Map();
 function getRenderDescForClass(className) {
   return RenderDescClassTypes.get(className);
@@ -43870,22 +44028,9 @@ function setTHREEObjectCF(threeObject, cframe) {
   threeObject.rotation.y = rad(cframe.Orientation[1]);
   threeObject.rotation.z = rad(cframe.Orientation[2]);
 }
-async function getTexture(texture, colorSpace = SRGBColorSpace) {
-  if (texture) {
-    const source = texture.replace(".dds", ".png");
-    const image = await API.Generic.LoadImage(source);
-    if (image) {
-      const texture2 = new Texture(image);
-      texture2.wrapS = ClampToEdgeWrapping;
-      texture2.wrapT = ClampToEdgeWrapping;
-      texture2.colorSpace = colorSpace;
-      texture2.needsUpdate = true;
-      return texture2;
-    }
-  }
-  return void 0;
-}
 class DisposableDesc {
+  toDispose = [];
+  managedTextures = [];
   disposeMesh(scene, mesh) {
     disposeMesh(scene, mesh);
   }
@@ -43901,6 +44046,22 @@ class DisposableDesc {
   dispose(_renderer, _scene) {
     throw new Error("Virtual method dispose called");
   }
+  clearToDispose() {
+    for (const disposeable of this.toDispose) {
+      disposeable.dispose();
+    }
+    this.toDispose = [];
+    for (const managedTexture of this.managedTextures) {
+      finishManagedTexture(managedTexture.url, managedTexture.params);
+    }
+    this.managedTextures = [];
+  }
+  removeFromToDispose(disposable) {
+    const index = this.toDispose.indexOf(disposable);
+    if (index > -1) {
+      this.toDispose.splice(index, 1);
+    }
+  }
 }
 class RenderDesc extends DisposableDesc {
   static classTypes = [];
@@ -45676,6 +45837,7 @@ class ModelLayersDesc {
       }
       const targetCage = meshMap.get(this.targetCages[i]);
       targetCage.removeDuplicateVertices();
+      offsetMesh(targetCage, this.targetOffsets[i]);
       inheritSkeleton(targetCage, targetMesh);
       targetCage.setBoneSource(this.getTargetName(i));
       targetCage.setBoneSourceSize();
@@ -45683,14 +45845,12 @@ class ModelLayersDesc {
     const distDeformer = this.targetDeformers[0];
     const dist_mesh = distDeformer ? meshMap.get(distDeformer.targetCage).clone() : meshMap.get(this.targetCages[0]).clone();
     const dist_mesh_mesh = meshMap.get(this.targetMeshes[0]);
-    offsetMesh(dist_mesh, this.targetOffsets[0]);
     scaleMesh(dist_mesh, this.targetSizes[0].divide(new Vector3().fromVec3(dist_mesh_mesh.size)));
     offsetMesh(dist_mesh, this.targetCFrames[0]);
     for (let i = 1; i < this.targetCages.length; i++) {
       const deformer = this.targetDeformers[i];
       const targetCage = deformer ? meshMap.get(deformer.targetCage).clone() : meshMap.get(this.targetCages[i]).clone();
       const targetMesh = meshMap.get(this.targetMeshes[i]);
-      offsetMesh(targetCage, this.targetOffsets[i]);
       scaleMesh(targetCage, this.targetSizes[i].divide(new Vector3().fromVec3(targetMesh.size)));
       offsetMesh(targetCage, this.targetCFrames[i]);
       dist_mesh.combine(targetCage);
@@ -46158,7 +46318,7 @@ async function promiseForMesh(url, readOnly = false) {
     });
   });
 }
-class MeshDesc {
+class MeshDesc extends DisposableDesc {
   //size: Vector3 = new Vector3(1,1,1)
   scaleIsRelative = false;
   mesh;
@@ -46186,9 +46346,6 @@ class MeshDesc {
   fileMesh;
   wasAutoSkinned = false;
   wasDeformed = false;
-  dispose() {
-    this.instance = void 0;
-  }
   isSame(other) {
     const singularTrue = (
       //this.size.isSame(other.size) &&
@@ -46535,6 +46692,7 @@ class MeshDesc {
     if (wrapTextureTransferResult instanceof Response) return wrapTextureTransferResult;
     this.fileMesh = mesh;
     const geometry = fileMeshToTHREEGeometry(the_ref_mesh || mesh, this.canHaveSkinning, this.forceVertexColor);
+    this.toDispose.push(geometry);
     let threeMesh = void 0;
     if (geometry.attributes.skinWeight) {
       threeMesh = new SkinnedMesh(geometry);
@@ -46699,6 +46857,11 @@ class MeshDesc {
       this.wrapTextureTargetOrigin = wrapTarget.Prop("CageOrigin").removeNaN();
     }
   }
+  dispose(renderer) {
+    this.instance = void 0;
+    this.clearToDispose();
+    this.disposeRenderLists(renderer);
+  }
 }
 const compositMeshPaths = [
   "rbxasset://avatar/compositing/CompositFullAtlasBaseTexture.mesh",
@@ -47050,67 +47213,6 @@ const Shader_TextureComposer_Gamma = new ShaderMaterial({
   depthWrite: false,
   transparent: true
 });
-const managedTextures = /* @__PURE__ */ new Map();
-async function createTexturePromise(url, params) {
-  const image = await API.Generic.LoadImage(url);
-  if (!image) return void 0;
-  const texture = new Texture(image, void 0, void 0, void 0, void 0, void 0, void 0, void 0, void 0, params?.colorSpace || "srgb");
-  texture.needsUpdate = true;
-  return texture;
-}
-function createManagedTexture(url, params) {
-  const textureInfo = {
-    texture: void 0,
-    uses: 1
-    //used by texture promise (internal), so we dont try to dispose when it doesnt even exist yet
-  };
-  textureInfo.texture = new Promise((resolve) => {
-    createTexturePromise(url, params).then((result) => {
-      textureInfo.texture = result;
-      finishManagedTexture(url, params);
-      resolve(result);
-    });
-  });
-  return textureInfo;
-}
-function getTextureInfoKey(url, params) {
-  return url + JSON.stringify(params);
-}
-async function getManagedTexture(url, params) {
-  const key = getTextureInfoKey(url, params);
-  let managedTextureInfo = managedTextures.get(key);
-  if (!managedTextureInfo) {
-    managedTextureInfo = createManagedTexture(url, params);
-    managedTextures.set(key, managedTextureInfo);
-  }
-  managedTextureInfo.uses += 1;
-  const disposeTimeout = managedTextureInfo.disposeTimeout;
-  if (disposeTimeout) {
-    clearTimeout(disposeTimeout);
-    managedTextureInfo.disposeTimeout = void 0;
-  }
-  return managedTextureInfo.texture;
-}
-async function finishManagedTexture(url, params) {
-  const key = getTextureInfoKey(url, params);
-  const managedTextureInfo = managedTextures.get(key);
-  if (managedTextureInfo) {
-    managedTextureInfo.uses -= 1;
-    if (managedTextureInfo.uses <= 0) {
-      if (!managedTextureInfo.disposeTimeout) {
-        const disposeTimeout = setTimeout(() => {
-          if (managedTextureInfo.disposeTimeout !== disposeTimeout || managedTextureInfo.uses > 0) return;
-          managedTextures.delete(key);
-          const texture = managedTextureInfo.texture;
-          if (texture && texture instanceof Texture) {
-            texture.dispose();
-          }
-        }, 5e3);
-        managedTextureInfo.disposeTimeout = disposeTimeout;
-      }
-    }
-  }
-}
 async function renderBodyPartClothingR15(limbId, texture) {
   let instruction;
   if (limbId !== BodyPart.Torso) {
@@ -47249,7 +47351,7 @@ class TextureLayer {
     return this.uvType === other.uvType && this.face === other.face && this.color === other.color && this.normal === other.normal && this.roughness === other.roughness && this.metalness === other.metalness && this.emissive === other.emissive;
   }
 }
-class MaterialDesc {
+class MaterialDesc extends DisposableDesc {
   layers = [];
   isDecal = false;
   canHaveMipmaps = true;
@@ -47268,6 +47370,7 @@ class MaterialDesc {
   createdTextures = [];
   noTextureTransparency = false;
   result;
+  resultRenderTarget;
   isSame(other) {
     if (this.dirty || other.dirty) return false;
     const propertiesSame = this.isDecal === other.isDecal && this.transparent === other.transparent && Math.round(this.transparency * 100) === Math.round(other.transparency * 100) && this.doubleSided === other.doubleSided && this.visible === other.visible && this.canHaveMipmaps === other.canHaveMipmaps && this.resampleMode === other.resampleMode;
@@ -47578,6 +47681,7 @@ class MaterialDesc {
       }
     }
     if (composeInsts.length === 0) {
+      this.finishManagedTextures(textureType);
       return void 0;
     }
     TextureComposer.new(width, height, textureType === "color" ? LinearSRGBColorSpace : NoColorSpace, RepeatWrapping, noMipmaps);
@@ -47586,12 +47690,15 @@ class MaterialDesc {
       TextureComposer.add(inst);
     }
     const renderTarget = TextureComposer.render();
+    this.toDispose.push(renderTarget);
     this.finishManagedTextures(textureType);
+    const linearRenderTarget = renderTarget;
     const lineartexture = renderTarget.texture;
     lineartexture.wrapS = RepeatWrapping;
     lineartexture.wrapT = RepeatWrapping;
     lineartexture.needsUpdate = true;
     let texture = lineartexture;
+    let renderTargetFinal = linearRenderTarget;
     if (textureType === "color") {
       const gammaInst = await TextureComposer.simpleMesh(
         "CompositQuad",
@@ -47605,17 +47712,21 @@ class MaterialDesc {
       TextureComposer.new(width, height, SRGBColorSpace, RepeatWrapping, noMipmaps);
       TextureComposer.cameraSize(camWidth, camHeight);
       TextureComposer.add(gammaInst);
-      texture = TextureComposer.render().texture;
+      renderTargetFinal = TextureComposer.render();
+      this.toDispose.push(renderTargetFinal);
+      texture = renderTargetFinal.texture;
     }
-    if (texture !== lineartexture) {
-      lineartexture.dispose();
+    if (linearRenderTarget !== renderTargetFinal) {
+      linearRenderTarget.dispose();
+      this.removeFromToDispose(linearRenderTarget);
     }
+    this.resultRenderTarget = renderTargetFinal;
     texture.magFilter = this.resampleMode === ResamplerMode.Default ? LinearFilter : NearestFilter;
     let hasTransparency = false;
     const rbxRenderer = RBXRenderer.getRenderer();
     if (!hasColorLayer && rbxRenderer || FLAGS.RENDERTARGET_TO_CANVASTEXTURE && rbxRenderer) {
       const data = new Uint8Array(width * height * 4);
-      await rbxRenderer.readRenderTargetPixelsAsync(renderTarget, 0, 0, width, height, data);
+      await rbxRenderer.readRenderTargetPixelsAsync(renderTargetFinal, 0, 0, width, height, data);
       for (let i = 3; i < data.length; i += 4) {
         if (data[i] < 255) {
           hasTransparency = true;
@@ -47625,6 +47736,7 @@ class MaterialDesc {
       if (FLAGS.RENDERTARGET_TO_CANVASTEXTURE) {
         const ogTexture = texture;
         texture = imageDataToCanvasTexture(data, width, height);
+        this.toDispose.push(texture);
         texture.colorSpace = textureType === "color" ? SRGBColorSpace : NoColorSpace;
         texture.wrapS = ogTexture.wrapS;
         texture.wrapT = ogTexture.wrapT;
@@ -47632,6 +47744,7 @@ class MaterialDesc {
         texture.magFilter = ogTexture.magFilter;
         texture.generateMipmaps = ogTexture.generateMipmaps;
         ogTexture.dispose();
+        this.removeFromToDispose(ogTexture);
       }
     }
     if (!this.transparent) {
@@ -47660,6 +47773,7 @@ class MaterialDesc {
       throw new Error("Failed to get CanvasContext");
     }
     const texture = new CanvasTexture(canvas);
+    this.toDispose.push(texture);
     texture.colorSpace = textureType === "color" ? SRGBColorSpace : NoColorSpace;
     texture.wrapS = RepeatWrapping;
     texture.wrapT = RepeatWrapping;
@@ -47711,21 +47825,21 @@ class MaterialDesc {
       }
     }
     if (textureUrl) {
-      const image = await API.Generic.LoadImage(textureUrl);
-      if (image) {
-        let hasTransparency = true;
-        if (!this.transparent) {
-          hasTransparency = false;
-        }
-        const texture = new Texture(image);
-        texture.wrapS = RepeatWrapping;
-        texture.wrapT = RepeatWrapping;
-        texture.colorSpace = textureType === "color" ? SRGBColorSpace : NoColorSpace;
-        texture.generateMipmaps = this.canHaveMipmaps;
-        texture.magFilter = this.resampleMode === ResamplerMode.Default ? LinearFilter : NearestFilter;
-        texture.needsUpdate = true;
-        return [texture, hasTransparency];
-      }
+      let hasTransparency = true;
+      if (!this.transparent) {
+        hasTransparency = false;
+      }
+      const textureParams = {
+        colorSpace: textureType === "color" ? SRGBColorSpace : NoColorSpace,
+        wrapS: RepeatWrapping,
+        wrapT: RepeatWrapping,
+        generateMipmaps: this.canHaveMipmaps,
+        //resampling mode
+        magFilter: this.resampleMode === ResamplerMode.Default ? LinearFilter : NearestFilter
+      };
+      const texture = await getManagedTexture(textureUrl, textureParams);
+      this.managedTextures.push({ url: textureUrl, params: textureParams });
+      return texture ? [texture, hasTransparency] : void 0;
     }
   }
   getComposeType(textureType) {
@@ -47742,8 +47856,8 @@ class MaterialDesc {
         }
       }
       if (layer instanceof ColorLayer) {
-        hasColorLayer = true;
         if (layer.textureType === textureType) {
+          hasColorLayer = true;
           hasLayerOfType = true;
         }
       }
@@ -48178,6 +48292,10 @@ class MaterialDesc {
       this.addDecals(child.parent, "Normal", true);
     }
   }
+  dispose() {
+    this.resultRenderTarget = void 0;
+    this.clearToDispose();
+  }
 }
 class BasePartWrapperData {
   assemblyNode;
@@ -48289,7 +48407,7 @@ function boneIsChildOf(bone, parentName) {
   }
   return false;
 }
-class SkeletonDesc {
+class SkeletonDesc extends DisposableDesc {
   renderableDesc;
   meshDesc;
   skeleton;
@@ -48300,6 +48418,7 @@ class SkeletonDesc {
   skeletonHelper;
   frameCount = 0;
   constructor(renderableDesc, meshDesc, scene) {
+    super();
     this.renderableDesc = renderableDesc;
     this.meshDesc = meshDesc;
     const mesh = this.meshDesc.fileMesh;
@@ -48576,14 +48695,14 @@ class SkeletonDesc {
     this.updateMatrixWorld();
     this.frameCount += 1;
   }
-  dispose(scene) {
+  dispose() {
     if (this.skeletonHelper) {
-      scene.remove(this.skeletonHelper);
+      this.skeletonHelper.removeFromParent();
       this.skeletonHelper.dispose();
       this.skeletonHelper = void 0;
     }
     if (this.rootBone.parent) {
-      this.rootBone.parent.remove(this.rootBone);
+      this.rootBone.removeFromParent();
     }
     for (let i = 0; i < this.skeleton.bones.length; i++) {
       const bone = this.skeleton.bones[i];
@@ -48591,6 +48710,7 @@ class SkeletonDesc {
         bone.removeFromParent();
       }
     }
+    this.skeleton.dispose();
   }
   static descNeedsSkeleton(meshDesc) {
     return meshDesc.canHaveSkinning && meshDesc.fileMesh && meshDesc.fileMesh.skinning && meshDesc.fileMesh.skinning.numskinnings > 0;
@@ -48694,32 +48814,10 @@ class ObjectDesc extends RenderDesc {
     this.meshDesc.fromInstance(child);
     this.materialDesc.fromInstance(child);
   }
-  disposeSkeleton(scene, skeletonDesc) {
-    skeletonDesc.dispose(scene);
-  }
-  //Used to dispose OLD stuff
-  dispose(renderer, scene) {
-    if (this.meshDesc) {
-      this.meshDesc.dispose();
-    }
-    if (this.results) {
-      for (const mesh of this.results) {
-        this.disposeMesh(scene, mesh);
-      }
-    }
-    if (this.skeletonDesc) {
-      this.disposeSkeleton(scene, this.skeletonDesc);
-    }
-    if (this.results) {
-      this.disposeRenderLists(renderer);
-    }
-  }
-  async compileResults(renderer, scene) {
+  async compileResults(_renderer, scene) {
     const loadingLabel = this.instance ? this.instance.GetFullName() : "unknown";
     API.Misc.startCurrentlyLoadingAssets(loadingLabel);
     try {
-      const originalResult = this.results;
-      const originalSkeletonDesc = this.skeletonDesc;
       this.results = void 0;
       this.skeletonDesc = void 0;
       const promises = [
@@ -48756,15 +48854,6 @@ class ObjectDesc extends RenderDesc {
       } else {
         this.meshDesc.fileMesh = void 0;
       }
-      if (originalResult) {
-        this.disposeMeshes(scene, originalResult);
-      }
-      if (originalSkeletonDesc) {
-        this.disposeSkeleton(scene, originalSkeletonDesc);
-      }
-      if (originalResult) {
-        this.disposeRenderLists(renderer);
-      }
     } finally {
       API.Misc.stopCurrentlyLoadingAssets(loadingLabel);
     }
@@ -48840,6 +48929,17 @@ class ObjectDesc extends RenderDesc {
     }
     return !isBakedDecal && (!isDecal || isFirstDecal);
   }
+  //Used to dispose OLD stuff
+  dispose(renderer) {
+    if (this.results) {
+      for (const result of this.results) {
+        result.removeFromParent();
+      }
+    }
+    if (this.meshDesc) this.meshDesc.dispose(renderer);
+    if (this.materialDesc) this.materialDesc.dispose();
+    if (this.skeletonDesc) this.skeletonDesc.dispose();
+  }
 }
 const __vite_glob_0_4$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
@@ -59819,7 +59919,7 @@ const $05f6997e4b65da14$export$ed4ee5d1e55474a5 = {
 class RBXRendererScene {
   //important scene components
   scene = new Scene();
-  camera = new PerspectiveCamera(70, 1 / 1, 0.1, 100);
+  camera = new PerspectiveCamera(70, 1 / 1, 0.1, 1e3);
   controls;
   shouldAnimate = true;
   destroyed = false;
@@ -59967,6 +60067,41 @@ class RBXRendererScene {
   isFullyCompiled() {
     return this.areInstancesCompiled(this.addedInstances);
   }
+  /**
+   * @param instances Array of instances you want to wait to be finished compiling
+   * @param timeoutSeconds Default is 30 seconds
+   * @returns true if successful, false if a RenderDesc failed to compile or timed out
+   */
+  async waitUntilFullyCompiled(instances, timeoutSeconds = 30) {
+    if (this.areInstancesCompiled(instances)) return true;
+    const connections = [];
+    const compiledSuccessfully = await Promise.race([
+      //on fail compilation
+      new Promise((resolve) => {
+        connections.push(this.failedRenderDesc.Connect(() => {
+          resolve(false);
+        }));
+      }),
+      //on success compilation, check if everything is successfull
+      new Promise((resolve) => {
+        connections.push(this.compiledRenderDesc.Connect(() => {
+          if (this.areInstancesCompiled(instances)) {
+            resolve(true);
+          }
+        }));
+      }),
+      //on fail due to timeout
+      new Promise((resolve) => {
+        setTimeout(() => {
+          resolve(false);
+        }, timeoutSeconds * 1e3);
+      })
+    ]);
+    for (const connection of connections) {
+      connection.Disconnect();
+    }
+    return compiledSuccessfully;
+  }
   /**
    * Exports scene as a GLTF or GLB
    * @param name Name of the resulting file if autoDownload is true
@@ -60842,13 +60977,6 @@ class EmitterDesc extends DisposableDesc {
     this.flipbookSizeY = other.flipbookSizeY;
     this.flipbookStartRandom = other.flipbookStartRandom;
   }
-  dispose(renderer, scene) {
-    const mesh = this.result;
-    if (mesh) {
-      this.disposeMesh(scene, mesh);
-      this.disposeRenderLists(renderer);
-    }
-  }
   getFlipbookSize() {
     let flipbookSizeX = this.flipbookSizeX;
     let flipbookSizeY = this.flipbookSizeY;
@@ -60874,27 +61002,33 @@ class EmitterDesc extends DisposableDesc {
     }
     return [flipbookSizeX, flipbookSizeY];
   }
-  async compileResult(renderer, scene) {
-    const originalResult = this.result;
+  async compileResult() {
     const texturePromises = [
-      getTexture(this.texture),
-      getTexture(this.alphaTexture, NoColorSpace),
-      getTexture(this.colorTexture)
+      this.texture ? getManagedTexture(this.texture, { colorSpace: SRGBColorSpace }) : void 0,
+      this.alphaTexture ? getManagedTexture(this.alphaTexture, { colorSpace: NoColorSpace }) : void 0,
+      this.colorTexture ? getManagedTexture(this.colorTexture, { colorSpace: SRGBColorSpace }) : void 0
     ];
+    if (this.texture) this.managedTextures.push({ url: this.texture, params: { colorSpace: SRGBColorSpace } });
+    if (this.alphaTexture) this.managedTextures.push({ url: this.alphaTexture, params: { colorSpace: NoColorSpace } });
+    if (this.colorTexture) this.managedTextures.push({ url: this.colorTexture, params: { colorSpace: SRGBColorSpace } });
     let [mapToUse, alphaMapToUse, colorMapToUse] = await Promise.all(texturePromises);
     if (!mapToUse) {
       mapToUse = new DataTexture(new Uint8Array([0, 0, 0, 0]), 1, 1, RGBAFormat);
       mapToUse.needsUpdate = true;
+      this.toDispose.push(mapToUse);
     }
     if (!alphaMapToUse) {
       alphaMapToUse = new DataTexture(new Uint8Array([255, 255, 255, 255]), 1, 1, RGBAFormat);
       alphaMapToUse.needsUpdate = true;
+      this.toDispose.push(alphaMapToUse);
     }
     if (!colorMapToUse) {
       colorMapToUse = new DataTexture(new Uint8Array([255, 255, 255, 255]), 1, 1, RGBAFormat);
       colorMapToUse.needsUpdate = true;
+      this.toDispose.push(colorMapToUse);
     }
     const geometry = new PlaneGeometry(2, 2);
+    this.toDispose.push(geometry);
     this.instanceColorBuffer = new InstancedBufferAttribute(new Float32Array(this.maxCount * 3), 3);
     geometry.setAttribute("instanceColor", this.instanceColorBuffer);
     this.instanceOpacityBuffer = new InstancedBufferAttribute(new Float32Array(this.maxCount), 1);
@@ -60960,14 +61094,12 @@ class EmitterDesc extends DisposableDesc {
         }
       ])
     });
+    this.toDispose.push(material);
     this.resultMaterial = material;
     this.result = new InstancedMesh(geometry, material, this.maxCount);
+    this.toDispose.push(this.result);
     this.result.name = "Particles";
     this.result.frustumCulled = false;
-    if (originalResult) {
-      this.disposeMesh(scene, originalResult);
-      this.disposeRenderLists(renderer);
-    }
     return this.result;
   }
   emit(groupDesc, force = false) {
@@ -61089,6 +61221,14 @@ class EmitterDesc extends DisposableDesc {
     this.instanceSeedTimeBuffer.needsUpdate = true;
     this.instanceFlipbookBuffer.needsUpdate = true;
   }
+  dispose(renderer) {
+    const mesh = this.result;
+    if (mesh) {
+      mesh.removeFromParent();
+    }
+    this.clearToDispose();
+    this.disposeRenderLists(renderer);
+  }
 }
 class EmitterGroupDesc extends RenderDesc {
   static classTypes = ["ParticleEmitter", "Sparkles", "Fire", "Smoke"];
@@ -61228,7 +61368,7 @@ class EmitterGroupDesc extends RenderDesc {
     }
   }
   fromParticleEmitter(child) {
-    this.emitterDir = child.Prop("EmissionDirection");
+    this.emitterDir = child.PropOrDefault("EmissionDirection", this.emitterDir);
     const emitterDesc = new EmitterDesc(this.renderScene);
     if (child.HasProperty("Lifetime")) emitterDesc.lifetime = child.Prop("Lifetime");
     if (child.HasProperty("Rate")) emitterDesc.rate = child.Prop("Rate");
@@ -61245,7 +61385,7 @@ class EmitterGroupDesc extends RenderDesc {
     if (child.HasProperty("Color")) emitterDesc.color = child.Prop("Color");
     if (child.HasProperty("Texture")) emitterDesc.texture = child.Prop("Texture");
     if (child.HasProperty("Transparency")) emitterDesc.transparency = child.Prop("Transparency");
-    if (child.HasProperty("LightEmission")) emitterDesc.lightEmission = child.Prop("LightEmission");
+    emitterDesc.lightEmission = specialClamp(child.PropOrDefault("LightEmission", emitterDesc.lightEmission), 0, 1);
     emitterDesc.blending = emitterDesc.lightEmission === 0 ? EmitterBlendType.Normal : EmitterBlendType.PremultipliedAdditive;
     if (child.HasProperty("LightInfluence")) emitterDesc.lightInfluence = child.Prop("LightInfluence");
     if (child.HasProperty("ZOffset")) emitterDesc.zOffset = child.Prop("ZOffset");
@@ -61381,18 +61521,10 @@ class EmitterGroupDesc extends RenderDesc {
       shader: EmitterShaderType.Smoke
     }));
   }
-  dispose(renderer, scene) {
-    const meshes = this.results;
-    if (meshes) {
-      this.disposeMeshes(scene, meshes);
-      this.disposeRenderLists(renderer);
-    }
-  }
   async compileResults(renderer, scene) {
-    const originalResults = this.results;
     const resultPromises = [];
     for (const emitterDesc of this.emitterDescs) {
-      resultPromises.push(emitterDesc.compileResult(renderer, scene));
+      resultPromises.push(emitterDesc.compileResult());
     }
     this.results = [];
     const compiledResults = await Promise.all(resultPromises);
@@ -61405,10 +61537,6 @@ class EmitterGroupDesc extends RenderDesc {
         return compiledResult;
       }
     }
-    if (originalResults) {
-      this.disposeMeshes(scene, originalResults);
-      this.disposeRenderLists(renderer);
-    }
     const startFull = this.renderScene.particlesStartFull || FLAGS.PARTICLES_START_FULL;
     const startFullFramerate = this.renderScene.particlesStartFullFramerate;
     if (startFull) {
@@ -61438,6 +61566,11 @@ class EmitterGroupDesc extends RenderDesc {
       }
     }
   }
+  dispose(renderer) {
+    for (const emitterDesc of this.emitterDescs) {
+      emitterDesc.dispose(renderer);
+    }
+  }
 }
 const __vite_glob_0_2 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
@@ -62172,21 +62305,20 @@ class BeamDesc extends RenderDesc {
     this.segments = child.PropOrDefault("Segments", this.segments);
     if (!FLAGS.BEAMS_ENABLED) this.enabled = false;
   }
-  async compileResults(renderer, scene) {
-    const originalResults = this.results;
+  async compileResults() {
     this.results = [];
     if (this.enabled) {
       let textureResult = void 0;
       if (this.texture) {
-        textureResult = await getTexture(this.texture);
-        if (textureResult) {
-          textureResult.wrapT = RepeatWrapping;
-        }
+        const params = { colorSpace: "srgb", wrapT: RepeatWrapping };
+        textureResult = await getManagedTexture(this.texture, params);
+        this.managedTextures.push({ url: this.texture, params });
       }
       if (!textureResult) {
         textureResult = new DataTexture(new Uint8Array([255, 255, 255, 255]), 1, 1, RGBAFormat);
         textureResult.colorSpace = SRGBColorSpace;
         textureResult.needsUpdate = true;
+        this.toDispose.push(textureResult);
       }
       const material = new ShaderMaterial({
         side: DoubleSide,
@@ -62215,17 +62347,15 @@ class BeamDesc extends RenderDesc {
           }
         ])
       });
+      this.toDispose.push(material);
       const geometry = new PlaneGeometry(1, 1, this.segments, 1);
+      this.toDispose.push(geometry);
       const colorValues = new Float32Array((this.segments + 1) * 2 * 4).fill(0);
       geometry.setAttribute("color", new BufferAttribute(colorValues, 4));
       const mesh = new Mesh(geometry, material);
       mesh.name = this.instance ? this.instance.PropOrDefault("Name", "Unknown") + "_Beam" : "Unknown_Beam";
       this.results.push(mesh);
     }
-    if (originalResults) {
-      this.disposeMeshes(scene, originalResults);
-      this.disposeRenderLists(renderer);
-    }
     this.updateResults();
     return this.results;
   }
@@ -62349,11 +62479,13 @@ class BeamDesc extends RenderDesc {
     }
     this.lastTime = this.time;
   }
-  dispose(_renderer, scene) {
+  dispose(renderer) {
     if (!this.results) return;
     for (const result of this.results) {
-      scene.remove(result);
+      result.removeFromParent();
     }
+    this.clearToDispose();
+    this.disposeRenderLists(renderer);
   }
 }
 const __vite_glob_0_1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
@@ -62601,21 +62733,20 @@ class TrailDesc extends RenderDesc {
     this.faceCamera = child.PropOrDefault("FaceCamera", this.faceCamera);
     if (!FLAGS.BEAMS_ENABLED) this.enabled = false;
   }
-  async compileResults(renderer, scene) {
-    const originalResults = this.results;
+  async compileResults() {
     this.results = [];
     if (this.enabled) {
       let textureResult = void 0;
       if (this.texture) {
-        textureResult = await getTexture(this.texture);
-        if (textureResult) {
-          textureResult.wrapT = RepeatWrapping;
-        }
+        const params = { colorSpace: "srgb", wrapT: RepeatWrapping };
+        textureResult = await getManagedTexture(this.texture, params);
+        this.managedTextures.push({ url: this.texture, params });
       }
       if (!textureResult) {
         textureResult = new DataTexture(new Uint8Array([255, 255, 255, 255]), 1, 1, RGBAFormat);
         textureResult.colorSpace = SRGBColorSpace;
         textureResult.needsUpdate = true;
+        this.toDispose.push(textureResult);
       }
       const material = new ShaderMaterial({
         side: DoubleSide,
@@ -62644,7 +62775,9 @@ class TrailDesc extends RenderDesc {
           }
         ])
       });
+      this.toDispose.push(material);
       const geometry = new PlaneGeometry(1, 1, this.maxSegments, 1);
+      this.toDispose.push(geometry);
       const colorValues = new Float32Array((this.maxSegments + 1) * 2 * 4).fill(1);
       geometry.setAttribute("color", new BufferAttribute(colorValues, 4));
       const mesh = new Mesh(geometry, material);
@@ -62652,10 +62785,6 @@ class TrailDesc extends RenderDesc {
       mesh.name = this.instance ? this.instance.PropOrDefault("Name", "Unknown") + "_Trail" : "Unknown_Trail";
       this.results.push(mesh);
     }
-    if (originalResults) {
-      this.disposeMeshes(scene, originalResults);
-      this.disposeRenderLists(renderer);
-    }
     this.updateResults();
     return this.results;
   }
@@ -62792,11 +62921,13 @@ class TrailDesc extends RenderDesc {
       segment.cframe.Position = add(segment.cframe.Position, vec);
     }
   }
-  dispose(_renderer, scene) {
+  dispose(renderer, scene) {
     if (!this.results) return;
     for (const result of this.results) {
       scene.remove(result);
     }
+    this.clearToDispose();
+    this.disposeRenderLists(renderer);
   }
 }
 const __vite_glob_0_5 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
@@ -63418,31 +63549,35 @@ class RBXRenderer {
       renderScene.scene.add(result);
     }
   }
+  static _updateCompiledRenderDesc(oldDesc, newDesc, renderScene, instance) {
+    if (!oldDesc.compiled && !oldDesc.failed) {
+      oldDesc.compiled = true;
+      renderScene.compiledRenderDesc.Fire(instance);
+    }
+    if (!oldDesc.isSame(newDesc)) {
+      oldDesc.fromRenderDesc(newDesc);
+      oldDesc.updateResults();
+    }
+  }
   static _addRenderDesc(instance, auth, DescClass, renderScene) {
     if (!RBXRenderer.renderer) return;
     const oldDesc = renderScene.renderDescs.get(instance);
     const newDesc = new DescClass(renderScene);
     newDesc.fromInstance(instance);
     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();
-      }
+      RBXRenderer._updateCompiledRenderDesc(oldDesc, newDesc, renderScene, instance);
     } else {
       if (!renderScene.isRenderingMesh.get(instance)) {
-        if (oldDesc) newDesc.transferFrom(oldDesc);
-        newDesc.results = oldDesc?.results;
+        if (oldDesc && Object.getPrototypeOf(oldDesc).constructor === Object.getPrototypeOf(newDesc).constructor) {
+          newDesc.transferFrom(oldDesc);
+        }
         renderScene.renderDescs.set(instance, newDesc);
         renderScene.isRenderingMesh.set(instance, true);
         newDesc.compileResults(RBXRenderer.renderer, renderScene.scene).then((results) => {
+          if (RBXRenderer.renderer) oldDesc?.dispose(RBXRenderer.renderer, renderScene.scene);
           if (results && !(results instanceof Response)) {
             newDesc.updateResults();
-            if (renderScene.renderDescs.get(instance) && RBXRenderer.renderer) {
-              oldDesc?.dispose(RBXRenderer.renderer, renderScene.scene);
+            if (renderScene.renderDescs.get(instance) === newDesc && RBXRenderer.renderer) {
               for (const result of results) {
                 RBXRenderer._addSkeletonToResult(result, newDesc, renderScene);
               }
@@ -63452,9 +63587,12 @@ class RBXRenderer {
               newDesc.dispose(RBXRenderer.renderer, renderScene.scene);
             }
           } else {
+            if (RBXRenderer.renderer) newDesc.dispose(RBXRenderer.renderer, renderScene.scene);
             newDesc.failed = true;
-            renderScene.isRenderingMesh.set(instance, false);
-            renderScene.failedRenderDesc.Fire(instance);
+            if (renderScene.renderDescs.get(instance) === newDesc) {
+              renderScene.isRenderingMesh.set(instance, false);
+              renderScene.failedRenderDesc.Fire(instance);
+            }
             warn(false, "Failed to compile mesh", this, results);
           }
         });
@@ -63469,16 +63607,26 @@ class RBXRenderer {
       }));
     }
   }
-  /**Adds an instance to the renderer or updates it */
-  static addInstance(instance, auth, renderScene = RBXRenderer.firstScene) {
+  /** */
+  /**
+   * Adds an instance to the renderer or updates it, add it again to update it after changes have been made
+   * @param instance The instance that will be updated (the descendants will also update)
+   * @param auth This is here just in case something requires it in the future
+   * @param renderScene The scene the instances will be rendered in. Default RBXRenderer.firstScene
+   * @param includeDescendants If descendants should also have addInstance called on them. Default true
+   * @returns 
+   */
+  static addInstance(instance, auth, renderScene = RBXRenderer.firstScene, includeDescendants = true) {
     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()) {
-      RBXRenderer.addInstance(child, auth, renderScene);
+    if (includeDescendants) {
+      for (const child of instance.GetDescendants()) {
+        RBXRenderer.addInstance(child, auth, renderScene, false);
+      }
     }
   }
   static setRendererSize(width, height) {
@@ -64188,8 +64336,8 @@ function getExtentsForParts(parts, includeTransform) {
 }
 function getExtents(cframe, parts) {
   const inverseCF = cframe.inverse();
-  let lowerExtents = new Vector3(0, 0, 0);
-  let higherExtents = new Vector3(0, 0, 0);
+  let lowerExtents = new Vector3(1e6, 1e6, 1e6);
+  let higherExtents = new Vector3(-1e6, -1e6, -1e5);
   for (const child of parts) {
     if (child.createWrapper()?.IsA("BasePart")) {
       const partCF = child.Prop("CFrame");
@@ -65070,10 +65218,11 @@ async function renderTargetToCanvas$1(renderTarget) {
 }
 async function imageThumbnailClick(renderScene, width, height, format, options) {
   const resultOptions = {
-    quality: 1
+    quality: 1,
+    size: [width, height]
   };
   if (options) Object.assign(resultOptions, options);
-  const renderTarget = renderToRenderTarget$1(width, height, renderScene);
+  const renderTarget = renderToRenderTarget$1(resultOptions.size[0], resultOptions.size[1], renderScene);
   const canvas = await renderTargetToCanvas$1(renderTarget);
   renderTarget.dispose();
   if (canvas) {
@@ -65093,8 +65242,24 @@ async function modelThumbnailClick(renderScene, format, options) {
   });
 }
 function getThumbnailCameraCFrame(model, fov2, forceAngle) {
-  const thumbnailCamera = model.FindFirstChildOfClass("Camera");
-  if (thumbnailCamera) return thumbnailCamera.PropOrDefault("CFrame", new CFrame());
+  const thumbnailCamera = model.FindFirstChild("ThumbnailCamera");
+  if (thumbnailCamera && thumbnailCamera.IsA("Camera")) return thumbnailCamera.PropOrDefault("CFrame", new CFrame());
+  const thumbnailConfiguration = model.FindFirstChild("ThumbnailConfiguration");
+  if (thumbnailConfiguration) {
+    const thumbnailCameraTarget = thumbnailConfiguration.FindFirstChild("ThumbnailCameraTarget");
+    if (thumbnailCameraTarget && thumbnailCameraTarget.IsA("ObjectValue")) {
+      const targetInstance = thumbnailCameraTarget.Prop("Value");
+      if (targetInstance && targetInstance.IsA("BasePart")) {
+        const targetCF = targetInstance.PropOrDefault("CFrame", new CFrame());
+        const thumbnailCameraValue = thumbnailConfiguration.FindFirstChild("ThumbnailCameraValue");
+        if (thumbnailCameraValue && thumbnailCameraValue.IsA("CFrameValue")) {
+          const cf = thumbnailCameraValue.PropOrDefault("Value", new CFrame());
+          const resultCF = targetCF.multiply(cf);
+          return resultCF;
+        }
+      }
+    }
+  }
   let rootPart = model.PropOrDefault("PrimaryPart", void 0);
   if (!rootPart) rootPart = model.FindFirstChildOfClass("Part");
   if (!rootPart) rootPart = model.FindFirstChildOfClass("MeshPart");
@@ -65126,6 +65291,56 @@ function getThumbnailCameraCFrame(model, fov2, forceAngle) {
   zoomExtents(cameraCF, rootPartCF, extentsSize, fov2, 1);
   return cameraCF;
 }
+function getThumbnailCamera(model) {
+  const thumbnailCamera = model.FindFirstChild("ThumbnailCamera");
+  if (thumbnailCamera && thumbnailCamera.IsA("Camera")) return thumbnailCamera;
+  const camera = new Instance("Camera");
+  const thumbnailConfiguration = model.FindFirstChild("ThumbnailConfiguration");
+  if (thumbnailConfiguration) {
+    const thumbnailCameraTarget = thumbnailConfiguration.FindFirstChild("ThumbnailCameraTarget");
+    if (thumbnailCameraTarget && thumbnailCameraTarget.IsA("ObjectValue")) {
+      const targetInstance = thumbnailCameraTarget.Prop("Value");
+      if (targetInstance && targetInstance.IsA("BasePart")) {
+        const targetCF = targetInstance.PropOrDefault("CFrame", new CFrame());
+        const thumbnailCameraValue = thumbnailConfiguration.FindFirstChild("ThumbnailCameraValue");
+        if (thumbnailCameraValue && thumbnailCameraValue.IsA("CFrameValue")) {
+          const cf = thumbnailCameraValue.PropOrDefault("Value", new CFrame());
+          const resultCF = targetCF.multiply(cf);
+          camera.setProperty("FieldOfView", 70);
+          camera.setProperty("CFrame", resultCF);
+          return camera;
+        }
+      }
+    }
+  }
+  let rootPart = model.PropOrDefault("PrimaryPart", void 0);
+  if (!rootPart) rootPart = model.FindFirstChildOfClass("Part");
+  if (!rootPart) rootPart = model.FindFirstChildOfClass("MeshPart");
+  if (!rootPart) return camera;
+  const rootPartCF = rootPart.PropOrDefault("CFrame", new CFrame()).clone();
+  const worldExtents = getExtentsWorld(model);
+  if (!worldExtents) return camera;
+  const extentsSize = worldExtents[1].minus(worldExtents[0]);
+  rootPartCF.Position = getExtentsCenter(worldExtents).toVec3();
+  let lookVector = rootPartCF.lookVector();
+  if (Math.abs(lookVector[1]) > 0.95) {
+    lookVector = [0, 0, -1];
+  } else {
+    lookVector[1] = 0;
+    lookVector = normalize(lookVector);
+  }
+  let lookCF = CFrame.lookAt([0, 0, 0], lookVector);
+  lookCF = lookCF.multiply(CFrame.fromEulerAngles(0, 0, rad(45)));
+  lookCF = lookCF.multiply(CFrame.fromEulerAngles(rad(35), 0, 0));
+  lookCF = lookCF.multiply(CFrame.fromEulerAngles(0, 0, 0));
+  lookVector = lookCF.lookVector();
+  lookCF.Position = add(rootPartCF.Position, multiply([10, 10, 10], lookVector));
+  lookCF = CFrame.lookAt(lookCF.Position, rootPartCF.Position);
+  const cameraCF = lookCF.clone();
+  zoomExtents(cameraCF, rootPartCF, extentsSize, 70, 1);
+  camera.setProperty("CFrame", cameraCF);
+  return camera;
+}
 function setupThumbnailScene(renderScene) {
   renderScene.particlesStartFull = 4;
   renderScene.particlesStartFullFramerate = 20;
@@ -65214,6 +65429,135 @@ async function generateOutfitModelThumbnail(auth, outfitModel, options) {
   Object.assign(defaultOptions, options);
   return generateOutfitThumbnail(auth, outfitModel, defaultOptions.size, defaultOptions.type, defaultOptions.quality, defaultOptions.gltfAutoDownload, defaultOptions.includeAnimations);
 }
+function getViewExtents(camera, positions, width, height) {
+  const minExtents = new Vector2(1e6, 1e6);
+  const maxExtents = new Vector2(-1e6, -1e6);
+  for (const pos of positions) {
+    const projPos = new Vector3$1(...pos.toVec3()).project(camera);
+    const x = (projPos.x / 2 + 0.5) * width;
+    const y = (-projPos.y / 2 + 0.5) * height;
+    if (x < minExtents.X) minExtents.X = x;
+    if (x > maxExtents.X) maxExtents.X = x;
+    if (y < minExtents.Y) minExtents.Y = y;
+    if (y > maxExtents.Y) maxExtents.Y = y;
+  }
+  minExtents.X = Math.max(0, minExtents.X);
+  minExtents.Y = Math.max(0, minExtents.Y);
+  maxExtents.X = Math.min(width, maxExtents.X);
+  maxExtents.Y = Math.min(height, maxExtents.Y);
+  return [minExtents, maxExtents];
+}
+function getModelViewExtents(model, camera, width, height) {
+  const worldExtents = getExtentsWorld(model);
+  const corners = [
+    new Vector3(worldExtents[0].X, worldExtents[0].Y, worldExtents[0].Z),
+    new Vector3(worldExtents[0].X, worldExtents[0].Y, worldExtents[1].Z),
+    new Vector3(worldExtents[0].X, worldExtents[1].Y, worldExtents[0].Z),
+    new Vector3(worldExtents[0].X, worldExtents[1].Y, worldExtents[1].Z),
+    new Vector3(worldExtents[1].X, worldExtents[0].Y, worldExtents[0].Z),
+    new Vector3(worldExtents[1].X, worldExtents[0].Y, worldExtents[1].Z),
+    new Vector3(worldExtents[1].X, worldExtents[1].Y, worldExtents[0].Z),
+    new Vector3(worldExtents[1].X, worldExtents[1].Y, worldExtents[1].Z)
+  ];
+  return getViewExtents(camera, corners, width, height);
+}
+function cropCameraToViewExtents(camera, viewExtents, width, height, keepAspectRatio = true) {
+  const blx = viewExtents[0].X;
+  const bly = viewExtents[0].Y;
+  const bhx = viewExtents[1].X;
+  const bhy = viewExtents[1].Y;
+  const xDiff = bhx - blx;
+  const yDiff = bhy - bly;
+  const cx = blx + xDiff / 2;
+  const cy = bly + yDiff / 2;
+  const scaleW = xDiff / width;
+  const scaleH = yDiff / height;
+  const maxScale = Math.max(scaleW, scaleH);
+  const cropWidth = keepAspectRatio ? width * maxScale : xDiff;
+  const cropHeight = keepAspectRatio ? height * maxScale : yDiff;
+  const flx = cx - cropWidth / 2;
+  const fly = cy - cropHeight / 2;
+  const x = flx;
+  const y = fly;
+  camera.setViewOffset(
+    width,
+    height,
+    x,
+    y,
+    cropWidth,
+    cropHeight
+  );
+  return cropWidth / cropHeight;
+}
+function cropForModel(model, renderScene, width, height, resizeToRemoveUnusedSpace = false) {
+  const viewExtents = getModelViewExtents(model, renderScene.camera, width, height);
+  const targetAspectRatio = cropCameraToViewExtents(renderScene.camera, viewExtents, width, height, !resizeToRemoveUnusedSpace);
+  renderScene.camera.updateProjectionMatrix();
+  let newHeight = height;
+  let newWidth = width;
+  if (resizeToRemoveUnusedSpace) {
+    newWidth = width * targetAspectRatio;
+    if (newWidth > width) {
+      newWidth = width;
+      newHeight = height / targetAspectRatio;
+    }
+  }
+  return [Math.ceil(newWidth), Math.ceil(newHeight)];
+}
+function createThumbnailScene() {
+  const renderScene = RBXRenderer.addScene(false);
+  renderScene.isForRenderTarget = true;
+  setupThumbnailScene(renderScene);
+  return renderScene;
+}
+async function generateAccessoryThumbnail(auth, id, type, imageOptions, isAccessoryCamera = false) {
+  let renderSceneToDestroy = void 0;
+  const instancesToDestroy = [];
+  const cleanup = () => {
+    if (renderSceneToDestroy) renderSceneToDestroy.destroy();
+    for (const instance of instancesToDestroy) {
+      instance.Destroy();
+    }
+    return void 0;
+  };
+  const resultOptions = {
+    quality: 1,
+    size: [420, 420]
+  };
+  if (imageOptions) Object.assign(resultOptions, imageOptions);
+  const renderScene = createThumbnailScene();
+  renderSceneToDestroy = renderScene;
+  const rbx = await API.Asset.GetRBX(`rbxassetid://${id}`, { "Roblox-AssetFormat": "avatar_meshpart_accessory" });
+  if (rbx instanceof Response) return cleanup();
+  const root = rbx.generateTree();
+  instancesToDestroy.push(root);
+  const accessory = root.FindFirstChildOfClass("Accessory");
+  if (!accessory) return cleanup();
+  let camera = void 0;
+  if (isAccessoryCamera) {
+    camera = new Instance("Camera");
+    setupAccessoryCamera(root, camera);
+  } else {
+    camera = getThumbnailCamera(accessory);
+  }
+  instancesToDestroy.push(camera);
+  RBXRenderer.setCameraCFrame(camera.PropOrDefault("CFrame", new CFrame()), renderScene);
+  RBXRenderer.setCameraFov(camera.PropOrDefault("FieldOfView", 70), renderScene);
+  renderScene.camera.aspect = resultOptions.size[0] / resultOptions.size[1];
+  renderScene.camera.updateProjectionMatrix();
+  let [newWidth, newHeight] = [resultOptions.size[0], resultOptions.size[1]];
+  if (!isAccessoryCamera) {
+    [newWidth, newHeight] = cropForModel(accessory, renderScene, resultOptions.size[0], resultOptions.size[1]);
+  }
+  RBXRenderer.addInstance(accessory, auth, renderScene);
+  const compiledSuccessfully = await renderScene.waitUntilFullyCompiled([accessory, ...accessory.GetChildrenDangerous()]);
+  if (!compiledSuccessfully) return cleanup();
+  const result = type === "gltf" || type === "glb" ? await modelThumbnailClick(renderScene, type) : await imageThumbnailClick(renderScene, newWidth, newHeight, type, {
+    quality: resultOptions.quality
+  });
+  cleanup();
+  return result;
+}
 async function runTests() {
   const auth = new Authentication();
   const testModel = await API.Asset.GetRBX(FLAGS.AUTOTEST_MODEL);
@@ -65394,6 +65738,7 @@ function exposeThumbnailGenerator() {
   globalThis.generateModelThumbnail = generateModelThumbnail;
   globalThis.setupThumbnailScene = setupThumbnailScene;
   globalThis.getThumbnailCameraCFrame = getThumbnailCameraCFrame;
+  globalThis.generateAccessoryThumbnail = generateAccessoryThumbnail;
 }
 function exposeTests() {
   globalThis.runTests = runTests;
@@ -65593,7 +65938,10 @@ export {
   closestPointTriangle,
   createContentMap,
   createThumbnailCamera,
+  createThumbnailScene,
   createWeightsForMeshChunked,
+  cropCameraToViewExtents,
+  cropForModel,
   cross,
   defaultPantAssetIds,
   defaultPantTemplateAssetIds,
@@ -65635,6 +65983,7 @@ export {
   getFullBodyCameraCFrame,
   getHeadExtents,
   getHeadshotCameraCFrame,
+  getModelViewExtents,
   getOffsetArray,
   getOriginalAttachmentOrientation,
   getOriginalAttachmentPosition,
@@ -65643,9 +65992,11 @@ export {
   getPartsInAssembly_Generate,
   getRandomBetweenInclusive,
   getRootAssemblyPart_Generate,
+  getThumbnailCamera,
   getThumbnailCameraCFrame,
   getUVtoIndexMap,
   getUVtoIndicesMap,
+  getViewExtents,
   getWorkerOnMessage,
   hasSameVal,
   hasSameValFloat,
@@ -65689,6 +66040,7 @@ export {
   rotationMatrixToEulerAngles,
   saveByteArray,
   scaleMesh,
+  setCacheFootprintPreset,
   setupAccessoryCamera,
   setupBodyPartCamera,
   setupCamera,