@vincentt-xr/sdk 2.0.0-alpha.7 → 2.0.0-alpha.9

package/dist/renderPasses-B6l8IpJv.js

@@ -0,0 +1,1290 @@
+import { jsx as f, jsxs as Fe, Fragment as Ye } from "react/jsx-runtime";
+import { useLoader as fe, useThree as Bt, useFrame as zt } from "@react-three/fiber";
+import { useRef as o, useMemo as $, useState as qe, useCallback as He, useEffect as Se } from "react";
+import * as E from "three";
+import { MathUtils as Qe, Color as Ht, Vector2 as Ve } from "three";
+import { C as se, j as Vt, X as Xt, F as jt } from "./index-CIe7eCMH.js";
+import { b as Wt, c as $t, e as Kt } from "./selectors-DmNaKIwE.js";
+import { t as Yt, p as qt, F as Qt } from "./index-BavF06C6.js";
+import { s as Jt } from "./updateThrottle-BseecYag.js";
+import { t as Zt, d as en, e as tn, T as Ee, f as nn, g as sn } from "./index-DBhQzvVa.js";
+import { TransformControls as rn } from "@react-three/drei";
+const an = (e) => {
+  const n = o(null);
+  if (n.current) {
+    const t = n.current;
+    Object.keys(e).forEach((s) => {
+      t[s].value = e[s];
+    });
+  } else {
+    const t = {};
+    Object.keys(e).forEach((s) => {
+      t[s] = { value: e[s] };
+    }), n.current = t;
+  }
+  return n.current;
+}, _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
+}, on = (e) => {
+  const n = e.slice(0, _e).map((t) => ({ ...t, offset: Qe.clamp(t.offset, 0, 1) })).sort((t, s) => t.offset - s.offset);
+  return n.length >= 2 ? n : K.stops.map((t) => ({ ...t }));
+}, ln = (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: on((e == null ? void 0 : e.stops) ?? K.stops)
+}), cn = `
+  varying vec2 vPosition;
+  void main() {
+    vPosition = position.xy;
+    gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+  }
+`, fn = `
+  #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);
+  }
+`, un = { linear: 0, radial: 1, angular: 2 }, dn = ({ opacity: e = 1, value: n }) => {
+  const t = $(() => {
+    const a = ln(n), r = Qe.degToRad(a.angle), i = a.stops.map((h) => new Ht(h.color)), u = a.stops.map((h) => h.offset);
+    for (; i.length < _e; ) i.push(i[i.length - 1]);
+    for (; u.length < _e; ) u.push(1);
+    return {
+      stopColors: i,
+      stopOffsets: u,
+      stopCount: a.stops.length,
+      gradientType: un[a.type],
+      direction: new Ve(Math.cos(r), Math.sin(r)),
+      center: new Ve(a.center.x - 0.5, 0.5 - a.center.y),
+      radius: a.radius,
+      angleOffset: a.angle / 360,
+      opacity: e
+    };
+  }, [e, n]), s = an(t);
+  return /* @__PURE__ */ f(
+    "shaderMaterial",
+    {
+      uniforms: s,
+      vertexShader: cn,
+      fragmentShader: fn,
+      transparent: e < 1,
+      depthTest: !1,
+      depthWrite: !1,
+      toneMapped: !1
+    }
+  );
+}, mn = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO2YpZcAAAAASUVORK5CYII=", ts = {
+  source: "solid",
+  color: "#ffffff",
+  opacity: 1,
+  textureUrl: "",
+  gradient: K
+}, Je = (e) => ({
+  ...K,
+  stops: [
+    { offset: 0, color: "#ffffff" },
+    { offset: 1, color: e }
+  ]
+}), hn = ({
+  depthTest: e,
+  depthWrite: n,
+  settings: t,
+  side: s,
+  toneMapped: a
+}) => {
+  const r = fe(
+    E.TextureLoader,
+    t.textureUrl || mn
+  );
+  return /* @__PURE__ */ f(
+    "meshBasicMaterial",
+    {
+      color: t.color,
+      map: r,
+      transparent: !0,
+      opacity: t.opacity,
+      side: s,
+      depthWrite: n,
+      depthTest: e,
+      toneMapped: a
+    }
+  );
+}, pn = ({
+  depthTest: e = !1,
+  depthWrite: n = !1,
+  settings: t,
+  side: s,
+  toneMapped: a = !1
+}) => {
+  const r = $(
+    () => t.gradient ?? Je(t.color),
+    [t.color, t.gradient]
+  );
+  return t.source === "gradient" ? /* @__PURE__ */ f(dn, { value: r, opacity: t.opacity }) : t.source === "texture" ? /* @__PURE__ */ f(
+    hn,
+    {
+      settings: t,
+      side: s,
+      depthTest: e,
+      depthWrite: n,
+      toneMapped: a
+    }
+  ) : /* @__PURE__ */ f(
+    "meshBasicMaterial",
+    {
+      color: t.color,
+      transparent: !0,
+      opacity: t.opacity,
+      side: s,
+      depthWrite: n,
+      depthTest: e,
+      toneMapped: a
+    }
+  );
+}, Me = Math.PI / 180, ve = 180 / Math.PI, G = (e) => Number(e.toFixed(6)), Xe = {
+  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
+}, ns = ({ children: e, objectRef: n, onChange: t, value: s }) => {
+  const a = o(null), r = o(n);
+  r.current = n;
+  const [i, u] = qe(null), h = He((l) => {
+    var F;
+    a.current = l, u(l), (F = r.current) == null || F.call(r, l);
+  }, []), g = He(() => {
+    const l = a.current;
+    !l || !t || t({
+      ...s,
+      position: {
+        x: G(l.position.x),
+        y: G(l.position.y),
+        z: G(l.position.z)
+      },
+      rotation: {
+        x: G(l.rotation.x * ve),
+        y: G(l.rotation.y * ve),
+        z: G(l.rotation.z * ve)
+      },
+      scale: {
+        x: G(l.scale.x),
+        y: G(l.scale.y),
+        z: G(l.scale.z)
+      }
+    });
+  }, [t, s]);
+  return s.enabled ? /* @__PURE__ */ Fe(Ye, { children: [
+    /* @__PURE__ */ f(
+      "group",
+      {
+        ref: h,
+        position: [s.position.x, s.position.y, s.position.z],
+        rotation: [
+          s.rotation.x * Me,
+          s.rotation.y * Me,
+          s.rotation.z * Me
+        ],
+        scale: [s.scale.x, s.scale.y, s.scale.z],
+        visible: s.visible,
+        children: e
+      }
+    ),
+    i && s.showTransformControls && /* @__PURE__ */ f(
+      rn,
+      {
+        object: i,
+        mode: s.transformControlMode,
+        space: s.transformControlSpace,
+        size: 0.85,
+        onMouseUp: g,
+        onObjectChange: g
+      }
+    )
+  ] }) : null;
+}, y = {
+  basic: "basic",
+  standard: "standard",
+  physical: "physical",
+  toon: "toon",
+  normal: "normal",
+  matcap: "matcap",
+  wireframe: "wireframe",
+  shader: "shader"
+}, H = {
+  originalFace: "originalFace",
+  composite: "composite"
+}, V = {
+  none: "none",
+  canonical: "canonical",
+  style2: "style2"
+}, Q = {
+  none: "none",
+  canonical: "canonical"
+}, re = {
+  solid: "solid",
+  gradient: "gradient",
+  imageUrl: "imageUrl",
+  mediaUrl: "mediaUrl"
+}, ne = {
+  front: "front",
+  back: "back",
+  double: "double"
+}, Ze = {
+  normal: "normal",
+  add: "add",
+  subtract: "subtract",
+  multiply: "multiply",
+  screen: "screen",
+  overlay: "overlay",
+  softLight: "softLight",
+  hardLight: "hardLight",
+  lighten: "lighten",
+  darken: "darken",
+  difference: "difference",
+  exclusion: "exclusion"
+}, yn = {
+  textureMap: V.canonical,
+  alphaMap: Q.canonical,
+  alphaOpacity: 1
+}, je = {
+  ...yn,
+  blendMode: Ze.hardLight,
+  blendOpacity: 0.85,
+  baseColor: "#ffffff",
+  opacity: 1,
+  compositeShading: !0
+}, O = {
+  materialType: y.basic,
+  shaderPreset: H.originalFace,
+  textureMap: V.none,
+  alphaMap: Q.none,
+  alphaOpacity: 1,
+  side: ne.front,
+  blendMode: Ze.normal,
+  blendOpacity: 1,
+  baseColor: "#38bdf8",
+  opacity: 0.45,
+  compositeShading: !1
+};
+y.shader, H.composite, ne.front;
+const Ae = {
+  mouth: !0,
+  eyes: !0,
+  nose: !0
+}, J = {
+  textureSource: re.solid,
+  color: "#111111",
+  opacity: 0.5
+}, gn = 24, et = 10, Ue = (e, n, t) => e !== y.shader ? "none" : n === H.originalFace ? "originalFace" : n === H.composite ? t === V.none ? "originalFace" : "composite" : "none", ss = (e, n) => e === y.basic || e === y.standard || e === y.physical || e === y.toon || e === y.shader && n === H.composite, rs = (e, n, t = V.canonical) => Ue(e, n, t) === "composite", bn = (e, n, t) => Ue(e, n, t) === "originalFace", Ce = (e) => e === re.imageUrl || e === re.mediaUrl, En = (e) => e === re.solid || e === re.gradient, xe = /* @__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
+], $e = [
+  78,
+  95,
+  88,
+  178,
+  87,
+  14,
+  317,
+  402,
+  318,
+  324,
+  308,
+  415,
+  310,
+  311,
+  312,
+  13,
+  82,
+  81,
+  80,
+  191
+], Te = /* @__PURE__ */ new Set([
+  33,
+  7,
+  163,
+  144,
+  145,
+  153,
+  154,
+  155,
+  133,
+  173,
+  157,
+  158,
+  159,
+  160,
+  161,
+  246
+]), Re = /* @__PURE__ */ new Set([
+  362,
+  382,
+  381,
+  380,
+  374,
+  373,
+  390,
+  249,
+  263,
+  466,
+  388,
+  387,
+  386,
+  385,
+  384,
+  398
+]), Mn = [814, 815, 816, 817, 818, 819, 830, 831, 832, 833], vn = new Set(Mn), An = (e, n, t) => {
+  const s = xe.has(e) && xe.has(n) && xe.has(t), a = Te.has(e) && Te.has(n) && Te.has(t), r = Re.has(e) && Re.has(n) && Re.has(t);
+  return s ? "mouth" : a ? "leftEye" : r ? "rightEye" : "base";
+}, xn = (e) => {
+  const n = [], t = [], s = [], a = [], r = [], i = [], u = [], h = [];
+  let g = 0, l = 0;
+  e.split(`
+`).forEach((b) => {
+    const k = b.trim();
+    if (!k) return;
+    if (k.startsWith("v ")) {
+      g += 1;
+      return;
+    }
+    if (k.startsWith("vt ")) {
+      const [, _, m] = k.split(/\s+/);
+      u.push([Number(_), Number(m)]);
+      return;
+    }
+    if (!k.startsWith("f ")) return;
+    const S = l;
+    l += 1;
+    const [, ...L] = k.split(/\s+/), I = L.map((_) => {
+      const [m, M] = _.split("/"), p = Number(m) - 1, T = Number(M) - 1;
+      return T >= 0 && u[T] && !h[p] && (h[p] = u[T]), p;
+    });
+    if (!(I.length < 3))
+      for (let _ = 1; _ < I.length - 1; _ += 1) {
+        const m = I[0], M = I[_], p = I[_ + 1];
+        n.push(m, M, p);
+        const T = An(m, M, p);
+        vn.has(S) ? i.push(m, M, p) : T === "mouth" ? s.push(m, M, p) : T === "leftEye" ? a.push(m, M, p) : T === "rightEye" ? r.push(m, M, p) : t.push(m, M, p);
+      }
+  });
+  const F = [];
+  for (let b = 0; b < g; b += 1) {
+    const [k, S] = h[b] ?? [0, 0];
+    F.push(k, S);
+  }
+  const U = new Uint16Array(a), X = new Uint16Array(r), A = new Uint16Array(a.length + r.length);
+  A.set(U), A.set(X, U.length);
+  const x = Zt(
+    en(n, We, $e),
+    n
+  );
+  return {
+    baseIndices: new Uint16Array(t),
+    mouthIndices: new Uint16Array(s),
+    lipIndices: x,
+    lipEdgeDistance: tn(
+      x,
+      g,
+      We,
+      $e
+    ),
+    leftEyeIndices: U,
+    rightEyeIndices: X,
+    eyeIndices: A,
+    noseIndices: new Uint16Array(i),
+    uvs: new Float32Array(F),
+    vertexCount: g
+  };
+}, Tn = "canonical_face_model.obj", Rn = new TextDecoder("utf-8"), ke = /* @__PURE__ */ new Map(), kn = (e) => {
+  const n = ke.get(e);
+  if (n) return n;
+  const t = Vt(e).then((s) => xn(Rn.decode(s))).catch((s) => {
+    throw ke.delete(e), s;
+  });
+  return ke.set(e, t), t;
+}, Sn = (e) => {
+  const { mesh: n, url: t } = e ?? {}, s = t ?? `${se.sdkAssetsBaseUrl}/${Tn}`, [a, r] = qe(n ?? null);
+  return Se(() => {
+    if (n) {
+      r(n);
+      return;
+    }
+    let i = !1;
+    return kn(s).then((u) => {
+      i || r(u);
+    }).catch((u) => {
+      i || console.error(`${se.loggerPrefix} canonical face mesh load failed`, u);
+    }), () => {
+      i = !0;
+    };
+  }, [n, s]), a;
+}, Ke = {
+  normal: 0,
+  add: 1,
+  subtract: 2,
+  multiply: 3,
+  screen: 4,
+  overlay: 5,
+  softLight: 6,
+  hardLight: 7,
+  lighten: 8,
+  darken: 9,
+  difference: 10,
+  exclusion: 11
+}, _n = `
+  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);
+    // Blending above runs in sRGB; the result is linear here and three only
+    // encodes built-in materials, so encode for the output colour space.
+    #include <colorspace_fragment>
+  }
+`, Fn = ({
+  alphaMap: e,
+  alphaOpacity: n,
+  blendMode: t,
+  blendOpacity: s,
+  cameraTexture: a,
+  color: r,
+  compositeShading: i,
+  faceAlphaMaskUrl: u,
+  faceTextureStyle2Url: h,
+  faceTextureUrl: g,
+  masked: l = !1,
+  maskColor: F,
+  maskOpacity: U,
+  maskSourceUrl: X,
+  maskTextureSource: A,
+  materialType: x,
+  opacity: b,
+  shaderPreset: k,
+  side: S,
+  textureMap: L
+}) => {
+  const I = fe(
+    E.TextureLoader,
+    g || Ee
+  ), _ = fe(
+    E.TextureLoader,
+    h || g || Ee
+  ), m = fe(
+    E.TextureLoader,
+    u || Ee
+  ), M = $(() => nn(), []), p = $(() => sn(), []);
+  Se(
+    () => () => {
+      M.dispose(), p.dispose();
+    },
+    [p, M]
+  );
+  const T = L === V.style2 ? _ : I, j = L !== V.none, ae = Ue(x, k, L), ue = [
+    "composite-material",
+    L,
+    e,
+    n,
+    t,
+    s,
+    i ? "lit" : "flat",
+    r,
+    b,
+    g,
+    h,
+    u
+  ].join("|"), B = {
+    side: S,
+    transparent: !0,
+    opacity: b,
+    wireframe: !1
+  }, de = $(
+    () => ({
+      source: Ce(A) ? "texture" : A,
+      color: En(A) ? F : "#ffffff",
+      opacity: U,
+      textureUrl: Ce(A) ? X : "",
+      gradient: Je(F)
+    }),
+    [F, U, X, A]
+  ), v = $(
+    () => ({
+      cameraTexture: { value: null },
+      canonicalTexture: { value: null },
+      alphaMask: { value: null },
+      textureTint: { value: new E.Color(r) },
+      opacity: { value: b },
+      blendMode: { value: Ke[t] },
+      blendOpacity: { value: s },
+      useCanonicalTexture: { value: j ? 1 : 0 },
+      useAlphaMask: { value: e === Q.canonical ? 1 : 0 },
+      alphaOpacity: { value: n },
+      compositeShading: { value: i ? 1 : 0 },
+      lightDirection: { value: new E.Vector3(0.3, 0.65, 0.7).normalize() },
+      ambientStrength: { value: 0.78 },
+      directionalStrength: { value: 0.38 }
+    }),
+    [
+      e,
+      n,
+      t,
+      s,
+      r,
+      i,
+      j,
+      b
+    ]
+  );
+  if (Se(() => {
+    v.cameraTexture.value = a ?? I, v.canonicalTexture.value = T, v.alphaMask.value = m, v.textureTint.value.set(r), v.opacity.value = b, v.blendMode.value = Ke[t], v.blendOpacity.value = s, v.useCanonicalTexture.value = j ? 1 : 0, v.useAlphaMask.value = e === Q.canonical ? 1 : 0, v.alphaOpacity.value = n, v.compositeShading.value = i ? 1 : 0;
+  }, [
+    e,
+    m,
+    n,
+    t,
+    s,
+    a,
+    r,
+    i,
+    v,
+    I,
+    j,
+    b,
+    T
+  ]), l)
+    return /* @__PURE__ */ f(
+      pn,
+      {
+        settings: de,
+        side: S
+      },
+      `masked-${A}-material`
+    );
+  if (x === y.wireframe)
+    return /* @__PURE__ */ f(
+      "meshBasicMaterial",
+      {
+        color: r,
+        transparent: !0,
+        opacity: b,
+        side: S,
+        depthWrite: !1,
+        depthTest: !1,
+        wireframe: !0,
+        toneMapped: !1
+      },
+      "wireframe-material"
+    );
+  if (ae === "originalFace" && a)
+    return /* @__PURE__ */ f(
+      "meshBasicMaterial",
+      {
+        map: a,
+        alphaMap: m,
+        transparent: !0,
+        opacity: b,
+        side: S,
+        depthWrite: !1,
+        depthTest: !0,
+        toneMapped: !1
+      },
+      "use-original-face-material"
+    );
+  if (ae === "composite" && a)
+    return /* @__PURE__ */ f(
+      "shaderMaterial",
+      {
+        uniforms: v,
+        vertexShader: _n,
+        fragmentShader: Cn,
+        transparent: !0,
+        side: S,
+        depthWrite: !1,
+        depthTest: !0,
+        toneMapped: !1
+      },
+      ue
+    );
+  const Y = j ? T : null, z = e === Q.canonical && n > 0 ? m : null, q = `${x}-${L}-${e}-${n > 0 ? "alpha-on" : "alpha-off"}`;
+  return x === y.standard ? /* @__PURE__ */ f(
+    "meshStandardMaterial",
+    {
+      ...B,
+      color: r,
+      map: Y ?? void 0,
+      alphaMap: z ?? void 0,
+      depthWrite: !0,
+      depthTest: !0,
+      metalness: 0.05,
+      roughness: 0.72
+    },
+    q
+  ) : x === y.physical ? /* @__PURE__ */ f(
+    "meshPhysicalMaterial",
+    {
+      ...B,
+      color: r,
+      map: Y ?? void 0,
+      alphaMap: z ?? void 0,
+      depthWrite: !0,
+      depthTest: !0,
+      roughness: 0.58,
+      metalness: 0.08,
+      clearcoat: 0.35,
+      clearcoatRoughness: 0.4
+    },
+    q
+  ) : x === y.toon ? /* @__PURE__ */ f(
+    "meshToonMaterial",
+    {
+      ...B,
+      color: r,
+      map: Y ?? void 0,
+      alphaMap: z ?? void 0,
+      gradientMap: M,
+      depthWrite: !0,
+      depthTest: !0
+    },
+    q
+  ) : x === y.normal ? /* @__PURE__ */ f(
+    "meshNormalMaterial",
+    {
+      ...B,
+      depthWrite: !0,
+      depthTest: !0,
+      flatShading: !1
+    },
+    "normal-material"
+  ) : x === y.matcap ? /* @__PURE__ */ f(
+    "meshMatcapMaterial",
+    {
+      ...B,
+      color: r,
+      matcap: p,
+      depthWrite: !0,
+      depthTest: !0
+    },
+    "matcap-material"
+  ) : /* @__PURE__ */ f(
+    "meshBasicMaterial",
+    {
+      ...B,
+      color: r,
+      map: Y ?? void 0,
+      alphaMap: z ?? void 0,
+      depthWrite: !1,
+      depthTest: L !== V.none || e !== Q.none,
+      toneMapped: !1
+    },
+    q
+  );
+}, Un = [
+  {
+    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
+  }
+], In = (e, n) => n ? {
+  "left-eye": e.leftEye,
+  "right-eye": e.rightEye,
+  "left-eye-mask": e.leftEyeMask,
+  "right-eye-mask": e.rightEyeMask
+} : {
+  "left-eye": e.rightEye,
+  "right-eye": e.leftEye,
+  "left-eye-mask": e.rightEyeMask,
+  "right-eye-mask": e.leftEyeMask
+}, On = {
+  [ne.front]: E.FrontSide,
+  [ne.back]: E.BackSide,
+  [ne.double]: E.DoubleSide
+}, Ln = (e) => ({
+  position: new E.BufferAttribute(new Float32Array(e.vertexCount * 3), 3),
+  uv: new E.BufferAttribute(new Float32Array(e.uvs), 2),
+  faceUv: new E.BufferAttribute(new Float32Array(e.vertexCount * 2), 2),
+  lipEdge: new E.BufferAttribute(new Float32Array(e.lipEdgeDistance), 1)
+}), wn = (e, n, t) => {
+  e.setAttribute("position", n.position), e.setAttribute("uv", n.uv), e.setAttribute("faceUv", n.faceUv), e.setAttribute("lipEdge", n.lipEdge), e.setIndex(new E.BufferAttribute(t, 1));
+}, Dn = ({
+  faceIndex: e = 0,
+  baseColor: n,
+  color: t = O.baseColor,
+  opacity: s = O.opacity,
+  materialType: a = O.materialType,
+  shaderPreset: r = O.shaderPreset,
+  textureMap: i = O.textureMap,
+  alphaMap: u = O.alphaMap,
+  alphaOpacity: h = O.alphaOpacity,
+  side: g = O.side,
+  blendMode: l = O.blendMode,
+  blendOpacity: F = O.blendOpacity,
+  showOverlayMask: U = !1,
+  showMouthMask: X = Ae.mouth,
+  showEyeMask: A = Ae.eyes,
+  showLeftEyeMask: x,
+  showRightEyeMask: b,
+  showNoseMask: k = Ae.nose,
+  showEyeGeometry: S = !0,
+  showLeftEyeGeometry: L,
+  showRightEyeGeometry: I,
+  showMouthGeometry: _ = !0,
+  // The lips mesh is an effect-only overlay. Rendering it with the base face
+  // mesh duplicates an incomplete triangulation over the mouth.
+  showLipsGeometry: m = !1,
+  showBaseGeometry: M = !0,
+  showNoseGeometry: p = !0,
+  maskTextureSource: T = J.textureSource,
+  maskSourceUrl: j = "",
+  maskColor: ae = J.color,
+  maskOpacity: ue = J.opacity,
+  faceTextureUrl: B = "",
+  faceTextureStyle2Url: de = "",
+  faceAlphaMaskUrl: v = "",
+  compositeShading: Y = !1,
+  transform: z,
+  renderOrder: q = et,
+  externalScale: me = 1,
+  mesh: tt,
+  meshUrl: nt,
+  materialOverride: Z,
+  maxUpdateFps: st,
+  holdMs: Ie = 250,
+  predictMs: Oe = 0
+}) => {
+  const he = Wt(Xt.FACE_TRACKER), Le = $t(), { camera: rt } = Bt(), w = Sn({ mesh: tt, url: nt }), we = o(null), at = o(null), ot = o(null), it = o(null), lt = o(null), ct = o(null), ft = o(null), ut = o(null), dt = o(null), mt = o(null), ht = o(null), pt = o(null), yt = o(null), gt = o(null), bt = o(null), Et = o(null), Mt = o(null), vt = o(null), At = o(null), xt = o(null), R = $(
+    () => w ? Ln(w) : null,
+    [w]
+  ), De = o(null), Ne = o(-1 / 0), oe = o(null);
+  oe.current || (oe.current = new jt({ holdMs: Ie, predictMs: Oe })), oe.current.setOptions({ holdMs: Ie, predictMs: Oe });
+  const Tt = o(new E.Vector3()), Rt = o({ x: 0, y: 0, z: 0 }), kt = o({ x: 0, y: 0, z: 0 }), ie = o(!1), St = On[g], _t = n ?? t, Ct = Kt(), le = In(
+    {
+      leftEye: L ?? S,
+      rightEye: I ?? S,
+      leftEyeMask: U || (x ?? A),
+      rightEyeMask: U || (b ?? A)
+    },
+    Ct
+  ), Ft = U || X, Ut = U || k, It = {
+    base: we,
+    mouth: at,
+    lips: ot,
+    "left-eye": it,
+    "right-eye": lt,
+    nose: ct,
+    "mouth-mask": ft,
+    "left-eye-mask": ut,
+    "right-eye-mask": dt,
+    "nose-mask": mt
+  }, Ot = {
+    base: ht,
+    mouth: pt,
+    lips: yt,
+    "left-eye": gt,
+    "right-eye": bt,
+    nose: Et,
+    "mouth-mask": Mt,
+    "left-eye-mask": vt,
+    "right-eye-mask": At,
+    "nose-mask": xt
+  }, Lt = {
+    base: M,
+    mouth: _,
+    lips: m,
+    "left-eye": le["left-eye"],
+    "right-eye": le["right-eye"],
+    nose: p,
+    "mouth-mask": Ft,
+    "left-eye-mask": le["left-eye-mask"],
+    "right-eye-mask": le["right-eye-mask"],
+    "nose-mask": Ut
+  }, wt = (d) => /* @__PURE__ */ f(
+    Fn,
+    {
+      alphaMap: u,
+      alphaOpacity: h,
+      blendMode: l,
+      blendOpacity: F,
+      cameraTexture: Le,
+      color: _t,
+      compositeShading: Y,
+      faceAlphaMaskUrl: v,
+      faceTextureStyle2Url: de,
+      faceTextureUrl: B,
+      masked: d,
+      maskColor: ae,
+      maskOpacity: ue,
+      maskSourceUrl: j,
+      maskTextureSource: T,
+      materialType: a,
+      opacity: s,
+      shaderPreset: r,
+      side: St,
+      textureMap: i
+    }
+  ), W = Un.map(
+    (d) => ({
+      ...d,
+      geometryRef: It[d.key],
+      meshRef: Ot[d.key],
+      visible: Lt[d.key]
+    })
+  ), Dt = (d) => qt(d, rt, Tt.current);
+  return zt((d) => {
+    var Be, ze;
+    const N = we.current, ee = (ze = (Be = he == null ? void 0 : he.detectionResults) == null ? void 0 : Be.faceLandmarks) == null ? void 0 : ze[e], Nt = W.every(
+      (c) => c.geometryRef.current && c.meshRef.current
+    );
+    if (!w || !R || !N || !Nt) return;
+    const P = oe.current.update(
+      [ee ?? []],
+      d.clock.elapsedTime * 1e3
+    )[0];
+    if (!P || P.length < w.vertexCount) {
+      W.forEach((c) => {
+        c.meshRef.current.visible = !1;
+      });
+      return;
+    }
+    if ((De.current !== w || W.some((c) => !c.geometryRef.current.index)) && (W.forEach((c) => {
+      wn(c.geometryRef.current, R, c.getIndices(w));
+    }), R.uv.needsUpdate = !0, R.lipEdge.needsUpdate = !0, De.current = w, ie.current = !1), Jt(d.clock.elapsedTime, Ne.current, st)) return;
+    Ne.current = d.clock.elapsedTime;
+    const pe = R.position.array, Pe = R.faceUv.array, ye = R.uv.array, Ge = bn(a, r, i), C = z ? kt.current : null;
+    if (C) {
+      C.x = 0, C.y = 0, C.z = 0;
+      for (let c = 0; c < P.length; c++) {
+        const D = P[c];
+        C.x += D.x, C.y += D.y, C.z += D.z;
+      }
+      C.x /= P.length, C.y /= P.length, C.z /= P.length;
+    }
+    const Pt = Math.min(P.length, w.vertexCount);
+    for (let c = 0; c < Pt; c++) {
+      const D = P[c], Gt = z && C ? Yt(
+        D,
+        C,
+        z,
+        Rt.current
+      ) : D, ge = c * 3, ce = c * 2, be = Dt(Gt);
+      pe[ge] = be.x, pe[ge + 1] = be.y, pe[ge + 2] = be.z, Pe[ce] = D.x, Pe[ce + 1] = 1 - D.y, Ge && (ye[ce] = D.x, ye[ce + 1] = 1 - D.y);
+    }
+    Ge ? (N.attributes.uv.needsUpdate = !0, ie.current = !0) : ie.current && (ye.set(w.uvs), N.attributes.uv.needsUpdate = !0, ie.current = !1), W.forEach((c) => {
+      c.meshRef.current.visible = c.visible;
+    }), N.attributes.position.needsUpdate = !0, N.attributes.faceUv.needsUpdate = !0, W.forEach((c) => {
+      c.geometryRef.current.computeVertexNormals();
+    });
+  }), /* @__PURE__ */ f("group", { scale: [me, me, me], children: W.map((d) => {
+    const N = Z ? typeof Z == "function" ? Z({
+      cameraTexture: Le ?? null,
+      geometryKey: d.key,
+      faceUv: (R == null ? void 0 : R.faceUv) ?? null,
+      lipEdge: (R == null ? void 0 : R.lipEdge) ?? null
+    }) : Z : void 0, ee = N instanceof E.Material ? N : void 0;
+    return /* @__PURE__ */ Fe(
+      "mesh",
+      {
+        ref: d.meshRef,
+        renderOrder: q + d.renderOrderOffset,
+        frustumCulled: !1,
+        material: ee,
+        children: [
+          /* @__PURE__ */ f("bufferGeometry", { ref: d.geometryRef }),
+          ee ? null : Z ? N : wt(d.masked)
+        ]
+      },
+      `${d.key}:${ee ? "instance" : "node"}`
+    );
+  }) });
+}, Nn = `${se.sdkAssetsBaseUrl}/Canonical_Face_Color.png`, Pn = `${se.sdkAssetsBaseUrl}/Canonical_Face_Color_style_2.png`, Gn = `${se.sdkAssetsBaseUrl}/Canonical_Face_Color_Mask.png`, Bn = {
+  ...Xe,
+  position: { ...Xe.position, y: 1e-3 }
+}, as = {
+  enabled: !0,
+  faceIndex: 0,
+  targetFps: gn,
+  ...O,
+  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: Nn,
+  faceTextureStyle2Url: Pn,
+  faceAlphaMaskUrl: Gn,
+  renderOrder: et
+}, zn = (e) => {
+  const { externalMeshUrl: n, ...t } = e;
+  return { ...t, color: t.baseColor, meshUrl: n };
+}, Hn = ({
+  materialOverride: e,
+  value: n
+}) => ({
+  ...zn(n),
+  materialOverride: e
+}), os = (e, n) => {
+  const t = { ...e, ...n };
+  return n.maskTextureSource && !Ce(n.maskTextureSource) && (t.maskSourceUrl = ""), t.materialType === y.shader && n.shaderPreset === H.composite ? {
+    ...t,
+    ...je,
+    materialType: y.shader,
+    shaderPreset: H.composite
+  } : t.materialType === y.shader && t.shaderPreset === H.composite && t.textureMap === V.none ? {
+    ...t,
+    textureMap: je.textureMap
+  } : t;
+}, is = ({ transform: e, value: n, materialOverride: t }) => n.enabled ? /* @__PURE__ */ Fe(Ye, { children: [
+  /* @__PURE__ */ f(
+    Qt,
+    {
+      active: n.enabled,
+      faceIndex: n.faceIndex,
+      numFaces: n.faceIndex + 1,
+      targetFps: n.targetFps
+    }
+  ),
+  /* @__PURE__ */ f(
+    Dn,
+    {
+      ...Hn({ value: n, materialOverride: t }),
+      transform: e ?? Bn
+    }
+  )
+] }) : null, Vn = 30, ls = 31, cs = (e, n = 1) => {
+  const t = n + e;
+  if (t < 1 || t > Vn)
+    throw new RangeError(`Render-group layer ${t} is outside the supported range 1-30.`);
+  return t;
+}, te = /* @__PURE__ */ new WeakMap(), fs = (e) => te.get(e) ?? null, us = ({
+  renderer: e,
+  scene: n,
+  camera: t,
+  layers: s,
+  includeDefaultLayer: a = !0
+}) => {
+  const r = t.layers.mask, i = e.autoClear, u = te.get(e);
+  try {
+    if (e.autoClear = !1, e.clear(!0, !0, !0), s.length === 0) {
+      t.layers.set(0), e.render(n, t);
+      return;
+    }
+    const h = { index: 0, count: s.length };
+    te.set(e, h), s.forEach((g, l) => {
+      h.index = l, t.layers.set(g), a && g !== 0 && t.layers.enable(0), l > 0 && e.clearDepth(), e.render(n, t);
+    });
+  } finally {
+    u ? te.set(e, u) : te.delete(e), t.layers.mask = r, e.autoClear = i;
+  }
+};
+export {
+  Bn as A,
+  Ae as B,
+  $e as C,
+  K as D,
+  ls as E,
+  y as F,
+  Dn as G,
+  Fn as H,
+  Gn as I,
+  Pn as J,
+  Nn as K,
+  Un as L,
+  Vn as M,
+  In as N,
+  Hn as O,
+  zn as P,
+  Sn as Q,
+  xn as R,
+  dn as S,
+  ns as T,
+  H as a,
+  ne as b,
+  V as c,
+  Q as d,
+  Ze as e,
+  re as f,
+  cs as g,
+  pn as h,
+  as as i,
+  Xe as j,
+  ts as k,
+  Je as l,
+  is as m,
+  ln as n,
+  _e as o,
+  rs as p,
+  En as q,
+  us as r,
+  ss as s,
+  Ce as t,
+  an as u,
+  os as v,
+  We as w,
+  fs as x,
+  Ke as y,
+  O as z
+};