@react-three/postprocessing 3.0.3 → 3.0.4

package/dist/EffectComposer.d.ts

@@ -0,0 +1,27 @@
+import type { TextureDataType, Camera, Scene } from 'three';
+import { type JSX } from 'react';
+import { EffectComposer as EffectComposerImpl, NormalPass, DepthDownsamplingPass } from 'postprocessing';
+export declare const EffectComposerContext: import("react").Context<{
+    composer: EffectComposerImpl;
+    normalPass: NormalPass | null;
+    downSamplingPass: DepthDownsamplingPass | null;
+    camera: Camera;
+    scene: Scene;
+    resolutionScale?: number | undefined;
+}>;
+export type EffectComposerProps = {
+    enabled?: boolean;
+    children: JSX.Element | JSX.Element[];
+    depthBuffer?: boolean;
+    /** Only used for SSGI currently, leave it disabled for everything else unless it's needed */
+    enableNormalPass?: boolean;
+    stencilBuffer?: boolean;
+    autoClear?: boolean;
+    resolutionScale?: number;
+    multisampling?: number;
+    frameBufferType?: TextureDataType;
+    renderPriority?: number;
+    camera?: Camera;
+    scene?: Scene;
+};
+export declare const EffectComposer: import("react").NamedExoticComponent<EffectComposerProps & import("react").RefAttributes<EffectComposerImpl>>;

package/dist/Selection.d.ts

