roavatar-renderer 1.7.3 → 1.8.0

package/README.md

@@ -42,6 +42,8 @@ Basic example on how to load an avatar using OutfitRenderer (to make it simpler)
     RBXRenderer.setBackgroundColor( 0xbbbbbb )
     RBXRenderer.setRendererSize(1000,500)
     RBXRenderer.setBackgroundTransparent(false)
+    //scene customization
+    RBXRenderer.firstScene.wellLitDirectionalLightIntensity *= 2.5 //recommended
     //add renderer to document
     document.body.appendChild(RBXRenderer.getRendererElement())
 

package/dist/index.d.ts

@@ -383,7 +383,7 @@ export declare const API: {
     };
     Inventory: {
         GetInventory: (userId: number, assetType: number, cursor?: string) => Promise<Response>;
-        IsItemOwned: (userId: number, itemType: string, assetId: number) => Promise<any>;
+        IsItemOwned: (userId: number, itemType: string, assetId: number) => Promise<boolean | Response>;
     };
     Users: {
         GetUserInfo: () => Promise<UserInfo | undefined>;
@@ -413,6 +413,11 @@ export declare const API: {
     Subscriptions: {
         HasPlus: () => Promise<Response | boolean>;
     };
+    AvatarAIGenerationService: {
+        GenerateBackground: (auth: Authentication, prompt: string) => Promise<Response | string>;
+        GetBackground: (generationId: string) => Promise<Response | GetBackground_Result>;
+        UploadBackground: (auth: Authentication, generationId: string, displayName: string, description?: string) => Promise<Response | string>;
+    };
     RBLXGet: typeof RBLXGet;
     RBLXPost: typeof RBLXPost;
     RBLXDelete: typeof RBLXDelete;
@@ -703,6 +708,8 @@ export declare class BackgroundRenderer {
     affectSceneLighting: boolean;
     cameraAffectsTransparency: boolean;
     cameraAffectsRotation: boolean;
+    forceImage: string | undefined;
+    forceColor: Color3 | undefined;
     lastFrameTime: number;
     animationInterval?: NodeJS.Timeout;
     animationFPS: number;
@@ -1092,6 +1099,7 @@ export declare class CFrame {
     fromRotationMatrix(r00: number, r01: number, r02: number, r10: number, r11: number, r12: number, r20: number, r21: number, r22: number, order?: string): void;
     lookVector(): Vec3;
     upVector(): Vec3;
+    rightVector(): Vec3;
     static lookAt(eye: Vec3, target: Vec3, up?: Vec3): CFrame;
     static fromEulerAngles(rx: number, ry: number, rz: number, order?: THREE.EulerOrder): CFrame;
     rotationOnly(): CFrame;
@@ -1623,6 +1631,8 @@ export declare const FLAGS: {
     GEAR_ENABLED: boolean;
     /**makes Audio instances play sound when played */
     AUDIO_ENABLED: boolean;
+    /**makes Beam instances render */
+    BEAMS_ENABLED: boolean;
     /**enables full texture compilation using ThreeJS RenderTarget */
     USE_RENDERTARGET: boolean;
     /**the renderer will attempt to restore the webgl context when it is lost */
@@ -1790,6 +1800,13 @@ export declare function GetAttachedPart(accessory: Instance, rig: Instance): Ins
 
 export declare function getAvatarCameraCFrame(character: Instance, applyEmote?: () => void, isFallbackEmoteApplied?: boolean, fieldOfViewDeg?: number, cameraOptionsOverride?: Partial<CameraOptions>): Instance | undefined;
 
+export declare interface GetBackground_Result {
+    generationId: string;
+    status: "Generating" | "Completed" | string;
+    presignedUrl: string | null;
+    failureReason: unknown | null;
+}
+
 export declare function getCameraCFrame(targetCFrame: CFrame, relativePos: Vector3): CFrame;
 
 /**
@@ -4011,6 +4028,13 @@ export declare const SpecialLayeredAssetTypes: string[];
 
 export declare const StringBufferProperties: string[];
 
+/**@category DataModelEnum */
+export declare const TextureMode: {
+    Stretch: number;
+    Wrap: number;
+    Static: number;
+};
+
 declare type ThreePoseCorrective = Vec3;
 
 /**
@@ -4129,7 +4153,7 @@ export declare class UDim2 {
     clone(): UDim2;
 }
 
-declare type UserInfo = {
+export declare type UserInfo = {
     id: number;
     name: string;
     displayName: string;

package/dist/index.js

@@ -14978,6 +14978,382 @@ class BoxGeometry extends BufferGeometry {
     return new BoxGeometry(data.width, data.height, data.depth, data.widthSegments, data.heightSegments, data.depthSegments);
   }
 }
+class Curve {
+  /**
+   * Constructs a new curve.
+   */
+  constructor() {
+    this.type = "Curve";
+    this.arcLengthDivisions = 200;
+    this.needsUpdate = false;
+    this.cacheArcLengths = null;
+  }
+  /**
+   * This method returns a vector in 2D or 3D space (depending on the curve definition)
+   * for the given interpolation factor.
+   *
+   * @abstract
+   * @param {number} t - A interpolation factor representing a position on the curve. Must be in the range `[0,1]`.
+   * @param {(Vector2|Vector3)} [optionalTarget] - The optional target vector the result is written to.
+   * @return {(Vector2|Vector3)} The position on the curve. It can be a 2D or 3D vector depending on the curve definition.
+   */
+  getPoint() {
+    warn$1("Curve: .getPoint() not implemented.");
+  }
+  /**
+   * This method returns a vector in 2D or 3D space (depending on the curve definition)
+   * for the given interpolation factor. Unlike {@link Curve#getPoint}, this method honors the length
+   * of the curve which equidistant samples.
+   *
+   * @param {number} u - A interpolation factor representing a position on the curve. Must be in the range `[0,1]`.
+   * @param {(Vector2|Vector3)} [optionalTarget] - The optional target vector the result is written to.
+   * @return {(Vector2|Vector3)} The position on the curve. It can be a 2D or 3D vector depending on the curve definition.
+   */
+  getPointAt(u, optionalTarget) {
+    const t = this.getUtoTmapping(u);
+    return this.getPoint(t, optionalTarget);
+  }
+  /**
+   * This method samples the curve via {@link Curve#getPoint} and returns an array of points representing
+   * the curve shape.
+   *
+   * @param {number} [divisions=5] - The number of divisions.
+   * @return {Array<(Vector2|Vector3)>} An array holding the sampled curve values. The number of points is `divisions + 1`.
+   */
+  getPoints(divisions = 5) {
+    const points = [];
+    for (let d = 0; d <= divisions; d++) {
+      points.push(this.getPoint(d / divisions));
+    }
+    return points;
+  }
+  // Get sequence of points using getPointAt( u )
+  /**
+   * This method samples the curve via {@link Curve#getPointAt} and returns an array of points representing
+   * the curve shape. Unlike {@link Curve#getPoints}, this method returns equi-spaced points across the entire
+   * curve.
+   *
+   * @param {number} [divisions=5] - The number of divisions.
+   * @return {Array<(Vector2|Vector3)>} An array holding the sampled curve values. The number of points is `divisions + 1`.
+   */
+  getSpacedPoints(divisions = 5) {
+    const points = [];
+    for (let d = 0; d <= divisions; d++) {
+      points.push(this.getPointAt(d / divisions));
+    }
+    return points;
+  }
+  /**
+   * Returns the total arc length of the curve.
+   *
+   * @return {number} The length of the curve.
+   */
+  getLength() {
+    const lengths = this.getLengths();
+    return lengths[lengths.length - 1];
+  }
+  /**
+   * Returns an array of cumulative segment lengths of the curve.
+   *
+   * @param {number} [divisions=this.arcLengthDivisions] - The number of divisions.
+   * @return {Array<number>} An array holding the cumulative segment lengths.
+   */
+  getLengths(divisions = this.arcLengthDivisions) {
+    if (this.cacheArcLengths && this.cacheArcLengths.length === divisions + 1 && !this.needsUpdate) {
+      return this.cacheArcLengths;
+    }
+    this.needsUpdate = false;
+    const cache = [];
+    let current, last = this.getPoint(0);
+    let sum = 0;
+    cache.push(0);
+    for (let p2 = 1; p2 <= divisions; p2++) {
+      current = this.getPoint(p2 / divisions);
+      sum += current.distanceTo(last);
+      cache.push(sum);
+      last = current;
+    }
+    this.cacheArcLengths = cache;
+    return cache;
+  }
+  /**
+   * Update the cumulative segment distance cache. The method must be called
+   * every time curve parameters are changed. If an updated curve is part of a
+   * composed curve like {@link CurvePath}, this method must be called on the
+   * composed curve, too.
+   */
+  updateArcLengths() {
+    this.needsUpdate = true;
+    this.getLengths();
+  }
+  /**
+   * Given an interpolation factor in the range `[0,1]`, this method returns an updated
+   * interpolation factor in the same range that can be ued to sample equidistant points
+   * from a curve.
+   *
+   * @param {number} u - The interpolation factor.
+   * @param {?number} distance - An optional distance on the curve.
+   * @return {number} The updated interpolation factor.
+   */
+  getUtoTmapping(u, distance2 = null) {
+    const arcLengths = this.getLengths();
+    let i = 0;
+    const il = arcLengths.length;
+    let targetArcLength;
+    if (distance2) {
+      targetArcLength = distance2;
+    } else {
+      targetArcLength = u * arcLengths[il - 1];
+    }
+    let low = 0, high = il - 1, comparison;
+    while (low <= high) {
+      i = Math.floor(low + (high - low) / 2);
+      comparison = arcLengths[i] - targetArcLength;
+      if (comparison < 0) {
+        low = i + 1;
+      } else if (comparison > 0) {
+        high = i - 1;
+      } else {
+        high = i;
+        break;
+      }
+    }
+    i = high;
+    if (arcLengths[i] === targetArcLength) {
+      return i / (il - 1);
+    }
+    const lengthBefore = arcLengths[i];
+    const lengthAfter = arcLengths[i + 1];
+    const segmentLength = lengthAfter - lengthBefore;
+    const segmentFraction = (targetArcLength - lengthBefore) / segmentLength;
+    const t = (i + segmentFraction) / (il - 1);
+    return t;
+  }
+  /**
+   * Returns a unit vector tangent for the given interpolation factor.
+   * If the derived curve does not implement its tangent derivation,
+   * two points a small delta apart will be used to find its gradient
+   * which seems to give a reasonable approximation.
+   *
+   * @param {number} t - The interpolation factor.
+   * @param {(Vector2|Vector3)} [optionalTarget] - The optional target vector the result is written to.
+   * @return {(Vector2|Vector3)} The tangent vector.
+   */
+  getTangent(t, optionalTarget) {
+    const delta = 1e-4;
+    let t1 = t - delta;
+    let t2 = t + delta;
+    if (t1 < 0) t1 = 0;
+    if (t2 > 1) t2 = 1;
+    const pt1 = this.getPoint(t1);
+    const pt2 = this.getPoint(t2);
+    const tangent = optionalTarget || (pt1.isVector2 ? new Vector2$1() : new Vector3$1());
+    tangent.copy(pt2).sub(pt1).normalize();
+    return tangent;
+  }
+  /**
+   * Same as {@link Curve#getTangent} but with equidistant samples.
+   *
+   * @param {number} u - The interpolation factor.
+   * @param {(Vector2|Vector3)} [optionalTarget] - The optional target vector the result is written to.
+   * @return {(Vector2|Vector3)} The tangent vector.
+   * @see {@link Curve#getPointAt}
+   */
+  getTangentAt(u, optionalTarget) {
+    const t = this.getUtoTmapping(u);
+    return this.getTangent(t, optionalTarget);
+  }
+  /**
+   * Generates the Frenet Frames. Requires a curve definition in 3D space. Used
+   * in geometries like {@link TubeGeometry} or {@link ExtrudeGeometry}.
+   *
+   * @param {number} segments - The number of segments.
+   * @param {boolean} [closed=false] - Whether the curve is closed or not.
+   * @return {{tangents: Array<Vector3>, normals: Array<Vector3>, binormals: Array<Vector3>}} The Frenet Frames.
+   */
+  computeFrenetFrames(segments, closed = false) {
+    const normal = new Vector3$1();
+    const tangents = [];
+    const normals = [];
+    const binormals = [];
+    const vec = new Vector3$1();
+    const mat = new Matrix4();
+    for (let i = 0; i <= segments; i++) {
+      const u = i / segments;
+      tangents[i] = this.getTangentAt(u, new Vector3$1());
+    }
+    normals[0] = new Vector3$1();
+    binormals[0] = new Vector3$1();
+    let min = Number.MAX_VALUE;
+    const tx = Math.abs(tangents[0].x);
+    const ty = Math.abs(tangents[0].y);
+    const tz = Math.abs(tangents[0].z);
+    if (tx <= min) {
+      min = tx;
+      normal.set(1, 0, 0);
+    }
+    if (ty <= min) {
+      min = ty;
+      normal.set(0, 1, 0);
+    }
+    if (tz <= min) {
+      normal.set(0, 0, 1);
+    }
+    vec.crossVectors(tangents[0], normal).normalize();
+    normals[0].crossVectors(tangents[0], vec);
+    binormals[0].crossVectors(tangents[0], normals[0]);
+    for (let i = 1; i <= segments; i++) {
+      normals[i] = normals[i - 1].clone();
+      binormals[i] = binormals[i - 1].clone();
+      vec.crossVectors(tangents[i - 1], tangents[i]);
+      if (vec.length() > Number.EPSILON) {
+        vec.normalize();
+        const theta = Math.acos(clamp$1(tangents[i - 1].dot(tangents[i]), -1, 1));
+        normals[i].applyMatrix4(mat.makeRotationAxis(vec, theta));
+      }
+      binormals[i].crossVectors(tangents[i], normals[i]);
+    }
+    if (closed === true) {
+      let theta = Math.acos(clamp$1(normals[0].dot(normals[segments]), -1, 1));
+      theta /= segments;
+      if (tangents[0].dot(vec.crossVectors(normals[0], normals[segments])) > 0) {
+        theta = -theta;
+      }
+      for (let i = 1; i <= segments; i++) {
+        normals[i].applyMatrix4(mat.makeRotationAxis(tangents[i], theta * i));
+        binormals[i].crossVectors(tangents[i], normals[i]);
+      }
+    }
+    return {
+      tangents,
+      normals,
+      binormals
+    };
+  }
+  /**
+   * Returns a new curve with copied values from this instance.
+   *
+   * @return {Curve} A clone of this instance.
+   */
+  clone() {
+    return new this.constructor().copy(this);
+  }
+  /**
+   * Copies the values of the given curve to this instance.
+   *
+   * @param {Curve} source - The curve to copy.
+   * @return {Curve} A reference to this curve.
+   */
+  copy(source) {
+    this.arcLengthDivisions = source.arcLengthDivisions;
+    return this;
+  }
+  /**
+   * Serializes the curve into JSON.
+   *
+   * @return {Object} A JSON object representing the serialized curve.
+   * @see {@link ObjectLoader#parse}
+   */
+  toJSON() {
+    const data = {
+      metadata: {
+        version: 4.7,
+        type: "Curve",
+        generator: "Curve.toJSON"
+      }
+    };
+    data.arcLengthDivisions = this.arcLengthDivisions;
+    data.type = this.type;
+    return data;
+  }
+  /**
+   * Deserializes the curve from the given JSON.
+   *
+   * @param {Object} json - The JSON holding the serialized curve.
+   * @return {Curve} A reference to this curve.
+   */
+  fromJSON(json) {
+    this.arcLengthDivisions = json.arcLengthDivisions;
+    return this;
+  }
+}
+function CubicBezierP0(t, p2) {
+  const k = 1 - t;
+  return k * k * k * p2;
+}
+function CubicBezierP1(t, p2) {
+  const k = 1 - t;
+  return 3 * k * k * t * p2;
+}
+function CubicBezierP2(t, p2) {
+  return 3 * (1 - t) * t * t * p2;
+}
+function CubicBezierP3(t, p2) {
+  return t * t * t * p2;
+}
+function CubicBezier(t, p0, p1, p2, p3) {
+  return CubicBezierP0(t, p0) + CubicBezierP1(t, p1) + CubicBezierP2(t, p2) + CubicBezierP3(t, p3);
+}
+class CubicBezierCurve3 extends Curve {
+  /**
+   * Constructs a new Cubic Bezier curve.
+   *
+   * @param {Vector3} [v0] - The start point.
+   * @param {Vector3} [v1] - The first control point.
+   * @param {Vector3} [v2] - The second control point.
+   * @param {Vector3} [v3] - The end point.
+   */
+  constructor(v0 = new Vector3$1(), v1 = new Vector3$1(), v2 = new Vector3$1(), v3 = new Vector3$1()) {
+    super();
+    this.isCubicBezierCurve3 = true;
+    this.type = "CubicBezierCurve3";
+    this.v0 = v0;
+    this.v1 = v1;
+    this.v2 = v2;
+    this.v3 = v3;
+  }
+  /**
+   * Returns a point on the curve.
+   *
+   * @param {number} t - A interpolation factor representing a position on the curve. Must be in the range `[0,1]`.
+   * @param {Vector3} [optionalTarget] - The optional target vector the result is written to.
+   * @return {Vector3} The position on the curve.
+   */
+  getPoint(t, optionalTarget = new Vector3$1()) {
+    const point = optionalTarget;
+    const v0 = this.v0, v1 = this.v1, v2 = this.v2, v3 = this.v3;
+    point.set(
+      CubicBezier(t, v0.x, v1.x, v2.x, v3.x),
+      CubicBezier(t, v0.y, v1.y, v2.y, v3.y),
+      CubicBezier(t, v0.z, v1.z, v2.z, v3.z)
+    );
+    return point;
+  }
+  copy(source) {
+    super.copy(source);
+    this.v0.copy(source.v0);
+    this.v1.copy(source.v1);
+    this.v2.copy(source.v2);
+    this.v3.copy(source.v3);
+    return this;
+  }
+  toJSON() {
+    const data = super.toJSON();
+    data.v0 = this.v0.toArray();
+    data.v1 = this.v1.toArray();
+    data.v2 = this.v2.toArray();
+    data.v3 = this.v3.toArray();
+    return data;
+  }
+  fromJSON(json) {
+    super.fromJSON(json);
+    this.v0.fromArray(json.v0);
+    this.v1.fromArray(json.v1);
+    this.v2.fromArray(json.v2);
+    this.v3.fromArray(json.v3);
+    return this;
+  }
+}
 class PlaneGeometry extends BufferGeometry {
   /**
    * Constructs a new plane geometry.
@@ -30649,6 +31025,11 @@ class RBXSimpleView {
 }
 const magic = "<roblox!";
 const xmlMagic = "<roblox ";
+const TextureMode = {
+  "Stretch": 0,
+  "Wrap": 1,
+  "Static": 2
+};
 const ResamplerMode = {
   "Default": 0,
   "Pixelated": 1
@@ -32226,7 +32607,7 @@ const FLAGS = {
   LAYERED_CLOTHING_COOLDOWN: 0.25,
   GET_WORKER_FUNC: DefaultGetWorkerFunc,
   RBF_PATCH_COUNT: 300,
-  //amount of "patches" that are used for layered clothing, multiple verts share the same patch
+  //amount of "deformation patches" that are used for layered clothing, multiple verts share the same deformation patch, layered clothing usually has (3000 vertices)
   RBF_PATCH_DETAIL_SAMPLES: 32,
   //amount of nearby vertices each patch samples from
   RBF_PATCH_SHAPE_SAMPLES: 32,
@@ -32239,6 +32620,7 @@ const FLAGS = {
   //does this count as anti aliasing?
   GEAR_ENABLED: true,
   AUDIO_ENABLED: true,
+  BEAMS_ENABLED: true,
   USE_RENDERTARGET: true,
   AUTO_RESTORE_CONTEXT: true,
   RENDERTARGET_TO_CANVASTEXTURE: false,
@@ -32780,6 +33162,16 @@ class CFrame {
     upVector.applyQuaternion(quat);
     return upVector.toArray();
   }
+  rightVector() {
+    const matrix = this.getTHREEMatrix();
+    const pos = new Vector3$1();
+    const quat = new Quaternion();
+    const scale = new Vector3$1();
+    matrix.decompose(pos, quat, scale);
+    const rightVector = new Vector3$1(1, 0, 0);
+    rightVector.applyQuaternion(quat);
+    return rightVector.toArray();
+  }
   static lookAt(eye, target, up = [0, 1, 0]) {
     const matrix = new Matrix4().lookAt(new Vector3$1(...eye), new Vector3$1(...target), new Vector3$1(...up));
     const newCFrame = new CFrame();
@@ -36531,8 +36923,8 @@ const CategoryDictionary = {
       "Idle": new SortInfo([new ItemSort(51)]),
       "Walk": new SortInfo([new ItemSort(55)]),
       "Run": new SortInfo([new ItemSort(53)]),
-      "Fall": new SortInfo([new ItemSort(50)]),
       "Jump": new SortInfo([new ItemSort(52)]),
+      "Fall": new SortInfo([new ItemSort(50)]),
       "Swim": new SortInfo([new ItemSort(54)]),
       "Climb": new SortInfo([new ItemSort(48)]),
       "Mood": new SortInfo([new ItemSort(AssetTypeNameToId.get("MoodAnimation") || 0)], "inventory")
@@ -38283,7 +38675,7 @@ class FileMesh {
       log(false, "COREMESH v2");
       const dracoBitStreamSize = view.readUint32();
       const buffer2 = view.buffer.slice(view.viewOffset, view.viewOffset + dracoBitStreamSize);
-      if (!window.DracoDecoderModule) throw new Error("DracoDecoderModule is missing, you forgot to add draco_decoder.js");
+      if (!globalThis.DracoDecoderModule) throw new Error("DracoDecoderModule is missing, you forgot to add draco_decoder.js");
       const decoderModule = await DracoDecoderModule();
       const decoder = new decoderModule.Decoder();
       const mesh = new decoderModule.Mesh();
@@ -38366,7 +38758,7 @@ class FileMesh {
   }
   async fromBuffer(buffer2) {
     this.reset();
-    if (!window.DracoDecoderModule) {
+    if (!globalThis.DracoDecoderModule) {
       error("Missing module dependency: draco_decoder.js");
       throw new Error("Missing module dependency: draco_decoder.js, more info in documentation");
     }
@@ -38879,7 +39271,7 @@ async function RBLXPost(url, auth, body, attempt = 0, method = "POST") {
         headers: fetchHeaders,
         body
       }).then((response2) => {
-        if (response2.status !== 200) {
+        if (!response2.ok) {
           if (response2.status === 403 && attempt < 1) {
             const responseToken = response2.headers.get("x-csrf-token");
             if (responseToken && auth) {
@@ -38901,7 +39293,7 @@ async function RBLXPost(url, auth, body, attempt = 0, method = "POST") {
       resolve(new Response(JSON.stringify({ "error": error2 }), { status: 500 }));
     }
   });
-  if (FLAGS.API_REQUEST_RETRY && response.status !== 200 && attempt === 0) {
+  if (FLAGS.API_REQUEST_RETRY && !response.ok && attempt === 0) {
     return RBLXPost(url, auth, body, attempt + 1, method);
   } else {
     return response;
@@ -38938,7 +39330,7 @@ async function RBLXGet(url, headers, includeCredentials = true, attempt = 0) {
       resolve(new Response(JSON.stringify({ "error": error2 }), { status: 500 }));
     }
   });
-  if (FLAGS.API_REQUEST_RETRY && response.status !== 200 && attempt === 0) {
+  if (FLAGS.API_REQUEST_RETRY && !response.ok && attempt === 0) {
     return RBLXGet(url, headers, includeCredentials, attempt + 1);
   } else {
     return response;
@@ -39854,7 +40246,7 @@ const API = {
       const cacheResult = CACHE.ItemOwned.get(`${userId}.${itemType}.${assetId}`);
       if (cacheResult) {
         if (cacheResult[0]) return true;
-        if ((/* @__PURE__ */ new Date()).getTime() - cacheResult[1] < 5) return false;
+        if (Date.now() / 1e3 - cacheResult[1] < 10) return false;
       }
       const response = await RBLXGet(`https://inventory.roblox.com/v1/users/${userId}/items/${itemType}/${assetId}/is-owned`);
       if (response.status !== 200) {
@@ -39864,7 +40256,7 @@ const API = {
       if (responseBool) {
         CACHE.ItemOwned.set(`${userId}.${itemType}.${assetId}`, [true, 0]);
       } else {
-        CACHE.ItemOwned.set(`${userId}.${itemType}.${assetId}`, [false, (/* @__PURE__ */ new Date()).getTime() / 1e3]);
+        CACHE.ItemOwned.set(`${userId}.${itemType}.${assetId}`, [false, Date.now() / 1e3]);
       }
       return responseBool;
     }
@@ -39874,15 +40266,21 @@ const API = {
       if (CACHE.UserInfo !== void 0) {
         return CACHE.UserInfo;
       }
-      const response = await RBLXGet("https://users.roblox.com/v1/users/authenticated");
-      if (response.status === 200) {
-        const result = await response.json();
-        CACHE.UserInfo = result;
-        return result;
-      } else {
-        warn(true, "Failed to get user info: GetUserInfo(auth)");
-        return void 0;
-      }
+      const promise = new Promise((resolve) => {
+        RBLXGet("https://users.roblox.com/v1/users/authenticated").then(((response) => {
+          if (response.status === 200) {
+            response.json().then((result) => {
+              CACHE.UserInfo = result;
+              resolve(result);
+            });
+          } else {
+            warn(true, "Failed to get user info: GetUserInfo(auth)");
+            resolve(void 0);
+          }
+        }));
+      });
+      CACHE.UserInfo = promise;
+      return promise;
     },
     GetIdsFromUsernames: async function(usernames) {
       const response = await RBLXPost("https://users.roblox.com/v1/usernames/users", void 0, { "usernames": usernames });
@@ -40075,6 +40473,46 @@ const API = {
       return (await response.json()).subscriptions.length > 0;
     }
   },
+  "AvatarAIGenerationService": {
+    GenerateBackground: async function(auth, prompt) {
+      const response = await RBLXPost("https://apis.roblox.com/avatar-ai-generation-service/v1/backgrounds/generation", auth, {
+        prompt
+      });
+      if (response.status !== 200 && response.status !== 202) {
+        return response;
+      }
+      const result = await response.json();
+      if (result.generationId) {
+        return result.generationId;
+      } else {
+        return response;
+      }
+    },
+    GetBackground: async function(generationId) {
+      const response = await RBLXGet(`https://apis.roblox.com/avatar-ai-generation-service/v1/backgrounds/generation/${generationId}`);
+      if (response.status !== 200) {
+        return response;
+      }
+      return await response.json();
+    },
+    UploadBackground: async function(auth, generationId, displayName, description) {
+      const response = await RBLXPost(`https://apis.roblox.com/avatar-ai-generation-service/v1/backgrounds/generation/${generationId}/upload`, auth, {
+        displayName,
+        //max 50 characters
+        description
+        //max 500 characters
+      });
+      if (response.status !== 200) {
+        return response;
+      }
+      const result = await response.json();
+      if (result.operationId) {
+        return result.operationId;
+      } else {
+        return response;
+      }
+    }
+  },
   "RBLXGet": RBLXGet,
   "RBLXPost": RBLXPost,
   "RBLXDelete": RBLXDelete,
@@ -43413,6 +43851,21 @@ 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 {
   disposeMesh(scene, mesh) {
     disposeMesh(scene, mesh);
@@ -47490,7 +47943,11 @@ class MaterialDesc {
   }
   fromMeshPart(child) {
     let affectedByHumanoid = isAffectedByHumanoid(child);
-    const meshPartTexture = child.Prop("TextureID");
+    let meshPartTexture = child.PropOrDefault("TextureID", void 0);
+    if (!meshPartTexture) {
+      const textureContent = child.PropOrDefault("TextureContent", void 0);
+      meshPartTexture = textureContent?.uri || "";
+    }
     const surfaceAppearance = child.FindLastChildOfClass("SurfaceAppearance");
     let surfaceAppearanceAlphaMode = AlphaMode.Overlay;
     if (surfaceAppearance) {
@@ -48122,7 +48579,6 @@ class ObjectDesc extends RenderDesc {
       threeMesh.material = threeMaterial;
       threeMesh.receiveShadow = true;
       threeMaterial.needsUpdate = true;
-      threeMesh.visible = threeMaterial.visible;
       this.results = [threeMesh];
       this.originalScale = threeMesh.scale.clone();
       if (!this.meshDesc.scaleIsRelative) {
@@ -48211,7 +48667,7 @@ class ObjectDesc extends RenderDesc {
     return !isBakedDecal && (!isDecal || isFirstDecal);
   }
 }
-const __vite_glob_0_3$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+const __vite_glob_0_4$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
   MeshPartTypes,
   ObjectDesc,
@@ -49592,7 +50048,7 @@ class AnimatorWrapper extends InstanceWrapper {
     return false;
   }
 }
-const __vite_glob_0_3 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+const __vite_glob_0_3$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
   AnimatorWrapper
 }, Symbol.toStringTag, { value: "Module" }));
@@ -51734,7 +52190,11 @@ class Particle {
     }
     if (isNext) offset += 1;
     if (offset >= total) {
-      offset %= total;
+      if (mode !== ParticleFlipbookMode.OneShot) {
+        offset %= total;
+      } else {
+        offset = total - 1;
+      }
     }
     return offset;
   }
@@ -51846,21 +52306,6 @@ class EmitterDesc extends DisposableDesc {
       this.disposeRenderLists(renderer);
     }
   }
-  async 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;
-  }
   getFlipbookSize() {
     let flipbookSizeX = this.flipbookSizeX;
     let flipbookSizeY = this.flipbookSizeY;
@@ -51889,9 +52334,9 @@ class EmitterDesc extends DisposableDesc {
   async compileResult(renderer, scene) {
     const originalResult = this.result;
     const texturePromises = [
-      this.getTexture(this.texture),
-      this.getTexture(this.alphaTexture, NoColorSpace),
-      this.getTexture(this.colorTexture)
+      getTexture(this.texture),
+      getTexture(this.alphaTexture, NoColorSpace),
+      getTexture(this.colorTexture)
     ];
     let [mapToUse, alphaMapToUse, colorMapToUse] = await Promise.all(texturePromises);
     if (!mapToUse) {
@@ -52387,7 +52832,7 @@ class EmitterGroupDesc extends RenderDesc {
     this.lastCframe = this.cframe.clone();
   }
 }
-const __vite_glob_0_1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+const __vite_glob_0_2 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
   EmitterGroupDesc
 }, Symbol.toStringTag, { value: "Module" }));
@@ -52847,7 +53292,7 @@ const __vite_glob_0_27 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.de
   __proto__: null,
   WeldWrapper
 }, Symbol.toStringTag, { value: "Module" }));
