@react-three/postprocessing 3.0.3 → 3.0.5

package/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2020 react-spring
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+MIT License
+
+Copyright (c) 2020 react-spring
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,81 +1,81 @@
-# react-postprocessing
-
-[![Version](https://img.shields.io/npm/v/@react-three/postprocessing?style=flat&colorA=000000&colorB=000000)](https://www.npmjs.com/package/@react-three/postprocessing)
-[![Storybook](https://img.shields.io/static/v1?message=Storybook&style=flat&colorA=000000&colorB=000000&label=&logo=storybook&logoColor=ffffff)](https://pmndrs.github.io/react-postprocessing)
-[![Downloads](https://img.shields.io/npm/dt/@react-three/postprocessing.svg?style=flat&colorA=000000&colorB=000000)](https://www.npmjs.com/package/@react-three/postprocessing)
-[![Discord Shield](https://img.shields.io/discord/740090768164651008?style=flat&colorA=000000&colorB=000000&label=discord&logo=discord&logoColor=ffffff)](https://discord.gg/ZZjjNvJ)
-[![Open in GitHub Codespaces](https://img.shields.io/static/v1?&message=Open%20in%20%20Codespaces&style=flat&colorA=000000&colorB=000000&label=GitHub&logo=github&logoColor=ffffff)](https://github.com/codespaces/new?template_repository=pmndrs%2Freact-postprocessing)
-
-`react-postprocessing` is a
-[postprocessing](https://github.com/pmndrs/postprocessing) wrapper for
-[@react-three/fiber](https://github.com/pmndrs/react-three-fiber). This is not
-(yet) meant for complex orchestration of effects, but can save you
-[hundreds of LOC](https://twitter.com/0xca0a/status/1289501594698960897) for a
-straight forward effects-chain.
-
-```bash
-npm install @react-three/postprocessing
-```
-
-<p align="center">
-  <a href="https://pqrpl.csb.app" target="_blank"><img width="274" src="bubbles.jpg" alt="Bubbles" /></a>
-  <a href="https://5jgjz.csb.app" target="_blank"><img width="274" src="control.jpg" alt="Take Control" /></a>
-</p>
-<p align="middle">
-  <i>These demos are real, you can click them! They contain the full code, too. 📦</i>
-</p>
-
-#### Why postprocessing and not three/examples/jsm/postprocessing?
-
-From
-[https://github.com/pmndrs/postprocessing](https://github.com/pmndrs/postprocessing#performance)
-
-> This library provides an EffectPass which automatically organizes and merges
-> any given combination of effects. This minimizes the amount of render
-> operations and makes it possible to combine many effects without the
-> performance penalties of traditional pass chaining. Additionally, every effect
-> can choose its own blend function.
->
-> All fullscreen render operations also use a single triangle that fills the
-> screen. Compared to using a quad, this approach harmonizes with modern GPU
-> rasterization patterns and eliminates unnecessary fragment calculations along
-> the screen diagonal. This is especially beneficial for GPGPU passes and
-> effects that use complex fragment shaders.
-
-Postprocessing also supports gamma correction out of the box, as well as WebGL2
-MSAA (multi sample anti aliasing), which is react-postprocessing's default, you
-get high performance crisp results w/o jagged edges.
-
-#### What does it look like?
-
-Here's an example combining a couple of effects
-([live demo](https://codesandbox.io/s/react-postprocessing-dof-blob-pqrpl?)).
-
-<a href="https://codesandbox.io/s/react-postprocessing-dof-blob-pqrpl?" target="_blank" rel="noopener">
-<img src="bubbles.jpg" alt="Bubbles Demo" />
-</a>
-
-```jsx
-import React from 'react'
-import { Bloom, DepthOfField, EffectComposer, Noise, Vignette } from '@react-three/postprocessing'
-import { Canvas } from '@react-three/fiber'
-
-function App() {
-  return (
-    <Canvas>
-      {/* Your regular scene contents go here, like always ... */}
-      <EffectComposer>
-        <DepthOfField focusDistance={0} focalLength={0.02} bokehScale={2} height={480} />
-        <Bloom luminanceThreshold={0} luminanceSmoothing={0.9} height={300} />
-        <Noise opacity={0.02} />
-        <Vignette eskil={false} offset={0.1} darkness={1.1} />
-      </EffectComposer>
-    </Canvas>
-  )
-}
-```
-
-## Documentation
-
-- [react-postprocessing docs](https://docs.pmnd.rs/react-postprocessing)
-- [postprocessing docs](https://pmndrs.github.io/postprocessing/public/docs/)
+# react-postprocessing
+
+[![Version](https://img.shields.io/npm/v/@react-three/postprocessing?style=flat&colorA=000000&colorB=000000)](https://www.npmjs.com/package/@react-three/postprocessing)
+[![Storybook](https://img.shields.io/static/v1?message=Storybook&style=flat&colorA=000000&colorB=000000&label=&logo=storybook&logoColor=ffffff)](https://pmndrs.github.io/react-postprocessing)
+[![Downloads](https://img.shields.io/npm/dt/@react-three/postprocessing.svg?style=flat&colorA=000000&colorB=000000)](https://www.npmjs.com/package/@react-three/postprocessing)
+[![Discord Shield](https://img.shields.io/discord/740090768164651008?style=flat&colorA=000000&colorB=000000&label=discord&logo=discord&logoColor=ffffff)](https://discord.gg/ZZjjNvJ)
+[![Open in GitHub Codespaces](https://img.shields.io/static/v1?&message=Open%20in%20%20Codespaces&style=flat&colorA=000000&colorB=000000&label=GitHub&logo=github&logoColor=ffffff)](https://github.com/codespaces/new?template_repository=pmndrs%2Freact-postprocessing)
+
+`react-postprocessing` is a
+[postprocessing](https://github.com/pmndrs/postprocessing) wrapper for
+[@react-three/fiber](https://github.com/pmndrs/react-three-fiber). This is not
+(yet) meant for complex orchestration of effects, but can save you
+[hundreds of LOC](https://twitter.com/0xca0a/status/1289501594698960897) for a
+straight forward effects-chain.
+
+```bash
+npm install @react-three/postprocessing
+```
+
+<p align="center">
+  <a href="https://pqrpl.csb.app" target="_blank"><img width="274" src="bubbles.jpg" alt="Bubbles" /></a>
+  <a href="https://5jgjz.csb.app" target="_blank"><img width="274" src="control.jpg" alt="Take Control" /></a>
+</p>
+<p align="middle">
+  <i>These demos are real, you can click them! They contain the full code, too. 📦</i>
+</p>
+
+#### Why postprocessing and not three/examples/jsm/postprocessing?
+
+From
+[https://github.com/pmndrs/postprocessing](https://github.com/pmndrs/postprocessing#performance)
+
+> This library provides an EffectPass which automatically organizes and merges
+> any given combination of effects. This minimizes the amount of render
+> operations and makes it possible to combine many effects without the
+> performance penalties of traditional pass chaining. Additionally, every effect
+> can choose its own blend function.
+>
+> All fullscreen render operations also use a single triangle that fills the
+> screen. Compared to using a quad, this approach harmonizes with modern GPU
+> rasterization patterns and eliminates unnecessary fragment calculations along
+> the screen diagonal. This is especially beneficial for GPGPU passes and
+> effects that use complex fragment shaders.
+
+Postprocessing also supports gamma correction out of the box, as well as WebGL2
+MSAA (multi sample anti aliasing), which is react-postprocessing's default, you
+get high performance crisp results w/o jagged edges.
+
+#### What does it look like?
+
+Here's an example combining a couple of effects
+([live demo](https://codesandbox.io/s/react-postprocessing-dof-blob-pqrpl?)).
+
+<a href="https://codesandbox.io/s/react-postprocessing-dof-blob-pqrpl?" target="_blank" rel="noopener">
+<img src="bubbles.jpg" alt="Bubbles Demo" />
+</a>
+
+```jsx
+import React from 'react'
+import { Bloom, DepthOfField, EffectComposer, Noise, Vignette } from '@react-three/postprocessing'
+import { Canvas } from '@react-three/fiber'
+
+function App() {
+  return (
+    <Canvas>
+      {/* Your regular scene contents go here, like always ... */}
+      <EffectComposer>
+        <DepthOfField focusDistance={0} focalLength={0.02} bokehScale={2} height={480} />
+        <Bloom luminanceThreshold={0} luminanceSmoothing={0.9} height={300} />
+        <Noise opacity={0.02} />
+        <Vignette eskil={false} offset={0.1} darkness={1.1} />
+      </EffectComposer>
+    </Canvas>
+  )
+}
+```
+
+## Documentation
+
+- [react-postprocessing docs](https://docs.pmnd.rs/react-postprocessing)
+- [postprocessing docs](https://pmndrs.github.io/postprocessing/public/docs/)

package/dist/EffectComposer.d.ts

@@ -0,0 +1,28 @@
+import { DepthDownsamplingPass, EffectComposer as EffectComposerImpl, NormalPass } from 'postprocessing';
+import { type ReactNode, type Ref } from 'react';
+import type { Camera, Scene, TextureDataType } from 'three';
+export declare const EffectComposerContext: import("react").Context<{
+    composer: EffectComposerImpl;
+    normalPass: NormalPass | null;
+    downSamplingPass: DepthDownsamplingPass | null;
+    camera: Camera;
+    scene: Scene;
+    resolutionScale?: number;
+}>;
+export type EffectComposerProps = {
+    enabled?: boolean;
+    children: ReactNode;
+    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;
+    ref?: Ref<EffectComposerImpl>;
+};
+export declare const EffectComposer: import("react").MemoExoticComponent<({ children, camera: _camera, scene: _scene, resolutionScale, enabled, renderPriority, autoClear, depthBuffer, enableNormalPass, stencilBuffer, multisampling, frameBufferType, ref, }: EffectComposerProps) => import("react").JSX.Element | null>;

package/dist/Selection.d.ts

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

package/dist/effects/ASCII.d.ts

@@ -0,0 +1,19 @@
+import { Effect } from 'postprocessing';
+import { Ref } from 'react';
+import { Texture } from 'three';
+interface IASCIIEffectProps {
+    font?: string;
+    characters?: string;
+    fontSize?: number;
+    cellSize?: number;
+    color?: string;
+    invert?: boolean;
+    ref?: Ref<ASCIIEffect>;
+}
+declare class ASCIIEffect extends Effect {
+    constructor({ font, characters, fontSize, cellSize, color, invert, }?: Omit<IASCIIEffectProps, 'ref'>);
+    /** Draws the characters on a Canvas and returns a texture */
+    createCharactersTexture(characters: string, font: string, fontSize: number): Texture;
+}
+export declare function ASCII({ font, characters, fontSize, cellSize, color, invert, ref, }: IASCIIEffectProps): import("react").JSX.Element;
+export {};

package/dist/effects/Autofocus.d.ts

@@ -0,0 +1,23 @@
+import { type Vector3 as R3FVector3 } from '@react-three/fiber';
+import { DepthOfFieldEffect } from 'postprocessing';
+import { Ref, type ComponentProps, type RefObject } from 'react';
+import { Vector3 } from 'three';
+import { DepthOfField } from './DepthOfField';
+export type AutofocusProps = ComponentProps<typeof DepthOfField> & {
+    target?: R3FVector3;
+    /** 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;
+    ref?: Ref<AutofocusApi>;
+};
+export type AutofocusApi = {
+    dofRef: RefObject<DepthOfFieldEffect | null>;
+    hitpoint: Vector3;
+    update: (delta: number, updateTarget: boolean) => void;
+};
+export declare function Autofocus({ target, mouse: followMouse, debug, manual, smoothTime, ref, ...props }: AutofocusProps): import("react").JSX.Element;

package/dist/effects/Bloom.d.ts

@@ -0,0 +1,2 @@
+import { BloomEffect } from 'postprocessing';
+export declare const Bloom: (props: import("..").EffectProps<typeof BloomEffect>) => import("react").JSX.Element;

package/dist/effects/BrightnessContrast.d.ts

@@ -0,0 +1,2 @@
+import { BrightnessContrastEffect } from 'postprocessing';
+export declare const BrightnessContrast: (props: import("..").EffectProps<typeof BrightnessContrastEffect>) => import("react").JSX.Element;

package/dist/effects/ChromaticAberration.d.ts

@@ -0,0 +1,8 @@
+import type { ReactThreeFiber } from '@react-three/fiber';
+import { ChromaticAberrationEffect } from 'postprocessing';
+import type { Ref } from 'react';
+export type ChromaticAberrationProps = Omit<Partial<ConstructorParameters<typeof ChromaticAberrationEffect>[0]>, 'offset'> & {
+    ref?: Ref<ChromaticAberrationEffect>;
+    offset?: ReactThreeFiber.Vector2;
+};
+export declare function ChromaticAberration({ ref, ...props }: ChromaticAberrationProps): import("react").JSX.Element;

package/dist/effects/ColorAverage.d.ts

@@ -0,0 +1,7 @@
+import { BlendFunction, ColorAverageEffect } from 'postprocessing';
+import type { Ref } from 'react';
+export type ColorAverageProps = {
+    blendFunction?: BlendFunction;
+    ref?: Ref<ColorAverageEffect>;
+};
+export declare function ColorAverage({ blendFunction, ref }: ColorAverageProps): import("react").JSX.Element;

package/dist/effects/ColorDepth.d.ts

@@ -0,0 +1,2 @@
+import { ColorDepthEffect } from 'postprocessing';
+export declare const ColorDepth: (props: import("..").EffectProps<typeof ColorDepthEffect>) => import("react").JSX.Element;

package/dist/effects/Depth.d.ts

@@ -0,0 +1,2 @@
+import { DepthEffect } from 'postprocessing';
+export declare const Depth: (props: import("..").EffectProps<typeof DepthEffect>) => import("react").JSX.Element;

package/dist/effects/DepthOfField.d.ts

@@ -0,0 +1,14 @@
+import type { ReactThreeFiber } from '@react-three/fiber';
+import { DepthOfFieldEffect } from 'postprocessing';
+import type { Ref } from 'react';
+import { type Texture } from 'three';
+export type DepthOfFieldProps = ConstructorParameters<typeof DepthOfFieldEffect>[1] & Partial<{
+    ref: Ref<DepthOfFieldEffect>;
+    target: ReactThreeFiber.Vector3;
+    depthTexture: {
+        texture: Texture;
+        packing: number;
+    };
+    blur: number;
+}>;
+export declare function DepthOfField({ ref, blendFunction, worldFocusDistance, worldFocusRange, focusDistance, focusRange, focalLength, bokehScale, resolutionScale, resolutionX, resolutionY, width, height, target, depthTexture, ...props }: DepthOfFieldProps): import("react").JSX.Element;

package/dist/effects/DotScreen.d.ts

@@ -0,0 +1,2 @@
+import { DotScreenEffect } from 'postprocessing';
+export declare const DotScreen: (props: import("..").EffectProps<typeof DotScreenEffect>) => import("react").JSX.Element;

package/dist/effects/FXAA.d.ts

@@ -0,0 +1,2 @@
+import { FXAAEffect } from 'postprocessing';
+export declare const FXAA: (props: import("..").EffectProps<typeof FXAAEffect>) => import("react").JSX.Element;

package/dist/effects/Glitch.d.ts

@@ -0,0 +1,13 @@
+import { ReactThreeFiber } from '@react-three/fiber';
+import { GlitchEffect, GlitchMode } from 'postprocessing';
+import { Ref } from 'react';
+export type GlitchProps = ConstructorParameters<typeof GlitchEffect>[0] & Partial<{
+    mode: GlitchMode;
+    active: boolean;
+    delay: ReactThreeFiber.Vector2;
+    duration: ReactThreeFiber.Vector2;
+    chromaticAberrationOffset: ReactThreeFiber.Vector2;
+    strength: ReactThreeFiber.Vector2;
+    ref?: Ref<GlitchEffect>;
+}>;
+export declare function Glitch({ active, ref, ...props }: GlitchProps): import("react").JSX.Element;

package/dist/effects/GodRays.d.ts

@@ -0,0 +1,9 @@
+import { GodRaysEffect } from 'postprocessing';
+import { Ref, RefObject } from 'react';
+import { Mesh, Points } from 'three';
+type GodRaysProps = ConstructorParameters<typeof GodRaysEffect>[2] & {
+    sun: Mesh | Points | RefObject<Mesh | Points>;
+    ref?: Ref<GodRaysEffect>;
+};
+export declare function GodRays({ ref, ...props }: GodRaysProps): import("react").JSX.Element;
+export {};

package/dist/effects/Grid.d.ts

@@ -0,0 +1,11 @@
+import { GridEffect } from 'postprocessing';
+import { Ref } from 'react';
+type GridProps = ConstructorParameters<typeof GridEffect>[0] & Partial<{
+    size: {
+        width: number;
+        height: number;
+    };
+    ref: Ref<GridEffect>;
+}>;
+export declare function Grid({ size, ref, ...props }: GridProps): import("react").JSX.Element;
+export {};

package/dist/effects/HueSaturation.d.ts

@@ -0,0 +1,2 @@
+import { HueSaturationEffect } from 'postprocessing';
+export declare const HueSaturation: (props: import("..").EffectProps<typeof HueSaturationEffect>) => import("react").JSX.Element;

package/dist/effects/LUT.d.ts

@@ -0,0 +1,10 @@
+import { BlendFunction, LUT3DEffect } from 'postprocessing';
+import { Ref } from 'react';
+import type { Texture } from 'three';
+export type LUTProps = {
+    lut: Texture;
+    blendFunction?: BlendFunction;
+    tetrahedralInterpolation?: boolean;
+    ref?: Ref<LUT3DEffect>;
+};
+export declare function LUT({ lut, tetrahedralInterpolation, ref, ...props }: LUTProps): import("react").JSX.Element;

package/dist/effects/LensFlare.d.ts

@@ -0,0 +1,54 @@
+import { BlendFunction, Effect } from 'postprocessing';
+import { Color, Texture, Vector2, Vector3 } from 'three';
+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: Vector3;
+    /** Effect resolution */
+    screenRes: 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 Color in RBG format */
+    colorGain: Color;
+    /** Texture to be used as color dirt for starburst effect */
+    lensDirtTexture: 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?: 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.Element;
+export {};

package/dist/effects/N8AO.d.ts

@@ -0,0 +1,19 @@
+import { ReactThreeFiber } from '@react-three/fiber';
+import { Ref } from 'react';
+import { N8AOPostPass } from 'n8ao';
+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;
+    ref?: Ref<N8AOPostPass>;
+};
+export declare function N8AO({ halfRes, screenSpaceRadius, quality, depthAwareUpsampling, aoRadius, aoSamples, denoiseSamples, denoiseRadius, distanceFalloff, intensity, color, renderMode, ref, }: N8AOProps): import("react").JSX.Element;

package/dist/effects/Noise.d.ts

@@ -0,0 +1,2 @@
+import { NoiseEffect } from 'postprocessing';
+export declare const Noise: (props: import("..").EffectProps<typeof NoiseEffect>) => import("react").JSX.Element;

package/dist/effects/Outline.d.ts

@@ -0,0 +1,11 @@
+import { OutlineEffect } from 'postprocessing';
+import { Ref, RefObject } from 'react';
+import { Object3D } from 'three';
+type ObjectRef = RefObject<Object3D | null>;
+export type OutlineProps = ConstructorParameters<typeof OutlineEffect>[2] & Partial<{
+    selection: Object3D | Object3D[] | ObjectRef | ObjectRef[];
+    selectionLayer: number;
+    ref?: Ref<OutlineEffect>;
+}>;
+export declare function Outline({ selection, selectionLayer, blendFunction, patternTexture, patternScale, edgeStrength, pulseSpeed, visibleEdgeColor, hiddenEdgeColor, multisampling, resolutionScale, resolutionX, resolutionY, width, height, kernelSize, blur, xRay, ref, }: OutlineProps): import("react").JSX.Element;
+export {};

package/dist/effects/Pixelation.d.ts

@@ -0,0 +1,7 @@
+import { PixelationEffect } from 'postprocessing';
+import { Ref } from 'react';
+export type PixelationProps = {
+    granularity?: number;
+    ref?: Ref<PixelationEffect>;
+};
+export declare function Pixelation({ granularity, ref }: PixelationProps): import("react").JSX.Element;

package/dist/effects/Ramp.d.ts

@@ -0,0 +1,74 @@
+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: (props: import("..").EffectProps<typeof RampEffect>) => import("react").JSX.Element;

package/dist/effects/SMAA.d.ts

@@ -0,0 +1,2 @@
+import { SMAAEffect } from 'postprocessing';
+export declare const SMAA: (props: import("..").EffectProps<typeof SMAAEffect>) => import("react").JSX.Element;

package/dist/effects/SSAO.d.ts

@@ -0,0 +1,7 @@
+import { SSAOEffect } from 'postprocessing';
+import { Ref } from 'react';
+type SSAOProps = ConstructorParameters<typeof SSAOEffect>[2] & {
+    ref?: Ref<SSAOEffect>;
+};
+export declare function SSAO({ ref, ...props }: SSAOProps): import("react").JSX.Element;
+export {};

package/dist/effects/ScanlineEffect.d.ts

@@ -0,0 +1,2 @@
+import { ScanlineEffect } from 'postprocessing';
+export declare const Scanline: (props: import("..").EffectProps<typeof ScanlineEffect>) => import("react").JSX.Element;

package/dist/effects/SelectiveBloom.d.ts

@@ -0,0 +1,15 @@
+import type { BloomEffectOptions } from 'postprocessing';
+import { SelectiveBloomEffect } from 'postprocessing';
+import { Ref, RefObject } from 'react';
+import { Object3D } from 'three';
+type ObjectRef = RefObject<Object3D | null>;
+export type SelectiveBloomProps = BloomEffectOptions & Partial<{
+    lights: Object3D[] | ObjectRef[];
+    selection: Object3D | Object3D[] | ObjectRef | ObjectRef[];
+    selectionLayer: number;
+    inverted: boolean;
+    ignoreBackground: boolean;
+    ref?: Ref<SelectiveBloomEffect>;
+}>;
+export declare function SelectiveBloom({ selection, selectionLayer, lights, inverted, ignoreBackground, luminanceThreshold, luminanceSmoothing, mipmapBlur, intensity, radius, levels, kernelSize, resolutionScale, width, height, resolutionX, resolutionY, ref, }: SelectiveBloomProps): import("react").JSX.Element;
+export {};

package/dist/effects/Sepia.d.ts

@@ -0,0 +1,2 @@
+import { SepiaEffect } from 'postprocessing';
+export declare const Sepia: (props: import("..").EffectProps<typeof SepiaEffect>) => import("react").JSX.Element;

package/dist/effects/ShockWave.d.ts

@@ -0,0 +1,2 @@
+import { ShockWaveEffect } from 'postprocessing';
+export declare const ShockWave: (props: import("..").EffectProps<typeof ShockWaveEffect>) => import("react").JSX.Element;