@react-three/drei 9.109.2 → 9.109.3

package/core/MotionPathControls.d.ts

@@ -1,27 +0,0 @@
-import * as THREE from 'three';
-import * as React from 'react';
-type MotionPathProps = JSX.IntrinsicElements['group'] & {
-    curves?: THREE.Curve<THREE.Vector3>[];
-    debug?: boolean;
-    object?: React.MutableRefObject<THREE.Object3D>;
-    focus?: [x: number, y: number, z: number] | React.MutableRefObject<THREE.Object3D>;
-    offset?: number;
-    smooth?: boolean | number;
-    eps?: number;
-    damping?: number;
-    focusDamping?: number;
-    maxSpeed?: number;
-};
-type MotionState = {
-    current: number;
-    path: THREE.CurvePath<THREE.Vector3>;
-    focus: React.MutableRefObject<THREE.Object3D> | [x: number, y: number, z: number] | undefined;
-    object: React.MutableRefObject<THREE.Object3D>;
-    offset: number;
-    point: THREE.Vector3;
-    tangent: THREE.Vector3;
-    next: THREE.Vector3;
-};
-export declare function useMotion(): MotionState;
-export declare const MotionPathControls: React.ForwardRefExoticComponent<Omit<MotionPathProps, "ref"> & React.RefAttributes<THREE.Group>>;
-export {};

package/core/NormalTexture.d.ts

@@ -1,14 +0,0 @@
-import * as React from 'react';
-import { Texture } from 'three';
-type Settings = {
-    repeat?: number[];
-    anisotropy?: number;
-    offset?: number[];
-};
-export declare function useNormalTexture(id?: number, settings?: Settings, onLoad?: (texture: Texture | Texture[]) => void): [Texture, string, number];
-export declare const NormalTexture: ({ children, id, onLoad, ...settings }: {
-    children?: (texture: ReturnType<typeof useNormalTexture>) => React.ReactNode;
-    id?: Parameters<typeof useNormalTexture>[0];
-    onLoad?: Parameters<typeof useNormalTexture>[2];
-} & Settings) => React.JSX.Element;
-export {};

package/core/OrbitControls.d.ts

@@ -1,22 +0,0 @@
-import { ReactThreeFiber } from '@react-three/fiber';
-import type { Camera, Event } from 'three';
-import { OrbitControls as OrbitControlsImpl } from 'three-stdlib';
-import { ForwardRefComponent } from '../helpers/ts-utils';
-export type OrbitControlsChangeEvent = Event & {
-    target: EventTarget & {
-        object: Camera;
-    };
-};
-export type OrbitControlsProps = Omit<ReactThreeFiber.Overwrite<ReactThreeFiber.Object3DNode<OrbitControlsImpl, typeof OrbitControlsImpl>, {
-    camera?: Camera;
-    domElement?: HTMLElement;
-    enableDamping?: boolean;
-    makeDefault?: boolean;
-    onChange?: (e?: OrbitControlsChangeEvent) => void;
-    onEnd?: (e?: Event) => void;
-    onStart?: (e?: Event) => void;
-    regress?: boolean;
-    target?: ReactThreeFiber.Vector3;
-    keyEvents?: boolean | HTMLElement;
-}>, 'ref'>;
-export declare const OrbitControls: ForwardRefComponent<OrbitControlsProps, OrbitControlsImpl>;

package/core/OrthographicCamera.d.ts

@@ -1,14 +0,0 @@
-import * as THREE from 'three';
-import * as React from 'react';
-import { OrthographicCamera as OrthographicCameraImpl } from 'three';
-import { ForwardRefComponent } from '../helpers/ts-utils';
-type Props = Omit<JSX.IntrinsicElements['orthographicCamera'], 'children'> & {
-    makeDefault?: boolean;
-    manual?: boolean;
-    children?: React.ReactNode | ((texture: THREE.Texture) => React.ReactNode);
-    frames?: number;
-    resolution?: number;
-    envMap?: THREE.Texture;
-};
-export declare const OrthographicCamera: ForwardRefComponent<Props, OrthographicCameraImpl>;
-export {};