-const modules$1 = /* @__PURE__ */ Object.assign({ "./instance/Accessory.ts": __vite_glob_0_0$1, "./instance/AccessoryDescription.ts": __vite_glob_0_1$1, "./instance/AnimationConstraint.ts": __vite_glob_0_2$1, "./instance/Animator.ts": __vite_glob_0_3, "./instance/Attachment.ts": __vite_glob_0_4, "./instance/BasePart.ts": __vite_glob_0_5, "./instance/BodyColors.ts": __vite_glob_0_6, "./instance/BodyPartDescription.ts": __vite_glob_0_7, "./instance/Bone.ts": __vite_glob_0_8, "./instance/Camera.ts": __vite_glob_0_9, "./instance/Constraint.ts": __vite_glob_0_10, "./instance/Decal.ts": __vite_glob_0_11, "./instance/FaceControls.ts": __vite_glob_0_12, "./instance/HumanoidDescription.ts": __vite_glob_0_13, "./instance/InstanceWrapper.ts": __vite_glob_0_14, "./instance/JointInstance.ts": __vite_glob_0_15, "./instance/MakeupDescription.ts": __vite_glob_0_16, "./instance/ManualWeld.ts": __vite_glob_0_17, "./instance/MeshPart.ts": __vite_glob_0_18, "./instance/Model.ts": __vite_glob_0_19, "./instance/Motor6D.ts": __vite_glob_0_20, "./instance/Part.ts": __vite_glob_0_21, "./instance/ParticleEmitter.ts": __vite_glob_0_22, "./instance/Script.ts": __vite_glob_0_23, "./instance/Sound.ts": __vite_glob_0_24, "./instance/Tool.ts": __vite_glob_0_25, "./instance/WedgePart.ts": __vite_glob_0_26, "./instance/Weld.ts": __vite_glob_0_27 });
+const modules$1 = /* @__PURE__ */ Object.assign({ "./instance/Accessory.ts": __vite_glob_0_0$1, "./instance/AccessoryDescription.ts": __vite_glob_0_1$1, "./instance/AnimationConstraint.ts": __vite_glob_0_2$1, "./instance/Animator.ts": __vite_glob_0_3$1, "./instance/Attachment.ts": __vite_glob_0_4, "./instance/BasePart.ts": __vite_glob_0_5, "./instance/BodyColors.ts": __vite_glob_0_6, "./instance/BodyPartDescription.ts": __vite_glob_0_7, "./instance/Bone.ts": __vite_glob_0_8, "./instance/Camera.ts": __vite_glob_0_9, "./instance/Constraint.ts": __vite_glob_0_10, "./instance/Decal.ts": __vite_glob_0_11, "./instance/FaceControls.ts": __vite_glob_0_12, "./instance/HumanoidDescription.ts": __vite_glob_0_13, "./instance/InstanceWrapper.ts": __vite_glob_0_14, "./instance/JointInstance.ts": __vite_glob_0_15, "./instance/MakeupDescription.ts": __vite_glob_0_16, "./instance/ManualWeld.ts": __vite_glob_0_17, "./instance/MeshPart.ts": __vite_glob_0_18, "./instance/Model.ts": __vite_glob_0_19, "./instance/Motor6D.ts": __vite_glob_0_20, "./instance/Part.ts": __vite_glob_0_21, "./instance/ParticleEmitter.ts": __vite_glob_0_22, "./instance/Script.ts": __vite_glob_0_23, "./instance/Sound.ts": __vite_glob_0_24, "./instance/Tool.ts": __vite_glob_0_25, "./instance/WedgePart.ts": __vite_glob_0_26, "./instance/Weld.ts": __vite_glob_0_27 });
 function RegisterWrappers() {
   for (const module of Object.values(modules$1)) {
     for (const exprt of Object.values(module)) {
@@ -52909,6 +53354,249 @@ const __vite_glob_0_0 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.def
   __proto__: null,
   AttachmentDesc
 }, Symbol.toStringTag, { value: "Module" }));
