@react-three/postprocessing 2.19.0 → 3.0.0-rc.0

package/dist/effects/SSAO.d.ts

@@ -1,30 +0,0 @@
-/// <reference types="react" />
-import { SSAOEffect, BlendFunction } from 'postprocessing';
-export declare const SSAO: import("react").ForwardRefExoticComponent<{
-    blendFunction?: BlendFunction | undefined;
-    distanceScaling?: boolean | undefined;
-    depthAwareUpsampling?: boolean | undefined;
-    normalDepthBuffer?: import("three").Texture | undefined;
-    samples?: number | undefined;
-    rings?: number | undefined;
-    worldDistanceThreshold: number;
-    worldDistanceFalloff: number;
-    worldProximityThreshold: number;
-    worldProximityFalloff: number;
-    distanceThreshold?: number | undefined;
-    distanceFalloff?: number | undefined;
-    rangeThreshold?: number | undefined;
-    rangeFalloff?: number | undefined;
-    minRadiusScale?: number | undefined;
-    luminanceInfluence?: number | undefined;
-    radius?: number | undefined;
-    intensity?: number | undefined;
-    bias?: number | undefined;
-    fade?: number | undefined;
-    color?: import("three").Color | undefined;
-    resolutionScale?: number | undefined;
-    resolutionX?: number | undefined;
-    resolutionY?: number | undefined;
-    width?: number | undefined;
-    height?: number | undefined;
-} & import("react").RefAttributes<SSAOEffect>>;

package/dist/effects/SSAO.js

@@ -1,37 +0,0 @@
-import { jsx } from "react/jsx-runtime";
-import { forwardRef, useContext, useMemo } from "react";
-import { SSAOEffect, BlendFunction } from "postprocessing";
-import { EffectComposerContext } from "../EffectComposer.js";
-const SSAO = forwardRef(function SSAO2(props, ref) {
-  const { camera, normalPass, downSamplingPass, resolutionScale } = useContext(EffectComposerContext);
-  const effect = useMemo(() => {
-    if (normalPass === null && downSamplingPass === null) {
-      console.error("Please enable the NormalPass in the EffectComposer in order to use SSAO.");
-      return {};
-    }
-    return new SSAOEffect(camera, normalPass && !downSamplingPass ? normalPass.texture : null, {
-      blendFunction: BlendFunction.MULTIPLY,
-      samples: 30,
-      rings: 4,
-      distanceThreshold: 1,
-      distanceFalloff: 0,
-      rangeThreshold: 0.5,
-      rangeFalloff: 0.1,
-      luminanceInfluence: 0.9,
-      radius: 20,
-      bias: 0.5,
-      intensity: 1,
-      color: void 0,
-      // @ts-ignore
-      normalDepthBuffer: downSamplingPass ? downSamplingPass.texture : null,
-      resolutionScale: resolutionScale != null ? resolutionScale : 1,
-      depthAwareUpsampling: true,
-      ...props
-    });
-  }, [camera, downSamplingPass, normalPass, resolutionScale]);
-  return /* @__PURE__ */ jsx("primitive", { ref, object: effect, dispose: null });
-});
-export {
-  SSAO
-};
-//# sourceMappingURL=SSAO.js.map

