@react-three/drei 11.0.0-alpha.6 → 11.0.0-alpha.7

package/webgpu/index.d.ts

@@ -3,8 +3,8 @@ import { ForwardRefExoticComponent, PropsWithoutRef, RefAttributes, CSSPropertie
 import * as _react_three_fiber from '@react-three/fiber';
 import { ThreeElements, ReactThreeFiber, ComputeFunction, Vector2, Vector3, ThreeElement, ThreeEvent, Color as Color$1, ObjectMap, Euler } from '@react-three/fiber';
 import * as THREE from 'three/webgpu';
-import { MeshBasicNodeMaterial, MeshNormalNodeMaterial, MeshPhysicalNodeMaterial, Material, CubeRenderTarget, Color, ColorRepresentation, Object3D, Texture as Texture$1, Fog, FogExp2, CubeCamera as CubeCamera$1, OrthographicCamera as OrthographicCamera$1, PerspectiveCamera as PerspectiveCamera$1, Event, EventDispatcher, Camera, Matrix4, Vector3 as Vector3$1, Group, LOD, Mesh, ExtrudeGeometry, PositionalAudio as PositionalAudio$1, AnimationClip, AnimationMixer, AnimationAction, BufferGeometry, BufferAttribute, InstancedMesh as InstancedMesh$1, InstancedBufferAttribute, DepthTexture, CubeTexture as CubeTexture$1, Raycaster, Intersection, RenderTargetOptions, Box3, Sphere as Sphere$1, Loader as Loader$1, ColorSpace, Scene, PlaneGeometry, MeshBasicMaterial, SpriteNodeMaterial, ShadowNode, Light, SpotLight as SpotLight$1 } from 'three/webgpu';
-import { reflector, Fn } from 'three/tsl';
+import { Material, UniformNode, TextureNode, Texture as Texture$1, MeshNormalNodeMaterial, CubeRenderTarget, Color, ColorRepresentation, Object3D, Fog, FogExp2, CubeCamera as CubeCamera$1, OrthographicCamera as OrthographicCamera$1, PerspectiveCamera as PerspectiveCamera$1, Event, EventDispatcher, Camera, Matrix4, Vector3 as Vector3$1, Group, LOD, Mesh, ExtrudeGeometry, PositionalAudio as PositionalAudio$1, AnimationClip, AnimationMixer, AnimationAction, BufferGeometry, BufferAttribute, InstancedMesh as InstancedMesh$1, InstancedBufferAttribute, DepthTexture, CubeTexture as CubeTexture$1, Raycaster, Intersection, RenderTargetOptions, Box3, Sphere as Sphere$1, Loader as Loader$1, ColorSpace, Scene, PlaneGeometry, MeshBasicMaterial, QuadMesh, MeshBasicNodeMaterial, SpriteNodeMaterial, ShadowNode, Light, SpotLight as SpotLight$1 } from 'three/webgpu';
+import { reflector } from 'three/tsl';
 import { LineSegments2 } from 'three/examples/jsm/lines/webgpu/LineSegments2.js';
 import { ArcballControls as ArcballControls$1 } from 'three/examples/jsm/controls/ArcballControls.js';
 import { FirstPersonControls as FirstPersonControls$1 } from 'three/examples/jsm/controls/FirstPersonControls.js';
@@ -57,6 +57,27 @@ type ContactShadowsProps = Omit<ThreeElements['group'], 'ref' | 'scale'> & {
 };
 declare const ContactShadows: ForwardRefComponent<ContactShadowsProps, THREE.Group>;
 
+type AnyCtor = new (...args: any[]) => Material;
+type UniformFactory = () => UniformNode<any, any> | TextureNode;
+type ReservedUniformName<B extends AnyCtor> = keyof InstanceType<B> | `_${string}` | 'uniforms';
+type UniformTable<B extends AnyCtor, U> = {
+    [K in keyof U]: K extends ReservedUniformName<B> ? never : UniformFactory;
+};
+type UniformValue<F> = F extends () => TextureNode ? Texture$1 | null : F extends () => UniformNode<any, infer V> ? V : never;
+type UniformProps<U> = {
+    [K in keyof U]: UniformValue<U[K]>;
+};
+type UniformNodes<U extends Record<string, UniformFactory>> = {
+    [K in keyof U]: ReturnType<U[K]>;
+};
+type UniformParameters<B extends AnyCtor, U> = NonNullable<ConstructorParameters<B>[0]> & Partial<UniformProps<U>>;
+type WithUniforms<B extends AnyCtor, U extends Record<string, UniformFactory>> = Omit<B, 'prototype'> & {
+    new (parameters?: UniformParameters<B, U>, ...rest: any[]): InstanceType<B> & UniformProps<U> & {
+        readonly uniforms: UniformNodes<U>;
+    };
+};
+declare function withUniforms<B extends AnyCtor, U extends Record<string, UniformFactory>>(Base: B, table: UniformTable<B, U> & U): WithUniforms<B, U>;
+
 type AccumulativeShadowsProps = Omit<ThreeElements['group'], 'ref'> & {
     frames?: number;
     blend?: number;
@@ -84,24 +105,13 @@ interface AccumulativeLightContext {
     update: () => void;
 }
 declare const accumulativeContext: React.Context<AccumulativeContext>;
-declare class SoftShadowMaterialImpl extends MeshBasicNodeMaterial {
-    private _color;
-    private _blend;
-    private _alphaTest;
-    private _opacity;
-    private _map;
+declare const SoftShadowMaterialImpl_base: WithUniforms<typeof THREE.MeshBasicNodeMaterial, {
+    shadowColor: () => THREE.UniformNode<"color", THREE.Color>;
+    blend: () => THREE.UniformNode<"float", number>;
+}>;
+declare class SoftShadowMaterialImpl extends SoftShadowMaterialImpl_base {
     constructor();
     private _buildShader;
-    get shadowColor(): THREE.ColorRepresentation;
-    set shadowColor(v: THREE.ColorRepresentation);
-    get blend(): number;
-    set blend(v: number);
-    get alphaTest(): number;
-    set alphaTest(v: number);
-    get opacity(): number;
-    set opacity(v: number);
-    get map(): THREE.Texture;
-    set map(v: THREE.Texture);
 }
 declare const AccumulativeShadows: ForwardRefComponent<AccumulativeShadowsProps, AccumulativeContext>;
 type RandomizedLightProps = Omit<ThreeElements['group'], 'ref'> & {
@@ -133,70 +143,35 @@ type CausticsProps = Omit<ThreeElements['group'], 'ref'> & {
     resolution?: number;
     lightSource?: [x: number, y: number, z: number] | React.RefObject<THREE.Object3D>;
 };
-declare class CausticsProjectionMaterial extends MeshBasicNodeMaterial {
-    private _causticsTexture;
-    private _causticsTextureB;
-    private _color;
-    private _lightProjMatrix;
-    private _lightViewMatrix;
+declare const CausticsProjectionMaterial_base: WithUniforms<typeof THREE.MeshBasicNodeMaterial, {
+    causticsTexture: () => THREE.TextureNode<"vec4">;
+    causticsTextureB: () => THREE.TextureNode<"vec4">;
+    lightProjMatrix: () => THREE.UniformNode<"mat4", THREE.Matrix4>;
+    lightViewMatrix: () => THREE.UniformNode<"mat4", THREE.Matrix4>;
+}>;
+declare class CausticsProjectionMaterial extends CausticsProjectionMaterial_base {
     constructor();
     private _buildShader;
-    get causticsTexture(): THREE.Texture;
-    set causticsTexture(v: THREE.Texture);
-    get causticsTextureB(): THREE.Texture;
-    set causticsTextureB(v: THREE.Texture);
-    get color(): THREE.Color;
-    set color(v: THREE.Color);
-    get lightProjMatrix(): THREE.Matrix4;
-    set lightProjMatrix(v: THREE.Matrix4);
-    get lightViewMatrix(): THREE.Matrix4;
-    set lightViewMatrix(v: THREE.Matrix4);
-}
-declare class CausticsMaterial extends MeshBasicNodeMaterial {
-    private _cameraMatrixWorld;
-    private _cameraProjectionMatrixInv;
-    private _normalTexture;
-    private _depthTexture;
-    private _lightDir;
-    private _lightPlaneNormal;
-    private _lightPlaneConstant;
-    private _near;
-    private _far;
-    private _worldRadius;
-    private _ior;
-    private _resolution;
-    private _size;
-    private _intensity;
+}
+declare const CausticsMaterial_base: WithUniforms<typeof THREE.MeshBasicNodeMaterial, {
+    cameraMatrixWorld: () => THREE.UniformNode<"mat4", THREE.Matrix4>;
+    cameraProjectionMatrixInv: () => THREE.UniformNode<"mat4", THREE.Matrix4>;
+    normalTexture: () => THREE.TextureNode<"vec4">;
+    depthTexture: () => THREE.TextureNode<"vec4">;
+    lightDir: () => THREE.UniformNode<"vec3", THREE.Vector3>;
+    lightPlaneNormal: () => THREE.UniformNode<"vec3", THREE.Vector3>;
+    lightPlaneConstant: () => THREE.UniformNode<"float", number>;
+    near: () => THREE.UniformNode<"float", number>;
+    far: () => THREE.UniformNode<"float", number>;
+    worldRadius: () => THREE.UniformNode<"float", number>;
+    ior: () => THREE.UniformNode<"float", number>;
+    resolution: () => THREE.UniformNode<"float", number>;
+    size: () => THREE.UniformNode<"float", number>;
+    intensity: () => THREE.UniformNode<"float", number>;
+}>;
+declare class CausticsMaterial extends CausticsMaterial_base {
     constructor();
     private _buildShader;
-    get cameraMatrixWorld(): THREE.Matrix4;
-    set cameraMatrixWorld(v: THREE.Matrix4);
-    get cameraProjectionMatrixInv(): THREE.Matrix4;
-    set cameraProjectionMatrixInv(v: THREE.Matrix4);
-    get normalTexture(): THREE.Texture | null;
-    set normalTexture(v: THREE.Texture | null);
-    get depthTexture(): THREE.Texture | null;
-    set depthTexture(v: THREE.Texture | null);
-    get lightDir(): THREE.Vector3;
-    set lightDir(v: THREE.Vector3);
-    get lightPlaneNormal(): THREE.Vector3;
-    set lightPlaneNormal(v: THREE.Vector3);
-    get lightPlaneConstant(): number;
-    set lightPlaneConstant(v: number);
-    get near(): number;
-    set near(v: number);
-    get far(): number;
-    set far(v: number);
-    get worldRadius(): number;
-    set worldRadius(v: number);
-    get ior(): number;
-    set ior(v: number);
-    get resolution(): number;
-    set resolution(v: number);
-    get size(): number;
-    set size(v: number);
-    get intensity(): number;
-    set intensity(v: number);
 }
 declare class CausticsNormalMaterial extends MeshNormalNodeMaterial {
     constructor(side?: THREE.Side);
@@ -248,43 +223,23 @@ interface MeshReflectorMaterialOptions {
     mixContrast?: number;
     reflectorOffset?: number;
 }
-declare class MeshReflectorMaterial$1 extends THREE.MeshStandardNodeMaterial {
+declare const MeshReflectorMaterial_base: WithUniforms<typeof THREE.MeshStandardNodeMaterial, {
+    mirror: () => THREE.UniformNode<"float", number>;
+    mixBlur: () => THREE.UniformNode<"float", number>;
+    mixStrength: () => THREE.UniformNode<"float", number>;
+    minDepthThreshold: () => THREE.UniformNode<"float", number>;
+    maxDepthThreshold: () => THREE.UniformNode<"float", number>;
+    depthScale: () => THREE.UniformNode<"float", number>;
+    depthToBlurRatioBias: () => THREE.UniformNode<"float", number>;
+    distortion: () => THREE.UniformNode<"float", number>;
+    mixContrast: () => THREE.UniformNode<"float", number>;
+    blurRadius: () => THREE.UniformNode<"float", number>;
+}>;
+declare class MeshReflectorMaterial$1 extends MeshReflectorMaterial_base {
     reflection: ReturnType<typeof reflector>;
-    mirrorUniform: THREE.UniformNode<'float', number>;
-    mixBlurUniform: THREE.UniformNode<'float', number>;
-    mixStrengthUniform: THREE.UniformNode<'float', number>;
-    minDepthThresholdUniform: THREE.UniformNode<'float', number>;
-    maxDepthThresholdUniform: THREE.UniformNode<'float', number>;
-    depthScaleUniform: THREE.UniformNode<'float', number>;
-    depthToBlurRatioBiasUniform: THREE.UniformNode<'float', number>;
-    distortionUniform: THREE.UniformNode<'float', number>;
-    mixContrastUniform: THREE.UniformNode<'float', number>;
-    blurRadiusUniform: THREE.UniformNode<'float', number>;
-    hasBlurUniform: THREE.UniformNode<'float', number>;
-    hasDepthUniform: THREE.UniformNode<'float', number>;
+    get reflectorTarget(): THREE.Object3D;
     constructor(options?: MeshReflectorMaterialOptions, parameters?: THREE.MeshStandardMaterialParameters);
     private setupNodes;
-    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);
-    get blurRadius(): number;
-    set blurRadius(v: number);
-    get reflectorTarget(): THREE.Object3D;
 }
 
 declare module '@react-three/fiber' {
@@ -335,32 +290,17 @@ declare module '@react-three/fiber' {
         meshRefractionMaterial: MeshRefractionMaterialType;
     }
 }
-declare class MeshRefractionMaterialImpl extends MeshPhysicalNodeMaterial {
-    private _envMap;
-    private _bounces;
-    private _ior;
-    private _fresnel;
-    private _aberrationStrength;
-    private _color;
-    private _opacityValue;
+declare const MeshRefractionMaterialImpl_base: WithUniforms<typeof THREE.MeshPhysicalNodeMaterial, {
+    bounces: () => THREE.UniformNode<"float", number>;
+    fresnel: () => THREE.UniformNode<"float", number>;
+    aberrationStrength: () => THREE.UniformNode<"float", number>;
+    tintColor: () => THREE.UniformNode<"color", THREE.Color>;
+}>;
+declare class MeshRefractionMaterialImpl extends MeshRefractionMaterialImpl_base {
     private _fastChroma;
     readonly isMeshRefractionMaterial = true;
     constructor(fastChroma?: boolean);
     private _buildRefractionShader;
-    get envMap(): THREE.Texture | THREE.CubeTexture | null;
-    set envMap(v: THREE.Texture | THREE.CubeTexture | null);
-    get bounces(): number;
-    set bounces(v: number);
-    get ior(): number;
-    set ior(v: number);
-    get fresnel(): number;
-    set fresnel(v: number);
-    get aberrationStrength(): number;
-    set aberrationStrength(v: number);
-    get tintColor(): THREE.Color;
-    set tintColor(v: THREE.Color | THREE.ColorRepresentation);
-    get opacity(): number;
-    set opacity(v: number);
 }
 declare const MeshRefractionMaterial: ForwardRefComponent<MeshRefractionMaterialProps, MeshRefractionMaterialImpl>;
 
@@ -374,41 +314,26 @@ type PortalProps = Omit<ThreeElements['meshBasicMaterial'], 'ref'> & {
     events?: boolean;
     children?: React.ReactNode;
 };
-declare class PortalMaterialImpl extends MeshBasicNodeMaterial {
-    private _blur;
-    private _map;
-    private _sdf;
-    private _blend;
-    private _size;
-    private _resolution;
+declare const PortalMaterialImpl_base: WithUniforms<typeof THREE.MeshBasicNodeMaterial, {
+    blur: () => THREE.UniformNode<"float", number>;
+    sdf: () => THREE.TextureNode<"vec4">;
+    blend: () => THREE.UniformNode<"float", number>;
+    size: () => THREE.UniformNode<"float", number>;
+    resolution: () => THREE.UniformNode<"vec2", THREE.Vector2>;
+}>;
+declare class PortalMaterialImpl extends PortalMaterialImpl_base {
     constructor();
     private _buildShader;
-    get blur(): number;
-    set blur(v: number);
-    get map(): THREE.Texture | null;
-    set map(v: THREE.Texture | null);
-    get sdf(): THREE.Texture | null;
-    set sdf(v: THREE.Texture | null);
-    get blend(): number;
-    set blend(v: number);
-    get size(): number;
-    set size(v: number);
-    get resolution(): THREE.Vector2 | [number, number];
-    set resolution(v: THREE.Vector2 | [number, number]);
 }
 declare const MeshPortalMaterial: ForwardRefComponent<PortalProps, PortalMaterialImpl>;
 
-declare class DistortMaterialImplWebGPU extends THREE.MeshPhysicalNodeMaterial {
-    timeUniform: THREE.UniformNode<'float', number>;
-    distortUniform: THREE.UniformNode<'float', number>;
-    radiusUniform: THREE.UniformNode<'float', number>;
+declare const DistortMaterialImplWebGPU_base: WithUniforms<typeof THREE.MeshPhysicalNodeMaterial, {
+    time: () => THREE.UniformNode<"float", number>;
+    distort: () => THREE.UniformNode<"float", number>;
+    radius: () => THREE.UniformNode<"float", number>;
+}>;
+declare class DistortMaterialImplWebGPU extends DistortMaterialImplWebGPU_base {
     constructor(parameters?: THREE.MeshPhysicalMaterialParameters);
-    get time(): number;
-    set time(v: number);
-    get distort(): number;
-    set distort(v: number);
-    get radius(): number;
-    set radius(v: number);
 }
 declare module '@react-three/fiber' {
     interface ThreeElements {
@@ -425,14 +350,12 @@ type MeshDistortMaterialProps = Omit<ThreeElements['distortMaterialImplWebGPU'],
 };
 declare const MeshDistortMaterial: ForwardRefComponent<MeshDistortMaterialProps, DistortMaterialImplWebGPU>;
 
-declare class WobbleMaterialImpl extends THREE.MeshStandardNodeMaterial {
-    timeUniform: THREE.UniformNode<'float', number>;
-    factorUniform: THREE.UniformNode<'float', number>;
+declare const WobbleMaterialImpl_base: WithUniforms<typeof THREE.MeshStandardNodeMaterial, {
+    time: () => THREE.UniformNode<"float", number>;
+    factor: () => THREE.UniformNode<"float", number>;
+}>;
+declare class WobbleMaterialImpl extends WobbleMaterialImpl_base {
     constructor(parameters?: THREE.MeshStandardMaterialParameters);
-    get time(): number;
-    set time(v: number);
-    get factor(): number;
-    set factor(v: number);
 }
 declare module '@react-three/fiber' {
     interface ThreeElements {
@@ -2270,55 +2193,27 @@ declare module '@react-three/fiber' {
         wireframeMaterial: WireframeMaterialType;
     }
 }
-declare class WireframeMaterialImpl extends MeshBasicNodeMaterial {
-    private _strokeOpacity;
-    private _fillOpacity;
-    private _fillMix;
-    private _thickness;
-    private _colorBackfaces;
-    private _dashInvert;
-    private _dash;
-    private _dashRepeats;
-    private _dashLength;
-    private _squeeze;
-    private _squeezeMin;
-    private _squeezeMax;
-    private _stroke;
-    private _backfaceStroke;
-    private _fill;
+declare const WireframeMaterialImpl_base: WithUniforms<typeof THREE.MeshBasicNodeMaterial, {
+    strokeOpacity: () => THREE.UniformNode<"float", number>;
+    fillOpacity: () => THREE.UniformNode<"float", number>;
+    fillMix: () => THREE.UniformNode<"float", number>;
+    thickness: () => THREE.UniformNode<"float", number>;
+    colorBackfaces: () => THREE.UniformNode<"bool", boolean>;
+    dashInvert: () => THREE.UniformNode<"bool", boolean>;
+    dash: () => THREE.UniformNode<"bool", boolean>;
+    dashRepeats: () => THREE.UniformNode<"float", number>;
+    dashLength: () => THREE.UniformNode<"float", number>;
+    squeeze: () => THREE.UniformNode<"bool", boolean>;
+    squeezeMin: () => THREE.UniformNode<"float", number>;
+    squeezeMax: () => THREE.UniformNode<"float", number>;
+    stroke: () => THREE.UniformNode<"color", THREE.Color>;
+    backfaceStroke: () => THREE.UniformNode<"color", THREE.Color>;
+    fill: () => THREE.UniformNode<"color", THREE.Color>;
+}>;
+declare class WireframeMaterialImpl extends WireframeMaterialImpl_base {
     readonly isWireframeMaterial = true;
     constructor();
     private _buildWireframeShader;
-    get strokeOpacity(): number;
-    set strokeOpacity(v: number);
-    get fillOpacity(): number;
-    set fillOpacity(v: number);
-    get fillMix(): number;
-    set fillMix(v: number);
-    get thickness(): number;
-    set thickness(v: number);
-    get colorBackfaces(): boolean;
-    set colorBackfaces(v: boolean);
-    get dashInvert(): boolean;
-    set dashInvert(v: boolean);
-    get dash(): boolean;
-    set dash(v: boolean);
-    get dashRepeats(): number;
-    set dashRepeats(v: number);
-    get dashLength(): number;
-    set dashLength(v: number);
-    get squeeze(): boolean;
-    set squeeze(v: boolean);
-    get squeezeMin(): number;
-    set squeezeMin(v: number);
-    get squeezeMax(): number;
-    set squeezeMax(v: number);
-    get stroke(): THREE.Color;
-    set stroke(v: THREE.Color | THREE.ColorRepresentation);
-    get backfaceStroke(): THREE.Color;
-    set backfaceStroke(v: THREE.Color | THREE.ColorRepresentation);
-    get fill(): THREE.Color;
-    set fill(v: THREE.Color | THREE.ColorRepresentation);
 }
 declare function setBarycentricCoordinates(geometry: THREE.BufferGeometry): THREE.BufferGeometry;
 declare const WireframeMaterial: ForwardRefComponent<WireframeMaterialProps, WireframeMaterialImpl>;
@@ -2358,57 +2253,56 @@ declare function Wireframe({ geometry: customGeometry, ...props }: WireframeProp
 
 declare function BakeShadows(): null;
 
-declare class ConvolutionMaterial extends MeshBasicNodeMaterial {
-    private _inputBuffer;
-    private _depthBuffer;
-    private _resolution;
-    private _texelSize;
-    private _halfTexelSize;
-    private _kernel;
-    private _scale;
-    private _cameraNear;
-    private _cameraFar;
-    private _minDepthThreshold;
-    private _maxDepthThreshold;
-    private _depthScale;
-    private _depthToBlurRatioBias;
-    private _useDepth;
+declare const ConvolutionMaterial_base: WithUniforms<typeof THREE.MeshBasicNodeMaterial, {
+    inputBuffer: () => THREE.TextureNode<"vec4">;
+    depthBuffer: () => THREE.TextureNode<"vec4">;
+    resolution: () => THREE.UniformNode<"vec2", THREE.Vector2>;
+    texelSize: () => THREE.UniformNode<"vec2", THREE.Vector2>;
+    halfTexelSize: () => THREE.UniformNode<"vec2", THREE.Vector2>;
+    kernelValue: () => THREE.UniformNode<"float", number>;
+    scale: () => THREE.UniformNode<"float", number>;
+    cameraNear: () => THREE.UniformNode<"float", number>;
+    cameraFar: () => THREE.UniformNode<"float", number>;
+    minDepthThreshold: () => THREE.UniformNode<"float", number>;
+    maxDepthThreshold: () => THREE.UniformNode<"float", number>;
+    depthScale: () => THREE.UniformNode<"float", number>;
+    depthToBlurRatioBias: () => THREE.UniformNode<"float", number>;
+    useDepth: () => THREE.UniformNode<"bool", boolean>;
+}>;
+declare class ConvolutionMaterial extends ConvolutionMaterial_base {
     readonly kernel: Float32Array;
     constructor(texelSize?: THREE.Vector2);
     private _buildShader;
     setTexelSize(x: number, y: number): void;
     setResolution(resolution: THREE.Vector2): void;
-    get inputBuffer(): THREE.Texture | null;
-    set inputBuffer(v: THREE.Texture | null);
-    get depthBuffer(): THREE.Texture | null;
-    set depthBuffer(v: THREE.Texture | null);
-    get resolution(): THREE.Vector2;
-    set resolution(v: THREE.Vector2);
-    get texelSize(): THREE.Vector2;
-    set texelSize(v: THREE.Vector2);
-    get halfTexelSize(): THREE.Vector2;
-    set halfTexelSize(v: THREE.Vector2);
-    get kernelValue(): number;
-    set kernelValue(v: number);
-    get scale(): number;
-    set scale(v: number);
-    get cameraNear(): number;
-    set cameraNear(v: number);
-    get cameraFar(): number;
-    set cameraFar(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 useDepth(): boolean;
-    set useDepth(v: boolean);
-}
-
-declare const DiscardMaterial: MeshBasicNodeMaterial;
+}
+
+interface BlurPassProps {
+    gl?: THREE.Renderer;
+    resolution: number;
+    width?: number;
+    height?: number;
+    minDepthThreshold?: number;
+    maxDepthThreshold?: number;
+    depthScale?: number;
+    depthToBlurRatioBias?: number;
+}
+declare class BlurPass {
+    readonly renderTargetA: THREE.RenderTarget;
+    readonly renderTargetB: THREE.RenderTarget;
+    readonly convolutionMaterial: ConvolutionMaterial;
+    readonly screen: QuadMesh;
+    renderToScreen: boolean;
+    constructor({ resolution, width, height, minDepthThreshold, maxDepthThreshold, depthScale, depthToBlurRatioBias, }: BlurPassProps);
+    render(renderer: THREE.Renderer, inputBuffer: THREE.RenderTarget, outputBuffer?: THREE.RenderTarget | null): void;
+    setSize(width: number, height: number): void;
+    dispose(): void;
+}
+
+declare class DiscardNodeMaterial extends MeshBasicNodeMaterial {
+    constructor();
+}
+declare const DiscardMaterial: DiscardNodeMaterial;
 
 declare enum GradientType {
     Linear = "linear",
@@ -2445,68 +2339,44 @@ type ImageProps = Omit<ThreeElements['mesh'], 'scale'> & {
 });
 declare const Image: ForwardRefComponent<ImageProps, THREE.Mesh>;
 
-declare class SpotLightMaterial extends MeshBasicNodeMaterial {
-    private _depth;
-    private _opacity;
-    private _attenuation;
-    private _anglePower;
-    private _spotPosition;
-    private _lightColor;
-    private _cameraNear;
-    private _cameraFar;
-    private _resolution;
+type MeshDiscardMaterialProps = Omit<ThreeElements['meshBasicMaterial'], 'ref'>;
+declare const MeshDiscardMaterial: ForwardRefComponent<MeshDiscardMaterialProps, DiscardNodeMaterial>;
+
+declare const SpotLightMaterial_base: WithUniforms<typeof THREE.MeshBasicNodeMaterial, {
+    depth: () => THREE.TextureNode<"vec4">;
+    attenuation: () => THREE.UniformNode<"float", number>;
+    anglePower: () => THREE.UniformNode<"float", number>;
+    spotPosition: () => THREE.UniformNode<"vec3", THREE.Vector3>;
+    lightColor: () => THREE.UniformNode<"color", THREE.Color>;
+    cameraNear: () => THREE.UniformNode<"float", number>;
+    cameraFar: () => THREE.UniformNode<"float", number>;
+    resolution: () => THREE.UniformNode<"vec2", THREE.Vector2>;
+}>;
+declare class SpotLightMaterial extends SpotLightMaterial_base {
     constructor();
     private _buildShader;
-    get depth(): THREE.Texture | null;
-    set depth(v: THREE.Texture | null);
-    get opacity(): number;
-    set opacity(v: number);
-    get attenuation(): number;
-    set attenuation(v: number);
-    get anglePower(): number;
-    set anglePower(v: number);
-    get spotPosition(): THREE.Vector3;
-    set spotPosition(v: THREE.Vector3);
-    get lightColor(): THREE.Color;
-    set lightColor(v: THREE.Color);
-    get cameraNear(): number;
-    set cameraNear(v: number);
-    get cameraFar(): number;
-    set cameraFar(v: number);
-    get resolution(): THREE.Vector2;
-    set resolution(v: THREE.Vector2);
 }
 
 declare const HtmlMaterial: ({ transform }: {
     transform: boolean;
 }) => React.JSX.Element;
 
-declare class StarfieldMaterial extends SpriteNodeMaterial {
-    private _time;
-    private _fade;
-    positionNode: ReturnType<typeof Fn>;
-    scaleNode: ReturnType<typeof Fn>;
-    colorNode: ReturnType<typeof Fn>;
+declare const StarfieldMaterial_base: WithUniforms<typeof SpriteNodeMaterial, {
+    time: () => THREE.UniformNode<"float", number>;
+    fade: () => THREE.UniformNode<"float", number>;
+}>;
+declare class StarfieldMaterial extends StarfieldMaterial_base {
     constructor();
     setTime(time: number): void;
     setFade(fade: number): void;
-    get time(): number;
-    set time(value: number);
-    get fade(): number;
-    set fade(value: number);
-}
-
-declare class SparklesMaterial extends SpriteNodeMaterial {
-    private _time;
-    private _pixelRatio;
-    positionNode: ReturnType<typeof Fn>;
-    scaleNode: ReturnType<typeof Fn>;
-    colorNode: ReturnType<typeof Fn>;
+}
+
+declare const SparklesMaterial_base: WithUniforms<typeof SpriteNodeMaterial, {
+    time: () => THREE.UniformNode<"float", number>;
+    pixelRatio: () => THREE.UniformNode<"float", number>;
+}>;
+declare class SparklesMaterial extends SparklesMaterial_base {
     constructor();
-    get time(): number;
-    set time(value: number);
-    get pixelRatio(): number;
-    set pixelRatio(value: number);
 }
 
 type GridMaterialType = {
@@ -2594,5 +2464,35 @@ type SparklesProps = Omit<ThreeElements['mesh'], 'ref'> & {
 };
 declare const Sparkles: ForwardRefComponent<SparklesProps, THREE.InstancedMesh>;
 
-export { AccumulativeShadows, AdaptiveDpr, AdaptiveEvents, ArcballControls, BBAnchor, Backdrop, BakeShadows, Billboard, Bounds, Box, CameraShake, Capsule, CatmullRomLine, Caustics, CausticsMaterial, CausticsNormalMaterial, CausticsProjectionMaterial, Center, Circle, Clone, Cloud, CloudInstance, Clouds, ComputedAttribute, Cone, ContactShadows, ConvolutionMaterial, CubeCamera, CubeTexture, CubicBezierLine, CurveModifier, CycleRaycast, Cylinder, Decal, Detailed, DetectGPU, DeviceOrientationControls, DiscardMaterial, Dodecahedron, DragControls, Edges, Environment, EnvironmentCube, EnvironmentMap, EnvironmentPortal, Example, Extrude, FakeCloudMaterial, Fbo, Fbx, FirstPersonControls, Fisheye, Float, FlyControls, GizmoHelper, GizmoViewcube, GizmoViewport, Gltf, GradientTexture, GradientType, Grid, Helper, Html, HtmlMaterial, Hud, Icosahedron, Image, Instance, InstancedAttribute, Instances, IsObject, KeyboardControls, Ktx2, Lathe, Lightformer, Line, Loader, MapControls, Mask, MatcapTexture, Merged, MeshDistortMaterial, MeshPortalMaterial, MeshReflectorMaterial, MeshReflectorMaterial$1 as MeshReflectorMaterialImpl, MeshRefractionMaterial, MeshTransmissionMaterial, MeshWobbleMaterial, MotionPathControls, NormalTexture, Octahedron, OrbitControls, OrthographicCamera, Outlines, PCSSShadowNode, PerformanceMonitor, PerspectiveCamera, PivotControls, Plane, Point, PointMaterial, PointMaterialImpl, PointerLockControls, Points, PointsBuffer, Polyhedron, PositionMesh, PositionPoint, PositionalAudio, Preload, PresentationControls, Progress, QuadraticBezierLine, RandomizedLight, RenderCubeTexture, RenderTexture, Resize, Ring, RoundedBox, RoundedBoxGeometry, Sampler, ScreenQuad, ScreenSizer, ScreenSpace, ScreenVideoTexture, Scroll, ScrollControls, Segment, SegmentObject, Segments, Select, Shadow, Shape, Sky, SoftShadows, Sparkles, SparklesMaterial, Sphere, SpotLight, SpotLightMaterial, SpriteAnimator, Stage, StarfieldMaterial, Stars, Stats, StatsGl, Svg, Tetrahedron, Text3D, Texture, Torus, TorusKnot, TrackballControls, Trail, TrailTexture, TransformControls, Tube, VideoTexture, View, WebcamVideoTexture, Wireframe, WireframeMaterial, WireframeMaterialShaders, accumulativeContext, calcPosFromAngles, checkIfFrameIsEmpty, createInstances, getFirstFrame, meshBounds, presetsObj, setBarycentricCoordinates, setWireframeOverride, useAnimations, useAspect, useBounds, useContextBridge, useCubeCamera, useCubeTexture, useCursor, useCustomRaycast, useDepthBuffer, useDetectGPU, useEnvironment, useFBO, useFBX, useFont, useGLTF, useGizmoContext, useHelper, useIntersect, useKTX2, useKeyboardControls, useMask, useMatcapTexture, useMotion, useNormalTexture, usePerformanceMonitor, useProgress, useScroll, useSelect, useSpriteAnimator, useSpriteLoader, useSurfaceSampler, useTexture, useTrail, useTrailTexture, useVariants, useVideoTexture, useWireframeUniforms };
-export type { AccumulativeShadowsProps, ArcballControlsProps, Args, BBAnchorProps, BackdropProps, BillboardProps, BoundsApi, BoundsProps, CalculatePosition, CameraShakeProps, CatmullRomLineProps, CausticsProps, CenterProps, CloneProps, CloudProps, CloudsProps, ComputedAttributeProps, ContactShadowsProps, ContainerProps, CubeCameraOptions, CubeCameraProps, CubeTextureProps, CubicBezierLineProps, CurveModifierProps, CurveModifierRef, CycleRaycastProps, DecalProps, DetailedProps, DetectGPUProps, DeviceOrientationControlsProps, DragConfig, DragControlsProps, EdgesProps, EdgesRef, EnvironmentLoaderProps, EnvironmentProps, ExampleApi, ExampleProps, FboProps, FirstPersonControlsProps, FisheyeProps, FloatProps, FlyControlsProps, FontData, FrameData, GizmoHelperProps, GltfProps, Glyph, GradientTextureProps, GridMaterialType, GridProps, HelperProps, HtmlProps, HudProps, ImageProps, InstanceProps, InstancedAttributeProps, InstancesProps, KeyboardControlsEntry, KeyboardControlsProps, Ktx2Props, LightProps, LineProps, LoaderOptions, MapControlsProps, MaskProps, MergedProps, MeshDistortMaterialProps, MeshReflectorMaterialProps, MeshRefractionMaterialProps, MeshRefractionMaterialType, MeshTransmissionMaterialProps, MetaData, MotionPathProps, MotionPathRef, OnCenterCallbackProps, OnDragProps, OnDragStartProps, OnHoverProps, OrbitControlsChangeEvent, OrbitControlsProps, OrthographicCameraProps, OutlinesProps, PCSSShadowNodeOptions, PerformanceMonitorApi, PerformanceMonitorProps, PerspectiveCameraProps, PivotControlsProps, PointMaterialProps, PointerLockControlsProps, PointsBuffersProps, PointsInstancesProps, PortalProps, PositionalAudioProps, PreloadProps, PresentationControlProps, PresetsType, QuadraticBezierLineProps, QuadraticBezierLineRef, RandomizedLightProps, RenderCubeTextureApi, RenderCubeTextureProps, RenderTextureProps, ResizeProps, RoundedBoxGeometryProps, RoundedBoxProps, SamplerProps, ScreenQuadProps, ScreenSizerProps, ScreenSpaceProps, ScreenVideoTextureProps, ScrollControlsProps, ScrollControlsState, ScrollProps, SegmentProps, SegmentsProps, SelectProps, ShadowProps, ShadowType, ShakeController, ShapeProps, Size, SizeProps, SkyProps, SoftShadowsProps, SparklesProps, SpotLightProps, SpriteAnimatorProps, SpriteData, StageProps, StarsProps, StatsGlProps, StatsOptions, StatsProps, SvgProps, Text3DProps, TrackballControlsProps, TrailProps, TrailTextureProps, TransformControlsProps, TransformFn, UseGLTFOptions, VideoTextureProps, ViewProps, ViewportProps, WebcamVideoTextureProps, WireframeMaterialProps, WireframeMaterialType, WobbleMaterialProps, useSurfaceSamplerProps };
+type InspectorProps = React.PropsWithChildren<{
+    hide?: boolean;
+}>;
+declare function Inspector({ children, hide }: InspectorProps): React.JSX.Element;
+
+interface Control<V> {
+    value: V;
+    label?: string;
+    min?: number;
+    max?: number;
+    step?: number;
+    color?: boolean;
+    options?: readonly V[] | Record<string, V>;
+    onChange?: (value: V) => void;
+}
+interface Folder<S extends ControlSchema = ControlSchema> {
+    label?: string;
+    collapsed?: boolean;
+    schema: S;
+}
+type ControlSchema = Record<string, Control<any> | Folder<any>>;
+type ControlValues<S extends ControlSchema> = {
+    [K in keyof S]: S[K] extends Folder<infer FS> ? ControlValues<FS> : S[K] extends Control<infer V> ? V : never;
+};
+interface InspectorControlsOptions {
+    title?: string;
+    collapsed?: boolean;
+}
+declare function useInspectorControls<S extends ControlSchema>(schema: S, options?: InspectorControlsOptions): ControlValues<S>;
+
+export { AccumulativeShadows, AdaptiveDpr, AdaptiveEvents, ArcballControls, BBAnchor, Backdrop, BakeShadows, Billboard, BlurPass, Bounds, Box, CameraShake, Capsule, CatmullRomLine, Caustics, CausticsMaterial, CausticsNormalMaterial, CausticsProjectionMaterial, Center, Circle, Clone, Cloud, CloudInstance, Clouds, ComputedAttribute, Cone, ContactShadows, ConvolutionMaterial, CubeCamera, CubeTexture, CubicBezierLine, CurveModifier, CycleRaycast, Cylinder, Decal, Detailed, DetectGPU, DeviceOrientationControls, DiscardMaterial, DiscardNodeMaterial, Dodecahedron, DragControls, Edges, Environment, EnvironmentCube, EnvironmentMap, EnvironmentPortal, Example, Extrude, FakeCloudMaterial, Fbo, Fbx, FirstPersonControls, Fisheye, Float, FlyControls, GizmoHelper, GizmoViewcube, GizmoViewport, Gltf, GradientTexture, GradientType, Grid, Helper, Html, HtmlMaterial, Hud, Icosahedron, Image, Inspector, Instance, InstancedAttribute, Instances, IsObject, KeyboardControls, Ktx2, Lathe, Lightformer, Line, Loader, MapControls, Mask, MatcapTexture, Merged, MeshDiscardMaterial, MeshDistortMaterial, MeshPortalMaterial, MeshReflectorMaterial, MeshReflectorMaterial$1 as MeshReflectorMaterialImpl, MeshRefractionMaterial, MeshTransmissionMaterial, MeshWobbleMaterial, MotionPathControls, NormalTexture, Octahedron, OrbitControls, OrthographicCamera, Outlines, PCSSShadowNode, PerformanceMonitor, PerspectiveCamera, PivotControls, Plane, Point, PointMaterial, PointMaterialImpl, PointerLockControls, Points, PointsBuffer, Polyhedron, PositionMesh, PositionPoint, PositionalAudio, Preload, PresentationControls, Progress, QuadraticBezierLine, RandomizedLight, RenderCubeTexture, RenderTexture, Resize, Ring, RoundedBox, RoundedBoxGeometry, Sampler, ScreenQuad, ScreenSizer, ScreenSpace, ScreenVideoTexture, Scroll, ScrollControls, Segment, SegmentObject, Segments, Select, Shadow, Shape, Sky, SoftShadows, Sparkles, SparklesMaterial, Sphere, SpotLight, SpotLightMaterial, SpriteAnimator, Stage, StarfieldMaterial, Stars, Stats, StatsGl, Svg, Tetrahedron, Text3D, Texture, Torus, TorusKnot, TrackballControls, Trail, TrailTexture, TransformControls, Tube, VideoTexture, View, WebcamVideoTexture, Wireframe, WireframeMaterial, WireframeMaterialImpl, WireframeMaterialShaders, accumulativeContext, calcPosFromAngles, checkIfFrameIsEmpty, createInstances, getFirstFrame, meshBounds, presetsObj, setBarycentricCoordinates, setWireframeOverride, useAnimations, useAspect, useBounds, useContextBridge, useCubeCamera, useCubeTexture, useCursor, useCustomRaycast, useDepthBuffer, useDetectGPU, useEnvironment, useFBO, useFBX, useFont, useGLTF, useGizmoContext, useHelper, useInspectorControls, useIntersect, useKTX2, useKeyboardControls, useMask, useMatcapTexture, useMotion, useNormalTexture, usePerformanceMonitor, useProgress, useScroll, useSelect, useSpriteAnimator, useSpriteLoader, useSurfaceSampler, useTexture, useTrail, useTrailTexture, useVariants, useVideoTexture, useWireframeUniforms, withUniforms };
+export type { AccumulativeContext, AccumulativeLightContext, AccumulativeShadowsProps, ArcballControlsProps, Args, BBAnchorProps, BackdropProps, BillboardProps, BlurPassProps, BoundsApi, BoundsProps, CalculatePosition, CameraShakeProps, CatmullRomLineProps, CausticsProps, CenterProps, CloneProps, CloudProps, CloudsProps, ComputedAttributeProps, ContactShadowsProps, ContainerProps, Control, ControlSchema, ControlValues, CubeCameraOptions, CubeCameraProps, CubeTextureProps, CubicBezierLineProps, CurveModifierProps, CurveModifierRef, CycleRaycastProps, DecalProps, DetailedProps, DetectGPUProps, DeviceOrientationControlsProps, DragConfig, DragControlsProps, EdgesProps, EdgesRef, EnvironmentLoaderProps, EnvironmentProps, ExampleApi, ExampleProps, FboProps, FirstPersonControlsProps, FisheyeProps, FloatProps, FlyControlsProps, Folder, FontData, FrameData, GizmoHelperProps, GltfProps, Glyph, GradientTextureProps, GridMaterialType, GridProps, HelperProps, HtmlProps, HudProps, ImageProps, InspectorControlsOptions, InspectorProps, InstanceProps, InstancedAttributeProps, InstancesProps, KeyboardControlsEntry, KeyboardControlsProps, Ktx2Props, LightProps, LineProps, LoaderOptions, MapControlsProps, MaskProps, MergedProps, MeshDiscardMaterialProps, MeshDistortMaterialProps, MeshReflectorMaterialProps, MeshRefractionMaterialProps, MeshRefractionMaterialType, MeshTransmissionMaterialProps, MetaData, MotionPathProps, MotionPathRef, OnCenterCallbackProps, OnDragProps, OnDragStartProps, OnHoverProps, OrbitControlsChangeEvent, OrbitControlsProps, OrthographicCameraProps, OutlinesProps, PCSSShadowNodeOptions, PerformanceMonitorApi, PerformanceMonitorProps, PerspectiveCameraProps, PivotControlsProps, PointMaterialProps, PointerLockControlsProps, PointsBuffersProps, PointsInstancesProps, PortalProps, PositionalAudioProps, PreloadProps, PresentationControlProps, PresetsType, QuadraticBezierLineProps, QuadraticBezierLineRef, RandomizedLightProps, RenderCubeTextureApi, RenderCubeTextureProps, RenderTextureProps, ReservedUniformName, ResizeProps, RoundedBoxGeometryProps, RoundedBoxProps, SamplerProps, ScreenQuadProps, ScreenSizerProps, ScreenSpaceProps, ScreenVideoTextureProps, ScrollControlsProps, ScrollControlsState, ScrollProps, SegmentProps, SegmentsProps, SelectProps, ShadowProps, ShadowType, ShakeController, ShapeProps, Size, SizeProps, SkyProps, SoftShadowsProps, SparklesProps, SpotLightProps, SpriteAnimatorProps, SpriteData, StageProps, StarsProps, StatsGlProps, StatsOptions, StatsProps, SvgProps, Text3DProps, TrackballControlsProps, TrailProps, TrailTextureProps, TransformControlsProps, TransformFn, UniformFactory, UniformTable, UniformValue, UseGLTFOptions, VideoTextureProps, ViewProps, ViewportProps, WebcamVideoTextureProps, WireframeMaterialProps, WireframeMaterialType, WireframeProps, WithUniforms, WobbleMaterialProps, useSurfaceSamplerProps };