@tresjs/post-processing 1.0.0 → 2.1.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/{Bloom.vue.d.ts → BloomPmndrs.vue.d.ts}

@@ -1,10 +1,10 @@
 import { BlendFunction, KernelSize, BloomEffect } from 'postprocessing';
-export interface BloomProps {
+export interface BloomPmndrsProps {
     /**
      * The blend function of this effect. This prop is not reactive.
      * @default BlendFunction.SCREEN
      * @type {BlendFunction}
-     * @memberof BloomProps
+     * @memberof BloomPmndrsProps
     */
     blendFunction?: BlendFunction;
     /**
@@ -21,7 +21,7 @@ export interface BloomProps {
      * @default KernelSize.LARGE
      *
      * @type {KernelSize}
-     * @memberof BloomProps
+     * @memberof BloomPmndrsProps
      */
     kernelSize?: KernelSize;
     /**
@@ -30,7 +30,7 @@ export interface BloomProps {
      * @default 0.9
      *
      * @type {number}
-     * @memberof BloomProps
+     * @memberof BloomPmndrsProps
      */
     luminanceThreshold?: number;
     /**
@@ -39,7 +39,7 @@ export interface BloomProps {
      * @default 0.025
      *
      * @type {number}
-     * @memberof BloomProps
+     * @memberof BloomPmndrsProps
      */
     luminanceSmoothing?: number;
     /**
@@ -48,14 +48,14 @@ export interface BloomProps {
      * @default false
      *
      * @type {boolean}
-     * @memberof BloomProps
+     * @memberof BloomPmndrsProps
      */
     mipmapBlur?: boolean;
 }
-declare const _default: import('vue').DefineComponent<BloomProps, {
+declare const _default: import('vue').DefineComponent<BloomPmndrsProps, {
     pass: import('vue').ShallowRef<import('postprocessing').EffectPass | null>;
     effect: import('vue').ShallowRef<BloomEffect | null>;
-}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<BloomProps> & Readonly<{}>, {
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<BloomPmndrsProps> & Readonly<{}>, {
     mipmapBlur: boolean;
 }, {}, {}, {}, 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/{DepthOfField.vue.d.ts → DepthOfFieldPmndrs.vue.d.ts}

@@ -1,5 +1,5 @@
 import { BlendFunction, DepthOfFieldEffect } from 'postprocessing';
-export interface DepthOfFieldProps {
+export interface DepthOfFieldPmndrsProps {
     /**
      * The blend function of this effect. This prop is not reactive.
      */
@@ -28,8 +28,8 @@ export interface DepthOfFieldProps {
     resolutionX?: number;
     resolutionY?: number;
 }
-declare const _default: import('vue').DefineComponent<DepthOfFieldProps, {
+declare const _default: import('vue').DefineComponent<DepthOfFieldPmndrsProps, {
     pass: import('vue').ShallowRef<import('postprocessing').EffectPass | null>;
     effect: import('vue').ShallowRef<DepthOfFieldEffect | null>;
-}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<DepthOfFieldProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<DepthOfFieldPmndrsProps> & 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/{EffectComposer.vue.d.ts → EffectComposerPmndrs.vue.d.ts}

@@ -1,7 +1,7 @@
 import { EffectComposer } from 'postprocessing';
 import { InjectionKey, ShallowRef } from 'vue';
 export declare const effectComposerInjectionKey: InjectionKey<ShallowRef<EffectComposer | null>>;
-export interface EffectComposerProps {
+export interface EffectComposerPmndrsProps {
     enabled?: boolean;
     depthBuffer?: boolean;
     disableNormalPass?: boolean;
@@ -11,11 +11,11 @@ export interface EffectComposerProps {
     multisampling?: number;
     frameBufferType?: number;
 }
-declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<EffectComposerProps, {
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<EffectComposerPmndrsProps, {
     composer: ShallowRef<EffectComposer | null>;
 }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
     render: (...args: any[]) => void;
-}, string, import('vue').PublicProps, Readonly<EffectComposerProps> & Readonly<{
+}, string, import('vue').PublicProps, Readonly<EffectComposerPmndrsProps> & Readonly<{
     onRender?: ((...args: any[]) => any) | undefined;
 }>, {
     enabled: boolean;

package/dist/core/pmndrs/{Glitch.vue.d.ts → GlitchPmndrs.vue.d.ts}

@@ -1,6 +1,6 @@
 import { BlendFunction, GlitchEffect, GlitchMode } from 'postprocessing';
 import { Texture, Vector2 } from 'three';
-export interface GlitchProps {
+export interface GlitchPmndrsProps {
     blendFunction?: BlendFunction;
     /**
      *  The minimum and maximum delay between glitch activations in seconds.
@@ -44,8 +44,8 @@ export interface GlitchProps {
      */
     dtSize?: number;
 }
-declare const _default: import('vue').DefineComponent<GlitchProps, {
+declare const _default: import('vue').DefineComponent<GlitchPmndrsProps, {
     pass: import('vue').ShallowRef<import('postprocessing').EffectPass | null>;
     effect: import('vue').ShallowRef<GlitchEffect | null>;
-}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<GlitchProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<GlitchPmndrsProps> & 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/{Noise.vue.d.ts → NoisePmndrs.vue.d.ts}

@@ -1,16 +1,15 @@
 import { BlendFunction, NoiseEffect } from 'postprocessing';
-export interface NoiseProps {
+export interface NoisePmndrsProps {
     /**
      * Whether the noise should be multiplied with the input color.
      */
     premultiply?: boolean;
     blendFunction?: BlendFunction;
 }
-declare const _default: import('vue').DefineComponent<NoiseProps, {
+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<NoiseProps> & Readonly<{}>, {
-    blendFunction: BlendFunction;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<NoisePmndrsProps> & Readonly<{}>, {
     premultiply: boolean;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
 export default _default;

package/dist/core/pmndrs/{Outline.vue.d.ts → OutlinePmndrs.vue.d.ts}

@@ -1,7 +1,7 @@
 import { TresColor } from '@tresjs/core';
 import { BlendFunction, KernelSize, OutlineEffect } from 'postprocessing';
 import { Object3D, Texture } from 'three';
-export interface OutlineProps {
+export interface OutlinePmndrsProps {
     /**
      * The objects in the scene which should have an outline.
      */
@@ -36,10 +36,10 @@ export interface OutlineProps {
     hiddenEdgeColor?: TresColor;
     visibleEdgeColor?: TresColor;
 }
-declare const _default: import('vue').DefineComponent<OutlineProps, {
+declare const _default: import('vue').DefineComponent<OutlinePmndrsProps, {
     pass: import('vue').ShallowRef<import('postprocessing').EffectPass | null>;
     effect: import('vue').ShallowRef<OutlineEffect | null>;
-}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<OutlineProps> & Readonly<{}>, {
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<OutlinePmndrsProps> & Readonly<{}>, {
     blur: boolean;
     xRay: boolean;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;

package/dist/core/pmndrs/{Pixelation.vue.d.ts → PixelationPmndrs.vue.d.ts}

@@ -1,12 +1,12 @@
 import { PixelationEffect } from 'postprocessing';
-export interface PixelationProps {
+export interface PixelationPmndrsProps {
     /**
      * The pixel granularity.
      */
     granularity?: number;
 }
-declare const _default: import('vue').DefineComponent<PixelationProps, {
+declare const _default: import('vue').DefineComponent<PixelationPmndrsProps, {
     pass: import('vue').ShallowRef<import('postprocessing').EffectPass | null>;
     effect: import('vue').ShallowRef<PixelationEffect | null>;
-}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<PixelationProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<PixelationPmndrsProps> & Readonly<{}>, {}, {}, {}, {}, 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/{Vignette.vue.d.ts → VignettePmndrs.vue.d.ts}

@@ -1,20 +1,15 @@
-import { BlendFunction, VignetteEffect, VignetteTechnique } from 'postprocessing';
-export interface VignetteProps {
+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<VignetteProps, {
+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<VignetteProps> & 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/composables/{useEffect.d.ts → useEffectPmndrs.d.ts}

@@ -1,6 +1,6 @@
 import { Effect, EffectPass } from 'postprocessing';
 import { Reactive, ShallowRef } from 'vue';
-export declare const useEffect: <T extends Effect>(newEffectFunction: () => T, passDependencies: Reactive<object>) => {
+export declare const useEffectPmndrs: <T extends Effect>(newEffectFunction: () => T, passDependencies: Reactive<object>) => {
     pass: ShallowRef<EffectPass | null>;
     effect: ShallowRef<T | null>;
 };

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/kuwahara/index.d.ts

@@ -0,0 +1,31 @@
+import { BlendFunction, Effect } from 'postprocessing';
+export declare class KuwaharaEffect extends Effect {
+    /**
+     * Creates a new KuwaharaEffect instance.
+     *
+     * @param {object} [options] - Configuration options for the effect.
+     * @param {BlendFunction} [options.blendFunction] - Blend mode.
+     * @param {number} [options.radius] - Intensity of the effect.
+     * @param {number} [options.sectorCount] - Number of sectors.
+     *
+     */
+    constructor({ blendFunction, radius, sectorCount }?: {
+        blendFunction?: BlendFunction | undefined;
+        radius?: number | undefined;
+        sectorCount?: number | undefined;
+    });
+    /**
+     * The radius.
+     *
+     * @type {number}
+     */
+    get radius(): any;
+    set radius(value: any);
+    /**
+     * The sector count.
+     *
+     * @type {number}
+     */
+    get sectorCount(): any;
+    set sectorCount(value: any);
+}