@tresjs/post-processing 2.0.0 → 2.2.0

package/dist/core/pmndrs/BarrelBlurPmndrs.vue.d.ts

@@ -0,0 +1,26 @@
+import { BlendFunction } from 'postprocessing';
+import { Vector2 } from 'three';
+import { BarrelBlurEffect } from './custom/barrel-blur/index';
+export interface BarrelBlurPmndrsProps {
+    /**
+     * The blend function for the effect.
+     * Determines how this effect blends with other effects.
+     */
+    blendFunction?: BlendFunction;
+    /**
+     * The intensity of the barrel distortion.
+     * A value between 0 (no distortion) and 1 (maximum distortion).
+     */
+    amount?: number;
+    /**
+     * The offset of the barrel distortion center.
+     * A Vector2 value or an A value or an array of two numbers, with both values ranging from 0 to 1.
+     * This allows you to change the position of the distortion effect.
+     */
+    offset?: Vector2 | [number, number];
+}
+declare const _default: import('vue').DefineComponent<BarrelBlurPmndrsProps, {
+    pass: import('vue').ShallowRef<import('postprocessing').EffectPass | null>;
+    effect: import('vue').ShallowRef<BarrelBlurEffect | null>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<BarrelBlurPmndrsProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/core/pmndrs/BrightnessContrastPmndrs.vue.d.ts

@@ -0,0 +1,20 @@
+import { BlendFunction, BrightnessContrastEffect } from 'postprocessing';
+export interface BrightnessContrastPmndrsProps {
+    /**
+     * The blend function.
+     */
+    blendFunction?: BlendFunction;
+    /**
+     * The brightness of the effect.
+     */
+    brightness?: number;
+    /**
+     * The contrast of the effect.
+     */
+    contrast?: number;
+}
+declare const _default: import('vue').DefineComponent<BrightnessContrastPmndrsProps, {
+    pass: import('vue').ShallowRef<import('postprocessing').EffectPass | null>;
+    effect: import('vue').ShallowRef<BrightnessContrastEffect | null>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<BrightnessContrastPmndrsProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/core/pmndrs/ChromaticAberrationPmndrs.vue.d.ts

@@ -0,0 +1,27 @@
+import { ChromaticAberrationEffect, BlendFunction } from 'postprocessing';
+import { Vector2 } from 'three';
+export interface ChromaticAberrationPmndrsProps {
+    /**
+     * The blend function.
+     */
+    blendFunction?: BlendFunction;
+    /**
+     * The color offset.
+     */
+    offset?: Vector2;
+    /**
+     * Whether the effect should be modulated with a radial gradient.
+     */
+    radialModulation?: boolean;
+    /**
+     * The modulation offset, applicable if radial modulation is enabled.
+     */
+    modulationOffset?: number;
+}
+declare const _default: import('vue').DefineComponent<ChromaticAberrationPmndrsProps, {
+    pass: import('vue').ShallowRef<import('postprocessing').EffectPass | null>;
+    effect: import('vue').ShallowRef<ChromaticAberrationEffect | null>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<ChromaticAberrationPmndrsProps> & Readonly<{}>, {
+    radialModulation: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/core/pmndrs/ColorAveragePmndrs.vue.d.ts

@@ -0,0 +1,16 @@
+import { BlendFunction, ColorAverageEffect } from 'postprocessing';
+export interface ColorAveragePmndrsProps {
+    /**
+     * The blend function.
+     */
+    blendFunction?: BlendFunction;
+    /**
+     * The opacity of the color Average.
+     */
+    opacity?: number;
+}
+declare const _default: import('vue').DefineComponent<ColorAveragePmndrsProps, {
+    pass: import('vue').ShallowRef<import('postprocessing').EffectPass | null>;
+    effect: import('vue').ShallowRef<ColorAverageEffect | null>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<ColorAveragePmndrsProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/core/pmndrs/ColorDepthPmndrs.vue.d.ts

@@ -0,0 +1,20 @@
+import { BlendFunction, ColorDepthEffect } from 'postprocessing';
+export interface ColorDepthPmndrsProps {
+    /**
+     * The blend function.
+     */
+    blendFunction?: BlendFunction;
+    /**
+     * The color bit depth.
+     */
+    bits?: number;
+    /**
+     * The opacity of the effect.
+     */
+    opacity?: number;
+}
+declare const _default: import('vue').DefineComponent<ColorDepthPmndrsProps, {
+    pass: import('vue').ShallowRef<import('postprocessing').EffectPass | null>;
+    effect: import('vue').ShallowRef<ColorDepthEffect | null>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<ColorDepthPmndrsProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/core/pmndrs/DepthPickingPassPmndrs.vue.d.ts

@@ -0,0 +1,18 @@
+import { DepthPackingStrategies } from 'three';
+import { DepthCopyMode, DepthPickingPass } from 'postprocessing';
+export interface DepthPickingPassPmndrsProps {
+    /**
+     * The depth packing strategy.
+     * Default: RGBADepthPacking
+     */
+    depthPacking?: DepthPackingStrategies;
+    /**
+     * The depth copy mode.
+     * Default: DepthCopyMode.SINGLE
+     */
+    mode?: DepthCopyMode;
+}
+declare const _default: import('vue').DefineComponent<DepthPickingPassPmndrsProps, {
+    pass: DepthPickingPass;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<DepthPickingPassPmndrsProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/core/pmndrs/DotScreenPmndrs.vue.d.ts

@@ -0,0 +1,22 @@
+import { BlendFunction, DotScreenEffect } from 'postprocessing';
+export interface DotScreenPmndrsProps {
+    /**
+     * The angle of the dot pattern.
+     * Default: 1.57
+     */
+    angle?: number;
+    /**
+     * The scale of the dot pattern.
+     * Default: 1.0
+     */
+    scale?: number;
+    /**
+     * The blend function. Defines how the effect blends with the original scene.
+     */
+    blendFunction?: BlendFunction;
+}
+declare const _default: import('vue').DefineComponent<DotScreenPmndrsProps, {
+    pass: import('vue').ShallowRef<import('postprocessing').EffectPass | null>;
+    effect: import('vue').ShallowRef<DotScreenEffect | null>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<DotScreenPmndrsProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/core/pmndrs/FishEyePmndrs.vue.d.ts

@@ -0,0 +1,30 @@
+import { BlendFunction } from 'postprocessing';
+import { Vector2 } from 'three';
+import { FishEyeEffect } from './custom/fish-eye/index';
+export interface FishEyePmndrsProps {
+    /**
+     * The blend function for the effect.
+     * Determines how this effect blends with other effects.
+     */
+    blendFunction?: BlendFunction;
+    /**
+     * The lens scale.
+     * A Vector2 value or an array of two numbers.
+     */
+    lensS?: Vector2 | [number, number];
+    /**
+     * The lens factor.
+     * A Vector2 value or an array of two numbers.
+     */
+    lensF?: Vector2 | [number, number];
+    /**
+     * The scale of the effect.
+     * A number value.
+     */
+    scale?: number;
+}
+declare const _default: import('vue').DefineComponent<FishEyePmndrsProps, {
+    pass: import('vue').ShallowRef<import('postprocessing').EffectPass | null>;
+    effect: import('vue').ShallowRef<FishEyeEffect | null>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<FishEyePmndrsProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/core/pmndrs/GodRaysPmndrs.vue.d.ts

@@ -0,0 +1,65 @@
+import { BlendFunction, KernelSize, GodRaysEffect } from 'postprocessing';
+import { Mesh, Points } from 'three';
+export interface GodRaysPmndrsProps {
+    /**
+     * The blend function of this effect.
+     */
+    blendFunction?: BlendFunction;
+    /**
+     * The light source. Must not write depth and has to be flagged as transparent.
+     */
+    lightSource?: Mesh | Points;
+    /**
+     * The opacity of the God Rays.
+     */
+    opacity?: number;
+    /**
+     * The density of the light rays.
+     */
+    density?: number;
+    /**
+     * The decay of the light rays.
+     */
+    decay?: number;
+    /**
+     * The blur kernel size. Has no effect if blur is disabled.
+     */
+    kernelSize?: KernelSize;
+    /**
+     * The resolution scale.
+     */
+    resolutionScale?: number;
+    /**
+     * Whether the god rays should be blurred to reduce artifacts.
+     */
+    blur?: boolean;
+    /**
+     * The horizontal resolution.
+     */
+    resolutionX?: number;
+    /**
+     * The vertical resolution.
+     */
+    resolutionY?: number;
+    /**
+     * The weight of the light rays.
+     */
+    weight?: number;
+    /**
+     * A constant attenuation coefficient.
+     */
+    exposure?: number;
+    /**
+     * The number of samples per pixel.
+     */
+    samples?: number;
+    /**
+     * An upper bound for the saturation of the overall effect.
+     */
+    clampMax?: number;
+}
+declare const _default: import('vue').DefineComponent<GodRaysPmndrsProps, {
+    pass: import('vue').ShallowRef<import('postprocessing').EffectPass | null>;
+    effect: import('vue').ShallowRef<GodRaysEffect | null>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<GodRaysPmndrsProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/core/pmndrs/GridPmndrs.vue.d.ts

@@ -0,0 +1,20 @@
+import { BlendFunction, GridEffect } from 'postprocessing';
+export interface GridPmndrsProps {
+    /**
+     * The blend function.
+     */
+    blendFunction?: BlendFunction;
+    /**
+     * The scale.
+     */
+    scale?: number;
+    /**
+     * The line width.
+     */
+    lineWidth?: number;
+}
+declare const _default: import('vue').DefineComponent<GridPmndrsProps, {
+    pass: import('vue').ShallowRef<import('postprocessing').EffectPass | null>;
+    effect: import('vue').ShallowRef<GridEffect | null>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<GridPmndrsProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/core/pmndrs/HueSaturationPmndrs.vue.d.ts

@@ -0,0 +1,22 @@
+import { BlendFunction, HueSaturationEffect } from 'postprocessing';
+export interface HueSaturationPmndrsProps {
+    /**
+     * The saturation adjustment. A value of 0.0 results in grayscale, and 1.0 leaves saturation unchanged.
+     * Range: [0.0, 1.0]
+     */
+    saturation?: number;
+    /**
+     * The hue adjustment in radians.
+     * Range: [-π, π] (or [0, 2π] for a full rotation)
+     */
+    hue?: number;
+    /**
+     * The blend function. Defines how the effect blends with the original scene.
+     */
+    blendFunction?: BlendFunction;
+}
+declare const _default: import('vue').DefineComponent<HueSaturationPmndrsProps, {
+    pass: import('vue').ShallowRef<import('postprocessing').EffectPass | null>;
+    effect: import('vue').ShallowRef<HueSaturationEffect | null>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<HueSaturationPmndrsProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/core/pmndrs/KuwaharaPmndrs.vue.d.ts

@@ -0,0 +1,27 @@
+import { BlendFunction } from 'postprocessing';
+import { KuwaharaEffect } from './custom/kuwahara/index';
+export interface KuwaharaPmndrsProps {
+    /**
+     * The blend function for the effect.
+     * Determines how this effect blends with other effects.
+     */
+    blendFunction?: BlendFunction;
+    /**
+     * The intensity of the barrel distortion.
+     * A value between 0 (no distortion) and 1 (maximum distortion).
+     */
+    radius?: number;
+    /**
+     * The number of sectors.
+     * Determines the number of angular divisions used in the Kuwahara filter.
+     * Higher values can improve the quality of the effect but may reduce performance.
+     * The maximum value is defined by MAX_SECTOR_COUNT = 8 in the kuwahara/index.ts file.
+     * It is preferable that the value is an integer.
+     */
+    sectorCount?: number;
+}
+declare const _default: import('vue').DefineComponent<KuwaharaPmndrsProps, {
+    pass: import('vue').ShallowRef<import('postprocessing').EffectPass | null>;
+    effect: import('vue').ShallowRef<KuwaharaEffect | null>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<KuwaharaPmndrsProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/core/pmndrs/LensDistortionPmndrs.vue.d.ts

@@ -0,0 +1,25 @@
+import { LensDistortionEffect } from 'postprocessing';
+import { Vector2 } from 'three';
+export interface LensDistortionPmndrsProps {
+    /**
+     * The distortion effect strength.
+     */
+    distortion?: Vector2 | [number, number];
+    /**
+     * The center point.
+     */
+    principalPoint?: Vector2 | [number, number];
+    /**
+     * The focal length.
+     */
+    focalLength?: Vector2 | [number, number];
+    /**
+     * The skew value.
+     */
+    skew?: number;
+}
+declare const _default: import('vue').DefineComponent<LensDistortionPmndrsProps, {
+    pass: import('vue').ShallowRef<import('postprocessing').EffectPass | null>;
+    effect: import('vue').ShallowRef<LensDistortionEffect | null>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<LensDistortionPmndrsProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/core/pmndrs/LinocutPmndrs.vue.d.ts

@@ -0,0 +1,15 @@
+import { BlendFunction } from 'postprocessing';
+import { LinocutEffect } from './custom/linocut/index';
+import { Vector2 } from 'three';
+export interface LinocutPmndrsProps {
+    blendFunction?: BlendFunction;
+    scale?: number;
+    noiseScale?: number;
+    center?: Vector2 | [number, number];
+    rotation?: number;
+}
+declare const _default: import('vue').DefineComponent<LinocutPmndrsProps, {
+    pass: import('vue').ShallowRef<import('postprocessing').EffectPass | null>;
+    effect: import('vue').ShallowRef<LinocutEffect | null>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<LinocutPmndrsProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/core/pmndrs/NoisePmndrs.vue.d.ts

@@ -10,7 +10,6 @@ declare const _default: import('vue').DefineComponent<NoisePmndrsProps, {
     pass: import('vue').ShallowRef<import('postprocessing').EffectPass | null>;
     effect: import('vue').ShallowRef<NoiseEffect | null>;
 }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<NoisePmndrsProps> & Readonly<{}>, {
-    blendFunction: BlendFunction;
     premultiply: boolean;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
 export default _default;

package/dist/core/pmndrs/ScanlinePmndrs.vue.d.ts

@@ -0,0 +1,24 @@
+import { BlendFunction, ScanlineEffect } from 'postprocessing';
+export interface ScanlinePmndrsProps {
+    /**
+     * The blend function.
+     */
+    blendFunction?: BlendFunction;
+    /**
+     * The density of the scanlines.
+     */
+    density?: number;
+    /**
+     * The density of the scanlines.
+     */
+    scrollSpeed?: number;
+    /**
+     * The opacity of the scanlines.
+     */
+    opacity?: number;
+}
+declare const _default: import('vue').DefineComponent<ScanlinePmndrsProps, {
+    pass: import('vue').ShallowRef<import('postprocessing').EffectPass | null>;
+    effect: import('vue').ShallowRef<ScanlineEffect | null>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<ScanlinePmndrsProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/core/pmndrs/SepiaPmndrs.vue.d.ts

@@ -0,0 +1,16 @@
+import { BlendFunction, SepiaEffect } from 'postprocessing';
+export interface SepiaPmndrsProps {
+    /**
+     * The blend function.
+     */
+    blendFunction?: BlendFunction;
+    /**
+     * The intensity of the sepia effect.
+     */
+    intensity?: number;
+}
+declare const _default: import('vue').DefineComponent<SepiaPmndrsProps, {
+    pass: import('vue').ShallowRef<import('postprocessing').EffectPass | null>;
+    effect: import('vue').ShallowRef<SepiaEffect | null>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<SepiaPmndrsProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/core/pmndrs/ShockWavePmndrs.vue.d.ts

@@ -0,0 +1,29 @@
+import { ShockWaveEffect } from 'postprocessing';
+import { Vector3 } from 'three';
+export interface ShockWavePmndrsProps {
+    /**
+     * The position of the shockwave.
+     */
+    position?: Vector3 | [number, number, number];
+    /**
+     * The amplitude of the shockwave.
+     */
+    amplitude?: number;
+    /**
+     * The speed of the shockwave.
+     */
+    speed?: number;
+    /**
+     * The max radius of the shockwave.
+     */
+    maxRadius?: number;
+    /**
+     * The wave size of the shockwave.
+     */
+    waveSize?: number;
+}
+declare const _default: import('vue').DefineComponent<ShockWavePmndrsProps, {
+    pass: import('vue').ShallowRef<import('postprocessing').EffectPass | null>;
+    effect: import('vue').ShallowRef<ShockWaveEffect | null>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<ShockWavePmndrsProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/core/pmndrs/TiltShiftPmndrs.vue.d.ts

@@ -0,0 +1,49 @@
+import { BlendFunction, KernelSize, TiltShiftEffect } from 'postprocessing';
+export interface TiltShiftPmndrsProps {
+    /**
+     * The blend function. Defines how the effect blends with the original scene.
+     */
+    blendFunction?: BlendFunction;
+    /**
+     * The relative offset of the focus area.
+     * Range: [-0.5, 0.5]
+     */
+    offset?: number;
+    /**
+     * The rotation of the focus area in radians.
+     * Range: [-π, π]
+     */
+    rotation?: number;
+    /**
+     * The relative size of the focus area.
+     * Range: [0, 1]
+     */
+    focusArea?: number;
+    /**
+     * The softness of the focus area edges.
+     * Range: [0, 1]
+     */
+    feather?: number;
+    /**
+     * The blur kernel size.
+     */
+    kernelSize?: KernelSize;
+    /**
+     * The resolution scale.
+     * Range: [0.1, 1]
+     */
+    resolutionScale?: number;
+    /**
+     * The horizontal resolution.
+     */
+    resolutionX?: number;
+    /**
+     * The vertical resolution.
+     */
+    resolutionY?: number;
+}
+declare const _default: import('vue').DefineComponent<TiltShiftPmndrsProps, {
+    pass: import('vue').ShallowRef<import('postprocessing').EffectPass | null>;
+    effect: import('vue').ShallowRef<TiltShiftEffect | null>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<TiltShiftPmndrsProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/core/pmndrs/ToneMappingPmndrs.vue.d.ts

@@ -0,0 +1,36 @@
+import { BlendFunction, ToneMappingMode, ToneMappingEffect } from 'postprocessing';
+export interface ToneMappingPmndrsProps {
+    /**
+     * The tone mapping mode.
+     */
+    mode?: ToneMappingMode;
+    /**
+     * The blend function.
+     */
+    blendFunction?: BlendFunction;
+    /**
+     * The resolution for luminance texture. The resolution of the luminance texture. Must be a power of two.
+     */
+    resolution?: number;
+    /**
+     * The average luminance. Only for `REINHARD2`.
+     */
+    averageLuminance?: number;
+    /**
+     * The middle grey factor. Only for `REINHARD2`.
+     */
+    middleGrey?: number;
+    /**
+     * The minimum luminance. Only for `REINHARD2`.
+     */
+    minLuminance?: number;
+    /**
+     * The white point. Only for `REINHARD2`.
+     */
+    whitePoint?: number;
+}
+declare const _default: import('vue').DefineComponent<ToneMappingPmndrsProps, {
+    pass: import('vue').ShallowRef<import('postprocessing').EffectPass | null>;
+    effect: import('vue').ShallowRef<ToneMappingEffect | null>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<ToneMappingPmndrsProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/core/pmndrs/VignettePmndrs.vue.d.ts

@@ -1,20 +1,15 @@
-import { BlendFunction, VignetteEffect, VignetteTechnique } from 'postprocessing';
+import { BlendFunction, VignetteTechnique, VignetteEffect } from 'postprocessing';
 export interface VignettePmndrsProps {
     /**
      * Whether the noise should be multiplied with the input color.
      */
     technique?: VignetteTechnique;
     blendFunction?: BlendFunction;
-    offset: number;
-    darkness: number;
+    offset?: number;
+    darkness?: number;
 }
 declare const _default: import('vue').DefineComponent<VignettePmndrsProps, {
     pass: import('vue').ShallowRef<import('postprocessing').EffectPass | null>;
     effect: import('vue').ShallowRef<VignetteEffect | null>;
-}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<VignettePmndrsProps> & Readonly<{}>, {
-    blendFunction: BlendFunction;
-    technique: VignetteTechnique;
-    offset: number;
-    darkness: number;
-}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<VignettePmndrsProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
 export default _default;

package/dist/core/pmndrs/custom/barrel-blur/index.d.ts

@@ -0,0 +1,36 @@
+import { Vector2 } from 'three';
+import { BlendFunction, Effect } from 'postprocessing';
+/**
+ * BarrelBlurEffect - A custom effect for applying a barrel distortion
+ * with chromatic aberration blur.
+ */
+export declare class BarrelBlurEffect extends Effect {
+    /**
+     * Creates a new BarrelBlurEffect instance.
+     *
+     * @param {object} [options] - Configuration options for the effect.
+     * @param {BlendFunction} [options.blendFunction] - Blend mode.
+     * @param {number} [options.amount] - Intensity of the barrel distortion (0 to 1).
+     * @param {Vector2} [options.offset] - Offset of the barrel distortion center (0 to 1 for both x and y). This allows you to change the position of the distortion effect.
+     *
+     */
+    constructor({ blendFunction, amount, offset }?: {
+        blendFunction?: BlendFunction | undefined;
+        amount?: number | undefined;
+        offset?: Vector2 | undefined;
+    });
+    /**
+     * The amount.
+     *
+     * @type {number}
+     */
+    get amount(): any;
+    set amount(value: any);
+    /**
+     * The offset.
+     *
+     * @type {Vector2}
+     */
+    get offset(): any;
+    set offset(value: any);
+}

package/dist/core/pmndrs/custom/fish-eye/index.d.ts

@@ -0,0 +1,44 @@
+import { Vector2 } from 'three';
+import { BlendFunction, Effect } from 'postprocessing';
+/**
+ * FishEyeEffect - A custom effect for applying a fish-eye distortion
+ */
+export declare class FishEyeEffect extends Effect {
+    /**
+     * Creates a new FishEyeEffect instance.
+     *
+     * @param {object} [options] - Configuration options for the effect.
+     * @param {BlendFunction} [options.blendFunction] - Blend mode.
+     * @param {Vector2} [options.lensS] - Lens scale.
+     * @param {Vector2} [options.lensF] - Lens factor.
+     * @param {number} [options.scale] - Scale.
+     *
+     */
+    constructor({ blendFunction, lensS, lensF, scale }?: {
+        blendFunction?: BlendFunction | undefined;
+        lensS?: Vector2 | undefined;
+        lensF?: Vector2 | undefined;
+        scale?: number | undefined;
+    });
+    /**
+     * The lensS.
+     *
+     * @type {Vector2}
+     */
+    get lensS(): any;
+    set lensS(value: any);
+    /**
+     * The lensF.
+     *
+     * @type {Vector2}
+     */
+    get lensF(): any;
+    set lensF(value: any);
+    /**
+     * The scale.
+     *
+     * @type {number}
+     */
+    get scale(): any;
+    set scale(value: any);
+}