package/dist/effects/SSAO.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"SSAO.js","sources":["../../src/effects/SSAO.tsx"],"sourcesContent":["import { Ref, forwardRef, useContext, useMemo } from 'react'\nimport { SSAOEffect, BlendFunction } from 'postprocessing'\nimport { EffectComposerContext } from '../EffectComposer'\n\n// first two args are camera and texture\ntype SSAOProps = ConstructorParameters<typeof SSAOEffect>[2]\n\nexport const SSAO = forwardRef<SSAOEffect, SSAOProps>(function SSAO(props: SSAOProps, ref: Ref<SSAOEffect>) {\n  const { camera, normalPass, downSamplingPass, resolutionScale } = useContext(EffectComposerContext)\n  const effect = useMemo<SSAOEffect | {}>(() => {\n    if (normalPass === null && downSamplingPass === null) {\n      console.error('Please enable the NormalPass in the EffectComposer in order to use SSAO.')\n      return {}\n    }\n    return new SSAOEffect(camera, normalPass && !downSamplingPass ? (normalPass as any).texture : null, {\n      blendFunction: BlendFunction.MULTIPLY,\n      samples: 30,\n      rings: 4,\n      distanceThreshold: 1.0,\n      distanceFalloff: 0.0,\n      rangeThreshold: 0.5,\n      rangeFalloff: 0.1,\n      luminanceInfluence: 0.9,\n      radius: 20,\n      bias: 0.5,\n      intensity: 1.0,\n      color: undefined,\n      // @ts-ignore\n      normalDepthBuffer: downSamplingPass ? downSamplingPass.texture : null,\n      resolutionScale: resolutionScale ?? 1,\n      depthAwareUpsampling: true,\n      ...props,\n    })\n    // NOTE: `props` is an unstable reference, so we can't memoize it\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [camera, downSamplingPass, normalPass, resolutionScale])\n  return <primitive ref={ref} object={effect} dispose={null} />\n})\n"],"names":["SSAO"],"mappings":";;;;AAOO,MAAM,OAAO,WAAkC,SAASA,MAAK,OAAkB,KAAsB;AAC1G,QAAM,EAAE,QAAQ,YAAY,kBAAkB,oBAAoB,WAAW,qBAAqB;AAC5F,QAAA,SAAS,QAAyB,MAAM;AACxC,QAAA,eAAe,QAAQ,qBAAqB,MAAM;AACpD,cAAQ,MAAM,0EAA0E;AACxF,aAAO;IACT;AACO,WAAA,IAAI,WAAW,QAAQ,cAAc,CAAC,mBAAoB,WAAmB,UAAU,MAAM;AAAA,MAClG,eAAe,cAAc;AAAA,MAC7B,SAAS;AAAA,MACT,OAAO;AAAA,MACP,mBAAmB;AAAA,MACnB,iBAAiB;AAAA,MACjB,gBAAgB;AAAA,MAChB,cAAc;AAAA,MACd,oBAAoB;AAAA,MACpB,QAAQ;AAAA,MACR,MAAM;AAAA,MACN,WAAW;AAAA,MACX,OAAO;AAAA;AAAA,MAEP,mBAAmB,mBAAmB,iBAAiB,UAAU;AAAA,MACjE,iBAAiB,4CAAmB;AAAA,MACpC,sBAAsB;AAAA,MACtB,GAAG;AAAA,IAAA,CACJ;AAAA,KAGA,CAAC,QAAQ,kBAAkB,YAAY,eAAe,CAAC;AAC1D,6BAAQ,aAAU,EAAA,KAAU,QAAQ,QAAQ,SAAS,KAAM,CAAA;AAC7D,CAAC;"}

package/dist/effects/SSR/index.cjs

@@ -1,33 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const jsxRuntime = require("react/jsx-runtime");
-const React = require("react");
-const screenSpaceReflections = require("./screen-space-reflections.cjs");
-const EffectComposer = require("../../EffectComposer.cjs");
-const Selection = require("../../Selection.cjs");
-const fiber = require("@react-three/fiber");
-const SSR = React.forwardRef(function SSR2({ ENABLE_BLUR = true, USE_MRT = true, ...props }, ref) {
-  const invalidate = fiber.useThree((s) => s.invalidate);
-  const { scene, camera } = React.useContext(EffectComposer.EffectComposerContext);
-  const effect = React.useMemo(
-    () => new screenSpaceReflections.SSREffect(scene, camera, { ENABLE_BLUR, USE_MRT, ...props }),
-    [scene, camera, ENABLE_BLUR, USE_MRT, props]
-  );
-  const api = React.useContext(Selection.selectionContext);
-  React.useEffect(() => {
-    var _a;
-    if (api && api.enabled) {
-      if ((_a = api.selected) == null ? void 0 : _a.length) {
-        effect.selection.set(api.selected);
-        invalidate();
-        return () => {
-          effect.selection.clear();
-          invalidate();
-        };
-      }
-    }
-  }, [api, effect, invalidate]);
-  return /* @__PURE__ */ jsxRuntime.jsx("primitive", { ref, object: effect, ...props });
-});
-exports.SSR = SSR;
-//# sourceMappingURL=index.cjs.map

