@react-three/drei 9.109.3 → 9.109.5

package/core/Example.d.ts

@@ -0,0 +1,13 @@
+import * as React from 'react';
+import type { Color } from '@react-three/fiber';
+export type ExampleProps = {
+    font: string;
+    color?: Color;
+    debug?: boolean;
+    bevelSize?: number;
+} & React.ComponentProps<'group'>;
+export type ExampleApi = {
+    incr: (x?: number) => void;
+    decr: (x?: number) => void;
+};
+export declare const Example: React.ForwardRefExoticComponent<Omit<ExampleProps, "ref"> & React.RefAttributes<ExampleApi>>;

package/core/Fbo.d.ts

@@ -0,0 +1,28 @@
+import * as React from 'react';
+import * as THREE from 'three';
+import { TextureEncoding } from '../helpers/deprecated';
+type ColorSpace = 'srgb' | 'srgb-linear' | '' | string;
+type FBOSettings = {
+    samples?: number;
+    depth?: boolean;
+    wrapS?: THREE.Wrapping | undefined;
+    wrapT?: THREE.Wrapping | undefined;
+    magFilter?: THREE.MagnificationTextureFilter | undefined;
+    minFilter?: THREE.MinificationTextureFilter | undefined;
+    format?: number | undefined;
+    type?: THREE.TextureDataType | undefined;
+    anisotropy?: number | undefined;
+    depthBuffer?: boolean | undefined;
+    stencilBuffer?: boolean | undefined;
+    generateMipmaps?: boolean | undefined;
+    depthTexture?: THREE.DepthTexture | undefined;
+    encoding?: TextureEncoding | undefined;
+    colorSpace?: ColorSpace | undefined;
+};
+export declare function useFBO(width?: number | FBOSettings, height?: number, settings?: FBOSettings): THREE.WebGLRenderTarget;
+export declare const Fbo: ({ children, width, height, ...settings }: {
+    children?: (target: ReturnType<typeof useFBO>) => React.ReactNode;
+    width: Parameters<typeof useFBO>[0];
+    height: Parameters<typeof useFBO>[1];
+} & FBOSettings) => React.JSX.Element;
+export {};

package/core/Fbx.d.ts

@@ -0,0 +1,11 @@
+import * as React from 'react';
+import { Group } from 'three';
+import { Clone } from './Clone';
+export declare function useFBX(path: string): Group;
+export declare namespace useFBX {
+    var preload: (path: string) => undefined;
+    var clear: (input: string | string[]) => void;
+}
+export declare function Fbx({ path, ...props }: {
+    path: Parameters<typeof useFBX>[0];
+} & Omit<React.ComponentProps<typeof Clone>, 'object'>): React.JSX.Element;

package/core/FirstPersonControls.d.ts

@@ -0,0 +1,8 @@
+import { Object3DNode } from '@react-three/fiber';
+import { FirstPersonControls as FirstPersonControlImpl } from 'three-stdlib';
+import { ForwardRefComponent } from '../helpers/ts-utils';
+export type FirstPersonControlsProps = Object3DNode<FirstPersonControlImpl, typeof FirstPersonControlImpl> & {
+    domElement?: HTMLElement;
+    makeDefault?: boolean;
+};
+export declare const FirstPersonControls: ForwardRefComponent<FirstPersonControlsProps, FirstPersonControlImpl>;

package/core/Fisheye.d.ts

@@ -0,0 +1,9 @@
+import * as React from 'react';
+export type FisheyeProps = JSX.IntrinsicElements['mesh'] & {
+    zoom?: number;
+    segments?: number;
+    resolution?: number;
+    children: React.ReactNode;
+    renderPriority?: number;
+};
+export declare function Fisheye({ renderPriority, zoom, segments, children, resolution, ...props }: FisheyeProps): React.JSX.Element;

package/core/Float.d.ts

@@ -0,0 +1,13 @@
+import * as React from 'react';
+import * as THREE from 'three';
+import { ForwardRefComponent } from '../helpers/ts-utils';
+export type FloatProps = JSX.IntrinsicElements['group'] & {
+    enabled?: boolean;
+    speed?: number;
+    rotationIntensity?: number;
+    floatIntensity?: number;
+    children?: React.ReactNode;
+    floatingRange?: [number?, number?];
+    autoInvalidate?: boolean;
+};
+export declare const Float: ForwardRefComponent<FloatProps, THREE.Group>;

