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

package/dist/hand/handCutout.d.ts

@@ -0,0 +1,23 @@
+import { TrackerPoint } from '../types/common';
+/** Triangles per hand: palm fan, two per bone, a circle per joint, the forearm quad and cap. */
+/**
+ * Frame priority of `HandCutout`'s silhouette update: before the made-up
+ * camera's pass (`MADE_UP_CAMERA_FRAME_PRIORITY`, -0.3), so the made-up feed
+ * (FaceInset, FaceMorph textures, a face swap's map) cuts this frame's hands,
+ * not the last frame's. Negative: it does not take over R3F's render loop.
+ */
+export declare const HAND_CUTOUT_FRAME_PRIORITY = -0.5;
+export declare const HAND_CUTOUT_TRIANGLES: number;
+export type HandCutoutOptions = {
+    /** Width multiplier for the fingers and palm. Default 1. */
+    inflate?: number;
+    /** Also cut out the forearm past the wrist (its length in hand sizes, 0 = none). Default 1.4. */
+    forearm?: number;
+};
+/**
+ * Writes one hand's silhouette into `out` (xy per vertex, 3 vertices per
+ * triangle) from its 21 joints in tracker space; `aspect` is the viewport's
+ * width / height (widths are round on screen). Returns the vertex count
+ * written. Unused room is left untouched.
+ */
+export declare const writeHandCutout: (points: ArrayLike<TrackerPoint>, aspect: number, { inflate, forearm }: HandCutoutOptions, out: Float32Array, at?: number) => number;

package/dist/hand/handCutoutRegistry.d.ts

@@ -0,0 +1,7 @@
+import type * as THREE from "three";
+/** Adds a cut-out's geometry for `scene`; returns the removal. */
+export declare const registerHandCutoutShape: (scene: THREE.Object3D, geometry: THREE.BufferGeometry) => (() => void);
+/** The cut-out geometries registered for `scene` (empty when none). */
+export declare const getHandCutoutShapes: (scene: THREE.Object3D) => ReadonlySet<THREE.BufferGeometry>;
+/** Whether any cut-out for `scene` draws a triangle this frame. */
+export declare const hasHandCutoutShapes: (scene: THREE.Object3D) => boolean;

package/dist/hand/handGestures.d.ts