package/dist/effects/SSR/index.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.cjs","sources":["../../../src/effects/SSR/index.tsx"],"sourcesContent":["import React, { Ref, forwardRef, useLayoutEffect, useEffect, useContext, useMemo } from 'react'\n/* @ts-ignore */\nimport { SSREffect } from './screen-space-reflections'\nimport { EffectComposerContext } from '../../EffectComposer'\nimport { selectionContext } from '../../Selection'\nimport { useThree } from '@react-three/fiber'\n\n// first two args are camera and texture\ntype SSRProps = {\n  /** whether you want to use Temporal Resolving to re-use reflections from the last frames; this will reduce noise tremendously but may result in \"smearing\" */\n  temporalResolve?: boolean\n  /** a value between 0 and 1 to set how much the last frame's reflections should be blended in; higher values will result in less noisy reflections when moving the camera but a more smeary look */\n  temporalResolveMix?: number\n  /** a value between 0 and 1 to set how much the reprojected reflection should be corrected; higher values will reduce smearing but will result in less flickering at reflection edges */\n  temporalResolveCorrectionMix?: number\n  /** the maximum number of samples for reflections; settings it to 0 means unlimited samples; setting it to a value like 6 can help make camera movements less disruptive when calculating reflections */\n  maxSamples?: number\n  /** whether to blur the reflections and blend these blurred reflections with the raw ones depending on the blurMix value */\n  ENABLE_BLUR?: boolean\n  /** how much the blurred reflections should be mixed with the raw reflections */\n  blurMix?: number\n  /** the sharpness of the Bilateral Filter used to blur reflections */\n  blurSharpness?: number\n  /** the kernel size of the Bilateral Blur Filter; higher kernel sizes will result in blurrier reflections with more artifacts */\n  blurKernelSize?: number\n  /** how much the reflection ray should travel in each of its iteration; higher values will give deeper reflections but with more artifacts */\n  rayStep?: number\n  /** the intensity of the reflections */\n  intensity?: number\n  /** the maximum roughness a texel can have to have reflections calculated for it */\n  maxRoughness?: number\n  /** whether jittering is enabled; jittering will randomly jitter the reflections resulting in a more noisy but overall more realistic look, enabling jittering can be expensive depending on the view angle */\n  ENABLE_JITTERING?: boolean\n  /** how intense jittering should be */\n  jitter?: number\n  /** how much the jittered rays should be spread; higher values will give a rougher look regarding the reflections but are more expensive to compute with */\n  jitterSpread?: number\n  /** how intense jittering should be in relation to a material's roughness */\n  jitterRough?: number\n  /** the number of steps a reflection ray can maximally do to find an object it intersected (and thus reflects) */\n  MAX_STEPS?: number\n  /** once we had our ray intersect something, we need to find the exact point in space it intersected and thus it reflects; this can be done through binary search with the given number of maximum steps */\n  NUM_BINARY_SEARCH_STEPS?: number\n  /** the maximum depth difference between a ray and the particular depth at its screen position after refining with binary search; lower values will result in better performance */\n  maxDepthDifference?: number\n  /** the maximum depth for which reflections will be calculated */\n  maxDepth?: number\n  /** the maximum depth difference between a ray and the particular depth at its screen position before refining with binary search; lower values will result in better performance */\n  thickness?: number\n  /** Index of Refraction, used for calculating fresnel; reflections tend to be more intense the steeper the angle between them and the viewer is, the ior parameter set how much the intensity varies */\n  ior?: number\n  /** if there should still be reflections for rays for which a reflecting point couldn't be found; enabling this will result in stretched looking reflections which can look good or bad depending on the angle */\n  STRETCH_MISSED_RAYS?: boolean\n  /** WebGL2 only - whether to use multiple render targets when rendering the G-buffers (normals, depth and roughness); using them can improve performance as they will render all information to multiple buffers for each fragment in one run; this setting can't be changed during run-time */\n  USE_MRT?: boolean\n  /** if roughness maps should be taken account of when calculating reflections */\n  USE_ROUGHNESSMAP?: boolean\n  /** if normal maps should be taken account of when calculating reflections */\n  USE_NORMALMAP?: boolean\n}\n\nexport const SSR = forwardRef<SSREffect, SSRProps>(function SSR(\n  { ENABLE_BLUR = true, USE_MRT = true, ...props }: SSRProps,\n\n  ref: Ref<SSREffect>\n) {\n  const invalidate = useThree((s) => s.invalidate)\n  const { scene, camera } = useContext(EffectComposerContext)\n  const effect = useMemo(\n    () => new SSREffect(scene, camera, { ENABLE_BLUR, USE_MRT, ...props }),\n    [scene, camera, ENABLE_BLUR, USE_MRT, props]\n  )\n\n  const api = useContext(selectionContext)\n  useEffect(() => {\n    if (api && api.enabled) {\n      if (api.selected?.length) {\n        effect.selection.set(api.selected)\n        invalidate()\n        return () => {\n          effect.selection.clear()\n          invalidate()\n        }\n      }\n    }\n  }, [api, effect, invalidate])\n\n  return <primitive ref={ref} object={effect} {...props} />\n})\n"],"names":["forwardRef","SSR","useThree","useContext","EffectComposerContext","useMemo","SSREffect","selectionContext","useEffect"],"mappings":";;;;;;;;AA6DO,MAAM,MAAMA,MAAA,WAAgC,SAASC,KAC1D,EAAE,cAAc,MAAM,UAAU,MAAM,GAAG,MAAM,GAE/C,KACA;AACA,QAAM,aAAaC,MAAAA,SAAS,CAAC,MAAM,EAAE,UAAU;AAC/C,QAAM,EAAE,OAAO,OAAO,IAAIC,iBAAWC,eAAqB,qBAAA;AAC1D,QAAM,SAASC,MAAA;AAAA,IACb,MAAM,IAAIC,uBAAAA,UAAU,OAAO,QAAQ,EAAE,aAAa,SAAS,GAAG,OAAO;AAAA,IACrE,CAAC,OAAO,QAAQ,aAAa,SAAS,KAAK;AAAA,EAAA;AAGvC,QAAA,MAAMH,iBAAWI,UAAAA,gBAAgB;AACvCC,QAAAA,UAAU,MAAM;;AACV,QAAA,OAAO,IAAI,SAAS;AAClB,WAAA,SAAI,aAAJ,mBAAc,QAAQ;AACjB,eAAA,UAAU,IAAI,IAAI,QAAQ;AACtB;AACX,eAAO,MAAM;AACX,iBAAO,UAAU;AACN;QAAA;AAAA,MAEf;AAAA,IACF;AAAA,EACC,GAAA,CAAC,KAAK,QAAQ,UAAU,CAAC;AAE5B,wCAAQ,aAAU,EAAA,KAAU,QAAQ,QAAS,GAAG,MAAO,CAAA;AACzD,CAAC;;"}