package/core/FlyControls.d.ts

@@ -0,0 +1,10 @@
+import { ReactThreeFiber } from '@react-three/fiber';
+import * as THREE from 'three';
+import { FlyControls as FlyControlsImpl } from 'three-stdlib';
+import { ForwardRefComponent } from '../helpers/ts-utils';
+export type FlyControlsProps = ReactThreeFiber.Object3DNode<FlyControlsImpl, typeof FlyControlsImpl> & {
+    onChange?: (e?: THREE.Event) => void;
+    domElement?: HTMLElement;
+    makeDefault?: boolean;
+};
+export declare const FlyControls: ForwardRefComponent<FlyControlsProps, FlyControlsImpl>;

package/core/GizmoHelper.d.ts

@@ -0,0 +1,15 @@
+import { Vector3 } from 'three';
+type GizmoHelperContext = {
+    tweenCamera: (direction: Vector3) => void;
+};
+export declare const useGizmoContext: () => GizmoHelperContext;
+export type GizmoHelperProps = JSX.IntrinsicElements['group'] & {
+    alignment?: 'top-left' | 'top-right' | 'bottom-right' | 'bottom-left' | 'bottom-center' | 'center-right' | 'center-left' | 'center-center' | 'top-center';
+    margin?: [number, number];
+    renderPriority?: number;
+    autoClear?: boolean;
+    onUpdate?: () => void;
+    onTarget?: () => Vector3;
+};
+export declare const GizmoHelper: ({ alignment, margin, renderPriority, onUpdate, onTarget, children, }: GizmoHelperProps) => any;
+export {};

package/core/GizmoViewcube.d.ts

@@ -0,0 +1,14 @@
+import * as React from 'react';
+import { ThreeEvent } from '@react-three/fiber';
+type GenericProps = {
+    font?: string;
+    opacity?: number;
+    color?: string;
+    hoverColor?: string;
+    textColor?: string;
+    strokeColor?: string;
+    onClick?: (e: ThreeEvent<MouseEvent>) => null;
+    faces?: string[];
+};
+export declare const GizmoViewcube: (props: GenericProps) => React.JSX.Element;
+export {};

package/core/GizmoViewport.d.ts

@@ -0,0 +1,16 @@
+import * as React from 'react';
+import { ThreeEvent } from '@react-three/fiber';
+type GizmoViewportProps = JSX.IntrinsicElements['group'] & {
+    axisColors?: [string, string, string];
+    axisScale?: [number, number, number];
+    labels?: [string, string, string];
+    axisHeadScale?: number;
+    labelColor?: string;
+    hideNegativeAxes?: boolean;
+    hideAxisHeads?: boolean;
+    disabled?: boolean;
+    font?: string;
+    onClick?: (e: ThreeEvent<MouseEvent>) => null;
+};
+export declare const GizmoViewport: ({ hideNegativeAxes, hideAxisHeads, disabled, font, axisColors, axisHeadScale, axisScale, labels, labelColor, onClick, ...props }: GizmoViewportProps) => React.JSX.Element;
+export {};

package/core/Gltf.d.ts

@@ -0,0 +1,20 @@
+import * as React from 'react';
+import { Clone } from './Clone';
+import { type GLTF, GLTFLoader } from 'three-stdlib';
+import { type ObjectMap } from '@react-three/fiber';
+export declare function useGLTF<T extends string | string[]>(path: T, useDraco?: boolean | string, useMeshOpt?: boolean, extendLoader?: (loader: GLTFLoader) => void): T extends any[] ? (GLTF & ObjectMap)[] : GLTF & ObjectMap;
+export declare namespace useGLTF {
+    var preload: (path: string | string[], useDraco?: string | boolean, useMeshOpt?: boolean, extendLoader?: ((loader: GLTFLoader) => void) | undefined) => undefined;
+    var clear: (input: string | string[]) => void;
+    var setDecoderPath: (path: string) => void;
+}
+type UseGLTF = Parameters<typeof useGLTF>;
+type CloneProps = React.ComponentProps<typeof Clone>;
+type GltfProps = Omit<CloneProps, 'object'> & {
+    src: string;
+    useDraco?: UseGLTF[1];
+    useMeshOpt?: UseGLTF[2];
+    extendLoader?: UseGLTF[3];
+};
+export declare const Gltf: React.ForwardRefExoticComponent<Omit<GltfProps, "ref"> & React.RefAttributes<import("three").Group>>;
+export {};

