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

package/dist/FaceRetouch-C7h7x9kd.js

@@ -0,0 +1,683 @@
+import { F as g, a as D, b as A, c as T, d as I, e as n, f as M } from "./FaceMeshRenderer-UuH5sTXG.js";
+import * as f from "three";
+import { jsx as F, jsxs as V } from "react/jsx-runtime";
+import { useMemo as R, useEffect as X } from "react";
+import { X as j } from "./index-CnGox6Xr.js";
+import { u as K } from "./index-CsUdQ-pn.js";
+import { useThree as Z, useFrame as q } from "@react-three/fiber";
+import { u as J } from "./selectors-C5G1PMYL.js";
+import { F as Q, d as $ } from "./landmarkMask-CbTFzBYG.js";
+const ee = {
+  enabled: !1,
+  strength: 1,
+  faceWidth: 0,
+  faceHeight: 0,
+  faceRoundness: 0,
+  midfaceHeight: 0,
+  foreheadHeight: 0,
+  foreheadWidth: 0,
+  cheekboneWidth: 0,
+  cheekWidth: 0,
+  cheekHollowness: 0,
+  midfaceDepth: 0,
+  scalpHeight: 0,
+  headCurve: 0,
+  faceTwist: 0,
+  faceSwirl: 0,
+  browDistance: 0,
+  browHeight: 0,
+  browDepth: 0,
+  eyeSize: 0,
+  leftEyeSize: 0,
+  rightEyeSize: 0,
+  eyeDistance: 0,
+  leftEyeX: 0,
+  rightEyeX: 0,
+  leftEyeY: 0,
+  rightEyeY: 0,
+  noseSize: 0,
+  noseLength: 0,
+  mouthWidth: 0,
+  mouthHeight: 0,
+  jawWidth: 0,
+  chinHeight: 0
+}, Me = {
+  ...ee,
+  enabled: !0,
+  strength: 1,
+  faceWidth: -0.08,
+  faceHeight: 0.04,
+  foreheadHeight: 0.04,
+  cheekWidth: -0.04,
+  eyeSize: 0.08,
+  eyeDistance: 0.03,
+  noseSize: -0.05,
+  noseLength: 0.03,
+  mouthWidth: 0.06,
+  mouthHeight: 0.02,
+  jawWidth: -0.05,
+  chinHeight: 0.03
+}, Ee = [
+  { label: "Wireframe", value: g.wireframe },
+  { label: "Basic", value: g.basic },
+  { label: "Standard", value: g.standard },
+  { label: "Physical", value: g.physical },
+  { label: "Toon", value: g.toon },
+  { label: "Normal", value: g.normal },
+  { label: "Matcap", value: g.matcap },
+  { label: "Shader", value: g.shader }
+], Ce = [
+  { label: "Original Face", value: D.originalFace },
+  { label: "Composite", value: D.composite }
+], Fe = [
+  { label: "Front", value: A.front },
+  { label: "Back", value: A.back },
+  { label: "Double", value: A.double }
+], we = [
+  { label: "None", value: T.none },
+  { label: "UV Map 1", value: T.canonical },
+  { label: "UV Map 2", value: T.style2 }
+], Le = [
+  { label: "None", value: I.none },
+  { label: "Default Mask", value: I.canonical }
+], Ae = [
+  { label: "Solid", value: M.solid },
+  { label: "Gradient", value: M.gradient },
+  { label: "Image URL", value: M.imageUrl },
+  { label: "Media URL", value: M.mediaUrl }
+], Te = [
+  { label: "Normal", value: n.normal },
+  { label: "Add", value: n.add },
+  { label: "Subtract", value: n.subtract },
+  { label: "Multiply", value: n.multiply },
+  { label: "Screen", value: n.screen },
+  { label: "Overlay", value: n.overlay },
+  { label: "Soft Light", value: n.softLight },
+  { label: "Hard Light", value: n.hardLight },
+  { label: "Lighten", value: n.lighten },
+  { label: "Darken", value: n.darken },
+  { label: "Difference", value: n.difference },
+  { label: "Exclusion", value: n.exclusion }
+], te = ["both", "left", "right"], ae = ["shader", "image"], oe = {
+  eye: "both",
+  mode: "shader",
+  color: "#4fa3ff",
+  textureUrl: "",
+  tintImage: !1,
+  scale: 1,
+  opacity: 0.85,
+  targetFps: 0,
+  smoothing: 0,
+  leadMs: 80,
+  mirrored: !1,
+  faceIndex: 0,
+  holdMs: 250
+}, _e = [
+  {
+    key: "eye",
+    label: "Eye",
+    type: "select",
+    options: te.map((e) => ({ label: e, value: e }))
+  },
+  {
+    key: "mode",
+    label: "Material",
+    type: "select",
+    options: ae.map((e) => ({ label: e, value: e }))
+  },
+  { key: "color", label: "Color / tint", type: "color" },
+  { key: "textureUrl", label: "Image URL (image mode)", type: "text" },
+  { key: "tintImage", label: "Tint image with color", type: "boolean" },
+  { key: "scale", label: "Scale (× iris radius)", type: "number", min: 0.2, max: 4, step: 0.05 },
+  { key: "opacity", label: "Opacity", type: "number", min: 0, max: 1, step: 0.05 },
+  { key: "targetFps", label: "Face FPS (0 = session)", type: "number", min: 0, max: 60, step: 1 },
+  { key: "smoothing", label: "Smoothing (0 = raw)", type: "number", min: 0, max: 60, step: 1 },
+  { key: "leadMs", label: "Lead between samples (ms)", type: "number", min: 0, max: 200, step: 10 },
+  { key: "mirrored", label: "Mirror material", type: "boolean" },
+  { key: "faceIndex", label: "Face index", type: "number", min: 0, max: 3, step: 1 },
+  { key: "holdMs", label: "Hold (ms)", type: "number", min: 0, max: 1e3, step: 10 }
+], Oe = (e) => ({
+  ...oe,
+  ...e
+}), Pe = (e, t) => ({ ...e, ...t }), Y = [
+  "lipstick",
+  "gloss",
+  "matte",
+  "tint",
+  "metallic",
+  "gradient"
+], re = ["texture", "solid"], le = ["outward", "vertical", "horizontal"], ie = {
+  preset: "custom",
+  maskMode: "outer-and-inner-lips",
+  colorMode: "texture",
+  color: "#e85d75",
+  opacity: 0.8,
+  intensity: 1,
+  shading: 0.6,
+  gloss: 0.35,
+  roughness: 0.5,
+  highlightColor: "#ffffff",
+  gradientColor: "#ffd6de",
+  gradientAmount: 0,
+  gradientDirection: "outward",
+  edgeSoftness: 0.12,
+  innerLipColor: "#7a1f36",
+  innerLipAmount: 0,
+  innerLipWidth: 0.35,
+  splitLips: !1,
+  lowerLipColor: "#e85d75",
+  lowerLipOpacity: 0.8,
+  textureScaleX: 1,
+  textureScaleY: 1,
+  textureOffsetX: 0,
+  textureOffsetY: 0,
+  textureRotation: 0,
+  textureFlipX: !1,
+  textureFlipY: !1
+}, N = {
+  lipstick: {
+    color: "#c0304f",
+    opacity: 0.85,
+    intensity: 1,
+    shading: 0.6,
+    gloss: 0.35,
+    roughness: 0.5,
+    highlightColor: "#ffffff",
+    gradientAmount: 0
+  },
+  gloss: {
+    color: "#e05a7a",
+    opacity: 0.7,
+    intensity: 1,
+    shading: 0.5,
+    gloss: 0.95,
+    roughness: 0.12,
+    highlightColor: "#ffffff",
+    gradientAmount: 0
+  },
+  matte: {
+    color: "#a8323e",
+    opacity: 0.92,
+    intensity: 1,
+    shading: 0.8,
+    gloss: 0,
+    roughness: 1,
+    highlightColor: "#ffffff",
+    gradientAmount: 0
+  },
+  tint: {
+    color: "#ff6b81",
+    opacity: 0.4,
+    intensity: 1,
+    shading: 0.9,
+    gloss: 0.1,
+    roughness: 0.7,
+    highlightColor: "#ffffff",
+    gradientAmount: 0
+  },
+  metallic: {
+    color: "#b5485a",
+    opacity: 0.9,
+    intensity: 1,
+    shading: 0.5,
+    gloss: 1,
+    roughness: 0.3,
+    highlightColor: "#f3c46b",
+    gradientAmount: 0
+  },
+  gradient: {
+    color: "#d6336c",
+    opacity: 0.8,
+    intensity: 1,
+    shading: 0.6,
+    gloss: 0.3,
+    roughness: 0.5,
+    highlightColor: "#ffffff",
+    gradientColor: "#f9c2cf",
+    gradientAmount: 0.85,
+    gradientDirection: "outward"
+  }
+}, W = (e) => typeof e == "string" && Y.includes(e), i = (e, t, a, r) => typeof e == "number" && Number.isFinite(e) ? Math.min(a, Math.max(t, e)) : r, se = (e, t) => typeof e == "number" && Number.isFinite(e) ? e : t, S = (e, t) => typeof e == "string" && e.trim() ? e : t, _ = (e, t) => typeof e == "boolean" ? e : t, B = (e, t, a) => typeof t == "string" && e.includes(t) ? t : a, H = (e = {}) => {
+  const t = W(e.preset) ? e.preset : "custom", a = {
+    ...ie,
+    ...t === "custom" ? {} : N[t]
+  }, r = Object.fromEntries(
+    Object.entries(e).filter(([, s]) => s !== void 0)
+  ), o = { ...a, ...r };
+  return {
+    preset: t,
+    maskMode: o.maskMode === "outer-lips" ? "outer-lips" : "outer-and-inner-lips",
+    colorMode: B(re, o.colorMode, a.colorMode),
+    color: S(o.color, a.color),
+    opacity: i(o.opacity, 0, 1, a.opacity),
+    intensity: i(o.intensity, 0, 1, a.intensity),
+    shading: i(o.shading, 0, 1, a.shading),
+    gloss: i(o.gloss, 0, 1, a.gloss),
+    roughness: i(o.roughness, 0, 1, a.roughness),
+    highlightColor: S(o.highlightColor, a.highlightColor),
+    gradientColor: S(o.gradientColor, a.gradientColor),
+    gradientAmount: i(o.gradientAmount, 0, 1, a.gradientAmount),
+    gradientDirection: B(
+      le,
+      o.gradientDirection,
+      a.gradientDirection
+    ),
+    edgeSoftness: i(o.edgeSoftness, 0, 1, a.edgeSoftness),
+    innerLipColor: S(o.innerLipColor, a.innerLipColor),
+    innerLipAmount: i(o.innerLipAmount, 0, 1, a.innerLipAmount),
+    innerLipWidth: i(o.innerLipWidth, 0, 1, a.innerLipWidth),
+    splitLips: _(o.splitLips, a.splitLips),
+    lowerLipColor: S(o.lowerLipColor, a.lowerLipColor),
+    lowerLipOpacity: i(o.lowerLipOpacity, 0, 1, a.lowerLipOpacity),
+    textureScaleX: i(o.textureScaleX, 0.05, 20, a.textureScaleX),
+    textureScaleY: i(o.textureScaleY, 0.05, 20, a.textureScaleY),
+    textureOffsetX: i(o.textureOffsetX, -2, 2, a.textureOffsetX),
+    textureOffsetY: i(o.textureOffsetY, -2, 2, a.textureOffsetY),
+    textureRotation: se(o.textureRotation, a.textureRotation),
+    textureFlipX: _(o.textureFlipX, a.textureFlipX),
+    textureFlipY: _(o.textureFlipY, a.textureFlipY)
+  };
+}, Ue = (e, t) => {
+  const a = t.preset;
+  if (!(a !== void 0 && a !== e.preset && W(a))) return H({ ...e, ...t });
+  const o = Object.fromEntries(
+    Object.entries(t).filter(
+      ([s, c]) => c !== void 0 && c !== e[s]
+    )
+  );
+  return H({
+    ...e,
+    ...N[a],
+    ...o,
+    preset: a
+  });
+}, p = { min: 0, max: 1, step: 0.01 }, De = [
+  {
+    key: "preset",
+    label: "Preset",
+    type: "select",
+    options: [
+      { label: "Custom", value: "custom" },
+      ...Y.map((e) => ({
+        label: e[0].toUpperCase() + e.slice(1),
+        value: e
+      }))
+    ]
+  },
+  {
+    key: "maskMode",
+    label: "Mask mode",
+    type: "select",
+    options: [
+      { label: "Outer + inner lips (mouth cut out)", value: "outer-and-inner-lips" },
+      { label: "Outer lips (mouth included)", value: "outer-lips" }
+    ]
+  },
+  {
+    key: "colorMode",
+    label: "Color mode",
+    type: "select",
+    options: [
+      { label: "Design texture", value: "texture" },
+      { label: "Procedural (solid / gradient)", value: "solid" }
+    ]
+  },
+  { key: "color", label: "Tint color", type: "color" },
+  { key: "opacity", label: "Opacity", type: "number", ...p },
+  { key: "intensity", label: "Tint intensity", type: "number", ...p },
+  { key: "shading", label: "Skin shading", type: "number", ...p },
+  { key: "gloss", label: "Gloss", type: "number", ...p },
+  { key: "roughness", label: "Roughness", type: "number", ...p },
+  { key: "highlightColor", label: "Highlight color", type: "color" },
+  { key: "gradientColor", label: "Gradient color", type: "color" },
+  { key: "gradientAmount", label: "Gradient amount", type: "number", ...p },
+  {
+    key: "gradientDirection",
+    label: "Gradient direction",
+    type: "select",
+    options: [
+      { label: "Mouth line → outer edge", value: "outward" },
+      { label: "Bottom → top", value: "vertical" },
+      { label: "Left → right", value: "horizontal" }
+    ]
+  },
+  { key: "edgeSoftness", label: "Edge softness", type: "number", ...p },
+  { key: "innerLipColor", label: "Inner lip color", type: "color" },
+  { key: "innerLipAmount", label: "Inner lip amount", type: "number", ...p },
+  { key: "innerLipWidth", label: "Inner lip width", type: "number", ...p },
+  { key: "splitLips", label: "Separate lower lip", type: "boolean" },
+  { key: "lowerLipColor", label: "Lower lip color", type: "color" },
+  { key: "lowerLipOpacity", label: "Lower lip opacity", type: "number", ...p },
+  { key: "textureScaleX", label: "Texture scale X", type: "number", min: 0.1, max: 10, step: 0.05 },
+  { key: "textureScaleY", label: "Texture scale Y", type: "number", min: 0.1, max: 10, step: 0.05 },
+  { key: "textureOffsetX", label: "Texture offset X", type: "number", min: -1, max: 1, step: 0.01 },
+  { key: "textureOffsetY", label: "Texture offset Y", type: "number", min: -1, max: 1, step: 0.01 },
+  {
+    key: "textureRotation",
+    label: "Texture rotation°",
+    type: "number",
+    min: -180,
+    max: 180,
+    step: 1
+  },
+  { key: "textureFlipX", label: "Flip horizontal", type: "boolean" },
+  { key: "textureFlipY", label: "Flip vertical", type: "boolean" }
+], Ie = (e, t, a = new f.Matrix3()) => {
+  const r = (t.minU + t.maxU) / 2, o = (t.minV + t.maxV) / 2, s = t.maxU - t.minU, c = t.maxV - t.minV, v = -f.MathUtils.degToRad(e.textureRotation), h = Math.cos(v), m = Math.sin(v), b = (e.textureFlipX ? -1 : 1) / Math.max(e.textureScaleX, 1e-3), u = (e.textureFlipY ? -1 : 1) / Math.max(e.textureScaleY, 1e-3), d = b * h, x = -b * m, l = u * m, y = u * h, k = r + e.textureOffsetX * s, w = o + e.textureOffsetY * c, P = r - (d * k + x * w), L = o - (l * k + y * w);
+  return a.set(d, x, P, l, y, L, 0, 0, 1);
+}, ne = `
+  varying vec2 vUv;
+
+  void main() {
+    vUv = uv;
+    gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+  }
+`, ce = `
+  uniform sampler2D cameraTexture;
+  uniform sampler2D retouchMaskTexture;
+  uniform vec2 texelSize;
+  uniform float retouchAmount;
+  uniform float blurRadius;
+  uniform float detailPreservation;
+  uniform float blemishReduction;
+  uniform float blemishRadius;
+  uniform float previewMask;
+  uniform float protectLandmarks;
+  uniform float clipMinX;
+  uniform float clipMaxX;
+  varying vec2 vUv;
+
+  vec3 sampleCamera(vec2 uv) {
+    return texture2D(cameraTexture, clamp(uv, vec2(0.0), vec2(1.0))).rgb;
+  }
+
+  vec3 readRetouchMask(vec2 uv) {
+    vec4 mask = texture2D(retouchMaskTexture, uv);
+    float faceRegion = clamp(mask.b, 0.0, 1.0);
+    float softFaceRegion = min(mask.r, faceRegion);
+    float protectedRegion = min(mask.g, faceRegion) * protectLandmarks;
+    float hardProtectedRegion = step(0.08, protectedRegion);
+    float softRetouchRegion = softFaceRegion * (1.0 - protectedRegion);
+    float hardRetouchRegion = step(0.5, faceRegion) * (1.0 - hardProtectedRegion);
+
+    return vec3(
+      clamp(softRetouchRegion, 0.0, 1.0),
+      clamp(protectedRegion, 0.0, 1.0),
+      clamp(hardRetouchRegion, 0.0, 1.0)
+    );
+  }
+
+  float retouchCoverage(vec2 uv) {
+    return step(0.001, readRetouchMask(uv).x);
+  }
+
+  void addMaskedBlurSample(inout vec3 color, inout float weightSum, vec2 centerUv, vec2 sampleUv, float weight) {
+    float coverage = retouchCoverage(sampleUv);
+    vec3 sampleColor = mix(sampleCamera(centerUv), sampleCamera(sampleUv), coverage);
+    color += sampleColor * weight;
+    weightSum += weight;
+  }
+
+  vec3 maskedBlurCamera(vec2 uv, float radius) {
+    vec2 r = texelSize * radius;
+    vec3 color = sampleCamera(uv) * 0.2;
+    float weightSum = 0.2;
+
+    addMaskedBlurSample(color, weightSum, uv, uv + vec2(r.x, 0.0), 0.1);
+    addMaskedBlurSample(color, weightSum, uv, uv - vec2(r.x, 0.0), 0.1);
+    addMaskedBlurSample(color, weightSum, uv, uv + vec2(0.0, r.y), 0.1);
+    addMaskedBlurSample(color, weightSum, uv, uv - vec2(0.0, r.y), 0.1);
+    addMaskedBlurSample(color, weightSum, uv, uv + r, 0.075);
+    addMaskedBlurSample(color, weightSum, uv, uv - r, 0.075);
+    addMaskedBlurSample(color, weightSum, uv, uv + vec2(r.x, -r.y), 0.075);
+    addMaskedBlurSample(color, weightSum, uv, uv + vec2(-r.x, r.y), 0.075);
+    addMaskedBlurSample(color, weightSum, uv, uv + r * 2.0, 0.05);
+    addMaskedBlurSample(color, weightSum, uv, uv - r * 2.0, 0.05);
+
+    return color / max(weightSum, 0.001);
+  }
+
+  float retouchLuminance(vec3 color) {
+    return dot(color, vec3(0.299, 0.587, 0.114));
+  }
+
+  vec3 reduceBlemishes(vec3 current, vec3 source, vec3 localAverage, vec3 skinBase, float skinMask) {
+    float originalLum = retouchLuminance(source);
+    float localLum = retouchLuminance(localAverage);
+    float redness = max(source.r - max(source.g, source.b), 0.0);
+    float localRedness = max(localAverage.r - max(localAverage.g, localAverage.b), 0.0);
+    float excessRedness = max(redness - localRedness * 0.72, 0.0);
+    float darkSpot = max(localLum - originalLum, 0.0);
+    float contrast = length(source - localAverage);
+    float candidate =
+      smoothstep(0.012, 0.09, excessRedness) +
+      smoothstep(0.018, 0.13, darkSpot) +
+      smoothstep(0.03, 0.16, contrast);
+    float blemishMask = clamp(candidate * 0.72, 0.0, 1.0) * skinMask * blemishReduction;
+
+    vec3 chromaReduced = vec3(
+      mix(current.r, min(current.r, localAverage.r * 1.04), blemishMask),
+      mix(current.g, max(current.g, localAverage.g * 0.98), 0.35 * blemishMask),
+      mix(current.b, max(current.b, localAverage.b * 0.98), 0.35 * blemishMask)
+    );
+    vec3 texture = source - localAverage;
+    vec3 repaired = clamp(skinBase + texture * detailPreservation * 0.18, 0.0, 1.0);
+
+    return mix(chromaReduced, repaired, min(blemishMask * 1.15, 1.0));
+  }
+
+  void main() {
+    if (vUv.x < clipMinX || vUv.x > clipMaxX) discard;
+
+    vec3 original = sampleCamera(vUv);
+    vec3 masks = readRetouchMask(vUv);
+    float faceAlpha = max(max(masks.x, masks.y), masks.z);
+
+    if (previewMask > 0.5) {
+      float sharpPreview = 1.0 - step(0.001, retouchAmount + blurRadius);
+      float retouchPreview = mix(masks.x, masks.z, sharpPreview);
+      float protectedPreview = mix(masks.y, step(0.08, masks.y), sharpPreview);
+      vec3 facePreview = vec3(retouchPreview, 0.08, 0.08);
+      vec3 featurePreview = vec3(0.05, protectedPreview, 0.1);
+      vec3 maskPreview = max(facePreview, featurePreview);
+      vec3 debugColor = mix(original * 0.18, maskPreview, max(retouchPreview, protectedPreview));
+      gl_FragColor = vec4(debugColor, faceAlpha);
+      #include <colorspace_fragment>
+      return;
+    }
+
+    float effectiveBlurRadius = min(blurRadius, 12.0);
+    vec3 smallBlur = maskedBlurCamera(vUv, max(0.0, effectiveBlurRadius * 0.45));
+    vec3 largeBlur = maskedBlurCamera(vUv, max(0.0, effectiveBlurRadius));
+    vec3 detail = original - smallBlur;
+    float detailAmount = mix(detailPreservation, 0.9, masks.y);
+    vec3 smoothed = clamp(largeBlur + detail * detailAmount, 0.0, 1.0);
+    vec3 color = mix(original, smoothed, min(retouchAmount, 0.72) * masks.x);
+    vec3 blemishAverage = maskedBlurCamera(vUv, max(1.0, blemishRadius));
+    color = reduceBlemishes(color, original, blemishAverage, smoothed, masks.x);
+    gl_FragColor = vec4(color, faceAlpha);
+    #include <colorspace_fragment>
+  }
+`, ue = ({
+  retouchMask: e,
+  retouchAmount: t,
+  blurRadius: a,
+  detailPreservation: r = 0.62,
+  blemishReduction: o = 0.35,
+  blemishRadius: s = 3,
+  previewMask: c,
+  protectLandmarks: v,
+  clipMinX: h = 0,
+  clipMaxX: m = 1,
+  renderOrder: b = -1e3
+}) => {
+  const { camera: u, size: d } = Z(), x = J(), l = R(
+    () => ({
+      cameraTexture: { value: null },
+      retouchMaskTexture: { value: null },
+      texelSize: { value: new f.Vector2(1 / 1280, 1 / 720) },
+      retouchAmount: { value: 0 },
+      blurRadius: { value: 0 },
+      detailPreservation: { value: 0 },
+      blemishReduction: { value: 0 },
+      blemishRadius: { value: 0 },
+      previewMask: { value: 0 },
+      protectLandmarks: { value: 1 },
+      clipMinX: { value: 0 },
+      clipMaxX: { value: 1 }
+    }),
+    []
+  ), y = R(() => {
+    if (!u.isPerspectiveCamera)
+      return [10, 10];
+    const k = u, L = (k.position.z || 5) - -1, G = f.MathUtils.degToRad(k.fov), U = 2 * Math.tan(G / 2) * L;
+    return [U * (d.width / d.height), U];
+  }, [u, d]);
+  return q(() => {
+    l.cameraTexture.value = x ?? null, l.retouchMaskTexture.value = e, l.texelSize.value.set(1 / Math.max(d.width, 1), 1 / Math.max(d.height, 1)), l.retouchAmount.value = t, l.blurRadius.value = a, l.detailPreservation.value = r, l.blemishReduction.value = o, l.blemishRadius.value = s, l.previewMask.value = c ? 1 : 0, l.protectLandmarks.value = v ? 1 : 0, l.clipMinX.value = h, l.clipMaxX.value = m;
+  }), x ? /* @__PURE__ */ F("group", { position: [0, 0, -1], children: /* @__PURE__ */ V("mesh", { renderOrder: b, children: [
+    /* @__PURE__ */ F("planeGeometry", { args: y }),
+    /* @__PURE__ */ F(
+      "shaderMaterial",
+      {
+        uniforms: l,
+        vertexShader: ne,
+        fragmentShader: ce,
+        transparent: !0,
+        depthTest: !1,
+        depthWrite: !1,
+        toneMapped: !1
+      }
+    )
+  ] }) }) : null;
+}, me = (e) => {
+  const t = document.createElement("canvas");
+  t.width = e, t.height = e;
+  const a = t.getContext("2d", { willReadFrequently: !1 });
+  if (!a) throw new Error("Unable to create face retouch mask context");
+  const r = new f.CanvasTexture(t);
+  return r.colorSpace = f.NoColorSpace, r.minFilter = f.LinearFilter, r.magFilter = f.LinearFilter, r.generateMipmaps = !1, r.needsUpdate = !0, { canvas: t, context: a, texture: r };
+}, de = (e, t = Q, a = {}, r = 0) => {
+  const o = R(() => me(t), [t]);
+  return X(() => {
+    let s = 0;
+    const c = () => {
+      var h, m;
+      s = requestAnimationFrame(c);
+      const v = (m = (h = e == null ? void 0 : e.detectionResults) == null ? void 0 : h.faceLandmarks) == null ? void 0 : m[r];
+      $(o.context, v, t, a), o.texture.needsUpdate = !0;
+    };
+    return c(), () => {
+      cancelAnimationFrame(s);
+    };
+  }, [r, e, o.context, o.texture, a, t]), X(() => () => {
+    o.texture.dispose();
+  }, [o.texture]), { canvas: o.canvas, texture: o.texture };
+}, Xe = [
+  { key: "skinSmoothing", label: "Skin smoothing", type: "number", min: 0, max: 1, step: 0.01 },
+  { key: "skinRealism", label: "Skin realism", type: "number", min: 0, max: 1, step: 0.01 },
+  {
+    key: "blemishReduction",
+    label: "Blemish reduction",
+    type: "number",
+    min: 0,
+    max: 1,
+    step: 0.01
+  },
+  { key: "previewMask", label: "Preview mask", type: "boolean" }
+], pe = (e) => {
+  const t = Number(e);
+  return Number.isFinite(t) ? Math.max(0, Math.round(t)) : 0;
+}, he = (e, t) => {
+  const a = Number(t);
+  return Number.isFinite(a) ? Math.max(e + 1, Math.round(a)) : e + 1;
+}, E = {
+  skinSmoothing: 0.55,
+  skinRealism: 0.62,
+  blemishReduction: 0.35,
+  previewMask: !1
+}, C = {
+  blurRadius: 8,
+  blemishRadius: 3,
+  protectLandmarks: !0,
+  foreheadCoverage: !0
+}, O = (e, t) => {
+  const a = Number(e);
+  return Number.isFinite(a) ? Math.min(1, Math.max(0, a)) : t;
+}, z = (e = {}) => ({
+  skinSmoothing: O(e.skinSmoothing, E.skinSmoothing),
+  skinRealism: O(e.skinRealism, E.skinRealism),
+  blemishReduction: O(e.blemishReduction, E.blemishReduction),
+  previewMask: typeof e.previewMask == "boolean" ? e.previewMask : E.previewMask
+}), Be = (e, t) => z({ ...e, ...t }), He = ({
+  faceIndex: e,
+  numFaces: t,
+  skinSmoothing: a,
+  skinRealism: r,
+  blemishReduction: o,
+  previewMask: s,
+  clipMinX: c = 0,
+  clipMaxX: v = 1,
+  renderOrder: h
+}) => {
+  const m = pe(e), b = he(m, t), u = z({
+    skinSmoothing: a,
+    skinRealism: r,
+    blemishReduction: o,
+    previewMask: s
+  }), d = R(() => ({ numFaces: b }), [b]), { node: x } = K(
+    j.FACE_TRACKER,
+    d
+  ), l = R(
+    () => ({ foreheadCoverage: C.foreheadCoverage }),
+    []
+  ), y = de(x, void 0, l, m);
+  return /* @__PURE__ */ F(
+    ue,
+    {
+      retouchMask: y.texture,
+      retouchAmount: u.skinSmoothing,
+      blurRadius: C.blurRadius,
+      detailPreservation: u.skinRealism,
+      blemishReduction: u.blemishReduction,
+      blemishRadius: C.blemishRadius,
+      previewMask: u.previewMask,
+      protectLandmarks: C.protectLandmarks,
+      clipMinX: c,
+      clipMaxX: v,
+      renderOrder: h
+    }
+  );
+};
+export {
+  ie as D,
+  Me as F,
+  te as I,
+  le as L,
+  H as a,
+  oe as b,
+  Ie as c,
+  ae as d,
+  _e as e,
+  Fe as f,
+  Le as g,
+  Te as h,
+  re as i,
+  N as j,
+  Y as k,
+  De as l,
+  Ee as m,
+  W as n,
+  Ue as o,
+  Pe as p,
+  ee as q,
+  Oe as r,
+  Ce as s,
+  we as t,
+  E as u,
+  Xe as v,
+  He as w,
+  Be as x,
+  z as y,
+  Ae as z
+};