package/dist/effects/SSR/index.d.ts

@@ -1,55 +0,0 @@
-import React from 'react';
-type SSRProps = {
-    /** whether you want to use Temporal Resolving to re-use reflections from the last frames; this will reduce noise tremendously but may result in "smearing" */
-    temporalResolve?: boolean;
-    /** a value between 0 and 1 to set how much the last frame's reflections should be blended in; higher values will result in less noisy reflections when moving the camera but a more smeary look */
-    temporalResolveMix?: number;
-    /** a value between 0 and 1 to set how much the reprojected reflection should be corrected; higher values will reduce smearing but will result in less flickering at reflection edges */
-    temporalResolveCorrectionMix?: number;
-    /** the maximum number of samples for reflections; settings it to 0 means unlimited samples; setting it to a value like 6 can help make camera movements less disruptive when calculating reflections */
-    maxSamples?: number;
-    /** whether to blur the reflections and blend these blurred reflections with the raw ones depending on the blurMix value */
-    ENABLE_BLUR?: boolean;
-    /** how much the blurred reflections should be mixed with the raw reflections */
-    blurMix?: number;
-    /** the sharpness of the Bilateral Filter used to blur reflections */
-    blurSharpness?: number;
-    /** the kernel size of the Bilateral Blur Filter; higher kernel sizes will result in blurrier reflections with more artifacts */
-    blurKernelSize?: number;
-    /** how much the reflection ray should travel in each of its iteration; higher values will give deeper reflections but with more artifacts */
-    rayStep?: number;
-    /** the intensity of the reflections */
-    intensity?: number;
-    /** the maximum roughness a texel can have to have reflections calculated for it */
-    maxRoughness?: number;
-    /** whether jittering is enabled; jittering will randomly jitter the reflections resulting in a more noisy but overall more realistic look, enabling jittering can be expensive depending on the view angle */
-    ENABLE_JITTERING?: boolean;
-    /** how intense jittering should be */
-    jitter?: number;
-    /** how much the jittered rays should be spread; higher values will give a rougher look regarding the reflections but are more expensive to compute with */
-    jitterSpread?: number;
-    /** how intense jittering should be in relation to a material's roughness */
-    jitterRough?: number;
-    /** the number of steps a reflection ray can maximally do to find an object it intersected (and thus reflects) */
-    MAX_STEPS?: number;
-    /** once we had our ray intersect something, we need to find the exact point in space it intersected and thus it reflects; this can be done through binary search with the given number of maximum steps */
-    NUM_BINARY_SEARCH_STEPS?: number;
-    /** the maximum depth difference between a ray and the particular depth at its screen position after refining with binary search; lower values will result in better performance */
-    maxDepthDifference?: number;
-    /** the maximum depth for which reflections will be calculated */
-    maxDepth?: number;
-    /** the maximum depth difference between a ray and the particular depth at its screen position before refining with binary search; lower values will result in better performance */
-    thickness?: number;
-    /** Index of Refraction, used for calculating fresnel; reflections tend to be more intense the steeper the angle between them and the viewer is, the ior parameter set how much the intensity varies */
-    ior?: number;
-    /** if there should still be reflections for rays for which a reflecting point couldn't be found; enabling this will result in stretched looking reflections which can look good or bad depending on the angle */
-    STRETCH_MISSED_RAYS?: boolean;
-    /** WebGL2 only - whether to use multiple render targets when rendering the G-buffers (normals, depth and roughness); using them can improve performance as they will render all information to multiple buffers for each fragment in one run; this setting can't be changed during run-time */
-    USE_MRT?: boolean;
-    /** if roughness maps should be taken account of when calculating reflections */
-    USE_ROUGHNESSMAP?: boolean;
-    /** if normal maps should be taken account of when calculating reflections */
-    USE_NORMALMAP?: boolean;
-};
-export declare const SSR: React.ForwardRefExoticComponent<SSRProps & React.RefAttributes<SSREffect>>;
-export {};

