roavatar-renderer 1.2.16 → 1.3.1

package/README.md

@@ -44,7 +44,7 @@ Basic example on how to load an avatar using OutfitRenderer (to make it simpler)
     document.body.appendChild(RBXRenderer.getRendererElement())
 
 //get avatar data for the user with id 1
-const outfit = API.Avatar.GetAvatarDetails(1)
+const outfit = await API.Avatar.GetAvatarDetails(1)
 if (!(outfit instanceof Outfit)) throw new Error("Failed to get outfit")
 
 //create renderer for outfit

package/dist/index.d.ts

@@ -55,6 +55,14 @@ export declare const AccessoryType: {
     Eyelash: number;
 };
 
+export declare class AccessoryWrapper extends InstanceWrapper {
+    static className: string;
+    static requiredProperties: string[];
+    setup(): void;
+    created(): void;
+    AccessoryBuildWeld(): void;
+}
+
 export declare const ActualBundleTypes: string[];
 
 export declare function add(v0: Vec3, v1: Vec3): Vec3;
@@ -83,6 +91,12 @@ export declare const AlphaMode: {
     TintMask: number;
 };
 
+export declare class AnimationConstraintWrapper extends InstanceWrapper {
+    static className: string;
+    static requiredProperties: string[];
+    setup(): void;
+}
+
 export declare type AnimationProp = "ClimbAnimation" | "FallAnimation" | "IdleAnimation" | "JumpAnimation" | "MoodAnimation" | "RunAnimation" | "SwimAnimation" | "WalkAnimation" | "dance1" | "dance2" | "dance3" | "toolnone";
 
 export declare const AnimationPropToName: {
@@ -552,6 +566,14 @@ declare type BodyColorsJson = {
     leftLegColorId?: number;
 };
 
+export declare class BodyColorsWrapper extends InstanceWrapper {
+    static className: string;
+    static requiredProperties: string[];
+    setup(): void;
+    created(): void;
+    update(): void;
+}
+
 export declare const BodyPart: {
     Head: number;
     Torso: number;
@@ -826,6 +848,12 @@ export declare const DataType: {
     NonSerializable: number;
 };
 
+export declare class DecalWrapper extends InstanceWrapper {
+    static className: string;
+    static requiredProperties: string[];
+    setup(): void;
+}
+
 /**
  * @deprecated
  */
@@ -982,6 +1010,8 @@ export declare class FileMeshSubset {
     clone(): FileMeshSubset;
 }
 
+export declare function fileMeshToTHREEGeometry(mesh: FileMesh, canIncludeSkinning?: boolean, forceVertexColor?: Vector3): THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>;
+
 export declare const FLAGS: {
     HAIR_IS_BODYPART: boolean;
     AVATAR_JOINT_UPGRADE: boolean;
@@ -1061,6 +1091,11 @@ export declare function getCameraCFrameForHeadshotCustomized(rig: Instance, fov:
 
 export declare function getDistIndexArray(ref: FileMesh, dist: FileMesh): (number | undefined)[];
 
+export declare function getExtents(cframe: CFrame, parts: Instance[]): [Vector3, Vector3];
+
+/**@deprecated this is SO broken */
+export declare function getExtentsForParts(parts: Instance[], includeTransform?: boolean): [Vector3, Vector3];
+
 export declare function getHeadExtents(rig: Instance): [Vector3, Vector3] | undefined;
 
 export declare interface GetInfoForId_Result {
@@ -1563,6 +1598,10 @@ export declare const MakeupType: {
     Eye: number;
 };
 
+export declare class ManualWeldWrapper extends WeldWrapper {
+    static className: string;
+}
+
 export declare function mapNum(x: number, in_min: number, in_max: number, out_min: number, out_max: number): number;
 
 export declare interface MarketplaceWidget {
@@ -1645,6 +1684,12 @@ export declare class ModelWrapper extends InstanceWrapper {
     GetModelCFrame(): CFrame;
 }
 
+export declare class Motor6DWrapper extends WeldWrapper {
+    static className: string;
+    static requiredProperties: string[];
+    setup(): void;
+}
+
 /**
  * @deprecated Use mountElement instead
  * @param container
@@ -1884,7 +1929,6 @@ export declare class OutfitRenderer {
     outfit: Outfit;
     currentRig?: Instance; /**Instance for the Model of the current outfit */
     currentRigType: AvatarType;
-    rigPath: string;
     doCameraUpdateOnLoad: boolean; /**Makes camera update when new avatar has loaded */
     doCameraUpdate: boolean; /**Does camera update every frame */
     currentlyChangingRig: boolean;
@@ -1894,13 +1938,14 @@ export declare class OutfitRenderer {
     animationInterval?: NodeJS.Timeout;
     animationFPS: number;
     deltaTimeMultiplier: number;
+    renderScene: RBXRendererScene;
     /**
      * Creates a new OutfitRenderer which makes it easy to render outfits
      * @param auth The authentication object, you should have one you use for everything
      * @param outfit The outfit you want to render, it can be updated later by calling setOutfit()
-     * @param rigPath The path that contains RigR6.rbxm and RigR15.rbxm, should always be "roavatar://" as rig path is now controlled by FLAGS
+     * @param renderScene The scene the outfit should be rendered in
      */
-    constructor(auth: Authentication, outfit: Outfit, rigPath?: string);
+    constructor(auth: Authentication, outfit: Outfit, renderScene?: RBXRendererScene);
     /**
      * Updates the current rig, called internally by _updateOutfit()
      */
@@ -2105,42 +2150,47 @@ export declare class RBX {
 }
 
 export declare class RBXRenderer {
-    static isRenderingMesh: Map<Instance, boolean>;
-    static renderDescs: Map<Instance, RenderDesc>;
-    static destroyConnections: Map<Instance, Connection>;
-    static lookAwayVector: Vec3;
-    static lookAwayDistance: number;
     static orbitControlsTarget: Vec3;
-    static scene: THREE.Scene;
-    static camera: THREE.PerspectiveCamera;
-    static controls: OrbitControls | undefined;
+    static scenes: RBXRendererScene[];
+    static get firstScene(): RBXRendererScene;
+    /**@deprecated This can only get the first renderScene's scene */
+    static get scene(): THREE.Scene;
+    /**@deprecated This can only get the first renderScene's camera */
+    static get camera(): THREE.PerspectiveCamera;
+    /**@deprecated This can only get the first renderScene's controls */
+    static get controls(): OrbitControls | undefined;
     static renderer?: THREE.WebGLRenderer;
-    static effectComposer: EffectComposer | undefined;
-    static shadowEnabled: boolean;
-    static shadowResolution: [number, number];
     static resolution: [number, number];
     static backgroundColorHex: number;
     static backgroundTransparent: boolean;
-    static _wellLitDirectionalLightIntensity: number;
-    static set wellLitDirectionalLightIntensity(v: number);
-    static get wellLitDirectionalLightIntensity(): number;
     static createLoadingIcon: boolean;
     static canvasContainer: HTMLDivElement;
     static loadingIcon?: HTMLSpanElement;
     static loadingIconStyle?: HTMLStyleElement;
-    static plane?: THREE.Mesh;
-    static shadowPlane?: THREE.Mesh;
-    static ambientLight?: THREE.AmbientLight;
-    static directionalLight?: THREE.DirectionalLight;
-    static directionalLight2?: THREE.DirectionalLight;
+    /**@deprecated This can only get the first renderScene's plane */
+    static get plane(): THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>, THREE.Material | THREE.Material[], THREE.Object3DEventMap> | undefined;
+    /**@deprecated This can only get the first renderScene's shadowPlane */
+    static get shadowPlane(): THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>, THREE.Material | THREE.Material[], THREE.Object3DEventMap> | undefined;
+    /**@deprecated This can only get the first renderScene's ambientLight */
+    static get ambientLight(): THREE.AmbientLight | undefined;
+    /**@deprecated This can only get the first renderScene's directionalLight */
+    static get directionalLight(): THREE.DirectionalLight | undefined;
+    /**@deprecated This can only get the first renderScene's directionalLight2 */
+    static get directionalLight2(): THREE.DirectionalLight | undefined;
+    /**@deprecated This can only set the first renderScene's wellLitDirectionalLightIntensity*/
+    static set wellLitDirectionalLightIntensity(v: number);
+    /**@deprecated This can only gey the first renderScene's wellLitDirectionalLightIntensity*/
+    static get wellLitDirectionalLightIntensity(): number;
     static failedToCreate: boolean;
     static error?: unknown;
     static boilerplateSetup(): Promise<void>;
     static showErrorHTML(): Promise<void>;
+    static createLoadingIconHTML(): void;
+    static addScene(): RBXRendererScene;
     /**Fully sets up renderer with scene, camera and frame rendering
      * @returns success
      */
-    static fullSetup(includeScene?: boolean, includeControls?: boolean): Promise<boolean>;
+    static fullSetup(includeSceneAppearance?: boolean, includeControls?: boolean, includeAnimate?: boolean): Promise<boolean>;
     /**Creates canvasContainer */
     static createContainer(): void;
     /**Sets up the THREE.js renderer */
@@ -2149,9 +2199,9 @@ export declare class RBXRenderer {
      * @param lightingType "WellLit" is the default lighting for RoAvatar, "Thumbnail" tries to match the Roblox thumbnail lighting
      * @param backgroundColorHex is the hex code for the background color, for example 0x2b2d33
      */
-    static setupScene(lightingType?: "WellLit" | "Thumbnail", backgroundColorHex?: number): void;
+    static setupScene(lightingType?: "WellLit" | "Thumbnail", backgroundColorHex?: number, renderScene?: RBXRendererScene): void;
     /**Sets up orbit controls */
-    static setupControls(): void;
+    static setupControls(renderScene?: RBXRendererScene): void;
     /**
      * @param colorHex example: 0x2b2d33 which is the default
      */
@@ -2162,13 +2212,15 @@ export declare class RBXRenderer {
      */
     static setBackgroundTransparent(transparent: boolean): void;
     /**Makes the renderer render a new frame on every animationFrame */
-    static animate(): void;
-    static _createEffectComposer(): void;
+    static animate(shouldRequestAnimationFrame?: boolean): void;
+    static animateAll(shouldRequestAnimationFrame?: boolean): void;
+    static renderScene(renderScene: RBXRendererScene, autoClear?: boolean): void;
+    static _createEffectComposer(renderScene?: RBXRendererScene): void;
     /**Removes an instance from the renderer */
-    static removeInstance(instance: Instance): void;
-    static _addRenderDesc(instance: Instance, auth: Authentication, DescClass: typeof RenderDesc): void;
+    static removeInstance(instance: Instance, renderScene?: RBXRendererScene): void;
+    static _addRenderDesc(instance: Instance, auth: Authentication, DescClass: typeof RenderDesc, renderScene: RBXRendererScene): void;
     /**Adds an instance to the renderer or updates it */
-    static addInstance(instance: Instance, auth: Authentication): void;
+    static addInstance(instance: Instance, auth: Authentication, renderScene?: RBXRendererScene): void;
     static setRendererSize(width: number, height: number): void;
     /**
      * @deprecated Use getRendererElement instead which includes the loading icon
@@ -2179,17 +2231,46 @@ export declare class RBXRenderer {
      * @returns An element containing the renderer canvas
      */
     static getRendererElement(): HTMLDivElement;
+    /**@deprecated This can only get the first renderScene's camera */
     static getRendererCamera(): THREE.PerspectiveCamera;
-    static getCameraCFrame(): CFrame;
-    static setCameraCFrame(cameraCF: CFrame): void;
-    static setCameraFov(fov: number): void;
+    static getCameraCFrame(renderScene?: RBXRendererScene): CFrame;
+    static setCameraCFrame(cameraCF: CFrame, renderScene?: RBXRendererScene): void;
+    static setCameraFov(fov: number, renderScene?: RBXRendererScene): void;
+    /**@deprecated This can only get the first renderScene's controls */
     static getRendererControls(): OrbitControls | undefined;
     static getRenderer(): THREE.WebGLRenderer | undefined;
-    static getScene(): THREE.Scene;
+    /**@deprecated This can only get the first renderScene's scene */
+    static getScene(): RBXRendererScene;
     /**@deprecated
      * This function is unstable and can throw errors, but might work
      */
-    static exportScene(): void;
+    static exportScene(renderScene?: RBXRendererScene): void;
+}
+
+export declare class RBXRendererScene {
+    scene: THREE.Scene;
+    camera: THREE.PerspectiveCamera;
+    controls: OrbitControls | undefined;
+    effectComposer: EffectComposer | undefined;
+    scissor?: [number, number, number, number];
+    viewport?: [number, number, number, number];
+    isRenderingMesh: Map<Instance, boolean>;
+    renderDescs: Map<Instance, RenderDesc>;
+    destroyConnections: Map<Instance, Connection>;
+    lookAwayVector: Vec3;
+    lookAwayDistance: number;
+    shadowEnabled: boolean;
+    shadowResolution: [number, number];
+    _wellLitDirectionalLightIntensity: number;
+    set wellLitDirectionalLightIntensity(v: number);
+    get wellLitDirectionalLightIntensity(): number;
+    plane?: THREE.Mesh;
+    shadowPlane?: THREE.Mesh;
+    ambientLight?: THREE.AmbientLight;
+    directionalLight?: THREE.DirectionalLight;
+    directionalLight2?: THREE.DirectionalLight;
+    setRect(bounds: DOMRect): void;
+    noRect(): void;
 }
 
 declare class RBXSimpleView {
@@ -2235,8 +2316,10 @@ export declare const RegularBodyColors: string[];
  * Abstract class used to describe all rendered instances
  */
 declare class RenderDesc extends DisposableDesc {
+    renderScene: RBXRendererScene;
     results?: THREE.Mesh[];
     instance?: Instance;
+    constructor(renderScene: RBXRendererScene);
     isSame(_other: RenderDesc): boolean;
     needsRegeneration(_other: RenderDesc): boolean;
     fromRenderDesc(other: RenderDesc): void;
@@ -2687,6 +2770,22 @@ export declare type WeightChunk3 = WeightChunk & {
     weights: Vec3[];
 };
 
+export declare class WeldWrapper extends InstanceWrapper {
+    static className: string;
+    static requiredProperties: string[];
+    setup(): void;
+    get data(): WeldWrapperData;
+    created(): void;
+    preRender(): void;
+    update(affectedPart?: number): void;
+}
+
+declare class WeldWrapperData {
+    part0ChangedConnection?: Connection;
+    lastUpdateTime: number;
+    timeUpdates: number;
+}
+
 export declare const WorkerTypeToFunction: {
     [K in string]: Function;
 };
@@ -2699,4 +2798,6 @@ export declare const WrapLayerAutoSkin: {
 
 export declare const xmlMagic = "<roblox ";
 
+export declare function zoomExtents(cameraCFrame: CFrame, modelCFrame: CFrame, modelSize: Vector3, targetFOV: number, distanceScale: number): void;
+
 export { }

package/dist/index.js

@@ -41220,7 +41220,6 @@ function TraverseRigFromAttachmentsInternal(self2, part, characterParts, buildJo
             if (part !== characterPart) {
               const matchingAttachment = characterPart.FindFirstChild(attachmentName);
               if (matchingAttachment && matchingAttachment.className === "Attachment") {
-                log(false, "matchingAtt", part, characterPart, attachmentName);
                 AdjustRootRigAttachmentPosition(self2, part, characterPart, attachment, matchingAttachment);
                 {
                   createJoint(jointName, attachment, matchingAttachment);
@@ -44797,8 +44796,13 @@ class DisposableDesc {
   }
 }
 class RenderDesc extends DisposableDesc {
+  renderScene;
   results;
   instance;
+  constructor(renderScene) {
+    super();
+    this.renderScene = renderScene;
+  }
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
   isSame(_other) {
     throw new Error("Virtual method isSame called");
@@ -45143,14 +45147,14 @@ class Particle {
     this.velocity = velocity;
     this.rotationSpeed = rotationSpeed;
   }
-  camDistance() {
-    const cameraPos = new Vector32(...RBXRenderer.getRendererCamera().position.toArray());
+  camDistance(renderScene) {
+    const cameraPos = new Vector32(...renderScene.camera.position.toArray());
     const particlePos = this.position;
     const distance2 = cameraPos.minus(particlePos).magnitude();
     return distance2;
   }
-  getMatrix(size, orientation) {
-    const camera = RBXRenderer.getRendererCamera();
+  getMatrix(renderScene, size, orientation) {
+    const camera = renderScene.camera;
     const particlePos = new Vector3$1(...this.position.toVec3());
     const translation = new Matrix4().makeTranslation(particlePos);
     const scale = new Matrix4().makeScale(size, size, 1);
@@ -45395,7 +45399,7 @@ class EmitterDesc extends DisposableDesc {
       this.passedTime -= 1 / this.rate;
     }
   }
-  updateResult() {
+  updateResult(renderScene) {
     if (!this.result || !this.instanceColorBuffer || !this.instanceOpacityBuffer || !this.instanceSeedTimeBuffer) return;
     this.result.count = this.particles.length;
     for (let i = 0; i < this.result.count; i++) {
@@ -45405,7 +45409,7 @@ class EmitterDesc extends DisposableDesc {
       const color = this.color.getValue(normalizedTime);
       const size = this.size.getValue(this.normalizeSizeKeypointTime ? normalizedTime : time2, particle.seed + 0);
       const opacity = 1 - this.transparency.getValue(normalizedTime, particle.seed + 1);
-      this.result.setMatrixAt(i, particle.getMatrix(size, this.orientation));
+      this.result.setMatrixAt(i, particle.getMatrix(renderScene, size, this.orientation));
       this.instanceColorBuffer.setXYZ(i, color.R, color.G, color.B);
       this.instanceOpacityBuffer.setX(i, opacity);
       this.instanceSeedTimeBuffer.setXY(i, particle.seed, normalizedTime);
@@ -45703,7 +45707,7 @@ class EmitterGroupDesc extends RenderDesc {
     this.lastTime = this.time;
     for (const emitterDesc of this.emitterDescs) {
       emitterDesc.tick(dt, this);
-      emitterDesc.updateResult();
+      emitterDesc.updateResult(this.renderScene);
     }
     this.lastCframe = this.cframe.clone();
   }
@@ -48962,42 +48966,104 @@ function RegisterWrappers() {
   BodyColorsWrapper.register();
   AccessoryWrapper.register();
 }
+class RBXRendererScene {
+  //important scene components
+  scene = new Scene();
+  camera = new PerspectiveCamera(70, 1 / 1, 0.1, 100);
+  controls;
+  //renderer
+  effectComposer;
+  //viewport
+  scissor;
+  viewport;
+  //renderables data
+  isRenderingMesh = /* @__PURE__ */ new Map();
+  renderDescs = /* @__PURE__ */ new Map();
+  destroyConnections = /* @__PURE__ */ new Map();
+  //scene appearance config
+  lookAwayVector = [0.406, 0.306, -0.819];
+  lookAwayDistance = 6;
+  shadowEnabled = true;
+  shadowResolution = [256, 256];
+  _wellLitDirectionalLightIntensity = Math.PI / 2;
+  set wellLitDirectionalLightIntensity(v) {
+    this._wellLitDirectionalLightIntensity = v;
+    if (this.directionalLight) {
+      this.directionalLight.intensity = this._wellLitDirectionalLightIntensity;
+    }
+  }
+  get wellLitDirectionalLightIntensity() {
+    return this._wellLitDirectionalLightIntensity;
+  }
+  //scene appearance
+  plane;
+  shadowPlane;
+  ambientLight;
+  directionalLight;
+  directionalLight2;
+  setRect(bounds) {
+    this.viewport = [bounds.left, window.innerHeight - bounds.bottom, bounds.width, bounds.height];
+    this.scissor = [...this.viewport];
+  }
+  noRect() {
+    this.viewport = [0, 0, 0, 0];
+    this.scissor = [0, 0, 0, 0];
+  }
+}
 class RBXRenderer {
-  static isRenderingMesh = /* @__PURE__ */ new Map();
-  static renderDescs = /* @__PURE__ */ new Map();
-  static destroyConnections = /* @__PURE__ */ new Map();
-  static lookAwayVector = [0.406, 0.306, -0.819];
-  static lookAwayDistance = 6;
   static orbitControlsTarget = [0, 3, 0];
-  static scene = new Scene();
-  static camera = new PerspectiveCamera(70, 1 / 1, 0.1, 100);
-  static controls;
+  static scenes = [new RBXRendererScene()];
+  static get firstScene() {
+    return RBXRenderer.scenes[0];
+  }
+  /**@deprecated This can only get the first renderScene's scene */
+  static get scene() {
+    return RBXRenderer.firstScene.scene;
+  }
+  /**@deprecated This can only get the first renderScene's camera */
+  static get camera() {
+    return RBXRenderer.firstScene.camera;
+  }
+  /**@deprecated This can only get the first renderScene's controls */
+  static get controls() {
+    return RBXRenderer.firstScene.controls;
+  }
   static renderer;
-  static effectComposer;
-  static shadowEnabled = true;
-  static shadowResolution = [256, 256];
   static resolution = [420, 420];
   static backgroundColorHex = 2829619;
   static backgroundTransparent = false;
-  static _wellLitDirectionalLightIntensity = Math.PI / 2;
-  static set wellLitDirectionalLightIntensity(v) {
-    RBXRenderer._wellLitDirectionalLightIntensity = v;
-    if (RBXRenderer.directionalLight) {
-      RBXRenderer.directionalLight.intensity = RBXRenderer._wellLitDirectionalLightIntensity;
-    }
-  }
-  static get wellLitDirectionalLightIntensity() {
-    return RBXRenderer._wellLitDirectionalLightIntensity;
-  }
   static createLoadingIcon = true;
   static canvasContainer;
   static loadingIcon;
   static loadingIconStyle;
-  static plane;
-  static shadowPlane;
-  static ambientLight;
-  static directionalLight;
-  static directionalLight2;
+  /**@deprecated This can only get the first renderScene's plane */
+  static get plane() {
+    return RBXRenderer.firstScene.plane;
+  }
+  /**@deprecated This can only get the first renderScene's shadowPlane */
+  static get shadowPlane() {
+    return RBXRenderer.firstScene.shadowPlane;
+  }
+  /**@deprecated This can only get the first renderScene's ambientLight */
+  static get ambientLight() {
+    return RBXRenderer.firstScene.ambientLight;
+  }
+  /**@deprecated This can only get the first renderScene's directionalLight */
+  static get directionalLight() {
+    return RBXRenderer.firstScene.directionalLight;
+  }
+  /**@deprecated This can only get the first renderScene's directionalLight2 */
+  static get directionalLight2() {
+    return RBXRenderer.firstScene.directionalLight2;
+  }
+  /**@deprecated This can only set the first renderScene's wellLitDirectionalLightIntensity*/
+  static set wellLitDirectionalLightIntensity(v) {
+    RBXRenderer.firstScene.wellLitDirectionalLightIntensity = v;
+  }
+  /**@deprecated This can only gey the first renderScene's wellLitDirectionalLightIntensity*/
+  static get wellLitDirectionalLightIntensity() {
+    return RBXRenderer.firstScene.wellLitDirectionalLightIntensity;
+  }
   static failedToCreate = false;
   static error;
   static async boilerplateSetup() {
@@ -49051,17 +49117,67 @@ class RBXRenderer {
     errorDiv.appendChild(errorLink);
     RBXRenderer.canvasContainer.append(errorDiv);
   }
+  static createLoadingIconHTML() {
+    RBXRenderer.loadingIcon = document.createElement("span");
+    RBXRenderer.loadingIcon.className = "roavatar-loader";
+    RBXRenderer.loadingIcon.style.opacity = "0";
+    RBXRenderer.loadingIcon.style.position = "absolute";
+    RBXRenderer.loadingIcon.style.bottom = "12px";
+    RBXRenderer.loadingIcon.style.right = "12px";
+    RBXRenderer.loadingIcon.style.width = "24px";
+    RBXRenderer.loadingIcon.style.height = "24px";
+    RBXRenderer.loadingIcon.style.transition = "0.1s";
+    RBXRenderer.loadingIconStyle = document.createElement("style");
+    RBXRenderer.loadingIconStyle.textContent = `
+            /*Loader source: https://cssloaders.github.io/ */
+            .roavatar-loader {
+            width: 48px;
+            height: 48px;
+            display: inline-block;
+            position: relative;
+            background: #FFF;
+            box-sizing: border-box;
+            animation: rooavatarFlipX 1s linear infinite;
+            }
+
+            @keyframes rooavatarFlipX {
+            0% {
+                transform: perspective(200px) rotateX(0deg) rotateY(0deg);
+            }
+            50% {
+                transform: perspective(200px) rotateX(-180deg) rotateY(0deg);
+            }
+            100% {
+                transform: perspective(200px) rotateX(-180deg) rotateY(-180deg);
+            }
+            }
+        `;
+    document.head.appendChild(RBXRenderer.loadingIconStyle);
+    RBXRenderer.canvasContainer.appendChild(RBXRenderer.loadingIcon);
+    const onLoadConnection = API.Events.OnLoadingAssets.Connect((newIsLoading) => {
+      if (RBXRenderer.loadingIcon) {
+        RBXRenderer.loadingIcon.style.opacity = newIsLoading ? "1" : "0";
+      } else {
+        onLoadConnection.Disconnect();
+      }
+    });
+  }
+  static addScene() {
+    const renderScene = new RBXRendererScene();
+    RBXRenderer.scenes.push(renderScene);
+    return renderScene;
+  }
   /**Fully sets up renderer with scene, camera and frame rendering
    * @returns success
   */
-  static async fullSetup(includeScene = true, includeControls = true) {
+  static async fullSetup(includeSceneAppearance = true, includeControls = true, includeAnimate = true) {
     try {
       RBXRenderer.createContainer();
       await RBXRenderer.boilerplateSetup();
       RBXRenderer.create();
-      if (includeScene) RBXRenderer.setupScene();
+      if (includeSceneAppearance) RBXRenderer.setupScene();
       if (includeControls) RBXRenderer.setupControls();
-      RBXRenderer.animate();
+      if (includeAnimate) RBXRenderer.animateAll();
     } catch (err2) {
       error(err2);
       RBXRenderer.failedToCreate = true;
@@ -49092,49 +49208,7 @@ class RBXRenderer {
     RBXRenderer.renderer.domElement.setAttribute("id", "OutfitInfo-outfit-image-3d");
     RBXRenderer.canvasContainer.appendChild(RBXRenderer.renderer.domElement);
     if (RBXRenderer.createLoadingIcon) {
-      RBXRenderer.loadingIcon = document.createElement("span");
-      RBXRenderer.loadingIcon.className = "roavatar-loader";
-      RBXRenderer.loadingIcon.style.opacity = "0";
-      RBXRenderer.loadingIcon.style.position = "absolute";
-      RBXRenderer.loadingIcon.style.bottom = "12px";
-      RBXRenderer.loadingIcon.style.right = "12px";
-      RBXRenderer.loadingIcon.style.width = "24px";
-      RBXRenderer.loadingIcon.style.height = "24px";
-      RBXRenderer.loadingIcon.style.transition = "0.1s";
-      RBXRenderer.loadingIconStyle = document.createElement("style");
-      RBXRenderer.loadingIconStyle.textContent = `
-                /*Loader source: https://cssloaders.github.io/ */
-                .roavatar-loader {
-                width: 48px;
-                height: 48px;
-                display: inline-block;
-                position: relative;
-                background: #FFF;
-                box-sizing: border-box;
-                animation: rooavatarFlipX 1s linear infinite;
-                }
-
-                @keyframes rooavatarFlipX {
-                0% {
-                    transform: perspective(200px) rotateX(0deg) rotateY(0deg);
-                }
-                50% {
-                    transform: perspective(200px) rotateX(-180deg) rotateY(0deg);
-                }
-                100% {
-                    transform: perspective(200px) rotateX(-180deg) rotateY(-180deg);
-                }
-                }
-            `;
-      document.head.appendChild(RBXRenderer.loadingIconStyle);
-      RBXRenderer.canvasContainer.appendChild(RBXRenderer.loadingIcon);
-      const onLoadConnection = API.Events.OnLoadingAssets.Connect((newIsLoading) => {
-        if (RBXRenderer.loadingIcon) {
-          RBXRenderer.loadingIcon.style.opacity = newIsLoading ? "1" : "0";
-        } else {
-          onLoadConnection.Disconnect();
-        }
-      });
+      RBXRenderer.createLoadingIconHTML();
     }
     if (FLAGS.USE_POST_PROCESSING) {
       RBXRenderer._createEffectComposer();
@@ -49144,10 +49218,10 @@ class RBXRenderer {
    * @param lightingType "WellLit" is the default lighting for RoAvatar, "Thumbnail" tries to match the Roblox thumbnail lighting
    * @param backgroundColorHex is the hex code for the background color, for example 0x2b2d33
   */
-  static setupScene(lightingType = "WellLit", backgroundColorHex = RBXRenderer.backgroundColorHex) {
+  static setupScene(lightingType = "WellLit", backgroundColorHex = RBXRenderer.backgroundColorHex, renderScene = RBXRenderer.firstScene) {
     RBXRenderer.backgroundColorHex = backgroundColorHex;
     const backgroundColor = new Color(backgroundColorHex);
-    RBXRenderer.scene.background = backgroundColor;
+    renderScene.scene.background = backgroundColor;
     let thumbnailAmbientVal = 138;
     thumbnailAmbientVal = 128;
     let ambientLightColor = void 0;
@@ -49157,8 +49231,8 @@ class RBXRenderer {
       ambientLightColor = new Color(100 / 255, 100 / 255, 100 / 255);
     }
     const ambientLight = new AmbientLight(ambientLightColor, Math.PI / 2);
-    RBXRenderer.scene.add(ambientLight);
-    RBXRenderer.ambientLight = ambientLight;
+    renderScene.scene.add(ambientLight);
+    renderScene.ambientLight = ambientLight;
     let directionalLightColor = void 0;
     const directionalLightVal = 0.7 * 0.9 * 2 * 0.4;
     if (lightingType === "Thumbnail") {
@@ -49168,7 +49242,7 @@ class RBXRenderer {
     }
     let directionalLightIntensity = 1;
     if (lightingType === "WellLit") {
-      directionalLightIntensity = this._wellLitDirectionalLightIntensity;
+      directionalLightIntensity = renderScene._wellLitDirectionalLightIntensity;
     }
     const directionalLight = new DirectionalLight(directionalLightColor, directionalLightIntensity);
     if (lightingType === "WellLit") {
@@ -49177,10 +49251,10 @@ class RBXRenderer {
       directionalLight.position.set(-0.47489210963249207 * 10, 0.8225368857383728 * 10, 0.3129066228866577 * 10);
     }
     if (lightingType === "WellLit") {
-      directionalLight.castShadow = RBXRenderer.shadowEnabled;
+      directionalLight.castShadow = renderScene.shadowEnabled;
     }
-    directionalLight.shadow.mapSize.width = RBXRenderer.shadowResolution[0];
-    directionalLight.shadow.mapSize.height = RBXRenderer.shadowResolution[1];
+    directionalLight.shadow.mapSize.width = renderScene.shadowResolution[0];
+    directionalLight.shadow.mapSize.height = renderScene.shadowResolution[1];
     const bottomOffset = 1.6;
     const shadowPhysicalSize = 5;
     directionalLight.shadow.camera.left = -shadowPhysicalSize;
@@ -49191,20 +49265,20 @@ class RBXRenderer {
     directionalLight.shadow.camera.far = 25;
     directionalLight.shadow.intensity = 0.5;
     directionalLight.target.position.set(0, 0, 0);
-    RBXRenderer.scene.add(directionalLight);
-    RBXRenderer.directionalLight = directionalLight;
+    renderScene.scene.add(directionalLight);
+    renderScene.directionalLight = directionalLight;
     if (lightingType === "WellLit") {
       const directionalLight2 = new DirectionalLight(16777215, 0.3);
       directionalLight2.position.set(5, -7, 5);
       directionalLight2.target.position.set(0, 0, 0);
-      RBXRenderer.scene.add(directionalLight2);
-      RBXRenderer.directionalLight2 = directionalLight2;
+      renderScene.scene.add(directionalLight2);
+      renderScene.directionalLight2 = directionalLight2;
     } else if (lightingType === "Thumbnail") {
       const directionalLight2 = new DirectionalLight(directionalLightColor, directionalLightIntensity * 0.5);
       directionalLight2.position.set(-0.47489210963249207 * -10, 0.8225368857383728 * -10, 0.3129066228866577 * -10);
       directionalLight2.target.position.set(0, 0, 0);
-      RBXRenderer.scene.add(directionalLight2);
-      RBXRenderer.directionalLight2 = directionalLight2;
+      renderScene.scene.add(directionalLight2);
+      renderScene.directionalLight2 = directionalLight2;
     }
     const planeGeometry = new PlaneGeometry(100, 100, 1, 1);
     const planeShadowMaterial = new ShadowMaterial({ opacity: 1 });
@@ -49212,27 +49286,27 @@ class RBXRenderer {
     shadowPlane.rotation.set(rad(-90), 0, 0);
     shadowPlane.position.set(0, 0, 0);
     shadowPlane.receiveShadow = true;
-    RBXRenderer.shadowPlane = shadowPlane;
-    RBXRenderer.scene.add(shadowPlane);
+    renderScene.shadowPlane = shadowPlane;
+    renderScene.scene.add(shadowPlane);
     const planeSolidColorMaterial = new MeshBasicMaterial({ color: backgroundColor });
     const plane = new Mesh(planeGeometry, planeSolidColorMaterial);
     plane.rotation.set(rad(-90), 0, 0);
     plane.position.set(0, 0, 0);
     plane.receiveShadow = false;
-    RBXRenderer.plane = plane;
-    RBXRenderer.scene.add(plane);
+    renderScene.plane = plane;
+    renderScene.scene.add(plane);
   }
   /**Sets up orbit controls */
-  static setupControls() {
+  static setupControls(renderScene = RBXRenderer.firstScene) {
     if (!RBXRenderer.renderer) return;
-    const controls = new OrbitControls(RBXRenderer.camera, RBXRenderer.renderer.domElement);
+    const controls = new OrbitControls(renderScene.camera, RBXRenderer.renderer.domElement);
     controls.maxDistance = 25;
     controls.zoomSpeed = 2;
     controls.target.set(...RBXRenderer.orbitControlsTarget);
     log(false, controls.target);
-    RBXRenderer.controls = controls;
-    RBXRenderer.camera.position.set(RBXRenderer.lookAwayVector[0] * RBXRenderer.lookAwayDistance, 3 + RBXRenderer.lookAwayVector[1] * RBXRenderer.lookAwayDistance, RBXRenderer.lookAwayVector[2] * RBXRenderer.lookAwayDistance);
-    RBXRenderer.camera.lookAt(new Vector3$1(...RBXRenderer.orbitControlsTarget));
+    renderScene.controls = controls;
+    renderScene.camera.position.set(renderScene.lookAwayVector[0] * renderScene.lookAwayDistance, 3 + renderScene.lookAwayVector[1] * renderScene.lookAwayDistance, renderScene.lookAwayVector[2] * renderScene.lookAwayDistance);
+    renderScene.camera.lookAt(new Vector3$1(...RBXRenderer.orbitControlsTarget));
     controls.update();
   }
   /**
@@ -49240,16 +49314,18 @@ class RBXRenderer {
    */
   static setBackgroundColor(colorHex) {
     RBXRenderer.backgroundColorHex = colorHex;
-    if (RBXRenderer.backgroundTransparent) {
-      RBXRenderer.scene.background = null;
-    } else {
-      RBXRenderer.scene.background = new Color(RBXRenderer.backgroundColorHex);
-    }
-    if (RBXRenderer.plane) {
-      RBXRenderer.plane.visible = !RBXRenderer.backgroundTransparent;
-    }
-    if (RBXRenderer.plane) {
-      RBXRenderer.plane.material = new MeshBasicMaterial({ color: colorHex });
+    for (const renderScene of RBXRenderer.scenes) {
+      if (RBXRenderer.backgroundTransparent) {
+        renderScene.scene.background = null;
+      } else {
+        renderScene.scene.background = new Color(RBXRenderer.backgroundColorHex);
+      }
+      if (renderScene.plane) {
+        renderScene.plane.visible = !RBXRenderer.backgroundTransparent;
+      }
+      if (renderScene.plane) {
+        renderScene.plane.material = new MeshBasicMaterial({ color: colorHex });
+      }
     }
   }
   /**
@@ -49258,60 +49334,103 @@ class RBXRenderer {
    */
   static setBackgroundTransparent(transparent) {
     RBXRenderer.backgroundTransparent = transparent;
-    if (RBXRenderer.backgroundTransparent) {
-      RBXRenderer.scene.background = null;
-    } else {
-      RBXRenderer.scene.background = new Color(RBXRenderer.backgroundColorHex);
-    }
-    if (RBXRenderer.plane) {
-      RBXRenderer.plane.visible = !RBXRenderer.backgroundTransparent;
+    for (const renderScene of RBXRenderer.scenes) {
+      if (RBXRenderer.backgroundTransparent) {
+        renderScene.scene.background = null;
+      } else {
+        renderScene.scene.background = new Color(RBXRenderer.backgroundColorHex);
+      }
+      if (renderScene.plane) {
+        renderScene.plane.visible = !RBXRenderer.backgroundTransparent;
+      }
     }
   }
   /**Makes the renderer render a new frame on every animationFrame */
-  static animate() {
+  static animate(shouldRequestAnimationFrame = true) {
+    if (!RBXRenderer.renderer) return;
+    RBXRenderer.renderScene(RBXRenderer.firstScene);
+    if (shouldRequestAnimationFrame) {
+      requestAnimationFrame(() => {
+        RBXRenderer.animate();
+      });
+    }
+  }
+  static animateAll(shouldRequestAnimationFrame = true) {
+    if (!RBXRenderer.renderer) return;
+    for (const renderScene of RBXRenderer.scenes) {
+      RBXRenderer.renderScene(renderScene, renderScene === RBXRenderer.firstScene);
+    }
+    if (shouldRequestAnimationFrame) {
+      requestAnimationFrame(() => {
+        RBXRenderer.animateAll();
+      });
+    }
+  }
+  static renderScene(renderScene, autoClear = true) {
     if (!RBXRenderer.renderer) return;
+    RBXRenderer.renderer.autoClear = autoClear;
+    if (!autoClear) {
+      RBXRenderer.renderer.clearDepth();
+    }
     RBXRenderer.renderer.setRenderTarget(null);
-    if (RBXRenderer.effectComposer) {
-      RBXRenderer.effectComposer.render();
+    let [x, y] = [0, 0];
+    let [width, height] = RBXRenderer.resolution;
+    if (renderScene.viewport) {
+      x = renderScene.viewport[0];
+      y = renderScene.viewport[1];
+      width = renderScene.viewport[2];
+      height = renderScene.viewport[3];
+    }
+    RBXRenderer.renderer.setViewport(x, y, width, height);
+    if (renderScene.scissor) {
+      RBXRenderer.renderer.setScissorTest(true);
+      RBXRenderer.renderer.setScissor(...renderScene.scissor);
     } else {
-      RBXRenderer.renderer.render(RBXRenderer.scene, RBXRenderer.camera);
+      RBXRenderer.renderer.setScissorTest(false);
     }
-    requestAnimationFrame(() => {
-      RBXRenderer.animate();
-    });
+    renderScene.camera.aspect = width / height;
+    renderScene.camera.updateProjectionMatrix();
+    if (width > 0 && height > 0) {
+      if (renderScene.effectComposer) {
+        renderScene.effectComposer.render();
+      } else {
+        RBXRenderer.renderer.render(renderScene.scene, renderScene.camera);
+      }
+    }
+    RBXRenderer.renderer.autoClear = true;
   }
-  static _createEffectComposer() {
+  static _createEffectComposer(renderScene = RBXRenderer.firstScene) {
     if (!RBXRenderer.renderer) return;
-    RBXRenderer.effectComposer = new EffectComposer(RBXRenderer.renderer);
-    const renderPass = new RenderPass(RBXRenderer.scene, RBXRenderer.camera);
-    RBXRenderer.effectComposer.addPass(renderPass);
+    renderScene.effectComposer = new EffectComposer(RBXRenderer.renderer);
+    const renderPass = new RenderPass(renderScene.scene, renderScene.camera);
+    renderScene.effectComposer.addPass(renderPass);
     const resolution = new Vector2$1(420, 420);
     const bloomPass = new UnrealBloomPass(resolution, 0.15, 1e-4, 0.9);
-    RBXRenderer.effectComposer.addPass(bloomPass);
+    renderScene.effectComposer.addPass(bloomPass);
     if (!FLAGS.POST_PROCESSING_IS_DOUBLE_SIZE) {
       const fxaaPass = new FXAAPass();
-      RBXRenderer.effectComposer.addPass(fxaaPass);
+      renderScene.effectComposer.addPass(fxaaPass);
     }
     const outputPass = new OutputPass();
-    RBXRenderer.effectComposer.addPass(outputPass);
+    renderScene.effectComposer.addPass(outputPass);
   }
   /**Removes an instance from the renderer */
-  static removeInstance(instance) {
+  static removeInstance(instance, renderScene = RBXRenderer.firstScene) {
     if (!RBXRenderer.renderer) return;
-    const desc = RBXRenderer.renderDescs.get(instance);
+    const desc = renderScene.renderDescs.get(instance);
     if (desc) {
-      desc.dispose(RBXRenderer.renderer, RBXRenderer.scene);
+      desc.dispose(RBXRenderer.renderer, renderScene.scene);
     }
-    RBXRenderer.renderDescs.delete(instance);
-    RBXRenderer.isRenderingMesh.delete(instance);
+    renderScene.renderDescs.delete(instance);
+    renderScene.isRenderingMesh.delete(instance);
     for (const child of instance.GetChildren()) {
-      RBXRenderer.removeInstance(child);
+      RBXRenderer.removeInstance(child, renderScene);
     }
   }
-  static _addRenderDesc(instance, auth, DescClass) {
+  static _addRenderDesc(instance, auth, DescClass, renderScene) {
     if (!RBXRenderer.renderer) return;
-    const oldDesc = RBXRenderer.renderDescs.get(instance);
-    const newDesc = new DescClass();
+    const oldDesc = renderScene.renderDescs.get(instance);
+    const newDesc = new DescClass(renderScene);
     newDesc.fromInstance(instance);
     if (oldDesc && !oldDesc.needsRegeneration(newDesc)) {
       if (!oldDesc.isSame(newDesc)) {
@@ -49319,15 +49438,15 @@ class RBXRenderer {
         oldDesc.updateResults();
       }
     } else {
-      if (!RBXRenderer.isRenderingMesh.get(instance)) {
+      if (!renderScene.isRenderingMesh.get(instance)) {
         newDesc.results = oldDesc?.results;
-        RBXRenderer.renderDescs.set(instance, newDesc);
-        RBXRenderer.isRenderingMesh.set(instance, true);
-        newDesc.compileResults(RBXRenderer.renderer, RBXRenderer.scene).then((results) => {
+        renderScene.renderDescs.set(instance, newDesc);
+        renderScene.isRenderingMesh.set(instance, true);
+        newDesc.compileResults(RBXRenderer.renderer, renderScene.scene).then((results) => {
           if (results && !(results instanceof Response)) {
             newDesc.updateResults();
-            if (RBXRenderer.renderDescs.get(instance) && RBXRenderer.renderer) {
-              oldDesc?.dispose(RBXRenderer.renderer, RBXRenderer.scene);
+            if (renderScene.renderDescs.get(instance) && RBXRenderer.renderer) {
+              oldDesc?.dispose(RBXRenderer.renderer, renderScene.scene);
               for (const result of results) {
                 if (result instanceof SkinnedMesh && newDesc instanceof ObjectDesc) {
                   const skeleton = newDesc.skeletonDesc?.skeleton;
@@ -49337,20 +49456,20 @@ class RBXRenderer {
                       if (FLAGS.USE_LOCAL_SKELETONDESC) {
                         result.add(newDesc.skeletonDesc.rootBone);
                       } else {
-                        RBXRenderer.scene.add(newDesc.skeletonDesc.rootBone);
+                        renderScene.scene.add(newDesc.skeletonDesc.rootBone);
                       }
                     }
                     result.bind(skeleton);
-                    RBXRenderer.scene.add(result);
+                    renderScene.scene.add(result);
                   }
                 } else {
-                  RBXRenderer.scene.add(result);
+                  renderScene.scene.add(result);
                 }
               }
-              RBXRenderer.isRenderingMesh.set(instance, false);
-              RBXRenderer.addInstance(instance, auth);
+              renderScene.isRenderingMesh.set(instance, false);
+              RBXRenderer.addInstance(instance, auth, renderScene);
             } else if (RBXRenderer.renderer) {
-              newDesc.dispose(RBXRenderer.renderer, RBXRenderer.scene);
+              newDesc.dispose(RBXRenderer.renderer, renderScene.scene);
             }
           } else {
             warn(false, "Failed to compile mesh", this, results);
@@ -49358,17 +49477,17 @@ class RBXRenderer {
         });
       }
     }
-    if (!RBXRenderer.destroyConnections.get(instance)) {
-      RBXRenderer.destroyConnections.set(instance, instance.Destroying.Connect(() => {
-        RBXRenderer.removeInstance(instance);
-        const connection = RBXRenderer.destroyConnections.get(instance);
+    if (!renderScene.destroyConnections.get(instance)) {
+      renderScene.destroyConnections.set(instance, instance.Destroying.Connect(() => {
+        RBXRenderer.removeInstance(instance, renderScene);
+        const connection = renderScene.destroyConnections.get(instance);
         connection?.Disconnect();
-        RBXRenderer.destroyConnections.delete(instance);
+        renderScene.destroyConnections.delete(instance);
       }));
     }
   }
   /**Adds an instance to the renderer or updates it */
-  static addInstance(instance, auth) {
+  static addInstance(instance, auth, renderScene = RBXRenderer.firstScene) {
     const isDecal = instance.className === "Decal";
     const isBakedDecal = isDecal && !instance.FindFirstChildOfClass("WrapTextureTransfer");
     let isFirstDecal = true;
@@ -49381,12 +49500,12 @@ class RBXRenderer {
       }
     }
     if (ObjectDescClassTypes.includes(instance.className) && !isBakedDecal && (!isDecal || isFirstDecal)) {
-      RBXRenderer._addRenderDesc(instance, auth, ObjectDesc);
+      RBXRenderer._addRenderDesc(instance, auth, ObjectDesc, renderScene);
     } else if (EmitterGroupDescClassTypes.includes(instance.className)) {
-      RBXRenderer._addRenderDesc(instance, auth, EmitterGroupDesc);
+      RBXRenderer._addRenderDesc(instance, auth, EmitterGroupDesc, renderScene);
     }
     for (const child of instance.GetChildren()) {
-      RBXRenderer.addInstance(child, auth);
+      RBXRenderer.addInstance(child, auth, renderScene);
     }
   }
   static setRendererSize(width, height) {
@@ -49399,8 +49518,6 @@ class RBXRenderer {
     if (FLAGS.USE_POST_PROCESSING && FLAGS.POST_PROCESSING_IS_DOUBLE_SIZE) {
       RBXRenderer.renderer.setSize(RBXRenderer.resolution[0] * 2, RBXRenderer.resolution[1] * 2);
     }
-    RBXRenderer.camera.aspect = width / height;
-    RBXRenderer.camera.updateProjectionMatrix();
   }
   /**
    * @deprecated Use getRendererElement instead which includes the loading icon
@@ -49416,11 +49533,12 @@ class RBXRenderer {
   static getRendererElement() {
     return RBXRenderer.canvasContainer;
   }
+  /**@deprecated This can only get the first renderScene's camera */
   static getRendererCamera() {
     return RBXRenderer.camera;
   }
-  static getCameraCFrame() {
-    const camera = RBXRenderer.camera;
+  static getCameraCFrame(renderScene = RBXRenderer.firstScene) {
+    const camera = renderScene.camera;
     const pos = camera.position;
     let rot = camera.rotation.clone();
     rot = rot.reorder("YXZ");
@@ -49429,34 +49547,36 @@ class RBXRenderer {
     cf.Orientation = [deg(rot.x), deg(rot.y), deg(rot.z)];
     return cf;
   }
-  static setCameraCFrame(cameraCF) {
+  static setCameraCFrame(cameraCF, renderScene = RBXRenderer.firstScene) {
     const camPos = new Vector3$1();
     const camQuat = new Quaternion();
     const camScale = new Vector3$1();
     const camMatrix = cameraCF.getTHREEMatrix();
     camMatrix.decompose(camPos, camQuat, camScale);
-    RBXRenderer.getRendererCamera().position.set(...camPos.toArray());
-    RBXRenderer.getRendererCamera().quaternion.set(...camQuat.toArray());
-    RBXRenderer.getRendererCamera().updateMatrixWorld();
+    renderScene.camera.position.set(...camPos.toArray());
+    renderScene.camera.quaternion.set(...camQuat.toArray());
+    renderScene.camera.updateMatrixWorld();
   }
-  static setCameraFov(fov2) {
-    RBXRenderer.getRendererCamera().fov = fov2;
+  static setCameraFov(fov2, renderScene = RBXRenderer.firstScene) {
+    renderScene.camera.fov = fov2;
   }
+  /**@deprecated This can only get the first renderScene's controls */
   static getRendererControls() {
     return RBXRenderer.controls;
   }
   static getRenderer() {
     return RBXRenderer.renderer;
   }
+  /**@deprecated This can only get the first renderScene's scene */
   static getScene() {
-    return RBXRenderer.scene;
+    return RBXRenderer.firstScene;
   }
   /**@deprecated
    * This function is unstable and can throw errors, but might work
    */
-  static exportScene() {
+  static exportScene(renderScene = RBXRenderer.firstScene) {
     const exporter = new GLTFExporter();
-    exporter.parse(RBXRenderer.scene, (gltf) => {
+    exporter.parse(renderScene.scene, (gltf) => {
       if (gltf instanceof ArrayBuffer) {
         saveByteArray([gltf], "scene.glb");
       } else {
@@ -49545,7 +49665,7 @@ class HSR {
         if (FLAGS.HSR_SHOW_RAY) {
           const geometry = new BufferGeometry().setFromPoints([new Vector3$1(...ray.origin), new Vector3$1(...ray.end)]);
           const line = new Line(geometry, rayHit ? hitMaterial : missMaterial);
-          RBXRenderer.getScene().add(line);
+          RBXRenderer.scene.add(line);
         }
       }
       this.innerHits[i] = hits;
@@ -49605,6 +49725,22 @@ function getHigher(a, b) {
     a.Z > b.Z ? a.Z : b.Z
   );
 }
+function getExtentsForParts(parts, includeTransform) {
+  let lowerExtents = new Vector32(0, 0, 0);
+  let higherExtents = new Vector32(0, 0, 0);
+  for (const child of parts) {
+    if (child.className === "Part" || child.className === "MeshPart") {
+      const cframe = traverseRigCFrame(child, includeTransform, true);
+      const size = child.Prop("Size");
+      const corners = getCorners(cframe, size);
+      for (const corner of corners) {
+        lowerExtents = getLower(lowerExtents, new Vector32().fromVec3(corner.Position));
+        higherExtents = getHigher(higherExtents, new Vector32().fromVec3(corner.Position));
+      }
+    }
+  }
+  return [lowerExtents, higherExtents];
+}
 function getExtents(cframe, parts) {
   const inverseCF = cframe.inverse();
   let lowerExtents = new Vector32(0, 0, 0);
@@ -49679,7 +49815,6 @@ class OutfitRenderer {
   currentRig;
   /**Instance for the Model of the current outfit */
   currentRigType;
-  rigPath;
   doCameraUpdateOnLoad = true;
   /**Makes camera update when new avatar has loaded */
   doCameraUpdate = false;
@@ -49691,17 +49826,18 @@ class OutfitRenderer {
   animationInterval;
   animationFPS = 60;
   deltaTimeMultiplier = 1;
+  renderScene = RBXRenderer.firstScene;
   /**
    * Creates a new OutfitRenderer which makes it easy to render outfits
    * @param auth The authentication object, you should have one you use for everything
    * @param outfit The outfit you want to render, it can be updated later by calling setOutfit()
-   * @param rigPath The path that contains RigR6.rbxm and RigR15.rbxm, should always be "roavatar://" as rig path is now controlled by FLAGS
+   * @param renderScene The scene the outfit should be rendered in
    */
-  constructor(auth, outfit, rigPath = "roavatar://") {
+  constructor(auth, outfit, renderScene = RBXRenderer.firstScene) {
     this.auth = auth;
     this.outfit = outfit;
     this.currentRigType = outfit.playerAvatarType;
-    this.rigPath = rigPath;
+    this.renderScene = renderScene;
     this._updateOutfit();
   }
   /**
@@ -49716,12 +49852,12 @@ class OutfitRenderer {
           this.currentRig = void 0;
         }
         this.currentRigType = newRigType;
-        API.Asset.GetRBX(`${this.rigPath}Rig${this.currentRigType}.rbxm`, void 0).then((result) => {
+        API.Asset.GetRBX(`roavatar://Rig${this.currentRigType}.rbxm`, void 0).then((result) => {
           if (result instanceof RBX) {
             const newRig = result.generateTree().GetChildren()[0];
             this.currentRig = newRig;
             this.currentlyChangingRig = false;
-            RBXRenderer.addInstance(this.currentRig, this.auth);
+            RBXRenderer.addInstance(this.currentRig, this.auth, this.renderScene);
             resolve(newRig);
           } else {
             resolve(result);
@@ -49754,7 +49890,7 @@ class OutfitRenderer {
           hrpWrapper.applyDescription(humanoid).then((result) => {
             this.currentlyUpdating = false;
             if (this.currentRig) {
-              RBXRenderer.addInstance(this.currentRig, this.auth);
+              RBXRenderer.addInstance(this.currentRig, this.auth, this.renderScene);
               if (this.doCameraUpdateOnLoad) {
                 this.centerCamera();
               }
@@ -49791,8 +49927,8 @@ class OutfitRenderer {
     if (this.currentRig) {
       const upperTorso = this.currentRig.FindFirstChild("HumanoidRootPart");
       if (upperTorso) {
-        const controls = RBXRenderer.getRendererControls();
-        const camera = RBXRenderer.getRendererCamera();
+        const controls = this.renderScene.controls;
+        const camera = this.renderScene.camera;
         const pos = upperTorso.Prop("Position");
         if (controls) {
           const offset = new Vector3$1().subVectors(camera.position, controls.target);
@@ -49823,7 +49959,7 @@ class OutfitRenderer {
             const animatorW = new AnimatorWrapper(animator);
             animatorW.renderAnimation(deltaTime);
             this.currentRig.preRender();
-            RBXRenderer.addInstance(this.currentRig, this.auth);
+            RBXRenderer.addInstance(this.currentRig, this.auth, this.renderScene);
           }
         }
       }
@@ -49867,6 +50003,7 @@ export {
   AccessoryAssetTypes,
   AccessoryDescriptionWrapper,
   AccessoryType,
+  AccessoryWrapper,
   ActualBundleTypes,
   AllAccessorySorts,
   AllAnimationSorts,
@@ -49878,6 +50015,7 @@ export {
   AllHeadShapes,
   AllInstances,
   AlphaMode,
+  AnimationConstraintWrapper,
   AnimationPropToName,
   AnimationTrack,
   AnimatorWrapper,
@@ -49892,6 +50030,7 @@ export {
   AvatarType,
   BodyColor3s,
   BodyColors,
+  BodyColorsWrapper,
   BodyPart,
   BodyPartDescriptionWrapper,
   BodyPartEnumToNames,
@@ -49911,6 +50050,7 @@ export {
   Content,
   ContentMap,
   DataType,
+  DecalWrapper,
   DefaultAnimations,
   DefaultAnimationsR6,
   DefaultGetWorkerFunc,
@@ -49937,10 +50077,12 @@ export {
   MakeupAssetTypes,
   MakeupDescriptionWrapper,
   MakeupType,
+  ManualWeldWrapper,
   MaxOneOfAssetTypes,
   MaxPerAsset,
   MeshType,
   ModelWrapper,
+  Motor6DWrapper,
   NeverLayeredAccessoryTypes,
   NormalId,
   NumberRange,
@@ -49957,6 +50099,7 @@ export {
   RBFDeformerPatch,
   RBX,
   RBXRenderer,
+  RBXRendererScene,
   RNG,
   Ray3 as Ray,
   RegisterWrappers,
@@ -49984,6 +50127,7 @@ export {
   Vector32 as Vector3,
   Wait,
   WearableAssetTypes,
+  WeldWrapper,
   WorkerTypeToFunction,
   WrapLayerAutoSkin,
   accessoryRefinementLowerBounds,
@@ -50022,11 +50166,14 @@ export {
   download,
   exposeAPI,
   exposeMesh,
+  fileMeshToTHREEGeometry,
   floor,
   gaussian_rbf,
   generateUUIDv4,
   getCameraCFrameForHeadshotCustomized,
   getDistIndexArray,
+  getExtents,
+  getExtentsForParts,
   getHeadExtents,
   getOffsetArray,
   getOriginalSize,
@@ -50082,5 +50229,6 @@ export {
   triangleNormal,
   versionToNumber,
   vertPosToChunkPos,
-  xmlMagic
+  xmlMagic,
+  zoomExtents
 };

package/package.json

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