roavatar-renderer 1.2.11 → 1.2.12

package/dist/index.d.ts

@@ -646,6 +646,9 @@ export declare class CFrame {
     getMatrix(): THREE.Matrix4Tuple;
     fromMatrix(m: Mat4x4): this;
     fromRotationMatrix(r00: number, r01: number, r02: number, r10: number, r11: number, r12: number, r20: number, r21: number, r22: number, order?: string): void;
+    lookVector(): Vec3;
+    static lookAt(eye: Vec3, target: Vec3, up?: Vec3): CFrame;
+    static fromEulerAngles(rx: number, ry: number, rz: number, order?: THREE.EulerOrder): CFrame;
     inverse(): CFrame;
     multiply(cf: CFrame): CFrame;
     isSame(other: CFrame): boolean;
@@ -786,6 +789,8 @@ export declare const DefaultAnimations: {
  */
 export declare const DefaultAnimationsR6: typeof DefaultAnimations;
 
+export declare function DefaultGetWorkerFunc(): Worker;
+
 export declare const defaultPantAssetIds: number[];
 
 export declare const defaultPantTemplateAssetIds: number[];
@@ -1022,6 +1027,8 @@ export declare function GetAttachedPart(accessory: Instance, rig: Instance): Ins
 
 export declare function getDistVertArray(ref: FileMesh, dist: FileMesh): (FileMeshVertex | undefined)[];
 
+export declare function getHeadExtents(rig: Instance): [Vector3, Vector3] | undefined;
+
 export declare interface GetInfoForId_Result {
     "description": string;
     "created": string;
@@ -1083,6 +1090,8 @@ export declare function getUVtoIndexMap(mesh: FileMesh): Map<number, number>;
 
 export declare function getUVtoVertMap(mesh: FileMesh): Map<number, FileMeshVertex[]>;
 
+export declare function getWorkerOnMessage(): (event: MessageEvent) => void;
+
 export declare function hashVec2(x: number, y: number): number;
 
 export declare function hashVec3(x: number, y: number, z: number, distance: number): number;
@@ -2512,6 +2521,8 @@ export declare class UDim2 {
     clone(): UDim2;
 }
 
+export declare function updateCameraForHeadshotCustomized(rig: Instance, fov: number, yRot: number, distance: number): void;
+
 declare type UserInfo = {
     id: number;
     name: string;
@@ -2628,6 +2639,10 @@ export declare type WeightChunk3 = WeightChunk & {
     weights: Vec3[];
 };
 
+export declare const WorkerTypeToFunction: {
+    [K in string]: Function;
+};
+
 export declare const WrapLayerAutoSkin: {
     Disabled: number;
     EnabledPreserve: number;

package/dist/index.js

@@ -29696,6 +29696,13 @@ const WorkerTypeToFunction = {
   "patchRBF": patchRBFWorkerFunc,
   "RBFDeformerSolveAsync": RBFDeformerSolveAsync
 };
+function getWorkerOnMessage() {
+  return function(event) {
+    const [id, type, data] = event.data;
+    const func = WorkerTypeToFunction[type];
+    self.postMessage([id, func(data)]);
+  };
+}
 function DefaultGetWorkerFunc() {
   return new WorkerWrapper();
 }
@@ -30107,6 +30114,27 @@ class CFrame {
       r22
     ], order);
   }
+  lookVector() {
+    const matrix2 = this.getTHREEMatrix();
+    const pos = new Vector3$1();
+    const quat = new Quaternion();
+    const scale = new Vector3$1();
+    matrix2.decompose(pos, quat, scale);
+    const lookVector = new Vector3$1(0, 0, -1);
+    lookVector.applyQuaternion(quat);
+    return lookVector.toArray();
+  }
+  static lookAt(eye, target, up = [0, 1, 0]) {
+    const matrix2 = new Matrix4().lookAt(new Vector3$1(...eye), new Vector3$1(...target), new Vector3$1(...up));
+    const newCFrame = new CFrame();
+    newCFrame.fromMatrix(matrix2.elements);
+    newCFrame.Position = [...eye];
+    return newCFrame;
+  }
+  static fromEulerAngles(rx, ry, rz, order = "XYZ") {
+    const matrix2 = new Matrix4().makeRotationFromEuler(new Euler(rx, ry, rz, order));
+    return new CFrame().fromMatrix(matrix2.elements);
+  }
   inverse() {
     const thisM = new Matrix4().fromArray(this.getMatrix());
     const inverse = thisM.clone();
@@ -62690,6 +62718,111 @@ class HSR {
     }
   }
 }
+function getCorners(cframe, size2) {
+  const halfX = size2.X / 2;
+  const halfY = size2.Y / 2;
+  const halfZ = size2.Z / 2;
+  return [
+    cframe.multiply(new CFrame(halfX, halfY, halfZ)),
+    cframe.multiply(new CFrame(halfX, halfY, -halfZ)),
+    cframe.multiply(new CFrame(-halfX, halfY, halfZ)),
+    cframe.multiply(new CFrame(-halfX, halfY, -halfZ)),
+    cframe.multiply(new CFrame(halfX, -halfY, halfZ)),
+    cframe.multiply(new CFrame(halfX, -halfY, -halfZ)),
+    cframe.multiply(new CFrame(-halfX, -halfY, halfZ)),
+    cframe.multiply(new CFrame(-halfX, -halfY, -halfZ))
+  ];
+}
+function getLower(a, b) {
+  return new Vector32(
+    a.X < b.X ? a.X : b.X,
+    a.Y < b.Y ? a.Y : b.Y,
+    a.Z < b.Z ? a.Z : b.Z
+  );
+}
+function getHigher(a, b) {
+  return new Vector32(
+    a.X > b.X ? a.X : b.X,
+    a.Y > b.Y ? a.Y : b.Y,
+    a.Z > b.Z ? a.Z : b.Z
+  );
+}
+function getExtents(cframe, parts) {
+  const inverseCF = cframe.inverse();
+  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 partCF = child.Prop("CFrame");
+      const partSize = child.Prop("Size");
+      const corners = getCorners(inverseCF.multiply(partCF), partSize);
+      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 zoomExtents(cameraCFrame, modelCFrame, modelSize, targetFOV, distanceScale) {
+  const largestSize = Math.max(modelSize.X, modelSize.Y, modelSize.Z);
+  const fovMultiplier = 70 / targetFOV;
+  const lookDir = multiply$1(normalize(minus(cameraCFrame.Position, modelCFrame.Position)), [distanceScale, distanceScale, distanceScale]);
+  cameraCFrame.Position = add$2(modelCFrame.Position, multiply$1(multiply$1(lookDir, [largestSize, largestSize, largestSize]), [fovMultiplier, fovMultiplier, fovMultiplier]));
+}
+function getHeadExtents(rig) {
+  const head = rig.FindFirstChild("Head");
+  if (!head) return;
+  const headParts = [];
+  for (const child of rig.GetDescendants()) {
+    if (child === head) {
+      headParts.push(head);
+    } else {
+      const weld = child.FindFirstChildOfClass("Weld");
+      if (weld && child.parent && child.parent.className === "Accessory") {
+        if (weld.Prop("Part0") === head || weld.Prop("Part1") === head) {
+          headParts.push(child);
+        }
+      }
+    }
+  }
+  const extents = getExtents(head.Prop("CFrame"), headParts);
+  return extents;
+}
+function updateCameraForHeadshotCustomized(rig, fov2, yRot, distance2) {
+  const head = rig.FindFirstChild("Head");
+  if (!head) return;
+  const headCF = head.PropOrDefault("CFrame", new CFrame());
+  const headLocalExtents = getHeadExtents(rig);
+  if (!headLocalExtents) return;
+  const headCenterPosLocal = headLocalExtents[0].add(headLocalExtents[1].minus(headLocalExtents[0]).divide(new Vector32(2, 2, 2)));
+  const headCenterPos = new Vector32().fromVec3(headCF.multiply(new CFrame(...headCenterPosLocal.toVec3())).Position);
+  const headCenterCF = new CFrame(...headCenterPos.toVec3());
+  let lookVector = headCF.lookVector();
+  if (Math.abs(lookVector[1]) > 0.95) {
+    lookVector = [0, 0, -1];
+  } else {
+    lookVector[1] = 0;
+    lookVector = normalize(lookVector);
+  }
+  let lookCF = CFrame.lookAt([0, 0, 0], lookVector);
+  lookCF = lookCF.multiply(CFrame.fromEulerAngles(0, yRot, 0, "ZXY"));
+  lookVector = lookCF.lookVector();
+  const fovMultiplier = 70 / fov2;
+  lookCF.Position = add$2(headCenterCF.Position, multiply$1(multiply$1([10, 10, 10], lookVector), [fovMultiplier, fovMultiplier, fovMultiplier]));
+  lookCF = CFrame.lookAt(lookCF.Position, headCenterCF.Position);
+  const cameraCF = lookCF.clone();
+  zoomExtents(cameraCF, headCenterCF, headLocalExtents[1].minus(headLocalExtents[0]), fov2, distance2);
+  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().fov = fov2;
+  RBXRenderer.getRendererCamera().updateMatrixWorld();
+}
 class OutfitRenderer {
   auth;
   outfit;
@@ -62925,6 +63058,7 @@ export {
   DataType,
   DefaultAnimations,
   DefaultAnimationsR6,
+  DefaultGetWorkerFunc,
   DefaultSearchData,
   EmitterGroupDescClassTypes,
   Event,
@@ -62996,6 +63130,7 @@ export {
   Vector32 as Vector3,
   Wait,
   WearableAssetTypes,
+  WorkerTypeToFunction,
   WrapLayerAutoSkin,
   accessoryRefinementLowerBounds,
   accessoryRefinementTypes,
@@ -63038,12 +63173,14 @@ export {
   gaussian_rbf,
   generateUUIDv4,
   getDistVertArray,
+  getHeadExtents,
   getOffsetArray,
   getOffsetMap,
   getOriginalSize,
   getRandomBetweenInclusive,
   getUVtoIndexMap,
   getUVtoVertMap,
+  getWorkerOnMessage,
   hasSameVal,
   hasSameValFloat,
   hashVec2,
@@ -63091,6 +63228,7 @@ export {
   traverseRigCFrame,
   traverseRigInstance,
   triangleNormal,
+  updateCameraForHeadshotCustomized,
   versionToNumber,
   vertPosToChunkPos,
   xmlMagic

package/package.json

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