1import { r as reactExports, j as jsxRuntimeExports } from "./vendor-react-Bay9Y7Lb.js"; 2import { a3 as Vector3, a4 as Spherical, a5 as Quaternion, a6 as OrthographicCamera, a7 as Vector2, a8 as PerspectiveCamera, a9 as MOUSE, aa as TOUCH, ab as Ray, ac as Plane, ad as constantsExports, ae as Raycaster, af as Scene, ag as PCFSoftShadowMap, ah as VSMShadowMap, ai as PCFShadowMap, aj as BasicShadowMap, ak as NoToneMapping, al as ACESFilmicToneMapping, am as WebGLRenderer, an as Camera, ao as Clock, ap as Reconciler, aq as Layers, ar as RGBAFormat, as as UnsignedByteType, at as FiberProvider, au as useContextBridge, av as j, aw as THREE, ax as MathUtils, ay as ShaderMaterial, az as UniformsUtils, aA as REVISION, aB as _extends, aC as CameraControls$1, aD as Vector4, aE as Sphere, aF as Matrix4, aG as Box3, aH as BackSide, aI as Color } from "./vendor-dVNaLJx_.js"; 3const scriptRel = "modulepreload"; 4const assetsURL = function(dep) { 5 return "/" + dep; 6}; 7const seen = {}; 8const __vitePreload = function preload(baseModule, deps, importerUrl) { 9 let promise = Promise.resolve(); 10 if (deps && deps.length > 0) { 11 document.getElementsByTagName("link"); 12 const cspNonceMeta = document.querySelector( 13 "meta[property=csp-nonce]" 14 ); 15 const cspNonce = (cspNonceMeta == null ? void 0 : cspNonceMeta.nonce) || (cspNonceMeta == null ? void 0 : cspNonceMeta.getAttribute("nonce")); 16 promise = Promise.allSettled( 17 deps.map((dep) => { 18 dep = assetsURL(dep); 19 if (dep in seen) return; 20 seen[dep] = true; 21 const isCss = dep.endsWith(".css"); 22 const cssSelector = isCss ? '[rel="stylesheet"]' : ""; 23 if (document.querySelector(`link[href="${dep}"]${cssSelector}`)) { 24 return; 25 } 26 const link = document.createElement("link"); 27 link.rel = isCss ? "stylesheet" : scriptRel; 28 if (!isCss) { 29 link.as = "script"; 30 } 31 link.crossOrigin = ""; 32 link.href = dep; 33 if (cspNonce) { 34 link.setAttribute("nonce", cspNonce); 35 } 36 document.head.appendChild(link); 37 if (isCss) { 38 return new Promise((res, rej) => { 39 link.addEventListener("load", res); 40 link.addEventListener( 41 "error", 42 () => rej(new Error(`Unable to preload CSS for ${dep}`)) 43 ); 44 }); 45 } 46 }) 47 ); 48 } 49 function handlePreloadError(err) { 50 const e = new Event("vite:preloadError", { 51 cancelable: true 52 }); 53 e.payload = err; 54 window.dispatchEvent(e); 55 if (!e.defaultPrevented) { 56 throw err; 57 } 58 } 59 return promise.then((res) => { 60 for (const item of res || []) { 61 if (item.status !== "rejected") continue; 62 handlePreloadError(item.reason); 63 } 64 return baseModule().catch(handlePreloadError); 65 }); 66}; 67var __defProp$1 = Object.defineProperty; 68var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value; 69var __publicField$1 = (obj, key, value) => { 70 __defNormalProp$1(obj, key + "", value); 71 return value; 72}; 73class EventDispatcher { 74 constructor() { 75 __publicField$1(this, "_listeners"); 76 } 77 /** 78 * Adds a listener to an event type. 79 * @param type The type of event to listen to. 80 * @param listener The function that gets called when the event is fired. 81 */ 82 addEventListener(type, listener) { 83 if (this._listeners === void 0) 84 this._listeners = {}; 85 const listeners = this._listeners; 86 if (listeners[type] === void 0) { 87 listeners[type] = []; 88 } 89 if (listeners[type].indexOf(listener) === -1) { 90 listeners[type].push(listener); 91 } 92 } 93 /** 94 * Checks if listener is added to an event type. 95 * @param type The type of event to listen to. 96 * @param listener The function that gets called when the event is fired. 97 */ 98 hasEventListener(type, listener) { 99 if (this._listeners === void 0) 100 return false; 101 const listeners = this._listeners; 102 return listeners[type] !== void 0 && listeners[type].indexOf(listener) !== -1; 103 } 104 /** 105 * Removes a listener from an event type. 106 * @param type The type of the listener that gets removed. 107 * @param listener The listener function that gets removed. 108 */ 109 removeEventListener(type, listener) { 110 if (this._listeners === void 0) 111 return; 112 const listeners = this._listeners; 113 const listenerArray = listeners[type]; 114 if (listenerArray !== void 0) { 115 const index = listenerArray.indexOf(listener); 116 if (index !== -1) { 117 listenerArray.splice(index, 1); 118 } 119 } 120 } 121 /** 122 * Fire an event type. 123 * @param event The event that gets fired. 124 */ 125 dispatchEvent(event) { 126 if (this._listeners === void 0) 127 return; 128 const listeners = this._listeners; 129 const listenerArray = listeners[event.type]; 130 if (listenerArray !== void 0) { 131 event.target = this; 132 const array = listenerArray.slice(0); 133 for (let i2 = 0, l = array.length; i2 < l; i2++) { 134 array[i2].call(this, event); 135 } 136 event.target = null; 137 } 138 } 139} 140var __defProp = Object.defineProperty; 141var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value; 142var __publicField = (obj, key, value) => { 143 __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value); 144 return value; 145}; 146const _ray = /* @__PURE__ */ new Ray(); 147const _plane = /* @__PURE__ */ new Plane();
148const TILT_LIMIT = Math.cos(70 * (Math.PI / 180)); 149const moduloWrapAround = (offset, capacity) => (offset % capacity + capacity) % capacity; 150let OrbitControls$1 = class OrbitControls extends EventDispatcher { 151 constructor(object, domElement) { 152 super(); 153 __publicField(this, "object"); 154 __publicField(this, "domElement"); 155 __publicField(this, "enabled", true); 156 __publicField(this, "target", new Vector3()); 157 __publicField(this, "minDistance", 0); 158 __publicField(this, "maxDistance", Infinity); 159 __publicField(this, "minZoom", 0); 160 __publicField(this, "maxZoom", Infinity); 161 __publicField(this, "minPolarAngle", 0); 162 __publicField(this, "maxPolarAngle", Math.PI); 163 __publicField(this, "minAzimuthAngle", -Infinity); 164 __publicField(this, "maxAzimuthAngle", Infinity); 165 __publicField(this, "enableDamping", false); 166 __publicField(this, "dampingFactor", 0.05); 167 __publicField(this, "enableZoom", true); 168 __publicField(this, "zoomSpeed", 1); 169 __publicField(this, "enableRotate", true); 170 __publicField(this, "rotateSpeed", 1); 171 __publicField(this, "enablePan", true); 172 __publicField(this, "panSpeed", 1); 173 __publicField(this, "screenSpacePanning", true); 174 __publicField(this, "keyPanSpeed", 7); 175 __publicField(this, "zoomToCursor", false); 176 __publicField(this, "autoRotate", false); 177 __publicField(this, "autoRotateSpeed", 2); 178 __publicField(this, "reverseOrbit", false); 179 __publicField(this, "reverseHorizontalOrbit", false); 180 __publicField(this, "reverseVerticalOrbit", false); 181 __publicField(this, "keys", { LEFT: "ArrowLeft", UP: "ArrowUp", RIGHT: "ArrowRight", BOTTOM: "ArrowDown" }); 182 __publicField(this, "mouseButtons", { 183 LEFT: MOUSE.ROTATE, 184 MIDDLE: MOUSE.DOLLY, 185 RIGHT: MOUSE.PAN 186 }); 187 __publicField(this, "touches", { ONE: TOUCH.ROTATE, TWO: TOUCH.DOLLY_PAN }); 188 __publicField(this, "target0"); 189 __publicField(this, "position0"); 190 __publicField(this, "zoom0"); 191 __publicField(this, "_domElementKeyEvents", null); 192 __publicField(this, "getPolarAngle"); 193 __publicField(this, "getAzimuthalAngle"); 194 __publicField(this, "setPolarAngle"); 195 __publicField(this, "setAzimuthalAngle"); 196 __publicField(this, "getDistance"); 197 __publicField(this, "getZoomScale"); 198 __publicField(this, "listenToKeyEvents"); 199 __publicField(this, "stopListenToKeyEvents"); 200 __publicField(this, "saveState"); 201 __publicField(this, "reset"); 202 __publicField(this, "update"); 203 __publicField(this, "connect"); 204 __publicField(this, "dispose"); 205 __publicField(this, "dollyIn"); 206 __publicField(this, "dollyOut"); 207 __publicField(this, "getScale"); 208 __publicField(this, "setScale"); 209 this.object = object; 210 this.domElement = domElement; 211 this.target0 = this.target.clone(); 212 this.position0 = this.object.position.clone(); 213 this.zoom0 = this.object.zoom; 214 this.getPolarAngle = () => spherical.phi; 215 this.getAzimuthalAngle = () => spherical.theta; 216 this.setPolarAngle = (value) => { 217 let phi = moduloWrapAround(value, 2 * Math.PI); 218 let currentPhi = spherical.phi; 219 if (currentPhi < 0) 220 currentPhi += 2 * Math.PI; 221 if (phi < 0) 222 phi += 2 * Math.PI; 223 let phiDist = Math.abs(phi - currentPhi); 224 if (2 * Math.PI - phiDist < phiDist) { 225 if (phi < currentPhi) { 226 phi += 2 * Math.PI; 227 } else { 228 currentPhi += 2 * Math.PI; 229 } 230 } 231 sphericalDelta.phi = phi - currentPhi; 232 scope.update(); 233 }; 234 this.setAzimuthalAngle = (value) => { 235 let theta = moduloWrapAround(value, 2 * Math.PI); 236 let currentTheta = spherical.theta; 237 if (currentTheta < 0) 238 currentTheta += 2 * Math.PI; 239 if (theta < 0) 240 theta += 2 * Math.PI; 241 let thetaDist = Math.abs(theta - currentTheta); 242 if (2 * Math.PI - thetaDist < thetaDist) { 243 if (theta < currentTheta) { 244 theta += 2 * Math.PI; 245 } else { 246 currentTheta += 2 * Math.PI; 247 } 248 } 249 sphericalDelta.theta = theta - currentTheta;
250 scope.update(); 251 }; 252 this.getDistance = () => scope.object.position.distanceTo(scope.target); 253 this.listenToKeyEvents = (domElement2) => { 254 domElement2.addEventListener("keydown", onKeyDown); 255 this._domElementKeyEvents = domElement2; 256 }; 257 this.stopListenToKeyEvents = () => { 258 this._domElementKeyEvents.removeEventListener("keydown", onKeyDown); 259 this._domElementKeyEvents = null; 260 }; 261 this.saveState = () => { 262 scope.target0.copy(scope.target); 263 scope.position0.copy(scope.object.position); 264 scope.zoom0 = scope.object.zoom; 265 }; 266 this.reset = () => { 267 scope.target.copy(scope.target0); 268 scope.object.position.copy(scope.position0); 269 scope.object.zoom = scope.zoom0; 270 scope.object.updateProjectionMatrix(); 271 scope.dispatchEvent(changeEvent); 272 scope.update(); 273 state = STATE.NONE; 274 }; 275 this.update = (() => { 276 const offset = new Vector3(); 277 const up = new Vector3(0, 1, 0); 278 const quat = new Quaternion().setFromUnitVectors(object.up, up); 279 const quatInverse = quat.clone().invert(); 280 const lastPosition = new Vector3(); 281 const lastQuaternion = new Quaternion(); 282 const twoPI = 2 * Math.PI; 283 return function update() { 284 const position = scope.object.position; 285 quat.setFromUnitVectors(object.up, up); 286 quatInverse.copy(quat).invert(); 287 offset.copy(position).sub(scope.target); 288 offset.applyQuaternion(quat); 289 spherical.setFromVector3(offset); 290 if (scope.autoRotate && state === STATE.NONE) { 291 rotateLeft(getAutoRotationAngle()); 292 } 293 if (scope.enableDamping) { 294 spherical.theta += sphericalDelta.theta * scope.dampingFactor; 295 spherical.phi += sphericalDelta.phi * scope.dampingFactor; 296 } else { 297 spherical.theta += sphericalDelta.theta; 298 spherical.phi += sphericalDelta.phi; 299 } 300 let min = scope.minAzimuthAngle; 301 let max = scope.maxAzimuthAngle; 302 if (isFinite(min) && isFinite(max)) { 303 if (min < -Math.PI) 304 min += twoPI; 305 else if (min > Math.PI) 306 min -= twoPI; 307 if (max < -Math.PI) 308 max += twoPI; 309 else if (max > Math.PI) 310 max -= twoPI; 311 if (min <= max) { 312 spherical.theta = Math.max(min, Math.min(max, spherical.theta)); 313 } else { 314 spherical.theta = spherical.theta > (min + max) / 2 ? Math.max(min, spherical.theta) : Math.min(max, spherical.theta); 315 } 316 } 317 spherical.phi = Math.max(scope.minPolarAngle, Math.min(scope.maxPolarAngle, spherical.phi)); 318 spherical.makeSafe(); 319 if (scope.enableDamping === true) { 320 scope.target.addScaledVector(panOffset, scope.dampingFactor); 321 } else { 322 scope.target.add(panOffset); 323 } 324 if (scope.zoomToCursor && performCursorZoom || scope.object.isOrthographicCamera) { 325 spherical.radius = clampDistance(spherical.radius); 326 } else { 327 spherical.radius = clampDistance(spherical.radius * scale); 328 } 329 offset.setFromSpherical(spherical); 330 offset.applyQuaternion(quatInverse); 331 position.copy(scope.target).add(offset); 332 if (!scope.object.matrixAutoUpdate) 333 scope.object.updateMatrix(); 334 scope.object.lookAt(scope.target); 335 if (scope.enableDamping === true) { 336 sphericalDelta.theta *= 1 - scope.dampingFactor; 337 sphericalDelta.phi *= 1 - scope.dampingFactor; 338 panOffset.multiplyScalar(1 - scope.dampingFactor); 339 } else { 340 sphericalDelta.set(0, 0, 0); 341 panOffset.set(0, 0, 0); 342 } 343 let zoomChanged = false; 344 if (scope.zoomToCursor && performCursorZoom) { 345 let newRadius = null; 346 if (scope.object instanceof PerspectiveCamera && scope.object.isPerspectiveCamera) { 347 const prevRadius = offset.length(); 348 newRadius = clampDistance(prevRadius * scale); 349 const radiusDelta = prevRadius - newRadius; 350 scope.object.position.addScaledVector(dollyDirection, radiusDelta); 351 scope.object.updateMatrixWorld(); 352 } else if (scope.object.isOrthographicCamera) {
353 const mouseBefore = new Vector3(mouse.x, mouse.y, 0); 354 mouseBefore.unproject(scope.object); 355 scope.object.zoom = Math.max(scope.minZoom, Math.min(scope.maxZoom, scope.object.zoom / scale)); 356 scope.object.updateProjectionMatrix(); 357 zoomChanged = true; 358 const mouseAfter = new Vector3(mouse.x, mouse.y, 0); 359 mouseAfter.unproject(scope.object); 360 scope.object.position.sub(mouseAfter).add(mouseBefore); 361 scope.object.updateMatrixWorld(); 362 newRadius = offset.length(); 363 } else { 364 console.warn("WARNING: OrbitControls.js encountered an unknown camera type - zoom to cursor disabled."); 365 scope.zoomToCursor = false; 366 } 367 if (newRadius !== null) { 368 if (scope.screenSpacePanning) { 369 scope.target.set(0, 0, -1).transformDirection(scope.object.matrix).multiplyScalar(newRadius).add(scope.object.position); 370 } else { 371 _ray.origin.copy(scope.object.position); 372 _ray.direction.set(0, 0, -1).transformDirection(scope.object.matrix); 373 if (Math.abs(scope.object.up.dot(_ray.direction)) < TILT_LIMIT) { 374 object.lookAt(scope.target); 375 } else { 376 _plane.setFromNormalAndCoplanarPoint(scope.object.up, scope.target); 377 _ray.intersectPlane(_plane, scope.target); 378 } 379 } 380 } 381 } else if (scope.object instanceof OrthographicCamera && scope.object.isOrthographicCamera) { 382 zoomChanged = scale !== 1; 383 if (zoomChanged) { 384 scope.object.zoom = Math.max(scope.minZoom, Math.min(scope.maxZoom, scope.object.zoom / scale)); 385 scope.object.updateProjectionMatrix(); 386 } 387 } 388 scale = 1; 389 performCursorZoom = false;
390 if (zoomChanged || lastPosition.distanceToSquared(scope.object.position) > EPS || 8 * (1 - lastQuaternion.dot(scope.object.quaternion)) > EPS) { 391 scope.dispatchEvent(changeEvent); 392 lastPosition.copy(scope.object.position); 393 lastQuaternion.copy(scope.object.quaternion); 394 zoomChanged = false; 395 return true; 396 } 397 return false; 398 }; 399 })(); 400 this.connect = (domElement2) => { 401 scope.domElement = domElement2; 402 scope.domElement.style.touchAction = "none"; 403 scope.domElement.addEventListener("contextmenu", onContextMenu); 404 scope.domElement.addEventListener("pointerdown", onPointerDown); 405 scope.domElement.addEventListener("pointercancel", onPointerUp); 406 scope.domElement.addEventListener("wheel", onMouseWheel); 407 }; 408 this.dispose = () => { 409 var _a, _b, _c, _d, _e, _f; 410 if (scope.domElement) { 411 scope.domElement.style.touchAction = "auto"; 412 } 413 (_a = scope.domElement) == null ? void 0 : _a.removeEventListener("contextmenu", onContextMenu); 414 (_b = scope.domElement) == null ? void 0 : _b.removeEventListener("pointerdown", onPointerDown); 415 (_c = scope.domElement) == null ? void 0 : _c.removeEventListener("pointercancel", onPointerUp); 416 (_d = scope.domElement) == null ? void 0 : _d.removeEventListener("wheel", onMouseWheel); 417 (_e = scope.domElement) == null ? void 0 : _e.ownerDocument.removeEventListener("pointermove", onPointerMove); 418 (_f = scope.domElement) == null ? void 0 : _f.ownerDocument.removeEventListener("pointerup", onPointerUp); 419 if (scope._domElementKeyEvents !== null) { 420 scope._domElementKeyEvents.removeEventListener("keydown", onKeyDown); 421 } 422 }; 423 const scope = this; 424 const changeEvent = { type: "change" }; 425 const startEvent = { type: "start" }; 426 const endEvent = { type: "end" }; 427 const STATE = { 428 NONE: -1, 429 ROTATE: 0, 430 DOLLY: 1, 431 PAN: 2, 432 TOUCH_ROTATE: 3, 433 TOUCH_PAN: 4, 434 TOUCH_DOLLY_PAN: 5, 435 TOUCH_DOLLY_ROTATE: 6 436 }; 437 let state = STATE.NONE; 438 const EPS = 1e-6; 439 const spherical = new Spherical(); 440 const sphericalDelta = new Spherical(); 441 let scale = 1; 442 const panOffset = new Vector3(); 443 const rotateStart = new Vector2(); 444 const rotateEnd = new Vector2(); 445 const rotateDelta = new Vector2(); 446 const panStart = new Vector2(); 447 const panEnd = new Vector2(); 448 const panDelta = new Vector2(); 449 const dollyStart = new Vector2(); 450 const dollyEnd = new Vector2(); 451 const dollyDelta = new Vector2(); 452 const dollyDirection = new Vector3(); 453 const mouse = new Vector2(); 454 let performCursorZoom = false;
455 const pointers = []; 456 const pointerPositions = {}; 457 function getAutoRotationAngle() { 458 return 2 * Math.PI / 60 / 60 * scope.autoRotateSpeed; 459 } 460 function getZoomScale() { 461 return Math.pow(0.95, scope.zoomSpeed); 462 } 463 function rotateLeft(angle) { 464 if (scope.reverseOrbit || scope.reverseHorizontalOrbit) { 465 sphericalDelta.theta += angle; 466 } else { 467 sphericalDelta.theta -= angle; 468 } 469 } 470 function rotateUp(angle) { 471 if (scope.reverseOrbit || scope.reverseVerticalOrbit) { 472 sphericalDelta.phi += angle; 473 } else { 474 sphericalDelta.phi -= angle; 475 } 476 } 477 const panLeft = (() => { 478 const v = new Vector3(); 479 return function panLeft2(distance, objectMatrix) { 480 v.setFromMatrixColumn(objectMatrix, 0); 481 v.multiplyScalar(-distance); 482 panOffset.add(v); 483 }; 484 })(); 485 const panUp = (() => { 486 const v = new Vector3(); 487 return function panUp2(distance, objectMatrix) { 488 if (scope.screenSpacePanning === true) { 489 v.setFromMatrixColumn(objectMatrix, 1); 490 } else { 491 v.setFromMatrixColumn(objectMatrix, 0); 492 v.crossVectors(scope.object.up, v); 493 } 494 v.multiplyScalar(distance); 495 panOffset.add(v); 496 }; 497 })(); 498 const pan = (() => { 499 const offset = new Vector3(); 500 return function pan2(deltaX, deltaY) { 501 const element = scope.domElement; 502 if (element && scope.object instanceof PerspectiveCamera && scope.object.isPerspectiveCamera) { 503 const position = scope.object.position; 504 offset.copy(position).sub(scope.target); 505 let targetDistance = offset.length(); 506 targetDistance *= Math.tan(scope.object.fov / 2 * Math.PI / 180); 507 panLeft(2 * deltaX * targetDistance / element.clientHeight, scope.object.matrix); 508 panUp(2 * deltaY * targetDistance / element.clientHeight, scope.object.matrix); 509 } else if (element && scope.object instanceof OrthographicCamera && scope.object.isOrthographicCamera) { 510 panLeft( 511 deltaX * (scope.object.right - scope.object.left) / scope.object.zoom / element.clientWidth, 512 scope.object.matrix 513 ); 514 panUp( 515 deltaY * (scope.object.top - scope.object.bottom) / scope.object.zoom / element.clientHeight, 516 scope.object.matrix 517 ); 518 } else { 519 console.warn("WARNING: OrbitControls.js encountered an unknown camera type - pan disabled."); 520 scope.enablePan = false; 521 } 522 }; 523 })(); 524 function setScale(newScale) { 525 if (scope.object instanceof PerspectiveCamera && scope.object.isPerspectiveCamera || scope.object instanceof OrthographicCamera && scope.object.isOrthographicCamera) { 526 scale = newScale; 527 } else { 528 console.warn("WARNING: OrbitControls.js encountered an unknown camera type - dolly/zoom disabled."); 529 scope.enableZoom = false;
530 } 531 } 532 function dollyOut(dollyScale) { 533 setScale(scale / dollyScale); 534 } 535 function dollyIn(dollyScale) { 536 setScale(scale * dollyScale); 537 } 538 function updateMouseParameters(event) { 539 if (!scope.zoomToCursor || !scope.domElement) { 540 return; 541 } 542 performCursorZoom = true; 543 const rect = scope.domElement.getBoundingClientRect(); 544 const x = event.clientX - rect.left; 545 const y = event.clientY - rect.top; 546 const w = rect.width; 547 const h = rect.height; 548 mouse.x = x / w * 2 - 1; 549 mouse.y = -(y / h) * 2 + 1; 550 dollyDirection.set(mouse.x, mouse.y, 1).unproject(scope.object).sub(scope.object.position).normalize(); 551 } 552 function clampDistance(dist) { 553 return Math.max(scope.minDistance, Math.min(scope.maxDistance, dist)); 554 } 555 function handleMouseDownRotate(event) { 556 rotateStart.set(event.clientX, event.clientY); 557 } 558 function handleMouseDownDolly(event) { 559 updateMouseParameters(event); 560 dollyStart.set(event.clientX, event.clientY); 561 } 562 function handleMouseDownPan(event) { 563 panStart.set(event.clientX, event.clientY); 564 } 565 function handleMouseMoveRotate(event) { 566 rotateEnd.set(event.clientX, event.clientY); 567 rotateDelta.subVectors(rotateEnd, rotateStart).multiplyScalar(scope.rotateSpeed); 568 const element = scope.domElement; 569 if (element) { 570 rotateLeft(2 * Math.PI * rotateDelta.x / element.clientHeight); 571 rotateUp(2 * Math.PI * rotateDelta.y / element.clientHeight); 572 } 573 rotateStart.copy(rotateEnd); 574 scope.update(); 575 } 576 function handleMouseMoveDolly(event) { 577 dollyEnd.set(event.clientX, event.clientY); 578 dollyDelta.subVectors(dollyEnd, dollyStart); 579 if (dollyDelta.y > 0) { 580 dollyOut(getZoomScale()); 581 } else if (dollyDelta.y < 0) { 582 dollyIn(getZoomScale()); 583 } 584 dollyStart.copy(dollyEnd); 585 scope.update(); 586 } 587 function handleMouseMovePan(event) { 588 panEnd.set(event.clientX, event.clientY); 589 panDelta.subVectors(panEnd, panStart).multiplyScalar(scope.panSpeed); 590 pan(panDelta.x, panDelta.y); 591 panStart.copy(panEnd); 592 scope.update(); 593 } 594 function handleMouseWheel(event) { 595 updateMouseParameters(event); 596 if (event.deltaY < 0) { 597 dollyIn(getZoomScale()); 598 } else if (event.deltaY > 0) { 599 dollyOut(getZoomScale()); 600 } 601 scope.update(); 602 } 603 function handleKeyDown(event) { 604 let needsUpdate = false; 605 switch (event.code) { 606 case scope.keys.UP: 607 pan(0, scope.keyPanSpeed); 608 needsUpdate = true; 609 break; 610 case scope.keys.BOTTOM: 611 pan(0, -scope.keyPanSpeed); 612 needsUpdate = true; 613 break; 614 case scope.keys.LEFT: 615 pan(scope.keyPanSpeed, 0); 616 needsUpdate = true; 617 break; 618 case scope.keys.RIGHT: 619 pan(-scope.keyPanSpeed, 0); 620 needsUpdate = true; 621 break; 622 } 623 if (needsUpdate) { 624 event.preventDefault(); 625 scope.update(); 626 } 627 } 628 function handleTouchStartRotate() { 629 if (pointers.length == 1) { 630 rotateStart.set(pointers[0].pageX, pointers[0].pageY); 631 } else { 632 const x = 0.5 * (pointers[0].pageX + pointers[1].pageX); 633 const y = 0.5 * (pointers[0].pageY + pointers[1].pageY); 634 rotateStart.set(x, y); 635 } 636 } 637 function handleTouchStartPan() { 638 if (pointers.length == 1) { 639 panStart.set(pointers[0].pageX, pointers[0].pageY); 640 } else { 641 const x = 0.5 * (pointers[0].pageX + pointers[1].pageX); 642 const y = 0.5 * (pointers[0].pageY + pointers[1].pageY); 643 panStart.set(x, y); 644 } 645 } 646 function handleTouchStartDolly() { 647 const dx = pointers[0].pageX - pointers[1].pageX; 648 const dy = pointers[0].pageY - pointers[1].pageY; 649 const distance = Math.sqrt(dx * dx + dy * dy); 650 dollyStart.set(0, distance); 651 } 652 function handleTouchStartDollyPan() { 653 if (scope.enableZoom) 654 handleTouchStartDolly(); 655 if (scope.enablePan) 656 handleTouchStartPan(); 657 } 658 function handleTouchStartDollyRotate() { 659 if (scope.enableZoom) 660 handleTouchStartDolly(); 661 if (scope.enableRotate) 662 handleTouchStartRotate(); 663 } 664 function handleTouchMoveRotate(event) { 665 if (pointers.length == 1) { 666 rotateEnd.set(event.pageX, event.pageY); 667 } else { 668 const position = getSecondPointerPosition(event); 669 const x = 0.5 * (event.pageX + position.x); 670 const y = 0.5 * (event.pageY + position.y); 671 rotateEnd.set(x, y); 672 } 673 rotateDelta.subVectors(rotateEnd, rotateStart).multiplyScalar(scope.rotateSpeed); 674 const element = scope.domElement; 675 if (element) { 676 rotateLeft(2 * Math.PI * rotateDelta.x / element.clientHeight); 677 rotateUp(2 * Math.PI * rotateDelta.y / element.clientHeight); 678 } 679 rotateStart.copy(rotateEnd); 680 } 681 function handleTouchMovePan(event) { 682 if (pointers.length == 1) { 683 panEnd.set(event.pageX, event.pageY); 684 } else { 685 const position = getSecondPointerPosition(event); 686 const x = 0.5 * (event.pageX + position.x); 687 const y = 0.5 * (event.pageY + position.y); 688 panEnd.set(x, y); 689 } 690 panDelta.subVectors(panEnd, panStart).multiplyScalar(scope.panSpeed); 691 pan(panDelta.x, panDelta.y); 692 panStart.copy(panEnd); 693 } 694 function handleTouchMoveDolly(event) { 695 const position = getSecondPointerPosition(event); 696 const dx = event.pageX - position.x; 697 const dy = event.pageY - position.y; 698 const distance = Math.sqrt(dx * dx + dy * dy); 699 dollyEnd.set(0, distance); 700 dollyDelta.set(0, Math.pow(dollyEnd.y / dollyStart.y, scope.zoomSpeed)); 701 dollyOut(dollyDelta.y); 702 dollyStart.copy(dollyEnd); 703 } 704 function handleTouchMoveDollyPan(event) { 705 if (scope.enableZoom) 706 handleTouchMoveDolly(event); 707 if (scope.enablePan) 708 handleTouchMovePan(event); 709 } 710 function handleTouchMoveDollyRotate(event) { 711 if (scope.enableZoom) 712 handleTouchMoveDolly(event); 713 if (scope.enableRotate) 714 handleTouchMoveRotate(event); 715 } 716 function onPointerDown(event) { 717 var _a, _b; 718 if (scope.enabled === false) 719 return; 720 if (pointers.length === 0) { 721 (_a = scope.domElement) == null ? void 0 : _a.ownerDocument.addEventListener("pointermove", onPointerMove); 722 (_b = scope.domElement) == null ? void 0 : _b.ownerDocument.addEventListener("pointerup", onPointerUp); 723 } 724 addPointer(event); 725 if (event.pointerType === "touch") { 726 onTouchStart(event); 727 } else { 728 onMouseDown(event); 729 } 730 } 731 function onPointerMove(event) { 732 if (scope.enabled === false) 733 return; 734 if (event.pointerType === "touch") { 735 onTouchMove(event); 736 } else { 737 onMouseMove(event); 738 } 739 } 740 function onPointerUp(event) { 741 var _a, _b, _c; 742 removePointer(event); 743 if (pointers.length === 0) { 744 (_a = scope.domElement) == null ? void 0 : _a.releasePointerCapture(event.pointerId); 745 (_b = scope.domElement) == null ? void 0 : _b.ownerDocument.removeEventListener("pointermove", onPointerMove); 746 (_c = scope.domElement) == null ? void 0 : _c.ownerDocument.removeEventListener("pointerup", onPointerUp); 747 } 748 scope.dispatchEvent(endEvent); 749 state = STATE.NONE; 750 } 751 function onMouseDown(event) { 752 let mouseAction; 753 switch (event.button) { 754 case 0: 755 mouseAction = scope.mouseButtons.LEFT; 756 break; 757 case 1: 758 mouseAction = scope.mouseButtons.MIDDLE; 759 break; 760 case 2: 761 mouseAction = scope.mouseButtons.RIGHT; 762 break; 763 default: 764 mouseAction = -1; 765 } 766 switch (mouseAction) { 767 case MOUSE.DOLLY: 768 if (scope.enableZoom === false) 769 return; 770 handleMouseDownDolly(event); 771 state = STATE.DOLLY; 772 break; 773 case MOUSE.ROTATE: 774 if (event.ctrlKey || event.metaKey || event.shiftKey) { 775 if (scope.enablePan === false) 776 return; 777 handleMouseDownPan(event); 778 state = STATE.PAN; 779 } else { 780 if (scope.enableRotate === false) 781 return; 782 handleMouseDownRotate(event); 783 state = STATE.ROTATE; 784 } 785 break; 786 case MOUSE.PAN: 787 if (event.ctrlKey || event.metaKey || event.shiftKey) { 788 if (scope.enableRotate === false) 789 return; 790 handleMouseDownRotate(event); 791 state = STATE.ROTATE; 792 } else { 793 if (scope.enablePan === false) 794 return; 795 handleMouseDownPan(event); 796 state = STATE.PAN; 797 } 798 break; 799 default: 800 state = STATE.NONE; 801 } 802 if (state !== STATE.NONE) { 803 scope.dispatchEvent(startEvent); 804 } 805 } 806 function onMouseMove(event) { 807 if (scope.enabled === false) 808 return; 809 switch (state) { 810 case STATE.ROTATE: 811 if (scope.enableRotate === false) 812 return; 813 handleMouseMoveRotate(event); 814 break; 815 case STATE.DOLLY: 816 if (scope.enableZoom === false) 817 return; 818 handleMouseMoveDolly(event); 819 break; 820 case STATE.PAN: 821 if (scope.enablePan === false) 822 return; 823 handleMouseMovePan(event); 824 break; 825 } 826 } 827 function onMouseWheel(event) { 828 if (scope.enabled === false || scope.enableZoom === false || state !== STATE.NONE && state !== STATE.ROTATE) { 829 return; 830 } 831 event.preventDefault(); 832 scope.dispatchEvent(startEvent); 833 handleMouseWheel(event); 834 scope.dispatchEvent(endEvent); 835 } 836 function onKeyDown(event) { 837 if (scope.enabled === false || scope.enablePan === false) 838 return; 839 handleKeyDown(event); 840 } 841 function onTouchStart(event) { 842 trackPointer(event); 843 switch (pointers.length) { 844 case 1: 845 switch (scope.touches.ONE) { 846 case TOUCH.ROTATE: 847 if (scope.enableRotate === false) 848 return; 849 handleTouchStartRotate(); 850 state = STATE.TOUCH_ROTATE; 851 break; 852 case TOUCH.PAN: 853 if (scope.enablePan === false) 854 return; 855 handleTouchStartPan(); 856 state = STATE.TOUCH_PAN; 857 break; 858 default: 859 state = STATE.NONE; 860 } 861 break; 862 case 2: 863 switch (scope.touches.TWO) { 864 case TOUCH.DOLLY_PAN: 865 if (scope.enableZoom === false && scope.enablePan === false) 866 return; 867 handleTouchStartDollyPan(); 868 state = STATE.TOUCH_DOLLY_PAN; 869 break; 870 case TOUCH.DOLLY_ROTATE: 871 if (scope.enableZoom === false && scope.enableRotate === false) 872 return; 873 handleTouchStartDollyRotate(); 874 state = STATE.TOUCH_DOLLY_ROTATE; 875 break; 876 default: 877 state = STATE.NONE; 878 } 879 break; 880 default: 881 state = STATE.NONE; 882 } 883 if (state !== STATE.NONE) { 884 scope.dispatchEvent(startEvent); 885 } 886 } 887 function onTouchMove(event) { 888 trackPointer(event); 889 switch (state) { 890 case STATE.TOUCH_ROTATE: 891 if (scope.enableRotate === false) 892 return; 893 handleTouchMoveRotate(event);
894 scope.update(); 895 break; 896 case STATE.TOUCH_PAN: 897 if (scope.enablePan === false) 898 return; 899 handleTouchMovePan(event); 900 scope.update(); 901 break; 902 case STATE.TOUCH_DOLLY_PAN: 903 if (scope.enableZoom === false && scope.enablePan === false) 904 return; 905 handleTouchMoveDollyPan(event); 906 scope.update(); 907 break; 908 case STATE.TOUCH_DOLLY_ROTATE: 909 if (scope.enableZoom === false && scope.enableRotate === false) 910 return; 911 handleTouchMoveDollyRotate(event); 912 scope.update(); 913 break; 914 default: 915 state = STATE.NONE; 916 } 917 } 918 function onContextMenu(event) { 919 if (scope.enabled === false) 920 return; 921 event.preventDefault(); 922 } 923 function addPointer(event) { 924 pointers.push(event); 925 } 926 function removePointer(event) { 927 delete pointerPositions[event.pointerId]; 928 for (let i2 = 0; i2 < pointers.length; i2++) { 929 if (pointers[i2].pointerId == event.pointerId) { 930 pointers.splice(i2, 1); 931 return; 932 } 933 } 934 } 935 function trackPointer(event) { 936 let position = pointerPositions[event.pointerId]; 937 if (position === void 0) { 938 position = new Vector2(); 939 pointerPositions[event.pointerId] = position; 940 } 941 position.set(event.pageX, event.pageY); 942 } 943 function getSecondPointerPosition(event) { 944 const pointer = event.pointerId === pointers[0].pointerId ? pointers[1] : pointers[0]; 945 return pointerPositions[pointer.pointerId]; 946 } 947 this.dollyIn = (dollyScale = getZoomScale()) => { 948 dollyIn(dollyScale); 949 scope.update(); 950 }; 951 this.dollyOut = (dollyScale = getZoomScale()) => { 952 dollyOut(dollyScale); 953 scope.update(); 954 }; 955 this.getScale = () => { 956 return scale; 957 }; 958 this.setScale = (newScale) => { 959 setScale(newScale); 960 scope.update(); 961 }; 962 this.getZoomScale = () => { 963 return getZoomScale(); 964 }; 965 if (domElement !== void 0) 966 this.connect(domElement); 967 this.update(); 968 } 969}; 970function createStore$1(createState) { 971 let state; 972 const listeners = /* @__PURE__ */ new Set(); 973 const setState = (partial, replace) => { 974 const nextState = typeof partial === "function" ? partial(state) : partial; 975 if (nextState !== state) { 976 const previousState = state; 977 state = replace ? nextState : Object.assign({}, state, nextState); 978 listeners.forEach((listener) => listener(state, previousState)); 979 } 980 }; 981 const getState = () => state; 982 const subscribeWithSelector = (listener, selector = getState, equalityFn = Object.is) => { 983 console.warn("[DEPRECATED] Please use `subscribeWithSelector` middleware"); 984 let currentSlice = selector(state); 985 function listenerToAdd() { 986 const nextSlice = selector(state); 987 if (!equalityFn(currentSlice, nextSlice)) { 988 const previousSlice = currentSlice; 989 listener(currentSlice = nextSlice, previousSlice); 990 } 991 } 992 listeners.add(listenerToAdd); 993 return () => listeners.delete(listenerToAdd); 994 }; 995 const subscribe = (listener, selector, equalityFn) => { 996 if (selector || equalityFn) { 997 return subscribeWithSelector(listener, selector, equalityFn); 998 } 999 listeners.add(listener); 1000 return () => listeners.delete(listener); 1001 }; 1002 const destroy = () => listeners.clear(); 1003 const api = { setState, getState, subscribe, destroy }; 1004 state = createState(setState, getState, api); 1005 return api; 1006} 1007const isSSR = typeof window === "undefined" || !window.navigator || /ServerSideRendering|^Deno\//.test(window.navigator.userAgent); 1008const useIsomorphicLayoutEffect$1 = isSSR ? reactExports.useEffect : reactExports.useLayoutEffect; 1009function create(createState) { 1010 const api = typeof createState === "function" ? createStore$1(createState) : createState; 1011 const useStore2 = (selector = api.getState, equalityFn = Object.is) => { 1012 const [, forceUpdate] = reactExports.useReducer((c) => c + 1, 0); 1013 const state = api.getState(); 1014 const stateRef = reactExports.useRef(state); 1015 const selectorRef = reactExports.useRef(selector); 1016 const equalityFnRef = reactExports.useRef(equalityFn); 1017 const erroredRef = reactExports.useRef(false); 1018 const currentSliceRef = reactExports.useRef(); 1019 if (currentSliceRef.current === void 0) { 1020 currentSliceRef.current = selector(state); 1021 } 1022 let newStateSlice; 1023 let hasNewStateSlice = false;
vendor: 9,929 bytes, lines 1024-1363
1024 if (stateRef.current !== state || selectorRef.current !== selector || equalityFnRef.current !== equalityFn || erroredRef.current) { 1025 newStateSlice = selector(state); 1026 hasNewStateSlice = !equalityFn(currentSliceRef.current, newStateSlice); 1027 } 1028 useIsomorphicLayoutEffect$1(() => { 1029 if (hasNewStateSlice) { 1030 currentSliceRef.current = newStateSlice; 1031 } 1032 stateRef.current = state; 1033 selectorRef.current = selector; 1034 equalityFnRef.current = equalityFn; 1035 erroredRef.current = false; 1036 }); 1037 const stateBeforeSubscriptionRef = reactExports.useRef(state); 1038 useIsomorphicLayoutEffect$1(() => { 1039 const listener = () => { 1040 try { 1041 const nextState = api.getState(); 1042 const nextStateSlice = selectorRef.current(nextState); 1043 if (!equalityFnRef.current(currentSliceRef.current, nextStateSlice)) { 1044 stateRef.current = nextState; 1045 currentSliceRef.current = nextStateSlice; 1046 forceUpdate(); 1047 } 1048 } catch (error) { 1049 erroredRef.current = true; 1050 forceUpdate(); 1051 } 1052 }; 1053 const unsubscribe = api.subscribe(listener); 1054 if (api.getState() !== stateBeforeSubscriptionRef.current) { 1055 listener(); 1056 } 1057 return unsubscribe; 1058 }, []); 1059 const sliceToReturn = hasNewStateSlice ? newStateSlice : currentSliceRef.current; 1060 reactExports.useDebugValue(sliceToReturn); 1061 return sliceToReturn; 1062 }; 1063 Object.assign(useStore2, api); 1064 useStore2[Symbol.iterator] = function() { 1065 console.warn("[useStore, api] = create() is deprecated and will be removed in v4"); 1066 const items = [useStore2, api]; 1067 return { 1068 next() { 1069 const done = items.length <= 0; 1070 return { value: items.shift(), done }; 1071 } 1072 }; 1073 }; 1074 return useStore2; 1075} 1076var scheduler = { exports: {} }; 1077var scheduler_production_min = {}; 1078/** 1079 * @license React 1080 * scheduler.production.min.js 1081 * 1082 * Copyright (c) Facebook, Inc. and its affiliates. 1083 * 1084 * This source code is licensed under the MIT license found in the 1085 * LICENSE file in the root directory of this source tree. 1086 */ 1087(function(exports$1) { 1088 function f(a, b) { 1089 var c = a.length; 1090 a.push(b); 1091 a: for (; 0 < c; ) { 1092 var d = c - 1 >>> 1, e = a[d]; 1093 if (0 < g(e, b)) a[d] = b, a[c] = e, c = d; 1094 else break a; 1095 } 1096 } 1097 function h(a) { 1098 return 0 === a.length ? null : a[0]; 1099 } 1100 function k(a) { 1101 if (0 === a.length) return null; 1102 var b = a[0], c = a.pop(); 1103 if (c !== b) { 1104 a[0] = c; 1105 a: for (var d = 0, e = a.length, w = e >>> 1; d < w; ) { 1106 var m = 2 * (d + 1) - 1, C = a[m], n = m + 1, x = a[n]; 1107 if (0 > g(C, c)) n < e && 0 > g(x, C) ? (a[d] = x, a[n] = c, d = n) : (a[d] = C, a[m] = c, d = m); 1108 else if (n < e && 0 > g(x, c)) a[d] = x, a[n] = c, d = n; 1109 else break a; 1110 } 1111 } 1112 return b; 1113 } 1114 function g(a, b) { 1115 var c = a.sortIndex - b.sortIndex; 1116 return 0 !== c ? c : a.id - b.id; 1117 } 1118 if ("object" === typeof performance && "function" === typeof performance.now) { 1119 var l = performance; 1120 exports$1.unstable_now = function() { 1121 return l.now(); 1122 }; 1123 } else { 1124 var p = Date, q = p.now(); 1125 exports$1.unstable_now = function() { 1126 return p.now() - q; 1127 }; 1128 } 1129 var r = [], t = [], u = 1, v = null, y = 3, z = false, A = false, B = false, D = "function" === typeof setTimeout ? setTimeout : null, E = "function" === typeof clearTimeout ? clearTimeout : null, F = "undefined" !== typeof setImmediate ? setImmediate : null; 1130 "undefined" !== typeof navigator && void 0 !== navigator.scheduling && void 0 !== navigator.scheduling.isInputPending && navigator.scheduling.isInputPending.bind(navigator.scheduling); 1131 function G(a) { 1132 for (var b = h(t); null !== b; ) { 1133 if (null === b.callback) k(t); 1134 else if (b.startTime <= a) k(t), b.sortIndex = b.expirationTime, f(r, b); 1135 else break; 1136 b = h(t); 1137 } 1138 } 1139 function H(a) { 1140 B = false; 1141 G(a); 1142 if (!A) if (null !== h(r)) A = true, I(J); 1143 else { 1144 var b = h(t); 1145 null !== b && K(H, b.startTime - a); 1146 } 1147 } 1148 function J(a, b) { 1149 A = false; 1150 B && (B = false, E(L), L = -1); 1151 z = true; 1152 var c = y; 1153 try { 1154 G(b); 1155 for (v = h(r); null !== v && (!(v.expirationTime > b) || a && !M()); ) { 1156 var d = v.callback; 1157 if ("function" === typeof d) { 1158 v.callback = null; 1159 y = v.priorityLevel; 1160 var e = d(v.expirationTime <= b); 1161 b = exports$1.unstable_now(); 1162 "function" === typeof e ? v.callback = e : v === h(r) && k(r); 1163 G(b); 1164 } else k(r); 1165 v = h(r); 1166 } 1167 if (null !== v) var w = true; 1168 else { 1169 var m = h(t); 1170 null !== m && K(H, m.startTime - b); 1171 w = false; 1172 } 1173 return w; 1174 } finally { 1175 v = null, y = c, z = false; 1176 } 1177 } 1178 var N = false, O = null, L = -1, P = 5, Q = -1; 1179 function M() { 1180 return exports$1.unstable_now() - Q < P ? false : true; 1181 } 1182 function R() { 1183 if (null !== O) { 1184 var a = exports$1.unstable_now(); 1185 Q = a; 1186 var b = true; 1187 try { 1188 b = O(true, a); 1189 } finally { 1190 b ? S() : (N = false, O = null); 1191 } 1192 } else N = false; 1193 } 1194 var S; 1195 if ("function" === typeof F) S = function() { 1196 F(R); 1197 }; 1198 else if ("undefined" !== typeof MessageChannel) { 1199 var T = new MessageChannel(), U = T.port2; 1200 T.port1.onmessage = R; 1201 S = function() { 1202 U.postMessage(null); 1203 }; 1204 } else S = function() { 1205 D(R, 0); 1206 }; 1207 function I(a) { 1208 O = a; 1209 N || (N = true, S()); 1210 } 1211 function K(a, b) { 1212 L = D(function() { 1213 a(exports$1.unstable_now()); 1214 }, b); 1215 } 1216 exports$1.unstable_IdlePriority = 5; 1217 exports$1.unstable_ImmediatePriority = 1; 1218 exports$1.unstable_LowPriority = 4; 1219 exports$1.unstable_NormalPriority = 3; 1220 exports$1.unstable_Profiling = null; 1221 exports$1.unstable_UserBlockingPriority = 2; 1222 exports$1.unstable_cancelCallback = function(a) { 1223 a.callback = null; 1224 }; 1225 exports$1.unstable_continueExecution = function() { 1226 A || z || (A = true, I(J)); 1227 }; 1228 exports$1.unstable_forceFrameRate = function(a) { 1229 0 > a || 125 < a ? console.error("forceFrameRate takes a positive int between 0 and 125, forcing frame rates higher than 125 fps is not supported") : P = 0 < a ? Math.floor(1e3 / a) : 5; 1230 }; 1231 exports$1.unstable_getCurrentPriorityLevel = function() { 1232 return y; 1233 }; 1234 exports$1.unstable_getFirstCallbackNode = function() { 1235 return h(r); 1236 }; 1237 exports$1.unstable_next = function(a) { 1238 switch (y) { 1239 case 1: 1240 case 2: 1241 case 3: 1242 var b = 3; 1243 break; 1244 default: 1245 b = y; 1246 } 1247 var c = y; 1248 y = b; 1249 try { 1250 return a(); 1251 } finally { 1252 y = c; 1253 } 1254 }; 1255 exports$1.unstable_pauseExecution = function() { 1256 }; 1257 exports$1.unstable_requestPaint = function() { 1258 }; 1259 exports$1.unstable_runWithPriority = function(a, b) { 1260 switch (a) { 1261 case 1: 1262 case 2: 1263 case 3: 1264 case 4: 1265 case 5: 1266 break; 1267 default: 1268 a = 3; 1269 } 1270 var c = y; 1271 y = a; 1272 try { 1273 return b(); 1274 } finally { 1275 y = c; 1276 } 1277 }; 1278 exports$1.unstable_scheduleCallback = function(a, b, c) { 1279 var d = exports$1.unstable_now(); 1280 "object" === typeof c && null !== c ? (c = c.delay, c = "number" === typeof c && 0 < c ? d + c : d) : c = d; 1281 switch (a) { 1282 case 1: 1283 var e = -1; 1284 break; 1285 case 2: 1286 e = 250; 1287 break; 1288 case 5: 1289 e = 1073741823; 1290 break; 1291 case 4: 1292 e = 1e4; 1293 break; 1294 default: 1295 e = 5e3; 1296 } 1297 e = c + e; 1298 a = { id: u++, callback: b, priorityLevel: a, startTime: c, expirationTime: e, sortIndex: -1 }; 1299 c > d ? (a.sortIndex = c, f(t, a), null === h(r) && a === h(t) && (B ? (E(L), L = -1) : B = true, K(H, c - d))) : (a.sortIndex = e, f(r, a), A || z || (A = true, I(J))); 1300 return a; 1301 }; 1302 exports$1.unstable_shouldYield = M; 1303 exports$1.unstable_wrapCallback = function(a) { 1304 var b = y; 1305 return function() { 1306 var c = y; 1307 y = b; 1308 try { 1309 return a.apply(this, arguments); 1310 } finally { 1311 y = c; 1312 } 1313 }; 1314 }; 1315})(scheduler_production_min); 1316{ 1317 scheduler.exports = scheduler_production_min; 1318} 1319var schedulerExports = scheduler.exports; 1320const catalogue = {}; 1321const extend = (objects) => void Object.assign(catalogue, objects); 1322function createRenderer(_roots, _getEventPriority) { 1323 function createInstance(type, { 1324 args = [], 1325 attach: attach2, 1326 ...props 1327 }, root) { 1328 let name = `${type[0].toUpperCase()}${type.slice(1)}`; 1329 let instance; 1330 if (type === "primitive") { 1331 if (props.object === void 0) throw new Error("R3F: Primitives without 'object' are invalid!"); 1332 const object = props.object; 1333 instance = prepare(object, { 1334 type, 1335 root, 1336 attach: attach2, 1337 primitive: true 1338 }); 1339 } else { 1340 const target = catalogue[name]; 1341 if (!target) { 1342 throw new Error(`R3F: ${name} is not part of the THREE namespace! Did you forget to extend? See: https://docs.pmnd.rs/react-three-fiber/api/objects#using-3rd-party-objects-declaratively`); 1343 } 1344 if (!Array.isArray(args)) throw new Error("R3F: The args prop must be an array!"); 1345 instance = prepare(new target(...args), { 1346 type, 1347 root, 1348 attach: attach2, 1349 // Save args in case we need to reconstruct later for HMR 1350 memoizedProps: { 1351 args 1352 } 1353 }); 1354 } 1355 if (instance.__r3f.attach === void 0) { 1356 if (instance.isBufferGeometry) instance.__r3f.attach = "geometry"; 1357 else if (instance.isMaterial) instance.__r3f.attach = "material"; 1358 } 1359 if (name !== "inject") applyProps$1(instance, props); 1360 return instance; 1361 } 1362 function appendChild(parentInstance, child) { 1363 let added = false;
1364 if (child) { 1365 var _child$__r3f, _parentInstance$__r3f; 1366 if ((_child$__r3f = child.__r3f) != null && _child$__r3f.attach) { 1367 attach(parentInstance, child, child.__r3f.attach); 1368 } else if (child.isObject3D && parentInstance.isObject3D) { 1369 parentInstance.add(child); 1370 added = true; 1371 } 1372 if (!added) (_parentInstance$__r3f = parentInstance.__r3f) == null ? void 0 : _parentInstance$__r3f.objects.push(child); 1373 if (!child.__r3f) prepare(child, {}); 1374 child.__r3f.parent = parentInstance; 1375 updateInstance(child); 1376 invalidateInstance(child); 1377 } 1378 } 1379 function insertBefore(parentInstance, child, beforeChild) { 1380 let added = false; 1381 if (child) { 1382 var _child$__r3f2, _parentInstance$__r3f2; 1383 if ((_child$__r3f2 = child.__r3f) != null && _child$__r3f2.attach) { 1384 attach(parentInstance, child, child.__r3f.attach); 1385 } else if (child.isObject3D && parentInstance.isObject3D) { 1386 child.parent = parentInstance; 1387 child.dispatchEvent({ 1388 type: "added" 1389 }); 1390 parentInstance.dispatchEvent({ 1391 type: "childadded", 1392 child 1393 }); 1394 const restSiblings = parentInstance.children.filter((sibling) => sibling !== child); 1395 const index = restSiblings.indexOf(beforeChild); 1396 parentInstance.children = [...restSiblings.slice(0, index), child, ...restSiblings.slice(index)]; 1397 added = true; 1398 } 1399 if (!added) (_parentInstance$__r3f2 = parentInstance.__r3f) == null ? void 0 : _parentInstance$__r3f2.objects.push(child); 1400 if (!child.__r3f) prepare(child, {}); 1401 child.__r3f.parent = parentInstance; 1402 updateInstance(child); 1403 invalidateInstance(child); 1404 } 1405 } 1406 function removeRecursive(array, parent, dispose2 = false) { 1407 if (array) [...array].forEach((child) => removeChild(parent, child, dispose2)); 1408 } 1409 function removeChild(parentInstance, child, dispose2) { 1410 if (child) { 1411 var _parentInstance$__r3f3, _child$__r3f3, _child$__r3f5; 1412 if (child.__r3f) child.__r3f.parent = null; 1413 if ((_parentInstance$__r3f3 = parentInstance.__r3f) != null && _parentInstance$__r3f3.objects) parentInstance.__r3f.objects = parentInstance.__r3f.objects.filter((x) => x !== child); 1414 if ((_child$__r3f3 = child.__r3f) != null && _child$__r3f3.attach) { 1415 detach(parentInstance, child, child.__r3f.attach); 1416 } else if (child.isObject3D && parentInstance.isObject3D) { 1417 var _child$__r3f4; 1418 parentInstance.remove(child); 1419 if ((_child$__r3f4 = child.__r3f) != null && _child$__r3f4.root) { 1420 removeInteractivity(findInitialRoot(child), child); 1421 } 1422 } 1423 const isPrimitive = (_child$__r3f5 = child.__r3f) == null ? void 0 : _child$__r3f5.primitive; 1424 const shouldDispose = !isPrimitive && (dispose2 === void 0 ? child.dispose !== null : dispose2); 1425 if (!isPrimitive) { 1426 var _child$__r3f6; 1427 removeRecursive((_child$__r3f6 = child.__r3f) == null ? void 0 : _child$__r3f6.objects, child, shouldDispose); 1428 removeRecursive(child.children, child, shouldDispose); 1429 } 1430 delete child.__r3f; 1431 if (shouldDispose && child.dispose && child.type !== "Scene") { 1432 const callback = () => { 1433 try { 1434 child.dispose(); 1435 } catch (e) { 1436 } 1437 }; 1438 if (typeof IS_REACT_ACT_ENVIRONMENT === "undefined") { 1439 schedulerExports.unstable_scheduleCallback(schedulerExports.unstable_IdlePriority, callback); 1440 } else { 1441 callback(); 1442 } 1443 } 1444 invalidateInstance(parentInstance); 1445 } 1446 } 1447 function switchInstance(instance, type, newProps, fiber) { 1448 var _instance$__r3f; 1449 const parent = (_instance$__r3f = instance.__r3f) == null ? void 0 : _instance$__r3f.parent; 1450 if (!parent) return; 1451 const newInstance = createInstance(type, newProps, instance.__r3f.root); 1452 if (instance.children) { 1453 for (const child of instance.children) { 1454 if (child.__r3f) appendChild(newInstance, child); 1455 } 1456 instance.children = instance.children.filter((child) => !child.__r3f); 1457 }
1458 instance.__r3f.objects.forEach((child) => appendChild(newInstance, child)); 1459 instance.__r3f.objects = []; 1460 if (!instance.__r3f.autoRemovedBeforeAppend) { 1461 removeChild(parent, instance); 1462 } 1463 if (newInstance.parent) { 1464 newInstance.__r3f.autoRemovedBeforeAppend = true; 1465 } 1466 appendChild(parent, newInstance); 1467 if (newInstance.raycast && newInstance.__r3f.eventCount) { 1468 const rootState = findInitialRoot(newInstance).getState(); 1469 rootState.internal.interaction.push(newInstance); 1470 } 1471 [fiber, fiber.alternate].forEach((fiber2) => { 1472 if (fiber2 !== null) { 1473 fiber2.stateNode = newInstance; 1474 if (fiber2.ref) { 1475 if (typeof fiber2.ref === "function") fiber2.ref(newInstance); 1476 else fiber2.ref.current = newInstance; 1477 } 1478 } 1479 }); 1480 } 1481 const handleTextInstance = () => { 1482 }; 1483 const reconciler2 = Reconciler({ 1484 createInstance, 1485 removeChild, 1486 appendChild, 1487 appendInitialChild: appendChild, 1488 insertBefore, 1489 supportsMutation: true, 1490 isPrimaryRenderer: false, 1491 supportsPersistence: false, 1492 supportsHydration: false, 1493 noTimeout: -1, 1494 appendChildToContainer: (container, child) => { 1495 if (!child) return; 1496 const scene = container.getState().scene; 1497 if (!scene.__r3f) return; 1498 scene.__r3f.root = container; 1499 appendChild(scene, child); 1500 }, 1501 removeChildFromContainer: (container, child) => { 1502 if (!child) return; 1503 removeChild(container.getState().scene, child); 1504 }, 1505 insertInContainerBefore: (container, child, beforeChild) => { 1506 if (!child || !beforeChild) return; 1507 const scene = container.getState().scene; 1508 if (!scene.__r3f) return; 1509 insertBefore(scene, child, beforeChild); 1510 }, 1511 getRootHostContext: () => null, 1512 getChildHostContext: (parentHostContext) => parentHostContext, 1513 finalizeInitialChildren(instance) { 1514 var _instance$__r3f2; 1515 const localState = (_instance$__r3f2 = instance == null ? void 0 : instance.__r3f) != null ? _instance$__r3f2 : {}; 1516 return Boolean(localState.handlers); 1517 }, 1518 prepareUpdate(instance, _type, oldProps, newProps) { 1519 var _instance$__r3f3; 1520 const localState = (_instance$__r3f3 = instance == null ? void 0 : instance.__r3f) != null ? _instance$__r3f3 : {}; 1521 if (localState.primitive && newProps.object && newProps.object !== instance) { 1522 return [true]; 1523 } else { 1524 const { 1525 args: argsNew = [], 1526 children: cN, 1527 ...restNew 1528 } = newProps; 1529 const { 1530 args: argsOld = [], 1531 children: cO, 1532 ...restOld 1533 } = oldProps; 1534 if (!Array.isArray(argsNew)) throw new Error("R3F: the args prop must be an array!"); 1535 if (argsNew.some((value, index) => value !== argsOld[index])) return [true]; 1536 const diff = diffProps(instance, restNew, restOld, true); 1537 if (diff.changes.length) return [false, diff]; 1538 return null; 1539 } 1540 }, 1541 commitUpdate(instance, [reconstruct, diff], type, _oldProps, newProps, fiber) { 1542 if (reconstruct) switchInstance(instance, type, newProps, fiber); 1543 else applyProps$1(instance, diff); 1544 }, 1545 commitMount(instance, _type, _props, _int) { 1546 var _instance$__r3f4; 1547 const localState = (_instance$__r3f4 = instance.__r3f) != null ? _instance$__r3f4 : {}; 1548 if (instance.raycast && localState.handlers && localState.eventCount) { 1549 findInitialRoot(instance).getState().internal.interaction.push(instance); 1550 } 1551 }, 1552 getPublicInstance: (instance) => instance, 1553 prepareForCommit: () => null, 1554 preparePortalMount: (container) => prepare(container.getState().scene), 1555 resetAfterCommit: () => { 1556 }, 1557 shouldSetTextContent: () => false, 1558 clearContainer: () => false, 1559 hideInstance(instance) { 1560 var _instance$__r3f5; 1561 const { 1562 attach: type, 1563 parent 1564 } = (_instance$__r3f5 = instance.__r3f) != null ? _instance$__r3f5 : {}; 1565 if (type && parent) detach(parent, instance, type); 1566 if (instance.isObject3D) instance.visible = false;
1567 invalidateInstance(instance); 1568 }, 1569 unhideInstance(instance, props) { 1570 var _instance$__r3f6; 1571 const { 1572 attach: type, 1573 parent 1574 } = (_instance$__r3f6 = instance.__r3f) != null ? _instance$__r3f6 : {}; 1575 if (type && parent) attach(parent, instance, type); 1576 if (instance.isObject3D && props.visible == null || props.visible) instance.visible = true; 1577 invalidateInstance(instance); 1578 }, 1579 createTextInstance: handleTextInstance, 1580 hideTextInstance: handleTextInstance, 1581 unhideTextInstance: handleTextInstance, 1582 // https://github.com/pmndrs/react-three-fiber/pull/2360#discussion_r916356874 1583 // @ts-expect-error 1584 getCurrentEventPriority: () => _getEventPriority ? _getEventPriority() : constantsExports.DefaultEventPriority, 1585 beforeActiveInstanceBlur: () => { 1586 }, 1587 afterActiveInstanceBlur: () => { 1588 }, 1589 detachDeletedInstance: () => { 1590 }, 1591 now: typeof performance !== "undefined" && is.fun(performance.now) ? performance.now : is.fun(Date.now) ? Date.now : () => 0, 1592 // https://github.com/pmndrs/react-three-fiber/pull/2360#discussion_r920883503 1593 scheduleTimeout: is.fun(setTimeout) ? setTimeout : void 0, 1594 cancelTimeout: is.fun(clearTimeout) ? clearTimeout : void 0 1595 }); 1596 return { 1597 reconciler: reconciler2, 1598 applyProps: applyProps$1 1599 }; 1600} 1601var _window$document, _window$navigator; 1602const hasColorSpace = (object) => "colorSpace" in object || "outputColorSpace" in object; 1603const getColorManagement = () => { 1604 var _ColorManagement; 1605 return (_ColorManagement = catalogue.ColorManagement) != null ? _ColorManagement : null; 1606}; 1607const isOrthographicCamera = (def) => def && def.isOrthographicCamera; 1608const isRef = (obj) => obj && obj.hasOwnProperty("current"); 1609const useIsomorphicLayoutEffect = typeof window !== "undefined" && ((_window$document = window.document) != null && _window$document.createElement || ((_window$navigator = window.navigator) == null ? void 0 : _window$navigator.product) === "ReactNative") ? reactExports.useLayoutEffect : reactExports.useEffect; 1610function useMutableCallback(fn) { 1611 const ref = reactExports.useRef(fn); 1612 useIsomorphicLayoutEffect(() => void (ref.current = fn), [fn]); 1613 return ref; 1614} 1615function Block({ 1616 set 1617}) { 1618 useIsomorphicLayoutEffect(() => { 1619 set(new Promise(() => null)); 1620 return () => set(false); 1621 }, [set]); 1622 return null; 1623} 1624class ErrorBoundary extends reactExports.Component { 1625 constructor(...args) { 1626 super(...args); 1627 this.state = { 1628 error: false 1629 }; 1630 } 1631 componentDidCatch(err) { 1632 this.props.set(err); 1633 } 1634 render() { 1635 return this.state.error ? null : this.props.children; 1636 } 1637} 1638ErrorBoundary.getDerivedStateFromError = () => ({ 1639 error: true 1640}); 1641const DEFAULT = "__default"; 1642const DEFAULTS = /* @__PURE__ */ new Map(); 1643const isDiffSet = (def) => def && !!def.memoized && !!def.changes; 1644function calculateDpr(dpr) { 1645 var _window$devicePixelRa; 1646 const target = typeof window !== "undefined" ? (_window$devicePixelRa = window.devicePixelRatio) != null ? _window$devicePixelRa : 2 : 1; 1647 return Array.isArray(dpr) ? Math.min(Math.max(dpr[0], target), dpr[1]) : dpr; 1648} 1649const getRootState = (obj) => { 1650 var _r3f; 1651 return (_r3f = obj.__r3f) == null ? void 0 : _r3f.root.getState(); 1652}; 1653function findInitialRoot(child) { 1654 let root = child.__r3f.root; 1655 while (root.getState().previousRoot) root = root.getState().previousRoot; 1656 return root; 1657} 1658const is = { 1659 obj: (a) => a === Object(a) && !is.arr(a) && typeof a !== "function", 1660 fun: (a) => typeof a === "function", 1661 str: (a) => typeof a === "string", 1662 num: (a) => typeof a === "number", 1663 boo: (a) => typeof a === "boolean", 1664 und: (a) => a === void 0, 1665 arr: (a) => Array.isArray(a), 1666 equ(a, b, { 1667 arrays = "shallow", 1668 objects = "reference", 1669 strict = true 1670 } = {}) { 1671 if (typeof a !== typeof b || !!a !== !!b) return false; 1672 if (is.str(a) || is.num(a) || is.boo(a)) return a === b; 1673 const isObj = is.obj(a); 1674 if (isObj && objects === "reference") return a === b; 1675 const isArr = is.arr(a); 1676 if (isArr && arrays === "reference") return a === b; 1677 if ((isArr || isObj) && a === b) return true; 1678 let i2; 1679 for (i2 in a) if (!(i2 in b)) return false;
1680 if (isObj && arrays === "shallow" && objects === "shallow") { 1681 for (i2 in strict ? b : a) if (!is.equ(a[i2], b[i2], { 1682 strict, 1683 objects: "reference" 1684 })) return false; 1685 } else { 1686 for (i2 in strict ? b : a) if (a[i2] !== b[i2]) return false; 1687 } 1688 if (is.und(i2)) { 1689 if (isArr && a.length === 0 && b.length === 0) return true; 1690 if (isObj && Object.keys(a).length === 0 && Object.keys(b).length === 0) return true; 1691 if (a !== b) return false; 1692 } 1693 return true; 1694 } 1695}; 1696function dispose(obj) { 1697 if (obj.dispose && obj.type !== "Scene") obj.dispose(); 1698 for (const p in obj) { 1699 p.dispose == null ? void 0 : p.dispose(); 1700 delete obj[p]; 1701 } 1702} 1703function prepare(object, state) { 1704 const instance = object; 1705 instance.__r3f = { 1706 type: "", 1707 root: null, 1708 previousAttach: null, 1709 memoizedProps: {}, 1710 eventCount: 0, 1711 handlers: {}, 1712 objects: [], 1713 parent: null, 1714 ...state 1715 }; 1716 return object; 1717} 1718function resolve(instance, key) { 1719 let target = instance; 1720 if (key.includes("-")) { 1721 const entries = key.split("-"); 1722 const last = entries.pop(); 1723 target = entries.reduce((acc, key2) => acc[key2], instance); 1724 return { 1725 target, 1726 key: last 1727 }; 1728 } else return { 1729 target, 1730 key 1731 }; 1732} 1733const INDEX_REGEX = /-\d+$/; 1734function attach(parent, child, type) { 1735 if (is.str(type)) { 1736 if (INDEX_REGEX.test(type)) { 1737 const root = type.replace(INDEX_REGEX, ""); 1738 const { 1739 target: target2, 1740 key: key2 1741 } = resolve(parent, root); 1742 if (!Array.isArray(target2[key2])) target2[key2] = []; 1743 } 1744 const { 1745 target, 1746 key 1747 } = resolve(parent, type); 1748 child.__r3f.previousAttach = target[key]; 1749 target[key] = child; 1750 } else child.__r3f.previousAttach = type(parent, child); 1751} 1752function detach(parent, child, type) { 1753 var _child$__r3f, _child$__r3f2; 1754 if (is.str(type)) { 1755 const { 1756 target, 1757 key 1758 } = resolve(parent, type); 1759 const previous = child.__r3f.previousAttach; 1760 if (previous === void 0) delete target[key]; 1761 else target[key] = previous; 1762 } else (_child$__r3f = child.__r3f) == null ? void 0 : _child$__r3f.previousAttach == null ? void 0 : _child$__r3f.previousAttach(parent, child); 1763 (_child$__r3f2 = child.__r3f) == null ? true : delete _child$__r3f2.previousAttach; 1764} 1765function diffProps(instance, { 1766 children: cN, 1767 key: kN, 1768 ref: rN, 1769 ...props 1770}, { 1771 children: cP, 1772 key: kP, 1773 ref: rP, 1774 ...previous 1775} = {}, remove = false) { 1776 const localState = instance.__r3f; 1777 const entries = Object.entries(props); 1778 const changes = []; 1779 if (remove) { 1780 const previousKeys = Object.keys(previous); 1781 for (let i2 = 0; i2 < previousKeys.length; i2++) { 1782 if (!props.hasOwnProperty(previousKeys[i2])) entries.unshift([previousKeys[i2], DEFAULT + "remove"]); 1783 } 1784 } 1785 entries.forEach(([key, value]) => { 1786 var _instance$__r3f; 1787 if ((_instance$__r3f = instance.__r3f) != null && _instance$__r3f.primitive && key === "object") return; 1788 if (is.equ(value, previous[key])) return; 1789 if (/^on(Pointer|Click|DoubleClick|ContextMenu|Wheel)/.test(key)) return changes.push([key, value, true, []]); 1790 let entries2 = []; 1791 if (key.includes("-")) entries2 = key.split("-"); 1792 changes.push([key, value, false, entries2]); 1793 for (const prop in props) { 1794 const value2 = props[prop]; 1795 if (prop.startsWith(`${key}-`)) changes.push([prop, value2, false, prop.split("-")]); 1796 } 1797 }); 1798 const memoized = { 1799 ...props 1800 }; 1801 if (localState != null && localState.memoizedProps && localState != null && localState.memoizedProps.args) memoized.args = localState.memoizedProps.args; 1802 if (localState != null && localState.memoizedProps && localState != null && localState.memoizedProps.attach) memoized.attach = localState.memoizedProps.attach; 1803 return { 1804 memoized, 1805 changes 1806 }; 1807} 1808function applyProps$1(instance, data) { 1809 var _instance$__r3f2; 1810 const localState = instance.__r3f; 1811 const root = localState == null ? void 0 : localState.root; 1812 const rootState = root == null ? void 0 : root.getState == null ? void 0 : root.getState(); 1813 const { 1814 memoized, 1815 changes 1816 } = isDiffSet(data) ? data : diffProps(instance, data); 1817 const prevHandlers = localState == null ? void 0 : localState.eventCount; 1818 if (instance.__r3f) instance.__r3f.memoizedProps = memoized; 1819 for (let i2 = 0; i2 < changes.length; i2++) { 1820 let [key, value, isEvent, keys] = changes[i2]; 1821 if (hasColorSpace(instance)) { 1822 const sRGBEncoding = 3001; 1823 const SRGBColorSpace = "srgb"; 1824 const LinearSRGBColorSpace = "srgb-linear"; 1825 if (key === "encoding") { 1826 key = "colorSpace"; 1827 value = value === sRGBEncoding ? SRGBColorSpace : LinearSRGBColorSpace; 1828 } else if (key === "outputEncoding") { 1829 key = "outputColorSpace"; 1830 value = value === sRGBEncoding ? SRGBColorSpace : LinearSRGBColorSpace; 1831 } 1832 }
1833 let currentInstance = instance; 1834 let targetProp = currentInstance[key]; 1835 if (keys.length) { 1836 targetProp = keys.reduce((acc, key2) => acc[key2], instance); 1837 if (!(targetProp && targetProp.set)) { 1838 const [name, ...reverseEntries] = keys.reverse(); 1839 currentInstance = reverseEntries.reverse().reduce((acc, key2) => acc[key2], instance); 1840 key = name; 1841 } 1842 } 1843 if (value === DEFAULT + "remove") { 1844 if (currentInstance.constructor) { 1845 let ctor = DEFAULTS.get(currentInstance.constructor); 1846 if (!ctor) { 1847 ctor = new currentInstance.constructor(); 1848 DEFAULTS.set(currentInstance.constructor, ctor); 1849 } 1850 value = ctor[key]; 1851 } else { 1852 value = 0; 1853 } 1854 } 1855 if (isEvent && localState) { 1856 if (value) localState.handlers[key] = value; 1857 else delete localState.handlers[key]; 1858 localState.eventCount = Object.keys(localState.handlers).length; 1859 } else if (targetProp && targetProp.set && (targetProp.copy || targetProp instanceof Layers)) { 1860 if (Array.isArray(value)) { 1861 if (targetProp.fromArray) targetProp.fromArray(value); 1862 else targetProp.set(...value); 1863 } else if (targetProp.copy && value && value.constructor && // Some environments may break strict identity checks by duplicating versions of three.js. 1864 // Loosen to unminified names, ignoring descendents. 1865 // https://github.com/pmndrs/react-three-fiber/issues/2856
1866 // TODO: fix upstream and remove in v9 1867 targetProp.constructor === value.constructor) { 1868 targetProp.copy(value); 1869 } else if (value !== void 0) { 1870 var _targetProp; 1871 const isColor = (_targetProp = targetProp) == null ? void 0 : _targetProp.isColor; 1872 if (!isColor && targetProp.setScalar) targetProp.setScalar(value); 1873 else if (targetProp instanceof Layers && value instanceof Layers) targetProp.mask = value.mask; 1874 else targetProp.set(value); 1875 if (!getColorManagement() && rootState && !rootState.linear && isColor) targetProp.convertSRGBToLinear(); 1876 } 1877 } else { 1878 var _currentInstance$key; 1879 currentInstance[key] = value; 1880 if ((_currentInstance$key = currentInstance[key]) != null && _currentInstance$key.isTexture && // sRGB textures must be RGBA8 since r137 https://github.com/mrdoob/three.js/pull/23129 1881 currentInstance[key].format === RGBAFormat && currentInstance[key].type === UnsignedByteType && rootState) { 1882 const texture = currentInstance[key]; 1883 if (hasColorSpace(texture) && hasColorSpace(rootState.gl)) texture.colorSpace = rootState.gl.outputColorSpace; 1884 else texture.encoding = rootState.gl.outputEncoding; 1885 } 1886 } 1887 invalidateInstance(instance); 1888 } 1889 if (localState && localState.parent && instance.raycast && prevHandlers !== localState.eventCount) { 1890 const internal = findInitialRoot(instance).getState().internal; 1891 const index = internal.interaction.indexOf(instance); 1892 if (index > -1) internal.interaction.splice(index, 1); 1893 if (localState.eventCount) internal.interaction.push(instance); 1894 } 1895 const isCircular = changes.length === 1 && changes[0][0] === "onUpdate"; 1896 if (!isCircular && changes.length && (_instance$__r3f2 = instance.__r3f) != null && _instance$__r3f2.parent) updateInstance(instance); 1897 return instance; 1898}
1899function invalidateInstance(instance) { 1900 var _instance$__r3f3, _instance$__r3f3$root; 1901 const state = (_instance$__r3f3 = instance.__r3f) == null ? void 0 : (_instance$__r3f3$root = _instance$__r3f3.root) == null ? void 0 : _instance$__r3f3$root.getState == null ? void 0 : _instance$__r3f3$root.getState(); 1902 if (state && state.internal.frames === 0) state.invalidate(); 1903} 1904function updateInstance(instance) { 1905 instance.onUpdate == null ? void 0 : instance.onUpdate(instance); 1906} 1907function updateCamera(camera, size) { 1908 if (!camera.manual) { 1909 if (isOrthographicCamera(camera)) { 1910 camera.left = size.width / -2; 1911 camera.right = size.width / 2; 1912 camera.top = size.height / 2; 1913 camera.bottom = size.height / -2; 1914 } else { 1915 camera.aspect = size.width / size.height; 1916 } 1917 camera.updateProjectionMatrix(); 1918 camera.updateMatrixWorld(); 1919 } 1920} 1921function makeId(event) { 1922 return (event.eventObject || event.object).uuid + "/" + event.index + event.instanceId; 1923} 1924function getEventPriority() { 1925 var _globalScope$event; 1926 const globalScope = typeof self !== "undefined" && self || typeof window !== "undefined" && window; 1927 if (!globalScope) return constantsExports.DefaultEventPriority; 1928 const name = (_globalScope$event = globalScope.event) == null ? void 0 : _globalScope$event.type; 1929 switch (name) { 1930 case "click": 1931 case "contextmenu": 1932 case "dblclick": 1933 case "pointercancel": 1934 case "pointerdown": 1935 case "pointerup": 1936 return constantsExports.DiscreteEventPriority; 1937 case "pointermove": 1938 case "pointerout": 1939 case "pointerover": 1940 case "pointerenter": 1941 case "pointerleave": 1942 case "wheel": 1943 return constantsExports.ContinuousEventPriority; 1944 default: 1945 return constantsExports.DefaultEventPriority; 1946 } 1947} 1948function releaseInternalPointerCapture(capturedMap, obj, captures, pointerId) { 1949 const captureData = captures.get(obj); 1950 if (captureData) { 1951 captures.delete(obj); 1952 if (captures.size === 0) { 1953 capturedMap.delete(pointerId); 1954 captureData.target.releasePointerCapture(pointerId); 1955 } 1956 } 1957} 1958function removeInteractivity(store, object) { 1959 const { 1960 internal 1961 } = store.getState(); 1962 internal.interaction = internal.interaction.filter((o) => o !== object); 1963 internal.initialHits = internal.initialHits.filter((o) => o !== object); 1964 internal.hovered.forEach((value, key) => { 1965 if (value.eventObject === object || value.object === object) { 1966 internal.hovered.delete(key); 1967 } 1968 }); 1969 internal.capturedMap.forEach((captures, pointerId) => { 1970 releaseInternalPointerCapture(internal.capturedMap, object, captures, pointerId); 1971 }); 1972} 1973function createEvents(store) { 1974 function calculateDistance(event) { 1975 const { 1976 internal 1977 } = store.getState(); 1978 const dx = event.offsetX - internal.initialClick[0]; 1979 const dy = event.offsetY - internal.initialClick[1]; 1980 return Math.round(Math.sqrt(dx * dx + dy * dy)); 1981 } 1982 function filterPointerEvents(objects) { 1983 return objects.filter((obj) => ["Move", "Over", "Enter", "Out", "Leave"].some((name) => { 1984 var _r3f; 1985 return (_r3f = obj.__r3f) == null ? void 0 : _r3f.handlers["onPointer" + name]; 1986 })); 1987 } 1988 function intersect(event, filter) { 1989 const state = store.getState(); 1990 const duplicates = /* @__PURE__ */ new Set(); 1991 const intersections = []; 1992 const eventsObjects = filter ? filter(state.internal.interaction) : state.internal.interaction; 1993 for (let i2 = 0; i2 < eventsObjects.length; i2++) { 1994 const state2 = getRootState(eventsObjects[i2]); 1995 if (state2) { 1996 state2.raycaster.camera = void 0; 1997 } 1998 } 1999 if (!state.previousRoot) { 2000 state.events.compute == null ? void 0 : state.events.compute(event, state); 2001 } 2002 function handleRaycast(obj) { 2003 const state2 = getRootState(obj); 2004 if (!state2 || !state2.events.enabled || state2.raycaster.camera === null) return []; 2005 if (state2.raycaster.camera === void 0) { 2006 var _state$previousRoot; 2007 state2.events.compute == null ? void 0 : state2.events.compute(event, state2, (_state$previousRoot = state2.previousRoot) == null ? void 0 : _state$previousRoot.getState()); 2008 if (state2.raycaster.camera === void 0) state2.raycaster.camera = null; 2009 } 2010 return state2.raycaster.camera ? state2.raycaster.intersectObject(obj, true) : []; 2011 } 2012 let hits = eventsObjects.flatMap(handleRaycast).sort((a, b) => { 2013 const aState = getRootState(a.object); 2014 const bState = getRootState(b.object); 2015 if (!aState || !bState) return a.distance - b.distance; 2016 return bState.events.priority - aState.events.priority || a.distance - b.distance; 2017 }).filter((item) => { 2018 const id = makeId(item); 2019 if (duplicates.has(id)) return false;
2020 duplicates.add(id); 2021 return true; 2022 }); 2023 if (state.events.filter) hits = state.events.filter(hits, state); 2024 for (const hit of hits) { 2025 let eventObject = hit.object; 2026 while (eventObject) { 2027 var _r3f2; 2028 if ((_r3f2 = eventObject.__r3f) != null && _r3f2.eventCount) intersections.push({ 2029 ...hit, 2030 eventObject 2031 }); 2032 eventObject = eventObject.parent; 2033 } 2034 } 2035 if ("pointerId" in event && state.internal.capturedMap.has(event.pointerId)) { 2036 for (let captureData of state.internal.capturedMap.get(event.pointerId).values()) { 2037 if (!duplicates.has(makeId(captureData.intersection))) intersections.push(captureData.intersection); 2038 } 2039 } 2040 return intersections; 2041 } 2042 function handleIntersects(intersections, event, delta, callback) { 2043 const rootState = store.getState(); 2044 if (intersections.length) { 2045 const localState = { 2046 stopped: false 2047 }; 2048 for (const hit of intersections) { 2049 const state = getRootState(hit.object) || rootState; 2050 const { 2051 raycaster, 2052 pointer, 2053 camera, 2054 internal 2055 } = state; 2056 const unprojectedPoint = new Vector3(pointer.x, pointer.y, 0).unproject(camera); 2057 const hasPointerCapture = (id) => { 2058 var _internal$capturedMap, _internal$capturedMap2; 2059 return (_internal$capturedMap = (_internal$capturedMap2 = internal.capturedMap.get(id)) == null ? void 0 : _internal$capturedMap2.has(hit.eventObject)) != null ? _internal$capturedMap : false; 2060 }; 2061 const setPointerCapture = (id) => { 2062 const captureData = { 2063 intersection: hit, 2064 target: event.target 2065 }; 2066 if (internal.capturedMap.has(id)) { 2067 internal.capturedMap.get(id).set(hit.eventObject, captureData); 2068 } else {
2069 internal.capturedMap.set(id, /* @__PURE__ */ new Map([[hit.eventObject, captureData]])); 2070 } 2071 event.target.setPointerCapture(id); 2072 }; 2073 const releasePointerCapture = (id) => { 2074 const captures = internal.capturedMap.get(id); 2075 if (captures) { 2076 releaseInternalPointerCapture(internal.capturedMap, hit.eventObject, captures, id); 2077 } 2078 }; 2079 let extractEventProps = {}; 2080 for (let prop in event) { 2081 let property = event[prop]; 2082 if (typeof property !== "function") extractEventProps[prop] = property; 2083 } 2084 let raycastEvent = { 2085 ...hit, 2086 ...extractEventProps, 2087 pointer, 2088 intersections, 2089 stopped: localState.stopped, 2090 delta, 2091 unprojectedPoint, 2092 ray: raycaster.ray, 2093 camera, 2094 // Hijack stopPropagation, which just sets a flag 2095 stopPropagation() { 2096 const capturesForPointer = "pointerId" in event && internal.capturedMap.get(event.pointerId); 2097 if ( 2098 // ...if this pointer hasn't been captured 2099 !capturesForPointer || // ... or if the hit object is capturing the pointer 2100 capturesForPointer.has(hit.eventObject) 2101 ) { 2102 raycastEvent.stopped = localState.stopped = true; 2103 if (internal.hovered.size && Array.from(internal.hovered.values()).find((i2) => i2.eventObject === hit.eventObject)) { 2104 const higher = intersections.slice(0, intersections.indexOf(hit)); 2105 cancelPointer([...higher, hit]); 2106 } 2107 } 2108 }, 2109 // there should be a distinction between target and currentTarget 2110 target: { 2111 hasPointerCapture, 2112 setPointerCapture, 2113 releasePointerCapture 2114 }, 2115 currentTarget: { 2116 hasPointerCapture, 2117 setPointerCapture, 2118 releasePointerCapture 2119 }, 2120 nativeEvent: event 2121 }; 2122 callback(raycastEvent); 2123 if (localState.stopped === true) break; 2124 } 2125 } 2126 return intersections; 2127 } 2128 function cancelPointer(intersections) { 2129 const { 2130 internal 2131 } = store.getState(); 2132 for (const hoveredObj of internal.hovered.values()) { 2133 if (!intersections.length || !intersections.find((hit) => hit.object === hoveredObj.object && hit.index === hoveredObj.index && hit.instanceId === hoveredObj.instanceId)) { 2134 const eventObject = hoveredObj.eventObject; 2135 const instance = eventObject.__r3f; 2136 const handlers = instance == null ? void 0 : instance.handlers; 2137 internal.hovered.delete(makeId(hoveredObj)); 2138 if (instance != null && instance.eventCount) { 2139 const data = { 2140 ...hoveredObj, 2141 intersections 2142 }; 2143 handlers.onPointerOut == null ? void 0 : handlers.onPointerOut(data); 2144 handlers.onPointerLeave == null ? void 0 : handlers.onPointerLeave(data); 2145 } 2146 } 2147 } 2148 } 2149 function pointerMissed(event, objects) { 2150 for (let i2 = 0; i2 < objects.length; i2++) { 2151 const instance = objects[i2].__r3f; 2152 instance == null ? void 0 : instance.handlers.onPointerMissed == null ? void 0 : instance.handlers.onPointerMissed(event); 2153 } 2154 } 2155 function handlePointer(name) { 2156 switch (name) { 2157 case "onPointerLeave": 2158 case "onPointerCancel": 2159 return () => cancelPointer([]); 2160 case "onLostPointerCapture": 2161 return (event) => { 2162 const { 2163 internal 2164 } = store.getState(); 2165 if ("pointerId" in event && internal.capturedMap.has(event.pointerId)) { 2166 requestAnimationFrame(() => { 2167 if (internal.capturedMap.has(event.pointerId)) { 2168 internal.capturedMap.delete(event.pointerId); 2169 cancelPointer([]); 2170 } 2171 }); 2172 } 2173 }; 2174 } 2175 return function handleEvent(event) { 2176 const { 2177 onPointerMissed, 2178 internal 2179 } = store.getState(); 2180 internal.lastEvent.current = event; 2181 const isPointerMove = name === "onPointerMove"; 2182 const isClickEvent = name === "onClick" || name === "onContextMenu" || name === "onDoubleClick"; 2183 const filter = isPointerMove ? filterPointerEvents : void 0; 2184 const hits = intersect(event, filter); 2185 const delta = isClickEvent ? calculateDistance(event) : 0; 2186 if (name === "onPointerDown") { 2187 internal.initialClick = [event.offsetX, event.offsetY]; 2188 internal.initialHits = hits.map((hit) => hit.eventObject); 2189 } 2190 if (isClickEvent && !hits.length) { 2191 if (delta <= 2) { 2192 pointerMissed(event, internal.interaction); 2193 if (onPointerMissed) onPointerMissed(event); 2194 } 2195 } 2196 if (isPointerMove) cancelPointer(hits); 2197 function onIntersect(data) { 2198 const eventObject = data.eventObject; 2199 const instance = eventObject.__r3f; 2200 const handlers = instance == null ? void 0 : instance.handlers; 2201 if (!(instance != null && instance.eventCount)) return; 2202 if (isPointerMove) { 2203 if (handlers.onPointerOver || handlers.onPointerEnter || handlers.onPointerOut || handlers.onPointerLeave) { 2204 const id = makeId(data); 2205 const hoveredItem = internal.hovered.get(id); 2206 if (!hoveredItem) { 2207 internal.hovered.set(id, data); 2208 handlers.onPointerOver == null ? void 0 : handlers.onPointerOver(data); 2209 handlers.onPointerEnter == null ? void 0 : handlers.onPointerEnter(data); 2210 } else if (hoveredItem.stopped) { 2211 data.stopPropagation(); 2212 } 2213 } 2214 handlers.onPointerMove == null ? void 0 : handlers.onPointerMove(data); 2215 } else { 2216 const handler = handlers[name]; 2217 if (handler) { 2218 if (!isClickEvent || internal.initialHits.includes(eventObject)) { 2219 pointerMissed(event, internal.interaction.filter((object) => !internal.initialHits.includes(object))); 2220 handler(data); 2221 } 2222 } else { 2223 if (isClickEvent && internal.initialHits.includes(eventObject)) { 2224 pointerMissed(event, internal.interaction.filter((object) => !internal.initialHits.includes(object))); 2225 } 2226 } 2227 } 2228 } 2229 handleIntersects(hits, event, delta, onIntersect); 2230 }; 2231 } 2232 return { 2233 handlePointer 2234 }; 2235} 2236const isRenderer = (def) => !!(def != null && def.render); 2237const context = /* @__PURE__ */ reactExports.createContext(null); 2238const createStore = (invalidate2, advance2) => { 2239 const rootState = create((set, get) => { 2240 const position = new Vector3(); 2241 const defaultTarget = new Vector3(); 2242 const tempTarget = new Vector3(); 2243 function getCurrentViewport(camera = get().camera, target = defaultTarget, size = get().size) { 2244 const { 2245 width, 2246 height, 2247 top, 2248 left 2249 } = size; 2250 const aspect = width / height; 2251 if (target.isVector3) tempTarget.copy(target); 2252 else tempTarget.set(...target); 2253 const distance = camera.getWorldPosition(position).distanceTo(tempTarget); 2254 if (isOrthographicCamera(camera)) { 2255 return { 2256 width: width / camera.zoom, 2257 height: height / camera.zoom, 2258 top, 2259 left, 2260 factor: 1, 2261 distance, 2262 aspect 2263 }; 2264 } else { 2265 const fov = camera.fov * Math.PI / 180; 2266 const h = 2 * Math.tan(fov / 2) * distance; 2267 const w = h * (width / height); 2268 return { 2269 width: w, 2270 height: h, 2271 top, 2272 left, 2273 factor: width / w, 2274 distance, 2275 aspect 2276 }; 2277 } 2278 } 2279 let performanceTimeout = void 0; 2280 const setPerformanceCurrent = (current) => set((state2) => ({ 2281 performance: { 2282 ...state2.performance, 2283 current 2284 } 2285 })); 2286 const pointer = new Vector2(); 2287 const rootState2 = { 2288 set, 2289 get, 2290 // Mock objects that have to be configured 2291 gl: null, 2292 camera: null, 2293 raycaster: null, 2294 events: { 2295 priority: 1, 2296 enabled: true, 2297 connected: false 2298 }, 2299 xr: null, 2300 scene: null, 2301 invalidate: (frames = 1) => invalidate2(get(), frames), 2302 advance: (timestamp, runGlobalEffects) => advance2(timestamp, runGlobalEffects, get()),
2303 legacy: false, 2304 linear: false, 2305 flat: false, 2306 controls: null, 2307 clock: new Clock(), 2308 pointer, 2309 mouse: pointer, 2310 frameloop: "always", 2311 onPointerMissed: void 0, 2312 performance: { 2313 current: 1, 2314 min: 0.5, 2315 max: 1, 2316 debounce: 200, 2317 regress: () => { 2318 const state2 = get(); 2319 if (performanceTimeout) clearTimeout(performanceTimeout); 2320 if (state2.performance.current !== state2.performance.min) setPerformanceCurrent(state2.performance.min); 2321 performanceTimeout = setTimeout(() => setPerformanceCurrent(get().performance.max), state2.performance.debounce); 2322 } 2323 }, 2324 size: { 2325 width: 0, 2326 height: 0, 2327 top: 0, 2328 left: 0, 2329 updateStyle: false 2330 }, 2331 viewport: { 2332 initialDpr: 0, 2333 dpr: 0, 2334 width: 0, 2335 height: 0, 2336 top: 0, 2337 left: 0, 2338 aspect: 0, 2339 distance: 0, 2340 factor: 0, 2341 getCurrentViewport 2342 }, 2343 setEvents: (events) => set((state2) => ({ 2344 ...state2, 2345 events: { 2346 ...state2.events, 2347 ...events 2348 } 2349 })), 2350 setSize: (width, height, updateStyle, top, left) => { 2351 const camera = get().camera; 2352 const size = { 2353 width, 2354 height, 2355 top: top || 0, 2356 left: left || 0, 2357 updateStyle 2358 }; 2359 set((state2) => ({ 2360 size, 2361 viewport: { 2362 ...state2.viewport, 2363 ...getCurrentViewport(camera, defaultTarget, size) 2364 } 2365 })); 2366 }, 2367 setDpr: (dpr) => set((state2) => { 2368 const resolved = calculateDpr(dpr); 2369 return { 2370 viewport: { 2371 ...state2.viewport, 2372 dpr: resolved, 2373 initialDpr: state2.viewport.initialDpr || resolved 2374 } 2375 }; 2376 }), 2377 setFrameloop: (frameloop = "always") => { 2378 const clock = get().clock; 2379 clock.stop(); 2380 clock.elapsedTime = 0; 2381 if (frameloop !== "never") { 2382 clock.start(); 2383 clock.elapsedTime = 0; 2384 } 2385 set(() => ({ 2386 frameloop 2387 })); 2388 }, 2389 previousRoot: void 0, 2390 internal: { 2391 active: false, 2392 priority: 0, 2393 frames: 0, 2394 lastEvent: /* @__PURE__ */ reactExports.createRef(), 2395 interaction: [], 2396 hovered: /* @__PURE__ */ new Map(), 2397 subscribers: [], 2398 initialClick: [0, 0], 2399 initialHits: [], 2400 capturedMap: /* @__PURE__ */ new Map(), 2401 subscribe: (ref, priority, store) => { 2402 const internal = get().internal; 2403 internal.priority = internal.priority + (priority > 0 ? 1 : 0); 2404 internal.subscribers.push({ 2405 ref, 2406 priority, 2407 store 2408 }); 2409 internal.subscribers = internal.subscribers.sort((a, b) => a.priority - b.priority); 2410 return () => { 2411 const internal2 = get().internal; 2412 if (internal2 != null && internal2.subscribers) { 2413 internal2.priority = internal2.priority - (priority > 0 ? 1 : 0); 2414 internal2.subscribers = internal2.subscribers.filter((s) => s.ref !== ref); 2415 } 2416 }; 2417 } 2418 } 2419 }; 2420 return rootState2; 2421 }); 2422 const state = rootState.getState(); 2423 let oldSize = state.size; 2424 let oldDpr = state.viewport.dpr; 2425 let oldCamera = state.camera; 2426 rootState.subscribe(() => { 2427 const { 2428 camera, 2429 size, 2430 viewport, 2431 gl, 2432 set 2433 } = rootState.getState(); 2434 if (size.width !== oldSize.width || size.height !== oldSize.height || viewport.dpr !== oldDpr) { 2435 var _size$updateStyle; 2436 oldSize = size; 2437 oldDpr = viewport.dpr; 2438 updateCamera(camera, size); 2439 gl.setPixelRatio(viewport.dpr); 2440 const updateStyle = (_size$updateStyle = size.updateStyle) != null ? _size$updateStyle : typeof HTMLCanvasElement !== "undefined" && gl.domElement instanceof HTMLCanvasElement; 2441 gl.setSize(size.width, size.height, updateStyle); 2442 } 2443 if (camera !== oldCamera) { 2444 oldCamera = camera; 2445 set((state2) => ({ 2446 viewport: { 2447 ...state2.viewport, 2448 ...state2.viewport.getCurrentViewport(camera) 2449 } 2450 })); 2451 } 2452 }); 2453 rootState.subscribe((state2) => invalidate2(state2)); 2454 return rootState; 2455}; 2456let i; 2457let globalEffects = /* @__PURE__ */ new Set(); 2458let globalAfterEffects = /* @__PURE__ */ new Set(); 2459let globalTailEffects = /* @__PURE__ */ new Set(); 2460function run(effects, timestamp) { 2461 if (!effects.size) return; 2462 for (const { 2463 callback 2464 } of effects.values()) { 2465 callback(timestamp); 2466 } 2467} 2468function flushGlobalEffects(type, timestamp) { 2469 switch (type) { 2470 case "before": 2471 return run(globalEffects, timestamp); 2472 case "after": 2473 return run(globalAfterEffects, timestamp); 2474 case "tail": 2475 return run(globalTailEffects, timestamp); 2476 } 2477} 2478let subscribers; 2479let subscription; 2480function render$1(timestamp, state, frame) { 2481 let delta = state.clock.getDelta();
2482 if (state.frameloop === "never" && typeof timestamp === "number") { 2483 delta = timestamp - state.clock.elapsedTime; 2484 state.clock.oldTime = state.clock.elapsedTime; 2485 state.clock.elapsedTime = timestamp; 2486 } 2487 subscribers = state.internal.subscribers; 2488 for (i = 0; i < subscribers.length; i++) { 2489 subscription = subscribers[i]; 2490 subscription.ref.current(subscription.store.getState(), delta, frame); 2491 } 2492 if (!state.internal.priority && state.gl.render) state.gl.render(state.scene, state.camera); 2493 state.internal.frames = Math.max(0, state.internal.frames - 1); 2494 return state.frameloop === "always" ? 1 : state.internal.frames; 2495} 2496function createLoop(roots2) { 2497 let running = false; 2498 let useFrameInProgress = false; 2499 let repeat; 2500 let frame; 2501 let state; 2502 function loop(timestamp) { 2503 frame = requestAnimationFrame(loop); 2504 running = true; 2505 repeat = 0; 2506 flushGlobalEffects("before", timestamp); 2507 useFrameInProgress = true; 2508 for (const root of roots2.values()) { 2509 var _state$gl$xr; 2510 state = root.store.getState(); 2511 if (state.internal.active && (state.frameloop === "always" || state.internal.frames > 0) && !((_state$gl$xr = state.gl.xr) != null && _state$gl$xr.isPresenting)) { 2512 repeat += render$1(timestamp, state); 2513 } 2514 } 2515 useFrameInProgress = false; 2516 flushGlobalEffects("after", timestamp); 2517 if (repeat === 0) { 2518 flushGlobalEffects("tail", timestamp); 2519 running = false; 2520 return cancelAnimationFrame(frame); 2521 } 2522 }
2523 function invalidate2(state2, frames = 1) { 2524 var _state$gl$xr2; 2525 if (!state2) return roots2.forEach((root) => invalidate2(root.store.getState(), frames)); 2526 if ((_state$gl$xr2 = state2.gl.xr) != null && _state$gl$xr2.isPresenting || !state2.internal.active || state2.frameloop === "never") return; 2527 if (frames > 1) { 2528 state2.internal.frames = Math.min(60, state2.internal.frames + frames); 2529 } else { 2530 if (useFrameInProgress) { 2531 state2.internal.frames = 2; 2532 } else { 2533 state2.internal.frames = 1; 2534 } 2535 } 2536 if (!running) { 2537 running = true; 2538 requestAnimationFrame(loop); 2539 } 2540 } 2541 function advance2(timestamp, runGlobalEffects = true, state2, frame2) { 2542 if (runGlobalEffects) flushGlobalEffects("before", timestamp); 2543 if (!state2) for (const root of roots2.values()) render$1(timestamp, root.store.getState()); 2544 else render$1(timestamp, state2, frame2); 2545 if (runGlobalEffects) flushGlobalEffects("after", timestamp); 2546 } 2547 return { 2548 loop, 2549 invalidate: invalidate2, 2550 advance: advance2 2551 }; 2552} 2553function useStore() { 2554 const store = reactExports.useContext(context); 2555 if (!store) throw new Error("R3F: Hooks can only be used within the Canvas component!"); 2556 return store; 2557} 2558function useThree(selector = (state) => state, equalityFn) { 2559 return useStore()(selector, equalityFn); 2560} 2561function useFrame(callback, renderPriority = 0) { 2562 const store = useStore(); 2563 const subscribe = store.getState().internal.subscribe; 2564 const ref = useMutableCallback(callback); 2565 useIsomorphicLayoutEffect(() => subscribe(ref, renderPriority, store), [renderPriority, subscribe, store]); 2566 return null; 2567} 2568const roots = /* @__PURE__ */ new Map(); 2569const { 2570 invalidate, 2571 advance 2572} = createLoop(roots); 2573const { 2574 reconciler, 2575 applyProps 2576} = createRenderer(roots, getEventPriority); 2577const shallowLoose = { 2578 objects: "shallow", 2579 strict: false 2580}; 2581const createRendererInstance = (gl, canvas) => { 2582 const customRenderer = typeof gl === "function" ? gl(canvas) : gl; 2583 if (isRenderer(customRenderer)) return customRenderer; 2584 else return new WebGLRenderer({ 2585 powerPreference: "high-performance", 2586 canvas, 2587 antialias: true, 2588 alpha: true, 2589 ...gl 2590 }); 2591}; 2592function computeInitialSize(canvas, defaultSize) { 2593 const defaultStyle = typeof HTMLCanvasElement !== "undefined" && canvas instanceof HTMLCanvasElement; 2594 if (defaultSize) { 2595 const { 2596 width, 2597 height, 2598 top, 2599 left, 2600 updateStyle = defaultStyle 2601 } = defaultSize; 2602 return { 2603 width, 2604 height, 2605 top, 2606 left, 2607 updateStyle 2608 }; 2609 } else if (typeof HTMLCanvasElement !== "undefined" && canvas instanceof HTMLCanvasElement && canvas.parentElement) { 2610 const { 2611 width, 2612 height, 2613 top, 2614 left 2615 } = canvas.parentElement.getBoundingClientRect(); 2616 return { 2617 width, 2618 height, 2619 top, 2620 left, 2621 updateStyle: defaultStyle 2622 }; 2623 } else if (typeof OffscreenCanvas !== "undefined" && canvas instanceof OffscreenCanvas) { 2624 return { 2625 width: canvas.width, 2626 height: canvas.height, 2627 top: 0, 2628 left: 0, 2629 updateStyle: defaultStyle 2630 }; 2631 } 2632 return { 2633 width: 0, 2634 height: 0, 2635 top: 0, 2636 left: 0 2637 }; 2638} 2639function createRoot(canvas) { 2640 const prevRoot = roots.get(canvas); 2641 const prevFiber = prevRoot == null ? void 0 : prevRoot.fiber; 2642 const prevStore = prevRoot == null ? void 0 : prevRoot.store; 2643 if (prevRoot) console.warn("R3F.createRoot should only be called once!"); 2644 const logRecoverableError = typeof reportError === "function" ? ( 2645 // In modern browsers, reportError will dispatch an error event, 2646 // emulating an uncaught JavaScript error. 2647 reportError 2648 ) : ( 2649 // In older browsers and test environments, fallback to console.error. 2650 console.error 2651 ); 2652 const store = prevStore || createStore(invalidate, advance); 2653 const fiber = prevFiber || reconciler.createContainer(store, constantsExports.ConcurrentRoot, null, false, null, "", logRecoverableError, null); 2654 if (!prevRoot) roots.set(canvas, { 2655 fiber, 2656 store 2657 }); 2658 let onCreated; 2659 let configured = false;
2660 let lastCamera; 2661 return { 2662 configure(props = {}) { 2663 let { 2664 gl: glConfig, 2665 size: propsSize, 2666 scene: sceneOptions, 2667 events, 2668 onCreated: onCreatedCallback, 2669 shadows = false, 2670 linear = false, 2671 flat = false, 2672 legacy = false, 2673 orthographic = false, 2674 frameloop = "always", 2675 dpr = [1, 2], 2676 performance: performance2, 2677 raycaster: raycastOptions, 2678 camera: cameraOptions, 2679 onPointerMissed 2680 } = props; 2681 let state = store.getState(); 2682 let gl = state.gl; 2683 if (!state.gl) state.set({ 2684 gl: gl = createRendererInstance(glConfig, canvas) 2685 }); 2686 let raycaster = state.raycaster; 2687 if (!raycaster) state.set({ 2688 raycaster: raycaster = new Raycaster() 2689 }); 2690 const { 2691 params, 2692 ...options 2693 } = raycastOptions || {}; 2694 if (!is.equ(options, raycaster, shallowLoose)) applyProps(raycaster, { 2695 ...options 2696 }); 2697 if (!is.equ(params, raycaster.params, shallowLoose)) applyProps(raycaster, { 2698 params: { 2699 ...raycaster.params, 2700 ...params 2701 } 2702 }); 2703 if (!state.camera || state.camera === lastCamera && !is.equ(lastCamera, cameraOptions, shallowLoose)) { 2704 lastCamera = cameraOptions; 2705 const isCamera = cameraOptions instanceof Camera; 2706 const camera = isCamera ? cameraOptions : orthographic ? new OrthographicCamera(0, 0, 0, 0, 0.1, 1e3) : new PerspectiveCamera(75, 0, 0.1, 1e3); 2707 if (!isCamera) { 2708 camera.position.z = 5; 2709 if (cameraOptions) { 2710 applyProps(camera, cameraOptions); 2711 if ("aspect" in cameraOptions || "left" in cameraOptions || "right" in cameraOptions || "bottom" in cameraOptions || "top" in cameraOptions) { 2712 camera.manual = true; 2713 camera.updateProjectionMatrix(); 2714 } 2715 } 2716 if (!state.camera && !(cameraOptions != null && cameraOptions.rotation)) camera.lookAt(0, 0, 0); 2717 } 2718 state.set({ 2719 camera 2720 }); 2721 raycaster.camera = camera; 2722 } 2723 if (!state.scene) { 2724 let scene; 2725 if (sceneOptions != null && sceneOptions.isScene) { 2726 scene = sceneOptions; 2727 } else { 2728 scene = new Scene(); 2729 if (sceneOptions) applyProps(scene, sceneOptions); 2730 } 2731 state.set({ 2732 scene: prepare(scene) 2733 }); 2734 } 2735 if (!state.xr) { 2736 var _gl$xr; 2737 const handleXRFrame = (timestamp, frame) => { 2738 const state2 = store.getState(); 2739 if (state2.frameloop === "never") return; 2740 advance(timestamp, true, state2, frame); 2741 }; 2742 const handleSessionChange = () => { 2743 const state2 = store.getState(); 2744 state2.gl.xr.enabled = state2.gl.xr.isPresenting; 2745 state2.gl.xr.setAnimationLoop(state2.gl.xr.isPresenting ? handleXRFrame : null); 2746 if (!state2.gl.xr.isPresenting) invalidate(state2); 2747 }; 2748 const xr = { 2749 connect() { 2750 const gl2 = store.getState().gl; 2751 gl2.xr.addEventListener("sessionstart", handleSessionChange); 2752 gl2.xr.addEventListener("sessionend", handleSessionChange); 2753 }, 2754 disconnect() { 2755 const gl2 = store.getState().gl; 2756 gl2.xr.removeEventListener("sessionstart", handleSessionChange); 2757 gl2.xr.removeEventListener("sessionend", handleSessionChange); 2758 } 2759 }; 2760 if (typeof ((_gl$xr = gl.xr) == null ? void 0 : _gl$xr.addEventListener) === "function") xr.connect(); 2761 state.set({ 2762 xr 2763 }); 2764 } 2765 if (gl.shadowMap) { 2766 const oldEnabled = gl.shadowMap.enabled; 2767 const oldType = gl.shadowMap.type; 2768 gl.shadowMap.enabled = !!shadows; 2769 if (is.boo(shadows)) { 2770 gl.shadowMap.type = PCFSoftShadowMap; 2771 } else if (is.str(shadows)) { 2772 var _types$shadows; 2773 const types = { 2774 basic: BasicShadowMap, 2775 percentage: PCFShadowMap, 2776 soft: PCFSoftShadowMap, 2777 variance: VSMShadowMap 2778 }; 2779 gl.shadowMap.type = (_types$shadows = types[shadows]) != null ? _types$shadows : PCFSoftShadowMap; 2780 } else if (is.obj(shadows)) { 2781 Object.assign(gl.shadowMap, shadows); 2782 } 2783 if (oldEnabled !== gl.shadowMap.enabled || oldType !== gl.shadowMap.type) gl.shadowMap.needsUpdate = true; 2784 } 2785 const ColorManagement = getColorManagement(); 2786 if (ColorManagement) { 2787 if ("enabled" in ColorManagement) ColorManagement.enabled = !legacy; 2788 else if ("legacyMode" in ColorManagement) ColorManagement.legacyMode = legacy; 2789 } 2790 if (!configured) { 2791 const LinearEncoding = 3e3; 2792 const sRGBEncoding = 3001; 2793 applyProps(gl, { 2794 outputEncoding: linear ? LinearEncoding : sRGBEncoding, 2795 toneMapping: flat ? NoToneMapping : ACESFilmicToneMapping 2796 }); 2797 } 2798 if (state.legacy !== legacy) state.set(() => ({ 2799 legacy 2800 })); 2801 if (state.linear !== linear) state.set(() => ({ 2802 linear 2803 })); 2804 if (state.flat !== flat) state.set(() => ({ 2805 flat 2806 })); 2807 if (glConfig && !is.fun(glConfig) && !isRenderer(glConfig) && !is.equ(glConfig, gl, shallowLoose)) applyProps(gl, glConfig); 2808 if (events && !state.events.handlers) state.set({ 2809 events: events(store) 2810 }); 2811 const size = computeInitialSize(canvas, propsSize); 2812 if (!is.equ(size, state.size, shallowLoose)) { 2813 state.setSize(size.width, size.height, size.updateStyle, size.top, size.left); 2814 } 2815 if (dpr && state.viewport.dpr !== calculateDpr(dpr)) state.setDpr(dpr); 2816 if (state.frameloop !== frameloop) state.setFrameloop(frameloop); 2817 if (!state.onPointerMissed) state.set({ 2818 onPointerMissed 2819 }); 2820 if (performance2 && !is.equ(performance2, state.performance, shallowLoose)) state.set((state2) => ({ 2821 performance: { 2822 ...state2.performance, 2823 ...performance2 2824 } 2825 })); 2826 onCreated = onCreatedCallback; 2827 configured = true; 2828 return this; 2829 }, 2830 render(children) { 2831 if (!configured) this.configure(); 2832 reconciler.updateContainer(/* @__PURE__ */ jsxRuntimeExports.jsx(Provider, { 2833 store, 2834 children, 2835 onCreated, 2836 rootElement: canvas 2837 }), fiber, null, () => void 0); 2838 return store; 2839 }, 2840 unmount() { 2841 unmountComponentAtNode(canvas); 2842 } 2843 }; 2844} 2845function Provider({ 2846 store, 2847 children, 2848 onCreated, 2849 rootElement 2850}) { 2851 useIsomorphicLayoutEffect(() => { 2852 const state = store.getState(); 2853 state.set((state2) => ({ 2854 internal: { 2855 ...state2.internal, 2856 active: true 2857 } 2858 })); 2859 if (onCreated) onCreated(state); 2860 if (!store.getState().events.connected) state.events.connect == null ? void 0 : state.events.connect(rootElement); 2861 }, []); 2862 return /* @__PURE__ */ jsxRuntimeExports.jsx(context.Provider, { 2863 value: store, 2864 children 2865 }); 2866} 2867function unmountComponentAtNode(canvas, callback) { 2868 const root = roots.get(canvas); 2869 const fiber = root == null ? void 0 : root.fiber; 2870 if (fiber) { 2871 const state = root == null ? void 0 : root.store.getState(); 2872 if (state) state.internal.active = false;
2873 reconciler.updateContainer(null, fiber, null, () => { 2874 if (state) { 2875 setTimeout(() => { 2876 try { 2877 var _state$gl, _state$gl$renderLists, _state$gl2, _state$gl3; 2878 state.events.disconnect == null ? void 0 : state.events.disconnect(); 2879 (_state$gl = state.gl) == null ? void 0 : (_state$gl$renderLists = _state$gl.renderLists) == null ? void 0 : _state$gl$renderLists.dispose == null ? void 0 : _state$gl$renderLists.dispose(); 2880 (_state$gl2 = state.gl) == null ? void 0 : _state$gl2.forceContextLoss == null ? void 0 : _state$gl2.forceContextLoss(); 2881 if ((_state$gl3 = state.gl) != null && _state$gl3.xr) state.xr.disconnect(); 2882 dispose(state); 2883 roots.delete(canvas); 2884 if (callback) ; 2885 } catch (e) { 2886 } 2887 }, 500); 2888 } 2889 }); 2890 } 2891} 2892reconciler.injectIntoDevTools({ 2893 bundleType: 0, 2894 rendererPackageName: "@react-three/fiber", 2895 version: reactExports.version 2896}); 2897const DOM_EVENTS = { 2898 onClick: ["click", false], 2899 onContextMenu: ["contextmenu", false], 2900 onDoubleClick: ["dblclick", false], 2901 onWheel: ["wheel", true], 2902 onPointerDown: ["pointerdown", true], 2903 onPointerUp: ["pointerup", true], 2904 onPointerLeave: ["pointerleave", true], 2905 onPointerMove: ["pointermove", true], 2906 onPointerCancel: ["pointercancel", true], 2907 onLostPointerCapture: ["lostpointercapture", true] 2908}; 2909function createPointerEvents(store) { 2910 const { 2911 handlePointer 2912 } = createEvents(store); 2913 return { 2914 priority: 1, 2915 enabled: true, 2916 compute(event, state, previous) { 2917 state.pointer.set(event.offsetX / state.size.width * 2 - 1, -(event.offsetY / state.size.height) * 2 + 1); 2918 state.raycaster.setFromCamera(state.pointer, state.camera); 2919 }, 2920 connected: void 0, 2921 handlers: Object.keys(DOM_EVENTS).reduce((acc, key) => ({ 2922 ...acc, 2923 [key]: handlePointer(key) 2924 }), {}), 2925 update: () => { 2926 var _internal$lastEvent; 2927 const { 2928 events, 2929 internal 2930 } = store.getState(); 2931 if ((_internal$lastEvent = internal.lastEvent) != null && _internal$lastEvent.current && events.handlers) events.handlers.onPointerMove(internal.lastEvent.current); 2932 }, 2933 connect: (target) => { 2934 var _events$handlers; 2935 const { 2936 set, 2937 events 2938 } = store.getState(); 2939 events.disconnect == null ? void 0 : events.disconnect(); 2940 set((state) => ({ 2941 events: { 2942 ...state.events, 2943 connected: target 2944 } 2945 })); 2946 Object.entries((_events$handlers = events.handlers) != null ? _events$handlers : []).forEach(([name, event]) => { 2947 const [eventName, passive] = DOM_EVENTS[name]; 2948 target.addEventListener(eventName, event, { 2949 passive 2950 }); 2951 }); 2952 }, 2953 disconnect: () => { 2954 const { 2955 set, 2956 events 2957 } = store.getState(); 2958 if (events.connected) { 2959 var _events$handlers2; 2960 Object.entries((_events$handlers2 = events.handlers) != null ? _events$handlers2 : []).forEach(([name, event]) => { 2961 if (events && events.connected instanceof HTMLElement) { 2962 const [eventName] = DOM_EVENTS[name]; 2963 events.connected.removeEventListener(eventName, event); 2964 } 2965 }); 2966 set((state) => ({ 2967 events: { 2968 ...state.events, 2969 connected: void 0 2970 } 2971 })); 2972 } 2973 } 2974 }; 2975} 2976const CanvasImpl = /* @__PURE__ */ reactExports.forwardRef(function Canvas({ 2977 children, 2978 fallback, 2979 resize, 2980 style, 2981 gl, 2982 events = createPointerEvents, 2983 eventSource, 2984 eventPrefix, 2985 shadows, 2986 linear, 2987 flat, 2988 legacy, 2989 orthographic, 2990 frameloop, 2991 dpr, 2992 performance: performance2, 2993 raycaster, 2994 camera, 2995 scene, 2996 onPointerMissed, 2997 onCreated, 2998 ...props 2999}, forwardedRef) { 3000 reactExports.useMemo(() => extend(THREE), []); 3001 const Bridge = useContextBridge(); 3002 const [containerRef, containerRect] = j({ 3003 scroll: true, 3004 debounce: { 3005 scroll: 50, 3006 resize: 0 3007 }, 3008 ...resize 3009 }); 3010 const canvasRef = reactExports.useRef(null); 3011 const divRef = reactExports.useRef(null); 3012 reactExports.useImperativeHandle(forwardedRef, () => canvasRef.current); 3013 const handlePointerMissed = useMutableCallback(onPointerMissed); 3014 const [block, setBlock] = reactExports.useState(false); 3015 const [error, setError] = reactExports.useState(false); 3016 if (block) throw block; 3017 if (error) throw error; 3018 const root = reactExports.useRef(null); 3019 useIsomorphicLayoutEffect(() => { 3020 const canvas = canvasRef.current; 3021 if (containerRect.width > 0 && containerRect.height > 0 && canvas) { 3022 if (!root.current) root.current = createRoot(canvas); 3023 root.current.configure({ 3024 gl, 3025 events, 3026 shadows, 3027 linear, 3028 flat, 3029 legacy, 3030 orthographic, 3031 frameloop, 3032 dpr, 3033 performance: performance2, 3034 raycaster, 3035 camera, 3036 scene, 3037 size: containerRect, 3038 // Pass mutable reference to onPointerMissed so it's free to update 3039 onPointerMissed: (...args) => handlePointerMissed.current == null ? void 0 : handlePointerMissed.current(...args), 3040 onCreated: (state) => { 3041 state.events.connect == null ? void 0 : state.events.connect(eventSource ? isRef(eventSource) ? eventSource.current : eventSource : divRef.current); 3042 if (eventPrefix) { 3043 state.setEvents({ 3044 compute: (event, state2) => { 3045 const x = event[eventPrefix + "X"]; 3046 const y = event[eventPrefix + "Y"]; 3047 state2.pointer.set(x / state2.size.width * 2 - 1, -(y / state2.size.height) * 2 + 1); 3048 state2.raycaster.setFromCamera(state2.pointer, state2.camera); 3049 } 3050 }); 3051 } 3052 onCreated == null ? void 0 : onCreated(state); 3053 } 3054 }); 3055 root.current.render(/* @__PURE__ */ jsxRuntimeExports.jsx(Bridge, { 3056 children: /* @__PURE__ */ jsxRuntimeExports.jsx(ErrorBoundary, { 3057 set: setError, 3058 children: /* @__PURE__ */ jsxRuntimeExports.jsx(reactExports.Suspense, { 3059 fallback: /* @__PURE__ */ jsxRuntimeExports.jsx(Block, { 3060 set: setBlock 3061 }), 3062 children: children != null ? children : null 3063 }) 3064 }) 3065 })); 3066 } 3067 }); 3068 reactExports.useEffect(() => { 3069 const canvas = canvasRef.current; 3070 if (canvas) return () => unmountComponentAtNode(canvas); 3071 }, []); 3072 const pointerEvents = eventSource ? "none" : "auto"; 3073 return /* @__PURE__ */ jsxRuntimeExports.jsx("div", { 3074 ref: divRef, 3075 style: { 3076 position: "relative", 3077 width: "100%", 3078 height: "100%", 3079 overflow: "hidden", 3080 pointerEvents, 3081 ...style 3082 }, 3083 ...props, 3084 children: /* @__PURE__ */ jsxRuntimeExports.jsx("div", { 3085 ref: containerRef, 3086 style: { 3087 width: "100%", 3088 height: "100%" 3089 }, 3090 children: /* @__PURE__ */ jsxRuntimeExports.jsx("canvas", { 3091 ref: canvasRef, 3092 style: { 3093 display: "block" 3094 }, 3095 children: fallback 3096 }) 3097 }) 3098 }); 3099}); 3100const Canvas2 = /* @__PURE__ */ reactExports.forwardRef(function CanvasWrapper(props, ref) { 3101 return /* @__PURE__ */ jsxRuntimeExports.jsx(FiberProvider, { 3102 children: /* @__PURE__ */ jsxRuntimeExports.jsx(CanvasImpl, { 3103 ...props, 3104 ref 3105 }) 3106 }); 3107}); 3108function shaderMaterial(uniforms, vertexShader, fragmentShader, onInit) { 3109 const material = class material extends ShaderMaterial { 3110 constructor(parameters = {}) { 3111 const entries = Object.entries(uniforms); 3112 super({ 3113 uniforms: entries.reduce((acc, [name, value]) => { 3114 const uniform = UniformsUtils.clone({ 3115 [name]: { 3116 value 3117 } 3118 }); 3119 return { 3120 ...acc, 3121 ...uniform 3122 }; 3123 }, {}), 3124 vertexShader, 3125 fragmentShader 3126 }); 3127 this.key = "";
3128 entries.forEach(([name]) => Object.defineProperty(this, name, { 3129 get: () => this.uniforms[name].value, 3130 set: (v) => this.uniforms[name].value = v 3131 })); 3132 Object.assign(this, parameters); 3133 } 3134 }; 3135 material.key = MathUtils.generateUUID(); 3136 return material; 3137} 3138const getVersion = () => parseInt(REVISION.replace(/\D+/g, "")); 3139const version = /* @__PURE__ */ getVersion(); 3140const OrbitControls2 = /* @__PURE__ */ reactExports.forwardRef(({ 3141 makeDefault, 3142 camera, 3143 regress, 3144 domElement, 3145 enableDamping = true, 3146 keyEvents = false, 3147 onChange, 3148 onStart, 3149 onEnd, 3150 ...restProps 3151}, ref) => { 3152 const invalidate2 = useThree((state) => state.invalidate); 3153 const defaultCamera = useThree((state) => state.camera); 3154 const gl = useThree((state) => state.gl); 3155 const events = useThree((state) => state.events); 3156 const setEvents = useThree((state) => state.setEvents); 3157 const set = useThree((state) => state.set); 3158 const get = useThree((state) => state.get); 3159 const performance2 = useThree((state) => state.performance); 3160 const explCamera = camera || defaultCamera; 3161 const explDomElement = domElement || events.connected || gl.domElement; 3162 const controls = reactExports.useMemo(() => new OrbitControls$1(explCamera), [explCamera]); 3163 useFrame(() => { 3164 if (controls.enabled) controls.update(); 3165 }, -1); 3166 reactExports.useEffect(() => { 3167 if (keyEvents) { 3168 controls.connect(keyEvents === true ? explDomElement : keyEvents); 3169 } 3170 controls.connect(explDomElement); 3171 return () => void controls.dispose(); 3172 }, [keyEvents, explDomElement, regress, controls, invalidate2]); 3173 reactExports.useEffect(() => { 3174 const callback = (e) => { 3175 invalidate2(); 3176 if (regress) performance2.regress(); 3177 if (onChange) onChange(e); 3178 }; 3179 const onStartCb = (e) => { 3180 if (onStart) onStart(e); 3181 }; 3182 const onEndCb = (e) => { 3183 if (onEnd) onEnd(e); 3184 }; 3185 controls.addEventListener("change", callback); 3186 controls.addEventListener("start", onStartCb); 3187 controls.addEventListener("end", onEndCb); 3188 return () => { 3189 controls.removeEventListener("start", onStartCb); 3190 controls.removeEventListener("end", onEndCb); 3191 controls.removeEventListener("change", callback); 3192 }; 3193 }, [onChange, onStart, onEnd, controls, invalidate2, setEvents]); 3194 reactExports.useEffect(() => { 3195 if (makeDefault) { 3196 const old = get().controls; 3197 set({ 3198 controls 3199 }); 3200 return () => set({ 3201 controls: old 3202 }); 3203 } 3204 }, [makeDefault, controls]); 3205 return /* @__PURE__ */ reactExports.createElement("primitive", _extends({ 3206 ref, 3207 object: controls, 3208 enableDamping 3209 }, restProps)); 3210}); 3211const CameraControls = /* @__PURE__ */ reactExports.forwardRef((props, ref) => { 3212 reactExports.useMemo(() => { 3213 const subsetOfTHREE = { 3214 Box3, 3215 MathUtils: { 3216 clamp: MathUtils.clamp 3217 }, 3218 Matrix4, 3219 Quaternion, 3220 Raycaster, 3221 Sphere, 3222 Spherical, 3223 Vector2, 3224 Vector3, 3225 Vector4 3226 }; 3227 CameraControls$1.install({ 3228 THREE: subsetOfTHREE 3229 }); 3230 extend({ 3231 CameraControlsImpl: CameraControls$1 3232 }); 3233 }, []); 3234 const { 3235 camera, 3236 domElement, 3237 makeDefault, 3238 onStart, 3239 onEnd, 3240 onChange, 3241 regress, 3242 ...restProps 3243 } = props; 3244 const defaultCamera = useThree((state) => state.camera); 3245 const gl = useThree((state) => state.gl); 3246 const invalidate2 = useThree((state) => state.invalidate); 3247 const events = useThree((state) => state.events); 3248 const setEvents = useThree((state) => state.setEvents); 3249 const set = useThree((state) => state.set); 3250 const get = useThree((state) => state.get); 3251 const performance2 = useThree((state) => state.performance); 3252 const explCamera = camera || defaultCamera; 3253 const explDomElement = domElement || events.connected || gl.domElement; 3254 const controls = reactExports.useMemo(() => new CameraControls$1(explCamera), [explCamera]); 3255 useFrame((state, delta) => { 3256 if (controls.enabled) controls.update(delta); 3257 }, -1); 3258 reactExports.useEffect(() => { 3259 controls.connect(explDomElement); 3260 return () => void controls.disconnect(); 3261 }, [explDomElement, controls]); 3262 reactExports.useEffect(() => { 3263 const callback = (e) => { 3264 invalidate2(); 3265 if (regress) performance2.regress(); 3266 if (onChange) onChange(e); 3267 }; 3268 const onStartCb = (e) => { 3269 if (onStart) onStart(e); 3270 }; 3271 const onEndCb = (e) => { 3272 if (onEnd) onEnd(e); 3273 }; 3274 controls.addEventListener("update", callback); 3275 controls.addEventListener("controlstart", onStartCb); 3276 controls.addEventListener("controlend", onEndCb); 3277 controls.addEventListener("control", callback); 3278 controls.addEventListener("transitionstart", callback); 3279 controls.addEventListener("wake", callback); 3280 return () => { 3281 controls.removeEventListener("update", callback); 3282 controls.removeEventListener("controlstart", onStartCb); 3283 controls.removeEventListener("controlend", onEndCb); 3284 controls.removeEventListener("control", callback); 3285 controls.removeEventListener("transitionstart", callback); 3286 controls.removeEventListener("wake", callback); 3287 }; 3288 }, [controls, onStart, onEnd, invalidate2, setEvents, regress, onChange]); 3289 reactExports.useEffect(() => { 3290 if (makeDefault) { 3291 const old = get().controls; 3292 set({ 3293 controls 3294 }); 3295 return () => set({ 3296 controls: old 3297 }); 3298 } 3299 }, [makeDefault, controls]); 3300 return /* @__PURE__ */ reactExports.createElement("primitive", _extends({ 3301 ref, 3302 object: controls 3303 }, restProps)); 3304}); 3305const GridMaterial = /* @__PURE__ */ shaderMaterial( 3306 { 3307 cellSize: 0.5, 3308 sectionSize: 1, 3309 fadeDistance: 100, 3310 fadeStrength: 1, 3311 fadeFrom: 1, 3312 cellThickness: 0.5, 3313 sectionThickness: 1, 3314 cellColor: /* @__PURE__ */ new Color(), 3315 sectionColor: /* @__PURE__ */ new Color(), 3316 infiniteGrid: false,
3317 followCamera: false, 3318 worldCamProjPosition: /* @__PURE__ */ new Vector3(), 3319 worldPlanePosition: /* @__PURE__ */ new Vector3() 3320 }, 3321 /* glsl */ 3322 ` 3323 varying vec3 localPosition; 3324 varying vec4 worldPosition; 3325 3326 uniform vec3 worldCamProjPosition; 3327 uniform vec3 worldPlanePosition; 3328 uniform float fadeDistance; 3329 uniform bool infiniteGrid; 3330 uniform bool followCamera; 3331 3332 void main() { 3333 localPosition = position.xzy; 3334 if (infiniteGrid) localPosition *= 1.0 + fadeDistance; 3335 3336 worldPosition = modelMatrix * vec4(localPosition, 1.0); 3337 if (followCamera) { 3338 worldPosition.xyz += (worldCamProjPosition - worldPlanePosition); 3339 localPosition = (inverse(modelMatrix) * worldPosition).xyz; 3340 } 3341 3342 gl_Position = projectionMatrix * viewMatrix * worldPosition; 3343 } 3344 `, 3345 /* glsl */ 3346 ` 3347 varying vec3 localPosition; 3348 varying vec4 worldPosition; 3349 3350 uniform vec3 worldCamProjPosition; 3351 uniform float cellSize; 3352 uniform float sectionSize; 3353 uniform vec3 cellColor; 3354 uniform vec3 sectionColor; 3355 uniform float fadeDistance; 3356 uniform float fadeStrength; 3357 uniform float fadeFrom; 3358 uniform float cellThickness; 3359 uniform float sectionThickness; 3360 3361 float getGrid(float size, float thickness) { 3362 vec2 r = localPosition.xz / size; 3363 vec2 grid = abs(fract(r - 0.5) - 0.5) / fwidth(r); 3364 float line = min(grid.x, grid.y) + 1.0 - thickness; 3365 return 1.0 - min(line, 1.0); 3366 } 3367 3368 void main() { 3369 float g1 = getGrid(cellSize, cellThickness); 3370 float g2 = getGrid(sectionSize, sectionThickness); 3371 3372 vec3 from = worldCamProjPosition*vec3(fadeFrom); 3373 float dist = distance(from, worldPosition.xyz); 3374 float d = 1.0 - min(dist / fadeDistance, 1.0); 3375 vec3 color = mix(cellColor, sectionColor, min(1.0, sectionThickness * g2)); 3376 3377 gl_FragColor = vec4(color, (g1 + g2) * pow(d, fadeStrength)); 3378 gl_FragColor.a = mix(0.75 * gl_FragColor.a, gl_FragColor.a, g2); 3379 if (gl_FragColor.a <= 0.0) discard; 3380 3381 #include <tonemapping_fragment> 3382 #include <${version >= 154 ? "colorspace_fragment" : "encodings_fragment"}> 3383 } 3384 ` 3385); 3386const Grid = /* @__PURE__ */ reactExports.forwardRef(({ 3387 args, 3388 cellColor = "#000000", 3389 sectionColor = "#2080ff", 3390 cellSize = 0.5, 3391 sectionSize = 1, 3392 followCamera = false, 3393 infiniteGrid = false, 3394 fadeDistance = 100, 3395 fadeStrength = 1, 3396 fadeFrom = 1, 3397 cellThickness = 0.5, 3398 sectionThickness = 1, 3399 side = BackSide, 3400 ...props 3401}, fRef) => { 3402 extend({ 3403 GridMaterial 3404 }); 3405 const ref = reactExports.useRef(null); 3406 reactExports.useImperativeHandle(fRef, () => ref.current, []); 3407 const plane = new Plane(); 3408 const upVector = new Vector3(0, 1, 0); 3409 const zeroVector = new Vector3(0, 0, 0); 3410 useFrame((state) => { 3411 plane.setFromNormalAndCoplanarPoint(upVector, zeroVector).applyMatrix4(ref.current.matrixWorld); 3412 const gridMaterial = ref.current.material; 3413 const worldCamProjPosition = gridMaterial.uniforms.worldCamProjPosition; 3414 const worldPlanePosition = gridMaterial.uniforms.worldPlanePosition; 3415 plane.projectPoint(state.camera.position, worldCamProjPosition.value); 3416 worldPlanePosition.value.set(0, 0, 0).applyMatrix4(ref.current.matrixWorld); 3417 }); 3418 const uniforms1 = { 3419 cellSize, 3420 sectionSize, 3421 cellColor, 3422 sectionColor, 3423 cellThickness, 3424 sectionThickness 3425 }; 3426 const uniforms2 = { 3427 fadeDistance, 3428 fadeStrength, 3429 fadeFrom, 3430 infiniteGrid, 3431 followCamera 3432 }; 3433 return /* @__PURE__ */ reactExports.createElement("mesh", _extends({ 3434 ref, 3435 frustumCulled: false 3436 }
3436, props), /* @__PURE__ */ reactExports.createElement("gridMaterial", _extends({ 3437 transparent: true, 3438 "extensions-derivatives": true, 3439 side 3440 }, uniforms1, uniforms2)), /* @__PURE__ */ reactExports.createElement("planeGeometry", { 3441 args 3442 })); 3443}); 3444export { 3445 Canvas2 as C, 3446 Grid as G, 3447 OrbitControls$1 as O, 3448 __vitePreload as _, 3449 OrbitControls2 as a, 3450 CameraControls as b, 3451 useFrame as u 3452};
Line numbers count LF bytes from the start of the resource, as the search results do. Vendor segments are library code the classifier recognised; they are stored but not indexed. Bytes are shown as Latin1 characters, one per byte.