@react-three/drei 10.8.0-alpha.1 → 11.0.0-alpha.3

package/external/index.d.mts

@@ -0,0 +1,464 @@
+import { ThreeElements, ThreeElement, ReactThreeFiber, Vector2, Vector3 } from '@react-three/fiber';
+import * as React from 'react';
+import { ForwardRefExoticComponent, PropsWithoutRef, RefAttributes, RefObject, ReactNode } from 'react';
+import * as THREE from 'three';
+import { Mesh, Group, PerspectiveCamera, OrthographicCamera, EventDispatcher, MeshStandardMaterial, Texture, Matrix4, Color, ColorRepresentation } from 'three';
+import { SplitStrategy } from 'three-mesh-bvh';
+import CameraControlsImpl from 'camera-controls';
+export { default as CameraControlsImpl } from 'camera-controls';
+import { FaceLandmarkerResult, FaceLandmarkerOptions, FaceLandmarker as FaceLandmarker$1 } from '@mediapipe/tasks-vision';
+import Hls from 'hls.js';
+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 { LineMaterialParameters, LineMaterial } from 'three/examples/jsm/lines/LineMaterial.js';
+
+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;
+
+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>;
+
+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;
+
+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.VideoTexture<HTMLVideoElement>;
+type UseVideoTextureParams = Parameters<typeof useVideoTexture>;
+type VideoTextureProps = {
+    children?: (texture: VideoTexture) => React.ReactNode;
+    src: UseVideoTextureParams[0];
+} & UseVideoTextureParams[1];
+type VideoTexture = ReturnType<typeof useVideoTexture>;
+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.VideoTexture<HTMLVideoElement>>>;
+
+type SoftShadowMaterialProps = {
+    map: THREE.Texture;
+    color?: ReactThreeFiber.Color;
+    alphaTest?: number;
+    blend?: number;
+};
+declare module '@react-three/fiber' {
+    interface ThreeElements {
+        softShadowMaterial: ThreeElements['shaderMaterial'] & SoftShadowMaterialProps;
+    }
+}
+
+declare module '@react-three/fiber' {
+    interface ThreeElements {
+        causticsProjectionMaterial: ThreeElements['meshNormalMaterial'] & {
+            viewMatrix?: {
+                value: THREE.Matrix4;
+            };
+            color?: ReactThreeFiber.Color;
+            causticsTexture?: THREE.Texture;
+            causticsTextureB?: THREE.Texture;
+            lightProjMatrix?: THREE.Matrix4;
+            lightViewMatrix?: THREE.Matrix4;
+        };
+    }
+}
+
+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.Texture;
+    time?: number;
+    args?: [samples: number, transmissionSampler: boolean];
+};
+declare module '@react-three/fiber' {
+    interface ThreeElements {
+        meshTransmissionMaterial: MeshTransmissionMaterialType;
+    }
+}
+
+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);
+}
+
+declare module '@react-three/fiber' {
+    interface ThreeElements {
+        meshReflectorMaterialImpl: ThreeElement<typeof MeshReflectorMaterial>;
+    }
+}
+
+declare module '@react-three/fiber' {
+    interface ThreeElements {
+        portalMaterialImpl: ThreeElements['shaderMaterial'] & {
+            resolution: ReactThreeFiber.Vector2;
+            blur: number;
+            blend: number;
+            size?: number;
+            sdf?: THREE.Texture;
+            map?: THREE.Texture;
+        };
+    }
+}
+
+declare module '@react-three/fiber' {
+    interface ThreeElements {
+        distortMaterialImpl: ThreeElements['meshPhysicalMaterial'] & {
+            time?: number;
+            distort?: number;
+            radius?: number;
+        };
+    }
+}
+
+declare module '@react-three/fiber' {
+    interface ThreeElements {
+        wobbleMaterialImpl: ThreeElements['meshStandardMaterial'] & {
+            time?: number;
+            factor?: number;
+            speed?: number;
+        };
+    }
+}
+
+declare module '@react-three/fiber' {
+    interface ThreeElements {
+        effectComposer: ThreeElement<typeof EffectComposer>;
+        renderPass: ThreeElement<typeof RenderPass>;
+        shaderPass: ThreeElement<typeof ShaderPass>;
+    }
+}
+
+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'>;
+
+declare module '@react-three/fiber' {
+    interface ThreeElements {
+        segmentObject: ThreeElement<typeof SegmentObject>;
+    }
+}
+declare class SegmentObject {
+    color: THREE.Color;
+    start: THREE.Vector3;
+    end: THREE.Vector3;
+    constructor();
+}
+
+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.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.Mesh>;
+    outerRef: React.RefObject<THREE.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.Group>;
+    irisDirRef: React.RefObject<THREE.Group>;
+    _computeSphere: (faceGeometry: THREE.BufferGeometry) => THREE.Sphere;
+    _update: (faceGeometry: THREE.BufferGeometry, faceBlendshapes: FacemeshProps['faceBlendshapes'], sphere?: THREE.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[];
+        }[];
+    };
+};
+
+type FaceControlsProps = {
+    camera?: THREE.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.EventDispatcher & {
+    computeTarget: () => THREE.Object3D;
+    update: (delta: number, target?: THREE.Object3D) => void;
+    facemeshApiRef: RefObject<FacemeshApi>;
+};
+declare const FaceControls: React.ForwardRefExoticComponent<FaceControlsProps & React.RefAttributes<FaceControlsApi>>;
+declare const useFaceControls: () => FaceControlsApi;
+
+type SplatMaterialType = {
+    alphaTest?: number;
+    alphaHash?: boolean;
+    centerAndScaleTexture?: THREE.DataTexture;
+    covAndColorTexture?: THREE.DataTexture;
+    viewport?: THREE.Vector2;
+    focal?: number;
+};
+type TargetMesh = THREE.Mesh<THREE.InstancedBufferGeometry, THREE.ShaderMaterial & SplatMaterialType> & {
+    ready: boolean;
+    sorted: boolean;
+    pm: THREE.Matrix4;
+    vm1: THREE.Matrix4;
+    vm2: THREE.Matrix4;
+    viewport: THREE.Vector4;
+};
+type SharedState = {
+    url: string;
+    gl: THREE.WebGLRenderer;
+    worker: Worker;
+    manager: THREE.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.DataTexture;
+    centerAndScaleTexture: THREE.DataTexture;
+    connect(target: TargetMesh): () => void;
+    update(target: TargetMesh, camera: THREE.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;
+
+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;
+
+export { Bvh, CameraControls, FaceControls, FaceLandmarker, FaceLandmarkerDefaults, Facemesh, FacemeshDatas, FacemeshEye, FacemeshEyeDefaults, Splat, useBVH, useFaceControls, useFaceLandmarker };
+export type { BVHOptions, BvhProps, CameraControlsProps, FaceControlsApi, FaceControlsProps, FaceLandmarkerProps, FacemeshApi, FacemeshEyeApi, FacemeshEyeProps, FacemeshProps, MediaPipeFaceMesh, MediaPipePoints, SharedState, SplatMaterialType, SplatProps, TargetMesh };