@react-three/drei 10.7.6 → 10.8.0-alpha.1

package/external/_chunks/rolldown-runtime.mjs

@@ -0,0 +1,32 @@
+import { createRequire } from "node:module";
+
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+//#endregion
+export { __require as n, __toESM as r, __commonJSMin as t };

package/external/_chunks/vision_bundle.mjs

@@ -0,0 +1,3 @@
+import { _ as wa, a as Qa, c as Xh, d as bh, f as fh, g as vh, h as lh, i as Mh, l as Yh, m as kh, n as Hh, o as Sh, p as ja, r as Ia, s as Uo, t as Fh, u as Za, v as xh, y as yh } from "./libs/@mediapipe/tasks-vision.mjs";
+
+export { lh as FaceLandmarker, Uo as FilesetResolver };

package/external/external/index.d.mts

@@ -0,0 +1,499 @@
+import { ReactThreeFiber, ThreeElement, ThreeElements, Vector2, Vector3 } from "@react-three/fiber";
+import * as React from "react";
+import { ForwardRefExoticComponent, PropsWithoutRef, ReactNode, RefAttributes, RefObject } from "react";
+import { SplitStrategy } from "three-mesh-bvh";
+import * as THREE from "three";
+import { Color, ColorRepresentation } from "three";
+import { RenderPass } from "three/examples/jsm/postprocessing/RenderPass";
+import { ShaderPass } from "three/examples/jsm/postprocessing/ShaderPass";
+import { EffectComposer } from "three/examples/jsm/postprocessing/EffectComposer";
+import { Line2 } from "three/examples/jsm/lines/Line2.js";
+import { LineSegments2 } from "three/examples/jsm/lines/LineSegments2.js";
+import { LineMaterial, LineMaterialParameters } from "three/examples/jsm/lines/LineMaterial.js";
+import * as THREE$1 from "#three";
+import { EventDispatcher, Group, Matrix4, Mesh, MeshStandardMaterial, OrthographicCamera, PerspectiveCamera, Texture } from "#three";
+import CameraControlsImpl from "camera-controls";
+import { FaceLandmarker as FaceLandmarker$1, FaceLandmarkerOptions, FaceLandmarkerResult } from "@mediapipe/tasks-vision";
+import Hls from "hls.js";
+
+//#region src/utils/ts-utils.d.ts
+type ForwardRefComponent<P, T> = ForwardRefExoticComponent<PropsWithoutRef<P> & RefAttributes<T>>;
+type NonFunctionKeys<T> = { [K in keyof T]-?: T[K] extends Function ? never : K }[keyof T];
+type Overwrite<T, O> = Omit<T, NonFunctionKeys<O>> & O;
+//#endregion
+//#region src/external/Performance/Bvh/Bvh.d.ts
+interface BVHOptions {
+  strategy?: SplitStrategy;
+  verbose?: boolean;
+  setBoundingBox?: boolean;
+  maxDepth?: number;
+  maxLeafTris?: number;
+  indirect?: boolean;
+}
+type BvhProps = BVHOptions & ThreeElements['group'] & {
+  enabled?: boolean;
+  firstHitOnly?: boolean;
+};
+declare function useBVH(mesh: React.RefObject<Mesh | undefined>, options?: BVHOptions): void;
+declare const Bvh: ForwardRefComponent<BvhProps, Group>;
+//#endregion
+//#region src/external/Controls/CameraControls/CameraControls.d.ts
+type CameraControlsProps = Omit<Overwrite<ThreeElement<typeof CameraControlsImpl>, {
+  impl?: typeof CameraControlsImpl;
+  camera?: PerspectiveCamera | OrthographicCamera;
+  domElement?: HTMLElement;
+  makeDefault?: boolean;
+  onControlStart?: (e?: {
+    type: 'controlstart';
+  }) => void;
+  onControl?: (e?: {
+    type: 'control';
+  }) => void;
+  onControlEnd?: (e?: {
+    type: 'controlend';
+  }) => void;
+  onTransitionStart?: (e?: {
+    type: 'transitionstart';
+  }) => void;
+  onUpdate?: (e?: {
+    type: 'update';
+  }) => void;
+  onWake?: (e?: {
+    type: 'wake';
+  }) => void;
+  onRest?: (e?: {
+    type: 'rest';
+  }) => void;
+  onSleep?: (e?: {
+    type: 'sleep';
+  }) => void;
+  onStart?: (e?: {
+    type: 'controlstart';
+  }) => void;
+  onEnd?: (e?: {
+    type: 'controlend';
+  }) => void;
+  onChange?: (e?: {
+    type: string;
+  }) => void;
+  events?: boolean;
+  regress?: boolean;
+}>, 'ref' | 'args' | keyof EventDispatcher>;
+declare const CameraControls: ForwardRefComponent<CameraControlsProps, CameraControlsImpl>;
+type CameraControls = CameraControlsImpl;
+//#endregion
+//#region src/core/Textures/VideoTexture/VideoTexture.d.ts
+declare function getHls(...args: ConstructorParameters<typeof Hls>): Promise<Hls | null>;
+declare function useVideoTexture(srcOrSrcObject: HTMLVideoElement['src' | 'srcObject'], {
+  unsuspend,
+  start,
+  hls: hlsConfig,
+  crossOrigin,
+  muted,
+  loop,
+  playsInline,
+  onVideoFrame,
+  ...videoProps
+}?: {
+  unsuspend?: keyof HTMLVideoElementEventMap;
+  start?: boolean;
+  hls?: Parameters<typeof getHls>[0];
+  onVideoFrame?: VideoFrameRequestCallback;
+} & Partial<Omit<HTMLVideoElement, 'children' | 'src' | 'srcObject'>>): THREE$1.VideoTexture<HTMLVideoElement>;
+type UseVideoTextureParams = Parameters<typeof useVideoTexture>;
+type VideoTexture = ReturnType<typeof useVideoTexture>;
+type VideoTextureProps = {
+  children?: (texture: VideoTexture) => React.ReactNode;
+  src: UseVideoTextureParams[0];
+} & UseVideoTextureParams[1];
+declare const VideoTexture: React.ForwardRefExoticComponent<{
+  children?: (texture: VideoTexture) => React.ReactNode;
+  src: UseVideoTextureParams[0];
+} & {
+  unsuspend?: keyof HTMLVideoElementEventMap;
+  start?: boolean;
+  hls?: Parameters<typeof getHls>[0];
+  onVideoFrame?: VideoFrameRequestCallback;
+} & Partial<Omit<HTMLVideoElement, "children" | "src" | "srcObject">> & React.RefAttributes<THREE$1.VideoTexture<HTMLVideoElement>>>;
+//#endregion
+//#region src/legacy/Materials/AccumulativeShadows/AccumulativeShadows.d.ts
+type SoftShadowMaterialProps = {
+  map: THREE$1.Texture;
+  color?: ReactThreeFiber.Color;
+  alphaTest?: number;
+  blend?: number;
+};
+declare module '@react-three/fiber' {
+  interface ThreeElements {
+    softShadowMaterial: ThreeElements['shaderMaterial'] & SoftShadowMaterialProps;
+  }
+}
+//#endregion
+//#region src/legacy/Materials/Caustics/Caustics.d.ts
+declare module '@react-three/fiber' {
+  interface ThreeElements {
+    causticsProjectionMaterial: ThreeElements['meshNormalMaterial'] & {
+      viewMatrix?: {
+        value: THREE$1.Matrix4;
+      };
+      color?: ReactThreeFiber.Color;
+      causticsTexture?: THREE$1.Texture;
+      causticsTextureB?: THREE$1.Texture;
+      lightProjMatrix?: THREE$1.Matrix4;
+      lightViewMatrix?: THREE$1.Matrix4;
+    };
+  }
+}
+//#endregion
+//#region src/legacy/Materials/MeshTransmissionMaterial/MeshTransmissionMaterial.d.ts
+type MeshTransmissionMaterialType = Omit<ThreeElements['meshPhysicalMaterial'], 'args' | 'roughness' | 'thickness' | 'transmission'> & {
+  transmission?: number;
+  thickness?: number;
+  roughness?: number;
+  chromaticAberration?: number;
+  anisotropy?: number;
+  anisotropicBlur?: number;
+  distortion?: number;
+  distortionScale?: number;
+  temporalDistortion?: number;
+  buffer?: THREE$1.Texture;
+  time?: number;
+  args?: [samples: number, transmissionSampler: boolean];
+};
+declare module '@react-three/fiber' {
+  interface ThreeElements {
+    meshTransmissionMaterial: MeshTransmissionMaterialType;
+  }
+}
+//#endregion
+//#region src/legacy/Materials/MeshReflectorMaterial/MeshReflectorMaterialClass.d.ts
+declare class MeshReflectorMaterial extends MeshStandardMaterial {
+  private _tDepth;
+  private _distortionMap;
+  private _tDiffuse;
+  private _tDiffuseBlur;
+  private _textureMatrix;
+  private _hasBlur;
+  private _mirror;
+  private _mixBlur;
+  private _blurStrength;
+  private _minDepthThreshold;
+  private _maxDepthThreshold;
+  private _depthScale;
+  private _depthToBlurRatioBias;
+  private _distortion;
+  private _mixContrast;
+  constructor(parameters?: {});
+  onBeforeCompile(shader: any): void;
+  get tDiffuse(): Texture | null;
+  set tDiffuse(v: Texture | null);
+  get tDepth(): Texture | null;
+  set tDepth(v: Texture | null);
+  get distortionMap(): Texture | null;
+  set distortionMap(v: Texture | null);
+  get tDiffuseBlur(): Texture | null;
+  set tDiffuseBlur(v: Texture | null);
+  get textureMatrix(): Matrix4 | null;
+  set textureMatrix(v: Matrix4 | null);
+  get hasBlur(): boolean;
+  set hasBlur(v: boolean);
+  get mirror(): number;
+  set mirror(v: number);
+  get mixBlur(): number;
+  set mixBlur(v: number);
+  get mixStrength(): number;
+  set mixStrength(v: number);
+  get minDepthThreshold(): number;
+  set minDepthThreshold(v: number);
+  get maxDepthThreshold(): number;
+  set maxDepthThreshold(v: number);
+  get depthScale(): number;
+  set depthScale(v: number);
+  get depthToBlurRatioBias(): number;
+  set depthToBlurRatioBias(v: number);
+  get distortion(): number;
+  set distortion(v: number);
+  get mixContrast(): number;
+  set mixContrast(v: number);
+}
+//#endregion
+//#region src/legacy/Materials/MeshReflectorMaterial/MeshReflectorMaterial.d.ts
+declare module '@react-three/fiber' {
+  interface ThreeElements {
+    meshReflectorMaterialImpl: ThreeElement<typeof MeshReflectorMaterial>;
+  }
+}
+//#endregion
+//#region src/legacy/Materials/MeshPortalMaterial/MeshPortalMaterial.d.ts
+declare module '@react-three/fiber' {
+  interface ThreeElements {
+    portalMaterialImpl: ThreeElements['shaderMaterial'] & {
+      resolution: ReactThreeFiber.Vector2;
+      blur: number;
+      blend: number;
+      size?: number;
+      sdf?: THREE$1.Texture;
+      map?: THREE$1.Texture;
+    };
+  }
+}
+//#endregion
+//#region src/legacy/Materials/MeshDistortMaterial/MeshDistortMaterial.d.ts
+declare module '@react-three/fiber' {
+  interface ThreeElements {
+    distortMaterialImpl: ThreeElements['meshPhysicalMaterial'] & {
+      time?: number;
+      distort?: number;
+      radius?: number;
+    };
+  }
+}
+//#endregion
+//#region src/legacy/Materials/MeshWobbleMaterial/MeshWobbleMaterial.d.ts
+declare module '@react-three/fiber' {
+  interface ThreeElements {
+    wobbleMaterialImpl: ThreeElements['meshStandardMaterial'] & {
+      time?: number;
+      factor?: number;
+      speed?: number;
+    };
+  }
+}
+//#endregion
+//#region src/legacy/Abstractions/Effects/Effects.d.ts
+declare module '@react-three/fiber' {
+  interface ThreeElements {
+    effectComposer: ThreeElement<typeof EffectComposer>;
+    renderPass: ThreeElement<typeof RenderPass>;
+    shaderPass: ThreeElement<typeof ShaderPass>;
+  }
+}
+//#endregion
+//#region src/legacy/Geometry/Line/Line.d.ts
+type LineProps = Omit<{
+  points: ReadonlyArray<Vector2 | Vector3>;
+  vertexColors?: ReadonlyArray<Color | [number, number, number] | [number, number, number, number]>;
+  lineWidth?: number;
+  segments?: boolean;
+} & Omit<LineMaterialParameters, 'vertexColors' | 'color'> & Omit<ThreeElement<typeof Line2>, 'ref' | 'args'> & Omit<ThreeElement<typeof LineMaterial>, 'ref' | 'color' | 'vertexColors' | 'args'> & {
+  color?: ColorRepresentation;
+}, 'ref'>;
+//#endregion
+//#region src/legacy/Geometry/Segments/Segments.d.ts
+declare module '@react-three/fiber' {
+  interface ThreeElements {
+    segmentObject: ThreeElement<typeof SegmentObject>;
+  }
+}
+declare class SegmentObject {
+  color: THREE.Color;
+  start: THREE.Vector3;
+  end: THREE.Vector3;
+  constructor();
+}
+//#endregion
+//#region src/external/Geometry/Facemesh/Facemesh.d.ts
+type MediaPipeFaceMesh = typeof FacemeshDatas.SAMPLE_FACE;
+type MediaPipePoints = typeof FacemeshDatas.SAMPLE_FACE.keypoints | (typeof FacemeshDatas.SAMPLE_FACELANDMARKER_RESULT.faceLandmarks)[0];
+type FacemeshProps = {
+  points?: MediaPipePoints;
+  face?: MediaPipeFaceMesh;
+  width?: number;
+  height?: number;
+  depth?: number;
+  verticalTri?: [number, number, number];
+  origin?: number | THREE$1.Vector3;
+  facialTransformationMatrix?: (typeof FacemeshDatas.SAMPLE_FACELANDMARKER_RESULT.facialTransformationMatrixes)[0];
+  offset?: boolean;
+  offsetScalar?: number;
+  faceBlendshapes?: (typeof FacemeshDatas.SAMPLE_FACELANDMARKER_RESULT.faceBlendshapes)[0];
+  eyes?: boolean;
+  eyesAsOrigin?: boolean;
+  debug?: boolean;
+  LineComponent?: React.ComponentType<LineProps>;
+} & Omit<ThreeElements['group'], 'ref'>;
+type FacemeshApi = {
+  meshRef: React.RefObject<THREE$1.Mesh>;
+  outerRef: React.RefObject<THREE$1.Group>;
+  eyeRightRef: React.RefObject<FacemeshEyeApi>;
+  eyeLeftRef: React.RefObject<FacemeshEyeApi>;
+};
+declare const Facemesh: React.ForwardRefExoticComponent<Omit<FacemeshProps, "ref"> & React.RefAttributes<FacemeshApi>>;
+type FacemeshEyeProps = {
+  side: 'left' | 'right';
+  debug?: boolean;
+  LineComponent?: React.ComponentType<LineProps>;
+};
+type FacemeshEyeApi = {
+  eyeMeshRef: React.RefObject<THREE$1.Group>;
+  irisDirRef: React.RefObject<THREE$1.Group>;
+  _computeSphere: (faceGeometry: THREE$1.BufferGeometry) => THREE$1.Sphere;
+  _update: (faceGeometry: THREE$1.BufferGeometry, faceBlendshapes: FacemeshProps['faceBlendshapes'], sphere?: THREE$1.Sphere) => void;
+};
+declare const FacemeshEyeDefaults: {
+  contourLandmarks: {
+    right: number[];
+    left: number[];
+  };
+  blendshapes: {
+    right: number[];
+    left: number[];
+  };
+  color: {
+    right: string;
+    left: string;
+  };
+  fov: {
+    horizontal: number;
+    vertical: number;
+  };
+};
+declare const FacemeshEye: React.ForwardRefExoticComponent<FacemeshEyeProps & React.RefAttributes<FacemeshEyeApi>>;
+declare const FacemeshDatas: {
+  TRIANGULATION: number[];
+  SAMPLE_FACE: {
+    keypoints: ({
+      x: number;
+      y: number;
+      z: number;
+      name: string;
+    } | {
+      x: number;
+      y: number;
+      z: number;
+      name?: undefined;
+    })[];
+    box: {
+      xMin: number;
+      yMin: number;
+      xMax: number;
+      yMax: number;
+      width: number;
+      height: number;
+    };
+  };
+  SAMPLE_FACELANDMARKER_RESULT: {
+    faceLandmarks: {
+      x: number;
+      y: number;
+      z: number;
+    }[][];
+    faceBlendshapes: {
+      categories: {
+        index: number;
+        score: number;
+        categoryName: string;
+        displayName: string;
+      }[];
+      headIndex: number;
+      headName: string;
+    }[];
+    facialTransformationMatrixes: {
+      rows: number;
+      columns: number;
+      data: number[];
+    }[];
+  };
+};
+//#endregion
+//#region src/external/Controls/FaceControls/FaceControls.d.ts
+type FaceControlsProps = {
+  camera?: THREE$1.Camera;
+  videoTexture?: VideoTextureProps;
+  manualDetect?: boolean;
+  faceLandmarkerResult?: FaceLandmarkerResult;
+  manualUpdate?: boolean;
+  makeDefault?: boolean;
+  smoothTime?: number;
+  offset?: boolean;
+  offsetScalar?: number;
+  eyes?: boolean;
+  eyesAsOrigin?: boolean;
+  depth?: number;
+  debug?: boolean;
+  facemesh?: FacemeshProps;
+};
+type FaceControlsApi = THREE$1.EventDispatcher & {
+  computeTarget: () => THREE$1.Object3D;
+  update: (delta: number, target?: THREE$1.Object3D) => void;
+  facemeshApiRef: RefObject<FacemeshApi>;
+};
+declare const FaceControls: React.ForwardRefExoticComponent<FaceControlsProps & React.RefAttributes<FaceControlsApi>>;
+declare const useFaceControls: () => FaceControlsApi;
+//#endregion
+//#region src/external/Geometry/Splat/Splat.d.ts
+type SplatMaterialType = {
+  alphaTest?: number;
+  alphaHash?: boolean;
+  centerAndScaleTexture?: THREE$1.DataTexture;
+  covAndColorTexture?: THREE$1.DataTexture;
+  viewport?: THREE$1.Vector2;
+  focal?: number;
+};
+type TargetMesh = THREE$1.Mesh<THREE$1.InstancedBufferGeometry, THREE$1.ShaderMaterial & SplatMaterialType> & {
+  ready: boolean;
+  sorted: boolean;
+  pm: THREE$1.Matrix4;
+  vm1: THREE$1.Matrix4;
+  vm2: THREE$1.Matrix4;
+  viewport: THREE$1.Vector4;
+};
+type SharedState = {
+  url: string;
+  gl: THREE$1.WebGLRenderer;
+  worker: Worker;
+  manager: THREE$1.LoadingManager;
+  stream: ReadableStreamDefaultReader<Uint8Array>;
+  loading: boolean;
+  loaded: boolean;
+  loadedVertexCount: number;
+  rowLength: number;
+  maxVertexes: number;
+  chunkSize: number;
+  totalDownloadBytes: number;
+  numVertices: number;
+  bufferTextureWidth: number;
+  bufferTextureHeight: number;
+  centerAndScaleData: Float32Array;
+  covAndColorData: Uint32Array;
+  covAndColorTexture: THREE$1.DataTexture;
+  centerAndScaleTexture: THREE$1.DataTexture;
+  connect(target: TargetMesh): () => void;
+  update(target: TargetMesh, camera: THREE$1.Camera, hashed: boolean): void;
+  onProgress?: (event: ProgressEvent) => void;
+};
+declare module '@react-three/fiber' {
+  interface ThreeElements {
+    splatMaterial: SplatMaterialType & ThreeElements['shaderMaterial'];
+  }
+}
+type SplatProps = {
+  src: string;
+  toneMapped?: boolean;
+  alphaTest?: number;
+  alphaHash?: boolean;
+  chunkSize?: number;
+} & Omit<ThreeElements['mesh'], 'ref'>;
+declare function Splat({
+  src,
+  toneMapped,
+  alphaTest,
+  alphaHash,
+  chunkSize,
+  ...props
+}: SplatProps): React.JSX.Element;
+//#endregion
+//#region src/external/Helpers/FaceLandmarker/FaceLandmarker.d.ts
+type FaceLandmarkerProps = {
+  basePath?: string;
+  options?: FaceLandmarkerOptions;
+  children?: ReactNode;
+};
+declare const FaceLandmarkerDefaults: {
+  basePath: string;
+  options: FaceLandmarkerOptions;
+};
+declare const FaceLandmarker: React.ForwardRefExoticComponent<FaceLandmarkerProps & React.RefAttributes<FaceLandmarker$1>>;
+declare function useFaceLandmarker(): FaceLandmarker$1 | undefined;
+//#endregion
+export { BVHOptions, Bvh, BvhProps, CameraControls, CameraControlsImpl, CameraControlsProps, FaceControls, FaceControlsApi, FaceControlsProps, FaceLandmarker, FaceLandmarkerDefaults, FaceLandmarkerProps, Facemesh, FacemeshApi, FacemeshDatas, FacemeshEye, FacemeshEyeApi, FacemeshEyeDefaults, FacemeshEyeProps, FacemeshProps, MediaPipeFaceMesh, MediaPipePoints, SharedState, Splat, SplatMaterialType, SplatProps, TargetMesh, useBVH, useFaceControls, useFaceLandmarker };