roavatar-renderer 1.5.4 → 1.5.6

package/dist/index.d.ts

@@ -1530,7 +1530,7 @@ export declare function getOriginalAttachmentPosition(attachment: Instance): Vec
 
 export declare function getOriginalSize(part: Instance): Vector3;
 
-export declare function getRandomBetweenInclusive(min: number, max: number): number;
+export declare function getRandomBetweenInclusive(min: number, max: number, randomVal?: number): number;
 
 export declare function getRigExtentsWorld(rig: Instance): [Vector3, Vector3];
 
@@ -2187,7 +2187,7 @@ export declare type Mat3x3 = [number, number, number, number, number, number, nu
 /** @category Mesh */
 export declare type Mat4x4 = [number, number, number, number, number, number, number, number, number, number, number, number, number, number, number, number];
 
-export declare function mathRandom(min: number, max: number): number;
+export declare function mathRandom(min: number, max: number, randomVal?: number): number;
 
 /** @category Outfit */
 export declare const MaxOneOfAssetTypes: string[];
@@ -2637,6 +2637,23 @@ export declare const ParticleEmitterShapeInOut: {
     InAndOut: number;
 };
 
+/**@category DataModelEnum */
+export declare const ParticleFlipbookLayout: {
+    None: number;
+    Grid2x2: number;
+    Grid4x4: number;
+    Grid8x8: number;
+    Custom: number;
+};
+
+/**@category DataModelEnum */
+export declare const ParticleFlipbookMode: {
+    Loop: number;
+    OneShot: number;
+    PingPong: number;
+    Random: number;
+};
+
 /**@category DataModelEnum */
 export declare const ParticleOrientation: {
     FacingCamera: number;

package/dist/index.js

@@ -27478,6 +27478,19 @@ class RBXSimpleView {
 }
 const magic = "<roblox!";
 const xmlMagic = "<roblox ";
+const ParticleFlipbookLayout = {
+  "None": 0,
+  "Grid2x2": 1,
+  "Grid4x4": 2,
+  "Grid8x8": 3,
+  "Custom": 4
+};
+const ParticleFlipbookMode = {
+  "Loop": 0,
+  "OneShot": 1,
+  "PingPong": 2,
+  "Random": 3
+};
 const PartType = {
   "Ball": 0,
   "Block": 1,
@@ -29886,7 +29899,7 @@ const FLAGS = {
   ENABLE_API_RBX_CACHE: true,
   ROAVATAR_DATA_URL: "rbxassetid://102463700065175",
   //url of model to load that lists issues with specific versions
-  ROAVATAR_TRYON_PLACE: 135979364355750,
+  ROAVATAR_TRYON_PLACE: 122920847927474,
   ASSETDELIVERY_V2: true,
   ASSET_REQUEST_PRIORITY: "high",
   API_DOMAIN: "roblox.com",
@@ -32164,11 +32177,11 @@ async function Wait(time2) {
     }, time2 * 1e3);
   });
 }
