@vincentt-xr/sdk 2.0.0-alpha.0 → 2.0.0-alpha.2

package/dist/FaceMeshRenderer-6t8OsQhK.js

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