@@ -0,0 +1,524 @@
+import { TrackerPoint } from '../types/common';
+import { Handedness } from '../types/hand-tracking';
+import { HandJointName } from './handPose';
+import { HandRigBinding } from './handRigSolver';
+import * as THREE from "three";
+/** The five digits, thumb first. */
+export type HandDigit = "thumb" | "index" | "middle" | "ring" | "pinky";
+export declare const HAND_DIGITS: readonly HandDigit[];
+/**
+ * A hand's shape from its 21 world joints (`HandPose.world`: centimetres,
+ * +X screen right, +Y up, +Z toward the viewer). Orientation-independent
+ * except `thumbDirection`, which is relative to the screen's up.
+ */
+export type HandShape = {
+    /** Digit straightened out. */
+    extended: Record<HandDigit, boolean>;
+    /** 0 = straight, 1 = fully curled (sum of the joint bends, normalised). */
+    curl: Record<HandDigit, number>;
+    /** Number of extended digits, thumb included. */
+    count: number;
+    /** Which way an extended thumb points on screen; `"side"` otherwise. */
+    thumbDirection: "up" | "down" | "side";
+    /** Thumb tip and index tip touch (an OK sign, a pinch). */
+    thumbIndexTouch: boolean;
+};
+/**
+ * The classifier's default thresholds. Read-only: tune per call with
+ * `analyzeHandShape(world, { limits })` or a hook's `limits` option.
+ */
+export declare const HAND_SHAPE_LIMITS: Readonly<{
+    /** A finger is extended when its PIP + DIP bends stay under this (radians, ~55°). */
+    fingerStraight: number;
+    /** … and its MCP bend stays under this (~70°, a finger folded at the knuckle is not up). */
+    fingerKnuckle: number;
+    /** The thumb is extended when its MCP + IP bends stay under this (~60°) … */
+    thumbStraight: number;
+    /** … and its tip is at least this many palm widths from the index MCP (tucked thumbs sit closer). */
+    thumbReach: 0.75;
+    /** |cos| of the thumb's angle to screen-up for "up" / "down" (~45°). */
+    thumbVertical: number;
+    /** Thumb and index tips touch within this many palm lengths (~1.75 cm). */
+    touch: 0.2;
+    /** Full curl, radians summed over a finger's three bends (normalises `curl`). */
+    fullCurl: number;
+}>;
+/** The classifier thresholds (see `HAND_SHAPE_LIMITS` for each one's meaning). */
+export type HandShapeLimits = Record<keyof typeof HAND_SHAPE_LIMITS, number>;
+export type AnalyzeHandShapeOptions = {
+    /** Thresholds to override (the rest keep `HAND_SHAPE_LIMITS`). */
+    limits?: Partial<HandShapeLimits>;
+};
+/**
+ * Reads extended digits, curl, count, thumb direction and thumb–index touch
+ * from a hand's world joints. Pure; needs all 21 joints.
+ */
+export declare const analyzeHandShape: (world: readonly TrackerPoint[], { limits }?: AnalyzeHandShapeOptions) => HandShape;
+/** What a gesture requires of a `HandShape`; omitted fields are "any". */
+export type HandGestureRule = {
+    /** `true` = must be extended, `false` = must be folded. */
+    digits?: Partial<Record<HandDigit, boolean>>;
+    /** Exact number of extended digits (thumb included). */
+    count?: number;
+    thumbDirection?: "up" | "down";
+    thumbIndexTouch?: boolean;
+};
+/**
+ * How to draw a gesture on the hint hand. `clip` names an authored pose (a
+ * model animation, see `applyHandHintPose`); the other fields (values 0..1)
+ * pose the hand procedurally, for models without that clip.
+ */
+export type HandHintPose = {
+    /**
+     * Authored pose: the name of a single-key animation clip on the model
+     * (`hand-v1.glb` ships one per pose). Used when the clip is passed in;
+     * otherwise the procedural fields below are used.
+     */
+    clip?: string;
+    /**
+     * Turn about the fingers' axis before showing, in degrees: 0 = palm to
+     * the viewer, 180 = the back of the hand, in between brings the thumb side
+     * round toward the viewer (an OK sign reads from ~125°).
+     */
+    yaw?: number;
+    /**
+     * Then turn in the screen plane, degrees counter-clockwise (after `yaw`):
+     * a call-me sign reads held sideways, thumb up and pinky down (~100°).
+     */
+    roll?: number;
+    /** Curl per digit; omitted = 0 (straight). */
+    curl?: Partial<Record<HandDigit, number>>;
+    /** Fan the fingers apart (0 = together, 1 = wide). */
+    spread?: number;
+    /** Swing the thumb across the palm (0 = out to the side, 1 = over the fingers). */
+    thumbTuck?: number;
+    /** Turn the whole hand in the screen plane so the extended thumb points this way. */
+    aimThumb?: "up" | "down";
+    /**
+     * Put the thumb tip HERE (IK on the thumb's three bones, after the fingers
+     * are posed): a joint of the posed hand plus an `offset` in palm lengths
+     * along [toward the thumb side, toward the fingers, out of the palm]. How a
+     * fist wraps the thumb over the curled fingers, or a peace sign holds the
+     * ring finger down. Replaces `curl.thumb` / `thumbTuck` as the thumb's pose.
+     */
+    thumbTo?: {
+        joint: HandJointName;
+        offset?: [number, number, number];
+    };
+    /**
+     * The digits drawn brighter on the hint. Default: picked from the gesture
+     * (its extended digits, thumb + index for a touch, the thumb for a thumb
+     * direction).
+     */
+    highlight?: readonly HandDigit[];
+};
+/**
+ * Your own test of a hand shape (any logic, e.g. curl amounts). `side` is the
+ * person's hand it is reading.
+ */
+export type HandGestureMatch = (shape: HandShape, side?: Handedness) => boolean;
+/**
+ * A gesture: its default copy, how it is detected (`rule`, or `match` for
+ * logic a rule cannot express; with both, both must pass) and how the hint
+ * hand shows it. Make your own with `defineHandGesture`.
+ */
+export type HandGestureDefinition = {
+    /** Default instruction copy. */
+    label: string;
+    rule?: HandGestureRule;
+    match?: HandGestureMatch;
+    hint: HandHintPose;
+};
+/**
+ * Anything that names a gesture to detect: a built-in name, a rule, a match
+ * function or a full definition.
+ */
+export type HandGestureSpec = HandGestureName | HandGestureRule | HandGestureMatch | HandGestureDefinition;
+/**
+ * Checks and returns your own gesture definition (it needs a `rule` or a
+ * `match`). Pass it anywhere a gesture name goes.
+ *
+ * ```ts
+ * const shaka = defineHandGesture({
+ *   label: "Hang loose",
+ *   rule: { digits: { thumb: true, index: false, middle: false, ring: false, pinky: true } },
+ *   hint: { clip: "callMe" },
+ * });
+ * ```
+ */
+export declare const defineHandGesture: <T extends HandGestureDefinition>(definition: T) => T;
+/**
+ * The instruction vocabulary. Counts (`one` … `five`) accept any digits as
+ * long as that many are up; named shapes require specific digits. The middle
+ * finger shown alone is deliberately absent (offensive in most places).
+ */
+export declare const HAND_GESTURES: {
+    readonly palm: {
+        readonly label: "Show your palm";
+        readonly rule: {
+            readonly count: 5;
+        };
+        readonly hint: {
+            readonly clip: "palm";
+            readonly spread: 0.8;
+            readonly thumbTuck: 0;
+        };
+    };
+    readonly fist: {
+        readonly label: "Make a fist";
+        readonly rule: {
+            readonly digits: {
+                readonly index: false;
+                readonly middle: false;
+                readonly ring: false;
+                readonly pinky: false;
+                readonly thumb: false;
+            };
+        };
+        readonly hint: {
+            readonly clip: "fist";
+            readonly curl: {
+                middle: number;
+                index: number;
+                thumb: number;
+                ring: number;
+                pinky: number;
+            };
+            readonly thumbTuck: 1;
+            readonly thumbTo: {
+                readonly joint: "indexPip";
+                readonly offset: [-0.15, -0.1, 0.13];
+            };
+        };
+    };
+    readonly peace: {
+        readonly label: "Show a peace sign";
+        readonly rule: {
+            readonly digits: {
+                readonly index: true;
+                readonly middle: true;
+                readonly ring: false;
+                readonly pinky: false;
+            };
+        };
+        readonly hint: {
+            readonly clip: "peace";
+            readonly curl: {
+                middle: number;
+                index: number;
+                thumb: number;
+                ring: number;
+                pinky: number;
+            };
+            readonly spread: 1;
+            readonly thumbTuck: 1;
+            readonly thumbTo: {
+                readonly joint: "ringPip";
+                readonly offset: [0, -0.08, 0.12];
+            };
+        };
+    };
+    readonly thumbUp: {
+        readonly label: "Give a thumbs up";
+        readonly rule: {
+            readonly digits: {
+                readonly index: false;
+                readonly middle: false;
+                readonly ring: false;
+                readonly pinky: false;
+                readonly thumb: true;
+            };
+            readonly thumbDirection: "up";
+        };
+        readonly hint: {
+            readonly clip: "thumbUp";
+            readonly curl: {
+                middle: number;
+                index: number;
+                thumb: number;
+                ring: number;
+                pinky: number;
+            };
+            readonly thumbTuck: 0;
+            readonly aimThumb: "up";
+        };
+    };
+    readonly thumbDown: {
+        readonly label: "Give a thumbs down";
+        readonly rule: {
+            readonly digits: {
+                readonly index: false;
+                readonly middle: false;
+                readonly ring: false;
+                readonly pinky: false;
+                readonly thumb: true;
+            };
+            readonly thumbDirection: "down";
+        };
+        readonly hint: {
+            readonly clip: "thumbUp";
+            readonly curl: {
+                middle: number;
+                index: number;
+                thumb: number;
+                ring: number;
+                pinky: number;
+            };
+            readonly thumbTuck: 0;
+            readonly aimThumb: "down";
+        };
+    };
+    readonly point: {
+        readonly label: "Point your index finger";
+        readonly rule: {
+            readonly digits: {
+                readonly index: true;
+                readonly middle: false;
+                readonly ring: false;
+                readonly pinky: false;
+            };
+        };
+        readonly hint: {
+            readonly clip: "one";
+            readonly curl: {
+                middle: number;
+                index: number;
+                thumb: number;
+                ring: number;
+                pinky: number;
+            };
+            readonly thumbTuck: 0.6;
+            readonly thumbTo: {
+                readonly joint: "middlePip";
+                readonly offset: [0.1, -0.1, 0.1];
+            };
+        };
+    };
+    readonly one: {
+        readonly label: "Show 1 finger";
+        readonly rule: {
+            readonly count: 1;
+        };
+        readonly hint: {
+            readonly clip: "one";
+            readonly curl: {
+                middle: number;
+                index: number;
+                thumb: number;
+                ring: number;
+                pinky: number;
+            };
+            readonly thumbTuck: 1;
+            readonly thumbTo: {
+                readonly joint: "middlePip";
+                readonly offset: [0, -0.08, 0.12];
+            };
+        };
+    };
+    readonly two: {
+        readonly label: "Show 2 fingers";
+        readonly rule: {
+            readonly count: 2;
+        };
+        readonly hint: {
+            readonly clip: "peace";
+            readonly curl: {
+                middle: number;
+                index: number;
+                thumb: number;
+                ring: number;
+                pinky: number;
+            };
+            readonly spread: 0.6;
+            readonly thumbTuck: 1;
+            readonly thumbTo: {
+                readonly joint: "ringPip";
+                readonly offset: [0, -0.08, 0.12];
+            };
+        };
+    };
+    readonly three: {
+        readonly label: "Show 3 fingers";
+        readonly rule: {
+            readonly count: 3;
+        };
+        readonly hint: {
+            readonly clip: "three";
+            readonly curl: {
+                middle: number;
+                index: number;
+                thumb: number;
+                ring: number;
+                pinky: number;
+            };
+            readonly spread: 0.6;
+            readonly thumbTuck: 1;
+            readonly thumbTo: {
+                readonly joint: "pinkyPip";
+                readonly offset: [0, -0.08, 0.12];
+            };
+        };
+    };
+    readonly four: {
+        readonly label: "Show 4 fingers";
+        readonly rule: {
+            readonly count: 4;
+        };
+        readonly hint: {
+            readonly clip: "four";
+            readonly curl: {
+                readonly thumb: 1;
+            };
+            readonly spread: 0.6;
+            readonly thumbTuck: 1;
+            readonly thumbTo: {
+                readonly joint: "ringMcp";
+                readonly offset: [0, -0.2, 0.1];
+            };
+        };
+    };
+    readonly five: {
+        readonly label: "Show 5 fingers";
+        readonly rule: {
+            readonly count: 5;
+        };
+        readonly hint: {
+            readonly clip: "palm";
+            readonly spread: 0.8;
+            readonly thumbTuck: 0;
+        };
+    };
+    readonly rock: {
+        readonly label: "Rock on";
+        readonly rule: {
+            readonly digits: {
+                readonly index: true;
+                readonly middle: false;
+                readonly ring: false;
+                readonly pinky: true;
+            };
+        };
+        readonly hint: {
+            readonly clip: "rock";
+            readonly yaw: 180;
+            readonly curl: {
+                middle: number;
+                index: number;
+                thumb: number;
+                ring: number;
+                pinky: number;
+            };
+            readonly spread: 0.8;
+            readonly thumbTuck: 1;
+            readonly thumbTo: {
+                readonly joint: "middlePip";
+                readonly offset: [-0.05, -0.08, 0.12];
+            };
+        };
+    };
+    readonly loveYou: {
+        readonly label: "Sign I love you";
+        readonly rule: {
+            readonly digits: {
+                readonly thumb: true;
+                readonly index: true;
+                readonly middle: false;
+                readonly ring: false;
+                readonly pinky: true;
+            };
+        };
+        readonly hint: {
+            readonly clip: "loveYou";
+            readonly curl: {
+                middle: number;
+                index: number;
+                thumb: number;
+                ring: number;
+                pinky: number;
+            };
+            readonly spread: 0.8;
+            readonly thumbTuck: 0;
+        };
+    };
+    readonly callMe: {
+        readonly label: "Call me";
+        readonly rule: {
+            readonly digits: {
+                readonly thumb: true;
+                readonly index: false;
+                readonly middle: false;
+                readonly ring: false;
+                readonly pinky: true;
+            };
+        };
+        readonly hint: {
+            readonly clip: "callMe";
+            readonly roll: 103;
+            readonly curl: {
+                middle: number;
+                index: number;
+                thumb: number;
+                ring: number;
+                pinky: number;
+            };
+            readonly spread: 0.8;
+            readonly thumbTuck: 0;
+        };
+    };
+    readonly ok: {
+        readonly label: "Make an OK sign";
+        readonly rule: {
+            readonly thumbIndexTouch: true;
+            readonly digits: {
+                readonly middle: true;
+                readonly ring: true;
+                readonly pinky: true;
+            };
+        };
+        readonly hint: {
+            readonly clip: "ok";
+            readonly yaw: 124;
+            readonly curl: {
+                readonly thumb: 0.3;
+                readonly index: 0.5;
+            };
+            readonly spread: 0.6;
+            readonly thumbTuck: 0.4;
+        };
+    };
+};
+export type HandGestureName = keyof typeof HAND_GESTURES;
+export declare const HAND_GESTURE_NAMES: HandGestureName[];
+/** The full definition a spec names (`undefined` for a bare rule or match function). */
+export declare const resolveHandGesture: (gesture: HandGestureSpec) => HandGestureDefinition | undefined;
+/**
+ * Whether a shape satisfies a gesture: a name from `HAND_GESTURES`, a rule, a
+ * match function or a definition. `side` is passed on to match functions.
+ */
+export declare const matchHandGesture: (shape: HandShape, gesture: HandGestureSpec, side?: Handedness) => boolean;
+/** Every named gesture a shape satisfies (several can: `two` and `peace`). */
+export declare const matchingHandGestures: (shape: HandShape) => HandGestureName[];
+/** Rig-local bone rotations, by joint name. */
+export type HandClipPose = Partial<Record<HandJointName, THREE.Quaternion>>;
+/**
+ * How far into a hint pose: one amount for the whole hand, or one per digit
+ * (to stagger the fingers). 0 = rest, 1 = the pose; up to 1.1 overshoots a
+ * little (a settle).
+ */
+export type HandHintAmount = number | ((digit: HandDigit) => number);
+/**
+ * The pose an authored clip holds: the first key of each `<joint>.quaternion`
+ * track (a glTF animation targeting the rig's joint nodes). Cached per clip.
+ */
+export declare const readHandClipPose: (clip: THREE.AnimationClip) => HandClipPose;
+/**
+ * Poses a bound rig (`bindHandRig`) into a gesture's hint at `amount`
+ * (0 = the model's rest, 1 = the full hint; or per digit, see
+ * `HandHintAmount`). With `clips` holding the hint's
+ * `clip` (e.g. the GLB's `animations`), each bone turns from its rest toward
+ * the authored pose. Otherwise the pose is built procedurally: bends about
+ * axes derived from the rig's own rest pose — flex about (bone direction ×
+ * palm normal), spread and thumb tuck about the palm normal — carried down
+ * each digit, so any contract rig works. Writes `bone.quaternion`s.
+ */
+export declare const applyHandHintPose: (binding: HandRigBinding, hint: HandHintPose, amount?: HandHintAmount, clips?: readonly THREE.AnimationClip[]) => void;