+class BeamDesc extends RenderDesc {
+  static classTypes = ["Beam"];
+  lastTime = Date.now() / 1e3;
+  time = Date.now() / 1e3;
+  passedLength = 0;
+  enabled = true;
+  lightEmission = 0;
+  //blends between normal -> additive blending, how?? graphics magic
+  lightInfluence = 1;
+  texture;
+  textureLength = 1;
+  textureMode = TextureMode.Stretch;
+  //static behaves identically to wrap
+  textureSpeed = 1;
+  color = ColorSequence.fromColor(new Color3(1, 1, 1));
+  transparency = new NumberSequence([new NumberSequenceKeypoint(0, 0.5), new NumberSequenceKeypoint(1, 0.5)]);
+  zOffset = 0;
+  //this moves its world position based on camera direction
+  cframe0 = new CFrame();
+  cframe1 = new CFrame();
+  curveSize0 = 0;
+  curveSize1 = 1;
+  width0 = 1;
+  width1 = 1;
+  faceCamera = false;
+  segments = 10;
+  //results
+  results = [];
+  isSame(newDesc) {
+    return this.time === newDesc.time && this.enabled === newDesc.enabled && this.lightEmission === newDesc.lightEmission && this.lightInfluence === newDesc.lightInfluence && this.texture === newDesc.texture && this.textureLength === newDesc.textureLength && this.textureMode === newDesc.textureMode && this.textureSpeed === newDesc.textureSpeed && this.color.isSame(newDesc.color) && this.transparency.isSame(newDesc.transparency) && this.zOffset === newDesc.zOffset && this.cframe0.isSame(newDesc.cframe0) && this.cframe1.isSame(newDesc.cframe1) && this.curveSize0 === newDesc.curveSize0 && this.curveSize1 === newDesc.curveSize1 && this.width0 === newDesc.width0 && this.width1 === newDesc.width1 && this.faceCamera === newDesc.faceCamera && this.segments === newDesc.segments;
+  }
+  needsRegeneration(newDesc) {
+    return this.enabled !== newDesc.enabled || this.texture !== newDesc.texture || this.segments !== newDesc.segments;
+  }
+  virtualFromRenderDesc(newDesc) {
+    this.time = newDesc.time;
+    this.lightEmission = newDesc.lightEmission;
+    this.lightInfluence = newDesc.lightInfluence;
+    this.textureLength = newDesc.textureLength;
+    this.textureMode = newDesc.textureMode;
+    this.textureSpeed = newDesc.textureSpeed;
+    this.color = newDesc.color.clone();
+    this.transparency = newDesc.transparency.clone();
+    this.zOffset = newDesc.zOffset;
+    this.cframe0 = newDesc.cframe0.clone();
+    this.cframe1 = newDesc.cframe1.clone();
+    this.curveSize0 = newDesc.curveSize0;
+    this.curveSize1 = newDesc.curveSize1;
+    this.width0 = newDesc.width0;
+    this.width1 = newDesc.width1;
+    this.faceCamera = newDesc.faceCamera;
+  }
+  virtualTransferFrom(oldDesc) {
+    this.passedLength = oldDesc.passedLength;
+  }
+  fromInstance(child) {
+    this.enabled = child.PropOrDefault("Enabled", this.enabled);
+    this.lightEmission = child.PropOrDefault("LightEmission", this.lightEmission);
+    this.lightInfluence = child.PropOrDefault("LightInfluence", this.lightInfluence);
+    this.texture = child.PropOrDefault("Texture", this.texture);
+    if (!this.texture) {
+      const textureContent = child.PropOrDefault("TextureContent", void 0);
+      if (textureContent) {
+        this.texture = textureContent.uri;
+      }
+    }
+    this.textureLength = child.PropOrDefault("TextureLength", this.textureLength);
+    this.textureMode = child.PropOrDefault("TextureMode", this.textureMode);
+    this.textureSpeed = child.PropOrDefault("TextureSpeed", this.textureSpeed);
+    this.color = child.PropOrDefault("Color", this.color);
+    this.transparency = child.PropOrDefault("Transparency", this.transparency);
+    this.zOffset = child.PropOrDefault("ZOffset", this.zOffset);
+    const att0 = child.PropOrDefault("Attachment0", void 0);
+    if (att0 && att0.IsA("Attachment")) {
+      const att0W = att0.w;
+      this.cframe0 = att0W.getWorldCFrame();
+    }
+    const att1 = child.PropOrDefault("Attachment1", void 0);
+    if (att1 && att1.IsA("Attachment")) {
+      const att1W = att1.w;
+      this.cframe1 = att1W.getWorldCFrame();
+    }
+    this.curveSize0 = child.PropOrDefault("CurveSize0", this.curveSize0);
+    this.curveSize1 = child.PropOrDefault("CurveSize1", this.curveSize1);
+    this.width0 = child.PropOrDefault("Width0", this.width0);
+    this.width1 = child.PropOrDefault("Width1", this.width1);
+    this.faceCamera = child.PropOrDefault("FaceCamera", this.faceCamera);
+    this.segments = child.PropOrDefault("Segments", this.segments);
+    if (!FLAGS.BEAMS_ENABLED) this.enabled = false;
+  }
+  async compileResults(renderer, scene) {
+    const originalResults = this.results;
+    this.results = [];
+    if (this.enabled) {
+      let textureResult = void 0;
+      if (this.texture) {
+        textureResult = await getTexture(this.texture);
+        if (textureResult) {
+          textureResult.wrapT = RepeatWrapping;
+        }
+      }
+      const material = new MeshBasicMaterial({
+        side: DoubleSide,
+        map: textureResult,
+        vertexColors: true,
+        transparent: true,
+        depthWrite: false
+      });
+      const geometry = new PlaneGeometry(1, 1, this.segments, 1);
+      const colorValues = new Float32Array((this.segments + 1) * 2 * 4).fill(1);
+      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;
+  }
+  updateResults() {
+    if (!this.results) return;
+    const deltaTime = this.time - this.lastTime;
+    this.passedLength += deltaTime * this.textureSpeed;
+    const camera = this.renderScene.camera;
+    const toCamera = new Vector3$1(0, 0, -1).applyQuaternion(camera.quaternion);
+    const v0 = new Vector3$1(...this.cframe0.Position);
+    const v1 = new Vector3$1(...this.cframe0.multiply(new CFrame(this.curveSize0, 0, 0)).Position);
+    const v2 = new Vector3$1(...this.cframe1.multiply(new CFrame(-this.curveSize1, 0, 0)).Position);
+    const v3 = new Vector3$1(...this.cframe1.Position);
+    const curve = new CubicBezierCurve3(v0, v1, v2, v3);
+    const curveLength = curve.getLength();
+    for (const result of this.results) {
+      const resultMaterial = result.material;
+      const resultGeometry = result.geometry;
+      resultMaterial.blending = this.lightEmission > 0.5 ? AdditiveBlending : NormalBlending;
+      const positions = resultGeometry.getAttribute("position");
+      for (let i = 0; i < positions.count; i++) {
+        const normSide = i < positions.count / 2 ? 0.5 : -0.5;
+        const t = i % (positions.count / 2) / (positions.count / 2 - 1);
+        const side = normSide * lerp(this.width0, this.width1, t);
+        const prevT = specialClamp(t - 1e-3, 0, 1);
+        const nextT = specialClamp(prevT + 1e-3, 0, 1);
+        const prevPos = curve.getPoint(prevT);
+        const nextPos = curve.getPoint(nextT);
+        let finalMatrix = void 0;
+        if (!this.faceCamera) {
+          const vZ = new Vector3$1().subVectors(nextPos, prevPos).normalize();
+          let vY = new Vector3$1(...lerpCFrame(this.cframe0, this.cframe1, t).upVector());
+          const vX = new Vector3$1().crossVectors(vZ, vY);
+          vY = new Vector3$1().crossVectors(vZ, vX);
+          const rotation = new Matrix4().set(
+            vX.x,
+            vY.x,
+            vZ.x,
+            0,
+            vX.y,
+            vY.y,
+            vZ.y,
+            0,
+            vX.z,
+            vY.z,
+            vZ.z,
+            0,
+            0,
+            0,
+            0,
+            1
+          );
+          finalMatrix = new Matrix4().makeTranslation(prevPos).multiply(rotation);
+        } else {
+          const vZ = new Vector3$1().subVectors(nextPos, prevPos).normalize();
+          let vX = toCamera.clone().negate().normalize();
+          const vY = new Vector3$1().crossVectors(vZ, vX).normalize();
+          vX = new Vector3$1().crossVectors(vY, vZ).normalize();
+          const rotation = new Matrix4().set(
+            vX.x,
+            vY.x,
+            vZ.x,
+            0,
+            vX.y,
+            vY.y,
+            vZ.y,
+            0,
+            vX.z,
+            vY.z,
+            vZ.z,
+            0,
+            0,
+            0,
+            0,
+            1
+          );
+          finalMatrix = new Matrix4().makeTranslation(prevPos).multiply(rotation);
+        }
+        const lookCF = new CFrame().fromMatrix(finalMatrix.toArray());
+        const sideCF = lookCF.multiply(new CFrame(0, side, 0));
+        positions.setXYZ(i, ...sideCF.Position);
+      }
+      const colors = resultGeometry.getAttribute("color");
+      for (let i = 0; i < colors.count; i++) {
+        const t = i % (colors.count / 2) / (colors.count / 2 - 1);
+        const colorValue = this.color.getValue(t);
+        const transparencyValue = this.transparency.getValue(t, 0);
+        const mult = 1 + this.lightEmission;
+        colors.setXYZW(i, colorValue.R * mult, colorValue.G * mult, colorValue.B * mult, 1 - transparencyValue);
+      }
+      const uvs = resultGeometry.getAttribute("uv");
+      if (this.textureMode === TextureMode.Stretch) {
+        for (let i = 0; i < uvs.count; i++) {
+          const t = i % (colors.count / 2) / (colors.count / 2 - 1);
+          const normSide = i < positions.count / 2 ? 1 : 0;
+          uvs.setXY(i, normSide, (1 - t + this.passedLength) * this.textureLength);
+        }
+      } else {
+        for (let i = 0; i < uvs.count; i++) {
+          const t = i % (colors.count / 2) / (colors.count / 2 - 1);
+          const normSide = i < positions.count / 2 ? 1 : 0;
+          uvs.setXY(i, normSide, (1 - t + this.passedLength / curveLength) * curveLength / this.textureLength);
+        }
+      }
+      positions.needsUpdate = true;
+      colors.needsUpdate = true;
+      uvs.needsUpdate = true;
+      const resultCF = new CFrame();
+      resultCF.Position = multiply(toCamera.clone().negate().normalize().toArray(), [this.zOffset, this.zOffset, this.zOffset]);
+      setTHREEObjectCF(result, resultCF);
+    }
+    this.lastTime = this.time;
+  }
+  dispose(_renderer, scene) {
+    if (!this.results) return;
+    for (const result of this.results) {
+      scene.remove(result);
+    }
+  }
+}
+const __vite_glob_0_1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  BeamDesc
+}, Symbol.toStringTag, { value: "Module" }));
 function disposeLight(scene, light) {
   if (light.shadow && light.shadow.map) {
     light.shadow.map.dispose();
@@ -53048,11 +53736,11 @@ class LightDesc extends RenderDesc {
     }
   }
 }