package/core/GradientTexture.d.ts

@@ -0,0 +1,18 @@
+import * as React from 'react';
+import * as THREE from 'three';
+export declare enum GradientType {
+    Linear = "linear",
+    Radial = "radial"
+}
+type Props = {
+    stops: Array<number>;
+    colors: Array<THREE.ColorRepresentation>;
+    attach?: string;
+    size?: number;
+    width?: number;
+    type?: GradientType;
+    innerCircleRadius?: number;
+    outerCircleRadius?: string | number;
+} & JSX.IntrinsicElements['texture'];
+export declare function GradientTexture({ stops, colors, size, width, type, innerCircleRadius, outerCircleRadius, ...props }: Props): React.JSX.Element;
+export {};

package/core/Grid.d.ts

@@ -0,0 +1,27 @@
+import * as THREE from 'three';
+import { ForwardRefComponent } from '../helpers/ts-utils';
+export type GridMaterialType = {
+    cellSize?: number;
+    cellThickness?: number;
+    cellColor?: THREE.ColorRepresentation;
+    sectionSize?: number;
+    sectionThickness?: number;
+    sectionColor?: THREE.ColorRepresentation;
+    followCamera?: boolean;
+    infiniteGrid?: boolean;
+    fadeDistance?: number;
+    fadeStrength?: number;
+    fadeFrom?: number;
+    side?: THREE.Side;
+};
+export type GridProps = GridMaterialType & {
+    args?: ConstructorParameters<typeof THREE.PlaneGeometry>;
+};
+declare global {
+    namespace JSX {
+        interface IntrinsicElements {
+            gridMaterial: JSX.IntrinsicElements['shaderMaterial'] & GridMaterialType;
+        }
+    }
+}
+export declare const Grid: ForwardRefComponent<Omit<JSX.IntrinsicElements['mesh'], 'args'> & GridProps, THREE.Mesh>;

package/core/Helper.d.ts

@@ -0,0 +1,16 @@
+import * as React from 'react';
+import { Object3D } from 'three';
+import { Falsey } from 'utility-types';
+type HelperType = Object3D & {
+    update: () => void;
+    dispose: () => void;
+};
+type HelperConstructor = new (...args: any[]) => any;
+type HelperArgs<T> = T extends [infer _, ...infer R] ? R : never;
+export declare function useHelper<T extends HelperConstructor>(object3D: React.MutableRefObject<Object3D> | Falsey, helperConstructor: T, ...args: HelperArgs<ConstructorParameters<T>>): React.MutableRefObject<HelperType | undefined>;
+export type HelperProps<T extends HelperConstructor> = {
+    type: T;
+    args?: HelperArgs<ConstructorParameters<T>>;
+};
+export declare const Helper: <T extends HelperConstructor>({ type: helperConstructor, args, }: HelperProps<T>) => React.JSX.Element;
+export {};

package/core/Hud.d.ts

@@ -0,0 +1,7 @@
+import * as React from 'react';
+type HudProps = {
+    children: React.ReactNode;
+    renderPriority?: number;
+};
+export declare function Hud({ children, renderPriority }: HudProps): React.JSX.Element;
+export {};

package/core/Image.d.ts

