@tresjs/post-processing 1.0.0-next.1 → 2.0.0

package/README.md

@@ -57,10 +57,6 @@ And then to run the development server on http://localhost:5173
 pnpm run playground
 ```
 
-### Test
-
-TODO...
-
 ### Docs
 
 To run de docs in dev mode

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

@@ -0,0 +1,61 @@
+import { BlendFunction, KernelSize, BloomEffect } from 'postprocessing';
+export interface BloomPmndrsProps {
+    /**
+     * The blend function of this effect. This prop is not reactive.
+     * @default BlendFunction.SCREEN
+     * @type {BlendFunction}
+     * @memberof BloomPmndrsProps
+    */
+    blendFunction?: BlendFunction;
+    /**
+     * The intensity of the bloom effect.
+     *
+     * @default 1
+     * @type {number}
+     * @memberof BloomProps
+     */
+    intensity?: number;
+    /**
+     * The kernel size.
+     *
+     * @default KernelSize.LARGE
+     *
+     * @type {KernelSize}
+     * @memberof BloomPmndrsProps
+     */
+    kernelSize?: KernelSize;
+    /**
+     * The luminance threshold. Raise this value to mask out darker elements in the scene. Range is [0, 1].
+     *
+     * @default 0.9
+     *
+     * @type {number}
+     * @memberof BloomPmndrsProps
+     */
+    luminanceThreshold?: number;
+    /**
+     * Controls the smoothness of the luminance threshold. Range is [0, 1].
+     *
+     * @default 0.025
+     *
+     * @type {number}
+     * @memberof BloomPmndrsProps
+     */
+    luminanceSmoothing?: number;
+    /**
+     * Enables mip map blur.
+     *
+     * @default false
+     *
+     * @type {boolean}
+     * @memberof BloomPmndrsProps
+     */
+    mipmapBlur?: boolean;
+}
+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<BloomPmndrsProps> & Readonly<{}>, {
+    mipmapBlur: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/core/{effects/DepthOfField.vue.d.ts → pmndrs/DepthOfFieldPmndrs.vue.d.ts}

@@ -1,6 +1,5 @@
 import { BlendFunction, DepthOfFieldEffect } from 'postprocessing';
-
-export interface DepthOfFieldProps {
+export interface DepthOfFieldPmndrsProps {
     /**
      * The blend function of this effect. This prop is not reactive.
      */
@@ -29,17 +28,8 @@ export interface DepthOfFieldProps {
     resolutionX?: number;
     resolutionY?: number;
 }
-declare const _default: import('vue').DefineComponent<__VLS_TypePropsToOption<DepthOfFieldProps>, {
+declare const _default: import('vue').DefineComponent<DepthOfFieldPmndrsProps, {
     pass: import('vue').ShallowRef<import('postprocessing').EffectPass | null>;
     effect: import('vue').ShallowRef<DepthOfFieldEffect | null>;
-}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToOption<DepthOfFieldProps>>>, {}, {}>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<DepthOfFieldPmndrsProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
 export default _default;
-type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
-type __VLS_TypePropsToOption<T> = {
-    [K in keyof T]-?: {} extends Pick<T, K> ? {
-        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
-    } : {
-        type: import('vue').PropType<T[K]>;
-        required: true;
-    };
-};

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

@@ -0,0 +1,36 @@
+import { EffectComposer } from 'postprocessing';
+import { InjectionKey, ShallowRef } from 'vue';
+export declare const effectComposerInjectionKey: InjectionKey<ShallowRef<EffectComposer | null>>;
+export interface EffectComposerPmndrsProps {
+    enabled?: boolean;
+    depthBuffer?: boolean;
+    disableNormalPass?: boolean;
+    stencilBuffer?: boolean;
+    resolutionScale?: number;
+    autoClear?: boolean;
+    multisampling?: number;
+    frameBufferType?: number;
+}
+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<EffectComposerPmndrsProps> & Readonly<{
+    onRender?: ((...args: any[]) => any) | undefined;
+}>, {
+    enabled: boolean;
+    depthBuffer: boolean;
+    disableNormalPass: boolean;
+    stencilBuffer: boolean;
+    autoClear: boolean;
+    multisampling: number;
+    frameBufferType: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -0,0 +1,51 @@
+import { BlendFunction, GlitchEffect, GlitchMode } from 'postprocessing';
+import { Texture, Vector2 } from 'three';
+export interface GlitchPmndrsProps {
+    blendFunction?: BlendFunction;
+    /**
+     *  The minimum and maximum delay between glitch activations in seconds.
+     */
+    delay?: Vector2;
+    /**
+     * The minimum and maximum duration of a glitch in seconds.
+     */
+    duration?: Vector2;
+    /**
+     * The strength of weak and strong glitches.
+     */
+    strength?: Vector2;
+    /**
+     * The glitch mode. Can be DISABLED | SPORADIC | CONSTANT_MILD | CONSTANT_WILD.
+     */
+    mode?: GlitchMode;
+    /**
+     * Turn the effect on and off.
+     */
+    active?: boolean;
+    /**
+     *
+     * The threshold for strong glitches.
+     */
+    ratio?: number;
+    /**
+     * The scale of the blocky glitch columns.
+     */
+    columns?: number;
+    /**
+     * A chromatic aberration offset. If provided, the glitch effect will influence this offset.
+     */
+    chromaticAberrationOffset?: Vector2;
+    /**
+     * A perturbation map. If none is provided, a noise texture will be created.
+     */
+    perturbationMap?: Texture;
+    /**
+     * The size of the generated noise map. Will be ignored if a perturbation map is provided.
+     */
+    dtSize?: number;
+}
+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<GlitchPmndrsProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

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

@@ -0,0 +1,16 @@
+import { BlendFunction, NoiseEffect } from 'postprocessing';
+export interface NoisePmndrsProps {
+    /**
+     * Whether the noise should be multiplied with the input color.
+     */
+    premultiply?: boolean;
+    blendFunction?: BlendFunction;
+}
+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/{effects/Outline.vue.d.ts → pmndrs/OutlinePmndrs.vue.d.ts}

@@ -1,8 +1,7 @@
-import { OutlineEffect, BlendFunction, KernelSize } from 'postprocessing';
 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.
      */
@@ -37,34 +36,11 @@ export interface OutlineProps {
     hiddenEdgeColor?: TresColor;
     visibleEdgeColor?: TresColor;
 }
-declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToOption<OutlineProps>, {
-    blur: undefined;
-    xRay: undefined;
-}>, {
+declare const _default: import('vue').DefineComponent<OutlinePmndrsProps, {
     pass: import('vue').ShallowRef<import('postprocessing').EffectPass | null>;
     effect: import('vue').ShallowRef<OutlineEffect | null>;
-}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<OutlineProps>, {
-    blur: undefined;
-    xRay: undefined;
-}>>>, {
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<OutlinePmndrsProps> & Readonly<{}>, {
     blur: boolean;
     xRay: boolean;
-}, {}>;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
 export default _default;
-type __VLS_WithDefaults<P, D> = {
-    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
-        default: D[K];
-    }> : P[K];
-};
-type __VLS_Prettify<T> = {
-    [K in keyof T]: T[K];
-} & {};
-type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
-type __VLS_TypePropsToOption<T> = {
-    [K in keyof T]-?: {} extends Pick<T, K> ? {
-        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
-    } : {
-        type: import('vue').PropType<T[K]>;
-        required: true;
-    };
-};

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

@@ -0,0 +1,12 @@
+import { PixelationEffect } from 'postprocessing';
+export interface PixelationPmndrsProps {
+    /**
+     * The pixel granularity.
+     */
+    granularity?: number;
+}
+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<PixelationPmndrsProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

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

@@ -0,0 +1,20 @@
+import { BlendFunction, VignetteEffect, VignetteTechnique } from 'postprocessing';
+export interface VignettePmndrsProps {
+    /**
+     * Whether the noise should be multiplied with the input color.
+     */
+    technique?: VignetteTechnique;
+    blendFunction?: BlendFunction;
+    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>;
+export default _default;

package/dist/core/pmndrs/composables/useEffectPmndrs.d.ts

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

package/dist/core/pmndrs/index.d.ts

@@ -0,0 +1,10 @@
+import { default as BloomPmndrs, BloomPmndrsProps } from './BloomPmndrs.vue';
+import { useEffectPmndrs } from './composables/useEffectPmndrs';
+import { default as DepthOfFieldPmndrs, DepthOfFieldPmndrsProps } from './DepthOfFieldPmndrs.vue';
+import { default as EffectComposerPmndrs, EffectComposerPmndrsProps } from './EffectComposerPmndrs.vue';
+import { default as GlitchPmndrs, GlitchPmndrsProps } from './GlitchPmndrs.vue';
+import { default as NoisePmndrs, NoisePmndrsProps } from './NoisePmndrs.vue';
+import { default as OutlinePmndrs, OutlinePmndrsProps } from './OutlinePmndrs.vue';
+import { default as PixelationPmndrs, PixelationPmndrsProps } from './PixelationPmndrs.vue';
+import { default as VignettePmndrs, VignettePmndrsProps } from './VignettePmndrs.vue';
+export { BloomPmndrs, DepthOfFieldPmndrs, EffectComposerPmndrs, GlitchPmndrs, NoisePmndrs, OutlinePmndrs, PixelationPmndrs, useEffectPmndrs, VignettePmndrs, BloomPmndrsProps, DepthOfFieldPmndrsProps, EffectComposerPmndrsProps, GlitchPmndrsProps, NoisePmndrsProps, OutlinePmndrsProps, PixelationPmndrsProps, VignettePmndrsProps, };

package/dist/core/three/EffectComposer.vue.d.ts

@@ -0,0 +1,20 @@
+import { EffectComposer } from 'three/examples/jsm/postprocessing/EffectComposer.js';
+import { InjectionKey, ShallowRef } from 'vue';
+export declare const effectComposerInjectionKey: InjectionKey<ShallowRef<EffectComposer | null>>;
+export interface EffectComposerProps {
+    enabled?: boolean;
+    withoutRenderPass?: boolean;
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<EffectComposerProps, {
+    composer: ShallowRef<EffectComposer | null>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<EffectComposerProps> & Readonly<{}>, {
+    enabled: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/core/three/Glitch.vue.d.ts

@@ -0,0 +1,15 @@
+import { GlitchPass } from 'three/examples/jsm/postprocessing/GlitchPass.js';
+export interface GlitchProps {
+    /**
+     * The size of the generated noise map
+     */
+    dtSize?: number;
+    /**
+     * If true, the glitch effect will be more wild 🤪
+     */
+    goWild?: boolean;
+}
+declare const _default: import('vue').DefineComponent<GlitchProps, {
+    pass: import('vue').ShallowRef<GlitchPass>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<GlitchProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/core/three/Halftone.vue.d.ts

@@ -0,0 +1,23 @@
+import { Blending } from 'three/src/constants.js';
+import { HalftonePass } from 'three/examples/jsm/postprocessing/HalftonePass.js';
+export declare enum HalftoneShape {
+    Dot = 1,
+    Ellipse = 2,
+    Line = 3,
+    Square = 4
+}
+export interface HalftoneProps {
+    shape?: HalftoneShape;
+    radius?: number;
+    rotateR?: number;
+    rotateG?: number;
+    rotateB?: number;
+    scatter?: number;
+    blending?: number;
+    greyscale?: boolean;
+    blendingMode?: Blending;
+}
+declare const _default: import('vue').DefineComponent<HalftoneProps, {
+    pass: import('vue').ShallowRef<HalftonePass>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<HalftoneProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/core/three/Output.vue.d.ts

@@ -0,0 +1,5 @@
+import { OutputPass } from 'three/examples/jsm/postprocessing/OutputPass.js';
+declare const _default: import('vue').DefineComponent<{}, {
+    pass: import('vue').ShallowRef<OutputPass>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/core/three/Pixelation.vue.d.ts

@@ -0,0 +1,10 @@
+import { RenderPixelatedPass } from 'three/examples/jsm/postprocessing/RenderPixelatedPass.js';
+export interface PixelationProps {
+    pixelSize: number;
+    depthEdgeStrength?: number;
+    normalEdgeStrength?: number;
+}
+declare const _default: import('vue').DefineComponent<PixelationProps, {
+    pass: import('vue').ShallowRef<RenderPixelatedPass>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<PixelationProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/core/three/SMAA.vue.d.ts

@@ -0,0 +1,9 @@
+import { SMAAPass } from 'three/examples/jsm/postprocessing/SMAAPass.js';
+export interface SMAAProps {
+    width?: number;
+    height?: number;
+}
+declare const _default: import('vue').DefineComponent<SMAAProps, {
+    pass: import('vue').ShallowRef<SMAAPass>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<SMAAProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/core/three/UnrealBloom.vue.d.ts

@@ -0,0 +1,14 @@
+import { UnrealBloomPass } from 'three/examples/jsm/postprocessing/UnrealBloomPass.js';
+export interface UnrealBloomProps {
+    radius?: number;
+    strength?: number;
+    threshold?: number;
+}
+declare const _default: import('vue').DefineComponent<UnrealBloomProps, {
+    pass: import('vue').ShallowRef<UnrealBloomPass>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<UnrealBloomProps> & Readonly<{}>, {
+    strength: number;
+    radius: number;
+    threshold: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/core/three/composables/useEffect.d.ts

@@ -0,0 +1,9 @@
+import { Pass } from 'three/examples/jsm/postprocessing/Pass.js';
+import { Reactive, ShallowRef } from 'vue';
+/**
+ * @param newPassFunction - A function that returns a new pass instance.
+ * @param passDependencies - A reactive object that the pass depends on (usually props). Changes to this object will trigger re-rendering.
+ */
+export declare const useEffect: <T extends Pass>(newPassFunction: () => T, passDependencies?: Reactive<object>) => {
+    pass: ShallowRef<T>;
+};

package/dist/core/three/index.d.ts

@@ -0,0 +1,9 @@
+import { useEffect } from './composables/useEffect';
+import { default as EffectComposer, EffectComposerProps } from './EffectComposer.vue';
+import { default as Glitch, GlitchProps } from './Glitch.vue';
+import { default as Halftone, HalftoneProps } from './Halftone.vue';
+import { default as Pixelation, PixelationProps } from './Pixelation.vue';
+import { default as Output } from './Output.vue';
+import { default as SMAA, SMAAProps } from './SMAA.vue';
+import { default as UnrealBloom, UnrealBloomProps } from './UnrealBloom.vue';
+export { EffectComposer, Glitch, Halftone, Output, Pixelation, SMAA, UnrealBloom, useEffect, EffectComposerProps, GlitchProps, HalftoneProps, PixelationProps, SMAAProps, UnrealBloomProps, };

package/dist/index.d.ts

@@ -1,11 +1,2 @@
-import { default as Bloom } from './core/effects/Bloom.vue';
-import { default as DepthOfField } from './core/effects/DepthOfField.vue';
-import { default as EffectComposer } from './core/EffectComposer.vue';
-import { default as Glitch } from './core/effects/Glitch.vue';
-import { default as Outline } from './core/effects/Outline.vue';
-import { default as Pixelation } from './core/effects/Pixelation.vue';
-import { default as Vignette } from './core/effects/Vignette.vue';
-import { default as Noise } from './core/effects/Noise.vue';
-import { useEffect } from './core/composables/effect.ts';
-
-export { Bloom, DepthOfField, EffectComposer, Glitch, Noise, Outline, Pixelation, Vignette, useEffect, };
+export * from './core/pmndrs';
+export * from './core/three';

package/dist/tres-post-processing.d.ts

@@ -0,0 +1,2 @@
+export * from './index'
+export {}