three-mediapipe-rig 0.1.0 → 0.1.2

package/dist/rigger.js

@@ -0,0 +1,853 @@
+var Pe = Object.defineProperty;
+var Ee = (l, o, e) => o in l ? Pe(l, o, { enumerable: !0, configurable: !0, writable: !0, value: e }) : l[o] = e;
+var R = (l, o, e) => Ee(l, typeof o != "symbol" ? o + "" : o, e);
+import { PoseLandmarker as we, HandLandmarker as I, FaceLandmarker as G, FilesetResolver as ge, DrawingUtils as We } from "@mediapipe/tasks-vision";
+import * as u from "three/webgpu";
+import { Vector3 as b, Quaternion as ye, VideoTexture as Q, SRGBColorSpace as Y, MeshPhysicalNodeMaterial as Fe } from "three/webgpu";
+import * as _ from "three";
+import { Bone as Ae } from "three";
+import { uniform as C, 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 z = new b(), Z = new b(), Be = new b(1, 0, 0), Ue = new b(-1, 0, 0), Ie = new b(0, 1, 0), Ge = new b(0, -1, 0), J = new b(0, 0, 1);
+new b(0, 0, -1);
+const ee = new b(), He = new b(), qe = new b(), te = new ye(), B = new ye();
+function F(l, o, e, t = "+x") {
+  l.lookAt(o);
+  const n = t == "+x" ? Be : t == "-x" ? Ue : t == "+y" ? Ie : Ge;
+  l.getWorldPosition(Z), l.getWorldQuaternion(B), z.subVectors(e, Z).normalize(), ee.copy(n).applyQuaternion(B);
+  const s = ee, a = He.copy(J).applyQuaternion(B), i = z.clone().addScaledVector(a, -z.dot(a)).normalize(), r = qe.crossVectors(s, i), m = Math.atan2(r.dot(a), s.dot(i));
+  te.setFromAxisAngle(J, m), l.quaternion.multiply(te);
+}
+const D = new u.Vector3(), N = new u.Vector3(), U = new u.Vector3();
+new u.Vector3();
+class H {
+  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 u.Object3D(), this.objectGhost = /* @__PURE__ */ new Map();
+    for (let t in this.points)
+      this.marks[t] = new $e(), this.root.add(this.marks[t]);
+  }
+  updateLandmarks(o, e, t) {
+    for (let n in this.points) {
+      const s = this.points[n], a = this.marks[n];
+      a && (s instanceof Array ? (D.copy(o[s[0]]), a.position.copy(o[s[1]]).sub(D).divideScalar(2).add(o[s[0]]), s.length == 4 && (D.subVectors(
+        o[s[3]],
+        o[s[2]]
+      ).divideScalar(2).add(o[s[2]]).sub(a.position).divideScalar(2), a.position.add(D))) : a.position.copy(o[s]));
+    }
+    t && e && t.drawConnectors(
+      e,
+      this.debugConnections,
+      {
+        lineWidth: 1
+      }
+    );
+  }
+  getGhost(o) {
+    var e;
+    if (!this.objectGhost.has(o)) {
+      const t = new je();
+      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 [n, s, a, i] of o) {
+      this.marks[a].getWorldPosition(U), this.marks[s].getWorldPosition(N);
+      const r = U.sub(N);
+      n.getWorldPosition(N), N.add(r);
+      const m = N, c = n.getWorldPosition(U).sub(t), f = this.getGhost(n);
+      F(f, m, c, i), f.rotateX(Math.PI / 2), n.position.lerp(f.position, e * 4), n.quaternion.slerp(f.quaternion, e * 4);
+    }
+  }
+  getBone(o, e) {
+    return o.getObjectByName(e.replace(/[\.\:]/g, ""));
+  }
+}
+class $e extends u.Mesh {
+  constructor() {
+    super(new u.SphereGeometry(0.01, 3, 3), new u.MeshStandardMaterial({ color: 16711680, wireframe: !0 }));
+    R(this, "_worldPosition", new u.Vector3());
+    this.add(new u.AxesHelper(1e-3));
+  }
+  get worldPosition() {
+    return this.getWorldPosition(this._worldPosition), this._worldPosition;
+  }
+}
+class je extends u.Object3D {
+  lerp(o, e, t = 8) {
+    o.position.lerp(this.position, e * t), o.quaternion.slerp(this.quaternion, e * t);
+  }
+}
+function W(l, o, e) {
+  return e.worldToLocal(o.getWorldPosition(l)), l;
+}
+function Ke(l) {
+  return l.replace(/[\.\:]/g, "");
+}
+function P(l, o) {
+  let e;
+  return o = Ke(o), l.traverse((t) => {
+    t.name.indexOf(o) === 0 && t instanceof Ae && (e = t);
+  }), e || console.log("Bone not found: ", o, l.name), e;
+}
+async function Xe(l, o) {
+  const e = await we.createFromOptions(l, {
+    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 u.Vector3(), oe = new u.Vector3(), Ze = new u.Vector3(), Je = new u.Vector3(), et = new u.Vector3(), ne = new u.Vector3(), se = new u.Vector3();
+class tt extends H {
+  constructor(e, t) {
+    super(Qe, we.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(), (n) => {
+      var s;
+      n.landmarks.length != 0 && (this.updateLandmarks(n.worldLandmarks[0], ((s = this.config) == null ? void 0 : s.drawLandmarks) === !1 ? void 0 : n.landmarks[0], t), this._leftWristNormalizedPosition = n.landmarks[0][this.points.leftWrist], this._rightWristNormalizedPosition = n.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 n = {
+      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 n.leftLeg, delete n.leftKnee, delete n.leftFoot, delete n.leftToes, delete n.rightLeg, delete n.rightKnee, delete n.rightFoot, delete n.rightToes);
+    const s = new u.Vector3(), a = new u.Vector3(), i = (m, c, f, k, x, d) => {
+      if (!c) return;
+      const h = this.marks[k].getWorldPosition(s).sub(this.marks[f].getWorldPosition(a)).normalize();
+      W(ne, c, e).add(h).applyMatrix4(e.matrixWorld), W(se, c, e).add(x).applyMatrix4(e.matrixWorld);
+      const w = this.getGhost(c);
+      F(w, ne, se, d), w.rotateX(Math.PI / 2), w.lerp(c, m);
+    };
+    return {
+      update: (m) => {
+        const c = this.marks.leftLeg.getWorldPosition(Ye).sub(this.marks.rightLeg.getWorldPosition(oe)).normalize(), f = this.marks.leftArm.getWorldPosition(oe).sub(this.marks.rightArm.getWorldPosition(Ze)).normalize(), k = this.marks.leftEar.getWorldPosition(Je).sub(this.marks.rightEar.getWorldPosition(et)).normalize();
+        i(m, n.hips, "hips", "torso", c, "+x"), i(m, n.torso, "torso", "neck", f, "+x"), i(m, n.neck, "neck", "head", k, "+x"), i(m, n.head, "neck", "head", k, "+x"), i(m, n.leftArm, "leftArm", "leftElbow", f, "-x"), i(m, n.leftElbow, "leftElbow", "leftWrist", f, "-x"), i(m, n.leftLeg, "leftLeg", "leftKnee", c, "+x"), i(m, n.leftKnee, "leftKnee", "leftFoot", c, "+x"), i(m, n.leftFoot, "leftFoot", "leftToes", c, "+x"), i(m, n.rightArm, "rightArm", "rightElbow", f, "-x"), i(m, n.rightElbow, "rightElbow", "rightWrist", f, "-x"), i(m, n.rightLeg, "rightLeg", "rightKnee", c, "+x"), i(m, n.rightKnee, "rightKnee", "rightFoot", c, "+x"), i(m, n.rightFoot, "rightFoot", "rightToes", c, "+x");
+      }
+    };
+  }
+}
+const ie = new u.Vector2(), re = new u.Vector2();
+async function ot(l, o) {
+  const e = await I.createFromOptions(l, {
+    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 = (n, s, a) => {
+    try {
+      ie.copy(n()), re.copy(s());
+    } catch (i) {
+      return console.warn("No pose data... will just be optimitic and say yes to everything.", i), !0;
+    }
+    return ie.distanceTo(a) < re.distanceTo(a);
+  };
+  return {
+    left: new ue(e, "Left", t.bind(null, o.leftWrist, o.rightWrist), o.drawLandmarks),
+    right: new ue(e, "Right", t.bind(null, o.rightWrist, o.leftWrist), o.drawLandmarks)
+  };
+}
+const nt = {
+  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
+}, O = {
+  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"]
+}, st = new u.Vector3(), ae = new u.Vector3(), de = new u.Vector3(), ce = new u.Vector3(), le = new u.Vector3(), he = new u.Vector3();
+new u.Vector3();
+new u.Vector3();
+new u.Vector3();
+const me = new u.Vector3(), pe = Math.PI / 2, it = new u.Vector3(0, -1, 0);
+class ue extends H {
+  constructor(e, t, n, s = !0) {
+    super(nt, I.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 = n, this.drawLandmarks = s, 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 n = this.handLandmarker.detectForVideo(e, performance.now());
+    if (n.landmarks.length)
+      for (let s = 0; s < n.landmarks.length; s++) {
+        const a = n.landmarks[s], i = a[this.points.wrist];
+        if (this.isMyWrist(i)) {
+          this.updateLandmarks(n.worldLandmarks[s]), this.drawLandmarks && (t.drawConnectors(a, I.HAND_CONNECTIONS, {
+            color: this.side == "Left" ? "#00FF00" : "#0000FF",
+            lineWidth: 4
+          }), t.drawLandmarks(a, { 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, n) {
+    const s = st.crossVectors(
+      ae.copy(this.marks.index1.worldPosition).sub(this.marks.wrist.worldPosition),
+      de.copy(this.marks.pinky1.worldPosition).sub(this.marks.wrist.worldPosition)
+    ).normalize(), a = ae.copy(this.marks.palm.worldPosition).sub(this.marks.wrist.worldPosition).normalize(), i = de.copy(this.marks.pinky1.worldPosition).sub(this.marks.index1.worldPosition).normalize();
+    if (!(a.dot(it) > 0.8)) {
+      if (t.wrist) {
+        const r = W(ce, t.wrist, n).add(a).applyMatrix4(n.matrixWorld), m = W(le, t.wrist, n).sub(i).applyMatrix4(n.matrixWorld), c = this.getGhost(t.wrist);
+        F(c, r, m, "-y"), c.rotateX(pe), c.lerp(t.wrist, e);
+      }
+      this.syncFinger(e, n, s, a, i, t, O.index, "middle1"), this.syncFinger(e, n, s, a, i, t, O.middle, "ring1"), this.syncFinger(e, n, s, a, i, t, O.ring, "pinky1"), this.syncFinger(e, n, s, a, i, t, O.pinky, "ring1", !0), this.syncFinger(e, n, s, a, i, t, O.thumb, "index1");
+    }
+  }
+  syncFinger(e, t, n, s, a, i, r, m, c = !1) {
+    for (let f = 0; f < r.length - 1; f++) {
+      const k = i[r[f]];
+      if (!k) continue;
+      const x = this.getGhost(k), d = ce.copy(this.marks[r[f + 1]].worldPosition).sub(this.marks[r[f]].worldPosition).normalize(), h = W(le, k, t);
+      if (f == 0) {
+        const w = he.copy(this.marks[m].worldPosition).sub(this.marks[r[0]].worldPosition).normalize();
+        c && w.negate(), me.copy(w), F(
+          x,
+          d.add(h).applyMatrix4(t.matrixWorld),
+          w.add(h).applyMatrix4(t.matrixWorld),
+          this.lookAtPoleAxis
+        );
+      } else
+        F(
+          x,
+          d.add(h).applyMatrix4(t.matrixWorld),
+          he.copy(me).add(h).applyMatrix4(t.matrixWorld),
+          this.lookAtPoleAxis
+        );
+      x.rotateX(pe), x.lerp(k, e);
+    }
+  }
+  bind(e, t) {
+    const n = {}, s = (a, i) => {
+      const r = P(e, a);
+      if (r)
+        return n[i] = r, i;
+    };
+    return s(this.isLeft ? t.handL : t.handR, "wrist"), s(this.isLeft ? t.index1L : t.index1R, "index1"), s(this.isLeft ? t.index2L : t.index2R, "index2"), s(this.isLeft ? t.index3L : t.index3R, "index3"), s(this.isLeft ? t.middle1L : t.middle1R, "middle1"), s(this.isLeft ? t.middle2L : t.middle2R, "middle2"), s(this.isLeft ? t.middle3L : t.middle3R, "middle3"), s(this.isLeft ? t.ring1L : t.ring1R, "ring1"), s(this.isLeft ? t.ring2L : t.ring2R, "ring2"), s(this.isLeft ? t.ring3L : t.ring3R, "ring3"), s(this.isLeft ? t.pinky1L : t.pinky1R, "pinky1"), s(this.isLeft ? t.pinky2L : t.pinky2R, "pinky2"), s(this.isLeft ? t.pinky3L : t.pinky3R, "pinky3"), s(this.isLeft ? t.thumb1L : t.thumb1R, "thumb1"), s(this.isLeft ? t.thumb2L : t.thumb2R, "thumb2"), s(this.isLeft ? t.thumb3L : t.thumb3R, "thumb3"), {
+      update: (a) => {
+        this.syncHandBones(a, n, e);
+      }
+    };
+  }
+}
+async function rt(l, o) {
+  const e = await G.createFromOptions(l, {
+    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(), Le = new b(), lt = new b(), ht = new b();
+new b();
+class mt extends H {
+  constructor(e, t) {
+    super(at, G.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 s, a, i;
+    const n = this.faceLandmarker.detectForVideo(e, performance.now());
+    n.faceLandmarks[0] && (this.cfg.drawLandmarks && (t.drawConnectors(n.faceLandmarks[0], G.FACE_LANDMARKS_TESSELATION, { color: "#00fff2ff", lineWidth: 0.1 }), t.drawLandmarks(n.faceLandmarks[0], { color: "#00ff00", lineWidth: 0.1, radius: 0.4 })), this.updateLandmarks(n.faceLandmarks[0], n.faceLandmarks[0])), this._faceLandmarks = n.faceLandmarks[0], this.blendshapeCategories = (a = (s = n.faceBlendshapes) == null ? void 0 : s[0]) == null ? void 0 : a.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: (n) => {
+        var s;
+        (s = this.blendshapeCategories) == null || s.forEach((a) => {
+          const { categoryName: i, score: r } = a;
+          if (!(t != null && t.hasOwnProperty(i))) return;
+          this.smoothed[i] === void 0 && (this.smoothed[i] = r);
+          const m = 1 - Math.pow(this.smoothing, n);
+          this.smoothed[i] += (r - this.smoothed[i]) * m, e.morphTargetInfluences[t[i]] = this.smoothed[i];
+        });
+      }
+    };
+  }
+  bind(e) {
+    const t = new fe(e, "L"), n = new fe(e, "R"), s = P(e, "head");
+    return {
+      update: (a) => {
+        if (t.update(a, this.blendshapeMap), n.update(a, this.blendshapeMap), !s) return;
+        const i = dt.copy(this.marks.earL.worldPosition), r = ct.copy(this.marks.earR.worldPosition), m = Le.subVectors(i, r).multiplyScalar(0.5).add(r), c = lt.subVectors(this.marks.noseTip.worldPosition, m), f = i.sub(r), k = W(ht, s, e), x = f.add(k).applyMatrix4(e.matrixWorld), d = c.add(k).applyMatrix4(e.matrixWorld);
+        F(s, d, 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 n = new b();
+    new b();
+    const a = e.geometry.attributes.position;
+    C(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 c;
+    const f = 116, k = 346, x = n.subVectors(
+      new b(a.getX(f), a.getY(f), a.getZ(f)),
+      new b(a.getX(k), a.getY(k), a.getZ(k))
+    ).lengthSq();
+    console.log("# mesh face reference (live): ", x);
+    const d = C(x), h = C(1);
+    let w;
+    return {
+      /**
+       * Disposes of the material and removes events listeners on the video element.
+       */
+      disposeMaterial: () => {
+        w == null || w();
+      },
+      /**
+       * asas
+       * @param delta asas
+       * @returns 
+       */
+      update: (E) => {
+        var g, L;
+        if (!c) {
+          const p = (L = (g = this.cfg) == null ? void 0 : g.videoElementRef) == null ? void 0 : L.call(g);
+          if (!p || !p.videoWidth || !p.videoHeight) return;
+          c = p;
+          const A = new Q(c);
+          A.colorSpace = Y;
+          const T = C(c.videoWidth / c.videoHeight), S = r.element(k).sub(r.element(f)).lengthSq(), be = d.div(S).sqrt().mul(2), xe = r.element(234).xy, q = r.element(93).xy, Re = r.element(454).xy, $ = r.element(323).xy, j = xe.sub(q).div(2).add(q), ve = Re.sub($).div(2).add($).sub(j).div(2).add(j), K = r.element(i).sub(ve).xzy.mul(Ne(1, -1, Oe(1).div(T))).mul(be), M = Te(A, _e(m.x, m.y.oneMinus())), X = () => {
+            const V = new Q(c);
+            V.colorSpace = Y, M.value = V, M.needsUpdate = !0, T.value = c.videoWidth / c.videoHeight;
+          };
+          c.addEventListener("loadeddata", X), t ? t(K, M) : e.material = new Fe({
+            positionNode: K,
+            colorNode: M,
+            roughness: 0.93
+          }), w = () => {
+            var V;
+            M.value.dispose(), c == null || c.removeEventListener("loadeddata", X), (V = e.material) == null || V.dispose();
+          };
+        }
+        const y = this.lastKnownLandmarks;
+        if (!(y != null && y.length)) return;
+        h.value = n.subVectors(y[k], y[f]).lengthSq(), h.needsUpdate = !0;
+        const v = r.value.array;
+        for (let p = 0; p < y.length; p++)
+          v[p * 3] = y[p].x, v[p * 3 + 1] = y[p].y, v[p * 3 + 2] = y[p].z;
+        r.value.needsUpdate = !0;
+      }
+    };
+  }
+}
+class fe {
+  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;
+    W(Le, this.eyeBone, this.rig);
+    const t = e.get(this.eyeLookOut) ?? 0, n = e.get(this.eyeLookIn) ?? 0, s = e.get(this.eyeLookUp) ?? 0, a = e.get(this.eyeLookDown) ?? 0, i = n - t, r = a - s;
+    this.eyeBone.rotation.y = i * this.sign / 2, this.eyeBone.rotation.x = r / 2;
+  }
+}
+const ke = {
+  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(l, o, e = 30) {
+  const t = [], n = l.getObjectByName(
+    o.faceMesh
+  ), s = /* @__PURE__ */ new Set();
+  if (n != null && n.morphTargetDictionary)
+    for (const h in n.morphTargetDictionary)
+      pt.includes(h) && s.add(h);
+  const a = Object.keys(o);
+  l.traverse((h) => {
+    if (h instanceof _.Bone) {
+      const w = a.find((E) => h.name.indexOf(o[E]) === 0);
+      w && t.push({
+        ref: h,
+        name: h.name,
+        normalizedName: w
+      });
+    }
+  });
+  const i = [], r = /* @__PURE__ */ new Map(), m = /* @__PURE__ */ new Map();
+  let c = !1, f = 0;
+  function k() {
+    r.clear(), m.clear(), i.length = 0, f = performance.now() / 1e3, c = !0;
+  }
+  function x() {
+    if (!c) return;
+    const h = performance.now() / 1e3 - f;
+    i.push(h);
+    for (const w of t) {
+      r.has(w.name) || r.set(w.name, []);
+      const E = r.get(w.name), y = w.ref.quaternion;
+      E.push(y.x, y.y, y.z, y.w);
+    }
+    for (const w of s) {
+      m.has(w) || m.set(w, []);
+      const E = m.get(w), y = n.morphTargetDictionary[w], v = n.morphTargetInfluences[y];
+      E.push(v);
+    }
+  }
+  function d(h = "RecordedClip") {
+    c = !1;
+    const w = [];
+    for (const [y, v] of r)
+      w.push(
+        new _.QuaternionKeyframeTrack(
+          `${y}.quaternion`,
+          i,
+          v
+        )
+      );
+    for (const [y, v] of m)
+      w.push(
+        new _.NumberKeyframeTrack(
+          `${ke.faceMesh}.morphTargetInfluences[${y}]`,
+          i,
+          v
+        )
+      );
+    const E = new _.AnimationClip(h, -1, w);
+    return {
+      clip: E,
+      saveToFile: () => {
+        new ze().parse(
+          l,
+          (v) => {
+            const g = new Blob([v], {
+              type: "model/gltf-binary"
+            }), L = URL.createObjectURL(g), p = document.createElement("a");
+            p.href = L, p.download = h + ".glb", p.click();
+          },
+          (v) => {
+            console.error(v);
+          },
+          {
+            binary: !0,
+            animations: [E]
+          }
+        );
+      }
+    };
+  }
+  return { start: k, captureFrame: x, stop: d, isRecording: () => c };
+}
+const ft = () => {
+  var l;
+  return !!((l = navigator.mediaDevices) != null && l.getUserMedia);
+};
+async function Pt(l) {
+  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"
+    },
+    ...l
+  };
+  let e;
+  const t = await ge.forVisionTasks(o.modelPaths.vision ?? "/wasm"), n = o.onlyFace ? void 0 : await Xe(t, {
+    ignoreLegs: o.ignoreLegs,
+    modelPath: o.modelPaths.pose,
+    drawLandmarks: o.drawLandmarksOverlay
+  }), s = o.onlyFace ? void 0 : await ot(t, {
+    leftWrist: () => n.leftWristNormalizedPosition,
+    rightWrist: () => n.rightWristNormalizedPosition,
+    modelPath: o.modelPaths.hand,
+    drawLandmarks: o.drawLandmarksOverlay,
+    ...l == null ? void 0 : l.handsTrackerOptions
+  }), a = 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"), c = new We(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 f(d) {
+    m.save(), m.clearRect(0, 0, r.width, r.height), n == null || n.predict(d, c), s == null || s.left.predict(d, c), s == null || s.right.predict(d, c), a == null || a.predict(d, c), m.restore();
+  }
+  function k() {
+    e = document.createElement("video"), i.appendChild(e);
+    let d = -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", o.debugVideo && (e.src = o.debugVideo, e.controls = !0, e.loop = !0, e.muted = !0, e.controls = !0, e.play());
+    function h() {
+      d !== e.currentTime && e.readyState >= 2 && (f(e), d = e.currentTime), window.requestAnimationFrame(h);
+    }
+    e.addEventListener("loadeddata", () => {
+      e.width = e.videoWidth * o.displayScale, e.height = e.videoHeight * o.displayScale, r.width = e.videoWidth, r.height = e.videoHeight, r.style.height = e.height + "px", r.style.width = e.width + "px", window.requestAnimationFrame(h);
+    });
+  }
+  if (o.debugFrame) {
+    const d = document.createElement("img");
+    d.src = o.debugFrame, d.style.zIndex = "21", d.style.position = "absolute", d.style.top = "0px", d.style.left = "0px", i.appendChild(d), d.addEventListener("load", () => {
+      d.width = d.naturalWidth * o.displayScale, d.height = d.naturalHeight * o.displayScale, r.width = d.naturalWidth, r.height = d.naturalWidth, r.style.width = d.width + "px", r.style.height = d.height + "px";
+      function h() {
+        f(d);
+      }
+      window.requestAnimationFrame(h);
+    });
+  } else o.debugVideo && k();
+  let x;
+  return {
+    poseTracker: n,
+    handsTracker: s,
+    faceTracker: a,
+    video: e,
+    canvas: r,
+    domElement: i,
+    start: async () => {
+      let d = !1;
+      if (!ft())
+        throw new Error("Webcam not supported");
+      e || k();
+      let h;
+      function w(L) {
+        d || (console.warn("Camera track ended, attempting recovery..."), E(L), y(L));
+      }
+      function E(L) {
+        h == null || h.getVideoTracks().forEach((p) => p.stop()), h = void 0, L.srcObject = null;
+      }
+      async function y(L, p = 0) {
+        const T = Math.min(1e3 * 2 ** p, 16e3);
+        if (p >= 3)
+          throw new Error("Camera recovery failed after max attempts");
+        if (await new Promise((S) => setTimeout(S, T)), !d)
+          try {
+            await v(L);
+          } catch (S) {
+            await g(S, L, p + 1);
+          }
+      }
+      async function v(L) {
+        h = await navigator.mediaDevices.getUserMedia({ video: !0 }), L.srcObject = h, await L.play(), h.getVideoTracks().forEach((p) => {
+          p.addEventListener("ended", () => w(L));
+        });
+      }
+      async function g(L, p, A = 0) {
+        if (L instanceof DOMException)
+          switch (L.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 y(p, A + 1);
+              break;
+            case "NotReadableError":
+              throw new Error("Camera in use by another app");
+            default:
+              throw new Error("Camera error: " + L.message);
+          }
+        else
+          throw new Error("Unknown camera error: " + L);
+      }
+      return await y(e), x = () => {
+        d = !0, E(e), x = void 0;
+      }, {
+        stop: x
+      };
+    },
+    bind: (d, h) => {
+      if (h = h || ke, !n) throw new Error("Pose tracker not initialized");
+      if (!s) throw new Error("Hands tracker not initialized");
+      if (!a) throw new Error("Face tracker not initialized");
+      const w = n.bind(d, h), E = s.left.bind(d, h), y = s.right.bind(d, h);
+      let v;
+      const g = a == null ? void 0 : a.bind(d);
+      d.traverse((p) => {
+        p instanceof u.Mesh && p.name.indexOf(h.faceMesh) === 0 && (p.frustumCulled = !1, v = a == null ? void 0 : a.bindShapeKeys(p));
+      });
+      const L = ut(d, h);
+      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: L.start,
+        stopRecording: L.stop,
+        isRecording: () => L.isRecording(),
+        update: (p) => {
+          w.update(p), E.update(p), y.update(p), v == null || v.update(p), g == null || g.update(p), L.isRecording() && L.captureFrame();
+        }
+      };
+    },
+    setVideoFromSource: (d) => {
+      x == null || x(), e || k(), e.src = d instanceof File ? URL.createObjectURL(d) : d, e.controls = !0, e.loop = !0, e.muted = !0, e.controls = !0, e.play();
+    },
+    async setVideoFromWebcam() {
+      if (e || k(), x)
+        throw new Error("Webcam already started");
+      return await this.start();
+    }
+  };
+}
+export {
+  De as FACE_LANDMARKS_COUNT,
+  Ce as createFaceLandmarksIndexAttribute,
+  Pt as setupTracker
+};