@@ -0,0 +1,40 @@
+import * as THREE from 'three';
+import { Color } from '@react-three/fiber';
+import { ForwardRefComponent } from '../helpers/ts-utils';
+export type ImageProps = Omit<JSX.IntrinsicElements['mesh'], 'scale'> & {
+    segments?: number;
+    scale?: number | [number, number];
+    color?: Color;
+    zoom?: number;
+    radius?: number;
+    grayscale?: number;
+    toneMapped?: boolean;
+    transparent?: boolean;
+    opacity?: number;
+    side?: THREE.Side;
+} & ({
+    texture: THREE.Texture;
+    url?: never;
+} | {
+    texture?: never;
+    url: string;
+});
+type ImageMaterialType = JSX.IntrinsicElements['shaderMaterial'] & {
+    scale?: number[];
+    imageBounds?: number[];
+    radius?: number;
+    resolution?: number;
+    color?: Color;
+    map: THREE.Texture;
+    zoom?: number;
+    grayscale?: number;
+};
+declare global {
+    namespace JSX {
+        interface IntrinsicElements {
+            imageMaterial: ImageMaterialType;
+        }
+    }
+}
+export declare const Image: ForwardRefComponent<ImageProps, THREE.Mesh>;
+export {};

package/core/Instances.d.ts

@@ -0,0 +1,43 @@
+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 {
+            positionMesh: ReactThreeFiber.Object3DNode<PositionMesh, typeof PositionMesh>;
+        }
+    }
+}
+type Api = {
+    getParent: () => React.MutableRefObject<InstancedMesh>;
+    subscribe: <T>(ref: React.MutableRefObject<T>) => void;
+};
+export type InstancesProps = JSX.IntrinsicElements['instancedMesh'] & {
+    range?: number;
+    limit?: number;
+    frames?: number;
+};
+export type InstanceProps = JSX.IntrinsicElements['positionMesh'] & {
+    context?: React.Context<Api>;
+};
+type InstancedMesh = Omit<THREE.InstancedMesh, 'instanceMatrix' | 'instanceColor'> & {
+    instanceMatrix: THREE.InstancedBufferAttribute;
+    instanceColor: THREE.InstancedBufferAttribute;
+};
+declare class PositionMesh extends THREE.Group {
+    color: THREE.Color;
+    instance: React.MutableRefObject<THREE.InstancedMesh | undefined>;
+    instanceKey: React.MutableRefObject<JSX.IntrinsicElements['positionMesh'] | undefined>;
+    constructor();
+    get geometry(): THREE.BufferGeometry | undefined;
+    raycast(raycaster: THREE.Raycaster, intersects: THREE.Intersection[]): void;
+}
+export declare const Instance: React.ForwardRefExoticComponent<Omit<InstanceProps, "ref"> & React.RefAttributes<unknown>>;
+export declare const Instances: ForwardRefComponent<InstancesProps, InstancedMesh>;
+export interface MergedProps extends InstancesProps {
+    meshes: THREE.Mesh[];
+    children: React.ReactNode;
+}
+export declare const Merged: ForwardRefComponent<any, THREE.Group>;
+export {};

package/core/Ktx2.d.ts

@@ -0,0 +1,14 @@
+import * as React from 'react';
+import { Texture } from 'three';
+export declare function useKTX2<Url extends string[] | string | Record<string, string>>(input: Url, basisPath?: string): Url extends any[] ? Texture[] : Url extends object ? {
+    [key in keyof Url]: Texture;
+} : Texture;
+export declare namespace useKTX2 {
+    var preload: (url: string, basisPath?: string) => undefined;
+    var clear: (input: string | string[]) => void;
+}
+export declare const Ktx2: ({ children, input, basisPath, }: {
+    children?: (texture: ReturnType<typeof useKTX2>) => React.ReactNode;
+    input: Parameters<typeof useKTX2>[0];
+    basisPath?: Parameters<typeof useKTX2>[1];
+}) => React.JSX.Element;

package/core/Lightformer.d.ts

@@ -0,0 +1,14 @@
+import { ReactThreeFiber } from '@react-three/fiber';
+import * as THREE from 'three';
+import { ForwardRefComponent } from '../helpers/ts-utils';
+export type LightProps = JSX.IntrinsicElements['mesh'] & {
+    args?: any[];
+    map?: THREE.Texture;
+    toneMapped?: boolean;
+    color?: ReactThreeFiber.Color;
+    form?: 'circle' | 'ring' | 'rect' | any;
+    scale?: number | [number, number, number] | [number, number];
+    intensity?: number;
+    target?: [number, number, number] | THREE.Vector3;
+};
+export declare const Lightformer: ForwardRefComponent<LightProps, THREE.Mesh>;

