@react-three/postprocessing 3.0.5 → 3.1.0

package/dist/effects/Sepia.d.ts

@@ -1,2 +1,13 @@
 import { SepiaEffect } from 'postprocessing';
-export declare const Sepia: (props: import("..").EffectProps<typeof SepiaEffect>) => import("react").JSX.Element;
+export declare const Sepia: (props: {
+    blendFunction?: import("postprocessing").BlendFunction;
+    intensity?: number;
+} & {
+    blendFunction?: import("postprocessing").BlendFunction;
+    opacity?: number;
+    args?: [({
+        blendFunction?: import("postprocessing").BlendFunction;
+        intensity?: number;
+    } | undefined)?] | undefined;
+    ref?: import("react").Ref<SepiaEffect> | undefined;
+}) => import("react").JSX.Element;

package/dist/effects/ShockWave.d.ts

@@ -1,2 +1,12 @@
+import type { ReactThreeFiber } from '@react-three/fiber';
 import { ShockWaveEffect } from 'postprocessing';
-export declare const ShockWave: (props: import("..").EffectProps<typeof ShockWaveEffect>) => import("react").JSX.Element;
+import { Ref } from 'react';
+export type ShockWaveProps = {
+    position?: ReactThreeFiber.Vector3;
+    speed?: number;
+    maxRadius?: number;
+    waveSize?: number;
+    amplitude?: number;
+    ref?: Ref<ShockWaveEffect>;
+};
+export declare function ShockWave(props: ShockWaveProps): import("react").JSX.Element;

package/dist/effects/Texture.d.ts

@@ -1,10 +1,10 @@
 import { TextureEffect } from 'postprocessing';
