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

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

@@ -1,6 +1,7 @@
-import type { TresObject } from '@tresjs/core';
+import { TresObject } from '@tresjs/core';
 import { EffectComposer as EffectComposerImpl } from 'postprocessing';
-import type { ShallowRef } from 'vue';
+import { ShallowRef } from 'vue';
+
 export interface EffectComposerProps {
     enabled?: boolean;
     children?: TresObject[];
@@ -12,7 +13,10 @@ export interface EffectComposerProps {
     multisampling?: number;
     frameBufferType?: number;
 }
-declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<EffectComposerProps>, {
+declare function __VLS_template(): {
+    default?(_: {}): any;
+};
+declare const __VLS_component: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToOption<EffectComposerProps>, {
     enabled: boolean;
     autoClear: boolean;
     frameBufferType: 1016;
@@ -22,9 +26,9 @@ declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<__
     stencilBuffer: undefined;
 }>, {
     composer: ShallowRef<EffectComposerImpl | null>;
-}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
     render: (...args: any[]) => void;
-}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<EffectComposerProps>, {
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<EffectComposerProps>, {
     enabled: boolean;
     autoClear: boolean;
     frameBufferType: 1016;
@@ -42,19 +46,9 @@ declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<__
     autoClear: boolean;
     multisampling: number;
     frameBufferType: number;
-}, {}>, {
-    default?(_: {}): any;
-}>;
+}, {}>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, ReturnType<typeof __VLS_template>>;
 export default _default;
-type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
-type __VLS_TypePropsToRuntimeProps<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;
-    };
-};
 type __VLS_WithDefaults<P, D> = {
     [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
         default: D[K];
@@ -68,3 +62,12 @@ type __VLS_WithTemplateSlots<T, S> = T & {
         $slots: S;
     };
 };
+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/effects/Bloom.vue.d.ts

@@ -1,5 +1,5 @@
-import { BloomEffect } from 'postprocessing';
-import type { BlendFunction, KernelSize } from 'postprocessing';
+import { BloomEffect, BlendFunction, KernelSize } from 'postprocessing';
+
 export interface BloomProps {
     /**
      * The blend function of this effect. This prop is not reactive.
@@ -53,26 +53,138 @@ export interface BloomProps {
      */
     mipmapBlur?: boolean;
 }
-declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<BloomProps>, {
+declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToOption<BloomProps>, {
     mipmapBlur: undefined;
 }>, {
-    pass: import("vue").Ref<import("postprocessing").EffectPass | null> | import("vue").ShallowRef<import("postprocessing").EffectPass | null>;
-    effect: import("vue").Ref<BloomEffect | null> | import("vue").ShallowRef<BloomEffect | null>;
-}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<BloomProps>, {
+    pass: import('vue').ShallowRef<import('postprocessing').EffectPass | null>;
+    effect: import('vue').ShallowRef<BloomEffect | null>;
+}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<BloomProps>, {
     mipmapBlur: undefined;
 }>>>, {
     mipmapBlur: boolean;
 }, {}>;
 export default _default;
-type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
-type __VLS_TypePropsToRuntimeProps<T> = {
-    [K in keyof T]-?: {} extends Pick<T, K> ? {
-        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+export declare const __VLS_globalTypesStart: {};
+declare global {
+    type __VLS_IntrinsicElements = __VLS_PickNotAny<import('vue/jsx-runtime').JSX.IntrinsicElements, __VLS_PickNotAny<globalThis.JSX.IntrinsicElements, Record<string, any>>>;
+    type __VLS_Element = __VLS_PickNotAny<import('vue/jsx-runtime').JSX.Element, globalThis.JSX.Element>;
+    type __VLS_GlobalComponents = __VLS_PickNotAny<import('vue').GlobalComponents, {}> & __VLS_PickNotAny<import('@vue/runtime-core').GlobalComponents, {}> & __VLS_PickNotAny<import('@vue/runtime-dom').GlobalComponents, {}> & Pick<typeof import('vue'), 'Transition' | 'TransitionGroup' | 'KeepAlive' | 'Suspense' | 'Teleport'>;
+    type __VLS_BuiltInPublicProps = __VLS_PickNotAny<import('vue').VNodeProps, {}> & __VLS_PickNotAny<import('vue').AllowedComponentProps, {}> & __VLS_PickNotAny<import('vue').ComponentCustomProps, {}>;
+    type __VLS_IsAny<T> = 0 extends 1 & T ? true : false;
+    type __VLS_PickNotAny<A, B> = __VLS_IsAny<A> extends true ? B : A;
+    const __VLS_intrinsicElements: __VLS_IntrinsicElements;
+    function __VLS_getVForSourceType(source: number): [number, number, number][];
+    function __VLS_getVForSourceType(source: string): [string, number, number][];
+    function __VLS_getVForSourceType<T extends any[]>(source: T): [
+        item: T[number],
+        key: number,
+        index: number
+    ][];
+    function __VLS_getVForSourceType<T extends {
+        [Symbol.iterator](): Iterator<any>;
+    }>(source: T): [
+        item: T extends {
+            [Symbol.iterator](): Iterator<infer T1>;
+        } ? T1 : never,
+        key: number,
+        index: undefined
+    ][];
+    function __VLS_getVForSourceType<T extends number | {
+        [Symbol.iterator](): Iterator<any>;
+    }>(source: T): [
+        item: number | (Exclude<T, number> extends {
+            [Symbol.iterator](): Iterator<infer T1>;
+        } ? T1 : never),
+        key: number,
+        index: undefined
+    ][];
+    function __VLS_getVForSourceType<T>(source: T): [
+        item: T[keyof T],
+        key: keyof T,
+        index: number
+    ][];
+    function __VLS_getSlotParams<T>(slot: T): Parameters<__VLS_PickNotAny<NonNullable<T>, (...args: any[]) => any>>;
+    function __VLS_getSlotParam<T>(slot: T): Parameters<__VLS_PickNotAny<NonNullable<T>, (...args: any[]) => any>>[0];
+    function __VLS_directiveFunction<T>(dir: T): T extends import('vue').ObjectDirective<infer E, infer V> | import('vue').FunctionDirective<infer E, infer V> ? (value: V) => void : T;
+    function __VLS_withScope<T, K>(ctx: T, scope: K): ctx is T & K;
+    function __VLS_makeOptional<T>(t: T): {
+        [K in keyof T]?: T[K];
+    };
+    type __VLS_SelfComponent<N, C> = string extends N ? {} : N extends string ? {
+        [P in N]: C;
+    } : {};
+    type __VLS_WithComponent<N0 extends string, LocalComponents, N1 extends string, N2 extends string, N3 extends string> = N1 extends keyof LocalComponents ? N1 extends N0 ? Pick<LocalComponents, N0 extends keyof LocalComponents ? N0 : never> : {
+        [K in N0]: LocalComponents[N1];
+    } : N2 extends keyof LocalComponents ? N2 extends N0 ? Pick<LocalComponents, N0 extends keyof LocalComponents ? N0 : never> : {
+        [K in N0]: LocalComponents[N2];
+    } : N3 extends keyof LocalComponents ? N3 extends N0 ? Pick<LocalComponents, N0 extends keyof LocalComponents ? N0 : never> : {
+        [K in N0]: LocalComponents[N3];
+    } : N1 extends keyof __VLS_GlobalComponents ? N1 extends N0 ? Pick<__VLS_GlobalComponents, N0 extends keyof __VLS_GlobalComponents ? N0 : never> : {
+        [K in N0]: __VLS_GlobalComponents[N1];
+    } : N2 extends keyof __VLS_GlobalComponents ? N2 extends N0 ? Pick<__VLS_GlobalComponents, N0 extends keyof __VLS_GlobalComponents ? N0 : never> : {
+        [K in N0]: __VLS_GlobalComponents[N2];
+    } : N3 extends keyof __VLS_GlobalComponents ? N3 extends N0 ? Pick<__VLS_GlobalComponents, N0 extends keyof __VLS_GlobalComponents ? N0 : never> : {
+        [K in N0]: __VLS_GlobalComponents[N3];
     } : {
-        type: import('vue').PropType<T[K]>;
-        required: true;
+        [K in N0]: unknown;
     };
-};
+    function __VLS_asFunctionalComponent<T, K = T extends new (...args: any) => any ? InstanceType<T> : unknown>(t: T, instance?: K): T extends new (...args: any) => any ? (props: (K extends {
+        $props: infer Props;
+    } ? Props : any) & Record<string, unknown>, ctx?: any) => __VLS_Element & {
+        __ctx?: {
+            attrs?: any;
+            slots?: K extends {
+                $slots: infer Slots;
+            } ? Slots : any;
+            emit?: K extends {
+                $emit: infer Emit;
+            } ? Emit : any;
+        } & {
+            props?: (K extends {
+                $props: infer Props;
+            } ? Props : any) & Record<string, unknown>;
+            expose?(exposed: K): void;
+        };
+    } : T extends () => any ? (props: {}, ctx?: any) => ReturnType<T> : T extends (...args: any) => any ? T : (_: {} & Record<string, unknown>, ctx?: any) => {
+        __ctx?: {
+            attrs?: any;
+            expose?: any;
+            slots?: any;
+            emit?: any;
+            props?: {} & Record<string, unknown>;
+        };
+    };
+    function __VLS_elementAsFunction<T>(tag: T, endTag?: T): (_: T & Record<string, unknown>) => void;
+    function __VLS_functionalComponentArgsRest<T extends (...args: any) => any>(t: T): Parameters<T>['length'] extends 2 ? [any] : [];
+    function __VLS_pickFunctionalComponentCtx<T, K>(comp: T, compInstance: K): __VLS_PickNotAny<'__ctx' extends keyof __VLS_PickNotAny<K, {}> ? K extends {
+        __ctx?: infer Ctx;
+    } ? Ctx : never : any, T extends (props: any, ctx: infer Ctx) => any ? Ctx : any>;
+    type __VLS_FunctionalComponentProps<T, K> = '__ctx' extends keyof __VLS_PickNotAny<K, {}> ? K extends {
+        __ctx?: {
+            props?: infer P;
+        };
+    } ? NonNullable<P> : never : T extends (props: infer P, ...args: any) => any ? P : {};
+    type __VLS_AsFunctionOrAny<F> = unknown extends F ? any : ((...args: any) => any) extends F ? F : any;
+    function __VLS_normalizeSlot<S>(s: S): S extends () => infer R ? (props: {}) => R : S;
+    /**
+     * emit
+     */
+    type __VLS_UnionToIntersection<U> = (U extends unknown ? (arg: U) => unknown : never) extends ((arg: infer P) => unknown) ? P : never;
+    type __VLS_OverloadUnionInner<T, U = unknown> = U & T extends (...args: infer A) => infer R ? U extends T ? never : __VLS_OverloadUnionInner<T, Pick<T, keyof T> & U & ((...args: A) => R)> | ((...args: A) => R) : never;
+    type __VLS_OverloadUnion<T> = Exclude<__VLS_OverloadUnionInner<(() => never) & T>, T extends () => never ? never : () => never>;
+    type __VLS_ConstructorOverloads<T> = __VLS_OverloadUnion<T> extends infer F ? F extends (event: infer E, ...args: infer A) => any ? {
+        [K in E & string]: (...args: A) => void;
+    } : never : never;
+    type __VLS_NormalizeEmits<T> = __VLS_PrettifyGlobal<__VLS_UnionToIntersection<__VLS_ConstructorOverloads<T> & {
+        [K in keyof T]: T[K] extends any[] ? {
+            (...args: T[K]): void;
+        } : never;
+    }>>;
+    type __VLS_PrettifyGlobal<T> = {
+        [K in keyof T]: T[K];
+    } & {};
+}
+export declare const __VLS_globalTypesEnd: {};
 type __VLS_WithDefaults<P, D> = {
     [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
         default: D[K];
@@ -81,3 +193,12 @@ type __VLS_WithDefaults<P, D> = {
 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/effects/DepthOfField.vue.d.ts

@@ -1,5 +1,5 @@
-import type { BlendFunction } from 'postprocessing';
-import { DepthOfFieldEffect } from 'postprocessing';
+import { BlendFunction, DepthOfFieldEffect } from 'postprocessing';
+
 export interface DepthOfFieldProps {
     /**
      * The blend function of this effect. This prop is not reactive.
@@ -29,13 +29,13 @@ export interface DepthOfFieldProps {
     resolutionX?: number;
     resolutionY?: number;
 }
-declare const _default: import("vue").DefineComponent<__VLS_TypePropsToRuntimeProps<DepthOfFieldProps>, {
-    pass: import("vue").Ref<import("postprocessing").EffectPass | null> | import("vue").ShallowRef<import("postprocessing").EffectPass | null>;
-    effect: import("vue").Ref<DepthOfFieldEffect | null> | import("vue").ShallowRef<DepthOfFieldEffect | null>;
-}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<__VLS_TypePropsToRuntimeProps<DepthOfFieldProps>>>, {}, {}>;
+declare const _default: import('vue').DefineComponent<__VLS_TypePropsToOption<DepthOfFieldProps>, {
+    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>>>, {}, {}>;
 export default _default;
 type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
-type __VLS_TypePropsToRuntimeProps<T> = {
+type __VLS_TypePropsToOption<T> = {
     [K in keyof T]-?: {} extends Pick<T, K> ? {
         type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
     } : {

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

@@ -1,6 +1,6 @@
-import { GlitchEffect, GlitchMode } from 'postprocessing';
-import type { BlendFunction } from 'postprocessing';
-import type { Texture, Vector2 } from 'three';
+import { GlitchEffect, GlitchMode, BlendFunction } from 'postprocessing';
+import { Texture, Vector2 } from 'three';
+
 export interface GlitchProps {
     blendFunction?: BlendFunction;
     /**
@@ -89,13 +89,13 @@ export interface GlitchProps {
      */
     dtSize?: number;
 }
-declare const _default: import("vue").DefineComponent<__VLS_TypePropsToRuntimeProps<GlitchProps>, {
-    pass: import("vue").Ref<import("postprocessing").EffectPass | null> | import("vue").ShallowRef<import("postprocessing").EffectPass | null>;
-    effect: import("vue").Ref<GlitchEffect | null> | import("vue").ShallowRef<GlitchEffect | null>;
-}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<__VLS_TypePropsToRuntimeProps<GlitchProps>>>, {}, {}>;
+declare const _default: import('vue').DefineComponent<__VLS_TypePropsToOption<GlitchProps>, {
+    pass: import('vue').ShallowRef<import('postprocessing').EffectPass | null>;
+    effect: import('vue').ShallowRef<GlitchEffect | null>;
+}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToOption<GlitchProps>>>, {}, {}>;
 export default _default;
 type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
-type __VLS_TypePropsToRuntimeProps<T> = {
+type __VLS_TypePropsToOption<T> = {
     [K in keyof T]-?: {} extends Pick<T, K> ? {
         type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
     } : {

package/dist/core/effects/Noise.vue.d.ts

@@ -1,4 +1,5 @@
 import { BlendFunction, NoiseEffect } from 'postprocessing';
+
 export interface NoiseProps {
     /**
      * Whether the noise should be multiplied with the input color.
@@ -6,13 +7,13 @@ export interface NoiseProps {
     premultiply?: boolean;
     blendFunction?: BlendFunction;
 }
-declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<NoiseProps>, {
+declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToOption<NoiseProps>, {
     premultiply: boolean;
     blendFunction: BlendFunction;
 }>, {
-    pass: import("vue").Ref<import("postprocessing").EffectPass | null> | import("vue").ShallowRef<import("postprocessing").EffectPass | null>;
-    effect: import("vue").Ref<NoiseEffect | null> | import("vue").ShallowRef<NoiseEffect | null>;
-}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<NoiseProps>, {
+    pass: import('vue').ShallowRef<import('postprocessing').EffectPass | null>;
+    effect: import('vue').ShallowRef<NoiseEffect | null>;
+}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<NoiseProps>, {
     premultiply: boolean;
     blendFunction: BlendFunction;
 }>>>, {
@@ -20,15 +21,6 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
     premultiply: boolean;
 }, {}>;
 export default _default;
-type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
-type __VLS_TypePropsToRuntimeProps<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;
-    };
-};
 type __VLS_WithDefaults<P, D> = {
     [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
         default: D[K];
@@ -37,3 +29,12 @@ type __VLS_WithDefaults<P, D> = {
 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/effects/Outline.vue.d.ts

@@ -1,7 +1,7 @@
-import { OutlineEffect } from 'postprocessing';
-import type { TresColor } from '@tresjs/core';
-import type { Object3D, Texture } from 'three';
-import type { BlendFunction, KernelSize } from 'postprocessing';
+import { OutlineEffect, BlendFunction, KernelSize } from 'postprocessing';
+import { TresColor } from '@tresjs/core';
+import { Object3D, Texture } from 'three';
+
 export interface OutlineProps {
     /**
      * The objects in the scene which should have an outline.
@@ -37,13 +37,13 @@ export interface OutlineProps {
     hiddenEdgeColor?: TresColor;
     visibleEdgeColor?: TresColor;
 }
-declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<OutlineProps>, {
+declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToOption<OutlineProps>, {
     blur: undefined;
     xRay: undefined;
 }>, {
-    pass: import("vue").Ref<import("postprocessing").EffectPass | null> | import("vue").ShallowRef<import("postprocessing").EffectPass | null>;
-    effect: import("vue").Ref<OutlineEffect | null> | import("vue").ShallowRef<OutlineEffect | null>;
-}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<OutlineProps>, {
+    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;
 }>>>, {
@@ -51,15 +51,6 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
     xRay: boolean;
 }, {}>;
 export default _default;
-type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
-type __VLS_TypePropsToRuntimeProps<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;
-    };
-};
 type __VLS_WithDefaults<P, D> = {
     [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
         default: D[K];
@@ -68,3 +59,12 @@ type __VLS_WithDefaults<P, D> = {
 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/effects/Pixelation.vue.d.ts

@@ -1,17 +1,18 @@
 import { PixelationEffect } from 'postprocessing';
+
 export interface PixelationProps {
     /**
      * The pixel granularity.
      */
     granularity?: number;
 }
-declare const _default: import("vue").DefineComponent<__VLS_TypePropsToRuntimeProps<PixelationProps>, {
-    pass: import("vue").Ref<import("postprocessing").EffectPass | null> | import("vue").ShallowRef<import("postprocessing").EffectPass | null>;
-    effect: import("vue").Ref<PixelationEffect | null> | import("vue").ShallowRef<PixelationEffect | null>;
-}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<__VLS_TypePropsToRuntimeProps<PixelationProps>>>, {}, {}>;
+declare const _default: import('vue').DefineComponent<__VLS_TypePropsToOption<PixelationProps>, {
+    pass: import('vue').ShallowRef<import('postprocessing').EffectPass | null>;
+    effect: import('vue').ShallowRef<PixelationEffect | null>;
+}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToOption<PixelationProps>>>, {}, {}>;
 export default _default;
 type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
-type __VLS_TypePropsToRuntimeProps<T> = {
+type __VLS_TypePropsToOption<T> = {
     [K in keyof T]-?: {} extends Pick<T, K> ? {
         type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
     } : {

package/dist/core/effects/Vignette.vue.d.ts

@@ -1,4 +1,5 @@
 import { BlendFunction, VignetteEffect, VignetteTechnique } from 'postprocessing';
+
 export interface VignetteProps {
     /**
      * Whether the noise should be multiplied with the input color.
@@ -8,15 +9,15 @@ export interface VignetteProps {
     offset: number;
     darkness: number;
 }
-declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<VignetteProps>, {
+declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToOption<VignetteProps>, {
     technique: VignetteTechnique;
     blendFunction: BlendFunction;
     offset: number;
     darkness: number;
 }>, {
-    pass: import("vue").Ref<import("postprocessing").EffectPass | null> | import("vue").ShallowRef<import("postprocessing").EffectPass | null>;
-    effect: import("vue").Ref<VignetteEffect | null> | import("vue").ShallowRef<VignetteEffect | null>;
-}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<VignetteProps>, {
+    pass: import('vue').ShallowRef<import('postprocessing').EffectPass | null>;
+    effect: import('vue').ShallowRef<VignetteEffect | null>;
+}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<VignetteProps>, {
     technique: VignetteTechnique;
     blendFunction: BlendFunction;
     offset: number;
@@ -28,15 +29,6 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
     darkness: number;
 }, {}>;
 export default _default;
-type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
-type __VLS_TypePropsToRuntimeProps<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;
-    };
-};
 type __VLS_WithDefaults<P, D> = {
     [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
         default: D[K];
@@ -45,3 +37,12 @@ type __VLS_WithDefaults<P, D> = {
 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/injectionKeys.d.ts

@@ -1,3 +1,4 @@
-import type { EffectComposer } from 'postprocessing';
-import type { InjectionKey, ShallowRef } from 'vue';
+import { EffectComposer } from 'postprocessing';
+import { InjectionKey, ShallowRef } from 'vue';
+
 export declare const effectComposerInjectionKey: InjectionKey<ShallowRef<EffectComposer | null>>;

package/dist/index.d.ts

@@ -1,10 +1,11 @@
-import Bloom from './core/effects/Bloom.vue';
-import DepthOfField from './core/effects/DepthOfField.vue';
-import EffectComposer from './core/EffectComposer.vue';
-import Glitch from './core/effects/Glitch.vue';
-import Outline from './core/effects/Outline.vue';
-import Pixelation from './core/effects/Pixelation.vue';
-import Vignette from './core/effects/Vignette.vue';
-import Noise from './core/effects/Noise.vue';
+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, };

package/dist/tres-postprocessing.js

@@ -1,26 +1,26 @@
 /**
  * name: @tresjs/post-processing
- * version: v1.0.0-next.0
+ * version: v1.0.0-next.1
  * (c) 2024
  * description: Post-processing library for TresJS
  * author: Alvaro Saburido <hola@alvarosaburido.dev> (https://github.com/alvarosabu/)
  */
-import { inject as q, shallowRef as E, watchEffect as x, onUnmounted as L, watch as _, defineComponent as d, provide as H, computed as $, renderSlot as I } from "vue";
-import { EffectPass as K, BloomEffect as P, DepthOfFieldEffect as R, EffectComposer as O, RenderPass as J, NormalPass as Q, DepthDownsamplingPass as Z, GlitchEffect as S, GlitchMode as ee, OutlineEffect as D, PixelationEffect as T, VignetteTechnique as te, BlendFunction as G, VignetteEffect as z, NoiseEffect as k } from "postprocessing";
-import { useTresContext as b, useLoop as ne, normalizeColor as w } from "@tresjs/core";
+import { inject as q, shallowRef as _, watchEffect as B, onUnmounted as L, watch as h, defineComponent as d, provide as H, computed as $, renderSlot as I } from "vue";
+import { EffectPass as K, BloomEffect as P, DepthOfFieldEffect as R, EffectComposer as O, RenderPass as J, NormalPass as Q, DepthDownsamplingPass as Z, GlitchEffect as w, GlitchMode as ee, OutlineEffect as D, PixelationEffect as T, VignetteTechnique as te, BlendFunction as G, VignetteEffect as z, NoiseEffect as k } from "postprocessing";
+import { useTresContext as b, useLoop as ne, normalizeColor as E } from "@tresjs/core";
 import { HalfFloatType as A } from "three";
 const W = Symbol("effectComposer"), p = (l) => {
-  const n = q(W), e = E(null), t = E(null), { scene: o, camera: a } = b();
-  x(() => {
+  const n = q(W), e = _(null), t = _(null), { scene: o, camera: a } = b();
+  B(() => {
     !a.value || !(t != null && t.value) || (t.value.mainCamera = a.value);
   });
-  let s = () => {
+  let i = () => {
   };
-  return s = x(() => {
-    !a.value || !(n != null && n.value) || !o.value || (s(), !t.value && (t.value = l(), e.value = new K(a.value, t.value), n.value.addPass(e.value)));
+  return i = B(() => {
+    !a.value || !(n != null && n.value) || !o.value || (i(), !t.value && (t.value = l(), e.value = new K(a.value, t.value), n.value.addPass(e.value)));
   }), L(() => {
-    var r, i, f;
-    e.value && ((r = n == null ? void 0 : n.value) == null || r.removePass(e.value)), (i = t.value) == null || i.dispose(), (f = e.value) == null || f.dispose();
+    var s, u, f;
+    e.value && ((s = n == null ? void 0 : n.value) == null || s.removePass(e.value)), (u = t.value) == null || u.dispose(), (f = e.value) == null || f.dispose();
   }), {
     pass: e,
     effect: t
@@ -32,16 +32,16 @@ const W = Symbol("effectComposer"), p = (l) => {
   return e == null ? void 0 : e.reduce((t, o) => t && t[o], l);
 }, M = (l, n, e) => {
   const t = Array.isArray(n) ? n : n.match(j);
-  t && t.reduce((o, a, s) => (o[a] === void 0 && (o[a] = {}), s === t.length - 1 && (o[a] = e), o[a]), l);
-}, B = (l, n) => {
+  t && t.reduce((o, a, i) => (o[a] === void 0 && (o[a] = {}), i === t.length - 1 && (o[a] = e), o[a]), l);
+}, x = (l, n) => {
   const e = { ...l };
   return n.forEach((t) => delete e[t]), e;
-}, X = (l, n, e, t, o = {}) => _(l, (a) => {
-  var s;
+}, X = (l, n, e, t, o = {}) => h(l, (a) => {
+  var i;
   if (n.value)
     if (a === void 0) {
-      const r = t();
-      M(n.value, e, oe(r, e)), (s = r.dispose) == null || s.call(r);
+      const s = t();
+      M(n.value, e, oe(s, e)), (i = s.dispose) == null || i.call(s);
     } else
       M(n.value, e, l());
 }, o), y = (l, n, e) => l.map(([t, o]) => X(
@@ -54,7 +54,7 @@ const W = Symbol("effectComposer"), p = (l) => {
   n,
   t,
   e
-)), ue = /* @__PURE__ */ d({
+)), ie = /* @__PURE__ */ d({
   __name: "Bloom",
   props: {
     blendFunction: {},
@@ -76,9 +76,10 @@ const W = Symbol("effectComposer"), p = (l) => {
       ],
       o,
       () => new P()
-    ), (a, s) => null;
+    ), () => {
+    };
   }
-}), ie = /* @__PURE__ */ d({
+}), ue = /* @__PURE__ */ d({
   __name: "DepthOfField",
   props: {
     blendFunction: {},
@@ -107,7 +108,8 @@ const W = Symbol("effectComposer"), p = (l) => {
       ],
       a,
       () => new R()
-    ), (s, r) => null;
+    ), () => {
+    };
   }
 });
 let v;
@@ -138,14 +140,14 @@ const ce = /* @__PURE__ */ d({
   },
   emits: ["render"],
   setup(l, { expose: n, emit: e }) {
-    const t = l, o = e, { scene: a, camera: s, renderer: r, sizes: i, render: f } = b(), u = E(null);
-    let g = null, h = null;
-    H(W, u), n({ composer: u });
+    const t = l, o = e, { scene: a, camera: i, renderer: s, sizes: u, render: f } = b(), r = _(null);
+    let S = null, g = null;
+    H(W, r), n({ composer: r });
     const Y = () => {
-      u.value && (h = new Q(a.value, s.value), h.enabled = !1, u.value.addPass(h), t.resolutionScale !== void 0 && N() && (g = new Z({
-        normalBuffer: h.texture,
+      r.value && (g = new Q(a.value, i.value), g.enabled = !1, r.value.addPass(g), t.resolutionScale !== void 0 && N() && (S = new Z({
+        normalBuffer: g.texture,
         resolutionScale: t.resolutionScale
-      }), g.enabled = !1, u.value.addPass(g)));
+      }), S.enabled = !1, r.value.addPass(S)));
     }, V = $(() => {
       const c = new O(), m = {
         depthBuffer: t.depthBuffer !== void 0 ? t.depthBuffer : c.inputBuffer.depthBuffer,
@@ -155,25 +157,25 @@ const ce = /* @__PURE__ */ d({
       };
       return c.dispose(), m;
     }), F = () => {
-      !r.value && !a.value && !s.value || (u.value = new O(r.value, V.value), u.value.addPass(new J(a.value, s.value)), t.disableNormalPass || Y());
+      !s.value && !a.value && !i.value || (r.value = new O(s.value, V.value), r.value.addPass(new J(a.value, i.value)), t.disableNormalPass || Y());
     };
-    _([r, a, s, () => t.disableNormalPass], () => {
-      !i.width.value || !i.height.value || F();
-    }), _(() => [i.width.value, i.height.value], ([c, m]) => {
-      !c && !m || (u.value ? u.value.setSize(c, m) : F());
+    h([s, a, i, () => t.disableNormalPass], () => {
+      !u.width.value || !u.height.value || F();
+    }), h(() => [u.width.value, u.height.value], ([c, m]) => {
+      !c && !m || (r.value ? r.value.setSize(c, m) : F());
     }, {
       immediate: !0
     });
     const { render: U } = ne();
     return U(() => {
-      if (t.enabled && r.value && u.value && i.width.value && i.height.value && f.frames.value > 0) {
-        const c = r.value.autoClear;
-        r.value.autoClear = t.autoClear, t.stencilBuffer && !t.autoClear && r.value.clearStencil(), u.value.render(), o("render", u.value), r.value.autoClear = c;
+      if (t.enabled && s.value && r.value && u.width.value && u.height.value && f.frames.value > 0) {
+        const c = s.value.autoClear;
+        s.value.autoClear = t.autoClear, t.stencilBuffer && !t.autoClear && s.value.clearStencil(), r.value.render(), o("render", r.value), s.value.autoClear = c;
       }
       f.priority.value = 0, f.mode.value === "always" ? f.frames.value = 1 : f.frames.value = Math.max(0, f.frames.value - 1);
     }), L(() => {
       var c;
-      (c = u.value) == null || c.dispose();
+      (c = r.value) == null || c.dispose();
     }), (c, m) => I(c.$slots, "default");
   }
 }), fe = /* @__PURE__ */ d({
@@ -192,20 +194,21 @@ const ce = /* @__PURE__ */ d({
     dtSize: {}
   },
   setup(l, { expose: n }) {
-    const e = l, { pass: t, effect: o } = p(() => new S(e));
-    return n({ pass: t, effect: o }), x(() => {
+    const e = l, { pass: t, effect: o } = p(() => new w(e));
+    return n({ pass: t, effect: o }), B(() => {
       const a = () => {
         if (e.mode !== void 0)
           return e.active === !1 ? ee.DISABLED : e.mode;
-        const s = new S(), r = s.mode;
-        return s.dispose(), r;
+        const i = new w(), s = i.mode;
+        return i.dispose(), s;
       };
       o.value && (o.value.mode = a());
     }), C(
-      B(e, ["active", "mode", "blendFunction"]),
+      x(e, ["active", "mode", "blendFunction"]),
       o,
-      () => new S()
-    ), (a, s) => null;
+      () => new w()
+    ), () => {
+    };
   }
 }), de = /* @__PURE__ */ d({
   __name: "Outline",
@@ -227,7 +230,7 @@ const ce = /* @__PURE__ */ d({
     visibleEdgeColor: {}
   },
   setup(l, { expose: n }) {
-    const e = l, t = (u) => u !== void 0 ? w(u).getHex() : void 0, { camera: o, scene: a } = b(), s = {
+    const e = l, t = (r) => r !== void 0 ? E(r).getHex() : void 0, { camera: o, scene: a } = b(), i = {
       blur: e.blur,
       xRay: e.xRay,
       kernelSize: e.kernelSize,
@@ -242,21 +245,21 @@ const ce = /* @__PURE__ */ d({
       resolutionScale: e.resolutionScale,
       hiddenEdgeColor: t(e.hiddenEdgeColor),
       visibleEdgeColor: t(e.visibleEdgeColor)
-    }, { pass: r, effect: i } = p(() => new D(a.value, o.value, s));
-    n({ pass: r, effect: i }), _(
-      [() => e.outlinedObjects, i],
+    }, { pass: s, effect: u } = p(() => new D(a.value, o.value, i));
+    n({ pass: s, effect: u }), h(
+      [() => e.outlinedObjects, u],
       // watchEffect is intentionally not used here as it would result in an endless loop
       () => {
-        var u;
-        (u = i.value) == null || u.selection.set(e.outlinedObjects || []);
+        var r;
+        (r = u.value) == null || r.selection.set(e.outlinedObjects || []);
       },
       {
         immediate: !0
       }
     );
     const f = $(() => ({
-      hiddenEdgeColor: e.hiddenEdgeColor ? w(e.hiddenEdgeColor) : void 0,
-      visibleEdgeColor: e.visibleEdgeColor ? w(e.visibleEdgeColor) : void 0
+      hiddenEdgeColor: e.hiddenEdgeColor ? E(e.hiddenEdgeColor) : void 0,
+      visibleEdgeColor: e.visibleEdgeColor ? E(e.visibleEdgeColor) : void 0
     }));
     return y(
       [
@@ -277,9 +280,10 @@ const ce = /* @__PURE__ */ d({
         [() => f.value.hiddenEdgeColor, "hiddenEdgeColor"],
         [() => f.value.visibleEdgeColor, "visibleEdgeColor"]
       ],
-      i,
+      u,
       () => new D()
-    ), (u, g) => null;
+    ), () => {
+    };
   }
 }), pe = /* @__PURE__ */ d({
   __name: "Pixelation",
@@ -292,7 +296,8 @@ const ce = /* @__PURE__ */ d({
       e,
       o,
       () => new T()
-    ), (a, s) => null;
+    ), () => {
+    };
   }
 }), me = /* @__PURE__ */ d({
   __name: "Vignette",
@@ -305,10 +310,11 @@ const ce = /* @__PURE__ */ d({
   setup(l, { expose: n }) {
     const e = l, { pass: t, effect: o } = p(() => new z(e));
     return n({ pass: t, effect: o }), C(
-      B(e, ["blendFunction"]),
+      x(e, ["blendFunction"]),
       o,
       () => new z()
-    ), (a, s) => null;
+    ), () => {
+    };
   }
 }), ve = /* @__PURE__ */ d({
   __name: "Noise",
@@ -319,15 +325,16 @@ const ce = /* @__PURE__ */ d({
   setup(l, { expose: n }) {
     const e = l, { pass: t, effect: o } = p(() => new k(e));
     return n({ pass: t, effect: o }), C(
-      B(e, ["blendFunction"]),
+      x(e, ["blendFunction"]),
       o,
       () => new k()
-    ), (a, s) => null;
+    ), () => {
+    };
   }
 });
 export {
-  ue as Bloom,
-  ie as DepthOfField,
+  ie as Bloom,
+  ue as DepthOfField,
   ce as EffectComposer,
   fe as Glitch,
   ve as Noise,

package/dist/tres-postprocessing.umd.cjs

@@ -1,8 +1,8 @@
 /**
  * name: @tresjs/post-processing
- * version: v1.0.0-next.0
+ * version: v1.0.0-next.1
  * (c) 2024
  * description: Post-processing library for TresJS
  * author: Alvaro Saburido <hola@alvarosaburido.dev> (https://github.com/alvarosabu/)
  */
-(function(f,a){typeof exports=="object"&&typeof module<"u"?a(exports,require("vue"),require("postprocessing"),require("@tresjs/core"),require("three")):typeof define=="function"&&define.amd?define(["exports","vue","postprocessing","@tresjs/core","three"],a):(f=typeof globalThis<"u"?globalThis:f||self,a(f["tres-postprocessing"]={},f.Vue,f.Postprocessing,f.TresjsCore,f.Three))})(this,function(f,a,r,h,B){"use strict";const y=Symbol("effectComposer"),v=o=>{const n=a.inject(y),e=a.shallowRef(null),t=a.shallowRef(null),{scene:l,camera:i}=h.useTresContext();a.watchEffect(()=>{!i.value||!(t!=null&&t.value)||(t.value.mainCamera=i.value)});let u=()=>{};return u=a.watchEffect(()=>{!i.value||!(n!=null&&n.value)||!l.value||(u(),!t.value&&(t.value=o(),e.value=new r.EffectPass(i.value,t.value),n.value.addPass(e.value)))}),a.onUnmounted(()=>{var s,d,p;e.value&&((s=n==null?void 0:n.value)==null||s.removePass(e.value)),(d=t.value)==null||d.dispose(),(p=e.value)==null||p.dispose()}),{pass:e,effect:t}},x=/([^[.\]])+/g,R=(o,n)=>{if(!n)return;const e=Array.isArray(n)?n:n.match(x);return e==null?void 0:e.reduce((t,l)=>t&&t[l],o)},F=(o,n,e)=>{const t=Array.isArray(n)?n:n.match(x);t&&t.reduce((l,i,u)=>(l[i]===void 0&&(l[i]={}),u===t.length-1&&(l[i]=e),l[i]),o)},S=(o,n)=>{const e={...o};return n.forEach(t=>delete e[t]),e},P=(o,n,e,t,l={})=>a.watch(o,i=>{var u;if(n.value)if(i===void 0){const s=t();F(n.value,e,R(s,e)),(u=s.dispose)==null||u.call(s)}else F(n.value,e,o())},l),g=(o,n,e)=>o.map(([t,l])=>P(t,n,l,e)),_=(o,n,e)=>Object.keys(o).map(t=>P(()=>o[t],n,t,e)),z=a.defineComponent({__name:"Bloom",props:{blendFunction:{},intensity:{},kernelSize:{},luminanceThreshold:{},luminanceSmoothing:{},mipmapBlur:{type:Boolean,default:void 0}},setup(o,{expose:n}){const e=o,{pass:t,effect:l}=v(()=>new r.BloomEffect(e));return n({pass:t,effect:l}),g([[()=>e.intensity,"intensity"],[()=>e.kernelSize,"kernelSize"],[()=>e.luminanceSmoothing,"luminanceMaterial.smoothing"],[()=>e.luminanceThreshold,"luminanceMaterial.threshold"]],l,()=>new r.BloomEffect),(i,u)=>null}}),D=a.defineComponent({__name:"DepthOfField",props:{blendFunction:{},worldFocusDistance:{},worldFocusRange:{},focusDistance:{},focusRange:{},bokehScale:{},resolutionScale:{},resolutionX:{},resolutionY:{}},setup(o,{expose:n}){const e=o,{camera:t}=h.useTresContext(),{pass:l,effect:i}=v(()=>new r.DepthOfFieldEffect(t.value,e));return n({pass:l,effect:i}),g([[()=>e.worldFocusDistance,"circleOfConfusionMaterial.worldFocusDistance"],[()=>e.focusDistance,"circleOfConfusionMaterial.focusDistance"],[()=>e.worldFocusRange,"circleOfConfusionMaterial.worldFocusRange"],[()=>e.focusRange,"circleOfConfusionMaterial.focusRange"],[()=>e.bokehScale,"bokehScale"],[()=>e.resolutionScale,"blurPass.resolution.scale"],[()=>e.resolutionX,"resolution.width"],[()=>e.resolutionY,"resolution.height"]],i,()=>new r.DepthOfFieldEffect),(u,s)=>null}});let C;function T(){var o;if(C!==void 0)return C;try{let n;const e=document.createElement("canvas");return C=!!(window.WebGL2RenderingContext&&(n=e.getContext("webgl2"))),n&&((o=n.getExtension("WEBGL_lose_context"))==null||o.loseContext()),C}catch{return C=!1}}const M=a.defineComponent({__name:"EffectComposer",props:{enabled:{type:Boolean,default:!0},children:{},depthBuffer:{type:Boolean,default:void 0},disableNormalPass:{type:Boolean,default:!1},stencilBuffer:{type:Boolean,default:void 0},resolutionScale:{},autoClear:{type:Boolean,default:!0},multisampling:{default:0},frameBufferType:{default:B.HalfFloatType}},emits:["render"],setup(o,{expose:n,emit:e}){const t=o,l=e,{scene:i,camera:u,renderer:s,sizes:d,render:p}=h.useTresContext(),c=a.shallowRef(null);let w=null,b=null;a.provide(y,c),n({composer:c});const L=()=>{c.value&&(b=new r.NormalPass(i.value,u.value),b.enabled=!1,c.value.addPass(b),t.resolutionScale!==void 0&&T()&&(w=new r.DepthDownsamplingPass({normalBuffer:b.texture,resolutionScale:t.resolutionScale}),w.enabled=!1,c.value.addPass(w)))},$=a.computed(()=>{const m=new r.EffectComposer,E={depthBuffer:t.depthBuffer!==void 0?t.depthBuffer:m.inputBuffer.depthBuffer,stencilBuffer:t.stencilBuffer!==void 0?t.stencilBuffer:m.inputBuffer.stencilBuffer,multisampling:T()?t.multisampling!==void 0?t.multisampling:m.multisampling:0,frameBufferType:t.frameBufferType!==void 0?t.frameBufferType:B.HalfFloatType};return m.dispose(),E}),O=()=>{!s.value&&!i.value&&!u.value||(c.value=new r.EffectComposer(s.value,$.value),c.value.addPass(new r.RenderPass(i.value,u.value)),t.disableNormalPass||L())};a.watch([s,i,u,()=>t.disableNormalPass],()=>{!d.width.value||!d.height.value||O()}),a.watch(()=>[d.width.value,d.height.value],([m,E])=>{!m&&!E||(c.value?c.value.setSize(m,E):O())},{immediate:!0});const{render:q}=h.useLoop();return q(()=>{if(t.enabled&&s.value&&c.value&&d.width.value&&d.height.value&&p.frames.value>0){const m=s.value.autoClear;s.value.autoClear=t.autoClear,t.stencilBuffer&&!t.autoClear&&s.value.clearStencil(),c.value.render(),l("render",c.value),s.value.autoClear=m}p.priority.value=0,p.mode.value==="always"?p.frames.value=1:p.frames.value=Math.max(0,p.frames.value-1)}),a.onUnmounted(()=>{var m;(m=c.value)==null||m.dispose()}),(m,E)=>a.renderSlot(m.$slots,"default")}}),k=a.defineComponent({__name:"Glitch",props:{blendFunction:{},delay:{},duration:{},strength:{},mode:{},active:{type:Boolean},ratio:{},columns:{},chromaticAberrationOffset:{},perturbationMap:{},dtSize:{}},setup(o,{expose:n}){const e=o,{pass:t,effect:l}=v(()=>new r.GlitchEffect(e));return n({pass:t,effect:l}),a.watchEffect(()=>{const i=()=>{if(e.mode!==void 0)return e.active===!1?r.GlitchMode.DISABLED:e.mode;const u=new r.GlitchEffect,s=u.mode;return u.dispose(),s};l.value&&(l.value.mode=i())}),_(S(e,["active","mode","blendFunction"]),l,()=>new r.GlitchEffect),(i,u)=>null}}),A=a.defineComponent({__name:"Outline",props:{outlinedObjects:{},blur:{type:Boolean,default:void 0},xRay:{type:Boolean,default:void 0},kernelSize:{},pulseSpeed:{},resolutionX:{},resolutionY:{},edgeStrength:{},patternScale:{},multisampling:{},blendFunction:{},patternTexture:{},resolutionScale:{},hiddenEdgeColor:{},visibleEdgeColor:{}},setup(o,{expose:n}){const e=o,t=c=>c!==void 0?h.normalizeColor(c).getHex():void 0,{camera:l,scene:i}=h.useTresContext(),u={blur:e.blur,xRay:e.xRay,kernelSize:e.kernelSize,pulseSpeed:e.pulseSpeed,resolutionX:e.resolutionX,resolutionY:e.resolutionY,patternScale:e.patternScale,edgeStrength:e.edgeStrength,blendFunction:e.blendFunction,multisampling:e.multisampling,patternTexture:e.patternTexture,resolutionScale:e.resolutionScale,hiddenEdgeColor:t(e.hiddenEdgeColor),visibleEdgeColor:t(e.visibleEdgeColor)},{pass:s,effect:d}=v(()=>new r.OutlineEffect(i.value,l.value,u));n({pass:s,effect:d}),a.watch([()=>e.outlinedObjects,d],()=>{var c;(c=d.value)==null||c.selection.set(e.outlinedObjects||[])},{immediate:!0});const p=a.computed(()=>({hiddenEdgeColor:e.hiddenEdgeColor?h.normalizeColor(e.hiddenEdgeColor):void 0,visibleEdgeColor:e.visibleEdgeColor?h.normalizeColor(e.visibleEdgeColor):void 0}));return g([[()=>e.blur,"blur"],[()=>e.xRay,"xRay"],[()=>e.pulseSpeed,"pulseSpeed"],[()=>e.kernelSize,"kernelSize"],[()=>e.edgeStrength,"edgeStrength"],[()=>e.patternScale,"patternScale"],[()=>e.multisampling,"multisampling"],[()=>p.value.hiddenEdgeColor,"hiddenEdgeColor"],[()=>p.value.visibleEdgeColor,"visibleEdgeColor"]],d,()=>new r.OutlineEffect),(c,w)=>null}}),N=a.defineComponent({__name:"Pixelation",props:{granularity:{}},setup(o,{expose:n}){const e=o,{pass:t,effect:l}=v(()=>new r.PixelationEffect(e.granularity));return n({pass:t,effect:l}),_(e,l,()=>new r.PixelationEffect),(i,u)=>null}}),j=a.defineComponent({__name:"Vignette",props:{technique:{default:r.VignetteTechnique.DEFAULT},blendFunction:{default:r.BlendFunction.NORMAL},offset:{default:.5},darkness:{default:.5}},setup(o,{expose:n}){const e=o,{pass:t,effect:l}=v(()=>new r.VignetteEffect(e));return n({pass:t,effect:l}),_(S(e,["blendFunction"]),l,()=>new r.VignetteEffect),(i,u)=>null}}),G=a.defineComponent({__name:"Noise",props:{premultiply:{type:Boolean,default:!1},blendFunction:{default:r.BlendFunction.SCREEN}},setup(o,{expose:n}){const e=o,{pass:t,effect:l}=v(()=>new r.NoiseEffect(e));return n({pass:t,effect:l}),_(S(e,["blendFunction"]),l,()=>new r.NoiseEffect),(i,u)=>null}});f.Bloom=z,f.DepthOfField=D,f.EffectComposer=M,f.Glitch=k,f.Noise=G,f.Outline=A,f.Pixelation=N,f.Vignette=j,f.useEffect=v,Object.defineProperty(f,Symbol.toStringTag,{value:"Module"})});
+(function(f,a){typeof exports=="object"&&typeof module<"u"?a(exports,require("vue"),require("postprocessing"),require("@tresjs/core"),require("three")):typeof define=="function"&&define.amd?define(["exports","vue","postprocessing","@tresjs/core","three"],a):(f=typeof globalThis<"u"?globalThis:f||self,a(f["tres-postprocessing"]={},f.Vue,f.Postprocessing,f.TresjsCore,f.Three))})(this,function(f,a,i,v,y){"use strict";const _=Symbol("effectComposer"),h=o=>{const n=a.inject(_),e=a.shallowRef(null),t=a.shallowRef(null),{scene:l,camera:r}=v.useTresContext();a.watchEffect(()=>{!r.value||!(t!=null&&t.value)||(t.value.mainCamera=r.value)});let c=()=>{};return c=a.watchEffect(()=>{!r.value||!(n!=null&&n.value)||!l.value||(c(),!t.value&&(t.value=o(),e.value=new i.EffectPass(r.value,t.value),n.value.addPass(e.value)))}),a.onUnmounted(()=>{var s,d,p;e.value&&((s=n==null?void 0:n.value)==null||s.removePass(e.value)),(d=t.value)==null||d.dispose(),(p=e.value)==null||p.dispose()}),{pass:e,effect:t}},x=/([^[.\]])+/g,R=(o,n)=>{if(!n)return;const e=Array.isArray(n)?n:n.match(x);return e==null?void 0:e.reduce((t,l)=>t&&t[l],o)},F=(o,n,e)=>{const t=Array.isArray(n)?n:n.match(x);t&&t.reduce((l,r,c)=>(l[r]===void 0&&(l[r]={}),c===t.length-1&&(l[r]=e),l[r]),o)},S=(o,n)=>{const e={...o};return n.forEach(t=>delete e[t]),e},P=(o,n,e,t,l={})=>a.watch(o,r=>{var c;if(n.value)if(r===void 0){const s=t();F(n.value,e,R(s,e)),(c=s.dispose)==null||c.call(s)}else F(n.value,e,o())},l),g=(o,n,e)=>o.map(([t,l])=>P(t,n,l,e)),w=(o,n,e)=>Object.keys(o).map(t=>P(()=>o[t],n,t,e)),z=a.defineComponent({__name:"Bloom",props:{blendFunction:{},intensity:{},kernelSize:{},luminanceThreshold:{},luminanceSmoothing:{},mipmapBlur:{type:Boolean,default:void 0}},setup(o,{expose:n}){const e=o,{pass:t,effect:l}=h(()=>new i.BloomEffect(e));return n({pass:t,effect:l}),g([[()=>e.intensity,"intensity"],[()=>e.kernelSize,"kernelSize"],[()=>e.luminanceSmoothing,"luminanceMaterial.smoothing"],[()=>e.luminanceThreshold,"luminanceMaterial.threshold"]],l,()=>new i.BloomEffect),()=>{}}}),D=a.defineComponent({__name:"DepthOfField",props:{blendFunction:{},worldFocusDistance:{},worldFocusRange:{},focusDistance:{},focusRange:{},bokehScale:{},resolutionScale:{},resolutionX:{},resolutionY:{}},setup(o,{expose:n}){const e=o,{camera:t}=v.useTresContext(),{pass:l,effect:r}=h(()=>new i.DepthOfFieldEffect(t.value,e));return n({pass:l,effect:r}),g([[()=>e.worldFocusDistance,"circleOfConfusionMaterial.worldFocusDistance"],[()=>e.focusDistance,"circleOfConfusionMaterial.focusDistance"],[()=>e.worldFocusRange,"circleOfConfusionMaterial.worldFocusRange"],[()=>e.focusRange,"circleOfConfusionMaterial.focusRange"],[()=>e.bokehScale,"bokehScale"],[()=>e.resolutionScale,"blurPass.resolution.scale"],[()=>e.resolutionX,"resolution.width"],[()=>e.resolutionY,"resolution.height"]],r,()=>new i.DepthOfFieldEffect),()=>{}}});let C;function T(){var o;if(C!==void 0)return C;try{let n;const e=document.createElement("canvas");return C=!!(window.WebGL2RenderingContext&&(n=e.getContext("webgl2"))),n&&((o=n.getExtension("WEBGL_lose_context"))==null||o.loseContext()),C}catch{return C=!1}}const M=a.defineComponent({__name:"EffectComposer",props:{enabled:{type:Boolean,default:!0},children:{},depthBuffer:{type:Boolean,default:void 0},disableNormalPass:{type:Boolean,default:!1},stencilBuffer:{type:Boolean,default:void 0},resolutionScale:{},autoClear:{type:Boolean,default:!0},multisampling:{default:0},frameBufferType:{default:y.HalfFloatType}},emits:["render"],setup(o,{expose:n,emit:e}){const t=o,l=e,{scene:r,camera:c,renderer:s,sizes:d,render:p}=v.useTresContext(),u=a.shallowRef(null);let B=null,b=null;a.provide(_,u),n({composer:u});const L=()=>{u.value&&(b=new i.NormalPass(r.value,c.value),b.enabled=!1,u.value.addPass(b),t.resolutionScale!==void 0&&T()&&(B=new i.DepthDownsamplingPass({normalBuffer:b.texture,resolutionScale:t.resolutionScale}),B.enabled=!1,u.value.addPass(B)))},$=a.computed(()=>{const m=new i.EffectComposer,E={depthBuffer:t.depthBuffer!==void 0?t.depthBuffer:m.inputBuffer.depthBuffer,stencilBuffer:t.stencilBuffer!==void 0?t.stencilBuffer:m.inputBuffer.stencilBuffer,multisampling:T()?t.multisampling!==void 0?t.multisampling:m.multisampling:0,frameBufferType:t.frameBufferType!==void 0?t.frameBufferType:y.HalfFloatType};return m.dispose(),E}),O=()=>{!s.value&&!r.value&&!c.value||(u.value=new i.EffectComposer(s.value,$.value),u.value.addPass(new i.RenderPass(r.value,c.value)),t.disableNormalPass||L())};a.watch([s,r,c,()=>t.disableNormalPass],()=>{!d.width.value||!d.height.value||O()}),a.watch(()=>[d.width.value,d.height.value],([m,E])=>{!m&&!E||(u.value?u.value.setSize(m,E):O())},{immediate:!0});const{render:q}=v.useLoop();return q(()=>{if(t.enabled&&s.value&&u.value&&d.width.value&&d.height.value&&p.frames.value>0){const m=s.value.autoClear;s.value.autoClear=t.autoClear,t.stencilBuffer&&!t.autoClear&&s.value.clearStencil(),u.value.render(),l("render",u.value),s.value.autoClear=m}p.priority.value=0,p.mode.value==="always"?p.frames.value=1:p.frames.value=Math.max(0,p.frames.value-1)}),a.onUnmounted(()=>{var m;(m=u.value)==null||m.dispose()}),(m,E)=>a.renderSlot(m.$slots,"default")}}),k=a.defineComponent({__name:"Glitch",props:{blendFunction:{},delay:{},duration:{},strength:{},mode:{},active:{type:Boolean},ratio:{},columns:{},chromaticAberrationOffset:{},perturbationMap:{},dtSize:{}},setup(o,{expose:n}){const e=o,{pass:t,effect:l}=h(()=>new i.GlitchEffect(e));return n({pass:t,effect:l}),a.watchEffect(()=>{const r=()=>{if(e.mode!==void 0)return e.active===!1?i.GlitchMode.DISABLED:e.mode;const c=new i.GlitchEffect,s=c.mode;return c.dispose(),s};l.value&&(l.value.mode=r())}),w(S(e,["active","mode","blendFunction"]),l,()=>new i.GlitchEffect),()=>{}}}),A=a.defineComponent({__name:"Outline",props:{outlinedObjects:{},blur:{type:Boolean,default:void 0},xRay:{type:Boolean,default:void 0},kernelSize:{},pulseSpeed:{},resolutionX:{},resolutionY:{},edgeStrength:{},patternScale:{},multisampling:{},blendFunction:{},patternTexture:{},resolutionScale:{},hiddenEdgeColor:{},visibleEdgeColor:{}},setup(o,{expose:n}){const e=o,t=u=>u!==void 0?v.normalizeColor(u).getHex():void 0,{camera:l,scene:r}=v.useTresContext(),c={blur:e.blur,xRay:e.xRay,kernelSize:e.kernelSize,pulseSpeed:e.pulseSpeed,resolutionX:e.resolutionX,resolutionY:e.resolutionY,patternScale:e.patternScale,edgeStrength:e.edgeStrength,blendFunction:e.blendFunction,multisampling:e.multisampling,patternTexture:e.patternTexture,resolutionScale:e.resolutionScale,hiddenEdgeColor:t(e.hiddenEdgeColor),visibleEdgeColor:t(e.visibleEdgeColor)},{pass:s,effect:d}=h(()=>new i.OutlineEffect(r.value,l.value,c));n({pass:s,effect:d}),a.watch([()=>e.outlinedObjects,d],()=>{var u;(u=d.value)==null||u.selection.set(e.outlinedObjects||[])},{immediate:!0});const p=a.computed(()=>({hiddenEdgeColor:e.hiddenEdgeColor?v.normalizeColor(e.hiddenEdgeColor):void 0,visibleEdgeColor:e.visibleEdgeColor?v.normalizeColor(e.visibleEdgeColor):void 0}));return g([[()=>e.blur,"blur"],[()=>e.xRay,"xRay"],[()=>e.pulseSpeed,"pulseSpeed"],[()=>e.kernelSize,"kernelSize"],[()=>e.edgeStrength,"edgeStrength"],[()=>e.patternScale,"patternScale"],[()=>e.multisampling,"multisampling"],[()=>p.value.hiddenEdgeColor,"hiddenEdgeColor"],[()=>p.value.visibleEdgeColor,"visibleEdgeColor"]],d,()=>new i.OutlineEffect),()=>{}}}),N=a.defineComponent({__name:"Pixelation",props:{granularity:{}},setup(o,{expose:n}){const e=o,{pass:t,effect:l}=h(()=>new i.PixelationEffect(e.granularity));return n({pass:t,effect:l}),w(e,l,()=>new i.PixelationEffect),()=>{}}}),j=a.defineComponent({__name:"Vignette",props:{technique:{default:i.VignetteTechnique.DEFAULT},blendFunction:{default:i.BlendFunction.NORMAL},offset:{default:.5},darkness:{default:.5}},setup(o,{expose:n}){const e=o,{pass:t,effect:l}=h(()=>new i.VignetteEffect(e));return n({pass:t,effect:l}),w(S(e,["blendFunction"]),l,()=>new i.VignetteEffect),()=>{}}}),G=a.defineComponent({__name:"Noise",props:{premultiply:{type:Boolean,default:!1},blendFunction:{default:i.BlendFunction.SCREEN}},setup(o,{expose:n}){const e=o,{pass:t,effect:l}=h(()=>new i.NoiseEffect(e));return n({pass:t,effect:l}),w(S(e,["blendFunction"]),l,()=>new i.NoiseEffect),()=>{}}});f.Bloom=z,f.DepthOfField=D,f.EffectComposer=M,f.Glitch=k,f.Noise=G,f.Outline=A,f.Pixelation=N,f.Vignette=j,f.useEffect=h,Object.defineProperty(f,Symbol.toStringTag,{value:"Module"})});

package/dist/util/prop.d.ts

@@ -1,4 +1,5 @@
-import type { Ref, WatchOptions } from 'vue';
+import { Ref, WatchOptions } from 'vue';
+
 /**
  * Creates a prop watcher function that monitors changes to a property and updates a target object.
  *
@@ -11,8 +12,8 @@ import type { Ref, WatchOptions } from 'vue';
  * @param {WatchOptions} watchOptions - The options for watch.
  */
 export declare const makePropWatcher: <T, E>(propGetter: () => T, target: Ref<E>, propertyPath: string, newPlainObjectFunction: () => E & {
-    dispose?: (() => void) | undefined;
-}, watchOptions?: WatchOptions) => import("vue").WatchStopHandle;
+    dispose?: () => void;
+}, watchOptions?: WatchOptions) => import('vue').WatchStopHandle;
 /**
  * Creates multiple prop watchers for monitoring changes to multiple properties and updating a target object.
  *
@@ -23,8 +24,8 @@ export declare const makePropWatcher: <T, E>(propGetter: () => T, target: Ref<E>
  * @param {() => E & { dispose?(): void }} newPlainObjectFunction - A function that creates a new plain object to retrieve the defaults from with an optional "dispose" method for cleanup.
  */
 export declare const makePropWatchers: <E>(propGettersAndPropertyPaths: (string | (() => any))[][], target: Ref<E>, newPlainObjectFunction: () => E & {
-    dispose?: (() => void) | undefined;
-}) => import("vue").WatchStopHandle[];
+    dispose?: () => void;
+}) => import('vue').WatchStopHandle[];
 /**
  * Creates multiple prop watchers via the props object for monitoring changes to multiple properties and updating a target object.
  * Use this method in case the prop names match the names of the properties you want to set on your target object.
@@ -36,5 +37,5 @@ export declare const makePropWatchers: <E>(propGettersAndPropertyPaths: (string
 export declare const makePropWatchersUsingAllProps: <E>(props: {
     [key: string]: any;
 }, target: Ref<E>, newPlainObjectFunction: () => E & {
-    dispose?: (() => void) | undefined;
-}) => import("vue").WatchStopHandle[];
+    dispose?: () => void;
+}) => import('vue').WatchStopHandle[];

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tresjs/post-processing",
   "type": "module",
-  "version": "1.0.0-next.0",
+  "version": "1.0.0-next.1",
   "packageManager": "pnpm@8.10.2",
   "description": "Post-processing library for TresJS",
   "author": "Alvaro Saburido <hola@alvarosaburido.dev> (https://github.com/alvarosabu/)",
@@ -46,36 +46,36 @@
   "peerDependencies": {
     "@tresjs/core": ">=4.0",
     "three": ">=0.133",
-    "vue": ">=3.3"
+    "vue": ">=3.4"
   },
   "dependencies": {
-    "@vueuse/core": "^10.6.1",
-    "postprocessing": "^6.33.4",
-    "three-stdlib": "^2.28.7"
+    "@vueuse/core": "^10.11.0",
+    "postprocessing": "^6.36.0",
+    "three-stdlib": "^2.30.5"
   },
   "devDependencies": {
     "@release-it/conventional-changelog": "^8.0.1",
-    "@tresjs/core": "^4.0.0-rc.1",
+    "@tresjs/core": "^4.2.2",
     "@tresjs/eslint-config": "^1.1.0",
-    "@types/three": "^0.159.0",
-    "@unocss/core": "^0.58.0",
-    "@vitejs/plugin-vue": "^4.5.1",
-    "eslint": "^9.3.0",
-    "gsap": "^3.12.3",
+    "@types/three": "^0.167.0",
+    "@unocss/core": "^0.61.5",
+    "@vitejs/plugin-vue": "^5.1.0",
+    "eslint": "^9.7.0",
+    "gsap": "^3.12.5",
     "kolorist": "^1.8.0",
-    "pathe": "^1.1.1",
-    "release-it": "^17.0.0",
+    "pathe": "^1.1.2",
+    "release-it": "^17.6.0",
     "rollup-plugin-analyzer": "^4.0.0",
-    "rollup-plugin-visualizer": "^5.10.0",
-    "three": "^0.159.0",
-    "typescript": "^5.3.2",
-    "unocss": "^0.58.0",
-    "vite": "^5.0.4",
+    "rollup-plugin-visualizer": "^5.12.0",
+    "three": "^0.167.0",
+    "typescript": "^5.5.4",
+    "unocss": "^0.61.5",
+    "vite": "^5.3.5",
     "vite-plugin-banner": "^0.7.1",
-    "vite-plugin-dts": "3.6.4",
+    "vite-plugin-dts": "4.0.0-beta.1",
     "vite-svg-loader": "^5.1.0",
-    "vitepress": "1.0.0-rc.31",
-    "vue": "^3.3.9",
-    "vue-tsc": "^1.8.24"
+    "vitepress": "1.3.1",
+    "vue": "^3.4.34",
+    "vue-tsc": "^2.0.29"
   }
 }

package/dist/core/composables/effect.d.ts

@@ -1,6 +0,0 @@
-import type { Effect } from 'postprocessing';
-import { EffectPass } from 'postprocessing';
-export declare const useEffect: <T extends Effect>(newEffectFunction: () => T) => {
-    pass: import("vue").Ref<EffectPass | null> | import("vue").ShallowRef<EffectPass | null>;
-    effect: import("vue").Ref<T | null> | import("vue").ShallowRef<T | null>;
-};