package/dist/effects/SSR/index.js

@@ -1,33 +0,0 @@
-import { jsx } from "react/jsx-runtime";
-import { forwardRef, useContext, useMemo, useEffect } from "react";
-import { SSREffect } from "./screen-space-reflections.js";
-import { EffectComposerContext } from "../../EffectComposer.js";
-import { selectionContext } from "../../Selection.js";
-import { useThree } from "@react-three/fiber";
-const SSR = forwardRef(function SSR2({ ENABLE_BLUR = true, USE_MRT = true, ...props }, ref) {
-  const invalidate = useThree((s) => s.invalidate);
-  const { scene, camera } = useContext(EffectComposerContext);
-  const effect = useMemo(
-    () => new SSREffect(scene, camera, { ENABLE_BLUR, USE_MRT, ...props }),
-    [scene, camera, ENABLE_BLUR, USE_MRT, props]
-  );
-  const api = useContext(selectionContext);
-  useEffect(() => {
-    var _a;
-    if (api && api.enabled) {
-      if ((_a = api.selected) == null ? void 0 : _a.length) {
-        effect.selection.set(api.selected);
-        invalidate();
-        return () => {
-          effect.selection.clear();
-          invalidate();
-        };
-      }
-    }
-  }, [api, effect, invalidate]);
-  return /* @__PURE__ */ jsx("primitive", { ref, object: effect, ...props });
-});
-export {
-  SSR
-};
-//# sourceMappingURL=index.js.map