-import { Ref } from 'react';
-type TextureProps = ConstructorParameters<typeof TextureEffect>[0] & {
+import type { Ref } from 'react';
+import { type EffectOptions } from '../createEffectComponent';
+export type TextureProps = EffectOptions<typeof TextureEffect> & {
     textureSrc: string;
     /** opacity of provided texture */
     opacity?: number;
     ref?: Ref<TextureEffect>;
 };
-export declare function Texture({ textureSrc, texture, opacity, ref, ...props }: TextureProps): import("react").JSX.Element;
-export {};
+export declare function Texture({ textureSrc, texture, opacity, ...props }: TextureProps): import("react").JSX.Element;

package/dist/effects/TiltShift.d.ts

@@ -1,2 +1,10 @@
 import { TiltShiftEffect } from 'postprocessing';
-export declare const TiltShift: (props: import("..").EffectProps<typeof TiltShiftEffect>) => import("react").JSX.Element;
+import type { Ref } from 'react';
+import { type EffectOptions } from '../createEffectComponent';
+type TiltShiftOptions = EffectOptions<typeof TiltShiftEffect>;
+export type TiltShiftProps = TiltShiftOptions & {
+    opacity?: number;
+    ref?: Ref<TiltShiftEffect>;
+};
+export declare function TiltShift({ blendFunction, kernelSize, resolutionScale, resolutionX, resolutionY, ...liveProps }: TiltShiftProps): import("react").JSX.Element;
+export {};

package/dist/effects/TiltShift2.d.ts

@@ -1,4 +1,6 @@
 import { BlendFunction, Effect } from 'postprocessing';
+import type { Ref } from 'react';
+type Vec2Tuple = [number, number];
 export declare class TiltShiftEffect extends Effect {
     constructor({ blendFunction, blur, // [0, 1], can go beyond 1 for extra
     taper, // [0, 1], can go beyond 1 for extra
@@ -9,10 +11,48 @@ export declare class TiltShiftEffect extends Effect {
         blendFunction?: BlendFunction | undefined;
         blur?: number | undefined;
         taper?: number | undefined;
-        start?: number[] | undefined;
-        end?: number[] | undefined;
+        start?: Vec2Tuple | undefined;
+        end?: Vec2Tuple | undefined;
         samples?: number | undefined;
-        direction?: number[] | undefined;
+        direction?: Vec2Tuple | undefined;
     });
+    private u;
+    private setU;
+    get blur(): number;
+    set blur(value: number);
+    get taper(): number;
+    set taper(value: number);
+    get start(): Vec2Tuple;
+    set start(value: Vec2Tuple);
+    get end(): Vec2Tuple;
+    set end(value: Vec2Tuple);
+    get samples(): number;
+    set samples(value: number);
+    get direction(): Vec2Tuple;
+    set direction(value: Vec2Tuple);
 }
-export declare const TiltShift2: (props: import("..").EffectProps<typeof TiltShiftEffect>) => import("react").JSX.Element;
+export type TiltShift2Props = {
+    blendFunction?: BlendFunction;
+    blur?: number;
+    taper?: number;
+    start?: Vec2Tuple;
+    end?: Vec2Tuple;
+    samples?: number;
+    direction?: Vec2Tuple;
+    ref?: Ref<TiltShiftEffect>;
+};
+export declare const TiltShift2: (props: TiltShift2Props & {
+    blendFunction?: BlendFunction;
+    opacity?: number;
+    args?: [({
+        blendFunction?: BlendFunction | undefined;
+        blur?: number | undefined;
+        taper?: number | undefined;
+        start?: Vec2Tuple | undefined;
+        end?: Vec2Tuple | undefined;
+        samples?: number | undefined;
+        direction?: Vec2Tuple | undefined;
+    } | undefined)?] | undefined;
+    ref?: Ref<TiltShiftEffect> | undefined;
+}) => import("react").JSX.Element;
+export {};

package/dist/effects/ToneMapping.d.ts

@@ -1,4 +1,10 @@
 import { ToneMappingEffect } from 'postprocessing';
-import { type EffectProps } from '../wrapEffect';
-export type ToneMappingProps = EffectProps<typeof ToneMappingEffect>;
-export declare const ToneMapping: (props: EffectProps<typeof ToneMappingEffect>) => import("react").JSX.Element;
+import type { Ref } from 'react';
+import { type EffectOptions } from '../createEffectComponent';
+type ToneMappingOptions = EffectOptions<typeof ToneMappingEffect>;
+export type ToneMappingProps = ToneMappingOptions & {
+    opacity?: number;
+    ref?: Ref<ToneMappingEffect>;
+};
+export declare function ToneMapping({ minLuminance, maxLuminance, ...liveProps }: ToneMappingProps): import("react").JSX.Element;
+export {};

package/dist/effects/Vignette.d.ts

@@ -1,2 +1,19 @@
 import { VignetteEffect } from 'postprocessing';
-export declare const Vignette: (props: import("..").EffectProps<typeof VignetteEffect>) => import("react").JSX.Element;
+export declare const Vignette: (props: {
+    blendFunction?: import("postprocessing").BlendFunction;
+    technique?: import("postprocessing").VignetteTechnique;
+    eskil?: boolean;
+    offset?: number;
+    darkness?: number;
+} & {
+    blendFunction?: import("postprocessing").BlendFunction;
+    opacity?: number;
+    args?: [({
+        blendFunction?: import("postprocessing").BlendFunction;
+        technique?: import("postprocessing").VignetteTechnique;
+        eskil?: boolean;
+        offset?: number;
+        darkness?: number;
+    } | undefined)?] | undefined;
+    ref?: import("react").Ref<VignetteEffect> | undefined;
+}) => import("react").JSX.Element;

package/dist/effects/Water.d.ts

@@ -1,8 +1,24 @@
 import { BlendFunction, Effect } from 'postprocessing';
+import type { Ref } from 'react';
 export declare class WaterEffectImpl extends Effect {
     constructor({ blendFunction, factor }?: {
         blendFunction?: BlendFunction | undefined;
         factor?: number | undefined;
     });
+    get factor(): number;
+    set factor(value: number);
 }
-export declare const WaterEffect: (props: import("..").EffectProps<typeof WaterEffectImpl>) => import("react").JSX.Element;
+export type WaterEffectProps = {
+    blendFunction?: BlendFunction;
+    factor?: number;
+    ref?: Ref<WaterEffectImpl>;
+};
+export declare const WaterEffect: (props: WaterEffectProps & {
+    blendFunction?: BlendFunction;
+    opacity?: number;
+    args?: [({
+        blendFunction?: BlendFunction | undefined;
+        factor?: number | undefined;
+    } | undefined)?] | undefined;
+    ref?: Ref<WaterEffectImpl> | undefined;
+}) => import("react").JSX.Element;

package/dist/index.d.ts

@@ -1,4 +1,6 @@
+export * from './createEffectComponent';
 export * from './EffectComposer';
+export * from './EffectGroup';
 export * from './Selection';
 export * from './util';
 export * from './wrapEffect';
@@ -35,4 +37,5 @@ export * from './effects/TiltShift2';
 export * from './effects/ToneMapping';
 export * from './effects/Vignette';
 export * from './effects/Water';
-export * from './effects/N8AO';
+export * from './passes/DepthPicking';
+export * from './passes/N8AO';