@crystaldesign/real-time-viewer-next 26.11.0-beta.18

package/build/esm/SunLensflare-e4ab3f81.js

@@ -0,0 +1,483 @@
+import _slicedToArray from '@babel/runtime/helpers/slicedToArray';
+import './index-920dd901.js';
+import { useMemo, useEffect, useRef } from 'react';
+import { Billboard } from '@react-three/drei';
+import { useThree, useFrame } from '@react-three/fiber';
+import { CanvasTexture, SRGBColorSpace, Vector3, Raycaster, Color, AdditiveBlending } from 'three';
+import { jsx, jsxs } from 'react/jsx-runtime';
+import '@crystaldesign/diva-core';
+import '@babel/runtime/helpers/toConsumableArray';
+import '@babel/runtime/helpers/asyncToGenerator';
+import '@babel/runtime/regenerator';
+import 'three/examples/jsm/loaders/DRACOLoader.js';
+import 'three/examples/jsm/loaders/GLTFLoader.js';
+import '@babel/runtime/helpers/defineProperty';
+import 'zustand';
+import 'zustand/middleware';
+import '@babel/runtime/helpers/typeof';
+import 'postprocessing';
+import '@babel/runtime/helpers/classCallCheck';
+import '@babel/runtime/helpers/createClass';
+import '@babel/runtime/helpers/possibleConstructorReturn';
+import '@babel/runtime/helpers/getPrototypeOf';
+import '@babel/runtime/helpers/inherits';
+import 'classnames';
+import 'three-mesh-bvh';
+import '@babel/runtime/helpers/objectWithoutProperties';
+import 'three/examples/jsm/environments/RoomEnvironment.js';
+import 'three/examples/jsm/loaders/RGBELoader.js';
+import 'three/examples/jsm/loaders/EXRLoader.js';
+import '@react-three/postprocessing';
+import '@babel/runtime/helpers/construct';
+import 'detect-gpu';
+
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+var FLARE_TEX_SIZE = 256;
+
+/**
+ * Alpha ramps (`[radius 0–1, alpha]`) for the radial sprites. The burst is a wide atmospheric haze
+ * that keeps fading all the way to the sprite edge; the ghost dots are tighter blobs; the ring
+ * peaks near its rim and is hollow inside.
+ */
+var BURST_RAMP = [[0, 1], [0.04, 0.8], [0.12, 0.36], [0.3, 0.13], [0.6, 0.035], [1, 0]];
+var GHOST_RAMP = [[0, 0.55], [0.35, 0.2], [0.7, 0.04], [1, 0]];
+var RING_RAMP = [[0, 0], [0.55, 0], [0.72, 0.45], [0.8, 0.5], [0.9, 0.12], [1, 0]];
+
+/**
+ * Draw a radial flare sprite: falloff in the **alpha** channel on a warm white.
+ *
+ * Generated rather than loaded so the flare has no network dependency and no colour-space ambiguity.
+ * The alpha falloff is what makes the additively blended quad fade into the sky — an opaque RGB
+ * sprite shows its own square outline the moment its dark surround decodes above black.
+ */
+function drawFlareSprite(ramp) {
+  var canvas = document.createElement('canvas');
+  canvas.width = FLARE_TEX_SIZE;
+  canvas.height = FLARE_TEX_SIZE;
+  var ctx = canvas.getContext('2d');
+  if (!ctx) return canvas;
+  var c = FLARE_TEX_SIZE / 2;
+  var glow = ctx.createRadialGradient(c, c, 0, c, c, c);
+  var _iterator = _createForOfIteratorHelper(ramp),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var _step$value = _slicedToArray(_step.value, 2),
+        stop = _step$value[0],
+        alpha = _step$value[1];
+      glow.addColorStop(stop, "rgba(255,246,232,".concat(alpha, ")"));
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  ctx.fillStyle = glow;
+  ctx.fillRect(0, 0, FLARE_TEX_SIZE, FLARE_TEX_SIZE);
+  return canvas;
+}
+
+/**
+ * Draw an aperture ghost: a soft-edged hexagon (6-blade iris) with a dim core and brighter rim,
+ * the way real internal reflections image the aperture. The soft edge comes from rendering only
+ * the blurred shadow of an off-canvas path — supported everywhere, unlike `ctx.filter`.
+ */
+function drawHexSprite() {
+  var canvas = document.createElement('canvas');
+  canvas.width = FLARE_TEX_SIZE;
+  canvas.height = FLARE_TEX_SIZE;
+  var ctx = canvas.getContext('2d');
+  if (!ctx) return canvas;
+  var c = FLARE_TEX_SIZE / 2;
+  var radius = FLARE_TEX_SIZE * 0.4;
+  ctx.save();
+  ctx.translate(FLARE_TEX_SIZE * 2, 0);
+  ctx.shadowOffsetX = -FLARE_TEX_SIZE * 2;
+  ctx.shadowBlur = FLARE_TEX_SIZE * 0.05;
+  ctx.shadowColor = 'rgba(255,246,232,1)';
+  ctx.beginPath();
+  for (var i = 0; i < 6; i++) {
+    var angle = Math.PI / 3 * i + Math.PI / 6;
+    var x = c + Math.cos(angle) * radius;
+    var y = c + Math.sin(angle) * radius;
+    if (i === 0) ctx.moveTo(x, y);else ctx.lineTo(x, y);
+  }
+  ctx.closePath();
+  ctx.fillStyle = 'rgba(255,246,232,1)';
+  ctx.fill();
+  ctx.restore();
+  var shade = ctx.createRadialGradient(c, c, 0, c, c, radius);
+  var shadeStops = [[0, 0.35], [0.55, 0.45], [0.85, 1], [1, 0.8]];
+  for (var _i = 0, _shadeStops = shadeStops; _i < _shadeStops.length; _i++) {
+    var _shadeStops$_i = _slicedToArray(_shadeStops[_i], 2),
+      stop = _shadeStops$_i[0],
+      alpha = _shadeStops$_i[1];
+    shade.addColorStop(stop, "rgba(255,255,255,".concat(alpha, ")"));
+  }
+  ctx.globalCompositeOperation = 'destination-in';
+  ctx.fillStyle = shade;
+  ctx.fillRect(0, 0, FLARE_TEX_SIZE, FLARE_TEX_SIZE);
+  return canvas;
+}
+
+/** Indices into the generated sprite maps. */
+var MAP_BURST = 0;
+var MAP_DOT = 1;
+var MAP_HEX = 2;
+var MAP_RING = 3;
+/**
+ * Element layout. Ghosts are internal-reflection images of the light, so they sit on the line
+ * from the sun through the optical (screen) center — panning the camera sweeps them across the
+ * frame in opposite directions.
+ */
+var ELEMENTS = [
+// Primary haze burst on the sun itself.
+{
+  mapIndex: MAP_BURST,
+  size: 1000,
+  along: 0,
+  opacity: 1
+},
+// Ghost train along the sun→center axis: aperture hexes, a soft dot pair and a ring, chromatically tinted.
+{
+  mapIndex: MAP_HEX,
+  size: 70,
+  along: 0.16,
+  opacity: 0.5,
+  tint: '#ffd9a0'
+}, {
+  mapIndex: MAP_HEX,
+  size: 130,
+  along: 0.45,
+  opacity: 0.35,
+  tint: '#9fd8ff'
+}, {
+  mapIndex: MAP_RING,
+  size: 210,
+  along: 0.52,
+  opacity: 0.3,
+  tint: '#ffe9c8'
+}, {
+  mapIndex: MAP_DOT,
+  size: 70,
+  along: 0.68,
+  opacity: 0.5,
+  tint: '#ffb37d'
+}, {
+  mapIndex: MAP_DOT,
+  size: 60,
+  along: 1,
+  opacity: 0.5
+}];
+
+/**
+ * World distance from the camera to the primary flare burst (meters). Sun is effectively at
+ * infinity, so we anchor in front of the camera each frame (mirrors three.js' `webgl_lensflares`
+ * example which always tracks the camera). Origin-anchoring would shrink the flare to a single
+ * pixel because the sky shell sits ~450 km away.
+ */
+var FLARE_FORWARD_DISTANCE = 200;
+/** Scale from legacy “size” to plane extent in world units. */
+var PLANE_SCALE = 1 / 45;
+/** Sun NDC radius below which ghosts and streak run at full strength. */
+var GHOST_FADE_START = 0.35;
+/** Sun NDC radius beyond which ghosts and streak are fully faded out. */
+var GHOST_FADE_END = 1.5;
+/** Raycast distance cap (meters): far enough for scene geometry, excludes huge skydome shell. */
+var OCCLUSION_MAX_DISTANCE = 10000;
+/** Avoid self-hit jitter when camera is very near geometry. */
+var OCCLUSION_NEAR = 0.1;
+/** Approximate angular radius for visibility sampling around the sun center ray. */
+var OCCLUSION_SAMPLE_RADIUS = 0.018;
+/** Smooth temporal response (higher = faster, lower = smoother). */
+var OCCLUSION_VISIBILITY_LERP = 0.2;
+/** Tiny alpha threshold to fully hide flare when effectively occluded. */
+var OCCLUSION_MIN_VISIBLE_ALPHA = 0.01;
+/**
+ * Run the 9-tap occlusion kernel only every Nth frame. Visibility is already
+ * temporally smoothed (see {@link OCCLUSION_VISIBILITY_LERP}), so a 3-frame
+ * cadence is visually indistinguishable from per-frame sampling — but cuts the
+ * raycast cost by ~3x.
+ */
+var OCCLUSION_SAMPLE_INTERVAL = 3;
+/**
+ * How many frames an occluder list is reused before being rebuilt. The scene
+ * graph rarely changes between frames, so walking it every frame just to
+ * collect raycastable meshes is wasted work.
+ */
+var OCCLUDER_LIST_REBUILD_INTERVAL = 12;
+/**
+ * How much the flare anchor shifts toward the visible side of the sun disc.
+ * 0 = disabled, 1 = full centroid shift.
+ */
+var OCCLUSION_ANCHOR_SHIFT = 0.75;
+/**
+ * Weight of center visibility in final alpha. Keeps flare dimmer when the sun core
+ * itself is blocked, even if edge samples are still visible.
+ */
+var OCCLUSION_CENTER_VISIBILITY_WEIGHT = 0.6;
+/** 9-tap kernel (center + cross + diagonals) for directional partial occlusion. */
+var OCCLUSION_SAMPLE_OFFSETS = [[0, 0, 2], [1, 0, 1], [-1, 0, 1], [0, 1, 1], [0, -1, 1], [0.7071, 0.7071, 1], [-0.7071, 0.7071, 1], [0.7071, -0.7071, 1], [-0.7071, -0.7071, 1]];
+/**
+ * Additive billboard lens flare on the sun direction: haze burst on the sun plus a chromatic
+ * ghost train (aperture hexagons, soft dots, a ring) laid out in screen space along the
+ * sun→screen-center axis, fading as the sun leaves the frame.
+ *
+ * Does **not** use `three/examples/jsm/objects/Lensflare.js`: that helper reads the framebuffer for
+ * occlusion (`copyFramebufferToTexture`), which fails or zeroes alpha when the scene is drawn through
+ * pmndrs `EffectComposer` / multisampled targets.
+ */
+function SunLensflare(_ref) {
+  var sunDirection = _ref.sunDirection,
+    _ref$color = _ref.color,
+    color = _ref$color === void 0 ? '#ffffff' : _ref$color,
+    _ref$distanceScale = _ref.distanceScale,
+    distanceScale = _ref$distanceScale === void 0 ? 1.0 : _ref$distanceScale,
+    _ref$sizeScale = _ref.sizeScale,
+    sizeScale = _ref$sizeScale === void 0 ? 1.0 : _ref$sizeScale,
+    _ref$occlusionEnabled = _ref.occlusionEnabled,
+    occlusionEnabled = _ref$occlusionEnabled === void 0 ? true : _ref$occlusionEnabled;
+  var scene = useThree(function (s) {
+    return s.scene;
+  });
+  // Index order matches the MAP_* constants used by ELEMENTS.
+  var maps = useMemo(function () {
+    var canvases = [drawFlareSprite(BURST_RAMP), drawFlareSprite(GHOST_RAMP), drawHexSprite(), drawFlareSprite(RING_RAMP)];
+    return canvases.map(function (canvas) {
+      var tex = new CanvasTexture(canvas);
+      tex.colorSpace = SRGBColorSpace;
+      return tex;
+    });
+  }, []);
+  useEffect(function () {
+    return function () {
+      maps.forEach(function (tex) {
+        return tex.dispose();
+      });
+    };
+  }, [maps]);
+  var rootRef = useRef(null);
+  var materialRefs = useRef([]);
+  var sunPos = useMemo(function () {
+    return new Vector3();
+  }, []);
+  var sunDirNormalized = useMemo(function () {
+    return new Vector3();
+  }, []);
+  var cameraWorldPos = useMemo(function () {
+    return new Vector3();
+  }, []);
+  var viewScratch = useMemo(function () {
+    return new Vector3();
+  }, []);
+  var rightScratch = useMemo(function () {
+    return new Vector3();
+  }, []);
+  var upScratch = useMemo(function () {
+    return new Vector3();
+  }, []);
+  var sampleDirScratch = useMemo(function () {
+    return new Vector3();
+  }, []);
+  var anchorShiftScratch = useMemo(function () {
+    return new Vector3();
+  }, []);
+  var elementPosScratch = useMemo(function () {
+    return new Vector3();
+  }, []);
+  var sunAnchorPos = useMemo(function () {
+    return new Vector3();
+  }, []);
+  var raycaster = useMemo(function () {
+    return new Raycaster();
+  }, []);
+  var hitBufferRef = useRef([]);
+  var smoothedVisibilityRef = useRef(1);
+  var smoothedCentroidXRef = useRef(0);
+  var smoothedCentroidYRef = useRef(0);
+  var frameCounterRef = useRef(0);
+  var occluderListRef = useRef([]);
+  var occluderListAgeRef = useRef(Number.MAX_SAFE_INTEGER);
+  var flareR = Math.max(10, FLARE_FORWARD_DISTANCE * distanceScale);
+  // Chromatic per-ghost tint composed with the overall flare colour.
+  var elementTints = useMemo(function () {
+    var base = new Color(color);
+    return ELEMENTS.map(function (el) {
+      var _el$tint;
+      return new Color((_el$tint = el.tint) !== null && _el$tint !== void 0 ? _el$tint : '#ffffff').multiply(base);
+    });
+  }, [color]);
+  useFrame(function (_ref2) {
+    var camera = _ref2.camera;
+    var g = rootRef.current;
+    if (!g) return;
+
+    // Anchor the burst at a fixed forward distance from the camera in the sun direction —
+    // gives a stable on-screen size regardless of the sky shell radius.
+    camera.getWorldPosition(cameraWorldPos);
+    sunDirNormalized.set(sunDirection[0], sunDirection[1], sunDirection[2]).normalize();
+    sunPos.copy(sunDirNormalized).multiplyScalar(flareR).add(cameraWorldPos);
+    viewScratch.copy(sunPos).applyMatrix4(camera.matrixWorldInverse);
+    var inFront = viewZInFront(viewScratch.z);
+    if (!occlusionEnabled) {
+      // Occlusion off → fast path: no raycaster, no scene traversal, no kernel loop. Just lock
+      // visibility at 1 (when in front of camera) and keep the anchor dead-center on the sun.
+      smoothedVisibilityRef.current = inFront ? 1 : 0;
+      smoothedCentroidXRef.current = 0;
+      smoothedCentroidYRef.current = 0;
+      sunAnchorPos.copy(sunPos);
+    } else {
+      rightScratch.set(1, 0, 0).applyQuaternion(camera.quaternion).normalize();
+      upScratch.set(0, 1, 0).applyQuaternion(camera.quaternion).normalize();
+      var frame = frameCounterRef.current++;
+      var shouldSample = inFront && frame % OCCLUSION_SAMPLE_INTERVAL === 0;
+      if (shouldSample) {
+        var occluders = getOccluders(scene, g, occluderListRef, occluderListAgeRef);
+        var totalWeight = 0;
+        var visibleWeight = 0;
+        var weightedVisibleX = 0;
+        var weightedVisibleY = 0;
+        var centerVisible = 0;
+        for (var i = 0; i < OCCLUSION_SAMPLE_OFFSETS.length; i++) {
+          var _OCCLUSION_SAMPLE_OFF = _slicedToArray(OCCLUSION_SAMPLE_OFFSETS[i], 3),
+            ox = _OCCLUSION_SAMPLE_OFF[0],
+            oy = _OCCLUSION_SAMPLE_OFF[1],
+            w = _OCCLUSION_SAMPLE_OFF[2];
+          sampleDirScratch.copy(sunDirNormalized).addScaledVector(rightScratch, ox * OCCLUSION_SAMPLE_RADIUS).addScaledVector(upScratch, oy * OCCLUSION_SAMPLE_RADIUS).normalize();
+          raycaster.near = OCCLUSION_NEAR;
+          raycaster.far = OCCLUSION_MAX_DISTANCE;
+          raycaster.set(cameraWorldPos, sampleDirScratch);
+          var hits = hitBufferRef.current;
+          hits.length = 0;
+          // `recursive: false` — `occluders` is already a flat list of leaf
+          // meshes filtered to skip InstancedMesh / SkinnedMesh / opt-outs.
+          raycaster.intersectObjects(occluders, false, hits);
+          var visible = hits.length > 0 ? 0 : 1;
+          totalWeight += w;
+          visibleWeight += visible * w;
+          weightedVisibleX += ox * visible * w;
+          weightedVisibleY += oy * visible * w;
+          if (i === 0) centerVisible = visible;
+        }
+        var avgVisibility = totalWeight > 0 ? visibleWeight / totalWeight : 0;
+        var targetVisibility = avgVisibility * (1 - OCCLUSION_CENTER_VISIBILITY_WEIGHT) + centerVisible * OCCLUSION_CENTER_VISIBILITY_WEIGHT;
+        var targetCentroidX = visibleWeight > 1e-4 ? weightedVisibleX / visibleWeight : 0;
+        var targetCentroidY = visibleWeight > 1e-4 ? weightedVisibleY / visibleWeight : 0;
+        var prevVis = smoothedVisibilityRef.current;
+        smoothedVisibilityRef.current = Math.min(1, Math.max(0, prevVis + (targetVisibility - prevVis) * OCCLUSION_VISIBILITY_LERP));
+        smoothedCentroidXRef.current += (targetCentroidX - smoothedCentroidXRef.current) * OCCLUSION_VISIBILITY_LERP;
+        smoothedCentroidYRef.current += (targetCentroidY - smoothedCentroidYRef.current) * OCCLUSION_VISIBILITY_LERP;
+      } else if (!inFront) {
+        // Sun behind camera: decay toward zero so we don't hold stale visibility
+        // when the user spins around.
+        smoothedVisibilityRef.current *= 1 - OCCLUSION_VISIBILITY_LERP;
+      }
+
+      // Shift anchor toward the visible side of the sun disc so left/right occlusion
+      // produces visibly different flare behavior (instead of only scalar alpha changes).
+      var worldShift = flareR * OCCLUSION_SAMPLE_RADIUS * OCCLUSION_ANCHOR_SHIFT;
+      anchorShiftScratch.copy(rightScratch).multiplyScalar(smoothedCentroidXRef.current * worldShift).addScaledVector(upScratch, smoothedCentroidYRef.current * worldShift);
+      sunAnchorPos.copy(sunPos).add(anchorShiftScratch);
+    }
+    var visibility = smoothedVisibilityRef.current;
+    g.visible = inFront && visibility > OCCLUSION_MIN_VISIBLE_ALPHA;
+    if (!g.visible) return;
+    g.position.copy(sunAnchorPos);
+
+    // Ghost axis in screen space: internal reflections mirror the light through the optical
+    // center, so each element sits at `along` on the line from the sun NDC through (0,0).
+    viewScratch.copy(sunAnchorPos).project(camera);
+    var sunNdcX = viewScratch.x;
+    var sunNdcY = viewScratch.y;
+
+    // Ghosts strengthen as the sun approaches the frame and vanish once it leaves.
+    var offCenter = Math.hypot(sunNdcX, sunNdcY);
+    var ghostStrength = 1 - (offCenter - GHOST_FADE_START) / (GHOST_FADE_END - GHOST_FADE_START);
+    ghostStrength = Math.min(1, Math.max(0, ghostStrength));
+    ghostStrength = ghostStrength * ghostStrength * (3 - 2 * ghostStrength);
+    var n = g.children.length;
+    for (var _i2 = 0; _i2 < n; _i2++) {
+      var el = ELEMENTS[_i2];
+      var child = g.children[_i2];
+      var k = 1 - 2 * el.along;
+      elementPosScratch.set(sunNdcX * k, sunNdcY * k, 0.5).unproject(camera).sub(cameraWorldPos).normalize();
+      child.position.copy(elementPosScratch).multiplyScalar(flareR).add(cameraWorldPos).sub(g.position);
+      var mat = materialRefs.current[_i2];
+      if (mat) {
+        mat.opacity = el.opacity * visibility * (el.along === 0 ? 1 : ghostStrength);
+      }
+    }
+  });
+  return /*#__PURE__*/jsx("group", {
+    ref: rootRef,
+    frustumCulled: false,
+    children: ELEMENTS.map(function (el, i) {
+      var dim = el.size * PLANE_SCALE * sizeScale;
+      return /*#__PURE__*/jsx("group", {
+        children: /*#__PURE__*/jsx(Billboard, {
+          follow: true,
+          lockX: false,
+          lockY: false,
+          lockZ: false,
+          children: /*#__PURE__*/jsxs("mesh", {
+            renderOrder: 10000,
+            children: [/*#__PURE__*/jsx("planeGeometry", {
+              args: [dim, dim]
+            }), /*#__PURE__*/jsx("meshBasicMaterial", {
+              ref: function ref(mat) {
+                materialRefs.current[i] = mat;
+              },
+              map: maps[el.mapIndex],
+              color: elementTints[i],
+              transparent: true,
+              opacity: el.opacity,
+              depthTest: false,
+              depthWrite: false,
+              toneMapped: false,
+              blending: AdditiveBlending
+            })]
+          })
+        })
+      }, i);
+    })
+  });
+}
+
+/** Right-handed view space: camera looks down −Z, so in-front surfaces have negative Z. */
+function viewZInFront(viewZ) {
+  return viewZ < 0;
+}
+
+/**
+ * Collect a flat list of meshes worth raycasting against for sun occlusion.
+ * The result is cached for {@link OCCLUDER_LIST_REBUILD_INTERVAL} frames so a
+ * static scene only walks the graph occasionally. Excludes:
+ * - the lensflare's own root (avoids self-hits)
+ * - invisible objects
+ * - `userData.lensflare === 'no-occlusion'` opt-outs
+ * - `InstancedMesh` (scattered trees) — per-instance raycasts are O(N)
+ *   and these are decorative, not real occluders for the sun disc
+ * - `SkinnedMesh` — skin-bound raycasts force skeleton matrix work
+ */
+function getOccluders(scene, flareRoot, listRef, ageRef) {
+  ageRef.current += 1;
+  if (ageRef.current < OCCLUDER_LIST_REBUILD_INTERVAL && listRef.current.length > 0) {
+    return listRef.current;
+  }
+  ageRef.current = 0;
+  var list = listRef.current;
+  list.length = 0;
+  scene.traverseVisible(function (object) {
+    if (flareRoot.getObjectById(object.id) !== undefined) return;
+    if (object.userData.lensflare === 'no-occlusion') return;
+    var anyObj = object;
+    if (anyObj.isInstancedMesh === true) return;
+    if (anyObj.isSkinnedMesh === true) return;
+    if (anyObj.isMesh === true) list.push(object);
+  });
+  return list;
+}
+
+export { SunLensflare };