-function getRandomBetweenInclusive(min, max) {
-  return Math.random() * (max + 1 - min) + min;
+function getRandomBetweenInclusive(min, max, randomVal = Math.random()) {
+  return randomVal * (max + 1 - min) + min;
 }
-function mathRandom(min, max) {
-  return Math.floor(getRandomBetweenInclusive(min, max));
+function mathRandom(min, max, randomVal = Math.random()) {
+  return Math.floor(getRandomBetweenInclusive(min, max, randomVal));
 }
 async function imageUrlToDataUrl(imageUrl) {
   const response = await fetch(imageUrl);
@@ -42574,12 +42587,12 @@ class ModelLayersDesc {
     }
     for (const deformer of this.targetDeformers) {
       if (deformer) {
-        meshPromises.push(promiseForMesh(deformer.targetCage));
+        meshPromises.push(promiseForMesh(deformer.targetCage, true));
       }
     }
     for (const enclosedLayer of this.layers) {
-      meshPromises.push(promiseForMesh(enclosedLayer.cage));
-      meshPromises.push(promiseForMesh(enclosedLayer.reference));
+      meshPromises.push(promiseForMesh(enclosedLayer.cage, true));
+      meshPromises.push(promiseForMesh(enclosedLayer.reference, true));
       if (enclosedLayer.mesh) meshPromises.push(promiseForMesh(enclosedLayer.mesh, true));
     }
     const values = await Promise.all(meshPromises);
@@ -42600,14 +42613,14 @@ class ModelLayersDesc {
       inheritSkeleton(targetCage, targetMesh);
     }
     const distDeformer = this.targetDeformers[0];
-    const dist_mesh = distDeformer ? meshMap.get(distDeformer.targetCage).clone() : meshMap.get(this.targetCages[0]);
+    const dist_mesh = distDeformer ? meshMap.get(distDeformer.targetCage).clone() : meshMap.get(this.targetCages[0]).clone();
     const dist_mesh_mesh = meshMap.get(this.targetMeshes[0]);
     offsetMesh(dist_mesh, this.targetOffsets[0]);
     scaleMesh(dist_mesh, this.targetSizes[0].divide(new Vector32().fromVec3(dist_mesh_mesh.size)));
     offsetMesh(dist_mesh, this.targetCFrames[0]);
     for (let i = 1; i < this.targetCages.length; i++) {
       const deformer = this.targetDeformers[i];
-      const targetCage = deformer ? meshMap.get(deformer.targetCage).clone() : meshMap.get(this.targetCages[i]);
+      const targetCage = deformer ? meshMap.get(deformer.targetCage).clone() : meshMap.get(this.targetCages[i]).clone();
       const targetMesh = meshMap.get(this.targetMeshes[i]);
       offsetMesh(targetCage, this.targetOffsets[i]);
       scaleMesh(targetCage, this.targetSizes[i].divide(new Vector32().fromVec3(targetMesh.size)));
@@ -42619,8 +42632,8 @@ class ModelLayersDesc {
     targetMeshes.push(dist_mesh.clone());
     const uvToHits = [];
     for (const layer of this.layers) {
-      const cage = meshMap.get(layer.cage);
-      const reference = meshMap.get(layer.reference);
+      const cage = meshMap.get(layer.cage)?.clone();
+      const reference = meshMap.get(layer.reference)?.clone();
       if (!cage || !reference) {
         throw new Error("this isnt possible, shut up typescript");
       }
@@ -42795,8 +42808,8 @@ class HSRDesc {
       const cacheId = `${layer.mesh}-${layer.reference}-${layer.cage}`;
       const cacheEntry = FLAGS.CACHE_HSR_HITS ? CACHE_uvToHits.get(cacheId) : void 0;
       if (!cacheEntry) {
-        meshPromises.push(promiseForMesh(enclosedLayer.cage));
-        meshPromises.push(promiseForMesh(enclosedLayer.reference));
+        meshPromises.push(promiseForMesh(enclosedLayer.cage, true));
+        meshPromises.push(promiseForMesh(enclosedLayer.reference, true));
         if (enclosedLayer.mesh) meshPromises.push(promiseForMesh(enclosedLayer.mesh, true));
       }
     }
@@ -42816,8 +42829,8 @@ class HSRDesc {
       const cacheEntry = FLAGS.CACHE_HSR_HITS ? CACHE_uvToHits.get(cacheId) : void 0;
       const latestUvToHitsMap = cacheEntry ? cacheEntry : /* @__PURE__ */ new Map();
       if (!cacheEntry && !isTransparent) {
-        const cage = meshMap.get(layer.cage);
-        const reference = meshMap.get(layer.reference);
+        const cage = meshMap.get(layer.cage)?.clone();
+        const reference = meshMap.get(layer.reference)?.clone();
         const mesh = layer.mesh ? meshMap.get(layer.mesh) : void 0;
         if (!cage || !reference) {
           throw new Error("this isnt possible, shut up typescript");
@@ -48262,6 +48275,11 @@ class HumanoidDescriptionWrapper extends InstanceWrapper {
                 } else {
                   const head2 = dataModel.FindFirstChildOfClass("MeshPart");
                   if (head2) {
+                    for (const childChild of head2.GetChildren()) {
+                      if (childChild.w?.IsA("Weld") || childChild.w?.IsA("AnimationConstraint")) {
+                        childChild.Destroy();
+                      }
+                    }
                     replaceBodyPart(rig, head2);
                   }
                 }
@@ -49365,13 +49383,16 @@ const __vite_glob_0_0 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.def
 }, Symbol.toStringTag, { value: "Module" }));
 const particle_vertexShader = `
 attribute vec3 instanceColor;
-attribute vec2 instanceSeedTime;
+attribute vec3 instanceSeedTime;
 attribute float instanceOpacity;
+attribute vec4 instanceFlipbook;
 
 varying vec2 vUv;
 varying vec3 vInstanceColor;
 varying float vInstanceOpacity;
-varying vec2 vInstanceSeedTime;
+varying vec3 vInstanceSeedTime;
+varying vec2 vFlipbookUv0;
+varying vec2 vFlipbookUv1;
 
 uniform float uZOffset;
 
@@ -49380,6 +49401,8 @@ void main() {
     vInstanceColor = instanceColor;
     vInstanceOpacity = instanceOpacity;
     vInstanceSeedTime = instanceSeedTime;
+    vFlipbookUv0 = instanceFlipbook.xy;
+    vFlipbookUv1 = instanceFlipbook.zw;
 
     vec4 modelViewPosition = modelViewMatrix * instanceMatrix * vec4(position, 1.0);
 
@@ -49393,19 +49416,28 @@ const particle_fragmentShader = `
 varying vec2 vUv;
 varying vec3 vInstanceColor;
 varying float vInstanceOpacity;
-varying vec2 vInstanceSeedTime;
+varying vec3 vInstanceSeedTime;
+varying vec2 vFlipbookUv0;
+varying vec2 vFlipbookUv1;
 
 uniform sampler2D uColorMap;
 uniform sampler2D uAlphaMap;
 uniform sampler2D uMap;
 uniform float uOpacity;
+uniform vec2 uFlipbookSize;
 
 void main() {
     float seed = vInstanceSeedTime.x;
     float time = vInstanceSeedTime.y;
+    float flipbookFrameTime = vInstanceSeedTime.z;
+
+    // Sample the texture using the UV coordinates (for both frames)
+    vec4 texColor0 = texture2D(uMap, vUv * uFlipbookSize + vFlipbookUv0);
+    vec4 texColor1 = texture2D(uMap, vUv * uFlipbookSize + vFlipbookUv1);
+
+    float frameTransition = mod(time, flipbookFrameTime) / flipbookFrameTime;
+    vec4 texColor = texColor0 * (1.0 - frameTransition) + texColor1 * frameTransition;
 
-    // Sample the texture using the UV coordinates
-    vec4 texColor = texture2D(uMap, vUv);
     vec4 alphaTex = texture2D(uAlphaMap, vec2(time, seed)); 
     vec4 colorTex = texture2D(uColorMap, vec2(time, seed));
 
@@ -49415,6 +49447,8 @@ void main() {
     // Apply opacity to the texture alpha
     vec4 opacityColor = tintedColor * vec4(1.0, 1.0, 1.0, uOpacity * vInstanceOpacity) * alphaTex.r;
 
+    //#ADDITIVE_INSERT
+
     // Apply that weird color things sparkles have
     vec4 finalColor = opacityColor;
     finalColor.rgb = mix(opacityColor.rgb, opacityColor.rgb * colorTex.rgb, colorTex.a);
@@ -49422,6 +49456,12 @@ void main() {
     gl_FragColor = finalColor;
 }
 `;
+const particle_fragmentShader_additive = particle_fragmentShader.replace(
+  "//#ADDITIVE_INSERT",
+  `if (opacityColor.r + opacityColor.g + opacityColor.b <= 0.05) {
+    discard;
+}`
+);
 function randomBetween(min, max) {
   return Math.random() * (max - min) + min;
 }
@@ -49450,17 +49490,22 @@ class Particle {
     this.velocity = velocity;
     this.rotationSpeed = rotationSpeed;
   }
+  get intSeed() {
+    return Math.floor(this.seed * 1e6);
+  }
   camDistance(renderScene) {
     const cameraPos = new Vector32(...renderScene.camera.position.toArray());
     const particlePos = this.position;
     const distance2 = cameraPos.minus(particlePos).magnitude();
     return distance2;
   }
-  getMatrix(renderScene, size, orientation) {
+  getMatrix(renderScene, size, orientation, squash) {
     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);
+    const sizeX = squash > 0 ? size / (1 + squash) : size * (1 - squash);
+    const sizeY = squash > 0 ? size * (1 + squash) : size / (1 - squash);
+    const scale = new Matrix4().makeScale(sizeX, sizeY, 1);
     switch (orientation) {
       case ParticleOrientation.FacingCameraWorldUp: {
         const cameraLookVector = new Vector3$1();
@@ -49490,13 +49535,29 @@ class Particle {
         return final;
       }
       case ParticleOrientation.VelocityParallel: {
-        const normalizedVelocity = new Vector3$1(...this.velocity.normalize().toVec3());
-        const rotationParticlePosMatrix = new Matrix4().lookAt(particlePos, camera.position, normalizedVelocity);
-        const _pos = new Vector3$1();
-        const _scale = new Vector3$1();
-        const rotationQuat = new Quaternion();
-        rotationParticlePosMatrix.decompose(_pos, rotationQuat, _scale);
-        const rotation = new Matrix4().makeRotationFromQuaternion(rotationQuat);
+        const toCamera = new Vector3$1(0, 0, -1).applyQuaternion(camera.quaternion);
+        const velocityVector = new Vector3$1(...this.velocity.toVec3());
+        const vY = velocityVector.normalize();
+        const vX = new Vector3$1().crossVectors(toCamera.normalize(), vY).normalize();
+        const vZ = new Vector3$1().crossVectors(vX, vY).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
+        );
         const flatRotation = new Matrix4().makeRotationAxis(new Vector3$1(0, 0, 1), rad(this.rotation + 90));
         const final = translation.multiply(rotation).multiply(flatRotation).multiply(scale);
         return final;
@@ -49510,6 +49571,30 @@ class Particle {
       }
     }
   }
+  getFlipbookIndex(total, isNext, framerate, mode, startRandom) {
+    const rng = new RNG(this.intSeed + 324);
+    const randomVal = rng.nextFloat();
+    let offset = startRandom ? mathRandom(0, total - 1, randomVal) : 0;
+    switch (mode) {
+      case ParticleFlipbookMode.Loop:
+        offset += Math.floor(this.time * framerate);
+        break;
+      case ParticleFlipbookMode.OneShot:
+        offset += Math.round(this.time * total);
+        break;
+      case ParticleFlipbookMode.PingPong:
+        offset += Math.floor(this.time * framerate);
+        break;
+      case ParticleFlipbookMode.Random:
+        offset += mathRandom(0, total - 1, new RNG(this.intSeed + 334 + Math.floor(this.time * framerate)).nextFloat());
+        break;
+    }
+    if (isNext) offset += 1;
+    if (offset >= total) {
+      offset %= total;
+    }
+    return offset;
+  }
   tick(dt, drag, acceleration) {
     this.time += specialClamp(dt, 0, this.lifetime);
     this.position = this.position.add(this.velocity.multiply(new Vector32(dt, dt, dt)));
@@ -49542,8 +49627,16 @@ class EmitterDesc extends DisposableDesc {
   blending = AdditiveBlending;
   color = new ColorSequence();
   size = new NumberSequence();
+  squash = new NumberSequence([new NumberSequenceKeypoint(0, 0, 0)]);
   transparency = new NumberSequence([new NumberSequenceKeypoint(0, 0, 0)]);
   normalizeSizeKeypointTime = true;
+  flipbookLayout = ParticleFlipbookLayout.None;
+  flipbookBlendFrames = true;
+  flipbookFramerate = new NumberRange(1, 1);
+  flipbookMode = ParticleFlipbookMode.Loop;
+  flipbookSizeX = 1;
+  flipbookSizeY = 1;
+  flipbookStartRandom = false;
   //requires recompilation
   rate = 10;
   colorTexture;
@@ -49553,7 +49646,9 @@ class EmitterDesc extends DisposableDesc {
   instanceOpacityBuffer;
   instanceColorBuffer;
   instanceSeedTimeBuffer;
+  instanceFlipbookBuffer;
   result;
+  resultMaterial;
   particles = [];
   initialParticleCount = 0;
   get maxCount() {
@@ -49565,7 +49660,7 @@ class EmitterDesc extends DisposableDesc {
     return this.texture === other.texture && this.alphaTexture === other.alphaTexture && this.colorTexture === other.colorTexture && this.rate === other.rate;
   }
   isSame(other) {
-    return !this.needsRegeneration(other) && this.lockedToPart === other.lockedToPart && this.lifetime.isSame(other.lifetime) && this.spreadAngle.isSame(other.spreadAngle) && this.speed.isSame(other.speed) && this.rotation.isSame(other.rotation) && this.rotationSpeed.isSame(other.rotationSpeed) && this.localAcceleration.isSame(other.localAcceleration) && this.acceleration.isSame(other.acceleration) && this.drag === other.drag && this.timeScale === other.timeScale && this.orientation === other.orientation && this.zOffset === other.zOffset && this.offset.isSame(other.offset) && this.shapeInOut === other.shapeInOut && this.opacity === other.opacity && this.lightEmission === other.lightEmission && this.blending === other.blending && this.color.isSame(other.color) && this.size.isSame(other.size) && this.transparency.isSame(other.transparency) && this.normalizeSizeKeypointTime === other.normalizeSizeKeypointTime;
+    return !this.needsRegeneration(other) && this.lockedToPart === other.lockedToPart && this.lifetime.isSame(other.lifetime) && this.spreadAngle.isSame(other.spreadAngle) && this.speed.isSame(other.speed) && this.rotation.isSame(other.rotation) && this.rotationSpeed.isSame(other.rotationSpeed) && this.localAcceleration.isSame(other.localAcceleration) && this.acceleration.isSame(other.acceleration) && this.drag === other.drag && this.timeScale === other.timeScale && this.orientation === other.orientation && this.zOffset === other.zOffset && this.offset.isSame(other.offset) && this.shapeInOut === other.shapeInOut && this.opacity === other.opacity && this.lightEmission === other.lightEmission && this.blending === other.blending && this.color.isSame(other.color) && this.size.isSame(other.size) && this.squash.isSame(other.squash) && this.transparency.isSame(other.transparency) && this.normalizeSizeKeypointTime === other.normalizeSizeKeypointTime && this.flipbookLayout === other.flipbookLayout && this.flipbookBlendFrames === other.flipbookBlendFrames && this.flipbookFramerate.isSame(other.flipbookFramerate) && this.flipbookMode === other.flipbookMode && this.flipbookSizeX === other.flipbookSizeX && this.flipbookSizeY === other.flipbookSizeY && this.flipbookStartRandom === other.flipbookStartRandom;
   }
   fromEmitterDesc(other) {
     this.lockedToPart = other.lockedToPart;
@@ -49588,8 +49683,16 @@ class EmitterDesc extends DisposableDesc {
     this.blending = other.blending;
     this.color = other.color.clone();
     this.size = other.size.clone();
+    this.squash = other.squash.clone();
     this.transparency = other.transparency.clone();
     this.normalizeSizeKeypointTime = other.normalizeSizeKeypointTime;
+    this.flipbookLayout = other.flipbookLayout;
+    this.flipbookBlendFrames = other.flipbookBlendFrames;
+    this.flipbookFramerate = other.flipbookFramerate.clone();
+    this.flipbookMode = other.flipbookMode;
+    this.flipbookSizeX = other.flipbookSizeX;
+    this.flipbookSizeY = other.flipbookSizeY;
+    this.flipbookStartRandom = other.flipbookStartRandom;
   }
   dispose(renderer, scene) {
     const mesh = this.result;
@@ -49613,6 +49716,31 @@ class EmitterDesc extends DisposableDesc {
     }
     return void 0;
   }
+  getFlipbookSize() {
+    let flipbookSizeX = this.flipbookSizeX;
+    let flipbookSizeY = this.flipbookSizeY;
+    switch (this.flipbookLayout) {
+      case ParticleFlipbookLayout.None:
+        flipbookSizeX = 1;
+        flipbookSizeY = 1;
+        break;
+      case ParticleFlipbookLayout.Grid2x2:
+        flipbookSizeX = 2;
+        flipbookSizeY = 2;
+        break;
+      case ParticleFlipbookLayout.Grid4x4:
+        flipbookSizeX = 4;
+        flipbookSizeY = 4;
+        break;
+      case ParticleFlipbookLayout.Grid8x8:
+        flipbookSizeX = 8;
+        flipbookSizeY = 8;
+        break;
+      case ParticleFlipbookLayout.Custom:
+        break;
+    }
+    return [flipbookSizeX, flipbookSizeY];
+  }
   async compileResult(renderer, scene) {
     const originalResult = this.result;
     const texturePromises = [
@@ -49638,8 +49766,11 @@ class EmitterDesc extends DisposableDesc {
     geometry.setAttribute("instanceColor", this.instanceColorBuffer);
     this.instanceOpacityBuffer = new InstancedBufferAttribute(new Float32Array(this.maxCount), 1);
     geometry.setAttribute("instanceOpacity", this.instanceOpacityBuffer);
-    this.instanceSeedTimeBuffer = new InstancedBufferAttribute(new Float32Array(this.maxCount), 2);
+    this.instanceSeedTimeBuffer = new InstancedBufferAttribute(new Float32Array(this.maxCount * 3), 3);
     geometry.setAttribute("instanceSeedTime", this.instanceSeedTimeBuffer);
+    this.instanceFlipbookBuffer = new InstancedBufferAttribute(new Float32Array(this.maxCount * 4), 4);
+    geometry.setAttribute("instanceFlipbook", this.instanceFlipbookBuffer);
+    const [flipbookSizeX, flipbookSizeY] = this.getFlipbookSize();
     const material = new ShaderMaterial({
       transparent: true,
       depthWrite: false,
@@ -49647,15 +49778,17 @@ class EmitterDesc extends DisposableDesc {
       blending: this.blending,
       opacity: this.opacity,
       vertexShader: particle_vertexShader,
-      fragmentShader: particle_fragmentShader,
+      fragmentShader: this.blending === AdditiveBlending ? particle_fragmentShader_additive : particle_fragmentShader,
       uniforms: {
         uMap: { value: mapToUse },
         uAlphaMap: { value: alphaMapToUse },
         uColorMap: { value: colorMapToUse },
         uOpacity: { value: this.opacity },
-        uZOffset: { value: this.zOffset }
+        uZOffset: { value: this.zOffset },
+        uFlipbookSize: { value: new Vector2$1(1 / flipbookSizeX, 1 / flipbookSizeY) }
       }
     });
+    this.resultMaterial = material;
     this.result = new InstancedMesh(geometry, material, this.maxCount);
     this.result.name = "Particles";
     this.result.frustumCulled = false;
@@ -49739,24 +49872,47 @@ class EmitterDesc extends DisposableDesc {
     }
   }
   updateResult(renderScene) {
-    if (!this.result || !this.instanceColorBuffer || !this.instanceOpacityBuffer || !this.instanceSeedTimeBuffer) return;
+    if (!this.result || !this.instanceColorBuffer || !this.instanceOpacityBuffer || !this.instanceSeedTimeBuffer || !this.instanceFlipbookBuffer) return;
     this.result.count = this.particles.length;
+    const [flipbookSizeX, flipbookSizeY] = this.getFlipbookSize();
+    const flipbookTotal = flipbookSizeX * flipbookSizeY;
+    if (this.resultMaterial) {
+      this.resultMaterial.uniforms.uOpacity.value = this.opacity;
+      this.resultMaterial.uniforms.uZOffset.value = this.zOffset;
+      this.resultMaterial.uniforms.uFlipbookSize.value.set(1 / flipbookSizeX, 1 / flipbookSizeY);
+    }
     for (let i = 0; i < this.result.count; i++) {
       const particle = this.particles[i];
       const time2 = particle.time;
       const normalizedTime = particle.time / particle.lifetime;
       const color = this.color.getValue(normalizedTime);
       const size = this.size.getValue(this.normalizeSizeKeypointTime ? normalizedTime : time2, particle.seed + 0);
+      const squash = this.squash.getValue(this.normalizeSizeKeypointTime ? normalizedTime : time2, particle.seed + 2);
       const opacity = 1 - this.transparency.getValue(normalizedTime, particle.seed + 1);
-      this.result.setMatrixAt(i, particle.getMatrix(renderScene, size, this.orientation));
+      const flipbookFramerate = mathRandom(this.flipbookFramerate.Min, this.flipbookFramerate.Max, new RNG(particle.seed + 67).nextFloat());
+      let flipbookFrameTime = this.flipbookMode === ParticleFlipbookMode.OneShot ? particle.lifetime / flipbookTotal : 1 / flipbookFramerate;
+      if (!this.flipbookBlendFrames) flipbookFrameTime = 1e6;
+      this.result.setMatrixAt(i, particle.getMatrix(renderScene, size, this.orientation, squash));
       this.instanceColorBuffer.setXYZ(i, color.R, color.G, color.B);
       this.instanceOpacityBuffer.setX(i, opacity);
-      this.instanceSeedTimeBuffer.setXY(i, particle.seed, normalizedTime);
+      this.instanceSeedTimeBuffer.setXYZ(i, particle.seed, normalizedTime, flipbookFrameTime);
+      const flipbookFrame0 = particle.getFlipbookIndex(flipbookTotal, false, flipbookFramerate, this.flipbookMode, this.flipbookStartRandom);
+      const flipbookFrame1 = this.flipbookBlendFrames ? particle.getFlipbookIndex(flipbookTotal, true, flipbookFramerate, this.flipbookMode, this.flipbookStartRandom) : flipbookFrame0;
+      const column0 = flipbookFrame0 % flipbookSizeX;
+      const row0 = Math.floor(flipbookFrame0 / flipbookSizeX);
+      const column1 = flipbookFrame1 % flipbookSizeX;
+      const row1 = Math.floor(flipbookFrame1 / flipbookSizeX);
+      const u0 = column0 * 1 / flipbookSizeX;
+      const v0 = (flipbookSizeY - 1 - row0) * 1 / flipbookSizeY;
+      const u1 = column1 * 1 / flipbookSizeX;
+      const v1 = (flipbookSizeY - 1 - row1) * 1 / flipbookSizeY;
+      this.instanceFlipbookBuffer.setXYZW(i, u0, v0, u1, v1);
     }
     this.result.instanceMatrix.needsUpdate = true;
     this.instanceColorBuffer.needsUpdate = true;
     this.instanceOpacityBuffer.needsUpdate = true;
     this.instanceSeedTimeBuffer.needsUpdate = true;
+    this.instanceFlipbookBuffer.needsUpdate = true;
   }
 }
 class EmitterGroupDesc extends RenderDesc {
@@ -49899,6 +50055,7 @@ class EmitterGroupDesc extends RenderDesc {
     if (child.HasProperty("Drag")) emitterDesc.drag = child.Prop("Drag");
     if (child.HasProperty("TimeScale")) emitterDesc.timeScale = child.Prop("TimeScale");
     if (child.HasProperty("Size")) emitterDesc.size = child.Prop("Size");
+    if (child.HasProperty("Squash")) emitterDesc.squash = child.Prop("Squash");
     if (child.HasProperty("Color")) emitterDesc.color = child.Prop("Color");
     if (child.HasProperty("Texture")) emitterDesc.texture = child.Prop("Texture");
     if (child.HasProperty("Transparency")) emitterDesc.transparency = child.Prop("Transparency");
@@ -49907,6 +50064,13 @@ class EmitterGroupDesc extends RenderDesc {
     if (child.HasProperty("ZOffset")) emitterDesc.zOffset = child.Prop("ZOffset");
     if (child.HasProperty("Orientation")) emitterDesc.orientation = child.Prop("Orientation");
     if (child.HasProperty("LockedToPart")) emitterDesc.lockedToPart = child.Prop("LockedToPart");
+    emitterDesc.flipbookLayout = child.PropOrDefault("FlipbookLayout", emitterDesc.flipbookLayout);
+    emitterDesc.flipbookBlendFrames = child.PropOrDefault("FlipbookBlendFrames", emitterDesc.flipbookBlendFrames);
+    emitterDesc.flipbookFramerate = child.PropOrDefault("FlipbookFramerate", emitterDesc.flipbookFramerate);
+    emitterDesc.flipbookMode = child.PropOrDefault("FlipbookMode", emitterDesc.flipbookMode);
+    emitterDesc.flipbookSizeX = child.PropOrDefault("FlipbookSizeX", emitterDesc.flipbookSizeX);
+    emitterDesc.flipbookSizeY = child.PropOrDefault("FlipbookSizeY", emitterDesc.flipbookSizeY);
+    emitterDesc.flipbookStartRandom = child.PropOrDefault("FlipbookStartRandom", emitterDesc.flipbookStartRandom);
     this.emitterDescs.push(emitterDesc);
   }
   fromSparkles(child) {
@@ -50522,8 +50686,8 @@ class RBXRenderer {
   }
   /**Sets up the THREE.js renderer */
   static create(canvas) {
-    RBXRenderer.renderer = new WebGLRenderer({ antialias: true, alpha: true, canvas });
-    RBXRenderer.renderer.setClearColor(new Color(1, 0, 1), 0);
+    RBXRenderer.renderer = new WebGLRenderer({ antialias: true, alpha: true, premultipliedAlpha: false, canvas });
+    if (RBXRenderer.renderer) RBXRenderer.renderer.setClearColor(new Color(0, 0, 0), 0);
     RBXRenderer.renderer.outputColorSpace = SRGBColorSpace;
     RBXRenderer.renderer.shadowMap.enabled = true;
     RBXRenderer.renderer.shadowMap.type = PCFSoftShadowMap;
@@ -50693,6 +50857,7 @@ class RBXRenderer {
    */
   static setBackgroundTransparent(transparent) {
     RBXRenderer.backgroundTransparent = transparent;
+    if (RBXRenderer.renderer) RBXRenderer.renderer.setClearColor(new Color(0, 0, 0), 0);
     for (const renderScene of RBXRenderer.scenes) {
       if (RBXRenderer.backgroundTransparent) {
         renderScene.scene.background = null;
@@ -51682,6 +51847,8 @@ export {
   OutfitRenderer,
   PartType,
   ParticleEmitterShapeInOut,
+  ParticleFlipbookLayout,
+  ParticleFlipbookMode,
   ParticleOrientation,
   Property,
   PropertyTypeInfo,

package/package.json

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