package/core/Outlines.d.ts

@@ -1,16 +0,0 @@
-import * as React from 'react';
-import { ReactThreeFiber } from '@react-three/fiber';
-type OutlinesProps = JSX.IntrinsicElements['group'] & {
-    color?: ReactThreeFiber.Color;
-    screenspace?: boolean;
-    opacity?: number;
-    transparent?: boolean;
-    thickness?: number;
-    angle?: number;
-    toneMapped?: boolean;
-    polygonOffset?: boolean;
-    polygonOffsetFactor?: number;
-    renderOrder?: number;
-};
-export declare function Outlines({ color, opacity, transparent, screenspace, toneMapped, polygonOffset, polygonOffsetFactor, renderOrder, thickness, angle, ...props }: OutlinesProps): React.JSX.Element;
-export {};

package/core/PerformanceMonitor.d.ts

@@ -1,36 +0,0 @@
-import * as React from 'react';
-type PerformanceMonitorHookApi = {
-    onIncline: (api: PerformanceMonitorApi) => void;
-    onDecline: (api: PerformanceMonitorApi) => void;
-    onChange: (api: PerformanceMonitorApi) => void;
-    onFallback: (api: PerformanceMonitorApi) => void;
-};
-export type PerformanceMonitorApi = {
-    fps: number;
-    factor: number;
-    refreshrate: number;
-    frames: number[];
-    averages: number[];
-    index: number;
-    flipped: number;
-    fallback: boolean;
-    subscriptions: Map<Symbol, Partial<PerformanceMonitorHookApi>>;
-    subscribe: (ref: React.MutableRefObject<Partial<PerformanceMonitorHookApi>>) => () => void;
-};
-type PerformanceMonitorProps = {
-    ms?: number;
-    iterations?: number;
-    threshold?: number;
-    bounds?: (refreshrate: number) => [lower: number, upper: number];
-    flipflops?: number;
-    factor?: number;
-    step?: number;
-    onIncline?: (api: PerformanceMonitorApi) => void;
-    onDecline?: (api: PerformanceMonitorApi) => void;
-    onChange?: (api: PerformanceMonitorApi) => void;
-    onFallback?: (api: PerformanceMonitorApi) => void;
-    children?: React.ReactNode;
-};
-export declare function PerformanceMonitor({ iterations, ms, threshold, step, factor: _factor, flipflops, bounds, onIncline, onDecline, onChange, onFallback, children, }: PerformanceMonitorProps): React.JSX.Element;
-export declare function usePerformanceMonitor({ onIncline, onDecline, onChange, onFallback, }: Partial<PerformanceMonitorHookApi>): void;
-export {};

package/core/PerspectiveCamera.d.ts

@@ -1,14 +0,0 @@
-import * as THREE from 'three';
-import * as React from 'react';
-import { PerspectiveCamera as PerspectiveCameraImpl } from 'three';
-import { ForwardRefComponent } from '../helpers/ts-utils';
-type Props = Omit<JSX.IntrinsicElements['perspectiveCamera'], 'children'> & {
-    makeDefault?: boolean;
-    manual?: boolean;
-    children?: React.ReactNode | ((texture: THREE.Texture) => React.ReactNode);
-    frames?: number;
-    resolution?: number;
-    envMap?: THREE.Texture;
-};
-export declare const PerspectiveCamera: ForwardRefComponent<Props, PerspectiveCameraImpl>;
-export {};

package/core/PointMaterial.d.ts

@@ -1,16 +0,0 @@
-import * as THREE from 'three';
-import { PrimitiveProps } from '@react-three/fiber';
-import { ForwardRefComponent } from '../helpers/ts-utils';
-type PointMaterialType = JSX.IntrinsicElements['pointsMaterial'];
-declare global {
-    namespace JSX {
-        interface IntrinsicElements {
-            pointMaterialImpl: PointMaterialType;
-        }
-    }
-}
-export declare class PointMaterialImpl extends THREE.PointsMaterial {
-    constructor(props: any);
-}
-export declare const PointMaterial: ForwardRefComponent<Omit<PrimitiveProps, 'object' | 'attach'>, PointMaterialImpl>;
-export {};