@@ -0,0 +1,17 @@
+import * as THREE from 'three';
+import React from 'react';
+import { type ThreeElements } from '@react-three/fiber';
+export type Api = {
+    selected: THREE.Object3D[];
+    select: React.Dispatch<React.SetStateAction<THREE.Object3D[]>>;
+    enabled: boolean;
+};
+export type SelectApi = Omit<ThreeElements['group'], 'ref'> & {
+    enabled?: boolean;
+};
+export declare const selectionContext: React.Context<Api | null>;
+export declare function Selection({ children, enabled }: {
+    enabled?: boolean;
+    children: React.ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function Select({ enabled, children, ...props }: SelectApi): import("react/jsx-runtime").JSX.Element;

package/dist/effects/ASCII.d.ts

@@ -0,0 +1,18 @@
+/// <reference types="react" />
+import { Texture } from 'three';
+import { Effect } from 'postprocessing';
+interface IASCIIEffectProps {
+    font?: string;
+    characters?: string;
+    fontSize?: number;
+    cellSize?: number;
+    color?: string;
+    invert?: boolean;
+}
+declare class ASCIIEffect extends Effect {
+    constructor({ font, characters, fontSize, cellSize, color, invert, }?: IASCIIEffectProps);
+    /** Draws the characters on a Canvas and returns a texture */
+    createCharactersTexture(characters: string, font: string, fontSize: number): Texture;
+}
+export declare const ASCII: import("react").ForwardRefExoticComponent<IASCIIEffectProps & import("react").RefAttributes<ASCIIEffect>>;
+export {};

package/dist/effects/Autofocus.d.ts

@@ -0,0 +1,22 @@
+import * as THREE from 'three';
+import React, { RefObject } from 'react';
+import { type Vector3 } from '@react-three/fiber';
+import { DepthOfFieldEffect } from 'postprocessing';
+import { DepthOfField } from './DepthOfField';
+export type AutofocusProps = React.ComponentProps<typeof DepthOfField> & {
+    target?: Vector3;
+    /** should the target follow the pointer */
+    mouse?: boolean;
+    /** size of the debug green point  */
+    debug?: number;
+    /** manual update */
+    manual?: boolean;
+    /** approximate time to reach the target */
+    smoothTime?: number;
+};
+export type AutofocusApi = {
+    dofRef: RefObject<DepthOfFieldEffect | null>;
+    hitpoint: THREE.Vector3;
+    update: (delta: number, updateTarget: boolean) => void;
+};
+export declare const Autofocus: React.ForwardRefExoticComponent<Omit<AutofocusProps, "ref"> & React.RefAttributes<AutofocusApi>>;

package/dist/effects/Bloom.d.ts

@@ -0,0 +1,5 @@
+export declare const Bloom: ({ blendFunction, opacity, ...props }: {
+    [x: string]: any;
+    blendFunction?: any;
+    opacity?: any;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/effects/BrightnessContrast.d.ts

@@ -0,0 +1,5 @@
+export declare const BrightnessContrast: ({ blendFunction, opacity, ...props }: {
+    [x: string]: any;
+    blendFunction?: any;
+    opacity?: any;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/effects/ChromaticAberration.d.ts

@@ -0,0 +1,8 @@
+import { ChromaticAberrationEffect } from 'postprocessing';
+import { type EffectProps } from '../util';
+export type ChromaticAberrationProps = EffectProps<typeof ChromaticAberrationEffect>;
+export declare const ChromaticAberration: ({ blendFunction, opacity, ...props }: {
+    [x: string]: any;
+    blendFunction?: any;
+    opacity?: any;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/effects/ColorAverage.d.ts

@@ -0,0 +1,8 @@
+import { ColorAverageEffect, BlendFunction } from 'postprocessing';
+import React from 'react';
+export type ColorAverageProps = Partial<{
+    blendFunction: BlendFunction;
+}>;
+export declare const ColorAverage: React.ForwardRefExoticComponent<Partial<{
+    blendFunction: BlendFunction;
+}> & React.RefAttributes<ColorAverageEffect>>;

package/dist/effects/ColorDepth.d.ts

@@ -0,0 +1,5 @@
+export declare const ColorDepth: ({ blendFunction, opacity, ...props }: {
+    [x: string]: any;
+    blendFunction?: any;
+    opacity?: any;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/effects/Depth.d.ts

@@ -0,0 +1,5 @@
+export declare const Depth: ({ blendFunction, opacity, ...props }: {
+    [x: string]: any;
+    blendFunction?: any;
+    opacity?: any;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/effects/DepthOfField.d.ts

@@ -0,0 +1,25 @@
+/// <reference types="react" />
+import { DepthOfFieldEffect } from 'postprocessing';
+import { ReactThreeFiber } from '@react-three/fiber';
+import { type Texture, Vector3 } from 'three';
+export declare const DepthOfField: import("react").ForwardRefExoticComponent<{
+    blendFunction?: import("postprocessing").BlendFunction | undefined;
+    worldFocusDistance?: number | undefined;
+    worldFocusRange?: number | undefined;
+    focusDistance?: number | undefined;
+    focalLength?: number | undefined;
+    focusRange?: number | undefined;
+    bokehScale?: number | undefined;
+    resolutionScale?: number | undefined;
+    resolutionX?: number | undefined;
+    resolutionY?: number | undefined;
+    width?: number | undefined;
+    height?: number | undefined;
+} & Partial<{
+    target: ReactThreeFiber.Vector3;
+    depthTexture: {
+        texture: Texture;
+        packing: number;
+    };
+    blur: number;
+}> & import("react").RefAttributes<DepthOfFieldEffect>>;

package/dist/effects/DotScreen.d.ts

@@ -0,0 +1,5 @@
+export declare const DotScreen: ({ blendFunction, opacity, ...props }: {
+    [x: string]: any;
+    blendFunction?: any;
+    opacity?: any;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/effects/FXAA.d.ts

@@ -0,0 +1,5 @@
+export declare const FXAA: ({ blendFunction, opacity, ...props }: {
+    [x: string]: any;
+    blendFunction?: any;
+    opacity?: any;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/effects/Glitch.d.ts

@@ -0,0 +1,30 @@
+/// <reference types="react" />
+import { Vector2 } from 'three';
+import { GlitchEffect, GlitchMode } from 'postprocessing';
+import { ReactThreeFiber } from '@react-three/fiber';
+export type GlitchProps = ConstructorParameters<typeof GlitchEffect>[0] & Partial<{
+    mode: GlitchMode;
+    active: boolean;
+    delay: ReactThreeFiber.Vector2;
+    duration: ReactThreeFiber.Vector2;
+    chromaticAberrationOffset: ReactThreeFiber.Vector2;
+    strength: ReactThreeFiber.Vector2;
+}>;
+export declare const Glitch: import("react").ForwardRefExoticComponent<{
+    blendFunction?: import("postprocessing").BlendFunction | undefined;
+    chromaticAberrationOffset?: Vector2 | undefined;
+    delay?: Vector2 | undefined;
+    duration?: Vector2 | undefined;
+    strength?: Vector2 | undefined;
+    perturbationMap?: import("three").Texture | undefined;
+    dtSize?: number | undefined;
+    columns?: number | undefined;
+    ratio?: number | undefined;
+} & Partial<{
+    mode: GlitchMode;
+    active: boolean;
+    delay: ReactThreeFiber.Vector2;
+    duration: ReactThreeFiber.Vector2;
+    chromaticAberrationOffset: ReactThreeFiber.Vector2;
+    strength: ReactThreeFiber.Vector2;
+}> & import("react").RefAttributes<GlitchEffect>>;

package/dist/effects/GodRays.d.ts

@@ -0,0 +1,21 @@
+import { GodRaysEffect } from 'postprocessing';
+import React from 'react';
+import { Mesh, Points } from 'three';
+export declare const GodRays: React.ForwardRefExoticComponent<{
+    blendFunction?: import("postprocessing").BlendFunction | undefined;
+    samples?: number | undefined;
+    density?: number | undefined;
+    decay?: number | undefined;
+    weight?: number | undefined;
+    exposure?: number | undefined;
+    clampMax?: number | undefined;
+    resolutionScale?: number | undefined;
+    resolutionX?: number | undefined;
+    resolutionY?: number | undefined;
+    width?: number | undefined;
+    height?: number | undefined;
+    kernelSize?: import("postprocessing").KernelSize | undefined;
+    blur?: boolean | undefined;
+} & {
+    sun: Mesh | Points | React.RefObject<Mesh | Points>;
+} & React.RefAttributes<GodRaysEffect>>;

package/dist/effects/Grid.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+import { GridEffect } from 'postprocessing';
+export declare const Grid: React.ForwardRefExoticComponent<{
+    blendFunction?: import("postprocessing").BlendFunction | undefined;
+    scale?: number | undefined;
+    lineWidth?: number | undefined;
+} & Partial<{
+    size: {
+        width: number;
+        height: number;
+    };
+}> & React.RefAttributes<GridEffect>>;

package/dist/effects/HueSaturation.d.ts

@@ -0,0 +1,5 @@
+export declare const HueSaturation: ({ blendFunction, opacity, ...props }: {
+    [x: string]: any;
+    blendFunction?: any;
+    opacity?: any;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/effects/LUT.d.ts

@@ -0,0 +1,9 @@
+import { LUT3DEffect, BlendFunction } from 'postprocessing';
+import React from 'react';
+import type { Texture } from 'three';
+export type LUTProps = {
+    lut: Texture;
+    blendFunction?: BlendFunction;
+    tetrahedralInterpolation?: boolean;
+};
+export declare const LUT: React.ForwardRefExoticComponent<LUTProps & React.RefAttributes<LUT3DEffect>>;

package/dist/effects/LensFlare.d.ts

@@ -0,0 +1,54 @@
+import * as THREE from 'three';
+import { BlendFunction, Effect } from 'postprocessing';
+type LensFlareEffectOptions = {
+    /** The blend function of this effect */
+    blendFunction: BlendFunction;
+    /** Boolean to enable/disable the effect */
+    enabled: boolean;
+    /** The glare size */
+    glareSize: number;
+    /** The position of the lens flare in 3d space */
+    lensPosition: THREE.Vector3;
+    /** Effect resolution */
+    screenRes: THREE.Vector2;
+    /** The number of points for the star */
+    starPoints: number;
+    /** The flare side */
+    flareSize: number;
+    /** The flare animation speed */
+    flareSpeed: number;
+    /** Changes the appearance to anamorphic */
+    flareShape: number;
+    /** Animated flare */
+    animated: boolean;
+    /** Set the appearance to full anamorphic */
+    anamorphic: boolean;
+    /** Set the color gain for the lens flare. Must be a THREE.Color in RBG format */
+    colorGain: THREE.Color;
+    /** Texture to be used as color dirt for starburst effect */
+    lensDirtTexture: THREE.Texture | null;
+    /** The halo scale */
+    haloScale: number;
+    /** Option to enable/disable secondary ghosts */
+    secondaryGhosts: boolean;
+    /** Option to enable/disable aditional streaks */
+    aditionalStreaks: boolean;
+    /** Option to enable/disable secondary ghosts */
+    ghostScale: number;
+    /** TODO The opacity for this effect */
+    opacity: number;
+    /** Boolean to enable/disable the start burst effect. Can be disabled to improve performance */
+    starBurst: boolean;
+};
+export declare class LensFlareEffect extends Effect {
+    constructor({ blendFunction, enabled, glareSize, lensPosition, screenRes, starPoints, flareSize, flareSpeed, flareShape, animated, anamorphic, colorGain, lensDirtTexture, haloScale, secondaryGhosts, aditionalStreaks, ghostScale, opacity, starBurst, }: LensFlareEffectOptions);
+    update(_renderer: any, _inputBuffer: any, deltaTime: number): void;
+}
+type LensFlareProps = {
+    /** Position of the effect */
+    lensPosition?: THREE.Vector3;
+    /** The time that it takes to fade the occlusion */
+    smoothTime?: number;
+} & Partial<LensFlareEffectOptions>;
+export declare const LensFlare: ({ smoothTime, blendFunction, enabled, glareSize, lensPosition, screenRes, starPoints, flareSize, flareSpeed, flareShape, animated, anamorphic, colorGain, lensDirtTexture, haloScale, secondaryGhosts, aditionalStreaks, ghostScale, opacity, starBurst, }: LensFlareProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/effects/N8AO.d.ts

@@ -0,0 +1,17 @@
+/// <reference types="react" />
+import { ReactThreeFiber } from '@react-three/fiber';
+export type N8AOProps = {
+    aoRadius?: number;
+    distanceFalloff?: number;
+    intensity?: number;
+    quality?: 'performance' | 'low' | 'medium' | 'high' | 'ultra';
+    aoSamples?: number;
+    denoiseSamples?: number;
+    denoiseRadius?: number;
+    color?: ReactThreeFiber.Color;
+    halfRes?: boolean;
+    depthAwareUpsampling?: boolean;
+    screenSpaceRadius?: boolean;
+    renderMode?: 0 | 1 | 2 | 3 | 4;
+};
+export declare const N8AO: import("react").ForwardRefExoticComponent<N8AOProps & import("react").RefAttributes<N8AOPostPass>>;

package/dist/effects/Noise.d.ts

@@ -0,0 +1,5 @@
+export declare const Noise: ({ blendFunction, opacity, ...props }: {
+    [x: string]: any;
+    blendFunction?: any;
+    opacity?: any;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/effects/Outline.d.ts

@@ -0,0 +1,30 @@
+import { OutlineEffect } from 'postprocessing';
+import { RefObject } from 'react';
+import { Object3D } from 'three';
+type ObjectRef = RefObject<Object3D>;
+export type OutlineProps = ConstructorParameters<typeof OutlineEffect>[2] & Partial<{
+    selection: Object3D | Object3D[] | ObjectRef | ObjectRef[];
+    selectionLayer: number;
+}>;
+export declare const Outline: import("react").ForwardRefExoticComponent<{
+    blendFunction?: import("postprocessing").BlendFunction | undefined;
+    patternTexture?: import("three").Texture | undefined;
+    patternScale?: number | undefined;
+    edgeStrength?: number | undefined;
+    pulseSpeed?: number | undefined;
+    visibleEdgeColor?: number | undefined;
+    hiddenEdgeColor?: number | undefined;
+    multisampling?: number | undefined;
+    resolutionScale?: number | undefined;
+    resolutionX?: number | undefined;
+    resolutionY?: number | undefined;
+    width?: number | undefined;
+    height?: number | undefined;
+    kernelSize?: import("postprocessing").KernelSize | undefined;
+    blur?: boolean | undefined;
+    xRay?: boolean | undefined;
+} & Partial<{
+    selection: Object3D | Object3D[] | ObjectRef | ObjectRef[];
+    selectionLayer: number;
+}> & import("react").RefAttributes<OutlineEffect>>;
+export {};

package/dist/effects/Pixelation.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="react" />
+import { PixelationEffect } from 'postprocessing';
+export type PixelationProps = {
+    granularity?: number;
+};
+export declare const Pixelation: import("react").ForwardRefExoticComponent<PixelationProps & import("react").RefAttributes<PixelationEffect>>;

package/dist/effects/Ramp.d.ts

@@ -0,0 +1,78 @@
+import { Effect } from 'postprocessing';
+export declare enum RampType {
+    Linear = 0,
+    Radial = 1,
+    MirroredLinear = 2
+}
+export declare class RampEffect extends Effect {
+    constructor({ 
+    /**
+     * Type of ramp gradient.
+     */
+    rampType, 
+    /**
+     * Starting point of the ramp gradient in normalized coordinates.
+     *
+     * Ranges from `[0 - 1]` as `[x, y]`. Default is `[0.5, 0.5]`.
+     */
+    rampStart, 
+    /**
+     * Ending point of the ramp gradient in normalized coordinates.
+     *
+     * Ranges from `[0 - 1]` as `[x, y]`. Default is `[1, 1]`
+     */
+    rampEnd, 
+    /**
+     * Color at the starting point of the gradient.
+     *
+     * Default is black: `[0, 0, 0, 1]`
+     */
+    startColor, 
+    /**
+     * Color at the ending point of the gradient.
+     *
+     * Default is white: `[1, 1, 1, 1]`
+     */
+    endColor, 
+    /**
+     * Bias for the interpolation curve when both bias and gain are 0.5.
+     *
+     * Ranges from `[0 - 1]`. Default is `0.5`.
+     */
+    rampBias, 
+    /**
+     * Gain for the interpolation curve when both bias and gain are 0.5.
+     *
+     * Ranges from `[0 - 1]`. Default is `0.5`.
+     */
+    rampGain, 
+    /**
+     * When enabled, the ramp gradient is used as an effect mask, and colors are ignored.
+     *
+     * Default is `false`.
+     */
+    rampMask, 
+    /**
+     * Controls whether the ramp gradient is inverted.
+     *
+     * When disabled, rampStart is transparent and rampEnd is opaque.
+     *
+     * Default is `false`.
+     */
+    rampInvert, ...params }?: {
+        rampType?: RampType | undefined;
+        rampStart?: number[] | undefined;
+        rampEnd?: number[] | undefined;
+        startColor?: number[] | undefined;
+        endColor?: number[] | undefined;
+        rampBias?: number | undefined;
+        rampGain?: number | undefined;
+        rampMask?: boolean | undefined;
+        rampInvert?: boolean | undefined;
+    });
+}
+export declare const Ramp: ({ blendFunction, opacity, ...props }: {
+    [x: string]: any;
+    blendFunction?: any;
+    opacity?: any;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/effects/SMAA.d.ts

@@ -0,0 +1,5 @@
+export declare const SMAA: ({ blendFunction, opacity, ...props }: {
+    [x: string]: any;
+    blendFunction?: any;
+    opacity?: any;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/effects/SSAO.d.ts

@@ -0,0 +1,30 @@
+/// <reference types="react" />
+import { SSAOEffect, BlendFunction } from 'postprocessing';
+export declare const SSAO: import("react").ForwardRefExoticComponent<{
+    blendFunction?: BlendFunction | undefined;
+    distanceScaling?: boolean | undefined;
+    depthAwareUpsampling?: boolean | undefined;
+    normalDepthBuffer?: import("three").Texture | undefined;
+    samples?: number | undefined;
+    rings?: number | undefined;
+    worldDistanceThreshold?: number | undefined;
+    worldDistanceFalloff?: number | undefined;
+    worldProximityThreshold?: number | undefined;
+    worldProximityFalloff?: number | undefined;
+    distanceThreshold?: number | undefined;
+    distanceFalloff?: number | undefined;
+    rangeThreshold?: number | undefined;
+    rangeFalloff?: number | undefined;
+    minRadiusScale?: number | undefined;
+    luminanceInfluence?: number | undefined;
+    radius?: number | undefined;
+    intensity?: number | undefined;
+    bias?: number | undefined;
+    fade?: number | undefined;
+    color?: import("three").Color | undefined;
+    resolutionScale?: number | undefined;
+    resolutionX?: number | undefined;
+    resolutionY?: number | undefined;
+    width?: number | undefined;
+    height?: number | undefined;
+} & import("react").RefAttributes<SSAOEffect>>;

package/dist/effects/ScanlineEffect.d.ts

@@ -0,0 +1,5 @@
+export declare const Scanline: ({ blendFunction, opacity, ...props }: {
+    [x: string]: any;
+    blendFunction?: any;
+    opacity?: any;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/effects/SelectiveBloom.d.ts

@@ -0,0 +1,20 @@
+import { SelectiveBloomEffect } from 'postprocessing';
+import type { BloomEffectOptions } from 'postprocessing';
+import React, { RefObject } from 'react';
+import { Object3D } from 'three';
+type ObjectRef = RefObject<Object3D>;
+export type SelectiveBloomProps = BloomEffectOptions & Partial<{
+    lights: Object3D[] | ObjectRef[];
+    selection: Object3D | Object3D[] | ObjectRef | ObjectRef[];
+    selectionLayer: number;
+    inverted: boolean;
+    ignoreBackground: boolean;
+}>;
+export declare const SelectiveBloom: React.ForwardRefExoticComponent<BloomEffectOptions & Partial<{
+    lights: Object3D[] | ObjectRef[];
+    selection: Object3D | Object3D[] | ObjectRef | ObjectRef[];
+    selectionLayer: number;
+    inverted: boolean;
+    ignoreBackground: boolean;
+}> & React.RefAttributes<SelectiveBloomEffect>>;
+export {};

package/dist/effects/Sepia.d.ts

@@ -0,0 +1,5 @@
+export declare const Sepia: ({ blendFunction, opacity, ...props }: {
+    [x: string]: any;
+    blendFunction?: any;
+    opacity?: any;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/effects/ShockWave.d.ts

@@ -0,0 +1,5 @@
+export declare const ShockWave: ({ blendFunction, opacity, ...props }: {
+    [x: string]: any;
+    blendFunction?: any;
+    opacity?: any;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/effects/Texture.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="react" />
+import { TextureEffect } from 'postprocessing';
+export declare const Texture: import("react").ForwardRefExoticComponent<{
+    blendFunction?: import("postprocessing").BlendFunction | undefined;
+    texture?: import("three").Texture | undefined;
+    aspectCorrection?: boolean | undefined;
+} & {
+    textureSrc: string;
+    /** opacity of provided texture */
+    opacity?: number | undefined;
+} & import("react").RefAttributes<TextureEffect>>;

package/dist/effects/TiltShift.d.ts

@@ -0,0 +1,5 @@
+export declare const TiltShift: ({ blendFunction, opacity, ...props }: {
+    [x: string]: any;
+    blendFunction?: any;
+    opacity?: any;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/effects/TiltShift2.d.ts

@@ -0,0 +1,22 @@
+import { BlendFunction, Effect } from 'postprocessing';
+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
+    start, // [0,1] percentage x,y of screenspace
+    end, // [0,1] percentage x,y of screenspace
+    samples, // number of blur samples
+    direction, }?: {
+        blendFunction?: BlendFunction | undefined;
+        blur?: number | undefined;
+        taper?: number | undefined;
+        start?: number[] | undefined;
+        end?: number[] | undefined;
+        samples?: number | undefined;
+        direction?: number[] | undefined;
+    });
+}
+export declare const TiltShift2: ({ blendFunction, opacity, ...props }: {
+    [x: string]: any;
+    blendFunction?: any;
+    opacity?: any;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/effects/ToneMapping.d.ts

@@ -0,0 +1,8 @@
+import { ToneMappingEffect } from 'postprocessing';
+import { type EffectProps } from '../util';
+export type ToneMappingProps = EffectProps<typeof ToneMappingEffect>;
+export declare const ToneMapping: ({ blendFunction, opacity, ...props }: {
+    [x: string]: any;
+    blendFunction?: any;
+    opacity?: any;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/effects/Vignette.d.ts

@@ -0,0 +1,5 @@
+export declare const Vignette: ({ blendFunction, opacity, ...props }: {
+    [x: string]: any;
+    blendFunction?: any;
+    opacity?: any;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/effects/Water.d.ts

@@ -0,0 +1,12 @@
+import { BlendFunction, Effect } from 'postprocessing';
+export declare class WaterEffectImpl extends Effect {
+    constructor({ blendFunction, factor }?: {
+        blendFunction?: BlendFunction | undefined;
+        factor?: number | undefined;
+    });
+}
+export declare const WaterEffect: ({ blendFunction, opacity, ...props }: {
+    [x: string]: any;
+    blendFunction?: any;
+    opacity?: any;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/index.d.ts

@@ -1 +1,37 @@
-export * from '../src/index.ts'
+export * from './Selection';
+export * from './EffectComposer';
+export * from './util';
+export * from './effects/Autofocus';
+export * from './effects/LensFlare';
+export * from './effects/Bloom';
+export * from './effects/BrightnessContrast';
+export * from './effects/ChromaticAberration';
+export * from './effects/ColorAverage';
+export * from './effects/ColorDepth';
+export * from './effects/Depth';
+export * from './effects/DepthOfField';
+export * from './effects/DotScreen';
+export * from './effects/Glitch';
+export * from './effects/GodRays';
+export * from './effects/Grid';
+export * from './effects/HueSaturation';
+export * from './effects/Noise';
+export * from './effects/Outline';
+export * from './effects/Pixelation';
+export * from './effects/ScanlineEffect';
+export * from './effects/SelectiveBloom';
+export * from './effects/Sepia';
+export * from './effects/SSAO';
+export * from './effects/SMAA';
+export * from './effects/FXAA';
+export * from './effects/Ramp';
+export * from './effects/Texture';
+export * from './effects/ToneMapping';
+export * from './effects/Vignette';
+export * from './effects/ShockWave';
+export * from './effects/LUT';
+export * from './effects/TiltShift';
+export * from './effects/TiltShift2';
+export * from './effects/ASCII';
+export * from './effects/Water';
+export * from './effects/N8AO';

package/dist/util.d.ts

@@ -0,0 +1,17 @@
+import React, { RefObject } from 'react';
+import { Vector2 } from 'three';
+import * as THREE from 'three';
+import { type ThreeElement } from '@react-three/fiber';
+import type { Effect, Pass, BlendFunction } from 'postprocessing';
+export declare const resolveRef: <T>(ref: T | React.RefObject<T>) => T;
+export type EffectConstructor = new (...args: any[]) => Effect | Pass;
+export type EffectProps<T extends EffectConstructor> = ThreeElement<T> & ConstructorParameters<T>[0] & {
+    blendFunction?: BlendFunction;
+    opacity?: number;
+};
+export declare const wrapEffect: <T extends EffectConstructor>(effect: T, defaults?: EffectProps<T> | undefined) => ({ blendFunction, opacity, ...props }: {
+    [x: string]: any;
+    blendFunction?: any;
+    opacity?: any;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare const useVector2: (props: Record<string, unknown>, key: string) => THREE.Vector2;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@react-three/postprocessing",
-  "version": "3.0.3",
+  "version": "3.0.4",
   "description": "postprocessing wrapper for React and @react-three/fiber",
   "keywords": [
     "postprocessing",
@@ -24,11 +24,11 @@
     "url": "git+https://github.com/pmndrs/react-postprocessing.git"
   },
   "scripts": {
-    "build": "vite build",
+    "build": "rimraf dist && vite build && tsc",
     "eslint": "eslint . --fix --ext=js,ts,jsx,tsx",
     "eslint:ci": "eslint . --ext=js,ts,jsx,tsx",
     "test": "vitest run",
-    "typecheck": "tsc"
+    "typecheck": "tsc --noEmit"
   },
   "dependencies": {
     "maath": "^0.6.0",
@@ -36,7 +36,7 @@
     "postprocessing": "^6.36.6"
   },
   "devDependencies": {
-    "@react-three/fiber": "^9.0.1",
+    "@react-three/fiber": "^9.0.4",
     "@types/node": "^22.10.7",
     "@types/react": "^19.0.2",
     "@types/react-dom": "^19.0.2",
@@ -53,6 +53,7 @@
     "prettier": "^2.8.8",
     "react": "^19.0.0",
     "react-dom": "^19.0.0",
+    "rimraf": "^6.0.1",
     "three": "^0.156.0",
     "typescript": "^5.0.4",
     "vite": "^4.3.5",