package/core/Line.d.ts

@@ -0,0 +1,13 @@
+import { Vector2, Vector3, Color, ColorRepresentation } from 'three';
+import { ReactThreeFiber } from '@react-three/fiber';
+import { LineMaterial, LineMaterialParameters, Line2, LineSegments2 } from 'three-stdlib';
+import { ForwardRefComponent } from '../helpers/ts-utils';
+export type LineProps = {
+    points: Array<Vector3 | Vector2 | [number, number, number] | [number, number] | number>;
+    vertexColors?: Array<Color | [number, number, number] | [number, number, number, number]>;
+    lineWidth?: number;
+    segments?: boolean;
+} & Omit<LineMaterialParameters, 'vertexColors' | 'color'> & Omit<ReactThreeFiber.Object3DNode<Line2, typeof Line2>, 'args'> & Omit<ReactThreeFiber.Object3DNode<LineMaterial, [LineMaterialParameters]>, 'color' | 'vertexColors' | 'args'> & {
+    color?: ColorRepresentation;
+};
+export declare const Line: ForwardRefComponent<LineProps, Line2 | LineSegments2>;

package/core/MapControls.d.ts

@@ -0,0 +1,14 @@
+import { ReactThreeFiber } from '@react-three/fiber';
+import * as THREE from 'three';
+import { MapControls as MapControlsImpl } from 'three-stdlib';
+import { ForwardRefComponent } from '../helpers/ts-utils';
+export type MapControlsProps = ReactThreeFiber.Overwrite<ReactThreeFiber.Object3DNode<MapControlsImpl, typeof MapControlsImpl>, {
+    target?: ReactThreeFiber.Vector3;
+    camera?: THREE.Camera;
+    makeDefault?: boolean;
+    onChange?: (e?: THREE.Event) => void;
+    onStart?: (e?: THREE.Event) => void;
+    onEnd?: (e?: THREE.Event) => void;
+    domElement?: HTMLElement;
+}>;
+export declare const MapControls: ForwardRefComponent<MapControlsProps, MapControlsImpl>;

package/core/MarchingCubes.d.ts

@@ -0,0 +1,24 @@
+import * as THREE from 'three';
+import { Color } from 'three';
+import { MarchingCubes as MarchingCubesImpl } from 'three-stdlib';
+import { ForwardRefComponent } from '../helpers/ts-utils';
+export type MarchingCubesProps = {
+    resolution?: number;
+    maxPolyCount?: number;
+    enableUvs?: boolean;
+    enableColors?: boolean;
+} & JSX.IntrinsicElements['group'];
+export declare const MarchingCubes: ForwardRefComponent<MarchingCubesProps, MarchingCubesImpl>;
+type MarchingCubeProps = {
+    strength?: number;
+    subtract?: number;
+    color?: Color;
+} & JSX.IntrinsicElements['group'];
+export declare const MarchingCube: ForwardRefComponent<MarchingCubeProps, THREE.Group>;
+type MarchingPlaneProps = {
+    planeType?: 'x' | 'y' | 'z';
+    strength?: number;
+    subtract?: number;
+} & JSX.IntrinsicElements['group'];
+export declare const MarchingPlane: ForwardRefComponent<MarchingPlaneProps, THREE.Group>;
+export {};

package/core/Mask.d.ts

@@ -0,0 +1,17 @@
+import * as THREE from 'three';
+import { ForwardRefComponent } from '../helpers/ts-utils';
+type Props = Omit<JSX.IntrinsicElements['mesh'], 'id'> & {
+    id: number;
+    colorWrite?: boolean;
+    depthWrite?: boolean;
+};
+export declare const Mask: ForwardRefComponent<Props, THREE.Mesh>;
+export declare function useMask(id: number, inverse?: boolean): {
+    stencilWrite: boolean;
+    stencilRef: number;
+    stencilFunc: 514 | 517;
+    stencilFail: 7680;
+    stencilZFail: 7680;
+    stencilZPass: 7680;
+};
+export {};

package/core/MatcapTexture.d.ts

