three-mediapipe-rig 0.1.1 → 0.1.3

package/dist/rigger.js

@@ -0,0 +1,864 @@
+var Pe = Object.defineProperty;
+var Ee = (h, o, e) => o in h ? Pe(h, o, { enumerable: !0, configurable: !0, writable: !0, value: e }) : h[o] = e;
+var R = (h, o, e) => Ee(h, typeof o != "symbol" ? o + "" : o, e);
+import { PoseLandmarker as Le, HandLandmarker as G, FaceLandmarker as j, FilesetResolver as We, DrawingUtils as ge } from "@mediapipe/tasks-vision";
+import * as p from "three/webgpu";
+import { Vector3 as b, Quaternion as ke, VideoTexture as Z, SRGBColorSpace as J, MeshPhysicalNodeMaterial as Fe } from "three/webgpu";
+import * as C from "three";
+import { Bone as Ae } from "three";
+import { uniform as D, attribute as Se, instancedArray as Me, varying as Ve, vec3 as Ne, float as Oe, texture as Te, vec2 as _e } from "three/tsl";
+import { c as Ce, F as De } from "./face-tracker-utils-xt9__vBF.js";
+import { GLTFExporter as ze } from "three/examples/jsm/Addons.js";
+const U = new b(), ee = new b(), Be = new b(1, 0, 0), Ue = new b(-1, 0, 0), Ie = new b(0, 1, 0), He = new b(0, -1, 0), te = new b(0, 0, 1);
+new b(0, 0, -1);
+const oe = new b(), Ge = new b(), je = new b(), se = new ke(), I = new ke();
+function S(h, o, e, t = "+x") {
+  h.lookAt(o);
+  const s = t == "+x" ? Be : t == "-x" ? Ue : t == "+y" ? Ie : He;
+  h.getWorldPosition(ee), h.getWorldQuaternion(I), U.subVectors(e, ee).normalize(), oe.copy(s).applyQuaternion(I);
+  const n = oe, d = Ge.copy(te).applyQuaternion(I), i = U.clone().addScaledVector(d, -U.dot(d)).normalize(), r = je.crossVectors(n, i), m = Math.atan2(r.dot(d), n.dot(i));
+  se.setFromAxisAngle(te, m), h.quaternion.multiply(se);
+}
+const z = new p.Vector3(), O = new p.Vector3(), H = new p.Vector3();
+new p.Vector3();
+class q {
+  constructor(o, e) {
+    R(this, "objectGhost");
+    R(this, "root");
+    /**
+     * per landmark index, it points to it's object3D equivalent.
+     */
+    R(this, "marks", {});
+    this.points = o, this.debugConnections = e, this.root = new p.Object3D(), this.objectGhost = /* @__PURE__ */ new Map();
+    for (let t in this.points)
+      this.marks[t] = new qe(), this.root.add(this.marks[t]);
+  }
+  updateLandmarks(o, e, t) {
+    for (let s in this.points) {
+      const n = this.points[s], d = this.marks[s];
+      d && (n instanceof Array ? (z.copy(o[n[0]]), d.position.copy(o[n[1]]).sub(z).divideScalar(2).add(o[n[0]]), n.length == 4 && (z.subVectors(
+        o[n[3]],
+        o[n[2]]
+      ).divideScalar(2).add(o[n[2]]).sub(d.position).divideScalar(2), d.position.add(z))) : d.position.copy(o[n]));
+    }
+    t && e && t.drawConnectors(
+      e,
+      this.debugConnections,
+      {
+        lineWidth: 1
+      }
+    );
+  }
+  getGhost(o) {
+    var e;
+    if (!this.objectGhost.has(o)) {
+      const t = new $e();
+      t.position.copy(o.position), t.quaternion.copy(o.quaternion), (e = o.parent) == null || e.add(t), this.objectGhost.set(o, t);
+    }
+    return this.objectGhost.get(o);
+  }
+  predict(o, e) {
+    throw new Error("Method 'predict' must be implemented.");
+  }
+  sync(o, e) {
+    throw new Error("Method 'sync' must be implemented.");
+  }
+  test(o) {
+    this.marks[o].position.set(1, 2, 3);
+  }
+  syncObjects(o, e, t) {
+    for (const [s, n, d, i] of o) {
+      this.marks[d].getWorldPosition(H), this.marks[n].getWorldPosition(O);
+      const r = H.sub(O);
+      s.getWorldPosition(O), O.add(r);
+      const m = O, l = s.getWorldPosition(H).sub(t), u = this.getGhost(s);
+      S(u, m, l, i), u.rotateX(Math.PI / 2), s.position.lerp(u.position, e * 4), s.quaternion.slerp(u.quaternion, e * 4);
+    }
+  }
+  getBone(o, e) {
+    return o.getObjectByName(e.replace(/[\.\:]/g, ""));
+  }
+}
+class qe extends p.Mesh {
+  constructor() {
+    super(new p.SphereGeometry(0.01, 3, 3), new p.MeshStandardMaterial({ color: 16711680, wireframe: !0 }));
+    R(this, "_worldPosition", new p.Vector3());
+    this.add(new p.AxesHelper(1e-3));
+  }
+  get worldPosition() {
+    return this.getWorldPosition(this._worldPosition), this._worldPosition;
+  }
+}
+class $e extends p.Object3D {
+  lerp(o, e, t = 8) {
+    o.position.lerp(this.position, e * t), o.quaternion.slerp(this.quaternion, e * t);
+  }
+}
+function A(h, o, e) {
+  return e.worldToLocal(o.getWorldPosition(h)), h;
+}
+function Ke(h) {
+  return h.replace(/[\.\:]/g, "");
+}
+function P(h, o) {
+  let e;
+  return o = Ke(o), h.traverse((t) => {
+    t.name.indexOf(o) === 0 && t instanceof Ae && (e = t);
+  }), e || console.log("Bone not found: ", o, h.name), e;
+}
+async function Xe(h, o) {
+  const e = await Le.createFromOptions(h, {
+    baseOptions: {
+      modelAssetPath: (o == null ? void 0 : o.modelPath) ?? "pose_landmarker_lite.task",
+      //modelAssetPath: `https://storage.googleapis.com/mediapipe-models/pose_landmarker/pose_landmarker_lite/float16/1/pose_landmarker_lite.task`,
+      //modelAssetPath: "https://storage.googleapis.com/mediapipe-models/pose_landmarker/pose_landmarker_heavy/float16/latest/pose_landmarker_heavy.task",
+      delegate: "GPU"
+    },
+    runningMode: "VIDEO",
+    numPoses: 1
+  });
+  return new tt(e, o);
+}
+const Qe = {
+  hips: [24, 23],
+  neck: [12, 11],
+  leftLeg: 23,
+  leftKnee: 25,
+  leftFoot: 27,
+  leftToes: 31,
+  leftArm: 11,
+  leftElbow: 13,
+  leftWrist: 15,
+  rightLeg: 24,
+  rightKnee: 26,
+  rightFoot: 28,
+  rightToes: 32,
+  rightArm: 12,
+  rightElbow: 14,
+  rightWrist: 16,
+  head: [8, 7],
+  mouth: [10, 9],
+  torso: [24, 23, 12, 11],
+  leftEar: 7,
+  rightEar: 8
+}, Ye = new p.Vector3(), ne = new p.Vector3(), Ze = new p.Vector3(), Je = new p.Vector3(), et = new p.Vector3(), ie = new p.Vector3(), re = new p.Vector3();
+class tt extends q {
+  constructor(e, t) {
+    super(Qe, Le.POSE_CONNECTIONS);
+    R(this, "_leftWristNormalizedPosition");
+    R(this, "_rightWristNormalizedPosition");
+    this.poseLandmarker = e, this.config = t, this.root.scale.y *= -2, this.root.scale.z *= -2, this.root.scale.x *= 2;
+  }
+  /**
+   * Position of the left wrist in normalized coordinates (0..1)
+   */
+  get leftWristNormalizedPosition() {
+    return this._leftWristNormalizedPosition;
+  }
+  /**
+   * Position of the right wrist in normalized coordinates (0..1)
+   */
+  get rightWristNormalizedPosition() {
+    return this._rightWristNormalizedPosition;
+  }
+  predict(e, t) {
+    this.poseLandmarker.detectForVideo(e, performance.now(), (s) => {
+      var n;
+      s.landmarks.length != 0 && (this.updateLandmarks(s.worldLandmarks[0], ((n = this.config) == null ? void 0 : n.drawLandmarks) === !1 ? void 0 : s.landmarks[0], t), this._leftWristNormalizedPosition = s.landmarks[0][this.points.leftWrist], this._rightWristNormalizedPosition = s.landmarks[0][this.points.rightWrist]);
+    });
+  }
+  // override sync ( delta:number, objects: BoneBinding[] ) {
+  // 	const hipsPos = this.marks.hips.getWorldPosition(C); 
+  // 	this.marks.rightArm.getWorldPosition(A).sub(hipsPos);
+  // 	this.marks.leftArm.getWorldPosition(B).sub(hipsPos); 
+  // 	const torsoNormal = C.crossVectors(A,B);
+  // 	this.syncObjects(objects, delta, torsoNormal); 
+  // }
+  bind(e, t) {
+    var r;
+    const s = {
+      hips: P(e, t.hips),
+      neck: P(e, t.neck),
+      leftArm: P(e, t.armL),
+      leftElbow: P(e, t.forearmL),
+      leftWrist: P(e, t.handL),
+      rightArm: P(e, t.armR),
+      rightElbow: P(e, t.forearmR),
+      rightWrist: P(e, t.handR),
+      head: P(e, t.head),
+      torso: P(e, t.torso),
+      leftLeg: P(e, t.thighL),
+      leftKnee: P(e, t.shinL),
+      leftFoot: P(e, t.footL),
+      rightLeg: P(e, t.thighR),
+      rightKnee: P(e, t.shinR),
+      rightFoot: P(e, t.footR)
+    };
+    (r = this.config) != null && r.ignoreLegs && (delete s.leftLeg, delete s.leftKnee, delete s.leftFoot, delete s.leftToes, delete s.rightLeg, delete s.rightKnee, delete s.rightFoot, delete s.rightToes);
+    const n = new p.Vector3(), d = new p.Vector3(), i = (m, l, u, y, x, W) => {
+      if (!l) return;
+      const a = this.marks[y].getWorldPosition(n).sub(this.marks[u].getWorldPosition(d)).normalize();
+      A(ie, l, e).add(a).applyMatrix4(e.matrixWorld), A(re, l, e).add(x).applyMatrix4(e.matrixWorld);
+      const c = this.getGhost(l);
+      S(c, ie, re, W), c.rotateX(Math.PI / 2), c.lerp(l, m);
+    };
+    return {
+      update: (m) => {
+        const l = this.marks.leftLeg.getWorldPosition(Ye).sub(this.marks.rightLeg.getWorldPosition(ne)).normalize(), u = this.marks.leftArm.getWorldPosition(ne).sub(this.marks.rightArm.getWorldPosition(Ze)).normalize(), y = this.marks.leftEar.getWorldPosition(Je).sub(this.marks.rightEar.getWorldPosition(et)).normalize();
+        i(m, s.hips, "hips", "torso", l, "+x"), i(m, s.torso, "torso", "neck", u, "+x"), i(m, s.neck, "neck", "head", y, "+x"), i(m, s.head, "neck", "head", y, "+x"), i(m, s.leftArm, "leftArm", "leftElbow", u, "-x"), i(m, s.leftElbow, "leftElbow", "leftWrist", u, "-x"), i(m, s.leftLeg, "leftLeg", "leftKnee", l, "+x"), i(m, s.leftKnee, "leftKnee", "leftFoot", l, "+x"), i(m, s.leftFoot, "leftFoot", "leftToes", l, "+x"), i(m, s.rightArm, "rightArm", "rightElbow", u, "-x"), i(m, s.rightElbow, "rightElbow", "rightWrist", u, "-x"), i(m, s.rightLeg, "rightLeg", "rightKnee", l, "+x"), i(m, s.rightKnee, "rightKnee", "rightFoot", l, "+x"), i(m, s.rightFoot, "rightFoot", "rightToes", l, "+x");
+      }
+    };
+  }
+}
+const ae = new p.Vector2(), de = new p.Vector2();
+async function ot(h, o) {
+  const e = await G.createFromOptions(h, {
+    baseOptions: {
+      modelAssetPath: o.modelPath ?? "hand_landmarker.task",
+      //modelAssetPath: `https://storage.googleapis.com/mediapipe-models/hand_landmarker/hand_landmarker/float16/1/hand_landmarker.task`,
+      delegate: "GPU"
+    },
+    runningMode: "VIDEO",
+    numHands: 2
+  }), t = (s, n, d) => {
+    try {
+      ae.copy(s()), de.copy(n());
+    } catch (i) {
+      return console.warn("No pose data... will just be optimitic and say yes to everything.", i), !0;
+    }
+    return ae.distanceTo(d) < de.distanceTo(d);
+  };
+  return {
+    left: new we(e, "Left", t.bind(null, o.leftWrist, o.rightWrist), o.drawLandmarks),
+    right: new we(e, "Right", t.bind(null, o.rightWrist, o.leftWrist), o.drawLandmarks)
+  };
+}
+const st = {
+  wrist: 0,
+  palm: [9, 13],
+  thumb1: 1,
+  thumb2: 2,
+  thumb3: 3,
+  thumb4: 4,
+  index1: 5,
+  index2: 6,
+  index3: 7,
+  index4: 8,
+  middle1: 9,
+  middle2: 10,
+  middle3: 11,
+  middle4: 12,
+  ring1: 13,
+  ring2: 14,
+  ring3: 15,
+  ring4: 16,
+  pinky1: 17,
+  pinky2: 18,
+  pinky3: 19,
+  pinky4: 20
+}, T = {
+  thumb: ["thumb1", "thumb2", "thumb3", "thumb4"],
+  index: ["index1", "index2", "index3", "index4"],
+  middle: ["middle1", "middle2", "middle3", "middle4"],
+  ring: ["ring1", "ring2", "ring3", "ring4"],
+  pinky: ["pinky1", "pinky2", "pinky3", "pinky4"]
+}, nt = new p.Vector3(), ce = new p.Vector3(), le = new p.Vector3(), he = new p.Vector3(), me = new p.Vector3(), pe = new p.Vector3();
+new p.Vector3();
+new p.Vector3();
+new p.Vector3();
+const ue = new p.Vector3(), fe = Math.PI / 2, it = new p.Vector3(0, -1, 0);
+class we extends q {
+  constructor(e, t, s, n = !0) {
+    super(st, G.HAND_CONNECTIONS);
+    R(this, "sign");
+    R(this, "isLeft");
+    /**
+     * the axis used to look at the pole
+     */
+    R(this, "lookAtPoleAxis");
+    this.handLandmarker = e, this.side = t, this.isMyWrist = s, this.drawLandmarks = n, this.sign = this.side == "Left" ? -1 : 1, this.isLeft = this.side == "Left", this.lookAtPoleAxis = this.sign < 0 ? "+x" : "-x", this.root.scale.setScalar(7), this.root.scale.y *= -1, this.root.scale.z *= -1;
+  }
+  predict(e, t) {
+    const s = this.handLandmarker.detectForVideo(e, performance.now());
+    if (s.landmarks.length)
+      for (let n = 0; n < s.landmarks.length; n++) {
+        const d = s.landmarks[n], i = d[this.points.wrist];
+        if (this.isMyWrist(i)) {
+          this.updateLandmarks(s.worldLandmarks[n]), this.drawLandmarks && (t.drawConnectors(d, G.HAND_CONNECTIONS, {
+            color: this.side == "Left" ? "#00FF00" : "#0000FF",
+            lineWidth: 4
+          }), t.drawLandmarks(d, { color: this.side == "Left" ? "#00FF00" : "#0000FF", lineWidth: 3, radius: 1 }));
+          break;
+        }
+      }
+  }
+  sync(e, t) {
+    throw new Error("Not used. Use syncHandBones instead");
+  }
+  /**
+   * 
+   * @param delta time since last frame
+   * @param landmark2bones Array the same size as the umber of hand landmarks, and on each positionthe bone that belongs to that point.
+   * @see https://ai.google.dev/edge/mediapipe/solutions/vision/hand_landmarker
+   */
+  syncHandBones(e, t, s) {
+    const n = nt.crossVectors(
+      ce.copy(this.marks.index1.worldPosition).sub(this.marks.wrist.worldPosition),
+      le.copy(this.marks.pinky1.worldPosition).sub(this.marks.wrist.worldPosition)
+    ).normalize(), d = ce.copy(this.marks.palm.worldPosition).sub(this.marks.wrist.worldPosition).normalize(), i = le.copy(this.marks.pinky1.worldPosition).sub(this.marks.index1.worldPosition).normalize();
+    if (!(d.dot(it) > 0.8)) {
+      if (t.wrist) {
+        const r = A(he, t.wrist, s).add(d).applyMatrix4(s.matrixWorld), m = A(me, t.wrist, s).sub(i).applyMatrix4(s.matrixWorld), l = this.getGhost(t.wrist);
+        S(l, r, m, "-y"), l.rotateX(fe), l.lerp(t.wrist, e);
+      }
+      this.syncFinger(e, s, n, d, i, t, T.index, "middle1"), this.syncFinger(e, s, n, d, i, t, T.middle, "ring1"), this.syncFinger(e, s, n, d, i, t, T.ring, "pinky1"), this.syncFinger(e, s, n, d, i, t, T.pinky, "ring1", !0), this.syncFinger(e, s, n, d, i, t, T.thumb, "index1");
+    }
+  }
+  syncFinger(e, t, s, n, d, i, r, m, l = !1) {
+    for (let u = 0; u < r.length - 1; u++) {
+      const y = i[r[u]];
+      if (!y) continue;
+      const x = this.getGhost(y), W = he.copy(this.marks[r[u + 1]].worldPosition).sub(this.marks[r[u]].worldPosition).normalize(), a = A(me, y, t);
+      if (u == 0) {
+        const c = pe.copy(this.marks[m].worldPosition).sub(this.marks[r[0]].worldPosition).normalize();
+        l && c.negate(), ue.copy(c), S(
+          x,
+          W.add(a).applyMatrix4(t.matrixWorld),
+          c.add(a).applyMatrix4(t.matrixWorld),
+          this.lookAtPoleAxis
+        );
+      } else
+        S(
+          x,
+          W.add(a).applyMatrix4(t.matrixWorld),
+          pe.copy(ue).add(a).applyMatrix4(t.matrixWorld),
+          this.lookAtPoleAxis
+        );
+      x.rotateX(fe), x.lerp(y, e);
+    }
+  }
+  bind(e, t) {
+    const s = {}, n = (d, i) => {
+      const r = P(e, d);
+      if (r)
+        return s[i] = r, i;
+    };
+    return n(this.isLeft ? t.handL : t.handR, "wrist"), n(this.isLeft ? t.index1L : t.index1R, "index1"), n(this.isLeft ? t.index2L : t.index2R, "index2"), n(this.isLeft ? t.index3L : t.index3R, "index3"), n(this.isLeft ? t.middle1L : t.middle1R, "middle1"), n(this.isLeft ? t.middle2L : t.middle2R, "middle2"), n(this.isLeft ? t.middle3L : t.middle3R, "middle3"), n(this.isLeft ? t.ring1L : t.ring1R, "ring1"), n(this.isLeft ? t.ring2L : t.ring2R, "ring2"), n(this.isLeft ? t.ring3L : t.ring3R, "ring3"), n(this.isLeft ? t.pinky1L : t.pinky1R, "pinky1"), n(this.isLeft ? t.pinky2L : t.pinky2R, "pinky2"), n(this.isLeft ? t.pinky3L : t.pinky3R, "pinky3"), n(this.isLeft ? t.thumb1L : t.thumb1R, "thumb1"), n(this.isLeft ? t.thumb2L : t.thumb2R, "thumb2"), n(this.isLeft ? t.thumb3L : t.thumb3R, "thumb3"), {
+      update: (d) => {
+        this.syncHandBones(d, s, e);
+      }
+    };
+  }
+}
+async function rt(h, o) {
+  const e = await j.createFromOptions(h, {
+    baseOptions: {
+      modelAssetPath: (o == null ? void 0 : o.modelPath) ?? "face_landmarker.task",
+      delegate: "GPU"
+    },
+    outputFaceBlendshapes: !0,
+    runningMode: "VIDEO",
+    numFaces: 1
+  });
+  return new mt(e, { ...o });
+}
+const at = {
+  eyeL: 473,
+  eyeR: 468,
+  eyeStartL: 463,
+  eyeStartR: 243,
+  eyeEndL: 263,
+  eyeEndR: 33,
+  earL: 454,
+  earR: 234,
+  noseTip: 4,
+  noseBone: 6,
+  chin: 152,
+  forehead: 10
+}, dt = new b(), ct = new b(), be = new b(), lt = new b(), ht = new b();
+new b();
+class mt extends q {
+  constructor(e, t) {
+    super(at, j.FACE_LANDMARKS_TESSELATION);
+    R(this, "blendshapeCategories");
+    R(this, "blendshapeMap", /* @__PURE__ */ new Map());
+    R(this, "smoothed", {});
+    R(this, "smoothing", 3e-4);
+    // lower = smoother but more lag, higher = more responsive
+    R(this, "_faceLandmarks", []);
+    this.faceLandmarker = e, this.cfg = t, this.root.scale.y *= -1, this.root.scale.z *= -1, this.root.scale.multiplyScalar(3);
+  }
+  predict(e, t) {
+    var n, d, i;
+    const s = this.faceLandmarker.detectForVideo(e, performance.now());
+    s.faceLandmarks[0] && (this.cfg.drawLandmarks && (t.drawConnectors(s.faceLandmarks[0], j.FACE_LANDMARKS_TESSELATION, { color: "#00fff2ff", lineWidth: 0.1 }), t.drawLandmarks(s.faceLandmarks[0], { color: "#00ff00", lineWidth: 0.1, radius: 0.4 })), this.updateLandmarks(s.faceLandmarks[0], s.faceLandmarks[0])), this._faceLandmarks = s.faceLandmarks[0], this.blendshapeCategories = (d = (n = s.faceBlendshapes) == null ? void 0 : n[0]) == null ? void 0 : d.categories, (i = this.blendshapeCategories) == null || i.forEach((r) => {
+      this.blendshapeMap.set(r.categoryName, r.score);
+    });
+  }
+  get lastKnownLandmarks() {
+    return this._faceLandmarks;
+  }
+  bindShapeKeys(e) {
+    const t = e.morphTargetDictionary;
+    return {
+      update: (s) => {
+        var n;
+        (n = this.blendshapeCategories) == null || n.forEach((d) => {
+          const { categoryName: i, score: r } = d;
+          if (!(t != null && t.hasOwnProperty(i))) return;
+          this.smoothed[i] === void 0 && (this.smoothed[i] = r);
+          const m = 1 - Math.pow(this.smoothing, s);
+          this.smoothed[i] += (r - this.smoothed[i]) * m, e.morphTargetInfluences[t[i]] = this.smoothed[i];
+        });
+      }
+    };
+  }
+  bind(e) {
+    const t = new ye(e, "L"), s = new ye(e, "R"), n = P(e, "head");
+    return {
+      update: (d) => {
+        if (t.update(d, this.blendshapeMap), s.update(d, this.blendshapeMap), !n) return;
+        const i = dt.copy(this.marks.earL.worldPosition), r = ct.copy(this.marks.earR.worldPosition), m = be.subVectors(i, r).multiplyScalar(0.5).add(r), l = lt.subVectors(this.marks.noseTip.worldPosition, m), u = i.sub(r), y = A(ht, n, e), x = u.add(y).applyMatrix4(e.matrixWorld), W = l.add(y).applyMatrix4(e.matrixWorld);
+        S(n, W, x, "+x");
+      }
+    };
+  }
+  /**
+   * The mesh is assumed to be a canonical_face_model because we will be manipulating it's vertices.
+   * 
+   * @see https://github.com/google-ai-edge/mediapipe/tree/master/mediapipe/modules/face_geometry
+   * @param mesh basically either the original or a clone of the canonical_face_model
+   * @returns an object with a disposeMaterial method that should be called when the mesh is disposed of.
+   */
+  bindGeometry(e, t) {
+    new b(), new b();
+    const s = new b();
+    new b();
+    const d = e.geometry.attributes.position;
+    D(new b(0.5, 0.5, 0.5)), Ce(e);
+    const i = Se("landmarkIndex", "uint"), r = Me(De, "vec3"), m = Ve(r.element(i)).xy;
+    let l;
+    const u = 116, y = 346, x = s.subVectors(
+      new b(d.getX(u), d.getY(u), d.getZ(u)),
+      new b(d.getX(y), d.getY(y), d.getZ(y))
+    ).lengthSq();
+    console.log("# mesh face reference (live): ", x);
+    const W = D(x), a = D(1);
+    let c;
+    return {
+      /**
+       * Disposes of the material and removes events listeners on the video element.
+       */
+      disposeMaterial: () => {
+        c == null || c();
+      },
+      /**
+       * asas
+       * @param delta asas
+       * @returns 
+       */
+      update: (L) => {
+        var E, g;
+        if (!l) {
+          const k = (g = (E = this.cfg) == null ? void 0 : E.videoElementRef) == null ? void 0 : g.call(E);
+          if (!k || !k.videoWidth || !k.videoHeight) return;
+          l = k;
+          const f = new Z(l);
+          f.colorSpace = J;
+          const F = D(l.videoWidth / l.videoHeight), _ = r.element(y).sub(r.element(u)).lengthSq(), B = W.div(_).sqrt().mul(2), M = r.element(234).xy, $ = r.element(93).xy, Re = r.element(454).xy, K = r.element(323).xy, X = M.sub($).div(2).add($), ve = Re.sub(K).div(2).add(K).sub(X).div(2).add(X), Q = r.element(i).sub(ve).xzy.mul(Ne(1, -1, Oe(1).div(F))).mul(B), V = Te(f, _e(m.x, m.y.oneMinus())), Y = () => {
+            const N = new Z(l);
+            N.colorSpace = J, V.value = N, V.needsUpdate = !0, F.value = l.videoWidth / l.videoHeight;
+          };
+          l.addEventListener("loadeddata", Y), t ? t(Q, V) : e.material = new Fe({
+            positionNode: Q,
+            colorNode: V,
+            roughness: 0.93
+          }), c = () => {
+            var N;
+            V.value.dispose(), l == null || l.removeEventListener("loadeddata", Y), (N = e.material) == null || N.dispose();
+          };
+        }
+        const w = this.lastKnownLandmarks;
+        if (!(w != null && w.length)) return;
+        a.value = s.subVectors(w[y], w[u]).lengthSq(), a.needsUpdate = !0;
+        const v = r.value.array;
+        for (let k = 0; k < w.length; k++)
+          v[k * 3] = w[k].x, v[k * 3 + 1] = w[k].y, v[k * 3 + 2] = w[k].z;
+        r.value.needsUpdate = !0;
+      }
+    };
+  }
+}
+class ye {
+  constructor(o, e) {
+    R(this, "eyeBone");
+    R(this, "eyeLookOut");
+    R(this, "eyeLookIn");
+    R(this, "eyeLookUp");
+    R(this, "eyeLookDown");
+    R(this, "sign", 1);
+    this.rig = o, this.side = e, this.eyeBone = o.getObjectByName(`eye${e}`);
+    const t = e == "L" ? "Left" : "Right";
+    this.eyeLookOut = `eyeLookOut${t}`, this.eyeLookIn = `eyeLookIn${t}`, this.eyeLookUp = `eyeLookUp${t}`, this.eyeLookDown = `eyeLookDown${t}`, this.sign = e == "L" ? -1 : 1;
+  }
+  update(o, e) {
+    if (!this.eyeBone) return;
+    A(be, this.eyeBone, this.rig);
+    const t = e.get(this.eyeLookOut) ?? 0, s = e.get(this.eyeLookIn) ?? 0, n = e.get(this.eyeLookUp) ?? 0, d = e.get(this.eyeLookDown) ?? 0, i = s - t, r = d - n;
+    this.eyeBone.rotation.y = i * this.sign / 2, this.eyeBone.rotation.x = r / 2;
+  }
+}
+const xe = {
+  faceMesh: "face",
+  head: "head",
+  hips: "hips",
+  neck: "neck",
+  torso: "torso",
+  armL: "upper_armL",
+  forearmL: "forearmL",
+  armR: "upper_armR",
+  forearmR: "forearmR",
+  thighL: "thighL",
+  shinL: "shinL",
+  footL: "footL",
+  toesL: "toesL",
+  thighR: "thighR",
+  shinR: "shinR",
+  footR: "footR",
+  toesR: "toesR",
+  handL: "handL",
+  index1L: "index1L",
+  index2L: "index2L",
+  index3L: "index3L",
+  middle1L: "middle1L",
+  middle2L: "middle2L",
+  middle3L: "middle3L",
+  ring1L: "ring1L",
+  ring2L: "ring2L",
+  ring3L: "ring3L",
+  pinky1L: "pinky1L",
+  pinky2L: "pinky2L",
+  pinky3L: "pinky3L",
+  thumb1L: "thumb1L",
+  thumb2L: "thumb2L",
+  thumb3L: "thumb3L",
+  handR: "handR",
+  index1R: "index1R",
+  index2R: "index2R",
+  index3R: "index3R",
+  middle1R: "middle1R",
+  middle2R: "middle2R",
+  middle3R: "middle3R",
+  ring1R: "ring1R",
+  ring2R: "ring2R",
+  ring3R: "ring3R",
+  pinky1R: "pinky1R",
+  pinky2R: "pinky2R",
+  pinky3R: "pinky3R",
+  thumb1R: "thumb1R",
+  thumb2R: "thumb2R",
+  thumb3R: "thumb3R"
+}, pt = [
+  "eyeBlinkLeft",
+  "eyeBlinkRight",
+  "eyeLookDownLeft",
+  "eyeLookDownRight",
+  "eyeLookInLeft",
+  "eyeLookInRight",
+  "eyeLookOutLeft",
+  "eyeLookOutRight",
+  "eyeLookUpLeft",
+  "eyeLookUpRight",
+  "eyeSquintLeft",
+  "eyeSquintRight",
+  "eyeWideLeft",
+  "eyeWideRight",
+  "browDownLeft",
+  "browDownRight",
+  "browInnerUp",
+  "browOuterUpLeft",
+  "browOuterUpRight",
+  "noseSneerLeft",
+  "noseSneerRight",
+  "cheekPuff",
+  "cheekSquintLeft",
+  "cheekSquintRight",
+  "jawForward",
+  "jawLeft",
+  "jawOpen",
+  "jawRight",
+  "mouthClose",
+  "mouthDimpleLeft",
+  "mouthDimpleRight",
+  "mouthFrownLeft",
+  "mouthFrownRight",
+  "mouthFunnel",
+  "mouthLeft",
+  "mouthLowerDownLeft",
+  "mouthLowerDownRight",
+  "mouthPressLeft",
+  "mouthPressRight",
+  "mouthPucker",
+  "mouthRight",
+  "mouthRollLower",
+  "mouthRollUpper",
+  "mouthShrugLower",
+  "mouthShrugUpper",
+  "mouthSmileLeft",
+  "mouthSmileRight",
+  "mouthStretchLeft",
+  "mouthStretchRight",
+  "mouthUpperUpLeft",
+  "mouthUpperUpRight",
+  "tongueOut"
+];
+function ut(h, o, e = 30) {
+  const t = [], s = h.getObjectByName(
+    o.faceMesh
+  ), n = /* @__PURE__ */ new Set();
+  if (s != null && s.morphTargetDictionary)
+    for (const a in s.morphTargetDictionary)
+      pt.includes(a) && n.add(a);
+  const d = Object.keys(o);
+  h.traverse((a) => {
+    if (a instanceof C.Bone) {
+      const c = d.find((L) => a.name.indexOf(o[L]) === 0);
+      c && t.push({
+        ref: a,
+        name: a.name,
+        normalizedName: c
+      });
+    }
+  });
+  const i = [], r = /* @__PURE__ */ new Map(), m = /* @__PURE__ */ new Map();
+  let l = !1, u = 0;
+  function y() {
+    r.clear(), m.clear(), i.length = 0, u = performance.now() / 1e3, l = !0;
+  }
+  function x() {
+    if (!l) return;
+    const a = performance.now() / 1e3 - u;
+    i.push(a);
+    for (const c of t) {
+      r.has(c.name) || r.set(c.name, []);
+      const L = r.get(c.name), w = c.ref.quaternion;
+      L.push(w.x, w.y, w.z, w.w);
+    }
+    for (const c of n) {
+      m.has(c) || m.set(c, []);
+      const L = m.get(c), w = s.morphTargetDictionary[c], v = s.morphTargetInfluences[w];
+      L.push(v);
+    }
+  }
+  function W(a = "RecordedClip") {
+    l = !1;
+    const c = [];
+    for (const [w, v] of r)
+      c.push(
+        new C.QuaternionKeyframeTrack(
+          `${w}.quaternion`,
+          i,
+          v
+        )
+      );
+    for (const [w, v] of m)
+      c.push(
+        new C.NumberKeyframeTrack(
+          `${xe.faceMesh}.morphTargetInfluences[${w}]`,
+          i,
+          v
+        )
+      );
+    const L = new C.AnimationClip(a, -1, c);
+    return {
+      clip: L,
+      saveToFile: () => {
+        new ze().parse(
+          h,
+          (v) => {
+            const E = new Blob([v], {
+              type: "model/gltf-binary"
+            }), g = URL.createObjectURL(E), k = document.createElement("a");
+            k.href = g, k.download = a + ".glb", k.click();
+          },
+          (v) => {
+            console.error(v);
+          },
+          {
+            binary: !0,
+            animations: [L]
+          }
+        );
+      }
+    };
+  }
+  return { start: y, captureFrame: x, stop: W, isRecording: () => l };
+}
+const ft = () => {
+  var h;
+  return !!((h = navigator.mediaDevices) != null && h.getUserMedia);
+};
+async function Pt(h) {
+  const o = {
+    debugFrame: void 0,
+    displayScale: 1,
+    ignoreLegs: !1,
+    debugVideo: void 0,
+    ignoreFace: !1,
+    onlyFace: !1,
+    drawLandmarksOverlay: !0,
+    modelPaths: {
+      vision: "https://cdn.jsdelivr.net/npm/@mediapipe/tasks-vision@0.10.3/wasm",
+      pose: "https://storage.googleapis.com/mediapipe-models/pose_landmarker/pose_landmarker_lite/float16/1/pose_landmarker_lite.task",
+      hand: "https://storage.googleapis.com/mediapipe-models/hand_landmarker/hand_landmarker/float16/1/hand_landmarker.task",
+      face: "https://storage.googleapis.com/mediapipe-models/face_landmarker/face_landmarker/float16/1/face_landmarker.task"
+    },
+    ...h
+  };
+  let e;
+  const t = await We.forVisionTasks(o.modelPaths.vision ?? "/wasm"), s = o.onlyFace ? void 0 : await Xe(t, {
+    ignoreLegs: o.ignoreLegs,
+    modelPath: o.modelPaths.pose,
+    drawLandmarks: o.drawLandmarksOverlay
+  }), n = o.onlyFace ? void 0 : await ot(t, {
+    leftWrist: () => s.leftWristNormalizedPosition,
+    rightWrist: () => s.rightWristNormalizedPosition,
+    modelPath: o.modelPaths.hand,
+    drawLandmarks: o.drawLandmarksOverlay,
+    ...h == null ? void 0 : h.handsTrackerOptions
+  }), d = o.ignoreFace ? void 0 : await rt(t, { modelPath: o.modelPaths.face, videoElementRef: () => e, drawLandmarks: o.drawLandmarksOverlay }), i = document.createElement("div");
+  i.style.position = "absolute", i.style.top = "0px", i.style.left = "0px", i.style.zIndex = "21", i.style.maxWidth = "600px", i.style.width = "100%", i.classList.add("three-mediapipe-rig"), document.body.appendChild(i);
+  const r = document.createElement("canvas"), m = r.getContext("2d"), l = new ge(m);
+  r.style.zIndex = "22", r.style.position = "absolute", r.style.top = "0px", r.style.left = "0px", r.style.pointerEvents = "none", r.style.maxWidth = "100%", i.appendChild(r);
+  function u(a) {
+    m.save(), m.clearRect(0, 0, r.width, r.height), s == null || s.predict(a, l), n == null || n.left.predict(a, l), n == null || n.right.predict(a, l), d == null || d.predict(a, l), m.restore();
+  }
+  function y() {
+    e = document.createElement("video"), i.appendChild(e);
+    let a = -1;
+    e.style.zIndex = "21", e.style.position = "absolute", e.style.top = "0px", e.style.left = "0px", e.style.height = "auto", e.style.maxWidth = "100%", e.style.display = "block", e.muted = !1, o.debugVideo && (e.src = o.debugVideo, e.controls = !0, e.loop = !0, e.muted = !0, e.controls = !0, e.play());
+    function c() {
+      a !== e.currentTime && e.readyState >= 2 && (u(e), a = e.currentTime), window.requestAnimationFrame(c);
+    }
+    e.addEventListener("loadeddata", () => {
+      const L = e.videoWidth, w = e.videoHeight, g = Math.min(600 / L, 600 / w, 1);
+      e.width = L * g * (o.displayScale ?? 1), e.height = w * g * (o.displayScale ?? 1), r.width = e.width, r.height = e.height, r.style.height = "auto", r.style.width = e.width + "px", r.style.maxWidth = "100%", window.requestAnimationFrame(c);
+    });
+  }
+  if (o.debugFrame) {
+    const a = document.createElement("img");
+    a.src = o.debugFrame, a.style.zIndex = "21", a.style.position = "absolute", a.style.top = "0px", a.style.left = "0px", i.appendChild(a), a.addEventListener("load", () => {
+      a.width = a.naturalWidth * o.displayScale, a.height = a.naturalHeight * o.displayScale, r.width = a.naturalWidth, r.height = a.naturalWidth, r.style.width = a.width + "px", r.style.height = a.height + "px";
+      function c() {
+        u(a);
+      }
+      window.requestAnimationFrame(c);
+    });
+  } else o.debugVideo && y();
+  let x;
+  function W(a) {
+    e && (e.srcObject ? e.srcObject.getTracks().forEach((L) => L.enabled = a) : a ? e.play() : e.pause());
+  }
+  return {
+    poseTracker: s,
+    handsTracker: n,
+    faceTracker: d,
+    video: e,
+    canvas: r,
+    domElement: i,
+    start: async (a = !1) => {
+      let c = !1;
+      if (!ft())
+        throw new Error("Webcam not supported");
+      e || y();
+      let L;
+      function w(f) {
+        c || (console.warn("Camera track ended, attempting recovery..."), v(f), E(f));
+      }
+      function v(f) {
+        L == null || L.getVideoTracks().forEach((F) => F.stop()), L = void 0, f.srcObject = null;
+      }
+      async function E(f, F = 0) {
+        const B = Math.min(1e3 * 2 ** F, 16e3);
+        if (F >= 3)
+          throw new Error("Camera recovery failed after max attempts");
+        if (await new Promise((M) => setTimeout(M, B)), !c)
+          try {
+            await g(f);
+          } catch (M) {
+            await k(M, f, F + 1);
+          }
+      }
+      async function g(f) {
+        L = await navigator.mediaDevices.getUserMedia({ video: !0, audio: a }), f.srcObject = L, await f.play(), L.getVideoTracks().forEach((F) => {
+          F.addEventListener("ended", () => w(f));
+        });
+      }
+      async function k(f, F, _ = 0) {
+        if (f instanceof DOMException)
+          switch (f.name) {
+            case "NotAllowedError":
+              throw new Error("Permission denied — prompt user to allow camera");
+            case "NotFoundError":
+              console.error("No camera found — retry when device is connected"), await E(F, _ + 1);
+              break;
+            case "NotReadableError":
+              throw new Error("Camera in use by another app");
+            default:
+              throw new Error("Camera error: " + f.message);
+          }
+        else
+          throw new Error("Unknown camera error: " + f);
+      }
+      return await E(e), x = () => {
+        c = !0, v(e), x = void 0;
+      }, {
+        getStream: () => L,
+        stop: x
+      };
+    },
+    pause: () => {
+      W(!1);
+    },
+    resume: () => {
+      W(!0);
+    },
+    bind: (a, c) => {
+      if (c = c || xe, !s) throw new Error("Pose tracker not initialized");
+      if (!n) throw new Error("Hands tracker not initialized");
+      if (!d) throw new Error("Face tracker not initialized");
+      const L = s.bind(a, c), w = n.left.bind(a, c), v = n.right.bind(a, c);
+      let E;
+      const g = d == null ? void 0 : d.bind(a);
+      a.traverse((f) => {
+        f instanceof p.Mesh && f.name.indexOf(c.faceMesh) === 0 && (f.frustumCulled = !1, E = d == null ? void 0 : d.bindShapeKeys(f));
+      });
+      const k = ut(a, c);
+      return {
+        /**
+         * Will save the tracked movement of the rig to an animation clip.
+         * Only the bones moved by the bone mapping will be recorded.
+         */
+        startRecording: k.start,
+        stopRecording: k.stop,
+        isRecording: () => k.isRecording(),
+        update: (f) => {
+          L.update(f), w.update(f), v.update(f), E == null || E.update(f), g == null || g.update(f), k.isRecording() && k.captureFrame();
+        }
+      };
+    },
+    setVideoFromSource: (a) => {
+      x == null || x(), e || y(), e.src = a instanceof File ? URL.createObjectURL(a) : a, e.controls = !0, e.loop = !0, e.muted = !0, e.controls = !0, e.play();
+    },
+    async setVideoFromWebcam(a = !1) {
+      if (e || y(), x)
+        throw new Error("Webcam already started");
+      return await this.start(a);
+    }
+  };
+}
+export {
+  De as FACE_LANDMARKS_COUNT,
+  Ce as createFaceLandmarksIndexAttribute,
+  Pt as setupTracker
+};