package/dist/effects/SSR/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sources":["../../../src/effects/SSR/index.tsx"],"sourcesContent":["import React, { Ref, forwardRef, useLayoutEffect, useEffect, useContext, useMemo } from 'react'\n/* @ts-ignore */\nimport { SSREffect } from './screen-space-reflections'\nimport { EffectComposerContext } from '../../EffectComposer'\nimport { selectionContext } from '../../Selection'\nimport { useThree } from '@react-three/fiber'\n\n// first two args are camera and texture\ntype SSRProps = {\n  /** whether you want to use Temporal Resolving to re-use reflections from the last frames; this will reduce noise tremendously but may result in \"smearing\" */\n  temporalResolve?: boolean\n  /** a value between 0 and 1 to set how much the last frame's reflections should be blended in; higher values will result in less noisy reflections when moving the camera but a more smeary look */\n  temporalResolveMix?: number\n  /** a value between 0 and 1 to set how much the reprojected reflection should be corrected; higher values will reduce smearing but will result in less flickering at reflection edges */\n  temporalResolveCorrectionMix?: number\n  /** the maximum number of samples for reflections; settings it to 0 means unlimited samples; setting it to a value like 6 can help make camera movements less disruptive when calculating reflections */\n  maxSamples?: number\n  /** whether to blur the reflections and blend these blurred reflections with the raw ones depending on the blurMix value */\n  ENABLE_BLUR?: boolean\n  /** how much the blurred reflections should be mixed with the raw reflections */\n  blurMix?: number\n  /** the sharpness of the Bilateral Filter used to blur reflections */\n  blurSharpness?: number\n  /** the kernel size of the Bilateral Blur Filter; higher kernel sizes will result in blurrier reflections with more artifacts */\n  blurKernelSize?: number\n  /** how much the reflection ray should travel in each of its iteration; higher values will give deeper reflections but with more artifacts */\n  rayStep?: number\n  /** the intensity of the reflections */\n  intensity?: number\n  /** the maximum roughness a texel can have to have reflections calculated for it */\n  maxRoughness?: number\n  /** whether jittering is enabled; jittering will randomly jitter the reflections resulting in a more noisy but overall more realistic look, enabling jittering can be expensive depending on the view angle */\n  ENABLE_JITTERING?: boolean\n  /** how intense jittering should be */\n  jitter?: number\n  /** how much the jittered rays should be spread; higher values will give a rougher look regarding the reflections but are more expensive to compute with */\n  jitterSpread?: number\n  /** how intense jittering should be in relation to a material's roughness */\n  jitterRough?: number\n  /** the number of steps a reflection ray can maximally do to find an object it intersected (and thus reflects) */\n  MAX_STEPS?: number\n  /** once we had our ray intersect something, we need to find the exact point in space it intersected and thus it reflects; this can be done through binary search with the given number of maximum steps */\n  NUM_BINARY_SEARCH_STEPS?: number\n  /** the maximum depth difference between a ray and the particular depth at its screen position after refining with binary search; lower values will result in better performance */\n  maxDepthDifference?: number\n  /** the maximum depth for which reflections will be calculated */\n  maxDepth?: number\n  /** the maximum depth difference between a ray and the particular depth at its screen position before refining with binary search; lower values will result in better performance */\n  thickness?: number\n  /** Index of Refraction, used for calculating fresnel; reflections tend to be more intense the steeper the angle between them and the viewer is, the ior parameter set how much the intensity varies */\n  ior?: number\n  /** if there should still be reflections for rays for which a reflecting point couldn't be found; enabling this will result in stretched looking reflections which can look good or bad depending on the angle */\n  STRETCH_MISSED_RAYS?: boolean\n  /** WebGL2 only - whether to use multiple render targets when rendering the G-buffers (normals, depth and roughness); using them can improve performance as they will render all information to multiple buffers for each fragment in one run; this setting can't be changed during run-time */\n  USE_MRT?: boolean\n  /** if roughness maps should be taken account of when calculating reflections */\n  USE_ROUGHNESSMAP?: boolean\n  /** if normal maps should be taken account of when calculating reflections */\n  USE_NORMALMAP?: boolean\n}\n\nexport const SSR = forwardRef<SSREffect, SSRProps>(function SSR(\n  { ENABLE_BLUR = true, USE_MRT = true, ...props }: SSRProps,\n\n  ref: Ref<SSREffect>\n) {\n  const invalidate = useThree((s) => s.invalidate)\n  const { scene, camera } = useContext(EffectComposerContext)\n  const effect = useMemo(\n    () => new SSREffect(scene, camera, { ENABLE_BLUR, USE_MRT, ...props }),\n    [scene, camera, ENABLE_BLUR, USE_MRT, props]\n  )\n\n  const api = useContext(selectionContext)\n  useEffect(() => {\n    if (api && api.enabled) {\n      if (api.selected?.length) {\n        effect.selection.set(api.selected)\n        invalidate()\n        return () => {\n          effect.selection.clear()\n          invalidate()\n        }\n      }\n    }\n  }, [api, effect, invalidate])\n\n  return <primitive ref={ref} object={effect} {...props} />\n})\n"],"names":["SSR"],"mappings":";;;;;;AA6DO,MAAM,MAAM,WAAgC,SAASA,KAC1D,EAAE,cAAc,MAAM,UAAU,MAAM,GAAG,MAAM,GAE/C,KACA;AACA,QAAM,aAAa,SAAS,CAAC,MAAM,EAAE,UAAU;AAC/C,QAAM,EAAE,OAAO,OAAO,IAAI,WAAW,qBAAqB;AAC1D,QAAM,SAAS;AAAA,IACb,MAAM,IAAI,UAAU,OAAO,QAAQ,EAAE,aAAa,SAAS,GAAG,OAAO;AAAA,IACrE,CAAC,OAAO,QAAQ,aAAa,SAAS,KAAK;AAAA,EAAA;AAGvC,QAAA,MAAM,WAAW,gBAAgB;AACvC,YAAU,MAAM;;AACV,QAAA,OAAO,IAAI,SAAS;AAClB,WAAA,SAAI,aAAJ,mBAAc,QAAQ;AACjB,eAAA,UAAU,IAAI,IAAI,QAAQ;AACtB;AACX,eAAO,MAAM;AACX,iBAAO,UAAU;AACN;QAAA;AAAA,MAEf;AAAA,IACF;AAAA,EACC,GAAA,CAAC,KAAK,QAAQ,UAAU,CAAC;AAE5B,6BAAQ,aAAU,EAAA,KAAU,QAAQ,QAAS,GAAG,MAAO,CAAA;AACzD,CAAC;"}