@@ -0,0 +1,9 @@
+import * as React from 'react';
+import { Texture } from 'three';
+export declare function useMatcapTexture(id?: number | string, format?: number, onLoad?: (texture: Texture | Texture[]) => void): [Texture, string, number];
+export declare const MatcapTexture: ({ children, id, format, onLoad, }: {
+    children?: (texture: ReturnType<typeof useMatcapTexture>) => React.ReactNode;
+    id?: Parameters<typeof useMatcapTexture>[0];
+    format?: Parameters<typeof useMatcapTexture>[1];
+    onLoad?: Parameters<typeof useMatcapTexture>[2];
+}) => React.JSX.Element;

package/core/MeshDiscardMaterial.d.ts

@@ -0,0 +1,11 @@
+import { ShaderMaterial } from 'three';
+import { ReactThreeFiber } from '@react-three/fiber';
+import { ForwardRefComponent } from '../helpers/ts-utils';
+declare global {
+    namespace JSX {
+        interface IntrinsicElements {
+            discardMaterialImpl: ReactThreeFiber.ShaderMaterialProps;
+        }
+    }
+}
+export declare const MeshDiscardMaterial: ForwardRefComponent<JSX.IntrinsicElements['shaderMaterial'], ShaderMaterial>;

package/core/MeshDistortMaterial.d.ts

@@ -0,0 +1,41 @@
+import { IUniform, MeshPhysicalMaterial, MeshPhysicalMaterialParameters } from 'three';
+import { ForwardRefComponent } from '../helpers/ts-utils';
+type DistortMaterialType = JSX.IntrinsicElements['meshPhysicalMaterial'] & {
+    time?: number;
+    distort?: number;
+    radius?: number;
+};
+type Props = DistortMaterialType & {
+    speed?: number;
+    factor?: number;
+};
+declare global {
+    namespace JSX {
+        interface IntrinsicElements {
+            distortMaterialImpl: DistortMaterialType;
+        }
+    }
+}
+interface Uniform<T> {
+    value: T;
+}
+declare class DistortMaterialImpl extends MeshPhysicalMaterial {
+    _time: Uniform<number>;
+    _distort: Uniform<number>;
+    _radius: Uniform<number>;
+    constructor(parameters?: MeshPhysicalMaterialParameters);
+    onBeforeCompile(shader: {
+        vertexShader: string;
+        uniforms: {
+            [uniform: string]: IUniform;
+        };
+    }): void;
+    get time(): number;
+    set time(v: number);
+    get distort(): number;
+    set distort(v: number);
+    get radius(): number;
+    set radius(v: number);
+}
+export declare const MeshDistortMaterial: ForwardRefComponent<Props, DistortMaterialImpl>;
+export {};

package/core/MeshPortalMaterial.d.ts

@@ -0,0 +1,28 @@
+import * as THREE from 'three';
+import * as React from 'react';
+import { ReactThreeFiber } from '@react-three/fiber';
+export type PortalMaterialType = {
+    resolution: ReactThreeFiber.Vector2;
+    blur: number;
+    blend: number;
+    size?: number;
+    sdf?: THREE.Texture;
+    map?: THREE.Texture;
+} & JSX.IntrinsicElements['shaderMaterial'];
+declare global {
+    namespace JSX {
+        interface IntrinsicElements {
+            portalMaterialImpl: PortalMaterialType;
+        }
+    }
+}
+export type PortalProps = JSX.IntrinsicElements['shaderMaterial'] & {
+    blend?: number;
+    blur?: number;
+    resolution?: number;
+    worldUnits?: boolean;
+    eventPriority?: number;
+    renderPriority?: number;
+    events?: boolean;
+};
+export declare const MeshPortalMaterial: React.ForwardRefExoticComponent<Omit<PortalProps, "ref"> & React.RefAttributes<PortalMaterialType>>;

package/core/MeshReflectorMaterial.d.ts

