@vincentt-xr/sdk 2.0.0-alpha.1 → 2.0.0-alpha.3

package/dist/FaceRetouch-DF5UsOsZ.js

@@ -0,0 +1,551 @@
+import { g as p, h as _, i as w, j as A, F as y, e as c, f as k } from "./FaceMeshRenderer-CALA4k49.js";
+import { jsx as x, jsxs as W } from "react/jsx-runtime";
+import { useMemo as b, useEffect as P } from "react";
+import { X } from "./index-JygePOwo.js";
+import { u as I } from "./index-YMUaJU7U.js";
+import { useThree as Y, useFrame as V } from "@react-three/fiber";
+import * as g from "three";
+import { u as G } from "./selectors-twqYByYZ.js";
+const j = {
+  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
+}, ke = {
+  ...j,
+  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
+}, Me = [
+  { label: "Wireframe", value: p.wireframe },
+  { label: "Basic", value: p.basic },
+  { label: "Standard", value: p.standard },
+  { label: "Physical", value: p.physical },
+  { label: "Toon", value: p.toon },
+  { label: "Normal", value: p.normal },
+  { label: "Matcap", value: p.matcap },
+  { label: "Shader", value: p.shader }
+], Se = [
+  { label: "Original Face", value: _.originalFace },
+  { label: "Composite", value: _.composite }
+], xe = [
+  { label: "Front", value: w.front },
+  { label: "Back", value: w.back },
+  { label: "Double", value: w.double }
+], Ee = [
+  { label: "None", value: A.none },
+  { label: "UV Map 1", value: A.canonical },
+  { label: "UV Map 2", value: A.style2 }
+], we = [
+  { label: "None", value: y.none },
+  { label: "Default Mask", value: y.canonical }
+], Ae = [
+  { label: "Solid", value: k.solid },
+  { label: "Gradient", value: k.gradient },
+  { label: "Image URL", value: k.imageUrl },
+  { label: "Media URL", value: k.mediaUrl }
+], Ce = [
+  { label: "Normal", value: c.normal },
+  { label: "Add", value: c.add },
+  { label: "Subtract", value: c.subtract },
+  { label: "Multiply", value: c.multiply },
+  { label: "Screen", value: c.screen },
+  { label: "Overlay", value: c.overlay },
+  { label: "Soft Light", value: c.softLight },
+  { label: "Hard Light", value: c.hardLight },
+  { label: "Lighten", value: c.lighten },
+  { label: "Darken", value: c.darken },
+  { label: "Difference", value: c.difference },
+  { label: "Exclusion", value: c.exclusion }
+], q = `
+  varying vec2 vUv;
+
+  void main() {
+    vUv = uv;
+    gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+  }
+`, Z = `
+  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>
+  }
+`, K = ({
+  retouchMask: e,
+  retouchAmount: a,
+  blurRadius: r,
+  detailPreservation: t = 0.62,
+  blemishReduction: o = 0.35,
+  blemishRadius: l = 3,
+  previewMask: i,
+  protectLandmarks: v,
+  clipMinX: n = 0,
+  clipMaxX: d = 1,
+  renderOrder: h = -1e3
+}) => {
+  const { camera: u, size: m } = Y(), R = G(), s = b(
+    () => ({
+      cameraTexture: { value: null },
+      retouchMaskTexture: { value: null },
+      texelSize: { value: new g.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 }
+    }),
+    []
+  ), E = b(() => {
+    if (!u.isPerspectiveCamera)
+      return [10, 10];
+    const T = u, D = (T.position.z || 5) - -1, N = g.MathUtils.degToRad(T.fov), F = 2 * Math.tan(N / 2) * D;
+    return [F * (m.width / m.height), F];
+  }, [u, m]);
+  return V(() => {
+    s.cameraTexture.value = R ?? null, s.retouchMaskTexture.value = e, s.texelSize.value.set(1 / Math.max(m.width, 1), 1 / Math.max(m.height, 1)), s.retouchAmount.value = a, s.blurRadius.value = r, s.detailPreservation.value = t, s.blemishReduction.value = o, s.blemishRadius.value = l, s.previewMask.value = i ? 1 : 0, s.protectLandmarks.value = v ? 1 : 0, s.clipMinX.value = n, s.clipMaxX.value = d;
+  }), R ? /* @__PURE__ */ x("group", { position: [0, 0, -1], children: /* @__PURE__ */ W("mesh", { renderOrder: h, children: [
+    /* @__PURE__ */ x("planeGeometry", { args: E }),
+    /* @__PURE__ */ x(
+      "shaderMaterial",
+      {
+        uniforms: s,
+        vertexShader: q,
+        fragmentShader: Z,
+        transparent: !0,
+        depthTest: !1,
+        depthWrite: !1,
+        toneMapped: !1
+      }
+    )
+  ] }) }) : null;
+}, B = 512, J = [
+  10,
+  338,
+  297,
+  332,
+  284,
+  251,
+  389,
+  356,
+  454,
+  323,
+  361,
+  288,
+  397,
+  365,
+  379,
+  378,
+  400,
+  377,
+  152,
+  148,
+  176,
+  149,
+  150,
+  136,
+  172,
+  58,
+  132,
+  93,
+  234,
+  127,
+  162,
+  21,
+  54,
+  103,
+  67,
+  109
+], Q = [
+  33,
+  246,
+  161,
+  160,
+  159,
+  158,
+  157,
+  173,
+  133,
+  155,
+  154,
+  153,
+  145,
+  144,
+  163,
+  7
+], $ = [
+  362,
+  398,
+  384,
+  385,
+  386,
+  387,
+  388,
+  466,
+  263,
+  249,
+  390,
+  373,
+  374,
+  380,
+  381,
+  382
+], z = [
+  61,
+  146,
+  91,
+  181,
+  84,
+  17,
+  314,
+  405,
+  321,
+  375,
+  291,
+  409,
+  270,
+  269,
+  267,
+  0,
+  37,
+  39,
+  40,
+  185
+], ee = [
+  78,
+  95,
+  88,
+  178,
+  87,
+  14,
+  317,
+  402,
+  318,
+  324,
+  308,
+  415,
+  310,
+  311,
+  312,
+  13,
+  82,
+  81,
+  80,
+  191
+], ae = [70, 63, 105, 66, 107, 55, 65, 52, 53, 46], re = [336, 296, 334, 293, 300, 276, 283, 282, 295, 285], te = [
+  Q,
+  $,
+  z,
+  ee,
+  ae,
+  re
+], L = (e, a, r) => {
+  H(e, a, J, r);
+}, U = (e, a, r) => {
+  const t = f(a, 10, r), o = f(a, 103, r), l = f(a, 332, r), i = f(a, 105, r), v = f(a, 334, r);
+  if (!t || !o || !l || !i || !v) return;
+  const n = (i.y + v.y) * 0.5, d = Math.abs(l.x - o.x), h = Math.max(Math.abs(n - t.y) * 0.72, d * 0.08), u = Math.max(0, t.y - h), m = h * 0.34;
+  e.beginPath(), e.moveTo(o.x, o.y - m), e.quadraticCurveTo((o.x + t.x) * 0.5, u, t.x, u), e.quadraticCurveTo(
+    (l.x + t.x) * 0.5,
+    u,
+    l.x,
+    l.y - m
+  ), e.lineTo(v.x, n), e.quadraticCurveTo(t.x, n + h * 0.16, i.x, n), e.closePath(), e.fill();
+}, oe = (e, a, r) => {
+  te.forEach((t) => H(e, a, t, r));
+}, f = (e, a, r) => {
+  const t = e[a];
+  return t ? {
+    x: t.x * r,
+    y: t.y * r
+  } : null;
+}, H = (e, a, r, t) => {
+  const o = f(a, r[0], t);
+  if (o) {
+    e.beginPath(), e.moveTo(o.x, o.y);
+    for (let l = 1; l < r.length; l += 1) {
+      const i = f(a, r[l], t);
+      i && e.lineTo(i.x, i.y);
+    }
+    e.closePath(), e.fill();
+  }
+}, le = (e, a, r = B, t = {}) => {
+  e.clearRect(0, 0, r, r), a != null && a.length && (e.save(), e.globalCompositeOperation = "lighter", e.fillStyle = "rgb(0, 0, 255)", L(e, a, r), t.foreheadCoverage && U(e, a, r), e.restore(), e.save(), e.globalCompositeOperation = "lighter", e.filter = "blur(8px)", e.fillStyle = "rgb(255, 0, 0)", L(e, a, r), t.foreheadCoverage && U(e, a, r), e.restore(), e.save(), e.globalCompositeOperation = "lighter", e.filter = "blur(3px)", e.fillStyle = "rgb(0, 255, 0)", oe(e, a, r), e.restore());
+}, se = (e) => {
+  const a = document.createElement("canvas");
+  a.width = e, a.height = e;
+  const r = a.getContext("2d", { willReadFrequently: !1 });
+  if (!r) throw new Error("Unable to create face retouch mask context");
+  const t = new g.CanvasTexture(a);
+  return t.colorSpace = g.NoColorSpace, t.minFilter = g.LinearFilter, t.magFilter = g.LinearFilter, t.generateMipmaps = !1, t.needsUpdate = !0, { canvas: a, context: r, texture: t };
+}, ie = (e, a = B, r = {}, t = 0) => {
+  const o = b(() => se(a), [a]);
+  return P(() => {
+    let l = 0;
+    const i = () => {
+      var n, d;
+      l = requestAnimationFrame(i);
+      const v = (d = (n = e == null ? void 0 : e.detectionResults) == null ? void 0 : n.faceLandmarks) == null ? void 0 : d[t];
+      le(o.context, v, a, r), o.texture.needsUpdate = !0;
+    };
+    return i(), () => {
+      cancelAnimationFrame(l);
+    };
+  }, [t, e, o.context, o.texture, r, a]), P(() => () => {
+    o.texture.dispose();
+  }, [o.texture]), { canvas: o.canvas, texture: o.texture };
+}, Te = [
+  { 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" }
+], ue = (e) => {
+  const a = Number(e);
+  return Number.isFinite(a) ? Math.max(0, Math.round(a)) : 0;
+}, ce = (e, a) => {
+  const r = Number(a);
+  return Number.isFinite(r) ? Math.max(e + 1, Math.round(r)) : e + 1;
+}, M = {
+  skinSmoothing: 0.55,
+  skinRealism: 0.62,
+  blemishReduction: 0.35,
+  previewMask: !1
+}, S = {
+  blurRadius: 8,
+  blemishRadius: 3,
+  protectLandmarks: !0,
+  foreheadCoverage: !0
+}, C = (e, a) => {
+  const r = Number(e);
+  return Number.isFinite(r) ? Math.min(1, Math.max(0, r)) : a;
+}, O = (e = {}) => ({
+  skinSmoothing: C(e.skinSmoothing, M.skinSmoothing),
+  skinRealism: C(e.skinRealism, M.skinRealism),
+  blemishReduction: C(e.blemishReduction, M.blemishReduction),
+  previewMask: typeof e.previewMask == "boolean" ? e.previewMask : M.previewMask
+}), Fe = (e, a) => O({ ...e, ...a }), _e = ({
+  faceIndex: e,
+  numFaces: a,
+  skinSmoothing: r,
+  skinRealism: t,
+  blemishReduction: o,
+  previewMask: l,
+  clipMinX: i = 0,
+  clipMaxX: v = 1,
+  renderOrder: n
+}) => {
+  const d = ue(e), h = ce(d, a), u = O({
+    skinSmoothing: r,
+    skinRealism: t,
+    blemishReduction: o,
+    previewMask: l
+  }), m = b(() => ({ numFaces: h }), [h]), { node: R } = I(
+    X.FACE_TRACKER,
+    m
+  ), s = b(
+    () => ({ foreheadCoverage: S.foreheadCoverage }),
+    []
+  ), E = ie(R, void 0, s, d);
+  return /* @__PURE__ */ x(
+    K,
+    {
+      retouchMask: E.texture,
+      retouchAmount: u.skinSmoothing,
+      blurRadius: S.blurRadius,
+      detailPreservation: u.skinRealism,
+      blemishReduction: u.blemishReduction,
+      blemishRadius: S.blemishRadius,
+      previewMask: u.previewMask,
+      protectLandmarks: S.protectLandmarks,
+      clipMinX: i,
+      clipMaxX: v,
+      renderOrder: n
+    }
+  );
+};
+export {
+  j as D,
+  ke as F,
+  xe as a,
+  we as b,
+  Ce as c,
+  M as d,
+  Te as e,
+  _e as f,
+  Ae as g,
+  Me as m,
+  Fe as p,
+  O as r,
+  Se as s,
+  Ee as t
+};

package/dist/audio/AudioEngine.d.ts

@@ -4,7 +4,7 @@
  *
  * 1. Gesture-started audio is BLOCKED. Audio kicked off from a camera-detected
  *    gesture (a peace sign to start) is not a user-input event, so iOS autoplay
- *    policy blocks it. The fix is IG/Snap-style: run muted by default (muted
+ *    policy blocks it. The fix is app-style: run muted by default (muted
  *    autoplay is allowed un-gestured) and let the tap that unmutes be the real
  *    gesture that unlocks the pipeline (prime each element with a muted
  *    play->pause on that tap).
@@ -52,6 +52,8 @@ export declare class AudioEngine {
     private muted;
     private readonly listeners;
     private music;
+    private musicUrl;
+    private musicReady;
     private musicWanted;
     private readonly pools;
     /** Last play time per SFX URL, for the coalesce window. */

package/dist/audio/AudioPlayer.d.ts

@@ -0,0 +1,29 @@
+export type AudioPlayMode = "once" | "loop" | "infinite";
+export interface AudioPlayerHandle {
+    play: () => Promise<void>;
+    pause: () => void;
+    stop: () => void;
+    readonly current: HTMLAudioElement | null;
+}
+export interface AudioPlayerProps {
+    src: string;
+    playMode?: AudioPlayMode;
+    /** Total number of plays in `loop` mode. Values below 1 become 1. */
+    loopCount?: number;
+    autoplay?: boolean;
+    muted?: boolean;
+    /** Volume from 0 through 100. Values are clamped. */
+    volume?: number;
+    preload?: "none" | "metadata" | "auto";
+    onReady?: () => void;
+    onPlay?: () => void;
+    onPause?: () => void;
+    onEnded?: () => void;
+    onError?: (error: Error) => void;
+}
+/**
+ * Headless, declarative audio player with timeline-friendly playback
+ * properties. It renders only a hidden HTML audio element; build any visible
+ * controls with the imperative ref or application state.
+ */
+export declare const AudioPlayer: import('react').ForwardRefExoticComponent<AudioPlayerProps & import('react').RefAttributes<AudioPlayerHandle>>;

package/dist/audio/AudioPlayerLogic.d.ts

@@ -0,0 +1,4 @@
+import { AudioPlayMode } from './AudioPlayer';
+export type AudioEndedAction = "replay" | "ended";
+export declare const resolveAudioEndedAction: (playMode: AudioPlayMode, completedPlays: number, loopCount: number) => AudioEndedAction;
+export declare const shouldAutoplaySource: (autoplay: boolean, autoplayedSrc: string | null, src: string) => boolean;

package/dist/audio/index.d.ts

@@ -1,6 +1,8 @@
 import { AudioEngine } from './AudioEngine';
 export { AudioEngine } from './AudioEngine';
 export type { AudioEngineOptions } from './AudioEngine';
+export { AudioPlayer } from './AudioPlayer';
+export type { AudioPlayerHandle, AudioPlayerProps, AudioPlayMode } from './AudioPlayer';
 /** The process-wide default engine the free functions target. */
 export declare const audio: AudioEngine;
 /** Create + buffer the looping music element. Await in the loading gate so the

package/dist/components/Axes/index.d.ts

@@ -0,0 +1,6 @@
+import { ThreeElements } from '@react-three/fiber';
+export type AxesProps = Omit<ThreeElements["axesHelper"], "args"> & {
+    size?: number;
+};
+/** RGB orientation axes: X red, Y green, Z blue. */
+export declare const Axes: ({ size, ...props }: AxesProps) => import("react/jsx-runtime").JSX.Element;

package/dist/components/FaceMesh/FaceMeshRenderer.d.ts

@@ -0,0 +1,17 @@
+import { CanonicalFaceMeshRendererProps } from './canonical/CanonicalFaceMeshRenderer';
+import { Transform3DSettings } from '../Transform3D';
+type SerializedFaceMeshRendererProps = Required<Pick<CanonicalFaceMeshRendererProps, "faceIndex" | "baseColor" | "opacity" | "materialType" | "shaderPreset" | "textureMap" | "alphaMap" | "alphaOpacity" | "side" | "blendMode" | "blendOpacity" | "showOverlayMask" | "showMouthMask" | "showLeftEyeMask" | "showRightEyeMask" | "showNoseMask" | "showLeftEyeGeometry" | "showRightEyeGeometry" | "showMouthGeometry" | "showNoseGeometry" | "maskTextureSource" | "maskSourceUrl" | "maskColor" | "maskOpacity" | "faceTextureUrl" | "faceTextureStyle2Url" | "faceAlphaMaskUrl" | "compositeShading" | "renderOrder" | "externalScale">>;
+export type FaceMeshRendererSettings = SerializedFaceMeshRendererProps & {
+    enabled: boolean;
+    targetFps?: number;
+    externalMeshUrl?: string;
+};
+export declare const DEFAULT_FACE_MESH_TRANSFORM: Transform3DSettings;
+export declare const DEFAULT_FACE_MESH_RENDERER: FaceMeshRendererSettings;
+export declare const mapFaceMeshRendererSettingsToProps: (settings: FaceMeshRendererSettings) => CanonicalFaceMeshRendererProps;
+export declare const resolveFaceMeshRendererSettings: (current: FaceMeshRendererSettings, patch: Partial<FaceMeshRendererSettings>) => FaceMeshRendererSettings;
+export declare const FaceMeshRenderer: ({ transform, value, }: {
+    transform?: Transform3DSettings;
+    value: FaceMeshRendererSettings;
+}) => import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist/components/FaceMesh/canonical/CanonicalFaceMeshRenderer.d.ts

@@ -1,3 +1,4 @@
+import { Transform3DSettings } from '../../Transform3D';
 import { FaceWarp3DSettings } from '../../FaceWarp3D';
 import { FaceMeshAlphaMap, FaceMeshBlendMode, FaceMeshMaskTextureSource, FaceMeshMaterialType, FaceMeshShaderPreset, FaceMeshSide, FaceMeshTextureMap } from '../material/types';
 import { ParsedCanonicalMesh } from './parseCanonicalFaceModel';
@@ -14,10 +15,19 @@ export type CanonicalFaceMeshRendererProps = {
     side?: FaceMeshSide;
     blendMode?: FaceMeshBlendMode;
     blendOpacity?: number;
+    showOverlayMask?: boolean;
     showMouthMask?: boolean;
     showEyeMask?: boolean;
+    showLeftEyeMask?: boolean;
+    showRightEyeMask?: boolean;
     showNoseMask?: boolean;
+    showEyeGeometry?: boolean;
+    showLeftEyeGeometry?: boolean;
+    showRightEyeGeometry?: boolean;
+    showMouthGeometry?: boolean;
+    showNoseGeometry?: boolean;
     maskTextureSource?: FaceMeshMaskTextureSource;
+    maskSourceUrl?: string;
     maskColor?: string;
     maskOpacity?: number;
     faceTextureUrl?: string;
@@ -25,7 +35,9 @@ export type CanonicalFaceMeshRendererProps = {
     faceAlphaMaskUrl?: string;
     compositeShading?: boolean;
     faceWarp3D?: Partial<FaceWarp3DSettings>;
+    transform?: Transform3DSettings;
     renderOrder?: number;
+    externalScale?: number;
     /**
      * Pre-parsed canonical mesh. If omitted, the renderer lazily fetches
      * the default OBJ from `libConfig.sdkAssetsBaseUrl` and parses it.
@@ -36,4 +48,8 @@ export type CanonicalFaceMeshRendererProps = {
      */
     meshUrl?: string;
 };
-export declare const CanonicalFaceMeshRenderer: ({ faceIndex, baseColor, color, opacity, materialType, shaderPreset, textureMap, alphaMap, alphaOpacity, side, blendMode, blendOpacity, showMouthMask, showEyeMask, showNoseMask, maskTextureSource, maskColor, maskOpacity, faceTextureUrl, faceTextureStyle2Url, faceAlphaMaskUrl, compositeShading, faceWarp3D, renderOrder, mesh, meshUrl, }: CanonicalFaceMeshRendererProps) => import("react/jsx-runtime").JSX.Element;
+/**
+ * @deprecated Use `FaceMeshRenderer` for scene-object/editor integrations.
+ * This remains as the low-level canonical mesh renderer for existing imports.
+ */
+export declare const CanonicalFaceMeshRenderer: ({ faceIndex, baseColor, color, opacity, materialType, shaderPreset, textureMap, alphaMap, alphaOpacity, side, blendMode, blendOpacity, showOverlayMask, showMouthMask, showEyeMask, showLeftEyeMask, showRightEyeMask, showNoseMask, showEyeGeometry, showLeftEyeGeometry, showRightEyeGeometry, showMouthGeometry, showNoseGeometry, maskTextureSource, maskSourceUrl, maskColor, maskOpacity, faceTextureUrl, faceTextureStyle2Url, faceAlphaMaskUrl, compositeShading, faceWarp3D, transform, renderOrder, externalScale, mesh, meshUrl, }: CanonicalFaceMeshRendererProps) => import("react/jsx-runtime").JSX.Element;