package/core/PointerLockControls.d.ts

@@ -1,15 +0,0 @@
-import { ReactThreeFiber } from '@react-three/fiber';
-import * as THREE from 'three';
-import { PointerLockControls as PointerLockControlsImpl } from 'three-stdlib';
-import { ForwardRefComponent } from '../helpers/ts-utils';
-export type PointerLockControlsProps = ReactThreeFiber.Object3DNode<PointerLockControlsImpl, typeof PointerLockControlsImpl> & {
-    domElement?: HTMLElement;
-    selector?: string;
-    enabled?: boolean;
-    camera?: THREE.Camera;
-    onChange?: (e?: THREE.Event) => void;
-    onLock?: (e?: THREE.Event) => void;
-    onUnlock?: (e?: THREE.Event) => void;
-    makeDefault?: boolean;
-};
-export declare const PointerLockControls: ForwardRefComponent<PointerLockControlsProps, PointerLockControlsImpl>;

package/core/Points.d.ts

@@ -1,34 +0,0 @@
-import * as THREE from 'three';
-import * as React from 'react';
-import { ReactThreeFiber } from '@react-three/fiber';
-import { ForwardRefComponent } from '../helpers/ts-utils';
-declare global {
-    namespace JSX {
-        interface IntrinsicElements {
-            positionPoint: ReactThreeFiber.Object3DNode<PositionPoint, typeof PositionPoint>;
-        }
-    }
-}
-type PointsInstancesProps = JSX.IntrinsicElements['points'] & {
-    range?: number;
-    limit?: number;
-};
-export declare class PositionPoint extends THREE.Group {
-    size: number;
-    color: THREE.Color;
-    instance: React.MutableRefObject<THREE.Points | undefined>;
-    instanceKey: React.MutableRefObject<JSX.IntrinsicElements['positionPoint'] | undefined>;
-    constructor();
-    get geometry(): THREE.BufferGeometry | undefined;
-    raycast(raycaster: THREE.Raycaster, intersects: THREE.Intersection[]): void;
-}
-export declare const Point: ForwardRefComponent<JSX.IntrinsicElements['positionPoint'], PositionPoint>;
-type PointsBuffersProps = JSX.IntrinsicElements['points'] & {
-    positions: Float32Array;
-    colors?: Float32Array;
-    sizes?: Float32Array;
-    stride?: 2 | 3;
-};
-export declare const PointsBuffer: ForwardRefComponent<PointsBuffersProps, THREE.Points>;
-export declare const Points: ForwardRefComponent<PointsBuffersProps | PointsInstancesProps, THREE.Points>;
-export {};

package/core/PositionalAudio.d.ts

@@ -1,9 +0,0 @@
-import { PositionalAudio as PositionalAudioImpl } from 'three';
-import { ForwardRefComponent } from '../helpers/ts-utils';
-type Props = JSX.IntrinsicElements['positionalAudio'] & {
-    url: string;
-    distance?: number;
-    loop?: boolean;
-};
-export declare const PositionalAudio: ForwardRefComponent<Props, PositionalAudioImpl>;
-export {};

package/core/Preload.d.ts

@@ -1,8 +0,0 @@
-import { Object3D, Camera } from 'three';
-type Props = {
-    all?: boolean;
-    scene?: Object3D;
-    camera?: Camera;
-};
-export declare function Preload({ all, scene, camera }: Props): null;
-export {};

package/core/Progress.d.ts

@@ -1,14 +0,0 @@
-import * as React from 'react';
-type Data = {
-    errors: string[];
-    active: boolean;
-    progress: number;
-    item: string;
-    loaded: number;
-    total: number;
-};
-declare const useProgress: import("zustand").UseBoundStore<Data, import("zustand").StoreApi<Data>>;
-export { useProgress };
-export declare function Progress({ children }: {
-    children?: (result: Data) => React.ReactNode;
-}): React.JSX.Element;