@@ -0,0 +1,27 @@
+import { Texture } from 'three';
+import { MeshReflectorMaterialProps, MeshReflectorMaterial as MeshReflectorMaterialImpl } from '../materials/MeshReflectorMaterial';
+import { ForwardRefComponent } from '../helpers/ts-utils';
+type Props = JSX.IntrinsicElements['meshStandardMaterial'] & {
+    resolution?: number;
+    mixBlur?: number;
+    mixStrength?: number;
+    blur?: [number, number] | number;
+    mirror: number;
+    minDepthThreshold?: number;
+    maxDepthThreshold?: number;
+    depthScale?: number;
+    depthToBlurRatioBias?: number;
+    distortionMap?: Texture;
+    distortion?: number;
+    mixContrast?: number;
+    reflectorOffset?: number;
+};
+declare global {
+    namespace JSX {
+        interface IntrinsicElements {
+            meshReflectorMaterialImpl: MeshReflectorMaterialProps;
+        }
+    }
+}
+export declare const MeshReflectorMaterial: ForwardRefComponent<Props, MeshReflectorMaterialImpl>;
+export {};

package/core/MeshRefractionMaterial.d.ts

@@ -0,0 +1,22 @@
+import * as THREE from 'three';
+import * as React from 'react';
+import { ReactThreeFiber } from '@react-three/fiber';
+import { MeshRefractionMaterial as MeshRefractionMaterial_ } from '../materials/MeshRefractionMaterial';
+declare global {
+    namespace JSX {
+        interface IntrinsicElements {
+            meshRefractionMaterial: typeof MeshRefractionMaterial_;
+        }
+    }
+}
+type MeshRefractionMaterialProps = JSX.IntrinsicElements['shaderMaterial'] & {
+    envMap: THREE.CubeTexture | THREE.Texture;
+    bounces?: number;
+    ior?: number;
+    fresnel?: number;
+    aberrationStrength?: number;
+    color?: ReactThreeFiber.Color;
+    fastChroma?: boolean;
+};
+export declare function MeshRefractionMaterial({ aberrationStrength, fastChroma, envMap, ...props }: MeshRefractionMaterialProps): React.JSX.Element;
+export {};

package/core/MeshTransmissionMaterial.d.ts

@@ -0,0 +1,35 @@
+import * as THREE from 'three';
+import { ForwardRefComponent } from '../helpers/ts-utils';
+type MeshTransmissionMaterialType = Omit<JSX.IntrinsicElements['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];
+};
+type MeshTransmissionMaterialProps = Omit<MeshTransmissionMaterialType, 'args'> & {
+    transmissionSampler?: boolean;
+    backside?: boolean;
+    backsideThickness?: number;
+    backsideEnvMapIntensity?: number;
+    resolution?: number;
+    backsideResolution?: number;
+    samples?: number;
+    background?: THREE.Texture | THREE.Color;
+};
+declare global {
+    namespace JSX {
+        interface IntrinsicElements {
+            meshTransmissionMaterial: MeshTransmissionMaterialType;
+        }
+    }
+}
+export declare const MeshTransmissionMaterial: ForwardRefComponent<MeshTransmissionMaterialProps, JSX.IntrinsicElements['meshTransmissionMaterial']>;
+export {};

package/core/MeshWobbleMaterial.d.ts

@@ -0,0 +1,38 @@
+import { IUniform, MeshStandardMaterial, MeshStandardMaterialParameters } from 'three';
+import { ForwardRefComponent } from '../helpers/ts-utils';
+type WobbleMaterialType = JSX.IntrinsicElements['meshStandardMaterial'] & {
+    time?: number;
+    factor?: number;
+    speed?: number;
+};
+type Props = WobbleMaterialType & {
+    speed?: number;
+    factor?: number;
+};
+declare global {
+    namespace JSX {
+        interface IntrinsicElements {
+            wobbleMaterialImpl: WobbleMaterialType;
+        }
+    }
+}
+interface Uniform<T> {
+    value: T;
+}
+declare class WobbleMaterialImpl extends MeshStandardMaterial {
+    _time: Uniform<number>;
+    _factor: Uniform<number>;
+    constructor(parameters?: MeshStandardMaterialParameters);
+    onBeforeCompile(shader: {
+        vertexShader: string;
+        uniforms: {
+            [uniform: string]: IUniform;
+        };
+    }): void;
+    get time(): number;
+    set time(v: number);
+    get factor(): number;
+    set factor(v: number);
+}
+export declare const MeshWobbleMaterial: ForwardRefComponent<Props, WobbleMaterialImpl>;
+export {};