@crystaldesign/real-time-viewer-next 26.11.0-beta.22 → 26.11.0-beta.24

package/build/esm/{DeckCutoutSubsystem-76dfe828.js → DeckCutoutSubsystem-4369a7a2.js}

@@ -1,4 +1,4 @@
-import { p as parseElementKey, u as useRTVStore, b as bootPhase, D as DECK_COLLAR_LOAD_ID } from './index-920dd901.js';
+import { p as parseElementKey, u as useRTVStore, b as bootPhase, D as DECK_COLLAR_LOAD_ID } from './index-fa3c5a24.js';
 import { useMemo, useRef, useEffect, useState, useCallback } from 'react';
 import _slicedToArray from '@babel/runtime/helpers/slicedToArray';
 import _defineProperty from '@babel/runtime/helpers/defineProperty';

package/build/esm/{SunLensflare-e4ab3f81.js → SunLensflare-6d65fd17.js}

@@ -1,5 +1,5 @@
 import _slicedToArray from '@babel/runtime/helpers/slicedToArray';
-import './index-920dd901.js';
+import { f as flushPendingBVH, e as collectCollisionTargets } from './index-fa3c5a24.js';
 import { useMemo, useEffect, useRef } from 'react';
 import { Billboard } from '@react-three/drei';
 import { useThree, useFrame } from '@react-three/fiber';
@@ -191,23 +191,29 @@ var OCCLUSION_MAX_DISTANCE = 10000;
 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;
