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

package/native/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, EventDispatcher, Camera, Group, Matrix4, Vector3 as Vector3$1, 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, 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, EventDispatcher, Camera, Group, Matrix4, Vector3 as Vector3$1, 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, MeshBasicNodeMaterial, SpriteNodeMaterial, SpotLight as SpotLight$1 } from 'three/webgpu';
+import { reflector } from 'three/tsl';
 import { LineSegments2 } from 'three/examples/jsm/lines/webgpu/LineSegments2.js';
 import * as zustand from 'zustand';
 import { StoreApi } from 'zustand';
@@ -46,6 +46,22 @@ 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 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>;
+    };
+};
+
 type AccumulativeShadowsProps = Omit<ThreeElements['group'], 'ref'> & {
     frames?: number;
     blend?: number;
@@ -73,24 +89,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'> & {
@@ -109,70 +114,35 @@ type RandomizedLightProps = Omit<ThreeElements['group'], 'ref'> & {
 };
 declare const RandomizedLight: ForwardRefComponent<RandomizedLightProps, AccumulativeLightContext>;
 
-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);
@@ -223,43 +193,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' {
@@ -310,32 +260,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>;
 
@@ -349,41 +284,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 {
@@ -400,14 +320,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 {
@@ -2101,55 +2019,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>;
@@ -2189,57 +2079,34 @@ 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;
+declare class DiscardNodeMaterial extends MeshBasicNodeMaterial {
+    constructor();
+}
+declare const DiscardMaterial: DiscardNodeMaterial;
 
 declare enum GradientType {
     Linear = "linear",
@@ -2276,64 +2143,37 @@ 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;
+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 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 = {