@vincentt-xr/sdk 2.0.0-alpha.4 → 2.0.0-alpha.6

package/dist/FaceMeshRenderer-DSCd1H55.js

@@ -0,0 +1,1264 @@
+import { jsx as g, jsxs as we, Fragment as Ye } from "react/jsx-runtime";
+import { useLoader as de, useThree as Bt, useFrame as Vt } from "@react-three/fiber";
+import { useMemo as Z, useRef as l, useState as $e, useCallback as He, useEffect as Ce } from "react";
+import * as m from "three";
+import { MathUtils as Ke, Color as Wt, Vector2 as Be } from "three";
+import { l as re, f as Xt, X as jt } from "./index-I4eF5TKT.js";
+import { c as Yt, u as $t } from "./selectors-ByKNTXeA.js";
+import { t as Kt, p as Qt, b as qt } from "./index-B-s4YbWu.js";
+import { TransformControls as Zt } from "@react-three/drei";
+const _e = 8, K = {
+  type: "linear",
+  stops: [
+    { offset: 0, color: "#38bdf8" },
+    { offset: 1, color: "#a78bfa" }
+  ],
+  angle: 0,
+  center: { x: 0.5, y: 0.5 },
+  radius: 0.5
+}, Jt = (e) => {
+  const n = e.slice(0, _e).map((t) => ({ ...t, offset: Ke.clamp(t.offset, 0, 1) })).sort((t, r) => t.offset - r.offset);
+  return n.length >= 2 ? n : K.stops.map((t) => ({ ...t }));
+}, en = (e) => ({
+  ...K,
+  ...e,
+  center: { ...K.center, ...e == null ? void 0 : e.center },
+  radius: Math.max(0.01, (e == null ? void 0 : e.radius) ?? K.radius),
+  stops: Jt((e == null ? void 0 : e.stops) ?? K.stops)
+}), tn = `
+  varying vec2 vPosition;
+  void main() {
+    vPosition = position.xy;
+    gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+  }
+`, nn = `
+  #define MAX_STOPS 8
+  uniform vec3 stopColors[MAX_STOPS];
+  uniform float stopOffsets[MAX_STOPS];
+  uniform int stopCount;
+  uniform int gradientType;
+  uniform vec2 direction;
+  uniform vec2 center;
+  uniform float radius;
+  uniform float angleOffset;
+  uniform float opacity;
+  varying vec2 vPosition;
+
+  vec3 sampleGradient(float amount) {
+    vec3 color = stopColors[0];
+    for (int index = 1; index < MAX_STOPS; index++) {
+      if (index >= stopCount) break;
+      if (amount <= stopOffsets[index]) {
+        float width = max(0.0001, stopOffsets[index] - stopOffsets[index - 1]);
+        return mix(stopColors[index - 1], stopColors[index], clamp((amount - stopOffsets[index - 1]) / width, 0.0, 1.0));
+      }
+      color = stopColors[index];
+    }
+    return color;
+  }
+
+  void main() {
+    vec2 delta = vPosition - center;
+    float amount;
+    if (gradientType == 1) {
+      amount = clamp(length(delta) / radius, 0.0, 1.0);
+    } else if (gradientType == 2) {
+      amount = fract(atan(delta.y, delta.x) / 6.28318530718 + 0.5 + angleOffset);
+    } else {
+      amount = clamp(dot(delta, direction) + 0.5, 0.0, 1.0);
+    }
+    gl_FragColor = vec4(sampleGradient(amount), opacity);
+  }
+`, rn = { linear: 0, radial: 1, angular: 2 }, an = ({ opacity: e = 1, value: n }) => {
+  const t = Z(() => {
+    const r = en(n), a = Ke.degToRad(r.angle), o = r.stops.map((s) => new Wt(s.color)), i = r.stops.map((s) => s.offset);
+    for (; o.length < _e; ) o.push(o[o.length - 1]);
+    for (; i.length < _e; ) i.push(1);
+    return {
+      stopColors: { value: o },
+      stopOffsets: { value: i },
+      stopCount: { value: r.stops.length },
+      gradientType: { value: rn[r.type] },
+      direction: { value: new Be(Math.cos(a), Math.sin(a)) },
+      center: { value: new Be(r.center.x - 0.5, 0.5 - r.center.y) },
+      radius: { value: r.radius },
+      angleOffset: { value: r.angle / 360 },
+      opacity: { value: e }
+    };
+  }, [e, n]);
+  return /* @__PURE__ */ g(
+    "shaderMaterial",
+    {
+      uniforms: t,
+      vertexShader: tn,
+      fragmentShader: nn,
+      transparent: e < 1,
+      depthTest: !1,
+      depthWrite: !1,
+      toneMapped: !1
+    }
+  );
+}, on = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO2YpZcAAAAASUVORK5CYII=", jn = {
+  source: "solid",
+  color: "#ffffff",
+  opacity: 1,
+  textureUrl: "",
+  gradient: K
+}, Qe = (e) => ({
+  ...K,
+  stops: [
+    { offset: 0, color: "#ffffff" },
+    { offset: 1, color: e }
+  ]
+}), sn = ({
+  depthTest: e,
+  depthWrite: n,
+  settings: t,
+  side: r,
+  toneMapped: a
+}) => {
+  const o = de(
+    m.TextureLoader,
+    t.textureUrl || on
+  );
+  return /* @__PURE__ */ g(
+    "meshBasicMaterial",
+    {
+      color: t.color,
+      map: o,
+      transparent: !0,
+      opacity: t.opacity,
+      side: r,
+      depthWrite: n,
+      depthTest: e,
+      toneMapped: a
+    }
+  );
+}, cn = ({
+  depthTest: e = !1,
+  depthWrite: n = !1,
+  settings: t,
+  side: r,
+  toneMapped: a = !1
+}) => {
+  const o = Z(
+    () => t.gradient ?? Qe(t.color),
+    [t.color, t.gradient]
+  );
+  return t.source === "gradient" ? /* @__PURE__ */ g(an, { value: o, opacity: t.opacity }) : t.source === "texture" ? /* @__PURE__ */ g(
+    sn,
+    {
+      settings: t,
+      side: r,
+      depthTest: e,
+      depthWrite: n,
+      toneMapped: a
+    }
+  ) : /* @__PURE__ */ g(
+    "meshBasicMaterial",
+    {
+      color: t.color,
+      transparent: !0,
+      opacity: t.opacity,
+      side: r,
+      depthWrite: n,
+      depthTest: e,
+      toneMapped: a
+    }
+  );
+}, Me = Math.PI / 180, xe = 180 / Math.PI, V = (e) => Number(e.toFixed(6)), Ve = {
+  enabled: !0,
+  linked: {
+    position: !1,
+    rotation: !1,
+    scale: !1
+  },
+  showTransformControls: !1,
+  transformControlMode: "translate",
+  transformControlSpace: "local",
+  position: { x: 0, y: 0, z: 0 },
+  rotation: { x: 0, y: 0, z: 0 },
+  scale: { x: 1, y: 1, z: 1 },
+  visible: !0
+}, Yn = ({ children: e, objectRef: n, onChange: t, value: r }) => {
+  const a = l(null), o = l(n);
+  o.current = n;
+  const [i, s] = $e(null), u = He((c) => {
+    var v;
+    a.current = c, s(c), (v = o.current) == null || v.call(o, c);
+  }, []), f = He(() => {
+    const c = a.current;
+    !c || !t || t({
+      ...r,
+      position: {
+        x: V(c.position.x),
+        y: V(c.position.y),
+        z: V(c.position.z)
+      },
+      rotation: {
+        x: V(c.rotation.x * xe),
+        y: V(c.rotation.y * xe),
+        z: V(c.rotation.z * xe)
+      },
+      scale: {
+        x: V(c.scale.x),
+        y: V(c.scale.y),
+        z: V(c.scale.z)
+      }
+    });
+  }, [t, r]);
+  return r.enabled ? /* @__PURE__ */ we(Ye, { children: [
+    /* @__PURE__ */ g(
+      "group",
+      {
+        ref: u,
+        position: [r.position.x, r.position.y, r.position.z],
+        rotation: [
+          r.rotation.x * Me,
+          r.rotation.y * Me,
+          r.rotation.z * Me
+        ],
+        scale: [r.scale.x, r.scale.y, r.scale.z],
+        visible: r.visible,
+        children: e
+      }
+    ),
+    i && r.showTransformControls && /* @__PURE__ */ g(
+      Zt,
+      {
+        object: i,
+        mode: r.transformControlMode,
+        space: r.transformControlSpace,
+        size: 0.85,
+        onMouseUp: f,
+        onObjectChange: f
+      }
+    )
+  ] }) : null;
+}, te = (e) => Math.min(1, Math.max(0, e)), L = (e, n, t) => te(1 - Math.abs(e - n) / t), ln = (e) => {
+  let n = 1 / 0, t = -1 / 0, r = 1 / 0, a = -1 / 0;
+  for (const s of e)
+    n = Math.min(n, s.x), t = Math.max(t, s.x), r = Math.min(r, s.y), a = Math.max(a, s.y);
+  const o = Math.max(t - n, 1e-3), i = Math.max(a - r, 1e-3);
+  return {
+    centerX: n + o * 0.5,
+    centerY: r + i * 0.5,
+    width: o,
+    height: i
+  };
+}, dn = (e) => e != null && e.enabled ? (e.strength ?? 1) !== 0 && Object.entries(e).some(
+  ([n, t]) => n !== "enabled" && n !== "strength" && typeof t == "number" && t !== 0
+) : !1, un = (e, n, t, r) => {
+  const a = t.enabled ? t.strength ?? 1 : 0;
+  if (a === 0)
+    return r.x = e.x, r.y = e.y, r.z = e.z, r;
+  const o = (e.x - n.centerX) / n.width, i = (e.y - n.centerY) / n.height, s = Math.abs(o), u = te((-i + 0.42) / 0.55), f = L(i, -0.02, 0.34), c = L(i, -0.24, 0.16) * te((s - 0.05) / 0.28), v = L(i, 0.02, 0.26) * L(s, 0, 0.18), R = L(i, 0.29, 0.18) * L(s, 0, 0.36), D = te((i - 0.16) / 0.36), _ = f * L(s, 0.34, 0.22), w = u * L(s, 0, 0.48), S = L(i, -0.19, 0.1) * te((s - 0.05) / 0.3), Y = L(i, 0.48, 0.2) * L(s, 0, 0.26);
+  let M = e.x, p = e.y, U = e.z;
+  const y = (T, h = 1) => {
+    M += o * n.width * T * a * h;
+  }, d = (T, h = 1) => {
+    p += i * n.height * T * a * h;
+  };
+  y(t.faceWidth ?? 0), d(t.faceHeight ?? 0), y(t.faceRoundness ?? 0, f * (1 - s)), p -= n.height * (t.midfaceHeight ?? 0) * a * f * 0.25, d(-(t.foreheadHeight ?? 0), w), y(t.foreheadWidth ?? 0, w), y(
+    t.cheekboneWidth ?? 0,
+    L(i, -0.06, 0.16) * L(s, 0.34, 0.2)
+  ), y(t.cheekWidth ?? 0, _), y(t.jawWidth ?? 0, D), d(t.chinHeight ?? 0, Y), p -= n.height * (t.scalpHeight ?? 0) * a * u * 0.3, U -= (t.midfaceDepth ?? 0) * a * f * 0.08, U += (t.cheekHollowness ?? 0) * a * _ * 0.06, U -= (t.browDepth ?? 0) * a * S * 0.05, p -= n.height * (t.browHeight ?? 0) * a * S * 0.2, M += Math.sign(o || 1) * n.width * (t.browDistance ?? 0) * a * S * 0.16;
+  const k = (t.headCurve ?? 0) * a * (i + 0.1);
+  U -= k * k * 0.04 * Math.sign(t.headCurve ?? 0), M += n.width * (t.faceTwist ?? 0) * a * i * 0.18;
+  const N = (t.faceSwirl ?? 0) * a * 0.22;
+  M += -i * n.width * N, p += o * n.height * N;
+  const I = o < 0 ? t.leftEyeSize ?? 0 : t.rightEyeSize ?? 0, x = ((t.eyeSize ?? 0) + I) * a * c;
+  M += o * n.width * x * 0.45, p += (i + 0.24) * n.height * x * 0.7, M += Math.sign(o || 1) * n.width * (t.eyeDistance ?? 0) * a * c * 0.2, M += n.width * (o < 0 ? t.leftEyeX ?? 0 : t.rightEyeX ?? 0) * a * c * 0.15, p += n.height * (o < 0 ? t.leftEyeY ?? 0 : t.rightEyeY ?? 0) * a * c * 0.15;
+  const E = (t.noseSize ?? 0) * a * v;
+  return M += o * n.width * E * 0.7, p += (i - 0.02) * n.height * E * 0.5, p += n.height * (t.noseLength ?? 0) * a * v * Math.max(i + 0.08, 0) * 0.4, U -= (t.noseSize ?? 0) * a * v * 0.08, M += o * n.width * (t.mouthWidth ?? 0) * a * R, p += (i - 0.29) * n.height * (t.mouthHeight ?? 0) * a * R, r.x = M, r.y = p, r.z = U, r;
+}, Ae = /* @__PURE__ */ new Set([
+  61,
+  146,
+  91,
+  181,
+  84,
+  17,
+  314,
+  405,
+  321,
+  375,
+  291,
+  78,
+  95,
+  88,
+  178,
+  87,
+  14,
+  317,
+  402,
+  318,
+  324,
+  308,
+  191,
+  80,
+  81,
+  82,
+  13,
+  312,
+  311,
+  310,
+  415
+]), We = [
+  61,
+  146,
+  91,
+  181,
+  84,
+  17,
+  314,
+  405,
+  321,
+  375,
+  291,
+  409,
+  270,
+  269,
+  267,
+  0,
+  37,
+  39,
+  40,
+  185
+], ve = /* @__PURE__ */ new Set([
+  33,
+  7,
+  163,
+  144,
+  145,
+  153,
+  154,
+  155,
+  133,
+  173,
+  157,
+  158,
+  159,
+  160,
+  161,
+  246
+]), Ee = /* @__PURE__ */ new Set([
+  362,
+  382,
+  381,
+  380,
+  374,
+  373,
+  390,
+  249,
+  263,
+  466,
+  388,
+  387,
+  386,
+  385,
+  384,
+  398
+]), fn = /* @__PURE__ */ new Set([814, 815, 816, 817, 818, 819, 830, 831, 832, 833]), hn = (e, n, t) => {
+  const r = Ae.has(e) && Ae.has(n) && Ae.has(t), a = ve.has(e) && ve.has(n) && ve.has(t), o = Ee.has(e) && Ee.has(n) && Ee.has(t);
+  return r ? "mouth" : a ? "leftEye" : o ? "rightEye" : "base";
+}, mn = (e) => {
+  const n = /* @__PURE__ */ new Map();
+  for (let s = 0; s < e.length; s += 3) {
+    const u = [e[s], e[s + 1], e[s + 2]];
+    for (let f = 0; f < 3; f += 1) {
+      const c = u[f], v = u[(f + 1) % 3], R = c < v ? `${c}:${v}` : `${v}:${c}`, D = n.get(R);
+      D ? D.count += 1 : n.set(R, { a: c, b: v, count: 1 });
+    }
+  }
+  const t = /* @__PURE__ */ new Map();
+  n.forEach(({ a: s, b: u, count: f }) => {
+    f === 1 && (t.set(s, [...t.get(s) ?? [], u]), t.set(u, [...t.get(u) ?? [], s]));
+  });
+  const r = [...t.keys()].sort((s, u) => s - u)[0];
+  if (r === void 0) return [];
+  const a = [r];
+  let o = -1, i = r;
+  for (; a.length <= t.size + 1; ) {
+    const s = (t.get(i) ?? []).find((u) => u !== o);
+    if (s === void 0 || s === r) break;
+    a.push(s), o = i, i = s;
+  }
+  return a;
+}, pn = (e) => {
+  const n = [], t = [], r = [], a = [], o = [], i = [], s = [], u = [];
+  let f = 0, c = 0;
+  e.split(`
+`).forEach((y) => {
+    const d = y.trim();
+    if (!d) return;
+    if (d.startsWith("v ")) {
+      const [, x, E, T] = d.split(/\s+/);
+      s.push([Number(x), Number(E), Number(T)]), f += 1;
+      return;
+    }
+    if (d.startsWith("vt ")) {
+      const [, x, E] = d.split(/\s+/);
+      i.push([Number(x), Number(E)]);
+      return;
+    }
+    if (!d.startsWith("f ")) return;
+    const k = c;
+    c += 1;
+    const [, ...N] = d.split(/\s+/), I = N.map((x) => {
+      const [E, T] = x.split("/"), h = Number(E) - 1, z = Number(T) - 1;
+      return z >= 0 && i[z] && !u[h] && (u[h] = i[z]), h;
+    });
+    if (!(I.length < 3))
+      for (let x = 1; x < I.length - 1; x += 1) {
+        const E = I[0], T = I[x], h = I[x + 1], z = hn(E, T, h);
+        fn.has(k) ? o.push(E, T, h) : z === "mouth" ? t.push(E, T, h) : z === "leftEye" ? r.push(E, T, h) : z === "rightEye" ? a.push(E, T, h) : n.push(E, T, h);
+      }
+  });
+  const v = [];
+  for (let y = 0; y < f; y += 1) {
+    const [d, k] = u[y] ?? [0, 0];
+    v.push(d, k);
+  }
+  const R = new Uint16Array(r), D = new Uint16Array(a), _ = new Uint16Array(r.length + a.length);
+  _.set(R), _.set(D, R.length);
+  const w = We.map((y) => {
+    const [d, k] = s[y] ?? [0, 0];
+    return new m.Vector2(d, k);
+  }), S = mn(t), Y = S.map((y) => {
+    const [d, k] = s[y] ?? [0, 0];
+    return new m.Vector2(d, k);
+  }), M = m.ShapeUtils.triangulateShape(w, [Y]), p = [...We, ...S], U = new Uint16Array(
+    S.length > 2 ? M.flatMap((y) => y.map((d) => p[d])) : []
+  );
+  return {
+    baseIndices: new Uint16Array(n),
+    mouthIndices: new Uint16Array(t),
+    lipIndices: U,
+    leftEyeIndices: R,
+    rightEyeIndices: D,
+    eyeIndices: _,
+    noseIndices: new Uint16Array(o),
+    uvs: new Float32Array(v),
+    vertexCount: f
+  };
+}, yn = "canonical_face_model.obj", bn = new TextDecoder("utf-8"), Se = /* @__PURE__ */ new Map(), gn = (e) => {
+  const n = Se.get(e);
+  if (n) return n;
+  const t = Xt(e).then((r) => pn(bn.decode(r))).catch((r) => {
+    throw Se.delete(e), r;
+  });
+  return Se.set(e, t), t;
+}, Mn = (e) => {
+  const { mesh: n, url: t } = e ?? {}, r = t ?? `${re.sdkAssetsBaseUrl}/${yn}`, [a, o] = $e(n ?? null);
+  return Ce(() => {
+    if (n) {
+      o(n);
+      return;
+    }
+    let i = !1;
+    return gn(r).then((s) => {
+      i || o(s);
+    }).catch((s) => {
+      i || console.error(`${re.loggerPrefix} canonical face mesh load failed`, s);
+    }), () => {
+      i = !0;
+    };
+  }, [n, r]), a;
+}, C = {
+  basic: "basic",
+  standard: "standard",
+  physical: "physical",
+  toon: "toon",
+  normal: "normal",
+  matcap: "matcap",
+  wireframe: "wireframe",
+  shader: "shader"
+}, X = {
+  originalFace: "originalFace",
+  composite: "composite"
+}, j = {
+  none: "none",
+  canonical: "canonical",
+  style2: "style2"
+}, J = {
+  none: "none",
+  canonical: "canonical"
+}, ae = {
+  solid: "solid",
+  gradient: "gradient",
+  imageUrl: "imageUrl",
+  mediaUrl: "mediaUrl"
+}, ne = {
+  front: "front",
+  back: "back",
+  double: "double"
+}, qe = {
+  normal: "normal",
+  add: "add",
+  subtract: "subtract",
+  multiply: "multiply",
+  screen: "screen",
+  overlay: "overlay",
+  softLight: "softLight",
+  hardLight: "hardLight",
+  lighten: "lighten",
+  darken: "darken",
+  difference: "difference",
+  exclusion: "exclusion"
+}, xn = {
+  textureMap: j.canonical,
+  alphaMap: J.canonical,
+  alphaOpacity: 1
+}, Xe = {
+  ...xn,
+  blendMode: qe.hardLight,
+  blendOpacity: 0.85,
+  baseColor: "#ffffff",
+  opacity: 1,
+  compositeShading: !0
+}, G = {
+  materialType: C.basic,
+  shaderPreset: X.originalFace,
+  textureMap: j.none,
+  alphaMap: J.none,
+  alphaOpacity: 1,
+  side: ne.front,
+  blendMode: qe.normal,
+  blendOpacity: 1,
+  baseColor: "#38bdf8",
+  opacity: 0.45,
+  compositeShading: !1
+};
+C.shader, X.composite, ne.front;
+const Te = {
+  mouth: !0,
+  eyes: !0,
+  nose: !0
+}, ee = {
+  textureSource: ae.solid,
+  color: "#111111",
+  opacity: 0.5
+}, An = 24, Ze = 10, Fe = (e, n, t) => e !== C.shader ? "none" : n === X.originalFace ? "originalFace" : n === X.composite ? t === j.none ? "originalFace" : "composite" : "none", $n = (e, n) => e === C.basic || e === C.standard || e === C.physical || e === C.toon || e === C.shader && n === X.composite, Kn = (e, n, t = j.canonical) => Fe(e, n, t) === "composite", vn = (e, n, t) => Fe(e, n, t) === "originalFace", ke = (e) => e === ae.imageUrl || e === ae.mediaUrl, En = (e) => e === ae.solid || e === ae.gradient, je = {
+  normal: 0,
+  add: 1,
+  subtract: 2,
+  multiply: 3,
+  screen: 4,
+  overlay: 5,
+  softLight: 6,
+  hardLight: 7,
+  lighten: 8,
+  darken: 9,
+  difference: 10,
+  exclusion: 11
+}, Re = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO2YpZcAAAAASUVORK5CYII=", Sn = () => {
+  const e = new Uint8Array([
+    32,
+    32,
+    32,
+    255,
+    96,
+    96,
+    96,
+    255,
+    176,
+    176,
+    176,
+    255,
+    255,
+    255,
+    255,
+    255
+  ]), n = new m.DataTexture(e, 4, 1, m.RGBAFormat);
+  return n.minFilter = m.NearestFilter, n.magFilter = m.NearestFilter, n.generateMipmaps = !1, n.needsUpdate = !0, n;
+}, Tn = () => {
+  const e = document.createElement("canvas");
+  e.width = 256, e.height = 256;
+  const n = e.getContext("2d");
+  if (!n)
+    return new m.CanvasTexture(e);
+  const t = n.createRadialGradient(96, 80, 10, 128, 128, 128);
+  t.addColorStop(0, "#ffffff"), t.addColorStop(0.18, "#f7d794"), t.addColorStop(0.45, "#d97706"), t.addColorStop(0.72, "#78350f"), t.addColorStop(1, "#120701"), n.fillStyle = t, n.fillRect(0, 0, e.width, e.height);
+  const r = new m.CanvasTexture(e);
+  return r.needsUpdate = !0, r;
+}, Rn = `
+  attribute vec2 faceUv;
+  varying vec2 vUv;
+  varying vec2 vFaceUv;
+  varying vec3 vNormal;
+
+  void main() {
+    vUv = uv;
+    vFaceUv = faceUv;
+    vNormal = normalize(normalMatrix * normal);
+    gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+  }
+`, Cn = `
+  uniform sampler2D cameraTexture;
+  uniform sampler2D canonicalTexture;
+  uniform sampler2D alphaMask;
+  uniform vec3 textureTint;
+  uniform float opacity;
+  uniform int blendMode;
+  uniform float blendOpacity;
+  uniform float useCanonicalTexture;
+  uniform float useAlphaMask;
+  uniform float alphaOpacity;
+  uniform float compositeShading;
+  uniform vec3 lightDirection;
+  uniform float ambientStrength;
+  uniform float directionalStrength;
+  varying vec2 vUv;
+  varying vec2 vFaceUv;
+  varying vec3 vNormal;
+
+  vec3 linearToSrgb(vec3 value) {
+    vec3 low = value * 12.92;
+    vec3 high = 1.055 * pow(max(value, vec3(0.0)), vec3(1.0 / 2.4)) - 0.055;
+    return mix(high, low, step(value, vec3(0.0031308)));
+  }
+
+  vec3 srgbToLinear(vec3 value) {
+    vec3 low = value / 12.92;
+    vec3 high = pow(max((value + 0.055) / 1.055, vec3(0.0)), vec3(2.4));
+    return mix(high, low, step(value, vec3(0.04045)));
+  }
+
+  float overlayChannel(float base, float blend) {
+    return base < 0.5 ? 2.0 * base * blend : 1.0 - 2.0 * (1.0 - base) * (1.0 - blend);
+  }
+
+  float hardLightChannel(float base, float blend) {
+    return blend < 0.5 ? 2.0 * base * blend : 1.0 - 2.0 * (1.0 - base) * (1.0 - blend);
+  }
+
+  float softLightChannel(float base, float blend) {
+    if (blend <= 0.5) {
+      return base - (1.0 - 2.0 * blend) * base * (1.0 - base);
+    }
+
+    float d = base <= 0.25
+      ? ((16.0 * base - 12.0) * base + 4.0) * base
+      : sqrt(base);
+
+    return base + (2.0 * blend - 1.0) * (d - base);
+  }
+
+  vec3 applyBlendMode(vec3 base, vec3 blend, int mode) {
+    if (mode == 0) return blend;
+    if (mode == 1) return min(base + blend, 1.0);
+    if (mode == 2) return max(base - blend, 0.0);
+    if (mode == 3) return base * blend;
+    if (mode == 4) return 1.0 - (1.0 - base) * (1.0 - blend);
+    if (mode == 5) {
+      return vec3(
+        overlayChannel(base.r, blend.r),
+        overlayChannel(base.g, blend.g),
+        overlayChannel(base.b, blend.b)
+      );
+    }
+    if (mode == 6) {
+      return vec3(
+        softLightChannel(base.r, blend.r),
+        softLightChannel(base.g, blend.g),
+        softLightChannel(base.b, blend.b)
+      );
+    }
+    if (mode == 7) {
+      return vec3(
+        hardLightChannel(base.r, blend.r),
+        hardLightChannel(base.g, blend.g),
+        hardLightChannel(base.b, blend.b)
+      );
+    }
+    if (mode == 8) return max(base, blend);
+    if (mode == 9) return min(base, blend);
+    if (mode == 10) return abs(base - blend);
+    return base + blend - 2.0 * base * blend;
+  }
+
+  void main() {
+    vec3 base = linearToSrgb(texture2D(cameraTexture, vFaceUv).rgb);
+    vec4 textureSample = texture2D(canonicalTexture, vUv);
+    vec3 blend = linearToSrgb(textureSample.rgb) * textureTint;
+    float light = ambientStrength + max(dot(normalize(vNormal), normalize(lightDirection)), 0.0) * directionalStrength;
+    blend *= mix(1.0, clamp(light, 0.35, 1.35), compositeShading);
+    float maskSample = texture2D(alphaMask, vUv).r;
+    float mask = useAlphaMask > 0.5 ? mix(1.0, maskSample, alphaOpacity) : 1.0;
+    float textureAlpha = useCanonicalTexture > 0.5 ? textureSample.a : 1.0;
+    vec3 blended = applyBlendMode(base, blend, blendMode);
+    vec3 color = useCanonicalTexture > 0.5 ? mix(base, blended, blendOpacity) : base;
+    gl_FragColor = vec4(srgbToLinear(color), opacity * mask * textureAlpha);
+  }
+`, _n = ({
+  alphaMap: e,
+  alphaOpacity: n,
+  blendMode: t,
+  blendOpacity: r,
+  cameraTexture: a,
+  color: o,
+  compositeShading: i,
+  faceAlphaMaskUrl: s,
+  faceTextureStyle2Url: u,
+  faceTextureUrl: f,
+  masked: c = !1,
+  maskColor: v,
+  maskOpacity: R,
+  maskSourceUrl: D,
+  maskTextureSource: _,
+  materialType: w,
+  opacity: S,
+  shaderPreset: Y,
+  side: M,
+  textureMap: p
+}) => {
+  const U = de(
+    m.TextureLoader,
+    f || Re
+  ), y = de(
+    m.TextureLoader,
+    u || f || Re
+  ), d = de(
+    m.TextureLoader,
+    s || Re
+  ), k = Z(() => Sn(), []), N = Z(() => Tn(), []);
+  Ce(
+    () => () => {
+      k.dispose(), N.dispose();
+    },
+    [N, k]
+  );
+  const I = p === j.style2 ? y : U, x = p !== j.none, E = Fe(w, Y, p), T = [
+    "composite-material",
+    p,
+    e,
+    n,
+    t,
+    r,
+    i ? "lit" : "flat",
+    o,
+    S,
+    f,
+    u,
+    s
+  ].join("|"), h = {
+    side: M,
+    transparent: !0,
+    opacity: S,
+    wireframe: !1
+  }, z = Z(
+    () => ({
+      source: ke(_) ? "texture" : _,
+      color: En(_) ? v : "#ffffff",
+      opacity: R,
+      textureUrl: ke(_) ? D : "",
+      gradient: Qe(v)
+    }),
+    [v, R, D, _]
+  ), F = Z(
+    () => ({
+      cameraTexture: { value: null },
+      canonicalTexture: { value: null },
+      alphaMask: { value: null },
+      textureTint: { value: new m.Color(o) },
+      opacity: { value: S },
+      blendMode: { value: je[t] },
+      blendOpacity: { value: r },
+      useCanonicalTexture: { value: x ? 1 : 0 },
+      useAlphaMask: { value: e === J.canonical ? 1 : 0 },
+      alphaOpacity: { value: n },
+      compositeShading: { value: i ? 1 : 0 },
+      lightDirection: { value: new m.Vector3(0.3, 0.65, 0.7).normalize() },
+      ambientStrength: { value: 0.78 },
+      directionalStrength: { value: 0.38 }
+    }),
+    [
+      e,
+      n,
+      t,
+      r,
+      o,
+      i,
+      x,
+      S
+    ]
+  );
+  if (Ce(() => {
+    F.cameraTexture.value = a ?? U, F.canonicalTexture.value = I, F.alphaMask.value = d, F.textureTint.value.set(o), F.opacity.value = S, F.blendMode.value = je[t], F.blendOpacity.value = r, F.useCanonicalTexture.value = x ? 1 : 0, F.useAlphaMask.value = e === J.canonical ? 1 : 0, F.alphaOpacity.value = n, F.compositeShading.value = i ? 1 : 0;
+  }, [
+    e,
+    d,
+    n,
+    t,
+    r,
+    a,
+    o,
+    i,
+    F,
+    U,
+    x,
+    S,
+    I
+  ]), c)
+    return /* @__PURE__ */ g(
+      cn,
+      {
+        settings: z,
+        side: M
+      },
+      `masked-${_}-material`
+    );
+  if (w === C.wireframe)
+    return /* @__PURE__ */ g(
+      "meshBasicMaterial",
+      {
+        color: o,
+        transparent: !0,
+        opacity: S,
+        side: M,
+        depthWrite: !1,
+        depthTest: !1,
+        wireframe: !0,
+        toneMapped: !1
+      },
+      "wireframe-material"
+    );
+  if (E === "originalFace" && a)
+    return /* @__PURE__ */ g(
+      "meshBasicMaterial",
+      {
+        map: a,
+        alphaMap: d,
+        transparent: !0,
+        opacity: S,
+        side: M,
+        depthWrite: !1,
+        depthTest: !0,
+        toneMapped: !1
+      },
+      "use-original-face-material"
+    );
+  if (E === "composite" && a)
+    return /* @__PURE__ */ g(
+      "shaderMaterial",
+      {
+        uniforms: F,
+        vertexShader: Rn,
+        fragmentShader: Cn,
+        transparent: !0,
+        side: M,
+        depthWrite: !1,
+        depthTest: !0,
+        toneMapped: !1
+      },
+      T
+    );
+  const Q = x ? I : null, $ = e === J.canonical && n > 0 ? d : null, W = `${w}-${p}-${e}-${n > 0 ? "alpha-on" : "alpha-off"}`;
+  return w === C.standard ? /* @__PURE__ */ g(
+    "meshStandardMaterial",
+    {
+      ...h,
+      color: o,
+      map: Q ?? void 0,
+      alphaMap: $ ?? void 0,
+      depthWrite: !0,
+      depthTest: !0,
+      metalness: 0.05,
+      roughness: 0.72
+    },
+    W
+  ) : w === C.physical ? /* @__PURE__ */ g(
+    "meshPhysicalMaterial",
+    {
+      ...h,
+      color: o,
+      map: Q ?? void 0,
+      alphaMap: $ ?? void 0,
+      depthWrite: !0,
+      depthTest: !0,
+      roughness: 0.58,
+      metalness: 0.08,
+      clearcoat: 0.35,
+      clearcoatRoughness: 0.4
+    },
+    W
+  ) : w === C.toon ? /* @__PURE__ */ g(
+    "meshToonMaterial",
+    {
+      ...h,
+      color: o,
+      map: Q ?? void 0,
+      alphaMap: $ ?? void 0,
+      gradientMap: k,
+      depthWrite: !0,
+      depthTest: !0
+    },
+    W
+  ) : w === C.normal ? /* @__PURE__ */ g(
+    "meshNormalMaterial",
+    {
+      ...h,
+      depthWrite: !0,
+      depthTest: !0,
+      flatShading: !1
+    },
+    "normal-material"
+  ) : w === C.matcap ? /* @__PURE__ */ g(
+    "meshMatcapMaterial",
+    {
+      ...h,
+      color: o,
+      matcap: N,
+      depthWrite: !0,
+      depthTest: !0
+    },
+    "matcap-material"
+  ) : /* @__PURE__ */ g(
+    "meshBasicMaterial",
+    {
+      ...h,
+      color: o,
+      map: Q ?? void 0,
+      alphaMap: $ ?? void 0,
+      depthWrite: !1,
+      depthTest: p !== j.none || e !== J.none,
+      toneMapped: !1
+    },
+    W
+  );
+}, kn = [
+  {
+    key: "base",
+    getIndices: (e) => e.baseIndices,
+    masked: !1,
+    renderOrderOffset: 0
+  },
+  {
+    key: "mouth",
+    getIndices: (e) => e.mouthIndices,
+    masked: !1,
+    renderOrderOffset: 2
+  },
+  {
+    key: "lips",
+    getIndices: (e) => e.lipIndices,
+    masked: !1,
+    renderOrderOffset: 3
+  },
+  {
+    key: "left-eye",
+    getIndices: (e) => e.leftEyeIndices,
+    masked: !1,
+    renderOrderOffset: 2
+  },
+  {
+    key: "right-eye",
+    getIndices: (e) => e.rightEyeIndices,
+    masked: !1,
+    renderOrderOffset: 2
+  },
+  {
+    key: "nose",
+    getIndices: (e) => e.noseIndices,
+    masked: !1,
+    renderOrderOffset: 2
+  },
+  {
+    key: "mouth-mask",
+    getIndices: (e) => e.mouthIndices,
+    masked: !0,
+    renderOrderOffset: 3
+  },
+  {
+    key: "left-eye-mask",
+    getIndices: (e) => e.leftEyeIndices,
+    masked: !0,
+    renderOrderOffset: 3
+  },
+  {
+    key: "right-eye-mask",
+    getIndices: (e) => e.rightEyeIndices,
+    masked: !0,
+    renderOrderOffset: 3
+  },
+  {
+    key: "nose-mask",
+    getIndices: (e) => e.noseIndices,
+    masked: !0,
+    renderOrderOffset: 3
+  }
+], wn = {
+  [ne.front]: m.FrontSide,
+  [ne.back]: m.BackSide,
+  [ne.double]: m.DoubleSide
+}, Fn = (e, n, t) => {
+  e.setAttribute("position", n.position), e.setAttribute("uv", n.uv), e.setAttribute("faceUv", n.faceUv), e.setIndex(new m.BufferAttribute(t, 1));
+}, Un = ({
+  faceIndex: e = 0,
+  baseColor: n,
+  color: t = G.baseColor,
+  opacity: r = G.opacity,
+  materialType: a = G.materialType,
+  shaderPreset: o = G.shaderPreset,
+  textureMap: i = G.textureMap,
+  alphaMap: s = G.alphaMap,
+  alphaOpacity: u = G.alphaOpacity,
+  side: f = G.side,
+  blendMode: c = G.blendMode,
+  blendOpacity: v = G.blendOpacity,
+  showOverlayMask: R = !1,
+  showMouthMask: D = Te.mouth,
+  showEyeMask: _ = Te.eyes,
+  showLeftEyeMask: w,
+  showRightEyeMask: S,
+  showNoseMask: Y = Te.nose,
+  showEyeGeometry: M = !0,
+  showLeftEyeGeometry: p,
+  showRightEyeGeometry: U,
+  showMouthGeometry: y = !0,
+  showLipsGeometry: d = !0,
+  showBaseGeometry: k = !0,
+  showNoseGeometry: N = !0,
+  maskTextureSource: I = ee.textureSource,
+  maskSourceUrl: x = "",
+  maskColor: E = ee.color,
+  maskOpacity: T = ee.opacity,
+  faceTextureUrl: h = "",
+  faceTextureStyle2Url: z = "",
+  faceAlphaMaskUrl: F = "",
+  compositeShading: Q = !1,
+  faceWarp3D: $,
+  transform: W,
+  renderOrder: Je = Ze,
+  externalScale: ue = 1,
+  mesh: et,
+  meshUrl: tt,
+  materialOverride: oe
+}) => {
+  const fe = Yt(jt.FACE_TRACKER), Ue = $t(), { camera: nt } = Bt(), H = Mn({ mesh: et, url: tt }), Ie = l(null), rt = l(null), at = l(null), ot = l(null), st = l(null), it = l(null), ct = l(null), lt = l(null), dt = l(null), ut = l(null), ft = l(null), ht = l(null), mt = l(null), pt = l(null), yt = l(null), bt = l(null), gt = l(null), Mt = l(null), xt = l(null), At = l(null), he = l(null), me = l(null), pe = l(null), Oe = l(null), vt = l(new m.Vector3()), Et = l({ x: 0, y: 0, z: 0 }), St = l({ x: 0, y: 0, z: 0 }), Tt = l({ x: 0, y: 0, z: 0 }), se = l(!1), Rt = wn[f], Ct = n ?? t, _t = p ?? M, kt = U ?? M, wt = R || (w ?? _), Ft = R || (S ?? _), Ut = R || D, It = R || Y, Ot = {
+    base: Ie,
+    mouth: rt,
+    lips: at,
+    "left-eye": ot,
+    "right-eye": st,
+    nose: it,
+    "mouth-mask": ct,
+    "left-eye-mask": lt,
+    "right-eye-mask": dt,
+    "nose-mask": ut
+  }, Lt = {
+    base: ft,
+    mouth: ht,
+    lips: mt,
+    "left-eye": pt,
+    "right-eye": yt,
+    nose: bt,
+    "mouth-mask": gt,
+    "left-eye-mask": Mt,
+    "right-eye-mask": xt,
+    "nose-mask": At
+  }, Dt = {
+    base: k,
+    mouth: y,
+    lips: d,
+    "left-eye": _t,
+    "right-eye": kt,
+    nose: N,
+    "mouth-mask": Ut,
+    "left-eye-mask": wt,
+    "right-eye-mask": Ft,
+    "nose-mask": It
+  }, Pt = (A) => /* @__PURE__ */ g(
+    _n,
+    {
+      alphaMap: s,
+      alphaOpacity: u,
+      blendMode: c,
+      blendOpacity: v,
+      cameraTexture: Ue,
+      color: Ct,
+      compositeShading: Q,
+      faceAlphaMaskUrl: F,
+      faceTextureStyle2Url: z,
+      faceTextureUrl: h,
+      masked: A,
+      maskColor: E,
+      maskOpacity: T,
+      maskSourceUrl: x,
+      maskTextureSource: I,
+      materialType: a,
+      opacity: r,
+      shaderPreset: o,
+      side: Rt,
+      textureMap: i
+    }
+  ), q = kn.map(
+    (A) => ({
+      ...A,
+      geometryRef: Ot[A.key],
+      meshRef: Lt[A.key],
+      visible: Dt[A.key]
+    })
+  ), zt = (A) => Qt(A, nt, vt.current);
+  return Vt(() => {
+    var ze, Ge;
+    const A = Ie.current, B = (Ge = (ze = fe == null ? void 0 : fe.detectionResults) == null ? void 0 : ze.faceLandmarks) == null ? void 0 : Ge[e], Gt = q.every(
+      (b) => b.geometryRef.current && b.meshRef.current
+    );
+    if (!H || !A || !Gt) return;
+    if (!B || B.length < H.vertexCount) {
+      q.forEach((b) => {
+        b.meshRef.current.visible = !1;
+      });
+      return;
+    }
+    if (Oe.current !== H) {
+      he.current = new Float32Array(H.vertexCount * 3), me.current = new Float32Array(H.uvs), pe.current = new Float32Array(H.vertexCount * 2);
+      const b = {
+        position: new m.BufferAttribute(he.current, 3),
+        uv: new m.BufferAttribute(me.current, 2),
+        faceUv: new m.BufferAttribute(pe.current, 2)
+      };
+      q.forEach((O) => {
+        Fn(O.geometryRef.current, b, O.getIndices(H));
+      }), b.uv.needsUpdate = !0, Oe.current = H, se.current = !1;
+    }
+    const ie = he.current, ye = pe.current, ce = me.current;
+    if (!ie || !ye || !ce) return;
+    const Le = vn(a, o, i), De = dn($), Pe = De ? ln(B) : null, P = W ? Tt.current : null;
+    if (P) {
+      P.x = 0, P.y = 0, P.z = 0;
+      for (let b = 0; b < B.length; b++) {
+        const O = B[b];
+        P.x += O.x, P.y += O.y, P.z += O.z;
+      }
+      P.x /= B.length, P.y /= B.length, P.z /= B.length;
+    }
+    const Nt = Math.min(B.length, H.vertexCount);
+    for (let b = 0; b < Nt; b++) {
+      const O = B[b], Ne = De && Pe ? un(O, Pe, $, Et.current) : O, Ht = W && P ? Kt(
+        Ne,
+        P,
+        W,
+        St.current
+      ) : Ne, be = b * 3, le = b * 2, ge = zt(Ht);
+      ie[be] = ge.x, ie[be + 1] = ge.y, ie[be + 2] = ge.z, ye[le] = O.x, ye[le + 1] = 1 - O.y, Le && (ce[le] = O.x, ce[le + 1] = 1 - O.y);
+    }
+    Le ? (A.attributes.uv.needsUpdate = !0, se.current = !0) : se.current && (ce.set(H.uvs), A.attributes.uv.needsUpdate = !0, se.current = !1), q.forEach((b) => {
+      b.meshRef.current.visible = b.visible;
+    }), A.attributes.position.needsUpdate = !0, A.attributes.faceUv.needsUpdate = !0, q.forEach((b) => {
+      b.geometryRef.current.computeVertexNormals();
+    });
+  }), /* @__PURE__ */ g("group", { scale: [ue, ue, ue], children: q.map((A) => /* @__PURE__ */ we(
+    "mesh",
+    {
+      ref: A.meshRef,
+      renderOrder: Je + A.renderOrderOffset,
+      frustumCulled: !1,
+      children: [
+        /* @__PURE__ */ g("bufferGeometry", { ref: A.geometryRef }),
+        oe ? typeof oe == "function" ? oe({ cameraTexture: Ue ?? null, geometryKey: A.key }) : oe : Pt(A.masked)
+      ]
+    },
+    A.key
+  )) });
+}, In = `${re.sdkAssetsBaseUrl}/Canonical_Face_Color.png`, On = `${re.sdkAssetsBaseUrl}/Canonical_Face_Color_style_2.png`, Ln = `${re.sdkAssetsBaseUrl}/Canonical_Face_Color_Mask.png`, Dn = {
+  ...Ve,
+  position: { ...Ve.position, y: 1e-3 }
+}, Qn = {
+  enabled: !0,
+  faceIndex: 0,
+  targetFps: An,
+  ...G,
+  showLeftEyeGeometry: !0,
+  showRightEyeGeometry: !0,
+  showMouthGeometry: !0,
+  showNoseGeometry: !0,
+  externalScale: 1,
+  showOverlayMask: !1,
+  showMouthMask: !1,
+  showLeftEyeMask: !1,
+  showRightEyeMask: !1,
+  showNoseMask: !1,
+  maskTextureSource: ee.textureSource,
+  maskSourceUrl: "",
+  maskColor: ee.color,
+  maskOpacity: ee.opacity,
+  faceTextureUrl: In,
+  faceTextureStyle2Url: On,
+  faceAlphaMaskUrl: Ln,
+  renderOrder: Ze
+}, Pn = (e) => {
+  const { externalMeshUrl: n, ...t } = e;
+  return { ...t, color: t.baseColor, meshUrl: n };
+}, qn = (e, n) => {
+  const t = { ...e, ...n };
+  return n.maskTextureSource && !ke(n.maskTextureSource) && (t.maskSourceUrl = ""), t.materialType === C.shader && n.shaderPreset === X.composite ? {
+    ...t,
+    ...Xe,
+    materialType: C.shader,
+    shaderPreset: X.composite
+  } : t.materialType === C.shader && t.shaderPreset === X.composite && t.textureMap === j.none ? {
+    ...t,
+    textureMap: Xe.textureMap
+  } : t;
+}, Zn = ({
+  transform: e,
+  value: n
+}) => n.enabled ? /* @__PURE__ */ we(Ye, { children: [
+  /* @__PURE__ */ g(
+    qt,
+    {
+      active: n.enabled,
+      faceIndex: n.faceIndex,
+      numFaces: n.faceIndex + 1,
+      targetFps: n.targetFps
+    }
+  ),
+  /* @__PURE__ */ g(
+    Un,
+    {
+      ...Pn(n),
+      transform: e ?? Dn
+    }
+  )
+] }) : null;
+export {
+  Qe as A,
+  Ve as B,
+  Un as C,
+  G as D,
+  _e as E,
+  C as F,
+  En as G,
+  ke as H,
+  cn as M,
+  an as S,
+  Re as T,
+  X as a,
+  ne as b,
+  j as c,
+  J as d,
+  qe as e,
+  ae as f,
+  je as g,
+  Qn as h,
+  Dn as i,
+  Te as j,
+  Kn as k,
+  _n as l,
+  Zn as m,
+  Ln as n,
+  On as o,
+  In as p,
+  kn as q,
+  Pn as r,
+  $n as s,
+  qn as t,
+  Mn as u,
+  pn as v,
+  K as w,
+  en as x,
+  Yn as y,
+  jn as z
+};