package/core/QuadraticBezierLine.d.ts

@@ -1,16 +0,0 @@
-import { Vector3 } from 'three';
-import { Line2 } from 'three-stdlib';
-import { LineProps } from './Line';
-import { Object3DNode } from '@react-three/fiber';
-import { ForwardRefComponent } from '../helpers/ts-utils';
-type Props = Omit<LineProps, 'points' | 'ref'> & {
-    start: Vector3 | [number, number, number];
-    end: Vector3 | [number, number, number];
-    mid?: Vector3 | [number, number, number];
-    segments?: number;
-};
-export type Line2Props = Object3DNode<Line2, typeof Line2> & {
-    setPoints: (start: Vector3 | [number, number, number], end: Vector3 | [number, number, number], mid: Vector3 | [number, number, number]) => void;
-};
-export declare const QuadraticBezierLine: ForwardRefComponent<Props, Line2Props>;
-export {};

package/core/Reflector.d.ts

@@ -1,30 +0,0 @@
-import * as React from 'react';
-import { Mesh, Texture } from 'three';
-import { MeshReflectorMaterialProps } from '../materials/MeshReflectorMaterial';
-import { ForwardRefComponent } from '../helpers/ts-utils';
-export type ReflectorProps = Omit<JSX.IntrinsicElements['mesh'], 'args' | 'children'> & Pick<JSX.IntrinsicElements['planeGeometry'], 'args'> & {
-    resolution?: number;
-    mixBlur?: number;
-    mixStrength?: number;
-    blur?: [number, number] | number;
-    mirror: number;
-    minDepthThreshold?: number;
-    maxDepthThreshold?: number;
-    depthScale?: number;
-    depthToBlurRatioBias?: number;
-    debug?: number;
-    distortionMap?: Texture;
-    distortion?: number;
-    mixContrast?: number;
-    children?: {
-        (Component: React.ElementType<JSX.IntrinsicElements['meshReflectorMaterial']>, ComponentProps: MeshReflectorMaterialProps): JSX.Element | null;
-    };
-};
-declare global {
-    namespace JSX {
-        interface IntrinsicElements {
-            meshReflectorMaterial: MeshReflectorMaterialProps;
-        }
-    }
-}
-export declare const Reflector: ForwardRefComponent<ReflectorProps, Mesh>;

package/core/RenderCubeTexture.d.ts

@@ -1,30 +0,0 @@
-import * as THREE from 'three';
-import * as React from 'react';
-import { ComputeFunction, ReactThreeFiber } from '@react-three/fiber';
-import { ForwardRefComponent } from '../helpers/ts-utils';
-export type RenderCubeTextureProps = Omit<JSX.IntrinsicElements['texture'], 'rotation'> & {
-    stencilBuffer?: boolean;
-    depthBuffer?: boolean;
-    generateMipmaps?: boolean;
-    renderPriority?: number;
-    eventPriority?: number;
-    frames?: number;
-    compute?: ComputeFunction;
-    flip?: boolean;
-    resolution?: number;
-    children: React.ReactNode;
-    near?: number;
-    far?: number;
-    position?: ReactThreeFiber.Vector3;
-    rotation?: ReactThreeFiber.Euler;
-    scale?: ReactThreeFiber.Vector3;
-    quaternion?: ReactThreeFiber.Quaternion;
-    matrix?: ReactThreeFiber.Matrix4;
-    matrixAutoUpdate?: boolean;
-};
-export type RenderCubeTextureApi = {
-    scene: THREE.Scene;
-    fbo: THREE.WebGLCubeRenderTarget;
-    camera: THREE.CubeCamera;
-};
-export declare const RenderCubeTexture: ForwardRefComponent<RenderCubeTextureProps, RenderCubeTextureApi>;

package/core/RenderTexture.d.ts