-const __vite_glob_0_2 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+const __vite_glob_0_3 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
   LightDesc
 }, Symbol.toStringTag, { value: "Module" }));
-const modules = /* @__PURE__ */ Object.assign({ "./attachmentDesc.ts": __vite_glob_0_0, "./emitterGroupDesc.ts": __vite_glob_0_1, "./lightDesc.ts": __vite_glob_0_2, "./objectDesc.ts": __vite_glob_0_3$1 });
+const modules = /* @__PURE__ */ Object.assign({ "./attachmentDesc.ts": __vite_glob_0_0, "./beamDesc.ts": __vite_glob_0_1, "./emitterGroupDesc.ts": __vite_glob_0_2, "./lightDesc.ts": __vite_glob_0_3, "./objectDesc.ts": __vite_glob_0_4$1 });
 function RegisterRenderDescs() {
   for (const module of Object.values(modules)) {
     for (const exprt of Object.values(module)) {
@@ -61341,6 +62029,7 @@ class RBXRenderer {
     plane.rotation.set(rad(-90), 0, 0);
     plane.position.set(0, 0, 0);
     plane.receiveShadow = false;
+    plane.renderOrder = -3;
     renderScene.plane = plane;
     renderScene.scene.add(plane);
   }
@@ -61481,7 +62170,8 @@ class RBXRenderer {
       mipmapBlur: true,
       luminanceThreshold: 0.95,
       luminanceSmoothing: 0.2,
-      intensity: 0.22
+      intensity: 0.5,
+      radius: 0.5
     })));
     const [width, height] = RBXRenderer.resolution;
     if (FLAGS.POST_PROCESSING_IS_DOUBLE_SIZE) {
@@ -62383,6 +63073,8 @@ class BackgroundRenderer {
   affectSceneLighting = true;
   cameraAffectsTransparency = true;
   cameraAffectsRotation = false;
+  forceImage;
+  forceColor;
   lastFrameTime = Date.now() / 1e3;
   animationInterval;
   animationFPS = 60;
@@ -62496,33 +63188,42 @@ class BackgroundRenderer {
         RBXRenderer.shadowPlane.position.set(0, -0.01, 0);
       }
     }
-    if (this.avatarCyclorama && this.backgroundData) {
+    if (this.avatarCyclorama && (this.backgroundData || this.forceImage && this.forceColor)) {
       const cameraDirTransparency = specialClamp((dot(RBXRenderer.getCameraCFrame(this.renderScene).lookVector(), [0, 0, -1]) + 0.5) * 2, 0, 1);
       const targetTransparency = this.cameraAffectsTransparency ? cameraDirTransparency : 0;
       const cyclorama = this.avatarCyclorama;
       const backgroundData = this.backgroundData;
       cyclorama.Child("color_mesh").setProperty("Transparency", targetTransparency);
       cyclorama.Child("texture_mesh").setProperty("Transparency", Math.max(0.05, targetTransparency));
+      let color2 = void 0;
+      let imageUrl = void 0;
       if (backgroundData) {
         const colorValue = backgroundData.Child("Color");
         const imageIdValue = backgroundData.Child("ImageId");
         if (colorValue && imageIdValue) {
-          const color2 = colorValue.Prop("Value");
+          color2 = colorValue.Prop("Value");
           const imageId = imageIdValue.Prop("Value");
-          cyclorama.Child("color_mesh").setProperty("Color", color2.toColor3uint8());
-          cyclorama.Child("texture_mesh").setProperty("TextureID", `rbxassetid://${imageId}`);
-          if (this.affectSceneLighting) {
-            this.ambientLight.color = new Color().setRGB(...color2.toArray(), SRGBColorSpace);
-            this.ambientLight.intensity = 1 * (1 - targetTransparency);
-            this.renderScene.scene.add(this.ambientLight);
-          }
+          imageUrl = `rbxassetid://${imageId}`;
+        }
+      }
+      color2 = this.forceColor || color2;
+      imageUrl = this.forceImage || imageUrl;
+      if (color2 && imageUrl) {
+        cyclorama.Child("color_mesh").setProperty("Color", color2.toColor3uint8());
+        cyclorama.Child("texture_mesh").setProperty("TextureID", imageUrl);
+        if (this.affectSceneLighting) {
+          this.ambientLight.color = new Color().setRGB(...color2.toArray(), SRGBColorSpace);
+          this.ambientLight.intensity = 1 * (1 - targetTransparency);
+          this.renderScene.scene.add(this.ambientLight);
+        } else {
+          this.renderScene.scene.remove(this.ambientLight);
         }
+        cyclorama.preRender();
+        RBXRenderer.addInstance(cyclorama, this.auth, this.renderScene);
       } else {
         cyclorama.Child("color_mesh").setProperty("Transparency", 1);
         cyclorama.Child("texture_mesh").setProperty("Transparency", 1);
       }
-      cyclorama.preRender();
-      RBXRenderer.addInstance(cyclorama, this.auth, this.renderScene);
       const colorDesc = this.renderScene.renderDescs.get(cyclorama.Child("color_mesh"));
       const textureDesc = this.renderScene.renderDescs.get(cyclorama.Child("texture_mesh"));
       if (colorDesc && colorDesc.results && colorDesc.results[0]) {
@@ -63441,6 +64142,7 @@ export {
   SpecialInfo,
   SpecialLayeredAssetTypes,
   StringBufferProperties,
+  TextureMode,
   ThumbnailCustomization,
   ToRemoveBeforeBundleType,
   ToolWrapper,

package/package.json

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