package/dist/hand/handPose.d.ts

@@ -0,0 +1,98 @@
+import { TrackerPoint } from '../types/common';
+import { Handedness } from '../types/hand-tracking';
+/**
+ * The 21 MediaPipe hand joints, in landmark order (index = MediaPipe index).
+ * CMC / MCP / PIP / DIP / IP are the knuckles from the wrist outward; the
+ * thumb has CMC, MCP, IP, tip, the fingers MCP, PIP, DIP, tip.
+ */
+export declare const HAND_JOINT_NAMES: readonly ["wrist", "thumbCmc", "thumbMcp", "thumbIp", "thumbTip", "indexMcp", "indexPip", "indexDip", "indexTip", "middleMcp", "middlePip", "middleDip", "middleTip", "ringMcp", "ringPip", "ringDip", "ringTip", "pinkyMcp", "pinkyPip", "pinkyDip", "pinkyTip"];
+export type HandJointName = (typeof HAND_JOINT_NAMES)[number];
+export declare const HAND_JOINT_INDEX: Readonly<Record<HandJointName, number>>;
+/**
+ * One tracked hand, both spaces.
+ *
+ * - `world`: 21 joints in the hand's own metric frame — CENTIMETRES, origin at
+ *   MediaPipe's hand centre (roughly the middle of the palm), three.js axes for
+ *   the feed as displayed: +X screen right, +Y up, +Z toward the viewer. This is
+ *   the true 3D shape (finger bend, palm facing), independent of distance.
+ * - `image`: the same 21 joints in tracker space (centre origin, ±1, Y up; `z`
+ *   is MediaPipe's relative depth) — what `HandTracker` has always published.
+ *   Unproject with `trackerToWorld` to place things on screen.
+ */
+export type HandPose = {
+    /** The person's anatomical hand on every source (mirrored webcam or not). */
+    handedness: Handedness;
+    /** MediaPipe's handedness confidence, 0..1. */
+    score: number;
+    world: TrackerPoint[];
+    image: TrackerPoint[];
+    /** `performance.now()` of the detection this pose came from. */
+    timestampMs: number;
+    /** True while the hand is lost and this pose is being held (see `holdMs`). */
+    held: boolean;
+};
+export type HandPoses = {
+    left: HandPose | null;
+    right: HandPose | null;
+};
+/** A raw detection before identity assignment. `handedness` is already anatomical. */
+export type HandDetection = {
+    handedness: Handedness | undefined;
+    score: number;
+    world: TrackerPoint[];
+    image: TrackerPoint[];
+};
+export type AssignHandPosesOptions = {
+    /** Keep a lost hand (marked `held`) this long before dropping it. Default 200 ms. */
+    holdMs?: number;
+    /**
+     * Below this handedness confidence a label that disagrees with where the
+     * hand was a moment ago loses to continuity. Default 0.8.
+     */
+    confidentScore?: number;
+    /**
+     * Continuity only applies while the previous pose is this recent. Default
+     * 500 ms: a hand gone longer than that is assigned by its label alone.
+     */
+    continuityMs?: number;
+};
+export declare const HAND_POSE_DEFAULT_HOLD_MS = 200;
+/**
+ * Assigns this frame's detections to a stable left / right slot.
+ *
+ * MediaPipe labels each hand independently, so it can call both hands "left",
+ * or flip one hand's label for a frame when it turns edge-on. A rig bound to
+ * that label would jump to the other hand. The rules, in order:
+ *
+ * 1. Two hands with different, confident labels: take the labels.
+ * 2. Otherwise, when both slots were seen within `continuityMs`, take the
+ *    pairing that keeps each wrist nearest to where that slot's wrist was.
+ * 3. Two hands with the same label and no history: the higher score keeps
+ *    the label, the other hand gets the other side.
+ * 4. One hand: its label, unless the label is not confident and the hand sits
+ *    where the OTHER slot's hand was a moment ago (it is that hand, mislabeled).
+ *
+ * A slot with no detection keeps its previous pose for `holdMs` (marked
+ * `held`), then becomes `null`. Pure: pass the previous result back in.
+ */
+export declare const assignHandPoses: (detections: readonly HandDetection[], previous: HandPoses, nowMs: number, { holdMs, confidentScore, continuityMs, }?: AssignHandPosesOptions) => HandPoses;
+/**
+ * MediaPipe's hand landmarker labels the hand AS IT APPEARS in the frame it
+ * is given (measured on the SDK's `hand_tracking.task`: an unmirrored right
+ * hand reads "Right", the same frame flipped reads "Left" — not the mirrored-
+ * selfie assumption some MediaPipe docs describe). The SDK analyzes the feed as
+ * displayed: straight for the rear camera, images and video (labels are
+ * anatomical), mirrored for the front webcam (labels are swapped). The same
+ * rule as every MediaPipe side (`personSide`, GROUNDING "Left and right").
+ */
+export declare const anatomicalHandedness: (label: string | undefined, feedMirrored: boolean) => Handedness | undefined;
+/**
+ * MediaPipe world landmark (metres, origin at the hand centre, image axes:
+ * +X right, +Y down, +Z away from the camera) → SDK hand world joint
+ * (centimetres, three.js axes: +X right, +Y up, +Z toward the viewer).
+ */
+export declare const handWorldLandmarkToJoint: (landmark: {
+    x: number;
+    y: number;
+    z: number;
+}, target?: TrackerPoint) => TrackerPoint;