@@ -1,18 +0,0 @@
-import * as THREE from 'three';
-import * as React from 'react';
-import { ForwardRefComponent } from '../helpers/ts-utils';
-type Props = JSX.IntrinsicElements['texture'] & {
-    width?: number;
-    height?: number;
-    samples?: number;
-    stencilBuffer?: boolean;
-    depthBuffer?: boolean;
-    generateMipmaps?: boolean;
-    renderPriority?: number;
-    eventPriority?: number;
-    frames?: number;
-    compute?: (event: any, state: any, previous: any) => false | undefined;
-    children: React.ReactNode;
-};
-export declare const RenderTexture: ForwardRefComponent<Props, THREE.Texture>;
-export {};

package/core/Resize.d.ts

@@ -1,10 +0,0 @@
-import * as THREE from 'three';
-import * as React from 'react';
-export type ResizeProps = JSX.IntrinsicElements['group'] & {
-    width?: boolean;
-    height?: boolean;
-    depth?: boolean;
-    box3?: THREE.Box3;
-    precise?: boolean;
-};
-export declare const Resize: React.ForwardRefExoticComponent<Omit<ResizeProps, "ref"> & React.RefAttributes<THREE.Group>>;

package/core/RoundedBox.d.ts

@@ -1,12 +0,0 @@
-import { Mesh } from 'three';
-import { ForwardRefComponent, NamedArrayTuple } from '../helpers/ts-utils';
-type Props = {
-    args?: NamedArrayTuple<(width?: number, height?: number, depth?: number) => void>;
-    radius?: number;
-    smoothness?: number;
-    bevelSegments?: number;
-    steps?: number;
-    creaseAngle?: number;
-} & Omit<JSX.IntrinsicElements['mesh'], 'args'>;
-export declare const RoundedBox: ForwardRefComponent<Props, Mesh>;
-export {};

package/core/Sampler.d.ts

@@ -1,28 +0,0 @@
-import * as React from 'react';
-import { Color, InstancedBufferAttribute, InstancedMesh, Mesh, Object3D, Vector3 } from 'three';
-import { GroupProps } from '@react-three/fiber';
-type SamplePayload = {
-    position: Vector3;
-    normal: Vector3;
-    color: Color;
-};
-export type TransformFn = (payload: TransformPayload, i: number) => void;
-type TransformPayload = SamplePayload & {
-    dummy: Object3D;
-    sampledMesh: Mesh;
-};
-type Props = {
-    mesh?: React.RefObject<Mesh>;
-    instances?: React.RefObject<InstancedMesh>;
-    weight?: string;
-    transform?: TransformFn;
-    count?: number;
-};
-export interface useSurfaceSamplerProps {
-    transform?: TransformFn;
-    weight?: string;
-    count?: number;
-}
-export declare function useSurfaceSampler(mesh: React.MutableRefObject<Mesh>, count?: number, transform?: TransformFn, weight?: string, instanceMesh?: React.MutableRefObject<InstancedMesh> | null): InstancedBufferAttribute;
-export declare function Sampler({ children, weight, transform, instances, mesh, count, ...props }: React.PropsWithChildren<Props & GroupProps>): React.JSX.Element;
-export {};

package/core/ScreenQuad.d.ts

@@ -1,5 +0,0 @@
-import * as THREE from 'three';
-import { ForwardRefComponent } from '../helpers/ts-utils';
-type Props = Omit<JSX.IntrinsicElements['mesh'], 'args'>;
-export declare const ScreenQuad: ForwardRefComponent<Props, THREE.Mesh>;
-export {};

package/core/ScreenSizer.d.ts

@@ -1,7 +0,0 @@
-import { Object3DProps } from '@react-three/fiber';
-import { Object3D } from 'three';
-import { ForwardRefComponent } from '../helpers/ts-utils';
-export interface ScreenSizerProps extends Object3DProps {
-    scale?: number;
-}
-export declare const ScreenSizer: ForwardRefComponent<ScreenSizerProps, Object3D>;

package/core/ScreenSpace.d.ts