+/**
+ * Temporal response toward LESS visibility (higher = faster, 1 = instant). Asymmetric on purpose:
+ * a light source winks out the moment something blocks it, so the fade-out has to feel immediate,
+ * while the partial-occlusion gradations still get a little smoothing against tap noise.
+ */
+var OCCLUSION_HIDE_LERP = 0.55;
+/**
+ * Temporal response toward MORE visibility. Slower than {@link OCCLUSION_HIDE_LERP}: the flare
+ * re-emerging along a geometry edge eases in instead of popping/flickering with every tap that
+ * clears.
+ */
+var OCCLUSION_REVEAL_LERP = 0.2;
+/** Temporal response of the anchor centroid shift — jitter matters more than speed here. */
+var OCCLUSION_CENTROID_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.
+ * temporally smoothed (see {@link OCCLUSION_HIDE_LERP} / {@link OCCLUSION_REVEAL_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.
@@ -228,6 +234,11 @@ var OCCLUSION_SAMPLE_OFFSETS = [[0, 0, 2], [1, 0, 1], [-1, 0, 1], [0, 1, 1], [0,
  * 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.
+ *
+ * Occlusion taps run against `collectCollisionTargets` (article + BVH decor) — the same scoped set
+ * the camera-collision probe uses, and for the same reason: raycasting the whole scene puts every
+ * blocked ray on three.js' O(triangles) `Mesh.raycast`, which stalls weak CPUs exactly while the
+ * sun sits behind geometry. Visual aids, drag previews and the sky shells drop out with it.
  */
 function SunLensflare(_ref) {
   var sunDirection = _ref.sunDirection,
@@ -238,7 +249,9 @@ function SunLensflare(_ref) {
     _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;
+    occlusionEnabled = _ref$occlusionEnabled === void 0 ? true : _ref$occlusionEnabled,
+    _ref$occludersRevisio = _ref.occludersRevision,
+    occludersRevision = _ref$occludersRevisio === void 0 ? 0 : _ref$occludersRevisio;
   var scene = useThree(function (s) {
     return s.scene;
   });
@@ -290,16 +303,23 @@ function SunLensflare(_ref) {
   var sunAnchorPos = useMemo(function () {
     return new Vector3();
   }, []);
+  // near/far never change, and `firstHitOnly` (three-mesh-bvh) makes every mesh with a
+  // `boundsTree` report at most one hit — the taps ask a boolean, so any hit past the
+  // first is wasted work.
   var raycaster = useMemo(function () {
-    return new Raycaster();
+    var r = new Raycaster();
+    r.near = OCCLUSION_NEAR;
+    r.far = OCCLUSION_MAX_DISTANCE;
+    r.firstHitOnly = true;
+    return r;
   }, []);
   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 occludersRef = useRef([]);
+  var occludersBuiltForRef = useRef(null);
   var flareR = Math.max(10, FLARE_FORWARD_DISTANCE * distanceScale);
   // Chromatic per-ghost tint composed with the overall flare colour.
   var elementTints = useMemo(function () {
@@ -334,7 +354,14 @@ function SunLensflare(_ref) {
       var frame = frameCounterRef.current++;
       var shouldSample = inFront && frame % OCCLUSION_SAMPLE_INTERVAL === 0;
       if (shouldSample) {
-        var occluders = getOccluders(scene, g, occluderListRef, occluderListAgeRef);
+        if (occludersBuiltForRef.current !== occludersRevision) {
+          occludersBuiltForRef.current = occludersRevision;
+          // Build queued BVHs first: a `boundsTree` is what marks decor collidable, and the
+          // article's trees keep the taps below off the O(triangles) raycast path.
+          flushPendingBVH();
+          occludersRef.current = collectCollisionTargets(scene).meshes;
+        }
+        var occluders = occludersRef.current;
         var totalWeight = 0;
         var visibleWeight = 0;
         var weightedVisibleX = 0;
@@ -346,15 +373,17 @@ function SunLensflare(_ref) {
             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;
+          var blocked = false;
+          // Any hit answers the tap — stop at the first blocking mesh instead of collecting
+          // (and sorting) every intersection along the whole ray.
+          for (var m = 0; m < occluders.length && !blocked; m++) {
+            hits.length = 0;
+            raycaster.intersectObject(occluders[m], false, hits);
+            blocked = hits.length > 0;
+          }
+          var visible = blocked ? 0 : 1;
           totalWeight += w;
           visibleWeight += visible * w;
           weightedVisibleX += ox * visible * w;
@@ -366,13 +395,14 @@ function SunLensflare(_ref) {
         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;
+        var visibilityLerp = targetVisibility < prevVis ? OCCLUSION_HIDE_LERP : OCCLUSION_REVEAL_LERP;
+        smoothedVisibilityRef.current = Math.min(1, Math.max(0, prevVis + (targetVisibility - prevVis) * visibilityLerp));
+        smoothedCentroidXRef.current += (targetCentroidX - smoothedCentroidXRef.current) * OCCLUSION_CENTROID_LERP;
+        smoothedCentroidYRef.current += (targetCentroidY - smoothedCentroidYRef.current) * OCCLUSION_CENTROID_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;
+        smoothedVisibilityRef.current *= 1 - OCCLUSION_HIDE_LERP;
       }
 
       // Shift anchor toward the visible side of the sun disc so left/right occlusion
@@ -450,34 +480,4 @@ 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 };

package/build/esm/{WaterSurface-93383fdf.js → WaterSurface-95b630aa.js}

@@ -1,4 +1,4 @@
-import { w as withRenderTarget, s as setCausticReceiversSuspended, a as waterUniforms, d as disableWaterUniforms, u as useRTVStore, F as FRAME_ORDER, c as sunAnglesToDirection, l as lightingSunTowardDirection } from './index-920dd901.js';
+import { w as withRenderTarget, s as setCausticReceiversSuspended, a as waterUniforms, d as disableWaterUniforms, u as useRTVStore, F as FRAME_ORDER, c as sunAnglesToDirection, l as lightingSunTowardDirection } from './index-fa3c5a24.js';
 import { useRef, useMemo, useEffect, useCallback } from 'react';
 import { useThree, useFrame } from '@react-three/fiber';
 import { Vector3, WebGLRenderTarget, HalfFloatType, RGBAFormat, LinearFilter, OrthographicCamera, ShaderMaterial, DoubleSide, MeshStandardMaterial, Box3, NoToneMapping, Frustum, Matrix4, Vector4, Vector2, Plane, Scene, Mesh, PlaneGeometry, ClampToEdgeWrapping, UnsignedByteType, MeshBasicMaterial, Color } from 'three';