@react-three/postprocessing 2.15.1 → 2.15.2

package/dist/effects/SMAA.js

@@ -0,0 +1,7 @@
+import { SMAAEffect } from "postprocessing";
+import { wrapEffect } from "../util.js";
+const SMAA = wrapEffect(SMAAEffect);
+export {
+  SMAA
+};
+//# sourceMappingURL=SMAA.js.map

package/dist/effects/SMAA.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SMAA.js","sources":["../../src/effects/SMAA.tsx"],"sourcesContent":["import { SMAAEffect } from 'postprocessing'\nimport { wrapEffect } from '../util'\n\nexport const SMAA = wrapEffect(SMAAEffect)\n"],"names":[],"mappings":";;AAGa,MAAA,OAAO,WAAW,UAAU;"}

package/dist/effects/SSAO.cjs

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const jsxRuntime = require("react/jsx-runtime");
+const React = require("react");
+const postprocessing = require("postprocessing");
+const EffectComposer = require("../EffectComposer.cjs");
+const SSAO = React.forwardRef(function SSAO2(props, ref) {
+  const { camera, normalPass, downSamplingPass, resolutionScale } = React.useContext(EffectComposer.EffectComposerContext);
+  const effect = React.useMemo(() => {
+    if (normalPass === null && downSamplingPass === null) {
+      console.error("Please enable the NormalPass in the EffectComposer in order to use SSAO.");
+      return {};
+    }
+    return new postprocessing.SSAOEffect(camera, normalPass && !downSamplingPass ? normalPass.texture : null, {
+      blendFunction: postprocessing.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, normalPass, props]);
+  return /* @__PURE__ */ jsxRuntime.jsx("primitive", { ref, object: effect, dispose: null });
+});
+exports.SSAO = SSAO;
+//# sourceMappingURL=SSAO.cjs.map

package/dist/effects/SSAO.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"SSAO.cjs","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  }, [camera, normalPass, props])\n  return <primitive ref={ref} object={effect} dispose={null} />\n})\n"],"names":["forwardRef","SSAO","useContext","EffectComposerContext","useMemo","SSAOEffect","BlendFunction"],"mappings":";;;;;;AAOO,MAAM,OAAOA,MAAAA,WAAkC,SAASC,MAAK,OAAkB,KAAsB;AAC1G,QAAM,EAAE,QAAQ,YAAY,kBAAkB,oBAAoBC,MAAAA,WAAWC,eAAAA,qBAAqB;AAC5F,QAAA,SAASC,MAAAA,QAAyB,MAAM;AACxC,QAAA,eAAe,QAAQ,qBAAqB,MAAM;AACpD,cAAQ,MAAM,0EAA0E;AACxF,aAAO;IACT;AACO,WAAA,IAAIC,eAAAA,WAAW,QAAQ,cAAc,CAAC,mBAAoB,WAAmB,UAAU,MAAM;AAAA,MAClG,eAAeC,eAAc,cAAA;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,EACA,GAAA,CAAC,QAAQ,YAAY,KAAK,CAAC;AAC9B,wCAAQ,aAAU,EAAA,KAAU,QAAQ,QAAQ,SAAS,KAAM,CAAA;AAC7D,CAAC;;"}

package/dist/effects/SSAO.js

@@ -0,0 +1,37 @@
+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, normalPass, props]);
+  return /* @__PURE__ */ jsx("primitive", { ref, object: effect, dispose: null });
+});
+export {
+  SSAO
+};
+//# sourceMappingURL=SSAO.js.map

package/dist/effects/SSAO.js.map

@@ -0,0 +1 @@
+{"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  }, [camera, normalPass, props])\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,EACA,GAAA,CAAC,QAAQ,YAAY,KAAK,CAAC;AAC9B,6BAAQ,aAAU,EAAA,KAAU,QAAQ,QAAQ,SAAS,KAAM,CAAA;AAC7D,CAAC;"}

package/dist/effects/SSR/index.cjs

@@ -0,0 +1,33 @@
+"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();
+  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]);
+  return /* @__PURE__ */ jsxRuntime.jsx("primitive", { ref, object: effect, ...props });
+});
+exports.SSR = SSR;
+//# sourceMappingURL=index.cjs.map

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

@@ -0,0 +1 @@
+{"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()\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])\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;AACM,QAAA,EAAE,eAAeC,MAAAA;AACvB,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,EAAA,GACC,CAAC,GAAG,CAAC;AAER,wCAAQ,aAAU,EAAA,KAAU,QAAQ,QAAS,GAAG,MAAO,CAAA;AACzD,CAAC;;"}

package/dist/effects/SSR/index.js

@@ -0,0 +1,33 @@
+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();
+  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]);
+  return /* @__PURE__ */ jsx("primitive", { ref, object: effect, ...props });
+});
+export {
+  SSR
+};
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"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()\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])\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;AACM,QAAA,EAAE,eAAe;AACvB,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,EAAA,GACC,CAAC,GAAG,CAAC;AAER,6BAAQ,aAAU,EAAA,KAAU,QAAQ,QAAS,GAAG,MAAO,CAAA;AACzD,CAAC;"}