@@ -1,6 +0,0 @@
-import { Group } from 'three';
-import { ForwardRefComponent } from '../helpers/ts-utils';
-export type ScreenSpaceProps = {
-    depth?: number;
-} & JSX.IntrinsicElements['group'];
-export declare const ScreenSpace: ForwardRefComponent<ScreenSpaceProps, Group>;

package/core/Segments.d.ts

@@ -1,31 +0,0 @@
-import * as THREE from 'three';
-import * as React from 'react';
-import { ReactThreeFiber } from '@react-three/fiber';
-import { Line2, LineMaterialParameters } from 'three-stdlib';
-import { ForwardRefComponent } from '../helpers/ts-utils';
-type SegmentsProps = LineMaterialParameters & {
-    limit?: number;
-    lineWidth?: number;
-    children: React.ReactNode;
-};
-type SegmentProps = Omit<JSX.IntrinsicElements['segmentObject'], 'start' | 'end' | 'color'> & {
-    start: ReactThreeFiber.Vector3;
-    end: ReactThreeFiber.Vector3;
-    color?: ReactThreeFiber.Color;
-};
-declare const Segments: ForwardRefComponent<SegmentsProps, Line2>;
-declare global {
-    namespace JSX {
-        interface IntrinsicElements {
-            segmentObject: ReactThreeFiber.Object3DNode<SegmentObject, typeof SegmentObject>;
-        }
-    }
-}
-export declare class SegmentObject {
-    color: THREE.Color;
-    start: THREE.Vector3;
-    end: THREE.Vector3;
-    constructor();
-}
-declare const Segment: ForwardRefComponent<SegmentProps, SegmentObject>;
-export { Segments, Segment };

package/core/Shadow.d.ts

@@ -1,12 +0,0 @@
-import { Mesh, Color, type PlaneGeometry, type MeshBasicMaterial } from 'three';
-import { ForwardRefComponent } from '../helpers/ts-utils';
-type Props = JSX.IntrinsicElements['mesh'] & {
-    colorStop?: number;
-    fog?: boolean;
-    color?: Color | number | string;
-    opacity?: number;
-    depthWrite?: boolean;
-};
-export type ShadowType = Mesh<PlaneGeometry, MeshBasicMaterial>;
-export declare const Shadow: ForwardRefComponent<Props, ShadowType>;
-export {};

package/core/ShadowAlpha.d.ts

@@ -1,8 +0,0 @@
-import * as React from 'react';
-import * as THREE from 'three';
-interface ShadowAlphaProps {
-    opacity?: number;
-    alphaMap?: THREE.Texture | boolean;
-}
-export declare function ShadowAlpha({ opacity, alphaMap }: ShadowAlphaProps): React.JSX.Element;
-export {};

package/core/Sky.d.ts

@@ -1,17 +0,0 @@
-import { ReactThreeFiber } from '@react-three/fiber';
-import { Sky as SkyImpl } from 'three-stdlib';
-import { Vector3 } from 'three';
-import { ForwardRefComponent } from '../helpers/ts-utils';
-type Props = {
-    distance?: number;
-    sunPosition?: ReactThreeFiber.Vector3;
-    inclination?: number;
-    azimuth?: number;
-    mieCoefficient?: number;
-    mieDirectionalG?: number;
-    rayleigh?: number;
-    turbidity?: number;
-};
-export declare function calcPosFromAngles(inclination: number, azimuth: number, vector?: Vector3): Vector3;
-export declare const Sky: ForwardRefComponent<Props, SkyImpl>;
-export {};

package/core/Sparkles.d.ts

@@ -1,21 +0,0 @@
-import * as THREE from 'three';
-import { PointsProps, Node } from '@react-three/fiber';
-import { ForwardRefComponent } from '../helpers/ts-utils';
-interface Props {
-    count?: number;
-    speed?: number | Float32Array;
-    opacity?: number | Float32Array;
-    color?: THREE.ColorRepresentation | Float32Array;
-    size?: number | Float32Array;
-    scale?: number | [number, number, number] | THREE.Vector3;
-    noise?: number | [number, number, number] | THREE.Vector3 | Float32Array;
-}
-declare global {
-    namespace JSX {
-        interface IntrinsicElements {
-            sparklesImplMaterial: Node<any, any>;
-        }
-    }
-}
-export declare const Sparkles: ForwardRefComponent<Props & PointsProps, THREE.Points>;
-export {};

package/core/Splat.d.ts

@@ -1,58 +0,0 @@
-import * as THREE from 'three';
-import * as React from 'react';
-export type SplatMaterialType = {
-    alphaTest?: number;
-    alphaHash?: boolean;
-    centerAndScaleTexture?: THREE.DataTexture;
-    covAndColorTexture?: THREE.DataTexture;
-    viewport?: THREE.Vector2;
-    focal?: number;
-};
-export 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;
-};
-export 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 global {
-    namespace JSX {
-        interface IntrinsicElements {
-            splatMaterial: SplatMaterialType & JSX.IntrinsicElements['shaderMaterial'];
-        }
-    }
-}
-type SplatProps = {
-    src: string;
-    toneMapped?: boolean;
-    alphaTest?: number;
-    alphaHash?: boolean;
-    chunkSize?: number;
-} & JSX.IntrinsicElements['mesh'];
-export declare function Splat({ src, toneMapped, alphaTest, alphaHash, chunkSize, ...props }: SplatProps): React.JSX.Element;
-export {};

package/core/SpotLight.d.ts

@@ -1,26 +0,0 @@
-import * as React from 'react';
-import { DepthTexture, SpotLight as SpotLightImpl, Texture } from 'three';
-import { ForwardRefComponent } from '../helpers/ts-utils';
-type SpotLightProps = JSX.IntrinsicElements['spotLight'] & {
-    depthBuffer?: DepthTexture;
-    attenuation?: number;
-    anglePower?: number;
-    radiusTop?: number;
-    radiusBottom?: number;
-    opacity?: number;
-    color?: string | number;
-    volumetric?: boolean;
-    debug?: boolean;
-};
-interface ShadowMeshProps {
-    distance?: number;
-    alphaTest?: number;
-    scale?: number;
-    map?: Texture;
-    shader?: string;
-    width?: number;
-    height?: number;
-}
-export declare function SpotLightShadow(props: React.PropsWithChildren<ShadowMeshProps>): React.JSX.Element;
-declare const SpotLight: ForwardRefComponent<React.PropsWithChildren<SpotLightProps>, SpotLightImpl>;
-export { SpotLight };

package/core/SpriteAnimator.d.ts

@@ -1,38 +0,0 @@
-import * as React from 'react';
-export type SpriteAnimatorProps = {
-    startFrame?: number;
-    endFrame?: number;
-    fps?: number;
-    frameName?: string;
-    textureDataURL?: string;
-    textureImageURL?: string;
-    loop?: boolean;
-    numberOfFrames?: number;
-    autoPlay?: boolean;
-    animationNames?: Array<string>;
-    onStart?: Function;
-    onEnd?: Function;
-    onLoopEnd?: Function;
-    onFrame?: Function;
-    play?: boolean;
-    pause?: boolean;
-    flipX?: boolean;
-    position?: Array<number>;
-    alphaTest?: number;
-    asSprite?: boolean;
-    offset?: number;
-    playBackwards?: boolean;
-    resetOnEnd?: boolean;
-    maxItems?: number;
-    instanceItems?: any[];
-    spriteDataset?: any;
-} & JSX.IntrinsicElements['group'];
-type SpriteAnimatorState = {
-    current: number | undefined;
-    offset: number | undefined;
-    hasEnded: boolean | undefined;
-    ref: React.MutableRefObject<any> | undefined | null | ((instance: any) => void);
-};
-export declare function useSpriteAnimator(): SpriteAnimatorState;
-export declare const SpriteAnimator: React.FC<SpriteAnimatorProps>;
-export {};